{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# useful to autoreload the module without restarting the kernel\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mppi import InputFiles as I, Calculators as C, Datasets as D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial for the Dataset module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataset is the class used to build, perform and post-process a set made of several calculation performed both with QuantumESPRESSO and Yambo.\n",
    "\n",
    "Here we discuss some explicit examples to describe the usage and the main features of the package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform a convergence analysis for the gs energy of Silicon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use this class to find the value of the energy cutoff that guarantees a converged result for the\n",
    "ground state energy of Silicon.\n",
    "\n",
    "We start from a given input file for Silicon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = I.PwInput(file='IO_files/si_scf.in')\n",
    "#inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we define a Calculator that will be used by the Dataset class to run the computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a QuantumESPRESSO calculator with scheduler direct\n",
      "Initialize a QuantumESPRESSO calculator with scheduler direct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'omp': 1,\n",
       " 'mpi': 2,\n",
       " 'mpi_run': 'mpirun -np',\n",
       " 'executable': 'pw.x',\n",
       " 'scheduler': 'direct',\n",
       " 'skip': False,\n",
       " 'clean_restart': True,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code1 = C.QeCalculator(mpi=2, skip = False)\n",
    "code2 = C.QeCalculator(mpi=2, skip = False)\n",
    "code1.global_options()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can define the instance of Dataset to perform the convergence procedure. Some information of the class\n",
    "can be read as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Dataset with 2 parallel tasks\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'label': 'Si_gs_convergence',\n",
       " 'run_dir': 'Si_gs_convergence',\n",
       " 'num_tasks': 2,\n",
       " 'verbose': True,\n",
       " 'spin_orbit': False}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence = D.Dataset(label='Si_gs_convergence',run_dir='Si_gs_convergence', spin_orbit = False)\n",
    "gs_convergence.global_options()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dataset inherit from Runner so it has the same structure and we can use the same methods of QeCalculator and YamboCalculator \n",
    "to access to its global options. \n",
    "\n",
    "Note that in this case we have defined a spin_orbit variable that can be used later. This variables is \n",
    "stored in the global options of the dataset.\n",
    "\n",
    "The run_dir identifies the folder in which the computations are performed. If you need to have separate run_dir for the various elements\n",
    "of the dataset you can specify a run_dir in the append_run method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to append to the Dataset all the calculation that we want to peform lately.\n",
    "\n",
    "For instance we can append some calculations in function of the cutoff energy. To show the design of the class\n",
    "we make usage of two different calculators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng_cut = 20 \n",
    "idd = {'eng_cut' : eng_cut} #id that identifies the run in the Dataset\n",
    "inp.set_prefix(D.name_from_id(idd)) #attribute the id as the prefix of the input\n",
    "inp.set_energy_cutoff(eng_cut)\n",
    "gs_convergence.append_run(id=idd,runner=code1,input=inp, variable1 = 'first_run')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The append_run method set the attribute of the object, for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'eng_cut': 20}]\n",
      "[{'calc': <mppi.Calculators.QeCalculator.QeCalculator object at 0x7f9c11e8adf0>, 'iruns': [0]}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'label': 'Si_gs_convergence',\n",
       "  'run_dir': 'Si_gs_convergence',\n",
       "  'num_tasks': 2,\n",
       "  'verbose': True,\n",
       "  'spin_orbit': False,\n",
       "  'input': {'control': {'verbosity': \"'high'\",\n",
       "    'pseudo_dir': \"'../pseudos'\",\n",
       "    'calculation': \"'scf'\",\n",
       "    'prefix': \"'eng_cut_20'\"},\n",
       "   'system': {'force_symmorphic': '.true.',\n",
       "    'occupations': \"'fixed'\",\n",
       "    'ibrav': '2',\n",
       "    'celldm(1)': '10.3',\n",
       "    'ntyp': '1',\n",
       "    'nat': '2',\n",
       "    'ecutwfc': 20},\n",
       "   'electrons': {'conv_thr': '1e-08'},\n",
       "   'ions': {},\n",
       "   'cell': {},\n",
       "   'atomic_species': {'Si': ['28.086', 'Si.pbe-mt_fhi.UPF']},\n",
       "   'atomic_positions': {'type': 'crystal',\n",
       "    'values': [['Si', [0.125, 0.125, 0.125]],\n",
       "     ['Si', [-0.125, -0.125, -0.125]]]},\n",
       "   'kpoints': {'type': 'automatic',\n",
       "    'values': ([4.0, 4.0, 4.0], [0.0, 0.0, 0.0])},\n",
       "   'cell_parameters': {},\n",
       "   'file': 'IO_files/si_scf.in'},\n",
       "  'variable1': 'first_run',\n",
       "  'name': 'eng_cut_20'}]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(gs_convergence.ids) # identify each element of the dataset\n",
    "print(gs_convergence.calculators) # list with the calculators and the associated runs\n",
    "gs_convergence.runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name of the input files is evaluated from the ids using the function name_from_id."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We add further calculations, but this time we specify also the name of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng_cut = 30 \n",
    "idd = {'eng_cut' : eng_cut} #id that identifies the run in the Dataset\n",
    "inp.set_prefix(D.name_from_id(idd)) #attribute the id as the prefix of the input\n",
    "inp.set_energy_cutoff(eng_cut)\n",
    "gs_convergence.append_run(id=idd,runner=code1,input=inp, name = 'second_run')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'eng_cut': 20}, {'eng_cut': 30}]\n",
      "[{'calc': <mppi.Calculators.QeCalculator.QeCalculator object at 0x7f9c11e8adf0>, 'iruns': [0, 1]}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'label': 'Si_gs_convergence',\n",
       " 'run_dir': 'Si_gs_convergence',\n",
       " 'num_tasks': 2,\n",
       " 'verbose': True,\n",
       " 'spin_orbit': False,\n",
       " 'input': {'control': {'verbosity': \"'high'\",\n",
       "   'pseudo_dir': \"'../pseudos'\",\n",
       "   'calculation': \"'scf'\",\n",
       "   'prefix': \"'eng_cut_30'\"},\n",
       "  'system': {'force_symmorphic': '.true.',\n",
       "   'occupations': \"'fixed'\",\n",
       "   'ibrav': '2',\n",
       "   'celldm(1)': '10.3',\n",
       "   'ntyp': '1',\n",
       "   'nat': '2',\n",
       "   'ecutwfc': 30},\n",
       "  'electrons': {'conv_thr': '1e-08'},\n",
       "  'ions': {},\n",
       "  'cell': {},\n",
       "  'atomic_species': {'Si': ['28.086', 'Si.pbe-mt_fhi.UPF']},\n",
       "  'atomic_positions': {'type': 'crystal',\n",
       "   'values': [['Si', [0.125, 0.125, 0.125]],\n",
       "    ['Si', [-0.125, -0.125, -0.125]]]},\n",
       "  'kpoints': {'type': 'automatic',\n",
       "   'values': ([4.0, 4.0, 4.0], [0.0, 0.0, 0.0])},\n",
       "  'cell_parameters': {},\n",
       "  'file': 'IO_files/si_scf.in'},\n",
       " 'name': 'second_run'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(gs_convergence.ids) \n",
    "print(gs_convergence.calculators) \n",
    "gs_convergence.runs[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the variables passed as kwargs in the append run are added to the runs members.\n",
    "\n",
    "We add further computations using also the second calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "eng_cut = 40 \n",
    "idd = 'eng_cut_%s'%eng_cut # the id can be also a string\n",
    "inp.set_prefix(D.name_from_id(idd)) \n",
    "inp.set_energy_cutoff(eng_cut)\n",
    "gs_convergence.append_run(id=idd,runner=code2,input=inp,variable3 = 'second_calculator')\n",
    "\n",
    "eng_cut = 50 \n",
    "idd = {'eng_cut' : eng_cut} \n",
    "inp.set_prefix(D.name_from_id(idd))\n",
    "inp.set_energy_cutoff(eng_cut)\n",
    "gs_convergence.append_run(id=idd,runner=code1,input=inp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'eng_cut': 20}, {'eng_cut': 30}, 'eng_cut_40', {'eng_cut': 50}]\n",
      "[{'calc': <mppi.Calculators.QeCalculator.QeCalculator object at 0x7f9c11e8adf0>, 'iruns': [0, 1, 3]}, {'calc': <mppi.Calculators.QeCalculator.QeCalculator object at 0x7f9c11e8aaf0>, 'iruns': [2]}]\n"
     ]
    }
   ],
   "source": [
    "print(gs_convergence.ids) \n",
    "print(gs_convergence.calculators) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "gs_convergence.runs is a list that contains the merge of the input object and the global options for each of the\n",
    "appended run, in this way one can check which are the inputs associated to each calculator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#gs_convergence.runs[1] #give the parameters of the runs associated to the second calculator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attribute .results a dictionary that is empty before the run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once that all the computation have been added we can run the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "delete log file: Si_gs_convergence/eng_cut_20.log\n",
      "delete log file: Si_gs_convergence/second_run.log\n",
      "delete xml file: Si_gs_convergence/eng_cut_20.xml\n",
      "delete folder: Si_gs_convergence/eng_cut_20.save\n",
      "delete xml file: Si_gs_convergence/eng_cut_30.xml\n",
      "delete folder: Si_gs_convergence/eng_cut_30.save\n",
      "run command: cd Si_gs_convergence; mpirun -np 2 pw.x -inp eng_cut_20.in > eng_cut_20.log\n",
      "run command: cd Si_gs_convergence; mpirun -np 2 pw.x -inp second_run.in > second_run.log\n",
      "computation eng_cut_20 is running...\n",
      "computation second_run is running...\n",
      "computation eng_cut_20 ended\n",
      "computation second_run ended\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "delete log file: Si_gs_convergence/eng_cut_40.log\n",
      "delete log file: Si_gs_convergence/eng_cut_50.log\n",
      "delete xml file: Si_gs_convergence/eng_cut_40.xml\n",
      "delete xml file: Si_gs_convergence/eng_cut_50.xml\n",
      "delete folder: Si_gs_convergence/eng_cut_40.save\n",
      "delete folder: Si_gs_convergence/eng_cut_50.save\n",
      "run command: cd Si_gs_convergence; mpirun -np 2 pw.x -inp eng_cut_40.in > eng_cut_40.log\n",
      "run command: cd Si_gs_convergence; mpirun -np 2 pw.x -inp eng_cut_50.in > eng_cut_50.log\n",
      "computation eng_cut_40 is running...\n",
      "computation eng_cut_50 is running...\n",
      "computation eng_cut_50 ended\n",
      "computation eng_cut_40 ended\n",
      "Task [2, 3] ended \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{0: 'Si_gs_convergence/eng_cut_20.save/data-file-schema.xml',\n",
       " 1: 'Si_gs_convergence/eng_cut_30.save/data-file-schema.xml',\n",
       " 3: 'Si_gs_convergence/eng_cut_50.save/data-file-schema.xml',\n",
       " 2: 'Si_gs_convergence/eng_cut_40.save/data-file-schema.xml'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = gs_convergence.run()\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the computations are performed in parallel using the num_tasks a the maximum number of \n",
    "parallel computations. According to this value the whole dataset is spliited into task_groups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The run method returns the attribute .results of the Dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'Si_gs_convergence/eng_cut_20.save/data-file-schema.xml',\n",
       " 1: 'Si_gs_convergence/eng_cut_30.save/data-file-schema.xml',\n",
       " 3: 'Si_gs_convergence/eng_cut_50.save/data-file-schema.xml',\n",
       " 2: 'Si_gs_convergence/eng_cut_40.save/data-file-schema.xml'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This implementation allows us to parse the data after the execution of the dataset and/or to choose a parser \n",
    "among several choices. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parsing of the results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to perform the parsing of the results is _a posteriori_ from the run of the dataset.\n",
    "\n",
    "For instance we can parse the results with the PwParser class of this package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse file : Si_gs_convergence/eng_cut_20.save/data-file-schema.xml\n",
      "Parse file : Si_gs_convergence/eng_cut_30.save/data-file-schema.xml\n",
      "Parse file : Si_gs_convergence/eng_cut_50.save/data-file-schema.xml\n",
      "Parse file : Si_gs_convergence/eng_cut_40.save/data-file-schema.xml\n"
     ]
    }
   ],
   "source": [
    "from mppi import Parsers as P\n",
    "results = {}\n",
    "for run,data in gs_convergence.results.items():\n",
    "    results[run] = P.PwParser(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: <mppi.Parsers.PwParser.PwParser at 0x7f9c11bd5d60>,\n",
       " 1: <mppi.Parsers.PwParser.PwParser at 0x7f9c55105be0>,\n",
       " 3: <mppi.Parsers.PwParser.PwParser at 0x7f9c57fa81c0>,\n",
       " 2: <mppi.Parsers.PwParser.PwParser at 0x7f9c550b7fa0>}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results associate to the key \"i\" correspond to the i-th element appended to the run.\n",
    "\n",
    "The input parameters associated to each key of results are written inside the gs_convergence_runs[key] list.\n",
    "\n",
    "For instance the total energy is extracted as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run 0 energy -7.87082131330662\n",
      "run 1 energy -7.87295319773563\n",
      "run 3 energy -7.874492376332525\n",
      "run 2 energy -7.874327291710335\n"
     ]
    }
   ],
   "source": [
    "for run,res in results.items():\n",
    "    print('run',run,'energy',res.get_energy(convert_eV=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage of the post processing function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can import the post_processing_function provided in the package as\n",
    "from mppi.Datasets import PostProcessing as P\n",
    "# and access to them as, for instance, P.QE_get_energy() \n",
    "# the same function can also be accessed as D.QE_get_energy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Parsing, or other more specific procedures, can be performed directly when the run method is called.\n",
    "\n",
    "To do so, we define a post processing function and pass it to the Dataset. \n",
    "\n",
    "The class will apply this function when the run method of Dataset is called. For instance in this way we can directly \n",
    "extract the total energy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_energy(dataset): \n",
    "    from mppi import Parsers as P\n",
    "    energy = {}\n",
    "    for run,data in dataset.results.items():\n",
    "        results = P.PwParser(data,verbose=False)\n",
    "        energy[run] = results.get_energy(convert_eV = False)\n",
    "    return energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_convergence.set_postprocessing_function(extract_energy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once that the post processing function is passed to dataset it is directly applied when the run is executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "Skip the run of eng_cut_20\n",
      "Skip the run of second_run\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "Skip the run of eng_cut_40\n",
      "Skip the run of eng_cut_50\n",
      "Task [2, 3] ended \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{0: -7.87082131330662,\n",
       " 1: -7.87295319773563,\n",
       " 3: -7.874492376332525,\n",
       " 2: -7.874327291710335}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code1.update_global_options(skip=True)\n",
    "code2.update_global_options(skip=True)\n",
    "results = gs_convergence.run()\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since a post_processing_function has been provided, the run method return its value. \n",
    "Instead the .results attribute of the dataset still contains the xml output files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'Si_gs_convergence/eng_cut_20.save/data-file-schema.xml',\n",
       " 1: 'Si_gs_convergence/eng_cut_30.save/data-file-schema.xml',\n",
       " 3: 'Si_gs_convergence/eng_cut_50.save/data-file-schema.xml',\n",
       " 2: 'Si_gs_convergence/eng_cut_40.save/data-file-schema.xml'}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The post processed results can also be accessed in the class as self.post_processing(). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: -7.87082131330662,\n",
       " 1: -7.87295319773563,\n",
       " 3: -7.874492376332525,\n",
       " 2: -7.874327291710335}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.post_processing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Various post_processing_function are provided in the package, for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mppi.Datasets import PostProcessing as P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can test the function P.pw_parse_data, P.pw_get_energy, and others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "Skip the run of eng_cut_20\n",
      "Skip the run of second_run\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "Skip the run of eng_cut_40\n",
      "Skip the run of eng_cut_50\n",
      "Task [2, 3] ended \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{0: -7.87082131330662,\n",
       " 1: -7.87295319773563,\n",
       " 3: -7.874492376332525,\n",
       " 2: -7.874327291710335}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.set_postprocessing_function(P.pw_get_energy)\n",
    "results = gs_convergence.run()\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the dataset has been already computed we can simply test the effects of the various function\n",
    "as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are no empty states. Gap cannot be computed.\n",
      "There are no empty states. Gap cannot be computed.\n",
      "There are no empty states. Gap cannot be computed.\n",
      "There are no empty states. Gap cannot be computed.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 0, 0: 0, 2: 0, 3: 0}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.set_postprocessing_function(P.pw_get_gap)\n",
    "gs_convergence.post_processing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage of the fetch_results method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use fetch_results to seek for the attribute energy in the computation(s) that match the id \n",
    "passed in fetch_results.\n",
    "\n",
    "For instance we can use a generic post_processing_function that parse the data and extract the energy\n",
    "using the `attribute` argument of fetch_results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_convergence.set_postprocessing_function(P.pw_parse_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-7.874492376332525]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.fetch_results(id={'eng_cut': 50},attribute='energy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or we can use a more specific post_processing_fiunction and extract directly the energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_convergence.set_postprocessing_function(P.pw_get_energy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-7.874492376332525]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs_convergence.fetch_results(id={'eng_cut': 50})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that it is not necesary to run the dataset since the fetch_results method perform the runs that match\n",
    "with the id (if the option run_if_not_present=True is used)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage of the seek_convergence method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We present the functionality of this method by performing a second convergence test on the number of kpoints.\n",
    "\n",
    "In this example we set the energy cutoff to 60 Ry and build a new dataset appending run with increasing number of\n",
    "kpoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = I.PwInput('IO_files/si_scf.in')\n",
    "inp.set_energy_cutoff(60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a QuantumESPRESSO calculator with scheduler direct\n"
     ]
    }
   ],
   "source": [
    "code = C.QeCalculator(mpi = 2, skip=True,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Dataset with 2 parallel tasks\n"
     ]
    }
   ],
   "source": [
    "gs_kpoint = D.Dataset(label='Si_kpoints_convergence',run_dir='Si_gs_convergence',verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "kpoints = [2,3,4,5,6,7,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in kpoints:\n",
    "    id = {'kp':k}\n",
    "    inp.set_kpoints(points = [k,k,k])\n",
    "    inp.set_prefix(D.name_from_id(id))\n",
    "    gs_kpoint.append_run(id=id,runner=code,input=inp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The runs have been appended but not performed, then we call seek_convergence.\n",
    "\n",
    "We want to perform a convergence procedure based on the value of the total energy of the system.\n",
    "So we can use the post processing function that directly provides this quantity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_kpoint.set_postprocessing_function(P.pw_get_energy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seeking convergence for id \" {'kp': 2} \"\n",
      "Seeking convergence for id \" {'kp': 3} \"\n",
      "Seeking convergence for id \" {'kp': 4} \"\n",
      "Convergence reached in Dataset \"Si_kpoints_convergence\" for id \" {'kp': 4} \"\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/marco/Applications/MPPI/mppi/Datasets/Dataset.py:50: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  if id_conv is not None:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'id_conv': {'kp': 4}, 'value_conv': -7.87451395219888}"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_kpoint.seek_convergence(rtol=0.001,convergence_level=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seek_converge runs all the computation (in the order provided by append_run) until convergence is reached.\n",
    "Otherwise it is possible to pass a list of ids as argument of the method, in this case the calculation are restricted\n",
    "to the simulations associated to the provided ids."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to use a more generic post processing function that simply parse the data.\n",
    "In this case we can choose which quantity is used to check if the convergence is reached by specifying the attribute = ...\n",
    "options in the call of the seek_convergence. For instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs_kpoint.set_postprocessing_function(P.pw_parse_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seeking convergence for id \" {'kp': 2} \"\n",
      "Seeking convergence for id \" {'kp': 3} \"\n",
      "Seeking convergence for id \" {'kp': 4} \"\n",
      "Convergence reached in Dataset \"Si_kpoints_convergence\" for id \" {'kp': 4} \"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'id_conv': {'kp': 4}, 'value_conv': -7.87451395219888}"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAHECAYAAAAqBGC6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABu4UlEQVR4nO2de3xcVbmwn5U0aZMmbUou0JC2oZcJhRYjqVzKJVERBUFFvCDFI4pWUVSOyvk+QLwBHo/gAUVQKudYaVFB4OAp4ocCppSWiw0EWihNW0jb0NI2oSlJkyZtsr4/9k47DbnMmz2TNXvmfX6/+bWZvWfvdz/7nZl31l5rbWOtRVEURVEUJRXIcB2AoiiKoihKvNDCRlEURVGUlEELG0VRFEVRUgYtbBRFURRFSRm0sFEURVEUJWXQwkZRFEVRlJRBCxtFSQKMMeXGGGuMmZeAbWcYY+40xrT4+6iJ9z4G2Ge7MebSRO8nmTDGXGqMaY9x3R8YY9aOQkyNxpjvJHo/ipJMaGGTJhhjjjTG/NwYs8kY02WMecMY81djzLmuY1NGhjGm1hjzyxhWPRf4PHA+MBlYldDARsBofdEPsF9JMfJFY8wLftG2xxjzkjHmhqhV7gWmJybSEfMe4I5YV05kga0oo8UY1wEoiccYUw6sBNqAq4EX8Yra9wO/BqY6Cy4GjDHZ1tpu13GEmJnAdmttoILGGJNlrd0fp5hChTHmC8AvgH8FHgeygDnAqX3rWGs7gU4nAQ6CtXaX6xjCiDEmAzDW2h7XsSgjwFqrjxR/AI8AbwB5AywriPr/VOB/8AqgNuBBoCxq+Q+AtcBFwCZ/nYeAIn/52UA3UNhvHz8GXor6ez6wHOjw4/oVMCFqea3/3M3ALuCf/vMfBtYD+4An/TgsUC7c9h1+TM3ATn8/GVHrZPvLNwNdwGvAN6KWHwf8xT/+ncAfgKOG8F/ux3kx8JQf/6vA2QOsMy/quTOBZ/31dwC3ANn+ssX++tGP8gH23X+9Rv/5scCt/nb3Ac8Ap0e9rsZf/1zgOf+8njfI8c30ve7zz895QDtwadQ6P/GXdQKNwE+Bcf6ySwc4lkv9Zd8CXgL2+ufzLg7P2YnAEv887PPP1ZX9li/yl7f5uTGv3zFGP34wyDE+BCwd5n12KdAe43vyB8Dafu+9V4Hf4f3gvNR3eD7Q4B/bP4Dp/bbzZWCjf342Al/qt7wR+E7U3xZYCPzJd/oacEm/5dGPWv/5uXgF3dt+XC8C743xWI8F/hfY47/2aWCuvywDuA7YivdeWwN8dID3xYXA3/He168AH4h6/Vbg6/32GfFfd+JweRB97vDyfS1wAK9wPdKPvRPv8+Dz/vIfRL021m2/33/tXv9cHtMv5nPx3u+dQAuwjEPvkWzgP4Am38E/gQ/G4j8dH84D0EeCTzAcAfQC1wyzXgbwAt5linn+4xlgNd4vF/A+jNvxip8T8H6tbgbu9JdnAtuAr0Rt1+B9uP6b//dcfxvfBmYBJ/sfdPdHvabW/4D4mf+hOBvvg78L+E+gAvgEsIWoL3TBtvcAP/I//D7lf4h9JmqdP/gfIBfiXVp4L/Av/rLJeAXRf/hxneB/AD1LVHHUz225H2eTv79jgdv8D7Cj+63T96V7tP8B+Gt/P+cBbwI/85dP9M/VfwNH+Y/MAfY9Efgh3of/UUCx//zPge14xeJs4De+u8n+8ho/njV4Bev0vtcOkDdr8ArNdwOn4eXMfg4vbK7zl5XjfYBvAa73l+XgFZevRh1Ljr/sSuB9/uuq8YqcJVHbvQ2oB04CpvlxfzIq957CK0JPwivArsf7cp6M92XxTd9z337fUfz72/o1XoExfaDl/jqXMoLCxve/FS+3TdS29vsuT/PdPukfa986F/jrXIGXy1/3/z4/aj+NvLOwaQIu8X38O15RNNVf/h5/nQ/6Po7wn18DLMXL3Zn+vk+N4ThL8d4vf/bPQcTfd6W//F/983Gxv+xHQE/U8nI/nlfxirxZeMVfS9+5wiuSn+m33x8Cr8SSB1G+D+B9Xpzmx5IP/D+8Iu5UoBKvuGvDL2wE294PPOavcwLeZ+2jUfF+yN//DXg/nE4AvgPk+svvwfs8PhPvvXiFf97e5fo7JhkfzgPQR4JPsPdGssAFw6z3Af8DpTzquel4RdFZ/t8/wPvlODFqnWuBjVF//yewIurv0/3tlvl/3w38V799V/oxlvh/1xLVwuM/9+/Aun7PXcPhhU2s23663zp/B+7y/z/LX/9Dg3j6EfB4v+cm+a85aZDXlPvLr416LgPvi/KGfuv0FTY3Ahs4vCXpUrziLjfqWH4ZQw58B7+lxv97vP+h+C9Rz2XitcL1xVPjx3PhMNs+2z+/U/udc0tUYTPA677SL29+QFQLxhCv+5DvIMP/+3+B/x5k3ffhFWs5/Z6v51ChfSkxFCN4hdDT/nFtwPuS/xcgq9/5ERU2eMV3c3RuRG3LAqdFPTfNd933flzZ/9jxWuieivq7kXcWNv8e9fcYvBaASwbKw6j13gY+F8ux9XvdjXg/frIHWf4G8L1+z9Xit45FxfPlqOVH+8+d7v99gv/3jKh1NuD/mBPkgQWqopZX+M+dEvXcFP8c/GAE266IWr4AL4/7itSVwB8HcTQD73N4ar/nHwLukJ6TdHho5+HUx8S43mxgm7W2se8Ja+1reC0wx0Wtt9lauyfq721ASdTfS4HTjDHT/L8XAMuttU3+31XAJX4HzHa/4+ZKf9mMqO3U9YvvWLzm12ie7fd3rNt+qd/roo/h3XgfIv9gYKqAM/vtY+sA+xiIp/v+Y63t9eM/bpB1Z+P9Cu2Neu4pvFaGmcPsZzhm4PUR6XOD9foSPD1APKuH2dZs4A1r7Zao557Fc3gQY8wnjDFPGWPe9J3dQgx9u4wx7zPG/N0Y02SM6bs8mo3XmgDepcZPG2NeNMbcbIypjnp5FZAL7Op3vuYw/Lk6DGvtdmvtqXitgrfiva/uBJ4zxuRKthXF0Xi/4v/DWnvjAMt78S4D9sWwmcPfj7OJOoc+TzF4TvVxMP+ttQfwLveWDL464P1gucsY84Qx5lpjzLHDrN/Hu/EKrXf0kTPGTMBr0YnlGKLfs9v8f0sArLUv4bUoLfC3ezLe+b3HXy/WPDiAV5D0cSzeOTj4HrDWbo3av2TbXdba9f2OIRvvRxF4nh5nYE7Ey7dX+u3jwwjzOF3QzsOpzwa8Xwuz8S4hjQQb9f/+nUctUaPrrLXPG2NeBS42xtwMfBL4t6j1M/D6SdwywH7eiPr/3hHEGeu2hzyGGPbxF7xWkP7siHEbQbHDrxK3bY/kPByGMeYU4I94lwf+FWgFPoJ3+Wmo103Dc/0b4Ht4lx9OxLtUmA1grf2rv945eH0Y/mKM+ZO19vN452oHcMYAm397JMdirV2L19JyuzHmdGAF3uXFxSPYXDNei8pFxpi7rLW7B9rlSMIcZrk4/621PzDG3IPn+YPA940xX7HW/vcI4ouF/sdwMGZrrTXGwOExLwUuw2tRXYBXTG32l8WaB11W3lk41m0f6Les7/hi+dzJ8Nd/D+88d0nVWT1Z0BabFMda+xbwKHCFMSav/3JjTIH/33VAqT+Cqm/ZdLxfVK8Id7sU78PlQ3iXPe6PWvY8cLy1duMAj6HepK/i9fuJ5qR+f49029HU470v3jvI8ueB4/Farvrvo22YbZ/S9x/jfTKfhOd9INYBp/ijM/o4He8S0ib/7268S0hSNvmvPS0qnky8fgTSc70OONoYMyXquZM4/LPlNLxWneuttf+01m7Au6wSzUDHMg+vgPlXa+3T1toGvHw8DGtts7V2ibX2Urwvt88ZY8binasjgd4BztXOIfYbK32u3vG+ipEuvAJvN/D3qPdiHxlE5bgxZire8fflzDqizqHP6cjPYTR9LSvvcGKt3WCt/YW19sPAfwFfjGF7LwCnG2OyB9je23gtF/E4ht8DM/0i+tN4n0F9xJIHA/Eq3jmo6nvCGFPG4Tk40m335wW8wnywZQZvgEL/fbwxyGvSG9fXwvSR+AdeX5nteG/UT+JdOz4WuBzY4q9j8N5AKznUefhp3tl5eG2/bV9Kv34FeF9avXhFwn39lp2Ad03/13jNrzPxOsbeGbVOLf36jvjb7ML7lV8BfBzv164FpgXc9mLg4ai/7+VQ5+Fj8H6NfdZfVoo3+uFBvP4R04Gz8EZF5A/iv9yPcytep+cKvM67+zjU96hvncE6D3+YqM7D/jqL8C7ZlQNFDN55+bA+Nv5zt/o5ca6//UUM3Hm4aJjcygBexrt0V4lXHD1HVOdhvE6fB/CK3el4ebcL78d333Yu9s/dif6xjOVQ34lv++fhM7yzw/iPgI/h9Y2a7Z+7jVE5vQLvMsU5/jZOxWs5OsNfZ76/vQ/4+80d5Dh/xaEO0NPwitSH/XMUGey9MIS3H3Co83AO3mWIf+KP+OJQh9PnONRx9R94l2T63o8f89f5mn/8sXYe/kS/WA6uw6E+N9/D+8Ke6Md3u58T5Xh5vwa/X9owx3k0XkvbQ3gtDjP981jpL78Sr2XjMxzeefhdA70vhjmOJ/A+c/YBk6KejyUPBjx3eJ2HX/DPdyVef7w24PtBtk2/9xfe+7CHQ52Hj8dr3ezrT7cUr6/SJ/DeQ/Pw3tcfl34fpMPDeQD6GKUT7XV+vA1veGcX3i+lvxLVSRavz8NDHBru/T8MMNy733YH+0B40n/jfmSAZfP8D4y38b4Y1gA/ilpeywCdYvGKlL6hryvwhl5a4Mgg2+adhc1YvJEWb/iuNgFXRC2fhdcKtRuvKXi973awDpLlfpwL8EYy9Q2LPmeAdQYa7t3FoeHeY6OWR/CKzw4GGe7trzdQYRM93LuLwYd7D1nYRMWx3N/OBrxWiP7Dvf8dr5hpxysKL+fwwmZslFPLoaLoG/556MT78v8Uhxc21+IVVh3AW3hTG8yO2m4+XhHZhNcasRXvslh0R9Nf4V0Wsgw+3PvjeIVMX05s9/+eP9x7YZDt/YDDh3sfVtxwaIjwR32nXb7jmf228xW8Yd77iX2496CFjf/3F/EKyB6890s2XotII4c+OxYRNY3CMMd6vH9e2vE+V1YBc/xl0cO9u/Herx8b6n0xxHF8wX/+wQFiGDIPBjt3eH25luG9Z7f4620C/k+QbTPA+wvvfVPnO27G6xjfN9w7y8+Z1/x9vOkvrxrIebo/+ip/RQkdxphv4v3CK7BJnMj+5b3XgfdYa4frjKso+Lej+KW1dqSXuZQEYIwpwivsPmOtfcB1PMrAaOdhJTQYY76G94t2F17T8HXA4mQuahRFCS/GmPfhtciswRuFdSNea8r/cxmXMjTaeVgJEzPxLo+tw5sE69fAVU4jUpQBMMa8HD00t99jgev44oUx5tdDHOevXccXB7Lw+r2swbsk1QGcaa0NPFpQSRx6KUpRFCXO+EPQswZZvMMOP4IuFBhjSoAJgyx+28pGBilKXNDCRlEURVGUlEEvRSmKoiiKkjKkRefhoqIiW15enpBtd3d3k539jrmnlEFQX7Gzb98+9u/fT35+vutQQoPmlwz1JUN9yUmUs7q6umZrbfFAy9KisCkvL2f16sSMst24cSMzZwa9dU/6oL5ip6amhs7OTp59tv8tsZTB0PySob5kqC85iXJmjNk82DK9FBWQ7u533NtNGQL1JUP7wMnQ/JKhvmSoLzkunGlhE5CdO7XTvwT1JUM/SGVofslQXzLUlxwXzrSwCUhVVdXwKykHUV8ytH+NDM0vGepLhvqS48KZFjYBqaurcx1CqFBfMtraUmK6k1FD80uG+pKhvuS4cJYWnYcTSU5OjusQQoX6ip3vfve7rFu3znUYoULzS4b6kqG+5LhwpoVNQBI1jDxVUV+xc9ZZZzF37lzXYYQKzS8Z6kuG+pLjwpleigqI/qKWob5ip76+nmXLlrkOI1RofslQXzLUlxwXzrSwCYhW8DLUV+xceeWV3HXXXa7DCBWaXzLUlwz1JUdbbEKIdu6Uob5k9PT0uA4hVGh+yVBfMtSXHBfOtLAJSEtLi+sQQoX6krF//37XIYQKzS8Z6kuG+pLjwpkWNgHReQ1kqC8ZOo+NDM0vGepLhvqSo/PYhBCd10CG+pKhTd8yNL9kqC8Z6kuOC2da2IyUe+6B8nLyrroKysu9v5VhycvLcx1CaPjxj3/M17/+dddhhArNLxnqS4b6kuPCmc5jMxLuuQcWLoSODkq7u2H7du9vgAUL3MaW5JSWlroOITTMnz9fR2EI0fySob5kqC85Lpxpi81IuPZa6Ojgz7OrWXT6J73nOjq855UhaWhocB1CaFi1ahUPPvig6zBCheaXDPUlQ33JceFMC5uRsGULAH859nT+X0kVtt/zyuDMmDHDdQih4ZprruEevcQpQvNLhvqSob7kuHCmhc1ImDoVgJrXVvNmXiGbCssOe14ZHB0uKUOHe8vQ/JKhvmSoLzk63Dss3Hgj5OZS/drzANQeUwW5ud7zypC0tra6DiFUHDhwwHUIoULzS4b6kqG+5LhwpoXNSFiwABYt4ugjcpnxVhPLjz8dFi3SjsMxoPNAyNB5bGRofslQXzLUlxydxyZMLFgAjY3MPLGcZ48+no5Pftp1RKFA54GQofPYyND8kqG+ZKgvOS6c6XDvgJxaPpFHG1t45rUW3nfska7DSXoKCgpchxAabr31VtavX+86jFCh+SVDfclQX3JcONMWm4CcXjGZnKxMlq/f5TqUUFBYWOg6hNBQWVnJ/PnzXYcRKjS/ZKgvGepLjgtnWtgEpGnz65w6o5DlDVrYxMKmTZtchxAaHnvsMe677z7XYYQKzS8Z6kuG+pLjwpkWNgGJRCLUVBTT2NJBY/Ne1+EkPZFIxHUIoeGGG27ggQcecB1GqND8kqG+ZKgvOS6caWETkG3btlEdKQbQVpsY2LZtm+sQQkVXV5frEEKF5pcM9SVDfclx4UwLm4C0t7czrXA8xxSNp3b9TtfhJD3t7e2uQwgVPT09rkMIFZpfMtSXDPUlx4UzLWwC0jdGvzpSzNOvtbBvv34RDYXOAyFD57GRofklQ33JUF9ydB6bENI3Rr86Usy+/b38s/EtxxElNzoPhAydx0aG5pcM9SVDfcnReWxCSN9QtlOmF5I9JoPa9bs4Y1ax46iSFx0uGTt33nmnzmMjRPNLhvqSob7k6HDvENJ3qSAnO5OTjzlCOxAPg15aiZ2KigpOOOEE12GECs0vGepLhvqS48KZFjYBaWxsPPj/mooSNu5sp2l3h7uAkpxoX8rQLFu2jN///veuwwgVml8y1JcM9SXHhTMtbAIye/bsg//XYd/DE+1LGZqf/exnPPzww67DCBWaXzLUlwz1JceFMy1sAhJdjc4oHs/RBTnU6u0VBkV/8cjYt2+f6xBCheaXDPUlQ33J0RabENLZ2Xnw/8YYaiqKWbWxme4DvQ6jSl6ifSnD09ureSRB80uG+pKhvuS4cKaFTUD6j9GvjhSzt7uHus27HUWU3Og8EDK0s6IMzS8Z6kuG+pKj89iEkP5j9OfPLCIr01DboLMQD4TOAyFD57GRofklQ33JUF9yXDjTwiYgJSUlh/2dN3YM86YdwXLtZzMg/X0pg7NkyRJ+9rOfuQ4jVGh+yVBfMtSXHBfOtLAJSHZ29jueq6ko5tU323hzj3b87M9AvpSBmTJlCtOmTXMdRqjQ/JKhvmSoLzkunGlhE5CmpqZ3PFdd4Q37flKHfb+DgXwpA3Pvvfdy9913uw4jVGh+yVBfMtSXHBfOtLAJyJw5c97xXMWR+Rw1YZz2sxmAgXwpA/OrX/2Kxx9/3HUYoULzS4b6kqG+5LhwpoVNQBoaGt7xnDGG6kgxKzY0c6BHh+tGM5AvZXB0eKkMzS8Z6kuG+pLjwpkWNgHp6ekZ8PnqimLa9h2gfmvr6AaU5AzmSxkYa63rEEKF5pcM9SVDfclx4UwLm4DMnTt3wOdPm1lEZobRWYj7MZgvZWDGjx/vOoRQofklQ33JUF9yXDjTwiYg9fX1Az4/MSeLE6cW6H2j+jGYL2Vg2tvbXYcQKjS/ZKgvGepLjgtnY0Z9jynG5MmTB11WU1HCTY+uZ1dbF8X5Y0cxquRlKF/K4dx///1s3LjRdRihQvNLhvqSob7kuHCmLTYJpO9u3ys2aKuNIqeoqIhJkya5DkNRFCVUaGETkO3btw+67LjJEyjKy9bLUVEM5Us5nMWLF/Pb3/7WdRihQvNLhvqSob7kuHCml6ICUllZOeiyjAzDmZFi/vHqTnp6LZkZZvQCS1KG8qUczuLFizlw4IDrMEKF5pcM9SVDfclx4UxbbAKyZs2aIZdXR4rZ3bGfNW/sGaWIkpvhfCmHs3fvXtchhArNLxnqS4b6kuPCmRY2AcnMzBxy+ZmzijEGatfrLMQwvC/lcIzRVj4Jml8y1JcM9SXHhTMtbAISiUSGXD5pfDbvKtNh330M50s5nJycHNchhArNLxnqS4b6kuPCmRY2AVm7du2w61RHiqnf2sruvd2jEFFyE4sv5RB6KUqG5pcM9SVDfclx4UwLm4CUlZUNu05NRTHWwoqNzaMQUXITiy/F45FHHmHJkiWuwwgVml8y1JcM9SXHhTMtbALS3T18K8wJZQVMys1iud5eISZfikdubq5e0xei+SVDfclQX3JcONPCJiA7dw7fKTgzw3DGrGKWN+yitze9b2oYiy/F44477mDRokWuwwgVml8y1JcM9SXHhbO4FjbGmHJjjB3kcdUwr73YGFNvjOkwxrxpjFlqjDmq3zoXGmNeMcZ0+f9eEM/4R0JVVVVM61VHimlu7+KV7W8nOKLkJlZfCtx3333U1dW5DiNUaH7JUF8y1JccF87i3WKzFZjc7/FVwAL3D/YiY8xpwBLgd8DxwMeA44B7otY5FbjXf67S//dPxpiT43wMImL94jnTv71Cuo+O0i9qGW1tba5DCBWaXzLUlwz1JceFs7gWNtbaHmvtm9EP4OPAY9ba14d46alAk7X2Fmvt69baZ4DbgOii5UrgH9baG62166y1NwK1/vPOiHU4bnH+WOYcPSHt+9no8GUZGRl6tViC5pcM9SVDfclx4Syhn5rGmOnA+4HhOgqsBCYbY843HkXARcAjUeucCvyt3+seBebHK96RUF5eHvO61ZFi6rbsZk/n/sQFlORIfCkwbtw41yGECs0vGepLhvqS48JZon8OfhHYBfx5qJWstU/jFTL3AN3+awzwuajVjgJ29HvpDv95Z6xbty7mdWsqSujptaxK42HfEl8KdHR0uA4hVGh+yVBfMtSXHBfOYroJpjHmBuDaYVZ7r7W2Nuo1Y4DPA7+z1g7ZRGGMOQ7v0tP1eK0wk4GbgDuBf4klxgG2uRBYCFBaWkptbS2zZ8+msbGRzs5OqqqqqKuro6SkhOzsbJqampgzZw4NDQ309PQwd+5c6uvrmTx5MuDdobSyspI1a9aQmZlJJBJh7dq1ZGVl8corr7Bz586D28zJyaG8vJx169ZRXl5OW1sbLS0tvOvdJ5IzBu5ftY53FVoaGhqYMWMGLS0ttLa2Hnx9QUEBhYWFbNq0iUgkwrZt22hvbz+4vLCwkPz8fBobGxNyTGVlZXR3d8d0TH3L8/LyKC0tHfaYWltb2bZtW0odU6LO05133snOnTupra1NmWNK9HnKzc2lvr4+pY4pkeeptbWV5ubmlDqmRJ6n3t5eamtrU+qYEn2eOjs7D3MWr2Ma8vvf2uGHH/uXhoqGWW2Ltfbgz0t/xNKDQIW1tmGY7S8B8qy1F0Q9dzqwAphirW0yxmwBbrPW3hS1zlXAFdbaaUNtf968eXb16tXDhD8y1qxZw9y5c2Ne/6v31PH85laevvp9aXkfIKmvdEd9yVBfMtSXDPUlJ1HOjDF11tp5Ay2L6VKUtbbZWvvqMI/+beZfApYPV9T45AI9/Z7r+7svxqeBD/Rb5wPAqliOIVG0tLSI1q+OFPPm2/to2NGeoIiSG6mvdObmm2/mjjvucB1GqND8kqG+ZKgvOS6cxXQpSooxZirwQQa5jGSMuRvAWtu3fBnwG2PM5Ry6FHUr8Ly1dou/zs+BJ40x/xd4CLgAeC9weiKOIVakY/SrIyWAd7fviqPyExFSUqPzQMTOww8/TE9P/3pfGQrNLxnqS4b6kpMK89j0cRmwB3hgkOVT/QcA1trFwLeAK4C1eHPeNAAfjVpnFV4H40uBl/CKpk9ba5+Ne/QCpGP0j5o4jmOPyk/b+Wx0HggZOo+NDM0vGepLhvqS48JZQlpsrLXfB74/xPKaAZ67Da8D8VDbvZ8hJvpzQV5envg11ZFi/nvl6+ztOsD4sQk5BUnLSHylM3qvKBmaXzLUlwz1JceFM539KyClpaXi11RXFLO/x7JqU/pdrx2Jr3Rm7NixrkMIFZpfMtSXDPUlx4UzLWwC0tAQS9/ow5k37QjGZ2eyvCH9bqg2El/pSk5OjvaxEaL5JUN9yVBfclw4S6/rIAlgxowZ4tdkj8lg/swiatfvwlqbVsO+R+IrXfnrX//K1q1bXYcRKjS/ZKgvGepLjgtn2mITkJEOZauOFNO0u5PXmvfGOaLkRodLylBfMtSXDPUlQ33JceFMC5uAtLa2juh11f7dvmvT7KaYI/WVjlx//fX84he/cB1GqND8kqG+ZKgvOS6caWETkJGO0Z9yRC4zisen3bBvnQcidh5//HE2bNjgOoxQofklQ33JUF9yUmkem7QhyBj96kgJz77Wwr796dNBVOeBkKHz2MjQ/JKhvmSoLzkunGlhE5CCgoIRv7amopiuA708/Vr6XLcN4isdGTNG+/dL0PySob5kqC85LpxpYROQwsLCEb/2pGOOYFxWBsvTqJ9NEF/pSFZWlusQQoXmlwz1JUN9yXHhTAubgGzatGnErx2Xlcmp0wvTqp9NEF/pRmFhoRY2QjS/ZKgvGepLjgtn2s4dkEgkEuj11ZFi/rHsFTa37GVa4fg4RZW8BPWVTjzwwANs27bNdRihQvNLhvqSob7kuHCmLTYBCfrFU13h3e07XVpt9ItahvqSob5kqC8Z6kuOC2da2ASkvb090OuPKRrPtMLctOlnE9RXOnH11Vdzyy23uA4jVGh+yVBfMtSXHBfO9FJUQOIxRr86UsyfVjfRdaCHsWNS+27OOg9E7Dz99NN6ryghml8y1JcM9SVH57EJIfEYo19TUUzn/h7++fruOESU3Og8EDJ0HhsZml8y1JcM9SVH57EJIfEYynbK9EKyMzPS4m7fOlxSho6KkqH5JUN9yVBfcnS4dwjJz88PvI3c7DGcPP2ItLhvVDx8pROZmal9aTLeaH7JUF8y1JccF860sAlIY2NjXLZTHSlmw8523mjtjMv2kpV4+UoHysrK9INUiOaXDPUlQ33JceFMC5uAzJ49Oy7b6bvb95MpPuw7Xr7SgaVLl7J06VLXYYQKzS8Z6kuG+pLjwpkWNgGJVzU6sySPowtyqF2f2v1s9BePDPUlQ33JUF8y1JccbbEJIZ2d8bl0ZIzhzEgxKze2sL+nNy7bTEbi5SsduPLKK7nppptchxEqNL9kqC8Z6kuOC2da2AQknmP0ayqKae86QN3m1B32rfNAxE59fT07duxwHUao0PySob5kqC85Oo9NCInnGP35MwoZk2FS+vYKOg+EDJ3HRobmlwz1JUN9ydF5bEJISUlJ3LaVPy6LqmmTUnrYdzx9pQPZ2dmuQwgVml8y1JcM9SXHhTMtbAIS7y+emooS1m1/mx1v74vrdpMF/aKWYYxxHUKo0PySob5kqC85LpxpYROQpqamuG4v1Yd9x9tXKhOJRCguLnYdRqjQ/JKhvmSoLzkunOlNMAMyZ86cuG5v9uR8SvLHUtuwi0/OmxLXbScD8faVyixatIjm5mbXYYQKzS8Z6kuG+pLjwpm22ASkoaEhrtszxlAdKeapDc0cSMFh3/H2leqoLxnqS4b6kqG+5LhwpoVNQHp6euK+zZqKEvZ07ufFpta4b9s1ifCVqixcuJCf/OQnrsMIFZpfMtSXDPUlx4UzLWwCMnfu3Lhv8/SZRWQYWJ6Co6MS4StVaWho4K233nIdRqjQ/JKhvmSoLzkunGlhE5D6+vq4b3NibhbvnjqJ2hTsQJwIX6lMe3u76xBCheaXDPUlQ33JceFMC5uATJ48OSHbrYkU81LTHprbuxKyfVckyleqosNLZWh+yVBfMtSXHBfOtLBJUqorvGG+T23QUTGKoiiKEita2ARk+/btCdnunNKJFI7PTrm7fSfKVypSWVnJ1KlTXYcRKjS/ZKgvGepLjgtnOo9NQCorKxOy3YwM727fyxt20dtrychIjRloE+UrFbn11ltpbW11HUao0PySob5kqC85Lpxpi01A1qxZk7Bt11QU89bebta8sSdh+xhtEukrFVFfMtSXDPUlQ33JceFMW2wCkpmZmbBtnz6zCGNgecMu3jWlIGH7GU0S6SvVuOSSS9i1axePPvqo61BCg+aXDPUlQ33JceFMW2wCEolEErbtwryxnHD0xJTqZ5NIX6lGU1OTDvcWovklQ33JUF9yXDjTwiYga9euTej2qytKqN/aSmtHd0L3M1ok2leqsXfvXtchhArNLxnqS4b6kuPCmRY2ASkrK0vo9qsjxfRaeGpjagz7TrSvVGPs2LGuQwgVml8y1JcM9SXHhTMtbALS3Z3YlpTKKQVMzMmiNkVur5BoX6mGtdZ1CKFC80uG+pKhvuS4cKaFTUB27kxs/5fMDMMZs4pY3rArJb7kEu0rlTj11FOZNWuW6zBCheaXDPUlQ33JceHMpMKX5XDMmzfPrl69OiHbbmtrIz8/PyHb7uNPq7dy1f0v8ZdvnM7xpRMTuq9EMxq+Ugn1JUN9yVBfMtSXnEQ5M8bUWWvnDbRMW2wCUldXl/B9VEe82yssT4GbYo6Gr1RCfclQXzLUlwz1JceFMy1sApKTk5PwfZRMGMdxkyewPAX62YyGr1Thwgsv5Ic//KHrMEKF5pcM9SVDfclx4UwLm4CUl5ePyn5qKoqp27ybtn37R2V/iWK0fKUCLS0tdHWl1t3dE43mlwz1JUN9yXHhTAubgKxbt25U9lMdKeZAr2XlxpZR2V+iGC1fqUJHR4frEEKF5pcM9SVDfclx4UwLm4CMVjV64rRJ5I8dw/KGcPfK1188MsaNG+c6hFCh+SVDfclQX3K0xSaEtLW1jcp+sjIzOG1mEcvXh3vY92j5ShV6enpchxAqNL9kqC8Z6kuOC2da2ASkpWX0Lg1VVxSzbc8+NuwM7/2DRtNX2Hn/+9/P3LlzXYcRKjS/ZKgvGepLjgtnenfvgFRVVY3avg4O+16/i8iR4ZxLYTR9hZ3rrrtOfyEK0fySob5kqC85Lpxpi01ARnOMfmlBDpEj80I9n43OAyFDfclQXzLUlwz1JceFM22xCUheXt6o7q+mooTFKxvZ23WA8WPDd/pG21eYOeecc9izZw+rVq1yHUpo0PySob5kqC85Lpxpi01ASktLR3V/1ZFiunt6eea1cF7rHW1fYaazs9N1CKFD80uG+pKhvuS4cKaFTUAaGhpGdX/zyieRm50Z2rt9j7avsKPz2MjQ/JKhvmSoLzkunGlhE5AZM2aM6v7Gjslk/oxCaht2hnLY92j7Cjs6hbsMzS8Z6kuG+pLjwpkWNgFxMZStOlLM1rc6eb1576jvOyg6XFLG/v3hvoXGaKP5JUN9yVBfclw408ImIK2traO+z+pICRDOu3278BVWzjvvPN7znve4DiNUaH7JUF8y1JccF85MGC9nSJk3b55dvXp1Qrbd1tZGfv7ozynzvptrmVqYy+LPnzTq+w6CK19hRX3JUF8y1JcM9SUnUc6MMXXW2nkDLdMWm4C4mteguqKYpze1sG9/uKbc13kgZKgvGepLhvqSob7kuHCmhU1ACgoKnOy3OlJM14Fenn39LSf7HymufIWRmpoavvOd77gOI1RofslQXzLUlxwXzrSwCUhhYaGT/Z4yvZCxYzKoXR+uu3278hVWsrKyXIcQKjS/ZKgvGepLjgtnWtgEZNOmTU72Oy4rk1OmF4auA7ErX2FFJ+mTofklQ33JUF9yXDjTwiYgkUjE2b6rI8W8tmsvW98KzyRuLn2FkdzcXNchhArNLxnqS4b6kuPCmRY2Adm2bZuzfddUeHf7rg1Rq41LX2Gkq6vLdQihQvNLhvqSob7kuHCmhU1A2tvbne37mKLxTDkih+Uhur2CS19h41Of+hRnnHGG6zBCheaXDPUlQ33JceEsroWNMabcGGMHeVw1zGsvNsbUG2M6jDFvGmOWGmOOilr+JWPMCmPMbmNMqzHmH8aY0+MZ/0ioqqpytm9jDDWRElZtaqbrQDiGfbv0FTa++tWvcv3117sOI1RofslQXzLUlxwXzuLdYrMVmNzv8VXAAvcP9iJjzGnAEuB3wPHAx4DjgHuiVqsB7gXeB5wMrAceNcbMivMxiHA9r0F1pJiO7h7qGnc7jSNWXPsKEx0dHaxcudJ1GKFC80uG+pKhvuS4cDYmnhuz1vYAb0Y/Z4z5OPCYtfb1IV56KtBkrb3F//t1Y8xtwG1R217Qb7uX4xVAHwI2BI9+ZLge/nfqjEKyMzOobdjF/JlFTmOJBde+wsS5557L3r17+dCHPuQ6lNCg+SVDfclQX3JSbri3MWY68H5g0TCrrgQmG2PONx5FwEXAI0O8JhsYBzhtqnA9vfb4sWN4zzGTQtPPxrWvsJGZmek6hFCh+SVDfclQX3JcOItri80AfBHYBfx5qJWstU8bYy7Cu/SU48f1d+BzQ7zsBqAd+N+BFhpjFgILAUpLS6mtrWX27Nk0NjbS2dlJVVUVdXV1lJSUkJ2dTVNTE3PmzKGhoYGenh7mzp1LfX09kydPBmD79u1UVlayZs0aMjMziUQirF27lrfeeouOjg527tx5cJs5OTmUl5ezbt06ysvLaWtro6Wl5eDyvLw8SktLaWhoYMaMGbS0tNDa2npweUFBAYWFhWzatIlIJMK2bdtob28/uLywsJD8/HwaGxuZPXs2x4zrZOXGDja80cwbG9YGPqaysjK6u7sTcky1tbWcffbZwx5TvM9TIo8p1vMkPaaOjg727t1LbW1tyhxTos/Tnj17aG1tTaljSuR5euqppzjvvPNS6pgSeZ6effZZGhsbU+qYEn2eVq5ceZizeB3TUMR0E0xjzA3AtcOs9l5rbW3Ua8bg9blZYq39t2G2fxxeIXMr8Che35ybgHpr7b8MsP43geuBs6y1zw0XfyJvgrljxw6OPPLIhGw7Vhp2tHH2LU/yk4/P5aKTpjqNZTiSwVdYqKmpobu7m1WrVrkOJTRofslQXzLUl5xEOYvHTTBvBWYP8+hfYJwPHAXcFcP2rwaes9beZK19yVr7KF6n488aY8r6HcyVeK0158ZS1CSaxsZG1yEwqySPyRPHhWIW4mTwFSb27dvnOoRQofklQ33JUF9yXDiL6VKUtbYZaBZu+0vAcmttQwzr5gL9xyv3/X2w+DLGfAv4IfBha+1TwngSQjJMeW+MoaaimIdf3M7+nl6yMpN3eqJk8BUWLr30Ul599VXXYYQKzS8Z6kuG+pLjwllC+tgYY6YCHwTecRnJX343QNRlpmXAb/yRTn2Xom4FnrfWbvFfcxVwI3AJ0BA1x02ntXZPIo4jFpJlXoPqSDF/eG4rL2xp5aRjjnAdzqAki68wcOmll9LW1uY6jFCh+SVDfclQX3JSYR6bPi4D9gAPDLJ8qv8AwFq7GPgWcAWwFm/Omwbgo1Gv+RqQhTeXzfaox8/jG7qMZJnXYP7MIsZkmKS/23ey+AoDzc3NPPHEE67DCBWaXzLUlwz1JSf089j0Ya39PvD9IZbXDPDcYfPWDLC8PB6xxZuSkhLXIQAwYVwWJ06bxPKGXfzbh451Hc6gJIuvMPCJT3yCjo4OPvrRjw6/sgJofklRXzLUlxwXzpK3M0ZIyM7Odh3CQaojxby87W12tiVvh9Nk8hUGjDGuQwgVml8y1JcM9SXHhTMtbALS1NTkOoSD9N3t+8kGaT/v0SOZfIUBvbu3DM0vGepLhvqS48KZFjYBmTNnjusQDnLc5AkU549N6mHfyeQrDIwfP951CKFC80uG+pKhvuS4cKaFTUAaGmIZzT46GGOojhSzYsMuenqHn3jRBcnkKwzo8FIZml8y1JcM9SXHhTMtbALS09N/+h23VEeKae3Yz4tNra5DGZBk85XMXH755XzkIx9xHUao0PySob5kqC85Lpwl+l5RKc/cuXNdh3AYZ8wqIsPA8vW7OHHqJNfhvINk85XMfPrTn6a1tdV1GKFC80uG+pKhvuS4cKYtNgGpr693HcJhFORmUzmlgNok7WeTbL6Sma1bt/K3v/3NdRihQvNLhvqSob7kuHCmhU1A+u5EmkxUR0p4qamVt/YOfQdUFySjr2Tls5/9LDfffLPrMEKF5pcM9SVDfclx4UwLmxSkpqIYa2HFhuRstVEURVGURKGFTUC2b9/uOoR3MPfoiRwxPpvl65OvsElGX8lMd3fytbolM5pfMtSXDPUlx4UzLWwCUllZ6TqEd5CRYThjVhHLG3bRm2TDvpPRVzKTl5fnOoRQofklQ33JUF9yXDjTwiYga9ascR3CgNRUFNOyt5uXt73tOpTDSFZfycrevXtdhxAqNL9kqC8Z6kuOC2c63DsgmZmZrkMYkDNmebdXWN6wk7llEx1Hc4hk9ZWMfPvb32bdunWuwwgVml8y1JcM9SXHhTNtsQlIJBJxHcKAFOWN5YSyidQmWT+bZPWVjJx//vl84QtfcB1GqND8kqG+ZKgvOS6caWETkLVr17oOYVCqI8U8v2U3ezr2uw7lIMnsK9lYv349jzzyiOswQoXmlwz1JUN9yXHhTAubgJSVlbkOYVBqKorptfDUxuS523cy+0o2vvzlL3P77be7DiNUaH7JUF8y1JccF860sAlIMg/HfVdZARPGjWF5w07XoRwkmX0lI9Ym16i2ZEfzS4b6kqG+5LhwpoVNQHbuTJ6ioT9jMjM4Y1Yxyxt2Jc0XZDL7Skb0g1SG5pcM9SVDfclx4UwLm4BUVVW5DmFIqiuK2fF2F6++2eY6FCD5fSUb+fn5rkMIFZpfMtSXDPUlx4UzLWwCUldX5zqEIamO9A37To7RUcnuK9loa0uOgjQsaH7JUF8y1JccF860sAlITk6O6xCG5MgJ45g9eQK165OjCTXZfSUT3/3ud7nssstchxEqNL9kqC8Z6kuOC2c6QV9AysvLXYcwLNWRYu5a8RrtXQfIG+v2lIfBV7Jw1llnMXfuXNdhhArNLxnqS4b6kuPCmbbYBCQMM8PWVBRzoNeyMgmGfYfBV7JQX1/PsmXLXIcRKjS/ZKgvGepLjgtnWtgEJAwV/IlTJ5E3dkxS9LMJg69k4corr+Suu+5yHUao0PySob5kqC852mITQsLQuTN7TAbzZxSyfL37Yd9h8JVM9PT0uA4hVGh+yVBfMtSXHBfOtLAJSEtLi+sQYqKmooQ3WjvZtKvdaRxh8ZUs7N+fPLfDCAOaXzLUlwz1JceFMy1sAhKWeQ2qK7xh365vihkWX8mCzmMjQ/NLhvqSob7k6Dw2ISQs8xocXZDDrJI85/1swuIrWdCmbxmaXzLUlwz1JceFMx3uHZC8vDzXIcRMdaSYu5/eTEf3AXKz3Zz6MPlyzY9//GMdhSFE80uG+pKhvuS4cKYtNgEpLS11HULMVFcU093TyzOvubtOHCZfrpk/fz7nnHOO6zBCheaXDPUlQ33JceFMC5uANDQ0uA4hZt5TfgQ5WZksd9jPJky+XLNq1SoefPBB12GECs0vGepLhvqS48KZFjYBmTFjhusQYmZcVianzih02s8mTL5cc80113DPPfe4DiNUaH7JUF8y1JccF860sAlI2Ib/1VQU09jSQWPzXif7D5sv1+hwbxmaXzLUlwz1JUeHe4eQ1tZW1yGIcH2377D5cs2BAwdchxAqNL9kqC8Z6kuOC2da2AQkbPMaTCsczzFF453d7Ttsvlyj89jI0PySob5kqC85Oo9NCAnjvAbVkWKefq2FfftHf7r+MPpyic5jI0PzS4b6kqG+5LhwpoVNQAoKClyHIKY6Usy+/b089/pbo77vMPpyxa233srVV1/tOoxQofklQ33JUF9yXDjTwiYghYWFrkMQc8r0QrLHZDjpZxNGX66orKxk/vz5rsMIFZpfMtSXDPUlx4UzLWwCsmnTJtchiMnJzuTkY45wUtiE0ZcrHnvsMe677z7XYYQKzS8Z6kuG+pLjwpkWNgGJRCKuQxgRNRUlbNzZTtPujlHdb1h9ueCGG27ggQcecB1GqND8kqG+ZKgvOS6caWETkG3btrkOYUS4GvYdVl+u6Orqch1CqND8kqG+ZKgvOS6caWETkPb2dtchjIgZxeMpm5RD7SjfXiGsvlzR0zP6I9fCjOaXDPUlQ33JceFMC5uAhHVeA2MM1ZFiVm1spvtA76jtN6y+XKHz2MjQ/JKhvmSoLzk6j00ICfO8BtWRYvZ291C3efeo7TPMvlyg89jI0PySob5kqC85LpyNGfU9phhhHv43f2YRWZmG2oadnDpjdI4jzL5GmzvvvJP169e7DiNUaH7JUF8y1JccHe4dQsJ8qSBv7BjmTTuC5aPYzybMvkabiooKTjjhBNdhhArNLxnqS4b6kuPCmRY2AWlsbHQdQiBqKop59c023tyzb1T2F3Zfo8myZcv4/e9/7zqMUKH5JUN9yVBfclw408ImILNnz3YdQiCqK7xh30+O0rDvsPsaTX72s5/x8MMPuw4jVGh+yVBfMtSXHBfOtLAJSNgr+Ioj8zlqwjhqG0bnbt9h9zXa7Ns3Oi1pqYLmlwz1JUN9ydEWmxDS2dnpOoRA9A37XrGhmQM9iR/2HXZfo01v7+gNxU8FNL9kqC8Z6kuOC2da2AQkFeY1qK4opm3fAeq3tiZ8X6ngazTRzooyNL9kqC8Z6kuOzmMTQlJhXoPTZhaRmWFGZRbiVPA1mug8NjI0v2SoLxnqS47OYxNCSkpKXIcQmIk5WZw4tYDlDbv4zgcrErqvVPA1WixZsoSGhgbXYYQKzS8Z6kuG+pLjwpm22AQkOzvbdQhxoaaihDVv7GFXW2JvupgqvkaDKVOmMG3aNNdhhArNLxnqS4b6kuPCmRY2AWlqanIdQlzou9v3ig2JvRyVKr5Gg3vvvZe7777bdRihQvNLhvqSob7kuHCmhU1A5syZ4zqEuHDc5AkU5WUnvJ9NqvgaDX71q1/x+OOPuw4jVGh+yVBfMtSXHBfOtLAJSKr0gcjIMJwZKWbFhl309NqE7SdVfI0WOrxUhuaXDPUlQ33JceFMC5uA9PT0uA4hblRHitndsZ81b+xJ2D5SyddoYG3iisxURPNLhvqSob7kuHCmhU1A5s6d6zqEuHHmrGKMgdr1iZuFOJV8jQbjx493HUKo0PySob5kqC85LpxpYROQ+vp61yHEjUnjs3lXmTfsO1Gkkq/RoL293XUIoULzS4b6kqG+5LhwpvPYBGTy5MmuQ4grNRXF/PzxDeze282k8fEfppdqvhLJ/fffz8aNG12HESo0v2SoLxnqS44LZ9pioxxGdaQYa2HFxmbXoaQ9RUVFTJo0yXUYiqIooUILm4Bs377ddQhx5YSyAiblZrE8QcO+U81XIlm8eDG//e1vXYcRKjS/ZKgvGepLjgtneikqIJWVla5DiCuZGYYzZhWzvGEXvb2WjAwT1+2nmq9EsnjxYg4cOOA6jFCh+SVDfclQX3JcONMWm4CsWbPGdQhxpzpSTHN7F69sfzvu205FX4lk7969rkMIFZpfMtSXDPUlx4WzuBY2xphyY4wd5HHVMK+92BhTb4zpMMa8aYxZaow5apB1P+Nv8+F4xj8SMjMzXYcQd870b6+QiNFRqegrkRgT3xazVEfzS4b6kqG+5LhwFu8Wm63A5H6PrwIWuH+wFxljTgOWAL8Djgc+BhwH3DPAutOBm4AV8Q19ZEQiEdchxJ3i/LHMOXpCQvrZpKKvRJKTk+M6hFCh+SVDfclQX3JcOItrYWOt7bHWvhn9AD4OPGatfX2Il54KNFlrb7HWvm6tfQa4DTg5eiVjTBbwB+Ba4LV4xj5S1q5d6zqEhFAdKaZuy272dO6P63ZT1Vei0EtRMjS/ZKgvGepLjgtnCe1j47euvB9YNMyqK4HJxpjzjUcRcBHwSL/1bgQarbW/i3+0I6OsrMx1CAmhpqKEnl7LqjgP+05VX4ngkUceYcmSJa7DCBWaXzLUlwz1JceFs0SPivoisAv481ArWWufNsZchHfpKceP6+/A5/rWMcacDXwKqIxlx8aYhcBCgNLSUmpra5k9ezaNjY10dnZSVVVFXV0dJSUlZGdn09TUxJw5c2hoaKCnp4e5c+dSX19/cHKh7du3U1lZyZo1a8jMzCQSibB27Vp6e3vp7u5m586dB7eZk5NDeXk569ato7y8nLa2NlpaWg4uz8vLo7S0lIaGBmbMmEFLSwutra0HlxcUFFBYWMimTZuIRCJs27aN9vb2g8sLCwvJz8+nsbExIcdUVlbGuH1d5IyBx17eRk7L+rgd0wsvvEBubq6TYwrjedqxYwctLS0pdUyJPE8ZGRm0t7en1DEl8jy98MILFBQUpNQxJfI8bdy4kaamppQ6pkSfp5dffvkwZ/E6piGx1g77AG7A6ycz1KOm32vGANuBn8aw/eOAN4CrgBOADwIvAXf7y4uBbUB11GsWAw/HEn9VVZVNFP/4xz8Stm3XXL50tT35xsdsb29v3LaZyr7ize23326/+c1vug4jVGh+yVBfMtSXnEQ5A1bbQb7zY22xuRVYOsw6W/r9fT5wFHBXDNu/GnjOWnuT//dLxpi9wApjzDXATLyOyI9HjRLJADDGHACOt9auj2E/caeqqsrFbkeF6kgxj6x5k4Yd7VQclR+Xbaayr3hz33336d2EhWh+yVBfMtSXHBfOYupjY61ttta+Osyjo9/LvgQst9Y2xLCLXKD/J3jf3xnAP4G5eJeh+h7/izcyqhIYqmNyQqmrq3O164RTHSkB4nu371T2lQja2tpchxAqNL9kqC8Z6kuOC2cJ6TxsjJmKdznpN4Msv9sYc3fUU8uAjxpjLjfGTPeHf/8CeN5au8Vau9dauzb6AbQCbf7fw1xwSxypPBz3qInjOPao/LjOZ5PKvhJBRobOoSlB80uG+pKhvuS4cJaoT83LgD3AA4Msn+o/ALDWLga+BVwBrMWb86YB+GiC4osb5eXlrkNIKNWRYv7Z+BbtXfGZ2j/VfcWbcePGuQ4hVGh+yVBfMtSXHBfOElLYWGu/b609wlq7b5DlNdbamn7P3WatPd5am2utnWytXWCtbRpiH5daa8+Lc+hi1q1b5zqEhFJdUcz+HsvTm1risr1U9xVvOjr6X+FVhkLzS4b6kqG+5LhwpjfBDEiqV/Dzph3B+OxMljfs5APHHRl4e6nuK57U1tbS2NjoOoxQofklQ33JUF9yUqbFJp1I9c6d2WMymD+ziNr1u/qG2Qci1X3FG/UlQ33JUF8y1JccF860sAlIS0t8LtEkM9WRYpp2d/Jac/Dp/dPBV7y4+eabueOOO1yHESo0v2SoLxnqS44LZ3opKiDpMK9BtX+379r1u5hRnBdoW+ngK148/PDDOo+NEM0vGepLhvqSk7Tz2CiDkw7zGkw5IpcZxePjMuw7HXzFE236lqH5JUN9yVBfclJmHpt0Ii8vWAtGWKiOlPDsay3s2x+sBSFdfMWLzMxM1yGECs0vGepLhvqS48KZFjYBKS0tdR3CqFBTUUzXgV6efi3Y9dJ08RUvxo4d6zqEUKH5JUN9yVBfclw408ImIA0NsdwxIvycdMwRjMvKYPn6YJej0sVXPMjJydE+NkI0v2SoLxnqS44LZ9p5OCAzZsxwHcKoMC4rk1OnFwbuZ5MuvuLBX//6V7Zu3eo6jFCh+SVDfclQX3JcONMWm4Ck0/C/6kgxrzfvZXPLyId9p5OveKC+ZKgvGepLhvqS48KZFjYBaW1tdR3CqFFd4d3tO0irTTr5Csr111/PL37xC9dhhArNLxnqS4b6kuPCmRY2AUmneQ2OKRrPtMLcQP1s0slXUB5//HE2bNjgOoxQofklQ33JUF9ydB6bEJJu8xpUR4pZtamFrgMj69Sabr6CovPYyND8kqG+ZKgvOTqPTQgpKChwHcKoUlNRTOf+Hv75+u4RvT7dfAVlzBjt3y9B80uG+pKhvuS4cKaFTUAKCwtdhzCqnDK9kOzMDJY37BzR69PNV1CysrJchxAqNL9kqC8Z6kuOC2da2ARk06ZNrkMYVXKzx3Dy9COoHWE/m3TzFYTCwkItbIRofslQXzLUlxwXzrSwCUgkEnEdwqhTHSlmw8523mjtFL82HX2NlAceeIA//vGPrsMIFZpfMtSXDPUlx4UzLWwCsm3bNtchjDp9d/seyeiodPQVBPUlQ33JUF8y1JccF860sAlIe3u76xBGnZkleRxdkDOifjbp6GukXH311dxyyy2uwwgVml8y1JcM9SXHhTMdchGQdJzXwBjDmZFilr24jf09vWRlxl4fp6OvkfL000/rvaKEaH7JUF8y1JccnccmhKTrvAY1FcW0dx2gbrNs2He6+hopOo+NDM0vGepLhvqSo/PYhJB0Hf43f0YhYzKM+PYK6eprpOioKBmaXzLUlwz1JUeHe4eQ/Px81yE4IX9cFvPKJ4mHfaerr5GSmZnpOoRQofklQ33JUF9yXDjTwiYgjY2NrkNwRnWkhHXb32bH2/tifk06+5JSVlamH6RCNL9kqC8Z6kuOC2da2ARk9uzZrkNwRt+w7ycFl6PS2ZeUpUuXsnTpUtdhhArNLxnqS4b6kuPCmRY2AUnnCn725HxK8sdSKyhs0tnXSFBfMtSXDPUlQ33J0RabENLZKZ99N1UwxlAdKeapDc0c6OmN6TXp7EvKlVdeyU033eQ6jFCh+SVDfclQX3JcONPCJiDpPq9BTUUJezr382JTa0zrp7svCfX19ezYscN1GKFC80uG+pKhvuToPDYhJN3nNTh9ZhEZJvbbK6S7Lyk6j40MzS8Z6kuG+pKj89iEkJKSEtchOGVibhbvnjop5n426e5LSnZ2tusQQoXmlwz1JUN9yXHhTAubgOgXD9REinmpaQ/N7V3Drqu+ZBhjXIcQKjS/ZKgvGepLjgtnWtgEpKmpyXUIzqmu8IZ9P7Whedh11VfsRCIRiouLXYcRKjS/ZKgvGepLjgtnehPMgMyZM8d1CM6ZUzqRwvHZ1K7fycfeffTQ66qvmFm0aBHNzcMXi8ohNL9kqC8Z6kuOC2faYhOQhoYG1yE4JyPDu9v3kxua6e21Q66rvmSoLxnqS4b6kqG+5LhwpoVNQHp6elyHkBTUVBTz1t5u1ryxZ8j11FfsLFy4kJ/85CeuwwgVml8y1JcM9SXHhTMtbAIyd+5c1yEkBafPLMIYhr3bt/qKnYaGBt566y3XYYQKzS8Z6kuG+pLjwpkWNgGpr693HUJSUJg3lhOOnkjt+p1Drqe+ZLS3t7sOIVRofslQXzLUlxwXzrSwCcjkyZNdh5A0VFeUUL+1ldaO7kHXUV8ydHipDM0vGepLhvqS48KZFjZK3KiOFNNr4amNOpJHURRFcYMWNgHZvn276xCShsopBUzMyaJ2iNsrqK/YqaysZOrUqa7DCBWaXzLUlwz1JceFM53HJiCVlZWuQ0gaMjMMZ8wqYnnDLqy1A86aq75i59Zbb6W1tdV1GKFC80uG+pKhvuS4cKYtNgFZs2aN6xCSipqKEna1dfHK9rcHXK6+ZKgvGepLhvqSob7kuHCmLTYByczMdB1CUnHmrCLAG/Z9fOnEdyxXX7FzySWXsGvXLh599FHXoYQGzS8Z6kuG+pLjwpm22AQkEom4DiGpKJkwjuMmT2D5IP1s1FfsNDU16XBvIZpfMtSXDPUlx4UzLWwCsnbtWtchJB01FcXUbd5N277971imvmTs3bvXdQihQvNLhvqSob7kuHCmhU1AysrKXIeQdFRHijnQa1m5seUdy9SXjLFjx7oOIVRofslQXzLUlxwXzrSwCUh39+CT0aUrJ06bRP7YMSxveOcsxOpLhrVD31RUORzNLxnqS4b6kuPCmRY2Adm5c+hbCKQjWZkZnDaziOXrd73ji1l9xc6pp57KrFmzXIcRKjS/ZKgvGepLjgtnJh1+Ec6bN8+uXr06Idtua2sjPz8/IdsOM398bgv/98E1/O1fzyRy5CE/6kuG+pKhvmSoLxnqS06inBlj6qy18wZapi02Aamrq3MdQlJyZqQY4B2jo9SXDPUlQ33JUF8y1JccF860sAlITk6O6xCSktKCHCJH5rG84fDCRn3FzoUXXsgPf/hD12GECs0vGepLhvqS48KZFjYBKS8vdx1C0lJTUcJzr7/F3q4DB59TX7HT0tJCV1eX6zBCheaXDPUlQ33JceFMC5uArFu3znUISUt1pJjunl6eee3QsG/1JaOjo8N1CKFC80uG+pKhvuS4cKaFTUC0gh+ceeWTyM3OPOxu3+pLxrhx41yHECo0v2SoLxnqS4622ISQtrY21yEkLWPHZDJ/RiG1DTsPDvtWXzJ6enpchxAqNL9kqC8Z6kuOC2da2ASkpeWds+sqh6iOFLP1rU5eb/ZuDaC+Yuf9738/c+fOdR1GqND8kqG+ZKgvOS6c6d29A1JVVeU6hKSmOlICvMzyhl1ML85TXwKuu+46/YUoRPNLhvqSob7kuHCmLTYB0XkNhmZqYS7Ti8YfHPatvmSoLxnqS4b6kqG+5Lhwpi02AcnLy3MdQtJTXVHM75/dwr79PepLwDnnnMOePXtYtWqV61BCg+aXDPUlQ33JceFMW2wCUlpa6jqEpKc6UkzXgV6eff0t9SWgs7PTdQihQ/NLhvqSob7kuHCmhU1AGhoaXIeQ9JwyvZCxYzKoXb9TfQnReWxkaH7JUF8y1JccF860sAnIjBkzXIeQ9IzLyuSU6YUsb9ilvoToFO4yNL9kqC8Z6kuOC2da2AREh//FRnXbZl7btZdXPv05KC+He+5xHVIo2L9/v+sQQoW+H2WoLxnqS44LZ1rYBKS1tdV1CMnPPfdQ89OrAVg55QTYvBkWLtTiZhjOO+883vOe97gOI1To+1GG+pKhvuS4cGb6ZoRNZebNm2dXr16dkG23tbWRn5+fkG2nDOXl2M2bOfPLdzH17R0s/cO1GIBp06Cx0XFwyY3mlwz1JUN9yVBfchLlzBhTZ62dN9CyuLbYGGPKjTF2kMdVw7z2YmNMvTGmwxjzpjFmqTHmqH7rTDDG/MIYs80Y02WM2WiM+VQ8j0GKzmsQA1u2YIALXv4HK6e+i2+e/x06ssbCli2uI0t6NL9kqC8Z6kuG+pKTCvPYbAUm93vuAuB24P7BXmSMOQ1YAnwHeAg4ErgDuAd4v79OFvB34C3gU0ATUAZ0xfMApBQUFLjcfTiYOhU2b+bKp35PS3ERv5/9ftYXl/PrZxdzjOvYkpiamhra29tJVGtjKqLvRxnqS4b6kuPCWVxbbKy1PdbaN6MfwMeBx6y1rw/x0lOBJmvtLdba1621zwC3ASdHrfN5oBj4qLX2KWtto//vP+N5DFIKCwtd7j4c3Hgj5OaSgeUrqx/kd/d9nx15hXzkI9/n8XU7XEeX1GRlZbkOIVTo+1GG+pKhvuS4cJbQzsPGmOl4LS6Lhll1JTDZGHO+8SgCLgIeiVrnY/56t/mXql4xxvzAb8lxxqZNm1zuPhwsWACLFsG0aWyaMYMz7Vssq7RMPWoil/1uNf/5t/X09KZ+X6+RoJP0ydD3owz1JUN9yXHhLNG3VPgisAv481ArWWufNsZchHfpKceP6+/A56JWmw68D/g98GGgHO8SVx7eJSwnRCIRV7sOFwsWwIIFRLZtg9JSpgAP7O/huw+t5RdPbOTFpj38/KJKCnKzXUeaVOTm5roOIVTo+1GG+pKhvuS4cBZTYWOMuQG4dpjV3mutrY16zRi8y0e/s9YOORmHMeY4vEtP1wOP4vXTuQm4E/gXf7UMYCfwJWttD1BnjCkEbjHGXGX7De8yxiwEFoI3pXNtbS2zZ8+msbGRzs5OqqqqqKuro6SkhOzsbJqampgzZw4NDQ309PQwd+5c6uvrmTzZ6zK0fft2KisrWbNmDZmZmUQiEdauXUtnZyetra3s3Lnz4DZzcnIoLy9n3bp1lJeX09bWRktLy8HleXl5lJaW0tDQwIwZM2hpaaG1tfXg8oKCAgoLC9m0aRORSIRt27bR3t5+cHlhYSH5+fk0NjYm5JjKysro7u5OyDGtWLGCmpqag8f0vQ+eSG7nTn7/6i7OuaWWr8zN5EMnzwnVMSXqPHV0dNDZ2UltbW3KHFOiz1Pfa1PpmBJ5np577jnOPvvslDqmRJ6nF198kYkTJ6bUMSX6PK1cuZLi4uK4H9OQNUUsw739S0NFw6y2xVp7cP53Y8wFwINAhbV2yDmVjTFLgDxr7QVRz50OrACmWGubjDHLgf3W2rOi1jkDeBIosdbuGmz7iRzuXVtbS01NTUK2nYoM5uv5Lbv56tLn2d3RzY8vmMuFVWWjH1yScccdd9DQ0MCtt97qOpTQoO9HGepLhvqSkyhnQw33Ttg8NsaYR4Bca21NDOs+AFhr7SeinjsVWAVMs9ZuMcb8GLgYmG6t7fXXuQz4BV5RNOiB6Dw2ycNQvna1dfH1PzzPM6+9xWdPmcZ15x1H9pj0nkNS80uG+pKhvmSoLzmhn8cmaodTgQ8Cvxlk+d3GmLujnloGfNQYc7kxZro//PsXwPPW2r7JTn4FHAH83BhTYYz5IPBD4I6hippEo/MayBjKV3H+WJZedjJfOuMYljyzmYsWPc2be/aNYnTJRUdHBytXrnQdRqjQ96MM9SVDfclx4SxRP4cvA/YADwyyfKr/AMBauxj4FnAFsBZvzpsG4KNR62wFzgaqgHrg18B/M3zfn4Siw/9kDOdrTGYG1374OH558bt59c02zrvtKZ59LT3vz3Luuedy3XXXuQ4jVOj7UYb6kqG+5KTMcG9r7fettUdYawf8uW2trel/icpae5u19nhrba61drK1doG1tqnfOs9Ya+dba3OstcdYa79nrR26F1GC0WZJGbH6Ou+EUh762mlMGDeGi+96lv966nXS4fYf/cnMzHQdQqjQ96MM9SVDfclx4Sy9OzDEgUa915EIia/Ikfk8dMVpvP/YEq5/+BW++cd6OroPJC64JGTfvvS9FDcS9P0oQ33JUF9yXDjTwiYgs2fPdh1CqJD6mjAui19fUsVVH6xg2UvbuOD2VbzevDdB0SUfOo+NDH0/ylBfMtSXHBfOtLAJiFbwMkbiKyPD8LX3zuR3nz+JHW37+Mgvn+KxV9LjVgzaYiND348y1JcM9SVHW2xCiE55LyOIrzMjxSy74nSmFebyxbtX87MUvxXDpZdeytlnn+06jFCh70cZ6kuG+pLjwlnC5rFJJnQem+QhHr727e/huofW8qe6JqojxSl9KwbNLxnqS4b6kqG+5KTMPDbphM5rICMevsZlZfLTT5zAjRfMYdWmZs7/5VOsfWNPHKJLLpqbm3niiSdchxEq9P0oQ33JUF9yUmkem7ShpKTEdQihIl6+jDEsOHka9335VPYfsFz4q1U8UNc0/AtDxCc+8QluvPFG12GECn0/ylBfMtSXHBfOtLAJSHZ2al4CSRTx9vXuqZN4+Bun8+6pBXz7Ty9y3UNr6T7QG9d9uMQY4zqEUKHvRxnqS4b6kuPCmRY2AWlqSq1WgkSTCF9Fed6tGBaeOT3lbsXQ1dXlOoRQoe9HGepLhvqS48KZFjYBmTNnjusQQkWifI3JzOCac2dz+8UnptStGMaPH+86hFCh70cZ6kuG+pLjwpkWNgFpaGhwHUKoSLSvD58wmT+n0K0YdHipDH0/ylBfMtSXHBfOtLAJSE9Pj+sQQsVo+Jp1ZD5/jroVwzdCeiuGyy+/nI985COuwwgV+n6Uob5kqC85LpzpPDYBaW1tpaCgICHbTkVG01dvr+VXyzfxs7+tZ1ZJPr/+bBXHFIXr0o7mlwz1JUN9yVBfchLlTOexSSD19fWuQwgVo+nr4K0YvnASO9v28ZHbwnUrhq1bt/K3v/3NdRihQt+PMtSXDPUlx4UzLWwCMnnyZNchhAoXvs6YVcyyr59OedH4UN2K4bOf/Sw333yz6zBChb4fZagvGepLjgtnWtgoaUHZpFz+9JVT+dS8Mm57YiOfX/xPWju6XYelKIqixBktbAKyfft21yGECpe+xmVl8h8XnsCPL5jLM5taQnErhu5uLb4k6PtRhvqSob7kuHCmhU1AKisrXYcQKlz7MsZw8clTue8rp3KgJ/lvxZCXl+c6hFDhOr/ChvqSob7kuHCmhU1A1qxZ4zqEUJEsviqnFLDs66dz4tRJSX0rhr1797oOIVQkS36FBfUlQ33JceFszKjvMcXIzMx0HUKoSCZfRXljWXLZSdz06HrufPI1Xt62hzsWVHHUxHGuQwPg29/+NuvWrXMdRqhIpvwKA+pLhvqS48KZzmMTkObmZoqKihKy7VQkWX09smY7V/3pRXKyM/nlxSdyyvRC1yEByesrWVFfMtSXDPUlJ1HOdB6bBLJ27VrXIYSKZPV17tzJPPS105gwLosFdz3LXStec34rhvXr1/PII484jSFsJGt+JSvqS4b6kuPCmRY2ASkrK3MdQqhIZl99t2I4a3YJN/xlHV//wwvs7XJ3K4Yvf/nL3H777c72H0aSOb+SEfUlQ33JceFMC5uA6HBcGcnuK39cFr++pIp/+1AFj6zZzgV3rOT1ZncdeF23GoWNZM+vZEN9yVBfclw408ImIDt37nQdQqgIgy9jDF+tmcndXziZXW1dTm/FoB+kMsKQX8mE+pKhvuS4cKaFTUCqqqpchxAqwuTr9FlFzm/FkJ+fP6r7Czthyq9kQH3JUF9yXDjTwiYgdXV1rkMIFWHz1Xcrhk/Pm+LkVgxtbW2jtq9UIGz55Rr1JUN9yXHhTAubgOTk5LgOIVSE0de4rEz+4xMn8O8f927FcN5to3Mrhu9+97tcdtllCd9PKhHG/HKJ+pKhvuS4cKaFTUDKy8tdhxAqwuzrMyd5t2Lo6fVuxXB/gm/FcNZZZ/GpT30qoftINcKcXy5QXzLUlxwXzrSwCYjODCsj7L4qpxTw8NdPp2raJL7zpxf57kNrEnYrhvr6epYtW5aQbacqYc+v0UZ9yVBfclw408ImIFrBy0gFX4V5Y7n7Cyfx5erpLH1mC59e9DRv7tkX9/1ceeWV3HXXXXHfbiqTCvk1mqgvGepLjrbYhBDt3CkjVXyNyczg6nNmc8eCE2l4s43zblvBM6+1xH0/PT09cd9mKpMq+TVaqC8Z6kuOC2da2ASkpSX+X2apTKr5OnfuZP58xWlMyEnMrRj2798ft22lA6mWX4lGfclQX3JcONPCJiA6r4GMVPQ1sySfP38tMbdi0HlsZKRifiUS9SVDfcnReWxCiM5rICNVffXdiuH/fOjYuN6KQZu+ZaRqfiUK9SVDfcnReWxCSF5enusQQkUq+zLGcHnNjMNuxfD3ALdi+PGPf8zXv/71OEaY+qRyfiUC9SVDfclx4UwLm4CUlpa6DiFUpIOv02cV8fA3zuCY4vF86e7V3PzoyG7FMH/+fM4555wERJi6pEN+xRP1JUN9yXHhTAubgDQ0NLgOIVSki6+jC3K478unctF7pvDLf3i3Yti9V3YrhlWrVvHggw8mKMLUJF3yK16oLxnqS44LZ1rYBGTGjBmuQwgV6eRrXFYmP7nw0K0Yzv+l7FYM11xzDffcc08CI0w90im/4oH6kqG+5LhwpoVNQHT4n4x09NV3K4beEdyKQYd7y0jH/AqC+pKhvuTocO8Q0tra6jqEUJGuviqnFLBsBLdiOHAgPsPG04V0za+Ror5kqC85LpxpYRMQnddARjr7GsmtGHQeGxnpnF8jQX3JUF9ydB6bEKLzGshId199t2L4VYy3YtB5bGSke35JUV8y1JccnccmhBQUFLgOIVSoL49zYrgVw6233srVV1/tKMJwovklQ33JUF9yXDjTwiYghYWFrkMIFerrEH23YvjA7CMHvBVDZWUl8+fPdxhh+ND8kqG+ZKgvOS6caWETkE2bNrkOIVSor8PJH5fFry458bBbMby2qx2Axx57jPvuu89xhOFC80uG+pKhvuS4cKaFTUAikYjrEEKF+nonfbdiWHLZyTS3d/PRX67kb7+6lxvOO48HrrkGystB57OJCc0vGepLhvqS48KZFjYB2bZtm+sQQoX6GpzTZhax7Ounc0zGPhZuzmPruInsy86GzZth4UItbmJA80uG+pKhvuS4cKaFTUDa29tdhxAq1NfQHF2Qw32/+zYXvfgob0wo4fUJpdx26qdZVTSTvd//kevwkh7NLxnqS4b6kuPCmek/EiMVmTdvnl29enVCtt3W1qZzjQhQXzGQkQHWcvz4SWybUMTEf7nFe7q3h9llkzhx6iSqpnmPskk5GGMcB5w8aH7JUF8y1JecRDkzxtRZa+cNtExbbAKi8xrIUF8xMHUqAMV7dzOtYycv3vppFt/3Pa545VEm5Wbz4PNNXHlvPWf89B+c9OPH+fKS1Sx6chN1m99i3/4ex8G7RfNLhvqSob7kuHA2ZtT3mGLo8D8Z6isGbrwRFi7kzo4O1h95JBMbGqjZ8So1138LFpxMT69l/Ztt1G3ZzQubd1O3ZTePvrwDgOzMDOYcPeGwVp2SCeMcH9DoofklQ33JUF9yXDjTwiYg2iwpQ33FwIIFAFRcey1ju7th2jSv2PGfz8wwHFc6geNKJ/DZU6YBsKuti+e37Ob5zbt5fstu7n5mM3c99ToAZZNyDit0jj0qnzGZqdlYq/klQ33JUF9yXDjTwiYgjY2NlJeXuw4jNKivGFmwgGUTJrBmzRquueaaYVcvzh/LB48/ig8efxQA3Qd6eXnbHuo27+aFLa08+3oL//uiNzohJyuTyikFnDitgKppk3j3lElMGp+d0MMZLTS/ZKgvGepLjgtn2nk4IDt27ODII49MyLZTEfUVOzU1NXR3d7Nq1arA27LWsm3PPuo2H2rVeXnb2/T0eu//GcXjqZp2qGPyjOI8MjLC1ylZ80uG+pKhvuQkytlQnYe1xSYgjY2NmugC1JeMffuGvvt3rBhjOLogh6MLcvjIu0oB6Og+wEtNfa06u/n7Kzu4b3UTABPGjeHEqELnXVMKyBub/B8Xml8y1JcM9SXHhbPk/6RKcjo7O12HECrUl4ze3t6EbTs3ewynTC/klOle5z5rLa837/Vadbbs5vnNrdzS0IC1kGHg2KMmeK060wqomnoEU45IvqHmml8y1JcM9SXHhTO9FBUQnddAhvqKnZqaGnp6elixYoWzGPZ07qd+a+vBS1j1W1tp92/UWZQ3liq/n86JUycx5+iJjMvKdBYraH5JUV8y1JccF/PYaItNQOrq6qipqXEdRmhQXzLa2tqc7n9iThbVkWKqI8UA9PRaGna0HdZXp2+oeVamYc7RE6nyL1+dOG0SR47yUHPNLxnqS4b6kuPCmRY2ASkpKXEdQqhQX7GzZMkSGhoaXIdxGJkZhtmTJzB78gQu8YeaN7d38bw/n84Lm1tZEjXU/OiCnIPDzEdjqLnmlwz1JUN9yXHhTAubgGRnp8Yw2dFCfcXOlClT6Orqch3GsBTljeXs44/i7Kih5q9sf/tgq85zr7912FDzd02ZeLDQifdQc80vGepLhvqS48KZFjYBaWpqYubMma7DCA3qK3buvfdeXn75ZX70o3Dd/DJ7TAaVUwqonFLAZacfA8C21k7qNu8+2DH5zuWvccAfaj69ePzBy1dBh5prfslQXzLUlxwXzrTzcECam5spKipKyLZTEfUVOzU1Nezfv5+VK1e6DiXudHb38FJTK3X+bMl1m3ezu2M/4A01f3dUoSMZaq75JUN9yVBfchLlTDsPJ5CGhgZNdAHqS0aqDi/Nyc7k5OmFnBw11LyxpeNQq87m3dzy2KGh5hVHTTg4AmvAoeb33APXXkvD0UdT9MYbh92CQhkcfT/KUF9yXDjTwiYgPT3pfTdlKepLRjq0qII3geAxReM5pmg8n6gqA+Dtffup39J68PLVQy9sY+kzWwCvX8+JU/1CZ/0/mfOdrzGubQ89U6fC5s2wcKG3YS1uhkTfjzLUlxwXzvRSVEBaW1spKChIyLZTEfUVOzU1NRw4cICnnnrKdShJQU+vZcPOtsNadRpbOgDI6tnP8Ts2Maf5da56YjETu/Z6Nw9tbHQbdJKj70cZ6ktOopwNdSkqruMujTHlxhg7yOOqYV57sTGm3hjTYYx50xiz1BhzVL91vmmMedUY02mMaTLG3G6MyYvnMUipr693ufvQob5ktLe3uw4hacjMMBx71AQWnDyN//xUJbVXvZfV3z2L3zx4PZf98yGyew7w4HHvZdwBfyTZli1uAw4B+n6Uob7kuHAW70tRW4HJ/Z67ALgduH+wFxljTgOWAN8BHgKOBO4A7gHe769zMfBT4IvACmA68F/AOOCyOB6DiMmT+x+uMhTqK3buv/9+Nm7c6DqMpKYobywf6H6TDyx/FoBXIhWM7fFmRmbqVIeRhQN9P8pQX3JcOItri421tsda+2b0A/g48Ji19vUhXnoq0GStvcVa+7q19hngNuDkqHXmA89Ya5dYaxuttU8Ad/dbR1FShqKiIiZNmuQ6jOTnxhshNxeATPxL67m53vOKoqQdiZsCFDDGTMdrcVk0zKorgcnGmPONRxFwEfBI1DpPAZXGmFP8bU8FPtJvnVFn+/btLncfOtRX7CxevJjf/va3rsNIfhYsgEWLYNo0tpeWen1rFi3SjsMxoO9HGepLjgtniR4V9UVgF/DnoVay1j5tjLkI79JTjh/X34HPRa3zR2NMIfCk8cZ5jsG7fPV/BtqmMWYhsBCgtLSU2tpaZs+eTWNjI52dnVRVVVFXV0dJSQnZ2dk0NTUxZ84cGhoa6OnpYe7cudTX1x9sRtu+fTuVlZWsWbOGzMxMIpEIa9euZdKkSbzyyivs3Lnz4DZzcnIoLy9n3bp1lJeX09bWRktLy8HleXl5lJaW0tDQwIwZM2hpaaG1tfXg8oKCAgoLC9m0aRORSIRt27bR3t5+cHlhYSH5+fk0NjYm5JjKysro7u5OyDHt27ePbdu2pdQxJeo83XHHHfT29lJbW5syx5Sw8/Te99KweDElJSXUd3d7x9TWFu5jGoXztG/fPpqbm1PqmBJ5nsaNG0dtbW1KHVOizxNwmLN4HdNQxDQqyhhzA3DtMKu911pbG/WaMXh9bpZYa/9tmO0fh1fI3Ao8itdP5yag3lr7L/461cC9wHeBZ4GZwM+Bxdba7w21/USOilqxYgVnnHFGQradiqiv2KmpqWHPnj288MILrkMJDZpfMtSXDPUlJ1HO4jFB363A0mHW6T8E4XzgKOCuGLZ/NfCctfYm/++XjDF7gRXGmGustU3ADcAfrLV921tjjBkP3GWM+ZG19kAsBxJvMjMzXew2tKgvGYdNQqcMi+aXDPUlQ33JceEspsLGWtsMNAu3/SVgubU2ltsT5wL9Z/Hp+ztjmHWcfvJHIhGXuw8d6ktGTk6O6xBCheaXDPUlQ33JceEsIZ2H/Y69HwR+M8jyu40xd0c9tQz4qDHmcmPMdH/49y+A5621W6LWWWiMucgYc4wx5gPA9cDDrlprANauXetq16FEfcnYu3ev6xBCheaXDPUlQ33JceEsUZ2HLwP2AA8MsvywCSastYuNMfnAFcDP/Nc+weEdg28ALF4xU4bXgrSM4fv+JJSysjKXuw8d6it2HnnkETZt2uQ6jFCh+SVDfclQX3JcOEtIYWOt/T7w/SGW1wzw3G14c9cM9poDwA/9R9IwXO9s5XDUV+zk5ubqNX0hml8y1JcM9SXHhbOEzmOTDuzcudN1CKFCfcXOHXfcwaJFw00BpUSj+SVDfclQX3JcONO7ewekqqrKdQihQn3Fzn333ad3Exai+SVDfclQX3JcONMWm4DU1dW5DiFUqC8ZbW1trkMIFZpfMtSXDPUlx4UzLWwCosNxZagvGRkZ+haVoPklQ33JUF9yXDjTT82AlJeXuw4hVKgvGePGjXMdQqjQ/JKhvmSoLzkunGlhE5B169a5DiFUqC8ZHR0drkMIFZpfMtSXDPUlx4WzmO4VFXaMMbuAzQnafBHyWZnTGfUlQ33JUF8y1JcM9SUnUc6mWWuLB1qQFoVNIjHGrB7sRlzKO1FfMtSXDPUlQ33JUF9yXDjTS1GKoiiKoqQMWtgoiqIoipIyaGETHJ0aVob6kqG+ZKgvGepLhvqSM+rOtI+NoiiKoigpg7bYKIqiKIqSMmhhoyiKoihKyqCFjaIoiqIoKYMWNoqiKIqipAxa2ChKSDHGGNcxhIE+T8YY/bxTEoIxJtP/V9+TwxDtKFG+9I2uJB364TA0xphCAGutVVcxMQfAWtvrOpAwYIyZZ4w5VnMrNowxHwP+0xgzxuow41gYC94PjUR9hmlhE2f8D4WPGWO+ZIw5wnU8yY4x5r3GmCuNMTcaY97dl+yu40pWjDGfAe4zxnwAtLgZDmPMV4AXjTEzXMcSBowxlwEPA5XABLfRJD/GmC8BDwIfA8b5z+n7cRCMMRcAvzXG/BW43hiTm4jPey1s4ogx5vPAA8B1wO3AI8aYcn+ZJns/jDFfAO4DaoCFwF14N0xTBsAYkwdcAcwCPm+MeR8cLG70vdwPY8yXgduAT1prNw2wXN+TURhjPg7cCnzHWvtHa+2efss1x6IwxizE+5y/Aq+ouQK896PLuJIV//P+bmAT8DbwIeDDUcvj9n4cE68NpTv+h8ItwBeAJ4D9wKvAvwLf1GQ/HGPMp4D/BC611j7kf2nvAGYCO6PWM+rOw1rbbozZBLwBlAPfNMZkWmv/3neZRX15GGM+B/wKONda+/+MMSV4RXM5sApos9b2qK+DXygG+Dhwi7V2qTFmOnABMBV4DfittfZtv0U17S/p+UXNHcCnrLUPGmNOAj5ojPmNtbbFcXhJhzGmEvgu8AVr7Z/8nFsFZPvLM6y1vfHKL63A44AxZjJeQXOjtfZBYK+1di9wJzDbX0d/HfoYY8qATwPXWWsfAu9LG6gHPmKM+Y0x5vOJaqYMI1H5swv4M/AN4CjgS8aYs4wxDxhjCtQXGGOOAa4B1vhFzRRgGd4lg4eBf+AVhWPV18EWhjHA8cBTxpgi4EngVGA+cCmwys+v3nT/LDPGnA/8GviE/3kP8CfgDKDKXyetHQ1AKdALPAUHc24/8FljzHJgcTzzSwub+LAH6ALWAVhr9/vP7wDKjTHZ9HOd5om/C1iK92UDgDHmEWAGXseyKXgtXd9Ic08HifoCrgfeZ61dDXwLz9W9wElAB6R9bgG8Cfwc6DTGPA4sB2qBzwOTgReBz+E1hSuAtbYb2A6cBfwQ+F/gM8ApwFeBNuBO7SALwNPAmX5LcwaAtfYvwCPAVcaYfHX0DrqBHuALxpgyY8wyvNbTB/B+aMwEfh+vHxta2ATEb8ruAD5rrX3Yfy7TX/w28La1ttta2+Mve386fzj4vrqAP1trG/3n3of3hXOGtfZfrbUfwruMdy6Q5SzY5ORt4EQAa+1K4EggE+/L+hT/+bTMLTiYX53Af/uPErxLwz8AnrXW7sArcDLxLr2kPVGF8D+BdwMnAM9Ya/dba3ustU/jtUgcC+Q7CjMp8C/9Nltr+1oeoi+bPIE3Au9of139fj3Ec3g/Li7Ba+16D/ABa+1vrLU/ABbjXd0oi8fOVHxA+r5E/OKm70OiL9kP++VsjHkM+Bpe5ZqWRPmK/kCoBU631m4wxvT1+1qL9ysxbV0NwnPAJmNMrjHmJbz+D5cBE4EbjDFVTqNzTN8oMWvtPryOij8Afm2t7fSbuft+VLyC5hZwWCF8O14heBreqKho1gOdpPl3Rt8P1GiiCsNfAHuBq/11074vEhzsP/M2cCVwOt4gkTfx+gr20Qi0c+i7MxDaeTjO9Pu1nAXkGmPGAv8DTAOOi/rwTdtf1tH4Xzgd/v8PGGNy8a7tvzTQB0ma04V32akdWAF8xlq7yxjTCXwUeMFlcMlAdHFjjHkoOof8/MrD65/0F3dRJhd+S8ROY8zZeP1rLjLGNAH/hTfi53JgK/CWwzCTkr5Rif7n2G+BzxhjZllrN7iOLRno6zfjt6R2GmP6um5MMcZsxCuWv4H3I60xHvs0+t2aOPyRP/8Xb5TPTGC2tXa//6vxgNvokg+/AJyI1yx5JHCy/0WkRSCHRjwZY74DVADf9S+t9F9PR64MgJ9fBXj5VQjM1/fhIfo+l4wxR+L9qp6Fd1nlVbxLdyf7n1/6fhwEY0wEz9cXrLWLHYeTlBhvgtHngWa8/pbZwBHAe/z8Cvz5pYVNAoj6AroErzl8JV6HTy1qhsB4k6ld4v/5Xt9XprbaHI7xJn7s9H8B6RDvGDHGfA1vhM8BvM6fml/96PNhjBmP18J8Il6n4lr/ef38GoSoVpvLgN+pp3cS5ehI4Ht4BfM24Md+UR2X/NLCJoEYb+6M3wAXxvOkpSrGmALgk8B/64eoEm+MMZOAi/H63Gh+DcJgv5i1CJSh+TUwUcXzYXkWz/zSwiYGRtI01v8kGWOy7KFh4CnNCH0lLMmTHb10JCNO+ZU2Xzojza90bQlUXzIC+Dr4uni7087Dw9BP/ly8TpvW+kOVhyD6QzQtixqhr4NJrb6G9xX9QZCuX9KaX8Oj+SVDfckI6KvvdXH3ldZD92IhSv5P8SZgWgU8aYz5tjk0X81h9EvyK4FfD7ZuqqG+ZMTJ153qS/NrIDS/ZKgvGUnry1qrjwEe+Jfp/P+fh9fB6Wy8SeO+jTcd9E+Hed1CvFmJL3Z9POoruR7qS32pr+R5qK/U8uVcULI/8OYG+Q3efY2in/8E3uWmSwY5aV/2T9rHXR+D+kreh/pSX+oreR7qKzV8OReTbI9+8k/Dm6yqFe8Gl+DNJpzp//8uvHuqjO17zn/+S/5Ju9D18aiv5HqoL/WlvpLnob5S05f2semH7Ts7xnwP774pPwc24d2FdJ6/vK9j8G4gz1rbZQ/dC+qreLezv9Ra+8CoH8Aoo75kqC8Z6kuG+pKhvmSExZcWNoAx5gpjzLv9//fd96MaaPTl/xhvqud/N8acaK21xpvAah7ePS+i2Y93zfB/Rif60Ud9yVBfMtSXDPUlQ33JCKWvRDZbheEBHAP03RNljv9cNt602BdFrfdJ4Bm84WxPAn/AmxY6u6+IdX0s6iv5HupLfamv5Hmor/TwlfYtNtba1/F6db8L+JYxZo61thvvzr+tUev9Ca8yXQ/kAU9Ya0+01nYbb14MO/rRjz7qS4b6kqG+ZKgvGepLRlh9pX1hA2Ctrcfr0FQJfMcYMw9owG9GM8bk+Ov9L/BHvLuQftQYM9t/Pi0m++pDfclQXzLUlwz1JUN9yQijL72lQhT+dcRFeGPyz8drgmvD6ww1zl/tz8Bq4It4vb0vt9auHf1o3aO+ZKgvGepLhvqSob5khMmX3lIhCmvtC8aYhXh35H4aeAL4O941xUl4Q9b+CGCMGQtciDdsLS1RXzLUlwz1JUN9yVBfMsLkS1tsBsAYU4k36dBLeLMnrh9kvXxrbdtoxpaMqC8Z6kuG+pKhvmSoLxlh8KWFzSD4zW6/wWtu+5a19rWoZWl5F9ehUF8y1JcM9SVDfclQXzKS3Zd2Hh4Ea+0LwFfxJhlq7LdMk7wf6kuG+pKhvmSoLxnqS0ay+9IWm2Hoqz5N1O3ZlcFRXzLUlwz1JUN9yVBfMpLVlxY2MZAMTWthQn3JUF8y1JcM9SVDfclIRl9a2CiKoiiKkjJoHxtFURRFUVIGLWwURVEURUkZtLBRFEVRFCVl0MJGURRFUZSUQQsbRVEURVFSBi1sFEVRFEVJGf4/L9IeL83pbyUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs_kpoint.seek_convergence(rtol=0.001,attribute='energy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform a convergence test for Hartree-Fock computations with Yambo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We consider a set of Hartree-Fock computation for silicon and we look for the value of the EXXRLvcs that ensure\n",
    "a converged value of the direct gap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First of all we need a nscf computation. We start from scf result with ecutoff = 60 and kpoints = [4,4,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = I.PwInput('Si_gs_convergence/kp_4.in')\n",
    "inp.set_nscf(8,force_symmorphic=True)\n",
    "inp.set_kpoints(points = [6,6,6]) #nscf kpoints can be different from the scf\n",
    "name = 'nscf_kp6_ecut60'\n",
    "inp.set_prefix(name)\n",
    "#inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a QuantumESPRESSO calculator with scheduler direct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'omp': 1,\n",
       " 'mpi': 4,\n",
       " 'mpi_run': 'mpirun -np',\n",
       " 'executable': 'pw.x',\n",
       " 'scheduler': 'direct',\n",
       " 'skip': True,\n",
       " 'clean_restart': True,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code = C.QeCalculator(mpi=4)\n",
    "code.global_options()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The folder Si_gs_convergence/nscf_kp6_ecut60.save already exsists. Source folder Si_gs_convergence/kp_4.save not copied\n",
      "Skip the run of nscf_kp6_ecut60\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Si_gs_convergence/nscf_kp6_ecut60.save/data-file-schema.xml'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code.run(run_dir='Si_gs_convergence',input=inp,name=name,source_dir='Si_gs_convergence/kp_4.save')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is the generation of the run_dir and SAVE folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mppi import Utilities as U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "run_dir = 'Si_hf_convergence'\n",
    "source_dir = 'Si_gs_convergence/nscf_kp6_ecut60.save'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SAVE folder already present in Si_hf_convergence. No operations performed.\n"
     ]
    }
   ],
   "source": [
    "U.build_SAVE(source_dir,run_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are ready to build the Yambo dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Yambo calculator with scheduler direct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'omp': 1,\n",
       " 'mpi': 2,\n",
       " 'mpi_run': 'mpirun -np',\n",
       " 'executable': 'yambo',\n",
       " 'scheduler': 'direct',\n",
       " 'skip': True,\n",
       " 'clean_restart': True,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code = C.YamboCalculator()\n",
    "code.global_options()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'args': 'yambo -x -V rl',\n",
       " 'folder': 'Si_hf_convergence',\n",
       " 'filename': 'yambo.in',\n",
       " 'arguments': ['HF_and_locXC'],\n",
       " 'variables': {'FFTGvecs': [2733.0, 'RL'],\n",
       "  'SE_Threads': [0.0, ''],\n",
       "  'EXXRLvcs': [17153.0, 'RL'],\n",
       "  'VXCRLvcs': [17153.0, 'RL'],\n",
       "  'QPkrange': [[1, 1, 1, 8], '']}}"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inp = I.YamboInput(args='yambo -x -V rl',folder=run_dir)\n",
    "inp.set_kRange(1,1) # we are interested at the direct gap at Gamma so we include only the first kpoint\n",
    "inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Dataset with 2 parallel tasks\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'label': 'Si_hf',\n",
       " 'run_dir': 'Si_hf_convergence',\n",
       " 'num_tasks': 2,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_convergence = D.Dataset(label='Si_hf',run_dir=run_dir)\n",
    "hf_convergence.global_options()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us start by adding some computations to see how to manage the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "exx_values = [1.,2.,3.] #in Hartree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in exx_values:\n",
    "    id = {'exxrl' : e}\n",
    "    inp['variables']['EXXRLvcs'] = [1e3*e, 'mHa']\n",
    "    hf_convergence.append_run(id=id,input=inp,runner=code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " If needed we can also pass the jobname attribute by adding, for istance\n",
    " \n",
    " jobname=D.name_from_id(id)+'-job' \n",
    " \n",
    " in the appen_run. For instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "exx = 4.\n",
    "id = {'exxrl' : exx}\n",
    "inp['variables']['EXXRLvcs'] = [1e3*exx, 'mHa']\n",
    "hf_convergence.append_run(id=id,input=inp,jobname=D.name_from_id(id)+'-job',runner=code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label': 'Si_hf',\n",
       " 'run_dir': 'Si_hf_convergence',\n",
       " 'num_tasks': 2,\n",
       " 'verbose': True,\n",
       " 'input': {'args': 'yambo -x -V rl',\n",
       "  'folder': 'Si_hf_convergence',\n",
       "  'filename': 'yambo.in',\n",
       "  'arguments': ['HF_and_locXC'],\n",
       "  'variables': {'FFTGvecs': [2733.0, 'RL'],\n",
       "   'SE_Threads': [0.0, ''],\n",
       "   'EXXRLvcs': [4000.0, 'mHa'],\n",
       "   'VXCRLvcs': [17153.0, 'RL'],\n",
       "   'QPkrange': [[1, 1, 1, 8], '']}},\n",
       " 'jobname': 'exxrl_4.0-job',\n",
       " 'name': 'exxrl_4.0'}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_convergence.runs[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can run the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "Skip the run of exxrl_2.0\n",
      "Skip the run of exxrl_1.0\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "Skip the run of exxrl_4.0\n",
      "Skip the run of exxrl_3.0\n",
      "Task [2, 3] ended \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: {'output': ['Si_hf_convergence/exxrl_2.0/o-exxrl_2.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_2.0/ndb.HF_and_locXC'},\n",
       " 0: {'output': ['Si_hf_convergence/exxrl_1.0/o-exxrl_1.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_1.0/ndb.HF_and_locXC'},\n",
       " 3: {'output': ['Si_hf_convergence/exxrl_4.0/o-exxrl_4.0-job.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_4.0-job/ndb.HF_and_locXC'},\n",
       " 2: {'output': ['Si_hf_convergence/exxrl_3.0/o-exxrl_3.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_3.0/ndb.HF_and_locXC'}}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_convergence.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {'output': ['Si_hf_convergence/exxrl_2.0/o-exxrl_2.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_2.0/ndb.HF_and_locXC'},\n",
       " 0: {'output': ['Si_hf_convergence/exxrl_1.0/o-exxrl_1.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_1.0/ndb.HF_and_locXC'},\n",
       " 3: {'output': ['Si_hf_convergence/exxrl_4.0/o-exxrl_4.0-job.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_4.0-job/ndb.HF_and_locXC'},\n",
       " 2: {'output': ['Si_hf_convergence/exxrl_3.0/o-exxrl_3.0.hf'],\n",
       "  'dft': 'Si_hf_convergence/SAVE/ns.db1',\n",
       "  'HF_and_locXC': 'Si_hf_convergence/exxrl_3.0/ndb.HF_and_locXC'}}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_convergence.results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parsing the results with a post processing function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can define a general post processing function to extract all the results from the o- files of the dataset.\n",
    "\n",
    "We can use the YamboParser class of this package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_data(dataset):\n",
    "    from mppi import Parsers as P\n",
    "    results = {}\n",
    "    for run,data in dataset.results.items():\n",
    "        results[run] = P.YamboParser(data,verbose=True)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "hf_convergence.set_postprocessing_function(parse_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "Skip the run of exxrl_2.0\n",
      "Skip the run of exxrl_1.0\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "Skip the run of exxrl_4.0\n",
      "Skip the run of exxrl_3.0\n",
      "Task [2, 3] ended \n",
      "\n",
      "Parse file Si_hf_convergence/exxrl_2.0/o-exxrl_2.0.hf\n",
      "Parse file : Si_hf_convergence/SAVE/ns.db1\n",
      "Parse file Si_hf_convergence/exxrl_1.0/o-exxrl_1.0.hf\n",
      "Parse file : Si_hf_convergence/SAVE/ns.db1\n",
      "Parse file Si_hf_convergence/exxrl_4.0/o-exxrl_4.0-job.hf\n",
      "Parse file : Si_hf_convergence/SAVE/ns.db1\n",
      "Parse file Si_hf_convergence/exxrl_3.0/o-exxrl_3.0.hf\n",
      "Parse file : Si_hf_convergence/SAVE/ns.db1\n"
     ]
    }
   ],
   "source": [
    "code.update_global_options(verbose=False,skip=True)\n",
    "results = hf_convergence.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results can be extracted as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-18.5920771   -0.98291615  -0.9763885   -0.97688737   6.96150102\n",
      "   6.96142707   6.95129216   8.07606703]\n",
      "[-18.5149594   -0.5280984   -0.52432564  -0.52620809   7.25884257\n",
      "   7.25947058   7.24850752   8.57440589]\n",
      "[-18.632854    -1.14186462  -1.1418194   -1.14185213   6.77885838\n",
      "   6.77883889   6.77870771   7.89729728]\n",
      "[-18.6264669   -1.12492861  -1.1253136   -1.12534784   6.79757485\n",
      "   6.79746045   6.79699993   7.91634358]\n"
     ]
    }
   ],
   "source": [
    "for irun in results:\n",
    "    data = results[irun].data\n",
    "    print(data['hf']['ehf'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing the direct gap with a post processing function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We describe the usage of a post processing function to perform a more specific operation like computing\n",
    "the direct band gap. We define the post processing function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_direct_gap(dataset):\n",
    "    \"\"\"\"\n",
    "    Compute the direct band gap assuming that there is only one kpoint.\n",
    "    The arguments energy_col, val_band and cond_band are read from the global_options\n",
    "    of the dataset.\n",
    "    \"\"\"\n",
    "    from mppi import Parsers as P\n",
    "    import numpy as np\n",
    "    glob_opt = dataset.global_options()\n",
    "    val_band = glob_opt.get('val_band')\n",
    "    cond_band = glob_opt.get('cond_band')\n",
    "    # the name of the column used to compute the gap\n",
    "    energy_col = glob_opt.get('energy_col','hf') \n",
    "    gap = {}\n",
    "    for run,data in dataset.results.items():\n",
    "        results = P.YamboParser(data).data\n",
    "        key = list(results.keys())[0] # select the key (can be hf or qp)\n",
    "        bands = results[key]['band']\n",
    "        index_val = np.where(bands == val_band)\n",
    "        index_cond = np.where(bands == cond_band)\n",
    "        energy = results[key][energy_col]\n",
    "        delta = energy[index_cond]-energy[index_val]\n",
    "        gap[run] = float(delta)\n",
    "    return gap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function assume that some inputs like the specification of the conduction and valence bands are given in the global options\n",
    "of the dataset. So we can se"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "hf_convergence.update_global_options(val_band = 4, cond_band = 5, energy_col = 'hf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we set the new post processing function and run the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "hf_convergence.set_postprocessing_function(get_direct_gap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Run the selection [0, 1, 2, 3] with the parallel task_groups [[0, 1], [2, 3]] \n",
      "\n",
      "Run the task [0, 1] \n",
      "Skip the run of exxrl_2.0\n",
      "Skip the run of exxrl_1.0\n",
      "Task [0, 1] ended \n",
      "\n",
      "Run the task [2, 3] \n",
      "Skip the run of exxrl_4.0\n",
      "Skip the run of exxrl_3.0\n",
      "Task [2, 3] ended \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 6.678640580000001,\n",
       " 0: 6.525302829999999,\n",
       " 3: 6.66096274,\n",
       " 2: 6.663174910000001}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_convergence.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage of seek convergence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The post processing function defined above can be used together with the seek_convergence method to perform a convergence study\n",
    "\n",
    "In this case we define a new dataset and append many possible runs. Only those one needed to reach the given tolerance will be executed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Dataset with 2 parallel tasks\n"
     ]
    }
   ],
   "source": [
    "hf_convergence2 = D.Dataset(label='Si_hf',run_dir=run_dir,val_band=4,cond_band=5,var_name ='hf',verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exx_values = [float(i) for i in range(1,10)] #in Hartree\n",
    "exx_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in exx_values:\n",
    "    id = {'exxrl' : e}\n",
    "    inp['variables']['EXXRLvcs'] = [1e3*e, 'mHa']\n",
    "    hf_convergence2.append_run(id=id,input=inp,runner=code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "hf_convergence2.set_postprocessing_function(get_direct_gap)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seeking convergence for id \" {'exxrl': 1.0} \"\n",
      "Seeking convergence for id \" {'exxrl': 2.0} \"\n",
      "Seeking convergence for id \" {'exxrl': 3.0} \"\n",
      "Seeking convergence for id \" {'exxrl': 4.0} \"\n",
      "Seeking convergence for id \" {'exxrl': 5.0} \"\n",
      "Convergence reached in Dataset \"Si_hf\" for id \" {'exxrl': 5.0} \"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'id_conv': {'exxrl': 5.0}, 'value_conv': 6.661829569999999}"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAHaCAYAAADIY6lzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAB+EElEQVR4nO2de3hdZZW435W0adMmEExJbQg0Nm2g2mIwHQVBqSMqAgoqIA4DMo6DgpfB64xcZrwhzowIonLzBgLOwA+8cXFEYKpYFGgkkkogaSBAaMhpUwM5TZo0J9/vj713ON0kzUly9u3b632e8zRnX9ebleasfLctxhgURVEURVGSQknUASiKoiiKoswELV4URVEURUkUWrwoiqIoipIotHhRFEVRFCVRaPGiKIqiKEqi0OJFURRFUZREocWLoiiBIiL1ImJEZF0A1y4RkWtEpN+9x/pi32OSe2ZF5Kyg7xMnROQsEckWeOwXRWRzgcf1uXk7a85BKqlCixcl8YjIUhH5loh0iciIiDwnIr8SkeOijk2ZHSKyQUS+U8ChxwH/ALwLWAY8EGhgs6DQD/MA7juTguPDIvKIW5i9ICKPishX8w65GVhRxNjWAP8OfBQnbzcX69pKOpgXdQCKMhdEpB7YCAwCXwD+jFOUvxW4GjgosuAKQETKjDGjUceRYFYCvcaYORUtIjLfGLO7SDElChH5EHAF8CngXmA+sAY4wjvGGDMMDBfxtivdf39udKVUZTYYY/Slr8S+gLuA54CKSfZV5X19EPAznCJnEPgpUJe3/4vAZuA0oMs95ufAEnf/24FRoNp3j68Bj+a9fyPwW2DIjesqYJ+8/Rvcbd8AtgEPu9uPB54AdgG/c+MwQP0Mr32lG9N2IOPepyTvmDJ3/9PACPAk8Mm8/a8G7nT9M8B/A6/cy/e/3o3z74Dfu/E/Drx9kmPW5W17M/Cge3wfcBlQ5u67zj0+/1U/yb39x3W72xcAl7vX3QX8ETgq77z17vHHAQ+5eT1hCr+V7vd1l5ufE4AscFbeMV939w0D3cB/AgvdfWdN4nKWu+/TwKPATjef32fPn9l9gRvcPOxyc3Web/+17v5B92djnc8x//XFKRx/Dtw4zf+zs4Bsgf8nv8je/y990R9b1L9H9JW8V+QB6Etfs30BrwDGgfOnOa4EeASnS2Gd+/ojsAkQ95gvuh9KPwMOxfmr82ngGnd/KbAV+GjedcX9sPq8+36te43PAKuANwB/AG7NO2eD+8v8UuAQYDVOYTUCfBM4GDgZeIa8D+0ZXPsF4MtAI3AqMAZ8IO+Y/wZ6gPfhdAO8BTjT3bcMp+j5DzeuQ4HbcYqMkim+t/VunD3u/Q4Bvo3zQX6A7xjvg/UAnA/sq937nAA8D1zq7t/XzdUPgVe6r9JJ7r0v8CXgWfeY/d3t3wJ6cQrC1cD33O/dMnf/ejeeNpyidIV37iQ/N204xeRhwJE4PzO72bN4ucjdV49TED0DfMXdV45TQD6e51Lu7jsP+Fv3vKNxCpkb8q77baAVeD2w3I37lLyfvd/jFJqvxymyvgK86OaxDPhn9/vs3fdlBb57rauBDmDFXv4PncXMipe9/V+qAD7s5uCV7KU41pe+pnpFHoC+9DXbl/tL2wDvmea4twE59mzFWIFT+Bzjvv8izl+3++YdcwGwJe/9N4H7894f5V63zn3/Y+AHvns3uTHWuO83kNdS4267BGj3bTufPYuXQq/9B98xvwG+7369yj3+2Cm+T18G7vVt28895/VTnFPv7r8gb1uJ+2H4Vd8xXvFyMdDJni1CZ+EUcIvyXL5TwM/AZ3FbXNz3i3FaUs7M21aK0wLgxbPejed901z77W5+D/LlfKL1ZIrzPur7ufkisLkAl2Pd70GJ+/6XwA+nOPZvcQqEct/2Vl4qps+igIIDp9j5g+vVCdwInAnM9+VnJsXLdP+XTkZbXPQ1h5cO2FWSjBR43GpgqzGm29tgjHkSpyXl1XnHPW2MeSHv/VagJu/9jcCRIrLcfX868FtjTI/7vhn4e3fQY9YdLLnR3deQd50WX3yHAA/7tj3oe1/otR/1nZfvcBhOwfZ/TE4z8GbfPZ6d5B6T8QfvC2PMuBv/q6c4djXwR/c4j9/jtBasnPyUgmnAGbPhfW8wxuTc+PzxbJrmWquB54wxz+RtexDneziBiJwsIr8Xkefd79llFDDWSkT+VkR+IyI9IuJ1ZZbhtEaA0y34fhH5s4h8Q0SOzju9GVgEbPPlaw3T52oPjDG9xpgjcFr3Lsf5f3UN8JCILJrJtfKY7v+SoswJHbCrJJlOnL8WV+M0Uc8Gk/e1f8CmIW9GnjHmTyLyOPB3IvIN4BTg83nHl+CMW7hskvs8l/f1zlnEWei19+pQwD3uxGnN8NNX4DXmipn+kKJdezZ52AMRORz4H5zuq08BA8C7cbqK9nbecpzv9feAfwP6gdfhdOuVARhjfuUe906cAeh3isj/M8b8A06u+oA3TXL5F2fjYozZjDNW5bsichRwP05X4HWzuNxcfg4VZVq0eFESizFmh4j8Gvi4iFxhjNljWqiIVBljBoB2oFZE6r3WFxFZAdQCj83wtjfitLhsxumiuDVv35+A1xhjtszwmo8DJ/q2vd73frbXzqcV5wPkLcD/TrL/TzgfVk+bmc+8ORy4D0BEBCf+W6c4th04VURK8lpfjsLp7uly34/idPfMlC733CO9a4lIKc64i5/M8FrtwAEicqAxxmuBej17fggfidM68xVvQ17LnMdkLutwipRPuS1DiMgJ/gCMMdtxBu3eICK/Av5bRD6Kk6ulwLjbijgZs/0ewkv/Lypmeb6iBIpWwkrS+RhOM/cmETlFRA4WkUNE5Bxe6kK5x/36JhFZ5y6WdhPOB8B9M7zfTTjdD18BbjfG5P+V+x/A60XkahE5TERWisgJInLNNNe8GmhwuwYOFpH3Ah9x93mtBbO99gTGmA7gFuD7IvI+EXmViLxJRM5wD/kuziDYm0XkDSKyQkSOEZFrRaRymsuf43afHIzT9bAcp9tjMq7EKRyvFJHVInI8zoyd7xhjhtxjul3fehFZIiIF/a4yxux07/sfInKciKx23y917zsT7sEpLH8sIk0icgROy9dY3jEdOAXO6e736xzgA77rdAPLReR1rssC3DE/wHluHj6AM4B3AhH5soicJCKrXI/3Ak8aY0bc2DYCvxCRd7rXOEJEviQib8q770IReZt730m7gETkKhG5SESOFJHlbmvSj3Fmtd09w++ZooSCFi9KonH/6nwdzsDU/8ApUu7Dabo/2z3G4LRsbMMZ7/F/OLNbTnL3zeR+T+OMz3gtTitM/r5HcaYA1+NMW/0zzmDcvXa5uNd8nxvzn3G6H77k7t41l2tPwpk4LRBX4HwwX4dTsGCM2YrTkjCO0zLzF5yCZsR97Y1/xZn6+2ecgafvyRsLtAfGmOdwukIOw2kN+iFOd8n5eYd9A6fl4DGcvM1kvZ5/wVn07Efu9Q/FGaTcO4NreGN33oPze/JBnA/0r5L3vTDG3A78F07B9ijO4PB/813qNpwp/fe6Lh9w8/nPON+zx3Bm3/i760ZwBjf/GadQqcRZjM/7mT4O52f9ezhTtW/Bma221T3mAZzC+L/d+36eyfkNzuy1W3CKMa8L9m1uwasosUNm+LtbUZQQEJF/xpn9UzXTAitM3EUCnwL+xhgz3QBYRVGUoqBjXhQlBojIx3BmHG3DGT9yEXBdnAsXRVGUqNDiRVHiwUqcbpNqnAXfrsZpeVGUWCEif8EZ0zQZHzHG3BRmPEo60W4jRVEUpWDc2VTzp9jdZ4wZDDMeJZ1o8aIoiqIoSqLQ2UaKoiiKoiSKRI55WbJkiamvrw/k2mNjY8ybl8hvS8Goox2oox2kwRHS4amOc6OlpWW7MWb/Qo5N5He5vr6eTZuCmZW5YcMG1q9fH8i144I62oHtjk888QQPPvggZ555ZtShBIrtefRIg6c6zg0RebrQYxNZvARJXV1d1CEEjjrage2OH/nIRxgeHra+eLE9jx5p8FTH8NAxLz5GR0ejDiFw1NEO0uCYhgkFacgjpMNTHcNDixcfmUwm6hACRx3tIA2OcflFGSRpyCOkw1Mdw0OLFx/Nzc1RhxA46mgHaXCsrJzueZDJJw15hHR4qmN4aPHio6WlJeoQAkcd7SANjoOD9q93loY8Qjo81TE8dMCuj/Ly8qhDCBx1tAPbHS+88ELa29ujDiNwbM+jRxo81TE8tHjxEdT6MXFCHe3AdsdjjjmGtWvXRh1G4NieR480eKpjeGi3kY80/KWnjnZgu2Nrayu333571GEEju159EiDpzqGR0HFi4gsE5HrRWSbiOwSkcdE5OhpzhEROU9EHheRERHpFZGv+475OxFpFZEhEXleRG4UkVfORWiuxKWqDBJ1tAPbHc877zy+//3vRx1G4NieR480eKpjeEzbbSQiVcBG4PfA8cA2YAUw3XypS4ETgM8BbcC+wLK86x4J3AB8Fvg5sBS4ErgJeOuMLIpIGgYIqqMdpMExl8tFHULgpCGPkA5PdQyPQsa8fB7oNcbkL3P51N5OEJGDgU8Ahxpj8tuYHsn7+gigxxhzmXdNEfk28O0CYgqM/v7+KG8fCupoB2lw3L17d9QhBE4a8gjp8FTH8Cik2+gk4EERuVlEMm43z8dFRPZyzonAk8CxIvKkiHS73U41ecdsBJaJyLvcLqYlwGnAXbOVKQZxmcMeJOpoB2lw1HVe7CENnuoYHoW0vKwAzgUuA74ONPFS68h39nLOcpxi5CzAAN8AbheRI4wx48aYP4jIaTjdROVuLL8BPjjZBUXkbOBsgNraWjZs2MDq1avp7u5meHiY5uZmWlpaqKmpoaysjJ6eHtasWUNHRwe5XI61a9fS2trKsmVOz1Vvby9NTU20tbVRWlpKY2MjmzdvZseOHRxyyCFkMpmJa5aXl1NfX097ezv19fUMDg7S398/sb+iooLa2lo6OjpoaGigv7+fgYGBif1VVVVUV1fT1dVFY2MjW7duJZvNTuyvrq6msrKS7u7uQJzq6uoYHR0lc889NF91Fbcdfjirn3+e+lNOoX3FimQ7TZGngYGBibhtcfLn6bbbbmPNmjVWOeXnaWBggLGxMVpbW61xmixPt912G01NTVY5TZanDRs2UFtba5WTP099fX284Q1vsMrJn6d77rmHAw44IBCnGWGM2esLGAUe8G37GtC+l3OudQuWxrxtje62N7jvXw08hzMm5lDgHcCjwI+ni6m5udkExcMPPxzYtSPlxhuNWbTIGDAPNzcbA877G2+MOrJAsDaPedjuuHHjRvP9738/6jACx/Y8eqTBUx3nBrDJTPP5770K6TbqBR7zbWsHDprmnDFjTEfetk4gl3feF4CHjDH/ZYx51Bjza5wWnjNEJLLHVtbW1kZ162C54AIYGmKwrJwXd7kNbkNDznYLsTaPedju+MY3vpF3vvOdUYcROLbn0SMNnuoYHoUULxuBg33bGoGnpzlnnog05G1bAZTmnbcIp5jJx3sf2fozHR0d0x+URJ55BoDvHnEqHzrhIj783gvp2Wf/ie22YW0e87Dd8YEHHuCnP/1p1GEEju159EiDpzqGRyFFwmXA4SJygYisFJFTgE8C3/UOEJFLROTevHPuAf4E/FBEDhORw4AfAg8Cm9xjbgdOFJFzRGSFO3X6CuBPxpjIPlEbGhqmPyiJHOQ0eP1laQP7jGTZuLyJYz58FVe+4x8ZHRuPOLjiY20e87Dd8fzzz+emm26KOozAsT2PHmnwVMfwmLZ4McY8jDPj6FRgM3AxcBHOmiwey4CGvHPGcdZ4yQC/A34N9AAnuvswxlwHfBr4uHvdW4EOnJlKkRGXaWBF5+KLYdEitlQfyOu2d/KbH5zDm55t4z9fexLHX3E/f3zSLm9r85hHGhx1qrQ9pMFTHcOjoGcbGWPuBO7cy/6zJtnWC5wyzXUjX9fFz8DAQNQhBMPppzOYg97HqjhyoJ26/RbxvRNXcc9h6/ji7X/htGv/yHsPO4AvHLea/SsXRB3tnLE2j3mkwXFsbCzqEAInDXmEdHiqY3iIM8A3Waxbt85s2rRp+gNnweDgoLVrSzzyzF95z5UPcMUpr+HdzfUT24dHc3zn/zq59ndPUj6/lM8dewh/9/qDKC3Z21I+8cbmPHrY7rh+/XpyuRz3339/1KEEiu159EiDpzrODRFpMcasK+RYfTCjj5aWlqhDCIzOviwAu/qe3GN7eVkpn3vHIfzqn9/Ea2r35aKfb+a9V26kreeFKMIsCjbn0SMNjnFZijxI0pBHSIenOoaHFi8+qqqqog4hMDozgyyYV0LDK/ebdP/Kmkp+8k9v4PL3N/HcwC5O/O7v+fdfbOaF4eSNO7A5jx62O15++eV84QtfiDqMwLE9jx5p8FTH8ChozEuaqK6ujjqEwOjMZGnYv4Ka/ZdMeYyIcNJhB/CWQ2q49O4n+PEfn+bOtue58PjVnNhUy96fChEfbM6jh+2O3qqztpMGR0iHpzqGh7a8+Ojq6oo6hMDo7MuyamlFQY77ls/nyyeu4ZcfO4raqoWcd3Mrp3//QbZksiFEOndszqOH7Y733HMPt9xyS9RhBI7tefRIg6c6hocWLz4aGxujDiEQdo6M8dzAMI1LK2fkuLZuX3527pF85aQ1tD33Au/81u/4r18/zvCof33BeGFrHvOx3fGrX/0qt912W9RhBI7tefRIg6c6hocWLz62bt0adQiB4LWYrKypmLFjaYlwxuHLue8z63nXobV89/+6eNtlv+Xe9r4gQi0KtuYxnzQ4joyMRB1C4KQhj5AOT3UMDy1efGSzyegWmSmdbvGyqqZi1o77Vy7gm+9v4r//6XAWzi/lH6/fxNk/3sRzA8PFDLUo2JrHfNLgmMvFu4WvGKQhj5AOT3UMDy1efDQ3N0cdQiB0ZgYpKy3hoFcsmrPjEQ3V3PXJN/Evxx7C7zq3ccylv+Xq33axOxefxwzYmsd80uBo+5oZkI48Qjo81TE8tHjxEZc57MWmsy/Liv0XM6+0pCiOZfNKOGd9A/d8+miOXLmEr//qcY771v08GJPHDNiax3zS4KjrvNhDGjzVMTy0ePERl2lgxaYzM8iqpc5fscV0rNtvEd//4Dq+d+Y6hkZzvP/aP/LpW1rZno12rIKteczHdsdrrrmGL3/5y1GHETi259EjDZ7qGB5avPiwsZl6aHSMnr8Os6qmAgjG8W2vXspvPv1mzl3fwO1/3spbL/0tNz34NOPj0Tx+wsY8+rHd8eCDD+bQQw+NOozAsT2PHmnwVMfw0OLFR3d3d9QhFJ0nt+3EGCaKl6AcF5XN4/PHOo8ZWL2skgt+tpn3XPUAm58L/zEDNubRj+2Ot99+Oz/5yU+iDiNwbM+jRxo81TE8tHjxsXr16qhDKDqdGWfcwKqlTvEStOPKmkr++58O57L3v5bn/jrEu7/ze774y7/w4q7wHjNgYx792O546aWXcscdd0QdRuDYnkePNHiqY3ho8eIjLlVlMenoyzK/VFhevRgIx1FEeM9hddz7mfWc/oblXP+Hbt566W/5RetzhPEkcxvz6CcNjrt27Yo6hMBJQx4hHZ7qGB5avPgYHo7fmiVzpbMvy6uWLGZ+qZPuMB33LZ/PV05awy8+diSv3Gch//w/rfz9Dx6ka1uwawXYmEc/aXAcH4/P9PugSEMeIR2e6hgeWrz4iMsc9mKyJTPIqpqXBllF4XhoXRU//9iRfOXE1/Bozwu88/L7ufTuJ9i1O5hFyGzMo580OMZlcGCQpCGPkA5PdQwPLV58xGUOe7HYtTvHMzuGWOkO1oXoHEtLhDOOqOfezxzN8Ycu49v3beFtl/2W/3s8U/R72ZbHyUiDo67zYg9p8FTH8NDixUdNTU3UIRSVrm1Zxg00Ln3pL9ioHWsqF3LZ+5v4yT+9gbLSEv7huof5yA2b2FrExwxE7RgGtjvecMMNXHrppVGHETi259EjDZ7qGB5avPgoKyuLOoSi4j2Q0ZtpBPFxfGPDEn71z2/mc+84mN92bOOYb/6Wa4r0mIG4OAaJ7Y4HHnggy5cvjzqMwLE9jx5p8FTH8NDixUdPT0/UIRSVzr4spSVCvTvTCOLlWDavhI+9ZSW/+dTRvLGhmkt+9TjHX3E/Dz21Y07XjZNjUNjuePPNN/PjH/846jACx/Y8eqTBUx3DQ4sXH2vWrIk6hKLSmRmkvnoRZfNeSnUcHQ98xSK+/8G/4XtnrmPnSI5Tr/kDn/1/f6Z/lo8ZiKNjsbHd8aqrruLee++NOozAsT2PHmnwVMfw0OLFR0dHR9QhFJXOvuwe410g3o7eYwbOWd/Azx95jr+99Lf85MFnZvyYgTg7Fos0OMZlWmaQpCGPkA5PdQwPLV585HLBTN2NgpGxHN39OyceC+ARd8dFZfP4F/cxA4e8spLzf9bGe2f4mIG4OxaDNDiGsaBh1KQhj5AOT3UMDy1efKxduzbqEIrGU9t3Mm5gpa/lJSmOq5ZW8j9nH843T30tPXmPGRgs4DEDSXGcC2lwXLx48fQHJZw05BHS4amO4aHFi4/W1taoQyganX3uTCNfy0uSHEWE976ujns/vZ6/e8NBE48ZuP3PW/f6V3mSHGdLGhyz2WBXYo4DacgjpMNTHcNDixcfy5YtizqEotHZN0iJwIr99/zrNYmO+y6az1dPWsvPzz2Spfss5BP//Qhn/OAhnpziMQNJdJwptjveeuutXH311VGHETi259EjDZ7qGB5avFhMZyZLffViFswrjTqUovHaA53HDHz5xNfw52cHOPby+/lmgI8ZUKJjyZIl7LffflGHoShKDNHixUdvb2/UIRSNzkx2j8cCeCTdsbREOPOIeu797NEct/aVXHHfFt5+2e/4vycycNNNUF9P70c/CvX1zntLSXoep+O6667jRz/6UdRhBI7tefRIg6c6hocWLz6ampqiDqEojI6N07195x4r63rY4lhTuZDLTzuMn/zTG5hfKvzDjx7mnJ89ztYdO2lqbYWnn4azz7a2gLElj1Nx3XXX8fvf/z7qMALH9jx6pMFTHcNDixcfbW1tUYdQFJ7u38nYuNnjadIetjh6TDxm4NFfct/ywzjmw1fxxePO4Rer38zG/VfxxH9+h+3ZEXIzXCsm7tiWx8nYuXNn1CEEThryCOnwVMfwmBd1AHGjtNSO8SEdfS9/ppGHLY75lM0r4WP/+z3e/cAv+OIxH+HnK4/k5wce+dIBX72HEoFXLC6jevECllQ6/1ZXlLGkYgFL3H+rKxZQvbiM/SsXsHB+vL9PNuZxgptugj/+EVmwwOn+u/hiOP30qKMKBKvzCE4uL7iA0gMOgOee01wmnLg4avHio7GxMeoQikJnZhARaNj/5cWLLY4v46CDOPDpp/nBbV/myWUHMj5i2L64iv7lK+n/z8vYPjjC9p2jbB8coX/nKI/2DLA9O0p2ZGzSyy0uK6XaLWycf92vF5expHKBUwS5Rc++5fMpKZFQda3N4003Od19IyOU53Lw4ovOe7DrQ8/9UG/cuRMWL7bzQ93L5dAQjdks9PfbmUsXa/9P5hEXRy1efGzevJn169dHHcac6cxkOegViyZtPbDF8WVcfPHEL8pnDm5g/YYNrNy1Ay75VziifsrTdu3OsT07Qn92lP6dI2wfHGW7+2//Tmf7szuGeOSZAXbsHGGy3qd5JeK06uS34vjeOy07ZVRXlM1tBpj7obf5Va9i/VNPJepDLzduGBnLsWv3OLt259i1O8fImPf1OLvGcoxceQsjy/+GzDOPsnPRIm484FBKzDglP7iTkoPfTIkIJYLzb0ne1xP/CiUlzhpBpd57wT3W+VpEKM07VwT3fd5+91xxzy3N21fiHi9593Xeu1+754lMUdDmfahvXr+e9Rs2FPShboxh3MC4MYwbg5n42vne7m3/+Lh56WvjO3acieNzE+fmn7fnvXPe/vGXru+/97gxjH/vF4yvOAIjJZQsK+fku38JQ0NwwQWJ+ZmdCdb+bs0jLo4FFS8isgz4OnAcUAk8CZxjjPntXs4R4J+BjwKvAnYA1xtj/jXvmDLgQuAMoBboA75hjLliVjZFoK6uLqpbF5UtfdmXLU7nYYvjy/B+GV5wAXU9PbB8eUEf7Avnl1K33yLq9ls07S1y44aBoVH63Racl1pynCJne3aE7dlRntq+k+3ZEXbtHp/0OpUL500UOF5Rs8TXylNdUcaSxQvYp3zeSx+CeR96dfPmvTQoOd+/QMZy4+wam7yIGMl/P/bStl35x+yxfc9te17zpWN25woYd/Qmx2d89y4ALpy/8KV9tz46I8eo8RczE4VUtoySD/+AEjOOKSlB1v4T41LCeEsppuPXeQWAUxTk3AIicRz+wYkvv7Txey9tf+aZCIIJHmt/t+YRF8dpixcRqQI2Ar8Hjge2ASuAzDSnXgqcAHwOaAP2Bfyr2/wPUAecDXQCS4HygqMPgNHR0ShvXxR258Z5cnuWv11dM+l+Gxyn5PTT4fTTGX3sMXj1q4t++dISccbFVCx42QMvJ2NodGyiJccrbvrdAsdr7enaluWh7lH+OjTKZIsGzy+Vl8bpPPwc1es/wv5DA+zaZxH7LvsrI/MWMHJbK7sWrn1ZYZFfVIz4ioqxOXwazi8VFs4rZcH8UhbOL2Hh/FIWzHP+XTi/hKry+SyYXzL1Me6/3jETX88vZcG738XCZ7tZuHuU7oZ6VnV2YqSE3IEHMr7xgYnWhJyvRSA3vmdrQ87XepDL3zc+favF+B4tC/n79mzFyC8unHP2bN3I7dHa4cZ5+eUYhHEpof8Vr6B6xw5KzDiCoeS88/JahKZuZZL8VqUpWo/8+/0tRHse690nf59vf8kULVN7nPfSvUuPfjPS00OJMfQtz/v1f9BBs/7ZizNW/251iYtjIS0vnwd6jTFn5m17am8niMjBwCeAQ40x7Xm7Hsk75u3AW4EGY8x2d3N3IUEHSSaT4dUBfOiFydP9Q+zOmSlbXmxwnI64OC4qm8dB1fM4qHr6Vp2x3Dg7hkbzipyXWnKcgmeEfimjc/lati+qYnReGQBlY6MsHBtlweMZp0jwioF5JSwum0f14hKngJiXXyy8vOBw3u/tGGfbgnmllAY5vudz58DZZ3Pl0BAdO6u4fOcALFoEF3wOCmgdSwQfv9tpNQM2eN1G4LQWnnBtdHEVm/M/PdFS2LnkNc62RYucFlELicvvnSCJjaNx/zqY6gU8BnwTuBmntaUV+Dggeznn88ATwKdwupi6geuBmrxjrgTuAb4G9OC0vFwBVEwXU3NzswmKF198MbBrh8Wv2raa5f9yh3n02YFJ99vgOB3WOi5fbgyYcTDbql5hcogx4Gy3iRtvNEcvWGCOKi113G68MeqIisuNNxqzaJExYF6srHRyuGiRfZ7GOE7LlzueNuYyD2t/7+QRpCOwyUzz+e+9Cml5WQGcC1yGM+6lCfi2u+87ezlnOXAacBZggG8At4vIEcaYcfeYo4AR4H1AlXvdWuBk/wVF5Gyc7iVqa2vZsGEDq1evpru7m+HhYZqbm2lpaaGmpoaysjJ6enpYs2YNHR0d5HI51q5dS2tr68RzGXp7e2lqaqKtrY3S0lIaGxvZvHkzO3bs4JBDDiGTyUxcs7y8nPr6etrb26mvr2dwcJD+/v6J/RUVFdTW1tLR0UFDQwP9/f0MDAxM7K+qqqK6upquri4aGxvZunUr2Wx2Yn91dTWVlZV0d3cXxek3D/0FgKqSXWzY8Ah1dXWMjo5OON12222sXr06UU7+PPmd/HkaGBiYiNsWp/r6egb/9V/p/+lPaf7jH7njpHezpq2N2h076DjvPBqefTaZTpP97L3lLQwccghjY2O03nij4zQ4mGyn/J+917yGgUsuofmqq7jt8MNpevZZqk87ja4DDqBx69ZkOk31s3fAATQ+8AAbNmygtrbW2b9hQ7KdpvjZ6+vr4w1veINVTv483XPPPRxwwAGBOM2I6aobYBR4wLfta0D7Xs651i1YGvO2Nbrb3uC+vxsYBvbNO+bt7jFL9xZTkC0vf/zjHwO7dlh8/Cd/Mkf9x71T7rfBcTqsdnT/kv3jG95g9V+yRx99tDnssMOiDiNwrP5ZzSMNnuo4Nyhyy0svTtdRPu04M4n2ds6YMaYjb1snkAMOAh50j3nOGPOC77q4x/QVEFvRqa+vj+K2RaWzb3DSlXU9bHCcDqsd3UHJ9X19sHRp1NEEysKFC6c/KOFY/bOaRxo81TE8Cnk8wEbgYN+2RuDpac6ZJyINedtWAKV5520EakUkf1Spt/rN3q4dKO3t7dMfFGPGcuM8uX3nlIN1IfmOhaCOdjA0NBR1CIGThjxCOjzVMTwKKV4uAw4XkQtEZKWInAJ8Eviud4CIXCIi9+adcw/wJ+CHInKYiBwG/BCnxWWTe8xPgH7gRyLyGhE5EvgWcKsxZoadX8UjLlXlbHn2r8OMjo1P+jRpj6Q7FoI6Jp8NGzbw85//POowAsf2PHqkwVMdw2Pa4sUY8zBwEnAqsBm4GLgIZ7aQxzKgIe+ccZw1XjLA74Bf48woOtHdhzEmCxyDs/7Lw8AtwG+BD83RaU4MDg5Gefs509nnxL9qL2uQJN2xENTRDtTRHtLgqY7hUdAKu8aYO4E797L/rEm29QKnTHPdJ3AG6caG/v7+qEOYE50Z54GMe2t5SbpjIahj8vnGN75BV1cXV111VdShBIrtefRIg6c6hoc+28hHc3Nz1CHMic6+QQ6oKqdiwdSpTbpjIahj8rnjjjvI5XJRhxE4tufRIw2e6hgehYx5SRUtLS1RhzAnOjPZvba6QPIdC0Ed7SAuTdRBkoY8Qjo81TE8tHjxUVGx9w/+OJMbN2zJTP1ARo8kOxaKOtpBaekcnr6dENKQR0iHpzqGhxYvPmpra6MOYdb0/HWIkbHxaR8YmGTHQlFHO1iwYEHUIQROGvII6fBUx/DQ4sVHR0fH9AfFlM4+d7Du0r1Xxkl2LBR1TD7l5eWpGPNiex490uCpjuGhA3Z9NDQ0TH9QTClkphEk27FQ1DH5/OpXv+LZZ5+NOozAsT2PHmnwVMfw0JYXH3GZBjYbOjODvHKfheyzcP5ej0uyY6Goox2ooz2kwVMdw0OLFx8DAwNRhzBrOvuyrJqmywiS7Vgo6ph8vvKVr3DFFVdEHUbg2J5HjzR4qmN4aLeRj7jMYZ8p4+5Mow+8/qBpj02q40xQx+Rz7733pmLMi+159EiDpzqGh7a8+IjLHPaZ8tzAMMO7cwW1vCTVcSaoox3oOi/2kAZPdQwPLV58VFVVRR3CrNjiDtadbo0XSK7jTFBHO5g3z/7G4TTkEdLhqY7hocWLj+rq6qhDmBUd3gMZa/a+xgsk13EmqKMdzJ+/98HnNpCGPEI6PNUxPLR48dHV1RV1CLOiM5OlpnIB+y6a/pd9Uh1ngjomn+rq6lQUL7bn0SMNnuoYHva3yc6QxsbGqEOYFZ2ZwmYaQXIdZ4I6Jp/bbruNrVu3Rh1G4NieR480eKpjeGjLi48k/rI0xrClb7CgLiNIpuNMUUc7UEd7SIOnOoaHFi8+stls1CHMmN4XdrFzNDftyroeSXScKeqYfL7whS9w2WWXRR1G4NieR480eKpjeGi3kY+4zGGfCd5g3ekeyOiRRMeZoo7J5w9/+IOu82IRafBUx/DQlhcfcZnDPhNmMk0akuk4U9TRDnSdF3tIg6c6hocWLz7iMg1sJnT2ZVlSUcZ+i8sKOj6JjjNFHe0gDbON0pBHSIenOoaHFi8+KisL63qJE52ZwYLHu0AyHWeKOtpBaWlp1CEEThryCOnwVMfw0OLFR3d3d9QhzAhjDJ192YLHu0DyHGeDOiafurq62PyiDBLb8+iRBk91DA8dsOtj9erVUYcwI/peHGFwZKzg8S6QPMfZoI7J58Ybb6Svry/qMALH9jx6pMFTHcNDW158xKWqLJTOjDOgcWWBa7xA8hxngzragTraQxo81TE8tOXFx/DwcNQhzIjOPnemUYGr60LyHGeDOiaf8847j56eHm699daoQwkU2/PokQZPdQwPLV58xGUOe6F0ZgbZb9F8qgucaQTJc5wN6ph8WltbdZ0Xi0iDpzqGh3Yb+YjLHPZC6ezLsmppJSJS8DlJc5wN6mgHus6LPaTBUx3DQ4sXHzU1NVGHUDDGGOeBjDMYrAvJcpwt6mgHZWWFtygmlTTkEdLhqY7hocWLjyT9styWHeGF4d0zLl6S5Dhb1NEOZtKimFTSkEdIh6c6hocWLz56enqiDqFgXhqsO7O1MJLkOFvUMfk0Njay//77Rx1G4NieR480eKpjeOiAXR9r1qyJOoSC6XQfyDiTmUaQLMfZoo7J59prr2X79u1RhxE4tufRIw2e6hge2vLio6OjI+oQCqYzk2Xf8vnsX7FgRuclyXG2qKMdqKM9pMFTHcNDW158JGlqpjdYd6bjApLkOFvUMfmcffbZPP/88/zyl7+MOpRAsT2PHmnwVMfw0JYXH2vXro06hILZksnOuMsIkuU4W9Qx+XR0dLBjx46owwgc2/PokQZPdQwPLV58tLa2Rh1CQWzPjrBj5yirZvBYAI+kOM4FdbSDbDYbdQiBk4Y8Qjo81TE8CipeRGSZiFwvIttEZJeIPCYiR09zjojIeSLyuIiMiEiviHx9imOPEpExEdk8G4lismzZsqhDKIjZPBbAIymOc0Ed7SAu0zKDJA15hHR4qmN4TDvmRUSqgI3A74HjgW3ACiAzzamXAicAnwPagH2Bl1mLyH7Aj4F7gQMKDz3dbHEfyDiblhdFURRFSTKFtLx8Hug1xpxpjHnIGPOUMeZeY0z7VCeIyMHAJ4ATjTG/MMY8aYx5xBhz1ySH/wC4HvjDrAyKTG9vb9QhFERnJkvlgnks3WdmM40gOY5zQR2TT1NTEwcddFDUYQSO7Xn0SIOnOoZHIcXLScCDInKziGREpFVEPi57n+JyIvAkcKyIPCki3W630x7rCovIucBS4KuzFSg2TU1NUYdQEB19g6xaOvOZRpAcx7mgjsnn8ssv5/vf/37UYQSO7Xn0SIOnOoZHIcXLCuBcnGLkHcC3gK8DH5vmnOXAacBZwBnAIcDtIlICICJrgX8H/t4YE4+5V0BbW1vUIRTElkx21l1GSXGcC+poB+poD2nwVMfwKGSdlxJgkzHmC+77R0RkFU7x8p29nLMAOMMY0wEgImcATwB/IyKtwM3AZ40xTxUSqIicDZwNUFtby4YNG1i9ejXd3d0MDw/T3NxMS0sLNTU1lJWV0dPTw5o1a+jo6CCXy7F27VpaW1snBhv19vbS1NREW1sbpaWlNDY2snnzZl588UUee+wxMpnMxDXLy8upr6+nvb2d+vp6BgcH6e/vn9hfUVFBbW0tHR0dNDQ00N/fz8DAwMT+qqoqqqur6erqorGxka1bt5LNZif2V1dXU1lZSXd3d0FOm9oeZ3t2lLp9StmwYcO0TnV1dYyOjk44dXd3U1ZWFiunmebJ7+TPUzabpa2tzSonf566u7spLy+3yik/Tx/84AcZGxvjsssus8Zpsjx1d3dTWVlpldNkeert7WXDhg1WOfnz1N/fT3d3t1VO/jw999xze+SxmE4zQYwx0xUNTwO/McZ8OG/bGcDVxpjFU5zzJeB8Y8z8vG0C7AY+ADwMPAXkt7iUAOJuO84Yc/dUMa1bt85s2rRpGrXZsX37dpYsWRLItYvFQ0/t4NRr/sB1//A3rD945k/4TILjXFHH5LN+/Xp2797Nxo0bow4lUGzPo0caPNVxbohIizFmXSHHFtJttBE42LetEXh6mnPmiUhD3rYVQKl73nPAWqAp73U1sMX9+oEC4gqEzZsjn609LR0TzzSaXbdREhznijrawc6dO6MOIXDSkEdIh6c6hkch3UaXAQ+IyAU4XT2HAZ8EzvcOEJFLgNcbY97qbroH+BPwQxE5z912OfAgThfUOLDHd0BEMsCIMSbS70xdXV2Uty+ILZksi8tKqd134azOT4LjXFFHO1iwYOaz6ZJGGvII6fBUx/CYtuXFGPMwzoyjU3EKjouBi4Ar8w5bBjTknTOOs8ZLBvgd8GugB2fq9HiRYg+E0dHRqEOYls7MICuXVs5qphEkw3GuqKMdTNetbQNpyCOkw1Mdw6OgFXaNMXcaY15rjFlojGk0xlxh8n6rGGPOMsbU+87pNcacYoypNMbUGGNON8b07eUeXzTGRP6s7ZkOGoqCzj7ngYyzJQmOc0Udk88RRxzBqlWrog4jcGzPo0caPNUxPPSp0j6am5ujDmGvvDC0m8zgyJyKl7g7FgN1TD6XXHIJg4ODUYcROLbn0SMNnuoYHvpgRh8tLS1Rh7BXOt3HAjTOcrAuxN+xGKijHaijPaTBUx3DQ1tefJSXl0cdwl7pzDgPZFw5h5aXuDsWA3VMPu973/vYsWMH69evjzqUQLE9jx5p8FTH8NDixUd9fX3UIeyVzr4s5fNLOaBq9j9AcXcsBuqYfPr7+2MzODBIbM+jRxo81TE8tNvIR3v7lM+bjAWdmUFW1lRQUjK7mUYQf8dioI52MDQ0FHUIgZOGPEI6PNUxPLR48RGXqnIqOvuyrFo6+y4jiL9jMVBHO1i4cHZrGSWJNOQR0uGpjuGhxYuPOM9ueHHXbp5/cdesH8joEWfHYqGOdpDLxeaZrYGRhjxCOjzVMTx0zIuP/v7+qEOYki3uYN25TJOGeDsWC3VMPm9961t56qmCntuaaGzPo0caPNUxPLR48RGXOeyTsaXPLV7m2G0UZ8dioY7J56KLLorNX3lBYnsePdLgqY7hod1GPuIyh30yOvoGWTCvhLr9Fs3pOnF2LBbqaAfqaA9p8FTH8NCWFx8VFXNr1QiSzkyWlTUVlM5hphHE27FYqGPyeec738kLL7zAAw9E9pD5ULA9jx5p8FTH8NCWFx+1tbVRhzAlWzJze6aRR5wdi4U6Jp/h4eGoQwgF2/PokQZPdQwPLV58dHR0RB3CpGRHxnhuYJhVc3gsgEdcHYuJOtpBGtZ5SUMeIR2e6hgeWrz4aGhoiDqESdlShMcCeMTVsZioox3EZSnyIElDHiEdnuoYHlq8+IjLNDA/nX1zfyCjR1wdi4k62sHu3bujDiFw0pBHSIenOoaHDtj1MTAwEHUIk7Ilk6VsXgkH7jf3v0Tj6lhM1DH5nHDCCXR1dUUdRuDYnkePNHiqY3iIMSbqGGbMunXrzKZNmwK59uDgIJWVc2/dKDYfuu5htg4M87/nvXnO14qrYzFRRztQR3tIg6c6zg0RaTHGrCvkWO028hGXOex+OjODRRmsC/F1LCbqaAfqaA9p8FTH8NBuIx9VVVVRh/AyhkbHeHbHMKc2H1iU68XRsdioY/JZv3492WyWoFpZ44LtefRIg6c6hoe2vPiorq6OOoSX0ZXZCcz9sQAecXQsNupoB/Pnz486hMBJQx4hHZ7qGB5avPiI4wDBzowz02jlHJ8m7RFHx2KjjnaQhoXq0pBHSIenOoaHFi8+Ghsbow7hZXRmsswvFZZXz+2ZRh5xdCw26mgHixYV52c+zqQhj5AOT3UMDy1efGzdujXqEF5GZ98gr1qymPmlxUlXHB2LjTrawcjISNQhBE4a8gjp8FTH8NABuz6y2WzUIbyMzkyWNQfsW7TrxdGx2Khj8jn11FNjsxR5kNieR480eKpjeGjx4qO5uTnqEPZg1+4cz+wY4j2HHVC0a8bNMQjUMfmce+65DA4ORh1G4NieR480eKpjeGi3kY+4zGH36NqWxRhYVaTBuhA/xyBQx+QzNDTExo0bow4jcGzPo0caPNUxPLTlxUdcpoF5dPY5TXTFmiYN8XMMAnVMPscddxw7d+7k2GOPjTqUQLE9jx5p8FTH8NCWFx9xW9q5MzPIvBKhvnpx0a4ZN8cgUEc7KC0tjTqEwElDHiEdnuoYHlq8+Oju7o46hD3o7MtSv2QxZfOKl6q4OQaBOtrBrl27og4hcNKQR0iHpzqGhxYvPlavXh11CHuwJZNlVU3xuowgfo5BoI52kIZ1XtKQR0iHpzqGhxYvPuJSVQKMjOXo7t9Z9OIlTo5BoY52oC0v9pAGT3UMDx2w6yNOy5E/uW0n44aiPU3aI06OQaGOyeess87i8ccfjzqMwLE9jx5p8FTH8NDixUdc5rCDszgdFHemEcTLMSjUMfmcddZZus6LRaTBUx3DQ7uNfMRlDjvAlr5BSgRetaR4M40gXo5BoY7JZ/v27dx3331RhxE4tufRIw2e6hgeBRUvIrJMRK4XkW0isktEHhORo6c5R0TkPBF5XERGRKRXRL6et/+9InK3e81BEXlQRN49V6G5UlNTE3UIE3RmstRXL2bBvOJOF42TY1CoY/I5+eSTufjii6MOI3Bsz6NHGjzVMTym7TYSkSpgI/B74HhgG7ACyExz6qXACcDngDZgX2BZ3v6jgfuAC4EdwOnAz0RkvTHm/hlZFJGysrKobv0yOvoGWVnkwboQL8egUEc7EJGoQwicNOQR0uGpjuFRSMvL54FeY8yZxpiHjDFPGWPuNca0T3WCiBwMfAI40RjzC2PMk8aYR4wxd3nHGGP+2RjzdfeaW4wxXwJagJPm6DQnenp6orz9BKNj43T3D9FY5MG6EB/HIFFHO0jDU6XTkEdIh6c6hkchxctJwIMicrOIZESkVUQ+Lnv/k+hE4EngWBF5UkS63W6n6dqbKoG/FhZ6MKxZsybK20/Q3b+T3Lgp+mBdiI9jkKijHSxeXNzxXnEkDXmEdHiqY3gUUrysAM7FKUbeAXwL+DrwsWnOWQ6cBpwFnAEcAtwuIpPeU0Q+BtQBNxQYeyB0dHREefsJvGcaBdFtFBfHIFFHO4jLtMwgSUMeIR2e6hgehUyVLgE2GWO+4L5/RERW4RQv39nLOQuAM4wxHQAicgbwBPA3wIP5B4vI+4D/At5vjHl6sguKyNnA2QC1tbVs2LCB1atX093dzfDwMM3NzbS0tFBTU0NZWRk9PT2sWbOGjo4Ocrkca9eupbW1lWXLnGE3vb29NDU10dbWRmlpKY2NjWzevJmBgQEee+wxMpnMxDXLy8upr6+nvb2d+vp6BgcH6e/vn9hfUVFBbW0tHR0dNDQ00N/fz8DAwMT+qqoqqqur6erqorGxka1bt5LNZif2V1dXU1lZSXd394TT3Y++QInAc+1/QgaWzsmprq6O0dHRCafOzk5KS0tDdypmnvxO/jy9+OKLtLW1WeXkz1NnZydlZWVWOeXn6c1vfjMjIyO0trZa4zRZnjo7O1m0aJFVTpPl6ZlnnmF0dNQqJ3+etm3bRnd3t1VOk+UpP4/FdJoJYozZ+wEiTwO/McZ8OG/bGcDVxphJ23RF5EvA+caY+XnbBNgNfMAY8//ytp8M/Bg40xhzayFBr1u3zmzatKmQQ2fMwMAAVVVVgVx7Jnzspj/xl60vsOFzbyn6tePiGCTqaAfqaA9p8FTHuSEiLcaYdYUcW0i30UbgYN+2RmDSFpK8c+aJSEPethVAaf55InIqTjfRWYUWLkHT2toadQiA8zTplTXBPL0zLo5Boo7J59lnn+Xuu++OOozAsT2PHmnwVMfwKKR4uQw4XEQuEJGVInIK8Engu94BInKJiNybd849wJ+AH4rIYSJyGPBDnO6iTe45pwE3Af8K/E5EXum+XlEUs1niNXFFye7cOE9t3xnIYF2Ih2PQqGPyOeOMM/jGN74RdRiBY3sePdLgqY7hMW3xYox5GGfG0anAZuBi4CLgyrzDlgENeeeM46zxkgF+B/wa6MGZOj3uHvZRnDE3lwO9ea+fzsHHCp7u38nunCn6AxkVRVEUxQYKWmHXGHOnMea1xpiFxphGY8wVJm+wjDHmLGNMve+cXmPMKcaYSmNMjTHmdGNMX97+9cYYmeS1vlhys6G3tzfK2wMvzTQKYo0XiIdj0KijHYyOjkYdQuCkIY+QDk91DA99tpGPpqamqEOgM5NFBBr2D6blJQ6OQaOOdlBRYX/rYxryCOnwVMfw0OLFR1tbW9Qh0JnJUrdfOeVlxX2mkUccHINGHe1g586dUYcQOGnII6TDUx3Do5B1XlJFaWkwBcNM6OwbZFVAM40gHo5Bo47J5zOf+Qzt7VM+hcQabM+jRxo81TE8tHjx0djYGOn9x3LjPLltJ0cfvH9g94jaMQzUMfm8613v4ogjjog6jMCxPY8eafBUx/DQbiMfmzdvjvT+z+wYYjQ3HmjLS9SOYaCOyeeJJ57grrvumv7AhGN7Hj3S4KmO4aEtLz7q6uoivX9nxplpFOQ06agdw0Adk89HPvIRhoeHOfPMM6MOJVBsz6NHGjzVMTy05cVH1FMzt7jFS0OAxUvUjmGgjnYw3eNLbCANeYR0eKpjeGjx4mOmD4cqNh19gxxQVU7FguAaxaJ2DAN1tIO4/KIMkjTkEdLhqY7hocWLj+bm5kjv39mXDeyxAB5RO4aBOtpBZWVwY7/iQhryCOnwVMfw0OLFR0tLS2T3zo0burZlA38sQJSOYaGOdjA4OBh1CIGThjxCOjzVMTx0wK6P8vLyyO7d89chRsaCnWkE0TqGhTomnwsvvDAV67zYnkePNHiqY3ho8eKjvr4+snt3uM80Whlwt1GUjmGhjsnnmGOOYe3atVGHETi259EjDZ7qGB7abeQjyr/0OjNOE3nQ3UZp+GtWHZNPa2srt99+e9RhBI7tefRIg6c6hocWLz6irCq39GVZtu9CKhfOD/Q+camcg0Qdk895553H97///ajDCBzb8+iRBk91DA8tXnxEOUCwM5NlZcCtLpCOQZDqaAe5XC7qEAInDXmEdHiqY3ho8eKjv78/kvuOjxu2ZLKBD9aF6BzDRB3tYPfu3VGHEDhpyCOkw1Mdw0OLFx9RzWF/bmCY4d05GgMerAvxmacfJOpoB7rOiz2kwVMdw0OLFx9RzWGfGKwbQvESl3n6QaKOdhCXJuogSUMeIR2e6hgeOlXaR0VF8MXDZHR606T3D/4vzagcw0Qdk8/Xvva12MxsCBLb8+iRBk91DA8tXnzU1tZGct/OTJaaygXsuyjYmUYQnWOYqGPyeeMb3xibmQ1BYnsePdLgqY7hod1GPjo6OiK5b2ffYChdRhCdY5ioY/J54IEH+OlPfxp1GIFjex490uCpjuGhxYuPhoaG0O9pjKEzpJlGEI1j2Khj8jn//PO56aabog4jcGzPo0caPNUxPLR48RHFNLCtL+xiaDQXWstLXKa6BYk62oFOlbaHNHiqY3ho8eJjYGAg9Ht29nmPBQin5SUKx7BRRzsYGxuLOoTASUMeIR2e6hgeWrz4iGIOuzfTKOhnGnnEZZ5+kKijHeg6L/aQBk91DA8tXnxEMYe9MzPIkooF7Le4LJT7xWWefpCoox3oOi/2kAZPdQwPnSrto6qqKvR7OoN1w5s7H4Vj2Khj8rn88st54oknog4jcGzPo0caPNUxPLR48VFdXR3q/YwxbOnL8p7XHRDaPcN2jAJ1TD5NTU3WO4L9efRIg6c6hod2G/no6uoK9X7Pv7iLwZGxUFtewnaMAnVMPvfccw+33HJL1GEEju159EiDpzqGhxYvPhobG0O938Rg3aXhDUwM2zEK1DH5fPWrX+W2226LOozAsT2PHmnwVMfw0OLFx9atW0O9X2cm3JlGEL5jFKijHYyMjEQdQuCkIY+QDk91DA8tXnxks9lQ77clM8grFpdRXbEgtHuG7RgF6mgHuVwu6hACJw15hHR4qmN4aPHiI+w57J19WVaG2OoC8ZmnHyTqaAe6zos9pMFTHcNDixcfYc5hN8bQ0TcYapcRxGeefpCoox3oOi/2kAZPdQyPgooXEVkmIteLyDYR2SUij4nI0dOcIyJynog8LiIjItIrIl/3HXO0iLS413xSRD46F5liEOY0sG2DI7y4a4zGEAfrQnymugWJOiafa665hi9/+ctRhxE4tufRIw2e6hge067zIiJVwEbg98DxwDZgBZCZ5tRLgROAzwFtwL7Asrzrvgq4C/gh8PfAUcCVIrLNGBPZFIMwm6mjGKwL6WiKV8fkc/DBB7NgQXhjwaLC9jx6pMFTHcOjkJaXzwO9xpgzjTEPGWOeMsbca4xpn+oEETkY+ARwojHmF8aYJ40xjxhj7so77KPAVmPMJ4wx7caY7wHXA5+di9Bc6e7uDu1e3gMZV4b0NGmPMB2jQh2Tz+23385PfvKTqMMIHNvz6JEGT3UMj0KKl5OAB0XkZhHJiEiriHxcRGQv55wIPAkc63YHdbvdTjV5xxwB3O0779fAOhGZPxOJYrJ69erQ7tWRybJv+Xz2D3GmEYTrGBXqmHwuvfRS7rjjjqjDCBzb8+iRBk91DI9CipcVwLk4xcg7gG8BXwc+Ns05y4HTgLOAM4BDgNtFxLvnK4E+33l9OF1ZSwoLv/iEWVVu6cvSuLSCvdeBxSculXOQqKMd7Nq1K+oQAicNeYR0eKpjeBTybKMSYJMx5gvu+0dEZBVO8fKdvZyzADjDGNMBICJnAE8AfwM8ONNAReRs4GyA2tpaNmzYwOrVq+nu7mZ4eJjm5mZaWlqoqamhrKyMnp4e1qxZQ0dHB7lcjrVr19La2sqyZc6wm97eXpqammhra6O0tJTGxkY2b97Mjh07eOyxx8hkMhPXLC8vp76+nvb2durr6xkcHKS/v39if0VFBbW1tXR0dNDQ0EB/fz8DAwMT+6uqqqiurqarq4vGxka2bt3K4OAgT/SNclg1tLW1UVlZSXd3dyBOdXV1jI6OTji1tzs9fsV2ymazE/urq6tDdfLnaWBggLa2Nquc/Hlqb2+ntLTUKqf8PA0MDDA2NkZra6s1TpPlqb29nQULFljlNFmeurq69ojZBid/nvr6+li6dKlVTv48bdmyJTCnGdUExpjpioangd8YYz6ct+0M4GpjzOIpzvkScL4xZn7eNgF2Ax8wxvw/Efkd0GaM+VjeMacAPwEWGWN2TxXTunXrzKZNmwoSnCmDg4OhDEjanh1h3Vfv4d9OeDUfOupVgd8vn7Aco0Qdk8/69evJ5XLcf//9UYcSKLbn0SMNnuo4N0SkxRizrpBjC+k22ggc7NvWCDw9zTnzRKQhb9sKoDTvvD8Ab/Od9zacVp4pC5egCWsOe4c7WHdVyIN1IT7z9INEHe1A13mxhzR4qmN4FNJtdBnwgIhcANwMHAZ8EjjfO0BELgFeb4x5q7vpHuBPwA9F5Dx32+U43UVek8nVwMdF5HLgGuBInPExH5i1TRGoqamZ/qAisMWdJh32Gi8QnmOUqGPyueGGG+jo6Ig6jMCxPY8eafBUx/CYtuXFGPMwzoyjU4HNwMXARcCVeYctAxryzhnHWeMlA/wOZxZRD87U6XH3mKeA44A3A63ABcAno1zjBaCsrCyU+3T2ZalcOI+ayvDXsQjLMUrUMfkceOCBLF++POowAsf2PHqkwVMdw6OgFXaNMXcaY15rjFlojGk0xlxh8gbLGGPOMsbU+87pNcacYoypNMbUGGNON8b0+Y75rTHmdcaYBcaYVxljri6K1Rzo6ekJ5T6dGeexAGHPNILwHKNEHZPPzTffzI9//OOowwgc2/PokQZPdQwPfbaRjzVr1oRyny2ZLKtqohnYFZZjlKhj8rnqqqu49957ow4jcGzPo0caPNUxPLR48RFGH/uOnaNsz45GMlgXwnGMGnW0g+Hh4ahDCJw05BHS4amO4aHFi49cLhf4PTonZhpF0/IShmPUqKMdTLeUgw2kIY+QDk91DA8tXnysXbs28HtE9UBGjzAco0Yd7WDx4kmXkrKKNOQR0uGpjuGhxYuP1tbWwO+xJZNlcVkpy/ZdGPi9JiMMx6hRRzvIZrNRhxA4acgjpMNTHcOjkHVeUoW3lHGQdPQNsnJpZSQzjSAcx6hRx+Rz6623smXLlqjDCBzb8+iRBk91DA9teYmAzkyWxoi6jBQlKSxZsoT99tsv6jAURYkhWrz46O3tDfT6A0OjbBsciWymEQTvGAfUMflcd911/OhHP4o6jMCxPY8eafBUx/DQbiMfTU1NgV5/y8Rg3ege3hW0YxxQx+Rz3XXXMTY2FnUYgWN7Hj3S4KmO4aEtLz7a2toCvX5Hn1O8rIyw2yhoxzigjnawc+fOqEMInDTkEdLhqY7hocWLj9LS0kCv35kZZFFZKQdUlQd6n70RtGMcUEc7iGpQe5ikIY+QDk91DA8tXnw0NjYGev0tmSwrayooKYnul3LQjnFAHe2gvDy6Ij8s0pBHSIenOoaHFi8+Nm/eHOj1O/uykXYZQfCOcUAd7SAN3UZpyCOkw1Mdw0MH7Pqoq6sL7NovDO/m+Rd3RTpYF4J1jAvqmHzuuusuurq6og4jcGzPo0caPNUxPLTlxcfo6Ghg1/ZmGjVGOE0agnWMC+qYfBYtWhSb/vUgsT2PHmnwVMfw0OLFRyaTCezaWzLuAxkjbnkJ0jEuqGPyufLKK7n22mujDiNwbM+jRxo81TE8tNvIR3Nzc2DX7uzLsnB+CQfsF+0gxCAd44I6Jp9bbrklNk+wDRLb8+iRBk91DA9tefHR0tIS2LU7M1ka9q+gNMKZRhCsY1xQRzsYHByMOoTASUMeIR2e6hgeWrz4CHJqZmffIKti8EyjNEw/VUc7KCmx/1dUGvII6fBUx/Cw/zfDDKmvrw/kuoO7drP1hV2sWhrteBcIzjFOqKMdLFy4MOoQAicNeYR0eKpjeGjx4qO9vT2Q63Ztc9ariEPLS1COcUId7WBoaCjqEAInDXmEdHiqY3jogF0fQVWVnX3uTCNteQkFdUw+GzZsoLu7O+owAsf2PHqkwVMdw0NbXnwENUCwM5OlbF4JB71iUSDXnwlpGASpjnagjvaQBk91DA8tXnz09/cHct3OvsFYzDSC4BzjhDomn2984xtceeWVUYcROLbn0SMNnuoYHtpt5COoOeydmSyvO2i/QK49U+IyTz9I1DH53HHHHbrOi0WkwVMdw0NbXnwEMYd9aHSMnr8Ox2KwLsRnnn6QqKMdxKWJOkjSkEdIh6c6hocWLz4qKopfYHjPNFoV8TONPIJwjBvqaAdpeLZRGvII6fBUx/DQ4sVHbW1t0a/Z2ecVL9HPNIJgHOOGOtrBggULog4hcNKQR0iHpzqGhxYvPjo6Oop+zc5MlvmlwvIYzDSCYBzjhjomn/Ly8lSMebE9jx5p8FTH8NABuz4aGhqKfs0tmUFWLKlgXmk8asUgHOOGOiafX/3qVzz77LNRhxE4tufRIw2e6hge8fg0jRFBTAPrzGRZGZPxLhCfqW5Boo52oI72kAZPdQwPLV58DAwMFPV6w6M5ntkxFJuZRlB8xziijsnnK1/5CldccUXUYQSO7Xn0SIOnOoaHdhv5KPYc9q5tWYyBxpgM1oX4zNMPEnVMPvfee28qxrzYnkePNHiqY3hoy4uPYs9hn5gmHaOWl7jM0w8SdbQDXefFHtLgqY7hocWLj6qqqqJerzMzyLwSYXn14qJedy4U2zGOqKMdzJtnf+NwGvII6fBUx/AoqHgRkWUicr2IbBORXSLymIgcvZfj60XETPI61nfc34lIq4gMicjzInKjiLxyrlJzobq6uqjX6+jLUr9kMWXz4lMnFtsxjqijHcyfPz/qEAInDXmEdHiqY3hM+4kqIlXARkCA44HVwCeATAHXPxZYlve6L++6RwI3ANcDrwFOAl4N3DSD+ItOV1dXUa+3JZOlMUYzjaD4jnFEHZNPdXV1KooX2/PokQZPdQyPQtpkPw/0GmPOzNv2VIHX7zfGPD/FviOAHmPMZd41ReTbwLcLvHYgNDY2Fu1au3bneLp/J+96bTxWJPQopmNcUcfkc9ttt7F169aowwgc2/PokQZPdQyPQvoyTgIeFJGbRSTjdvN8XESkgHN/6p6zUURO9u3bCCwTkXeJwxLgNOCumSkUl2L+snxq+07GTbwG60JxHeOKOtqBOtpDGjzVMTwKaXlZAZwLXAZ8HWjipdaR70xxThb4LE6BMga8G7hZRD5ojLkRwBjzBxE5DaebqNyN5TfABye7oIicDZwNzrMVNmzYwOrVq+nu7mZ4eJjm5mZaWlqoqamhrKyMnp4e1qxZQ0dHB7lcjrVr19La2sqyZcsA6O3tpampiba2NkpLS2lsbGTz5s3s2LGDRYsWkclkJq5ZXl5OfX097e3t1NfXMzg4SH9//8T+iooKamtr6ejooKGhgf7+fgYGBuhbeCAAub8+x7PP5ujq6qKxsZGtW7eSzWYnzq+urqayspLu7u5AnOrq6hgdHZ1w2rx5M7lcblZO3v6qqiqqq6tj4+TP08DAAAsWLLDKyZ+nzZs34/1/sMUpP0+f+9znGBkZ4cILL7TGabI8bd68mXnz5lnlNFmeOjo6rHPy56mvr48lS5ZY5eTP0xNPPLHH/mI6zQQxxuz9AJFRYJMx5o15274GvMcYs7rgG4lcCRxljDnUff9qnGLlcuDXOGNi/gto9XVRvYx169aZTZs2FXrrGTE4OEhlZXHWZLn07ie4ckMXj335HSyYF5+n4xbTMa6oY/JZv349uVyO+++/P+pQAsX2PHqkwVMd54aItBhj1hVybCHdRr3AY75t7cBBM4zrQWBV3vsvAA8ZY/7LGPOoMebXOC08Z4hI3QyvXTSKOYe9sy/L8upFsSpcID7z9INEHe1A13mxhzR4qmN4FFK8bAQO9m1rBJ6e4b2acAohj0WAf/lM731k84qLOQ2sMzMYu/EuEJ+pbkGijnaQhtlGacgjpMNTHcOjkCLhMuBwEblARFaKyCnAJ4HvegeIyCUicm/e+w+6a7isFpGDReSzwMfYcybR7cCJInKOiKxwp05fAfzJGPNMMeRmQ7Gaw0bGcnT3D7GqJn5NiLY3a4I62kJpabxaLYMgDXmEdHiqY3hMW7wYYx7GmXF0KrAZuBi4CLgy77BlgP852RcCm4CHcWYRfShvWjTGmOuATwMfd697K9ABnDgrkyLR3d1dnOtsHyI3blgVszVeoHiOcUYdk09dXV1sflEGie159EiDpzqGR0Frbxtj7gTu3Mv+s3zvr8dZfG6660a+rouf1asLHoO8VzozTl99HFteiuUYZ9Qx+dx444309fVFHUbg2J5HjzR4qmN4xGfN+phQrKqysy9LicCK/ePzTCOPuFTOQaKOdqCO9pAGT3UMD/ufejZDhoeHi3KdLZksB71iEQvnx6/PvliOcUYdk895551HT08Pt956a9ShBIrtefRIg6c6hocWLz6am5uLcp2OvkFWxrDLCIrnGGfUMfm0traSy/knJNqH7Xn0SIOnOoaHdhv5KMYc9t25cZ7avjN2D2T0iMs8/SBRRzvQdV7sIQ2e6hgeWrz4qKmpmfM1nu7fyVhMZxpBcRzjjjraQVlZWdQhBE4a8gjp8FTH8NDixUcxfll29mWBeM40gnR8IKijHRT2/Ndkk4Y8Qjo81TE8tHjx0dPTM+drdPRlEYGG/ePZ8lIMx7ijjsmnsbGR/fffP+owAsf2PHqkwVMdw0MH7PpYs2bNnK/RmRnkwP0WUV4Wv5lGUBzHuKOOyefaa69l+/btUYcROLbn0SMNnuoYHtry4qOjo2PO19iSycbymUYexXCMO+poB+poD2nwVMfw0JYXH3OdmjmWG+fJbTs5+uD4NnenYfqpOiafs88+m+eff55f/vKXUYcSKLbn0SMNnuoYHlq8+Fi7du2czn96xxCjufHYDtaFuTsmAXVMPh0dHYyNjUUdRuDYnkePNHiqY3hot5GP1tbWOZ3/0kyj+HYbzdUxCaijHWSz2ahDCJw05BHS4amO4aHFi49ly5bN6fwt7gMZV8a4eJmrYxJQRzuIy7TMIElDHiEdnuoYHlq8FJnOTJYDqspZvEB75BRFURQlCLR48dHb2zun8zv7srFdWddjro5JQB2TT1NTEwcddFDUYQSO7Xn0SIOnOoaHNg/4aGpqmvW5uXFD17YsR66sLl5AATAXx6Sgjsnn8ssvZ2BgIOowAsf2PHqkwVMdw0NbXny0tbXN+txndwwxMjbOqqXxnWkEc3NMCupoB+poD2nwVMfw0JYXH6Wls18VtzMT/5lGMDfHpKCOyefv//7v2bZtG7/+9a+jDiVQbM+jRxo81TE8tHjx0djYOOtzOxMw0wjm5pgU1DH59PT0sHv37qjDCBzb8+iRBk91DA/tNvKxefPmWZ/b2Zdl2b4LqVw4v4gRFZ+5OCYFdbSDnTt3Rh1C4KQhj5AOT3UMDy1efNTV1c363M7MYOzHu8DcHJOCOtrBggULog4hcNKQR0iHpzqGhxYvPkZHR2d13vi4if0DGT1m65gk1NEOjDFRhxA4acgjpMNTHcNDixcfmUxmVuc9NzDMrt3jiSheZuuYJNQx+RxxxBGsWrUq6jACx/Y8eqTBUx3DQwfs+mhubp7VeR19zmDduC9QB7N3TBLqmHwuueQSBgcHow4jcGzPo0caPNUxPLTlxUdLS8uszvOmSa+M8dOkPWbrmCTU0Q7U0R7S4KmO4aEtLz7Ky8tndV5nX5al+yxg3/J4zzSC2TsmCXVMPu973/vYsWMH69evjzqUQLE9jx5p8FTH8NDixUd9ff2sztuSGWRVAlpdYPaOSUIdk09/f39sBgcGie159EiDpzqGh3Yb+Whvb5/xOePjhs5MNvaL03nMxjFpqKMdDA0NRR1C4KQhj5AOT3UMDy1efMymqtz6wjBDo7lEDNaF+FTOQaKOdrBw4cKoQwicNOQR0uGpjuGhxYuP2cxu8AbrNiZggTqYnWPSUEc7yOVyUYcQOGnII6TDUx3DQ8e8+Ojv75/xOVv63JlG+yej5WU2jklDHZPPW9/6Vp566qmowwgc2/PokQZPdQwPSeIKluvWrTObNm0K5NqDg4NUVs6sBeXzt/6Z+x7fxqYLjwkkpmIzG8ekoY52oI72kAZPdZwbItJijFlXyLHabeRjNnPYO/qS8VgAj7jM0w8SdbQDdbSHNHiqY3hot5GPioqZFSHGOM80et/rDggoouIzU8ckoo7J553vfCcvvPACDzzwQNShBIrtefRIg6c6hkdBLS8iskxErheRbSKyS0QeE5Gj93J8vYiYSV7H+o4rE5Evi8hTIjIiIs+IyCfnKjUXamtrZ3T88y/uIjsyxsqEDNaFmTsmEXVMPsPDw1GHEAq259EjDZ7qGB7TFi8iUgVsBAQ4HlgNfAIo5OlMxwLL8l73+fb/j3vM2cDBwCnAo4WFHgwdHR0zOr7THaybpG6jmTomEXW0gzSs85KGPEI6PNUxPArpNvo80GuMOTNvW6FTAPqNMc9PtkNE3g68FWgwxmx3N3cXeN3AaGhomNHxEw9kTFDxMlPHJKKOdhCXpciDJA15hHR4qmN4FNJtdBLwoIjcLCIZEWkVkY+LiBRw7k/dczaKyMmTXPdh4NMi0iMinSJyhYhEWgXMdBrYlkyW6sVlVFcsCCii4hOXqW5Boo52sHv37qhDCJw05BHS4amO4VFIy8sK4FzgMuDrQBPwbXffd6Y4Jwt8Fqe7aQx4N3CziHzQGHNj3nWPAkaA9wFV7nVrAX+hg4icjdO9RG1tLRs2bGD16tV0d3czPDxMc3MzLS0t1NTUUFZWRk9PD2vWrKGjo4NcLsfatWtpbW1l2bJlAPT29tLU1ERbWxulpaU0NjayefNmduzYQVlZGZlMZuKa5eXl1NfX097eTn19PYODg/T399Pc3MymzudYWl7K1q1b6ejooKGhgf7+fgYGBibOr6qqorq6mq6uLhobG9m6dSvZbHZif3V1NZWVlXR3dwfiVFdXx+jo6IRTa2srIyMjUzq1tLRQUVFBbW1tYpz8eRoYGKC0tNQqJ3+eWltbGRsbs8opP0+rV69m165dtLa2WuM0WZ5aW1sBrHKaLE+PPfbYHvttcPLnqa+vj6qqKquc/Hn6y1/+ssf5xXSaCdOu8yIio8AmY8wb87Z9DXiPMWZ1wTcSuRI4yhhzqPv+buBNwCuNMS+4294O/Nrd1jfVteKyzosxhtd+6W7e3VTLV09aG0g8QaBrEdiBOtpBGhwhHZ7qODeKvc5LL/CYb1s7cNAM43oQWOW77nNe4ZJ3XWZx7aIxkznsmcERXtw1lpinSXvEZZ5+kKijHaijPaTBUx3Do5Buo404M4HyaQSenuG9mnAKlvzrniIiFcaYbN51mcW1i0ZVVVXBxyZxphHMzDGpqGPyWb9+PdlslqBaWeOC7Xn0SIOnOoZHIS0vlwGHi8gFIrJSRE4BPgl81ztARC4RkXvz3n9QRP5ORFaLyMEi8lngY7w0VgbgJ0A/8CMReY2IHAl8C7jVGDOzzq8iUl1dXfCxnRl3plGC1niBmTkmFXW0g/nz50cdQuCkIY+QDk91DI9pixdjzMM4M4NOBTYDFwMXAVfmHbYM8M+fuhDYhDOj6DTgQ8aYy/KumwWOAfZ1j7kF+C3wodmpFIeurq6Cj+3MZKlaNJ8lFWUBRlR8ZuKYVNTRDtKwUF0a8gjp8FTH8Cjo8QDGmDuBO/ey/yzf++uB6wu47hPA2wuJISwaGxunP8ils2+QVTUVFDZrPD7MxDGpqKMdLFq0KOoQAicNeYR0eKpjeOiDGX1s3bq1oOOMMXT0ZVmZsMG6ULhjklFHOxgZGYk6hMBJQx4hHZ7qGB76YEYf2Wx2+oOA7dlRXhjeTePSZA3WhcIdk4w6Jp9TTz01NkuRB4ntefRIg6c6hocWLz6am5sLOm5isG4CW14KdUwy6ph8zj33XAYHB6MOI3Bsz6NHGjzVMTy028hHoXPYt2TcadIJbHmJyzz9IFHH5DM0NMTGjRujDiNwbM+jRxo81TE8tOXFR6HTwDr6BqlcOI+ayuQ808gjLlPdgkQdk89xxx3Hzp07OfbYY6MOJVBsz6NHGjzVMTy05cVHocsed/ZlaVxambiZRlC4Y5JRRzsoLS2NOoTASUMeIR2e6hgeWrz46O7uLui4LZls4lbW9SjUMcmoox3s2rUr6hACJw15hHR4qmN4aPHiY/Xq6Z812Z8doX/nKCsTWrwU4ph01NEO0rDOSxryCOnwVMfw0OLFRyFVZefEYN14NJ/NlLhUzkGijnagLS/2kAZPdQwPHbDro5DlyCeKl4S2vKRhyXV1TD5nnXUWjz/+eNRhBI7tefRIg6c6hocWLz4KmcO+pW+QigXzWLbvwhAiKj5xmacfJOqYfM466yxd58Ui0uCpjuGh3UY+CpnD3pnJsjKBzzTyiMs8/SBRx+Szfft27rvvvqjDCBzb8+iRBk91DA9tefFRU1Mz7TEdfVnecvD+IUQTDIU4Jh11TD4nn3wyQ0NDnHjiiVGHEii259EjDZ7qGB7a8uKjrKxsr/v/unOU7dmRRK6s6zGdow2oox0ktXVzJqQhj5AOT3UMDy1efPT09Ox1/5ZtyZ5pBNM72oA62kEaniqdhjxCOjzVMTy0ePGxZs2ave7v7Ev2TCOY3tEG1NEOFi9eHHUIgZOGPEI6PNUxPLR48dHR0bHX/Z2ZQRaVlVK7b3lIERWf6RxtQB3tIC7TMoMkDXmEdHiqY3jogF0fuVxur/s7+5yZRiUlye2Ln87RBtQx+Zxzzjm0t7dHHUbg2J5HjzR4qmN4aPHiY+3atXvd35kZ5KiVyZ1pBNM72oA6Jp/3v//9DAwMRB1G4NieR480eKpjeGi3kY/W1tYp970wvJu+F5M90wj27mgL6ph8nn32We6+++6owwgc2/PokQZPdQwPbXnxsWzZsin3bUn4YwE89uZoC+qYfM444wyGhoY49dRTow4lUGzPo0caPNUxPLTlZQZ09jlLla+qSe40aUVRFEVJOlq8+Ojt7Z1yX2cmy8L5JdTtl9yZRrB3R1tQRzsYHR2NOoTASUMeIR2e6hgeWrz4aGpqmnKf90yjJM80gr072oI62kFFRbK7aAshDXmEdHiqY3ho8eKjra1tyn1b+gat6DLam6MtqKMd7Ny5M+oQAicNeYR0eKpjeOiAXR+lpaWTbh/ctZutL+xiZcIH68LUjjahjsnnM5/5TCrWebE9jx5p8FTH8NDixUdjY+Ok222ZaQRTO9qEOiafd73rXRxxxBFRhxE4tufRIw2e6hge2m3kY/PmzZNu73SLl8YEP5DRYypHm1DH5PPEE09w1113RR1G4NieR480eKpjeGjLi4+6urpJt2/JZCmbV8KBr1gUckTFZypHm1DH5PORj3yE4eFhzjzzzKhDCRTb8+iRBk91DA9tefEx1dTMjr5BGvavoDThM40gHdNP1dEOjDFRhxA4acgjpMNTHcNDixcfmUxm0u2dfVkrxrvA1I42oY52EJdflEGShjxCOjzVMTy0ePHR3Nz8sm07R8Z4bmCYxoQ/08hjMkfbUEc7qKxM/hiz6UhDHiEdnuoYHlq8+GhpaXnZtq5tzmDdlRas8QKTO9qGOtrB4OBg1CEEThryCOnwVMfw0AG7PsrLX770f2efO03akpaXyRxtQx2Tz4UXXpiKdV5sz6NHGjzVMTwKankRkWUicr2IbBORXSLymIgcvZfj60XETPI6dorjjxKRMRGJfA5WfX39y7Z1ZAaZXyost2CmEUzuaBvqmHyOOeYY658oDfbn0SMNnuoYHtMWLyJSBWwEBDgeWA18Aihk1M6xwLK8132TXH8/4MfAvYUGHSST/aW3pS/LiiUVzCu1o5ctDX/NqmPyaW1t5fbbb486jMCxPY8eafBUx/AopNvo80CvMSZ/sYWnCrx+vzHm+WmO+QFwPU5xdHKB1w2MyarKzkyWQ+v2DT+YgIhL5Rwk6ph8zjvvPHbt2sWHP/zhqEMJFNvz6JEGT3UMj0KaEk4CHhSRm0UkIyKtIvJxESlkwZOfuudsFJGXFSYici6wFPjqzMIODv8AweHRHM/+dciKBzJ6pGEQpDraQS6XizqEwElDHiEdnuoYHoW0vKwAzgUuA74ONAHfdvd9Z4pzssBncbqbxoB3AzeLyAeNMTcCiMha4N+Bw40xuelqIRE5GzgboLa2lg0bNrB69Wq6u7sZHh6mubmZlpYWampqKCsro6enhzVr1tDR0UEul2Pt2rW0traybNkyAHp7e2lqaqKtrY3S0lIaGxvZvHkzO3bsoLS0lEwmQ3NzM7fd9xDGwP4LxtiwYQP19fUMDg7S398/cc+Kigpqa2vp6OigoaGB/v5+BgYGJvZXVVVRXV1NV1cXjY2NbN26lWw2O7G/urqayspKuru7A3Gqq6tjdHR0wqmlpYWhoSHq6+tpb2+3xqm8vHzCaWBgAMAqp8nyNDIyYp2Tl6eBgQHGxsZobW21xmmqPOVyOeuc/Hlqa2vb43wbnPx56uvrs87Jn6dHH310j+sX02kmyHQrWIrIKLDJGPPGvG1fA95jjFld8I1ErgSOMsYcKiILgEeAS4wxN7j7vwicbIxZM9211q1bZzZt2lTorWfE4ODgHmtL/OyRHj5185/5zafezCoLnmsEL3e0EXVMPuvXryeXy3H//fdHHUqg2J5HjzR4quPcEJEWY8y6Qo4tpNuoF3jMt60dOGiGcT0IrHK/XoYz8PdH7iyjMeDfgNe4798+w2sXDf8c9s6+LPNKhPoliyOKqPjEZZ5+kKijHcSliTpI0pBHSIenOoZHId1GG4GDfdsagadneK8mnEII4DlgrW//ucDbgPcA3TO8dtGoqNhzLZfOTJZXLVnMfEtmGsHLHW1EHZPP1772tdjMbAgS2/PokQZPdQyPQoqXy4AHROQC4GbgMOCTwPneASJyCfB6Y8xb3fcfBHbjdA2NA+8CPgb8C4AxZjewx5ouIpIBRowxka71Ultbu8f7zr5BXl27T0TRBIPf0UbUMfm88Y1vjM3MhiCxPY8eafBUx/CYtjnBGPMwzoyjU3EKjouBi4Ar8w5bBjT4Tr0Q2AQ8DJwGfMgYc9ncQw6Wjo6Oia937c7xzI4hax4L4JHvaCvqmHweeOABfvrTn0YdRuDYnkePNHiqY3gU9HgAY8ydwJ172X+W7/31OGu3FIwx5ovAF2dyThA0NLxUgz25bSfjBmseyOiR72gr6ph8zj//fEZGRvj4xz8edSiBYnsePdLgqY7hYc9AjiLR398/8XVnxhksaNMaL7Cno62oox3s3r076hACJw15hHR4qmN4aPHiw1sfBGBLJktpiVC/xI5nGnnkO9qKOtrB2NhY1CEEThryCOnwVMfw0OLFR3Nz88TXHX2DLK9exIJ5pRFGVHzyHW1FHe3A9jUzIB15hHR4qmN4aPHiI38Oe2cmS6NlXUYQn3n6QaKOdqDrvNhDGjzVMTwKGrCbJqqqqgAYGcvxdP8Qx69dFm1AAeA52ow6Jp/LL7+cJ554IuowAsf2PHqkwVMdw0OLFx/V1dUAdG8fIjduWFlj10wjeMnRZtQx+TQ1NVnvCPbn0SMNnuoYHtpt5KOrqwtwxruAfTON4CVHm1HH5HPPPfdwyy23RB1G4NieR480eKpjeGjx4qOxsRFwxruUCKzY355nGnl4jjajjsnnq1/9KrfddlvUYQSO7Xn0SIOnOoaHFi8+tm7dCsCWzCDLqxezcL5dM43gJUebUUc7GBkZiTqEwElDHiEdnuoYHlq8+Mhms4DzNGkbx7vAS442o452kMvlog4hcNKQR0iHpzqGhxYvPpqbmxkdG+ep7TtZZWnxEpd5+kGijnag67zYQxo81TE8tHjx0dLSwtP9OxkbN6yy7JlGHnGZpx8k6mgHus6LPaTBUx3DQ6dK+6iurqYz4zSL2TjTCOIz1S1I1DH5XHPNNalY58X2PHqkwVMdw0OLFx+VlZV0bskiAg3729nykoameHVMPgcffDALFiyIOozAsT2PHmnwVMfw0G4jH93d3XRkBjlwv0WUl9k30wgcR9tRx+Rz++2385Of/CTqMALH9jx6pMFTHcNDixcfq1evZktf1trBuuA42o46Jp9LL72UO+64I+owAsf2PHqkwVMdw0OLFx9dTz7Fk9uzrFoaj6axIIhL5Rwk6mgHu3btijqEwElDHiEdnuoYHlq8+Hi6f4jdOWN1y8vw8HDUIQSOOtrB+Ph41CEEThryCOnwVMfw0OLFR/nSVwFYO00a4jNPP0jU0Q7iMjgwSNKQR0iHpzqGhxYvPn73aCdg70wjiM88/SBRRzvQdV7sIQ2e6hgeOlXaR//uMg6omsfiBfZ+a2pqaqIOIXDUMfnccMMNdHR0RB1G4NieR480eKpjeNj7CT1Lel4co3HpPlGHEShlZWVRhxA46ph8DjzwwFQ8mNH2PHqkwVMdw0O7jfLIjRueHhixeqYRQE9PT9QhBI46Jp+bb76ZH//4x1GHETi259EjDZ7qGB5avHjcdBPPHPp6xsZh5X99CW66KeqIAmPNmjVRhxA46ph8rrrqKu69996owwgc2/PokQZPdQwPLV7AKVTOPpvOEWdF3VVPPAJnn21tAZOGcQTqaAdxmZYZJGnII6TDUx3DQ4sXgAsugKEhOpccBMCq/mdhaMjZbiG5XC7qEAJHHe3AGBN1CIGThjxCOjzVMTy0eAF45hkAuqoP5JWD26kYHd5ju22sXbs26hACRx3tYPHixVGHEDhpyCOkw1Mdw0OLF4CDnBaX//jVt/j8lltftt02Wltbow4hcNTRDrLZbNQhBE4a8gjp8FTH8NCp0gAXXwxnn838oSFe0+325y1a5Gy3kGXLlkUdQuCoY/K59dZb2bJlS9RhBI7tefRIg6c6hoe2vACcfjpcey0sXw4izr/XXutsVxQlEpYsWcJ+++0XdRiKosQQLV48Tj8durvpvfpq6O62unDp7e2NOoTAUcfkc9111/GjH/0o6jACx/Y8eqTBUx3DQ7uNfDQ1NUUdQuCoox3Y7njdddcxNjYWdRiBY3sePdLgqY7hoS0vPtra2qIOIXDU0Q7S4Lhz586oQwicNOQR0uGpjuGhxYuP0tLSqEMIHHW0gzQ4ikjUIQROGvII6fBUx/AoqHgRkWUicr2IbBORXSLymIgcvZfj60XETPI6Nu+Y94rI3e41B0XkQRF5dzGk5kJjY2PUIQSOOtpBGhzLy8ujDiFw0pBHSIenOobHtMWLiFQBGwEBjgdWA58AMgVc/1hgWd7rvrx9R7vvjwcOA+4CfiYibyo8/OKzefPmKG8fCupoB2lwTEO3URryCOnwVMfwKGTA7ueBXmPMmXnbnirw+v3GmOcn22GM+Wffpi+JyPHAScD9BV6/6NTV1UV169BQRzuw3fGuu+6iq6sr6jACx/Y8eqTBUx3Do5Buo5OAB0XkZhHJiEiriHxcCuuM/ql7zkYRObmA4yuBvxZwXGCMjo5GeftQUEc7sN1x0aJFselfDxLb8+iRBk91DI9CWl5WAOcClwFfB5qAb7v7vjPFOVngszjdTWPAu4GbReSDxpgbJztBRD4G1AE3TLH/bOBsgNraWjZs2MDq1avp7u5meHiY5uZmWlpaqKmpoaysjJ6eHtasWUNHRwe5XI61a9fS2to6sTpgb28vTU1NtLW1UVpaSmNjI5s3b2bHjh0AZDKZiWuWl5dTX19Pe3s79fX1DA4O0t/fP7G/oqKC2tpaOjo6aGhooL+/n4GBgYn9VVVVVFdX09XVRWNjI1u3biWbzU7sr66uprKyku7u7kCc6urqGB0dnXB66KGHGBwctMrJn6eBgQFyuZxVTv48PfTQQwwNDVnllJ+n//zP/2R4eJhzzjnHGqfJ8vTQQw8xOjpqldNkeWptbd3j+jY4+fPU19fHokWLrHLy5+mRRx7Z4/7FdJoJMt1TW0VkFNhkjHlj3ravAe8xxqwu+EYiVwJHGWMOnWTf+3CKlvcbY26f7lrr1q0zmzZtKvTWM2JwcJDKyspArh0X1NEObHdcv349uVyO+++PrBc5FGzPo0caPNVxbohIizFmXSHHFtJt1As85tvWDsz0qYUPAqv8G93upBuAMwspXIKmpaUl6hACRx3tIA2Og4ODUYcQOGnII6TDUx3Do5DiZSNwsG9bI/D0DO/VhFMITSAip+IULmcZY26d7KSwScPUTHW0gzQ4lpTYvxRVGvII6fBUx/AoZMzLZcADInIBcDPOtOZPAud7B4jIJcDrjTFvdd9/ENgNPAKMA+8CPgb8S945p+EULp8Fficir3R3jRpjdszRa9bU19dHdevQUEc7SIPjwoULow4hcNKQR0iHpzqGx7R/1hhjHsaZcXQqsBm4GLgIuDLvsGVAg+/UC4FNwMPAacCHjDGX5e3/KE7xdDlOi4z3+unMNYpHe3t7lLcPBXW0gzQ4Dg0NRR1C4KQhj5AOT3UMj2kH7MYREdnGzLutCmUJsD2ga8cFdbQDdbSDNDhCOjzVcW4sN8bsX8iBiSxegkRENhU62jmpqKMdqKMdpMER0uGpjuFh/2g4RVEURVGsQosXRVEURVEShRYvL+faqAMIAXW0A3W0gzQ4Qjo81TEkdMyLoiiKoiiJQlteFEVRFEVJFFq8KIqiKIqSKLR4URRFURQlUWjxEhAiIlHHEDTqaA9p8FRHJSmkIY9zdSzk2UZKgYjIAcAiYCswCuwWETEWjYpWR3tIg6c62oGINACvADLAgDHmBREpMcaMRxxa0UhJHovmqC0vRUJE/gHYAPwf0A5cKiJrjDFGRKz4PqujHY6QDk91tMbxQ8B9wM+AB4AbReQNxphxixzTkMeiOupU6SIgIu/AeaDkp4CHgBOAY4B9gY8YYx5KegWtjnY4Qjo81dEax6OBO4BPAL8FjgbeA7wZeJ8x5r6kt8CkJI/FdzTG6GuOL+DfgVt9244Bfgn8BWiKOkZ1VMc0eaqjNY4fBe7xbVsN3ADsBI5yt0nUsWoew3W0ojkqBswHXiMiFd4GY8w9wKU4T7++QESqowquSKijHY6QDk91tMexSUSWeBuMMe3Al3A++C4TkYOM+2mYUNKSx6I6avFSHB4FyoCj8/vujDG/BW4FjsB5jHiSUUc7HCEdnupoh+Mm4HngNBFZ5G00xmwBfgRUAisjiq1YpCGPRXfU4qUIGGNuAbqAbwFrfft+iJO0N0UQWtFQRzscIR2e6miN4x9wxkh8HjhGRBbk7bsb5y/610cUXlFISR6L7qjFyxwRkVL3y3cDO4CbReRNIjLP3b8UZ3rf8xGFOGfU0Q5HSIenOlrjWAJgjPkQzuyUq4BTRWSxu78K+CvwXFQxzpWU5DEQR51tVAS8UdLuf6bbgeW8NB3sbUA10GyMyUUX5dyw0dE/ut1Gx8lIg6c6JstRRKqNMf2TbC/14heRW4DX4qwR8iecFpcq4DBjzFiI4RYVW/Io4iw6N9n4oyActXgpgLxvfOlU39z8D0IRuQhoBvYDngTONsbs3tv5ccQ/BdEWx3yvqQoY9+skO74S6JtqIKMNniLyZmC7MeaxKfbb4HgCMGaM+d8p9tvgeBrwLmPM6VPsn+cVJyLyQeBIYCnwDPDphDjuCywwxmSm2J/4PE5HsR21eCkAEVlrjGlzv570mzvJh+A8YJ4xZpf3Ps5/HYjIeuCNOH/J/MEY8zN3e/4PXNIdjweOBw4C/tcY851Jjkm0I4CInA5cAZxljLl9imMS7Ski5wKXAEcbY1qnOCbpjv8I/BfwXeBSY8zAJMck3fHDwLXu2/cYY34xyTEvW8fF1yITd8cPAP8IHIyzyN4XjDFP+o5Jeh6Px1mDpxL4M/AjY8yIu8/747+ojjrmZRrcD4I/i8jVAMaYnLzUhzeBm5wKEVnuvh/LS4rE/AfvQ8DNOMXLm4AbxFkNcY8mwIQ7/iPwY2ABMABcISLvz9svef/JkuroPSvkeJy/aH4oIu+e5LjShHt+BLgcZ3Gr1imOSXoujwO+CZxjjLnIGDOQl1/vGBvyeDVwDnAncLyIlIhvtVXjrKS7j4iszduWy/s6zo5nAtcA9wAXAu8EPuw7piTheTwL+G+c2UILcAbl/kJE3goTnxvFdzQxWMAmri/gKJw+uZ8BLwJX5+0rzftagIXAb3D+Ey6POvYZOB6HM1jq/e77auAbOP2Si4ASCxzfC/QBJ7vvy4H/xflLz39seRId3di9XH0e+BfgKzgLeU3mmdRcngGMA+913x8InAx8DKfrIfGObuz/BnzD/Xo18B3X5Urg2LzjFiXREfg4sAs40X3/eSALrHDfS96xZTgfjn8GXht17DNwrAc2A3+ft+0i4F+B/X3HJjWPjUCn9/nhbjsayOEUbO/M217U/4/a8jIFIjIfp2/1D8AFOH8dnDlZC4xx2IXz3IZq4NlIgp4hIlKJ88F+izHmZgDjDJr7E9CE8wtk3N3uOf4fyXJcBHwAuMoYcyuAMWYYZ1nqc0TkjyJyuYgclLcvUY4e5qWm9eeAtxhjLsJZQ+HHInKSiNwhIqe4xyYql27DWAXOL/8O4GEReTXO0vH/AnwG56+977k5T5yjj8MAIyJ1wK9xHNpwWkcvcv/axRgzRMIc3bxdgvOh7nUT/RDnQ/BTbvdBfovvKM6zjZ7F+R4khQU4H9hP5217O3Am8Lj7//HvIJl5dNkHGAF+77aazccZi/QnnPV3znP/3xb//2PUlVucX0At8Oa8qvFMYIg9W2BK8LXCeNujjr8Av/nAP+H+9ZO3vcn9AdzP75U0RzfOA4G1ee9/BvTgFKXnAoPA9b5zEuXoi/0onHFL3vvv4/wl9BhQlWRPnDUi/gz83v0Z/SbOGKZ9gWNx/pr/9yQ7urFeBvwA+HvgezhjAwD2B36OU9Ak9fdOBVDvjxune+UxnIGt4LT2vmzZ/3zvOL/c3ztZN4+n4rQ4dOI8m+lvgbtxirJXJjGPbpyvA8aA4/K2nYrTsv0md9+5vnOK4hi5fFxfU/ynKcdptp4oYHDGFnwKWOadN9m5cX0B+/idcZo7nwJq8/adlv/DlhRHf5zA4Tgrc77K5zYCrPB+MSYtjz7HMpwWwzL3Q+FRnGItm/9LJoG59LrF1gCPAzcCFb5jvu5+AO6X94GfuFziFKBjOAXad/PzhNMqM+5+cHjbEuc4SV7rcP6Q+Lxvf+K88pyOxWkpvA7oxZnW7R1zqJvHtyXVF+eP+mtct+/iFN1jOJMFwCm8r3G/Lurv1nkok2Lc77Jv27CI3Oa+vVqc1R7rgVfhDFKa9Lw4Y4x5Me9rL/Z9cH4oXwQQkd/g9LvfMsmxscYfpzHmjyLyZ+N0D3ksBh4EnjfuQMCk+PlxBzvOx2lpeTPwVZyFof4WZwzMHSLyZmPM771zkuJqnIGbJcaYzeI8pXalMSbrO0yAp40xf807LxF+Hu7gxd+LyIU4Y19eKSL7GmNecA8xOMvmb/fckuaYj5tXwfk5vQP4WxG5BnjRuEQb4czxnIwx/ysih+IUZofiTAueOAynFXGH79zE+BpjdonI5Th/7J4MbAdOMsbc4R6yL84f+xT7d6sWLzPEGDMkzmJJ+wDfxlm6elXeL9bEPpodJmasLAB2A/NF5Jc43WevyvsPmZj/XPnkxb4rb9sC4EScv46Gpzo3SRhjdopIB06z9AacwXTbccb4dAN/jDC8OZH3M/g0e44lQETKcT4g/hJJcEUi7//XTTi/Zz4HXCIiN+OsQvolnFa0nmgiLD6u85CI3IjTLXaEmWJtm6SQV1juEpEczhiQdwC3iPMQwi8DLwCPRBfl3DHOgzLb3SKmxDjjd7y1bfbH6S4rOrrOyywQZ5XA3+AUf39jjBmTmM/DnwkisgLng28Ep5BZbZwFhGxyXIDTmvQVnNUeX+fmMbHFWT7uFM3DgS8ZY/om2W9TLhcCrwG+iDP+pdmWXLq/a94N/AdOF8MAbkua+38y8X8w5eP+8fQn4CFjzEeijqcY5E3b/xrOTKN2nD8OdwFvsi2P7h8Rh+FMDa/D/d1a9Psk/P/2nBCRdcCjxhnNXug5JcAncQYlHR33D/VZOr4W56+BR4DDbXN0f0G+CWeGSiXwDpOAFSwL8cz/wBaRBcZdKCopzDKXb8YZfF3OSx/qsc3lLP9P1uL8FSvuueM2/Z/0nXsScHtc8+cxi5/VCpyf1WacsUw3GmfWqlV5FJFX4BTbB+BMBgnm/+NUg2Fsf+FUwOPACcD8GZ67hJcGZM2L2qXYjsArcNZh8AY82up4BC8NIout40w9SdCAvyLm8qgk5HI2jpPlkxjPRplDHv2D62M7q2gunx9pcMSZDh3oZ2TaW15+jvMB9mGc5eJ3F3BO/rLUUz6IKi7MxtF3fikwbrlj7PMIs/55nfLZTXGkCLkswV2WKIDwisJc8uj/N+hYZ4s6TnlOGhxD+YxM5SJ17ngHjDEnAb/FWTb+WHEW2NnbeZKXlFcZl6DjnQ1zcCzN+3qFMSZnoWNJ3tcr4pxHmPPPq9eFtMK9Riw9i5jL2BbaxcgjzsxGG/OojjEiEZ+RQTTnxPnFnoutrXf/vQ3YBryLKZrHfOd9BGgBDojaRx3tdUyLpzqqozrG55UUx8i/UREm5d9w5qYvd9//YqrkTJKUQdxnq8TtpY52OKbFUx3VUR3j80qSY+TfrIgStAanklzv2+4lZ2KAEnuuKvsRnHn5sfzBU0f7HNPiqY7qqI7xeSXBMfJvUgRJOQdnka4HcZe/B8ry9v8cZyGoU8irLoGPAn8F3he1gzqmwzEtnuqojuoYn1dSHCP/RoWQiBLf+yOBLTgLBL0vb3t+cn4P3Jn3/kT3+JOj9lFHex3T4qmO6qiO8Xkl1THyb1yICfoMcKj79aHAEzhPvnzjFMnx5qgLcBLOgnSRe6ij/Y5p8VRHdVTH+LyS5hj5NyykpBwAdOd/c4F1OM+z+RnOczS87fPyvo7tAkLqaKdjWjzVUR2jjl0dk+1o5Tov+Ws/uDwPjOKswuktorMJ+ADwauBzIrIewOQt02xivDy1OtrhCOnwVEd1VMf4YIOjlcWLcR9wJSL7iEiZ+w1uAxa7h5S4x7UApwNvBY6NItbZoo6ABY6QDk91BNQxEagjkABHax8PICIfBS4FHsd5SukROAOKzgL6jTG9eUs0HwJ0xrlSngx1tMMR0uGpjuqYFNQx/o7WFC/+Z0S43+zXAvsAh+M8mvttOHPUB3EeK78b+FdjzP3uObF9Ei2oI5Y4Qjo81VEd1TE+2OY4L+oAioWXFBH5NPCiMeb7OBUlwPdE5G+BhTirBo4BbwEqgT/kXSMWSZkKdbTDEdLhqY7qmHcNdYwY2xytKV5ERID5wD8CP5rkkGeANwA5Y8xGYGPeubGpJveGOgIWOEI6PNURUEd1jAm2OSZ6wK64I6a95jBjzChOlbjCt78U6MWZCvYK/3XilpR81NEOR0iHpzqqYz7qGC02Oya6eDHuiGngb0RkkVtZ9gOHuZXiuHtczhizExjGGZSUGNTRDkdIh6c6qmNSUMeEO5oYLJAzlxfwfpzBRc/iVI134jwJ8zych0vVu8cJcAZ5C+wk5aWOdjimxVMd1TEpL3VMrmPiZhuJSIl5qZpERJYCBqcZbB2wEvgk8ChwIFCKswDPtcaYb7rnxK7/Lh91tMMR0uGpjuqojvEhDY6QsKnS+UkRkX/Eef7CIuBe4BZjzLiIvBq4DzgOeBFYDjQC3zN5KwPGFXW0wxHS4amO6og6xoY0OE4QddPPbF7Af+JUil8HfojTHPZDd998YBNw6iTnJelZE+pogWNaPNVRHaOOXR3T5Zi4Absi8nbgfcC7jTH/itN/9wrgtwDGmN3AX3HmqO+BiXkzmIc62uEI6fBUR3VUx/iQBkdI5jovtUCPMeYhEXkfznz1zxhjrheRfYC1QB8wvreLxBx1tMMR0uGpjuqYFNTRDsfkFC8iE0sbLwD6ROQE4Drgc8aYq93D3oSzyM4twF2RBDoH1NEOR0iHpzqqY1JQRzsc9yDqfquZvnAezz2KUzV+KG97OfC/wPV52xLTf6eO9jmmxVMd1TEpL3W0w9GYBI55McY8hrO88S7g1SLyVhE5BvgFsMzd51Whiem/y0cd7XCEdHiqozomBXW0wxESNlXaQ0TmAScD38BZWGcr8BxwijFmdxLmqE+HOtrhCOnwVEd1TArqaIljEosXDxHZH6jCWdL4OWOMEZF5Jklz1adBHe0hDZ7qaAfqaAc2Oya6ePEjvpUFbUQd7SENnupoB+poBzY5WlW8KIqiKIpiP4kbsKsoiqIoSrrR4kVRFEVRlEShxYuiKIqiKIlCixdFURRFURKFFi+KoiiKoiQKLV4URVEURUkUWrwoiqIoipIotHhRFEVRFCVR/H/87svbwaHCxwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "hf_convergence2.seek_convergence(rtol=0.0001,convergence_level=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}