sigmod.10.04.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import Counter\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import numpy as np\n",
    "import probscale\n",
    "import itertools\n",
    "import csv\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "class Result:\n",
    "    def __init__(self, path):\n",
    "        self.path = Path(f\"results/{path}/flamestream\")\n",
    "    \n",
    "    def lat_data(self):\n",
    "        with open(self.path.joinpath(\"latency/lat.data\"), 'r') as file:\n",
    "            return list(map(int, file.read().split(\", \")))\n",
    "    \n",
    "    def notification_await_times(self):\n",
    "        with open(self.path.joinpath(\"notification_await_times.csv\"), 'r') as file:\n",
    "            return list(map(lambda row: int(row[0]) / 1E6, csv.reader(file)))\n",
    "        \n",
    "    def duration(self):\n",
    "        with open(self.path.joinpath(\"duration.txt\"), 'r') as file:\n",
    "            return int(file.read())\n",
    "        \n",
    "    def durations(self):\n",
    "        with open(self.path.joinpath(\"durations.txt\"), 'r') as file:\n",
    "            return list(map(int, file.read().split(\", \")))\n",
    "    \n",
    "    def throughput_hz(self, skip=0):\n",
    "        durations = self.durations()\n",
    "        return (len(durations) - skip) / (durations[-1] - durations[skip]) * 1E9\n",
    "\n",
    "    def plot_latencies_evolution(self, **kwargs):\n",
    "        plot_quantiles_evolution(self.lat_data(), **kwargs)\n",
    "        \n",
    "    def last_notification_await_times(self, parallelism):\n",
    "      [min(slice) for slice in each_slice(\n",
    "        self.notification_await_times(),\n",
    "        parallelism,\n",
    "      )]\n",
    "        \n",
    "def plot_quantiles_evolution(data, window_size=100, q=0.95, stabilize=True):\n",
    "    quantiles = []\n",
    "    prev_quantile = None\n",
    "    is_stable = not stabilize\n",
    "    for window in each_slice(data, window_size):\n",
    "        quantile = np.quantile(window, q)\n",
    "        if is_stable:\n",
    "            quantiles.append(quantile)\n",
    "        elif prev_quantile and prev_quantile < quantile:\n",
    "            is_stable = True\n",
    "            quantiles.append(prev_quantile)\n",
    "            quantiles.append(quantile)\n",
    "        else:\n",
    "            prev_quantile = quantile\n",
    "        prev_window = window\n",
    "    if not is_stable:\n",
    "        raise \"has not stabilized\"\n",
    "    plt.plot(quantiles)\n",
    "        \n",
    "def results_path(parallelism=3, rate=5, watermarks=False):\n",
    "    return Path(f\"results/sigmod/parallelism={parallelism}/distributed_acker={False}/rate={rate}/watermarks={watermarks}/iterations=10/flamestream\")\n",
    "\n",
    "def plot_probabilities(results_by_legends, legend_title=None, plot_title=None):\n",
    "    fig, ax = plt.subplots(figsize=(10,10))\n",
    "    ax.legend(results_by_legends.keys(), title=legend_title)\n",
    "    for result in results_by_legends.values():\n",
    "        plt.plot(*probscale.plot_pos(result.lat_data()))\n",
    "    plt.xlabel('Percentile')\n",
    "    plt.ylabel('Latency, ns')\n",
    "    plt.title(plot_title)\n",
    "    plt.show()\n",
    "    \n",
    "def plot_percentile(percentile, results_by_rates):\n",
    "    fig, ax = plt.subplots(figsize=(10,10))\n",
    "    plt.plot(\n",
    "        results_by_rates.keys(),\n",
    "        [np.percentile(result.lat_data(), percentile) for result in results_by_rates.values()],\n",
    "        marker='o'\n",
    "    )\n",
    "    plt.xlabel('Rate')\n",
    "    plt.ylabel(f\"Latencies {percentile} percentile, ns\")\n",
    "    \n",
    "def plot_percentile_by_throughput(percentile, results):\n",
    "    plt.plot(*plottable_percentile_by_throughput(percentile, results))\n",
    "    \n",
    "def plottable_percentile_by_throughput(percentile, results):\n",
    "    return (\n",
    "        [result.throughput() for result in results],\n",
    "        [np.percentile(result.lat_data(), percentile) for result in results]\n",
    "    )\n",
    "\n",
    "def plot_throughput_by_number_of_iterations(results):\n",
    "    plt.plot(\n",
    "        [result.iterations for result in results],\n",
    "        [result.throughput() for result in results],\n",
    "    )\n",
    "    \n",
    "def show_max_throughput(result_factory, bad_rate, max_rate):\n",
    "    pass\n",
    "\n",
    "def plot_throughput_by_parallelism(results):\n",
    "    plt.plot(\n",
    "        [result.parallelism for result in results],\n",
    "        [result.throughput_hz() for result in results],\n",
    "    )\n",
    "    \n",
    "def plot_latencies_barh(results_by_labels, ax):\n",
    "    w = .70\n",
    "    ind_fs = [1, 2.0, 3.0]\n",
    "\n",
    "    def do_plot(q, c):\n",
    "        ax.barh(range(len(results_by_labels)), [np.percentile(result.lat_data(), q) for result in results_by_labels.values()], color=c, height=w, left=0)\n",
    "\n",
    "    do_plot(99, '.8')\n",
    "    do_plot(90, '.6')\n",
    "    do_plot(75, '.4')\n",
    "    do_plot(50, '.2')\n",
    "\n",
    "    plt.gca().invert_yaxis()\n",
    "\n",
    "    for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(60)\n",
    "\n",
    "    ax.set_yticklabels([])\n",
    "#     plt.xlim((0, np.percentile(latencies[8], 99) + 100))\n",
    "\n",
    "    ax.set_xlabel('Latency(ms)', fontsize=60)\n",
    "\n",
    "    for i, label in enumerate(results_by_labels):\n",
    "        ax.text(np.percentile(results_by_labels[label].lat_data(), 99) + 10, i, label, fontsize = 60)\n",
    "\n",
    "    patch_99 = mpatches.Patch(color='.8', label='99 %-ile')\n",
    "    patch_90 = mpatches.Patch(color='.6', label='95 %-ile')\n",
    "    patch_75 = mpatches.Patch(color='.4', label='75 %-ile')\n",
    "    patch_50 = mpatches.Patch(color='.2', label='50 %-ile')\n",
    "    ax.legend(handles=[patch_99, patch_90, patch_75, patch_50][::-1], fontsize = 60, frameon=False, bbox_to_anchor=(1, 1), ncol=1)\n",
    "\n",
    "    for spine in plt.gca().spines.values():\n",
    "        spine.set_visible(False)\n",
    "        \n",
    "def each_slice(generator, n):\n",
    "    group = []\n",
    "    for element in generator:\n",
    "        group.append(element)\n",
    "        if len(group) == n:\n",
    "            yield group\n",
    "            group = []\n",
    "\n",
    "    if group:\n",
    "        yield group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x11953de90>"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 17
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8U2X2+PHP6V5oS1lawAJDVURAKEtZtIqMKOAGKOCoqKB+QcR1nEFh3HCZkfmBozKiiIKooyiiAioKyCIqCoIoS0FBRWmpUsCWFkrX5/fHvSlpSdc0TZOc9+vVV5MnN8m5BnN6n+U8YoxBKaVU4AnydgBKKaW8QxOAUkoFKE0ASikVoDQBKKVUgNIEoJRSAUoTgFJKBShNAEopFaA0ASilVIDSBKCUUgEqxNsBVKZFixamffv23g5DKaV8yubNmw8aY+KqOq5BJ4D27duzadMmb4ehlFI+RUR+qc5x2gWklFIBShOAUkoFKE0ASikVoBr0GIBSqnYKCwtJS0vj+PHj3g5FeVBERARt2rQhNDS0Vs/XBKCUH0pLSyM6Opr27dsjIt4OR3mAMYZDhw6RlpZGYmJirV7DP7uAti6Ep86CqbHW760LvR2RUvXq+PHjNG/eXL/8/ZiI0Lx5c7eu8vzvCmDrQnj/TijMs+5n77PuA3S76uRjVz0K2WnQpA0MfMg6pqJ2pXyIfvn7P3c/Y/9LAKsePfHl71CYZ7U7f4lXlCh+/Qq+e6N6CUQppXyY/3UBZadVr72iRLH55YoTiFKqThw6dIju3bvTvXt3WrVqRUJCQun9goKCWr/uSy+9xN13331S+6xZs3j99dfdCdkv+d8VQJM21l/trtqdVZQoTInr9oqOV0rVWPPmzfn2228BmDp1KlFRUfz9738vc4wxBmMMQUHu/5162223uf0a/sj/rgAGPgShkWXbQiOtdmflE4KDVPCfJOYU92NTSlVqz549dO7cmdGjR9OlSxcyMjIYP348ycnJdOnShUcfPXElvmHDBs4++2ySkpLo27cvx44dK/NaS5cuJSUlhcOHD/PAAw/w9NNPA3DuuecyefJk+vTpQ8eOHVm/fj0AR48eZcSIEXTu3JmRI0eSnJxcmqT8lf8lgG5XweUzISTCut+krXW/fP99RYmi140nt4PVDfTTWo+ErJQ6YdeuXfz1r38lNTWVhIQEpk2bxqZNm/juu+9YuXIlqampHD9+nKuvvppZs2bx3XffsWLFCsLDw0tfY9GiRTz55JMsW7aMZs2anfQexhg2btzI9OnTS5PKf//7X1q1akVqaioPPvggW7Zsqbdz9hb/6wIC68t+7+fw/TL46/aKjwFYchsUF1iJwjHbp12/srOAul8H29+GV4dBn/Fw4SMQ1qj+zkepAHLaaaeRnJxcen/BggXMnTuXoqIi9u/fT2pqKvn5+bRr146ePXsC0KRJk9LjV65cycaNG1mxYgVRUVEu3+PKK68EoFevXuzduxeAzz//nPvuuw+ApKQkunTp4onTa1D8MwGA9cV9NBOK8iEk3PUx3a6ClQ/BaQNh+Kyy7eWvGFLuhFWPwIbZsGcVXDEb2vbxXPxKBajGjRuX3t69ezfPPPMMGzduJDY2luuuu67Kee+nn346e/bsYffu3fTo0cPlMY6rheDgYIqKiuoueB9TZReQiMwTkQMictKf0iLyNxExItLCvi8iMlNE9ojIVhHp6XTsGBHZbf+MqdvTcCEmwfp9JL3iY4oKIOe3iscDnIU1gov/DWPet64Y5g2GT6ZaCUYp5RFHjhwhOjqamJgYMjIyWL58OQCdO3fm119/5Ztvvik9rri4GIDExETefvttRo8ezc6dO6v9XikpKSxcaC0a3bZtG6mpqXV8Ng1PdcYA5gNDyjeKSFtgEPCrU/PFQAf7ZzzwvH1sM+BhoC/QB3hYRJq6E3iVHF/q2ZUkgJz9gKleAnBI7A+3rofuo+Hzp2DOnyFjq1uhKqVc69mzJ507d+bMM8/khhtuICUlBbD+gl+wYAG33norSUlJDBo0iPz8E3+Mde7cmddee40RI0bw888/V+u97rjjDtLT0+ncuTOPPPIInTt3LtO15JccU60q+wHaA9vLtS0CkoC9QAu77QXgGqdjvgdaA9cALzi1lzmuop9evXqZWju4x5iHY4z5dkHFx/z8mXXMntW1e49dHxkzvYMxjzQzZu3/M6aosHavo1QdS01N9XYIPqewsNDk5eUZY4z54YcfTPv27U1hYcP/f9rVZw1sMtX4bq/VGICIDAPSjTHflVuKnAA4T8JPs9sqavccx7RNV2sCHBxz+5u0rd17dBwCbb+CD/8Gax63Bp2veAHizqjd6ymlvCY3N5eBAwdSVFSEMYYXXniBkBD/HSaFWgwCi0gj4B9Y3T91TkTGY3Uf0a5du9q/UGgkNGpeeReQIzk0cSMXNWoGo16GTpdZieCF82Dgw9B3AtTBAhalVP2IjY1l8+bN3g6jXtXmG+o0IBH4TkT2Am2Ab0SkFZAOOP853cZuq6j9JMaYOcaYZGNMclxclXsaVy4mofJB4Ow0aNTC9bz/mjprBEz8ChLPh+VT4JXL4Y+97r+uUkp5SI0TgDFmmzEm3hjT3hjTHqs7p6cx5jdgKXCDPRuoH5BtjMkAlgODRKSpPfg7yG7zrCZtq7gCSKvZAHBVolvBtW/B0Gch4zt4PgU2zwdr3EMppRqU6kwDXQB8CXQUkTQRubmSw5cBPwF7gBeBiQDGmMPAY8DX9s+jdptnNUmovIZPXScAABHoeT1MXA+n9ID374LXR8GRjLp9H6WUclOVYwDGmGuqeLy9020DuKy6ZIyZB8yrYXzuiUmA/GzIz4Hw6PIBWQng1D975r1j28ENS+HrF2Hlw/BcP7j0SaurSOu0K6UaAP8epaxsLcDxLCjIrfsrAGdBQdD3FpjwObToAO/cDG+PgaMHPfeeSjUQv/32G1dffTWnnXYavXr14pJLLuGHH36o1WvNnz+f/fv31/h5U6dOZcaMGQA89NBDfPLJJ7V6f2cVlZeoCee4vCkwEsARF91ApVNAPZgAHFqcDjd+bNUa2rXMuhrYtczz76tUNS3ekk7KtNUkTv6QlGmrWbylkrGzajDGcMUVVzBgwAB+/PFHNm/ezBNPPMHvv/9eq9erLAE4VgBX5dFHH+XCCy+s1fs3JHVZusK/E4CjHISrcQB31wDUVHAInPc3GL8WolrBm9fA4olwPLt+3l+pCizeks6Ud7eRnpWHAdKz8pjy7ja3ksCaNWsIDQ1lwoQJpW1JSUmcd955AEyfPp3evXvTrVs3Hn74YQD27t1Lp06dGDduHF26dGHQoEHk5eWxaNEiNm3axOjRo+nevTt5eXm0b9+e++67j549e/L222/z4osv0rt3b5KSkhgxYsRJpaEBxo4dW/pajs1nunbtWrqt4o8//siQIUPo1asX5513Hrt27QLg559/5uyzz6Zr16488MADFZ7z8OHD6dWrF126dGHOnDml7R9//DE9e/YkKSmJgQMHnvS8F198kYsvvpi8vLwKYxg7diwTJkygb9++3HvvvTX9OCrk36scoltb9f1ddQGVJgDPrkc7SauzYNxq+PTf8Pl/4KdPrUJ0pw6o3zhUwHjk/R2k7j9S4eNbfs2ioLjsRkh5hcXcu2grCzb+6vI5nU+J4eHLK66WuX37dnr16uXysRUrVrB79242btyIMYahQ4eybt062rVrx+7du1mwYAEvvvgiV111Fe+88w7XXXcdzz77LDNmzChTJbR58+altYAOHTrEuHHjAHjggQeYO3cud9xxh8v3d67zP2nSJIYMsSrdjB8/ntmzZ9OhQwc2bNjAxIkTWb16NXfddRe33norN9xwA7NmzXL5mgDz5s2jWbNm5OXl0bt3b0aMGEFJSQnjxo1j3bp1JCYmcvhw2bkvzz77LCtXrmTx4sWEh4dXGANAWloa69evJzg4uMIYasq/E0BwiPXXtqu1ANn7ICgUGsfXf1whYTDwQeh4Mbx3i1Vmuvc4uOgRCGtc9fOVqkPlv/yranfXihUrWLFiRWmlztzcXHbv3k27du1ITEyke/fuQNlSza785S9/Kb29fft2HnjgAbKyssjNzWXw4MFVxvHWW2/xzTffsGLFCnJzc1m/fj2jRo0qfdxRW+iLL77gnXfeAeD6668vLRld3syZM3nvvfcA2LdvH7t37yYzM5P+/fuTmJgIUGZvgldffZW2bduyePFiQkNDK40BYNSoUXX65Q/+ngCg4qmg2WnWY95crdsmGW75DFY/Bl89Bz+uguGzoV1f78Wk/E5lf6kDpExbTXpW3kntCbGRvHXL2bV6zy5durBo0SKXjxljmDJlCrfcckuZ9r1795bZ1CU4OJi8vJPjcnAuGz127FgWL15MUlIS8+fPZ+3atZXGt337dqZOncq6desIDg6mpKSE2NjYCncAkypm7q1du5ZPPvmEL7/8kkaNGjFgwIAqy1Z37dqVb7/9lrS0NBITE6uMwfl864p/jwGAvUdwRQmgnvr/KxPWCIY8AWM+gOIieHmINW1Uy0yrejJpcEciQ8v+ZRkZGsykwR1r/ZoXXHAB+fn5ZfrCt27dymeffcbgwYOZN28eubm5AKSnp3PgwIFKXy86OpqcnJwKH8/JyaF169YUFhZWufl7VlYW11xzDa+++iqOagMxMTGlZaTBSlLfffcdYJWJfvPNNwEqfO3s7GyaNm1Ko0aN2LVrF1999RUA/fr1Y926daUVSZ27gHr06MELL7zA0KFD2b9/f6UxeIr/JwBHOYjyq3Gz0+tnBlB1JZ4Ht34BPa6DL56GOQOs1cRKedjwHgk8cWVXEmIjEay//J+4sivDe9R+fExEeO+99/jkk0847bTT6NKlC1OmTKFVq1YMGjSIa6+9tnRgdeTIkZV+ucOJQVDHIHB5jz32GH379iUlJYUzzzyz0tdasmQJv/zyC+PGjSsdDAbry33u3Lmlu4EtWbIEgGeeeYZZs2bRtWtX0tNdD4wPGTKEoqIiOnXqxOTJk+nXrx8AcXFxzJkzhyuvvJKkpKQy3VZg7U88Y8YMLr30Ug4ePFhhDJ4ipgGXKUhOTjabNm1y70W+eh4+ngyTfoLGza224iJ4PM6alXNBxaP6XvPDclh6Bxw7BOffB+feY41nKFVNO3fupFOnTt4OQ9UDV5+1iGw2xiRX8JRSgXEFAGXXAuRkgClpWFcAzs4YbBWW6zwc1vwT5l4Emd97OyqllJ/x/wTgajVwfS4Cq61GzWDkXBg136oqOvs8WP8slHhmZoZSKvAEUAJwugKo70Vg7uhyhXU1cNoFsOJ+eOUyLTOtlKoT/p8AGrWA4LCyXUCOjWBi6nkRWG1Ft4RrFsCw5+C3bfDcObDpZS0zrZRyi/8ngKAga3vI8l1AkU0h3P2iTvVGBHqMtjakb9MLPrgbXh8JR2peIEsppSAQEgBATJuyq4E9sQ9AfYltC9cvgYunw94vrMJyWxfq1YBSqsYCIwGUXwzWUBaB1VZQEPQdb5eZPgPeHQcLb9Ay06pBCQ4Opnv37nTp0oWkpCSefPJJSuxJDJs2beLOO++s8Ll79+7ljTfeqPDx/fv3M3LkSMCqFHr77bfXKLbalJfeu3cvZ511Vo2e44qjKF1DECAJIMHqKimxy8b68hWAsxanw03L4cKp8MPHdpnpD70dlfJFWxfCU2fB1Fjr99aFbr9kZGQk3377LTt27GDlypV89NFHPPLII4BVkG3mzJkVPreyBFBUVMQpp5zi1pdobfcX8La6LAUNgZIAYhLAFEPu71b55fxs/0gAAEHBcO5frTLT0a3gzWvhvQmQl+XtyJSv2LoQ3r/TnhxhrN/v31knScAhPj6eOXPm8Oyzz2KMYe3atVx22WUAfPrpp6Urcnv06EFOTg6TJ0/ms88+o3v37jz11FPMnz+foUOHcsEFFzBw4MCT/hrft28fAwYMoEOHDqVJpvwxM2bMYOrUqS7LS2/evJnzzz+fXr16MXjwYDIyrC1cN2/eTFJSEklJSRVWAs3NzWXgwIH07NmTrl27llm9++qrr9KtWzeSkpK4/vrrT3rugw8+yNixYykuLq4whgEDBnD33XeTnJzMM8884+YnUVaVy0tFZB5wGXDAGHOW3TYduBwoAH4EbjTGZNmPTQFuBoqBO40xy+32IcAzQDDwkjFmWp2eSWWc1wI4qm36SwJwaNkF/m81rPt/8Nl/4Od1MGwWnOahLS+V7/hosjV7rCJpX0NxudpThXmw5HbY/Irr57TqChfX7H/hU089leLi4pPq/syYMYNZs2aRkpJCbm4uERERTJs2jRkzZvDBBx8A1l/s33zzDVu3bqVZs2YnVQnduHEj27dvp1GjRvTu3ZtLL72UFi1auIxj5MiRZcpLFxYWcscdd7BkyRLi4uJ46623uP/++5k3bx433ngjzz77LP3792fSpEkuXy8iIoL33nuPmJgYDh48SL9+/Rg6dCipqak8/vjjrF+/nhYtWpxUCnrSpEnk5OTw8ssvU1RUVGEMAAUFBbhdFcGF6lwBzAeGlGtbCZxljOkG/ABMARCRzsDVQBf7Oc+JSLCIBAOzgIuBzsA19rH1ozQB7POtNQA1FRJmlba4eaWV6F4bDh/+DQqOejsy1ZCV//Kvqr2OpaSkcM899zBz5kyysrIICXH9d+lFF11Uppxy+ceaN29OZGQkV155JZ9//nm13//7779n+/btXHTRRXTv3p3HH3+ctLQ0srKyyMrKon///gAu/4IHq2jbP/7xD7p168aFF15Ieno6v//+O6tXr2bUqFGlicg59scee4zs7Gxmz56NiFQYg0P5GkJ1pTqbwq8Tkfbl2lY43f0KGGnfHga8aYzJB34WkT1AH/uxPcaYnwBE5E372FS3oq+u0nIQ6RDayLrtb1cAztr0glvWwapHrTLTe1bBFbOhXT9vR6a8oaq/1J8668TaGGdN2sKNdTem9NNPPxEcHEx8fDw7d+4sbZ88eTKXXnopy5YtIyUlheXLl7t8fmXlkMuXaxYRQkJCSgedgQrLMxtj6NKlC19++WWZ9qys6nWjvv7662RmZrJ582ZCQ0Np3759laWge/fuzebNmzl8+DDNmjWrMAYHT5SChroZA7gJ+Mi+nQA4/0tKs9sqaq8fEU0gLMrqAspOg6AQiGpZb2/vFaGRJ8pMm2KYNwRWPgSFlf/DVAFo4EPWvxdnoZFWex3JzMxkwoQJ3H777Sd9Wf/444907dqV++67j969e7Nr164qyz+Xt3LlSg4fPkxeXh6LFy8mJSWFli1bcuDAAQ4dOkR+fn5pdxKULS/dsWNHMjMzS798CwsL2bFjB7GxscTGxpZeTVRWCjo+Pp7Q0FDWrFnDL7/8Alglsd9++20OHToElC0FPWTIkNLEl5OTU2EMnuZWiUkRuR8oAiovwF2z1xwPjAdo165dXb2oXRY6DUIirYVhQXW7s06DlXietXhs+f3wxTPwwwrrauCU7t6OTDUU3a6yfq969MQMuYEPnWivpby8PLp3705hYSEhISFcf/313HPPPScd9/TTT7NmzRqCgoLo0qULF198MUFBQQQHB5OUlMTYsWNp2rRppe/Vp08fRowYQVpaGtddd13p1pEPPfQQffr0ISEhoUyZaEd56cjISL788ksWLVrEnXfeSXZ2NkVFRdx999106dKFl19+mZtuugkRYdCgQS7fe/To0Vx++eV07dqV5OTk0vfp0qUL999/P+effz7BwcH06NGD+fPnlz5v1KhR5OTkMHToUJYtW1ZhDJ5UrXLQdhfQB45BYLttLHALMNAYc8xumwJgjHnCvr8cmGo/ZaoxZrCr4ypSJ+WgHV67wpoZExJh3b/po8qP90e7V1oDe8cOQv974bx7IDjU21EpD9By0IGj3stB2zN67gWGOr78bUuBq0UkXEQSgQ7ARuBroIOIJIpIGNZA8dLavHetORaD+csagNrocBFM/NIqMLf2X1aZ6QO7vB2VUspLqkwAIrIA+BLoKCJpInIz8CwQDawUkW9FZDaAMWYHsBBrcPdj4DZjTLExpgi4HVgO7AQW2sfWn5g2cPSANRAcqAkArDLTI16CUa/AH7/AC/3tMtPF3o5MKVXPqjML6BoXzXMrOf6fwD9dtC8DltUourrUxB5zNsWBnQAcugyHP50D799llZne9SEMfw6aJXo7MlVHjDFVbmaufJu7OzoGxkpgKFv62R/XANRGVDxc/QYMfx5+3w7Pp8CmeVpYzg9ERERw6NAht78gVMNljOHQoUNERETU+jUCZ6NZ5y99vQI4QQS6Xwvtz4Mlt8EHf4WdH8CwZ63ZUsontWnThrS0NDIzM70divKgiIgI2rSp/fdZ4CSAX786cfv1kVYBNTenufmV2LZw/WLYNNdaL/BcP6vkdLerrCShfEpoaCiJidqdpyoXGF1AWxfCR38/cf9Iep0Xu/ILQUHQZ5xVZjruTHhvPCy8XstMK+WnAiMBrHrUKm7lrDDPalcna34a3PgRXPgI/LAcZvW1uoWUUn4lMBKA82Yw1WlXdpnpu60y0zGt4a3RWmZaKT8TGAmgokFfHQyumqPMdP97rS6z5862issppXxeYCSAeih25ddCwuCC++H/VkJ4FPzvSvjgHsjP9XZkSik3BEYC6HYVXD7Tngoq1u/LZ+osoJpKsMtMn327tV5g9rnwi+vytUqphq9axeC8pU6Lwam6tfdzWDwRsn6Fc26HPz8AobVfkKKUqjseLQanFO3PhVu/gF5jYP1/Yc75sH+Lt6NSStWAJgBVe+HRcPkzMPodOJ4NL10Ia6dBcaG3I1NKVYMmAOW+DhfaZaavhLVPWIlAy0wr1eBpAlB1I7IpjHgRrnrV2l/2hf7wxUwtM61UA6YJQNWtzsNg4ldw+oWw8kGYfykc/snbUSmlXNAEoOpeVDxc/ToMnw2/74Dnz4Wv52qZaaUaGE0AyjNEoPs11thA297w4T3WArLsdG9HppSyaQJQntWkjVVm+pIZVknu586G797UqwGlGoDq7Ak8T0QOiMh2p7ZmIrJSRHbbv5va7SIiM0Vkj4hsFZGeTs8ZYx+/W0TGeOZ0VIMkcqLMdHwneO8WeOs6yNXNSpTypupcAcwHhpRrmwysMsZ0AFbZ9wEuBjrYP+OB58FKGMDDQF+gD/CwI2n4ssVb0kmZtprEyR+SMm01i7do90almp8GNy6Dix6F3SusTWd2vu/tqJQKWFUmAGPMOuBwueZhwCv27VeA4U7trxrLV0CsiLQGBgMrjTGHjTF/ACs5Oan4lMVb0pny7jbSs/IwQHpWHlPe3aZJoCpBwZByl1VTqEmCdSXw7njI+8PbkSkVcGo7BtDSGJNh3/4NaGnfTgD2OR2XZrdV1O6zpi//nrzCsnPc8wqLmb78ey9F5GPiO8H/rYLzJ8O2RfDcObDnE29HpVRAcXsQ2FjV5OpsRE9ExovIJhHZ1JA3tN6flVejduVCcCj8eQr83ydWWYn/jbA2pdcy00rVi9omgN/trh3s3wfs9nSgrdNxbey2itpPYoyZY4xJNsYkx8XF1TI8zzslNrJG7aoSCT3hlk/tMtMvw+wU+GW9t6NSyu/VNgEsBRwzecYAS5zab7BnA/UDsu2uouXAIBFpag/+DrLbfNakwR2JDA0u0xYZGsykwR29FJGPC42Ewf+0BokBXr4Elt8Phce9G5dSfqw600AXAF8CHUUkTURuBqYBF4nIbuBC+z7AMuAnYA/wIjARwBhzGHgM+Nr+edRu81nDeyRw/6WdSu/HRITwxJVdGd7Dp4c2vO9P58CELyD5RvjyWaumUPo33o5KKb8UUtUBxphrKnhooItjDXBbBa8zD5hXo+gauMQWjUtvX9EjQb/860p4FFz2FJx5KSy5w6ou2n8S9P+7NW6glKoTuhLYDTszjgDQvHEYB3LyvRyNHzr9Qpi4HrqOhE+nwUsD4cBOb0ellN/QBOCG1IwjxEeHc0bLaE0AnhLZFK6cA1e9ZtUReqE/fPGMlplWqg5oAnDDzowcOrWOIT4mnAM5OljpUZ2HWmWmOwyClQ9Zg8SHfvR2VEr5NE0AtVRQVMKeA3YCiA4nMycfowXOPCsqDv7yP7jiBasraPa58PVLWlhOqVrSBFBLP2bmUlhs6NQ6mvjoCI4XlpCTX+TtsPyfCCRdbZWZbtcPPvwbvHYFZKd5OzKlfI4mgFpK3W8NAHe2u4AADhzRcYB60yQBrnsXLv0P7NtglZL4doFeDShVA5oAamlnxhHCQoJIbNGYuCg7Aeg4QP0Sgd43w61fQMvOsHiClplWqgY0AdTSzt+OcGaraEKCg0qvADJ1JpB3NDsVxn4IFz1ml5nuC6lLvR2VUg2eJoBaMMZYM4BaxQAQFx0BaBeQVwUFQ8qddpnpNrDwenhnnJaZVqoSmgBq4UBOPoePFtCpdTRglYEIDwnSLqCGwFFmesAU2PGutQXlbi0zrZQrmgBqIdVeAdyptXUFICL2WgC9AmgQgkNhwGSrzHREE3h9BLx/t5aZVqocTQC14CgBcaadAADioyN0DKChOaUHjP8UzrkDNs+H58+BvV94OyqlGgxNALWQuv8ICbGRNIk8UZgsPlqvABqk0AgY9Djc+JE1a2j+pVpmWimbJoBa2JlxpLT7xyEuOpwDR/RLpcH609l2membtMy0UjZNADV0vLCYnw8epfMpZRNAfHQ4R44XcbxQi5Q1WOFRcNl/rAVk+TlWmek1/4KiAm9HppRXaAKooe9/y6HEQGd7BpBDvD0VVMcBfMDpA61SEl1Hwaf/tspM/57q7aiUqneaAGpoZ7kZQA5xMboa2KdExsKVL1jF5Y7shznnw+dPa5lpFVA0AdTQzowjNA4Lpm3TRmXa46O1HpBP6nT5iTLTnzwML1+sZaZVwHArAYjIX0Vkh4hsF5EFIhIhIokiskFE9ojIWyISZh8bbt/fYz/evi5OoL6lZhzhzNYxBAVJmXZHF5DOBPJBpWWm58CBXVaZ6Y0vQkmJtyNTyqNqnQBEJAG4E0g2xpwFBANXA/8GnjLGnA78AdxsP+Vm4A+7/Sn7OJ9ijGFXRk7pCmBnzRuHERz642jLAAAcgElEQVQkOgbgq0Qg6S92memzYdnf4X9aZlr5N3e7gEKASBEJARoBGcAFwCL78VeA4fbtYfZ97McHikjZP6MbuLQ/8sjJLzqp/x8gKEhoERWmYwC+rkkCXPeOtSn9vq+tUhLfvqFlppVfqnUCMMakAzOAX7G++LOBzUCWMcaxM0oakGDfTgD22c8tso9vXv51RWS8iGwSkU2ZmQ2rrG/5EhDlxeliMP8gYq0XuPULaHkWLL4V3hwNuQe8HZlSdcqdLqCmWH/VJwKnAI2BIe4GZIyZY4xJNsYkx8XFuftydWpnxhFE4MxWJ3cBgTUOoIPAfqRZIoz9wFpJvOcTeK4fpC7xdlRK1Rl3uoAuBH42xmQaYwqBd4EUINbuEgJoA6Tbt9OBtgD2402AQ268f73bmXGExOaNaRQW4vJxLQfhh4KCrVpCt6yDJm1h4Q3wzv9pmWnlF9xJAL8C/USkkd2XPxBIBdYAI+1jxgCOP5mW2vexH19tfGwX9Z0ZORV2/4CVAA4dzaeoWGeP+J34M63qogP+ATves8tMr/R2VEq5xZ0xgA1Yg7nfANvs15oD3AfcIyJ7sPr459pPmQs0t9vvASa7EXe9yzleyK+Hj7mcAeQQFxOBMXDoqJYW8EvBoTDgPrvMdCy8PhLev8sqK6GUD3Ldl1FNxpiHgYfLNf8E9HFx7HFglDvv5027frP+J6/qCgCsxWAtYyLqJS7lBaf0gPFrYc0/Yf1/4cfVMPx5aH+utyNTqkZ0JXA1VVQCwpkjAWTm6lRQvxcaAYMeg5s+BgmG+ZfBx/+AwjxvR6ZUtWkCqKadGUdoEhlK6yYV/2UfH6N7Awecdv2s6aK9b4avZtllpjd7OyqlqkUTQDWlZuTQuXUMla1daxEVBmg5iIAT1hgufRKufw8KjsJLF8Hqx7XMtGrwNAFUQ3GJ4fvfTt4EprzwkGBiG4XqauBAddoFcOt66PYXWDfdLjO9w9tRKVUhTQDVsPfQUY4XllQ6A8ghPjpcu4ACWWQsXPE8/OV1yMmAOQPg86e0zLRqkDQBVEPq/qoHgB3ioyO0C0hBp8usMtNnDIZPpsK8IVpmWjU4mgCqYWfGEUKChA4to6o8Nj46XCuCKkvjFnDVa3DlS3Dwe3g+BTbM0TLTqsHQBFANOzOOcFpcFOEhwVUeGxdjJQAfW+SsPEUEuo2yrgbap8BHk+C14ZC1z9uRKaUJoDp2VrAHgCvx0REUFJeQnVfo4aiUT4k5BUYvgsuehrRN8Pw5sOV1LTOtvEoTQBX+OFrAb0eO0/mUqvv/wSoJDToVVLkgAsk3WusGWnWFJRPhzWsh53dvR6YClCaAKlRnBbAz3RtYValZIoz5AAb/C/assspM71js7ahUANIEUIWqNoEprzQB6FoAVZmgIDj7NpjwGTT9E7w9BhbdDMcOezsyFUA0AVQhNeMIcdHhtIgKr9bxpeUgtAtIVUdcR7h5Jfz5fkhdbJWZ/mGFt6NSAUITQBWq2gOgvKjwEBqFBWsXkKq+4FA4/14YtxoaNYM3RsHSO7TMtPI4TQCVKCgqYc+B6s8AcrB2BtMuIFVDrZOsMtMpd8OW/1kzhX7+zNtRKT+mCaASP2bmUlhs6FyDKwCwpoLqYjBVKyHhcNEjcOPHEBQCr1wGH0/RMtPKIzQBVMIxA6imCcCxGEypWmvXFyZ8Dr3HwVfPwezzIE3LTKu6pQmgEjszjhAWEkRii8Y1el5clG4Or+pAWGO4dAZcv9i6ApirZaZV3XIrAYhIrIgsEpFdIrJTRM4WkWYislJEdtu/m9rHiojMFJE9IrJVRHrWzSl4TmrGETq2jCYkuGb/meJjwsnNL+JYQZGHIlMB5bQ/w8T1kHS1XWb6Ai0zreqEu1cAzwAfG2POBJKAnVibva8yxnQAVnFi8/eLgQ72z3jgeTff26OMMTUqAeEsPlp3BlN1LKIJDH8Orl4AOb/BC+fDZ//RMtPKLbVOACLSBOgPzAUwxhQYY7KAYcAr9mGvAMPt28OAV43lKyBWRFrXOnIPO5CTz+GjBTWaAuoQr+UglKeceQlM3GD9XvUIzBsMB/d4Oyrlo9y5AkgEMoGXRWSLiLwkIo2BlsaYDPuY34CW9u0EwLkEYprdVoaIjBeRTSKyKTMz043w3FPTFcDO4mN0NbDyoMbNYdQrMGIuHNwNs8+FDS9omWlVY+4kgBCgJ/C8MaYHcJQT3T0AGKsmco3KHRpj5hhjko0xyXFxcW6E557SGkCtanMFoF1AysNEoOtIu8z0ufDRvfDaMMj61duRKR/iTgJIA9KMMRvs+4uwEsLvjq4d+/cB+/F0oK3T89vYbQ3O4i3p/HeVdVl9yczPWLylZmE2bRRKaLCQmasJQHlYTGsY/TZc/gykfwPPnWMtItMy06oaap0AjDG/AftEpKPdNBBIBZYCY+y2McAS+/ZS4AZ7NlA/INupq6jBWLwlnSnvbiOv0BpcS8/KY8q722qUBETEmgqqVwCqPohAr7FWmenWSbDkNlhwjZaZVlVydxbQHcDrIrIV6A78C5gGXCQiu4EL7fsAy4CfgD3Ai8BEN9/bI6Yv/770y98hr7CY6cu/r9HrxGk5CFXfmraHMe/D4CfgpzXwXF/Y/q63o1INWIg7TzbGfAsku3hooItjDXCbO+9XH/ZnuV5yX1F7ReKiI0j741hdhKRU9QUFwdkT4fQL4b1bYNGNsOsDuGSGVWhOKSe6EricU2Ija9RekfgYXQ2svCjuDLvM9AOQusTadOaH5d6OSjUwmgDKmTS4I5GhZTd/jwwNZtLgjhU8w7X46HAOHy2goEin5ikvCQ6B8yfBuDXQqDm8cRUsuR2OH/F2ZKqB0ARQzvAeCTxxZVcSYiMRICE2kieu7MrwHictWaiUYyroQZ0JpLytdTerzPS5f4VvX4fnU+Dndd6OSjUAbo0B+KvhPRJq/IVfnvNq4Jp2HylV50LC4cKp0PESeG8CvHI59L0VLnwYQvXfZ6DSKwAPcawG1rLQqkFp28fah7jPeNjwvF1mepO3o1JeognAQ+J0c3jVUIU1hkumww1LTpSZXvWolpkOQJoAPKRFVDgiWg5CNWCnDrDLTF8Lnz0JL14Av233dlSqHmkC8JDQ4CCaNQrTqaCqYYtoAsNnWWWmc3+HOQOsZFCse1kEAk0AHhQXHU6mdgEpX3DmJVZhuTMvtbqDXh6iZaYDgCYAD4qPidArAOU7GjeHUfPLlpn+araWmfZjmgA8KD5aC8IpH+NcZjrxPPj4Pnh1qJaZ9lOaADwoPjqcg7n5lJRoaV7lY2Jaw7UL4fKZsH+LVWb6m9e0zLSf0QTgQfHR4RSVGP44ptPrlA8SgV5j4Nb1cEp3WHo7LLja2pNY+QVNAB4U59gZTMcBlC9r+ie4YSkMmQY/rbUKy21/x9tRqTqgCcCDTuwNrAlA+bigIOh3K9zyGTQ7FRbdBG/fCMcOezsy5QZNAB5UWg/oiE4FVX4i7gy4aQVc8CDsfF/LTPs4TQAeFK9dQMofBYdA/7/D+DXQqIVdZvo2LTPtgzQBeFBkWDDR4SFaEE75p1ZdrSRw7j3w7Rvw/DlaZtrHuJ0ARCRYRLaIyAf2/UQR2SAie0TkLREJs9vD7ft77Mfbu/veviAuRvcGVn4sJNwqKX3TCggOs8pMf3QfFOh2qL6gLq4A7gJ2Ot3/N/CUMeZ04A/gZrv9ZuAPu/0p+zi/Fx8drlcAyv+17Q0TPoe+E2DDbHjhPNj3tbejUlVwKwGISBvgUuAl+74AFwCL7ENeAYbbt4fZ97EfH2gf79fio7UchAoQYY3g4n9bU0aL8mHeIPjkEeu2apDcvQJ4GrgXcBQLaQ5kGWMcpQTTAMfWWgnAPgD78Wz7+DJEZLyIbBKRTZmZmW6G531xdjkIoysoVaA49Xxr8Vj3a+Hz/9hlprd5OyrlQq0TgIhcBhwwxmyuw3gwxswxxiQbY5Lj4uLq8qW9Ij46nLzCYnLztbyuCiARMTBsFlzzFhzNhDl/hnUztMx0A+POFUAKMFRE9gJvYnX9PAPEiohjr+E2QLp9Ox1oC2A/3gQ45Mb7+wRdDKYCWschVmG5TpfB6sdg3mCr0qhqEGqdAIwxU4wxbYwx7YGrgdXGmNHAGmCkfdgYYIl9e6l9H/vx1SYA+kVK1wJoVVAVqBo1s8pMj5wHh3+0y0w/r2WmGwBPrAO4D7hHRPZg9fHPtdvnAs3t9nuAyR547wYnXvcGVspy1gi7zPT58PFkq8z0H794O6qAFlL1IVUzxqwF1tq3fwL6uDjmODCqLt7PlziuAHQqqFJAdCu49i3Y8j/4eAo8nwJD/gU9rreqj6p6pSuBPSwmMoSwkCBNAEo5iEDP6+HWL+wy03fAG3/RMtNeoAnAw0SEuKhwHQRWqrzSMtP/hp8/hVl9Yduiqp+n6owmgHoQr+UglHItKAj6TbBWETc/Hd65Gd4eC0f9foJgg6AJoB7o3sBKVaFFB7hpOQx8CHZ+YJWZ/v4jb0fl9zQB1AMtB6FUNQSHwHl/syqMRsVb208u1jLTnqQJoB7ER4eTnVfI8cJib4eiVMPXqiuMWwPn/R2+s8tM//Spt6PyS5oA6oFjNbDOBFKqmkLCYOCDcPNKq+T0q0Nh2b1aZrqOaQKoB7ozmFK11CbZ2oe4762w8QVrFfG+jd6Oym9oAqgHcdF6BaBUrYU1gounwZj3objQqif0yVQtM10HNAHUg/jSBKBTQZWqtcT+1uKx7qPh86esCqMZW70dlU/TBFAPmkeFEyTaBaSU2yJiYNizcO1COHbQ2mtg3XQtM11LmgDqQXCQ0DxK1wIoVWfOGGwVlus8FFY/bu0+lvmDt6PyOZoA6kl8tK4GVqpONWpmlZge+TIc/tnah/jL57TMdA1oAqgnVgLQKwCl6txZV1pXA6cOgOVT4JXL4Y+9Xg7KN2gCqCe6GlgpD4puCde8aW1DmfGdVWZ683zw/z2n3KIJoJ7Ex4RzKDef4hL9B6mUR4hAj+tg4no4pQe8fxe8cRUcyfB2ZA2WJoB6Eh8dTomBQ0f1KkApj4ptZ5WZvvj/wc+fWYXlti3SqwEXap0ARKStiKwRkVQR2SEid9ntzURkpYjstn83tdtFRGaKyB4R2SoiPevqJHyBYzGYzgRSqh4EBUHfW6wy0y06aJnpCrhzBVAE/M0Y0xnoB9wmIp2x9vpdZYzpAKzixN6/FwMd7J/xwPNuvLfPidOtIZWqfy1Ot8tMPwy7PtQy0+XUOgEYYzKMMd/Yt3OAnUACMAx4xT7sFWC4fXsY8KqxfAXEikjrWkfuY3RzeKW8JCgYzrsHxq+FqJZ2memJcDzb25F5XZ2MAYhIe6AHsAFoaYxxjLr8BrS0bycA+5yelma3BQTtAlLKy1qdBeNW22WmF8Bz58BPa70dlVe5nQBEJAp4B7jbGFNm5wZjjAFqNPIiIuNFZJOIbMrMzHQ3vAbj4+2/IQJPrvyBlGmrWbwl3dshKRV4nMtMh0bCq8Pgw79DwVFvR+YVbiUAEQnF+vJ/3Rjzrt38u6Nrx/59wG5PB9o6Pb2N3VaGMWaOMSbZGJMcFxfnTngNxuIt6Ux5d1vpJIT0rDymvLtNk4BS3tImGSZ8Bv0mwtcvWmWmf93g7ajqXUhtnygiAswFdhpj/uP00FJgDDDN/r3Eqf12EXkT6AtkO3UV+bXpy78nr9xuYHmFxUx+dytf7z1Mi6hw4qLD7d9htIiybjcOr/XHo5SqSmgkDHkCOl5ijQm8PATOuRP+/A9rE5oA4M43TApwPbBNRL612/6B9cW/UERuBn4BrrIfWwZcAuwBjgE3uvHePmV/Vp7L9uOFJSzblsEfxwpdPh4ZGmwnBjspOJKEfd+RNFpEh9M4LBgrJyulaiTxPGvx2PL74YunYfcKuGI2tE7ydmQeJ6YBL45ITk42mzZt8nYYbkuZtpp0F0kgITaSLyZfQGFxCYePFpCZk8/B3HwO5jrftn9yCjiYm8/hYwUu17NEhAaVXjnEOScKR5IobQ8jKjxEk4VSrvywApbeYZWaPn8ynPtXa7N6HyMim40xyVUd53tn5oMmDe7IlHe3lekGigwNZtLgjgCEBgfRMiaCljERVb5WkSNZ2InioFOisJJGAfsOH2PLr39w6KjrZBEeElR65XDS1USUfcVh34+J0GShAsgZg2Dil7BsEqx5HL5fBle8AHFneDsyj9ArgHqyeEs605d/z/6sPE6JjWTS4I4M7+HZWbDFJYbDRwucksOJK4yDOflkOiWNw0fzcVWmKCwkiLgop26oqHBaRJ+cNOKiwomJ1GSh/MiO9+CDe6DwGAx8yNqXOMg3qudU9wpAE4ACrGTxx7GCMt1NjqRR/mrj0NECl0XtwoKDaB4V5pQYnJOGdT/efqxJZKgmC9Xw5fxuFZX74SP4UwoMfw6atvd2VFXSBKA8pqQ0WRSc1P1UfuziUG4BRS6SRWiw0Lyx09WE0yB3i6iwMvdjI0MJCtJkobzEGPj2Dfh4MpgSGPxP6DnGqj7aQGkCUA1CSYkhO6/QuorIcbqasO+XXmHkFHDoaD6FxSf/ewwJEpo7X03Y3VBxLsYumjYK02ShPCNrHyy5DX7+FE6/CIb+F2IaZjUbTQDK5xhjJQvriqKgNGmUGbtwSiSukkVwkNCssfMVhH27NGlElF51NG0URrAmC1UTJSWwaS6seNBaK3DJDOg6ssFdDWgCUH7NGMORvCL7iiK/TGJwjGGUTqnNzaeg6OR9YoMEmjW2k0R0eJmk4Xy1ERcdTrPGmiyUk0M/wnsTIG0jdBoKlz0FjVt4O6pSmgCUshljyMkvssYncvLLjF04xi8ynQa58ytMFmFlupvKdD85XW00axxGSLBvzBZRbigphvUzYc2/IKIJXP4MnHmpt6MCNAEoVSvGGHLzi0qTROmgtiNJlBn0zud44cnJQgSaNQrDecps+cV4zlcWoZosfNvvO+C9W+C3bZB0rVVeIjLWqyFpAlDKw4wxHC0oLrsYz3kmVE7ZsYtjBcUuX6dpo9CTF+M5zY5ytDeP0mTRYBUVwLrp8NmTEN3K2pz+tD97LRxNAEo1MEfzi5yuIE7uhnIe5D5aQbKItZNFi3IruONcXG2EhWiyqHdpm2HxBDj4A/QeBxc9AmGN6z0MTQBK+bC8gmIO5uZzwHkWVAVJIze/yOVrNIkMLVNIMK5cF5Tz2EV4SHA9n6EfK8yDVY/BV89Bs0QYPhva9a3XEDQBKBUgjhcWV6uQYGZuPjnHXSeL6IiQslcT5SvQOiWOiFBNFtWy93NYfCtkp8E5d8CAf0Bo1fW+6oImAKXUSY4XFpepB3XSSm6nKbVHKkoW4SEnZj2VWYh3opCg42oj4JNFfg6seAA2z4e4TlaZ6VO6e/xtNQEopdySX1TMoZOuKE7cd77qyM5zvadFVHjISYUEnRfjOY9fNArz4+LEu1fCktutMtP977U2qQ8O9djbaQJQStWbgqISDh0tW0gw0ylpOJf9yKpgA6TGYcFl6kE5j1PE+cNueccOw0f3wbaFcEoPa2wg/kyPvJUmAKVUg1RYXMKh3BPjEgcrKCRolSkvcPkakaHBpfWgXO2W18JpZXeD2y1vx2L44K/WRvQDH7L2Ja7jMtOaAJRSPs/VbnmuCglWd7c8x4B2+d3yHOMZ9bZbXu4Bq8z098usMtPDZlkzhupIg00AIjIEeAYIBl4yxkyr6FhNAEqp6ioqLuHwsQIOVlJI0JFIDh8tcLkBkqvd8sou0qvD3fKMge8WWN1CJcUw+HHodWOdFJZrkAlARIKBH4CLgDTga+AaY0yqq+M1ASilPMF5t7yTFuOVK1t+KLfi3fJaNC5fE+rkpFHlbnnZaVaZ6Z/WwukX8l1EX1pun0O8yeSAxLGv5yR6D72lRufXUPcE7gPsMcb8BCAibwLDAJcJQCmlPCE4SKyuoOjwKo91tVueo/vJkTQyso+zLT27yt3yyq+pKB2/OOdFTk9YSPPPH6ZbySfWRYBAKzJpsvkBvoYaJ4HqqO8EkADsc7qfBtTvEjmllKqB4CAp/bKmVeXHlpQYskr3tHBR5iM3n9+PHGfH/mwXu+Ul8lV4NK3kjzKvGSkFtP1mOvhBAqiSiIwHxgO0a9fOy9EopVT1BdkbEjVrHMYZLaMrPdaxW57zvtvx7/7h8th4c9AT4VLf1aLSgbZO99vYbaWMMXOMMcnGmOS4uLh6DU4ppepLUJDQtHEYHVpGc85pLRiadAoHxPV33gHxzGYz9Z0AvgY6iEiiiIQBVwNL6zkGpZRqkPb1nESeCSvTlmfC2Ndzkkfer167gIwxRSJyO7AcaxroPGPMjvqMQSmlGqreQ2/ha6DtN9OJNwc5IC3Y16vms4CqSxeCKaWUn6nuNFDdMUIppQKUJgCllApQmgCUUipAaQJQSqkApQlAKaUCVIOeBSQimcAv3o6jjrUAPLOsz3v88ZzAP8/LH88J/PO83DmnPxljqlxJ26ATgD8SkU3VmZ7lS/zxnMA/z8sfzwn887zq45y0C0gppQKUJgCllApQmgDq3xxvB+AB/nhO4J/n5Y/nBP55Xh4/Jx0DUEqpAKVXAEopFaA0AXiIiAwRke9FZI+ITHbx+FgRyRSRb+2f//NGnDUhIvNE5ICIbK/gcRGRmfY5bxWRnvUdY01V45wGiEi20+f0UH3HWFMi0lZE1ohIqojsEJG7XBzjU59VNc/JFz+rCBHZKCLf2ef1iItjwkXkLfuz2iAi7essAGOM/tTxD1ap6x+BU4Ew4Dugc7ljxgLPejvWGp5Xf6AnsL2Cxy8BPgIE6Ads8HbMdXBOA4APvB1nDc+pNdDTvh0N/ODi359PfVbVPCdf/KwEiLJvhwIbgH7ljpkIzLZvXw28VVfvr1cAntEH2GOM+ckYUwC8CQzzckxuM8asAw5Xcsgw4FVj+QqIFZHW9RNd7VTjnHyOMSbDGPONfTsH2Im1H7czn/qsqnlOPsf+759r3w21f8oPzA4DXrFvLwIGiojUxftrAvCMBGCf0/00XP9jHWFffi8SkbYuHvc11T1vX3O2fYn+kYh08XYwNWF3F/TA+svSmc9+VpWcE/jgZyUiwSLyLXAAWGmMqfCzMsYUAdlA87p4b00A3vM+0N4Y0w1YyYkMrxqWb7CW1ScB/wUWezmeahORKOAd4G5jzBFvx1MXqjgnn/ysjDHFxpjuWHuk9xGRs+rrvTUBeEY64PwXfRu7rZQx5pAxJt+++xLQq55i86Qqz9vXGGOOOC7RjTHLgFARD+3QXYdEJBTri/J1Y8y7Lg7xuc+qqnPy1c/KwRiTBawBhpR7qPSzEpEQoAlwqC7eUxOAZ3wNdBCRRBEJwxq4Wep8QLn+1qFYfZq+bilwgz3DpB+QbYzJ8HZQ7hCRVo7+VhHpg/X/TJ38z+cpdrxzgZ3GmP9UcJhPfVbVOScf/aziRCTWvh0JXATsKnfYUmCMfXsksNrYI8LuqtdN4QOFMaZIRG4HlmPNCJpnjNkhIo8Cm4wxS4E7RWQoUIQ1CDnWawFXk4gswJpp0UJE0oCHsQatMMbMBpZhzS7ZAxwDbvROpNVXjXMaCdwqIkVAHnB1Xf3P50EpwPXANrtvGeAfQDvw2c+qOufki59Va+AVEQnGSlgLjTEflPuumAu8JiJ7sL4rrq6rN9eVwEopFaC0C0gppQKUJgCllApQmgCUUipAaQJQSqkApQlAKaUClCYApZQKUJoAlFIqQGkCUEqpAPX/AZJccTvRuuYdAAAAAElFTkSuQmCC\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from glob import glob\n",
    "import re\n",
    "\n",
    "plt.legend([\n",
    "    plt.plot(*zip(*(\n",
    "        (\n",
    "          float(rate),\n",
    "          np.quantile([np.min(slice) for slice in each_slice(Result(\n",
    "            path=f\"sigmod.04.10/iterations=100/rate={rate}/tracking_frequency=1/tracking=acking/distributed=False\"\n",
    "          ).notification_await_times(), 100)], 0.5),\n",
    "        )\n",
    "        for rate in sorted(set([\n",
    "            re.search(\"rate=(\\d+(?:\\.\\d*)?)\", path)[1]\n",
    "            for path in glob(f'results/sigmod.04.10/iterations=100/rate=*/tracking_frequency=1/tracking=acking/distributed=False')\n",
    "        ]) - {'3'}, key=float)\n",
    "    )), marker='o') and \"Centralized acker\",\n",
    "    plt.plot(*zip(*(\n",
    "        (\n",
    "          float(rate),\n",
    "          np.quantile([np.min(slice) for slice in each_slice(Result(\n",
    "            path=f\"sigmod.04.10/iterations=100/rate={rate}/tracking_frequency=1/tracking=acking/distributed=True\"\n",
    "          ).notification_await_times(), 200)], 0.5),\n",
    "        )\n",
    "        for rate in sorted(set([\n",
    "            re.search(\"rate=(\\d+(?:\\.\\d*)?)\", path)[1]\n",
    "            for path in glob(f'results/sigmod.04.10/iterations=100/rate=*/tracking_frequency=1/tracking=acking/distributed=True')\n",
    "        ]), key=float)\n",
    "  )), marker='o') and \"Distributed acker\",\n",
    "], title=\"Tracking\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}