ModelSwapping.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "# Online Model Swapping in SVE-Cachesim\n",
       "\n",
       "\n",
       "## Project Structure\n",
       "\n",
       "### Source Files\n",
       "This project consists of four files. \n",
       "* `sveCacheSim.py`: The simulation driver\n",
       "* `CacheModels.py`: All of the cache models and model swapping methodology\n",
       "* `PhaseDetector.py`: The phase detection methdology\n",
       "* `Markov.py`: An implementation of a predictive markov chain\n",
       "    \n",
       "### Trace Files\n",
       "Trace files that we used are in `traces/`. They are \n",
       "* `traces/memtrace.meabo.i125.N512.P521.L1.log`\n",
       "* `traces/memtrace.meabo.i125.N512.P521.L2.log`\n",
       "* `traces/memtrace.meabo.i125.N1536.P521.L3.log`\n",
       "\n",
       "We will refer to these traces later as 'small', 'medium' and 'large', respectively. \n",
       "The naming of each file indicates how we ran Meabo to genrate that trace. So, `i125` means we ran with `-i 125`, \n",
       "`N512` means we use an input size of 512 for any phase we ran, `P512` means we ran with `-P 521` which means we \n",
       "ran phases 1, 4, and 10, and `Ln` means\n",
       "we ran with `-L n`, with n indicating the number of times each phase is run. \n",
       "\n",
       "### Gold Files\n",
       "The files in `gold/` represent the proper stats when running the cache without any model swapping. There is one for each trace file. The mapping \n",
       "from trace file to gold file in in sveCacheSim.simulation so you never forget! In fact, you don't actually have to worry about the trace files and \n",
       "the gold files at all, as that is all handled for you by that function. Simply tell it the trace_id of 'small', 'medium' or 'large', and \n",
       "it takes care of the rest! \n",
       "\n",
       "### Base Models\n",
       "These files allow you to configure the base cache. We will only use `base-models/3-level.json` in this work. \n",
       "\n",
       "## Running Some Simulations\n",
       "The first two files need to be imported before we can run our simulations. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "# Online Model Swapping in SVE-Cachesim\n",
    "\n",
    "\n",
    "## Project Structure\n",
    "\n",
    "### Source Files\n",
    "This project consists of four files. \n",
    "* `sveCacheSim.py`: The simulation driver\n",
    "* `CacheModels.py`: All of the cache models and model swapping methodology\n",
    "* `PhaseDetector.py`: The phase detection methdology\n",
    "* `Markov.py`: An implementation of a predictive markov chain\n",
    "    \n",
    "### Trace Files\n",
    "Trace files that we used are in `traces/`. They are \n",
    "* `traces/memtrace.meabo.i125.N512.P521.L1.log`\n",
    "* `traces/memtrace.meabo.i125.N512.P521.L2.log`\n",
    "* `traces/memtrace.meabo.i125.N1536.P521.L3.log`\n",
    "\n",
    "We will refer to these traces later as 'small', 'medium' and 'large', respectively. \n",
    "The naming of each file indicates how we ran Meabo to genrate that trace. So, `i125` means we ran with `-i 125`, \n",
    "`N512` means we use an input size of 512 for any phase we ran, `P512` means we ran with `-P 521` which means we \n",
    "ran phases 1, 4, and 10, and `Ln` means\n",
    "we ran with `-L n`, with n indicating the number of times each phase is run. \n",
    "\n",
    "### Gold Files\n",
    "The files in `gold/` represent the proper stats when running the cache without any model swapping. There is one for each trace file. The mapping \n",
    "from trace file to gold file in in sveCacheSim.simulation so you never forget! In fact, you don't actually have to worry about the trace files and \n",
    "the gold files at all, as that is all handled for you by that function. Simply tell it the trace_id of 'small', 'medium' or 'large', and \n",
    "it takes care of the rest! \n",
    "\n",
    "### Base Models\n",
    "These files allow you to configure the base cache. We will only use `base-models/3-level.json` in this work. \n",
    "\n",
    "## Running Some Simulations\n",
    "The first two files need to be imported before we can run our simulations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sveCacheSim as sim\n",
    "import CacheModels\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "from tqdm import tqdm\n",
    "import importlib\n",
    "importlib.reload(sim)\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Meabo Traces\n",
       "\n",
       "Before we run any simulations, we should take a look at what our phase detector is doing with the traces we give it. \n",
       "We'll run some simulations now, but we won't worry about the stats. We'll just grab the phase trace that gets included with the stats. \n",
       "As we are passing `None` as the first argument, these simulations will not do any model swapping. (Of course, model swapping does not affect the phase trace anyways.)\n",
       "\n",
       "### Meabo Changes\n",
       "\n",
       "For those of you familiar with Meabo, you'll notice a few changes. The first, mentioned above, is that we added a `-L` argument to allow users\n",
       "to run each phase multiple times. The second is that we added a marker phase between the Meabo phases so we can be totally sure that we \n",
       "know that our phase detection is working. This phase is designed to write over a small location a few times, so it should be essentially 100% write hits. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Meabo Traces\n",
    "\n",
    "Before we run any simulations, we should take a look at what our phase detector is doing with the traces we give it. \n",
    "We'll run some simulations now, but we won't worry about the stats. We'll just grab the phase trace that gets included with the stats. \n",
    "As we are passing `None` as the first argument, these simulations will not do any model swapping. (Of course, model swapping does not affect the phase trace anyways.)\n",
    "\n",
    "### Meabo Changes\n",
    "\n",
    "For those of you familiar with Meabo, you'll notice a few changes. The first, mentioned above, is that we added a `-L` argument to allow users\n",
    "to run each phase multiple times. The second is that we added a marker phase between the Meabo phases so we can be totally sure that we \n",
    "know that our phase detection is working. This phase is designed to write over a small location a few times, so it should be essentially 100% write hits. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 2:17]          \n",
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 3:58]          \n",
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 14:46]          \n"
     ]
    }
   ],
   "source": [
    "stats_small, _  = sim.simulation(None, trace_id='small',  show_summary=False)\n",
    "stats_medium, _ = sim.simulation(None, trace_id='medium', show_summary=False)\n",
    "stats_large, _  = sim.simulation(None, trace_id='large',  show_summary=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "### Phase Trace Object\n",
       "We first need to grab the phase trace object from the stats of our simulation. It is stored in `stats_*.phase_trace`. This object\n",
       "has type `PhaseTrace` which is defined in `PhaseDetector.py` and includes 4 fields.\n",
       "\n",
       "* `trace`: The phase assigned to each interval. -1 represents an interval not identified as part of a phase. \n",
       "* `nphases`: The number of unique phases identified.\n",
       "* `phase_count`: A list of length nphases where phase_count[i] is the number of intervals assigned to phase i\n",
       "* `phase_unique`: A list of length nphases where phase_unique[i] is the number of times phase i was entered\n",
       "\n",
       "Let's take a look at these for the 'large' trace. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "### Phase Trace Object\n",
    "We first need to grab the phase trace object from the stats of our simulation. It is stored in `stats_*.phase_trace`. This object\n",
    "has type `PhaseTrace` which is defined in `PhaseDetector.py` and includes 4 fields.\n",
    "\n",
    "* `trace`: The phase assigned to each interval. -1 represents an interval not identified as part of a phase. \n",
    "* `nphases`: The number of unique phases identified.\n",
    "* `phase_count`: A list of length nphases where phase_count[i] is the number of intervals assigned to phase i\n",
    "* `phase_unique`: A list of length nphases where phase_unique[i] is the number of times phase i was entered\n",
    "\n",
    "Let's take a look at these for the 'large' trace. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Identified 5 phases\n",
      "Number of intervals assigned to each phase [67, 113, 232, 112, 338]\n",
      "Number of times each phase was entered [1, 10, 3, 3, 3]\n"
     ]
    }
   ],
   "source": [
    "trace = stats_large.phase_trace\n",
    "print('Identified', trace.nphases, 'phases')\n",
    "print('Number of intervals assigned to each phase', trace.phase_count)\n",
    "print('Number of times each phase was entered', trace.phase_unique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "This looks good, as we expect each of our three Meabo phases to be entered 3 times which is what we see in the `phase_unique` data. \n",
       "\n",
       "### Phase Plot\n",
       "\n",
       "We should take a look at the trace itself. Let's plot the phase traces for each of the traces.\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "This looks good, as we expect each of our three Meabo phases to be entered 3 times which is what we see in the `phase_unique` data. \n",
    "\n",
    "### Phase Plot\n",
    "\n",
    "We should take a look at the trace itself. Let's plot the phase traces for each of the traces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "trace_small  = stats_small.phase_trace.trace\n",
    "trace_medium = stats_medium.phase_trace.trace\n",
    "trace_large  = stats_large.phase_trace.trace\n",
    "\n",
    "def plot_trace(ax, label, trace, axis_labels):\n",
    "    ax.scatter([*range(len(trace))], trace,s=2, color='red')\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.set_title(label)\n",
    "    if axis_labels:\n",
    "        ax.set_ylabel('Phase Number (-1 is uncategorized)')\n",
    "        ax.set_xlabel('Interval number (Interval = 10k inst)')\n",
    "\n",
    "fig, ax = plt.subplots(1, 3, figsize=(12,4))\n",
    "plot_trace(ax[0], 'Small',  trace_small,  True)\n",
    "plot_trace(ax[1], 'Medium', trace_medium, False)\n",
    "plot_trace(ax[2], 'Large',  trace_large,  False)\n",
    "#plt.savefig('plots/phase-traces.svg')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "We see above that our marker phase is identified as phase 1 each time and the Meabo phases (2, 3, 4) are run the expected number of times\n",
       "int each trace. It is hard to tell from the scale here, but the Meabo phases in the Large trace run longer than in the other two.  \n",
       "\n",
       "## Accuracy Study\n",
       "\n",
       "It's time to actually look at the results of our simulation. We'll be looking at four different cache models, \n",
       "* `FixedHitRate`\n",
       "* `Markov4`\n",
       "* `Markov8`\n",
       "* `All`\n",
       "\n",
       "The first three will train the same type of model for each phase. The last model will train all of the previous three for each phase, \n",
       "then pick between them. \n",
       "\n",
       "We have already run the base model, so well stick that in our dictionary, and run the rest. Let's view the summary for these models as they run.\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "We see above that our marker phase is identified as phase 1 each time and the Meabo phases (2, 3, 4) are run the expected number of times\n",
    "int each trace. It is hard to tell from the scale here, but the Meabo phases in the Large trace run longer than in the other two.  \n",
    "\n",
    "## Collecting Data\n",
    "\n",
    "It's time to actually look at the results of our simulation. We'll be looking at four different cache models, \n",
    "* `FixedHitRate`\n",
    "* `Markov4`\n",
    "* `Markov8`\n",
    "* `All`\n",
    "\n",
    "The first three will train the same type of model for each phase. The last model will train all of the previous three for each phase, \n",
    "then pick between them. \n",
    "\n",
    "We have already run the base model, so well stick that in our dictionary, and run the rest. Let's view the summary for these models as they run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 2:42]          \n",
      "Trace: memtrace.meabo.i125.N512.P521.L1.log\n",
      "Summary:\n",
      " L1 percent change in hit count: 0.01%\n",
      " L2 percent change in hit count: 19.71%\n",
      " L3 percent change in hit count: -7.04%\n",
      " Percent change in cycles: -19.49%\n",
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 2:50]          \n",
      "Trace: memtrace.meabo.i125.N512.P521.L1.log\n",
      "Summary:\n",
      " L1 percent change in hit count: -0.52%\n",
      " L2 percent change in hit count: 23.26%\n",
      " L3 percent change in hit count: -4.31%\n",
      " Percent change in cycles: -17.24%\n",
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 2:54]          \n",
      "Trace: memtrace.meabo.i125.N512.P521.L1.log\n",
      "Summary:\n",
      " L1 percent change in hit count: -0.78%\n",
      " L2 percent change in hit count: 15.14%\n",
      " L3 percent change in hit count: -7.36%\n",
      " Percent change in cycles: -3.53%\n",
      "[xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] [Elapsed: 2:42]          \n",
      "Trace: memtrace.meabo.i125.N512.P521.L1.log\n",
      "Summary:\n",
      " L1 percent change in hit count: -0.06%\n",
      " L2 percent change in hit count: 8.22%\n",
      " L3 percent change in hit count: -9.59%\n",
      " Percent change in cycles: -4.54%\n"
     ]
    }
   ],
   "source": [
    "stats = {}\n",
    "stats['base']    = stats_small\n",
    "\n",
    "stats['fr'], _   = sim.simulation(CacheModels.FixedHitRateSmartCache, trace_id='small')\n",
    "stats['m4'], _   = sim.simulation(CacheModels.Markov4StateSmartCache, trace_id='small')\n",
    "stats['m8'], _   = sim.simulation(CacheModels.Markov8StateSmartCache, trace_id='small')\n",
    "stats['all'], _  = sim.simulation(CacheModels.AllModelSmartCache,     trace_id='small')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy \n",
       "\n",
       "Ok, first thing we should check out is how well the models did at predicting the proper hits or misses. First we'll collect this data into\n",
       "a dataframe called accuracy_df, then we'll plot it. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown \n",
    "\n",
    "## Accuracy \n",
    "\n",
    "Ok, first thing we should check out is how well the models did at predicting the proper hits or misses. First we'll collect this data into\n",
    "a dataframe called accuracy_df, then we'll plot it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Fixed Rate  Markov 4  Markov 8\n",
      "0    0.688158  0.709025  0.763008\n",
      "1    0.988111  0.974292  0.972607\n",
      "2    0.698668  0.713695  0.869632\n",
      "3    0.539333  0.625350  0.672950\n",
      "4    0.818771  0.852806  0.888687\n"
     ]
    }
   ],
   "source": [
    "def get_acc(st1, st2, phase):\n",
    "    # t1 is assumed to be from the base cache\n",
    "    \n",
    "    t1 = st1.cache_trace[0] # cache trace from st1\n",
    "    t2 = st2.cache_trace[0] # cache trace from st2\n",
    "    \n",
    "    # Just get accesses where were are in phase `phase` and in state is Swapped (2)\n",
    "    pick_state = t2['state'] == 2\n",
    "    pick_phase = t2['phase'] == phase\n",
    "    \n",
    "    pick = np.logical_and(pick_state, pick_phase)\n",
    "    \n",
    "    # Get the hit/miss from each \n",
    "    t1_hits = t1['isHit'][pick]\n",
    "    t2_hits = t2['isHit'][pick]\n",
    "    \n",
    "    num_correct = np.sum(np.equal(t1_hits, t2_hits))\n",
    "    acc = num_correct / len(t1_hits)\n",
    "    \n",
    "    return acc\n",
    "    \n",
    "nphases = stats['base'].phase_trace.nphases\n",
    "name_map={'fr':'Fixed Rate', 'm4': 'Markov 4', 'm8':'Markov 8', 'all':'All'}\n",
    "data = {}\n",
    "for name in stats:\n",
    "    if name is 'base' or name is 'all':\n",
    "        continue\n",
    "    acc = []\n",
    "    for i in range(nphases):\n",
    "        acc.append(get_acc(stats['base'], stats[name], i))\n",
    "    data[name_map[name]] = acc\n",
    "accuracy_df = pd.DataFrame(data)\n",
    "print(accuracy_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAEWCAYAAAA+bHOCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd3xUVfr48c9JIw1CaAKBkCAdQhMRBQFFKRsBUbGggoKiiIq6lrg16373J65r3UUB2yKiVGkGBGQpgghITSgBhABJKCGQ3jPn98edxJRJMimTycw879drXmbuvXPvMzHMM+fcc56jtNYIIYQQjsLN3gEIIYQQ1SGJSwghhEORxCWEEMKhSOISQgjhUCRxCSGEcCiSuIQQQjgUSVzCqSmlIpVSX9k7DiFE3ZHEJeqFUipOKZWtlMpQSl1SSv1XKeVv77jqk/k9Fyil2tg7FiEcmSQuUZ/Gaq39gf7AAOBP1XmxMjjk36xSyg+4F0gFHqnna3vU5/WEsDWH/BAQjk1rnQCsB3oBKKUGKaV+UkqlKKUOKaWGFx2rlNqqlPqHUmonkAV0LHkupVSIUkorpaYrpRKVUheUUi+XuaSXUupLpVS6UuqIUmpAiddHKKV+Ne87qpSaUGJfJ6XUNqVUqlLqilJqSYl93ZRSm5RSV5VSsUqp+6t42/cCKcAbwJQy76GZUuoLc/zXlFKrSuwbr5Q6qJRKM8c52rw9Til1R4njirtES/xOpimlzgH/M29fppS6aH4/25VSPUu83kcp9Y5S6qx5/w7ztiil1HNl4j1c8vckRH2TxCXqnVKqPfA74IBSKgiIAv4PaAa8DKxQSrUs8ZJHgelAY+BsBae9DegMjAReK/mhDowDFgNNgTXAf0rs+xW4FQgA/gZ8VaIr7+/ARiAQaAf82xy/H7AJ+BpoBTwIfKSU6lHJ254CfGOOo5tS6oYS+xYCvkBP8/neM19nIPAl8Io59qFAXCXXKGsY0B0YZX6+HuN31ArYDywqcey/gBuAWzD+P7wKmIAFlGghKqX6AEX/z4SwD621PORh8wfGB24GRqvjLPAR4AO8Biwsc+wGYIr5563AG5WcNwTQQLcS2/4JfGb+ORL4ocS+HkB2Jec7CIw3//wlMB9oV+aYB4Afy2ybB/y1gnMGYySBviXe3wfmn9uY9wVaeN084L1Kfp93lHgeCXxV5nfSsZL32dR8TADGF9hsoI+F47yBa0Bn8/N/AR/Z++9JHq79kBaXqE93a62baq07aK2f0VpnAx2AieZuwhSlVAowBOMDvcj5oh/MgzuKHsGWjsFIjG1LPL9Y4ucswLvovo9SarK5K67o2r2AFuZjXwUUsMfcxTjVvL0DcFOZmB8GWlfwvh8FjmmtD5qfLwImKaU8gfbAVa31NQuva4/RIqypkr83d6XUbHN3Yxq/tdxamB/elq6ltc4BlgCPmO8vPoTRQhTCbuSmrbC38xgtricrOaZ4CQNtDO4oppQKMf/YHjhu/jkYSKzqwkqpDsAnwAhgl9a6UCl1ECNZobW+CDxpPnYI8INSars55m1a6zuruobZZCBYKVWUQD2A5hjdpXuAZkqpplrrlDKvOw9cX8E5MzG6F4tYSpoll36YBIwH7sBIWgEYLSkFXAFyzNc6ZOE8CzCS1Q4gS2u9q4KYhKgX0uIS9vYVMFYpNcrcKvBWSg1XSrWr5nn+rJTyNQ84eByjlVAVP4wP9yQApdTjmAeMmJ9PLBHHNfOxJuA7oItS6lGllKf5caNSqnvZCyilbsZICAOBvuZHL4z7Y5O11hcw7j19pJQKNJ9rqPnlnwGPK6VGKKXclFJBSqlu5n0HgQfNxw8A7qvivTYGcoFkjIT3/4p2aK1NwOfAu0qptub/DzcrpRqZ9+8yv+93kNaWaAAkcQm70lqfx2gJ/AEjgZzHGIxQ3b/NbcApYDPwL631RiuufRTjw3gXcAkIA3aWOORGYLdSKgNjUMcsrfVprXU6xiCQBzFadheBt4BGFi4zBVittY7WWl8segAfAHcppZphdCXmY7QYLwMvmOPbg5GE38MYRr8No5sS4M8YCfEaxqCSr6t4u19idKEmAEeBn8vsfxmIBvYCV83vx63M68MwvmgIYVdKa1lIUjguc1fhGcBTa11g32icl1JqMjBdaz3E3rEIIS0uIUSllFK+wDMYIyyFsDtJXEKICimlRmF04V6i6u5IIeqFdBUKIYRwKDZrcSmlPldKXVZKxVSwXymlPlRKnTKXkOlvq1iEEEI4D1t2Ff4XGF3J/jEY5Wc6Y5Tz+diak44ePVpjDEuWhzzkIQ95WP9wGjZLXFrr7RjDaisyHvhSG34Gmiorlnu4cuVKXYUohBDCAdmzckYQpcv0xJu3XbBPOKLIqgMJvL0hlsSUbNo29eGVUV25u1+QvcMSQgjAQUo+KaWmY3QnEhwcXMXRojZWHUjg9W+jyc4vBCAhJZvXv40GkOQlhGgQ7DkcPgGjvlyRduZt5Wit52utB2itB7Rs2dLSIaKOvL0htjhpFcnOL+TtDbF2ikgIIUqzZ+JaA0w2jy4cBKSa67YJO0pMyWac2w52eD3P6UaT2OH1POPcdpCYkm3v0IQQArBhV6FS6htgONBCKRUP/BXwBNBazwXWYVTHPoWx1MTjtopFWG+K/x56e33F1Gb+XPRoT+uCQp6++hXN8ryAcHuHJ4QQtktcWuuHqtivgZm2ur6omd6Nl/JmkybkuBmN8QueHrzZsgmvpy3FqOUqhBD2JSWfRClz/ShOWkVy3Nx4r7EiJafsclFCCFH/JHG5uKT0XB7+9Gei41MhL4uLHu4Wj0txd+fx7x8rfp5TZgCHEELUF0lcLuzEpXTunrOTfWeT+Ob453z3xTBaF1hOSC1w55XUTEi/xJpDiYx4ZxtHE9MASM1NJTM/sz5DF0K4MElcLsxNKby8rxDcey5rEz5nT8tgZvV8HG/lWeo4b+XJy+1Gc8v5aJg7mC6eSRSaNPd+/BM/n05m0bFFDFk8hCc3PsnOhJ0VXE0IIeqGQ0xAFrbRqZU/a2eEM2vrBv5082sMbWdeMf66nnyw/wMuZl6ktV9rZvWfRXjHcAibAns/o1u3MNY8m8fs9cfp0bYJjZsMI6cgh+3x20nPT7fvmxJCOD2HW9ZkwIAB+pdffrF3GKICWmuUUuW2zz00l2bezRjabiit/VrbITIhXF75f5gOSlpcLiI7r4CswlSa+zSHg99AQDsIvbXOr2MpaZm0ifVn1nM69TQAm+7bJMlLCFFjkrhcwM/nj/Hs93/Fx/cam/064XXwa+h1b90lrtQE2D0XbvsjucqTo4lp9AsOLN7tptxYNX4VZ1LPsP/yfotJy6RNpOSm0My7Wd3EJIRwWjI4w8kdu3CVJzdNJdfjDKOuG4k6+QMMfRUmzK+7i5zcCD99CJ/ewaKozUycu4uFP58tdYhSio5NO3Jfl/ssnuLIlSMMXzKch6MeZtGxRXUXmxDC6UiLy8mFtgigr/czPDfkVgYGh8CQ6eAdULcXGfA4NGkLq5/lge6N2HEtkD+viiG0uR9DOrew6hQtfVsyo+8MdsTv4FjysbqNTwjhVGRwhqg7eVng5UuhSfN9zEV+F9ba4j2vqpi0CTdVvjNgy7ktnE07y9B2QwkNCK3RuYVwYU7zD0a6Cp1EWl4a/435LyZtMjZcPQOmeq5u4eULgLubIrx3mxonFktJC2Bn4k7e2fcO41ePZ9WpVTUOUwhnFbYgjIgfI4qfF5gKGLp4KDM3V68sbNiCsOFhC8K+q+PYRoQtCNsftiDsYNiCsB1hC8I61fRckricwNpf1zJ25Vje3fcuuxL2G6MGP74Ffvq3vUMznN8DddCy/9OgP7Hx3o38edCfubntzRaPSc1NrfV1hHBUPh4+nLp2ipyCHAB2Je6ilW+rap0jbEGYrW4hfQw8HD0lui/wNfCnmp5I7nE5gTOpZ2jp3ZaCxGkcWruDwZf+Ch2GQO8H7B0aJOyDz+6EbncRN3g2UadymTHsetzcatYaa+Pfhvu73m9xn0mbGLdqHIGNAhnabihP93kaX0/f2kQvhMO5td2tbI/fzsiQkaw/s54xoWPYf3k/AGELwgYCHwDeQDbwePSU6NiwBWGPAfcA/oA7xjJURa+5EZgP3AeEAP/CyB17gRnAbcC06CnRE83HDwdejp4SfVeZ0DTQxPxzAJBY0/coLS4nMLHTVE4cnEJuZhsGjXkYxn4Ak1dDkzb2Dg3a9oeR/4ATG8hYG8HbG2J5ZtF+MnML6vxSBaYCpvWaRgvfFqw7sw5vD+86v4YQDd3okNF8H/c9uYW5nLh2gt4te5fcfRy4NXpKdD/gL8D/K7GvP3Bf9JToYUUbwhaE3QLMBcZjrFD/X+CB6CnRYRjJawbwA3BT2IIwP/PLHgAWWwjtCWBd2IKweOBRYHZN36MkLgdSWME9qzZN/HllZDdWPjOY/iEt4YbHwL2BNKaVgluehWkb6Pnou/wpvDs/nkzibHJWnV/Ky92LyT0n8+nIT1l/73qL98ouZFzgo4MfEZ0U/dv9QCGcSNdmXUnISGDd6XXc2q7cXM0AYFnYgrAY4D2gZ4l9m6KnRF8t8bw7RktrbPSU6HNAV+BM9JToE+b9C4Ch0VOiC4DvgbHmbsZwYLWF0F4Efhc9Jbod8AXwbk3foyQuB7H/0n4e+O4Btsdvt7j/0ZtDaN+sAXeLBd2AanwdT9zake2v3kaPtk2qfk0teLp5Wtx++Mph5h2ex6R1k3ht+2s2jUGIuhJ1OoqRy0fSe0FvRi4fSdTpqEqPH95+OO/se4cxoWPK7vo7sCV6SnQvYCxGl2GRsks8XABygH5WhLgYuB+4Hfglekp0qaKlYQvCWgJ9oqdE7zZvWgLcYsV5LZLE5QBWnlzJlO+nkJqXiioa0ZoUC1/eDRmX7RtcDTT3b/Tbk8K67zKszKiQUWy9fytv3vomEzpPsHhMVn4WjjZNRDivqNNRRP4UyYXMC2g0FzIvEPlTZKXJa0KnCczoM4MugV3K7grA6PIDeKyKS6dgtJ7eNN+3igVCSowGfBTYZv55G0ZX45NY7ia8BgSELQgrCuhOoMYTNiVxOYBh7YfxTJ9nWD1+NZ0b38j5H7+C+cPhYjSknLN3eDVXWABfjocfIqEwH5OpfpJFoHcgd3W8i1vaWv7C94/d/2DUilH8fdffi+srCmEv7+17j5zCnFLbcgpz+GD/BxW+prVfax7u/rClXf/ESEQHsGJwXvSU6EvAXcAcoA/wOEZXYzRgwrj/RfSU6ELgO2CM+b9lz1OAkdRWhC0IO4SR9F6p6voVkQnIDiQmIZVpC/Yy1C2at1pvxu2eTxrGAIyays+B9a/C/gUkNbuB57zeYM4jN5ZukdnB92e+Z/2Z9ey6sIvPRn5GWMswu8YjXFvvBb3RlP+cVigOTzlcemNkAITdD/d+YjwvLIB3ukDQAHh4qfVDeSMDhgMvE5ladmRg7UUGfAhMJTLVv6anaCB38AVAYkYi2QXZXN/0+nL78gpMTP/yF9yVYuqUabi1fsEY+ODIPL1h3IfQcRiXjh9n/8F0xv1nJwunDaRjyxr/Tdfa6NDRjA4dTV5hHh5ulv+JfBr9KWEtwujfqj8bz260vH6ZEHWgtV9rLmResLi9HE8/uHwM8rPB0wdOb4HGbat3wcgA2+WFyIABQGCVx1VBElcDkFuYyxcxX/Bp9Kf0btmbz0d9Xu4YLw835jzcn6BAH1o1drJh3r3upVcvWHZTCv/aGEurJg3j/Xm5e1ncnpydzEcHPyLflI+fhx+FurC4K6fo/gMgyUvUiVn9ZxH5U2Sp7kJvd29m9Z9l+QWd74QTG6Dn3RC9HMLuhbO7jH2RAeXmcRGZGktkwGNUMI+LyACr5nERmTrRfPxwLLXWIgPcgbeBSYDlG8xWkntcDcDlzMt8cvgThrcfzv8bUmJaRV4WxK4vftovOND5klYJfdo3ZeG0m/Bv1LC/TzX3ac6OB3fw4W0f4u7mXu37D0KUpbVm09lNvLT1pXLTNMI7hhN5SyRt/NqgULTxa0PkLZEVfzHqdS/ErDC64i8dMboJf3McuJXI1ArncRGZWjyPi8gAi/O4iEwtN4+LyICq5nE9C6whMrV887GaGvYnhIto36Q9ayespa1/iSZ9UiwsnQLJJ+H5A9A02H4B2svJHyDzMvSdZO9IyvH19OW24NtI35Jucf/FzItk5WdJ5Q5RJa01L2x5gf+d/x9dA7tyNecqLXxKr6oQnpFJ+PlESI2HABN0KTtyvYTWvYxBWzHLjdZXaQHAAiIDOmNUsig5b2QTkamW5nGNJDI1kciAPsAZIlNLzuOaSWTq+0QGfA+MJTJgOcZIxFdLXTUyoC0wERhe9W+katLiaiBKJq2zyZkkLv298aE9aYlrJi2AA1/CqhkUrphO4uUr9o7GoopWcvZw8+CulXex8uTKCieOCwHGWnW9W/bmtRtfY/Fdi8slLQ4vhbXPQ+p5QBv/Xfu8sb0iXX8HG/8EYeXWv/s7sIXIVJvO4yIytew3un5AJ+AUkQFxgC+RAaesOK9Fkrjqidaa9WfWF9//qMieM1e5e85OHkueTNpjW6HTHfUSX4N03xcw/HXSj2/hkblb2X062d4RlTOr/yy83Ut333q7ezOt1zTa+LfhjZ/fsHhjXYiSpoVN45Eej1geDLT5DWOwRUn52cb2ivR7BIZFwHU9y+6p0Twu832rWCCEyIDqz+OKTI0iMrU1kakhRKaGAFlEpkp1+IYs35TPkxuf5NXtr3I0+SjpeZa7l7TWfLj5JIG+Xsx/JpwmrVy0pVXEzR2GR3DtsR3g14KHP93NiUuWf3f2UtH9h5n9ZvLVmK9YHL6Ydo3b2TtM0UCk5KRU/0Wp8VZvz8wrYMwHPzLmv6cZs7sn569m8efVMSUP+SdGIrJqHheRqcXzuCbm/uX0MVP7WcAyIgOK53GFRETFheR8fXB54VD/bO15z4N5fzpU2SlDIqJCCnQFw3WtJPO46sm7+96lnX877u18L+5u7qV35ucYQ8OBa5l5uClFgK/lkkWuKi0nn9UHEnhkUAdZQFI4nAJTAV8f+5o5B+fwz6H/ZFj7YVW/qMh7vczdhGUEtIcXSyUlevzle46+MbqiM9XqH05IRFQcMCBudviViraHRET9DWgbNzv8yUrOMxx4OW52eI3niMngjHry0g0vld+YlwXrXzG+OT3yLbi5E+hneQi2q2vi7cmjN4f8tqEw3xgx1bav3WKqjde2v0ZoQCiTe0yWARwuYN7hecw9NJdbg26lY9OOVb/g1A9wchOMeQtG/MW4p1Wyu9DTx9huhaJkFhIRNQFjZN8dQGuM7r2hQCHGyMGiLp4X4maH7wyJiGoOfAMEAbuwLvHtAp4Ho2UFLASKRhs+Gzc7/CeMqvDdQyKiDmIM8PjQvG040AiYEzc7fF5lF5Guwjp2IcPK+xkFucY6VQcWGcNVHazla3e75sAnt8OP74DJsaq85xXmkW/KZ87BOYxbNY7M/EpGiAmnMKnbJN6/7X3mjJhD+8btKz7QVAgrn4av7oVf/wfZ16D3/TD2Q6OFhTL+O/ZDY3sZOfmFRlfhBz8y/cvSPVNxs8NXYgy4mAl8Avw1bnb4RYx5Xe/FzQ6/EbgX+NT8kr8CO+Jmh/cEVvJbYqvMaKBoefLLwJ1xs8P7YwyR/9C8PQL4MW52eN+42eHvAdOAVPP1bwSeDImICq3sItLiqiPXcq7x4YEPWXlyJQvHLKyyTNDxK7mc4lZGT4rEo0u5IauiKgMehwuHYPMbHE5vTO/fTbd3RFbzcvfi3eHvcuDyAfZd2oefp1/VLxIOLdA7kBHBI6o+0M0dPH1h6Ksw9GXwMJc/632/xURVlrenO+tnlVvKpKTngBjg57jZ4d+Yt90B9AiJKC7a2yQkIsofozV2D0Dc7PCokIioa5Wcd0tIRFQzIAP4s3mbJ/CfkIiovhitunIVf81GAr1DIqKKhkAGAJ2BMxVdTBJXHZm9ZzYb4jYwqfskQgJCKj12y/HLPPv1fvy976B381us+hojyvAOgPs+Z37KAN7c3oYXvE7y3O2daryysj30a9WPfq2sGWksHMXxq8dRKLo261rzk4S/U66c26oDCby9IZbElGzaNvXhlVFdubtfUE3O3g5jUMV1IRFRbnGzw00YPW+D4maHl5pJXyKRWeM2jFGIi4C/AS9hrL91CaM4rxvG0HpLFPBc3OzwDdZeTLoK68jz/Z9n+djlvHrjqzT2alzpsYfjUwlp4cfqmUMIbi73N2pMKSY/9jQT+rdn7rZfib+WXfVrHMSaX9dwJbthzl0T5WXkZfDWnrd44LsHeH//+9a9qKLbAxaS1uvfRpOQko0GElKyef3baFYdSLD8+gqERER5AJ8DD2EsKVJ0430jRkus6LiiG8fbMcozERIRNYYqagzGzQ4vAF4AJptbXwHABXNyfBSjlBRAOlDyQ3IDMCMkIsrTfK0uIRFRlXZDSOKqI0H+QXQKrGBawqElcObH4qfPj+jEihm30DrAecs31RdvT3femdiHqOfLfAlw4Em/V7Kv8Lef/kb4t+HMOzRPVmp2ANdyrrHi5AomdpnI7FutWJE+KRb+Gw4J+6s89O0NsWTnl/57zs4v5O0NsdUN8w8Y95Z2YCStJ0IiorpjDKYYEBIRdTgkIuoo8LT5+L8BQ0Mioo5gdBlWuYZS3OzwCxgDOmYCHwFTQiKiDgHd+G2C82GgMCQi6lBIRNSLGPfUjgL7QyKiYoB5VNEbKMPhqyG/MJ9FxxZxe/DtBDexooMvL8tYtuPAQug5ASb+1+YxCiAtEf57F9z5N+g+1t7R1MjZtLO8v+998kx5zBkxx97hCCskZyfT3Kd51QdGL4dVM4x7WRPmQtdyqxSXEhoRZWFRE6N/7czsahVydpx+9CrYtMWllBqtlIpVSp1SSkVY2B+slNqilDqglDqslPqdLeOpjYOXD3Lv2nt5Z987rDuzzroX5aahT2yAW1+Gez6t+nhRNwrzwbsJLHkEtlrx7bcB6tCkA+/d9h7vDX/P3qEIK1mVtACCboCe98Cze6tMWgBtm/pUa7srsFniUkq5Y6yaOQboATyklOpR5rA/AUu11v2ABzGalg2Sp5snJm3iP7f/h6f7PF31C4D91xpxn/sHnO/3e3CXcTD1JrADTN1IbOhkPosPIr/QcbvaKlpapUYVGEStbTu/jf/7+f+oVU9Vs1C4Zx74t7Lq8FdGdcXHs3TRAh9Pd14ZVYsBIA7Oli2ugcAprfVprXUeRv2q8WWO0UAT888BQKIN46mVni16snr8aqtnvH8fc4EH5/9MUoEPeQ78wemwPLxY03omf49pxqOf7SYlK8/eEdWZ8+nnuXP5nbyx6w0ZwFFPCk2FvLjlRZ7937PsvbiXtLw0615YUL2/O601H209xdJffquUcXe/IN68J4ygpj4oIKipD2/eE1bTUYVOwZbNgCCgZJ2SeOCmMsdEAhuVUs9hzK62WFFWKTUdmA4QHGzbweNaawpMBXi6ly+5VK5UU0lXzxhV3M3HNPdvxI0hgfz7of40k2oYdvHKqG50auXPgp/O4uXhPOOQGns25p7O97A0dinx6fHMHznf3iE5PXc3d9r6t+WF/i8wucdki58PpWRdhe9fNyYQT1pi1WrlGbkFvLz0EN8fuci9/dtx/4DfJirf3S/IpRNVWTYbnKGUug8YrbV+wvz8UeAmrfWzJY55yRzDO0qpm4HPgF5aVzyMypaDM86mneWtPW/RwqcFbwyupPJyWYeWwHcvwrBXYcgLxZu11lJXrwEwmXTp+V0/z4UOt0Cb3vYLqg7EpcaRb8qnc2Bne4ciSspOgf/cCNlXYfALcNsfir/QViYrr4D7Pt7FPf2DmDYk1BafHU7zYWTLFlcCULK2STt+K6dfZBpGiRC01ruUUt5AC4xSIfXqXNo5JqyegJe7FzP7zrT+hcfWwsrp0GFwuZntkrQahlJJKzcdfvoQNv0FRv0DbnzCqm/DDVFVE91FzdR6AVCfpsYX2NBhxqKOVvL18mD1s4PxdHee3gFbseVvaC/QWSkVqpTywhh8sabMMeeAEQBKqe4Yi5ol2TCmCgU3CealG17iuwnf8WiPR61/YZcxZI18ByavgSZtqz5e2FejxvDUdgpDhlJ4LMopa0QmZyfz8raXOZ1y2t6hOJRCUyGLjy/mzuV3ciip0pU5qnbzzGolrSKStKxjs9+S1roAoxLxBoxZ2ku11keUUm8opcaZD/s98KRS6hDGpLXHtB0nlj3S45Hyq49WYcfpFAZtbM/3x+ySb0VN+LXgRffXmXhtBvGpFVWhcVyx12LZmbCTe9bcw6fRMg3DWu/vf59/7P4H3Zt3p2mjpta9KLNmi5umZOWRlVdQo9cKF5mAHHU6ig/2f8DFzIu08m3F6JDRvHzjy7WOZdPRSzz91T46tfTns8cG0C5Qyjc5ii2xl3n+mwN4ubux/oVbadXYuaqYXM25ytxDcxkSNISh7YbaOxyHkJCRwKHLhxgTOqbqbv6CPNj5gbE6weTVEFx23FnFjiSm8tTCfQwMbca799frsjyO2SdugdMnrqjTUUT+FElOYelv1n8e9Gfu71p1teViSSfg+9dgwm/zL1Ky8vjXxlheG92Nxt6y8KOj+TUpg+9jLjLzthKlutIuGDfSrZxjI1zUuldhzzxjIvGYt6z+ezmXnMXI97fR1MeLjx/pT7/gSsv/1TVJXPZS3cQ1cvlILmSWXyOrjV8bNt630bqTHFkFq54xVil+aAm0v9Hq6wsHs3ACXIwxJohef7u9o7GJzPxMjiYf5cbWrvl3fOraKbw9vGnXuF3NT5JyHi5GQ7fqF/v5fMcZxvZpS8vGjWp+/ZpxmsTl9HcCL2ZerNZ2ixo1hqD+8PQOSVrObuQ/wLcZLJpofDg5oW+Of8PUDVN5bvNznEmtcMkjp5OVn8V7+95j4tqJ1ldwr0jT9jVKWgBTh4TaI2k5FaevQ9Tar7XFFldrv9bWn6TTCE7630gHX39kKrGTu64HJ8atxSdxJ+2bVrJSrQN7pPsjAHwa/SnRV6IJDah0sVmnEZcWx4IjCxh3/TheuDn96U8AACAASURBVOGFql8AxkTighwZMdzAOH2La1b/WXi7l77x7u3uzaz+s6w+x/cxFxk35yfe++FEXYcnGhitNa9/d4pRUT5sOFKNVrkD8fbw5omwJ1h3zzru6niXvcOpNz2a9+C7Cd/xxuA3aObdrPKDtYaYFTBnIKx5vtrX0lqzaPdZjl+0sjSUqBanT1zhHcOJvCWSNn5tUCja+LUh8pZIwjtaWA4gLwtivy+1ad/Zazz91T66tm7M1MGu8c3UlSmlmDOpP51b+fPy0kPlaxyanKfuZDPvZrip8h8BBaYCp10DzOr7WsmnYMUTENAO7vhrta6Rk1/Iq8sP88eVMSzcdbYGUYqqOP3gDKslnYBlU+DKCXhuv1FhHOOb09d7znFv/3Z4e1ZdtkU4h5z8QmIvptOnfYn5PCc3weY34L4voEUFi4Y6gYVHF/Ld6e94ecDLDjmAY1fiLg5ePsiMvjNqd6K4HdB+ULVXdvg1KYPx/9nJ1MEhzLqjC+5uDWZMRIMJpLacvsVltY1/goxLRkFMc9IC4xv4wzd1kKTlYrw93UsnLQAUpMbDvKHw6xa7xFUfWvm2Ijk7makbprL57GZ7h2O1/MJ8Xt32KtM3Tee709+RlZ9VuxOGDKnRckTXt/Rn6yvDeWlk14aUtJyKtLiKpF8EbZKbsKJyqQmw8Y/wu3+BX/WqrDiSnIIcVpxcwf1d7q+6EnoD8ur2VwltEsrUsKk0crdi5F5hPvz6P+gyyvbB2Z/TZFFJXCXsPp1M6wBvOjT3s8n5heNbtPssbkrx0MASy+scXmp0IabGG/dERvylXMFlUT+qtSJDwn5Y8xxcioEZP8F1Pat9vZz8Qhp5uDlKQW2HCNIartFVeHgpvNcLIpsa/z34dblDlu+L55HPdvOPqGN2CFA4Aq01/zt2mde/jeavq2OMlZUPL4W1z0PqeUAb/137vLHdSW0+t5mo01F2HcCRX5hvcXu1EsjO9yErGR78ukZJ63RSBmP/vYOv95yr9mtF7Th/4rL0wbJ6JhxaXHxIYko2f1gZzcDQZrw9sY/9YhUNmlKK+ZMH8OStoew/l0KhSRstrfzs0gfmZxvbndSqk6uI+DGCh6Me5lxa/X5om7SJlSdXMvrb0bWfPB3+LszcDd0sjDCuwuH4FMb/ZydXMnIJkR6aeuf0E5AtfrBoE/zv79DnQQDaNvVh8fRBhAUFyLIColLuboo/hvcgJ7/QGLCTGm/5wIq2O4EPbv+Atb+u5evjX9Pcp3m9Xnv2ntl8c/wb+rXqV/uT1eIeZedWjRnZszUv3tlZimvbgfPf44psClh6jwoiU+oqLOGist7qhm92+cosWT5t8H3teOmNV8/AlZMQPAi8m9RThLZjjxW+j189zrHkY4zvNN7iHLRytIajq+C6XtDC5VeKlntcDiOgggmHFW0Xohr+mf8AWbp0IbAs7cU/8x8of/CRb+HrifBWCGx9q34CtKGKkta5tHPkFuba5JrdmnVjQucJ1iWttERYPAmWPQY/f2STeIR9OH/iGvEXCsqUfMpTjYyRX0LU0oKMgUTkP0G8qQUmrYg3tSAi/wkWZAwsf/BNM4yVsm/9PbS7wfIJr52FHMctE1RoKuT5/z3P+FXjWX9mPTXt0TmXdo7k7Jot0lgsK9mYRHzn32HM2zU+zcYjF8nIlUUfGxKnT1yrCgeX+2B5NW8aK/NvsXdowgm0berDGtMQhuR9SMfcRQzJ+5A1piGWq397+ULHYXD7H6HTHZZPuP5VeKsDzL8N4m0z7cOW3N3cibgpAn9Pf/62629cy71WrdfnFuby0cGPmLB6Av8+8O/aBdM6DF48AoOfr9FE4vxCE3//7ijTF+7jk+2naxeLqFNOPzjj7Q2xJOTdwnJKJ6q9m04w4QbpLhS188qorrz+bTTZ+YXF2xp5uPGH33Wv2QkHz4LWvY2Wgk8FiwwW5IJHw10WY1CbQSy5awm/pv5adTHbMg5cPsDHhz5mTOgYZvadWftganEvccfJK3y24wyP3RJSerFRYXdOPzgjNCKqoqEZnJld/WGwQpS16kACb2+IJTElm7ZNfXhlVFfu7hdU7rhzyVn8mpTBsC4tcatpKSCTCd7patyjDRkCw183WnIOJup0FB/s/4CLmRdp7deaWf1nFRe+jr0aS9dmXa0/WcJ+o47k8NfqPM6D51PoW670l8NymsEZTt/iatvUh4SUbIvbhagLd/cLspioylq0+yzztp+mUyt//nJXD4Z2aVn9ixXmwg2PGS2y6OVwp2PNF9NaM3HtRH5N/ZUCk3Hf6ELmBSJ/igSM1RysTlomE/zwF9g1B/yvg4FPGouA1iEnSlpOxenvcb0yqis+ZQrk+ni688qoanyjE6IOvDyqK+8/0Bcvdzc83Gv45dfTx7hHNnU9vBANlkb2Jf9q3CPb+Gc4vbVWMde1jPwM4tLiipNWkZzCHD7Y/0H1TubmBmkXoP9keObnWiUtR+t5cnVO3+Iq+iZsTVeOELbk6e7G3f2CGN+3jgo5VzTgIDfNSHC75xrL9HQcXjfXqwONvRqTV5hncd/FzBos3HnPfHCr3coNiSnZvLjkIH++qwe9ggJqdS5RP5w+cYH1XTlC1IeK5j9dTsvhr2uOMHVIKAM6BNZ8cm/bfvD4OqNiTNZVy8ec3ARntkHIreYJ0fX3gd3arzUXMstP2m7t17r6J6tl0tp39irTv9xHboGJpAzbzD0Tdc/puwqFcBQnLmWw63QyE+fu4o+rYmp/Qk8fCKjgC9vFw7B7Hnx9P+z5pPbXqoZZ/WfhXWZupbe7N7P6z7L8grREWDoZLh2p81ia+nrRrpkvq2YO5raurer8/MI2nH5UoRCOJCuvgBX7E+jQzLdmgzeqIz8b4vdC0w6lFk8tdnSNMezeBi2yykYVlhK7Hr6dDoV5MH4OhN1Xp3GAfUpX2YnTvElJXEI4kOy8Qny86mk17o8HG2tVKTd44gcIqqDahy0lxcKGP8CYf0Lz6+v/+s7FaRKXS9zjEsIZpOXkM+yfW7itayueuLUjPdrauFDvEz8Y1TvidkCrHpaPOfMjtOltu3tkLbvCIyvq5FRHElPp0aaJq7SunJrc4xLCQRQUasb3DeL7Ixd5fvEB2w/h9vSB0FvhtteNn8vKugoLxhpFgz8ZAabC8sdUh43ej8mk+XDzSe769w5WHUywyTVE/ZIWlxAOopmfF5HjevLiHV2IT8myf8vByx+mrDFaZJlXLI/wK8g17qX5lJnIe3ipsVZeajw0CTJWIG7UGO77rM7DXPjzWd7ddIJ7+gUxumebOj+/qH+SuIRwMAG+ngT4Wu6a+yXuKte39CfQz8vi/jrl4QWhQ41HRc5sN0Yutu4NfR6CQU//tip50QKvafHGo8MQKCyoUUHcyjxwY3ua+noyrk9b+yd7USckcQnhJAoKTcxYtJ+MnAImDmjH70d2JcDH075BNesIQ181WmXp5rlbllYlB0g5W+dJC8Db053xfWUepzORxCWEk/Bwd2PhtIF8+uMZtsYm8afwCgZU1Kfm1xv3yEpKjbd8bEXbhShDBmcI4US6tW7Cvyb24YeXhuHl0UD/edtoVfLkjFwiVhwmLSe/VucRDV8D/csWQtRGRUlr7aFEFvwUR1aeHVf0HfGX8qMUPX1qtSr54fgUxv57B98eSODw+dRaBigaOpsmLqXUaKVUrFLqlFIqooJj7ldKHVVKHVFKfW3LeIRwdT8cu8Rf1xzh5jf/x76zFdQxtLXe98PYDyGgPaCM/4790NheQ3HJxijLFU/fwpDOLeouVtEg2axyhlLKHTgB3AnEA3uBh7TWR0sc0xlYCtyutb6mlGqltb5c2XmlcoYQtbPv7FUW7jrLPyaE4dfIeW5z12tVEcfkNEMqbflXOxA4pbU+DaCUWgyMB46WOOZJYI7W+hpAVUlLCFF7N3Roxg0dLK9dZTJplKq4gn1DJknLdVTZVaiUGquUqkmXYhBwvsTzePO2kroAXZRSO5VSPyulRlcQw3Sl1C9KqV+SkpJqEIoQwhrfRV9gzAc/smJfPHkFJnuHY9HVTMvreQnXYU1CegA4qZT6p1KqWx1f3wPoDAwHHgI+UUqVWytbaz1faz1Aaz2gZUsbV8wWwoX5eblj0prfLzvEpztO2zucUrTWfLHzDLe+9T9iEmQAhiursqtQa/2IUqoJRmL5r1JKA18A32it0yt5aQLQvsTzduZtJcUDu7XW+cAZpdQJjES2txrvQQhRR0Z0v47bu7Vi24kkwhrYasDv/XCSDzef5I7u1xHc3Nfe4Qg7sqoLUGudBiwHFgNtgAnAfqXUc5W8bC/QWSkVqpTyAh4E1pQ5ZhVGawulVAuMrsOG9TVPCBejlGJ411Y0929Ubp/W2m6tnXv6BfHq6K7Mf/QGmnjbuSKIsCtr7nGNU0qtBLYCnsBArfUYoA/w+4pep7UuAJ4FNgDHgKVa6yNKqTeUUuPMh20AkpVSR4EtwCta6+TavCEhhO38ePIKd/17BxPn/sSW4/U7liqkhR/PDO+Em5vjDRwRdavK4fBKqQXAZ1rr7Rb2jdBab7ZVcJbIcHgh7Ccjt4Cle8/z+c4z3NH9OiLH9bR3SMJ6TpPxrUlcocAFrXWO+bkPcJ3WOs724ZUniUsI+ysoNJFTYMLfBvPA0nPyWfZLPI8PDnHIYfkNmNP8Mq25x7UMKDkuttC8TQjhojzc3SpMWh9v/ZWTlyobt1WxU5fTGT9nJ/9Yd4wjiWm1CVE4MWsSl4fWunjihPnneljsRwjhaC6kZvPB5hPc+d52nvzyF0ym6lXmWbT7HGnZ+Sx64iZ6NbBRjaLhsKadn6SUGqe1XgOglBoPXLFtWEIIR9QmwIefIkbw1c9nScnKr/ZAiogx3Xh62PVc18TbRhEKZ2DNPa7rgUVAW4w+0vPAZK31KduHV57c4xLC8a06kMDbG2JJTMmmbVMfXhnVlbv7yWKPNuY097ismYD8KzBIKeVvfp5h86iEEE7rvo93cuB8KoXmbsSElGxe/zYaQJKXsIpVQ4KUUuFAT8C7aJSP1voNG8YlhHBChSbNkcT04qRVJDu/kLc3xEriElaxZgLyXIx6hc9hNDUnAh1sHJcQwgm5uyly8gst7ktMya7naISjsmZU4S1a68nANa3134CbMUozCSFEtbVt6lOt7UKUZU3iyjH/N0sp1RbIx6hXKIQQ1fbKqK74eJZeO8vH051XRnW1U0TC0Vhzj2uteamRt4H9gAY+sWlUQginVXQfS0YVipqqdDi8eQHJQVrrn8zPGwHeWmu7LYYjw+GFEKJGnGY4fKVdhVprEzCnxPNceyYtIYQQwpp7XJuVUvcqqXYphBCiAbAmcT2FUVQ3VymVppRKV0pJ9UshhBB2YU3ljMb1EYgQQghhjSoTl1JqqKXtlhaWFEIIIWzNmuHwr5T42RsYCOwDbrdJREIIIUQlrOkqHFvyuVKqPfC+zSISQgghKmHN4Iyy4oHudR2IEEIIYQ1r7nH9G6NaBhiJri9GBQ0hhBCi3llzj6tkmYoC4But9U4bxSOEEEJUyprEtRzI0VoXAiil3JVSvlrrLNuGJoQQQpRnVeUMoOR6Az7AD7YJRwghhKicNYnLW2udUfTE/LOv7UISQgghKmZN4spUSvUveqKUugGQpUqFEELYhTX3uF4AlimlEjHK4rcGHrBpVEIIIUQFrJmAvFcp1Q0oWp40Vmudb9uwhBBCCMuq7CpUSs0E/LTWMVrrGMBfKfWM7UMTQgghyrPmHteTWuuUoida62vAk7YLSQghhKiYNYnLveQikkopd8DLdiEJIYQQFbNmcMb3wBKl1Dzz86eA9bYLSQghhKiYNYnrNWA68LT5+WGMkYVCCCFEvauyq1BrbQJ2A3EYa3HdDhyzbVhCCCGEZRUmLqVUF6XUX5VSx4F/A+cAtNa3aa3/Y83JlVKjlVKxSqlTSqmISo67VymllVIDqvsGhBBCuJbKugqPAz8Cd2mtTwEopV609sTmQRxzgDsx1vDaq5Rao7U+Wua4xsAsjFadEEIIUanKugrvAS4AW5RSnyilRmBUzrDWQOCU1vq01joPWAyMt3Dc34G3gJxqnFsIIYSLqjBxaa1Xaa0fBLoBWzBKP7VSSn2slBppxbmDgPMlnsebtxUz10Bsr7WOquxESqnpSqlflFK/JCUlWXFpIYQQzsqawRmZWuuvtdZjgXbAAYyRhrWilHID3gV+b0UM87XWA7TWA1q2bFnbSwshhHBg1kxALqa1vmZOIiOsODwBaF/ieTvztiKNgV7AVqVUHDAIWCMDNIQQQlSmWomrmvYCnZVSoUopL+BBYE3RTq11qta6hdY6RGsdAvwMjNNa/2LDmIQQQjg4myUurXUB8CywAWPe11Kt9RGl1BtKqXG2uq4QQgjnprTW9o6hWgYMGKB/+UUaZUIIUU3VGRXeoNmyq1AIIYSoc5K4hBBCOBRJXEIIIRyKJC4hhBAORRKXEEIIhyKJSwghhEORxCWEEMKhSOISQgjhUCRxCVGHYmNjcbRJ/UI4msoWkhRCVNORI0fYsGED3bt3p1+/frRo0cLeIQnhdKTkkxB1LDc3l+joaA4ePIhSir59+9KrVy8aNWpk79CEa5OST0IIyxo1akSPHj3o1asX6enpHD9+nPnz57N79257hyaEU5CuQiHq0PHjxzl06BBXr16ld+/ePPnkk/j5+ZGfn8+cOXO46aab7B2iEA7PZRNXWloaqampmEym4m0dOnSwY0TCGRw/fpxBgwaV+1vy9PRk3DhZzUeIuuCSiWvTpk0cOXKEli1b4ub2W2+pJC5RW35+fuX+jjZt2sSdd95Jx44d7RSVEM7FJRNXbGwszz77LB4eLvn2hQ2dPn263LZTp05x55132iEaIZyTS35yBwYGluoiFKK29u7dyy+//MLVq1f5+OOPi7fn5eXRvn17O0YmhPNxycTl6enJ3LlzCQ0NLdXqGjNmjB2jEo4sLCyMzp07s3nzZkaMGFG8vVGjRvj4+NgxMiGcj0smri5dutClSxd7hyGciFKKpk2b8rvf/a7cvuzsbEleQtQhl0xcffv2pbCwkOTkZACaN2+Ou7u7naMSjmzFihVMmjSJ+fPnW9w/a9aseo6o4du1a1el+2+++eZ6ikQ4GpdMXHFxcaxatYqmTZuitSYtLY27775bRhWKGps0aRIgCao6cnNzAUhOTiYxMbG4F+TEiRMEBQXZMzTRwLlk4tq4cSOPPPJIcR255ORkVqxYwfTp0+0cmXBUFy5cqHR/mzZt6ikSxzF8+HAAvvjiC6ZPn15cEmv48OF8/fXXdoxMNHQumbgKCwtLFT9t3rw5hYWFdoxIOLqNGzdWun/KlCn1FInjyczMLNVV7+7uTmZmph0jEg2dSyautm3bsmbNGnr37g3A4cOHadu2rZ2jEo5MElPN9e7dm08//ZRu3boBRvWRPn362Dkq0ZC5ZHX4goIC9u7dy7lz5wAIDg7mxhtvlAnJok5cvnyZpKQkCgoKirfJB3HlLly4wNmzZwGjgo10rdqE01SHd8nEJYStbN26lbNnz5KUlETnzp05efIkwcHB3H///fYOrcHJzs6udL9MIahzTpO4XKqJsWzZMiZOnFiqskFJM2bMqOeIhLM5duwYTz/9NPPmzWP8+PFkZGSwcuVKe4fVIJWcOpCamoq3tzcAOTk5BAQEyAhNUSGXSlyjR48G4KGHHrJzJMJZeXh4oJTCzc2N3Nxc/Pz8SE1NtXdYDVJRYlqzZg3du3enc+fOAJw8eZLjx4/bMzTRwLnUQpKNGzcGjLpyTZs2LfXYu3evnaMTzqBt27bk5OTQv39/5s+fz/z586VWYRUSEhKKkxZA586diY+Pt2NEoqFzqRZXEangLWwlPDwcgAEDBtCpUydyc3O57rrr7BxVw9a4cWO2b99eapRv0ZdMISxxqcEZRRW8r127RmBgYPH2ogre99xzT12FKVzUsWPHCA0NLXW/Ji4urniotygvOzubrVu3Fo/y7dChA8OGDZPBGXVPBmc4IqngLWxt27ZtdO/evfi5t7c327Ztk8RVCR8fn1IrM6SmprJ//34GDx5sx6hEQ+ZSicvb2xtvb2/uvfdewJixX1BQQF5eHnl5eQQEBNg5QuHoLPVgyNpvVcvMzOTo0aPExMSQnp4uiV5UyqUSV5HY2Fg2btxIeno6fn5+pKSk0LJlS5555hl7hyYcXNu2bdmwYQM33ngjYHRPy2Ray3Jzczl27BgxMTEkJyfTrVs3rl27xksvvWTv0BzCpUuXSElJKfXFqGRr35nZNHEppUYDHwDuwKda69ll9r8EPAEUAEnAVK31WVvGBLBlyxamTZvGwoULeeqppzhz5gyHDx+29WWFCxgzZgzbt29n+fLlAHTs2NHiGl0C/vWvfxEUFMRtt91GcHAwSikZBm+l1atXc+nSJVq1aoVSv926ksRVS0opd2AOcCcQD+xVSq3RWh8tcdgBYIDWOkspNQP4J/CArWIq4ubmhq+vL1prtNaEhoayYcMGW19WuAAvLy/uuOMOcnNzUUrh5eVl75AarBEjRhATE8O6devo1asXPXv2tHdIDiM+Pp6ZM2faOwy7sWWLayBwSmt9GkAptRgYDxQnLq31lhLH/ww8YsN4inl7e5OXl0dwcDDffvstvr6+eHp61selhZO7dOkSq1atKi5n5Ovry913302rVq3sHFnDM2jQIAYNGsS1a9eIiYlhyZIlpKens2PHDrp3707z5s3tHWKD1a5dO5KSkmjZsqW9Q7ELmw2HV0rdB4zWWj9hfv4ocJPW+tkKjv8PcFFr/X8W9k0HpgMEBwffUFSMs6by8vLw9PREa83hw4fJzc0lLCwMX1/fWp1XiM8++4zbb7+d0NBQwFi0dPPmzUybNs3OkTmGy5cvEx0dzZEjR3j++eftHU6DFRcXx+LFi/H39y+1JEwVZetkOHxdUko9AgwAhlnar7WeD8wHYx5Xba+3a9cu+vbtS0BAAH379gVg37593HDDDbU9tXBx+fn5xUkLICQkhPz8fDtG5FhatWrFiBEjSk1XEeWtWbOGCRMmlLvH5SpsWfIpAShZ66adeVspSqk7gD8C47TWuTaMp9iePXtYtGgRZ86cKd4mFectM5lM7Nq1y95hOIzAwEC2bdtGSkoKKSkpbN++vdRkdyHqgp+fH127diUwMLBU6TpXYcvEtRforJQKVUp5AQ8Ca0oeoJTqB8zDSFqXbRhLKU2aNOHhhx9m8+bN7Ny5s74u65Dc3NyIiYmxdxgOY9y4cWRlZbFkyRKWLl1KVlYW48ePt3dYwsm0bt2aFStWEB0dzbFjx4ofrsJmXYVa6wKl1LPABozh8J9rrY8opd4AftFarwHeBvyBZebm7jmt9ThbxVRSQEAAjz32GFFRUSxbtky6cyrRvn171q1bR8+ePUuNkpP5SeWVrQIBsHz5cu677z47RdSwmUwmVq1aJeXWqqmgoAAPD49ydVdlOHwd0FqvA9aV2faXEj/fYcvrV6ToA9fDw4Px48ezZ88eEhMT7RGKQ7h06RJgLJJYkixXb53z58/bO4QGy83NjZSUFAoLC0sNMhCVc/VWfIMYnFHfxo0r3agbOHAgAwcOtFM0DZ8kKGFLgYGBfP7553Tp0qVUi/7mm2+2Y1QNW1paGuvXry9VmHj06NE0adLEzpHVD5dKXLICcs1kZGSwefNmMjIyePjhh0lKSuL8+fP079/f3qE1GBcuXLC4XWsttQqrEBgYSGBgIFprcnPrZXyWw1u9ejW9evVi4sSJgLEUzOrVq3n00UftHFn9cKnEJSsg18zq1avp27cvP/74IwDNmzdn+fLlkrhK2LhxY4X7WrRoUY+ROJ7hw4cDxvxKQKqNWCEzM5N+/foVP+/bty8///yzHSOqXy6VuIoWp3OlYaN1ISsri549e7Jjxw7AuC/hinNHKiPdqTV3+fJlVq5cKdVGqsHX15fDhw/Tq1cvAGJiYlyqgIJLJa4333yz0v2vv/56PUXiWDw9PcnKyip+Hh8fX7xQohC1tXbtWkaOHFmq2sjatWul2kglxo0bx/r164trrLZv396lBmy4VOKSxFQzo0aNYvHixVy7do3PP/+czMxM7r//fnuHJZyEVBupvqZNm7r0LQ+XSlxlFS0kWUQWkrTM29ubxx57jCtXrgDGPa6LFy/aOSrhLIqqjfTp0wcwBhpItRHL1q1bV2k3fdk5hM7KJROXLCRZPcuWLePBBx8svudw9uxZ1q1bJ6MwK5CWlkZqamqp0YQdOnSwY0QN27hx49i6dStLlixBKUVwcLBLdXtVR9u2bQFjbmBSUlLxUjBHjx51qUrxLpm4ZCHJ6gkPD2fJkiU89NBDXLhwgc2bNzNp0iR7h9Ugbdq0iSNHjtCyZUvc3H6rqCaJq2KnT58u11I4cuSIrM9lQVFR8F9++YWpU6cW/40NGDCAL774wp6h1SuXTFyykGT1BAUFMXr0aBYuXIiHhwePPvoofn5+9g6rQYqNjeXZZ5/Fw8Ml/2nVyI4dO8olKUvbxG9ycnLIzc3Fx8cHMKYS5OTk2Dmq+uOS/7pkIUnrfPPNN6We5+fn4+3tzZo1Rq1kV745XJHAwECZcGylkydPcvLkSdLT01m/fn3x9tzc3FKtVVHe4MGDmTdvHiEhIYDRfT9smMVVoZySzRaStJUBAwbo2i5BkpeXV/yNWBaSrFhcXFyl+4v+0Yjfbpqnp6dz8eJFQkNDS7W6XOWmeXVcvHiRixcvsnXr1uJJyACNGjUiJCSkuDUhLMvIyCA+Ph4wVkT29/ev6iVOM/nSJROXsJ7JZGLhwoUywbYKBw8erHR/0b0JUV5ubi6enp7FrSyTyURhYaH0glShBoOAnCZxuVRX4eeff87UqVMrnIgs87zKK6qSkZOTI5OOKyGJqeYWLlzI5MmTi0s9FRQUDI7jcQAACmhJREFUsHDhQpmAXImiQUBlV0B2lUFALpW4pk6dCkiCqi4vLy8+/vhjOnbsWKqOnHR/lWepgLO3tzdt2rRh6NCh0h1tQUFBQam/Ky8vL5mAXAVXHwTkku965cqVTJgwocptwtCtWze6detm7zAcQqdOnVBKERYWBhg15PLz8/H392f16tUyoMUCLy8vLly4ULxOXmJionQTVsHVBwG5ZOK6fPlyqecmk0kWkqyEdINZ7/Tp0zz11FPFz6+77jrmzZvHU089VeFyOq5u1KhRLFu2jMaNG6O1JiMjQ1aMroKnpydz58512UFALpW4fvzxR3bs2EF+fn6p+1zu7u6yREclkpOT2bx5M0lJSaVKZM2aNcuOUTVMWmsSEhIICgoCICEhgaIBUDLE27KgoCBmzpxJcnIyYJQUk9WQK9elSxe6dOli7zDsxiVHFf7www/ccccddRSR8/v8888ZPnw4GzZs4KGHHuLgwYNorbntttvsHVqDk5CQwJo1a8jLy0NrTaNGjRg3bhwtW7bk5MmTMqnWgvz8fHbt2kVKSgrjxo0jOTmZ5ORkl/5gthEZVeiIrly5QosWLejZs6fFFWuL+thFaQUFBXTs2BEwqlIPHz6c+fPnS+KyICgoiBkzZhRXMSg5ElOSlmWrV6+mTZs2xXOSmjRpwrJlyyRxVcLVe0FcKnHt2rWLsWPHVrharcxVsszd3R2tNc2aNWPPnj00bty4eLVaYTh8+DC9e/dm165dFvfffPPN9RyR47h69Sr33XcfMTExADIwwwqrV68u7gWZMmVKcS+Iq3CpxDV27FhAElR1jR49mvz8fMaMGcOWLVs4c+YMd999t73DalCKEnlubq6dI3E87u7upYa/X716Ve5xVcHVe0FcKnGVdP78eVJSUkoNKS1aD0iUVjTQwMvLS5abqMCAAQMASpUuEtYZPnw4ixYtIi0tjW+//ZZz587JF6MquHoviEsOzli5ciVXr16ldevWxbPOlVIuM5TUWmWL7JYlc5J+U7JIrCXyt1VeVFQUYWFhBAcHk5WVVarunkzUrlxCQgItW7YkJyeHLVu2kJOTw+DBg2nXrl1lL5PBGY4sMTGRZ555ptKVRAXEx8fTpEkTevXqRbt27VyqD726Sg7sKVs0VljWvHlzNm3aRHp6Oj179qRXr14yQMpKZXtBTCYTMTExVSUup+GSiatVq1ZkZGTQuHFje4fSoP3+97/n9OnTxMTEEBMTQ+fOnenVq1fxSsjiNyUnae/evVsmbVth0KBBDBo0iJSUFGJiYlizZg35+fn06tWLsLAwmjdvbu8QG5zc3Fz27NlDenr6/2/vfkPruus4jr8/TaftdJ0wpZVkkNXF0i6ttdpssAeRiVq1zIEbTOY/KJ0rKrMIog8MtM9kVH2yJ9ONBhXrn60QfGANrrAhpUu7td2Nddz+EZ2kTdVmujK23vbrg/OLS0J6e2+T23NPzucFIef8cnL53h/J+d7zu+d+v6xatYqVK1cyMjLCgQMHWL58OevWrcs7xOuilEuFg4ODnDlzhs7OzmlvAnvp68pqtRqVSoXh4WH6+/vp6+vLO6S2NVkpw5o3NjbG0NAQZ8+eZWBgIO9w2s6ePXtYsmQJXV1dnD59mgsXLgDZDVQrVqy42q8vmCWmUl5xlanh2lzVajWq1SqVSoWJiQn6+vpct9Dm1eXLl6lWq4yOjnLq1Cm6u7v9P3oF58+fZ9u2bQBs2LCBXbt2sX379tIV2y3Xs03cALExe/fuZXx8nJ6eHvr7+71EWMfUEmIzS4qBOxLM5uTJk1QqFarVKp2dnfT29rJ58+ZpleJtuqllwxYtWsSyZctKl7SgZEuFV+rDNcknl+l27NhR9yTi+bK5GBwcZO3ataxevdrdjhu0c+fOaR/Qvnjx4rT9q/xPLpilwlIlLjOzElswicvlqs3MrFCcuMzMrFCcuMzMrFBamrgkbZL0iqQTkr47y8/fKelX6ecHJXW3Mh4zMyu+liUuSR3A48CngTXAFyStmXHYFuB8RNwO/Aj4QaviMTOzhaGVV1x9wImIOBURbwF7gJmlxT8HDKbt3wIflwsImplZHa385Fon8Pcp+68Cd17pmIioSXoNuAX459SDJD0MPJx2X5f0yjXG9N6Zj211eb6a4/lqnuesOXOZr99HxKb5DCYvhfjIdUQ8ATwx18eRdCgiPjoPIZWC56s5nq/mec6a4/nKtHKp8B/ArVP2u9LYrMdIWgzcDPyrhTGZmVnBtTJxjQA9km6T9A7gQWBoxjFDwFfS9v3As1G0Uh5mZnZdtWypML1n9Q1gH9ABPBURo5J2AociYgh4EviZpBPAv8mSWyvNebmxZDxfzfF8Nc9z1hzPFwWsVWhmZuXmyhlmZlYoTlxmZlYopUlcVys/ZW+T9JSkcUmVvGMpAkm3Stov6c+SRiU9mndM7UzSEkkvSDqa5mtH3jEVgaQOSS9J+l3eseStFImrwfJT9rbdwIL4oOJ1UgO+HRFrgLuAr/vvq643gXsi4kPAemCTpLtyjqkIHgWO5x1EOyhF4qKx8lOWRMRzZHd5WgMiYiwiXkzb/yU7uXTmG1X7iszrafeG9OW7xOqQ1AV8Fvhp3rG0g7IkrtnKT/nEYvMudTj4MHAw30jaW1r2OgKMA8MR4fmq78fAd4DLeQfSDsqSuMxaTtK7gaeBb0XEf/KOp51FxKWIWE9WUadPUm/eMbUrSZuB8Yg4nHcs7aIsiauR8lNm10zSDWRJ6xcR8Uze8RRFREwA+/F7qvXcDdwr6a9kb3PcI+nn+YaUr7IkrkbKT5ldk9SK50ngeET8MO942p2k90l6T9peCnwC+Eu+UbWviPheRHRFRDfZuevZiPhizmHlqhSJKyJqwGT5qePAryNiNN+o2pekXwIHgFWSXpW0Je+Y2tzdwJfIXgkfSV+fyTuoNvZ+YL+kY2QvKocjovS3eFvjXPLJzMwKpRRXXGZmtnA4cZmZWaE4cZmZWaE4cZmZWaE4cZmZWaE4cZnNQtKldFt7RdJvJN0oqdsV883y58RlNrs3ImJ9RPQCbwGP5B2QmWWcuMyu7nng9rTdIeknqY/UH1LlByRtlTSSekw9LenGNP5Aumo7Kum5NNYh6bF0/DFJX8vnaZkVkxOXWR2SFpP1cXs5DfUAj0fEHcAE8Pk0/kxEbEw9po4Dk9VGBoBPpfF709gW4LWI2AhsBLZKuq31z8ZsYXDiMpvd0tR24xDwN7JahACnI+JI2j4MdKftXknPS3oZeAi4I43/CdgtaSvQkcY+CXw5Pf5B4BayhGhmDVicdwBmbeqN1Hbj/7Jaurw5ZegSsDRt7wbui4ijkr4KfAwgIh6RdCdZE8DDkj4CCPhmROxr5RMwW6h8xWU2P24CxlJ7k4cmByV9ICIORsQAcI6svc4+YFs6FkkflPSuPII2KyJfcZnNj++TLfudS99vSuOPSeohu8r6I3AUOEa2xPhiaolyDrjvegdsVlSuDm9mZoXipUIzMysUJy4zMysUJy4zMysUJy4zMysUJy4zMysUJy4zMysUJy4zMyuU/wFkoMtK0kPo5QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ny = 5\n",
    "ax=plt.gca()\n",
    "accuracy_df.plot(xticks=[*range(0,5)],\n",
    "        yticks=[i/ny for i in range(0,ny+1)], \n",
    "             title='Per-phase Accuracy',ax=ax, \n",
    "             marker='o', linestyle=(0, (2,4)))\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_xlabel('Phase')\n",
    "ax.get_legend().remove()\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "ax.text( x=4.1, y=accuracy_df['Fixed Rate'][ny-1], s='Fixed Rate', color=cmap(0))\n",
    "ax.text( x=4.1, y=accuracy_df['Markov 4'][ny-1], s='Markov 4', color=cmap(1))\n",
    "ax.text( x=4.1, y=accuracy_df['Markov 8'][ny-1], s='Markov 8', color=cmap(2))\n",
    "\n",
    "ax.text(x=0, y=.05, s='Initialization', rotation=90, color='grey')\n",
    "ax.text(x=1, y=.05, s='Marker', rotation=90, color='grey')\n",
    "ax.text(x=2, y=.05, s='High Locality', rotation=90, color='grey')\n",
    "ax.text(x=3, y=.05, s='Vector Add', rotation=90, color='grey')\n",
    "ax.text(x=4, y=.05, s='Random', rotation=90, color='grey')\n",
    "\n",
    "#plt.savefig('plots/per-phase-accuracy.svg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy Over Time\n",
       "Let's now take a look at how accuracy changes over the course of a simulation. Does it get worse over time? \n",
       "\n",
       "As we're using the small trace, we won't see much here. Please re-run the notebook to get a better large chart. \n",
       "\n",
       "The reason a legend isn't generated is because it is hard to place it well. To get a legend, re-run the plot and uncomment the line labeled as such. \n",
       "Then grab the legend and paste it onto the plot in a good area. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Accuracy Over Time\n",
    "Let's now take a look at how accuracy changes over the course of a simulation. Does it get worse over time? \n",
    "\n",
    "As we're using the small trace, we won't see much here. Please re-run the notebook to get a better large chart. \n",
    "\n",
    "The reason a legend isn't generated is because it is hard to place it well. To get a legend, re-run the plot and uncomment the line labeled as such. \n",
    "Then grab the legend and paste it onto the plot in a good area. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "interval_len = 10000\n",
    "def acc_over_time(st1, st2, phase):\n",
    "    \n",
    "    t1 = st1.cache_trace[0] # cache trace from st1\n",
    "    t2 = st2.cache_trace[0] # cache trace from st2\n",
    "    \n",
    "    # Just get accesses where were are in phase `phase` and in state is Swapped (2)\n",
    "    pick_state = t2['state'] == 2\n",
    "    pick_phase = t2['phase'] == phase\n",
    "    \n",
    "    pick = np.logical_and(pick_state, pick_phase)\n",
    "    \n",
    "    # Get the hit/miss from each \n",
    "    t1_hits = t1['isHit'][pick]\n",
    "    t2_hits = t2['isHit'][pick]\n",
    "    \n",
    "    nintervals = int(len(t1_hits) // interval_len)-1\n",
    "    \n",
    "    acc = []\n",
    "    \n",
    "    for i in range(nintervals):\n",
    "        start = i*interval_len\n",
    "        end   = (i+1)*interval_len\n",
    "        t1_hits_rest = t1_hits[start:end]\n",
    "        t2_hits_rest = t2_hits[start:end]\n",
    "    \n",
    "        num_correct = np.sum(np.equal(t1_hits_rest, t2_hits_rest))\n",
    "        acc.append(num_correct / interval_len)\n",
    "    \n",
    "    return acc\n",
    "\n",
    "nphases = stats['base'].phase_trace.nphases\n",
    "name_map={'fr':'Fixed Rate', 'm4': 'Markov 4', 'm8':'Markov 8', 'all':'All'}\n",
    "all_df = {}\n",
    "for i in range(nphases):\n",
    "    data = {}\n",
    "    for name in stats:\n",
    "        if name is 'base':\n",
    "            continue\n",
    "        data[name_map[name]] = acc_over_time(stats['base'], stats[name], i)\n",
    "    data_df = pd.DataFrame(data)    \n",
    "    all_df[i] = data_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pretty=['Initialization', 'Marker', 'High Locality', 'Vector Add', 'Random']\n",
    "def acc_over_time_plot(ax, approx, m4, m8, phase):\n",
    "    ax.plot(approx, label='Fixed Rate')\n",
    "    ax.plot(m4, label='Markov 4')\n",
    "    ax.plot(m8, label='Markov 8')    \n",
    "    ax.set_ylim((0,1))\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.get_yaxis().set_ticks([])\n",
    "    ax.set_title('Phase {}'.format(phase))\n",
    "    ax.text(x=0, y=.05, s=pretty[phase], color='grey')\n",
    "    if phase == 0:\n",
    "        ax.set_ylabel('Accuracy')\n",
    "        ax.get_yaxis().set_ticks([.2, .4, .6, .8, 1.])\n",
    "        ax.set_xlabel('Interval number')\n",
    "    if phase == 4:\n",
    "        pass\n",
    "        #ax.legend(loc=10) ##UNCOMMENT ME FOR LEGEND\n",
    "\n",
    "fig, ax = plt.subplots(1, 5, figsize=(12,3), squeeze=False)\n",
    "for phase in range(5):    \n",
    "    acc_over_time_plot(ax[0,phase], \n",
    "          all_df[phase]['Fixed Rate'],\n",
    "          all_df[phase]['Markov 4'],\n",
    "          all_df[phase]['Markov 8'],\n",
    "          phase)\n",
    "#plt.savefig('plots/acc-over-time.svg')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Accuracy as a function of Model Size\n",
       "\n",
       "This is just a fun little plot. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Accuracy as a function of Model Size\n",
    "\n",
    "This is just a fun little plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "bs=8192\n",
    "sz = {'base':1, 'fr':24/bs, 'm4':(3 * (4 * 4) * 8)/bs, 'm8':(3 * (8 * 8) * 8)/bs}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['fr']], accuracy_df['Fixed Rate'][i], marker='${}$'.format(i), color=cmap(0), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m4']], accuracy_df['Markov 4'][i], marker='${}$'.format(i), color=cmap(1), s=60)\n",
    "for i in range(5):\n",
    "    ax.scatter([sz['m8']], accuracy_df['Markov 8'][i], marker='${}$'.format(i), color=cmap(2), s=60)\n",
    "ax.scatter(1,1,  color=cmap(3))\n",
    "ax.set_xscale('log')\n",
    "\n",
    "\n",
    "labs=np.float64([24/bs, (3 * (4 * 4) * 8)/bs, (3 * (8 * 8) * 8)/bs, 1])*100\n",
    "ax.get_xaxis().set_ticks([24/bs, (3 * (4 * 4) * 8)/bs, (3 * (8 * 8) * 8)/bs, 1])\n",
    "ax.set_xticklabels(['{:.2f}%'.format(labs[i]) for i in range(4)])\n",
    "\n",
    "ax.get_yaxis().set_ticks([.4,.6, .8, 1])\n",
    "\n",
    "ax.set_xlabel('Model Size (% of Base Cache)')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.set_ylim(0,1.05)\n",
    "ax.set_xlim(0,1.5)\n",
    "ax.text(x=labs[0]/100, y=.05, s='Fixed Rate', rotation=90, color='grey')\n",
    "ax.text(x=labs[1]/100, y=.05, s='Markov 4', rotation=90, color='grey')\n",
    "ax.text(x=labs[2]/100, y=.05, s='Markov 8', rotation=90, color='grey')\n",
    "ax.text(x=labs[3]/100, y=.05, s='Base', rotation=90, color='grey')\n",
    "\n",
    "ax.spines['top'].set_visible(False)\n",
    "ax.spines['right'].set_visible(False)\n",
    "\n",
    "ax.set_title('Points are Phase Numbers', size=10)\n",
    "fig.suptitle('Accuracy as a function of Model Size')\n",
    "\n",
    "#plt.savefig('plots/acc_vs_modelsize.svg')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "## Locality Analysis\n",
       "\n",
       "Finally, we get to the hardest plot to generate, the locality plot. \n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%markdown\n",
    "\n",
    "## Locality Analysis\n",
    "\n",
    "Finally, we get to the hardest plot to generate, the locality plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "def index(array, item):\n",
    "    for idx, val in enumerate(array):\n",
    "        if val == item:\n",
    "            return idx\n",
    "    return -1\n",
    "\n",
    "def rightshift(val: np.uint64, shift: np.uint64) -> np.uint64:\n",
    "    return val >> shift\n",
    "\n",
    "def reuse(trace, shift, outfile=None):\n",
    "    stack = np.array([], dtype=np.int64)\n",
    "    out = []\n",
    "    for i in tqdm(range(len(trace))):\n",
    "        addr = rightshift(trace[i], np.uint64(shift)) # Cache line\n",
    "        idx = index(stack, addr)\n",
    "        if idx == -1:\n",
    "            stack = np.insert(stack, 0, addr)\n",
    "        else:\n",
    "            out.append(idx)\n",
    "            stack = np.delete(stack, idx)\n",
    "            stack = np.insert(stack, 0, addr)\n",
    "\n",
    "    if outfile is not None:\n",
    "        save_object(out, outfile)\n",
    "        print('Wrote reuse trace to: {}'.format(outfile))\n",
    "        \n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 26515/26515 [00:07<00:00, 3328.31it/s]\n",
      "100%|██████████| 27694/27694 [00:02<00:00, 10488.76it/s]\n",
      "100%|██████████| 26426/26426 [00:02<00:00, 9462.64it/s] \n",
      "100%|██████████| 26080/26080 [00:03<00:00, 7609.16it/s]\n",
      "100%|██████████| 4826/4826 [00:02<00:00, 2337.25it/s]\n",
      "0it [00:00, ?it/s]\n",
      "100%|██████████| 10253/10253 [00:01<00:00, 6556.16it/s]\n",
      "100%|██████████| 10851/10851 [00:01<00:00, 6900.54it/s]\n",
      "100%|██████████| 38604/38604 [00:44<00:00, 863.72it/s] \n",
      "100%|██████████| 39157/39157 [00:15<00:00, 2585.33it/s]\n",
      "100%|██████████| 39890/39890 [00:15<00:00, 2531.24it/s]\n",
      "100%|██████████| 39154/39154 [00:40<00:00, 970.48it/s] \n",
      "100%|██████████| 27781/27781 [00:05<00:00, 4956.51it/s]\n",
      "100%|██████████| 29881/29881 [00:04<00:00, 6106.55it/s]\n",
      "100%|██████████| 29946/29946 [00:05<00:00, 5900.33it/s]\n",
      "100%|██████████| 30012/30012 [00:05<00:00, 5731.53it/s]\n",
      "100%|██████████| 33025/33025 [00:02<00:00, 15125.95it/s]\n",
      "100%|██████████| 33649/33649 [00:01<00:00, 27364.02it/s]\n",
      "100%|██████████| 32104/32104 [00:01<00:00, 21853.44it/s]\n",
      "100%|██████████| 36357/36357 [00:02<00:00, 17691.74it/s]\n"
     ]
    }
   ],
   "source": [
    "reuse_perphase_base    = {}\n",
    "reuse_perphase_approx  = {}\n",
    "reuse_perphase_markov4 = {}\n",
    "reuse_perphase_markov8 = {}\n",
    "gran=6\n",
    "\n",
    "def get_addrs(data, phase):\n",
    "    df = pd.DataFrame(data)\n",
    "    return np.array(df[df['phase']==phase]['addr'], dtype=np.uint64)\n",
    "\n",
    "for phase in range(0,5):\n",
    "    reuse_perphase_base[phase] = reuse(get_addrs(stats['base'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_approx[phase] = reuse(get_addrs(stats['fr'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov4[phase] = reuse(get_addrs(stats['m4'].cache_trace[1], phase), gran)\n",
    "    reuse_perphase_markov8[phase] = reuse(get_addrs(stats['m8'].cache_trace[1], phase), gran)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "binwidth=16\n",
    "#maxbin={1:50, 2:850, 3:225, 4:50}\n",
    "maxbin={0:200,1:200, 2:200, 3:200, 4:200}\n",
    "\n",
    "yl=45000\n",
    "ylim={0:yl,1:yl, 2:yl, 3:yl, 4:yl}\n",
    "\n",
    "\n",
    "def bins(data, binwidth, maxbin):\n",
    "    #return range(min(data), min(maxbin, max(data) + binwidth), binwidth)\n",
    "   # print(data)\n",
    "    return range(min(data), maxbin, binwidth)\n",
    "\n",
    "def plot(ax, data, title, phase):\n",
    "    if not data:\n",
    "        data = [1]\n",
    "    ax.hist(data, bins=bins(data, binwidth, maxbin=maxbin[phase]), color='black')\n",
    "    ax.set_ylim((0,ylim[phase]))\n",
    "    #ax.suptitle(title)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.get_yaxis().set_ticks([])\n",
    "    if phase == 0:\n",
    "        ax.get_yaxis().set_ticks([30000])\n",
    "        ax.set_yticklabels(['30k'])\n",
    "    \n",
    "#plot(reuse_perphase_base[1], 'Base Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_approx[1], 'Fixed Rate Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_markov4[1], '4-State Markov Cache', maxbin=maxbin[1])\n",
    "#plot(reuse_perphase_markov8[1], '8-State Markov Cache', maxbin=maxbin[1])\n",
    "\n",
    "#i = 1\n",
    "\n",
    "fig, ax = plt.subplots(4, 5, figsize=(8,8))\n",
    "for i in range(5):\n",
    "    #phase = i+1\n",
    "    phase=i\n",
    "    \n",
    "    plot(ax[0,i], reuse_perphase_base[phase], 'Base Cache', phase)\n",
    "    plot(ax[1,i], reuse_perphase_approx[phase], 'Fixed Rate Cache', phase)\n",
    "    plot(ax[2,i], reuse_perphase_markov4[phase], '4-State Markov Cache', phase)\n",
    "    plot(ax[3,i], reuse_perphase_markov8[phase], '8-State Markov Cache', phase)\n",
    "\n",
    "#plt.savefig('plots/locality_per_phase.svg')\n",
    "plt.show()"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}