{ "cells": [ { "cell_type": "markdown", "id": "3669e39a", "metadata": {}, "source": [ "# Driving the xnn MDI engine from LAMMPS: liquid-argon NVE and $g(r)$\n", "\n", "The companion notebook [`mdi_argon_md.ipynb`](mdi_argon_md.ipynb) served a trained\n", "checkpoint over the [MolSSI Driver Interface](https://github.com/MolSSI-MDI/MDI_Library)\n", "and drove it from a hand-written Python driver, so every protocol command was visible.\n", "This notebook replaces that driver with **LAMMPS**: the production coupling. LAMMPS owns\n", "the integrator, the thermodynamic output and its analysis machinery (here a radial\n", "distribution function), while **every energy, force and stress evaluation happens in the\n", "unchanged xnn engine** via LAMMPS' `fix mdi/qm`.\n", "\n", "| stage | tool |\n", "|---|---|\n", "| model | `runs/mdi_argon/best.pt` from the companion notebook (trained here if missing) |\n", "| driver | `lmp` with the MDI package: `fix mdi/qm`, NVE, RDF |\n", "| engine | `xnn mdi --ckpt best.pt` over TCP, byte-for-byte the same command as before |\n", "| validate | LAMMPS step-0 potential energy and pressure vs direct evaluation |\n", "\n", "**Requirements.** Besides `xnn[mdi]`, a LAMMPS executable built with the MDI package:\n", "\n", "```bash\n", "git clone --depth 1 --branch stable https://github.com/lammps/lammps\n", "cmake -B lammps/build -S lammps/cmake -D PKG_MDI=yes -D BUILD_MPI=no -D CMAKE_BUILD_TYPE=Release\n", "cmake --build lammps/build -j # -> lammps/build/lmp\n", "```\n", "\n", "Put `lmp` on `PATH` (or point the `XNN_LMP` environment variable at it). Unlike the\n", "companion notebook, this one never calls the MDI library in-process (driver and engine\n", "are both subprocesses), so it can be re-run without restarting the kernel.\n" ] }, { "cell_type": "markdown", "id": "f05dfd29", "metadata": {}, "source": [ "## 0. Setup\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "c891d6a6", "metadata": { "execution": { "iopub.execute_input": "2026-08-10T13:55:29.774883Z", "iopub.status.busy": "2026-08-10T13:55:29.774698Z", "iopub.status.idle": "2026-08-10T13:55:32.241292Z", "shell.execute_reply": "2026-08-10T13:55:32.240371Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 0.1.0 | device: cuda | lmp: /D3/sina/xnn/.venv/bin/lmp\n" ] } ], "source": [ "# silence the expected warnings (TorchScript scripting + e3nn torch.load)\n", "import logging, warnings\n", "logging.getLogger(\"cuequivariance\").setLevel(logging.ERROR)\n", "warnings.filterwarnings(\"ignore\", category=UserWarning,\n", " message=\"The TorchScript type system doesn't support\")\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning,\n", " message=\"You are using `torch.load` with `weights_only=False`\")\n", "\n", "import os, sys, time, shutil, subprocess\n", "from pathlib import Path\n", "import numpy as np\n", "import torch\n", "import matplotlib.pyplot as plt\n", "\n", "torch.set_default_dtype(torch.float32)\n", "torch.manual_seed(0)\n", "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "\n", "LMP = (os.environ.get(\"XNN_LMP\") or shutil.which(\"lmp\")\n", " or str(Path(sys.executable).parent / \"lmp\"))\n", "assert os.path.exists(LMP), (\"LAMMPS with the MDI package not found: build it with \"\n", " \"-D PKG_MDI=yes and put `lmp` on PATH or set XNN_LMP\")\n", "\n", "import xnn\n", "print(\"xnn:\", xnn.__version__, \"| device:\", DEVICE, \"| lmp:\", LMP)" ] }, { "cell_type": "markdown", "id": "15f8aca4", "metadata": {}, "source": [ "## 1. Data and checkpoint\n", "\n", "Same bundled `argon_md` hub data and the same 30-epoch MACE checkpoint as the companion\n", "notebook; if `runs/mdi_argon/best.pt` is not there yet, it is trained here with the\n", "identical recipe.\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "39e6dbb9", "metadata": { "execution": { "iopub.execute_input": "2026-08-10T13:55:32.244274Z", "iopub.status.busy": "2026-08-10T13:55:32.244004Z", "iopub.status.idle": "2026-08-10T13:55:33.512880Z", "shell.execute_reply": "2026-08-10T13:55:33.512065Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reusing the checkpoint trained in mdi_argon_md.ipynb\n" ] } ], "source": [ "from xnn.common.data import load_dataset\n", "\n", "train_structs = load_dataset(\"argon_md\", split=\"train\")\n", "test_structs = load_dataset(\"argon_md\", split=\"test\")\n", "CUTOFF, SPECIES, E0 = 6.0, [18], {18: 0.0}\n", "\n", "CKPT = \"runs/mdi_argon/best.pt\"\n", "if os.path.exists(CKPT):\n", " print(\"reusing the checkpoint trained in mdi_argon_md.ipynb\")\n", "else:\n", " from xnn.common.config import from_dict\n", " from xnn.common.data import AtomicDataset\n", " from xnn.common.train import Trainer\n", " probe = AtomicDataset(train_structs[:10], CUTOFF)\n", " graphs = [probe[i] for i in range(len(probe))]\n", " lam = float(sum(g.num_edges for g in graphs) / sum(g.num_nodes for g in graphs))\n", " core = from_dict({\n", " \"model\": {\"name\": \"mace\", \"cutoff\": CUTOFF, \"n_features\": 32,\n", " \"n_interactions\": 2, \"n_rbf\": 8, \"species\": SPECIES, \"max_ell\": 3,\n", " \"max_L\": 1, \"correlation\": 3, \"hidden_irreps\": \"32x0e+32x1o\",\n", " \"MLP_irreps\": \"16x0e\", \"avg_num_neighbors\": lam,\n", " \"atomic_energies\": [E0[z] for z in SPECIES]},\n", " \"data\": {\"batch_size\": 10},\n", " \"optim\": {\"lr\": 0.01, \"weight_decay\": 5e-7, \"epochs\": 30,\n", " \"energy_weight\": 1.0, \"force_weight\": 100.0, \"scheduler\": \"plateau\"},\n", " \"device\": DEVICE, \"seed\": 0, \"output_dir\": \"runs/mdi_argon\",\n", " })\n", " rng = np.random.default_rng(0)\n", " idx = rng.permutation(len(train_structs))\n", " Trainer(core,\n", " AtomicDataset([train_structs[i] for i in idx[:180]], CUTOFF),\n", " AtomicDataset([train_structs[i] for i in idx[180:]], CUTOFF)).fit()\n", " print(f\"trained -> {CKPT}\")" ] }, { "cell_type": "markdown", "id": "2be35e39", "metadata": {}, "source": [ "## 2. LAMMPS inputs\n", "\n", "Two files, both generated into `runs/mdi_argon_lammps/`:\n", "\n", "**`data.argon`**: the same 400-atom test frame used in the companion notebook, written\n", "in LAMMPS `data` format. The dataset stores unwrapped MD coordinates, so the frame is\n", "wrapped into the box first (`read_data` requires in-box positions; under periodic\n", "boundaries this is the identical system).\n", "\n", "**`in.argon`**: a completely ordinary LAMMPS NVE script, except that **no `pair_style`\n", "is defined**. The MDI-specific lines are:\n", "\n", "* `fix qm all mdi/qm virial yes elements Ar`: outsources energy/forces to the connected\n", " MDI engine; `elements Ar` maps LAMMPS atom type 1 to $Z=18$ for the `>ELEMENTS`\n", " command, `virial yes` also requests `CELL_DISPL` (the engine does not\n", "register it; a rigid cell shift is irrelevant to the graph) and falls back from ` 5 fs\n", "\n", "fix integrate all nve\n", "fix qm all mdi/qm virial yes elements Ar\n", "\n", "compute grdf all rdf 100 cutoff 8.0\n", "fix rdf all ave/time 10 24 240 c_grdf[*] file rdf.argon mode vector\n", "\n", "thermo_style custom step time temp pe ke etotal press\n", "thermo_modify format float %20.13g\n", "thermo 1\n", "\n", "run 240\n", "\n" ] } ], "source": [ "from ase import Atoms\n", "import ase.io\n", "\n", "RUN = \"runs/mdi_argon_lammps\"\n", "os.makedirs(RUN, exist_ok=True)\n", "\n", "s0 = test_structs[0]\n", "at = Atoms(numbers=s0[\"atomic_numbers\"], positions=s0[\"pos\"], cell=s0[\"cell\"], pbc=True)\n", "at.wrap()\n", "ase.io.write(f\"{RUN}/data.argon\", at, format=\"lammps-data\", masses=True)\n", "\n", "N_STEPS = 240\n", "IN_ARGON = f'''\\\n", "# Liquid argon NVE; energy/forces/stress from an xnn model over MDI\n", "units metal\n", "atom_style atomic\n", "atom_modify map array\n", "comm_modify cutoff 10.0\n", "\n", "read_data data.argon\n", "mass 1 39.948\n", "\n", "velocity all create 170.0 87287 mom yes\n", "\n", "timestep 0.005 # metal units (ps) -> 5 fs\n", "\n", "fix integrate all nve\n", "fix qm all mdi/qm virial yes elements Ar\n", "\n", "compute grdf all rdf 100 cutoff 8.0\n", "fix rdf all ave/time 10 24 {N_STEPS} c_grdf[*] file rdf.argon mode vector\n", "\n", "thermo_style custom step time temp pe ke etotal press\n", "thermo_modify format float %20.13g\n", "thermo 1\n", "\n", "run {N_STEPS}\n", "'''\n", "open(f\"{RUN}/in.argon\", \"w\").write(IN_ARGON)\n", "print(IN_ARGON)" ] }, { "cell_type": "markdown", "id": "1eb18529", "metadata": {}, "source": [ "## 3. Run: LAMMPS driver + xnn engine\n", "\n", "Exactly the two commands from the companion notebook's closing section, with TCP instead\n", "of MPI so a plain serial `lmp` works: the LAMMPS **driver initializes first** (it owns\n", "the listening socket), then the engine connects. LAMMPS sends `EXIT` to the engine when\n", "it shuts down.\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "3813e76f", "metadata": { "execution": { "iopub.execute_input": "2026-08-10T13:55:33.533729Z", "iopub.status.busy": "2026-08-10T13:55:33.533514Z", "iopub.status.idle": "2026-08-10T13:56:56.059569Z", "shell.execute_reply": "2026-08-10T13:56:56.058634Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "finished in 83 s | lammps exit 0 | engine exit 0\n" ] } ], "source": [ "PORT = 8021\n", "\n", "lmp_proc = subprocess.Popen(\n", " [LMP, \"-mdi\", f\"-role DRIVER -name LAMMPS -method TCP -port {PORT}\",\n", " \"-in\", \"in.argon\", \"-log\", \"log.argon\"],\n", " cwd=RUN, stdout=open(f\"{RUN}/lmp_screen.out\", \"w\"), stderr=subprocess.STDOUT)\n", "\n", "engine_proc = subprocess.Popen(\n", " [sys.executable, \"-W\", \"ignore\", \"-m\", \"xnn.common.deploy.mdi_engine\",\n", " \"--ckpt\", os.path.abspath(CKPT), \"--device\", DEVICE, \"--dtype\", \"float64\",\n", " \"-mdi\", f\"-role ENGINE -name xnn -method TCP -port {PORT} -hostname localhost\"],\n", " stdout=open(f\"{RUN}/engine.log\", \"w\"), stderr=subprocess.STDOUT)\n", "\n", "t0 = time.time()\n", "lmp_rc = lmp_proc.wait(timeout=1500)\n", "try:\n", " eng_rc = engine_proc.wait(timeout=120)\n", "except subprocess.TimeoutExpired:\n", " engine_proc.kill()\n", " eng_rc = \"killed (driver never connected?)\"\n", "print(f\"finished in {time.time()-t0:.0f} s | lammps exit {lmp_rc} | engine exit {eng_rc}\")\n", "assert lmp_rc == 0 and eng_rc == 0" ] }, { "cell_type": "markdown", "id": "ac484ba5", "metadata": {}, "source": [ "## 4. Thermodynamics from the LAMMPS log\n", "\n", "The thermo table is parsed straight out of `log.argon`; nothing on the analysis side\n", "knows or cares that the forces came from a neural network in another process.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "70bc23f3", "metadata": { "execution": { "iopub.execute_input": "2026-08-10T13:56:56.062477Z", "iopub.status.busy": "2026-08-10T13:56:56.062262Z", "iopub.status.idle": "2026-08-10T13:56:56.482748Z", "shell.execute_reply": "2026-08-10T13:56:56.482058Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAEsCAYAAAB+LHq4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAl6FJREFUeJzs3Xd0k9UbB/BvRpvupHtPoAM6WIWy95IhUzaIgCCiKIKAA0T5iQoKKjiQKYIsQfbeu4xSKKO0pZPumc60Se7vj9JI6ErapOl4PudwDn1z75vnvmnz5sldHMYYAyGEEEIIIYSQRoGr6wAIIYQQQgghhGgOJXmEEEIIIYQQ0ohQkkcIIYQQQgghjQgleYQQQgghhBDSiFCSRwghhBBCCCGNCCV5hBBCCCGEENKIUJJHCCGEEEIIIY0IJXmEEEIIIYQQ0ohQkkcIIYQQQgghjQgleYSQKnXt2hU9e/bUaQwDBgzA1KlTdRpDY7d69WpwOBykp6frOhSNGzFiBEaPHq3rMEgDYmdnhxkzZug6DEIIqTFK8mrgt99+A4fDgb6+PqKioso9Pm7cOBgYGCh+7t27N0xMTJCbm1vpOT/55BNwOBzcunVL6Tkq+7du3TrNN4w0We3bt0ffvn11HUaFjh07hnPnzmHp0qVKx4cMGaL0d1ad3bt3g8PhwNLSEkVFRRWW2bdvn+JvbMeOHRWWGTVqlKKMNupyOBzweDzY2tpi5MiRCA0NVSp769YtjBo1Cq6urjA0NISnpycmT56My5cvV3sN1q1bBw6Hg4SEhGrLNiZffvkl9u/fj0uXLuk6FEIURCIRZs+e3WifryGia1Q1uj4NCyV5tVBSUoIlS5ZUW27mzJnIz8/H7t27K3xcJpNh27ZtCAgIQGBgoNJjp0+fBmOs3L+5c+dqpA2EVOfKlSu4cOGCzp7/66+/xmuvvYZmzZrV6jwbN26Eo6MjMjMzsX///irLGhsbY+vWreWOZ2Rk4MiRIzA2NtZK3b///huMMRQWFuLAgQN4+PAhunbtioiICADA0aNH0alTJ8hkMhw5ckTRFqlUiu7duyM5ObnKdjVVfn5+6N69O1auXKnrUEgDkZycjI0bN+o6DEIIqTFK8mph0KBB2Lt3L27evFlluZEjR8LCwgKbNm2q8PGjR48iMTERM2fO1EaYhDRYYWFhuHr1KiZPnlyr80RHR+Ps2bP44osv0LlzZ/zxxx9Vlh85ciTOnTuH+Ph4peM7duyAnp4eBg4cqJW6ZfT19dG5c2esWbMGeXl5ig+b3377LYyNjbFnzx74+fnB0NAQvr6++Pvvv7FmzRpwufSWXplJkybh5MmTiI6O1nUohBBCiNbRJ4Ja+Oijj2Bvb4+FCxdWWU4gEGDy5Mm4ceMGHj58WO7xTZs2wdDQEBMnTtRofJGRkZg4cSJsbW2hr6+PFi1a4JtvvoFcLleUWbx4MTgcDoqKivDuu+/C0tISpqamGDNmTIVzc9Q5Z35+PmbPng1ra2vY29sDAORyOb766iu4uLjA0NAQXbp0wZ07dzBu3Di4ubkpzjFmzBhYWVlVOKxu4sSJEIlEKCwsrLL9x44dQ58+fSASiSAUCtGnT59yQ9p+//13BAQEwMDAACKRCEOGDEFISIhSGV9fXwwZMgQRERHo168fjIyM4ODggOXLl4MxplT24sWL6NOnD6ysrCAUChEUFIQdO3aUK3fs2DH07NkTZmZmMDQ0RKdOnXDixIkKn/fRo0fo168fTExMMGPGDIwYMQI2NjYoKSkp1+YpU6YoXZvRo0crDQG0trbGyJEj8eTJE0UdKysr3LlzB2fPnlWUdXJyUjxe2Zw8TV+7ihw+fBgA0KtXr2rLVmXjxo0QCoWYMGEC5syZg4sXLyIyMrLS8q+//jqEQiH+/PNPpeNbtmzBmDFjYGJiopW6r/L29gYARcKYmZkJKysr6Ovrlyv7wQcfwMbGptJzLViwAO+99x4AwNnZWfFanzlzRqmcVCrFokWLYGNjA2NjYwwZMqTC4Z0JCQmYPn06HBwcoK+vD3d3d3z++ecoLi5WlCmb55eYmIgFCxbAzs4Oenp6AICePXsiKCgI0dHRGDBgAExMTNCsWTPs3bsXQOl7zaBBg2BiYgJHR8dKh6jv3LkT7du3h5GREczMzNCvXz9cvXq1XLnevXuDMYYjR45Ueo0IKVPRnDwDAwN88MEHuHHjBoKCgmBgYAAPD48KvzTat28fgoKCIBKJYGlpid69e+PkyZMAgOzsbHA4HOTk5OD3339X/C2+/D7bunVrxXE+nw9HR0e8+eabSEpKUjumun6+l23duhWBgYEwMjKCqakp+vfvj9u3byuVkUqlWLFiBby8vCAQCGBtbY0JEyYofSGTnp4ODoeD1atXl3uO1q1bl/vyrKrrXxFVrpGq7Sm7RhcuXEC7du1gZGSEwMBA3L17FwBw7tw5BAYGwtDQED4+Pjh9+nS5eMrOcf78ebRt2xYGBgZo0aIFfv311xpf57JzXrp0SfHaffPNN4prWNXrX931Uff1qSqWrKwsfPjhh3Bzc4O+vj4cHBwwd+5ciMXiCttOqsCI2n799VcGgF2/fp1t2LCBAWD//vuv4vGxY8cygUCgVCcsLIwBYB9++KHS8cTERMbn89nkyZMrfI7Tp0/XKMawsDAmFApZ3759WWhoKMvNzWWHDx9mVlZWbNasWYpyixYtYgDYO++8w/755x+Wk5PDLl68yCwtLdnYsWNrdc4333yT7d27l2VmZrKNGzcyxhibN28eEwgEbMOGDSwrK4uFhYWxwYMHsx49ejBXV1fFOc6fP88AsG3btinFkJqayvT19dns2bOrbP/PP//MOBwOmzdvHouIiGA5OTns3LlzbOTIkYoyS5YsYTwej61evZqlp6ez8PBwNnDgQGZoaMhu376tKNeqVSvWpUsXNmLECHb37l2Wk5PD1q5dywCw7du3K8pFR0czQ0ND9u6777LExESWn5/Pbt++zSZPnszCw8MV5X799VfG4XDYJ598wuLi4lh6ejr7+uuvGZfLZQcPHlR63s6dO7OBAweyO3fusJSUFLZ792525MgRBoDt27dPqc05OTnMyMiIvfPOOxVeE4lEwkJDQ1n//v2Zi4sLy87OVjzWrl071qdPnwrrdenShfXo0UPpmKavXWVee+015u7uXuFjgwcPLvd3VhGpVMocHBzYvHnzGGOl18Ha2potWrSoXNm9e/cyAOzw4cNszpw5rEWLForHQkJCGAB24cIFNnXqVPbq26cm6v79999Kx48dO8YAsI8//pgxxtisWbMYALZhwwYml8urbfurfv75ZwaAxcfHl3ts1apVDACbPn06+/PPP1l2djYLDg5mTk5O5X43YmJimK2tLevUqRO7desWy8vLY2fPnmVOTk5s1KhR5c45YcIEtmXLFpaZmcl+//13xhhjPXr0YP7+/mzEiBHs9u3bLDs7m3366aeMx+OxCxcusAEDBrDg4GCWnZ3Nli1bxgCwK1euKMXx/fffMwBs6dKlLCUlhUVFRbGxY8cyPp/Pzpw5U66NVlZWbPTo0WpfN9L02NrasunTpysdEwgEbPDgwWzs2LEsPDycZWRksPnz5ys+D5S5dOkS43A47JtvvmHp6eksJyeHXbp0iQ0aNIhJpVJFOaFQqHTvrExBQQG7du0aa926NevQoYPSOVSNSRfPt2DBAiYQCNiPP/7IUlJS2PPnz9mcOXOYgYEBu3v3rqLcmDFjmJGRkeJ95+7du6xNmzbMxsZG8V6VlpbGALBVq1aVizcgIIANGDBA8bOq178iVV0jVdsjEAjYoEGD2Pjx49mzZ89YSkoKGzJkCLOxsWGXL19mY8aMYZGRkSw1NZUNHz6cmZqasqysLKXnEggEbODAgWz48OHs6dOnLC0tjX399deMw+GwH374oVZxDR8+nD158oTFxsayw4cPl2tnVa9/ZddHndenqliys7OZt7c38/b2ZufOnWO5ubns1q1bzNfXlwUFBbGSkpIKXxtSMUryauDlJE8qlbKWLVsyb29vxS9fRUkeY4wFBQUxKysrJpFIFMe+/vprBoBdunSpwueo7N+DBw+qjLFfv37M0dGR5eXlKR3fuHEj43A47OnTp4yx/xKyDRs2KJX7/PPPGZfLVXrjUfecP/74o1K5hIQExuPxKkx0BQKBUpLHGGMtW7ZkQUFBSsdWrlzJALBbt25V2va0tDRmaGjI3njjjUrLPH/+nPH5fPbWW28pHc/NzWWWlpZKH2pbtWrF9PT0WExMjFLZNm3asG7duil+3rVrFwOglNC9KiMjgxkbG7OJEyeWe2z48OHMy8tL6Xm5XK7iupaRSqXM0dGRDRo0SOn4b7/9xgAoJVkVSUhIYADYrl27FMfUSfK0ce0q4+vryzp37lzhY6omeQcPHmQA2JMnTxTHFi9ezGxtbcvdMF5O1IKDg5USi/fff595eHgwuVxebZJX07plSV5xcTG7fv068/b2ZsbGxorfqczMTNavXz8GgFlbW7Phw4ezL7/8kgUHB1d7HRhTLcn7+uuvlY7/+OOPDACLiopSHBs/fjwTiUQsLS1Nqey///6r9GGv7Jyff/55uefr0aMH43A4Su9lxcXFzNLSkpmYmLCQkBDFcalUyqytrdm0adMUx8RiMTMxMWHDhg1TOm9JSQlzc3NjAQEB5Z7T19eXBQYGVnBlCFFWWZJnbW2tdA+USCTM0tJS6XdzxYoVjMvlVvuBVNWkq8yFCxfKvcerGlNdP19YWBjjcDhs2bJlSueUy+XM39+fDR48mDHG2LVr1yp834mOjmZ8Pl8RrzpJhKrXvyKVXSNV28NY6TWysbFh+fn5imOPHj1iAJirq6vStQsPD2cAFF9+vXwOkUjExGKx0vHRo0czMzMzxTnUjcvMzKzcOStT0euvySSvoljKvkB+/Pix0vHQ0NAKvwglVaPhmrXE4/Hw7bff4smTJ9VO0p45cybS09Nx8OBBxbHNmzfDy8sL3bp1q7BOZQuv+Pr6Vvo8+fn5OHfuHAYNGlRukYe+ffuCMVZulbnBgwcr/ezr6wu5XI6YmJgan3PYsGFKP1+6dAkymQxDhw5VOm5vb4927dqVa8ecOXNw48YNxRBAuVyO33//Hf7+/mjfvn2l7T9//jwKCwsxYcKESstcunQJUqkUI0eOVDpuYmKCgQMHKh4v4+vrC1dXV6Wyvr6+ePbsmdLPXC4Xb7/9No4fP478/PwKY8vPz8eYMWPKPda3b1+Eh4cjJSVFcczHxwctWrRQKsfj8fDmm2/i1KlTeP78ueL45s2bERAQoHQt4+LiMG3aNDg7O0NPT09pKGZVwxWroo1rV5ns7GyYmprWKM4yf/zxB/r06QMvLy/FsdmzZyMtLU0xHLQigYGBaNWqFbZu3Yri4mLs3LkTb775ZrmVMTVZd/z48eBwOBAIBBg6dCi8vLxw+fJleHp6AgDMzc1x6tQpPH78GMuXL4e9vT22b9+ODh064LXXXkNeXp6KV6VyFb0XAFB6vQ4fPoyePXvCyspKqWyfPn0AlA5bftmr7wVlnJyclN7L9PT00KxZM5iamqJ169aK4zweDy1atFCK4ebNm8jLyyv3e8jn8/H6668jNDQUGRkZSo+ZmZkhOzu7wlgIUUXPnj2V7oH6+vrw9PRU+t0MCAiAXC7H+PHjcenSJaUhzKq6f/8+Ro0aBTs7O/D5fKWhca++d6sSU10/35EjR8AYK3ev43A46N27t+I94uzZswBQ7u/Yzc0N7dq1UzyuDk1c/1ep2p4yPXr0gJGRkeJnT09PcLlctG3bVunatWjRAnw+v8LXqlevXuXuf8OHD4dYLFYMxVQ3rorOCaj3+mtKRbEcPnwYfn5+iqkKZfz9/WFlZVWuPaRqlORpwJAhQ9CzZ0988cUXVX7IGjt2LExNTRULsFy4cAGRkZEa34snPT0dMpkMmzZtAp/PB4/HA4/HA5fLVcx7e/XDT9mcuTJmZmYAoPhAVJNzOjo6Kv1c9nhF84YqOjZlyhSYmJgoxqAfP34cMTExmD59epXtT01NrfD5K4rFzs6u3GN2dnYoKSlBTk6O4tir1wco/4GxVatWOHDgAIqKijBkyBCIRCJ06dJFaW5W2eqHo0aNUlxHLpcLLperWDH15etYWRumT58OuVyuWMXx4cOHCA4OVro2BQUF6NatG+7du4c9e/YgMzMTcrlcEXNFc/pUoY1rVxmRSFSrcfiJiYk4fvy40nxDDocDNzc3yOXyahdgmTp1Kvbs2YPdu3cjIyMDU6ZMUfm5a1K3bHVNuVyOtLQ0/Pvvv2jTpk25ct7e3njnnXfwyy+/4OnTp/j2229x/PhxLFu2TOX4KlPde0F+fj7y8vJw8ODBcu8FZTfs6t4LKnsuADA1Na30+Mu/M9X9HgIoN69YLBbD3Ny8wlgIUYUq72dDhgzBhg0b8PjxY/To0QNCoRD9+/cvN++6MvHx8ejatSvy8vJw8uRJ5ObmgjGm+GD/6nt3bd5jtfV8Zfe6gICAcve6tWvXIi8vD8XFxdX+Hauybyd7ZX53ba9/RVRtT5lXrxGPx4OhoWG54xwOB8bGxhW+Vra2tpUeK7su6sZV0Xuxuq+/ul59faqKJTk5GaGhoeDz+UrtKdvD9dV7C6kaJXkasmrVKqSmplY46bSMsbExxo8fj9OnTyMuLg4bN26Enp6exjd5trCwAJfLxbx58yCVSiGTySCTySCXyxU9gR9//LFSnep6GGpyzrIFFspYWloC+C8Je1lFx0xNTTF58mTs3LkTOTk5+OWXXyAQCDBp0qQqY7W2tgYApV6uitoDQKnXrExKSgr09PQgFAoVx1TpvQFKeyxu3LiBjIwMHDx4ENbW1pg6daoiGSvr+Th58qTiOsrlcqXr2LJlS8X5Xr2GZdzd3dGrVy9s2bIFjDFs2rQJAoFAafGeCxcuIC4uDt9++y06deoEU1NTcDicWq8uqK1rVxFXV9dabQuwefNm2NvbV9gbfv78eZw8ebLcKpgvmzx5MvLz8zFv3jz07t27XI9kVWpTV10LFy6EoaGhSnvlVae618vIyEixUFRl7wXfffedUp3Kfo8rey5Vfmeq+z0EUK6nMSkpSauvA2n8VH0/mzlzJsLCwpCSkoLt27ejsLAQr732mkp/owcOHEBubi5+/fVXBAQEwNDQEAAqfe+uzXustp6v7G8vKiqq0nudvr5+tX/HZecxMzMDh8OpcL/hiu71tbn+tWlPmdq8t5Wp6r2t7POUunFV9F6s7utfEXVfn8pisbKyQpcuXSCVSpXaU9aWPXv2qBwToSRPY9q3b4+xY8di9erVVX4onTlzJuRyOdasWYP9+/fj9ddfVyQlmmJqaooePXrg8OHD1a5AWZfn7N69O3g8Ho4ePap0PDk5GXfu3Kmwzpw5c5Cfn4/ly5fjxIkTGD58uOKmUJnevXvD0NAQO3furLRMjx49wOfzceDAAaXj+fn5OHHiBLp37w4+n69iy8oTiUR47bXXsH//fggEAsVQ1j59+sDQ0LDSPRPVMWPGDERFReH06dPYvn07RowYUeG1EQgESj+/uuojUPoFhEQiUel5tX3tXta1a1dER0fX6Ns7xhg2b95c6ZYFXbp0gYmJCTZv3lzpOezs7DBw4EBkZWXhzTffVOv5a1O3MkuWLKlwtEBGRgaKioogEomqrF82TEjV17oiHA4HQ4YMwenTp5GVlVXj89RWx44dYWxsXO73UCqV4tChQwgICFB8EAJKh5tmZGRUOjSeEG2wsbHB6NGjsX37djDGlJKM6t53VXnvVkddPt+QIUMAoNp7XdkQ71f/jmNjY3Hnzh3F4/r6+nByckJYWJhSubIvVStT1fWvSGXXSNX2aNKFCxfKvd8fPHgQpqamij2VNRlXbT4r1PT1edXQoUNx69Yt2upGQyjJ06Cvv/4aJSUlVY4Zbt++PVq3bo0ff/wRhYWFWtsb7+eff0ZmZiaGDRuGmzdvIj8/H4mJiTh27Bhee+01xMbG1vk5HR0dMXfuXKxbtw6bNm1CdnY2Hj16hFmzZiEoKKjCOr6+vujevTvWrFkDuVxe7VBNoPSboO+++w579+7Fhx9+iKioKOTm5uLChQsYNWoUAMDBwQHz58/Hli1bsGbNGmRmZiIiIgJjx45FXl5ejTZN/v333zFv3jzcunULubm5yM7Oxvr16yGRSBRbAFhZWWHNmjXYtGkTPv74Y0RFRaGwsBARERH4448/MHr0aJWfr2z/xRkzZiA9Pb3ctenUqROsrKywbNkyxMTEICMjA2vXri23JDZQep3DwsIQGRlZ7dYG2rh2lSm7gZ0/f17tumfOnEF0dHSlSZ6enh769OmDzZs3K20B8qqyOQ/V9SBrum5FDh8+DF9fX2zduhXp6enIz8/HjRs3MHLkSHC5XMyfP7/K+mXz344ePVqreSrfffcduFwuBg8ejMuXLyM3NxcpKSk4c+YMRo0aVW4rDW0wMzPDsmXLcPDgQXz55ZdITU1FTEwMpkyZgri4OKxatUqp/Llz5xQJKiHa9Pnnn2PZsmW4f/8+CgoKkJqail9++QUcDgc9evRQlPP19cXNmzfLvScPGDAA+vr6WLBgAVJTU5GYmIhFixaV+xCurrp8voCAACxcuBBLly7FqlWrEBcXh8LCQjx8+BCrV69WTE/o3LkzRo4ciRUrVihG7dy7dw+jR4+GUCjEp59+qjjnzJkzcfjwYezduxd5eXm4fPkyVq1aBR8fH6XnVvX6q3ONVG2PJnXo0AFTp05FZGQkMjIy8N133+Gff/7B0qVLFV/YaSIudV7/yq4PoPrrU5VPPvkEzZo1w+DBg3H8+HFkZWUhIyMDV65cwVtvvVXlPHpSHiV5GuTu7o5333232nIzZ84EYwyurq7o27dvlWX79eunNJeo7F91f7itWrVCSEgI3NzcMGbMGJibm6Njx4747bff8P7779doyJImzvnDDz/gk08+wRdffAF7e3vMmDEDS5cuhbm5eaU3lLJr6urqqvhWrzpz587FoUOHEBISgtatW8PFxQUrVqzABx98oCjz7bff4ueff8aWLVtgb2+P9u3bQy6X48qVK4pvydQxadIktGjRAu+99x4cHR3h4eGBXbt2YceOHUqbec+aNQunT59GWFgYOnToAAsLCwwdOhQhISH43//+p/LzlQ3PjI+Ph5ubW7lrY25ujmPHjkEul8PX1xetWrVCTEwMfvvtt3Ln+uyzz9CxY0e0adMGXC5XaZ+8imj62lXG19cXXbt2xfbt2yt8XCKRVPj3weFw8Mcff4DH41X5NzZo0CDExcVVuX9SfXLkyBFMnz4dv/32G7y9vSESiTBq1ChYW1vj0qVL1W60HhgYiKVLl+Lbb7+FoaFhhfvkqcLNzQ13795F27ZtMWXKFFhaWqJt27b4/vvvMXnyZAQEBNS0iWpZuHAhtm3bhoMHD8LV1RV+fn5ISUnB2bNn0a9fP6Wyf/31FwYMGAB3d/c6iY00XfPmzYO+vj6mTp0Ka2tr+Pr64t69ezh58iS6dOmiKPf9999DJBKhWbNmSgtdeHl54d9//0V4eDjc3NzQqVMnCIVCLF26tFZx1fXzfffdd9i2bRuOHDkCX19fWFlZYdy4ccjIyMCSJUsU5Xbt2oWFCxdi2bJlsLa2Rt++fdGsWTPcuHEDzs7OinKLFi3CrFmz8M4778DOzg7ff/891q9fX27fUFWvvzrXSJ32aErZ3OvRo0fD0dERGzZswE8//YQFCxYolattXOq8/lVdH1Vfn6qIRCJcv34dw4cPx4cffgg7Ozv4+Pjgs88+Q48ePTBgwACVz0UADqvua3tC6kDZJp4V9YKeOHECgwYNwhdffKGRhSVIw3LixAkMHToUT548QbNmzXQdDmmAHjx4gICAAFy4cAHdu3fXdTiEEFIlAwMDzJ49G2vXrtV1KKQBo548onPPnj3DvXv3Kh1GsXv3bvB4PEybNq2OIyP1wcCBA9GnTx8sX75c16GQBmrZsmUYOXIkJXiEEEKaDM2sjkCIik6ePImbN29i/PjxcHBwQGhoKObMmQMLC4sKh7revn0bu3fvxuTJk+Hi4qKDiEl9UJulrwnZv3+/rkMghBBC6hT15JE61aNHDzDGMHz4cFhZWeH111+Hl5cXrl69qrQnTFFRkWKSdL9+/bBmzRodRk0IIYQQQkjDQXPyCCGEEEIIIaQRoZ48QgghhBBCCGlEKMkjhBBCCCGEkEaEFl6pBblcjsTERJiamoLD4eg6HEIIIZVgjCE3NxcODg7gcun7zVfR/YwQQhoGVe9nlOTVQmJiotJGnYQQQuq3+Ph4ODk56TqMeofuZ4QQ0rBUdz+jJK8WTE1NAZReZDMzMx1HQwghpDJisRjOzs6K922ijO5nhBDSMKh6P6MkrxbKhrSYmZnRTZEQQhoAGopYMbqfEUJIw1Ld/YwmJhBCCCGEEEJII0JJHiGEEEIIIYQ0IpTkEUIIIYQQQkgjQkkeIYQQQgghhDQilOQRQgghhBBCSCNCSR4hhBBCaoUxpusQCCGEvISSvCbockQa5u+5h/jMAl2HQgghpBHYfDUG7+64i2dpeboOhRBCCGifvCbn57MR+P70UwAAY8Casa11GxAhhJAG73GSGEcfJOHEw2Ssn9AGA33tdR0SIYQ0adST14QwxrDjZhwcRYZo6yLCodBEJGRRbx4hhJDaWT0mAHtnd4LIUA8f77uPxOxCXYdECCFNGiV5TcjjpFwki4sw0NcO8/p6QiZn2HwlRtdhEUIIaQQC3Szw3Wh/iIuk+PzfMF2HQwghTRoleU3I+fBUAEAvLxt0b2EFV0sjnHmcouOoCCGENBZ9fGwxsJUdzj5JRURKrq7DIYSQJouSvCbk/JNUGOnzEOhuDg6Hg/auFojLLEB6nkTXoRFCCGkkZnRzBwBsuRaj20AIIaQJoySviciXSHE3LgtdmltBwOcBANq4iAAA9+KydRcYIYSQRqWdqzn8nYTYfzcBOQUlug6HEEKaJErymoiotDzIGeDvKFQcK0vyQuKzdBQVIYSQxobD4WBCBxcUlchpSgAhhOgIJXlNRGRq6d5FzWxMFMe8bE1hpM9DCPXkEUII0aB+LW3B5QAnHybrOhRCCGmSKMlrIsqSvOYvJXl8Hhf+TkKExmdDJme6Co0QQkgjY2kiQKCbBS4+TUNBsVTX4RBCSJNDSV4TEZWWBx6XA1dLI6XjAc4i5BfLEJ2ep6PICCGENEYDWtlBIpXj0tM0XYdCCCFNDiV5TURkah5cLIwUi66UaWFj+uLxfF2ERQghpJHq19IWAHD+CSV5hBBS1yjJawJKZHLEZhSgmbVJuceaWRsDAJ5RTx4hhBANcrYwgouFEW5GZ+g6FEIIaXIoyWsCYjMKIJUzpfl4ZTxeJH5R1JNHCCFEw4I8LBCTUYCknEJdh0IIIU0KJXlNgGJlzRe9di8TGurBykRAPXmEEEI0LsjDEgBw81mmjiMhhJCmha/rADIyMrBnzx6kpKTAz88PI0aMAJdbde6pSh1VyoSHh+PkyZPIysqCi4sLRo0aBTMzM423UddiMkp76TwqGK5ZetwYT5LEYIyBw+HUZWiEENLkFRcXIzMzExYWFtDX16+0XGFhIXg8XqVlpFIp8vLyIBKJtBSp+jq+SPJuPMvA8DaOOo6GEEKaDp325EVHR8PPzw+7d+9Gfn4+PvroIwwdOhRyubxWdVQps2XLFvj5+eHOnTuQy+XYtGkTmjdvjsjISK22WReSskuHyTiKDCt8vJm1CcRFUmTkF9dlWIQQ0qTFxsZi8eLFcHFxgb29Pa5du1ZhueDgYHTu3Bnm5uZwcHDA7NmzkZ//3xB7xhgWLVoEoVAIe3t7uLi44NChQ3XVjCo5igzhYmGEG89oXh4hhNQlnSZ5ixYtgpubG86ePYtVq1bh3LlzOHXqFHbv3l2rOqqU+e677/D2229j27ZtWL58OS5cuAAjIyNs3rxZq23WhcScIvC4HFibCip8vGwYZ1QqDdkkhJC6smfPHgiFQhw7dqzSMmFhYejVqxd69uyJ7OxspKSkIDAwEI8fP1aUWbNmDTZs2ICLFy8iLy8PH3zwAUaPHo3w8PC6aEa12ruaIyajAFn0RSIhhNQZnSV5UqkUhw8fxqRJk8DjlS7r7+HhgR49emD//v01rqPqeS0sLFBSUqL4WS6XQyqVwsLCQivt1aXknCLYmgrA41Y8FLNs1c1n6bT4CiGE1JWFCxdiyZIlsLGxqbTMZ599Bj8/P3z99dcwMDAAj8fD9OnT0b59e0WZn3/+GTNmzED79u3B4/Ewf/58ODk54ffff6+LZlTL30kIALj/PEfHkRBCSNOhsyQvLi4ORUVFaN68udLx5s2b4+nTpzWuo+p5N23ahCdPnmDEiBH44IMP0K1bNwwdOhRz586tNGaJRAKxWKz0ryFIyimEfSVDNQHA3aq0Jy+akjxCCKk3pFIpTp06hdGjRwMAcnLKJ0lpaWmIiYlB165dlY5369YNwcHBdRJndfydRQCA+/HZOo2DEEKaEp0leWXzCV5d6EQoFCrNNVC3jqrnTUhIQGxsLIyMjGBmZgYej4cnT55UeBMts3LlSgiFQsU/Z2dnVZqqUxKpDOl5xbAXGlRaxkFkCC4HSMgqqMPICCGEVCUtLQ2FhYUQi8Vo0aIFnJ2dYWJigjlz5qCwsFBRBgCsrKyU6lpbWyM1NbXSc9fll5Yt7c3A53IQmpCttecghBCiTGdJnolJ6RDBV5Oq7OxsxWM1qaNKmeLiYowbNw5vvfUWduzYgS+//BJXrlyBWCzGokWLKo15yZIlyMnJUfyLj49Xtbk6k5IjAYAqkzx9Phd2ZgaIz6R9jAghpL4oW+34119/xf79+yEWixEcHIz9+/fjs88+UyojlUqV6kqlUsWUhYrU5ZeWBno8eNmZIjQhB4wxrT0PIYSQ/+gsyXNxcYGxsXG5ieHh4eHw8fGpcR1VyqSkpCAjIwNBQUGKx7lcLjp06ICwsLBKYxYIBDAzM1P6V98lvtiA1l5Y+XBNAHAyN6KePEIIqUesrKwgEAgwYcIE+Pn5AQBatmyJqVOn4ujRowAABwcHAKX3tZelpKQoHqtIXX9p6e8kQlquBMniIq0+DyGEkFI6S/J4PB5GjBiBP//8E8XFpStuPXr0CFeuXMGYMWMU5fbv34+1a9eqXEeVMo6OjjAzM8P58+cVzyOVSnHlypVKE8yGKulFkucgqrwnDwCcLAyRVVCCPIm0ynKEEELqBp/PR9euXctNYcjLy4ORkRGA0qkIAQEBOH36tOJxqVSKs2fPonv37pWeu66/tAx4sfjKgwRafIUQQuqCTjdD/+abb9CtWzd06tQJ7dq1w6FDhzB69GiMGDFCUebYsWO4ceMGPvjgA5XrVFeGy+Vi/fr1mDlzJh48eAAPDw+cP38eOTk5+PLLL+v0GmhbYnbpt6Z2KvTkAaXz8rzt6n8PJSGENHSFhYXIyclRzKvLzMxEcnIyTExMFNMLPv/8cwwePBg9evRAly5dcPPmTWzduhWrV69WnOezzz7DhAkTEBQUhE6dOmH16tWQy+V45513dNKuivjYl95XniTnon8rOx1HQwghjZ9OkzxHR0fcv38fhw4dQkpKCt544w307dtXqcyoUaPQqVMnteqoUmbSpEno2bMnLly4gIyMDPTu3RsDBw6EgUHVPV4NTXJOaZLnUMWcPABwNi9NAuMzCynJI4SQOnDo0CHMmzcPAGBra4s5c+YAABYsWIAFCxYAAHr06IF9+/Zh5cqV+Pzzz+Hi4oJff/0VU6ZMUZxn9OjRkEgk+PHHH/Hll1/Cz88PFy5cqHJrhrrmaWsKDgd4ktwwVqUmhJCGjsNoFnSNicViCIVC5OTk1Nv5eTO23cKF8DSErxhU6T55AHA9KgPj/7iBZUNbYloX9zqMkBBCtK8hvF/rUl1cn16rL4DDAc591FMr5yeEkKZA1fdrnc3JI3UjKacItmYGVSZ4AOBs8V9PHiGEEKJp3namiEnPR1GJTNehEEJIo0dJXiOXliuBtamg2nJ2LxJBWmGTEEKINnjZmULOgIiUPF2HQgghjR4leY2YXM6QkV8MK5Pqkzw+jwsHkQHis6gnjxBCiOaVzfd+TPPyCCFE6yjJa8SyC0sgkzNYm+qrVN5RZIjn1JNHCCFEC3zsTQEAT5JydRwJIYQ0fpTkNWLpeRIAUKknDwAchIYQF0mRT3vlEUII0TBncyMY6vHwNIWSPEII0TZK8hqx9Fz1kjz7Fxuml22gTgghhGgKl8uBh7UxnqXRnDxCCNE2SvIasbQXPXmqLLwCAPYvNkwv20CdEEII0aRm1iZIzCmiESOEEKJllOQ1Yul5xQDUGK5JPXmEEEK0qLmNCQDgWVq+jiMhhJDGjZK8Ruy/OXmqLbxCPXmEEEK0qZl1aZIXRUM2CSFEqyjJa8QUc/JUHK7p8CLJo548Qggh2tDMxhgAEJlKSR4hhGgTJXmNWHqeBPp8LkwFfJXKmxnyYaTPQ1IO9eQRQgjRPDdLY3A51JNHCCHaRkleI5aeVwxrEwE4HI5K5TkcDuyFBkjMpp48Qgghmmegx4OzhRH15BFCiJZRkteIpedJVJ6PV8ZBZIiknCIwxrQUFSGEkKasmbUJYjLyIZXJdR0KIYQ0WiqN4zt8+DC2bdum8kmHDRuGKVOm1DgoUnuMMWTkFaOlvZla9eyFBigolkFcJIXQUE9L0RFCCGmqPKyMce5JKp5nF8LV0ljX4RBCSKOkUpIXHh6OyMhIBAUFVVs2NDQU9+/fr3VgpHbEhVIUy+Qqb59Qxv6lxVcoySOEEKJpblaliV1MRgEleYQQoiWqrcgBoG/fvli9enW15VavXo3k5ORaBUVqr2wjdCtTdYdrvtgrL7sI3nbq9QISQggh1XF7kdjFpOejh6e1jqMhhJDGSaUkb/z48SgpKVHphOqUJdqTmV+6EbqFcc168hJpGwVCCCFa4GZlBACIyaAN0QkhRFtUSvIcHR1VPqE6ZYn2ZBWUJXnqDbm0F/7Xk0cIIYRomr3QEPo8LmLSKckjhBBtUXm45qsePHiA6OhoFBcXKx338vKCn59frQMjtZP9IskTGak3XNNeRD15hBBCtIfH5cDF0gixGQW6DoUQQhottZO8kpISDBs2DCdOnICxsTH4fOVTvPfee5Tk1QNZBaVDZs3VTPJMBHyYGvCpJ48QQojWuFka4UJ4GqQyOfg82s2JEEI0Te0k79ChQ4rVNps1a6aNmIgGZL2Yk2dupP4KmQ5CQyRRTx4hhBAtcbM0hlSeisTsIrhYGuk6HEIIaXTU/vosOTkZAwYMoASvnsuq4XBNALAXGdCG6IQQQrTG9cU2CtG0+AohhGiF2kleUFAQgoODIZfLtREP0ZCsghLwuByYGag/7dJeaAiJVK5YoZMQQgjRJPeXtlEghBCieWpnAO3atUPPnj3Rt29fjBgxAqampkqP+/r6on379hoLkNRMdkExzI30wOFw1K7rULbCZk4RLNXcTJ0QQgipjrNF6SJfCVm0+AohhGiD2kleTk4ODh06hGfPnuHhw4fQ01Oe8zV79mxK8uqBzPziGg3VBF5aYTO7EL6OQk2GRQghhMBBZAguB4jPpPnfhBCiDWoneQcPHgSXy0VCQgLs7e21ERPRgOyCEnhYG9eo7ss9eYQQQoim6fG4sBcaIp568gghRCvUnpNXXFyM3r17U4JXjzHGkF1YUvuePFphkxBCiJY4mhsiIYvuM4QQog1qJ3nt2rXDtWvXIJVKtREP0QBxkRQyOYNFTZO8sp482iuPEEK0Ti6XIy8vDzKZTKVyxcWVL4pVUlKi6fC0xtncCDmFJRAXNZyYCSGkoVA7yeNyuSgpKUG3bt2watUq/Pbbb0r/bty4oY04iRqyy7ZPMFZ/jzwAMNDjwcJYH8k0XJMQQrQmOTkZK1asgLu7O0xNTXH58uUqy8+bNw+mpqb4+OOPyz321VdfwdLSEgYGBvDx8cGZM2e0FbbGOJm/WHyF5uURQojGqT0n7/bt2yguLkZaWhp+//33co/PmDEDQUFBGgmO1EymYiP0mvXkAaW9eTRckxBCtGfjxo0oLCzEzp070bVr1yrLHjx4EBcvXoS3t3e5x9avX49Vq1bh0KFD6NixI1avXo2hQ4ciLCysXu9p62xRugl6fFYBWjqY6TgaQghpXNRO8qZPn47p06drIxaiIdkFpUNfzI1q1pMHlO6V9zQlF3I5A5er/jYMhBBCqvbZZ58BABISEqosl5CQgDlz5uDEiROYPHlyucfXrl2L6dOno2fPngCAzz//HBs3bsRvv/2GVatWaTxuTXF+0ZMXn0mLrxBCiKapPVzzZUVFRXj27BkKCugNuj7JKqh9T56DyAAlMob0PImmwiKEEKImmUyGCRMmYOHChfDz8yv3eEZGBiIjI9G9e3el4z169Kj30yecXvTk0eIrhBCieWr35AHAkydPMG/ePJw+fRqMMXA4HHTq1Ak//fQT2rVrp9a5IiIisHHjRqSkpMDPzw+zZ8+GsXHVS/+rUkeVMnK5HPv27cO5c+dgZGSEN998E/7+/mrFXx9llfXkGdc8ybN7sfhKYk4RbMwMNBIXIYQQ9SxfvhwGBgaYN29ehY+npKQAAKytrZWOW1tb4+bNm5WeVyKRQCL570s8sVisgWjVY2dmAD0ehzZEJ4QQLVC7J08sFqNXr17gcrk4dOgQ7t27h+PHj8PJyQm9evXC8+fPVT7XvXv30KZNGyQmJiIwMBA7duxA9+7dq1w5TJU6qpQpLi7GoEGDsGTJEnh5ecHLywtvv/02QkND1b0k9U6WYk5ezYdrOghLh9EkZdM3rIQQogvXrl3D+vXrsX79euTn5yMvLw9yuRwlJSXIy8tTKiuXy8v9zOFUPtR+5cqVEAqFin/Ozs5aaUNVeFwOHESGtCE6IYRogdo9eUePHoWLiwuOHj0KLrc0RwwICMCAAQMwZMgQ7N27Fx988IFK51q8eDG6deuG7du3AwDGjh0LFxcXbNmyBbNmzapxHVXKrFq1CsHBwXj8+DHs7OwAAG+99Rby8/PVvST1TtlwzZrukwf8t41CIq2wSQghOhEWFgaJRII2bdoojhUWFuLJkyfYtm0bcnJy4ODgAABITU1VqpuamlrlfrZLlizB/PnzFT+LxWKdJHpO5oa4F5etGBVECCFEM9TuyUtLS4O/v78iwXtZmzZtkJaWptJ5JBIJzp49izFjxiiOWVlZoXfv3jh69GiN66h63j/++AOTJ09WJHgAoKenB5FIpFL89VnZwisiw1r05ImoJ48QQnTp7bffRl5entI/Pz8/zJkzB3l5eeDxeBCJRGjVqhXOnj2rqCeXy3Hu3LkqV+wUCAQwMzNT+qcLzuZGyC+WKaYZEEII0Qy1kzwfHx+cOHGi3LeGYrEY//zzT4XLO1ckLi4OUqkULi4uSsddXV3x7NmzGtdRpUx2djZiY2MRGBiIdevWYdq0afj000/x6NGjKmOWSCQQi8VK/+qjrIJimBnwwefVfF0dWzMDcDhAEvXkEUKIVkilUuTl5SkWLyssLKx2s/OKLF68GFu2bMHu3bsRFxeH999/H4WFhXjnnXe0EbZGKfbKo3l5hBCiUWpnAX379oWXlxd8fHzw9ttvY/ny5ZgzZw48PT1hYGCAN954Q6XzFBWVJg8mJiZKx01MTBSP1aSOKmXK5jJ89tlnuHv3Lrp164b09HS0bt0ap06dqjTm+jCHQRVZBSW1WnQFAPT5XFiZCGivPEII0ZLdu3fDzs4Obdu2hbGxMcaMGQM7OzusXr260jpGRkYQCARKxyZNmoSffvoJy5cvR5s2bRAWFoYzZ84ohnLWZ4q98mheHiGEaJTac/I4HA5OnDiBDRs24PDhw7h+/Trs7e3x0Ucf4b333it386mMUCgEAGRmZiodz8jIqHTIpCp11Cnj7++PzZs3Ayidj5eZmYkvv/wS/fv3r/D568schupk5RfDVlj7FTEdhAZIyqaePEII0YaJEydi4sSJatW5du1ahcfffvttvP3225oIq045mf+3ITohhBDNUbsnr7CwEMXFxZgzZw6OHz+OBw8e4NSpU1i4cCEYYyrvmefs7AyRSISwsDCl4w8ePKhwLyBV66hSxtTUFO7u7uWGlnp7eyMxMbHSmOvLHIbqZBUU12plzTL2QkOk5hZBKpNXX5gQQghRkzMN1ySEEK1QO8lbv349li5dqvZjr+JwOJgwYQI2bdqkmNt25coVBAcHY9KkSYpyGzZswMKFC1Wuo+p5p06diuPHj6OwsHSISFFREY4ePYqgoCB1Lke9U1gsg0Qqr9VG6GXsRQaQMyAllzZEJ4QQonnWpgII+FwarkkIIRpW85U5KlBYWAhDQ0OVy//vf/+Dubk5WrZsif79+2PgwIH4+OOP0adPH0WZ4OBgHD9+XK06qpRZtGgR3Nzc4OnpiWHDhsHLywtcLhc//PBDLa+CbpVtn6CJJI/2yiOEEKJNHA4HjuaGNFyTEEI0TOU5eTdu3MCZM2dw9epV5ObmYsWKFUqP5+fn488//8TatWtVfnKRSIRr167hxo0bSElJwS+//ILmzZsrlZk1axZGjx6tVh1VyhgYGODIkSMICQlBbGwsXFxc0KZNmwa/T0+mBjZCL2Mvor3yCCGEaJezuRFuPMugvfIIIUSDVE7ynj17hiNHjiApKQklJSU4cuSI0uNmZmaYM2cORo0apVYAXC4XnTt3rvTxwMBAteuoWgYo3dvv5Y1mGzrFHnm1XF0TKJ2TBwDJtMImIYQQLXG2MMTFp3Kk5UpgY1b7RcMIIYSokeRNmDABEyZMwIEDB5CVlYW33npLm3GRGvpvuGbte/IcynryaIVNQgghWvLfCpuFlOQRQoiGqL2FwogRI7QRB9GQ7BdJnoUG5uTZmBqAx+UgiXryCCGEaImD6MX875xCAOa6DYYQQhoJtZM8oHT+3S+//IJ79+4hMzMTjDHFY6NHj8aMGTM0FiBRT2b+i+GaGkjyeFwObE0FSKI5eYQQQrTEQVg2aoS+UCSEEE1RO8mTSqXo0qUL9PT0YGBggKKiInh5eeHo0aMwMTHB3LlztREnUZFiuKZx7YdrAoC9yBCxGbTqGSGEEO0o68mjqQGEEKI5am+hcOrUKcjlcty4cQOvv/46evTogb/++gtPnjwBl8uFtbW1NuIkKsrW4BYKAGAnNEB6ngQSqUwj5yOEEEJeZmMqAJdDPXmEEKJJaid5UVFR6N69O3g8HgQCAfLz8wEAtra2mDhxIk6fPq3xIInqsgpKYKDHhYEeTyPnKxtGk5JDG6ITQgjRPD6PCzszA5oaQAghGqR2kieRSGBgUPrB39HREWFhYYrHsrOzIZfLNRcdUVt2QbFGFl0pU7aNQiItvkIIIURLHESG1JNHCCEaVKOFV8r0798fM2bMwBtvvAFzc3Ns3boVFy9e1FRspAYyC4o1suhKmbJtFGiFTUIIIdpiLzLE7dgsFJXINDYShRBCmjK1e/KmTp2K+fPnAwBMTExw4cIFGBoaIjU1Fbt27UJQUJDGgySqy84v0diiKwDgKCrdv+h5FiV5hBBCtOO/LxRpyCYhhGiCyj15YWFh4HA4aNWqldJxf39/bNu2TeOBEfWVyOTIlUg12pPnbFE6XDM+k5I8Qggh2uFQNjUguxDuVsY6joYQQho+lXvyHjx4gI4dO8LDwwPvvfceTp48CYmEFuOoT7ILSvfIMzfSXE+e0FAPpgI+4jJpGwVCCCHa8d82CvSFIiGEaILKSd748eORkZGB9evXQy6XY9asWbCyssKIESOwadMmJCcnazNOooKyPfI0ufAKh8OBs4UR4rMoySOaJZczPE3JxdnHKciTSHUdDiFEh8qGa9JeeYQQohlqLbwiEAgwaNAgDBo0COvXr8eDBw9w5MgRbN68GbNnz0br1q0xZMgQDBkyBG3btgWHw9FW3KQCWfmlSZ4mh2sCpUM2zzzORYlMDj2e2tM4CSknPrMA7+y4g7DnYgCAoR4PH/Zrgbe7N9NxZIRUbNeuXWqVHzdunJYiaZxeHq5JCCGk9mq1uqafnx/8/PywZMkSZGRk4NixYzhy5AjWrFmDOXPm4Ouvv9ZUnEQFWWXDNTW48AoAOJsbQSZnSMougoulkUbPTZqeZ2l5GPXrNWQXlmBiRxe4WxljZ3Acvj72BLlFUnzU30vXIRJSzvjx42FpaalS2YyMDEry1CQy0oOhHo+26yGEEA1ROck7efIkcnNzMWzYMOjrl+8psrS0xOTJkzF58mRIpVKkpaVpNFBSvewC7fTklSV28VkFlOSRWikslmHOjrvIKSzBrxPbYaCvHQBgTDtnTNkSjJ/PRcLPUYj+rex0HCkh5aWnp6tUjkaxqI/D4cBBZEA9eYQQoiEqj71LTk7G2LFj4eTkhI8++giPHj2qtCyfz4e9vb1GAiSqK+vJ0+ScPKC0Jw8oHWJHSG18e+IJniTnYn4/T0WCBwBCIz38PqkdhIZ6WLL/ATLyaFEnUr/MmzdPK2XJfxxEhkjKKQJjTNehEEJIg6dykjd16lTExMTgvffew4EDB9CqVSt07twZmzdvRl5enjZjJCoqW3jFXAtz8gDQ4iukVp4ki/Hn9Ri0dRFhTs/m5R63Exrgy9dbISO/GD+cfqqDCAmp3Nq1ayGVVr9AUEREBNauXav9gBohB6EhCoplyCks0XUohBDS4Km1ioazszM+//xzREVF4cyZM3B3d8e7774Le3t7zJw5Ezdu3NBWnEQFioVXNDwnz+lFT14c7ZVHaogxhi8PPwIDsHyYL7jcioezDQtwQKCbOXbdikdUGn15ROqXGTNmVNnLFBUVhV69etVhRI2L/YsVNp/TkE1CCKm1Gi2VyOFw0KdPH+zYsQNJSUn45ptvcOfOHXTq1AlffPGFhkMkqsoqKAGfy4GpoFbr6ZRjoMeDjamA9spTU55EisjUXBp6BOD6swxci8rAqLZO8HMSVlqOw+FgyWs+kMkZVp0Ir8MICanekSNHsHDhwgofi46ORq9eveDt7V3HUTUeZXvlJdE2CoQQUmu1zgaKi4tRVFSk2Bi9okVZSN3ILiiGyEhPK5P+3ayM8SRJDMYYLSpQDcYYfjobiY2XnyFXIoWLhRFWDPdFd09rXYemMz+eiQCPy8H7vVtUW7atizn6tbTFiYfJeJwkho+9WR1ESEj1jh07hj59+sDKygqLFy9WHI+NjUWvXr3QrFkzHDp0SIcRNmyOZRui0wqbhBBSazXqyZPJZDhy5AhGjhwJJycnrFy5Ev369cODBw/wySefaDpGoqLMgmKNz8cr42FlDHGRFJkvhoSSyv1x+RnWnHkKGzMBJgW5IKugGDP+vI3LEU1zxdng6EzcjM7EiDaOKq/OOq9PaTL487kIbYZWL0hlctx8loGNl5/hz+sxuBaZDqlMruuwSAU6dOiA/fv344svvsDGjRsBAHFxcejVqxecnZ1x5MgRGBnRCsQ1ZS+kDdEJIURT1OrJe/r0KbZs2YJt27YhOTkZffr0wfbt2zF8+HAIBAJtxUhUlF1QgubWJlo5t4e1MQAgOj0flib0WlcmODoTK48/gaetCf55pzNMDfQwLtAFE/64gTk77uLUh91h/2LT36Ziw6Vn4HCAOT1V3+jc11GIvj42OPYgGeHJufCyM9VihLpzPSoDSw+GISJVef6htakAs3s0w6QgFwj4PB1FRyrSr18/bN++HRMnToREIsEPP/wAOzs7HDt2DMbGxroOr0ErG65J2ygQQkjtqdyTt3HjRnh5eWHHjh2YMWMGnj17htOnT2Ps2LGU4NUDcjlTDNfUBner0uTxWXq+Vs7fGDDG8L+jj8DncvDbpHYwNSh9LXwdhVg7rjVyi6T4eN/9JjVH71laHs4+SUEfb1t4qPkFxPsvevN+aqS9efvvJmDSppuIyyzArB4e2DmjI3bM6Ih5fVqAz+XgqyOPMOSnKwh7nqPrUMkrxowZg59//hlz586FlZUVTpw4AVPTxvlFRF0y0OPBwlifkjxCCNEAlZO8Zs2a4dixY4iJicGXX34JNzc3LYZF1JVbJIWcaX77hDLuVqXfUD9LoySvMkcfJCE0IQeTglzLJTS9vW0xtr0zLkek45+7z3UUYd3bfDUajAEzu7mrXdffSYReXtY49iAJESm5WohOd47eT8L8PaGwNRXg2LxuWDLIB52bW6FLcyt82M8T5xf0xPx+nohOz8fIX67h35Cm8ztTn/n6+ir+/fzzz9DX10dqaio6d+6s9JiqsrKysHbtWnh5eYHD4eDChQvlyly8eBFDhw6FpaUlbG1tMWrUKERElP/iY82aNXB1dYWBgQECAwNx5cqV2jRVZxxEBkjKoeGahBBSWyoP13x1WegzZ87g2rVraN26NYYNG4akpCRkZ2fDx8dH40GS6pXtkafp7RPKuFgYgcflIDqdlrWvSOliKxEwEfDxXiWLi3wy2AdnHqfgm+OP0a+lLYSG2nmt6ous/GLsu5MAP0chOrhb1Ogc7/dpgfPhafj5XCR+Gt9GwxHqxpNkMRbsDYWViQB7ZndSbFHyMgM9Ht7v0wI9vawxa/sdfLD7HpLFRZjdQ/Uhr0TzBg4cWOXP6lqzZg1ycnKwbt069O/fv9zjMpkMy5Ytw8KFC7Ft2zYUFBRg7ty56Nu3Lx4+fAgTk9IvkzZt2oRPP/0Ue/bsQadOnfDdd99h4MCBePToEVxcXGoVY11zEBricVIuZHIGXiVbrRBCCKlejVbXnD17Nnbt2gVLS0uIxWIMGzYMPB4Pr7/+OkJCQmhegg5kvkjyLLTUk6fP58LZ3JB68ipxNTIDT1PyML2rOyyMK34NhIZ6WPKaDxbsDcUPp8Kx/HXVv/FviHbcjEVRiRwzurnXeEXWNi7m6O5pjcP3E/F+nxZobqOdOad1pahEhnd33EWJTI7fJrWtMMF7mb+TCAff7YIpm4PxzfEnkDNW4UbypG6sXr1ao+f78ssvAQAJCQkVPs7j8ZR69ywsLPDTTz/B1dUVN27cQN++fQEAq1atwowZMzBkyBAAwDfffIMdO3bg119/xcqVKzUas7Y5iAwhkzOk5hY1ufnLhBCiSWqvrnn79m0cOnQI4eHhmDNnjuK4jY0NgoKCsGfPHo0GSFST/SLJ09ZwTaB0yGZsRgFk8qYzp0xVW65Gg8MBpnZyq7LcyDaOaO9qju03Yhv1XCuJVIZt12NhLzTAa372tTrXvD4twBiw/nykhqLTnW9PPEFUWj4+6u+F9m6q9W7amBlg58wgeNuZ4rsT4dhzO17LUZKK3Lt3Tytl1ZWWVrpKr1BYut9kZmYmwsPD0bNnT0UZDoeDnj174tq1a1qLQ1scRGUrbNK8PEIIqQ21k7w7d+5g6NChsLW1LfftfLNmzSqcK0C0Lyu/BAC0tvAKAHhYm6BYJsfzLLr5viw6PR9nn6Sin49ttVsEcLkcfDXcFxwOB58fDGu0CfOBu8+RlivBtC5u0OPVaKcWhXau5uja3AoH7z1HdANe+OdaZDq2XI1BO1dzvN3dQ626Fsb6+POtDnAUGWLJ/ge4FZOppShJZdq0UX24sDpl1SGVSjF//ny0adMG7dq1AwAkJycDAKytlffhtLGxUTxWEYlEArFYrPSvPijrvaNtFAghpHbUHq6pr6+PnJyKeyAePnyIoKCgWgdF1Fc2J8+8kqGCmtDixVC58JRclfc7awq2XYsBAEzrotriIj72Znizsxs2XYnGxsvPMKuRzbOSyRl+v/QMZgZ8jO+gmflA8/q2wJXIdKw7F4nv3wjQyDnrkrioBAv33YeRPg8/vBFQo7lGNmYG2DItEK+vu4r3dobg6PtdaTuTOrZgwQKdPTdjDDNmzEB4eDiuXLkCLrfqL08YY1UOk165ciWWL1+u6TBrjbZRIIQQzVA7yevfvz8+/PBD3LhxQ3EDYYxhw4YNOHDgAP73v/9pPEhSvaw6GK7pY28GAHicJEa/lrZaex5NKZbKEZaYAxMBH+5WxrXuUaqIuKgEe2/Hw9vOFEEeqi8usqC/F86Hp+L7U0/RpbkVfB2FGo9NV049TEZ0ej7m9mqu2EaitgLdLNC5mSX+vfcc7/ZqpvZ2DLr21eFHeJ5diBXDfeFqWfM5y562plgx3Bcf7Q3Fh3tCsfXNQHDr0eIURSUyHA5NxKlHKUjKKYSxPh/dPa0xqaMrhFocZVAXBgwYgLCwMJXLahJjDG+//TaOHz+O8+fPo3nz/+Zl2tnZAfhvGGeZtLQ02NpW/j69ZMkSzJ8/X/GzWCyGs7OzRuOuCUdK8gghRCPUTvIcHR2xbt069OzZE4aGhtDX18emTZsgFovx448/okWLilcWJNqVVVA6XNNcix+kPG1NweWUrg5YnxWVyLDuXCS234hFTmHpdXG1NMKK4b7o1sK6mtrq2XMrHvnFMrzVVb3FRQz1eVjzRmuM+e06Zv55Gwff7QIbMwONxqYLjDH8ejEKAj4Xb3Zx0+i5P+rviVG/Xsdn/4Zhx4yONV7Mpa6deZSCvXcS0N3TGhM71r5nc1Q7JwRHZ2L37Xj8ejEK7/bS/UIscjnDgZDnWH0qHEk5ReBzObATGiA6LR83ozOx7VoMVo8JQHdPzf791aUTJ07o5HkZY5g9ezYOHTqEc+fOoWXLlkqPW1hYwMvLC+fPn8fIkSMVdS5cuIDJkydXel6BQFAv97i1NhWAz+UgkbZRIISQWqlR18akSZMQGRmJr776Cm+99RY+/fRTPHr0CHPnztV0fERFZQuvaHNZfkN9HtysjPE4qf7uWXYnNguDf7qMdecjYWWijw/6tsCMru5IFUsweVMwDt7T3H5jMjnDtusxsDTWx7AAB7XrBziL8O1oPyTlFGHSpptIymn431xfi8rA/YQcjA10hpWGhxK2c7XA+A7OuBaV0WAWH4lJz8eCfaEwM+Dju1H+GktMl7/eCt52pvjh9FPcjcvSyDlr6lpUOoauu4KP9oaisESGzwb74NanfXFlUW+ELO2P70b5o7BEhunbbuHkw8rniJGKvfvuu/j3339x7tw5tGrVqsIyCxYswObNm3H06FFkZmZi8eLFyM7OxuzZs+s42trjcTmwNTOgnjxCCKmlGm2hAABOTk4aSequXbuG9evXIyUlBX5+fli8eHGVQ0xUraPOeXft2oV169bhjTfewPvvv1/rNulCVn4JzAz44GthSOLLfOzMcCwsCQXFUhjp1/jXRy1yOcOpR8m4GpmBzPxiWJnoI8BZhA7uFool6GMz8vHrhSjsvh0PPS4XHw/0wtvdPBTXY3InV4z9/QYW7A2FtakAnZtZ1Tqus49TEJ9ZiPd6N4eBHq9G5xjRxgkZecVYcfQxRv5yDavHBKBL89rHpguMMaw/Hwkel4OZ3dRbWERViwf54NyTVCw9+BBedmZo7SyqsFxOYQkO3XuOO7FZ4HI58HMUYlygCwz1a/Y61USKuAhvbb0FcWEJNk5tDzuh5npqDfR4+Gl8Gwz9+Qo+3H0PR9/vBhNB3fw9lolMzcXKY09w9kkq9HlcvN3dA+/2aq70RZM+n4s3Ap3R2kWECX/cwLs77mLX20EqryxaRiqT43FSLvycGs+wZgDYunUrpk2bpvi5bD/aZcuW4YsvvkB6ejp+/fVXACi3yfoff/yBGTNmAABmzJgBsViMd955R3HPO3HiBFxdXeuoJZrlIDJAFG3XQwghtcJhjKm9vF9qaiq2bduG6OhoFBcXKz02YMAAjBkzRqXzXLp0CX379sX8+fPRqVMnrFu3DtHR0bh3755ik9ea1FHnvBEREejduzfkcjnGjBmDtWvXqnwdxGIxhEIhcnJyYGZmpnI9bRi49hIKS2S4uLBX9YVrYd25CKw+9RQH5nRGGxdzrT4XAIQn52LB3lA8qGS7AXMjPfC4XKTnSQAAQR4WWDHcF81tTMuVfZqSixHrr8LEgI+TH3SHqJbzF8f+fh1347JwZVFv2NZyqOXBe8+xZP8DFBTLMKCVLaZ39UB7V/MazbeSyxnS8iSQyRlERnp1loyfe5KCt7bexuh2Tlg9RnuLo4TGZ+ON36/D1EAPG6a0Q9uXfg9zCkqw6cozbLkag1yJVKmevdAAP7zRGp2aWdbq+VPFRQiOyURmfjEM9XhoZmMCT1tTRZLFGMOVyHQs2BuKFLEEy4e1wtTObrV6zspsvRqNLw4/wtj2zvh2tL9WnuNV9+Kz8duFKJx8lAzGgCH+9lg00BvOFlUvxvQ4SYyRv1yDiQEfR9/rqtbw5B03Y/HpgTD8PL4Nhtag1xyoX+/X9VF9uj7zdoXg4L1EPP5yYJ1+MUMIIQ2Bqu/Xan/6S0lJQUBAAIRCIXx9faGnpzw88NWkryqffvophg8fjm+++QYA0LdvX9jb22PDhg1KE8LVraPqeSUSCcaOHYtVq1YpyjZUWQXFdbJxrLdd6S/Tk+RcrSd5VyPTMXv7HRSWyDCzmzsmB7nBQWSApJwi3I3Lws3oTESm5EEik6NfS1sM8rVDtxZWlQ6J87Q1xbJhrfDxvvv4/OBD/Dy+5sucB0dn4mZ0Jka1dap1ggcAr7d2RFsXc3x55BFOPkzByYcpsDEVYEArO3RpboUAZyHszAwqbFtmfjHuJ2TjZnQmbj7LQFiiGMVSOQCAwwHcLY3R3dMafXxs0MHdAgJ+xR+aSmRyhCfnIiYjHxxw4GhuCH9HoUqJZolMjhVHH8NQj4eFA7xqdzGqEeAswk/j22DerhCM/f06hgY4wMvWFE9T8nA8LAkFxTJ4WBlj2bBW6OdjC3CA/XcT8P2pp5i6JRi/TGiLvjVYOOh5diFWnXiCg6GJqOirMSdzQ7hYGOF5diFiMwqgz+fix3Gt8XprRw20umJTOrnhXHgadt+ORy9vGwz0tdPK8zDGcOFpGn6/GIUbz0q3b+jtbYO5vZsrJdlV8bE3w7ej/fH+3yGYs+Muds4Mgj6/+pEH4qIS/HDqKaxNBejtbVOrdpCGQbHCZk4hmjWwRZYIIaS+UDvJO3bsGDw9PXHx4sVazS8pKCjAtWvXsG3bNsUxY2Nj9O3bF6dPn64wyVOljjrn/fjjj9GqVSuMGzeuQSd5jDFkFZSgpb32v31t6VD6HNreyPtaZDqmbb0FAZ+L7dM7KvW+OFsYwdnCqEYfnse0c8LpRyk4HJqIYQEONV4l9MezT8HlAHN7a27RC2cLI/wxpT3Ck3Px773nOBGWjO03YrH9RiwAwMpEAHuhAcyN9WEi4CG3SIrI1DwkvbRAgakBH0EelnCzNAKfy0WKuAj34rOx9VoMtl6LgbE+D91aWKO3jw2a25igqFiGJ8m5uBaVgRvPMpD3Su+XjakA07q4483OblV+o/79qad4lpaPj/p5aiTprc6AVnbY/04XfHLgAfbf/W+eZYCzCG92dsWwAEelbQqmdXFHoJsFpm4Oxpwdd7FjZkcEqjFk8Hx4Kj7YdQ85hSXo1sIKwwIc4GRuhNyiEkSk5uFpSi7Ck3MRGp8NWzMDTOnkipndPKrt3aotLpeDVaP9MXDtJSzefx9tXEQavf4lMjmO3E/E7xef4UlyLvhcDka2dcSs7s3gZVe+t7w6wwIcEBqfjU1XovH1scf4YljFc8xetv5cJDLyi/HdKH8Y1/GQ1FeNHj0a+/bt02kMTYHDi6HNSdlFlOQRQkgNqX3HlMvl8Pb2rvUCAvHx8ZDL5XB0VP6g7ujoiHPnztW4jqrnPXz4MA4fPox79+6pHLNEIoFEIlH8XF82jy0skaFYKtfq9gll7IUGsDUT4E6s9hZ7uBObiRl/3oaAz8XfM4M0ur0Ah8PBiuG+uPEsA5//G4aOHhYwU3OZ/2tR6bgamYGRbRzhblXz5fAr42VnikUDvfHxAC9EpubhblwWQhNy8DBRjPRcCSJT81BYIoOhXulCOF2aW6GVgxkC3SzgY29Wbg82xhiepuTh7JMUnH2cipOPknHilQUweFwOWjuL0LmZJZrbmIDL4eBRkhiH7iXi2xNP8NeNWCwb2hL9W5XvKTr7OAW/XYxCgLOoTvf8a+lghn/f7YK4jAKk50tga2agWH69Ir6OQmx7qwPe+P063v7zNg7M6QI3FV6/Pbfjsfif+zAR8LFxSvtyvYD9q89TtMrWzAArR/pj9l93sGBvKLZN61DrbRUkUhn+vhmHPy5H43l2IYz0eZje1R1vdXWv8hqrYvEgb4Q9z8HWazHwcxRiVDunSsuGxmdj45VotHIwq7JcXfnnn390HUKTUNaT9zy7QMeREEJIw6V2kjdw4ECsXLkSKSkp1S6QUpWSktKl7Q0MlL91NjQ0rHTIpyp1VCnz/PlzzJgxA//8849acw/q6+axZdsn1HaOmSo4HA7au1ng2IMk5BSWaHw1zwcJOXhz8y0AwNZpHbSyf5ytmQE+ec0HS/Y/wLfHn+B/I/xUrlsik+OLQw+hz+fig76eGo/tZRwOBy1sTdHC1hRjA5Ufk8mZyhtqczgceNmZwsvOFHN6NkdmfjEuPU1Dam4R9HlcNLMxQWtnUbk97YYGOOCDvi2w40Yc1px+ire330FfH1ssHOAFLztTyOQM/9xJwKf/PoCZAR8/j2uj0vA7TXOxNIKLpWo9Zr6OQqyb0AYztt3GtK23sP+dzjA3rvzvZvOVaHx55BEcRYb4a0ZHrST1mjDQ1w7jAp2x61Y81px5io/612zILGMMx8OSsfL4Y8RnFsLSWB8f9fPE5E6uGnt/0eNxsX5iWwz9+Qo+OfAALpZGFfaq5kuk+GhvKLgcYPWYmm0gTxqm/zZEp20UCCGkpmq0T95bb70FLy8vdOnSBaamykN2hg4diokTJ1Z7HguL0pt6RkaG0vGMjAzFYzWpo0qZf//9FwUFBVi8eLHi8cjISKSlpeH27du4ePEieLzyQ9Pq6+axWfllG6HXzWbD7V3NcfR+Eu7GZaGXl+bmyARHZ2L61lsolsmxZVog2rlqb87fuEBnHLz3HDtuxmFYgAM6eqi2GMfmK9F4mpKH9/u0UDmx0IbafOC1MNbH8DaqDXUV8Hl4q6s7hvjb46ujj3E4NBFnHqfAydwQRSVypOdJYGdmgK1vBer0eqijt7ctvhjWCksPPsTULcHYPr1juS8rGGNYcyYCP52NQDNrY/w1o2OdzHmtjS+GtcKjJDF+PhcJD2tjjGijXs/X/YRsrDjyGMExmTAV8LFkkDemdnar8cqxVbEyEeD3ye0wfsMNvLXlFra+1UHp710ileHt7bcRmZqHxYO84VMHQ9FVlZeXV22ZyhYOI6pxePG31hi2lSGEEF1RO8kr2x/P29sbVlZW5RZe0ddX7dteBwcH2Nra4s6dOxgyZIjieHBwMLp06VLjOqqUGTlyJAIClFf/mzZtGtq0aYP333+/wgQPqL+bx2a92COvqh4JTSr71v12TKZGkjzGGP66EYuvjjyGPp+LrdM61HoFxOpwOBx8M9IfA9ZeUixBX931uxuXhVUnw+FuZYw5PetuWGJ9YGNmgJ/Ht8G0Lm7YeTMODxPFMBEwTOjogslBrrA2rX9/F1WZ0skN6XnF+OlsBMZvuIGfxrdBc5vSD+ZpuRJ8ceghjj5Igq+jGbZN6wBLDe/5pw0Gejz8PrkdRv5yDQv23ocej4sh/tWvRJmUU4hVJ8Ox/+5zcDnAxI4u+LCfp8b3OXyVv5MIG6cG4s0twRj7+3XM7tEMg/zskCqWYNXJcDxKEmNSkAtmddfOdhw19eoXmxWpwaLV5CVmhnwY6/OoJ48QQmpB7STv9OnT6Ny5M86ePVvrJ582bRo2btyIt99+G/b29vj3338RFhaGjRs3Ksp8++23ePjwIf7880+V61RXxt7eHvb29kqxGBsbw8HBAV27dq11u+pa2XDNupiTBwDedqYw0ufhdkzt5+Vdi0rHqpPhCInLhouFEX6Z2FYrQzQr4mZljK+G++Ljfffx/q4QbJoaWOlww9iMfMz56y54XA5+mdhWK70bDUFbF3OVV1Os7+b384Q+j4PvTz/Faz9dRtfmVtDjcXAlIh35xTK85meH1WMC6mwLCk2wFxpi58wgvPH7dczdGYKIlDzM7d0cehXsn5kiLsKvF6KwMzgOxVI5urWwwmeDW9ZoQZWa6tTMEgfmdMG8XSFYdz4S685HAgD4XA7m9mqO+f08NbaBvKb8/fffug6h0eNwOHAQGdKG6IQQUgtqf3oRiUTw8NDMN6vLli1DeHg4mjdvDldXV8TExODHH39Ex44dFWUiIiJw9+5dteqoUqYxyS6o2+GafB4X7VzNcTM6E/kSaY1WvAuNz8bqU+G4HJEOPpeDyUGuWDjQS+1FUGrrjfbOCInLwt/B8Ziz4y7WTWhTLoELe56DGdtuIzW3CGvGtq5XQ8dI7czt3QJBHpb47mQ4Lj1NA0Pplxjv9W6BAa1s612CoQp3K2Psf6czZm2/gx/PRuBwaCImd3JFWxdz6PG4eJaeh3OPU3H0QRIkUjn8HIWY398TPT2tddLelg5mOPp+N1yNTMetmExYmwrQ3dO63q6qOG7cOF2H0CQ4iAxx41kGGGMN8u+QEEJ0Te3N0BMSEtC1a1dcunQJLi4uGgkiLi4OKSkp8PT0hFCo3IsTGRmJ3NxctGnTRuU66pQpc+/ePQiFQri7u6scd33ZPHbtmadYeyYCx97vptjiQNu2XYvBskMPsX5CWwz2t6++wgup4iKsOPoYh0ITweEAI9o44oM+njqdzyWVyfHxvvvYH/IcrpZGeL93CwQ4i5BVUIxD9xKxMzgOHADfvxGg1T3PiG4VlcgAoNH00hYWy7Dh0jP8fikKBcWyco+3cRHh3Z7N0cfHpkl8iNbE+zWHw2m0QzHry/2szJL99/F3cDzuft4PFnU0FYEQQhoCrW2GfufOHQCAj48PgoKCys1PGD58ON588021zuni4lJpwti8ecX7kFVVR50yZVq3bq1Sufoo+8Vwzbq8EfZvZYtlhx7ixMNklZO8c09S8OHuUOQUlqCPtw0WDfKGp23dDQ2rDJ/HxaoxAfCxN8MPp5/io72hSo/7OQrx7Sj/OkugiW40luSujKE+D/P6tsCMbu64GpmOiNQ8lMjkcLEwQntXiwazUE59Uh/nZDdWZYuvJGYXUpJHCCE1oHaSZ2JiorSgyatEIlFt4iE1ULbwiqiOhmsCpXN/WjuLcO5xCopKZNV+QN56NRpfHH4EoaEefpvUDgN9y++3pks8Lgczu3tgRFtHXHqahqcpeTAz5KNzMysEOAmbRE8HaZyMBXz0b2Wn8/38GoOiIloIpK78t1deYZ3N0yaEkMZE7SSvT58+6NOnjzZiITWUVVACQz1enfdEDPK1w734bJx9nFplb96vF6Lw7YknaGZtjK3TOsDZov72IFiZCDCyre43XSaEkKbsv73yaPEVQgipibrfuZhoXGa+RCfDWUa0dYSAz8X685EVzlNhjOGH00/x7Ykn8LYzxe5Znep1gkcIIaR+cKQkjxBCakWlJG/Lli347rvvVDqhOmWJZmTmFcPSpO6TPBtTA0zs6IpHSWKcfpSi9BhjDN8cf4KfzkbAz1GIv2cGaX3fLUIIIY2DrbD0fpGYQ0NkCSGkJlQarpmRkYEHDx7g9u3b1ZYNDQ0Fn99w9pVq6BhjyMgvhmcd7m31stk9PLAzOBaf/RsGLztTuFoaI18ixScHHuDgvUS0czXHlmmBdb41AiGEkIZLwOfB2lRAPXmEEFJDKmdjf/31F/766y+Vyn700Uc1Doiop6BYBolUDos62gj9VTZmBvh+TGu89/ddjPjlGjq6WyA4OhMZ+cXo62OLH8e1rtE+eoQQQpo22hCdEEJqTqVP3++99x5mzJih8kkNDAxqHBBRT2Z+6cqaulxierC/PeSsDX44/RTHw5LhYW2MeX1bYHKQK61KSQghpEYcRQa4n5CNYqkc+nxaQoAQQtShUpInEAhof6B6SpHk6WBO3suGBjhgaIAD8iRSGOvzKLkjhBBSK/ZCQzAGpIiLaNEuQghRE3011sCVJXmW9WSzWBMBnxI8QgghtUbbKBBCSM1RktfAZSiGa1JPKyGEkMbDUVQ69SMxh5I8QghRFyV5DVxmvgSAbufkEUIIIZr2X08ebaNACCHqoiSvgcuoZ8M1CSGEEE2wF5Ymec9puCYhhKhNI0neoUOHsHTp0kp/JtqTmVc/Fl4hhBBCNMnSWB/6fC6SKMkjhBC1aSTJy8zMRFxcnOLnqKgoZGZmauLUpBqZ+cXQ43FgSnvREUIIaUS4XA4chAY0XJMQQmqgVpnB7t27MW/ePBQWFqK4uBgnTpwAAJiammLbtm0aCZBULbOgGOZG+rSiJSGEkEbHQWSIBwk5ug6DEEIanFoleWPHjsXYsWNx7do1hIeHY9q0aZqKi6goM7+YFl0hhBDSKNkLDXEtKgM5hSUQGurpOhxCCGkwNDJcs3PnzvDx8cHEiRMxYsQI/PXXX5o4LVFBZl4xLGk+HiGEkEbIyfzF4itZNC+PEELUoZGJXImJiRgyZAi+//572NjY4L333oNIJMKQIUM0cXpSCYlUhlyJlPbII4QQ0iiVJXnxWQVo6WCm42gIIaTh0EhP3vXr19GjRw9MnToVgwYNwrx583Dq1ClNnJpUISu/BABtn0AIIQ1Rfn4+Nm7ciPbt28PExASXL1+usNyGDRvQqlUrWFlZoVevXrhz506NyjREzhZGAIAE6skjhBC1aCTJs7S0RHR0NORyOQDg6dOnsLS01MSpSRXS80o3Qrc2pZ48QghpaL766itcv34dn332GfLz8yGTycqV2bFjB95//318/vnnuHPnDlq1aoU+ffogMTFRrTINVVmSF59ZoONICCGkYdFIktejRw84ODjA398fPXv2xIkTJzB79mxNnJpUIS23NMmzojl5hBDS4HzzzTfYtGkT2rdvX2mZlStXYtq0aRg3bhxcXV3x008/wdDQEL/++qtaZRoqOzMD8LkcJGRRkkcIIerQyJw8mUyGf/75B+Hh4SgsLESrVq2gp0erYGlbWZJHPXmEENL4ZGdn4+HDh/jiiy8Ux7hcLnr37o0rV66oXKYh43E5cBAZ0nBNQghRk0Z68v766y/MmjUL/v7+6NixI/bt20c9eXUgLa+sJ4+SPEIIaWzKhlva2NgoHbexsUFSUpLKZSoikUggFouV/tVXzhaGiM8sAGNM16EQQkiDUaskLzMzE/fu3UNcXJzi//fu3UNwcDCsrKw0FSOpBPXkEUJI48flcsv9/GrCo0qZl61cuRJCoVDxz9nZWXMBa5iTyAj5xTJkFZToOhRCCGkwajVc886dO/j+++/x/PlzZGZmYvHixeBwOLC1tcXixYs1FSOpRNnCK5a0hQIhhDQ6Zb1zaWlpSsfT0tIUj6lSpiJLlizB/PnzFT+LxeJ6m+g5W5Ruo5CQVQALWk2aEEJUonKS9/jxYwgEAnh4eCiO9evXD/369UNkZCSSk5PRtWtXrQRJKpaWK4HISA/6fI2MuiWEEFKPWFlZoXnz5rh06RJGjBihOH7x4kW88cYbKpepiEAggEDQML4g/G+FzUL4O4l0GwwhhDQQKmcHR48exS+//KL4OTw8HDExMQCA5s2bU4KnA+l5EljTfDxCCGm0PvjgA2zatAkXL15EUVERvvrqK6SmpirNe1elTEP28obohBBCVFPj4ZqHDx9GcnIyVq9erTi2b98+MMYwZswYjQRHqpaWK0ErB6GuwyCEEFIDO3bswKxZsxRz5wYNGgQej4dPPvkEn3zyCQDg3XffRUZGBkaMGIGcnBy0aNEChw4dQrNmzRTnUaVMQ+ZsXrYhOiV5hBCiKo1soVAmJiYGycnJlOTVAYlUBnGRlBZdIYSQBmrs2LF4/fXXyx3X11eed7Z06VIsXboUJSUllW5PpEqZhsraVAABn4v4TNpGgRBCVKXRJI/UnfS8YgC0fQIhhDRUfD4fJiYmKpdXJXlrbAkeAHA4HDiZG9JwTUKqUSyVIyotD09TcpGVXwwZA+RyBmtTAZwtjOBmaQRL+tzYZKiV5EkkEm3FQdSUTtsnEEIIaSKczI1w41kGGGPgcDi6DoeQeiM+swAnHybj5MNkhMRlQyqvej9JV0sjdHCzQKdmlujtbQOREa1Y21ipleStW7cOu3btQrt27ZCfnw8HBwfExMTAzc1NS+GRypTtkWdlQn+chBBCGjdnC0NcfCpHWq4ENmYGug6HEJ0qlspx6lEytl+Pxc3oTACAoR4P3T2t0dLeDF52prA2FYDP5YDDAVLEEsRnFiAiNQ+3YzKx904C9t5JAI/LQUd3Cwz2t8fQAAeYGTS+kQBNmcpJ3pw5c9CxY0fcvXsXd+7cwZ07d3Dt2jXs2bMHZmZm8PPzg0QiQY8ePdQKYM+ePfjxxx+RkpICPz8/fP311/Dx8al1nerKPH36FGvWrMG1a9fA5/PRtWtXfPrpp1XuK1SflO2RRz15hBBCGruyxVfiswooySNNVp5Eih03YrHpSjRScyXQ53ExLMABQ/zt0d3TGgZ6PJXOkyIuwsWnaTgZlozLkem4FpWBr448wiBfe4xp54QgD0twufWvxzy3qAT3E3IQlZaH9LxiZORJIGcMBno8GOnzYC80hJulMdytjeEgNGjyvf4qJ3lGRkbo1q0bunXrpjiWn5+Pe/fuKSV+fL7qnYMHDhzAxIkT8fPPP6NTp074/vvv0aNHDzx8+BDW1tY1rlNdGZlMhhEjRuD999/HO++8g4KCAixYsAB9+vTBrVu3YGBQ/28gqYqePEryCCGENG5OihU2C9HOVcfBEFLHsvKLseVaDLZdi0FOYQnszAzw8UAvvNHeuUafA23NDPBGe2e80d4ZeRIpjt1Pwp7b8TgQ8hwHQp7DzdII07u6Y3Q7Zxjqq5Y4agNjDI+TcnH4fiLOP0lFeEouWNWjURWsTPTR2lmEdq4W6NbCCi3tzepl4qpNHMZUvVzVi4yMRFJSklIiWJW2bduibdu22LhxIwBAKpXC3t4e7733HpYuXVrjOqqUkcvl4HL/2yYwIiICnp6eOH/+PHr27KlS/GKxGEKhEDk5OTAzM1OpjqZ8cuABdt6Mw53P+tIkWkIIqYYu368bgvp+fe4nZGPYuqtY0N8Tc3u30HU4pI7J5QxpeRIkZhciOacIiTlFSM+TILeoBHlFUpS8NA/NWJ8HMwM9iIz04CAyhKPIEG5WxrAxFTS4np08iRQbLj3DxsvPUFAsg4uFEd7p2Qwj2zpCwNd88hWVloe9txOw61YcsgtKYG6kh8md3DClk2uddioUFEux704C/rwei8jUPAClI9c6uFmgjYsIPvZmsDYVwMJYH3pcLgpLZMiTSPE8uxCxGfmISMnDvfhsPE4SK+YoWhjro2tzK3T3tEa3FlawbcAjAlR9v6716pqFhYX4559/FBuxzp8/X6UkTywWIyQkBIsWLfovGD4fffr0waVLl2pcR9XzvpzgAUBJSQmAhrMyWUpOEfR5XFgY05w8QgghjZtiuCZto1AtuZwhKi0PUWn5yMiXoFgqh7E+H/YiA3jZmcLGtH5+uGWMISO/GFGppbFHpuYhKi0Pz9LzkJRdVO2CItWxNNZHSwcztHUxRw8vawQ4icCrpz07xVI5/g6Ow09nI5CRXwwPa2PM69MCg/3swedxqz9BDTWzNsHiQd54v09z7LuTgI2Xo/HT2Qj8fjEK4wKdMbO7h6JXXRuSc4qw7XoMdt6MQ05hCURGepjSyRVD/B3Q3tW80p44IUo/uze3MQHw30jAohIZ7sZm4WJEGi4/Tceh0EQcCk0EAHjZmqJrCyt0a2GFju6WOu2x1JYaJ3khISHYuHEjdu7cifz8fAwYMKDC/X4q8/z5cwCAnZ2d0nFbW1uEhobWuE5NzssYwyeffILmzZsjMDCw0pglEonSCqNisbjSstqWlFMEW2HD+1aKEEIIUZfISA/G+jwkZNM2ChUpKpHh4tM0HA5NxKWnaRAXSSst625ljNf87DCijSOa25jWYZTKCoqlCI3PQUh8Fu7FZSMkPluxqFwZfT4XHlbG6OllDXuhIexFBnAQGsJeaAAbMwOYGvBhIuBDwC9NfOQMyC+WQlxYgqz8EjzPLkRCVgGi0vLxKEmM4OhMXI5Ix49nIyAy0sNrfvaY0MEFvo5CXVyCCl0IT8UXhx4iJqMA1qYCfD3CD2+0d9JqcvcqI30+pnRyw8SOrjgRlozfLkZh2/VY7LgZh9dbO+Kdns1eJFSaEfY8B5uuRONwaCKkcgYPa2N8PNALI9s41Sr5MtDjoXNzK3RuboUlg0oXLbwamY5LEWm4EpGOTVeiselKNPR5XAS6m6NzMyu0dTGHv5MQxoKGv8ucWi3IycnBjh07sGnTJoSEhKBbt2745ptvMGbMGFhYWGD16tVITk5W6Vxyubw0gFfm8Onp6UEmk9W4Tk3O+8knn+DcuXO4cOFCuU1oX7Zy5UosX7680sfrUrK4CM2sjXUdBiGEEKJ1HA4HzhZGiMukJO9l8ZkF2Hw1GvtuJyBXUprYBTiL0NHdAp62prB5sZF8frEU8ZmFCHuegyuR6Vh/Pgrrz0chwFmEd3p4oH9LuzqZr5QqLsKZx6k48zgFVyLTUSwt/czG43LgZWuK3l42aG5jguY2JmhmbQJHc0O1ett4HMDMQA9mBnpwMgf8nJSTtxKZHPfis3ExPA1nHqdg58047LwZBz9HIeb2bo7+LW119uV5TmEJVhx5hL13EmCsz8NH/TwxvZs7jPR1l2zwuBwM9rfHa352uByRjl8uROKfuwnYH5KAga3sMKdn83LXWFUVrRDaycMSM7u7o6enjVZ+H61NBRjexhHD2ziCMYanKXm4HJGGSxHpuPksA1cjMwAAXA7gZmUMDytjuFsZw9pUAKGhHkwEepAzBqlcjhIZg1TGUCyVoVgmh6REDolUDj0eF8YCHowFfDiZly4E4yBS7/dYU1T+zdmzZw/efPNNeHl5YcKECTh48CCcnJxq/MRli6Skp6crHU9PT6900RVV6qh73i+++ALr1q3D8ePH0bZt2ypjXrJkCebPn6/4WSwWw9nZuco62lBUIkNmfjG6NLeq8+cmhBBCdMHN0hinHiWjWCqHPr/uejXqozuxWdh4+RlOPkyGnJUOPRvVzhGD/R3gKDKssq5cznAzOhMHQhJwKDQRs/+6ixY2Jni3V3MM8dfscMCyD9JnHqfg1KMUhMZnAwD4XA6CPCzRtUVpz4mvo1mdJDN6PC4C3SwQ6GaBj/p74sHzHPwdHI9/Q55j1vY7CHAW4eMBXnX++ep8eCqW/PMAyeIidGthhW9G+Vf7OtYlDoeD7p7W6O5pjTuxmfjlfBSOhyXjeFgyOnlY4vXWDhjoa1ftnntSmRx347Jx+lEyDoQ8R3peMfR4HIxo44jpXd3rtEeVw+HAy84UXnammNHNA0UlMtxPyMG9+CyExGUjPCUXF8LTcOZxaq2fS8DnIsBZhPau5gh0s0BbF3MIjbQ/PUzlv6jnz5/D0NAQgwYNwqBBg2qV4AGAjY0NXF1dcfXqVaVhnleuXMHQoUNrXEed8y5fvhzff/89jh07hq5du1Ybs0AggECg+0VOUsWlwxnszHQfCyGEEFIX3KyMIWdAXGaBRoeKNRQlMjlOPkzGpivRCInLBgD09LLGjK4e6NLcUuUeKC6Xg07NLNGpmSUWDvDGpivR2H49Bh/svoc1Z55iVvdmGNWu5gt7SGVy3IrJwulHKTjzOEXR+2oq4GNogAP6+tigp5cNhIa6XQOBw+HA30kEfycRPuzXAr+cj8KOm7GYuPEmhvjbY+mQllrfruPl3jsTAR/fjPTD2EDnej0Vp52rBTa9aYHHSWL8eiEKx8OScP1ZBj77NwxtXcwR4CyEm5UxzI30weWUtrFsjuXduCxkF5SugeFiYYTFgzwwup1TvVgp3kCPhw7uFujgbqE4JpXJkZBViIz8YoiLSpBbJAWPwwGfx4EejwM+lwsBnwuBHg8CPhd6PC6kcjnyJTKIi0qQkFmAmIwChCfnIiQuC8HRmQCiAAAbJrdD/1Z2lUSjGSonefPmzYOPjw82btyItm3bKnr0xo0bB3d39xo9+bvvvotvvvkGEydOhJ+fH9atW4e4uDi8/fbbijIff/wx7t69izNnzqhcR5Uy//vf/7B69WocO3ZM5dVA64tkcREAwE5Yf77lIYQQQrTJ3ap0wYeY9PwmleSl5hZhV3A8dtyMRYpYAn0+F+MCnfFWV3d42tZuTp21qQCLB3ljdg8PbL0Wgy1XY/DJgQdYe+YppnZ2w7AABzhbVL/QRnZBMa5GZuDM4xSce5KKnMLSD/IOQgNM7eSKvi1t0dHdst72wNqYGuCLYa0wvas7vjryCEfuJ+Hi0zQsHuSN8YEuWhk6eP5JKhbvv48UsQTdPa2xcqRfveq9q46PvRl+Gt8GOYW+OP0oBcceJCE4OhPBMZkVltfjlfacTenkhr4+NvB1ENb7LQ34PC7crIzhZlX76VFSmRxPknNxJzYLt2Oz0NJB+6sYq5zkcblcDBw4EAMHDkRaWhq2bduGTZs24ZNPPkGnTp0wfvx4pKWlqfXkH330EZKSkhAUFAQejwczMzPs2rVLadPyzMxMpXl+qtSprkxmZiY+++wzGBkZYfz48UoxrVq1qtyx+iYpp3R1MbsGvPwrIYQQog43y9IPWjEZ+TqORPsYY7gbl40/r8fg2IMklMgY7MwMsKC/J8Z1cNF4z4fISB8f9PXEzG4e+Ds4Dn9cfoZVJ8Ox6mQ42riI0NPTBj72prA1MwCPy0FWQTFiMgoQnZaPWzGZCEvMUexf1srBDNO6uKFfS1u0tDer171Sr3K2MMKGKe1x8mEyvjj0EJ8eCMOhe4n4dpS/Rj7oA6U9W18deYR9dxJgKuDj21F+eKN9/e69q4rQUA+j2zlhdDsnyOQMsRn5iM8qhLiwBHLGYCLgw93KGC4WRnW6eEx9w+dx4esohK+jEFM7u9XJc9Z6n7wrV65g48aN2Lt3LwoKCvDRRx9h9erVap2juLgYOTk5sLKyKvdLnpWVheLiYtja2qpcp7oycrkciYmJFdaxsLCAkZFqy8Pqal+hDZei8PWxJ/jnnc5o52peZ89LCCENVX3fB07XGsL1SRUXocPXZzGxowv+N8JP1+FoRb5EiiP3E7H9RizCnpeu4N3JwxJTOrmiX0vbOvuQXCyV43JE6Wqdpx6loKC44oXrAMDcSA+dmlmiczMr9Pa2gUMD6o2qSm5RCb498QR/3YiDgR4XH/Xzwltd3Wu1gMa5JylYsv+Bovfum5F+jeZ6kbpTZ/vkde3aFV27dsVPP/2EnTt3Vrk6ZWX09fUrXWzF3LziJKaqOtWV4XK5tZ5TqEtJOWXDNaknjxBCSNNgbSqAsT4P0emNrycv7HkO/g6Ow8F7iciTSGGkz8OkIBdM6eRW6yGZNaHP56KPjy36+NiiqESGJ8m5iEjJRXpeMeSMwcyAD1dLY7haGsHZ3KjeD7urCVMDPawY7och/g5Y/M99/O/YYxy+n4hPX/NBRw9Ltc4Vl1GAFUcf4dSjFJgK+PhulD/GtHdqsL13pGHQ2FJGZmZmmD17tqZOR6qQnFMEDgewMdX9RFVCCCGkLnA4HLhaGiOmkSR5eRIpDocm4u/gONxPyAEAtLQ3w/iOLni9tQPMDHS7MEkZAz0eWjuL0NpZpOtQdCLIwxLH53XH2jNPsflqNMZuuIG+PraY38+z2nlVabkSbLoSjc1Xo1EslWOwnz0+HexDvXekTjT8nf6aoGRxEaxNBNBrwmObCSGEND3u1sY4el+MohIZDPRqvkmyrjDGEPZcjJ3BcTh07znyi2Uw0udhfAdnjO/gAj9HIfXu1EOG+jwsec0HEzq64LuT4Th6PwlnHqegrYsIg3zt0dZVBCdzI/C5HKTlSfAgIQfnnqTi7JNUFEvl8LI1xbJhLdG5GW19ReoOJXkNUGJ2IexpqCYhhJAmxv3F4iuxGQXwsqv7YYw1lVNQgoOhz7ErOB6Pkkrn2vk7CTG+gwuGBjjAREAfxxoCV0tjrJ/QFrO752DL1WgcC0vC3RfbWbyKwwE6ulvgzc5u6NfSTiebYZOmjd5VGpiiEhlSxBIEullUX5gQQghpRDysS5O8qLS8ep/kMcYQHJ2JXbficexBEiRSOUwFfEwKcsG4QJc63fiZaJafkxA/jG2Nr0f64WZ0Jh4m5iBVLEGxTA4rY3142pmig5uF1vfZI6QqlOQ1MAlZpdsnqLJvDSGEENKYtLApTewiU/N0HEnlSmRyHA5NxO8XnyE8JRcAEOhmjrGBLnjNzw5G+vTRq7Ew0OOhh6c1enhWvRAgIbpA7zQNTHxmAQDAhZI8QgghTUwzm9KevIh6mOTJ5Qz7Q55jzemneJ5dCGN9Ht7q4o4JHV2a1ObthJD6gZK8BibuRZLnbE5JHiGEkKbFSJ8PR5EhIl70kNUXt2Iy8eXhR3jwPAfmRnpY0N8Tk4PcIDSqHytkEkKaHkryGhjqySOEEKItUqkUUqkUQOmWBTweDzKZDIwxRRkulwsul1vp8bL61R3n8UpXx5TJZCod5/P5kMvlaGlnjJvRmZAUl4DH5SiOy+VyRdmy2Cs7rqk25RZIsOZ0OHYGx0OPx8HMbm54t1cLmOhzFddTlTa9HGNlx+uqTZp6nahN1CZqk3ba9Oo5K0NJXgMTl1kAHpcDexFN5iWEEKJZ169fh7Fx6ZBIOzs7eHt7IyIiAsnJyYoyrq6ucHd3R1hYGLKyshTHPT094eDggLt376KgoEBx3N/fHxYWFrh+/brSB5jAwEAIBAJcuXJFKYauXbtCIpHg1q1bimM8Hg/dunVDdnY2JroVYqKbIa5fuwojIyN06NABycnJePr0qaK8ubk5AgICEBsbi9jYWMVxTbbpeQEPieEh6C4EuvczftEmNwj0uWq36f79+4rjumyTJl8nahO1idqknTa9msRWhsNeTkeJWsRiMYRCIXJycmBmVvWGmJoycO0l5EmkuLKod508HyGENAa6eL9uSMquT0ZGhuL61NdvtPfdjsPSgw/x8/g26OVto5Nv6Y8+SMbCfx5AwGV4v3cLTOnsBh6XQz0P1CZqE7VJ620Si8WwtLSs9n5GPXkNCGMMCVmF8HeiZZcJIYRoHp/PB5+v/NGg7MPHqyo7/mp9TR7ncrloZitEkQyISC9Avxdlyj5QVVS+ouM1bRNjDGvOROCnsxGwMzPAH1Paw6+Ce7K6bVIndk23SRvHqU3UpqqOU5tq16bK6pY7l0qlSL2QVVCCPImU5uMRQghpslrYlq5U+TS5bhdfkckZFv1zH/vuJMDPUYiNU9vDlvZBI4TUU5TkNSCxGfkAaI88QgghTZeZgR6czA3xOKnukjy5nOGT/Q+w704CenlZY/3EtrTfHSGkXivfP0nqrai00iTPw8pYx5EQQgipC/n5+fjss8/Qtm1buLu7o0ePHvj777/Lldu5cyc6duwINzc3DB06FGFhYTqItu60tDdDZFoeikpk1ReuJcYYlh4Kw+7b8ejuaY3fJrejBI8QUu9RkteAlO0L1MLWVMeREEIIqQtz5szBjh078P333+PcuXMYN24cJk2ahH///VdRZt++fXjzzTcxc+ZMHD16FFZWVujZsydSU1N1F7iWtXIQQiZneFoH++WtPROBv27EoXMzS2yY3A4CfsVzcgghpD6hJK8BeZqSC30eF26WNFyTEEKagosXL2Lq1Kno1asX3N3d8c4778DX1xcXL15UlFmxYgWmTp2KGTNmoFWrVvjjjz/A5XLx66+/6jBy7WrpULqi3MNEsVaf50RYMn48GwFfRzNsnNoeBnqU4BFCGgZK8hqQiNQ8eFgbg8+jl40QQpqCgQMH4sSJE8jMzAQABAcHIyoqCgMHDgRQupR2aGgo+vXrp6jD5/PRp08fXLp0SScx14VWL5K8R1pM8p6m5OKjPfdgaayP3ye3pyGahJAGhbKFBiJfIkVCViGa25joOhRCCCF1ZP369XB3d4eNjQ1EIhG6d++O9evXY8CAAQCA58+fAwBsbW2V6tna2iIxMbHS80okEojFYqV/DYm90AAiIz08TMzRyvlzCksw88/bkEjl+GViWziKDLXyPIQQoi2U5DUQkal5AABPmo9HCCFNxocffojg4GAcP34cd+/exdq1azFnzhycPn0aABSb8r66bxKfzy+3qe7LVq5cCaFQqPjn7OysvUZoAYfDQSsHMzxOyoVUJq++gpqWH36I2IwCfDbYBx09LDV+fkII0TZK8hqICEWSRz15hBDSFGRlZWHdunVYsWIF+vXrBw8PD8yePRuDBw/GypUrAQDW1tYAgPT0dKW6aWlpsLGxqfTcS5YsQU5OjuJffHy89hqiJQFOIhSWyBCu4cVXToQlYf/d5+jlZY2pnd00em5CCKkrlOQ1ELSyJiGENC0ymQyMMRgbK2+bY2JiguLiYgClSZ6bmxuuXLmiVOby5cvo0KFDpecWCAQwMzNT+tfQtHM1BwDcjc3S2DlTc4uwZP8DiIz08O0of3A4HI2dmxBC6hIleQ3E/YQcGOrx4EoboRNCSJNgZWWFdu3a4bvvvlNsh3Djxg3s27cPgwYNUpSbO3cuNm7ciDt37kAmk+GHH35AQkIC3n77bV2FXifauJQmeXc0lOQxxvDJ/jBkFZTgf8P9YGNmoJHzEkKILtBSUQ2ATM4QmpANfychraxJCCFNyN69ezF37ly4urpCT08PPB4Ps2bNwqJFixRl5s+fj5SUFHTv3h1yuRzW1tbYt28fvL29dRi59lkY68PD2hh34jST5J0IS8aZxykYGuCAwf72GjknIYToCiV5DUB4ci4KimVo+2JoCiGEkKbB3d0dR48ehVwuR25uLoRCYbkyHA4H3333Hb7++mvk5uZCJBI1mWGG7VzMsfdOAlLFRbXqecuTSLH88COYGfCxdEhLDUZICCG6Qd1CDcDdF99StnWhJI8QQpoiLpdbYYL3Mj6fD3Nz8yaT4AH/zcu7Xcshm2tOP0WyuAgfD/SGtalAE6ERQohOUZLXAJQleW1cRLoNhBBCCKlHOjUr3d7gckRajc/xMDEHW6/FoLWzCBM6uGgqNEII0SlK8hqAkLhsuFoawcqEvl0khBBCyrhaGsPdyhgXwtMUewaqQy5n+OzfMDDGsGK4L7jcptMLSghp3CjJq+cSswsRnZ6vGJJCCCGEkP/09LJGUk4RnqbkqV131614hMRl483O7vB1rHo4LCGENCSU5NVzZx6nAAD6+tjqOBJCCCGk/unpVbrp+4XwVLXqpeVK8O2JJ7A1E2B+f09thEYIITpDSV49d/pRCvR5XHT3tNZ1KIQQQki909HdAgZ6XMWXoqr68sgj5BSWYNnQVjAR0GLjhJDGhZK8ekxcVIIbzzLQubkl3YAIIYSQChjo8dCvpR1uxWQhJj1fpTpnH6fgcGgi+rW0xSBfOy1HSAghdY+SvHrs9MMUlMgY+rWkoZqEEEJIZca0cwIA7LuTUG3ZPIkUn/0bBlMBH1+97tuktpwghDQdOk/y1qxZA1dXVxgYGCAwMBBXrlzRSB1NldEVxhg2XomGkT4Pg/3sdR0OIYQQUm91aW4FB6EB/rmbAJm86lU2V514gqScIiwa5A07Yc03UCeEkPpMp0nepk2b8Omnn2L9+vV4/vw5evfujYEDByIuLq5WdTRVRpeuRKbjcZIYYwOdITLS13U4hBBCSL3F43Iwpr0zknKKsP9u5b15px+lYNv1WHRws6A98QghjRqH1WRjGQ3x9vZG//798dNPPwEo7b1ydnbG5MmTsXLlyhrX0VSZ6ojFYgiFQuTk5MDMzKzmF+IVJTI5Rv92HWHPc3BxYU84mRtp7NyEENIUaev9urFoDNcnp7AEPVedhz6fiwsLesFQn6f0+LO0PAxffxU8LgdH3+8GB5GhjiIlhJCaU/X9Wmc9eZmZmQgPD0fPnj0VxzgcDnr27Ilr167VuI6mytSFpJxCpOYWlTu+6mQ4QuOzMb2rOyV4hBBCiAqEhnr4oK8nUsQSfHX0kdLm6PGZBZi08Sbyi2VYM7Y1JXiEkEZPZ0s2JicnAwCsrZW3BrCxscGtW7dqXEdTZSoikUggkUgUP4vFYgCAVCqFVCoFUJos8ng8yGQypRsMl8sFl8tVOv7d8cc49SgF4zu4on9La3A5HOy+FY/DoYlo5yLEwgFeivOW4fFKv5mUyWQqHefz+ZDL5ZDL5dUeL4u9suOqtOnl46/GXtlxahO1idpEbdJ2m149J2mcJnR0wcmHydh5Mw5SmRxjA13wMDEHq0+GI1cixZo3Wiv21SOEkMas3q3LzxhTe6UrVepooszKlSuxfPnycsevX78OY2NjAICdnR28vb0RERGhSCYBwNXVFe7u7ggLC0NWVhYA4HU7QK/YCBuvRMOdJcPRlIvBNsDgfsZwbd4CejwuLl++qvQBJjAwEAKBoNwiMV27doVEIlFKUnk8Hrp164bs7Gzcv39fcdzIyAgdOnRAcnIynj59qjhubm6OgIAAxMbGIjY2VnFcnTYBgKenJxwcHHD37l0UFBQojvv7+8PCwgLXr1+nNlGbqE3Upjpt06tJLGmc9Hhc/DGlPaZtvYU9txOw53bp/DwrEwE2jm2NPj60WjUhpGnQ2Zy8zMxMWFpa4p9//sHIkSMVxydNmoT4+HhcvHixRnU0VaYiFfXkOTs7IyMjQzEmVt1vtAEObsVm415cBjgcoJW9EEEeFuDxePQtPbWJ2kRtojZpqE1isRiWlpYNes6ZNjWGOXkvk8sZbjzLwM3oTHhYG6Onpw2ERnq6DosQQmpN1fdrnfXkWVhYwMvLC+fPn1ckWowxXLhwAZMnT65xHU2VqYhAIIBAICh3nM/ng89XvpRlHz5eVdHxTs0s0amZZYXlXz1vTY6XfXCq7XF12qRujOoepzZRm6o6Tm2iNr0aY2V1SePE5XLQubkVOje30nUohBCiEzrdQmHBggXYvHkzjh49iszMTCxevBjZ2dmYPXu2osyMGTPg6+urVh1NlSGEEEIIIYSQhkanX23OmDEDYrEY77zzDlJSUuDn54cTJ07A1dW1VnU0VYYQQgghhBBCGhqd7pPX0DW2OQyEENJY0ft11ej6EEJIw1Dv98kjhBBCCCGEEKJ5lOQRQgghhBBCSCNCSR4hhBBCCCGENCK0pnQtlE1nFIvFOo6EEEJIVcrep2kaesXofkYIIQ2DqvczSvJqITc3FwDg7Oys40gIIYSoIjc3F0KhUNdh1Dt0PyOEkIaluvsZra5ZC3K5HImJiTA1NQWHw1G7vlgshrOzM+Lj4xvdamaNuW1A424fta1horZVjTGG3NxcODg4VLiRe1NH97PKNea2AY27fdS2honaVjVV72fUk1cLXC4XTk5OtT6PmZlZo/slLtOY2wY07vZR2xomalvlqAevcnQ/q15jbhvQuNtHbWuYqG2VU+V+Rl9nEkIIIYQQQkgjQkkeIYQQQgghhDQilOTpkEAgwLJlyyAQCHQdisY15rYBjbt91LaGidpGdKkxv0aNuW1A424fta1horZpBi28QgghhBBCCCGNCPXkEUIIIYQQQkgjQkkeIYQQQgghhDQilOQRQgghhBBCSCNCSZ6WZWdn4/bt20hISNBqHV2QSCS4e/cuwsPDVa6TmZmJkJAQZGZmajGy2mOM4eHDhwgNDYVMJlOrbnR0NK5cuYKcnBwtRVd70dHRuHPnDvLz81WuU1JSgvv37yMuLk6LkdVeSkoKbt26hfT0dJXrxMfH4/bt23j+/LkWI6s9iUSC69evIyoqSuU6ubm5uH37NmJjY7UYWe0xxnDnzh2EhoaqXCc7OxshISFqvdak5uh+pozuZ/UD3c+U0f1M9+rN/YwRrVm1ahUzMDBgPj4+zNDQkI0dO5ZJJBKN19GFY8eOMUtLS+bh4cHMzc1Zu3btWGJiYqXl7927x/r3788sLCxY69atmZGRERs3bhzLz8+vw6hV8/jxY+bp6clsbW2Zk5MTc3JyYjdv3lSpblJSErOzs2MA2OnTp7UcqfpycnJY3759mYmJCfP09GQmJibszz//rLbeli1bmIWFBfP09GTe3t5s+PDhLDc3tw4iVp1cLmdz5sxhAoGAtWzZkgkEArZo0aIq68THx7MOHToofofNzMxYjx49WFpaWh1FrZqsrCy2aNEi5ujoyIyNjdmsWbNUqvfbb78xIyMj5u3tzYyMjNiQIUPq3d+cXC5nq1evZi1atGAikYi1a9eu2jqPHj1igwcPZubm5qx169bM2NiYDR8+nOXk5NRBxE0T3c/+Q/ez+oHuZ8rofqZ79e1+Rkmelly4cIFxOBx28uRJxhhjsbGxzMbGhi1fvlyjdXQhLS2NmZqasi+//JIxxlhhYSELCgpigwYNqrTO3r172alTpxQ/x8fHM0dHR/bhhx9qPV51yOVy5u/vz4YPH85kMhljjLHp06czZ2dnVlRUVGVdmUzG+vbtyxYtWlRvb4ozZsxgXl5eLDMzkzHG2B9//MH4fD4LDw+vtM6BAwcYj8dj+/fvVxw7fPgwi4mJ0Xq86vjtt9+YqakpCwsLY4wxdvPmTaavr892795daZ0JEyYwPz8/xY0iKyuLubu7s3fffbdOYlZVWFgYW7lyJUtJSWFdunRR6aYYEhLCOBwO27NnD2OMsZSUFObi4lLv/uYkEgmbP38+Cw8PZ/PmzVPppnjw4EF25MgRxc/JycnMw8ODzZw5U5uhNll0P1NG97P6ge5nyuh+pnv17X5GSZ6WTJkyhQUFBSkdW7BgAXN1ddVoHV345ZdfmJGRkdI3KPv27WMcDqfKbz9fNXv2bBYYGKiNEGssODiYAWC3b99WHIuJiWEA2OHDh6us+7///Y8NHDiQxcfH18ubYlFRETMyMmLr1q1THJPL5czBwYF9+umnldbz8/NjEyZMqIsQa6VDhw7szTffVDo2ZMgQNmDAgErr9OvXj02aNEnp2ODBg9kbb7yhlRg1QdWb4vvvv8+8vb2Vjq1YsYKZm5srPvDVN6reFCuyYMEC5uPjo+GICGN0P1MF3c/qFt3PyqP7Wf1SH+5nNCdPS0JCQtCuXTulYx06dEBsbCyysrI0VkcXQkJC4OPjAyMjI8WxDh06gDGGe/fuqXQO9mK8cvPmzbUUZc2EhISAy+WiTZs2imOurq6wsbFBSEhIpfWuX7+OdevWYevWrXUQZc2Eh4ejoKBA6XeMw+Ggffv2lbYtLe3/7d1/TNT1HwfwJ+DdifwYByggyoGkKMx0EAFeU7Kg2TJMYRE2pzhdtXStVZDzD6cVFCrIWCGotIjcROSnQ2DEjzuDJFS0/LHQUiANE9ASBIX39w/G57v7AoZyxx33fT42Nj5vPp/3vd533OfJ+3Ofz4dbOH/+PFauXInOzk40Njaivb19okoeMyEEmpqaRnz/POp127ZtGyoqKrBv3z5UVlYiMTERjY2NiIuLM3TJBjfa/qSzs9Pkr2d4Ej/99JPJ7U/MBfPs0ZhnE495NhzzzHzoK8+m6KEWGkFHRwecnJx02oaWOzo6oFQq9bKNMfxbnWOxZ88eNDU1ISMjQ+/1jUdHRwccHBxgaal7/MPJyWnUsXV1dSEmJgb79++Hi4uLyd5gYKj+kV67ixcvjrjNH3/8AQDQaDR47733MHPmTFy+fBkvvfQSsrOzYWNjY9iix+jevXvo7e0dcWyP+p0MDAxEREQEduzYAS8vL1y9ehWxsbHw8/MzdMkG19HRofPHHaD7PvXy8jJGWQaRnp4OrVaL2tpaY5dilphnj8Y8m3jMs+GYZ+ZBn3nGSZ6ByGQy3L9/X6etp6cHACCXy/W2jTGMt87s7Gxs27YN33zzDRYvXmyIEp/YSGMDBsc32tg++ugjqFQqKJVKaLVa3Lp1CwDw888/w83NzWR2sDKZDABGfO0e9TsJAFqtFpcuXYKDgwPa2toQGBiIHTt2ICkpybBFj9GTjA0A3nzzTdy8eRPXr1+HnZ0dOjs7sXTpUty9excHDhwwaM2GNln2J+OVl5eHrVu3Yv/+/QgJCTF2OWaJeTY65plxMM+GY55NfvrOM07yDESlUg27fW1bWxtkMhlcXV31to0xqFQqNDQ06LQN1e3h4fHIbXNycrBx40ZkZWUhOjraYDU+KZVKhe7ubnR1dcHBwQEA8PDhQ7S3t486Nnt7ezx8+BDx8fEAgL6+PgDAwYMH0drait27d09I7f9GpVIBGHytFi5cKLW3tbVJP/tfHh4esLCwQHR0tPR8uLu7Y+XKldBoNAaveawUCgVcXFxGfP+M9roJIXD8+HHs27cPdnZ2AAClUomYmBgkJycbvGZDG21/AgCzZ882Rkl6l5+fj5iYGKSlpSE2NtbY5Zgt5tnImGfGwzzTxTyb/AyRZ7wmz0DCwsJQXl6O3t5eqa2wsBChoaHSUZrbt29Dq9VKO9GxbGMKwsLCcOXKFVy4cEFqKywshKOjI/z9/QEMBoNWq8Xt27eldQ4fPozY2FgcOnQIa9eunfC6x2LouS4qKpLaKioq0N3djRdffFFqO3XqlHQe+O7du6HVaqWvY8eOAQCSk5NNJhABYNasWZg/f77O2Nrb21FXV4ewsDCp7eLFizh//jwAwNbWFmq1etjOtbW1FdOnT5+YwscoLCwMxcXF0nJ/fz9KSkp0xtbS0oK6ujoAg9dvODs7DzsdqaWlxeTGNhZ37tyBVqtFd3c3gMHno7q6Gn///be0TmFhIQIDA6U/cCaL/v5+aLVanetnCgsLER0djdTUVGzevNmI1Zk/5hnzjHk2sZhnzDO9GPetW2hEHR0dwsPDQ7z88suiqKhIvP/++0Iul4u6ujppndzcXAFAtLS0jHkbUxEeHi58fX1Fbm6u2Ldvn1AoFOLLL7+Ufj50R67c3FwhxOAtYq2srMTbb78tNBqN9HXq1CljDWFUH3/8sVAqleLgwYPi22+/Fe7u7iI2NlZnHRcXl1H/Z42p3o1MiP/ePnrXrl0iPz9fhISEiEWLFom+vj5pnYiICLFs2TJpWaPRCFtbW5GQkCDKyspEXFycsLKyEtXV1UYYweguXbok7OzsxMaNG0VRUZGIjo4WTk5O4vr169I6u3btEjY2NtJyQkKCsLa2Fl988YUoLy8Xn3zyiZDJZOKrr74yxhBGNTAwIL1nFi5cKCIiIoRGoxGNjY3SOhUVFQKAOH/+vBBCiHv37gkfHx/x/PPPi4KCArF9+3ZhZWWlc+t3U3H69Gmh0WhEVFSU8PHxkcY6dNe0zs5OAUBkZWUJIQbHKpfLxfr163X2J6a4rzQHzDPmGfNsYjHPmGf62FfydE0DUSqV+OGHH/D5558jJSUFbm5uqK2tRVBQkLSOs7Mz1Go1FArFmLcxFfn5+di7dy8yMjIwbdo0ZGdnIyoqSvq5QqGAWq2Gs7MzAODKlSsIDg7GuXPncO7cOWm9GTNmSEcKTcWnn36KOXPm4NixY3j48CE++OADvPvuuzrrBAUFwdPTc8Tth8ZuikeXVq1ahdLSUmRmZqK6uhpLly5FXFyczpF1X19fnaNlzz33HCorK5GWlobKykp4eXmhoaFh2EXQxubj44O6ujrs2bMHKSkp8Pb2Rn19vc6pHB4eHliyZIm0HB8fDx8fH+Tl5aG8vBwzZ85EYWEhVqxYYYwhjOrBgwfS6VP29vb466+/EB8fD5VKhZycHACAg4MD1Gq1dPOAadOmQaPRIDExEampqZg+fToqKyuxbNkyo41jNMnJybh69SqAwf3i0FgrKipgbW2NKVOmQK1Ww8XFBQDQ3NyMwMBA/Prrr9K6AGBnZ4fS0tKJH4CZY54xz5hnE4t5xjzTR55ZCCHEuHogIiIiIiIik8Fr8oiIiIiIiMwIJ3lERERERERmhJM8IiIiIiIiM8JJHhERERERkRnhJI+IiIiIiMiMcJJHRERERERkRjjJIyIiIiIiMiP8Z+hEk0xxcTH8/PwwZ86cCX/sI0eOYGBgAAqFAq+99ppe+jxx4gS6uroAAKtXr4ZcLtdLv0REZNqYZ0SGw0/yiExYUVERfvvtN522LVu24PvvvzdKPTExMUhPT0dpaane+qysrMTXX3+NN954A3fv3tVbv0REZDqYZ0QTi5M8IhP2zjvvoKamRqdt5cqV8Pb2NlJFQHx8PDIyMvTWX1JSEhITE/XWHxERmR7mGdHE4umaRCaqrKwMPT09+PHHHzF16lRYWVkhKioK4eHhUKlU0nr5+fkICAiATCZDU1MTbGxsoFarYWlpiWvXruHs2bOYPXs2/P39hz1GX18f6uvrcefOHfj6+j5R2A49/pQpU9DU1AR7e3ssWbIEFhYWOuudPn0ara2tmDt3LhYsWPD4TwgREU1KzDOiicdJHpGJqqqqQk9PD06fPo3Ozk7I5XJERUVhy5Yt2L59u3QNw6ZNm7BgwQK0tbXBz88PJ0+eREBAAEJDQ5GVlYX58+dDo9Fgw4YNSElJkfo/e/YsVq1aBUdHR7i7u6O+vh5r1qxBenr6Y9W5adMm+Pv748KFC3j66afR0NCARYsW4fjx41AoFOjt7cWKFSvQ3NwMf39/XLlyBXPnzkVeXt6w4CQiIvPDPCMyAkFEJsvd3V1kZWXptKlUKpGZmSktOzk5ieDgYNHT0yOEEKKhoUEAEEuXLhW9vb1CCCGqqqqEpaWluHHjhhBCiL6+PuHp6SmSk5Olftrb24Wbm5s4fPjwqPVYWVmJ0tJSnTYnJyehUqnErVu3hBBC3LhxQ7i6uoq9e/cKIYQoKSkRSqVS/PPPP9I2BQUFor+/X1o+c+aMACD1QURE5oV5RjSxeE0ekRlYt24dpk6dCgAICAiAXC7H+vXrpTt7hYSEYGBgAM3NzQAGj6peu3YNM2bMwNGjR5Gbm4uqqip4e3ujqqrqsR9/w4YNcHZ2BgC4urpi3bp1OHLkCADA2toavb29uHz5srR+REQELC25+yEiIl3MMyL94OmaRGZAqVRK31tYWEAmk+m0KRQKAMD9+/cBAL///jvkcjmKiop0+nF3d8e8efMe+/E9PT11lr28vJCdnQ0AWL58ObZu3Yrly5fDxcUFL7zwAjZv3ozFixc/9uMQEZF5Y54R6QcneUT/h+zt7dHX14cDBw7A1tZ23P11dnYOWx46EgoACQkJ2LlzJxobG/Hdd9/h2WefxZkzZ+Dn5zfuxyYiov9fzDOikfHzZSITZmtrKx2t1KfQ0FDI5fJht47u7+/Hn3/++dj9FRQUSN8LIZCfnw+1Wg0AuHnzJvr7+yGTyRAcHIzU1FTY2dmhsbFxXGMgIqLJg3lGNLH4SR6RCXvmmWdw6NAhTJs2DdbW1oiKitJLv66urkhJScGWLVtw6dIlBAUFobW1FXl5efjss8/wyiuvPFZ/v/zyCyIjIxEeHo6SkhI0Nzfj6NGjAICTJ09i586diIyMhIeHB6qqqmBhYYHly5frZSxERGT6mGdEE4uf5BGZsNTUVLz66quorKxEcXExgOH/PHb16tU6/2cIACIjIzFr1iydttdffx2urq7S8ltvvYVTp07B0dERtbW1AIDc3Nx/DcSamhrk5+frtKWkpCA8PByNjY2YN28eGhoa4OHhAQBYs2YNDh8+jAcPHqCmpgZPPfUUzp49K9V34sQJlJWVPc7TQkREkwzzjGhiWQghhLGLIKLJYe3atejv74e9vb10aoyzszPS0tIQHR39RH1++OGHaGlpAQBkZmbCzs5Ob/USERGNhHlG5o6naxLRmOXk5Oi9z6SkJL33SURE9CjMMzJ3PF2TiMZlpNNriIiIJhvmGZkTnq5JRERERERkRvhJHhERERERkRnhJI+IiIiIiMiMcJJHRERERERkRjjJIyIiIiIiMiOc5BEREREREZkRTvKIiIiIiIjMCCd5REREREREZoSTPCIiIiIiIjPCSR4REREREZEZ+Q/sZ1rNTp/qqgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "max |E_tot(t) - E_tot(0)| = 0.009 meV/atom over 1.2 ps | (last half) = 92.5 K\n", "Loop time of 76.717 on 1 procs for 240 steps with 400 atoms\n", "Performance: 1.351 ns/day, 17.759 hours/ns, 3.128 timesteps/s, 1.251 katom-step/s\n" ] } ], "source": [ "def read_thermo(logfile):\n", " lines = open(logfile).read().splitlines()\n", " i0 = next(i for i, l in enumerate(lines) if l.lstrip().startswith(\"Step\"))\n", " cols = lines[i0].split()\n", " rows = []\n", " for l in lines[i0 + 1:]:\n", " if l.startswith(\"Loop time\"):\n", " break\n", " rows.append([float(x) for x in l.split()])\n", " return cols, np.array(rows)\n", "\n", "cols, th = read_thermo(f\"{RUN}/log.argon\")\n", "t_ps, T, pe, ke, etot, press = (th[:, cols.index(c)] for c in\n", " (\"Time\", \"Temp\", \"PotEng\", \"KinEng\", \"TotEng\", \"Press\"))\n", "N = len(at)\n", "\n", "fig, ax = plt.subplots(1, 2, figsize=(9, 3.1))\n", "ax[0].plot(t_ps, (etot - etot[0]) / N * 1000, color=\"#1f77b4\", lw=1.2)\n", "ax[0].axhline(0, color=\"0.75\", lw=0.8, ls=\"--\")\n", "ax[0].set_xlabel(\"time [ps]\")\n", "ax[0].set_ylabel(\"$\\\\Delta E_\\\\mathrm{tot}$ [meV/atom]\")\n", "ax[0].set_title(\"NVE energy conservation (LAMMPS thermo)\")\n", "ax[1].plot(t_ps, T, color=\"#1f77b4\", lw=1.2)\n", "ax[1].axhline(85, color=\"0.75\", lw=0.8, ls=\"--\")\n", "ax[1].set_xlabel(\"time [ps]\"); ax[1].set_ylabel(\"T [K]\")\n", "ax[1].set_title(\"instantaneous temperature\")\n", "plt.tight_layout(); plt.show()\n", "\n", "drift = np.abs(etot - etot[0]).max() / N * 1000\n", "print(f\"max |E_tot(t) - E_tot(0)| = {drift:.3f} meV/atom over {t_ps[-1]:.1f} ps | \"\n", " f\" (last half) = {T[len(T) // 2:].mean():.1f} K\")\n", "for l in open(f\"{RUN}/log.argon\"):\n", " if l.startswith((\"Loop time\", \"Performance\")):\n", " print(l.rstrip())" ] }, { "cell_type": "markdown", "id": "9eeb1a20", "metadata": {}, "source": [ "## 5. Validate against direct evaluation\n", "\n", "The step-0 state is exactly the wrapped frame we wrote to `data.argon` (`velocity\n", "create` does not move atoms), so LAMMPS' first `PotEng` must equal a direct\n", "`XNNCalculator` evaluation of that frame.\n", "\n", "One subtlety, continuing the unit-constant story from the companion notebook: this\n", "coupling chains **three** codes' conversion constants (the engine converts eV\n", "$\\rightarrow$ Hartree with CODATA 2018 values; LAMMPS converts Hartree $\\rightarrow$ eV\n", "using the MDI library's own CODATA 2014-era factors). The net effect is a uniform scale\n", "factor of about $8\\times 10^{-9}$, i.e. agreement at the $10^{-7}$ eV level instead of\n", "the companion's $10^{-14}$: unavoidable between independent codes, physically\n", "irrelevant, and harmless to the dynamics (a conservative potential scaled by a constant\n", "is still conservative).\n", "\n", "The pressure decomposition also checks the MDI stress-sign convention end to end:\n", "LAMMPS' reported pressure must equal its own kinetic term plus the virial term from the\n", "engine's `" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "first peak: r = 3.56 A, g = 3.63\n" ] } ], "source": [ "rdf = np.loadtxt(f\"{RUN}/rdf.argon\", skiprows=4)\n", "r, g = rdf[:, 1], rdf[:, 2]\n", "\n", "fig, ax = plt.subplots(figsize=(4.6, 3.1))\n", "ax.plot(r, g, color=\"#1f77b4\", lw=1.4)\n", "ax.axhline(1, color=\"0.75\", lw=0.8, ls=\"--\")\n", "ax.set_xlabel(\"r [A]\"); ax.set_ylabel(\"g(r)\")\n", "ax.set_title(\"Ar-Ar radial distribution (LAMMPS, avg over 1.2 ps)\")\n", "plt.tight_layout(); plt.show()\n", "print(f\"first peak: r = {r[np.argmax(g)]:.2f} A, g = {g.max():.2f}\")" ] }, { "cell_type": "markdown", "id": "ac33f288", "metadata": {}, "source": [ "## 7. What the engine saw\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "21c8851a", "metadata": { "execution": { "iopub.execute_input": "2026-08-10T13:56:58.881868Z", "iopub.status.busy": "2026-08-10T13:56:58.881678Z", "iopub.status.idle": "2026-08-10T13:56:58.885273Z", "shell.execute_reply": "2026-08-10T13:56:58.884549Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--- runs/mdi_argon_lammps/engine.log (tail) ---\n", "INFO:__main__:MDI connection established\n", "INFO:__main__:received 400 atoms, elements [18]\n", "INFO:__main__:step 100: avg 150.1 ms/step\n", "INFO:__main__:step 200: avg 108.9 ms/step\n", "INFO:__main__:engine finished: 241 calculations, avg 102.1 ms/step\n" ] } ], "source": [ "print(\"--- runs/mdi_argon_lammps/engine.log (tail) ---\")\n", "print(\"\\n\".join(open(f\"{RUN}/engine.log\").read().splitlines()[-5:]))" ] }, { "cell_type": "markdown", "id": "2586aa1f", "metadata": {}, "source": [ "## Where to go from here\n", "\n", "**Production launch.** TCP was convenient for a notebook; on a cluster run both codes\n", "under one `mpirun` with the MPI method (`mpi4py` required on the engine side):\n", "\n", "```bash\n", "mpirun -np 1 xnn mdi --ckpt runs/mdi_argon/best.pt --device cuda:0 --dtype float64 \\\n", " -mdi \"-role ENGINE -name xnn -method MPI\" \\\n", " : -np 4 lmp -mdi \"-role DRIVER -name LAMMPS -method MPI\" -in in.argon\n", "```\n", "\n", "**Anything LAMMPS can drive, the engine can serve.** Swap `fix nve` for NPT, add more\n", "fixes/computes, or use `fix mdi/qm` in hybrid QM/MM-style setups; on the xnn side,\n", "point `--ckpt` at any family's `best.pt` (NequIP, Allegro, CACE, SchNet, ANI, PhysNet,\n", "BAMBOO, with or without LES). The protocol details of what travels over the wire are in\n", "the companion notebook [`mdi_argon_md.ipynb`](mdi_argon_md.ipynb).\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.12" } }, "nbformat": 4, "nbformat_minor": 5 }