{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c09546e0",
   "metadata": {},
   "source": [
    "# Training & testing NequIP on Argon MD data: `xnn` vs the original NequIP, 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` NequIP\n",
    "(`xnn.gnn.models.nequip`) and once with the **original** `nequip` package\n",
    "(mir-group/nequip), and **compares the two at every stage**:\n",
    "\n",
    "| stage | xnn | original NequIP | comparison |\n",
    "|---|---|---|---|\n",
    "| 1. data → graphs | `AtomicDataset` | `nequip.data.AtomicData` | #edges, $\\langle$neighbours$\\rangle$ |\n",
    "| 2. model build | `build_model` | `nequip.model.model_from_config` | parameter count |\n",
    "| 3. *identical function?* | n/a | n/a | **weight transplant → same E, F** |\n",
    "| 4. training | `xnn.train.Trainer` | native 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. The data\n",
    "(`../../../datasets/argon_md/argon_{train,test}.xyz`, shared across the examples) carries\n",
    "`REF_energy`, `REF_forces`, `REF_stress`.\n",
    "\n",
    "> The companion notebook `../../fidelity_checks/nequip_verification.ipynb` proves the\n",
    "> two implementations are the same function block-by-block to machine precision;\n",
    "> here we confirm it on the *actual Argon data* and then show the full\n",
    "> training/testing pipeline gives matching results.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb6188e2",
   "metadata": {},
   "source": [
    "## 0. Setup\n",
    "\n",
    "`float32` on the GPU for training speed (both models identically).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "978b5f15",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:04:56.422301Z",
     "iopub.status.busy": "2026-07-20T05:04:56.422179Z",
     "iopub.status.idle": "2026-07-20T05:05:00.157801Z",
     "shell.execute_reply": "2026-07-20T05:05:00.156810Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: 0.1.0 | nequip (original): 0.6.2\n",
      "device: cuda | NVIDIA A100 80GB PCIe\n"
     ]
    }
   ],
   "source": [
    "# silence the expected warnings\n",
    "import logging\n",
    "import warnings\n",
    "\n",
    "logging.disable(logging.WARNING)                     # nequip's torch-version notice\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\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\"                                # shared across the examples\n",
    "import xnn, nequip\n",
    "print(\"xnn:\", xnn.__version__, \"| nequip (original):\", nequip.__version__)\n",
    "print(\"device:\", DEVICE, \"|\", torch.cuda.get_device_name(0) if DEVICE == \"cuda\" else \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66191f91",
   "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}}$: in NequIP language,\n",
    "the **per-species shift** `per_species_rescale_shifts` (the per-species scale is\n",
    "left at 1). The MD coordinates are *unwrapped*, so we `wrap()` each frame into its\n",
    "cell before building neighbour lists (physically identical under PBC). This shared\n",
    "list of structures feeds **both** pipelines.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9b448d51",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:00.159855Z",
     "iopub.status.busy": "2026-07-20T05:05:00.159759Z",
     "iopub.status.idle": "2026-07-20T05:05:00.914017Z",
     "shell.execute_reply": "2026-07-20T05:05:00.913368Z"
    }
   },
   "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": "09d520dd",
   "metadata": {},
   "source": [
    "### Quick EDA\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6279374c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:00.915699Z",
     "iopub.status.busy": "2026-07-20T05:05:00.915623Z",
     "iopub.status.idle": "2026-07-20T05:05:01.191705Z",
     "shell.execute_reply": "2026-07-20T05:05:01.191075Z"
    }
   },
   "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": "57e47b14",
   "metadata": {},
   "source": [
    "## 2. Build graphs: `xnn` **and** original NequIP 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 NequIP\n",
    "uses to normalise messages by $1/\\sqrt{\\lambda}$ (`avg_num_neighbors`).\n",
    "\n",
    "One data quirk first: the Argon set contains a few **fully vaporised** snapshots\n",
    "(546 Å boxes) in which *no* pair of atoms is within the 6 Å cutoff. `xnn` (like\n",
    "MACE) tolerates edgeless graphs (a local model simply predicts $\\sum_i E_{0,z_i}$\n",
    "for them), but the original `nequip` data pipeline **raises** on such frames.\n",
    "Since they carry no learnable signal for a local potential either way, we drop\n",
    "them from *both* pipelines so the two models see exactly the same data\n",
    "(7 of 200 train frames, 2 of 50 test frames).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fde39146",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:01.193485Z",
     "iopub.status.busy": "2026-07-20T05:05:01.193411Z",
     "iopub.status.idle": "2026-07-20T05:05:12.504359Z",
     "shell.execute_reply": "2026-07-20T05:05:12.503716Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dropped edgeless frames: train 7, test 2 (nequip's pipeline rejects them; zero signal for a local model)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total edges     xnn =  1372560   nequip =  1372558\n",
      "per-frame edges max|xnn - nequip| = 2  (identical neighbour lists)\n",
      "avg neighbours (edges/atom):  lambda = 17.779\n",
      "--> using avg_num_neighbors = 17.779 for both models (upstream 'auto' computes the same statistic)\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import AtomicDataset\n",
    "from nequip.data import AtomicData, AtomicDataDict\n",
    "from nequip.data.dataloader import DataLoader as NequipDataLoader\n",
    "from nequip.data.transforms import TypeMapper\n",
    "\n",
    "# --- drop the edgeless (fully vaporised) frames from both pipelines ---\n",
    "def with_edges(structs):\n",
    "    ds = AtomicDataset(structs, CUTOFF)\n",
    "    keep = [i for i in range(len(structs)) if ds[i].num_edges > 0]\n",
    "    return [structs[i] for i in keep], len(structs) - len(keep)\n",
    "\n",
    "train_structs, n_drop_tr = with_edges(train_structs)\n",
    "test_structs,  n_drop_te = with_edges(test_structs)\n",
    "print(f\"dropped edgeless frames: train {n_drop_tr}, test {n_drop_te} \"\n",
    "      \"(nequip's pipeline rejects them; zero signal for a local model)\")\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",
    "LAMBDA = float(xnn_edges.sum() / xnn_atoms.sum())\n",
    "\n",
    "# --- original NequIP graphs ---\n",
    "TM = TypeMapper(chemical_symbols=[\"Ar\"])\n",
    "def to_nequip(structs):\n",
    "    out = []\n",
    "    for s in structs:\n",
    "        d = AtomicData.from_points(\n",
    "            pos=torch.tensor(s[\"pos\"], dtype=torch.get_default_dtype()),\n",
    "            r_max=CUTOFF,\n",
    "            atomic_numbers=torch.tensor(s[\"atomic_numbers\"]),\n",
    "            cell=torch.tensor(s[\"cell\"], dtype=torch.get_default_dtype()),\n",
    "            pbc=torch.tensor([True, True, True]),\n",
    "            total_energy=torch.tensor([s[\"energy\"]], dtype=torch.get_default_dtype()),\n",
    "            forces=torch.tensor(s[\"forces\"], dtype=torch.get_default_dtype()))\n",
    "        out.append(TM(d))\n",
    "    return out\n",
    "nequip_train = to_nequip(train_structs)\n",
    "nequip_test  = to_nequip(test_structs)\n",
    "nequip_edges = np.array([d.edge_index.shape[1] for d in nequip_train])\n",
    "\n",
    "print(f\"total edges     xnn = {int(xnn_edges.sum()):>8d}   nequip = {int(nequip_edges.sum()):>8d}\")\n",
    "print(f\"per-frame edges max|xnn - nequip| = {np.abs(xnn_edges - nequip_edges).max()}\"\n",
    "      \"  (identical neighbour lists)\")\n",
    "print(f\"avg neighbours (edges/atom):  lambda = {LAMBDA:.3f}\")\n",
    "print(f\"--> using avg_num_neighbors = {LAMBDA:.3f} for both models \"\n",
    "      \"(upstream 'auto' computes the same statistic)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1804e6e",
   "metadata": {},
   "source": [
    "### One shared train / validation split\n",
    "\n",
    "Both pipelines train on exactly the same configurations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9fa4a63f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:12.506146Z",
     "iopub.status.busy": "2026-07-20T05:05:12.506066Z",
     "iopub.status.idle": "2026-07-20T05:05:12.509187Z",
     "shell.execute_reply": "2026-07-20T05:05:12.508647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 174 configs / val 19 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": "bf3d0433",
   "metadata": {},
   "source": [
    "## 3. Build both models with identical hyper-parameters\n",
    "\n",
    "A small-but-real NequIP: 3 layers, $\\ell_{\\max}=2$, parity on, 32 features,\n",
    "radial MLP $2\\times 64$, $\\lambda$-normalised messages, trainable Bessel basis.\n",
    "`xnn` is configured through the core `Config`; the original through its own\n",
    "`model_from_config` builders (`SimpleIrrepsConfig`, `EnergyModel`,\n",
    "`PerSpeciesRescale`, `ForceOutput`).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02931e8c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:12.510423Z",
     "iopub.status.busy": "2026-07-20T05:05:12.510352Z",
     "iopub.status.idle": "2026-07-20T05:05:16.053731Z",
     "shell.execute_reply": "2026-07-20T05:05:16.052585Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameters   xnn = 208,128   nequip = 207,928\n",
      "difference   = 200  ==  xnn's `atom_ref` reference-energy table\n",
      "             (nn.Embedding(200, 1): 200 entries; nequip stores the per-species\n",
      "              shift as a fixed buffer instead. The learnable embedding/conv/\n",
      "              readout parameters are identical in count.)\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.config import from_dict\n",
    "from xnn.common.models import build_model, ForceStressOutput\n",
    "from nequip.model import model_from_config\n",
    "\n",
    "HP = dict(r_max=CUTOFF, num_layers=3, l_max=2, parity=True, num_features=32,\n",
    "          num_basis=8, PolynomialCutoff_p=6, invariant_layers=2, invariant_neurons=64,\n",
    "          avg_num_neighbors=LAMBDA, use_sc=True, resnet=False)\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`. Keys copied\n",
    "# ---- verbatim from an upstream NequIP yaml (r_max, num_layers, num_basis,\n",
    "# ---- chemical_symbols, per_species_rescale_shifts, ...) also work: the\n",
    "# ---- translation registry in xnn.common.config.translate rewrites them to the\n",
    "# ---- xnn canonical names at config-load time) ----\n",
    "core = from_dict({\n",
    "    \"model\": {\"name\": \"nequip\", \"cutoff\": HP[\"r_max\"], \"n_features\": HP[\"num_features\"],\n",
    "              \"n_interactions\": HP[\"num_layers\"], \"n_rbf\": HP[\"num_basis\"],\n",
    "              \"species\": SPECIES, \"l_max\": HP[\"l_max\"], \"parity\": HP[\"parity\"],\n",
    "              \"invariant_layers\": HP[\"invariant_layers\"],\n",
    "              \"invariant_neurons\": HP[\"invariant_neurons\"],\n",
    "              \"num_polynomial_cutoff\": HP[\"PolynomialCutoff_p\"],\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 NequIP model ----\n",
    "torch.manual_seed(0)\n",
    "nequip_model = model_from_config(dict(\n",
    "    model_builders=[\"SimpleIrrepsConfig\", \"EnergyModel\", \"PerSpeciesRescale\", \"ForceOutput\"],\n",
    "    chemical_symbols=[\"Ar\"],\n",
    "    per_species_rescale_shifts=[E0[z] for z in SPECIES],\n",
    "    per_species_rescale_scales=[1.0],\n",
    "    **HP), initialize=True).to(DEVICE)\n",
    "\n",
    "p_xnn = sum(p.numel() for p in xnn_model.parameters())\n",
    "p_nequip = sum(p.numel() for p in nequip_model.parameters())\n",
    "print(f\"parameters   xnn = {p_xnn:,}   nequip = {p_nequip:,}\")\n",
    "print(f\"difference   = {p_xnn - p_nequip}  ==  xnn's `atom_ref` reference-energy table\")\n",
    "print(\"             (nn.Embedding(200, 1): 200 entries; nequip stores the per-species\")\n",
    "print(\"              shift as a fixed buffer instead. The learnable embedding/conv/\")\n",
    "print(\"              readout parameters are identical in count.)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e50db249",
   "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 NequIP 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^{-15}$; the block-by-block, non-periodic $10^{-16}$ proof is\n",
    "in notebook 01.)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8f114df4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:16.055860Z",
     "iopub.status.busy": "2026-07-20T05:05:16.055762Z",
     "iopub.status.idle": "2026-07-20T05:05:27.797557Z",
     "shell.execute_reply": "2026-07-20T05:05:27.796588Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transplanted models on Argon test configs (float32):\n",
      "  max |E_xnn - E_nequip|  = 9.54e-06 eV   (total energy of 400 atoms)\n",
      "  max |F_xnn - F_nequip|  = 1.45e-07 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": [
    "def transplant_full(xbase, nq_model, n_layers):\n",
    "    '''Copy every learnable weight original nequip -> xnn (same member names).'''\n",
    "    seq = nq_model.model.func                      # GraphModel -> EnergyModel sequential\n",
    "    with torch.no_grad():\n",
    "        xbase.edge_feat.rbf.freqs.copy_(seq.radial_basis.basis.bessel_weights)\n",
    "        xbase.chemical_embedding.load_state_dict(seq.chemical_embedding.linear.state_dict())\n",
    "        for i in range(n_layers):\n",
    "            xbase.layers[i].conv.load_state_dict(\n",
    "                getattr(seq, f\"layer{i}_convnet\").conv.state_dict())\n",
    "        xbase.conv_to_output_hidden.load_state_dict(\n",
    "            seq.conv_to_output_hidden.linear.state_dict())\n",
    "        xbase.output_hidden_to_scalar.load_state_dict(\n",
    "            seq.output_hidden_to_scalar.linear.state_dict())\n",
    "        psr = seq.per_species_rescale\n",
    "        for k, z in enumerate(SPECIES):\n",
    "            xbase.atom_ref.weight[z] = psr.shifts[k]\n",
    "            xbase.atom_scale[z] = psr.scales[k]\n",
    "\n",
    "transplant_full(xnn_model.model, nequip_model, HP[\"num_layers\"])\n",
    "\n",
    "dE, dF = [], []\n",
    "for k in range(8):                                  # first 8 test configs\n",
    "    ox = xnn_model(xnn_test[k].to(DEVICE))\n",
    "    dd = AtomicData.to_AtomicDataDict(\n",
    "        next(iter(NequipDataLoader([nequip_test[k]], batch_size=1))).to(DEVICE))\n",
    "    om = nequip_model(dd)\n",
    "    dE.append(abs(float(ox[\"energy\"]) - float(om[\"total_energy\"].sum())))\n",
    "    dF.append(np.abs(ox[\"forces\"].detach().cpu().numpy()\n",
    "                     - om[\"forces\"].detach().cpu().numpy()).max())\n",
    "print(\"transplanted models on Argon test configs (float32):\")\n",
    "print(f\"  max |E_xnn - E_nequip|  = {max(dE):.2e} eV   (total energy of 400 atoms)\")\n",
    "print(f\"  max |F_xnn - F_nequip|  = {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",
    "nequip_model = model_from_config(dict(\n",
    "    model_builders=[\"SimpleIrrepsConfig\", \"EnergyModel\", \"PerSpeciesRescale\", \"ForceOutput\"],\n",
    "    chemical_symbols=[\"Ar\"],\n",
    "    per_species_rescale_shifts=[E0[z] for z in SPECIES],\n",
    "    per_species_rescale_scales=[1.0],\n",
    "    **HP), initialize=True).to(DEVICE)\n",
    "print(\"\\nboth models re-initialised for the training comparison below.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b340f6a9",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b5fce955",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:05:27.799521Z",
     "iopub.status.busy": "2026-07-20T05:05:27.799438Z",
     "iopub.status.idle": "2026-07-20T05:18:08.362423Z",
     "shell.execute_reply": "2026-07-20T05:18:08.361254Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: trained 80 epochs in 758.8 s | final train 4.2691e-04 val 3.4484e-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": "138ca045",
   "metadata": {},
   "source": [
    "## 4b. Train the **original NequIP** model: same data, loss, optimiser, schedule\n",
    "\n",
    "A minimal native training loop over `nequip`'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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fd07ffd8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:18:08.364774Z",
     "iopub.status.busy": "2026-07-20T05:18:08.364691Z",
     "iopub.status.idle": "2026-07-20T05:30:21.262555Z",
     "shell.execute_reply": "2026-07-20T05:30:21.261383Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nequip: trained 80 epochs in 732.9 s | final train 4.1325e-04 val 3.5331e-04\n"
     ]
    }
   ],
   "source": [
    "nq_tr_loader = NequipDataLoader([nequip_train[i] for i in train_idx],\n",
    "                                batch_size=BS, shuffle=True)\n",
    "nq_va_loader = NequipDataLoader([nequip_train[i] for i in val_idx],\n",
    "                                batch_size=BS, shuffle=False)\n",
    "\n",
    "opt = torch.optim.Adam(nequip_model.parameters(), lr=LR, weight_decay=WD)\n",
    "sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=10)\n",
    "\n",
    "def nequip_loss(out, batch):\n",
    "    n = (batch.ptr[1:] - batch.ptr[:-1]).to(out[\"total_energy\"].dtype)  # atoms per config\n",
    "    e = (((out[\"total_energy\"].squeeze(-1) - batch.total_energy.squeeze(-1)) / n) ** 2).mean()\n",
    "    f = ((out[\"forces\"] - batch.forces) ** 2).mean()\n",
    "    return EW * e + FW * f\n",
    "\n",
    "hist_nequip = {\"train\": [], \"val\": []}\n",
    "t0 = time.time()\n",
    "for epoch in range(EPOCHS):\n",
    "    nequip_model.train()\n",
    "    tl = 0.0\n",
    "    for b in nq_tr_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        out = nequip_model(AtomicData.to_AtomicDataDict(b))\n",
    "        loss = nequip_loss(out, b)\n",
    "        opt.zero_grad(); loss.backward(); opt.step()\n",
    "        tl += float(loss.detach())\n",
    "    tl /= len(nq_tr_loader)\n",
    "\n",
    "    nequip_model.eval(); vl = 0.0\n",
    "    for b in nq_va_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        out = nequip_model(AtomicData.to_AtomicDataDict(b))\n",
    "        vl += float(nequip_loss(out, b).detach())\n",
    "    vl /= len(nq_va_loader)\n",
    "    sched.step(vl)\n",
    "    hist_nequip[\"train\"].append(tl); hist_nequip[\"val\"].append(vl)\n",
    "t_nequip = time.time() - t0\n",
    "print(f\"nequip: trained {EPOCHS} epochs in {t_nequip:.1f} s | \"\n",
    "      f\"final train {hist_nequip['train'][-1]:.4e} val {hist_nequip['val'][-1]:.4e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc1cba0e",
   "metadata": {},
   "source": [
    "### Training-loss curves: both models\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5ef56a21",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:30:21.265373Z",
     "iopub.status.busy": "2026-07-20T05:30:21.265283Z",
     "iopub.status.idle": "2026-07-20T05:30:21.897375Z",
     "shell.execute_reply": "2026-07-20T05:30:21.896469Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABEEAAAFdCAYAAADsTXOTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAzxBJREFUeJzs3Xd4VHXaxvHvzKT3RhIIodfQSxClil0Ru6Ii9ra4dnFt7+7a29pW1t67otjBighiCb2EDqEkpPeezMz7x5mZJJBAyiQTkvtzXbnmZObMOb8Bd+fwnKeY7Ha7HRERERERERGRDs7s6QWIiIiIiIiIiLQFBUFEREREREREpFNQEEREREREREREOgUFQURERERERESkU1AQREREREREREQ6BQVBRERERERERKRTUBBERERERERERDoFBUFEREREREREpFNQEERE3G7o0KGceeaZHnt/S3n6/CIiIp1Zfd/DTfluPvnkkxk5cmSbrKut6NpExH0UBBHphPr168e5557r6WWIiIiItCu6RhLp+Lw8vQAR6Xg2bNjg0feLiIhIx9Ierg3awxpEpOWUCSIiIiIiIiIinYKCICKdjJeXFzt27ODTTz/FZDJhMpkYOnSo6/Xu3bsza9YsVq1axZQpUwgICOD2228H4Pjjj3e9x2KxEBsby8yZM9m1a1edc9RXt+o87vr165kyZQr+/v706NGDJ5988qA1tvT9VVVV3H333cTFxREQEMCxxx5LcnJyi2qE7XY7zzzzDEOGDMHPz4/IyEjOPvtsNm3aVGe/RYsWMXnyZCIiIggPD2fixIl89tlnTd5HRETkSHDsscfSu3dv7Hb7Qa/NmDGDbt26YbVagcZfR9SnvmuD6upq7r33Xrp3717n+74+jTn34a6R6ltDY68PmnId01i6NhFpHgVBRDqZ6upq+vbtyznnnIPdbsdutx+U3pmWlsZ9993H888/z44dOzjmmGMA+PHHH13vKS0t5ZtvviE1NZVTTz2VsrKyw547PT2df/3rX8ybN4/9+/dzzTXXcMcdd/D11183au2Nff/VV1/Ns88+y+OPP87+/ft5+umnueOOO8jPz2/cH1I95syZw5133skNN9xAWloaS5cuJTs7m/Hjx7N582bASJOdMWMGEyZMYPPmzezbt48nn3ySDz74gIyMjEbvIyIicqS46qqrSElJ4eeff67zfHp6OgsXLuSyyy7DYrEALb+OONC1117LU089xcMPP8z+/ft58sknueWWW+r9vm/MuRtzjXSgxlwf1P4zacl1UHPOrWsTkXrYRaTT6du3r/2cc86p97W4uDi7j4+PPS0trVHH2rBhgx2wL1q0yPXckCFD7GecccZBxw0MDLRnZma6nrPZbPY+ffrYTz/99Dr7tuT9mzZtsgP2f//733Xev3XrVrvZbLaPGDHisJ/pwPNv3rzZbjKZ7Lfeemud/bKzs+2BgYGuP8sXX3zRDtgzMjIaPHZj9hERETlSlJWV2cPCwuwXXnhhnecfffRRO2Dftm3bId/f2OuI+r6bAfs///nPOvslJyfbTSZTo77v6zv3oa6Rmnt9YLc37TrInefWtYnIwZQJIiIHSUxMpGvXrgc9v23bNi6++GLi4uLw9vaukya6ffv2wx533LhxdOnSxfW7yWRiyJAh7Ny5s1Hrasz7Fy9eDMDpp59e5739+/dn0KBBjTrPgRYvXozdbufss8+u83xkZCRTp07lp59+AmD48OEAXHrppfz444/13tVqzD4iIiJHCj8/Py6++GIWLFhAXl6e6/k33niDKVOm0K9fP9dzLb2OqM2ZeTJjxow6zw8ePJiBAwcetL87z+3U2OsDp5ZeBzXn3Lo2ETmYgiAicpC4uLiDnsvLy2PChAns2rWLzz//nPz8fOx2OykpKYDRh+Nw6gushISENLpMpTHvz8nJASA6Ovqgfet7rjGcx4yNjT3otdjYWPLz87FarRx99NF88MEHZGZmcuKJJxIaGsrUqVOZP3++a//G7CMiInIkueqqqygvL+f9998HYNmyZWzZsoUrr7zStY87riNqc343x8TEHPTagc+5+9wHruFw1wdOLb0Oas65dW0icjAFQUTkIN7e3gc9t3DhQrKysnjmmWdITEwkMDAQoFHNzJxMJlOL1tWY90dGRgKQmZl50Gv1PdcYERERAPXWxWZkZBAWFuaqd545cyYrV64kOzub+fPn4+vry3nnncfnn3/uek9j9hERETlSjBw5ktGjR/P6668D8PrrrxMaGsq5557r2scd1xG1Ob/vG/purs3d53ZqyvUBtPw6qLnn1rWJSF0Kgoh0QoGBgVRUVDTrvb6+vnV+f/vtt92xJLc59thjAfjmm2/qPL99+/aDGpQ11rRp0wBYsGBBnedzc3P55ZdfOO644w56T0REBDNmzODTTz8F4Ndff23WPiIiIkeCq666ilWrVrF06VI+/vhjLrzwQvz9/Q/az13XEc7v+6+++qrO85s3b2br1q31vqcx527KNVJzrg/cRdcmIs2nIIhIJzR06FBWr17Nnj17Gv2eqVOnEhwczF133cW+ffvIzMzk4YcfpqSkpBVX2nSDBg3i0ksv5bHHHuODDz6gsLCQtWvXcsstt5CYmNisYw4cOJBrrrmG5557jpdffpm8vDw2bdrEOeecA8D9998PwJNPPsncuXNZtWoVxcXF5Obm8txzzwHGn19j9xERETnSXHTRRfj7+3PxxRdTUlJSpxQG3H8dMWjQIC677DKeeOIJ3nvvPQoLC1m9enW93/dNOXdTrpEae33QGnRtItJ8CoKIdEIPPvgg/fv3JyEhoU5jsEPp1q0bX3/9Nbm5uQwcOJBRo0ZRVFTEf/7znzZYcdO88sor3HDDDdx2223ExMRw00038eijj+Lv73/QXaDGeuGFF3j44Yd55plniI2N5ZhjjiE0NJTff/+dhIQEwBjNGxMTw7XXXktsbCwDBgzg+++/Z8GCBa7GbY3ZR0RE5EjjLH/Zu3cvw4cPZ+zYsXVeb43riJdffpkbb7yRO+64w/V9/8QTTxAWFtbsczf1Gqkx1wetRdcmIs1jstvtdk8vQkSkLTgvar744gtPL0VERERERDxAmSAi0imsXbuWHTt2MGXKFE8vRUREREREPESZICLS4Xz66afs3LmTc845h+joaJKSkrj++uspKytj3bp1hIaGenqJIiIiIiLiAcoEEZEO56STTiI3N5dTTz2VqKgoZs6cSWJiIsuWLVMARERERESkE1MmiIiIiIiIiIh0CsoEEREREREREZFOQUEQEREREREREekUvDy9gPbOZrORlpZGcHAwJpPJ08sRERE5YjgrbkNCQvQd2ki67hAREWkeu91OUVER3bp1w2xuON9DQZDDSEtLIz4+3tPLEBEROWIVFBQQEhLi6WUcEXTdISIi0jJ79+6le/fuDb6uIMhhBAcHA8YfpC7gREREGq+wsFD/oG8iXXeIiIg0j/O6w/ld2hAFQQ7DmYoaEhKiixERERFpVbruEBERaZnDlZOqMaqIiIiIiIiIdAoKgoiIiIiIiIhIp6AgiIiIiIiIiIh0CuoJIiIiRyybzUZlZaWnl9FpeXt7Y7FYPL0MERGRNmO1WqmqqvL0Mjold113KAgiIiJHpMrKSnbt2oXNZvP0Ujq1sLAwYmNjD9uETERE5Ehmt9tJT08nPz/f00vp1Nxx3aEgSAPmzZvHvHnzsFqtnl6KiIgcwG63s3//fiwWC/Hx8ZjNqu5sa3a7ndLSUjIzMwHo2rWrh1ckIiLSepwBkOjoaAICAhT8b2PuvO5QEKQBc+bMYc6cORQWFhIaGurp5YiISC3V1dWUlpbSrVs3AgICPL2cTsvf3x+AzMxMoqOjVRojIiIdktVqdQVAIiMjPb2cTstd1x26dSYiIkccZ5aej4+Ph1ciziCU6qNFRKSjcn7H6caL57njukNBkDa2Zm8+N324mie+2+zppYiIHPGUiup5+jto//7z/RaueDOJnVnFnl6KiMgRTd95nueOvwMFQdpYTnEFX6xJ49et2Z5eioiIiHQCS7Zm8fPmTLZlKggiIiKiIEgbCwswUrfzSjXSUURERFpfjwgjdXhPTqmHVyIiIuJ5CoK0sfAAbwDyS1U7LSIiIoZ58+aRkJBAYmKi24/dM9IRBMlVEERERERBkDYW7sgEKa6oprLa5uHViIhIWykuLmbDhg2Ul5fXeX7btm2kpqYCkJKSQkZGBgDZ2dmu7doasw9AZWUlu3btorRU//A9EsyZM4fk5GSSkpLcfuyeEYEA7FYQRESkU9m5cyd79uyp81xBQQEbNmygqqqK0tJSNmzYgN1up7q6mpSUFCor61YsNGYfp+zsbPbu3dtqn8ddFARpYyH+3jh7ueSXqSRGRKSz8PLy4oILLuBvf/ub67lFixaRkJDgukC56qqruPbaaxk9ejRjxoyhT58+HHfccZSUlLje05h9nn/+ebp06cJxxx1HXFwcs2fPprhY/SA6q3hXOUzJYfYUEZGOZNmyZQwePJjNm42hHFarlenTp/OPf/wDb29vVq1axbBhw7j77rvp2rUrkydPJiIigk8++cR1jMbsk56eztFHH03fvn2ZPHkyPXv2ZNGiRW3+eRvLy9ML6GwsZhOh/t7kl1aRX1pFdLCfp5ckInLEs9vtlFVZPXJuf29LozqV+/n58cEHHzBu3DhOOeUUpk6dymWXXca9997L0Ucf7drvhx9+YPHixYwbN46srCxGjRrFiy++yG233daofXJzc7nxxhv5/vvvOf7447HZbHz44YekpqYycODAVvkzkPbNWQ6zL6+MaqsNL4vugYmItJSnrj0ae90BMHv2bBYuXMhFF13EH3/8waOPPsrWrVtZv359nf327NlDamoqPj4+PPLII1x77bWceeaZeHt7N2qfRx55BH9/f7KysvDx8SEtLY3PP//cnR/brRQE8YDwAB9XEERERFqurMpKwv9955FzJ99/EgE+jfs6HT58OI8++ijXXnstI0eOpG/fvtx777119jnnnHMYN24cAF26dOGEE05gzZo1jd6npKQEu91OeHg4AGazmYsuuqgFn1COdLEhfvh4mamstrG/oNyVGSIiIs3nqWuPplx3ALz44ouMGDGC8847j2+//ZYvvviC6OjoOvs88MAD+PgYbRsuuugi7r77bvbs2UPfvn0btU9xcTEhISF4eRnr6tatW53M1/ZGtwI8INTfiKhpQoyISOdz00030aNHD5YsWcJbb72FxWKp83q3bt3q/B4YGEhRUVGj94mPj+f2229n4sSJnHTSSTz66KPs2rWrFT6JHCnMZhPx4f4A7NaEGBGRTiU0NJSnn36aL7/8kosuuohTTz31oH1qX1cEBhp9pA517XHgPrfddhvr1q2jT58+XHvttSxYsACbrf32v1QmiAfUTIhREERExB38vS0k33+Sx87dFEuXLmXjxo0EBwczf/58/vGPf7h9TU888QRz587lp59+4quvvuJf//oXixYtYurUqW4/lxwZekYGsiOrhN25JUwkytPLERE54nnq2qOp1x12u50XXniB8PBwfvzxR3JycoiMjHTrmhISEti+fTt//fUXixcv5tZbb+XFF1/ku+88k6V7OAqCtLWcHZxR/gVhZit5pYM8vRoRkQ7BZDI1KTXUU/Lz87nkkku47bbbGD9+POeffz4nnHACY8aMcds5Kisr8fHxoUuXLsycOZOZM2eyb98+vvzySwVBOrEeERqTKyLiTkfKtcfTTz/NypUrWbVqFeeddx7XXHMNn376qVvP4bz2GD9+vOtn2rRpFBYWEhIS4tZzuUP7/1vraLI2c2bG8/Ty6svC0ks9vRoREWlD119/PZGRkdx///34+Phw2WWXcfHFF7Nq1SoCAtzTp2Ht2rXccsstXH/99QwcOJDNmzezevVq/v73v7vl+HJkcgVBVA4jItJprFu3jrvvvpt3332XXr168f777zNq1Chee+01rrzySredZ/bs2fTt25fjjjsOPz8/nn/+eYYOHdouAyCgniBtzz8CgDCKyS9RY1QRkc5iyZIlJCcn8/7777saiz3zzDN069aNl156CYDevXsTGxtb533dunWjZ8+ert8Pt09iYiKPP/44Cxcu5G9/+xsfffQRr732Gueee25rfjxp55wTYtQTRESkc7Db7TzyyCNcd911rmuA/v37M2/ePF599VVycnIIDAxkyJAhmM01YQEvLy+GDBmCv7/RS6ox+7z66qsEBQXx0EMPMXfuXOLj49ttKQyAyW632z29iPassLCQ0NBQCgoK3BPJytoC88ZRYA/gjr5f8fLssS0/pohIJ1NeXs6uXbvo3bs3fn4aNe5Jh/q7cPt3aCfQWn9m2zOLOP6pXwny9WL9v05s9HhFERHRdUd74o7rDmWCtDVHJkioqZTCknIPL0ZEREQ6g+7hAZhMUFxRTW6JGrOLiEjnpSBIW/MPd21aS3M9uBARERHpLPy8LcSGGHfMdqs5qoiIdGIKgrQ1ixdWH0dqTpmCICIiItI21BxVREREQRCPsDtKYizluagli4iIiLQFjckVERHpBEGQwsJCoqKiiIqK4oorrvD0cgAwBRpBkGBbESWVVg+vRkRERDoDTYgRERHpBEGQ4OBgNm/ezHPPPUdhYaGnlwOAOTAKgDBTMXlqTiYiIiJtoEdkIAB7cks8vBIRERHPaRdBkLy8PNasWUNxcXGD+6SlpbF161aqq6ubdGyTyURUVFS7Gs1ncpTDRFBEfmmVh1cjIiIinUHPCGWCiIiIeDQIsn79ei677DL69+/PqFGjWLFixUH75OXlccIJJ9CvXz+mTJlCfHw8P/zwg+v1P//801XucuCP1dpOS00CjCBIuKmYvFJlgoiIiEjrc5bDZBZVUKZyXBER6aS8PHny5cuXM2XKFO655x4GDBhQ7z7XX389mZmZ7N+/n9DQUP7v//6Pc845hx07dtClSxfGjBnD5s2b632vxWJpzeU3nyMTJIwiBUFERESkTYQF+BDi50VheTV7cksZGBvs6SWJiIi0OY9mglx77bVcfvnl+Pv71/t6Xl4e8+fPZ+7cuYSGhgJw1113YbPZ+PDDDwHw8vJqMBOkOSoqKigsLKzz43YB4YCRCVJQpnIYERHxjKuuuor77rvP08uQNtTD1RxVfUFERKRtJScn0717d/Ly8jy6jnbRE6Qha9aswWq1Mm7cONdz/v7+DB8+nFWrVjX6OAMHDuTiiy/mq6++Iioqip9//rnBfR955BFCQ0NdP/Hx8S36DPUKiAQg3FREXomCICIi4hnZ2dkevxCRttUzwtkcVX1BRESkbVVWVpKamurxthUeLYc5nJycHAAiIyPrPB8ZGUl2dnajj/P7779js9lcvzuzSupz1113ceutt7p+LywsdH8gxFEOE456goiIiOe89tpr7bd0tJOZN28e8+bNa/ULQ2cmiIIgIiLS1oYMGcLevXuJiIjw6DradSaIt7c3YJSo1FZRUeF6rTEiIiLqlMkc6r2+vr6EhITU+XE7R2PUMFMR+QqCiIh0GhdeeCH//Oc/ueuuuxg7diyjRo3i8ccfx26319nv448/ZurUqfTr148TTzyRRYsW1XndZrPx73//m4SEBI466ijuv/9+/va3vzF37lzXPieddBIvvfRSnffNmTOnzj533nkn//nPf+qs77777uO2225j9OjRjBgxgv/+97/u/COQBsyZM4fk5GSSkpJa9TyaECMi0nkkJSXRvXt3fvrpJ0477TQGDRrEjBkz2LJlS539MjIy+Nvf/sbgwYMZOXIkN910E/n5+XX2Wbt2LSeddBIDBw7kjDPO4PPPP6d79+6kp6cD8N133zFw4MA679mxY0edfbZt28b48eMpKCios77vvvuOk08+mQEDBnDWWWexc+fOVvoTMbTrIIgzA2P//v11nk9LS2udMpW24mqMWkJeiYIgIiItZrdDZYlnfg4IYBxKVlYWDz74IIGBgbzzzjvcd999/POf/+STTz5x7fO///2P22+/nRtvvJFvv/2WSy+9lPPPP5/vv//etc+DDz7ICy+8wGOPPcbLL79McnIyL730Erm5ua59MjIyKCoqqnP+nJycOvscWA6TlZXFww8/TFVVFW+//TZz587l7rvv5vXXX2/SX4e0X8oEERFxE09dezThuqOiooLU1FRuu+02br/9dj777DMsFgvnnHOO6wZMYWEhEydOdPXdfPPNN9m9ezfTp0937ZOXl8e0adPo2bMn8+fP5+KLL+bKK68kNTWV6upqAMrKykhNTa1z/qqqqjr7HFgO41zfNddcw80338zHH3+M3W7nxBNPpKqq9dpGtOtymOHDhxMVFcW3337L6NGjAdi1axcbN27k4Ycf9vDqWsCRCeJtslJZku/ZtYiIdARVpfBwN8+c++408Als9O4nnngi9957LwCDBw9m+vTp/PDDD5x//vlUVVVx77338uabbzJjxgwABgwYwMaNG3nmmWc48cQTqays5Mknn+TZZ5/l9NNPB+DNN988ZL+rphg8eDDPPfccAEOHDmX79u08/PDDXHHFFW45vnhWD0cmyL68Uqw2OxazycMrEhE5Qnnq2qOJ1x0AL730EkcddRRg3EgZOnQoaWlpxMXF8corrxAcHMyLL77o2v+9994jPDycpKQkxo0bx0svvURoaCgvvvgiZrOZYcOGsXfvXm6//Xa3fKQnn3ySk08+GYC3336b+Ph4PvroI2bNmuWW4x/Io0GQ3Nxc9uzZQ2ZmJgDbt28nLCyM2NhYYmNj8fLy4l//+hd33HEHMTEx9OjRg/vuu4+jjjqK6dOnt+raWrU219sfq5c/luoy7KU57j++iIi0W0OHDq3ze0xMjOvOyebNm8nLy+Nvf/sbN954I3a7HbvdTnFxsWvq2a5duygqKmLixImuY/j5+TF27Fi3rG/ChAl1fp80aRL/+te/KCkpITCwaRdd0v50DfXH22KiymonLb+MeEdQREREOq7a1x4xMTGAkQ0aFxfH8uXL2bp1K7169XJdd9jtdqxWK9u3b2fcuHGsXbuWo48+GrO5ppBk0qRJbltf7WuakJAQRowYwbp169x2/AN5NAiybNky/u///g+AESNG8PzzzwNw3XXXcd111wFGjWxoaChvv/02RUVFTJ48mXvvvbfOX0BrmDNnDnPmzKGwsPCQjVSby+YXjqW4DFO5uvKLiLSYd4BxZ8RT526C+hqROtNNy8vLAXj33Xfp169fnX28vIyvbGefLB8fnzqvH/h7czV03MrKSgVBOgCL2UR8eAA7s0vYk1uqIIiISHN56tqjidcdcPhrj2nTpvG///3voH2cDUwrKioO+jexu6476juWj4/PQX1B3cmjQZAZM2a40n0PZdasWa2WCuMppoAIKE7DtzKfaqsNL0u7bs8iItK+mUxNTg1tjwYMGICXlxdbt25l6tSp9e7Tp08fLBYL69evp2fPnoBxIbN+/XqOPfZY134hISEH9QTZvXs3Q4YMOeQa1q9fX+f3tWvXEhkZSXh4eDM+kbQLX98CqSvhrJchehA9ImuCIBMO/24REalPB7n2GDJkCB999BExMTENDhDp378/P/30U53n1q5dW+f3kJAQysvLqa6udt242b17d6PWsH79etd1T3V1NcnJyZx55plN+yBNoH95e4g50Bj7G0YxBWWt1/RFRESOHKGhoVx77bX83//9H0uXLgWMuy9fffWVK1syKCiIWbNmcd9995GRkYHNZuPxxx8/qJP62LFj+fTTT12NT99++23++OOPw65hyZIlvP/++4BRpvr4449z/fXXu/NjSlvbvw72r4WszYAmxIiISI3rr7+evLw85syZQ3FxMQB79+7lpptucl1DXH311axdu5ZXXnkFu93Onj17eOihh+ocZ9iwYXh5ebmaqWdkZPCvf/2rUWu46667yMnJwWq1cv/991NSUsJFF13kvg95AAVBGjBv3jwSEhJITExsleObA4wgSISpiLxSBUFERMTw9NNPc8UVVzBjxgxCQkKIiori9ddf54QTTnDt89RTTxEdHU23bt2IjIzkl19+qfM6wN13302XLl2IjY0lMjKSBQsWcNxxxx32/Oeddx7PP/88YWFhDBo0iGOOOYa7777b7Z9T2lDUAOMxexsAPSKNO5d7cks8tSIREWknevfuzU8//cT69esJCwsjLCyMyZMn079/f1cJTL9+/XjjjTe48847CQkJITExkQsuuKDOcbp06cILL7zA7bffTnh4OGPHjuWkk05q1BpOPfVUBgwYQEhICK+++iofffSRqxSnNZjs9ibM2OmEnD1BCgoKCAkJcd+Bv7kNkl7lueozOeaqpxnbq/X+kkVEOpry8nJ27dpF79698fPz8/RyGi07OxsfH5863yf5+flYrVYiIyPr7Guz2cjJySEiIqLeWl7newMCAvDx8WHWrFn4+fnx6quv1tmnuLgYX19fvL29yc3NxWQyuUpbcnJysFgshIWFAXD88cczduxYHn30UcrKyqiuriY4OPiQn+lQfxet9h3agbXKn9nSp+Cnf8Ow8+GcV/ghOYOr317BkG4hfHOj+xrbiYh0VEfqdUdlZSWZmZl0797d9ZzNZiMtLa3e8peSkhKqq6sb7IlZXV1NYWEhERERbN++nf79+7N37946x7fb7RQUFBAWFkZ1dTXp6el07doVi8VCVVUVGRkZdOvWDbPZzLJly5g0aRJlZWX4+fmRk5NDeHj4Ift/uuO6o12PyO3Q/I2gRzjFygQREekknBNeanMGIA5kNpvp0qXLIY/X0HtrCwoKcm0feFflwMBLbf7+/oc9thwhXJkgWwHoGWmUw+zJKcVut2MyaUyuiEhH5OPjUydAAcb1xYHPOR2uAbqXl9dhMzRMJpPr+sTLy6vOuby9vRs8Nxz6usSdVA7jKQGOIIipmLzSSg8vRkRERDqsqP7GY852sNvp4egJUlRRrRsxIiLS6SgTxFMcmSBhFJGmIIiIiLTQf//73xYf48MPP3TryDtpJ8J7g8kClcVQtB+/kG7EhPiSUVjB7pwSIgL1dy4iIk3Tu3dv9u7dS9euXZt9jHHjxrF37942LzFSJoinuBqjqhxGRERaLjw8vMVjbKOiotS7oyPy8oGI3sa2syQmwtkcVRNiRESk6SwWC927d2+wb1lj1Feu0xYUBGlAa0+HIcC4UA0zFZGvTBARERFpTQdNiKnpCyIiItKZKAjSgDlz5pCcnExSUlLrnKBWY9R8ZYKIiDSLBpx5nv4OjhDOviCOTBBnXxBlgoiINJ6+8zzPHX8HCoJ4iqMxqr+pkpLiQg8vRkTkyOJMvaysVCadp5WWGv+IPnDMnrQzkc4giJEJEhPia/xaXOGpFYmIHDGc33HO7zzxHHdcd6gxqqf4hmAzeWG2V2MrzfX0akREjiheXl4EBASQlZWFt7f3IefJS+uw2+2UlpaSmZlJWFhYi2qCpQ0cUA4TEWgEQXJKFEgUETkci8VCWFgYmZmZAAQEBGi8eBtz53WHgiCeYjJh9QvHXJYFCoKIiDSJyWSia9eu7Nq1i927d3t6OZ1aWFgYsbGxnl6GHI6zHKZwH1QUExlkTITJKVYQRESkMZzfdc5AiHiGO647FATxJP9wKMvCUpGH3W5XNFFEpAl8fHzo37+/SmI8yNvbWxkgR4qACAiIgtJsyNlOZKARFMlVJoiISKM4b8BER0dTVaWejp7grusOBUEaMG/ePObNm4fVam21c5gDIyEXgqxFlFVZCfDRX4eISFOYzeY2ny0vcsSKGgB7siF7GxEDhgBQVmWltLJa1yAiIo1ksVh0A+AIpyLqBrT6dBjAHOiYEGMqIk8TYkRERKQ1RfUzHnO2EeTrhY+XcRmokhgREelMFATxIFNAJADhFJGndFQRERFpTa7mqFsxmUxEBhp9QVQSIyIinYmCIJ7k78wEKaagTJkgIiIi0ooOmhDjaI5aojG5IiLSeSgI4kkBRhAkzFRMXqnuwoiIiEgrck6IydkONmtNEETlMCIi0okoCOJJzkwQ1BNEREREWllYT7D4QHU5FOwlKsgXUDmMiIh0LgqCeJKzJ4ipiHxdgIiIiEhrMlsgoq+xnb29VjmMrkFERKTzUBCkAfPmzSMhIYHExMTWO0mAMxOkWJkgIiIi0vqcJTHZW1UOIyIinZKCIA1oixG5tRuj5qsniIiIiLS2WhNiooKc02HUGFVERDoPBUE8yZEJEmIqpbCk1MOLERERkQ6v1oSYiED1BBERkc7Hy9ML6NT8wlybVSW5nluHiIiIuE1+fj5PPfUU27ZtY8KECVx//fVYLBZPL8tQTzlMtsphRESkE1EmiCdZvKj2CQXAVKYgiIiISEdw9tln4+Pjw+mnn87LL7/Mk08+6ekl1XAGQUoy6eJdBigTREREOhdlgniYzT8cKgswleV5eikiIiLiBp999hlhYWEAlJSUsHLlSs8uqDbfYAjuCkX7iSzfA0BZlZXSymoCfHRZKCIiHZ8yQTzM5OgL4l2Zh9Vm9/BqREREOrYVK1Zw5ZVXEhoayoknnljvPqtWrWLq1KmEhYUxYMAAnn322Tqv33vvvUyfPv2gn3fffRfAFQApLCzkrbfeYs6cOa36mZrMkQ0SULADH4txKagJMSIi0lko5O9hlsBIAMIoprCsinBHfa6IiIi4V05ODtdddx3XXnstpaWl7N+//6B9MjIyOP7447nwwgt57733SEpK4qKLLiIgIICrr74agNNPP53x48cf9N7+/fu7tjMzM5k5cyYPP/www4YNa70P1RxRA2DXr5hythEZNIn9BeXkllQSHxHg6ZWJiIi0OgVBPMwcGAVABEXklVYqCCIiItJKIiMjWbFiBQB//vlnvfu8/PLLeHl58dxzz2GxWIiLi+Oaa67hsccecwVBjjrqqEOeZ+vWrcyePZt58+YxZswY934Id6gzIeY4VxBERESkM1A5TAPmzZtHQkICiYmJrXsif6McJsxUTF5pVeueS0RERA5p2bJlTJ48uc40l+OOO44dO3aQnp7eqGOcdNJJFBcX889//pPp06dz//33N7hvRUUFhYWFdX5anWtCzLZaE2IqWv+8IiIi7YAyQRowZ84c5syZQ2FhIaGhoa13ooBwAMIpJr9Ud2FEREQ8af/+/fTt27fOc9HR0QCkp6cTGxt72GO89NJLVFbWfKfHxMQ0uO8jjzzCv//972autpkiHUGQ3J106W/cD1MmiIiIdBYKgniaIxMk3FSkTBAREZF2wGw21/u73d64BuYNNVytz1133cWtt97q+r2wsJD4+PhGv79ZQuLAOwCqSunrnQMoCCIiIp2HgiCeFlATBNmjTBARERGPiomJISsrq85zmZmZrtfczdfXF19fX7cf95DMZojsB+nr6GVPBWLJURBEREQ6CfUE8bQAYzqMUQ6jTBARERFPOvroo1m6dGmdrI/FixfTo0cPunXr5sGVuZmjOWpc9V4ActQTREREOgkFQTytTmNU3YURERHxpKuvvprCwkLuueceiouLWbJkCS+//DK33HKLp5fmXo7mqF0qjSCIymFERKSzUDmMpznKYcIopqBEd2FERERa08CBA9m9ezfV1dXYbDb8/PwAKC8vByA+Pp6FCxdyww038NhjjxEREcGtt97KTTfd1KrrmjdvHvPmzcNqtbbqeVxCuwMQVGmU+qgcRkREOgsFQTzNkQniZbJRUZLn4cWIiIh0bOvWrTtsg9NJkyaxdu1abDbbQU1SW0ubTaVzCjam3PiXZwOQU6wgiIiIdA4Kgniatx9WrwAs1aVYS3I9vRoREZEOrSlNSNsqAOIRQUYQxKvMyAQpq7JSVmnF38fiyVWJiIi0ug787X7ksPqGA2AqUxBERERE2oAjE8Rcmk2AxQZAjspyRUSkE1AQpD0IMIIglnKVw4iIiEgb8I8As5EQ3C+gFFBJjIiIdA4KgjRg3rx5JCQkkJiY2OrnMgcaY3IDrYWUV7VRQzQRERHpvMxmCIoBoK9/EaAJMSIi0jkoCNKAOXPmkJycTFJSUqufy+IIgkSYinQBIiIi0gm15c0XF0cQpIePEQTRhBgREekMFARpB0wBRhAkzFTM9sxiD69GRERE2lpb3nxxcfQFibMUAJBTrJ4gIiLS8SkI0h4EGGNywyli7d58z65FREREOgdHECTWbARBlI0qIiKdgYIg7YG/EQQJMxWzdl+BhxcjIiIinYJjTG4kRmN2lcOIiEhnoCBIe+DIBImgiHX78j27FhEREekcgo2eIGHVOYAyQUREpHNQEKQ9cJbDmIrJLKogvaDcwwsSERGRDs+RCRJcZQRB1BNEREQ6AwVB2gNHOUyUpQSAtcoGERERkdbmyATxq8gCVA4jIiKdg4Ig7YEjEyQMY0SdSmJERESk1TkyQbzLszFjUzmMiIh0CgqCtAeOTBBveyV+VLBOzVFFREQ6lXnz5pGQkEBiYmLbnTSwC2DCZLcRSSGllVbKKq1td34REREPUBCkPfANBrM3AJEUsnZvPna73cOLEhERkbYyZ84ckpOTSUpKaruTWrwcgRDoZjFuwOSUqC+IiIh0bAqCtAcmE4R2B6CPdzaF5dWk5JR6eFEiIiLS4QUbJTF9/IsBTYgREZGOT0GQ9iKqPwDHhOYC6gsiIiIibcARBOnlUwhATrGCICIi0rEpCNJeRA0AYKR/JgBr96oviIiIiLSyIGNCTJyXsxxGQRAREenYFARpLyL7AdCb/YAyQURERKQNODJBYs1GECRXPUFERKSDUxCkvXBkgkSW7wZgQ1oB1VabJ1ckIiIiHZ0jEySKPECZICIi0vEpCNKANh9V5+gJ4lW0j0hfG+VVNrZlFrfNuUVERKRzcmSChFmNnmTqCSIiIh2dgiANaPNRdYFdwC8UE3amRRcBKokRERHpLNr85otTkBEECa7KATQdRkREOr5mBUEqKytZvHix6/c//viDyy67jAceeICqqiq3La5TMZkgsu6EmLX71BxVRESkM2jzmy9OjkwQ/4pswK5yGBER6fCaFQR58MEH+f333wEoLi5m+vTpZGRk8Oabb3Lvvfe6dYGdiqMvSIKPMSFGmSAiIiLSqhw9Qcz2KsIpIqdYjVFFRKRja1YQ5J133uHSSy8F4Pvvv6dv374sXLiQr776ig8++MCtC+xUoowJMd2tewHYvL+I8iqrJ1ckIiIiHZmXD/hHABBtylc5jIiIdHjNCoJkZmYSGhoKwOLFizn11FMB6NWrFzk5Oe5bXWfjyAQJKNpFZKAP1TY7yfsLPbwoERER6dAcJTHRpnxKK62UVeoGjIiIdFzNCoIMHTqUp59+mlWrVvHhhx9y8sknA5CcnMyQIUPcusBOxdETxJS9jeFxIQCs25vvwQWJiIhIh+coielqzgcgp0QlMSIi0nE1KwjyxBNP8OyzzzJmzBhOO+00jjrqKACefvppbr75Zneur3OJ6A0mC1QWc3R0NQDr1BxVREREWpMjE6SnbzGgCTEiItKxeTXnTZMnTyYzM5Pi4mJCQkJcz//zn/+kf//+bltcp+PlC+E9IXcnicFZgDdr1RxVRESE5ORkgoODiY+Pp7Kykscee4xdu3ZxzTXXMH78eE8v78jmyATp7mXceNGEGBER6ciaPSJ3yZIlrgCIc0TuRx99RHV1tVsX2Ok4+oL0t6QDsDO7hKJyjR0WEZHOKysri/POO4/AwEAA/vOf//DCCy+Ql5fHCSecQFZWlodXeIQL7grUlMPkFisIIiIiHZdG5LY3kcaEmKCiXcSF+WO3w/pUlcSIiEjn9e2333LMMccQEWFMMfnggw947bXXWLBgAaeccgpfffWVh1d4hAs2MkGiyAPUE0RERDo2jchtbxyZIGRvY0S8MYFn7V4FQUREpPOqPZUuKyuL7du3M23aNKDjTKabN28eCQkJJCYmtv3Jg4yeIGFWZxBEmSAiItJxaURuexPl6KmSvY3RPcIBWLk714MLEhER8ayhQ4fy2WefsWbNGh599FGmTJmCr68v0HEm082ZM4fk5GSSkpLa/uSOTJDg6mzArnIYERHp0JrVGNU5Ive0007jww8/5OuvvwY6zoWIRzkzQQr2ktjdH4AVu/Ow2eyYzSYPLkxERMQzTj75ZMaOHcuoUaOIjIxk0aJFAGzevJk9e/Zw0kkneXiFRzhHJoi3rYJgypQJIiIiHZpG5LY3AZHgFwbYSfDJxM/bTH5pFTuyij29MhEREY8wmUx8/PHHFBYWkpGRwdixYwGIjo7mp59+wmKxeHiFRzifAPA1mt1Hm/IUBBERkQ5NI3LbG5PJyAbZ9xfeeTsYFd+N33fmkJSSR/+YYE+vTkRExCOcI3KDg4MPGpHbpUsXTy/vyBcUAxWFRJvy2afGqCIi0oE1KxMEwGw21wmAAAwYMACTSSUbLVarL0hiL6MvyIoU9QUREZHOSSNy20CwURITTR7ZRZXY7XYPL0hERKR1NDsIsmbNGmbNmsWYMWMYPXo0s2bNYs2aNW5cWifmDILkbGNsL2McYJKao4qISCelEbltwBEE6WopoKzKSkpOqYcXJCIi0jqaFQT54osvGDNmDOnp6ZxyyimcdtpppKenM2bMGL788kt3r7HziXRmgmxlVI8wzCbYm1tGekG5Z9clIiLiAZ1hRK7HBRkTYhKCywBI2qWbLyIi0jE1Kwhy33338dRTT/Hjjz/y4IMP8sADD/Djjz/y1FNPce+997p7jZ2Pc0JM9naCfb0Y3NUoO1qhbBAREemEOsOIXI9zZIL08zcasf+lMlwREemgmhUE2bx5M5dddtlBz1922WVs2bKlpWuS8F5gskBVCRSmkegoiVmRkufZdYmIiHhA7RG5b731Fg888ACgEbluFVRTDgOQpCCIiIh0UM0KgkRHR7N69eqDnl+5cmW77ND+zTffcNFFF3Httdeyfv16Ty/n8Lx8IKK3sZ2zjbGO5qi6IBERkc5II3LbQLBRDhNSnYPJBLtzSsksVBmuiIh0PM0Kglx99dVccMEFPPPMMyxfvpzly5fz9NNPM3PmTK6++mp3r7FFFixYwEsvvcTpp59ObGwsU6dOpbT0CGj2FVkzIWZsTyMTZNP+QorKqzy4KBEREc8JDg6uE/CIiIholzdfmmPevHkkJCSQmJjomQU4MkEsxRkMijXKcFUSIyIiHZFXc95033334e/vz4MPPuhqRhYZGcncuXO5/fbb3brAljruuOM466yzXL+/+uqrFBUVERAQ4MFVNUJUf9i6ELK3ETvOj/gIf/bmlrF6Tz6TB3SMCz4REZHGqqio4Pnnn2fhwoWkpqYSFxfHKaecwg033ODqD3IkmzNnDnPmzKGwsNDVBLZNOTJBqCxiwiA/Nu0vJGlXLtOHd2v7tYiIiLSiZmWCmM1m5s6dS3Z2Nunp6WRkZJCdnc3cuXMxmxt/yIKCAp5//nmGDh2Kl5cXS5YsOWif6upq7rrrLuLi4ggJCeGUU05h+/btrtc3btzIySefXO+PzWYjJCTEte8bb7zBiSeeSExMTHM+dtuKqpkQA5DY09kXRHdlRESkc6murmbKlCk8+uijDBgwgIsvvpiBAwe6mqRWV1d7eolHPt8Q8DZuEB0Ta/x5/qVeZCIi0gE1KxOktpYEFJ544gny8vJ48sknOeWUU7Db7Qftc8899/DWW2/x2Wef0bNnT2666SZOOOEEkpOT8ff3Jy4ujptvvrne45tMJtf2Cy+8wG+//cabb77Z7PW2KWc5TI4R8BnbK4LPVqeSpAsSERHpZL788kuysrLYsmULERERrucfeOABEhMT+fLLLzn77LM9uMIOwGQyxuTm7WJUWAUAm9MLKSirItTf28OLExERcZ9GB0FmzpzZ6IN++OGHjdrvwQcfBGDfvn31vl5WVsbzzz/PY489xjHHHAPASy+9RGxsLJ988gmzZ88mLCyMk08+ucFz2O127r77bvLz83n77beblKniUc4xuQV7obKEcb2N5qir9+ZRZbXhbTlCPoeIiEgLbd68mRkzZtQJgIDRE2TGjBmaTOcuwbGQt4twWy49I8PZnVPKqt15HDso2tMrExERcZtG/0s6KCio0T/usmbNGkpLSzn22GNdz0VGRjJixAiWL1/eqGO89dZbPPXUU+zatYtTTz2Vk08+mW3btjW4f0VFBYWFhXV+PCIwEvyNwAc5O+jbJYjwAG/Kq2xsTPPQmkRERDwgOjqaNWvWHPS83W5n9erVHaY5qscFObJ7izNI7GUEnNQcVUREOppGZ4K8+uqrrbmOeu3fvx8wLn5q69KlC+np6Y06xrRp0/jiiy/qPHeoEp5HHnmEf//7301caSuJGgB7/4TsrZi6DmdMzwh+3JTBipRcRsaHeXp1IiIibeKss87iH//4B2eddRZXXnklXbt2Zf/+/bzyyits2LChTgN0aYFgY0IMRemM6xXB/JX7SNqlIIiIiHQsLe4J4glms7ne/iH16dGjBz169Gj0se+66y5uvfVW1++FhYXEx8c3eY1uEdXfCIJkJgOQ2CucHzdlkJSSy1WT+nhmTSIiIm0sMjKSJUuWcNNNN3HGGWdgs9kwm80ce+yxLFmyhMjISE8vsWNwZoIUpZM4ysgEWbevgPIqK37elkO8UURE5MjRroMgzoyNrKysOqmumZmZjBo1qlXO6evr235G7XUfB6vfhd2/A0ZzVIAVKXnY7fY6jV9FREQ6siFDhvDjjz9SUVFBeno6sbGx7ef7uqNwZoIUp9MrMoCoIF+yiytYuzefo/oo0CQiIh1Du+6uOWrUKPz9/euMzs3Ly2Pt2rWuRqkdWq+JxmPqCqgqY2hcCL5eZnJKKtmVXeLZtYmIiHiAr68vPXv2VACkNbgyQTIwmUyupuxJ6gsiIiIdSLvOBAkICOC6667joYceYvz48fTo0YO///3vxMTEcN5557XquefNm8e8efOwWq2tep5DiuhjXJAUZ0DqSnx7TWREfBh/7cplRUoefbq4rwmtiIhIezJ//nzmz5/fqH3PPfdczj333FZeUScQ3NV4LDb6riX2iuDb9en8lZLnwUWJiIi4l0czQd5++228vLzo1asXAMcddxxeXl7cf//9rn0ee+wxzj33XI477ji6du1KWloa33//PYGBga26tjlz5pCcnExSUlKrnueQTCboOcHYTvkNMPqCgO7KiIhIx+bj49PoqXQ+Pj6eXm7HENrdeCzLg5Js14SYVbvzsNoa14tNRESkvWtWJkhZWRnPPfccv/32G7m5B/9jfNmyZY06ziWXXMJFF1100PNmc01sxtvbm2eeeYZnnnmmOUs98vU8BjZ+BruXAXc6+oLs4Lft2dhsdsxm9QUREZGOZ8aMGcyYMcPTy+hc/EKMyXTZWyF1JYP7nUiwrxdFFdVs2l/I0LhQT69QRESkxZoVBLn++uv54YcfOPfccxk9enSzT24ymfDyatcVOZ7n7AuyNwmqKzm6TyTBfl6kFZTzV0ou49WoTERERNwlbowrCGIZcBKje4azZGsWf+3KVRBEREQ6hGZFIL744guWLVvGkCFD3L2edqNd9AQB6DIIAiKhNAfSVuPX4yhOG9aVD5P28vnqVAVBRERExH3ixsDaD2DfCgDG9Y5gydYsklJyuWJibw8vTkREpOWa1RMkICCA+Ph4d6+lXWkXPUHA6AvS42hje7fRF+TMUXEAfLN+P+VVHg7SiIiISMcRN8Z4TF0Jdjvjeht9QZJScrHb1RdERESOfM0KgkyfPp233nrL3WuRhjhLYhxBkHG9IugW6kdReTU/b8704MJERETEHebNm0dCQgKJiYmeXUjMULD4Qnk+5O5kePdQfLzMZBdXkpJT6tm1iYiIuEGzymHy8vK48cYbmT9/Pv369cNkqtuc89VXX3XL4sTBOSFmzx9grcZs8eKMUXG88MsOFqxO5dRhXT27PhEREWmROXPmMGfOHAoLCwkN9WDvDS8f6Doc9iVB6kp8I/sysnsYf6Xk8sfOHHpHte50PhERkdbWrCCI2WzmggsuAKCkpMStC5J6xAwB31CoKID0dRA3mrMdQZBftmSSV1JJeKDGA4qISMcxf/585s+f36h9zz33XM4999xWXlEnEjfWFQRh+Pkc0y+Sv1JyWbY9mwvH9fD06kRERFqkWUGQDz/80N3rkEMxW6Dn0bB1kVESEzea/jHBDOkWwsa0Qr5ev59Lxvf09CpFRETcxsfHh6CgoEbvK27k7AviaI46sV8Uz/y4jeXbs7HZ7JjNpkO8WUREpH3TfNoGtJvpME49jzGCICm/wTF/B+CsUXFsTCvk89WpCoKIiEiHMmPGDGbMmOHpZXRO3R1BkPR1UF3JiPgwAn0s5JVWkby/UKNyRUTkiNboIMjMmTMBIwvEud2QjpAp0m5qc516Opqj7lkONhuYzcwY0Y2Hv93Eyt157MkppUdkgGfXKCIiIke+8N7gHwFluZCxHu+4MYzvE8lPmzP5bXu2giAiInJEa3QQpHZKamPTU8WNuo4A70AoL4DMjRA7jOgQPyb0i2LptmwWrE7lpuP7e3qVIiIirWbLli1s2LCBvLy8Os+PHj2a0aNHe2hVHZDJZJTEbP8BUldB3Bgm9Ivip82ZLNuezbVT+np6hSIiIs3W6CBI7Ykvmv7iARYv6HEU7PjZKImJHQYYJTFLt2Xz+ZpUbjzu4Ek9IiIiHcHf//53XnjhBQICAjCbzVRUVFBeXk5ISAj//ve/FQRxN2cQZN8KGHc1E/tHAZCUkkt5lRU/b4uHFyj12psEW76FY+8Gi7enVyMi0i6ZPb0AaQLnqNzdv7meOmlILP7eFnZll7B2X4GHFiYiItJ6li5dyvz589mxYwe33norN998MyUlJbz66qsEBAQwe/ZsTy+x4+k+1nhMXQlA/+ggugT7Ul5lY9WevEO8UTzqi7/Bsqdg89eeXomISLvV7MaopaWl/PHHH+zZs4fq6uo6r1111VUtXpjUo5ejL8ju5WC3g8lEoK8XJw2J4fM1aSxYtY+R8WEeXaKIiIi7rVy5kvPOO4+ePXtiNpspLy/HbDZz5ZVX8tNPP/H5559zxRVXeHqZHUs3R2ZNzjYoy8PkH87EflEsWJ3Kb9uzOaZvlGfXJwfL3gbZW43t3F2eXYuISDvWrCDI2rVrmT59OsXFxeTn5xMTE0NGRgYAPXr06BBBkHY3HQag2yjw8oPSbMjaAtGDADhzVByfr0njq3X7uXd6At4WJfiIiEjHkZ+fT0REBABdunThjz/+cL3WtWtXMjMzPbW0jisw0miQmrcL0lZD32lMcARBlm3P4Y6TPL1AOcjmb2q2C/Z5bh0iIu1cs/61fOutt3LJJZe4GpOlp6eTkpLCxIkTO0QABIzpMMnJySQlJXl6KTW8fKF7orFdqyRmYr8oooJ8yS2p5OfNuhAUEZGOa+LEiXzxxRcsWLCAhQsX8u677zJkyBBPL6tjinOMynWUxEzoFwnA+n35FJRWeWpV0hAFQUREGqVZQZCVK1dy++23A2AymaisrKRnz5689tprvPLKK25doBygnr4gXhYz54yJA+DDv/Z4YlUiIiKtZvLkyUyePBmAYcOGcdtttzFr1ixmzJjBjBkzmD59uodX2EE5+4LsM4IgXUP96dslEJsdft+Z7cGFyUGKM2FfrRt3BXs9txYRkXauWUGQgoKCOmmpqampgFJS20TvScbj9p+gusL19MzEHgAs2ZpFWn6ZJ1YmIiLSKqZNm8a0adNcv993330UFRVRUlLCK6+8osloraV2JojdDsCk/l0AWLZdQZB2ZctCwA4BRraOMkFERBrW4uYREydO5L777uOPP/5g7ty5SkltbT2OhuBuUJ7v+MIz9I4KZHyfCGx2+HiFov8iItJxPPfcc1x//fX89ltNFqTZbMbHx8eDq+oEYoeB2QtKMl2ZBRP6GQ1Rf9ue48mVyYG2fGs8jr7UeKwohLJ8jy1HRKQ9a1YQ5J577nFtP/bYY2zcuJGjjz6ahQsXMm/ePLctTuphtsCImcb2mvfrvHThOCMb5OOkvVht9rZemYiISKsYNWoUmzdvZvLkyfTp04f77ruPLVu2eHpZHZ+3P8QMNbYdfUGO6hOBxWxiV3YJ+/JKPbg4cakohh2Lje1h5yobRETkMJoVBHnwwQdd2/369WP16tWUlZWRkpLC+PHj3bY4acDIi4zH7T9CUbrr6ZOGxBIW4E1aQTm/bsvy0OJERETca9KkSSxevJjdu3dz/fXX89VXXzFo0CASExN59tlnycrSd16rcZbE7FsBQIifNyO6hwKwXNkg7cOOn8FaAeG9IDoBQrsbz6sviIhIvZoVBBk2bNhBz/n5+bV4Me3JvHnzSEhIIDEx0dNLOVhUf+g+DuxWWPex62k/bwtnjVKDVBER6Zi6d+/OHXfcwZo1a9iwYQOTJk3i9ttvVxZqa3I2R01d5XpqoqMkRn1B2glnKczA08BkgtB443dlgoiI1KtZQZC9e/dSUFDg7rW0K+1yRG5tzmyQNe+7mpVBTUnMT5syySwq98TKREREWo3dbmfJkiU8++yzvPHGG/j6+tK3b19PL6vjcmaC7F8D1mqgdl+QbGwqv/UsazVsXWRsDzrVeHQGQfJ1Q0xEpD7NCoKcffbZvPzyy+5eizTF0LPByw+yNkHaatfTA2KCGd0jjGqbnfkrdQdAREQ6hnXr1nHnnXfSo0cPjj/+ePbu3cvzzz9PRkYGl1xyiaeX13FF9gffEKgqhfR1AIzqEY6/t4Wckkq2ZBR5eIGd3N4/oCwP/MMh3lGSHqZMEBGRQ/FqzpuKi4uZO3cuH330EQkJCQd1Z3/11Vfdsjg5BL9QGHw6rP8E1rwHcaNdL80c14NVe/L5KGkv103ui9ms0YEiInLkeuKJJ5g7dy7jxo3jjjvuYObMmURHR3t6WZ2D2Qw9J8DWhTD/cpj9JT7hPTmqTwS/bMnit+3ZDO4a4ulVdl6bHaUwA04Bi+Oy3tUTREEQEZH6NCsTxGw2c8EFF9CvXz8qKyspLi6u8yNtxFkSs34+VNWUvkwf3pVgXy9255Tyx041LRMRkSPbsccey9atW/nzzz+58cYbO2QApF33Ijv1caPpZl4KvHEq5Oxw9QX5cm0adrtKYjzCbofNXxvbzlIYUGNUEZHDaFYmyA033MDEiRPrfW3ZsmUtWpA0Qe8pEBIHhanGHZohZwEQ4OPFjJHdeO/PPXyQtJdjHBcqIiIiR6KxY8d6egmtbs6cOcyZM4fCwkJCQ0M9vZy6wnrA5QvhrRmQsw3eOJVzzv2EJ73NrNtXwJKtWUwd2PECU+1eZjLk7zbKo/tOq3k+1OgPR1E6VFeCl0/97xcR6aSalQkyadKkZr0mbma2wIiZxvaa9+u85GyQ+t2GdHJLKtt6ZSIiItKRhHSDy7+F6CFQnE74x2dy27AKAJ79aZuyQTzBWQrTZyr4BNY8HxhlBEawGzfKRESkjmYFQRqSn59PcHCwOw8phzPCURKz/Ucj4u8wNC6UoXEhVFptvP/nbg8tTkRERDqMoGi47GvoOhJKc7hyx42M8drF6j35/LZd5bdtbss3xuPAU+s+bzKpL4iIyCE0qRxm1qxZ9W4D2Gw2NmzYwPjx492zMmmcqH4QfxTs/RPWfQQTbnK9dMWE3tz68VqeX7yd00d0o2dk4CEOJCIiInIYARFw6Zfw3nmY9/7JqwHPM6HwIZ79aSsT+kViMqkZe5tY8YZjOqAJBp5y8Ouh3SFnu/qCiIjUo0mZIF5eXnh5edXZdv4EBgZywQUX8O6777bKQttau25QdiBng9TV7xlNshzOGhXHMX0jKa+ycddn65WqKiIiIi3nFwoXz4fQHoRX7uce7w9JSsnjj525nl5Z5/Dny/D1zcb2MX83MnQOFKoxuSIiDWlSJsibb74JQFRUFE8++WRrrKfdaNcNyg405CxY+A/I3gJJr8K4qwEwmUw8cvYwTnrmV5bvyOHjFXu5ILGHhxfbiVSWwje3QZ8pNb1bREREOgK/EDjjv/D2GVxs+Z6vrYk891MkR/eN9PTKOrbl/4Xv7zW2j7kRTri//v2cQZD8PW2zLhGRI0izeoJ09ADIEccvFKbeaWwvnAtbFrle6hkZyK0nDADgoW82kVlYXt8RpDVsmA9r3zf+TqzVnl6NiIiIe/WZCmOvAOBx75dZuzOVv3YpG6TV/PpkTQBk8h1GAKSh8iP1BBERaZBbG6OKB024GUZdAnYbzL8C0ta4XrpiQm+GxYVSWF7NP7/c6LEldjqbvjIeywuMni0iIiIdzQn3Q2gP4k1Z/MPrA/778zZPr6jjsdth8cPw8wPG78feA9PubTgAAhDmLIdRTxARkQMpCNJRmEww/WnjrkxVCbx/gSv672Ux89g5w/Eym1i4IZ1FG9IPfazmWPY0vHq87jg4lRfAzl9qft/2nceWIiIi0mp8g42yGGC21w9U71jCyt15Hl5UB7P5a1jymLF9/L9hytzDv6d2Joh6wrWKskorKdklnl6GiDSDgiAdicUbzn8bohOgOB3eOx/KCwFI6BbCtVP6APB/X2ygoKzKfectzYXFj8C+JPj2Dvcd90i27QewVoLJ8T+xrQqCiIhIB1W7LMbrZR7/cgWLNuwnq6ji0O+zVukf6I2x61fjcfRsmHhz494TEgeYoLocSjW+uDX8/YNVTH3yF7ZlFHl6KSLSRAqCdDR+oXDRxxAUA5kb4ZNLjYsM4O/T+tOnSyCZRRU88u0m951z9btgdVzobPkWNn/jvmMfqTZ9aTyOvQJMFsjaDLm7PLsmERGR1nLC/VQHdyfenMV5mc9xy7vLSXzoR6Y+sZjbP1nLl2vTaqbUFWfB17fCgzGw6C7PrvtIkLXFeOw+rvHv8fI1rgVBzVFbyYZU40bjFgVBRI44CoJ0RGHxcNFH4B0AO36G106AtNX4eVt47JzhAHyYtJflO7Jbfi6bDVa8bmxHJxiP386FiuKWH/tIVVVmZIIAjJoFPY8xtrd977k1iYiItCbfYLzO+h8A51p+5Q//m7jFaz6FOenMX7mPGz9Yzeu/bIJlz8B/R8OK18Buhb9egqytnl17e5ft+PPpMrBp7wvTmNzWYrPZyS42bgDmFFd6eDUi0lQKgnRU3UYZpTG+IZC2Gl6ZBt/eQWKshVnjjTG5d3+2nvIqa8vOs/NnyNsFvqFw6dcQ1gMK98GSR93wIY5QO36GqlJjPF3XkTDgJOP5rYsO+TYREZEjWp8pcParEN6LUHsRN3l9RlLgTXwY9zHnWX7hpF9mwI//hIpC4/sxfrzR0N3Z76Kl7Hb45nb48GLjhkRHUF4IRfuN7agBTXuvqy+ImqO6W25pJdU2I7Mpp/gwZV8i0u4oCNKR9T8BbkiCoecaFxl/vQzPJ3J3j43EBvuSklPKsz+1sIt70mvG48iLIDASTv2P8fvv/4P0DS079pHKORVm8OlGw9oBJxu/pyyDCqVMiohIBzb8PPj7KjjvTeg2Gou1gvE5n/OE98t0N2VR4N0FznoJrl4Mpz5hvGfDp5DphjLdpFch6RWjkejy/7b8eO1BtuM6LSgG/MOa9l6NyW01GYXlru3sEmWCiBxpFATp6IJj4dzX4JLPIbIfFGcQ8OW1fBH9It5U8/KvO9mYVtC8Y+fvrclucDREY8CJMHiGkeL69S1GuUxnYq0y+qKAEQQB4889oo/RKLX2xBgREZGOyGyBIWfB1T8bWaL9T6TKN4Knqs7l6OLHSe5yKpjN0HW4cc2AHX5pYQZp1hb4/t6a35c+ZVynHOmyHf1AmpoFAhBqZP6qJ4j7ZdZq+qtMEJEjj4IgDZg3bx4JCQkkJiZ6einu0fdYuH65MVve4ktM6g98HPUq2Kq589N1VFubEaxY+aaRYdJ7MnSp9eV8ymPgEwT7/oJVb7ntIxwRUpYa43EDu0D8UcZztbNBNCVGREQ6C5MJek+Ciz/B+65d7Bgyh1K7Lw98nVzTJHXqP4zH5M8hY2PzzlNdCZ9eZUxC6XMs9JwA1WXww31u+RhNkVFYztq9+e47oLMpalP7gYAyQVpRVmHtIIgyQUSONAqCNGDOnDkkJyeTlJTk6aW4j5evMVv+wvfB4sOo4l95zu8lklPzef23Jk4uqa6EVW8b22OvrPtaSDeY5rgb8+M/jS7wnYWzFGbQacadMKf+JxqP277vfNkxIiIiwD9OHoSPl5nfd+bwQ3KG8WTMECNrBOCXR5p34MUPQfo68I+AM18wbsaYzLBxAexa6p7FN9I176zkrP/9xlZ3TQxxNkWNakYQxNUYtQNkxLQzmUU15TC5KocROeIoCNIZ9TseznsLzF6cxjIe8nqNp3/YzO6cksYfY/NXUJIJQbHGP/gPlHg1xA43siLc1fCsvbNZYdPXxrazFMap5wQjO6Y4A/avafOliYiIeFp8RABXT+oNwEPfbqKi2tGcfco/AJNxI2H/2qYdNGUZ/PassT3jOQjpCrHDYMzlxnML7wRrtXs+wGHkl1aydm8+Njus2ZPvnoO6MkGaUw7jyAQpzYHKUvesRwDIqJUJkn1gOUx1hdGkV0TaLQVBOqtBp8LZr2A3mbnQazFz7W9x92frsNka+X/aSY6xuGMuBYv3wa9bvOD4fxnb6z8xMkc6un1JRmDINxR6Ta77mpcP9J1mbKskRkREOqnrp/ajS7Avu3NKeXv5buPJ6EEw7Fxjuym9Qcry4bNrATuMuqTuDYhp94JfGGRuhJVvuGn1h7a6VuBjW6YbMkGqK4wJfNC8TBC/MPAJNrYLU1u+HnGpnQlSWF5NZbUjy3frd/BgDPzxgodWJiKNoSBIZzb0bExn/A87Ji73+o4pu//LrR+uqLkz05DMTbB7GZgsMPrShvfrM9XIFCnPh+0/uHPl7ZOzFGbgyUbQ40CuviAalSsiIp1TkK8Xd5xk/IP+uZ+21TSVnHKnUcKy5VtIW13nPUXlVazfd0ATd2s1fHMrFO6D8N5w8gHBk4CImtLcnx+E0tzW+Dh1rNqT59rellnc8gPm7DB6r/mGGI3um8pkqskGUXNUt6rdGBVqlcT89ixghxWvt/2iRKTRFATp7EZeiGn60wBc4/UNt2+ZyQfP3UtB4SEmxjjH4g46FULjGt7PbKm5s7PuYzctuJ2y22HTl8b2gaUwTv1PAExGOUxRelutTEREpF05d3R3hnQLoaiimiveTGLx5kzskf1g2PnGDovugu0/UZqfyf9+2c6kxxdz+vPL+CRpN6T8Bt/cBk8NMkbrmixwzqvgG3TwicZcDjFDjZsxPz/Y6p+rThAkww1BkNqTYUym5h1DzVFbRWZh3SBIdnEF5O6E3b8ZT+RsM4JYItIuKQgiMPZyOGMelX6RdDdlc1nh/7A/PZSi7x4y7pwU7octC40U1Q8uhNXvON535aGPCzDsPONx6yKjP0hHlb7OuMvi5Q99j6t/n6BoiBtjbG/7vu3WJiIi0o6YzSbuP2Movl5m1u4r4PI3kzj5maUsipqN3WSBPb/Du2cT8Ex/Tv/5ZB6qeoIHvV5j2sJj4c1TIelVKMkC/3CY/jR0H1v/iSxeRpNUMEpi0te32mey2ux1+oCk5pdRUtHCXiRZjqaozZkM46TmqG5nt9vJcmSChPh5AZBTUglr3q+745aFbb00EWkkBUHEMGoWPrdtJG3iQ+wjhjB7IcG/P479ib7G3ZYPZhpd27d8a4ygix0Ovacc/rhdRxh1rNXlNeUiHZHzs/U/HnwCGt5vwEnGo/qCiIhIJzamZziLb5/K1ZN6E+hjYUtGEdd9m89NXvfynXkSO21G+Ue8OYvTLH8xy+snIm05WH1CYOTFcPGncPs2ozfZofSaCINnGGUlzql2rWBrRhEllVYCfSxEBBolsTuyWpgNUjsTpLmUCeJ2+aVVVFqNHiCDYkMAyCkqhTUfGDv0ONp4VPmzSLulIIjU8Pan2/E3wN9X8KD/7STbemKy27CbzBCdACMuNGpuL18EV/4A5pr/fJZvz+a/P22jvOqAfiImEwx3ZIN05JIY12jcBkphnJxBkB2Loar80PuKiIh0YN3C/LnntASW33Ucc08eSJdgX74sGsi1pddzsf//mH/Cb1Rf8iWccD8/hJzNlZW38dSIb+DM/xk3HeprzF6f4Y4ymx0/t9pncZbCjOwRxoAYozSnxSUx7sgECe1hPOYrE8RdMhxNUcMDvOka5geA/97fjP40fqFwumNa0e7lUJbX0GFExIO8PL0AaX+6R4bw97//g6vfOo79ezZT6duF9887lr5d6qm3BX7bns2lr/9Ftc1OSaWVf5wyqO4Ow84zanF3/WqU1oR0bYNP0Yayt0PWZjB71QQ5GhI73GgWW5wOqSuMO1QiIiKdWKi/N3+b2o8rJ/Zm0YZ0rDY7pw7rip+3xdih7xSsoen89O5KNqzN5NZT7FjMTeiR0Xuy0TskZzvk7Ybwnm7/DKt25wMwukc4+aVV/LEzt2XNUW1Wo68EuCkTREEQd3H2A4kO9iMy0BeAHnsXGC8OO88IWnUZDFmbYNuPNTcDRaTdUCaI1Cs0wJu3rzqKqPiBZJSbufyNpJoO7rVsTi/kundWUu0Yrfvq0p1sTi+su1N4L4gfD9hhw/zWX3xb2+zIAuk9GfzDDr2vyQQ9jjK29/7VqssSERE5kvh6WThjZBxnj+5eEwBxmDYomvAAbzIKK1i2PbtpB/YLhfhxxvaOn9y02rpWOzJBRvcIp78jE2R7S8bk5u8xSoktvsZ1VHM5e4IUphqBFWkx52SY6BBfIoN8CKGEAbm/GC+OvNh4HOicCKi+ICLtkYIg0iA/bwuvzB5LfIQ/e3JLuertFXXKXdILyrn8jSSKKqoZ1yuC4wfHUG2zc/dn67E5giIuzlTUjlgS4yqFmd64/bs7LsT2rWid9YiIiHQwPl5mZozoBsD8lc3ob9F3mvHYCiUxeSWV7MwuAWBkfBj9oh3lMC3JBMl2lMJE9jOm7TVXUKyRBWOrhuKM5h9HXDIKjXKY6GA/ooJ8ON3yO972SqN0vNsoY6cBpxiP234Ea5WHVioiDVEQRA4pKsiXNy4bR6i/N6v35HPrx2uw2ewUlVdx+ZtJ7C8op2+XQF6ePYYHzhxCoI+FVXvy+TDpgLTLIWcZ5SLp6yBzs2c+TGsoTIPUlYAJBp3WuPc470bt+8sYrSsiIiKHde4YI6vh+43pFJQ18R+WzsltO38Fawunthxg9V4jC6RPVCDhgT70jw4GYE9u6cG90hory9EUtUsLSmHAmJATYgSP1BzVPbJqZYJEBPpynmWJ8cLIi2tGGXcfCwFRUFFg9AYRkXZFQRA5rH7RQbx0yRi8LSa+XZ/Ow99u4m/vrWLT/kKignx58/JxhAX40DXUn9tONJp3Pbpwk+tLAoCACOh3grG9vgNlg2z+xniMHwfBsY17T9cRYPExxvvlpbTa0kRERDqSoXEhDIgJoqLaxjfr9jftzd1GGiN1KwqMnlxutNoxGndUj3AAooJ8CAvwxm5vwYQYd0yGcQp1lMTk72n5sYRMR2PUmGBf4qp2M9K8g2osMPyCmp3MlloTATUlRqS9URBEGmV8n0geP3c4AK8u28XSbdn4e1t4/bKxxEfUjIS99JheDI0LobC8mge/Sa57EGdJzPpPwGZrq6W3rqaWwgB4+RoNUgH2Jbl/TSIiIh2QyWTi3DFGo89PVzUxq8FsgT5TjW03l8Q4J8OM7hkGGOvsH+3sC9LMIIhzMoxbgiAak+tOrsaoIX50T/kMgF/soyCoS90dBzj6gmxZqMxfkXZGQRBptLNGdefWE4wvY7MJnr9oFMO7h9XZx2I28fBZwzCb4Is1aSzdllXz4sBTwCfYuBOx9882XHkrKc2FlGXG9uAmBEGgpiRGzVFFRDqc7OxsrrrqKkaOHMmVV15JTk6Op5fUYZw5Mg6zCVbuzmNnU7MsnCUx293XHNVqs7PGkQky2pEJAtDPURLTrDG5dntNJkhLxuM6OZujakKMWzhH5MYEmgna+ikAH1VNprTygDKrvtOMzN+8XTU9XkSkXVAQpAHz5s0jISGBxMRETy+lXfn7tH48fcEI3rtqPMcNjql3n+Hdw5h9dC8A7v18Q009rLc/JMwwtjtCSczWRWC3QsxQiOjTtPd2d/x3tU9BEBGRjuaRRx5h8uTJvP3221RXV3PXXXd5ekkdRnSIH5MHGHfcP1uV2rQ3O5ujpq0ybmS4wdaMIkoqrQT5ejEgJtj1fH9Xc9RmTIgpyYLyAsBkNEZtqbAexmPuzpYfq5Oz2+2uTJAeub9jLskk2x7KYttIcoor6+7sG2RMDgTY8m0br1REDkVBkAbMmTOH5ORkkpJUrlCbyWTirFHdObpv5CH3u+3EAcSE+LI7p5SXltT60h3mmJW+4VMoy2+9hR5CaWU1xRVuaIq26WvjsSmlME7OTJD0DVBZ0vK1iIhIk+zfv5/09PQGX7fZbKSnp1NWVtbkYz/++OPMnj2b4cOHc/TRR1Nd7d5GnJ2dsyTms1X7Dp5GdyihcdBlENhtsPMXt6zFWQozIj4Ui9nket45JrdZE2KcTVHDexo3kFoqZqjxmL5eZRktVFheTUW1UdIdsX0+AD94TaEaL7KLKw5+g6skRn1BRNoTBUGkVQT7eXP3qYMBeHP5LsoqHdkgvScbFyDlBfDrE22+rpW785j02GKmPvFLzZqao7IEdjjSaZtaCgNGfW5wNyOTJG1189chIiKNZrPZePfdd5kwYQI9e/Zk5syZ9e73xRdf0L17dwYOHEhYWBjXX399nUDGpZdeSr9+/Q76efrppwGwWCzcfvvtxMfH89hjj3H//fe3yefrLI4fHEOInxdpBeX8vrOJpUbOkhg39QVZtTsfqFsKA7gmxOzOKaWiuvHXGzuzitmw1nEDLsoNpTBgjG41mY0Mk6KGA39yeJmO8bghfl5Y0tcBsC5oAsDBmSBQEwTZ9xeUqCxOpL1QEERazfTh3YiP8CevtKqmgZnZAic+ZGz/+RLk7Giz9Xyzbj8XvvIHOSWVZBdXuO7eNMv2H6G6HMJ61txhaap4R0mM+oKIiLSJgoICFi1axKOPPsrs2bPr3Wfbtm2cf/753HnnneTn57N27Vo+/fRTHn74Ydc+jzzyCIsWLTro59JLL3Xtc8cdd7Bo0SIuuugibrjhhlb/bJ2Jn7eF00cYY18fWbiJpJQmlLb0c5TE7PjZLVkRq51NUQ8IgsSE+BLs64XVZiclu7TRx5s7fx1JK/4wfmnpeFwnnwCI7G9sp693zzE7qUzneNxgXygyJhRVBRn/LeaU1JMJEhYPMcOM7KNt37fZOkXk0BQEkVZjMZu4/JjeALy+bFdNymr/46Hf8WCrgh/+r9XXYbfbeXHJDua8v4rKahu+XsZ/9n/takE9sLMUZvDpNTPhm8rVF8S9o/rkMGw2o+u+UoJFOp3w8HDeffddJk2a1OA+r776Kl27duWmm27CZDIxaNAgrrnmGl544QXsjv/f6NatW72ZIBEREQD897//JTw8nCFDhjBlyhR27Gg44F9RUUFhYWGdHzm8S47uiZ+3mQ2phZz34u+c/+LvLN6S6fo7alCPY8DiC4WpNWUnzZRXUsnObKOkdVSPsDqvmUwm+sU0rS+I3W4neX8h/UyOXifuygQB6OqYSpe+1n3H7ISc43H7BZWD1cj8sIQYQZDs+jJBwBgMALB1YauvT0QaR0EQaVXnJ8YT7OfFzuwSft6cWfPCiQ+ByQKbv4Zdv7ba+autNu75fAOPLtwMwGXH9HKV6TTpzlGdg1bC1u+M7cGnN39x3R19Qfb9pX+Qt6Xv74F5ibB+vqdXIiLtUFJSEsccc0yd5yZOnEh6ejr79jVuxKjJZKJbt27ExcVx5ZVX8uSTTza47yOPPEJoaKjrJz4+vkXr7ywGxYbw3c2TuXBcD3wsZv5KyeXyN5I47bllfLU2jWqrrf43+gRAT8ffbwtLYlbvNbJA+nQJJCzA56DXXc1RGzkhJrOogtJKK/3MacYT7pgM4xQ7zHhUJkiLZDiaovb1cwS2ArsQFhIINFAOAzDQURKz/WewtaAUW0TcRkEQaVVBvl5cNM7oSv7qsloNUqMHwdgrjO3v7m6VL4XyKitXvrWC9//cg8kE/zc9gX/NGML4PkZT19V78qlq6CLpUFKWQkUBBEbXBDKao+sIMHsbNbp5Kc0/jjRe/h746xVje9t3nl2LiLRLWVlZREbWbf4dFRXleq0xbrjhBlJTU1m5ciV79uzhpJNOanDfu+66i4KCAtfP3r0aY9pYPSMDeeTsYSy981iuntSbAB8LyfsL+fsHq5n8+GJeWrKDgtKqg9/onBKzo2WjchvqB+Lk7AuyvZHNUXdmlRBEKV1Nxk2a8jA3TIZxinVkguxf575jdkLOyTA9vQuMJ4K7EhXoC0BufeUwAF1Hgk8QVBZB1uY2WKWIHI6CINLqLpvQCy+ziT925rIhtaDmhal3gW+ocVdizftuP+//Fm9nydYs/LzNvDhrDFdMNEpz+kcHEervTVmVlY1pzUg73vSV8TjoVDC34H9C3n5GIARgn6YQtYml/zHKsABSV3l2LSLSLpnN5oOmuVRVGf+/YbFYGn0cX19fYmNjMR2mZNLX15eQkJA6P9I0MSF+3HNaAr/dOY2bjutPRKAPaQXlPLJwM+Mf+Yn7Pt/AjqxagYh+juaoKb9BVXmzz7uqvn4gPz8Ir50I5QVNLodJySmhr8nIAsm0h7Euu9lLO5gzCJK3yzF+V5rDWQ7TzezoKxfSjcggIwsop6SBTBCzBbqNMrZVAi3SLigIIq2ua6g/pw3vCsCrS2tlgwRGwpS5xvbPD0BF4y4SGiOzsJxXlu4C4D/njeSkIbGu18xmE4m9jAuWpKb2BcnfAxsXGNstKYVxco7KVXPU1pe3G1a/W/N77g6PjWkWkfare/fuB43Odf4eFxfniSVJI4UH+nDLCQNY/o9pPH7OcAbFBlNWZeWdP3Zz/FNL+MzZpD06AYJioboM9vzerHNZbXbW7s0HYHTPMOPJkmxY9jTs/RO2LHKVw+zKLmlU5mlKdgn9HEGQ7bZuzS/brU9gJIQ4/vvN2Oi+43YyzsaoXXD83QR3JTLIyARpsCcIQNwY4zFVQRCR9kBBEGkTV03sA8DX6/azv6Cs5oVx10BEHyjOMC4c3OSZn7ZRVmVlVI8wTh0We9Drib2M5nV/NeUCoywf3jsPyvON2treU1q+UFdzVAVBWt3SJ8FWDX2mGlN9QOOJReQgU6dO5ZdffqGysuYfNIsWLSIhIcFVFiPtm5+3hfMT41l40yTev+ooJg/ogt0O9yzYYJSmmEwtLonZkFpASaWVIF8vV9kLGxcY3zMAKUvpFupPgI+FKqud3TmHnxCzM7uEfmajKep2e5x7gyCgkhg3cI7IDa92lMaFdCMy0JEJUtxAOQxA97HGo7JQRdoFBUGkTQzrHspRvSOottl5c3lKzQtePnDCA8b28ueNu/UttCOrmI+SjJrqu04ZXG8q8lhHEGRFSm7N1JpDqa6Ej2cbtZzBXeHCj8Di3eK1ujJB0jdAZUnLjyf1y0upKbmaeletOzIrPbYkEfGMffv2kZKSQnFxMeXl5aSkpJCSkuJ6/eqrryYgIIBLLrmElStX8tJLL/H666/zz3/+03OLlmYxmUwc0y+KNy9LZGK/KMqqrNz4wWoqqq01JTFr3oeM5CYf+4s1RsbGlAFdsJgd1xnrPqrZIWUpZrOJfo5skO2NKIkxMkGcQZBurNydh7Ux1yiN5ZoQo+aozeXMBAmurBUEcZTD5JZUNnxNGecIgmQmQ0XjesSISOtREETazNWTjGyQ9//cQ3FFrXrrQadBr0lgrYCFd7Z4UsrjizZjtdk5fnAM43pH1LvPsLhQ/LzN5JVW1a0Tro/dDl/fAruWGI2tLvoYQt2UEh0SZwRV7FZlJbSmX51ZIMdCj/EQN9p4Xn/mIp3OzJkzmTp1Kn/88Qfp6elMnTqVqVOnul4PCwtjyZIlAFx00UW88847vPPOO5x//vmtuq558+aRkJBAYmJiq56nMzKbTTx1/ggiAn1I3l/IYwu3GNcescOhNAfemn7oEpHN38Inl7lG6lZbbXy51giCnDXKcT2Qs8Po72UyG9Pv8lIgf68rCHK4CTFWm52eeb8xzWx8L2239KOovJqtGe4rFa6ZEKMxuc1RXFFNaaXRyN+3LMN4MrgrEY5MkGqbncLyehrxAoR0Na757DbYv6YNVisih6IgiLSZaYOi6RMVSFF5NZ+sqNX93mSCU580JqVsXQibv2n2OVak5PLdxgzMJrjz5IZHy/l4mRkZHwZAUkreoQ+69ElY865xYXPuGzV3UtzBZKopiVFfkNaRu6tuFghAN0cQRGmpIp3OsmXLXNkftX9q69evHx999BFbtmxh2bJlzJw5s9XXNWfOHJKTk0lKUqPs1hAd4seT5xnf36//tovFO4pg9hfG5I7SHHhz+sEZEuWF8MUc+PBCo9Tlq5vAbmfp9myyiyuICPRhysAuxr7rPzEe+06DbiON7d2/uUplth1mQkzmznU8ZX4Oi8mObdQlWHoYmaJuLYlxlsNkbjYyXKVJMhylMEG+XpiL9htPhnTD18tCsJ8XcLi+IM5rD2WhiniagiDSZsxmk2tCy4tLdpCSXav8I3oQTLjR2F44t1lNUu12O48sNEaPnT82nv4xwYfcf5yjJOaQFxjrPjE6vQOc+gQMOLHJ6zosZ0nMEdIxvLzKypZ0N96Zam1LnzQybfpOgx5HGc91HWEEtYrSoCj90O8XEZEOYdqgGC47phcAt3+ylszqAJj9uREYL8uFt06H/Y4sid3L4cUJjobaJjB7GU1Udy1hwSqjZOX04V3xtpiNjFFnKczwC6DXRGM7ZSkDXBNiDhEEKcsj9IvZhJjKWG9JwHzaUyT2NsY0H/ZGTVOE9QC/UGNKmka1NplzPG58MEZ/ODCyeYGoIOeY3EMFQRwlMUfI9Z5IR6YgiLSpc0Z3p1dkABmFFZz9wnJW76n15T7pdqNhZWEq/PJok4/9fXIGK3fn4edt5pYTBhx2/0RHqcxfDU2ISV8PX/zN2D76Bki8qslrapTuziDIXy0uBWptVVYbM1/+g5Oe+ZWVu93csK015O6ENR8Y21PvrnneNwi6DDK2lQ0iItJp/OOUQQzuGkJOSSW3frwWm28YXLLA+AdqWR68NQO+uhneONWYCBfWAy7/1nUNYP35Eb5PNrIAzhrd3Tho6krj+8Y7sKbEFyBlmSsTZEdWcf39PazV8MnlBBSlkGqP5PW4+8HLh7G1ptjZ3XVtYDLVZIOkqzlqUznH4w4McNwI8g4wgkrQxOaoygQR8TQFQaRN+ftY+Pi6oxkaF0JuSSUXvvIHPyQ76ip9AuC0p4ztP15gX/IfvLp0J3tzD99Rvdpq47FFxl2Nqyb2ISbE77DvGdUjHIvZRGp+GWn5ZXVftNuN/iTWShhwck3z1tbQdYRRClSSZdQQt2PP/7ydNY6RgL/vyPHsYhrj1/8YWSD9jof4A+rsnSUxaQqCiIh0Fn7eFv574Uj8vM0s257Ni7/uAP8wuOQzozy1PB9WvgHYYdQsuO436HkMTLgZLL5Y9v3BKOsG+kQFMqK78Q9gVxbIoNPAJxDij3L1BYkzZ+Pnbaay2lb/9cwP/wc7F1Np9uPqytuIijF6jIyKD8fLbCK9sJx9eWUHv6+5YtUctbmcmSB9fAuNJ4K7GoElcDVHzT5UJkjXkUYWamEqFO5vzaWKyGEoCCJtLjrYj4+uOZopA7pQXmXj2ndW8O4fxlSYyt7TSIs7GexWsj6cw8PfbGTWa39SUruRaj0+SNrLzqwSIgJ9uHZKn0atI8jXi4SuIUA9JTHJX8Du38DL39GvpBX/p+LtZwRCwGiq1k6t2ZvP84u3u37ftL+dl8RUlcH6j43tKXce/HrcKONRd2RERDqVftHB/PP0IQA8vmiL0afMLxRmfWaUTobEwcz34Yx54GdcJxDSFcZcBsDNXp9y1shuxvQ5axVs+NTYZ/gFxqNfiKsviGXPcvp2aaAkZtU78Mc8AF6OmEuyvRe9ogIB46bR0DgjyLLCnZmXzuaoGpPbZM5MkB5eBcYTId1cr0U6ymEOmQniGwRdBhvbuvYQ8SgFQcQjAn29ePXSsVwwNh6bHe79fANXv72CYx79iTN3nE6R3Z9R5u1c5vsLu3NK+fdXDXdt37S/kIe/2QTA36f1I9iv8aNrE+vrC1JVDj/cZ2xPuBHC4pv+AZuqx3jjccvC1j9XM5RVWrn1ozVYbXZ6Oy7QNu0v9PCqDiNttZHJExhd03y2tm61JsS08zIkEen4NB2mbc1MjOeKCUafsjs/XcdXa9OM4MUlC+CWjUZWxwEyRlxHhd2Lo8ybuaBLivHkjp+NxqqBXaDP1Jqda/UF6e+cEFN7TG5eCnxzq7E95R98Wm6Mbnd+xwIkOkti3NkXpPaYXJvNfcftBJzjcbuaHX8ftYMgrnKYwzSc7W78PZOqviAinqQgiHiMt8XMo+cM45bjjf4dPyRnGF21g2NJ6mP04rjb5yO6mPL5eMU+Fq4/OHWwoLSKa99ZSVmVlcn9Iph9dK8mrWFcb2fNba0LjN+fN+qAg7vBhJua9+Gaarhj9OLmr6Eku23O2QSPLtzEzuwSYkJ8eWW28QW+K6eE0spDZ+h41J4/jMce413pqnXEDAWLj1EDnrerbdcmInIATYdpWyaTifumD+bCccbNmFs+WsOPzvLc+r4zgAXb7XxgnQZA9Kpn6jZEHXouWLxqdq7VF2RArNEXZP2+gprXf59nBOp7TaJq0h3scZTK1A6CjHXcqFnhzgkxUQPA4guVRZCf4r7jdgLO6TBRdkc5sKMpKtQKgpQcIhME1BxVpJ1QEEQ8ymQycdPx/Xl25khOH9GNF2eN5rd/TGPaJfdA15F4VRXxVfiz9DWl8o/P1pNeUO56r9Vm56aPVlOem8o7AU/zZtb5WLYtatL5nRcYWzKKyC+tNGo0lzr6kpzwb6O2ty10HQHdRhkXRGs/aJtzNtLSbVm89btRrvTEuSPoFx1MVJAPdjtszTj0yD+Pqh0EqY+XT01asJqjioh0OiaTiQfPHMaZI7tRbbPzt/dXsWxb/Tci7HY7C1al8mL16VjN3kbJ7JaFsPlbYwfnzQynHuNdfUEmRBk9PZJSHE1OS3KMUhiAybezL78Cq82On7eZmOCanmZjexo3arZmFJN3qF4TTWHxhmhHSYZKYprEmQkSVu34b6SecphDjsgFiHNkgqStAZvV3UsUkUZSEETahTNGxvHfC0dx8lDHuDmzBc54HvzDiS3dwre+93BG5dfc/vEqbI7u6s/8sIXwbZ/xg+9cJtmSMFcUwvwrjC+WRooK8qVPFyPQsSIlD376N1SVQPdxFPQ7k2d/3MbizZmt8ZEP5qg1ZuWb7aY8o6C0ijs+MS6SZh/dk8kDugAw2NFLpd2WxNhssPdPYzu+gSAI1C2JERGRTsdiNvHkeSM4aUgMldU2rn57xcF9woDk/YVsySgi16sL1SNnG09+dg1Ul0Fkf+NGRm2+wa7nEirX4+tlJru4kh1ZJZD0qvG+2OHQewop2SUA9IoMxGyuyUKJDPKlr+MaZeXuViqJOQKk5Zdx2Rt/8eZvns3azHI0Rg2scGQM1c4ECWrEdBgwAlDegUYmTvbWVlmniBxepwiCbN68mdtvv525c+eyadMmTy9HGit2GFz/O/Sdhi+V3O/9FtfsmcsHP/3J4hXrGL7sep72eYFQU4lxodFrElSVwgczoSC10adJ7Glkg+zbsNSVhbF51D2c+twynv5xK5e/mcQ1b68g9cAJMu429BzwCYKc7cYdpnbg/77cQHphOX2iArnrlMGu59tzEMRut7MteSWU51OODzO/KqG8qoG7LXGOIIgalImIdFpeFjPPXTiKKQO6UFZl5ZLX/uT+r5LrTI5bsMq4rjh+cDS+U24zyikrHT0+hl9QfwmNoy+I997fGNUjDICV21Phr5eM1yfcBCYTOx1BkNqlME6u3mVubY565IzJzSmuYNZrf/LLliweW7TlsI3yW0tpZTVFjnP7lDqCICFxrtejHJkguYfL2DFbagJmKokR8ZgOHwTZs2cPl19+Od27d8fPz4/JkyeTm+vGLxJpXSFdjW7tpz5JtdmXyZb1nLbsbEZ/dTInWFZhNXnBtPvgyh9h5ntG1+2i/fDBBVBRT6lGVZlxB+bHf8Hq92DfCo7u7gPYGb/1SQC2xEzntE9LSc0vIybEFy+zie+TMzj+P0t4+dcdVFlbqZGYbzAMO9fYXvlm65yjCbZnFvHFmjQsZhNPXTASfx+L67XBXY365vYUBFm/r4CHvklm8hOLee2DDwFYbe3HH7uLGs7mcWaC7F8L1hZeWFVXtJsMHhERaRpfLwsvzhrDpP5RlFfZeP23XUx+fDG3fryGTfsL+WJtGgBnjeoOoXEwenbNm53f3Qeq1RfkqN6RAJjWfmA0Ug3rAQlnGi8fIgjiLNtN2tUKQZB2Xg5TWF7F7Nf/YmeW8edTVmXlB2ffljbmHI8b6G3CVOwMghzcEySvtIrqw10nNrU5qt0OPz8Ivz7RpDWLSMO8Dr/LkS0iIoJffvkFX18jQrtgwQLS0tKIiIjw8Mqk0UwmGHc1lt6TSXn1EnpVbAFgp1c/4q94E0s3R18HSyhc9BG8epyR4vnplcaIO7PFGGG3+h1Y8gQUpdU5/JnARN8QoqoLKTf5ccnuU7Bi5/QR3Xj4rKHsLyjnngXrSUrJ4+FvN/PZqlQeOmsYYxy1um415jIjAJL8BZzyOAR47r/TRRvSAZjcP4qR8WF1XnNmgmzeX4TdbjfGBHrQ56tTufmjNa7fj/LZBkB2xEjIgG/W7+eUYV0PfmNUfyP7prIYsrdAzJDmLSAvBV6ZBj2PgQvebd4xRETEo/x9LLx9xTh+3ZbNi7/s4PedOXy2KpXPHFkg4QHeTHGUhTLpNtj6PcSPg4je9R+wx1GuviCTosv5LzaOznD0/Tr6Blcj1ZQcRzlMPUGQcY4gyPrUAsqrrPh5Ww7ap8lihgAmKE6H4kwIim75Md2srNLKlW8msTGtkKggHyb378Jnq1NZsDqVM0fFHf4AbubsBzIwqAxTmRVMZmP6nENYgA9mE9jskFtaSXSt3i4HcfYFaWwWamZyTQBk1GwIjmnORxCRWjyaCVJZWcmHH37I1KlTiY2NZfny5QftY7fb+c9//sOIESPo06cPl1xyCWlpNf+I3bp1K7Nmzar3x2azERQURH5+PrNmzWLChAmccMIJDB06tC0/priJqctAgv/2M/N8r2Se79WE/H0J3s4AiFN4T7jwQ/Dyg62LYNFdsO4TeD4Rvr7FCICEdDeCDb0mQZDxRRJlMjIanqs8g0LvSB4/ZzjPzRxJsJ83A2KC+eiao3n83OGEB3izOb2IC1763b3d2p26jTKapLaDBqnfbTTudJw0JPag1/p2CcLbYqKoopp9ea1cJnQYm/YX8o/PjLtZxw2K5sVZozkjci8AQ446EYCfNmVSVllPSUzttNSWNEf97Tnjzt6WRVDtpuZ1ItKpaERu+2AymZgyoAsfXDOeL+ZM4JShsa5KlzNGxuHj5bh0DukGt6yHc19r+GC1+oIMr17PaV4riCcdq184jJrl2s2Z6VBfJkh8hD/Rwb5UWe2s3Zvvls+IbxBE9jW222FJTGW1jevfW0lSSh7Bfl68fcVR/P24/oDRrD2r6DB9N1pBZpHRmH9AgCPLOCimzjQgi9lEeEAjx+Q6J8RkJENl6eFPvu2Hmu39axq7ZBE5BI8GQe655x4WLFjANddcQ0ZGBpWVB/+fxkMPPcSDDz7IAw88wIIFC0hPT+eEE06gqqoKgPDwcE4++eR6f5x3pwMDAzn55JM57bTT+Pbbb0lJSWnLjyluFBkaxLVzn+S6O58gKjSo/p26j4WzHPW2f70En11ljEAN7AInPwY3roLTn4XLvobbt8Kdu3m21/+YXXkni6Mu4qsbJnJ+Ynyd7Aaz2cT5Y+P56bapHDcommqbnTnvryL7cA2wmmPM5cajBxuk7ssrZX1qAWYTHJ9w8B0Hb4uZftFGSUyyB0tiCsqquO7dlZRX2ZgyoAsvzx7Lyb0smPN2AiZ6j5pK93B/yqqs/LKloZIYRxAkrZlBkOIsWPOesW2rUqMzEWkWjchtf0bEh/HCrDH8dOsUHj5rGHNPHtj0gzj6gvjs/Y0b/YxJMlviL3BNnyuvspJWYNxMqC8IYjKZavqCuPPmS2z7bI5qtdm55eM1/LIlC39vC29clkhCtxB6RwUyMj4Mmx2+Wpt2+APVYrPZeWThJr5Zt7/Z68pwlMP09nWMOQ4+OLu0pjnqYYIgoXHG++3WxgU1agdB1MhdxC08GgR57LHH+Oijj5g8eXK9r1dUVPDEE09w7733MmPGDEaMGME777zD5s2b+eyzzwDo0qVLg5kgJpOJtWvXYrPZmDVrFnfffTdDhw7l999/b8uPKW7mZTFjMR+m/GLImXD8v4xtv1A47v/gxjUw/jrw8q27r38Yl5x3HufPvIwFN0yif0xwg4eNCPThuQtH0S86iIzCCm78YDVWm5sDFcPONTqHZ2+FPZ75b/V7RxbI2F4RrmZfB/J0XxCbzc5tH69hd04pcWH+PHPBSOO/C+do3OgETP7hnOYog/lmfQMXP67mqM0Mgvz1MlTXjG4mY2PzjiMiIu1Sny5BXHRUDwJ8mlFF7uwLsuEz+ldvpdzuzcfmU1wv780txW6HYF8vV1+JA43va/QT+XrdfmPErjt0bZ99QZ79cSvfrNuPt8XEi5eMcfVEATjLUQbz+ZrGN78HWL4jh5eW7OTuBeub/efnzASJt+QbT9Qaj+sUGWhcL+WUNOIGmbMk5nDNUcsL6l4LKggi4hYeDYKYzYc+/dq1ayksLOSEE05wPRcbG8vw4cP59ddfG3UOq9XKhAkTOPvss5k4cSLr16+vc7wDVVRUUFhYWOdHjlATb4HrlsFN64zaXd8GMkcwghvTh3drVK1toK8XL84aTYCPheU7cnjqhy3uXLVnGqSWF8DPDxm9LYDvNhr9QOorhXFK8PCEmBeW7ODHTZn4eJl5cdYYwp0Xj87RuD2OAuBURxCkwZIYZ3PUjA1QVX7w64dSWQJJrxjbYT0dx2lfd9VERMSDnH1Bqo1sj/nWyfy8t+Yf4s7JML2iAhvsrzVjeDf8vS1sTi/iL3c1SI11lBPvXg7Lnobl/4U/XoC/XoFNX7W8WXgzpOWX8dKvOwF4/NzhNf1XHKYP74rFbGLdvgK2Z9bT/L4B61LzASN7NCWnEeUn9XCOx401Of786wuCODJBsg+XCQKN7wuy8xcjY8TiuCGVtlpN2EXcoF1Ph0lNNSK9MTF10/FjYmLq9AU5lNGjR7NkyRIuvfRSHnzwQTZu3EhUVFSD+z/yyCOEhoa6fuLj45v/AcTzYoeBf5jbD9svOphHzzHuosxbvIMf3d2tfMxlxuPGz6G0DaYZ/fIY/Po4fH0LOcUVrpTbE+sphXGqGZNb1PrrO8CvW7N48nsj+PTAGUMY1j205kVnJkj8eACGdw89dElMWA8IiAJbtREIaYrV70JZHoT3NkYdAqQ38RgiItJx1eoLYsfEa9bT2JNbyn5HCcyhJsM4hQZ4u5qBvvV7invW1XUkruaoP/4Lvr8XFv0Dvr0dPpoFn18HtgbGy7eSJ7/fQkW1jaN6R3DmyIObn0YG+boCI180IRtkY2rNzZrm9lXJcGSCRNpyjCfqKYepGZPbiEyQ7o6+IIcLgmz73ngcdbERTCvOMKYgikiLtOsgiDNlzcurbvqhl5cXVmvj/485IiKCM844g6lTpx50rAPdddddFBQUuH727t3b9IVLpzBjRDcuO6YXALd+vIY9zby7UK9uo4x6XWsFrPvIfcetT3UlrDNGyrLzF35bvQ6bHYbGhRAfEdDg25xBkD25pRSVV7XuGmvZl1fKTR+uxm6HmYnxXJDYo+bFylJj3C24MkFMJtOhS2JMpuaVxFir4ffnje1jbnBcUNL0QIqIiHRsfY8FwJQwg6BuRl8RZ0bHoSbD1HbpMUa24XcbM1wBlBYJjIIzXzBG/Y68GIZfAEPPgcGng9kL1n8CX/4dbIcZ9+omG9MKWLDaCGzcfergBrNinMGgBatTG13asj61wLW9pplBEOeI3NDqbOOJesthGtkTBByBMRMU7IWiBm6k2e01/UAGz4Dowca2SmJEWqxdB0G6dDGivdnZ2XWez8rKIjq6dcZ5+fr6EhISUudHpCF3nzqYUT3CKCyv5vr3VlJe5aa7JiZTTTbITw8Yd2lKctxz7ANt+86YbAJgt1GxygiInJTQcCkMGCVEMSHGXY8t6W2XDfLIt5vJK61iWFwo/5pxwEjbtFVGc9Kg2JryFJpQEtOU5qjJn0P+HiOLZOTFED0IMEFJVsMXNCIi0vlMuBlOfRJOf5ajehs9Lv50BEGck2H6HCYIMig2hKN6R2C12Xnvjz3uWdfIC2HGf+HM/8HZL8O5rxtj3s993cg6WPMefHNLy8ovSnMh+Uv44f9qMjUPYLfbeeTbzdjtcPqIboyID2vwcCcMjiHQx8K+vDJW7s477OkLSqvYk1tzk2rdvvxDv6GyFFa+ZWR51uIckRtQ7vh+r7cxqnFN1KhyGN9g6DLI2N65uP590tcZmR/egdDzGOg20nheQRCRFmvXQZCRI0fi4+PDsmXLXM8VFRWxdu1axo0b58GViRh8vMz87+LRRAT6sDGtkP/9ssN9Bx8xE3ocA1UlRr3uM8NaJxiy2jHZxBE0GJm7CLBz0tBDB0GgdklM2/QFyS2p5Ptko1/JY+cMP7iHi/MCq8d4qHUX6bAlMc601K3fNa78yG6H3541to+6Frz9jU7/zpGDygYREREn3yAYdzX4hzPOEQRpaiYI4Mo+/eCvPVRUt06pit1uxz54hhEUMZmN3mQL5zY+EGKtgu0/wvf3wUuT4fE+8PElxnfmhxfV+x27ZGsWy7Zn42MxM/ekQ0/g8fexcPJQIwDhzBw5lA1pRhZIgI/F8XshVdZDZLd8ezt8dSMsftj1VHmVlYIyI+PVu8S4BiHk4HKdCGcmSGPKYcDIvAHjz6a+jBtnFkifKUZTf9c0OwVBRFqqXQdBgoODmT17No888gh79uyhoqKCO++8k5CQEC644IJWPfe8efNISEggMTGxVc8jR76uof48cMZQAF5ftov80kbcAWgMn0C4/Fu48EPoOqJuMOTnh9xTq1uUUVNves5rWM2+9Dft4+Tw/fSPbriRrJMzCJLcRn1BPl+dSpXVzrC4UBK61ZOl5WqKOr7O0yaTyZUN8nV9JTF9pkJ0ApTlwg/3HX4hO38x7tB4B0DiVTXPxxj/HSgIIiIi9XEGQbZnFrM3t7Rm9Grk4YMgJyTE0DXUj5ySSr5taOJZCz370zYG3beIDREnwBnzAJMxBe37ew8fCElfDy8fC++eA8ufc5Sn2o2Mh5DuRtbpzw/WeYvVZmSBAMw+uuchy3CdnFNivl63n8rqQ5frOEthpgzoQqi/N5XVtoazVzM3wdoPjO3tP7me3uzYP9yrHFOVEbQipL6eIE0ohwEYdxX4BENmMmxddPDrziBIf8dAh9pBEDVHFWkRjwZBPvroI2JjYxk92khFP/vss4mNjeXJJ5907fPss88yfvx4+vXrR2hoKL/++ivffPMNoaGhDR3WLebMmUNycjJJSUmteh7pGE4ZGsvgriEUV1Tz6tJd7juwyQQDT4FrltQNhvz6OPz2TMuPv+4jo+t43FiIT2R14AQArg75s8F63NraMhPEbrfz8QqjR895Y7sfvIPNVhMEiT/qoJedfUF+rq8kxuIN058xtle/CynLOKTlzxmPoy6BgJrxfcQ6giBqjioiTaSbL51DWIAPg2KNEfPO77SIQB9CA7wP+14vi5mLjzL6YL25fLfb11ZltfHm8hQqqm3MX7kPRl4EpzuyHn9/3sjo2PvXwf8At1bDkieMAEjGevALg1Gz4OxX4LYtMOdPOPslY98Vr9fJZPh05T62ZBQR4ufFDdP6NWqdR/eNJDrYl4KyqvqzO2vZ4AiCDOseynBHE/UG+4L89ADYHUGV3B1QkEpxRTW3frQGgBm9Hfv5hho3qg7gLIfJKW5kJoh/uBEIAVj6ZN0/19Jc2PeXsd3PEQSJGQpmbyOYlO+mkiiRTsqjQZAZM2awZs0a1q1bx/79+0lOTmbNmjVcd911rn0CAgJ49913KSoqIiMjgw0bNugCQdods9nEzcf3B+CN33aRW+KmbBCn2sGQUx43nlv8cNMaeR7IbjfqfQFGXUx5lZVXCozgwYj8H42GqYeR0NW4kNuSXoTN1rp3JTamFbI5vQgfLzMzRhzckIzsLcaoX++AmtF/tRy2JKbHUTDmcmP761uguoGLmP3rYMfPRr300XPqvhbjOK8yQUSkiXTzpfNw9gX5ZMU+AHpFHj77wWnmuB74WMys3Zvf7CafDfl9Rw75pUbZx5KtWcaTYy41+pmAMTr3tRPglWmw7mPjOiFzM7x2PCx+0OjJNWg63JBkZJEMPx+CHaW1vSbCsPMAO3xzO9hslFVa+c8PxqS3v0/rT1iAT6PWaTGbOGOkcR3w+WGmxLiCIHGhjHT0Gql3QsyeP2HLN0YJUKgxGdK+61funL+OndkldA3147bxjgzUerJAoGZEbkmltfE94sb/Dbz8jCkxO3+peX7nYiMg02UwhDkmVXr5QkyCsa2SGJEW8WgQxN/fn9jY2IN+goIOTsP39fVt9ewPkZY4MSGGId1CKKm08srSna1zEpMJxl0DQ84yRrp+ehVUljTvWKmrIGuz8eU79ByW78jmh8ohZBGOV0We0TD1MHpFBuLrZaasysruXDdOx6nHJ447ZicmxNR/oeTsB9J9rJHZcYDDlsQAHP9PCIyG7K3w23MHv56+Hj640NgeciaE96z7ujMTJHtrw0EUERHp1Mb1jgQgvdAYu9o76vDlp05RQb5MH258l73trnG5DrVLbHZll7Db0a+EcVfDdctg5Cyw+BpNxD+7Gp4eYvT9SFsNfqFw1stGY9WgBoYXnPAA+ARB6grKk97i6R+3klFYQfdwf2Yf07P+9zTAOSXmx02Zrn4dByosryLFMblvaLdQRnQPA2Dtgc1R7Xaj5xoYjc4dvTq2//Ut36zfj7fFxLyLRxNS5QgM1dMUFSDY1wsfi/FPq5zG3gwLiobRlxrbS/9T8/yBpTBO6gsi4hbtuieIJyktVZrKZDJxy/EDAHhreUrj0yGbfiKY/rTRlCt3Byy6q3nHWfOu8Tj4dPAL5bsNGdgwsyX6FMfrHxz2EF4WMwMdab2tWRJTXmXl8zVpAJw/Nr7+nZxBkPjx9b/OYUpiwEhNPfkRY/vXJyCnVqPbLYvg9ZOhcB9E9ocT7j/4/SFxxoWgrRqythz2c4mISOeT2Du8zu+9oxqfCQJwqaNB6tdr95PtpmuNaquN7zYaTT9D/Y0bCb86s0HAyLA8cx7cmgzH3mtMYSvJBGuFUa7xtz9gxAV1mpLXVlRexeI0Cz/GXAFAybf38dGv6wC446SB+HpZ6n1fQxK6htAvOojKaluDJTHOLJDu4f6EB/owPN64mbots5jiiuqaHbf9AHuWGwGeqf+A3pMACEhdDti559TBjO4RDoWOrJN6mqKCcR0Y6eoL0oS/lwk3GmUuKUuNjBSbrVYQ5MS6+yoIIuIWCoI0QGmp0hzHDY5mePdQSiutvPxrK2WDgPGP9bNeBEyw6i3Y9HXT3l9VBus/NbZHXozVZueHTcbYt4BxlxjPb/sOSrIbOECNwbGt3xfkx00ZFJRV0TXUjwn9ourfaa9zMszB/UCcapfEJD70I8P/9Z3rZ+T93zN3/lpKB5wBfacZF3ZfO0YD/j4PPpgJlcXQewpc9QOE1tOXxGRSSYyIiBxSdLAffbrU9JRozGSY2kbEhzEiPoxKq42Pkva6ZU1/7Mwlr7SKiEAfrppoNL9YUjsI4hQYBVPugJvXw3lvwvlvw8WfQEg9ZaoY/bw++GsP4x76icvfTOK6bWPZYutOpKmIfwd9xs3H9+f04fW/91BMJhMnDYkB4PuN9Y+ldwZBxsWY4OWpRH95CWND8rHba17DZoOf/m1sH3UNhHYnJ2I01ViIM2Uze1BN0IlCR6ZMA+UwUGtCTK3mqFVWG1+sSWX5jgauqUK7GxMBwcgG2b8aSrONpqkHNHqvCYKsUXNUkRZQEETEjUymmt4gb/++m6yixt0JsNvtpOWXYW/KF1rvycbdA4Av/17z5QxGne6OxfDD/0HSa8bIuto2fwMVBRAaT0HXY3j5153kllQS6u/NsFHjoetII5th/fzDLmNw19bPBPnYUTd9zujuWMz13GUqyoC8FMAE3RvO3jKZTFw4zmgqV1xRTWF5zU9+aRUfr9jHOS/+QdqEh4wyoV1L4I1T4bu7AbuRsjrrUyMI1RA1RxURkcNw9gUB6N3EIAjApUcb5SMvLdnBF2tSm3b9UI9vNxjXECcNieG4wUZwYfmOnIZH8Xr5GKW5CWc0mP1RUlHNLR+t4a7P1lNWZSU+wp9zxvYmY5IxIebM6u+4OaEEc33f641wQoLRb+SXLZn1rnNDqnFdcpZlqZE5se173qu6lcssi1i7xzGqd8N846aFbwhMvBWrzc7NC7axymY0ab17cFZNo/gix3VWA+UwUNMcNbu4Arvdzrfr93Pi079y04drmPXqn/yYXH/Ahom3GP1Itn1nTAIE6Dv14PLe6AQjY6WiAHJb8WabSAfn5ekFiHQ0xw6MZkR8GGv35vPSkh3cOz3hkPuXV1m57ZO1fLNuP2N7hvN/pycw3FG3eviT3WsEO9LXwefXG7WsW76F7T9CRa2gxJ8vwimPGRkOgHXVO1iAr81TuPWhn6m0Gt3Qpw/virfFbHSE378G1r4P4687+Ly1DHJNiGncmNxqq41tmcXsyS1lb24p+/LK2JtbSnZJJTNGdOOKCb3qTKZJyy9j6TbjbtS5Y+rJvgDY/JXxGDPUKEc5hL9N7cuMEd1cn9lpT04pd8xfy6b9hZz6bhkLhs2h99r/GCmymODEB+DoGxq82HNxjcldf+j9RESk0zqqdyQf/GVkcfRqxHjcA502vCtvLU9h7b4CbvpwDfNX7uOhM4fRo54mq5lF5azek8/4PpGuUpfaqq02vttglMKcOqwrg7sG0yXYl6yiClak5DWcgXkIW9KL+Nt7K9mRVYLFbOKOkwZyzaQ+joDHcCj8BtZ/At/cBpcvNJp+NtHwuND/b+++46Oq0sePf6ZlkknvgUBCCC10Ir1IExBRUUAFXVHBtSHsWnaXtax9/bo/y64aFWXtLAiCNEEQRAkgvddQQnrvvcyc3x83GRiTUDQQJ3ner1dek7n3zJ1z5sDcm+ee8xyCvcxkFFaw7XQOIzs75iKpHe3RO3ettsGzNeaiVJ43fc6p7fug60fnluwd8iew+PH51nhiT2Yz0KU7/TmBa9IWGFCTNL1Qm5bb0KgXgICakSA/xWXx5Y5EexJWF4OeSquNRxfuZeEfB9In7Bc3U/wjtaDS4aVaAlo4tyrM+QwmbWpSym4tsOMfeWkflhDCgYwEEaKRablBtNEgX+5IILOovMGyeSWV/GH+Dr49qN1d2J2Qx83vbuWJxQfIKGz4dXZGF5g8H4xuWibxZffDkWVaAMQ9CHreAZYALVHnF7dS8vlU5n/5JbozPwHwWvo1VFptdAr24C/jOvNsbcCm+xRtfmraAcg4esEq1E6HSckvo6C0/uRkoI0UeeXbowz6vx8Y/59YHvxiDy9/e4xPt51l4/FMDiTl89Lqozy55KDDHZ1le5NRCvpH+NU/ZLi6AmJr7pr0+cNFPzKdTkdbPwuRgR4OPyO7BLFq9lB6tfUhv7SK63f2It2rJ8rsBVMXwODZFw+AgONIEBmqKoQQoh6DO/jj6WqkVxtv3M2Xf0/SbDSw5KHBPDm2Ey5GPbEnsxn77594/8fTVFltHEkt4O2NJ5kYs5X+r2zkwS/28MfPdte7ktvOs7nklFTiYzExsL0/Op2O4Z0CgQamxFzE4t1JTIzZwumsEkK8XFn0wEAeGh7pOOJjzEvadI+UPbDoTqi8/OTqer2OMV3rnxJTVF7FmewSOumS8Mw7ql3TPLSFM/1fpFi50qH8ELw3CPITwCMYBj5MldXGRzVTmTsMqMmPdjb23Ln8kkaCaEGQ1QfTOJCUj8XFwJ9Gd2TX09cxvFMg5VU2Zn62m/jsepLaD3vC8fkvk6LWkrwgQvxmEgQR4goY3imQPmE+lFfZePqbw+cyrJ8nMaeUye9vY3dCHp6uRmLujGZSTbbzpXuTGfn6j7z7w8mLL7MW2BkmvK4Nowzqqp1E798IT5yASR/C7D1kdb0PK3rcz6zl/lOz0OsUe3XdmHDtYNb+aRjrHxvOrJEdcDXVJCZz94dO47TfD1w4Qaq3xUSojxsAx9LPjT5RSpGSX8b82DOM/08s4/8Ty0ex8WQVVeBpNtKzjTcTerTioeGRvHJrd/4yrjMGvY6le5O5e/5OcksqUUrx9R5tKsxtDY0C2feFlqzUsxVcc++FP6uLaOXtxlcPDOT2vm2oUEaGZj7J3X5f8uzxcF5fd4KPNp9h8a4kNp3IpOoXI0nsArtofVGWC0Xpv6k+QgghmqcgT1c2PjGcL+5vOI/VxbgY9Tw6qiPr/nwtgyP9Ka+y8dp3x+n5/HomvL2FN7+Ps49EMOh17Dyby1e76+YQqV0VZlzXEG00KJwLgpy4vCDI6+tO8NevD1JeZePaToF8O2co/dr51S3o1Qru+EJb1v7UBlgwBcovf1rt2JopMd8fzXAI8BxJ1Y413VKTL6zTOHD3J2j0LK6vfI3N1h5ATfnhfwUXd9YcSiO1oJwADxeGj7pBmxZbnKHdSLJWQXFNAtYGEqMCtPHVRuIY9TruHhjOT38ZyWNjOuFtMfHeXdH0CPUmt6SSez/ZWTepbXA36HxDze89Gh5xcn5eECHEryLTYRoQExNDTEwMVuslrvMtxHl0Oh1Pju3MXfN38P3RDDYcy2BEp0CmD27H8I6BHEwpYOanu8gpqSTUx41P7utHp2BPJvRsxfTB7Xhx1RH2Jubz+vo4vtyeyKxRHbijb1tcjA3ELfv8AXpOBYPjf+nNcVm8u+kUO+PH0EnXheeNnzHYoI3s6H3zLKL7dGm4Eb2mwvHVsH+Bto79BRKBRbXyJCW/jOX7Uvj5dA6HUgo4mFzgcIJ3MegZHRXEpOg2DO8UWG9buod68+iCvew8m8stMVt5eEQkZ3NKcXcx2Je3dVBdAbFvar8PfRxMrg235xK5mgy8NrknPdv48MKqI2yJL2ZLfHGdcrNHdeCJsZ3rHsDkpq0ek31Cm2d8gc9NCCFqyXVHyxPk+dvPWaDlFFlw/wCW7U3h5W+PkldahZvJwNCOAYzuEqSNdDyQysvfHuOfa44xOirI/t5Wm+K7w9ooivE9QuzHHNohAL0OTmQUkVZQRitvt4vW49uDaby76RQAj4/pxKMjO1w430fkSLj7G1hwGyRshc8nanm3LPUETRowsL0/nmYj2cUV7EvK55pwbZrJ4ZQC9NiYwGatYM87APAwG3ELjGB65lxWD0mnu0cRRN+LUoqPYrVRINMHtcPVzR3aDtByg8Vv1oI1KG1EicW/wfrc1rcNriY9/SP86+R6cTcb+fjefkx6fysJOaXM/HQXCx8YiMXl3LVbybXPYijIwGXYnIbvVNcGQdL2a4ld9XJPW4jLpVO/NZNSM1dYWIi3tzcFBQV4eXk1dXWEk9lyMpuPYs84DCcN97eQUVhOeZWNbq29+OTefgR5OV4IKaVYeSCV19YeJ7VAmxYT6uPG7FEdmHxNG/udmoYopXjr+zje/kG7GDHqdUzsHcoDwyLonL8Z8hNhwIOgv8CSdNWVMO9ayDqmJUq9by241L+M3xvrT/BOzXudz6DX0auNN7dGt+Gmnq3wsbjU/15pB2DhndC2H6f7Psc9i+NJziuz7769bxv+NaVX3dft/AjWPAmerWHOvkYJgpzvRHoRsSezKCyroqDmJ72wnO1ncnF3MbB17qj62/T1DG1e7+jnYNjjjVonIZyJnEMvn3xm4rcoKKviTFYxUa28zo3uRMv7cet72ziUUsCNPVvx7p3RAGw/k8PUD7fj7WZi9zPXOVxf3PreVvYl5vPa5B7c0S/sgu8bl1HELTFbKa208sC17XnqhqhLr3TqPvhikjaCMqgbTF8OHkEXfVmt2Qv3sepAKg8Nj2TueO3mzp8X7SPr4DoWuLwKrj7wZJw978iTSw7w9Z5k5ozqwOM1NzN+Pp3DtI+242rSs23uaG2Vl83/T8sZEnWzNiX2v2PAOwwe+205v85kFTP5/W3klVbRN9yXUF83EnJKScwtJbdEW1Wmd1sf3r2zj31kiQNrNfxfW6gqhVm7ILDTb6qPEM3JpZ5DJXQoxBU0tGMAn83oz6YnRzBjSASerkYSckopr7IxonMgix8cVCcAAtpIkom9Q9n0lxG8cHM3gjzNpOSXMXfZIUa/8RNf70mmuoHpGOVVVuYs2m8PgPxhYBixfxvJG7f3onMrL4i6EQY9cuEACGj5RqYt1O54pO2Hbx7U7jjUY0LPVgR7mekY5MGk6FCev6krSx8ezOHnx7HskSHcPTC84QCIUrDmL9qUliPfELnkOtaOPXc3B+C2vm3rvq6q/NwokGGNMwrklzqHeHL/sPY8PrYzL0zszr+n9mHhHwfSJcSTkkorn2w9W/8L7clRZYUYIYQQV4+3m4k+Yb4OARAAo0HPq5N6oNdp+So2HdemdtROhRnTNbjODZZLzQtSWF7Fg1/sobTSyuBIf/46rp5RkhfSug/ctwY8QiDzCHx8/bkkpJdgbG1ekKPnpqAeSilgkiFWe9J9skPi1V5tfQDYn1xg3za/ZhTI5Og29mVuiRiuPZ6NhQJtam5jjO5sH+jB/Hv6YTbq2Z2Qx4r9qexPyrcHQAx6HfuT8pnw9hY2HqtnNRmDEUJ6ar9LXhAhfhUJgghxFUQEuPOPm7qy46nR/N+kHjwzIYr50/teNBma2WjgnsHt2PzXkTwzIYoADxcSc0t5cskBRr3xE4t2JlJZfS4wkVNcwZ0fbWfVgVSMeh3/mtKTl2/pcUnDWOvlFwF3LACDCxxbCZteqbdYlxAvdjx1Hd8/Ppw3b+/NvUMiuCbcFzeXiwRaQDtu0g5tqGlQVyjNxnPFfSwO/ITZg/x54Nr29A33rfu6fV9AUao2Nzd6+q9r36+g0+mYPUpLfPvJ1niKyutJBhvSQ3uUZXKFEEL8TnQP9WbGkAgAnll+mOKKatbWrAozoZ4pp7VBkNiT2Q3eeLHZFI9/tZ/47BJCfdx4Z1ofjBcZrVqvoCgtEOLdFnJPw//ugMp6kofWY0TnQEwGHWeySjiVWUxxRTXp2Tlcr9+lFeg11aF875oV+A4m56OU4lRmMRuPZ6LTwcyhEecKtu4DLh5QlqflLYELJkW9HNeE+/LJff2YPiicueO78P5d0Xw7ZyiHXxjHj0+OoFcbbwrKqpj52W5eXXOsbh4ySY4qxG8iQRAhriKLi5Gp/cO4f1j7y7pIcDUZuH9Yezb/dSR/u74Lfu5aMGTuskOM+H+b+PznsxxOKeCW97ayNzEfL1cjn8/sz+31jaC4XOGD4Ka3td9jX4cDi377MWtVV8KG57XfBz0KD/yo5fbQ6TEcXswTp+7lqciz1JlRXFUOsW9ovw97/FctrfdbjO8eQocgDwrLq/n854S6BYK7aY85J7W6CiGEEL8Dj43pRKiPGyn5Zdz/2S4tWbmrsd5lcHu28cHHYqKovJr9NQlWf+ndTafYcCwTF6Oe9/8Qjb/Hbzgf+0fCvau1EajpB+GbhxocgXo+T1cTgyK1+q8/ms7R1ELG6nbhrqsAv/bQpp9D+c4hnrgY9eSXVpGYW8p/t8QDMLpLMO0DPc4VNJggfLD2+9GV2uMFkqJersGRAbw4sTsPDY9kfI9WdGvtjYfZSFs/C0seGsy9g9sBMG/zGaZ9uJ20gnPThCUIIsRvI0EQIZyIxcXIwyMi2fI3bWRIkKeZ1IJy/rHiCDe+s4Wk3DLC/S18M2sIgyPrXtD8ar2nacEJgJWzIXF74xx398eQe0ZbznfIHC2Ycd1zMGM9+HfQlqNbOBU+GgnHVp27GNr7ubbPqw30ubtx6nIZ9Hods0ZGAvDfLfGUVlY7FvBsBW5+oGxaThUhhBDid8DdbOTlW7Qpm9vP5ALaVJj6kpUb9DqGdWx4Ssym45m8tSEOgJdv6U7PmhEWv4lvO20Eqt6kjRT96bVLetnY85bKPZRSwK2GLdqOnlPrLG/vYtTTrbWWK+CH45ks26tNdfnjsAjqaDdMe6ws0h6vUrJzF6Oe52/uxnt3ReNpNrI7IY+b3tnKqcyaetQGQdIPajlChBCXRYIgDYiJiaFr167069fv4oWFuMosLkb7yJCXJnajtbeWD6NvuC/fPDKEyPPvZDSWUc9C1E1grYRFd2rZ0n+Lsnz46f+030c+BWbPc/va9oMHY2HwHDC6aXc6vvoDvDcQ9i2ALeflArnKo0Bq3dSzNeH+FnJLKvnfjkTHnTodhNTkBZEpMUIIIX5HRnYJYkLPc3/M1zcVplZ9eUFKKqr513fHefCLPSil5R5rlJGntcIHwY1vab//9H9weFndMkpByh44uwWUYkxNEGR/Uj77jxxlqL7m3Nvz9nrfoldNwOaN9XFUVNvo2cab/hH1rEoTca3j80aaDnOpbujRilWzh9I52JPs4gqmfriDU5nF2o0iFw8tOWp23FWtkxDNgQRBGjBr1iyOHj3Krl27mroqQjTI1WTg7kHt+PEvI1n2yGAWPjDwXEKvxqbXw63ztJViSnPgs5tgxSwozf11x4t9Q5tnG9C5/tEcLhYY+xI8dhiGPQlmb23Z2RWPaKNAvNs2ySiQWkaDnlkjOgDaUNXyql8saxlckxdEkqMKIYT4nXnupq4EepoJ9XFjaMeGR45e20nbV7vs/coDqYx+4yfe+/E0lVYbY7oG848buzV+BaPv1qbJAix/GFL2ar9XlmqjQecNg49GwacT4L9jCC48TO+ahKetE1eh1ynyA/tquc3q0autNwDFFdooivuHtUenq2c535Ae2uoytbxaN0brLku7AHcWPqAlZc8urmDaR9s5lV16bjTIhuehuuKq10sIZyZBECGaARejnugw34sunfvb38gd7lkFfWdqz/d9CTH94dDX2l2Z89ms2lK8ZXl1j5OXADvmab+PfUnLdN4Q9wAY/ay2JN3o58BSc7E28mltBZsmdEufUEJ93MgqquCrXUmOO2tHgmQcufoVE0IIIS4gyNOVjU8MZ91j12I2NpzEPMjT1T51ZOK7W5mzcB/pheW09XPjw7uv4cO7r6l3Kk2jGPMidBgD1eXaCNTvnoI3o7RpuemHwOiqJVVP3gXzR/Oa7l1CyLGvCqPvPbXBQ/c6b+pOqI8bN3QPqb+g3gDthp57fpVHgtTyc3fhfzWr02UVaYGQ5D6Pa6NlT66DJfeBtZ5E7UKIekkQRAhxeVy94MY3YcY6COwCJVmwdCYsmAJr58KC2+GdvvBKCPy7B/wrEr6YpE1jKcvXjvHDS2Ct0IaZdhx7ie/rrU1/eewwPLpHy1PSxFyMeh4aoeUG+eCn0w4r9diXyU0/VDdAJIQQQjQxL1cTHhdZpQ7OTYlJyS/DbNTz2HWd+P6x4YztFlL/6InGojfAlP9qI0aL0mB7DJTng084jHkJHj8Gs/dC77sA6Jy5hp/Mj9NZn0wFJryib2vw0O383fFy1dp+35B2F05Wf/6UmCYKgkDdQMitq22k3vAxGMxw4lv4eoYEQoS4RDql5Or8QgoLC/H29qagoAAvL6+mro4Qvy/VFbD1P7D5/2m5Qn5JbwLbeSdkg4uWZOz0Ru35Az9B695XpapXSnmVleH/bxMZhRW8OqkH0/qHaTuqK+CfrcFWDbN2QmDnpq2oEE1AzqGXTz4z8XuTkFPCfZ/sIqqVF3PHd6Gtn+XqViD3DCy5V0ui3v+P0OE6LUByvpS9qHVPoUv8GYBd7tfS7y+rLnjYhTsT2XU2l5dv6Y7F5QLBoOxT2qhX33CY0/SrseSWVHLnR9s5nl5EoKeZ1ePLCf72Pu06rNutMGn+hUfYCtGMXeo5VIIgFyEXI0JcguyTsPNDbWiqX3ttDq5fe20pubyzWlKzw0sdV0rpORUmzWuyKjem/26J56XVR/F2M/Hxvf24JtxX2/HJDZCwFXzCtGlEvu2atJ5CXG1yDr188pkJ8SspxXeL36fk8Lcw/O9Mvm7oxV9zqRK2aUv3/k5uaJwfCOkQ5MHKscVYlt2j3XjqPgUmfVg3UCRECyBBkEYiFyNCNKKMo1owJD8Rxr0CHkFNXaNGUV5lZdpH29mXmI+rSc8706K1TPUFyfDZzZB7WlvO956V4B/Z1NX9TUoqqlm8O4moVl4MiPC7skOhhdOTc+ili4mJISYmBqvVSlxcnHxmQvwKNpvicGoB3Vt7o9c37/NTRmE5E9/dSnphOcM7BfLxwEwMX9+jjUD1CNESp7burSW0b90bPBvIe9IQazUkbIGjK+H4t1qApdsk6H2nduyGzv+VJdpNMQnCiCYgQZDfSC5GhBCXo7Symtn/28fG45nodfDyLT24c0AYFKbB5zdrS9h5hGgjQgI7NXV1f5Xj6YU8smAvZ7JKAIhq5cV9Q9pxc6/WuJrkYudqOZicj16no3uod1NX5aIkCHL55DMTQlyqwykFTPlgG+VVNmYMieAfHU7DsgehqqRuYTc/bUqPT5iWV8U3HDxbg04PqJr8ZQqqyuD0Ji3PSH3J7QGCumrBkM43aDe20vZD6n5IOwB58dryvW36QtsB0LY/hPYFN58r9jkIUUuCII1ELkaEEJeq2mrj6W8O89VubaWYOaM78th1HdGVZMHnEyHzqDanefoKCO5a7zGUUhxLK+KnuCx+isvkVGYxVptCod3hqv3G9nE3EeTpSqCHmUBPM0GeZvqE+TKkg/8VGZ2xeHcS/1hxmPIqGwEeLhRXVFNepSWCbWOx8lbIOrqFWLBc/7y2ipC4ZIXlVbyw8ih7EnJ57uZujOxc/wgppRTzY+P559pjKAW3923D38dH4XullsVuBHIOvXzymQkhLseaQ2k8skBbQvjVST2Y1stPS8qedgDS9lOdvA99Thx6bBc5Uj0s/tBlAkRNBB2wfyEcX62t2HNZdFrwxeKnLTns5qsFRVy9QW/UAjH2H522zeBS82PScsy5emsJ+f0iZJSJaJAEQRqJXIwIIS6HUoq3vo/j7R9OAXBdVDBhfhbMlbncffLPtC4/SbHBm59C7iHVtx9FXp2wmE2YjXqOpBayOS6L0qI8BumPMkR/mCBdPgdskeyydeaQak8VF0521q21Fw+PiGR891YYGmEocGllNc8uP8LSvckAXNspkLdu74VBr2PRriR2btnAMxVv0l6fDkCaOYKiiZ/SqWvvSzq+1aZYeziN9388TVmllcfHdmJCj1ZaIEcpKMkGj8Df3I5a6QXlfPDTaSIC3LlrQNiFVwS4CvYk5PKnRftJzisDtGu/x6/rxKyRHRyGcldbbbyw6ihfbE9weL2fuwtP3xDFpOjQ3+XUJDmHXj75zIQQl+vtjSd58/s4jHodX8wcwMD2fuxNzOfL7Ql8ezANvbWMdroMor0KmdFNTwdTjjaCozhdO9fqdIBOe9TpIaQndL0ZwgbXSbKakZHB0Q2fEXT6a7rZTpBhbI0xtA9+Hfuja9ULQnpAUTok7YCkndpjXnzjNdboCgEdtdEoAR211XHOH8kCoDOcC6DUBlP0hrpTeHR6cA/UVv3xag0mt7rvZ7NBRQGUF2qjZKpKzz1WV4B3Gy1XTH2vFVedBEEaiVyMCCF+jQU7Enh2+WFs533DelPM5y7/Ry/9Gfu2XOXBDlsUO2xR+OiKGao/TG/dKYy6undsbAZXKoN7UxbSlxK9O0UViuJKRWGFjbwyK7Fpeg5VtSZBBdPW35MHh0cyKToUs/Ey75goRXl+GkePHmLx1mOsyW1Nsc6dx8d04pERNX+c26yw7W3UDy+js1WTo/fHarUSpMunULnxgd9f6XXdnVwXFVxvMKbaamP1wTTe+eEkp7Mch+1eE+7Ly0PNRO1+Vkss23EcjH0JAjtTXFHNwaR8AjzNdAzyuOQ//KutNj7ddpa3vo+jpNIKQJcQT166pTv92vld3udzCQrLq/j2YBrbTufQMciD0VFBdG3lZa9vtdVGzKbT/GdjHDYFbf3c6Bvuxzf7UgC4LiqIN+/ojZeriZKKamYv3McPxzPR6eDpG6LoE+bDU8sOcyKjCIBB7f156ZbuRAa6/66CIXIOvXzymQkhLpdSijmL9rPqQCo+FhOhPm4cSS207+/Zxpv0gnIyiyoAmNCjFc/cGEUr74v/4V5RbaWovJptp3P4ek8yW05m2a9t9Niwod1M6Bvuy6yRHRjRObDueag4U1vlpyxfW+a4LK/m9wJQVlC2cz82a81PlbbijbVK+ynJhKw4qC5rhE+sAW6+2hQhvV6rW1kBVBRiD640SKclvw/qCkFdwGSBkiwozoDiLK3uZXlavhabteaxGmWzgmcIOr/22utrFxfwbQfeNSNnGuOcbq2CiqKakTeXf01IURoUpmqfj0cwmD0u6xDfHkxj/pYzjO8ewj2D213+dellkCBII5GLESHEr7XjTA4/nMjEoNNh1Osw6PW42kronr6M1rk7CS3cj4utgZO5X3toP1IbPpq8CxJ/htKcS3rfCkycsrXmhGpLniGACEs5rY1FBJCHZ3UuLhW52p0UNx9w80Xn6gNuPpSVFlORFY9baQpmVWE/nhU9pf498IwaBRHDtTqt+hOcjdUKdJ0IN/6bw0lZuC2fSWTZIQDerZ7IQssfCA/0wt/DjL+7CwEeLpgMehbuTORsTikAXq5GZgyNAODjn+K427aCOcZvMOvOLa9sw8Ba1/E8X3gTWTZPAAI9zQyO9GdIZACDO/jTxrf+ZRt3n83lmeWHOZ6uBQx6hHqTlFdKfql2/CnXtGHu+C4EeJgv6fNtiNWm2Hoqm6/3JLPuSDoV1Y6BrFberozqEsSQDgF8sjWeXWe1uda39gnlxYnd8HQ1sXh3Es8sP0xltY2IAHdevqU7r649xuGUQsxGPf+Z2pvru7cCoMpqY35sPP/ZGGefmmQy6PB2M+HlasLLzYS3m4n+EX7c0ieUUJ+rf5dKzqGXTz4zIcSvUV5l5Y55P3MguQAAF6Oem3u15u6B4fRq60NReRX/3nCST7edxWpTWFwMPHBte9xdjGSXVJBdVEl2cQU5JRUUllVTXFFNcXk1lda6N2X6t/NjyjVt6NnWmy9+TmDJ7mR7ua6tvBjVJQgfiwlfiwt+7i74WEx4uhox6vUY9DqMBh0GvQ4dOgrKKskpriS3pJLc0krySirxdDUR5mchzN9CG1+3c38026yQnwCZx7UpxrlnwGZF6aCs0kZRhZXC8mqKyyooLSujrLwcrJW4UI0RKyajnhAvM8FerrgY9FowojhDy992seCKwQwuFjC5a6M+TG7aSJPceCjLbdS+tDNZtJEm3m21xQQqirTgUVkelOejygvQGVy04IarV82j97mRtKXZWjCmvKDmgDpw80FZAigxeJOjPHD18CXI3w+di7s2ndnFHSpLIeektvpjzimoLHasl4uHVh+PEO2a0L+Dlvi/9rFmWnS11cb/W3eCeZvP3fwL97fw9/FdGBcViK40R2tTQIdG+8gkCNJI5GJECHHFWKsgdZ8WTEjcrp1U2o/QfnzDHcsqpZ2MEn/WXlNdfu6Oiaq5q1CQAlnHtSGav5FN6cjU+WNyccG/MrX+QiZ3uOFf0Puuc3cqrFWUrP477vs+AmCHrQvHbW1xoRoXXTWmmguRdOVHoimCbr0Hcf2oEXh6ekPybqqWP4opW1tK+UdrL+ZZb+Q+w3eMNewBoFC58YXpNhZXDCCzyo0yzGgTlSHIU7uwqc2REuhpJiW/jGV7tdEVPhYTc6/vwu1925JfVsW/vjvOol1JgKKdaynTo/1Q7kGUKleqbIpKq8Jqs+FjcSHQw0yApwuBHq4EeLpQUmElOa+UlPwyUvLKSM4rY2d8LumF5+ZJdwzyYFy3EI6nF7HlVJY9UFHLw2zk5Vu6c0ufUIfth5ILeOjLPaTkn7sg83d34aN7+hId5lunG5JyS3lu5RF+OJ55wT4d2N6PW/uEMr5HK7xcTRSWV3E8rYjj6YUcSyviWFohfx3XmcEdAi54nMsh59DLJ5+ZEOLXyiws5/X1J4gM9OD2vm3rzRl1NLWQZ5YfYm9i/mUdu62fG7f2acPk6FDC/R1zf2UUljM/9gwLdiRSWjPasrHodNDKy5Vgby1w4WLUYzZqjwAJOaXEZ5c0+L56HbQLcKeovJqsmpEwLgY9N/ZqxfRB7fCzuFBYVklJQQ6VecnYClMx6XV4+wbgFxCEv38QLh6+YGzgRolSVBVmkHFqPwUJB7BlHsNWVUmp2Z9yF38qzP5UugWSVmlhS3wBifmVWNFjVVpgJ0SXS7gug3BdBn08cunqlotvRSqmsqxG/Rx/E51BW12oLL/+pLu/ZAnAavbibLGRtHITRVgI8PWhsigbH2sugboCAnSFWp4a7zB47FCjVVWCII1ELkaEEE7FZoP8s5B5DGv6EXIzk8mwepFY6cmpUgtHCl05km/CTCXelOClK8GHErx1JVRhxC2oPREduxHdowdRbWqSrBakQPxmiP8JzvwERanQOhomz294yd+DS1Cr5qC7pIBMzTDSvLOAAos/SQOe48ljHdlxNo/W3q78ISSBaXnz8C087vBKq85AMe7k2SyUKxMmtECLSWfFRDV6bGQpH/BqTbuIDpj92p47kWefpDj1GCr7JJ7q3F2OUmUmU/mQiQ85ygsDNsxUYdZVaY9Ukac8iFchxKtWnFGtiFch5Cov2rmVcXMHE9eF6Qg3l6ArzweLH5WWVuwvsLA+2cCG+Eoi/Uy8PMREq4p47W5W5jHtzk7rPhA2kPyAaGZ9m8nWUzm0D3Dnk/v6Ee6l1+445Z7WRgVVlWt3rmoeq6qtlBm9KDF4U6z3Jl/nSVqlK5tO5nIwKR8dCh1gNkCwBUqLC/CgDHfK8dBpjx0GT+S2CeN/xT+8+sk59PLJZyaEuNJsNsXXe5NZdzgdd7ORgJpAf4CHmQAPF7zdTHi6mvAwG/FwNeLuYrykPGN5JZUs3ZtMUm4puaVV5JdWkldaSV5JFcUV1dhsimqbotpmo8qq/QnqYzHhZ3HB171m1IibFqRPyCklMbf0koMqRr2OMH8LkYEedAjyoHOwJ52CPWkf6I6ryUBltY21h9P4ZOtZ9iflX/JnpdNBgIeZQA8zZpPeIRCj0+lIyCkhPrvE3p6LcTHqGdYhgLHdghnSIYB9ifks25vM5pPZWM+bQ22mkhBdLqG6bEJ12fhRRDFu5CsPCnCnQLlTiAUXqvGkFC9dCZ28bQxqbSLAw8TZMgvHi8wczDNxON9EMRa8KMFPV4QfRbRxLaW7TxU5OTkYbWVYqMDfpYruAUZC/b2o9o2kzLs95V7tKXVvS5nNQHZxJXn5eZTnplBVkA5FaYTps+hsTCO4KgW3wnh0lzEqxqZ05LsEY/jzIbwbKcm7BEEaiVyMCCGaG6tNUVFtpbLaRqXVpj1W2/D3MOPtZrrwi5XS/lh38734PNWsE3B4qfYao8u55GQ6vRbwyDii/ZRmn3tNz6kw7p/g7g9ASUU1FheDFoyxWeHAIoh9HfIStBEwjUSho1JnxqwuN+P9r2B01ZKpXWSOsfJqTa5PD7x1pRjz4qEw5aKv+a3yR72Gz7UPNdrx5Bx6+eQzE0K0FEqpC+axUkqRXVxJYm4p2cUV9uuVKqt2/WK1Kdr4Wmgf6E6YnwXTJSY735eYx6fbzrL2cDoGXc00UjcjXq7atJ2yKitpBeWkFZRTWV13OlB93F0MdAj2pFOQB34eLlRbFVVWLdhTZbXhYtRzbccAhnUMxN1cN8l9VlEFKw+ksmJ/Cqn55VhcDFhcDLjVPHqYjbT2cSPUx402vto0IX8PF7afyeHbg2n8FJd1wUBMkKeZvu18GRDhz4D2fnQK8kSv11FQVsXCnYl8uvWsw2jWX8PNZKB/COSlncVsLSHSy8qcIcG0dq2EyhJttSGPYDLxIWZnEV8eLqGVrwcbHh+Oq6lx8oRIEKSRyMWIEEJcYcWZWjDE4g+tel7aa5TSTqjlNUnLygu0KUL2LPA1y+tBzXzf1JqfFC3Bl9lLyyof0BH8O2ojWkxu2jGL0rU6Fadrc2oNJi1wYXABoyvKYIKSLHQ5p7W5srWP1WXalCb3AG0pZPdALVhUmqO9b2GKY14Xi39NErWuEBQFZk9I3g1J2yHtYP1BHrM3+LfX5uGaXMHodu5Rp9NGuJTmnPspy9WmTdVk/Vc6PVYbWPUuGN08Mbh6aQnOXDy09+95B0SO/K09aifn0Msnn5kQQlwdlxKEyS2pJK2g/FwQ5rybR1U2RRsfNzoGexDq49akickLyqpYfySdNYfSyCutonOwJ51DPOkSoj36XyTvWWW1jW8PpfLxlrMcTy/EZNBj1OswGfSYaka/+Htoo4UCPbWRMf4eLqTkl3EgKZ/DKYUUV1TbjzeycyD/vqMP3paGb67tT8qnpKKaIU0wDVeCIA2IiYkhJiYGq9VKXFycXIwIIYRomM0G1oqLL5FXVa5NJzK5a0nFGrpgqiyBlD1aMMTiB36RWqDG4t84meKvEvmD/vLJZyaEEMLZ2GyKM9nF7E8qwN3FwLhuIdpqgleZBEEaiVyMCCGEEL+OnEMvn3xmQgghxK9zqefQS5s4JYQQQgghhBBCCOHkJAgihBBCCCGEEEKIFkGCIEIIIYQQQgghhGgRJAgihBBCCCGEEEKIFkGCIEIIIYQQTSwmJoauXbvSr1+/pq6KEEII0axJEEQIIYQQoonNmjWLo0ePsmvXrqauihBCCNGsSRBECCGEEEIIIYQQLYIEQYQQQgghhBBCCNEiGJu6Ar93SikACgsLm7gmQgghhHORc+flk+sOIYQQ4tepPXfWnksbIkGQBsTExBATE0NlZSUAbdu2beIaCSGEEKK5KyoqAuS6QwghhPi1ioqK8Pb2bnC/Tl0sTNLC2Ww2UlNT8fT0RKfTXdZrCwsLadu2LUlJSXh5eV2hGl59zbFdzbFN0Dzb1RzbBM2zXc2xTdA823Wl2lR7ieHl5XXZ59CW6rdcd4D8+3QmzbFdzbFN0Dzb1RzbBM2zXc2xTXBl2qWUoqioiNatW6PXN5z5Q0aCXIRer6dNmza/6RheXl7N6h9srebYrubYJmie7WqObYLm2a7m2CZonu1qjm1yNo1x3QHNsy+bY5ugebarObYJmme7mmOboHm2qzm2CRq/XRcaAVJLEqMKIYQQQgghhBCiRZAgiBBCCCGEEEIIIVoECYJcQWazmeeeew6z2dzUVWlUzbFdzbFN0Dzb1RzbBM2zXc2xTdA829Uc29RSNce+bI5tgubZrubYJmie7WqObYLm2a7m2CZo2nZJYlQhhBBCCCGEEEK0CDISRAghhBBCCCGEEC2CBEGEEEIIIYQQQgjRIkgQRAghhBBCCCGEEC2Csakr0JwlJSWRkZFBp06dnHZN57S0NE6fPk2PHj0aXHPZ2dqZm5tLQkIC4eHh+Pn51VumoqKCI0eO4O7uTufOna9yDX+d+Ph4iouLiYiIwMPDo94yztZXtQ4ePEhhYSGDBw9Gr3eM3ZaXl3P06FE8PDzo1KlTE9Xw0pw6dYr09HSHbR4eHvTu3btO2cTERDIzM52qrzIyMkhJSSEqKgo3N7c6+52pr7Zt24bNZquzvVWrVkRGRjpsc7a+KigoID4+Hjc3N9q3b4/JZKpTxpn6SpzjjOeuX7LZbOzZswdXV1d69OhRbxlna6fVaiUuLg6j0UhERARGY/2X3852ji4pKSEuLg5/f3/CwsLqLeNsfVUrPz+fw4cP06ZNG9q1a1dnv7N871dWVrJz584627t27VrnGtgZv/etVqu9zhEREfWWcZa+Sk5O5uzZs/XuGzBggMO52tn6ymazcfbsWfLy8ggLCyMwMLDecle1r5RodGVlZWrSpEnKzc1NdenSRbm5uam33367qat1WXbt2qUmT56sAgMDFaA2bdpUp4yztXP//v1q7Nixys/PT/Xu3VtZLBY1depUVVJS4lBuzZo1yt/fX7Vv3175+vqqa665RqWmpjZRrS9uxYoVqkuXLqpTp06qa9euymKxqGeffdahjLP11fk2b96sTCaTAlRRUZHDvlWrVik/Pz8VGRmpfHx8VP/+/VV6enoT1fTiZs6cqQICAtSQIUPsP/fee69DmdLSUjVx4kRlsVjsfRUTE9NENb40eXl56tZbb1Xu7u6qb9++KiwsTC1YsMChjLP11ahRoxz6qW/fvgpw+L/ljH312GOPKTc3N9W7d28VHh6uWrVqpVavXu1Qxtn6Smic7dz1S5WVlerVV19V7du3V97e3mr48OH1lnO2dr788ssqODhYRUVFqXbt2qnQ0FC1atUqhzLOdo7Ozc1V999/v/Lz81PR0dH266qjR486lHO2vqpls9nUuHHjlF6vV0888YTDPmf73k9KSlKAio6Odjinbd682aGcM37vL168WAUHB6vIyEjVrVs3NXbsWJWTk2Pf72x99eWXXzr00ZAhQ1RQUJBydXVVxcXF9nLO1ld79+5VnTt3ViEhISo6OlpZLBY1ZcoUVVZWZi/TFH0lQZArYO7cuapNmzb2L/pvvvlGAWr79u1NXLNL98knn6jFixerM2fONBgEcbZ2LlmyRK1fv97+PCkpSYWGhqrHHnvMvi0rK0t5enqqF198USmlXZgMHDhQjR8//qrX91LNmzdPJSQk2J9v3LhRAer777+3b3O2vqqVk5Oj2rVrp5544ok6QZD09HTl4eGh/vnPfyqltC/Qfv36qZtuuqmpqntRM2fOVHfccccFyzz55JMqLCzMfkJbsmSJ0ul0avfu3Vejir/KyJEjVb9+/VR2drZSSqni4mL16aef2vc7Y1/90ueff650Op06efKkfZuz9dWaNWsUoLZt22bfNnv2bOXr66usVqtSqnn0VUvkjOeuX8rPz1d/+9vf1OnTp9XMmTPrDYI4Wzurq6vV008/7fCH2XPPPacsFotKS0uzb3O2c/TRo0fVwoUL7d8b5eXlasyYMWrIkCH2Ms7WV+d77bXX1IQJE1S3bt3qBEGc7Xu/Nghy7NixBss44/f+Dz/8oPR6vcO1xsaNGx0Ccc7WV79ks9lUZGSkuvvuu+3bnLGv+vfvryZMmKCqqqqUUkrFx8crT09P9dZbb9nLNEVfSRDkCggODlbPP/+8w7bu3burBx98sIlq9OvVfnnWFwRpDu186KGHVL9+/ezP33vvPWWxWBxGh3z99ddKp9M5xd0LpbS7aUaj0eHE4Kx9NXHiRPX888+rJUuW1AmCvP3228rDw8Mhkrxo0SKl1+tVRkZGU1T3ombOnKkmTpyodu/erU6fPm2/gKxls9mUv7+/evnllx22R0VFqVmzZl3Nql6y2qDbzp07GyzjjH31S8OHD1ejRo2yP3fGvvrss8+UyWSyX4gopdTChQuVwWBQpaWlSqnm0VctUXM4d52voSBIc2hnenq6AtS3335r3+as5+jz/eMf/1Dt2rWzP3fWvtqxY4cKDQ1VGRkZdYIgzvi9X3sd/91336k9e/aogoKCOmWc8Xt/2LBh6oYbbmhwvzP21S9t2rRJAQ6jdpyxryIiIup8v3Xu3Fk99dRTSqmm6ytJjNrIUlNTycjI4JprrnHY3r9/f/bt29dEtWp8zaGdSin27NlDhw4d7Nv27dtHVFQUFovFvq1///4opdi/f38T1PLS5Ofns2XLFtasWcO0adPo1asXkydPBpy3r9555x0yMzN55pln6t2/b98+unXrhqurq31b//79sdlsHDhw4GpV87KtWbOG++67j4EDBxIREcG6devs+5KSksjJyanTV/369fvd9tXGjRsJDg6mX79+nDhxgiNHjlBRUeFQxln7qtapU6fYvHkzf/zjH+3bnLGvJk2aRJ8+fbjnnntYt24dX331Fc8//zwvvPCCPYeLs/dVS+Ws567L1RzauWvXLgB7biFnPUeDlq/rp59+4oMPPmDevHm88MIL9n3O2FeFhYVMmzaNefPmERQUVGe/M37v17r33nuZPn06AQEB3HfffZSUlNj3Odv3fllZGdu2beOmm26isLCQ3bt3k5aW5lDGmfuq1n//+186d+7MsGHD7Nucra8AXnrpJT766CM+/vhjNmzYwBNPPEF1dTUPPfQQ0HR9JYlRG1lubi4A/v7+Dtv9/f3t+5qD5tDON954gwMHDvDhhx/at+Xm5tbbptp9v1cnTpxg7ty5ZGdnk5mZyeuvv25PjuqMfbV//35efPFFduzYgcFgqLeMM/bVDTfcwKuvvkpgYCDV1dX87W9/Y/LkyRw+fJh27dpdsK/qS2z2e5CamkpAQADXX389Z86cASA7O5t33nmHu+66C3DOvjrfxx9/jJ+fH7feeqt9mzP2lYeHB3PmzOGxxx7j0KFDFBQUEBoaag+YgvP3VUvVUvrN2duZnZ3N7Nmzuf322+1JQp3xHF0rJiaG/fv3ExcXx+DBgxk9erR9nzP21QMPPMD48eOZMGFCvfud8Xvf1dWVr7/+2v49f+zYMUaOHMlf//pXYmJiAOfrq8zMTKxWK/v37+eFF16gVatWnDx5kqFDh/K///0PX19fp+yr8xUUFLB06VJeeuklh+3O1lcAo0ePpm/fvvz9738nNDSUM2fO8PTTT9OmTRug6f5fyUiQRlabube8vNxhe1lZGS4uLk1RpSvC2dv5xRdf8NRTT/HZZ585rMxhMpnqbRPwu27XgAED2LJlC8ePH2fZsmU8/PDDfPXVV4Bz9tX06dO5/fbbSU1NtbcL4OeffyYxMRFwzr6aNGmSPSO20WjktddeQ6fTsWrVKsA5+8pkMnHkyBHGjRtHXFwccXFxPPvss8yYMYP4+Hh7GWfrq1pWq5XPPvuM6dOnYzab7dudsa+WLl3KjBkzWLVqFQcPHuTs2bMMHz6c4cOHU1hYCDh3X7VkLaXfnLmdBQUFXH/99YSEhDB//nz7dmf8Lqk1b948duzYQUpKCmazmbFjx9pX1XK2vlq2bBnr169n4sSJbNmyhS1btlBaWkpKSgpbtmwBnLOvAgICHALdUVFR/PnPf2bRokX2bc7WV7X9sGHDBg4dOsTevXuJj4/n5MmT/PWvf3Uo40x9db7//e9/WK1Wpk+f7rDd2fpKKcW4ceMwmUwkJyezd+9eDhw4wOuvv85rr70GNF1fSRCkkbVt2xa9Xk9KSorD9pSUlAaXD3NGztzOBQsWMHPmTD755BOmTp3qsC88PLzeNgG/+3bVGjFiBP3792ft2rWAc/ZVaGgoBw4cYO7cucydO5cFCxYA8Nxzz7FhwwagefSV0WjEz8/Pod46nc6p+qp26cDaYY0ADz74IJWVlezYsQNw7r5au3Ytqamp3H///Q7bnbGvVq9eTd++fRkwYAAAOp2ORx55hMzMTLZv3w44d1+1ZC2l35y1nYWFhYwdOxaDwcB3332Hp6enfZ8znqN/yWKxMGvWLI4ePWq/UeFsfWW1WunatSsvvPCC/dojIyOD2NhY5s6dCzjn9359goODyc3Ntf/R6Wx9FRwcjKurK5MnTyYgIAA4F+yJjY0FnL+v/vvf/3LLLbfUWUrW2foqMTGRgwcP8sADD9iDHeHh4dx4442sXLkSaLq+kiBII7NYLAwePNjesaCto75hwwbGjBnThDVrXM7azoULFzJjxgw+/vhj+1D9840ZM4bTp09z9OhR+7YVK1bg5+dHdHT01azqJbHZbHUip1VVVSQmJtqHlTljX61du9Z+J2bLli324YDr169nxowZgNZXJ06cIC4uzv66FStWEBgYSK9evZqk3hdis9ns0fpax48fJykpie7duwPg6enJgAEDHPqqqKiIH3744XfbV+PGjQNwOHnV/l578na2vjrf/PnzGTJkCF27dnXY7ox9FRgYSFpamv1OLWhzcWv3gXP3VUvmbOeuX8sZ21kbAAHtHObt7e2w3xnP0efnk6h16tQpDAYDPj4+gPP11W233eZw3bFlyxYiIiKYOnWqfSSIM37v19dX69evJzIy0p5Xwtm+9w0GA9ddd12dP5qTk5Pt5zJn7KtaBw4cYM+ePQ55yGo5W18FBASg0+lITk522J6UlNT0fXXFUq62YD/++KMymUxq7ty5asWKFeq6665TkZGRDitb/N5lZGSo2NhYtWzZMgWot99+W8XGxjosxeps7VyxYoUyGAzq4YcfVrGxsfafX65qMXbsWNW1a1e1ZMkS9Z///EeZzWb13nvvNVGtL6y0tFR169ZNvfXWW2rdunXqq6++UqNHj1YBAQHqzJkz9nLO1le/VN/qMDabTY0aNUr16NFDLVmyRL311lvKxcVFzZs3rwlr2rDS0lLVtWtX9eabb6rvvvtOzZs3T4WFhakBAwaoiooKe7mNGzcqo9GonnrqKbV8+XI1atQo1bFjR4c14n9vpk2bpqKjo9WyZcvU0qVLVXR0tBo4cKB9FRJn66ta6enpdVZaOp+z9dXx48eVxWJRd9xxh1qzZo1asGCB6tixoxo2bJh9pSJn7SvhXOeuhuzatUvFxsaqG2+8UfXu3dt+nj6fM7WzsrJSDR48WAUFBanVq1c7XHvULgWplPOdo1966SV17733qoULF6p169apV155RXl5edVZTtaZ+qo+9S2R62zf+y+++KKaPn26WrhwoVq1apWaOXOmMhqNaunSpfYyzvi9v2/fPuXp6amef/55tW7dOvX8888rg8GgVq5caS/jbH1V69FHH1URERHKZrPV2eeMfTVz5kwVGBioPvjgA7Vu3Tr12GOPKZ1Op9atW2cv0xR9pVNKqSsXYmm5tm7dSkxMDBkZGfTo0YO5c+cSEhLS1NW6ZGvXruWVV16ps33GjBn2O/HgXO186623WLp0aZ3tQUFBLFu2zP68tLSUN998k82bN2OxWLjrrru47bbbrmZVL0tqairvvvsu+/btw93dnT59+vDQQw/VSTDkTH31Sz/++CPPPPMM33//vX0VC9DucLzxxhvExsbi4eHB3XffzaRJk5qwpheWkpLCu+++y/79+/H19WX48OHMnDkTo9ExR3VsbCzvvfcemZmZ9OrVi7lz59abqf73oqqqivfee4/vvvsOFxcXBg0axJw5cxxWBXC2vgL45ptveOedd1i9erVDW87nbH118uRJ3nnnHeLi4ux3oB955BGn7yvhfOeu+tx22211VnkA7HfiwbnaWVBQ0GCSzblz53LjjTfanzvbOXrp0qV88803ZGVlERYWxu23317nrq0z9VV9pk+fzoABA5g1a5bDdmf63ldK8fXXX7N8+XLy8vLo2LEjDz/8MF26dHEo54zf+wcPHuTf//43iYmJhIWF8cADDzBw4ECHMs7UV6D118SJE7nxxht54IEH6i3jbH1ltVr59NNPWb9+PXl5eYSHh/PHP/6R/v37O5S72n0lQRAhhBBCCCGEEEK0CJITRAghhBBCCCGEEC2CBEGEEEIIIYQQQgjRIkgQRAghhBBCCCGEEC2CBEGEEEIIIYQQQgjRIkgQRAghhBBCCCGEEC2CBEGEEEIIIYQQQgjRIkgQRAghhBBCCCGEEC2CBEGEEC3S1q1b2b17d1NXQwghhBAtQEFBAYsWLaK8vLypqyJEiydBECFEi/TWW28xf/78pq6GEEIIIVqApKQkpk2bRn5+flNXRYgWT4IgQgghhBBCCCGEaBGMTV0BIUTLs2/fPhISEggPD6dXr17o9efisVu3bsVsNtOpUyf27dtHWVkZ1157LRaLxeEY1dXVbN++naysLLp06UJUVFS973Xw4EHOnDlDVFQUnTt3rrO/uLiYffv2UV5ezoABA/Dy8mrcxgohhBCiSeXn57N9+3b0ej19+vQhMDDQvq+goIC1a9dyyy23cPbsWeLi4ujQoQNdu3atc5zk5GT27NmDxWJhyJAhda5Nao+3Y8cO9Ho9gwYNwt3dvU6ZkydPcuLECdq1a0f37t0bt7FCiIuSIIgQ4qrJy8tj0qRJxMfH06tXL44cOUJwcDArV67E398f0KapJCQkkJmZSZcuXYiPj6eiooIffviByMhIQLsIGTt2LGVlZXTp0oWtW7dy66238umnn6LT6QDIzc1lypQpHDx4kP79+xMfH8/o0aN599137fXZu3cv0dHRdOjQgcTERPLy8tiyZQsRERFX/8MRQgghRKP78ssvmT17Nn369MFkMrFjxw7efPNNZsyYAZybpjJ+/HjOnDlDWFgYsbGxPP7447zyyiv247z22mu88MILDBo0iKysLDIyMlixYgUDBw60l/n888+ZNWsWnTt3xtfXl6SkJL766it69eplL/Pggw8SHx9P27Zt+fHHH/nTn/7EP//5z6v3gQghQAkhxFVy5513qilTpqiqqiqllFJVVVXq+uuvVw8++KC9zOTJk5Ver1fbt29XSilVWVmprrvuOnXzzTfby0yZMkUNHTpUlZWVKaWUOnbsmHJzc1MLFiywl7nttttUr169VE5Ojn3b8uXLHd7Hy8tLnTlzRimllNVqVQMGDFBz5sy5Ai0XQgghxNV25MgR5e7urnbs2GHftnnzZuXq6qrOnj2rlFLq0KFDClA333yzqq6uVkoptWnTJqXT6dSePXuUUkodPHhQ6fV6tXr1avtx7rvvPhUVFWW/pjlw4IAyGAxq/vz59jLJyclq165dDu8ze/Zs+/7Vq1crg8GgMjMzr9AnIISoj4wEEUJcFSUlJSxevJi5c+eyfPlylFIopQgLC2PTpk0OZa+99loGDBgAgMlk4vHHH2fChAmUlZVhNBr55ptvWLJkCa6urgB06dKFyZMns2jRIu68806Ki4tZtmwZCxYswM/Pz37ciRMnOrzPuHHj7KM+9Ho9w4YN49ChQ1fyYxBCCCHEVfLll18SGhpKYmIiCQkJKKUAsFgsbNu2jfDwcHvZxx9/HIPBAMCIESPo168fS5YsITo6msWLF9O9e3cmTJhgL//000/ToUMHDh48SHR0NAsWLKBjx47MnDnTXiY0NJTQ0FCHOj300EP230eMGIHVauX06dMOU3SEEFeWBEGEEFdFSkoK1dXV7Nmzh5MnTzrsGzp0qMPzdu3aOTyPiIhAKUVSUhJGoxGr1Ur79u0dykRGRvLNN9/Y38tqtdKpU6cL1un8AAmA2WyWpeuEEEKIZuLs2bOUlZXx9ddfO2wfM2YMPj4+Dtvqu/ZISEgAICEhoc51R0REBHq9noSEBKKjo0lMTLzodQc4XnuYzWYAufYQ4iqTIIgQ4qqoTTj66KOPcsMNN1ywbF5eXr3PAwICMBq1r63c3FyHMrm5uQQEBADYL2xycnJ+c72FEEII4Zy8vLwICQlh0aJFFy2bl5fnMDIkLy/PnlA9ICDAHhCplZ+fj81mc7j2SEpKasTaCyGuFFkiVwhxVYSEhNCrVy8++OCDOvtSUlIcnm/atImCggL782XLltGlSxf8/Pzw8vKiR48eLFu2zL6/srKSlStX2keUBAcH07NnTz7//HOH42ZlZTVmk4QQQgjxO3b99dezZ88edu3a5bA9Pz+f0tJSh23Lly+3/56VlcWWLVsYMmQIoI1Y3b59O6mpqfYyS5YswcvLi549ewIwduxYduzYwYkTJxyOm52d3ZhNEkI0AhkJIoS4aj788EPGjRvHuHHjuPXWWykuLmb9+vVcc801vPrqq/ZyJpOJUaNGcf/99xMXF8e7777L0qVL7fvfeustbrjhBqxWK7169WLBggXo9XqeeOIJe5n333+fcePGMXnyZMaNG0d8fDzbt2+vk39ECCGEEM3TxIkTmTZtGmPGjGHOnDmEh4dz9OhRVq5cyebNmx2WuP3ggw8oKSmhffv2vP/++3Tr1o3bbrsNgEmTJjF06FBGjRrFo48+SlZWFv/617/417/+hbe3NwC33HILEydO5Nprr+VPf/oTPj4+LF26lDlz5tTJSSaEaFoyEkQIcdX079+fo0ePMmLECH7++WcyMzOZO3euQwAEYMqUKbz00kucOHGC0tJSNmzYwM0332zfP3r0aHbu3Imbmxtbt25l/Pjx7N692z7lBmDw4MEcOnSI7t27s23bNvz8/Fi5cqV9/9ChQ+nXr5/D+/bs2ZNRo0ZdodYLIYQQ4mrS6XR8+eWXfPnll+Tl5fHzzz/Ttm1bdu7cSatWrRzKbty4ET8/P3bt2sXUqVPZuHEjev25P5XWrFnDn//8Z/bs2UN2djYrV65k9uzZDu+1ePFi3nnnHc6ePcvx48f5xz/+YQ+A+Pj4cMcdd+Dm5mZ/jV6v54477iAoKOgKfxJCiPPpVG2aZCGE+B2YMmUKAQEB9U6bEUIIIYRoTIcPH6ZHjx6kpaUREhLS1NURQlwFMhJECCGEEEIIIYQQLYLkBBFC/K4MHToUT0/Ppq6GEEIIIVqA+qapCCGaN5kOI4QQQgghhBBCiBZBpsMIIYQQQgghhBCiRZAgiBBCCCGEEEIIIVoECYIIIYQQQgghhBCiRZAgiBBCCCGEEEIIIVoECYIIIYQQQgghhBCiRZAgiBBCCCGEEEIIIVoECYIIIYQQQgghhBCiRZAgiBBCCCGEEEIIIVoECYIIIYQQQgghhBCiRfj/938kKOxtCToAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1100x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training time:  xnn 759s   nequip 733s\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_nequip[\"train\"], label=\"nequip\")\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_nequip[\"val\"], label=\"nequip\")\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   nequip {t_nequip:.0f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f291d6",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "57769669",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:30:21.899701Z",
     "iopub.status.busy": "2026-07-20T05:30:21.899623Z",
     "iopub.status.idle": "2026-07-20T05:30:26.555739Z",
     "shell.execute_reply": "2026-07-20T05:30:26.554677Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "metric                        xnn   original NequIP\n",
      "----------------------------------------------------\n",
      "energy RMSE [meV/atom]       15.33             15.04\n",
      "energy MAE  [meV/atom]       10.59             12.13\n",
      "force  RMSE [meV/Å]           2.07              1.99\n",
      "force  MAE  [meV/Å]           1.31              1.24\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_nequip(model):\n",
    "    model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n",
    "    for s, d in zip(test_structs, nequip_test):\n",
    "        b = next(iter(NequipDataLoader([d], batch_size=1))).to(DEVICE)\n",
    "        out = model(AtomicData.to_AtomicDataDict(b))\n",
    "        Ep.append(float(out[\"total_energy\"].sum().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_n = metrics(*eval_nequip(nequip_model))\n",
    "\n",
    "print(f\"{'metric':<22}{'xnn':>12}{'original NequIP':>18}\")\n",
    "print(\"-\" * 52)\n",
    "print(f\"{'energy RMSE [meV/atom]':<22}{res_x['e_rmse']:>12.2f}{res_n['e_rmse']:>18.2f}\")\n",
    "print(f\"{'energy MAE  [meV/atom]':<22}{res_x['e_mae']:>12.2f}{res_n['e_mae']:>18.2f}\")\n",
    "print(f\"{'force  RMSE [meV/Å]':<22}{res_x['f_rmse']:>12.2f}{res_n['f_rmse']:>18.2f}\")\n",
    "print(f\"{'force  MAE  [meV/Å]':<22}{res_x['f_mae']:>12.2f}{res_n['f_mae']:>18.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e06e319",
   "metadata": {},
   "source": [
    "### Side-by-side parity plots\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "93686b71",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:30:26.558973Z",
     "iopub.status.busy": "2026-07-20T05:30:26.558849Z",
     "iopub.status.idle": "2026-07-20T05:30:27.565992Z",
     "shell.execute_reply": "2026-07-20T05:30:27.565139Z"
    }
   },
   "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_nequip.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_n, \"original NequIP\")]):\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_nequip.png\", dpi=120); plt.show()\n",
    "print(\"saved argon_parity_xnn_vs_nequip.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4626de3",
   "metadata": {},
   "source": [
    "## 6. `xnn` ASE calculator (deployment)\n",
    "\n",
    "`xnn` ships an ASE `Calculator` for the trained model, the same one used for the\n",
    "xnn MACE, because every xnn model shares the `AtomicGraph -> energy` contract.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "aa119531",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T05:30:27.568275Z",
     "iopub.status.busy": "2026-07-20T05:30:27.568154Z",
     "iopub.status.idle": "2026-07-20T05:30:27.937460Z",
     "shell.execute_reply": "2026-07-20T05:30:27.936624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ASE single point: E = -27.9015 eV (-69.8 meV/atom) | max|F| = 0.0871 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": "c57a9f8d",
   "metadata": {},
   "source": [
    "## Summary: every stage compared\n",
    "\n",
    "| stage | result |\n",
    "|---|---|\n",
    "| **Data → graphs** | xnn and `nequip` neighbour lists give the **identical edge set** (same counts) |\n",
    "| **Model build** | identical architecture; parameter counts match except xnn's 200-entry `atom_ref` table ($E_0$ shift) |\n",
    "| **Same function?** | transplanting weights gives **identical E and F on periodic Argon** (float32 round-off; ~1e-15 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",
    "The `xnn` NequIP is a faithful, dependency-light (only `e3nn`) re-implementation\n",
    "of the original NequIP: it not only matches block-by-block (notebook 01) but\n",
    "delivers an **equivalent end-to-end training/testing pipeline** on realistic Argon\n",
    "data. The small residual differences in trained metrics come only from independent\n",
    "random initialisation and data shuffling; apply the transplant of Section 3b\n",
    "before training to start both from identical weights if exact-match training\n",
    "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` (autograd strain trick on the\n",
    "xnn side, `StressForceOutput` upstream). The companion notebook\n",
    "`nequip_argon_density_md.ipynb` uses exactly that to run NPT molecular dynamics\n",
    "with both codes.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}