From a9d001e764a239c33ed60f83e465fbb022ffff42 Mon Sep 17 00:00:00 2001
From: Jake Hillion <jake@hillion.co.uk>
Date: Sat, 12 Dec 2020 10:40:29 +0000
Subject: [PATCH 1/4] Refactored graph generation

- Refactored graph generation
- Added bar graphs and switched most
---
 .gitignore                |    2 +-
 evaluation.ipynb          | 1550 ++++++++++++++++++++++---------------
 graphs/__init__.py        |    2 +
 graphs/graphs.py          |  132 ++++
 graphs/store.py           |   21 +
 runners/runners.py        |   57 +-
 structure/__init__.py     |    7 +-
 structure/environments.py |  116 +++
 structure/generic.py      |  132 ++++
 structure/structure.py    |  356 +--------
 structure/tests.py        |  137 ++++
 11 files changed, 1484 insertions(+), 1028 deletions(-)
 create mode 100644 graphs/__init__.py
 create mode 100644 graphs/graphs.py
 create mode 100644 graphs/store.py
 create mode 100644 structure/environments.py
 create mode 100644 structure/generic.py
 create mode 100644 structure/tests.py

diff --git a/.gitignore b/.gitignore
index 00491ff..e64f433 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-graphs/
+output/
 
 # Created by https://www.toptal.com/developers/gitignore/api/python,intellij+all,dotenv
 # Edit at https://www.toptal.com/developers/gitignore?templates=python,intellij+all,dotenv
diff --git a/evaluation.ipynb b/evaluation.ipynb
index 858fdb9..7b4ae99 100644
--- a/evaluation.ipynb
+++ b/evaluation.ipynb
@@ -2,64 +2,74 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
    "source": [
     "# Project Evaluation\n",
     "\n",
     "This file interfaces with a Proxmox server to automatically generate VM structures and graphs for testing the\n",
     "success criteria of my project."
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
    "source": [
     "## Setup\n",
     "This section sets up the required variables for the Proxmox server."
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 29,
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'BaseEnvironment' from 'structure' (/home/jake/repos/dissertation/3-evaluation/structure/__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mImportError\u001B[0m                               Traceback (most recent call last)",
+      "\u001B[0;32m<ipython-input-29-9f1181ce8d4d>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m      5\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mStandardEnvironment\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mStandardTest\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      6\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mDirectEnvironment\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mDirectTest\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 7\u001B[0;31m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mBaseEnvironment\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m      8\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      9\u001B[0m \u001B[0mget_ipython\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mrun_line_magic\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m'load_ext'\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m'dotenv'\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;31mImportError\u001B[0m: cannot import name 'BaseEnvironment' from 'structure' (/home/jake/repos/dissertation/3-evaluation/structure/__init__.py)"
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import ipaddress\n",
-    "from typing import Dict\n",
     "\n",
     "import runners\n",
-    "from structure import StandardEnvironment, StandardTest, StandardIperfResult\n",
-    "from structure.structure import DirectEnvironment, DirectTest\n",
+    "from structure import StandardEnvironment, StandardTest\n",
+    "from structure import DirectEnvironment, DirectTest\n",
+    "from structure import BaseEnvironment\n",
     "\n",
     "%load_ext dotenv\n",
     "%dotenv"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "## Testing\n",
-    "This section gathers the required data from the different structures for later graphs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Testing\n",
+    "This section gathers the required data from the different structures for later graphs."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
    "outputs": [],
    "source": [
     "runner = runners.ProxmoxRunner(\n",
@@ -82,13 +92,28 @@
     "    'access_key': os.getenv('S3_ACCESS_KEY'),\n",
     "    'secret_key': os.getenv('S3_SECRET_KEY'),\n",
     "    'branch': os.getenv('TARGET_BRANCH'),\n",
-    "}\n",
+    "}"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "from graphs import TestStore\n",
     "\n",
-    "directionInbound: Dict[str, StandardIperfResult] = {}\n",
-    "directionOutbound: Dict[str, StandardIperfResult] = {}\n",
+    "test_store = TestStore()\n",
     "\n",
-    "def run_and_save_test(env: StandardEnvironment, test: StandardTest):\n",
-    "    (directionInbound[test.name()], directionOutbound[test.name()]) = env.test(test)\n",
+    "def run_and_save_test(env: BaseEnvironment, test: StandardTest):\n",
+    "    (inbound, outbound) = env.test(test)\n",
+    "    test_store.save_inbound(test, inbound)\n",
+    "    test_store.save_outbound(test, outbound)\n",
     "\n",
     "def attempt_n_times(foo, n=3):\n",
     "    for i in range(n):\n",
@@ -102,786 +127,1029 @@
     "\n",
     "\n",
     "fast_tests = True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   ],
    "metadata": {
     "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
     "### Direct Server to Server"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 4,
    "outputs": [],
    "source": [
     "def direct_tests():\n",
     "    with DirectEnvironment(runner) as env:\n",
-    "        run_and_save_test(env, DirectTest(1, variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, DirectTest(2, variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, DirectTest(3, variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, DirectTest(4, variation_target=0.4 if fast_tests else 0.2))\n",
+    "        run_and_save_test(env, DirectTest(1, bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, DirectTest(2, bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, DirectTest(3, bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, DirectTest(4, bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(direct_tests)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   ],
    "metadata": {
     "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
     "### Local Portal with 2 Interfaces"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
+   "execution_count": 5,
    "outputs": [],
    "source": [
     "def two_interface_tests():\n",
     "    with StandardEnvironment(2, runner, setup_params) as env:\n",
-    "        run_and_save_test(env, StandardTest([1,1], variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, StandardTest([1,2], variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, StandardTest([2,2], variation_target=0.4 if fast_tests else 0.2))\n",
+    "        run_and_save_test(env, StandardTest([1,1], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, StandardTest([1,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, StandardTest([2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "        run_and_save_test(env, StandardTest(\n",
     "            [2,2],\n",
     "            events={10: (0,1), 15: (0,2)},\n",
     "            duration=30,\n",
-    "            variation_target=0.8 if fast_tests else 0.5,\n",
+    "            interval_variation_target=0.8 if fast_tests else 0.5,\n",
     "        ))\n",
     "\n",
     "attempt_n_times(two_interface_tests)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Local Portal with 3 Interfaces"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Local Portal with 3 Interfaces"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "outputs": [],
    "source": [
     "def three_interface_tests():\n",
     "    with StandardEnvironment(3, runner, setup_params) as env:\n",
-    "        run_and_save_test(env, StandardTest([1,1,1], variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, StandardTest([2,2,2], variation_target=0.4 if fast_tests else 0.2))\n",
+    "        run_and_save_test(env, StandardTest([1,1,1], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, StandardTest([2,2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(three_interface_tests)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Local Portal with 4 Interfaces"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Local Portal with 4 Interfaces"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "outputs": [],
    "source": [
     "def four_interface_tests():\n",
     "    with StandardEnvironment(4, runner, setup_params) as env:\n",
-    "        run_and_save_test(env, StandardTest([1,1,1,1], variation_target=0.4 if fast_tests else 0.2))\n",
-    "        run_and_save_test(env, StandardTest([2,2,2,2], variation_target=0.4 if fast_tests else 0.2))\n",
+    "        run_and_save_test(env, StandardTest([1,1,1,1], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
+    "        run_and_save_test(env, StandardTest([2,2,2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(four_interface_tests)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "## Graphs\n",
-    "This section produces graphs from the collected data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from itertools import cycle\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "def plot_iperf_results(\n",
-    "        series: Dict[str, StandardTest],\n",
-    "        title: str = None,\n",
-    "        direction = 'both',\n",
-    "        error_bars_x=False,\n",
-    "        error_bars_y=True,\n",
-    "        filename=None,\n",
-    "        start_at_zero=True,\n",
-    "):\n",
-    "    if direction == 'both':\n",
-    "        plot_iperf_results(series, title, 'outbound', error_bars_x, error_bars_y, filename, start_at_zero)\n",
-    "        plot_iperf_results(series, title, 'inbound', error_bars_x, error_bars_y, filename, start_at_zero)\n",
-    "        return\n",
-    "\n",
-    "    if filename in ['png', 'eps']:\n",
-    "        filename = 'graphs/{}{}{}{}.{}'.format(\n",
-    "            'I' if direction == 'inbound' else 'O',\n",
-    "            'Ex' if error_bars_x else '',\n",
-    "            'Ey' if error_bars_y else '',\n",
-    "            ''.join(['S{}-{}'.format(i,x.name()) for (i, x) in enumerate(series.values())]),\n",
-    "            filename,\n",
-    "        )\n",
-    "\n",
-    "    series = {\n",
-    "        k: (directionInbound if direction == 'inbound' else directionOutbound)[v.name()] for (k, v) in series.items()\n",
-    "    }\n",
-    "\n",
-    "    cycol = cycle('brgy')\n",
-    "\n",
-    "    fig = plt.figure()\n",
-    "    axes = fig.add_axes([0,0,1,1])\n",
-    "\n",
-    "    if title is not None:\n",
-    "        axes.set_title(title, pad=20.0 if True in [len(x.test.events) > 0 for x in series.values()] else None)\n",
-    "\n",
-    "    axes.set_xlabel('Time (s)')\n",
-    "    axes.set_ylabel('Throughput (Mbps)')\n",
-    "\n",
-    "    for k, v in series.items():\n",
-    "        data = v.summarise()\n",
-    "\n",
-    "        axes.errorbar(\n",
-    "            data.keys(),\n",
-    "            [x/1e6 for x in data.values()],\n",
-    "            xerr=([x[0] for x in v.time_range().values()], [x[1] for x in v.time_range().values()]) if error_bars_x else None,\n",
-    "            yerr=[x*1.5/1e6 for x in v.standard_deviation().values()] if error_bars_y else None,\n",
-    "            capsize=3,\n",
-    "            ecolor='grey',\n",
-    "            color=next(cycol),\n",
-    "            label=k,\n",
-    "        )\n",
-    "\n",
-    "    legend = axes.legend()\n",
-    "\n",
-    "    if start_at_zero:\n",
-    "        axes.set_ylim(bottom=0)\n",
-    "        axes.set_xlim(left=0)\n",
-    "\n",
-    "    if False:\n",
-    "        for k, v in events.items():\n",
-    "            axes.axvline(k, linestyle='--', color='grey')\n",
-    "            axes.annotate(v, (k, 1.02), xycoords=axes.get_xaxis_transform(), ha='center')\n",
-    "\n",
-    "    if fast_tests:\n",
-    "        fig.text(0.95, 0.05, 'Draft', fontsize=50, color='gray', ha='right', va='bottom', alpha=0.5)\n",
-    "\n",
-    "    if filename is not None:\n",
-    "        fig.savefig(filename, bbox_extra_artists=(legend,), bbox_inches='tight', pad_inches=0.3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "if not os.path.exists('graphs/'):\n",
-    "    os.makedirs('graphs/')\n",
-    "\n",
-    "for filename in os.listdir('graphs'):\n",
-    "    file_path = os.path.join('graphs/', filename)\n",
-    "    os.unlink(file_path)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   ],
    "metadata": {
     "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
-    "### Error Bar Evaluation"
-   ]
+    "## Graphs\n",
+    "This section produces graphs from the collected data."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 39,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "from graphs import plot_iperf_results, plot_iperf_results_time\n",
+    "\n",
+    "if not os.path.exists('output/'):\n",
+    "    os.makedirs('output/')\n",
+    "\n",
+    "for filename in os.listdir('output'):\n",
+    "    file_path = os.path.join('output/', filename)\n",
+    "    os.unlink(file_path)"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
-    "plot_iperf_results(\n",
+    "### Error Bar Evaluation"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
+      "output/TIS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results_time(test_store,\n",
     "    {\n",
     "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
     "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
     "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
     "    },\n",
+    "    fast_tests,\n",
     "    error_bars_x=False,\n",
     "    error_bars_y=False,\n",
     "    filename='png',\n",
     ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOExS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
+      "output/TIExS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "plot_iperf_results(\n",
+    "plot_iperf_results_time(test_store,\n",
     "    {\n",
     "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
     "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
     "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
     "    },\n",
+    "    fast_tests,\n",
     "    error_bars_x=True,\n",
     "    error_bars_y=False,\n",
     "    filename='png',\n",
     ")"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOExEyS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
+      "output/TIExEyS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results_time(test_store,\n",
+    "    {\n",
+    "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
+    "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
+    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    error_bars_x=False,\n",
+    "    error_bars_y=True,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
    "source": [
     "### More than 2 connections evaluation"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 45,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
+      "output/OES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '4x1MB Connections\\n(proxied)': StandardTest([1,1,1,1]),\n",
+    "        '3x1MB Connections\\n(proxied)': StandardTest([1,1,1]),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
-    "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 46,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n",
+      "output/OES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '4x2MB Connections\\n(proxied)': StandardTest([2,2,2,2]),\n",
+    "        '3x2MB Connections\\n(proxied)': StandardTest([2,2,2]),\n",
+    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x2MB Connections (proxied)': StandardTest([2,2,2,2]),\n",
-    "        '3x2MB Connections (proxied)': StandardTest([2,2,2]),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
    "source": [
     "### Mixed Performance Evaluation"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 47,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n",
+      "output/OES0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
+    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
+    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x1MB + 1x2MB Connections (proxied)': StandardTest([1,2]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
+   }
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
    "source": [
     "### Eventful Evaluation"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
+   "execution_count": 48,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n",
+      "output/TIEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     }
-   },
-   "outputs": [],
+   ],
    "source": [
-    "plot_iperf_results(\n",
+    "plot_iperf_results_time(test_store,\n",
     "    {\n",
     "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
     "    },\n",
+    "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "markdown",
    "source": [
-    "plot_iperf_results(\n",
+    "### Comparisons to a Direct Connection"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n",
+      "output/OES0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '1x2MB Connection\\n(direct)': DirectTest(2),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
+    "        '1x1MB Connection\\n(direct)': DirectTest(1),\n",
+    "\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n",
+      "output/OES0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '1x4MB Connection\\n(direct)': DirectTest(4),\n",
+    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
+    "        '1x2MB Connection\\n(direct)': DirectTest(2),\n",
+    "\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
+      "output/OES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '4x1MB Connections\\n(proxied)': StandardTest([1,1,1,1]),\n",
+    "        '3x1MB Connections\\n(proxied)': StandardTest([1,1,1]),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/IES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n",
+      "output/OES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results(test_store,\n",
+    "    {\n",
+    "        '4x2MB Connections\\n(proxied)': StandardTest([2,2,2,2]),\n",
+    "        '3x2MB Connections\\n(proxied)': StandardTest([2,2,2]),\n",
+    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Mixed Performance Evaluation"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOEyS0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n",
+      "output/TIEyS0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results_time(test_store,\n",
+    "    {\n",
+    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
+    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Eventful Evaluation"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n",
+      "output/TIEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results_time(test_store,\n",
+    "    {\n",
+    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
+    "    },\n",
+    "    fast_tests,\n",
+    "    filename='png',\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Comparisons to a Direct Connection"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOEyS0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n",
+      "output/TIEyS0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_iperf_results_time(test_store,\n",
     "    {\n",
     "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
     "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
     "        '1x1MB Connection (not proxied)': DirectTest(1),\n",
     "\n",
     "    },\n",
+    "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   ],
    "metadata": {
+    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "output/TOEyS0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n",
+      "output/TIEyS0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "plot_iperf_results(\n",
+    "plot_iperf_results_time(test_store,\n",
     "    {\n",
     "        '1x4MB Connection (not proxied)': DirectTest(4),\n",
     "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
     "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
     "\n",
     "    },\n",
+    "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
-    "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x2MB Connections (proxied)': StandardTest([2,2,2,2]),\n",
-    "        '3x2MB Connections (proxied)': StandardTest([2,2,2]),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Mixed Performance Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x1MB + 1x2MB Connections (proxied)': StandardTest([1,2]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Eventful Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "        '1x1MB Connection (not proxied)': DirectTest(1),\n",
-    "\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '1x4MB Connection (not proxied)': DirectTest(4),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   ],
    "metadata": {
     "collapsed": false,
     "pycharm": {
-     "name": "#%% md\n"
+     "name": "#%%\n"
     }
-   },
-   "source": []
+   }
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
    "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x1MB Connections (proxied)': StandardTest([1,1,1,1]),\n",
-    "        '3x1MB Connections (proxied)': StandardTest([1,1,1]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '4x2MB Connections (proxied)': StandardTest([2,2,2,2]),\n",
-    "        '3x2MB Connections (proxied)': StandardTest([2,2,2]),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
+   "source": [],
    "metadata": {
     "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "### Mixed Performance Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
     "pycharm": {
      "name": "#%%\n"
     }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x1MB + 1x2MB Connections (proxied)': StandardTest([1,2]),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "### Eventful Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "        '1x1MB Connection (not proxied)': DirectTest(1),\n",
-    "\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(\n",
-    "    {\n",
-    "        '1x4MB Connection (not proxied)': DirectTest(4),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "\n",
-    "    },\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": []
+   }
   }
  ],
  "metadata": {
@@ -905,4 +1173,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
+}
\ No newline at end of file
diff --git a/graphs/__init__.py b/graphs/__init__.py
new file mode 100644
index 0000000..2432ed8
--- /dev/null
+++ b/graphs/__init__.py
@@ -0,0 +1,2 @@
+from .store import TestStore
+from .graphs import plot_iperf_results, plot_iperf_results_time
diff --git a/graphs/graphs.py b/graphs/graphs.py
new file mode 100644
index 0000000..7505c41
--- /dev/null
+++ b/graphs/graphs.py
@@ -0,0 +1,132 @@
+from itertools import cycle
+from typing import Dict
+
+from matplotlib import pyplot as plt
+
+from graphs import TestStore
+from structure import StandardTest
+
+
+def plot_iperf_results(
+        store: TestStore,
+        series: Dict[str, StandardTest],
+        fast_tests: bool,
+        title: str = None,
+        direction='both',
+        error_bars=True,
+        filename=None,
+):
+    if direction == 'both':
+        plot_iperf_results(store, series, fast_tests, title, 'inbound', error_bars, filename)
+        plot_iperf_results(store, series, fast_tests, title, 'outbound', error_bars, filename)
+        return
+
+    if filename in ['png', 'eps']:
+        filename = 'output/{}{}{}.{}'.format(
+            'I' if direction == 'inbound' else 'O',
+            'E' if error_bars else '',
+            ''.join(['S{}-{}'.format(i, x.name()) for (i, x) in enumerate(series.values())]),
+            filename,
+        )
+        print(filename)
+
+    series = {
+        k: (store.get_inbound(v) if direction == 'inbound' else store.get_outbound(v))
+        for (k, v) in series.items()
+    }
+
+    fig = plt.figure()
+    axes = fig.add_axes([0, 0, 1, 1])
+
+    if title is not None:
+        axes.set_title(title, pad=20.0 if True in [len(x.test.events) > 0 for x in series.values()] else None)
+
+    axes.set_ylabel('Throughput (Mbps)')
+
+    for k, v in series.items():
+        axes.bar(
+            k,
+            v.bandwidth_mean() / 1e6,
+            yerr=1.5 * v.bandwidth_standard_deviation() / 1e6,
+            width=0.4,
+            capsize=15,
+        )
+
+    if fast_tests:
+        fig.text(0.95, 0.05, 'Draft', fontsize=50, color='gray', ha='right', va='bottom', alpha=0.5)
+
+    if filename is not None:
+        fig.savefig(filename, bbox_inches='tight', pad_inches=0.3)
+
+
+def plot_iperf_results_time(
+        store: TestStore,
+        series: Dict[str, StandardTest],
+        fast_tests: bool,
+        title: str = None,
+        direction='both',
+        error_bars_x=False,
+        error_bars_y=True,
+        filename=None,
+        start_at_zero=True,
+):
+    if direction == 'both':
+        plot_iperf_results_time(store, series, fast_tests, title, 'outbound', error_bars_x, error_bars_y, filename,
+                                start_at_zero)
+        plot_iperf_results_time(store, series, fast_tests, title, 'inbound', error_bars_x, error_bars_y, filename,
+                                start_at_zero)
+        return
+
+    if filename in ['png', 'eps']:
+        filename = 'output/T{}{}{}{}.{}'.format(
+            'I' if direction == 'inbound' else 'O',
+            'Ex' if error_bars_x else '',
+            'Ey' if error_bars_y else '',
+            ''.join(['S{}-{}'.format(i, x.name()) for (i, x) in enumerate(series.values())]),
+            filename,
+        )
+        print(filename)
+
+    series = {
+        k: (store.get_inbound(v) if direction == 'inbound' else store.get_outbound(v))
+        for (k, v) in series.items()
+    }
+
+    cycol = cycle('brgy')
+
+    fig = plt.figure()
+    axes = fig.add_axes([0, 0, 1, 1])
+
+    if title is not None:
+        axes.set_title(title, pad=20.0 if True in [len(x.test.events) > 0 for x in series.values()] else None)
+
+    axes.set_xlabel('Time (s)')
+    axes.set_ylabel('Throughput (Mbps)')
+
+    for k, v in series.items():
+        data = v.interval_means()
+
+        axes.errorbar(
+            data.keys(),
+            [x / 1e6 for x in data.values()],
+            xerr=(
+                [x[0] for x in v.interval_time_ranges().values()],
+                [x[1] for x in v.interval_time_ranges().values()]) if error_bars_x else None,
+            yerr=[x * 1.5 / 1e6 for x in v.interval_standard_deviations().values()] if error_bars_y else None,
+            capsize=3,
+            ecolor='grey',
+            color=next(cycol),
+            label=k,
+        )
+
+    legend = axes.legend()
+
+    if start_at_zero:
+        axes.set_ylim(bottom=0)
+        axes.set_xlim(left=0)
+
+    if fast_tests:
+        fig.text(0.95, 0.05, 'Draft', fontsize=50, color='gray', ha='right', va='bottom', alpha=0.5)
+
+    if filename is not None:
+        fig.savefig(filename, bbox_extra_artists=(legend,), bbox_inches='tight', pad_inches=0.3)
diff --git a/graphs/store.py b/graphs/store.py
new file mode 100644
index 0000000..9e501bd
--- /dev/null
+++ b/graphs/store.py
@@ -0,0 +1,21 @@
+from typing import Dict
+
+from structure import IperfResult, StandardTest
+
+
+class TestStore:
+    def __init__(self):
+        self.inbound: Dict[str, IperfResult] = dict()
+        self.outbound: Dict[str, IperfResult] = dict()
+
+    def save_inbound(self, test: StandardTest, result: IperfResult):
+        self.inbound[test.name()] = result
+
+    def save_outbound(self, test: StandardTest, result: IperfResult):
+        self.outbound[test.name()] = result
+
+    def get_inbound(self, test: StandardTest) -> IperfResult:
+        return self.inbound[test.name()]
+
+    def get_outbound(self, test: StandardTest) -> IperfResult:
+        return self.outbound[test.name()]
diff --git a/runners/runners.py b/runners/runners.py
index 0ed4ecf..460a8f7 100644
--- a/runners/runners.py
+++ b/runners/runners.py
@@ -11,6 +11,7 @@ import proxmoxer
 import paramiko
 
 import structure
+import structure.generic
 
 
 def check_env(*names: str) -> bool:
@@ -21,14 +22,14 @@ def check_env(*names: str) -> bool:
 
 
 def bridge_node_search(
-        first: structure.Bridge,
-        bridge_name_generator: Callable[[structure.Bridge], str],
-        node_id_generator: Callable[[structure.Node], int],
-) -> Tuple[List[structure.Bridge], List[structure.Node]]:
-    bridges: List[structure.Bridge] = []
-    nodes: List[structure.Node] = []
+        first: structure.generic.Bridge,
+        bridge_name_generator: Callable[[structure.generic.Bridge], str],
+        node_id_generator: Callable[[structure.generic.Node], int],
+) -> Tuple[List[structure.generic.Bridge], List[structure.generic.Node]]:
+    bridges: List[structure.generic.Bridge] = []
+    nodes: List[structure.generic.Node] = []
 
-    queue: List[structure.Bridge] = [first]
+    queue: List[structure.generic.Bridge] = [first]
     while len(queue) > 0:
         bridge = queue.pop()
         if bridge.get_name() != '':
@@ -38,7 +39,7 @@ def bridge_node_search(
         bridge.set_name(bridge_name_generator(bridge))
 
         # from this bridge, find all nodes (via all interfaces)
-        reachable_nodes: List[structure.Node] = []
+        reachable_nodes: List[structure.generic.Node] = []
         for interface in bridge.get_interfaces():
             node = interface.get_node()
             if node.get_id() is not None:
@@ -63,7 +64,7 @@ class PrintRunner:
         self._last_bridge: int = 0
         self._last_node_id = 0
 
-    def build(self, bridge: structure.Bridge):
+    def build(self, bridge: structure.generic.Bridge):
         bridges, nodes = bridge_node_search(bridge, lambda _: self.name_bridge(), lambda _: self.id_node())
 
         print(bridges)
@@ -121,10 +122,10 @@ class ProxmoxRunner:
         self._template_id = template_id
         self._initial_vm_id = initial_vm_id
 
-        self._internet_bridge = structure.Bridge()
+        self._internet_bridge = structure.generic.Bridge()
         self._internet_bridge.set_name(internet_bridge)
 
-        self._management_bridge = structure.Bridge()
+        self._management_bridge = structure.generic.Bridge()
         self._management_bridge.set_name(management_bridge)
         self._management_initial_ip = management_initial_ip
         self._management_netmask = management_netmask
@@ -133,7 +134,7 @@ class ProxmoxRunner:
         self._private_key = paramiko.RSAKey.generate(3072)
         self._client = paramiko.SSHClient()
 
-    def build(self, bridge: structure.Bridge):
+    def build(self, bridge: structure.generic.Bridge):
         bridges, nodes = bridge_node_search(bridge, lambda x: self._create_bridge(x), lambda x: self._create_node(x))
 
         self._build_bridges(bridges)
@@ -156,7 +157,7 @@ class ProxmoxRunner:
                 return
         raise TimeoutError
 
-    def _create_bridge(self, bridge: structure.Bridge) -> str:
+    def _create_bridge(self, bridge: structure.generic.Bridge) -> str:
         while True:
             try:
                 self._proxmox.nodes(self._proxmox_node).network.post(
@@ -177,7 +178,7 @@ class ProxmoxRunner:
         self._created_bridges.append(bridge_name)
         return bridge_name
 
-    def _build_bridges(self, bridges: List[structure.Bridge]):
+    def _build_bridges(self, bridges: List[structure.generic.Bridge]):
         network_task = self._proxmox.nodes(self._proxmox_node).network.put()
         self._await_task(network_task)
 
@@ -187,7 +188,7 @@ class ProxmoxRunner:
                 bridge.new_network()
             existing.append(bridge.get_network())
 
-    def _create_node(self, node: structure.Node) -> int:
+    def _create_node(self, node: structure.generic.Node) -> int:
         while True:
             try:
                 clone_task = self._proxmox.nodes(self._proxmox_node).qemu(self._template_id).clone.post(
@@ -207,10 +208,10 @@ class ProxmoxRunner:
         self._created_nodes.append(new_id - 1)
         return new_id - 1
 
-    def _open_ssh(self, node: structure.Node, interface: structure.Interface = None):
+    def _open_ssh(self, node: structure.generic.Node, interface: structure.generic.Interface = None):
         if interface is None:
             for iface in node.get_interfaces():
-                if iface.get_method() == structure.IpMethod.Management:
+                if iface.get_method() == structure.generic.IpMethod.Management:
                     interface = iface
                     break
             if interface is None:
@@ -235,13 +236,13 @@ class ProxmoxRunner:
 
         node.ssh_client = client
 
-    def _close_ssh(self, node: structure.Node):
+    def _close_ssh(self, node: structure.generic.Node):
         node.ssh_client.close()
         del node.ssh_client
 
     def ssh(
             self,
-            node: structure.Node,
+            node: structure.generic.Node,
             command: str,
             error_stderr=False,
             error_stdout=False,
@@ -269,7 +270,7 @@ class ProxmoxRunner:
 
         return exit_status
 
-    def _build_node(self, node: structure.Node):
+    def _build_node(self, node: structure.generic.Node):
         # Step 1: Configure access
         self._proxmox.nodes(self._proxmox_node).qemu(node.get_id()).config.put(
             ciuser='python',
@@ -282,7 +283,7 @@ class ProxmoxRunner:
         # Step 2: connect to Internet bridge with DHCP to install packages
         if node.get_internet_setup() is not None:
             interfaces = node.get_interfaces()
-            internet_interface = structure.Interface(structure.IpMethod.Dhcp4)
+            internet_interface = structure.generic.Interface(structure.generic.IpMethod.Dhcp4)
             internet_interface.set_bridge(self._internet_bridge)
             temp_interfaces = [internet_interface, interfaces[len(interfaces) - 1]]
 
@@ -307,7 +308,7 @@ class ProxmoxRunner:
         self._open_ssh(node)
         node.ssh = (lambda n: lambda *args, **kwargs: self.ssh(n, *args, **kwargs))(node)
 
-    def _setup_node_interfaces(self, node: structure.Node, interfaces: List[structure.Interface] = None):
+    def _setup_node_interfaces(self, node: structure.generic.Node, interfaces: List[structure.generic.Interface] = None):
         if interfaces is None:
             interfaces = node.get_interfaces()
 
@@ -316,20 +317,20 @@ class ProxmoxRunner:
             interface = interfaces[i]
             method = interface.get_method()
 
-            if method == structure.IpMethod.Management:
+            if method == structure.generic.IpMethod.Management:
                 interface.set_bridge(self._management_bridge)
                 addr = self._management_initial_ip + node.get_id() - self._initial_vm_id
 
                 kwargs['ipconfig{}'.format(i)] = 'ip={}/{}'.format(addr, self._management_netmask)
                 interface.set_address(addr)
-            elif method == structure.IpMethod.Auto4 or method == structure.IpMethod.Manual:
+            elif method == structure.generic.IpMethod.Auto4 or method == structure.generic.IpMethod.Manual:
                 # handle manual the same as auto4 so it doesn't get stuck in DHCP
                 bridge = interface.get_bridge()
                 addr = bridge.get_ip_address()
 
                 kwargs['ipconfig{}'.format(i)] = 'ip={}/{}'.format(addr, bridge.netmask)
                 interface.set_address(addr)
-            elif method == structure.IpMethod.Dhcp4:
+            elif method == structure.generic.IpMethod.Dhcp4:
                 kwargs['ipconfig{}'.format(i)] = 'ip=dhcp'
             else:
                 raise RuntimeError('not implemented')
@@ -340,7 +341,7 @@ class ProxmoxRunner:
 
             def interface_set_rate(iface):
                 def new_set_rate(rate: Optional[int]):
-                    structure.Interface.set_rate(iface, rate)
+                    structure.generic.Interface.set_rate(iface, rate)
                     self._update_node_interfaces(node)
 
                 return new_set_rate
@@ -349,7 +350,7 @@ class ProxmoxRunner:
 
         self._proxmox.nodes(self._proxmox_node).qemu(node.get_id()).config.put(**kwargs)
 
-    def _update_node_interfaces(self, node: structure.Node):
+    def _update_node_interfaces(self, node: structure.generic.Node):
         interfaces = node.get_interfaces()
 
         old_config = self._proxmox.nodes(self._proxmox_node).qemu(node.get_id()).config.get()
@@ -368,7 +369,7 @@ class ProxmoxRunner:
 
         self._proxmox.nodes(self._proxmox_node).qemu(node.get_id()).config.put(**new_config)
 
-    def _setup_node(self, node: structure.Node):
+    def _setup_node(self, node: structure.generic.Node):
         if node.get_setup() is not None:
             cmd = node.get_setup()
             self.ssh(node, cmd, error_stdout=True, error_stderr=True)
diff --git a/structure/__init__.py b/structure/__init__.py
index d47d649..04cbf48 100644
--- a/structure/__init__.py
+++ b/structure/__init__.py
@@ -1,6 +1,5 @@
-from .structure import Node
-
-from .structure import IpMethod, Interface, Bridge
+from .generic import IpMethod, Interface, Bridge, Node
 
 from .structure import SpeedTestServer, LocalPortal, RemotePortal
-from .structure import StandardEnvironment, StandardTest, StandardIperfResult
+from .tests import StandardTest, DirectTest, IperfResult
+from .environments import StandardEnvironment, DirectEnvironment, BaseEnvironment
diff --git a/structure/environments.py b/structure/environments.py
new file mode 100644
index 0000000..9d94fb3
--- /dev/null
+++ b/structure/environments.py
@@ -0,0 +1,116 @@
+import threading
+from typing import Tuple, Optional
+
+from structure import Bridge, StandardTest, SpeedTestServer, Node, IperfResult, RemotePortal, Interface, \
+    IpMethod, LocalPortal
+from structure.tests import repeat_until_satisfied
+
+
+class BaseEnvironment:
+    def __init__(self, runner, top_level_bridge: Bridge):
+        self.top_level_bridge = top_level_bridge
+        self._runner = runner
+
+    def __enter__(self):
+        try:
+            self._runner.build(self.top_level_bridge)
+        except Exception as e:
+            self._runner.teardown()
+            raise e
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._runner.teardown()
+
+    def _test(
+            self,
+            test: StandardTest,
+            inbound_server: SpeedTestServer,
+            inbound_client: SpeedTestServer,
+            rated_node: Node,
+            expected_interfaces: int,
+    ) -> Tuple[IperfResult, IperfResult]:
+        if len(test.rates) != expected_interfaces:
+            raise RuntimeError('mismatched number of interfaces')
+
+        results = []
+        for server, client in [(inbound_server, inbound_client), (inbound_client, inbound_server)]:
+            def test_reducer(old: Optional[IperfResult]) -> IperfResult:
+                for i, r in enumerate(test.rates):
+                    rated_node.get_interfaces()[i].set_rate(r)
+                server.server()
+
+                for t, (iface, rate) in test.events.items():
+                    threading.Timer(
+                        6 + t,
+                        (lambda n: lambda: n.get_interfaces()[iface].set_rate(rate))(rated_node),
+                    )
+
+                iperf = client.client(server, time=test.duration)
+                if old is None:
+                    return IperfResult(test, iperf)
+                else:
+                    old.add_results(iperf)
+                    return old
+
+            def test_satisfier(val: IperfResult) -> bool:
+                if val.num_tests < 3:
+                    return False
+                return val.bandwidth_coefficient_variance() < test.bandwidth_variation_target and False not in \
+                    [x < test.interval_variation_target for x in val.interval_coefficient_variances().values()]
+
+            result = repeat_until_satisfied(
+                test_reducer,
+                test_satisfier,
+                max_failures=test.max_failures,
+                max_attempts=test.max_attempts,
+            )
+            results.append(result)
+
+        # Return a tuple of (inbound, outbound)
+        return results[0], results[1]
+
+    def test(self, test: StandardTest) -> Tuple[IperfResult, IperfResult]:
+        raise RuntimeError('not implemented')
+
+
+class StandardEnvironment(BaseEnvironment):
+    def __init__(self, interfaces: int, runner, setup_params: dict):
+        self._interfaces = interfaces
+
+        self.rp = RemotePortal([Interface(IpMethod.Auto4)], setup_params=setup_params)
+
+        self.st = SpeedTestServer()
+        self.cl = SpeedTestServer(clone_interface=self.rp.get_interfaces()[0])
+
+        self.lp = LocalPortal(
+            [Interface(IpMethod.Auto4) for _ in range(interfaces)],
+            self.cl,
+            setup_params=setup_params,
+        )
+
+        self.rp.set_local_portal(self.lp)
+        self.lp.set_remote_portal(self.rp)
+
+        super().__init__(runner, Bridge(
+            self.st.get_interfaces()[0],
+            self.rp.get_interfaces()[0],
+            *self.lp.get_interfaces()[0:interfaces],
+        ))
+
+    def test(self, test: StandardTest) -> Tuple[IperfResult, IperfResult]:
+        return self._test(test, self.st, self.cl, self.lp, self._interfaces)
+
+
+class DirectEnvironment(BaseEnvironment):
+    def __init__(self, runner):
+        self.st1 = SpeedTestServer()
+        self.st2 = SpeedTestServer()
+
+        super().__init__(runner, Bridge(
+            self.st1.get_interfaces()[0],
+            self.st2.get_interfaces()[0],
+        ))
+
+    def test(self, test: StandardTest) -> Tuple[IperfResult, IperfResult]:
+        return self._test(test, self.st2, self.st1, self.st2, 1)
diff --git a/structure/generic.py b/structure/generic.py
new file mode 100644
index 0000000..49dd515
--- /dev/null
+++ b/structure/generic.py
@@ -0,0 +1,132 @@
+import ipaddress
+import random
+from enum import Enum
+from typing import Optional, List, Dict, Union
+
+
+class IpMethod(Enum):
+    Manual = 0
+    Management = 1
+    Auto4 = 2
+    Auto6 = 3
+    Dhcp4 = 4
+    Dhcp6 = 5
+
+
+class Interface:
+    def __init__(self, method: IpMethod, rate: Optional[int] = None):
+        self._method: IpMethod
+
+        self._node: Optional[Node] = None
+        self._rate: Optional[int] = None
+        self._bridge: Optional[Bridge] = None
+
+        self._method = method
+        self._rate = rate
+        self._address: ipaddress.ip_address = None
+
+    def get_method(self):
+        return self._method
+
+    def set_node(self, node):
+        self._node = node
+
+    def get_node(self):
+        return self._node
+
+    def set_bridge(self, bridge):
+        self._bridge = bridge
+
+    def get_bridge(self):
+        return self._bridge
+
+    def set_address(self, addr: ipaddress.ip_address):
+        self._address = addr
+
+    def get_address(self) -> ipaddress.ip_address:
+        return self._address
+
+    def get_rate(self) -> Optional[int]:
+        return self._rate
+
+    def set_rate(self, rate: Optional[int]):
+        self._rate = rate
+
+
+class Bridge:
+    def __init__(self, *interfaces: Interface):
+        self._interfaces: List[Interface] = []
+        self._name: str = ''
+
+        for interface in interfaces:
+            self._interfaces.append(interface)
+            interface.set_bridge(self)
+
+        # Generate a random class c private range by default (10.0.0.0)
+        self._addr: ipaddress.ip_address = None
+        self._network_iterator: iter = None
+
+        self.netmask = 24
+        self.new_network()
+
+    def get_interfaces(self) -> List[Interface]:
+        return self._interfaces
+
+    def set_name(self, name: str):
+        self._name = name
+
+    def get_name(self) -> str:
+        return self._name
+
+    def set_netmask(self, mask: int):
+        self.netmask = mask
+        self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
+
+    def get_ip_address(self) -> ipaddress.ip_address:
+        return next(self._network_iterator)
+
+    def get_network(self) -> ipaddress.ip_network:
+        return ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False)
+
+    def get_network_string(self) -> str:
+        return str(ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False))
+
+    def new_network(self):
+        self._addr: ipaddress.ip_address = ipaddress.ip_address('10.0.0.0') + random.randint(0, 16777216)
+        self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
+
+
+class Node:
+    def __init__(self, interfaces: List[Interface], setup_params: Dict = None):
+        self._id: Union[int, None] = None
+        self._interfaces: List[Interface] = interfaces
+        self._interfaces.append(Interface(IpMethod.Management))
+
+        for interface in self._interfaces:
+            interface.set_node(self)
+
+        self.setup_params = {} if setup_params is None else setup_params
+
+    def get_interfaces(self):
+        return self._interfaces
+
+    def set_id(self, new_id):
+        self._id = new_id
+
+    def get_id(self):
+        return self._id
+
+    def get_core_count(self) -> int:
+        return 2
+
+    def get_memory_mb(self) -> int:
+        return 2048
+
+    def get_internet_setup(self) -> Optional[str]:
+        return None
+
+    def get_setup(self) -> Optional[str]:
+        return None
+
+    def ssh(self, *args, **kwargs):
+        raise RuntimeError('ssh not implemented')
\ No newline at end of file
diff --git a/structure/structure.py b/structure/structure.py
index 445f657..3555048 100644
--- a/structure/structure.py
+++ b/structure/structure.py
@@ -1,140 +1,8 @@
-import ipaddress
-import json
 import textwrap
-import threading
-from enum import Enum
-import random
 
-import numpy as np
-from typing import List, Optional, Union, Dict, Tuple
+from typing import List, Optional
 
-
-class IpMethod(Enum):
-    Manual = 0
-    Management = 1
-    Auto4 = 2
-    Auto6 = 3
-    Dhcp4 = 4
-    Dhcp6 = 5
-
-
-class Interface:
-    def __init__(self, method: IpMethod, rate: Optional[int] = None):
-        self._method: IpMethod
-
-        self._node: Optional[Node] = None
-        self._rate: Optional[int] = None
-        self._bridge: Optional[Bridge] = None
-
-        self._method = method
-        self._rate = rate
-        self._address: ipaddress.ip_address = None
-
-    def get_method(self):
-        return self._method
-
-    def set_node(self, node):
-        self._node = node
-
-    def get_node(self):
-        return self._node
-
-    def set_bridge(self, bridge):
-        self._bridge = bridge
-
-    def get_bridge(self):
-        return self._bridge
-
-    def set_address(self, addr: ipaddress.ip_address):
-        self._address = addr
-
-    def get_address(self) -> ipaddress.ip_address:
-        return self._address
-
-    def get_rate(self) -> Optional[int]:
-        return self._rate
-
-    def set_rate(self, rate: Optional[int]):
-        self._rate = rate
-
-
-class Bridge:
-    def __init__(self, *interfaces: Interface):
-        self._interfaces: List[Interface] = []
-        self._name: str = ''
-
-        for interface in interfaces:
-            self._interfaces.append(interface)
-            interface.set_bridge(self)
-
-        # Generate a random class c private range by default (10.0.0.0)
-        self._addr: ipaddress.ip_address = None
-        self._network_iterator: iter = None
-
-        self.netmask = 24
-        self.new_network()
-
-    def get_interfaces(self) -> List[Interface]:
-        return self._interfaces
-
-    def set_name(self, name: str):
-        self._name = name
-
-    def get_name(self) -> str:
-        return self._name
-
-    def set_netmask(self, mask: int):
-        self.netmask = mask
-        self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
-
-    def get_ip_address(self) -> ipaddress.ip_address:
-        return next(self._network_iterator)
-
-    def get_network(self) -> ipaddress.ip_network:
-        return ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False)
-
-    def get_network_string(self) -> str:
-        return str(ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False))
-
-    def new_network(self):
-        self._addr: ipaddress.ip_address = ipaddress.ip_address('10.0.0.0') + random.randint(0, 16777216)
-        self._network_iterator = ipaddress.ip_network('{}/{}'.format(self._addr, self.netmask), False).hosts()
-
-
-class Node:
-    def __init__(self, interfaces: List[Interface], setup_params: Dict = None):
-        self._id: Union[int, None] = None
-        self._interfaces: List[Interface] = interfaces
-        self._interfaces.append(Interface(IpMethod.Management))
-
-        for interface in self._interfaces:
-            interface.set_node(self)
-
-        self.setup_params = {} if setup_params is None else setup_params
-
-    def get_interfaces(self):
-        return self._interfaces
-
-    def set_id(self, new_id):
-        self._id = new_id
-
-    def get_id(self):
-        return self._id
-
-    def get_core_count(self) -> int:
-        return 2
-
-    def get_memory_mb(self) -> int:
-        return 2048
-
-    def get_internet_setup(self) -> Optional[str]:
-        return None
-
-    def get_setup(self) -> Optional[str]:
-        return None
-
-    def ssh(self, *args, **kwargs):
-        raise RuntimeError('ssh not implemented')
+from structure import IpMethod, Interface, Bridge, Node
 
 
 class SpeedTestServer(Node):
@@ -343,223 +211,3 @@ class LocalPortal(Node):
             remote_host=self.remote_portal.get_interfaces()[0].get_address(),
             local_interface='eth{}'.format(len(self.get_interfaces()) - 2),
         )
-
-
-class StandardTest:
-    def __init__(
-            self,
-            rates: List[int],
-            events: Dict[float, Tuple[int, int]] = None,
-            duration: int = 10,
-            variation_target: float = 0.2,
-            max_failures: int = 3,
-            max_attempts: int = 60,
-    ):
-        self.rates = rates
-        self.events = events if events is not None else dict()
-        self.duration = duration
-
-        self.variation_target = variation_target
-        self.max_failures = max_failures
-        self.max_attempts = max_attempts
-
-    def name(self) -> str:
-        name_builder = ['R{}-{}'.format(*y) for y in enumerate(self.rates)]
-        name_builder += ['E{}R{}-{}'.format(x, *y) for (x, y) in self.events.items()]
-        name_builder.append('T{}'.format(self.duration))
-        return ''.join(name_builder)
-
-
-class DirectTest(StandardTest):
-    def __init__(self, rate: int, **kwargs):
-        super().__init__([rate], **kwargs)
-
-    def name(self) -> str:
-        return 'D{}'.format(super().name())
-
-
-class StandardIperfResult:
-    def __init__(self, test: StandardTest, iperf: str, interval_size=2.0):
-        self.test = test
-
-        self.interval_size = interval_size
-
-        # list containing an exact time and a value
-        self.data: List[Tuple[float, float]] = []
-
-        self.num_tests = 0
-        self.add_results(iperf)
-
-    def add_results(self, iperf: str):
-        data = json.loads(iperf)
-        # grab the sum data of all non omitted intervals, excluding any that are smaller than expected
-        intervals = [
-            x['sum'] for x in data['intervals'] if
-            (not x['sum']['omitted']) and (x['sum']['end'] - x['sum']['start'] > self.interval_size / 2)
-        ]
-
-        for (time, result) in zip(
-                [((x['start'] + x['end']) / 2) for x in intervals],
-                [x['bits_per_second'] for x in intervals],
-        ):
-            self.data.append((time, result))
-
-        self.num_tests += 1
-
-    def bins(self) -> List[List[Tuple[float, float]]]:
-        bins: List[List[Tuple[float, float]]] = [[] for _ in np.arange(0, self.test.duration, self.interval_size)]
-
-        for time, result in self.data:
-            index = int(np.round((time - self.interval_size / 2) / self.interval_size))
-            bins[index].append((time, result))
-
-        return bins
-
-    def summarise(self) -> Dict[float, float]:
-        bins = self.bins()
-        means = [np.mean(x, axis=0)[1] for x in bins]
-        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
-        return dict(zip(times, means))
-
-    def standard_deviation(self) -> Dict[float, float]:
-        bins = self.bins()
-        stds = [np.std(x, axis=0)[1] for x in bins]
-        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
-        return dict(zip(times, stds))
-
-    def coefficient_variance(self) -> Dict[float, float]:
-        stds = self.standard_deviation()
-        means = self.summarise()
-
-        return {k: stds[k] / means[k] for k in stds.keys()}
-
-    def time_range(self) -> Dict[float, Tuple[float, float]]:
-        bins = self.bins()
-        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
-        ranges = [(-np.min(x, axis=0)[0] + time, np.max(x, axis=0)[0] - time) for (x, time) in zip(bins, times)]
-        return dict(zip(times, ranges))
-
-
-def repeat_until_satisfied(reducer, satisfied, initial=None, max_attempts=100, max_failures=3):
-    val = initial
-
-    for i in range(max_attempts):
-        for j in range(max_failures):
-            try:
-                val = reducer(val)
-                break
-            except Exception as e:
-                print('failed with {}'.format(e))
-                if j == max_failures - 1:
-                    raise e
-
-        if satisfied(val):
-            return val
-
-    raise RuntimeError('too many attempts')
-
-
-class BaseEnvironment:
-    def __init__(self, runner, top_level_bridge: Bridge):
-        self.top_level_bridge = top_level_bridge
-        self._runner = runner
-
-    def __enter__(self):
-        try:
-            self._runner.build(self.top_level_bridge)
-        except Exception as e:
-            self._runner.teardown()
-            raise e
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._runner.teardown()
-
-    def _test(
-            self,
-            test: StandardTest,
-            inbound_server: SpeedTestServer,
-            inbound_client: SpeedTestServer,
-            rated_node: Node,
-            expected_interfaces: int,
-    ) -> Tuple[StandardIperfResult, StandardIperfResult]:
-        if len(test.rates) != expected_interfaces:
-            raise RuntimeError('mismatched number of interfaces')
-
-        results = []
-        for server, client in [(inbound_server, inbound_client), (inbound_client, inbound_server)]:
-            def test_reducer(old: Optional[StandardIperfResult]) -> StandardIperfResult:
-                for i, r in enumerate(test.rates):
-                    rated_node.get_interfaces()[i].set_rate(r)
-                server.server()
-
-                for t, (iface, rate) in test.events.items():
-                    threading.Timer(
-                        6 + t,
-                        (lambda n: lambda: n.get_interfaces()[iface].set_rate(rate))(rated_node),
-                    )
-
-                iperf = client.client(server, time=test.duration)
-                if old is None:
-                    return StandardIperfResult(test, iperf)
-                else:
-                    old.add_results(iperf)
-                    return old
-
-            def test_satisfier(val: StandardIperfResult) -> bool:
-                if val.num_tests < 3:
-                    return False
-                return False not in [x < test.variation_target for x in val.coefficient_variance().values()]
-
-            result = repeat_until_satisfied(
-                test_reducer,
-                test_satisfier,
-                max_failures=test.max_failures,
-                max_attempts=test.max_attempts,
-            )
-            results.append(result)
-
-        # Return a tuple of (inbound, outbound)
-        return results[0], results[1]
-
-
-class StandardEnvironment(BaseEnvironment):
-    def __init__(self, interfaces: int, runner, setup_params: dict):
-        self._interfaces = interfaces
-
-        self.rp = RemotePortal([Interface(IpMethod.Auto4)], setup_params=setup_params)
-
-        self.st = SpeedTestServer()
-        self.cl = SpeedTestServer(clone_interface=self.rp.get_interfaces()[0])
-
-        self.lp = LocalPortal(
-            [Interface(IpMethod.Auto4) for _ in range(interfaces)],
-            self.cl,
-            setup_params=setup_params,
-        )
-
-        self.rp.set_local_portal(self.lp)
-        self.lp.set_remote_portal(self.rp)
-
-        super().__init__(runner, Bridge(
-            self.st.get_interfaces()[0],
-            self.rp.get_interfaces()[0],
-            *self.lp.get_interfaces()[0:interfaces],
-        ))
-
-    def test(self, test: StandardTest) -> Tuple[StandardIperfResult, StandardIperfResult]:
-        return self._test(test, self.st, self.cl, self.lp, self._interfaces)
-
-
-class DirectEnvironment(BaseEnvironment):
-    def __init__(self, runner):
-        self.st1 = SpeedTestServer()
-        self.st2 = SpeedTestServer()
-
-        super().__init__(runner, Bridge(
-            self.st1.get_interfaces()[0],
-            self.st2.get_interfaces()[0],
-        ))
-
-    def test(self, test: StandardTest) -> Tuple[StandardIperfResult, StandardIperfResult]:
-        return self._test(test, self.st2, self.st1, self.st2, 1)
diff --git a/structure/tests.py b/structure/tests.py
new file mode 100644
index 0000000..5b6dac3
--- /dev/null
+++ b/structure/tests.py
@@ -0,0 +1,137 @@
+import json
+from typing import List, Dict, Tuple
+
+import numpy as np
+
+
+def repeat_until_satisfied(reducer, satisfied, initial=None, max_attempts=100, max_failures=3):
+    val = initial
+
+    for i in range(max_attempts):
+        for j in range(max_failures):
+            try:
+                val = reducer(val)
+                break
+            except Exception as e:
+                print('failed with {}'.format(e))
+                if j == max_failures - 1:
+                    raise e
+
+        if satisfied(val):
+            return val
+
+    raise RuntimeError('too many attempts')
+
+
+class StandardTest:
+    def __init__(
+            self,
+            rates: List[int],
+            events: Dict[float, Tuple[int, int]] = None,
+            duration: int = 10,
+
+            interval_variation_target: float = np.inf,
+            bandwidth_variation_target: float = np.inf,
+            max_failures: int = 3,
+            max_attempts: int = 60,
+    ):
+        self.rates = rates
+        self.events = events if events is not None else dict()
+        self.duration = duration
+
+        self.interval_variation_target = interval_variation_target
+        self.bandwidth_variation_target = bandwidth_variation_target
+        self.max_failures = max_failures
+        self.max_attempts = max_attempts
+
+    def name(self) -> str:
+        name_builder = ['R{}-{}'.format(*y) for y in enumerate(self.rates)]
+        name_builder += ['E{}R{}-{}'.format(x, *y) for (x, y) in self.events.items()]
+        name_builder.append('T{}'.format(self.duration))
+        return ''.join(name_builder)
+
+
+class DirectTest(StandardTest):
+    def __init__(self, rate: int, **kwargs):
+        super().__init__([rate], **kwargs)
+
+    def name(self) -> str:
+        return 'D{}'.format(super().name())
+
+
+class IperfResult:
+    def __init__(self, test: StandardTest, iperf: str, interval_size=2.0):
+        self.test = test
+
+        self.interval_size = interval_size
+
+        # list containing an exact time and a value
+        self.interval_data: List[Tuple[float, float]] = []
+
+        # list containing the overall data transferred and the time taken
+        self.bandwidth_data: List[float] = []
+
+        self.num_tests = 0
+        self.add_results(iperf)
+
+    def add_results(self, iperf: str):
+        data = json.loads(iperf)
+
+        # grab the overall bandwidth
+        self.bandwidth_data.append(data['end']['sum_sent']['bits_per_second'])
+
+        # grab the sum data of all non omitted intervals, excluding any that are smaller than expected
+        intervals = [
+            x['sum'] for x in data['intervals'] if
+            (not x['sum']['omitted']) and (x['sum']['end'] - x['sum']['start'] > self.interval_size / 2)
+        ]
+
+        for (time, result) in zip(
+                [((x['start'] + x['end']) / 2) for x in intervals],
+                [x['bits_per_second'] for x in intervals],
+        ):
+            self.interval_data.append((time, result))
+
+        self.num_tests += 1
+
+    def bins(self) -> List[List[Tuple[float, float]]]:
+        bins: List[List[Tuple[float, float]]] = [[] for _ in np.arange(0, self.test.duration, self.interval_size)]
+
+        for time, result in self.interval_data:
+            index = int(np.round((time - self.interval_size / 2) / self.interval_size))
+            bins[index].append((time, result))
+
+        return bins
+
+    def interval_means(self) -> Dict[float, float]:
+        bins = self.bins()
+        means = [np.mean(x, axis=0)[1] for x in bins]
+        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
+        return dict(zip(times, means))
+
+    def interval_standard_deviations(self) -> Dict[float, float]:
+        bins = self.bins()
+        stds = [np.std(x, axis=0)[1] for x in bins]
+        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
+        return dict(zip(times, stds))
+
+    def interval_coefficient_variances(self) -> Dict[float, float]:
+        stds = self.interval_standard_deviations()
+        means = self.interval_means()
+
+        return {k: stds[k] / means[k] for k in stds.keys()}
+
+    def interval_time_ranges(self) -> Dict[float, Tuple[float, float]]:
+        bins = self.bins()
+        times = [i + self.interval_size / 2 for i in np.arange(0, self.test.duration, self.interval_size)]
+        ranges = [(-np.min(x, axis=0)[0] + time, np.max(x, axis=0)[0] - time) for (x, time) in zip(bins, times)]
+        return dict(zip(times, ranges))
+
+    def bandwidth_mean(self):
+        return np.mean(self.bandwidth_data)
+
+    def bandwidth_standard_deviation(self):
+        return np.std(self.bandwidth_data)
+
+    def bandwidth_coefficient_variance(self):
+        return self.bandwidth_standard_deviation() / self.bandwidth_mean()

From 1e3b0d7634106fb24bc3a6cc5969a915bfa1818f Mon Sep 17 00:00:00 2001
From: Jake Hillion <jake@hillion.co.uk>
Date: Sat, 12 Dec 2020 13:06:20 +0000
Subject: [PATCH 2/4] git churn error

---
 evaluation.ipynb   | 941 +++++++++++----------------------------------
 runners/runners.py |   5 +-
 2 files changed, 235 insertions(+), 711 deletions(-)

diff --git a/evaluation.ipynb b/evaluation.ipynb
index 7b4ae99..856e041 100644
--- a/evaluation.ipynb
+++ b/evaluation.ipynb
@@ -2,42 +2,35 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "# Project Evaluation\n",
     "\n",
     "This file interfaces with a Proxmox server to automatically generate VM structures and graphs for testing the\n",
     "success criteria of my project."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Setup\n",
     "This section sets up the required variables for the Proxmox server."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "outputs": [
-    {
-     "ename": "ImportError",
-     "evalue": "cannot import name 'BaseEnvironment' from 'structure' (/home/jake/repos/dissertation/3-evaluation/structure/__init__.py)",
-     "output_type": "error",
-     "traceback": [
-      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
-      "\u001B[0;31mImportError\u001B[0m                               Traceback (most recent call last)",
-      "\u001B[0;32m<ipython-input-29-9f1181ce8d4d>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[1;32m      5\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mStandardEnvironment\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mStandardTest\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      6\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mDirectEnvironment\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mDirectTest\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 7\u001B[0;31m \u001B[0;32mfrom\u001B[0m \u001B[0mstructure\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mBaseEnvironment\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m      8\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      9\u001B[0m \u001B[0mget_ipython\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mrun_line_magic\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m'load_ext'\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m'dotenv'\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
-      "\u001B[0;31mImportError\u001B[0m: cannot import name 'BaseEnvironment' from 'structure' (/home/jake/repos/dissertation/3-evaluation/structure/__init__.py)"
-     ]
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "import os\n",
     "import ipaddress\n",
@@ -49,27 +42,26 @@
     "\n",
     "%load_ext dotenv\n",
     "%dotenv"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Testing\n",
     "This section gathers the required data from the different structures for later graphs."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "runner = runners.ProxmoxRunner(\n",
@@ -93,17 +85,16 @@
     "    'secret_key': os.getenv('S3_SECRET_KEY'),\n",
     "    'branch': os.getenv('TARGET_BRANCH'),\n",
     "}"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "from graphs import TestStore\n",
@@ -127,26 +118,25 @@
     "\n",
     "\n",
     "fast_tests = True"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Direct Server to Server"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Direct Server to Server"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "def direct_tests():\n",
@@ -157,26 +147,25 @@
     "        run_and_save_test(env, DirectTest(4, bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(direct_tests)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Local Portal with 2 Interfaces"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Local Portal with 2 Interfaces"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "def two_interface_tests():\n",
@@ -192,26 +181,25 @@
     "        ))\n",
     "\n",
     "attempt_n_times(two_interface_tests)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Local Portal with 3 Interfaces"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Local Portal with 3 Interfaces"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "def three_interface_tests():\n",
@@ -220,26 +208,25 @@
     "        run_and_save_test(env, StandardTest([2,2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(three_interface_tests)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Local Portal with 4 Interfaces"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Local Portal with 4 Interfaces"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "def four_interface_tests():\n",
@@ -248,37 +235,27 @@
     "        run_and_save_test(env, StandardTest([2,2,2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "\n",
     "attempt_n_times(four_interface_tests)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Graphs\n",
     "This section produces graphs from the collected data."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The autoreload extension is already loaded. To reload it, use:\n",
-      "  %reload_ext autoreload\n"
-     ]
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "from graphs import plot_iperf_results, plot_iperf_results_time\n",
     "\n",
@@ -288,56 +265,29 @@
     "for filename in os.listdir('output'):\n",
     "    file_path = os.path.join('output/', filename)\n",
     "    os.unlink(file_path)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Error Bar Evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Section 4.2: Graphs\n",
+    "#### Subsection 4.2.2 Line Graphs\n",
+    "\n",
+    "Figure 4.1 Line graphs produced with varying error bars enabled"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
-      "output/TIS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAFNCAYAAADYVrylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABAeUlEQVR4nO3deXhU1eH/8ffJnpAQlgREEBLZBBIJEBaLImjdCrVubd2lLVVbqdj2a6Vf/dblZ1ttqbVqW+uKrVStG/gorhVL3UBAFAQRkJ0IYcu+5/z+uJlhJjOTTJbJTSaf1/PMw8zd5swwmc+cc889x1hrERERkY4V43YBREREuiMFsIiIiAsUwCIiIi5QAIuIiLhAASwiIuICBbCIiIgL4twuQDgyMjJsVlaW28UQERFpkdWrVx+w1mYGW9clAjgrK4tVq1a5XQwREZEWMcbsCLVOTdAiIiIuUACLiIi4QAEsIiLiAgWwiIiIC7pEJywRcV9pKWzd6ty2b4e+fWH0aDjhBEhLc7t0Il2PAlhEALAWCguPhuyWLUfvb90K+/eH3ve445wwHj0aRo06er93744rv0hXowAW6Ubq6mDXruABu3WrU8v1MAYGDYJhw+Dcc2Ho0KO3rCwnrDdsgI0bnX83bIDly6Gi4ugxjjnGP5A99/v1c44v0tlYC/v2Qc+ekJIS2ecyXWE+4Pz8fKvrgEXCU1EBX34ZGK6epuOamqPbJiTA8cf7h6vnlp0NiYkte+76etix42gg+4ZzScnR7fr08Q9mTzgPGqRglsirrXU+p8H+Rr78EsrK4KWX4JvfbPtzGWNWW2vzg65TAEfGPfdAVZVTA/C99esHsbFul066ukOHgn95bN0Ke/b4b5ueHjxghw2DgQMhpgO6YlrrlMs3kDduhM8+c16LR1qaE8SNw3nIEP3dSMuUlTlhGqylZ8cOpzXIIykp8IfozJnOj9C2UgC7ICfH+XJpLCYGMjMDgznYLT1dtYHuqr4e9u4N/OLwfJkcOeK//YABgeHqud+nT+f9HHnOO/sGsyecCwqObpeU5HT2anyOeehQiI93r/ziHmvhwIHQP0S/+sp/+z59gv8QHTrU+fuJ1A9RVwLYGJMELAcScc41P2etvdUYkw08DfQFVgNXWGurmzpWVwxgcH6B7dvnfBCau/k2C3okJYUX1P37O9tK11Jd7TQJB+v0tG0bVFYe3TYuzqkFNg7XoUOdX+6RPlflhsOHnSBuHM47dx7dJj4ehg8PPMc8YoT+JqKBb5+FYDff0xrgnMIIFbJudQh0K4AN0MNaW2qMiQfeBeYBPwNesNY+bYx5EPjEWvvXpo7VVQM4XNY6XzZffeX86m8qqA8cCH6M3r3DC+uMjI5pchRHcXHoL49du5yarkdKSmC4em6DBzshLE5Hsc8/DzzH/OWXR9/PmBjnh0njc8wnnACpqe6WX/xVVDg/OIP9EA3WZyE7O3Sfhc74o8v1JmhjTApOAP8IeAU4xlpba4w5CbjNWntWU/tHewC3RE2NczlI42BuHNwFBVBeHrh/bKxzHnrAgObDOjW18zZddhaeHpOhQraw0H/7zMzQv9D799f73RaVlfDFF4EdwL74wul04zFkSGBT9qhR0KuXa0WPei3ps9CzZ+i/kUGDul5fgKYCOKK/qY0xsTjNzMOAPwNbgSPWWs+fw25gYCTLEG3i452OMwPDeNdKS5uuTRcUwNq1ToD4dkjwSElxgri5sO7Xz/llGq1qa51mz1BfIGVlR7eNiXGuiR06FM47z/+c7PHHO18uEhlJSXDiic7NV02N8//U+BzzsmX+zfwDBgS/ljkz6ERy4qu+3gnSUH8jofosfP3rgSHbt2/3+SHaUTXgXsCLwP8BC621wxqWHwe8aq3NCbLP1cDVAIMHD56wY0fIGZ2kjerr4eDB8M5V+/ZY9dW3b3hh3Vk7BJWXB16642kK27HDvwaVmOjfY9K32TgrK7p/jESTujqniTNYBzDf66E9I341Dudjj+2cn+VIqary77Pg+3eybZuz3sO3z0LjzoHZ2dCjh2svo8O53gTdUIhfARXATagJusuqqgqvY1lBgX/twiM+3mlq9QRyU4Hdnh2LrD3aDBbssgTfHrfgNEcG6/A0dKjzxavz6NHLWti9O/Ac84YNTl8Nj549gw8yMmRI1/18FBU13WfBNy569AjdVKw+C0e51QkrE6ix1h4xxiQDbwB3A1cBz/t0wvrUWvuXpo6lAO56rHV6KIbTsWz/fv/OSB5paf6BHCqsMzOdP3ZPM1iwgN261fly8TVwYOgvkD59OuZ9kq7DWuezGmyQkX37jm6XnBx4LfOoUc7nyu1Qstb5mwv1N3LwoP/26rPQdm4F8InAE0AszqxL/7LW3mGMOR7nMqQ+wMfA5dbaqtBHUgBHu7o6p3d3U53KPLfGIQrOl0BGhtPj2LcZLD7eaRIO9uVx/PHOF6VIezh0KHCQkQ0bnFqjR0KCc3lU43PMw4e3fMSxptTUND3Kk2/nzJgYp7Ya6m9EfRbarlM0QbeFAlg8KipCN4H79p4cNszpDNXVekxKdCkpOXrJlG84f/nl0ebc2FjnM9u4KfuEE0KfhvGdmarxbefO5kd58vyNDBmiPguRpgAWEelEKipg06bAWvPmzUc7/Blz9JKp4cP9+zA0npnKrVGepHmuXYYkIiKBkpMhL8+5+aqudgK28TnmZcuc3thDh8KsWYE98HUNc9ekABYR6SQSEo42RUv0U8OEiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCIiIi5QAIuIiLhAASwiIuICBbCIiIgLFMAiIiIuUACLiIi4QAEsIiLiAgWwiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCIiIi5QAIuIiLhAASwiIuICBbCIiIgLFMAiIiIuUACLiIi4QAEsIiLiAgWwiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCIiIi5QAIuIiLhAASwiIuICBbCIiIgLIhbAxpjjjDHLjDEbjDGfGWPmNSy/zRizxxiztuH2jUiVQUREpLOKi+Cxa4GfW2vXGGPSgNXGmDcb1v3RWrsggs8tIiLSqUUsgK21BUBBw/0SY8xGYGCknk9ERKQr6ZBzwMaYLGAcsKJh0VxjzKfGmMeMMb07ogwiIiKdScQD2BiTCjwP3GCtLQb+CgwF8nBqyH8Isd/VxphVxphVhYWFkS6miIhIh4poABtj4nHCd5G19gUAa+0+a22dtbYeeBiYFGxfa+1D1tp8a21+ZmZmJIspIiLS4SLZC9oAjwIbrbX3+Cwf4LPZ+cD6SJVBRESks4pkL+ipwBXAOmPM2oZl/wtcYozJAyywHbgmgmUQERHplCLZC/pdwARZtTRSzykiItJVaCQsERERFyiARUREXKAAFhERcYECWERExAUKYBERERcogEVERFygABYREXGBAlhERMQFCmAREREXKIBFRERcoAAWERFxgQJYRETEBQpgERERF0RyOkKRplkL5eVQUnL0Vlzc9ONQy0pKwBhITnZuSUlH70fisWdZjH7DikjrKIClZerqwgvEcIK0pATq65t/TmMgNRXS0qBnT+fftDTIyDi6LDXVCfSKCqisdP713Cornefavz/4+rq61r8fCQkdF/qex3H6sxWJBvpL7g6qqlpfs2y8rLw8vOeMjz8alJ6Q7N0bBg8ODFLfbYItS0mJbE2ztjYwsH0fhwr1cB4fOhR8fU1N68sbFxfZWn2wx/Hxzg8hEWk3CuDOyFooK2t9zbLxsnC/7FNSAsNv4MCmQzJUaCYmRvY9ak9xcUfL3lHq6lof6s39UCguDr5NVVXryxsTExjQKSnQo0f73JKTFfDS7SiAI2XNGjhwoHW1zdJSJ4SbExMTPPz69w8vJH0fp6aqabMjxcYeDZ+OUl/vhHB7hHxFhfMj0fNDsaDg6OOyMqelJJzPsIcx7RfmjW+RbkERaSV940bKJZfAF18ELk9ICAy/vn0hO7vloZmSolqDhM9Ti01Ojvxzec7H+4Zya28HDgQua+l5++TkyAW8frhKK+mTEymPP+58CTUOzYQEt0smEnnGOD8QU1IgM7N9j20tVFcHhnJpacvDfe/ewGUtPT+fkOC0IEUi3PV9EdUUwJHyta+5XQKR6GSM08cgMRH69Gn/49fUtE/NvbAQtm/3X1ZZ2bKyxMWF18TemmZ5taC5TgEsIuIrPh569XJu7a2uzjk/3trau2ffoqLA2ntLz7tDy8K7pUGvpvlm6R0SEekosbGR63Ef6rx7sMBv7nbkSPs0zbc0tMPdPikpKmrvCmARkWgQyfPu0HTTfEtC/tAh2LXLf59wxxfwfa2trZmHs31sbPu/f0EogEVEpHmRbJqvrw+v13w4QX/wYNt7zScmwjPPwLe+1f6v1YcCWERE3BUTc7T2GQnBes03F/LDhkWmLD4UwCIiEt0SEpxb795ul8SPhocRERFxgQJYRETEBQpgERERFyiARUREXKAAFhERcUGzvaCNMTHAWOBYoAJYb63dH+mCiYiIRLOQAWyMGQrcBHwd2AwUAknACGNMOfA34AlrbX1HFFRERCSaNFUDvhP4K3CNtf4jfBtj+gGXAlcAT0SueCIiItEpZABbay9pYt1+4N5IFEhERKQ7aLYTljHm28aYtIb7/2eMecEYMz7yRRMREYle4fSC/j9rbYkx5mTgdOBRnKbpJhljjjPGLDPGbDDGfGaMmdewvI8x5k1jzOaGfzvX2GAiIiIdIJwA9kwjMRN4yFr7CpAQxn61wM+ttaOBKcB1xpjRwHzg39ba4cC/Gx6LiIh0K+EE8B5jzN+A7wJLjTGJ4exnrS2w1q5puF8CbAQGAt/iaMetJ4DzWlFuERGRLi2cAP4O8DpwlrX2CNAHuLElT2KMyQLGASuA/tbagoZVXwH9Q+xztTFmlTFmVWFhYUueTkREpNMLpyZbDmwHzjHG/AQYYK19I9wnMMakAs8DN1hrixsd2wI22H7W2oestfnW2vzMzMxwn05ERKRLCKcX9K9wmor7AhnA48aYW8I5uDEmHid8F1lrX2hYvM8YM6Bh/QBAo2qJiEi3E04T9GXARGvtrdbaW3E6VF3R3E7GGIPTY3qjtfYen1UvAVc13L8KWNKyIouIiHR9zY4FDezFGYKysuFxIrAnjP2m4gT1OmPM2oZl/wvcBfzLGPMDYAfOOWYREZFuJZwALgI+M8a8iXO+9gxgpTHmPgBr7fXBdrLWvguYEMc8vRVlFRERiRrhBPCLDTePdyJTFBERke6j2QC21j5hjEkATsCpAW+y1lZHvGQiIiJRLJz5gL+BM/XgVpwm5WxjzDXW2lcjXTgREZFoFU4T9D3ADGvtFvDOE/wKoAAWERFppXAuQyrxhG+DL4GSCJVHRESkWwhZAzbGXNBwd5UxZinwL5xzwN8GPuqAsomIiEStppqgv+lzfx9wasP9QpzrgkVERKSVQgawtfZ7HVkQERGR7qSpJuj7mtox1AAcIiIi0rymmqCvBdbjnPvdS+hRrURERKSFmgrgATgdrr4L1ALPAM81zAksIiIibRDyMiRr7UFr7YPW2hnA94BewAZjTLMzIYmIiEjTwhkJazxwCc4kDK8CqyNdKBERkWjXVCesO4CZwEbgaeCX1trajiqYiIhINGuqBnwLsA0Y23D7jTEGnM5Y1lp7YuSLJyIiEp2aCuDsDiuFiIhIN9NUAO+01tqmdjbGmOa2ERERkUBNTcawzBjzE2PMYN+FxpgEY8xpxpgngKsiWzwREZHo1FQN+Gzg+8BTxphs4AjOGNCxwBvAvdbajyNeQhHpVKy1lNeUEx8bT0JsgtvFEemymhoLuhL4C/AXY0w8kAFUaCAOka6ttr6W4qpijlQe4UjlEYoqi5x/q4r8Hh+pClznWV9n6wBIiE0gLSGN1IRU0hLT/O6nJqSSlpDW/Hqf+0lxSTR09hSJes1eBwxgra0BCiJcFhFphrWWytrKo2HYODR9l4VYV1pd2uzzpCWkkZ6UTq+kXvRK6sWA1AGMyhhFeqKzrGdiT2rraympLqGkqoTSmlJKqkqcx9Ul7C3ZS2l1qXd9TX1NWK8v1sS2W5inJaaREp9CjAln2nORjhdWAItI+6i39d7aZ6jaZbAQ9V3XXJjFxcTRK6mXNyzTk9IZmTGSXom9vKHqu84Tsr7hGhsT266vu7qu2hvQpdVOWPsGdLD7vssOlh/0W19RWxHW8xoMPRJ6hA7r+PDDPDUhldSEVOJi9LUp7UOfJJEWqKqtar7mWVnk13zru66kqgRL0xcO9Ijv4ReMmSmZDO8zvMnQ9A3WlPiUTteMmxCbQN+UvvRN6dsux6utr6Wsuqz5APcNfZ9lBaUFbD602W99uJLjkpsO6zDD3HNf59G7r3CGorzbWntTc8tEOjtrLSXVJWHVPIOFbFFVEZW1lU0+R4yJ8YaiJxiH9hnqvyxIaHrW9UzsSXxsfAe9I11XXEwc6UnppCelt8vx6m095TXlgaHdVK3dp9n9UMUhdhzZ4bfec568OfEx8U2HdXwqPRN7ktMvh5OOO4nsXtmd7geWtE44NeAzgMZhe06QZSIdxlrL4crD7Diyg51FO9lZtJMD5QdCdh4qqiyiqKqIelvf5HGT45L9grF3Um+ye2U3GZq+y1ITUvXl2AXFmBhvE/Mxqce0+XjWWqrqqtrU7L6vdJ/3fnFVsffUQ78e/Thp0EnO7biTyD82n5T4lDaXWTpeU2NB/wj4MXC8MeZTn1VpwHuRLph0b3X1dRSUFngDdkfRDnYc2cGOoqOPGzcbGgw9E3v6BePg9MHk9sttMjR9l6k5UNqDMYakuCSS4pLI7JHZ5uPV1dexfv96Ptj9gXPb9QFLNi0BnI5rY48Z6xfKqiV3DSbUQFbGmHSgN/BbYL7PqhJr7aEOKJtXfn6+XbVqVUc+pURYZW2lt+bqCVZPyO4s2smu4l3U1vvP/dE3uS9Deg1hcPpghqQPcW4+j/um9FWPV+k2DpQf4MPdH/Lh7g/5YPcHrNyz0vujVLXkzsMYs9pamx90XXMjSTYeCcvDWruzHcoWFgVw12Kt5UjlkaO1VZ+A9TzeV7bPb58YE8PAtIFOmPYaEhCwg9MHk5qQ6tIrEun8gtWSNx/aDKiW7Ka2BvA6wOLMgpSEM0nDJmvtmPYuaCgK4M6l3tZTUFIQsml4x5EdlFSX+O2TFJfEkHSf2mtDyHoCd2DaQHU+Emln4daSpwyawsSBE1VLjoA2BXCQg40HfmytndMehQuHArhjVdVWHW0eDhKwu4p2BVyL2ie5T8im4SG9hpCZkqlf2yIuUy2547VrADcccJ21NrfNJQuTArh9Hak80mTnpq9Kv/Lb3mAY2HNgyIAdnD6YtMQ0l16NiLRFOLXkKYOmcNKgk1RLboW2NkH/zOdhDDAe6GutPav9itg0BXD46m09X5V+5X/u9cgOdhYffVxcVey3T2JsYshzr0PShzCo5yA1D4t0E6olt6+2BvCtPg9rge3A8w2TNXQIBfBRVbVV7CreFbJz067iXVTXVfvt0zupd0DA+j7u16Of/oBEJCTVkluvXZqgjTE9AWutLWl243bWnQK4qLIooGnYN2C/Kv3KbyhDg2FA2oDAjk0+tdieiT1dfEUiEm1USw5fW2vA+cDjOANwABQBP7DWdlgiRksA19t69pXua7L3cFFVkd8+CbEJTXZuGtRzkAaPEBHXqZYcXFsD+FPgOmvtfxsenwz8xVp7YruXNISuGMBPr3+aTQc2BfQerqqr8tsuPTE9ZNPwkF5O87AGlxCRrka1ZEdbA/hja+24RsvWWGvHN7PfY8AsYL+1Nqdh2W3AD4HChs3+11q7tLkX0BUDeMxfxrChcAMDUgeEDNjB6YPbbTB5EZHOrjvWktsawPcCycBTOANyfBeoBJ4EsNauCbHfNKAU+HujAC611i5oyQvoigH8VelX9E7qTWJcottFERHplLpDLbmtAbysidXWWntaE/tmAS93xwAWEZGWa66W7KkhnzTIGeO6R0IPl0vctKYCuNnpCK21M9q5PHONMVcCq4CfW2sPt/PxRUSki8pIyWDWiFnMGjELCF5LfmnTS0DXryWHUwNOBC4EsvAJbGvtHc0ePLAG3B84gNOU/f+AAdba74fY92rgaoDBgwdP2LFjR/OvRkREol5XqiW3tQn6NZxLj1YDdZ7l1to/hPHEWfgEcLjrGlMTtIiIhNKZzyW3NYDXhxOSIfbNwr8GPMBaW9Bw/6fAZGvtxc0dRwEsIiIt0VlqyW06Bwy8b4zJtdaua+GTPgVMBzKMMbuBW4Hpxpg8nCbo7cA1LTmmiIhIOLrCueSQNWCfeYDjgOHAl0AVzrzAVgNxiIhIV9ZULXnRBYu4NPfSNj9Ha2vAs9r8zCIiIp1UU7XkU4ecGvHnDxnA1todAMaYPkFWd/iEDCIiIpEUG+M0RY89ZmyHPF84gwyvwRk68gtgc8P97caYNcaYCZEsnIiISLQKJ4DfBL5hrc2w1vYFzgFeBn4M/CWShRMREYlW4QTwFGvt654H1to3gJOstR8CGuhYRESkFcK5DKnAGHMT8HTD4+8C+4wxsUB9xEomIiISxcKpAV8KDAIWN9wGNyyLBb4TqYKJiIhEs3AmYzgA/CTE6i3tWxwREZHuodkAbpiOMGC0jqamIRQREZGmhXMO+H987ifhzIxUG5niiIiIdA/hNEGvbrToPWPMygiVR0REpFsIpwnadySsGGACkB6xEomIiHQD4TRBr8Y5B2xwmp63AT+IZKFERESiXThN0NkdURAREZHuJJwm6HjgR8C0hkXvAH+z1tZEsFwiIiJRLZwm6L8C8Rwd9/mKhmVzIlUoERGRaBdOAE+01vrOzfS2MeaTSBVIRESkOwhnKMo6Y8xQzwNjzPFAXeSKJCIiEv3CHYhjmTHmS5ye0EOA70W0VCIiIlGuyQBumPFoLDAcGNmweJO1tirSBRMREYlmTTZBW2vrgEustVXW2k8bbgpfERGRNgqnCfo9Y8wDwDNAmWehtXZNxEolIiIS5cIJ4LyGf+/wWWYBzYYkIiLSSuGMhDWjIwoiIiLSnYQzElYizhSEWb7bW2vvCLWPiIiINC2cJuglQBHOpAzqgCUiItIOwgngQdbasyNeEhERkW4knJGw3jfG5Ea8JCIiIt1IyBqwMWY9UN+wzfcaRsKqwhkNy1prT+yYIoqIiESfppqgB3L0EiQRERFpR00F8DZr7Y4OK4mIiEg30lQA9zPG/CzUSmvtPREoj4iISLfQVADHAqk453xFRESkHTUVwAUabENERCQymroMSTVfERGRCGkqgE/vsFKIiIh0MyED2Fp7qC0HNsY8ZozZ33A9sWdZH2PMm8aYzQ3/9m7Lc4iIiHRV4YyE1VoLgcZDWM4H/m2tHQ78u+GxiIhItxOxALbWLgca16K/BTzRcP8J4LxIPb+IiEhnFskacDD9rbUFDfe/Avp38POLiIh0Ch0dwF7WWgvYUOuNMVcbY1YZY1YVFhZ2YMlEREQir6MDeJ8xZgBAw7/7Q21orX3IWptvrc3PzMzssAKKiIh0hI4O4JeAqxruXwUs6eDnFxER6RQiFsDGmKeAD4CRxpjdxpgfAHcBZxhjNgNfb3gsIiLS7TQ1FGWbWGsvCbFKA3yIiEi351onLBERke5MASwiIuICBbCIiIgLFMAiIiIuUACLiIi4QAEsIiLiAgWwiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCIiIi5QAIuIiLhAASwiIuICBbCIiIgLFMAiIiIuUACLiIi4QAEsIiLiAgWwiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCIiIi6Ic7sAIiIiwRQVFVFYWEhxcTGVlZXU1tZSX1/vt01OTg4ZGRkulbBtFMAiItKpVFVVsXHjRo4cOeJ2USJKASwi0ozKyko+/PDDsLY1xhATE0NMTAxxcXEkJCSQlJRESkoKqamp9OzZk/j4+AiXuOuqrq5m9erVVFdXu12UiFMAi4i0I2stdXV11NXVUVNTQ0VFBUVFRX7bpKam0q9fP/r3709iYqJLJe2cNm3aFDR8Y2NjSUxMJCYmJmC5x4cffkhlZaX38THHHMMJJ5wQucK2kQJYRKSDlZaWUlpayrZt2+jXrx/Z2dkkJSW5XSzXlZeXc/DgQb9lycnJjBw5kvT0dIwxLpUsMhTAIiKtEBsbS3JyctB1tbW11NXVUVtbi7U25DGstezbt4/CwkKOP/54Bg0aFKnidgkHDhwIWJaTk0OPHj1cKE3kKYBFRFohLS2NvLy8Zrerrq6muLiYkpISDh8+THFxccA29fX1bNmyheLiYkaNGhV1Nb1wlZSU+D3u0aNH1IYvKIBFRCIqISGBjIwMMjIyyM7OpqSkhN27d7Nv376Abffv3w/A6NGjO7qYnYLv+VuAlJQUl0rSMTQQh4hIB0pLS2PUqFHk5uYG7Q29f/9+du3a5ULJ3FdXV+f3uHGHq2jTZWvANTU17N69O+AXk0hXlpSUxKBBg3SZSjfQt29fJkyYwOrVq6mpqfFbt23bNjIzM7tdx6zGg2xEe1N8lw3g3bt3k5aWRlZWVtT/J0n3YK3l4MGD7N69m+zsbLeLIx0gKSmJ0aNH8+mnn/p11qqvr2fbtm2MGjWqXZ6nvLycsrIyqqqqqKurwxhDQkICxxxzTFj7V1VVUV5e7jcaVWxsLPHx8SQmJtKzZ8+or61GQpcN4MrKSoWvRBVjDH379qWwsNDtokgH6t27N8ceeyx79uzxW75//36GDh1KQkJCyH3feecdv8dZWVlkZWUBTnPunj172Lt3b8iWwlABXFNTQ2FhIYcPH6aoqKjZQTGMMfTs2ZOBAweSmZkZ1vdyOIObfPXVV3z11Vch10+ZMqXJYzS3v8f06dOb3SYSumwAQ/Q3T0j3o8909zRo0CD27t3rVwu21rJ///5WXZpUXFzMZ599RlVVVYv33bBhA4WFhU1ePtWYtZaioiKKiopISUlhzJgxUd17ub240mZgjNlujFlnjFlrjFnlRhnaS11dHePGjWPWrFnNbnvzzTdz3HHHkZqa6rf8tttuwxjDli1bvMvuvfdejDGsWuW8PVlZWeTm5pKXl0dubi5LliwJ+hylpaVcc801DB06lAkTJjB9+nRWrFjRhlfYdgsXLmTv3r3ex3PmzGHDhg0Re76CgoKw/j/a4sEHH+Tvf/97i/bx/L8XFhZy9tlnR6JY0kUlJyfTt2/fgOWNB6UIx5EjR1i7dm2rwhec8G5J+DZWXl7OmjVrOHz4cKuP0V24WQOeYa0NvOq6i/nTn/7EqFGjgl7b19g3v/lN5s6dy/DhwwPW5ebm8vTTT3PLLbcA8OyzzzJmzBi/bZYtW0ZGRgabNm3izDPP5Fvf+lbAcebMmUN2djabN28mJiaGbdu2RTTswrFw4UJycnI49thjAXjkkUci+nz33HMPP/zhD8Pe3lqLtbZF57Cuvfba1hQNgMzMTAYMGMB7773H1KlTW30ciS69e/cOGIjCE4bhtoxUV1fz2Wef+XVmSktLo0+fPiQlJREbG0t1dTVlZWVhneowxpCamkqPHj1ISUkhPj7eO/RjbW0tFRUVFBcXBwy1WVdXx4YNG5gwYULIjmSeY/sqKyvzC/+4uLgmO6I1PkZL93dbl26Cdtvu3bt55ZVXuPnmm7nnnnsAZ/qsSZMm8dJLLzFy5EguueQSTjvtNH74wx8yZcqUkMc677zzWLJkCbfccgtbt24lPT09ZE/Y4uJievfuHbB869atrFixgkWLFnnDJDs729uh55577uGxxx4DnKC+4YYb2L59O+eccw4nn3wy77//PgMHDmTJkiUkJyczffp0Jk+ezLJlyzhy5AiPPvoop5xyCnV1dcyfP5933nmHqqoqrrvuOq655hoA7r77bp588kliYmI455xzyM/PZ9WqVVx22WUkJyfzwQcfcM4557BgwQLy8/N56qmn+M1vfoO1lpkzZ3L33XcDTm1x3rx5vPzyyyQnJ7NkyRL69+/Ps88+y+23305sbCzp6eksX7484H14/vnnufPOOwEn/F988UWKiorYs2cPl19+Obfeeivbt2/nrLPOYvLkyaxevZqlS5fywAMP8Oqrr2KM4ZZbbuG73/0u8+bNo2/fvvzqV7/i9ddf59e//jXvvPMOd9xxB6mpqfzP//wPW7du5brrrqOwsJCUlBQefvhhTjjhBLZt28all15KaWlpwI+l8847j0WLFimAxatnz54By+rq6qioqAj7etiCggJvAPXo0YMRI0aQnp4edNtgFQFwQi0jI4P+/fvTu3dv4uKaj4nKykq+/PJL73XM4JxH3rx5M7m5uUH3SUxMJD8/329Z47GcMzIymh3L2fcYrdnfTW4FsAXeMMZY4G/W2ocab2CMuRq4GmDw4MFNHuyGG2Dt2vYtYF4e3Htv09vccMMN/O53v/MbvSU9PZ0HHniA2bNnM2/ePA4fPhxWbaxnz54cd9xxrF+/niVLlvDd736Xxx9/3G+bGTNmYK3lyy+/5F//+lfAMT777DPy8vL8Bif3WL16NY8//jgrVqzAWsvkyZM59dRT6d27N5s3b+app57i4Ycf5jvf+Q7PP/88l19+OeD8yl25ciVLly7l9ttv56233uLRRx8lPT2djz76iKqqKqZOncqZZ57J559/zpIlS1ixYgUpKSkcOnSIPn368MADD3gD19fevXu56aabWL16Nb179+bMM89k8eLFnHfeeZSVlTFlyhR+/etf84tf/IKHH36YW265hTvuuIPXX3+dgQMHBp2qbNu2bfTu3dtvgPuVK1eyfv16UlJSmDhxIjNnziQjI4PNmzfzxBNPMGXKFJ5//nnWrl3LJ598woEDB5g4cSLTpk3jt7/9LRMnTuSUU07h+uuvZ+nSpQE15auvvpoHH3yQ4cOHs2LFCn784x/z9ttvM2/ePH70ox9x5ZVX8uc//9lvn/z8fG9rhwg4PzqNMQHNv5WVlWEHsGff9PR0cnNzmwzPUC0+EyZMCCt0fXl6c6ekpLB9+3bv8oMHD1JeXh71A2q0llv9xk+21o4HzgGuM8ZMa7yBtfYha22+tTY/MzOz40vYjJdffpl+/foxYcKEgHVnnHEGubm5XHfddS1qbr344ot5+umnWbx4Meeff37A+mXLlrF+/XrWrVvH3LlzKS0tDfvY7777Lueffz49evQgNTWVCy64gP/+97+AU0v2DKk3YcIEvz+gCy64IGD5G2+8wd///nfy8vKYPHkyBw8eZPPmzbz11lt873vf8/6x9enTp8kyffTRR0yfPp3MzEzi4uK47LLLvDXahIQE73lc3+eeOnUqs2fP5uGHHw64aB+cGkDjz8sZZ5xB3759SU5O5oILLuDdd98FYMiQId5WiXfffZdLLrmE2NhY+vfvz6mnnspHH33krdGeccYZzJ07l6FDh/odu7S0lPfff59vf/vb5OXlcc0111BQUADAe++9xyWXXALAFVdc4bdfv379/M6LixhjgrZ6tfRcblxcHKNHj25xiPru31pDhgwhLS3Nb5nn70ECuVIDttbuafh3vzHmRWASENiWGKbmaqqR8N577/HSSy+xdOlSKisrKS4u5vLLL+fJJ5+kvr6ejRs3kpKSwuHDh8PuxThr1ixuvPFG8vPzgzZHeQwdOpT+/fuzYcMGJk2a5F0+ZswYPvnkE+rq6oLWgkPxrS3GxsZSUVERsC42Npba2lrA+ZV9//33c9ZZZ/kd5/XXXw/7OZsTHx/vPe/l+9wPPvggK1as4JVXXvEOYuDbeSU5OTngkovG5888j8Ptpblu3Tr69u0bNDDr6+vp1asXa0M0wYQ6d1dZWRlyIH/pvuLi4gIu+fF89sM1aNAg16Y4NMbQv39/v1bBxueH5agOrwEbY3oYY9I894EzgfUdXY62+u1vf8vu3bvZvn07Tz/9NKeddhpPPvkkAH/84x8ZNWoU//znP/ne974XMMpNKCkpKdx9993cfPPNTW63f/9+tm3bxpAhQ/yWDx06lPz8fG699VZvU9T27dt55ZVXOOWUU1i8eLH3gvwXX3yRU045pRWvHM466yz++te/el/XF198QVlZGWeccQaPP/445eXlABw6dAhwOoE0HmQdYNKkSfznP//hwIED1NXV8dRTT3Hqqac2+dxbt25l8uTJ3HHHHWRmZgYM2TdixAi/GjzAm2++yaFDh6ioqGDx4sVBz7uecsopPPPMM9TV1VFYWMjy5cuZNGkSO3bs4A9/+AMff/wxr776akCP8p49e5Kdnc2zzz4LOD9OPvnkE8CprT/99NMALFq0yG+/L774gpycnCZfq3Q/wWqfjUeHas6AAQPaqzit0ri5ubS0tMWvobtwowbcH3ixoWYQB/zTWvuaC+WIiE2bNvHII4+wcuVK0tLSmDZtGnfeeSe33347v/jFL/jnP/9JeXk5gwYNYs6cOdx2221++1988cUhjz1jxgxiY2Opqanhrrvuon///gHbPPLII/z85z9n2LBhJCcnk5GRwe9//3vGjx/P7NmzvTXmOXPmMG7cuICwCsecOXPYvn0748ePx1pLZmYmixcv5uyzz2bt2rXk5+eTkJDAN77xDX7zm98we/Zsrr32Wm8nLI8BAwZw1113ec9tz5w5M2jPbl833ngjmzdvxlrL6aefztixY/3W9+jRg6FDh7JlyxaGDRsGOEF/4YUXsnv3bi6//HLy8/MDXvf555/PBx98wNixYzHG8Lvf/Y7+/ftzxhlnsGDBAo499lgeffRRZs+ezUcffeS376JFi/jRj37EnXfeSU1NDRdffDFjx47lT3/6E5deeil33313wOtatmwZM2fObOlbL1GuLZf/gNMC1N6137q6Oo4cOUJZWRllZWXU1NRQV1cX9BSQZ3tf9fX11NTUuFYr78xMW//DO0J+fr71XA/rsXHjxnYbpk2iy4svvsjq1au58847WbhwIatWreKBBx5wu1h+pk2bxpIlS4L2Ztdnu/MJNmpTr169wpqOsCVWrFjhdwoInJat4447Luj2jUfC6tevX7vNpFRSUsKuXbs4cOBAm2uwEydODOuUT+NezMccc0yLejG3df9IMMasttbmB1uny5Ak6px//vmtGsCgoxQWFvKzn/0saPhK9xbsfG9LOkW1xyQe9fX1bN26NWBozLZo6Xns7kIBLFFpzpw5AMyePZvZs2e7W5hGMjMzOe+889wuhnQy9fX1QYOqJU23benB7CnDhg0bAgYEaauu0NLqBgWwiEgnUFpaGjSoWtJbvq1jiXuanBtLTEykb9++pKene88zx8bGEhMTE3A9sWcoTGmeAlhEpBMINpxtbGxshw2lWF1dzY4dO/yWGWMYOnQoAwcODDvcQ3XOkkAKYBGRTiDY5AXp6ekdNkPWwYMHAzpbHX/88S2ejUnne8OnGZRFRFxWXl4etONgsBmSIsVz3b5HXFwcAwcObPFxGvfiltAUwK1UWVnJpEmTGDt2LGPGjOHWW29tdh9NR+jQdISajlD87d69O2BZTExMwLCqkdR4yMuePXu2aIYwj3BmhhOHAriVEhMTefvtt/nkk09Yu3Ytr732WsB1go1985vfZOXKlUHXeaYj9Ag1HeHatWt57rnnuP7664MeZ86cOfTp04fNmzd7J2Bo7x6NLdU4gB955JF2u1YxmNZMR9jS6xyvvfZarrzyypYWDfCfjlDk0KFDQYc57devHwkJCR1WjsYj9rWmR3VNTU3QSVI6SuPm+s7e+1oB3Eq+81DW1NRQU1ODMYaioiJGjhzJpk2bALjkkkt4+OGHAZgyZUrIYeI80xEC3ukIMzIygm7b3HSEd955p990hJ4Rl+655x5ycnLIycnh3oYBtLdv386oUaP44Q9/yJgxYzjzzDO9TUjTp0/npptuYtKkSYwYMcI7eUNdXR033ngjEydO5MQTT+Rvf/ubtwx33303ubm5jB07lvnz5/Pcc895pyPMy8ujoqKC6dOne2v2Tz31FLm5ueTk5HDTTTd5j5OamsrNN9/M2LFjmTJlCvv27QOcHyY5OTmMHTuWadMC5vAAnOkIPTXMhQsX8q1vfYvp06czfPhwbr/9du/rHjlyJFdeeSU5OTns2rWLG2+8kZycHHJzc3nmmWcAmDdvHnfccQfgjHU9bdo06uvrue2221iwYIH3fT/77LOZMGECp5xyCp9//jngzMx00kknkZubGzDzkWc6QuneKioq2LhxY8DymJgY7zSiHaXx+PHhDqHra8+ePa4OO9n4NXT2DmHR0QnLpfkI6+rqmDBhAlu2bOG6665j8uTJAJqOUNMRajpCadaBAwf4/PPPg3ZaGjp0aIcP3di4tl1cXNyiiV3KysrYuXNnJIoWtsa19s5+Plo14DaIjY1l7dq17N692/slD5qOUNMRajpCCa2kpISNGzeyfv36oOF7zDHHtKrzU1ulp6f7Pa6rqwt7rPjKykrWrVvn+qQLjYe7LCsrC5gdrTOJjhqwG/MR+ujVqxczZszgtddeIycnR9MRtgNNRyjRorq6mpKSEoqLizl8+HCTnZSOOeYYRo4c2YGlOyozM5Nt27b5Ldu1axcxMTFkZWWF/Czv27ePrVu3eqdRjI2Nda3pNz09PWAIzQ0bNjB8+PCAeYo7A9WAW6mwsNDbBFpRUcGbb77pHfRb0xFqOkLQdITRrqSkhFWrVgW9rVixgvfee4///Oc/vP/++6xbt44dO3aEDN/Y2FiGDx/OCSec0GHX/TaWkpISdIa1HTt28OGHH7JlyxYKCgrYv38/e/fuZcuWLaxYsYKNGzd6wzcmJiaglagjZWRkBDRDFxcXs3r1av773/+ycuXKoP9fbomOGrALCgoKuOqqq6irq6O+vp7vfOc7zJo1S9MRajpCTUfYTdTV1bXoNFAwngnss7OzO8V0fcOHD6ekpMT7I9qjqqoq6KVSvowxjBkzpkWtb+0tJiaGYcOGeTtC+qqrqwt4XW7TdIQSdTQdobS3YNMRtkVaWhqZmZn079+/TcHbeDrCrKwssrKy2lS2qqoqPvvssxZdz5uQkMDo0aPp1atX0LGg8/Ly6NWrV7PHaa/pBAsKCtiyZUvYTeHTp09v8XOES9MRSrei6QjFbZ5JCuLj40lISCApKYnk5GRSU1NJT09vl2kDIyUxMZG8vDwKCgrYtWtXk52YkpKSGDBgAAMHDmzzTEztacCAAWRmZnLgwAEOHz5MWVkZVVVV3hbLzkI1YJFORp9t6UzKy8spKSmhurqa+vp6YmJiSExMJDU11XvFg4SmGrCIiLRKSkqKgjZC1AtaRETEBQpgERERFyiARUREXKAAbqVdu3YxY8YMRo8ezZgxY/jTn/7U7D4PPPAAw4YNwxjjN0PRwoULMcbw1ltveZctXrwYYwzPPfcc4HSTHzlyJHl5eYwaNYqHHnoo6HPU1NQwf/58hg8fzvjx4znppJN49dVX2/hq22bx4sV+0w/+6le/8nut7a2iooJTTz01oqPxvPTSS9x1110t2icrK4sDBw5QXV3NtGnTNHG5SDenAG6luLg4/vCHP7BhwwY+/PBD/vznPzc7x+3UqVN56623AkawgsDpCJ966qmAQSYWLVrE2rVree+997jpppu8o8/4+r//+z8KCgpYv349a9asYfHixUFHoepIjQP4jjvu4Otf/3rEnu+xxx7jggsuaNGAAC0N63PPPZf58+e3tGiAc83k6aef7p1xSUS6JwVwKw0YMIDx48cDzkX1o0aNYs+ePdTW1jJx4kTvBfK//OUvvUNLjhs3LuRF8qeccgorV66kpqaG0tJStmzZ4p0gobHS0lJ69OgREDDl5eU8/PDD3H///d6L+/v37893vvMdoOVT/82ePZvrr7+er33taxx//PHe2jjA73//e+90hLfeeqt3+d///ndOPPFExo4dyxVXXMH777/PSy+9xI033kheXh5bt25l9uzZ3mP9+9//Zty4ceTm5vL973/fOyl4VlYWt956K+PHjyc3N9c7ss1//vMf8vLyyMvLY9y4cUF/XCxatMg78tQ777zDtGnTmDlzJiNHjuTaa6/1XgeYmprKz3/+c8aOHcsHH3wQdLrGP/7xj3z/+98HnDGhc3JyKC8vZ+HChcydOxdwruu98MILmThxIhMnTvTO83vw4EHOPPNMxowZw5w5c/zmJtV0hCISFZch3fDaDaz9am27HjPvmDzuPfvesLbdvn07H3/8MZMnTyYuLo6FCxdy0UUXcf/99/Paa68FjB8cjDGGr3/967z++usUFRVx7rnnBgyMftlll5GYmMjmzZu59957AwJ4y5YtDB48OOhEDq2Z+g+cEWXeffddPv/8c84991wuuugi3njjDTZv3szKlSux1nLuueeyfPly+vbty5133sn7779PRkaGdzrCc889l1mzZnHRRRf5lamyspLZs2fz73//mxEjRnDllVfy17/+lRtuuAFwxnVds2YNf/nLX1iwYAGPPPIICxYs4M9//jNTp06ltLSUpKQkv2NWV1fz5Zdf+v3QWblyJRs2bGDIkCGcffbZvPDCC1x00UWUlZUxefJk/vCHP4ScrnHevHlMnz6dF198kV//+tf87W9/C7gkY968efz0pz/l5JNPZufOnZx11lls3LiR22+/nZNPPplf/epXvPLKKzz66KPefXJycgKGtBSR7kU14DYqLS3lwgsv5N577/UG35gxY7jiiiuYNWsWjz32WMA8m6F4piN8+umnvdPY+Vq0aBGffvopO3fuZMGCBezYsSPscrZm6j9wamoxMTGMHj3aWzN+4403eOONNxg3bhzjx4/n888/Z/Pmzbz99tt8+9vfJiMjA2h+OsJNmzaRnZ3NiBEjALjqqqu8ZYLgUyFOnTqVn/3sZ9x3330cOXIkYPSdAwcOBAx5N2nSJI4//nhiY2O55JJLvNMRxsbGcuGFFwKhp2uMiYlh4cKFXHHFFZx66qlBJ3J46623mDt3Lnl5eZx77rkUFxdTWlrK8uXLvfMqz5w502/kq9jYWBISElw/PSAi7omKGnC4NdX2VlNTw4UXXshll13mDQuPdevW0atXL/bv3x/28SZNmsS6detISUnxhlIwmZmZjB8/nhUrVvidTx42bBg7d+6kuLi4yekMGws19R/4T1XoaUK11vLLX/6Sa665xu84999/f9jPGY5gUyHOnz+fmTNnsnTpUqZOncrrr7/uN1ZsS6YjTEpKCus88ebNm0lNTQ05f299fT0ffvhhQG28OVVVVS3eR0Sih2rArWSt5Qc/+AGjRo3iZz/7md+6F154gUOHDrF8+XJ+8pOfeKctDMddd93Fb37zmya3KS8v5+OPPw6Y9islJYUf/OAHzJs3z9tBq7CwkGeffbZVU/+FctZZZ/HYY495Z4LZs2cP+/fv57TTTuPZZ5/1jsPc3HSEI0eOZPv27WzZsgWAf/zjH2FNR5ibm8tNN93ExIkTA2Y96d27N3V1dX4hvHLlSrZt20Z9fT3PPPMMJ598csBxQ03XWFRUxPXXX8/y5cs5ePCg33lwjzPPPNPvx4dnIPpp06bxz3/+E4BXX32Vw4cPe7c5ePAgGRkZnXpMYBGJLAVwK7333nv84x//4O233/Z2Clq6dCkHDhxg/vz5PPLII4wYMYK5c+cyb948AO677z4GDRrE7t27OfHEE5kzZ07Acc855xxmzJgR9Dkvu+wy8vLymDBhArNnz2bChAkB29x5551kZmYyevRocnJymDVrFj179vSb+m/s2LFMmDCh2an/QjnzzDO59NJLOemkk8jNzeWiiy6ipKSEMWPGcPPNN3PqqacyduxY7w+Tiy++mN///veMGzeOrVu3eo+TlJTE448/zre//W1yc3OJiYnh2muvbfK57733XnJycjjxxBOJj4/nnHPOCVo+TzMzwMSJE5k7dy6jRo0iOzub888/P2Af3+kaJ0+e7J2u8ac//SnXXXcdI0aM4NFHH2X+/PkBrRr33Xcfq1at4sQTT2T06NE8+OCDANx6660sX76cMWPG8MILLzB48GDvPpqOUEQ0GYNEnTVr1vDHP/6Rf/zjH7zzzjssWLCAl19+2e1i+bngggu46667gp5q0GdbJHo0NRmDasASdcaPH8+MGTMiOhBHW1RXV3Peeec1eZ5fRKKfasAinYw+2yLRQzVgERGRTqZLB3BXqL2LtIQ+0yLdR5cN4KSkJA4ePKgvLIka1loOHjyoa4NFuokuOxCH53KewsJCt4si0m6SkpIYNGiQ28UQkQ7gSgAbY84G/gTEAo9Ya1s2rxvO6E3Z2dntXjYREZGO0OFN0MaYWODPwDnAaOASY8zoji6HiIiIm9w4BzwJ2GKt/dJaWw08DbRuSCYREZEuyo0AHgjs8nm8u2GZiIhIt9FpO2EZY64Grm54WGWMWe9mebqZDOCA24XoRvR+dyy93x2ru7/fQ0KtcCOA9wDH+Twe1LDMj7X2IeAhAGPMqlAjiUj70/vdsfR+dyy93x1L73dobjRBfwQMN8ZkG2MSgIuBl1woh4iIiGs6vAZsra01xswFXse5DOkxa+1nHV0OERERN7lyDthauxRY2oJdHopUWSQovd8dS+93x9L73bH0fofQJWZDEhERiTZddixoERGRrqxTB7Ax5mxjzCZjzBZjzHy3yxPNjDHHGWOWGWM2GGM+M8bMc7tM3YExJtYY87Ex5mW3yxLtjDG9jDHPGWM+N8ZsNMac5HaZopkx5qcN3yXrjTFPGWM0y0gjnTaANWRlh6sFfm6tHQ1MAa7T+90h5gEb3S5EN/En4DVr7QnAWPS+R4wxZiBwPZBvrc3B6XB7sbul6nw6bQCjISs7lLW2wFq7puF+Cc6Xk0YoiyBjzCBgJvCI22WJdsaYdGAa8CiAtbbaWnvE1UJFvzgg2RgTB6QAe10uT6fTmQNYQ1a6xBiTBYwDVrhclGh3L/ALoN7lcnQH2UAh8HhDk/8jxpgebhcqWllr9wALgJ1AAVBkrX3D3VJ1Pp05gMUFxphU4HngBmttsdvliVbGmFnAfmvtarfL0k3EAeOBv1prxwFlgPqVRIgxpjdOi2U2cCzQwxhzubul6nw6cwCHNWSltB9jTDxO+C6y1r7gdnmi3FTgXGPMdpzTK6cZY550t0hRbTew21rradV5DieQJTK+Dmyz1hZaa2uAF4CvuVymTqczB7CGrOxAxhiDc35so7X2HrfLE+2stb+01g6y1mbhfLbfttaqhhAh1tqvgF3GmJENi04HNrhYpGi3E5hijElp+G45HXV6C9BpZ0PSkJUdbipwBbDOGLO2Ydn/NoxaJhINfgIsavhB/yXwPZfLE7WstSuMMc8Ba3CusPgYjYgVQCNhiYiIuKAzN0GLiIhELQWwiIiICxTAIiIiLlAAi4iIuEABLCIi4gIFsIiIiAsUwCJdjDGmrzFmbcPtK2PMnob7pcaYv0ToOW8wxlzZxPpZxpg7IvHcItFK1wGLdGHGmNuAUmvtggg+RxzOgArjrbW1IbYxDdtMtdaWR6osItFENWCRKGGMmW6Mebnh/m3GmCeMMf81xuwwxlxgjPmdMWadMea1hnG/McZMMMb8xxiz2hjzujFmQJBDnwas8YSvMeZ6Y8wGY8ynxpinAazzS/4dYFaHvFiRKKAAFoleQ3HC81zgSWCZtTYXqABmNoTw/cBF1toJwGPAr4McZyrgO2vTfGCctfZE4Fqf5auAU9r9VYhEqU47FrSItNmr1toaY8w6nPHUX2tYvg7IAkYCOcCbTgsysThztzY2AP+B9D/FGVN5MbDYZ/l+nKnnRCQMCmCR6FUFYK2tN8bU2KMdPupx/vYN8Jm19qRmjlMBJPk8nglMA74J3GyMyW1onk5q2FZEwqAmaJHuaxOQaYw5CZz5oI0xY4JstxEY1rBNDHCctXYZcBOQDqQ2bDcCWB/xUotECQWwSDdlra0GLgLuNsZ8Aqwl+KTpr+LUeMFppn6yoVn7Y+A+a+2RhnUzgFciWWaRaKLLkESkWcaYF4FfWGs3h1jfH/intfb0ji2ZSNelABaRZhljRgL9rbXLQ6yfCNRYa9d2aMFEujAFsIiIiAt0DlhERMQFCmAREREXKIBFRERcoAAWERFxgQJYRETEBf8fsGMQKJ8fmo8AAAAASUVORK5CYII=\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -350,47 +300,17 @@
     "    error_bars_y=False,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOExS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
-      "output/TIExS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -403,47 +323,17 @@
     "    error_bars_y=False,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOExEyS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
-      "output/TIExEyS0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -456,56 +346,26 @@
     "    error_bars_y=True,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### More than 2 connections evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### More than 2 connections evaluation"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
-      "output/OES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -516,47 +376,17 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n",
-      "output/OES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -567,56 +397,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Mixed Performance Evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Mixed Performance Evaluation"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n",
-      "output/OES0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -627,56 +427,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Eventful Evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Eventful Evaluation"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n",
-      "output/TIEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAFNCAYAAADYVrylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAA06UlEQVR4nO3deXxU9b3/8dcnIQshELYIYZEgUhAIoETFKhpFFLdaq8VS24pttVeUqu11abWitvaiba1LrRavirfV4l5b12p/olVrKyCyiqiAsgcMJGxZv78/vpN9m4TMnMnM+/l4zGNmzpwz853JZN7nu5zvMeccIiIiEl1JQRdAREQkESmARUREAqAAFhERCYACWEREJAAKYBERkQAogEVERALQJegChKNv374uNzc36GKIiIi0yaJFi7Y757KbeqxTBHBubi4LFy4MuhgiIiJtYmbrm3tMTdAiIiIB6BQ14Fi3YMEC3njjjUbLTzjhBAoKCqJfIBERiXkK4A5QUFBAQUEB8+bNA2DGjBmBlkdERGKfAlhikloVRCTeKYAlJqlVQUTinQZhiYiIBEABLCIiEgAFsIiISADirg9Yg3dEJFr0eyMHIu4CWIN3RCRa9HsjB0JN0CIiIgFQAIuIiAQg7pqgpeOpn0tEpOMpgKVV6ucSEel4aoIWEREJgAJYREQkAGqCFhGRhBbUOBcFsIiIJLSgxrmoCVpERCQAqgGLSMToEDaR5imARRJEEGGoQ9hEmqcAFkkQCkOR2KIAbqOqKti0Cdatg7Vra6/XroVPPvkKZ565FP2uiYhIaxTADTgH27bVD9a6Ybt+PZSV1d8mJwdyc6GqyrjvvgIGDIDrrwez6Jdf2kd9lSISbQkXwM5BUVHjYK0btvv21d+mb18YOhTGj4dzzvG3c3P99cEHQ9eufr0HHvgb8+Z9mZ/97FA+/BD+938hPT2qb0/aSc2zIk1bsGABr7zyLxYvnsCuXVlMnPgvevXapZ3TDhC3AbxtWyYbN/Zi167GYVtcXH/drCwfpiNHwtSp9QM2NxcyM8N7zZSUKr7//bc444xDuf56/3rPPgsHHdSx701EYkNFBbz0Etx990msX9+bFSvg8sthyJCgS9YxNm2Cl18u4L77CiguhuTkKpYsOZqrroIjjgi6dJ1f3Abwiy/m8cYbIwDIyPBhOnQoHH987e3qkO3Zs+Ne1wx++lP40pfgO9+Bo4+Gv/0NxozpuNeQA1dZ6VtCtm+HHTtqr19+eQxmjrw8OPxwSNKR8tKEDz+Ehx+G//s/2LIFevTIZsiQHfz2t5nccQd89atwxRUwaVLn7IpatQp+/Wv44x/9/8p558HIkX+jR499fPDBNObMgYcegp//HL77XegSt0kSWXH7sZ1yykqOP34Ns2adSd++0f8nOO88vxf8la/Al78MTzzha9fS8SoqGodpw2BtuKyoyHdHNJYP+L9Xdjaceqq/nHKKWjISXUmJ/1489BC88w4kJ8OZZ/oA2rbtCbp0cUyePIN774W5c+GZZ/xO3BVXwDe+AWlpQb+D1r39Ntx+O/z1r7777OKL4ctffpePP34FgN27Ydiwm7n44hzefXcaP/hBT+65B37zG/8/Im0TtwE8YMAuwP+IBuXII+E///EhfMYZcOedMGtWcOXpLCoqYOtW3/y1ePFgSkrS2bKl+WAtKmr+udLTfR9+377Qp4/vs6++Xfe6+vbLL/+J0tIu9O79DV5+GV5+Gf70J/9cEyb4naipU2HiRO31JwLnfCg99JAP3z17fFfVr34F3/oW9O/v15s3z+/NDR4Mc+bAjTf6781dd8GMGXDNNfBf/wWXXlq7TayoqvKtdLff7ncseveG2bPhssuqfz8nhi71Oed3Mq65xu+knnaarzWPGhXtd9B56SckwgYPhn/+Ey64AH74Q1i92gdxIv54O+dDc9Mm2LjRX1df6t7futX/KHiTa7bPyKgfmrm59cOzqUDNyGhbGdPSKkhLq+Bb3/I/sFVVsHgxvPKKD+M5c+DWW/24gZNP9mF86qn+7xzLKithzRpYtgyeeeZwysqSKS31YTJiBPTr1zmbSiNl0ybfvPzQQ/5zy8yE6dN9bXfixNY/q4wMuOQSX4N87TUfxLfcAv/zP3D++XDllX6HLkilpb6J+de/9r9Lublwzz1w0UXQrVvr25vBuef6VoDf/c43R48d69/3zTcHW/npLBIwBqIvM9PvKf7kJ37Pec0avzedlRV0yTpOSUnLobpxI2ze3PgQLvBhOXAgDBjgR5pX3x4wABYt8v1Ol146rWa0eTQlJUF+vr9cfz3s3An/+Ac1teOnn/brjR5dWzs+7rhgR78XFsLSpf6ybJm/XrEC9u/3j5vl0aVLFa+8UrtNjx4+iKsDufoyfHjnGsl/IIeTlZXB88/70H3pJb/zdfzx/u9+3nnhhVJDZjBlir+sWeMD7uGHfe342GN98/Q550R3h3znTrj/fr9TsGWLbyb/85/9e2xPOdLS4Mc/hgsv9MF7333w6KNwww2+0tEZmt6r7d6dyhdftOMP3U4R+7ObWTrwJpAWep2nnHOzzWwoMB/oAywCvu2ca+JnOb4kJ/smnhEjfFPUMcf4f/ZDDgm6ZOHbtSud997LZeXKxgG7e3fj9bt3rw3TSZP8dd1wHTjQN8e19A+6Y8cOgIiHb8Mf7ptvvhlo/MPds6ff6z/3XF+jX7myNoyr+8IyMuDEE33NeOpUOPTQpmtMB3rs8f79frBM3aBdutS3IFTr1w/y8mDmTF87GTsWFi58lOTkSk4+eQarV/sBRatX+8uCBb5WVM3M14zqhnJ1SOfkxF6tuT2Hk61Y4UP3j3/0Oy8DBsC11/qa4PDhHVe24cPh7rt9TfHhh/33Zdo033py2WW+tty7d8e9XkMbNvjWtz/8wf+/Tpni3/PkyR3zd+zb17+nmTPh6qt90/R998Ftt/lwj7XvSrWiIvjLX3yl6NVXv0H//ru48cbovHYk97tKgZOcc7vNLAV4y8xeAn4E/NY5N9/M7ge+B9wXwXLElO99D4YNg699zY+QfvZZX2OKZdu3+5r7nXeeS1lZCqmptQE6bpzv+2kYrDk5PoA7i+of7rYw8zXf0aN9DWDPHnjjjdpAfuEFv94hh9TWjk88sfawtnDDwjn47LPGQfvRR75pGfxOzOjR/m8xdqwP3bw8H8ANffCB3+jgg/1lypT6j+/Z45+7OpSrQ/qf//SPVeve3Y/2b6rW3Nam/2jbtQvmz/fB+5//QEqKH6vx3e/6wUSRrJFmZfkm6Fmz/E74XXfBddf52uN3vuNrjR3Zj7p8uW9mfvRR/106/3z47//2Nd9IOOww/75efdX/X0yb5mv7d9wBRx0Vmddsq+rQffJJ30VQXu53NE85ZQVHHrkO586Kyg5DxL5mzjkHVNeLUkIXB5wEfDO0/BHgJhIogAEKCuDf//Z9J5MnwwMP+H+8WFNU5Gt0d93lf3iPPvozzjprKT/5yTkxuzcbpG7d4PTT/QXgk09q+44feQR+/3v/Qz9pUm0gNzw8rbjY/2A2bEKue+x6bq4P2a99rbZWe+ihHRca3br5H+eGP9DO+VaPhrXmt96Cxx6rHVVu5oO9biivW5dDjx772LTJ980H0SxZVQVvvgkPPui7Dvbt85//b3/rx2hEu88yORnOPttfli71teN583wNdcoU3zx92mntOxTOOf9eb78dXnzR7xDNnAlXXeW/P9EwZQq8/77fybnhBl/huOAC+OUv/fcj2oqK4LnnfE23buheeaXfSZgwAR55ZBEQvdp6RHsezCwZ38x8KHAv8Amw0zlXEVplAzAwkmWIVcOHw7/+5ZtmLrzQ/5D9/OexcdxpcbFvqrrjDl9TOO88uOkmeO+9fwKx25QUa4YN8z96M2f6AS9vv10byNdc4y8DBkBu7nHs3ZvKzTf7iWKq9ejhw/WCC2qDdswYvzwIZjBokL9Mnlz/sb17fR9nw1rzww9Xd0+cClDTtNe9e+MBc00Noqt7u72h/fnnfgfo4Yfh00/953fhhb62m58fG9/nsWP9zHlz5vhDmO691++gDx/ua8ozZtS2KLXUdTFpUgF/+YsP3v/8x+9U/PznfvR1nz5RfUuA38m4+GJ/GNacOX6H/umnfc342msj30pWHbpPPulr5OXl/vDQK6+Er389+L9/RAPYOVcJjDeznsCzwMhwtzWzS4BLAA4OYncpCnr39j/IM2f6vcLVq/3Iy6Ca73bv9qMZf/Ur+OILv2d+882+mRngvfeCKVc8SEuDk07yl9tu8zXJv/+9url6IJmZpUya5H+sqpuQDz44NsIhHBkZ/ntS/V2p5pwffHfPPS9RUpJOXt6JTR6b/dFH/nbDWerqysxsOaDrXu/YkcGnn2Yzf77/nJ3zn/0tt/hBT7HaRN63r5/I5+qr4amnfOvTD3/oa5Df+56fZauprot9+/xOxsUXw8cf+52/++7zOxpBDF5sqHt3f/TAJZf493frrb4l4he/8DsXyckd91o7d9bWdKtD9+CDfYvC17/uDw+Nlf+rqIy9c87tNLPXgWOAnmbWJVQLHgRsbGabucBcgPz8/CanTIgHKSl+j/eww3y/zPr1/iD4nJzmt+noEwfs2+f/WefM8YNQTjvN/1Dl57f5qSRMAwf6QT4XXQTz5j0OxOf802a+lj9ihB8Z1tpbLCvzO3/NTaBS9/bHH/vrXbuaeqZpgB/g9LOf+dcdOrQj31lkpaT4w56mT/fdVXfd5Qc43Xmn76u+4gq/U7FnTyq/+IVvvi4s9OHy5JN+J6MjQ62jDBni+6JnzYIf/Qi+/31f9jvuaNyq0hbVofvkk36Hqzp0f/hD37wcS6FbVyRHQWcD5aHw7QpMAW4DXgfOw4+EvhB4LlJl6CzM/Jdx+HD/D3fUUT6Emxsk0VEnDigt9eH/y1/6wxFOPtkH7zHHtO99iByo1FQ/Mr4tk1WUl9eGdnVA//Wv75CdXcKcOafGZBC1xdFH+z72X/3K7yjff78PmwEDvsqOHd0oLfXjDq6+Gk44ITaDpqGJE32XzJNP+qbok0/2Te6/+pUf1BdOJWPnTv87+cQTtaE7eLAP3a9/3f+OxvpnEckacA7wSKgfOAl4wjn3vJmtBOab2S+A94EHI1iGTuWss/yX8qyz/Mjoxx7zzcAdrazM94f94hf+0ITjj/cjQk84oeNfSyTSUlL8aO+6I76Liz8CYrMW2F4DB/r/2euv978Nt91WSm7udu6//1Dy8oIuXduZ+drpV77ia/i33uq7Xi69FGbPbrqSsWuXP3SqOnTLynzozprlQ/foo2M/dOuK5CjopUCjOpxz7lMgRgajx55x43yT09ln+2ak227zTdMd8aWqqPBf3ltu8YN9Jk70QdxRxwGKSOR17er7g5OTXwIgL+/QgEt0YNLTa4+7nj3bD0D74x9910GPHkmUlSXzxz/62vIrr9SG7uWX19Z0Y2HwantoJqwYlJPjjyetnkP2ww9901Nqavuer7LS13BvvtmPVJ0wwR8SM3WqgjdI4U7+0VlfT6QtDjrI/85dfrkfJf3jH0PPnueye3c6FRV+9P1ll9XWdDtr6NalAI5RXbv66eFGjPCHEXzyiR++35ZDCaqq/EjKm27yMyaNHesPPv/KVxS8saA9k390ptcTaY/Ro2sns7nmmiJycnZx002j4yZ061IAx7CkJN9cPGJE7STwzz/v77fEOT9IY/Zsf4D/YYf5PpNzz42/L7BIokmUloypU2HLltcAOOaY0QGXJjIUwJ3ABRf4GVvOOceH8NNP+2MaG3LOTyJ/442waJEfVf2nP/mD4ONpMIpIcxIhnNSSET8UwJ3EscfWTl956qm10xqCD95//MMPWnj3XX+848MP+9PpJeJpDyVxRTucEiHwJXLi7uc5iH+IaL3m0KH+hNnf+IafUebUU/MZP34DBQV+3tfBg/08sjNmtH/AloiET7XRyEiUHZu4C+Ag/iGi+ZpZWfC3v/mJO+65ZwyvvDKGnBw/S87FF3euc2+KiDQlUXZs4i6AE0GXLn76tn37/sm+fSk88MDEmJjvVUSkMwqqxq0A7sSOPfYTALp2nRhwSUREOq+gatw6KEVERCQAqgGLSMQkymAakfZQAItIxCTKYBqR9lATtIiISABUA5ZWqRlRRKTjKYClVWpGFBHpeApgiUmqdYtIvFMAS0xSrVtE4p0GYYmIiARANeBOSM2zIiKdnwK4E1LzrIhI56cmaBERkQAogEVERAKgABYREQmAAlhERCQACmAREZEAKIBFREQCoAAWEREJgAJYREQkAApgERGRACiARUREAqAAFhERCYACWEREJAAKYBERkQBELIDNbLCZvW5mK81shZldEVp+k5ltNLMlocvpkSqDiIhIrIrk6QgrgB875xabWXdgkZm9Gnrst865X0fwtUVERGJaxALYObcZ2By6XWJmq4CBkXo9ERGRziQqfcBmlgscDvw7tOhyM1tqZg+ZWa9olEFERCSWRDyAzSwTeBq40jlXDNwHDAPG42vIv2lmu0vMbKGZLSwsLIx0MUVERKIqogFsZin48H3UOfcMgHNuq3Ou0jlXBTwAHNXUts65uc65fOdcfnZ2diSLKSIiEnWRHAVtwIPAKufcHXWW59RZ7RxgeaTKICIiEqsiOQr6WODbwDIzWxJa9lNgupmNBxywDvhBBMsgIiISkyI5CvotwJp46MVIvaaIiEhnoZmwREREAqAAFhERCYACWEREJAAKYBERkQAogEVERAKgABYREQmAAlhERCQACmAREZEAKIBFREQCoAAWEREJgAJYREQkAApgERGRACiARUREAqAAFhERCUCrpyM0syRgHDAA2Acsd85ti3TBRERE4lmzAWxmw4BrgZOBNUAhkA58ycz2An8AHnHOVUWjoCIiIvGkpRrwL4D7gB8451zdB8zsIOCbwLeBRyJXPBERkfjUbAA756a38Ng24M5IFEhERCQRtDoIy8y+bmbdQ7d/ZmbPmNkRkS+aiIhI/ApnFPTPnHMlZnYcMBl4EN80LSIiIu0UTgBXhq7PAOY6514AUiNXJBERkfgXTgBvNLM/AOcDL5pZWpjbiYiISDPCCdJpwCvAqc65nUBv4OpIFkpERCTetRrAzrm9wDrgNDObBeQ45/4e6YKJiIjEs3BGQd+IP9a3D9AXeNjMboh0wUREROJZq1NRAhcA45xz+wHMbA6wBD9Rh4iIiLRDOH3Am/BTUFZLAzZGpjgiIiKJIZwa8C5ghZm9CjhgCvAfM7sbwDn3wwiWT0REJC6FE8DPhi7VFkSmKCIiIomj1QB2zj1iZqnASHwNeLVzriziJRMREYlj4ZwP+HT8qQc/AQwYamY/cM69FOnCiYiIxKtwmqDvAE50zn0MNecJfgFQAIuIiLRTOKOgS6rDN+RToCRC5REREUkIzdaAzexroZsLzexF4Al8H/DXgfdae2IzGwz8H9AvtN1c59xdZtYbeBzIxc+wNc05V3QA70FERKTTaakGfFbokg5sBU4ACoBC6h8X3JwK4MfOuVHAROAyMxsFXAf8wzk3HPhH6L6IiEhCabYG7Jy76ECe2Dm3Gdgcul1iZquAgcDZ+CAHP8XlAuDaA3ktERGRzqalJui7W9qwLRNwmFkucDjwb6BfKJwBtuCbqEVERBJKS6Og/wtYju/73YQ/BKnNzCwTeBq40jlXbFb7NM45Z2aume0uAS4BOPjgg9vz0iIiIjGrpQDOwQ+4Oh/fn/s48FTonMBhMbMUfPg+6px7JrR4q5nlOOc2m1kOsK2pbZ1zc4G5APn5+U2GtIiISGfV7CAs59wO59z9zrkTgYuAnsBKM/t2OE9svqr7ILDKOXdHnYf+ClwYun0h8Fx7Ci4iItKZhTMT1hHAdPxJGF4CFoX53McC3waWmdmS0LKfAnOAJ8zse8B6YFobyywiItLptTQI6xbgDGAVMB/4iXOuItwnds69RfP9xpPbUkgREZF401IN+AZgLTAudPllaACV4cdPjY188UREROJTSwE8NGqlEBERSTAtBfBnzrkWRx+bmbW2joiIiDTW0lSUr5vZLDOrdxCumaWa2Ulm9gi1o5lFRESkDVqqAU8Fvgv82cyGAjvxc0AnA38H7nTOvR/xEoqIiMShluaC3g/8Hvh9aEKNvsC+tkzEISIiIk1r9ThgAOdcOaETK4iIiMiBa6kPWERERCJEASwiIhKAVgPYzG4LZ5mIiIiEL5wa8JQmlp3W0QURERFJJC3NBX0pMBM4xMyW1nmoO/B2pAsmIiISz1oaBf0Y/uxH/wNcV2d5iXPui4iWSkREJM61dBzwLmCXmV3b4KFMM8t0zn0W2aKJiIjEr3COA34BcPizIKXjT9KwGhgdwXKJiIjEtVYD2DmXV/e+mR2B7xsWERGRdmrzccDOucXA0REoi4iISMJotQZsZj+qczcJOALYFLESiYiIJIBw+oC717ldge8TfjoyxREREUkM4fQB3wxgZj38XVcS8VKJiIjEuXCmosw3s2XAUmCZmX1gZvmRL5qIiEj8CqcJ+iFgpnPunwBmdlxo2dhIFkxERCSehTMKurI6fAGcc2/h+4JFRESkncKpAb9hZn8A/oyfkON8YEHoeODqw5JERESkDcIJ4HGh69kNlh+OD+STOrREIiIiCSCcUdAnRqMgIiIiiSSciTjSgHOB3LrrO+duiVyxRERE4ls4TdDPAbuARUBpZIsjIiKSGMIJ4EHOuakRL4mIiEgCCecwpHfMLK/11URERCRczdaAQ7NfudA6F5nZp/gmaMNPSamJOERERNqppSboM6NWChERkQTTbAA759YDmFnvJh7WCRlEREQOQDh9wIuBQuAjYE3o9jozW2xmE5rbyMweMrNtZra8zrKbzGyjmS0JXU4/0DcgIiLSGYUTwK8Cpzvn+jrn+gCnAc8DM4Hft7DdPKCp0dO/dc6ND11ebGuBRURE4kE4ATzROfdK9R3n3N+BY5xz7wJpzW3knHsT+OLAiygiIhJ/wgngzWZ2rZkNCV2uAbaaWTJQ1Y7XvNzMloaaqHs1t5KZXWJmC81sYWFhYTteRkREJHaFE8DfBAYBfwldDg4tSwamtfH17gOGAeOBzcBvmlvROTfXOZfvnMvPzs5u48uIiIjEtnBOxrAdmNXMwx+35cWcc1urb5vZA/i+ZBERkYQTzskYXsdPyFGPc67NpyE0sxzn3ObQ3XOA5S2tLyIiEq/CmQv6v+vcTsefGamitY3M7M9AAdDXzDbgzydcYGbj8YG+DvhB24orIiISH8Jpgl7UYNHbZvafMLab3sTiB8MtmIiISDwLpwm67kxYScAEICtiJRIREUkA4TRBL8I3GRu+6Xkt8L1IFkpERCTehdMEPTQaBREREUkk4TRBpwCXAseHFi0A/uCcK49guUREROJaOE3Q9wEp1M77/O3Qsu9HqlAiIiLxLpwAPtI5N67O/f9nZh9EqkAiIiKJIJypKCvNbFj1HTM7BKiMXJFERETiX7gTcbxuZp/iR0IPAS6KaKlERETiXIsBHDrj0ThgODAitHi1c6400gUTERGJZy02QTvnKoHpzrlS59zS0EXhKyIicoDCaYJ+28x+BzwO7Kle6JxbHLFSiYiIxLlwAnh86PqWOssc0OazIYmIiIgXzkxYJ0ajICIiIokknJmw0vCnIMytu75z7pbmthEREZGWhdME/RywC39SBg3AEhER6QDhBPAg59zUiJdEREQkgYQzE9Y7ZpYX8ZKIiIgkkGZrwGa2HKgKrXNRaCasUvxsWM45NzY6RRQREYk/LTVBD6T2ECQRERHpQC0F8Frn3PqolURERCSBtBTAB5nZj5p70Dl3RwTKIyIikhBaCuBkIBPf5ysiIiIdqKUA3qzJNkRERCKjpcOQVPMVERGJkJYCeHLUSiEiIpJgmg1g59wX0SyIiIhIIglnJiwRERHpYApgERGRACiARUREAqAAFhERCYACWEREJAAKYBERkQAogEVERAIQsQA2s4fMbFvovMLVy3qb2atmtiZ03StSry8iIhLLIlkDngdMbbDsOuAfzrnhwD9C90VERBJOxALYOfcm0HA2rbOBR0K3HwG+GqnXFxERiWXR7gPu55zbHLq9BejX3IpmdomZLTSzhYWFhdEpnYiISJQENgjLOecA18Ljc51z+c65/Ozs7CiWTEREJPKiHcBbzSwHIHS9LcqvLyIiEhOiHcB/BS4M3b4QeC7Kry8iIhITInkY0p+BfwEjzGyDmX0PmANMMbM1wMmh+yIiIgmnS6Se2Dk3vZmHJkfqNUVERDoLzYQlIiISAAWwiIhIABTAIiIiAVAAi4iIBEABLCIiEgAFsIiISAAUwCIiIgFQAIuIiARAASwiIhIABbCIiEgAFMAiIiIBUACLiIgEQAEsIiISAAWwiIhIABTAIiIiAVAAi4iIBKBL0AUQERFpyq5duygsLKS4uJj9+/dTUVFBVVVVvXXGjBlD3759AyrhgVEAi4hITCktLWXVqlXs3Lkz6KJElAJYRKQV+/fv59133w1rXTMjKSmJpKQkunTpQmpqKunp6WRkZJCZmUmPHj1ISUmJcIk7r7KyMhYtWkRZWVnQRYk4BbCISAdyzlFZWUllZSXl5eXs27ePXbt21VsnMzOTgw46iH79+pGWlhZQSWPT6tWrmwzf5ORk0tLSSEpKarS82rvvvsv+/ftr7vfv35+RI0dGrrAHSAEsIhJlu3fvZvfu3axdu5aDDjqIoUOHkp6eHnSxArd371527NhRb1nXrl0ZMWIEWVlZmFlAJYsMBbCISDskJyfTtWvXJh+rqKigsrKSiooKnHPNPodzjq1bt1JYWMghhxzCoEGDIlXcTmH79u2Nlo0ZM4Zu3boFUJrIUwCLiLRD9+7dGT9+fKvrlZWVUVxcTElJCUVFRRQXFzdap6qqio8//pji4mIOO+ywuKvphaukpKTe/W7dusVt+IICWEQkolJTU+nbty99+/Zl6NChlJSUsGHDBrZu3dpo3W3btgEwatSoaBczJtTtvwXIyMgIqCTRoYk4RESiqHv37hx22GHk5eU1ORp627ZtfP755wGULHiVlZX17jcccBVv4vvdiYjEqD59+jBhwoQmQ3jt2rWNaoOJoOEkG/HeFK8maBGRgKSnpzNq1CiWLl1ab7BWVVUVa9eu5bDDDuuQ19m7dy979uyhtLSUyspKzIzU1FT69+8f1valpaXs3bu33mxUycnJpKSkkJaWRo8ePeK+thoJCmARkQD16tWLAQMGsHHjxnrLt23bxrBhw0hNTW122wULFtS7n5ubS25uLuCbczdu3MimTZuarU03F8Dl5eUUFhZSVFTErl27Wp0Uw8zo0aMHAwcOJDs7O6yaaziTm2zZsoUtW7Y0+/jEiRNbfI7Wtq9WUFDQ6jqRoAAWEQnYoEGD2LRpU71asHOObdu2tevQpOLiYlasWEFpaWmbt125ciWFhYUtHj7VkHOOXbt2sWvXLjIyMhg9enRcj17uKGozEBEJWNeuXenTp0+j5Q0npQjHzp07WbJkSbvCF3x4tyV8G9q7dy+LFy+mqKio3c+RKFQDFhGJAb169Wo0EUV1GIY7GKmsrIwVK1bUG8zUvXt3evfuTXp6OsnJyZSVlbFnzx4KCwtbfT4zIzMzk27dupGRkUFKSkrN1I8VFRXs27eP4uLiRlNtVlZWsnLlSiZMmNDsDF/Vz13Xnj176oV/ly5dWpwhrOFztHX7oCmARURiQI8ePRotq6ysZN++fWEfD7t58+aaAOrWrRtf+tKXyMrKanLd4cOHN7nczOjbty/9+vWjV69edOnSekzs37+fTz/9tOY4ZvD9yGvWrCEvL6/JbdLS0sjPz6+3rOFczn379m11Lue6z9Ge7YMUSACb2TqgBKgEKpxz+S1vISIS3zIzMzGzRs2/+/fvDzuAq7fNysoiLy+vxfBsbtTyhAkTwgrduqpHc2dkZLBu3bqa5Tt27GDv3r1xP6FGewXZB3yic268wldExNc8mzomuK19uV26dGHUqFFtDtG627fXkCFD6N69e71lmzdvbvfzxTsNwhIRiRFNhV9FRUWbnmPQoEGBneLQzOjXr1+9ZQ37h6VWUAHsgL+b2SIzuySgMoiIxJSmArjh7FCtycnJ6ajitEvD5ubdu3e3+T0kiqAGYR3nnNtoZgcBr5rZh865N+uuEArmSwAOPvjgIMooIhJVB3L4D/jDmTq69ltZWcnOnTvZs2cPe/bsoby8nMrKykbzNtddv66qqirKy8sDq5XHskAC2Dm3MXS9zcyeBY4C3mywzlxgLkB+fv6BfStFRDqBppqb2zLFY8P+1wNRUlLC559/zvbt2w+4BltRUaEAbkLUA9jMugFJzrmS0O1TgFuiXQ4RkVjTVAC3ZVBUU4O42qqqqopPPvmk0dSYB6Kt/diJIogacD/g2dCB5V2Ax5xzLwdQDhGRmFFVVdVkULWl5nggI5iry7By5cpGE4IcqANtWo9XUQ9g59ynwLhov66ISCzbvXt3k0HVtWvXsJ/jQE/fV93k3FBaWhp9+vQhKyurpp85OTmZpKSkRk3k1VNhSus0E5aISAwoLi5utCw5OTlqUymWlZWxfv36esvMjGHDhjFw4MCww725wVnSmAJYRCQGNHXygqysrKidlH7Hjh2NBlsdcsghbT4bk/p7w6eJOEREArZ3794mz3zU1BmSIuWLL76od79Lly4MHDiwzc+zb9++jipS3FMAi4gEbMOGDY2WJSUlkZ2dHbUyNJzyskePHm06BKpaU03p0jQFsIhIgL744gs2bdrUaPlBBx1Eampq1MpRXl5e7357RlSXl5ezc+fODipR2zVsro/10dcKYBGRgOzbt49Vq1Y1Wp6UlMTQoUOjWpbq8/xWaxjI4di4cWOg0042fA+xPiBMg7BERAKwfft2PvzwwyYHLQ0bNizqM0c1rG0XFxdTWVnZKNSas2fPHj777LNIFC1sDWvtsd4frRqwiEgUlZSUsGrVKpYvX95k+Pbv379dg58OVFZWVr37lZWV9c7t25L9+/ezbNmywE+60K1bt3r39+zZw/79+wMqTetUAxYRiaCysjJKSkooLi6mqKioxUFK/fv3Z8SIEVEsXa3s7GzWrl1bb9nnn39OUlISubm5zR4OtXXrVj755BPKysoA3wwcVNNvVlZWoyk0V65cyfDhwzt0nuyOogAWEWmHkpISFi5c2ORjlZWVVFRUUFFREdZAoOTkZA455JBAar7VMjIy6NevH1u3bq23fP369WzZsoXs7Gy6detGcnIyFRUVNYdO1W3mTUpKYtiwYXz00UfRLj4Affv2pUuXLvVaFoqLi1m0aBHJycmkpaU1ObI7Pz8/msWsoQAWEWmHyspKdu/efUDPUX0C+6FDh8bE2YKGDx9OSUkJe/furbe8tLS0yUOl6jIzRo8eHXafcSQkJSVx6KGH8uGHHzZ6rLKystH7CpoCWEQkyrp37052djb9+vWLieCt1qVLF8aNG8eKFSvadDxvamoqo0aNomfPnoEehgS+Gd85x8cff6xR0CIiiab6JAUpKSmkpqaSnp5O165dyczMJCsrq0NOGxgpaWlpjB8/ns2bN/P555+3OIgpPT2dnJwcBg4ceMBnYupIOTk5ZGdns337doqKitizZw+lpaVUVlYGPlCsLov1A5UB8vPzXXN9LSIiEjl79+6lpKSEsrIyqqqqSEpKIi0tjczMTDIyMoIuXswzs0XOuSY7mWNnl6WNysvL2bBhQ0wPMZeOl56ezqBBg2K6BiESTzIyMhS0EdJpA3jDhg107969xeHxEl+cc+zYsYMNGzZEfZYgEZGO1mkn4ti/fz99+vRR+CYQM6NPnz5q9RCRuNBpa8DQeOLt5ixYsIA33nij0fITTjiBgoKCDi6VRJJ2uEQkXnTaGnBbFBQUMHv2bIYMGcKQIUOYPXs2s2fPPqDwPfHEE3nllVfqLbvzzju59NJLw36OG2+8kddeey3s9detW8eYMWOafOyjjz7i9NNPZ/jw4RxxxBFMmzat0QH10fbLX/6y3v0vf/nLAZVERCT2JEQAR8L06dOZP39+vWXz589n+vTpYW1fWVnJLbfcwsknn3zAZdm/fz9nnHEGl156KWvWrGHx4sXMnDmTwsLCA37uA9EwgN95552ASiIiEnsUwO103nnn8cILL9TMf7pu3To2bdrEpEmTuPTSS8nPz2f06NHMnj27Zpvc3FyuvfZajjjiCJ588klmzJjBU089BcCiRYs44YQTmDBhAqeeeiqbN2+uWT5u3DjGjRvHvffe22RZHnvsMY455hjOOuusmmUFBQWMGTOG/fv3c9FFF5GXl8fhhx/O66+/DsC8efP42te+xtSpUxk+fDjXXHNNzbaZmZlcf/31jBs3jokTJ9bUpAsLCzn33HM58sgjOfLII3n77bcB2L17d81rjB07lqeffprrrruOffv2MX78eC644IKa5wU/mOrqq69mzJgx5OXl8fjjjwO+q6CgoIDzzjuPkSNHcsEFF8T8+TxFRNqrU/cBV7vySliypPX1tmyZCsC8ea2vO3483Hln84/37t2bo446ipdeeomzzz6b+fPnM23aNMyMW2+9ld69e1NZWcnkyZNZunQpY8eOBaBPnz4sXrwYgJdffhnwh1TNmjWL5557juzsbB5//HGuv/56HnroIS666CJ+97vfcfzxx3P11Vc3WZbly5czYcKEJh+79957MTOWLVvGhx9+yCmnnFIzT+uSJUt4//33SUtLY8SIEcyaNYvBgwezZ88eJk6cyK233so111zDAw88wA033MAVV1zBVVddxXHHHcdnn33GqaeeyqpVq/j5z39OVlYWy5YtA6CoqIhzzz2X3/3udyxp4g/zzDPPsGTJEj744AO2b9/OkUceyfHHHw/A+++/z4oVKxgwYADHHnssb7/9Nscdd1xrfy4RkU4nLgI4KNXN0NUB/OCDDwLwxBNPMHfuXCoqKti8eTMrV66sCeDzzz+/0fOsXr2a5cuXM2XKFMA3T+fk5LBz50527txZE07f/va3eemll9pUxrfeeotZs2YBMHLkSIYMGVITwJMnT645BdmoUaNYv349gwcPJjU1lTPPPBOACRMm8OqrrwLw2muvsXLlyprnLi4uZvfu3bz22mv1muN79erVapmmT59OcnIy/fr144QTTuC9996jR48eHHXUUQwaNAiA8ePHs27dOgWwiMSluAjglmqqdc2b52ucM2bM6JDXPfvss7nqqqtYvHgxe/fuZcKECaxdu5Zf//rXvPfee/Tq1YsZM2bUO2ym4fkqwTfJjh49mn/961/1loc7p+ro0aObHOXdmrpz0Faf4QQgJSWlZrRx3eVVVVW8++67pKent/m1DrRMIiLxRn3AByAzM5MTTzyR7373uzWDr4qLi+nWrRtZWVls3bo1rBrriBEjKCwsrAng8vJyVqxYQc+ePenZsydvvfUWAI8++miT23/zm9/knXfe4YUXXqhZ9uabb7J8+XImTZpUs91HH33EZ5991u7zjZ5yyincc889Nferm5enTJlSr3+6qKgI8EFeXl7e6HkmTZrE448/TmVlJYWFhbz55pscddRR7SqTiEhnpQA+QNOnT+eDDz6oCeBx48Zx+OGHM3LkSL75zW9y7LHHtvocqampPPXUU1x77bWMGzeO8ePH14wYfvjhh7nssssYP358swOSunbtyvPPP88999zD8OHDGTVqFL///e/Jzs5m5syZVFVVkZeXx/nnn8+8efPaffaVu+++m4ULFzJ27FhGjRrF/fffD8ANN9xAUVERY8aMYdy4cTUDvS655BLGjh1bMwir2jnnnMPYsWMZN24cJ510Erfffjv9+/dvV5lERDqrTnsyhlWrVnHYYYe16XnmhUZfdVQTtASjPX97EZEgxOXJGNqi4UxYN998M6CZsEREJDgJEcAFBQUKWhERiSnqAxYREQlApw7gztB/LR1Lf3MRiRedNoDT09PZsWOHfpATSPX5gCN5HLKISLR02j7gQYMGsWHDhsBPOCDRlZ6eXjNTlohIZxZIAJvZVOAuIBn4X+fcnLY+R0pKCkOHDu3wsomIiERD1JugzSwZuBc4DRgFTDezUdEuh4iISJCC6AM+CvjYOfepc64MmA+cHUA5REREAhNEAA8EPq9zf0NomYiISMKI2UFYZnYJcEnobqmZLQ+yPDGsL7A96ELEKH02zdNn0zx9Ns3TZ9O85j6bIc1tEEQAbwQG17k/KLSsHufcXGAugJktbG4uzUSnz6Z5+myap8+mefpsmqfPpnnt+WyCaIJ+DxhuZkPNLBX4BvDXAMohIiISmKjXgJ1zFWZ2OfAK/jCkh5xzK6JdDhERkSAF0gfsnHsReLENm8yNVFnigD6b5umzaZ4+m+bps2mePpvmtfmz6RTnAxYREYk3nXYuaBERkc4spgPYzKaa2Woz+9jMrgu6PLHGzNaZ2TIzW2JmC4MuT5DM7CEz21b3cDUz621mr5rZmtB1ryDLGJRmPpubzGxj6LuzxMxOD7KMQTGzwWb2upmtNLMVZnZFaHnCf3da+GwS/rtjZulm9h8z+yD02dwcWj7UzP4dyqzHQwONm3+eWG2CDk1Z+REwBT9Zx3vAdOfcykALFkPMbB2Q75xL+OPyzOx4YDfwf865MaFltwNfOOfmhHbgejnnrg2ynEFo5rO5CdjtnPt1kGULmpnlADnOucVm1h1YBHwVmEGCf3da+GymkeDfHTMzoJtzbreZpQBvAVcAPwKecc7NN7P7gQ+cc/c19zyxXAPWlJUSNufcm8AXDRafDTwSuv0I/scj4TTz2QjgnNvsnFscul0CrMLPzJfw350WPpuE57zdobspoYsDTgKeCi1v9XsTywGsKStb54C/m9mi0MxhUl8/59zm0O0tQL8gCxODLjezpaEm6oRrYm3IzHKBw4F/o+9OPQ0+G9B3BzNLNrMlwDbgVeATYKdzriK0SquZFcsBLK07zjl3BP7MUpeFmhqlCc73tcRmf0sw7gOGAeOBzcBvAi1NwMwsE3gauNI5V1z3sUT/7jTx2ei7AzjnKp1z4/GzOR4FjGzrc8RyAIc1ZWUic85tDF1vA57Ffwmk1tZQP1Z1f9a2gMsTM5xzW0M/IFXAAyTwdyfUh/c08Khz7pnQYn13aPqz0XenPufcTuB14Bigp5lVz6/RambFcgBrysoWmFm30MAIzKwbcAqgE1bU91fgwtDtC4HnAixLTKkOl5BzSNDvTmgwzYPAKufcHXUeSvjvTnOfjb47YGbZZtYzdLsrfrDwKnwQnxdardXvTcyOggYIDW+/k9opK28NtkSxw8wOwdd6wc9o9lgifz5m9megAH9Gkq3AbOAvwBPAwcB6YJpzLuEGIzXz2RTgmxAdsA74QZ0+z4RhZscB/wSWAVWhxT/F93Um9Henhc9mOgn+3TGzsfhBVsn4iuwTzrlbQr/L84HewPvAt5xzpc0+TywHsIiISLyK5SZoERGRuKUAFhERCYACWEREJAAKYBERkQAogEVERAKgABYREQmAAlikkzGzPnVOBbelzqnhdpvZ7yP0mlea2XdaePxMM7slEq8tEq90HLBIJxaN0wqGptZbDBxRZ6L5hutYaJ1jnXN7I1UWkXiiGrBInDCzAjN7PnT7JjN7xMz+aWbrzexrZna7mS0zs5dDc/xiZhPM7I3QGbVeaTDNYLWTgMXV4WtmPwydpH2pmc2HmhMWLADOjMqbFYkDCmCR+DUMH55fAf4EvO6cywP2AWeEQvge4Dzn3ATgIaCp6UyPxZ+Mvdp1wOHOubHAf9VZvhCY1OHvQiROdWl9FRHppF5yzpWb2TL8nLUvh5YvA3KBEcAY4FXfgkwy/vRyDeXgJ5qvthR41Mz+gp9vu9o2YEDHFV8kvimAReJXKYBzrsrMyl3tgI8q/P++ASucc8e08jz7gPQ6988AjgfOAq43s7xQ83R6aF0RCYOaoEUS12og28yOAX/uVzMb3cR6q4BDQ+skAYOdc68D1wJZQGZovS+RgKemE2kvBbBIgnLOleHPXXqbmX0ALAG+3MSqL+FrvOCbqf8UatZ+H7g7dEJygBOBFyJZZpF4osOQRKRVZvYscI1zbk0zj/fDn5N6cnRLJtJ5KYBFpFVmNgLo55x7s5nHjwTKnXNLolowkU5MASwiIhIA9QGLiIgEQAEsIiISAAWwiIhIABTAIiIiAVAAi4iIBOD/A2BqKYQ6Ci8AAAAAAElFTkSuQmCC\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -685,56 +455,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Comparisons to a Direct Connection"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n",
-      "output/OES0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAFKCAYAAAA5RqfXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAnx0lEQVR4nO3de5hdVX3/8ffnnLkmmSQkmVxIxISLlNhIxIhaEYO3AqXeqsXIz3otar3UWv2J/VmJ9ucjPn2qraWKFCnYB9G2gvorWKFKRFHEBCEEkBITlFxIBgiZyW0u53x/f+w94czMmcmZyZxz9uR8Xs8zz5yz9tp7fycszvfstddeSxGBmZmZZU+u3gGYmZlZeU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTfUOYDLNmzcvli5dWu8wzMzMxmXDhg2PR0Tn8PJjKkkvXbqU9evX1zsMMzOzcZH0m3Ll7u42MzPLKCdpMzOzjHKSNjMzyygnaTMzs4xykjYzM8soJ2kzM7OMqtojWJKuBi4AdkfE76Zl3wROTavMBp6KiJVl9n0E6AEKwEBErKpWnGZmZllVzeekrwEuB742WBARFw6+lvR3wN4x9j8nIh6vWnRmZmYZV7UkHRG3S1pabpskAX8MvKxa5zczM5vq6nVP+iXAroh4eJTtAdwiaYOki8c6kKSLJa2XtL6rq2vSAzUzM6uXeiXpNcD1Y2w/KyLOAM4D3ifp7NEqRsSVEbEqIlZ1do6Y9tTMzGzKqnmSltQEvB745mh1ImJ7+ns3cCNwZm2iMzMzy456XEm/AvhVRGwrt1HSdEkdg6+BVwGbahif2TFr7dq1SKr5z9q1a+v9p5tNSYqI6hxYuh5YDcwDdgGXRsRXJV0D3BkRV5TUPR64KiLOl3QiydUzJAPbvh4Rn6nknKtWrQqvgmU2+VavXg3AunXr6hqH2bFK0oZyjxtXc3T3mlHK31ambAdwfvp6C3B6teIyMzObKjzjmJmZWUY5SZuZmWWUk7SZmVlGOUmbmZlllJO0mZlZRjlJm5mZZZSTdJV58ggzM5uoai5VaSRJeiIJ05NHmJmZr6TNzMwyylfSo1h6yU11Pf9jW57IRByPXPYHdT2/mVkj85W0mZlZRvlKusqe+sl17L1jrKWzx/abz10wof1mvXgNs8+6aMLnNTOz+nOSrrLZZ13kZGlmZhPi7m4zM7OMcpI2MzPLKCdpMzOzjPI9abOpYO2s+p7/kf31j2Pt3vqd26xOfCVtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUVVL0pKulrRb0qaSsrWStku6J/05f5R9z5X0kKTNki6pVoxmZmZZVs0r6WuAc8uUfyEiVqY/Nw/fKCkP/BNwHrAcWCNpeRXjNDMzy6SqJemIuB14cgK7nglsjogtEdEHfAN4zaQGZ2ZmNgXU4570+yVtTLvDjyuzfTHwaMn7bWlZWZIulrRe0vqurq7JjtXMzKxuap2kvwycBKwEdgJ/d7QHjIgrI2JVRKzq7Ow82sOZmZllRk2TdETsiohCRBSBfybp2h5uO/CMkvdL0jIzM7OG0lTLk0laFBE707evAzaVqfYL4BRJy0iS85uAN9coRLNj2tp1h/jUj/omvL8+1T2h/S59aQtrV7dN+LxmjapqSVrS9cBqYJ6kbcClwGpJK4EAHgHendY9HrgqIs6PiAFJ7we+D+SBqyPi/mrFadZI1q5uc7I0m0KqlqQjYk2Z4q+OUncHcH7J+5uBEY9nmZmZNRLPOGZmZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRTtJmZmYZ5SRtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZRVUvSkq6WtFvSppKyv5X0K0kbJd0oafYo+z4i6T5J90haX60YzczMsqyaV9LXAOcOK7sV+N2IeA7wP8DHx9j/nIhYGRGrqhSfmZlZplUtSUfE7cCTw8puiYiB9O2dwJJqnd/MzGyqq+c96XcA3xtlWwC3SNog6eKxDiLpYknrJa3v6uqa9CDNzMzqpS5JWtL/AQaA60apclZEnAGcB7xP0tmjHSsiroyIVRGxqrOzswrRmpmZ1UfNk7SktwEXABdFRJSrExHb09+7gRuBM2sWoJmZWUbUNElLOhf438CrI+LAKHWmS+oYfA28CthUrq6ZmdmxrJqPYF0P/Aw4VdI2Se8ELgc6gFvTx6uuSOseL+nmdNcFwE8k3QvcBdwUEf9VrTjNzMyyqqlaB46INWWKvzpK3R3A+enrLcDp1YrLzMxsqvCMY2ZmZhnlJG1mZpZRTtJmZmYZdcR70pJyJPeIjwcOApvSR6PMzMysikZN0pJOAj4GvAJ4GOgC2oBnSToAfAW4NiKKtQjUzMys0Yx1Jf1/gS8D7x4+6Yik+cCbgbcA11YvPDMzs8Y1apIe5RGqwW27gb+vRkBmZmaWOOLAMUlvLJkB7K8l3SDpjOqHZmZm1tgqGd391xHRI+ks4OUkE5J8ubphmZmZWSVJupD+/gPgyoi4CWipXkhmZmYGlSXp7ZK+AlwI3CyptcL9zMzM7ChUkmz/GPg+8PsR8RQwB/hoNYMyMzOzCpJ0uqTkI8B5kj4ALIqIW6odmJmZWaOrZHT3J0mehZ4LzAP+RdInqh2YmZlZo6tkqcqLgNMj4hCApMuAe0gmOzEzM7MqqeSe9A6S6UAHtQLbqxOOmZmZDarkSnovcL+kW4EAXgncJemLABHxwSrGZ2Zm1rAqSdI3pj+D1lUnFDMzMyt1xCQdEddKagF+h+RK+qGI6Kt6ZGZmZg2ukvWkzydZlvLXgIBlkt4dEd+rdnBmZmaNrJLu7s8D50TEZji8zvRNgJO0mZlZFVUyurtnMEGntgA9VYrHzMzMUqNeSUt6ffpyvaSbgX8juSf9RuAXNYjNzMysoY3V3f2HJa93AS9NX3cx9LlpMzMzq4JRk3REvL2WgZiZmdlQY3V3f3GsHT2JiZmZWXWN1d39HmATyb3oHSSPX5mZmVmNjJWkF5EMErsQGAC+CfxHuqa0mZmZVdmoj2BFxBMRcUVEnAO8HZgNPCDpLbUKzszMrJFVMuPYGcAakoU1vgdsqHZQZmZmNvbAsU8DfwA8CHwD+HhEDNQqMDMzs0Y31oxjnyDp4j4d+Cxwt6SNku6TtLGSg0u6WtJuSZtKyuZIulXSw+nv40bZ961pnYclvbXyP8nMzOzYMFZ397JJOP41wOXA10rKLgF+EBGXSbokff+x0p0kzQEuBVaRzHK2QdJ3I2LPJMRkZmY2JYyVpH8bETHWzpI0Vp2IuF3S0mHFrwFWp6+vJVmf+mPD6vw+cGtEPJme51bgXOD6seIxMzM7lozV3X2bpA9IOqG0UFKLpJdJuhaYSDf0gojYmb5+DFhQps5i4NGS99vSshEkXSxpvaT1XV1dEwjHzMwsm8ZK0ucCBeB6STskPSBpC/AwyWjvv4+Ia47m5OlV+JhX6xUc48qIWBURqzo7O4/mUGZmZpky1tzdh4AvAV+S1AzMAw5OwmQmuyQtioidkhYBu8vU2c7TXeIAS0i6xc3MzBpGJetJExH9EbFzkmYb+y5Pd5O/FfhOmTrfB14l6bh09Per0jIzM7OGUVGSnihJ1wM/A06VtE3SO4HLgFdKehh4RfoeSaskXQWQDhj7G5J1q38BfHpwEJmZmVmjOOKMY0cjItaMsunlZequB95V8v5q4OoqhWZmZpZ5R7ySlvS5SsrMzMxsclXS3f3KMmXnTXYgZmZmNtRYc3e/F/gz4MRh04B2AHdUOzAzM7NGN9Y96a+TrHr1WZKpOwf1eBCXmZlZ9Y31nPReYK+k4VN2zpA0IyJ+W93QzMzMGlslo7tvIpkVTEAbycIbDwHPrmJcZmZmDe+ISToiVpS+l3QGyb1qMzMzq6JxT2YSEXcDL6hCLGZmZlbiiFfSkj5c8jYHnAHsqFpEZmZmBlR2T7qj5PUAyT3qb1UnHDMzMxtUyT3pTwFImpm8jZ6qR2VmZmYVTQu6StJ9wEbgPkn3SlpV/dDMzMwaWyXd3VcDfxYRPwaQdFZa9pxqBmZmZtboKhndXRhM0AAR8ROSe9NmZmZWRZVcSf9I0leA60kmNbkQWJc+Lz34SJaZmZlNskqS9Onp70uHlT+XJGm/bFIjMjMzM6Cy0d3n1CIQMzMzG6qSyUxagT8ClpbWj4hPVy8sMzMzq2Tg2HeA15AMFttf8mNmZjYha9euRVLNf9auXVvvP31cKrknvSQizq16JGZm1jDWrl07oYS5evVqANatWzep8WRVJUn6p5JWRMR9VY/GzMwybcW1K45cqYq2PLYlE3Hc99bapMRRk3Q6y1ikdd4uaQvQS7KudESEJzMxMzOrorGupC+oWRRmZtZQdt24i67vdE14/01v2zSh/Tpf08mC1y2Y8HlrbdQkHRG/AZA0p8xmL7JhZmYTtuB1C6ZUsqyXSkZ33w10Af8DPJy+fkTS3ZKeV83gzMzMGlklSfpW4PyImBcRc4HzgP8E/gz4UjWDMzMza2SVJOkXRsT3B99ExC3AiyLiTqC1apGZmZk1uEoewdop6WPAN9L3FwK7JOWBYtUiMzMza3CVXEm/GVgCfDv9OSEtywN/XK3AzMzMGl0lC2w8DnxglM2bJzccMzMzG1TJAhu3kUxqMkRETGiJSkmnAt8sKToR+GRE/H1JndUkc4ZvTYtu8IIeZmbWaCq5J/2RktdtJCtiDUz0hBHxELASIL2vvR24sUzVH0eEJ1QxM7OGVUl394ZhRXdIumuSzv9y4NeDE6eYmZnZ0yrp7i6dcSwHPA+YNUnnfxNw/SjbXiTpXmAH8JGIuH+U+C4GLgY44YQTJiksMzOz+quku3sDyT1pkXRzbwXeebQnltQCvBr4eJnNdwPPjIh9ks4nGVV+SrnjRMSVwJUAq1atGnHv3MzMbKqqpLt7WZXOfR5wd0TsKnPO7pLXN0v6kqR56UhzMzOzhlBJd3cz8F7g7LRoHfCViOg/ynOvYZSubkkLgV0REZLOJOlmf+Ioz2dmZjalVNLd/WWgmafn6X5LWvauiZ5U0nTglcC7S8reAxARVwBvAN4raQA4CLwpItyVbWZmDaWSJP38iDi95P0P0wFdExYR+4G5w8quKHl9OXD50ZzDzMxsqqtkWtCCpJMG30g6EShULyQzMzODyiczuU3SFpIR3s8E3l7VqMzMzGzsJJ3OCHY6yeNPp6bFD0VEb7UDMzMza3RjdndHRAFYExG9EbEx/XGCNjMzq4FKurvvkHQ5yaIY+wcLI+LuqkVlZmZmFSXplenv0lWoApjQKlhmZmZWmUpmHDunFoGYmZnZUJXMONZKsjzl0tL6Xt/ZzMysuirp7v4OsJdkoQ0PGjMzM6uRSpL0kog4t+qRmJmZ2RCVzDj2U0krqh6JmZmZDTHqlbSkTUAxrfP2dMaxXpJZxyIinlObEM3MzBrTWN3di3n68SszMzOrsbGS9NaI+E3NIjEzM7MhxkrS8yV9eLSNEfH5KsRjZmZmqbGSdB6YQXIP2szMzGpsrCS90xOWmJmZ1c9Yj2D5CtrMzKyOxkrSL69ZFGZmZjbCqEk6Ip6sZSBmZmY2VCUzjpmZmVkdOEmbmZlllJO0mZlZRjlJm5mZZZSTtJmZWUY5SZuZmWWUk7SZmVlGOUmbmZlllJO0mZlZRjlJm5mZZZSTtJmZWUbVLUlLekTSfZLukbS+zHZJ+qKkzZI2SjqjHnGamZnVy1jrSdfCORHx+CjbzgNOSX9eAHw5/W1mZtYQstzd/Rrga5G4E5gtaVG9gzIzM6uVeibpAG6RtEHSxWW2LwYeLXm/LS0bQtLFktZLWt/V1VWlUM3MzGqvnkn6rIg4g6Rb+32Szp7IQSLiyohYFRGrOjs7JzdCMzOzOqpbko6I7env3cCNwJnDqmwHnlHyfklaZmZm1hDqkqQlTZfUMfgaeBWwaVi17wJ/ko7yfiGwNyJ21jhUMzOzuqnX6O4FwI2SBmP4ekT8l6T3AETEFcDNwPnAZuAA8PY6xWpmZlYXdUnSEbEFOL1M+RUlrwN4Xy3jMjMzy5IsP4JlZmbW0JykzczMMspJ2szMLKOcpM3MzDLKSdrMzCyjnKTNzMwyyknazMwso5ykzczMMspJ2szMLKOcpM3MzDLKSdrMzCyjnKTNzMwyql6rYJmZmU2K9oF2ZvbNpL3QTnOxmXzkycXQa9BHpz9KT0tPnSKcOCdpMzObkpqKTSzev5jpA9PrHUrVOEmbmU2SQ4cOceedd1ZUVxK5XI5cLkdTUxMtLS20tbUxbdo0ZsyYwcyZM2lubq5yxFNXvphnWc8ymovH9r+Rk7SZWR1EBIVCgUKhQH9/PwcPHmTv3r1D6syYMYP58+ezYMECWltb6xRpNh1/4PiyCbqgAgO5AYIYUT7o5L0n01JsOfz+qZan2DF9R/WCPQpO0mZmGbVv3z727dvH1q1bmT9/PsuWLaOtra3eYdVdS6GFGQMzhpT15nvZOW0nB/IHQHUKrAqcpM3Mqiifz9Pe3l5228DAAIVCgYGBASKibB1Irrp37dpFV1cXJ554IkuWLKlWuFNCR38HiqGZeNv0bfTme+sUUfU4SZuZVVFHRwcrV648Yr2+vj66u7vp6elhz549dHd3j6hTLBbZvHkz3d3dnHbaaUjH0CXjOLQXhn7pOZQ/dEwmaHCSNjPLhJaWFubNm8e8efNYtmwZPT09bNu2jV27do2ou3v3bgCWL19e6zAzYfi96L58X50iqT5PZmJmlkEdHR2cdtpprFixouwo7927d/Poo4/WIbL6G/4MdJFinSKpPidpM7MMmzt3Ls973vPKJuqtW7dy6NChOkRVX8PvRx/L3N1tZpZxbW1tLF++nI0bNw4ZYFYsFtm6dSunnXbapJznwIED7N+/n97eXgqFApJoaWlh4cKFFe3fVGyitdBKc7GZXOTIkaOoIgUV6M/1czB/kNDoA+RsJCdpM7Mp4LjjjuP4449n+/btQ8p3797NSSedREtLyyh7wrp164a8X7p0KUuXLgWgUCiwfft2duzYMepV+WhJOl/M09HfwfSB6UwfmE5TceyUEgoO5A+wp3UP3c3dFT0q1Vxo5pTuU8asM7tvNrP7Zo+6/eGZD495jCPtP+iB4x44Yp3J5iRtZjZFLFmyhB07dgy5mo4Idu/ePaHHsrq7u7n//vvp7R3/yOjF+xczs3/muLqeFTqc0HvzvcfsY1OTyfekzcymiPb2dubOnTui/Iknnhj3sZ566inuueeeCSVoSBa1OJp7w62FVpb1LGN6/7E77/Zk8JW0mdkUctxxx/H4448PKevu7iYiKn5uuq+vj/vvv59i8elR0R0dHcyZM4e2tjby+Tx9fX3s37+frq6uIx4vFMmzyrleevO9FFSgqOTYucjRUmyhfaCdaYVpQxJ7LnIsPrCYLR1bGMgNjHnsUq3F1iHHKeQK9Kv/iPFNdP96cpI2M5tCZs6cOaKsUChw8OBBpk2bVtExdu7cebjLfPr06TzrWc9i1qxZZeueckr5e7mhoLulm73Ne9nftJ9i7siPQTUXmpl/aD6z+p4+V1OxiUUHFvHojPKPkw3kBtgyc8uQspP3nkxLPH0Pvqep54hzb5ceYyL714uTtJnZFDJjxgwkjZhG9NChQxUn6cF9Z82axYoVK2hqGj0V5HLl74punbG1osRcqj/fz/bp2+nL9dF5qPNw+YyBGbQUWo7pSUkmyvekzcymEElln5ke773lpqYmli9fPmaCHst4E3SprrYuDjYdPPxeoYpGVzciJ2kzsymmXGIdGCh/T3c0S5Ysqd/yl4K9LUOX5Zw2UFkvQKOpeZKW9AxJt0l6QNL9kv68TJ3VkvZKuif9+WSt4zQzy6pySbp0EFglFi1aNFnhTEhvbuiVf1uhDTzPyQj1uCc9APxlRNwtqQPYIOnWiBj+lPiPI+KCOsRnZpZpYy1rWYn29vZJv4oefAa6tdBKa6GVfOTJRx6hso9q5YZdI+YiR1M0MaDx9Qgc62qepCNiJ7Azfd0j6UFgMVD7qVzMzKagcl3bow3wKqejo2PSYmkbaGNu71w6+jtGLHwxXvnIM4CTdKm63pOWtBR4LvDzMptfJOleSd+T9OwxjnGxpPWS1lfyPJ+Z2VRXLkmPZwBYuYFn4xaw8MBClu1bxqy+WUedoGHk6lZWxyQtaQbwLeBDETF8dfO7gWdGxOnAPwLfHu04EXFlRKyKiFWdnZ2jVTMzOyYUi8WySXo83dcTHdF9WMCS/UuY0ztnUlekaqTVrSpVl+ekJTWTJOjrIuKG4dtLk3ZE3CzpS5LmRcTjw+uamTWSffv2lb0n3d7eXvExKp2ZbDTzeucxs3/kpCr9uX56mns42HSQvlwf/bl+ihQJxYjVr6b1T2PpvqVHFUcjqHmSVtI6vgo8GBGfH6XOQmBXRISkM0mu+Mc/Oa2Z2TGmu3t4xyPk83na2tpqcv58Mc+8Q/OGlIWCXW27eLL1yYpWtoKRA8esvHpcSb8YeAtwn6R70rK/Ak4AiIgrgDcA75U0ABwE3hRHO5zRzOwYsGfPnhFls2bNOuqr40qVGyC2q20XT7Y9Oa7j5CM/mWEds+oxuvsnHOG7VkRcDlxem4jMzKaGAwcOlF3xqtzKWNUyfWDoqlWFXCG5gh6n5uIkDF5rAO5vMDObIrZt2zaiLJfLUctBs8OT68H8wYq7uEu1D1R+D72ROUmbmU0BTz75JDt2jFypaf78+bS0tJTZozqGd1MXVBj/MYr5EVfkNTWFBpE7SZuZZdzBgwd58MEHR5TncjmWLVtW01hi2NydE7m3PKd3Tl2fiS4ydArVLD+f7aUqzcwy7PHHH+dXv/pV2WejTzrppJovktGf60/m2U5NG5iGQiMesRpNa6GVub21u4deTiFXgJIOgJZi7Xoixiu7Xx/MzBpYT08PDz74IJs2bSqboBcuXMjixYtrHlfpEpOQXIWWrg09luZCM8/Y/4y6X7kOX9yjtdhKUzGb16zZjMrMrMH09fXR09NDd3c3e/bsKfs89KCFCxdy6qmn1jC6p3U3d9N5qHPI7GDzDs0jCLrauka93zuzbyYLDy48nAwLKtTtMawDTQeY0zvn8HuFWLJ/CY+1P8ahpkN1iWk0TtJmZlXU09PD+vXry24rFAoMDAwwMDBQ0cpW+XyeE088sS5X0IP68n3sbd7L7L7ZQ8o7D3Uyu2823c3d9OZ7KapIPvK0FFvo6O+gpfB0l3JRRXa372bRgfosl9nT3EMhVyBffPpLwrSBaZzYcyIFFRjIDYy49w6wZeaWWoYJOEmbmVVVoVBg3759R3UMSSxYsIBly5bV/B50OY+1P0Z7oZ3WwtBYmovNR7zfHAq2Td82YvBWLYWCx9oeY/GBkV928pEnX8jORCtO0mZmGdXR0UFnZycLFizIRHIeVMwV+c2M37Bk/xKmDUyreL/+XD/bp2/nQNMBpvVXvl817G3dixALDi7I9OxnTtJmZnWSy+XI5XI0NzfT0tJCW1sb7e3tzJgxg1mzZk3OkpJVMpAb4JEZj3Bc33HM7Z07pDt7uL5cH0+1PsWTrU9SVP2uoId7qvUpulu66ejrYPrAdFqLrTQXm8lFru6D2wY5SZuZTZK2tjZWr15d7zBGqFpMgj2te9jTuoeWQgvthXbyxTw5chQpMpAb4FD+EH35vhG7Hmg+wAPHPTCh026etfloIz+sqCJ7W/eyt3XvpB1zMjlJm5nZUevL95VNxnZ0snE9b2ZmZiM4SZuZmWWUk7SZmVlGOUmbmZlllJO0mZlZRjlJm5mZZZSTtJmZWUY5SZuZmWWUk7SZmVlGOUmbmZlllJO0mZlZRjlJm5mZZZSTtJmZWUY5SZuZmWWUk7SZmVlGOUmbmZlllJO0mZlZRjlJm5mZZVRdkrSkcyU9JGmzpEvKbG+V9M10+88lLa1DmGZmZnVV8yQtKQ/8E3AesBxYI2n5sGrvBPZExMnAF4DP1TZKMzOz+qvHlfSZwOaI2BIRfcA3gNcMq/Ma4Nr09X8AL5ekGsZoZmZWd011OOdi4NGS99uAF4xWJyIGJO0F5gKPDz+YpIuBi9O3+yQ9NOkR1888yvzNtST3YdjT6tseP+Xv6XZY/T8b3zbp7fGZ5QrrkaQnVURcCVxZ7ziqQdL6iFhV7zjMwO3RsqOR2mI9uru3A88oeb8kLStbR1ITMAt4oibRmZmZZUQ9kvQvgFMkLZPUArwJ+O6wOt8F3pq+fgPww4iIGsZoZmZWdzXv7k7vMb8f+D6QB66OiPslfRpYHxHfBb4K/KukzcCTJIm8ER2T3fg2Zbk9WlY0TFuUL1DNzMyyyTOOmZmZZZSTtJmZWUY1RJKWdLWk3ZI2VVj/unTa0k3pvs1p+dskhaRXlNR9bVr2hvT9unTfeyQ9mD7HXe4czZIuk/SwpLsl/UzSeZPx905U+rcsL3n/6dK/1SZG0jMk3SbpAUn3S/rzCvZ5fzotbkiaV1LuNmiTZgKfjW6X1LZdNkSSBq4Bzh1H/euA3wFWAO3Au0q23cfQgWxrgHuH7X9RRKwEXgx8Lh3FPtzfAIuA342IM4DXAh3jiLEaXksyVSsAEfHJiPjv+oVzzBgA/jIilgMvBN5XZirc4e4AXgH8psw2t0GbLNcwvs9Gt0tq2y4bIklHxO0ko8QPk9Qk6ReSVqfvPyvpM2n9myMF3EXyLPegHwNnpt/2ZgAnA/eMcuoZwH6gMOzc04A/BT4QEb3pOXdFxL+l29dIui+9kv9cyX77JH1G0r2S7pS0IC2/RtIXJf1U0pbBb67pto+mf+dGSZ8qKf+TtOxeSf8q6feAVwN/m37TPSk97uC34JdL+mUa19WSWtPyRyR9Kv3Ge5+k3znif5AGExE7I+Lu9HUP8CCw+Aht8JcR8cgoh3QbrKANSnppepx70v3q/UGfORP4bHS7rPFnY0Mk6XIiYgB4G/BlJd0W5wKfKq2jpJv7LcB/le4K/Dfw+yRzjA9/xhvgOkkbgYeAv4mIwrDtJwO/jYju4TtKOp5kQZGXASuB50t6bbp5OnBnRJwO3E7SmActAs4CLgAuS4/1KuAUkvnSVwLPk3S2pGcDnwBelh7rzyPip+nf8tGIWBkRvy6JqY3kG/eFEbGC5NG995ac+/H0G++XgY+U+fewlJIV3Z4L/LySNjgKt8HK2uBHgPelV24vAQ6W+XeyYdwus/XZ2LBJGiAi7gf+FfhP4B3pgh+lvgTcHhE/Hlb+DZJunTcB15c59EUR8RzgBOAjksrOyTqK5wPrIqIr/Z/lOuDsdFtfGivABmBpyX7fjohiRDwALEjLXpX+/BK4m6QL/xSSRv7vEfE4QEQM+SZdxqnA1oj4n/T9tSUxAdwwSkxWIr26+BbwocEPoQra4GjcBo/cBu8APi/pg8Ds9G+xCrhdZuezsaGTdGoF8BQwv7RQ0qVAJ/Dh4TtExF3pfvNK/uOMEBFdJA1g+AIim4ETJM0cZ6z9JTOvFRg6GU1vafglvz+bfvtbGREnR8RXx3nOSgyee3hMlkp7Zb4FXBcRNwzbXLYNjsVtcIQRbTAiLiMZT9IO3DHR7sYG5nZ59I76s7Ghk7Sk1wNzSL75/KOk2Wn5u0i6bNZERHGU3S8B/uoIx59G0rX569LyiDhAMqvaPygdOCGpU9IbSe6Bv1TSPCVrb68BfjSxv5DvA+9Ir+CQtFjSfOCHwBslzU3L56T1eyg/QOMhYKmkk9P3bzmKmBqOJJH8934wIj4/bFvZNlght8ExSDopIu6LiM+RTEfsJF0ht8vsfDY2RJKWdD3wM+BUSdskvVPJ4wOXAe9Kv/FdDvxDussVJN0iP0sHCnxy+DEj4nsRcdsop7xO0j0kXRzXRMSGMnU+AXQBDyh5/OE/ge6I2EnSyG8jGRm5ISK+M5G/OyJuAb6e/h33kazN3ZF2ZX0G+JGke4HBxPEN4KPpIIiTSo5zCHg78O/pcYok/0ZWmReT/M/7Mj09kOn8sdqgpA9K2kYyaHGjpKuGH9Rt8Iht8ENKBhhtBPqB703kbziWjfez0e2y9p+NnhbUzMwsoxriStrMzGwqcpI2MzPLKCdpMzOzjHKSriJJ7ZJ+lI5ELC0vna3mKh15ishKzrVaycw4g+/fL+kdR3tcm5pGa3uTePxXS7pknPs8ko7MbZF0uyQ/rteg/NlYOSfp6noHcEOZWXUOi4h3pQ/ZDzGBD9fVwO+VvL8a+MA4j2HHjiO2vVLjbW8R8d30OeRxSyfG+AFw4UT2t2OCPxsr5CRdXRcB31HiciUrwPw3JZMDKFkZZlX6ep+kv0uH/r9I0v+SdFf6yM5XBhunpHOVzAd7r6QfKJlq8j3AX6R1X5I+b/iIpDNr/ldbFgy2vdXpVetNafu7QlIOyra3D6ePLG2S9KG0zl9Iujp9vSLdNk3JqkeXp+Wdkr6lZB7kX0h6cVo+V9ItSlb+uoqnJ5IA+HYaozUmfzZWyEm6SpQ8iH9iJJPRv45k+rjlwJ8w9FtdqekkczqfDjxBcqXx4nTu4QJwkaRO4J+BP0rrvTE9xxXAF9LZcwanMV1PMmexNZBhbQ+S+Yk/QNL+TgJen5aXtreDJM97voBkpa4/lfRckudjT5b0OuBfgHenH3Kl/oGk7T0f+CNg8NnZS4GfRMSzgRtJpoIctIlkmkdrMP5sHB/fE6qeeSRT6kEya8/1adfODkk/HGWfAsnUkQAvB54H/EISJFMb7ib5AL09IrbCEeeW3Y1nWWpEpW0P4K6I2AKHJ684i2TyhtL2dhZwY0TsT+vdALwkIn4p6W3ARuArEXFHmfO9AlietlOAmUpmcjqb9AtBRNwkac9ghYgoSOqT1BHJymDWOPzZOA5O0tVzEGgb5z6HSu7RCLg2Ij5eWkHSH47jeG145Z9GNLztDZ+xaPB9aXsbyynAPuD4UbbngBemsy8dVpK0R9MKHDpSJTvm+LNxHNzdXSURsQfIK1nK7HbgQkl5SYuAcyo4xA+ANyiZTxZJc5SsGHMncLakZYPlaf1yc8s+i6Rb0RrIsLYHyRq/y9J70RcCPymz24+B16b3m6eTdEP+WNIs4IskVzxzVbIeb4lbKBmII2ll+vJ24M1p2XnAcSV15pIs49c/8b/UpiJ/No6Pk3R13ULajQg8DDwAfI1krtwxpaMaPwHcomTu4VuBRenqMRcDN6SDKL6Z7vL/gNcNDo5Iy16c7meNZ7DtQbK4xOXAg8BWkvY4RETcTbIu7l3Az4GrIuKXwBeAf0rncH4ncNngh2OJDwKrJG2U9ADJQB1I1iA+W9L9JN3evy3Z5xzgpqP9I23K8mdjhTx3dxVJOgP4i4h4Sx3O/Vzgw/U4t9XfYNsjWVHoIxFxQZ1DGiK9533JWMsZ2rHLn42V85V0FaVXJ7epShNKHME84K/rcF7LgMG2B9Sj7Y0pHd37bSfoxuXPxsr5StrMzCyjfCVtZmaWUU7SZmZmGeUkbWZmllFO0mZmZhnlJG1mZpZR/x8MKqFIIMVaGAAAAABJRU5ErkJggg==\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -746,47 +486,17 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n",
-      "output/OES0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -798,47 +508,17 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n",
-      "output/OES0-R0-1R1-1R2-1R3-1T10S1-R0-1R1-1R2-1T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -849,47 +529,17 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/IES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n",
-      "output/OES0-R0-2R1-2R2-2R3-2T10S1-R0-2R1-2R2-2T10S2-R0-2R1-2T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
@@ -900,56 +550,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Mixed Performance Evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Mixed Performance Evaluation"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOEyS0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n",
-      "output/TIEyS0-R0-2R1-2T10S1-R0-1R1-2T10S2-R0-1R1-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeAAAAFNCAYAAADYVrylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABRB0lEQVR4nO3dd3iUVdr48e9J7wkl9BI66QUIIC0oYoGXrgtvLFGw7SKw7q7i67ourvpjV1QEXTtEXVbcXRFd1sKqYASlEwkCCkivIUAq6ef3x5MZMplJMikzk3J/rmuuzDz1PMMw95zznHMfpbVGCCGEEM7l5uoCCCGEEK2RBGAhhBDCBSQACyGEEC4gAVgIIYRwAQnAQgghhAtIABZCCCFcwMPVBbBH+/btdVhYmKuLIYQQQtTJzp07L2itQ22taxYBOCwsjB07dri6GEIIIUSdKKWOVbdOmqCFEEIIF5AALIQQQriABGAhhBDCBSQACyGEEC4gAVgIIYRwAQnAQgghhAs0i2FIQgjRGm3cuJGvv/7aavmYMWNISkpyfoFEo5IALJo1+YISLVlSUhJJSUmkpqYCkJKS4tLyiMYlAVg0a6YvqLfeehs3N81dd6W4ukhCCGEXCcCiWTpzBr799upjx47b8PQsIzUVYmMhLs74GxkJPj6uLq0QQliTACyavNJSyMiwDLhHjxrrvL1hyBAYN24/xcXuFBaGs2IF5Ocb693dITz8alA2BeZQm5lZRW2kyV+IxiMBWDQ5ly7Bli1Xg+3WrVcDaufOMGIEzJsH11wD8fHg5QWpqUau8JSUcMrL4eefIT3deHz/PXz9NaxadfUcXbpYB+W+fY2ALaon9ySFaDwSgIVLaQ0//WRZu923z1jn7m4ExrvuMoLtNddAjx6g1NX9q9bIFi1aBBg1shkzkpgx4+q2WVlGMDYF5fR0+O9/jRo2gJ8fREdbBuXoaAgIcOQ7IIRorSQAC6cqKIDt2y0D7sWLxro2bWD4cPjf/zWC7ZAhtQc/U43MHu3awbXXGg+ToiLYv98yKL//Prz2mrFeKejXz/K+clycUYOu/ENACCHqSgKwcKgTJyyDbXr61RpneDhMnXq1dtu/P7g5OTWMt/fVGq+J1ka5KwflnTvhn/+8uk379tZBeeBA8PR0ZumFEM2ZBGDRaIqLjWBVOeCeOmWs8/ODoUPhkUeMYDtsGLRt69LiVkspo6m7Rw+YNOnq8pwc2LPHMjC//DIUFhrrvbyMXteVm7BjYyEkxOmXIIRoBiQAi3rLzITvvrsabLdvvxqMevaE0aOv1m5jYsCjmX/agoJg5EjjYVJaatzDrhyU//MfWLny6jY9e1oG5bg4CAuTJmwhmhpn9/Jv5l+JwlnKy43OUZVrtwcPGus8PSEhAR54wAi2w4dD166uLa+zeHhARITx+N//vbr87FnLoJyeDv/+t/E+ghHMqzZhy5hlIVzL2b38JQALm3JyYNu2q8F2yxbIzjbWhYYagXbOHOPvoEHg6+va8jY1nTrBjTcaD5OCAti71zIor1wJeXnGend34z5y5aAcGwsdOji//EIIx5MALNAajhyxrN1mZBi1NaUgKgpmzrzanNynjzSf1oefHyQmGg+TymOWTYE5Lc1yzHLnzpZBOS5OxiwL0RJIAG6FCgth1y7LgHvunLEuMNBoQp4yxQi2Q4dCcLBLi9uiubkZwbRvX2yOWa5cW65uzLIpMMuYZSGaFwnArUDVvMm7dhk9lsH44r/hhqu124gIqVk1BfaOWf7HPyzHLPfta92E3bWrtFgI0RRJAG5h7MmbvGDB1c5Scn+x+bB3zPKuXZZjltu1sw7K4eEyZlkIV5MA3MzVJ2+yaDlqG7NcOfXmX/9qPWa5clCOjTWykQkhnEMCcDPS0LzJovWoacxy5fvKn3wCFSMuAGPMctVJKnr1ks+REI4gAbgJa+y8yaJ1qzxmedasq8urjln+/ntYt85yzHJMjGVQLilxx9OzzOoc5eW1P8rKnLONs87jjG1OnBiHp2cZ//0v+PsbnfBMj5peV13n6+v8dK+ieg4LwEopHyAN8K44z7+01k8opXoBq4F2wE7gdq11saPK4WwNyaRSU97kgQOv9ky+5hoYMED+I4nGYe+Y5dTUq2OWlUrGw6Oc++6zDBStkVLG/0V3d+NvTY/6bpOX501pqTvZ2ca/TUGBcavJ9P1QF76+dQ/cdVnn4yMtJvZyZA24CLhWa52nlPIENimlPgUeAl7QWq9WSr0KzAZecWA5nMreTCq15U1OTISHH76aN7ldO6cUXwig5jHL338P77yzh5ISd2JjoxslwDTXbZRyTrBJTf0PYP19UlJyNRibAnPV1/auu3zZ+A6qvC4/v34/rBozqNva1tu7ZQR5hwVgrbUGKn4v41nx0MC1gClp39vAH2lBAbg6rS1vsmh5Ko9Zzs1NByAlJdq1hWrlPD2NcfqOGquvte0gX9+An5VltPRVXVfXIK9U49fcK68rKXHDw8PxTToO/ZpXSrljNDP3BV4GDgOXtdamhpOTQIvMGnzyZAiHDnVg40bJmyyEaJ6UMnrMe3k5blYvrY0WwcaoxRcUGJUdW+u0rkup7uCXv9zAXXc55ppNHBqAtdZlQJxSKgT4EBho775KqXuBewF69OjhkPI50rJl15GZGSh5k4UQogZKGU3K3t6Om6JUayORjb1B/ZtvdtK9+yXHFKYSpzR0aq0vK6U2AMOBEKWUR0UtuBtwqpp9XgdeBxg8eHCdfrs0BXPmfENw8BUefnh6i7hXIYQQzZVSRucwHx/7+tMEB2c4vlCAw/rRKqVCK2q+KKV8geuB/cAGwJT19k7gI0eVwZX69z9Px465EnyFEELY5MgacGfg7Yr7wG7AP7TW65RS+4DVSqmngN3AWw4sgxBCCNEkObIX9B4g3sbyn4FE6z2EEEKI1kMGuzSyqok4Fi1aBNiXiEMIIUTrIQG4kZkScQghhBA1kWSGQgghhAtIABZCCCFcQAKwEEII4QISgIUQQggXkAAshBBCuIAEYCGEEMIFZBiSEMJuMs5diMYjAVgIYTcZ5y5aMmf/wJQALIQQQuD8H5gSgIUQoomSJv+WTQKwEEI0UdLk37JJL2ghhBDCBSQACyGEEC4gAVgIIYRwAQnAQgghhAtIABZCCCFcQAKwEEII4QISgIUQQggXkAAshBBCuIAEYCGEEMIFJAALIYQQLiABWAghhHABCcBCCCGEC0gAFkIIIVxAArAQQgjhAhKAhRBCCBeQACyEEEK4gARgIYQQwgUkAAshhBAuIAFYCCGEcAEJwEIIIYQLSAAWQgghXMBhAVgp1V0ptUEptU8p9YNSan7F8j8qpU4ppdIrHjc7qgxCCCFEU+XhwGOXAr/RWu9SSgUCO5VS/61Y94LWeokDzy2EEEI0aQ4LwFrrM8CZiue5Sqn9QFdHnU8IIYRoTpxyD1gpFQbEA1srFs1VSu1RSq1QSrWpZp97lVI7lFI7MjMznVFMIYQQwmkcHoCVUgHAB8ACrXUO8ArQB4jDqCE/Z2s/rfXrWuvBWuvBoaGhji6mEEII4VQODcBKKU+M4LtKa70GQGt9TmtdprUuB94AEh1ZBiGEEKIpcmQvaAW8BezXWj9faXnnSptNBfY6qgxCCCFEU+XIXtAjgNuBDKVUesWy/wNmKaXiAA0cBe5zYBmEEEKIJsmRvaA3AcrGqk8cdU4hhBCiuZBMWEIIIYQLSAAWQgghXEACsBBCCOECEoCFEEIIF5AALIQQQriAI4chCSFamI0bN/L1119bLR8zZgxJSUnOL5AQjcjZn2+ltW70gza2wYMH6x07dri6GHaRLyjRGqSmpgKQkpLi0nII4QiN+flWSu3UWg+2tU5qwI0sKSmJpKQk+YISQghRIwnADnL9c8/heeUKbNgA/foZj/79oW9fCAx0dfGEEELYUlBAQGYmhU74npYA7CCXunal3bFj8OWX8M47lis7dboakE3BuV8/Izj7+rqmwEII0RJpDTk5cO6c5eP8edvL8vKYAXz54IMOL5oEYAfZMXMmUNEEnZ8Phw/DwYPw00/G34MHYd064x+9su7dLYOyKVD37g1eXs6/ECGEy0ifkmqUl0NWVvVBtOrroiLrYygF7dtDx47GY9gw42+HDmw6eJCLPXs6/DIkADuDvz/ExBiPqnJyrgZk0+Onn+Cf/4SLF69u5+YGPXvarjmHhYGH/FMK0dK0qj4lJSWQmVl7DfXcOWO7sjLrY3h6QocOxqNjR4iMvBpgTctMj/btwd3dZlEOVbzfjibf2o2s6i/WRYsWATX8Yg0KgkGDjEdVFy9aBmXT83feMQK3iYeHUUO2VXPu3t0I3kII4WyFhfY3/WZl2T6Gr+/VoNmjBwwZYhlIKwfWNm2Mmm0zIQG4kZl+sTaKtm1h6FDjUZnWxgfWVs15wwYoKLi6rbc39OljGZRNz7t0aVYfViGEi2kNubnVN/VWDay5ubaPExR0NWhGRMDYsdY1VFNwDQhosd9TEoCbI6WufkBHjrRcpzWcPm275vzZZ5b3Qvz8rGvNpiAdGtosPvRyj8zJioshK4vgU6eM14cOGX0TvL2Nv6aHh0ez+PwIjPuply7Z1/R77pxRq61KKWjX7moQHTy4+qbfDh3Ax8f512mHOrdgNpAk4mhNysrg5EnLoGwK0keOQGnp1W2DgqyDsul527auu4ZqtIp7ZI2prMz40r140Wj6y8qq/fnFi5CXZ9/xlbIMyFUDtK1l9dmmIcdtRj8S6vz5Li2FCxfsa/o9f97y/76Ju7tl8LQVSE3PQ0OlH0o1JBGHMLi7Gx25evaE66+3XFdaCkePWtect26Ff/zD+JVs0ratdUcw0yMoyKmX1OqZhljUJZBmZcHly9Uf083NuJfWrp3x6NIFoqON523bQrt2fL1nD1opkq65xmhVKS6++qjtddVleXm1b2OrF2tjcFXwt3cbT0/zjwS3khI4fty+nr9ZWcZnoypv76tBs1s3o+9JdU2/bdtK/xEHkwAsDB4exjjkvn3hppss1xUVGTXkqjXnDRvg3Xctt+3Y0XbNuW9fo8lbVK+goO6B9OJF271BTYKDzUGTtm2N/gCVAqnN58HBtX7xHjH1Er3ttsa7/ppobfxIrEtgb8xt8vONFoPajuOIFkVPT5KVwrO42Pb6wMCrQbN/fxg1ynaNtWNHY9tmUutvDWoNwEopNyAW6AJcAfZqrc87umCiCfH2hoEDjUdVBQVXxzhXrjl/+imsXGm5bdeutmvOffoY52gpiouNL+u6BlJb99ZM/PwsA2VUVO2BtE0bowbVEihlXIunpzGsrynS2vgx5IAfCD/u3k2xvz8JN91kGVw7dJAfts1YtQFYKdUHeAQYBxwEMgEfoL9SqgB4DXhba11e3TFEK+DnZzRPRkdbr8vNNTrpVK05f/CB5ZADNzdjeIGtmnNYmOuCSFmZ0VRb+R6oPYG0up6fYFxL5UDZu7cxrKK6YGr620Q7rYhKlDJakjw8Gj0o7qhocUiQPg4tSk014KeAV4D7dJWeWkqpDsD/ArcDbzuueKJZCwyE+HjjUdWlS9YdwQ4ehFWrIDv76nYeHkYQtlVz7tGj2oH0FrQ27jPWtUZ66VL1TYpKGcHRFCA7dzYG/ddWK23BQyqEEHVTbQDWWs+qYd15YKkjCiRaiTZtIDHReFSmtdF7s+oQqoMH4euvjXtxJl5e5jHOg4uKjMCWlmYdSC9eNLLsVCcoyDJQ9upVfU3U9DwkRDqoCCEaxJ57wLcAn2mtc5VSjwPxwFNa610OL51ofZQyhjSEhsI111iu0xrOnLGZgCT8xx/Rbm7GfqZAGRFRfU3U9Ldt25Zzn1QI0azY0wv6ca31P5VSI4HrgGcxmqaH1rybEI1MKWNITJcuMGaMxap3V64EpWQcsBCi2bCnDc00xmEC8LrW+j+ATMsjmha5ryqEaGbsCcCnlFKvAb8APlFKedu5nxBCCCGqYU8T9K3AjcASrfVlpVRn4HeOLZYQQghn5yYWzlVrANZaFyiljgI3KaVuBDZrrdc7vGRCiCZHAoJzNersaqLJsacX9B+AW4A1FYtWKqX+qbV+yqElE0I0ORIQhGg89jRBJwOxWutCAKXUYiAdI1GHEEIIIerBngB8GiMFpSlRrTdwymElEqIOpElUCNFc2ROAs4EflFL/BTRwPbBNKbUMQGs9z4HlE6JG0iQqhGiu7AnAH1Y8TDY6pihCCCFE62FPL+i3lVJewECMGvCPWutqJqa8SinVHXgH6Fix3+ta6xeVUm2B94Ew4Chwq9b6Ur2vQAghhGiGak2ooZS6GTgMLANeAg4ppW6qeS8ASoHfaK0jgGHAr5RSEcBC4EutdT/gy4rXQgghRKtiTxP088BYrfUhMM8T/B/g05p20lqfAc5UPM9VSu0HugKTgaSKzd7GaNJ+pB5lF0IIIZote1JK5pqCb4WfgRpmHLemlArDmEVpK9CxIjgDnMVoohZCCCFalWprwEqpaRVPdyilPgH+gXEv9xZgu70nUEoFAB8AC7TWOapS0nyttVZK2ZzxXCl1L3AvQI8ePew9nRBCCNEs1NQE/T+Vnp8DTPO/ZWKMC66VUsoTI/iu0lqbMmmdU0p11lqfqcgrfd7Wvlrr14HXAQYPHmwzSAshhBDNVbUBWGt9V0MOrIyq7lvAfq3185VWfQzcCSyu+PtRQ84jhBBCNEc1NUEvq2lHOxJwjABuBzKUUukVy/4PI/D+Qyk1GziGMduSEEII0arU1AR9P7AX497vaaBOM55rrTfVsM91dTmWEEII0dLUFIA7Y3S4+gXGmN73gX9prS87oVxCCCFEi1bTPeAs4FXgVaVUN2AmsE8p9YjW+l1nFVCImlSdjMFEJmMQQjR19swHnADMwpiE4VNgp6MLJYS9TJMxpKamApCSkuLS8gghhL1q6oT1JDAB2A+sBh7VWpc6q2BCCCFES1ZTDfj3wBEgtuLxTEUSDYWRQyPG8cUTQgghWqaaAnAvp5VCCCGEaGVqCsDHtdY1ZqBSSqnathFCtBzS6U2IxlNTAN6glPoA+Ehrfdy0sGJu4JEYWaw2AKkOLaEQosmQTm9CNJ6aAvCNwN3Ae0qpXsBljBzQ7sB6YKnWerfDSyiEEEK0QDWNAy4E/gr8tWJShfbAFUnEIYQQQjRcreOAAbTWJcCZWjcUQgghhF3cXF0AIYQQojWSACyEEEK4QK0BWCn1Z3uWCSGEEMJ+9twDvh54pMqym2wsE0II0Yhk3HXLVlMu6AeAXwK9lVJ7Kq0KBDY7umBCCNHaybjrlq2mGvDfMWY/+n/AwkrLc7XWFx1aKiGEEKKFq2kccDaQrZSq2tQcoJQKqJwdSwghhBB1Y8894P8AGmMWJB+MSRp+BCIdWC4hhIOU63Lyi/PJLsomuzCbnKKcmp8XVTwvvPr8UsEl3HHn/577PwK8Aiwe/l7+xnPPAKt1VttUeXi42ZWaQIgWodZPu9Y6uvJrpVQCxr1hIYSTlZSV2AyIpue1BU7Tek3Nc6goFEHeQQT7BBt/vYPpGNCRfu36EewdzLGDxyjX5fTs15O84jzz40LBBY5ePmqxrKS8xO7r83b3rjlQ2wjq1QVz08PXw5eKqVSFaFLq/HNTa71LKTXUEYVpCaTXorBFa01+SX61gdPqeTU10iulV2o9l7e7tzl4BnsbAbRv277m58HewRbrbD339/LHTVU/StHcKeh/UmotT3FZMfnF+RZB2dYjv6T6bbIKsqy2sZdC1RqkAzxrD+QBXgH4e17dxtPd0+4yCGFLrQFYKfVQpZduQAJw2mElauak12LLU1pe2uDAmVOUQ5kuq/VcgV6BFgGxnV87erfpbRE4a3vu7eHthHfFfl7uXnj5etHGt02jHbNcl3Ol5Eq9grnpcfHKRY5nH7dYVlxWXKfrsidQ12UbP08/qa23IvbUgAMrPS/FuCf8gWOKI0Tj0VpzpfRKjfc57QmiBSUFtZ7L083TKiCGhYQZz+0MnIHegTXWOsVVbsoNfy9//L386UjHRjuurdq6PcG88jZVg3p+cX6tTf4mVWvrpiCdk5lDF68u+O71JbFrImEhYRKoWwB77gEvAlBKBRkvda7DSyVENUrLSzmde5oT2Sc4kXPC/Hfz+c3kl+fz4msvWgTT0vLSWo8Z4BVgERBDfELoGdyzxibaqs99PHzkC7EFcGRt3a5AXjn4l1xdnl2ezf6c/Xz+wecAtPdrz5AuQ0jsmsiQLkMY0nUIHfw7NFqZhXPY0wQ9GFhJRU1YKZUNzNZa73Bw2UQrU67LOZd3ziKwmv9WPD+Td4ZyXW6xX6BXIIE6kEC3QLoHdSeqQxRBXvYFziDvINzd3F10xaI1qFxbr2+QTE1NpVSXknBjAttPbWfbqW1sP72dzw9/bv7/0DO4pzkgJ3ZNZFCXQQR4BTTmpYhGZk8T9Argl1rrbwCUUiMrlsU4smCiZdFak3Ulq9rAeiLnBKdyTln1mPXx8KF7UHe6B3dnXO9x5ueV/wb7BF+95z4rxfkXJ4QTeCgPEjonkNA5gfsG3wdAXnEeu87sMoLy6W1sP7Wdf+77J2AE/vD24RZBObpjNF7uXq68DFGJPQG4zBR8AbTWm5RStbfriVYluzC7xprryZyTVj14Pd086RrUle5B3bmm+zVGUK0SYNv5tpOmXSGqEeAVwOieoxndc7R5WWZ+JttPbzcH5XU/rWNl+krA6CEf1ynOIij3a9dP+h64iD0B+Gul1GvAexgJOX4BbKwYD4zWepcDyyeagPzi/FqDa26xZdcAN+VGl8AudA/qTnzneCYNmGQOqt2CutE9qDsdAzrKf3whGlmofyg397uZm/vdDBitT8eyjxnN1hVBecXuFSzfthyAYO9gBncZbBGUuwZ1deUltBr2BODYir9PVFkejxGQr23UEgmnKiot4mTOyRoD7KXCS1b7dfTvSPfg7gxsP5Dre19v1SzcObCzZDUSoglQShEWEkZYSBi3Rt4KQFl5Gfsv7DffT952ehvPfvusudNi54DOFgF5cJfBjdoxralydh4He3pBj230swqnqK7HcOXn5/PPW+3X1rct3YO60yO4ByO6j7BqFu4a2LXJjTUVQtjP3c2dqA5RRHWI4q74uwAoLC0k/Wy6uZa87dQ2PvrxI/M+/dr2swjKcZ3i8PX0ddUlOISz8zjY0wvaG5gOhFXeXmv9pOOKJWpTrss5m3fW3ARclx7DpmAa3ynequbaLagb/l7+LroqIYSr+Hj4MKzbMIZ1G2ZedrnwMjtO7zAH5Y1HN7IqYxUAHm4eRHeItgjKEaERMqqgDuxpI/wIyAZ2AkWOLY4A457NhYILNTYLn8o9ZTXG1dfD1xxIr+9zvTmgVu0xLER9VW2iW7RoESCpVluqEJ8QxvUex7je48zLTuWcsujktXrval7b+RoAfp5+DOo8yByQJWlIzewJwN201jc6vCSthNaa7KLsGpuFT+acpLC00GI/TzdPI5gGd2dkj5E2h+O09W0rH3ThUKYmOuEcTfEHT9egrnQN6sqUgVMAozXu0MVDFveTX97+Ms9veR6Adr7tLGrJkjTkKnsC8LdKqWitdYbDS9OCHCg8wPnS8xzbeMwqwFZNJF+5x3BC5wQmD5hsFWA7+HeQHsNCtDLN4QePm3Kjf7v+9G/Xn+SYZMCYtSvjfIYkDalFtQFYKZWB0cvZA7hLKfUzRhO0wkhJWWMiDqXUCmAicF5rHVWx7I/APUBmxWb/p7X+pKEX0RS9nfU2Z0vPwtfSY1gI0bp4untK0hA71PStP7GBx04FXgLeqbL8Ba31kgYeu8n7Zegv8VbezL9rvvQYFkK0epI0xFq1AVhrfQxAKdXWxupaJ2TQWqcppcLqX7TmrbtXdwAJvkIIUY36Jg2p3MmrOScNsafdcxfQHbiE0fwcApxVSp0D7tFa76zjOecqpe4AdgC/0VpbZ3kQQgjR6tibNGTJd0taRNIQewLwf4F/aa0/B1BKjccYF7wS+CswtA7newX4E8a95T8BzwF329pQKXUvcC9Ajx496nAKIYQQLYU9SUO2n9reLJOG2BOAh2mt7zG90FqvV0ot0VrfV5Gkw25a63Om50qpN4B1NWz7OvA6wODBg+2bzVoIIUSL11KShtgTgM8opR4BVle8/gVwTinlDpRXv5s1pVRnrfWZipdTgb112V8IIYSwxVbSkNO5py2arpta0hB7AvD/YkzEsLbi9eaKZe7ArdXtpJR6D0gC2iulTlYcI0kpFYfRBH0UuK9+xRZCCCFq1iWwC5MHTmbywMmA/UlDPC97Msx/WE2HbhT2TMZwAXiwmtWHathvlo3Fb9lZLiGEEKJR2Zs0ZG/2Xvp493F4eeyZjGEDRo3VgtZapiEUQgjRrNlKGvLqildxV46/P2xPE/RvKz33wegBXVrNtkIIIUSz5uPm45Tz2NMEXXWc72al1DYHlUcIIYRoFexpgq6cCcsNGATInHZCCCFEA9jTBL0T4x6wwmh6PgLMdmShhLBXU5yuTQgh7GFPE3QvZxREiPpoDtO1CSGELfY0QXsCDwCmKSw2Aq9prUscWK5mS2pkQggh7GFPE/QrgCdG3meA2yuWzXFUoZozqZEJIYSwhz0BeIjWOrbS66+UUt87qkBCCCFEa2DPzMZlSilzShClVG+gzHFFEkIIIVo+exNxbFBK/YzRE7oncJdDSyWEEEK0cDUG4IoZj2KBfsCAisU/aq2LHF0wIYQQoiWrsQlaa10GzNJaF2mt91Q8JPgKIYQQDWRPE/RmpdRLwPtAvmmh1nqXw0olhBBCtHBKa6uJjiw3MGZDqko7czakwYMH6x07djjrdEIIIVqhqnkcTBqSx0EptVNrPdjmutoCcFMgAVgIIURzVFMAticTljfGFIRhlbfXWj/ZWAUUQgghWht77gF/BGRjTMogHbCEEEKIRmBPAO6mtb7R4SURQgghWhF7MmF9q5SKdnhJhBBCiFak2hqwUmovUF6xzV0VmbCKMLJhaa11jHOKKIQQQrQ8NTVBdwXinFQOIYQQolWpKQAf0Vofc1pJhBBCiFakpgDcQSn1UHUrtdbPO6A8QgghRKtQUwB2BwIw7vkKIYQQohHVFIDPSLINIYQQwjFqGoYkNV8hhBDCQWoKwNc5rRRCCCFEK1NtANZaX3RmQYQQQojWxJ5MWEIIIYRoZBKAhRBCCBeQACyEEEK4gARgIYQQwgUkAAshhBAu4LAArJRaoZQ6XzGrkmlZW6XUf5VSByv+tnHU+YUQQoimrKZMWA2VCrwEvFNp2ULgS631YqXUworXj9Tn4CUlJZw8eZLCwsIGF1S0Tj4+PnTr1g1PT09XF0UI0Qo5LABrrdOUUmFVFk8Gkiqevw1spJ4B+OTJkwQGBhIWFoZSkrRL1I3WmqysLE6ePEmvXr1cXRwhRCvk7HvAHbXWZyqenwU6VrehUupepdQOpdSOzMxMq/WFhYW0a9dOgq+oF6UU7dq1kxYUIYTLuKwTltZaA7qG9a9rrQdrrQeHhoba3EaCr2gI+fwIIVzJ2QH4nFKqM0DF3/NOPn+jOXHiBGPHjiUiIoLIyEhefPHFWvdJTk5mwIABREVFcffdd1NSUgJAamoqSim++OIL87Zr165FKcW//vUvAJKSkhgwYABxcXGEh4fz+uuv2zxHSUkJCxcupF+/fiQkJDB8+HA+/fTTRrji+lu7di379u0zv/7DH/5gca1CCNEaOTsAfwzcWfH8TuAjJ5+/0Xh4ePDcc8+xb98+tmzZwssvv2wRZGxJTk7mwIEDZGRkcOXKFd58803zuujoaFavXm1+/d577xEbG2ux/6pVq0hPT2fz5s088sgjFBcXW53j8ccf58yZM+zdu5ddu3axdu1acnNzG3i1DVM1AD/55JOMGzfOhSUSQgjXc+QwpPeA74ABSqmTSqnZwGLgeqXUQWBcxetmqXPnziQkJAAQGBhIeHg4p06dorS0lCFDhrBx40YAHn30UR577DEAbr75ZpRSKKVITEzk5MmT5uONGjWKbdu2UVJSQl5eHocOHSIuLs7mufPy8vD398fd3d1ieUFBAW+88QbLly/H29sbgI4dO3LrrbcCRlCPjo4mKiqKRx652vctICCAxx57jNjYWIYNG8a5c+cASElJYd68eVxzzTX07t3bXBsHePbZZxkyZAgxMTE88cQT5uXvvPMOMTExxMbGcvvtt/Ptt9/y8ccf87vf/Y64uDgOHz5MSkqK+Vhffvkl8fHxREdHc/fdd1NUVARAWFgYTzzxBAkJCURHR3PgwAEAvv76a+Li4oiLiyM+Pt7lPy6EEKK+HBaAtdaztNadtdaeWutuWuu3tNZZWuvrtNb9tNbjWsqMS0ePHmX37t0MHToUDw8PUlNTeeCBB/jiiy/47LPPLAIUGM3E7777LjfeeKN5mVKKcePG8fnnn/PRRx8xadIkq/MkJycTExPDgAEDePzxx60C8KFDh+jRowdBQUFW+54+fZpHHnmEr776ivT0dLZv387atWsByM/PZ9iwYXz//feMHj2aN954w7zfmTNn2LRpE+vWrWPhwoUArF+/noMHD7Jt2zbS09PZuXMnaWlp/PDDDzz11FN89dVXfP/997z44otcc801TJo0iWeffZb09HT69OljPnZhYSEpKSm8//77ZGRkUFpayiuvvGJe3759e3bt2sUDDzzAkiVLAFiyZAkvv/wy6enpfPPNN/j6+tr7zySEEE2KZMJqoLy8PKZPn87SpUvNgS8yMpLbb7+diRMnsmLFCry8vCz2+eUvf8no0aMZNWqUxfKZM2eyevVqVq9ezaxZs6zOtWrVKvbs2cPx48dZsmQJx44ds7uc27dvJykpidDQUDw8PEhOTiYtLQ0ALy8vJk6cCMCgQYM4evSoeb8pU6bg5uZGRESEuWa8fv161q9fT3x8PAkJCRw4cICDBw/y1Vdfccstt9C+fXsA2rZtW2OZfvzxR3r16kX//v0BuPPOO81lApg2bZpVmUaMGMFDDz3EsmXLuHz5Mh4ejhzKLoQQjiMBuAFKSkqYPn06ycnJ5mBhkpGRQUhICOfPW/YzW7RoEZmZmTz//PNWx0tMTCQjI4MLFy6Yg5ItoaGhJCQksHXrVovlffv25fjx4+Tk5NTpOjw9Pc09gt3d3SktLTWvMzVlgzF21vT30UcfJT09nfT0dA4dOsTs2bPrdE57mM5duUwLFy7kzTff5MqVK4wYMcLcNC2EEM1Nq6g+bNy4ka+//tpq+ZgxY0hKSqrXMbXWzJ49m/DwcB566CGLdWvWrOHixYukpaUxceJEtm3bRkhICG+++Saff/45X375JW5utn/7LF68GB8fnxrPXVBQwO7du3n44Yctlvv5+TF79mzmz5/Pa6+9hpeXF5mZmWzcuJGRI0cyb948Lly4QJs2bXjvvfd48MEH63XtN9xwA48//jjJyckEBARw6tQpPD09ufbaa5k6dSoPPfQQ7dq14+LFi7Rt25bAwECb92oHDBjA0aNHOXToEH379uXdd99lzJgxNZ778OHDREdHEx0dzfbt2zlw4AADBw6s13UIIYQrtYoAnJSURFJSEqmpqYDRuaihNm/ezLvvvkt0dLS5s9QzzzxDYmIiCxcu5Msvv6R79+7MnTuX+fPn8/bbb3P//ffTs2dPhg8fDhhNrH/4wx8sjnvTTTdVe87k5GR8fX0pKioiJSWFQYMGWW3z1FNP8fvf/56IiAh8fHzw9/fnySefpHPnzixevJixY8eitWbChAlMnjy5Xtc+fvx49u/fb76OgIAA/va3vxEZGcljjz3GmDFjcHd3Jz4+ntTUVGbOnMk999zDsmXLLDpy+fj4sHLlSm655RZz57X777+/xnMvXbqUDRs24ObmRmRkZI3vlxBCNGXK1KzYlA0ePFjv2LHDYtn+/fsJDw+v03EaMwCLlqE+nyMhhLCXUmqn1nqwrXVyD1gIIYRwgRbRBL1gAaSn177d2bPGsJ+KinCN4uJg6dL6l0kIIYSoidSAhRBCCBdoETVge2uqqamfAY17D/jKlSvceOONfPXVV1aJMRrDxx9/zL59+8xJMOwRFhbGjh07CAoKYty4cXz11VcyXlYIIZoYqQE30IoVK5g2bZrdwbesrKxOx580aVKdgm9lXl5eXHfddbz//vv12l8IIYTjSABuoFWrVjF58mQ2btzI6NGjmTBhAgMGDOD++++nvLwcMIbp/OY3vyE2NpbvvvuO559/nqioKKKiolhaUX1/4YUXuPvuuwEjiUdUVBQFBQWkpqYyd+5cADIzM5k+fTpDhgxhyJAhbN68GYCsrCzGjx9PZGQkc+bMoXLP9ilTprBq1SonviNCCCHsIQG4AYqLi/n5558JCwsDYNu2bSxfvpx9+/Zx+PBh1qxZAxi5locOHcr333+Pr68vK1euZOvWrWzZsoU33niD3bt3M3/+fA4dOsSHH37IXXfdxWuvvYafn5/F+ebPn8+vf/1rtm/fzgcffMCcOXMAI7vWyJEj+eGHH5g6dSrHjx837xMVFcX27dud84YIIYSwW6u4MVg1E9aiRYuAhmXCArhw4QIhISHm14mJifTu3RuAWbNmsWnTJmbMmIG7uzvTp08HYNOmTUydOhV/f3/ASMbxzTffmJNWxMTEcN999zFixAir833xxRcW0/rl5OSQl5dHWlqaOdhPmDCBNm3amLdxd3fHy8uL3NxcAgMD632tQgghGlerCMCmTFiNzdfXl8LCQvNrUz7lqq99fHzsukd88OBBAgICOH36tM315eXlbNmypdZUlVUVFRXVeR8hhBCOJU3QDdCmTRvKysrMQXjbtm0cOXKE8vJy3n//fUaOHGm1z6hRo1i7di0FBQXk5+fz4YcfMmrUKLKzs5k3bx5paWlkZWVZpGw0GT9+PMuXLze/Tq8Y/Dx69Gj+/ve/A/Dpp59y6dIl8zZZWVm0b98eT0/Pxrx0IYQQDSQBuIHGjx/Ppk2bABgyZAhz584lPDycXr16MXXqVKvtExISSElJITExkaFDhzJnzhzi4+P59a9/za9+9Sv69+/PW2+9xcKFC61mUlq2bBk7duwgJiaGiIgIXn31VQCeeOIJ0tLSiIyMZM2aNfTo0cO8z4YNG5gwYYID3wEhhBD10apyQTvCrl27eOGFF5g9ezZLlixh3bp1ri6ShWnTprF48eIapzdszZrK50gI0TJJLmgHSkhIYOzYsXUe3+sMxcXFTJkyRYKvEEI0Qa2iE5ajmcbvXnfddS4uiSUvLy/uuOMOVxdDCCHqJTs7m8zMTHJycigsLKS0tNScX8EkKiqK9u3bu6iEDSMBWAghRJNSVFTE/v37uXz5squL4lASgIUQohaFhYVs2bLFrm2VUri5ueHm5oaHhwdeXl74+Pjg5+dHQEAAQUFBMiqhBsXFxezcuZPi4mJXF8XhJAALIUQj0lpTVlZGWVkZJSUlXLlyhezsbIttAgIC6NChAx07dsTb29tFJW2afvzxR5vB193dHW9vb9zc3KyWm2zZssUiN0OnTp0YOHCg4wrbQBKAhRDCyfLy8sjLy+PIkSN06NCBXr16SbIcoKCggKysLItlvr6+DBgwgODgYKtkR82d9IJugLvvvpsOHToQFRVl1/YvvfQSffv2RSnFhQsXzMtTU1NRSvHFF1+Yl61duxallDkhR1JSEgMGDCAuLo7w8HBef/31Bpc/KyuLsWPHEhAQYJ7woSYnTpxg7NixREREEBkZyYsvvmhel5KSgp+fH7m5ueZlCxYssLhWd3d34uLiiI2NJSEhgW+//bbB1yCEq7i7uxMQEGDz4ePjg6enZ60BQ2vNuXPn2LZtGydPnnRSyZuuyt+LJlFRUYSEhLS44AtSA26QlJQU5s6da3dP4xEjRjBx4kSbaTGjo6NZvXo148aNA+C9994jNjbWYptVq1YxePBgLl68SJ8+fUhJScHLy6va84WFhXH06NFq1/v4+PCnP/2JvXv3snfv3lrL7+HhwXPPPUdCQgK5ubkMGjSI66+/noiICAD69u3LRx99xG233UZ5eTlfffUVXbt2Ne/v6+trzt71+eef8+ijj1rk6BaiOQkMDCQuLq7W7YqLi8nJySE3N5dLly6Rk5NjtU15eTmHDh0iJyeH8PDwFhls7FH5BzyAv7+/OW9+SyQ14AYYPXo0bdu2tVhWWlrKkCFD2LhxIwCPPvoojz32GADx8fHmmZOqGjVqFNu2baOkpIS8vDwOHTpU7X/uvLw8/P397Z6DuDr+/v6MHDnSqunr2LFj9OvXjwsXLlBeXs6oUaNYv349nTt3JiEhATC+fMLDwzl16pR5v5kzZ5rnHt64cSMjRozAw8P2b7ycnByLSSOEaKm8vLxo3749vXr1IiEhgUGDBtGxY0eb254/f579+/c7uYRNR+X7t4DVjHAtjdSAG5mHhwepqanMmDGD5cuX89lnn7F169Za91NKMW7cOD7//HOys7OZNGkSR44csdgmOTkZb29vDh48yNKlSxscgKvTs2dPHnnkER544AESExOJiIhg/PjxFtscPXqU3bt3M3ToUPOy/v378/HHH3Pp0iXee+89brvtNj799FPz+itXrhAXF0dhYSFnzpzhq6++ckj5hWjKTD9eO3TowIEDBygpKbFYf/78eQIDA+nevbuLSug6VRMaVe1w1dK07KtzkcjISG6//XYmTpzIihUramwmrmzmzJmsXr2a1atXM2vWLKv1q1atYs+ePRw/fpwlS5Zw7Ngxq21+9atfERcXR1xcHKdPnzY/f/rpp+t0DXPmzCEnJ4dXX32VJUuWWKzLy8tj+vTpLF26lKCgIIt106ZNY/Xq1WzdupVRo0ZZrDM1QR84cIDPPvuMO+64g+aQClUIR2jXrh2DBg2yOSTpyJEjVrXB1qBqko2W3hQvNWAHycjIICQkxGpChZokJiaSkZGBn59fjekjQ0NDSUhIYOvWrfTs2dNi3csvv2x+HhYWZr7nWlcFBQXmTiF5eXnmuYRLSkqYPn06ycnJTJs2zWq/X/ziFwwaNIg777yzxl+vw4cP58KFC2RmZtKhQ4d6lVGI5s7Hx4eIiAj27Nlj8WO0vLycI0eONFqectPsa0VFRZSVlaGUwsvLi06dOtm1f1FREQUFBRbZqNzd3fH09MTb25ugoKAWX1t1hFYRgDdu3Gizs8+YMWMcMk/wmjVruHjxImlpaUycOJFt27YREhJi176LFy+udThCQUEBu3fv5uGHH26E0tr2yCOPkJycTM+ePbnnnntYt24dWmtmz55NeHg4Dz30kM39evbsydNPP23uTFadAwcOUFZWRrt27RxRfCGajTZt2tClSxeL/hRgNEX36dOnxhY0U18Tk7CwMHM/k7KyMk6dOsXp06errU1XF4BLSkrIzMzk0qVLZGdn15oUQylFUFAQXbt2JTQ01K6aqz3JTc6ePcvZs2erXT9s2LAaj1Hb/iaOiAP2aBUBOCkpiaSkJFJTUwGj93JjmDVrFhs3buTChQt069aNRYsWMXnyZBYuXMiXX35J9+7dmTt3LvPnz+ftt99m2bJl/OUvf+Hs2bPExMRw88038+abb1oc86abbqr2fMnJyfj6+lJUVERKSgqDBg1q8DWEhYWRk5NDcXExa9euZf369WRmZrJ9+3Y2b96Mu7s7H3zwAStXrqRfv368++67REdHmzuIPfPMM9x8880Wx7zvvvtsnst0DxiM4Rdvv/22w+5jC9GcdOvWjdOnT1vUgrXWnD9/nm7dutX5eDk5Ofzwww8UFRXVed99+/aRmZlZp9tDWmuys7PJzs7Gz8+PyMjIFt17ubG0qukIGzsAi+ZPpiMU9rBVWwsJCbFrGJK99u7dazUOtk2bNlbDESuzVQMOCQlhz549VvdTbbFV86uaTao+3N3diYqKqnGkQ13Se1anthqwvRxZA65pOsJWUQMWQoimrk2bNlYBOCcnB6213Z2RiouL+eGHHyyCb2BgIG3btsXHxwd3d3eKi4vJz88nMzOz1uMppQgICMDf3x8/Pz88PT3NrValpaVcuXKFnJwcq1SbZWVl7Nu3j0GDBlV7S8107Mry8/Mtat4eHh413pKreoy67u9qLgnASqmjQC5QBpRW9+vAbgsWgB2djW403QuoqAnXKC4Oli6tf5mEEKIOqo4oACOQXblyxe7xsGfOnDEHIH9/f/r3709wcLDNbfv162dzuVKK9u3b07FjR9q0aVPtWP7KCgsL+fnnny06nZaUlHDw4EGio6Nt7uPt7c3gwZZf/VVr3+3bt681l3PlY9Rnf1dyZQ14rNbaOu+YEEK0QgEBASilrO69FhYW2h2ATfsGBwcTHR1dY/CsrtfyoEGD7Aq6lZl6c/v5+Vlk38vKyqKgoKDFJ9Sor5bRBG1nTfWzRr4HfPbsWRYsWMD27dsJCQmhY8eOLF26tMYhRI62dOlS7r33XvMH/uabb+bvf/+73b2w62r37t289NJLvPXWWw45PsAf/vAHRo8eXWvPapOjR48yceJE9u7dS0ZGBs8995z5/r8QTZVSCk9PT6sex3XtSOXh4UFERESdg2jl/eurZ8+eZGVlWaSUPHPmDH369Kn3MVsyVw3c0sB6pdROpdS9LipDg2itmTp1KklJSRw+fJidO3fy//7f/+PcuXMuLdfSpUspKCgwv/7kk08cFnzB6AU9b948u7cvLS2t8zmefPJJu4NvVdHR0Zw8eZLjx4/Xa38hnMlW8Kvr/5lu3bq5bIpDpZRVms2q94fFVa4KwCO11gnATcCvlFKjq26glLpXKbVDKbXDns4CzrZhwwY8PT25//77zctiY2MZNWoUWmt+97vfERUVRXR0tEV+5KSkJGbMmMHAgQNJTk42NxmFhYXxxBNPkJCQQHR0NAcOHACMTgV33303iYmJxMfH89FHHwHGvaHf/va3REVFERMTw/Lly1m2bBmnT59m7NixjB071nxcU8eO559/nqioKKKiolha0Wpw9OhRwsPDueeee4iMjGT8+PFcuXIFgGXLlhEREUFMTAwzZ860eg9yc3PZs2ePuZfmH//4R26//XaGDx9Ov379eOONN8zXPWrUKCZNmkRERASFhYXcddddREdHEx8fz4YNGwCYPHky77zzDgCvvfYaycnJgNFiYZoVaufOnYwZM4ZBgwZxww03cObMGfPy2NhYYmNjLZKRAPzP//wPq1evrse/shDOZSsA29ObubLOnTs3VnHqpWpzc15eXp2vobVwSRO01vpUxd/zSqkPgUQgrco2rwOvgzEMyemFrMXevXurHYe7Zs0a0tPT+f7777lw4QJDhgxh9GjjN8bu3bv54Ycf6NKlCyNGjGDz5s2MHDkSMDoM7Nq1i7/+9a8sWbKEN998k6effpprr72WFStWcPnyZRITExk3bhzvvPMOR48eJT09HQ8PDy5evEjbtm15/vnn2bBhA+3bt7co086dO1m5ciVbt25Fa83QoUMZM2YMbdq04eDBg7z33nu88cYb3HrrrXzwwQfcdtttLF68mCNHjuDt7c3ly5etrnPHjh1WUzHu2bOHLVu2kJ+fT3x8PBMmTABg165d7N27l169evHcc8+hlCIjI4MDBw4wfvx4fvrpJ15//XVGjBhh3qbq8IKSkhIefPBBPvroI0JDQ3n//fd57LHHWLFiBXfddRcvvfQSo0eP5ne/+53FfoMHD2bx4sUOTVwiRGNo6LBQX1/fRq/9lpWVcfnyZfLz88nPz6ekpISysjKrvM2Vt6+svLyckpISl9XKmzKnB2CllD/gprXOrXg+HnjSkeesmglr0aJFgOMyYW3atIlZs2bh7u5Ox44dGTNmDNu3bycoKIjExETzwPq4uDiOHj1qDsCm1I6DBg1izZo1AKxfv56PP/7YnI+5sLCQ48eP88UXX3D//febfzFXnZXJVpmmTp1qHhw/bdo0vvnmGyZNmkSvXr3M4xkHDRpk7kQRExNDcnIyU6ZMYcqUKVbHPHPmDKGhoRbLJk+ejK+vL76+vowdO9acBSwxMZFevXqZy/Lggw8CMHDgQHr27MlPP/1ETEwMTz75JGPHjuXDDz+0uqYff/yRvXv3cv311wPGf/TOnTtz+fJlLl++bP6Rc/vtt1tMAtGhQwdOnz5d4/sjRFNgq7m5LikeTSljG0Nubi4nTpwwz4rWEKWlpRKAbXBFDbgj8GHFuDYP4O9a688ceUJTJqzGFBkZaW4WrYvKH0J3d3eL/3CmdZWXa6354IMPGDBgQANLbH+ZTE3Q//nPf0hLS+Pf//43Tz/9NBkZGRZNZL6+vlYD9quOVzS9tjcrTkZGBu3atbMZMLXWREZG8t1331kst1U7r6ywsBBfX1+7zi+EK9kKwHXpFGVrYoe6Ki8v5/Dhw1apMRuiPn0/WgOn3wPWWv+stY6teERqres2TU8Tce2111JUVMTrr79uXrZnzx6++eYbRo0axfvvv09ZWRmZmZmkpaWRmJhYr/PccMMNLF++3Nw0tXv3bgCuv/56XnvtNfMH++LFi4DxC7jqpNZgzDe8du1ac1L2Dz/80Gq2osrKy8s5ceIEY8eO5c9//jPZ2dnk5eVZbBMeHs6hQ4csln300UcUFhaSlZXFxo0bGTJkiM2yrFq1CoCffvqJ48ePM2DAALZt28ann37K7t27WbJkidV0jAMGDCAzM9McgEtKSvjhhx8ICQkhJCSETZs2AZiPbfLTTz9ZNZUL0dSUl5fbDFR1qTk2pAezqQz79u1r1OALDW9ab6laxjAkF1BK8eGHH7JgwQL+/Oc/4+PjQ1hYGEuXLmXkyJF89913xMbGopTiL3/5C506dTJ3rKqLxx9/nAULFhATE0N5eTm9evVi3bp1zJkzx9xs6+npyT333MPcuXO59957ufHGG+nSpYu5cxNAQkICKSkp5h8Cc+bMIT4+3mLMXmVlZWXcdtttZGdno7Vm3rx5Vr2pBw4cSHZ2Nrm5ueamr5iYGMaOHcuFCxd4/PHH6dKlCz/99JPFfr/85S954IEHzOMUTUOE7rnnHlauXEmXLl147rnnuPvuuy3mDPby8uJf//oX8+bNIzs7m9LSUhYsWEBkZCQrV67k7rvvRillNXfxhg0bzPeihWiq8vLybAaqurTeNHT6PlOTc1Xe3t60a9eO4OBg831md3d33NzcrJrIL1++XO9Z2FqbVpULWjS+F154gcDAQObMmcMf//hHAgIC+O1vf+vqYpkVFRUxZswYNm3aZLN2IJ8jYQ9n5II+efKkVYuSu7s7I0eOrDaw1jQbUl0VFxezZcsWi/u9Sin69OlD165d7Q7uWVlZZGRkWCyLi4uzazhk1UxWnTp1qlMmq4bu7wg15YKWCRxFgzzwwANNunPF8ePHWbx4cYOb5oRwtEuXLlktCw4Odtqk9FlZWVadrXr37k23bt3qVAa532s/+VYSDeLj48Ptt98OGOOAm5p+/fpVm/NWiKaioKCArKwsq+XOnC/b1I/ExMPDg65du9b5OKZOnKJ2UgMWQggXO3nypNUyNzc3q2F+jlQ15WVQUFCdhkCZ5OTkNFaRWjwJwEII4UIXL160OeyuQ4cOeHl5Oa0cJSUlFq/rc9umpKSk1mGBjlS1qbyp93GSACyEEC5y5coV9u/fb7Xczc3NnLjGWUzz/JpUDcj2OHXqlEvTTla9huqydTUVcg9YCCFc4MKFCxw4cMBmp6U+ffo4vXNj1dp2Tk4OZWVlVkGtOvn5+S6f9KRqrb2p34+WGnA9mZJUREREEBkZyYsvvljrPi+99BJ9+/ZFKWUx1i41NRWlFF988YV52dq1a1FKmbNtJSUlMWDAAOLi4ggPD7dIAFJZSUkJCxcupF+/fiQkJDB8+HCLtIyusHbtWvbt22d+/Yc//MHiWoVoTXJzc9m/fz979+61GXw7depUr85PDRUcHGzxuqysrNo8AVUVFhaSkZHh8kkXqmbcy8/Pt8rW15RIDbiePDw8eO6550hISCA3N5dBgwZx/fXXExERUe0+I0aMYOLEiTbTYkZHR7N69WrztHvvvfeeeZYhk1WrVjF48GAuXrxInz59SElJsfrV+vjjj3PmzBn27t2Lt7c3586ds8iD7Qpr165l4sSJ5vfmyScdmvpbiCaluLiY3NxccnJyuHTpUo2dlDp16uTQtLM1CQ0Ntco+d+LECdzc3AgLC6t2KNK5c+c4fPiweR5jd3d3lzX9BgcHW2Xx2rdvH/369WvUPNmNRQJwPXXu3Nk87VdgYCDh4eGcOnWK/v37M3z4cJ599lmSkpJ49NFHcXNz4+mnnyY+Pr7a440aNYpvvvmGkpISioqKOHToULWD/PPy8vD397dqGiooKOCNN94wz2AE0LFjR2699VbACOrPPPMMWmsmTJjAn//8ZwACAgKYP38+69atw9fXl48++oiOHTuSkpJCUFAQO3bs4OzZs/zlL39hxowZADz77LP84x//oKioiKlTp5onuHjnnXdYsmQJSiliYmJ44IEH+Pjjj/n666956qmn+OCDD/jTn/7ExIkTmTFjBl9++SW//e1vKS0tZciQIbzyyit4e3sTFhbGnXfeyb///W9KSkr45z//ycCBA/n666+ZP38+YHS4SEtLa5L/sUTLl5ubS9UEQSZlZWWUlpZSWlpqV0cgd3d3evfu7ZKar4mfnx8dO3a0mtP82LFjnD17ltDQUPP3TmlpqXnoVOVmXjc3N/r06WOV/c5Z2rdvj4eHh0XLQk5ODjt37sTd3R1vb2+bPbsHD7aZJ8PhJAA3gqNHj7J7926GDh1qTq04Y8YMli9fzmeffcbWrVtrPYZSinHjxvH555+TnZ3NpEmTrH6NJicn4+3tzcGDB1m6dKlVAD506BA9evQgKCjI6vinT5/mkUceYefOnbRp04bx48ezdu1apkyZQn5+PsOGDePpp5/m4Ycf5o033uD3v/89YMx4tGnTJg4cOMCkSZOYMWMG69ev5+DBg2zbtg2tNZMmTSItLY127drx1FNP8e2339K+fXvzFImTJk0yB9zKCgsLSUlJ4csvv6R///7ccccdvPLKKyxYsACwPT3jkiVLePnllxkxYgR5eXn4+PjU5Z9KiEZTVlZmlR+9rkwT2Pfq1atJJLTp168fubm5FBQUWCwvKiqyOVSqMqUUkZGRdt8zdgQ3Nzf69u1rM+1vWVmZ1XW5mtwDbqC8vDymT5/O0qVLzYEvMjKS22+/nYkTJ7JixQq7hxLMnDmT1atXs3r1ambNmmW1ftWqVezZs4fjx4+zZMkSjh07Znc5t2/fTlJSEqGhoXh4eJCcnExamjEFs5eXFxMnTgQspyMEmDJlCm5ubkRERJh/Ga9fv57169cTHx9PQkICBw4c4ODBg3z11Vfccsst5rmIa5si8ccff6RXr170798fgDvvvNNcJrCcntFUphEjRvDQQw+xbNkyLl++LBmuRLMUGBhI7969GTZsGAMHDmwSwReMW2uxsbE2f8TXxMvLi9jYWKcmDqmOqRnflT8E7CXfXg1QUlLC9OnTSU5ONgcLk4yMDEJCQjh//rzdx0tMTCQjIwM/Pz9zULIlNDSUhIQEtm7dSs+ePc3L+/bty/Hjx8nJyanTfyBPT0/z/Z3qpkiEq2PqtNY8+uij3HfffRbHWb58ud3ntIet6RkXLlzIhAkT+OSTTxgxYgSff/65y3O9ClGVaZICT09PvLy88PHxwdfXl4CAAIKDgxtl2kBH8fb2Ji4ujjNnznDixIkaOzH5+PjQuXNnunbt2qR+DHfu3JnQ0FAuXLjApUuXyM/Pp6ioiLKyMpd3FKus6bxjDrRx40abHZHGjBlT73mCtdbMnj2b8PBwHnroIYt1a9as4eLFi6SlpTFx4kTzpPT2WLx4ca3NqgUFBezevZuHH37YYrmfnx+zZ89m/vz5vPbaa3h5eZGZmcnGjRsZOXIk8+bN48KFC7Rp04b33nuPBx98sE7XbHLDDTfw+OOPk5ycTEBAAKdOncLT05Nrr72WqVOn8tBDD9GuXTtzE3R1UyQOGDCAo0ePcujQIfr27cu7777LmDFjajz34cOHiY6OJjo6mu3bt3PgwAEJwMLhfHx8Gn1O8cbgqDK5ubnRtWtXunbtSkFBAbm5uRQXF1NeXo6bmxve3t4EBATg5+dntW9ISEi9yzVs2LAGlvwqDw8POnXqRKdOnRrtmI2tVQTgpKQkkpKSzNPepaSkNPiYmzdv5t133yU6OtrcWeqZZ54hMTGRhQsX8uWXX9K9e3fmzp3L/Pnzefvtt1m2bBl/+ctfOHv2LDExMdx88828+eabFse96aabqj1ncnIyvr6+FBUVkZKSwqBBg6y2eeqpp/j9739PREQEPj4++Pv78+STT9K5c2cWL17M2LFjzZ2wJk+eXK9rHz9+PPv372f48OGA0Ynrb3/7G5GRkTz22GOMGTMGd3d34uPjSU1NZebMmdxzzz0sW7bMPKwKjC+1lStXcsstt5g7Yd1///01nnvp0qVs2LABNzc3IiMja3y/hBAN5+fnZzPQioZrVdMRNmYAFi2DTEcohHAkmY5QCCGEaGJaRBP0gs8WkH42vdbtzp49C1ytCdckrlMcS29c2rCCCSGEENWQGnADXblyhTFjxjgs88vHH3/M4sWL67RPWFgYFy5coLi4mNGjR8sE2UII0QS1iBqwvTVVR9wDXrFiBdOmTbN7zFldkpsDTJo0iUmTJtWrbF5eXlx33XW8//77JCcn1+sYQgghHENqwA20atUqJk+ezMaNGxk9ejQTJkxgwIAB3H///ebxZgEBAfzmN78hNjaW7777jueff56oqCiioqJYunQpAC+88AJ33303YIwhjoqKoqCggNTUVObOnQtAZmYm06dPZ8iQIQwZMoTNmzcDkJWVxfjx44mMjGTOnDkWqe+mTJnCqlWrnPiOCCGEsIcE4AYoLi7m559/JiwsDIBt27axfPly9u3bx+HDh1mzZg1gzMgxdOhQvv/+e3x9fVm5ciVbt25ly5YtvPHGG+zevZv58+dz6NAhPvzwQ+666y5ee+01q67/8+fP59e//jXbt2/ngw8+YM6cOQAsWrSIkSNH8sMPPzB16lSLKcGioqLYvn27c94QIYQQdmsRTdCucuHCBYsEG4mJifTu3RuAWbNmsWnTJmbMmIG7uzvTp08HYNOmTUydOtU8bda0adP45ptvzGNmY2JiuO+++xgxYoTV+b744guLaf1ycnLIy8sjLS3NHOwnTJhAmzZtzNu4u7vj5eVFbm6uTFoghBBNSKsIwFUzYZlm7mlIJiwAX19fizRtVafrMr328fGx677vwYMHCQgI4PTp0zbXl5eXs2XLljpPQFBUVCSTFgghRBPTKpqgk5KSeOKJJ6weDU3j1qZNG8rKysxBeNu2bRw5coTy8nLef/99Ro4cabXPqFGjWLt2LQUFBeTn5/Phhx8yatQosrOzmTdvHmlpaWRlZVlkjDIZP368Rb7l9PR0AEaPHs3f//53AD799FMuXbpk3iYrK4v27ds36dyzQgjRGrWKAOxI48ePZ9OmTQAMGTKEuXPnEh4eTq9evZg6darV9gkJCaSkpJCYmMjQoUOZM2cO8fHx/PrXv+ZXv/oV/fv356233mLhwoVWEzksW7aMHTt2EBMTQ0REBK+++ioATzzxBGlpaURGRrJmzRp69Ohh3mfDhg1MmDDBge+AEEKI+mhVqSgdYdeuXbzwwgvMnj2bJUuWsG7dOlcXycK0adNYvHhxjbMrtWZN5XMkhGiZJBWlAyUkJDB27FiHJeJoiOLiYqZMmSLBVwghmqBW0QnL0Uzjd6+77joXl8SSl5cXd9xxh6uLIYQQwgapAQshhBAu0KwDcHO4fy2aLvn8CCFcqdkGYB8fH7KysuRLVNSL1pqsrCwZHy2EcJlmew+4W7dunDx5kszMTFcXRTRTPj4+dOvWzdXFEEK0Ui4JwEqpG4EXAXfgTa113ebbAzw9PenVq1ejl00IIYRwBqc3QSul3IGXgZuACGCWUirC2eUQQgghXMkV94ATgUNa65+11sXAamCyC8ohhBBCuIwrAnBX4ESl1ycrlgkhhBCtRpPthKWUuhe4t+JlkVJqryvL08q0By64uhCtiLzfziXvt3O19ve7Z3UrXBGATwHdK73uVrHMgtb6deB1AKXUjupyaYrGJ++3c8n77VzyfjuXvN/Vc0UT9Hagn1Kql1LKC5gJfOyCcgghhBAu4/QasNa6VCk1F/gcYxjSCq31D84uhxBCCOFKLrkHrLX+BPikDru87qiyCJvk/XYueb+dS95v55L3uxrNYj5gIYQQoqVptrmghRBCiOasSQdgpdSNSqkflVKHlFILXV2elkwp1V0ptUEptU8p9YNSar6ry9QaKKXclVK7lVLrXF2Wlk4pFaKU+pdS6oBSar9Sariry9SSKaV+XfFdslcp9Z5SSmY+qaLJBmBJWel0pcBvtNYRwDDgV/J+O8V8YL+rC9FKvAh8prUeCMQi77vDKKW6AvOAwVrrKIwOtzNdW6qmp8kGYCRlpVNprc9orXdVPM/F+HKSDGUOpJTqBkwA3nR1WVo6pVQwMBp4C0BrXay1vuzSQrV8HoCvUsoD8ANOu7g8TU5TDsCSstJFlFJhQDyw1cVFaemWAg8D5S4uR2vQC8gEVlY0+b+plPJ3daFaKq31KWAJcBw4A2Rrrde7tlRNT1MOwMIFlFIBwAfAAq11jqvL01IppSYC57XWO11dllbCA0gAXtFaxwP5gPQrcRClVBuMFsteQBfAXyl1m2tL1fQ05QBsV8pK0XiUUp4YwXeV1nqNq8vTwo0AJimljmLcXrlWKfU31xapRTsJnNRam1p1/oURkIVjjAOOaK0ztdYlwBrgGheXqclpygFYUlY6kVJKYdwf26+1ft7V5WnptNaPaq27aa3DMD7bX2mtpYbgIFrrs8AJpdSAikXXAftcWKSW7jgwTCnlV/Hdch3S6c1Kk50NSVJWOt0I4HYgQymVXrHs/yqylgnREjwIrKr4Qf8zcJeLy9Niaa23KqX+BezCGGGxG8mIZUUyYQkhhBAu0JSboIUQQogWSwKwEEII4QISgIUQQggXkAAshBBCuIAEYCGEEMIFJAALIYQQLiABWIhmRinVTimVXvE4q5Q6VfE8Tyn1Vwedc4FS6o4a1k9USj3piHML0VLJOGAhmjGl1B+BPK31EgeewwMjoUKC1rq0mm1UxTYjtNYFjiqLEC2J1ICFaCGUUklKqXUVz/+olHpbKfWNUuqYUmqaUuovSqkMpdRnFXm/UUoNUkp9rZTaqZT6XCnV2cahrwV2mYKvUmqeUmqfUmqPUmo1gDZ+yW8EJjrlYoVoASQAC9Fy9cEInpOAvwEbtNbRwBVgQkUQXg7M0FoPAlYAT9s4zgig8qxNC4F4rXUMcH+l5TuAUY1+FUK0UE02F7QQosE+1VqXKKUyMPKpf1axPAMIAwYAUcB/jRZk3DHmbq2qM5aJ9Pdg5FReC6yttPw8xtRzQgg7SAAWouUqAtBalyulSvTVDh/lGP/3FfCD1np4Lce5AvhUej0BGA38D/CYUiq6onnap2JbIYQdpAlaiNbrRyBUKTUcjPmglVKRNrbbD/St2MYN6K613gA8AgQDARXb9Qf2OrzUQrQQEoCFaKW01sXADODPSqnvgXRsT5r+KUaNF4xm6r9VNGvvBpZprS9XrBsL/MeRZRaiJZFhSEKIWimlPgQe1lofrGZ9R+DvWuvrnFsyIZovCcBCiFoppQYAHbXWadWsHwKUaK3TnVowIZoxCcBCCCGEC8g9YCGEEMIFJAALIYQQLiABWAghhHABCcBCCCGEC0gAFkIIIVzg/wPHlNle/jTuaQAAAABJRU5ErkJggg==\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -960,56 +580,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Eventful Evaluation"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Eventful Evaluation"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n",
-      "output/TIEyS0-R0-2R1-2E10R0-1E15R0-2T30.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -1018,56 +608,26 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ],
    "metadata": {
     "collapsed": false
-   }
+   },
+   "source": [
+    "### Comparisons to a Direct Connection"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOEyS0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n",
-      "output/TIEyS0-DR0-2T10S1-R0-1R1-1T10S2-DR0-1T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAFNCAYAAAAkQ5dvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABJ9UlEQVR4nO3dd3zV9fXH8dfJDhshQAQhqICBAGGKRSGodUFxURelRbRWWqu0tRVrHVi1tFq14qpViraI1jprrWKtQF0owwIC/gRFVtgrYWR+fn98b25yk3uTG5Kbe5O8n4/Hfdx7v+Pek5vknu9nm3MOERERiT1x0Q5AREREglOSFhERiVFK0iIiIjFKSVpERCRGKUmLiIjEKCVpERGRGJUQ7QDqU8eOHV1GRka0wxAREamVpUuX7nLOpVXe3qSSdEZGBkuWLIl2GCIiIrViZl8H267qbhERkRilJC0iIhKjlKRFRERilJK0iIhIjFKSFhERiVFK0iIiIjGqSQ3BEglmwYIFLFy4sMr20aNHk5OT0/ABiYiESUlamrycnBxycnKYM2cOAJMnT45qPCIi4VJ1t4iISIxSkhYREYlRStIiIiIxSklaREQkRilJi4iIxCglaRERkRilJC0iIhKjNE5aROqVJo8RqT9K0iJSrzR5jEj9UXW3iIhIjFKSFhERiVFK0iIiIjFKSVpERCRGKUmLiIjEKCVpERGRGKUhWCIiImFq6HkAlKRFRETC1NDzAKi6W0REJEYpSYuIiMQoJWkREZEYpTZpEZFGTAuaNG0RS9JmNhsYB+xwzmX5tj0P9PEd0g7Y55zLDnLuBiAPKAGKnXNDIxWniEhjpgVNmrZIlqTnAA8Dz5RtcM5dWvbYzH4P7K/m/DHOuV0Ri05EIqJyyW7GjBmASnYiRyNiSdo5t8jMMoLtMzMDLgFOj9T7i0h0lJXsZs6cCcD06dOjHJFI4xWtNunTgO3OuS9C7HfAfDNzwB+dc080XGjS1KhkJyKNVbSS9OXAvGr2n+qc22JmnYC3zWytc25RsAPN7BrgGoDu3bvXf6TS6KlkJyKNVYMPwTKzBOAi4PlQxzjntvjudwAvA8OrOfYJ59xQ59zQtLS0+g5XREQkaqJRkj4TWOuc2xxsp5m1BOKcc3m+x2cBdzZkgCIijYWac5q2SA7BmgfkAB3NbDNwu3PuKeAyKlV1m9mxwJPOufOAzsDLXt8yEoBnnXNvRipOETkKhYWwfTvk5ga/bdvGD//v/0g+cgQefRQ6dvRuaWnljyveyrZ36ACJidH+6RoVNec0bZHs3X15iO2Tg2zbCpzne/wlMDBScYlINfLzqyTboEl49+6q55p5yTY9HdLT2eAcBSkpDOvVC3buhF274Msvvfv91Yy+bNs2eAIPldzbtYM4TZ4oDSMvDz75BP7xjwHs25dKpIela8axKNEsQdJgnIM9e6ot9fof5+dXPT8xEbp08ZLvCSfAqaf6EzHp6f59pR07ceBwInv2wN698Oijz1FSEsddv76Erl29HO5XWOjFVJa8g9127oStW2HFCu/xkSPBf764OK8EXpvE3rJlpYBEqiothbVr4aOPym+rVnn/UjCYrl33UlQU2cofJWmRxqq4OLDKOVSpd9s2KCqqen6rVuWJdtAgOO88XJd0Cjukk9cqnT3J6exKTGdH8THs3Wf+5LtnD+xdA3ver/B8L+zb532plbsMgKef9vL40KEwbFjZfRJpXbp4O8J16FB58q4usf/f/8EHH3jPS0qCv1ZycvXV7sFuycnhxyqN0u7dsHhxeUJevBgOHPD2tW8PJ58MF18Mp5wCX3zxLC1bFpKYODmiMSlJR4nakSSkw4fDK/Xu3Fl2SR+oQwdcl3SKOqZzeMhJ5LdO50BqF3YnpbMjPp2tLp1Nxelsy29VnmRXwZ5FXrItKAgdWlyc92V1zDHefYcOcOKJ5c8r3v/zn38FICvrO3zyCSxZAv/8Z3nI3btXTNowZIhXcx1SixbeSeEOtXTOq1avmMBDJfdly7z7vXtDv17r1rVL7MccA/Hx4cUqDa64GFauLE/IH34IX/hm7oiLgwED4IorYMQI79arV2CrytathQ0Sp5K0SENwzitqVlfiLbuVXbpXPD0+noJ2nTnUNp28lsexN2M4u05MZ5uls6U0nY2FXfjycDrr8ruwfW8SeZ9VH07r1oFJNTOzapINdt+6dfjNv6tXewM4fvzj8m0HDsDy5fiT9iefwIsvlu/v1SuwxD14sFczfVTMvKzfrp13JRGO4mLvqqWmxL5zJ6xe7T0+eDD0+x9zTPXV7pW3tWmjavgIyc0NrLZessSrnAHo3NlLxFdd5d0PGeJVNMUCJWmRuigp8b6wqynxlm7NxbZvw4K0qRYmpLK/hVe1vCOuP9tSv8mmxHQ2FKSz/lA6m0vTySWdXSUdcbvjoEJ/raSkSkk0Hb5RQ5I95hgvZ0WrA3WbNjB6tHcrs2eP94VZlrT/+1+Y5xv/ERfnXUBULHEPGAApKREKMCEBOnXybuE6fNirJ60psX/1FXz8sfc4WPMDeL+YUEk9VGJPTa2fn70JKSjwLgY//LA8KW/c6O1LTPQu/r7//fJSco8esXttpCQtEkxBQUCyLd2Sy5ENuRRtzMVtySVuey4Ju7eRsn87ca60yukH4tqxLc4r5W4pHUkuXrLdRhf/41zSyStuQ7t445g2VZNpdns4vZpkm5oau18stXHMMXDWWd6tzLZt5Um7rJrct8gTiYnQv39gibtfvyiO3EpNhW7dvFs4nPO6CFcumQdL7CtXevv27AnetAFeM0DHjnyvpIQD7dp5zQHnn1+HKojGxTn4+uvAUvLy5V7fRPAS8CmnwE9+4iXk7OwIXuRFgJK0NEnOld9KS71bUVEC8YcK2fru5xxan0vBhlxKtnhJOH5nLsm7c2lxIJc2+bm0Kgpsm4wDkoljP50qJNtB/mS7Nzmdg228TlclHTvTKi21SlLtHiTZtm2r0UPBdOkC48Z5N/B+j5s2BVaTP/88POGb1T8lxfvyrVji7t07RpuEzbwqhTZt4PjjwzunpMRrLw9W7e57fHDxYtI3bYKJE70EfcEF3uMzz2xSY8/z872/gYpJeft2b19qqve7nzbNS8gnnwzHHhvVcOtMSTqKduyATz4ZgHPGH/8YmFAq3oJtr82xzfE1nHN0ZQuDWM4gljOYZXyX5fRgI8y8JeD3UECSL/Gmszu5D/ta5nCwdRcOt0unqEM6pZ3TieuaTlLXNNqnJfiTbM8KyTYpKUp/RM2EWXmfsYsv9raVlsL69YEl7tmzYdYsb3+rVl7bYsUS9/HHN9Lah/j48urtEP4+cyaUljJ95EiYOxdeeMG7T0uDSy7xEvaIEY3qAygt9TpzVUzIK1aUjyLo3RvOPru82jorq0ldjwBK0lH15Zfw0kvnAfDyy0f/OmZeaazsvuIt2Lbabq/NsQkJDR9HHKWk7fuCbjuXc+yO5Ry7fTnp25bT8pC3HLkzY0+HXqxKOIF323yTjNNyiO/ahaQe6bQ8MZ02PdrTsYPRQ0NnG5W4OK+jWa9ecLlv6qSSEm9ca8US96xZ5VWf7dtXHgpG1THcjVlcXHmj/6xZ8OabXqJ+6il45BHvKuWKK7xbZma0o61i716v2b7iEKiyDvdt2ngl41tu8aqvhw/3Rhc0dUrSUTRoENx00yOYOX784+uOKoGZNaEvmHAUFMBnn3mNTmW3//2vvIdtYqJ3OZ0z3vuABw3CBg6kQ6tWfOgb7jZ5+nei+ANIJMXHe+3T/frhnwmqsNCbgKJi4v7tb8uHUFcewz10aO36jcWs5GSvbfr8871u9S+9BM8+C/fcA3fd5f1/TJwIl13mXak0sJIS71+5bPjTRx95F1jgfadlZcGECeWl5JNOap5NQ0rSUZScDO3a5QGNv90kIvLyvARcloyXLfOGvZT1jG3VymuInDLFn5Dp21d1zxIgKcnrzTt4MPzgB962w4fh00+rdk476jHcsa5NG++qZfJkr0Pk8897Jewbb4Sf/xxycryEffHFEftBt28PnCjk44/Lr607dvRKx5MmeQl56FAvZFGSllixY0dg6Xj5cli3rvxbMy3NS8LnnON92w4a5E1R2RwvrWNcY1iVKTXVSwqnnFK+rbZjuAcNip2xtLWSnu71rJo2zZud7dlnvYR99dXwwx/C2LFewh479qi7QRcWehdBFduSv/rK25eQ4F1bX3lleSm50fYVaABK0tKwnIMNG6om5K1by4/JyPC+ASdNKi8hH3us/osbibLZ9Ob4xkxNjvQKBPXkaMdwlyXuiI/hjoTeveGOO+D2270fcu5ceO45r5NM27ZeyXriRO9DCdFV3jnYvDkwIS9dWj5zXdeu3sXQj37kJeTBgzW0uzaUpCVyiovh88+rJuR9+7z9Zd9yp59enoyzs73ePSIxIJwx3G+84c1PDl4pccCAGBrDHS6z8iuN++6D//zHS9h/+5vXZf7YY72264kTOdRnEEuXWUBSLrvGTknxmgauu668lBzu8HEJTkla6sfhw97ECxWT8YoV5SsXpaR4M1Bcckl5dXX//rqklkanSY/hBu9Kw3dl4h57nO1P/oOip+eS/uAsEu6/n685iflcwbNcgZ1wAmPGlCfkAQOafpeQhm7OUZKW2tu3r2rpeO3a8u6ybdt6SXjq1PIS8kknef/8Ik1MUxrDfeBA4BCojz5KZffuS4BLOK7lHqZ1+zsXHprLrzfdxq+5DdJGwMlXwCWXNpEu8bFH35oSmnNeT9DKCbmsBwh41WCDBsGFF5Yn5IyM6H/biERRYxjDXVoKa9YEzm+9enV5X82+fb3RW2Wl5L59jyE+/hrgGm8i7Oee86rEr7/em3Pzm9/02q8vuKCR9qgLT0P3uVCSjpKY6wFbdulfOSHv2FF+zIknet8e3/++V2Wdne0tHyMiNapuDHfFEnfFMdydOwcm7bqM4d61q+oQqIprJY8YAZde6t0PG1bDSKzu3eEXv/Buq1Z5yfrZZ73OnqmpXnafONGbDizmG+Rjm5J0lES1B2xhoXfJXHlCkDxvzDYJCd43yXnnlZeOBw7UwEWRelZxDPc113jbDh/2/h0rlrgrj+GuPPlK5YRaVOR1CanYuWvdOm9ffLzXdlw2S2jZWslHXWLPyoLf/Abuvhs++KC8w9lzz3lTgn37296bfeMbGjJ5FJSkm7qDBwMnBFm+3LvyLatja9nSS8Df/W55Qu7Xz5tpRUQaXGpqefIsk5fnzeVTscT90kvl+088EVq2/BatWh3kjTe8/YcPe/u6dPGGQJUtzThkSIQWyIqLg1NP9W5/+APMn+8l7Kefhscf95ajKpuSNCsrAgE0TUrSTcmuXVWrq//v/8ovwTt08JLwtGnlCfnEE2O4m6k0RjHXlNMEtG5d8xjud989jvz8Fgwb5s2sVpbou3ePQheRpKTyLvB5efDKK151+O9+55W6y4ryl18Oxx3XwME1LuZCrVHaCA0dOtQtWbIk2mHUylFVd5eN+Vi2LDAhb95cfkz37uWJuOzWrVuz7NBVOWmUUdKQpmTmzJmUlsIvfzk92qGEtn27VxU+d67XQA4wapSXsCdM8AamNxL13VRpZkudc0OrbFeSjq4af9ElJV5puHIJec8eb39cHPTpE5iMs7Obx/IwtdTYZsASCUejvQhdv758StLPP/c6mJ13nlcd/q1vxfwcCg2VpFXdHUuOHPHaiytPCHLokLc/KcmrJrr44vKE3L9/hBqYRKQxaKzTsHLCCXDrrfCrX3m1gs8+6825+uqrXv3+RRd5JewxY5r1HAvN9yePBbm5ZM6fT4eNG+H++71Bi8XF3r42bbwS8fe/X56QMzM1nEFEmhYzrzfbkCFem/WCBV7C/vvfvU5nnTv7pyRl6NBm12SnJB1NW7dy8rx5HGrb1hue8K1vlSfknj01XEFEmpf4eDjjDO/2yCPe2LO5c+Gxx7we4716edXhEyd6j5sBJeloGjCA5x98kMNt2zaeKioRkYaQkuI17V18sTcV8Ysvegn7zjthxgxvoPgVV3il7C5doh1txESsqGZms81sh5mtqrDtDjPbYmaf+m7nhTj3HDP73MzWmVkMd1Wso8REDrdtG+0oRERiW7t2cNVV3upcGzd6K3UVF3vTkXbt6i0I8vTT5VOoNSGRrE+dA5wTZPsDzrls3+2NyjvNLB54BDgX6AtcbmZ9IxiniIg0Ft26wc9+5nU2W70abr7Zm05t8mSv/fqSS7zOZ2UTNjVyEUvSzrlFwJ6jOHU4sM4596VzrhB4Dji/XoMTEZHGLzMT7rrLG871wQdeafvdd71FPrp08WZ1WbjQW5ugkYpGz6TrzGyFrzq8fZD9XYFNFZ5v9m0TERGpysyb+/Thh2HrVnjjDW/M9dy5kJPjrcx3003ekNZGNjdIQyfpx4ATgGwgF/h9XV/QzK4xsyVmtmTnzp11fTkREWnMEhPh3HPhr3/1ZjibO9ebX+L++711Cvr396Ym/frraEcalgZN0s657c65EudcKfAnvKrtyrYAFSdz7ebbFuo1n3DODXXODU1LS6vfgEVEpPFq2dLrAf76614J+5FHoG1b+OUvvdL1qad6w7t27Yp2pCE1aJI2s/QKTy8EVgU57BOgl5n1NLMk4DLgtYaIT0REmqi0NPjhD+H99+HLL72lNffu9balp3vzVDz3XPkMjzEikkOw5gEfAn3MbLOZXQX8zsxWmtkKYAzwE9+xx5rZGwDOuWLgOuAtYA3wN+fcZ5GKU0REmpmePb3S9KpV8Omn3lCuTz/1VuXq1AkmTYI33yyfATKKIjaZiXPu8iCbnwpx7FbgvArP3wCqDM8SERGpN2ZeO/XAgTBzJixa5E1J+sILXpt2Whpceqk3w9nJJ0dlSlLNOykiIhIX5/UEf+IJ2LYNXn7ZW8D7T3/yeo6feKK3IMjatQ0bVoO+m4iISKxLTvbGWr/wgtdD/M9/huOPh3vu8cZmDxlC37feInXv3oiHoiQtIiISStu23mxmb78NmzfDAw9AXBzDn3uOi6ZPh8OHI/r2StIiIiLhSE+HadPgk0946Z57eH/KFEhNjehbahUsERGRWjqQns6B9PSaD6wjlaRFRERilJK0iIhIjFJ1t4hII7ZgwQIWLlzofz5jxgwARo8eTU5OTpSikvqiJC0i0ojl5OQoGTdhqu4WERGJUUrSIiIiMUrV3dLkqc1ORBorJWlp8tRmJyKNlaq7RUREYpRK0lGiKlgREamJknSUqApWRERqoupuERGRGKUkLSIiEqOUpEVERGKUkrSIiEiMUpIWERGJUUrSIiIiMarGIVhmFgcMBI4FDgOrnHM7Ih2YiIhIcxcySZvZCcBNwJnAF8BOIAXobWaHgD8CTzvnShsiUBERkeamupL0XcBjwA+cc67iDjPrBFwBTAKejlx4IiIizVfIJO2cu7yafTuAByMRkIiIiHhq7DhmZt82s9a+x7ea2UtmNjjyoYmIiDRv4czdfatz7gUzOxU4A7gXrxr85OpOMrPZwDhgh3Muy7ftXuBbQCGwHrjSObcvyLkbgDygBCh2zg0N9wcSERGJlIZeHMkqNTdXPcBsuXNukJn9BljpnHu2bFsN540C8oFnKiTps4D/OOeKzey3AM65m4KcuwEY6pzbVZsfZujQoW7JkiW1OUVERCTqzGxpsAJpOOOkt5jZH4FLgTfMLDmc85xzi4A9lbbNd84V+55+BHQL4/1FRESapXCS9CXAW8DZvqrpY4Cf18N7TwH+FWKfA+ab2VIzu6Ye3ktERKTRqbFN2jl3yFf9fK6ZnQO875ybX5c3NbNbgGJgbohDTnXObfEN9XrbzNb6SubBXusa4BqA7t271yUsERGRmBJO7+7b8MZCdwA6An82s18d7Rua2WS8DmUTK4+/LuOc2+K73wG8DAwP9XrOuSecc0Odc0PT0tKONiwREZGYE07v7onAQOfcEQAzmwl8ijfZSa34SuK/AEY75w6FOKYlEOecy/M9Pgu4s7bvJSIi0tiF0ya9FW860DLJwJaaTjKzecCHQB8z22xmVwEPA63xqrA/NbPHfccea2Zv+E7tDLxnZv8DPgb+6Zx7M+yfSEREpIkIpyS9H/jMzN7G69D1TeBjM3sIwDl3fbCTQsxY9lSIY7cC5/kef4m3oIeIiEizFk6Sftl3K7MgMqGIiIhIReH07n7azJKAk/BK0p875wojHpmIiEgzF8560ufhLUu5HjCgp5n9wDkXaoyziIiI1INwqrvvB8Y459aBf53pfxJ6IhIRERGpB+H07s4rS9A+X+ItfiEiIiIRFLIkbWYX+R4u8Q2P+htem/S3gU8aIDYREZFmrbrq7m9VeLwdGO17vJPAcdMiIiISASGTtHPuyoYMRERERAJVV939UHUnhprEREREROpHddXd1wKr8Nqit+INvxIREZEGUl2STsfrJHYp3rKSzwN/960pLSIiIhEWcgiWc263c+5x59wY4EqgHbDazCY1VHAiIiLNWTgzjg0GLsdbWONfwNJIByUiIiLVdxy7ExgLrAGeA252zhU3VGAiIiLNXXUl6V8BX+EtGzkQuMfMwOtA5pxzAyIfnoiISPNVXZLu2WBRiIiISBXVJemNzjlX3clmZjUdIyIiIkenugU23jWzH5tZ94obzSzJzE43s6eB70U2PBERkearupL0OcAUYJ6Z9QT24c3ZHQ/MBx50zi2PeIQiIiLNVHVzdx8BHgUeNbNEoCNwWJOZiIiINIwax0kDOOeKgNwIxyIiIiIVVNcmLSIiIlGkJC0iIhKjakzSZvbbcLaJiIhI/QqnJP3NINvOre9AREREJFB1c3dPBX4IHG9mKyrsag28H+nAREREmrvqenc/i7fq1W+A6RW25znn9kQ0KhEREal2nPR+YL+Z3VRpVysza+Wc2xjZ0ERERJq3cNqk/wm87rt/B/gSr4RdIzObbWY7zGxVhW3HmNnbZvaF7759iHO/5zvmCzPT9KMiItLs1JiknXP9nXMDfPe9gOHAh2G+/hy86UUrmg6843utdwisSge8RA7cDpzse7/bQyVzERGRpqrW46Sdc8vwkmc4xy4CKrdfnw887Xv8NHBBkFPPBt52zu1xzu0F3qZqshcREWnSapwW1Mx+WuFpHDAY2FqH9+zsnCubYnQb0DnIMV2BTRWeb/ZtCxbfNcA1AN27dw92iIiISKMUTkm6dYVbMl7b9Pn18ea+tajrtB61c+4J59xQ59zQtLS0+ghLREQkJtRYknbOzQAwszbeU5dXx/fcbmbpzrlcM0sHdgQ5ZguQU+F5N2BBHd9XRESkUQlnWtChZrYSWAGsNLP/mdnQOrzna0BZb+3vAa8GOeYt4Cwza+/rMHaWb5uIiEizEU5192zgh865DOdcBvAj37Yamdk8vJ7gfcxss5ldBcwEvmlmXwBn+p6XXQw8CeCbLOXXwCe+252aQEVERJob85qFqznAbLlzblClbcucc4MjGtlRGDp0qFuyZEm0wxAREakVM1vqnKtSS11jmzSw0Mz+CMzD6+R1KbDAzAaDf0iWiIiI1LNwkvRA3/3tlbYPwkvap9drRCIiIgKE17t7TEMEIhIpCxYsYOHChVW2jx49mpycnIYPSEQarYb+PgmnTToZuBjIoEJSd87dWe/R1JHapKU6c+bMAWDy5MlRjUNEGr/6/j6pS5v0q8B+YClQUC/RiIiISI3CSdLdnHOaN1tERKSBhTNO+gMz6x/xSERERCRAyJK0b5Yx5zvmSjP7Eq+62/CmBx3QMCGKiIg0T9VVd49rsChERESkipBJ2jn3NYCZHRNkd10X2Wj2NCxIROqDvkuatnA6ji0DjgP24lV1twO2mdl24PvOuaWRC6/pysnJIScnR8OCRKRO9F3StIXTcext4DznXEfnXAfgXOB14IfAo5EMTkREpDkLJ0mPcM75l4l0zs0HTnHOfQQkRywyERGRZi6c6u5cM7sJeM73/FJgu5nFA6URi0xERCQKSkpLOFh0kENFhzhY6Luv9HxR/iJwMJnJEY0lnCR9Bd7iGq/4nr/v2xYPXBKZsERERKpyzlFYUhg0cYbzPJxjCksKw4olxVKYzeyI/rzhLLCxC/hxiN3r6jccERFpzJxzHC4+XKvEWfbc/7iGc0pcSa1iird4Wia1pGViS1oktqBlku8+sSXHpB7jPU8I3F52XLBzWiS24I1X3yDJkiL0KZarMUmb2bt4k5oEcM5picpGyDlHiSuhpLSE4tJiSpzvvtLzYNvKnld3Xn0dE/S8Or7H/gP7Abj30Xtpk9ym/JbUJvB5pVvblLb+x62TWhMfFx/l36LI0QunKjfk86KDNR5zqOhQrWNKjk8OmgjbprQlvXU6LRNDJ8twnifF138yXZywuN5fM5hwqrtvrPA4BW9FrOLIhNO8rN+zntm7Z1PqSnnn5XdqTI71kUBrewXaEOIsjniLJyEugfg4332l58G2VX6enJBc7TEbvtwAQHrHdPYX7GffkX1s3L+RAwUHOFBwgPzC/LDibZnYstqkHu4tEl8csUDjdo+ec46i0qLAUmWYiXT57uUUuAJeff7VqiXTo6jKrShUEkxrkUZGu4zA/dUky2D7UhNTSYgLJxU1T+FUd1ceB/2+mX0coXialf0F+1l1eBVxxJG7KdefUEIlmaT4JFITUqs9JsGqbq8usdX3MbVJqmXbzKxBPm//ONJLJgfdX1JaQn5hvj9p13grLH+8/eD2gH2lruY+lcnxyaFL7jWU7iveUhJSGuwzDEdTHrdbVpVb63bQICXSUOfU9kI6zuJomdiSuJI4kiyJg3sO+hNh+9T2AcnzaEqhKQkpxFk4A4EkEsKp7q4441gcMARoG7GImpHB6YO5v9v9QNP6Imus4uPiaZvSlrYpdfvzds5xqOhQ2Ml+f8F+/+ON+zdyYEf59uLSmiutEuISQifxWlTlt0xsGVPJ/miUlJb4q1zDavusRfIse1xbSfFJQUuUrZNa06VVl7BLoaESbVJ8EmbWJC+KJLzq7qV4bdKGV839FXBVJIMSaczMzPsiTmpJeuv0o34d5xwFJQXhl+wr3Lbnb+eL3V/4nx8uPlxz3Fi9VONX125fVFIUXkkz2PPimhNuQUntl7xPTUgNmhQ7tOhA98TuYXckCvVcVblSF+FUd/dsiEBEJJCZkZKQQkpCCp1adqrTaxWVFJFXmFdzqf7I/oBq/L1H9vL1/q+Pqt0+sTSRREvkl7//pT+xhlMzUFGcxYVMkse2PrbWpdDKr5GamKqqXIlp4VR3JwJTgVG+TQuAPzrniiIYl4jUo8T4RI5JPYZjUoOtlxO+2rTbL1m1hMLSQrJ6ZdVYZRvqeXJ8cqOvghepi3DqYR4DEimfp3uSb9vVkQpKRGJTbdrt5+TOAWDy+MmRDUqkCQsnSQ9zzg2s8Pw/Zva/SAUkIiIinnAaY0rM7ISyJ2Z2PBB7g21FRESamHAnM3nXzL7E6+HdA7gyolGJiIgI5lyVGT/Ld3orXV2P1x7dx7f5c+dc7cc5lL9mH+D5CpuOB25zzj1Y4Zgc4FW84V4ALznn7qzptYcOHeqWLFlytKE1KM3K1PA0jrRh6G+7YenzbliR+rzNbKlzbmiV7dUlad+JHzvnhh/1O1f/2vHAFuBk59zXFbbnADc658bV5vUaU5KWhqckLSKxKlSSDqe6+30zexiv9HuwbKNzblk9xHUGsL5ighYRERFPOEk623dfsbrZAfWxCtZlwLwQ+07x9SLfileq/izYQWZ2DXANQPfu3eshJBERkdgQzoxjYyLxxmaWBIwHbg6yexnQwzmXb2bnAa8AvULE9wTwBHjV3ZGIVUREJBrCmXEsGW95yoyKx4fTkasG5wLLnHPbK+9wzh2o8PgNM3vUzDo653bV8T2lGarc0WPGjBmAOtaISOwLp7r7VWA/3kIbR92rO4jLCVHVbWZdgO3OOWdmw/HGc++ux/eWZqRs6UQRkcYmnCTdzTl3Tn2+qZm1BL4J/KDCtmsBnHOPAxOAqWZWDBwGLnM1dUMXERFpYsJJ0h+YWX/n3Mr6elPn3EGgQ6Vtj1d4/DDwcH29n4iISGMUMkmb2Sqg1HfMlb4ZxwrwZh1zzrkBDROiiIhI81RdSbor5cOvREREpIFVl6S/0iQjIiIi0VNdku5kZj8NtdM5d38E4hERERGf6pJ0PNAKrw1aREREGlh1STq3HiYsERERkaMUV80+laBFRESiqLokfUaDRSEiIiJVhEzSzrk9DRmIiIiIBKquJC0iIiJRpCQtIiISo5SkRUREYpSStIiISIxSkhYREYlRStIiIiIxSklaREQkRilJi4iIxCglaRERkRilJC0iIhKjlKRFRERilJK0iIhIjFKSFhERiVFK0iIiIjFKSVpERCRGKUmLiIjEKCVpERGRGKUkLSIiEqOilqTNbIOZrTSzT81sSZD9ZmYPmdk6M1thZoOjEaeIiEi0JET5/cc453aF2Hcu0Mt3Oxl4zHcvIiLSLMRydff5wDPO8xHQzszSox2UiIhIQ4lmknbAfDNbambXBNnfFdhU4flm37YAZnaNmS0xsyU7d+6MUKgiIiINL5pJ+lTn3GC8au0fmdmoo3kR59wTzrmhzrmhaWlp9RuhiIhIFEUtSTvntvjudwAvA8MrHbIFOK7C826+bSIiIs1CVJK0mbU0s9Zlj4GzgFWVDnsN+K6vl/cIYL9zLreBQxUREYmaaPXu7gy8bGZlMTzrnHvTzK4FcM49DrwBnAesAw4BV0YpVhERkaiISpJ2zn0JDAyy/fEKjx3wo4aMS0REJJbE8hAsERGRZk1JWkREJEYpSYuIiMQoJWkREZEYpSQtIiISo6K9wIaIiEid7N+/n507d3LgwAGOHDlCcXExpaWlAcdkZWXRsWPHKEV49JSkRUSkUSooKGDNmjXs27cv2qFEjJK0iEg9OXLkCB999FFYx5oZcXFxxMXFkZCQQFJSEikpKbRo0YJWrVrRpk0bEhMTIxxx41VYWMjSpUspLCyMdigRpSQtIhIFzjlKSkooKSmhqKiIw4cPs3///oBjWrVqRadOnejcuTPJyclRijQ2ff7550ETdHx8PMnJycTFxVXZXuajjz7iyJEj/uddunThpJNOilywdaAkLSISo/Lz88nPz+err76iU6dO9OzZk5SUlGiHFXWHDh1i9+7dAdtSU1Pp06cPbdu2xTfldJOgJC0iEkHx8fGkpqYG3VdcXExJSQnFxcV4MyEH55xj+/bt7Ny5k+OPP55u3bpFKtxGYdeuXVW2ZWVl0bJlyyhEE1lK0iIiEdS6dWuys7NrPK6wsJADBw6Ql5fH3r17OXDgQJVjSktLWbduHQcOHCAzM7NJlRhrIy8vL+B5y5Ytm2SCBiVpEZGYkJSURMeOHenYsSM9e/YkLy+PzZs3s3379irH7tixA4C+ffs2dJgxoWJ7MkCLFi2iFEnkaTITEZEY1Lp1azIzM+nfv3/QXt47duxg06ZNUYgs+kpKSgKeV+4k1pQ0+ZJ0UVERmzdvrnLlJdIcpaSk0K1bNw3taUQ6dOjAkCFDWLp0KUVFRQH7vvrqK9LS0ppdZ7LKE5U05Wr/Jp+kN2/eTOvWrcnIyGjSv0iRmjjn2L17N5s3b6Znz57RDkdqISUlhb59+7JixYqADmalpaV89dVXZGZm1sv7HDp0iIMHD1JQUEBJSQlmRlJSEl26dAnr/IKCAg4dOhQw61d8fDyJiYkkJyfTpk2bJl3qjYQmn6SPHDmiBC2CV9ro0KEDO3fujHYochTat2/Psccey5YtWwK279ixgxNOOIGkpKSQ5y5YsCDgeUZGBhkZGYBXdbxlyxa2bt0assYxVJIuKipi586d7N27l/3799c4sYiZ0aZNG7p27UpaWlpY38vhTBCzbds2tm3bFnL/iBEjqn2Nms4vk5OTU+Mx9a3JJ2kIvypkwYIFLFy4sMr20aNHR+WXI1LfdLHauHXr1o2tW7cGlKadc+zYseOohmUdOHCAzz77jIKCglqfu3r1anbu3Fnt0LHKnHPs37+f/fv306JFC/r169dke2XXF9U7VJCTk8Ptt99Ojx496NGjB7fffju33357nRP0lClT6NSpE1lZWWEdP3HiRPr06UNWVhZTpkzxt0PNmTMHM+Pf//63/9hXXnkFM+Pvf/+7/2fo06cP2dnZZGZm8sQTTwR9j6KiIqZPn06vXr0YPHgwp5xyCv/617/q9HPW1SuvvMLq1av9z2+77baAn7Uuli9fzlVXXXVU5+7bt49HH320XuII15IlS7j++utrdU5OTg5LliwB4Mwzz2Tv3r2RCE2iKDU1lQ4dOlTZXnlij3Ds27ePTz/99KgSNHgJvjYJurJDhw6xbNky/Z3WQEm6AUyePJk333wz7OMnTpzI2rVrWblyJYcPH+bJJ5/07+vfvz/PPfec//m8efMYOHBgwPlz587l008/5f333+emm24KWgV16623kpuby6pVq1i2bBmvvPJKlbGHDa1ykr7zzjs588wz6+W177nnnlonvTL1kaQr90atydChQ3nooYeO+v0mTZrU4BcW0jDat29fZVttE2ZhYSGfffZZQAes1q1b06NHD/r06UPfvn058cQTSU9PJyGh5gpXM6N169Z06dKF448/3v8affv2pXfv3hx33HG0bdu2ynklJSWsXr262o69ZkarVq0CbpVrhBISEqocU/n4upxfdouGZlHdHW2jRo1iw4YNAduKi4s55ZRTuPfee8nJyeHmm28mLi6Ou+++m/POO89/3PDhw9m8ebP/+WmnncZ///tfioqKKCgoYN26dSEnSsjPz6dly5YBc9aCdwX7pz/9ia+++so/H3Dnzp255JJLAC/x33PPPTjnGDt2LL/97W8Bbx7hG264gddff53U1FReffVVOnfuzOTJk2nTpg1Llixh27Zt/O53v2PChAkA3Hvvvfztb3+joKCACy+8kBkzZgDwzDPPcN9992FmDBgwgKlTp/Laa6+xcOFC7rrrLl588UV+/etfM27cOCZMmMA777zDjTfeSHFxMcOGDeOxxx4jOTmZjIwMvve97/GPf/yDoqIiXnjhhSpz8Obl5bFixQr/xcwdd9zBxo0b+fLLL9m4cSPTpk3zJ/D777+f2bNnA3D11Vczbdo0pk+fzvr168nOzuab3/wm9957r/+1N2zYwDnnnMOQIUNYtmwZ/fr145lnnqFFixZkZGRw6aWX8vbbb/OLX/wC51yVz/Xll1/m4Ycf5t///jfbtm1j9OjRLFq0iLVr13Lffffx+uuvc/DgQX784x+zatUqioqKuOOOOzj//PM5fPgwV155Jf/73/846aSTOHz4sD+u8ePHc9ppp3HLLbeE+rOURqpNmzZVtpWUlHD48OGwxwvn5ub6k3rLli3p3bt30CQK0KtXr6DbzYyOHTvSuXNn2rdvH1YyP3LkCF9++aV/nDd4tXpffPEF/fv3D3pOcnIyQ4cODdhWee7tjh071jj3dsXXOJrzo6VZJelp0+DTT2s+btu2cwCYM6fmY7Oz4cEHax9LQkICc+bMYcKECcyaNYs333yTxYsXBxxTVFTEX/7yF/7whz/4t5kZZ555Jm+99Rb79+9n/PjxfPXVVwHnTZw4keTkZL744gsefPDBKkl63bp1dO/ePeg/+9atW7nppptYunQp7du356yzzuKVV17hggsu4ODBg4wYMYK7776bX/ziF/zpT3/iV7/6FeD907/33nusXbuW8ePHM2HCBObPn88XX3zBxx9/jHOO8ePHs2jRIjp06MBdd93FBx98QMeOHdmzZw/HHHMM48eP9yflio4cOcLkyZN555136N27N9/97nd57LHHmDZtGuD9gy1btoxHH32U++67L6DmAbyq48pNDWvXruXdd98lLy+PPn36MHXqVFasWMGf//xnFi9ejHOOk08+mdGjRzNz5kxWrVrFpyH+eD7//HOeeuopRo4cyZQpU3j00Ue58cYbAW/4zLJly9i6dSsjRoyo8rleeOGFvPjiizzyyCO8+eabzJgxgy5durB27Vr/6999992cfvrpzJ49m3379jF8+HDOPPNM/vjHP9KiRQvWrFnDihUrGDx4sP+c9u3bU1BQwO7du4NWj0rjVVYSrFxyPnLkSNhJuuzctm3b0r9//2oTbKje2EOGDAkrMVdU1ku9RYsWAQWX3bt3c+jQoSY9KcnRUnV3FPXr149JkyYxbtw4Zs+eXaV35g9/+ENGjRrFaaedFrD9sssu47nnnuO5557j8ssvr/K6c+fOZcWKFWzcuJH77ruPr7/+OuyYPvnkE3JyckhLSyMhIYGJEyeyaNEiwJsRady4cYD3D1rxn+yCCy4gLi6Ovn37+mdImj9/PvPnz2fQoEEMHjyYtWvX8sUXX/Cf//yHb3/72/4F2I855phqY/r888/p2bMnvXv3BuB73/uePyaAiy66KGhMZXJzc0lLSwvYNnbsWJKTk+nYsSOdOnVi+/btvPfee1x44YW0bNmSVq1acdFFF/Hf//63xs/suOOOY+TIkQB85zvf4b333vPvu/TSS4HqP9dZs2bxm9/8huTk5KC/z/nz5zNz5kyys7PJycnhyJEjbNy4kUWLFvGd73wHgAEDBjBgwICA8zp16sTWrVtrjF8aFzMLOs69tm3LCQkJ9O3bt9aJtuL5R6tHjx60bt06YFtubu5Rv15T1qxK0uGWeOfM8dqPJ0+eHLFYyqxcuZJ27doFVP8AzJgxg507d/LHP/6xyjnDhw9n5cqVtGjRwp+4gklLS2Pw4MEsXryYHj16+LefeOKJbNy4kQMHDgQtTYeSmJjob8uJj4+nuLjYv6/iMnplV+nOOW6++WZ+8IMfBLzOrFmzwn7PcJS9d+WYyqSmplZp86oYb6jzwlW5favi83B6rm7evJm4uDi2b99OaWlplZKLc44XX3yRPn361CquI0eOhFzYQRq3hISEKn1Navs33K1bt6gtf2lmdO7cOaAfTOVlOsWjknQUvfTSS+zZs4dFixbx4x//mH379gHw5JNP8tZbbzFv3ryQVU0zZ87knnvuqfb1Dx06xPLlyznhhBMCtrdo0YKrrrqKG264wf+PvnPnTl544QWGDx/OwoUL2bVrFyUlJcybN4/Ro0cf1c939tlnM3v2bPLz8wHYsmULO3bs4PTTT+eFF17w90jds2cP4HVcCdZ5rU+fPmzYsIF169YB8Je//KVWMWVmZvrPrc5pp53GK6+84p/Q4eWXX+a0004LGVeZjRs38uGHHwLw7LPPcuqpp1Y5JtTnWlxczJQpU5g3bx6ZmZncf//9Vc49++yzmTVrlv/iZ/ny5YDX1+HZZ58FYNWqVaxYscJ/jnOObdu2+cfCStMSrBRbeRaumqSnp9dXOEelctV2fn5+rX+G5qBZlaSj5fLLL2fBggXs2rWLbt26MWPGDM4//3ymT5/OO++8w3HHHcd1113HDTfcwNNPP821115Ljx49OOWUUwCvOve2224LeM1zzz035PtNnDiR1NRUCgoKmDx5MkOGDKlyzF133cWvfvUr+vbtS0pKCi1btuTOO+8kPT2dmTNnMmbMGH8Hp/PPP/+ofu6zzjqLNWvW+H+OVq1a8de//pV+/fpxyy23MHr0aOLj4xk0aBBz5szhsssu4/vf/z4PPfSQf0gZeO1Yf/7zn/n2t7/t7zh27bXXhh3HSSedxP79+8nLy6tSxVbR4MGDmTx5MsOHDwe8jmODBg0CYOTIkWRlZXHuuecGdBwD7yLikUceYcqUKfTt25epU6dWee1Qn+udd97JaaedxqmnnsrAgQMZNmwYY8eODTj31ltvZdq0aQwYMIDS0lJ69uzJ66+/ztSpU7nyyivJzMwkMzMz4Pe8dOlSRowYUacqSYlddRn6BF7tUn2XoktKSti3bx8HDx7k4MGDFBUVUVJSEnJkQ+XtpaWlFBUVRa10H6usrr/sWDJ06FBXNk60zJo1a2o9Zd4cX4+xhqjulobxwAMP0Lp1a66++up6fd0NGzYwbtw4Vq1aVa+vW1c33HAD48eP54wzzqiy72j+JyQ8wWbHateuXVhLVdbG4sWLA3rzA5xwwgkcd9xxQY+vPONYp06d6m0Frby8PDZt2sSuXbvqXBIeNmxYWE1ElXtnd+nSpVa9s+t6fiSY2VLn3NDK2xv8MtvMjgOeAToDDnjCOfeHSsfkAK8CZd2WX3LO3Rnp2CrPOFY2XEgzjjV+U6dO5YUXXoh2GA0mKysraIKWpiFY+3Ntak3qY4GV0tJS1q9fX2Wa0rqoS9+QpioadWHFwM+cc8vMrDWw1Mzeds6trnTcf51z4xoysJycHCXjJiolJYVJkybV++tmZGTEXCka4Pvf/360Q5AIKS0tDZrMalNNXNdmkNLSUlavXs2uXbvq9DqVNaWa3frS4EnaOZcL5Poe55nZGqArUDlJi4hIJfn5+UGTWW168td1Dvey6u3KkpOT6dChA23btvW3e8fHxxMXF1elE2zZtKRSvaj2KjGzDGAQsDjI7lPM7H/AVuBG59xnDRmbiEgsOnDgQJVt8fHxDbamdGFhYZW5F8yME044ga5du4Z9AVDbqXKbq6glaTNrBbwITHPOVf6rWwb0cM7lm9l5wCtA0LnpzOwa4BqA7t27Ry5gEZEYEGxBirZt2zbYCme7d++u0kHs+OOPr/UqXGp/Dk9UkrSZJeIl6LnOuZcq76+YtJ1zb5jZo2bW0TlXpX7FOfcE8AR4vbvrEpeWqhSRWHbo0KGgK1415NSvZfMalElISKBr1661fp3KvdMluAafzMS8y72ngDXOuaozN3jHdPEdh5kNx4uz9mux1VIklqrctGkTY8aMoW/fvvTr1y9gHu5QHn74YU488UTMLKDdR0tV1q/Dhw8zevToiFa7vfbaa8ycObNW52RkZLBr1y4KCwsZNWqUShziV3GxnTJxcXFVpr2NpMrTj7Zp0ybkpEvVCVZtL1VFY8axkcAk4HQz+9R3O8/MrjWzshkqJgCrfG3SDwGXuUba7S8hIYHf//73rF69mo8++ohHHnkkIBEFM3LkSP79738HTOVZRktV1p/Zs2dz0UUXVVmApDq1Tejjx49n+vTptQ0N8OZKP+OMM3j++eeP6nxpWvbs2RN0LvZOnTpVmfc/ksrWty9zND3Fi4qK/DMsRkPlpoFYTi8NnqSdc+8558w5N8A5l+27veGce9w597jvmIedc/2ccwOdcyOccx80dJz1JT093b86UevWrcnMzGTLli3+mbPKJhm4+eab/csKDho0KOR0jqeddhoff/wxRUVF5Ofn12mpylmzZoVcqrJ///5kZWVx0003+c9r1aoVt9xyCwMHDmTEiBH+hTQmT57M9ddfzze+8Q2OP/74gNnC7r33XoYNG8aAAQO4/fbb/dufeeYZBgwYwMCBA5k0aRIffPABr732Gj//+c/Jzs5m/fr1TJ482f9a77zzDoMGDaJ///5MmTLFfzWfkZHB7bffzuDBg+nfv79/9aiFCxeSnZ1NdnY2gwYNCnoBMnfuXP9sagsWLGDUqFGMHTuWPn36cO211/rb3Vq1asXPfvYzBg4cyIcffsj9999PVlYWWVlZPOibEP6BBx5gypQpgDcfe1ZWFocOHWLOnDlcd911gDf16sUXX8ywYcMYNmwY77//PuC18Z111ln069ePq6++OuAL44ILLmDu3LlBf7/SfBw+fJg1a9ZU2R4XF0fPnj0bNJbK3yeVk3Y4tmzZEtUpQCv/DLHcia15zRkY5lqV52zb5j2o57UqN2zYwPLlyzn55JPDWqoyGC1VGd5Slffddx+PPPIII0eOJD8/v0rP18LCQr788suAi6GPP/6Y1atX06NHD8455xxeeuklJkyYwMGDBzn55JP5/e9/z9KlS4MuZ3nDDTeQk5PDyy+/zN133+1fRrKiG264gZ/85CeceuqpbNy4kbPPPps1a9YwY8YMTj31VG677Tb++c9/8tRTT/nPycrK4pNPPqnx70Karl27drF27dqgzR4nnHBCg0+jWbnUfuDAAUpKSsKukTp48CAbN26MRGhhq1z6j+X2cS2w0UDy8/O5+OKLefDBB/3JsaalKkPRUpU1L1U5cuRIfvrTn/LQQw+xb9++Kv+Uu3btol27dgHbhg8fzvHHH098fDyXX365f8nJ+Ph4Lr74YoCQy1nGxcUxZ84cJk2axOjRo/1LV1b073//m+uuu47s7GzGjx/PgQMHyM/PD1hycuzYsbRv395/Tnx8PElJSVFvipCGl5eXx5o1a1i1alXQBN2lS5ej6rBVV23btg14XlJSEnSJ2GCOHDnCypUro76QRuWpRw8ePFhlpbxY0bxK0mGWeN+s57m7i4qKuPjii5k4caI/oZQJtVRldbRUZaBgS1VOnz6dsWPH8sYbbzBy5EjeeuutgLl5gy1fGWrJyZSUlLBKCV988QWtWrUKuYZzaWkpH330Ua3HsxYUFDTYGFiJnsLCQvLy8jhw4AB79+6ttmNVly5dar10aX1JS0urUnu3adMm4uLiyMjICDkUbPv27axfv97fRyY+Pj5q1cxt27atMp3p6tWr6dWrV7WL8ESDStIR5pzjqquuIjMzk5/+9KcB+0ItVRkOLVVZfUzr16+nf//+3HTTTQwbNszfVl2mffv2lJSUBCTqjz/+mK+++orS0lKef/75oEtOhlrOcv/+/Vx//fUsWrSI3bt3B7TLlznrrLMCLlDKZluquOTkv/71r4BxsLt376Zjx471MteyREdeXh5LliwJelu8eDHvv/8+Cxcu5IMPPmDlypV8/fXXIRN0fHw8vXr14qSTTmqwcdGVtWjRgs6dO1fZ/vXXX/PRRx+xbt06cnNz2bFjB1u3bmXdunUsXryYNWvW+L9v4uLiqnwvNaSOHTtWqV07cOAAS5cu5b///S8ff/xx0N9XNDSvknQUvP/++/zlL3+hf//+/g5e99xzD8OHDw+5VOVDDz3E7373O7Zt28aAAQM477zzePLJJwNeV0tVVr9U5YMPPsi7775LXFwc/fr1C/p5nXXWWbz33nv+HuTDhg3juuuuY926dYwZM4YLL7ywyjmhlrOcMmUKP/rRj+jduzdPPfUUY8aMYdSoUQHnPvTQQ/zoRz9iwIABFBcXM2rUKB5//HFuv/12Lr/8cvr168c3vvGNgEl53n333SpLV0rjUlJS4r9QPVpmRufOnenZs2dMLOXYq1cv8vLyOHToUMD2goKCoMPEKjIz+vXrV6tRFfUtLi6OE088scrFO3i/r8o/VzRpqcogtFRl87Bs2TIeeOAB/vKXv7BgwQLuu+8+Xn/99WiHFeCiiy5i5syZ1TZr1JaWqoycYEtV1kXr1q1JS0ujc+fOdUrOlZeqzMjICDmCJFwFBQV89tlntRrvnJSURN++fWnXrl3Qubuzs7Or9BUJpr6WmszNzWXdunVhV7tHclKrmFmqMpZpqcrmZfDgwYwZMyZmh18UFhZywQUX1GuClthStvBEYmIiSUlJpKSkkJqaSqtWrWjbtm1MN3MkJyeTnZ1Nbm4umzZtqrbjVUpKCunp6XTt2rXOK3DVp/T0dNLS0ti1axd79+7l4MGDFBQUUFJSEvXObWVUkhZpZvQ/IZFw6NAh8vLyKCwspLS0lLi4OJKTk2nVqlWV4YhSlUrSIiISMS1atFAyjgD17hYREYlRStIiIiIxStXdFWipShERiSUqSVcQiaUqAaZMmUKnTp3IysoK63gtVempz6Uqly9fzlVXXXVU5+7bt49HH320XuII15IlS7j++utrdU5OTo5/woUzzzwzYFIUEWmclKQbwOTJk3nzzTfDPl5LVXrqc6nKe+65p9ZJr0x9JOnaDvMaOnQoDz300FG/36RJkxr8wkJE6p+SdAMYNWpUlUUktFRlZJeqrCgvL48VK1b4L2buuOMOpkyZQk5ODscff3xAMgy2DOX06dNZv3492dnZ/PznPw947Q0bNnDSSScxceJEMjMzmTBhgn+2ooyMDG666SYGDx7MCy+8EPRzffnllznjjDNwzpGbm0vv3r3Ztm0bCxYs8C9mcvDgQaZMmcLw4cMZNGgQr776KuCt3HPZZZeRmZnJhRdeGLCSz/jx45k3b17QvwsRaTyaVZv0tDen8em2T2s8bptvqco5YSxVmd0lmwfPebDWsWipysguVVnRkiVLqjQ1rF27lnfffZe8vDz69OnD1KlTWbFiRdBlKGfOnMmqVauqzI5U5vPPP+epp55i5MiRTJkyhUcffZQbb7wRgA4dOrBs2TK2bt3KiBEjqnyuF154IS+++CKPPPIIb775JjNmzKBLly4BFxt33303p59+OrNnz2bfvn0MHz6cM888078c5po1a1ixYoV/3XLw5iYvKChg9+7ddOjQIWjcIhL7VJKOIi1VGbmlKivKzc0lLS0tYNvYsWNJTk6mY8eOdOrUie3bt4dchrImxx13nH9pyu985zv+JS4BLr30UqD6z3XWrFn85je/ITk5Oejvc/78+cycOZPs7GxycnI4cuQIGzduDFjicsCAAQwYMCDgvE6dOoVckUtEGodmVZIOt8TbkHN3a6nKugu2VGVFwZalrBhvqPPCFWqJS6i6bm0wmzdvJi4uju3bt/tnaqrIOceLL75Y66UJjxw5Qmpqaq3OEZHYopJ0FGmpysgtVVlRZmam/9zqhFqGMlRcZTZu3MiHH34IwLPPPht0ictQn2txcTFTpkxh3rx5ZGZmcv/991c59+yzz2bWrFn+i5/ly5cDgUtcrlq1ihUrVvjPcc6xbdu2Oi+iICLRpSTdAC6//HJOOeUUPv/8c7p168ZTTz3Frl27mD59Ok8++SS9e/f2L1UJ3pKG3bp1Y/PmzQwYMICrr766ymuee+65jBkzJuj7TZw4kezsbIYMGVLtUpVpaWn07duXrKwsxo0bR5s2bQKWqhw4cCBDhgyp01KVV1xxBaeccgr9+/dnwoQJ5OXlBSxVOXDgQP8625dddhn33nsvgwYNYv369f7XqbhUZf/+/YmLi6txqcqKTjrpJPbv319j7/WKy1CefPLJ/mUoO3TowMiRI8nKyqrScQy8i4hHHnmEzMxM9u7dy9SpU6scE+pzveeeezjttNM49dRTuf/++3nyySdZs2ZNwLm33norRUVFDBgwgH79+nHrrbcCMHXqVPLz88nMzOS2224L+D0vXbqUESNGxNRiBiJSe1pgIwgtVdn0PPDAA7Ru3TroBU9dbNiwgXHjxrFq1ap6fd26uuGGGxg/fjxnnHFGlX1aYEMk9miBjTBoqcqma+rUqbzwwgvRDqPBZGVlBU3QItK4qCQt0szof0Ik9oQqSatNWkREJEY1iyTdlGoLROpC/wsijUuTT9IpKSns3r1bX07S7Dnn2L17NykpKdEORUTC1OQ7jpUNZdq5c2e0QxGJupSUFLp16xbtMEQkTFFJ0mZ2DvAHIB540jk3s9L+ZOAZYAiwG7jUObfhaN4rMTGRnj171i1gERGRKGjw6m4ziwceAc4F+gKXm1nfSoddBex1zp0IPAD8tmGjFBERib5otEkPB9Y55750zhUCzwGVp7Q6H3ja9/jvwBlWeYJkERGRJi4aSborsKnC882+bUGPcc4VA/sBrbcnIiLNSqPvOGZm1wDX+J4WmFlszc/YdHUEdkU7iGZEn3fD0ufdsPR5Q49gG6ORpLcAx1V43s23Ldgxm80sAWiL14GsCufcE8ATAGa2JNiMLVL/9Fk3LH3eDUufd8PS5x1aNKq7PwF6mVlPM0sCLgNeq3TMa8D3fI8nAP9xGugsIiLNTIOXpJ1zxWZ2HfAW3hCs2c65z8zsTmCJc+414CngL2a2DtiDl8hFRESalai0STvn3gDeqLTttgqPjwDfPoqXfqKOoUn49Fk3LH3eDUufd8PS5x1Ck1oFS0REpClp8nN3i4iINFZNIkmb2Tlm9rmZrTOz6dGOpykzs+PM7F0zW21mn5nZDdGOqTkws3gzW25mr0c7lqbOzNqZ2d/NbK2ZrTGzU6IdU1NmZj/xfZesMrN5ZqYVYCpo9Ek6zGlGpf4UAz9zzvUFRgA/0ufdIG4A1kQ7iGbiD8CbzrmTgIHoc48YM+sKXA8Mdc5l4XUmVkfhChp9kia8aUalnjjncp1zy3yP8/C+wCrPGCf1yMy6AWOBJ6MdS1NnZm2BUXgjTHDOFTrn9kU1qKYvAUj1zYnRAtga5XhiSlNI0uFMMyoRYGYZwCBgcZRDaeoeBH4BlEY5juagJ7AT+LOveeFJM2sZ7aCaKufcFuA+YCOQC+x3zs2PblSxpSkkaYkCM2sFvAhMc84diHY8TZWZjQN2OOeWRjuWZiIBGAw85pwbBBwE1M8lQsysPV7NZ0/gWKClmX0nulHFlqaQpMOZZlTqkZkl4iXouc65l6IdTxM3EhhvZhvwmnJON7O/RjekJm0zsNk5V1Y79He8pC2RcSbwlXNup3OuCHgJ+EaUY4opTSFJhzPNqNQT35KhTwFrnHP3Rzueps45d7NzrptzLgPvb/s/zjmVNCLEObcN2GRmfXybzgBWRzGkpm4jMMLMWvi+W85AHfUCNPpVsEJNMxrlsJqykcAkYKWZferb9kvfLHIiTcGPgbm+i/4vgSujHE+T5ZxbbGZ/B5bhjRxZjmYfC6AZx0RERGJUU6juFhERaZKUpEVERGKUkrSIiEiMUpIWERGJUUrSIiIiMUpJWkREJEYpSYs0QWbWwcw+9d22mdkW3+N8M3s0Qu85zcy+W83+cWZ2ZyTeW6Sp0jhpkSbOzO4A8p1z90XwPRLwJqQY7JwrDnGM+Y4Z6Zw7FKlYRJoSlaRFmhEzyzGz132P7zCzp83sv2b2tZldZGa/M7OVZvamb452zGyImS00s6Vm9paZpQd56dOBZWUJ2syuN7PVZrbCzJ4DcF6JYAEwrkF+WJEmQElapHk7AS/Bjgf+CrzrnOsPHAbG+hL1LGCCc24IMBu4O8jrjAQqrtQ1HRjknBsAXFth+xLgtHr/KUSaqEY/d7eI1Mm/nHNFZrYSb+77N33bVwIZQB8gC3jbq60mHm/d38rSCVwYYQXe/NevAK9U2L4Db0lCEQmDkrRI81YA4JwrNbMiV95JpRTv+8GAz5xzp9TwOoeBlArPxwKjgG8Bt5hZf19VeIrvWBEJg6q7RaQ6nwNpZnYKeGuJm1m/IMetAU70HRMHHOecexe4CWgLtPId1xtYFfGoRZoIJWkRCck5VwhMAH5rZv8DPgW+EeTQf+GVnMGrEv+rrwp9OfCQc26fb98Y4J+RjFmkKdEQLBGpF2b2MvAL59wXIfZ3Bp51zp3RsJGJNF5K0iJSL8ysD9DZObcoxP5hQJFz7tMGDUykEVOSFhERiVFqkxYREYlRStIiIiIxSklaREQkRilJi4iIxCglaRERkRj1/zTzZfsoD8k5AAAAAElFTkSuQmCC\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -1079,47 +639,17 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "output/TOEyS0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n",
-      "output/TIEyS0-DR0-4T10S1-R0-2R1-2T10S2-DR0-2T10.png\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
@@ -1131,25 +661,18 @@
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "outputs": [],
-   "source": [],
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%%\n"
     }
-   }
+   },
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -1173,4 +696,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
\ No newline at end of file
+}
diff --git a/runners/runners.py b/runners/runners.py
index 460a8f7..525296b 100644
--- a/runners/runners.py
+++ b/runners/runners.py
@@ -384,8 +384,9 @@ class ProxmoxRunner:
         for bridge in self._created_bridges:
             self._proxmox.nodes(self._proxmox_node).network(bridge).delete()
 
-        network_task = self._proxmox.nodes(self._proxmox_node).network.put()
-        self._await_task(network_task)
+        if len(self._created_bridges) > 0:
+            network_task = self._proxmox.nodes(self._proxmox_node).network.put()
+            self._await_task(network_task)
 
         self._created_nodes = []
         self._last_node_id = 0

From 23e13ad43c43552cc228ceadde48b8b9a32bb153 Mon Sep 17 00:00:00 2001
From: Jake Hillion <jake@hillion.co.uk>
Date: Sat, 12 Dec 2020 17:15:09 +0000
Subject: [PATCH 3/4] events and timeouts

---
 evaluation.ipynb          | 68 +++++++++++----------------------------
 graphs/graphs.py          |  2 +-
 runners/runners.py        |  4 +--
 structure/environments.py | 10 +++---
 4 files changed, 25 insertions(+), 59 deletions(-)

diff --git a/evaluation.ipynb b/evaluation.ipynb
index 856e041..e0d9f30 100644
--- a/evaluation.ipynb
+++ b/evaluation.ipynb
@@ -2,9 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "# Project Evaluation\n",
     "\n",
@@ -14,9 +12,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "## Setup\n",
     "This section sets up the required variables for the Proxmox server."
@@ -46,9 +42,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "## Testing\n",
     "This section gathers the required data from the different structures for later graphs."
@@ -122,9 +116,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Direct Server to Server"
    ]
@@ -151,9 +143,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Local Portal with 2 Interfaces"
    ]
@@ -175,7 +165,7 @@
     "        run_and_save_test(env, StandardTest([2,2], bandwidth_variation_target=0.2 if fast_tests else 0.05))\n",
     "        run_and_save_test(env, StandardTest(\n",
     "            [2,2],\n",
-    "            events={10: (0,1), 15: (0,2)},\n",
+    "            events={10: (0,1), 20: (0,2)},\n",
     "            duration=30,\n",
     "            interval_variation_target=0.8 if fast_tests else 0.5,\n",
     "        ))\n",
@@ -185,9 +175,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Local Portal with 3 Interfaces"
    ]
@@ -212,9 +200,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Local Portal with 4 Interfaces"
    ]
@@ -239,9 +225,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "## Graphs\n",
     "This section produces graphs from the collected data."
@@ -269,9 +253,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Section 4.2: Graphs\n",
     "#### Subsection 4.2.2 Line Graphs\n",
@@ -350,9 +332,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### More than 2 connections evaluation"
    ]
@@ -401,9 +381,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Mixed Performance Evaluation"
    ]
@@ -431,9 +409,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Eventful Evaluation"
    ]
@@ -459,9 +435,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Comparisons to a Direct Connection"
    ]
@@ -554,9 +528,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Mixed Performance Evaluation"
    ]
@@ -584,9 +556,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Eventful Evaluation"
    ]
@@ -612,9 +582,7 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "source": [
     "### Comparisons to a Direct Connection"
    ]
@@ -691,7 +659,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.6"
+   "version": "3.9.0"
   }
  },
  "nbformat": 4,
diff --git a/graphs/graphs.py b/graphs/graphs.py
index 7505c41..e9fe7af 100644
--- a/graphs/graphs.py
+++ b/graphs/graphs.py
@@ -1,5 +1,5 @@
 from itertools import cycle
-from typing import Dict
+from typing import Dict, Union
 
 from matplotlib import pyplot as plt
 
diff --git a/runners/runners.py b/runners/runners.py
index 525296b..ea56808 100644
--- a/runners/runners.py
+++ b/runners/runners.py
@@ -142,13 +142,13 @@ class ProxmoxRunner:
         with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
             build_futures = [executor.submit(self._build_node, node) for node in nodes]
             for future in build_futures:
-                future.result()
+                future.result(300)
 
             # guarantee that setup is not called until all of the nodes are built
             # this means that all will have their final IPs by this point
             setup_futures = [executor.submit(self._setup_node, node) for node in nodes]
             for future in setup_futures:
-                future.result()
+                future.result(300)
 
     def _await_task(self, upid, timeout=10):
         t1 = datetime.now()
diff --git a/structure/environments.py b/structure/environments.py
index 9d94fb3..bd940d5 100644
--- a/structure/environments.py
+++ b/structure/environments.py
@@ -40,11 +40,9 @@ class BaseEnvironment:
                     rated_node.get_interfaces()[i].set_rate(r)
                 server.server()
 
-                for t, (iface, rate) in test.events.items():
-                    threading.Timer(
-                        6 + t,
-                        (lambda n: lambda: n.get_interfaces()[iface].set_rate(rate))(rated_node),
-                    )
+                for delay, (index, rate) in test.events.items():
+                    iface = rated_node.get_interfaces()[index]
+                    threading.Timer(6 + delay, iface.set_rate, args=[rate]).start()
 
                 iperf = client.client(server, time=test.duration)
                 if old is None:
@@ -57,7 +55,7 @@ class BaseEnvironment:
                 if val.num_tests < 3:
                     return False
                 return val.bandwidth_coefficient_variance() < test.bandwidth_variation_target and False not in \
-                    [x < test.interval_variation_target for x in val.interval_coefficient_variances().values()]
+                       [x < test.interval_variation_target for x in val.interval_coefficient_variances().values()]
 
             result = repeat_until_satisfied(
                 test_reducer,

From 71849ff60d70225bc9e5a7960a884f72c965894a Mon Sep 17 00:00:00 2001
From: Jake Hillion <jake@hillion.co.uk>
Date: Sat, 12 Dec 2020 18:55:05 +0000
Subject: [PATCH 4/4] reordered notebook

---
 evaluation.ipynb | 243 +++++++++++++----------------------------------
 1 file changed, 65 insertions(+), 178 deletions(-)

diff --git a/evaluation.ipynb b/evaluation.ipynb
index e0d9f30..e08da75 100644
--- a/evaluation.ipynb
+++ b/evaluation.ipynb
@@ -2,7 +2,9 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "# Project Evaluation\n",
     "\n",
@@ -12,7 +14,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Setup\n",
     "This section sets up the required variables for the Proxmox server."
@@ -42,7 +46,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Testing\n",
     "This section gathers the required data from the different structures for later graphs."
@@ -116,7 +122,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Direct Server to Server"
    ]
@@ -143,7 +151,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Local Portal with 2 Interfaces"
    ]
@@ -175,7 +185,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Local Portal with 3 Interfaces"
    ]
@@ -200,7 +212,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Local Portal with 4 Interfaces"
    ]
@@ -225,7 +239,9 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Graphs\n",
     "This section produces graphs from the collected data."
@@ -253,12 +269,12 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "### Section 4.2: Graphs\n",
-    "#### Subsection 4.2.2 Line Graphs\n",
-    "\n",
-    "Figure 4.1 Line graphs produced with varying error bars enabled"
+    "#### Subsection 4.2.2 Line Graphs"
    ]
   },
   {
@@ -332,9 +348,12 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
-    "### More than 2 connections evaluation"
+    "### Section 4.3: Success Criteria\n",
+    "#### Subsection 4.3.2: Bidirectional Performance Gains"
    ]
   },
   {
@@ -349,58 +368,9 @@
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
-    "        '4x1MB Connections\\n(proxied)': StandardTest([1,1,1,1]),\n",
-    "        '3x1MB Connections\\n(proxied)': StandardTest([1,1,1]),\n",
-    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(test_store,\n",
-    "    {\n",
-    "        '4x2MB Connections\\n(proxied)': StandardTest([2,2,2,2]),\n",
-    "        '3x2MB Connections\\n(proxied)': StandardTest([2,2,2]),\n",
-    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Mixed Performance Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results(test_store,\n",
-    "    {\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
     "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
+    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
+    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
     "    },\n",
     "    fast_tests,\n",
     "    filename='png',\n",
@@ -409,35 +379,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Eventful Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
    "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
+    "collapsed": false
    },
-   "outputs": [],
    "source": [
-    "plot_iperf_results_time(test_store,\n",
-    "    {\n",
-    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Comparisons to a Direct Connection"
+    "#### Subsection 4.3.5: More Bandwidth over Two Equal Connections"
    ]
   },
   {
@@ -452,9 +398,9 @@
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
-    "        '1x2MB Connection\\n(direct)': DirectTest(2),\n",
-    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
     "        '1x1MB Connection\\n(direct)': DirectTest(1),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
+    "        '1x2MB Connection\\n(direct)': DirectTest(2),\n",
     "\n",
     "    },\n",
     "    fast_tests,\n",
@@ -462,6 +408,16 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "### Section 4.4: Extended Goals\n",
+    "#### Subsection 4.4.1: More Bandwidth over Unequal Connections"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -474,16 +430,24 @@
    "source": [
     "plot_iperf_results(test_store,\n",
     "    {\n",
-    "        '1x4MB Connection\\n(direct)': DirectTest(4),\n",
     "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
-    "        '1x2MB Connection\\n(direct)': DirectTest(2),\n",
-    "\n",
+    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
+    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
     "    },\n",
     "    fast_tests,\n",
     "    filename='png',\n",
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "#### Subsection 4.4.2: More Bandwidth over Four Equal Connections"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -528,9 +492,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
-    "### Mixed Performance Evaluation"
+    "#### Subsection 4.4.3: Bandwidth Variation"
    ]
   },
   {
@@ -545,86 +511,7 @@
    "source": [
     "plot_iperf_results_time(test_store,\n",
     "    {\n",
-    "        '2x2MB Connections\\n(proxied)': StandardTest([2,2]),\n",
-    "        '1x1MB + 1x2MB\\nConnections (proxied)': StandardTest([1,2]),\n",
-    "        '2x1MB Connections\\n(proxied)': StandardTest([1,1]),\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Eventful Evaluation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results_time(test_store,\n",
-    "    {\n",
-    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 15: (0,2)}, duration=30),\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Comparisons to a Direct Connection"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results_time(test_store,\n",
-    "    {\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "        '2x1MB Connections (proxied)': StandardTest([1,1]),\n",
-    "        '1x1MB Connection (not proxied)': DirectTest(1),\n",
-    "\n",
-    "    },\n",
-    "    fast_tests,\n",
-    "    filename='png',\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "plot_iperf_results_time(test_store,\n",
-    "    {\n",
-    "        '1x4MB Connection (not proxied)': DirectTest(4),\n",
-    "        '2x2MB Connections (proxied)': StandardTest([2,2]),\n",
-    "        '1x2MB Connection (not proxied)': DirectTest(2),\n",
-    "\n",
+    "        'Varied Connection': StandardTest([2,2], events={10: (0,1), 20: (0,2)}, duration=30),\n",
     "    },\n",
     "    fast_tests,\n",
     "    filename='png',\n",