{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "42ae1df9",
   "metadata": {},
   "source": [
    "# Argon density from MD: `xnn` vs the original Allegro\n",
    "\n",
    "Computes the **mass density of liquid Argon** from **NPT molecular dynamics\n",
    "through ASE** with a trained Allegro potential, in the same two complementary\n",
    "tracks as the MACE/NequIP companions:\n",
    "\n",
    "* **Track (a): same potential.** The trained original-Allegro weights are\n",
    "  *copied* into `xnn`; any density difference reflects only the inference/MD\n",
    "  code path (should be ~zero).\n",
    "* **Track (b): independently trained.** `xnn` is trained from scratch on the\n",
    "  same data; densities are compared as two practitioners would.\n",
    "\n",
    "Pipeline per track: train → ASE calculator (energy + forces + **stress**) →\n",
    "NPT MD ($T=85$ K, $P=1$ bar) → $\\rho = M/V$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1940daaf",
   "metadata": {},
   "source": [
    "## 0. Setup: train `float32`, run MD `float64`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "11af09f0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:37:29.162257Z",
     "iopub.status.busy": "2026-07-20T04:37:29.162137Z",
     "iopub.status.idle": "2026-07-20T04:37:31.948781Z",
     "shell.execute_reply": "2026-07-20T04:37:31.947682Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn: 0.1.0 | allegro (original): 0.3.0 | device: cuda\n"
     ]
    }
   ],
   "source": [
    "# silence the expected warnings\n",
    "import logging, warnings\n",
    "logging.disable(logging.WARNING)\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=FutureWarning,\n",
    "                        message=\"You are using `torch.load` with `weights_only=False`\")\n",
    "\n",
    "import time\n",
    "import numpy as np\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import ase.io\n",
    "import ase.units as u\n",
    "\n",
    "torch.set_default_dtype(torch.float32)\n",
    "torch.manual_seed(0)\n",
    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "CUTOFF, SPECIES = 6.0, [18]\n",
    "DATA = \"../../../datasets/argon_md\"\n",
    "import xnn, allegro\n",
    "print(\"xnn:\", xnn.__version__, \"| allegro (original):\", allegro.__version__,\n",
    "      \"| device:\", DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "929a0e57",
   "metadata": {},
   "source": [
    "## 1. Load data and build both data pipelines\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e8161c5a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:37:31.950914Z",
     "iopub.status.busy": "2026-07-20T04:37:31.950820Z",
     "iopub.status.idle": "2026-07-20T04:37:40.636654Z",
     "shell.execute_reply": "2026-07-20T04:37:40.635798Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "193 configs | E0={18: 0.0} | lambda=17.78 | train 174 / val 19\n"
     ]
    }
   ],
   "source": [
    "from xnn.common.data import AtomicDataset, load_dataset\n",
    "from nequip.data import AtomicData\n",
    "from nequip.data.dataloader import DataLoader as NequipDataLoader\n",
    "from nequip.data.transforms import TypeMapper\n",
    "\n",
    "E0 = {18: 0.0}   # argon isolated-atom reference energy\n",
    "train_structs = load_dataset(\"argon_md\", split=\"train\")\n",
    "ds_all = AtomicDataset(train_structs, CUTOFF)\n",
    "train_structs = [s for i, s in enumerate(train_structs) if ds_all[i].num_edges > 0]\n",
    "\n",
    "TM = TypeMapper(chemical_symbols=[\"Ar\"])\n",
    "xnn_train = AtomicDataset(train_structs, CUTOFF)\n",
    "LAMBDA = float(sum(xnn_train[i].num_edges for i in range(len(xnn_train))) /\n",
    "               sum(xnn_train[i].num_nodes for i in range(len(xnn_train))))\n",
    "\n",
    "def to_upstream(s):\n",
    "    d = AtomicData.from_points(\n",
    "        pos=torch.tensor(s[\"pos\"], dtype=torch.get_default_dtype()), 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]*3),\n",
    "        total_energy=torch.tensor([s[\"energy\"]], dtype=torch.get_default_dtype()),\n",
    "        forces=torch.tensor(s[\"forces\"], dtype=torch.get_default_dtype()))\n",
    "    return TM(d)\n",
    "al_train = [to_upstream(s) for s in train_structs]\n",
    "\n",
    "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\"{len(train_structs)} configs | E0={E0} | lambda={LAMBDA:.2f} | \"\n",
    "      f\"train {len(train_idx)} / val {len(val_idx)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ccd0f66",
   "metadata": {},
   "source": [
    "## 2. Train the two models\n",
    "\n",
    "Same architecture (2 layers, $\\ell_{\\max}=2$ `o3_full`, 32 tensor channels),\n",
    "same data/loss/optimiser/schedule/split. Original with a native loop; `xnn`\n",
    "with `xnn.train.Trainer`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "47b17d7e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:37:40.638403Z",
     "iopub.status.busy": "2026-07-20T04:37:40.638321Z",
     "iopub.status.idle": "2026-07-20T04:49:37.741884Z",
     "shell.execute_reply": "2026-07-20T04:49:37.740984Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original Allegro trained 60 epochs in 193 s (final val 4.061e-04)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    0 | train loss 9.3339e-01 | val loss 1.7936e-01\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    1 | train loss 7.4252e-02 | val loss 1.2085e-02\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    2 | train loss 1.1073e-02 | val loss 2.6839e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    3 | train loss 4.4131e-03 | val loss 1.6396e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    4 | train loss 2.8103e-03 | val loss 1.3049e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    5 | train loss 2.0568e-03 | val loss 1.1053e-03\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    6 | train loss 1.7918e-03 | val loss 9.4939e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    7 | train loss 1.3174e-03 | val loss 8.5242e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    8 | train loss 1.0816e-03 | val loss 7.6886e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch    9 | train loss 9.3924e-04 | val loss 7.2583e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   10 | train loss 8.5024e-04 | val loss 7.0451e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   11 | train loss 7.8161e-04 | val loss 6.7192e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   12 | train loss 7.4336e-04 | val loss 6.5199e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   13 | train loss 6.9064e-04 | val loss 6.1449e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   14 | train loss 6.5856e-04 | val loss 6.3887e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   15 | train loss 6.9874e-04 | val loss 5.7859e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   16 | train loss 6.5901e-04 | val loss 5.5251e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   17 | train loss 5.9613e-04 | val loss 5.2888e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   18 | train loss 6.0417e-04 | val loss 5.3255e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   19 | train loss 5.5718e-04 | val loss 5.0468e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   20 | train loss 5.2535e-04 | val loss 4.8798e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   21 | train loss 5.1400e-04 | val loss 4.8761e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   22 | train loss 5.2655e-04 | val loss 4.9559e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   23 | train loss 5.0366e-04 | val loss 4.8256e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   24 | train loss 4.7429e-04 | val loss 4.5582e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   25 | train loss 4.6373e-04 | val loss 4.4049e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   26 | train loss 4.4726e-04 | val loss 4.6189e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   27 | train loss 4.4362e-04 | val loss 4.5016e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   28 | train loss 4.3721e-04 | val loss 4.2293e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   29 | train loss 4.1618e-04 | val loss 4.2283e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   30 | train loss 4.2706e-04 | val loss 4.6601e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   31 | train loss 4.2393e-04 | val loss 3.9880e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   32 | train loss 4.1589e-04 | val loss 4.0192e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   33 | train loss 3.9876e-04 | val loss 3.9462e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   34 | train loss 4.1270e-04 | val loss 3.8881e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   35 | train loss 4.1359e-04 | val loss 3.9523e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   36 | train loss 3.9687e-04 | val loss 3.6866e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   37 | train loss 3.7622e-04 | val loss 3.9155e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   38 | train loss 3.8085e-04 | val loss 3.7154e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   39 | train loss 3.8232e-04 | val loss 3.7094e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   40 | train loss 3.6297e-04 | val loss 3.8782e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   41 | train loss 3.7186e-04 | val loss 3.8430e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   42 | train loss 3.6196e-04 | val loss 3.7639e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   43 | train loss 3.6581e-04 | val loss 3.7024e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   44 | train loss 3.9327e-04 | val loss 3.7947e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   45 | train loss 3.7136e-04 | val loss 3.6896e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   46 | train loss 3.5533e-04 | val loss 3.3163e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   47 | train loss 3.6300e-04 | val loss 3.3912e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   48 | train loss 3.5166e-04 | val loss 3.5246e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   49 | train loss 3.4953e-04 | val loss 3.9673e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   50 | train loss 3.8315e-04 | val loss 3.5802e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   51 | train loss 3.5842e-04 | val loss 3.6046e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   52 | train loss 3.3230e-04 | val loss 3.3324e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   53 | train loss 3.5310e-04 | val loss 3.4285e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   54 | train loss 3.4336e-04 | val loss 3.5681e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   55 | train loss 3.3566e-04 | val loss 3.3169e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   56 | train loss 3.2688e-04 | val loss 3.3325e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   57 | train loss 3.3887e-04 | val loss 3.3419e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   58 | train loss 3.1849e-04 | val loss 3.3383e-04\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch   59 | train loss 3.1927e-04 | val loss 3.3496e-04\n",
      "xnn (independent) trained 60 epochs in 523 s\n"
     ]
    }
   ],
   "source": [
    "from nequip.model import model_from_config\n",
    "from xnn.common.config import from_dict\n",
    "from xnn.common.train import Trainer\n",
    "from torch.utils.data import Subset\n",
    "\n",
    "NL, LMAX, NF = 2, 2, 32\n",
    "TB, LAT, EE = [32, 64, 128], [128], [32]\n",
    "EW, FW, LR, WD, BS, EPOCHS = 1.0, 100.0, 0.01, 5e-7, 10, 60\n",
    "\n",
    "UPSTREAM_HP = dict(\n",
    "    r_max=CUTOFF, num_layers=NL, l_max=LMAX, parity=\"o3_full\",\n",
    "    num_tensor_features=NF, num_bessels_per_basis=8, PolynomialCutoff_p=6.0,\n",
    "    avg_num_neighbors=LAMBDA, chemical_symbols=[\"Ar\"],\n",
    "    two_body_latent_mlp_latent_dimensions=TB, latent_mlp_latent_dimensions=LAT,\n",
    "    env_embed_mlp_latent_dimensions=[], edge_eng_mlp_latent_dimensions=EE,\n",
    "    per_species_rescale_shifts=[E0[18]], per_species_rescale_scales=[1.0])\n",
    "\n",
    "# ---------- 2.1 train the ORIGINAL Allegro (native loop) ----------\n",
    "torch.manual_seed(0)\n",
    "al_model = model_from_config(dict(\n",
    "    model_builders=[\"allegro.model.Allegro\", \"PerSpeciesRescale\", \"ForceOutput\"],\n",
    "    **UPSTREAM_HP), initialize=True).to(DEVICE)\n",
    "\n",
    "tr_loader = NequipDataLoader([al_train[i] for i in train_idx], batch_size=BS, shuffle=True)\n",
    "va_loader = NequipDataLoader([al_train[i] for i in val_idx],   batch_size=BS, shuffle=False)\n",
    "opt = torch.optim.Adam(al_model.parameters(), lr=LR, weight_decay=WD)\n",
    "sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=10)\n",
    "def al_loss(out, b):\n",
    "    n = (b.ptr[1:] - b.ptr[:-1]).to(out[\"total_energy\"].dtype)\n",
    "    return EW * (((out[\"total_energy\"].squeeze(-1) - b.total_energy.squeeze(-1)) / n) ** 2).mean() \\\n",
    "         + FW * ((out[\"forces\"] - b.forces) ** 2).mean()\n",
    "\n",
    "t0 = time.time()\n",
    "for epoch in range(EPOCHS):\n",
    "    al_model.train()\n",
    "    for b in tr_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        loss = al_loss(al_model(AtomicData.to_AtomicDataDict(b)), b)\n",
    "        opt.zero_grad(); loss.backward(); opt.step()\n",
    "    al_model.eval(); vl = 0.0\n",
    "    for b in va_loader:\n",
    "        b = b.to(DEVICE)\n",
    "        vl += float(al_loss(al_model(AtomicData.to_AtomicDataDict(b)), b))\n",
    "    sched.step(vl / len(va_loader))\n",
    "print(f\"original Allegro trained {EPOCHS} epochs in {time.time()-t0:.0f} s \"\n",
    "      f\"(final val {vl/len(va_loader):.3e})\")\n",
    "\n",
    "# ---------- 2.2 train xnn INDEPENDENTLY (Trainer) ----------\n",
    "core = from_dict({\n",
    "    \"model\": {\"name\": \"allegro\", \"cutoff\": CUTOFF, \"n_features\": NF,\n",
    "              \"n_interactions\": NL, \"species\": SPECIES, \"l_max\": LMAX,\n",
    "              \"avg_num_neighbors\": LAMBDA, \"two_body_latent\": TB, \"latent\": LAT,\n",
    "              \"edge_eng\": EE, \"atomic_energies\": [E0[18]]},\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_md_indep\",\n",
    "})\n",
    "t0 = time.time()\n",
    "trainer = Trainer(core, Subset(xnn_train, train_idx), Subset(xnn_train, val_idx))\n",
    "trainer.fit()\n",
    "print(f\"xnn (independent) trained {EPOCHS} epochs in {time.time()-t0:.0f} s\")\n",
    "xnn_indep_base = trainer.model.model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "169daa3e",
   "metadata": {},
   "source": [
    "### Common MD utilities\n",
    "\n",
    "Switch to `float64`; rebuild the trained original with `StressForceOutput`\n",
    "(adds the barostat's stress via the strain trick, same convention as the xnn\n",
    "`ForceStressOutput`) and load the trained weights.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a2db8afc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:49:37.747289Z",
     "iopub.status.busy": "2026-07-20T04:49:37.747108Z",
     "iopub.status.idle": "2026-07-20T04:49:38.488433Z",
     "shell.execute_reply": "2026-07-20T04:49:38.487600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial density = 1.7910 g/cm³ | target T=85.0 K, P=1.0 bar | exp ~1.41 g/cm³\n"
     ]
    }
   ],
   "source": [
    "torch.set_default_dtype(torch.float64)\n",
    "from xnn.common.models import build_model, ForceStressOutput\n",
    "from ase import Atoms\n",
    "from ase.calculators.calculator import Calculator, all_changes\n",
    "from ase.md.nptberendsen import NPTBerendsen\n",
    "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, Stationary\n",
    "from xnn.common.deploy import XNNCalculator\n",
    "\n",
    "al_md_model = model_from_config(dict(\n",
    "    model_builders=[\"allegro.model.Allegro\", \"PerSpeciesRescale\", \"StressForceOutput\"],\n",
    "    **UPSTREAM_HP), initialize=True)\n",
    "# keep the float64 rebuild's exact Wigner-3j constants (the float32 model's\n",
    "# _big_w3j buffers are float32-rounded); load only the learned state\n",
    "sd = {k: v.double() for k, v in al_model.state_dict().items() if \"_big_w3j\" not in k}\n",
    "al_md_model.load_state_dict(sd, strict=False)   # only misses a dummy buffer\n",
    "al_md_model = al_md_model.to(DEVICE).eval()\n",
    "xnn_indep_base = xnn_indep_base.double().eval()\n",
    "\n",
    "class AllegroASECalculator(Calculator):\n",
    "    '''Minimal ASE calculator wrapping an in-memory original-Allegro model.'''\n",
    "    implemented_properties = [\"energy\", \"forces\", \"stress\"]\n",
    "    def __init__(self, model, cutoff, device=\"cuda\", **kw):\n",
    "        super().__init__(**kw); self.model, self.cutoff, self.device = model, cutoff, device\n",
    "    def calculate(self, atoms=None, properties=(\"energy\",), system_changes=all_changes):\n",
    "        super().calculate(atoms, properties, system_changes)\n",
    "        d = TM(AtomicData.from_ase(atoms.copy(), r_max=self.cutoff))\n",
    "        b = next(iter(NequipDataLoader([d], batch_size=1))).to(self.device)\n",
    "        out = self.model(AtomicData.to_AtomicDataDict(b))\n",
    "        self.results[\"energy\"] = float(out[\"total_energy\"].sum().detach())\n",
    "        self.results[\"forces\"] = out[\"forces\"].detach().cpu().numpy()\n",
    "        s = out[\"stress\"][0].detach().cpu().numpy()\n",
    "        self.results[\"stress\"] = np.array([s[0,0], s[1,1], s[2,2], s[1,2], s[0,2], s[0,1]])\n",
    "\n",
    "T_K, P_BAR, DT = 85.0, 1.0, 5 * u.fs\n",
    "N_EQUIL, N_PROD = 300, 700\n",
    "AMU_A3_TO_G_CM3 = 1.6605390666\n",
    "a0 = train_structs[0]\n",
    "\n",
    "def density(atoms):\n",
    "    return atoms.get_masses().sum() / atoms.get_volume() * AMU_A3_TO_G_CM3\n",
    "\n",
    "def compare_calcs(make_x, make_a):\n",
    "    at = Atoms(numbers=a0[\"atomic_numbers\"], positions=a0[\"pos\"], cell=a0[\"cell\"], pbc=True)\n",
    "    ax = at.copy(); ax.calc = make_x(); aa = at.copy(); aa.calc = make_a()\n",
    "    return (abs(ax.get_potential_energy() - aa.get_potential_energy()),\n",
    "            np.abs(ax.get_forces() - aa.get_forces()).max(),\n",
    "            np.abs(ax.get_stress() - aa.get_stress()).max())\n",
    "\n",
    "def run_npt(make_calc, label):\n",
    "    at = Atoms(numbers=a0[\"atomic_numbers\"], positions=a0[\"pos\"], cell=a0[\"cell\"], pbc=True)\n",
    "    at.calc = make_calc()\n",
    "    MaxwellBoltzmannDistribution(at, temperature_K=T_K, rng=np.random.default_rng(0)); Stationary(at)\n",
    "    dyn = NPTBerendsen(at, timestep=DT, temperature_K=T_K, pressure_au=P_BAR * u.bar,\n",
    "                       taut=100 * u.fs, taup=1000 * u.fs, compressibility_au=2e-4 / u.bar)\n",
    "    rho = np.empty(N_EQUIL + N_PROD)\n",
    "    t0 = time.time()\n",
    "    for k in range(N_EQUIL + N_PROD):\n",
    "        dyn.run(1); rho[k] = density(at)\n",
    "    print(f\"{label}: {N_EQUIL+N_PROD} steps in {time.time()-t0:.0f} s | \"\n",
    "          f\"rho_eq = {rho[N_EQUIL:].mean():.4f} g/cm³\")\n",
    "    return rho\n",
    "\n",
    "RHO_EXP = 1.41\n",
    "print(f\"initial density = {density(Atoms(numbers=a0['atomic_numbers'], positions=a0['pos'], cell=a0['cell'], pbc=True)):.4f} g/cm³ \"\n",
    "      f\"| target T={T_K} K, P={P_BAR} bar | exp ~{RHO_EXP} g/cm³\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2802587",
   "metadata": {},
   "source": [
    "# Track (a): same potential (weights copied Allegro → xnn)\n",
    "\n",
    "## 3a. Copy the trained original-Allegro weights into `xnn`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f741a5e8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:49:38.491985Z",
     "iopub.status.busy": "2026-07-20T04:49:38.491662Z",
     "iopub.status.idle": "2026-07-20T04:49:41.178770Z",
     "shell.execute_reply": "2026-07-20T04:49:41.177831Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "track (a) calculators on one Argon config (SAME potential):\n",
      "  dE = 1.28e-06 eV | dF = 6.60e-08 eV/Å | dσ = 3.08e-10 eV/ų  -> identical\n"
     ]
    }
   ],
   "source": [
    "def copy_fcn(fcn, mod):\n",
    "    sd = dict(mod.named_parameters())\n",
    "    with torch.no_grad():\n",
    "        for i in range(len(fcn.hs) - 1):\n",
    "            getattr(fcn, f\"layer{i}\").weight.copy_(\n",
    "                sd[f\"_forward._weight_{i}\"].to(getattr(fcn, f\"layer{i}\").weight.dtype))\n",
    "\n",
    "def copy_allegro_into_xnn(x, al_gm, n_layers):\n",
    "    seq = al_gm.model.func\n",
    "    al = seq.allegro\n",
    "    with torch.no_grad():\n",
    "        x.edge_feat.rbf.freqs.copy_(seq.radial_basis.bessel_weights.double() * float(al.r_max))\n",
    "        x.type_embeddings.copy_(seq.typeembed.type_embeddings.double())\n",
    "        copy_fcn(x.basis_embed, seq.typeembed.basis_mlp)\n",
    "        for i in range(n_layers):\n",
    "            copy_fcn(x.latents[i], al.latents[i])\n",
    "            copy_fcn(x.env_embed_mlps[i], al.env_embed_mlps[i])\n",
    "            x.linears[i].w.copy_(al.linears[i].w.double())\n",
    "        copy_fcn(x.final_latent, al.final_latent)\n",
    "        copy_fcn(x.edge_eng, seq.edge_eng._module)\n",
    "        x._resnet_params.copy_(al._latent_resnet_coefficients_params.double())\n",
    "        psr = seq.per_species_rescale\n",
    "        for k, z in enumerate(SPECIES):\n",
    "            x.atom_ref.weight[z] = float(psr.shifts[k])\n",
    "            x.atom_scale[z] = float(psr.scales[k])\n",
    "\n",
    "xnn_shared_base = build_model(core.model)          # fresh float64 model\n",
    "copy_allegro_into_xnn(xnn_shared_base, al_md_model, NL)\n",
    "xnn_shared = ForceStressOutput(xnn_shared_base, compute_forces=True,\n",
    "                                compute_stress=True).to(DEVICE).double().eval()\n",
    "\n",
    "def xnn_a():    return XNNCalculator(xnn_shared, cutoff=CUTOFF, device=DEVICE)\n",
    "def allegro_a(): return AllegroASECalculator(al_md_model, CUTOFF, DEVICE)\n",
    "\n",
    "dE, dF, dS = compare_calcs(xnn_a, allegro_a)\n",
    "print(\"track (a) calculators on one Argon config (SAME potential):\")\n",
    "print(f\"  dE = {dE:.2e} eV | dF = {dF:.2e} eV/Å | dσ = {dS:.2e} eV/ų  -> identical\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eefaf89d",
   "metadata": {},
   "source": [
    "## 4a/5a. NPT MD: same potential through both codes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5243c16b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:49:41.180695Z",
     "iopub.status.busy": "2026-07-20T04:49:41.180619Z",
     "iopub.status.idle": "2026-07-20T04:53:57.493137Z",
     "shell.execute_reply": "2026-07-20T04:53:57.492279Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1044677/1079695994.py:52: DeprecationWarning: Use thermalize_momenta\n",
      "  MaxwellBoltzmannDistribution(at, temperature_K=T_K, rng=np.random.default_rng(0)); Stationary(at)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn (a): 1000 steps in 154 s | rho_eq = 1.4133 g/cm³\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "allegro (a): 1000 steps in 102 s | rho_eq = 1.4133 g/cm³\n",
      "track (a)  rho_xnn = 1.4133   rho_allegro = 1.4133   |diff| = 4.82e-08 g/cm³\n"
     ]
    }
   ],
   "source": [
    "rho_xa = run_npt(xnn_a, \"xnn (a)\")\n",
    "rho_aa = run_npt(allegro_a, \"allegro (a)\")\n",
    "da_x, da_a = rho_xa[N_EQUIL:].mean(), rho_aa[N_EQUIL:].mean()\n",
    "print(f\"track (a)  rho_xnn = {da_x:.4f}   rho_allegro = {da_a:.4f}   \"\n",
    "      f\"|diff| = {abs(da_x-da_a):.2e} g/cm³\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45827723",
   "metadata": {},
   "source": [
    "# Track (b): independently trained models\n",
    "\n",
    "## 3b/4b/5b. Two independent potentials → two densities\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e8f18d65",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:53:57.494922Z",
     "iopub.status.busy": "2026-07-20T04:53:57.494844Z",
     "iopub.status.idle": "2026-07-20T04:56:18.793672Z",
     "shell.execute_reply": "2026-07-20T04:56:18.792966Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "track (b) calculators on one Argon config (INDEPENDENT models):\n",
      "  dE = 4.380e-02 eV | dF = 3.025e-02 eV/Å | dσ = 8.178e-05 eV/ų (training-level differences)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_1044677/1079695994.py:52: DeprecationWarning: Use thermalize_momenta\n",
      "  MaxwellBoltzmannDistribution(at, temperature_K=T_K, rng=np.random.default_rng(0)); Stationary(at)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xnn (b): 1000 steps in 141 s | rho_eq = 1.4180 g/cm³\n",
      "track (b)  rho_xnn = 1.4180 ± 0.012   rho_allegro = 1.4133 ± 0.011\n",
      "           |diff| = 4.76e-03 g/cm³ (within thermal fluctuations; exp ~1.41)\n"
     ]
    }
   ],
   "source": [
    "xnn_indep = ForceStressOutput(xnn_indep_base, compute_forces=True,\n",
    "                               compute_stress=True).to(DEVICE).double().eval()\n",
    "def xnn_b():    return XNNCalculator(xnn_indep, cutoff=CUTOFF, device=DEVICE)\n",
    "\n",
    "dE, dF, dS = compare_calcs(xnn_b, allegro_a)\n",
    "print(\"track (b) calculators on one Argon config (INDEPENDENT models):\")\n",
    "print(f\"  dE = {dE:.3e} eV | dF = {dF:.3e} eV/Å | dσ = {dS:.3e} eV/ų \"\n",
    "      \"(training-level differences)\")\n",
    "\n",
    "rho_xb = run_npt(xnn_b, \"xnn (b)\")\n",
    "rho_ab = rho_aa                                  # same trained original potential\n",
    "db_x, db_a = rho_xb[N_EQUIL:].mean(), rho_ab[N_EQUIL:].mean()\n",
    "print(f\"track (b)  rho_xnn = {db_x:.4f} ± {rho_xb[N_EQUIL:].std():.3f}   \"\n",
    "      f\"rho_allegro = {db_a:.4f} ± {rho_ab[N_EQUIL:].std():.3f}\")\n",
    "print(f\"           |diff| = {abs(db_x-db_a):.2e} g/cm³ (within thermal fluctuations; exp ~{RHO_EXP})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05a6e34a",
   "metadata": {},
   "source": [
    "## 6. Overview: both tracks\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f1f396ac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-07-20T04:56:18.795016Z",
     "iopub.status.busy": "2026-07-20T04:56:18.794934Z",
     "iopub.status.idle": "2026-07-20T04:56:19.804200Z",
     "shell.execute_reply": "2026-07-20T04:56:19.802772Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGuCAYAAABBQrUvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAA4eJJREFUeJzs3Xd0FOX7NvBrS7LpvUJC6L2D9BJ670hRkGoUkCoqCNJUEEEExC8IUhUFARFEqlQpoYYmhB4gQHrvye7z/sGb/bGmbTYbJpu9PufkSKZes5tkb++ZeUYmhBAgIiIiIiIiIiJ6jeRSByAiIiIiIiIiIvPDphQREREREREREb12bEoREREREREREdFrx6YUERERERERERG9dmxKERERERERERHRa8emFBERERERERERvXZsShERERERERER0WvHphQREREREREREb12bEoREREREREREdFrx6YUlQpqtRq1atXC3LlzC71uZmYmKlWqhK+++qoYkpHUfHx8MHLkyNe+7rZt2yCTyRAXF2fQ+qayTyKi0qhLly4YMWKEzrTatWujZ8+eeq3fpk0bvP/++3rvr1WrVvD39y9MRL0MGTIE5cuXN/p2pVQSjqm43q/iInXeorxngYGBkMlkuHr1qlEzlbR9EpkzNqWoVPjhhx/w4sULTJs2rdDrWlhYYM6cOVi4cCHCw8OLIZ35cXNzw9ixY0vt/oylZs2akMlkWLJkidRRCpSeno7atWtDJpPp/T9aGRkZ+Oabb1C3bl3Y29vD1dUVLVq0wLZt24ol4z///IO2bdvC1tYWTk5O6N+/Px48eCB5LuBlw1ChUCAiIqLY9vFfS5cuhUwmg1wuh6+vL77++uvXtm8iU7Z//34cO3YMc+bMMXgbn3/+OX788UfcuHHDiMnodWrcuDE6duxY6vZVGnXr1g0ymQwTJkyQOkqBhBDo1KkTZDIZunbtqvc669evR5MmTeDs7AxHR0c0bNgQq1evhkajMXrGmzdvokePHnBwcIC9vT06deqEy5cv51ju+fPnmDt3LurXrw9bW1uUKVMGXbt2xZEjR4yeKVt2wzC3PMVl586dkMlkkMlk8PT0xPTp04vldTdnbEqRydNoNFi8eDGGDx8OR0dHg7YxdOhQWFhYYNWqVUZOR1ILDQ3Fpk2bpI6Rw5kzZ3D79m0MGjQIP/74o9RxCvTpp58iOjq6UOuMGTMGH3/8MSZPnoxnz57h9u3baNmyJYYOHYoVK1YYNd/Zs2fRsWNH1KlTB6Ghobhx4wZSU1PRqlUrhIWFSZYr2969e9G8eXN4eHgUy/ZzM336dAghkJGRgU2bNuGTTz7hWV8iPSxcuBDdu3dHpUqVDN5G27ZtUb16db2bwadPn8aJEycM3h9Rfkrzz9fTp09x+PBhDB48GFu3bkVKSorUkfK1atUqXLlyBZaWlnqvM2fOHIwdOxa9e/fG/fv38fjxYwwbNgzjx4/Hhx9+aNR89+/fR+vWrWFtbY07d+7g0aNH8PHxgb+/P27evKmz7MKFC+Hk5IStW7ciKioKJ0+ehJOTEzp37ozffvvNqLmy7d27Fz4+PmjUqFGxbD83AwcOhBACarUaBw8exA8//IC9e/e+tv2bAzalyOTt378fT548wfDhww3ehqWlJd588038+OOPyMrKMmI6otytW7cOjRo1wuzZs3H37l2cPHlS6kh5OnnyJFasWFGopm1GRgZ+/fVXdOvWDWPGjIGDgwM8PDywZMkSlC1bFps3bzZqxunTp6N8+fJYuXIlnJ2d4evri59++glxcXH48ssvJcsFvLxF+MCBA+jTp4/Rt60PmUwG4OXfOWdnZ0kyEJmKmzdv4syZM0WqKbINGzYMO3bsKHRDn4j0t379eri5uWHlypVISUnBjh07pI6Upzt37uCTTz7Bt99+CwsLC73X27x5M2rVqoXZs2fD1dUVTk5OmDZtGlq0aGH0umXOnDkQQmDTpk3w9vaGm5sbfvjhBzg4OGDmzJk6y65atQpTp05FrVq1YG1tjSpVqmDLli2wsrLC2rVrjZor2549e9C7d+9i2bY+5PKX7ZPXeZLRHLApRSbvzz//hKOjY64d88aNG2svt1QqlShTpgzeeecdPHv2LMey7du3R1hYGC5evFjgPnfv3o3mzZvDyckJLi4u8Pf3x4EDBwzat52dHT744AP8888/eOONN2BjY4PGjRtrc5w8eRJNmjSBtbU1qlevjkOHDuWa6aeffkKTJk1gY2MDOzs7dOrUCRcuXCjwWLL3f/LkSTRu3BhWVlaoXLlyrg2IrKwsLFy4ENWqVYNKpYK7uzuGDBmChw8fAgCSkpIgk8kQHR2N9evXa4+/VatWhc6anevChQto3rw5rK2tUaFCBaxZs0a7jD77y21cqML8XBSHhIQE7NixA4MHD0adOnVQo0aNfK+Wio2NxciRI+Hq6gpLS8s835/iyjpixAiMHTsWbdu21Xs9CwsL2NjY5Dk/t6saDf0Zfv78Oc6dO4fevXtriwXg5W2drVu31ilQDcn1X6mpqZg6dSq8vLxga2uLLl264OHDh2jWrFmuY3acPHkScXFxOZpSP//8M1q0aKG9hbBPnz64fv26dr4x/jZs27YNSqUSnTt3xty5c+Hn51fg8RGZsz///BMA0K5duzyXuXHjBtq2bQsbGxv4+vpi3rx5UKvVOZZr37490tPTcfjw4QL3m9uYP9ljWN27dw+dOnWCjY0NypQpg/nz50MIobOsRqPBwoUL4efnB2tra7Rs2TLf21v2798Pf39/ODg4wNraGs2bN8fBgwdz3b++x1uYbUp9TAXt383NDZcvX8bRo0e19YKPj0+e+37zzTfh5uaGtLS0HPPefvttODk5ITU1Ndd1C9pXduZbt26hU6dOsLOz0w5ZMHDgQO06CoUC7u7u6N+/P4KDg3X2UdSfL31f38K+Z0Wl0WiwYcMGDBw4EB4eHujYsWO+9VRaWhqmTZsGLy8vWFpa5vvzbGxZWVkYPnw42rRpg3feeadQ6+ZXm+Q2T5/3Kq+Me/bs0f6cZbO0tESPHj1w8OBBJCUl5bsNhUIBhUIBW1vbAven0Wjw+eefo1y5cjo/L3mNQXb//n3cunUrRz21f/9+dOjQAU5OTnB0dESHDh3wzz//aOdn/6z/+++/8Pf3h42NDWrUqKF9Ta5fv4527drB1tYWfn5++Omnn3LsOzAwEAqFAvXr18ewYcPQvHnzAo+PCkEQmbiaNWuKdu3aFbhcSkqKOHfunGjUqJFo1KiRyMzM1Jn/6NEjAUB89dVX+W7n7NmzQi6Xiy+//FJERUWJhIQE8c8//4gePXqItLS0Qu/b1tZWdO3aVQwZMkQ8ePBAhIeHi759+wo3Nzdx+vRpMWDAAHHv3j0REREhBgwYIGxtbUV0dLTO9mfMmCEsLS3FsmXLRFhYmHj+/LmYOHGiUKlU4uLFi/kej62trejSpYvo3bu3uHPnjoiKihKLFy8WcrlcfP311zrLDh06VFhbW4tNmzaJ2NhYERQUJBo3bizc3NzE48ePtcu5urqKMWPG5Lo/fbPa2tqK7t27izfffFMEBweLmJgY8dFHHwkA4tSpUzrbzG9/ZcuWFSNGjMjz+PN7bwpaNz+//vqrACBiY2NzzPvf//4nAIiQkBAhhBDz5s0TVlZWIiYmJseyCQkJolatWqJz584Fvj957bNHjx4CQIFfjo6OOfY/cuRIUbZsWREfHy8iIyMFAPHee+/p9RqsWrVKKJVK8eOPP4r4+HgREREhpk+fLmxsbMTx48d1li3Kz/DBgwcFALFu3boc8yZNmiQAiIiICINy5aZPnz7C0dFR7Nq1S8THx4vz58+LHj16iLp164q2bdvmWP6DDz4Q1atX15k2ffp0YWFhIb744gvx+PFjERMTI/78808xevRo7TLG+NsghBCZmZni/PnzwsHBQezbt6/A4yMyZ927dxcVKlTIdV6tWrVE8+bNRdeuXcWVK1dEbGys2LBhg1CpVGL8+PE5ls/IyBAWFhbi/fffL3C/LVu2zPH3o1atWqJly5aiX79+4sqVKyI+Pl4sX75cABA//fSTzrLTpk0TlpaWYs2aNSI2NlZcv35ddOnSRbRt21b4+fnpLLt69Wohk8nEp59+Kp48eSKioqLEwoULhVwuF3v27DHoeAuzTamPSd/9N2rUSHTo0EGv9+v48eMCgNi8ebPOchEREcLS0rLAn4H89lWrVi3RokUL0bVrV3H58mURHh4utm/fnmO59PR0ce3aNdG5c2dRrlw5ERcXl2fe7O3q+1ro+/oW5j3T17lz5wQAERQUlGPe/v37BQBx8uRJIYQQmzZtEgDErVu3ciybmZkp2rdvLxo0aFDgz3Ne+5wwYYJe9VRutdi8efOEnZ2dtvbLrr/1sXv3bmFpaSm++OILER0dLWJjY8WyZcuEUqkUv/zyi86y+r5XuQkODhYAxKxZs3LMW7ZsmQAgLly4kOu6arVahISEiNGjRwsHBwcRGBhY4HFNnjxZqFQqsXbtWhEbGytu3rwpevTokefPy9KlS4WDg4NIT0/XTvvuu++ETCYTkydPFvfu3RPx8fHi2LFjon///tplsn+H+vbtK27cuCFiYmLE+PHjhZWVlTh79qzo1q2buHbtmoiJiRGTJk0Scrk8158htVotbt26Jfz8/MSqVasKPD7SH5tSZPLs7OzEW2+9pffyp0+fFgBy/LFMT08XAMS4cePyXf+rr74SMpkszwZUYfdta2sr3NzcRFJSknba3bt3BQDh6+srEhIStNMfPHggAIjvv/9eO+327dtCJpPl+ADRaDSiYcOGBX7g2draCgcHB53iRQghhgwZIuzs7LT7v3DhggAgFixYoLPc48ePhYWFhU5TKK8mUWGy2traCldXV5GYmKidlpmZKTw8PMTw4cN11i9KUypbbu9NcTWlGjRoIJo1a6b9/vbt2wKAWLlyZY5lv/rqK73en/z2aWhTavfu3QKA2Lt3rxBCFLopJYQQS5YsERYWFjr72L17t84yRf0Z3rp1qwAgduzYkWPenDlzci1Q9cmVm+xCdcWKFTrTL126JADk2pQqV66c+OSTT7Tf37hxQ8hkMvHxxx/nu6+i/m3IlpGRIc6cOSPs7e1z/R8ZIvo/tWvXFi1atMh1Xq1atYRCoRD379/XmT5jxgwhk8nEgwcPcqzj5eUlunXrVuB+82oaWFhYaP8nNluDBg1E69attd8/e/ZMKBQKMXnyZJ3lnjx5IiwsLHT+5y46OlrY2tqKt99+O0eGvn37imrVqunsX5/jLew2pT4mffYvROGaUkK8PEn66me7EEIsWrRIACjw5EpBTSm5XC7u3r2b7zayhYaGCgBi27Zt+ebV97XQ9/UtzHtWGPk1pfr16yfKlCkj1Gq1EEKIuLg4oVKpxLRp03Isu23bNr1/f43dlLp48aJQKpU6dV5hmlJCCPHzzz8LW1tb7fZVKpVYvXq1zjKF+V3IzZkzZwQAsWTJkhzzNmzYIACI/fv355jn6OiozeXu7i4OHTpU4PGEhoYKhUIhpk6dqjP9+fPnQqVS5frz0rp1azF48GDt95GRkcLa2loMGjQo331l/6w/efJEOy0hIUGoVCrh5OQkHj16pJ2elJQkrK2txUcffZRjO1lZWeL69euiXLlyYvHixQUeI+mPt++RSVOr1UhKSoK9vX2u82/evIk333wT3t7eUCqVOrd23b9/X2dZS0tLWFpaIi4uLt991qtXD0IIDB06FCdPnkR6enqR9926dWudy1wrV64MpVKJ+vXr6xxbxYoVoVKptLfLAcBff/0FIQTefPNNnW3KZDK0b99er7GK2rZtm+Py3759+yIpKUl7+9TRo0cBAP3799dZrly5cmjSpIl2fn4Km7VNmzY6lw8rlUpUq1ZN5/gNUZj3xtiuXLmCoKAgDBkyRDutevXqqFu3bq6XnO/atUuv9yc/+/btg3h5EiLfr1d/9iMiIhAQEIDBgwejV69eBh3rxIkTMWvWLKxevRqxsbEICwvDpEmTMGDAAKxfv167nL4/F6/epiCTydC4ceMcy+fl1Xn65srN8ePHASDHa9KoUSOUKVMmx/JBQUF48uSJzqXmBw4cgBACb731Vr77Aor2t6Fv376QyWSwsbHBkCFD8MEHH2DgwIEF7pPInMXFxeVZUwAvn5r63wHQ+/btCyGE9u/DqxwcHAqsK/JTu3btHLfd1q5dW+d3/eTJk1Cr1TnGWfH19c0xtMHx48eRnJyc4+8tAHTs2BF37tzReRKxPsdb2G1KfUz67N8Q48ePR2BgIIKCggC8vDXphx9+QN26dXN8XhVWjRo1UKVKlRzTnzx5glGjRsHX1xcWFhY6t/7pU8/o81ro+/oW5j0zhvDwcPz5558YNGiQ9tZ9R0dHdOnSBVu2bEFGRobO8rt27Sr07+9/rVq1Sq96SggBJycnAC9v+R8+fDiaNGli8NMBly5diuHDh2P27NkIDw9HdHQ0li1bhg8++ADz5s3TLqfvezV9+nSdesrNzU1nWX3rqWxxcXHIzMzEnTt30L17d/To0QO//PJLvsd06tQpqNXqHPWUt7d3rj8vUVFROHv2rE49dfz4caSmpupVT9WuXRu+vr7a7+3t7VG2bFn4+vrq3Cpoa2sLX19fnd+BKVOmQCaTwdLSEp07d0a3bt0wceLEAvdJ+mNTikyaQqGAnZ0dEhIScsx7/vw5WrZsibi4OBw4cAAJCQkQQmifPpWZmamzfHp6OjIyMgocCLhr165Yv3497t27B39/fzg6OqJjx47Yv3+/wfv29vbW+V4mk8HW1jbHdODlODOvFrjZTxZr1KgRlEolFAoF5HI55HI5li5dirS0tAKfROLp6ZnntKioKADQDtTq5eWVY1kvLy/tcvkpbNbcjr+oBX5h3xtjW7duHeRyeY6CYciQIbh+/XqOJtPTp0/1en+Mbc6cOdBoNFi5cqVB69+6dQurVq3C+PHjMWbMGDg5OcHT0xMLFixA+/btMXXqVO1rXdSfYVdXVwAvx976r+yfFRcXl0Lnyk3270FuA1zmNm3Pnj3w9PREs2bNtNMiIiIAAGXLls1zP9mK8rfhjz/+gBACmZmZePLkCRYuXKgz5hYR5eTk5JRrTZGtsH+PExISivSAAX0+B7P/LuWXLVv239sBAwbk+Hv7wQcf6GyvoG1mH29htyn1MRVHbQEA77zzDuzs7LB69WoAL09AhISEYMyYMUXaLpD750VKSgpat26Nq1ev4rfffkNMTAw0Go32OPSpZ/R5LfR9fQvznhnDpk2bkJWVhcGDB+tMHzJkCKKiovDHH3/oTJeqnlqxYgUePnyIH3/80aDP4Li4OMyaNQt9+vTBjBkz4OHhARcXF4wfPx6jRo3CF198oR0TtbC/C/9VmHrqv5RKJapWrYqNGzeiVq1amDp1ar7HVdh6at++fZDL5ejevbt2WlHqKeBlYyqv6a/+Dixfvlz79L0XL15gzZo1sLa2LnCfpD9Wp2Ty/Pz8cjzyHXj5P2QJCQn4/vvvUb9+fe3gxo8ePcp1Oy9evNBuryCjR4/GjRs3EBERga1btyIzMxM9evTQnmUp7L7zOiOR35mKbNlnN+7cuYOsrCyo1WpoNBpoNBrt2Zr8BnYGoHMG8b/Tsj+gsj+E8lr2v2dZjJFVn+MvrMK+N8aUkpKCX375Ba1atcpxVU12UbVu3Tqd6YmJiXq9P/np2bOnzhmxvL6yz+oBL4uz6OhoeHp6aue7u7sDAH744QfIZDL8/PPPee7zzp07AIA6derkmFe7dm0kJiZqiyh9fy527typcxby0qVLOvvI3uerbt++DU9PT22BU5hcucl+vbMLoVflNm3v3r3o3bu3zs9y9uuoz8D6RfnbQESFl1dNka0wf48zMzMRHR1dpAcM6PO7nr3f/LJly/57e+jQoTz/3tasWTPP9V+dlr3fwm5T6mMqrr+f9vb2GD58OH755RfEx8fjf//7H1QqFYYNG1bkbef2pLYTJ07gyZMnWLx4MZo3bw57e3vIZLJC1TOFqTMLen0L854VlRAC69evh5+fH5o2baozr1evXrC2ti6WeuqDDz7Qq56SyWTapkZUVBQyMjJQs2ZNnfnJyck4dOgQZDIZvvjiizz3+ejRI2RkZORZt6jVaty7dw+A/u/V0qVLdeqp7IZcpUqVYGNjk2c9pVQqdX6XciOTyVC7dm1EREQgOTk5z+UMqaeyLwbIxnqq9GBTikxeq1atcOXKlVyfFAIAKpVK5/stW7bkulz2FSqtW7fWe9/u7u4YMGAAtm7dCgA6T3oozL6LokePHpDJZNi+fbvB2zh16lSOM8N79uyBra2t9sO+Q4cOAF4+efBVoaGhuHDhgnY+8PLS19xuazRG1tzktb/8vI735r+2b9+OhISEHGf1gJe3XzVu3Bjbtm3L8WQTfd4fY/tvA0gIgcjISADAe++9ByFEvoV29v+E3bx5M8e8GzduQKVSac9OFvXnokyZMmjatCn27t0LjUajnR4VFYV//vlH55a1wuTKTfYTuf766y+d6UFBQXj+/LnOtKdPnyIoKCjHU2Kyj7egS9uJ6PVr1aoVHj16lOfVBLdu3cpxm9eePXsgk8lyPLEvKCgImZmZhaorDNGmTRsoFArtkwOzhYaG4sqVKzrTOnToAGtra73/3upzvIXdpj6K85j0ZUhtMX78eCQnJ2P+/Pk4ePAg+vbtm+eVJUXdV7birmf0fX0L854V1YkTJ3Dv3j0MGjQoR1PBzs4OPXr0wNGjR3M06Arz+2ss/20AZX9lP71XCIHZs2fnub6vry/kcnmedQvwf7VNUX8XlEolevXqhSNHjujUohkZGfjrr7/QpUsXnWE1cqNWq3HlyhX4+vrm+wS+7J+X/9ZTYWFhOZ7YmJaWhsOHD+eop9q3bw9ra2vWU6UAm1Jk8nr16oX4+Pgcf8A6d+4MKysrfPTRRwgPD8eLFy/w6aefQqlU5rqdY8eOwcvLC2+88Ua++5s3bx7mzJmDa9euISUlBZGRkfj+++8hk8nQtm1bg/ZdFLVr18aMGTMwf/58LF68GE+ePEFqaipu3bqFb775BuPHjy9wG02bNsXIkSNx7949xMTEYOnSpdi+fTtmz56tHVujSZMmGDRoEBYuXIiffvoJ8fHxuH79OgYMGAA7OzudD9TatWvjwoULOf4n3RhZ83oNcttfbl7ne/NfP/74IxQKRZ7j+gwePBhJSUnYtm2bznQPDw8MGTIk3/cnP4aMKVVY2eMXZW+jYcOG6NixI/73v/9h06ZNiIuLQ3h4OObOnYujR49iypQp2kufjfFzsXTpUjx69AiTJk1CbGwsQkNDMXz4cDg4OGDWrFna5QqTKzfNmjVDnz59MGfOHPzxxx9ITEzExYsXMXfuXNStW1dn2ezG4asNWwCoVasWpk2bhm+//RYLFy7E06dPERcXh3379hnlNg8iMlzPnj0BIM/xZZo0aYKJEyfi2rVriI+Px+bNm/Htt98iICAgx1g1x44dg0qlQufOnYs1c9myZTFx4kSsXr0a69atQ1xcHP79918EBATkeGy5m5sbvv32W6xfvx4ff/wxHjx4gNTUVNy7dw/r1q3L8fmkz/EWdptSH5O+ateujZs3b+L+/ft5nvjMbZ02bdrg22+/hUaj0ftvuiH7at68Odzc3DB37lyEhIQgOjoay5cv1175byz6vr6Fec+KKnsMztxO8mVPz76a6lW+vr4YNmyYXr+/uTFkTKnCyh6/KHtYCTc3N4wePRq7d+/GkiVLEBUVhZiYGG0dM3jwYFSoUEG7bFF/FxYsWAAAGDlyJMLCwhAVFYX33nsPcXFxWLRokXa56OhodOvWDYcPH0ZYWBhSUlJw9epVDB48GHfu3MGSJUvy3U/ZsmXxwQcfYNWqVVi/fj3i4uJw69YtvPfeezpDHgDA33//jeTk5Bzjlbm5ueHrr7/Gjh07MHXqVDx48ACJiYk4ceIEBgwYUOCxUgmi95DoRCWUWq0Wfn5+YtKkSTnmHTx4UDRs2FBYW1sLX19fsWDBAvHvv/8KAGLjxo3a5dLT04WLi4uYPXt2gfuLiooSX375pWjQoIGwsbER7u7uomPHjuLAgQMG7dvW1lZMmDAhx34cHR1zfcpZXk+a27Fjh2jbtq1wcHAQNjY2onbt2uLjjz8WT58+zfd4svd/7NgxUb9+fWFpaSkqVqyY4+liQrx8+t3nn38uqlSpIiwsLISrq6t48803xb1793SWu3XrlmjZsqWwtrYWAETLli0LnTWv16VHjx6iVq1aeu8vtyfo6fveGPPpe7du3dL7iS1NmjTJ8Tps2rRJVKtWLd/3J78n/hlDfk/f69OnT459p6SkiK+++krUqVNH2NvbCxcXF9G0aVOxZcsWodFocmzD0J/hbCdOnBCtW7cWNjY2wsHBQfTt2zfXpxUVNldu60+ePFl4eHgIGxsb0alTJ/HgwQNRv3590blzZ+1yHTt21Hkk8X9t2rRJvPHGG8La2lq4u7uLPn36iOvXr2vnG+tvAxEVTqtWrUTv3r1zTK9Vq5bo0aOHuHr1qmjZsqWwsrISZcuWFZ999pnIysrKsXzt2rXFsGHD9NpnXk9H69GjR45lJ0yYIGxtbXWmqdVqsWDBAuHr6ytUKpVo2rSpuHDhghg8eHCuT7E6evSo6Natm3BxcRFWVlaiWrVqYty4cSI4ONjg4y3MNqU+Jn32//z5c9GlSxdhZ2cnAIiyZctq5+X2fmXbvn27ACD8/Py0T4UrSH77yiuzEC+fjNy6dWtha2srPD09xeTJk0VcXJwAIObOnZtv3sK8FkLo9/oW9j3Tx3+fhBcTEyOsrKz0qqfKlCmj/VnNPt6//vpLW+/m9fOc3xP/jCWvp+9Nnjw5x74zMzPFmjVrRKNGjYSTk5NwdHQU9evXFytXrhTp6ek5tqHPe5Wfa9euia5duwo7Oztha2srOnToIC5cuJBjuWPHjokBAwYIHx8foVQqhZeXl+jXr5/4559/9NqPWq0W8+fPFz4+PsLKyko0b95cXLp0SfTt21dUrVpVu9zYsWNFw4YN89zOn3/+Kdq2bSvs7OyEk5OT6NChgzh16pR2fl4/6/Xq1cv1PcjvaZhUPNiUolJh9erVwtnZWcTFxRm0/qZNm4S9vb0ICwszcrKSL6//8aWiMVaDqDDvT3E3pSh/bm5u4p133hFCvHwstYWFhdi8ebPEqYiosA4cOCCUSmWOR8cXxokTJ4RCodBpNJua/JohlLcDBw4IAGLevHlSRykVjNUgKszP8+toSlHeGjduLNq0aSOEEEKj0QhPT08xf/58iVNRceLte1QqvPvuuyhTpgy++eabQq+blZWFBQsW4NNPPy2Wp4MQUel36tQpREVFaW/h3b9/PzQaDXr06CFxMiIqrK5du6JDhw6YP3++wdv47LPPMHbs2FwHJ6bSbfv27VAoFBg1apTUUYhMzsOHD3H16lVtPRUYGIjw8PAc40lR6VL8g6gQvQYKhSLXAQD1oVQq8eDBAyMnIqLSavPmzUhISECvXr3g4uKCc+fO4f3330f16tUxdOhQAMDQoUO1/yYi03Pw4MEirX/q1CkjJSFTcunSJWzfvh3Dhw9HuXLlpI5DVKIdOnQI58+fx9ChQ1GmTBlcu3YN48ePh4uLCyZMmADg5dhpQs9x1sh08UopIiKiQujTpw8ePnyIzp07w93dHaNGjUKHDh1w4sSJfAdJJyKi0iktLU37wJtOnTrh22+/lToSUYnXtm1bCCHQt29fuLm5oU+fPqhWrRrOnDnDu1fMjEyw9UhERERERERERK8Zr5QiIiIiIiIiIqLXjk0pIiIiIiIiIiJ67TjQeR40Gg2eP38Oe3t7yGQyqeMQERGRGRBCIDExEWXKlIFcXvRzh6xniIiISAr61jRsSuXh+fPn8PX1lToGERERmaGnT5/Cx8enyNthPUNERERSKqimYVMqD/b29gBevoAODg4SpyEqWGZmJmJjY+Hs7AwLCwup4xARkQESEhLg6+urrUOKivUMmSLWNEREpk/fmoZNqTxkX+Lu4ODAIo5MwosXL7B161YEBATA1dVV6jhERFQExrrVjvUMmSLWNEREpUdBNQ0HOicqJVxdXTF27FgWb0RERGTSWNMQEZkPXilFVEpYWlqibNmyUscgIiIiKhLWNERE5oNNKaJSIjExEZcvX0ajRo2MNhYJEb1earUamZmZUseg18TCwgIKhULqGEQlDmsakhI/i4kKp6j1DJtSRKVESkoKrly5gho1arCAIzJBSUlJCA0NhRBC6ij0mshkMvj4+MDOzk7qKEQlCmsakgo/i4kKr6j1jEzwNy5XCQkJcHR0RHx8PAcGJSKiYqVWq3Hv3j3Y2NjA3d3daINcU8klhEBkZCRSUlJQpUoV7RlGY9cfrGeIiPTDz2KiwsurngH0r0F4pRQREZHEMjMzIYSAu7s7rK2tpY5Dr4m7uztCQkKQmZnJ2/iIiCTGz2IiwxS1nuHT94hKicjISKxevRqRkZFSRyEiA/GsrHnh+02UO9Y0JCX+bSYqnKL+zrApRVRKWFpaonz58rC0tJQ6ChEREZHBWNMQlQzHjh3Drl27irSNuXPnIjg42EiJiqY4sixatAihoaFG3aa5YVOKqJRwdHREt27d4OjoKHUUIiIiIoOxpiGSnhAC06ZNQ/PmzQEAX375Ja5evVro7Zw8eRJRUVFGTmcYY2RZsGABbty4of2+Vq1amDNnTlGjmTU2pYhKiaysLMTExCArK0vqKEREREQGY01DJL1jx46hbNmyKFOmDACgbdu28Pb2ljiV9E6dOoXw8HDt9927d8fff/+NmJgYCVOZNjaliEqJyMhIfPfddxx/gYiMYs2aNdi0aZP2+7lz5+LIkSMAgBMnTuD777/Hzz//jNGjR2PlypVQq9UFzktISMAXX3yBt956CwMHDsRvv/322o+LiEo+1jREQGpqKkaNGoWQkBAAQFhYGEaMGIHExEQALz+XT58+jc8++wxjx47FmTNntOvmNy8oKAgTJkzAm2++iYEDB+b5e7Zv3z60b99e+/3Jkyfx4sWLArefkZGBxYsX491338XevXtzbPfnn3/G2LFjMXnyZJ0rjubOnYuTJ0/i008/xfvvv48LFy7ovV5xZMltm3/++Sdu3LiBBQsWYODAgbh8+TKUSiWaNm2Kw4cP5/o6UsH49D2iUsLFxQUjRoyAi4uL1FGIyAhSM9R4EJlUbNuv5G4Ha8u8n5AyYMAANGnSBLVr18bNmzdx9OhRfPbZZwCAkJAQzJo1C6NHj0bbtm2xdOlSWFtb491338133owZMxAdHY1+/fpBqVSiZs2axXZ8RGS6WNNQSSD157C1tTU6dOiAwYMH4+TJk3j77bfx5ptvwt7eHsDLJtHOnTsxYcIEODg4oGfPnnj48CGcnZ3znGdnZ4euXbvi448/Rrt27QAAtra2ue7/5s2b2mUA4J9//kGjRo0K3Pe7776LZ8+eYdiwYdi6dSuuXLmi3cb06dPx/PlzdO/eHZGRkejZsydOnjyJ8uXL4+TJk/jll18wefJk2Nvbo0uXLrh48SIqV65c4HrFkSW3bVarVg2enp5o164d6tSpg7JlywIAqlevjuvXr2PIkCEG/jSYNzalJHI/IhH7rr/AOP9KUCn5GGgqOpVKhfLly0sdg4iM5EFkEnp+d7rYtr9vYivULpv3eC3u7u7YtGkTBg8ejMzMTJw5cwZK5f+VDU2aNMGyZcu03588eRLvvvtuvvMSExPh7e2NevXqoUaNGsVwVCSF/524DxlkGOdfSeooVEqwpqGSQOrPYQAYNmwYTpw4gYYNG6J27dp4//33debPmjULb731FgBg//79uHHjBtq0aZPnvEaNGkGtVqN8+fJo27Yt3Nzc8tx3cnIybGxs8pyf2/abNGmC3377DWFhYXB0dMTw4cNRrlw5AEBmZiZWrVqFHj164I8//gAAyOVy/P333xg7diyAl42i9957DwAQFRWFn376CbNnzy5wveLIktdr6+HhgdatW6Njx47a18LGxgZhYWF5vlaUPzalJBJ9+yQ6nJqF5HoHoXLnvblUdElJSbh27Rrq1asHOzs7qeMQURFVcrfDvomtinX7BalTpw6Sk5PRoEED+Pr66szLHmMCeHmWNSUlpcB5S5YswRdffIFevXohMzMTa9asQbdu3Yp6KCSxileXQJGVCvhvkToKlRKsaagkKAmfwwDQvn17rF+/HnPnzs0xr7Cfxba2tvj111+xatUqBAQEoGHDhti+fXuuVyV6eHggOjo6z1y5bT8mJgYODg7ahxQoFArt1UTZ2xo6dKh2vSFDhqB+/fra77ObRgDg5+eHO3fu6LVecWTJ77X9r+joaHh6euY5n/LHppREbGRZqCMPwfPkBIBNKTKCpKQknD59GpUqVWIBR1QKWFsqCjyDWtxGjhyJyZMn4++//8b//vc/jB8/vkjb8/LywqpVqwAAv/76KxYtWsSmVCngromCVUZ4wQsS6Yk1DZUEJeFz+OHDh/jkk0/wxx9/YOLEiWjRokWOk0SF1alTJ3Tq1AlqtRq9e/fGH3/8gdGjR+dYrmnTprh27RoGDx6s97a9vb2hVqsRFBSEBg0a4NmzZ/j3338BvKwBXFxcoFKp0KtXr1zXP3LkCLp16wYhhPbf+qxXHFnyYmVlhfT0dJ1pQUFBmD17dqG2Q/+HTSmJKK1e3rubkVp89ymTefHy8sInn3widQwiKiWWLVuGzMxMzJgxA6NGjULTpk3RvHlzNGjQwOBtfvrpp7h79y6ysrJw8eJFTJ8+3YiJSSoapTUs1OkFL0ikJ9Y0RC8H6R48eDC+/vpr9OnTB9HR0RgyZAhOnjypczt9YTx//hyTJk0CAMTHx+PmzZtYuXJlrssOHjwYffv2xcKFC/Xevkwmw9KlS9GhQwc0adIEYWFhOk/s27hxI4YNG4ZatWppbx38+uuvUbFiRQDAxYsX0apVKyQlJUEul2PkyJF6rVccWfLSokULTJo0CRs3bsTMmTNRsWJFPHr0SHvbJBUem1ISsbB+edaHTSkiIiqJKleujBEjRkAmk8HLywv79+9HUtLLz6x27dqhdu3a2mWbN2+uPXOb37xOnTqhYcOGUKlU+Oabb1CpEscgKg00SmtYilSpYxARlSpRUVH44osv0KVLFwDA6NGj4eXlpb1VbP78+ToPDJk5cyYqV64MAHnOs7GxwZAhQyCTyeDo6IhmzZrleTVixYoVUbNmTZw6dQpt2rTB7NmzUaVKlXy3D7y8yrpNmzZ4+PAh3njjDVy9elU7jmSXLl1w//59XLlyRXsLnbOzs3Y7n3/+OVxcXBAdHY0WLVpApVIVuF5xZMlvm59++inat2+P58+fo2zZsvjxxx8xceJEKBQcJ9pQMiGEkDpESZSQkABHR0fEx8fDwcHB6Nt/ev8GfH9uhX87/4paLbobfftkfqKiorBnzx706dMn30ELiajkSUtLw6NHj1ChQgVYWVlJHYdek9zed2PXH8VdzwDA+XWT4ft8P8rMvVcs2yfzw5qGpMDP4pzCwsIQFhamM9ZScfH398e8efPg7+9f7PsypmPHjqFVq1awtLSUOopk8vrd0bcGkb+OkJSTpVMZTMz4ALE25aWOQqWEUqmEu7u7wZfzEhERGSLEuyu+Qs7xSIgMxZqGqGTw8vJ6LQ0p4OXVSbVq1Xot+zKm9u3bm3VDyhj4l14iVrYO+FPTAl3lzgUvTKQHJycn9O7dW+oYRERkZlKcq+NQptQpqDRhTUNkftq2bSt1BJIIr5SSiLVSjlGKA7CIvi11FCol1Go1EhMToVarpY5CRERmxDP9MYaJP6FRa6SOQqUEaxoiIvPBppRELC0U+FT5CxwjLkkdhUqJiIgILFu2DBEREVJHISIiM+KZcgefWWxFamqy1FGolGBNQ0RkPtiUklAaLCEyWcCRcTg7O2Po0KE6T7AgIiIqbgpLGwBAagqfKEzGwZqGiMh8cEwpCaXJrCAyUqSOQaWElZUVqlatKnUMIiIyMxZWLx8nnpGaCMBb2jBUKrCmISIyH7xSSkIZMhWQyaYUGUdycjIuXLiA5GRefUdEpdvdu3dx4MCBIq9blO3Q/1Fa2QIA0lP4+UPGwZqGqOT7448/8Pjx4yKvW5TtGNOJEyfw6NGjIm1j5cqVRkpTdMbOkpWVhZ9++smo28zGppSErlg0RLiyrNQxqJRISEjA4cOHkZCQIHUUIjJD+jZ4jNEIunLlCjZv3pzvMg8ePMDy5cuRmpqa57r6bIcKpnDwxN/qBkgVCqmjUCnBmobIMPo2eIzRCFqzZg1u387/oV1//vkn9uzZk++6+mynuCUmJmLSpEnw8vICAKxatcqgBy1MmzbN2NEMZowsK1euhBACAKBUKrFv3z6cPHmyyNv9LzalJLTR6QOcceghdQwqJby9vTF79mx4e/PWCSJ6/ZKTkxEZGWm05YpqyZIlmDNnDn7//fdi35e5s3CvjLGZHyFOVUbqKFRKsKYhMkx4eHiOkzFFWa4o0tLSMHbsWAQEBCAlpWTfHbR582Z07doV1tbWAIDHjx9rmzHmbNq0aTrNuYCAACxdutTo++GYUhJyVqYDaZlSxyAiIspVVFQUDh8+DJlMhs6dO8PV1RUAcOvWLYSGhsLX1xenT5/GoEGDYGtrC3d3d+26oaGh+Pvvv1GhQgW4u7vj+fPn6Nixo85y2dvx8/PDmTNnULduXTRu3BjAy4Jw9+7dkMlk8Pb2Rvfu3WFnZ6dX7rS0NPz+++/4/vvvsWHDBrz99tt6rZeUlIQjR44gNjYWrVu3RpUqVQo8ntxeC0dHR9y5cwdnzpyBu7s7unXrBqWy9JZc1koZXJDw/2/fc5M6DhFRqRIUFIQrV67Az88PHTp0gEwmAwDs3LkTTZo0we3bt5GUlIQBAwbA09NT21gBgNOnT+PBgwdo27YtLl26hBYtWqBMmTI6y+3cuRNNmzbFrVu38OLFC/To0UP7OX3gwAHcuXMHKpUKtWrVQps2bfTOvXv3brRo0QKWlpbYtWsXhg8frtd69+7dw5kzZ2Bra4sePXrAxsamwOPJ7bUQQuDIkSN4+vQpGjdujHr16uW5z507d2LevHna7/38/LSv8/LlyzF69GgcPHgQMpkMffv2hYWFBYCXt7Tt27cP6enp6Nq1a47tnj17Fv/++y/Kly+Pjh076mxz5MiROHToEKysrNCzZ08oFAq91iuOLLltc+/evRBCYOXKlZDL5ZgwYQL8/f0xYMAAJCYmwt7eXq/3Ux8l4kqpGzduYOfOnXqdOf3jjz+wc+fOHF+XL1/WLhMUFJRj/pEjR4rzEAzyQdwSvP18kdQxqJSIjo7Gli1bEB0dLXUUIioFHjx4gNq1a2PXrl347bffUKtWLe1YCxcuXMAHH3yAd999Fzdu3EBmZqbOrXDBwcGoX78+Dh48iCVLlmDQoEHYtm0bAN1b5rK3ExAQgHPnzqFLly44dOgQACA1NRUhISF4+PAhtm/fjkaNGuk9vsyuXbvQqlUrvPXWW7hz5w5CQkIKXOfFixdo3rw5duzYgcDAQLRv3157y0F+x5Pba7Fr1y60aNEC//zzD7744gu0bdsWWVlZ+r/4JsZak4QrVu/DPvS41FGolGBNQ/TSihUr0L17d5w7dw6TJ0/G4MGDtfNWrVqF3r17Y9OmTXj27BkA3VvhvvrqKwwdOhT//PMPBg0ahKlTp+Lhw4c5llu1ahX69u2LzZs3Y/fu3WjatCnS09MBAJGRkQgJCcHNmzcxadIkzJw5U+/sGzZswKhRozBy5Ehs2LBBr3V++ukn9O/fH4GBgdi2bRsaNGiA+Pj4Ao8nt9diwIABmD59Os6ePYvOnTvj+++/z3O/ly5dQp06dbTfT58+HZmZLy8emTp1Kvr27YvDhw9j8eLFGDFihHa5vn37YsGCBTh06BB69uyps833338fM2fORFBQEObPn49BgwZp502dOhW9evXC4cOHMW/ePAwYMEDv9YojS27bDA8PhxACjx8/RkhICIQQUCgUqFatGq5cuZLna2kISU/bHT9+HJ999hlevHiBhw8f4vjx4/D39893nV27dulcapiSkoIDBw5g3rx5aNSoEQDghx9+wL59+9CsWTPtcuXKlUOnTp2K5TgMpVZYwzo9SuoYVErI5XLY2tpCLi8RvWYiMobEsJdfr7J2ApzLA5lpQGRwznXK1H/536h7QMZ/mjhO5QAbF712vXTpUowcORJfffUVAGDKlCn49ttvtQNnWlpa4tSpU7n+zfn2228xadIkzJkzBwAwcuTIPPdjZ2eHEydOQCaToV69evjjjz/QpUsXVK9eHe+99x4CAwNRoUIF3L17F6dPn0aXLl0KzL5x40ZMmjQJCoUCb731FjZu3Ij58+fnu87ixYtRpUoVNGnSBMDLv6mrVq1Cnz59Cjye/74Ws2fPxtatW9G1a1doNBo0btwYe/fuRf/+/QvMboqsbV6eLVWnJ0mchEoL1jRUYkj4OazRaDB79mxcuHABNWrUQEpKCipXrowrV66gYcOGAIC33noLH3/8cY511Wo1Fi5ciOvXr6N8+fKIi4tD+fLl89zX8OHDMWXKFABA48aNcfXqVTRt2hTDhg2Dp6cnHjx4AB8fH6xcuRKLFhV8UcWTJ09w8+ZNdO/eHTKZDGPHjsXDhw9RsWLFPNcRQmDq1KmYNm0abGxsUL16dTx69Aj79u3DkCFDCjyeV1+L8+fP4/Lly7h79y5UKhWuXr2Ktm3bYvz48dorhLKlp6cjOTkZjo6OeWZbtmwZ6tevj4SEBJQpUwZCCFy4cAHBwcEIDg6GUqnE8ePHtf2Ga9euYd++fZg+fToAoEqVKpg3bx6ePXuGsmVfjin95Zdfok2bNsjMzETVqlVx+fJl7bhN+a1XHFly2+a7776LcePG4ZtvvtG52tvZ2dnoJwwkbUrFxsZi0aJFqFChAnx9ffVa578jvm/YsAGHDh3KUSA2a9YMO3fuNFbUYqFRWkGZmiZ1DColnJ2ddbrsRFQKXNoInPxKd1qdQcCAdUDCM2Bt25zrzHt5RhF/jANCL+rO67cWqDc45zq5ePDgAcaPH6/9vmXLlti4caP2+wYNGuT5P4wPHz5Ev379tN83a9YMly5dynXZunXragtELy8vnD59GgCwbds2TJkyBV26dIGTkxOysrIQFVXwiZzHjx/j5MmT6Nq1q3ag8+3bt2Pu3Ln5/g/u7du3oVKptFdVWVlZoXPnznodz39fiwcPHmhPjMnlcjRv3hz3798vMLupUlpaQS1k0KSX7DFDyHSwpqESQ8LP4bCwMCgUCtSoUQMAYGNjgwYNGuD+/fvaplT2RRm5rWtjY6Nt3Dg5OaF69ep57qt+/fraf3t5eSE2NhYA0LNnT0RFRaFhw4ZQqVR6fQ4DwKZNm+Dj44NVq1YBAHx8fLBx40Z8/vnn+R5vUlISIiIitNPatGkDHx8fvY7n1dfiwYMHaNCgAVQqlfb4srKyEBkZCQ8PD531VCoVrKyskJSUBCcnp1yzZb8+Dg4OAF42su7fv4/GjRtrGzavXhBz69YtWFlZ6VypPWrUKJ1tZp8Es7CwQMOGDfHgwQOo1eoC1yuOLLlt08rKKtfXIjExMc/XyVCSNqWyzxiGhoYavI3169ejU6dO8PPz05keHx+P/fv3w9HREXXq1NG+wCWJRmkDSw2bUmQcGo0GmZmZsLCw4JlFotKi8SigWjfdadZOL//rUBYIyOcJKH1X536GVk9ly5bFrVu30LdvXwDAzZs34ePjo53/6tgH/1WmTBncuXNHO6bBrVu39N5vtl27dmH58uUYMmQIhBBo1KiRXoOObtq0CY0bN9bWFgqFAjKZDEePHs33imk/Pz84Oztj8eLFhT6e/74W2a9dixYtALx87Vq2bFlgdpMlkyFVZgWRwaYUGQdrGioxJPwcdnd3R1paGkJDQ+Hj4wO1Wo3g4GC9Povd3d2RkJCAqKgouLm5IT09XXurm76Sk5Nx8uRJJCYmQi6X49q1a/neApdNCIHNmzfD399f2wipV68eNm/ejPnz5+f5O+3u7g65XI6AgADUrFlTZ15GRkaBx/Pqa1G2bFncvn0bQgjIZDI8evQIGo1GOzbmf9WrVw+3b99G8+bNCzy+bD4+Pjr1wKv/9vPzQ2ZmJr766qs8mzvZQwMIIRAcHIyyZctCJpMVuF5xZMmLUqmERqPRfp+d9dUmpjGY9KibwcHBOHv2bK5XRF2+fBnLly/Hs2fP8Pz5c6xcuTLfwdXS09O1984CeC2PoBUW1rAUbEqRcYSHh2Pt2rUICAjg02qISgt7r5dfubGw+r9bBHLjViXveXqYNGkSOnTogJiYGGg0GmzcuFHvxwCPGzcOPXr0QFhYGJKTk7Fnz55cB93MT926dbFo0SI8evQIp0+fxtOnTwtcRwiBTZs2YcuWLWjdurV2uo+PDzZs2JBvU+rjjz9G8+bNER4ejrp160Iul6N+/frw9/cv9PF8/PHHGDJkCMaOHYubN2/i+fPnOldaFScp6hkASIcKIpNNKTIO1jRUYkj4OWxhYYHJkyejS5cuGDp0KE6dOoUyZcro1TixtLTEmDFj0KVLF/Tv3x8nT56ERqPJ94TSf9na2sLb2xtjxoxBhQoVsHfvXr3Wy74lf/369TrT69SpgyNHjuR5G75SqcTnn3+Ozp07Y+TIkXBze/ngjLfeegseHh6FOp7WrVvDxcUF3bt3R8uWLfHzzz/jww8/zHP5vn374siRI4VqSrVu3RoqlQq9e/fGG2+8gYMHD2rntWjRAvXq1UPr1q3Rr18/2NjYwNLSUucK9IkTJ6Jz5864cOEC7O3t0aJFC+1QBvmtVxxZ8lKlShVMnz4dFStWxIQJExAUFIQ6derAxUW/W1D1ZdKnHtavXw8PDw/07t1bZ/qgQYMQGhqKw4cP499//8WsWbMwZswY3Lx5M89tLVq0CI6OjtovfW8nLIqg8gEYJP+22PdD5sHJyQkDBw40+uWURGSeGjRogLNnz8LFxQVubm44f/486tatCwCoWbOm9ta2bNWqVUP37t0BvLxs/PDhw1CpVGjYsCHeeust7bgFry733+1UqVJFO2/mzJmYNGkSUlNTMWnSJKxYsUJ7C8Or23hVWFgYBg8ejFatWulMHz58OMqXLw8hhM66r/67cuXK+Pfff9GoUSM8e/YMISEh2jET8jue3F6LcePGYdOmTcjKykLr1q1x6dIlnachFScp6hkAGGG7Gqfch72WfVHpx5qG6KXFixfjyy+/RFpaGt588038/fff2lveBw4cqHPVFAD069dPe4vbihUrMGXKFGRmZmLevHmwtbXVfna9utx/t9OnTx/tvOPHj6NChQqwsbHBjh07MHny5Fz39aqEhATteJSvWrhwIZKSknKs++q/P/zwQ/z222/a2+lDQkK0J1ryO57/HoNcLsfx48fRr18/pKWl4euvv8YXX3yR5+s8ZswY7Nq1S/tQkokTJ2pvhXv1mAFgwoQJUCqVkMvlOHbsGNq3bw9LS0v8+uuvOsv+8ccfmDFjBpKTkxESEoLHjx/rbOenn36ChYUFOnTooPO+5rdecWTJa5vAy6cSuri4aAc6X79+vXbsMWOSCX2uhS9m2Y9S1meg82yZmZnw8fHByJEjc73U/lVCCLi7u+OTTz7BRx99lOsyuZ1Z9PX1RXx8fLHd+vfjPw/x7ZG7+HdB4c4eExFR6ZKWloZHjx6hQoUKhb60uiTKzMzE999/DyEEHjx4gF9++QUXLlxA5cqVpY5mkOI6ntze94SEBDg6Ohpcf0hRzwBAj5X/oEE5J3zRt07BCxMRlUCl7bP42rVrOH78ONLT03HkyBHI5XIcPnxY6lgGK+7j2b59Oxo0aICqVasabZt5kclkeg1JUJKo1Wp8/fXXuT6BMa/fHX1rGpO9fe/PP/9EZGQkxo4dW+CyMpkM9vb2OoOm/ZdKpdIOhPa6VIw/h7X4HkLTGTLeL09FlJKSgrt376Jq1aqwsbGROg4RmTEhBEJCQiCTyeDr62vSDSnAtI5HinoGAMalrYd47gHg69e+byp9WNMQFV1iYiJCQkJgaWmJoUOHYtgw076atbiPZ/Bg/QagN4b/Xp1kChQKRa4NKWMo8U2py5cvIyYmJsc4EOvXr4e/vz+qVNG9V1ej0SAmJkZ7DyoABAUF4fHjx2jcuPFryawve3U83pD/i7T0VFhZ20odh0xcfHw89uzZg4CAABZwRCQpS0tLLF++XOoYRlPajqc4VFA/QkpKnNQxqJRgTUNUdK1atcpxO7spK03Hw5pCl6RNqcePH+PixYuIiYkBAJw8eRJRUVGoWbOmdsT91atXIzAwUGc8qGfPnuHQoUP46aefcmxTrVajVatW6N27N2rVqoUnT55gxYoV6NKlCwYOHPh6DkxPCit7AEBaciKbUlRkXl5e+Oyzz7T3IxMREb0uWQprKNSpUsegUoI1DRGR+ZD0nrFHjx5h27ZtOHz4MAYMGIAbN25g27ZtOg2oxo0b5xhA9ObNmxg4cCD69++fY5sWFha4ePEifHx8cOLECcTGxmLdunU4cOBAoZ428DpYWNsBAFKT4yVOQqWBTCaDXC5nAUdERK+dWmkLiyw2pcg4WNMQEZkPSa+U8vf3L3Bg8/fffz/HtC5duuT5KEkAsLe3x6RJk4oar9hZWGdfKfV6HtdMpVtMTAwOHTqELl26GP0xnURERPnRWNhAlZwsdQwqJVjTEBGZD46uLSGlW2V8mjkGCUp+2BIREZHpuuvZHVsUOa9gJyIiIsoPm1ISsnLywC/qDkiQFd8jmsl8uLi4YOjQoTyjSEREr12s+xvYr24idQwqJVjTEBGZjxL/9L3SzFYhMEB+CppoN6CKu9RxyMQJISCEgEwm4xgMRFRqRUVF4f79+wAANzc3VK5cWa/1bt26BQsLC+1Tew3dDuWuTOYTdMo4CqBTgcsSFYQ1DVHJdvv2bcTHvxwXuUaNGnB0dCxwnfT0dAQFBaF69epwcnIyeDtU+vBKKQnZqhT4xnINbMIuSR2FSoGwsDB8/vnnCAsLkzoKEVGxuXz5MqZMmYKhQ4di9uzZeq0TFBSEZs2aYebMmUXaDuWtXGIQFsrXIDNLLXUUKgVY0xCVbKtXr8aUKVPQsWNHnDt3Tq91Zs2ahXbt2uH06dNF2g6VPmxKSchSZYUMoYAmPVHqKFQKODo6ok+fPjzDQERG9eLFC9y6dQsZGRnaaRcvXkTyK4Na//vvv4iMjAQAPH78GGFhYUhOTsbt27eRlZVl1DxdunRBYGAgPvzwQ72Wz8jIwOTJk3M8AKWw26H8Ka3soZAJpCQnSR2FSgHWNET/JysrC8HBwXj69Kl2WnR0NK5fv679Pi0tDefPn4cQAgBw6dIlqNVqhIaGIjQ01OiZVq5cicDAQFSvXl2v5c+ePYsnT56gXr16RdoOlU5sSkksRWYNTTqfVkNFZ2Njg/r168PGxkbqKERUCqSmpqJXr15o2bIlhgwZgipVqmgL4L1792LMmDEAgNOnT6Nv376wsLAAAHz77bcYPXo0atasiZ49e6Ju3br5Xu2g0WgQHByMxETdEzRxcXFGOY758+dj1KhR8PHxMcr2KHeK//9E4ZSkeImTUGnAmobopcDAQFSrVg1DhgxB8+bN0b9/f6jValhZWWHo0KHYv38/AGDy5MnYtm2b9nbXjh07YtCgQejcuTNq166NadOm5bufxMRE3Lp1S9vUAl7ebpeWllbkY0hNTcX06dOxatWqIm+LSieOKSWxNFgD6TyrSEWXmpqKhw8fomLFirC2tpY6DhEZwYsXL/DixYt8lylXrhzc3NwQFRWFJ0+eoGHDhgCAO3fu6FzN9Cpvb294e3vnu91ly5bB2dkZv/zyCwBg//79mDt3Lnbv3o158+ahY8eOWLhwIX788Uds27ZNOz4E8PIM7p07d2BlZYVx48bhq6++wvLly3Ps4+7du+jduzdkMhkiIiIwcuRIdO/eHUeOHIGHh0eBRXRBLl26hBs3buDLL7/EmjVrirQtyp+FzcuHtqQlsylFRceahkoKKT+HAWDEiBH44osvUKFCBQghMHHiROzbtw99+vTB9u3b0b17d0yZMgVBQUE6t8UBQKtWrbBr1y5ER0ejXr16GD58OBo0aJBjH2vWrMGcOXPg4OAAS0tLTJkyBb6+vvjqq6/w22+/wcrKqsCc+ZkxYwamTJkCDw+PIm2HSi82pSR2y6ImUhV8sggVXVxcHHbu3ImAgAAWcESlxA8//ID58+fnu8y6deswduxY/PHHH3j33Xe1ZzlHjhyJwMDAXNeZO3cu5s2bl+92z549iwcPHuDu3bvaadWqVQMAKBQKbN68GRUrVsTMmTPRpInuU9f69OmjLWKHDBmS55hN4eHh+PPPP6FWqyGXy7FhwwYsXrwY7dq1Q0BAQL75CqLRaDBmzBjMmTMHgYGBePToEWJiYnDjxg3UqVOnSNumnCwcPHBeUx12GRqpo1ApwJqGSgopP4cjIyPx8OFDrFixQjtNqVQiPT0dAFC7dm289957+OijjxAcHAxLS0ud9QcPHgwAcHV1RadOnXDlypVcm1KOjo64ffs2wsPDER4ejjVr1iArKwuzZs2Cq6trvhkLcu7cOZw9exZDhw5FYGAgkpKScOfOHTRu3BheXl5F2jaVHmxKSWyl0yeo6mCHHlIHIZPn6emJGTNmaG+hISLT995776F37975LlOuXDkAQN++fbVnZwFg06ZN+Z6hLYiDgwPee+89TJ06Ndf5K1euRIsWLbBr1y7MmDEDtra22nnZ40tl/9vBwSHXbXh6eqJPnz4AXjaoRo4cienTp+P06dPYsGFDjnGgCiMrKwvW1tZYsmQJACAiIgLx8fFYsmQJtmzZYvB2KXcWXrUwOGMOflaVlToKlQKsaaikkPJz2M7ODjKZDPv27YObm1uO+QkJCdi8eTNatGiBLVu24PPPP9eZHxkZiTJlymj/nddncXx8PGrXrg1bW1vtlVLe3t5YsWIF6tWrB09PzwKz5iUsLAwKhQJTpkwB8HLcyXXr1sHHx0fbNCNiU0pi9pZypKelSh2DSgG5XA6VSiV1DCIyIn0v7wcANzc3naI1+6omQwUEBGDgwIGwtrZG3bp1IZfL4eXlhfLly2Pfvn04dOgQzp8/jwULFmDcuHE6jZ6ff/4ZdevWhZubGz799NM8r5RKTEzEoUOH4OvrixcvXmDFihVYunQp2rVrh3HjxuW6TnJyMm7cuIGQkBBER0cjMDAQFSpUgKenJyIjIxEZGYmaNWvC0tJS5wz1mjVr8Pfff2tz5rcdKjxblRJKZCE5lTUNFR1rGioppPwctra2xttvv43+/fvj448/1m67Tp06sLW1xdixY/H2229j2rRpeOONN9C2bVt07NhRu/60adPwySef4MaNGzh//jx+/vnnXPfj4+OD0NBQKBQKnDx5Ev/73/+QlZWFqVOn5vmZGBISon2oSXBwMJycnNCkSRPI5XLcunUL7u7ucHd3R79+/dCvXz/tes2aNcPs2bPRs2fPArdD5kMmXh3NjLQSEhLg6OiI+Pj4PLvKxhC0pAfk6nTUm/F3se2DzENsbCyOHTuG9u3bw9nZWeo4RFQIaWlpePToESpUqFDksRuM6dSpU/jhhx8QEhICtVqNN998E+PGjcPgwYPx1VdfoVatWsjKysLbb7+NiRMnolWrVpgyZQpcXV0RERGBu3fvok+fPhg/frzRMgUHB2PkyJE606ZPn46BAwdi7969OHjwIP73v//lWG/37t24ePEiFi5cWOB2Xpfc3ndj1x+vq55JT46Fakl5BDb6Bs16jS22/ZB5YE1DUiiJn8WZmZlYtWoV/v77b0RHRwN4eQXW8+fPsWHDBmzZsgVyuRxBQUGYP38+tm3bBisrKzg5OWHr1q3YuHEjAGD27NmoX7++0XJ988032LFjh86048ePw9raWnt1WY8eOe8FGjt2LEaNGoWWLVsWuB0yHXn97uhbg7AplYfXVcRd/PZN2KU8Q41ZZ4ttH2QeoqOj8ddff6FHjx5Fvv+biF6vklgIG2rKlCkoX7689lJ9yltpakpBowYWuOBcrblo/mbRBqgnYk1DUihNn8VOTk4ICQnReQgJUXEpalOKt+9JTGNhB0sNL3WnonN1dcU777wjdQwiMnPly5fX+1YHKkXkCqRCBXV67uOnEBUGaxqionnjjTegVPJ/9ck08CdVYhoLG6g0KVLHICIiMgpeIWW+UmEFpCdKHYOIyOwdOXJE6ghEeuMIYlKztIO14JVSVHQvXrzAF198gRcvXkgdhYiIzFCq3BrISJI6BpUCrGmIiMwHm1ISu1/+LfRVfy11DCoFHBwc0Llz5+IdM4SIiCgPc5y/xiGX4VLHoFKANQ0Rkfng7XsSs7RzxtNMe6g1Agq5TOo4ZMJsbW3RpEkTqWMQURHw2SPmpbS93+nWXojJspA6BpUCrGlISqXtbzNRcSvq7wybUhIrm3wLayy+RXJSCzg48JG3ZLi0tDQ8efIE5cqVM/knhhCZGwsLC8hkMkRGRsLd3R0yGU9SlHZCCERGRkImk8HConQ0cvqn7kRWYiaAhlJHIRPHmoakwM9iosIzRj3DppTEHEQSWikuIiw+mk0pKpLY2Fj8+uuvCAgI4JOviEyMQqGAj48PQkNDERISInUcek1kMhl8fHygUCikjmIUFbPuQ54SLXUMKgVY05AU+FlMZJii1jNsSknM0u5lIyo1IUbiJGTqPDw8MG3aNNjY2EgdhYgMYGdnhypVqiAzM1PqKPSaWFhYlJqGFACoLexhrX4sdQwqBVjTkFT4WUxUeEWtZ9iUkpiV/cumVHpSrMRJyNQpFArY29tLHYOIikChUJSqJgWZF6FygLUmWeoYVAqwpiEp8bOY6PXi0/ckZmPvAgBIT2ZTioomLi4Oe/fuRVxcnNRRiIjIDMmsHGArUqSOQaUAaxoiIvPBppTEbJ3csThzCCItfaWOQiYuKysLkZGRyMrKkjoKERGZoTivlliZ1Q+Zao3UUcjEsaYhIjIfbEpJzMbGBmtFH7xQ+kgdhUycm5sbxowZAzc3N6mjEBGRGcr0boTN6i5ITGMjgYqGNQ0RkflgU0piMpkMXVQ3YBF1W+ooRERERAZzQTy6ywORlBgvdRQiIiIyEWxKlQCzsR5+z/+SOgaZuLCwMCxevBhhYWFSRyEiIjPkmvoY/7NcibTop1JHIRPHmoaIyHywKVUCpMptIU9PkDoGmTg7Ozu0atUKdnZ2UkchIiIzZGXvBABIS+TDW6hoWNMQEZkPpdQBCEhT2EKRmSR1DDJxdnZ2aNmypdQxiIjITNk6ZD9ROE7aIGTyWNMQEZkPXilVAmQo7WGRmSh1DDJx6enpCAkJQXp6utRRiIjIDGU3pTLZlKIiYk1DRGQ+2JQqAWKsKyACLlLHIBMXExODzZs3IyYmRuooRERkhixsHHFHlEOymhfiU9GwpiEiMh+SNqUyMjKwbds2+Pv7w8vLC2fPni1wnUqVKsHLyyvH18yZM3WW++WXX9C0aVOUL18evXr1ws2bN4vrMIrsVLnx+EY1XuoYZOLc3d0xceJEuLu7Sx2FiIjMkVyBYZbf4pZ9C6mTkIljTUNEZD4kbUrNmjULu3fvRkBAAMLDw5GRkVHgOufOncPVq1e1Xz/88APCw8Ph7++vXWbnzp0YOXIk3n33Xfz1119wc3ODv78/IiIiivFoDGdvZYHE1EypY5CJUyqVcHFxgVLJM9RERCQNeyslElILrueI8sOahojIfEjalFq8eDG2b9+ONm3a6L2Oh4eHzhVS+/btg5+fHzp16qRd5osvvsCIESMwduxY1KpVC+vWrYNcLsfq1auL4zCKrHnUDuxPHy51DDJx8fHxOHDgAOLj46WOQkREZmpt6ofwD/lW6hhk4ljTEBGZD0mbUnJ50XafnJyM7du3Y8yYMdptJSQk4Nq1azpNKqVSiQ4dOuDUqVNF2l9xUVpaw16kQKNWSx2FTFhGRgZCQkL0uuKQiIioOAi5JRQZCVLHIBPHmoaIyHyY9DWx27dvR0pKCkaNGqWd9uzZMwCAp6enzrKenp64evVqnttKT0/XecJHQsLrK6iUtk6QywQSEuPg4OT62vZLpYu7uzvGjRsndQwiIpKQlPUMAGRY8InCVHSsaYiIzIdJP31v/fr16NatG3x8fLTThBAAkOMedKVSCXU+VyItWrQIjo6O2i9fX9/iCZ0LSzs3AEBSbORr2ycRERGVPlLWMwCQZekAVRavlCIiIiL9mGxTKjg4GGfPnsW7776rMz37KR1RUVE60yMjI+Hh4ZHn9mbOnIn4+Hjt19OnT40fOg9WDi+vjkqJZ1OKDBceHo5ly5YhPDxc6ihERCQRKesZANConGCj5pVSVDSsaYiIzIfJNqXWr1+PMmXKoEePHjrT3d3dUb58eZw+fVpn+j///IMmTZrkuT2VSgUHBwedr9fFqkxNdEhfgnCriq9tn1T62NjYoGHDhrCxsZE6ChERSUTKegYAblcei/fUH7/WfVLpw5qGiMh8lPim1Icffgh/f3+daZmZmdiyZQtGjRoFhUKRY50PPvgAP/74Iy5fvgy1Wo1ly5YhNDQUAQEBryl14Tg62OOBKIvYDJnUUciE2dvbw9/fH/b29lJHISIiM2Xp7IMHGc7IyNJIHYVMGGsaIiLzIWlTavv27fDy8kLDhg0BAP3794eXlxeWLl2qXSY+Pj7HrXj79u1DZGQkxowZk+t2p02bhnfffRdt2rSBnZ0dli9fjp07d6J69erFdzBFYK9S4iuLH2H9+LjUUciEZWRk4NmzZ3xSDRERSaZcyi0st1iF+ETewkeGY01DRGQ+JH36Xu/evdG2bdsc0+3s7LT/XrZsGTIzM3Xmd+rUCeHh4drxo/5LJpPh66+/xsKFC5GYmAgnJyfIZCX3KiSZTIYuiku4E11D6ihkwqKjo/Hjjz8iICAA3t7eUschIiIz5IwENFGcxaO4SLg7O0odh0wUaxoiIvMhaVPK2toa1tbW+S6T21gIdnZ2Oo2rvCiVSjg7Oxuc73VKktkBqTFSxyAT5ubmhvfffx8uLi5SRyEiIjNl/f8f3pIcFwWgsrRhyGSxpiEiMh+SNqXo/yQrHKBIj5c6BpkwCwsLeHp6Sh2DiIjMmI3jy6vY0xKiCliSKG+saYiIzEeJH+jcXKRbOECZwaYUGS4hIQF///03EhISpI5CRERmys75ZVMqPYlXf5PhWNMQEZkPNqVKiKvOXXDKspXUMciEpaWl4datW0hLS5M6ChERmSlLOxesFgPwQs5xgMhwrGmIiMwHm1IlxCOvbtgv2JQiw3l4eGDSpEnw8PCQOgoREZkrhQV+th6Gx4pyUichE8aahojIfLApVUL4yKJQPfm81DGIiIiIiqS5xT2oooOljkFEREQmgE2pEqJ20mkszlwsdQwyYREREVi1ahUiIiKkjkJERGZsQtpa1A3bKXUMMmGsaYiIzAebUiWE0tYFVrJMpCYnSh2FTJSVlRWqVq0KKysrqaMQEZEZS7dwgEVGnNQxyISxpiEiMh9KqQPQS5YOL++Zj48Og7WtvcRpyBQ5ODigc+fOUscgIiIzl6lygVUir3Ahw7GmISIyH7xSqoSwcfYEACRGv5A4CZmqzMxMREREIDMzU+ooRERkxjTWrrDPipM6Bpkw1jREROaDTakSwt6tLB5ovJGQkip1FDJRUVFRWL16NaKioqSOQkREZizTsTwiNPbQaITUUchEsaYhIjIfbEqVEE6e5dAh4xs8sqoldRQyUa6urhg9ejRcXV2ljkJERGYsqtZovJUxC3GpvMqFDMOahojIfHBMqRJCpVTAXqVEdGKa1FHIRFlaWsLX11fqGEREZObc7CwBANGJaXCxtZQ4DZki1jREROaDV0qVIDsUn6LunW+ljkEmKjExEadOnUJiIp/gSERE0vFODsYt1SikPL8ldRQyUaxpiIjMB5tSJYncAsoU3jtPhklJScHFixeRkpIidRQiIjJjDk7OsJGlIyU2XOooZKJY0xARmQ/evleCpFo6Q5UeLXUMMlGenp748MMPpY5BRERmzs7FCwCQkcCmFBmGNQ0RkfnglVIlSKaVK6z5CGUiIiIyYTIrJ2RCiazECKmjEBERUQnHplQJorZ2gz2bUmSgyMhI/PDDD4iMjJQ6ChERmTOZDPEyRyCZQxKQYVjTEBGZD96+V4KEVByKeU/q4qAQkMlkUschE2NpaQkfHx9YWvJJR0REJK2lXouRZeWKDlIHIZPEmoaIyHywKVWC2Lj64E5mFFIy1LBV8a2hwnF0dESPHj2kjkFERIR0pyp4FpsqdQwyUaxpiIjMB2/fK0HKal5giXIN4iKeSh2FTFBWVhbi4uKQlZUldRQiIjJz/mlH0T1ms9QxyESxpiEiMh9sSpUgLpZqvKk8haTwR1JHIRMUGRmJFStWcPwFIiKSXPnMB2iTcUrqGGSiWNMQEZkPNqVKEAdXbwBAahwfoUyF5+LiguHDh8PFxUXqKEREZOZkdu5wFvHIVGukjkImiDUNEZH5YFOqBHF09QQAZCbwEcpUeCqVChUrVoRKpZI6ChERmTmlvTucZUmITUyROgqZINY0RETmg02pEsTCUoU42CErkU0pKrykpCScO3cOSUlJUkchIiIzZ+3kBQCIiXwhcRIyRaxpiIjMB5tSJcxvqgG4Y1FD6hhkgpKSknDixAkWcEREJDl739pYkdUf4cm8fY8KjzUNEZH5UEodgHSddH8LTsISI6UOQibHy8sLM2fOlDoGERERnH2qYYV6ID5Pt5I6Cpkg1jREROaDV0qVMLVUUXCLOi91DCIiIiKDKeQydLW9i/Twe1JHISIiohKMTakSpl3qIbwXt0zqGGSCoqKisGHDBkRFRUkdhYiICF+oV8An9C+pY5AJYk1DRGQ+2JQqYWT23nDTxEBoOAYDFY5SqYSLiwuUSt6VS0RE0ku0cINFSrjUMcgEsaYhIjIfkv+lz8zMxJ49exAcHIzhw4fDz89Pr/Vu3ryJEydOwMbGBn369IGrq6t23oEDB3D58mWd5T08PBAQEGDU7MXB0rksLGVZiIuJgJObl9RxyIQ4OTmhb9++UscgIiICAKRaecA6hU8UpsJjTUNEZD4kvVLq119/RaVKlbB27Vp89tlnePTokV7rTZ06FS1atEBQUBCCgoLg7++P+/fva+fv2bMHW7duRVpamvYrPT29uA7DqGzcfAAAMWGPJU5CpkatViM5ORlqtVrqKERERMiy9YRjVrTUMcgEsaYhIjIfkl4pVa5cOZw/fx5qtRq+vr56rbN+/XqsXr0a58+fR7169QAAkZGRyMjI0FmuVq1a+OKLL4yeubg5elXAfU0ZxCckSB2FTExERATWrl2LgIAAeHt7Sx2HiIjMXJZzFcSE3kPFLDVUSoXUcciEsKYhIjIfkl4p1bJly0J/0CxfvhxDhgzRNqQAwN3dHWXLltVZ7unTp1i2bBnWr1+P27dvGyXv6+DmXR4dM5bivkU1qaOQiXF2dsaQIUPg7OwsdRQiIiIk1H8X72TORESCaVytTiUHaxoiIvNhUgOdJyUl4ebNm/D398eJEyfwzTff4Ndff0V8fHyOZdPT0xESEoL9+/ejfv36mDdvXr7bTk9PR0JCgs6XFCwUcrjZWSI8PlWS/ZPpsrKyQrVq1WBlZSV1FCIikkhJqWcAwMvRCoBgTUOFxpqGiMh8mFRTKi4uDgCwbt06zJgxA8+ePcOqVatQpUoVXL9+XbvcxIkTcfXqVaxcuRK7du3C9u3bMX/+fJw5cybPbS9atAiOjo7aL31vJywOGzAPTW8vlGz/ZJqSk5Nx6dIlJCcnSx2FiIgkUpLqGe+MJwhWjUT644uSZSDTxJqGiMh86D2mVPXq1Qu14eDg4EKHKYitra323+fOnYNMJgMAtG/fHh9//DEOHjwI4OV4Uq/q27cvvL29cfz4cbRs2TLXbc+cORPTpk3Tfp+QkCBZIScsbKFK5SOUqXASEhKwf/9+lC1bVud3hYiIzEdJqmfsXDwhk2UiNeaZJPsn08WahojIfOjdlLpz5w6+++47vZadOHGiwYHy4+zsDA8PD7Rs2VLbkAKAVq1aYcuWLfmuK5fLkZSUlOd8lUoFlUpltKxFkW7tAed40xkHi0oGb29vzJkzR+oYREQkoZJUz8hsXJEJJdTxz6WOQiaGNQ0Rkfko1NP3PvjgA72WM2ZT6q+//sKzZ88QEBAAAHjzzTcRGBios8y5c+dQo0YNAC8fIfvvv/+ibt262vn79+/Hs2fP4O/vb7RcxUlt6wXnmH+kjkFERERkOJkMsQoXyBJfSJ2EiIiISii9m1KxsbF6b1TfZa9fv469e/dqB+H86aefcPr0abRp0wZt2rQBAOzevRuBgYHaptS8efPQunVrtG3bFi1btsT58+dx48YNHD9+HAAghMC7774LT09P1KpVC0+ePMGuXbswefJkdO3aVe9jkJLCsQxcnsQjMyMdFpYl42wnlXzR0dE4cOAAunXrBldXV6njEBERIdnSAxYpYVLHIBPDmoaIyHzo3ZRycnLSe6P6LqtWq5GWlgZLS0vMmjULAJCWloasrCztMj179kS9evW037u5ueHKlSvYuXMnHj9+jBEjRqBPnz5wdHQEACiVSgQGBuLIkSMICgpChQoV8Omnn+YYZ6oky6zWC/6XnbA1MRO+rmxKkX7kcjlUKhXkcpN6fgEREZViR2sswI4bCWgndRAyKaxpiIjMh0wIIfRdODY2FleuXEG7du3w66+/Ii0tDcOGDSsxYxcYU0JCAhwdHREfHw8HB4fXuu/7EUnouOwktgU0Q7OKPDtERERkLoxdf0hZzwDAtgtPMHP3Ddz5vBsslWwwEBERmQt9a5BCjSk1ePBgPHjwAHXr1kVERAQ0Gg1OnjxZ4CDjVDhlHVVYarEGmXeSgIqDpY5DJkKj0SArKwtKpZJnFomIqESokXUbq5TLERbbBuXc7aWOQyaCNQ0RkfkoVFPq1KlTePToEcqUKYPIyEhkZWVpBxgn47FWWaC94iruhNUEwKYU6Sc8PBxr165FQEAAvL29pY5DREQET8t01FNcwKXnj1DOvW7BKxCBNQ0RkTkpVFMqPT0d3t7eePvtt+Hm5gYAiIuLK45cZi9a4QlFwlOpY5AJcXJyQv/+/Qs1/hsREVFxci5TEQCQEP4IAJtSpB/WNERE5qNQTakPP/wQAPDzzz9rp7Vt29a4iQgAkGjlDeuU51LHIBNibW2NOnXqSB2DiIhIS+VaHgCQHhkiaQ4yLaxpiIjMR6Fu0l66dGmOaSdOnDBWFnpFul1ZOGWESx2DTEhqaiquX7+O1NRUqaMQERG9pLJDgsweIp5Xf5P+WNMQEZmPIo8cmJaWluOLii7GpxPWZXWDRqP3wxHJzMXFxWH37t28pZaIiEqUA+6jEaiuLnUMMiGsaYiIzIdBTal79+6hU6dOsLGxgbW1dY4vKjplxZbYktkBUcnpUkchE+Hl5YVZs2bBy8tL6ihERERaDysMxfHUilLHIBPCmoaIyHwUakypbCNGjICrqyt+++03DkBYTHzsgB7yQIQ/qwSP6jy7SAWTyWRQKg36lSYiIio2NS3CERp/EmpNOyjkMqnjkAlgTUNEZD4M+msfFBSEFy9esCFVjHzs5fjeciUuPywPsClFeoiNjcXhw4fRuXNnODs7Sx2HiIgIAFAz6Rw6K/+HsPhPUNbZRuo4ZAJY0xARmQ+Dbt/z8/NDVFSUsbPQKxyc3JAkrJEZ/VjqKGQihBBQq9UQguOQERFRyWHnWRHWsgw8fx4qdRQyEaxpiIjMh0FNqfnz52PUqFEIDAxEZGQkoqKidL6o6GRyOSIUnpDFsSlF+nFxccFbb70FFxcXqaMQERFpufpWBQDEPbsrcRIyFaxpiIjMh0G373l6euLGjRto3rx5rvN5VsM44qx9YZP0ROoYRERERAazdKsEAEiNeCBxEiIiIippDGpKjRs3Dp07d8b48eM5rlQxinWpj7Tn/6KO1EHIJLx48QJr165FQEAAvL29pY5DRET0kpUDbqrqIzxJLXUSMhGsaYiIzIdBTanHjx8jMDAQjo6Oxs5DrwivHYDZ92+gU5YGlkqD7rQkM+Lo6IhevXrx95KIiEqcrdVW4drTOLwrdRAyCaxpiIjMh0GdjsqVK+PFixfGzkL/4edqAyuRhmfRcVJHIRNgY2ODhg0bwsaGTzYiIqKSpbyLNeJiIjjEA+mFNQ0RkfkwqCk1YsQIDBs2DMePH8fTp08RGhqq80XGUdEyFresRiPx1jGpo5AJSE1Nxe3bt5Gamip1FCIiIh3tIzZjD6YiOjlD6ihkAljTEBGZD4OaUtOnT8fly5fRvn17lCtXDr6+vjpfZBweZSogQyiQGn5P6ihkAuLi4vDbb78hLi5O6ihEREQ6bDwrwV0Wj6dh4VJHIRPAmoaIyHwYNKbU7du3jZ2DcqFQKvFM4QUR80jqKGQCPD098fHHH0OlUkkdhYiISIerbzUAQMzTu0DlchKnoZKONQ0RkfkwqClVvXp1Y+egPMSqysI68bHUMcgEyOVyWFtbSx2DiIgoByvPKgCA5PD7ADpKG4ZKPNY0RETmw6Db9xISEvDrr7/mmP7rr78iISGhyKHo/6TZlYNj+jOpY5AJiI2Nxe+//47Y2FipoxAREemycUWKzAbqaF79TQVjTUNEZD4Makp9+OGHSE5OzjE9KSkJH3/8cZFD0f+5X2syemQsglrDp9VQ/jQaDRISEqDRaKSOQkREpEsmwzc1tmNtZg+pk5AJYE1DRGQ+DGpK/f777xgwYECO6QMGDMDvv/9e5FD0f3zLeCM5S45nsXz6COXP1dUVI0eOhKurq9RRiIiIcvD29sHDqGRoeKKNCsCahojIfBjUlNJoNIiOjs4xPTo6GhkZfNSvMVVx1GCb5eeIvnlY6ihEREREBmuWfgYbZQvwLI4n2oiIiOglg5pSnTp1wvTp05GUlKSdlpiYiGnTpqFjRw5eaUxe7u6oK3uI9KdXpY5CJVxYWBgWLlyIsLAwqaMQERHl4O1giRaKW3j89InUUaiEY01DRGQ+DHr63pIlS9C6dWv4+fmhQYMGEEIgKCgI9vb2OHnypLEzmjWZXI5nSl/Io+9KHYVKOHt7e3To0AH29vZSRyEiIsrB2bcWACDm8b9APT7JmfLGmoaIyHwY1JTy8/PDjRs3sGXLFly5cgUymQx9+/bFO++8A0dHR2NnNHvxthXgkMSn1VD+bG1t0bRpU6ljEBER5UruVhlqyJERFix1FCrhWNMQEZmPQjWl7t69i6pVqwIAHB0dMXHixGIJRboyXSrDO+QshEYDmdygOy7JDKSnp+Pp06fw9fWFSqWSOg4REZEuCyvEWHjBMu6+1EmohGNNQ0RkPgrV4ahXrx6qVauGDz/8EMePH0dWVlZx5aJXZFbrjakZ4xCdnC51FCrBYmJisHXrVsTExEgdhYiIKFdnq87A5pQWEIJP4KO8saYhIjIfhWpKRUdH4+uvv0ZCQgKGDRsGNzc3DB48GD/99BOioqKKK6PZK1OpDo5pGuJ+ZIrUUagE8/DwwNSpU+Hh4SF1FCIiolxZVu+My2llEJXEpzVT3ljTEBGZj0I1pWxsbNCnTx+sW7cOoaGhOHr0KGrWrImVK1fC29sbLVu2xKJFi3Djxo1ChVCr1YiLiyv0lVdqtRpqtTrfZdLS0gq1zZKonIstxigPIDH4uNRRqARTKBRwcHCAQqGQOgoREVGuqltF40Plb3j4PFLqKFSCsaYhIjIfBg9QJJPJ0KhRI8ydOxcXL17E06dPMXr0aFy4cAEtWrSAn59fgdt4/vw55s2bBz8/Pzg7O+P06dN67TsoKAjt27eHtbU1PDw8MGXKFKSmpuosM3fuXDg5OcHOzg5VqlTBwYMHDTrOksBSKccIy2OwDzkkdRQqweLj4/Hnn38iPj5e6ihERES58rFIxkTlH4h8/K/UUagEY01DRGQ+jDZqtpeXF8aMGYPdu3cjOjoaa9euLXCdzZs3QwiBnTt36r2f4OBgtGnTBg0aNEBMTAzCwsJQpUoVnauzvvvuOyxfvhz79u1DSkoKRo0ahb59++L+fdMdWDPGyg82CQ+kjkElWGZmJsLCwpCZmSl1FCIiolxZeFYDAKQ+uyVxEirJWNMQEZkPmTBgpMmrV6/mOU+lUqFcuXKwtbXVe3uhoaHw9fXF8ePH4e/vn++yAwYMwOPHj3Hp0qU8l6lUqRL69u2Lb775RjutfPnyGDhwIJYuXapXpoSEBDg6OiI+Ph4ODg56rVOczq2diArP98NrHhtTREREpZWx64+SVs8AQPznFXDEuisGTl8tdRQiIiIqJvrWIEpDNt6gQYN85ysUCgwaNAg//vgjbGxsDNlFrtRqNQ4ePIi5c+cCePm42P8+JjYqKgoPHz5E69atdaa3adMG58+fN1qW183Cqya8nm9BQlw0HJxcpY5DREREZJAE+0pwirsPIQRkMpnUcYiIiEhCBt2+t27dOlSrVg2///47QkJC8PjxY+zatQtVqlTBd999h7/++gtXr17FrFmzjBo2MjISKSkpSEtLQ+3ateHg4ABXV1dMmzYN6enpAICIiAgAgJubm866Hh4e2nm5SU9PR0JCgs5XSeJctQW2ZnXAg+d8yiHlLjw8HEuWLEF4eLjUUYiISCIlvZ4BgKTKfXAusyqexaUWvDCZJdY0RETmw6Cm1IoVK/Dbb7+hX79+8PPzQ7ly5dC/f3/s2LEDa9euRZcuXbBp0ybs2bPHqGGz7zRcvnw5NmzYgPT0dPz999/4+eefMWfOHJ1lNRqNzvdZWVn5no1btGgRHB0dtV++vr5GzV5U5arUwTwxFtfjVAUvTGbJ1tYWzZo1K9Sts0REVLqU9HoGAJxaj8V6dXfcfpEodRQqoVjTEBGZD4OaUvfv34ePj0+O6T4+PtrBxGvWrImoKONe1ePu7g5LS0u8/fbbaNKkCYCXtxKOGDECe/fuBQCUKVMGAHKcWYmIiNDOy83MmTMRHx+v/Xr69KlRsxeVhUKOFq4pSHh4UeooVELZ2dmhdevWsLOzkzoKERFJpKTXMwDgZWeB1taPEBLyUOooVEKxpiEiMh8GNaWqVq2KL774AllZWdppWVlZ+Pzzz1G1alUAQFBQEN54440iB0xNTUVi4sszaUqlEi1atNDeqpctLS1NO7aUk5MTateujaNHj2rnazQaHDt2DK1atcpzPyqVCg4ODjpfJc0Hst/QJeRrqWNQCZWRkYEnT54gIyND6ihERCQRU6hnZEKNjWIObB8ekDoKlVCsaYiIzIdBTanvv/8eGzduhJ+fH3r06IHu3bvDz88Pmzdvxvfffw8AOHLkCBYvXpzvdjIyMhAXF6cd7yApKQlxcXFIS0vTLjNx4kQ0b95c+/2sWbPwyy+/YMeOHXj+/Dl2796NjRs3YtSoUdplPv30U2zcuBFbt27Fw4cPMWHCBKSnp2PcuHGGHG6JofaoBd/MEKhfaQYSZYuOjsbGjRsRHR0tdRQiIqK8KVWIti4P27hgqZNQCcWahojIfBj09L1WrVrh0aNH2Lx5M27fvg2ZTIYuXbpgxIgRcHJyAgAsWLCgwO3s3LkT48ePBwA4Ojpi2LBhAIAZM2ZgxowZAAAbGxuds3wdO3bE1q1bsXDhQkycOBHlypXDsmXL8O6772qXGTp0KFJTU7F48WKEh4ejTp06OHbsGLy9vQ053BLDzq8BrO9l4PGDm/CrVl/qOFTCuLu7Y8KECdrfQSIiopIqzaUmfJ/eRlJ6FuxUBpWjVIqxpiEiMh8ykT16OOlISEiAo6Mj4uPjS8yl77FRYXBeVQ2X3/gGjXqMlToOERERGZmx64+SWM8AQNiBr2EfuBS3R/yLxhXdpY5DRERERqZvDaL37Xt9+/bVe+eFWZb05+zmhVuySgiPjpM6CpVACQkJOHToUIl8/DcREdGrXCs3QSg88OjJE6mjUAnEmoaIyHzofb30nj17kJSUpPeyVDy+LrcGMjXQXeogVOKkp6fjwYMHaNiwodRRiIiI8mVRxR9TXFajXrQF3pQ6DJU4rGmIiMxHoW7it7e3L64cpKca3g44ePm+1DGoBHJ3d9eO0UZERFTS1SvrgDtPwwDUlToKlTCsaYiIzIfeTalz584VZw7SUzvFdXyUEYCoF9fg5u0ndRwiIiIig7wf8xWexIQiJaM9bCw52DkREZE50rsCaNasWXHmID2Vq9YA8jMCoTfPsClFOiIiIvDLL7/grbfegoeHh9RxiIiI8mXjXQN1np3Cv8/i8UYFV6njUAnCmoaIyHzoPdA5lQyePpUQBSekPr4odRQqYaytrVG3bl1YW1tLHYWIiKhArlWbwVmWhId3b0odhUoY1jREROaD10qbGJlcjlCbGrCNuiZ1FCph7O3t0b59e6ljEBER6UXh2xgAkPLoAoC20oahEoU1DRGR+eCVUiYo1b0eyqbdh9BopI5CJUhmZiZevHiBzMxMqaMQEREVzMYFMaqysIz6V+okVMKwpiEiMh8GNaWOHTsGIYSxs5Ce1E3eQ4u0FQiJSZU6CpUgUVFRWLt2LaKioqSOQkREpJdLHX/DrKSBiEpKlzoKlSCsaYiIzIdBTanOnTujUqVKWLBgAZ48eWLsTFSA2hV8kA5LXHsaJ3UUKkHc3NwQEBAANzc3qaMQERHppUaligBkuB4aJ3UUKkFY0xARmQ+DmlJPnz7Fe++9h19++QUVKlRAly5dsH37dqSn8yzX6+BkY4nv7TbA+fzXUkehEsTCwgLe3t6wsLCQOgoREZFefBCOg1azEHr7gtRRqARhTUNEZD4Makp5e3vjk08+QXBwME6dOgUfHx+MHTsWZcqUwcSJE3H16lUjx6T/8rQBvKICpY5BJUhiYiKOHTuGxMREqaMQERHpRWbniSp4jAw+VZhewZqGiMh8FHmg85YtW+Lrr7/Gp59+iqSkJKxZswYNGjRAu3btcPfuXWNkpFxkeTdEhcz7SEtNljoKlRCpqam4fv06UlM51hgREZkISxvE2leFS8xVZGTxAS70EmsaIiLzYXBTSqPR4ODBgxg0aBDKlCmDLVu24Msvv8Tz588RHBwMb29vDBw40JhZ6RVuNf1hKcvCw2v/SB2FSggPDw9MmTIFHh4eUkchIiLSm/BthoYIxo1n8VJHoRKCNQ0RkfkwqCk1e/Zs+Pn5YcCAAbC2tsbff/+N27dvY/r06XB3d0e1atWwceNG3Lx509h56f+rUKspEoU1EoJPSR2FiIiIyGAuNfxRXh6Of4ODpY5CREREr5lBTan9+/dj5syZeP78OTZv3ozWrVvnWEalUuH3338vckDKnUKpxHdeX+KnzLZSR6ESIjIyEv/73/8QGRkpdRQiIiK9KSq3w+ce3+DUM96+Ry+xpiEiMh8GNaVcXFwwfvx4ODo65pjXsWNH7b/79u1rcDAqmGP1tjgZCmSpWcTRy0ZwpUqVoFKppI5CRESkP2snOFdvi/OPk6DWCKnTUAnAmoaIyHwoDVnp6NGjuU7XaDQ4fvx4kQKR/lp6C3hpvsPDf51QtW5TqeOQxBwcHNClSxepYxARERVaR+U1OKt/we0XzVC7bM6TnmReWNMQEZmPQjWl7t+/n+u/gZcNqbNnz6Js2bLGSUYFqlG+LKrLA3H15mGATSmzl5WVhbi4ODg5OUGpNKjfTEREJImKtumorjyKn+4+Qu2y9aWOQxJjTUNEZD4K9Ve+SpUquf47m5WVFb777ruipyK9qKxs8K+qOlTPAqWOQiVAZGQk1q5di4CAAHh7e0sdh4iISG+WFVsCAGJvnwTa1Zc2DEmONQ0RkfkoVFPq0aNHAIAKFSpo/53NwsICnp6ePJvxmiV6NEG10N+gUashVyikjkMScnV1xahRo+Dq6ip1FCIiosJx8kOiyhMO4eeRkaWBpdKgYU+plGBNQ0RkPgrVQSpfvjwAIDExEXZ2dsWRhwrJoVYnOIeux70bZ1Glfs6nIJL5sLS0RLly5aSOQUREVHgyGbL82qBZcCAuP45F80psRpgz1jREROZD76ZUcHAwAKB69eoIDQ3Nd9nq1asXLRXprXLD9vjywEh4h1si5w2VZE6SkpIQFBSEBg0asGlMREQmx7H1+/jyvh/c70awKWXmWNMQEZkPvZtSNWrUAAAIIbT/zosQfJzv62KpUuFRpeG4HpKJ0VKHIUklJycjMDAQVatWZQFHREQmR+7bGFlVFTh1LwqfdJM6DUmJNQ0RkfnQuyn19OnTXP9N0uvmm4nY498hKaE67BycpY5DEvH09MRHH30kdQwiIiKDDXK8hYM3ziMqqQnc7FRSxyGJsKYhIjIfejelfHx8cv13tpCQEHh4eMDGxsY4yUhvTcvZw0fxF65e6IX6HYdKHYeIiIjIIPVwB9WUv+Ofux+hb0NfqeMQERFRMTPo0SaXL1/GxIkTtd8PGzYMFSpUgJeXF86ePWu0cKSfshVr4rnME+nBR6SOQhKKiorCunXrEBUVJXUUIiIig9jW6AJXWSLuXjsjdRSSEGsaIiLzYVBTavr06Rg8eDAA4ObNm/jzzz8RGBiIjz76CDNnzjRqQCqYTC7HU5fmKBt9FkKjkToOScTCwgJeXl6wsLCQOgoREZFhfN5AhsIGViHHkZ6lljoNSYQ1DRGR+TCoKXXp0iU0atQIAHD48GH069cPTZs2xdSpU3H16lVj5iM9qWp2g494gSd3r0odhSTi6OiIXr16wdHRUeooREREhlFaIs3PH23ERZx7EC11GpIIaxoiIvNhUFPKzs4OISEhAIB9+/ahffv2AID4+Hg+IUMi1Vv0wmrRH8dDUqWOQhJRq9VISEiAWs0zy0REZLrsW72Pw1ZdcOhmmNRRSCKsaYiIzIfeA52/auDAgejRowdq166Nq1evolevXgCAQ4cOoVu3wj3D98WLF1i/fj2Cg4Mxa9Ys1KhRI9/lN27ciKNHj+pM8/X1xaJFiwq1TGljZW2LG1U/wLP7qRgpdRiSREREBNauXYuAgAB4e3tLHYeIiMggsoptkVnPHUeCnuNLjYBcLpM6Er1mrGmIiMyHQU2pZcuWoXLlynj8+DHmz58PZ2dnAEBwcDDmzp2r93aWL1+OZcuWoUePHti6dSvGjh1bYFPq/PnzuHv3LiZNmqSd5uTkVOhlSqOeVaxxY89ahD8rC8+yFaSOQ6+Zi4sL3n77bbi4uEgdhYiIqEj6ekYgM3UPgp42RCM/fq6ZG9Y0RETmw6CmlIWFBSZPnpxj+tdff12o7fTs2RMTJkxAeHg41qxZo/d65cqVw7Bhw4q8TGnTsooHOil34MrpCvAcPEPqOPSaqVQqVK5cWeoYRERERVZDfQ+zLbbi26C30civmdRx6DVjTUNEZD4MakoBQEpKCoKDgxETE5NjXseOHfXahqEfNrdu3UJAQAAcHR3RunVr9O7d26BlShtHZzfcsKoH24cHALApZW6Sk5Nx8+ZN1K5dG7a2tlLHISIiMpi8enfID0xH4o2/oO7dFArewmdWWNMQEZkPg5pShw8fxltvvYXo6NyfiiKEKFKo/MjlctSpUwf169fHs2fP8M4776Bbt2749ddfC7XMf6WnpyM9PV37fUJCQrEdQ3FKqdwDjW5+iaiwp3Dz8pU6Dr1GiYmJOHr0KPz8/FjAERGZqdJSz8CxLJLd66N12GkEPoxGy8puUiei14g1DRGR+ZAJAzpINWvWRO/evfHJJ59ox5MqitDQUPj6+uL48ePw9/fPd9nIyEi4u7trv7948SKaNm2KvXv3omfPnnov81/z5s3D/Pnzc0yPj4+Hg4ODAUcljbioMNh+VxNXanyEpkNmSh2HiIiICiEhIQGOjo4G1x+lpZ4BABG4GuqDs7Cg2h9YMLSN1HGIiIioEPStaeSGbPzx48f47LPPjNKQKqxXm00A8MYbb6BcuXK4cOFCoZb5r5kzZyI+Pl779fTpU+MGf02c3Lyw0/U97Ar3kDoKERERvWalpZ4BAFntAbjgOwZHgyOQlqmWOg4REREVA4OaUtWrV0dISIiRoxguOTm5yMuoVCo4ODjofJkq27YT8dsLLzyJTpE6Cr1G0dHR2LRpU5631RIRUelXmuoZ2HnAq/dcPEu3xt+3w6VOQ68RaxoiIvNhUFNq3LhxGDFiBI4fP46nT58iNDRU58uY1q9fj5kzX96GlpmZiV27dunMX7VqFaKiotCjRw+9lyntOtXwxADLQNw6vF7qKPQayeVyODg4QC436NeaiIioxKlom4HFLn/iaOAVqaPQa8SahojIfBg0ppRMlv8TUPTd5D///IMffvgBKSkp2L17Nzp27AhPT0/0798f/fv3BwCMHTsWgYGBuHnzJjQaDd5++20EBQWhRo0aePLkCe7fv4/Fixfj/fffBwC9ltFHUcd0kNqlZQPhkXQLvrNvQsYPdCIiIpNg7PrD1OsZpCcia3FlfJPRF29N+xa+LjZSJyIiIiI96FuDGPT0vdu3bxsc7FVly5ZF165dAUDbhAKAypUra/89duxY9O3bF8DLsya//vorQkJCcO3aNTg7O6Nu3bpwcnLSLq/PMubAqsk7KPf3cNy+eAQ1mnaROg69BhqNBunp6VCpVDyzSEREpYPKHqjZG0NunMBvFx/jwy41pE5ErwFrGiIi82FQU6p69epG2XnFihVRsWLFfJdp1qxZjmnly5dH+fLl811Pn2VKs5rNeyD0qBeSzv4IsCllFsLDw7F27VoEBATA29tb6jhERERGoXxjFPxu/oYHFw4iq2M1KBVsUpR2rGmIiMyHwZ/qycnJ2LNnD7799lvttLt37+p96x4VL7lCgaflB6JO3HHEx0RKHYdeAycnJwwaNMjsrgokIqJSrlxzpDtVRteMQzgaHCF1GnoNWNMQEZkPg5pSd+/eRa1atfDee+9h2rRp2umff/45tm/fbrRwVDSVu7yHOeox2HuTTy4xB9bW1qhRowasra2ljkJERGQ8MhlUPRfjjNub2HQmROo09BqwpiEiMh8GNaWmTJmCQYMG4cWLFzrTJ0+ejKVLlxolGBWdu1c5JFQbhJ8uh/MKNjOQkpKCK1euICUlReooRERExlW5I1q364ZzD6Px7/N4qdNQMWNNQ0RkPgxqSp07dw6ffvppjqfwVa9eHTdu3DBKMDKOkW+44f2Yr3Hz9F6po1Axi4+Px59//on4eBbrRERU+nR1CMHPNt9i4z/3pI5CxYw1DRGR+TCoKaXRaJCRkQEAOo2pkJAQODo6GicZGUXTqr6oZ/kMmjPfSR2Fipm3tzfmzp3LAUGJiKhUUqps0UpzERk39iAiIU3qOFSMWNMQEZkPg5pSnTp10t6ml92UioqKwqRJk9C1a1fjpaMik8nliKnzLuqlXcTj4CtSxyEiIiIyjHc9ZJVrhdGKA9jAsaWIiIhKBYOaUt988w127NiBGjVqQAiBdu3aoUKFCggJCcFXX31l7IxURPW6jUEUnBB2+NuCFyaTFRMTg19++QUxMTFSRyEiIioWypYfoL7sHq6fO4zY5Ayp41AxYU1DRGQ+DGpK+fn54fr165g0aRJGjRqF8uXLY+HChbh69SrKlClj7IxURJYqK9wrPxS1ow8jmh/upZZMJoNCocgx1hsREVGpUaUL1M4VMQBHseHMI6nTUDFhTUNEZD5kgo9ly1VCQgIcHR0RHx8PBwcHqeMUWVx0JPovP4Qerd/Ah52rSR2HiIiIcmHs+qO01TMAgKh7WByYgp8vhuH0J+3haGMhdSIiIiL6D31rEKW+G7x69areO69fv77ey9Lr4eTqjo7NG+HnM/cwpokHnJycpY5ERiaEgFqt5plFIiIq3dyqYHTbdPx+/i42nHmEqZ2qSp2IjIw1DRGR+dC7KdWgQQO9N8qLr0qmd1uWw9Dz/RC8szuajV0mdRwysrCwMKxduxYBAQF8Wg0REZVq7pGBOKMcj76nv8bIFuXhbGspdSQyItY0RETmQ+8xpWJjY7Vf69atQ6VKlbBjxw6EhIQgJCQEO3bsQKVKlfDjjz8WZ14qAndHW4R7+aPW018QHxMpdRwyMicnJ/Tr1w9OTk5SRyEiIipevk0hs3VBAH7Hd8fuS52GjIw1DRGR+TBoTKk6dergp59+ynGb3tWrV/HOO+/g+vXrxsonmVI5BgOAqLCnsF3dEFfLvYPmY76ROg4RERG9gmNKFcL5H6A5MAOdM5diw7ShKOdqI3UiIiIi+v/0rUEMevre/fv34evrm2O6r68v7t/n2aqSzM3LF9e8BqDOk62IDg+VOg4ZUWpqKm7cuIHU1FSpoxARERW/hiMgs/PEx6pd+PpQsNRpyIhY0xARmQ+DmlLVq1fHggULkJWVpZ2WlZWFBQsWoHr16kYLR8Wj+pvzcE9WDtuOXZQ6ChlRXFwcfv/9d8TFxUkdhYiIqPhZWEHWYTaqejvjwPVQBD2JlToRGQlrGiIi82HQ7Xvnzp1Dz549YWVlhfr160MIgatXryIjIwN//fUXmjZtWhxZX6tSfbk7gDUnH2DpoTs4PLUNKrrbSR2HjECj0SArKwtKpRJyuUH9ZiIikhhv3ys8tUag53enoZTL8MeEllDI+bQ2U8eahojI9BXr7XvNmzfHw4cPMWPGDJQrVw5+fn6YOXMmHj58WCoaUuZgZIvyaGYXjmu/zpE6ChmJXC6HpaUlizciIjIrChnwv1rBcHxxGlvPP5Y6DhkBaxoiIvOhNHRFR0dHTJw40ZhZ6DWyslBgSu1UNL6yHrfOdULN5t2kjkRFFBsbi7///hsdO3aEs7Oz1HGIiIhemwrP9mKZ/WN0OVgHXWt7wcPeSupIVASsaYiIzAdPP5ixhj3ewx1lddgc+RgZ6WlSx6Ei0mg0SE9Ph0ajkToKERHR6yOTAV0WwT0jFKPlf+HzfbelTkRFxJqGiMh8sCllxuQKBZR9VsBHHYrL27+UOg4VkaurK4YNGwZXV1epoxAREb1eXrUhaz4e4+S7EHT9KvbfeCF1IioC1jREROaDTSkzV6lOM1z0GozKDzYjNCJa6jhEREREhmk7AwpbN8z3/Aef7r6BsHheBU5ERFTSsSlFqPP2Ioy2XIrZfz2AAQ9jpBLixYsXWLBgAV684NlhIiIyQyo7yEbsRcMxq2CpkOOjndeg0bCuMUWsaYiIzAebUgQ7B2dM6d8WV+6E4Oj+36SOQwZycHBA9+7dS+0jv4mIiArkWgnO9jZY007g7r27+PH0Q6kTkQFY0xARmQ+Dn75HpUuHGp5YWe4kmlzYgadVq8O3Sj2pI1Eh2draonHjxlLHICIiklZWBhoGTsE2jzLodNAZdco6oXkljk1kSljTEBGZD14pRVpN3lmIaLkrUrePRWZGutRxqJDS0tJw584dpKVxDA0iIjJjSkug9wpUSLiAOe7/4INfruBFfKrUqagQWNMQEZkPNqVIy8bOEam9VqNC5gNcXj9J6jhUSLGxsdi2bRtiY2OljkJERCStyh2Bpu9jeNIG1Jc/wPitV5CRpZE6FemJNQ0RkflgU4p0VG3oj8vVP8QbYdtx/J9/pI5DheDh4YHp06fDw8ND6ihERETS67QAMq+6WOm8Hf8+i8fsP27wgS4mgjUNEZH5YFOKcmg6eCaWlF+HCUeScTc8Ueo4pCeFQgFbW1soFAqpoxAREUlPqQIG/wzbd37Dov518dulUKz7hwOfmwLWNERE5oNNKcpBJpdj0tv9UM7JCgfWL0BCXLTUkUgPcXFx+OOPPxAXFyd1FCIiopLBwRuwc8eAqkqsqXEDiw4E48itcKlTUQFY0xARmY8S8fS9iIgIPHz4EDVr1izw0a+PHj1CeLhuMWFjY4O6devmWPb58+eIiIhA5cqVYWdnZ9TMpZ2NpRJr+5WB0+afEbLmCmp+eABKC0upY1E+srKyEBMTg6ysLKmjEBERlSy39qLro0X4zPdTTN6mwI73m6NWGUepU1EeWNMQEZkPmZDw5vqgoCAsXrwYR48eRVRUFI4fPw5/f/9813n//fexY8cOVKlSRTutUqVK2Lp1q/b79PR0vPPOO9i7dy98fHzw/PlzLF26FOPGjdM7W0JCAhwdHREfH19go6w0u3FqN2ocHY1LngPRbPw6qeMQERGVasauP1jP/H9CAH+Mh7i5C9Ntv8S59Ir4Y0JLeDhYSZ2MiIioVNK3BpH09r2goCD06dMH58+fL9R67dq1Q2BgoPbr1YYUAHz++ec4ffo07t+/j3v37mHLli2YMGECLl68aMz4ZqFOm364XHMGmkX8hvM7vpE6DhEREVHhyWRAr+WQlWmAr7MWw00TgXd/uoy0TLXUyYiIiMyapE2p0aNHY+jQobC0LNxtYRkZGbh+/ToeP36c61NU1q9fj7Fjx6Js2bIAgAEDBqBmzZrYsGGDUXKbm6aDP8F5t/6IuXEIZ+9FSh2H8hAWFoZFixYhLCxM6ihEREQlj1IFDNkKhbUjvmsrx52wBHz42zWoNXwiX0nDmoaIyHyY5EDn+/fvx5AhQ9CwYUNUqFABhw4d0s57/vw5wsLC8MYbb+is07RpUwQFBeW5zfT0dCQkJOh80f9p9N4P+MV3Psb9EoRHkUlSx6Fc2NnZwd/fn+OnERGZMdYzBbB1A8adg1+rwVgxpAEO3HyOeXv/zfUkJ0mHNQ0RkfkwuaZUp06dEBoailu3biE8PBwDBgzAgAED8PDhy0f8xsTEAABcXFx01nN1dUV0dN5PkVu0aBEcHR21X76+vsV3ECZIaWGJVW83Rjure0hd3Q7xMbxiqqSxs7ND8+bNWcD9v/buOzyqMnvg+HdqJpPee0JJCCQ0KVKkI1iwy4rooisotrXrihW7outP17Z2xIplFSwgTUCCIL23BNJ779Pv74+BSASkhdwkcz7PM0+SO3PvnLmTuTk5973nFUIIDyb5zAnQu0fon5f3Oj/2WMYna7N5ZWm6ykGJw0lOI4QQnqPdFaWuvPJKIiMjAdDr9cyaNQu9Xs/8+fMBMBgMgPtM4eEaGxub7juahx56iOrq6qZbbm7uGXoF7VeA2cB9V44gxpVP3ttXYmmsVzskcRir1cqBAweO+N0XQgjhOSSfOQl+UaQc+JCPeu/itWXpfJiWqXZE4iDJaYQQwnO0u6LUn+n1ekJDQ8nPzwcgLi4OrVZLQUFBs8cVFBSQkJBwzO14eXnh7+/f7CaOFJfYi/zzP6SrdRe73rgap0zV22ZUVFTwySefNI0WFEII4XkknzkJQ26HgTcyMv05Xu6ZzVM/7uK9Xw+oHZVAchohhPAkbb4odeDAAbZt2waAoihYLJZm92dkZJCVlUVqaioAZrOZwYMH88MPPzQ9pqGhgaVLlzJ27NjWC7wDSxl8PnuGvUbvujRWv3279GFoI8LCwrjrrrsICwtTOxQhhBCi7dNo4IIX0aRcxhWZM3lqoI1nF+zmtWXpktuoTHIaIYTwHHo1n7y0tJT9+/dTWuruT7Rr1y5MJhOxsbHExsYC8Nxzz7F27Vp27NiB3W6nf//+3HzzzaSmppKTk8MzzzxDnz59mDx5ctN2n3nmGcaPH89jjz3GkCFDeO211wgODmb69OmqvM6OqO+4a1jbUMtTa2Hsz3uYcX53NBqN2mF5NL1eT2BgoNphCCGEEO2HVgeXv4Nm7ZtcN3gCNUHZ/HvxPkprrcy8OAW9rs2fv+2QJKcRQgjPoepf2nXr1nH33Xfz7LPPMmjQID7++GPuvvtufv7556bHdO3alT59+gBgNBpZtGgReXl5vPDCCyxcuJC7776bNWvWYDKZmtYZPXo0y5YtY+/evcyaNYvExERWr14tQ9hb2OBLb2byhPF8vHIXCz98GsXlUjskj1ZdXc1PP/1EdXW12qEIIYQQ7YfeCMPuAb2RfyZV8sEoG1+sy+GGj9ZTY7GrHZ1HkpxGCCE8h0aR8clHVVNTQ0BAANXV1VLMOo7l82czevPd/B5yGQNu/QCdXtUBeB6rtLSUb7/9liuuuEKGuwshRDvV0vmH5DMnae61sP8Xdo54m8nLTIT6evH6NWeRGh2gdmQeRXIaIYRo/040B5Gi1DFIEndy1n/7H/ptnck2nyEk3zYXs68kb0IIIcTJkqKUyuyN8OUUOLCc0tEv8Y/NSaSX1PHohB5MGZwgrQqEEEKIE3SiOYhcKC9axMAr7mL7iLdJrt9I/itjKK6Q4dZCCCGEaGcM3jD5C+h7DWHL7mF+v01cc3Y8j8/fyU0fb6Co2nL8bQghhBDihElRSrSYvmOvpvDKeSxgGBPeWs9vGWVqh+RRiouLefnllykuLlY7FCGEEKL90hng4tdg/DPoE8fwxCWpvHfdALbmVTPu/1by+e85uFxyocGZJDmNEEJ4DilKiRbVtfdQrrn7RZIjfVny0ROs/eB+nA6H2mF5BLPZzMCBAzGbzWqHIoQQQrRvGg0MvQMie4HDyrht97L8byYu7BXFw99t55r317K/tE7tKDssyWmEEMJzSFFKtLgwPy8+njqIcV39ODvnffbOGklexg61w+rw/Pz8GDFiBH5+fmqHIoQQQnQc1jpoKMf3i0uYFTSfz2/oS0GVhQteXcXLi/disTvVjrDDkZxGCCE8hxSlxBmh02oYesPz7Dn/CwIcpYR8Mpq1nz+DyymJ25lis9nIzc3FZrOpHYoQQgjRcfiEwPU/wqgZsPo/DF02kSVX+3PLqK68s/IA415ZyfI9JWpH2aFITiOEEJ5DilLijEoZcgFB961nW/glWHYv5qp31pJZVq92WB1SeXk5H374IeXl5WqHIoQQQnQsOj2M/BdMXwFaPV7Vmdw7rhs/3z2chGAfbvhoPbd8spGCqka1I+0QJKcRQgjPoVEURTo1HoVModzy1mYU869vd5FY+zvTu9sYOOlhdHq92mF1GHa7ncrKSoKCgjAYDGqHI4QQ4hS0dP4h+cwZ4HSAVufuO7XsaZTkC/mxPIqnf9xFndXB3ecmccM5nTHo5NzvqZKcRggh2r8TzUHkr6VoNYMTI/j57uFcG1vO4PSX2TdrOLkZ29UOq8MwGAyEh4dL8iaEEEKcSTq9uyBlrYWMJWg+GMfFpe+x9K7BXDUgjhcW7uGi19LYkFWhdqTtluQ0QgjhOaQoJVqV2ahn7M0vseu8ufg5Kgj7ZDRrP3tKZuhrATU1NSxevJiamhq1QxFCCCE6Pi8/uHEZjHoIfnsd/zljeaK/he//OQyTUcfEt9fwwNdbqaiXvkgnS3IaIYTwHFKUEqpIGXIBwfetY0v45UTs/ZTr3v1Vek2dJovFwr59+7BYLGqHIoQQQngGnQFGPgA3rwS9F+z+gZ4xAXx761Cevbwni3YWMeblFcxdl4PLJR0zTpTkNEII4Tmkp9QxSA+G1rN+by73zc/AqyaLp5KzGHj1I+gNRrXDEkIIIVqd9JRqx5x2UBTQG2HTJxCWTFlQH55bsJtvN+XTLz6QZy7rRUq0vA9CCCE6PukpJdqNgclx/Hz3cO7uWsTZGf8h84Uh7N++Vu2whBBCCCFOnM7gLki5XLDlc/hgPKGrZvJ/lyYyd/pgaiwOLn4jrakhuhBCCCGkKCXaCLNRz4QbHiLj4m8xKDbiv7mQNe/fg9XSoHZo7UZJSQmvvfYaJSUlaocihBBCeC6tFv7xI4x/BjZ+BG8NYbBrCwvuHM7945P57Pdszn15JT9sLUAuWDg6yWmEEMJzSFFKtCnJA8YQ/eB6NiRMo0ful/zj9R9ISy9TO6x2wWQykZKSgslkUjsUIYQQwrNpdTD0n3DbbxDcCX5/B6Ney62jurL03pH0ig3gji82c9U7a9ieV612tG2O5DRCCOE5pKfUMUgPBvVl5Bbw8E/Z7Mgq4J3wb0ma+ASR8UlqhyWEEEKcMdJTqgNSFLDVuWfr2/szVOyHs6eTdqCap37cSXpJHRP7xfLA+cmE+0kRRgghRMcgPaVEu5cYF82XNw/mrfP96V6zGv8PzmHNRw/JJX3HYLfbKS4uxm63qx2KEEIIIQ7RaNwFKYCi7bD4UXh7GMP0u1hw53CeuiSVJbuLGf3SCt5akYHF7lQ33jZAchohhPAcUpQSbZpGo2HUqHGY7tnEtqiJDMh8h9JZ/di86ge1Q2tzysrKePvttykrk8sdhRBCiDZp5AMwfSWYAmHOxei/ncqUPv6suH8UfxsQx8uL9zH+lV/5ZU+x2pGqSnIaIYTwHHL53jHIcPe2KXvPJmq/u4fnai/Et/tYHpvQg7gQH7XDahNsNhulpaWEhYVhNBrVDkcIIcQpkMv3PISiwNa5sGkOTJkHBhMoChmldTzx/S7SMsoYlxLB4xelEBdsVjvaVic5jRBCtH8nmoNIUeoYJIlruxSXi592FPH0Dzt50fYMxk5DOOvqxzF5e17SJoQQomORopSHURT35X2l++CbqXDesyidR/DT9kKe/nEX1Y12/jk6kZtGdMFLr1M7WiGEEOKESU8p0WFptFou6h3NsnvOwRjdkwFZ71L2Yj+2//qd2qGpqra2lhUrVlBbW6t2KEIIIYQ4ERrNH997+cLHl6D5ZioXdday7L5RXD+kE68uTef8V1fx675S9eJsZZLTCCGE55CilGi3fM1mhtz8JvmTl1JtCKPXL/9g9avXUV5nVTs0VTQ0NLBp0yYaGqQRvBBCCNGuhHWDGxbCZW9D5q/wxtn45q7goQt7sPCu4UT4e3Hdh+u49dONFFQ1qh3tGSc5jRBCeA65fO8YZLh7+6K4XGyY/wYLt+XxneZcHjs/kcsHdEKjlbqrEEKI9kMu3xM0VMCyp2DE/RAQCw4ris7I91sLePan3VQ32vn74ARuGdmVMD8vtaMVQgghjkp6Sp0mSeLap7I6K8/8uIs+O55noE8xAX97k7jEnmqHJYQQQpwQKUqJZiw18PYw6DMZht9LrUPLh2lZvJ92ALvTxXVDOjF9RBdCfaU4JYQQom2RnlLCI4X6evHq1WfR/9xJBNsKCftkFGvmPIzN2vEv6SstLeW///0vpaWe03NCCCGE6NB0Ruh9Fax6Gf57Dn5F67jr3CTS/jWG6cO78PnvOQyftZwXFu6hot6mdrQtRnIaIYTwHFKUEh1S71FXEnT/RjZHT2Lggf+SN+tsNu0vUDusM8poNNKpUyeZOlkIIYToKAwmGPMo3LIKzMHw0YWw8kUCzAbuHZ9M2oOjmTqsE5+syWLEi8t5bVk69VaH2lGfNslphBDCc8jle8cgw907jv3bfiPt5y95onI8l/YK596BJuKTeqkdlhBCCHEEuXxPHJPLBRtnQ3gPSBgKVblgDgGjmYp6G28tz+DjNdn4exu4c2wiVw+Mx6iX889CCCHUIT2lTpMkcR2L06Xw5fpc9i75gMfsr7Ep6HxiL3uC6E7JaofWYhwOBzU1Nfj7+6PX69UORwghxCmQopQ4YR9fCiW7Yfj90P960HuRV9nAK0vS+XZzHvHBZu4bn8xFvaLQajVqR3tSJKcRQoj2T3pKCXEYnVbDNYPieei+f7Eh+X66Vq0mdPYQfn/9ekoLstQOr0WUlpby+uuvS/8FIYQQwhNc9Cp0HQs/Pwiv9YONc4j1N/LyVX34+a4RJIX7cucXm5nwehrLdhfTns5DS04jhBCeQ0ZKHYOcWezYGuqq2frtv0k58AEvuq7Fd8hUbh3ZlUBz++1dYLVaKSwsJCoqCi8vmYVHCCHaIxkpJU5a6T5Y8Rzs/wXu3OLuPXXQhqwKXlq0l98zKzgrPpAHxiczNDFUvVhPkOQ0QgjR/rWbkVIrVqzg6quvpm/fvmzYsOGk1p09ezZ9+/blpZdearb82WefpW/fvs1uEydObMmwRTtn9g1gyHVPo7l7OyHn/INP1mTz04tTWPPRDOprq9QO75R4eXnRqVMnSd6EEEIITxLWDf720R8FqYYK+OgiSF/CgIQg5k4fzCfTzsalwDXv/841761lVXppmx45JTmNEEJ4DlUv0p4xYwZr1qzh8ssv58svv6Suru6E1925cyczZ85EURTy8/Ob3Zebm0tYWFizYpW3t3eLxS06Dv/AEO49L4QpQ7qS8el39M98j9qXP2d78i2cdfndeJnMaod4wurq6ti6dSt9+vTB19dX7XCEEEII0ZoOjZBqrASXAz6bCPFD0Zw7k+FJgxmWGMrS3SW8unQfUz5YR/dIP6ae05lL+kZjMujUjf1PJKcRQgjPoepIqccee4yVK1ee9CimxsZGJk2axGuvvUZISMhRHxMQENBspFRycsdpaC1aXpi/iSG3vUP51N/YH3gOA/e8SNkLfflyTTp2p0vt8E5IXV0daWlpJ1XcFUIIIUQHE9IVblgI13wNtlr48DxY9hQajYZxKRH8eMcwvrhpMLFB3vzrf9sY9NwyHv5uOxuyKtrM6CnJaYQQwnO0iZ5SeXl5xMXFsXz5ckaNGnXcx0+fPh2Ad999l759+zJq1CheffXVpvtvueUWfvzxR+Lj4wkICGD48OHcc889JzVaSnoweLbsvVtY/csPPJLTjy6BBp7rfoD+F05Fb2i/PaeEEEK0fdJTSrQolwt2z4fABIjpB/mbQGeAyF4AHCit45uNeczbnE9BtYW4YG8u6RPNxX2iSY7wQ6NpX7P2CSGEaDtONAdpd3Osfv3116xYsYLNmzcf8zF+fn7cfPPNjBw5kvz8fJ588knmzZvHb7/9dsxpZa1WK1artennmpqaFo9dtB8JyX1JSO5Lv6Ialsz7hEGbH6Zgy/+R0+16ek64DV//ILVDFEIIIY4g+YxoRquF1Mv/+Hn1f2DXPEgaD4Nvo0uXUfzr/O7cPz6ZdVkVzNucz6drc3hz+X6Swn25uE80F/WOokuYXEInhBDizGhXI6WysrIYOHAgCxYsYODAgQBHHSllt9sxGAxNP2dmZpKUlMScOXO49tprj7rtJ554gieffPKI5XJmUQBkbF1N1bL/o2/1LzRoTKQl/JOkC+8kKcJP7dCalJWVMX/+fC699FJCQ9v+zDpCCCGOdLojmySfEX/J6YDtX8OaN6B4B4SnwqRP3Jf8HWRzuEjLKOWHrYUs3llEvc1Jzxh/Lu4dzUV9ookJPPN9WiWnEUKI9u9Ec5p2VZR64403mDFjBomJiU3L9u7di6+vLzExMWzcuBGd7uiNGhMTE5k4cSIvvPDCUe8/2pnFuLg4SeJEM0W5GWQueIX/FYbzjWUAV0YU8bfIIhJHTyE0Ml7V2Kqqqvj1118ZMWIEgYGBqsYihBDi1JxuUUryGXFCFAUyf4X178Flb4OXL6x7DwLioOsY0LvbFVjsTpbvKeGHbQUs212C1eFiYKcgLukbw4U9IwnxPTOz40lOI4QQ7V+HLEqVlZWRl5fXbNmkSZMYMGAADzzwAH379j3qena7nZCQEB588EEeeeSRE4pJejCIv2J1uJO0quWvcUXZO+hwscerN3VJl9Bt1LUEhUWpHaIQQoh2SHpKCVUoCrx/LuRvAFMA9LgYUq+AziNB5259UWd1sGRXEfO3FLAqvQyA4UmhjE+JZGjXEBJCzNKDSgghRJMO01PqqaeeYtu2bXzzzTeEhoYeMYTX29ubsLCwpoKUzWbj+eef54EHHsBsNmOz2bj33nuxWq387W9/U+EViI7IS6/j/J5R0PN5qsvvZu+KL/DeN5/+O57l1a372Np5Glf28GZ09ygCgsNaJSan00lDQwNms/mYIwaFEEIIIY6g0cCNS6FkF+z4FnZ+C5s/g3t3gX80VGTiGxjP5WfFcvlZsZTXWVmwo4jvt+Tz6LztuBSIDjDRNz6Q5Ah/kiP96BbhS1ywGYPu5Cf7lpxGCCE8h6pFqe+//57HH38cu90OwI033oivry+33HILt9xyCwA5OTns2bPnhLdpMBjQ6/UkJCQQGBhIcXExcXFxLFy4kG7dup2R1yE8W0BIBGdfeTdwN+Ul+cTtKWf97nryF/wb70U/ssU8EEePy0geOQm/gOAzFkdJSQnvvvsu06dPJypKRmoJIYQQ4iRoNBCR6r6NeRTKM9wFKZcLZl8IihNSLoOeVxASezZTBicwZXACNRY76zMrWLO/nB0F1Xz0WyaVDe7c3qDTkBDiQ5dQH7qG+9I1zJeuYT50CfMlwNtwzFAkpxFCCM+h6uV7FRUV5OTkHLE8MjKSyMhIAHJzc2loaCA5Ofmo2zi8p9ThXC4XmZmZBAUFERx88oUAGe4uTldpQRb7V35G4P4f6O7YjVUx8GX4HQQNu4mxPcIxG1u2JmyxWMjJySE+Ph6TydSi2xZCCNE65PI90eYoCuRtcI+e2vkd1BaCfyzc9Av4RRzl4QqltVYySurYX1rH/tJ69pfWcaC0nvyqxqbHRQWYOLtzMEO7hjCkSyjxIeam+ySnEUKI9q9d9ZRqiySJEy2pKCedrF8/ZW5ZF+YVhTLFuJwr/HZjixtGRJ9xJCT3Q6M9+eHtQgghOhYpSok2zeWCnDVwYDmMfsQ9umruteAXBZ2HQ8I54HPs2fIabA4OHCxS7SyoYe2BcnbkV+NSIC7Ym2GJoQxLDGNo1xCCfIyt+MKEEEK0NClKnSZJ4sSZklvRwJ4ls4nN+JSutr0YNU6q8OU7/ynkJE2hT7CTFO9K4pL74e3jd8Lbra+vZ+fOnaSmpuLj43MGX4EQQogzRYpSol1x2mHhg7D/F6jMdC8L7gJT5kFQAhTvAr0XBHWGY5x8q260sy6zgtUZZaxKL2V/aT0mjZ2hwY10696DIckx9Ij0I8zPSxqpCyFEO9JhGp0L0dHEBZuJm3Q7cDsNddXs3bSCuv2/Ue3oysq9pVRVLuIyw1u4FA252ihKzV2pihiMrd+N9IsPJNz/6MPYa2pqWLx4MXFxcVKUEkIIIcSZpzPARf/n/r46D7JWQ+EW8HO34eDnGZC5Egw+EN4dwlOg/w0Q279pEwHeBsalRDAuxX0pYGF1I0s27OXA6h9YvMXE26vzAQg0G4gO8Cbc34sgsxGjTotR776ZDFpMeh0mgw6TUYdJr8Xf20CEv4lIfxOhvkb0p9BwXQghxJknI6WOQc4sCrU01NeQt3cTVZlbcBXvxLd6H/ttQdzVeBN+NPCD+QmKg/pjSBxN8rDL8fELVDtkIYQQLURGSokOpbYYindA8U73zH7FO91N1LudBxtmw/ZvoNMwSBoHMf3dlwMeRlEUsssb2Ftcy76iWopqLJTUWqlusGN1urA5XFgdTqx291eL3UWj3YnT1fzfG63GfVKwa5hvU9P1LqE+dA7zIcxXRmAJIcSZIJfvnSZJ4kRboigKJbVWtu7eQ8C6V4is3ECCKw+rYmC7zxCyx7zFuJ6R+JuOPZONEEKItk+KUsJj7FsMm+ZAVhpYqsA/xt2n6qxrT3vTdqeLqgY7JbUWSmqsFFQ3kllaz4Eydz+r3IoGDtWtzEYd8cFmEkLMRPqbCDAbCfA2YDJo0aBBo4HDS1aH/+Ok02gI8TUS6utFQoiZQLP0wRJCiEOkKHWaJIkTbV1B5h5yVn9JcX4Wd1VOJFzXwBTT7/Tu0YUB510jI6iEEKIdkqKU8DhOB+Suhd0/QJfRkHw+5Zt+5KeV65gwbgwhqSOPGEF1uqwOJ9nlDWSW1ZNT3kBWeT05FQ2U1lqparBT1WjD6nDxV/8laTQccX+EvxfdIvxIifInJdqfnjEBdA7xQauVkVhCCM8jRanTJEmcaE8KqhpZumo1zs1fcZlrISbFwm6/wTi6XUTY0L/TKcQsQ9OFEKIdkKKUEFC5eg6/LF/BGMdSggICIfUy6H0VRPZSJR5FUY6aRzmcLirqbZTUWjlQVs++olr2FNWyu7CG/KpGwD0Sq0eUP6nR/vSMDiA50o/EcF98vKS1rxCiY5Oi1GmSJE60VwWZe8hZ9Rmh2T9hszu40PY8/iYdc/VPYDUGYfcKxqU3oxjM7Ez4O4p3CAk16wm0FqI1eKE1mNAavLEHd0Ub0pVws47IABMGo5faL00IITo8KUoJcZDLCdmrYed3sOt7GH4fDLkN0pfCqn+7L/cz+YPBDKFJ0P8f7qFLGz4Evck965/eC3Re7r5VRjPYG933tcKJusp6G7sKa9iRX83Oghp2FlRzoKy+aXRVTKA3ieG+JIX7khThS5+4QLqF+8moKiFEhyFFqdMkSZxob1wuF3a7HYPBgPbgtMtVNbVsLbKwK7eMfjufx7uhAJOjGqOrEaNi5UbNU+Q4g3lWeY1LtWnNtveyfSKvO69glHYLHxpeolQTTLGpC/XBPdDHDSRkwBV0kiHpQgjRoqQoJcRRchpFAacd9EbIXuMuPNUUgLUG7A0Q0ROumgN2CzwXDYqz+Qbv2QUBMfDV9bDvZwjqDJE93SOvup0PYcmt8roabA72l9STXlJLekkd6cXurzkVDSgK+Jv09EsIYmCnYAYkBNEnLhCTQdcqsQkhREuTotRpkiROtDeFhYW8++67TJ8+naioqJNe3+V0YrNZsFoasVkbsOFFHWYqCw+gPfALzvJMzJV7iGzMINsVylW2mQR6afjY9BINgcno4/sT1rU/wVGd8PULRKM99tTLLpeC3WHDYW1Epzdg8vY5nZcuhBAdhhSlhDj9nAanA5xWcBy8+YaDVuduql60HcrS3V+Ld8IFs6DfFNi7ELZ8DtF9IfosCO0GPuHuQtjxHHoeo4/7eU5Sg83B1txqNmRVsD67kk3ZldRZHRh0GnrGBDQVqfonBBHiKyPXhRDtgxSlTpMkcaK9aWxs5MCBA3Tp0gVvb+8z+lwV1TXsLLGyNzObflufJLJhD9FKSdP9/VwfozGYedk1i55KOjqcGBQHehw84ryJ/zmG8XfdEp4xzHZvD39KDLHkRYzBOeQORiSF4W2UM4NCCM8jRSkhWjGncbnA5XAXnvYsgLVvQcEWsNW670+5zD0CqzILPjjPPQLLaXffFCc8Wux+3HtjIH8jaA3gHw0RqTDsXogbeEphOV0Kuwtr2JhdyYbsStZnVlBUYwGgS5gPfeMCSYnyp3ukPz2i/KRQJYRok6QodZokiRPi5FSWFlKQvpmGqiK2+o3C6nDRrfB7fC1FoDOg0RlAZ6AkbCiNAV0JbMglpG4XLpsFZ1Uexop97GoM5LG6icQaank18Ct8R9xGcv8xfznqSgghOhIpSgmhMpcLKg5AZSZ4B0HsAGiogHXvgUYLB/MZtAY4+yZ3f6qMpdBYBY2VUJUDhVthzKMQdzZs/hSq82HADe4RW6dAURTyqxrZmF3JuswKduRXs7e4FovdBUCYnxfdI/3oEeVPcoQf3aPczdS99HKCTwihHilKnSZJ4kR709DQwL59++jWrRtms1ntcE5ZZlk9635bzjmb7ydWKWSfvhu1Z91Mn/HXoTecwBB6IYRox6QoJUTHyWkASHsFVr7oHpHVcyIMvQMiUk57s06XQnZ5PXuKatlTWMPug7P+5VW6Z/3TaTV0DvWhe6Qf3SP9SI70p3ukH7FB3jIjsxCiVUhR6jRJEifam9Puv9DGuJxOtq/8Gu3vb9PLupkfdedSPvZl/jYgFrNRplEWQnRMUpQSouPlNDRWwqaP4fd3oSYPblgICUPPyFPVWuzsK65jT1ENe4tqm4pWNRYHAL5eerpF+NI9yl2kSo7wo3ukPwFmwxmJRwjhuaQodZokiRPtjaIoKIqCRqPpcGfAMrau5uvNRby/z5sLvLZzbWwJncffSmRcotqhCSFEi5KilBAdOKdx2mHPj9DjEndD9KVPuGcO7H4RGExn7GkVRaGoxsKeQneRam9RDXuKatlfWofd6f5XMCrARLcIP+KDzcQGeRMbZCYu2JuYQG+CfYwd630QQrQKKUqdJknihGh7cisa2P7tS4zKfRMTNnZ79aa+x0SSR0wiICRC7fCEEOK0SVFKCA/hsMFnV0Lmr+AVAKmXQq+r3COoTmEGv1Nhc7jILKtnz8EiVXpxLXmVjeRWNFBvczY9zqjXEulvIjLARFSA+2uk/6HvvYkKMBHm64VWK4UrIcQfpCh1miSJE+1NRUUFixYt4rzzziM4OFjtcM6o2uoKdv/yGeY935Bi2cpDzpvIiruCKzrZGJYUSkyXVLVDFEKIUyJFKSE8K6ehLB22fem+1ZXAvw6A0Qdy10F4D/Dya/WQFEWhutFOXmUjeZUNFFVbKKyxuL9Wu78WVVuwOV1N6/h66Uk+2L+qR5R7VsDkSH98vY7eckFRFCob7ORWNDQ9T0FVI/U2J1aHC7vDhVGvxWTQ4m3QYTLoMBv1+JkO3Qz4H/zqZ9Lje3C5NHcXou040RxEGrMIIdodv4Bgzr78DuAOSguy6X+gntKMelyr/03MmqXkaqIpCBqArstwEgZcQFhknNohCyGEEEIcKTTJPVPfqIfdM/4ZfdyjqD65HJw2iB0InYZBp+EQNwj0Z37SF41GQ6DZSKDZSM+YgKM+RlEUKuptFNVYKKiykFHi7mO1PquCuetzcbrc4x7ig80kR/rh66XH4VIor7NSdLDA1XDYaCxfLz0xgd74mvQYdVoMei3VjXYa7U4sB2/1Nie1FnvTrINHYzJoCfdzj+QK9/dyj+gK9KZLmA+JYb7EBHrLiC4h2hgZKXUMcmZRiPanvraKvb/9gH3fUiIrN5LgyuU5+2QWBlzF+cHFjNFtwZxwFpHdBhIe3RmNVqt2yKfM5XRSUVpAZVE2tSVZ1NdUkuZzLoVVFqZkzSDWuh8fGtArDvQ4uF15kJ3eA7hau5SRynoa/TqhCU3EHJVMWNd+RETHS78IIdoAGSklhACgMgv2LXJf3pe92t0s/f4M8A2DDR+CywlRfSA8Bbx81Y62GavDSUZJHbsL3U3W9xbXYnW40GogxMeLiIOX/sUFH+xd5afD31GKprYQqvMhqBPEDYT8TfDDXVBbBA6Lu0hnDsV+13ZqLQ5M/5uCDQN1PglUmuIo9Yon19CZggYorrZQVGOhuMZKQVUjVoe7kOVt0NE9yo++cYH0jQukX3yQzEgoxBkiI6WE8DAdtinoSfDxC6TfeVPgvCkAlBXl0D+nFleJhsCMNaRWfYJ/9tvwK1TjQ5rPeNZ1u58eEd6cpc8mNrkfPn6BqsVvt1mpsTiotipYSjNxlOzDVl+Bo6oAagrYq+nE98pI/Cp38671AUI1TkIPrlut+PCwOYWoQDOVvok4QrqhMQWC3ohGZ2BUyCi6uwIJL4hGKdYRXf4bkSXfYtzt5JPF5/KC9ibOCanlJtdXOIKT8IpMIaRTT6K7pGAwnPmzskIIIcQhktPgLswMutl9c7mgbJ+7IAWQvhTSF4HLcfCxneHi/0CXkVCV4x5pFdy51XpT/ZmXTktqmBep0QdHWeWug4YqqC+D2kKoKYBed0NQFCx6BNa80XwDg29zF6W8gyCmH/hFg9EMOiN4B2HQaQn2MUJoPObinQRmrie2rsi97k2/QEx/2PgRFO+E0G64QrpRaExgX703GSX17Cio5pc9JcxenQVAiI+R3rEB9IwJIDU6gF6xAUQHmE76d8/qcFLVYKe8zkZlg416qwO9ToNOq0Wv1aDTajAZdE2XJHobdJiMOkx6HQadB/+uC48nI6WOQc4sivamw02ffAYoLheFOemUpG+kMW8rGRZ/Pmo4B0P5Hn42PghAniaSUnMijcEplPa7iy5hfnQO0uPr43Pc7TvsNuprKqm1uahRfKivLkOf+xv2+kpcjVUojVXY7A7mB91AjcXO1MInibLl4OOqxVepx6yx8nfbQ6S5enGP/mvu0n8HQIPiRZkulN99xrAm9kYSfOwMrl+GMSgWn9A4gqM7ExwWg1Z3csmnw26jODedrAoLO+oDsWRv4Pyc/yPKkYM/DQBkKxFMC3iPTiE+/KPmLfQGE4o5BJ05CJ05gMa4kXj7hxDkqsTXqMHHPwizj3+7HoUmhJpkpJQQktOcEIcVSnZDyS538aX/DRCa+EeRR+8N4d0hIhV6XArdxoPzYBFLd5xxCYri3r61Bg6e4KJ4F5TthcYqsFSDpQpiz4buF0LhNvjxbvfyQ/f7hMF9u93b+79UqMlzf+8TBn5RcMlrEH0WZK+BigPgH+UuPgXEnFofLWsdlGdAWHf3TIarXoatX0LF/j+Kd6MfhZEPQMFm2PwpDTp/8qwmDtTq2Vbjw1cViZTVWYnXFKP18iUgKJSIIH8iA0x4Hywe2Z0u6q0Oaq0OKuttVNTbqGiwUVlvp87qOPm4D9JpNU29s7yNWkx6nfs5DTq89FqMOi16nQaD7o/vtQeLtloNaA9+df98cJlWg+bgfX4mPRF+JqICTXSP9HcX9YQ4w6TR+WmSJE60Nw0NDezbt49u3bphNpvVDqddsVgayd2zgcrMLbiKduBbtQeNtY4JlqcASPO6k0DqqdP40qD1waXR8ar5LjJ0nflbw1wusS3AR2nArLEC8LFjHI87biBVk8lPXo8A7sJSncaHSl0Ij4a9RoC3gUk1H+GntaKYAtCYAtCag2iMG4FXcCzB1OKvt+MbGIqPb0CrFnkUl4vyolyKDmylpLyCFQwgp7yeGQV34eusxE+pJYB6AMZaX2K/EsOL+ne4Sr8SAKeioV5j5nP95czznURPfR7XWOZiN4Xi8glD5xeOLigOTdI4wny9CDUpeJuPX/QTwhNIUUoIyWlOS305FG1zF6pKdkHxDki9HIbdAwdWuntVmQLAO9Bd/AmIg6s/c6/79jD3KCZLDbjs7mU3LXePVlrwL1j3DqABk7+7WNX/HzD8XqjIhLT/c2/XFOC+zyfU/bzgvhRR7+0e+dQKPbGacdrd8ZXthZBEd/P4jKWw5AlorICGCnA0QswAuGkZxdWNhL8ShQb3v8g2DDRozNxqmkWmM5zJyo+kkEWDIQibKRSXOZSakN4Q0o1gby3BPgaC/HwINhsxe+lwuRQcLgWnS8HudGF1uJr1yWq0/flnJxZH8+VWhxO7072+3enC7lCwOV3uEYWAS1FwudxfFeXgz4d971QUahodVDfam3ZLpL+J/glBnJMYyrDEUOJD5HMmWp4UpU6TJHFCiOpGO5ll9di3zMVZXYRiqUZrqQLFxW/hk6n2jqNb7Vo6W/eg8fJD5x2AzhyAEpyILqon/gaFQE09voGhGL1Mar+cFuVyOqmrraLW5UWdTcFetBtnRRb2hmqcjdUojdVkmnqw26s3fhXbuaDobcz2KgJclQQqNWQqUZxr+zcAm72m442VBo03jRpvLFozbwTNoNq3K6Msv9Ddth2X3oxiMIPRTGVQX2oiB+NPLVFVm9Gb/PDyDSAkJpHgsGgZpSXaNSlKCSHOmOo8SF/s7k9lqQZrLZhDYYz7BBq/uv8uYwoAL3930SphiLuY1Fjlvs/LHzra31mHzd2zyuTvvlQyO829byw17q/Wajh7unu/rHoZ9i2G+hL35YjWGjj3CXfRb88CmHsNGH3dfb6Mvu6RalfNcT/PD3eBRue+FNHg4/7a91p3Aa9wq7t3lsEM5hD35ZvGli0UWexO8iob2VNUw478GtZllrM1rxqnSyEu2JthiWGMSAplaNdQAsyGFn1u4ZmkKHWaJIkT7U1jYyMHDhygS5cueHt7qx2OEMfkdDiorKygzGmirNaGac//cNSVg7UOxVqL1l7HwsBryHcFMbrsCwY2rMTosmB0WTBh5QvXWF60/Y2zNbv5yuvpZtvOU8K4OWQ2qdH+XKRdQ0R8EgkpgzCZ21YTWCGORYpSQkhOI9oReyMoLvesiVU5cGCFu5hlq3MXtLyDYMT97sfOnuAucNka3OvZ62HaUgjrBvNugy2fNd/2qIdg1Az36LWcNRDVF4K7QAv2nqq12Pn9QAWr0ktZlVHGgdJ6tBroHRvIiKRQhncLo29cIAZdBytEilYhRanTJEmcaG+k/4LwJC6XgsVmpbG6DGtjPY015VQX7qeqqoKfdaPYnV/JFxWT8NVYcChacvTxlPn3JP+se+mWmEhyhB96SbBEGyRFKSEkpxEeyFbvLmbZG6CuBCozISzZ3bR9x//gm6nux3kFQHQfSBoPQ+9o8TDyqxpJSy/l1/QyVmeUUdVgx2zU0Sc2kP4JQfRPCOKs+EACzdKTShyfFKVOkyRxor1xuVzY7XYMBgPajjasWohTYLU0kLN7AxUZ69AUbCa0egeXWx6j2uXNG8Y3SPSqoiqoJ/rYfgR16kNMUh9M3tLbSqhLilJCSE4jxBHqy6BwCxRscTdq94uECS+7e2L9d6i7aXxMP4js7W72Hhh/2iOqnC6FHfnV/La/nE05lWzKrqS83gZAYrgvvWMCSIn2d9+i/KVQJY4gRanTdGgHrly5El/fY1/2ER8fT2hoKGVlZeTk5NCvXz8A9u7dS319/V8+R8+ePTEajRw4cACn00lSUhJOp5OtW7f+5Xomk4mUlBQAtmzZQlRUFBEREVRWVpKZmfmX64aHhxMbG0tdXR379u2jR48eeHt7k52dTXl5+V+um5iYiL+/P4WFhZSVldGrVy8Atm/fjt1u/8t1D98vJpOJhIQEGhsb2b1791+u5+fn12y/dO7cmaCgIIqLi8nPz//LdWNiYprtlz59+qDT6UhPT6e2tvYv1z18v1gsFpKTkwHYtGnTX65nMBia7ZfQ0FCioqKoqakhIyPjL9cNCQlptl+6deuGr68veXl5lJSU/OW6h++XwsJC+vbtC8CuXbuwWCx/ue7h+0Wn09GlSxdsNhs7duz4y/V8fHya7Zc/fxb+SlRUVLP9cvhnoaqq6i/XPXy/1NTUNPssuFyuY66n1Wqb7Rd/f/9mn4W/EhgY2Gy/HP5ZKCws/Mt15RjRto4RFruTA6V1WHb8QLxlNymaA/g0FJJZ5WJ28B1sDx7P0IZfSbbvQhfSBb+oRMLiuh1RrJJjhBwjDteSx4jExMQzUpSSfOYP7eFYdTjJZ+RYdbi2cqySY8TRtfoxorGSmMJFRDTspXL/RjKLqugT44Pu0QLS9x+gdvlroDNCUGcISnDPfHhYofdkjhGKolBUbWF3YQ37yhoo0Ueyp6iGmoIDaL39SYiNITFIS6izks5hPnQN8yHcz4TmT8UxOUZ4zjHihE+MKeKoqqurFeC4t/fee09RFEV57733lMN35+DBg4+7bm5urqIoijJx4kRl/PjxJ/y8KSkpTc/j5+envPzyy4qiKMpXX3113HXvueceRVEU5bffflMAZceOHYqiKMq0adOOu+7PP/+sKIqizJw5U4mJiWmKISYm5rjrHr5fpk2bpiiKouzYseO46/15v3z11VeKoijKyy+/fNx1/7xfqqurFUVRlPHjxx933cP3y+DBg5viP956f94vM2fOVBRFUX7++efjrvvn/fLbb78piqIo99xzz3HX/eqrr5SKigrl+uuvV3x9fZtiSElJOe66h++XiRMnKoqiKLm5ucdd78/75c+fhb+6/Xm/HP5ZON66h++XP38W/mo9Pz+/Zvvlz5+Fv7r9eb8c/lk43rpyjGj7x4iPZn+gAMqni9KUp3/YqfRM7nLcdbdt3dq0X9rLMeLQfvnzZ+F468oxonWPEYd+lw/t99Ml+cyRt/Z6rPKUfEZRFOXpp59WvL29lYqKCkVR5Fh1+K2tHKsO/ywcb105RrTSMeLLL92fhe1Lmj4Lx1t3x+8rmvbLqRwjHE6XEhEVrUy6+R7luZ92KaPvevW4606dOrXZfpF8puMeI040p5GRUscgZxaP1K7OGuB5ZxZdLheff/45vXr1YtSoUYCcNThcWzprAHKM+LO2eIyor62mNHcv9UUZZNv8+M3SCXPhOh7WziEyNJCC4LMpDBxAVOpIBgw+B2jbxwg5s9g+jhEyUkqOVX/maflMUFAQu3fv5ptvvuG2224jJCREjlWHaSvHKjlGHF2bPEYoirtPVVUWVGRBt/PBOwAWP0qP2jS8Y1LJ9huAJXooyaP+Bjr9aR0j0tPTKa+zcaCsjqyyBg6U1nGgrJ78qkYAIsJCGTMwlYGxPoS7yhnUt6fkM0fREY4RcvneaZIeDEIIIf7MZrWQvvEXancuIrRoFYnO/axzdeel6FcYmxzK+ZE1JCT3QyM9UMQpkp5SQgghWkVdKWSuhP2/QPoSqC+BS96AflPcM/7pTWAObrmnszrYlF1JWkYZaell7CqsQaOB3jEBjEwOZ3RyGL1jA9FpW252QaGudlWUSktLY8+ePUyYMOGkZtjIzs5myZIl9OzZk8GDBze7z263s2LFCoqLi+nVqxd9+vQ5qZgkiRNCCHE8pfmZbNydwf8KgqhN/425usco0ISTGzIM79QJdBt8gTRPFydFilJCCCFancsFhZvdvafMwfDD3bBpDsQNgm7nuUdXhXU/7ebphyuttfLrvlKW7y3h132l1FgcBJkN9IoNJCXKny6hPoT5eRHsY8Sg06LVglajwelS/rgpCq5m34PD5cKlKBh0WsxGPT5eOswG91d/bwOGk5h92epwUl5nc9/qrZTX2aiot1Feb6PWYseluGeE1uk0BHgbCPA2EGw2EhlgIirARESACT8v/RF9tTxFuyhK/fTTTzz44IPo9Xq2bt3K8uXLmy47Oh6bzcbQoUPZuXMnN998M6+++mrTfeXl5YwdO5a6ujp69erFL7/8wpQpU3jjjTdOODZJ4kR7U1hYyAcffMC0adNk+mQhVGBprGfv7z9j2fET8eW/EqWUskvpxCtdP2BM93DOjYOwqHi1wxRtnBSlhJCcRgjV1RRC+mLYtwgOLAd7A5z/Agy+FRqr3KOoDKYWezqH08WW3CpWpZexs6CGXQXVFFT/9eV4p8ps1BHgbcDf5C4i+XsbMBt12BwubE4XdVYHZXVWymqt1FgcR6zv66Un2MeIn0mPTqtBq9Fgd7qosdipbrAfsY6PUUfEoSKVv/trXJCZ+BAz8cFmogK8O+zosBPNQfStGNMRtFotc+fOJTAwkLi4uJNa98EHH6Rv3744HEf+ojz00EPY7Xa2bt2Kj48P69evZ9CgQUyYMIELLrigpcIXok3x9/dn/Pjx8k+HECoxefvQZ9SVMOpKFJeLrL2byNiTTnWxnbe/W8pkr3vI0HWlNHo0wWddQlKfYWh1OrXDPi2Ky4XdbqOxoQ6L1ozFoeAoz8RZV4a9sR6HtR6nrYFScxJlXrGYKtOJKf4F7BZwWNA4GqnQhfJz0DW4FJhS+Lz7JKxGh6LVoWh0/Bp9I/iG0b1+HeH2QgyB0QREJxGRkIyvf5Dau0AIcQZITiOEyvyjoP/17pvdAllpENbNfd+aN2HNG9BltHsUVdJ49+NPg16nZUCnYAZ0+uNyQbvT1TRCyeFUcCkKLgV0Wg06jQat1v29/mBh6FCBSK9z329zumiwOam3Omi0Oam1OqhptFPdaKem0V08qj74c2mtFS8d+OgchPpq6BUTToSPli5KLsFGJ0FGB/56J346G8ael4NODzu+hfL94Gg8mNc0Qs8rscUOpXLPSvSbPqLBAfV2qLcr5Fgi+dR+GWv3l3N+/XdsUkzkK6EUEIE2MI7OEQH0jg2kV2wA/eKCCDAbTmuftieqFqUOFYjy8vJOar2ffvqJn376iU2bNjFs2LBm97lcLr788ksef/xxfHzcl0wMHDiQwYMH88UXX0hRSnRYPj4+nH322WqHIYQANFotnXoMoFOPAVwCVFUmsyHNDvsWkZL7BQG577P/+zjeTvmUsSkRDOvsh6/PsZtQnymKy0V9XTV1VWU01FRQrg2h2GFGyd9MaP5StA1lGC3leNsrSSeeFw03Y7DV8p3jVoyKHS/sGDUKRmCE5V2q8eVDw4uM0W1p9jxP2acw23UBF+s38KTuY2wYsWm8sGuMNBi6UKyzoNVo8LEUoFOcaBQXGlxoFSfb7MVk2u10bZxHf2U5es0fzT3f0V/Dts43MSTczoCAGrr0GY7Rq+XO3Aoh1CE5jRBtiMEESef+8XPvSWA0w77F8OPdoLhg3NNwzp3gsILWAC3QW9Og0xIZYCIy4AT/rjsdYKkGSxVYayG6r3v5pk+gbC/Ul0F9qfs25nH3a1r/Pix9EhwWcNrcj+92AVw01/34lwYd+TzdxoF3IOz8DnLW/jFqTG+CziMw6rVEeDnBUUKI4gStEwwO+kf4cvllQ8FpR5l1HRpb3R+hN+p5wPIBH6RV0smym2r8CIzpxohuYQzvFkbfuMCTuuywvVG1KHUqCgoKuPHGG5k/f/5RZ5HJzc1t1p3+kNTUVDZu3HjM7VqtVqxWa9PPNTU1LRe0EK3AYrGQk5NDfHw8JpP8UyZEWxIYFMyAi28GbsZht7Fr4y/sy9jHlrxqFm3ay1qvO9htTKQ6uBf6mL6Ywzvjk3gO/t5e6Jz16LVaXC4XDpsVh82CVe+LVWPCVVcG1bk4HVacNhsuh41GvR+FPj1orK0kfv9nYKlGZ61Gb6vBYK/lMd8nqLS4eLb+SQYrW/HVuDj01/Rt+0185RzN3/Rp3Kf/nlpdIA2GIGrM8ej8e3JxTDTeWhe7i6aBwYRGb0JrMKHzMvNa/FAMJm8CG14hU2vH4OWDl9kXo8mHB338eMzohUYzAZjZbN90AUY3/ZR2xL77pOm7MSguF+WlBZTm7KGuMB2tNYbScisZe7/h79r3sfxkYKdXd2rCz8bcYzyJA87Fx6vdpTqnRfIZ0RFITiNEGxaaCMPucd8aKiBjGYT3cN+3cQ78+qK7F1V0XwhPhbBkCOkKLifY6kGrA5cDHDb310OjrEr3ga0WnHZ3gchhg6je4BsOOb+7LyNsrDpYeKqGmH4w4n6ozIb/DoXDijwAPFYGOgPs/t49osknDHxCIfos8AlxPya6H4z8l7ugpDOCwQwBse77TIEwfQXovcFw2M14MGua9AnHlHRu80Le4XQGNA/nu19ndS5UZKKrOMD/DbgERaPB9vbzeBVvoqoyhN9/68YPK7txv24wnTsnMqRLCEO7hpIS7d+hLvlrV5may+Xi2muv5fbbbz/m2ZNDyVdQUPMh/cHBwX+ZmD3//PM8+eSTLResEK2ssrKSL774gunTp0v/BSHaML3BSMrg80kZfD6XAXmFRWxbcTeG/N+JK1lOTPFcbIqOZOscFLT8aHyYntqsZtu4zXYnC1yDuVH3E48aPmt23xJnP+6030+Ito6lxo+p1/jSqPPFovPDZvCnd5QJbx9/6monsZEJ6HwCMfoE4+UbxO0RSTwaFomf14VoNM8T+afYL2z67um/eIWhp7N7/pJGqyUkIpaQiFjgXAYANwEOe3/Sd1xK+a7leOX/Tve8r/gley9X/ORiaKSL2w0/YOwyjE5njSE4POaMxdcWSD4jOgLJaYRoJ8zB0Ptvf/ycMBTOmgL5G2H162Cthn7XwSWvQ8kueLv5VU4YfOCRAvf3X1/vfszhJn0KPS6Ggs2wYbZ7hJIpEEwB7kISgDkERj3kXuZ98D5TAGgOjiy69utjxx/Tz307Gp3eXcA6U3QGCO7ivjEWAA3g9Y9vIXcdgdmrGZ+9hnEFn/NjryF8XaGwc+mnVC4uYJY+FaLPIjUulJ4xAfSODSA+2NxuG6q3idn38vLyiIuLO26j808//ZR//vOfzJo1C93BPhxPPfUUycnJTJo0iWnTprF//36SkpJYvHgx48aNa1r3tttuY9WqVWzfvv2o2z7amcW4uDhpDCraDafTSUNDA2azuenzIYRof+pqKikvyiFXE0Od1UFwURpaSwUarQ6t3gut3ogltCf4RuBtK8NsLUVv8EJnNKE3GNGZ/DAHhuNj1LXb5OR0KS4XBwqK+T3fTtHu1VyT9RiRlAKQrY0lM2Qk2Wf9i06hPiQaK4mM7YJO3zbO051uY3LJZ0RHIDmNEB2AywX1Je7v/SLdo5z2/+K+3E+rd49M0ntBorsgQ8lu98gpndFdsNEZ3QUng7dqL6FNsDUc3B8GnEufgbVvonM0YNMY2UESr1ov4ldXHyJNdlIjTERHxtAt0o9uEe5bkI9RtdDbRaPzkxUTE8PEiRNZv35907L6+noKCwtZu3YtU6dOJT4+HoPBQFZWVrN1MzMzSUxMPOa2vby88PLyOlOhC3HG6XQ6/Pz81A5DCHGafP2D8PUPIuHQgp4T/+LRIUDymQ+qndFotXSNjaJrLDAoHphMUU46eVuW4cz+DUtVCc/8tAvFaWeP1z9woqFUE0StPoh6Qwg/xM/AFBxFb9tWwo0WvENiCYxIICQiDoOxbecKks+IjkByGiE6AK3WXYw6xDsQel5x7McfugRQNGc0N32rO/dRGP0gFG3DmL2GfjlreDOpGxt9B+Lc+Alj9z1FfbGZ4i0BlCoBfOZK5iPTdSQEeXGpZiVavyhcfpE4fSPRmYPx8zZw+VmxKr44tzZflEpLS6OkpIQrrriC0aNHM3r06Gb3b9iwgVGjRvHqq68CYDQaOe+885g7dy433ngjGo2GwsJCli9fzltvvaXCKxCidVRVVfHrr78yYsQIAgMD1Q5HCCHalMj4JCLjk4BbANjtdFFYUcvuXR/QUJSOq6YQXUMpRks5u0pt5GQX0K/hHc7S/tGP0qVoeEk3lYGTZjAqOVylVyJExyc5jRBCHIPOADH93beh/8QPGAUQNRlyu+JTmUVCXQmh5QUE6aKwhcRTVVrIdftegpI/NmNVDIzXviNFqfT0dFauXEllZSXgnlUvIyODfv360a+f+9rOjz76iLVr13LFFX9RVf2TWbNmMXToUK688koGDx7MnDlz6N+/P1OmTDkjr0OItsDhcFBaWorD4VA7FCGEaPP0Oi1xYQHEjTwyv/ji4FfFNYrK8mIqirKpK8vFWpFHtD6Z+GDzEesIIVqO5DRCCHGS/KMh9TIAdID/wdu9AHQDRynUFUNtIdQW4lVTyLIBl6oVbTOqFqVKS0tZu3YtANOmTaOyspK1a9cSHh7eVJQaPnw4MTHHbkp6xRVXkJzc/NKFlJQUtm3bxkcffUR2djZ33HEHN9xwAwaD4cy9GCFUFhoayrRp09QOQwghOgyNVktQWBRBYVHAYABkknohzjzJaYQQooXpjRAY574dWqRiOIdrE43O26LTbTQqhBBCCHGyWjr/kHxGCCGEEGo40RxE24oxCSHOoKKiImbNmkVRUZHaoQghhBBCnDLJaYQQwnNIUUqIDsLX15dhw4bh6+urdihCCCGEEKdMchohhPAcbeUyQiHEafL19eWcc85ROwwhhBBCiNMiOY0QQngOGSklRAdhtVrJysrCarWqHYoQQgghxCmTnEYIITyHFKWE6CAqKiqYM2cOFRUVaocihBBCCHHKJKcRQgjPIZfvCdFBhIWFcccdd8jsSkIIIYRo1ySnEUIIzyFFKSE6CL1eT3BwsNphCCGEEEKcFslphBDCc8jle0J0ENXV1SxcuJDq6mq1QxFCCCGEOGWS0wghhOeQopQQHYTNZiMrKwubzaZ2KEIIIYQQp0xyGiGE8BwaRVEUtYNoi2pqaggICKC6ulquZxdCCCFEq2jp/EPyGSGEEEKo4URzEBkpJYQQQgghhBBCCCFanTQ6P4ZDA8hqampUjkSIE1NSUsJXX33FVVddRXh4uNrhCCGEOAWH8o6WGsgu+YxojySnEUKI9u9Ecxq5fO8Y8vLyiIuLUzsMIYQQQnig3NxcYmNjT3s7ks8IIYQQQk3Hy2mkKHUMLpeLgoIC/Pz80Gg0Lb79mpoa4uLiyM3NlR4PbYC8H22HvBdth7wXbYe8F23HmX4vFEWhtraW6OhotNrT77JwpvMZkN/PtkTei7ZD3ou2Q96LtkXej7ajreQ0cvneMWi12hY5Q3k8/v7+8mFsQ+T9aDvkvWg75L1oO+S9aDvO5HsREBDQYttqrXwG5PezLZH3ou2Q96LtkPeibZH3o+1QO6eRRudCCCGEEEIIIYQQotVJUUoIIYQQQgghhBBCtDopSqnEy8uLmTNn4uXlpXYoAnk/2hJ5L9oOeS/aDnkv2g55L44k+6TtkPei7ZD3ou2Q96Jtkfej7Wgr74U0OhdCCCGEEEIIIYQQrU5GSgkhhBBCCCGEEEKIVidFKSGEEEIIIYQQQgjR6qQoJYQQQgghhBBCCCFanV7tADxVTk4OJSUldOvWDX9/f7XD8WgVFRXs2rWLbt26ER4ernY4Hi0vL4+Kigq6du2Kj4+P2uF4tJqaGjIyMoiIiCAmJkbtcASwZ88eysrKGDBgACaTSe1wPM6GDRuwWCzNlsXGxtKpUyd1AmojHA4HO3fuRK/Xk5KSgkajUTskj3boODFs2DC1Q/FodrudvXv3YjabSUhIQKfTqR2SR8vOzqa6uprOnTvj5+endjgez+l0snbtWvz9/enVq5fa4Xic6upqtm/ffsTyfv36YTabVYhIGp23usbGRiZPnsySJUuIj48nOzubf//739x2221qh+Zx0tPTee6551i0aBGFhYXMnj2bf/zjH2qH5ZF++OEHHn74YSorKwkODubAgQPcd999PPnkk2qH5nEKCwu5//77WbRoEQkJCWRkZJCamsrcuXOJj49XOzyPtXPnTgYNGkR9fT3p6ekkJiaqHZLH6dSpEwaDgYiIiKZlkydP5vbbb1cxKnWtW7eOK6+8Eo1Gg81mIyAggPnz59O9e3e1Q/M4X3/9Na+88gp79uyhsrISSe/VYbVaeeKJJ3jvvfeIjIyksrISs9nMhx9+yPDhw9UOz+MsWrSI+++/n8bGRry9vdm/fz+33347L774ohTQVfT444/z7LPPMmTIENLS0tQOx+OsWLGC0aNHc8455zRb/sknn9C5c2dVYpLL91rZ448/zubNmzlw4AC7d+/m448/5p///CcbN25UOzSPs3v3boYPH87+/fvlDJbKMjMzmTt3Lnl5eWzbto0FCxbw/PPP89VXX6kdmsfJy8tj0qRJlJaWsnHjRgoKCrDb7dx5551qh+axGhsbufrqqz26+NFWPPjgg6SlpTXdPPk9sVqtXHnllVx44YXk5ORQUFBA9+7dmTRpktqheaRdu3bx0ksv8dprr6kdikerra0lICCAzMxMduzYQW5uLuPGjePyyy+nsbFR7fA8Tn5+PvPnzycjI4Pt27ezfPlyXn75ZebPn692aB5rxYoVfP7551x55ZVqh+LxVqxY0SynUasgBVKUalWKojB79mymT5/edKZ14sSJdO/endmzZ6scnee55JJLmDp1Kt7e3mqH4vHuvPNOUlNTm34eMWIEqampcvZEBQMHDuSSSy5pOoPo4+PD2WefTX5+vsqRea677rqLYcOGcfHFF6sdiscrLy9nw4YNFBcXqx2K6hYvXkxeXh6PPfYYAFqtlocffpht27axYcMGlaPzPDNnzjzirLdofaGhocyYMaPpEjGtVsvNN99MeXk5u3fvVjk6zzN16lS6dOnS9PPZZ5+Nj4+P5DQqKSsr4/rrr2fOnDnSvqYN2Lt3L9u2baOhoUHtUKQo1Zpyc3MpLy+nf//+zZYPHDiQzZs3qxSVEG1PZWUl+/fvl0uUVLRx40ZWrFjBf/7zH7766qumfzxF6/rmm29YtWoVL7/8stqhCODZZ5/lxhtvpGvXrowYMYIDBw6oHZJqNm/eTEREBLGxsU3LBgwYgEajkZxGiMOsX78enU7n8f3n1FJTU0NaWhoLFy7k73//O506dWLy5Mlqh+WR/vGPf3D99ddLAb2NuOiii5g4cSJBQUHMmDEDl8ulWizS6LwVVVRUABASEtJseUhICOvWrVMjJCHaHEVRmD59OkFBQVx//fVqh+OxXnrpJfbv38/evXu54IILJIFQQVZWFrfddhs///yzao0nxR9mzpzJ3//+dwwGA+Xl5Vx++eX87W9/Y926dR55CXhFRcUR+YxOpyMwMLAp3xHC02VlZfHQQw9x++23ExwcrHY4Hik7O5sZM2ZQUVFBfn4+zz//vLwXKnjllVcoKyvj8ccfVzsUjxceHs6qVauaJsRYtWoV48ePJyIignvuuUeVmGSkVCsyGAwAR8ze09jYiNFoVCMkIdqcO++8k19++YXvv/+egIAAtcPxWHPnzmX9+vXk5eVRWlrKZZddpnZIHmf69OmMHTuWhoYG0tLSmmZK2bhxI/v371c5Os9zww03NP0dDwkJ4bnnnmPTpk3s27dP5cjUYTAYjshnwJ3jSE4jhHvikPHjxzNw4EBeeukltcPxWL169SItLY1du3axePFiHnjgAT744AO1w/IoWVlZPPzww9xyyy2sXbuWtLQ0iouLm0ax1dbWqh2iR0lJSWk2Q+vw4cO59tprmTt3rmoxyUipVhQfH49GozniOub8/HyZ1UoI4J577uGzzz5j6dKl9OnTR+1wBODv78/NN9/M1VdfTW1trUyl3IrCwsKazvCC+xIEcI9iu/rqq7n//vvVDM/jHeoNmZ+fT48ePVSOpvUlJCRQXFyM0+lsGilWUVFBY2Oj5DTC4xUVFTFmzBi6dOnCd999J4XaNmLQoEGMGDGChQsXMm3aNLXD8RgNDQ3079+f999/v2lZRkYGjY2NzJgxg3fffZeUlBQVIxQRERH8/PPPqj2/FKVakZ+fH4MGDeL777/n6quvBtyzdPzyyy8899xzKkcnhLruvfde5syZw5IlS+jXr5/a4Xis+vp6fHx8mi3LyMjAx8dHJgVoZZ999lmzn9PS0hg+fDhz586Vfmut7Gifi8WLF6PVaj2yIAVw7rnnUl9fz7Jlyxg/fjwA8+fPx2AwMHLkSJWjE0I9xcXFjBkzhvj4eObNm4eXl5faIXmsPx+7nU4nWVlZjBgxQsWoPE9KSsoRkxfdeOON7NmzRyY1UsGfPxeKorB06VJ69uypWkxSlGplzz77LOeddx6dO3fm7LPP5rXXXiM6Olqq9Sqorq5uuhwGID09nbS0NCIiIkhKSlIxMs/z+OOP85///IdXXnmFxsbGpj9QoaGhdO/eXeXoPMtjjz2GxWJhzJgx+Pr68ttvv/HSSy8xc+ZM9Hr5kyE805o1a3j22WeZMmUKMTExrF27llmzZnHfffcRExOjdniq6N69OzfccAPTpk3jhRdewGKxcP/99/PAAw8QGhqqdngeJz09neLi4qbLSQ/9He3Vq5dcCt+KampqGDt2LBaLhQceeKDZTJSpqakEBQWpGJ3nGThwIFOnTqVXr17U1tYye/ZsioqKVOubI0RbcNddd+Hr69t0Amn27Nns3LmTX375RbWYNIqiKKo9u4datWoVb731FiUlJfTp04cZM2YQHh6udlgeZ/Pmzdxxxx1HLL/wwgt5+OGHVYjIcx06W/Jno0eP5umnn1YhIs/lcrn47LPPWLBgAZWVlXTq1IkpU6ZIo/M2YPv27dx66618+eWXHlsIUdO6dev44IMPyMrKIi4ujkmTJjFu3Di1w1KVw+HgjTfe4Oeff0av13PZZZcxbdo0NBqN2qF5nOeee44FCxYcsfz111/nrLPOUiEiz5SZmcmUKVOOet+LL77I0KFDWzkiz1ZSUsIbb7zBhg0b8Pb2pnfv3tx6663yf1cbMGvWLLKzs3nrrbfUDsXjOBwOZs+ezaJFi7DZbKSkpHDHHXeomltKUUoIIYQQQgghhBBCtDqZfU8IIYQQQgghhBBCtDopSgkhhBBCCCGEEEKIVidFKSGEEEIIIYQQQgjR6qQoJYQQQgghhBBCCCFanRSlhBBCCCGEEEIIIUSrk6KUEEIIIYQQQgghhGh1UpQSQgghhBBCCCGEEK1Or3YAQgjR2tLS0jCbzfTr16/Vn3vx4sVUVFQAcOmll+Lt7X3a21y7di1ZWVkAjB49moiIiNPephBCCCHaNrvdzv/+9z/OO+88goKCWvW5q6urWbhwIQCRkZGMGjXqtLepKApffvklAGazmUsuueS0tymEaPtkpJQQokNbtWoVmzdvbrbs3//+Nx9++KEq8Tz88MM8//zzzJs3j8bGxhbZ5saNG5k3bx6TJ09m+/btLbJNIYQQQrQdNpuNuXPnUlVV1bSsvr6eyZMns3///laPJzc3l8mTJzN37lxWr17dIttUFIV58+bxyiuvcNttt7XINoUQbZ8UpYQQHdqsWbOYM2dOs2XDhw+nf//+KkVEUxIXHBzcItu7/fbbmTt3botsSwghhBBtT01NDZMnT24aGQ1gNBqZNGlSi+UTp+Ltt9/mkUceaZFtabVa5s6dy6233toi2xNCtA9y+Z4QosP6/fffKSgowOVyNRVtJkyYwKBBgzCbzU2PW7FiBcHBwcTHx7N582ZsNhsjR47EZDJRXl7OmjVrCAgIYMiQIej1zQ+biqKwceNG8vLy6NKlC7179z7pOA89f1xcHJs3b8bpdDJixAi8vLyaPW7fvn3s3buX6Oho+vbti06nO4W9IoQQQoj25rvvvgNg0aJF7Nmzh9DQUEaOHMlll13WdOleY2Mj8+fPZ8KECRQXF7N7927i4uLo27cvANu3b+fAgQOkpKSQlJR0xHPU1tayZs0aXC4Xffv2JTIy8qRiPPz5i4qK2LNnDwkJCUfkRg6Hg7Vr11JVVUWfPn2Ii4s7hT0ihOgopCglhOiwNm3aRHFxMfX19cybNw+AESNG8O9//5vY2NimnlLPPPMM1dXVFBcX07t3b7Zv347RaGTGjBk8/fTT9OzZky1bttCtWzeWLVuGRqMBoLi4mEsvvZSysjJSUlLYtm0biYmJzJs3D19f3xOO85lnnqGhoYHc3FxSU1PZu3cvRqOR5cuXEx0dDcBtt93G3LlzGTZsGCUlJWi1WubPn09YWFjL7jQhhBBCtDmH+jctX76cwMBAkpKSGDBgAJMnT2b9+vUMGDCA8vJyJk+ezMiRIykrKyMhIYGlS5dyyy23UFFRwbZt24iOjmb58uW89dZbTJ06tWn78+bNY9q0aaSmpuLj48OaNWt46qmnuPPOO084xkPPf8EFF7Bv3z4SExNZtWoVN9xwA2+88QYABQUFjBw5Ei8vL7p27crOnTu55ppreOqpp1p2hwkh2g0pSgkhOqxbb72Vn376icTERF599dW/fGxOTg7btm0jIiKCyspK4uPjmTlzJlu3biUkJITi4mISEhJYsmQJ48ePB2Dq1Kmkpqby3nvvodVqsVqtjB07lmeeeYYXXnjhpGLduHEjmzZtIjU1FYvFwujRo3nooYeYM2cO+fn5/Pe//2XXrl306NGj6fEt1ZNKCCGEEG3bu+++y3fffccLL7zQNPLp8P5Sh+vcuTPLly9Ho9Hw/vvvc9NNN3HLLbewdetWAF599VUeffTRpqJUTk4Of//73/n+++8ZM2YMAJs3b2bo0KGMHTuW1NTUk4rVYrGwa9cujEYjGzduZNCgQUycOJFRo0Yxe/ZsQkJCWLNmDRqNBkVR+P77709tpwghOgTpKSWEEMBll13WNGtdUFAQ3bt358orryQkJASAiIgIOnfuzL59+wAoKSlhwYIFJCUl8e233/L1118zf/78pkTwZF144YVNSZ/JZOLOO+/k66+/RlEUjEYjOp2Obdu2NT2+f//+xMfHn+7LFkIIIUQHM3369KZR3UOGDGladsiQIUMoLCykrq4OgLlz5xIYGEhFRQVff/01X331Fenp6YSGhvLrr7+e9PPfddddGI1GwJ2vjB07tmlWPW9vb8rLy8nLywNAo9Fw6aWXnvqLFUK0ezJSSggh4IiplL28vI66zGKxADQ1Gl2zZg1btmxp9rhBgwad9PN36tSp2c+dO3emsbGR0tJSwsPDeeedd7j33nu59957GT16NNddd13TiC0hhBBCiEMOz18O9ac82jKLxYKvry9ZWVk4HA6++eabZts555xzCA8PP+nnP1pOk52dDcDNN9/Mpk2bSE5OpkePHowbN45//vOfxMbGnvTzCCE6BilKCSHEKfD39wfgwQcfZOjQoae9vcrKyiN+1ul0TUnktGnTmDp1Kjt37uSHH37gkksu4eOPP+aqq6467ecWQgghhOfy9/fH39+/xWbyPVpOExoaCoCPjw+ffvopDQ0NrF69mjfffJP+/fuTkZGBn59fizy/EKJ9kcv3hBAdmq+vb9PoppaUnJxMp06dePvtt4+4Lz8//6S3t2jRomZxfvvttwwcOBCDwUBVVRUNDQ1oNBp69uzJQw89xDnnnMPatWtP6zUIIYQQon04NIHKmchpzj//fNLT01m2bFmz5XV1ddTU1Jz09g5NLgPuGf2WLFnCOeecA/yRI5nNZsaNG8frr79OSUkJmZmZp/4ChBDtmoyUEkJ0aAMGDODVV1/l/fffx9fXlwkTJrTIdjUaDR9++CEXX3wx1dXVTJgwgcrKShYsWMAFF1zAjBkzTmp7DoeDsWPHct1117FlyxY++ugjlixZArgTuMsuu4yJEyeSnJzMnj17+O2335g5c2aLvBYhhBBCtG0mk4nU1FRefPFFrrzySiIiIhgwYECLbHvUqFHcdtttXHrppdxxxx0kJiayb98+vv32WxYsWNA0OvxEff7557hcLlJSUvjggw+IiorihhtuAOC9995j5cqVTJgwgeDgYD7//HN69uzZNJGLEMLzyEgpIUSHdueddzJjxgzWrFnDvHnzqK2tZfjw4fTv37/pMaNHj6ZPnz7N1jv33HPp2bNns2Xnn38+3bt3b7berl27GDBgAKtXr6aqqornnnvuuAWpbdu2MXfu3Gaz502bNo377ruPnTt3otFoSEtLY9SoUQCkpqayatUqAgIC+PXXX9FoNPz++++MGDECgLVr17bYkHshhBBCtE3ff/89SUlJLFy4kJUrV2I0Gpk0aRLBwcGAe/TRpEmTmhWR/Pz8mDRpEj4+Pk3LgoKCmDRpUlNvKYA333yTb7/9tumyurCwMFavXk1SUtJfxjR//nxWrFjRbNmPP/5IXFwc69at46KLLiItLa2p8fkTTzzBE088QVFREWvWrOHiiy8mLS0Ng8GAoijMnTuX33///XR3lRCiHdEoiqKoHYQQQniKRx55hP379wPw1ltvERwczLnnnsuAAQN44YUXTmmbb775JqtWrQLg0UcfPaKYJoQQQgjRkvLy8rj//vsB6NWrF4888gh5eXnExcWxe/fuZifxTpTL5eKaa64BICQkhDfffLNFYxZCtE1SlBJCCJWdblFKCCGEEEJtp1uUEkJ4JukpJYQQKhs9ejRdunRROwwhhBBCiFN2tMsHhRDieGSklBBCCCGEEEIIIYRoddLoXAghhBBCCCGEEEK0OilKCSGEEEIIIYQQQohWJ0UpIYQQQgghhBBCCNHqpCglhBBCCCGEEEIIIVqdFKWEEEIIIYQQQgghRKuTopQQQgghhBBCCCGEaHVSlBJCCCGEEEIIIYQQrU6KUkIIIYQQQgghhBCi1UlRSgghhBBCCCGEEEK0uv8H4cYX8vHmlL8AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x440 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            xnn  original Allegro      |diff|\n",
      "--------------------------------------------------------------\n",
      "(a) same PES              1.4133            1.4133     4.8e-08\n",
      "(b) independent           1.4180            1.4133     4.8e-03\n",
      "experiment                  1.41\n"
     ]
    }
   ],
   "source": [
    "t_ps = np.arange(N_EQUIL + N_PROD) * (DT / u.fs) / 1000.0\n",
    "xc = N_EQUIL * (DT / u.fs) / 1000.0\n",
    "fig, ax = plt.subplots(1, 2, figsize=(12, 4.4), sharey=True)\n",
    "ax[0].plot(t_ps, rho_xa, label=\"xnn\", lw=1)\n",
    "ax[0].plot(t_ps, rho_aa, label=\"original Allegro\", lw=1, ls=\"--\")\n",
    "ax[0].set_title(f\"(a) same potential  |Δρ|={abs(da_x-da_a):.1e} g/cm³\")\n",
    "ax[1].plot(t_ps, rho_xb, label=\"xnn (independent)\", lw=1)\n",
    "ax[1].plot(t_ps, rho_ab, label=\"original Allegro (independent)\", lw=1, ls=\"--\")\n",
    "ax[1].set_title(f\"(b) independently trained  |Δρ|={abs(db_x-db_a):.1e} g/cm³\")\n",
    "for a in ax:\n",
    "    a.axvline(xc, color=\"gray\", ls=\":\", lw=1)\n",
    "    a.axhline(RHO_EXP, color=\"k\", ls=\"-.\", lw=1, label=f\"exp ≈ {RHO_EXP}\")\n",
    "    a.set_xlabel(\"time [ps]\"); a.legend(fontsize=8)\n",
    "ax[0].set_ylabel(\"density [g/cm³]\")\n",
    "plt.tight_layout(); plt.savefig(\"argon_density_md.png\", dpi=120); plt.show()\n",
    "\n",
    "print(f\"{'':<20}{'xnn':>12}{'original Allegro':>18}{'|diff|':>12}\")\n",
    "print(\"-\" * 62)\n",
    "print(f\"{'(a) same PES':<20}{da_x:>12.4f}{da_a:>18.4f}{abs(da_x-da_a):>12.1e}\")\n",
    "print(f\"{'(b) independent':<20}{db_x:>12.4f}{db_a:>18.4f}{abs(db_x-db_a):>12.1e}\")\n",
    "print(f\"{'experiment':<20}{RHO_EXP:>12.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c64d1a1b",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "* **Track (a)**: copying the trained original-Allegro weights into `xnn` gives\n",
    "  identical energy/forces/stress and **identical NPT densities**; the `xnn`\n",
    "  inference/MD path reproduces the original Allegro exactly.\n",
    "* **Track (b)**: an independently trained `xnn` Allegro lands within the\n",
    "  thermal fluctuations of the original, both near the experimental liquid-Ar\n",
    "  density (~1.41 g/cm³).\n",
    "\n",
    "Same conclusions, same pipeline, third model family: Allegro joins MACE and\n",
    "NequIP as a faithful, dependency-light member of the xnn equivariant-GNN\n",
    "family (shared `EquivariantGNN` base, featurizers, `ForceStressOutput`,\n",
    "ASE/LAMMPS deploy).\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
}