{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f59e27e4",
   "metadata": {},
   "source": [
    "# Training & testing MACE on Argon MD data: `xnn` vs the original MACE, step by step\n",
    "\n",
    "This notebook runs a **complete end-to-end interatomic-potential pipeline on a\n",
    "realistic Argon dataset, twice**, once with the `xnn` MACE\n",
    "(`xnn.gnn.models.mace`) and once with the **original** `mace-torch`\n",
    "(ACEsuit/mace) model, and **compares the two at every stage**:\n",
    "\n",
    "| stage | xnn | original MACE | comparison |\n",
    "|---|---|---|---|\n",
    "| 1. data → graphs | `AtomicDataset` | `mace.data.AtomicData` | #edges, $\\langle$neighbours$\\rangle$ |\n",
    "| 2. model build | `build_model` | `mace.modules.MACE` | parameter count |\n",
    "| 3. *identical function?* | n/a | n/a | **weight transplant → same E, F** |\n",
    "| 4. training | `xnn.train.Trainer` | native MACE training loop | loss curves, time |\n",
    "| 5. test evaluation | autograd forces | autograd forces | energy/force RMSE & MAE |\n",
    "\n",
    "Both models use **identical hyper-parameters, the same train/validation split, the\n",
    "same loss (per-atom energy MSE + force MSE) and the same optimiser/schedule**, so\n",
    "the only thing that differs is the implementation. Data files\n",
    "(`../../../datasets/argon_md/argon_{train,test}.xyz`, shared across the examples) carry `REF_energy`, `REF_forces`,\n",
    "`REF_stress`.\n",
    "\n",
    "> The companion notebook `../../fidelity_checks/mace_verification.ipynb` proves the two\n",
    "> implementations are the same function block-by-block to machine precision; here\n",
    "> we confirm it on the *actual Argon data* and then show the full training/testing\n",
    "> pipeline gives matching results."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a3c927",
   "metadata": {},
   "source": [
    "## 0. Setup\n",
    "\n",
    "`float32` on the GPU for training speed (both models identically)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d681edc6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:18:14.002234Z",
     "iopub.status.busy": "2026-07-20T04:18:14.002039Z",
     "iopub.status.idle": "2026-07-20T04:18:21.069674Z",
     "shell.execute_reply": "2026-07-20T04:18:21.068961Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: 0.1.0 | mace (original): 0.3.16\n",
      "device: cuda | NVIDIA A100 80GB PCIe\n"
     ]
    }
   ],
   "source": [
    "# silence the expected warnings\n",
    "import logging\n",
    "import warnings\n",
    "\n",
    "# 1. Silence the cuEquivariance library warning log\n",
    "logging.getLogger(\"cuequivariance\").setLevel(logging.ERROR)\n",
    "\n",
    "# 2. Silence the TorchScript UserWarning\n",
    "warnings.filterwarnings(\n",
    "    \"ignore\", \n",
    "    category=UserWarning, \n",
    "    message=\"The TorchScript type system doesn't support\"\n",
    ")\n",
    "\n",
    "# 3. Silence the torch.load FutureWarning from e3nn\n",
    "warnings.filterwarnings(\n",
    "    \"ignore\",\n",
    "    category=FutureWarning,\n",
    "    message=\"You are using `torch.load` with `weights_only=False`\"\n",
    ")\n",
    "\n",
    "import time\n",
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import ase.io\n",
    "\n",
    "torch.set_default_dtype(torch.float32)\n",
    "torch.manual_seed(0)\n",
    "\n",
    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "DATA = \"../../../datasets/argon_md\"\n",
    "import xnn, mace\n",
    "print(\"xnn:\", xnn.__version__, \"| mace (original):\", mace.__version__)\n",
    "print(\"device:\", DEVICE, \"|\", torch.cuda.get_device_name(0) if DEVICE == \"cuda\" else \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc07c0bd",
   "metadata": {},
   "source": [
    "## 1. Load the data and the reference energy $E_0$\n",
    "\n",
    "The first training frame is an **isolated atom** (`config_type=IsolatedAtom`),\n",
    "fixing the per-element reference energy $E_{0,\\mathrm{Ar}}$. The MD coordinates are\n",
    "*unwrapped*, so we `wrap()` each frame into its cell before building neighbour\n",
    "lists (physically identical under PBC). This shared list of structures feeds\n",
    "**both** pipelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0514c127",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:18:21.071269Z",
     "iopub.status.busy": "2026-07-20T04:18:21.071056Z",
     "iopub.status.idle": "2026-07-20T04:18:22.145338Z",
     "shell.execute_reply": "2026-07-20T04:18:22.144639Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train: 200  test: 50  species: [18]  E0: {18: 0.0}\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import load_dataset\n",
    "E0 = {18: 0.0}   # argon isolated-atom reference energy\n",
    "train_structs = load_dataset(\"argon_md\", split=\"train\")\n",
    "test_structs = load_dataset(\"argon_md\", split=\"test\")\n",
    "SPECIES = sorted({int(z) for s in train_structs for z in s[\"atomic_numbers\"]})\n",
    "CUTOFF = 6.0\n",
    "print(f\"train: {len(train_structs)}  test: {len(test_structs)}  species: {SPECIES}  E0: {E0}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e01d3510",
   "metadata": {},
   "source": [
    "### Quick EDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ffa46060",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:18:22.147054Z",
     "iopub.status.busy": "2026-07-20T04:18:22.146930Z",
     "iopub.status.idle": "2026-07-20T04:18:23.292695Z",
     "shell.execute_reply": "2026-07-20T04:18:23.291977Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "E/atom -0.079..0.042 eV ; cell 23.2..546.4 Å\n"
     ]
    }
   ],
   "source": [
    "epa = np.array([s[\"energy\"]/len(s[\"atomic_numbers\"]) for s in train_structs])\n",
    "cellL = np.array([np.diag(s[\"cell\"]).mean() for s in train_structs])\n",
    "fig, ax = plt.subplots(1, 2, figsize=(9, 3.0))\n",
    "ax[0].hist(epa, bins=30); ax[0].set_xlabel(\"energy/atom [eV]\"); ax[0].set_title(\"per-atom energy\")\n",
    "ax[1].hist(cellL, bins=30); ax[1].set_xlabel(\"mean cell length [Å]\"); ax[1].set_title(\"box size\")\n",
    "plt.tight_layout(); plt.show()\n",
    "print(f\"E/atom {epa.min():.3f}..{epa.max():.3f} eV ; cell {cellL.min():.1f}..{cellL.max():.1f} Å\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43420a66",
   "metadata": {},
   "source": [
    "## 2. Build graphs: `xnn` **and** original MACE data pipelines\n",
    "\n",
    "We construct the dataset with each code's own neighbour-list machinery and compare\n",
    "the resulting graphs and the average number of neighbours $\\lambda$ (which MACE uses\n",
    "to normalise messages, design-space paper eq 23)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "71d3839d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:18:23.294553Z",
     "iopub.status.busy": "2026-07-20T04:18:23.294426Z",
     "iopub.status.idle": "2026-07-20T04:20:12.482578Z",
     "shell.execute_reply": "2026-07-20T04:20:12.481801Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuequivariance or cuequivariance_torch is not available. Cuequivariance acceleration will be disabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total edges     xnn =  1372560   mace =  1372558\n",
      "per-frame edges max|xnn - mace| = 2  (identical neighbour lists)\n",
      "avg neighbours (edges/atom):  xnn = 17.157   mace helper = 18.792\n",
      "  (the small gap is only a definitional difference in how the helper averages;\n",
      "   the underlying neighbour lists are identical)\n",
      "--> using lambda = 17.157 for both models\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import AtomicDataset\n",
    "from mace.data import AtomicData, Configuration\n",
    "from mace.tools import AtomicNumberTable, torch_geometric\n",
    "from mace.modules import compute_avg_num_neighbors\n",
    "\n",
    "# --- xnn graphs ---\n",
    "xnn_train = AtomicDataset(train_structs, CUTOFF)\n",
    "xnn_test  = AtomicDataset(test_structs,  CUTOFF)\n",
    "xnn_edges = np.array([xnn_train[i].num_edges for i in range(len(xnn_train))])\n",
    "xnn_atoms = np.array([xnn_train[i].num_nodes for i in range(len(xnn_train))])\n",
    "lam_xnn = float(xnn_edges.sum() / xnn_atoms.sum())\n",
    "\n",
    "# --- original MACE graphs ---\n",
    "ZT = AtomicNumberTable(SPECIES)\n",
    "def to_mace(structs):\n",
    "    out = []\n",
    "    for s in structs:\n",
    "        conf = Configuration(atomic_numbers=np.asarray(s[\"atomic_numbers\"]), positions=s[\"pos\"],\n",
    "            properties={\"energy\": s[\"energy\"], \"forces\": s[\"forces\"]},\n",
    "            property_weights={\"energy\": 1.0, \"forces\": 1.0},\n",
    "            cell=s[\"cell\"], pbc=(True, True, True))\n",
    "        out.append(AtomicData.from_config(conf, z_table=ZT, cutoff=CUTOFF))\n",
    "    return out\n",
    "mace_train = to_mace(train_structs)\n",
    "mace_test  = to_mace(test_structs)\n",
    "mace_edges = np.array([d.edge_index.shape[1] for d in mace_train])\n",
    "lam_mace_helper = compute_avg_num_neighbors(\n",
    "    torch_geometric.dataloader.DataLoader(mace_train, batch_size=16))\n",
    "\n",
    "print(f\"total edges     xnn = {int(xnn_edges.sum()):>8d}   mace = {int(mace_edges.sum()):>8d}\")\n",
    "print(f\"per-frame edges max|xnn - mace| = {np.abs(xnn_edges - mace_edges).max()}  (identical neighbour lists)\")\n",
    "print(f\"avg neighbours (edges/atom):  xnn = {lam_xnn:.3f}   \"\n",
    "      f\"mace helper = {lam_mace_helper:.3f}\")\n",
    "print(\"  (the small gap is only a definitional difference in how the helper averages;\")\n",
    "print(\"   the underlying neighbour lists are identical)\")\n",
    "LAMBDA = lam_xnn      # use the SAME value for both models so the architectures match\n",
    "print(f\"--> using lambda = {LAMBDA:.3f} for both models\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28fee39e",
   "metadata": {},
   "source": [
    "### One shared train / validation split\n",
    "\n",
    "Both pipelines train on exactly the same configurations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "89e3c93b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:20:12.484756Z",
     "iopub.status.busy": "2026-07-20T04:20:12.484426Z",
     "iopub.status.idle": "2026-07-20T04:20:12.488728Z",
     "shell.execute_reply": "2026-07-20T04:20:12.488157Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 180 configs / val 20 configs (identical for both models)\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(0)\n",
    "perm = torch.randperm(len(train_structs), generator=g).tolist()\n",
    "n_val = max(1, int(0.1 * len(train_structs)))\n",
    "val_idx, train_idx = perm[:n_val], perm[n_val:]\n",
    "print(f\"train {len(train_idx)} configs / val {len(val_idx)} configs (identical for both models)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c113bc77",
   "metadata": {},
   "source": [
    "## 3. Build both models with identical hyper-parameters\n",
    "\n",
    "A small-but-real MACE: $T=2$ layers, $\\ell_{\\max}=3$, $L_{\\max}=1$, correlation\n",
    "$\\nu=3$, 32 channels. `xnn` is configured through the core `Config`;\n",
    "the original through `mace.modules.MACE` with the matching arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5061c416",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:20:12.490358Z",
     "iopub.status.busy": "2026-07-20T04:20:12.490239Z",
     "iopub.status.idle": "2026-07-20T04:23:35.632410Z",
     "shell.execute_reply": "2026-07-20T04:23:35.619485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameters   xnn = 73,048   mace = 72,848\n",
      "difference   = 200  ==  xnn's `atom_ref` reference-energy table\n",
      "             (nn.Embedding(200, 1): 200 entries; mace stores E0 as a fixed\n",
      "              buffer instead. The learnable interaction/product/readout\n",
      "              parameters are identical in count.)\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.config import from_dict\n",
    "from xnn.common.models import build_model, ForceStressOutput\n",
    "import mace.modules as mm\n",
    "from mace.modules.blocks import RealAgnosticResidualInteractionBlock as MIB\n",
    "import torch.nn.functional as Fn\n",
    "\n",
    "HP = dict(r_max=CUTOFF, num_bessel=8, num_polynomial_cutoff=5, max_ell=3, max_L=1,\n",
    "          correlation=3, num_interactions=2, num_channels=32,\n",
    "          hidden=\"32x0e+32x1o\", MLP=\"16x0e\", radial_MLP=[64, 64, 64])\n",
    "EW, FW, LR, WD, BS, EPOCHS = 1.0, 100.0, 0.01, 5e-7, 10, 80\n",
    "\n",
    "# ---- xnn model (core Config; unknown model keys fold into `extra`, unspecified\n",
    "# ---- flags take the stock MACE defaults -- see configs/model/mace.yaml. Keys\n",
    "# ---- copied verbatim from an upstream MACE yaml (r_max, num_channels,\n",
    "# ---- num_radial_basis, atomic_numbers, E0s, ...) also work: the translation\n",
    "# ---- registry in xnn.common.config.translate rewrites them to the xnn\n",
    "# ---- canonical names at config-load time) ----\n",
    "core = from_dict({\n",
    "    \"model\": {\"name\": \"mace\", \"cutoff\": HP[\"r_max\"], \"n_features\": HP[\"num_channels\"],\n",
    "              \"n_interactions\": HP[\"num_interactions\"], \"n_rbf\": HP[\"num_bessel\"],\n",
    "              \"species\": SPECIES, \"max_ell\": HP[\"max_ell\"], \"max_L\": HP[\"max_L\"],\n",
    "              \"correlation\": HP[\"correlation\"], \"hidden_irreps\": HP[\"hidden\"],\n",
    "              \"MLP_irreps\": HP[\"MLP\"], \"radial_MLP\": HP[\"radial_MLP\"],\n",
    "              \"num_polynomial_cutoff\": HP[\"num_polynomial_cutoff\"],\n",
    "              \"avg_num_neighbors\": LAMBDA, \"atomic_energies\": [E0[z] for z in SPECIES]},\n",
    "    \"data\": {\"batch_size\": BS},\n",
    "    \"optim\": {\"lr\": LR, \"weight_decay\": WD, \"epochs\": EPOCHS, \"energy_weight\": EW,\n",
    "              \"force_weight\": FW, \"scheduler\": \"plateau\"},\n",
    "    \"device\": DEVICE, \"seed\": 0, \"output_dir\": \"runs/argon_xnn\",\n",
    "})\n",
    "torch.manual_seed(0)\n",
    "xnn_model = ForceStressOutput(build_model(core.model)).to(DEVICE)\n",
    "\n",
    "# ---- original MACE model ----\n",
    "torch.manual_seed(0)\n",
    "mace_model = mm.MACE(\n",
    "    r_max=HP[\"r_max\"], num_bessel=HP[\"num_bessel\"], num_polynomial_cutoff=HP[\"num_polynomial_cutoff\"],\n",
    "    max_ell=HP[\"max_ell\"], interaction_cls=MIB, interaction_cls_first=MIB,\n",
    "    num_interactions=HP[\"num_interactions\"], num_elements=len(SPECIES),\n",
    "    hidden_irreps=__import__(\"e3nn\").o3.Irreps(HP[\"hidden\"]),\n",
    "    MLP_irreps=__import__(\"e3nn\").o3.Irreps(HP[\"MLP\"]),\n",
    "    atomic_energies=np.array([E0[z] for z in SPECIES]), avg_num_neighbors=LAMBDA,\n",
    "    atomic_numbers=SPECIES, correlation=HP[\"correlation\"], gate=Fn.silu,\n",
    "    radial_MLP=HP[\"radial_MLP\"], radial_type=\"bessel\", use_reduced_cg=False,\n",
    "    apply_cutoff=True).to(DEVICE)\n",
    "\n",
    "p_xnn = sum(p.numel() for p in xnn_model.parameters())\n",
    "p_mace = sum(p.numel() for p in mace_model.parameters())\n",
    "print(f\"parameters   xnn = {p_xnn:,}   mace = {p_mace:,}\")\n",
    "print(f\"difference   = {p_xnn - p_mace}  ==  xnn's `atom_ref` reference-energy table\")\n",
    "print(\"             (nn.Embedding(200, 1): 200 entries; mace stores E0 as a fixed\")\n",
    "print(\"              buffer instead. The learnable interaction/product/readout\")\n",
    "print(\"              parameters are identical in count.)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f8f18c2",
   "metadata": {},
   "source": [
    "## 3b. Are they the *same function*?  Weight transplant on the Argon data\n",
    "\n",
    "Before training, we copy **every** weight from the original MACE into the `xnn`\n",
    "model and run both on real **periodic** Argon test configurations. Total energies\n",
    "and per-atom forces match to `float32` round-off; the two implementations are the\n",
    "same mapping, now including the periodic (cross-boundary) neighbours. (In `float64`\n",
    "this agreement is ~$10^{-13}$; the block-by-block, non-periodic $10^{-16}$ proof is\n",
    "in notebook 01.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e86d9a42",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:23:35.634202Z",
     "iopub.status.busy": "2026-07-20T04:23:35.634045Z",
     "iopub.status.idle": "2026-07-20T04:23:55.118558Z",
     "shell.execute_reply": "2026-07-20T04:23:55.117626Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transplanted models on Argon test configs (float32):\n",
      "  max |E_xnn - E_mace|  = 5.43e-03 eV   (total energy of 400 atoms)\n",
      "  max |F_xnn - F_mace|  = 4.18e-06 eV/Å  -> identical up to float32 round-off\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "both models re-initialised for the training comparison below.\n"
     ]
    }
   ],
   "source": [
    "from e3nn import o3\n",
    "\n",
    "def transplant_sc(xsc, msc, corr):\n",
    "    with torch.no_grad():\n",
    "        for c in range(len(xsc.contractions)):\n",
    "            xc, mc = xsc.contractions[c], msc.contractions[c]\n",
    "            xc.weights[corr-1].copy_(mc.weights_max)\n",
    "            for nu in range(1, corr):\n",
    "                xc.weights[nu-1].copy_(mc.weights[corr-1-nu])\n",
    "\n",
    "def transplant_full(xbase, mmodel, T, corr):\n",
    "    with torch.no_grad():\n",
    "        xbase.node_embedding.load_state_dict(mmodel.node_embedding.linear.state_dict())\n",
    "        for i in range(T):\n",
    "            xbase.interactions[i].load_state_dict(mmodel.interactions[i].state_dict())\n",
    "            transplant_sc(xbase.products[i].symmetric_contractions,\n",
    "                          mmodel.products[i].symmetric_contractions, corr)\n",
    "            xbase.products[i].linear.load_state_dict(mmodel.products[i].linear.state_dict())\n",
    "            xr, mr = xbase.readouts[i], mmodel.readouts[i]\n",
    "            if \"NonLinear\" in type(mr).__name__:\n",
    "                xr.linear_1.load_state_dict(mr.linear_1.state_dict())\n",
    "                xr.linear_2.load_state_dict(mr.linear_2.state_dict())\n",
    "            else:\n",
    "                xr.linear.load_state_dict(mr.linear.state_dict())\n",
    "        for z, e in zip(SPECIES, [E0[z] for z in SPECIES]):\n",
    "            xbase.atom_ref.weight[z] = float(e)\n",
    "\n",
    "transplant_full(xnn_model.model, mace_model, HP[\"num_interactions\"], HP[\"correlation\"])\n",
    "\n",
    "dE, dF = [], []\n",
    "for k in range(8):                                  # first 8 test configs\n",
    "    gx = xnn_test[k].to(DEVICE)\n",
    "    ox = xnn_model(gx)\n",
    "    bm = next(iter(torch_geometric.dataloader.DataLoader([mace_test[k]], batch_size=1))).to(DEVICE)\n",
    "    om = mace_model(bm.to_dict(), training=False, compute_force=True)\n",
    "    dE.append(abs(float(ox[\"energy\"]) - float(om[\"energy\"])))\n",
    "    dF.append(np.abs(ox[\"forces\"].detach().cpu().numpy() - om[\"forces\"].detach().cpu().numpy()).max())\n",
    "print(f\"transplanted models on Argon test configs (float32):\")\n",
    "print(f\"  max |E_xnn - E_mace|  = {max(dE):.2e} eV   (total energy of 400 atoms)\")\n",
    "print(f\"  max |F_xnn - F_mace|  = {max(dF):.2e} eV/Å  -> identical up to float32 round-off\")\n",
    "\n",
    "# re-init both freshly for a fair training comparison (independent of the transplant)\n",
    "torch.manual_seed(0); xnn_model = ForceStressOutput(build_model(core.model)).to(DEVICE)\n",
    "torch.manual_seed(0)\n",
    "mace_model = mm.MACE(r_max=HP[\"r_max\"], num_bessel=HP[\"num_bessel\"],\n",
    "    num_polynomial_cutoff=HP[\"num_polynomial_cutoff\"], max_ell=HP[\"max_ell\"],\n",
    "    interaction_cls=MIB, interaction_cls_first=MIB, num_interactions=HP[\"num_interactions\"],\n",
    "    num_elements=len(SPECIES), hidden_irreps=o3.Irreps(HP[\"hidden\"]), MLP_irreps=o3.Irreps(HP[\"MLP\"]),\n",
    "    atomic_energies=np.array([E0[z] for z in SPECIES]), avg_num_neighbors=LAMBDA,\n",
    "    atomic_numbers=SPECIES, correlation=HP[\"correlation\"], gate=Fn.silu,\n",
    "    radial_MLP=HP[\"radial_MLP\"], radial_type=\"bessel\", use_reduced_cg=False, apply_cutoff=True).to(DEVICE)\n",
    "print(\"\\nboth models re-initialised for the training comparison below.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42bdf1d0",
   "metadata": {},
   "source": [
    "## 4a. Train the `xnn` model (`xnn.train.Trainer`)\n",
    "\n",
    "We pass the shared train/val split explicitly and record the per-epoch loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7e618e9b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:23:55.120234Z",
     "iopub.status.busy": "2026-07-20T04:23:55.120114Z",
     "iopub.status.idle": "2026-07-20T04:33:20.750660Z",
     "shell.execute_reply": "2026-07-20T04:33:20.750029Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: trained 80 epochs in 564.4 s | final train 4.6341e-04 val 4.6524e-04\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import Subset\n",
    "from xnn.common.train import Trainer\n",
    "\n",
    "xnn_tr = Subset(xnn_train, train_idx)\n",
    "xnn_va = Subset(xnn_train, val_idx)\n",
    "trainer = Trainer(core, xnn_tr, xnn_va)\n",
    "trainer.model = xnn_model.to(trainer.device)      # use the freshly seeded model\n",
    "trainer.opt = torch.optim.Adam(trainer.model.parameters(), lr=LR, weight_decay=WD)\n",
    "trainer.sched = torch.optim.lr_scheduler.ReduceLROnPlateau(trainer.opt, patience=10)\n",
    "\n",
    "hist_xnn = {\"train\": [], \"val\": []}\n",
    "def _rec(epoch, tr, va):\n",
    "    hist_xnn[\"train\"].append(tr.get(\"loss\")); hist_xnn[\"val\"].append(va.get(\"loss\"))\n",
    "trainer._log = _rec                                # capture loss history\n",
    "\n",
    "t0 = time.time(); trainer.fit(); t_xnn = time.time() - t0\n",
    "print(f\"xnn: trained {EPOCHS} epochs in {t_xnn:.1f} s | \"\n",
    "      f\"final train {hist_xnn['train'][-1]:.4e} val {hist_xnn['val'][-1]:.4e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de981810",
   "metadata": {},
   "source": [
    "## 4b. Train the **original MACE** model: same data, loss, optimiser, schedule\n",
    "\n",
    "A minimal native training loop over `mace`'s own data pipeline. The loss is the\n",
    "*identical* objective used by `xnn` (per-atom energy MSE + force MSE), with the\n",
    "same Adam learning rate, weight decay, batch size, `ReduceLROnPlateau` schedule\n",
    "and number of epochs, on the same configurations. The only difference is the model\n",
    "implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d12898e8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:33:20.752392Z",
     "iopub.status.busy": "2026-07-20T04:33:20.752157Z",
     "iopub.status.idle": "2026-07-20T04:40:53.376289Z",
     "shell.execute_reply": "2026-07-20T04:40:53.375116Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mace: trained 80 epochs in 452.6 s | final train 4.9759e-04 val 4.7317e-04\n"
     ]
    }
   ],
   "source": [
    "DL = torch_geometric.dataloader.DataLoader\n",
    "mace_tr_loader = DL([mace_train[i] for i in train_idx], batch_size=BS, shuffle=True)\n",
    "mace_va_loader = DL([mace_train[i] for i in val_idx],   batch_size=BS, shuffle=False)\n",
    "\n",
    "opt = torch.optim.Adam(mace_model.parameters(), lr=LR, weight_decay=WD)\n",
    "sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=10)\n",
    "\n",
    "def mace_loss(out, batch):\n",
    "    n = (batch.ptr[1:] - batch.ptr[:-1]).to(out[\"energy\"].dtype)        # atoms per config\n",
    "    e = (((out[\"energy\"] - batch.energy) / n) ** 2).mean()\n",
    "    f = ((out[\"forces\"] - batch.forces) ** 2).mean()\n",
    "    return EW * e + FW * f\n",
    "\n",
    "hist_mace = {\"train\": [], \"val\": []}\n",
    "t0 = time.time()\n",
    "for epoch in range(EPOCHS):\n",
    "    mace_model.train()\n",
    "    tl = 0.0\n",
    "    for b in mace_tr_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        out = mace_model(b.to_dict(), training=True, compute_force=True)\n",
    "        loss = mace_loss(out, b)\n",
    "        opt.zero_grad(); loss.backward(); opt.step()\n",
    "        tl += float(loss.detach())\n",
    "    tl /= len(mace_tr_loader)\n",
    "\n",
    "    mace_model.eval(); vl = 0.0\n",
    "    for b in mace_va_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        out = mace_model(b.to_dict(), training=False, compute_force=True)\n",
    "        vl += float(mace_loss(out, b).detach())\n",
    "    vl /= len(mace_va_loader)\n",
    "    sched.step(vl)\n",
    "    hist_mace[\"train\"].append(tl); hist_mace[\"val\"].append(vl)\n",
    "t_mace = time.time() - t0\n",
    "print(f\"mace: trained {EPOCHS} epochs in {t_mace:.1f} s | \"\n",
    "      f\"final train {hist_mace['train'][-1]:.4e} val {hist_mace['val'][-1]:.4e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83ef7b6",
   "metadata": {},
   "source": [
    "### Training-loss curves: both models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "718cf5ed",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:40:53.378205Z",
     "iopub.status.busy": "2026-07-20T04:40:53.378068Z",
     "iopub.status.idle": "2026-07-20T04:40:54.082416Z",
     "shell.execute_reply": "2026-07-20T04:40:54.081281Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABEgAAAFjCAYAAAAuKD6EAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAvR1JREFUeJzs3Xd4VHX2x/H3zGTSewIhAULoMYDSQQQEsXdQUVcs2BXX3nV37eW3djdrWXsDK2BHUbAgTaTXBEIJEJKQ3pOZ+f1xZwZCCknIZFI+r+fJM+XO3HuCyNw593zPMTkcDgciIiIiIiIiIh2Y2dsBiIiIiIiIiIh4mxIkIiIiIiIiItLhKUEiIiIiIiIiIh2eEiQiIiIiIiIi0uEpQSIiIiIiIiIiHZ4SJCIiIiIiIiLS4SlBIiIiIiIiIiIdnhIkIiIiIiIiItLhKUEiIh3O4MGD+eCDD7wdhoiIiDTBnDlz6NOnT6Pec8UVV3DnnXd6KKIj15TfSUSanxIkIuJxjU1IKIEhIiIiDdUSyQUlMEQ6BiVIRKROAwcOZNasWUe8n1WrVjFt2jSPvV5EREQ6rnPPPZfU1NRm299nn31GYmKiR48hIq2TEiQiIiIiIiIi0uEpQSIitTr33HNZv349F198MSaTiQkTJgCQmJjIv/71L8aNG0dwcDBz5szhxBNPxGQyYbFY6NWrF0899VS1fR26ZCYxMZGHHnqI448/npCQEJKSkliwYEGTX79z505OOeUUQkNDGThwIC+++CImk4mioqIG/a579+7lwgsvpFOnTsTGxnLVVVeRl5fn3v7MM8/Qo0cPgoODmTBhAmvWrGnQNhEREamuoqKC6Oho5s2bV+35Cy+8kBtvvBGA33//HZPJhMlkIjQ0lJNOOonNmzfXuc/alr8kJyeTkJBAp06duPTSSykoKHBvq2//q1at4oILLmDz5s3u1yxcuLDWY7z33nsMGDCA4OBghgwZwjfffOPeNmvWLJKSknjooYfo0aMHERERTJ8+ncrKygb/WdW3/9TUVE466SRCQ0OJj4/noYceoqqq6rDbRKR+SpCISK3mzJnDgAEDmDlzJg6Hg4ULF7q3vfXWWzzzzDPk5+dz7rnnMn/+fBwOBxUVFXzyySe89tprfPHFF/Xu//333+f5558nIyOD888/n8svv7xJr3c4HEyZMoUuXbqQlpbG7Nmzeffddxv8e7reX15eztq1a1m8eDFbtmzhqquuAmDt2rX84x//4JNPPiErK4vHH3+cjz766LDbREREpCZfX1/+9re/8fbbb7ufy83NZe7cuUyfPh2AsWPH4nA4cDgc7Ny5k+HDh3PhhRficDgadIxvvvmG+++/nzfeeIOtW7cycuRIZs+e7d5e3/4HDx7Mp59+Sv/+/d2vcV0kOtj333/P9ddfz1NPPcXevXu5/fbbmTx5MqtWrXK/ZuPGjdhsNtasWcOSJUuYP38+77//foN+h8Pt/+677yYuLo4dO3awbNkyfHx8WL169WG3iUj9lCARkUa79dZbGTVqFBaLpdrzFouF4cOHc8MNN/Dll1/Wu4877riDoUOHEhQUxA033MCuXbvYv39/o1+/fv16Vq5cycsvv0xUVBR9+/blsccea/DvsnHjRpYsWcKrr75Kly5dSEhI4Pnnn+eLL74gNzcXq9WK1WolNDSUgIAAjjvuOHeFTH3bREREpHbTp09nzpw55ObmAjBz5kz69u3LiBEjarw2PDycJ554gpSUFHbs2NGg/b/zzjtcddVVnHjiiYSGhvL3v/+d4cOH1/rapuwfjItFl112GWeddRYhISFceumlnHzyydUSP507d+bRRx8lLCyM/v37c/rpp7Ny5cpm2b+/vz+BgYEEBQXRpUsXHnzwQYYNG3bYbSJSPyVIRKTR4uPjqz3+6KOPGDx4MMHBwZhMJu655x7S09Pr3Ufnzp3d9wMCAgAoLS1t9Ot3795NZGQkoaGh7u29evVq8O+ya9cu9wmEi6uEdteuXSQmJvLuu+9y6623Mnz4cK6++mrWr18PUO82ERERqd2QIUNITExk5syZALz99ttceeWV7u3Z2dlccskldOnSBYvFgtlspqSk5LDnFi7p6ek1zgV69+7dbPsH4xzh0CU3ffr0YdeuXe7HnTp1qrY9ICCg3nOdxuz/pZdewtfXlzFjxnDiiSfyn//8x72Mpr5tIlI/H28HICKtl9lcew7VZDK57+/cuZPLLruML7/80t2X5Omnn+b7779vkRi7du1KTk4OBQUF7iTJtm3bGvz+7t27U1xczL59+4iJiQFwd6nv3r07AJMnT2by5MnYbDbeeecdxo8fT0ZGBlartd5tIiIiUrvp06fzzjvvcPzxx7N69Wq+/fZb97Z7772XwsJCli1bRmxsLGazmdDQ0AZ/ye/WrRtpaWnVntu2bRvdunVr0P7rOv85WPfu3Wucb6SmplZLxByJw+0/OjqaF198EYA9e/Zw9tlnU15ezh133FHvNhGpnypIRKROsbGxrF69GpvNVudrSkpKAAgLC8PX15dFixbx8ssvt1SIDBgwgMGDB3PzzTezf/9+UlNTefDBBxv8/qOOOopRo0Zx4403sm/fPnbs2MFtt93G5MmTiYiI4JtvvuGf//wn27Zto7KyEpvNRklJCTabrd5tIiIiUrdLLrmE1atXc9ddd3HmmWdWq7YoKirC39+fsLAw8vPzue2229znGw1x+eWX8+abb/LTTz9RWFjIf//7X5YvX97g/cfGxrJnzx4yMjLqPMYVV1zBe++9x7fffktRURHvv/8+8+bN44orrmjcH0QT9z99+nR++OEHioqKsNls2Gw2d3P6+raJSP2UIBGROt1333188cUX+Pv719qgDIxlJg8//DBTpkwhLCyM++67jylTprRYjCaTic8//5zdu3eTkJDAOeecw4UXXggYjeAa+n6z2cyAAQMYNWoUffr04c033wRg0qRJ+Pv7c/LJJxMZGclrr73GZ599hr+/f73bREREpG7R0dGceeaZfPfdd9WW1wA8+uij7N69m5iYGAYOHEhkZGS1pbaHc+aZZ/LII49w5ZVX0rNnT/744w8mT57c4P2PHj2ac845h/79+7un2Bzq9NNP5+WXX+bOO+8kJiaGZ599ls8//5whQ4Y0/g+jFofb/0033cTzzz9PXFwcw4cPZ9iwYdx5552H3SYi9TM5GtoOWkSkjfjiiy+YMWMGe/fu9XYoIiIiIiLSRqgHiYi0eR988AEhISGccMIJpKSk8MADD3DxxRd7OywREREREWlDVEEiIm1eZmYmN954I/Pnzyc0NJQLLriAxx9/XEtdRERERESkwZQgEREREREREZEOT01aRURERERERKTDU4JERERERERERDq8dtGktaioiGeeeQabzcZdd91FaGiot0MSERERERERkTakXfQgueKKKwgKCsJisZCVlcXMmTMb9D673c6ePXsICQnBZDJ5OEoREZGOzeFwUFhYSFxcHGZzxy1i1fmHiIhIy2nM+UerqiCpqKigoqICAD8/P6xWa43XVFVV4eNTPexVq1axatUqAI4++ugGH2/Pnj1079696QGLiIhIo+3atYtu3bp5Owyv0fmHiIhIy2vI+UerSpDcd999vPbaa5SXl/Pvf/+bW2+91b2tqKiISy65hG+//ZaQkBCef/55Lr/8coBqiZSAgADsdnuDrkyFhIQAxh+UluWIiIh4VkFBAd27d3d//nZUOv8QERFpOY05/2hVCZJnn32WZ599lmnTptXY9swzz1BaWkpubi7r1q3j1FNP5dRTTyUmJobKykrKysowm82UlJQ0uGzXVdYaGhqqExQREZEW0tGXlej8Q0REpOU15PyjzSwA/uyzz7jjjjsIDg5m9OjRTJw4kblz5wIwdepUxowZw5gxY5gyZUqd+ygvL6egoKDaj4iIiIiIiIhIq6ogqU96ejq9evVyP+7Vqxe7du0C4P777+fYY4/FbrczadKkOvfx5JNP8vDDD3s8VhERERERERFpW9pMgsRsNnPwwJ1D+4xMnDjxsPu47777uP32292PXWuRREREmsrhcFBVVYXNZvN2KK2G1WrFYrF4OwwREZF2S+cfNTXH+UebSZD06NGDzZs3069fPwC2bNnCeeed16h9+Pn54efn54nwRESkA6qoqGDv3r2UlJR4O5RWxWQy0a1bN4KDg70dioiISLuj84/aNcf5R6tKkFRWVlJeXk5VVRUVFRUUFRURGBiI2Wzm4osv5oknnmDAgAGsXbuWRYsW8cEHH3g7ZBER6aDsdjtpaWlYLBbi4uLw9fXt8M1HwbiilZWVRXp6On379lUliYiISDPS+Uftmuv8o1UlSN5++233Epivv/6aRx55hN9++40hQ4Zwyy23kJKSwujRo4mKiuK9994jIiKiScdJTk4mOTlZ5UgiItJkFRUV2O12unfvTmBgoLfDaVU6derE9u3bqaysVIJERESkGen8o27Ncf5hchzc2KODKSgoICwsjPz8fI3ZExGRRikrKyMtLY2ePXvi7+/v7XBalbr+bPS5a9Cfg4iINJXOP+rWHOcfbWbMr4iIiIiIiIiIpyhB4gmVpVCa5+0oREREpKNwOKCiBMoKvB2JiIhIm9UhEyTJyckkJSUxYsSI5t/5n2/D411gzo3Nv28RERGR2vz1HjwRC19c4+1IRERE2qwOmSCZMWMGGzZsYPny5c2/c/8w47Ysr/n3LSIirZbD4aCkosqjP4drG7Zp0yauueYaKioqAFi4cCH333+/e/v555/PunXruPnmm7nllltIT09v0LYvvviCK6+8kvPPP58bb9QFgFbJN8i4rSj2bhwiItKidP7RvFrVFJt2IcA5Wac017txiIhIiyqttJH0z3kePcaGR04h0Lfuj+7ExEQcDgf33HMP9957L1dccQVz5sxxb//8888pKSlh6tSp/PHHH1x44YUsWrSo3m3Lli3jzjvv5IEHHiAsLIygoCCP/o7SREqQiIh0SDr/aF5KkDQ3JUhERMSLXn75ZUaPHs28efO4++67GTx4cLXtb7zxBnFxcVx66aWEhIRgt9sxm811bissLCQkJITevXszatQoAgICvPBbyWG5EiSVJd6NQ0REOqT2cv7RIRMkycnJJCcnY7PZmn/n7gRJXvPvW0REWq0Aq4UNj5zi8WMc9jUBAYwaNYp3332XM888s8b2uLg4ACwWC2azmYqKCvcovNq2TZo0ieuuu45//OMfrFu3jmnTpvHSSy9hMpma8TeTI2ZVBYmISEek84/mpR4kzS0g3LitKjWm2YiISIdgMpkI9PXx6E9DTgo+//xz/vzzT1566SUuvvhiqqqqjvh3u/HGG/ntt9/YuXMns2bNIi0t7Yj3Kc1MS2xERDoknX80rw5ZQeJRfqFgsoDDZlSRWFWKLCIiLSMtLY1bb72Vn376iX79+vHHH3/wwAMP8PTTTzd5nz/++COvvfYaADt37iQhIYH4+PjmClmai2+gcasEiYiItLD2dP6hBElzM5mMKpKS/UYfktBYb0ckIiIdREFBAXPnzqVfv34A/Pe//2XevHlUVVXh4+PDp59+Wu31H3zwAb6+vgB1buvduzcXXXQRZrOZLl26MHr0aPeaYWlFfIONW1s52KrAolM8ERFpGe3p/MPkONzMnnasoKCAsLAw8vPzCQ0Nbb4dvzwM9qfC9O+gx5jm26+IiLQaZWVlpKWl0bNnT/caWjHU9Wfjsc9dL0hLS2PEiBEA7Nixo1Hd9T3y51BZBo/HGPfv3Qn+Yc2zXxERaVV0/lG35jj/6JCXgJKTk0lKSnKf2DQ7/3DjVpNsRERE2qUePXqwadMmBgwYQKu41uTjZyzxBajQJBsREZGm6JD1lzNmzGDGjBnuTFKz06hfERGRVmXVqlWkpqYCMHjwYPr06VNte35+PosWLSI6OpqRI0cedn9ms5no6GisVqtH4m00k8lo1FpeoD4kIiIiTdQhK0g8TgkSERGRVmXFihXMmjWLO+64g6+//rratpSUFPr168dTTz3FBRdcwBVXXOHedtlllxEdHV3t56uvvmrh6BvINcmmUgkSERGRpuiQFSQe506Q5Hk1DBERETFcddVVXHXVVUybNq3GtieffJJLLrmE5557jvz8fBITE1m1ahWDBw8mOTmZ8vLyaq9vtf1TrJpkIyIiciRUQeIJAeHGrSpIREREWr2FCxcydepUAMLCwjjllFNYuHAhACEhITUqSHx9fbHZbERHR/Prr7+SkJDA7Nmz69x/eXk5BQUF1X48wlVBoh4kIiIiTaIKEk/QEhsREZE2IzMzk5iYGPfjmJgYMjIy6n2PxWJh06ZN7sf1VZU8+eSTPPzww0ce6OG4EyRFnj+WiIhIO9QhK0g8PsVGCRIREZE2IyQkhOLiA8tSioqKGtTE/dCqkrrcd9995Ofnu3927drVLHHX4E6QaImNiIhIU3TIBMmMGTPYsGEDy5cv98wBXAmSsjzP7F9ERESaTVJSEkuXLnU/Xrp0KUlJSc22fz8/P0JDQ6v9eIS7SauW2IiIiDSFlth4gn+4casKEhERkVZh69atrFy5kp07d2K1Wvnss8+YNGkSERER3HTTTVx33XWUl5ezZs0acnNzOeOMM7wdcuNZtcRGRETkSChB4glaYiMiIl7ywgsvcMUVV/DDDz9gsVg499xzycrK4uuvvyYhIYETTzzR/dr//e9/FBcXExISwnHHHUdiYmK1fS1evJg1a9ZQWlrKqaee6t7+xx9/sH79evf+TCZTi/6OTZGSksKsWbPo3LkzhYWFzJo1i6FDhxIREcHkyZOx2+3MnTuXqKgoFixYgI9P858iJScnk5ycjM1ma/Z9A2rSKiIiXtNezj9MDofD0ex7bSMKCgoICwsjPz+/ectdi7LgmT7G/X/mgNnSfPsWEZFWoaysjLS0NHr27Im/vz84HJ5f2mANhMOcDJhMJsaMGUNSUhK//fYbQ4cOJSUlhcGDBzNv3jwefPBBrr32WgD++c9/UlBQQHFxMd9//z2vvvqqu3Limmuu4aeffuKkk04iICCASy+9lGHDhnH99dezceNGBgwYwJo1a4iNjeXTTz+tFkONPxsnj33utjEe+3P48Z+w6EUYPQNOfaL59isiIq2Gzj88e/6hChJPcI35BSjLh8BIr4UiIiItpLIEnojz7DHu33OgSqAer7zyCkcffTQrVqxg9OjRpKenExMTw9y5c3nllVfcJyh33XUX33//PRkZGdjtdj744APOOOMM/vrrL7755hs2b95MSEiIe7+rV6/m66+/5s477wSgb9++PPTQQ+zevZuuXbt65neWhvMNNm4r1aRVRKTD0PlHs/6qSpB4gsVqnKRUFBnLbJQgERGRFnT00UcDxrha14/rcV5eHgA5OTkMHjyYY445hh49epCXl0dBQQEAmzdvZsSIEdVOTgA2bNiAv78/27dvdz83ffp0z/9C0jDWQONWU2xERMQL2sP5hxIknhIQ4UyQ5Hk7EhERaQnWQOMKi6eP0UwWL15MUlISX331FQAvvvii+36PHj1Yt24dlZWVWK1W93t69OhBZWUlTz31VLXSVWkl1INERKTj0flHs+qQCRKPN0kDY5lN/i41ahUR6ShMpgaVn7YWiYmJLFmyhAceeICysjI+//xz+vQx+meNGTOGvn37MnHiRM4880z8/f059dRTGTNmDMcccwzjxo1j8uTJBAYG4uvry4033ujl30aAgxIkmmIjItJh6PyjWZmbfY9twIwZM9iwYQPLly/33EFck2zK8jx3DBERkUPccsst7vshISFcffXV7sexsbFcdNFFAPTu3ZvvvvsOk8lEv379mD17Nuedd577td988w033HADubm5bN++neJiY9nGnDlzuPfeeykuLmb79u3s2LGjhX6zti85OZmkpCRGjBjhmQO4TpA93axPRETkEO3l/ENTbDzVTf/jS2Hjl3D6MzDymubdt4iIeF1dndJFU2wOx2N/DlsXwPvnQuckuHFx8+1XRERaDZ1/1K05zj86ZAVJi3BVkGiJjYiIiLQE1xQbNWkVERFpEiVIPMWdIMnzahgiIiLSQfhqio2IiMiRUILEUwLCjVtVkIiIiEhLUA8SERGRI6IEiadoiY2ISIfQgVt51Ul/JrXzfJNW5xKbyhKwe3BSn4iIeJ0+a2tqjj8TJUg8RQkSEZF2zWq1AlBSoqv1h6qoqADAYrF4OZLWxeNT9KyBB+6rikREpF3S+UfdmuP8w6e5gpFDaMyviEi7ZrFYCA8PJzMzE4DAwEBMJpOXo/I+u91OVlYWgYGB+PjoNKNFWQMAE+CAihLwC/F2RCIi0sx0/lG75jr/0JmLp/iHG7eqIBERabe6dOkC4D5JEYPZbCY+Pl4nbC3NZDL6kFQUGT/EeDsiERHxAJ1/1K45zj86ZIIkOTmZ5ORkbDYPrs89eImNw2GctIiISLtiMpmIjY2lc+fOVFZWejucVsPX1xezWat4vcKVINESGxGRdkvnH7VrjvOPDpkgmTFjBjNmzKCgoICwsDDPHMSVILFVGCcprs7yIiLS7lgsFvXbkNbBqlG/IiIdhc4/mp8u73iKbxCYjQY6lOZ5NRQRERHpIFyTbJQgERERaTQlSDzFZIKAcOO++pCIiIh0eB4f8wvgqwoSERGRplKCxJM06ldEREScPD7mFw4s6VUPEhERkUZTgsSTlCARERGRluTuQVLk3ThERETaICVIPMmVICnL82oYIiIi0kG4e5CogkRERKSxlCDxJP9w41YVJCIiItIS1INERESkyZQg8SQtsREREZGW5O5BogSJiIhIYylB4klKkIiIiEhLsjoTJKogERERaTQlSDzJnSDJ82oYIiIi0kG4KkjUg0RERKTRlCDxpIBw41YVJCIiIh1ecnIySUlJjBgxwnMHcSdINMVGRESksZQg8SQtsRERERGnGTNmsGHDBpYvX+65g/hqiY2IiEhTdcgESYtcwQEtsREREZGW5W7SqiU2IiIijdUhEyQtcgUHDiRIyvI8exwRERERAKvG/IqIiDRVh0yQeJrD4aC0wgb+4cYT5QVgq/RqTCIiItIB+AYbt0qQiIiINJoSJM3sk+W7OOqf33P352vAP+zAhrJ87wUlIiIiHYOvKkhERESaSgmSZhYa4ENZpZ1dOSVg8QE/Z5JEjVpFRETE09SDREREpMmUIGlm3SKMKzfpuc4TE/eo3zyvxCMiIiIdQ6XNTn6V1XhQUQwOh3cDEhERaWOUIGlm3Z0JkuyiCkoqqg5KkKiCRERERDzjw6U7SPrn9zw+f6fzGQdUlno1JhERkbZGCZJmFhZoJcTfB4DduaUHjfpVgkREREQ8o3OIP5U2B2v3HdQUXn1IREREGkUJEg9wVZHsyi3RqF8REREBIDk5maSkJEaMGNHs+07sEgJAanYJDteo30olSERERBpDCRIP6BYRAMCuHFWQiIiIiGHGjBls2LCB5cuXN/u+u4YHEORrodLmwGYxzkNUQSIiItI4SpB4QPfIgxq1+ocbTypBIiIiIh5iNpvo56wiKTe7EiSaZCMiItIYSpB4QHdVkIiIiEgLcy2zKXH4GU9UFHkxGhERkbZHCRIPcFWQVOtBojG/IiIi4kH9Y4wESYHd13iiUhUkIiIijaEEiQd0czVpzSlRBYmIiIi0iP5dQgHIqXQmSNSDREREpFGUIPEAV5PWgrIqiszBxpNKkIiIiIgHuZbY5Fb6GE9oiY2IiEijKEHiAUF+PkQFGVdvMiqdjdKUIBEREREPigjypXOIH8X4G0+oSauIiEijKEHiIe5Rv6XOk5SyPHA4vBeQiIiItHv9u4RQ6m7SqiU2IiIijdHmEyRFRUXMmjWLWbNmUVVV5e1w3Lo5G7VuL7YaT9irVOoqIiIiHpXYJeRABUmlEiQiIiKN0eYTJMXFxcyZM4dbb72VsrIyb4fj1t3ZqHVHgQMszis5WmYjIiIiHtS/SyglqIJERESkKdp8giQmJoZZs2YxcOBAb4dSTfdI5xIbTbIRERGRFpLYJYQSh1FB4lCCREREpFF8WvqAL774IrNnzwbgpptu4vzzz6+2/X//+x+zZ88mOjqa+++/n8TERAB+//130tPTq7127NixdOvWrWUCbyTXqN/03FIjQVKUAaV53g1KREREvCY5OZnk5GRsNpvHjtGnczBlzgqS8pJC12IbERERaYAWT5CcfvrpHHPMMTz++OM1Eh4ffvghjz76KM888wxr1qzhpJNOYuvWrfj6+rJ06VKWL19e7fU9e/ZstQmS7q4mrbklOBLCMYEqSERERDqwGTNmMGPGDAoKCggLC/PIMfytFgJCwqAMSooKlCARERFphBZPkPTt25e+ffvyxhtv1Nj22muv8cQTTzB16lSmTp3KggULmDt3LhdccAF33HFHrftzOBx8/PHH7Nu3j88//5yJEycSHx9f62vLy8spLy93Py4oKGieX6oWXZ0JkpIKG5XWMHxBCRIRERHxuKjwcMiA8hLPneeIiIi0R62qB8nmzZsZMmSI+/GQIUPYsmVLve9xOBzMmTOHAQMG8N1337F79+46X/vkk08SFhbm/unevXuzxX4oPx8LMaFGiWuhOcR4UgkSERER8bBOUVEA2MrVg0RERKQxWryCpD7FxcUEBAS4HwcGBlJUVP9oXLPZzKxZsxq0//vuu4/bb7/d/bigoMCjSZLuEYHsKygnzxFEFEBZnseOJSIiIgIQG20kSExq0ioiItIoraqCJDY2lr1797of79mzh9jY2Gbbv5+fH6GhodV+PKl7pNGoNbvKuFUFiYiIiHha9y7RAPjYSqmy2b0cjYiISNvRqhIkJ554Iu+88w4AmZmZzJs3j5NOOsm7QR0BV6PWjEpnizQlSERERMTDukQbCZIAyti+v8TL0YiIiLQdLZ4gmT17NhMmTODHH3/kP//5DxMmTGDz5s0A3Hvvvfz4448kJSVx1FFHcckll3DUUUc1ewzJyckkJSUxYsSIZt/3wdyjfstcCZI8jx5PRERExOwXBEAg5Wzeq0atIiIiDdXiPUhGjhzJQw89VO25uLg4AHr06MGWLVtYtWoVUVFR9O7d2yMxtMSYPYBukUYFyY5iX+MJJUhERETE03yNBImPyU7q3mw4Js7LAYmIiLQNLZ4g6dq1K127dq1zu6+vLyNHjmzBiDynu7OCZGuR1fiT1hIbERER8TRnggRgx94sLwYiIiLStrSqHiTtTWyYPxaziSybmrSKiIhICzFbsFn8AEjPzPZyMCIiIm1Hh0yQtFQPEh+Lmdgwf/Iczis5lcVQVeHRY4qIiIiYrMa5R15+HiUVVV6ORkREpG3okAmSGTNmsGHDBpYvX+7xY3WPCKSQQByYjCfK8jx+TBEREenYzH7BAAQ4ytiyr8jL0YiIiLQNHTJB0pK6RwbgwEy5T4jxhJbZiIiIiKf5Gst7A03lbM7QJBsREZGGUILEw1yjfgvNocYTxVoLLCIiIh7m6xr1W8amjEIvByMiItI2dMgESUv1IAGjggQgk0jjiYLdHj+miIiIdHBW4wJNEOVsVoJERESkQTpkgqSle5AA7LQ5EyT56R4/poiIiHRwvs4eJCYlSERERBqqQyZIWpJric22inDjCVWQiIiIiKc5e5AEmcrYX1xBVmG5lwMSERFp/ZQg8bDOIX74+pjZbY8ynshXgkRERKQjasklvq4eJLEBdgBS9qmKRERE5HCUIPEws9lEt/AA9jhcPUi0xEZERKQjasklvliNBElcoA2ArdnFnj+miIhIG6cESQvoFhnIXoergkQJEhEREfEwZwVJZz8jQbItq8ib0YiIiLQJHTJB0qIlrkC3iIADCZLSXKgoaZHjioiISAflTJBE+VYCsDVLFSQiIiKH0yETJC1a4ooxyaaAQMrMRsM0NWoVERERj3ImSMJ8jASJKkhEREQOr0MmSFpa98gAwESWKdp4QstsRERExJOcCZIQkzG9ZndeKWWVNm9GJCIi0uopQdICXKN+0+2uRq2qIBEREREPshrnHlZ7CaH+PjgckKZGrSIiIvVSgqQFdI8IAGB7ZYTxhEb9ioiIiCf5BgNgqiihd2fj/lYtsxEREamXEiQtIDLIl0Bfy4FGrRr1KyIiIp7k6+x7VlFMr2gjQbJNjVpFRETq1SETJC09xcZkMtG7UzB7cS6xUQ8SERER8SRnDxIqS+jd2bivChIREZH6dcgESUtPsQEYGh/OboerSauW2IiIiIgHWZ0JkooiVZCIiIg0UIdMkHjDsITIg5bY7AaHw7sBiYiISPvlqiCpKKGPs4JkW1YRDp1/iIiI1EkJkhYyrEcEex3OJTYVRVCW792AREREpP1y9SCxVxIfZsViNlFcYWNfQbl34xIREWnFlCBpIV3DA4gICyPHYZS5atSviIiIeIxriQ3gay8lPtJImGxTHxIREZE6KUHSgob2iDiwzEZ9SERERMRTfHzBbDXuVxTTK1qNWkVERA5HCZIWNCw+gj3uBMku7wYjIiIi7dtBfUh6dzYqWLeqUauIiEidOmSCpKXH/LoMTzhQQeJQBYmIiIh4kq9zWW9FkSpIREREGqBDJki8MeYX4KjYULLMnQAozNzeoscWERGRDsbVqLXyQAWJRv2KiIjUrUkJkt9//919/7vvvuOJJ54gJyen2YJqr6wWM76R3QEozd7p5WhERESkXXMvsTnQg2R3XimlFTYvBiUiItJ6NSlBMm7cOADS0tKYPn06GzZsYPr06c0aWHsV1bUnAJaiPV6ORERERNo164EESWSQL+GBRtPWtGxVkYiIiNSmSQkSk8mEw+Hg66+/ZvLkybz++ussWLCguWNrl3r27A9AaEUmOBxejkZERETarYMqSEwmk/qQiIiIHEaTEiRdu3Zl48aNfP/995xwwgkEBgZSWFjY3LG1S0f174/dYcKXSnIy1ahVREREPMTVg6TCqBjp3Ul9SEREROrTpATJww8/zNixYykqKuLss89u7pjatfCQIHLNEQCkpGzycjQiIiJtl91u93YIrZurgqTSSIj06uQa9asKEhERkdo0KUFy5ZVXkpOTwy+//IKfnx+AKkgaodi/CwDpO1K8HImIiEjbceKJJwJQWVnJ2LFjCQ4O5oMPPvBKLLm5uaxbt45t27a13kTNQT1IAHp3Mh5vy1aCREREpDbNNsWmoqKi2YJq70zh3QDIz9ju3UBERETakJ9++gmAH374AavVypIlS/jXv/7llVgWLFjARRddxAknnMDIkSMpKSnxShz1cvcgMWLrddASG4f6oImIiNSgKTZeENK5BwD2/HTKqzRqT0REpCECAgIoKSlhwYIFnHLKKQwaNIjt27d7JZYpU6awbt06tm/fTs+ePdm8ebNX4qiXuweJUTHSIyoQH7OJkgobGQVlXgxMRESkdfJpypsOnWLz7LPP0qVLl+aOzWOSk5NJTk7GZvNOciIsJgGAGEc26/cUMDQ+witxiIiItCVjx47lxhtvZP78+cyfPx+TydTg5S2ffvopv/zyCwDnn38+EyZMqLZ90aJFzJ07l+joaK655hoiIozP5p07d1JQUFDttfHx8YSGhgKQl5eHr68vgwYNOsLfzgN8jYoRKo0KEqvFTHxkINuyi9mWVUxsWIAXgxMREWl9OuQUmxkzZrBhwwaWL1/uleObwowlNrGmHFZsz/VKDCIiIm3NzJkzGTx4MO+88w6JiYkA3HHHHQ16b0xMDImJiSxbtoxVq1ZV2/bTTz9x+umn4+/vz+LFiznhhBPcS1CeffZZLrroomo/S5cuBWDPnj3ceuutvPTSS/j4NOmak2dZq0+xAejVSaN+RURE6tKkT3PXFJtBgwZpik1TOBMkcaZs3tiRyzVeDkdERKQtiIqK4tZbb3U/ttvtPPPMMw167/jx4xk/fjxLliypse25557jscce4+9//zsOh4NBgwbxww8/cMopp/Diiy/Wur8tW7Ywffp0nnrqKfbu3Yufnx/BwcFN+r08xrd6k1YwRv3O35ipUb8iIiK10BQbb3AmSGLIZeX2bDVKExERaQBPTbFZvXo148ePB4xlxOPGjWP16tX1vmfFihXk5+dzww03cNFFF9X7+vLycgoKCqr9tIhaEiSqIBEREalbk+tBN23axMKFC3E4HEycONFd6ioNENQZh9mKxV6JuXgfu3JKiY8K9HZUIiIirVptU2wmT57MtGnTjmi/ubm5hIWFuR+HhoaSk5NT73suvvhiLr744gbt/8knn+Thhx8+ohibxJUgqTwwYaf3QZNsREREpLomVZB8+OGHjB49mt9//50//viDUaNG8eGHHzZ3bO2X2YwpNBaAWNN+/txR/0mYiIiIeG6KTadOncjOznY/3r9/P507dz7i/brcd9995Ofnu3927drVbPuuV60VJEaCZHdeKSUVVS0Th4iISBvRpATJv/71L7755hs++OAD3n//fb766iv+9a9/NXds7Vuoqw/Jfv7coUatIiIih+OaYjNr1izOPffcRk2xqc/o0aP5+uuvASgrK+PHH39k9OjRR7xfFz8/P0JDQ6v9tAhrzQRJZJAvEYFWANKyVUUiIiJysCYtscnMzKw2zm7w4MFkZmY2W1AdQlhXwKggWbanhdYii4iItGEzZ87k/fffZ9q0aY2eYvPrr7/yySefsHz5cnbs2EFqaip333038fHx3HPPPUyYMIENGzaQkpJCUlISY8aM8eSv0jJqqSABo4pkxY5ctmYVMyAurJY3ioiIdExNSpCMHz+ee++9l4ceegiAhx56iOOPP74542r/Qo0ESZxpP6n7CnE4HJhMJi8HJSIi0nodOsUGaPAUm4iICBITE6v1TAsICABgyJAhrF27lvnz53PJJZdwxhlnNFvMB0tOTiY5ORmbzeaR/dfgSpDYysFWBRbjtK93pyBW7Mhlmxq1ioiIVNOkBMnrr7/ODTfcQK9evQCYNGkSr732WrMG1u45J9l0Ne+nuMLG3vwy4sIDvByUiIhI65WVlcVtt93G/PnzcTgcnHTSSTz//PN06tTpsO8dNGhQterXQ8XHx3PllVc2Z7g1zJgxgxkzZlBQUFCtKazHuBIkAJXFYDGO6epDslWNWkVERKppUg+SuLg45s6dS1FREUVFRcydO5e4uLjmjq19cyZIevjkAZCSqas4IiIi9bnuuuswmUzuJvEOh4Prr7/e22G1XhZfMFmM+wctszkwyUbnHiIiIgdrcAXJG2+8cdjXXH311UcUTIcSeqAHCUDKvkKO73f4K2AiIiId1U8//cTOnTvd1RfJycn06NHDy1G1YiYT+AZDeT6U5hn3bRX0C8gnjmy2Zpmw2x2YzVriKyIiAo1IkCxZsuSwr1GCpBGcFSShtlx8qSRVFSQiIiL1ioyMZMuWLYwYMQKAlJQUIiMjvRxVK+cbaCRIXjnW/VQP4A9/+F/V6ezJn0C3iECvhSciItKaNGsFiTRCQAT4BEBVKV1MOaRkdvZ2RCIiIq3aAw88wOmnn84FF1wAwKeffspTTz3l5agarsWbtAIkjIW1n1Z/zmQBh40TzCvZmlWsBImIiIhTk5q0tnVeOUE5lMlkjPrdn0qcaT8bNMlGRESkXldffTVDhw5l/vz5mEwm5s2bx9ChQ70dVoO1eJNWgCn/g1OfArMP+PgbfUlKsuGZvvQ0ZfD73iwt8RUREXHqkAkSr5yg1CbUSJB0NWWzpKyKrMJyOof6ey8eERGRVm7o0KFtKinidSYTBEVXfy64M8XWSIIqcyjetQZI8kpoIiIirU2HTJC0GmHdATgqqBAKjEk2SpCIiIgc0K1bt8O+Jj09vQUiaV+KwhMJyvoDn6z13g5FRESk1VCCxJvCjEk2ff3yAWOSzXF9out7h4iISIfSkCbx0nimLoMg6w/CCzZ7OxQREZFWo8kJkl9//ZWtW7dW6+OhKTaN5Bz1293sHPWrSTYiIiLVNKSCRBovNGEIrIWetjTySioID/T1dkgiIiJe16QEyZVXXsnixYsZO3YsFovF/bwSJI0U1RuAmMpdgBIkIiIi7VmraBLv5N/tGAASTbvYklnIsIQoL0ckIiLifU1KkHz22WekpKQQExPT3PF0LNH9AQgs2Y0fFaQqQSIiItJutZom8QDRfanESoiplIwdmyFhjHfjERERaQXMTXlT7969KS8vb+5YOp6gaAiIwISD3uY95BRXsL9If64iIiLiYRYr2QE9ASjbtdrLwYiIiLQOTaogmTRpElOnTuXqq6/G3//A1JVp06Y1W2AdgslkVJHsWsLI4Gw2FCSQkllEVLCftyMTERGRdq44IhFKt2DN1iQbERERaGKCJCMjgz59+rBw4cJqzytB0gSd+sGuJQwNyOQd56jf0b20DlhERAQ05teTLLFHw54viSjc4u1QREREWoUmJUg++OCD5o6j43L2Ielr3gNA6r5Cb0YjIiLSqmjMr+eE9xwCK6BH1TbKq2z4+VgO/yYREZF2rFEJkjfeeIOrr76aN954o9btmmLTBJ2MBElclTHJJjVLjVpFRERcNObXc8J7DQUg3pRF6t599Oke5+WIREREvKtRCZIlS5Zw9dVX13k1RwmSJojuB0BI8Q4s2EjZpwSJiIhIbcrLy3nzzTfZuHEjlZWV7udfffVVL0bVcK1pzC+AKTCSbHM00fZsslP/UoJEREQ6vEZXkBx8K80grDtYAzFXltDdlMn2wljySyoJC7R6OzIREZFW5aqrrsJisfDee+/x7LPP8t///peTTjrJ22E1WKsa8+uUGdiX6KJsytJXA2d6OxwRERGvatKYX5f9+/eTkZHh/pEmMJshqg8AI4OyAEjNUh8SERGRQ33zzTe8+OKLANx6663MnTuXFStWeDmqtq008igAfLM3eDkSERER72tSguT7778nPj6e6Oho+vfvT2xsLMOGDWvu2DoOZx+SYcFGgkTLbERERGrKy8sjPDyc6OhoMjIy6N69Oxs26Iv9kbDEDQIgqliTbERERJo0xea2227js88+Y9SoUeTn5/Poo4+Sk5PT3LF1HM5JNomWvYAx6ldERERqd8455zBt2jSsVivjxo3zdjhtWmSvobAE4iu3Y6+qwuzTpFNDERGRdqFJFSSpqakMGzYMPz8/SktLue2225g1a1Zzx9YgX3zxBQMHDmTkyJE8/fTTXonhiHUyGrV2c06yUYJERESkpsJCYwnqK6+8whVXXMGUKVP49NNPvRxV2xbbcwClDl8CTBVk7dzo7XBERES8qkmXCaqqqrBYLPTv35/vvvuOkJCQ5o6rwSZOnMisWbMoKiri+uuv57TTTuPoo4/2WjxN4pxkE16SBjhI3aceJCIiIocKDg4GwGq1ctlll3k5mvbBarWSaunBUfYUcratIKbXIG+HJCIi4jVNSpDccccdADz33HNcc801lJaWupumHc62bdvYs2cPAL169SIurvpIuaqqKtasWUNUVBQ9evQ47P4iIiKIiIgA4KijjqJbt26N+VVah8jeYLJgqSwihlz25JsoLKskxF+TbERERFz69evHFVdcwWWXXdY2P+9bqeygflCYQsXuNd4ORURExKuatMTmmWeeAWDSpEls27aNvXv3MnXq1Aa9d+7cudx7771MmTKFTz75pNq29PR0EhMTueiiixg8eDB33323e9stt9zCwIEDq/38+OOPADgcDh5++GGuvPJKIiMjm/IreZePL0T2BGB4UCYAW7OKvRmRiIhIq/PJJ5+wb98+hg8fzimnnMKsWbMoKyvzdlgNlpycTFJSEiNGjPB2KNWURRmTbPz2a4mNiIh0bCaHw+Fo7Jv69OlDamrqER142rRpDB8+nFtvvdX93E033URpaSlvvvkmGRkZDBw4kD/++IN+/fqxc+dOCgoKqu0jPj6egIAA/v73v3PhhRcyceLERsVQUFBAWFgY+fn5hIaGHtHvc8Rm/g02f8O74Tfyr4yx/Pv8o7lgeHfvxiQiItKMmutzt7Kykq+//po333yTRYsWkZub24xRel6rOv8AFv4wlwl/XMZ+czRR/9zq7XBERESaVWM+d5u0xCY4OJgdO3Y0aAlMY/zwww+89dZbAHTp0oVTTjmFefPm0a9fP+Lj42t9z2uvvcYnn3zC77//7n583HHH1fra8vJyysvL3Y8PTbh4Vad+sPkbknyMSTapatQqIiJSq5SUFJYsWcKqVavaXt+xViiq91D4A6Ls2VCSA4FtsBpXRESkGTQpQTJp0iQmT57MNddcU61B67Rp044omL1791brSdK1a1d3v5K6XHDBBdUSIgkJCXW+9sknn+Thhx8+ohg9xjnqt7s9HdAkGxERkUMlJyfz7rvvkp2dzaWXXspvv/1Gz549vR1Wm5fQtQs77Z2IN2dRtHMVwYkneDskERERr2hSgmTfvn0kJSWxaNGias8faYIkMDCw2lri0tJSYmJi6n1PZGRkg/uO3Hfffdx+++3uxwUFBXTv3kqWsThH/UaWpAGQkqlJNiIiIgdbvnw5Tz/9NBMmTMBkMnk7nHYjxN/KCktP4h1Z5KX9pQSJiIh0WE1KkIwdO5brr7++2nOvvvrqEQfTt29fVq5cSVJSEgCrVq3i73//+xHv18XPzw8/P79m21+zco769S3LJpQi0nOhpKKKQN8m/ScSERFpd9555x1vh9Bu7Q/uB4XLqNqz1tuhiIiIeE2TptjccMMN1R47HA5mzJjRoPfu3buX33//naysLNLS0vj9998pKjKWk1xzzTU8+OCDfPHFFzz88MNs3bqVs88+uykh1qtVdpH3C4HQrgAMDczE4YCtmZpkIyIiIp5XEW1cnPLXJBsREenAGlWecPCVm4Pvp6WlNXgN8OLFi3nuuecAWLFiBStWrODNN9+kf//+XH755RQVFfHqq68SFRXFDz/8gL+/f2NCbJAZM2YwY8YMdzfbViO6HxTsZnRINgtLerFlXyGDurWi+ERERKRd8u16DKRBVMk2sFWCxertkERERFpcoxIkCxcurHHfZDIRFhbGxx9/3KB9TJkyhSlTptS53ZW86JA69YdtCxjktw+ALepDIiIiIi0gJr4fhY4AQkylkJ0CMUneDklERKTFNamC5NRTT+Wiiy7yRDwdm7MPSQ+Hc5LNPk2yERERaS+Sk5NJTk7GZrN5O5Qa+sSEkuroyhBTKpWZW7AqQSIiIh1Qk3qQtPXkSKvsQQJGBQkQXbodgM0ZqiARERFpL2bMmMGGDRtYvny5t0OpISbUj12mWADy09WHREREOqYmJUjaulZ7ghJtJEj8itLxo4LdeaUUlVd5OSgRERFp70wmE4VB8QCU7dvi5WhERES8o0MmSFqtoGgIiMCEg+HB2QCk7FMViYiIiHheZXgvACy527wciYiIiHcoQdKamEzuKpIxofsB9SERERGRluHbuS8AwcU7vRyJiIiIdyhB0tp0Mhq1DvLLAGCzKkhERESkBYR1TQQgpCoHygq8HI2IiEjL65AJklbbpBXcFSQJzkk2W5QgERERkRYQH9uFLEeY8SBnq3eDERER8YIOmSBptU1awT3JplPZDkAJEhEREWkZCdGBpDm6AFCSoUatIiLS8XTIBEmrFm0ssfEvSMOCjX0F5eSXVHo5KBEREWnvQvytZFi6AlCwe5OXoxEREWl5SpC0NmHdwRqIyV7JiNB8ALZkqopEREREPK8o2Bj1W7kvxcuRiIiItDwlSFobsxk6JwFwQojRRV7LbERERKQl2CN6A+CTl+blSERERFpeh0yQtOomrQA9xgAw0myUt27JUIJEREREPM8vxhj1G1qiUb8iItLxdMgESatu0grQ4zgAepesBmDLviJvRiMiIiIdREQ3Y9RvkL0ASnK8HI2IiEjL6pAJklYvfjRgIqR4B53I1RIbERGRdqDVV7ACCbHR7HFEAuDYn+rlaERERFqWEiStUUA4dBkEwGjLRvYXV5BdVO7dmEREROSItPoKVqB7ZCDbnaN+C/ds9nI0IiIiLUsJktYqYSwAJwYYV29URSIiIiKe5udjIdu3GwAFu5UgEfGY9bNh7gyoLPV2JCJyECVIWitno9bhpo0ApKgPiYiIiLSAkuAEAGxZGvUr4jELnoSVHxiJEhFpNTpkgqQtrAEm3kiQdK3cQSQFbFYFiYiIiLQAR6Qx6tc3X6N+RTymKMO43bbQq2GISHUdMkHSFtYAExQFnZMAY9xvihIkIiIi0gICY/sBEF66CxwOL0cj0g5VlkFZvnF/20L9fybSinTIBEmb4Rz3O8q8kc0ZhTj0j6eIiIh4WGS3ftgcJgIcJVCc5e1wRNqf4swD94v2QeZG78UiItUoQdKaOfuQjDJvoqCsisxCTbIRERERz0qIiWS3IxpQHxIRjyjKrP542wLvxCEiNShB0po5K0gSzTsJpYjNGVpmIyIiIp4VFx7ADmIByEvf5OVoRNqhon3VH6sPiUiroQRJaxYSA1F9MeNgpHmzRv2KiIiIx1nMJnL8jVG/RXs06lek2bkqSMLjjdvti6CqwnvxiIibEiStnXuZzUaN+hUREZEWURrSEwDH/lQvRyLSDrkSJL0mQFAnqCyG9FY8PEKkA1GCpLVLGAs4G7WqgkRERERagDm6DwD+Bdu9G4hIe+RaYhPcBXoeb9zXMhuRVqFDJkiSk5NJSkpixIgR3g7l8Jx9SAaYtrNn3z5NshERERGPC47tD0BEeTrY7V6ORqSdcSdIOhtVJKBGrSKtRIdMkMyYMYMNGzawfHkbKGUL64ojIgGLyUFS1UZ255V6OyIRERFp5zrF96XSYcHPUQ6Fe70djkj74lpiExxzIEGyewWU5XstJBExdMgESVtjclaRqA+JiIiItISencPY6egMQEXmFi9HI9LOFB+UIAnvDlF9wGGHtN+8G5eIKEHSJhyUIFEfEpFm9t298HgsfHEdpK/wdjQiIq1CVJAv6WZj1G/OLo36FWk2DsdBFSSdjNteE41b9SER8TolSNqCBCNBMsiURtqeTC8HI9LObPwKKktgzSx44wR4fSKsmgmVZd6OTETEa0wmE/n+3QEo3atRvyLNpqLIOO8ACDKqtA70IVnYoqGUVFRp+b7IIZQgaQvCe1AWGIvVZCN38yLKKm3ejkikfbDboCjDuH/UWWDxgz1/wZzr4fkk2Pi1d+MTkXalTTWJB8rDehl3crZ5N5DG2rsGKvWlT1opV/WIbzD4BRv3e44Dkxn2p0B+eouFcsMHfzH+/xaQmqkKdREXJUjaApMJ397jABhYtZavVu/xckAi7URxFtirjJOS89+B2zfApH9BaDco2Q/f3GEkUUREmkGbahIPWDoZo34DC9O8HEkjbPkBXhsHb5wEpXnejkakpoMn2Lj4h0HXYcb9FqoiSdlXyC9bsrDZHfy1I69FjinSFihB0kaYexoJkjPNS/hocRu7kiPSWhU4k43BMWDxgaBoGHc73PyXcbJSlAE7F3s3RhERLwnpaoz6jazY03aSxSvfM273rYWPpkJFsXfjETmUq4IkqHP1513LbLa2zLjfj5fvct/fvl//n4i4KEHSVgyYjD0gil7mDPpkfM2a9DxvRyTS9rkSJKFx1Z/38TOW3ACs+7xlYxIRaSViu/eh3GHFShXk7zr8G7ytLN+oIAGwBsGupfDxNKgq925cIgdzN2g9NEFyUKNWu92jIZRX2fhi5W734x05JR49nkhb0iETJG1tDTAAfiGYx90OwK0+nzPzjxQvByTSDhTuNW5DYmtuG3iecbthLtgqWy4mEZFWIqFTCNsdMQAU72kDjVo3fg22cojuD5fNNZIkW3+Gz68GW5W3oxMxuJfYxFR/vtsI4+9sSTZkrvdoCPM3ZJJTXOF+vEMVJCJuHTJB0tbWALuNuIqKwC50Ne0naO375JfoS5vIESlwXj0J7VpzW8J4CIw2epGk/dKycYmItALBfj7stRgVdrnpG70cTQOs/dS4HXQBdB8BF30IFl/Y+CV8dbPHr8qLNEhdCRIfX/fkSk/3IZm1fCcApwwwYtiRXYLD4fDoMUXaig6ZIGmzrAFYJ94DwHXm2cxetsXLAYm0cXUtsQGjJ0nSOcb9dbNbLianjXsLuOj1xcxatrPFjy0i4lIQGA9A2b5WXrlalHkgmT1winHbeyKc/xaYLLDqQ/jhAe/FJ+JS1xIbOGjcr+cuzOzKKeH31GwA7jy5PyYTFJZXkasLryKAEiRtjmnopRQGdKOTqYDKP17Bble2V6TJ6kuQwIFlNhu/atE17ItSs5n66mKWbMvh9V/VlFlEvKciwphk03Xnlx790nbE1s8Gh92YBBLV+8DzR50F5yQb95f8F3b/5Z34RFyK60mQuCbZZHluSdunK9JxOOC4PlH0jQmhS6g/oEatIi5KkLQ1FivWEx8EYGr55yzd2IZG74m0NodLkMQfa/QnKc+H1J9aJKQv/krn8reWUVhurJffkVNCeVUbmR4hIu1OQa8zWWPvSUBVAbw/GZa8Aq2xFH/tZ8btwPNrbht8MfQ7zbi/c0nLxSRSm/oqSCKdyb38XVBZ1uyHttkdfPqn0XD5whFGdViPqEAAdu5Xo1YRUIKkTfIfMpV9/j0JM5WQ++Mz3g5HpG1yOOpv0gpgNsMAZ6m2h6fZOBwOkhekcvsnq6myOzjz6FhC/H2w2R1sz9ZJi4h4x9G9unJBxb+Yax8LDht8fy/MuQEqS70d2gG52yF9GWCi6qhz+WjpTtKyD7ka3s15ZX73ipaOTuQAu/2gBElMze1B0eAXCjiMv9fN7NeULPbmlxEeaOXkJOP4PSKDAFWQiLgoQdIWmS1UTTDW0R6f+xn79qhHgUijleVBpTPxUFcFCRxYy775O6jwTKKiymbn/tnr+Pc8o6T2uvG9eOmiIfTtHAzAln2FHjmuiMjhDOsRQWK3TtxScQMLEm4z+nmsnglvnwb56d4Oz+BKYPccx2srS7h/9loe+vKQKSBdlSCRVqAsD+zOXh9BnWpuN5kgspdxf39qsx/+42VG9cjkIV3xt1oA6BFtVJDsUAWJCKAESZvVddT5pFr7EWQqZ/dXj3s7HJG2p8BZPRIQAdaAapt255Vy3it/8NjXG6jsMgTC46GyGFLmeSSUR77ewMxlOzGZ4JFzBnDf6UdhNpvo2zkEgJTMIo8cV0TkcEwmE9cf3xswccv2Yym96FMIiIQ9K+H1CbB9kbdDdC+vKU2c4u7btHFvQfXXxA0xbnPToCSnJaMTOcA1wSYgAnz8an+Nq4dOztZmPXRWYTnzNxrHv3BEd/fzCVFGBYlG/YoYlCBpq0wmskfeDcDAvZ9RkdnKu8uLtDbu/iM1R/w+98MWVuzI5Y3f05j25jJK+59rbPDAMhuHw8E3a4xkzbMXHMNlxya4t/WNMSpIUjNVQSIi3nPygC70ig6ioKyKDzN7wrULIWYQFGfBe2fDsv95ry/JvvWQuQHMVt7OGUR+qXF1PrOwnIKyg6ZyBERAlNFwlj1eatRqt0FpnneOLa2Da3lNUC39R1xcf0/3N2+C5Iu/0qmyOxjcPZzELqHu5+MjVUEicjAlSNqwoROmsMR0DL5UUfDB5VBV4e2QRNqOQmeC5JD+I9uzi5mzajcAAVYLS9NyuGF1grFxyw9QdshVySOUVVjO/uIKzCY4bWD1WPo4l9ik7FMFiYh4j8Vs4trxRtn/G7+lURHSHa6aZ0z6slfBt3fC3Js80lTysJzVIxW9TuS/S/YDxioFgG1Zh1wRjxtq3Hpjkk1OGrxyHDzTD3J3tPzxpXWor0Gri6tRa07zTbFzOBx87GzOetFB1SNwoEnr/uIKCss06ldECZI2zNdqYff4f5PnCCK6YD1lPzzi7ZBE2o46Jtj8Z0EqNruDCf07Mfem44iPDGRhXgzbHHFgK4fN3zZrGBszjOqQhOggAnwt1bb1izGW2KRlF1NpszfrcUVEGmPy0K50DvEjo6CMuat2g28QnPcmnPQomMyw6gNnX5LdLReUwwHrjATJdxxHUXkVSbGhjEyIBGDrocsTvdWHZOcSeGMSZG00PkfSfm3Z40vr4VpiU1uDVqe8QGcCoxkrSFbuymNbVjGBvhbOPKb6eU+Iv5WoIF9AVSQioARJm3fu8SN5KegWAPyXvQxbF3g5IpE2osB5En/QEpsd+4uZvdJ4/pZJfekXE8KcGccxulcUX9pGG6/59f1mDcO1Tv6o2NAa22LD/AnytVBld2htsIh4lZ+PhSvH9gTgtV+3Ybc7jFKN426GaZ8bS1j2/AWvHw/bf2+ZoNKXQ95OHNZAHtpsjCy9/aR+B5YnZtWVIPmr5ZYErf4Y3j0LSvaD2cd4bs9K92aHw8Ga9DyKnaPdpZ2rJ0Fiszt4/sctTHjLqPSgcA/b92Y1y2HX7MoDYEzvaIL9fGpsd1WRKEEiogRJm2cxmzj5/Kv5sGoSAJWfXwvF2V6OSqQNcDVpDT2wrOU/PxvVI8f368SQ+AgAIoN8ef+qUe5xv3HZi/lrU/Nd1XElSJJqSZCYTCb6OKtItmiZjYh42d9GxRPi50NqZpG72SMAvU9w9iUZaPQlefcs+PlxsDXfl/79ReVUHVpJ51xesy5kHLmVPhzTPZxJR3WmTycjQVKjgqTLICNJUZzp+Qk8djv8/BjMvhZsFZB4Jpz1orFt7yoAduWUcNlbyzj7P4u45/M1no1HWodiZ8IjuPoEm+yici5/axkv/pRCniOYXIfxd/j6lz7j4teX8NXqPZRX2Zp8WFez9/5dgmvd3sPVqDVHF2NElCBpB0b3imJ54p2k2LtiLcnEMXeG95qlibQVhyyx2bm/hC9c1SMn9q32UqvFzK0Xn8Vu315YTTbS//ym2cI4UEESUuv2vupDIiKtRKi/lWnH9gDg1V+24jj4XCMiAa76AQZfAg47/Pp/8M7pkLfziI+7eOt+Rj3xEyc//yuLUp0XgSpLYe2nALycdQxgVI+YTCZ6O//d3HpoBYnV30jigGeX2dgq4fOr4Nd/G4+PuxWmvg89xgDgyFjH279u4ZQXfuW3FOP3+WtHbpMPl19SSaqmnbUNtVSQLN+ewxkv/cbvqdkEWC08e8ExmJyTbHqaM1i8bT9/n7mS4/9vIZkFTevz4zqHcE3HO5S7giRbFSQiHTJBkpycTFJSEiNGjPB2KM3mrjOHcKfjZsodPpi2fG90lBeRurmbtBoJkmRn75Hx/Tox1Fk9cqjSrsbJrSV9abOEUFZpY6uziWBtS2zgoASJJtmISCsw/bgEfH3M/LUzj+XbD/lS7xsE5/7X6E3iFwq7lsIrY2H97CM65hu/baPK7mBbdjGXvLGUW2atpGDZB1CaQ65vLPMrj2Z4jwjG940GoLezgmTH/pKa/Zu6uhq1ejBBsuYTWP+FUa1yTjKc9DCYzRDRE5tvGCZbOZ9+9yMlFTaG9TA+b/bklzW5Qeb0d5Zxygu/auJZW3BQk1aHw8Frv2zloteXsK+gnD6dg/nypuM4b1g3wrslAvDUhCBuntSXUH8fMgrKWJLW+BHVDoeDLc6/G67lZ4dKUAWJiFuHTJDMmDGDDRs2sHz5cm+H0my6hgcw8fgTeLLqbwA4fngQMtZ5OSqRVqqyFEqdJ/ahcezKKeHzv4xy61sm9a3zbVFJxwOQULKW/JIj7/SemlmEze4gPNBKl1D/Wl/jatSqq4Mi0hp0DvHnvKHdAKOKpFaDzofrf4NuI6A8Hz69Ar78O1Q0/ur0nrxSFmw2vlROGdIVkwnmrtpN5o8vAPBK6STsmLnj5P6YnONruoT6E+js37Qz55BjHtyHxFM2fmXcjrsThkxzP/3ZX7tZWmb82Q333cnjkwfy6XXHEhPqBxxYBtGoQ+0t4K+dedjsDpZsa/yXZ2lhzgqSImsU176/gie/24TN7uCcwXHMnXEcfZ2f+a5JNmHFO7j9pH6cMqALAGmHTmZqgOyiCvJKKjGZDiQPDxWvHiQibh0yQdJeXTe+Nz8Gn8tPtiGYbOXw0dRmn6EuHdP/fb+JSc8uJHlBarMkBrzOtbzGGgj+YSQvSKXK7mBc32j31bzaRPQfB0CiaSfLN6cdcRiu5TWJXULcJ/aHco363ZZVXHP9vYiIF1w7vhcmE/y8KZP1e/Jrf1FEAkz/DsbdAZjgr/fgjRMhO7VRx5q1fBd2B4zuFclzFw5m7ozjuLRTGn1Ip8jhz8zKCYzpHcWxvaPc7zGbTfTqZFwRr5FcdiVI9q4Ce+09HV5ZuJW//W8JmYVNWM5QUQzbnA3zk86utun/vt/EGrsxLvmeY0q4ZFQPzGaTOxG+JaPxFSCusfQAG/Y27xh6aWa2KnefwEs/3s6PG/bhazHz2LkDeeHCwQQd3Dw1yjXq1ziPT4g2/j5vb0LDdlcFanxkIP5WS62vcVWQ7M0vo6yy6b1ORNoDJUjakQBfCw+cmcRdldeR6uhqTOl4+3TI2uLt0A7I2Qap873bI6WiGAr3Hf51AsC2rCJe+WUrW7OK+fe8zRz71E889OV6dh16Va4tOaj/yK7cUj5bYVSP3Hpi3dUjxutjyfGNw2JykL72yMc0btxrnLTUtbwGjOqwAKuFCpu95pVQEREv6BkdxFlHG8sT/z1vc90vtFhh0j/hsrkQ1Bky1xtTbtZ90aDjVNnsfLzc6GHyt1FG75Oju4XzSMwvAMxhIqXmIO44uX+N97obtR7ahyS6H/gGQ0URZNc8P6qosvPyzyn8sXU/d3yy2pjW0xhbf4aqMgjvAZ2T3E9nF5WTWVjOOocxCSgo+0CVb7+GNuPe+jO8PBwWGc1e7XYHX67a4968YY8SJN62LC2Hp77bxB9bs2v+3SnZDziwOUyszvGha3gAn91wLNNG96h5kSTSSKS5LnT2dCZI0rIbnyBxJQnr6j8CEBFoJcSZoGnT53cizUAJknbmtIFd6NcrgYvKH2S7pQcUZcA7Z0DmRm+HBmX58NZp8MF5sOoj78Xx8TR48WjITvFeDG3IKwu34nDAoK5hJHYJoaTCxjt/bOf4fy9gxkd/tc0P0kLXBJs4Xvll60HVI5GHfWtZ7EgALLuOvA9JfSN+Xcxmk7uKpCnl1yIinnD7Sf3wMZtYuDmLJdv21//iXscbS256jDUSE59Nh2/vgqpyY3tlKaT8CN/cAc8PhGf6QeYmft6Uyb6CciKDfDllgLOpZdYWTKk/AibOvvZhfrrj+For/3q7J9kc8oXSbIG4Icb9WvqQrEnPo6TCuIL+W0o2by1qZLXgJmcT78QzjTHITq5/73PDBhhP7FsPVRUA9ItpQK+pdV/Ah1NhfwrMfxiyU1ialsPe/DKsFuM4mzIKsDU2odNKFJVXcf/stSzYlOntUI7IP+as49VftvK3/y1lzFM/88S3G1m3O5+KKjuvfL0IgBxCOa5vZ776+1iO7hZe+45cFSTFmVBWcEQJki376u8/AsbUvB7RxjKb7VpmIx2cEiTtjMlk4tFzBlLhH8Xk4vvYRILxj+s7Z3i/J8lPjxoJG4Dv7oHc7S0fQ/7uA1d3Nsxt+eO3MbvzSpntnOzy8DkD+O6Wcbx/1UjG9Y3G7oBv1uxl+jvL294JWYHxOzlCYvl+nfF38vrjezforRFHjQegT9k6dueVNjkEh8PBxoy6R/we7MAkGzXgE5HWISE6iItGdgfgqe82VZ9oU5uQLkYlydjbjcfLXoc3T4aPLoKne8KH58PyNyB/l9Gn4eNLmL3EuLhzwbBu+Pk4lwYsfdW47X86oV37u8eTHqrOSTZQb4Lkj61Gsic62BeAp7/fxLrddSwjOpStCrZ8b9xPPKPaJld1R3hcX/APB1s5ZBm/X193BUkd/8YvfwM+uxLslUbzW4cN5j/EHOfn8+QhXQn0tVBWaSctu2mJ9LJKW+OrZZrR679u46OlO7nu/RWsOIKJPt5kszsYn/MJM62PEetbSkZBGa//uo0zX/6dYY/9yJK1mwBwBHXmnekjiQzyrXtn/mEQ5BwFnLPNvQQmv7SS3OKKRsXlmmDTr54ECRw06rcJy3hE2hMlSNqhvjEhfHPzOOLiunFh2f2ssfeEkv043j0T9qzyTlDpK4wPeDAaT1UUwuwb6lz/6zFbvjtwP3V+yx67DXrdWV0xpncUQ+MjMJlMjOvbifevGsV3t4wjPNBKamaRO4nSZjiX2OT5dCKnuAJfHzPDE+ruPXKwgN5jARhsTmXxlr1NDmFfQTl5JZVYDqoQqUufGFWQiLQ2O3bs4N577+Xhhx9m1apV3g7HK26e1JcAq4VVu/KYt77upauzlu3k9k9W8cOmbCom/AP+9omRJNi7yvhcriqF0K4wbDpc8K5xf38q52x/HHBw0ch4Y0clObB6pnF/9A31xtb7oCU2NZI37kattSVIjB4Rt5zYj5OSYqi0Obhl1kpKKqoO98cBOxcbDcADo6D7qGqbXBUkSV3DINYYS+w6J3MlwfcVlJNfelCfL4cDfvm3UVmDA4ZfBVfOA5MZNn1NxrqfAZg8pBuJXYwky/omLLPZsKeAox/+gce/9U61cUlFFe8t3g5Ahc3Ode+vYG9+0y9AeMuevFKuMX/FsZYN/HpmAa9OG8bpg7rg62OmsKyK7r5GAqxzbDwWc+19x6qJPNCHJMDX4m7mntbIBEZKA5bYAPSIVKNWEVCCpN3qHhnI5zeM4bQRRzGt4n5W2vtgKs3F8fbpxgft3jUtF4ytCr66BXDAMRfDpV8Y6393/gF/vNRycQBs+vbA/V3LDkwykRqyCsuZtXwXADdN7FNj+1Gxoe6qixfmb6Giqg01EHUmSNLKwwA4plvYgauThxPdjxKfMAJMFexav7jJIbhOlntFB9XZNM2ln/OkJuVw69NFpMVYLBbCw8Ox2Wyce+657Nmz5/Bvamc6h/hz1Vijp8a/522qtZH0e4u3c+8Xa/nir91c+/4KRj0xn39t7MqGs7/BMfRyOOFBuP53uG09nPUCDDgXpr5PlcnKqZblPNH5Z/fyAv56FypLIGYQJIytN7aE6EDMJigsqyKrsLz6RleCZN96qDzQiLWs0sZfO/IAOK53FE+fdzQxoX5szSrm0a8bkDxwLa/pdypYfKpt2uBeUhlyoIJlz0oAQvytxIUZX37dlYJ2O3x/Hyx4zHh8/D1wxrMQkwRDLwPgVvv7xIb6MapnJElxRiViU/qQfLl6DxVVdndFZUv79M908koqiY8MJLFLCNlF5Vzz3p+UVrStZqG7d++ksykPAOvO3zl1YBf+e8kw/nzwRF65ZCh3H+e8EBPcuWE7dC2z2b8NMP5OA2xvxDKb/UXl5BRX1DvBxsVVpdKURrAi7YkSJO2Yv9XCU+cdzYPnHcuV9vtZak/EVFlsVHK8Ng5eOx6Wv2n0BvGkpa/AvrUQEAEnP2Z0tj/taWPbz4+3XLKmrADSnI01AyKNEtWtC1rm2G3Qm7+nUV5lZ3D38GrTAQ52+bEJdArxIz231N1Ir01wJkjWFhonAw3pPeJmMlHWZYRxf9fSw5eV12FDA/qPuLjWDW/NKmp7y5lE2qlu3bpx77338sgjj3DRRRexeXM9zUrbsWuP70VEoJWtWcXucekun61I559z1wMwsX8nOoX4kVtSybuLd3D6ezuYlDKFL8MugS6DqvXrqIwdwr9NVwJwccHbsG0h2Cph2f+MFxx7Y7XX18bPx0K884p46qHLbMK6GU1j7VWQsdb99IoduVTY7HQJ9adndBCRQb48N3UwJhPMXLaz/gSCw3FQ/5Hqy2vKKm1sdY5nTYoNg7jBxoa9q9yvcS2z2exKkMy73zh/Ajj1aZh4/4HfecL9lJn8GWJO5e74TZjNJgbEGQn/pkyycVXN7M4rpaCsZSfVVdns/O83IwFwzfhe/O+y4UQG+bJudwF3fba6UZ+xa9Pz+XDpDsqrvJNYKdyx+sCDtF/dAwlC/a2cNiiWUJvzolxDEySuRq05rkatxrlAY/qQuBr/do8IJMC3/osxrlG/aggvHZ0SJB3A1BHdef+GE7kr6HH+VnE/X9lGU4nV+GD+5nZ4pj/8/oJnJsvk7YQFTxj3T3oEgqKN+4MvMRqY2Svhi2urXcHxmK0/GceL6gOD/2Y8p2U2tcovqeSDJTsAo3qkrhG0Ab4Wbj7BqC55+efUtnO1x9mkdUm2sf53eD2jfWsT2t+4cplUuf7wUwfq0JAGrS7dIgLx8zFTXmUnPVcnLiJNcccddxAcHExwcDD//e9/q22rqKjguuuuo3PnziQlJfHNN9+4t73//vvce++91X7WrTN6ei1fvpxbb72VtLQ0jj322Bb9fVqLUH8rM5xVhi/MT3GPCP1u7V7u/sz4wjj9uATeumIEi+89gXemj+DsY+Lwt5rZllXMzTNX8sDstdVGi/60MZPXSsbzpWkiJuxG/40l/zX6RwV1hoHnNSi2A8tsDvlCaTLVuszGlSgY0zvK/bl3XJ9orhtvXMm/94s1dS/92LcO8neCTwD0mlhtU8o+I7kdEWglJtQPYgc733OgUWv/LgdVChZlwXJnMujcV2H09dX2l2+J5PWqMwE4I/N1qKpw97LasKegUUmF/JJK1h7UY2VzE0YNH4nv1mWQnltKZJAvFwzrRvfIQF6dNgwfs4mv1+zlPz83bCz09+syOO+VP3hg9jqm/PcPttXWe8bDHAf3+ivOgqxN1V9Q5FyGFhzTsB26K0iMP4OezgqSxiRIUp2Nf/seZikvHKggSc8tpbKWajCRjkIJkg5iYNcwvr11AsMmnMtd3MrIspd5pPJS9vomGGt/5//L+GnOJInDAd/ebZTDxo+BwdMObDOZ4KwXjROdrI3w0yPNd9y6uJbX9D8N+p5k3E+db5SxSjXvLt5OUXkViV1CmHRU/Vc6LhwRT7eIADILy91riFs1W5X7JOXPHONko7YJCPXxSTgOgOHmzSxKyWpSGBsPLrc+DIvZ5D7R1zIbkaZ58sknycjI4Mwzz6SionqTwxdffJHVq1ezZMkSnnjiCaZNm0ZurnG1NygoiPDw8Go/VqsVAD8/P6KjoykpKWH16tU1jtlRTBvdg7gwf/bml/He4u0s3JzJzbNWYnfA1OHd+McZSZhMJnwsZib078xLFw9h+QMnOhPw8OHSnVzw6mL3VLSPlu0ETGwZ/pDRr6NkP/z4T+NgI64GH78GxeVu1Fpb/6auQ43bagkSo0HroVWTt5/Uj6O7hZFXUsm1762o3ifExVU90vsE8A2stsndfyQu1Ei8RCQ4G7VWQOYG4MAX2C37Co0+K/YqiBsKgy+ucahv1+3l1crTyTFF4FuwA/58k/5dQjCbYH9xBZmHLimqx+Jt2dVO/TY1oQKlqRwOB6/9alRHXH5sgnu56ciekTx67kAAnv1xy2GX/ny2Ip0bP1xBhc2OxWxi/Z4Cznz5dz79c1eTqzybIij3kISIq2rZpcg5oaehCRJXDxLnqN+mLIFx9x+JOfy5RucQP/ytZmx2B3uOoAm9SFunBEkHEuznwx0n9+fnOyYwcchRvGU7jWMLHucJ26XGCxa9CN/eWW/CYE9eacMalQFs+tpovma2wpnPg/mQv25B0XDOf4z7S5KNElpPsVVCyjzjfv8zIP5YsAYZX5T3ra3/vR1McXmVe6zhjfVUj7j4+pi59cR+ALzyy9YWL89ttKJ94LBjN/mQTSi9OwURUV8n+drEHkOV2Y8oUyGpm1Y1OoSySpv7CtDhJti4uJbZbKlvDKSI1MnX15fg4GB8fHxqbPvoo4944IEH6NWrF+eeey5jxoxhzpw5AEyZMqVGBUn//v1ZunQpH330Ebm5uezcuZOcnJw6j11eXk5BQUG1n/bE32rh1pOMz4GXf07l+g9WUGlzcMbRsTw55WjMtTSkDPG3cucp/Xn7ihFEBFpZuzufM176jfcXb+c3Z+L5gtF9Yer7xhJdAIsvDL+ywXH17mR8oax1ko0rQbLnLwAKyypZk25UUozpE13tpb4+Zl66aIg7zkvfXFozSbLpa+P2kOU1cNCSyi7Of+9NphrLbPq5JtlkFMLK941tzl4jh5qzcjcl+LO23wzjiV+exr+q0J1IX7+n4UunF6UaSSFX09CNLVhBsnjrftbtLsDfaubSY3tU23bxyHiuGJMAwK0fr+TZHzaTU8v0lrcXpXHnp6uxO4xpR7/ePZFje0VRUmHjrs/WcMusVRS20HlJ51Kj0qMgarDxRI0EiauCpJFLbEpzoDSXXs6/z2lZxQ1O/LhH/DaggsRsNrmXpWnUr3RkSpB0QHHhATx34WC+umkso3pG8XrladxTeQ12TEZ/krk3GlfZD7ImPY9pbxgz3Uc8Np97P1/Dih05df8DXZpnVI8AHHcLdE6s/XX9TjlwsvP1be5S02a3c7HRayUwCrqPNK4+9ZpgbEv50TPHbKNmLttJXkklCVGBnDEotkHvmTykK707BZFXUsmbv6V5OMIGWPIqvHt27U14nf1HCq3RODAzvDH9R1x8/CjvPBgAy64ljS5F3bKvELsDooJ86RTSsCuhrpPnVFWQiDS7HTt20L9/f/fjfv36sWPHjnrf4+fnR3h4OPHx8bzyyiucdtppdb72ySefJCwszP3TvXv3Zou9tThvaDf6dg6msKyKsko7JyR25vmpgw87rWNC/858c/M4hsSHU1BWxT/mrsfhgHF9o42xoxE94Py3jObuo66H4E4NjsmVMNh26BIbMKozwFi+UJrLsrQcbHYHCVGBdA0PqPHyhOggPrpmNBGBVtak53PZwUmSvJ1GLxOT2WjQeogNB1WQHDh+9UatrmlmPUrWQvYWsAbWupRod14pS9NyMJmg7ynXQ6dE47Pu9+cY0IRGrYucy4pOHdgFaNkKkld/NXqPXDi8e60jbx884ygm9O9EWaWdl39O5binfubRrzeQkV+Gw+HghflbePgrowLnqrE9efq8o+kaHsAHV4/irlP6YzGb+HL1Hk5/6TfWpOd59HexVVXSw2b0Yqsc6VwStf236tMaXQmSoAYmSPyCIdj478L+bXSPNBoPF1fYyCpqWJVQaqZrxO/hK0hAo35FQAmSDm1QtzBmXTualy8ewnz/U7i14kaqHGZYPZOqT66Aqgq2ZRUx48O/OPs/i/g91fgQLa6wMWv5Ls57ZTGTnvuFV3/ZSmbBQT1E8nfD26dD4R6I6Anj76w/kJMeMWa952yDFW975pd1La/pdyqYnU2q+p5o3CpB4lZcXsXrzhOWGyb0btgYOowrT3ecbHy5eOO3bbVe5WkxDgf8+n+Q9gus/azm9gJjJPFeh5EYGdbA8b6HCuxtLLMZZN/U6BMvV7l1YmzIYSt0XFwnzxr1K9L87HZ7tf8XzWYzNlv9PZUGDx7Mvffeyy233MKYMWPqfe19991Hfn6++2fXrl3NEndrYjGbuP+MozCZ4Lg+Ufz3kqH4+jTsNDMuPICPrz2W6ccluJ/7m2u0LxjLVu7dCSc/2qiYXAmS3XmlFJcfUv0aGHngCv2elQctr6lePXKwo2JD3UmS1en5XPbWMiNJ4jrHiB8DQdWX5zgcjtp7Trn6kDhH/Qb5+dAtIoALLQuN5wdMBv+aFYZfrjKS/CMTIomLDDHOoQCWvMqocKNypKGNWvfml7ItqxizCa50/tlvyijE3gLNwDfsKeDXLVmYTXD1uF61vsbHYuaty0fw6rShDOwaSmmljTd/T2P8/y3gwteX8ML8FMBYAvXgGUe5K5UsZhMzJvbh0+uPpVtEALtySpn62mJ+2lj3KOojlZm2Dl9TFUUOfyKGngd+YcaFuQznIIKq8gNDERpaQQIH+pDkbMXPx0KcM3m3PfvwFR45xRVkFxnnY707BzXocBr1K6IESYdnMpk465g45t9+PNbBF3Jj5S2UO3zw2fwVKc+dTPKLj7Nm3SpMJgdThnblt7sn8sl1x3L+sG4EWC1syyrmqe82cdzTP3P3Z6tJ37gM3jgRMtcbayynvgfWmldiqvELgQn3GfcXPtX8U3UcDtjs6j9y+oHn+zj7kKRr3K/N7uCTP3dxwrMLySwsJy7Mn8lDujVqH6cO6MKAuFCKK2y8srBhTdU8Im+HsV4dak9+ORu0bis3Tjwb26DVxdTDaMg43LyZ31P2N+q9G/caJa/ucusGcJXHpmYWtcjJq0hH0q1bN7Zt2+Z+vG3btmat8vDz8yM0NLTaT3s0sX9nlt43ifeuHHXY8eWH8vUx86+zBvDelSN5YvIgd0WDm7lx+wOICPIlylmZUGtjy4MatboSJGPqmNrmUi1JsiuPy95aRtWGr4yNiafXeH16bimFZVX4WszVx6y6ltjsW298eQaO7mTmTMsS4/khl9Z6/DkrjST/5CFdjSf6nmxUxNrKOX3rI5ixs76BFSSu5TWDuoZxTLdwfH3MlFTY2NUCzcBdk2tOHxRL98jAOl9nNps4dWAsX900lnemj2BEQgQVNjvL0owlbQ+dlcTNk/rWerFhaHwE394yzl2Fcs17f/LRUs9M3MtLWwXADp8EzFZfcPYqcy+zcfUfMVsPLBlrCFcSb79rko1zmU324S+WuEZGd4sIINC35tLC2vSIVgWJiBIkAhgnEc9OPYZpV8zgXr8HKHX40rdkJc/6/Jff/G4jJeI2nnM8Q/dNbzEyYA/PnH80yx88kf8772iG9Yig0uYg/a/vCZ11NhTuoSy8D1w9H2KPblgAQy+H6H7GOsvfn2/eXy5zg/Gl2ccfeh/UWT68u1Ga6rB36HG/i1KzOfPl37n7szXsKyine2QAL1w0pMFX/lzMZhN3nmJUkby3eAf7CppvMpHD4aCkooqKqgYsZUn/88D9tF+h8pBGY84Kkj32CKKCfN0nG43WfQQOTPQyZ7Buc0qj3tqYEb8u8ZGB+FrMlFba2K3maSLN6rzzzuPZZ5+lqKiIpUuXsmDBAs4++2xvh9UmdQ71b3D1YW3G9+vE30bFN7i67nAOTLKp5Qulc5lN1ZrPSd9rNAId3av+BAkY/3Z/eLWRJNm+Kx3Tzj+MDf1rJkhc/9736Rxc/XM1vIfxRdle6W7UeqZlMYGmcrL84iF+dI19bdxbwOZ9hfhazJzmWgJrMsFZL4FvCGFZK7jW8jU79pc0qO/GH87K4DF9ovGxmOnn7HXlSuJ7yu68Ur5cbVTCuCYEHY7JZGJC/858ev0YPrnuWM4b2o1XLhnKFcf1rPd9of5W/nfZcKYO74bdAffPXstzP2xu9uatVXuNfnZZgcZEJ3qON24PTZAExxx2RHU1Uc795RyaIDl8EiulkctrQBUkIqAEiRxifL9OPH7nzXx09FvMC72Aok5DwGzFpyQTNn4FPzwArx4HLwwieP49TA3fxOdXD2XhyRm85/s0oaZSltoTGZlxN1fMzmh4ozCLD5z4sHF/ySuQn958v5Sr9LXXBPA95MtwH+cym7rG/a76CObcWP1LdzuxK6eEK99ZziVvLGXj3gJC/H24//RE5t9+PCN7NqEvBzChXyeGxodTXmVv8lWaHfuLufytZUx8ZiEjH5/PgH9+T6/7vyXpn/MY/tiPh08O7P7rwP2qUtj+e/XtBUYFSYYjkqE9Ipp+Eh4QQWWU0VvHd++ymuXbdaiz3PowfCxmd4O2VC2zEWm0119/neDgYD7++GPuuecegoODWbnS6P9w55134ufnR0REBKeddhrPPfccXbp0OcwepS1wLS2odZLNgHMhMAqf7I284/s0gztbGtwXKinOSJKcGbAGC3byQ/tBZM0v6xtr6z8CxpfkQ5bZjM41JuHM8z2p1i/RruqRiYmdCAuwHtgQ0QNOewqAO6yfkWjayabDNFt1OBzu/iNjnU1pE51VjZsyPNuH5M3f0rDZHYzpHcWgbmGNfv/InpE8O/WYA0miw7BazDx93tHcfIKRbHjp51Tu/mxNs46y9cvZCEBphLPnnitBsmOx0V/P3aC14T10gING/R4yyaYBo35TGtGg1cW1/x05JapWlQ6rzSdI9uzZwwsvvMBrr7122IZq0jCBvj5cdd5ZnHL7GwTPWAj3pcP07+HEh4xSTh9/yN9lNHT98Hx4OoGEX2/HBxsFvc/i48SXKDIFs3BzFucmL+LN39Malqnvfxr0GAtVZfDzY42Kubi8ip11Zbvdy2tqaaDX92QAHKnzeePXVHe3b8BIrMy5AVZ9CG9MgvcnGx907cSNH/7Fz5sy8TGbuGJMAr/cNZFrx/fGz6fxZcwuJpOJ6c6rOTOX7Wz0yceO/cVc9PoSftmSRVp2MZmF5RRX2NwjCAvKqpi/4TBriHcbySx7gPMqYMoP1bc7m7RmOCKbvLzGxdrT6DswhE0s2173BIuD7ckvo7CsCh+zyd1XpKH6HDwGUkQaZfr06WRkZJCbm8v+/fvJyMjgmGOOASAkJISvvvqK0tJScnJyuPLKhk9KaYzk5GSSkpIYMWKER/YvNR2oIKnlC2VoHFw2lxJLCMPMKbxoewIqGr60ICm4mBnBvwCwgNr/m7oaptaaEHcts9mzEvatJzJvLZUOC+8UH1vjpTa7gzmrXMtralkCO/gS6H8GVqp43prMpvTsemPfmlXEvoJyfH3M7lH3iV2MSoNNHqwg2Z5dzAdLjPP1a8fX3nvEE0wmE7ef3J8nJg/CbIJPV6Rz9bt/UlZZf6+hhoouMipJzbHGeGI6HQWB0VBZbExKcidIGjji1yXyQA8SHA56uibZNCRB0ogRvy5x4f74mE1UVNnJaMZKYJG2pM0nSMrLy9m+fTsrVqxg3LhxZGVleTuk9sfqDz2OhbG3wSWfwt1p8LdPjOkzoV2Nq/QAY/5O6CXv8dzfRrHgzgmclBRDpc3Bo19v4Mp3lrP/cB23TaYDDdhWz4K9qxsUXm5xBWe9/DsnPLuQdbsPqVgp2Osc4WeCfrUkSOKPBd9gTEX7mP3d98z48C8jmZO5Eb64xnhNl6PBZIGtP8Pbp8I7Zxolk81cntmS0nNLWLs7H7MJvrtlHA+dPaDWDvJNccqALkQH+5FZWM4P6xveEG3n/hIufn0Je/PL6N0piI+uGcU3N49l4Z0TWP7Aie4rP/UmImyV7r83zxQ7/3tvmVftv5Wj0JUgiWB4Exu0upjiD/Qh+XljZoPes3FPHeXWDeAqk1WjVpHGs1qtBAcHV/sxHzJ+vrYRwM1pxowZbNiwgeXLl3v0OHJA74P6N9WqyyBu83uIAkcgPYpXw0cXQsVhlheUFcBPj8JLQ4grXEuFw8Ir2YPJruU8Z6OzGqPWke6uSTZ7V8Ffxmjfn+xDSS0JrLGvJdv2s6+gnLAAKxMTa6lCMJngrBcp8YngKPMuuq16rt5fwdV/ZHiPCHe/GFcSx1MVJA6Hg4e+Wk+Fzc64vtEc36+R1RRNVVbgnibzt1HxvH7pcPytZn7ZksW/5q4/8v2X5BBpM75/hPUYbDxnNkPPccb9tF+h2Pn9pDENWuFAVVJZPpTsp6ergmR/8WErPLY4p941poLEx2KmW4TRO1DLbKSjavMJkp49e/LCCy/w+uuvc9FFF7F27Vpvh9T++QYa43nPfB5uWw/X/WZUmJz8mPGBgDEm7PVLh/HoOQPw9TGzYHMWp734m3u9a526DoWB5wMO+OEfh01CVFTZueHDFWzLLqbK7uCtRYeMmHVVj3QbDiG1ZO19fHE4yyAnmFeTklnEik3bYObFUFEECePgmp/h5r9g2BVGc63tv8G7Z8GXf2+zSZKFm40P6mE9Ihp1ZaEhfH3MXDzSaG74/pLtDXrPrpwSLv7fEvbkl9GrUxAzrxnNmN7RDIgLIyE6iE4hfoxxlgAvT6tnvPS+9VBVRr4jiHcqTqASq9F/JtvZI8ThwOFcYrPfbOz/iDjXiA80beezJZu5+t3lh21s1pTlNS59NclGRKRR+jgrSNKyi7HV8oUyI7+MeTmxXF55Lw7fYOMzftbfoLKWq+dVFcYY+ZcGw2/PGBeIuo/igfCn2Wzvyrdr91Z7eUFZJbtyjItItSZIXEts9m2ANbMA+DnwFAC2HLJEZrZzec0ZR8fWXekZ3ImNI4wK3OOzZ8GOP2p/HUb/MYDj+hyY2uOqINmRU9LgZaON8eOGfSzcnIXVYuLhswc0W5+Zeu1ZCf/uDd/c7n7qxKQYXr90OGYTfPznLmYuO7LGrVUZRpIl3RFNt9iDzjUP7kPS1AoSawCEOiuG9m+lW0QAPmYT5Yep8MgtrnAn2RpbrapRv9LRtXiC5LHHHiMxMZHExETee++9atscDgePPvooQ4cO5eSTT2bp0qXubV999RUvvPBCtZ/UVGNSxvr163nqqafYsmWLylZbmslkNGLtUbMc1GQycemxCXx503H06RxMZmE5l7y5lGfmba4/6z3pn2DxNca01tUbBOPvyz/mrGPJthz8nFfiv169t/pVl83fGbe1La9x2h09FoAJllVYsBH81TWQmwbh8XDBu2CxQkQCnPUi3LIKRl5rVJSsfB8WvVD379GKLdxsVDtM6N/IKxkNdPHIeMwmWLItx70Gti7puSVc9PoSdueV0is6iFnXjKZzqH+N1w3uHo6vxUxmYXndVzV2rwBgtb0XJfiz2OZcC+xaZlOSg9lm/P3o3DWh0VMWagjvjiO0Gz4mO8MsW5m/MZOTnv+V537YTGlF7WW7rquJR8U2PjHV19lAL3VfYbM3mBMRaY/iwgPw8zFTYbOTXst0lsXbjESBPW4YpmmfgzUIti0wKkY/uQw+OB/ePh1eOx5eGAjf32NMSovqCxd+CFfOo//wSQDMdY7gdXEtVekaHkBYoJUawuMPNGotzYWQOHJjjS/VBy+lLK2w8Z0z+eKeXlOHTsOn8EnV8Zhx4Jh9PZTX/Ay22R0s3mZUkBycIIkK9qNziJ8x/K+xSzmrKqCo7iru0gobD39lNKO9ZlwvenVq3Jf2JvvzbbBVwJpPqjVtH9+vE3ecbDSW/9fc9azaldfkQxTuWAXAZkcP4sIOmtzY83jjdtdSyHW2AWhsggQgyrkUKWcrPhYz8c5GqvUts3FdSOkaHkCQX+Mq43pEORu15pTgcDjIK6lgbXo+36zZy4JNDauWFWnLWjxBcs011zBnzhz69etHTk71UvnXX3+dmTNn8sILL3D22Wdz1llnUVxs/M+fmZnJ9u3bq/24thUWFpKeno7dbmf79u0t/SvJYSR2CeWrm8Zy8cjuOBzwnwWpvLd4e91viOhhJCHAqCKx1d6J/Y3f0vj4z12YTfDq347mnC77SbJv4Zcf5xpTaTZ/ZyRZAPqfUefhPszpB8BQcypP+rxBYskKHNZAuHgWBB3SzT6sG5z+bzjtaePx/IcPJGHaiLJKm7u0dkJ/z5S3xoUHcFKScRLgWmtcm915pe7kSM/oIGZeW3tyBMDfauFoZzO3OpfZOBMkqxy98fMxs8A+GADHlnnGducEmyxHKIMTmic5ZHJWkbw4poyxfaKpqLLz0s+pnPjcL8xdtZuiQ67CuUf8NqGCpEdUED5mE8UVNvbma22wiMjhWMwm9+SP2ibZuD4Pj+0dbVQFXvIJ+AQYlQcb5kLqj7BjkbEMpmif8QX3zOfhxiVw1JlgMnH2MXGYTLBiRy67cg4kYTY4G9XXmRA3mQ4sswEYcgl9uxifc1sOqhT8ceM+iitsdIsIOGzvrG4RATxnmU66IxpT3g54LgmSRxt91ObOgJ8fZ++PL3Ja5Y9c6L+EQQW/wJYfjIbmlWUkupbZNKYPSVk+vHkiPJ8EmZtqfcl/F6ayO6+UuDB/bnIumfW4qgrjvyFAZUmNpu03TujNyUkxVNjs3PjBisMvBa9DWfoaAPb698Z88ASnyF7GUnRbxYHz0aAmnHe5+pC4GrVGH74PSUqms0FrTOMTUa4Kkg8W7+Doh39g8CM/ctZ/fmfGR38x/Z3l7hHLIu2VZxfb1iImJoaYmBhCQ2t+OXj77bd5+OGHGT9+POPHj2f27NnMmTOHSy65hKuuuqrW/a1du5YlS5bQo0cP1qxZQ0pKCoMGDar1teXl5ZSXH/jHr6DAs1265YAAXwtPTjma3p2CeeybjTz53SbG9u1Ud9nf+Dth5QeQtRG+uBam/M+YdOM0f8M+nvjO6Bj++KQoJi44j4l5G8EPWO38cYnoCZ3613qY0gobH2ywM9nRlX7m3Uz1MT7Avu/3MKfFDKj7FxpxtbGcY8Xb8PnVxkjjzkfVfJ3dDunLIGYA+DXvUpamWr49h9JKG51D/Gov+W0ml45OYN76fXz+127uOjWR4EOuYOSXVHLpG0tJzy0lISqQmdeMJqaO5IjLiJ6R/Lkjl2VpOUwd3r3mC1wJEnsf7jsjkU9+zATex7HjD0xlBdUatA47wgatbvGjYd1nRO2cx/vX3MP3G3N47JuN7M4r5ZZZq7CYTRzdLYzRvaIY3iOC7c6S1aYkSKzOSTZb9hWxLC2Hcw9zJVFEWpfk5GSSk5Ox2ZqnMaQ0TO/OwWzKKGRrZjEnJB543uFwsHirkSAZ09t5QSRhLFy70Kg89PE3lhVbA40peL7BRkLDN7Da/juH+jOmdxSLUvfz5eo9zJhoJABcCfF6P2tjBxs9zgAGX0L/nUY/sIOrL13TayYP6XrYZSlms4n42C7ctuNGPgx+Ad/yAsgqMM6nnLoB/+cqaPn0oDdH9mZc3KP8St19SLbsK2Tqa4u5ZFQ8d52SCFXlMOuSA33jVrzjnqjjsj27mNd+2QbAP85MItC3hb5+bP0JyvIOCv576HuS+6HJZOLZqcdwzn8WsS27mL/PXMl7V47Ex9K468fWbKMypjA8sfoGk8lYZrN6ppEkgSZWkBzUqJWGTbJJ2df4Eb8uA50TlwoPusDTKcQPm91BTnEFy9L2N3naoUhb0Kp6kGzdupWBAwe6Hw8YMICtW7fW+57CwkK2b99OTk4Ot956K1OmTKnztU8++SRhYWHun+7da/mCJR515XE9Gdc3mvIqO3d8soqquqacBETAlNeNnh/rv4DZ14HN+Id6w54Cbp61EocDZgy2cNG6ayFrIw5rELvpzFZ7LAWh/YyTjvgxcMrjdc6c/3btXgrLq1jhO9z93POV5/H4tj61rlV2M5mMSpIeY41eJTMvgpKDMuoOB6TMh9fGw1unwNun1b6e2QsWbDJKYCf27+zR9b9jekfRKzqIovIq98mdS6XNzoyP/mJbdjFxYf7MvHY0XcLqT44A7g/k5bVVkJQV4MjaDMBqe29OHxTLWRPGss3eBbOjioqUnynZvwto5gTJUWeBfxjsW4fpx39y2qBY5t9+PLdM6kv3yABsdgcrd+bxysKtXPXunzgcxolGdHDDRkke6oxBcQC888f25olfRFqMmrR6h6sPyaGNWjfvK2R3XilWi6l60+7OiXDczTDqWhgyDQZOMXqvJRxXIznics4xRsJ6zsrd7iWQGxrSc6r3ROO236kQ2ZO+nY0vtFv2FeFwOMguKueXLcbndkOT4klxoSx3JPLcwDlw41K4dDackwwTH4ThV7IsYCw/2YawJ3IUdB9tnC8FRELOVqZvvIozzEvqrCB5e1EaeSWVvL1oO6Xllcb52fbfjKXHAGs/rVb5e2hj1lMHtuD47LXO7E8nZ+LikKbtACH+Vl67dBiBvhb+2LqfZ37Y0rhj2G2EFhpL/umcVHO7qw+JS2ObtEKNCpKGTLJxVZA0tv8IwKheUbx35UjevHw4P9w2ng2PnMLyB07kxglGHKvT8w+zB5G2rVUlSMrLy/H1PTBJw8/Pr1rFR23GjBnDCy+8wJNPPllvcgTgvvvuIz8/3/2za9euZolbGs5sNvF/5x9NqL8Pq9PzSV5QTwKs3ykw9V0w+8C6z2DODWTmFXP1u8spqbAxtUchd6bfYpSQRvbCNGMJM4/9mkkVz3J10Etw3S9w5XeQWPfymo//dP4dOPoisPhhGziVd61TSc8t5deUw0xEslhh6nsQ3gNytxtrlW2VRhXDu2fBh+fBPmfT4Iy18MMD9e4uu6icV3/Zyucr0mssy2hOrv4jtXbBb0Zms4lpo3sAxjKbg3tmPPr1Bn5PzSbQ18Ibl48g9uA1u/UY1iMCk8norL7v0OZke1ZiwsEueyciO3elc6g/049LYKmPkfxKWzybfenGFawSvxiimpigqCGkC0x+3bi/9FVY9zkBvhZuO6kfv919Ar/dPZFnLjiG84d1o2u48XtOSmz68p5LRsfjazGzalcef+3MbY7fQESkXXNNsnEtsSkur+K5H7dwbvIiAIb3iDziqoZTBnbB12ImJbOITRmFVNns7j4eSXH1JEh6jjcqVs57A4BenYIwmyC/tJKswnK+Xr0Hm93BMd3C3COLD8d1vNX7Ko1kT+8TjETP8XdRdsozTCu8iasq76Lkos/hqnnG+dJNf0LP4/GxlZLs+xKnZ/wHxyFLnEsqqvhq9V73/YxPboP1s42LWZd8AkGdoSQbUn50v+cHbzRmBSgvOrAE+oxnjWqg/F2QuaHGS/vGhPDv842R36/+spV7PlvDM/M28+ovW/lw6Q6+XL2HtXUlBXK342svo8xhJbRrLdXKCeOqPz6iCpJtxqhfZwVJWj1NVFOaMMHmYOP7dWLSUTH0iwlx/79xTPdwANak5zVpnyJtRatKkMTFxVVLWuzcuZO4uLhm27+fnx+hoaHVfqTlxYYF8Oi5RqXQyz+n1P8PbeIZcME7RpJk7SesSb6EjPwSTonYy1MF92EqyjAy9tO/h/B4Lhkdj8VsYllajntaSF22ZRnLFMwmmHj8CXBfOpbzXue84fEAfFhP7wy3oCijV4mr8/0rx8H/TjDuW3zh2JsoOfs147XL3ziwFvYgDoeDz1ekc+Jzv/DUd5u449PVDH/sR26euZIFmzKprKvKpgm2ZxezLbsYH7OpWmM2TzlvWDf8rWY2ZRTy5w7jy/z7S3bw3mLjz/b5CwfXf+J4iFB/q7tUucYa2N1/ArDa0dv9u/lbLcQNPxuAiD2/kJuxHQDfyGZemtL/VBjr7JD/5c2QdeAKVPfIQM4f1o1nLjiGRfeewKp/nsQTk2tfBtgQ0cF+nDPY+Hfxzd/TDvNqERHp7bzinppVxCd/7mLiMwt56acUyirtjEyI5Knzmv5vssvB43fnrtrDtuxiKqrsBPla6B5Re9WJW9wQ9zJcf6vFvYRi875CZjsbvzZmSaXrc3L9nvwaDb1X7MilospO5xC/6gmXoCiY9gW2MbcAcAVfU/722dUar36/LsN9Aec6y9f03GqMJmbyq9DnRDh6qvF41YeAsYz5EWdj1mvHt2BjVjCSI5UlxjLrHscdaJi65ftaX37G0bFcM84Yqfvxn7v4z4JUnvpuEw/MXsfNM1dy1n9+r72Ra4ZxIWyzozsJnWo5nwnvbvQiAaMBsF8T/gwiEsBkNiqWizJJiDb+Pu3KKam1Eju/pJLMQuMCc3NOKhwQF4rZBPsKymtepBJpR1pVguSMM87glVdeweFwkJaWxg8//MAZZ9R99V/arrOPieOMQbFU2R3c/slqyirrWY991FmUn/s/bJg5sXIB7wY8zytV/8JcmgNdh8EV37hH+MaGBXDqAKN8s95GsMAnf6YDcHy/TsbyDh9fMJn42ygjQfLzpkx255XWeJ/N7mBRajYrduRQUWWHmCSjRwomyN4MmKgadBHfTviGqWlnkvRJCO+azzXeO+cmo9rEaVdOCZe9tYw7Pl1NXkkl/WNC6BUdRFmlnS9X72H6O8sZ/cRPPPTlelbuzD3iySWu6pHhCRGE+NfSUb+ZhQVYOXewcVL3/uId/J6SzUNfGuPw7jqlP6cMaHyp7YiEOpbZ7P4LgJX23gfWkgPHTTqbUvzpTC5d9xsjDyNjExp93MOa+IBxpaiiCD65FCpqv7ITHuhbvYlbE1w51jiJ+35dRq1/R0VE5IBe0caX0rySSu7+bA2ZheXERwby6rShfHzdaHdTyiN1jvPz7qvVe1jvbtAa2uh/812NNeetz2D1rjwsZhNnHdPwC4Z9Y4LxMZsoKKuq8Rlx8HjfGtUcFh8sJz/CY4H3UuTwxz/9D/jPcHjvXPj2LvJ+SWaMeR1Pdl/GfdaZAJSd8CgMOt94/+C/Gbdb5kFJDh8t2+luzOrqy9Ji1n1m3A66wFgW3e+UA7HV4d7TjuKFCwfz9xP6cMWYBKYM7cpJSTF0izCqP788ZEoRgD1jHQCb7PHu6S81uJbZBDexctfHD8KcbQF2LCIuLABfHzOVNgd78momKlzLa+LC/Gv0fzsSgb4+7p4mq49g6o9Ia9fiCZIPP/yQxMREvvrqK5588kkSExNZv974wnTPPfeQkpJCp06dGDBgAHfddRcJCQnNHkNycjJJSUkaCexFJpOJx84dSKcQP1Izi/j3vM11vraiys7Vy7vy94qbqMLMOMcKzJVFxpfRy+ZCYPVGUZePSQBg9srd5JVU1LrPKpudz/8yEiQXjqjei6Z3p2DG9I7C7oBZy3ZW25ZTXMEVby/jkjeWct4riznm4R+49M2l/GdPX7aNe4bsvlN5oe87DF4zhRu/yXJPW3m0ZAor7H2xVBSwJXkqnyzZypu/p3HKC7/yW0o2vj5m7jqlP1/fPJaf7jieL286junHJRAd7Mv+4gre+WM7k//7BxOeWchzP2yusY66oRZuOdB/pKW4ltl8t24vN364ApvdweQhXd1rWRvL1YekWgWJw4Ftl7Gmf62jN6N6HUiQ+PgFUBh3HAAxpjwAusU37dj1svjAeW9CcBfI2gRf3VpjrXNzOSo2lDG9o7DZHbynXiQiIvUK8LW4v7yG+PvwwOlH8ePt4zl1YGyzLvk4IbEzwX4+7M4r5X1npWRTGnK7voTOWmZUVY/vG92ovlV+PhZ374kNewqw2x38kZrNbR+vclce1ldFur/HaZxT8Si5AT2MJqfbFsCy17ky/7985PsEF2e9AMBrVWfwbfBBy9tjBkCXo8FeiX3Np7zzh3GsGyf2qb6EKWcbbP7eY5+RlORA6nzjvit540qQ7FoGxftrfZvFbOLcIV254+T+PHT2AJ6bOpj/XTacf55p9BaZtz6jxoWqst3GBJsUU3z1Eb8H63OicRt5BOceAyYbt9/fh7k8jwTn3+dt2TXPB7e4ltccrnrE4TDGIH99u7EkqQFc0wTXqA+JtGMtniA544wzmDNnDkuXLuWXX35hzpw59O5t/IPRuXNn/vrrL/766y/27t3L/fff75EY1CStdYgI8uX/zjsaMJYKfPrnrhqVJDa7g9s+WcVvKdkssBzHzuNfNEoUjzoLLvm01skwIxIiSOwSQlmlnU/+rL3PzILNWWQVlhMV5MsJiTXXg7q+1M9avsu9xGXVrjzOfOk3fkvJxt9qJiLQSmmljd9Ssnnmhy2c8GMsw9eeywtrrRSVVxEfGcidJ/fjt7sn8p9po/g4/iHyHYH0q9pM7tf/4NGvN1BSYWNkz0i+v2UcMyb2wWoxYzKZOLpbOP86awBL7pvE29NHcO7gOAKsFnbsL3GPkD3z5d8aNY++tMLm7tY/8Qh6YDTWwK5hDI0Pp9LmoKCsiiHx4Tw5ZVCTT0pdFSSb9xWSX+JcH12wB0vxPqocZhxxgwkLqF4d02noWdUex3kiQQJGJdMFbxvN6tZ+An++6ZnjYDQ8Bpi5bCfFHuxZIyLNRxdovOfJyYO4/aR+LLxzAteM74Wfj6XZj+FvtbibkP61Mw84TP+ROrgSJFXOZvGTh3Zr9D4GxBlfZF/9ZSvj/72Av72xlNkrd1NeZScpNpSTjqq7F0ZilxC2Orryr27/gyt/gLP/w/K4afxoG8pen65g9mFdzDk8VXUxX60+pKrCWUVSuPQ9duWUEh5o5byD4y/JgbdOhZkXwrrPG/17NciGuWCvgi6DDkwxDOsGMYMAhzG6uRHG9+tEgNXC7rxS1u2uvnzbtM9YQpQX0q/uSqHEM40LKGc809jf5IAJ90JUXyjKgO/urXeSjXvEb339RyrLYM4N8PWtxrnK0lcaFMbR3cIBWK0+JNKOtXiCJDw8nMTExGo//v7Vp1fEx8cTFhbW0qGJF0xM7MzFI40lLXd9toYhj/zIde//yRd/pZNXUsGDc9bxzZq9WC0mXrt0GL0mXgb3bIcLPwBr7Zl6k8nEFc4qkvcW76h1Gs3Hy43EyXnDuuHrU/N/g5OSYugU4kdWYTk/rN/HB0t2MPXVxezJL6NndBBzZ4xlxYMnMe/W8Tx89gBOH9SFyCBf/HzMTB7SlZnXjGbhnRO46YS+dI8M5NSBXfi/q8/EcU4yANf5fMPp/mt4fPJAZl0zus51uT4WMxP7d+aFi4aw4h8n8uJFg5nYvxMWs4l1uwu4+r0/a56c1GHJtv2UV9npGh7Q5KZdTeWq6okL8+f1S4fjb236iWmnED96RQcZFz52OKtInP1HNju6M6JPzXXapr4nV38c2ny9jWroMQZOfMi4//19sHeNRw5zQmJnEqICKSir4gtnNZSItG66QOM9Y/pEc/Okvs3XoLsOrh5RLkdSQQIQ7OdTbzKjLq7EzF8780jPLSXE34e/jYpn9o1j+ObmsYQF1r3MNtHVwySjFOJHYRs8jVv2T+Gayjv586z58I9s/M/7Lw7M/JaSTW7xQdW6gy4Asw9huevoa0rnbyPjCfA96DP/m9uhaJ9xf/5DUOmBZaJrnctrBp5f/Xn3Mpva+5DUxd9qcfeX+X793gMbygoIKDbOJyuja5lg42IyGZUsrl4kTWENgHNfMXqRrJnFyZYVAGzfX1LjpeudSRzXUq0aCvcZwwRWzzzw3JJXG/TfwlVBsnZ3zf42Iu1Fq+pBIh3TP89M4rrje9E1PIDSShvz1u/j9k9WM+TRH5m5bCcmE7xw4RDG93Ou3fTxrX+HGOuAwwKspOeW8vlf6dUqUzILyljg7MUxdXjto56tFjMXOZfe3Pv5Gh6cs44Km/3/27vv+CirrIHjv+mTTCY9JCEJhJ5QQ2+iIIhY1roWLIsuuLiKZV3riq6r7u67q6+7r72hYgN1bbt2RF0VlCK9SYdQkpBC+vT7/nEnEwIBkhCSTHK+n08+M8kzmbl3gj5nznPuuZzZL5kPZ42lT4oTo9FAnxQn08Zk8vSVQ/lp9iQ2PjiFf1yWw+geCfVeSYgdchGMmAnAUxHPc2X0Go65NDkQ0B3iv3uMSNycn5PGy9eOYOkfJnLh4DT8AcUt81fy/srjf0CumfNpfZJarot80HmDOvP81UN574axJDlPPDitqSKpWWaj9uhAYVWgZ/1lwzFpkBzcQtwWXW/lUbMacxP0ORv8HvjwxjpbHjYXo9HAtcEqkpcW7SRwrG2phRBCtIjR3RNCy2GMBujThCaZ3RIdmIPBwZT+KXUTDA109oAU+iQ7OaVnIv93eQ7L7p3EXy4cwOAucceNAbJT9Jh3FFbi8vpZtLWQfaUuou1mzuibDAYDPTtF0Tc1Gl9A8em6vNpfdiRSmnE6AJeYv+VXozNrj639V3DXGzM4kvSuMj881ei5HVPpXtildyei/8V1j/Weom+3Lmz0ebmmZ9pnh861YCMA+1U8nZJTmzTcRskYDmNuBuCcXX8jlnK2H1ZB8uGqvSzdqTcgGJYZf+Rz7F+tNxPYsxTsMXDlvyCmi959KNhc91iyUqKxmowcrPKyu/jI5IwQ7UGHTJBIiWvbEmE1cc9Z2Xx/1wQ+uukUbj69J1kpztDS1D9fMIBzBjbuxBNhNYV6i9z5rzX0vf8zTn/0G2a+tpw7312DP6AY2jXumPvDTx3RBaMByt0+jAa4+6wsnr1qKNFHaW5qMBga1oht8kPQeTCG6mJ46yqdxT+8yiAQ0CWiz4yBd66BhX+C58eHuqUnRNl49JJBXDYsg4CC295ezX++Ww7vzoCnRsHSF+pcCVBKhRIkLdl/pIbBYGByvxTdDLcZhPqQBHu8uHYuBWCdoSdDu8bV/0u9ztC3J7N6pIbBAOf+E+yxkLcGFv3fSXmZXw5Nx2k3s6Owkm82N3y5lRBCiJPDbDJybjBm6ZboaFJyw2o20j9NX6n/5dDGL68B3bT+89+dyuszRnJ+TlqjKjeTnDbiHVYCSm8X+85P+iLMBYPrPk9N49jDK1nf9emtbS+z/UBKVLD3SNl++Pj3+v6pd8CZf9X3v/+HrmhoLuvfAxR0Ga13kDlU2hCITAR3Gez+oVFPe3pWJ6wmI9sOVLI1uISF/JoGrRnN1uj3uMbfA0lZRHiKeNDySp0lNrnFVcx+X4/pptN7Hbkt9PoP9PKmsj16uc6Mr3RsNGaWPr74CfAfe8mu1WwkOzXYqFX6kIh2qkMmSKTEtW0yGAz0T4vhtsl9+OzWU/nvHeP55OZxoV1lGuu6cd0Z1yuRaLuZgILthZV8vj6fb37WjUovO0r1SI3OsRFcf1oPslKcvD59JNef1qN5Ki/MNpj2kQ4QzHa9JfBzp8KHs6A8T29N9/yp8Pav4MBGsMVAVDIUboYXJurkh1KYjAb+etEArh7RmV8bP2HCl+fA2nf073xyO/xzAHz3v+AqZXthJbnF1VhNxjo7vISrmgTJ2j2lVLs8mPNXAeBLHXL0IHDQVL0dc02ztJPNmQxn/U3f/+/foGBTs7+Ew2YOVTrJlr9CCNE2XDMmk+6JDq4Y2bXJz/HkFYOZd90oRnVv+XO2wWAgK1hF8uP2Ij5fr6smDq+6rUkE/bijiILgtq/5ZS4e2ZFJsYoixlcE27/RzUD/PUs3fO08GMb9Xld3pA3VO7999VDzDb5mec2AXx55zGiCmiW3x9jNpj5Ou4WxPfXfIlRFkq83mdikutAtsYUSJBY7XPA0ymDiPNMPDCj9Go8vgM8f4La3V1Hu9jGkSyw3nX7IrkEBPyx8CN6Zprc+7jERZnwJicHHDL4KIuL1LosbPzzuEGr6kKyRnWxEO9UhEyQiPHRNcDSpuVmNJKeN16aPZPUfJ7PkDxN5bfoI7ju3L5cPz+CaMZmcP/j4lQR3Tsnis1tPZcwxur03iS0KTp8Ns5YH18gqWPkaPNYX5l2uK0WsUTqJcutq+O0PujTU79bJj7eugqpijHuW8mD+jdxneZ0og4ufAr1Y2vNWVEwGVB6AhQ/CP/pT/tFs4ihjZPd4HM245VuDeap0FcXuH5vl6dLjIkiJtuMLKH5euwyLv5oKZadb1uCj/1JSH7h7N5z552YZQ4MMvAx6nVm71CZwjO2sm+hXozMxGmDR1iI25ZUd/xeEEEKcVJmJDr66fTzTg1uyN0V6XCSjW/GCRlaKjr+e/mYrHl+ArBQn/Q6LyTLiIxncJRal4OO1ujfHqz/spDpgYoljgn7Qqjfgp5f1rjImG1z4HJgsYDTWVpGsfL15+nUVboX9q3Sj9L4X1P+YPsFlNo3sQwKEGvB+FkwYqWBV78ZAFzJbKkECOrF0yu8AeND8Env37OaZb7axbGcJUTYz/7xsMGZT8CNeVTG8cQl8F2wQO+oGuOJtiIitfT6rA0bq5d98/8/j7i4kO9mI9k4SJKLdMxgMJEfbGdcriemndON/Lh7IA+f1Oykd7BstNgN+OUd3iU8bCsoPlkgYeyvcskYnUSLiwJEAU+fDlP8BkxU2fQRPDIWXJmPIX4+KiOPjzHv4peePXLpuBKdW/y8f9fgj7rje4C4jZ9fLfGS7l4s6Fx93SM3O54G3r4YF98PLZ+lEyQk29jIYDKEqkoJNeq3xmkB3Rvc8zvIhYwv/zQ0GOPcfuu/J3uXwY8O6xDdGTRNggJekikSINk2W+IpwUbOMoiS4W9ylwzLqraL9xcDaZTbVHj9vLNkNQMzoafoBmz6Gz2fr+5MeqN1VBqDLSOh3EaDgi3tPfNvfdcHqkR6ng+MoF7a6TwCjBYq26oRKI0zKTsZogHV7y8gtqkAFd7DZZswkNbp5lhA3lOG0u9huyiTBUE7s/HMp+/qfxFLOg+f3o0twC2D2r9HLs7ctBHMEXPQiTPkrmOq5UDbiNzr+zFujt3U+hkEZsQCs21da70YIQoS7DpkgkQBFtDldRsL0L+GaT3Ri5Iw/6aTIoQwGGPVbmL4A4ntAdTDZMfgqDLOWc/a0u7j9zGycdjO5ZT5mre9D1v77+ZNjNjtUCmmGIs7/6VrY+J+Wm1fAD+9dp68cGUygAjpR8s40cJef0FMPDyZIKrcvAWCDsTcD0trg7lcxaTD5YX3/q4egaFvd455KvS548ROwc5Heeq+Raq5Svr9yL3mljf99IUTLkCW+IlwcuvuOxWTggsFH7hAHepmNwaB3y3niqy0crPKSHhfByDETISlbV756KyFzHIy8/sgnOONPurJkx7d6ifGh/D7Y8R1s+kRfbDmagF/3Mvk2WCVR3/KaGvZoyByr729p3DKbhChb6OLMop9WYvRW4FEm/HE9GtaDrjmZrcxPv5cSFUWcK5d7za+zLGIWF+74k44lVs+HOWfAwV0Ql6mX1Ay85OjPFxkPQ36l73//z2O+dI+kKCKtJqo8frYWVDTblIRoKzpkgkQCFNEmGY36pB2VdOzHdc6Bmf/VpanTF8D5T4EjEYPBwI0TerLs3kk8feUQJvdNxmwy8XJRX853P8gy4yCMvmq9POfbR0/8Ss3xKAUf3QobPtBXa658G855TN/f8KHup3Jgc5OffmQwSOnj3wKAO/mQktK2ZsivoPt48Lng3zfp5NC693SfmUd66oTRF7PhlbPhfzJ0E7Uv/wRbvmxQp/2hXeMZkRmP16944bvtJ38+Qggh2rWenaJCu+xNyk4m3lH/DoKdou2M6qYv6Dz9jb4AcM2YTEwmI+RM1Q+yOnWsYqznHB3bBUbfqO9/MRuqD8LGj+D938KjPWHuuTB/qq6aXfHqkefE4h3wyjl6y+CAF7LOPXL3msP1PoFlNv1SMBIgeaVuvr5VpZOe2DoXZ6ydB3GK+//4g3c6Pxu6Y1FeDGvf1rHE+zN1zNHzDPjNN5DS//hPOPpGfTFrx39h74qjPsxkNISaCK/ec7B5JiNEG9JGP00IIY7J5oTRN0DGiCMO2S0mzh6QyvO/Gsayeyfx5wv7M6ZfT0ovmqdLKEFXMrz3myOrFQIBcFecePJEKV0psuJVMBjh4hd1c9Th0+HaT8GZCoU/663mNvy7SS/RMymKlAg/fQy6nDe+z+gTG/PJZDDALx4Hi0NvP/i3bvCva3WiyFsFsV2hzzm6Ga/fo7vrf/8YvHGx3uWoAVUlN0zoAcCbS3ZTXHmMK21CCCHEcdgtptCH4MtHHLtZfs1uNgBRNnNoF0GGz9BVI5e/DnHHaFh7yu/0tr/F2+Dv3eGtK2H1m1BdopuHOjpB6W59geHJ4bBqnq4uWfEqPHuKPmfWJGEue133ODmW3mfq212L4YMbdI+wf98M/7kVPrkDtn111F+dnBXP45YnmFC9gABGHvddSLfEyGO/3knSLdFBJRHMD0yk9Oov4bqv9QUZS7Afyml3BfuNHGV3v8PFdqmtvln0z2M+dFCoD8nBpg1eiDbMoNTJvozcdpWVlRETE0NpaSnR0U1vBipEWFk2RwcAyq8/mNuc4CoFV5ne+g4F0Wl6DW/PibryoaEn1xrfPaa3JgY474nass0aFQXwzrWw63v9fe+zdJntoWuTG2DOk39heuHf2K/iKfvtGvoEu+63WUtf0E12QZe89r0A+l0AqTk6iaIUFG/XQdvuH3TyyFMOAy6Fi57XjzkKpRTnPvE96/eVcfPEXtx2Ru8WmJAQjSPnXU3eBxEOdhVVsqOwkvF9jt3fq7jSw4g/f4kvoPj12G7c/4u+jX+xFa/qBAjoD+pZ50LWOZAxSleGLJujl9FUFerHRMTXLjXuMgYufPbYSZjDPT0aCjYc/XjfC3S/juhDGvp7q+Gtq2HrAjzKxC2+m/nUP5w/X9ifK09gx6KmKq32MuvNFUzpn1L39d3lOrkU24RdIPPXwzNjAAPc9BMk9Kj3Yf9ZvY+b5q1kUHoMH846pWkT6MgO5kJUJ72zpWgRjTnvSoJEAhTREW3/r17e4Tp4/McajLqBbM9J0OdsSBlw9A/qB37Wu/EsfkJ/P/lhGHNT/Y/1e/UuOz88pZM1BqNOpIy/B5wpxx/XmncIvD8To/LzuuEXXHn/a82zDfPJpJRulhaZCKmDjpnwAPT2iK9dpN+f0++DU28/5sM/XrOfG99cQbTdzOJ7JhLVGjsWCXEMct7V5H0Q7c0D/17P1z8XMO+6UXSOjWj8Eyilm4M6kiC5f/3nR3cFLHtBN3uvLtFN60+fDaNnNb4Je+FWvcQm4NP90ZRfj6F0j95VR/l1Vcrps3UljLcK5k2FXd/jNdqZ7rqFbwODAHhjxkjGNvduh63pjUt1f5bMcXDO/9Z78Wp3URWnPvI1VpORdX86E6u5HS5KqCjQF7Y65+j4tzlizJrYd/Hjup/g1HmNvjgomkYSJMfx1FNP8dRTT+H3+9m8ebMEKKJjqijQ2+5aHWCP0V+2aJ3N3rsctn6lP8wf2FT392K66Ks6WedAl9FQshPWv6+/CtbXPm7c7TDxvuOP48BmXW2y6SP9vcWhkypjZunqlvr89IouhUWxwDqR3WP/h+mntdOKieUvwUd6Oz8ufQ36nnfUh/oDijMe+y/bCyu556wsZp5W/5UfIVqLJAY0eR+EOAGuMt3fLH0EdMpq/ufPW6vPu3uCvQpTBuoEzL6VYItm79lzGTuvOvTwRXefTlpTkkJt1Z7luhdawKsvXg24FMbfBfHdQw9RSjHkoQWUVHn596yxDEyPbb3xNje/T8deXz0M7uBWxr0mw9mP6OrfpjqYC//6NexZWvszq1MvQ6/ZfrqhCjbqZF63U6UKpYEkQdJAEqAI0QCle/R63M2fw9aF4KsNCrA4dHf6GkaLXpoz6DK9dV9jsu27foAF99UGJLZoXVEy4jd1y2Z/eBo+v0ffHzYdzn60/sZv7cmnd8GSZ/UWfNd+qq9mHMXby3O5819rSHLa+O7OCdgtbWA7ayGC5LyryfsgRBsXCMCKufDlH/UyZNDLeq5+HzrncOY/vuXn/HKsZiObHpzS8rvYnGx56+Drv8DPH+vvDSbIuQLG3AyRCWAyM+P11XyztYQ/nj+Iq0dnNv41An6oPADl+/XyJWeKXuLdmh/4dy+BT36vk2QAib11I+CAV2+VfNodMPomMAebFgcCsH8lbP5C95iL7qyXh/WcqC9A1vj5M/jgel35ZIvRy7dWvaF/B4OuVBr3+2PHzX6vvpi49IXg76F7+o2eBUOvAVvUkb/jrtA7SR74GSJi9d8uMj54mwBRKfVv+9wOSYKkgSRAEaKRPFW6BHbTJ/DzJ3r9r9Gs+5T0u1BXlTS2X8mhlNKNS796GIr07jQYjPpkM+oG2Pk9fB3cMnfMzXDGg81T8tjW+X3w5qW6osfZGa77CqJT632oxxfgtEe+Zn+pi4cv6M9Vo1p+XbQQR9PRz7tSwSpEmKk4AAsf0B8wz3syVLHy2ILNPL5wC706RbHgttNad4wn094VOlGydcGxH2eNqluNbI8Ba6RevhQILl9Sfr2kqaoIyvOgIl8fP1xkIsSk6WRJTWWz2R68temlVaGPr6r2vskClgj92Jpbo1nv5uOp1EkYb5W+NVn0RSdrpL7YZ43USY5Vr+vnssfCxPt14qFoG3x8G+z8Th9L7AMjZ+pKm60LdJLncGY7dJ8A2efqSuyapeedB8MvX4b4bjrh8dndsOxFfazvBXDB03UTK36vTiCtmgc/vazvg05YRcQd0pMnDkb+FkZcp9/Tnz/VyZRtX+utto/GZIPEXnqZT1KWvk3oqf8GkfHHb3gcRiRB0kAdPVAT4oT4fbrBWUy6/p9ocwoEdMb7x6d1QuZwE+6FU+/oGMmRGq5SePEMvftP8gAYdq3uY9Kprz6xH+LlRTv40382kBEfwde/H992tz9ui/xe8FTo4Kgj/ftqIXLe1eR9ECK87S+t5rpXl3PJ0Aymjcls7eGcfLuXwDd/gR3f6URHczEY9S5Flgj94d93/F37TrrBV8OkB3Db4pi3ZDd9O8cwIjMO1rwNn/+hNilRw+qEHuN1BXXRNtj4Hzi468jnHXm9vrB3eIXM8pf15gkBL0Sn60oQV6n+8lbVfayjk07aDL0GHImwer7ecah4uz5ujtAJkUMTT/HddSNjT4VOTlUVB2+L9Gseiy26tuIklPyKrk2CmW16p0VvMAHlqdJjNll1osfq0Mkza6SuMneX6Xm5y4KbQ5TrJIzVEUxYRdX+XvYvdPKmmUiCpIEkQBEiDORv0MtL1rylT5yT/6z7k3RExdvhhYm1nftBBxcJvXTzXEcSmG14DVaeWbSXUo+B84ZkMqhLnH6cwQgY9K3RrL9MZn3SMlmC31uDX5baKzUma+3VGLNdHzs0eaBU8AqRX29T7PeCzx2879EnapP1kCtAwec52tIoVxnkr4P9a3SZa8F6/fyHnjhrrlY5k3VVTXSqLjV1ph6RMKqXUrpJccEm/Rp5Na+1UQcX9lhdWpvYGxJ76vfYHl37/hkM+r7Voa+4yBrgBpHzribvgxAibAUCEPBScLCCSY9+id3g57+3DifCX4GqLmXZph189tPP+N1VnJ6dzKl9UjAYTcFzZ7DywZmiz9eOpNolHkrpJShle6F0L5Tv05UfPpeOKWpu/R70uTh4HgaqvH7sBj9Gv0t/UPe59Af3gE/HL5bI4G3wy+/VH+QPrSyxRetm+BkjcHn9zHztJ/67WVeHXD2qK3eflYUjUK4ravaugC6jdG+SLqNrl9zUzCN/PWz6GDb9R1chnf3IMXvIsesHePvq+qtRQO/mNOI6yD6v7muBjo82fKB3kMxfp3+WOii4E9S50Cm7/gs+gYDePvvAz7rKpWCTvi3Zqf8OtG6KYPOE5+h92uXN9nySIGkgCVCECCM1Ge9mzCaHpaJteqeg/Wv0h/qjnUxPJoNRJ1WUX5+Ym3oSrUm8hAKXSB2slOw4sfFZInWCIyJWB2L2WB1Q1Fw5qSxs2JWThjJadACSOkj3h0kZpN+bmiCvbB+U7YHKIp18qUki+T26Esvm1Nv9RXXSwWJUsr5aY7HXJpNqkksB3yHBX81tMMjzVOr1xp4K/TOzXV/5iYivvY2I1VeYDi9Zrnne0FewDDltiB5XM5HzribvgxCiPRj5ly/JL3Pz9szRJEfbmP3BOr7bUrfC4oqRXXjwvH6NqmZdvK2QB/+zgfS4CC4b3oUJfZKO+P1AQPHfzQd4adEOvttSSN/UaF6cNqxpuygdwuX1c92ry/luSyFWkxGPX1djdImP5JFfDmRk94QTev6jqiqG3CXBGCam7pKlhvQJUQr2r9bn+6Zs8XyogF9XehxacVKn8qNUV394XbXxm/WQWM7vDcYlOh5RngpKK6rZUW5kYzHsc1kpJ5IKFYHREMCBi0hcOAwuInHjwEXG2b9n9JjmW74mCZIGkgBFCBH2yvN05UP+On3y8nnA58LjruaLNbsxBjxE2Uz0THKQGm3FoFRwTbBPJwj8wduA75AP7Yd8gPd59If6xpa9GkzBqhErYAhWlVTXv964PtHpkDpQV8akDNAf6j0VtYkAT4W+wlGep8tyy/dD2f66TYMb9Dppta9R8xWVrJuyFW6Gwi26H07RVp0wUAq95jkQvNpVHLzS0k5NnQ99zmq2p5PzribvgxCiPbju1eUs2JDP8Mw41uwpxe0LYDUbmTWhJ1E2Mw99vAGlYFJ2Jx6fOphI67E/6PsDiie+2sLjC7cQOOQTapLTxi+HpnPpsAw6OW28u2IPryzayfbCuuf8Tk4bc6YNZ0B6TJPmU+3xM33uMhZvKyLSauKla4bj8yvuencNew9WYzDANWMyufPMLCKs0gS/IfwBxc3zVvLx2v2hn0VaTUzKTuacgalkxEXi9vlxeQO4fX7cvgBuX4ARmfGkxNibbRySIDkOaZImhOgIPlqzj9kfrONgla6U6J7k4JaJvTh3YGdMje24HwgEEybVwbJVr06CGE16aY7BqO/XLMkxHiVw8PuCZbKu2iqImmoFb5V+rk79wNGEKzRK6SsaNUmL6hKoPqhv/Z7aru2OxOD9RF2lcSKUgoO79VWb/atg3yqdrDLbdJInunNts7moTrVLlELvk1kntioKoLJA31YU6Dn43MEqkUNKi42muk3oau7bnIes9Q2u9/VWQVWJfq6qYn3rKq0tPa55Xr9b/y2tjkOeN3glaNID0L11ruC0Z/I+CCHagye/2sKjX2wOfT+2ZwIPXzCAbom60ehn6/K4Zf5K3L4AgzJimTNtGIlR9S9JLSh3cev8VSzeVgTAL4emE++w8u5Peyiq9IQeF2ExUe3VfVCcdjOXD89gcr8UZr+/jp/zy4mwmPjn5Tmc2S+lUXOpdPuYPncZP24vxmE18fK1IxjRTffYK3d5+fPHG5m/LBeAuEgLDpsZrz+A16/w+gP4/IqYCAspMXZSY+wkR+vbuEgrHn8Ajy8QuvUFFKf1TmJo1xPY2CAMKKV44N/rmfvDLiwmA5P7pXDugFQmZHVq8V0WJUHSQBKgCCHau3KXl1d/2MXz326ntFonSnokOThvUBp9UqLoneyka4Kj8QkT0S58vamAv3y8gQOVHowGAwbAYDBgMIDRAH+7eCDj+8gSm+Ym74MQoj1YubuEC59eTLzDyn3nZnNBThqGw/pd/LSrmOlzl3OwykvXhEjuOSubtNgIkqNtJETZMBkNfL+lkFvfWklhhYdIq4k/X9ifCwenA3p3voUb83lreS7fbj5AQEG3RAfXjs3k4iHpOGy6KqXM5WXWmyv5dvMBDAb4w1nZzBjX7YjxHM7rD1BU4eHmeStZurOYKJuZub8eztCuR25A8PXPBdz97hryy46xM0wjTBvdlTunZIXm0N68+N12Hv54IwYDPHXFEM4eUP8OjC1BEiQNJAGKEKKjKHd5mbt4Jy98tyOUKKlhMxvpkRRFRnwEAQU+v7664fMr/AFFlN1MvMNKQpSVBIeVBIeNmAgLVrMRi8mIxWQI3hpJiLKSGAx4mksgoDAYOG6QA3rt8J6SKnKLq8ktqSK3WN8vKHeFyjbdPj9ubwCvP0D/tBguHZbB5H7J2Mwdp1y2wu3jzx9vYN7S3GM+7vmrhzK5kVfhjkXOu5q8D0KI9mJLfjkpMXac9qNvCbvtQAXTXlrKnpLqOj83GQ10ctrIK3OhFPRJdvLUlUPo2Smq3ufZX1pNQZmbAWkxGOuJM3z+AH/6zwZe+1HvInNW/xRSYyKodPuo8PiodOuvsmofZS4vpdVeqjy1u/I47WZe/fUIBnc5emVHlcfHxv1lGA069rGajZiNBsxGIyVVHvLKXOSVuthf6iKvtJrSai9WsxGr2YQ1+PiDVR4+XZcHQHpcBH+7eCBjeyYe/U1ug0oqPRRXeeie6Kg3Pvtk7X5ufHMFSsG9Z2dz3andW2GUtSRB0kASoAghOppyl5f3Vuxl7d5SNueXszm/HJe3gX1BGshkNJDstAXLTCNIiLJiNRkxm4xYTQbMwWSK3WIk0moi0mom0moiwmrCH1DsLKxkR2EVOwor2FFYSW5JNWajgcQoG4lRVhKCt3aLiaIKDwfK3RRWuDlQ7qbc7WvSmGMjLVyQk8ZlwzPITm3f54Ml24u4/V+ryS3Wgeq1YzOZOkI3dFMKAkqFbjPiI4mJOHrQ21hy3tXkfRBCdDQF5S7+/tnPbMkvZ3+pi8IKd50+I1NHZPDHX/Q74aUXSileXrQz1P+kobolOvi/y3MYmB57Qq/fUN9vKQz1NgGYOqILfzg7q95Ekz+gKCh3se9gNXsP6tsqj58eSQ56JzvpnuRokYs8+WUuvlifx6fr8liyoxh/QDEwPYbrxnXnrP4poUa6P+0qZuoLS/D4Akwb3ZUHzuvXoItcJ5MkSBpIAhQhREcXCChyS6r4Oa+c/DIXJqMRs8mAxWTQ940Gyl1eCis8FFd6KKpwU1TpobTae8i6W70G1+3zU1LlxR9o3dNKlM1MelwEGfGRZMRFkhEfQWqMHbvFhM1swmYxYjebCCjFF+vzeOenPewvrW1C2zs5ii7xkSQ57XRy2ugUbSMpyka118+BcjcHgsmYA+VuXF4/8Q5rMHljI9FpI9FhpbTay56SavaUVAVvq6ny+OiV7CQrxUl2ajTZqU76pEQTdZTS2kq3jw37y1i7p5R1e0vZsL+MgFKhhFKk1YzDZsJkNFDh8lHh9lEevK1w+4iNsNA1IZIu8Q59mxDJ4q2FvPj9DpSCtNgIHrlkIGN6tNxVKznvavI+CCE6Op8/wIEKN3mlLiKsJrJSmvf/hT9sK+Lz9XnYLSaibCYcNjMOm5kom5lou4WYCP0VHWHGabe0ylLjCrePv3+2iVd/0BUvUTZ9Xj9UQOlqDd8xYiuT0UDXhEh6d3JiMhkoq/ZS7tJVMuUuH15/gJgIC7GRVuIiLcRFWomJsOAPKCrdPsqDlTUVbh8eX4Bou4Xo4HsTbbdgt5hYuqOIFbsP1nlds9EQGldabAS/PqUbI7vFc/WcJZRUeZmUncxzVw9tE8u4JUHSQBKgCCFE8/IHFIUV7lBp6f5SF8WVnjrJFE/wfrXXT7XHT5XHR5XHT5XHjwHomhBJt0QH3RKjyEyMJDPBEXrewgqdpCmscFPt9YcSE0lO/ZUYZSPabm7UlQp/QPHtlgO8vSyXLzfm4/W37Gkx0moiwmLCbtFVNBEWE1UeH9sLKxt19asxLh2Wzn3n9j1mSfTJ0NHPu9IkXgghxOF+3F7EXe+uYVdR1VEfYzYaSImx0zk2grTYCGxmI1sLKticX06Zq2nVs00xpEssU/qncGa/FKJsZl77cRev/bCrTiNdgEHpMcz7zajj7lzUUiRB0kAdPVATQghRV1GFmxW7D3Kg3E1BuYuCcjcFZbpqJNJiqpOISXLaiLCYKK50c6DCoxM45brCJtpuJj0ukrS4CNLjIkiPi8RmNrI5v5xNeeVs3F/Gpv3l5JUde/vk5GgbA9Ji6J8WQ//OMURaTVQeklSqdPvwBRRRNjNOu77SE2U347CaKap0s7Ooit1FlewqqmJXURUGA9w+uQ+T+ia30Dtal5x3NXkfhBBCHMrjC7C1oIJAPR/NE6KsdHLa663EUEqRX+Zmc345WwsqMBrAabfgtOvKmOgIMxaTkdJqLyWVHg5WeSmp8nCw2ovFZCTKZiLKZsFhM+G0mzEbjaHqk7Jqb6gKpWenKCb3Tal3612X1897K/by4vfb2X6gkoz4CN777ViSnPXvWNQaJEFyHHIFRwghRFtQWqWbxFV7/aGKGpfXj9FoIDvVSSfnCW5D3MZIYkCT90EIIUR7EwgoVuaW0D0xijiHtbWHU4ckSBpIAhQhhBCi5ch5V5P3QQghhGg5jTnvGltoTEIIIYQQQgghhBBtliRIhBBCCCGEEEII0eFJgkQIIYQQQgghhBAdniRIhBBCCCGEEEII0eFJgkQIIYQQQgghhBAdniRIhBBCCCGEEEII0eFJgkQIIYQQQgghhBAdniRIhBBCCCGEEEII0eF1yATJU089Rd++fRk+fHhrD0UIIYQQHYTEH0IIIUTbZlBKqdYeRGspLS0lNjaW3NxcoqOjW3s4QgghRLtWVlZGRkYGBw8eJCYmprWH02ok/hBCCCFaTmPiD3MLjalNKi8vByAjI6OVRyKEEEJ0HOXl5R06QSLxhxBCCNHyGhJ/dOgKkkAgwL59+3A6nRgMhkb/fk0mqj1eAZK5hSeZW3iSuYUnmVvjKaUoLy+nc+fOGI0dcpUvIPHHscjcwpPMLTzJ3MKTzK3xGhN/dOgKEqPRSHp6+gk/T3R0dLv7x1lD5haeZG7hSeYWnmRujdORK0dqSPxxfDK38CRzC08yt/Akc2uchsYfHffyjRBCCCGEEEIIIUSQJEiEEEIIIYQQQgjR4UmC5ATYbDb++Mc/YrPZWnsozU7mFp5kbuFJ5haeZG6itbTnv4/MLTzJ3MKTzC08ydxOrg7dpFUIIYQQQgghhBACpIJECCGEEEIIIYQQQhIkQgghhBBCCCGEEJIgEUIIIYQQQgghRIcnCZIm+vTTTxk5ciR9+vThgQceIJxbudx5552kp6eTnp7O66+/XudYVVUV119/PT179uT0009n9erVrTTKplm7di0XX3wxWVlZXHLJJWzZsiV0rLq6mhtuuIFevXoxYcIEVq5c2Yojbbz8/HxmzJhBVlYWEydOZMGCBaFjbrebWbNm0atXL0477TSWL1/eiiNtulWrVtGlSxeee+650M/CfW733Xdf6L+39PR0ZsyYETrmdru5+eab6dWrF6eeeipLly5txZE2zYcffsgpp5xCly5dSE9Px+12A+DxeLj11lvp1asX48aN48cff2zlkTbOpEmT6vzd0tPT+frrrwHwer3cdttt9O7dm1NOOYVFixa18mgbJzc3l6lTp9KnTx+GDRvGM888EzoW7nNrjyT+CA8Sf4TnObqGxB8Sf7QVEn+0wtyUaLSCggLldDrV66+/rpYtW6b69u2r5s6d29rDarLi4mKVm5urzj77bPXMM8/UOXbnnXeqiRMnqtWrV6tHH31UZWZmKp/P10ojbbzx48er9957T23atEndfPPNKisrK3TsD3/4gxo/frxatWqV+sc//qEyMjKU1+ttxdE2zqxZs9Rrr72mNm/erF5++WVls9lUWVmZUkqp+++/X40bN06tWrVKPf744yotLU15PJ5WHnHjuN1uNW7cODVx4kT1yCOPhH4e7nO78cYb1UMPPaRyc3NVbm6uKiwsDB178MEH1ZgxY9TKlSvVk08+qVJTU5Xb7W7F0TbON998o+Lj49W8efPUzp07VW5ubujYX/7yFzVy5Ei1cuVK9cwzz6jk5GRVXV3diqNtnLy8vNDf7Ouvv1ZxcXGh8f/9739Xw4YNUytWrFDPP/+8SkpKUlVVVa084oa78MIL1TXXXKM2b96sFi5cqOLi4tSSJUuUUuE/t/ZG4g+JP9oCiT/Cc24Sf0j80da01fhDEiRN8OSTT6rzzjsv9P0bb7yhJkyY0Iojah4XX3zxEQFKSkqKWrp0aej77OxstXDhwpYeWpP5/f7Q/by8PGUymUJBSHp6ulq8eHHo+IABA9Tnn3/e4mNsqkAgELq/ZcsWFR0drQ4ePKiUUiozM1N9++23oeODBw9WH3/8cYuP8UTce++96qWXXlLTpk2rE6CE+9xuvPFG9cQTT9R7rGfPnuqrr74KfT98+HD14YcfttTQTtjkyZPVo48+Wu+xrKws9cUXX4S+Hz16tHr33XdbamjN6q677lKzZs0Kfd+/f3/1ySefhL4fN26ceuutt1pjaE0ydepU9de//lUppVRJSYnq2rWrWrVqlVIq/OfW3kj8IfFHWyDxhxZuc5P4Q5P4o+1oq/GHLLFpgh07dpCdnR36Pjs7mx07drTiiE4Ol8tFXl5eWM/VaKz9Jz5//nymTJmC2WzG6/Wyd+/esJ6bwWDggQceIDU1lZycHObOnUtMTAx+v5/c3Nywntvy5ctZs2YN1157bZ2ft4e5ATzyyCP07t2b888/P1Q2rpRi165dYT23NWvWYDAYGDx4MEOGDOGJJ54IHdu5c2dYz62Gz+dj7ty5TJ8+PfSzcD8nPPHEE7zxxhskJCSQmprKrbfeyqBBg4Dwn1t701H+HhJ/tG0Sf2jhNjeQ+APCb241JP5oubmZW+RV2hmv14vdbg99b7FY8Hg8rTiik8Pr9QJgNtf+MwnXuX7wwQfMmTOHL7/8EtD/k1FKhf3cfve73/GrX/2KBQsWMHPmTMaOHRsKUsJ1bm63m1tuuYW33377iGN+vz+s5wbw8MMPc/fdd1NVVcVbb73F5MmT2bZtGxEREWE/t6qqKj766CPmzp1LUVERV1xxBT169GDKlCn4fL6wnluNjz76iM6dO5OTkxP6mdfrDeu5/f73vycnJ4d33nmHHTt2MH36dMaPH09OTk7Yz629kfgj/OYq8Uf4zE3ij/Cdm8QfWrjNra3GH1JB0gRpaWns2rUr9P2uXbtIT09vxRGdHE6nE6fTGfZznT9/Pvfffz9ffPEFnTp1AiAiIoK4uLiwn1tMTAzdu3dn5syZpKens2TJEqxWK0lJSWE7tx9//JGVK1cycuRI0tPTeeedd3j44Ye55557wn5uALGxsaSnp9O7d2/uu+8+IiMj2bBhAyaTieTk5LCeW3p6OjNnzmTgwIFMmDCBiy++mMWLF2M0GklNTQ3rudV48cUX61y9gfA/J7z//vvMnj2brKwszjrrLCZPnsynn34KhP/c2puO8veQ+KPtk/gjvOYGEn/UCLe51ZD4owXn1iILedqZjRs3qtjYWLV582bl8XjUlClTQuunwll9a4CvvPJKdf311yu/36++++47FRcXp8rLy1tphI33yiuvqAEDBqi8vLwjjk2bNk3NmDFD+f1+tXjxYhUbG6tKS0tbYZRN88ADD4Saoi1ZskQ5nU61ZcsWpZRS06dPV9dcc43y+/1qyZIlKiYmRpWUlLTiaBvO5XKFmlHl5uaqSy65RM2ePTs0/nCe2+E+//xz5XA4VEFBgVJKqZkzZ6qrr75a+f1+tXz5chUTE6OKiopaeZQNN3v2bDVt2jTl8/lUSUmJGjBggHr11VeVUnrt89SpU5XP51MrV65UMTEx6sCBA6084sbZs2ePioqKOuLf2y233KIuueQS5fP51OrVq1VMTEy9/89pqwYOHBhaZ3/gwAHVq1cvNX/+fKVU+M+tvZH4Q+KPtkDij/Cb2+Ek/pD4oy1oq/GHJEia6KGHHlJ2u11FRkaqSZMmhdVJ+3DPPvusSktLUxERESo2NlalpaWpTZs2KaWU2rlzpxowYIByOBwqOjpavfnmm6082saxWCwqLi5OpaWlhb5qTga7d+9WgwYNUg6HQzmdTvXaa6+18mgb59lnn1VJSUkqLi5OJScnq5deeil0bM+ePWrw4MHK4XCoqKgo9corr7TiSE/M4U3Swn1uAwYMUGlpaaF/l4c2nNq3b58aOnRoaG5z5sxpxZE23sGDB9XEiROV0+lUkZGRavr06aFGhXl5eWr48OHK4XAoh8OhnnvuuVYebeM99NBD6qqrrjri5/n5+WrUqFEqMjJSORwO9fTTT7fC6Jpu0aJFqnv37io2NlbZ7XZ17bXXhv5u4T639kjij/Ag8Ud4nqMPJfFH+JD4IzzP0W01/jAopVTL1Kq0P9XV1bhcLuLi4lp7KCekoqKCgwcP1vlZSkpKnXVfhYWFREdHY7VaW3h0J2bv3r0c/k+8c+fOdZqnhevcAAKBAGVlZcTGxtZ7PJznVqOkpASLxUJUVFSdn4fr3Pbv34/f78fhcBz1/x3hOrcaBw8eJDIyst7xFxUVERUVhc1ma4WRnZiioiLsdjsOh+Oox8N1bqD/W4uKisJisRxxLNzn1t5I/NH2SfwRvnOrIfFH+JH4I/zmBm0v/pAEiRBCCCGEEEIIITo8adIqhBBCCCGEEEKIDk8SJEIIIYQQQgghhOjwJEEihBBCCCGEEEKIDk8SJEIIIYQQQgghhOjwJEEihBBCCCGEEEKIDk8SJEIIIYQQQgghhOjwJEEihGjXvF4vV1xxRWsPQwghhBAdiMQfQoQng1JKtfYghBDiZHG5XMTGxuJyuVp7KEIIIYToICT+ECI8SQWJEEIIIYQQQgghOjxzaw9ACNExVVRU8OSTT7Jx40a6d+/OTTfdRHx8PF6vl2nTpnHbbbfx8ssv43A4uOOOO0hKSgKgoKCAxx9/nL179zJ69GhmzJiB0ahzveXl5Tz99NOsXbsWl8vF7bffTk5ODgCrVq1izpw5WCwW7rjjDlJTU1tr6kIIIYRoJRJ/CCGORSpIhBAtzufzccYZZ1BVVcWZZ55JWVkZZ555JgB+v5+33nqLu+++m2HDhlFYWMjEiRMJBAK4XC5Gjx5NYWEhp556Ki+88AK/+93vAL3Wd+zYsaxYsYIpU6Zw+eWXk5GRETo2e/Zshg0bRklJCVdddVWrzV0IIYQQrUPiDyHE8UgPEiFEi/v888+55pprGDt2bOhnn3zyCZs3byYxMZGIiAh27txJ165dAejfvz8vvPACRUVFPPTQQyxZsgSAXbt2kZ2dTWVlJZ999hn33nsvK1asqPNaLpeLiIgICgsLSUhIwOVykZCQQGVlZctNWAghhBCtTuIPIcTxyBIbIUSL279/P127duXyyy8P/ezyyy8nJiYGAIPBQHp6euhYly5dKCwspLCwkMzMzNDPMzIy8Hg8VFRUkJ+fT8+ePet9PZvNRkJCAgB2ux23230SZiWEEEKItkziDyHE8UiCRAjR4nJycti2bRtjx449Yi2uy+VCKcXChQuZPHkyJSUlLF++nOzsbIqLi7nvvvuoqKggKiqKBQsWkJaWhtPpJCcnh3vuuYeioqJQMCKEEEIIUUPiDyHE8UiCRAjR4nJycrjhhhvo378/I0eOJDIykujoaF566SUALBYLf/3rX3nsscdYu3YtV1xxRejqzJQpU8jOzqZfv34sW7aMOXPmhJ5z2rRpZGVlMWrUKGw2W50maUIIIYTo2CT+EEIcj/QgEUK0mtzcXNauXUtVVRU2m41f/OIXuFwuYmNjKS0tZenSpTgcDoYMGVLn99auXcu+ffsYNGgQKSkpdY5t27aN9evX4/F4GD16NKmpqXz44YdceOGFoce89957XHTRRS0yRyGEEEK0LRJ/CCGORhIkQog2pSZAcblcrT0UIYQQQnQQEn8IIUC2+RVCtDFWq5V58+a19jCEEEII0YFI/CGEAKkgEUIIIYQQQgghhJAKEiGEEEIIIYQQQghJkAghhBBCCCGEEKLDkwSJEEIIIYQQQgghOjxJkAghhBBCCCGEEKLDkwSJEEIIIYQQQgghOjxJkAghhBBCCCGEEKLDkwSJEEIIIYQQQgghOjxJkAghhBBCCCGEEKLDkwSJEEIIIYQQQgghOrz/B9iSNtcKsIZxAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1100x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training time:  xnn 564s   mace 453s\n"
     ]
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(11, 3.6))\n",
    "ep = range(1, EPOCHS + 1)\n",
    "ax[0].plot(ep, hist_xnn[\"train\"], label=\"xnn\"); ax[0].plot(ep, hist_mace[\"train\"], label=\"mace\")\n",
    "ax[0].set_yscale(\"log\"); ax[0].set_xlabel(\"epoch\"); ax[0].set_ylabel(\"train loss\"); ax[0].legend(); ax[0].set_title(\"training loss\")\n",
    "ax[1].plot(ep, hist_xnn[\"val\"], label=\"xnn\"); ax[1].plot(ep, hist_mace[\"val\"], label=\"mace\")\n",
    "ax[1].set_yscale(\"log\"); ax[1].set_xlabel(\"epoch\"); ax[1].set_ylabel(\"val loss\"); ax[1].legend(); ax[1].set_title(\"validation loss\")\n",
    "plt.tight_layout(); plt.savefig(\"argon_loss_curves.png\", dpi=120); plt.show()\n",
    "print(f\"training time:  xnn {t_xnn:.0f}s   mace {t_mace:.0f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d26ad66c",
   "metadata": {},
   "source": [
    "## 5. Evaluate both trained models on the held-out test set\n",
    "\n",
    "Identical evaluation for each: predict energy + forces (autograd) on all 50 test\n",
    "configurations and compute per-atom energy and force errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d450f320",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:40:54.084654Z",
     "iopub.status.busy": "2026-07-20T04:40:54.084526Z",
     "iopub.status.idle": "2026-07-20T04:41:02.214874Z",
     "shell.execute_reply": "2026-07-20T04:41:02.213903Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "metric                        xnn   original MACE\n",
      "--------------------------------------------------\n",
      "energy RMSE [meV/atom]       16.67           16.34\n",
      "energy MAE  [meV/atom]       16.25           14.12\n",
      "force  RMSE [meV/Å]           1.99            2.16\n",
      "force  MAE  [meV/Å]           1.30            1.44\n"
     ]
    }
   ],
   "source": [
    "def eval_xnn(model):\n",
    "    model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n",
    "    for s, i in zip(test_structs, range(len(xnn_test))):\n",
    "        out = model(xnn_test[i].to(DEVICE))\n",
    "        Ep.append(float(out[\"energy\"].detach())); Er.append(s[\"energy\"]); na.append(len(s[\"atomic_numbers\"]))\n",
    "        Fp.append(out[\"forces\"].detach().cpu().numpy()); Fr.append(s[\"forces\"])\n",
    "    return map(np.array, (Ep, Er, na)), np.concatenate(Fp), np.concatenate(Fr)\n",
    "\n",
    "def eval_mace(model):\n",
    "    model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n",
    "    for s, d in zip(test_structs, mace_test):\n",
    "        b = next(iter(DL([d], batch_size=1))).to(DEVICE)\n",
    "        out = model(b.to_dict(), training=False, compute_force=True)\n",
    "        Ep.append(float(out[\"energy\"].detach())); Er.append(s[\"energy\"]); na.append(len(s[\"atomic_numbers\"]))\n",
    "        Fp.append(out[\"forces\"].detach().cpu().numpy()); Fr.append(s[\"forces\"])\n",
    "    return map(np.array, (Ep, Er, na)), np.concatenate(Fp), np.concatenate(Fr)\n",
    "\n",
    "def metrics(EpErNa, Fp, Fr):\n",
    "    Ep, Er, na = EpErNa\n",
    "    e = (Ep - Er) / na * 1000.0; f = (Fp - Fr) * 1000.0\n",
    "    return dict(e_rmse=np.sqrt((e**2).mean()), e_mae=np.abs(e).mean(),\n",
    "                f_rmse=np.sqrt((f**2).mean()), f_mae=np.abs(f).mean(),\n",
    "                Ep=Ep/na, Er=Er/na, Fp=Fp, Fr=Fr)\n",
    "\n",
    "res_x = metrics(*eval_xnn(trainer.model))\n",
    "res_m = metrics(*eval_mace(mace_model))\n",
    "\n",
    "print(f\"{'metric':<22}{'xnn':>12}{'original MACE':>16}\")\n",
    "print(\"-\" * 50)\n",
    "print(f\"{'energy RMSE [meV/atom]':<22}{res_x['e_rmse']:>12.2f}{res_m['e_rmse']:>16.2f}\")\n",
    "print(f\"{'energy MAE  [meV/atom]':<22}{res_x['e_mae']:>12.2f}{res_m['e_mae']:>16.2f}\")\n",
    "print(f\"{'force  RMSE [meV/Å]':<22}{res_x['f_rmse']:>12.2f}{res_m['f_rmse']:>16.2f}\")\n",
    "print(f\"{'force  MAE  [meV/Å]':<22}{res_x['f_mae']:>12.2f}{res_m['f_mae']:>16.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d194c3",
   "metadata": {},
   "source": [
    "### Side-by-side parity plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "86d25cc2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:41:02.216891Z",
     "iopub.status.busy": "2026-07-20T04:41:02.216762Z",
     "iopub.status.idle": "2026-07-20T04:41:03.254902Z",
     "shell.execute_reply": "2026-07-20T04:41:03.254249Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 950x900 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved argon_parity_xnn_vs_mace.png\n"
     ]
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 2, figsize=(9.5, 9))\n",
    "rng = np.random.default_rng(0)\n",
    "idx = rng.choice(res_x[\"Fr\"].size, size=4000, replace=False)\n",
    "for col, (res, name) in enumerate([(res_x, \"xnn\"), (res_m, \"original MACE\")]):\n",
    "    a0 = ax[0, col]\n",
    "    lim = [min(res[\"Er\"].min(), res[\"Ep\"].min()), max(res[\"Er\"].max(), res[\"Ep\"].max())]\n",
    "    a0.plot(lim, lim, \"k--\", lw=1); a0.scatter(res[\"Er\"], res[\"Ep\"], s=26, alpha=0.7)\n",
    "    a0.set_xlabel(\"ref E/atom [eV]\"); a0.set_ylabel(\"pred E/atom [eV]\")\n",
    "    a0.set_title(f\"{name}: energy (RMSE {res['e_rmse']:.1f} meV/atom)\")\n",
    "    a1 = ax[1, col]\n",
    "    fr, fp = res[\"Fr\"].ravel()[idx], res[\"Fp\"].ravel()[idx]\n",
    "    lim = [min(fr.min(), fp.min()), max(fr.max(), fp.max())]\n",
    "    a1.plot(lim, lim, \"k--\", lw=1); a1.scatter(fr, fp, s=6, alpha=0.3)\n",
    "    a1.set_xlabel(\"ref force [eV/Å]\"); a1.set_ylabel(\"pred force [eV/Å]\")\n",
    "    a1.set_title(f\"{name}: forces (RMSE {res['f_rmse']:.1f} meV/Å)\")\n",
    "plt.tight_layout(); plt.savefig(\"argon_parity_xnn_vs_mace.png\", dpi=120); plt.show()\n",
    "print(\"saved argon_parity_xnn_vs_mace.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0855aff0",
   "metadata": {},
   "source": [
    "## 6. `xnn` ASE calculator (deployment)\n",
    "\n",
    "`xnn` ships an ASE `Calculator` for the trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f8274405",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:41:03.256911Z",
     "iopub.status.busy": "2026-07-20T04:41:03.256791Z",
     "iopub.status.idle": "2026-07-20T04:41:03.433755Z",
     "shell.execute_reply": "2026-07-20T04:41:03.432976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ASE single point: E = -22.5679 eV (-56.4 meV/atom) | max|F| = 0.0867 eV/Å\n",
      "reference       : E = -31.0395 eV\n"
     ]
    }
   ],
   "source": [
    "from ase import Atoms\n",
    "from xnn.common.deploy import XNNCalculator\n",
    "\n",
    "s = test_structs[0]\n",
    "atoms = Atoms(numbers=s[\"atomic_numbers\"], positions=s[\"pos\"], cell=s[\"cell\"], pbc=True)\n",
    "atoms.calc = XNNCalculator(trainer.model.to(\"cpu\"), cutoff=CUTOFF)\n",
    "print(f\"ASE single point: E = {atoms.get_potential_energy():.4f} eV \"\n",
    "      f\"({atoms.get_potential_energy()/len(atoms)*1000:.1f} meV/atom) | \"\n",
    "      f\"max|F| = {np.abs(atoms.get_forces()).max():.4f} eV/Å\")\n",
    "print(f\"reference       : E = {s['energy']:.4f} eV\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53f93429",
   "metadata": {},
   "source": [
    "## Summary: every stage compared\n",
    "\n",
    "| stage | result |\n",
    "|---|---|\n",
    "| **Data → graphs** | xnn and `mace` neighbour lists give the **identical edge set** (same counts, same lengths) |\n",
    "| **Model build** | identical architecture; parameter counts match except xnn's 200-entry `atom_ref` table (E0) |\n",
    "| **Same function?** | transplanting weights gives **identical E and F on periodic Argon** (float32 round-off; ~1e-13 in float64) |\n",
    "| **Training** | same data / loss / optimiser / schedule → **comparable loss curves** and final losses |\n",
    "| **Test accuracy** | energy and force RMSE/MAE **agree** between the two implementations |\n",
    "\n",
    "<br>\n",
    "\n",
    "> **Bug found & fixed while building this notebook.** The reference periodic\n",
    "> neighbour-list stored the cell-shift with a sign inconsistent with\n",
    "> `AtomicGraph.edge_vectors`, so cross-boundary edges got displacement lengths far\n",
    "> beyond the cutoff and were silently zeroed by the envelope; i.e. periodic\n",
    "> systems were trained as if non-periodic. The one-line fix (negate the stored\n",
    "> shift) is in `xnn/data/neighborlist.py`, guarded by `tests/test_neighborlist.py`\n",
    "> (xnn edge lengths now match ASE exactly). Every result above uses the fix.\n",
    "\n",
    "The `xnn` MACE is a faithful, dependency-light (only `e3nn`) re-implementation of\n",
    "the original MACE: it not only matches block-by-block (notebook 01) but delivers an\n",
    "**equivalent end-to-end training/testing pipeline** on realistic Argon data. The\n",
    "small residual differences in trained metrics come only from independent random\n",
    "initialisation and data shuffling; set the transplant before training (Section 3b)\n",
    "to start both from identical weights if exact-match training curves are desired.\n",
    "\n",
    "`REF_stress` is also present in the data; periodic stress training can be enabled\n",
    "with `compute_stress=True` / non-zero `stress_weight` (same autograd machinery on\n",
    "both sides)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "xnn (3.13.12)",
   "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
}