direct space electrostatics recapitulation of openmm energies

electrostatics_treatment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6e42a54b-4be2-4d0f-829b-1da8662bf80f",
   "metadata": {},
   "source": [
    "# Learnable Free Energy Calculations: Electrostatics Treatment\n",
    "Electrostatics treatment becomes a potentially tricky issue in attempting to reweigh `perses` RBFEs to an engine that cannot evaluate full PME.\n",
    "It becomes necessary to extract the energetic contributions of particles whose parameters will be modified and reweighed; one such extraction method involves the following partition.\n",
    "1. evaluate the ligand-ligand interactions (to be iteratively modified) with vacuum electrostatic or direct space PME only.\n",
    "2. evaluate the ligand-environment interactions (to be iteratively modified by virtue of ligand particle charge changes) by evaluating the PME energy of env-to-ligand on a per-particle basis (i.e., each ligand atom will be turned on individually whilst the rest are off, and the the electrostatic potential energy or potential can be evaluated for each atom individually and summed)\n",
    "3. evaluate the env-env interactions with PME (not modified). This is not strictly necessary for reweighing since for each configuration, this will not change, but it is good to keep this as a reference.\n",
    "\n",
    "The sum of these three terms should match (up to a constant with hopefully a low variance among different configs) the full PME energy of any given ligand-environment configuration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95bfc5ab-7b36-4399-b905-bcd646a16281",
   "metadata": {},
   "outputs": [],
   "source": [
    "import openmm\n",
    "from openmm import app\n",
    "from openmm import unit\n",
    "from openmmtools.testsystems import HostGuestExplicit\n",
    "from openmmtools.constants import ONE_4PI_EPS0, kB\n",
    "import copy\n",
    "import typing\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c124f3ce-9735-43a7-a465-a9103e26b857",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openmmtools.utils import get_fastest_platform\n",
    "PLATFORM = get_fastest_platform()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5b18db27-1698-42f5-ae01-e47fbed1bcd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openmmtools.constants import kB\n",
    "kT = kB * 300 * unit.kelvin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7ab19916-d5bb-4ec5-bab4-bdc45cb430ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CPU'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PLATFORM.getName()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a6218af0-d952-4936-8958-25033c03315a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# utility function to zero the sterics and/or electrostatics particle terms and exceptions.\n",
    "def zero_force_and_exceptions(target_nbf: openmm.NonbondedForce, \n",
    "                              indices: typing.Iterable[int], \n",
    "                              zero_sterics: bool=True, \n",
    "                              zero_elec: bool=True) -> openmm.NonbondedForce:\n",
    "    \"\"\"utility function to toggle the nonbonded/exception terms; modifies in place\"\"\"\n",
    "    # do exceptions first\n",
    "    for exception_idx in range(target_nbf.getNumExceptions()):\n",
    "        p1, p2, cp, s, e = target_nbf.getExceptionParameters(exception_idx)\n",
    "        if len(set([p1, p2]).intersection(set(indices))) > 0:\n",
    "            if zero_elec:\n",
    "                cp = 0.*cp\n",
    "            if zero_sterics:\n",
    "                e = 0.*e\n",
    "            _ = target_nbf.setExceptionParameters(exception_idx, p1, p2, cp, s, e)\n",
    "\n",
    "    # now particle terms.\n",
    "    for idx in indices:\n",
    "        c, s, e = target_nbf.getParticleParameters(idx)\n",
    "        if zero_elec:\n",
    "            c = c * 0\n",
    "        if zero_sterics:\n",
    "            e = e * 0\n",
    "        _ = target_nbf.setParticleParameters(idx, c, s, e)\n",
    "\n",
    "    return target_nbf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7404fe6b-6320-43f3-a3a7-bd7b587035c1",
   "metadata": {},
   "source": [
    "## Energy Bookkeeping Experiment\n",
    "In this experiment, I'll attempt to compare the energies and variance thereof between a typical full PME treatment of a system with the \"separated\" energy treatment as described above. As far as implementation goes, the nonbonded forces contain the following:\n",
    "1. nbf0: full pme energetics of original system for bookkeeping purposes.\n",
    "2. nbf1: env-ligand sterics only (all electrostatics and electrostatic exceptions are zeroed)\n",
    "3. nbf2: env-env electrostatics w/ pme (all sterics and steric exceptions, electrostatic ligand charges and exceptions are zeroed)\n",
    "4. nbf3: ligand-ligand vacuum electrostatics sans exceptions (zero all sterics and steric exceptions, electrostatic env charges and charge exceptions are zeroed)\n",
    "5. nbf4: ligand-ligand direct space pme electrostatics sans exceptions (as nbf3).\n",
    "6. bf3: ligand-ligand electrostatic exceptions\n",
    "7. bf4: ligand-ligand pme self energy.\n",
    "8. nbf5: ligand-environment electrostatics (there are no exceptions here) w/ PME. the ligand charges will be turned on/off iteratively to account for the electrostatic ligand-environment interactions on a per-ligand-particle basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "378a6534-4bb2-4bd4-ab17-950374274005",
   "metadata": {},
   "outputs": [],
   "source": [
    "def treat_fg(nbf: openmm.NonbondedForce, use_pme: bool, reciprocal_fg: int):\n",
    "    if use_pme:\n",
    "        nbf.setReciprocalSpaceForceGroup(-1)\n",
    "    else:\n",
    "        nbf.setReciprocalSpaceForceGroup(reciprocal_fg)\n",
    "        \n",
    "\n",
    "def mod_pme_system(original_system: openmm.System, \n",
    "                   ligand_indices = typing.List[int],\n",
    "                   use_pme: bool=True, # whether to treat all groups (except lig-lig electrostatics) with pme\n",
    "                   reciprocal_fg: int=13, # place of reciprocal fg of (lig-lig electrostatics)\n",
    "                   lig_lig_as_bf: bool=False # whether to treat the ligand-ligand interactions as a bond Force.\n",
    "                  ) -> typing.Tuple[openmm.System, openmm.System, typing.List[float]]:\n",
    "    \"\"\"modify a given `orignal_system` with PME treatment into separate forces as describe\"\"\"\n",
    "    mod_system = copy.deepcopy(original_system) # make a copy of the original system to mod\n",
    "    nbf = copy.deepcopy([f for f in mod_system.getForces() if f.__class__.__name__ == 'NonbondedForce'][0]) # find the pme nbf\n",
    "    \n",
    "    # for calculating error and alpha\n",
    "    delta = nbf.getEwaldErrorTolerance() # for computing the alpha term for pme treatment\n",
    "    r_cut = nbf.getCutoffDistance().value_in_unit_system(unit.md_unit_system)\n",
    "    \n",
    "    nbf_num_particles = nbf.getNumParticles() # get number of particle in nbf/system\n",
    "    num_forces = mod_system.getNumForces() # query the number of forces\n",
    "    _ = [mod_system.removeForce(idx) for idx in range(num_forces)[::-1]] # remove _all_ the forces (will be added again after)\n",
    "    solvent_indices = list(set(range(nbf_num_particles)).difference(set(ligand_indices))) # get the solvent indices\n",
    "\n",
    "    # charge exceptions\n",
    "    all_charge_exceptions = [nbf.getExceptionParameters(i)[:3] for i in range(nbf_num_particles)] # get all of the chargeprod exceptions\n",
    "    \n",
    "    # get the solute charge exceptions\n",
    "    solute_charge_exceptions = [[e[0], e[1], e[2].value_in_unit_system(unit.md_unit_system)] \\\n",
    "                                for e in all_charge_exceptions if len(set(e[:2]).intersection(set(ligand_indices))) > 0]\n",
    "    solute_charge_exceptions_dict = {tuple(sorted(q[:2])): q[2] for q in solute_charge_exceptions}\n",
    "\n",
    "    # get all appropriate charges\n",
    "    charges = [nbf.getParticleParameters(i)[0] for i in range(nbf_num_particles)] # get charges of all nbf particles\n",
    "    # get unitless charges and zero if is not in `ligand_indices`\n",
    "    ligand_charges = [c.value_in_unit_system(unit.md_unit_system) * (idx in ligand_indices) for idx, c in enumerate(charges)]\n",
    "    \n",
    "    # create a nbf that has all sterics/steric exceptions removed; this is used as a template\n",
    "    zeroed_sterics_nbf = zero_force_and_exceptions(copy.deepcopy(nbf), range(nbf_num_particles), zero_sterics=True, zero_elec=False)\n",
    "\n",
    "    # 0: copy of original pme nonbonded system: use PME\n",
    "    nbf0 = copy.deepcopy(nbf)\n",
    "    _ = treat_fg(nbf0, use_pme, reciprocal_fg)\n",
    "\n",
    "    # 1: first nbf will be sterics only (just zero all electrostatics and exceptions)\n",
    "    nbf1 = zero_force_and_exceptions(copy.deepcopy(nbf), range(nbf_num_particles), zero_sterics=False, zero_elec=True)\n",
    "    _ = treat_fg(nbf1, use_pme, reciprocal_fg)\n",
    "\n",
    "    # 2:  second nbf will be env-env electrostatics w/ pme (zero all sterics/steric exceptions, zero all ligand charges and exceptions)\n",
    "    nbf2 = copy.deepcopy(zeroed_sterics_nbf)\n",
    "    nbf2 = zero_force_and_exceptions(nbf2, ligand_indices, zero_sterics=False, zero_elec=True)\n",
    "    _ = treat_fg(nbf2, use_pme, reciprocal_fg)\n",
    "\n",
    "    if not lig_lig_as_bf:\n",
    "        # 3: third nbf will be ligand-ligand electrostatics w/ direct PME only (zero all sterics/sterics exceptions, zero all solvent charges/exceptions)\n",
    "        nbf3 = copy.deepcopy(zeroed_sterics_nbf)\n",
    "        nbf3 = zero_force_and_exceptions(nbf3, solvent_indices, zero_sterics=False, zero_elec=True)\n",
    "        nbf3.setReciprocalSpaceForceGroup(reciprocal_fg) # only direct space pme for ligand-ligand\n",
    "        # # then zero the charge exceptions as a test\n",
    "        # for i in range(nbf.getNumExceptions()):\n",
    "        #     p1, p2, cp, s, e = nbf.getExceptionParameters(i)\n",
    "        #     if {p1, p2}.issubset(set(ligand_indices)):\n",
    "        #         nbf13.setExceptionParameters(i, p1, p2, cp, s*0., e*0.)\n",
    "    else:\n",
    "        # 3: third nbf will be ligand-ligand electrostatics w/ nocutoff only (zero all sterics/sterics exceptions, zero all solvent charges/exceptions)\n",
    "        # http://docs.openmm.org/latest/userguide/theory/02_standard_forces.html#coulomb-interaction-with-ewald-summation\n",
    "        alpha = np.sqrt(-np.log(2.*delta)) / r_cut\n",
    "        print(alpha)\n",
    "        # \n",
    "        # exceptions are written as coulomb, so write a select function or a different custom bond force\n",
    "        # to treat exceptions as coulomb interactions. \n",
    "        # \n",
    "        nbf3 = openmm.CustomBondForce(f\"0.5 * {ONE_4PI_EPS0} * chargeprod * erfc({alpha} * r) / r\")\n",
    "        nbf3.addPerBondParameter('chargeprod')\n",
    "        for i in ligand_indices:\n",
    "            for j in ligand_indices:\n",
    "                my_idx = tuple(sorted([i, j]))\n",
    "                is_exception = solute_charge_exceptions_dict.get(my_idx)\n",
    "                if i == j: # don't add\n",
    "                    continue\n",
    "                if is_exception:\n",
    "                    #continue\n",
    "                    _ = nbf3.addBond(i, j, [is_exception])\n",
    "                else:\n",
    "                    _ = nbf3.addBond(i, j, [ligand_charges[i] * ligand_charges[j]])\n",
    "\n",
    "    # nbf4 = openmm.CustomBondForce(f\" -{alpha} * c^2 / sqrt({np.pi})\")\n",
    "    # nbf4.addPerBondParameter(\"c\")\n",
    "    # for i in ligand_indices:\n",
    "    #     _ = nbf4.addBond(i, i, [ligand_charges[i]])\n",
    "    \n",
    "\n",
    "    # # make bf to accomodate self electrostatic interaction\n",
    "    # bf4 = openmm.CustomBondForce(f\"-1 * {alpha}{ONE_4PI_EPS0} * c^2 / sqrt(pi)\")\n",
    "    # bf4.addPerBondParameter(\"c\")\n",
    "    # _ = [bf4.addBond(i, i, [charges[i]]) for i in ligand_indices]\n",
    "\n",
    "    # 4: fifth nbf will be ligand/env electrostatics (this is toggled; zero all sterics/steric exceptions, zero all ligand/ligand interactions)\n",
    "    nbf5 = copy.deepcopy(zeroed_sterics_nbf)\n",
    "    nbf5 = zero_force_and_exceptions(nbf5, ligand_indices, zero_sterics=False, zero_elec=True)\n",
    "    _ = treat_fg(nbf5, use_pme, reciprocal_fg)\n",
    "\n",
    "    # add all forces\n",
    "    for idx, f in enumerate([nbf0, nbf1, nbf2, nbf3, nbf5]):\n",
    "        f.setForceGroup(idx)\n",
    "        _ = mod_system.addForce(f)\n",
    "    return mod_system\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c0592e7f-4af2-49cb-9076-e4955c9ef846",
   "metadata": {},
   "outputs": [],
   "source": [
    "def energy_by_group(\n",
    "    context: openmm.Context, \n",
    "    fgs: typing.List[int]=None,\n",
    "    get_forces: bool=False) -> typing.List[float]:\n",
    "    \"\"\"return a list of floating point energies (in `md_unit_system`) by force group\"\"\"\n",
    "    sys = context.getSystem()\n",
    "    if fgs is None:\n",
    "        fgs = []\n",
    "        for f in sys.getForces():\n",
    "            fgs.append(f.getForceGroup())\n",
    "            \n",
    "    energies = []\n",
    "    forces = []\n",
    "    for fg in fgs:\n",
    "        state = context.getState(getEnergy=True, getForces=get_forces, groups = {fg})\n",
    "        energies.append(state.getPotentialEnergy().value_in_unit_system(unit.md_unit_system))\n",
    "        if get_forces:\n",
    "            forces.append(state.getForces(asNumpy=True).value_in_unit_system(unit.md_unit_system))\n",
    "    return energies, forces\n",
    "        \n",
    "def query_energies_by_force(\n",
    "    mod_context: openmm.Context, \n",
    "    ligand_indices: typing.List[int], \n",
    "    ref_posits: np.ndarray * unit.nanometer, \n",
    "    box_vectors: typing.List[openmm.vec3.Vec3],\n",
    "    get_forces: bool) -> typing.Tuple[typing.List[float], typing.List[float]]:\n",
    "    \"\"\"for each force in the `mod_context`'s `openmm.System` object, return the energy in accordance with the force's group.\n",
    "    More specifically, collect the energies by force before turning on the ligand-environment interactions iteratively, \n",
    "    then collect the ligand-environment interactions iteratively.\n",
    "    Hence, returns two lists:\n",
    "    1. list of energies by force group before toggling ligand-env interactions.\n",
    "    2. list of energies by force group after toggling ligand-env interactions (this is specifically the energies of the \n",
    "        last nbf, the one that collects ligand-env interactions. This list will have `len(ligand_indices)` terms.)\n",
    "\n",
    "    #2 is queried and assumed to be the _last_ force\n",
    "    \"\"\"\n",
    "    \n",
    "    mod_context.setPositions(ref_posits)\n",
    "    mod_context.setPeriodicBoxVectors(*box_vectors)\n",
    "    init_energy_by_fg = energy_by_group(mod_context, None, get_forces)\n",
    "\n",
    "    unmod_nbf = mod_context.getSystem().getForce(0)\n",
    "    lig_env_nbf_idx = mod_context.getSystem().getNumForces() - 1\n",
    "\n",
    "    interaction_energies = []\n",
    "    # iterate over the last force in the system to toggle on (then off) the ligand charges to recover the \n",
    "    # interaction energy of the ligand particle with the environment atoms.\n",
    "    for lig_idx in ligand_indices:\n",
    "        nbf = mod_context.getSystem().getForce(lig_env_nbf_idx) # target force to toggle charge particles\n",
    "        oc, os, oe = unmod_nbf.getParticleParameters(lig_idx)\n",
    "        mc, ms, me = nbf.getParticleParameters(lig_idx)\n",
    "        \n",
    "        # internal assertions to make sure term is zeroed first\n",
    "        assert np.isclose(0., mc.value_in_unit_system(unit.md_unit_system))\n",
    "        assert np.isclose(0., me.value_in_unit_system(unit.md_unit_system))\n",
    "        \n",
    "        _ = nbf.setParticleParameters(lig_idx, oc, os, oe*0.) # turn on charge, zero sterics\n",
    "        _ = nbf.updateParametersInContext(mod_context)\n",
    "        mod_e = mod_context.getState(getEnergy=True, groups={lig_env_nbf_idx}).getPotentialEnergy().value_in_unit_system(unit.md_unit_system)\n",
    "        _ = interaction_energies.append(mod_e)\n",
    "        \n",
    "        # revert back to zeros\n",
    "        _ = nbf.setParticleParameters(lig_idx, mc, ms, me)\n",
    "        _ = nbf.updateParametersInContext(mod_context)\n",
    "\n",
    "    return init_energy_by_fg, interaction_energies    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c4308a9f-7a8d-42cd-afba-5e5328aee7a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(\n",
    "    steps_per_collection: int, # number of md steps to run before collecting energies\n",
    "    num_collections: int, # number of energy collections to do\n",
    "    run_system: openmm.System, # system that will run `openmm.integrators.LangevinMiddleIntegrator`\n",
    "    collect_systems: typing.List[openmm.System], # returned system of `mod_pme_system`\n",
    "    ligand_indices: typing.List[int], # ligand indices\n",
    "    init_positions: np.ndarray * unit.nanometers, # initial positions\n",
    "    init_box_vectors: typing.Tuple[openmm.vec3.Vec3],\n",
    "    temperature: float = 300. * unit.kelvin,\n",
    "    ) -> typing.List:\n",
    "    \"\"\"function to run md and iteratively collect energies via `query_energies_by_force`;\n",
    "    returns a list of tuples. Each tuple is a returnable of `query_energies_by_force` for each of `num_collections`\"\"\"\n",
    "    run_integrator = openmm.LangevinMiddleIntegrator(temperature, 1., 0.002)\n",
    "    run_context = openmm.Context(run_system, \n",
    "                                 run_integrator,\n",
    "                                 PLATFORM)\n",
    "    run_context.setPositions(init_positions)\n",
    "    run_context.setPeriodicBoxVectors(*init_box_vectors)\n",
    "    run_context.setVelocitiesToTemperature(temperature)\n",
    "\n",
    "    collector_contexts = []\n",
    "    for coll_sys in collect_systems:\n",
    "        collector_integrator = openmm.VerletIntegrator(1.)\n",
    "        collector_context = openmm.Context(coll_sys, collector_integrator, PLATFORM)\n",
    "        collector_contexts.append(collector_context)\n",
    "\n",
    "    out = []\n",
    "    for _iter in range(num_collections):\n",
    "        print(f\"iter: {_iter}\")\n",
    "        run_integrator.step(steps_per_collection)\n",
    "        state = run_context.getState(getPositions=True)\n",
    "        internal_outs = []\n",
    "        for coll_context in collector_contexts:\n",
    "            init_energy_by_fg, interaction_energies = query_energies_by_force(\n",
    "                mod_context = coll_context, \n",
    "                ligand_indices = ligand_indices, \n",
    "                ref_posits = state.getPositions(asNumpy=True), \n",
    "                box_vectors = state.getPeriodicBoxVectors(),\n",
    "                get_forces=True)\n",
    "            internal_outs.append([init_energy_by_fg, interaction_energies])\n",
    "        out.append(internal_outs)\n",
    "\n",
    "    # garbage\n",
    "    del run_context\n",
    "    del run_integrator\n",
    "    for context in collector_contexts:\n",
    "        del context\n",
    "    \n",
    "    return out "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "73fb2b22-5edd-4361-9072-0becb3b96d2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.2893431387452243\n"
     ]
    }
   ],
   "source": [
    "ala = HostGuestExplicit()\n",
    "sys = ala.system\n",
    "posit = ala.positions\n",
    "top = ala.topology\n",
    "\n",
    "# mod the nbf to only do direct space pme\n",
    "nbf = sys.getForce(3)\n",
    "#nbf.setReciprocalSpaceForceGroup(13)\n",
    "\n",
    "solute_residue = list(top.residues())[1] # for host guest, residue 1 is B2 guest\n",
    "solute_atoms = list(solute_residue.atoms())\n",
    "min_idx = solute_atoms[0].index\n",
    "max_idx = solute_atoms[-1].index\n",
    "ligand_indices = list(range(min_idx, max_idx+1))\n",
    "\n",
    "run_sys = copy.deepcopy(sys)\n",
    "run_sys.removeForce(4) # remove the `CMMotionRemover`\n",
    "\n",
    "# add barostat.\n",
    "barostat = openmm.MonteCarloBarostat(1.01325, 300., 25)\n",
    "_ = run_sys.addForce(barostat)\n",
    "\n",
    "# make mod sys\n",
    "mod_sys_nopme = mod_pme_system(original_system = run_sys, \n",
    "                   ligand_indices = ligand_indices,\n",
    "                    use_pme=False)\n",
    "mod_sys_pme = mod_pme_system(original_system = run_sys, \n",
    "                   ligand_indices = ligand_indices,\n",
    "                    use_pme=True)\n",
    "mod_sys_bf = mod_pme_system(original_system = run_sys, \n",
    "                   ligand_indices = ligand_indices,\n",
    "                    use_pme=True,\n",
    "                    lig_lig_as_bf=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "69933b7b-b0df-4822-ac25-322413491535",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0\n",
      "iter: 1\n",
      "iter: 2\n",
      "iter: 3\n",
      "iter: 4\n",
      "iter: 5\n",
      "iter: 6\n",
      "iter: 7\n",
      "iter: 8\n",
      "iter: 9\n",
      "iter: 10\n",
      "iter: 11\n",
      "iter: 12\n",
      "iter: 13\n",
      "iter: 14\n",
      "iter: 15\n",
      "iter: 16\n",
      "iter: 17\n",
      "iter: 18\n",
      "iter: 19\n",
      "iter: 20\n",
      "iter: 21\n",
      "iter: 22\n",
      "iter: 23\n",
      "iter: 24\n",
      "iter: 25\n",
      "iter: 26\n",
      "iter: 27\n",
      "iter: 28\n",
      "iter: 29\n",
      "iter: 30\n",
      "iter: 31\n",
      "iter: 32\n",
      "iter: 33\n",
      "iter: 34\n",
      "iter: 35\n",
      "iter: 36\n",
      "iter: 37\n",
      "iter: 38\n",
      "iter: 39\n",
      "iter: 40\n",
      "iter: 41\n",
      "iter: 42\n",
      "iter: 43\n",
      "iter: 44\n",
      "iter: 45\n",
      "iter: 46\n",
      "iter: 47\n",
      "iter: 48\n",
      "iter: 49\n"
     ]
    }
   ],
   "source": [
    "outs = run(\n",
    "    steps_per_collection = 500, # number of md steps to run before collecting energies\n",
    "    num_collections = 50, # number of energy collections to do\n",
    "    run_system = run_sys, # system that will run `openmm.integrators.LangevinMiddleIntegrator`\n",
    "    collect_systems = [mod_sys_nopme, mod_sys_pme, mod_sys_bf], # returned system of `mod_pme_system`\n",
    "    ligand_indices = ligand_indices, # ligand indices\n",
    "    init_positions = posit, # initial positions\n",
    "    init_box_vectors = run_sys.getDefaultPeriodicBoxVectors(),\n",
    "    temperature = 300. * unit.kelvin,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "15c28203-cfc4-43c0-b11a-e8766587478d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_energy_discrepancy(query_e_by_f):\n",
    "    outs = query_e_by_f\n",
    "    base_energy = outs[0][0][-1] # env-env interaction energy\n",
    "    test_energies = outs[1] # env-env energy  + interaction energy\n",
    "    all_energies = [q - base_energy for q in test_energies] # interaction energy only\n",
    "    total_inter_energy = np.sum(all_energies) # sum of interaction energies\n",
    "    total_nb_energy = outs[0][0][0] # total unmod energy\n",
    "    \n",
    "    total_steric_energy = outs[0][0][1]\n",
    "    env_env_elec_energy = outs[0][0][2]\n",
    "    ligand_ligand_elec_energy_dir = outs[0][0][3]\n",
    "\n",
    "    discrepancy = total_nb_energy - (total_steric_energy + env_env_elec_energy + ligand_ligand_elec_energy_dir + total_inter_energy)\n",
    "    return discrepancy   \n",
    "\n",
    "def energy_discrepancy_analysis(run_outs):\n",
    "    num_iters = len(run_outs)\n",
    "    discrepancies = []\n",
    "    for _iter in range(num_iters):\n",
    "        disc_energy = eval_energy_discrepancy(run_outs[_iter])\n",
    "        discrepancies.append(disc_energy)\n",
    "    return discrepancies  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "01cb080e-3993-43e5-8342-947478ccece9",
   "metadata": {},
   "outputs": [],
   "source": [
    "nopme_outs = [outs[i][0] for i in range(len(outs))]\n",
    "pme_outs = [outs[i][1] for i in range(len(outs))]\n",
    "bf_outs = [outs[i][2] for i in range(len(outs))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "13842471-50a9-4dab-9533-951f4d55f8e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "discrepancies = [energy_discrepancy_analysis(q) for q in [nopme_outs, pme_outs, bf_outs]]\n",
    "discrepancies = np.array(discrepancies) * unit.kilojoule_per_mole\n",
    "discrepancies = discrepancies / kT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "806bef03-7dd3-4281-9525-8f64703658f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Full NB Energy - Constructed NB Energy [kT]')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = range(50)\n",
    "for disc, legend in zip(discrepancies, ['DIRECT SPACE: Control', 'PME', 'BF']):\n",
    "    plt.plot(x, disc, label=legend, ls='none', marker='o')\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('time [ps]')\n",
    "plt.ylabel(f\"Full NB Energy - Constructed NB Energy [kT]\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "399a7668-f717-4d12-80a6-8fc5b5b94f57",
   "metadata": {},
   "source": [
    "This plot shows the difference between the full nonbonded force energy and the reconstructed energy (separated into env-env, lig-env, lig-lig interactions) for three different experiments for a variety of snapshots in time. `Direct Space` is the energy discrepancy between the direct-space only full nonbonded energy and that of the reconstructed direct-space only nonbonded energy. `PME` shows the energy discrepancy between full nonbonded energy (direct and reciprocal space) with the reconstructed energy (env-env, lig-env are computed w/ direct + reciprocal whilst lig-lig is direct only). `BF` is the same as `PME`, but the lig-lig energy is explicitly written as a direct space electrostatic interaction with a CustomBondForce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "daa7031e-eafd-443b-ab1a-1dce3c8ba98d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "63778a2c-049b-47a0-85f6-875957d73626",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_20798/1764043269.py:1: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(discrepancies[0] - np.mean(discrepancies[0]), label=f\"DIRECT SPACE\")\n",
      "/tmp/ipykernel_20798/1764043269.py:2: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(discrepancies[1] - np.mean(discrepancies[1]), label=f\"PME\")\n",
      "/tmp/ipykernel_20798/1764043269.py:3: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(discrepancies[2] - np.mean(discrepancies[2]), label=f\"BF\")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.0, 1.0)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHFCAYAAAAOmtghAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAACMVElEQVR4nOzdd3hTZfvA8W+ajnTvTReUJXsvAQHZIOJCFAEFf/LiQsQBDnC8L4oLF4rKciGCgnuAsmRvkL3aQmnponsn5/dHSCC0QEfa06T357pyJTl5zjn3SdP07jM1iqIoCCGEEELYCQe1AxBCCCGEsCZJboQQQghhVyS5EUIIIYRdkeRGCCGEEHZFkhshhBBC2BVJboQQQghhVyS5EUIIIYRdkeRGCCGEEHZFkhshhBBC2BVJbkSdNWvWLDQajcW26Ohoxo8fX6njbN68mVmzZpGZmVmp/a4817p169BoNKxYsaJSx7mW/Px8Zs2axbp168q8tnjxYjQaDXFxcVY7X014/vnniYyMxNHRER8fH7XDsSnl/YxvuukmbrrpJtVisnVV+Y4Q9sdR7QCEqIyVK1fi5eVVqX02b97MSy+9xPjx4yv1x7cq56qs/Px8XnrpJYAyf9CGDh3Kli1bCA0NrdEYquOHH37gv//9L8899xyDBw/GxcVF7ZBs3rx589QOwabVxu+tqPskuRE2pV27djV+joKCAlxdXWvlXNcSGBhIYGCgqjFcz7///gvAY489RlBQkMrRVE5+fj5ubm5qh1HGDTfcUGvnKikpQaPR4OhoP38K1P69FXWDNEuJOuGXX36hbdu2uLi4EBMTw5tvvlluuSurnA0GA6+++ipNmzbF1dUVHx8fWrduzbvvvgsYm7aeeuopAGJiYtBoNGg0GnMzUHR0NMOGDeP777+nXbt26HQ6c03K1aq3CwsLmTp1KiEhIbi6utK7d2/27NljUeZqTQvjx48nOjoagLi4OHPy8tJLL5ljM53zas1SCxcupE2bNuh0Ovz8/Bg5ciSHDx8ucx4PDw9OnDjBkCFD8PDwICIigieffJKioqJy39vLGQwG5syZQ7NmzXBxcSEoKIixY8dy9uxZc5no6Gief/55AIKDg9FoNMyaNeuax925cye33HILfn5+6HQ62rVrx7fffmtRxnTda9eu5T//+Q8BAQH4+/tz2223ce7cuTLHXLZsGd26dcPd3R0PDw8GDhxY5udhej8OHDjAgAED8PT0pF+/fgBkZmYyYcIE/Pz88PDwYOjQoZw6dcriejZu3IhGo2Hp0qVlzv/555+j0WjYsWPHNa9969at9OjRA51OR1hYGNOnT6ekpKRMufI+Ox999BFt2rTBw8MDT09PmjVrxowZMyzKJCYm8n//939ERETg7OxMWFgYd9xxB+fPnwcuNat+8cUXPPnkk4SHh+Pi4sKJEycAWLNmDf369cPLyws3Nzd69OjBX3/9ZXEOU1Pxnj17uO222/Dy8sLb25sxY8aQmppa5ucyYMAAQkNDcXV1pXnz5jz77LPk5eWV+7OpyGe1qKiIl19+mebNm6PT6fD396dPnz5s3rzZXKa839vs7GymTZtGTEwMzs7OhIeHM2XKlDKxLF++nC5duuDt7Y2bmxsNGzbkgQceKPMzEnWf/aTrwmb99ddfjBgxgm7duvHNN9+g1+uZM2eO+Uv5WubMmcOsWbN4/vnn6dWrFyUlJRw5csTcv2bixIlkZGTw/vvv8/3335ubeC7/73j37t0cPnyY559/npiYGNzd3a95zhkzZtC+fXs+++wzsrKymDVrFjfddBN79uyhYcOGFb7u0NBQfv/9dwYNGsSECROYOHEiwDVra2bPns2MGTMYPXo0s2fPJj09nVmzZtGtWzd27NhB48aNzWVLSkq45ZZbmDBhAk8++SQbNmzglVdewdvbmxdffPGasf3nP//hk08+4ZFHHmHYsGHExcXxwgsvsG7dOnbv3k1AQAArV67kww8/ZMGCBfz+++94e3vToEGDqx5z7dq1DBo0iC5duvDxxx/j7e3NN998w6hRo8jPzy/zB2nixIkMHTqUr7/+mjNnzvDUU08xZswY/v77b3OZ//3vfzz//PPcf//9PP/88xQXF/PGG2/Qs2dPtm/fbvFzLi4u5pZbbuGhhx7i2WefpbS0FIPBwPDhw9m5cyezZs2iffv2bNmyhUGDBlnE0rNnT9q1a8eHH37I6NGjLV774IMP6NSpE506dbrqtR86dIh+/foRHR3N4sWLcXNzY968eXz99dfX/DkAfPPNN0yePJlHH32UN998EwcHB06cOMGhQ4fMZRITE+nUqRMlJSXMmDGD1q1bk56ezh9//MGFCxcIDg42l50+fTrdunXj448/xsHBgaCgIL788kvGjh3LiBEjWLJkCU5OTsyfP5+BAwfyxx9/mBNBk5EjR3LXXXcxadIkDh48yAsvvMChQ4fYtm0bTk5OABw/fpwhQ4YwZcoU3N3dOXLkCK+//jrbt2+3+BlCxT6rpaWlDB48mI0bNzJlyhT69u1LaWkpW7duJSEhge7du5f7/uXn59O7d2/Onj1rfm8OHjzIiy++yIEDB1izZg0ajYYtW7YwatQoRo0axaxZs9DpdMTHx5eJVdgIRQiVdenSRQkLC1MKCgrM27KzsxU/Pz/lyo9oVFSUMm7cOPPzYcOGKW3btr3m8d944w0FUE6fPl3mtaioKEWr1SpHjx4t97XLz7V27VoFUNq3b68YDAbz9ri4OMXJyUmZOHGieVvv3r2V3r17lznmuHHjlKioKPPz1NRUBVBmzpxZpuyiRYss4r5w4YLi6uqqDBkyxKJcQkKC4uLiotxzzz0W5wGUb7/91qLskCFDlKZNm5Y51+UOHz6sAMrkyZMttm/btk0BlBkzZpi3zZw5UwGU1NTUax5TURSlWbNmSrt27ZSSkhKL7cOGDVNCQ0MVvV5vcd1Xnn/OnDkKoCQlJZmv29HRUXn00UctyuXk5CghISHKXXfdZd5mej8WLlxoUfaXX35RAOWjjz6y2D579uwyPxdTXHv27DFv2759uwIoS5Ysuea1jxo1SnF1dVWSk5PN20pLS5VmzZqV+Wxe+dl55JFHFB8fn2se/4EHHlCcnJyUQ4cOXbWM6fPbq1cvi+15eXmKn5+fMnz4cIvter1eadOmjdK5c2fzNtPP+4knnrAo+9VXXymA8uWXX5Z7boPBoJSUlCjr169XAGXfvn3m1yr6Wf38888VQPn000+veo2KUvb3dvbs2YqDg4OyY8cOi3IrVqxQAOXXX39VFEVR3nzzTQVQMjMzr3l8YRukWUqoKi8vjx07dnDbbbeh0+nM2z09PRk+fPh19+/cuTP79u1j8uTJ/PHHH2RnZ1c6htatW9OkSZMKl7/nnnssRnFFRUXRvXt31q5dW+lzV8aWLVsoKCgoU8MRERFB3759yzQhaDSaMu9h69atiY+Pv+Z5TNdx5Xk6d+5M8+bNy5ynIk6cOMGRI0e49957AeN/4abbkCFDSEpK4ujRoxb73HLLLWViB8zx//HHH5SWljJ27FiL4+l0Onr37l3uCLTbb7/d4vn69esBuOuuuyy2X1k7Y9oWFBTEhx9+aN72/vvvExgYyKhRo655/WvXrqVfv34WNSharfa6+4Hxfc/MzGT06NH88MMPpKWllSnz22+/0adPH5o3b37d4135HmzevJmMjAzGjRtn8T4aDAYGDRrEjh07yjTfmH6OJnfddReOjo4WvwOnTp3innvuISQkBK1Wi5OTE7179wYo04xakc/qb7/9hk6nq3Qz0c8//0zLli1p27atxfUNHDjQoonaVPN211138e2335KYmFip84i6RZIboaoLFy5gMBgICQkp81p52640ffp03nzzTbZu3crgwYPx9/enX79+7Ny5s8IxVHY00tViTU9Pr9RxKst0/PLiDQsLK3N+Nzc3i4QRwMXFhcLCQquepyJMTYzTpk3DycnJ4jZ58mSAMn+0/f39y8QOxg7flx+zU6dOZY65bNmyMsdzc3MrM4omPT0dR0dH/Pz8LLZfnoRcfv6HHnqIr7/+mszMTFJTU/n222+ZOHHidUeJpaenV/kzft9997Fw4ULi4+O5/fbbCQoKokuXLqxevdpcJjU19ZpNgpe78udqeh/vuOOOMu/j66+/jqIoZGRkXDNuR0dH/P39zZ+N3NxcevbsybZt23j11VdZt24dO3bs4Pvvvwcu/QxNKvJZTU1NJSwsDAeHyv3ZOn/+PPv37y9zbZ6eniiKYv6c9OrVi1WrVpkT5gYNGtCyZcty+1mJuk/63AhV+fr6otFoSE5OLvNaeduu5OjoyNSpU5k6dSqZmZmsWbOGGTNmMHDgQM6cOVOh0TBXzqVzPVeL9fI/xjqdjqysrDLlyvuvu6JMx09KSirz2rlz5wgICKjysa92niv/YFb1PKZ9pk+fzm233VZumaZNm1bpmCtWrCAqKuq65cv7Ofv7+1NaWkpGRoZFgnO1z95//vMfXnvtNRYuXEhhYSGlpaVMmjTpuuf29/ev8mcc4P777+f+++8nLy+PDRs2MHPmTIYNG8axY8eIiooiMDDQorP3tVz5Ppjex/fff5+uXbuWu8+VyV5ycjLh4eHm56WlpaSnp5s/O3///Tfnzp1j3bp15toaoNJzTV0uMDCQf/75B4PBUKkEJyAgAFdXVxYuXHjV101GjBjBiBEjKCoqYuvWrcyePZt77rmH6OhounXrVuXYRe2TmhuhKnd3dzp37sz3339v8V9aTk4OP/30U6WO5ePjwx133MHDDz9MRkaGeZTRlf/xV9fSpUtRFMX8PD4+ns2bN1uMcImOjubYsWMWoz3S09MtRnVUNrZu3brh6urKl19+abH97Nmz/P3332U6fVZV3759AcqcZ8eOHRw+fLhK52natCmNGzdm3759dOzYsdybp6dnpY45cOBAHB0dOXny5FWPeT2mP7zLli2z2P7NN9+UWz40NJQ777yTefPm8fHHHzN8+HAiIyOve54+ffrw119/WXSS1+v1Zc57Pe7u7gwePJjnnnuO4uJiDh48CMDgwYNZu3Ztmaa9iujRowc+Pj4cOnToqu+js7OzxT5fffWVxfNvv/2W0tJS8++AKYG6skZr/vz5lY7PZPDgwRQWFrJ48eJK7Tds2DBOnjyJv79/uddmGr14ORcXF3r37s3rr78OUGb0naj7pOZGqO6VV15h0KBB9O/fnyeffBK9Xs/rr7+Ou7t7merwKw0fPpyWLVvSsWNHAgMDiY+PZ+7cuURFRZlHDrVq1QqAd999l3HjxuHk5ETTpk0r/cfUJCUlhZEjR/Lggw+SlZXFzJkz0el0TJ8+3VzmvvvuY/78+YwZM4YHH3yQ9PR05syZU6ZZxNPTk6ioKH744Qf69euHn58fAQEB5X7h+vj48MILLzBjxgzGjh3L6NGjSU9P56WXXkKn0zFz5swqXc+VmjZtyv/93//x/vvv4+DgwODBg82jpSIiInjiiSeqdNz58+czePBgBg4cyPjx4wkPDycjI4PDhw+ze/duli9fXqnjRUdH8/LLL/Pcc89x6tQpBg0ahK+vL+fPn2f79u24u7ubh/VfzaBBg+jRowdPPvkk2dnZdOjQgS1btvD5558DlFtD8Pjjj9OlSxcAFi1aVKFYn3/+eX788Uf69u3Liy++iJubGx9++GGZvizlefDBB3F1daVHjx6EhoaSnJzM7Nmz8fb2NvcTefnll/ntt9/o1asXM2bMoFWrVmRmZvL7778zdepUmjVrdtXje3h48P777zNu3DgyMjK44447CAoKIjU1lX379pGamspHH31ksc/333+Po6Mj/fv3N4+WatOmjbnvUvfu3fH19WXSpEnMnDkTJycnvvrqK/bt21eh96s8o0ePZtGiRUyaNImjR4/Sp08fDAYD27Zto3nz5tx9993l7jdlyhS+++47evXqxRNPPEHr1q0xGAwkJCTw559/8uSTT9KlSxdefPFFzp49S79+/WjQoAGZmZm8++67Fn2FhA1RuUOzEIqiKMqPP/6otG7dWnF2dlYiIyOV1157zTwy43JXjoR46623lO7duysBAQHmfSdMmKDExcVZ7Dd9+nQlLCxMcXBwUABl7dq15uMNHTq03JiuNlrqiy++UB577DElMDBQcXFxUXr27Kns3LmzzP5LlixRmjdvruh0OuWGG25Qli1bVma0lKIoypo1a5R27dopLi4uCmA+55WjpUw+++wz83vl7e2tjBgxQjl48KBFmXHjxinu7u5lYirvPS2PXq9XXn/9daVJkyaKk5OTEhAQoIwZM0Y5c+ZMuceryGgpRVGUffv2KXfddZcSFBSkODk5KSEhIUrfvn2Vjz/+2FzGdN1Xjm4xvf+mn53JqlWrlD59+iheXl6Ki4uLEhUVpdxxxx3KmjVrzGWu9n4oiqJkZGQo999/v+Lj46O4ubkp/fv3V7Zu3aoAyrvvvlvuPtHR0Urz5s0rdM0mmzZtUrp27aq4uLgoISEhylNPPaV88skn1x0ttWTJEqVPnz5KcHCw4uzsrISFhSl33XWXsn//fovjnzlzRnnggQeUkJAQxcnJyVzu/PnziqJcev+WL19ebnzr169Xhg4dqvj5+SlOTk5KeHi4MnToUIvypp/3rl27lOHDhyseHh6Kp6enMnr0aPN5TDZv3qx069ZNcXNzUwIDA5WJEycqu3fvVgBl0aJF5nKV+awWFBQoL774otK4cWPF2dlZ8ff3V/r27ats3rzZXObK31tFUZTc3Fzl+eefV5o2bWr+vWnVqpXyxBNPmEew/fzzz8rgwYOV8PBwxdnZWQkKClKGDBmibNy4sdz3S9RtGkW5rH5dCCEEX3/9Nffeey+bNm0qM3/K/v37adOmDR9++KG5M3R9MWvWLF566SVSU1Ot1sdLiJogzVJCiHpt6dKlJCYm0qpVKxwcHNi6dStvvPEGvXr1skhsTp48SXx8PDNmzCA0NFQWZxSiDpPkRghRr3l6evLNN9/w6quvkpeXZ05cXn31VYtyr7zyCl988QXNmzdn+fLldXJdKiGEkTRLCSGEEMKuqDoUfMOGDQwfPpywsDA0Gg2rVq267j7r16+nQ4cO6HQ6GjZsyMcff1zzgQohhBDCZqia3OTl5dGmTRs++OCDCpU/ffo0Q4YMoWfPnuzZs4cZM2bw2GOP8d1339VwpEIIIYSwFXWmWUqj0bBy5UpuvfXWq5Z55pln+PHHHy3WJZk0aRL79u1jy5YttRClEEIIIeo6m+pQvGXLFgYMGGCxbeDAgSxYsICSkhKcnJzK7FNUVGQxS6zBYCAjIwN/f/9KT7svhBBCCHUoikJOTk6F1hizqeQmOTm5zBonwcHBlJaWkpaWVu5Cf7Nnz77uLKVCCCGEsA1nzpy57kKxNpXcQNlF30ytalerhZk+fTpTp041P8/KyiIyMpIzZ86UmQpfCGGfWs78w/z435cGGh/s/vIqpa+h/RgrRSSEqKzs7GwiIiIqtHSOTSU3ISEhZVbRTUlJwdHR0WJF5su5uLiUWbwNwMvLS5IbIeoJB5dLc9KYf+89XCt/IPnOEEJ1FelSYlOrgnfr1o3Vq1dbbPvzzz/p2LFjuf1thBBCCFH/qJrc5ObmsnfvXvbu3QsYh3rv3buXhIQEwNikNHbsWHP5SZMmER8fz9SpUzl8+DALFy5kwYIFTJs2TY3whRBCCFEHqdostXPnTvr06WN+buobM27cOBYvXkxSUpI50QGIiYnh119/5YknnuDDDz8kLCyM9957j9tvv73WYxdCCCFE3aRqcnPTTTdxrWl2Fi9eXGZb79692b17dw1GJYQQojL0ej0lJSVqhyHsgLOz83WHeVeETXUoFkIIUXcoikJycjKZmZlqhyLshIODAzExMTg7O1frOJLcCCGEoRSO/Azn9oCrHzTqByEt1Y6qzjMlNkFBQbi5ucnEqKJaDAYD586dIykpicjIyGp9niS5EULUb4oBts2H9OPG54VZsGshdH4IApuqG1sdptfrzYnN1abiEKKyAgMDOXfuHKWlpdUaBW1TQ8GFEMLqErYaExutC7QdA6FtjQnPrkVQlKN2dHWWqY+Nm5vbdUoKUXGm5ii9Xl+t40hyI4Sov0oK4OivxsdNh0CDjsYExyscSgvh1DpVw7MF0hQlrMlanydJboQQ9VfCVijOBfcgiL7RuE3rCE0GGR/H/wPF+erFJ4SoEkluhBD1k6LA2e3Gxw17g4P20mvBLcAzFEqL4MxWdeITQlSZdCgWQtRP2YmQkwQOjhDazvI1jYOxJufAcuMIqkZ91YnRRn29LeH6hazoni6RlSo/fvx4lixZAoCjoyN+fn60bt2a0aNHM378eIt5VqKjo5kyZQpTpkwxP4+PjwdAp9MRFRXFhAkTmDZtmrlJJS4ujpiYmHLPvWXLFrp27QpAcXExc+fO5auvvuL48eO4ubnRtGlTJk6cyJgxY647HNo04e2VUlJSeOGFF/jtt984f/48vr6+tGnThlmzZtGtW7cy1+Hq6krDhg159NFHeeihhyyO1bRpU06fPs3p06cJDw8vc661a9fyxhtvsG3bNgoKCoiOjmbw4MFMnTqV8PBw1q1bZzFZ7+WSkpIICQm55jVWldTcCCHqp7M7jPfBLcG5nE6xIa0BDWSdgby0Wg1N1LxBgwaRlJREXFwcv/32G3369OHxxx9n2LBhlJaWXnPfl19+maSkJA4fPsy0adOYMWMGn3zySZlya9asISkpyeLWoUMHwJjYDBw4kNdee43/+7//Y/PmzWzfvp2HH36Y999/n4MHD1rsN3fuXLy8vCy2vfvuu+XGd/vtt7Nv3z6WLFnCsWPH+PHHH7npppvIyMgo9zr279/PrbfeyqRJk1i2bJn59X/++YfCwkLuvPPOcpOo+fPnc/PNNxMSEsJ3333HoUOH+Pjjj8nKyuKtt96yKHv06NEy70VQUNA13+fqkJobIUT9oyhw/l/j4/AO5Zdx8YSAxpB2DJL2QuzNtRaeqHkuLi7mWoPw8HDat29P165d6devH4sXL2bixIlX3dfT09O878SJE/noo4/4888/y9R6+Pv7X7VmYu7cuWzYsIGdO3fSrt2lmsOGDRty5513UlxcjLu7u3m7t7c3Go3mujUdmZmZ/PPPP6xbt47evXsDEBUVRefOna95Ha+++irffvstq1atYtSoUQAsWLCAe+65h969e/Pwww8zY8YMc+3U2bNneeyxx3jsscd45513zMeMjo6mV69eZSZ2DAoKwsfH55qxW5PU3Agh6p+MU5CfDhotBDS5ermwi390kvbVTlxCVX379qVNmzZ8//33FSqvKArr1q3j8OHDlZ6T5auvvuLmm2+2SGxMnJycLBKbyvDw8MDDw4NVq1ZRVFRUqX11Op15iH9OTg7Lly9nzJgx9O/fn7y8PNatW2cuu3z5coqLi3n66afLPVZtJjLlkeRGCFH/nPzbeO8XA44uVy8XdIPxPussFOfVfFxCdc2aNSMuLu6aZZ555hk8PDxwcXGhT58+KIrCY489VqZc9+7dzcmG6Waav+X48eM0a9bM6vE7OjqyePFilixZgo+PDz169GDGjBns37//qvuUlpayePFiDhw4QL9+/QD45ptvaNy4MS1atECr1XL33XezYMEC8z7Hjx/Hy8uL0NDQCsXVoEEDi/ehadOanSBTmqWEEPXPib+M94HX+eOi8waPYMg9D+knaj4uoTpFUa4718pTTz3F+PHjSU1N5bnnnqNv37507969TLlly5bRvHlzi21arbbC56mq22+/naFDh7Jx40a2bNnC77//zpw5c/jss88YP368udwzzzzD888/T1FREc7Ozjz11FPmprUFCxYwZswYc9kxY8aYm5t8fHwqHf/GjRvx9PQ0P3d0rNn0Q5IbIUT9oi+BuI3GxxVZXiGgiTG5STtWs3GJOuHw4cNXHelkEhAQQGxsLLGxsXz33XfExsbStWtXbr7Zsl9WREQEsbGx5R6jSZMmHD582GpxX0mn09G/f3/69+/Piy++yMSJE5k5c6ZFcmNK0tzc3AgNDTUnK4cOHWLbtm3s2LGDZ555xlxer9ezdOlS/vOf/9CkSROysrJISkqqUO1NTEyM9LkRQogak7zfOHGfk5txJuLrMfXJkeTG7v39998cOHCA22+/vcL7+Pr68uijjzJt2jQURanwfvfccw9r1qxhz549ZV4rLS0lL8+6zaA33HBDmWOakrSwsDCLWpgFCxbQq1cv9u3bx969e823p59+2tw0dccdd+Ds7MycOXPKPZ/aK8VLciOEqF/O7jTe+0QZ57O5Hv9YQAN5qZCVWKOhidpTVFREcnIyiYmJ7N69m//973+MGDGCYcOGMXbs2Eod6+GHH+bo0aN89913FtvT09NJTk62uBUWFgIwZcoUevToQb9+/fjwww/Zt28fp06d4ttvv6VLly4cP368SteVnp5O3759+fLLL9m/fz+nT59m+fLlzJkzhxEjRlx3/5KSEr744gtGjx5Ny5YtLW4TJ05k165d7Nu3j4iICN555x3effddJkyYwPr164mPj2fTpk089NBDvPLKKxbHTUlJKfNemDov1wRplhJC2L6di65T4LL5NPZ9Y7z3ja7YsZ1cjTU82WeNc+N4V6C2R9R5v//+O6GhoTg6OponuXvvvfcYN26cxSR+FREYGMh9993HrFmzuO2228zbr2ymAli6dCl33303Li4urF69mnfeeYf58+czbdo03NzcaN68OY899hgtW7as0nV5eHjQpUsX3nnnHU6ePElJSQkRERE8+OCDzJgx47r7//jjj6SnpzNy5MgyrzVu3JhWrVqxYMEC3nvvPSZPnkyTJk148803GTlypHkSv2HDhjF16lSLfcvrQHz5hIbWplEqU49mB7Kzs/H29iYrKwsvLy+1wxFCWMN1kpvoFZeSmzjfR6AgA7r8p2J9bsA4U3H8Juj2CAz8b3UitRuFhYWcPn2amJgYdDqd2uEIO3Gtz1Vl/n5Ls5QQot4IJNOY2KAxNktVlKls4q6aCEsIYWWS3Agh6o12Dhf7MXiGgFMlaht8LyY35/YYR1sJIeo0SW6EEPVGS4fTxgc+lVtoEfdA4+iq0sJLyzYIIeosSW6EEPXGDRrjKsh4NajcjhqHSwmRabSVEKLOkuRGCFFv3OBgSm7CKr+zKbmRdaaEqPMkuRFC1As+5BCmyTA+qUpyY5rwL/mA9YISQtQISW6EEPVCc4cE4wM3f+PcNZVlSm5SDkunYiHqOEluhBD1wg2aOOODiiy5UB43P3DxAn0RpFVt9lghRO2Q5EYIUS9c6m9TxeRG4wDBLYyPpWlKiDpNkhshRL3QTHPG+KAq/W1MQloZ75P3Vz8gIUSNkbWlhBB2zwEDjTTnjE88Q6p+IEluKua6a31ZWcf7K1V8/PjxLFmyBABHR0ciIiK47bbbeOmll0hNTSUmJgatVkt8fDzh4Zdq+pKSkoiIiECv13P69Gmio6OJi4sjJiam3PPU5NpJ4tqk5kYIYfcaaFLRaUooUpyMHYqrKvjiYoYph60TmFDNoEGDSEpK4tSpU7z66qvMmzePadOmmV8PCwvj888/t9hnyZIlFsnO5dasWUNSUpLFrUOHDjV6DeLqJLkRQti9xpqzAJxUwox9Z6rKtNBmXirkpVshMqEWFxcXQkJCiIiI4J577uHee+9l1apV5tfHjRvHokWWNVCLFy9m3Lhx5R7P39+fkJAQi5uTk1NNXoK4BkluhBB2L/Zik9RxpYqdiU2c3S9N5pd6pJpRibrE1dWVkpJLQ/xvueUWLly4wD///APAP//8Q0ZGBsOHD1crRFEJktwIIexeY4dEAE4YqtGZ2CSwufE+VZqm7MX27dv5+uuv6devn3mbk5MTY8aMYeHChQAsXLiQMWPGXLU2pnv37nh4eFjc9Hp9rcQvypIOxUIIuxd7sVnquFLJNaXKE9QMjv8BKVJzY8t+/vlnPDw8KC0tpaSkhBEjRvD++++Tn59vLjNhwgS6devG//73P5YvX86WLVsoLS0t93jLli2jefPmFtu0Wm2NXoO4OkluhBD2TVGs1ywFENjMeC/NUjatT58+fPTRRzg5OREWFmaukYmLizOXadmyJc2aNWP06NE0b96cli1bsnfv3nKPFxERQWxsbC1ELipCmqWEEPatMAsPTSElipZ4Jbj6x5Pkxi64u7sTGxtLVFTUNTv+PvDAA6xbt44HHnigFqMT1SU1N0II+5aXAkCCEkSpNb7yrhwx5V6NoeWiznvwwQe588478fHxuWa59PR0kpOTLbb5+Pig0+lqMDpxNVJzI4Swb3mpAMQp1Zi873LO7uB9ccRU2jHrHFPUWY6OjgQEBODoeO3E+OabbyY0NNTidvnQclG7pOZGCGHfLiY3p62V3AD4N4SsBMg4CVHdrHdce1HJGYNr2+LFi6/6WnR0NIqiXPX1tm3bWrx+vfJCHVJzI4Swb7lWrrkB8L/YcTT9pPWOKYSwGkluhBD27WLNzSkl1HrH9GtkvE8/Yb1jCiGsRpIbIYT9MughPw2AOIM1a24uJjcZp6x3TCGE1UhyI4SwXwUXQDFQqDiRhJ/1jut3WXIj/S2EqHMkuRFC2K+Lw8DjlBAUa37d+UaBRgsl+ZCTZL3jCiGsQpIbIYT9svYwcBOt06UFNKVTsRB1jiQ3Qgj7lZ8OQJw1Zia+knnElHQqFqKukeRGCGG/8ozJzRklyPrHNncqlpobIeoaSW6EEPbrYs2NVdaUupJ5OLiMmBKirpHkRghhnxTFnNwk1EjNTUPjvdTcCFHnyPILQgj7VJQNhhLQOHBOqYHFLc3DwU8b59Nx0Fr/HDZq+bHltXq+O5vcWany48ePZ8mSJebnfn5+dOrUiTlz5tC6dWsANBpNmf169OjBP//8U71gRa2QmhshhH26WGuDq691VgO/kncEODiBvgiyzlr/+KJGDRo0iKSkJJKSkvjrr79wdHRk2LBhFmUWLVpkLpOUlMSPP/6oUrSisqTmRghhn/KMMxPj5g8ZNXB8rSP4RkP6cWPTlG9UDZxE1BQXFxdCQoxTBISEhPDMM8/Qq1cvUlNTCQwMBMDHx8dcRtgWqbkRQtgnU82NWw00SZnIApp2ITc3l6+++orY2Fj8/Wvw8yJqjdTcCCHsU60kN7LGlK36+eef8fDwACAvL4/Q0FB+/vlnHBwu/c8/evRotNpLfam+/PJLbr311toOVVSBJDdCCPtUG8mN38URU1JzY3P69OnDRx99BEBGRgbz5s1j8ODBbN++nagoYxPjO++8w80332zeJzTUiivLixolyY0Qwj7lX+xoUxs1NzJLsc1xd3cnNjbW/LxDhw54e3vz6aef8uqrrwLGvjiXlxG2Q/rcCCHsj77UOBQcwNW35s7jG228zzoDBkPNnUfUOI1Gg4ODAwUFBWqHIqxAam6EEPan8AKgGIdqO3vU3Hm8GhhXB9cXQ24yeIXV3LmEVRUVFZGcnAzAhQsX+OCDD8jNzWX48OEqRyasQZIbIYT9KbhgvHfzhXImY7MarSN4h0NmAlyIl+TGhvz+++/mPjSenp40a9aM5cuXc9NNN6kbmLAKSW6EEPbH1N/G1a/mz+UTZUxuMuMhqlvNn88GVHbG4Nq2ePFiFi9efM0yiqLUTjCiRkifGyGE/THV3NRkfxsTn4uT92Um1Py5hBAVIsmNEML+FNRizY1pZuIL8TV/LiFEhUhyI4SwP+ZmqdqsuZHkRoi6QvXkZt68ecTExKDT6ejQoQMbN268ZvmvvvqKNm3a4ObmRmhoKPfffz/p6em1FK0QwiaYOxTXYs2NJDdC1BmqJjfLli1jypQpPPfcc+zZs4eePXsyePBgEhLKb7v+559/GDt2LBMmTODgwYMsX76cHTt2MHHixFqOXAhRZykGKMw0Pq6VDsWRxvusROP8OvWMdLwV1mStz5Oqyc3bb7/NhAkTmDhxIs2bN2fu3LlERESYp8S+0tatW4mOjuaxxx4jJiaGG2+8kYceeoidO3fWcuRCiDqrMMuY4GgcQOdV8+fzCAGtCyh6yD5b8+erI5ycnADIz89XORJhT4qLiwEs1vSqCtWGghcXF7Nr1y6effZZi+0DBgxg8+bN5e7TvXt3nnvuOX799VcGDx5MSkoKK1asYOjQoVc9T1FREUVFRebn2dnZ1rkAIUTddPlIKU0t/P/m4AA+EcYlGDITLs1abOe0Wi0+Pj6kpKQA4ObmhqYm5xQSds9gMJCamoqbmxuOjtVLT1RLbtLS0tDr9QQHB1tsDw4ONs8aeaXu3bvz1VdfMWrUKAoLCyktLeWWW27h/fffv+p5Zs+ezUsvvWTV2IUQdVhtdiY28YkyJjcX4iGm9k6rtpCQEABzgiNEdTk4OBAZGVntRFn1SfyuvABFUa56UYcOHeKxxx7jxRdfZODAgSQlJfHUU08xadIkFixYUO4+06dPZ+rUqebn2dnZREREWO8ChBB1S4Eayc3Ffjf1rFOxRqMhNDSUoKAgSkpK1A5H2AFnZ2ccHKpf46pachMQEIBWqy1TS5OSklKmNsdk9uzZ9OjRg6eeegqA1q1b4+7uTs+ePXn11VfLXY7excUFFxcX61+AEKJuMjdL1UJnYhPf+j2Rn1arrXYfCSGsSbUOxc7OznTo0IHVq1dbbF+9ejXdu3cvd5/8/PwyGZ3pF0p67AshgEs1N7UxDNzERybyE6IuUXW01NSpU/nss89YuHAhhw8f5oknniAhIYFJkyYBxialsWPHmssPHz6c77//no8++ohTp06xadMmHnvsMTp37kxYmCxYJ4QA8mtx6QUTmchPiDpF1T43o0aNIj09nZdffpmkpCRatmzJr7/+SlSU8YsiKSnJYs6b8ePHk5OTwwcffMCTTz6Jj48Pffv25fXXX1frEoQQdYmiqNsslZMEpUXgKE3hQqhJo9Sz9pzs7Gy8vb3JysrCy6sW5sAQQtS8nYuM90U5sPoFQAND3gAH4/9v0SuCzEXj7qjGyJ6O95e/XVHgf+FQkgeP7IKA2KqfQwhRrsr8/VZ9+QUhhLAa0zBwFy9zYlMrNJrLOhXH1d55hRDlkuRGCGE/anNNqSuZh4PXzxFTQtQlktwIIeyHGnPcmMiIKSHqDEluhBD2oyDTeK9KcmNaQLP+rC8lRF0lyY0Qwn6YVgPX+dT+ub0bGO+zztT+uYUQFiS5EULYD3PNjU/tn9v74rIuUnMjhOokuRFC2I+6UHOTkwR6WWdJCDVJciOEsA+GUuM8N6BOzY17IGidQTEYExwhhGokuRFC2IfCbEABBy04u9f++R0cwCvc+FiapoRQlSQ3Qgj7cHmTlEalrzZzp2JJboRQkyQ3Qgj7YOpMXE5/mw7+xQD0Di6q2RjMnYplxJQQalJ14UwhhLCaa3QmjnLXsysdegQVV+8cpjWsriY/3Xh/fM2lhTuvth6VEKLGSM2NEMI+mIeBe6sXg2nyQNMyEEIIVUhyI4SwD+aaGxVmJzYxJTeFktwIoSZJboQQ9sGU3Khac+NjvM+/AIqiXhxC1HOS3Agh7IO5Q3EdqLnRF0FpgXpxCFHPSXIjhLB9Br26E/iZaJ0vzbFjSraEELVOkhshhO0rzAIU0Kg0gd/lpFOxEKqT5EYIYfvM/W181JvAz8TULFaQoW4cQtRjktwIIWyfeaSUip2JTdyk5kYItUlyI4SwfXWhM7GJNEsJoTpJboQQtq8uDAM3MTdLZaoahhD1mSQ3Qgjbd411pWqd1NwIoTpJboQQtu/yDsVqM89SnGUcoi6EqHWS3AghbF9BlvG+LtTcuHiAgxZQLg5RF0LUNkluhBC2TV8CRdnGx651oEOxxuGyfjfSNCWEGiS5EULYtpxk6swEfiam5jFTc5kQolZJciOEsG3Z54z3dWECPxNT85iMmBJCFXXkm0AIIaoo+6zxvi5M4GciNTdCqEqSGyGEbTPV3NSFzsQmUnMjhKokuRFC2LasRON9XRgGbiI1N0KoSpIbIYRty76Y3NTFmhtJboRQhSQ3QgjbdnmH4rrClNwU5UBpsaqhCFEfSXIjhLBtdbHmxtkdHByNj3POqRuLEPWQJDdCCNulL7k4zw11K7nRaC7Fky3JjRC1TZIbIYTtunwCPxcPtaOxZGomM3V4FkLUGkluhBC2yzwM3LvuTOBnYq65keRGiNpWx74NhBCiErLr4DBwE9OkgtIsJUStk+RGCGG76mJnYhPTIp5ScyNErZPkRghhuyo5O7FGU3OhlCHNUkKoRpIbIYTtMjdL1aF1pUxcpVlKCLVIciOEsF11cV0pE93FZqncFJnIT4haJsmNEMJ2ZScZ7+ticmOeyE+BnCS1oxGiXpHkRghhmwz6S0lDXRwtZTGRn/S7EaI2SXIjhLBNuSmg6C9O4OepdjTlk+HgQqhCkhshhG0yJQyeIXVvAj8TU42S1NwIUavq6DeCEEJchylh8ApTN45rMTVLyRIMQtQqSW6EELbJ1N+mLic3UnMjhCokuRFC2CZzzU24unFci05mKRZCDZLcCCFsk6nPTZ2uuZEOxUKoQZIbIYRtMncoDlU3jmsx9bmRifyEqFWS3AghbJMtNEs5e4DWGZnIT4jaJcmNEML2KMql2YnrcrOURnMpPmmaEqLWSHIjhLA9+RmgLzI+rsvNUgBeDYz30qlYiFojyY0QwvaYEgX3IHB0VjeW6zHX3EhyI0RtkeRGCGF7zCOl6nitDUizlBAqkORGCGF7bKEzsYn3xWaprLPqxiFEPSLJjRDC9tjCHDcmUnMjRK2T5EYIYXtsKrm5WLskyY0QtUaSGyGE7ckxJTc20CxlijH3vEzkJ0QtkeRGCGF7bKnmxs3/0kR+uclqRyNEvSDJjRDCtigKZF3sUOxpA8mNg8OlJCxLhoMLURskuRFC2JaibCjJMz62haHgcFm/G0luhKgNqic38+bNIyYmBp1OR4cOHdi4ceM1yxcVFfHcc88RFRWFi4sLjRo1YuHChbUUrRBCdaYmKZ0POLurGkqFyYgpIWqVo5onX7ZsGVOmTGHevHn06NGD+fPnM3jwYA4dOkRkZGS5+9x1112cP3+eBQsWEBsbS0pKCqWlpbUcuRBCNdk21JnYRGpuhKhVqiY3b7/9NhMmTGDixIkAzJ07lz/++IOPPvqI2bNnlyn/+++/s379ek6dOoWfnx8A0dHRtRmyEEJtttSZ2ESSGyFqlWrNUsXFxezatYsBAwZYbB8wYACbN28ud58ff/yRjh07MmfOHMLDw2nSpAnTpk2joKDgqucpKioiOzvb4iaEsGG2tPSCibfMdSNEbVKt5iYtLQ29Xk9wcLDF9uDgYJKTyx8ueerUKf755x90Oh0rV64kLS2NyZMnk5GRcdV+N7Nnz+all16yevxCCJXY0tILJjJaSohapXqHYo1GY/FcUZQy20wMBgMajYavvvqKzp07M2TIEN5++20WL1581dqb6dOnk5WVZb6dOXPG6tcghKhFttwslXse9CXqxiJEPaBachMQEIBWqy1TS5OSklKmNsckNDSU8PBwvL29zduaN2+OoiicPVv+onQuLi54eXlZ3IQQNswWkxu3gEsT+eUkqR2NEHZPteTG2dmZDh06sHr1aovtq1evpnv37uXu06NHD86dO0dubq5527Fjx3BwcKBBgwY1Gq8Qoo6wpaUXTBwcwPNiHyHpdyNEjVO1WWrq1Kl89tlnLFy4kMOHD/PEE0+QkJDApEmTAGOT0tixY83l77nnHvz9/bn//vs5dOgQGzZs4KmnnuKBBx7A1dVVrcsQQtSW4nwouGB8bEs1NwDeF/8BkxFTQtQ4VYeCjxo1ivT0dF5++WWSkpJo2bIlv/76K1FRUQAkJSWRkJBgLu/h4cHq1at59NFH6dixI/7+/tx11128+uqral2CEKI2mZp0nNzBxcaamKVTsRC1RtXkBmDy5MlMnjy53NcWL15cZluzZs3KNGUJIeoJ80ipMLjKwIM6S2YpFqLWqD5aSgghKswWOxObeJmapcof/CCEsB5JboQQtsMWl14wkZobIWqNJDdCCNthyzU3plmKpc+NEDVOkhshhO2wxaUXTGQiPyFqjSQ3QgjbYYtLL5hYTORX/hIzQgjrUH20lBBCVJgKzVLLM/ZX7wDHlpsfDtZ54ZGXxt8HvyA9sHE1IzO6s8mdVjmOEPZEam6EELahtBjyUoyPbbHmBihw8wXANf+CypEIYd+qVHNz+vRpYmJirB2LEEJcXe7FphytM7j5qxtLZcRtNj/MV/QAuJ3dA0rptfeLLn8ZGiHE9VWp5iY2NpY+ffrw5ZdfUlhYaO2YhBCirMubpGxtAr+LCpzdAXAtzlM5EiHsW5WSm3379tGuXTuefPJJQkJCeOihh9i+fbu1YxNCiEtMnYk9bXAY+EX5Lsbkxq1IkhshalKVkpuWLVvy9ttvk5iYyKJFi0hOTubGG2+kRYsWvP3226Smplo7TiFEfWfLc9xcJDU3QtSOanUodnR0ZOTIkXz77be8/vrrnDx5kmnTptGgQQPGjh1LUlKSteIUQtR3dpDcSM2NELWjWsnNzp07mTx5MqGhobz99ttMmzaNkydP8vfff5OYmMiIESOsFacQor6z5aUXLjLV3OhKCtAYDCpHI4T9qtJoqbfffptFixZx9OhRhgwZwueff86QIUNwcDDmSjExMcyfP59mzZpZNVghRD1mBzU3RU469BoHtIoB1+J88nUeaockhF2qUnLz0Ucf8cADD3D//fcTEhJSbpnIyEgWLFhQreCEEMLMDpIbNBoKnN3wKMrFtThPkhshakiVkpvVq1cTGRlprqkxURSFM2fOEBkZibOzM+PGjbNKkEKIek5fCjm23ywFUODigUdRLm7FeaSrHYwQdqpKfW4aNWpEWlpame0ZGRkyuZ8Qwvpyk0ExgIMTeASrHU215Du7AeAqnYqFqDFVSm4URSl3e25uLjqdrloBCSFEGVmmBTNDwcG2V42R4eBC1LxKNUtNnToVAI1Gw4svvoibm5v5Nb1ez7Zt22jbtq1VAxRCCLLOGO+9GqgbhxXIcHAhal6lkps9e/YAxpqbAwcO4OzsbH7N2dmZNm3aMG3aNOtGKIQQptmJvW0/uZGaGyFqXqWSm7Vr1wJw//338+677+Ll5VUjQQkhhIWss8Z7b9vuTAxScyNEbajSaKlFixZZOw4hhLi6LPuruTFN5KfYeB8iIeqiCic3t912G4sXL8bLy4vbbrvtmmW///77agcmhBBmdtTnRibyE6LmVTi58fb2RqPRmB8LIUStsaM+NzKRnxA1r8LJzeVNUdIsJYSoNcX5kH9xujs76HMDMpGfEDWtSo29BQUF5Ofnm5/Hx8czd+5c/vzzT6sFJoQQwKVlF5w9QOejaijWIhP5CVGzqpTcjBgxgs8//xyAzMxMOnfuzFtvvcWIESP46KOPrBqgEKKeM/e3CYeLTeO2rsA0YkqGgwtRI6qU3OzevZuePXsCsGLFCkJCQoiPj+fzzz/nvffes2qAQoh6zp7621yUb5rrRmpuhKgRVUpu8vPz8fT0BODPP//ktttuw8HBga5duxIfH2/VAIUQ9ZwdzXFjYhoOLjU3QtSMKiU3sbGxrFq1ijNnzvDHH38wYMAAAFJSUmRiPyGEdZmSGzsYBm5imshPam6EqBlVSm5efPFFpk2bRnR0NF26dKFbt26AsRanXbt2Vg1QCFHPmWtu7Ce5uXIiPyGEdVVphuI77riDG2+8kaSkJNq0aWPe3q9fP0aOHGm14IQQ4lKfG/tplpKJ/ISoWVVKbgBCQkIICQmx2Na5c+dqBySEEGaKclnNTYS6sViTTOQnRI2qUnKTl5fHa6+9xl9//UVKSgqGK6pVT506ZZXghBD1XMEFKLk4p5ZXmLqxWJlM5CdEzalScjNx4kTWr1/PfffdR2hoqHlZBiGEsCpTk5RbADi5qhuLlclEfkLUnColN7/99hu//PILPXr0sHY8QghxiR0OAzeRifyEqDlVGi3l6+uLn5+ftWMRQghL9tjf5iKZyE+ImlOl5OaVV17hxRdftFhfSgghrM48x43U3AghKq5KzVJvvfUWJ0+eJDg4mOjoaJycnCxe3717t1WCE0LUc3Y4x42J1NwIUXOqlNzceuutVg5DCCHKkZlgvPeJVDeOGmA5kZ8exUGrckRC2I8qJTczZ860dhxCCFGWHSc3lhP5FchcN0JYUZX63ABkZmby2WefMX36dDIyMgBjc1RiYqLVghNC1GMlhZCbbHzsE6VuLDXh4kR+AK7FuSoHI4R9qVLNzf79+7n55pvx9vYmLi6OBx98ED8/P1auXEl8fDyff/65teMUQtQ3pjlunNzAzT5HZ16ayC9fJvITwoqqVHMzdepUxo8fz/Hjx9HpdObtgwcPZsOGDVYLTghRj2XGG+99IsFOJwqVifyEqBlVSm527NjBQw89VGZ7eHg4ycnJ1Q5KCCHsub+NiQwHF6JmVCm50el0ZGdnl9l+9OhRAgMDqx2UEELUh+RGhoMLUTOqlNyMGDGCl19+mZKSEgA0Gg0JCQk8++yz3H777VYNUAhRT2WeMd7b4ezEJlJzI0TNqFJy8+abb5KamkpQUBAFBQX07t2b2NhYPD09+e9//2vtGIUQ9ZHU3AghqqhKo6W8vLz4559/WLt2Lbt27cJgMNC+fXtuvvlma8cnhKivzMmNHQ4Dv0gm8hOiZlQ6uTEYDCxevJjvv/+euLg4NBoNMTExhISEoCgKGjsd1SCEqEWlxZCTZHxsxzU3xon8tGgVPa7F+eTrPNUOSQi7UKlmKUVRuOWWW5g4cSKJiYm0atWKFi1aEB8fz/jx4xk5cmRNxSmEqE+yzwIKOLqCe4Da0dQcjYb8i/1u3ItkIj8hrKVSNTeLFy9mw4YN/PXXX/Tp08fitb///ptbb72Vzz//nLFjx1o1SCFEPWNukoqw2zluTPJd3PEszMZNkhshrKZSNTdLly5lxowZZRIbgL59+/Lss8/y1VdfWS04IUQ9VQ86E5vkuxjXlHKTTsVCWE2lkpv9+/czaNCgq74+ePBg9u3bV+2ghBD1XL1MbqTmRghrqVRyk5GRQXBw8FVfDw4O5sKFC9UOSghRz5nmuKkHyU2eKbmRuW6EsJpKJTd6vR5Hx6t309FqtZSWllY7KCFEPWequbHjCfxMTB2KpeZGCOupVIdiRVEYP348Li4u5b5eVFRklaCEEPVcPZjjxiTf+bJmKUWx+w7UQtSGSiU348aNu24ZGSklhKgWfQnknDM+rgfNUqYlGBwNepxLCyl2clU5IiFsX6WSm0WLFtVUHEIIYZSdCIoBHHXgEaR2NDXO4KClwMkV15IC3IryJLkRwgqqtLaUEELUGHN/mwb1ponGNGJKJvITwjokuRFC1C0Zp4339aC/jcmlTsUyYkoIa5DkRghRt1y4mNz4xagbRy2SuW6EsC5JboQQdYup5sZXkhshRNWontzMmzePmJgYdDodHTp0YOPGjRXab9OmTTg6OtK2bduaDVAIUbvqYc1NnizBIIRVqZrcLFu2jClTpvDcc8+xZ88eevbsyeDBg0lISLjmfllZWYwdO5Z+/frVUqRCiFqhKJARZ3xcr2puZCI/IaxJ1eTm7bffZsKECUycOJHmzZszd+5cIiIi+Oijj66530MPPcQ999xDt27dailSIUStKLgARVnGx77RqoZSm0wT+elKC3HQyyzvQlSXaslNcXExu3btYsCAARbbBwwYwObNm6+636JFizh58iQzZ86s0HmKiorIzs62uAkh6ihTfxuPEHB2UzeWWlTi6EyJg3HaMVljSojqq9QkftaUlpaGXq8vsxBncHAwycnJ5e5z/Phxnn32WTZu3HjNNa4uN3v2bF566aVqxyuEqAV1sL9Nnr6Y86U55BtK0CsGtBoHfLWu+Du6o3Ow0leoRkO+iwfeBZm4FeWS6+ptneMKUU+pltyYaK6YpEtRlDLbwLho5z333MNLL71EkyZNKnz86dOnM3XqVPPz7OxsIiLsfzE+IWxSHRgppSgK+wuS+D3rKH/lnCCpJOeqZRs4edNcF0Qr1xA8tOWvuVdRpuRGJvITovpUS24CAgLQarVlamlSUlLK1OYA5OTksHPnTvbs2cMjjzwCgMFgQFEUHB0d+fPPP+nbt2+Z/VxcXK660KcQoo5RsebGoCiszTnB/NRtHC5MsXjNT+uGl9YFrcaBEkVPRmk+uYZizpZkcbYki7U5J+ng3oAe7lFVTnJkIj8hrEe15MbZ2ZkOHTqwevVqRo4cad6+evVqRowYUaa8l5cXBw4csNg2b948/v77b1asWEFMTN2pxhZCVJFKNTcHC5J5+dxfHCo8D4CrxpE+XrEM9m7K2aIsXMppfsrWF3KkMJX9BUmcK8lmW14Ce/MTGejVlDauoeXWQF+LzHUjhPWo2iw1depU7rvvPjp27Ei3bt345JNPSEhIYNKkSYCxSSkxMZHPP/8cBwcHWrZsabF/UFAQOp2uzHYhhI2q5ZqbAkMJc89vZGnGXhTAw8GZ0X7tuM+/Pb6OxgUsl5fsL3dfL62Ozu4RdHJrwMniDNZebML6MesQRwpTGOHTAlcHpwrHIsmNENajanIzatQo0tPTefnll0lKSqJly5b8+uuvREUZ15RJSkq67pw3Qgg7UVIAOUnGx7VQc3OsMJWnzv7CqaIMAIZ7N2dqSC8CHN0rdRyNRkOsiz8Nnf3YkhfPupyTHCtKY2HaDkb7tcXPsWKjvqRZSgjrUb1D8eTJk5k8eXK5ry1evPia+86aNYtZs2ZZPyghRO27EGe8d/ECN78aPdWPmYd46dxqihU9gY7uvBo+iO4e1Vuo00GjoYdHNI1c/PkmYy/p+nwWXExwGjhff/STeZbi4jzjZIZCiCpTffkFIYQALutvEw2V7K9SUQbFwNvJG3gu8XeKFT09PWJY0ei+aic2lwtx8mRCQGdCnTwpUEr4KmM3icVZ192v0NkNAxocFAO6kgKrxSNEfSTJjRCibqjp/jaaEn7Tf8+i9J0APBTYhQ8ib61ws1FleGpdGOfXkUhnH4oUPV9l7CGp5NoTiCoaBwouTlwo/W6EqB7Vm6WEEAK4VHNTlAs7F1n10CUU4hrxLSeV0zhrtLwaPpDB3s2seo4rOTtoGe3blq8y9nC2JIuvM/Yywb8TPhc7Kpcn38UD9+I83IpyyajR6ISwb1JzI4SoG0w1N24BVj1slr6QXbolOLqfxhkXPo66rcYTGxMXB0fu9WtHiKMHeYZill7YS6Hh6mtHmUZMyUR+QlSPJDdCiLrBVHPj7m+1Q+bpi5kcv5IcbTKGUg9ud7yPTu61O0O5i4Mjd/u1xcPBmdTSPL7LPIDhKh2GZcSUENYhyY0QQn36Usi8OO2DlWpuCg0lPJqwiv0FSTgprhQkTCRQU3b289rgpdVxt19bnDQOnCxKZ0PuqXLLyVw3QliHJDdCCPVlxoOhBBycwNWn2ocrMeh54sxP7Mg/i7uDM+0Kx2AoCql+nNUQ5uTFUK/mAGzIPc3JovQyZS7V3EhyI0R1SHIjhFBf+gnjvXsgaKr3tVSqGHgm8Vf+yY1Dp3Hkw8hb8TaEWSHI6mvtFkp7t3AAVmb+S46+yOL1SzU30iwlRHVIciOEUF/aceO9R1C1DmNQFGYm/snq7OM4abS8G3kLHdwbWCFA6xnk1YQQRw/yDSX8mHUI5bL+N6aJ/Jz1xTgW56sVohA2T5IbIYT60o4Z76uR3CiKwv+S/ubHrENo0fBmg6F094i2TnxW5KjRMtKnFY4Y+9/syk80v6bXOlHkaFxV3D2vbLOVEKJiJLkRQqjP3CxVteRGURTeOb+RZRf2oQH+Gz6Ivl6x5tdvDC5hUGAGLXyuPgy7NgU6udPvYnyrc46RXnqplibPxRMA99w0VWITwh5IciOEUF81m6U+Sdtmnnn4xdCbGerT3OL126IKuT8yhe5BJdUK05o6u0UQ7exLiWLgx8xLzVN5uotz3eSmqhmeEDZNkhshhLoKMiEvxfi4CjU3X6Tv5oOUzQA8HXITd/i1tmJwNUej0XCL9w04abScKclk98XmKXPNTZ7U3AhRVZLcCCHUZWqS8ggBJ12ldl2RsZ85yesAeDiwO/f5t7dycDXLx9GVvp6NAFiTc5xsfSF5OmmWEqK6JLkRQqjL1CQV0LhSu/2SeZiXk9YAcL9/Rx4K7GLtyGpFJ7cIwpy8KFL0/J519FJyIzU3QlSZJDdCCHWlVz65+Tv7BM8l/o4CjPJtwxPBPdFoNDUTXw1z0GgY7n0DGjQcKUplt4MeuFhzc5VlGoQQ1ybJjRBCXaaaG/+KJTebc+OYdvYX9Cjc4n0DM0L72mxiYxLs5EHni/PxrCo8SzHgqC/GpTBb3cCEsFGS3Agh1FWJZqldeWd5POFHShQ9/b0a81L4ABxsPLEx6e3RCHcHZ9L1+Sz2My4eKk1TQlSNJDdCCPUY9JBxcRHJ6yQ3BwuSeThhFYVKKTd6RPN6+BAcq7lUQ12ic3A0dy7+zMuNVK2DdCoWoors55tBCGF7MhNAXwRaF/COuGqx44VpPBT/PXmGYjq5NeCdiOE4OWhrMdDa0dY1jDAnLwo0Gub6+kjNjRBVJMmNEEI9pmHg/o3gKsnKqaIMHoxfQZa+kNauIbwfeSs6B6daDLL2aDQaBns1BeBHTw/O5CReZw8hRHkkuRFCqMfcmTi23Jfjiy4wMW456aX5NNMFMi/qNty1zrUYYO0Ld/amh8YdgAWlKRgUg8oRCWF7JLkRQqjHtGBmQJMyL50pzmRC3HJSS/OIdfHnk6g78NZWbpI/WzVYF4GHwcAxrYF9KfvUDkcImyPJjRBCPalHjfdXJDfnirOZGLeC86W5NHTx47PoO/F1dFUhQHVoXX2YdCELgHVn1lKirztrYglhCyS5EUKoQ1Eg5aDxcfAN5s3JJTlMiFvOuZJsop19+SzqDvwd3VQKUh0Fzm6Mys0nvKSUnJJctiZtVTskIWyKJDdCCHXkJEFhFmi05pqbM8WZjDu9jLMlWUQ4e/NZ9B0EOnmoHKgKNA6UuAfw6IVMADad20ReSZ66MQlhQyS5EUKo4/wh471/LDi6cCrrFONPL+NcSTZRzj4sjL6LYCdPdWNUUZ57AIPz8oly9KRYX8zGsxvVDkkImyHJjRBCHZc1SR3NOMr9v99PysXOw4ujRxFSjxMbgDyPAByAsdpAAHae30lGQYa6QQlhIyS5EUKo42LNzQHvYB744wEyCjNorgtiUfRdBDi5qxyc+vI8AgDoUlhArE8sBsXA32f+VjkqIWyDJDdCCHWkHOIfVx0Tzq8huzibtoFtWRB9Jz71aFTUteS5G5Mb99w0+kX2A+BQ+iHO5pxVMywhbIIkN0KI2qcvZVV+PI8GB1JgKKZraFfm95+Pp9ZF7cjqjFzPIAA8clMIdg+mbWBbANbEr0FRFBUjE6Luk+RGCFGrFEXhk+1zeMHfm1KNhmExQ5nXbx5uTvVruPf1mJIbXWEOjiUF3BRxE44aRxJyEjh24ZjK0QlRt0lyI4SoNaWGUl7Z+grvH1sKwAS9K//rORsnrX2uFVUdpU6uFOqMnao9clLwcvGiS2gXAP5K+EuWZRDiGiS5EULUiuzibB756xGWH1uOBpiRlsEU/05oNBq1Q6uzcj0uNk3lpADQI7wHro6upBWksTdlr4qRCVG3SXIjhKhx8dnx3PvLvWw6twmdVsc7jlGMzsmFoBZqh1anXd7vBkDnqKNXg14ArDuzjmJ9sVqhCVGnSXIjhKhRW85t4Z5f7iEuO45gt2A+H/w5/dITjS9etuyCKOvKmhuAjsEd8XXxJVeWZRDiqhzVDkAIYZ8URWHpkaXM2TEHvaKndWBr3u3zLgFaV8g4bSx0seZm+bHlxucZ+2ssntOleSRk2Nb8Oeaam8uSG62Dlj6Rffj++PdsTtxMekE6/q7+aoUoRJ0kNTdCCKsrKC1gxj8zmL19NnpFz/CGw1k4cCEBrgEXVwJXwC0APALVDrVOu7JZyqSFfwvC3MMoNhTz8b6P1QhNiDpNkhshhFXFZ8dz76/38vOpn9FqtEzrOI3/3vhfXExz2Jz/13gvTVLXZUpuXAuy0JYWmbdrNBr6RRkn9ltxbAXx2fGqxCdEXSXJjRDCav5O+Ju7f76b4xeO46/z59MBnzKuxTjLEVHn9hrvQ9uoEqMtKXF2p8jFuCr65U1TADHeMcT6xFKqlPLu7nfVCE+IOkuSGyFEtZUaSpm7ay6Pr32c3JJc2gW149vh39IppFPZwkl7jfdh7Wo1RltVXqdik36R/dCgYXX8avan1lx/JSFsjSQ3QohqSS9IZ9LqSSz4dwEAY5qPYcHABQS5BZUtrC+B5IvNUpLcVEiup7Ff0pX9bgCC3YO5pdEtALy18y1ZlkGIiyS5EUJU2b7Ufdz1811sS96Gq6Mrb/R6g2c6P4OTw1VmHE45DPoi0HmDb0ztBmujrlVzA/BIu0dw0bqwO2U368+ur83QhKizJLkRQlSaaZj3+N/Hk5KfQrRXNEuHLmVQzKBr73huj/E+tC3IzMQVUt5w8MuFuIdwb/N7AZi7ay6lhtJai02IukqSGyFEpeSX5DPjnxn8b9v/KDWU0j+qP0uHLqWRT6Pr72xKbsLa1miM9iTXMxgov1nKZEKrCXi7eHMy6yQ/nPihtkITos6S5EYIUWEJ2QmM+W2MxTDvt3q/hYezR8UOIJ2JK81Uc+OWfwGH0vKXW/By9uL/Wv0fAPP2ziO/JL/W4hOiLpLkRghRIRvPbuTuXy4N8/5swGdlh3lfS2mRdCaugmJnd4qd3ADwyE29arm7m91NuEc4KQUpfHn4y9oKT4g6SZIbIcQ1KYrCp/s/5eG/HianOIc2gW34dvi3dAzpWLkDpRwCQwnofMAnqkZitUsazXX73QA4a515pN0jACz8dyFpBWm1Ep4QdZGsLSVEPWBeu6mSivRF/HDiB45kHAGgQ3AHBkYPrNKonJgT6+kIJPuEsfH4iirFU1/legbhlxGHR875a5YbEjOELw99ycH0g3yw5wNmdZ9VOwEKUcdIzY0QolzpBeksPLCQIxlH0Gq0DGs4jKENh+LoULX/ifzSjUsEXPCLtmKU9UOOVwgAXtnJ1yznoHHgmc7PAPD98e85nH64xmMToi6S5EYIUcaxC8f47MBnpBak4uHkwbgW42gf3L5ax/TNiAPggp80SVVW9sXkxjM76bpl2wW1Y3D0YBQUXtv+mkzsJ+olSW6EEGaKorDl3Ba+OfINRfoiIjwjeLD1gzTwbFCt4zroS/DOSgTggn+0FSKtX3K8QgHwyk6CCiQrT3R4Ap1Wx+6U3fwZ/2dNhydEnSPJjRACAL1Bz6+nf2V1/GoA2ge1Z+wNY/F09qz2sX0z4nAw6CnUeZHv5lft49U3OZ7BKGhwLs7HpSjnuuVDPUK5v+X9gHFZhsLSwpoOUYg6RZIbIQSFpYUsPbKUXed3ATAgagBDGw5F66C1yvEDUk8AkBbYWGYmrgKDozN57v4AeF6n343J/S3vJ9gtmKS8JJYcXFKT4QlR50hyI0Q9d6HwAov+XcSprFM4OTgxqukouoZ1rfj8NRUQkHIcgLTAWKsds77J8b7YNJV1/X43AK6OrkztMBWABf8u4HzetUdaCWFPJLkRoh5Lzktm0b+LSC1IxdPZk/tb3k9Tv6bWPYliICDtspobUSWV6VRsMjhmMG0D21JQWsCbO9+sqdCEqHMkuRGinjqddZrFBxeTW5JLsFswE1pOIMQ9xOrn8cpKwrk4n1JHFzJ9I6x+/PrC1Km4os1SABqNhuldpuOgceD3uN/ZlLippsITok6R5EaIeuhg2kG+Pvw1xfpioryiGNdiHF4uXjVyLlN/m3T/hihW6sNTH2VfPmKqEm7wv4F7mt0DwCtbX6GgtMDqsQlR10hyI0Q9sz1pO98d/w69oqe5X3PubX4vOkddjZ0vIFX621iDaSI/97x0tKVFldr3kXaPEOwWTGJuIp/s/6QmwhOiTpHkRoh6QlEUNpzdwO9xvwPQMbgjtze5vcozDleUeaRUkPS3qY5inSdFLsbV16+3DMOV3J3cmd5lOgCL/13MiQsnrB6fEHWJJDdC1AOKovB3wt+sO7MOgN4NejM4ZjAOmpr9CnDNz8A9Lw2DxoEM/4Y1eq76wNw0VcERU5frF9mPmyJuolQp5ZWtr2BQDNYOT4g6Q5IbIeycQTEYO5OeM3Ym7R/Vn94Rva061Ptq/C/W2mT6RlDqVHNNX/VFjnnEVMU7FV9uRucZuDq6sjtlNyuPr7RmaELUKZLcCGHH9AY9MzfPZEfyDgCGNhxKt7ButXZ+i8n7RLVdWkCz8jU3YJy5+OG2DwPw9q63SclPsVpsQtQlqic38+bNIyYmBp1OR4cOHdi4ceNVy37//ff079+fwMBAvLy86NatG3/88UctRiuE7dAb9Dy36TlWnViFBg23xt5Kh+AOtRpD0PmjgHQmtpZs83DwqiU3APc2v5cb/G8guzibmZtnysKawi6pmtwsW7aMKVOm8Nxzz7Fnzx569uzJ4MGDSUhIKLf8hg0b6N+/P7/++iu7du2iT58+DB8+nD179tRy5ELUbQbFwIubX+SXU7/gqHHkjiZ30Dqwda3GoMvPxDsrEQUNqcHNavXc9so0S7Fn9nkwVK3PjKODI/+78X84OzjzT+I/LD+23JohClEnqJrcvP3220yYMIGJEyfSvHlz5s6dS0REBB999FG55efOncvTTz9Np06daNy4Mf/73/9o3LgxP/30Uy1HLkTdZVAMvLTlJX48+SNajZY5vefQ3L95rccRnHwQgAt+URRfHOUjqifPzR+91gmtoRT3vNQqH6eRTyMeb/84AG/ufJP47HhrhShEnaBaclNcXMyuXbsYMGCAxfYBAwawefPmCh3DYDCQk5ODn9/VVxkuKioiOzvb4iaEvVIUhf9u/S/fH/8eB40Dr/V8jf5R/VWJJTjpEADJoS1UOb9dcnAwN015ZyZW61BjbhhD55DOFJQW8Nw/z1FqKLVGhELUCaolN2lpaej1eoKDgy22BwcHk5xcsZEAb731Fnl5edx1111XLTN79my8vb3Nt4gImf5d2CdFUZi9fTbfHvsWDRr+e+N/GRQzSKVgDAQnG5Ob85LcWFWWTwOg+smNg8aBV3u8ioeTB/tS97Ho30XWCE+IOkH1DsVXDkdVFKVCQ1SXLl3KrFmzWLZsGUFBQVctN336dLKyssy3M2fOVDtmIeoaRVF4Y+cbLD2yFA0aXunxCsMaDlMtHp8LZ9EV5VDi6EJ6gMxvY02ZF5Mbn8yz1T5WqEeoeXK/eXvncTj9cLWPKURdoFpyExAQgFarLVNLk5KSUqY250rLli1jwoQJfPvtt9x8883XLOvi4oKXl5fFTQh7oigK7+x+hy8OfQHArO6zGBE7QtWYTP1tUoKbo9TwDMj1TZavqeam+skNwPCGw7k58mZKlVKe3vA0eSV5VjmuEGpSLblxdnamQ4cOrF692mL76tWr6d69+1X3W7p0KePHj+frr79m6NChNR2mEHWaoii8v+d9c5PCC11f4LbGt6kcFQQnGZOb86E3qByJ/TE1S3nkpFR6janyaDQaZnabSbBbMHHZcby0+SUZHi5snqr/Uk2dOpX77ruPjh070q1bNz755BMSEhKYNGkSYGxSSkxM5PPPPweMic3YsWN599136dq1q7nWx9XVFW9vb9WuQ9iAnVXsT9DxfuvGYWUf7/+YTw98CsCznZ/lrqZX739WW7SlRebJ+86HSH8bayvSeVGo80JXmI1XNfvdmPjofHiz95vc//v9/Bb3Gx2COzCq2SirHFsINaja52bUqFHMnTuXl19+mbZt27JhwwZ+/fVXoqKiAEhKSrKY82b+/PmUlpby8MMPExoaar49/vjjal2CEKr57MBnzNs7D4BpHadxb/N7VY7IKPD8UbSGUvLcA8j1vHp/OFF11ux3Y9I2qC1TOkwB4LUdr7E3Za/Vji1EbVO9MXzy5MlMnjy53NcWL15s8XzdunU1H5AQNmDxv4t5d/e7AExpP4VxLcapHNElYYn7gItDwGth/ar6KMunASHJh6zW78Zk7A1j2Ze6j9Xxq3li3RMsG7aMIDdJUIXtUX20lBCicr449AVv7XoLgEfaPsKEVhNUjugyBgPhZ40zhic2aKdyMPYryyccsF6nYhONRsOrPV4l1ieWtII0nlj7BEX66vfrEaK2SXIjhA1ZemQpc3bMAWBSm0k81OYhlSOy5J9+El1hNsVOrqTIkgs1JsvHOF+Xd2YiWLnzr5uTG+/1eQ9PZ0/2p+3n+X+ex6BUbakHIdQiyY0QNmL5seX8b9v/AJjYaiKT25TfnKum8DO7AUgKb4OiVb3V225le4di0DjgUpwHOVVfRPNqIrwieOemd3DUOPJ73O98sOcDq59DiJokyY0QNmDl8ZW8vOVlAMa3GM9j7R6r0GSXtUpRaHDG2CR1NqK9ysHYN4PWiRyvEOOT8wdr5BxdQrsws/tMAD498CnfHv22Rs4jRE2Q5EaIOu7Hkz8yc7Pxj8yY5mOY2mFq3UtsAJ8LZ3DPS6NU6yxLLtQC03w3nP+3xs5xa+ytPNTa2PT56tZX+emkLFIsbIMkN0LUYb+c+oUXNr2AgsLdTe/m6U5P18nEBi41SSWHtUTv6KJyNPbvUnJTMzU3Jg+3fZjRzUajoPDCphf4K/6vGj2fENYgyY0QddTPp35mxj8zMCgG7mhyB9O7TK+ziQ1A+FljcpPYQJqkaoNprhuSD9ToeTQaDc92fpYRjUagV/Q8teEpNidurtFzClFdktwIUQf9fOpnnvvnOQyKgdsb384LXV/AQVN3f129MhPxzjqHwUFLUnhrtcOpFzL9Io0P0o5BUW6NnstB48Cs7rPoH9WfEkMJj699nF3nd9XoOYWojrr7bSlEPfXTyZ8sEpsXu71YpxMbgKjTxv/kk8JaUeLspnI09UOhqw/5br6gGCBpX42fz9HBkdd7vs6N4TdSqC/kP2v+w5ZzW2r8vEJUhYzVFMJKlh9bXu1j7E/dzw8nfkBBoX1Qe27wv4Hvjn9nhehqjsagJ+r0VgDiYnqoHE39kuEXjVv+BUjcBdE1/947aZ1456Z3eOzvx9iStIWH/3qY13u9Tv+o/jV+biEqo27/OyhEPbI/dT+rTqwyJzZDGw6t031sTIKTD+FamEWRiwdJYa3UDqdeyfCPMT44t7vWzqlz1PFBvw/MTVTT1k9jxbEVtXZ+ISpCkhsh6gBTYgPQIbiDzSQ2ANGnNgEQH91VJu6rZRdMyU1i7SU3AM5aZ97o9Qa3N74dg2LgpS0vseDAglqNQYhrkeRGCJXtPr/bIrEZEjPEZhIbp+I8ws7uBSCuYXd1g6mHLvhFGR9kxkNeWq2eW+ugZWa3mUxoaVzbbO7uuby69VVKDCW1GocQ5ZHkRggVbTm3hZ9P/QzYXmIDEBG/Ha2hlEyfCLJ8I9UOp94pcXYD/8bGJ+f21Pr5NRoNUzpM4ckOTwKw7Ogy/rP6P2QWZtZ6LEJcTpIbIVSgKAprE9ayOn41AN3DuttcYoOiEHPyHwDiGnZTOZh6LPzivEK13DR1ufEtx/Nun3dxc3RjW/I27vn1Hk5mnlQtHiEkuRGilimKwu9xv7MxcSMAfSP7cnPUzbaV2AD+aSfxy4hH7+BIfLQkN6oJ72C8T1R33pm+kX35YsgXhHuEcybnDPf+ei/rzqxTNSZRf0lyI0Qt0hv0rDqxih3JOwAYEjOEG8NvVDmqqml8dA0A8TFdKdZ5qhxNPRZ2sebm3G5QFFVDaeLbhKVDl9IxuCN5JXk8+vejvLPrHemHI2qdJDdC1JKC0gK+PPwlB9IOoEHDyNiRdAzpqHZYVeKWl06DM8aaguNNb1Y5mnoupBU4OEJeKmSdVTsafHW+fDLgE+5pdg8AC/9dyAO/P0BSbpLKkYn6RJIbIWpBZmEmi/5dRHx2PM5aZ+5pfg+tAm13TphGx/5GoyicD25OtmmNI6EOJx0EX1yFXeWmKRMnByemd5nO2ze9jaeTJ3tT93Lnz3dKM5WoNZLcCFHDzuWeY8G/C0grSMPT2ZPxLcbTyKeR2mFVmba0iIYnjP2FjjeTWps6wdQ0lbhT3Tiu0D+qP8uGL6OFfwuyirJ49O9Hmb1tNgWlBWqHJuyczLglRA06nH6YVSdWUWIoIdgtmNHNRuPl4qV2WNUSfXITziX55HgEyYzEdUVkV9i1CBK2qh2JBdOSJCNiR+Dh5MG25G18feRr/oj7g1tjbyXcM1zV+O5scqeq5xc1R2puhKgBBsXAmvg1LD+2nBJDCQ29GzK+xXibT2wc9CU0O/QbAMeb9Yc6vqBnvRF5cbTauT1QnK9uLOVwdHBkYMxA7ml+D55OnqQXprPw34WsTViL3qBXOzxhh+SbSQgryy/J5+vDX7P5nHGl7K6hXbmn+T24OLqoHFn1NTyxHreCC+S7+XG6kW2O8rJLPpHgGQaG0jrT76Y8sT6xTGo7iZYBLVFQ2Ji4kQX/LiAlP0Xt0ISdkeRGCCtKzkvmswOfcSrrFE4OTtzW+DYGRA/AwQ5qOLSlRTQ/+CsAh1oOxaB1UjkiYabRQNTF2puELerGch2ujq7c1vg2bm98O66OriTnJfPp/k/ZfG4zBsWgdnjCTkifGyGswKAY2Ja0jTXxa9ArenxdfLmr6V0EuwerHZrVNDq+Dl1hNrnuAcQ17KF2OOJKkd3g3+8gfrPakVRIi4AWRHpF8tPJnziReYI18Ws4nH6YWxrdQqBboNrhCRtn+/9OCqGytII0Jq+ZzB9xf6BX9DT2bczE1hPtKrFxLCmk6aHfATjcchiKg/xfVOdEXVy49Mx2KC1WN5YK8nT2ZHSz0QxrOAxnrTOJuYnM3z+f9WfWS18cUS3yDSVENaw/s54XNr3AhaILOGoc6R/dn47BHW1uKYXraX7wZ3RFOeR4BhMfI0st1EmBzcEtAPLTjP1uomzj56TRaGgf3J5Yn1h+Of0Lxy8cZ/3Z9RzOOMzwRsMJ91B3RJWwTVJzI0QVZBZm8sKmF3jk70e4UHSBJr5NmNh6Ip1COtldYuORnUyTI8YFPve1vwvFQatyRKJcDg4Q08v4+PQGdWOpAi8XL+5ueje3Nb4NN0c3UvJTWHhgIavjVlOil+UbROVIciNEJSiKwq+nfmXEDyNYdWIVGjTcd8N9LB26lCC3ILXDsz5Fod3OpTgY9JwLa01SeBu1IxLXYk5u1qsbRxVpNBpaBrRkctvJtApohYLClqQtfLzvY05nnVY7PGFDpFlKiAo6l3uOV7a+wj+J/wDQyLsRs7rPom1QW3UDq0FhZ/cSknwQvYMjezuMUjsccT0Nexvvz2w3znfj7KZuPFXk5uTGyMYjaRHQgl9P/cqFogt8cegL2ge15+aom9E56tQOUdRxktwIcR35Jfks+HcBSw4uoUhfhJODE//X+v+Y0HICTnY8HNqxOJ92u5YCcLT5QPI87aeDtN3yjQHvSMhKgPhN0Li/2hFVSxPfJkS1ieKvhL/YeX4nu1N2c+zCMQbFDKK5X3O7awIW1iPNUkJchUFRWHl8JcNWDuOT/Z9QpC+iY3BHVtyygkltJtl1YgPQbtdS3PIzyPUI5EiLIWqHIypCo4HYvsbHx1erG4uVuDi6MKThEMa1GIe/zp/cklxWHFvBsqPLyCrKUjs8UUdJzY2wGaZ1aqokY3+FiyqKwsniDP7OPkFyaQ4Avi6+3Bx1M838mrHr/C52nbfyLLBxVZibJLp7jZ0rPO000ae3oKBhe3Rn9Gfr7qy39d2Vvxdhbu70AHIPfc9vsZ3UCaoGRHlF8VCbh/gn8R/+SfyHYxeOEZcVR5/IPnQK6WQXE2UK65HkRoiLFEXhdHEG63JOcbbE+B+hi9aFng160jmkM471ZG4XXXE+HU4ZE6Aj4a1I95LmKFuSEtIcg4MWj9xUPLLPk2tHPz9HB0duiriJFv4t+PnUz5zJOcMfcX9wIPUAwxoNI8Q9RO0QRR1RP76thbgGRVGIK77A+txTJBRnAuCIAx3cG3Bj8ztxd3JXN8BapDHo6XpsHS6lRVxw9+dgRDu1QxKVVOqkIzWwMcHnjxBy7gAn7Ci5MQl0C2R8i/HsTtnNmvg1nMs7x6f7P6VbWDd6N+ht903G4vokuRH1lkFROFKYwua8eM6VZAOgxYEObuH08IjGU+sC9SixAWh3ehuB2cmUaJ3Y1ri3zGljo5LCWhN8/gjhiXs50exmtcOpERqNhg7BHWji24Q/4v7gUPohNp/bzKH0QwxtOJRGPo3UDlGoSJIbUe+UKHr25yexJS+eDH0BYKypaecWRg+PaLy09XOYacPkIzQ6fwQF2Na4NzluPmqHJKooMaIdbfd8S0DKMZwLcyjWeaodUo3xdPbkjiZ3cDTjKL+d/o3Moky+OvwVrQJaMSB6QL2qeRWXSHIj6o3M0gJ25J9lb/45ChTjjKc6jSOd3CPo7BaBu9ZZ5QjVE3LhDO1OG1eT/jeyA0l+kSpHJKoj3yOQC74R+F44Q1jiPuIa3ah2SDWuqV9Tor2jWZewjm3J2ziQdoATmScYEDWA1oGtZdh4PSPJjbBriqJwOus02zP2cqwozbzdR6uji3sk7VzDcK4nHYWvJijzHN2P/I2DohAf0JAj4a3VDklYQWKD9vheOEP4md31IrkB4wCAgTEDaRnYkp9P/sz5/PP8cPIH9qXuY2jDofi7+qsdoqgl9ftbXditIn0R+1P3syN5B2kFl5Kahs5+dHKPoLFLAA7ynxwB2cn0OLIGraIn0TeSHbG9jHOlCJuXGNGelgd+IDj5EE7FeZQ415/mmXCPcCa2msi2pG2sO7uOuOw4Pt73Mb0a9KJ7WHe00pfM7klyI+xKWkEaO5N3sjd1L8X6YgCcHZxpowuik3sEAY715wv+esIy4ulybD2OhlKSfMLZ2rQPioPMFWIvsn3CyfIOxzsrkQYJuzgd20vtkGqV1kFL9/DuNPdvzi+nfuFU1inWnlnLwbSDDGs0jAaeDdQOUdQgSW6EzVMUheOZx9metJ1TWafM2/11/nQK6USbwDa4yCR0lygKjZMO0SZuGxogySeczU37YZD/Zu1OfHQXWu/7nsi4bfUuuTHx1flyb/N7+TftX/6I+4OUghQW/ruQDsEdGBA1AG8Xb7VDFDVAkhths4pKi9ibupftSdu5UHTBvL2JbxM6hXSioXdDNBoNzoU5eGUloyvJx0ExUKJ1JlfnRY6rF9SzWU21JYW0O/kPMSnHATgZ3JQ9Dbuh1LP3ob44czG5CUw5hmt+BgVufmqHpAqNRkOrwFY08mnE6vjV7Evdx67zuxi2chhPdHiCW2NvlRmO7YwkN8LmpBeksyN5B3tT9lJsMDY96bQ62ga1pVNIJ3x1vrjmZxD97880OLMLn8yz5R6nWOtMsk84p4ObkOIdZvd9TXzTT9Nl06d45qagAPujOnEsrKXdX3d9lu/uT0pQE4JSjhF9chOHWw1XOyRVuTm5MSJ2BG2D2vLbqd9IKUhh5uaZfHf8O57r8hw3+N+gdojCSiS5ETZBURROZp5ke9J2jmceN28PcA2gc0hnWge2xlnrjC4/k5ZbFxN1egsOit5cLtfFk3wXdxSNA86lRXgWZOGsLyYy/TSR6afJcvXheFgL4oIa210thmNxPi0O/ETssb9wUAzkO7uzrXEv0rxD1Q5N1ILTjXoRlHKMmJMbOdxiKEi/KqK8oniw9YMU64v5cO+H7E/dz+hfRnNXk7t4pN0j0lRlByS5EXVafkk+P5/6ma8Of2XRnybWJ5YuoV3MTU8ag55GR9bQcv8qnEoLAUgNasLphj1ICmtNcfIBywMrBvxy04hMPUlMynG8CzLpeHITsUmH2BvTlVQ7+MOvMZQSfWozLfevRFdoXAD0TGRHdoU0pcTRReXoRG05G9mBdru+xj0/g5Ckf0mWof6AscPx2GZjGRQziDd3vslvp3/jm6Pf8Gf8n0ztMJXhjYZLU5UNk+RG1Enncs/xzZFvWHF8BTnFxj/Mzg7O5qany+ercM9JoeumT/DLiAMg3b8hezuMIiPgGtOvaxzI8AwiwzOIfyM70PD8UZon7sMn/wI3HfyNhICG7InpSnFNXmQNcdCXEH1qE80O/YZ7XjoAOZ7B7OkwmvNhLau2ArmwWQatE3Ex3WlydA2xx/6W5OYKQW5BzOk1hzsa38F/t/2XU1mneH7T83x3/Dumd55Oc//maocoqkCSG1FnKIrCrvO7+OrwV/x95m8MigGACM8I7ml2DwoKOkfLpREaJOyk47YlOJUUUOzsxv62t3O6Uc9KdRQudXTmWHgr4oIa0+LMbholHyUy7RSBWUnsdAuwmT8GrnnpNDq+npiTG9EVGRPCQp0XR24YxInGfVG08uteX51o0pfGR/8iNOlfPLPOkeMdpnZIdU7n0M6sGL6CLw9/yUf7PmJPyh5G/TyK4Y2G81i7xwh2t78FSO2ZfNsJ1RXpi/j11K98feRrjmQcMW/vEtqFMc3H0DO8J1oHLcuPLb+0k8FAmz3LaXJ0NQCpgY3Z1uPBao0GKXbSsadhd+ICG9P5xAa8CrLouf49TjXqxb72d1HqVPfWnNKWFBJ+dg9Rp7cQfP4wGkUBIN/Nl6PNB3KqUS8MjvV3WQlhlOcZRGJEOxqc2U2TI3+yq8t4tUOqk5y0Ttzf8n4GxwzmnV3v8OvpX/nx5I/8Gfcn41uO5/4W9+Pm5KZ2mKICNIpy8duwnsjOzsbb25usrCy8vLzUDqdeS8lPYdnRZaw4toKMwgzAOOppWKNh3NvsXmJ9Yy3Km5IbbUkhXTd9Qti5/QAcvmEwB1vfeu0VrCvZFOOgL6VVwi4aJx1Cg0KuewA7uj1AWlCTSh2nwioTn2IgOCuJqPwsws/uwbG0yPzS+eBmnGzSh3Phba/+ftTTZqnT6XnE+NvQJI7R3a16OL/Uk/RbPRuDg5bfhv+PfHdZiuDOJnde8/UDqQd4Y+cb7EnZA0CgayCPtnuUWxrdIrMcq6Ayf7+l5kbUuv2p+/ny8JesjltNqVIKQIh7CKObjeb2xrdfc6SCa34GPda/j++FM+i1TmzvNoGzkR2tHqNB68i+mC6cu2EwnbYuwiMvjZvWvMHxpjdzoM1IVWpDvPPSiUo9SWTqSVxLCszbcz0CiY/pRnx0V/I8g2o9LmEbMgIbcT64GcHnj9D835/Z1WWc2iHVea0CW7Fk0BLWJKzh7Z1vczb3LC9ufpEvD3/J4+0fp2d4T1mQs46S5EbUihJ9CavjV/PV4a/Yn7bfvL19UHvubX4vfSP74nidBSx9MuK4cf0HuBZkUqjzZFOvR67dadgKUoOb8eeQWbTZ/S0NT26kydHVhCQdYEfXB8gIaFij5wbQFeURmXaKqNQT+ORfmqiwyNGFMzHdiI/uZoxDvmBFBRxsfSvBq18j+tQmjjYfSK5XiNoh1XkajYb+Uf3p3aA3S48sZf6++Ry7cIyH/3qYtoFtebTdo3QO7ax2mOIK0iwlalRaQRorjq3g26PfklqQCoCTgxODYwZzb/N7Kz5p1pFfKF0+Hkd9MVneYfzT+zHyPQIqHkhVm2IuaxoISdxPx21LcC3MQkFDXMMeHGgzkiJXK8yJcVl8Wn0JDdLjiEo9SVDWOUxpi17jQJJvJPGBjUjybYDSsGe1z1Wf1PdmKZMe694j7Nx+zoW1ZtNNj9XIOWzF9ZqlypNZmMmCfxew9MhSivTGJuEuoV14pO0jtA1qa+UIxeUq8/dbkhthdYqisC91H0uPLOXP+D8pNRibngJcAxjVdBR3NLmDANcKJiaKApvfg9UzAYXkkBZsufEhSp0r2anPCskNgHNRLm12LyP69BYASpxcOdb0Zk406UuxzrNq5wC0JzcQnHmWBulxhGck4HjxPQNI8wwiPjCWMwExlvPTVPWPnyQ3tqGGkhuP7GQG/jITB0XPxt6P2cxowJpQleTGJDU/lU/2f8KK4yvM33GdQjoxsdVEuoV2k+aqGiDJzTVIclNzCksL+e30byw9spTDGYfN29sEtuHuZnczMGogTlqnih+wtAh+fgL2fgXAydje7Ok4GuU6zVflslJyY+KXepJ2u77GLyPeGKrWmfiYbpyJ6kRaYGyFYnTNyyAw5SjhZ/cQkrgPR8OlGZVzdF7EBzYiIbARebqrfE4luakUSW4uab1nOU0P/0Gemx9/Dn2JUifXGjtXXVad5MbkXO45Ptn/CT+c/MGc5LTwb8HEVhPpE9FHOh5bkSQ31yDJjfUdzTjKqhOr+OnUT2QVZQHgonVhcMxg7m52Ny38W1T+oHnpsGwMJGw2zlkz6DWW+/hWvW+JlZMbABQDDRJ20vTwH+YkB6DYyY3UoCbkegWT6xFEqaMzGkVBqy/BPTcVj9xUfDPicc9LszhcnosHZ/2iOBsQQ4ZH4PWvVZKbSpHk5hJtSSEDfnsJj9xUTje8kZ1dx9fYueoyayQ3Jsl5ySw5uIQVx1ZQqDfOkt7AowGjm41mZOOReDpXvWZXGElycw2S3FhHVlEWv53+jZUnVnIo/ZB5e7hHOKOajmJk7Eh8dD5VO/i5PfDtOMiMBxcvuGMRNL7Zcp6byqqJ5MZEUQhMOUrU6c2EJe7HpSi3Qoc2aBzI9I3kfOgNnNU6kunuX7nkTZKbSpHkxlJAyjFuWvMGGhS2d32A+IY1e766yJrJjUlGYQZfHvqSb45+Y55d3dXRlRGNRjC62Wga+tT8QAR7JUPBRY3QG/RsS97GquOr+CvhL/OK3I4OjvSJ6MOtsbfSI6xH1athFQV2fAZ/zAB9MfhGw+hlENTMehdREzQaUoObkRrcDAwG/NNP4pNxBs+c87jnpuJgKAWNBoODI3nu/uR5BJLtHUZ6QKNLEwPW04RDqCctqAmHWg6jxb8/0WHHF2R7h3LBP0btsGyen86Px9o/xsRWE/nl9C98ffhrTmSe4Juj3/DN0W9oE9iGkbEjGRg9EA9nD7XDtVuS3Ihr0hv07E7ZzR9xf7A6frV5sj2AJr5NGBk7kqENh+Kr863eiXLOwy9T4cjPxudNh8KtH4JrNY9b2xwcSA9sTHpgY7UjEeK6DrUajl9GHKHnDtBz3busvfkZcuxg0di6wM3JjTub3Mkdje9gW/I2vjr8FRvPbmRf6j72pe7j9R2v0z+qP4NjBtMltAtODpXojyiuS5IbUUZhaSHbk7ez4ewG/kr4i7SCS31DvF28GRw9mJGNR9Lcr3n1RwQoCuxfBr89A4WZ4OAI/V+Brv+RuVuEqGkaB7b2eIjef72JX0YcN/31Bhv6PEGWb4TakdkNjUZD19CudA3tSmp+Kj+d+omVx1cSlx3Hjyd/5MeTP+Ll7EXfyL4MiBpA19CulRt4IcolyY1AURTO5Jxha9JWNpzdwLakbeYOcQCezp70i+zHoOhBdA7tbL3/MM7ugtUvQPwm4/OQ1nDrPAhpZZ3jCyGuq9RJx8abHqfX2rfxvXCGPqtfZ3v3CZxr0E7t0OxOoFsgD7R8gPtb3M++1H38dPIn1iSsIaMwg1UnVrHqxCrcndzpGtqVHuE9uDHsRkI9pCatKiS5qYcURSEhJ4Hd53ezPXk7O5J3cD7/vEWZEPcQeoX3ondEb7qFdrPufxLn9sKmuXBwpfG5ow56PQU9Hgf5j0WIWles82R9v6fovuEDglKO0WPDh5xo3IcDbW+vkwvG2jqNRkPboLa0DWrLjC4zzE3/a+LXkF6Yzl8Jf/FXwl8ANPRuSKeQTrQLakf7oPaS7FSQ6snNvHnzeOONN0hKSqJFixbMnTuXnj2vPvPq+vXrmTp1KgcPHiQsLIynn36aSZMm1WLEtsWgGDiXe45jF47xb9q//Jv2LwfTD5JdnG1RzsnBiVYBrejZoCc9w3vSxLeJdSehKimAo78ZOwybamrQQJvR0Pc58G5gvXMJISqtxNmNDX2n0nrPCpocXUPs8bVEJOzgSPNBnGzSB/3lE0gKq9E6aOkU0olOIZ2Y0WUGh9MPszFxI5sSN7E/bT+nsk5xKusUy44uA4z/eLYJbEMzv2Y092tOM79m+LvKIqhXUjW5WbZsGVOmTGHevHn06NGD+fPnM3jwYA4dOkRkZGSZ8qdPn2bIkCE8+OCDfPnll2zatInJkycTGBjI7bffrsIV1A2KopBRmMG53HMk5iWSmJPI6azTnMw8ycmskxSUFpTZx9nBmRYBLegU0onOIZ1pHdgaV0crT+SVmwqn18PxP+HIL1B8cYi0gyO0GGmsqZEmKCHqDMXBkX0d7iYpvA3td3yJZ8552uxdQdPDf5AQ3YWEqM7GEVXSH65GOGgcaBHQghYBLZjUZhJZRVlsT97O7vO72ZOyhyMZR0jOSyY5L5k/4v4w7xfkGkSMTwzRXtHGm3c0EZ4RBLsFo3OsnzVvqs5z06VLF9q3b89HH31k3ta8eXNuvfVWZs+eXab8M888w48//sjhw5dmv500aRL79u1jy5YtFTqnrcxzU2oopaC0gNziXDKKMrhQeIELhRfIKMwgo9D4PKUghaTcJM7lnrPoI3MlJwcnYrxjaOHfgpYBLWkZ0JLGvo2t13emOB+yzkDmGUg9AskHIGmv8fHlvCOh9Z3QcQJ4h1f6NHV2nhtrqEp8Ms9Npcg8N5WjMeiJjNvKDQd+wuOyCSfz3XxJC2xMWkAsmb4R5HoFU+TiaZMJT03Mc1OT8kvy2Z+2n4NpBzmScYQjGUeIz45H4ep/xn1cfAhyCyLYLZhg92CC3YLxd/XH29kbb5eLt4uPXR1d6/SyETYxz01xcTG7du3i2Weftdg+YMAANm8u/8t3y5YtDBgwwGLbwIEDWbBgASUlJTg5qddfI78kn5UnVlJqKKXEUEKpodR8s3iulFKiNz4vNhSTX5JPfunFW0m++blpQbaK0qAhyC2IcI9wwjzCiPSMJNY3lkY+jYj0jLzuitvXdGa7sfalMAsKsy/eZ0FRNuQkQX761fcNaQUxveGGEdCgk01+AQpRHykOWuIb9iAhugsh5/4lMn47YWf34pZ/gcj47UTGbzeXLXHUUejqTZGLB0U6Lwp1niSHtZJOyVbm5uRmHnllkl+Sz/HM48RlxRGXHWe+T8xNpKC0gMyiTDKLMjl24dh1j+/o4Ii7kzs6rQ5XR1d0jjp0Wp3x3lGHq9a4zcnBCUcHR/NNq9FabNNqtHg4e3Bb49tq8u249rWodeK0tDT0ej3BwcEW24ODg0lOTi53n+Tk5HLLl5aWkpaWRmho2Y5WRUVFFBVdShSysozLA2RnZ5cpWx1p+Wn8d/1/rXpMMH7YfJ198dH54OPig4/OB18XX3xcfPB39SfMI4xQt1CC3YOv2uk3Pze/ekEc+wfWzLl2GWdP8AoHvxgIbmG8hXUAd79LZXJyqhVGta4jr3LJoll137uKqkp8VY2tqu+FjSvMLyZfp3o3w4qrrc9eBZz0acJJnyZoW9yFb/pp/NNO4Zd+Gs+cFNzyM9AUFUBeAc6AM+AJpOt15Ps0VTnya7P23wG1xLjEEBMUA0GXtimKQk5JDql5qaQUpJCSf+mWWZRJdnE22UXZZBdnk1WcRamhFD16irDO90OALoCbg2+2yrFMTD+vijQ4qf6bfmUVmKIo16wWK698edtNZs+ezUsvvVRme0SEzONgXTnAOWCH2oFY2UfXL6KauhybqD5b//muuHiru8YzXu0Q7Jr3/d41ctycnBy8va99bNWSm4CAALRabZlampSUlDK1MyYhISHllnd0dMTfv/ze4tOnT2fq1Knm5waDgYyMDPz9/S0SouzsbCIiIjhz5kyd7otjbXLdct31RX29drluuW57oSgKOTk5hIWFXbesasmNs7MzHTp0YPXq1YwcOdK8ffXq1YwYMaLcfbp168ZPP/1kse3PP/+kY8eOV+1v4+LigouL5RBGHx+fq8bl5eVldx+IipDrrl/q63VD/b12ue76xV6v+3o1NiYONRzHNU2dOpXPPvuMhQsXcvjwYZ544gkSEhLM89ZMnz6dsWPHmstPmjSJ+Ph4pk6dyuHDh1m4cCELFixg2rRpal2CEEIIIeoYVfvcjBo1ivT0dF5++WWSkpJo2bIlv/76K1FRUQAkJSWRkJBgLh8TE8Ovv/7KE088wYcffkhYWBjvvfdevZ7jRgghhBCWVO9QPHnyZCZPnlzua4sXLy6zrXfv3uzevdvqcbi4uDBz5swyTVj2Tq5brru+qK/XLtct110fqTqJnxBCCCGEtana50YIIYQQwtokuRFCCCGEXZHkRgghhBB2RZIbIYQQQtgVSW6uoaioiLZt26LRaNi7d6/a4dS4W265hcjISHQ6HaGhodx3332cO3dO7bBqVFxcHBMmTCAmJgZXV1caNWrEzJkzKS4uVju0WvHf//6X7t274+bmds3JLW3dvHnziImJQafT0aFDBzZu3Kh2SDVuw4YNDB8+nLCwMDQaDatWrVI7pFoxe/ZsOnXqhKenJ0FBQdx6660cPXpU7bBq3EcffUTr1q3Nk/d169aN3377Te2wVCPJzTU8/fTTFZrm2V706dOHb7/9lqNHj/Ldd99x8uRJ7rjjDrXDqlFHjhzBYDAwf/58Dh48yDvvvMPHH3/MjBkz1A6tVhQXF3PnnXfyn//8R+1QasyyZcuYMmUKzz33HHv27KFnz54MHjzYYg4te5SXl0ebNm344IMP1A6lVq1fv56HH36YrVu3snr1akpLSxkwYAB5eXlqh1ajGjRowGuvvcbOnTvZuXMnffv2ZcSIERw8eFDt0NShiHL9+uuvSrNmzZSDBw8qgLJnzx61Q6p1P/zwg6LRaJTi4mK1Q6lVc+bMUWJiYtQOo1YtWrRI8fb2VjuMGtG5c2dl0qRJFtuaNWumPPvssypFVPsAZeXKlWqHoYqUlBQFUNavX692KLXO19dX+eyzz9QOQxVSc1OO8+fP8+CDD/LFF1/g5uamdjiqyMjI4KuvvqJ79+5XXbfLXmVlZeHn56d2GMIKiouL2bVrFwMGDLDYPmDAADZv3qxSVKI2ZWVlAdSr32m9Xs8333xDXl4e3bp1UzscVUhycwVFURg/fjyTJk2iY8eOaodT65555hnc3d3x9/cnISGBH374Qe2QatXJkyd5//33zeubCduWlpaGXq8nODjYYntwcDDJyckqRSVqi6IoTJ06lRtvvJGWLVuqHU6NO3DgAB4eHri4uDBp0iRWrlzJDTfcoHZYqqg3yc2sWbPQaDTXvO3cuZP333+f7Oxspk+frnbIVlHR6zZ56qmn2LNnD3/++SdarZaxY8ei2OAk1pW9boBz584xaNAg7rzzTiZOnKhS5NVXlWu3dxqNxuK5oihltgn788gjj7B//36WLl2qdii1omnTpuzdu5etW7fyn//8h3HjxnHo0CG1w1JFvVl+IS0tjbS0tGuWiY6O5u677+ann36y+OLT6/VotVruvfdelixZUtOhWlVFr1un05XZfvbsWSIiIti8ebPNVW1W9rrPnTtHnz596NKlC4sXL8bBwXbz/qr8zBcvXsyUKVPIzMys4ehqV3FxMW5ubixfvpyRI0eatz/++OPs3buX9evXqxhd7dFoNKxcuZJbb71V7VBqzaOPPsqqVavYsGEDMTExaoejiptvvplGjRoxf/58tUOpdaovnFlbAgICCAgIuG659957j1dffdX8/Ny5cwwcOJBly5bRpUuXmgyxRlT0ustjynuLioqsGVKtqMx1JyYm0qdPHzp06MCiRYtsOrGB6v3M7Y2zszMdOnRg9erVFsnN6tWrGTFihIqRiZqiKAqPPvooK1euZN26dfU2sQHje2GL39/WUG+Sm4qKjIy0eO7h4QFAo0aNaNCggRoh1Yrt27ezfft2brzxRnx9fTl16hQvvvgijRo1srlam8o4d+4cN910E5GRkbz55pukpqaaXwsJCVExstqRkJBARkYGCQkJ6PV683xOsbGx5s++rZs6dSr33XcfHTt2pFu3bnzyySckJCTYfb+q3NxcTpw4YX5++vRp9u7di5+fX5nvOXvy8MMP8/XXX/PDDz/g6elp7lvl7e2Nq6urytHVnBkzZjB48GAiIiLIycnhm2++Yd26dfz+++9qh6YO1cZp2YjTp0/Xi6Hg+/fvV/r06aP4+fkpLi4uSnR0tDJp0iTl7NmzaodWoxYtWqQA5d7qg3HjxpV77WvXrlU7NKv68MMPlaioKMXZ2Vlp3759vRgWvHbt2nJ/tuPGjVM7tBp1td/nRYsWqR1ajXrggQfMn/HAwEClX79+yp9//ql2WKqpN31uhBBCCFE/2HbnAiGEEEKIK0hyI4QQQgi7IsmNEEIIIeyKJDdCCCGEsCuS3AghhBDCrkhyI4QQQgi7IsmNEEIIIeyKJDdCiFpz0003MWXKFPPz6Oho5s6dq1o8tuymm24yL4Rqmll63bp1aDSaaq0RtnjxYvNxL/9ZCWFLJLkRog4YP358uat3Dxo0SO3QatSOHTv4v//7P7XDsFkPPvggSUlJtGzZ8rplL09arnZbt24do0aNIikpya6XXRH2T9aWEqKOGDRoEIsWLbLY5uLiUqPnLC4uxtnZuUbPcS2BgYE1clxFUdDr9Tg62vdXnJubW4XXQBs1apRFsnzbbbfRsmVLXn75ZfM2Pz8/nJ2dcXV1VfVzIUR1Sc2NEHWEi4sLISEhFjdfX1/z6xqNhs8++4yRI0fi5uZG48aN+fHHHy2OcejQIYYMGYKHhwfBwcHcd999pKWlmV+/6aabeOSRR5g6dSoBAQH0798fgB9//JHGjRvj6upKnz59WLJkibl5Iy8vDy8vL1asWGFxrp9++gl3d3dycnLKvZ68vDzGjh2Lh4cHoaGhvPXWW2XKXNksNWvWLCIjI3FxcSEsLIzHHnvM/FpRURFPP/00ERERuLi40LhxYxYsWABcao75448/6NixIy4uLmzcuBFFUZgzZw4NGzbE1dWVNm3aWFyHab9ffvmFNm3aoNPp6NKlCwcOHDCXSU9PZ/To0TRo0AA3NzdatWrF0qVLLa7jpptu4rHHHuPpp5/Gz8+PkJAQZs2aZVEmMzOT//u//yM4OBidTkfLli35+eefq/z+VkRBQQFDhw6la9euFBQUWHy2nJ2dzcnR5duEsAeS3AhhQ1566SXuuusu9u/fz5AhQ7j33nvJyMgAICkpid69e9O2bVt27tzJ77//zvnz57nrrrssjrFkyRIcHR3ZtGkT8+fPJy4ujjvuuINbb72VvXv38tBDD/Hcc8+Zy7u7u3P33XeXqVVatGgRd9xxB56enuXG+tRTT7F27VpWrlzJn3/+ybp169i1a9dVr23FihW88847zJ8/n+PHj7Nq1SpatWplfn3s2LF88803vPfeexw+fJiPP/64zMrlTz/9NLNnz+bw4cO0bt2a559/nkWLFvHRRx9x8OBBnnjiCcaMGcP69evLxPrmm2+yY8cOgoKCuOWWWygpKQGgsLCQDh068PPPP/Pvv//yf//3f9x3331s27atzPvq7u7Otm3bmDNnDi+//DKrV68GwGAwMHjwYDZv3syXX37JoUOHeO2119BqtVV+f68nKyuLAQMGUFxczF9//YWfn1+VjiOETVJ33U4hhKIYV+fWarWKu7u7xe3ll182lwGU559/3vw8NzdX0Wg0ym+//aYoiqK88MILyoABAyyOe+bMGQVQjh49qiiKovTu3Vtp27atRZlnnnlGadmypcW25557TgGUCxcuKIqiKNu2bVO0Wq2SmJioKIqipKamKk5OTsq6devKvZ6cnBzF2dlZ+eabb8zb0tPTFVdXV+Xxxx83b4uKilLeeecdRVEU5a233lKaNGmiFBcXlzne0aNHFUBZvXp1ueczrYC9atUqi/dHp9Mpmzdvtig7YcIEZfTo0Rb7lRfnsmXLyj2XoijKkCFDlCeffNL8vHfv3sqNN95oUaZTp07KM888oyiKovzxxx+Kg4OD+edwpcq+v6ZzXv5eXn49R44cUdq0aaPcdtttSlFRUYX3r8zrQtRlUnMjRB3Rp08f9u7da3F7+OGHLcq0bt3a/Njd3R1PT09SUlIA2LVrF2vXrsXDw8N8a9asGQAnT54079exY0eLYx49epROnTpZbOvcuXOZ5y1atODzzz8H4IsvviAyMpJevXqVey0nT56kuLjYolOqn58fTZs2ver133nnnRQUFNCwYUMefPBBVq5cSWlpKQB79+5Fq9XSu3fvq+5/5bUdOnSIwsJC+vfvb/GefP755xbvB1BunIcPHwZAr9fz3//+l9atW+Pv74+Hhwd//vknCQkJFse4/GcDEBoaav7Z7N27lwYNGtCkSZNy467s+3s9N998Mw0bNuTbb7+VpiZRL9l3bzshbIi7uzuxsbHXLOPk5GTxXKPRYDAYAGPTx/Dhw3n99dfL7BcaGmpxnsspioJGoymz7UoTJ07kgw8+4Nlnn2XRokXcf//9Zfa71v7XExERwdGjR1m9ejVr1qxh8uTJvPHGG6xfvx5XV9cKHePyazO9L7/88gvh4eEW5SrSUdt0bW+99RbvvPMOc+fOpVWrVri7uzNlyhSKi4styl/rZ1OR+Cvz/l7P0KFD+e677zh06JBF054Q9YXU3AhhJ9q3b8/BgweJjo4mNjbW4nZlQnO5Zs2asWPHDottO3fuLFNuzJgxJCQk8N5773Hw4EHGjRt31WPGxsbi5OTE1q1bzdsuXLjAsWPHrnkNrq6u3HLLLbz33nusW7eOLVu2cODAAVq1aoXBYCjTV+ZabrjhBlxcXEhISCjzfkRERFiULS9OU63Xxo0bGTFiBGPGjKFNmzY0bNiQ48ePVzgOMNbqnD179prXX5n393pee+01xo0bR79+/Th06FCVjyOErZKaGyHqiKKiIpKTky22OTo6EhAQUKH9H374YT799FNGjx7NU089RUBAACdOnOCbb77h008/RavVlrvfQw89xNtvv80zzzzDhAkT2Lt3L4sXLwawqDnw9fXltttu46mnnmLAgAE0aNDgqrF4eHgwYcIEnnrqKfz9/QkODua5557DweHq/08tXrwYvV5Ply5dcHNz44svvsDV1ZWoqCj8/f0ZN24cDzzwAO+99x5t2rQhPj6elJSUMh2mTTw9PZk2bRpPPPH/7d0xSONgGMbx/+0BKzqoQ6HgYEWKWMTBEGsRshVBEVwVEVzCIQgOOqilYqVureAo2ayDXVyEgtjFWRAEF0GdFAQVhHg3HBQi6Nme3knu+UGX9Gt4+04P3/s1/c7z8zOmaXJ3d0elUsEwDF94WFpa8tXZ3NzM8PAw8CuoFYtFKpUKjY2N5HI5rq+viUajr36XlwYGBrAsi5GREXK5HO3t7ZyenvqeZVRLf99jfX0dz/NIJpOUy+VqWBP5H2jnRuSL2N/fp7W11fcyTfPdn29ra+Po6AjP87Btm66uLhzHoaGh4c1QEYlE2NnZYXd3l1gsRqFQqP5a6uX4ZnJykqenJyYmJn5bTzabxbIsUqkUQ0NDmKZJPB5/dX0oFGJra4v+/n5isRgHBweUSiWampoAKBQKjI6OMjMzQ0dHB1NTU9zf379Zw/LyMouLi2QyGaLRKLZtUyqViEQivnWrq6s4jkM8Hufq6oq9vb3qWZWFhQV6enqwbZtEIkFLS0s1+NSiWCzS29vL+Pg4nZ2dzM3N4Xmeb00t/X2PjY0NxsbGSCaTv901EwmSbz/qGY6LSKCl02k2Nze5uLjwXXddF8dxuLy8DMRB1XK5zODgILe3t4RCoX9dTk39TSQSdHd3f9rfV3z2/UU+k3ZuRIR8Ps/x8THn5+dsb2+TzWZ9Y5uHhwdOTk7IZDJMT08HIth8JfX2N5/PYxiG76GDf8p1XQzD4PDw8MPuKfK36cyNiHB2dsbKygo3NzeEw2FmZ2eZn5+vvr+2tkY6ncayLN91+Rj19Nd1XR4fHwEIh8MfVksqlaKvrw/gS+xmidRDYykREREJFI2lREREJFAUbkRERCRQFG5EREQkUBRuREREJFAUbkRERCRQFG5EREQkUBRuREREJFAUbkRERCRQFG5EREQkUH4CgynCEQ38lHUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(discrepancies[0] - np.mean(discrepancies[0]), label=f\"DIRECT SPACE\")\n",
    "sns.distplot(discrepancies[1] - np.mean(discrepancies[1]), label=f\"PME\")\n",
    "sns.distplot(discrepancies[2] - np.mean(discrepancies[2]), label=f\"BF\")\n",
    "plt.xlabel(\"Energy discrepancy [kT]\")\n",
    "plt.title(\"distribution of energy discrepancies\")\n",
    "plt.legend(loc='best')\n",
    "plt.ylim(0, 1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "2a290b6d-88a5-458b-b3be-9851bef4d614",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_20798/3954277828.py:1: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(discrepancies[1])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'PME')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(discrepancies[1])\n",
    "\n",
    "plt.xlabel(\"Energy discrepancy [kT]\")\n",
    "plt.title(\"PME\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e984c441-64bb-46e7-a3ee-0ba442683777",
   "metadata": {},
   "source": [
    "lets show the std deviations of each energy difference collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "8945d965-9050-4c6e-9822-8f5d6a392dd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0005405567799847361"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(discrepancies[0]) # nopme discrepancies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "fab86f58-ad3a-4314-a62b-791853d593ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5536461490895151"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(discrepancies[1]) # pme discrepancies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "c41d6f07-823c-446f-8610-ec5a3622b6b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0103652650217458"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(discrepancies[2]) # bf discrepancies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "223b76cc-7c26-4dd4-9890-05b6c40b2aaa",
   "metadata": {},
   "source": [
    "lets compute reduced free energies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "7eafac41-4c19-4c70-8d69-9c7f1a47b5a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymbar.exp import EXP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "a5eea7d0-224c-4418-ad45-2c645c5ccf94",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = [EXP(-discrepancies[i]) for i in range(3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "723c4428-3e40-4712-b0f9-0f1e02c7d660",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3.6396494484502995e-05, 7.643082795953777e-05),\n",
       " (89.5669393617875, 0.05185429838858166),\n",
       " (-229.4584913138414, 0.15226045882617034)]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "683b7599-daa1-4fad-8a59-09fd0e3ce329",
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute ligand inner product of normed forces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "c549947f-5564-4887-8567-30811c604b6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# nopme_outs = [outs[i][0] for i in range(len(outs))]\n",
    "# pme_outs = [outs[i][1] for i in range(len(outs))]\n",
    "# bf_outs = [outs[i][2] for i in range(len(outs))]\n",
    "\n",
    "\n",
    "nopme_outs_forces = np.array([outs[i][0][0][1] for i in range(len(outs))])\n",
    "pme_outs_forces = np.array([outs[i][1][0][1] for i in range(len(outs))])\n",
    "bf_outs_forces = np.array([outs[i][2][0][1] for i in range(len(outs))])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d6870d74-ef2a-412c-a014-25761e1a04b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "lig_lig_nopme_forces = nopme_outs_forces[:,3,ligand_indices,:]\n",
    "lig_lig_pme_forces = pme_outs_forces[:,3,ligand_indices,:]\n",
    "lig_lig_bf_forces = bf_outs_forces[:,3,ligand_indices,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "98c837db-724c-4561-867f-a27603544e59",
   "metadata": {},
   "outputs": [],
   "source": [
    "pme_dot_nopme = []\n",
    "pme_dot_bf = []\n",
    "for i in range(lig_lig_nopme_forces.shape[0]):\n",
    "    nopme = lig_lig_nopme_forces[i].flatten()\n",
    "    pme = lig_lig_pme_forces[i].flatten()\n",
    "    bf = lig_lig_bf_forces[i].flatten()\n",
    "    _pme_dot_nopme = np.dot(nopme / np.linalg.norm(nopme), pme / np.linalg.norm(pme))\n",
    "    _pme_dot_bf = np.dot(pme / np.linalg.norm(pme), bf / np.linalg.norm(bf))\n",
    "    pme_dot_nopme.append(_pme_dot_nopme)\n",
    "    pme_dot_bf.append(_pme_dot_bf)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "0deac660-9a08-491f-b2fc-d3a95a0e5c7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'inner product of normalized forces [unitless]')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABg7klEQVR4nO3deVxUVf8H8M9lB5VBRRaXkNwRF8CFwdxy13JNKcvtMX009y01NZcy1DazHk1LUZ/MJVPTMoR8BFxQE8U9NERFhQhUUFFkub8/iPk5AsNcuDNzZ/i8X6956Zw5c+Z7LzNzv3POuecKoiiKICIiIqJiWZk6ACIiIiIlY7JEREREpAOTJSIiIiIdmCwRERER6cBkiYiIiEgHJktEREREOjBZIiIiItLBxtQBWIL8/HzcuXMHVapUgSAIpg6HiIiI9CCKIh48eICaNWvCyqrk/iMmSzK4c+cO6tSpY+owiIiIqAySkpJQu3btEh9nsiSDKlWqACjY2c7OziaOhoiIiPSRmZmJOnXqaI7jJWGyJIPCoTdnZ2cmS0RERGamtCk0nOBNREREpAOTJSIiIiIdmCwRERER6cBkiYiIiEgHJktEREREOjBZIiIiItKByRIRERGRDkyWiIiIiHRgskRERESkA1fwVqi8fBEnE+8i9cETuFVxQBvvarC2KrrCqD71lFZHiTExbuXVYUyMW4kxMW7l1TEGs0qWoqOj8fHHHyM2NhbJycnYvXs3+vfvr/M5UVFRmD59Oi5evIiaNWvi3Xffxbhx47Tq/Pjjj1iwYAESEhJQr149LF26FAMGDDDglugWdiEZi/ddQnLGE02Zp8oBC1/1QU9fT0n1lFZHiTExbuXVYUyMW4kxMW7l1TEWQRRF0aivWA6//vorjh49Cn9/fwwaNKjUZCkxMRG+vr4YM2YM/v3vf+Po0aN45513sHXrVgwaNAgAEBMTg/bt2+ODDz7AgAEDsHv3brz//vs4cuQI2rZtq1dcmZmZUKlUyMjIKPe14cIuJGP8d6fx/B+lMI9e85Y/evp66lUPgKLqMG7Gba5xKzEmxs24GXf5EyZ9j99mlSw9SxCEUpOl2bNnY+/evbh8+bKmbNy4cTh79ixiYmIAAMHBwcjMzMSvv/6qqdOzZ09UrVoVW7du1SsWuZKlvHwRLy3/n1YW/SwBgIfKAVGzOqPjx4d01nN3tgcgICVTGXUYN+M217iVGBPjZtyM2wFHZr9c7iE5fY/fZjUMJ1VMTAy6d++uVdajRw+sX78eOTk5sLW1RUxMDKZNm1akzsqVK0tsNzs7G9nZ2Zr7mZmZssR7MvFuiW9WABABJGc8wX9jrpdaLyUzu8THTVGHcTNuc41biTExbsbNuJ/gZOJdqOtV11lXLhZ9NlxKSgrc3d21ytzd3ZGbm4u0tDSddVJSUkpsNyQkBCqVSnOrU6eOLPGmPij5zfqsG3ezZHk9Y2PcxsW45aPEmPTBuI2LcRuXvsdMOVh0sgQUDNc9q3DU8dny4uo8X/asuXPnIiMjQ3NLSkqSJVa3Kg561fOq5iTL6xkb4zYuxi0fJcakD8ZtXIzbuPQ9ZsrBopMlDw+PIj1EqampsLGxQfXq1XXWeb636Vn29vZwdnbWusmhjXc1eKocUFKaJqDgTIBh6rql1vNwtoeHs3LqMG7Gba5xKzEmxs24GXfBMgLGYtHJklqtRkREhFZZeHg4WrVqBVtbW511goKCjBZnIWsrAQtf9QGAIm+SwvsLX/WBnY1VqfUW9W2KRX2VU4dxM25zjVuJMTFuxs24fYy63pJZJUsPHz5EXFwc4uLiABQsDRAXF4ebN28CKBgeGz58uKb+uHHjcOPGDUyfPh2XL1/Ghg0bsH79esycOVNTZ8qUKQgPD8fy5cvxxx9/YPny5fjtt98wdepUY26aRk9fT6x5yx8eKu3uRQ+Vg9apkvrUU1odxs24zTVuJcbEuBk34zYes1o6IDIyEp07dy5SPmLECGzcuBEjR47E9evXERkZqXksKioK06ZN0yxKOXv27CKLUu7cuRPz58/HtWvXNItSDhw4UO+45FxnqZClr7aqtJgYt/LqMCbGrcSYGLfy6pSHxa+zpCSGSJaIiIjIsPQ9fpvVMBwRERGRsTFZIiIiItKByRIRERGRDkyWiIiIiHRgskRERESkA5MlIiIiIh2YLBERERHpwGSJiIiISAcmS0REREQ62OhTafr06ZIbnj9/PqpVM94VgYmIiIgMQa/LnVhZWUGtVsPOzk6vRo8cOYL4+Hi8+OKL5Q7QHPByJ0REROZH3+O3Xj1LALB79264ubnpVbdKlSr6NktERESkaHrNWQoNDYVKpdK70bVr18Ld3b3MQREREREphV7DcKQbh+GIiIjMj77Hb8lnwyUlJeHWrVua+ydPnsTUqVOxbt26skVKREREpGCSk6WhQ4fi0KFDAICUlBR069YNJ0+exHvvvYclS5bIHiARERGRKUlOli5cuIA2bdoAAHbs2AFfX18cO3YM33//PTZu3Ch3fEREREQmJTlZysnJgb29PQDgt99+Q9++fQEAjRs3RnJysrzREREREZmY5GSpadOm+Prrr3H48GFERESgZ8+eAIA7d+6gevXqsgdIREREZEqSk6Xly5dj7dq16NSpE9544w20aNECALB3717N8BwRERGRpSjT0gF5eXnIzMxE1apVNWXXr1+Hk5OT3gtXWhIuHUBERGR+DLZ0wOPHj5Gdna1JlG7cuIGVK1ciPj6+QiZKREREZNkkJ0v9+vXD5s2bAQD3799H27Zt8emnn6J///5Ys2aN7AESERERmZLkZOn06dNo3749AGDnzp1wd3fHjRs3sHnzZqxatUr2AImIiIhMSXKylJWVpblQbnh4OAYOHAgrKysEBgbixo0bsgdIREREZEqSk6X69etjz549SEpKwoEDB9C9e3cAQGpqKic3ExERkcWRnCy9//77mDlzJurWrYs2bdpArVYDKOhl8vPzkz1AIiIiIlMq09IBKSkpSE5ORosWLWBlVZBvnTx5Es7OzmjcuLHsQSodlw4gIiIyPwZbOgAAPDw8UKVKFURERODx48cAgNatW1fIRImIiIgsm+RkKT09HV26dEHDhg3Ru3dvzfXg3n77bcyYMUP2AImIiIhMSXKyNG3aNNja2uLmzZtwcnLSlAcHByMsLEzW4IiIiIhMzUbqE8LDw3HgwAHUrl1bq7xBgwZcOoCIiIgsjuSepUePHmn1KBVKS0uDvb29LEERERERKYXkZKlDhw6ay50AgCAIyM/Px8cff4zOnTvLGhwRERGRqUkehvv444/RqVMnnDp1Ck+fPsW7776Lixcv4u7duzh69KghYiQiIiIyGck9Sz4+Pjh37hzatGmDbt264dGjRxg4cCDOnDmDevXqGSJGIiIiIpMp06KUpI2LUhIREZkffY/feg3DnTt3Tu8Xbt68ud51iYiIiJROr2SpZcuWEAQBpXVCCYKAvLw8WQIjIiIiUgK9kqXExERDx0FERESkSHpN8Pby8tLcbty4gVq1ammVeXl5oVatWkZZlHL16tXw9vaGg4MDAgICcPjw4RLrjhw5EoIgFLk1bdpUU2fjxo3F1nny5InBt4WIiIiUT/LZcJ07d8bdu3eLlGdkZBh8naXt27dj6tSpmDdvHs6cOYP27dujV69euHnzZrH1v/jiCyQnJ2tuSUlJqFatGgYPHqxVz9nZWatecnIyHBwcDLotREREZB4kr7MkiiIEQShSnp6ejkqVKskSVEk+++wzjB49Gm+//TYAYOXKlThw4ADWrFmDkJCQIvVVKhVUKpXm/p49e3Dv3j2MGjVKq54gCPDw8NA7juzsbGRnZ2vuZ2ZmSt0UIiIiMhN6J0sDBw4EUJBYjBw5UuvSJnl5eTh37hyCgoLkj/AfT58+RWxsLObMmaNV3r17dxw7dkyvNtavX4+uXbvCy8tLq/zhw4fw8vJCXl4eWrZsiQ8++AB+fn4lthMSEoLFixdL3wgiIiIyO3oPwxX20oiiiCpVqmjuq1QqeHh4YOzYsfjuu+8MFmhaWhry8vLg7u6uVe7u7o6UlJRSn5+cnIxff/1V0ytVqHHjxti4cSP27t2LrVu3wsHBAe3atcPVq1dLbGvu3LnIyMjQ3JKSksq2UURERKR4evcshYaGAgDq1q2LmTNnGnzIrSTPDwGWNCz4vI0bN8LFxQX9+/fXKg8MDERgYKDmfrt27eDv748vv/wSq1atKrYte3t7XjSYiIiogpA8Z2nhwoWGiKNUrq6usLa2LtKLlJqaWqS36XmiKGLDhg0YNmwY7OzsdNa1srJC69atdfYsERERUcWhV7Lk7++PgwcPomrVqvDz89PZk3P69GnZgnuWnZ0dAgICEBERgQEDBmjKIyIi0K9fP53PjYqKwp9//onRo0eX+jqiKCIuLg7NmjUrd8xERERk/vRKlvr166cZdnp+GMuYpk+fjmHDhqFVq1ZQq9VYt24dbt68iXHjxgEomEt0+/ZtbN68Wet569evR9u2beHr61ukzcWLFyMwMBANGjRAZmYmVq1ahbi4OPznP/8xyjYRERGRsumVLD079GaqYTgACA4ORnp6OpYsWYLk5GT4+vpi//79mrPbkpOTi6y5lJGRgR9//BFffPFFsW3ev38fY8eORUpKClQqFfz8/BAdHY02bdoYfHuIiIhI+QSxtAu+leDp06dITU1Ffn6+VvkLL7wgS2DmRN+rFhMREZFy6Hv8ljzB+8qVKxg9enSRtY0Kz0rjhXSJiIjIkkhOlkaNGgUbGxv8/PPP8PT01Ou0fSIiIiJzJTlZiouLQ2xsLBo3bmyIeIiIiIgURfKFdH18fJCWlmaIWIiIiIgUR3KytHz5crz77ruIjIxEeno6MjMztW5ERERElkTy2XBWVgX5VUmXHamIE7x5NhwREZH5MdjZcIcOHSpXYERERETmRHKy1LFjR0PEQURERKRIkpOl6OhonY936NChzMEQERERKY3kZKlTp05Fyp6dv1QR5ywRERGR5ZJ8Nty9e/e0bqmpqQgLC0Pr1q0RHh5uiBiJiIiITEZyz5JKpSpS1q1bN9jb22PatGmIjY2VJTAiIiIiJZDcs1SSGjVqID4+Xq7miIiIiBRBcs/SuXPntO6Loojk5GQsW7YMLVq0kC0wIiIiIiWQnCy1bNkSgiDg+bUsAwMDsWHDBtkCIyIiIlICyclSYmKi1n0rKyvUqFEDDg4OsgVFREREpBSSkyUvLy9DxEFERESkSHpN8F61ahWePHmid6Nff/01Hjx4UOagiIiIiJRCrwvpWltbIyUlBTVq1NCrUWdnZ8TFxeHFF18sd4DmgBfSJSIiMj+yXkhXFEV06dIFNjb6jdo9fvxYvyiJiIiIFE6v7GfhwoWSGu3Xrx+qVatWpoCIiIiIlESvYTjSjcNwRERE5kff47dsK3gTERERWSImS0REREQ6MFkiIiIi0oHJEhEREZEO5U6W8vLyEBcXh3v37skRDxEREZGiSE6Wpk6divXr1wMoSJQ6duwIf39/1KlTB5GRkXLHR0RERGRSkpOlnTt3okWLFgCAffv2ITExEX/88QemTp2KefPmyR4gERERkSlJTpbS0tLg4eEBANi/fz8GDx6Mhg0bYvTo0Th//rzsARIRERGZkuRkyd3dHZcuXUJeXh7CwsLQtWtXAEBWVhasra1lD5CIiIjIlPS72NszRo0ahSFDhsDT0xOCIKBbt24AgBMnTqBx48ayB0hERERkSpKTpUWLFsHX1xdJSUkYPHgw7O3tAQDW1taYM2eO7AESERERmVK5rg335MkTODg4yBmPWeK14YiIiMyPwa4Nl5eXhw8++AC1atVC5cqVce3aNQDAggULNEsKEBEREVkKycnS0qVLsXHjRqxYsQJ2dnaa8mbNmuHbb7+VNTgiIiIiU5OcLG3evBnr1q3Dm2++qXX2W/PmzfHHH3/IGhwRERGRqUlOlm7fvo369esXKc/Pz0dOTo4sQREREREpheRkqWnTpjh8+HCR8h9++AF+fn6yBEVERESkFJKTpYULF2LixIlYvnw58vPzsWvXLowZMwYfffQR3n//fUPEqGX16tXw9vaGg4MDAgICik3cCkVGRkIQhCK354cLf/zxR/j4+MDe3h4+Pj7YvXu3oTeDiIiIzITkZOnVV1/F9u3bsX//fgiCgPfffx+XL1/Gvn37NAtUGsr27ds116A7c+YM2rdvj169euHmzZs6nxcfH4/k5GTNrUGDBprHYmJiEBwcjGHDhuHs2bMYNmwYhgwZghMnThh0W4iIiMg8lGudJWNr27Yt/P39sWbNGk1ZkyZN0L9/f4SEhBSpHxkZic6dO+PevXtwcXEpts3g4GBkZmbi119/1ZT17NkTVatWxdatW/WKi+ssERERmR+DrbP0+++/F9vrcuLECZw6dUpqc3p7+vQpYmNj0b17d63y7t2749ixYzqf6+fnB09PT3Tp0gWHDh3SeiwmJqZImz169NDZZnZ2NjIzM7VuREREZJkkJ0sTJkxAUlJSkfLbt29jwoQJsgRVnLS0NOTl5cHd3V2r3N3dHSkpKcU+x9PTE+vWrcOPP/6IXbt2oVGjRujSpQuio6M1dVJSUiS1CQAhISFQqVSaW506dcqxZURERKRkkq8Nd+nSJfj7+xcp9/Pzw6VLl2QJShdBELTui6JYpKxQo0aN0KhRI819tVqNpKQkfPLJJ+jQoUOZ2gSAuXPnYvr06Zr7mZmZTJiIiIgslOSeJXt7e/z1119FypOTk2FjIzn30purqyusra2L9PikpqYW6RnSJTAwEFevXtXc9/DwkNymvb09nJ2dtW5ERERkmSQnS926dcPcuXORkZGhKbt//z7ee+89g54NZ2dnh4CAAERERGiVR0REICgoSO92zpw5A09PT819tVpdpM3w8HBJbRIREZHlktwV9Mknn6Bjx47w8vLSLEIZFxcHd3d3/Pe//5U9wGdNnz4dw4YNQ6tWraBWq7Fu3TrcvHkT48aNA1AwPHb79m1s3rwZALBy5UrUrVsXTZs2xdOnT/Hdd9/hxx9/xI8//qhpc8qUKejQoQOWL1+Ofv364aeffsJvv/2GI0eOGHRbiIiIyDxITpZq166Nc+fOYcuWLTh79iwcHR0xatQovPHGG7C1tTVEjBrBwcFIT0/HkiVLkJycDF9fX+zfvx9eXl4ACoYCn11z6enTp5g5cyZu374NR0dHNG3aFL/88gt69+6tqRMUFIRt27Zh/vz5WLBgAerVq4ft27ejbdu2Bt0WIiIiMg+S1lnKyclBo0aN8PPPP8PHx8eQcZkVrrNERERkfgyyzpKtrS2ys7N1nilGREREZEkkT/CeNGkSli9fjtzcXEPEQ0RERKQokucsnThxAgcPHkR4eDiaNWuGSpUqaT2+a9cu2YIjIiIiMjXJyZKLiwsGDRpkiFiIiIiIFEdyshQaGmqIOIiIiIgUqcxLbv/999+Ij4+HIAho2LAhatSoIWdcRERERIogeYL3o0eP8K9//Quenp7o0KED2rdvj5o1a2L06NHIysoyRIxEREREJiM5WZo+fTqioqKwb98+3L9/H/fv38dPP/2EqKgozJgxwxAxEhEREZmMpEUpgYIL2u7cuROdOnXSKj906BCGDBmCv//+W874zAIXpSQiIjI/BlmUEgCysrLg7u5epNzNzY3DcERERGRxJCdLarUaCxcuxJMnTzRljx8/xuLFi6FWq2UNjoiIiMjUJJ8Nt3LlSvTq1Qu1a9dGixYtIAgC4uLi4ODggAMHDhgiRiIiIiKTkTxnCSjoSfruu+/wxx9/QBRF+Pj44M0334Sjo6MhYlQ8zlkiIiIyP/oev/XqWfL398fBgwdRtWpVLFmyBDNnzsSYMWNkC5aIiIhIqfSas3T58mU8evQIALB48WI8fPjQoEERERERKYVePUstW7bEqFGj8NJLL0EURXzyySeoXLlysXXff/99WQMkIiIiMiW95izFx8dj4cKFSEhIwOnTp+Hj4wMbm6J5liAIOH36tEECVTLOWSIiIjI/+h6/JU/wtrKyQkpKCtzc3ModpKVgskRERGR+ZJ3g/az8/PxyBUZERERkTiQvSklERERUkTBZIiIiItKByRIRERGRDkyWiIiIiHRgskRERESkg15nw1WtWhWCIOjV4N27d8sVEBEREZGS6JUsrVy5UvP/9PR0fPjhh+jRowfUajUAICYmBgcOHMCCBQsMEiQRERGRqUhelHLQoEHo3LkzJk6cqFX+1Vdf4bfffsOePXvkjM8scFFKIiIi86Pv8VvynKUDBw6gZ8+eRcp79OiB3377TWpzRERERIomOVmqXr06du/eXaR8z549qF69uixBERERESmF5MudLF68GKNHj0ZkZKRmztLx48cRFhaGb7/9VvYAiYiIiExJcrI0cuRINGnSBKtWrcKuXbsgiiJ8fHxw9OhRtG3b1hAxEhEREZmM5AneVBQneBMREZkfg03wBoCEhATMnz8fQ4cORWpqKgAgLCwMFy9eLFu0RERERAolOVmKiopCs2bNcOLECfz44494+PAhAODcuXNYuHCh7AESERERmZLkZGnOnDn48MMPERERATs7O015586dERMTI2twRERERKYmOVk6f/48BgwYUKS8Ro0aSE9PlyUoIiIiIqWQfDaci4sLkpOT4e3trVV+5swZ1KpVS7bAiIhIPnl5ecjJyTF1GERGZWtrC2tr63K3IzlZGjp0KGbPno0ffvgBgiAgPz8fR48excyZMzF8+PByB0RERPIRRREpKSm4f/++qUMhMgkXFxd4eHhAEIQytyE5WVq6dClGjhyJWrVqadZYysvLw9ChQzF//vwyB0JERPIrTJTc3Nzg5ORUrgMGkTkRRRFZWVmas/Y9PT3L3FaZ11lKSEjAmTNnkJ+fDz8/PzRo0KDMQZg7rrNEREqUl5eHK1euwM3NjZejogorPT0dqampaNiwYZEhOYOtsxQdHY3U1FTUq1cPr732GoYMGYIGDRogJycH0dHR0rdCotWrV8Pb2xsODg4ICAjA4cOHS6y7a9cudOvWDTVq1ICzszPUajUOHDigVWfjxo0QBKHI7cmTJ4beFCIigyqco+Tk5GTiSIhMp/D9X545e5KTpU6dOqFFixZFlgm4e/cuOnfuXOZA9LF9+3ZMnToV8+bNw5kzZ9C+fXv06tULN2/eLLZ+dHQ0unXrhv379yM2NhadO3fGq6++ijNnzmjVc3Z2RnJystbNwcHBoNtCRGQsHHqjikyO93+ZVvB+/fXX0aVLF2zcuFGr3NBXTvnss88wevRovP3222jSpAlWrlyJOnXqYM2aNcXWX7lyJd599120bt0aDRo0wEcffYQGDRpg3759WvUEQYCHh4fWTZfs7GxkZmZq3YiIiMgySU6WBEHA3Llz8d1332HSpEmYPn26Jkky5K+Xp0+fIjY2Ft27d9cq7969O44dO6ZXG/n5+Xjw4AGqVaumVf7w4UN4eXmhdu3aeOWVV4r0PD0vJCQEKpVKc6tTp460jSEiIsXo1KkTpk6dKktb8fHx8PDwwIMHD2Rpj3SbOXMmJk+ebPDXkZwsFSZGAwcORHR0NHbu3IlevXoZ/LTUtLQ05OXlwd3dXavc3d0dKSkperXx6aef4tGjRxgyZIimrHHjxti4cSP27t2LrVu3wsHBAe3atcPVq1dLbGfu3LnIyMjQ3JKSksq2UUREZiIvX0RMQjp+iruNmIR05OVX3Guwb9y4ES4uLsU+Nm/ePEyYMAFVqlQxblAV1LvvvovQ0FAkJiYa9HUkLx3wLD8/P5w8eRL9+/dHly5d5IpJp+d7r0RR1KtHa+vWrVi0aBF++uknuLm5acoDAwMRGBioud+uXTv4+/vjyy+/xKpVq4pty97eHvb29mXcAiIi8xJ2IRmL911Ccsb/n/jiqXLAwld90NO37KdjW5pbt25h7969WLlypalDqTDc3NzQvXt3fP3111i+fLnBXkdyz9KIESPg6Oioue/h4YGoqCh06dIFL7zwgqzBPcvV1RXW1tZFepFSU1OL9DY9b/v27Rg9ejR27NiBrl276qxrZWWF1q1b6+xZIiKqKMIuJGP8d6e1EiUASMl4gvHfnUbYhWSDvG6nTp0wefJkvPvuu6hWrRo8PDywaNEirTqCIGDNmjXo1asXHB0d4e3tjR9++EFnu48ePcLw4cNRuXJleHp64tNPPy1S5969exg+fDiqVq0KJycn9OrVS3NMiIyMxKhRo5CRkaE5e7owrh07dqBFixaoXbu2pq3CXqg9e/agYcOGcHBwQLdu3bRGJBYtWoSWLVtiw4YNeOGFF1C5cmWMHz8eeXl5WLFiBTw8PODm5oalS5dqxZmRkYGxY8fCzc0Nzs7OePnll3H27Fkpu1mv/Xzz5k3069cPlStXhrOzM4YMGYK//vqrSPxr165FnTp14OTkhMGDB2uNOI0cORL9+/fHRx99BHd3d7i4uGDx4sXIzc3FrFmzUK1aNdSuXRsbNmzQeu3bt28jODgYVatWRfXq1dGvXz9cv35dq07fvn2xdetWSdstleRkKTQ0tEj3or29PTZt2mTQbjA7OzsEBAQgIiJCqzwiIgJBQUElPm/r1q0YOXIkvv/+e/Tp06fU1xFFEXFxceVavIqIyBLk5YtYvO8SihtwKyxbvO+SwYbkNm3ahEqVKuHEiRNYsWIFlixZUuQYsGDBAgwaNAhnz57FW2+9hTfeeAOXL18usc1Zs2bh0KFD2L17N8LDwxEZGYnY2FitOiNHjsSpU6ewd+9exMTEQBRF9O7dGzk5OQgKCsLKlSu1zqKeOXMmgIIzsFu1alXkNbOysrB06VJs2rQJR48eRWZmJl5//XWtOgkJCfj1118RFhaGrVu3YsOGDejTpw9u3bqFqKgoLF++HPPnz8fx48cBFByr+vTpg5SUFM0Z3/7+/ujSpQvu3r0r234WRRH9+/fH3bt3ERUVhYiICCQkJCA4OFirjT///BM7duzAvn37EBYWhri4OEyYMEGrzv/+9z/cuXMH0dHR+Oyzz7Bo0SK88sorqFq1Kk6cOIFx48Zh3LhxmkQyKysLnTt3RuXKlREdHY0jR46gcuXK6NmzJ54+fappt02bNkhKSsKNGzckbbckoh7Onj0r5uXlaf6v62ZI27ZtE21tbcX169eLly5dEqdOnSpWqlRJvH79uiiKojhnzhxx2LBhmvrff/+9aGNjI/7nP/8Rk5OTNbf79+9r6ixatEgMCwsTExISxDNnzoijRo0SbWxsxBMnTugdV0ZGhghAzMjIkG9jiYjK6fHjx+KlS5fEx48fl+n5x/5ME71m/1zq7difaTJHLoodO3YUX3rpJa2y1q1bi7Nnz9bcByCOGzdOq07btm3F8ePHF9vmgwcPRDs7O3Hbtm2asvT0dNHR0VGcMmWKKIqieOXKFRGAePToUU2dtLQ00dHRUdyxY4coiqIYGhoqqlSqIu23aNFCXLJkiVZZaGioCEA8fvy4puzy5csiAM1xZuHChaKTk5OYmZmpqdOjRw+xbt26mmOvKIpio0aNxJCQEFEURfHgwYOis7Oz+OTJE63Xq1evnrh27dpit784pe3n8PBw0draWrx586bm8YsXL4oAxJMnT2rit7a2FpOSkjR1fv31V9HKykpMTk4WRVEUR4wYIXp5eRXZnvbt22vu5+bmipUqVRK3bt0qiqIorl+/XmzUqJGYn5+vqZOdnS06OjqKBw4c0JQVHoMjIyOL3UZdnwN9j996zVlq2bIlUlJS4ObmhpYtW0IQBK1lAgrvC4KAvLw82RO6QsHBwUhPT8eSJUuQnJwMX19f7N+/H15eXgCA5ORkrTWX1q5di9zcXEyYMEErwx0xYoRm2YP79+9j7NixSElJgUqlgp+fH6Kjo9GmTRuDbQcRkTlIfaDf4rz61pOqefPmWvc9PT01l64opFari9yPi4srtr2EhAQ8ffpU6znVqlVDo0aNNPcvX74MGxsbtG3bVlNWvXp1NGrUSGePFQA8fvy42DX6bGxstHqcGjduDBcXF1y+fFlzrKlbt67WqI27uzusra1hZWWlVVa4/bGxsXj48GGRldkfP36MhIQEnXE+T9d+vnz5MurUqaN11rePj48m/tatWwMAXnjhBa3hR7Vajfz8fM3ZgQDQtGnTItvj6+uruW9tbY3q1atrbeOff/5ZZDTryZMnWttYODUoKytL0nZLoVeylJiYiBo1amj+b0rvvPMO3nnnnWIfe37dp8jIyFLb+/zzz/H555/LEBkRkWVxq6Lf4rz61pPK1tZW637hxdtLU9JJP6IeawGWVEfU42QiV1dX3Lt3T++Yni0rblt1bX9+fj48PT2LPc6VdKZeSXS9TknbXdr+KHysvNsYEBCALVu2FGm/MCcBoBl2fLZMbnolS4U9N8//n4iILFcb72rwVDkgJeNJsfOWBAAeKge08a5WzKPGcfz4cQwfPlzrvp+fX7F169evD1tbWxw/flxzQtK9e/dw5coVdOzYEUBBr0lubi5OnDihmQ+bnp6OK1euoEmTJgAK5tAWN4ri5+eHS5cuFSnPzc3FqVOnNL1I8fHxuH//Pho3blzm7fb390dKSgpsbGxQt27dMrdTGh8fH9y8eRNJSUma3qVLly4hIyNDsz+Agkngd+7cQc2aNQEAMTExsLKyQsOGDcv82v7+/ti+fbtmAntJLly4AFtbWzRt2rTMr1UavZKlvXv36t1g3759yxwMEREph7WVgIWv+mD8d6chAFoJU2F/wcJXfWBtZbrLqfzwww9o1aoVXnrpJWzZsgUnT57E+vXrNY936dIFAwYMwMSJE1G5cmWMHj0as2bNQvXq1eHu7o558+ZpDQ01aNAA/fr1w5gxY7B27VpUqVIFc+bMQa1atdCvXz8ABUNmDx8+xMGDB9GiRQs4OTnByckJPXr0wNtvv428vDytC7ba2tpi0qRJWLVqFWxtbTFx4kQEBgaWa7pH165doVar0b9/fyxfvhyNGjXCnTt3sH//fvTv37/YieZlfZ3mzZvjzTffxMqVK5Gbm4t33nkHHTt21HoNBwcHjBgxAp988gkyMzMxefJkDBkypNQrYujy5ptv4uOPP0a/fv2wZMkS1K5dGzdv3sSuXbswa9YszbDf4cOH0b59e60z9eWmV7LUv39/vRoz9JwlIiIyrp6+nljzln+RdZY8FLLO0uLFi7Ft2za888478PDwwJYtW+Dj46N5PCEhAWlpaZr7H3/8MR4+fIi+ffuiSpUqmDFjBjIyMrTaDA0NxZQpU/DKK6/g6dOn6NChA/bv368ZMgoKCsK4ceM082gXLlyIRYsWoXfv3rC1tcVvv/2GHj16aNpzcnLC7NmzMXToUNy6dQsvvfRSkVPkpRIEAfv378e8efPwr3/9C3///Tc8PDzQoUMHzXI6169fh7e3Nw4dOoROnTqV+XX27NmDSZMmoUOHDrCyskLPnj3x5ZdfatWrX78+Bg4ciN69e+Pu3bvo3bs3Vq9eXa5tdHJyQnR0NGbPno2BAwfiwYMHqFWrFrp06aLV07R161YsXry4XK9VGkHUZxCXdMrMzIRKpUJGRobOrkIiImN68uQJEhMT4e3tXe6Lg+fliziZeBepD57ArUrB0Jspe5SAggP57t279f5BbwyrV6/GTz/9hAMHDgAomEs7depUg1/lojiRkZEYMGAArl27hqpVqxrsdRYtWoQ9e/aUOLHekH755RfMmjUL586dg41N8f0/uj4H+h6/y7WCNxERVQzWVgLU9aqXXrGCGzt2LO7du4cHDx6Y/JInYWFheO+99wyaKJnao0ePEBoaWmKiJJcytf7o0SNERUXh5s2bWgtDATDKBe2IiIiUyMbGBvPmzTN1GACAZcuWmToEg3v2Wq+GJHkY7syZM+jduzeysrLw6NEjVKtWDWlpaXBycoKbmxuuXbtmqFgVi8NwRKREcg7DEZkrOYbhJF/uZNq0aXj11Vdx9+5dODo64vjx47hx4wYCAgLwySefSN8KIiIiIgWTnCzFxcVhxowZsLa2hrW1NbKzs1GnTh2sWLEC7733niFiJCIiIjIZycmSra2tZkVOd3d3zeVFVCqV1qVGiIiIiCyB5Anefn5+OHXqFBo2bIjOnTvj/fffR1paGv773/+iWbNmhoiRiIiIyGQk9yx99NFH8PQsWITsgw8+QPXq1TF+/HikpqZi3bp1sgdIREREZEqSe5aeXd68Ro0a2L9/v6wBERERESmJ5J4lIiIiS9KpUydMnTpVlrbi4+Ph4eGBBw8eyNKeoemz7VlZWRg0aBCcnZ0hCALu37+P1q1bY9euXcYJUgEkJ0vp6emYMGECfHx84OrqimrVqmndiIjIAuXnAYmHgfM7C/7Nr7jXAd24cSNcXFyKfWzevHmYMGGCyVfvltOmTZtw+PBhHDt2DMnJyVCpVFiwYAHmzJmD/Px8U4dnFJKH4d566y0kJCRg9OjRcHd315wZR0REFurSXiBsNpB55//LnGsCPZcDPn1NF5fC3Lp1C3v37sXKlStNHYqsEhIS0KRJE/j6+mrK+vTpgzFjxuDAgQPo1auXCaMzDsk9S0eOHMEPP/yA2bNnY+TIkRgxYoTWjYiILMilvcCO4dqJEgBkJheUX9prkJft1KkTJk+ejHfffRfVqlWDh4cHFi1apFVHEASsWbMGvXr1gqOjI7y9vfHDDz/obPfRo0cYPnw4KleuDE9PT3z66adF6ty7dw/Dhw9H1apV4eTkhF69euHq1asACi5OO2rUKGRkZEAQBAiCoIlrx44daNGiBWrXrq1pq7AXas+ePWjYsCEcHBzQrVs3JCUlaeosWrQILVu2xIYNG/DCCy+gcuXKGD9+PPLy8rBixQp4eHjAzc0NS5cu1YozIyMDY8eOhZubG5ydnfHyyy/j7NmzUnYzACA3NxcTJ06Ei4sLqlevjvnz56Pw4h6dOnXCp59+iujoaAiCgE6dOgEArK2t0bt3b2zdulXy65kjyclS48aN8fjxY0PEQkRESpKfV9CjhOKuivVPWdgcgw3Jbdq0CZUqVcKJEyewYsUKLFmyBBEREVp1FixYgEGDBuHs2bN466238MYbb+Dy5csltjlr1iwcOnQIu3fvRnh4OCIjIxEbG6tVZ+TIkTh16hT27t2LmJgYiKKI3r17IycnB0FBQVi5ciWcnZ2RnJyM5ORkzJw5EwAQHR2tdRJUoaysLCxduhSbNm3C0aNHkZmZiddff12rTkJCAn799VeEhYVh69at2LBhA/r06YNbt24hKioKy5cvx/z583H8+HEAgCiK6NOnD1JSUrB//37ExsbC398fXbp0wd27dyXvZxsbG5w4cQKrVq3C559/jm+//RYAsGvXLowZMwZqtRrJycla85TatGmDw4cPS3otsyVKdPLkSfHll18WIyMjxbS0NDEjI0PrVhFlZGSIACrs9hORMj1+/Fi8dOmS+Pjx47I1cC1aFBc6l367Fi1v4KIoduzYUXzppZe0ylq3bi3Onj1bcx+AOG7cOK06bdu2FcePH19smw8ePBDt7OzEbdu2acrS09NFR0dHccqUKaIoiuKVK1dEAOLRo0c1ddLS0kRHR0dxx44doiiKYmhoqKhSqYq036JFC3HJkiVaZaGhoSIA8fjx45qyy5cviwDEEydOiKIoigsXLhSdnJzEzMxMTZ0ePXqIdevWFfPy8jRljRo1EkNCQkRRFMWDBw+Kzs7O4pMnT7Rer169euLatWuL3f7idOzYUWzSpImYn5+vKZs9e7bYpEkTzf0pU6aIHTt2LPLcn376SbSystKKUYl0fQ70PX5LnrPk4uKCjIwMvPzyy88nXRAEAXl5FXfSHxGRRXn4l7z1JGrevLnWfU9PT6SmpmqVqdXqIvfj4uKKbS8hIQFPnz7Vek61atXQqFEjzf3Lly/DxsYGbdu21ZRVr14djRo10tljBQCPHz8u9oLFNjY2Wj1OjRs3houLCy5fvow2bdoAAOrWras1Kdzd3R3W1tawsrLSKivc/tjYWDx8+BDVq1cvEkNCQoLOOJ8XGBioNf9YrVbj008/RV5eHqytrUt8nqOjI/Lz85GdnQ1HR0dJr2luJCdLb775Juzs7PD9999zgjcRkSWr7C5vPYlsbW217guCoNfZVyUdl0SxuOFE/eoUdgjo4urqinv37ukd07NlxW2rru3Pz8+Hp6cnIiMji7Rb0pl6crt79y6cnJwsPlECypAsXbhwAWfOnNHKxImIyAJ5BRWc9ZaZjOLnLQkFj3sFGTsyjePHj2P48OFa9/38/IqtW79+fdja2uL48eN44YUXABRM5r5y5Qo6duwIAPDx8UFubi5OnDiBoKCC7UpPT8eVK1fQpEkTAICdnV2xoyh+fn64dOlSkfLc3FycOnVK04sUHx+P+/fvo3HjxmXebn9/f6SkpMDGxgZ169YtczsANPOgnr3foEEDnb1KQEE+4O/vX67XNheSJ3i3atVKaxY/ERFZKCvrguUBAADP94z8c7/nsoJ6JvLDDz9gw4YNuHLlChYuXIiTJ09i4sSJmse7dOmCr776CgBQuXJljB49GrNmzcLBgwdx4cIFjBw5Umuoq0GDBujXrx/GjBmDI0eOaCaO16pVC/369QNQMGT28OFDHDx4EGlpacjKygIA9OjRAzExMUUSKVtbW0yaNAknTpzA6dOnMWrUKAQGBmqSp7Lo2rUr1Go1+vfvjwMHDuD69es4duwY5s+fj1OnTklqKykpCdOnT0d8fDy2bt2KL7/8ElOmTCn1eYcPH0b37t3LuglmRXKyNGnSJEyZMgUbN25EbGwszp07p3UjIiIL4tMXGLIZcPbULneuWVBu4nWWFi9ejG3btqF58+bYtGkTtmzZAh8fH83jCQkJSEtL09z/+OOP0aFDB/Tt2xddu3bFSy+9hICAAK02Q0NDERAQgFdeeQVqtRqiKGL//v2aYbGgoCCMGzcOwcHBqFGjBlasWAEA6N27N2xtbfHbb79ptefk5ITZs2dj6NChUKvVcHR0xLZt28q13YIgYP/+/ejQoQP+9a9/oWHDhnj99ddx/fp1uLsXDItev34dgiAUO1T3rOHDh+Px48do06YNJkyYgEmTJmHs2LE6n3P79m0cO3YMo0aNKtd2mAtB1GcQ9xnPZuCaRgShQk/wzszMhEqlQkZGBpydnU0dDhERAODJkydITEyEt7d3sROPJcnPA24cK5jMXdm9YOjNhD1KQMGxZ/fu3ejfv79J43jW6tWr8dNPP+HAgQMACtZZmjp1Ku7fv2/0WCIjIzFgwABcu3YNVatWlbXtWbNmISMjA+vWrZO1XUPQ9TnQ9/gtec5SYmKi9EiJiMi8WVkD3u1NHYXijR07Fvfu3cODBw9MfsmTsLAwvPfee7InSgDg5uamWV+qIpCULOXk5KBz5874+eeftbo5iYiIqGCZgHnz5pk6DADAsmXLDNb2rFmzDNa2Ekmas2Rra4vs7GwuF0BERCYniqKihuCKM3LkSJMMwZG8yjTBe/ny5cjNzTVEPERERESKInnO0okTJ3Dw4EGEh4ejWbNmqFSpktbjz143hoiITE/ieTxEFkWO93+ZLncyaNCgcr8wEREZVuGp7llZWRVilWWi4hSug/X8iuhSSE6WQkNDy/xiRERkPNbW1nBxcdFcT8zJyYlzTqnCEEURWVlZSE1NhYuLS6krkusiOVkq9PfffyM+Ph6CIKBhw4aoUaNGmYMgIiLD8PDwAIAiF6AlqihcXFw0n4OykpwsPXr0CJMmTcLmzZs1F/SztrbG8OHD8eWXX8LJyalcARERkXwEQYCnpyfc3NyQk5Nj6nCIjMrW1rZcPUqFJCdL06dPR1RUFPbt24d27doBAI4cOYLJkydjxowZWLNmTbmDIiIieVlbW8ty0CCqiCRf7sTV1RU7d+5Ep06dtMoPHTqEIUOG4O+//5YzPrPAy50QERGZH32P35LXWcrKytJcpO9Zbm5umhnnRERERJZCcrKkVquxcOFCPHnyRFP2+PFjLF68GGq1WtbgiIiIiExN8pylL774Aj179kTt2rXRokULCIKAuLg4ODg4aK6yTERERGQpJPcs+fr64urVqwgJCUHLli3RvHlzLFu2DFevXkXTpk0NEaOW1atXw9vbGw4ODggICMDhw4d11o+KikJAQAAcHBzw4osv4uuvvy5S58cff4SPjw/s7e3h4+OD3bt3Gyp8IiIiMjNlWmfJ0dERY8aMkTuWUm3fvh1Tp07F6tWr0a5dO6xduxa9evXCpUuX8MILLxSpn5iYiN69e2PMmDH47rvvcPToUbzzzjuoUaOGZhXymJgYBAcH44MPPsCAAQOwe/duDBkyBEeOHEHbtm2NvYlERESkMJLPhgOAK1euIDIyEqmpqZq1lgq9//77sgX3vLZt28Lf319reYImTZqgf//+CAkJKVJ/9uzZ2Lt3Ly5fvqwpGzduHM6ePYuYmBgAQHBwMDIzM/Hrr79q6vTs2RNVq1bF1q1b9YqLZ8MRERGZH32P35J7lr755huMHz8erq6u8PDw0Fo6XxAEgyVLT58+RWxsLObMmaNV3r17dxw7dqzY58TExKB79+5aZT169MD69euRk5MDW1tbxMTEYNq0aUXqrFy5ssRYsrOzkZ2drbmfmZkpcWuIiIjIXEhOlj788EMsXboUs2fPNkQ8JUpLS0NeXl6RZQvc3d2RkpJS7HNSUlKKrZ+bm4u0tDR4enqWWKekNgEgJCQEixcvLuOWEBERkTmRPMH73r17GDx4sCFi0cvzF4EURVHnhSGLq/98udQ2586di4yMDM0tKSlJ7/iJiIjIvEhOlgYPHozw8HBDxKKTq6srrK2ti/T4pKamFrtIJlBwAcni6tvY2KB69eo665TUJgDY29vD2dlZ60ZERESWSfIwXP369bFgwQIcP34czZo1g62trdbjkydPli24Z9nZ2SEgIAAREREYMGCApjwiIgL9+vUr9jlqtRr79u3TKgsPD0erVq00cavVakRERGjNWwoPD0dQUJABtoKIiIjMjeSz4by9vUtuTBBw7dq1cgdVku3bt2PYsGH4+uuvoVarsW7dOnzzzTe4ePEivLy8MHfuXNy+fRubN28GULB0gK+vL/79739jzJgxiImJwbhx47B161bN0gHHjh1Dhw4dsHTpUvTr1w8//fQT5s+fL2npAJ4NR0REZH4MdjZcYmJiuQIrj+DgYKSnp2PJkiVITk6Gr68v9u/fDy8vLwBAcnIybt68qanv7e2N/fv3Y9q0afjPf/6DmjVrYtWqVZpECQCCgoKwbds2zJ8/HwsWLEC9evWwfft2rrFEREREAMq4zhJpY88SERGR+dH3+C15gjcRERFRRcJkiYiIiEgHJktEREREOuiVLA0cOFBzSY/NmzdrXeqDiIiIyJLplSz9/PPPePToEQBg1KhRyMjIMGhQREREREqh19IBjRs3xty5c9G5c2eIoogdO3aUOGt8+PDhsgZIREREZEp6LR1w7NgxTJ8+HQkJCbh79y6qVKlS7LXTBEHA3bt3DRKoknHpACIiIvOj7/Fb8jpLVlZWSElJgZubW7mDtBRMloiIiMyPwdZZSkxMRI0aNcoVHBEREZG5kHy5Ey8vL9y/fx/r16/H5cuXIQgCmjRpgtGjR0OlUhkiRiIiIiKTkdyzdOrUKdSrVw+ff/457t69i7S0NHz++eeoV68eTp8+bYgYiYiIiExG8pyl9u3bo379+vjmm29gY1PQMZWbm4u3334b165dQ3R0tEECVTLOWSIiIjI/Bpvg7ejoiDNnzqBx48Za5ZcuXUKrVq2QlZVVtojNGJMlIiIi82OwCd7Ozs64efNmkfKkpCRUqVJFanNEREREiiY5WQoODsbo0aOxfft2JCUl4datW9i2bRvefvttvPHGG4aIkYiIiMhkJJ8N98knn0AQBAwfPhy5ubkAAFtbW4wfPx7Lli2TPUAiIiIiU5I8Z6lQVlYWEhISIIoi6tevDycnJ7ljMxucs0RERGR+9D1+S+5ZKuTk5IRmzZqV9elEREREZkHynCUiIiKiioTJEhEREZEOTJaIiIiIdJCcLEVHR2vOgntWbm5uhVy9m4iIiCyb5GSpc+fOuHv3bpHyjIwMdO7cWZagiIiIiJRCcrIkiiIEQShSnp6ejkqVKskSFBEREZFS6L10wMCBAwEAgiBg5MiRsLe31zyWl5eHc+fOISgoSP4IiYiIiExI72RJpVIBKOhZqlKlChwdHTWP2dnZITAwEGPGjJE/QiIiIiIT0jtZCg0NBQDUrVsXs2bNqtArdhMREVHFIXnO0vDhw3H79u0i5VevXsX169fliImIiIhIMSQnSyNHjsSxY8eKlJ84cQIjR46UIyYiIiIixZCcLJ05cwbt2rUrUh4YGIi4uDg5YiIiIiJSDMnJkiAIePDgQZHyjIwM5OXlyRIUERERkVJITpbat2+PkJAQrcQoLy8PISEheOmll2QNjoiIiMjU9D4brtCKFSvQoUMHNGrUCO3btwcAHD58GJmZmfjf//4ne4BEREREpiS5Z8nHxwfnzp3DkCFDkJqaigcPHmD48OH4448/4Ovra4gYiYiIiExGEEVRNHUQ5i4zMxMqlQoZGRlwdnY2dThERESkB32P35KH4aKjo3U+3qFDB6lNEhERESmW5GSpU6dORcqevbAuz4gjIiIiSyJ5ztK9e/e0bqmpqQgLC0Pr1q0RHh5uiBiJiIiITEZyz1LhBXWf1a1bN9jb22PatGmIjY2VJTAiIiIiJZDcs1SSGjVqID4+Xq7mirh37x6GDRsGlUoFlUqFYcOG4f79+yXWz8nJwezZs9GsWTNUqlQJNWvWxPDhw3Hnzh2tep06dYIgCFq3119/3WDbQUREROZFcs/SuXPntO6Loojk5GQsW7YMLVq0kC2w5w0dOhS3bt1CWFgYAGDs2LEYNmwY9u3bV2z9rKwsnD59GgsWLECLFi1w7949TJ06FX379sWpU6e06o4ZMwZLlizR3Hd0dDTYdhAREZF5kZwstWzZEoIg4PkVBwIDA7FhwwbZAnvW5cuXERYWhuPHj6Nt27YAgG+++QZqtRrx8fFo1KhRkeeoVCpERERolX355Zdo06YNbt68iRdeeEFT7uTkBA8PD4PETkREROZNcrKUmJiodd/Kygo1atSAg4ODbEE9LyYmBiqVSpMoAQXJmUqlwrFjx4pNloqTkZEBQRDg4uKiVb5lyxZ89913cHd3R69evbBw4UJUqVKlxHays7ORnZ2tuZ+ZmSltg4iIiMhsSE6WvLy8DBGHTikpKXBzcytS7ubmhpSUFL3aePLkCebMmYOhQ4dqLTz15ptvwtvbGx4eHrhw4QLmzp2Ls2fPFumVelZISAgWL14sfUOIiIjI7OiVLK1atUrvBidPnqx33UWLFpWadPz+++8AtNdyKiSKYrHlz8vJycHrr7+O/Px8rF69WuuxMWPGaP7v6+uLBg0aoFWrVjh9+jT8/f2LbW/u3LmYPn265n5mZibq1KlTahxERERkfvRKlj7//HOt+3///TeysrI0w1n379+Hk5MT3NzcJCVLEydOLPXMs7p16+LcuXP466+/ijz2999/w93dXefzc3JyMGTIECQmJuJ///tfqZcj8ff3h62tLa5evVpismRvbw97e3ud7RAREZFl0CtZenae0vfff4/Vq1dj/fr1mrlC8fHxGDNmDP79739LenFXV1e4urqWWk+tViMjIwMnT55EmzZtAAAnTpxARkYGgoKCSnxeYaJ09epVHDp0CNWrVy/1tS5evIicnBx4enrqvyFERERksSRfSLdevXrYuXMn/Pz8tMpjY2Px2muvFZkALpdevXrhzp07WLt2LYCCpQO8vLy0lg5o3LgxQkJCMGDAAOTm5mLQoEE4ffo0fv75Z60eqGrVqsHOzg4JCQnYsmULevfuDVdXV1y6dAkzZsyAo6Mjfv/9d1hbW+sVGy+kS0REZH70PX5LXpQyOTkZOTk5Rcrz8vKKHSqTy5YtW9CsWTN0794d3bt3R/PmzfHf//5Xq058fDwyMjIAALdu3cLevXtx69YttGzZEp6enprbsWPHAAB2dnY4ePAgevTogUaNGmHy5Mno3r07fvvtN70TJSIiIrJsknuWXn31Vdy8eRPr169HQEAABEHAqVOnMGbMGNSpUwd79+41VKyKxZ4lIiIi82OwnqUNGzagVq1aaNOmDRwcHGBvb4+2bdvC09MT3377bbmCJiIiIlIayess1ahRA/v378eVK1dw+fJlAECTJk3QsGFD2YMjIiIiMjXJyVKhhg0bokGDBgCKXwOJiIiIyBJIHoYDgM2bN6NZs2ZwdHSEo6NjsZOtiYiIiCyB5J6lzz77DAsWLMDEiRPRrl07iKKIo0ePYty4cUhLS8O0adMMEScRERGRSUg+G87b2xuLFy/G8OHDtco3bdqERYsWGWydJSXj2XBERETmx6DrLBW3anZQUBCSk5OlNkdERESkaJKTpfr162PHjh1Fyrdv366Z8E1ERERkKSTPWVq8eDGCg4MRHR2Ndu3aQRAEHDlyBAcPHiw2iSIiIiIyZ5J7lgYNGoSTJ0/C1dUVe/bswa5du+Dq6oqTJ09iwIABhoiRiIiIyGQk9Szl5ORg7NixWLBgAb777jtDxURERESkGJJ6lmxtbbF7925DxUJERESkOJKH4QYMGIA9e/YYIBQiIiIi5ZE8wbt+/fr44IMPcOzYMQQEBKBSpUpaj0+ePFm24IiIiIhMrUyLUpbYmCDg2rVr5Q7K3HBRSiIiIvOj7/Fbcs9SRVyhm0ix8vOAG8eAh38Bld0BryDAytrUURERWRTJydKzCjulBEGQJRgikuDSXiBsNpB55//LnGsCPZcDPn1NFxcRkYWRPMEbANavXw9fX184ODjAwcEBvr6++Pbbb+WOjYhKcmkvsGO4dqIEAJnJBeWX9pomLiIiCyS5Z2nBggX4/PPPMWnSJKjVagBATEwMpk2bhuvXr+PDDz+UPUiicrG0oar8vIIeJRQ33VAEIABhc4DGfcx7O4mIFELyBG9XV1d8+eWXeOONN7TKt27dikmTJiEtLU3WAM0BJ3grmCUOVSUeBja9Unq9ET8D3u0NHw8RkZnS9/gteRguLy8PrVq1KlIeEBCA3Nxcqc0RGY6lDlU9/EveekREpJPkZOmtt97CmjVripSvW7cOb775pixBEZVbqUNVKBiqys8zZlTyqOwubz0iItKpTGfDrV+/HuHh4QgMDAQAHD9+HElJSRg+fDimT5+uqffZZ5/JEyWRVDeOFe1R0iICmbcL6pnbUJVXUMFQYmYyik8GhYLHvYKMHRkRkUWSnCxduHAB/v7+AICEhAQAQI0aNVCjRg1cuHBBU4/LCZBJGWqoSgmTxa2sC+Zc7RgOQIB2wvTP567nMk7uJiKSieRk6dChQ4aIgyyFEpIJwDBDVUqaLO7TFxiyuYR4lpnv5HUiIgUq16KURFqUlEzIPVRVOFn8+bYKJ4sP2WyahKlxH2Ukp0REFqxMi1ISFaG0M88Kh6oAaIamNCQOVSl5sriVdcGcq2avFfzLRImISHZMlqj8lJpMFA5VOXtqlzvXlNYTJGWyOBERWRwOw1H5GerMMznmP8kxVMV1jYhMRynzIKlCk5Qs5eTkYOzYsViwYAFefPFFQ8VE5sYQyYSc858Kh6rKiusaEZmGkuZBUoUmaRjO1tYWu3fvNlQsZK7Kkkzk5xVctuP8zoJ/nx2iU9r8p8LJ4kXmPhUSAOdaXNeISE5K+x6gCk3ynKUBAwZgz549BgiFzJbUZOLSXmClb8H1zX4cXfDvSt+CciXOf5JzsjgRlU6J3wNUoUmes1S/fn188MEHOHbsGAICAlCpUiWtxydPnixbcGQmpCySWNop+J3mKnPlba5rRGQ8lrwCP5klQRTF4lL3Enl7e5fcmCDg2rVr5Q7K3Oh71WKLV+z8glr/n0zk5xX0IJX4JSgAji7A43ulv9ag9QWnyxsbJ5sSGd75nQW9zqUx1fcAWQx9j9+Se5YSExPLFRhZsNLOPNPn16I+iRJgusnU5Z0sTkSl40kVpDBlXjrg6dOnSExMRL169WBjwxUI6B+6kgl9z4ZzrAo8vg9eJJaoguLFoklhJE/wzsrKwujRo+Hk5ISmTZvi5s2bAArmKi1btkz2AMmC6PsrsO34f/7DydREFRJPqiCFkZwszZ07F2fPnkVkZCQcHBw05V27dsX27dtlDY4sjL5nzXWYKc/K20qma+kEIpJvBX4p+LmkEkgeP9uzZw+2b9+OwMBACML/H/R8fHyQkJAga3BkYaScNWfOF4ktbRI4F9ozPk7MN0/G/B7g59L4zOhzKTlZ+vvvv+Hm5lak/NGjR1rJE1GxpJyCb46TqUv7wi1t6QRL6TkzJianls0Y3wP8XBqfmX0uJQ/DtW7dGr/88ovmfmGC9M0330CtVssX2XPu3buHYcOGQaVSQaVSYdiwYbh//77O54wcORKCIGjdAgMDtepkZ2dj0qRJcHV1RaVKldC3b1/cunXLYNtBKPggTL0AjPi54NTfET8DU88r8gMiSWkrDl/Yw4X2Csk13KFrgdPCx7kKNOnCBTCNzww/l5J7lkJCQtCzZ09cunQJubm5+OKLL3Dx4kXExMQgKirKEDECAIYOHYpbt24hLCwMADB27FgMGzYM+/bt0/m8nj17IjQ0VHPfzs5O6/GpU6di37592LZtG6pXr44ZM2bglVdeQWxsLKytldkdaBHMsddIl1K/cAVg/wwgK01HIxVkoT25flGW1hvw2kYgfG7RxwFo/iZhcwqGeRTa9U9GwAUwjUuf70oFfi4l9ywFBQXh6NGjyMrKQr169RAeHg53d3fExMQgICDAEDHi8uXLCAsLw7fffgu1Wg21Wo1vvvkGP//8M+Lj43U+197eHh4eHppbtWrVNI9lZGRg/fr1+PTTT9G1a1f4+fnhu+++w/nz5/Hbb78ZZFvIQunzhaszUXqGlAsOmxu5flHq0xuwf4b+B0G5caKw+TDEhcCpZFKSUwUp0wJJzZo1w6ZNm+SOpUQxMTFQqVRo27atpiwwMBAqlQrHjh1Do0aNSnxuZGQk3Nzc4OLigo4dO2Lp0qWaOVexsbHIyclB9+7dNfVr1qwJX19fHDt2DD169Ci2zezsbGRnZ2vuZ2ZmlncTydzJ+UVqqQvtleUXZUnzkZScnJrZXIwKz1ALYJrR5GWjMtPktEzJUn5+Pv7880+kpqYiPz9f67EOHTrIEtizUlJSip1U7ubmhpSUlBKf16tXLwwePBheXl5ITEzEggUL8PLLLyM2Nhb29vZISUmBnZ0dqlatqvU8d3d3ne2GhIRg8eLFZd8gsjz6fpE6uQJZ6aiQC+1JHe7QlXTkPZUvLjmTU1NMFOZBuXwMsQAmE+aSmenq7JKTpePHj2Po0KG4ceMGnr+snCAIyMvTv7t50aJFpSYdv//+u6bt54miqPMMvODgYM3/fX190apVK3h5eeGXX37BwIEDS3xeae3OnTsX06dP19zPzMxEnTp1dG6HwfCLUhn0/cLt8RHww0iUunSCJZLyi1KfCy7rw5jJqSnmYvCgXH5SljTRB8+s081MV2eXnCyNGzcOrVq1wi+//AJPT89yLRcwceJEvP766zrr1K1bF+fOncNffxX9ov3777/h7q5/9unp6QkvLy9cvXoVAODh4YGnT5/i3r17Wr1LqampCAoq+Q9lb28Pe3t7vV/XYPhFqZxkUd8vXJ++gKDn0gmWRkrv20/joTPpiN2ovOTU2BOFeVCWj5QlTXQx08nLkpXne1fu5NRIJCdLV69exc6dO1G/fv1yv7irqytcXV1LradWq5GRkYGTJ0+iTZs2AIATJ04gIyNDZ1LzvPT0dCQlJcHTs2BF2ICAANja2iIiIgJDhgwBACQnJ+PChQtYsWJFGbbIiPhFqbxkUd8vXHNecLM89P1FKQilJx0P7gCd3gMiQ6CY5NSYczEqykHZmOT4XFaEM+vk+N6VKzk1IsnJUtu2bfHnn3/Kkizpq0mTJujZsyfGjBmDtWvXAihYOuCVV17RmtzduHFjhISEYMCAAXj48CEWLVqEQYMGwdPTE9evX8d7770HV1dXDBgwAACgUqkwevRozJgxA9WrV0e1atUwc+ZMNGvWDF27djXa9knGL0rlJov6fuFa2tIJ+tD3F+Wjv/Vrr3o9ZSWnxpyLUREOyqZQ3s+lmU5e1puc37tm9qNRcrI0adIkzJgxAykpKWjWrBlsbW21Hm/evLlswT1ry5YtmDx5subMtb59++Krr77SqhMfH4+MjAwAgLW1Nc6fP4/Nmzfj/v378PT0ROfOnbF9+3ZUqVJF85zPP/8cNjY2GDJkCB4/fowuXbpg48aNyl5jqaJ/USo9WZQrETL2EKMxXk+fX5SJh/Vrq7J7wX5WSnJqzLkYln5QNldmOnlZL4b43jWjH42C+Pws7VJYWRVdmkkQBM2kaCkTvC1FZmYmVCoVMjIy4OzsbPgXPL+zYLXi0gxaDzR7Tb7XVcr8oMTDBSs1l2bEz2bzQSzC2EOMxn49Xe+l/LyCVbhLSzqmnlfer1DNL2+g2J4zuXo8K8JnwByZ83u3NBb6ntP3+C25ZykxMbFcgZEMTPHrRUnzgyz9V7WxhxhNMaSp6xelmU4ABWC8uRhmekaRxTPEe1cpP1It/Xu3FJKTJS8vL0PEQc/T9QEx9hel0uYHsatbviFGpQ5pmuEEUA1jzMUoy0FZKQddUzHW9sv53lXSj1RL/t7Vg+RhOAC4cuUKIiMji12U8v3335ctOHMh+zCcPh8QY3X3a7qVS5ojZYJuZXZ1y9fVrfSu9Yp+gC9Nsd8VtYoelJV00DUFU2x/ed+7Jf1Ilfs7Xl8W+r1rsGG4b775BuPHj4erqys8PDy01lkSBKFCJkuy0rcXR8qvl/J8aJU4mZxd3fJ1dUt9PWPvJzOaAGoS+vRiSekZVsrnQE6m6hnX571b0v5WYo+vOQ+Py0BysvThhx9i6dKlmD17tiHiqdikfkD0/aLU5xdVSR9apY5Ts6vb+K9X3veS0plr3LoOylK+U/74RTmfA6nMKekopOvz5FhV2o9UcxxiNDOSk6V79+5h8ODBhoiFytKLo+uLUt9fVLo+tEoep5ZjbojS5mMZez6avq+Xlf7PStjleC8p+YtUqXGX9yCo73dK9Cf/LPCpkM+BFHImHcZS2vdO4Hj92im8NJAx37tmtj6SXIquA1CKwYMHIzw83BCxkJy9OKX+okLBL6qLewo+nM9/oRR+aB+lF3zwIDzfyD+EgjkSpjrrpjBZbPZawb9Sh9702Uf5RlwOo7CrG0DRfW6Arm59Xq/7R8CBuSj3e+nSXnlillvhgUtpcV/aWzBHZNMrBUuFbHql4L6UePT9TjmxBor6HOirtL9d/H792jFmz7g+3zvndujXVnqCad675fneNVOSe5bq16+PBQsW4Pjx48UuSjl58mTZgqtw5OzF0fcX5S8zoLOLOvw9oEeIZV78VYnzsQDjd3WX9nr6/jov7b2kxFXllTpMI1ePp77fKY/v6XhQoYvc6vO30zfpMGbPuD7fO1lppV8EuooncHpjCY8r+DNnpiQnS+vWrUPlypURFRWFqKgorccEQWCyVB5yDsHo+0spK03Hg/98STpVt8xxaqXOxwKM39Wt6/XO79SvDX3eS0o74CoxYZYzgdPnO8XRpZRk6R9KWz9HrqRD6rB2eYdG9d2PzYcAx9egxB+pASOByI90NKDQz5yZ4qKUSiLn2QZy/lJ6+FdBd6uljVMreT4WYPwzwUp6PbnfS0qixIRZzgROn++UtuNLOej+Q2nr58iVdEjpGZdjfpC++7FRb+AFdck/UvOe6teOqT5z5nrCRAkkJ0tkYHINwejzi9Kpeim9Af8o/HBb2mncXAVZP4Z4LylFWRJmQx8E5E7gSvtOadynYDjH3D4HciUd+n6nyjU0KuV7x8q65B+pUq6haGxKPWGiHPRKlqZPn44PPvgAlSpVwvTp03XW/eyzz2QJrEKTYwhGn1+UvT8Fwuea35ekXCr4uiF6s+T3ktSE2RgHAUP0eJb2nWKOnwO5kg59yDk0KvV7p6QfqUr9sae0M4xlotfZcGfOnEFOTo7m/yXd4uLiDBlrxSLH2QaFvyidPbXLnWsWlPv2N+6ZV0pU2j4yww91sfLzCn6Jnt9Z8K/UM5ss9b0k5exDY501V3gQlPsMVF3fKeb4OZB65mh5vlOlDI3qQ479bewzZ/WhxDOMZVKmy52QNtkvdyK30oYN9L1kgiWzsPF1LXL2hljqe6m0uI192R9jXc7oeeb4OTDGe+78zoLlG0ozaH1BMqYvOfa3kj5zSr98UjH0PX4zWZKB4pMlfZjjlySVzhTXlzLX95KuuE1xEFDSQVAqY78HDP16Sk8C9Nl+Y/xNDJVUGpDBrg1HFsrSJm+T6dYQMtf3kq64TXHWnLmulGyKy+IY+j2n1PlBhUrbfim9y+X5uyj9DONyYLJEZKmUuIaQuTLVQcDcEk85LrGkxF4zcz4ZRMqE6/L+XZSeVJaD5MudEJGZUOIaQubKUJOuLYlcl1hS6mVxzHESvJQJ13KcwKDESecyYbJEZKksuEvc6Cz4ICAbWS6xBGWfLeXTF5h6oWBu0qD1Bf9OPa/MRAnQ/2+SeFi+s9jMManUA4fhiCyVBXeJm4Tc1+wz14nwJZHzEktKHho2p6FRff8mN47IO2RvrvPtdGCyRGSpzHmehVLJdRAwtzk7zyopybPky+KYK33/JvqeEy/l72JOSaUemCwRWTK5e0Oo/AcBc17hWFeS17iP5V4Wx1zp27vs3R44/HHp7Zni76KQHliusyQDi1hniSybQr5wKjxjL24pJ33W7AJ0L6b52kb9LoujxO03V/oscNq4zz/vS4X9XYzQA6vv8ZsTvIkqAjkun0PlJ/dlM4xF37OqGvexzMvimDN9Jlwr8QQGY11eSE8chiMiMhZzXc5BSpJX2rwuDg0bnz5z7ZT0dzHVgro6MFkiIjIWc13OQWqSV9q8Lgs8W0rx9Jlrp5S/iwIX1GWyRERkLOa6nIMhkjwLO1vKYijh76LAHljOWSIiMhYlzg3RB1cwJ2NSYA8skyUiImMyxxWOzTXJI/OkwOScSwfIgEsHEJFk5ricQ7GnctfixGySnz5LHsjwntP3+M1kSQZMloiowjDHJI/MkxGSc32P35zgTURE+lPCBGCqGJRydh6YLBEREZFSKSQ55wRvIiIiIh2YLBERERHpwGSJiIiISAcmS0REREQ6MFkiIiIi0oHJEhEREZEOTJaIiIiIdGCyRERERKQDkyUiIiIiHbiCtwwKL6+XmZlp4kiIiIhIX4XH7dIuk8tkSQYPHjwAANSpU8fEkRAREZFUDx48gEqlKvFxQSwtnaJS5efn486dO6hSpQoEQZCt3czMTNSpUwdJSUk6r4ZM8uD+Ni7ub+PjPjcu7m/jKsv+FkURDx48QM2aNWFlVfLMJPYsycDKygq1a9c2WPvOzs78oBkR97dxcX8bH/e5cXF/G5fU/a2rR6kQJ3gTERER6cBkiYiIiEgHJksKZm9vj4ULF8Le3t7UoVQI3N/Gxf1tfNznxsX9bVyG3N+c4E1ERESkA3uWiIiIiHRgskRERESkA5MlIiIiIh2YLBERERHpwGRJwVavXg1vb284ODggICAAhw8fNnVIFiE6OhqvvvoqatasCUEQsGfPHq3HRVHEokWLULNmTTg6OqJTp064ePGiaYK1ACEhIWjdujWqVKkCNzc39O/fH/Hx8Vp1uM/ls2bNGjRv3lyzMJ9arcavv/6qeZz72nBCQkIgCAKmTp2qKeP+lteiRYsgCILWzcPDQ/O4ofY3kyWF2r59O6ZOnYp58+bhzJkzaN++PXr16oWbN2+aOjSz9+jRI7Ro0QJfffVVsY+vWLECn332Gb766iv8/vvv8PDwQLdu3TTXACRpoqKiMGHCBBw/fhwRERHIzc1F9+7d8ejRI00d7nP51K5dG8uWLcOpU6dw6tQpvPzyy+jXr5/mgMF9bRi///471q1bh+bNm2uVc3/Lr2nTpkhOTtbczp8/r3nMYPtbJEVq06aNOG7cOK2yxo0bi3PmzDFRRJYJgLh7927N/fz8fNHDw0NctmyZpuzJkyeiSqUSv/76axNEaHlSU1NFAGJUVJQoitznxlC1alXx22+/5b42kAcPHogNGjQQIyIixI4dO4pTpkwRRZHvbUNYuHCh2KJFi2IfM+T+Zs+SAj19+hSxsbHo3r27Vnn37t1x7NgxE0VVMSQmJiIlJUVr39vb26Njx47c9zLJyMgAAFSrVg0A97kh5eXlYdu2bXj06BHUajX3tYFMmDABffr0QdeuXbXKub8N4+rVq6hZsya8vb3x+uuv49q1awAMu795IV0FSktLQ15eHtzd3bXK3d3dkZKSYqKoKobC/Vvcvr9x44YpQrIooihi+vTpeOmll+Dr6wuA+9wQzp8/D7VajSdPnqBy5crYvXs3fHx8NAcM7mv5bNu2DadPn8bvv/9e5DG+t+XXtm1bbN68GQ0bNsRff/2FDz/8EEFBQbh48aJB9zeTJQUTBEHrviiKRcrIMLjvDWPixIk4d+4cjhw5UuQx7nP5NGrUCHFxcbh//z5+/PFHjBgxAlFRUZrHua/lkZSUhClTpiA8PBwODg4l1uP+lk+vXr00/2/WrBnUajXq1auHTZs2ITAwEIBh9jeH4RTI1dUV1tbWRXqRUlNTi2TMJK/Csyq47+U3adIk7N27F4cOHULt2rU15dzn8rOzs0P9+vXRqlUrhISEoEWLFvjiiy+4r2UWGxuL1NRUBAQEwMbGBjY2NoiKisKqVatgY2Oj2afc34ZTqVIlNGvWDFevXjXo+5vJkgLZ2dkhICAAERERWuUREREICgoyUVQVg7e3Nzw8PLT2/dOnTxEVFcV9X0aiKGLixInYtWsX/ve//8Hb21vrce5zwxNFEdnZ2dzXMuvSpQvOnz+PuLg4za1Vq1Z48803ERcXhxdffJH728Cys7Nx+fJleHp6Gvb9Xa7p4WQw27ZtE21tbcX169eLly5dEqdOnSpWqlRJvH79uqlDM3sPHjwQz5w5I545c0YEIH722WfimTNnxBs3boiiKIrLli0TVSqVuGvXLvH8+fPiG2+8IXp6eoqZmZkmjtw8jR8/XlSpVGJkZKSYnJysuWVlZWnqcJ/LZ+7cuWJ0dLSYmJgonjt3TnzvvfdEKysrMTw8XBRF7mtDe/ZsOFHk/pbbjBkzxMjISPHatWvi8ePHxVdeeUWsUqWK5thoqP3NZEnB/vOf/4heXl6inZ2d6O/vrznVmsrn0KFDIoAitxEjRoiiWHD66cKFC0UPDw/R3t5e7NChg3j+/HnTBm3GitvXAMTQ0FBNHe5z+fzrX//SfG/UqFFD7NKliyZREkXua0N7Plni/pZXcHCw6OnpKdra2oo1a9YUBw4cKF68eFHzuKH2tyCKoli+vikiIiIiy8U5S0REREQ6MFkiIiIi0oHJEhEREZEOTJaIiIiIdGCyRERERKQDkyUiIiIiHZgsEREREenAZImIiIhIByZLRGTWIiMjIQgC7t+/b/TXFgQBgiDAxcVFtjY3btyoaXfq1KmytUtEZcdkiYjMRqdOnYokEEFBQUhOToZKpTJJTKGhobhy5Yps7QUHByM5ORlqtVq2NomofGxMHQARUXnY2dnBw8PDZK/v4uICNzc32dpzdHSEo6Mj7OzsZGuTiMqHPUtEZBZGjhyJqKgofPHFF5phquvXrxcZhtu4cSNcXFzw888/o1GjRnBycsJrr72GR48eYdOmTahbty6qVq2KSZMmIS8vT9P+06dP8e6776JWrVqoVKkS2rZti8jISMlxLlq0CC1btsTatWtRp04dODk5YfDgwVrDhJGRkWjTpg0qVaoEFxcXtGvXDjdu3CjnHiIiQ2HPEhGZhS+++AJXrlyBr68vlixZAgCoUaMGrl+/XqRuVlYWVq1ahW3btuHBgwcYOHAgBg4cCBcXF+zfvx/Xrl3DoEGD8NJLLyE4OBgAMGrUKFy/fh3btm1DzZo1sXv3bvTs2RPnz59HgwYNJMX6559/YseOHdi3bx8yMzMxevRoTJgwAVu2bEFubi769++PMWPGYOvWrXj69ClOnjwJQRDKvY+IyDCYLBGRWVCpVLCzs4OTk1Opw245OTlYs2YN6tWrBwB47bXX8N///hd//fUXKleuDB8fH3Tu3BmHDh1CcHAwEhISsHXrVty6dQs1a9YEAMycORNhYWEIDQ3FRx99JCnWJ0+eYNOmTahduzYA4Msvv0SfPn3w6aefws7ODhkZGXjllVc08TVp0kTq7iAiI2KyREQWx8nJSZOIAIC7uzvq1q2LypUra5WlpqYCAE6fPg1RFNGwYUOtdrKzs1G9enXJr//CCy9oEiUAUKvVyM/PR3x8PDp27IiRI0eiR48e6NatG7p27YohQ4bA09NT8usQkXEwWSIii2Nra6t1XxCEYsvy8/MBAPn5+bC2tkZsbCysra216j2bYJVV4RBb4b+hoaGYPHkywsLCsH37dsyfPx8REREIDAws92sRkfyYLBGR2bCzs9OalC0XPz8/5OXlITU1Fe3bty93ezdv3sSdO3c0Q3oxMTGwsrLS6rny8/ODn58f5s6dC7Vaje+//57JEpFC8Ww4IjIbdevWxYkTJ3D9+nWkpaVpeobKq2HDhnjzzTcxfPhw7Nq1C4mJifj999+xfPly7N+/X3J7Dg4OGDFiBM6ePYvDhw9j8uTJGDJkCDw8PJCYmIi5c+ciJiYGN27cQHh4OK5cucJ5S0QKxp4lIjIbM2fOxIgRI+Dj44PHjx8jMTFRtrZDQ0Px4YcfYsaMGbh9+zaqV68OtVqN3r17S26rfv36GDhwIHr37o27d++id+/eWL16NYCC+VR//PEHNm3ahPT0dHh6emLixIn497//Ldu2EJG8BFEURVMHQURkjgRBwO7du9G/f39N2aJFi7Bnzx7ExcWVq+1OnTqhZcuWWLlyZbnaIaLy4zAcEVE5vPHGG1pnvpXXli1bULlyZRw+fFi2NomofDgMR0RURlevXgWAImfQlUffvn3Rtm1bAJD1Ar1EVHYchiMiIiLSgcNwRERERDowWSIiIiLSgckSERERkQ5MloiIiIh0YLJEREREpAOTJSIiIiIdmCwRERER6cBkiYiIiEiH/wPteqzfMNL74QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(pme_dot_nopme, ls='none', marker='o', label=f\"np.dot(pme, nopme)\")\n",
    "plt.plot(pme_dot_bf, ls='none', marker='o', label=f\"np.dot(pme, bf)\")\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel(\"time [ps]\")\n",
    "plt.ylabel(\"inner product of normalized forces [unitless]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f38d6ab-45ca-4ff4-8ef5-a66fc4a36668",
   "metadata": {},
   "source": [
    "here, I am showing the normed inner product of the ligand-ligand only forces at each frame between `PME` and `NOPME` as well as between `PME` and `BF`. While we expect the inner products to be 1 for the former (which is the control), since both forces are being computed with openmm's direct space PME, this is not true for the dot between direct space and the manual bond force. in fact, they always point away from each other. this is confusing to me since the std dev of the energy discrepancies is rather low..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edcb427c-f82f-4a42-bf9a-9559e88512f8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5aeff59d-b285-4c47-b07a-a6df382c038d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "113b0473-8551-469a-b6f5-3b67e16b0d71",
   "metadata": {},
   "outputs": [],
   "source": [
    "base_energy = outs[0][0][-1]\n",
    "test_energies = outs[1]\n",
    "all_energies = [q - base_energy for q in test_energies]\n",
    "total_inter_energy = np.sum(all_energies)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "71f597c2-6f33-4fd6-a731-2c148e9a8862",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-140.01190756703727"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_inter_energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "efabae8a-be1f-4da5-bc0b-7905a89193b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# determine energy discrepancy...\n",
    "total_nb_energy = outs[0][0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "de5511c0-6a0f-4d71-8182-bf2d4b7dc5f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "total_steric_energy = outs[0][0][1]\n",
    "env_env_elec_energy = outs[0][0][2]\n",
    "ligand_ligand_elec_energy_dir = outs[0][0][3]\n",
    "\n",
    "discrepancy = total_nb_energy - (total_steric_energy + env_env_elec_energy + ligand_ligand_elec_energy_dir + total_inter_energy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "632a14a5-5703-41c9-b8a5-6a5d1307fe6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-229.9825008437474"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "discrepancy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2aace600-4751-48b9-9c24-30f169a7e81f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0\n",
      "iter: 1\n",
      "iter: 2\n",
      "iter: 3\n",
      "iter: 4\n",
      "iter: 5\n",
      "iter: 6\n",
      "iter: 7\n",
      "iter: 8\n",
      "iter: 9\n"
     ]
    }
   ],
   "source": [
    "out = run(\n",
    "    steps_per_collection=250, # number of md steps to run before collecting energies\n",
    "    num_collections=10, # number of energy collections to do\n",
    "    run_system=run_sys, # system that will run `openmm.integrators.LangevinMiddleIntegrator`\n",
    "    collect_system=mod_sys, # returned system of `mod_pme_system`\n",
    "    ligand_indices=ligand_indices, # ligand indices\n",
    "    init_positions = out_posits, # initial positions\n",
    "    init_box_vectors=out_box_vectors,\n",
    "    temperature = 300. * unit.kelvin,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "886e1cc4-54ec-4bed-a0fa-d5701c5f3e7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def energy_match_analysis(run_out: typing.List) -> np.array:\n",
    "    \"\"\"with an input from `run`, evaluate the discrepancy between the original energy and the separated energies\"\"\"\n",
    "    # iterate over all iters\n",
    "    energy_discrepancies = []\n",
    "    for entry in run_out:\n",
    "        tup1, by_particle_energies = entry # tup1 is separated force groups, tup2 is all lig-env interactions by particle\n",
    "        snapshot_nb_energy = tup1[0] # original nbf energy\n",
    "        snapshot_exc_energy = np.array(tup1[1:-1]) # lig-lig, env-env\n",
    "        #print(snapshot_exc_energy)\n",
    "        snapshot_ref_lig_env_energy = tup1[-1] # lig-env energy + env-env energy by particle\n",
    "        offset_by_particle_energies = np.array(by_particle_energies) - snapshot_ref_lig_env_energy # has env-env energies removed\n",
    "        full_sep_energy = np.sum(offset_by_particle_energies) + np.sum(snapshot_exc_energy)\n",
    "        energy_discrepancies.append(full_sep_energy - snapshot_nb_energy)\n",
    "    return np.array(energy_discrepancies)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "bc7e4f3e-d307-406b-951e-e5d7f94750bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "q = energy_match_analysis(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "197de13e-0f05-4cec-b998-4bbfcc3e5d65",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-128.09372108, -128.82731542, -129.56294307, -129.56922436,\n",
       "       -130.11869323, -130.29133159, -131.23097851, -131.57614752,\n",
       "       -131.90893278, -132.48046269, -132.41383535, -132.86862174,\n",
       "       -132.91190276, -133.85230741, -134.24219298, -134.18044361,\n",
       "       -134.79366242, -135.84514309, -136.36224462, -137.07671302,\n",
       "       -137.55073841, -138.32757615, -139.48254176, -139.69230245,\n",
       "       -140.19876722, -140.07589572, -140.55498869, -141.18087326,\n",
       "       -141.20081652, -142.23297459, -142.45191962, -142.97038018,\n",
       "       -143.1502955 , -143.35359445, -144.09511801, -144.42291888,\n",
       "       -144.98997948, -145.59287915, -145.81048578, -145.92558096,\n",
       "       -145.61312798, -145.75511062, -145.73690406, -145.30939804,\n",
       "       -145.05250259, -146.15942206, -146.53306204, -146.53522747,\n",
       "       -146.13986057, -145.54186576, -145.32443747, -144.74769438,\n",
       "       -144.75954383, -144.87437309, -145.9056543 , -146.32937424,\n",
       "       -146.62590005, -146.62904132, -146.45940026, -145.9883448 ,\n",
       "       -145.64371925, -145.85984266, -146.00571785, -145.9198566 ,\n",
       "       -145.7632679 , -145.72787951, -145.8100766 , -145.91668789,\n",
       "       -145.90436579, -145.70854142, -145.96681272, -145.65162291,\n",
       "       -145.45638196, -145.43282987, -145.62162645, -145.16371012,\n",
       "       -145.34875445, -144.99870465, -145.23782573, -145.21738382,\n",
       "       -145.46950065, -145.45658255, -145.34931687, -145.58653287,\n",
       "       -145.62678845, -145.71432302, -145.33796312, -145.61174403,\n",
       "       -145.12266477, -145.58704058, -145.83690876, -144.86262623,\n",
       "       -145.10749303, -145.36072188, -145.24517354, -145.46799635,\n",
       "       -145.65125739, -145.53763577, -144.55052666, -144.30191074])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "8d5c4aed-240e-44e8-b70f-b341bd060a38",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "59105bec-85e9-47dc-a66e-506c6458c401",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f872ec96950>]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkEAAAGdCAYAAAAVEKdkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABchklEQVR4nO3dd3hUVf4G8Hdmkkz6pJFKGqH30FIAA6KIC8IuLgpIgKUJilLWRbEg8JNFZBd3baAUg0sQV4oiYlQwIEhCQgkEAqGlV9JmUmeSzP39ETKSTYdM7iTzfp7nPvvM3DP3fucuMi/nnHuuRBAEAURERERGRip2AURERERiYAgiIiIio8QQREREREaJIYiIiIiMEkMQERERGSWGICIiIjJKDEFERERklBiCiIiIyCiZiF2AodJqtcjMzISNjQ0kEonY5RAREVELCIKA4uJiuLu7Qyptuq+HIagRmZmZ8PT0FLsMIiIiegBpaWno2rVrk20YghphY2MDoOYi2trailwNERERtYRKpYKnp6fud7wpeg1BGzZswPfff4+4uDiYmZmhqKiozv5Lly7h3XffxenTp5GXlwcfHx8sXrwYy5Yt07VZu3Yt1q1bV+/YlpaWKC0tbfTcPj4+SElJqfPeq6++infffbdFtdcOgdna2jIEERERdTAtmcqi1xCk0Wgwbdo0BAUFYefOnfX2nz9/Hl26dMGePXvg6emJM2fOYNGiRZDJZFi6dCkA4JVXXsHixYvrfG7cuHEYPnx4s+dfv349Fi5cqHttbW39kN+IiIiIOgu9hqDaHpywsLAG98+bN6/O627duiEqKgoHDx7UhSBra+s64eXSpUtISEjAtm3bmj2/jY0NXF1dH7B6IiIi6swM7hZ5pVIJBweHRvfv2LEDPXv2xOjRo5s91qZNm+Do6IjBgwdjw4YN0Gg0jbZVq9VQqVR1NiIiIuq8DGpidFRUFP773//i+++/b3C/Wq1GeHg4XnvttWaPtWzZMgwZMgT29vaIiYnB6tWrkZSUhB07djTYfuPGjQ3OPSIiIqLOqdU9QWvXroVEImlyO3fuXKsLuXr1KqZMmYI1a9bg8ccfb7DNwYMHUVxcjNmzZzd7vBUrViAkJAQDBw7EggULsG3bNuzcuRP5+fkNtl+9ejWUSqVuS0tLa/V3ICIioo6j1T1BS5cuxfTp05ts4+Pj06pjJiQk4NFHH8XChQvx5ptvNtpux44dmDRp0gPN8wkMDAQA3Lp1C46OjvX2y+VyyOXyVh+XiIiIOqZWhyAnJyc4OTm1WQFXr17Fo48+ijlz5mDDhg2NtktKSkJkZCQOHz78QOe5ePEiAMDNze2BPk9ERESdi17nBKWmpqKgoACpqamorq5GXFwcAKB79+6wtrbG1atXMXbsWIwfPx4rV65EdnY2AEAmk6FLly51jrVr1y64ubnhySefrHeemJgYzJ49G8ePH4eHhweioqIQHR2NsWPHQqFQIDY2FitWrMDkyZPh5eWlz69MREREHYReQ9CaNWuwe/du3Wt/f38AQGRkJMaMGYOvv/4ad+/eRXh4OMLDw3XtvL29kZycrHut1WoRFhaGuXPnQiaT1TtPWVkZEhMTUVlZCaBmaOurr77CunXroFar4e3tjYULF2LVqlV6+qZERETU0UgEQRDELsIQqVQqKBQKKJVKrhhNRETUQbTm99vg1gkiIiIiag8MQURERGSUDGqxRGOQlFeKfbGp6GItx4LR3cQuh4iIyGixJ6idXctS4dOTdxB2JhmcjkVERCQehqB2NraXM6zMZEgvLEdcWpHY5RARERkthqB2ZmEmw2N9XQAA313KErkaIiIi48UQJIKnBroDAL6Pz4RWyyExIiIiMTAEiWB0TyfYmpsgR6VGbHKB2OUQEREZJYYgEchNZHiiX81DYL+7nClyNURERMaJIUgkTw2qGRI7Gp+NqmqtyNUQEREZH4YgkQT7OcLBygwFpRqcuZ0vdjlERERGhyFIJCYyKZ7sXzMkdoRDYkRERO2OIUhEtUNiEVeyoa6qFrkaIiIi48IQJKLhPg5wsZVDVVGFUzfyxC6HiIjIqDAEiUgmleAPA9wA8C4xIiKi9sYQJLLaIbFjCTko13BIjIiIqL0wBInM39MOHnYWKNVU45fruWKXQ0REZDQYgkQmkUgwaVDNkBjvEiMiImo/DEEGoPZZYr9cz0WJukrkaoiIiIwDQ5AB6OduC18nK6irtDiWkCN2OUREREaBIcgASCQSTBrIITEiIqL2xBBkIGrvEjt54y6UZZUiV0NERNT5MQQZiJ4uNujpYo3KagE/JmSLXQ4REVGnxxBkQGonSB+5nCVyJURERJ0fQ5ABmXRvSOy3W3nIL1GLXA0REVHnxhBkQHydrNDP3RbVWgERVzkkRkREpE8MQQamdoL0kUscEiMiItInhiADM/HeA1Wjk/KRq6oQuRoiIqLOiyHIwHg6WMLfyw6CAByNZ28QERGRvpiIXQDVN2mgOy6mFmHjD9ex7eQdmJpIYCqTQmFhio1TB6C3q63YJRIREXV47AkyQE8NcoONuQnUVVpkqyqQVlCOO3dLcTG1CO9FJIpdHhERUafAniAD5Gxjjt9eexTZygpoqrTQVGtxt1iNxXvO45frubiZU4weLjZil0lERNShsSfIQNmam6Kniw36eygwxMseT/Rzxfi+LgCAz369I3J1REREHR9DUAfyfIgfAOCbuAzk8M4xIiKih6LXELRhwwYEBwfD0tISdnZ29fbn5+djwoQJcHd3h1wuh6enJ5YuXQqVSlWnXXx8PEJCQmBhYQEPDw+sX78egiA0ee7CwkKEhoZCoVBAoVAgNDQURUVFbfjt2t8QL3sM97FHZbWAz39LFrscIiKiDk2vIUij0WDatGlYsmRJwyeXSjFlyhQcPnwYN27cQFhYGI4dO4bFixfr2qhUKjz++ONwd3dHbGwsPvzwQ/zjH//Ali1bmjz3zJkzERcXh4iICERERCAuLg6hoaFt+v3EsOiRmt6g8LMpKFFXiVwNERFRxyURmutSaQNhYWFYvnx5i3piPvjgA2zevBlpaWkAgK1bt2L16tXIycmBXC4HALz77rv48MMPkZ6eDolEUu8Y165dQ9++fREdHY2AgAAAQHR0NIKCgnD9+nX06tWr2TpUKhUUCgWUSiVsbQ3nlnStVsDj75/E7buleHNiHywY3U3skoiIiAxGa36/DWpOUGZmJg4ePIiQkBDde1FRUQgJCdEFIAB44oknkJmZieTk5AaPExUVBYVCoQtAABAYGAiFQoEzZ840+Bm1Wg2VSlVnM0RSqQQL7wWfXaeTUFmtFbkiIiKijskgQtCMGTNgaWkJDw8P2NraYseOHbp92dnZcHFxqdO+9nV2dsMPGc3Ozoazs3O9952dnRv9zMaNG3XzhxQKBTw9PR/06+jdH/094GQtR6ayAkcuZ4pdDhERUYfU6hC0du1aSCSSJrdz58616pjvv/8+Lly4gG+++Qa3b9/GypUr6+z/3yGv2hG8hobCGvtM7eca+8zq1auhVCp1W+1wnCEyN5XhLyN9AAAf/nIL2UreKUZERNRarV4scenSpZg+fXqTbXx8fFp1TFdXV7i6uqJ3795wdHTE6NGj8dZbb8HNzQ2urq71em9yc3MBoF4P0f3Hy8nJqff+3bt3G/2MXC6vM+Rm6GYFeGP7qTu4c7cU498/if/7Y39MHuTeZDAkIiKi37U6BDk5OcHJyUkftQD4vZdHrVYDAIKCgvD6669Do9HAzMwMAPDTTz/B3d290bAVFBQEpVKJmJgYjBgxAgBw9uxZKJVKBAcH66329qSwNMWBJcFY+VUcLqUrsWxfHH5KyME7U/rD3spM7PKIiIgMnl7nBKWmpiIuLg6pqamorq5GXFwc4uLiUFJSAgA4evQoPv/8c1y5cgXJyck4evQolixZgpEjR+oCzsyZMyGXyzF37lxcuXIFhw4dwt///nesXLlS1+sRExOD3r17IyMjAwDQp08fTJgwAQsXLkR0dDSio6OxcOFCTJo0qUV3hnUUfl2scWBJMFY81hMmUgm+v5yF8f/6FQmZhjmpm4iIyKAIejRnzhwBQL0tMjJSEARB+OWXX4SgoCBBoVAI5ubmQo8ePYRXX31VKCwsrHOcy5cvC6NHjxbkcrng6uoqrF27VtBqtbr9kZGRAgAhKSlJ915+fr7w3HPPCTY2NoKNjY3w3HPP1TtuU5RKpQBAUCqVD3EF2s/ltCJh3D9PCN6vHhGW7DkndjlERESiaM3vd7usE9QRGeo6QU05n1KAp7dGwc7SFOfffBwyKecHERGRcemw6wTRwxnU1Q7WchMUlVXiaqZS7HKIiIgMGkNQJ2IikyKwmyMA4PStPJGrISIiMmwMQZ3M6B41d+6dvskQRERE1BSGoE5mZPeaEHQuuRDlmmqRqyEiIjJcDEGdjF8XK7gpzKGp1uJcSoHY5RARERkshqBORiKR6HqDOCRGRETUOIagTkg3L4iTo4mIiBrFENQJBfvVhKCrmSrkl6hFroaIiMgwMQR1Ql1s5OjtagMAOHM7X+RqiIiIDBNDUCc1ivOCiIiImsQQ1EmNum9eEJ+MQkREVB9DUCc1wtcBZjIpMorKkZxfJnY5REREBochqJOyNDPBEG87ALxLjIiIqCEMQZ3Y7/OC7opcCRERkeFhCOrERvXoAqDmDrGqaq3I1RARERkWhqBObICHAg5WZiiuqMLHkbfFLoeIiMigMAR1YjKpBGsm9QUA/Pv4DcQk8VliREREtRiCOrk/+ntg6hAPaAVg+b6LKCrTiF0SERGRQWAIMgLrp/SHj6MlMpUVePXAZa4bREREBIYgo2AtN8GHM4bAVCbBj1dzEH42VeySiIiIRMcQZCQGdFXg1Qm9AQD/dyQBidnFIldEREQkLoYgIzJvpC9CenaBukqLF/deQKm6SuySiIiIRMMQZESkUgn++cwgONvIcSu3BG99c4Xzg4iIyGgxBBkZJ2s5PpjhD6kEOHgxA/89lyZ2SURERKJgCDJCgd0c8dfxvQAAa769imtZKpErIiIian8MQUZqSYgfxvS6Nz8o/AJKOD+IiIiMDEOQkZJKJdjyzGC4KcxxJ68Urx+M5/wgIiIyKgxBRszBygwfzfSHiVSCw5cycfIGnzZPRETGgyHIyA31dkBokDcAYOfpJJGrISIiaj8MQYR5I30hlQCnbubhRg4XUSQiIuPAEETwdLDE+L6uAIDPf2NvEBERGQeGIAIAzBvlCwA4eCEDBaV80jwREXV+DEEEABjuY48BHgqoq7TYezZF7HKIiIj0jiGIAAASiQTzRvkAAL6ISoGmSituQURERHqm1xC0YcMGBAcHw9LSEnZ2dvX25+fnY8KECXB3d4dcLoenpyeWLl0Kler3FYxPnDiBKVOmwM3NDVZWVhg8eDDCw8ObPbePjw8kEkmd7bXXXmvLr9fpTBzgDmcbOXKL1fg+PlPscoiIiPRKryFIo9Fg2rRpWLJkScMnl0oxZcoUHD58GDdu3EBYWBiOHTuGxYsX69qcOXMGAwcOxIEDB3D58mXMmzcPs2fPxnfffdfs+devX4+srCzd9uabb7bZd+uMzEykmH3f7fL3L55YUKrBrdwSsUojIiJqcxKhHZYJDgsLw/Lly1FUVNRs2w8++ACbN29GWlrjD/acOHEiXFxcsGvXrkbb+Pj4YPny5Vi+fPkDVAyoVCooFAoolUrY2to+0DE6ooJSDYI2Hoe6Sou3JvVFjqoCp2/mIeHe88W2PjcETw5wE7lKIiKihrXm99ug5gRlZmbi4MGDCAkJabKdUqmEg4NDs8fbtGkTHB0dMXjwYGzYsAEaTeN3PanVaqhUqjqbMXKwMsPUIR4AgP87koDPfr2jC0AAsOHoNairqsUqj4iIqM0YRAiaMWMGLC0t4eHhAVtbW+zYsaPRtvv370dsbCz+8pe/NHnMZcuWYd++fYiMjMTSpUvxr3/9Cy+88EKj7Tdu3AiFQqHbPD09H/j7dHTPP+IHRyszeNhZ4JlhXfHv6YNxatVYuNjKkV5Yji/O8O4xIiLq+Fo9HLZ27VqsW7euyTaxsbEYNmyY7nVzw2HZ2dkoKipCYmIiXn/9dYSEhOCTTz6p1+7EiROYNGkSPvnkE8yePbs1ZePAgQP485//jLy8PDg6Otbbr1aroVarda9VKhU8PT2NbjjsfoIgQCKR6F7/NzYNqw5chq25CX5dNRZ2lmYiVkdERFRfa4bDTFp78KVLl2L69OlNtvHx8WnVMV1dXeHq6orevXvD0dERo0ePxltvvQU3t9/nnpw8eRJPPfUUtmzZ0uoABACBgYEAgFu3bjUYguRyOeRyeauP25ndH4AA4OmhXbHrtyRczy7GR7/cwpuT+opUGRER0cNrdQhycnKCk5OTPmoBAN0dSff3ytT2AG3atAmLFi16oONevHgRAOoEK2odmVSC1X/ogzm7YrA7Khmzg3zg5WgpdllEREQPpNUhqDVSU1NRUFCA1NRUVFdXIy4uDgDQvXt3WFtb4+jRo8jJycHw4cNhbW2NhIQErFq1CiNHjtT1Jp04cQITJ07EsmXL8PTTTyM7OxsAYGZmppscHRMTg9mzZ+P48ePw8PBAVFQUoqOjMXbsWCgUCsTGxmLFihWYPHkyvLy89PmVO72Qnl0wuocTTt3Mw3s/XsdHM4eIXRIREdGDEfRozpw5AoB6W2RkpCAIgvDLL78IQUFBgkKhEMzNzYUePXoIr776qlBYWNjsMUJCQnRtIiMjBQBCUlKSIAiCcP78eSEgIEB33F69eglvv/22UFpa2uLalUqlAEBQKpVtcCU6l6sZSsHntSOC96tHhAspBWKXQ0REpNOa3+92WSeoIzLWdYJa6pWvL2H/+XTYmJugv7sCvVxt0NPFBv09bDHAQ1FvPhEREVF70OvEaCIAeGV8L0TfyUd6YTmi7uQj6k6+bt+WZwZh6pCuIlZHRETUPIYgeiCuCnMcWxmCmzklSMwpxo2cYvx2Kw9XM1WIuJLNEERERAaPIYgemLmpDAO6KjCgqwIAcCmtCFM+/g1Rd/JRVa2Ficwg1uIkIiJqEH+lqM3091DA1twExRVViM9Qil0OERFRkxiCqM3IpBIE+9WsIXX6Zp7I1RARETWNIYja1Kge90LQLYYgIiIybAxB1KZGda8JQRdSC1GqrhK5GiIiosYxBFGb8na0RFd7C1RWC4hJLhC7HCIiokYxBFGbkkgkut6g3zgviIiIDBhDELU5zgsiIqKOgCGI2lztHWLXs4uRW1whcjVEREQNYwiiNudgZYZ+7jXPa4m6nd9MayIiInEwBJFe1A6JneK8ICIiMlAMQaQXusnRt/IgCILI1RAREdXHEER6MdzHAWYmUmQpK3D7bqnY5RAREdXDEER6YW4qw3AfewA1vUFERESGhiGI9GZkd94qT0REhoshiPRmdPcuAGruECss1YhcDRERUV0MQaQ3/dxt0dPFGiXqKrzz/TWxyyEiIqqDIYj0RiqVYOPUgZBIgAMX0vHrjbtil0RERKTDEER6NdTbHnOCfAAArx+K55PliYjIYDAEkd797Yle8LCzQHphObb8fEPscoiIiAAwBFE7sJKbYMOf+gMAPv8tCXFpRXX2ZynLcbdYLUJlRERkzEzELoCMw5hezviTvwcOXczAq/svY/5oX5y9U4CzSflILyyHjdwEx/4aAhdbc7FLJSIiI8GeIGo3b03qCwcrMyTmFGPV/ss4cCEd6YXlAIBidRX2xaSJXCERERkThiBqNw5WZnjv6YFwsjbDUG97vDDGD7vnjcDf/zQAAPBlTCqqqrUiV0lERMaCw2HUrh7r64JzfR+v8566qhr//CkR2aoKHL+eiyf6uYpUHRERGRP2BJHo5CYyTBvmCQDYE50icjVERGQsGILIIDwX4AWJBDh1Mw/JeXzqPBER6R9DEBkETwdLhPSsedbY3phUkashIiJjwBBEBmNWgDcA4OtzaaiorBa5GiIi6uwYgshgjO3tDHeFOQrLKnE0PkvscoiIqJNjCCKDIZNKMGOEFwAg/CyHxIiISL8YgsigPDvCEyZSCc6nFOJalkrscoiIqBPTawjasGEDgoODYWlpCTs7u3r78/PzMWHCBLi7u0Mul8PT0xNLly6FSvX7j19ycjIkEkm9LSIioslzFxYWIjQ0FAqFAgqFAqGhoSgqKmrjb0htzdnGXLdO0JecIE1ERHqk1xCk0Wgwbdo0LFmypOGTS6WYMmUKDh8+jBs3biAsLAzHjh3D4sWL67U9duwYsrKydNujjz7a5LlnzpyJuLg4REREICIiAnFxcQgNDW2T70X69Sd/DwA1t8sTERHpi15XjF63bh0AICwsrMH99vb2dQKSt7c3XnjhBWzevLleW0dHR7i6tmwl4WvXriEiIgLR0dEICAgAAGzfvh1BQUFITExEr169WvlNqD0N93GARAIk5ZUit7gCzjZ8qCoREbU9g5oTlJmZiYMHDyIkJKTevsmTJ8PZ2RkjR47E/v37mzxOVFQUFAqFLgABQGBgIBQKBc6cOdPmdVPbUliaopeLDQDgXHKhyNUQEVFnZRAhaMaMGbC0tISHhwdsbW2xY8cO3T5ra2ts2bIF+/fvx9GjRzFu3Dg8++yz2LNnT6PHy87OhrOzc733nZ2dkZ2d3eBn1Go1VCpVnY3EM8LXAQAQk1QgciVERNRZtToErV27tsGJyvdv586da9Ux33//fVy4cAHffPMNbt++jZUrV+r2OTk5YcWKFRgxYgSGDRuG9evX44UXXsB7773X5DElEkm99wRBaPB9ANi4caNuErVCoYCnp2ervgO1reE+NSEoNpkhiIiI9KPVc4KWLl2K6dOnN9nGx8enVcd0dXWFq6srevfuDUdHR4wePRpvvfUW3NzcGmwfGBhYp7eooePl5OTUe//u3btwcXFp8DOrV6+uE75UKhWDkIhqe4KuZamgqqiErbmpyBUREVFn0+oQ5OTkBCcnJ33UAqCmtwaoGZ5qzMWLFxsNSAAQFBQEpVKJmJgYjBgxAgBw9uxZKJVKBAcHN/gZuVwOuVz+EJVTW3KxNYeXgyVSC8pwPqUQY3vVH94kIiJ6GHq9Oyw1NRUFBQVITU1FdXU14uLiAADdu3eHtbU1jh49ipycHAwfPhzW1tZISEjAqlWrMHLkSF1v0u7du2Fqagp/f39IpVJ89913+OCDD7Bp0ybdeWJiYjB79mwcP34cHh4e6NOnDyZMmICFCxfi008/BQAsWrQIkyZN4p1hHchwHwekFpQhNqmAIYiIiNqcXkPQmjVrsHv3bt1rf39/AEBkZCTGjBkDCwsLbN++HStWrIBarYanpyemTp2K1157rc5x3nnnHaSkpEAmk6Fnz57YtWsXZs2apdtfVlaGxMREVFZW6t4LDw/Hyy+/jPHjxwOoubvso48+0ufXpTYW4OuAAxfSOS+IiIj0QiLUjj9RHSqVCgqFAkqlEra2tmKXY5SS8kox9h8nYCaT4vLa8TA3lYldEhERGbjW/H4bxC3yRA3xcbSEk7UcmmotLqcrxS6HiIg6GYYgMlgSiQQjfO0B8FZ5IiJqewxBZNBq1wvioolERNTWGILIoNWGoPMphajWcvoaERG1HYYgMmh93GxhIzdBiboK17L4KBMiImo7DEFk0GRSCYb61MwL4pAYERG1JYYgMnh8jhgREekDQxAZvNrniMUmF4DLWhERUVthCCKDN7CrAmYmUuSVaHAzt0TscoiIqJNgCCKDJzeRYVT3mof2fv5bksjVEBFRZ8EQRB3CkjF+AID959ORWVQucjVERNQZMARRhzDcxwGB3RxQWS3gs1/viF0OERF1AgxB1GG89GgPAMCXManILa4QuRoiIuroGIKowwj2c4S/lx3UVVrsOMW5QURE9HAYgqjDkEgkePleb9Ce6BQUlGpEroiIiDoyhiDqUMb06oL+HrYo01Rj12n2BhER0YNjCKIORSKRYOnYmt6g3WeSoSyvFLkiIiLqqBiCqMMZ39cFvVxsUKyuwu4zyWKXQ0REHRRDEHU4UqkEL4ytWTdoT3QKqrV8lAYREbUeQxB1SBP6u8LW3AS5xWqcTcoXuxwiIuqAGIKoQ5KbyPCHAW4AgMNxmSJXQ0REHRFDEHVYkwe7AwCOxmdBXVUtcjVERNTRMARRhxXg6wgXWzlUFVU4mXhX7HKIiKiDYQiiDksmleCpgTW9Qd9e4pAYERG1DkMQdWhTBnsAAI4l5KBEXSVyNURE1JEwBFGH1t/DFt2crKCu0uKnq9lil0NERB0IQxB1aBKJRNcb9C3vEiMiolZgCKIOr/YusdO38pBXoha5GiIi6igYgqjD83WywqCuClRrBRyNzxK7HCIi6iAYgqhTmMwhMSIiaiWGIOoUnhroBokEOJ9SiLSCMrHLISKiDoAhiDoFZ1tzjPRzAgBsP3VH5GqIiKgjYAiiTmPpo90BAHvPpiI1n71BRETUNIYg6jQCuznikZ5dUKUVsOXnRLHLISIiA8cQRJ3Kqid6Aah5jMa1LJXI1RARkSHTawjasGEDgoODYWlpCTs7u3r78/PzMWHCBLi7u0Mul8PT0xNLly6FSvX7j9fatWshkUjqbVZWVk2e28fHp95nXnvttbb+imRg+nsoMGmgGwQB+MeP7A0iIqLG6TUEaTQaTJs2DUuWLGn45FIppkyZgsOHD+PGjRsICwvDsWPHsHjxYl2bV155BVlZWXW2vn37Ytq0ac2ef/369XU+9+abb7bZdyPD9dfxvSCTSnD8ei5ikwvELoeIiAyUiT4Pvm7dOgBAWFhYg/vt7e3rBCRvb2+88MIL2Lx5s+49a2trWFtb615funQJCQkJ2LZtW7Pnt7Gxgaur6wNWTx2Vr5MVnhnmiS9jUvFexHX89/kgSCQSscsiIiIDY1BzgjIzM3Hw4EGEhIQ02mbHjh3o2bMnRo8e3ezxNm3aBEdHRwwePBgbNmyARqNptK1arYZKpaqzUce1bFwPyE2kiE0uxInEu2KXQ0REBsggQtCMGTNgaWkJDw8P2NraYseOHQ22U6vVCA8Px/z585s95rJly7Bv3z5ERkZi6dKl+Ne//oUXXnih0fYbN26EQqHQbZ6eng/8fUh8rgpzzB3pAwDY8vMNcYshIiKD1OoQ1NhE5fu3c+fOteqY77//Pi5cuIBvvvkGt2/fxsqVKxtsd/DgQRQXF2P27NnNHnPFihUICQnBwIEDsWDBAmzbtg07d+5Efn5+g+1Xr14NpVKp29LS0lr1HcjwPP+IH0ykEsRnKJGUVyp2OUREZGBaPSdo6dKlmD59epNtfHx8WnVMV1dXuLq6onfv3nB0dMTo0aPx1ltvwc3NrU67HTt2YNKkSQ80zycwMBAAcOvWLTg6OtbbL5fLIZfLW31cMlwOVmYI8nPEqZt5+OFKFl4Y013skoiIyIC0OgQ5OTnByclJH7UAAARBAFAz9HW/pKQkREZG4vDhww903IsXLwJAvWBFnduT/d1w6mYeIq5kMwQREVEder07LDU1FQUFBUhNTUV1dTXi4uIAAN27d4e1tTWOHj2KnJwcDB8+HNbW1khISMCqVaswcuTIer1Ju3btgpubG5588sl654mJicHs2bNx/PhxeHh4ICoqCtHR0Rg7diwUCgViY2OxYsUKTJ48GV5eXvr8ymRgxvdzwRvfxONyuhLphWXoam8pdklERGQg9BqC1qxZg927d+te+/v7AwAiIyMxZswYWFhYYPv27VixYgXUajU8PT0xderUeosaarVahIWFYe7cuZDJZPXOU1ZWhsTERFRWVgKoGdr66quvsG7dOqjVanh7e2PhwoVYtWqVHr8tGSInazmG+zggJqkAP17NwfxRvmKXREREBkIi1I4/UR0qlQoKhQJKpRK2trZil0MP4fPfkrDuuwQM97HH14uDxS6HiIj0qDW/3wZxizyRPj3Rr2Yi/bmUQuQWV4hcDRERGQqGIOr03O0sMMjTDoIA/Hg1R+xyiIjIQDAEkVF4sn9Nb1DElSyRKyEiIkPBEERGoTYERd8pQGFp449PISIi48EQREbB29EKfdxsUa0V8PM1DokRERFDEBmRCf1qh8SyRa6EiIgMAUMQGY0nB9SEoNM381BcUSlyNUREJDaGIDIaPZyt0a2LFTTVWvxyPVfscoiISGQMQWQ0JBIJHu3lDACISSoQuRoiIhIbQxAZlSHe9gCAi6lF4hZCRESiYwgio+LvZQcAuJ6tQpmmStxiiIhIVAxBZFTcFBZwtTWHVgDi05Vil0NERCJiCCKjM9jTDgBwMa1I1DqIiEhcDEFkdGqHxC6mFopbCBERiYohiIyOv9fvk6MFQRC5GiIiEgtDEBmdAR4KyKQS5BarkaWsELscIiISCUMQGR0LMxl6u9oA4K3yRETGjCGIjFLtvKC4NM4LIiIyVgxBZJT8PbloIhGRsWMIIqM0+F5PUHyGEpXVWnGLISIiUTAEkVHydbSCwsIU6iotrmcVi10OERGJgCGIjJJUKrlv0UTOCyIiMkYMQWS0fl80sUjUOoiISBwMQWS0anuC4vj4DCIio8QQREarNgQl5ZWisFQjbjFERNTuGILIaNlZmqFbFysA7A0iIjJGDEFk1HTrBTEEEREZHYYgMmqD+UR5IiKjxRBERs3/3ryg8ymFuJKhFLcYIiJqVwxBZNT6uNmiv4ctyjTVmLYtChFXssQuiYiI2glDEBk1mVSC8AWBeKRnF5RXVmPxngv46JebEARB7NKIiEjPGILI6CksTLFrzjDMDfYBAPzjpxtY8VUcKiqrxS2MiIj0iiGICICJTIq1k/thw5/6w0QqwTdxmdgUcV3ssoiISI8Ygoju81yANz5+bggAIPxsKnJUFSJXRERE+qLXELRhwwYEBwfD0tISdnZ2TbbNz89H165dIZFIUFRUVGdffHw8QkJCYGFhAQ8PD6xfv77ZORuFhYUIDQ2FQqGAQqFAaGhoveMSNWR8XxcM87aHpkqLbSdvi10OERHpiV5DkEajwbRp07BkyZJm286fPx8DBw6s975KpcLjjz8Od3d3xMbG4sMPP8Q//vEPbNmypcnjzZw5E3FxcYiIiEBERATi4uIQGhr6wN+FjIdEIsGyx3oAAPaeTUUue4OIiDolvYagdevWYcWKFRgwYECT7bZu3YqioiK88sor9faFh4ejoqICYWFh6N+/P6ZOnYrXX38dW7ZsabQ36Nq1a4iIiMCOHTsQFBSEoKAgbN++HUeOHEFiYmKbfDfq3EZ1d8IQLzuoq7T49Nc7YpdDRER6IPqcoISEBKxfvx5ffPEFpNL65URFRSEkJARyuVz33hNPPIHMzEwkJyc3eMyoqCgoFAoEBATo3gsMDIRCocCZM2ca/IxarYZKpaqzkfGq6Q3qCQAIP5uCu8VqkSsiIqK2JmoIUqvVmDFjBjZv3gwvL68G22RnZ8PFxaXOe7Wvs7OzG/2Ms7NzvfednZ0b/czGjRt184cUCgU8PT1b81WoE3qkhxMGe9qholKLz36tOzeoorIap27eRZmmSqTqiIjoYbU6BK1duxYSiaTJ7dy5cy061urVq9GnTx/MmjWryXYSiaTO69phsP99v6nP1H6usc+sXr0aSqVSt6WlpTVXPnVy988N+k90CvJK1CjXVGPX6SSEbI5E6M4YvLT3oshVEhHRgzJp7QeWLl2K6dOnN9nGx8enRcf65ZdfEB8fj/379wP4Pdw4OTnhjTfewLp16+Dq6lqv9yY3NxcA6vUQ1XJ1dUVOTk699+/evdvoZ+RyeZ0hNyIAGNOzCwZ1VeBSuhIvhl/A7bslyCvR6PYfv56LmKQCjPB1ELFKIiJ6EK0OQU5OTnBycmqTkx84cADl5eW617GxsZg3bx5OnToFPz8/AEBQUBBef/11aDQamJmZAQB++uknuLu7Nxq2goKCoFQqERMTgxEjRgAAzp49C6VSieDg4DapnYxDbW/QvLBzOJtUAADoam+BF8Z0R1xaIf57Lh2bf7yO/z4f1GTPJBERGR69zglKTU1FXFwcUlNTUV1djbi4OMTFxaGkpAQA4Ofnh/79++s2X19fAECfPn10c3pmzpwJuVyOuXPn4sqVKzh06BD+/ve/Y+XKlbofnZiYGPTu3RsZGRm6z0+YMAELFy5EdHQ0oqOjsXDhQkyaNAm9evXS51emTmhsL2dMGeyOfu622PzngYh8ZQxmBnhh5eO9YGYiRWxyIU7euCt2mURE1Eqt7glqjTVr1mD37t261/7+/gCAyMhIjBkzpkXHUCgU+Pnnn/Hiiy9i2LBhsLe3x8qVK7Fy5Updm7KyMiQmJqKyslL3Xnh4OF5++WWMHz8eADB58mR89NFHbfCtyNhIJBL8e7p/vfddFeaYE+SN7aeSsPnHRDzSowukUvYGERF1FBKBj8tukEqlgkKhgFKphK2trdjlkIEqKNXgkfciUaKuwsczh2DiQDexSyIiMmqt+f0WfZ0goo7MwcoMC0bXDOP+8+dEVFVrRa6IiIhaiiGI6CHNH+ULe0tT3LlbioMXM8Quh4iIWoghiOgh2Zib4sWx3QEA/z52E+qqapErIiKilmAIImoDswK94WIrR0ZROb6/nCV2OURE1AIMQURtwNxUhlkB3gBqnjxPRESGjyGIqI08M9wTMqkE51IKcSOnWOxyiIioGQxBRG3ExdYcj/WpWeSTvUFERIaPIYioDc0Y4QUAOHghHRWVnCBNRGTIGIKI2tAjPbqgq70FVBVVOMIJ0kREBo0hiKgNSaUSXW/Q3rMpIldDRERNYQgiamPThnWFiVSCC6lFuJ6tErscIiJqBEMQURtztjHH431dAABfcoI0EZHBYggi0gPdBOmLGSjXcII0EZEhYggi0oNR3Z3g5WCJ4ooqbDt5G1cylMgsKucdY0REBkQiCIIgdhGGSKVSQaFQQKlUwtbWVuxyqAP65MQtvBeRWO99N4U59i0KhLejlQhVERF1bq35/WZPEJGezAr0xpP9XdHb1QbONnKYyiQAgCxlBb6P5+3zRERiMxG7AKLOytbcFFtnDdW9FgQBO08n4Z3vr+HsnQK8MEa82oiIiD1BRO1GIpEgyM8RAHA+pRBV1VqRKyIiMm4MQUTtqLerLWzNTVCirsK1LD5klYhITAxBRO1IJpVguI8DAOBsUr7I1RARGTeGIKJ2NsK3NgQViFwJEZFxYwgiamcB3WrmBcUmF0Cr5QoVRERiYQgiamf93G1haSZDUVklbuRyXhARkVgYgojamalMiqHe9gCAGA6JERGJhiGISAQjfDgviIhIbAxBRCKonRd09k4B+OQaIiJxMAQRiWBgVwXMTKTIK1EjKa9U7HKIiIwSQxCRCMxNZRjsaQeA84KIiMTCEEQkkkCuF0REJCqGICKRjPCtmRfEniAiInEwBBGJZIi3HUykEmQUlSO9sEzscoiIjA5DEJFILM1M0N9DAaDmLjEiImpfDEFEIgroVjMviENiRETtjyGISEQB9yZHR1zNxuX0InGLISIyMnoNQRs2bEBwcDAsLS1hZ2fXZNv8/Hx07doVEokERUVFuvdPnDiBKVOmwM3NDVZWVhg8eDDCw8ObPbePjw8kEkmd7bXXXnvIb0TUtkZ2d0I/d1soyyvx7KfROJaQI3ZJRERGQ68hSKPRYNq0aViyZEmzbefPn4+BAwfWe//MmTMYOHAgDhw4gMuXL2PevHmYPXs2vvvuu2aPuX79emRlZem2N99884G+B5G+yE1k2LcoEI/07ILyymos+s85/CcqWeyyiIiMgok+D75u3ToAQFhYWJPttm7diqKiIqxZswY//PBDnX2vv/56ndcvv/wyfvzxRxw6dAhPPfVUk8e1sbGBq6tr6wsnakc25qbYOWcY3vrmCvbFpuGtb68irbAcr03oDalUInZ5RESdluhzghISErB+/Xp88cUXkEpbVo5SqYSDg0Oz7TZt2gRHR0cMHjwYGzZsgEajedhyifTCVCbFxqkD8Mr4ngCAz369g93sESIi0iu99gQ1R61WY8aMGdi8eTO8vLxw586dZj+zf/9+xMbG4tNPP22y3bJlyzBkyBDY29sjJiYGq1evRlJSEnbs2NFoLWq1WvdapVK17ssQPSSJRIKlj/aAuakM73x/DdtO3saMEV4wN5WJXRoRUafU6p6gtWvX1ptw/L/buXPnWnSs1atXo0+fPpg1a1aL2p84cQJz587F9u3b0a9fvybbrlixAiEhIRg4cCAWLFiAbdu2YefOncjPz2+w/caNG6FQKHSbp6dni2oiamuzg3zgpjBHjkqNr8+ni10OEVGnJREEQWjNB/Ly8pCXl9dkGx8fH5ibm+teh4WFYfny5XXu+gKAwYMHIz4+HhJJzbwHQRCg1Wohk8nwxhtv6OYUAcDJkycxadIk/POf/8SiRYtaUzIAICMjA127dkV0dDQCAgLq7W+oJ8jT0xNKpRK2tratPh/Rw9h9JhlvH74KDzsLnPjbGJjKRB+5JiLqEFQqFRQKRYt+v1s9HObk5AQnJ6cHLu5+Bw4cQHl5ue51bGws5s2bh1OnTsHPz0/3/okTJzBp0iRs2rTpgQIQAFy8eBEA4Obm1uB+uVwOuVz+QMcmamvPDvfEh7/cQkZROQ5dzMAzw9gzSUTU1vQ6Jyg1NRUFBQVITU1FdXU14uLiAADdu3eHtbV1naADQNfD1KdPH926QidOnMDEiROxbNkyPP3008jOzgYAmJmZ6SZHx8TEYPbs2Th+/Dg8PDwQFRWF6OhojB07FgqFArGxsVixYgUmT54MLy8vfX5lojZhbirDokd88fej1/FJ5C08PaQrZLxTjIioTem1j33NmjXw9/fH22+/jZKSEvj7+8Pf37/Fc4aAmqG0srIybNy4EW5ubrpt6tSpujZlZWVITExEZWUlgJpena+++gpjxoxB3759sWbNGixcuBBffvllm39HIn15LsAbdpamSM4vw5HLmWKXQ0TU6bR6TpCxaM2YIpG+fHj8Jv758w30dLFGxLJHuG4QEVEzWvP7zdmWRAZsdrAPbOQmuJFTgp/4SA0iojbFEERkwBQWppgT7AMA+MdPichWVohbEBFRJ8IQRGTg5o3yhcLCFLdySzDh37/ix6vZYpdERNQpMAQRGTgHKzMcfCEY/T1sUVRWief/cx6rD8ajTFMldmlERB0aQxBRB+DXxRoHl4zE8490AwB8GZOKSR+exvVsPt6FiOhBMQQRdRBmJlKs/kMf7JkfAGcbOe7cLcXUT87gh/gssUsjIuqQGIKIOphRPZwQsfwRjOzuiDJNNZaEX8A/f0qEVsvVLoiIWoMhiKgDcrAyw+6/jMD8Ub4AgA9/uYVF/zmH4opKkSsjIuo4GIKIOigTmRRvTeqLf04bBDMTKY5dy8W0bVFQV1WLXRoRUYfAEETUwT09tCu+fj4IdpamuJ5djF9v5IldEhFRh8AQRNQJDPK0w1T/rgDA54wREbUQQxBRJzFxoBsA4FhCDioqOSRGRNQchiCiTmKIlx087CxQqqlG5PVcscshIjJ4DEFEnYREItH1Bh3h2kFERM1iCCLqRCbdC0G/XMvlYzWIiJrBEETUiQzwUMDLwRLlldU4fo1DYkRETWEIIupE6gyJ8S4xIqImMQQRdTK1Q2KRiXdRouaQGBFRYxiCiDqZvm626OZkBU2VFscScsQuh4jIYDEEEXUyEolE1xvEITEiosYxBBF1QpMGuQMATt64C2U5H6pKRNQQhiCiTqiniw16OFujslrAzxwSIyJqEEMQUSf11L3eoI9+uQlVBXuDiIj+F0MQUScVGugNd4U5kvPL8Or+yxAEQeySiIgMCkMQUSdlb2WGj58bAlOZBD9cycau35LFLomISMcQHvTMEETUifl72ePNiX0BABuPXsP5lAKRKyIiAlLzy/D4+ydx4Hy6qHUwBBF1crODvDFpoBuqtAJeDL+I/BK12CURkRFLyS/F9M+ikFZQjq0nb0NTpRWtFoYgok5OIpHg3acHolsXK2SrKrBsXxy0Ws4PIqL2l5xXiumfRSNTWQG/LlbYuyAAZibiRRGGICIjYC03wbZZQ2FhKsPpW3mIuJotdklEZGTu3C3Bs59FIUtZgR7O1vhyUSCcbc1FrYkhiMhI9HSxwYLRvgCAnaeTRK6GiIzJ7bslmP5ZNHJUavR0uReAbMQNQABDEJFRCQ30hqlMgvMphbiYWih2OURkBARBwOL/nEdusRq9XW3w5cJAOFnLxS4LAEMQkVFxtjXH5EEeANgbRETtI62gHDdzS2Aqk2DPggA4GkgAAhiCiIzO/FE1Q2I/XMlGRlG5yNUQUWd35nYeAGCwp53B9ADVMhG7ACJqX33dbRHUzRFRd/LxxZlkrP5DH7FLMijhZ1MQfacAVmYyWJqZwFoug7W5CR7t7YzuzjZil0fU4UTdyQcABHVzFLmS+hiCiIzQgtG+iLqTj70xqXh5XA9YyflXAVBz98obh640uO/vR6/jsT7OWPSIH4b72EMikbRzdUQdjyAIiLpdE4IC/QwvBOl1OGzDhg0IDg6GpaUl7Ozsmmybn5+Prl27QiKRoKioSPd+cnIyJBJJvS0iIqLJ4xUWFiI0NBQKhQIKhQKhoaF1jktkzMb2ckY3JysUV1Th63NpYpdjMMLOJAMABnna4a+P98TiED/MDvJGSM8ukEiAY9dy8cynUfjTJ2dwIjFX3GKJWuFCaiG2nrjd7o+quJNXitxiNcxMpBjiZd+u524Jvf7zT6PRYNq0aQgKCsLOnTubbDt//nwMHDgQGRkZDe4/duwY+vXrp3vt4ODQ5PFmzpyJ9PR0XVhatGgRQkND8d1337XyWxB1PlKpBH8Z5Yu3vrmCz88kIzTIBzKpcfdsKMsrsf/eEv6rnuiFkd2d6uy/fbcEO04l4cCFdMSlFWH+7nOIWDYaPVw4REaG75WvL+HO3VKcvnUX22cPg6VZ+/T+1vYCDfGyg7mprF3O2Rp67Qlat24dVqxYgQEDBjTZbuvWrSgqKsIrr7zSaBtHR0e4urrqNjMzs0bbXrt2DREREdixYweCgoIQFBSE7du348iRI0hMTHzg70PUmTw9xAMKC1Ok5Jfh2LUcscsR3X9j01CmqUYvFxsEN9Bt79fFGhunDsBvrz6KwZ52qNYK+PVmngiV0oMyhAd2iiGzqBx37pYCAH67lY+5n8eiRF3VLueuDUFB3ZyaaSkO0e8OS0hIwPr16/HFF19AKm28nMmTJ8PZ2RkjR47E/v37mzxmVFQUFAoFAgICdO8FBgZCoVDgzJkzDX5GrVZDpVLV2Yg6M0szEzwX4AUA2GVAt8tXawWUttNf0LWqqrW6obC/jPRpcr5PFxs5nujnCgCIScpvj/KoDWw9cRsD1v6ITRHXIQjG9diY2iDiYWcBG7kJYpIKMHvnWagqKvV6XkEQEH1vUnRwd8ObDwSIHILUajVmzJiBzZs3w8vLq8E21tbW2LJlC/bv34+jR49i3LhxePbZZ7Fnz55Gj5udnQ1nZ+d67zs7OyM7u+HHBWzcuFE3f0ihUMDT0/PBvhRRBxIa5A2ZVIKzSQVIzC4WuxwUlGow+aPTGLHhGLKVFe123mPXcpBRVA57S1P80d+j2fYjfGuG42OSCvgctg4gJqkAm3+8jspqAVtP3MZb314xqv/fztwLQU8Nckf4wgAoLExxIbUIoTvOQlmmvyB0I6cE+aUaWJjKMKirnd7O8zBaHYLWrl3b4ETl+7dz58616FirV69Gnz59MGvWrEbbODk5YcWKFRgxYgSGDRuG9evX44UXXsB7773X5LEb+pecIAiN/gtv9erVUCqVui0tjZNFqfNzU1jg8T4uAID/RCeLWktRmQazdpzF1UwVSjXVOHXzbrude9dvyQCAmQFeLZq3MMBDAXNTKQrLKnHrbomeq6OWaGyoS1lWieX7LkIrAAO7KiCRAHuiU/HK/kuoqhbv6eUP6kqGElM+Oo3jLRzCrrk7q2bYNtjPEQO72mHvwgDYW5riUroSz+2MRlGZRi+11p53mI+9qA9JbUqrq1q6dCmuXbvW5Na/f/8WHeuXX37B119/DRMTE5iYmGDcuHEAaoLP22+/3ejnAgMDcfPmzUb3u7q6Iien/h+Qu3fvwsXFpcHPyOVy2Nra1tmIjMHsIG8AwKELGSjWc/d4Y5TllQjdGYOErN+HoS+002M9rmQoEZNUABOpBKGBPi36jJmJFEO9a+50OZtUoMfqqCXe/eE6+q6JwDtHEqCp+j3YCIKA17+JR6ayAt6Olti7MBD/enYwZFIJDl7IwEtfXtS112oFFJVpkKtqvx7I1hIEAW8fvopL6UqsPhiPMk3zw8Yp+WXIVFbAVCbBMJ+aP7P93BXYtygITtZmuJKhQujOGL30CNWuDxRogOsD1Wr19HAnJyc4ObXNBKcDBw6gvPz3FWtjY2Mxb948nDp1Cn5+fo1+7uLFi3Bzc2t0f1BQEJRKJWJiYjBixAgAwNmzZ6FUKhEcHNwmtRN1FkF+jujubI1buSU4dDEDs4N82vX8xRWVmLMrBvEZSjhYmWH+KF9s/jER51PaJwR9fq8X6A8D3OCqaPkDHUf4OOK3W/k4eycfoYHeeqqOmnMrtxif/XobWgHYcToJsckF+HDGEHg5WuLr8+n4/nIWTKQS/Hu6P6zlJpgy2AMWpjIs3XsRP1zJxsX3IlGl1aKwrBLV94bI/uTvgc1/HggTmWH1Xpy8cVf330VusRqf/5aMF8d2b/IztUNh/p72de4I6+Vqg/AFgZi5PRrxGUqE7jqL/8yvGSqrlVZQhr0xqfC0t8SMEZ6tWhtLqxUQfafmHwhBBrg+UC29/j+cmpqKuLg4pKamorq6GnFxcYiLi0NJSU33sZ+fH/r376/bfH1rlvPv06ePbk7P7t27sXfvXly7dg2JiYn4xz/+gQ8++AAvvfSS7jwxMTHo3bu37vb6Pn36YMKECVi4cCGio6MRHR2NhQsXYtKkSejVq5c+vzJRhyORSHQ/4l9EpbTrpNEyTRX+8nks4tKKYGdpij3zA/Ds8Jr5eDdySqAs12/P1N1iNb67lAmgZkJ0awR0+31ekLFNtDUk7/5wHVqhZohSYVEzxDPxg1PYceoO1h6+CgBYOb4nBnva6T4zvp8rds4dBnNTKbJVFcgr0egCEAAcupiBFf81rOEyQRCw5ecbAIA+bjUjFdtO3EZBadNDWbWPrGgoiPRytUH4wgA4WJnhcrpSN1k6Pl2JpXsvIGRzJLaeuI3XD8XjrW+v1LlGzUnIUkFZXgkrMxkGeCha/Ln2pteFAtasWYPdu3frXvv7+wMAIiMjMWbMmBYf55133kFKSgpkMhl69uyJXbt21ZlHVFZWhsTERFRW/v4XZnh4OF5++WWMHz8eQM3dZR999NFDfiOizulPQzywKeI6buWWIOpOPoL92ud21s0/JuJcSiFszU2wZ34A+rrX/OXu42iJ5PwyXEwtxJhe9W9yaAvlmmqsPhgPTbUW/l528G/lQm6DPe1gJpMit1iNlPwy+DhZ6aVOalz0nXwcu5YLmVSCf00fDHNTGV7+8iLOpxTine+vAah5VMPzj9QfWRjdowt+XTUWN3NKYG9pBkdrM9hbmuFEYi5e3HsB313KhATAlmcGNdkjlFZQhj1nU5BRWI43J/ZtVW/i/zpyORNbfrqBFY/3xFOD3Ovs+zkhB5fTlbA0k+GLeSPwl7AYXMlQ4aNfbmHNU30bPN79qzU3tOwDAPR2tUX4ggDM3B6NS+lKjNl8ok6w8veyQ1xaEfZEpyJHpcYH0/1hYdb8vLnau8KG+zrA1MB61O6n18rCwsIgCEK9rbEANGbMGAiCUGd16Tlz5iAhIQGlpaVQqVQ4d+5cvYnUtZ/z8fHRvefg4IA9e/bobnffs2dPs6tWExkrW3NT/OneXVF7olPa5Zw3corxRVTNuT6cOQT97/vX4pB7820u6GlI7G6xGtO3R+PYtRyYyaT42/jW9xCbm8owyLOm5hjOC2pz1VoBd4vVSMhUITmvtN5+rVbAxqM1QWfGCE/4dbGGh50FvloUiBfH+kEiAewtTbHl2UGNLgTqbGOOkd2d0NfdFi625jAzkWJ8P1d8PHMITGUSHL6Uib9+Xb9HSBAE/HYrDwu/OIeQzZH49OQdHLmchWmfnkFqftkDfd+0gjK8uv8y7uSVYsVXcYi8/vuK5Frt771Ac4N90MVGjtcm1Dzz7z/RyUgraPictXdnmZtKMdjLrtFz93GzRfiCQNhZmqKgVAOZVII/DnbH9y+PwqEXRuKTmUNgZiLFzwk5mLkjutneJ+D+9YEMdygM4LPDiOie0CBvhJ9NxY9Xc5CtrHiof9E2RxAErD18FdVaAU/0c0FIzy519g/1tsfBCxk4p4cQdCu3GHM/j0V6YTnsLE2xffYwDPdpegX6xgT4OiI2uRDRSfl4ZjiX1XhY8elK/N/3CUjKK0V+iRr3j77MDvLGGxP7QG5S0wvxfXwWLqUrYWUmw7JxPXXtTGRS/O2J3vjzUE9YmcngbNv6P8e1QeiF8Av4Ni4T2coKONnIUaquQqm6CtmqCqQV/D6fdXQPJ6QWlCElvwx/3nYG4QsCWrWSuFYr4NUDl1GqqYalmQxlmmosCT+PPfMDMMzHAUevZOF6djFs5CZY9Eg3AMCoHk4Y3cMJp27m4Z8/JeJf0/3rHbd2KGy4j4PuujWmr7stDiwJxvFrOfjDADd0tbfU7XtygBucbORYsPscLqYW4emtZ7BjzjD4dbFu8FhV1VrdPwzaq1f5QRluHxURtaverrYY4eOAaq2AvTGpej1XxJVsnLmdD7mJFG9OrN+VX3vnVVxaUZvOyzhzOw9TPzmD9MJyeDta4uCS4AcOQEDd9YLo4eyLScXTW88gJqkAd4trApBEAjhZ1zwd4IuoFDy99QxS8kuhrqrGez9eBwA8H+KHLjbyesfzdbJ6oABUa3w/V3z83BCY3FtH6/vLWTiReBexyYVIKyiHpZkMoYHeOLbyEfxnfgC+fj4IvVxskFusxjOfRiE+Xdnic4XHpOLM7XyYm0pxeOkoPNrbGRWVWswLi0VCpgrv3+sFmj/aF3aWvz8t4dUJvQEA38Rl4kpG/fPVTopu6cRkvy7WWPSIX50AVGu4jwMOLAmCh50FkvJK8dSHp7H/fHqD8+GuZKpQrK6CrbmJbojbULEniIh0QoO8EZNcgC9jUvHSo931MpZfrqnWzdd4PsQPng71/8Lt6WwDG7kJitVVuJ5dXGeo7EHlqiowLywWFZVaDPW2x2ehQ+FoXf/HszWGettDJpUgvbAcGUXl8LCzeOg6jU1FZTXWfHsF/z1X89y2x/o4Y9m4nnCxlcPBygwmMikiE3Ox8qs4XMlQYdIHpxHSqwvSCsrhbCPHgtG+eqvtiX6uOLAkGKdv5cHCVAZruQmszU1gLTfBIE+7OndSOduaY9+iQMz9PAaX0pWYuT0aq//QB/3cbeHnbA1recM/t2kFZbphvVcn9EZ3Z2t8PHMIQneexbmUQvzpk9+grtLCztIU80bV/a79PRSYMtgd38ZlYlPEdXwxb4TuDq5q7X2rNbdRb0x3ZxsceiEYL++7iOg7BXjl60s4ffMu/u+P/WFjbopcVQV2RyVjT3TNP6JG+Doa/DMJGYKISOeJfq7oYiPH3WI1Vu2/jE1PD2zRImdFZRrM/TwWAhp++Oj9tp28rQsMS0IaXgpDKpXA39sev964iwuphW0SgvbGpKKiUosBHgqELwhok4c5WslN0N9DgUtpRYhJysef/Ls+9DFbIiFThfLKKgz1fvBeLEOQVlCGxXvO42qmClIJ8NfxvbAkxA/S//nhHNvLGd+/PBov3Zv0fORyFgBg5eM99f4g0EGedhh0351lTbG3MsOeBQGYv/scYpIK8PqheN0+N4U5ernaYHxfVzzZ3xX2VmbQagWs2n8ZZZpqjPB1wJx7y1NYmMmwc85wPPNpFBJzalZyX/RIN9iam9Y75yvje+FofBZO3czDP35KxCvje0EikeBqphLFFVWwkZugfxv2xjjbmiN8QSC2nriF94/dxDdxmbiYVoRh3g747lImNPd6bn0cLfG3Jwz/bmwOhxGRjpmJFGsm9YVMKqlZM2hX88vqV1Vr8dKXFxGXVoRLaUV4bsdZLNgdi9sNrKScVlCGbSdvAwDemNinybtMht67W6st1guqrNZi79maf50uGO3bpk+zDmjnIbErGUr88ePf8PTWKGz5KdFgb88vKNUgt7jxhQdziyswbVsUrmaq4GBlhv/MD8CLY7vXC0C13O0ssG9RIBbfC879PWzx56HtEzpbw8bcFF/MG4EXx/ohsJsDnO71NmYpK3Ai8S5ePxSP4RuOYX5YLNYcvoKoO/mwMJVh858H1vnuCktTfDF/BPy6WMHXyUoXkP6Xp4Olbkj548jb2PxjzZ+J2qGwgG4Obb7ekUwqwdJHe+C/zwfCw84CKfllOHAhHZrqml7WbbOG4vhfx6CXa8vnRYmFPUFEVMdTg9xha2GKF8MvIPpOAaZu/Q1hfxnR4LAVALz3YyJO3awZLpg8yB0HLqTj2LVcnEi8i+kjPOFiY47CskoUlWsQn66EukqLoG6OeLK/a5N11M4LaosQ9OPVbOQWq+FkLceT/RtfaPVBBPg64LNf77TLytGl6iq8/OVF3b+2P/jlFlIKyvDenwc2O/G1IcUVlYi+U4CU/FIk55ciJb8MaQVl6GpviQn9XXU9g6115HImVu2/DK0g4PO5I+rNSdFUafFi+AVkqyrg18UK/5kfAPcWDCWayqR47cnemB3kDYWFqcEtZljL3FSGvz3RW/e6qEyD23dLEJNUiMOXMnEtS4Xj99399eqEXvB2rL/EgoutOX5aEQIJ0Gg4BIA5wT6o1gpYfyQBn5y4DQHQzREK0uPE5KHeDjj68mhs/OEayjTVmBPs3eF6JyWCof4zQmQqlQoKhQJKpZKP0CCjdC1LhXlhschSVsDJ2gwfzxyCgP+53fXbuAws2xcHAPh45hBMHOiG23dLsPHoNRy7ltvAUQETqQTfvzy62X8lFldUYtC6n6AVgLOvj4PLQ0xyfebTKMQkFeDlR7tj5QPcDt8UZXklBq//CYIAxLwxDs42+rur7pWvL2H/+XS4KcyxYHQ3bDx6DVVaAcN97PFp6DA4WJk1fxDU3J13+FIm/u9IAvJKGr/dWSIBRvg44A8D3PDHwR5QWNYfjrlfZbUWG49ex67fknTv1a5rM+y+Cehvf3sFu6NSYCM3wTdLRzZ6l1FndSu3GIfjMvHj1Rz0drPB+88MbjLktFTYb0lY+11Cnfd+WDZat7iisWjN7zdDUCMYgoiAbGXNZOLaZ3oF+Drg+ZBuGNPTGQlZKjy99QzUVVq8MMYPqyb0rvPZ0zfzcPBCOkxlUthZmcLe0gx2Fqbo76Fo8RyfJ/99CteyVNj63BA8OeDBenCuZ6sw4V+nIJNK8Nurj+rl1v8//PsUErJUuiCoD7WBUyoBvlwYiIBujvjtVh4W7zmP4ooq+DhaYlvoUPR2bfrvq5T8Urz5zRWcullz+7SHnQUGe9nBx9ES3o5W6GpngfgMJY5eycaltCLd5yxMZfijvwfmBHs3eI5cVQVe3HsBsck1PXfPh3RDQqYKp27mwVpugj0LAjDY0w5fn0vD3/ZfBgDsmD0Mj/Vt+HmO9GB2n0nG2/dWynawMsO5Nx5rk4DVkbTm95vDYUTUKFeFOf67OAj/910CDlxIx9mkApxNKkBPF2sUV1RBXaXFmF5d8NcGeldG9XDCqB4P1xU/1NsO17JUOJ9S+MAhqHZBxif6ueht7aMRvg5IyFLhbFK+XkJQSn4p3jh0BQDw0qM9dD1yI7s74eCSYMz9PBbJ+WWY+MFphAZ6Y8VjPev12uSVqLH3bCo+jrwFdZUWZiZSvDS2OxaFdKs3lBbc3QnPh/ghvbAMEVeysf98Oq5nF+PLmFR8GZOKAF8HDPdxQJmmumbtHE0Vou8UIK9EDWu5Cf4xbRAm9HdFuaYafwmLQfSdAoTuPIs3J/bBW9/W/EAvf6wHA5AezAn2gVQCvH34KiYOcDO6ANRa7AlqBHuCiOrKUpbj89+SsfdsKkrUNU+v9nWywjcvjqxzq3BbOnQxHSu+uoTBnnb45sWRrf68srwSgX8/jvLKauxbFKi3p1n/dDUbi/5zHgoLU0S+MqbFw1ItoanSYtq2M7iUrsQIHwfsXRhQby7M3WI13vwmHj9ezQFQs1LyyvG9MHGAG35OyMaRy1k4cztf9+ynkd0d8c4fB8C3hY/6EAQBMUkF2B2VjB+v5jT6DKmeLtbYNmsout03vFWqrsKcXTF1Fr58rI8LPgsdyh9oPSoq00BhYdqqh552FhwOawMMQUQNU1VUYu/ZVMSlFuFvE3rpdT5HWkEZRr8XCVOZBPFrn2j1XV27Tidh/ZEE9HSxxo/LH9HbD0K1VsCkD0/jWpYKM0Z4YePUAW127A+O38SWn29AYWGKo8tGN7kW0W+38rDuu6u4kVP/zjyg5iGj80f5Yspg9we+FlnKcnx9Lh15JWpYmpnAWi6DpZkJHK3N8HhflwZvWS+uqMSsnTG4lFaEbl1qgnNDt3sTtQWGoDbAEEQkPkEQMOLvx3G3WI2vFwe1anVnrVbAuC0nkZRXinf+2B+zAr31WCkQm1yAaduiIJEA3744EgO72j30MfNK1Ah5LxKlmmr8e/pgTBns0exnqqq1CD+bii0/34CyvBK9XW3w1CB3TBzgJupDXlUVlThyKQuP9XF+qJWciZrDOUFE1ClIJBIM9bJHxNVsnE8pbFUIOnUrD0l5pbCRm+geDqtPw30c8Cd/Dxy6mIE1317FwSXBDz3c89Evt1CqqcYADwUm/89TxRtjIpNiTrAPpg3rCmV5JdwUhrGKta25KWYGeIldBlEdhrnIAhHRPbXrBf16426LFwbUagX8+1jN85aeHtoVVo08sqCtrX6yN6zMZIhLK8L+C+kPday0gjKEn62Z1P3qhN6tHr6yNDMxmABEZKgYgojIoD3axxkmUgnO3M7XPS6hOeFnU3AhtQhWZjLdU7fbg7OtOZY91gMAsOmH61CWN73adlPe//kGKqsFjOr+8HfZEVHDGIKIyKD5dbHG0ke7AwDe+vZKk49iAGrWNtoUkQgAWDWhd4tWIm5Lc4N94dfFCvmlGt3Tv1vrerYKh+IyAACrJhj+85eIOiqGICIyeC+O7Y6+brYoKqvEG4euNDkstubbKyhRV8Hfy07vk6EbYmYixdrJ/QAAX0Ql40Jq6x/7sTkiEYIATBzg1iYTrImoYQxBRGTwTGVS/POZQTCVSfBzQg6+uddL8r8irmThp4QcmEgl2Dh1AGQirUMzukcXTBroBq0ALPriPNILy1r82djkAhy/nguZVIK/ju+pxyqJiCGIiDqEPm62WDauZr7N299eRY6q7rCYsrwSa+6tRrw4xK/Zx0fo27tPD0RvVxvklaixYPc5FFc0Pz+oXFONjUevAQCeGeZZZ9FBImp7DEFE1GEsDvHDAA8FVBVVeOXrSzh+LQeR13Nx8sZdvP3tFeQWq+HrZKWbQyQma7kJds4dDidrOa5nF+PlLy+i6t7T3xtyPqUQf/jgFC6kFsHcVKoLfESkP1wssRFcLJHIMN3IKcakD05D00ig+HJhIIL89PN4jAcRl1aEZz+NgrpKi7nBPrr5QrUqKqvx/rEb2P7rHWgFwNXWHP98ZhBGducdYUQPgitGtwGGICLDdfBCOvZEp6BaK0Ar4N7/CnhqkDteHCt+L9D/OhqfhRfCLwAAnuzvCjtLU0glEsikEkTdzsfN3JrHXEwd4oG3n+qnt2exERkDhqA2wBBERG3p48hb2PxjYoP7nKzl2Dh1AB7nU9WJHhofm0FEZGBeGOOHHs7WuHW3BFqtgCqtAK1WgKXcBM8O84R9Gz55nohahiGIiKgdSCQSjO/nivFiF0JEOrw7jIiIiIwSQxAREREZJYYgIiIiMkoMQURERGSUGIKIiIjIKDEEERERkVFiCCIiIiKjxBBERERERokhiIiIiIySXkPQhg0bEBwcDEtLS9jZ2TXZNj8/H127doVEIkFRUZHu/bVr10IikdTbrKysmjyej49Pvc+89tprbfCtiIiIqDPQ62MzNBoNpk2bhqCgIOzcubPJtvPnz8fAgQORkZFR5/1XXnkFixcvrvPeuHHjMHz48GbPv379eixcuFD32trauhXVExERUWem1xC0bt06AEBYWFiT7bZu3YqioiKsWbMGP/zwQ5191tbWdcLLpUuXkJCQgG3btjV7fhsbG7i6ura+cCIiIur0RJ8TlJCQgPXr1+OLL76AVNp8OTt27EDPnj0xevToZttu2rQJjo6OGDx4MDZs2ACNRtNoW7VaDZVKVWcjIiKizkvUp8ir1WrMmDEDmzdvhpeXF+7cudNs+/Dw8BbN7Vm2bBmGDBkCe3t7xMTEYPXq1UhKSsKOHTsabL9x40Zdz9X9GIaIiIg6jtrfbUEQmm8stNLbb78tAGhyi42NrfOZzz//XFAoFPWOtWLFCuHZZ5/VvY6MjBQACIWFhQ2ee+/evYKJiYmQlZXV2rKF/fv3CwCEvLy8BvdXVFQISqVStyUkJDT7Pblx48aNGzduhrmlpaU1mw0kgtCSqPS7vLw85OXlNdnGx8cH5ubmutdhYWFYvnx5nbu+AGDw4MGIj4+HRCIBAAiCAK1WC5lMhjfeeKNez8y4ceNga2uLQ4cOtaZkAEBGRga6du2K6OhoBAQENNteq9UiMzMTNjY2uvraikqlgqenJ9LS0mBra9umx6a6eK3bD691++G1bj+81u2nra61IAgoLi6Gu7t7s9NsWj0c5uTkBCcnpwcu7n4HDhxAeXm57nVsbCzmzZuHU6dOwc/Pr07bpKQkREZG4vDhww90rosXLwIA3NzcWtReKpWia9euD3SulrK1teV/VO2E17r98Fq3H17r9sNr3X7a4lorFIoWtdPrnKDU1FQUFBQgNTUV1dXViIuLAwB0794d1tbW9YJObQ9Tnz596q0rtGvXLri5ueHJJ5+sd56YmBjMnj0bx48fh4eHB6KiohAdHY2xY8dCoVAgNjYWK1aswOTJk+Hl5aWX70pEREQdi15D0Jo1a7B7927da39/fwBAZGQkxowZ0+LjaLVahIWFYe7cuZDJZPX2l5WVITExEZWVlQAAuVyOr776CuvWrYNarYa3tzcWLlyIVatWPdwXIiIiok5DryEoLCys2TWC7jdmzJgGZ3NLpVKkpaW1+HNDhgxBdHR0q2ptT3K5HG+//TbkcrnYpXR6vNbth9e6/fBatx9e6/YjxrVu9cRoIiIios5A9MUSiYiIiMTAEERERERGiSGIiIiIjBJDEBERERklhqB29sknn8DX1xfm5uYYOnQoTp06JXZJHd7GjRsxfPhw2NjYwNnZGX/84x+RmJhYp40gCFi7di3c3d1hYWGBMWPG4OrVqyJV3Hls3LgREokEy5cv173Ha912MjIyMGvWLDg6OsLS0hKDBw/G+fPndft5rdtGVVUV3nzzTfj6+sLCwgLdunXD+vXrodVqdW14rR/Mr7/+iqeeegru7u6QSCT45ptv6uxvyXVVq9V46aWX4OTkBCsrK0yePBnp6eltU2CrH8JFD2zfvn2CqampsH37diEhIUFYtmyZYGVlJaSkpIhdWof2xBNPCJ9//rlw5coVIS4uTpg4caLg5eUllJSU6Nq8++67go2NjXDgwAEhPj5eePbZZwU3NzdBpVKJWHnHFhMTI/j4+AgDBw4Uli1bpnuf17ptFBQUCN7e3sLcuXOFs2fPCklJScKxY8eEW7du6drwWreNd955R3B0dBSOHDkiJCUlCV9//bVgbW0t/Otf/9K14bV+MEePHhXeeOMN4cCBAwIA4dChQ3X2t+S6Ll68WPDw8BB+/vln4cKFC8LYsWOFQYMGCVVVVQ9dH0NQOxoxYoSwePHiOu/17t1beO2110SqqHPKzc0VAAgnT54UBEEQtFqt4OrqKrz77ru6NhUVFYJCoRC2bdsmVpkdWnFxsdCjRw/h559/FkJCQnQhiNe67bz66qvCqFGjGt3Pa912Jk6cKMybN6/Oe1OnThVmzZolCAKvdVv53xDUkutaVFQkmJqaCvv27dO1ycjIEKRSqRAREfHQNXE4rJ1oNBqcP38e48ePr/P++PHjcebMGZGq6pyUSiUAwMHBAUDNc+eys7PrXHu5XI6QkBBe+wf04osvYuLEiXjsscfqvM9r3XYOHz6MYcOGYdq0aXB2doa/vz+2b9+u289r3XZGjRqF48eP48aNGwCAS5cu4fTp0/jDH/4AgNdaX1pyXc+fP4/Kyso6bdzd3dG/f/82ufZ6XTGafpeXl4fq6mq4uLjUed/FxQXZ2dkiVdX5CIKAlStXYtSoUejfvz8A6K5vQ9c+JSWl3Wvs6Pbt24cLFy4gNja23j5e67Zz584dbN26FStXrsTrr7+OmJgYvPzyy5DL5Zg9ezavdRt69dVXoVQq0bt3b8hkMlRXV2PDhg2YMWMGAP651peWXNfs7GyYmZnB3t6+Xpu2+O1kCGpnEomkzmtBEOq9Rw9u6dKluHz5Mk6fPl1vH6/9w0tLS8OyZcvw008/wdzcvNF2vNYPT6vVYtiwYfj73/8OoObZi1evXsXWrVsxe/ZsXTte64f31VdfYc+ePdi7dy/69euHuLg4LF++HO7u7pgzZ46uHa+1fjzIdW2ra8/hsHbi5OQEmUxWL7nm5ubWS8H0YF566SUcPnwYkZGR6Nq1q+59V1dXAOC1bwPnz59Hbm4uhg4dChMTE5iYmODkyZP44IMPYGJioruevNYPz83NDX379q3zXp8+fZCamgqAf67b0t/+9je89tprmD59OgYMGIDQ0FCsWLECGzduBMBrrS8tua6urq7QaDQoLCxstM3DYAhqJ2ZmZhg6dCh+/vnnOu///PPPCA4OFqmqzkEQBCxduhQHDx7EL7/8Al9f3zr7fX194erqWufaazQanDx5kte+lcaNG4f4+HjExcXptmHDhuG5555DXFwcunXrxmvdRkaOHFlvqYcbN27A29sbAP9ct6WysjJIpXV/DmUyme4WeV5r/WjJdR06dChMTU3rtMnKysKVK1fa5to/9NRqarHaW+R37twpJCQkCMuXLxesrKyE5ORksUvr0JYsWSIoFArhxIkTQlZWlm4rKyvTtXn33XcFhUIhHDx4UIiPjxdmzJjB21vbyP13hwkCr3VbiYmJEUxMTIQNGzYIN2/eFMLDwwVLS0thz549uja81m1jzpw5goeHh+4W+YMHDwpOTk7CqlWrdG14rR9McXGxcPHiReHixYsCAGHLli3CxYsXdUvDtOS6Ll68WOjatatw7Ngx4cKFC8Kjjz7KW+Q7qo8//ljw9vYWzMzMhCFDhuhu46YHB6DB7fPPP9e10Wq1wttvvy24uroKcrlceOSRR4T4+Hjxiu5E/jcE8Vq3ne+++07o37+/IJfLhd69ewufffZZnf281m1DpVIJy5YtE7y8vARzc3OhW7duwhtvvCGo1WpdG17rBxMZGdng389z5swRBKFl17W8vFxYunSp4ODgIFhYWAiTJk0SUlNT26Q+iSAIwsP3JxERERF1LJwTREREREaJIYiIiIiMEkMQERERGSWGICIiIjJKDEFERERklBiCiIiIyCgxBBEREZFRYggiIiIio8QQREREREaJIYiIiIiMEkMQERERGSWGICIiIjJK/w8xdSlU5Deb2AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c60498dd-f819-47b1-94a8-f89e87252585",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-26806.47323388637,\n",
       "  3992.2533634796905,\n",
       "  -30538.21449488442,\n",
       "  -336.80291313777013,\n",
       "  205.08054624250693,\n",
       "  -30538.214555919578],\n",
       " [-30544.75186763855,\n",
       "  -30542.07568350318,\n",
       "  -30543.532056437456,\n",
       "  -30539.389911519014,\n",
       "  -30518.258791111293,\n",
       "  -30645.317564035737,\n",
       "  -30567.383226297068,\n",
       "  -30549.237836063665,\n",
       "  -30537.218125096435,\n",
       "  -30534.016886881465,\n",
       "  -30542.083614149073,\n",
       "  -30538.919947034185,\n",
       "  -30540.074608212773,\n",
       "  -30535.289041882817,\n",
       "  -30550.196979977452,\n",
       "  -30613.39375021585,\n",
       "  -30535.806492707896,\n",
       "  -30565.411395252508,\n",
       "  -30537.414186579204,\n",
       "  -30543.123461932875,\n",
       "  -30538.977908344008,\n",
       "  -30537.06359216664]]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "52233740-9829-4907-ad5a-55e6291faa29",
   "metadata": {},
   "outputs": [],
   "source": [
    "mod_out = energy_match_analysis(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d8804ab4-b9a5-4277-a5f4-f6745b0c3e31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[29697.37102009, -3957.57195501, 25436.82004472, 25928.42382855],\n",
       "       [30540.50990056, -3989.95795781, 26211.45362394, 26753.33708332],\n",
       "       [30947.54429994, -3816.71509103, 26816.34669855, 27305.69785555],\n",
       "       [31724.06929999, -4192.53886141, 27198.14083412, 27731.52450553],\n",
       "       [32169.03255376, -4614.19663308, 27229.77162215, 27737.60390264],\n",
       "       [31987.20305453, -4106.81258027, 27553.07905811, 28081.24711821],\n",
       "       [32501.58541623, -4188.79709395, 27978.69043632, 28509.85389949],\n",
       "       [32538.20929168, -4313.36952351, 27887.14605012, 28431.24631243],\n",
       "       [32776.1608126 , -4168.16384138, 28272.12883966, 28815.18290811],\n",
       "       [33488.66029384, -4626.1551783 , 28546.44418811, 29078.42546982]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mod_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1d48a31-e6b3-4772-a20a-22b3500a78e2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "aludel",
   "language": "python",
   "name": "aludel"
  },
  "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}