{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "from pandas import DataFrame, Series\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import matplotlib.colors as colors\n",
    "from matplotlib.legend_handler import HandlerLine2D, HandlerTuple\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "from scipy import stats\n",
    "import scikit_posthocs as sp\n",
    "import sys\n",
    "\n",
    "from mpl_toolkits.mplot3d import axes3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "AllName=\"dataG.pkl\"\n",
    "ResizesName=\"dataM.pkl\"\n",
    "ItersName=\"dataL.pkl\"\n",
    "matrixIt_Total=\"data_L_Total.csv\"\n",
    "n_cores=20\n",
    "repet = 5 #CAMBIAR EL NUMERO SEGUN NUMERO DE EJECUCIONES POR CONFIG\n",
    "\n",
    "p_value = 0.05\n",
    "processes = [2,10,20,40,80,120,160]\n",
    "\n",
    "positions = [321, 322, 323, 324, 325]\n",
    "positions_small = [221, 222, 223, 224]\n",
    "\n",
    "labels = ['(1,10)',   '(1,20)',   '(1,40)',  '(1,80)',  '(1,120)','(1,160)',\n",
    "            '(10,1)', '(10,20)',  '(10,40)', '(10,80)', '(10,120)','(10,160)',\n",
    "            '(20,1)', '(20,10)',  '(20,40)', '(20,80)', '(20,120)','(20,160)',\n",
    "            '(40,1)', '(40,10)',  '(40,20)', '(40,80)', '(40,120)','(40,160)',\n",
    "            '(80,1)', '(80,10)',  '(80,20)', '(80,40)', '(80,120)','(80,160)',\n",
    "            '(120,1)','(120,10)', '(120,20)','(120,40)','(120,80)','(120,160)',\n",
    "            '(160,1)','(160,10)', '(160,20)','(160,40)','(160,80)','(160,120)']\n",
    "\n",
    "labelsExpand = ['(1,10)',   '(1,20)',   '(1,40)',  '(1,80)',  '(1,120)','(1,160)',\n",
    "            '(10,20)',  '(10,40)', '(10,80)', '(10,120)','(10,160)',\n",
    "            '(20,40)', '(20,80)', '(20,120)','(20,160)',\n",
    "            '(40,80)', '(40,120)','(40,160)',\n",
    "            '(80,120)','(80,160)',\n",
    "            '(120,160)']\n",
    "labelsShrink = ['(10,1)', \n",
    "            '(20,1)', '(20,10)',\n",
    "            '(40,1)', '(40,10)',  '(40,20)',\n",
    "            '(80,1)', '(80,10)',  '(80,20)', '(80,40)',\n",
    "            '(120,1)','(120,10)', '(120,20)','(120,40)','(120,80)',\n",
    "            '(160,1)','(160,10)', '(160,20)','(160,40)','(160,80)','(160,120)']\n",
    "\n",
    "#                       WORST        BEST\n",
    "labels_dist = ['null', 'SpreadFit', 'CompactFit']\n",
    "                  #0          #1                #2                        #3\n",
    "labelsMethods = ['Baseline', 'Baseline single','Baseline - Asynchronous','Baseline single - Asynchronous',\n",
    "                 'Merge','Merge single','Merge - Asynchronous','Merge single - Asynchronous']\n",
    "                  #4      #5             #6                     #7\n",
    "    \n",
    "colors_spawn = ['green','springgreen','blue','darkblue','red','darkred','darkgoldenrod','olive','violet']\n",
    "linestyle_spawn = ['-', '--', '-.', ':']\n",
    "markers_spawn = ['.','v','s','p', 'h','d','X','P','^']\n",
    "\n",
    "OrMult_patch = mpatches.Patch(hatch='', facecolor='green', label='Baseline')\n",
    "OrSing_patch = mpatches.Patch(hatch='', facecolor='springgreen', label='Baseline single')\n",
    "OrPthMult_patch = mpatches.Patch(hatch='//', facecolor='blue', label='Baseline - Asyncrhonous')\n",
    "OrPthSing_patch = mpatches.Patch(hatch='\\\\', facecolor='darkblue', label='Baseline single - Asyncrhonous')\n",
    "MergeMult_patch = mpatches.Patch(hatch='||', facecolor='red', label='Merge')\n",
    "MergeSing_patch = mpatches.Patch(hatch='...', facecolor='darkred', label='Merge single')\n",
    "MergePthMult_patch = mpatches.Patch(hatch='xx', facecolor='yellow', label='Merge - Asyncrhonous')\n",
    "MergePthSing_patch = mpatches.Patch(hatch='++', facecolor='olive', label='Merge single - Asyncrhonous')\n",
    "\n",
    "handles_spawn = [OrMult_patch,OrSing_patch,OrPthMult_patch,OrPthSing_patch,MergeMult_patch,MergeSing_patch,MergePthMult_patch,MergePthSing_patch]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfG = pd.read_pickle( AllName )\n",
    "\n",
    "dfG['ADR'] = round((dfG['ADR'] / dfG['DR']) * 100,1)\n",
    "dfG['SDR'] = round((dfG['SDR'] / dfG['DR']) * 100,1)\n",
    "       \n",
    "out_group = dfG.groupby(['Groups', 'ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy'])['T_total']\n",
    "group = dfG.groupby(['ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy','Groups'])['T_total']\n",
    "\n",
    "grouped_aggG = group.agg(['median'])\n",
    "grouped_aggG.rename(columns={'median':'T_total'}, inplace=True) \n",
    "\n",
    "out_grouped_G = out_group.agg(['median'])\n",
    "out_grouped_G.rename(columns={'median':'T_total'}, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_7488/535752050.py:7: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\n",
      "  out_group = dfM.groupby(['NP','NC','ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy'])['T_Malleability','T_spawn','T_spawn_real','T_SR','T_AR']\n",
      "/tmp/ipykernel_7488/535752050.py:8: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\n",
      "  group = dfM.groupby(['ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy','NP','NC'])['T_Malleability','T_spawn','T_spawn_real','T_SR','T_AR']\n"
     ]
    }
   ],
   "source": [
    "dfM = pd.read_pickle( ResizesName )\n",
    "\n",
    "dfM['ADR'] = round((dfM['ADR'] / dfM['DR']) * 100,1)\n",
    "dfM['SDR'] = round((dfM['SDR'] / dfM['DR']) * 100,1)\n",
    "dfM['T_Malleability'] = dfM['T_spawn'] + dfM['T_SR'] + dfM['T_AR']\n",
    "       \n",
    "out_group = dfM.groupby(['NP','NC','ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy'])['T_Malleability','T_spawn','T_spawn_real','T_SR','T_AR']\n",
    "group = dfM.groupby(['ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy','NP','NC'])['T_Malleability','T_spawn','T_spawn_real','T_SR','T_AR']\n",
    "\n",
    "grouped_aggM = group.agg(['median'])\n",
    "grouped_aggM.columns = grouped_aggM.columns.get_level_values(0)\n",
    "\n",
    "out_grouped_M = out_group.agg(['median'])\n",
    "out_grouped_M.columns = out_grouped_M.columns.get_level_values(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_7488/998390630.py:6: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\n",
      "  group = dfL.groupby(['ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy','NP','NC'])['T_iter', 'T_stages']\n",
      "/tmp/ipykernel_7488/998390630.py:7: FutureWarning: ['T_stages'] did not aggregate successfully. If any error is raised this will raise in a future version of pandas. Drop these columns/ops to avoid this warning.\n",
      "  grouped_aggLAsynch = group.agg(['mean'])\n"
     ]
    }
   ],
   "source": [
    "dfL = pd.read_pickle( ItersName )\n",
    "\n",
    "dfL['ADR'] = round((dfL['ADR'] / dfL['DR']) * 100,1)\n",
    "dfL['SDR'] = round((dfL['SDR'] / dfL['DR']) * 100,1)\n",
    "       \n",
    "group = dfL.groupby(['ADR','Spawn_Method','Redistribution_Method', 'Redistribution_Strategy','NP','NC'])['T_iter', 'T_stages']\n",
    "grouped_aggLAsynch = group.agg(['mean'])\n",
    "grouped_aggLAsynch.columns = grouped_aggLAsynch.columns.get_level_values(0)\n",
    "\n",
    "group = dfL.groupby('NP')['T_iter']\n",
    "grouped_aggLSynch = group.agg(['mean'])\n",
    "grouped_aggLSynch.rename(columns={'mean':'T_iter'}, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bt_scheme import PartialSolution, BacktrackingSolver\n",
    "def elegirConf(parameters):\n",
    "    class StatePS(PartialSolution):\n",
    "        def __init__(self, config):\n",
    "            self.config= config\n",
    "            self.n= len(config) #Indica el valor a añadir\n",
    "\n",
    "        def is_solution(self):\n",
    "            return self.n == len(parameters)\n",
    "\n",
    "        def get_solution(self):\n",
    "            return tuple(self.config)\n",
    "\n",
    "        def successors(self):\n",
    "            array = parameters[self.n]\n",
    "            for parameter_value in array: #Test all values of the next parameter\n",
    "                self.config.append(parameter_value)\n",
    "                yield StatePS(self.config)\n",
    "                self.config.pop()\n",
    "\n",
    "    initialPs= StatePS([])\n",
    "    return BacktrackingSolver().solve(initialPs)\n",
    "\n",
    "\n",
    "def obtenerConfs(parameters):\n",
    "    soluciones=[]\n",
    "    for solucion in elegirConf(parameters):\n",
    "        soluciones.append(solucion)\n",
    "    return soluciones\n",
    "\n",
    "def modifyToUsable(parameters, len_parameters, configuration):\n",
    "    usable_configuration = []\n",
    "    for i in range(len(parameters)):\n",
    "        if len_parameters[i] > 1:\n",
    "            aux = (parameters[i][0], configuration[i])\n",
    "        else:\n",
    "            aux = (configuration[i])\n",
    "        usable_configuration.append(aux)\n",
    "        \n",
    "    return usable_configuration\n",
    "\n",
    "def CheckConfExists(configuration, dataSet, type_conf='global'):\n",
    "    remove = 0\n",
    "    config = list(configuration)\n",
    "    for np_aux in processes:\n",
    "        for ns_aux in processes:\n",
    "            if np_aux != ns_aux:\n",
    "                \n",
    "                if type_conf == 'global':\n",
    "                    config.append((np_aux, ns_aux))\n",
    "                elif type_conf == 'malleability':\n",
    "                    config.append(np_aux)\n",
    "                    config.append(ns_aux)\n",
    "                    \n",
    "                if tuple(config) in dataSet.index:     \n",
    "                    remove = 1\n",
    "                elif remove != 1:\n",
    "                    remove = -1\n",
    "                config.pop()\n",
    "                \n",
    "                if type_conf == 'malleability':\n",
    "                    config.pop()\n",
    "    if remove == 1:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 0, 1], [0, 1, 1, 1], [96.6, 0, 0, 1], [96.6, 0, 0, 2], [96.6, 0, 1, 1], [96.6, 0, 1, 2], [96.6, 1, 0, 1], [96.6, 1, 0, 2], [96.6, 1, 1, 1], [96.6, 1, 1, 2]]\n",
      "[[0, (0, 0), (0, 0), (1, 1)], [0, (0, 0), (0, 1), (1, 1)], [0, (0, 1), (0, 0), (1, 1)], [0, (0, 1), (0, 1), (1, 1)], [96.6, (0, 0), (0, 0), (1, 1)], [96.6, (0, 0), (0, 0), (1, 2)], [96.6, (0, 0), (0, 1), (1, 1)], [96.6, (0, 0), (0, 1), (1, 2)], [96.6, (0, 1), (0, 0), (1, 1)], [96.6, (0, 1), (0, 0), (1, 2)], [96.6, (0, 1), (0, 1), (1, 1)], [96.6, (0, 1), (0, 1), (1, 2)]]\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "sp_method = [0,1]\n",
    "rd_method = [0,1]\n",
    "rd_strat  = [1,2]\n",
    "adr = [0,96.6]\n",
    "parameters = [adr, sp_method, rd_method, rd_strat]\n",
    "len_parameters = [1,2,2,2]\n",
    "configurations_aux = obtenerConfs(parameters)\n",
    "configurations = []\n",
    "configurations_simple = []\n",
    "for index in range(len(configurations_aux)):\n",
    "    aux_conf = modifyToUsable(parameters, len_parameters, configurations_aux[index])\n",
    "    if CheckConfExists(aux_conf, grouped_aggG):\n",
    "        configurations.append(aux_conf)\n",
    "    if CheckConfExists(configurations_aux[index], grouped_aggM, 'malleability'):\n",
    "        configurations_simple.append(list(configurations_aux[index]))\n",
    "\n",
    "print(configurations_simple)\n",
    "print(configurations)\n",
    "print(len(configurations))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ALPHA already exists\n"
     ]
    }
   ],
   "source": [
    "#ALPHA COMPUTATION\n",
    "def compute_alpha(config_a, config_b):\n",
    "    for np_aux in processes:\n",
    "        for ns_aux in processes:\n",
    "            if np_aux != ns_aux:\n",
    "                config_a.append(np_aux)\n",
    "                config_a.append(ns_aux)\n",
    "                config_b.append(np_aux)\n",
    "                config_b.append(ns_aux)\n",
    "                grouped_aggM.loc[tuple(config_b),'Alpha'] = grouped_aggM.loc[tuple(config_b),'T_Malleability'] / grouped_aggM.loc[tuple(config_a),'T_Malleability']\n",
    "                config_a.pop()\n",
    "                config_a.pop()\n",
    "                config_b.pop()\n",
    "                config_b.pop()\n",
    "                \n",
    "                \n",
    "                config_a.insert(0,ns_aux)\n",
    "                config_a.insert(0,np_aux)\n",
    "                config_b.insert(0,ns_aux)\n",
    "                config_b.insert(0,np_aux)\n",
    "                out_grouped_M.loc[tuple(config_b),'Alpha'] = out_grouped_M.loc[tuple(config_b),'T_Malleability'] / out_grouped_M.loc[tuple(config_a),'T_Malleability']\n",
    "                config_a.pop(0)\n",
    "                config_a.pop(0)\n",
    "                config_b.pop(0)\n",
    "                config_b.pop(0)\n",
    "\n",
    "if not ('Alpha' in grouped_aggM.columns):\n",
    "    for config_a in configurations_simple:\n",
    "        for config_b in configurations_simple:\n",
    "            #FIXME/TODO If the last index of configurations is not the strategy or different from pthreads may fail this computation\n",
    "            if config_a[1:-1] == config_b[1:-1] and config_a[0] == 0 and config_b[0] != 0:\n",
    "                compute_alpha(config_a, config_b)\n",
    "else:\n",
    "    print(\"ALPHA already exists\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OMEGA already exists\n"
     ]
    }
   ],
   "source": [
    "#OMEGA COMPUTATION\n",
    "def compute_omega(config):\n",
    "    for np_aux in processes:\n",
    "        for ns_aux in processes:\n",
    "            if np_aux != ns_aux:\n",
    "                config.append(np_aux)\n",
    "                config.append(ns_aux)\n",
    "                grouped_aggLAsynch.loc[tuple(config),'Omega'] = grouped_aggLAsynch.loc[tuple(config),'T_iter'] / grouped_aggLSynch.loc[np_aux,'T_iter']\n",
    "                config.pop()\n",
    "                config.pop()\n",
    "\n",
    "if not ('Omega' in grouped_aggLAsynch.columns):\n",
    "    for config in configurations_simple:\n",
    "        if config[0] != 0:\n",
    "            compute_omega(config)\n",
    "else:\n",
    "    print(\"OMEGA already exists\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_grouped_G.to_excel(\"resultG.xlsx\") \n",
    "out_grouped_M.to_excel(\"resultM.xlsx\") \n",
    "grouped_aggLAsynch.to_excel(\"AsynchIters.xlsx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>T_iter</th>\n",
       "      <th>Omega</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ADR</th>\n",
       "      <th>Spawn_Method</th>\n",
       "      <th>Redistribution_Method</th>\n",
       "      <th>Redistribution_Strategy</th>\n",
       "      <th>NP</th>\n",
       "      <th>NC</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"11\" valign=\"top\">96.6</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">0.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">0.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">1.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">2</th>\n",
       "      <th>10.0</th>\n",
       "      <td>1.075937</td>\n",
       "      <td>1.789700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20.0</th>\n",
       "      <td>1.207753</td>\n",
       "      <td>2.008962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40.0</th>\n",
       "      <td>1.256070</td>\n",
       "      <td>2.089332</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80.0</th>\n",
       "      <td>1.169895</td>\n",
       "      <td>1.945990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>120.0</th>\n",
       "      <td>1.225243</td>\n",
       "      <td>2.038054</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <th>...</th>\n",
       "      <th>...</th>\n",
       "      <th>...</th>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">1.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">1.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">2.0</th>\n",
       "      <th rowspan=\"5\" valign=\"top\">160</th>\n",
       "      <th>10.0</th>\n",
       "      <td>0.896296</td>\n",
       "      <td>5.711017</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20.0</th>\n",
       "      <td>0.708625</td>\n",
       "      <td>4.515218</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40.0</th>\n",
       "      <td>0.533604</td>\n",
       "      <td>3.400016</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>80.0</th>\n",
       "      <td>0.482244</td>\n",
       "      <td>3.072765</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>120.0</th>\n",
       "      <td>0.468189</td>\n",
       "      <td>2.983204</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>336 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                             T_iter  \\\n",
       "ADR  Spawn_Method Redistribution_Method Redistribution_Strategy NP  NC                \n",
       "96.6 0.0          0.0                   1.0                     2   10.0   1.075937   \n",
       "                                                                    20.0   1.207753   \n",
       "                                                                    40.0   1.256070   \n",
       "                                                                    80.0   1.169895   \n",
       "                                                                    120.0  1.225243   \n",
       "...                                                                             ...   \n",
       "     1.0          1.0                   2.0                     160 10.0   0.896296   \n",
       "                                                                    20.0   0.708625   \n",
       "                                                                    40.0   0.533604   \n",
       "                                                                    80.0   0.482244   \n",
       "                                                                    120.0  0.468189   \n",
       "\n",
       "                                                                              Omega  \n",
       "ADR  Spawn_Method Redistribution_Method Redistribution_Strategy NP  NC               \n",
       "96.6 0.0          0.0                   1.0                     2   10.0   1.789700  \n",
       "                                                                    20.0   2.008962  \n",
       "                                                                    40.0   2.089332  \n",
       "                                                                    80.0   1.945990  \n",
       "                                                                    120.0  2.038054  \n",
       "...                                                                             ...  \n",
       "     1.0          1.0                   2.0                     160 10.0   5.711017  \n",
       "                                                                    20.0   4.515218  \n",
       "                                                                    40.0   3.400016  \n",
       "                                                                    80.0   3.072765  \n",
       "                                                                    120.0  2.983204  \n",
       "\n",
       "[336 rows x 2 columns]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grouped_aggLAsynch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aquellos grupos que tengán valores por encima del límite no se considerarán\n",
    "# Con sumar a si mismos su valor actual estarán fuera\n",
    "def check_groups_boundaries(dataLists, boundaries, tc_boundary):\n",
    "    for index in range(len(boundaries)):\n",
    "        if boundaries[index] > tc_boundary:\n",
    "            dataLists[index]= float('infinity')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_perc_differences(dataLists, boundaries, tc_boundary):\n",
    "    if boundaries != None: # Si se usa perspectiva de RMS, se desconsideran valores muy altos\n",
    "        check_groups_boundaries(dataLists, boundaries, tc_boundary) \n",
    "    indexes = np.argsort(dataLists)\n",
    "    \n",
    "    best = -1\n",
    "    bestMax = -1\n",
    "    otherBest=[]\n",
    "    for index in indexes: # Para cada metodo -- Empezando por el tiempo más bajo en media/mediana\n",
    "        if best == -1:\n",
    "            best = index\n",
    "            bestMax = dataLists[best] * 1.05\n",
    "        elif dataLists[index] <= bestMax: # Medias/Medianas diferentes && Media/Medianas i < Media/Mediana best\n",
    "            otherBest.append(index)\n",
    "                \n",
    "    otherBest.insert(0,best)\n",
    "    return otherBest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_config_data(tipo, data_aux, used_config, np_aux, ns_aux):\n",
    "    dataLists=[]\n",
    "    for config in used_config:\n",
    "        if tipo == \"T_total\":\n",
    "            config.append((np_aux,ns_aux))\n",
    "        elif tipo == \"T_Malleability\":\n",
    "            config.append(np_aux)\n",
    "            config.append(ns_aux)\n",
    "        \n",
    "        if tuple(config) in data_aux.index:\n",
    "            aux_value = data_aux.loc[tuple(config),tipo]\n",
    "            if isinstance(aux_value, pd.Series):\n",
    "                aux_value = aux_value.values[0]\n",
    "        else: # This configuration is not present in the dataset\n",
    "            aux_value = float('infinity')\n",
    "        dataLists.append(aux_value)\n",
    "        config.pop()\n",
    "        if tipo == \"T_Malleability\":\n",
    "            config.pop()\n",
    "    return dataLists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def results_with_perc(tipo, data_aux, used_config, rms_boundary=0):\n",
    "    results = []\n",
    "    boundaries = None\n",
    "    for np_aux in processes:\n",
    "        for ns_aux in processes:\n",
    "            if np_aux != ns_aux:\n",
    "                \n",
    "                # 1 - Get all values for particular config with these number of processes\n",
    "                dataLists = get_config_data(tipo, data_aux, used_config, np_aux, ns_aux)\n",
    "                \n",
    "                tc_boundary = 0\n",
    "                if rms_boundary != 0:\n",
    "                    # El porcentaje de tc_boundary se tiene en cuenta para eliminar aquellos\n",
    "                    # tiempos demasiado grandes en su malleability time respecto al más pequeño\n",
    "                    boundaries = get_config_data(\"T_Malleability\", grouped_aggM, configurations_simple, np_aux, ns_aux)\n",
    "                    tc_boundary = min(boundaries)\n",
    "                    tc_boundary = tc_boundary + tc_boundary*rms_boundary\n",
    "\n",
    "                aux_data = get_perc_differences(dataLists, boundaries, tc_boundary)\n",
    "                results.append(aux_data)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1], [2], [2], [4, 6], [6, 4], [4], [2], [10, 3, 2, 8], [2, 8, 3], [2], [3, 2], [2, 10, 3], [8], [2], [2], [2, 10, 3], [3, 10], [3], [10], [8, 2], [8, 2], [2], [2, 3], [3], [10], [10, 2], [10, 2], [3], [2, 3], [3, 2], [10], [10], [10, 2], [3, 2], [3, 2], [2], [10], [2], [2, 3], [3, 2], [3, 2], [3, 2]]\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "checked_type='T_total'\n",
    "use_perc = True\n",
    "rms_boundary=0.1 # Poner a 0 para perspectiva de app. Valor >0 y <1 para perspectiva de RMS\n",
    "if checked_type=='T_total':\n",
    "    tipo=\"T_total\"\n",
    "    data_aux=grouped_aggG\n",
    "    used_config = configurations\n",
    "elif checked_type=='T_Malleability':\n",
    "    tipo=\"T_Malleability\"\n",
    "    data_aux=grouped_aggM\n",
    "    used_config = configurations_simple\n",
    "    \n",
    "if use_perc:\n",
    "    results = results_with_perc(tipo, data_aux, used_config, rms_boundary)\n",
    "else:\n",
    "    #results = results_with_st(tipo, data_aux)\n",
    "    results = None\n",
    "#Results is a 2 dimensional array. First dimensional indicates winners of a particulal number of processes (NP->NC). \n",
    "#Second dimension is an ordered preference of indexes in the array configurations.\n",
    "print(results)\n",
    "print(len(results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  1  2  2  4  6  4]\n",
      " [ 2 -1 10  2  2  3  2]\n",
      " [ 8  2 -1  2  2  3  3]\n",
      " [10  8  8 -1  2  2  3]\n",
      " [10 10 10  3 -1  2  3]\n",
      " [10 10 10  3  3 -1  2]\n",
      " [10  2  2  3  3  3 12]]\n"
     ]
    }
   ],
   "source": [
    "#Lista de indices de mayor a menor de los valores\n",
    "aux_array = []\n",
    "for data in results:\n",
    "    aux_array+=data\n",
    "unique, counts = np.unique(aux_array, return_counts=True)\n",
    "aux_dict = dict(zip(unique, counts))\n",
    "aux_keys=list(aux_dict.keys())\n",
    "aux_values=list(aux_dict.values())\n",
    "aux_ordered_index=list(reversed(list(np.argsort(aux_values))))\n",
    "\n",
    "i=0\n",
    "j=0\n",
    "used_aux=0\n",
    "heatmap=np.zeros((len(processes),len(processes))).astype(int)\n",
    "\n",
    "if use_perc:\n",
    "    for i in range(len(processes)):\n",
    "        for j in range(len(processes)):\n",
    "            if i==j:\n",
    "                heatmap[i][j]=-1\n",
    "                used_aux+=1\n",
    "            else:\n",
    "                results_index = i*len(processes) +j-used_aux\n",
    "                heatmap[i][j] = results[results_index][0]\n",
    "else:\n",
    "    for i in range(len(processes)):\n",
    "        for j in range(len(processes)):\n",
    "            if i==j:\n",
    "                heatmap[i][j]=-1\n",
    "                used_aux+=1\n",
    "            else:  \n",
    "                results_index = i*len(processes) +j-used_aux\n",
    "                for index in aux_ordered_index:\n",
    "                    if aux_keys[index] in results[results_index]:\n",
    "                        heatmap[i][j]=aux_keys[index]\n",
    "                        break\n",
    "heatmap[-1][-1]=len(used_config)\n",
    "print(heatmap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adapta results a una cadena asegurando que cada cadena no se sale de su celda\n",
    "results_str = []\n",
    "max_counts = 1\n",
    "max_per_line = 3\n",
    "for i in range(len(results)):\n",
    "    results_str.append(list())\n",
    "    count = len(results[i])\n",
    "    results_aux = results[i]\n",
    "    if count > max_counts:\n",
    "        count = max_counts\n",
    "        results_aux = results[i][:count]\n",
    "        \n",
    "    remainder = count%max_per_line\n",
    "    if count <= max_per_line:\n",
    "        aux_str = str(results_aux).replace('[','').replace(']','')\n",
    "        results_str[i].append(aux_str)\n",
    "    else:\n",
    "        if remainder == 0:\n",
    "            index = count//2\n",
    "        else:\n",
    "            index = count - ((remainder-1)*max_per_line + 1)\n",
    "        aux_str = str(results_aux[:index]).replace('[','').replace(']','')\n",
    "        results_str[i].append(aux_str)\n",
    "        aux_str = str(results_aux[index:]).replace('[','').replace(']','')\n",
    "        results_str[i].append(aux_str)\n",
    "#print(results_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4155/3389487544.py:37: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_xticklabels(['']+processes, fontsize=36)\n",
      "/tmp/ipykernel_4155/3389487544.py:38: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels(['']+processes, fontsize=36)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1728x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Crea un heatmap teniendo en cuenta los colores anteriores\n",
    "f=plt.figure(figsize=(24, 12))\n",
    "ax=f.add_subplot(111)\n",
    "\n",
    "myColors = (colors.to_rgba(\"white\"),colors.to_rgba(\"green\"), colors.to_rgba(\"springgreen\"),colors.to_rgba(\"blue\"),colors.to_rgba(\"darkblue\"),\n",
    "            colors.to_rgba(\"red\"),colors.to_rgba(\"darkred\"),colors.to_rgba(\"darkgoldenrod\"),colors.to_rgba(\"olive\"),\n",
    "            colors.to_rgba(\"green\"), colors.to_rgba(\"springgreen\"),colors.to_rgba(\"blue\"),colors.to_rgba(\"darkblue\"),colors.to_rgba(\"white\"))\n",
    "cmap = LinearSegmentedColormap.from_list('Custom', myColors, len(myColors))\n",
    "\n",
    "im = ax.imshow(heatmap,cmap=cmap,interpolation='nearest')\n",
    "\n",
    "# Loop over data dimensions and create text annotations.\n",
    "used_aux=0\n",
    "for i in range(len(processes)):\n",
    "    for j in range(len(processes)):\n",
    "        if i!=j:\n",
    "            aux_color=\"white\"\n",
    "            if heatmap[i, j] == 1 or heatmap[i, j] == 9: # El 1 puede necesitar texto en negro\n",
    "                aux_color=\"black\"\n",
    "            results_index = i*len(processes) +j-used_aux\n",
    "            if len(results_str[results_index]) == 1:\n",
    "                text = results_str[results_index][0]\n",
    "                ax.text(j, i, text, ha=\"center\", va=\"center\", color=aux_color, fontsize=36)\n",
    "            else:\n",
    "                add_aux = 0.33\n",
    "                for line in range(len(results_str[results_index])):\n",
    "                    i_range = i - 0.5 + add_aux\n",
    "                    ax.text(j, i_range, results_str[results_index][line],\n",
    "                            ha=\"center\", va=\"center\", color=aux_color, fontsize=36)\n",
    "                    add_aux+=0.33\n",
    "        else:\n",
    "            used_aux+=1\n",
    "\n",
    "ax.set_ylabel(\"NP\", fontsize=36)\n",
    "ax.set_xlabel(\"NC\", fontsize=36)\n",
    "\n",
    "ax.set_xticklabels(['']+processes, fontsize=36)\n",
    "ax.set_yticklabels(['']+processes, fontsize=36)\n",
    "\n",
    "\n",
    "labelsMethods_aux = ['Baseline - AllS (0)', 'Baseline - P2PS (1)',\n",
    "                    'Merge - AllS (2)','Merge - P2PS (3)',\n",
    "                    'Baseline - AllA (4)', 'Baseline - AllT (5)','Baseline - P2PA (6)','Baseline - P2PT (7)',\n",
    "                    'Merge - AllA (8)','Merge - AllT (9)','Merge - P2PA (10)','Merge - P2PT (11)']\n",
    "colorbar=f.colorbar(im, ax=ax)\n",
    "tick_bar = []\n",
    "for i in range(len(used_config)):\n",
    "    tick_bar.append(0.37 + i*0.92) #TE\n",
    "colorbar.set_ticks(tick_bar) \n",
    "colorbar.set_ticklabels(labelsMethods_aux)\n",
    "colorbar.ax.tick_params(labelsize=32)\n",
    "#\n",
    "\n",
    "f.tight_layout()\n",
    "f.savefig(\"Images/Spawn/Heatmap_\"+tipo+\".png\", format=\"png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  6  8 10]\n",
      "[ 1 21  8  1  2  2  7]\n"
     ]
    }
   ],
   "source": [
    "aux_array = [0] * len(results)\n",
    "for index in range(len(results)):\n",
    "    aux_array[index] = results[index][0]\n",
    "aux_results, aux_counts = np.unique(aux_array, return_counts = True)\n",
    "print(aux_results)\n",
    "print(aux_counts)\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPoAAAEECAYAAAABAyngAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABq+0lEQVR4nO29d3hc9ZX//7rT1HuvlixbbrKqbUwwHduQEGroLZSw2YSEhISEkP0R2A0tySZsvmzK0gJsAksogcSFGnoxttUsyZJl9a5pGpXR1Pv7Y3QvI2lGGo1mVKx5PY8ey6OZO3fKued8zue8zxFEUSREiBAnNorFPoEQIUIEn5ChhwixAggZeogQK4CQoYcIsQIIGXqIECuAkKGHCLECCBn6EkQQhLY53j9eEIRvuf3/DEEQ/jHHY7wrCELeXB4TYvkQMvRljiAISiAe+NYsdw2xggkZ+tJkEEBw8UtBEI4IglArCMIVE7efIQjCPwVB+AtQCzwEFAiCUCUIwi8njhEtCMKLgiAcFQThz4IgCBOPPVsQhMqJ4z0pCELYxP31gGNhX2aIhUIIVcYtXQRBuBT4JnAukAx8DpwErAP2AEWiKLZOhNz/EEWxaOJxZwCvApuAHuAj4E7gIHAMOFsUxSZBEJ4BDoui+MjCvaoQi0HIoy9tdgDPiaLoEEWxH3gP2DrxtwOiKLbO8NgDoih2iaLoBKqAPFwXiFZRFJsm7vM0cFpQzjzEkiJk6EsbYYa/jc7yWIvb7w5ANcvxQpzAhAx9afM+cIUgCEpBEFJwed8DHu43DMT4cLyjQJ4gCGsm/n8drighxAlOyNCXNq8ANUA18A7wI1EU+6beSRRFHfDRRNLul1P/7na/ceBG4K+CINQCTuAPQTnzEEuKUDIuRIgVQMijhwixAggZeogQK4CQoYcIsQIIGXqIECuAkKHPAUEQvisIQoMgCH8O4DHfFQRhywx/bxMEITlQzzdxzDxBEK52+//XBUF4NJDPEWJpETL0ufEt4MuiKF6z2CcyT/KAq2e7U4gTh5Ch+4ggCH8AVgOvCYLwfUEQEgVB+JsgCDWCIHwqCELxxP2iBUF4akI0UjNRr44gCL8XBOGgIAh1giDc5+c5XCsIwoEJ8cofJ5RrCIIwIgjC/YIgVE+cS9rE7QUT//9cEIR/FwRhZOJQDwGnThzn+xO3ZQqCsF8QhGOCIPxiHm9ViKWIKIqhHx9/gDYgeeL3/wf8bOL3s4Cqid8fBh5xe0zCxL+JE/8qgXeB4on/vwtsme05gQ3A3wH1xO2/A66f+F0Evjrx+y+Af5v4/R/AVRO/fxMYmfj9DFwiGOk5vg60AHFAONAO5Hg4l9/gqpuf+nOXl3O/G1fl3cXAD3AV/dyw2J/jSvxRzf3SEGKCHcClAKIoviMIQpIgCHHAOcCV0p1EUTRM/Hq5IAi34qo5zwA24qp685WzgQrg8wnFaQQwMPE3Ky6jBjgE7Jz4/WTgoonf/wL8aobjvy2K4hCAIAj1wCqg0/0Ooih+39MDPSEIQgygBs4E/gy0iKJ4liAID/l6jBCBI2To/uNJICJO3D6p3FAQhHzgh8BWURQNgiD8CZfnnOvzPS2K4k88/M0mTrhQvhCwzBVPIpjJJyAIv8FluFN5XhTFqQYsAIii6BQEwQDETtweWi4uAqE33X/eB64BWf+tFUXRBLwB3CbdSRCEBFxf8lFgaGL9fJ4fz/c28DVBEFInjpsoCMKqWR7zKRNRB25RBr6LYCYhiuL3RVEs9fAzzUtPvBcWQRDeBT4EmgVBeA9omnrfEMEn5NH9517gKUEQaoAx4IaJ238O/LcgCEdwecb7RFF8WRCESqAO11r4o7k+mSiK9YIg/BvwhiAICsAGfBvXetob3wP+VxCEH+BqVDE0cXsNYBcEoRr4E2Dw+Oh5MnEBcL8I/FcwnifE7IRELScwgiBEAmZRFEVBEK7ElZi7cLHPK8TCE/LoJzYVwKMT/eKMwE2LezohFouQR18iCILwGRA25ebrRFGsXYzzCXFiETL0ECFWAKGse4gQK4DZ1ughdx8iRPAJetPOkEcPEWIFEDL0ECFWACFDDxFiBRAy9BAhVgAhQw8RYgUQMvQQIVYAIUMPEWIFEDL0ECFWACFDDxFiBRAy9BAhVgAhQ19gRFHEbrcTEhOFWEhCevQFRBRFrFYrY2NjCIKASqVCrVajUqlQKBRMNH0MESLgzCZTDbmdAOF0OrFarYiiiM1mAya32lYqlSiVSjQaDSqVKmT0K4uQqOVEwOl0YrG4mqxKBiwIAgqFQjZwgM8++4zh4WGGhoYYGRnBYrHgdDpDYX6IeRMK3YOM3W7HZrMhCAKCIHg0WnfjVyqVCIKAw+HAbrdjNptRKBSyp5f+HiLEXAgZepCQkm52u102cl9xv78U2o+Pj8t/m7q2DxFiNkKGHgSkdbjD4ZizkU9l6uOlY1utVjn8D3n7ELMRMvQAI2XWnU7nvI3cE1J4Lz2Xu7cHsFqtJCQkoFQqQ94+hEzomxBAnE4nHR0d6PV6n4zcYnditTtwOP1Ltk1N6ImiSH19PaOjo5hMJoaHhxkfHw/t24cIGXqgkLbPRkdHsVgsPnnypz7ppOLhj3i5qjcg5yA9p+TNnU4nZrOZkZERTCYTY2Nj2Gw2nE5nQJ4vxPIhFLoHgKmZdV9p0Y4B4PTTo8+EdC5S+C4tKaxWK+C6GKjVatRqdahYZwUQMvR5MJ/MOsDR/hEAtKO2YJzeJKau7SVvPz4+jiAIstGHinVOTEKG7ifzNfIhs41WnZkItYLBEWuQztIzM3n78fFxnE4nSUlJodLcE4iQoftBIDLrVV0mAJKiNGgX2NCn4u7tR0dHGRkZITIyUv5byNsvf0KGPkcCtX1W2WVCpRDIjg9HO7q4hu6O9Jrcw3z3tX1IiLM8CRn6HHAXpsx3j7qyc4j1adGkxYbR0joWoDMMPFONXirNBVAoFLLRh7z90iZk6D5itVrR6/XEx8fP28htDid1vSNcVp5BuEqBftSGcxnsc08tzQWwWCyyYCfk7ZcuoX30WZCSbiMjI7S1tQXky1vfN4LF7qQsO5bkaA12p4hhLPiZ90DiHuJL+/YOhwOz2UxLSwuDg4OYzeZQsc4SIeTRZ2BqZj1QSIm4suxYDk/8vtgJufni7u2HhoYICwtDo9HI3l7y9NK+fYiFJWToXpgqTAkkVZ0msuLDSYkJIyVaA7gMPSygz7K4SKW58MUFMyTEWTxChu6BYApTRFGkssvEl1YnAMiGPjhiJTtgz7K0cN+3D8luF4eQoU/BPbMeDPVZQ6cW/ZiNtQmuNW2ym0fPPpFcuhdmk91Kpbkhbx9YQobuRiC3zzyh1WrZ81kDAKsiHRw+fBi1Wk2kWqDXOEZpWsCfcsnjrTS3ubmZwsJCuVgnJLudHyFDn8BdmBKML1RnZyc9PT0Y1UnEhA1yZsV6FIKA2Wwm4YMq2voNjERZOHbsGMnJycTHx8sGsFJwD/GHh4cRBCEkxAkQK97Q51uz7svxjx07xujoKFu2bOHff3+A4qxYFBPPExERQUZ8JHZRJCpKRVJSEjqdjuPHjxMeHk5SUhKJiYlEREQE9LyWA74KcULefnZWtKFLRv7JJ5+wdevWgBu5w+GgtraWiIgISktLGTLbaR4c5dwNyZPulxKt4UjvMIKgIDExkeRk19/HxsbQ6XQ0NjZis9lISEggKSmJuLi4FffFDslu58eKNXT3zHowttCsVitVVVWkp6eTm5sLQFXXEACl2bGT7psc7RK2iOLkbFxkZCSRkZHk5OTgcDgwGAwMDAxw7NgxIiIiSEpKIikpibCwFZDFm4Inbz8+Ph6S3XphRRp6sPu6WSwWDh48yNq1a0lJSZFvP9xhRCkIFGXGTLp/SrQGs83JuMP7MZVKJcnJySQnJyOKouzt6+vrcTgcJCQkkJCQsCKr0Dxl8oeHh2lra2PdunWTBmOsVG+/4gw92Jl1s9nM4OAg5eXlxMZO9tyVnUY2ZEQTqZmcZJO22IwW34xUEASioqKIiooiNzcXu92OwWCgr6+PkZERjhw5Int7jUYTmBe2jJBCfLvdPqmllvS3lejtV5ShOxyOSdVZgaavr4/BwUHy8/OnGbnN4aSm28Tl5VnTHicZ+pCPhj4VlUpFSkoKiYmJjI2NkZeXh1ar5ciRIzidTnndHxMTs2K+2BKevL3VapX7+q0UIc6KMHRJXulPXzdfj9/a2operycrK8ujF23oHWbc5qQ8N27a31LmaejuCIJAdHQ00dHR5OXlYbPZ0Ov1dHV1MTw8TExMjJzJV6vV836+5YY32a00/849k38iGf0Jb+jB3j5zOp00NDQgiiLl5eW0tbV5vN/hDiMAZTnx0/6WMsfQfS6o1WrS0tJIS0uT1646nY6uri4AOcSPjo4+ob7YvjCb7FbS24eFhQXlu7OQnNCGHsiJKZ6w2+1UV1eTkJBAfn7+jMc/3DlEVnw4abFh8paQRGy4Co1SCIhHnwlBEIiNjSU2Npb8/HxZY9/R0cHIyAixsbGo1epl/YX2F/dW2eD67vT09OBwOMjKylr2QpwT1tBFUaS3txeFQkF8fHzAP5jx8XEqKyvJy8sjIyNj1nM53GFk++pEj38XBIHkaA1Giz2g5zgbGo2G9PR00tPTEUURk8lER0cHJpOJoaEh2dtHRUUtuy/2fHHft5fEOMtZiHNCGrqUWZd00QkJCQE9vslkora2lo0bN/p07C6DmcERK+UewnaJ5CgNQ5bFaz4hCAJxcXGkp6cTHR1NZmYmOp2OtrY2xsbGiIuLIykpSR73tJI4EebfnXCGHmz12eDgIMeOHaO0tJSoqCifHnOo01Uo4ykRJ5EcraHRNBKQcwwEYWFhZGZmkpmZidPpZGhoCJ1OR2trK2q1Wvb2ERERS/KLHUxmmn8nefuwsDBUqqVjXkvnTAJAsIUpY2NjtLS0sGXLljntTx/uMBIdpmRtarTX+6REa/gsyGt0f1EoFHJBDriWLTqdjubmZsbHx4mPjycpKWlFC3EkJG9/4YUX8tZbby3imU3mhDD0hRCmtLa2YrVa2b59+5y/zJUdRkpz4lEqBK+Va8nRGkZtYLU7Cdcs7TVfeHg4WVlZZGVl4XQ6MRqN6HQ6Wlpa0Gg02O12OXO90pCcjE6nW+xTmcSyN/RgG7kkTFGr1cTFxc3ZyE1mG8cGRzl308xic7ml1KiVbM3y+VgUCpcQJzHRlWg0m83U19fT0dFBW1ubLMQJRPfcEP6zfL5RHgh2zbrVaqWyspLMzEySkpJobGyc8zEqu4YQRSjPjZ/xfl/0jrORHdjc4YISERFBdHS0nNQzGo1otVqam5tl2W1SUhLh4eGLfaorimVr6ME28tHRUaqrq2VhytiYf0MWDncYUSoEirNiZ7xfkptHP1FQKpWyYUtCHL1eT0NDA3a7ncTERJKSkoiNjQ15+yCzLA3dbrczNDREZGRkUL4gBoOB+vp6Nm/ePK1mfa4c7nBNZIkKm/mtdu8GeyLiLsTJycmZJMRpbGwkKipKLs1dibLbYLPsDN1utzM8PExjYyMVFRUBP35vby9tbW1UVFTMO7x0CVmGuMyDkGUqiVEaBFjwyaqLhSTESUlJQRRFRkdH0el01NXV4XQ6sVgsDA0NERsbu+K274LBsjH0hRSmbN26NSB7oA193oUsU1EpBGI0J65Hnwl3Ic6qVauw2+0cOHCAnp4ejh49SnR0tLwEWIlCnECwLAx9IbbP6urqUCgUlJeXB2w5cLhjolDGrSKuv79fzkYnJydPEpPEhwkn1BrdX6Ty0g0bNiCKIiMjI+h0OmpqagDktf1KlN36y5I39IUQpoyNjZGenj6rMGWuHO4wkhkXTnpcOKIo0tbWhlarZf369XJd+cjICDExMSQnJxOrEdCOLK8ZbMFGEARiYmKIiYnxKrtNTk4mISEh5O1nYEkberAz62azmaqqKjQaTcCNXBRFDncaOSkvAafTydGjR3E4HJSXl2O324mMjJwkJtHpdEQrHRw1jNLe3r5ixSSz4Ul2q9Vq6ejoQKFQyCH+SqvQm40la+jBrll3F6YcPXo0oMcG6DKOMzhspSQrlsrKSuLj41m9evW0+0likri4OJI/62N40I5SpaatrY3R0dFJYpKlVDu9FHCX3a5evRqr1SoLcUZGRnA4HAwODobeO5aooUtZVyAo22f+CFPmitRoQmPqJGPzajIzMwG8lsACxGkEHCKExyVTlOUSk0jevq2tDZVKJXusyMjIkLefgkajISMjg4yMDLlCz2Qy0d7ePmlPfyW+d0vO0N2FKcH4MDo6Oujr65uzMGWufHZ8kHAlnF2xgZTkJJ8eEx/mer26USvJ0RpZSx8fH09BQQHj4+Po9XpaWlowm80rWjo6G1ITyIKCAsDVOUaqx1+J792SMXQps3748GE2b94ccE8uiiJNTU2YzWYqKiqC+uEODw/z2fFBSrLjfDZygLgJQx8csbLOQ2l8eHj4JOmoJCZpbW1Fo9GQkODKB4SYzkyyW41GIxfrREZGLvapBoUlYeju22eSrjeQOBwOampqiIqKoqSkJKhh29DQEAOGYbpHRC7e4ruRw2RDnw1PYpLBwUHMZjMHDhwIiUlmYKrs1mw2o9frZdmt9N6dSBfNRTf0qZn1QGO32zl48CCZmZnk5OQE/PgS7jPWxiLTEOn0qVDGHSl096doJiIigqysLAYHByktLQ2JSeaA9N5lZWXhcDjk925wcFDu/b7c37tFNfSFUJ/19vZSVFQkzzMLBk6nk9raWsLCwsjIyODdI8MoBCjOnpuha5QCMWHKeZfBuiee4IsZbkePHl3xM9xmw/29i46OZnx8XN4eXc7v3aIZerAnpuj1enp6esjNzQ2qkU+dsdbS0sKRPjPr02OInkXI4glpDlsgCc1w8x+NRkN2dnZQ3ztBEMKB94EwXDb5oiiKPxMEIRH4PyAPaAMuF0XRMPGYnwA3Aw7gu6Iovj7TcyyKoQe75VNPTw/t7e1kZ2cHddzw2NgYVVVVrFmzhtTUVADsTpGGgTG+5oOQxRPBMHR3ZpvhJvU6k+oXQnyBL/PvpLLmOWIBzhJFcUQQBDXwoSAI+4BLgLdFUXxIEIS7gLuAHwuCsBG4EtgEZAJvCYJQKIqi1+l9Cxp7SEm3YApTjh8/Tm9vb8CEKd4wGAxUVlayadMm2cgBWvRWxu3irI0mvJEcpVkwBZskHc3NzaWsrIzS0lIiIiIYHh7mwIED1NXV0dfXN60PfQjP711sbCzd3d3s2LEDg8HAs88+y8DAwKzHEl1InUHVEz8icCHw9MTtTwMXTfx+IfC8KIoWURRbgWZg20zPsWCGHmwjdzqdHDlyhPHxccrKyoJq5H19fRw9epTy8nLi4iavw+sHXLsGfht6tHpihPLCN4pUqVTExcWRkpLCtm3byM3NZXx8nCNHjnDo0CFaW1sxmUwrcmLrbEiy240bN/Lhhx8SFRVFd3c3v/jFL3x6vCAISkEQqoAB4E1RFD8D0kRR7AWY+FfyKFlAp9vDuyZu835+c3s5/iGKIlqtFlEUg6IvttlsVFdXk5SURF5eXtBCTknKqtPpvEYM9QPjpEaryYjzL0ObEq1h3O5kxOIgJnzxcqW+iElW8gy3mZD6vN91110+P2Yi7C4VBCEeeEUQhKIZ7u7pCz7j1Tfo3yQps67T6eQGi4FEEqbk5+eTnp4e0GO7IwkoNBqNVymrKIrUD4xTkuV/WW1y1BctpRbT0KfibYZbZ2envKcvZapD+I8oikZBEN4FzgX6BUHIEEWxVxCEDFzeHlwe3H2vOBvomem4Qf0mBVuYMjQ0xJEjR9i0aRPx8fEBPbY7druduro6lEolmzZt8vo6uo3j6MwOitL9r65KdmsplZ+0NKu0ZpvhJooiYWFhREVFrXgxiS8IgpAC2CaMPAI4B3gYeA24AXho4t9XJx7yGvAXQRB+jSsZtxY4MNNzBO1TkHTkwdo+s1gs1NXVUVZWFtSyRWnGWkZGBgaDYZZBikYANgfA0JdTSyn3GW5SrkTakVjpYhIfyQCeFgRBiStv9oIoiv8QBOET4AVBEG4GOoDLAERRrBME4QWgHrAD354p4w5BNHT3IXWBpru7m7GxMU499dSgClOGh4epqalhw4YNhIeHYzAYZrz/4Y4hIlQC+Yn+V1ClRC0/Q3dHoVAQFhZGeno6cXFxK15M4guiKNYAZR5u1wFne3nM/cD9vj5HUOMqQfA+mcQfRFGksbGRsbEx4uPjg2rkU6WsvrR7PtxhZH1KOCqF/14rJlyJRikwMHxiTDrxdYbbiSomWSosmwWUJEyJjo5mw4YN1NfX82mrnpPyEgIeDnZ2dtLT0zMnKevwuJ2mgRGuLo6f13MLgsCmjBj+8nkPWXHhXLUl84QJd+cywy1EYFkWxboWi4WDBw+SkpLC2rVrEQSBBp2dG/50mPebAzfjSooYdDrdnPXqVRMTWTamzl/48P8u38QpqxN48I3j/OhvRxld4LnpC4U0w624uJgtW7aQnJyMXq/n8OHDjI2N0dXVhdlsBmDM6uD9Y0trntlyYskb+sjICAcPHqSgoIDs7Gz59p4RV+7hYJsxIM/jcDiorq4GoKSkxK9BigoB1qfMbuizLWfiItT89vJN3H5mHm80DHLlU5UcGxid0/ksN6QturVr17J161ZZKdbU1MTnn3/Of79Ry7dfqKNqIuEZYm4saUPX6/VUV1dTXFw8TZgyMOrSCh+aaNk0H5xOJ4cOHSIxMZF169b5FSof7hxiXVo0kWrvb6koijQ3N/Ppp59SW1tLT0+P16mjCkHgli/l8vg1xQyP27n6qUr+Xts/5/NarigUCrKzsykpKaG8vJxmo+vz/p+362Z970JMZ8mu0Xt6eujo6PA6MWVgzPXB1/aYsNqdaFT+XbNGR0cZHR2ltLR0Us36XLA7nFR3DXFxaYbX+0jbTmq1mu3bt2M2m2VBhDSHzG6343Q6J+1UbF0Vz19vLudHfzvK3a81cqhjiK+VZVCQEkmEemVkrRUKhVxafGgQ0rNXYR42TnrvQjPcZmbJGbooirS0tGAymdiyZYvXgovBMQdqpYDV7uRIj8mv2nJpxlpkZCQpKSl+n3Nj/whjVsfEOUzPzttsNqqqqkhNTSU3Nxer1SrPIcvNzZXnkPX09HDo0CF5DllSUhIajYaUmDAeu6aY/36vjcc/7uSlqj4EICchnLWpUaxNiWJtahQFSeE4T8A69FadGaPZzsUlabxS3c+HHWNcXJI76b2bOsMtWE0/lytLytCdTidmsxmr1Up5efmMIfTAqJMzC5N5o2GQQx3GORu6+4y1ysrKeZ231PG1PCeecf1kQ58qZfW0PpcEEe3t7ZSVlWE2m9FqtRw5cgSn0yl7rO+ekcdl5Rk09I7QNDjKsYFRjg2O8s8mHc6Jw6oVsKb6MGtToyhMiWJtaiRrU6JIjtYs2+x9VZdr4s3Xt+dQ2WXilao+Li5xlTt7m+Em1Vq0tLTI3n65vv5AsGQMXfJ6CoVi1nXyiMXOiE2kODuOpoFR2dB8IRgz1g53DpEeG0ZmfDgt+i9uNxqN1NXVUVRU5HONv/scMncxSXd3tzyHbFNSEqcVZMpiknGbgxbtGEf7hvm4vg2ToOLj4wZeq/liTZ8SraEsJ5bynDhKs2NZlxY9r/3+haSy00R8hIr8pAguKUnn1++00qIdY3Xy5L139/cuLS1Nfr9CM9yWiKGbzWYqKyspKCigtbV11itvt9G1XstOiKA8N453GrU+NUpwOp3U19cDBHjG2vSIor+/n+PHj1NeXj6v5hfexCTSHDLpi7shPZp1qZGscvZSUVEMgGHMJnv9mm4TVV0m3mjQAhChVlCcFUt5TixlOXEUZ8bMOtp5sajqMlGa7fLIX92cxm/fbeNv1X3ccfb0gRjuKBQKUlNT5UhqZGQErVY77b1zn393orLon+xUYUpra+usj+mSDD0+gorceF6u7KVFO0ZBivd1md1up6qqisTExICOX+oxjtNnslCe4/LYoigyODiIxWJh69atAfUcs4lJYmJisNls2O12VCoVCZFqtuXFsy0vnmu2uuTKfaZxKjtNVHaZqOwc4o8fduAUQSHAurRo1iepWRuvIDLJQlrs4reW0o9aadObuWgiVE+O1nDamkRere3nO2fkoVb6drF2l916eu9iY2Nl2e2JKMRZ1Fc0MDBAc3PznIUp3UOubZWchAiiw1yZ58MdRq+GLglT8vLyyMjwnhn3B0nIUp4bLxu5IAhs3bo16BlgdzGJKIoYDAYMBoO8BJI8lvsMt/TYcM7bFM55m1w7DCMWOzXdJg53ujz+vkYjr9hFfvGRjqy4MMpy4ijLdnn9gpRIFAvs+aq6TACU5cTKt11Sms47TTreb9Zz9jr/+gFOfe+kiTjuM9ycTucJY/SL9ira29sZGBjwy+t1G8eJUAnERaiIi1CRGKXmcIeRyyqmN9kwm80cOnSIjRs3yqWXgeRAq4FIjZKC5HAOHz6MUqkkKytrwbd5pBlu4eHhVFRUYLFY0Ov1s85wiw5T8aXViXxptas/fG//ALWdevqd0VR2mvik1cA/jrhk0DHhKkonwv3SnFiKMmIID/IWX1WXCbXSVRYscUpBIinRGl6p6vPb0N1xn3/nPsOtq6sLi8XC6Ojosp9/t+BnLYqi3Dq3oqLCL4PoNo6TGqmQvVR5TrzHwpmRkRH0ej1btmwJynbLP2r7eOFwN+dvSqXq8GG59dJSWO9JraczMjImiUlmm+GmUgisTQpjV342121zfV5dxnEOdw7JIf8Hx/XyfTdmRMsJvrLsWBKjAis0quwysTE9hjC3OgmVQuDC4jSe/KSTgWELqTGBXWJIM9xEUcThcBATE7Ps598tqKE7nU4qKyuJiYlh/fr1fr9J3cZxUqO++ODLc+N56+gg2hELydGuD72jowO9Xk9+fn5QjPzdJi0/frmOsqwYvpJmorBwI4mJibS0tAT8ueaLNzHJ8ePHZxWTCIJATkIEOQkRXFjsWicbx2xUdZk43DVEVaeJP3/ezZ8+7QIgLymCwjg4fV04Z2yMInYeXXIsdid1vcNyfsGdi0vSefzjTl6r6eeWU3L9fo7ZEARhxvl37u+dv7JbQRBygGeAdMAJ/I8oiv+1LNs92+12Ojo6KCgoICvLv1bI4PIw3UMW1q/6wnNUTGS8D3cMsXNDijxjLTs7Oyih1udtBr77fzUUJIdzc6GNreWly6qFkiQmycrKmjTD7fjx4wiCgEajwWw2e90tiI9Uc0ZhEmcUugZESAZZ2WnicOcQ77cZeKOlHcX+dooyYjgpP56T8xMozY71OXkGUN87jM0hUpodO+1vuYkRbMmN45XqPm7+Us6CeVZv8+9aWlrkGW52+5xFSHbgB6IoHhYEIQY4JAjCm8DXCVC75wUx9JGRETo7O8nMzJyXkYOrIYPF7iQ18osvzMYMV2h3sE1PqrWHiIgISkpKaGtrm+eZT6eux8Q3/1JFWrSK72xWcOpJ5ct68MHUGW7d3d1otVqampqwWCw+zXALUykoz4mjPCeOm8mhruEoOmKoGbDxSauBJz7u5LGPOolQK9iSG8/Jq12GX5A8c+hbOZGI82To4ErK3f1aIwc7hti6Kn5+b4QfeJp/p9Vq+c53vkNHRwd33HEHF154IaeffvqMx5no8Cp1ex0WBKEBV1fXC4EzJu72NPAu8GPc2j0DrYIgSO2eP/H2HEE3dGkUUGZmZkC8XpfBJVt0D901KgVFmTF8cLSH6zavDdqMtZ5hBz9/o5IIFfxoWyRnbS874bqkaDQaefvOfQ7ZXGa4qRQCJenRnLYhjttOz8M0bufzdiOftBr4tNXIB2+61vip0Rq258ezPT+Bk/MT5DZaEpWdJlYlRpDkZd1/zvpkHni9mVeq+xbF0KcSERFBTk4Or732Gqeeeiq7d++mubl5VkN3RxCEPFzdZqa1exYEwb3d86duD1vcds9dXV10dHSwZcsWent7A3NM44ShR35hYKOjo6QrR6kadpKclhmQ55lKr8nC/R+bcDhF7t+ZyplbipZNIsZf3Pu9iaIoC3EaGhqw2+0+zyGLDVdx9rpkOUPeMzTOJy0GPmk18n6zntdqXVn9talRnDwR5ot2J9XdJk5bk+j1uBFqJV/elMprNf38ZJd9SXXNVSgU7N69e06PEQQhGngJ+J4oiqYZvl9Lq92zKIozClP8oVPvMvSUidBdEqbsLCtgT2sjNd1DnJTv/cvhD7oRK998vo4xq5Nfn5/LWeWFAT3+ckAQhEkz3CQxSX9/P01NTURGRk4a7DgTmXHhXFqWwaVlGThFkYa+EdnbP3ewh2c+60aJK8s0Mm6nrmeY9enRKD2U7F5Sks4Lh3vZVzfA5RXBucgvBBOjmF4C/iyK4ssTNy+Pds85OTkBnzHdZTSTEq1BoxTkGWsVFRVYRCXQyKEOY0ANfXjczo1PH6JvaJw7t0WsSCP3hDcxSV1dHaOjozgcrrzQbGISxUTrrE0ZMdzypVzMNgeHO4b4f2/WU6dz8naTjrebdMRFqNi2yuXtT14dT3a8K1G4MSOawtQoXq7uW7aGLrjeoCeABlEUf+32p6Xf7jlYdBnGyYwLY3R0dNKMtXCgMDWKwx1DAXsus9XBzU8fpHlwlIe/kke2ajhgxz6RcBeTrFq1ioaGBiIiIqaJSRITE2dtzxWhVnJKQSL/+4GrIOrlb1RwoN3IJ61GPm0x8OZRV61+TkI4p61J5Ltn5HNJaToPvXGcxv4R1qUtn90PN04BrgNqJ8YyAdyNy8CXdrvnYNFpGKMg1rUnX1ZWNmltWJYbz57aPhxO0WOYNxesdif/8uzn1PSM8NCF6zh7fRKNjY3zPf0VgbRvn5eXJ4tJdDodtbW1ALLsNiYmxqu3bzY4Kc1KIDUmjPOL0ji/yCXqadGOuYy+1cBfPu/B7hS57bQ8/vPtFl6p7uOuXWsW8qUGBFEUP8TzuhsC1O55WbXjMFus9A1ZyIoLIzo6eloCqCI3nhGLg2MDI16O4Bt2h5Pbnj3AZx0j/OzLhVxUHpws/kpAEpPk5eVRUVFBcXExkZGRdHV1ceDAAerr6+nv78dms8mPMYzZ6BsTKc2JnXasgpQort2WxaNXFHHN1iz+71Avrboxzl6XzD+ODGC1B3apeKKwbDy62WzmjY8PIwIbV6UhCNM7gkpS0UMdRtanx0z7uy84HA6+97+f8V7bGD88p4CrTgpe1dVKxJPsVqvVTprh1mByfS3LsmfW8H/njDzeadLysz1N/ODs1eyvH+SdJi3nbvSvJdiJzLLw6ENDQxw+fJjwZFcX2Kw4zwUq2fHhpMaE+b1Ot9vt3PWXT3izZYxbd6ziG6fm+33OIWZHkt2uXr2aLVu2UFRURFhYGB829KAURFSmbgYHB71WmkVqlNxz3lpadWaqu0xkxoXxUlXfAr+K5cGSN/SBgQF5xprR5to7z473XKwhCALluXFz6jgjMT4+zn3/9xGvNY9z5ZYs7jgnOGs9aT86NGN8OpKYpMuiYVWsglXZmZhMJqqqqqisrKSjo4PR0dFJ790pBYl8dXMqT33axY6CRD5tNcqNSUJ8wZIO3Ts6Oujr65OHKXQZelArBVJjwvA2Ba0iN579dQP0Dvn+YTscDn792gFeaLLxlaI07vmK/4KbmbDb7dTU1GC1WrHb7aE5ZB5wNfsc5sxspSwmAWac4fajcwr46LiBqi4TAvC36j5uPil4I7SXI0vS0CUpq8ViYcuWLXLSrctoJiMufMaMerkscDGy0YedFq1WywftYzzbpOD0tUk8fMmmeWfsPWGxWKisrCQ7O1uujR4aGkKv18tzyKxWK2azeUV3MK3vG8HqEFkTPznYnG2G2y0V8fzig0HyEiP4W00/X9+atkivYGmy5AxdFEV5xlpxcfEkz9ppMJOTMHP/tfVp0URqlBzqMLJx48xik46ODp75pJ2/HFNQkRvPf11ePCd1la+MjIxQXV3NunXriI+Pl2fGS22hFAoF4+PjVFdX09zc7LOY5ERE6vg61dDdmSq7NZvNJOt0vNFooHbQjEOEd+p7yFWHlkcSS+obZLFYGBkZITk5mcLCwmnhc5fBLFdEeUOlVFCSPfM6XRRFquuO8rP9bTxbb6EoWcnvry4hQhP48Fmn08nTZqROsGFhYWg0GtRqNUqlElEUUavVKBQKNmzYQFlZGYmJiWi1Wg4ePEhNTQ3d3d2Mj5/4a8/KThO5CeHEhfkeVUVERJCdnc0vrygnTKVApYDXjgxiNBrl906a4bZSWTIeXfJ6klZ62t8tdgxjNrJn8egAFblx/O69VkatKUxVkDocDvZ9VMlvPh+hZ9jOHWcXUKTqDYogoru7m87OTsrKylCr1fLMeED20kqlErvdTn19PWlpaSgUimne3mw2YzAY5M48vopJlhuiKFLVZWLHmkTANOfHp8eG8/2zVnP/680c6LHy9U1xrFmzBp1OR2Nj4wn93s3GkjB0vV5PQ0MDxcXF1NXVebyPJE/1xdDLc+NxinB0cJwvxXxxf6vVyu/3fM6TR8aJClPz1A3lbM9P5JNPArslI4oix44dY3h4WB5E4W7k7oyPj1NTU0NOTo7cuNLpdCKKIk6nE4fDQVhYGOnp6XJ7o6GhIQYGBqaJSZZrPzOJDsM4+jEbpVmx4Ji7oQNcXpHBS1W9HO0f5a12C6ds/UKI43A4MBgMDAwMcOzYMSIiIuT3bjn3FPCFRf9mzDZjTUKSp2YnzD6ttCQ7DoUAdQPjfGmi9bdhaJi7/3qIdzrtVOTG85vLNgelnbEoinR2dhITE0NxcbHcb96TkQ8PD3PkyBHWr18/qXGlu7dXq9WywYuiiCiKciNDQRBkby/NIbNarRiNxmU5h6yy07U+L8uJxdDm3zEUgsDDF23goj8eZM9xC/e49ftXKpUkJyeTnJyMKIqMjY3J8+8cDofs7Zfjezcbi2bo0ow1o9Hok5S1y/BFL3dXWy3vRIep2JAeIw/mq2/v444X62g1idz0pVXccU5BUJJuNpuN7u5u4uPjWbduHU6n06uR63Q6jh07RnFx8axZdoVCIX/xJG/vcDhwOp2Eh4eTkZFBZmYmNpuN6upqent7J80hk2a4LXWqukzEhKtYnRzJoTb/j7M6OZJTC+J5/7iRpz/r4uvbp5cwC4Lgcf6d+ww3pVI5r+EbS4lFMXSn00ldXR1KpXKaMMUbXQYzUWFKEiLVPo3LLc+N54VDXbxZ38t/fWpAUCh59MpN7NwQnPJIacZaXFwciYmJMxp5d3c3PT09lJeXz9kA3b09MMnbj4+Po1arKSgoQKFQMDY2hl6vl2e4SUY/k5hkMansMlGaFRuQ3vH/tiuP3b+v4r/fb+fS0oxZczCeZLetra309vai1WpJTEwkOTl5yb53s7Hghi7NWEtOTiYvL8/nN03KuPt6/9LsWJ79TOSBDwwUpkbx/64sIS/J9yERc0GasbZp0yZsNhvNzc10d3eTlJREcnKyPPJHFEWOHz/O6Ogo5eXlASmSkby9TqejubmZjRs3olQqcTqdREREkJWVRXZ2ttwWqquri+HhYWJiYmTp6FKYQzZkttGiHeP8osBciBMiNZSkqqgasPOrt45z3/nrfH6sJLuVCnLS0tLQ6/WT3jtJgbcU3jtfWFBDt1qtHDx4kPz8fNLT51a51GU0k5vom6Fqh8d54r0mANanhPN/t24L2qABacZaSUkJYWFhCILAtm3bsFqtaLVaWltbGR0dJTY2lrGxMXntHkiv4C1CkLy9NHNdamQoCAIjIyMYDAa6ulxtmt1bRi0GVbM0gvSH89eEUzUwwsvV/VxQnE5Frm+DLqfi6/w7f2e4CYLwJHA+MCCKYtHEbQFr9QwLaOjj4+P09fVRWlrqsX/4TIiiSJfBzCkFs7cpOtim4zvPVTFig9gwBWkx6qAZeVtbG4ODg7J3dg/VNRqNXMklVcVpNBpZoCMlheYzBGC2CGGmtX1UVNSktlBGo5GOjg6MRiNqtZqoqKgFnUNW2WVCpRAoyvRPdeiJ9YlKchLC6TdZuHdPEy9+o2LSIAh/mG3+XWxsLPX19XON1v4EPIqrt7vEXQSo1TMsUMHMwMAAfX19rFq1as5GDqAbtWK2Ob2KWcD1pX/ig+Nc/6dKwjUqXvjGNiqyIqntC7yARBRF6uvrMZlMlJaWTjNyd8bGxuRJseXl5Zx00kls2rQJlUpFc3Mzn376KUePHmVwcFBuv+QLTqdTXnsXFxfP+sVSKBQolUo0Gg3h4eFoNBrZiKUmkIWFhRQUFBAdHc3w8LAsJmlvb2dkZCSo3r6yc4gN6dFEBPCiLAgCl5SmY3WItOnN/PGD9oAdW0Ka4bZp0ya2bdtGRkYGn3zyCW1tbZx11lk89thjsx5DFMX3Af2Umy/E1eKZiX8vcrv9eVEULaIotgJSq+cZCfrlur29nf7+fnJycvzO/MoZdy976CMWOz9+sYa3mvSctjqO/7y8lNgINUWp4fyzZYQug5kcH8P+2ZCEKTExMRQWFs64fWY0GmloaGDTpk3Exn4RknoaoKDVamlpaUGtVk/y9p6QsutpaWl+t7b25O0lzx4VFUVmZiZ5eXlYrVYMBgOtra2MjY3Jk0kCKcSxOZzU9Y5weXlgB2ACXLg5jUffbSM/OZKnPu1i98aUoLWbkqa6/PKXv+TAgQP85S9/obm52d/DBazVMwTZ0I8ePYrZbGbLli10dHT4fZzOiWIZT3Xun7Xq+fHLR+gftvLd03P51plrZaPbmOaKAA51GANi6A6Hg4MHD5KTkyOv17wZeX9/P21tbZSVlc1YH+BtCEBjY6Nc856cnExCQoKcSa+pqaGgoICUlJR5vybpHJxOJ01NTYSFhbFq1SqcTqc8TVTKRguCgMlkmiTEcZ9D5i/1fSNY7M5JE1MDRUpMGKeuSaS2Z5iYcCU/29PE/369DFUQhEtTkaa1Bpg5t3qGIBt6enp6QLYjpKq4LLc693G7yM/3NvLsZ52kRQr86boSTiqY/MVfFa8hSqPgUMcQF5XOr0Po6OgoRqORsrIy4uLivBq5KIq0t7ej1+upqKiY8xpXGgIgVXJJ3v7YsWMolUrMZjMbNmwImJGD5wjBffvO/Sc6OlqeMW6xWDAYDDQ3N0+a4TbXEL+qc2I08iwdZfzl4pJ03j2m5+vbs/nTp138+UA3N2zPDspzBZCAtXqGIBt6fHx8QNo9dxnNJEdrZNHJ4c4h7np3iP5RA+cVhPPzy7cRHT59WaAQBIrSIv1qROGONG0mLi6O2NhYRFH0uPfvdDppbGxEFEVKS0vnXV3lPkChv7+flpYWsrKy6Ozs5Pjx4/Le7nwUbrNFCJ5CfMno1Wo1KSkppKamyt5ep9MxODjI6OgoaWlpJCUlzVp0Utk1RHZ8+LRJLYHi1DWJpMeG8c8mHTtWJ/Doe22ctS5pViXkIhOwVs+wBEpgfUGSp47bHDzy9nH+9EkHSeHwwNkpXHLqzFtVRekRPPH5IMYxG/GRc9/z7Orqoquri+LiYiorK2ltbSUlJWVapGK326mtrSU+Pn5O9QGz4R4hSK2twbWM0Ov19Pf309jYSGRkJMnJybOOS3LHWw7BG56KddwLdmJiYoiJicHhcBAfH4/dbqepqQmr1Tpp6qj7RUkURSq7TJyyOvCz6yXUSgUPXLCOW/5cQ35SBAoB7tt7jMeu3rwkil8EQXgO14y1ZEEQuoCfEcBWz7BMDL3LYCYvKZILf/8ZbboxzspV8bU1Ks4+rWTWxxalu9aOlZ1Gzlzne7griiLNzc2ThCknnXSSvJUyPDxMbGwsycnJREVFUV9fT25ubkDXZDNFCEqlcloll1arpa6uDofDIXt7b3XbUg6htLTU7zJPydurVCrZ24+OjjI0NERWVhbh4eGkp6cjiiImk8njDLeBMRH9qC2g++ee2LoqnttOz+O377Zx3sYU9tUP8reafi4uWfxONKIoXuXlTwFp9QzLwNDNNjs9xnF6jOOkxWq4c0sY55Wvpr+/36fHr0+JQK0UONThu6FLW1dqtXqSMEXaSnH/8nZ3d3PkyBEiIyMxm80MDw/7XTjhzlwiBPcBCnl5edjtdvR6PT09PTQ0NBAVFSVn8tVqtRwhlJeXB6yyS6FQyBFCUVER0dHR8p49IO89C4IgzxhvaGjgvXbXjsqaOIVc2BMsbv5SDoc6hnirUcv6tCh++VYLpxYkBm3JsJRY0obeOzTObc9XIwLFGVH8ywYH28qK0Wg0Pht6uFrBxowYnzvD2mw2KisrSU1NJTs722vSTRAEbDYbJpOJ7du3o1Kp5NZGo6OjxMXFkZyc7FfRiSRd9TdCUKlUpKamkpqaKg9Q0Gq1VFdXMzY2RlhYGOvXrw9oMYynCMFbsU5YWJgsxHmlq5lojZZwq4HPP2+XhTiBHuUFrpzNgxeu52uPH8JotjNutfPA6838+tKNAX+upcaSNfS3Gga4+9V6LDbXB35etoMdJ20hPDx8zp1WKnLj+d8DXVjtTjQzVEZJwpSCggI5e+xt+6yrq4ve3t5JZafuPc2kULW1tRWVSuVzJZw36aq/SAMUIiIiMBqNZGVlER0dTVdXFw0NDcTExMhre3+8u3sOwVuEMJMQp7p7mJLsWNa4CXEMBgPj4+McPHhQrimfbYabryREqvnVxRu48dlq8pIiefOolrcbtfKk1xOVJWnobboxvv18DZsyYtiSpuLpKgNnby/xOck0lfLceJ78uIMjPSa5eeRUjEYj9fX1bNq0iaioKK+ZdWntbjabvQpTFAqF3MF0zZo1jI+Py6KTsbExWfecmJg46fFzka7OBU/NLdyXHzqdjs7OTgD5guTL8kPKITidzjntMkhre6PZRovOzFeK0iYJcSIiIujv72fz5s0MDQ1Nm+E2XzFJWU4c3z0zn9+800pKtIYH9jezbVX8khq7HGiW5CtrnxiNfO0GNZ/3WFApBLIS/P/il+fEA67CGU+GbrPZaGhomCRM8fQldzgc1NXVERERwebNvmdsvVXCHT9+HI1GQ3JyMna7HZ1O55d0dSZmihAEQZCbWKxevRqr1YpOp6OtrU2u25a8/dQwPxC7DNUTjSYqVsXLr9nhcNDe3k5YWJjcBFLK1I+OjqLX62UxiZRw9Ccn8vXt2RzqGOKjFgNOp8iv32nhZ18+cSflLklD1w67QvP0hGjGB9RkxDlRzaNRRFK0hryk6fvpoijS1taGxWJh27ZtM9asW61WampqSE9PJzvb/2KLqZVwY2NjNDQ0MDIygkajobW1dVIl3HyYa4QgDVBwb1ml1Wppb2+X9/STk5NRKpXU1tZOihD84XDnECqFwOYsV8Zdqs6TIgRg0to+MjJSLiiS2kJJYhJpCZKQkOCTt1cIAvd/dR2XPXGYEYudFyv7+PKmVLauivf79SxllpyhO51Oao+3AlCybjWPfHbYpz5xs1GeG8c7jVqcThGFQsDpdHL06FEcDgeRkZGMjIzI7ZmmMjo6Sm1tLWvWrCE5OXBrOYfDQXNzM7GxsZSXl0/y9seOHSM8PFz2qHPdAvOUQ5gLUt321AEKjY2NGI1G2cs7HA6/a97dhSwzRQhT1/ZSdl4K4yXZrbT1qVAoiI2NxW63y3kWT8RHqvnVJRu44ZlqwlUK7t3TxEvfqAia2nExWVKGbjKZGBkZQRWdTphKS6RGSafBzNlz2P/2RnlOPC9XuiZvrkoIo7q6mri4OPLy8tDr9XR3d8vrQMm4NBrNpC2jmJjASSg9RQjulXDgusDodDoaGhqwWq0+VcJJOYSxsbGANbcAV4vqsLAwbDYb27Ztw263TxPiJCUl+ZxbsDqc1PYMc0VFpsccgid8kd2uWrUKm83GwMAAY2NjHDhwYNJUl6lLkJKsWL5/Vj6/equFDsM4f/iwg++deeLN3Fsyhj44OMixY8eIiopibERBUpQGo9mGftRGfvL8E1MVEyHZZ8cHGRB7yc3NlYUpUmbXfbpndXU1VqsVh8PBxo0biY4OnOJJKjudLUJw72nmrRIuOTlZ7mDqnkMIdHMLTxGCtOYfHx+XoxCp5l0Ko71daBp6h7HYnaxP1lBVVcW6devmtMvgLZPvdDpRKl3jnPR6PUVFRZhMJgwGA21tbahUqklCHEEQuH5bFoc6hni3ScdTH3eye0MKG9KDo3BbLJaEobvPWDt8+DC6USuJURqOD44BsCZ1/oaenxRJfISKt6pb+eXXimVhirtnlJoKSOWtOp2OjIwM+vr6OHbsmJycmk/7JX8jBG+VcEeOHMHhcBAXF4fBYCAzM5Pc3MCNevZllyE8PJzs7Gyys7NxOp0YDAa5Ci4sLEy+ILkvP6SOr+EjPWzeMv9dBndvbzabaWpqkusgJCFOXl4eFosFo9E4bYbbfV9ewxV9I/QPW/i3vzfyfzeXz+t8lhqLauiiKNLU1ITZbKaiokL+EulHbSRFa2geGAFgTcr8DV2n05EfI9Ixpp5VmHL06FEAysvLUSgUZGVlTSrjbG9vl9eIc8n69vX10dHRMat0dTamVsKZTCaqq6uJioqiu7sbo9EoG9d8MvhShBAeHu7zLoP72hmQWypLs/Sk5cfHTX2kRAicdXJFwHcZ6urq5AhBKryRvL0kxJFkt9L8O2NrK98sVnHfRxaaBkZ55tNOzs1bEn4wICzaK3E4HNTU1BAVFUVJScmkL5F+zEphWjTNg6NEapRkxPpvFOAKO7u7uzl9UzaP/LMd3aiNlJjpPd2lphKJiYmsWrVq0jm5b0UVFBTIySlfKuGmFpUEsiJNihBKS0uJiYmZVAlXU1Mjd3+V6t59DeelHMJ8mlsAREZOHqCg1+tpamqiusdMSZqGgYEBkpOT53Xhk5B2GTZv3ixHCNLF3H1t7/7jPhFn4/g4PZZW/vi5nv96t43M06LIT4kOemnuQrAohm61WqmsrCQzM3Pal0gUXSKHhEgNDX3DFKREofCzSYAoivT19SEIgqutdLcJaKeqy8TODZMTfHMtO/U03dNTJVx4eDiNjY0AAZGuutPX10d7e/ukCEGqhJM04zabTS6IkTqYzlYJF4zmFtK59fX1YVHHMmwzs2N9phw12O122dv7My7J1xbaM8luNRoNt55RSJ3uKB+2GPl9tYV7tsPBgwcnCXECcVFaaBbc0EdGRqipqaGwsNBjIsriAIvdSVKUmubBEXb40BDSE06nk97eXsLCwigtLcXpdLIpI5YwlYL/PdBFemwYRZmutbhUVLJhwwa/etpNne4pVcIdO3YMvV5PdHQ0+fn5Aeu5NpfmFmq1epoQR6vVeq2Em6t01VfcI4QWvRroZ3tBCqvSolm1apUsxOnt7eXo0aOyEGe2cUlSg0x/dhm8JfQeuKCQC/54mBajnY8Go/n2ztJlP/9uQQ19dHSUtrY2iouLvSaiTFaXMURolAwOW/1an1utVqqqqoiIiJCFHQqFgjClwG1n5PO799q44olDbMyI5ivr4lit0LG1vGRe7ZDcka7+3d3drF+/nvDw8GmVcDP1hJsJ9xzCXCOEqcuPqZVwarVrOEZJSUlQdxker24kJkw1Kck6VYgjJRtra2txOp2TvL20/JAGgYSFhc2pUtEbkrdPVqv5j3PS+e7fu3iy0sgl28ykxXiefxfsGW6CIJwL/BegBB4XRfEhf46zYIY+NDSE0WjkpJNOmjH0MVlchm62ubT0a1Ln9oWThClr1qwBoKmpiYGBAVJSUkhKSuLmL+VyRUUmf6/p59lP2vjlu91Ehym5YLiLKyoyWTvH5/OEpwjB155wMxHo5hZSJVx6ejptbW3y+yS1K5bW9lFRUX4/l6ddhsrOIUqyvU9kmZpstNlscq1DQ0MD0dHRxMfH09vbS0ZGxrxyCFORIoRkxRj/siOXP3zYwXdebORv/7Jl2vy7qdNupRluf//731EqlfMqJpp4H5TAfwM7cbWQ+lwQhNdEUayf67GCbujSjDWTyUR+fv6s65vhCY8+bLYDUDAHjy692UVFRbK33L59u0fvUBRu5oHTonAkbOCFw328eLiXv3zeTXlOHFdsyWT3htQZlW7ekLaVSko8RwhTe8JJW1GzVcLNV7rqDfcIYevWrfLFxmKxyAUxo6Oj8t74VCHOTPT390/LIQyZbTQPjvLlTb5PZJk6QGFwcJCGhgbUajV9fX3YbLaAjEtyjxCKi4spBt5p0tE0MMr/fNjBN0/Lk+/nbf6dw+Hg6NGjvPjii5SVlXHeeefx8MMP+3tK24BmURRbAARBeB5Xu+elZejSGycIAtnZ2T59QaTQfWDEQoRaQVacb4mPvr4+WltbKS0tRaPRTKpZd/cOksHI7Y+U3XxvezJ3nLmKvQ06/u9QDz9+pYGHXm/m4pJ0LqvIZJWPHWS7urro6+vzuezUfbonTK6Es9lsciGPUqmkvr7e7xyCN6RdhoSEhGkRQlhY2CQhjpRs9KUSbqZdBmkiS1mOf40gh4aGOH78OGVlZcTGxsrJxqldf+Za6+Btl+Gp60s54zcf81bjoGzoM8luFQoFF198Mb/4xS+orq72uW+CF7KATrf/dwEn+XOgoBp6dXU1sbGx5OXl0d7uW/N8ydB7jOOs9iHjLglTtFqtvO89kzCltraWzMxMuZhCqoTTdXVRpIJTz0uhzRzGa/UGnv60iyc/6eSU1QlcsSWLMwqTUM0iXS0rK/M7XPNUCScZTEJCAqOjo0RERARkHTiXCMFTslGKQsxm86TlhyAIMzbIrOwcQil8IWSZC54iBG/JxrnUOsy0y5AQqWHft08iM9671sA9k280GrnhhhtQq9UIgjDf6Muv1s6eCKqhSxNJ5sKwVSRSo6RVN8bJ+Ykz3tfpdNLQ0DBJ7eTNyD0JU9zH67jLNNPNOq7KGeGy1Yl8OqBgb+MQ333hCKkxGr5WlsnXyjNIn9jb91e6OhtKpRKLxYLD4WDHjh3YbDa5Es5ut8tfYG9CnJmY7y6Dt0q4Y8eOYbFYiI+Pp7Cw0GPOobJziA0Z0URqfL8Y+lqH4E+tgy+7DDMZuTudnZ1cc801/PCHP+SKK67w+fXNgF+tnT0RVEPXaDRzbglksookRKrpNo7PuD53Op1UVlYSHx/PqlWrZuwGI22LzFZ2OlWmaTKZyEzQsiNxlFqdkg974ffvt/HHD9o4ozCZS0tSiTC1kzURIQQKTxFCWFiY155wU4U4MyHlEALV3ELymlFRUQwNDbF69WrZq7tXwsXHx+MQobbbxGUVvvfYn08LbU+1DtIug/SemkwmysrK5j0HvbKykn/913/ld7/7HTt27JjXsdz4HFgrCEI+0I1r5trV/hxoydX4mSwiEWrXh+mtxl2qV964caO8HePNyHt7e+ns7Jxz2elU71BusXC+Tkddez+vHxvmw1YdbzdqyYxVc9VWBxcnuOrz54svEcJMPeFEUfRaCTfXHIKvSGWn69evlyME92TjwMAAjY2N9IyrGbc7KUrzLecRyF0G9+WHlFkfGBggMjKSqqoqr11/fGHfvn3cf//9vPjiixQWBq55hSiKdkEQbgNex7W99qQoinX+HEuYpYhjXhUeNptN9uhtbW2o1WqysmYeE7XzV+8QERlBY/8ob93+pWmjlKThfyqViq1bt87Y8qmtrQ2j0cjmzZsDWnaq1+upPlLHsbFI9h0bodHgRKWAswuTuOakHCpy4/36UlqtVqqrq8nIyPA7QpCSU1qtdtIc9KGhIaxWK5s2bQqYdBW+iBDcy049IYoij3/Qwm/e7eC3Z0cTo3LOWAkXzF0GKUJYv369PI5K6gOg1+t9rnUQRZHHHnuMV155hZdeemk+vQqC3lx+6Xl0q0hYuEi4WjFpBBN8IWUtKiqipqaG7u5uj3XS0tpdoVBQUlIS8LLTjo4OTt62lTPDw7n1XKjv1vO/n7TzRpOe14/qyIlVcUlxCleclE98lG+Js0A1t5ianJLWoHa7nYiICDo6OvxuvzSVuUQIgiBQ128mKz6cc07ZOmMlnNVqnRYhBAJvEcJc59+BK/L6t3/7N/r7+3n99deXfFnskvLooiiy6b63yYgLJy5Czcvf/GInobOzk56eHoqLi1GpVLIqSqvVTqqTjoyMpK6uzqMwZT74EiGYbQ721Pbx3IFOGgbMaBSwPklFaXYsX1qbxtaCFI9jgX3NIcyVqRGClGzUarWz9oSbCfccgq8RQlP/CFc+cYjzilK5/4IN044n1Tr09vYyNjZGZmYmGRkZfiUbPeFvhOA+/85gMMg96w4ePEhJSQn3339/IBxJ0D36kjJ0k9nG1ofeIyZMyZnrUvjlpUWylHVsbIxNmzbJa/Gp45CkpgwDAwPExMSQnZ0dsJJEqahEEATWrVvn0wdb1zPMK9W9fNaqp0VrRgSUAqxOUFOWE8fJa1OpyE3APuJqf1RcXBxQrzBbhODeE06v1/tcCeeeQ1izZo1PRjg8bueyxw9itjp48dYtpER7/kykCGHjxo3ytqfJZJpTstHj8wewhXZVVRV33XUXer2e8PBw7rvvPr7yla/M65istNBdN2oFYNjiYE1KFA6Hg9raWlkP7XQ6PSbdVCoV4eHhjIyMyNsvOp1uxjppX5lJujoTmzJj2JTp8s5DZhtVXSYOtxs40Kbnb0e0vFCtBSA1QmBrfiIdKj1lOXGsTp6577sv+BIheOoJJ9XjS3PQp1bC+dMg0ymK/OTVBnqM4zx1falHI/e0yxAZGSlXwrl3/QHkC5IvlXCB3GU4evQo3/rWt3jooYc499xzGR0dnfOMgcViSXn0Qx1Grn7iIAC/vWwT8aMdcmnhTJn1wcFBjh8/TnFx8bTkiVQn7Y93GB8fp7q6mry8PNLS0ub68r1isdnZ9+kR6gcsHDdBXb9ZLhSKC1dSlhNPeW4c5TlxFGXGzqkUV8ohzCdCkJJTOp0OvV6PWq0mJiaGwcFBr6pDb/zxgzb+65+t/GT3Wq47afrFYa4RgrT80Ol0s1bCSe2vSkpK5r3L8P777/PjH/+YZ555hpKS2Wf+zZGVFbq/2TDAbc+7enY/tCOcU0oKSUxMnNHIOzs76e/vp6SkZNaSx0mVcDod4N07mEwm6urqglZ26h4hiKJIy+AIHzb28nmrnvqBcfrGXG+9WimwOTOWshyX4ZflxHmcChvMXQb3PnV2u92nnnAAHx3Xc+ufq/lyURq/uHjDtM9vvi203SvhdDrdpEq43t5exsfH573LIIoizz//PI899hgvvvhiQOsl3FhZhv7851387B9HUQnwwe1biIme3CVk0omJolyJtWnTJr8SIt68g9PppL293WOEMB98jRBEUaRr0MiHR3s41GGkUW+n3eTEPlF7tDo5kvKcOMpzXYafHRdGY2PjnHIIvjI1QnCvhDMYDF57wnUbx7nssYOkxGh47qaKaZVwwWihbbFYGBwcpKWlBafTSWpqqt/z78AV2Tz88MMcPnyY559/PqCJ0imsrDV6e78egPykCGKio2acmHLkyBGioqIoKirye03rqRLu+PHjGI1GoqOj6e/vD9hW1FwiBEEQyElN4KrUBK7CFQX09A9yoLmfqu5hWodt7K/r58XKXgDiwgQ2pUWwY10Gtt4RNqRHo57HwAuYHCG4l5360hMuJj6R219txe508l+XFU0z8mC10JY62KxevZrMzEyvXX9mm38HLifw3e9+l8jISF599dWARkiLwZI4e1EUaW1tpUtrRABWJ0fMKEyprq4mMzNz1uKbudLf349areaMM86QC08CMR1VyiF4k67OhkqlIjcrg9ysDC6dqIQbGBykurWfI31muq0ajhvtfPzmcQDCVQqKs2LldX5Jdtyc5oq57zLMVocwtSecwWDgvn3N1Pea+cG2aFRmPePjCjlfEKgGmVPxFCF46voz2/w7cF2IrrvuOs4991x+8IMfLIsOMrOx6IbudDqpr3fJa51hsYhoiRVH+eyzz6YNLJA+zLVr18oeJRB4ihB87Qk3m3eQcgiBKjuVesIBZPT3c9ruYnmYQsegiW5LGO1jSo5qbTz2YQcOUUQACtOiJ4X7mV7kv/7uMoBLiPNuh5W3W83cekouV25PR6vVyj3hFAqFXLMeyBJcXyIEX+bfSbs61157LT/+8Y+57LLLAtobfzFZVEO32+1UVVWRmJhIbm4uvR+6Mu6nlqxl69pE9Hq9XCetUqnkAo1AGrkvEYI3meZM3sE9hzAf6aonPEUI6enpbJqSnLI4ItGK0bSNKKkbMPNqTR/PHex23T82jIoJoy/PiWdtahQ2q2Veuwwft+j5j31NfGl1At85czVKhUBUVBQ5OTnU19djsVgIDw/n0KFDPveEmw1/IgRPlXCDg4Pceuut1NfXs3PnTlJTU08YI4dFNPTx8XEqKytZtWqVLM7Qjrj20dekRE0aWNDT00N7eztZWVm0tbXR3Nw8r46hEv5GCFNlmlO9Q1JSEjqdjtjY2HnlEDwxU4TgrSfcGq2W7TFmokoSGRKiaR0WqOoe4fN2I3uODAAQpVGSHyNy8to0GNMQY3X4JCUVRZGPWwz8z4ftfN5uJDs+nF9eshHlRB8B9whBKnjy1BNuri2ppRyCwWCYdwvtiIgIampqGBsb4/3336e7u5umpibOOOMMv4+51FiUrLvJZKK2tpYNGzZMGqZQ8eB7WOxOqn56OqqJMK+1tZWhoaFJW0ZSJZxWq2VoaMgv72AwGGhsbGTTpk0BTQiZTCZqamrkyaxz6Qk3E1KE4O+WkdPpnOTtVSoViYmJ2DSxfN6m56PGXjrHNXIVn0ohsCFdCvfjKcuJIzn6iwvLmNXBmw2D/O+BLup6h0mLCePGk3P4WnmmfIHwdZdhrrUO7u2vJGGKv4iiyB//+Ef+/ve/8+KLLwY0WpwDJ972mkajkUf5us8id4oiRf/xLklRaj74wQ5ZmKJUKlm3bp3Xq7y7TFOn0/nkHSTparDKTqUIwb0nnMFgICIiwq/pqO45hIKCgoBECFIlXGdnJ2NjY6SmppKWloYyIoba3lEOdxip7Byitsc1Iw0gNzGCsuxYLHYnHzTrGbU6WJUYwc1fyuWC4vRJhT3+NreYrdZBGvwRCC2D3W7n7rvvRq/X8+STTy6mMOXEMnSTyYTZbJaFKe6ZdcOYlVN+9REbM6J57uul1NTUkJycTG5u7pw+zJm8g1qt9hghBAJfyk6lnnBarRar1SpvU800HTUQ0lVPuOcQ1q9fz/DwsFxTICWnkpKSUIdH0NA7zKGOISo7hzjcOcS6tGjSY8O4pDSDitzpZcXuZafzrUNwr3UYGhrCZrORkZHB6tWr/Z5/B67P4pZbbqGoqIj/+I//WOzM+olh6KIo8vnnn+NwOKioqPAoTDnSY+Lyxw9xzrpErskbJz8/n9RU3zuFejx5N++g1Woxm82Eh4ezbt26gKmiwL8IQeoJp9VqMRqNHqejBnOXoa6ujsjISI8Rgtlsli9IU3vCSZlzb4Yh5RCKi4sD3tyitraW3NxcuUWUP/PvwJXAu/baa7npppu4+eabA/I9uOmmm/jHP/5BamoqR44cAeDee+/lsccek/vQPfDAA3z5y18G4MEHH+SJJ55AqVTS1NR0riiKr8/7JGYg6IZus9mora3FarXKOmmpgaM7Lxzq5t49TVy4WsldXy0hLs6/LqHezkPSIUdEREyTafo7HdVbDsGf40jJKZ1Oh91uJyoqCqPRSHFxccAnpsylDsHXSrj55hBmwluEIBm8Vqv1udahvr6eW265hYcffpjdu3cH7Bzff/99oqOjuf766ycZenR0ND/84Q+nncNVV13FgQMH6OnpYfXq1S1AoSiKjoCd0BSCmnW3WCwcPnyYjIwMeW0+PDzssU76pHQl3ytTs/ukTQE1crPZTE1NzaSEkPu0DZ1O59d01EA2t5g6sKCrq4v29nZiY2Opq6ubt0xTwp8IwVMlnFarpaGhAavVSmJiIgkJCfT09BAVFRXQBpkwc3OLudY6vPfee9x11108++yzFBcXB+wcAU477TTa2tp8uu+rr77KlVdeSVhYGPn5+QDNuHq4fxLQk3IjqIZeV1fH6tWr5T5diYmJ8laU++xsq9WK0WjkxnNPmte6aypS2enGjRunXTzcZZpznY4qRQhJSUlzziHMhHuEcNJJJ6FSqebUE24mArXLEBkZSW5urtySemBggPr6evk8vHX9mStzbaE9U63D008/TUtLCx0dHezZs4eCgoJ5ndtcePTRR3nmmWfYsmUL//mf/0lCQgLd3d1s377d/W5duHq4B42ghu7j4+PY7a6JK5483ujoKA0NDYyNjaHRaKZVws2HmaSrs+HuHfR6/STvIAgCtbW1AZeuukcIMwlTPPWEm2066kLsMiQmJsrefmrXn7nWOvjT3MIbTqeT+++/n88//5yNGzfy0UcfsWfPnoD2oZNoa2vj/PPPl0N3SSshCAL/3//3/9Hb28uTTz7Jt7/9bU4++WSuvfZaAARBeBLYK4riSwE/qQmC5tEHBga45JJLOOecc9i9ezebN2+e9GE7HA6am5tJSEigoqJCXgtKlXCRkZGy55rrl7Ozs5OBgQEqKir8ihC8eYeGhgaGhoZITk5GoVDMe7aWhBQh+LJl5G1gQUdHB4IgTJqOCngUpgQCT7sM0gCK+UxHDeQug8Vi4bbbbiM+Pp79+/cvuDDF3RF84xvf4PzzzwcgOztbnmY7gd/92n0lqB69r6+Pffv2sXfvXhoaGtiyZQu7du1i/fr1vP7661x22WVkZk7v8S2Kol/eQWo7JXU7DeSWiRQhFBUVYbVa59wx1Buecgj+MrUnnNPpJCIigqKiooBmwOcaIfha6xBI6arBYOC6667jK1/5CnfccceClLNO9ejSEEiA3/zmN3z22Wc8//zz1NXVcfXVV7sn41qBtcFMxgXV0N2x2Wx88sknPPPMM7z00kts2bKFM888Uzb8mYzSWyVccnKy/AUORlGJhBQhFBcXT4sQpI6hWq12ztNRg9XcwmazUVNTQ1SUq5RYWn7MdzpqoJpbeKp1iIiIYGBggM2bN8+7UrGtrY1rr72Wn/70p1x66aXzOpavXHXVVbz77rtotVrS0tK47777ePfdd6mqqkIQBPLy8vjjH/8oG/7999/Pk08+iUqloqmp6cuiKO4L5vktmKGD64tyzTXXcPfddxMfH8/evXvZt28fzc3NbN++nV27dnH66afPOJvbfStKq9XidDqJi4tDr9eTm5sbUOnqXCME90o4o9E443TU+eQQZsJbhCDJNLVardeecDPhaw5hrsgS5a4uwsLCJu1++DMd9eDBg9x22238z//8z9SE11JmeRfM+IrFYuHDDz9kz549vPvuuyQlJbFz50527949azLGaDRSW1tLVFQUFotFHlgw362oQEQI3irhRkZGGBgY8Kn91VzwNULw1BNupumoc8khzAVPEcJcesJN5bXXXuOXv/wlL7zwQsAy654KYe68807+/ve/o9FoKCgo4KmnniI+Pp62tjY2bNjAunXrANfI7j/84Q++PM3KMPRJTzjx4UvevrOzk1NOOYXdu3ezY8eOSZ5Rr9fT1NREUVER0dHRc+oJNxMWi4WampqANrdwOBzodDqOHz/O+Pi4nHNwr4SbD/OJEGaqhJP6ui3GLsNMPeHcax1EUeR3v/sd+/bt469//WtAqwg9FcK88cYbnHXWWahUKn784x8D8PDDD09bo8+BlWfoUzGbzbz33nvs2bOHDz74gIyMDHbt2sXQ0BBJSUlce+21Xg3FH+8wMjLCkSNHgtrcYvXq1XKyUafT4XA45tWSeqYcwlxxr4ST8g7Z2dnk5OTMexChhL8RwtRKOLvdTmtrK4cPH2ZsbIwnnngiIBfNqcxkwK+88govvvgif/7zn0OGHihEUaSxsZHvfe97NDQ0kJyczI4dO9i9ezcnn3zyjB+yJ+8geVQpOTU1QggUs5Wd2u12+Qs8l5bUC7HLsHbtWjknIlXCzafWIVAttJ1OJ9XV1dx11120trayfv167r77bs466yy/j+mNmQz4q1/9KldccQXXXnstbW1tbNq0icLCQmJjY/n5z3/Oqaee6stThAx9KgMDA/z2t7/lvvvuw2w2884777B3714+/vhj8vPz5bV9ZmbmjJ5iqndQq9VyN5hAJsfmWnbqvhWl1Wq9VsIFe5fBUwttSYij0+kwGAxzrnUI5C5DX18fV199Nbfeeis33ngj3d3dOBwOVq1aNa/jesKbod9///0cPHiQl19+GUEQsFgsjIyMkJSUxKFDh7jooouoq6vzRasQMnRfkdZ8e/bsYd++fQwPD3PGGWewa9cuTjrJe2mtNELXYDAQFxeHwWCYc8dQbwQiQvBUCRcfH093dzfZ2dkB32XwtYX2XGsdArnLUF9fz80338yvfvUrdu7cOa9j+YInQ3/66af5wx/+wNtvv+319Zxxxhn86le/YsuWLbM9RcjQ/WVoaIi33nqLvXv38tlnn7Fu3Tp27drFrl275H5g3ppbSJVwOp0Os9ns88ACd6SikpKSkoCtG0VRlIcpqNVqOVseiJbU840QZur6MzAwEDDp6j//+U/uvvtu/vznP1NUVDSvY/nKVEPfv38/d9xxB++9954sQQXXxUzarmxpaeHUU0+VcxGzEDL0QOB0OqmpqWHPnj3s378fq9XKKaecwqeffsqvfvUrSktLZ3zsXGZnB0q66ompEYJUoTcXmaYnAt1C23350dnZidPpJDs7m5SUlDkJcaYe89lnn5ULrqTCk2DjqRDmwQcfxGKxyEsxaRvtpZde4p577kGlUqFUKrnvvvv46le/6svThAw90IiiSE1NDZdccglr166ls7OTzZs3s2vXLs455xySkpJm/CLOVAkH+NT+yh9mixDce8LNZTrqQrTQzs3NlTP5JpNpzrUOTqeTn//85zQ0NPCXv/xl3sMSJTztkev1eq644gra2trIy8vjhRdekD9b92YRv/3tbwOpZw8ZejCorKzEZrOxbds2HA4Hhw4dYs+ePbz55psA7Ny5k127ds2qM5/aE04y/MLCwoBtRUkRgslkYvPmzT4vHXyphFuMXYa51jpYLBa+9a1vkZyczG9+85uARkie9sh/9KMfkZiYyF133cVDDz2EwWDg4YcfntYs4pxzzqGpqSlQDTZChr6QiKLI4OAg+/fvZ+/evRw5coTy8nJ2797NmWee6TVTLJWdSlNftVotNpuNxMTEWXvCzYSvDTJ9Oc7U5YdGo2F4eJjy8vKA7j3PNUKYKsSRah2ioqKwWq1cd911XHDBBXzve98LijBl6vp73bp1vPvuu2RkZNDb28sZZ5xBY2MjDz74IAA/+clPANi9ezf33nsvJ598ciBOY2XNXltsBEEgNTWV66+/nuuvvx673c6nn37K3r17+e1vf0tYWJi8fbdx40YUCgU6nY6mpqZJzS2kpgx6vX7SJNK5VMJJwpTk5OR5bxm5DyyQ9t51Oh0RERFUVlb6lWz0hC8NMqcydf6d1Afg8ssvp6urS46uFmqYQn9/v7z+z8jIYGDA1fd+arOI7Oxsuru7F+ScAkHI0GdApVKxY8cOduzYgSiK9Pb2snfvXh5++GGamprIy8tjYGCAF154YVoHG/cBFO5CnCNHjsxaCSdFCIFokOmOe4Rw8sknIwgCDofDY9efqT3hZkPKIcxnpprU9aepqQmLxcITTzzB4OAgL7/8Mps2bfLrmIHCU+S7nCa5hAzdRwRBIDMzk1tuuYVbbrmFRx99lKeeeopTTz2VSy+9lNjYWNnbFxYWTgrVp/aEkyrhenp6aGhomFQJZzabqa+v99j+aj64Rwju7a+kpN1MPeFmqoRz32WYb3MLURR59dVX+fWvf82rr74q9VNbUNLS0mQdeW9vr3yhndosoqury2MvhaVKUNbo+/fv5/bbb8fhcHDLLbdw1113+Xd2S5jKyko2btxIWFgYoijS0dEhC3Ha2to4+eST2b17N6eddtqMBSLuW1G9vb2Mj4+TlZVFenq631tRU/E3QpitEs49Qph6cZsrTqeTRx99lDfffJO//vWvvuw9B4Spa/Q777yTpKQkORmn1+v5xS9+Ma1ZxNlnn82xY8dWbjLO4XBQWFjIm2++SXZ2Nlu3buW5555j48aN/p/lMmN8fJz333+fPXv28P7775OamsquXbvYvXs3+fn5Ho23o6ODwcFBNmzYIG+T+doTbiaGhoYCEiFMrYSz2WzY7XaSk5NZu3btvL7wdrudO++8k7GxMR5//PGgCFM84WmP/KKLLuLyyy+no6OD3NzcSRcd92YRjzzyCOedd16gTmX5Gfonn3zCvffey+uvu/rRT81WrjSkElvJ2/f19bFjxw527drFKaecgkql4uDBg0RHR8sJPvfHuu+NA3OqhHOfuhqo7T5wRQjV1dUkJiZit9u9dv3xheHhYW688Ua2bdvGPffcE/CJKY2NjVxxxRXy/1taWvj3f/93jEaj1+EKi8DyM/QXX3yR/fv38/jjjwPw7LPP8tlnn/Hoo4/6eYonFqOjo7z77ruyt7dYLHzpS1/iJz/5CTk5OTMa79StqJkq4aQIIRDSVXc8tdD2Z/4duBJ4V199Nd/61re4/vrrg57ccjgcZGVl8dlnn/HUU095HK6wSCy/7bXlnp0MNlFRUXzlK1/h3HPP5ZxzzmHnzp1oNBq+/e1vYzAYZCHO9u3bp3lGb1tRbW1tkyrhurq6sNvtlJWVBUW66j6XHVyfb0xMDDExMeTn58s94bq6urxWwh05coRvfOMb/PrXv+bss88O2DnOxNtvv01BQUFQFG5LnYAbur/Zyc7OTq6//nr6+vpQKBTceuut3H777TPOr1rOKJVKnn/+eVmT/cMf/hCTycQ777zDyy+/zJ133smaNWtkIU56evqkC6b7AApwVZANDAxw+PBhRFEkNTUVnU7nc0+42ZAiBF9aaKvVatLS0khLS5tUCVddXc3evXvp7u7mwIEDvPTSS2zevHne5+Yrzz//PFdddZX8f0/DFU5UAh662+12CgsLefvtt8nKymLr1q385S9/mXUftLe3l97eXsrLyxkeHqaiooK//e1vvPDCC0spxFownE4nR44ckYU4Y2NjnHnmmezevZutW7dOC9Wl9ldSxt5TTzh/WlJLBTY2m21aDmGuiKLI73//e1588UWysrJoampi3759AZ0S6w2r1UpmZiZ1dXWkpaV5Ha6wSCy/0F2lUvHoo4+ye/duHA4HN910k0/FDlJIChATE8OGDRuWVeVRoFEoFBQXF1NcXMxPfvITDAYDb7zxBs888wy33347GzduZNeuXezcuZOuri60Wi0VFRVyhliqhIMvesI1NTUxPj4uC3Hi4+Nn9PbuwpTCwsJ5T0z593//d5qamnj77beJiorC4XAs2Ljiffv2UV5eLkdQ3oYrnKgsyVr3trY2TjvtNI4cOcKvf/1r/vSnPxEbG7siQixfcDqdVFZWsmfPHl544QW0Wi1XXHEFl1566axzynydjuoeIcy3MGR8fJxvfvObZGZm8p//+Z8BnbTqK1deeSW7d+/mxhtvBLwPV1gkll/Wfb6MjIxw+umn89Of/pRLLrlkqYVYS4rW1lauu+46/vjHP1JZWcm+ffuoqqqitLSUXbt2cfbZZ5OQkDCjJ3bfG5cq4aKioujo6KCwsHDe0lWdTse1117LpZdeyne+851FScyOjY2Rk5NDS0uLvFNw3XXXeR2usAisLEO32Wycf/757N69mzvuuGPa32frspmXl0dMTAxKpVLen55JX3wiYLfbJ63XHQ4HBw4cYM+ePbz11luo1Wp5/l1RUdGsstuOjg7a29tRq9WTSnP9qV8/fvw4N9xwA/fccw8XXXSRPy9vpbByDF0URW644QYSExN55JFH5NvnEmLl5eVx8ODBSXO7vOmLVwJS6ylP8+/OOuusaU0Le3p66OrqoqSkBI1GM6/pqJ9++im33347Tz75JFu3bg3K6zuBLuwrx9A//PBDTj311ElTVx944AGee+45n0MsT4buTV+8ErHZbHz88cfs3buXd955h6ioKLmzzuuvv86pp55KRUWFxzW0L/PvwHVxeeWVV3jkkUd48cUXycvLC9rrOYEu7CvH0ANBfn6+vCb9l3/5F2699Vbi4+MxGo3yfRISEjAYDIt3kksEURTp6uritdde4xe/+AVxcXFs27aNc889l9NPP33Gdk1SJZxUped0OtFoNOh0Oqqrq3nvvfcWxJOeQBf25be9tph89NFHZGZmMjAwwM6dO1m/fv1in9KSRRAEcnJyiI2N5Y477uCb3/ymPP/ugQcemHH+nXslXF5eHjabjaqqKu6//36OHTvGueeey9GjRwPVfWXG1yA1pZAu7N4aR6x0TihDl7aBUlNTufjiizlw4IBXfbEnlokAIqBcd9118u9nn302Z599tqwx37t3L3fffTddXV1e59+Ba/vsoYce4stf/jJ33303NTU1AZ3H7o3Qhd13TpjQfXR0FKfTSUxMDKOjo+zcuZN77rmHt99+26O+eDaWsABiwTGbzbIQ58MPPyQzM1MuzdVoNFx99dV85zvf4dprr100XcO9995LdHQ0jz32WCh098AJ49H7+/u5+OKLAVfi6Oqrr+bcc89l69atXH755TzxxBOyvtgXVrIAYioRERGcd955nHfeeXJJ7N69e7n99ts5dOgQL730EmeeeeaCntPUC/sbb7zBPffcwwUXXMDTTz/NXXfdxdNPP82FF164oOe1VDlhPHqguemmmygvL+e2227j3nvvDVXneWFsbCygs+p8paWlZdqF/ac//Sk6nc5r44glTPDDIFEUZ/pZkVgsFjEpKUns6+sTRVEU+/r6RLvdLjocDvHuu+8Wb7zxxkn3v/HGG8WUlBRx06ZN8m06nU4855xzxDVr1ojnnHOOqNfr5b898MADYkFBgVhYWCju379/YV7UMqGjo0M844wzxPXr14sbN24UH3nkEVEURfFnP/uZmJmZKZaUlIglJSXinj17FvlMA8psdjjvn5Che+Bvf/ubuHPnTo9/a21tnWTQoiiK7733nnjo0KFJt995553igw8+KIqiKD744IPij370I1EURbGurk4sLi4Wx8fHxZaWFnH16tWi3W4P0itZfvT09IiHDh0SRVEUTSaTuHbtWrGurk782c9+Jv7yl79c5LMLGkE39IWRDi0znnvuuUm65d7eXvn3V155Zdpwv9NOO21aePjqq69yww03AHDDDTfwt7/9Tb79yiuvJCwsjPz8fNasWcOBAweC9EqWHxkZGZSXlwMhFWMgCRn6FMbGxnjzzTe55JJL5Nt+9KMfsXnzZoqLi/nnP//Jb37zm1mPM9MggJycHPl+y20QwELS1tZGZWUlJ510EuBqFFFcXMxNN90UKnqaIyFDn0JkZCQ6nW5Sx9Rnn32W2tpaampqeO211+alchJDrbZ8YmRkhEsvvZRHHnmE2NhY/vVf/5Xjx49TVVVFRkYGP/jBDxb7FJcVIUMPElKhDuDTIICbbrqJ1NTUScuCO++8k/Xr11NcXMzFF18sl/K2tbURERFBaWkppaWlfPOb31y4F7YA2Gw2Lr30Uq655ho5skpLS0OpVKJQKPjGN74RWu7MkZChBwlpPxeYtJ97wQUX8Pzzz2OxWGhtbeXYsWNs27aNr3/96+zfv3/SMXbu3MmRI0eoqamhsLBQbp0NUFBQQFVVFVVVVfzhD39YuBcWZERR5Oabb2bDhg2TpMqz5UlCzMIs2boQPnDllVeK6enpokqlErOyssTHH39c1Gq14llnnSWuWbNGPOuss0SdTiff/+c//7m4evVqsbCwUNy7d698u6eMvsTLL78sXn311bPeb7nzwQcfiIC4efPmSVtp1157rVhUVCRu3rxZ/OpXvyr29PQs9qkGktD22kpiJgM+//zzxWeffVa+X2RkpFhaWiqedtpp4vvvv7+Qpxkw9u3bJxYWFooFBQXyVuQKJeiGfsKUwJ7I3H///ahUKq655hrAlcXv6OggKSmJQ4cOcdFFF1FXVzetkcRSxuFw8O1vf3vS6K4LLrhgRY3uWkhCa/QlztNPP80//vEP/vznP8vZ+bCwMLmXW0VFBQUFBTQ1NXlM6N17771kZWXJibu9e/fKf3vwwQdZs2YN69atk0doLRQHDhxgzZo1rF69Go1Gw5VXXsmrr766oOewkggZ+hJm//79PPzww7z22muT6skHBwdxOByAq+b72LFjrF692mNCD+D73/++nLiT5LX19fU8//zz1NXVsX//fr71rW/Jx1wIQvUEC0vI0JcIV111FSeffDKNjY1kZ2fzxBNPcNtttzE8PMzOnTsnbaO9//77FBcXU1JSwte+9jX+8Ic/kJiY6LFCzxuLXaEnhuoJFpTQGn2J8Nxzz0277eabb/Z430svvZRLL73U52N7Gj3U3d3N9u3b5fsstEf1d3RXCP8IefQTHG8VZYvtUbdu3cqxY8dobW3FarXy/PPPc8EFFyzY8680Qh79BMfb6KHF9qj+ju4K4R8hj36C462izFuF3kLy5S9/maamJo4fP85Pf/rTBX3ulcZsHWZCLCMEQXgOOANIBvqBn038vxRXt6A24F9EUeyduP9PgZsAO/A9URT3LfQ5h1gYQoYeIsQKIBS6hwixAggZeogQK4CQoYcIsQIIGXqIECuAkKGHCLECCBl6iBArgJChhwixAggZeogQK4D/H0ODg96CZOYdAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, subplot_kw={'projection': '3d'})\n",
    "\n",
    "# Get the test data\n",
    "#X, Y, Z = axes3d.get_test_data(0.05)\n",
    "\n",
    "aux = grouped_aggG.loc[u_sols[0],'T_total']\n",
    "Z = [None] * len(processes)\n",
    "X, Y = np.meshgrid(processes, processes)\n",
    "removed_index = 0\n",
    "for i in range(len(processes)):\n",
    "    Z[i] = [0] * len(processes)\n",
    "    for j in range(len(processes)):\n",
    "        if i!=j:\n",
    "            real_i = i - removed_index\n",
    "            real_j = j - removed_index\n",
    "            Z[i][j] = aux.values[real_i*len(processes)+real_j]\n",
    "        else:\n",
    "            Z[i][j] = 0\n",
    "            removed_index += 1  \n",
    "Z = np.array(Z)\n",
    "\n",
    "ax.plot_wireframe(X, Y, Z, rstride=20, cstride=10)\n",
    "ax.set_proj_type('ortho')  # FOV = 0 deg\n",
    "ax.set_title(\"'ortho'\\nfocal_length = ∞\", fontsize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "El siguiente código es para utilizar Dask. Una versión que paraleliza una serie de tareas de Pandas.\n",
    "Tras llamar a compute se realizan todas las tareas que se han pedido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dask.dataframe as dd\n",
    "ddf = dd.from_pandas(dfL[(dfL.Asynch_Iters == False)], npartitions=10)\n",
    "group = ddf.groupby('NP')['T_iter']\n",
    "grouped_aggLSynch = group.agg(['mean'])\n",
    "grouped_aggLSynch = grouped_aggLSynch.rename(columns={'mean':'T_iter'}) \n",
    "grouped_aggLSynch = grouped_aggLSynch.compute()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "(3, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "a = (4, 3, 5, 6)\n",
    "b = (4, 3, 5, 6)\n",
    "d = (4, 3, 5, 7)\n",
    "c = (3, 4, 5, 6)\n",
    "\n",
    "print(a[1:]==b[1:])\n",
    "print(a[1:]==c[1:])\n",
    "print(a[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3]\n"
     ]
    }
   ],
   "source": [
    "a = [2, 3]\n",
    "a.pop(0)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}