VisualizationV2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# IMPORT PACKAGES\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "%matplotlib widget\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import pandas as pd\n",
    "from matplotlib.pyplot import cm\n",
    "import tqdm\n",
    "import seaborn as sns\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from sklearn.decomposition import PCA\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# Functions\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "def moving_average(numbers, window_size):\n",
    "    i = 0\n",
    "    moving_averages = []\n",
    "    while i < len(numbers) - window_size + 1:\n",
    "        this_window = numbers[i : i + window_size]\n",
    "\n",
    "        window_average = sum(this_window) / window_size\n",
    "        moving_averages.append(window_average)\n",
    "        i += 1\n",
    "    return moving_averages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# LOGISTICS\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "\n",
    "# Define parts of file location\n",
    "parent_directory = '/Users/michaeldawson/Documents/GitHub/Research/TestBatches'\n",
    "batch_name = '2022-03-10--13-02-13'\n",
    "\n",
    "# Combine parts of file location\n",
    "batch_path = os.path.join(parent_directory,batch_name)\n",
    "batch_data = pd.read_csv(os.path.join(batch_path,\"batch_data.csv\"),index_col=0)\n",
    "device = batch_data['device'][0]\n",
    "\n",
    "net_names = ['efficientdet_lite4_detection_metadata_2',\n",
    "            'efficientdet_lite3_detection_metadata_1',\n",
    "            'efficientdet_lite2_detection_metadata_1',\n",
    "            'efficientdet_lite1_detection_metadata_1',\n",
    "            'efficientdet_lite0_detection_metadata_1']\n",
    "\n",
    "# Load in Data\n",
    "old_df = None\n",
    "test_data = {}\n",
    "\n",
    "if batch_data['alg1'][0] == True :\n",
    "    alg1_path = os.path.join(batch_path,\"alg1\")\n",
    "    \n",
    "    for net in net_names :\n",
    "        net_path = os.path.join(alg1_path,'{}'.format(net))\n",
    "        \n",
    "        # Read in test parameters\n",
    "        test_data['test_params_alg1_net{}'.format(net)] = pd.read_csv(os.path.join(alg1_path,\"test_params.csv\"),index_col=0)\n",
    "        \n",
    "        # Read in data from CSV into Pandas Dataframe\n",
    "        test_data['metadata_alg1_net{}'.format(net)] = pd.read_csv(os.path.join(net_path,\"metadata.csv\"),index_col=0)\n",
    "        \n",
    "        # Read in data from testing spreadsheet\n",
    "        test_data['df_alg1_net{}'.format(net)] = {}\n",
    "        for i in range(0,len(test_data['metadata_alg1_net{}'.format(net)].index)):\n",
    "            test_data['df_alg1_net{}'.format(net)][i] = pd.read_excel(os.path.join(net_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "            \n",
    "            #\n",
    "            new_df = pd.read_excel(os.path.join(net_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "            for key in list(test_data['test_params_alg1_net{}'.format(net)].keys()) :\n",
    "                new_df[key] = test_data['test_params_alg1_net{}'.format(net)][key].tolist() * len(new_df) \n",
    "            for key in list(test_data['metadata_alg1_net{}'.format(net)].keys()) :\n",
    "                new_df[key] = [test_data['metadata_alg1_net{}'.format(net)][key].tolist()[i]] * len(new_df) \n",
    "            new_df['alg'] = ['alg1']*len(new_df)\n",
    "\n",
    "            if old_df is None : old_df = new_df\n",
    "            else : old_df = pd.concat([old_df, new_df], ignore_index = False)\n",
    "            #\n",
    "            \n",
    "\n",
    "if batch_data['alg2'][0] == True :\n",
    "    alg2_path = os.path.join(batch_path,\"alg2\")\n",
    "    # Read in test parameters\n",
    "    test_data['test_params_alg2'] = pd.read_csv(os.path.join(alg2_path,\"test_params.csv\"),index_col=0)\n",
    "    # Read in data from CSV into Pandas Dataframe\n",
    "    test_data['metadata_alg2'] = pd.read_csv(os.path.join(alg2_path,\"metadata.csv\"),index_col=0)\n",
    "    # Read in data from testing spreadsheet\n",
    "    test_data['df_alg2'] = {}\n",
    "    for i in range(0,len(test_data['metadata_alg2'].index)):\n",
    "        test_data['df_alg2'][i] = pd.read_excel(os.path.join(alg2_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "        \n",
    "        #\n",
    "        new_df = pd.read_excel(os.path.join(alg2_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "        for key in list(test_data['test_params_alg2'].keys()) :\n",
    "            new_df[key] = test_data['test_params_alg2'][key].tolist() * len(new_df) \n",
    "        for key in list(test_data['metadata_alg2'].keys()) :\n",
    "            new_df[key] = [test_data['metadata_alg2'][key].tolist()[i]] * len(new_df) \n",
    "        new_df['alg'] = ['alg2']*len(new_df)\n",
    "\n",
    "        if old_df is None : old_df = new_df\n",
    "        else : old_df = pd.concat([old_df, new_df], ignore_index = False)\n",
    "        #\n",
    "\n",
    "        \n",
    "if batch_data['alg3'][0] == True :\n",
    "    alg3_path = os.path.join(batch_path,\"alg3\")\n",
    "    # Read in test parameters\n",
    "    test_data['test_params_alg3'] = pd.read_csv(os.path.join(alg3_path,\"test_params.csv\"),index_col=0)\n",
    "    # Read in data from CSV into Pandas Dataframe\n",
    "    test_data['metadata_alg3'] = pd.read_csv(os.path.join(alg3_path,\"metadata.csv\"),index_col=0)\n",
    "    # Read in data from testing spreadsheet\n",
    "    test_data['df_alg3'] = {}\n",
    "    for i in range(0,len(test_data['metadata_alg3'].index)):\n",
    "        test_data['df_alg3'][i] = pd.read_excel(os.path.join(alg3_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "\n",
    "        #\n",
    "        new_df = pd.read_excel(os.path.join(alg3_path,\"data.xlsx\"),index_col=0,sheet_name=\"Test{}\".format(i+1))\n",
    "        for key in list(test_data['test_params_alg3'].keys()) :\n",
    "            new_df[key] = test_data['test_params_alg3'][key].tolist() * len(new_df) \n",
    "        for key in list(test_data['metadata_alg3'].keys()) :\n",
    "            new_df[key] = [test_data['metadata_alg3'][key].tolist()[i]] * len(new_df) \n",
    "        new_df['alg'] = ['alg3']*len(new_df)\n",
    "\n",
    "        if old_df is None : old_df = new_df\n",
    "        else : old_df = pd.concat([old_df, new_df], ignore_index = False)\n",
    "        #\n",
    "        \n",
    "data = old_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display(old_df)\n",
    "# display(test_data['metadata_alg2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "# Settings\n",
    "#-------------------------------------------------------------------------------------------------------------------------------\n",
    "threshold = data['threshold_temp'].tolist()[0]\n",
    "# moving_average_window = test_params['moving_average_window'].tolist()[0]\n",
    "moving_average_window = 20\n",
    "end_of_detections = data['stop'].tolist()[0]\n",
    "start_temp = data['start_temp'].tolist()[0]\n",
    "net = data['start_net'].tolist()[0]\n",
    "# if program_name == \"Combined\" : TAC = data['TAC'].tolist()\n",
    "\n",
    "if net==1: net='MobileNetV1-SSD'\n",
    "if net==2: net='MobileNetV1-PPN'\n",
    "if net==3: net='MobileNetV2-SSD'\n",
    "if net==4: net='InceptionV2-SSD'\n",
    "\n",
    "num_pause_adjustment_coefficients = len(pd.unique(data['pause_adjustment_coef_records']))\n",
    "num_initial_pause_durations = len(pd.unique(data['initial_pause_duration_records']))\n",
    "\n",
    "plt.style.use('default')\n",
    "matplotlib.rcParams['mathtext.fontset'] = 'stix'\n",
    "matplotlib.rcParams['font.family'] = 'STIXGeneral'\n",
    "matplotlib.rcParams['font.size'] = 16\n",
    "plt.rcParams['figure.dpi'] = 100\n",
    "\n",
    "import matplotlib.colors as colors\n",
    "\n",
    "def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100):\n",
    "    new_cmap = colors.LinearSegmentedColormap.from_list(\n",
    "        'trunc({n},{a:.2f},{b:.2f})'.format(n=cmap.name, a=minval, b=maxval),\n",
    "        cmap(np.linspace(minval, maxval, n)))\n",
    "    return new_cmap\n",
    "\n",
    "working_plasma = cmap = plt.get_cmap('plasma')\n",
    "working_plasma = truncate_colormap(working_plasma, 0, 0.8)\n",
    "\n",
    "colors = cm.plasma(np.linspace(0, 0.8, len(data['pause_adjustment_coef_records'])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b3bd1199e5c49afadc8428b876faa55",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "$p_d$:   0%|          | 0/6 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f18f48562c164fc7ba438488fa6ee05f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "$p_a$:   0%|          | 0/6 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'df' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m iterator\u001b[38;5;241m=\u001b[39mj\u001b[38;5;241m+\u001b[39mi\u001b[38;5;241m*\u001b[39mnum_pause_adjustment_coefficients\n\u001b[1;32m     11\u001b[0m color \u001b[38;5;241m=\u001b[39m colors[iterator]\n\u001b[0;32m---> 13\u001b[0m working_df \u001b[38;5;241m=\u001b[39m \u001b[43mdf\u001b[49m[iterator]\n\u001b[1;32m     14\u001b[0m length \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(working_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtemp_record_CPU\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m     16\u001b[0m graphing_times \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mlinspace(working_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtime_record\u001b[39m\u001b[38;5;124m'\u001b[39m][\u001b[38;5;241m0\u001b[39m],\n\u001b[1;32m     17\u001b[0m      working_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtime_record\u001b[39m\u001b[38;5;124m'\u001b[39m][length\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m], \n\u001b[1;32m     18\u001b[0m      \u001b[38;5;28mint\u001b[39m(working_df[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtime_record\u001b[39m\u001b[38;5;124m'\u001b[39m][length\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]))\n",
      "\u001b[0;31mNameError\u001b[0m: name 'df' is not defined"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0d6fb461ca914ce298f46fdea8c7b828",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABkAAAAZACAYAAAAhDI6nAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACYkUlEQVR4nOzdf7CWdZ3/8Rcc4AYOnSMoCh5pC3djkkAdXHfWw0JUuhqULdaa3y2dnE3ANabc+hY06+oeB2asqZA206n1j5pWmbFJ2ZUGghXE/OKxKUExf025Rw9WA8t9i8g5yDnfPxrOROcg4grn9uPjMXOmzv25Ptd53zPdTnM/va5rSG9vb28AAAAAAAAKMnSwBwAAAAAAAHijCSAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAULd6e3uzatWqfO1rXxvsUQAAAAAAeJMRQKg7B8PHtGnTcumll2br1q1Htf/Xv/51Lr/88lxzzTVZsGBBzj///Kxdu/YYTQsAAAAAQD0SQKg7jz32WM4555x87nOfO+q9v/jFL3LWWWdlxowZ+eY3v5lbb701119/febOnZvvf//7x2BaAAAAAADqkQBC3XnPe96TyZMn5/TTTz+qfa+88ko++tGPpqmpKddcc03f662trfnIRz6ShQsX5vnnn3+jxwUAAAAAoA4JIBTjrrvuyjPPPJO5c+emoaHhkLWLL744L730UlauXDlI0wEAAAAAcDwJIBRj3bp1SZLp06f3WzvrrLOSJPfcc8/xHAkAAAAAgEEigFCM7du3J0laWlr6rR187YknnkhXV9dxnQsAAAAAgONv2GAPAG+UXbt2JUkaGxv7rY0ZMyZJ0tPTk927d+eUU07pd0xXV9chcaSnpye7du3KiSeemCFDhhyjqQEAAACgTL29vXnxxRdz6qmnZuhQ/y4+x58AQjF6e3sPu/aH/4A93HHLly/PDTfc8IbPBQAAAABvZR0dHTnttNMGewzeggQQijF+/Pg8+eST2bt3b7+1g681NDRk3LhxA+5fsmRJrr322r7fq9Vq3v72t6ejoyNNTU3HZmgAAAAAKFStVsukSZPytre9bbBH4S1KAKEYU6dOzQMPPJAdO3b0W+vs7EySTJkyJSNGjBhwf6VSSaVS6fd6U1OTAAIAAAAAr5PbyzNY3HiNYnzwgx9Mkmzbtq3f2iOPPJIkueiii47rTAAAAAAADA4BhDete++9Nz//+c/7fp87d27e8Y535N577+33nI+77747w4YNy6JFi473mAAAAAAADAIBhLr1wgsvJMmAz/RYu3Zt5s6dm9bW1tRqtSTJsGHDcvvtt6ezszO33HJL37EPPfRQVq1aleXLl+f0008/PsMDAAAAADCoPAOEuvOrX/0qP/rRj7JixYokyerVq3P99dentbU1559/fpJk8uTJOfXUU/POd74zo0eP7tv73ve+Nz/96U/T1taW9vb2jBo1Kk8++WTuuOOOXHLJJYPyfgAAAAAAOP6G9P7xvYKAJEmtVktzc3Oq1aqHoAMAAADAUfL9GoPNLbAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAijNssAeAP9bd3Z2bb7457e3tmThxYh5//PGcd955Wbp0aYYPH37E/atWrcqdd96ZCRMmZPfu3Xn++eezePHizJ8//zhMDwAAAABAPRBAqCvd3d2ZN29earVaNm7cmEqlkr1792bmzJnZsmVLVq9enYaGhsPu/8IXvpC77747Dz30UE444YQkybZt2/IXf/EX+frXv54FCxYcp3cCAAAAAMBgcgss6sqyZcuybt26tLW1pVKpJElGjx6dtra2rFmzJitXrjzs3pdeeikrVqzIhz/84b74kSTTpk3L+9///txyyy3HenwAAAAAAOqEAELd6Orqyje+8Y00Njbmfe973yFrF1xwQUaNGpWvfOUr6enpGXD/vn37sn///mzfvr3fWk9PT0aNGnVM5gYAAAAAoP4IINSN9vb2VKvVTJ06td9troYPH54zzjgjnZ2defjhhwfcf+KJJ+bss8/OmjVr8p3vfKfv9SeeeCLr16/P4sWLj+n8AAAAAADUDwGEunHwyo2WlpYB1w++vnXr1sOe4/bbb8+4cePy6U9/OpdffnnuuOOOfOpTn8qqVaty2WWXvfFDAwAAAABQlwQQ6sauXbuSJI2NjQOujxkzJkmyc+fOw57jzDPPzAMPPJApU6bke9/7Xi677LJccskl+dCHPnTEv9/V1ZVarXbIDwAAAAAAb04CCHWjt7f3VdeHDh36mo777W9/m3HjxuXKK6/M0KFD8/nPfz7z5s3Liy+++Kr7li9fnubm5r6fSZMmHd0bAAAAAACgbggg1I3x48cnSfbu3Tvg+sHXDx43kDvvvDMf+tCHcvvtt+e73/1uNm3alHe+8525995784lPfOJV//6SJUtSrVb7fjo6Ol7nOwEAAAAAYLAJINSNqVOnJkl27Ngx4HpnZ2eSZPr06QOu79mzJwsWLMi8efMyZcqUJElra2s2b96ciRMn5p577sm2bdsO+/crlUqampoO+QEAAAAA4M1JAKFunHvuuTnppJPy2GOP9bvN1YEDB/Loo4/m5JNPzowZMwbcv3379lSr1X63rjr11FOzYMGCvmMAAAAAACifAELdaGhoyMKFC1Or1XL//fcfsrZhw4bs2bMnV199dYYOHZoDBw7krrvuylNPPdV3zIQJE5IkzzzzTL9zNzc3J4nnegAAAAAAvEUM6T3SE6XhOHr55ZfT2tqaxsbGrF+/PiNGjMi+ffsya9as9PT0ZPPmzRk5cmRuu+22LFiwIC0tLXnuuef69i9YsCD/9m//lg0bNuSv/uqvkvz+2SEzZ87MKaecknvvvTdDhgx5TbPUarU0NzenWq26HRYAAAAAHCXfrzHYhg32APCHRo0alU2bNuXGG2/M/PnzM3ny5Dz99NOZM2dOrrvuuowcOTLJ758XMnbs2LS2th6y/5ZbbsnMmTOzdOnSnHbaaTnxxBPT0dGRK6+8MlddddVrjh8AAAAAALy5uQIEDkOhBgAAAIDXz/drDDbPAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOMMGewA41vbs2ZMtW7bk17/+dWbPnp0//dM/HeyRAAAAAAA4xlwBQrHa29szd+7cXHjhhdm9e3c+8YlPiB8AAAAAAG8RrgCh7nR3d+fmm29Oe3t7Jk6cmMcffzznnXdeli5dmuHDh7+mc1x//fVpa2vLjTfemC996UsZMmTIMZ4aAAAAAIB6IoBQV7q7uzNv3rzUarVs3LgxlUole/fuzcyZM7Nly5asXr06DQ0Nr3qOz372s1mxYkW+9rWv5XOf+9xxmhwAAAAAgHriFljUlWXLlmXdunVpa2tLpVJJkowePTptbW1Zs2ZNVq5c+ar777jjjqxYsSIf+MAHxA8AAAAAgLewIb29vb2DPQQkSVdXV0455ZS88sorqVarh1zpsX///jQ3N2fs2LHp6OjI0KH92113d3fe9a535dlnn819992X2bNn/6/mqdVqaW5uTrVaTVNT0//qXAAAAADwVuP7NQabK0CoG+3t7alWq5k6dWq/21wNHz48Z5xxRjo7O/Pwww8PuH/t2rV59tln09zcnCeffDIzZsxIY2NjJkyYkE9/+tP53e9+dzzeBgAAAAAAdUAAoW5s3749SdLS0jLg+sHXt27dOuD6+vXr+/77CSeckP/6r//Kr371q1x55ZX5zne+k1mzZmXPnj2H/ftdXV2p1WqH/AAAAAAA8OYkgFA3du3alSRpbGwccH3MmDFJkp07dw64/uyzzyZJlixZko997GNpamrKySefnGXLluXiiy/OL3/5y/zrv/7rYf/+8uXL09zc3PczadKk/83bAQAAAABgEAkg1I0jPY7m4HM/DnfcwSs2zjzzzH5rf/d3f5ckWbNmzWHPv2TJklSr1b6fjo6O1zQ3AAAAAAD1Z9hgDwAHjR8/Pkmyd+/eAdcPvn7wuD/W3Nx82HNPmTIlSdLZ2XnYYyqVSiqVymuaFQAAAACA+uYKEOrG1KlTkyQ7duwYcP1gvJg+ffqA6+95z3sOu3/UqFGH/CcAAAAAAGUTQKgb5557bk466aQ89thj/W5zdeDAgTz66KM5+eSTM2PGjAH3X3jhhUmSn//85/3Wfve73yU5fDwBAAAAAKAsAgh1o6GhIQsXLkytVsv9999/yNqGDRuyZ8+eXH311Rk6dGgOHDiQu+66K0899VTfMX/5l3+Zc845Jz/84Q+zf//+Q/Y/+OCDSZIrrrji2L8RAAAAAAAG3ZDeIz15Go6jl19+Oa2trWlsbMz69eszYsSI7Nu3L7NmzUpPT082b96ckSNH5rbbbsuCBQvS0tKS5557rm//I488kpkzZ2bRokW56aabkiQvvvhizj777FxwwQX51re+9ZpnqdVqaW5uTrVaTVNT0xv+XgEAAACgZL5fY7B5CDp1ZdSoUdm0aVNuvPHGzJ8/P5MnT87TTz+dOXPm5LrrrsvIkSOT/P55IWPHjk1ra+sh+88888xs2bIl//RP/5SLLroo73jHO7Jjx4584QtfyFVXXTUYbwkAAAAAgEHgChA4DIUaAAAAAF4/368x2DwDBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAUb9GiRXnve9872GMAAAAAAHAcDRvsAeCPdXd35+abb057e3smTpyYxx9/POedd16WLl2a4cOHH9W5/uM//iPf/va3M3v27GM0LQAAAAAA9UgAoa50d3dn3rx5qdVq2bhxYyqVSvbu3ZuZM2dmy5YtWb16dRoaGl7TuX7zm99k5cqVx3hiAAAAAADqkVtgUVeWLVuWdevWpa2tLZVKJUkyevTotLW1Zc2aNUcVNK6++up8/etfP1ajAgAAAABQx4b09vb2DvYQkCRdXV055ZRT8sorr6RarR5ypcf+/fvT3NycsWPHpqOjI0OHvnq7++Y3v5menp4sXrw4Q4YMyezZs3Pfffcd1Ty1Wi3Nzc2pVqtpamp6PW8JAAAAAN6yfL/GYHMFCHWjvb091Wo1U6dO7Xebq+HDh+eMM85IZ2dnHn744Vc9z/bt2/OTn/wkn/nMZ47luAAAAAAA1DEBhLqxffv2JElLS8uA6wdf37p162HP0d3dncWLF+db3/pWhgwZ8sYPCQAAAADAm4KHoFM3du3alSRpbGwccH3MmDFJkp07dx72HEuXLs2iRYty6qmnHvXf7+rqSldXV9/vtVrtqM8BAAAAAEB9cAUIdeNIj6M5+NyPwx23fv367Nq1K5dccsnr+vvLly9Pc3Nz38+kSZNe13kAAAAAABh8rgChbowfPz5Jsnfv3gHXD75+8Lg/9D//8z/54he/mH//93/PCy+80G+9u7u77/UJEyYMeP4lS5bk2muv7fu9VquJIAAAAAAAb1ICCHVj6tSpSZIdO3YMuN7Z2ZkkmT59er+1Rx55JD/72c/yrne9a8C9Dz74YCZOnJjk8FeQVCqVVCqVo54bAAAAAID6I4BQN84999ycdNJJeeyxx9Lb23vIQ8wPHDiQRx99NCeffHJmzJjRb+/06dOzZs2aAc970UUXZdq0abnpppuO2ewAAAAAANQXAYS60dDQkIULF+bGG2/M/fffn1mzZvWtbdiwIXv27MnnP//5DB06NAcOHMiPfvSjTJ8+PX/2Z3+WcePG5cILLzzsuY+0DgAAAABAWYb0HunJ03Acvfzyy2ltbU1jY2PWr1+fESNGZN++fZk1a1Z6enqyefPmjBw5MrfddlsWLFiQlpaWPPfcc696ziFDhmT27Nm57777jmqWWq2W5ubmVKvVNDU1/S/eFQAAAAC89fh+jcE2dLAHgD80atSobNq0Ka2trZk/f34WL16c+fPnZ86cOdm4cWNGjhyZ5PfPCxk7dmxaW1sHeWIAAAAAAOqRK0DgMBRqAAAAAHj9fL/GYHMFCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBDqTnd3d7761a/m0ksvzWc/+9n89V//dW644Ybs37//iHsPHDiQm266Ke9+97tTqVQybty4/M3f/E0effTR4zA5AAAAAAD1Ykhvb2/vYA8BB3V3d2fevHmp1WrZuHFjKpVK9u7dm5kzZ2bChAlZvXp1GhoaDrv/7//+7/PjH/845513Xl5++eU8+OCD2blzZ8aMGZOf/vSnmTZt2muepVarpbm5OdVqNU1NTW/E2wMAAACAtwzfrzHYXAFCXVm2bFnWrVuXtra2VCqVJMno0aPT1taWNWvWZOXKlYfdu3bt2vzmN7/JM888k1WrVmX16tV5+umnM3v27OzZsyfXX3/9cXoXAAAAAAAMNleAUDe6urpyyimn5JVXXkm1Wj3kSo/9+/enubk5Y8eOTUdHR4YO7d/u/uEf/iH/8i//khNPPPGQ13/xi1/k7LPPzpQpU/LLX/7yNc+jUAMAAADA6+f7NQabK0CoG+3t7alWq5k6dWq/21wNHz48Z5xxRjo7O/Pwww8PuP9LX/pSv/iRJFOmTEmSnHbaaW/80AAAAAAA1CUBhLqxffv2JElLS8uA6wdf37p164DrkyZNGvD1F154IUnysY997FX/fldXV2q12iE/AAAAAAC8OQkg1I1du3YlSRobGwdcHzNmTJJk586dR3Xee+65J+9+97tzxRVXvOpxy5cvT3Nzc9/P4YIKAAAAAAD1TwChbhzpcTQHn/txNI+tqdVque222/KDH/wgI0eOfNVjlyxZkmq12vfT0dHxmv8OAAAAAAD1ZdhgDwAHjR8/Pkmyd+/eAdcPvn7wuCPp7e3NZz7zmaxYsSJnnXXWEY+vVCqpVCqvbVgAAAAAAOqaK0CoG1OnTk2S7NixY8D1zs7OJMn06dNf0/k+//nP5+Mf/3g+8IEPvDEDAgAAAADwpjGk92juJwTH0IEDBzJhwoR0d3dn9+7dGTJkyCFrJ5xwQkaPHp0dO3b03Q7rcL74xS/m/e9/fy644ILXPU+tVktzc3Oq1Wqamppe93kAAAAA4K3I92sMNleAUDcaGhqycOHC1Gq13H///YesbdiwIXv27MnVV1+doUOH5sCBA7nrrrvy1FNPHXJcb29v/vEf/zHnn39+v/hx4MCBfPnLXz7m7wMAAAAAgMHnChDqyssvv5zW1tY0NjZm/fr1GTFiRPbt25dZs2alp6cnmzdvzsiRI3PbbbdlwYIFaWlpyXPPPZck6enpyVVXXZXNmzf3e+ZHT09Ptm3blkWLFmXx4sWvaRaFGgAAAABeP9+vMdg8BJ26MmrUqGzatCk33nhj5s+fn8mTJ+fpp5/OnDlzct1112XkyJFJfv+8kLFjx6a1tbVv76JFi/Ld7343SfLEE0/0O/fo0aNzxRVXHJ83AgAAAADAoHIFCByGQg0AAAAAr5/v1xhsngECAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDjDBnsA+GPd3d25+eab097enokTJ+bxxx/Peeedl6VLl2b48OFH3L9169a0tbXltNNOy+7du/Pb3/42N9xwQ84555zjMD0AAAAAAPVAAKGudHd3Z968eanVatm4cWMqlUr27t2bmTNnZsuWLVm9enUaGhoOu3/t2rWZN29eVq1alY985CNJkjvuuCOtra358Y9/nDlz5hyndwIAAAAAwGByCyzqyrJly7Ju3bq0tbWlUqkkSUaPHp22trasWbMmK1euPOze3bt352//9m/z53/+533xI0k+/vGPZ/r06fnkJz+Zl1566Vi/BQAAAAAA6oAAQt3o6urKN77xjTQ2NuZ973vfIWsXXHBBRo0ala985Svp6ekZcP+tt96aarWaD3/4w/3WLr744jz//PP53ve+d0xmBwAAAACgvggg1I329vZUq9VMnTq1322uhg8fnjPOOCOdnZ15+OGHB9y/bt26JMn06dP7rZ111llJknvuueeNHRoAAAAAgLokgFA3tm/fniRpaWkZcP3g61u3bj3q/UfaCwAAAABAWTwEnbqxa9euJEljY+OA62PGjEmS7Ny586j3H2lv8vtbcHV1dfX9Xq1WkyS1Wu1IowMAAAAAf+Tg92q9vb2DPAlvVQIIdeNI/yAcOnToqx73avuPtDdJli9fnhtuuKHf65MmTXrVuQAAAACAw9u5c2eam5sHewzeggQQ6sb48eOTJHv37h1w/eDrB48baP/zzz8/4P4j7U2SJUuW5Nprr+37fffu3fmTP/mT/Pd//7d/QENharVaJk2alI6OjjQ1NQ32OMAbyOcbyuXzDeXy+YZyVavVvP3tb8+4ceMGexTeogQQ6sbUqVOTJDt27BhwvbOzM8nADzk/uP/555/Pjh07Mm3atKPamySVSiWVSqXf683Nzf4PGBSqqanJ5xsK5fMN5fL5hnL5fEO5Dt6dBY43/8ujbpx77rk56aST8thjj/W7VdWBAwfy6KOP5uSTT86MGTMG3P/BD34wSbJt27Z+a4888kiS5KKLLnqDpwYAAAAAoB4JINSNhoaGLFy4MLVaLffff/8haxs2bMiePXty9dVXZ+jQoTlw4EDuuuuuPPXUU33HXH755Xnb296W//zP/+x37rvvvjvNzc355Cc/eczfBwAAAAAAg08Aoa4sXbo0Z599dr785S+nu7s7SbJv3758+ctfzowZM/LFL34xSfLd7343H/3oRzNnzpy+vWPHjs23v/3tbNq0Kffee2/f6z/84Q/z//7f/8utt956VM/yqFQq+ed//ucBb4sFvLn5fEO5fL6hXD7fUC6fbyiXzzeDbUjvH99rCAbZnj17cuONN+bRRx/N5MmT8/TTT2fatGm57rrr0tjYmCR54IEH8qEPfSjnn39+7rzzzkP2b9iwIV/96lczadKk9Pb2pqOjI//3//7fQ2IJAAAAAABlE0AAAAAAAIDiuAUWAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIINSt3t7erFq1Kl/72tcGexQAAAAAAN5kBBDqzsHwMW3atFx66aXZunXrUe3/9a9/ncsvvzzXXHNNFixYkPPPPz9r1649RtMCAAAAAFCPBBDqzmOPPZZzzjknn/vc54567y9+8YucddZZmTFjRr75zW/m1ltvzfXXX5+5c+fm+9///jGYFgAAAACAeiSAUHfe8573ZPLkyTn99NOPat8rr7ySj370o2lqaso111zT93pra2s+8pGPZOHChXn++eff6HEBAAAAAKhDAgjFuOuuu/LMM89k7ty5aWhoOGTt4osvzksvvZSVK1cO0nQAAAAAABxPAgjFWLduXZJk+vTp/dbOOuusJMk999xzPEcCAAAAAGCQDBvsAeCNsn379iRJS0tLv7WDrz3xxBPp6upKpVLpd0xXV1e6urr6fu/p6cmuXbty4oknZsiQIcdoagAAAAAoU29vb1588cWceuqpGTrUv4vP8SeAUIxdu3YlSRobG/utjRkzJsnvo8bu3btzyimn9Dtm+fLlueGGG47tkAAAAADwFtPR0ZHTTjttsMfgLUgAoRi9vb2HXfvDwny445YsWZJrr7227/dqtZq3v/3t6ejoSFNT0xs3KAAAAAC8BdRqtUyaNClve9vbBnsU3qIEEIoxfvz4PPnkk9m7d2+/tYOvNTQ0ZNy4cQPur1QqA94aq6mpSQABAAAAgNfJ7eUZLG68RjGmTp2aJNmxY0e/tc7OziTJlClTMmLEiOM6FwAAAAAAx58AQjE++MEPJkm2bdvWb+2RRx5Jklx00UXHdSYAAAAAAAaHAMKb1r333puf//znfb/PnTs373jHO3Lvvff2e87H3XffnWHDhmXRokXHe0wAAAAAAAaBAELdeuGFF5JkwGd6rF27NnPnzk1ra2tqtVqSZNiwYbn99tvT2dmZW265pe/Yhx56KKtWrcry5ctz+umnH5/hAQAAAAAYVB6CTt351a9+lR/96EdZsWJFkmT16tW5/vrr09ramvPPPz9JMnny5Jx66ql55zvfmdGjR/ftfe9735uf/vSnaWtrS3t7e0aNGpUnn3wyd9xxRy655JJBeT8AAAAAABx/Q3r/+F5BQJKkVqulubk51Wo1TU1Ngz0OAAAAALyp+H6NweYWWAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKM2ywB4A/1t3dnZtvvjnt7e2ZOHFiHn/88Zx33nlZunRphg8ffsT9q1atyp133pkJEyZk9+7def7557N48eLMnz//OEwPAAAAAEA9EECoK93d3Zk3b15qtVo2btyYSqWSvXv3ZubMmdmyZUtWr16dhoaGw+7/whe+kLvvvjsPPfRQTjjhhCTJtm3b8hd/8Rf5+te/ngULFhyndwIAAAAAwGByCyzqyrJly7Ju3bq0tbWlUqkkSUaPHp22trasWbMmK1euPOzel156KStWrMiHP/zhvviRJNOmTcv73//+3HLLLcd6fAAAAAAA6oQAQt3o6urKN77xjTQ2NuZ973vfIWsXXHBBRo0ala985Svp6ekZcP++ffuyf//+bN++vd9aT09PRo0adUzmBgAAAACg/ggg1I329vZUq9VMnTq1322uhg8fnjPOOCOdnZ15+OGHB9x/4okn5uyzz86aNWvyne98p+/1J554IuvXr8/ixYuP6fwAAAAAANQPAYS6cfDKjZaWlgHXD76+devWw57j9ttvz7hx4/LpT386l19+ee6444586lOfyqpVq3LZZZe98UMDAAAAAFCXBBDqxq5du5IkjY2NA66PGTMmSbJz587DnuPMM8/MAw88kClTpuR73/teLrvsslxyySX50Ic+dMS/39XVlVqtdsgPAAAAAABvTgIIdaO3t/dV14cOHfqajvvtb3+bcePG5corr8zQoUPz+c9/PvPmzcuLL774qvuWL1+e5ubmvp9JkyYd3RsAAAAAAKBuCCDUjfHjxydJ9u7dO+D6wdcPHjeQO++8Mx/60Idy++2357vf/W42bdqUd77znbn33nvziU984lX//pIlS1KtVvt+Ojo6Xuc7AQAAAABgsAkg1I2pU6cmSXbs2DHgemdnZ5Jk+vTpA67v2bMnCxYsyLx58zJlypQkSWtrazZv3pyJEyfmnnvuybZt2w779yuVSpqamg75AQAAAADgzUkAoW6ce+65Oemkk/LYY4/1u83VgQMH8uijj+bkk0/OjBkzBty/ffv2VKvVfreuOvXUU7NgwYK+YwAAAAAAKJ8AQt1oaGjIwoULU6vVcv/99x+ytmHDhuzZsydXX311hg4dmgMHDuSuu+7KU0891XfMhAkTkiTPPPNMv3M3Nzcnied6AAAAAAC8RQzpPdITpeE4evnll9Pa2prGxsasX78+I0aMyL59+zJr1qz09PRk8+bNGTlyZG677bYsWLAgLS0tee655/r2L1iwIP/2b/+WDRs25K/+6q+S/P7ZITNnzswpp5ySe++9N0OGDHlNs9RqtTQ3N6darbodFgAAAAAcJd+vMdiGDfYA8IdGjRqVTZs25cYbb8z8+fMzefLkPP3005kzZ06uu+66jBw5MsnvnxcyduzYtLa2HrL/lltuycyZM7N06dKcdtppOfHEE9PR0ZErr7wyV1111WuOHwAAAAAAvLm5AgQOQ6EGAAAAgNfP92sMNs8AAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4wwZ7ADjW9uzZky1btuTXv/51Zs+enT/90z8d7JEAAAAAADjGXAFCsdrb2zN37txceOGF2b17dz7xiU+IHwAAAAAAbxGuAKHudHd35+abb057e3smTpyYxx9/POedd16WLl2a4cOHv6ZzXH/99Wlra8uNN96YL33pSxkyZMgxnhoAAAAAgHoigFBXuru7M2/evNRqtWzcuDGVSiV79+7NzJkzs2XLlqxevToNDQ2veo7PfvazWbFiRb72ta/lc5/73HGaHAAAAACAeuIWWNSVZcuWZd26dWlra0ulUkmSjB49Om1tbVmzZk1Wrlz5qvvvuOOOrFixIh/4wAfEDwAAAACAt7Ahvb29vYM9BCRJV1dXTjnllLzyyiupVquHXOmxf//+NDc3Z+zYseno6MjQof3bXXd3d971rnfl2WefzX333ZfZs2f/r+ap1Wppbm5OtVpNU1PT/+pcAAAAAPBW4/s1BpsrQKgb7e3tqVarmTp1ar/bXA0fPjxnnHFGOjs78/DDDw+4f+3atXn22WfT3NycJ598MjNmzEhjY2MmTJiQT3/60/nd7353PN4GAAAAAAB1QAChbmzfvj1J0tLSMuD6wde3bt064Pr69ev7/vsJJ5yQ//qv/8qvfvWrXHnllfnOd76TWbNmZc+ePW/w1AAAAAAA1CMBhLqxa9euJEljY+OA62PGjEmS7Ny5c8D1Z599NkmyZMmSfOxjH0tTU1NOPvnkLFu2LBdffHF++ctf5l//9V8P+/e7urpSq9UO+QEAAAAA4M1JAKFuHOlxNAef+3G44w4GizPPPLPf2t/93d8lSdasWXPY8y9fvjzNzc19P5MmTXpNcwMAAAAAUH8EEOrG+PHjkyR79+4dcP3g6weP+2PNzc2HPfeUKVOSJJ2dnYc9ZsmSJalWq30/HR0dr2luAAAAAADqjwBC3Zg6dWqSZMeOHQOuH4wX06dPH3D9Pe95z2H3jxo16pD/HEilUklTU9MhPwAAAAAAvDkJINSNc889NyeddFIee+yxfre5OnDgQB599NGcfPLJmTFjxoD7L7zwwiTJz3/+835rv/vd75IcPp4AAAAAAFAWAYS60dDQkIULF6ZWq+X+++8/ZG3Dhg3Zs2dPrr766gwdOjQHDhzIXXfdlaeeeqrvmL/8y7/MOeeckx/+8IfZv3//IfsffPDBJMkVV1xx7N8IAAAAAACDbkjvkZ48DcfRyy+/nNbW1jQ2Nmb9+vUZMWJE9u3bl1mzZqWnpyebN2/OyJEjc9ttt2XBggVpaWnJc88917f/kUceycyZM7No0aLcdNNNSZIXX3wxZ599di644IJ861vfes2z1Gq1NDc3p1qtuh0WAAAAABwl368x2IYN9gDwh0aNGpVNmzblxhtvzPz58zN58uQ8/fTTmTNnTq677rqMHDkyye+fFzJ27Ni0trYesv/MM8/Mli1b8k//9E+56KKL8o53vCM7duzIF77whVx11VWD8ZYAAAAAABgErgCBw1CoAQAAAOD18/0ag80zQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgBC8RYtWpT3vve9gz0GAAAAAADH0bDBHgD+WHd3d26++ea0t7dn4sSJefzxx3Peeedl6dKlGT58+FGd6z/+4z/y7W9/O7Nnzz5G0wIAAAAAUI8EEOpKd3d35s2bl1qtlo0bN6ZSqWTv3r2ZOXNmtmzZktWrV6ehoeE1nes3v/lNVq5ceYwnBgAAAACgHrkFFnVl2bJlWbduXdra2lKpVJIko0ePTltbW9asWXNUQePqq6/O17/+9WM1KgAAAAAAdWxIb29v72APAUnS1dWVU045Ja+88kqq1eohV3rs378/zc3NGTt2bDo6OjJ06Ku3u29+85vp6enJ4sWLM2TIkMyePTv33XffUc1Tq9XS3NycarWapqam1/OWAAAAAOAty/drDDZXgFA32tvbU61WM3Xq1H63uRo+fHjOOOOMdHZ25uGHH37V82zfvj0/+clP8pnPfOZYjgsAAAAAQB0TQKgb27dvT5K0tLQMuH7w9a1btx72HN3d3Vm8eHG+9a1vZciQIW/8kAAAAAAAvCl4CDp1Y9euXUmSxsbGAdfHjBmTJNm5c+dhz7F06dIsWrQop5566lH//a6urnR1dfX9XqvVjvocAAAAAADUB1eAUDeO9Diag8/9ONxx69evz65du3LJJZe8rr+/fPnyNDc39/1MmjTpdZ0HAAAAAIDB5woQ6sb48eOTJHv37h1w/eDrB4/7Q//zP/+TL37xi/n3f//3vPDCC/3Wu7u7+16fMGHCgOdfsmRJrr322r7fa7WaCAIAAAAA8CYlgFA3pk6dmiTZsWPHgOudnZ1JkunTp/dbe+SRR/Kzn/0s73rXuwbc++CDD2bixIlJDn8FSaVSSaVSOeq5AQAAAACoPwIIdePcc8/NSSedlMceeyy9vb2HPMT8wIEDefTRR3PyySdnxowZ/fZOnz49a9asGfC8F110UaZNm5abbrrpmM0OAAAAAEB9EUCoGw0NDVm4cGFuvPHG3H///Zk1a1bf2oYNG7Jnz558/vOfz9ChQ3PgwIH86Ec/yvTp0/Nnf/ZnGTduXC688MLDnvtI6wAAAAAAlGVI75GePA3H0csvv5zW1tY0NjZm/fr1GTFiRPbt25dZs2alp6cnmzdvzsiRI3PbbbdlwYIFaWlpyXPPPfeq5xwyZEhmz56d++6776hmqdVqaW5uTrVaTVNT0//iXQEAAADAW4/v1xhsQwd7APhDo0aNyqZNm9La2pr58+dn8eLFmT9/fubMmZONGzdm5MiRSX7/vJCxY8emtbV1kCcGAAAAAKAeuQIEDkOhBgAAAIDXz/drDDZXgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwCh7nR3d+erX/1qLr300nz2s5/NX//1X+eGG27I/v37j7j3wIEDuemmm/Lud787lUol48aNy9/8zd/k0UcfPQ6TAwAAAABQL4b09vb2DvYQcFB3d3fmzZuXWq2WjRs3plKpZO/evZk5c2YmTJiQ1atXp6Gh4bD7//7v/z4//vGPc9555+Xll1/Ogw8+mJ07d2bMmDH56U9/mmnTpr3mWWq1Wpqbm1OtVtPU1PRGvD0AAAAAeMvw/RqDzRUg1JVly5Zl3bp1aWtrS6VSSZKMHj06bW1tWbNmTVauXHnYvWvXrs1vfvObPPPMM1m1alVWr16dp59+OrNnz86ePXty/fXXH6d3AQAAAADAYHMFCHWjq6srp5xySl555ZVUq9VDrvTYv39/mpubM3bs2HR0dGTo0P7t7h/+4R/yL//yLznxxBMPef0Xv/hFzj777EyZMiW//OUvX/M8CjUAAAAAvH6+X2OwuQKEutHe3p5qtZqpU6f2u83V8OHDc8YZZ6SzszMPP/zwgPu/9KUv9YsfSTJlypQkyWmnnfbGDw0AAAAAQF0SQKgb27dvT5K0tLQMuH7w9a1btw64PmnSpAFff+GFF5IkH/vYx/63IwIAAAAA8CYxbLAHgIN27dqVJGlsbBxwfcyYMUmSnTt3HtV577nnnrz73e/OFVdc8arHdXV1paurq+/3Wq12VH8HAAAAAID64QoQ6saRHkdz8LkfR/PYmlqtlttuuy0/+MEPMnLkyFc9dvny5Wlubu77OdwVJQAAAAAA1D8BhLoxfvz4JMnevXsHXD/4+sHjjqS3tzef+cxnsmLFipx11llHPH7JkiWpVqt9Px0dHa9tcAAAAAAA6o5bYFE3pk6dmiTZsWPHgOudnZ1JkunTp7+m833+85/Pxz/+8XzgAx94TcdXKpVUKpXXdCwAAAAAAPVtSO/R3E8IjqEDBw5kwoQJ6e7uzu7duzNkyJBD1k444YSMHj06O3bs6Lsd1uF88YtfzPvf//5ccMEFr3ueWq2W5ubmVKvVNDU1ve7zAAAAAMBbke/XGGxugUXdaGhoyMKFC1Or1XL//fcfsrZhw4bs2bMnV199dYYOHZoDBw7krrvuylNPPXXIcb29vfnHf/zHnH/++f3ix4EDB/LlL3/5mL8PAAAAAAAGnytAqCsvv/xyWltb09jYmPXr12fEiBHZt29fZs2alZ6enmzevDkjR47MbbfdlgULFqSlpSXPPfdckqSnpydXXXVVNm/e3O+ZHz09Pdm2bVsWLVqUxYsXv6ZZFGoAAAAAeP18v8Zg8wwQ6sqoUaOyadOm3HjjjZk/f34mT56cp59+OnPmzMl1112XkSNHJvn980LGjh2b1tbWvr2LFi3Kd7/73STJE0880e/co0ePzhVXXHF83ggAAAAAAIPKFSBwGAo1AAAAALx+vl9jsHkGCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxhg32APDHuru7c/PNN6e9vT0TJ07M448/nvPOOy9Lly7N8OHDj7h/69ataWtry2mnnZbdu3fnt7/9bW644Yacc845x2F6AAAAAADqgQBCXenu7s68efNSq9WycePGVCqV7N27NzNnzsyWLVuyevXqNDQ0HHb/2rVrM2/evKxatSof+chHkiR33HFHWltb8+Mf/zhz5sw5Tu8EAAAAAIDB5BZY1JVly5Zl3bp1aWtrS6VSSZKMHj06bW1tWbNmTVauXHnYvbt3787f/u3f5s///M/74keSfPzjH8/06dPzyU9+Mi+99NKxfgsAAAAAANQBAYS60dXVlW984xtpbGzM+973vkPWLrjggowaNSpf+cpX0tPTM+D+W2+9NdVqNR/+8If7rV188cV5/vnn873vfe+YzA4AAAAAQH0RQKgb7e3tqVarmTp1ar/bXA0fPjxnnHFGOjs78/DDDw+4f926dUmS6dOn91s766yzkiT33HPPGzs0AAAAAAB1yTNAqBvbt29PkrS0tAy43tLSkp/97GfZunVrzj333KPaf/C1rVu3Hvbvd3V1paurq+/3arWaJKnVaq/xHQAAAAAABx38Xq23t3eQJ+GtSgChbuzatStJ0tjYOOD6mDFjkiQ7d+486v1H2psky5cvzw033NDv9UmTJr3K1AAAAADAq9m5c2eam5sHewzeggQQ6saRSvDQoUNf9bhX23+kvUmyZMmSXHvttX2/7969O3/yJ3+S//7v//YPaChMrVbLpEmT0tHRkaampsEeB3gD+XxDuXy+oVw+31CuarWat7/97Rk3btxgj8JblABC3Rg/fnySZO/evQOuH3z94HED7X/++ecH3H+kvUlSqVRSqVT6vd7c3Oz/gEGhmpqafL6hUD7fUC6fbyiXzzeU6+C/nAzHm//lUTemTp2aJNmxY8eA652dnUkGfsj5kfYfaS8AAAAAAGURQKgb5557bk466aQ89thj/W5VdeDAgTz66KM5+eSTM2PGjAH3f/CDH0ySbNu2rd/aI488kiS56KKL3uCpAQAAAACoRwIIdaOhoSELFy5MrVbL/ffff8jahg0bsmfPnlx99dUZOnRoDhw4kLvuuitPPfVU3zGXX3553va2t+U///M/+5377rvvTnNzcz75yU++5nkqlUr++Z//ecDbYgFvbj7fUC6fbyiXzzeUy+cbyuXzzWAb0nukJ0/DcfTyyy+ntbU1jY2NWb9+fUaMGJF9+/Zl1qxZ6enpyebNmzNy5MjcdtttWbBgQVpaWvLcc8/17f/BD36Qyy+/PPfcc0/fFSE//OEP87GPfSw/+MEPcumllw7WWwMAAAAA4DjyEHTqyqhRo7Jp06bceOONmT9/fiZPnpynn346c+bMyXXXXZeRI0cm+f3zPsaOHZvW1tZD9v+f//N/MmHChHz1q1/N3Xffnd7e3nR0dOQnP/lJ5syZMxhvCQAAAACAQeAKEAAAAAAAoDieAQIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQ6lZvb29WrVqVr33ta4M9CgAAAAAAbzICCHXnYPiYNm1aLr300mzduvWo9v/617/O5ZdfnmuuuSYLFizI+eefn7Vr1x6jaQEAAAAAqEcCCHXnscceyznnnJPPfe5zR733F7/4Rc4666zMmDEj3/zmN3Prrbfm+uuvz9y5c/P973//GEwLAAAAAEA9EkCoO+95z3syefLknH766Ue175VXXslHP/rRNDU15Zprrul7vbW1NR/5yEeycOHCPP/882/0uAAAAAAA1CEBhGLcddddeeaZZzJ37tw0NDQcsnbxxRfnpZdeysqVKwdpOgAAAAAAjicBhGKsW7cuSTJ9+vR+a2eddVaS5J577jmeIwEAAAAAMEgEEIqxffv2JElLS0u/tYOvPfHEE+nq6jqucwEAAAAAcPwNG+wB4I2ya9euJEljY2O/tTFjxiRJenp6snv37pxyyin9junq6jokjvT09GTXrl058cQTM2TIkGM0NQAAAACUqbe3Ny+++GJOPfXUDB3q38Xn+BNAKEZvb+9h1/7wH7CHO2758uW54YYb3vC5AAAAAOCtrKOjI6eddtpgj8FbkABCMcaPH58nn3wye/fu7bd28LWGhoaMGzduwP1LlizJtdde2/d7tVrN29/+9nR0dKSpqenYDA0AAAAAharVapk0aVLe9ra3DfYovEUJIBRj6tSpeeCBB7Jjx45+a52dnUmSKVOmZMSIEQPur1QqqVQq/V5vamoSQAAAAADgdXJ7eQaLG69RjA9+8INJkm3btvVbe+SRR5IkF1100XGdCQAAAACAwSGA8KZ177335uc//3nf73Pnzs073vGO3Hvvvf2e83H33Xdn2LBhWbRo0fEeEwAAAACAQSCAULdeeOGFJBnwmR5r167N3Llz09ramlqtliQZNmxYbr/99nR2duaWW27pO/ahhx7KqlWrsnz58px++unHZ3gAAAAAAAaVZ4BQd371q1/lRz/6UVasWJEkWb16da6//vq0trbm/PPPT5JMnjw5p556at75zndm9OjRfXvf+9735qc//Wna2trS3t6eUaNG5cknn8wdd9yRSy65ZFDeDwAAAAAAx9+Q3j++VxCQJKnVamlubk61WvUQdAAAAAA4Sr5fY7C5BRYAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcYYN9gDwx7q7u3PzzTenvb09EydOzOOPP57zzjsvS5cuzfDhw4+4f9WqVbnzzjszYcKE7N69O88//3wWL16c+fPnH4fpAQAAAACoBwIIdaW7uzvz5s1LrVbLxo0bU6lUsnfv3sycOTNbtmzJ6tWr09DQcNj9X/jCF3L33XfnoYceygknnJAk2bZtW/7iL/4iX//617NgwYLj9E4AAAAAABhMboFFXVm2bFnWrVuXtra2VCqVJMno0aPT1taWNWvWZOXKlYfd+9JLL2XFihX58Ic/3Bc/kmTatGl5//vfn1tuueVYjw8AAAAAQJ0QQKgbXV1d+cY3vpHGxsa8733vO2TtggsuyKhRo/KVr3wlPT09A+7ft29f9u/fn+3bt/db6+npyahRo47J3AAAAAAA1B8BhLrR3t6earWaqVOn9rvN1fDhw3PGGWeks7MzDz/88ID7TzzxxJx99tlZs2ZNvvOd7/S9/sQTT2T9+vVZvHjxMZ0fAAAAAID6IYBQNw5eudHS0jLg+sHXt27dethz3H777Rk3blw+/elP5/LLL88dd9yRT33qU1m1alUuu+yyV/37XV1dqdVqh/wAAAAAAPDmJIBQN3bt2pUkaWxsHHB9zJgxSZKdO3ce9hxnnnlmHnjggUyZMiXf+973ctlll+WSSy75/+39f5CXdaH//z/YFRdY2hX8BSLnlHXinQTqYJ7J5UCUmiZmB/NUk+kc3yXiOfLuh6bgJ9OW0RnrXaH9ksnje6b3KeU9NiklHglSxDyETYmA+euUBwXTgXi9XJFdXF7fP/zChLsIyI99+eR2m3mN7vW8ntc+r5kusdfd67py1lln7fT3X3/99Wltbd32GTly5Js4CwAAAAAA6oEAQt2o1WpvON7Q0LBL+73wwgsZOnRoLrzwwjQ0NOSyyy7L5MmT89JLL73hvBkzZqRSqWz7rF69evdOAAAAAACAuiGAUDcOP/zwJMnGjRt7Hd+6fet+vbn99ttz1lln5dZbb80tt9ySxYsX5x3veEfuvvvunHfeeW/4+5uamtLS0rLdBwAAAACAtyYBhLoxevToJMnatWt7HV+zZk2SZOzYsb2Od3R0ZOrUqZk8eXJGjRqVJGlra8uSJUsyfPjw3HXXXXn00Uf3wcoBAAAAAKg3Agh146STTsphhx2WlStX9njMVXd3d1asWJEjjjgi48aN63X+qlWrUqlUery746ijjsrUqVO37QMAAAAAQPkEEOpGY2NjLr744lSr1TzwwAPbjS1atCgdHR255JJL0tDQkO7u7txxxx158sknt+0zbNiwJMnTTz/d49itra1J4sXmAAAAAAAHiH61nb1RGvajV155JW1tbWlubs7ChQtz8MEHZ9OmTZkwYUK2bNmSJUuWZMCAAZkzZ06mTp2aESNG5Nlnn902f+rUqfm3f/u3LFq0KP/wD/+Q5LV3h4wfPz5HHnlk7r777vTr12+X1lKtVtPa2ppKpeJ9IAAAAACwm3y/Rl87qK8XAH9t4MCBWbx4cWbNmpUpU6bkmGOOyVNPPZVJkybl6quvzoABA5K89r6QIUOGpK2tbbv53//+9zN+/PjMnDkzRx99dA499NCsXr06F154YS666KJdjh8AAAAAALy1uQMEdkChBgAAAIA3z/dr9DXvAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQ7q6wXAvtbR0ZGlS5fmT3/6UyZOnJh3vetdfb0kAAAAAAD2MXeAUKxly5blzDPPzOmnn54NGzbkvPPOEz8AAAAAAA4Q7gCh7nR1deXGG2/MsmXLMnz48Dz22GM5+eSTM3PmzPTv33+XjnHNNdekvb09s2bNypVXXpl+/frt41UDAAAAAFBPBBDqSldXVyZPnpxqtZr7778/TU1N2bhxY8aPH5+lS5dm3rx5aWxsfMNjfP7zn8/s2bPzzW9+M1/4whf208oBAAAAAKgnHoFFXbnuuuuyYMGCtLe3p6mpKUkyaNCgtLe3Z/78+bnpppvecP5tt92W2bNn55RTThE/AAAAAAAOYP1qtVqtrxcBSdLZ2Zkjjzwyr776aiqVynZ3emzevDmtra0ZMmRIVq9enYaGnu2uq6sr7373u/PMM8/kvvvuy8SJE/doPdVqNa2tralUKmlpadmjYwEAAADAgcb3a/Q1d4BQN5YtW5ZKpZLRo0f3eMxV//79c+yxx2bNmjV5+OGHe51/77335plnnklra2ueeOKJjBs3Ls3NzRk2bFg+97nP5cUXX9wfpwEAAAAAQB0QQKgbq1atSpKMGDGi1/Gt25cvX97r+MKFC7f9/SGHHJJf/epX+eMf/5gLL7wwP/zhDzNhwoR0dHTs5VUDAAAAAFCPBBDqxvr165Mkzc3NvY4PHjw4SbJu3bpex5955pkkyYwZM3LuueempaUlRxxxRK677rqcffbZ+cMf/pDvfve7O/z9nZ2dqVar230AAAAAAHhrEkCoGzt7Hc3W937saL+tweK4447rMfbpT386STJ//vwdHv/6669Pa2vrts/IkSN3ad0AAAAAANQfAYS6cfjhhydJNm7c2Ov41u1b93u91tbWHR571KhRSZI1a9bscJ8ZM2akUqls+6xevXqX1g0AAAAAQP0RQKgbo0ePTpKsXbu21/Gt8WLs2LG9jr/3ve/d4fyBAwdu99feNDU1paWlZbsPAAAAAABvTQIIdeOkk07KYYcdlpUrV/Z4zFV3d3dWrFiRI444IuPGjet1/umnn54k+d3vftdj7MUXX0yy43gCAAAAAEBZBBDqRmNjYy6++OJUq9U88MAD240tWrQoHR0dueSSS9LQ0JDu7u7ccccdefLJJ7ft8/73vz8nnnhifvrTn2bz5s3bzX/ooYeSJBdccMG+PxEAAAAAAPpcv9rO3jwN+9Err7yStra2NDc3Z+HChTn44IOzadOmTJgwIVu2bMmSJUsyYMCAzJkzJ1OnTs2IESPy7LPPbpv/yCOPZPz48Zk2bVpuuOGGJMlLL72UE044Iaeddlq+973v7fJaqtVqWltbU6lUPA4LAAAAAHaT79foawf19QLgrw0cODCLFy/OrFmzMmXKlBxzzDF56qmnMmnSpFx99dUZMGBAktfeFzJkyJC0tbVtN/+4447L0qVL85WvfCVnnHFG3v72t2ft2rW5/PLLc9FFF/XFKQEAAAAA0AfcAQI7oFADAAAAwJvn+zX6mneAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAELxpk2blg984AN9vQwAAAAAAPajg/p6AfB6XV1dufHGG7Ns2bIMHz48jz32WE4++eTMnDkz/fv3361j/fznP88PfvCDTJw4cR+tFgAAAACAeiSAUFe6uroyefLkVKvV3H///WlqasrGjRszfvz4LF26NPPmzUtjY+MuHevPf/5zbrrppn28YgAAAAAA6pFHYFFXrrvuuixYsCDt7e1pampKkgwaNCjt7e2ZP3/+bgWNSy65JN/61rf21VIBAAAAAKhj/Wq1Wq2vFwFJ0tnZmSOPPDKvvvpqKpXKdnd6bN68Oa2trRkyZEhWr16dhoY3bnff+c53smXLlkyfPj39+vXLxIkTc9999+3WeqrValpbW1OpVNLS0vJmTgkAAAAADli+X6OvuQOEurFs2bJUKpWMHj26x2Ou+vfvn2OPPTZr1qzJww8//IbHWbVqVX75y1/m0ksv3ZfLBQAAAACgjgkg1I1Vq1YlSUaMGNHr+Nbty5cv3+Exurq6Mn369Hzve99Lv379duv3d3Z2plqtbvcBAAAAAOCtSQChbqxfvz5J0tzc3Ov44MGDkyTr1q3b4TFmzpyZadOm5aijjtrt33/99dentbV122fkyJG7fQwAAAAAAOqDAELd2NnraLa+92NH+y1cuDDr16/POeec86Z+/4wZM1KpVLZ9Vq9e/aaOAwAAAABA3zuorxcAWx1++OFJko0bN/Y6vnX71v3+2l/+8pdcccUV+clPfpLnn3++x3hXV9e27cOGDev1+E1NTWlqanpTawcAAAAAoL4IINSN0aNHJ0nWrl3b6/iaNWuSJGPHju0x9sgjj+S3v/1t3v3ud/c696GHHsrw4cOT7PxOEwAAAAAA3voEEOrGSSedlMMOOywrV65MrVbb7iXm3d3dWbFiRY444oiMGzeux9yxY8dm/vz5vR73jDPOyJgxY3LDDTfss7UDAAAAAFBfBBDqRmNjYy6++OLMmjUrDzzwQCZMmLBtbNGiReno6Mhll12WhoaGdHd352c/+1nGjh2bv/u7v8vQoUNz+umn7/DYOxsHAAAAAKAs/WqeB0QdeeWVV9LW1pbm5uYsXLgwBx98cDZt2pQJEyZky5YtWbJkSQYMGJA5c+Zk6tSpGTFiRJ599tk3PGa/fv0yceLE3Hfffbu1lmq1mtbW1lQqlbS0tOzBWQEAAADAgcf3a/S1hr5eAPy1gQMHZvHixWlra8uUKVMyffr0TJkyJZMmTcr999+fAQMGJHntfSFDhgxJW1tbH68YAAAAAIB65A4Q2AGFGgAAAADePN+v0dfcAQIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIdaerqyvf+MY38olPfCKf//zn8+EPfzjXXnttNm/evNO53d3dueGGG/Ke97wnTU1NGTp0aP7xH/8xK1as2A8rBwAAAACgXvSr1Wq1vl4EbNXV1ZXJkyenWq3m/vvvT1NTUzZu3Jjx48dn2LBhmTdvXhobG3c4/7Of/WzuueeenHzyyXnllVfy0EMPZd26dRk8eHB+/etfZ8yYMbu8lmq1mtbW1lQqlbS0tOyN0wMAAACAA4bv1+hr7gChrlx33XVZsGBB2tvb09TUlCQZNGhQ2tvbM3/+/Nx00007nHvvvffmz3/+c55++unMnTs38+bNy1NPPZWJEyemo6Mj11xzzX46CwAAAAAA+po7QKgbnZ2dOfLII/Pqq6+mUqlsd6fH5s2b09ramiFDhmT16tVpaOjZ7v7lX/4lX/va13LooYdut/33v/99TjjhhIwaNSp/+MMfdnk9CjUAAAAAvHm+X6OvuQOEurFs2bJUKpWMHj26x2Ou+vfvn2OPPTZr1qzJww8/3Ov8K6+8skf8SJJRo0YlSY4++ui9v2gAAAAAAOqSAELdWLVqVZJkxIgRvY5v3b58+fJex0eOHNnr9ueffz5Jcu655+7pEgEAAAAAeIs4qK8XAFutX78+SdLc3Nzr+ODBg5Mk69at263j3nXXXXnPe96TCy644A336+zsTGdn57afq9Xqbv0eAAAAAADqhztAqBs7ex3N1vd+7M5ra6rVaubMmZMf//jHGTBgwBvue/3116e1tXXbZ0d3lAAAAAAAUP8EEOrG4YcfniTZuHFjr+Nbt2/db2dqtVouvfTSzJ49O8cff/xO958xY0Yqlcq2z+rVq3dt4QAAAAAA1B2PwKJujB49Okmydu3aXsfXrFmTJBk7duwuHe+yyy7LJz/5yZxyyim7tH9TU1Oampp2aV8AAAAAAOpbv9ruPE8I9qHu7u4MGzYsXV1d2bBhQ/r167fd2CGHHJJBgwZl7dq12x6HtSNXXHFFPvShD+W000570+upVqtpbW1NpVJJS0vLmz4OAAAAAByIfL9GX/MILOpGY2NjLr744lSr1TzwwAPbjS1atCgdHR255JJL0tDQkO7u7txxxx158sknt9uvVqvlS1/6Uk499dQe8aO7uztXXXXVPj8PAAAAAAD6njtAqCuvvPJK2tra0tzcnIULF+bggw/Opk2bMmHChGzZsiVLlizJgAEDMmfOnEydOjUjRozIs88+myTZsmVLLrrooixZsqTHOz+2bNmSRx99NNOmTcv06dN3aS0KNQAAAAC8eb5fo695Bwh1ZeDAgVm8eHFmzZqVKVOm5JhjjslTTz2VSZMm5eqrr86AAQOSvPa+kCFDhqStrW3b3GnTpuWWW25Jkjz++OM9jj1o0KBccMEF++dEAAAAAADoU+4AgR1QqAEAAADgzfP9Gn3NO0AAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAinNQXy8AXq+rqys33nhjli1bluHDh+exxx7LySefnJkzZ6Z///47nb98+fK0t7fn6KOPzoYNG/LCCy/k2muvzYknnrgfVg8AAAAAQD0QQKgrXV1dmTx5cqrVau6///40NTVl48aNGT9+fJYuXZp58+alsbFxh/PvvffeTJ48OXPnzs3HPvaxJMltt92Wtra23HPPPZk0adJ+OhMAAAAAAPqSR2BRV6677rosWLAg7e3taWpqSpIMGjQo7e3tmT9/fm666aYdzt2wYUP+6Z/+Ke973/u2xY8k+eQnP5mxY8fmM5/5TF5++eV9fQoAAAAAANQBAYS60dnZmW9/+9tpbm7OBz/4we3GTjvttAwcODBf//rXs2XLll7n33zzzalUKvnoRz/aY+zss8/Oc889lx/96Ef7ZO0AAAAAANQXAYS6sWzZslQqlYwePbrHY6769++fY489NmvWrMnDDz/c6/wFCxYkScaOHdtj7Pjjj0+S3HXXXXt30QAAAAAA1CUBhLqxatWqJMmIESN6Hd+6ffny5bs9f2dzAQAAAAAoi5egUzfWr1+fJGlubu51fPDgwUmSdevW7fb8nc1NXnsEV2dn57afK5VKkqRare5s6QAAAADA62z9Xq1Wq/XxSjhQCSDUjZ39g7ChoeEN93uj+TubmyTXX399rr322h7bR44c+YbrAgAAAAB2bN26dWltbe3rZXAAEkCoG4cffniSZOPGjb2Ob92+db/e5j/33HO9zt/Z3CSZMWNGvvjFL277ecOGDfnbv/3b/Pd//7d/QENhqtVqRo4cmdWrV6elpaWvlwPsRa5vKJfrG8rl+oZyVSqV/M3f/E2GDh3a10vhACWAUDdGjx6dJFm7dm2v42vWrEnS+0vOt85/7rnnsnbt2owZM2a35iZJU1NTmpqaemxvbW31L2BQqJaWFtc3FMr1DeVyfUO5XN9Qrq1PZ4H9zf/yqBsnnXRSDjvssKxcubLHo6q6u7uzYsWKHHHEERk3blyv8z/ykY8kSR599NEeY4888kiS5IwzztjLqwYAAAAAoB4JINSNxsbGXHzxxalWq3nggQe2G1u0aFE6OjpyySWXpKGhId3d3bnjjjvy5JNPbtvn/PPPz9ve9rb84he/6HHsO++8M62trfnMZz6zz88DAAAAAIC+J4BQV2bOnJkTTjghV111Vbq6upIkmzZtylVXXZVx48bliiuuSJLccsst+fjHP55JkyZtmztkyJD84Ac/yOLFi3P33Xdv2/7Tn/40//mf/5mbb755t97l0dTUlK9+9au9PhYLeGtzfUO5XN9QLtc3lMv1DeVyfdPX+tVe/6wh6GMdHR2ZNWtWVqxYkWOOOSZPPfVUxowZk6uvvjrNzc1JkgcffDBnnXVWTj311Nx+++3bzV+0aFG+8Y1vZOTIkanValm9enW+/OUvbxdLAAAAAAAomwACAAAAAAAUxyOwAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAKFu1Wq1zJ07N9/85jf7eikAAAAAALzFCCDUna3hY8yYMfnEJz6R5cuX79b8P/3pTzn//PPzr//6r5k6dWpOPfXU3HvvvftotQAAAAAA1CMBhLqzcuXKnHjiifnCF76w23N///vf5/jjj8+4cePyne98JzfffHOuueaanHnmmfm///f/7oPVAgAAAABQjwQQ6s573/veHHPMMXnnO9+5W/NeffXVfPzjH09LS0v+9V//ddv2tra2fOxjH8vFF1+c5557bm8vFwAAAACAOiSAUIw77rgjTz/9dM4888w0NjZuN3b22Wfn5Zdfzk033dRHqwMAAAAAYH8SQCjGggULkiRjx47tMXb88ccnSe666679uSQAAAAAAPrIQX29ANhbVq1alSQZMWJEj7Gt2x5//PF0dnamqampxz6dnZ3p7Ozc9vOWLVuyfv36HHrooenXr98+WjUAAAAAlKlWq+Wll17KUUcdlYYG/y0++58AQjHWr1+fJGlubu4xNnjw4CSvRY0NGzbkyCOP7LHP9ddfn2uvvXbfLhIAAAAADjCrV6/O0Ucf3dfL4AAkgFCMWq22w7G/Lsw72m/GjBn54he/uO3nSqWSv/mbv8nq1avT0tKy9xYKAAAAAAeAarWakSNH5m1ve1tfL4UDlABCMQ4//PA88cQT2bhxY4+xrdsaGxszdOjQXuc3NTX1+mislpYWAQQAAAAA3iSPl6evePAaxRg9enSSZO3atT3G1qxZkyQZNWpUDj744P26LgAAAAAA9j8BhGJ85CMfSZI8+uijPcYeeeSRJMkZZ5yxX9cEAAAAAEDfEEB4y7r77rvzu9/9btvPZ555Zt7+9rfn7rvv7vGejzvvvDMHHXRQpk2btr+XCQAAAABAHxBAqFvPP/98kvT6To977703Z555Ztra2lKtVpMkBx10UG699dasWbMm3//+97ft+5vf/CZz587N9ddfn3e+8537Z/EAAAAAAPQpL0Gn7vzxj3/Mz372s8yePTtJMm/evFxzzTVpa2vLqaeemiQ55phjctRRR+Ud73hHBg0atG3uBz7wgfz6179Oe3t7li1bloEDB+aJJ57IbbfdlnPOOadPzgcAAAAAgP2vX+31zwoCkiTVajWtra2pVCppaWnp6+UAAAAAwFuK79foax6BBQAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4B/X1AuD1urq6cuONN2bZsmUZPnx4HnvssZx88smZOXNm+vfvv9P5c+fOze23355hw4Zlw4YNee655zJ9+vRMmTJlP6weAAAAAIB6IIBQV7q6ujJ58uRUq9Xcf//9aWpqysaNGzN+/PgsXbo08+bNS2Nj4w7nX3755bnzzjvzm9/8JoccckiS5NFHH83f//3f51vf+lamTp26n84EAAAAAIC+5BFY1JXrrrsuCxYsSHt7e5qampIkgwYNSnt7e+bPn5+bbrpph3NffvnlzJ49Ox/96Ee3xY8kGTNmTD70oQ/l+9///r5ePgAAAAAAdUIAoW50dnbm29/+dpqbm/PBD35wu7HTTjstAwcOzNe//vVs2bKl1/mbNm3K5s2bs2rVqh5jW7ZsycCBA/fJugEAAAAAqD8CCHVj2bJlqVQqGT16dI/HXPXv3z/HHnts1qxZk4cffrjX+YceemhOOOGEzJ8/Pz/84Q+3bX/88cezcOHCTJ8+fZ+uHwAAAACA+iGAUDe23rkxYsSIXse3bl++fPkOj3Hrrbdm6NCh+dznPpfzzz8/t912W/75n/85c+fOzac+9am9v2gAAAAAAOqSAELdWL9+fZKkubm51/HBgwcnSdatW7fDYxx33HF58MEHM2rUqPzoRz/Kpz71qZxzzjk566yzdvr7Ozs7U61Wt/sAAAAAAPDWJIBQN2q12huONzQ07NJ+L7zwQoYOHZoLL7wwDQ0NueyyyzJ58uS89NJLbzjv+uuvT2tr67bPyJEjd+8EAAAAAACoGwIIdePwww9PkmzcuLHX8a3bt+7Xm9tvvz1nnXVWbr311txyyy1ZvHhx3vGOd+Tuu+/Oeeed94a/f8aMGalUKts+q1evfpNnAgAAAABAXxNAqBujR49Okqxdu7bX8TVr1iRJxo4d2+t4R0dHpk6dmsmTJ2fUqFFJkra2tixZsiTDhw/PXXfdlUcffXSHv7+pqSktLS3bfQAAAAAAeGsSQKgbJ510Ug477LCsXLmyx2Ouuru7s2LFihxxxBEZN25cr/NXrVqVSqXS49FVRx11VKZOnbptHwAAAAAAyieAUDcaGxtz8cUXp1qt5oEHHthubNGiReno6Mgll1yShoaGdHd354477siTTz65bZ9hw4YlSZ5++ukex25tbU0S7/UAAAAAADhA9Kvt7I3SsB+98soraWtrS3NzcxYuXJiDDz44mzZtyoQJE7Jly5YsWbIkAwYMyJw5czJ16tSMGDEizz777Lb5U6dOzb/9279l0aJF+Yd/+Ickr707ZPz48TnyyCNz9913p1+/fru0lmq1mtbW1lQqFY/DAgAAAIDd5Ps1+tpBfb0A+GsDBw7M4sWLM2vWrEyZMiXHHHNMnnrqqUyaNClXX311BgwYkOS194UMGTIkbW1t283//ve/n/Hjx2fmzJk5+uijc+ihh2b16tW58MILc9FFF+1y/AAAAAAA4K3NHSCwAwo1AAAAALx5vl+jr3kHCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFOaivFwD7WkdHR5YuXZo//elPmThxYt71rnf19ZIAAAAAANjH3AFCsZYtW5Yzzzwzp59+ejZs2JDzzjtP/AAAAAAAOEC4A4S609XVlRtvvDHLli3L8OHD89hjj+Xkk0/OzJkz079//106xjXXXJP29vbMmjUrV155Zfr167ePVw0AAAAAQD0RQKgrXV1dmTx5cqrVau6///40NTVl48aNGT9+fJYuXZp58+alsbHxDY/x+c9/PrNnz843v/nNfOELX9hPKwcAAAAAoJ54BBZ15brrrsuCBQvS3t6epqamJMmgQYPS3t6e+fPn56abbnrD+bfddltmz56dU045RfwAAAAAADiA9avVarW+XgQkSWdnZ4488si8+uqrqVQq293psXnz5rS2tmbIkCFZvXp1Ghp6truurq68+93vzjPPPJP77rsvEydO3KP1VKvVtLa2plKppKWlZY+OBQAAAAAHGt+v0dfcAULdWLZsWSqVSkaPHt3jMVf9+/fPsccemzVr1uThhx/udf69996bZ555Jq2trXniiScybty4NDc3Z9iwYfnc5z6XF198cX+cBgAAAAAAdUAAoW6sWrUqSTJixIhex7duX758ea/jCxcu3Pb3hxxySH71q1/lj3/8Yy688ML88Ic/zIQJE9LR0bHD39/Z2ZlqtbrdBwAAAACAtyYBhLqxfv36JElzc3Ov44MHD06SrFu3rtfxZ555JkkyY8aMnHvuuWlpackRRxyR6667LmeffXb+8Ic/5Lvf/e4Of//111+f1tbWbZ+RI0fuyekAAAAAANCHBBDqxs5eR7P1vR872m/rHRvHHXdcj7FPf/rTSZL58+fv8PgzZsxIpVLZ9lm9evUurRsAAAAAgPpzUF8vALY6/PDDkyQbN27sdXzr9q37vV5ra+sOjz1q1KgkyZo1a3a4T1NTU5qamnZprQAAAAAA1Dd3gFA3Ro8enSRZu3Ztr+Nb48XYsWN7HX/ve9+7w/kDBw7c7q8AAAAAAJRNAKFunHTSSTnssMOycuXKHo+56u7uzooVK3LEEUdk3Lhxvc4//fTTkyS/+93veoy9+OKLSXYcTwAAAAAAKIsAQt1obGzMxRdfnGq1mgceeGC7sUWLFqWjoyOXXHJJGhoa0t3dnTvuuCNPPvnktn3e//7358QTT8xPf/rTbN68ebv5Dz30UJLkggsu2PcnAgAAAABAn+tX29mbp2E/euWVV9LW1pbm5uYsXLgwBx98cDZt2pQJEyZky5YtWbJkSQYMGJA5c+Zk6tSpGTFiRJ599tlt8x955JGMHz8+06ZNyw033JAkeemll3LCCSfktNNOy/e+971dXku1Wk1ra2sqlUpaWlr2+rkCAAAAQMl8v0Zf8xJ06srAgQOzePHizJo1K1OmTMkxxxyTp556KpMmTcrVV1+dAQMGJHntfSFDhgxJW1vbdvOPO+64LF26NF/5yldyxhln5O1vf3vWrl2byy+/PBdddFFfnBIAAAAAAH3AHSCwAwo1AAAAALx5vl+jr3kHCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAo3rRp0/KBD3ygr5cBAAAAAMB+dFBfLwBer6urKzfeeGOWLVuW4cOH57HHHsvJJ5+cmTNnpn///rt1rJ///Of5wQ9+kIkTJ+6j1QIAAAAAUI8EEOpKV1dXJk+enGq1mvvvvz9NTU3ZuHFjxo8fn6VLl2bevHlpbGzcpWP9+c9/zk033bSPVwwAAAAAQD3yCCzqynXXXZcFCxakvb09TU1NSZJBgwalvb098+fP362gcckll+Rb3/rWvloqAAAAAAB1rF+tVqv19SIgSTo7O3PkkUfm1VdfTaVS2e5Oj82bN6e1tTVDhgzJ6tWr09Dwxu3uO9/5TrZs2ZLp06enX79+mThxYu67777dWk+1Wk1ra2sqlUpaWlrezCkBAAAAwAHL92v0NXeAUDeWLVuWSqWS0aNH93jMVf/+/XPsscdmzZo1efjhh9/wOKtWrcovf/nLXHrppftyuQAAAAAA1DEBhLqxatWqJMmIESN6Hd+6ffny5Ts8RldXV6ZPn57vfe976dev395fJAAAAAAAbwlegk7dWL9+fZKkubm51/HBgwcnSdatW7fDY8ycOTPTpk3LUUcdtdu/v7OzM52dndt+rlaru30MAAAAAADqgztAqBs7ex3N1vd+7Gi/hQsXZv369TnnnHPe1O+//vrr09rauu0zcuTIN3UcAAAAAAD6njtAqBuHH354kmTjxo29jm/dvnW/v/aXv/wlV1xxRX7yk5/k+eef7zHe1dW1bfuwYcN6Pf6MGTPyxS9+cdvP1WpVBAEAAAAAeIsSQKgbo0ePTpKsXbu21/E1a9YkScaOHdtj7JFHHslvf/vbvPvd7+517kMPPZThw4cn2fEdJE1NTWlqatrtdQMAAAAAUH8EEOrGSSedlMMOOywrV65MrVbb7iXm3d3dWbFiRY444oiMGzeux9yxY8dm/vz5vR73jDPOyJgxY3LDDTfss7UDAAAAAFBfBBDqRmNjYy6++OLMmjUrDzzwQCZMmLBtbNGiReno6Mhll12WhoaGdHd352c/+1nGjh2bv/u7v8vQoUNz+umn7/DYOxsHAAAAAKAs/Wo7e/M07EevvPJK2tra0tzcnIULF+bggw/Opk2bMmHChGzZsiVLlizJgAEDMmfOnEydOjUjRozIs88++4bH7NevXyZOnJj77rtvt9ZSrVbT2tqaSqWSlpaWPTgrAAAAADjw+H6NvtbQ1wuAvzZw4MAsXrw4bW1tmTJlSqZPn54pU6Zk0qRJuf/++zNgwIAkr70vZMiQIWlra+vjFQMAAAAAUI/cAQI7oFADAAAAwJvn+zX6mjtAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgFB3urq68o1vfCOf+MQn8vnPfz4f/vCHc+2112bz5s07ndvd3Z0bbrgh73nPe9LU1JShQ4fmH//xH7NixYr9sHIAAAAAAOpFv1qtVuvrRcBWXV1dmTx5cqrVau6///40NTVl48aNGT9+fIYNG5Z58+alsbFxh/M/+9nP5p577snJJ5+cV155JQ899FDWrVuXwYMH59e//nXGjBmzy2upVqtpbW1NpVJJS0vL3jg9AAAAADhg+H6NvuYOEOrKddddlwULFqS9vT1NTU1JkkGDBqW9vT3z58/PTTfdtMO59957b/785z/n6aefzty5czNv3rw89dRTmThxYjo6OnLNNdfsp7MAAAAAAKCvuQOEutHZ2Zkjjzwyr776aiqVynZ3emzevDmtra0ZMmRIVq9enYaGnu3uX/7lX/K1r30thx566Hbbf//73+eEE07IqFGj8oc//GGX16NQAwAAAMCb5/s1+po7QKgby5YtS6VSyejRo3s85qp///459thjs2bNmjz88MO9zr/yyit7xI8kGTVqVJLk6KOP3vuLBgAAAACgLgkg1I1Vq1YlSUaMGNHr+Nbty5cv73V85MiRvW5//vnnkyTnnnvuG/7+zs7OVKvV7T4AAAAAALw1CSDUjfXr1ydJmpubex0fPHhwkmTdunW7ddy77ror73nPe3LBBRe84X7XX399Wltbt312FFQAAAAAAKh/Agh1Y2evo9n63o/deW1NtVrNnDlz8uMf/zgDBgx4w31nzJiRSqWy7bN69epd/j0AAAAAANSXg/p6AbDV4YcfniTZuHFjr+Nbt2/db2dqtVouvfTSzJ49O8cff/xO929qakpTU9OuLRYAAAAAgLrmDhDqxujRo5Mka9eu7XV8zZo1SZKxY8fu0vEuu+yyfPKTn8wpp5yydxYIAAAAAMBbRr/a7jxPCPah7u7uDBs2LF1dXdmwYUP69eu33dghhxySQYMGZe3atdseh7UjV1xxRT70oQ/ltNNOe9PrqVaraW1tTaVSSUtLy5s+DgAAAAAciHy/Rl9zBwh1o7GxMRdffHGq1WoeeOCB7cYWLVqUjo6OXHLJJWloaEh3d3fuuOOOPPnkk9vtV6vV8qUvfSmnnnpqj/jR3d2dq666ap+fBwAAAAAAfc8dINSVV155JW1tbWlubs7ChQtz8MEHZ9OmTZkwYUK2bNmSJUuWZMCAAZkzZ06mTp2aESNG5Nlnn02SbNmyJRdddFGWLFnS450fW7ZsyaOPPppp06Zl+vTpu7QWhRoAAAAA3jzfr9HXvASdujJw4MAsXrw4s2bNypQpU3LMMcfkqaeeyqRJk3L11VdnwIABSV57X8iQIUPS1ta2be60adNyyy23JEkef/zxHsceNGhQLrjggv1zIgAAAAAA9Cl3gMAOKNQAAAAA8Ob5fo2+5h0gAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIpzUF8vAF6vq6srN954Y5YtW5bhw4fnsccey8knn5yZM2emf//+O52/fPnytLe35+ijj86GDRvywgsv5Nprr82JJ564H1YPAAAAAEA9EECoK11dXZk8eXKq1Wruv//+NDU1ZePGjRk/fnyWLl2aefPmpbGxcYfz77333kyePDlz587Nxz72sSTJbbfdlra2ttxzzz2ZNGnSfjoTAAAAAAD6kkdgUVeuu+66LFiwIO3t7WlqakqSDBo0KO3t7Zk/f35uuummHc7dsGFD/umf/inve9/7tsWPJPnkJz+ZsWPH5jOf+UxefvnlfX0KAAAAAADUAQGEutHZ2Zlvf/vbaW5uzgc/+MHtxk477bQMHDgwX//617Nly5Ze5998882pVCr56Ec/2mPs7LPPznPPPZcf/ehH+2TtAAAAAADUFwGEurFs2bJUKpWMHj26x2Ou+vfvn2OPPTZr1qzJww8/3Ov8BQsWJEnGjh3bY+z4449Pktx11117d9EAAAAAANQlAYS6sWrVqiTJiBEjeh3fun358uW7PX9ncwEAAAAAKIuXoFM31q9fnyRpbm7udXzw4MFJknXr1u32/J3NTV57BFdnZ+e2nyuVSpKkWq3ubOkAAAAAwOts/V6tVqv18Uo4UAkg1I2d/YOwoaHhDfd7o/k7m5sk119/fa699toe20eOHPmG6wIAAAAAdmzdunVpbW3t62VwABJAqBuHH354kmTjxo29jm/dvnW/3uY/99xzvc7f2dwkmTFjRr74xS9u+3nDhg3527/92/z3f/+3f0BDYarVakaOHJnVq1enpaWlr5cD7EWubyiX6xvK5fqGclUqlfzN3/xNhg4d2tdL4QAlgFA3Ro8enSRZu3Ztr+Nr1qxJ0vtLzrfOf+6557J27dqMGTNmt+YmSVNTU5qamnpsb21t9S9gUKiWlhbXNxTK9Q3lcn1DuVzfUK6tT2eB/c3/8qgbJ510Ug477LCsXLmyx6Oquru7s2LFihxxxBEZN25cr/M/8pGPJEkeffTRHmOPPPJIkuSMM87Yy6sGAAAAAKAeCSDUjcbGxlx88cWpVqt54IEHthtbtGhROjo6cskll6ShoSHd3d2544478uSTT27b5/zzz8/b3va2/OIXv+hx7DvvvDOtra35zGc+s8/PAwAAAACAvieAUFdmzpyZE044IVdddVW6urqSJJs2bcpVV12VcePG5YorrkiS3HLLLfn4xz+eSZMmbZs7ZMiQ/OAHP8jixYtz9913b9v+05/+NP/5n/+Zm2++ebfe5dHU1JSvfvWrvT4WC3hrc31DuVzfUC7XN5TL9Q3lcn3T1/rVXv+sIehjHR0dmTVrVlasWJFjjjkmTz31VMaMGZOrr746zc3NSZIHH3wwZ511Vk499dTcfvvt281ftGhRvvGNb2TkyJGp1WpZvXp1vvzlL28XSwAAAAAAKJsAAgAAAAAAFOegvl4AAAAA7C0dHR1ZunRp/vSnP2XixIl517ve1ddLAgCgj3gHCAAAB5xp06blAx/4QF8vA9iLli1bljPPPDOnn356NmzYkPPOO0/8AIB9rFarZe7cufnmN7/Z10uBXrkDhANOV1dXbrzxxixbtizDhw/PY489lpNPPjkzZ85M//79dzp/+fLlaW9vz9FHH50NGzbkhRdeyLXXXpsTTzxxP6weeCN7cn13d3fnf//v/51bb701//Vf/5Xm5uZMnDgx7e3tee9737ufzgDYkT398/uv/fznP88PfvCDTJw4cR+tFtgde+P6vuaaa9Le3p5Zs2blyiuvTL9+/fbxqoFdsafX99y5c3P77bdn2LBh2bBhQ5577rlMnz49U6ZM2Q+rB95IrVbL//t//y9f+9rXsnLlylxwwQW7Nf9Pf/pTrr766rS0tGTz5s35r//6r1x++eU57bTT9tGKOVAJIBxQurq6Mnny5FSr1dx///1pamrKxo0bM378+CxdujTz5s1LY2PjDuffe++9mTx5cubOnZuPfexjSZLbbrstbW1tueeee7xoHfrQnl7fU6dOzT333JOTTz4573rXu/LQQw/lZz/7WX75y1/m17/+dcaMGbMfzwb4a3t6ff+1P//5z7npppv28YqBXbU3ru/Pf/7zmT17dr75zW/mC1/4wn5aObAze3p9X3755bnzzjvzm9/8JoccckiS5NFHH83f//3f51vf+lamTp26n84E6M3KlStz4okn5gtf+EI++9nP7tbc3//+9/nABz6Qa6+9Nv/rf/2vJMmDDz6YD3zgA7n11ltz3nnn7Yslc6CqwQHkq1/9ai1J7d57791u+89//vNaktq3vvWtHc79y1/+Umttba2dfPLJPcZOPPHE2ogRI2odHR17e8nALtqT6/s//uM/apMnT65t2rRp27a//OUvtYkTJ9aS1KZMmbKvlg3sgj25vl9vypQptZUrV9aS1CZOnLh3Fwrstj29vn/yk5/UktROOeWUfbhK4M3Yk+u7o6Oj1r9//9qXvvSlHmOTJ0+uHXfccXt5tcCb9atf/aqWpHbBBRfs0v6bN2+uvfOd76yNHDmy9uqrr2439vGPf7zW3Nxce/bZZ/fBSjlQeQcIB4zOzs58+9vfTnNzcz74wQ9uN3baaadl4MCB+frXv54tW7b0Ov/mm29OpVLJRz/60R5jZ599dp577rn86Ec/2idrB97Ynl7fd955Z/7P//k/aWpq2rbtkEMOybe//e0kr/2XLUDf2NPr+6995zvfycSJE3Psscfuq+UCu2FPr++urq5ceeWVSZL/7//7//b5eoFdt6fX96ZNm7J58+asWrWqx9iWLVsycODAfbJuYN+744478vTTT+fMM8/scRfY2WefnZdfftkd2+xVAggHjGXLlqVSqWT06NE9/gHbv3//HHvssVmzZk0efvjhXucvWLAgSTJ27NgeY8cff3yS5K677tq7iwZ2yZ5e31deeWUOPfTQHttHjRqVJDn66KP3/qKBXbKn1/dWq1atyi9/+ctceuml+3K5wG7Y0+v73nvvzTPPPJPW1tY88cQTGTduXJqbmzNs2LB87nOfy4svvrg/TgPoxZ5e34ceemhOOOGEzJ8/Pz/84Q+3bX/88cezcOHCTJ8+fZ+uH9h3fL/G/iaAcMDY+l+OjBgxotfxrduXL1++2/N3NhfYt/b0+h45cmSv259//vkkybnnnrunSwTepD29vpPX/ivx6dOn53vf+54XI0Md2dPre+HChdv+/pBDDsmvfvWr/PGPf8yFF16YH/7wh5kwYUI6Ojr28qqBXbE3/vy+9dZbM3To0Hzuc5/L+eefn9tuuy3//M//nLlz5+ZTn/rU3l80sF/syvdrjz/+eDo7O/fruiiXAMIBY/369UmS5ubmXscHDx6cJFm3bt1uz9/ZXGDf2tPre0fuuuuuvOc978kFF1ywZwsE3rS9cX3PnDkz06ZNy1FHHbX3Fwi8aXt6fT/zzDNJkhkzZuTcc89NS0tLjjjiiFx33XU5++yz84c//CHf/e5398HKgZ3ZG39+H3fccXnwwQczatSo/OhHP8qnPvWpnHPOOTnrrLP2/oKB/WZXvl/bsmVLNmzYsD+XRcEEEA4YtVrtDccbGhrecL83mr+zucC+tafXd2+q1WrmzJmTH//4xxkwYMAerQ948/b0+l64cGHWr1+fc845Z6+vDdgze3p9V6vVJK99Sfp6n/70p5Mk8+fP35MlAm/S3vr38xdeeCFDhw7NhRdemIaGhlx22WWZPHlyXnrppb22VmD/2pXv13a2H+wOAYQDxuGHH54k2bhxY6/jW7dv3W935u9sLrBv7en1/Xq1Wi2XXnppZs+eve0ZpEDf2JPr+y9/+UuuuOKKzJgxI88///x2n+S1R2P99c/A/rWnf363trbu8Nhb3+O1Zs2aPVki8CbtjX8/v/3223PWWWfl1ltvzS233JLFixfnHe94R+6+++6cd955e3/RwH6xK9+vNTY2ZujQoft1XZRLAOGAMXr06CTJ2rVrex3f+n+OensJ087m72wusG/t6fX9epdddlk++clP5pRTTtk7CwTetD25vh955JH89re/zbvf/e4MHz58u0+SPPTQQ9v9DOxfe/rn93vf+94dzh84cOB2fwX2rz29vjs6OjJ16tRMnjx5W9Bsa2vLkiVLMnz48Nx111159NFH98HKgX1tV75fGzVqVA4++OD9ui7KJYBwwDjppJNy2GGHZeXKlT1uo+vu7s6KFStyxBFHZNy4cb3O/8hHPpIkvf5L1iOPPJIkOeOMM/byqoFdsafX91+74oor8uEPf9j1DHViT67vsWPHZv78+b1+kmTMmDHb/QzsX3v65/fpp5+eJPnd737XY+zFF19M4j9Qgr6yp9f3qlWrUqlUMnLkyO22H3XUUZk6deq2fYC3Ht+vsb8JIBwwGhsbc/HFF6dareaBBx7YbmzRokXp6OjIJZdckoaGhnR3d+eOO+7Ik08+uW2f888/P29729vyi1/8osex77zzzrS2tuYzn/nMPj8PoKc9vb6T1x579aUvfSmnnnpqTjvttO3Guru7c9VVV+3z8wB62pPre+jQoTn99NN7/bx+HNj/9vTP7/e///058cQT89Of/jSbN2/ebv5DDz2UJLngggv2/YkAPezp9T1s2LAkydNPP93j2Fsff/f6OALUp7vvvnu7/1jhzDPPzNvf/vbcfffdPQLpnXfemYMOOijTpk3b38ukZDU4gGzcuLF2wgkn1MaPH1/r7Oys1Wq12iuvvFJ73/veVxs3blztlVdeqdVqtdrNN99cS1IbMWLEdvP//d//vdbY2Fj7xS9+sW3bHXfcUWtoaKjddttt++9EgB725Pru7u6u/c//+T9ro0aNqn3iE5/Y7nPuuefW/sf/+B+12bNn98l5AXv+53dvktQmTpy4L5cN7II9vb5///vf1wYPHly7/PLLt22rVqu1d77znbVp06btvxMBetjT6/uiiy6qHXTQQbXFixdv2/byyy/XTjjhhNrpp59e27Jly/47GWCHfvKTn9SS1M4999weY//xH/9RS1IbOHBgrVKpbNv+q1/9qjZgwIDad7/73W3bli5dWjvooINqX//61/fLujlw9KvVXpfaoHAdHR2ZNWtWVqxYkWOOOSZPPfVUxowZk6uvvjrNzc1JkgcffDBnnXVWTj311Nx+++3bzV+0aFG+8Y1vZOTIkanValm9enW+/OUvZ9KkSX1xOsBfebPX99SpUzNnzpwdHnfQoEFZs2bNG75sFdi39vTP79fr169fJk6cmPvuu28/rB54I3t6fa9atSpf+cpXsnHjxrz97W/P2rVrc8YZZ+Siiy5Kv379+uKUgP+/Pbm+t2zZkn//93/PnDlzcvTRR+fQQw/N6tWrc+qpp+aiiy7yfgDoY3/84x/zs5/9LLNnz84zzzyTAQMG5IorrkhbW1tOPfXUJMlTTz2ViRMn5h3veEfuu+++HHTQQdvm/+53v0t7e3taW1szcODAPPHEE5k2bVrOOeecvjolCiWAAAAAAAAAxfEOEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4gggAAAAAABAcQQQAAAAAACgOAIIAAAAAABQHAEEAAAAAAAojgACAAAAAAAURwABAAAAAACKI4AAAAAAAADFEUAAAAAAAIDiCCAAAAAAAEBxBBAAAAAAAKA4AggAAAAAAFAcAQQAAAAAACiOAAIAAAAAABRHAAEAAAAAAIojgAAAAAAAAMURQAAAAAAAgOIIIAAAAAAAQHEEEAAAAAAAoDgCCAAAAAAAUBwBBAAAAAAAKI4AAgAAAAAAFEcAAQAAAAAAiiOAAAAAAAAAxRFAAAAAAACA4vz/AJ12sOriZbhfAAAAAElFTkSuQmCC",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='data:image/png;base64,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' width=1600.0/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Data Overview ###\n",
    "\n",
    "# Temp\n",
    "fig, axs = plt.subplots(nrows=4,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(16)\n",
    "fig.set_figheight(16)\n",
    "temp = []\n",
    "for i in tqdm.notebook.tnrange(0,num_initial_pause_durations,leave=False, desc='$p_d$') :\n",
    "    for j in tqdm.notebook.tnrange(0, num_pause_adjustment_coefficients,leave=False, desc='$p_a$') :\n",
    "        iterator=j+i*num_pause_adjustment_coefficients\n",
    "        color = colors[iterator]\n",
    "\n",
    "        working_df = data[iterator]\n",
    "        length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "        graphing_times = np.linspace(working_df['time_record'][0],\n",
    "             working_df['time_record'][length-1], \n",
    "             int(working_df['time_record'][length-1]))\n",
    "        graphing_times = graphing_times.tolist()\n",
    "        graphing_temp = []\n",
    "        graphing_temp.append(0)\n",
    "        for x in working_df['time_record']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "                    temp_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                    graphing_temp.append(working_df['temp_record_CPU'][temp_time_index[0]])\n",
    "                    \n",
    "        axs[0].step(working_df['time_record'],working_df['temp_record_CPU'], \n",
    "                    label=\"Test {} ; $p_a$: {} s /$^\\circ$C ; $p_d$: {} s\".format(j+i*num_pause_adjustment_coefficients+1, \n",
    "                                                              metadata['pause_adjustment_coef_records'][iterator],\n",
    "                                                              metadata['initial_pause_duration_records'][iterator]),\n",
    "                    color=color,\n",
    "                    alpha=0.5\n",
    "                   )\n",
    "        axs[0].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2) +\n",
    "                          len(moving_average(graphing_temp,moving_average_window))),\n",
    "                    moving_average(graphing_temp,moving_average_window),\n",
    "                    label= \"Test {}; {} Second Average\".format(j+i*num_pause_adjustment_coefficients+1,moving_average_window),\n",
    "                    color=color,\n",
    "                    alpha=1)\n",
    "\n",
    "        # Loops\n",
    "        graphing_loopLength = []\n",
    "        graphing_loopLength.append(0)\n",
    "        for x in working_df['time_record']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    loopLength_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                    graphing_loopLength.append(working_df['loop_duration_record'][loopLength_time_index[0]])\n",
    "\n",
    "        axs[1].step(working_df['time_record'],\n",
    "                    working_df['loop_duration_record'], \n",
    "                    color=color, \n",
    "                    alpha=0.5\n",
    "                   )\n",
    "        axs[1].step(working_df['time_record'],\n",
    "                    working_df['pause_duration_record'], \n",
    "                    alpha=0.3,\n",
    "                    color=color\n",
    "                   )\n",
    "        axs[1].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                          len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "                    moving_average(graphing_loopLength,moving_average_window), \n",
    "                    color=color,\n",
    "                    alpha=1\n",
    "                   )   \n",
    "        \n",
    "        # CPU\n",
    "        graphing_cpu = []\n",
    "        graphing_cpu.append(0)\n",
    "        for x in working_df['time_record']:\n",
    "            for y in graphing_times:\n",
    "                if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                    graphing_times_index = graphing_times.index(y)\n",
    "                    cpu_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                    graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "        axs[2].step(working_df['time_record'],working_df['cpu_record'],color=color,alpha=0.5)\n",
    "        axs[2].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "            len(moving_average(graphing_cpu,moving_average_window))),\n",
    "            moving_average(graphing_cpu,moving_average_window), color=color, alpha=1)\n",
    "\n",
    "        axs[3].scatter(working_df['time_record'],working_df['net_record'], color=color)\n",
    "\n",
    "\n",
    "\n",
    "if device == 'nano' :\n",
    "    axs[0].axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "    axs[0].set_ylim([50,100])\n",
    "\n",
    "elif device == 'rpi' :\n",
    "    axs[0].axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "    axs[0].axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "    axs[0].axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "    axs[0].set_ylim([50,90])\n",
    "\n",
    "axs[0].axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "        \n",
    "axs[0].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "axs[0].set_ylabel('Temperature [$^\\circ$C]')\n",
    "\n",
    "if program_name == 'Combined' : axs[0].set_title('Temperature (Starting Network: {}, TAC: {})'.format(net,throughput_adjustment_tolerance))\n",
    "else : axs[0].set_title('Temperature (Starting Network: {}'.format(net))\n",
    "axs[0].grid()\n",
    "\n",
    "# axs[1].set_ylim([0,3])        \n",
    "axs[1].set_ylabel('Loop Length [s]')\n",
    "axs[1].set_title('Loop Length (Starting Network: {})'.format(net))\n",
    "axs[1].grid()\n",
    "\n",
    "axs[2].set_ylim([0,100])        \n",
    "axs[2].set_ylabel('CPU Usage [%]')\n",
    "axs[2].set_title('CPU Usage (Starting Network: {})'.format(net))\n",
    "axs[2].grid()\n",
    "\n",
    "plt.sca(axs[3])\n",
    "ticks = [3,4]\n",
    "labels = ['MobileNetV2SSD', 'InceptionV2SSD']\n",
    "plt.yticks(ticks, labels)\n",
    "axs[3].set_xlabel('Time [s]')\n",
    "\n",
    "\n",
    "fig.legend(loc='center left', bbox_to_anchor=(0.9, 0.5))\n",
    "\n",
    "# Save plot\n",
    "plot4_path = os.path.join(path, \"Combined_color_net_{}.png\".format(net))\n",
    "plt.savefig(plot4_path,bbox_inches=\"tight\",dpi=400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == ('Variable_Loop_V2' or 'Variable_Loop_V2_alg2') :\n",
    "### Create Meta-result DF ###\n",
    "    mean_cpu = []\n",
    "    mean_loop_duration = []\n",
    "    mean_temp = []\n",
    "    temp_error = []\n",
    "    first_temp = []\n",
    "    for i in tqdm.notebook.tnrange(0,num_initial_pause_durations,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0, num_pause_adjustment_coefficients,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            working_df = df[iterator]\n",
    "            mean_cpu.append(working_df['cpu_record'].mean())\n",
    "            mean_loop_duration.append(working_df['loop_duration_record'].mean())\n",
    "            mean_temp.append(working_df['temp_record_CPU'].mean())\n",
    "            temp_error.append((working_df['temp_record_CPU'].sub(threshold)).pow(2).mean())\n",
    "    #         first_temp.append(working_df['temp_record_CPU'][0])\n",
    "\n",
    "    mean_record = {'mean_cpu':mean_cpu,\n",
    "                   'mean_loop_duration':mean_loop_duration,\n",
    "                   'mean_temp':mean_temp,\n",
    "                   'temp_error':temp_error,\n",
    "    #                'first_temp':first_temp\n",
    "                  }\n",
    "    mean_record_df = pd.DataFrame.from_dict(mean_record)\n",
    "    means_and_meta_df = metadata.join(mean_record_df)\n",
    "    means_and_meta_df['results'] = 10* (1/means_and_meta_df['mean_loop_duration']) * 1/(means_and_meta_df[\"mean_cpu\"]/100) \n",
    "\n",
    "    # means_and_meta_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == ('Variable_Loop_V2' or 'Variable_Loop_V2_alg2') :\n",
    "    ### Mean Temp Topology ###\n",
    "\n",
    "    fig = plt.figure(figsize=(6,6))\n",
    "    ax = plt.axes(projection='3d')\n",
    "\n",
    "    x = metadata['initial_pause_duration_records']\n",
    "    y = metadata['pause_adjustment_coef_records']\n",
    "    z = means_and_meta_df['mean_temp']\n",
    "\n",
    "    ax.scatter3D(x,y,z,c=z,cmap=working_plasma,linewidth=0.5)\n",
    "    ax.set_xlabel('$p_d$')\n",
    "    ax.set_ylabel('$p_a$')\n",
    "    ax.set_zlabel('Mean Temperature [$^\\circ$C]')\n",
    "    plt.xticks(np.linspace(0, max(x), num_initial_pause_durations))\n",
    "    plt.yticks(np.linspace(0, max(y), num_pause_adjustment_coefficients))\n",
    "    ax.view_init(30, -45)\n",
    "\n",
    "    plot5_path = os.path.join(path, \"scatter_net_{}.png\".format(net))\n",
    "    plt.savefig(plot5_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()\n",
    "\n",
    "    fig = plt.figure(figsize=(6,6))\n",
    "\n",
    "    ax = plt.axes(projection='3d')\n",
    "    ax.plot_trisurf(x, y, z,cmap=working_plasma, edgecolor='none')\n",
    "    ax.set_xlabel('$p_d$')\n",
    "    ax.set_ylabel('$p_a$')\n",
    "    ax.set_zlabel('Mean Temperature [$^\\circ$ C]')\n",
    "    plt.xticks(np.linspace(0, max(x), num_initial_pause_durations))\n",
    "    plt.yticks(np.linspace(0, max(y), num_pause_adjustment_coefficients))\n",
    "    ax.view_init(30, -45)\n",
    "\n",
    "\n",
    "    plot6_path = os.path.join(path, \"topology_net_{}.png\".format(net))\n",
    "    plt.savefig(plot6_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == ('Variable_Loop_V2' or 'Variable_Loop_V2_alg2') :\n",
    "\n",
    "    ### \"Efficiency\" ###\n",
    "\n",
    "    sns.heatmap(means_and_meta_df.corr())\n",
    "    plot9_path = os.path.join(path, \"mean_corr_heatmap_net_{}.png\".format(net))\n",
    "    plt.savefig(plot9_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "    pivoted = means_and_meta_df.pivot('pause_adjustment_coef_records','initial_pause_duration_records','results')\n",
    "    pivoted = pivoted.T\n",
    "    axs = plt.axes()\n",
    "    sns.heatmap(pivoted,\n",
    "                annot=True,\n",
    "                cmap=working_plasma,\n",
    "                fmt='.4g',\n",
    "                cbar_kws={'label': '(10x) FPS per fraction of CPU use ',\"orientation\": \"horizontal\"}\n",
    "               )\n",
    "    axs.set_title('Image Processing Efficiency (Network: {})'.format(net))\n",
    "    axs.set_ylabel('Initial Loop Length [s]')\n",
    "    axs.set_xlabel('Loop Length Adjustment Coef. [s /$^\\circ$C]')\n",
    "    plot10_path = os.path.join(path, \"results_net_{}.png\".format(net))\n",
    "    plt.savefig(plot10_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Temp v. Time (Paper) ###\n",
    "\n",
    "colors = cm.plasma(np.linspace(0, 0.8, 4))\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "\n",
    "###################\n",
    "### Algorithm 1 ###\n",
    "###################\n",
    "\n",
    "if program_name == 'Variable_Loop_V2' :\n",
    "    for i in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "            \n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator+5\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_times = np.linspace(working_df['time_record'][0],\n",
    "                                         working_df['time_record'][length-1], \n",
    "                                         int(working_df['time_record'][length-1]))\n",
    "            graphing_times = graphing_times.tolist()\n",
    "            graphing_temp = []\n",
    "            graphing_temp.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "                        temp_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_temp.append(working_df['temp_record_CPU'][temp_time_index[0]])\n",
    "\n",
    "            axs.step(working_df['time_record'],working_df['temp_record_CPU'], \n",
    "    #                     label=\"Test {} ; $p_a$: {}s/$^\\circ$C ; $p_d$: {}s\".format(\n",
    "    #                         iterator+1,\n",
    "    #                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "    #                         metadata['initial_pause_duration_records'][iterator]),\n",
    "                        color=color,\n",
    "                        alpha=0.1,\n",
    "                        zorder=zorder\n",
    "                       )\n",
    "            axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "                        + len(moving_average(graphing_temp,moving_average_window))),\n",
    "                        moving_average(graphing_temp,moving_average_window),\n",
    "                        color=color,\n",
    "    #                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                        label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                            iterator+1,\n",
    "                            metadata['pause_adjustment_coef_records'][iterator],\n",
    "                            metadata['initial_pause_duration_records'][iterator]),                    \n",
    "                        alpha=1,\n",
    "                        zorder=zorder\n",
    "    #                     linewidth=\n",
    "                       )\n",
    "            plt.step(working_df[1:].iloc[0::2,:]['time_record'],working_df[1:].iloc[0::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     alpha=0.2)\n",
    "            plt.step(working_df[1:].iloc[1::2,:]['time_record'],working_df[1:].iloc[1::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     alpha=0.2)\n",
    "            count += 1\n",
    "            \n",
    "    if device == 'nano' :\n",
    "        axs.axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,100])\n",
    "\n",
    "    elif device == 'rpi' :\n",
    "        axs.axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "        axs.axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "        axs.axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,90])\n",
    "    \n",
    "    axs.axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "    axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "    axs.set_title('{} Temperature'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.95))\n",
    "    axs.set_xlabel('Time [s]')\n",
    "\n",
    "    # Save plot\n",
    "    plot11_path = os.path.join(path, \"TempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "    ## Clean\n",
    "    fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "    fig.set_figwidth(6)\n",
    "    fig.set_figheight(4)\n",
    "    temp = []\n",
    "    count = 0\n",
    "    for i in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "    # for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "    #     for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator+5\n",
    "            color = colors[count]\n",
    "            working_df = df[iterator]\n",
    "\n",
    "            plt.step(working_df[1:].iloc[0::2,:]['time_record'],working_df[1:].iloc[0::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                         iterator+1,\n",
    "                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "                         metadata['initial_pause_duration_records'][iterator]),                \n",
    "                     alpha=1)\n",
    "            count += 1\n",
    "\n",
    "    if device == 'nano' :\n",
    "        axs.axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,100])\n",
    "\n",
    "    elif device == 'rpi' :\n",
    "        axs.axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "        axs.axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "        axs.axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,90])\n",
    "    \n",
    "    axs.axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "        \n",
    "    axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "    axs.set_title('{} Temperature'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.95))\n",
    "    # axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.6))\n",
    "    axs.set_xlabel('Time [s]')\n",
    "\n",
    "    # Save plot\n",
    "    plot11_path = os.path.join(path, \"CleanTempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "    \n",
    "###################\n",
    "### Algorithm 2 ###\n",
    "###################\n",
    "            \n",
    "if program_name == 'Variable_Loop_V2_alg2' :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            \n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator+5\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_times = np.linspace(working_df['time_record'][0],\n",
    "                                         working_df['time_record'][length-1], \n",
    "                                         int(working_df['time_record'][length-1]))\n",
    "            graphing_times = graphing_times.tolist()\n",
    "            graphing_temp = []\n",
    "            graphing_temp.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "                        temp_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_temp.append(working_df['temp_record_CPU'][temp_time_index[0]])\n",
    "\n",
    "            axs.step(working_df['time_record'],working_df['temp_record_CPU'], \n",
    "    #                     label=\"Test {} ; $p_a$: {}s/$^\\circ$C ; $p_d$: {}s\".format(\n",
    "    #                         iterator+1,\n",
    "    #                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "    #                         metadata['initial_pause_duration_records'][iterator]),\n",
    "                        color=color,\n",
    "                        alpha=0.1,\n",
    "                        zorder=zorder\n",
    "                       )\n",
    "            axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "                        + len(moving_average(graphing_temp,moving_average_window))),\n",
    "                        moving_average(graphing_temp,moving_average_window),\n",
    "                        color=color,\n",
    "    #                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                        label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                            iterator+1,\n",
    "                            metadata['pause_adjustment_coef_records'][iterator],\n",
    "                            metadata['initial_pause_duration_records'][iterator]),                    \n",
    "                        alpha=1,\n",
    "                        zorder=zorder\n",
    "    #                     linewidth=\n",
    "                       )\n",
    "            plt.step(working_df[1:].iloc[0::2,:]['time_record'],working_df[1:].iloc[0::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     alpha=0.2)\n",
    "            plt.step(working_df[1:].iloc[1::2,:]['time_record'],working_df[1:].iloc[1::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     alpha=0.2)\n",
    "            count += 1\n",
    "\n",
    "    if device == 'nano' :\n",
    "        axs.axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,100])\n",
    "\n",
    "    elif device == 'rpi' :\n",
    "        axs.axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "        axs.axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "        axs.axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,90])\n",
    "    \n",
    "    axs.axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "        \n",
    "    axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "    axs.set_title('{} Temperature'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.95))\n",
    "    axs.set_xlabel('Time [s]')\n",
    "\n",
    "    # Save plot\n",
    "    plot11_path = os.path.join(path, \"TempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "    ## Clean\n",
    "    fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "    fig.set_figwidth(6)\n",
    "    fig.set_figheight(4)\n",
    "    temp = []\n",
    "    count = 0\n",
    "    # for i in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "    #     for j in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator+5\n",
    "            color = colors[count]\n",
    "            working_df = df[iterator]\n",
    "\n",
    "            plt.step(working_df[1:].iloc[0::2,:]['time_record'],working_df[1:].iloc[0::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                         iterator+1,\n",
    "                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "                         metadata['initial_pause_duration_records'][iterator]),                \n",
    "                     alpha=1)\n",
    "            count += 1\n",
    "\n",
    "    if device == 'nano' :\n",
    "        axs.axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,100])\n",
    "\n",
    "    elif device == 'rpi' :\n",
    "        axs.axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "        axs.axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "        axs.axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,90])\n",
    "    \n",
    "    axs.axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "\n",
    "    axs.set_ylim([50,90])\n",
    "    axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "    axs.set_title('{} Temperature'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.95))\n",
    "    # axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.6))\n",
    "    axs.set_xlabel('Time [s]')\n",
    "\n",
    "    # Save plot\n",
    "    plot11_path = os.path.join(path, \"CleanTempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "\n",
    "\n",
    "###################\n",
    "### Algorithm 3 ###\n",
    "###################\n",
    "    \n",
    "## Switching\n",
    "if program_name == 'Combined' :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator+5\n",
    "            color = colors[count]\n",
    "            working_df = df[iterator]\n",
    "\n",
    "            plt.step(working_df[1:].iloc[0::2,:]['time_record'],working_df[1:].iloc[0::2,:]['temp_record_CPU'],\n",
    "                     color=color,\n",
    "                     label=\"Algorithm 2 Test\",                \n",
    "                     alpha=1)\n",
    "            count += 1\n",
    "\n",
    "    if device == 'nano' :\n",
    "        axs.axhline(y=97, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,100])\n",
    "\n",
    "    elif device == 'rpi' :\n",
    "        axs.axhline(y=80, color='red',alpha=0.3,zorder=0)\n",
    "        axs.axhspan(80,85, color='red',alpha=0.1,label='Throttling Temperature',zorder=0)\n",
    "        axs.axhline(y=85, color='red',alpha=0.3,zorder=0)\n",
    "        axs.set_ylim([50,90])\n",
    "    \n",
    "    axs.axhline(y=threshold, color='green',alpha=1,label='Desired Temperature',zorder=0)\n",
    "\n",
    "    axs.set_ylabel('Temperature [$^\\circ$C]')\n",
    "    axs.set_title('Temperature')\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.6))\n",
    "    axs.set_xlabel('Time [s]')\n",
    "\n",
    "    # Save plot\n",
    "    plot11_path = os.path.join(path, \"SwitchingTempEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot11_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Loop v. Time (Paper) ###\n",
    "\n",
    "colors = cm.plasma(np.linspace(0, 0.8, 4))\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "\n",
    "###################\n",
    "### Algorithm 1 ###\n",
    "###################\n",
    "\n",
    "if program_name == 'Variable_Loop_V2' :\n",
    "    for i in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_loopLength = []\n",
    "            graphing_loopLength.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        loopLength_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_loopLength.append(working_df['loop_duration_record'][loopLength_time_index[0]])\n",
    "\n",
    "            axs.step(working_df['time_record'], \n",
    "                     working_df['loop_duration_record'],\n",
    "                     color=color, \n",
    "                     alpha=1,\n",
    "                     zorder=zorder,\n",
    "                     label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                         iterator+1,\n",
    "                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "                         metadata['initial_pause_duration_records'][iterator])                 \n",
    "                    )      \n",
    "\n",
    "    #         axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "    #                           len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "    #                        moving_average(graphing_loopLength,moving_average_window), \n",
    "    #                  color=color,\n",
    "    #                  alpha=1,\n",
    "    #                  label=\"Test {} ; $p_a$: {} s /$^\\circ$C ; $p_d$: {} s\".format(\n",
    "    #                      iterator+1,\n",
    "    #                      metadata['pause_adjustment_coef_records'][iterator],\n",
    "    #                      metadata['initial_pause_duration_records'][iterator])\n",
    "    #                    )   \n",
    "\n",
    "            axs.step(working_df['time_record'], working_df['pause_duration_record'], \n",
    "                        alpha=0.5,\n",
    "                        color=color,\n",
    "                        zorder=zorder,\n",
    "                        label= \"Test {}, Pause Duration\".format(iterator+1),\n",
    "                       )  \n",
    "\n",
    "            count +=1\n",
    "\n",
    "    axs.set_ylabel('Loop Length [s]')\n",
    "    axs.set_title('{} Loop Length'.format(net))\n",
    "    axs.grid()\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -1.15))\n",
    "\n",
    "    # Save plot\n",
    "    plot12_path = os.path.join(path, \"LoopEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot12_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "\n",
    "    \n",
    "###################\n",
    "### Algorithm 2 ###\n",
    "###################\n",
    "\n",
    "if program_name == 'Variable_Loop_V2_alg2' :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_loopLength = []\n",
    "            graphing_loopLength.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        loopLength_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_loopLength.append(working_df['loop_duration_record'][loopLength_time_index[0]])\n",
    "\n",
    "            axs.step(working_df['time_record'], \n",
    "                     working_df['loop_duration_record'],\n",
    "                     color=color, \n",
    "                     alpha=1,\n",
    "                     zorder=zorder,\n",
    "                     label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                         iterator+1,\n",
    "                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "                         metadata['initial_pause_duration_records'][iterator])                 \n",
    "                    )      \n",
    "\n",
    "    #         axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "    #                           len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "    #                        moving_average(graphing_loopLength,moving_average_window), \n",
    "    #                  color=color,\n",
    "    #                  alpha=1,\n",
    "    #                  label=\"Test {} ; $p_a$: {} s /$^\\circ$C ; $p_d$: {} s\".format(\n",
    "    #                      iterator+1,\n",
    "    #                      metadata['pause_adjustment_coef_records'][iterator],\n",
    "    #                      metadata['initial_pause_duration_records'][iterator])\n",
    "    #                    )   \n",
    "\n",
    "            axs.step(working_df['time_record'], working_df['pause_duration_record'], \n",
    "                        alpha=0.5,\n",
    "                        color=color,\n",
    "                        zorder=zorder,\n",
    "                        label= \"Test {}, Pause Duration\".format(iterator+1),\n",
    "                       )  \n",
    "\n",
    "            count +=1\n",
    "\n",
    "    axs.set_ylabel('Loop Length [s]')\n",
    "    axs.set_title('{} Loop Length'.format(net))\n",
    "    axs.grid()\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -1.15))\n",
    "\n",
    "    # Save plot\n",
    "    plot12_path = os.path.join(path, \"LoopEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot12_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "    \n",
    "    \n",
    "###################\n",
    "### Algorithm 3 ###\n",
    "###################\n",
    "\n",
    "## Switching\n",
    "\n",
    "if program_name == 'Combined' :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_loopLength = []\n",
    "            graphing_loopLength.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        loopLength_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_loopLength.append(working_df['loop_duration_record'][loopLength_time_index[0]])\n",
    "\n",
    "            axs.step(working_df['time_record'], \n",
    "                     working_df['loop_duration_record'],\n",
    "                     color=color, \n",
    "                     alpha=1,\n",
    "                     zorder=zorder,\n",
    "                     label=\"Algorithm 2 Test\"                \n",
    "                    )      \n",
    "\n",
    "    #         axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "    #                           len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "    #                        moving_average(graphing_loopLength,moving_average_window), \n",
    "    #                  color=color,\n",
    "    #                  alpha=1,\n",
    "    #                  label=\"Test {} ; $p_a$: {} s /$^\\circ$C ; $p_d$: {} s\".format(\n",
    "    #                      iterator+1,\n",
    "    #                      metadata['pause_adjustment_coef_records'][iterator],\n",
    "    #                      metadata['initial_pause_duration_records'][iterator])\n",
    "    #                    )   \n",
    "\n",
    "            axs.step(working_df['time_record'], working_df['pause_duration_record'], \n",
    "                        alpha=0.5,\n",
    "                        color=color,\n",
    "                        zorder=zorder,\n",
    "                        label= \"Pause Duration\"\n",
    "                       )  \n",
    "\n",
    "            count +=1\n",
    "\n",
    "    axs.set_ylabel('Loop Length [s]')\n",
    "    axs.set_title('Loop Length')\n",
    "    axs.grid()\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.5))\n",
    "\n",
    "    # Save plot\n",
    "    plot12_path = os.path.join(path, \"SwitchingLoopEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot12_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### CPU v. Time (Paper) ###\n",
    "\n",
    "colors = cm.plasma(np.linspace(0, 0.8, 4))\n",
    "fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "fig.set_figwidth(6)\n",
    "fig.set_figheight(4)\n",
    "temp = []\n",
    "count = 0\n",
    "\n",
    "\n",
    "###################\n",
    "### Algorithm 1 ###\n",
    "###################\n",
    "\n",
    "if program_name == 'Variable_Loop_V2' :\n",
    "    for i in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,5,4,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_cpu = []\n",
    "            graphing_cpu.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        cpu_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "    #         axs.step(working_df['time_record'],working_df['cpu_record'],\n",
    "    #                     color=color,\n",
    "    #                     alpha=0.05,\n",
    "    #                     zorder=zorder,\n",
    "    # #                     label=\"Test {} ; $p_a$: {}$/degree$C ; $p_d$: {}s\".format(\n",
    "    # #                         iterator+1,\n",
    "    # #                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "    # #                         metadata['initial_pause_duration_records'][iterator]),\n",
    "    #                    )\n",
    "            axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                        len(moving_average(graphing_cpu,moving_average_window))),\n",
    "                        moving_average(graphing_cpu,moving_average_window), \n",
    "                        color=color, \n",
    "                        alpha=1,\n",
    "                        zorder=zorder,\n",
    "    #                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                        label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                            iterator+1,\n",
    "                            metadata['pause_adjustment_coef_records'][iterator],\n",
    "                            metadata['initial_pause_duration_records'][iterator]),                    \n",
    "                       )\n",
    "            count += 1\n",
    "\n",
    "    axs.set_ylim([0,100])        \n",
    "    axs.set_ylabel('CPU Usage [%]')\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.set_title('{} CPU Usage'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.73))\n",
    "\n",
    "    # Save plot\n",
    "    plot13_path = os.path.join(path, \"CPUEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot13_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "\n",
    "###################\n",
    "### Algorithm 2 ###\n",
    "###################\n",
    "\n",
    "if program_name == 'Variable_Loop_V2_alg2' :\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_cpu = []\n",
    "            graphing_cpu.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        cpu_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "    #         axs.step(working_df['time_record'],working_df['cpu_record'],\n",
    "    #                     color=color,\n",
    "    #                     alpha=0.05,\n",
    "    #                     zorder=zorder,\n",
    "    # #                     label=\"Test {} ; $p_a$: {}$/degree$C ; $p_d$: {}s\".format(\n",
    "    # #                         iterator+1,\n",
    "    # #                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "    # #                         metadata['initial_pause_duration_records'][iterator]),\n",
    "    #                    )\n",
    "            axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                        len(moving_average(graphing_cpu,moving_average_window))),\n",
    "                        moving_average(graphing_cpu,moving_average_window), \n",
    "                        color=color, \n",
    "                        alpha=1,\n",
    "                        zorder=zorder,\n",
    "    #                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                        label=\"Test {}, $p_a$: {} s/$^\\circ$C, $p_d$: {} s\".format(\n",
    "                            iterator+1,\n",
    "                            metadata['pause_adjustment_coef_records'][iterator],\n",
    "                            metadata['initial_pause_duration_records'][iterator]),                    \n",
    "                       )\n",
    "            count += 1\n",
    "\n",
    "    axs.set_ylim([0,100])        \n",
    "    axs.set_ylabel('CPU Usage [%]')\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.set_title('{} CPU Usage'.format(net))\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.73))\n",
    "\n",
    "    # Save plot\n",
    "    plot13_path = os.path.join(path, \"CPUEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot13_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "\n",
    "\n",
    "###################\n",
    "### Algorithm 3 ###\n",
    "###################\n",
    "\n",
    "## Switching\n",
    "if program_name == 'Combined' :\n",
    "\n",
    "    for i in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,leave=False) :\n",
    "            iterator = j+i*num_pause_adjustment_coefficients\n",
    "            zorder = iterator\n",
    "            color = colors[count]\n",
    "\n",
    "            working_df = df[iterator]\n",
    "            length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            graphing_cpu = []\n",
    "            graphing_cpu.append(0)\n",
    "            for x in working_df['time_record']:\n",
    "                for y in graphing_times:\n",
    "                    if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "                        graphing_times_index = graphing_times.index(y)\n",
    "                        cpu_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "                        graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "    #         axs.step(working_df['time_record'],working_df['cpu_record'],\n",
    "    #                     color=color,\n",
    "    #                     alpha=0.05,\n",
    "    #                     zorder=zorder,\n",
    "    # #                     label=\"Test {} ; $p_a$: {}$/degree$C ; $p_d$: {}s\".format(\n",
    "    # #                         iterator+1,\n",
    "    # #                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "    # #                         metadata['initial_pause_duration_records'][iterator]),\n",
    "    #                    )\n",
    "            axs.plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "                        len(moving_average(graphing_cpu,moving_average_window))),\n",
    "                        moving_average(graphing_cpu,moving_average_window), \n",
    "                        color=color, \n",
    "                        alpha=1,\n",
    "                        zorder=zorder,\n",
    "    #                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "                        label=\"Algorithm 2 Test\"                    \n",
    "                       )\n",
    "            count += 1\n",
    "\n",
    "    axs.set_ylim([0,100])        \n",
    "    axs.set_ylabel('CPU Usage [%]')\n",
    "    axs.set_xlabel('Time [s]')\n",
    "    axs.set_title('CPU Usage')\n",
    "    axs.grid()\n",
    "    axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.4))\n",
    "\n",
    "    # Save plot\n",
    "    plot13_path = os.path.join(path, \"SwitchingCPUEffectOfMetareasoning_net_{}.png\".format(net))\n",
    "    plt.savefig(plot13_path,bbox_inches=\"tight\",dpi=400)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Switching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == 'Variable_Loop_V2_alg2' or 'Combined' :\n",
    "\n",
    "    colors = cm.plasma(np.linspace(0, 0.8, 2))\n",
    "    count = 0\n",
    "\n",
    "    for i in tqdm.notebook.tnrange(0,1,4,leave=False) :\n",
    "        for j in tqdm.notebook.tnrange(0,1,4,leave=False) :\n",
    "            fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "            fig.set_figwidth(6)\n",
    "            fig.set_figheight(4)\n",
    "    #         iterator = j+i*num_pause_adjustment_coefficients\n",
    "    #         zorder = iterator\n",
    "            # color = colors[count]\n",
    "            working_df = df[iterator]\n",
    "    #         length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "            sns.histplot(data=working_df, x=\"time_record\", hue=\"net_record\", multiple=\"stack\", bins=30, palette =working_plasma)\n",
    "    #         count += 1\n",
    "\n",
    "    #         plt.sca(axs)\n",
    "    #         ticks = [3,4]\n",
    "            labels = ['InceptionV2SSD', 'MobileNetV2SSD']\n",
    "            axs.set_title('Algorithm 2 Network Distribution')\n",
    "            axs.legend(loc='lower center', bbox_to_anchor=(0.5, -0.5),labels=labels)\n",
    "            axs.set_xlabel('Time [s]')\n",
    "\n",
    "            plot13_path = os.path.join(path, \"SwitchingGraph\")\n",
    "            plt.savefig(plot13_path,bbox_inches=\"tight\",dpi=400)\n",
    "            plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "working_df['temp_record_CPU'].min()\n",
    "colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if batch_data['alg3'][0] == True :\n",
    "\n",
    "    from matplotlib.animation import FuncAnimation\n",
    "    import matplotlib.animation as animation\n",
    "    from IPython.display import HTML\n",
    "    fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "    fig.set_figwidth(6)\n",
    "    fig.set_figheight(4)\n",
    "\n",
    "    working_df = test_data['df_alg3'][0]\n",
    "    length = len(working_df['temp_record_CPU'][5:])\n",
    "    colors = cm.plasma(np.linspace(0, 0.8, length))\n",
    "\n",
    "    plotting_accuracy = np.linspace(working_df['avg_accuracy_record'].min(),working_df['avg_accuracy_record'].max(),10)\n",
    "    \n",
    "    if device == 'nano' :\n",
    "        plotting_throughput = 1/0.68 - (0.739-plotting_accuracy)*TAC\n",
    "    elif device == 'rpi' :\n",
    "        plotting_throughput = 1/1.775 - (0.739-plotting_accuracy)*TAC\n",
    "\n",
    "    axs.plot(plotting_accuracy, plotting_throughput, '--', label='Expected Trajectory')\n",
    "\n",
    "    regx = working_df['avg_accuracy_record'][5:].to_numpy().reshape(-1,1)\n",
    "    regy = 1/working_df['loop_duration_record'][5:].to_numpy().reshape(-1,1)\n",
    "    reg = LinearRegression().fit(regx,regy)\n",
    "    throughput_reg = reg.predict(plotting_accuracy.reshape(-1,1))\n",
    "    axs.plot(plotting_accuracy, throughput_reg, linestyle='dotted', label='Measured Trajectory')\n",
    "\n",
    "    temp_colors = []\n",
    "    min_color = working_df['temp_record_CPU'].min()\n",
    "    max_color = working_df['temp_record_CPU'].max() \n",
    "    color_diff = max_color - min_color \n",
    "    color_factor = 1/color_diff\n",
    "    \n",
    "    for i in range(length) :\n",
    "        temp_adjusted = (working_df['temp_record_CPU'][i] - working_df['temp_record_CPU'].min())*color_factor\n",
    "        # print(temp_adjusted)\n",
    "        temp_colors.append(cm.plasma(temp_adjusted))\n",
    "    \n",
    "    axs.scatter(working_df['avg_accuracy_record'][5:],\n",
    "                1/working_df['loop_duration_record'][5:],\n",
    "                color=temp_colors,\n",
    "                edgecolor='black',\n",
    "                alpha=1)\n",
    "\n",
    "    axs.set_title('Throughput-Accuracy Trade-off, TAC: {}'.format(TAC))\n",
    "    axs.set_xlabel('Expected Top-1 Accuracy [-]')\n",
    "    axs.set_ylabel('Throughput [FPS]')\n",
    "    fig.legend(loc='lower center', bbox_to_anchor=(0.5, -0.28))\n",
    "\n",
    "    ani_ylim = axs.get_ylim()\n",
    "    ani_xlim = axs.get_xlim()\n",
    "    \n",
    "    plot_path = os.path.join(path, \"Combined\")\n",
    "    plt.savefig(plot_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# temp_colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == 'Combined' :\n",
    "    fig, axs = plt.subplots()\n",
    "    axs.set_ylim(ani_ylim)\n",
    "    axs.set_xlim(ani_xlim)\n",
    "    axs.set_title('Throughput-Accuracy Trade-off, TAC: {}'.format(throughput_adjustment_tolerance))\n",
    "    axs.set_xlabel('Expected Top-1 Accuracy [-]')\n",
    "    axs.set_ylabel('Throughput [FPS]')\n",
    "    axs.plot(plotting_accuracy, plotting_throughput, '--', label='Expected Trajectory')\n",
    "\n",
    "    r = axs.plot(plotting_accuracy, plotting_throughput, linestyle='dotted', label='Measured Trajectory',color='C1')\n",
    "\n",
    "    fig.legend(loc='lower center', bbox_to_anchor=(0.5, -0.28))\n",
    "\n",
    "    def animate(i) :\n",
    "        global r\n",
    "        axs.scatter(working_df['avg_accuracy_record'][i+5],1/working_df['loop_duration_record'][i+5],color=temp_colors[i],edgecolors='black')\n",
    "\n",
    "        if i > 10 :\n",
    "            r.pop(0).remove()\n",
    "            regx = working_df['avg_accuracy_record'][5:i+5].to_numpy().reshape(-1,1)\n",
    "            regy = 1/working_df['loop_duration_record'][5:i+5].to_numpy().reshape(-1,1)\n",
    "            reg = LinearRegression().fit(regx,regy)\n",
    "            throughput_reg = reg.predict(plotting_accuracy.reshape(-1,1))\n",
    "            r = axs.plot(plotting_accuracy, throughput_reg, linestyle='dotted', label='Measured Trajectory', color='C1')\n",
    "\n",
    "\n",
    "    ani = FuncAnimation(fig, animate, frames=length, interval = 60)\n",
    "\n",
    "    video_path = os.path.join(path, \"CombinedGraph.gif\")\n",
    "    writervideo = animation.PillowWriter(fps=10)\n",
    "    ani.save(video_path, writer=writervideo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if program_name == 'Combined' :\n",
    "\n",
    "    fig, axs = plt.subplots(nrows=1,ncols=1, sharey='row', sharex='col')\n",
    "    fig.set_figwidth(6)\n",
    "    fig.set_figheight(4)\n",
    "\n",
    "    working_df = df[0]\n",
    "    length = len(working_df['temp_record_CPU'][5:])\n",
    "    colors = cm.plasma(np.linspace(0, 0.8, length))\n",
    "\n",
    "    plotting_accuracy = np.linspace(working_df['avg_accuracy_record'].min(),working_df['avg_accuracy_record'].max(),10)\n",
    "    \n",
    "    if device == 'nano' :\n",
    "        plotting_throughput = 1/0.68 - (0.739-plotting_accuracy)*throughput_adjustment_tolerance\n",
    "    elif device == 'rpi' :\n",
    "        plotting_throughput = 1/1.775 - (0.739-plotting_accuracy)*throughput_adjustment_tolerance\n",
    "\n",
    "    axs.plot(plotting_accuracy, plotting_throughput, '--', label='Expected Trajectory')\n",
    "\n",
    "    regx = working_df['avg_accuracy_record'][5:].to_numpy().reshape(-1,1)\n",
    "    regy = 1/working_df['loop_duration_record'][5:].to_numpy().reshape(-1,1)\n",
    "    reg = LinearRegression().fit(regx,regy)\n",
    "    throughput_reg = reg.predict(plotting_accuracy.reshape(-1,1))\n",
    "    axs.plot(plotting_accuracy, throughput_reg, linestyle='dotted', label='Measured Trajectory')\n",
    "\n",
    "    \n",
    "    \n",
    "    axs.violin(working_df['avg_accuracy_record'][5:],\n",
    "                1/working_df['loop_duration_record'][5:],\n",
    "                color=temp_colors,\n",
    "                edgecolor='black',\n",
    "                alpha=1)\n",
    "\n",
    "    axs.set_title('Throughput-Accuracy Trade-off, TAC: {}'.format(throughput_adjustment_tolerance))\n",
    "    axs.set_xlabel('Expected Top-1 Accuracy [-]')\n",
    "    axs.set_ylabel('Throughput [FPS]')\n",
    "    fig.legend(loc='lower center', bbox_to_anchor=(0.5, -0.28))\n",
    "\n",
    "    ani_ylim = axs.get_ylim()\n",
    "    ani_xlim = axs.get_xlim()\n",
    "    \n",
    "    plot_path = os.path.join(path, \"Combined\")\n",
    "    plt.savefig(plot_path,bbox_inches=\"tight\",dpi=400)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = sns.violinplot(x='avg_accuracy_record',y='loop_duration_record',data=test_data['df_alg3'][0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mask = means_and_meta_df['pause_adjustment_coef_records']>0\n",
    "X = means_and_meta_df[['pause_adjustment_coef_records','initial_pause_duration_records']].to_numpy()\n",
    "y = means_and_meta_df['temp_error'].to_numpy()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "     X, y, test_size=0.4, random_state=3)\n",
    "\n",
    "reg = LinearRegression().fit(X_train, y_train)\n",
    "\n",
    "fig = plt.figure(figsize=(6,6))\n",
    "ax = plt.axes(projection='3d')\n",
    "x = X_train[:,0]\n",
    "y = X_train[:,1]\n",
    "z = y_train\n",
    "ax.scatter3D(x,y,z,c='blue',s=50,label='Train')\n",
    "x = X_test[:,0]\n",
    "y = X_test[:,1]\n",
    "z = y_test\n",
    "ax.scatter3D(x,y,z,c='red',s=50,label='Test')\n",
    "# plt.xticks(np.linspace(0, max(x), num_initial_pause_durations))\n",
    "# plt.yticks(np.linspace(0, max(y), num_pause_adjustment_coefficients))\n",
    "\n",
    "\n",
    "x = np.linspace(0,0.1,5)\n",
    "y = np.linspace(0,2,5)\n",
    "xx, yy = np.meshgrid(x,y)\n",
    "X_working = np.hstack([xx.flatten().reshape(-1,1),yy.flatten().reshape(-1,1)])\n",
    "z = reg.predict(X_working)\n",
    "ax.scatter3D(xx,yy,z,label='Predict',color='green')\n",
    "\n",
    "ax.set_ylabel('$p_a$')\n",
    "ax.set_xlabel('$p_d$')\n",
    "ax.set_zlabel('Temperature Error [($^\\circ$C)$^2$]')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "print(\"Train MSE: {}\".format(mean_squared_error(y_train,reg.predict(X_train))))\n",
    "print(\"Test MSE: {}\".format(mean_squared_error(y_test,reg.predict(X_test))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "df_mask=df[2]['time_record']<=100\n",
    "X = df[2][df_mask]['time_record'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "X_train = np.hstack([X,np.sqrt(X)])\n",
    "y = df[2][df_mask]['temp_record_CPU'].to_numpy().astype(np.float32)\n",
    "reg = LinearRegression().fit(X_train, y)\n",
    "y_pred = reg.predict(X_train)\n",
    "\n",
    "pause = df[2][df_mask]['loop_duration_record'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "# print(pause.flatten())\n",
    "# from scipy.integrate import odeint\n",
    "# def model(T,t):\n",
    "#     k1 = 0.025\n",
    "#     Tss = 80\n",
    "#     Tamb = 22\n",
    "#     dTdt = -k1 * (T - Tamb) + 1.55\n",
    "# #     d2Tdt2 = \n",
    "#     return dTdt\n",
    "\n",
    "# T0 = 50\n",
    "# t = X.flatten()\n",
    "# T = odeint(model,T0,t)\n",
    "\n",
    "# from scipy.integrate import odeint\n",
    "# def model(C,t):\n",
    "#     k1 = 0.8\n",
    "#     dCdt = -k1*(1/(t)) + 0.0025\n",
    "#     return dCdt\n",
    "\n",
    "# C0 = 0.9\n",
    "# t = X.flatten()\n",
    "# C= odeint(model,C0,t)\n",
    "\n",
    "# np.exp(-k*pause[i])\n",
    "\n",
    "# plt.plot(t,C,label='DEQ',c='green')\n",
    "plt.scatter(X,y,label='Data',c='red')\n",
    "plt.scatter(X,y_pred,label='LOBF')\n",
    "plt.legend() \n",
    "print(reg.coef_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Network Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "df_mask=df[0]['time_record']<300\n",
    "X = df[0][df_mask]['time_record'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "y = df[0][df_mask]['temp_record_CPU'].to_numpy().reshape(-1,1).astype(np.float32)\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "     X, y, test_size=0.4, random_state=0)\n",
    "\n",
    "# plt.scatter(X_train,y_train, label=\"Train\", c='Blue', s=20, edgecolors='none')\n",
    "# plt.scatter(X_test,y_test, label=\"Test\", c='Red', s=20, edgecolors='none')\n",
    "\n",
    "x = metadata['initial_pause_duration_records']\n",
    "y = metadata['pause_adjustment_coef_records']\n",
    "z = means_and_meta_df['mean_temp']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(Net, self).__init__()  \n",
    "        # Fully-Connected Layer: 1 (input data) -> 5 (hidden node)\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)  \n",
    "        \n",
    "        # Non-Linear Layer\n",
    "        self.sigmoid1 = nn.Sigmoid()\n",
    "        # You can try other kinds as well\n",
    "        # self.relu = nn.ReLU()\n",
    "        # self.elu = nn.ELU()\n",
    "        \n",
    "        self.fc2 = nn.Linear(hidden_size,hidden_size)\n",
    "        self.sigmoid2 = nn.Sigmoid()\n",
    "        \n",
    "        # Fully-Connected Layer: 5 (hidden node) -> 1 (output)\n",
    "        self.fc3 = nn.Linear(hidden_size, 1) \n",
    "        \n",
    "    \n",
    "    # Forward pass builds the model prediction from the inputs\n",
    "    def forward(self, x):                              \n",
    "        out = self.fc1(x)\n",
    "        out = self.sigmoid1(out)\n",
    "        out = self.fc2(out)\n",
    "        out = self.sigmoid2(out)\n",
    "        out = self.fc3(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the network -- is it not trained yet\n",
    "model = Net(input_size=1, hidden_size=4)\n",
    "\n",
    "# What Loss function should we use? MSE!\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "# What Optimization procedure should we use?\n",
    "learning_rate = 0.05\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Train the model\n",
    "\n",
    "# Convert numpy arrays to torch tensors\n",
    "inputs = torch.from_numpy(X_train)\n",
    "targets = torch.from_numpy(y_train)\n",
    "\n",
    "num_epochs = 5000\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "    ## Do Forward pass\n",
    "    # Make predictions\n",
    "    outputs = model(inputs)\n",
    "    # Compute the loss function\n",
    "    loss = criterion(outputs, targets)\n",
    "    \n",
    "    ## Update the model\n",
    "    # Reset the optimizer gradients\n",
    "    optimizer.zero_grad()\n",
    "    # Compute the gradient of the loss function\n",
    "    loss.backward()\n",
    "    # Do an optimization step\n",
    "    optimizer.step()\n",
    "    \n",
    "    # Print the loss\n",
    "    if (epoch+1) % 200 == 0:\n",
    "        print ('Epoch [{:4}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the graph\n",
    "plt.scatter(X_train, y_train, label='Data',s=10)\n",
    "predicted = model(torch.from_numpy(np.linspace(0,300).reshape(-1,1).astype(np.float32))).detach().numpy()\n",
    "plt.plot(np.linspace(0,300), predicted, label='Prediction',color='orange')\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Line Selector ###\n",
    "\n",
    "# index = means_and_meta_df['temp_error'].idxmin()\n",
    "\n",
    "# # Temp\n",
    "# fig, axs = plt.subplots(nrows=3,ncols=1, sharey='row', sharex='col')\n",
    "# fig.set_figwidth(16)\n",
    "# fig.set_figheight(16)\n",
    "# temp = []\n",
    "# for i in tqdm.notebook.tnrange(0,num_initial_pause_durations,leave=False) :\n",
    "#     for j in tqdm.notebook.tnrange(0, num_pause_adjustment_coefficients,leave=False) :\n",
    "#         iterator = j+i*num_pause_adjustment_coefficients\n",
    "#         zorder = iterator\n",
    "        \n",
    "#         if iterator == 10 :\n",
    "#             color = 'blue'\n",
    "#             zorder = 1000\n",
    "#             color = 'gray'\n",
    "\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "#         graphing_times = np.linspace(working_df['time_record'][0],\n",
    "#                                      working_df['time_record'][length-1], \n",
    "#                                      int(working_df['time_record'][length-1]))\n",
    "#         graphing_times = graphing_times.tolist()\n",
    "#         graphing_temp = []\n",
    "#         graphing_temp.append(0)\n",
    "#         for x in working_df['time_record']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "\n",
    "#                     temp_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "#                     graphing_temp.append(working_df['temp_record_CPU'][temp_time_index[0]])\n",
    "                    \n",
    "#         axs[0].step(working_df['time_record'],working_df['temp_record_CPU'], \n",
    "#                     label=\"Test {} ; $p_a$: {}$/degree$C ; $p_d$: {}s\".format(\n",
    "#                         iterator+1,\n",
    "#                         metadata['pause_adjustment_coef_records'][iterator],\n",
    "#                         metadata['initial_pause_duration_records'][iterator]),\n",
    "#                     color=color,\n",
    "#                     alpha=0.3,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[0].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "#                     + len(moving_average(graphing_temp,moving_average_window))),\n",
    "#                     moving_average(graphing_temp,moving_average_window),\n",
    "#                     color=color,\n",
    "#                     label= \"Test {} ; {} Second Average\".format(iterator+1,moving_average_window),\n",
    "#                     alpha=1,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "\n",
    "#         graphing_loopLength = []\n",
    "#         graphing_loopLength.append(0)\n",
    "#         for x in working_df['time_record']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_loopLength)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     loopLength_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "#                     graphing_loopLength.append(working_df['pause_duration_record'][loopLength_time_index[0]])\n",
    "\n",
    "#         axs[1].step(working_df['time_record'], working_df['pause_duration_record'],\n",
    "#                     color=color, \n",
    "#                     alpha=0.5,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[1].step(working_df['time_record'], working_df['loopLength_goal'], \n",
    "#                     alpha=1,\n",
    "#                     color=color,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "# #         axs[1].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)\n",
    "# #                           +len(moving_average(graphing_loopLength,moving_average_window))),\n",
    "# #                     moving_average(graphing_loopLength,moving_average_window), \n",
    "# #                     color=color,\n",
    "# #                     zorder=zorder,\n",
    "# #                     alpha=1\n",
    "# #                    )\n",
    "\n",
    "#         graphing_cpu = []\n",
    "#         graphing_cpu.append(0)\n",
    "#         for x in working_df['time_record']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_cpu)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     cpu_time_index = working_df.index[working_df['time_record']==x].tolist()\n",
    "#                     graphing_cpu.append(working_df['cpu_record'][cpu_time_index[0]])\n",
    "\n",
    "#         axs[2].step(working_df['time_record'],working_df['cpu_record'],\n",
    "#                     color=color,\n",
    "#                     alpha=0.3,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "#         axs[2].plot(range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "#                     len(moving_average(graphing_cpu,moving_average_window))),\n",
    "#                     moving_average(graphing_cpu,moving_average_window), \n",
    "#                     color=color, \n",
    "#                     alpha=1,\n",
    "#                     zorder=zorder\n",
    "#                    )\n",
    "\n",
    "\n",
    "# axs[0].set_ylim([40,90])\n",
    "# axs[0].axhline(y=start_temp, color='red',alpha=0.3)\n",
    "# axs[0].axhline(y=threshold, color='red',alpha=0.3)\n",
    "# axs[0].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "# axs[0].text(end_of_detections+1,5,'End Detections',rotation=90,color='k')\n",
    "# axs[0].set_ylabel('Temperature [$^\\circ$C]')\n",
    "# axs[0].set_title('Temperature (Network: {})'.format(net))\n",
    "# axs[0].grid()\n",
    "\n",
    "# axs[1].set_ylim([0,3])        \n",
    "# axs[1].set_ylabel('Loop Length [s]')\n",
    "# axs[1].set_title('Loop Length (Network: {})'.format(net))\n",
    "# axs[1].grid()\n",
    "\n",
    "# axs[2].set_ylim([0,100])        \n",
    "# axs[2].set_ylabel('CPU Usage [%]')\n",
    "# axs[2].set_xlabel('Time [s]')\n",
    "# axs[2].set_title('CPU Usage (Network: {})'.format(net))\n",
    "# axs[2].grid()\n",
    "\n",
    "# fig.legend(loc='center left', bbox_to_anchor=(0.9, 0.5))\n",
    "\n",
    "# # Save plot\n",
    "# plot7_path = os.path.join(path, \"Combined_gray_net_{}.png\".format(net))\n",
    "# plt.savefig(plot7_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Temp Grid ###\n",
    "\n",
    "# # Plot all temp_record_CPU vs time in grid plot\n",
    "# fig, axs = plt.subplots(nrows=num_initial_pause_durations,ncols=num_pause_adjustment_coefficients, sharey='row', sharex='col')\n",
    "# fig.set_figwidth(num_pause_adjustment_coefficients*8)\n",
    "# fig.set_figheight(num_initial_pause_durations*5)\n",
    "# fig.set_dpi(200)\n",
    "# for i in tqdm.notebook.tnrange(0,num_initial_pause_durations,desc='lg',leave=False) :\n",
    "#     for j in tqdm.notebook.tnrange(0, num_pause_adjustment_coefficients,desc='la',leave=False) :\n",
    "#         iterator = j+i*num_pause_adjustment_coefficients        \n",
    "#         color = colors[iterator]\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temp_record_CPU'])\n",
    "\n",
    "#         graphing_times = np.linspace(working_df['time_record'][0],\n",
    "#                                      working_df['time_record'][length-1],\n",
    "#                                      int(working_df['time_record'][length-1]))\n",
    "#         graphing_times = graphing_times.tolist()\n",
    "#         graphing_temp = []\n",
    "#         graphing_temp.append(0)\n",
    "#         for x in working_df['time_record']:\n",
    "#             for y in graphing_times:\n",
    "#                 if x >= y and y > graphing_times[len(graphing_temp)-1]:\n",
    "#                     graphing_times_index = graphing_times.index(y)\n",
    "#                     temp_time_index = working_df.index[working_df['time_record']==x].tolist()        \n",
    "#                     graphing_temp.append(working_df['temp_record_CPU'][temp_time_index[0]])\n",
    "                    \n",
    "#         axs[i,j].step(working_df['time_record'],\n",
    "#                               working_df['temp_record_CPU'],\n",
    "#                               label=\"CPU Temperature\",\n",
    "#                               color=color,\n",
    "#                               alpha=0.5\n",
    "#                              )\n",
    "        \n",
    "#         m_a_x = range(math.floor(moving_average_window/2),math.floor(moving_average_window/2)+\n",
    "#                       len(moving_average(graphing_temp,moving_average_window)))\n",
    "#         m_a_y = moving_average(graphing_temp,moving_average_window)\n",
    "#         axs[i,j].plot(m_a_x,m_a_y,     \n",
    "#                                   color=color,\n",
    "#                                   alpha=1,\n",
    "#                                   label= '{} Second Average'.format(moving_average_window)\n",
    "#                                  )\n",
    "        \n",
    "# #         axs[i,j].step(working_df['time_record'],\n",
    "# #                       working_df['temp_record_CPU2']/10,\n",
    "# #                       label=\"GPU Temperature\",\n",
    "# #                       color='green',\n",
    "# #                       alpha=0.5,\n",
    "# #                       zorder=100\n",
    "# #                      )\n",
    "        \n",
    "#         axs[i,j].legend(loc='lower right')\n",
    "#         axs[i,j].set_ylim([40,90])\n",
    "\n",
    "# #             for x in switch_record:\n",
    "# #                 \n",
    "# #                 if net_record[time_record.index(x)] == 1 :\n",
    "# #                     axs[0].axvline(x-0.2, color='r')\n",
    "# #                     axs[0].text(x + 0.2,5,net_1_name,rotation=90)\n",
    "# #                 if net_record[time_record.index(x)] == 2 :\n",
    "# #                     axs[0].axvline(x-0.2, color='c')\n",
    "# #                     axs[0].text(x + 0.2,5,net_2_name,rotation=90)\n",
    "# #                 if net_record[time_record.index(x)] == 3 :\n",
    "# #                     axs[0].axvline(x-0.2, color='m')\n",
    "# #                     axs[0].text(x + 0.2,5,net_3_name,rotation=90)\n",
    "# #                 if net_record[time_record.index(x)] == 4 :\n",
    "# #                     axs[0].axvline(x-0.2, color='y')\n",
    "# #                     axs[0].text(x + 0.2,5,net_4_name,rotation=90)\n",
    "                \n",
    "#         axs[i,j].axhline(y=threshold, color='red',alpha=0.3)\n",
    "#         axs[i,j].axhline(y=start_temp, color='red',alpha=0.3)\n",
    "#         axs[i,j].axvline(end_of_detections, color='red',alpha=0.3)\n",
    "# #         axs[i,j].text(end_of_detections+1,5,'End Detections',rotation=90,color='k')\n",
    "\n",
    "\n",
    "#         if j == 0 : axs[i,j].set_ylabel('Temperature [$^\\circ$C]' + \" ; $IPD$: \" + \n",
    "#                                         str(metadata['initial_pause_duration_records'][iterator]))\n",
    "#         if i == num_initial_pause_durations-1: axs[i,j].set_xlabel('Time [s] ; $p_a$: {}$/degree$C'.format(\n",
    "#                                                                    metadata['pause_adjustment_coef_records'][iterator]))\n",
    "        \n",
    "#         axs[i,j].grid()\n",
    "\n",
    "# # Save plot\n",
    "# plot3_path = os.path.join(path, \"All_temp_record_CPU_net_{}.png\".format(net))\n",
    "# plt.savefig(plot3_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Temp Histplot ###\n",
    "\n",
    "# fig, axs = plt.subplots(nrows=num_initial_pause_durations,ncols=num_pause_adjustment_coefficients, sharey='row', sharex='col')\n",
    "# fig.set_figwidth(num_pause_adjustment_coefficients*10)\n",
    "# fig.set_figheight(num_initial_pause_durations*5)\n",
    "# for i in tqdm.notebook.tnrange(0,num_initial_pause_durations,desc='lg',leave=False) :\n",
    "#     for j in tqdm.notebook.tnrange(0, num_pause_adjustment_coefficients,desc='$PAC$',leave=False) :\n",
    "#         iterator = j+i*num_pause_adjustment_coefficients        \n",
    "#         color = colors[iterator]\n",
    "#         working_df = df[iterator]\n",
    "#         sns.histplot(data=working_df, x=\"temp_record_CPU\", kde=True,ax=axs[i,j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### PCA ###\n",
    "\n",
    "# X = pd.DataFrame()\n",
    "# for i in tnrange(0,num_initial_pause_durations,leave=False) :\n",
    "#     for j in tnrange(0, num_pause_adjustment_coefficients,leave=False) :\n",
    "#         working_df = df[iterator]\n",
    "#         length = len(working_df['temp_record_CPU'])\n",
    "#         q = pd.DataFrame(working_df.mean())        \n",
    "#         X = X.append(q.T,ignore_index=True)\n",
    "        \n",
    "# from sklearn import preprocessing\n",
    "# # data_scaled = pd.DataFrame(preprocessing.scale(X),columns = X.columns) \n",
    "# pca = PCA(n_components=4)\n",
    "# pca.fit_transform(X)\n",
    "\n",
    "# # Dump components relations with features:\n",
    "# # print(pd.DataFrame(pca.components_,columns=data_scaled.columns,index = ['PC-1','PC-2','PC-3','PC-4']))\n",
    "\n",
    "# fig = plt.figure()\n",
    "# PC_values = np.linspace(1,pca.n_components_,pca.n_components,endpoint=True)\n",
    "# plt.plot(PC_values, pca.explained_variance_ratio_, 'ro-', linewidth=2)\n",
    "# plt.title('Scree Plot (Network: {})'.format(net))\n",
    "# plt.xlabel('Principal Component')\n",
    "# plt.ylabel('Proportion of Variance Explained')\n",
    "\n",
    "# plot8_path = os.path.join(path, \"scree_net_{}.png\".format(net))\n",
    "# plt.savefig(plot8_path,bbox_inches=\"tight\",dpi=400)\n",
    "# plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "60995f486619ddad088d69c456fe48b82cf26db14cbc31a3a2043a057c51c38f"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}