new_analyser.ipynb

{
 "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",
    "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",
    "matrixIt=\"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": 264,
   "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",
    "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",
    "grouped_aggG.to_excel(\"resultG.xlsx\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_aggG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "used_direction='s'\n",
    "test_parameter='T_total'\n",
    "    \n",
    "if used_direction=='s':\n",
    "    df_aux=grouped_aggG.query('NP > NS')\n",
    "    used_labels=labelsShrink\n",
    "    name_fig=\"Shrink\"\n",
    "    np_aux = [10, 20,20, 40,40,40, 80,80,80,80, 120,120,120,120,120]\n",
    "    nc_aux = [1,  1,10,  1,10,20,  1,10,20,40,  1,10,20,40,80]\n",
    "elif used_direction=='e':\n",
    "    df_aux=grouped_aggM.query('NP < NS')\n",
    "    used_labels=labelsExpand\n",
    "    name_fig=\"Expand\"\n",
    "    np_aux = [1,1,1,1,1,        10,10,10,10,  20,20,20,  40,40,  80 ]\n",
    "    nc_aux = [10,20,40,80,120,  20,40,80,120, 40,80,120, 80,120, 120]\n",
    "elif used_direction=='a':\n",
    "    df_aux=grouped_aggM\n",
    "    used_labels=labels\n",
    "    name_fig=\"All\"\n",
    "    np_aux = [1,1,1,1,1,        10,10,10,10,10, 20,20,20,20,20, 40,40,40,40,40, 80,80,80,80,80, 120,120,120,120,120]\n",
    "    nc_aux = [10,20,40,80,120,  1,20,40,80,120, 1,10,40,80,120, 1,10,20,80,120, 1,10,20,40,120, 1,10,20,40,80]\n",
    "    \n",
    "x = np.arange(len(used_labels))\n",
    "handles = []\n",
    "\n",
    "f=plt.figure(figsize=(20, 12))\n",
    "#ax=f.add_subplot(111)\n",
    "ax = plt.axes(projection='3d')\n",
    "ax.azim = -60\n",
    "ax.dist = 10\n",
    "ax.elev = 10\n",
    "ax.set_xlabel(\"NP\", fontsize=20)\n",
    "ax.set_ylabel(\"NC\", fontsize=20)\n",
    "ax.set_zlabel(\"Alpha\", fontsize=20)\n",
    "ax.tick_params(axis='both', which='major', labelsize=24)\n",
    "ax.tick_params(axis='both', which='minor', labelsize=22)\n",
    "\n",
    "for cst_aux in [1,3]:\n",
    "    df_aux2 = df_aux.query('Cst == @cst_aux')\n",
    "    for css_aux in [0,1]:\n",
    "        array_aux = df_aux2.query('Css == @css_aux')['alpha'].values\n",
    "        ax.plot3D(np_aux, nc_aux, array_aux, colors_spawn[cst_aux*2 + css_aux])\n",
    "      \n",
    "        handles.append(handles_spawn[cst_aux*2 + css_aux])\n",
    "        \n",
    "#ax.set_zlim(0,4)\n",
    "plt.legend(handles=handles, loc='best', fontsize=20,ncol=2,framealpha=1)\n",
    "        \n",
    "f.tight_layout()\n",
    "f.savefig(\"Images/Spawn/3dPlot_\"+name_fig+'_'+test_parameter+\".png\", format=\"png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "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):\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",
    "                config.append((np_aux, ns_aux))\n",
    "                if tuple(config) in grouped_aggG.index:     \n",
    "                    remove = 1\n",
    "                elif remove != 1:\n",
    "                    remove = -1\n",
    "                config.pop()\n",
    "    if remove == 1:\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, (0, 0), (0, 0), (1, 1)], [0, (0, 0), (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)]]\n",
      "6\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",
    "for configuration in configurations_aux:\n",
    "    aux_conf = modifyToUsable(parameters, len_parameters, configuration)\n",
    "    if CheckConfExists(aux_conf):\n",
    "        configurations.append(aux_conf)\n",
    "\n",
    "print(configurations)\n",
    "print(len(configurations))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "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(data_stats, np_aux, ns_aux, tc_boundary):\n",
    "    index_aux = 0\n",
    "    for cst_aux in [0,2]: # Primero los grupos síncronos\n",
    "        for css_aux in [0,1]:\n",
    "            if cst_aux == 2 and css_aux == 1 and np_aux > ns_aux: # Arreglo para coger bien el tiempo en Merge Single Shrink\n",
    "                index_aux = 1\n",
    "            tc_val = grouped_aggM.loc[('2,2',0, cst_aux, css_aux - index_aux, np_aux,ns_aux), 'TC_A']\n",
    "            if tc_val > tc_boundary:\n",
    "                data_stats[cst_aux*2 + css_aux]+=data_stats[cst_aux*2 + css_aux]\n",
    "    index_aux = 0\n",
    "    for cst_aux in [1,3]: # Segundo se comprueban los asíncronos\n",
    "        for css_aux in [0,1]:\n",
    "            if cst_aux == 3 and css_aux == 1 and np_aux > ns_aux: # Arreglo para coger bien el tiempo en Merge Single Shrink\n",
    "                index_aux = 1\n",
    "            tc_val = grouped_aggM.loc[('2,2',0, cst_aux, css_aux - index_aux, np_aux,ns_aux), 'TH']\n",
    "            if tc_val > tc_boundary:\n",
    "                data_stats[cst_aux*2 + css_aux]+=data_stats[cst_aux*2 + css_aux]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_perc_differences(dataLists, np_aux, ns_aux, rms_boundary, tc_boundary):\n",
    "    #if rms_boundary != 0: # Si se usa perspectiva de RMS, se desconsideran valores muy altos\n",
    "        #check_groups_boundaries(data_stats, np_aux, ns_aux, 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": 300,
   "metadata": {},
   "outputs": [],
   "source": [
    "def results_with_perc(tipo, data_aux, configurations, rms_boundary=0):\n",
    "    results = []\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=[]\n",
    "                for config in configurations:\n",
    "                    config.append((np_aux,ns_aux))\n",
    "                    if tuple(config) in data_aux.index:\n",
    "                        aux_value = data_aux.loc[tuple(config),tipo].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",
    "                \n",
    "                tc_boundary = 0\n",
    "                #tc_boundary = dfM.query('NP == @np_aux and NS == @ns_aux')['TC'].max()\n",
    "                if rms_boundary != 0:\n",
    "                    boundaries = []\n",
    "                    for cst_aux in [0,1,2,3]:\n",
    "                        for css_aux in [0,1]:\n",
    "                            dataSet_aux = dataSet.query('Cst == @cst_aux and Css == @css_aux')\n",
    "                            lista_aux = list(dataSet_aux[tipo])\n",
    "                            dataLists.append(lista_aux)\n",
    "                            \n",
    "                            if cst_aux == 0 or cst_aux == 2:\n",
    "                                if cst_aux == 2 and css_aux == 1  and (np_aux > ns_aux):\n",
    "                                    new_boundary = tc_boundary\n",
    "                                else:\n",
    "                                    new_boundary = grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux), 'TC_A']\n",
    "                            else:\n",
    "                                if cst_aux == 3 and css_aux == 1 and (np_aux > ns_aux):\n",
    "                                    new_boundary = tc_boundary\n",
    "                                else:\n",
    "                                    new_boundary = grouped_aggM.loc[('2,2',0, cst_aux, css_aux, np_aux,ns_aux), 'TH']\n",
    "                            boundaries.append(new_boundary)\n",
    "                    tc_boundary = min(boundaries)\n",
    "                    tc_boundary = tc_boundary + tc_boundary*rms_boundary\n",
    "\n",
    "                aux_data = get_perc_differences(dataLists, np_aux, ns_aux, rms_boundary, tc_boundary)\n",
    "                results.append(aux_data)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5, 1, 0, 4, 3, 2], [1, 4, 0, 5, 2, 3], [4, 5, 2, 3, 1, 0], [2, 1, 5, 4, 0, 3], [4, 0, 1, 3, 5, 2], [1, 3, 0, 5, 4, 2], [4, 2, 5, 3, 1], [1, 0, 2, 4, 5], [5, 0, 4, 3, 2, 1], [4, 2, 1, 5, 0, 3], [2, 1, 0, 4, 3, 5], [4, 1, 0, 5], [4, 2, 1, 0, 3, 5], [1, 0, 4, 2, 5], [0, 2, 4, 1], [1, 0, 2], [1, 4, 0, 2], [1, 0, 2], [1], [3, 0, 4, 2], [2, 0, 1, 4, 5, 3], [1, 0, 4], [2, 0, 1], [4, 0, 1, 2, 3, 5], [4, 2, 3], [2, 1, 0, 3], [4, 1, 5, 3, 2], [1, 4, 2], [1, 2, 4], [1, 0, 2, 4], [2, 4, 5, 3, 1, 0], [1, 2, 0, 5, 4], [1, 5, 4, 2, 0, 3], [4, 1], [1, 2, 4, 5], [1, 2], [4, 1, 0, 2, 3, 5], [2, 1, 4, 5, 0], [5, 4, 1], [4, 1, 2, 0], [2, 1, 4], [4, 1, 5, 3, 2, 0]]\n"
     ]
    }
   ],
   "source": [
    "checked_type='te'\n",
    "use_perc = True\n",
    "rms_boundary=0 # Poner a 0 para perspectiva de app. Valor >0 y <1 para perspectiva de RMS\n",
    "if checked_type=='te':\n",
    "    tipo=\"T_total\"\n",
    "    data_aux=grouped_aggG\n",
    "elif checked_type=='tc':\n",
    "    tipo=\"TC\"\n",
    "    data_aux=dfM\n",
    "    \n",
    "if use_perc:\n",
    "    results = results_with_perc(tipo, data_aux, configurations, 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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  5  1  4  2  4  1]\n",
      " [ 4 -1  1  5  4  2  4]\n",
      " [ 4  1 -1  0  1  1  1]\n",
      " [ 1  3  2 -1  1  2  4]\n",
      " [ 4  2  4  1 -1  1  1]\n",
      " [ 2  1  1  4  1 -1  1]\n",
      " [ 4  2  5  4  2  4  6]]\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(configurations)\n",
    "print(heatmap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "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": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4327/287705176.py:38: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_xticklabels(['']+processes, fontsize=36)\n",
      "/tmp/ipykernel_4327/287705176.py:39: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels(['']+processes, fontsize=36)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABCAAAANYCAYAAAAVOpxHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACM4ElEQVR4nOzdeZhU1Z3/8fdpuhuaPayCyCLuuCCSRLOAmiiauCSaZYxmNHHFmMkvizOJkzFqNjVGnSQzjqCJxjWbSQxm3MaAexQiAppIREEb4sK+I9Dn90cVTVH0UtX07VtV/X49Tz3cc+rc219s763m0+eeG2KMSJIkSZIkJakq7QIkSZIkSVLlM4CQJEmSJEmJM4CQJEmSJEmJM4CQJEmSJEmJM4CQJEmSJEmJM4CQJEmSJEmJM4CQJEmSJEmJq067AEmSJEmSVJgQQj/gn4CTgH2BwcA7wBvAAmA6cH+McW5aNTYnxBjTrkGSJEmSJLUihHAe8H2gXytDZ8QYj0y+ouI4A0KSJEmSpBIXQrgG+GpO19+AGcBiMv+2HwKMBt7f8dUVxgBCkiRJkqQSFkL4GtvDh38A58QY/9jM2B7Afh1VWzG8BUOSJEmSpBIVQtgPeA7oBqwADosxvppuVW3jUzAkSZIkSSpd3yATPgD8a7mGD+AMCEmSJEmSSlL2iReLyQQQy4GhMcZN6VbVds6AkCRJkiSpNB3J9tkPj8QYN4UQxoYQpoQQFoQQNoYQlocQngsh/CCEMDK9UlvnDAhJkiRJkkpQCOFq4OJs89+zf15O8w+UeAe4JMb4w6RrawufgiFJkiRJUmnaO2f7RODw7PZrwL1knoixW/a9kUAtcE0IoTbG+P0OrLMgzoDoBAYMGBBHjhyZdhkqwOo3nku7BBWh9+KGtEtQgWYxLO0SVIS9d1+Sdgkq0N8XD027BBXoMOrTLkEFWggsjTGkXUelOe644+LSpUvTLmMHs2bNegHYmNM1JcY4JXdMCGE6MDFv1ynAv+SuBRFCqAWuAy7Mdm0l87SM59u77l3hDIhOYOTIkcycOTPtMlSAB77fM+0SVIRJl6xLuwQVKPCltEtQEX78hcvSLkEFOu4Sz61yMbNxBrdK3fi0C6hQS5cuLbl/E4UQNsYYW/uW5/8D4Qnggpg3kyDG+E4I4SJgDJnAoguZWzfOaK9624OLUEqSJEmSVJo25LWvyg8ftsn259528ZEQQknNpjGAkCRJkiSpNK3J2Y7A9FbGPwpsyW6/CxiVQE1tZgAhSZIkSVJpeiNne1WMcU2zI4EY4wZgeU7XgESqaiMDCEmSJEmSStO8NuwTm9lOnQGEJEmSJEmlaVbOdp8QQour1ocQugH9c7reTqSqNjKAkCRJkiSpND3O9hAhAEe2Mn4C2592+VaMcWEyZbWNAYQkSZIkSSUoxrgVuC2n69+ae7JFtv8bOV2/TbK2tjCAkCRJkiSpdH0PWJHd/gBwQwiha+6AEEIN8GO2z5DYAFzVUQUWqrr1IZIkSZIkKQ0xxmUhhH8mM6OhGjgfOD6E8HvgH8BuwEnAyG27AOfHGF9NodwWGUBIkiRJklTCYozTQgifAKYCA4HhwBebGLoaODfG+MuOrK9QBhCSJEmSJJW4GOPvQwiPA58DPgbsBfQDVgHzgf8FbogxLkutyFYYQEiSJEmSVAay4cI12VfZcRFKSZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUuOq0C5BU/rr1Gc7EC18ser+1y+bzxJRxCVSk1qwG/gLMAmZm/3wZiNn3JwLTU6lMxbr99o9w+ukH7NA3cuQUFi1anVJFnVdVl670HXYE/UZMoPduh9Cj/77Udh9AVVUNmzetZuPq11i5+Fne+Os9rKx/Mu1y1QrPrdLhZ5ZUOQwgJKmT2Rf4O9t/cFP5OuGEPXf6B5I6Xm33Qex3zFUMHH0c1V17NTmma/VAuvYYSJ8hhzFi/AWsXPxn5t13IeuWvdTB1aoQnlulw88sqbIYQEhqd8tfe5yGLRtaHbdxdX0HVKN889MuQO2ib9+u3HjjsWmXIaBb790ZcsAnd+rfsLqeTWuWsHXzBrr1GkKP/vs0vtd39/dy+FkzmPWLj7Oy/qmOLFet8NwqLX5mSZXFACJlIYRuwPuBo4BxwP7AQKAGWAUsAp4GfhljfCytOqVizJ12HhtXvZZ2GWpFL+BQ4LDs64fAc6lWpGJcf/3RDB3aE4AHHniVSZNGpVyRAFa8/iSL597B0lceYtOaJTu8V9dnBHtP/BZDxnwKgOranhz6ibt5/MZxbN6wLI1y1QTPrdLkZ5Z21ZIls7j88pB2GZ2eAURKQgiDgeuBE4CezQwbmH2NBy4KITwNfD7G+NcOKVJSRbqDzA9v+wC5H8NT0ylHbXD88aM488wxAEybtoBf/3q+/0hKUYwNvPnSH1jw+PdY89bcZsdtWLWIOfd+nk1r32Dke/8FgNq6/ux5xFd56ZFLOqpctcBzq/T4mSVVFp+CkZ49gH9i5/ChHvgz8Cd2nnV2OPBsCOEDyZcnqVJ9hsw9tf4OoDz17l3LlCmZ6eGrV29i8uSHU65Ia958ntn3nNZi+JBr/vRvsSHnFrTB+30socpUDM+t0uRnllRZDCBKwxPAucAeMcY9YoyHxxiPjjHuC+wJ3JUztgfw+xDCgDQKlSSl69prj2LYsMxCh1//+mPU169JuSIVKzZsZumChxrbdX2GU1Vdl2JFAs8tSeoIBhDpaQB+BxwaY/xAjPGmGONOK/LFGF+NMX4GuDanux/wjY4pU5JUKo49diRnn30QAI89Vs8NN8xOtyC1Wf6aD809PUMdw3NLkjqGAURKYox/iTF+PMY4u8BdvkHm9oxtPtH+VUmSSlXPnjVMnZqZHr5x4xbOOeeBlCvSrqjrO6JxOzZsZfN6F6FMi+eWJHUcF6EsEzHGd0II/0vmVg2A4SGE7jHG9WnWJTVl36O+Q4/++9Kt9+50qa5j88aVbFxTz8r6p3nzpT+w4vXH0y5RKjvXXHMkw4f3BuCKK55i/vwVKVektqqq7saAPY9pbK/6xyxi3JpiRZ2b55YkdRwDiPKS/+uR3oABhErObvufskO7a8/BdO05mD5DDmPEu7/AyiXP8sJ9X2Dt0hdTqlAqL0cfPZzzzz8EgNmz3+Lqq59JuSLtihHjJ1PTrW9je8m8u9MrppPz3JKkjuUtGOVlZM52A7A0pTqkFr2zfhkrlzzLslf/xMrFz/DO+h3/V+079N0cftZ0Bu51XEoVSuWjR48abrppEgBbtjRwzjkPsHVrTLkqtVXPAQcw+gPbH7m5fsUC6mf/LMWKOi/PLUnqeM6AKBMhhDrg+JyuZ2OMW9KqR8q36h9/YfGc21i64EE2rFq00/u9dxvLqMO/ym77fxyALjXdOfjkW3nmtg8X/Og6qTO66qoJjBrVB4DrrpvFrFlvplyR2qqmrh9jT72TLjWZJ140NGxh7rQLiA2bU66sc/LckqSO5wyI8vEvQJ+c9m1pFSLl27jqNZ6+ZQKv/2Vqk+EDwOo3ZvP87z7LXx/8WmNfdW0P9jvmmo4qUyo7EyfuweTJYwF4+eUVXHrpE+kWpDarqu7GoafeTY9+ezX2vTzjclbWP5ViVZ2X55YkpcMAogyEEA4ELsvpWgBMTacaade8Nut/qH/+1sZ2v+Hvp/duh6ZYkVSa6uqqufnmSVRVBQDOPfdBNm504ls5ClU1jD3lTt61x/sa+xbN/B9effq6FKvqvDy3JCk9BhAlLoTQH/gt0C3btRU4K8b4Tiv7nRdCmBlCmPn2228nXaZUlFee/MEO7dzV4CVlXHnlBEaP7gvA1KlzmD799XQLUpuEqmrGfvw2Bo4+trHv9ed+xt8e+loLeylJnluSlB4DiBKWXffh98BeOd3/HmNs9RmGMcYpMcbxMcbxAwcOTKxGqS02rFzIhpXbb9Xo0X+fFKuRSs/++/fnoosyM4OWLFnLxRfPSLkitUUIXTj45FsYtM8JjX31z9/Ki/d/McWqOjfPLUlKl4tQlqgQQi1wD/D+nO6fxBivSqkkqV1tWvcGdX1HAFDbvX/K1UilZdCg7o3Tw4cO7cnKlcX9g3XhwvNytlcxapR37XW4UMVBJ/2U3fb7WGPX4jm38cIfL0qvJnluSVLKnAFRgkIINcCvgNxnFE4lsxClVBG6VHdv3N66eWOKlUhSOwtVHHziTQw54NTGrsVzbmfefRcCPuZRktR5OQOixIQQqoG7gJNyun8KnB9j9KcWVYTQpZa6d+3Z2N60zkefSbk2b97K0qXrCx7ftWs1vXrVNraXL99AQ0PMbhvwdahQxUEnTmXImE81di2eewfz7puM4UP6PLckKV0GECUkhNAFuAM4Naf7FuBcwwdVksH7nkx1bY/G9sr6J1OsRio9Tz65hIED/7vg8WeeOYZbbjm+sT1u3G0sWrQ6idLUosBBJ9zI0DGfbuxZPPdO5k27AMOH0uC5JUnp8haMEpENH24DPpXTfStwdoyxIZ2qpPZX230g+xx5eWN7yztrWfrKwylWJEntIXDgR29g6IGnNfYsmXcX86adj+GDJEkZBhAlIBs+/Bw4Laf758DnDR9U6vrs/h4OmPSfdO+3d6tjew4cw7s/80fq+gxv7Fv4zI/ZvGF5kiVKUuLGHP8jdj/4jMb2knl3M/cP52H4IEnSdt6CkbIQQhWZ2yw+k9N9G/A5wweVg6ouXdlj3NnsMe5sVr85h+WLZrDmrXm8s+5NtmxaS5faHnR/12gG7PkhBo4+jlDVpXHfpa/+H688cXWK1XdO38m+8r2Ts/0o0K2JMZ8lsyKupO0G73cKw8Z+rrEdYwO1PQZx2KfvKfgYLz3yTda+/UIS5Ullzc8sqbIYQKQoGz78FDgjp/t24CzDB5Wj3oMPpvfggwsau3jO7fz1wa8QGzYnXJXybQE2tTImNjPG75a0sy41dTu0Q6hiwKijizrGK09d254lSRXDzyypshhApCSEEIAbgTNzuu8AzjR8UDnZsHIhS+bdRZ+h76ZHv71aHNuwdTNLFzzAopk3sHzRjA6qUJIkSVIpMIBIzyeBc3LaERgM/DGTTRTkX2OMc9q7MKkYG1e/ztw/nAtATV1/eg06kNruA6ip60dNt75s3bKRLRtXsm75Ala/8RcatvjYsrRdln2pctx66wvceqvT99OyZO4dLJl7R9plKAGeW+m7DD+zpEpiAJGe7nntAHy4yGNc2U61SO1i84ZlzmyQJEmS1CSfgiFJkiRJkhLnDIiUxBhvIfP0C0mSJEmSKp4zICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuKq0y5AkiRJkqQk9ayq4vDaurTLyLMu7QI6nDMgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJEkqYSGEy0IIsYjX0rRrbooBhCRJkiRJSlx12gVIkiRJkqSC/QKY2cqY9R1RSLEMICRJkiRJKh/3xxhvSbuItvAWDEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSyse5IYS5IYQ1IYSNIYTFIYT/CyFcEkIYnHZxLTGAkCRJkiSpfLwPOBDoCXQFhgJHA98FFoYQvh5CCCnW1yyfgtEJzJr1JiFck3YZKkCMa9MuQcW4pCSv62rC/d+7LO0SVITjLrks7RJUIM+t8hEu+UHaJahg/5l2ASptbwGPAy8Bq4FewEHAh4E6oBvwfWBv4OyUamyWAYQkSZIkSR1vQAhhZk57SoxxSjNjnyYzy2FGjLEh/80QwkDgeuAz2a7PhxD+3MLxUmEAIUmSJElSx1saYxxfyMAY4/2tvP82cHoIYSvw2Wz35SGEW2OMm3axznbjGhCSJEmSJFWG/wdsu697N2BCeqXszABCkiRJkqQKEGNcDjyc03VEWrU0xQBCkiRJkqTK8XLOdkk9ltMAQpIkSZKkyhGb2U6dAYQkSZIkSZVjr5ztt1KrogkGEJIkSZIkVYAQQl/gwzldf06plCYZQEiSJEmSVBmuBXplt98GZqRYy04MICRJkiRJKlEhhItDCNeGEPZpYUz/EMKtwOdyui+LMW5MvsLCVaddgCRJkiRJalYP4MvAl0MIfwNmAouANUBP4CDgGKB7zj63xBj/u6MLbY0BhCRJkiRJ5WG/7Ks564FvAT/smHKKYwAhSZIkSVLp+k8ysx4OB94NDAMGAO8CNgLLgOeBR4DbYowrUqqzVQYQkiRJkiSVqGygMC37KmsuQilJkiRJkhJnACFJkiRJkhJnACFJkiRJkhJnACFJkiRJkhLnIpSSJEmSpIq2YXEDcy9Zl3YZnZ4zICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuKq0y5A2hW33/4RTj/9gB36Ro6cwqJFq1OqSCoPq4G/ALOAmdk/XwZi9v2JwPRUKpMql59ZpaOqS1f6DjuCfiMm0Hu3Q+jRf19quw+gqqqGzZtWs3H1a6xc/Cxv/PUeVtY/mXa5aoXnllQ+DCBUtk44Yc+dPmwktW5f4O9sDxtUurr1Gc7EC18ser+1y+bzxJRxCVSktvIzqzTUdh/EfsdcxcDRx1HdtVeTY7pWD6Rrj4H0GXIYI8ZfwMrFf2befReybtlLHVytCuG5JZUXb8FQWerbtys33nhs2mVIZWk+hg9SR/Izq3R06707Qw745E7hw4bV9axc/AzLFs5g3bL5O7zXd/f3cvhZM+g77IiOLFUF8NySyo8zIFSWrr/+aIYO7QnAAw+8yqRJo1KuSCo/vYBDgcOyrx8Cz6VakVqz/LXHadiyodVxG1fXd0A1KpSfWaVpxetPsnjuHSx95SE2rVmyw3t1fUaw98RvMWTMpwCoru3JoZ+4m8dvHMfmDcvSKFdN8NySyo8BRAFCCL2BcWR+Rh+f/XMvIGSHzIgxHrmLX2M/4J+BScAeQG/gDeAl4FfAL2KMa3bla1SK448fxZlnjgFg2rQF/PrX8/3AkYpwB5mL2D5sv4gBTE2nHBVh7rTz2LjqtbTLUBH8zCotMTbw5kt/YMHj32PNW3ObHbdh1SLm3Pt5Nq19g5Hv/RcAauv6s+cRX+WlRy7pqHLVAs8tqTx5C0YrQggvASuBPwHXAP8E7M2OP7fvyvGrQwjfBuYB3yATdAwEugIjgGPJ/LtgXgjhqPb4muWsd+9apkzJTLVbvXoTkyc/nHJFUvn5DJl1INrlIiapWX5mlZ41bz7P7HtOazF8yDV/+rfYkDOjaPB+H0uoMhXDc0sqXwYQrcv/JWF7uxn4JtAl247Ai8CjwOs544YDD4YQOvWNbtdeexTDhmXu2/z61x+jvt5JIZKk0uRnVvmLDZtZuuChxnZdn+FUVdelWJHAc0sqZwYQhVtDJhS4DjiDdrhVOoTwFTK3XWzzKLBfjHFMjHFijHE4cAyw7cbEauBXIYQRu/q1y9Gxx47k7LMPAuCxx+q54YbZ6RYkSVIz/MyqHPlrPjT39Ax1DM8tqby5BkTrTgdmAfNjjI0Lx4cQzt2Vg4YQ+gOX5nQ9BxwbY9yUOy7G+HAIYQIwG+hJZm2Ib7NjcFHxevasYerUzOSPjRu3cM45D6RckSRJTfMzq7LU9d3+e5/YsJXN612EMi2eW1L5cwZEK2KMd8YYX8oNH9rJRUCfnPb5+eFDTg0LyIQO25weQhjZzvWUtGuuOZLhw3sDcMUVTzF//oqUK5IkqWl+ZlWOqupuDNjzmMb2qn/MIsatKVbUuXluSeXPGRDp+WTO9jMxxmdbGX8TcDnQjUxwdCqZp+ZVvKOPHs755x8CwOzZb3H11c+kXJEkpWPfo75Dj/770q337nSprmPzxpVsXFPPyvqnefOlP7Di9cfTLrHT8zOrsowYP5mabn0b20vm3Z1eMZ2c55ZUGQwgUhBC2BMYk9M1rbV9YozLQwhPAduehHESnSCA6NGjhptumgTAli0NnHPOA2zd2t6TUSSpPOy2/yk7tLv2HEzXnoPpM+QwRrz7C6xc8iwv3PcF1i59MaUKOzc/sypLzwEHMPoD2x+5uX7FAupn/yzFijovzy2pcngLRjoOzWs/UeB+uePGtk8ppe2qqyYwalTmTpXrrpvFrFlvplyRJKXnnfXLWLnkWZa9+idWLn6Gd9Yv3eH9vkPfzeFnTWfgXselVGHn5mdW5aip68fYU++kS03miRcNDVuYO+0CYsPmlCvrnDy3pMrhDIh0HJDX/nuB++WO6x1CGBZjrG92dJmbOHEPJk8eC8DLL6/g0ksLzWkkqXKs+sdfWDznNpYueJANqxbt9H7v3cYy6vCvstv+HwegS013Dj75Vp657cOseWtuR5fbafmZVTmqqrtx6Kl306PfXo19L8+4nJX1T6VYVefluSVVFmdApGNkzvZWtj9mszX5P3mObGpQJairq+bmmydRVRUAOPfcB9m4cUvKVUlSx9q46jWevmUCr/9lapPhA8DqN2bz/O8+y18f/FpjX3VtD/Y75pqOKrPT8zOrcoSqGsaecifv2uN9jX2LZv4Prz59XYpVdV6eW1LlMYBIR++c7TWx8OWUV+W1m30QdQjhvBDCzBDCTFhbdIFpu/LKCYwe3ReAqVPnMH366+kWJEkl7rVZ/0P987c2tvsNfz+9d8u/409J8DOrMoSqasZ+/DYGjj62se/1537G3x76Wgt7KUmeW1LlMYBIR8+c7Q1F7Jc/ttkAIsY4JcY4PsY4fscvV/r2378/F12U+aF5yZK1XHzxjJQrkqTy8MqTP9ihnfv4QCXDz6zKEEIXDj75Fgbtc0JjX/3zt/Li/V9MsarOzXNLqkyuAZGOmpztYuaR5Y+taXJUmRs0qHvjVLuhQ3uycmVxH/4LF56Xs72KUaOmtmt9klSqNqxcyIaVi6jrOwKAHv33SbmiyudnVgUIVRx00k/Zbb+PNXYtnnMbL/zxovRqkueWVKGcAZGOdTnb3YrYL3/suiZHSZI6rU3r3mjcru3eP8VKpDIQqjj4xJsYcsCpjV2L59zOvPsuBHzMoyS1N2dApCN3UYbuReyXP3ZNO9RScjZv3srSpesLHt+1azW9etU2tpcv30BDQ8xub2z3+iSplHWp3v5RsXWz18Ck+ZlVxkIVB504lSFjPtXYtXjuHcy7bzKGD+nz3JIqkwFEOt7O2e4RQugVYywkTBiS117a5Kgy9+STSxg48L8LHn/mmWO45ZbjG9vjxt3GokWrkyhNkkpa6FJL3bv2bGxvWvdmitV0Dn5mlavAQSfcyNAxn27sWTz3TuZNuwDDh9LguSVVJgOIdPwtrz0CmFfAfiNythuA+e1WkSSp7A3e92Sqa3s0tlfWP5liNVKpChz40RsYeuBpjT1L5t3FvGnnY/ggVa7BQKk90+bitAtIgWtApOOFvPa4AvfLHbcwxljMEzQkSRWstvtA9jny8sb2lnfWsvSVh1OsSCpNY47/EbsffEZje8m8u5n7h/MwfJCk5DkDIh0zySwgue3XVBOBnxew34Sc7entXJOkTuI72Ve+d3K2H6XpFXI/C7iOeMfos/t72P3A01n47E9Yv/zvLY7tOXAMh5x8C3V9hjf2LXzmx2zesDzpMqWyMni/Uxg29nON7RgbqO0xiMM+fU/Bx3jpkW+y9u383yVJkgphAJGCGOOGEML9wLYll08NIXwxxtjsSjshhA8Ae+Z0/SbJGiVVri3AplbGxGbGbG7/ctSMqi5d2WPc2ewx7mxWvzmH5YtmsOatebyz7k22bFpLl9oedH/XaAbs+SEGjj6OUNWlcd+lr/4frzxxdYrVS6WpS03dDu0Qqhgw6uiijvHKU9e2Z0mS1KkYQKTnZrYHEH2ALwPfbWH8t3K2XwOcVytJnUTvwQfTe/DBBY1dPOd2/vrgV4gNxkWSJKm0GECkJMb4vyGEGWRuvwC4NITwXIzxj/ljQwjfBT6c03VpjPGd/HGd1a23vsCttzoVUirUZdmXStuGlQtZMu8u+gx9Nz367dXi2Iatm1m64AEWzbyB5YtmdFCFags/s9K1ZO4dLJl7R9plKAGeW1J5MIBoRQjhm8A3m3irNmd7QgihqQcM3xZjPLeFw58HPAX0yx7v3hDCXcDvgGXAKOBzwAdz9rkXuK3gv4AkqSxtXP06c/+Q+QipqetPr0EHUtt9ADV1/ajp1petWzayZeNK1i1fwOo3/kLDFp9zL0mSSpsBROuqga6tjAnNjKlpaacY4/wQwsnA78mEEF2AM7KvpjwCnBZjbGilHklSBdm8YZkzGyRJUtnzMZwpizE+DowB7qL5deHqga8Ax7S0UKUkSZIkSaXKGRCtiDFeRsK3S8cY3wA+E0LoAxwJDAN6AW8CLwFPxRh9OLUkSZIkqWwZQJSQGOMqMrdjSJIkSZJUUbwFQ5IkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZIkJc4AQpIkSZKkMhVCODiE8E4IIea8RqZdV1MMICRJkiRJKkMhhGrgZ0BN2rUUwgBCkiRJkqTy9A1gHPBO2oUUwgBCkiRJkqQyE0I4EPhmtvndNGspVHXaBUiSJEmSlKRZDCPwpbTLyHNxm/fM3npxC1ALzAO+D1zeLmUlyBkQkiRJkiSVl38DDgMagLNjjJtTrqcgBhCSJEmSJJWJEMIY4NJs8z9jjM+kWU8xDCAkSZIkSSoDIYQuZJ56UQu8yvY1IMqCAYQkSZIkSeXhYuDd2e3zYozr0yymWAYQkiRJkiSVuBDC/sBl2eZPY4wPp1hOm/gUDKmUhJB2BSpGjGlXoAId1/hZrXIQL2n7quDqYJekXYAKFXdhtX11rPFpF6CONCCEMDOnPSXGOKWpgTm3XnQF3gC+1gH1tTsDCEmSJEmSOt7SGGOhmdNXgfdmt78QY1yRUE2J8hYMSZIkSZJKVAhhX+DybPOeGOM9adazKwwgJEmSJEkqQSGEKjK3XnQDVgJfSLWgXWQAIUmSJElSafoccER2+6sxxjfSLGZXGUBIkiRJklSa9sjZvjmEEJt75e33as57l3VgvS0ygJAkSZIkSYnzKRiSJEmSJJWm2cCtBY49M2f7N8DanGOUBAMISZIkSZJKUIzxd8DvChkbQsgNIL4WY1yYQEm7xFswJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4lyEUpIkSZKkMhdjDGnX0BpnQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMQZQEiSJEmSpMRVp12AJEmSJEnJGgx8Le0i8lycdgEdzhkQkiRJkiQpcQYQkiRJkiQpcd6CobJ2++0f4fTTD9ihb+TIKSxatDqlijqv1cBfgFnAzOyfLwMx+/5EYHoqlUmVYQ/68FkO5kT2ZTh96E8db7GOV1jBPfyVO5nLUtanXWan5nWwvPj9Kh9+r6TKYQChsnXCCXvuFD4oHfsCf2f7DwKS2tdFvIerOIbu1OzQvwd92IM+TGQklzKRydzHr3ghpSo7N6+D5cXvV/nweyVVFm/BUFnq27crN954bNplKGs+/mAgJeUKjuLHfGSH8GE+y5jOQl5meWNff7rzSz7JWYxNoUp5HSwvfr/Kh98rqbI4A0Jl6frrj2bo0J4APPDAq0yaNCrligTQCzgUOCz7+iHwXKoVSeXt4+zPfzCxsf0Cb/FZfstz/KOx7zCG8nM+zgEMBGAKJ/ICb/Msizu8XnkdLDd+v8qH3yupMhhAFCCE0A14P3AUMA7YHxgI1ACrgEXA08AvY4yPtfFr7Af8MzAJ2APoDbwBvAT8CvhFjHHNrv1NKsPxx4/izDPHADBt2gJ+/ev5BhApu4PMDwP7ACGnf2o65UgVoZoqfsAxje3XWcUH+Ckr2bjDuFks4QP8lDlMZhi9qaEL13AsE/lZR5fcqXkdLC9+v8qH3yupsngLRgtCCINDCHcBbwMPA/8OHA+MBHoAtWSCiPHARcCjIYSnQgj7F/E1qkMI3wbmAd8gE3AMBLoCI4BjyVxj54UQjmqnv1rZ6t27lilTMrderF69icmTH065IgF8hsw9mqG1gZIK9hkOYjT9Gttf4YGdwodtVrCBr/BAY3sCI/ggIxKvUdt5HSwvfr/Kh98rqbIYQLRsD+CfgJ55/fXAn4E/kbk1LdfhwLMhhA8U+DVuBr4JdMm2I/Ai8Cjwes644cCDIYROvfDBtdcexbBhvQD4+tcfo77eSSGSKtMnGdO4vZjV/Ja/tTj+Hv7KYrY/AeiTuEivJEkqLQYQhXsCOBfYI8a4R4zx8Bjj0THGfYE9gbtyxvYAfh9CGNDSAUMIXyFz28U2jwL7xRjHxBgnxhiHA8cAS7LvVwO/CiF0yl9rHXvsSM4++yAAHnusnhtumJ1uQZKUkG5U82H2bGzfz8tspaHFfbbSwAMsaGyfxL6J1SdJktQWBhAtawB+BxwaY/xAjPGmGGN9/qAY46sxxs8A1+Z09yNzS0WTQgj9gUtzup4Djo0x7jCjIsb4MDABWJvt6g18uw1/l7LWs2cNU6dmJn9s3LiFc855oJU9JKl8HcBAuuUs0/TEDhPimvcErzVuj6Av76Ku3WuTJElqKwOIFsQY/xJj/HiMcXaBu3yDzO0Z23yihbEXAX1y2ufHGDc1U8cCdgwdTg8hjCywpopwzTVHMnx4bwCuuOIp5s9fkXJFkpScbU+02ObvLCtov7/nPJazqeNIkiSlyQCiHcUY3wH+N6dreAihezPDP5mz/UyM8dlWDn8TNK4+VgWc2rYqy8/RRw/n/PMPAWD27Le4+upnUq5IkpI1kr47tF9jVUH7LWJli8eRJElKkwFE+8v/NVXv/AEhhD0hZ3UxmNbaQWOMy4GncrpOalN1ZaZHjxpuumkSAFu2NHDOOQ+wdWtMuSpJSlZvuu7Qbu7pF/lWseNEul7UtltNkiRJu8oAov2NzNluAJY2MebQvPYTBR47d9zYwksqX1ddNYFRozJ3qlx33SxmzXoz5YokKXk984KDDWwpaL8NbN6h3SsvyJAkSUqTAUQ7CiHUAcfndD0bY2zqp8b8Z6P9vcAvkTuudwhhWDH1lZuJE/dg8uSxALz88gouvbTQnEaSyltN45OZM7a08gSMbTbnjavxY16SJJUQfzJpX//CjgtL3tbMuJE521vZ/pjN1ixq4TgVpa6umptvnkRVVQDg3HMfZOPGwn4DKEnlbh3v7NDOfSJGS+ryxq3LmxEhSZKUJgOIdhJCOBC4LKdrATC1meG560KsiTFuLfDL5K9C1quFes4LIcwMIczc/gTP8nHllRMYPbovAFOnzmH69MIeQSdJlWBtXgDRnZqC9ssft4YmH64kSZKUCgOIdhBC6A/8FuiW7doKnJV9KkZTeuZsbyjiS+WPbTaAiDFOiTGOjzGO3/HLlb799+/PRRdllslYsmQtF188I+WKJKljvc36HdpDCryOD8n7WFiadxxJkqQ0FTanU83Krvvwe2CvnO5/jzE+3sJuub+iKua+gvyxhf1KrMwMGtS98daLoUN7snLlF4vaf+HC83K2VzFqVHMTUSSpNP0tb/3iEfRlHm+1ut+IHe4C3Pk4kiRJaXIGxC4IIdQC9wDvz+n+SYzxqlZ2XZez3a3ZUTvLH7uuyVGSpLL2Ql7YMI4hBe2XO24TW3iZ5e1alyRJ0q5wBkQbhRBqgF8Bx+V0TyWzEGVrchdl6F7El80fu6aIfcvG5s1bWbq08GnDXbtW06vX9kfWLV++gYaGmN3e2O71SVLS6lnNApYzmn4ATGQE3y5gv4k5axM/zms0EJMpUJIkqQ0MINoghFAN3AWclNP9U+D8GGMhP+29nbPdI4TQK8ZYSJiQ/yuwipxb++STSxg48L8LHn/mmWO45ZbtTz8dN+42Fi1anURpktRhfsvf+BrvA+BIRrIHfXh9p7WIt9uDPkxkRGP7N/w18RolSZKK4S0YRQohdAHuAE7N6b4FOLfA8AHgb3ntEU2O2lnuuAZgfoH7SZLKzM94jq00ANCFKv6DCS2Ov5SJdMl+rK9hE7/khcRrlCRJKoYBRBGy4cNtwKdyum8Fzo4xNhRxqPyfCscVuF/uuIUxxmKeoCFJKiMv8ja3M6exfS6HcXYzHxfncRjn5Lx3DU+yzCdgSJKkEmMAUaBs+PBz4LSc7p8Dny8yfACYyY4LSE4scL/cX39NL/JrSon5DpkVUvNfj+aMebSZMed2aKVSebmYh3iFFY3tmziJ3/FP/BMHMoERnMZB3Mtp3MiJjWOeYTE/4Mk0yu3UvA6WF79f5cPvlVRZXAOiACGEKjK3WXwmp/s24HNtCB+IMW4IIdzP9ts4Tg0hfDHG2Oyvq0IIHwD2zOn6TbFfV0rKFmBTK2NiM2M2t385UsV4m3V8hDt4gDMYQV8ATmY/Tma/Jsc/zxucwJ1s8MzqcF4Hy4vfr/Lh90qqLM6AaEU2fPgpcEZO9+3AWW0JH3LcnLPdB/hyK+O/lbP9GvDwLnxtSVKZeImlHMQN/BfPsKaZH8OXsp5vM4N3M5W3fUKzJEkqUaHwdRM7nxBCAKYA5+R03wH88y6GD9uOP53tt1+8A3w8xvjHJsZ9F7gkp+usGOOthX+dPSJ8aVdKVQeJXJx2CSqG18+yEbgs7RLaRTeqOZKRjKAv76IbS1nPAlbwKIsaF6ysBDFcnnYJkpSa8cDMGEPadVSaEMbHzJ3wpSTMijGOT7uKjuQtGC37JDuGDxEYDPwxk00U5F9jjHOaee884CmgH1AL3BtCuAv4HbAMGAV8Dvhgzj73krn9Q5LUyWxkC/fzctplSJIktYkBRMu657UD8OEij3Flc2/EGOeHEE4Gfk8mhOhC5laPM5rZ5RHgtPaYfSFJkiRJUkdyDYiUxRgfB8YAd9H8Gjv1wFeAY1paqFKSJEmSpFLlDIgWxBhvIfP0i6S/zhvAZ0IIfYAjgWFAL+BN4CXgqehiHZIkSZKkMmYAUUJijKvI3I4hSZIkSVJF8RYMSZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUuOq0C5AkSZIkKVGHLYGZl6VdxY5C2gV0PGdASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxBlASJIkSZKkxFWnXYAkSZIkSWpeCGEv4L3AeGAsMAQYAPQB1gFLgFnAr4FpMcat6VTaMgMISZIkSZJK2/3A6Gbe65N97Q+cATwfQvhsjHFuRxVXKAMISZIkSZLKw2JgNvAP4E1gLdAfGAdMBLoAhwCPhhDeF2P8a0p1NskAQpIkSZKk0nYxMCvG+FpzA0II+wD3AGOAvsB/AUd3SHUFchFKSZIkSZJKWIzxty2FD9kx84FP53QdGUIYnGxlxTGAkCRJkiSpAsQYXwDeyjYDMDK9anZmACFJkiRJUgUIIdQAPXO61qdVS1MMICRJkiRJqgwXAd2z228BL6ZYy05chFKSJEmSpDIUQqgis+DkIcCZ2dc2/x5j3JpGXc0xgJAkSZIkqUyEEK4E/q2FIRuAC2KMP++gkgpmANEJHEY9M7k47TJUgBC/lXYJKsL93+/Z+iCVhPiNtWmXoKJcnnYBKtAD3+uRdgkq0HGXXJZ2CSrYf6ZdgDrOgBDCzJz2lBjjlF085i+AL8YY397F4yTCAEKSJEmSpI63NMY4vg373QcszW7XAIOAI4D3knkM53tDCF+NMd7TPmW2HwMISZIkSZLKRIzxMeCx/P4QwnuAO4HRwG9CCBfFGP+ro+triU/BkCRJkiSpzMUYnwE+BKzLdl0XQtgrxZJ2YgAhSZIkSVIFiDEuAm7PNmuAs9KrZmcGEJIkSZIkVY45OduHpFZFEwwgJEmSJEmqHLlrPXZJrYomGEBIkiRJklQ53p2zXZ9aFU0wgJAkSZIkqQKEEMYAn8rpejCtWppiACFJkiRJUokKIVyafQ1rZdxHgYeB2mzXX4F7k66vGNWtD5EkSZIkSSnpB3wJuCyE8Dwwm8ytFWuBOmAk8EFgz5x9lgKnxRjf6dBKW2EAIUmSJElS6WrI/hmAsdlXSx4GJscYX06wpjYxgJAkSZIkVbYl/4DLL0+7irb6V+B3wJFkFpjcBxgC9AA2AiuBl4BngF/FGGelUWQhDCAkSZIkSSpRMcYtwKPZV1lzEUpJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpQ4AwhJkiRJkpS46l09QAhhAHAwMAB4B3gTeC7GuHFXjy1JkiRJkipDmwOIEMLxwLeA8UDIe3tTCOEPwKUxxpd2oT5JkiRJklQB2nQLRgjhamAa8O7sMULeqxvwCeAvIYQT26dUSZIkSZJUroqeARFCuBD4WrYZs6/8GRAx+2cd8IsQwrgY49/aXKU6rdXAX4BZwMzsny+z/X+wicD0VCpTrkDgIAbxPvbgYAazPwMZQR8G0J06aljPZpazgTm8yQwWcgdzeZO1aZfdaVV16UrfYUfQb8QEeu92CD3670tt9wFUVdWwedNqNq5+jZWLn+WNv97Dyvon0y5XKht+ZpUPr4OV5fbbP8Lppx+wQ9/IkVNYtGh1ShVJak5RAUQIoRdwJds/SwPwPJnZEK8DNcD+wCnAbtlx3YDrgePapWJ1GvsCf2f7/2wqXV/mcH7IpGbf701XetOVkfTlJPble3yIH/AkVzCDzWztwEo7t9rug9jvmKsYOPo4qrv2anJM1+qBdO0xkD5DDmPE+AtYufjPzLvvQtYt8246qSV+ZpUHr4OV54QT9twpfJBUuoqdAXE60JPM52sDcGGMcWr+oBDCV4EbgX/Odn04hDAixrhoV4pV5zI/7QJUsJA3CeodtvIqK3iLdWxiK33oyr4MoDddAehKNd9kAocxhI9xN+8YQnSIbr13Z8gBn9ypf8PqejatWcLWzRvo1msIPfrv0/he393fy+FnzWDWLz7OyvqnOrJcqaz4mVUevA5Wlr59u3LjjcemXYakIhQbQByVs/39psIHgBjjphDC54C9gSPIzJQ4CrilLUWqc+sFHAocln39EHgu1YqUbzNb+T9e4Q/M5zEW8TxvspWGHcZUETievfkBx7A/AwE4nr35DybyHzySRtmd2orXn2Tx3DtY+spDbFqzZIf36vqMYO+J32LImE8BUF3bk0M/cTeP3ziOzRuWpVGuVDb8zCofXgfL3/XXH83QoT0BeOCBV5k0aVTKFUlqTbGLUI7N/rkFuKalgTHGmDfm0CK/VtkIIdwRQoh5r5FFHmO/EML3QgizQghvhRA2hhAWhhAeCCGck739pVO5A/gbsAqYAVxLZgpO7zSLUpN+xJ/5MD/nP3mav/CPncIHgAYi9zGfI7iZl1ja2P8l3ku3XX8isAoQYwNvvvQHnrz5CJ65/VgWP3/rTj90A2xYtYg5936ehX/+UWNfbV1/9jziqx1ZrlRW/MwqD14HK8fxx4/izDPHADBt2gLuusvl5qRyUGwAMZDM7RcvxhgLWdXliZztAUV+rbKQfcrHZ3Zh/+oQwreBecA3gHFk/jt3BUYAxwJTgXkhhKOaPVAF+gyZe2rzVzhVeVvFRr7LY43tXnTlvQxLsaLOY82bzzP7ntNY89bcgsbPn/4tNqyub2wP3u9jCVUmlT8/s8qD18HK0Lt3LVOmZG69WL16E5MnP5xyRZIKVWwAsS3If6vA8UtztivulwAhhHeRWetiV9wMfBPokm1H4EXgUTILe24zHHgwhOCNbip7M9nxt01D6JlSJWpJbNjM0gUPNbbr+gynqrouxYokqWN5HSxN1157FMOGZSYHf/3rj1FfvybliiQVqtgAYtv4glaMizHmzsPu0uzA8nU9MCS7/WCxO4cQvsL2hTohEzrsF2McE2OcGGMcDhwDjf9aqwZ+FUIY0faSpfTV5F16VrMppUrUmvx7nZtbNV6SKpXXwdJy7LEjOfvsgwB47LF6brhhdroFSSpKsQGEskIIH2F7eHAfcFeR+/cHLs3peg44Nsa4w0LaMcaHgQnA2mxXb+DbbalZKhVHsX2RqM1s5RkWp1iNWlLXd3veGRu2snm9i69J6ly8DpaOnj1rmDo1Mxl448YtnHPOAylXJKlYBhBtEELoA0zJNtcAk9twmIuAPjnt82OMTf4aOMa4gB1Dh9OLXeRSKhX70J9/54ON7VuYzVLWp1iRmlNV3Y0Bex7T2F71j1nE6CNTJXUeXgdLyzXXHMnw4Zm7uq+44inmz1+RckWSimUA0TbXArtnt78eY3y9pcHNyH0I9TMxxmdbGX8TsDG7XQWc2oavKaWiF10Zz1C+w9HM5DwG0gOAJ3mdr+BvL0rViPGTqenWt7G9ZN7d6RUjSSnwOlg6jj56OOeffwgAs2e/xdVXP5NyRZLaoq3PvpsYQngloX1ijHF0W4rqCCGEScDns83HgRvacIw9gTE5XdNa2yfGuDyE8BSw7UkYJ5F5vLhUcv6XMziOvZp9/23W8Z/8mat5gs2FLSmjDtZzwAGM/sAlje31KxZQP/tnKVYkSR3L62Dp6NGjhptumgTAli0NnHPOA2zdGlOuSlJbtDWA6AaMLHDstqtDa/tEMk+vKtmrSQihF5lHYgJsAs6JMbal3kPz2k80OWpnT7A9gBjbhq8rpW41m7iRWdzKbMOHElVT14+xp95Jl5rMSu8NDVuYO+0CYsPmlCuTpI7hdbC0XHXVBEaNyty5fN11s5g1682UK5LUVm0JIIp9xHWh48vh0dnXAHtkt6+IMb7UxuMckNf+e4H75Y7rHUIYFmOsb3a0lJLcx2x2IdCXbuzHAHrRld505ZtM4F95P9/hUb7NjBQrVb6q6m4ceurd9Oi3fQbLyzMuZ2X9UylWJUkdx+tgaZk4cQ8mTx4LwMsvr+DSSwv9vZ2kUlRsAHFrIlWUgRDCh4Dzss3ngat34XAjc7a3Qs6/1lq2qInjGECo5PwHj+zUFwh8iFF8m6M5nGHU0oUrOIp+1PFl7k+hSuULVTWMPeVO3rXH+xr7Fs38H159+roUq5KkjuN1sLTU1VVz882TqKrK/J7y3HMfZOPGLSlXJWlXFBVAxBg/l1QhpSyE0JPMIpCQCQzOiTHuytWvd872mlj4csqr8trNPog6hHAe2cBkeHG1SYmIRB7mFR7hVe7kVD7NgQD8Pw7nd/yNGSxMt8BOLlRVM/bjtzFw9LGNfa8/9zP+9tDXUqxKkjqO18HSc+WVExg9ui8AU6fOYfr0tqz7LmUMAc5Pu4g8l6VdQAp8CkZhrmL7rIXrYowzd/F4PXO2NxSxX/7YZgOIGOOUGOP4GOP4gUWVJiWrgci5/IFlOY/evIj3pFiRQujCwSffwqB9Tmjsq3/+Vl68/4spViVJHcfrYOnZf//+XHRRZtm0JUvWcvHF3rIpVYK2LkLZaYQQjgQmZ5sLgEvb4bA1OdvFzKTIH1vT5CipxK1hE//Ly5zBwQC8r3FpFXW4UMVBJ/2U3fb7WGPX4jm38cIfL0qvJknqSF4HS9KgQd0bb70YOrQnK1cWFwYtXHhezvYqRo2a2sJoSR3FGRAtCCF0B25m+wKZ58YYi5mx0Jx1Odvditgvf+y6JkdJZeC1nDuKBtA9xUo6sVDFwSfexJADTm3sWjzndubddyEl/EAiSWo/XgclqUM5A6JlVwJ7ZrdvijH+qZ2OuzZnu5h/eeWPXdMOtUip6EPXxu0VRd2JpHYRqjjoxKkMGfOpxq7Fc+9g3n2T8YduSZ2C18GStnnzVpYuXd/6wKyuXavp1au2sb18+QYaGmJ2e2O71yepbYoKIEII/5xUIblijD/viK/TkhDCAcC2uXf/AC5ux8O/nbPdI4TQK8ZYSJgwJK+9tB1rkjrUxJyHwSxgRXqFdEqBg064kaFjPt3Ys3juncybdgH+0C2pc/A6WOqefHIJAwf+d8HjzzxzDLfccnxje9y421i0aHUSpUnaBcXOgLiFjrkqpx5AAIPYfuvFEGBFCKGF4Tt5NWf8ohjjyJz3/pY3dgQwr4BjjsjZbgDmF1OQVCo+w0EcyKDG9r28lGI1nU3gwI/ewNADT2vsWTLvLuZNOx9/6JbUOXgdlKS0pL0GRGji1Rm8kNceV+B+ueMWttN6FNIuOZxh/BcfZTT9Chp/DuO4mZMb22+xjhvZ1QfLqFBjjv8Rux98RmN7yby7mfuH8/CHbkmdhddBSUpPW9aASCIk2HbFL6UAYjOwrIjxXdnx8ZoryMxSAFieN3YmmQUke2TbEyls1seEnO3pRdRWlr6TfeV7J2f7UZpexfOzgGsdd4yuVHMh7+ZC3s1z/IPpLGQOb/IP1rKGTXSlmt3oyVh24xT2Z6+coGITWziL37ES783sCIP3O4VhYz/X2I6xgdoegzjs0/cUfIyXHvkma9/Oz1Al+ZlVHrwOSlK6ig0g6tr5638U+B6wDyUWO8cYnwAGFDo+hHAW8LOcrnExxoXNHHtDCOF+YNuSy6eGEL4YY2x2pZ0QwgfYviAmwG8Kra1cbQE2tTImNjNmc/uXowIcyhAO3WmpkqbVs5rP83seYkHCVWmbLjU7XsJDqGLAqKOLOsYrT13bniVJFcPPrPLgdVCS0lXULRgxxk3t8QIOBu4HfgXsTeYzOWT/vLO9/5Il6uac7T7Al1sZ/62c7deAh9u9IqkNXuRtvs9jzGIJWxon/bQ8/us8zP78xPBBkiRJ6kQ69DGcIYS9ycx4OGVbV87bDwL/FmN8viNrSkuM8X9DCDPI3H4BcGkI4bkY4x/zx4YQvgt8OKfr0hjjO/njKs1l2ZdK29us4xL+j0v4P+qo4SAGMZp+DKYHPajlHbayio28zmpm8wb/8OmxqVky9w6WzL0j7TKkinQZfmaVA6+DlevWW1/g1lu9NUYqdR0SQIQQBpP5XP589mvmBg8zyQQPf+qIWkrMecBTQD+gFrg3hHAX8Dsy60+MAj4HfDBnn3uB2zq2TKkwG9jMMyzmGRanXYokSZKkEpNoABFC6AX8G/AloDvbb7MAeBn4Zozxl0nWUMpijPNDCCcDvycTQnQBzsi+mvIIcFqMsfV57pIkSZIklZBEHsMZQqgJIfw/YAHwDbY/7QHgLeAi4IDOHD5sE2N8HBgD3EXz61fVA18BjmlpoUpJkiRJkkpVu8+ACCGcAVwBjGDHGQ9rgR8CP4wxrmvvr5u2GOMtwC1t3PcN4DMhhD7AkcAwoBfwJvAS8FSMsaSeEiJJkiRJUjHaLYAIIRwHfJ/MEy5yg4ctwI3AFTHGpe319SpRjHEVmdsxJEmSJEmqKLscQIQQ3g1cxfanOeS6G/j3GOOru/p1JEmSJElS+WpzABFC2IvMIzVP3daV8/ZDZJ5sMbvtpUmSJEmSpEpRdACRfaTmt4Cz2fmRmrPIBA+PtE95kiRJkiSpEhQVQIQQrgC+zPZHam6zgMwjNX/RjrVJkiRJkqQKUewMiG+SWVxy2yKTbwHfBm6MMW5t59okSZIkSVKFaOsaENuecNGVTCjxzRBCC8OLO3aMcff2OpgkSZIkSUrfrj4Fo0/21W7pA9vDDUmSJEmSVCHaEkC0Z9ggSZIkSZI6gWIDiMsTqUKSJEmSJFW0ogKIGKMBhCRJkiRJKlpV2gVIkiRJkqTKZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISZwAhSZIkSZISV512AZIkSZIkJalnVRWH19alXUaedWkX0OGcASFJkiRJkhLnDAhJkiRJkkpUCCEA7wU+DLwPOAAYRGZCwQrgBeAR4KcxxjfSqrMQBhCSJEmSJJWgEMJJwA3A0GaG7JZ9fQj4jxDCf8QYr+mo+oplACFJkiRJUmk6gB3DhwXAE8BrwAZgFHAiMBjoBvwghDAkxvjVji60EAYQkiRJkiSVrjXAVOBnMcZ5+W+GELoB1wPnZ7u+EkKYFmP8U8eVWBgXoZQkSZIkqTT9ERgZY/xqU+EDQIxxY4zxAuB/c7ov6pDqimQAIUmSJElSCYoxzokxLi9w+I9yto9Iop5dZQAhSZIkSVL5ezVnu39qVbTAAEKSJEmSpPK3e87226lV0QIDCEmSJEmSyt+ncrYfS62KFhhASJIkSZJUxkIIY4DP5XRNSauWlvgYzk5gFsMIfCntMlSA+79/WdolqAjHXXJZ2iWoQPGSkHYJKkaMaVegAk0KnlvlInJx2iWoQOPTLkAdaUAIYWZOe0qMsejgIITQA7gdqM12/bYUH8EJBhCSJEmSJKVhaYxxlzKnEEIVcBswNttVD5y7i3UlxlswJEmSJEkqMyGEANwIfDzbtRr4WIxxWXpVtcwAQpIkSZKk8vNj4Jzs9hrguBjjrBTraZUBhCRJkiRJZSSE8GPgC9nmWuD4GONTKZZUEAMISZIkSZLKRDZ8uCjbXAd8JMb4RIolFcxFKCVJkiRJKgMhhJ+wfebDeuCjMcbHUiypKM6AkCRJkiSpxDUTPsxIsaSiOQNCkiRJkqQSFkL4L+DCbHM9cEKMcXp6FbWNMyAkSZIkSSpRzYQPf0qxpDZzBoQkSZIkSSUohHAJ28MHgP8DDgshHFbA7r+IMb6eTGVtYwAhSZIkSVJp2ievfWL2VYiZQEkFEN6CIUmSJEmSEucMCEmSJEmSSlCM8SzgrJTLaDfOgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYkzgJAkSZIkSYmrTrsASZIkSZKStGFxA3MvWZd2GZ2eMyAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiqtMuQNoVt9/+EU4//YAd+kaOnMKiRatTqqjzqurSlb7DjqDfiAn03u0QevTfl9ruA6iqqmHzptVsXP0aKxc/yxt/vYeV9U+mXa5a4HlVWlYDfwFmATOzf74MxOz7E4HpqVQmlTfPrfLh90qqHAYQKlsnnLDnTv9IUser7T6I/Y65ioGjj6O6a68mx3StHkjXHgPpM+QwRoy/gJWL/8y8+y5k3bKXOrhatcbzqrTsC/yd7T9kS2ofnlvlw++VVFm8BUNlqW/frtx447FplyGgW+/dGXLAJ3cKHzasrmfl4mdYtnAG65bN3+G9vru/l8PPmkHfYUd0ZKlqhedV6ZmPP3RLSfDcKh9+r6TK4gwIlaXrrz+aoUN7AvDAA68yadKolCsSwIrXn2Tx3DtY+spDbFqzZIf36vqMYO+J32LImE8BUF3bk0M/cTeP3ziOzRuWpVGu8nhela5ewKHAYdnXD4HnUq1IqgyeW+XD75VUGQwgihBC6AacApwAjAN2A3oCa4E3yFwH7wN+E2PcUOSx9wP+GZgE7AH0zh7zJeBXwC9ijGva529S3o4/fhRnnjkGgGnTFvDrX8/3H0opirGBN1/6Awse/x5r3prb7LgNqxYx597Ps2ntG4x8778AUFvXnz2P+CovPXJJR5WrZnhelaY7yPygvQ8QcvqnplOOVDE8t8qH3yupsngLRoFCCB8lcwvaHcBpZG5J6wN0yf65L/BPwG3AyyGEkwo8bnUI4dvAPOAbZIKNgUBXYARwLJlr7LwQwlHt+XcqR7171zJlSmaK+OrVm5g8+eGUK9KaN59n9j2ntRg+5Jo//VtsWF3f2B6838cSqkyF8rwqXZ8h8+ESWhsoqSieW+XD75VUWQwgChBCOAO4FxiW072BzEK8/0dmMd6NOe8NBX4XQvhcAYe/GfgmmSADMre5vQg8CryeM2448GAIoVPfoH3ttUcxbFhmrYGvf/0x6uudFFJuYsNmli54qLFd12c4VdV1KVYkzytJkiR1BAOIVoQQhgM3sv2/1QbgS0D/GOO7Y4wfjjGOB/oDX2F7EBGA/w4hjG7h2F8hc9vFNo8C+8UYx8QYJ8YYhwPHANtupq8GfhVCGNFOf72ycuyxIzn77IMAeOyxem64YXa6BanN8td8aO7pGUqe55UkSZI6igFE684Huue0Pxtj/FH+Gg8xxvUxxuuAM3O6uwHnNXXQEEJ/4NKcrueAY2OMOzwuIMb4MDCBzDoTkFkb4ttt+YuUs549a5g6NTP5Y+PGLZxzzgMpV6RdUdd3e4YWG7ayeb2LUKbB80qSJEkdyQCidRNztl+MMf6mpcExxl8Cf83p+kAzQy8is3bENufHGDc1c8wF7Bg6nB5CGNlSHZXmmmuOZPjw3gBcccVTzJ+/IuWK1FZV1d0YsOcxje1V/5hFjFtTrKjz8rySJElSRzKAaN2gnO05Be6TO25AM2M+mbP9TIzx2VaOeRPbb++oAk4tsJayd/TRwzn//EMAmD37La6++pmUK9KuGDF+MjXd+ja2l8y7O71iOjHPK0mSJHU0A4jW5a7G1q3AfXLH7fQrxRDCnsCYnK5prR0wxrgceCqnq6CnbJS7Hj1quOmmSQBs2dLAOec8wNatMeWq1FY9BxzA6A9sf+Tm+hULqJ/9sxQr6pw8ryRJkpQGA4jWPZ2z/b4QQm1Lg0MIXYH35XQ92sSwQ/PaTxRYS+64sQXuU9auumoCo0Zl7lS57rpZzJr1ZsoVqa1q6vox9tQ76VKTeeJFQ8MW5k67gNiwOeXKOh/PK0mSJKXBAKJ1NwBbstuDgO+2Mv77wMDs9lrgJ02MOSCv/fcCa8kd1zuEMKzZkRVg4sQ9mDx5LAAvv7yCSy8tNKdRqamq7sahp95Nj357Nfa9PONyVtY/1cJeSoLnlSRJktJiANGKGOM84IvAtlXyvhZCuC+EMCmE0C+E0CX75/EhhPuBL2fHrQE+GWN8rYnDjszZ3sr2x2y2ZlELx6kodXXV3HzzJKqqAgDnnvsgGzduaWUvlaJQVcPYU+7kXXtsnxi0aOb/8OrT16VYVefkeSVJkqQ0VaddQDmIMf5PCGEhcD2wL/CR7KspW4E/At+IMb7QzJjeOdtrYuGPAFiV1+7V3MAQwnk0PgK0b4GHLx1XXjmB0aP7AjB16hymT3893YLUJqGqmrEfv42Bo49t7Hv9uZ/xt4e+lmJVnZfnlSRJktLkDIgCxRjvB44FftfK0IeBn7QQPgD0zNneUEQZ+WObDSBijFNijONjjON3/HKlb//9+3PRRZllMpYsWcvFF89IuSK1RQhdOPjkWxi0zwmNffXP38qL938xxao6L88rSZIkpc0ZEAUIIfQEfgCcw/b/Zu8AL5B5ykUvMk+16A5MAiaFEB4FzogxNvUrxpqc7WLmP+ePrWlyVJkbNKh74xTxoUN7snJlcf9gXbjwvJztVYwaNbVd61MBQhUHnfRTdtvvY41di+fcxgt/vCi9mjo5zytJkiSlzRkQrQgh9AIeAS4gEz6sJ7POQ78Y47gY44dijO8hc5/DmcDS7K4TgMdCCLs1cdh1OduFPtqzqbHrmhwlpSlUcfCJNzHkgFMbuxbPuZ15910I+KhHSZIkqbNyBkTrfgi8O7v9DnBsjHGnZeNjjJuBn4cQnibz6M53ASOA/wZOyRu+Nme7exG15I9dU8S+ZWPz5q0sXbq+4PFdu1bTq9f2p6MuX76BhoaY3d7Y7vWpBaGKg06cypAxn2rsWjz3DubdNxnDh3R5XkmSJCltBhAtCCEMBT6X0zW1qfAhV4xxfgjh+8DV2a6PhRD2jDG+kjPs7ZztHiGEXjHGQsKEIXntpU2OKnNPPrmEgQP/u+DxZ545hltuOb6xPW7cbSxatDqJ0tSiwEEn3MjQMZ9u7Fk8907mTbsAw4f0eV5JkiQpbd6C0bKj2TGk+W2B+/0uZzsAE/Pe/1tee0SBx80d1wDML3A/KWGBAz96A0MPPK2xZ8m8u5g37XwMHyRJkiSBAURr9shrF/rMutfy2vnrQOQ/IWNcgcfNHbcwxljMEzSkxIw5/kfsfvAZje0l8+5m7h/Ow/BBkiRJ0jbegtGyTXntugL3y1+rIf/G65lkFpDskW1PBH5ewHEn5GxPL7AWKVGD9zuFYWO336kUYwO1PQZx2KfvKfgYLz3yTda+3dKTa6XO6TvZV753crYfpenVjD8L+KwSqWmeW+XD75VUWQwgWrYkr/1u4PkC9ntPXrs+txFj3BBCuB/Y9piAU0MIX4wxNrtCXAjhA8CeOV2/KaAOKXFdanbM5UKoYsCoo4s6xitPXdueJUkVYws7J+H5YjNjNrd/OVLF8NwqH36vpMriLRgtm86Oc8i/FEKoaWmHEEIAvpbT1QDMaGLozTnbfcg82rMl38rZfg14uJXxkiRJkiSVjBCj92i3JIRwL3BiTtevgLOamq0QQqgGrge+kNP96xjjJ5s59nS2L1D5DvDxGOMfmxj3XeCSnK6zYoy3Fv532CPClwodrhTd/73L0i5BRTjuksvSLkEFilycdgkqhj+blI8Q0q5AqjjjgZkxenK1sz1CiKX2L6KLYVaMcXzadXQkb8Fo3deADwJ9s+1PAu8LIdwC/BlYAfQis0DkmcDeOfsuA/61hWOfBzwF9ANqgXtDCHeReYrGMmAUmceAfjBnn3uB23bh7yNJkiRJUoczgGhFjHF+COF44B5gSLZ7d+DfW9l1MZkZDa+2cuyTgd+TCSG6AGdkX015BDgtxthQxF9BkiRJkqTUuQZEAWKMTwMHAlcDb7cy/C3gSuDAGOOzBRz7cWAMcBfNr7FTD3wFOKalhSolSZIkSSpVzoAoUIxxOfBvIYRLyAQGY4H+ZB6luY5MMPE88GKMcWuRx34D+EwIoQ9wJDCMzG0dbwIvAU9FF+uQJEmSJJUxA4giZcOFOdlXex97FZnbMSRJkiRJqijegiFJkiRJkhLnDAhJkiRJUkUbTObxhqWkMz4k3BkQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcQYQkiRJkiQpcdVpFyBJkiRJkloWQhgAHJbzGg8MzxlyVIxxegqlFcwAQpIkSZKkEhZCuAC4Ie06dpW3YEiSJEmSVNq6NdG3Btjc0YXsCmdASJIkSZJU2tYCM4BZOa/5wKvAiBTrKooBhCRJkiRJJSzGeBNwU35/CCGFatrOWzAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLifApGJ7D37kv48RcuS7sMFWDSJevSLkFFiFycdgkqUOAHaZegIsQyW9G7U4sx7QpUKM8rqRQNCCHMzGlPiTFOSa2aDmAAIUmSJElSx1saYxyfdhEdyVswJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4lyEUpIkSZJU0WYxjMCX0i4jT+d7opozICRJkiRJUuIMICRJkiRJUuIMICRJkiRJUuJcA0KSJEmSpBIXQvh1E90Dc7YvDyG8nff+L2OMv0ywrKIYQEiSJEmSVPpObeX9CU30zUuikLbyFgxJkiRJkpQ4Z0BIkiRJklTiYowh7Rp2lTMgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4gwgJEmSJElS4qrTLkBqSVWXrvQddgT9Rkyg926H0KP/vtR2H0BVVQ2bN61m4+rXWLn4Wd746z2srH8y7XI7tdXAX4BZwMzsny8DMfv+RGB6KpWpKX6/Ksftt3+E008/YIe+kSOnsGjR6pQq6rw8r6RkeG5JlcMAQiWptvsg9jvmKgaOPo7qrr2aHNO1eiBdewykz5DDGDH+AlYu/jPz7ruQdcte6uBqtS/wd7b/IKDS5vercpxwwp47hQ9Kh+eVlAzPLamyeAuGSlK33rsz5IBP7hQ+bFhdz8rFz7Bs4QzWLZu/w3t9d38vh581g77DjujIUgXMxx8Myonfr8rQt29Xbrzx2LTLUJbnlZQMzy2psjgDQiVvxetPsnjuHSx95SE2rVmyw3t1fUaw98RvMWTMpwCoru3JoZ+4m8dvHMfmDcvSKLdT6wUcChyWff0QeC7VitQSv1/l7frrj2bo0J4APPDAq0yaNCrligSeV1JSPLekylAxAUQIoTcwjsw1aXz2z72AkB0yI8Z4ZBuO2wuYABxJ5rq3L9CfzOyRlWRuQXsKuD3G+Pwu1D8e+CxwFLA7UAcsAeYBvwDuiTFuauvxy02MDbz50h9Y8Pj3WPPW3GbHbVi1iDn3fp5Na99g5Hv/BYDauv7secRXeemRSzqq3E7vDjIn3D5sP+EApqZTjlrh96v8HX/8KM48cwwA06Yt4Ne/nm8AkTLPKykZnltSZamIACKE8BKwNztel3b1mPsCVwOTgK7NDBucfb0f+FoI4Y/A+THG+iK+Tg/gWuC8Jt4enX2dDMwLIXw2xji74L9EGVvz5vPMvue0gsfPn/4tBu9/CnW9hwEweL+PGUB0oM+kXYCK4vervPXuXcuUKZlbL1av3sTkyQ/zoQ8NT7kqeV5JyfDckipLpawBkR+KtoeDgJPYOXx4lcyMh+nAwrz3PgLMzIYXrQoh1AD3smP4sBmYAzwGvJnTfyDwaAjhkMLK71xiw2aWLniosV3XZzhV1XUpViRJybj22qMYNiyzPs7Xv/4Y9fVrUq5IkiSpMJUSQGyzBngUuA44g/a5NawBeIBMADsoxrhnjPF9McajYoyjgIOBh3LGDwamhRCamzWR64fA0Tnt3wCjYoyHxBgnAEOBT5N5+hBkbn+blr0tRHny13xo7ukZklSujj12JGeffRAAjz1Wzw03zE63IEmSpCJUSgBxOrAf0CfGODHG+JUY4x1s/4d7W2wGbgH2iTEeF2O8K8b4dv6gGONc4Djg1znde9H0LRWNsrMkJud0TQM+GWNcnHPshhjjL4Hjga3Z7mHAxcX/dSpfXd8RjduxYSub17sIpaTK0bNnDVOnZm692LhxC+ec80DKFUmSJBWnItaAiDHemcAxfw/8vsCxDSGEC4CPklk8EuATwI9b2O3rbP/vvxm4IMbY5FOGYoxPhhCmsD2w+HII4coY4/pC6usMqqq7MWDPYxrbq/4xixi3trCHJJWXa645kuHDewNwxRVPMX/+ipQrkiSpnAwGvpZ2EXk63++VK2UGROpijMuAx3O69m9ubHbth5Nzun6bO/OhGT/J2e5JZlaEskaMn0xNt76N7SXz7k6vGElqZ0cfPZzzz88sATR79ltcffUzKVckSZJUPAOI9pU75793C+M+CLwrpz2ttQPHGF8kswDmNicVV1rl6jngAEZ/YPsTL9avWED97J+lWJEktZ8ePWq46aZJAGzZ0sA55zzA1q1NTpiTJEkqaQYQ7WtkzvZbLYw7NK/9RIHHzx2Xf4xOqaauH2NPvZMuNZk7XxoatjB32gXEhs0pVyZJ7eOqqyYwalQfAK67bhazZr3Zyh6SJEmlyQCinYQQ9gDek9P1ZAvDD8jZ3szOj/Nszt9ztvcJIXQpcL+KVFXdjUNPvZse/fZq7Ht5xuWsrH8qxaokqf1MnLgHkyePBeDll1dw6aWF5tWSJEmlxwCi/VzCjv89b2th7Mic7cUxxoYCv8ainO2uwJAC96s4oaqGsafcybv2eF9j36KZ/8OrT1+XYlWS1H7q6qq5+eZJVFUFAM4990E2btySclWSJEltZwDRDkIIxwDn53Q9FmO8r4VdcteHWFnEl1qV1+7VQk3nhRBmhhBmrlpXWfcKh6pqxn78NgaOPrax7/XnfsbfHiq1VW0lqe2uvHICo0f3BWDq1DlMn/56ugVJkiTtIgOIXRRC2BO4EwjZrjXA2a3s1jNne0MRXy5/bLMBRIxxSoxxfIxxfJ8eoblhZSeELhx88i0M2ueExr7652/lxfu/mGJVktS+9t+/PxddlFnqZ8mStVx88YyUK5IkSdp11WkXUM5CCAOB/wUG5HSfF2P8ezO7bFOTs13MfNr8sTVNjqpUoYqDTvopu+33scauxXNu44U/XpReTZKUgEGDujfeejF0aE9WriwuZF248Lyc7VWMGjW1XeuTJElqC2dAtFEIoS/wALBPTvfFMca7C9h9Xc52tyK+bP7YdU2OqkShioNPvIkhB5za2LV4zu3Mu+9CoLJuMZEkSZKkSuQMiDYIIfQC7mfHR2F+M8Z4TYGHWJuz3b2IL50/dk0R+5avUMVBJ05lyJhPNXYtnnsH8+6bjOGDpEq0efNWli5dX/D4rl2r6dWrtrG9fPkGGhpidntju9cnSZLUFgYQRQoh9CRz28V7c7ovizF+t4jDvJ2zXcyTLPLHLiti3zIVOOiEGxk65tONPYvn3sm8aRdg+CCpUj355BIGDvzvgsefeeYYbrnl+Mb2uHG3sWjR6iRKkyRJajNvwShCCKEHcB/w/pzuK2KMlxd5qL/lbPfLzqgoxIic7TdijCuL/LplJnDgR29g6IGnNfYsmXcX86adj+GDJEmSJJUXA4gChRC6kwkfJuR0fzvG+K02HO6FvPahTY7a2bic7Rfb8HXLypjjf8TuB5/R2F4y727m/uE8DB8kSZIkqfx4C0YBsuHDNGBiTvd3YoyXtvGQ+c9Tmwg82koN3djxto/pbfzaZWHwfqcwbOznGtsxNlDbYxCHffqego/x0iPfZO3b+VmPkvCd7CvfOznbj9L0iqufBVyfv2P5/ZLan+eVlAzPLamyGEC0IoRQB9wLHJXT/d0Y43+09ZgxxtdCCLOAw7Jdnw0hfCfG2NKv9j8B1OW0f9PWr18OutTU7dAOoYoBo44u6hivPHVte5akFmwBNrUyJjYzZnP7l6NW+P2S2p/nlZQMzy2psngLRguysw5+B3wop/t7McZvtsPhb87Z3hv4TAt1dAW+kdP1dIyx4m/BkCRJkiRVjtDyL93LWwhhOttvm5gRYzyyiH1ryYQPx+d0fz/GeEk71VZDZh2HvbJdK4BJMcZn88ZVkwkr/jmn+8gYY/5tHM3aZ1iX+OMv1LU+UKmbdMm6tEuQKlLgB2mXoCJELk67BBWqgn+OrDghpF2BCjQemBmj37B2FsL4CDPTLiNPmBVjHJ92FR2pIm7BCCF8E2hqVkJtzvaEEEJTD0O/LcZ4bhP9/48dw4dNwLgQwv1FlHZmjPHNpt6IMW4OIXwOeBjoCrwLeDSEcDPwELAG2Bc4HzgkZ9efFBM+SJIkSZJUCioigCDz9+jaypjQzJiaZsZ3z2t3BSYVWVeL0w5ijI+HEE4Hfp79et2AL2RfTbmTTDAiSZIkSVJZcQ2IlMUYfwOMBf4IbG1m2N+Bz8YYT48xNjdGkiRJkqSSVREzIGKMlwGXlfoxW/hafwc+GkIYBEwAdiczG+IfwLwY4186og5JkiRJkpJSEQFEpYgxvgX8Ou06JEmSJElqb96CIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEmcAIUmSJEmSEleddgGSJEmSJCXqsCUw87K0q9hRSLuAjucMCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSlDgDCEmSJEmSykAIYc8QwvdCCLNDCMtDCOtDCAtCCHeGED6Sdn2tqU67AEmSJEmS1LIQwoXANUBd3lt7Zl+nhRB+B5wZY1zdweUVxABCkiRJkqQSFkK4APivnK45wP3AeuAQ4EQy/77/GPDbEMLxMcZ3OrrO1hhASJIkSZJUokIIo4H/zOn6RozxyrwxhwL/CwwGjga+Cny/w4oskGtASJIkSZJUuq4AarPbd+aHDwAxxueAf87p+noIoW8H1FYUAwhJkiRJkkpQCKEncEq2GcmEEU2KMT4IPJ1t9iZzO0ZJMYCQJEmSJKk0HQt0y27PiTG+1Mr4X+VsfzyZktrOAEKSJEmSpNI0Lmf78QLGP5azfWg717LLDCAkSZIkSSpNY3K2/17A+JdztvcIIfRu53p2iQGEJEmSJEmlabec7frWBscYVwDrcroGt3tFu8DHcHYCf188lOMu+VLaZagA93/vsrRLkCrTJWkXoGI88L0eaZegAh0Xrkm7BBUoxph2CSrU+PFpV6COMyCEMDOnPSXGOCVvTK+c7XUUZj2w7cO0V0sDO5oBhCRJkiRJHW9pjLG1xKkuZ/udAo+7MWe7e3ElJctbMCRJkiRJKk0bcrZrC9ynW872+nasZZcZQEiSJEmSVJrW5GwXeo9i7qyHNc2OSoEBhCRJkiRJpemNnO3dWxscQujDjkHFW+1e0S4wgJAkSZIkqTS9mLO9TwHj987Zro8xrmrnenaJAYQkSZIkSaXpLznb7y9g/Adztp9r51p2mQGEJEmSJEml6QG2P9XikBBCa7MgPpGz/dtkSmo7AwhJkiRJkkpQjHEt8LtsMwD/0dzYEMKHgfdlm2ty9isZBhCSJEmSJJWu/wA2Z7fPCCFcnD8ghHAI8POcrqtijCs6orhiVKddgCRJkiRJalqM8eUQwpeBn2S7rg4hnA7cD6wHDgFOBGqy788ArunwQgtgACFJkiRJUgmLMf5XCKEKuBroRiZ0OKSJoX8APhtj3NSR9RXKWzAkSZIkSSpxMcYfAwcCVwFzgJVkFqhcCPwCOCHGeFKpPXozlzMgJEmSJEkqAzHGBcDXs6+y4wwISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUOAMISZIkSZKUuOq0C5AkSZIkKVFL/gGXX552FZ2eMyAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiDCAkSZIkSVLiqtMuQNoVt9/+EU4//YAd+kaOnMKiRatTqqjzqurSlb7DjqDfiAn03u0QevTfl9ruA6iqqmHzptVsXP0aKxc/yxt/vYeV9U+mXW6n1a3PcCZe+GLR+61dNp8npoxLoCLtKq+DpcPrYGXx3JKk9mcAobJ1wgl77vSDgTpebfdB7HfMVQwcfRzVXXs1OaZr9UC69hhInyGHMWL8Baxc/Gfm3Xch65a91MHVSpXF62Bp8DpYeTy3JCkZBhAqS337duXGG49NuwwB3XrvzpADPrlT/4bV9Wxas4StmzfQrdcQevTfp/G9vru/l8PPmsGsX3yclfVPdWS5yrP8tcdp2LKh1XEbV9d3QDUqhtfB0uF1sLJ4bklScgwgVJauv/5ohg7tCcADD7zKpEmjUq5IACtef5LFc+9g6SsPsWnNkh3eq+szgr0nfoshYz4FQHVtTw79xN08fuM4Nm9Ylka5AuZOO4+Nq15Luwy1gdfB0uR1sPx5bklScipmEcoQQu8QwpEhhK+GEO4KIcwPITSEEGL2Nb2dvk5tCOHEEMJPQwhzQghvhxA2hRDqQwgzQwg/DyGcHUIYXeRxx4cQ/jN7zGUhhPUhhJdDCL8LIZwWQujaHvVXguOPH8WZZ44BYNq0Bdx1199Srqhzi7GBN1/6A0/efATP3H4si5+/dacfugE2rFrEnHs/z8I//6ixr7auP3se8dWOLFeqCF4HS4vXwcrhuSVJyaqIACKE8BKwEvgTcA3wT8DeQGjnr3MMMBe4F/gccBAwAKgFdgcOAz4L3ATMKPCYPUIINwLPAv+SPWY/oA4YDZwM3AnMDCGMbce/Tlnq3buWKVMy0yJXr97E5MkPp1yR1rz5PLPvOY01b80taPz86d9iQ850/sH7fSyhyqTK5HWw9HgdrAyeW5KUvIoIIIB9aOewIV8I4RLgwezX2mY1MBt4BPgzUNT8yRBCDZkw47yc7s3AHOAx4M2c/gOBR0MIhxRbeyW59tqjGDYss8DX17/+GPX1a1KuSMWKDZtZuuChxnZdn+FUVdelWJFUXrwOlj+vg6XJc0uSklcpAcQ2a4BHgeuAM4Dn2uOgIYSvA9/N6foLcDwwIMZ4aIzxQzHGw2OMA8jMvPgKUMhz7n4IHJ3T/g0wKsZ4SIxxAjAU+DSZoAOgFzAthND0EtsV7thjR3L22QcB8Nhj9dxww+x0C1Kb5d/r3Nyq8ZJ25HWwcngdLC2eW5LUMSplEcrTgVnA/Bhj3NYZQjh3Vw8cQngP8J2crtuBs2KMW5saH2N8mUwAcl0rx90XmJzTNQ34ZG79McYG4JchhHoywUoXYBhwMXBp8X+b8tWzZw1Tp2amRW7cuIVzznkg5Yq0K+r6jmjcjg1b2bzexdek1ngdrCxeB0uH55YkdZyKCCBijHcmcdwQQhXwUzL/8IfMOg3Nhg9F+jrb//tvBi7IDR9yxRifDCFMYXtg8eUQwpUxxvXtUEdZuOaaIxk+vDcAV1zxFPPnr0i5IrVVVXU3Bux5TGN71T9m0T6nlNpi36O+Q4/++9Kt9+50qa5j88aVbFxTz8r6p3nzpT+w4vXH0y5RWV4HK4fXwdLiuSVJHaciAogETQLG5LT/pT3Ch+zaDyfndP02xri4ld1+wvYAoieZW0B+s6u1lIOjjx7O+ednlr6YPfstrr76mZQr0q4YMX4yNd36NraXzLs7vWLEbvufskO7a8/BdO05mD5DDmPEu7/AyiXP8sJ9X2Dt0kLuKlNSvA5WFq+DpcNzS5I6VqWtAdHeLsjZfj7G+HQ7HfeDwLty2tNa2yHG+CLwak7XSe1US0nr0aOGm26aBMCWLQ2cc84DbN3a5EQRlYGeAw5g9AcuaWyvX7GA+tk/S7EivbN+GSuXPMuyV//EysXP8M76pTu833fouzn8rOkM3Ou4lCqU18HK4nWwdHhuSVLHcwZEM0IIXYAP53Td246HPzSv/USB+z0BjGrmGBXpqqsmMGpUHwCuu24Ws2a92coeKlU1df0Ye+qddKnJrPTe0LCFudMuIDZsTrmyzmfVP/7C4jm3sXTBg2xYtWin93vvNpZRh3+V3fb/OABdarpz8Mm38sxtHy74MYNqP14HK4fXwdLiuSVJHc8ZEM07COie034SIISwdwjhyhDCnBDCyhDC+hDCayGEe0MIF4YQujd9uB0ckLO9GVhYYE1/z9neJxuSVKyJE/dg8uSxALz88gouvbTQnEalpqq6G4eeejc9+u3V2PfyjMtZWf9UilV1ThtXvcbTt0zg9b9MbTJ8AFj9xmye/91n+euDX2vsq67twX7HXNNRZSrL62Dl8DpYWjy3JCkdBhDNG5vXnh9CuASYB/wbmYCiD1AH7AGcCPwX8GoI4WOtHHtkzvbi7NMuCpH7r4WuwJAC9ys7dXXV3HzzJKqqAgDnnvsgGzduSbkqtUWoqmHsKXfyrj3e19i3aOb/8OrTLT4oRiXgtVn/Q/3ztza2+w1/P7136xSTr0qC18HK4XWwtHhuSVJ6DCCaNyCvfRHwXaA2234dmAH8GViXM24QcE8I4bwWjt07Z3tlETWtyms3+9DwEMJ5IYSZIYSZsLaIL1EarrxyAqNH9wVg6tQ5TJ/+eroFqU1CVTVjP34bA0cf29j3+nM/428Pfa2FvVRKXnnyBzu0c1fuV7K8DlYGr4Olx3NLktJjANG8vnntL2f/nAd8IMY4PMZ4ZIzxcKB/9v13smMC8JMQwnuaOXbPnO0NRdSUP7bZACLGOCXGOD7GOH7HL1f69t+/PxddlPkt65Ila7n44hkpV6S2CKELB598C4P2OaGxr/75W3nx/i+mWJWKtWHlQjas3D75qkf/fVKspvPwOlgZvA6WHs8tSUqXi1A2r1sTfX8HPhhjXJnbGWPcBFwfQngV+F22uwb4PvChJo5Tk7NdzJy//LE1TY4qc4MGdW+cFjl0aE9WrizuB7WFC8/L2V7FqFFT27U+FSBUcdBJP2W3/T7W2LV4zm288MeL0qtJbbZp3RvU9R0BQG33/ilX0zl4HawAXgdLkueWJKXLGRDNW9dE35fyw4dcMcbfA/fkdB0dQhjdyrGbCjqakz+2qRqldIUqDj7xJoYccGpj1+I5tzPvvgsBH29WjrpUb19bd+vmjSlWIpUJr4OSJDXJGRDNW5PXfgu4v4D9fgacktM+CliQNyZ3UYZCnprR3Nj8GivC5s1bWbp0fcHju3atplev2sb28uUbaGiI2W3/sdShQhUHnTiVIWM+1di1eO4dzLtvMv7QXZ5Cl1rq3rVnY3vTOh9T1xG8DpYxr4MlzXNLktJlANG8t/Paf4kxFvKTw6y8dlMzIHKPXcyTLPLHLiti37Lx5JNLGDjwvwsef+aZY7jlluMb2+PG3caiRauTKE0tChx0wo0MHfPpxp7Fc+9k3rQL8Ifu8jV435Opru3R2F5Z/2SK1XQeXgfLldfBUue5JUnp8haM5r2Y115e4H5L89r9mhjzt9z3QwjNLiaZZ0TO9hst3Q4idazAgR+9gaEHntbYs2TeXcybdj7+0F2+arsPZJ8jL29sb3lnLUtfeTjFiqRS5nVQkqTWGEA070V2/Imha4H75a/T0NRTLl7Iax9a4LHH5WznByRSasYc/yN2P/iMxvaSeXcz9w/n4Q/dpaXP7u/hgEn/Sfd+e7c6tufAMbz7M3+krs/wxr6Fz/yYzRsKzWKlzsXroCRJrfMWjGbEGNeFEP4MHJ7t2rOl8Tnyb7l4o4kx+c98mgg82tJBQwjdgPfmdE0vsB4pUYP3O4VhYz/X2I6xgdoegzjs0/e0sNeOXnrkm6x9Oz+XU3ur6tKVPcadzR7jzmb1m3NYvmgGa96axzvr3mTLprV0qe1B93eNZsCeH2Lg6OMIVV0a91366v/xyhNXp1i9VLq8DkqSVBgDiJb9mu0BxMEhhCExxn+0ss9xee2dbpiOMb4WQpgFHJbt+mwI4TutrDHxCaAup/2bVuqQOkSXmrod2iFUMWDU0UUd45Wnrm3PklSA3oMPpvfggwsau3jO7fz1wa8QGzYnXJVUnrwOSpJUGG/B+P/t3Xm0LFV96PHvT+6FyyQzDhi5OIBBNDigeU4gRkCNI+haij4uooJxisYIKkaCEcWIsp74VJyCBIwDiAPOEkAiEBBFr/gAUQSZZy7IcLn83h9VJ6e6bvfp7nOqTnef8/2sVYuq3bt27ds/6nT3r6r2ntkJTE91uQ7w7pkqR8SmQHVC6WuAs3tU/3xl/dHAq2Zod73asc/JTB/BkDSUu269nKtXfpk7b/5d37r3r1nN9Zd8h/NOfAErTz2INasHHzVekiRJ6sY7IGaQmddGxL8Ch5VFb46IlZl5bL1uRGwEfA14aKX4iMzsdcnwc8A7gEeV25+IiEsy87xau0uAY4EdK8WHDP2PWcCOO+43HHect62OytW/PoGrf33CqLuhAdx9+5X8+tuvB2Dp+luw8dY7se4GW7J0/c1ZumxT1tx3N/fdfSt33nwZt197Afff5xRzk8K/g6Pl38GFy3NLkpq1IBIQEXEocGiXl9atrD8rIrp9mz4+M18/Q/NHAs8Fng4E8JmIeAVwInAZxaCTuwAHAdtU9jsV6DnPU2aujoj9gR9TDHC5GXBmRHwe+BGwCtgBOBD4q8qux2RmfQwJSRrK6rtu4uY/+qdEkiQtDk966JM4//3nj7obHeKwGHUX5t2CSEBQ/Dv6zVIRPeosnWmnzLw7Il4IfJfp8SCeUy69nAK8JjPv79P2WRGxL/AlYAOKZMabyqWbE4G/n6lNSZIkSZLGkWNADCAzbwGeAfwDcOUMVS8G9gNelpl3DNj2ScDOFAmONT2qXUqR0Ng3M3vVkSRJkiRpbC2IOyAy8zCmx2lo6xhrgI9FxMcpHrl4DPBgiqTB9cC5mXnJLNu+FHhBRGwNPIviUY5lFINYrszMCxr4J0iSJEmSNDILIgExn8qpMv+7XJpu+3qKqT8lSZIkSVpQfARDkiRJkiS1zgSEJEmSJElqnQkISZIkSZLUOhMQkiRJkiSpdSYgJEmSJElS60xASJIkSZKk1pmAkCRJkiRJrTMBIUmSJEmSWmcCQpIkSZIktc4EhCRJkiRJap0JCEmSJEmS1DoTEJIkSZIkqXUmICRJkiRJUutMQEiSJEmSpNaZgJAkSZIkSa0zASFJkiRJklpnAkKSJEmSJLXOBIQkSZIkSWqdCQhJkiRJktQ6ExCSJEmSJKl1JiAkSZIkSVLrTEBIkiRJkqTWmYCQJEmSJEmtMwEhSZIkSZJaZwJCkiRJkiS1zgSEJEmSJElqnQkISZIkSZLUuiWj7oAkSZIkSRq9iHgo8KRyeXL53wdXqmyXmZfPtn0TEJIkSZIkLXIR8WHg4DaP4SMYkiRJkiRpWZeym5s8gHdASJIkSZKkW4AfAT+fWjLzDxGRTR3ABIQkSZIkSYtcZv5z28fwEQxJkiRJktQ6ExCSJEmSJKl1JiAkSZIkSVLrTEBIkiRJkqTWmYCQJEmSJEmti8zGZtTQmIqIG4A/jrofDdsSuHHUndDAjNfkMFaTxXhNDmM1OYzVZFmI8do2M7cadScWmoj4PsX/L+NkGXB3ZfvYzDx2VJ3ppTYN53aZefms2zIBoUkUEedn5pNH3Q8NxnhNDmM1WYzX5DBWk8NYTRbjpcUgIj4EvLTBJt+fmV8Z4viNJSCWzHZHSZIkSZLUuocAOzTY3mYNtjUUx4CQJEmSJEmt8w4ITaqxezZKMzJek8NYTRbjNTmM1eQwVpPFeGnBy8wVwIoRd6MRjgEhSZIkSZK6anIMCB/BkCRJkiRJrTMBIUmSJEmSWmcCQpIkSZIktc5BKDXWImIZ8HTg2cATgb8EtgKWArcBfwTOAb6amT8dVT8Xqoh4IMX7/iTgyeV/HwVEWeWMzNxtjsd4DPC/gT2BvwAeCFwLXAx8DfhKZq6ayzEWg/k4V4zV/IiIE4BX1YqHet7SWDWrPL9eBvwtxfn1YGAj4A6K9/UXwKnASZl515BtG6sZtPU5FBEbA88CdgOeQDG93RYUF+duBX4HnA38e2ZeOIf+Pxl4DcXf5m2A9YGrgZXAV4CTM/Oe2bY/TubjO0N5nHUpzpeXlsd5CMV5cwPFuXMRcAZwemZeNkS7iyZW0ig5CKXGUkQ8CDia4sveRgPudg7w2sz8bVv9Wkwi4mLg0Ux/cehm1l8mImIJ8H7g3cA6M1S9AliRmf85m+MsdPNxrhir+RMRLwS+1eWlgRIQxqp5EfEC4NPAwwaofjXwxszsFsN6u8aqjzY+hyJiB+AjFD9g1xtwt+8CB2bmn4Y4zobAx4A39Km6EnhNZv5y0LbHUdvfGSrHeS5wDLD9ANWvysy+5+1ii5U0k4jYCvhUl5f2rqx/D/hz7fVjMvP0gY5hAkLjqMxCn9flpT8BV1H8T78Na38A3QnslZlntdvDha822m0vc0lAHEdx1W9KAr8FbgS2o7gSOOU+4AWZ+cPZHGshm49zxVjNj4jYDPgNxdW8ukETEMaqQRHxauA4Oh9ZvYsiTrcBmwKPBZZVXk/ggMz8Yp+2jVUfbXwORcQ+FHeW1P2B4ur5PcDycqm6Dtg1My8e4BhLge8Du1eKV1PE9zaKv8cPqry2CnjmXO60GLW2vzOUx3gP8MFa8e3A74GbgQ0p7rjYonytbwJiMcZKmklELKf4ezis/TPz3waqmZkuLmO3UNxSl+VyFvA64GFd6m0HnFipm8BNwJaj/jdM+lJ5P2+nuJXxY8C+wAWV106fZdvvqMXsDGD7Wp2/ofgBPVXnNmDbUb8v47a0fa4Yq3mN5XGV9/AHtfd9+QD7G6tm4/FwikTd1Hv1Z+CtwPq1ehsAb6dITEzVvQt4pLGacwwa/xwC9in3W0Pxw/OVwFZd6j0O+GEtTpcC6w1wjP9T2+/rwDaV1x8AvKKM6VSdK4GNR/2ej1Osau0fUntPfw7sBSztUvdR5Tn5Q2Pl4jLcQpF8zVksKwY+xqj/kS4u3RaKZwi/Aew8YP2jaifBUaP+N0z6QvEM+g6Ud0pVyk+fy5cJiisTt1bauKDXFzrgkRRXG6bqfmnU78u4LW2eK8ZqXuP4/Mp79x1gRS1Oy/vsb6yaj8kHazHYu0/9V9TqH2ms5hyDxj+HgBcDX2SGBFGl7gMo7paoxvUtffbZgeIK+lT9b9f7X6n7NIq7W6bqHj7q93ycYlVp4ym19+l4YJ0G+rwoY+XiMurFWTA0ljLzgsx8aQ7+nN27KW45n7JP871aXDLzxMy8ODOz4abfDGxS2T4wewzqlMXgUR+oFO1b3hqmUsvnirGaBxGxCXBsubkKeOMsmjFWzdu1sn5RZp40U+XM/CrFbdtTntGjqrEaUBufQ5n5zczcPwcYnDAz7wcOorijZUq/7xeHMD3I+2rgoF79z8yfMX3uA7w9Ijbo169x1NZ3hoh4APAFpsdJOY/iSuuaBppflLGSRs0EhBaEzLyXYkCUKQ/3g2Fsvbyy/t+Z2W38gqrPAXeX6w+gcxAcDWnIc8VYzY+PUYzTAXBIZl45izaMVfO2rqz/asB9qvW27FHHWE2QzLyJ4vG2KX/Zq245nsCLK0XfyMyr+hzimMr6RsDzhu7kwrYnxTgrU97aRPLBWEmjYwJCC8lNte0HjqQX6ikiHkHnF4nv9NsnM2+mmAptyoua7tci1PdcMVbzIyL2BF5bbp5F95Gn+7VhrNpRnfpyWc9anar1bqm/aKwmVvVv5kzfLZ4JbFbZHiS+F9E54Jvx7XRQZf3CzDynoXaNlTQiJiC0kCyvrN9PMZK4xssTatv/NeB+1Xo7N9OVRW15Zb3XuWKsWhYRGwOfLTfvAV43y9uXjVU7qj90nhYR685UOSLWo3hOfMqZXaoZq8m0vLJ+/Qz1mohvvY1FKyLWoRiMdUrf6W2HYKykETEBoQUhItan81a48zLzvlH1Rz3tWNu+dMD9qvUeGBF95/VWd0OcK8aqfR9leqrFw3OA6f16MFbt+BTFoHNQPI5Rn/6v7kPAVuX6HXTerj3FWE2YiPgLikEQp/xshurV+K4GLh/wMNX4bl/+8FYxE0n1EcGfAUTEoyPiwxHxq4i4NSL+HBFXRMS3IuLvBnwE11hJI2ICQgvFW+kc1Ov4UXVEM1peWV8DXD3gfn+coR0NZ9BzZXll3Vg1LCKeA7yh3LwQ+MgcmlteWTdWDcnMlcBbKN5TgHdGxKkRsWdEbB4R65T/fV5EfJ9i2j8oHt14eWZe0aXZ5ZV1YzUZ3kPn9+WZvl8sr6xfVQ5iOYhqfNcDHjLgfgvdzrXtSyLiPcBK4GCKBMUmwPoUydwXAp8E/hARL+nT9vLKurGS5tGS/lWk8RYROwGHVYouY/q2Zo2X6rOzq4YYSOq22vbGDfVnURnyXDFWLYmIjSgGFoTiR+jr5njHlrFqSWZ+OiIuB46mmLLv+eXSzRrgu8C7M/M3PeoYqwkSEc8FDqwU/TQzT51hl2p8bx3iUMa3u/pArm9mOtEHcCXwe4qxV3YCNizLtwZOjoiDMvNYujNW0oh4B4QmWkRsAXyD6YG/1lBMz3Tv6HqlGWxUWb+rZ6211ev6gT+kWZwrxqo9RzJ99e3jmXn+HNszVi3KzO8DewCn9Kn6Y+CYGZIPYKwmRjlg6IlAlEWrgAP67GZ8m7VpbXsq+bASeEZmPjwzd8vMvwa2KF+f+kwL4JiIeArdGStpRExAaGKVz7J/E3hUpfi9mXlWj100eksr68Nc8a3XXdq1lrqa5blirFoQEbsBbyw3LwP+qYFmjVVLImKjiPgURaxeUhbfC/wCOA04D/hzWb4n8IOIOKMcN6AbYzUBImIriumKq1fg35CZ/cbsML7N6jb7zKXAMzOzY9DIzLwnM48GXlEpXkoxNks3xkoaERMQmkjlaOQnA0+vFB+TmUeOqEsazJ2V9UGntetW986utbSWOZwrxqph5cBon2f6iurrM3OYK2+9GKsWlLOUnEYxDeASikTD24HNM/OJmfmczHwKxVXa/ZieTeZZwE8j4sFdmjVWYy4iNgV+AGxfKf7HzPyPAXY3vs3q9j68LTNv7bVDZn6T4jNvyu4R8cg+bRsraR6ZgNDEiYilwNeAvSrFn6UYXE/j7Y7K+iCjVPequ6qBvix4czxXjFXzPgw8olz/XGb+Z0PtGqt2HAXsUq7fC+yRmUdnZscPjsxcnZlfokjy3VIWbwv83y5tGqsxViadvk/n9IqHZuZHB2zC+Dar/j5cTxGffr5Y2352lzrGShoRExCaKBGxBPgy8KJK8ReAAzMzR9MrDeGGyvqG5Ze9QdRHmb6xay39jwbOFWPVoIjYkWIANYBrgH9ssHlj1bCIeCiwf6Xos/Vbvusy8xI6b/d+STmOQJWxGlPl4LDfA55aKT4sM/tNv1pVje8wsyPU6940xL4L2Q217QsG/Pz6eW272x0QxkoaERMQmhjlXMsnAHtXiv+N4jZmkw+T4f/VtrcdcL9qvfuBS5rpzsLU0LlirJq1NdOPXjwEuCUistfC2lfw/lB5/fLaa8aqebvTOVPYNwbc75TKegC71l43VmMoIjYETqXzUbXDM/Ofh2yqGt/Nh0gwVeN77UyPGCwyF9W2bx5wv3qCbvMudYyVNCImIDQRyh9Ux9M5uNBxwAFDzN2s0auPDv/EAfer1ru8oefmF6QGzxVjNTmMVfPqg0heOeB+V9S26+NAGKsxU47NcirF2B1TPpCZ759Fc/X4PqFrrbVV41v/0b2YXQRUk+brDbhffZyGbueLsZJGxASExl75g+pLwCsrxV8CXmvyYeKcT+eATfWrg71Uvxie3lhvFpiGzxVj1azVFLfqDrrcUdv/lspr9auAxqp599S21x9wv/rz4X+ubRurMVImH75DZxz+JTNnOzvNGbXtvvGNiGV0PvZx+iyPveCU462cWymqP9LUS/2Ri2u71DFW0oiYgNBYi4gHUNw6/qpK8fHA/iYfJk951a46gNTe5RfAniLiGXR+6Tipjb5NuqbPFWPVrMz8r8zcctAFeEutiSdWXn9irW1j1byra9u7dK21tqfUtv9U3TBW46OcnvhbdA5Q+MHMfN9s28zMK+gcf+A1ERG96pf2oTPBZXw7fb2y/viIGGS8hr1q2z+rVzBW0uiYgNDYKn9QfQF4daX434EVJh8m2ucr65tQTGs3k+ptsFcAP268RxOuxXPFWE0OY9Ws0+m89ftt5awyPZU/Xt5ZKbqfta+ygrEaufJK9inAcyrFR2TmoQ00X43vo+lMCtf7sR7w7krROZnpbf2dTmD6rqF16Hy/1lJOo1pN4F4DnN2jurGSRsAEhMZS+UXuMxRzq085AdjP5MNky8zv0fml/J8i4vnd6kbEB4G/qdbNzHvb7N+kafNcMVaTw1g1KzOvpbg1f8pOwAm97lYoZ535BJ3v68mZudZsFcZqtCJiXeBkYI9K8Ycy870NHeJzwO8q25+IiLXuoCn/nzkW2LFSfEhDfVgwynPxXytFb46IN3SrW85k8jXgoZXiIzJzdY/mjZU0AuHkARpHEfEK4CuVogR+AqwZopl3ZeavGu3YIhIRhwLdrgaty/Ro/gl0+zJ8fGa+foa2t6e4IjE1MvUaiikjT6F4xn07iinwnlnZ7VvAS01AdWr7XDFWoxERK+icCWO7zLy8zz7GqkHl+3kusGml+CqKR53OpRiXY2OKQen2o7iCOuUmYJfM/MMMbRurPtr4HIqIdwFHVoruYfhn+ffLzOt6vVg+NvNjpgdNvJviavuPgFXADsCBwF9VdjsmM+uPXk2Mlr8zLKN4P6uzlPwEOBG4jGLQyV2Ag4BtKnVOBV400zmzGGMljdqS/lWkkahfZQo6rwIN4sMN9WWxWkL/EaejR50Zb1XOzEsi4sXANym+gK9D8fjAq3vschrwysX0xXsIrZ4rxmpyGKtmle/n8yiulk89d74N0O9K+VUUiYKuyYdK28aqvzY+h+p/M9cD9hyyXzMOSpqZZ0XEvhSDAG9A8QP5TeXSzYnA3w/Zh3HT5neGuyPihcB3gb8ui59D5yM0dacAr+l3zizSWEkj5SMYkkYiM88CHktx1a8+4vyUPwHvAJ6bmfXR5DVPjNXkMFbNysxzKB6/+AhwQ5/q11Mk83bKzPMGaNtYLWCZeRKwM8WP5l53pF1K8SN538wc5q61RSczbwGeAfwDM0+LezHFHUkvy8z6bEK92jZW0jzyEQxJIxcRmwC7AQ+juKX5OoovEWenf6TGirGaHMaqWeU0t4+l+KGyBbAhxeB4NwAXAhfN9oeJsVrYImJriqlUt6G4wn4NsDIzLxhpxyZUOfbRLsBjgAdTJA2uB87NzEvm2LaxklpmAkKSJEmSJLXORzAkSZIkSVLrTEBIkiRJkqTWmYCQJEmSJEmtMwEhSZIkSZJaZwJCkiRJkiS1zgSEJEmSJElqnQkISZIkSZLUOhMQkiRJkiSpdSYgJEmSJElS60xASJIkSZKk1pmAkCSpRRFxWERkbfmXIfZfVtt3xZDHf0REvDEivh4Rv46IayLi3oi4PSL+GBGnRcSREbFHRKwz9D9QkiRpQEtG3QFJkhaht0fEJzPzmrYOEBGPBQ4D9gaiS5WlwMbAw4FnA+8CrouITwNHZeaqtvomSZIWJ++AkCRp/m0AvL+txiPibcCFwD50Jh/uBH4LnAmcDfweWF15/UFlvy6LiA3b6p8kSVqcTEBIkjQaB0TE9k03GhGfBI4Gph6nuB84DtgV2Cwzd8zMXTPzaZn5SGALirskTgKy3GcrijskJEmSGmMCQpKk+XMbcH25vgQ4osnGI+KtwN9Viq4EnpSZKzLzzMxcXd8nM1dl5smZuQ/wBOCnTfZJkiRpigkISZLmz93AByrbe0fEU5toOCJ2Bj5aKboK+F+Z+ctB28jMC4HdgaOYvhtCkiSpESYgJEmaX58BLqtsH9lQu+9j+rGJBFZk5lXDNpKZ92XmOzPztob6JUmSBJiAkCRpXpWPQRxaKdo1Ip4/lzbLsSReUin6SWb+eC5tSpIkNc0EhCRJ8+8rwM8r2x+KiLl8Jr+Yzs/0T8+hLUmSpFaYgJAkaZ5lZgIHV4oeD7x6Dk3uVm0e+Mkc2pIkSWqFCQhJkkYgM38C/KhSdHhErDfL5naprF+SmbfOumOSJEktMQEhSdLoHMz0bBPbAm8atoHy0Y0tKkVXNtAvSZKkxpmAkCRpRDLzFxTjQUx5T0RsMmQzm9L5eX7rHLslSZLUChMQkiSN1nuB1eX6FnSODTGIZbXte+bcI0mSpBaYgJAkaYQy8/fAZypFb4uIhwzRxC217WHvoJAkSZoXJiAkSRq9w4FV5foGwGGD7piZdwF3V4o2b65bkiRJzTEBIUnSiGXmDcBRlaLXRsQOQzRxWWV9p4iIZnomSZLUHBMQkiSNh6OA68r1JcARQ+x7RmX9gcCOTXVKkiSpKSYgJEkaA5l5B/CBStHLIuKpA+5+Wm37Vc30SpIkqTkmICRJGh/HAr+rbH9kwP2+DVxV2X5dRGzUWK8kSZIaYAJCkqQxkZmrgUMrRc8CXjDAfvcCH68UbQ0cPdt+RMS2EbHebPeXJEnqxgSEJEnj5avA+ZXtQceCOAa4oLJ9QES8b9iDR8ReZTvrD7uvJEnSTExASJI0RjIzgYMrRdsPuN89wN7AzZXiwyPi6xHxqH77R8TjIuIbwPdwKk9JktSCJaPugCRJ6pSZp0XED4E9htzv8ojYlWJMiOVl8d7AiyPiTOBHFGNM3AgsBR4EPBZ4PvD4ZnovSZLUnQkISZLG08HAc4EYZqfMXBkRuwCfokg+BMXn/e7l0s+NFI993D5UbyVJkvrwEQxJksZQZv4S+PIs970xM18O7AwcD1zfZ5c1wFnAQcAjMvPjmXn/bI4tSZLUSxSPmkqSpIUqIgJ4HLADsCWwGXAPcAvFIxk/z8w7R9dDSZK0GJiAkCRJkiRJrfMRDEmSJEmS1DoTEJIkSZIkqXUmICRJkiRJUutMQEiSJEmSpNaZgJAkSZIkSa0zASFJkiRJklpnAkKSJEmSJLXOBIQkSZIkSWqdCQhJkiRJktQ6ExCSJEmSJKl1JiAkSZIkSVLr/j8XLxV8FKeG/gAAAABJRU5ErkJggg==\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\"),\n",
    "            colors.to_rgba(\"red\"),colors.to_rgba(\"darkred\"),colors.to_rgba(\"darkgoldenrod\"),colors.to_rgba(\"olive\"),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: # 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)', 'Invalid (1)','Baseline - P2PS (2)','Invalid (3)',\n",
    "#                    'Merge -AllS (4)','Invalid (5)','Merge -P2PS (6)','Invalid(7)',\n",
    "#                    'Baseline - AllA (8)', 'Baseline - AllT (9)','Baseline - P2PA (10)','Baseline - P2PT (11)',\n",
    "#                    'Merge -AllA (12)','Merge - AllT (13)','Merge -P2PA (14)','Merge - P2PT (15)']\n",
    "colorbar=f.colorbar(im, ax=ax)\n",
    "tick_bar = []\n",
    "for i in range(len(configurations)):\n",
    "    tick_bar.append(0.35 + i*0.95) #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": "raw",
   "metadata": {},
   "source": [
    "[[0, (0, 0), (0, 0), (1, 1)], [0, (0, 0), (0, 0), (1, 2)], [0, (0, 0), (0, 1), (1, 1)], [0, (0, 0), (0, 1), (1, 2)], [0, (0, 1), (0, 0), (1, 1)], [0, (0, 1), (0, 0), (1, 2)], [0, (0, 1), (0, 1), (1, 1)], [0, (0, 1), (0, 1), (1, 2)], [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)]]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 100, 3, 4]\n",
      "[0, 1, 100, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a=[0,1,2,3,4]\n",
    "b=a\n",
    "count=3\n",
    "a[2]=100\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": "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
}