From c978327059a8820800935d654b8e4472f2614b39 Mon Sep 17 00:00:00 2001
From: unknown <kadri.muuga@gmail.com>
Date: Tue, 15 Sep 2026 11:26:13 +0200
Subject: [PATCH 1/2] [doc] fix tf version conflict with konda

---
 docs/notebooks/Build_MLP_Water.ipynb     | 1803 +++++++++++-----------
 docs/notebooks/Customizing_dataset.ipynb |  700 +++++----
 docs/notebooks/Layer_debug.ipynb         |  698 ++++++---
 docs/notebooks/Learn_LJ_potential.ipynb  | 1127 ++++++++++----
 docs/notebooks/MLP_water/water.xyz       |  194 +++
 docs/notebooks/More_on_training.ipynb    | 1442 +++++++++++------
 docs/notebooks/Quick_tour.ipynb          |  533 ++++---
 7 files changed, 4045 insertions(+), 2452 deletions(-)
 create mode 100644 docs/notebooks/MLP_water/water.xyz

diff --git a/docs/notebooks/Build_MLP_Water.ipynb b/docs/notebooks/Build_MLP_Water.ipynb
index ef88fe3c..788e6580 100644
--- a/docs/notebooks/Build_MLP_Water.ipynb
+++ b/docs/notebooks/Build_MLP_Water.ipynb
@@ -1,883 +1,962 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "mlFaUm2f_Uc9"
-   },
-   "source": [
-    "# Building machine learning potentials (MLPs) for liquid water [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Build_MLP_Water.ipynb)\n",
-    "\n",
-    "\n",
-    "This notebook showcases the usage of PiNN with a practical problem of building machine learning potentials for liquid water on the H2O(l)-revPBE0-D3 dataset.\n",
-    "It serves as a basic test and demonstration of the workflow with PiNN."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "ZTdzb9ym_Uc_"
-   },
-   "outputs": [],
-   "source": [
-    "# Install PiNN\n",
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "i7k54_m3_UdA"
-   },
-   "source": [
-    "## Download the H2O(l)-revPBE0-D3 dataset\n",
-    "\n",
-    "The H2O(l)-revPBE0-D3 dataset was published by Cheng et al ([Proc. Nat. Acad. Sci. 2019, 116, 1110-1115](https://doi.org/10.1073/pnas.1815117116)). It comprises 1593 liquid water configurations involving 64 molecules with the energies and forces computed by DFT at the revPBE0-D3 level and presents an excellent example to test MLPs in the interpolation regime."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "id": "7HTszdEb_UdA"
-   },
-   "outputs": [],
-   "source": [
-    "# step 1: download the dataset\n",
-    "import requests\n",
-    "with requests.get(\"https://raw.githubusercontent.com/BingqingCheng/ab-initio-thermodynamics-of-water/master/training-set/input.data\", stream=True) as r:\n",
-    "    r.raise_for_status()\n",
-    "    with open(\"input.data\", 'wb') as f:\n",
-    "        for chunk in r.iter_content(chunk_size=8192):\n",
-    "            f.write(chunk)\n",
-    "\n",
-    "# step 2: create project directory\n",
-    "!mkdir MLP_Water\n",
-    "\n",
-    "# step 3: move the dataset file to project directory\n",
-    "!mv input.data MLP_Water"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "Zbm9Qcws_UdB"
-   },
-   "source": [
-    "## Configure the model architecture and parameters\n",
-    "\n",
-    "Three different model architectures are supplied in the PiNN package, i.e., Behler−Parrinello neural network (BPNN, [Phys. Rev. Lett. 2007, 98, 146401](https://doi.org/10.1103/PhysRevLett.98.146401)), PiNet ([J. Chem. Inf. Model. 2020, 60, 1184−1193](https://doi.org/10.1021/acs.jcim.9b00994)), and PiNet2-P3. The BPNN and PiNet only involve invariant features, whereas PiNet2-P3 incorporates equivariant information as well. Generally speaking, the training loss of PiNet2-P3 is lower than that of BPNN/PiNet. Before training the MLPs, it is essential to define the model architecture and set corresponding parameters. In this case, we will use PiNet2-P3 as an example. You can also use following functions to know which networks and models are available."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Available networks:\n",
-      "  - PiNet\n",
-      "  - PiNet2\n",
-      "  - BPNN\n",
-      "  - LJ\n"
-     ]
-    }
-   ],
-   "source": [
-    "import pinn\n",
-    "pinn.get_available_networks()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "ps8JXQ4U_UdB"
-   },
-   "source": [
-    "You can find detailed information about the parameters of both the `model` and the `network` on their respective pages under the `Usage` tab. These sections provide comprehensive guidance on how to configure and implement them effectively for your specific applications. Here is the configuration file for training water model:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "id": "Ow1LX1vz_UdB"
-   },
-   "outputs": [],
-   "source": [
-    "import yaml\n",
-    "\n",
-    "params = {\n",
-    "\n",
-    "    \"model\":\n",
-    "      {\"name\": \"potential_model\",\n",
-    "      \"params\":\n",
-    "        {\"e_loss_multiplier\": 10.0,\n",
-    "        \"e_scale\": 27.2114,\n",
-    "        \"e_unit\": 27.2114,\n",
-    "        \"f_loss_multiplier\": 100.0,\n",
-    "        \"log_e_per_atom\": True,\n",
-    "        \"use_e_per_atom\": False,\n",
-    "        \"use_force\": True,}},\n",
-    "    \"network\":\n",
-    "      {\"name\": \"PiNet2\",\n",
-    "      \"params\":\n",
-    "        {\"atom_types\": [1, 8],\n",
-    "        \"basis_type\": \"gaussian\",\n",
-    "        \"depth\": 5,\n",
-    "        \"ii_nodes\": [16, 16, 16, 16],\n",
-    "        \"n_basis\": 10,\n",
-    "        \"out_nodes\": [16],\n",
-    "        \"pi_nodes\": [16],\n",
-    "        \"pp_nodes\": [16, 16, 16, 16],\n",
-    "        \"rank\": 3,\n",
-    "        \"rc\": 6.0,\n",
-    "        \"weighted\": False}},\n",
-    "    \"optimizer\":\n",
-    "      {\"class_name\": \"Adam\",\n",
-    "      \"config\":\n",
-    "        {\"global_clipnorm\": 0.01,\n",
-    "        \"learning_rate\":\n",
-    "          {\"class_name\": \"ExponentialDecay\",\n",
-    "          \"config\":\n",
-    "            {\"decay_rate\": 0.994,\n",
-    "            \"decay_steps\": 100000,\n",
-    "            \"initial_learning_rate\": 5.0e-05,}}}}\n",
-    "\n",
-    "}\n",
-    "\n",
-    "with open(\"MLP_Water/pinet2-pot.yml\", 'w') as f:\n",
-    "    yaml.dump(params, f)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "ps8JXQ4U_UdB"
-   },
-   "source": [
-    "## Train the MLP models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 0
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mlFaUm2f_Uc9"
+      },
+      "source": [
+        "# Building machine learning potentials (MLPs) for liquid water [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Build_MLP_Water.ipynb)\n",
+        "\n",
+        "\n",
+        "This notebook showcases the usage of PiNN with a practical problem of building machine learning potentials for liquid water on the H2O(l)-revPBE0-D3 dataset.\n",
+        "It serves as a basic test and demonstration of the workflow with PiNN."
+      ]
     },
-    "id": "k5mGgz49_UdB",
-    "outputId": "9269d17d-1003-4cad-9871-12d91f4473cf"
-   },
-   "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " 1275 samples written to MLP_Water/train.tfr, done.\n",
-      " 318 samples written to MLP_Water/vali.tfr, done.\n",
-      "Fitting an atomic dress from the training set.\n",
-      " RMSE after substracting the dress: 5.477752e-01\n",
-      "45568 trainable vaiables, training with float32 precision.\n",
-      "done\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "import yaml\n",
-    "import warnings\n",
-    "import tensorflow as tf\n",
-    "from pinn import get_model, get_network\n",
-    "from pinn.utils import init_params\n",
-    "from pinn.io import load_runner, write_tfrecord, load_tfrecord, sparse_batch\n",
-    "from tensorflow.python.lib.io.file_io import FileIO\n",
-    "from tempfile import mkdtemp, mkstemp\n",
-    "\n",
-    "random_seed = 1 # random seed for data splitting\n",
-    "num_train_steps = int(5e6) # total number of training steps; typical training step is ~5M steps\n",
-    "eval_per_num_steps = 500 # evaluate the models every eval_per_num_steps steps\n",
-    "batch_size = 1 # batch size\n",
-    "nmax_ckpts = 1 # max number of checkpoint file\n",
-    "nckpt_every = 50 # save the checkpoint file every nckpt_every steps\n",
-    "nlog_every = 50 # write the log file every nlog_every steps\n",
-    "num_shuffle_buffer = 1000\n",
-    "bool_shuffle = True\n",
-    "bool_preprocess = True # turn on/off the preprocess of dataset\n",
-    "bool_cache = True\n",
-    "bool_early_stop = False # turn on/off the early stop\n",
-    "\n",
-    "# set the GPU\n",
-    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
-    "\n",
-    "# turn off the specific warning of tensorflow\n",
-    "index_warning = 'Converting sparse IndexedSlices'\n",
-    "warnings.filterwarnings('ignore', index_warning)\n",
-    "tf.get_logger().setLevel('ERROR')\n",
-    "\n",
-    "project_dir = \"MLP_Water/\"\n",
-    "\n",
-    "# split training and test sets\n",
-    "runner_dataset_file = project_dir + \"input.data\"\n",
-    "dataset = load_runner(runner_dataset_file, splits={'train':8, 'vali':2}, shuffle=bool_shuffle, seed=random_seed)\n",
-    "write_tfrecord(project_dir + 'train.yml', dataset['train'])\n",
-    "write_tfrecord(project_dir + 'vali.yml', dataset['vali'])\n",
-    "\n",
-    "# get model parameters\n",
-    "params = {}\n",
-    "with FileIO(project_dir + \"pinet2-pot.yml\", 'r') as f:\n",
-    "    params = yaml.load(f, Loader=yaml.Loader)\n",
-    "\n",
-    "molde_dir = project_dir + \"PiNet2_rPBE0_seed%d\"%(random_seed)\n",
-    "params['model_dir'] = molde_dir\n",
-    "\n",
-    "# initial some parameters (e.g., e_dress)\n",
-    "ds = load_tfrecord(project_dir + \"train.yml\")\n",
-    "init_params(params, ds)\n",
-    "\n",
-    "scratch_dir = None\n",
-    "if scratch_dir is not None:\n",
-    "    scratch_dir = mkdtemp(prefix='pinn', dir=scratch_dir)\n",
-    "def _dataset_fn(fname):\n",
-    "    dataset = load_tfrecord(fname)\n",
-    "    if batch_size is not None:\n",
-    "        dataset = dataset.apply(sparse_batch(batch_size))\n",
-    "    if bool_preprocess:\n",
-    "        def pre_fn(tensors):\n",
-    "            with tf.name_scope(\"PRE\") as scope:\n",
-    "                network = get_network(params['network'])\n",
-    "                tensors = network.preprocess(tensors)\n",
-    "            return tensors\n",
-    "        dataset = dataset.map(pre_fn)\n",
-    "    if bool_cache:\n",
-    "        if scratch_dir is not None:\n",
-    "            cache_dir = mkstemp(dir=scratch_dir)\n",
-    "        else:\n",
-    "            cache_dir = ''\n",
-    "        dataset = dataset.cache(cache_dir)\n",
-    "    return dataset\n",
-    "\n",
-    "train_fn = lambda: _dataset_fn(project_dir + 'train.yml').repeat().shuffle(num_shuffle_buffer)\n",
-    "eval_fn = lambda: _dataset_fn(project_dir + 'vali.yml')\n",
-    "config = tf.estimator.RunConfig(keep_checkpoint_max=nmax_ckpts,\n",
-    "                                log_step_count_steps=nlog_every,\n",
-    "                                save_summary_steps=nlog_every,\n",
-    "                                save_checkpoints_steps=nckpt_every)\n",
-    "\n",
-    "model = get_model(params, config=config)\n",
-    "\n",
-    "if bool_early_stop:\n",
-    "    early_stop = \"loss:1000\"\n",
-    "    stops = {s.split(':')[0]: float(s.split(':')[1])\n",
-    "             for s in early_stop.split(',')}\n",
-    "    hooks = [tf.estimator.experimental.stop_if_no_decrease_hook(\n",
-    "        model, k, v) for k,v in stops.items()]\n",
-    "else:\n",
-    "    hooks=None\n",
-    "\n",
-    "train_spec = tf.estimator.TrainSpec(input_fn=train_fn, max_steps=num_train_steps, hooks=hooks)\n",
-    "eval_spec  = tf.estimator.EvalSpec(input_fn=eval_fn, steps=eval_per_num_steps)\n",
-    "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)\n",
-    "print('done')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "KHYSYGJU_UdC"
-   },
-   "source": [
-    "## Check the training loss"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 0
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZTdzb9ym_Uc_"
+      },
+      "outputs": [],
+      "source": [
+        "# Install konda\n",
+        "!pip -q install konda\n",
+        "\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "# Accept Anaconda Terms of Service\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "# Create the environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "\n",
+        "!konda activate pinn_env\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'ase>=3.25' 'PyYAML~=6.0.1' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "\n",
+        "#Install ase to runtime\n",
+        "import sys\n",
+        "!{sys.executable} -m pip -q install ase"
+      ]
     },
-    "id": "bI-g_zEb_UdC",
-    "outputId": "78c9b1aa-0498-473b-cf9d-1a4566f0e071"
-   },
-   "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "done\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "def log(log_dir, tag, fmt):\n",
-    "    from glob import glob\n",
-    "    from sys import stdout\n",
-    "    from warnings import warn\n",
-    "    from itertools import chain\n",
-    "    from tensorboard.backend.event_processing.event_file_loader import LegacyEventFileLoader\n",
-    "    files = sorted(glob(f'{log_dir}/events.out.*'), key=os.path.getmtime)\n",
-    "    logs = {}\n",
-    "    events = chain(*[LegacyEventFileLoader(log).Load() for log in files])\n",
-    "    for event in events:\n",
-    "        for v in event.summary.value:\n",
-    "            if tag not in v.tag:\n",
-    "                continue\n",
-    "            if v.tag not in logs.keys():\n",
-    "                logs[v.tag] = []\n",
-    "            logs[v.tag].append([event.step, v.simple_value])\n",
-    "    logs = {k: np.array(v) for k,v in logs.items()}\n",
-    "    keys = sorted(list(logs.keys()))\n",
-    "    steps = [logs[k][:,0] for k in keys]\n",
-    "    data = [logs[k][:,1] for k in keys]\n",
-    "    steps, rows = np.unique(np.concatenate(steps), return_inverse=True)\n",
-    "\n",
-    "    return (steps,data,keys)\n",
-    "\n",
-    "log_dir_train = molde_dir + \"/\"\n",
-    "train_loss = log(log_dir_train,'RMSE', '%14.6e ')\n",
-    "\n",
-    "log_dir_eval = molde_dir + \"/eval\"\n",
-    "eval_loss = log(log_dir_eval,'RMSE', '%14.6e ')\n",
-    "print(\"done\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 280
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "i7k54_m3_UdA"
+      },
+      "source": [
+        "## Download the H2O(l)-revPBE0-D3 dataset\n",
+        "\n",
+        "The H2O(l)-revPBE0-D3 dataset was published by Cheng et al ([Proc. Nat. Acad. Sci. 2019, 116, 1110-1115](https://doi.org/10.1073/pnas.1815117116)). It comprises 1593 liquid water configurations involving 64 molecules with the energies and forces computed by DFT at the revPBE0-D3 level and presents an excellent example to test MLPs in the interpolation regime."
+      ]
     },
-    "id": "jZhB8-BO_UdC",
-    "outputId": "8c1bcff9-5ca7-4607-b33e-258e71ce2cd6"
-   },
-   "outputs": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 2000x400 with 3 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "7HTszdEb_UdA"
+      },
+      "outputs": [],
+      "source": [
+        "# step 1: download the dataset\n",
+        "import requests\n",
+        "with requests.get(\"https://raw.githubusercontent.com/BingqingCheng/ab-initio-thermodynamics-of-water/master/training-set/input.data\", stream=True) as r:\n",
+        "    r.raise_for_status()\n",
+        "    with open(\"input.data\", 'wb') as f:\n",
+        "        for chunk in r.iter_content(chunk_size=8192):\n",
+        "            f.write(chunk)\n",
+        "\n",
+        "# step 2: create project directory\n",
+        "!mkdir MLP_Water\n",
+        "\n",
+        "# step 3: move the dataset file to project directory\n",
+        "!mv input.data MLP_Water"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "import matplotlib\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "train_steps = train_loss[0]\n",
-    "eval_steps = eval_loss[0]\n",
-    "train_metrics = train_loss[1]\n",
-    "eval_metrics = eval_loss[1]\n",
-    "metric_keys = train_loss[2]\n",
-    "num_metrics = len(metric_keys)\n",
-    "\n",
-    "fig, axs = plt.subplots(1, num_metrics, figsize=(20, 4))\n",
-    "\n",
-    "metrics_unit={\"METRICS/E_PER_ATOM_RMSE\":\"eV/Atom\",\n",
-    "          \"METRICS/E_RMSE\":\"eV\",\n",
-    "          \"METRICS/F_RMSE\":\"eV/Ang\"}\n",
-    "\n",
-    "for index in range(0, num_metrics):\n",
-    "    axs[index].set_xlabel(r'Step')\n",
-    "    y_label = \"%s(%s)\"%(metric_keys[index], metrics_unit[metric_keys[index]])\n",
-    "    axs[index].set_ylabel(y_label)\n",
-    "    axs[index].set_xlim(0, num_train_steps)\n",
-    "    axs[index].plot(train_steps, train_metrics[index], color='black', label=\"Training\")\n",
-    "    axs[index].plot(eval_steps, eval_metrics[index], color='red', label=\"Validation\")\n",
-    "    axs[index].legend(edgecolor='none', loc='best')\n",
-    "\n",
-    "plt.subplots_adjust(hspace=500)\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "I1z-xFvI_UdC"
-   },
-   "source": [
-    "## Run molecular dynamics with ASE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "H_YRSWitmTfn"
-   },
-   "outputs": [],
-   "source": [
-    "import requests\n",
-    "with requests.get(\"https://raw.githubusercontent.com/Teoroo-CMC/PiNN/refs/heads/master/docs/notebooks/MLP_Water/water.xyz\", stream=True) as r:\n",
-    "    r.raise_for_status()\n",
-    "    with open(\"water.xyz\", 'wb') as f:\n",
-    "        for chunk in r.iter_content(chunk_size=8192):\n",
-    "            f.write(chunk)\n",
-    "! cp water.xyz MLP_Water"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 0
     },
-    "id": "dQRpScdt_UdC",
-    "outputId": "256fc660-4e55-4da3-9f33-427028d612ad"
-   },
-   "outputs": [
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/usr/local/lib/python3.10/dist-packages/ase/md/md.py:48: FutureWarning: Specify the temperature in K using the 'temperature_K' argument\n",
-      "  warnings.warn(FutureWarning(w))\n"
-     ]
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Zbm9Qcws_UdB"
+      },
+      "source": [
+        "## Configure the model architecture and parameters\n",
+        "\n",
+        "Three different model architectures are supplied in the PiNN package, i.e., Behler−Parrinello neural network (BPNN, [Phys. Rev. Lett. 2007, 98, 146401](https://doi.org/10.1103/PhysRevLett.98.146401)), PiNet ([J. Chem. Inf. Model. 2020, 60, 1184−1193](https://doi.org/10.1021/acs.jcim.9b00994)), and PiNet2-P3. The BPNN and PiNet only involve invariant features, whereas PiNet2-P3 incorporates equivariant information as well. Generally speaking, the training loss of PiNet2-P3 is lower than that of BPNN/PiNet. Before training the MLPs, it is essential to define the model architecture and set corresponding parameters. In this case, we will use PiNet2-P3 as an example. You can also use following functions to know which networks and models are available."
+      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "done\n"
-     ]
-    }
-   ],
-   "source": [
-    "import pinn\n",
-    "from ase import units\n",
-    "from ase.io import read,write\n",
-    "from ase.io.trajectory import Trajectory\n",
-    "from ase.md import MDLogger\n",
-    "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution\n",
-    "from ase.md.nptberendsen import NPTBerendsen\n",
-    "from ase.md.nvtberendsen import NVTBerendsen\n",
-    "\n",
-    "setup = {\n",
-    "        'ensemble': 'nvt',  # ensemble\n",
-    "        'T': 330.0,  # temperature\n",
-    "        't': 1000,  # time in fs\n",
-    "        'dt': 0.5,  # timestep in fs\n",
-    "        'taut': 10,  # thermostat damping in steps\n",
-    "        'taup': 1000,  # barastat dampling in steps\n",
-    "        'log-every': 100,  # log interval in steps\n",
-    "        'pressure': 1,  # pressure in bar\n",
-    "        'compressibility': 4.57e-4,  # compressibility in bar^{-1}\n",
-    "    }\n",
-    "\n",
-    "ensemble=setup['ensemble']\n",
-    "T = float(setup['T'])\n",
-    "t=float(setup['t'])*units.fs\n",
-    "dt=float(setup['dt'])*units.fs\n",
-    "taut=int(setup['taut'])\n",
-    "taup=int(setup['taup'])\n",
-    "every=int(setup['log-every'])\n",
-    "pressure=float(setup['pressure'])\n",
-    "compressibility=float(setup['compressibility'])\n",
-    "\n",
-    "# get calculator\n",
-    "calc = pinn.get_calc(molde_dir + \"/params.yml\")\n",
-    "\n",
-    "# read initial structure\n",
-    "init_structure_file = project_dir + \"water.xyz\"\n",
-    "atoms = read(init_structure_file)\n",
-    "atoms.set_calculator(calc)\n",
-    "\n",
-    "# assign initial velocities (i.e., momenta)\n",
-    "MaxwellBoltzmannDistribution(atoms, T * units.kB)\n",
-    "\n",
-    "if ensemble == 'npt':\n",
-    "    dyn = NPTBerendsen(atoms, timestep=dt, temperature=T, pressure=pressure,\n",
-    "                  taut=dt * taut, taup=dt * taup, compressibility=compressibility)\n",
-    "if ensemble == 'nvt':\n",
-    "    dyn = NVTBerendsen(atoms, timestep=dt, temperature=T, taut=dt * taut)\n",
-    "\n",
-    "log_file = project_dir + \"asemd.log\"\n",
-    "dyn.attach(\n",
-    "    MDLogger(dyn, atoms,log_file,stress=True, mode=\"w\"),\n",
-    "    interval=int(50*units.fs/dt))\n",
-    "\n",
-    "traj_file = project_dir + \"asemd.traj\"\n",
-    "dyn.attach(\n",
-    "    Trajectory(traj_file, 'w', atoms).write,\n",
-    "    interval=int(50*units.fs/dt))\n",
-    "\n",
-    "# run simulations\n",
-    "dyn.run(int(t/dt))\n",
-    "\n",
-    "print(\"done\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "c8EZJTyw_UdD"
-   },
-   "source": [
-    "## Analyze the trajectory\n",
-    "\n",
-    "Once the trajectory has been acquired, you can perform various analyses based on it, such as calculating the radial distribution function (RDF) for specific pairs of atoms."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 40,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 0
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "beUw5rRAVIOD"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile get_networks.py\n",
+        "\n",
+        "import pinn\n",
+        "pinn.get_available_networks()"
+      ]
     },
-    "id": "92yiXFYf_UdD",
-    "outputId": "c7cb9bf6-ef21-4526-dfa8-72a0e57faf54"
-   },
-   "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "done\n"
-     ]
-    }
-   ],
-   "source": [
-    "import itertools\n",
-    "from ase.io import iread\n",
-    "\n",
-    "r_min = 0.0\n",
-    "r_max = 6.0\n",
-    "bin_num = 201\n",
-    "hist = 0\n",
-    "\n",
-    "bins = np.linspace(r_min,r_max,bin_num)\n",
-    "r_mid = (bins[1:] + bins[:-1])/2\n",
-    "bin_vol = (bins[1:]**3 - bins[:-1]**3)*4*np.pi/3\n",
-    "\n",
-    "from ase.io.trajectory import Trajectory\n",
-    "trajObj = Trajectory(traj_file)\n",
-    "start_fram_index = int(len(trajObj) / 2)\n",
-    "\n",
-    "count = 0\n",
-    "traj = iread(traj_file, index=slice(start_fram_index, None))\n",
-    "for data in traj:\n",
-    "\n",
-    "    count += 1\n",
-    "\n",
-    "    listIndex1 = [idx for idx in range(len(data)) if data[idx].symbol == \"O\"]\n",
-    "    index_ij = np.array(list(itertools.combinations(listIndex1, 2)))\n",
-    "\n",
-    "    data.wrap()\n",
-    "\n",
-    "    diff = data.positions[index_ij[:, 0]] - data.positions[index_ij[:, 1]]\n",
-    "    listCellLen = [data.cell[0][0], data.cell[1][1], data.cell[2][2]]\n",
-    "    diff = diff - np.rint(diff / listCellLen) * listCellLen\n",
-    "    dist = np.linalg.norm(diff, axis=1)\n",
-    "\n",
-    "    h, edges = np.histogram(dist, bins)\n",
-    "\n",
-    "    # normalize by the number density\n",
-    "    rho = dist.shape[0] / data.get_volume()\n",
-    "    hist += h / bin_vol / rho\n",
-    "\n",
-    "rdf = hist/count\n",
-    "print(\"done\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 392
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "6u6aYGTYPuOK",
+        "outputId": "2436a023-5297-410b-9f56-c55e1c4ce179"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Available networks:\n",
+            "  - PiNet\n",
+            "  - PiNet2\n",
+            "  - BPNN\n",
+            "  - LJ\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python get_networks.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ps8JXQ4U_UdB"
+      },
+      "source": [
+        "You can find detailed information about the parameters of both the `model` and the `network` on their respective pages under the `Usage` tab. These sections provide comprehensive guidance on how to configure and implement them effectively for your specific applications. Here is the configuration file for training water model:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Ow1LX1vz_UdB"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile parameters.py\n",
+        "\n",
+        "import yaml\n",
+        "\n",
+        "params = {\n",
+        "\n",
+        "    \"model\":\n",
+        "      {\"name\": \"potential_model\",\n",
+        "      \"params\":\n",
+        "        {\"e_loss_multiplier\": 10.0,\n",
+        "        \"e_scale\": 27.2114,\n",
+        "        \"e_unit\": 27.2114,\n",
+        "        \"f_loss_multiplier\": 100.0,\n",
+        "        \"log_e_per_atom\": True,\n",
+        "        \"use_e_per_atom\": False,\n",
+        "        \"use_force\": True,}},\n",
+        "    \"network\":\n",
+        "      {\"name\": \"PiNet2\",\n",
+        "      \"params\":\n",
+        "        {\"atom_types\": [1, 8],\n",
+        "        \"basis_type\": \"gaussian\",\n",
+        "        \"depth\": 5,\n",
+        "        \"ii_nodes\": [16, 16, 16, 16],\n",
+        "        \"n_basis\": 10,\n",
+        "        \"out_nodes\": [16],\n",
+        "        \"pi_nodes\": [16],\n",
+        "        \"pp_nodes\": [16, 16, 16, 16],\n",
+        "        \"rank\": 3,\n",
+        "        \"rc\": 6.0,\n",
+        "        \"weighted\": False}},\n",
+        "    \"optimizer\":\n",
+        "      {\"class_name\": \"Adam\",\n",
+        "      \"config\":\n",
+        "        {\"global_clipnorm\": 0.01,\n",
+        "        \"learning_rate\":\n",
+        "          {\"class_name\": \"ExponentialDecay\",\n",
+        "          \"config\":\n",
+        "            {\"decay_rate\": 0.994,\n",
+        "            \"decay_steps\": 100000,\n",
+        "            \"initial_learning_rate\": 5.0e-05,}}}}\n",
+        "\n",
+        "}\n",
+        "\n",
+        "with open(\"MLP_Water/pinet2-pot.yml\", 'w') as f:\n",
+        "    yaml.dump(params, f)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "oorbaOo-W6gl"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python parameters.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zrLsD0F_PuON"
+      },
+      "source": [
+        "## Train the MLP models"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "QgvvpGbOdT7u"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile train_MLP_models.py\n",
+        "\n",
+        "import os\n",
+        "import yaml\n",
+        "import warnings\n",
+        "import tensorflow as tf\n",
+        "from pinn import get_model, get_network\n",
+        "from pinn.utils import init_params\n",
+        "from pinn.io import load_runner, write_tfrecord, load_tfrecord, sparse_batch\n",
+        "from tensorflow.python.lib.io.file_io import FileIO\n",
+        "from tempfile import mkdtemp, mkstemp\n",
+        "\n",
+        "random_seed = 1 # random seed for data splitting\n",
+        "num_train_steps = int(5e6) # total number of training steps; typical training step is ~5M steps\n",
+        "eval_per_num_steps = 500 # evaluate the models every eval_per_num_steps steps\n",
+        "batch_size = 1 # batch size\n",
+        "nmax_ckpts = 1 # max number of checkpoint file\n",
+        "nckpt_every = 50 # save the checkpoint file every nckpt_every steps\n",
+        "nlog_every = 50 # write the log file every nlog_every steps\n",
+        "num_shuffle_buffer = 1000\n",
+        "bool_shuffle = True\n",
+        "bool_preprocess = True # turn on/off the preprocess of dataset\n",
+        "bool_cache = True\n",
+        "bool_early_stop = False # turn on/off the early stop\n",
+        "\n",
+        "# set the GPU\n",
+        "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
+        "\n",
+        "# turn off the specific warning of tensorflow\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "index_warning = 'Converting sparse IndexedSlices'\n",
+        "warnings.filterwarnings('ignore', index_warning)\n",
+        "tf.get_logger().setLevel('ERROR') #turns off tensorflow info and warnings. usually not recommended\n",
+        "\n",
+        "project_dir = \"MLP_Water/\"\n",
+        "\n",
+        "# split training and test sets\n",
+        "runner_dataset_file = project_dir + \"input.data\"\n",
+        "dataset = load_runner(runner_dataset_file, splits={'train':8, 'vali':2}, shuffle=bool_shuffle, seed=random_seed)\n",
+        "write_tfrecord(project_dir + 'train.yml', dataset['train'])\n",
+        "write_tfrecord(project_dir + 'vali.yml', dataset['vali'])\n",
+        "\n",
+        "# get model parameters\n",
+        "params = {}\n",
+        "with FileIO(project_dir + \"pinet2-pot.yml\", 'r') as f:\n",
+        "    params = yaml.load(f, Loader=yaml.Loader)\n",
+        "\n",
+        "model_dir = project_dir + \"PiNet2_rPBE0_seed%d\"%(random_seed)\n",
+        "params['model_dir'] = model_dir\n",
+        "\n",
+        "# initial some parameters (e.g., e_dress)\n",
+        "ds = load_tfrecord(project_dir + \"train.yml\")\n",
+        "init_params(params, ds)\n",
+        "\n",
+        "scratch_dir = None\n",
+        "if scratch_dir is not None:\n",
+        "    scratch_dir = mkdtemp(prefix='pinn', dir=scratch_dir)\n",
+        "def _dataset_fn(fname):\n",
+        "    dataset = load_tfrecord(fname)\n",
+        "    if batch_size is not None:\n",
+        "        dataset = dataset.apply(sparse_batch(batch_size))\n",
+        "    if bool_preprocess:\n",
+        "        def pre_fn(tensors):\n",
+        "            with tf.name_scope(\"PRE\") as scope:\n",
+        "                network = get_network(params['network'])\n",
+        "                tensors = network.preprocess(tensors)\n",
+        "            return tensors\n",
+        "        dataset = dataset.map(pre_fn)\n",
+        "    if bool_cache:\n",
+        "        if scratch_dir is not None:\n",
+        "            cache_dir = mkstemp(dir=scratch_dir)\n",
+        "        else:\n",
+        "            cache_dir = ''\n",
+        "        dataset = dataset.cache(cache_dir)\n",
+        "    return dataset\n",
+        "\n",
+        "train_fn = lambda: _dataset_fn(project_dir + 'train.yml').repeat().shuffle(num_shuffle_buffer)\n",
+        "eval_fn = lambda: _dataset_fn(project_dir + 'vali.yml')\n",
+        "config = tf.estimator.RunConfig(keep_checkpoint_max=nmax_ckpts,\n",
+        "                                log_step_count_steps=nlog_every,\n",
+        "                                save_summary_steps=nlog_every,\n",
+        "                                save_checkpoints_steps=nckpt_every)\n",
+        "\n",
+        "model = get_model(params, config=config)\n",
+        "\n",
+        "if bool_early_stop:\n",
+        "    early_stop = \"loss:1000\"\n",
+        "    stops = {s.split(':')[0]: float(s.split(':')[1])\n",
+        "             for s in early_stop.split(',')}\n",
+        "    hooks = [tf.estimator.experimental.stop_if_no_decrease_hook(\n",
+        "        model, k, v) for k,v in stops.items()]\n",
+        "else:\n",
+        "    hooks=None\n",
+        "\n",
+        "train_spec = tf.estimator.TrainSpec(input_fn=train_fn, max_steps=num_train_steps, hooks=hooks)\n",
+        "eval_spec  = tf.estimator.EvalSpec(input_fn=eval_fn, steps=eval_per_num_steps)\n",
+        "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)\n",
+        "print('done')"
+      ]
     },
-    "id": "h8gxyITc_UdD",
-    "outputId": "77e4474f-a6cc-4f3e-ce16-d3a2e3b656a4"
-   },
-   "outputs": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 400x400 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "k5mGgz49_UdB",
+        "outputId": "9269d17d-1003-4cad-9871-12d91f4473cf"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            " 1275 samples written to MLP_Water/train.tfr, done.\n",
+            " 318 samples written to MLP_Water/vali.tfr, done.\n",
+            "Fitting an atomic dress from the training set.\n",
+            " RMSE after substracting the dress: 5.477752e-01\n",
+            "45568 trainable vaiables, training with float32 precision.\n",
+            "done\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python train_MLP_models.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KHYSYGJU_UdC"
+      },
+      "source": [
+        "## Check the training loss"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "bI-g_zEb_UdC",
+        "outputId": "78c9b1aa-0498-473b-cf9d-1a4566f0e071"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "done\n"
+          ]
+        }
+      ],
+      "source": [
+        "import numpy as np\n",
+        "import json\n",
+        "import os\n",
+        "\n",
+        "def log(log_dir, tag, fmt):\n",
+        "    from glob import glob\n",
+        "    from sys import stdout\n",
+        "    from warnings import warn\n",
+        "    from itertools import chain\n",
+        "    from tensorboard.backend.event_processing.event_file_loader import LegacyEventFileLoader\n",
+        "    files = sorted(glob(f'{log_dir}/events.out.*'), key=os.path.getmtime)\n",
+        "    logs = {}\n",
+        "    events = chain(*[LegacyEventFileLoader(log).Load() for log in files])\n",
+        "    for event in events:\n",
+        "        for v in event.summary.value:\n",
+        "            if tag not in v.tag:\n",
+        "                continue\n",
+        "            if v.tag not in logs.keys():\n",
+        "                logs[v.tag] = []\n",
+        "            logs[v.tag].append([event.step, v.simple_value])\n",
+        "    logs = {k: np.array(v) for k,v in logs.items()}\n",
+        "    keys = sorted(list(logs.keys()))\n",
+        "    steps = [logs[k][:,0] for k in keys]\n",
+        "    data = [logs[k][:,1] for k in keys]\n",
+        "    steps, rows = np.unique(np.concatenate(steps), return_inverse=True)\n",
+        "\n",
+        "    return (steps,data,keys)\n",
+        "\n",
+        "# use the directory with trained models\n",
+        "project_dir = \"MLP_Water/\"\n",
+        "random_seed = 1\n",
+        "model_dir = project_dir + \"PiNet2_rPBE0_seed%d\"%(random_seed)\n",
+        "\n",
+        "log_dir_train = model_dir + \"/\"\n",
+        "train_loss = log(log_dir_train,'RMSE', '%14.6e ')\n",
+        "\n",
+        "log_dir_eval = model_dir + \"/eval\"\n",
+        "eval_loss = log(log_dir_eval,'RMSE', '%14.6e ')\n",
+        "print(\"done\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 280
+        },
+        "id": "jZhB8-BO_UdC",
+        "outputId": "8c1bcff9-5ca7-4607-b33e-258e71ce2cd6"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABnEAAAF4CAYAAACLs9zvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd1gUVxfG3wUVsACKBVQUNPaCRAxiElswSBIj9pbYNTG2BI2GaOyJJWo00cTEhkaNJX4ae8PeFcXErgQbzQoKKHW/P5bd7C4zuzOzMzuzu+f3PDzszty590zZmTvnvedclVqtVoMgCIIgCIIgCIIgCIIgCIIgCIJQFE5yG0AQBEEQBEEQBEEQBEEQBEEQBEEUhUQcgiAIgiAIgiAIgiAIgiAIgiAIBUIiDkEQBEEQBEEQBEEQBEEQBEEQhAIhEYcgCIIgCIIgCIIgCIIgCIIgCEKBkIhDEARBEARBEARBEARBEARBEAShQEjEIQiCIAiCIAiCIAiCIAiCIAiCUCAk4hAEQRAEQRAEQRAEQRAEQRAEQSgQEnEIgiAIgiAIgiAIgiAIgiAIgiAUCIk4BEEQBEEQBEEQBEEQBEEQBEEQCoREHIIgCIIgCIIgCIIgCIIgCIIgCAWiCBFn8eLF8PPzg6urK4KDg3H27FmT5Tdt2oS6devC1dUVjRo1wq5duwzW/+9//8O7774LLy8vqFQqxMXFFanj1atXGD58OLy8vFC6dGl06dIFqampYu4WQRAEQRB2wMyZM9GsWTOUKVMGFStWREREBG7cuGF2O3P9FbVajUmTJsHHxwdubm4IDQ3FrVu3pNoNgiAIgiAUDB+/yNKlS/H222+jbNmyKFu2LEJDQ4uU59LPePr0Kfr06QN3d3d4enpi0KBByMjIkGT/CIIgCIIQjuwizoYNGxAZGYnJkyfjwoULCAgIQFhYGB4+fMhY/uTJk+jVqxcGDRqEixcvIiIiAhEREbh8+bKuTGZmJt566y3Mnj2btd0vvvgC27dvx6ZNm3DkyBEkJSWhc+fOou8fQRAEQRC2zZEjRzB8+HCcPn0a+/fvR25uLt59911kZmaybsOlvzJnzhz8+OOPWLJkCc6cOYNSpUohLCwMr169ssZuEQRBEAShEPj6RQ4fPoxevXrh0KFDOHXqFHx9ffHuu+8iMTFRV4ZLP6NPnz64cuUK9u/fjx07duDo0aMYOnSo5PtLEARBEAQ/VGq1Wi2nAcHBwWjWrBkWLVoEACgoKICvry9GjhyJr776qkj5Hj16IDMzEzt27NAta968OZo0aYIlS5YYlL1z5w78/f1x8eJFNGnSRLc8PT0dFSpUwLp169C1a1cAwPXr11GvXj2cOnUKzZs3l2BPCYIgCIKwBx49eoSKFSviyJEjaNmyJWMZc/0VtVqNypUrY8yYMRg7diwATf+kUqVKiI6ORs+ePa2yLwRBEARByA9fv4gx+fn5KFu2LBYtWoS+ffty6mdcu3YN9evXx7lz5xAUFAQA2LNnD9577z08ePAAlStXlm6HCYIgCILgRTE5G8/JyUFsbCyioqJ0y5ycnBAaGopTp04xbnPq1ClERkYaLAsLC8PWrVs5txsbG4vc3FyEhobqltWtWxfVqlVjFXGys7ORnZ2t+15QUICnT5/qUrYRBEEQBKFJ3fHixQtUrlwZTk6yB/xKQnp6OgCgXLlyrGXM9VcSEhKQkpJi0Bfx8PBAcHAwTp06xSjiUF+EIAiCIMxja30RIX4RY7KyspCbm6vrm3DpZ5w6dQqenp46AQcAQkND4eTkhDNnzqBTp05F2qG+CEEQBEGYR4q+iKwizuPHj5Gfn49KlSoZLK9UqRKuX7/OuE1KSgpj+ZSUFM7tpqSkoESJEvD09ORcz8yZMzF16lTObRAEQRCEI3P//n1UrVpVbjNEp6CgAJ9//jnefPNNNGzYkLWcuf6K9j+fPg31RQiCIAiCO7bSFxHiFzFm/PjxqFy5sk604dLPSElJQcWKFQ3WFytWDOXKlaO+CEEQBEGIgJh9EVlFHFsiKirKYERteno6qlWrhvv378Pd3R2AJk3KtWvXdOsJgiAIwtF4/vw5fH19UaZMGblNkYThw4fj8uXLOH78uNXb5tIX6dKlCw4cOKBbTxAEQRCOhr33RYyZNWsW1q9fj8OHD8PV1VXStkz1RYoVKwYfHx8AwN9//43GjRsblDOFh4cHAGDQoEGYP3++BJZbB+1+lC1bFnfu3GFcp8+vv/6KTz75BIBmXqT27dtLbiMbI0aMwO+//w7AOn3IkJAQXL16VZL2tMfazc2N14BvgiAIsZCiLyKriFO+fHk4OzsjNTXVYHlqaiq8vb0Zt/H29uZVnq2OnJwcpKWlGUTjmKrHxcUFLi4uRZa7u7vrHCfOzs4GywmCIAjCUbHHlBojRozQTfprbjSNuf6K9n9qaqrO4aH9rj+Pnz5c+iLFihUzWE4QBEEQjoqt9EWE+EW0zJ07F7NmzcKBAwcMRBMu/Qxvb288fPjQoL68vDw8ffpUkF9Evw9i7LTi2idxcXGxi/6LSqXitB/6opubm5us+65/XoXYkZ6ejm+++Qa9e/fmNM+0fnohKffbHq4ngiBsFzH7IrImiC1RogSaNm2KmJgY3bKCggLExMQgJCSEcZuQkBCD8gCwf/9+1vJMNG3aFMWLFzeo58aNG7h37x6vegiCIAiCsH/UajVGjBiBLVu24ODBg/D39ze7jbn+ir+/P7y9vQ3KPH/+HGfOnKG+CEEQBEE4EEL8IgAwZ84cTJ8+HXv27DGY1wbg1s8ICQlBWloaYmNjdWUOHjyIgoICBAcH894PtVrNextjbEV4M4cYx8IccXFxWLFihWhtWXrso6Ki8NNPP3Hux1rjGBEEQdgTsqdTi4yMRL9+/RAUFIQ33ngDCxYsQGZmJgYMGAAA6Nu3L6pUqYKZM2cCAEaPHo1WrVph3rx5eP/997F+/XqcP38ev/32m67Op0+f4t69e0hKSgKgEWgAzUgTb29veHh4YNCgQYiMjES5cuXg7u6OkSNHIiQkhNOIAYIgCIIgHIfhw4dj3bp1+Ouvv1CmTBldWgYPDw+4ubkB4N9fUalU+PzzzzFjxgzUqlUL/v7++Oabb1C5cmVERETIsp8EQRAEQcgDX7/I7NmzMWnSJKxbtw5+fn66vknp0qVRunRpTv2MevXqoX379hgyZAiWLFmC3NxcjBgxAj179kTlypUt2h+hgoC9iDhC4CtqBAYGAtBEcn344YcWt2/psdemRuMKiTgEQRD8kF3E6dGjBx49eoRJkyYhJSUFTZo0wZ49e3QT8N27d88gzLJFixZYt24dJk6ciK+//hq1atXC1q1bDSYX3rZtm66zAwA9e/YEAEyePBlTpkwBAPzwww9wcnJCly5dkJ2djbCwMPz8889W2GOCIAiCIGyJX375BQDQunVrg+UrV65E//79AQjrr4wbNw6ZmZkYOnQo0tLS8NZbb2HPnj2S57MnCIIgCEJZ8PWL/PLLL8jJyUHXrl0N6tH3eXDpZ6xduxYjRozAO++8o/OP/Pjjj4L2gSJx+CPGMfvnn38UIeIQBEEQ0qJSk/wtiOfPn8PDwwPp6em6HJuNGzfGP//8A4BGFRAEQRCOCdPzkZAGpmP93nvvYffu3QCoL0IQBEE4JtQXsR76x1p/Hpg7d+7Az89PV85cn0QrIIwaNQoLFy6UzF6p0e5H2bJl8fTpU8Z1+kRHR+sGBP3111+8xBhtfTNmzMCECRMEWvwfw4YNw5IlSwAI60O2atUKR48e5bx9/fr1ce3aNcHtmUJ7bNzc3JCVlSVq3QRBEFyQoi8i65w4BEEQBEEQBEEQBEEQhG1j7IgXEtlhL9EgQkQJuQffWPvYy72/hH2Rm5uLwYMHY/369XKbQhCSQSIOQRAEQRAEQRAEQRAEIZiCggLdZ5VKBWdnZxmtsQ2UJGRYKuLw3Rcl7Tth+6xYsQLLly9Hr1695DaFICSDRByCIAiCIAiCIAiCIAhCMMZOef05fLgiZBt7QaioIZYYQiIOYcs8fPhQbhMIQnIc9wlJEARBEARBEARBEARBWIyxU75YsWK867CXdGpcUZKQQenUCIIglA2JOARBEARBEHaCozk/CIIgCIJQBsZOeSHp1OylH2NNgUKsY2Yvx14fEooIgrAnSMQhCIIgCIIgCIIgCIIgBGM8J44jp0YTApvg8PLlS+zZswcvX77ktR1fLD1flE6NIAhCWuipKiL2OHKBIAiCsBw/Pz8sWLCAc/nDhw9DpVIhLS1NMpsIgiAIgnAcqC9CSA2lU+MPFyFj6NChCA8Px9ChQyW1xR7nxHG064kgCPuGRByCIAiCKESlUpn8mzJliqB6z507x+vFq0WLFkhOToaHh4eg9giCIAiCsE2oL0LYKvpOebVaLSidmiNH77CJGmvWrDH4by9YQ8ShaB+CIOwJ/kMjCIIgCMJOSU5O1n3esGEDJk2ahBs3buiWlS5dWvdZrVYjPz+f0yjDChUq8LKjRIkS8Pb25rUNQRAEQRC2D/VFCFvFWMQRIsjYS+SELc6JQ+nUCIIglI3jDnMgCIIgrI5arUZmZqbV/7i+JHh7e+v+PDw8oFKpdN+vX7+OMmXKYPfu3WjatClcXFxw/PhxxMfHo2PHjqhUqRJKly6NZs2a4cCBAwb1GqcwUalUWLZsGTp16oSSJUuiVq1a2LZtm269cQqT6OhoeHp6Yu/evahXrx5Kly6N9u3bGzh68vLyMGrUKHh6esLLywvjx49Hv379EBERIfh8EbaHvTg/CIIgpIL6IhqoL0KIjf6cOEIjcRwNY+HL0joswdp9SBJxCIIg+EEijszk5ubi6dOncptBEARhFbKyslC6dGmr/2VlZYm2D1999RVmzZqFa9euoXHjxsjIyMB7772HmJgYXLx4Ee3bt0eHDh1w7949k/VMnToV3bt3x99//4333nsPffr0Mfk8yMrKwty5c/H777/j6NGjuHfvHsaOHatbP3v2bKxduxYrV67EiRMn8Pz5c2zdulWs3SYIgiAIu4D6Iv9BfRFCTMRIp0aDUWwXEmUIgiCkhUQcERHS4WjQoAG8vLyQmJgogUUEQRCE2EybNg3t2rVDzZo1Ua5cOQQEBOCTTz5Bw4YNUatWLUyfPh01a9Y0GM3KRP/+/dGrVy+89tpr+O6775CRkYGzZ8+yls/NzcWSJUsQFBSE119/HSNGjEBMTIxu/U8//YSoqCh06tQJdevWxaJFi+Dp6SnWbhMEQRAEoRCoL0IoERJx+KMU4eOLL77AvHnzrNqmUvadIAjCVqA5cWTm1q1bAIA9e/Zg0KBBMltDEAQhLSVLlkRGRoYs7YpFUFCQwfeMjAxMmTIFO3fuRHJyMvLy8vDy5Uuzo18bN26s+1yqVCm4u7vj4cOHrOVLliyJmjVr6r77+PjoyqenpyM1NRVvvPGGbr2zszOaNm1qkNqCIAiCIBwd6ov8B/VFCDGxpoiTnZ2N1NRUVKtWjXcb1kCIQCGXqJGWlmaQalEoNCcOQRCEtJCIQxAEQVgNlUqFUqVKyW2GRRjbP3bsWOzfvx9z587Fa6+9Bjc3N3Tt2hU5OTkm6ylevLjBd5VKZdLJwVSeXn4IgiAIgh/UF/kP6osQYiLGnDhcRZymTZviypUrOHv2LJo1a8a7HeI/8vPzRamHRBxCThwtio9wTCidGkEQBEFYwIkTJ9C/f3906tQJjRo1gre3N+7cuWNVGzw8PFCpUiWcO3dOtyw/Px8XLlywqh0EQRAEQVgf6osQSsCakThXrlwBAKxbt66IDTdu3LAZgcD4mDkSjra/hLTQ9UQ4AoIjcbKzs3HmzBncvXsXWVlZqFChAgIDA+Hv7y+mfQ4D3XAIgiBsk1q1auF///sfOnToAJVKhW+++UaWtCEjR47EzJkz8dprr6Fu3br46aef8OzZMxqVRBAEQRB2DvVFCCWghDlxJk6ciO+++w7jx4/HrFmzLKrLUZDLF0U+MIIgCH7wFnFOnDiBhQsXYvv27cjNzYWHhwfc3Nzw9OlTZGdno0aNGhg6dCg+/fRTlClTRgqbCYIgCEIxzJ8/HwMHDkSLFi1Qvnx5jB8/Hs+fP7e6HePHj0dKSgr69u0LZ2dnDB06FGFhYYJeoAmCIAiCsB2oL0IoAWMRx8mJf+IXS0Wc7777DgAwe/ZsWUUcRxQolLjPSrSJkAYaLEA4ArxEnA8//BAXLlxA7969sW/fPgQFBcHNzU23/t9//8WxY8fwxx9/YP78+Vi9ejXatWsnutEEQRAEITX9+/dH//79dd9bt27N+CLg5+eHgwcPGiwbPny4wXfjlCZM9aSlpbG2ZWwLAERERBiUKVasGH766Sf89NNPADR5yevVq4fu3bsz7h9hn9ALDEEQhP1AfRHCljCeE6dYMW7uJv1ryJH6McZzStm64EBz4hByQtcT4QjwEnHef/99bN68uciEhlpq1KiBGjVqoF+/frh69SqSk5NFMdJWcKQOB0EQBKEs7t69i3379qFVq1bIzs7GokWLkJCQgN69e8ttGkEQBEEQDgD1RRwbU+nU1Go1q79EX/xxJJ+KkEgle8IaTndHup4IgrB/eIk4n3zyCeey9evXR/369XkbRBAEQRAEf5ycnBAdHY2xY8dCrVajYcOGOHDgAOrVqye3aQRBEARBOADUF3FsTKVTKygoYE2rR5E4GpQ0N40p0Y1PPWKWFwJFZxAEYU/wnhOHiYyMjCITJ7q7u4tRNUEQBEEQHPD19cWJEyfkNoMgCIIgCAeF+iKOjbHDXD+dWl5eHquIY+xLsge4iAdKFqyEiDhC2iAIgiC4Izh+MyEhAe+//z5KlSoFDw8PlC1bFmXLloWnpyfKli0rpo0EQRAEQRAEQRAEQRCEQjGeE0dftMnLy+O0nSOlGFPKvjKJKUKENRJlCIIgpEVwJM5HH30EtVqNFStWoFKlSooeRWAL0AOPIAiCIAg5OHToEI4ePYqJEyeyjpIlCIIgCIIwhal0avn5+Zy24+tXsmU/lFLSqTFBqc4IgiCUh2AR59KlS4iNjUWdOnXEtIcgCIIgCIKwIm3btgUA+Pn5oV+/fjJbQxAEQRCErbFv3z5MmjRJ993YQW/KYa8f9WHLogxflLKvckXikIhDiIlSfk8EISWCRZxmzZrh/v37JOKIBN1wCIIgCIKwFEv6E//++6+IlhAEQRAE4Sh069bN4LvxnCqmRAFHnRPHOJ2akkQNEnEIW4OuJ8IRECziLFu2DJ9++ikSExPRsGFDFC9e3GB948aNLTbO1iAhhiAIgiAIW4VefgiCIAiCEANjEYcicYpinE5NLphsUIJdBMFETk4Ojh07hhYtWsDNzU1ucwjCqggWcR49eoT4+HgMGDBAt0z7EFKpVCZznhJFoYckQRAEQRAEQRAEQRC2Dp90apbMiSMmubm5aN26NQICAvDzzz9L3p5SInHESqcmRrsEYY7IyEgsXrwY3bt3x4YNG3TLHUkAJhwXJ/NFmBk4cCACAwNx6tQp/Pvvv0hISDD4TxAEQRCOSuvWrfH555/rvvv5+WHBggUmt1GpVNi6davFbYtVD0EQBEEQtgv1RQg5EZpOTU5H7P79+3Hy5En88ssvFtfFRaBQciQOpVMjlMrixYsBABs3bjRYTtcT4QgIFnHu3r2L2bNnIzg4GH5+fqhevbrBH0EQBEHYIh06dED79u0Z1x07dgwqlQp///03rzrPnTuHoUOHimGejilTpqBJkyZFlicnJyM8PFzUthydo0ePokOHDqhcuTInx1T//v2hUqmK/DVo0EBXZsqUKUXW161bV+I9MQ2NYCMIglAG1BdxTBYvXgw/Pz+4uroiODgYZ8+eZS175coVdOnSBX5+flCpVIwCnXad8d/w4cN1ZVq3bl1k/aeffmrxvvCJxFGKiJObm2vV9pTS7xIrnZoSRRxy7BMEYU8IFnHatm2LS5cuiWkLQRAEQcjOoEGDsH//fjx48KDIupUrVyIoKIj3vG8VKlRAyZIlxTLRJN7e3nBxcbFKW45CZmYmAgICdCO/zLFw4UIkJyfr/u7fv49y5coVmfS3QYMGBuWOHz9usa2WOAToRZcgCEIZUF/E8diwYQMiIyMxefJkXLhwAQEBAQgLC8PDhw8Zy2dlZaFGjRqYNWsWvL29GcucO3fOoJ+xf/9+ACjSHxkyZIhBuTlz5li8P2q12qBfYQsijrX7QWKlU7PUbkqnRtgDShFFCUJKBIs4HTp0wBdffIEpU6Zg8+bN2LZtm8GfI0I3DYIgCDOo1UBmpvX/eLwkfPDBB6hQoQKio6MNlmdkZGDTpk2IiIhAr169UKVKFZQsWRKNGjXCH3/8YbJO4xQmt27dQsuWLeHq6or69evrXqr1GT9+PGrXro2SJUuiRo0a+Oabb3QjBKOjozF16lRcunRJN2pSa69xpMg///yDtm3bws3NDV5eXhg6dCgyMjJ06/v374+IiAjMnTsXPj4+8PLywvDhw60+GlHJhIeHY8aMGejUqROn8h4eHvD29tb9nT9/Hs+ePTOYRxAAihUrZlCufPnyJuvNzs7G8+fPDf4IgiAInlBfBAD1RZTG/PnzMWTIEAwYMAD169fHkiVLULJkSaxYsYKxfLNmzfD999+jZ8+erIJZhQoVDPoZO3bsQM2aNdGqVSuDciVLljQo5+7uzmon174IHxGHazmpsYZwoQ+lU5N+38lHZxts3LgRkyZNUsTvgSCUTDGhG2pDbKdNm1ZknUqlQn5+vnCrCIIgCPskKwsoXdr67WZkAKVKcSparFgx9O3bF9HR0ZgwYYKu879p0ybk5+fjo48+wqZNmzB+/Hi4u7tj586d+Pjjj1GzZk288cYbZusvKChA586dUalSJZw5cwbp6ekGOeu1lClTBtHR0ahcuTL++ecfDBkyBGXKlMG4cePQo0cPXL58GXv27MGBAwcAaIQDYzIzMxEWFoaQkBCcO3cODx8+xODBgzFixAgDx9ChQ4fg4+ODQ4cO4fbt2+jRoweaNGmCIUOGcDpmhGmWL1+O0NDQIulmb926hcqVK8PV1RUhISGYOXMmqlWrxlrPzJkzMXXqVKnNJQiCsG+oL0J9EYWRk5OD2NhYREVF6ZY5OTkhNDQUp06dEq2NNWvWIDIysohje+3atVizZg28vb3RoUMHfPPNN6xRW1z7IsbOWK5z4tgLXOfE4bsNl3r4IlY6NSVirZRtixcvRvPmzREUFCR5e/ZIjx49AACtWrXCO++8Y7Ksk5OTXd4zCIILgiNxCgoKWP9IwCEIdl68eIF169YhPT1dblMIgmBh4MCBiI+Px5EjR3TLVq5ciS5duqB69eoYO3YsmjRpgho1amDkyJFo3759kckV2Thw4ACuX7+O1atXIyAgAC1btsR3331XpNzEiRPRokUL+Pn5oUOHDhg7dqyuDTc3N5QuXdogksPNza1IHevWrcOrV6+wevVqNGzYEG3btsWiRYvw+++/IzU1VVeubNmyWLRoEerWrYsPPvgA77//PmJiYvgeNoKBpKQk7N69G4MHDzZYHhwcjOjoaOzZswe//PILEhIS8Pbbb+PFixesdUVFRSE9PV33d//+fanNJwiCIGSC+iKO0xd5/Pgx8vPzUalSJYPllSpVQkpKiihtbN26FWlpaejfv7/B8t69e2PNmjU4dOgQoqKi8Pvvv+Ojjz5irYdrX0RoOjU5xQO506kJhdKpycvGjRsxcuRINGvWTJb2r169in379snSttiwpY/Uh6KrCEdGcCQOIS728gAjzDNw4ED8+eefePfdd7F37165zSEI61KypGYkqhzt8qBu3bpo0aIFVqxYgdatW+P27ds4duwYpk2bhvz8fHz33XfYuHEjEhMTkZOTg+zsbM555q9duwZfX19UrlxZtywkJKRIuQ0bNuDHH39EfHw8MjIykJeXZzK9BVtbAQEBKKU38vfNN99EQUEBbty4oXMWNGjQAM7OzroyPj4++Oeff3i1RTCzatUqeHp6IiIiwmC5/oTPjRs3RnBwMKpXr46NGzdi0KBBjHW5uLhIOscA9UUIgnAIqC9CfREHZPny5QgPDzc45wAwdOhQ3edGjRrBx8cH77zzDuLj41GzZs0i9XDti1A6NfNQOjX5910MLl++LGv7DRo00Nmh/WzPODk5UeAA4bBYJP0fOXIEHTp0wGuvvYbXXnsNH374IY4dOyaWbQRhl/z5558AYDejJQiCFyqVJpWItf8EjNgZNGgQNm/ejBcvXmDlypW6HOLff/89Fi5ciPHjx+PQoUOIi4tDWFgYcnJyRDtMp06dQp8+ffDee+9hx44duHjxIiZMmCBqG/oUL17c4LtKpaIwdRFQq9VYsWIFPv74Y5QoUcJkWU9PT9SuXRu3b9+2qE0anUYQBGEG6otwgvoi1qN8+fJwdnY2iEwCgNTUVHh7e1tc/927d3HgwIEiUcFMBAcHA4DF/RFjuKZTc6RIHLHSqVmKWOnUHFXEUUrf++rVq3KbYDFcrgl9sZ8gHA3BIs6aNWsQGhqKkiVLYtSoURg1ahTc3NzwzjvvYN26dWLa6BAo5cZPEARBaOjevTucnJywbt06rF69GgMHDoRKpcKJEyfQsWNHfPTRRwgICECNGjVw8+ZNzvXWq1cP9+/fR3Jysm7Z6dOnDcqcPHkS1atXx4QJExAUFIRatWrh7t27BmVKlChhdhRSvXr1cOnSJWRmZuqWnThxAk5OTqhTpw5nmwlhHDlyBLdv32aNrNEnIyMD8fHx8PHxsYJlzFBfhCAIQllQX8QxKFGiBJo2bWqQPq6goAAxMTGMEVJ8WblyJSpWrIj333/fbNm4uDgAsLg/IjSdGl/E7LuIKRoa7y/T/js5OYkiZEgxJw5F4hBKhd5XCEdGsIjz7bffYs6cOdiwYYNOxNmwYQNmzZqF6dOni2mjQ0APMIIgCGVRunRp9OjRA1FRUUhOTtblEK9Vqxb279+PkydP4tq1a/jkk0+KjJw0RWhoKGrXro1+/frh0qVLOHbsGCZMmGBQplatWrh37x7Wr1+P+Ph4/Pjjj9iyZYtBGT8/PyQkJCAuLg6PHz9GdnZ2kbb69OkDV1dX9OvXD5cvX8ahQ4cwcuRIfPzxx0XyrhPsZGRkIC4uTufY0B73e/fuAdDkh+/bt2+R7ZYvX47g4GA0bNiwyLqxY8fiyJEjuHPnDk6ePIlOnTrB2dkZvXr1knRfCIIgCNuB+iKOQ2RkJJYuXYpVq1bh2rVrGDZsGDIzMzFgwAAAQN++fREVFaUrn5OTo+ub5OTkIDExEXFxcUUiaAoKCrBy5Ur069cPxYoZZtOPj4/H9OnTERsbizt37mDbtm3o27cvWrZsicaNG1u0P7Y4J46UMO2XWJE4NCeOvJCoYF3EmkuKIGwRwVf/v//+iw4dOhRZ/uGHHyIhIcEio2wVunkTBEHYF4MGDcKzZ88QFhamyyE+ceJEvP766wgLC0Pr1q3h7e1dZL4TUzg5OWHLli14+fIl3njjDQwePBjffvutQZkPP/wQX3zxBUaMGIEmTZrg5MmT+OabbwzKdOnSBe3bt0ebNm1QoUIF/PHHH0XaKlmyJPbu3YunT5+iWbNm6Nq1K9555x0sWrSI/8FwYM6fP4/AwEAEBgYC0DhaAgMDMWnSJABAcnKyTtDRkp6ejs2bN7NG4Tx48AC9evVCnTp10L17d3h5eeH06dOoUKGCtDtjAnt5mSYIgrAnqC/iGPTo0QNz587FpEmT0KRJE8TFxWHPnj06oevevXsGkVNJSUm6vklycjLmzp2LwMDAIinTDhw4gHv37mHgwIFF2ixRogQOHDiAd999F3Xr1sWYMWPQpUsXbN++3eL9scU5caRsm0kUUYr/SC4Rx15Qynm0B7gcSxJxCEemmPkizPj6+iImJgavvfaawfIDBw7A19fXYsMIgiAIQm5CQkKKvNiUK1cOW7duNbnd4cOHDb7fuXPH4Hvt2rWLzCFn3M6cOXMwZ84cg2Wff/657rOLi4tuji1T9TRq1AgHDx5ktTU6OrrIsgULFrCWd0Rat25t8sWe6Rh6eHggKyuLdZv169eLYRpBEARh51BfxHEYMWIERowYwbjO+Hz6+flxEh3effdd1nK+vr44cuQIbzu5YNymLcyJw2ZjYmIivv76a4wcORJBQUGC6uaSTo3mxCEI85BoRjgygkWcMWPGYNSoUYiLi0OLFi0AaHLbRkdHY+HChaIZSBAEQRAEQRAEQRAEQdgGtphOja3tjz/+GIcOHcLq1as528dFxFKKM5rSqRG2BEXiEI6MYBFn2LBh8Pb2xrx587Bx40YAmkkLN2zYgI4dO4pmIEEQBEEQBMENpTgECIIgCIJwXISmUxPSjliw1XX58mVJ6lZKn00sEUeJkTjWaEMp59Ee4HK+SMQhHBnBIg4AdOrUCZ06dRLLFoIgCIIgCIIgCIIgCMKGMXbG2lokjlqt1jnn8/PzRa1bi0qlsol0amq1Gj169ICLiwt+//13XvXwbZcgzEGiGeHICJYwa9SogSdPnhRZnpaWhho1alhkFEEQBEEQBEEQBEEQBGF7GEfi8J0T58WLF5yc/GI6dNnEJDFEHFtOp5aYmIhNmzZhzZo1ePHihaTtio01jrFSzqOjQJE49o1arUZ2drbcZigWwVf/nTt3GB9m2dnZSExMtMgoR4RGIRAEQRAEQRDW4M6dO+jWrRvOnDkjtykEQRCEHWLJnDinT5+Gu7s7hg4dKqmNxrDZK0ZqMab9d3JyUmwkjv4+KyVSSgi2Zi9hHhJx7JsePXqgZMmSSEpKktsURcI7ndq2bdt0n/fu3QsPDw/d9/z8fMTExMDPz08U42wNUuAJgiAIgiAIpdOjRw+cPXsWf/75Jzk4CIIgCNEROieOWq3G9OnTAQDLli3D0qVLpTPSjB1apEynpgTMpVOzpB4xyysVpZxHR4GOt32zadMmAMDKlSsxYcIEma1RHrxFnIiICACaH06/fv0M1hUvXhx+fn6YN2+eKMYRBEEQBEEQ1sFeXqYJ89y+fVtuEwiCIAg7xrhPwTWdmpxIKeLYcjo1c2W5rBOjvFJRynl0FCgSh3BkeIs42pu5v78/zp07h/Lly4tuFEEQBEEQBEEQ0mAvjhOCIAhCmViSTk0upzhbCjUxRCZbTqcm1fmgvoiyUKvV6Ny5M6pVq4aFCxfKbQ4rJOI4BiSOMiP46k9ISCgi4KjVauzevRtdu3a12DCCIAiCIAiCIAiCIAjCtrBFEYdt7hep5sRRipNSrnRqhLK4cOECtm7dih9//FFuU0yilN8NQciBKBJmQkICvvnmG1SrVg2dOnXCq1evxKiWIAiCIAiCIAiCIAiCsGH4zInDx0krpkNX7nRqSo3EMVdWzHZtEXsRFXJzc+U2gRP6kTh5eXm4evWq4q+l9PR0vHjxQm4zCDtAsIiTnZ2NtWvXom3btqhTpw6+++47REZG4uHDh9ixY4eYNtoM9nLzJgiCIAjCNqG+CMEFpb/sEgRBELaNcSQO1zlx5Hw+SZnajEs6Nbngk06N5sSRnri4OGzcuNHq7drKO4S+iNOtWzc0aNAAy5Ytk9Ei02RnZ8PT0xPu7u6iCMKEY8NbxImNjcVnn30Gb29vLFiwABEREbh//z6cnJwQFhYGd3d3Key0e+gBRhAEQRAEQRAEQRCErSM0nRognzPZ0hRqXOvWItZ+Tpo0CcOHDxe8PZ90auS3KorY12tgYCB69OiB48ePi1qvOfTFESWfZ/3jvXXrVgDAvHnzZLLGPElJSbrPlLWKO7YiKlob3iJOcHAwXFxccPr0aZw7dw6jRo1CpUqVLDJi8eLF8PPzg6urK4KDg3H27FmT5Tdt2oS6devC1dUVjRo1wq5duwzWq9VqTJo0CT4+PnBzc0NoaChu3bplUObmzZvo2LEjypcvD3d3d7z11ls4dOiQRftBEARBEARBEEqHXowIgiAIKeEj4liSTk1MxIzEMd6eLZ2aWG3+/PPPgrflk07NlLglluNfrVZjzJgxWLx4sSj12SpXrlyxanv6vzuxRUyucLmG9MUmgnA0eF/977zzDpYvX45p06Zhz549Ft+oN2zYgMjISEyePBkXLlxAQEAAwsLC8PDhQ8byJ0+eRK9evTBo0CBcvHgRERERiIiIwOXLl3Vl5syZgx9//BFLlizBmTNnUKpUKYSFhRmonh988AHy8vJw8OBBxMbGIiAgAB988AFSUlIs2h8+6B87epkmCIIgCEJOlDzqjhAXOtcEQRCElHARMZjWySniSJnWjS2dmhKQK50aG+fOncP8+fMxYsQIi+uyRn/HXnx5ShBxuKCU3w1ByAHvq3/v3r24cuUK6tSpg2HDhsHHxwejR48GIOzmNX/+fAwZMgQDBgxA/fr1sWTJEpQsWRIrVqxgLL9w4UK0b98eX375JerVq4fp06fj9ddfx6JFiwBobtILFizAxIkT0bFjRzRu3BirV69GUlKSLtTu8ePHuHXrFr766is0btwYtWrVwqxZs5CVlWUgBumTnZ2N58+fG/yJCb1MEwRBEARBEARBEARh6whNp+ZIc+IY+8/Ejv6xZDs506mlp6dL3oaYkIhjXZiOt72cA4IwhyAJ09fXF5MmTUJCQgJ+//13PHr0CMWKFUPHjh3x9ddf48KFC5zqycnJQWxsLEJDQ/8zyMkJoaGhOHXqFOM2p06dMigPAGFhYbryCQkJSElJMSjj4eGB4OBgXRkvLy/UqVMHq1evRmZmJvLy8vDrr7+iYsWKaNq0KWO7M2fOhIeHh+7P19eX0z6agoQbgrBdCgoKcPXqVfodEwRBEARBEARB6GGJiKOEdGqWOrGN94FLOjVLEWqzuUgcKecKkhpbdu5b23YliDhc9pktEkfuc52amorg4GAsX75cVjsI+8biOLR27dph3bp1SEpKwsiRI7F79240a9aM07aPHz9Gfn5+kTl1KlWqxJrWLCUlxWR57X9TZVQqFQ4cOICLFy+iTJkycHV1xfz587Fnzx6ULVuWsd2oqCikp6fr/u7fv89pH01Bzl+CsF3GjRuHBg0a4Ouvv5bbFIIgCILgBfVBCYIgCCkxfs5ov587dw6vvfYatmzZwlpWCSKO2FExXNKp8WmTqWxubi7n7c3VxebEt0Y6NTFRok1KRf96VLJYxyTiGIvGcjBhwgScPXsWgwcPltUOe0FuUU6p8BZxVqxYgUePHhVZXrZsWYwcORIXL17EuXPnRDFOKtRqNYYPH46KFSvi2LFjOHv2LCIiItChQwckJyczbuPi4gJ3d3eDP2P4XmRy32QIghDOvHnzAACzZs2S2RKCIIj/oA4vQRAEQRByY+xU1TqFO3bsiPj4eHTu3LnIOu129iDiGMMWiSMmeXl5grYzl06N63FxVP+WvfS9lRCJwwWlzonz4sULs2Uc9TdCiAfvq3/NmjXw9fVFixYtMHv2bFy7dq1Imddff51TXeXLl4ezszNSU1MNlqempsLb25txG29vb5Pltf9NlTl48CB27NiB9evX480338Trr7+On3/+GW5ubli1ahUn2wmCIAiCIAiCIAiCIAhD2NKpZWZmFimrlDlxpLSDLRJHzHlspIrEseV0araMI6ZT4/J7UGo6NS6QiMMdWzifcsBbxDl48CCSk5Px2WefITY2FsHBwahVqxbGjBmDo0eP8vqxlyhRAk2bNkVMTIxuWUFBAWJiYhASEsK4TUhIiEF5ANi/f7+uvL+/P7y9vQ3KPH/+HGfOnNGVycrKAlD0x+/k5GTVmxX9gAmCIAiCIAiCIAiCsCfYRBwmx5xxOXuMxGGqz3g/LU2nJmYkDpuIQ5E4RbEXZ7MSRBwusIk4tnD92YKN+fn5GDhwIH755Re5TSEYEBSHVrZsWXz00UfYuHEjHj9+jJ9++gkvX75Enz59ULFiRfTt2xd//vkn4ygLYyIjI7F06VKsWrUK165dw7Bhw5CZmYkBAwYAAPr27YuoqChd+dGjR2PPnj2YN28erl+/jilTpuD8+fMYMWIEAM2N5/PPP8eMGTOwbds2/PPPP+jbty8qV66MiIgIABohqGzZsujXrx8uXbqEmzdv4ssvv0RCQgLef/99IYdEELbwAyYIgiAIgiAIgiAIguCKsa/DlFPYeJ1cTnF9Oyx1YnPZf5VKJapPyBqROFztJV+X7WErIg6X+4NSrz+l2qXP9u3bsXLlSnz22Wdym0IwUMzSCkqUKIH27dujffv2+Pnnn3H+/Hls27YN06dPx7Vr1/DNN9+Y3L5Hjx549OgRJk2ahJSUFDRp0gR79uxBpUqVAAD37t0zUFpbtGiBdevWYeLEifj6669Rq1YtbN26FQ0bNtSVGTduHDIzMzF06FCkpaXhrbfewp49e+Dq6gpAk8Ztz549mDBhAtq2bYvc3Fw0aNAAf/31FwICAiw9JIKwhR8zQRAEQRD2C/VFCIIgCIIQA7ZIHCaUMidOfn6+gR1iYmuROGznjqtzv6CgAM7OzqLZo2TkjMQR81jJJeLw3QemSBzj+4ac9xFT2MK1/ezZM7lNIEzAW8QZO3YsBg8ejLp16zKuDwoKQlBQEKZNm8Z5JMCIESN0kTTGHD58uMiybt26oVu3bqz1qVQqTJs2DdOmTWMtExQUhL1793KyTyps4QdMEARBEITtoMQXFkJ5UB+UIAhCHBISEnDs2DHcvXsXWVlZqFChAgIDAxESEqIbROqoCBVx+CBmv8fac+JYYrtcc+JwTafmSP0Mqfreckac2JqIY2md1kKpdumjlCgseqdlhnc6tb/++gsNGjRAixYtsGLFCpMp04oXL26RcfaOLfyACYIgCIJwDKizTBAEQRDcWLt2Ld544w3UrFkT48ePx9atW3Hs2DEsW7YM7du3R6VKlfDZZ5/h7t27cpsqC8a+Dj7OfyWkU7PUV8MlnZpxtJIl9QP/ReJs2bIFp06dsqguEnFsAzGPs5CIK7Hb5fLbV+r7ihKvebVajX379iEpKYnzNkoRcQhmeIs4t27dwqFDh1C7dm2MHj0a3t7eGDhwIE6ePCmFfTYF35sJ35sVQRDScPDgQbz//vu4d++e3KYQBEEQBEEQBKFgAgMD8eOPP6J///64e/cukpOTERsbi+PHj+Pq1at4/vw5/vrrLxQUFCAoKAibNm2S22SrYyxQcJ0TRynp1MR2ZHJx8FrqBM7NzcX169fRuXNntGjRgvN2YqVTcyQRJy0tDXv27BGcwk4spBJx9H8L1oTL/lAkDne2bduGsLAwVK1alfM2Sjl25CNnhreIAwAtW7ZEdHQ0UlJSsHDhQty6dQtvvfUW6tWrh7lz5yI1NVVsO+0epfxQCOWiVquxZs0aXL9+XW5T7I533nkHu3btQv/+/eU2hSAIQjaoL+I40Lm2DzIyMrB69Wo8ffpUblMIwqGYNWsWzpw5g88++wy+vr5F1ru4uKB169ZYsmQJrl+/jho1ashgpbywzYnD5JgzFgbsIRLHGHNCiRj15eXlISEhQZS6hETimKtTDqSy4+2330Z4eDjmzZtXZC4Wa2JvkThckDPNnKVY2659+/bxbpcicZSNIBFHS6lSpTBw4EAcO3YMN2/eROfOnTFz5kxUq1ZNLPvsGqXeWAhlsmnTJnz88ceoV6+e3KbYLYmJiXKbQBAEQRAEwYnPPvsM/fr1w/vvvy+3KQThUISFhXEu6+XlhaZNm0pojTJhE3GYsEQ8EdOnoh99oK2Xzzwzjx49Yl3HJZ0an31R4pw45uq0xB6lcfnyZQDAunXrDJbbgu1cULKIwyUSR6nYwvVhCzY6MqJc/ZmZmTh27BiOHDmCZ8+eOeRIEyHQj4Pgw5kzZ+Q2gSAIwiE5evQoOnTogMqVK0OlUmHr1q0myx8+fBgqlarIX0pKikG5xYsXw8/PD66urggODsbZs2cttpVCzwnCcVizZg0A4PTp0zJbQhCOy/Pnzxn/Xrx4gZycHF518ekXXLlyBV26dIGfnx9UKhUWLFhQpMyUKVOK9EXq1q1rUObVq1cYPnw4vLy8ULp0aXTp0kWUzCpc5oRhKqu0OXGGDRumW2bOrtq1axfZnu27FAhN7SVFOjWljOa3xrXkSJE4WVlZorXH1C4XlJpOzZYjhPSRK5UewQ2LRJzjx49j4MCB8PHxwahRo1C7dm0cO3YM165dE8s+h8EWfswEYe+Q85MgCCYyMzMREBCAxYsX89ruxo0bSE5O1v1VrFhRt27Dhg2IjIzE5MmTceHCBQQEBCAsLAwPHz4U23yCIAiCICTC09MTZcuWLfLn6ekJNzc3VK9eHZMnTzbr1ObbL8jKykKNGjUwa9YseHt7s9bboEEDg77I8ePHDdZ/8cUX2L59OzZt2oQjR44gKSkJnTt35n8gGPZH3y/ENZ0aXxFHzPc3JhFn+fLlumXOzs4mt09LS2NdxyaUCPUD2XMkjpj12LKoor22V61ahREjRrBGc4mFORFn7NixKFWqFE6cOCFam8btcsGWxRKl2qWPIwmwtkgxvhskJydj1apViI6Oxs2bN9G8eXPMnz8fPXv2ROnSpaWw0Wbge5HZwg+YUA50EyMIgpCH8PBwhIeH896uYsWK8PT0ZFw3f/58DBkyBAMGDAAALFmyBDt37sSKFSvw1VdfWWIuQRAOgkqlovcJgpCZ6OhoTJgwAf3798cbb7wBADh79ixWrVqFiRMn4tGjR5g7dy5cXFzw9ddfs9bDt1/QrFkzNGvWDABM9huKFSvGKvKkp6dj+fLlWLduHdq2bQsAWLlyJerVq4fTp0+jefPm3A4CA5s3bzb4bupepR9BwuWeJtV9T38EOpMj05yIYwouDnj974mJiRgwYABGjhzJWB/bnDhM5Z4+fQovLy9W2/iIOHwiqsRAzsgsrujbJ4UDXDtvb7t27dCxY0eDddYUcebNmwdAc785duyYaO2y2cCGUiNx2JDid8EVIb8dJR07oii8RRxfX194eXnh448/xqBBg2h+DgvQ/3Eo/cFEEI4A/Q4JghCTJk2aIDs7Gw0bNsSUKVPw5ptvAgBycnIQGxuLqKgoXVknJyeEhobi1KlTrPVlZ2cjOztb9/358+fSGU8QhOKhF22CkJ9Vq1Zh3rx56N69u25Zhw4d0KhRI/z666+IiYlBtWrV8O2337KKOEL7BVy4desWKleuDFdXV4SEhBjMYRwbG4vc3FyEhobqytetWxfVqlXDqVOnGEUcoX0RU/cr4wgSc+9kUt37zM3NY8lcHHxtHj58OPbv34/9+/dz3oYpEufjjz/G2rVrcfjwYbRq1YqzbWyOZ1P7IZWIo3S4pFNTq9WYNGkS/P39MXDgQEHtPH36lLFesZArHZ69z4kjp4gjBKVE4hDM8L76N27ciMTERMydO5cEHAuxhR8woRzoeiEIgrANfHx8sGTJEmzevBmbN2+Gr68vWrdujQsXLgAAHj9+jPz8fFSqVMlgu0qVKhWZN0efmTNnwsPDQ/fn6+sr6X4Q9gv1KQiCIMTh5MmTCAwMLLI8MDBQJ8C89dZbuHfvHmsdQvsF5ggODkZ0dDT27NmDX375BQkJCXj77bfx4sULAEBKSgpKlChRJGrYVLtC+yKmHIP64gOXyAtrROIwpX8TW8QxTqem/9nceecaibN27VoAwJw5c1jr4pOmy5J0akwihJB6lAybvefPn8eMGTMwaNAgznVZO22YrYg4TMdFjjmouGJrIo4t2OjI8H4Kde7cGcWKaQJ44uPjMXHiRPTq1UuXq3X37t24cuWKuFY6APRDEYcjR46gUaNGRXL9EgRBEIS1qFOnDj755BM0bdoULVq0wIoVK9CiRQv88MMPFtUbFRWF9PR03d/9+/dFspggCIIgCCH4+voazJuiZfny5TqB48mTJyhbtqy1TUN4eDi6deuGxo0bIywsDLt27UJaWho2btwouE6hfRFTc+IoRcRhisQpU6aMbpnU6dT4wHdOHFO284nE4ercNy63ePFieHl5Yf78+Zy2N2WbkmE7Pk+ePLGyJfxRgojDRbhSajo1OVNBiomckTiUrco8gocSaJ3lZ86cwf/+9z9kZGQAAC5duoTJkyeLZqA9Yws/YFujdevWuHz5Mt5++225TSFsEHpQEAQhFW+88QZu374NAChfvjycnZ2RmppqUCY1NdXk5MQuLi5wd3c3+DPGkvsY9UsIQj5evnyJw4cPC56YmiAIeZg7dy5++OEHBAQEYPDgwRg8eDCaNGmCBQsW6OaQOHfuHHr06MFah9B+AV88PT1Ru3ZtXX/E29sbOTk5SEtL49wul74IE1zTqSltThx9EUfqdGp8RuyzReKwbSeWiCM0ndqIESMAAGPGjGHdnqttSoNLOjWpkCMSR2yfCaVTUxZKEXEIZgRf/V999RVmzJiB/fv3o0SJErrlbdu2xenTp0Uxzt6hC5TgAwkMBEEQtktcXBx8fHwAACVKlEDTpk0RExOjW19QUICYmBiEhITIZSLhQFjSB83NzaU+rAT06tULbdq0wcSJE+U2hSAIHnz44Ye4fv06wsPD8fTpUzx9+hTh4eG4fv06PvjgAwDAsGHDTEYgWKtfkJGRgfj4eF1/pGnTpihevLhBuzdu3MC9e/dE74/YQjo1OSJxxNwXU4MAtNl0mKA5ccRDTAe48e/A3HmyFK4ijtjnRIx0apbWqUUKAUPOa1hI23Laq3/8hfo/09PT0blzZ/z5559imaUo2O/kZvjnn3+wbt26IssrVqyIx48fW2QUQRAEQRCEUsjIyNCNWgWAhIQExMXFoVy5cqhWrRqioqKQmJiI1atXAwAWLFgAf39/NGjQAK9evcKyZctw8OBB7Nu3T1dHZGQk+vXrh6CgILzxxhtYsGABMjMzMWDAAKvvH0Fw5fHjx/Dz88N7771nUToeoih//fUXAODHH3/E7NmzOW1ja84tgrBX/P39MWvWLIvqMNcv6Nu3L6pUqYKZM2cCAHJycnD16lXd58TERMTFxaF06dJ47bXXAABjx45Fhw4dUL16dSQlJWHy5MlwdnZGr169AAAeHh4YNGgQIiMjUa5cObi7u2PkyJEICQlB8+bNLdofY0zdr3Jycgy+8xFxxBzoyCTi6EcaWSLi8L1fC43EYcPa6dQcRcRRqVScInGk2g97mBOHzQY2pEqn9tlnn+Gvv/7C5cuXRU1/SZE43BHj+Hz77bfYsmULtmzZYhPHmy+CRRxPT08kJyfD39/fYPnFixdRpUoViw2zRfh2IOzxgiIIW4ainQiCYOL8+fNo06aN7ntkZCQAoF+/foiOjkZycrLBhMU5OTkYM2YMEhMTUbJkSTRu3BgHDhwwqKNHjx549OgRJk2ahJSUFDRp0gR79uwpMqkxQUiB0Ofd2rVrkZmZiU2bNolsEaGF+iIEYXukpaXh7NmzePjwYREHWN++fTnVYa5fcO/ePQPnZVJSEgIDA3Xf586di7lz56JVq1Y4fPgwAODBgwfo1asXnjx5ggoVKuCtt97C6dOnUaFCBd12P/zwA5ycnNClSxdkZ2cjLCwMP//8s9BDwQqfdGpyReLop1NjisQRO52acSQOn/3iOycOReJYB3tJp6b/W5AaMSJxxDgOv/zyCwDNfGZjx461uD4ttibiKCUSRyiPHj0SwRLlIljE6dmzJ8aPH49NmzZBpVKhoKAAJ06cwNixYzl3VBwdW/gBEwRBEIStkpCQgGPHjuHu3bvIyspChQoVEBgYiJCQELi6unKup3Xr1iaf2dHR0Qbfx40bh3Hjxpmtd8SIEboc4QRhTagPah+oVCo6lwQhM9u3b0efPn2QkZEBd3d3AwejSqXi5Rsx1S/QCjNa/Pz8zP7+169fb7ZNV1dXLF68GIsXL+ZspxC0tjI5YJUyJ46+A1H7uWTJkrplxhFDQuvWwlUQ4Yo1InG42mVczsnJSZCD1tJzbY1npP41LWUUg1TiBRNKnhNH6jotibhjwtZEHFuPxLH3wVCCRZzvvvsOw4cPh6+vL/Lz81G/fn3k5+ejd+/elMuZI7bwAyYIgiAIW2Pt2rVYuHAhzp8/j0qVKqFy5cpwc3PD06dPER8fD1dXV/Tp0wfjx49H9erV5TaXIAhCEPQuQRDyM2bMGAwcOBDfffedgcOfMESqOXHM3Qe3bt0KLy8vvP3222ZtZIrE8fDw0C3z9vY2WwcbYohT5tJ25ebmsh47sSJxuM6VYlyuePHiyM7OZt2Wj21KQux0amILe3yQK52aGKkGucwfxBUpRSqlX8+AvCKOGHPikIjDQokSJbB06VJMmjQJ//zzDzIyMhAYGIhatWqJaZ/DYAs/ZkJe7P1mpAToGBOE7RMYGIgSJUqgf//+2Lx5M3x9fQ3WZ2dn49SpU1i/fj2CgoLw888/o1u3bjJZKy1cHCEEQSgL+s0ShG2RmJiIUaNGkYBjBq7p1ADx7oMJCQno1KmT2fa1MM2JI5YDlks6NXPlza03jsTRL2ONSBym46elWLFisog41n6mWuoAF3vuJKF1KVnEkbpOS9ImMkEiDnfEOD5inz+lIVjE0eLr61vEQUJwwxZ+wARBEARhS8yaNQthYWGs611cXNC6dWu0bt0a3377Le7cuWM94xQO9UscBzrX9gGlUyMI+QkLC8P58+dRo0YNuU1RNHzSqYk1J879+/d5WCitiCN2OjUuc+Lol+EbicMmyAidE8dU+6awhXRqXNrjagffSAR7E3Gsvc9M2JOII0TEVEokjlDsfTAUrzvprFmzMHr0aLi5uZkte+bMGTx+/Bjvv/++YOPsHb43K8KxoZd06aHfIUHYPmFhYXj69CnKlStntqyXlxe8vLysYJU8UCSOPNy6dQvjx4/H119/jaCgILnNIewY6hsShPy8//77+PLLL3H16lU0atQIxYsXN1j/4YcfymSZspAqnZqY/RymdGpSRuLwLWNuX60RiWPqPJqLxBGCrT3npEynJkZ5rnXJ5cgX+jsxXkaROMKR00bjtrOzs7Flyxa0bdsWFStW5FSHvb/78rqTXr16FdWqVUO3bt3QoUMHBAUFoUKFCgA0D4yrV6/i+PHjWLNmDZKSkrB69WpJjLZHbOHHTBAEQRC2QOXKlREREYFBgwahXbt2cptjVbjk5SakpUOHDrhx4wa2bNlid+fA3l+MlAAdY4KwLYYMGQIAmDZtWpF1KpXKQBhwZLimUxMzEocv+o5r7WexHNt806kJqU/MSByx06kZi5tcsYV+lJjihyOKOFLss5JEHH1s4XpWSiSOSqXC1KlTMXPmTNSoUQPx8fGc6rD3dGq89m716tU4cOAAcnNz0bt3b3h7e6NEiRIoU6YMXFxcEBgYiBUrVqBv3764fv06WrZsKZXdioTvS5etKbKEvNBLPUEQBDeWLl2KR48eoX379vDz88OUKVMobRoL1P8Qn1u3bsltglnovBMEQYhDQUEB6x8JOP9hCyKOlJE4XNKp8amfy5w4OTk5us/WmBPHlAjgKCKOtdO/kYgjPtaKxNm3bx+WLl0qaltioKRInP/9738AgH///ZdzHfbuN+V9dQYEBGDp0qV48uQJYmNjsWnTJixduhR79+5Famoqzp8/j08//RSurq5S2GtXkIhDEARBEOLz8ccfIyYmBrdv30a/fv2watUqvPbaa2jXrh02bNhg8FJrz1DfgiAIgiDkIS0tDYsWLZLbDMXAdU4ctjJMdXFtkyuWzIljzsnIN82WkD6c8XHMzs7WfRY7ndrChQvx22+/GWxD6dTETadmbWc0VxFHbLuUFokj5f7pfw4LC8PQoUNx8eJFUduzFCVF4ggR1EjEYdvQyQlNmjRBx44d0bNnT4SGhqJ8+fJi2mb3kIijHG7duoW9e/fKbQZBEAQhIv7+/pg6dSoSEhKwZ88eVKxYEQMHDoSPjw9GjRolt3mKgPof4mMLLw+2YKOjQueGIGybmJgY9O7dGz4+Ppg8ebLc5igGU45B/cE1XKJT5IrEMbUPNWvWNFk333k8mMqbS5lrHPmlL+KImU4tJSUFn3/+OT755BMD4UisdGq21je1Vjo1qX8L9hSJo6R0auZsSUpKErU9S5FTxDE+VkLOBaVTM2Ljxo0GD9kHDx4YnOSsrCzMmTNHHOsIwkrUrl0b7du3x+nTp+U2hSAIgpCA0NBQrF27Vjdf3+LFi2W2SHqkfskhbBc67wRBEOJx//59TJs2Df7+/nj33XehUqmwZcsWpKSkyG2aYhCaTo1LGjJL22dqi2lOHL7tHjt2DGlpaUXqFlqfuW1NiTimBgjwEQfUajUyMzN135mOGdP29hyJI+bgbONIBGu2LZeIw2YDnzLG9w2lijhMdpmKkpMDOX9zxvcQisQpCu8j0qtXL92DCADq169vkGf+xYsXiIqKEsM2u4cicZTH2bNn5TaBkBF7v+EThKNy9+5dTJkyBf7+/ujRowdef/11rF27Vm6zJIHvCwz1PwiCIAiCP7m5udi0aRPCwsJQp04dxMXF4fvvv4eTkxMmTJiA9u3bC54HxB5RooiTn5+PsLAwfPHFF0XaEmNOnJYtWyIwMNDktnyWm3tXNSXimHLKC0mnZq4eSyJxzNmmNPiKH3yjbbQwnX+pfIq2GIkjlihqbRFHaZEj1jz3T548wbBhw3DmzBkARY8ViThF4X1EuIS3Oip8LxYScZSHkieftPebEUEQhJhkZ2dj3bp1CA0NRc2aNbFy5Ur07dsXt2/fxv79+9GzZ0+5TVQc1BchzEF9EemhY0wQtkGVKlXw008/oUuXLkhMTMT//vc/dO3aVW6zFAuTY3DlypXIz8+3SMThGmHC1Mc5cuQI9u3bhwULFgCwLJ0aG9oBz3zTqZmDbySOKT8H33RqbOXEisSxNT8ZF3u57pMUqcWE1CWXiMO0P/fu3TNIOSbFIDX93weJONY796NHj8aSJUvQvHnzIm0bPwu4orTjKTb2vXc2BN+bTGxsLAYPHozk5GSJLHJM8vLy5DaBkBFynBCEffDZZ5/Bx8cHAwcOhJeXF3bt2oU7d+5g6tSp8PPzk9s8q0GROAQbdN4JgiAsIy8vDyqVCiqVSnHpcJSI9rmj/741cOBA/PbbbwYiDtt25pZxbV8ffZEDMC/iWPLs5OsYNdcWXxFHqkgctnXG5fRFnA8++ABZWVms9pizjQ/W6O/wvUaEijh8zpMQ9Le35uBmU/uQmZmJ6tWro0qVKjqb2PbTknRq+vsr1CfER8CTMvLHUvR/u1JfB1evXjX4TpE45hGWmJIQBUtuuEFBQQCAxMRE7N69W1S7HBklR+IQBEEQ3Dh+/DgmT56Mjz76CF5eXnKbo2jImU8QBEEQ/ElKSsLmzZuxfPlyjB49GuHh4fjoo4/s3oEkFLb+xvHjx62STo2LiKI/oFNsEYfNAc814oVLffn5+QbLrR2JY6qcvoizc+dO/PTTT5zssYV+qrXSqVlSL9/tlRKJoz+vWF5eHpydnSVJp2btSBwp29NHyPNI/9w3adIEly5dsprQRHPimEeQiLN37154eHgA0BzkmJgYXL58GQAM5sshTCPGA8lYuSQsQ8kiji10YAiCIJTA33//bfA9JycHCQkJqFmzpuCJVW0RvqMB7b3TSxC2AP0OCcI2cHV1RZ8+fdCnTx/Ex8dj5cqVGDVqFPLy8vDtt9+if//+aNu2LUXpFMIUiaP9zlfEYaqXa/um0PcFaNuVMhJH7Pd7a0TiGJdlOk5M343nxLl9+7bus5ubG6e2hWCNZ6pS0qlZS8QR+5jyPTZSZBrQF3DtScQRgr69ly9fxpMnT1ChQgXJ2zL+LlTEUdrxFBtBnox+/foZfP/kk08MvtPLBzdsbYSBI2Dc8Tl9+jS8vb0dKv2OI0P3LoKwL7KysjBy5EisWrUKAHDz5k3UqFEDI0eORJUqVfDVV1/JbKH4WJJKgPoihDnoGiEIgihKzZo1MWPGDEybNg179+7F8uXL8cEHH6BMmTJ4/Pix3OYpAlNOYakiccz5W4yXSTEnjqn2TS1nwlwfzzg1vBSROGzp1EylWQOKijiJiYm6z8YDrKQSJqyBpZE4+turVCpeEVm2GonDZgPAfM1bKpQxIYaowsWXZAsijlzn3rjtgoICQf45e/fp8b5aCgoKzP4pOZpBqQi94dLLtLjoX7vXr19HSEgI/P39ZbToP+z9ZkQQBCE2UVFRuHTpEg4fPgxXV1fd8tDQUGzYsEFGy5QD9SMIQllQf48gbIN///23yDInJyeEh4fjzz//xIMHD/D111/LYJkyKSgoQFRUFFJTU4usMxZx9OEivnCBSz1ypFMzV0YfcyKOqUgcqdOpmRNxjIWaBw8ecLLHFvqpfO3lE4mjRBFH7HPCNV0fW9QXl3rMYe10avr3GqVFa1rzNydFJI6996OVJfk5GLb2cHIE9G/esbGxMlpCEARBWMrWrVuxaNEivPXWWwYdugYNGiA+Pl5Gy6yDFOkGCPMIfXlYuXIlOnbsiMzMTJEtEg97fzEiCILgSuPGjdGwYUN8/fXXOHPmTJH1FSpUQGRkpAyWKZO9e/di1qxZjOv0RRwAvCJxuPZjuIwuNxeJY810akLaslY6Nabzw5ZmTYtxJI6+iGPOkat0pEynxkfEsRS5InG4HhtzIo4lSBmIYGvp1JQSiaMEEeeLL77AlClTRKtPDHgfkZs3b+Ls2bMGy2JiYtCmTRu88cYb+O6770Qzztbge7HY2sPJEVDyzZSQHnJOEYR98ejRI1SsWLHI8szMTPq9F0L9D/ERem0NHDgQ27Ztw8KFC0W2qCh03gmCICzj8ePHmDlzJh4+fIiOHTvCx8cHQ4YMwfbt2/Hq1Su5zVMc+hOU66NSqZCTk6P7zjedmpDUamzL9EfHMzmMpU6nxme/uETi6ItjYqZTY1rHNxLn2bNnrGWt5Sd7/vw5fvvtNzx69MiierhcI0KvUyVG4lhzThw50qlJGWnE1J7S/I62Hokj1vFMSEjAggULMHXqVFmFLWN479348eOxY8cO3feEhAR06NABJUqUQEhICGbOnIkFCxaIaaNNwvfCp5dpZaDkmylBEATBj6CgIOzcuVP3XfsisGzZMoSEhMhlltWgvohtQvMnODYkMBOEbeDq6ooOHTpg2bJlSE5OxubNm+Hl5YXx48ejfPnyiIiIwIoVKyx2ENsLpvoYlsyJwzWqgYuII2UkDpf2La3PWKjRH3wtZiQOUzm+c+KYQsgxj42NRffu3XlF2o8YMQKffPIJQkNDMXToUKxevZrztvrIkU4tPT2dt+DDxy65InFMYSoSR61WW/RbZRJwxcJcOjWl9fsoEkfDy5cvRalHbHgfkfPnzyM8PFz3fe3atahduzb27t2LhQsXYsGCBYiOjhbTRruFnCXKQ8k3U0J66JwThH3x3Xff4euvv8awYcOQl5eHhQsX4t1338XKlSvx7bffym2eJJjLl26MpalBrl+/Tv0ZkaG5JQmCIGwLlUqFFi1aYNasWbh69SouXryIt99+G9HR0ahatSoWL14st4myY8oxaCzi8BFfxIrEUavVdpdO7aeffmJdZ64tviKOOUHB1LwfYkTiBAUFYdOmTejcuTOn8oAm7TIA/P3331i6dCn69evHeVstKpVKsnRqxr8FLefOnYOnpyf69OkjWdSSI6dTE1o/n3MvZeSPpZgTZMXE1G+/oKBAkH9OCp+eks4RbxHn8ePHqFq1qu77oUOH0KFDB9331q1b486dO6IYZ8vwdZwo6aJwZPRvpkpz6CvNHoIgCKXz1ltvIS4uDnl5eWjUqBH27duHihUr4tSpU2jatKnc5ikC/f4H3+fMyJEjUa9ePYdOpSsF1hBxqN9JEARhGTt27GB1dNaqVQtjxozB0aNHkZSUhHfffdfK1ikPtmOlUqkM5oIzdlxLOSeOcT36AzqZxAlrplNjwtxAHVP9B7EicYwdq9p6LXH8iiHiaLl58ybnsqVKleJVNxt8rxEuQoW2HFN9c+bMAQD88ccfovoU5YrEYbMBYJ4fS4zfkjH6vx1rROLYkohjTZSUTs1cRKhc8N67cuXKITk5GYBmR86fP4/mzZvr1ufk5CjuIlQqJOIoD0qnRhAEYV/UrFkTS5cuxdmzZ3H16lWsWbMGjRo1ktssqyB1JM7PP/8MAJg4caLgOoii6DuRlAYNKJEeOsYEYRtERETA19cXEyZMwO3bt1nLeXl5oVatWla0TJmYmiskKyuryDJT24kViWNsH5MjV650auba4iviiBmJw7TOnIjDxwlqLT+ZFCKOmOnU2CJxLGmba11KicRhsklqEUfsa45EHHZM3SeEijgUiWNE69atMX36dNy/fx8LFixAQUEBWrdurVt/9epV+Pn5iWiibcL3JCvponBkhETi5ObmKtrhQnCHHCcEYfvoj+aUorw9Q30RZWDsaDGeRJggCIKQn4SEBHzyySdYv3496tSpg1atWuH3339XbB59uWF7jhkfL76ROJa0b9yOHOnUmOrPyclhrINLJA6bjV7PnwMcnN9My4w/GztagaL7xycyR8xIHD7v86VLl+ZVNxdMiZVMn82VEyLmCUWJIo6+HXzSqfE9LkxReGLBtH9SzsFjKXK+cxgfK0vTqYm1L0p6D+Mt4nz77be4fv06qlevjvHjx2POnDkGCvbvv/+Otm3bimqkLcL3xqKki8KR4TsnTl5eHqpUqQI/Pz/F3XwJgiAckddeew2zZs3SRQ0zoVarsX//foSHh+PHH3+0onXWRepIHEIa9J1IOTk5qFu3Ltq3by+jRQRBEIQxvr6+mDRpEuLj43HgwAH4+flh2LBh8PHxwaeffopz587JbaKiYHtXNh5MwyZsGJcxtZ4JLvXIkU7NmG+//RYuLi64du0a7zbYRJwxAH7csQP4/XfOtrHZazywhM2xbu4717JiRpcYI0YkDtc5cbjaxCXqyVR5SzA+rydPnkRqaqpFdfJtV6iIw0XwMgWlU/sPOefEESMSR38bexRxivHdwM/PD9euXcOVK1dQoUIFVK5c2WD91KlTDebMcSRMOf3j4uIwa9YszJgxA6+99hoAcS4EJV1M9gDfSJwHDx7g0aNHADQd0DJlykhmG0EQBGGew4cP4+uvv8aUKVMQEBCAoKAgVK5cGa6urnj27BmuXr2KU6dOoVixYoiKisInn3wit8mSQSKObaLfFzl79ixu3bqFW7duyWgRYU0oKpggbI82bdqgTZs2WLRoEdavX4/o6Gg0b94cDRs2xKVLl+Q2TxEIFXEsSafGpx6pI3G4CCVqtZpzilo+kTiB2g+F12JaWhp2796Njh07omTJkrwjcZjWmXP88jl21hrsLDR9/rJlywy+W0vEsaRevtsfOnQIw4YNg5OTU5EIcbH7KaaOHx8R1ZLrxlqiCok4pjE+35ZG4uTn5wv+nSs16IK3iAMAxYoVQ0BAAOM6tuWOhvFJbtq0KQoKCvD333/j6tWrZssT8qB/w+LyY9c/b/TSbfvQOSQI26dOnTrYvHkz7t27h02bNuHYsWM4efIkXr58ifLlyyMwMBBLly5FeHg4nJ2d5TZXdpTaQXVkhKR25Quda4IgCPEpU6YM3nnnHdy9exfXr19nfO93VK5cucK4nCmt7fPnz3Wf+ThuLSmnVqs5iTgPHz5E6dKlUbJkSV42cEmnZg6h6dQqaj+kpQEAOnTogOPHj2Py5MmYMmWK7CKOJYKPUGbNmoXjx48L2nbIkCEG37kIDUKER7XaMHUdU59QqkicPXv2ALB+qi+hkThCIqL0sfacOFKmb7MUa/4eja9psefEEev6VdI54i3iTJs2jVO5SZMm8TbGntFePNevX9ctI8eJ8tC/eRuH4Zl7aNq7APDq1StkZWWhXLlycptCEARhlmrVqmHMmDEYM2aM3KbIBvUtbBO+qV0JgiAIeXn58iU2bdqEFStW4NixY/D390dkZCT69+8vt2mK58KFCwbft2zZYvBdrEgcc32igoICg+fvjz/+iICAAIPtsrKyUKlSJZQrVw5PnjzhXDcAq8yha1bEefYMAHTixaZNm3iLOAUFBZwc62KJOFL1ZaOiokSrS8xIHGMnNhfxkU/bQu2SEj7Hw1x5oYiRTo2tz850jigSh7lu42NlaTo1exRxeB+RKVOm4LfffsPWrVuxZcsWxr+tW7dKYKptwffmLfSioJd7cWFznLCdH0cScapUqQIvLy88fvxYblMkwxbPYVZWFqZOnUqpGghCQo4ePYoOHTqgcuXKUKlUZvs5//vf/9CuXTtUqFAB7u7uCAkJwd69ew3KTJkyBSqVyuCvbt26FtvK9z7mSM8xa2HpcbRGJI5QlGaPPULHmCBsh9OnT2Po0KG6eXCqVq2KAwcO4Pbt25gwYQKqVKnCq77FixfDz88Prq6uCA4OxtmzZ1nLXrlyBV26dIGfnx9UKhUWLFhQpMzMmTPRrFkzlClTBhUrVkRERARu3LhhUKZ169ZF+iOffvopL7ulhI/AYAyTA5itHuN0avv27cMbb7zBuN3Tp0/N2mhMbm6uyfa51mOqLBcRJzExUbe8cePGrHVZGoljiSPYEj+Z1M9QLteRkDqY1rEda1PlLUGudwJT+8B0bLn45rgeiwMHDqBXr15ISUnhvS1XbE3EMRUNJTViR+IYpwIUipLOEe8jEh4ejidPnqBatWqYOnUqYmNjcfHiRYM/49EUBDNi3HCVdDHZA2yOE0vDYu0BbWf11KlTMltC6DN9+nRMmTIFTZo0kdsUglAM9evXN3jB/uyzzwwE6IcPHxqkwTBHZmYmAgICsHjxYk7ljx49inbt2mHXrl2IjY1FmzZt0KFDB1y8eNGgXIMGDZCcnKz7E5rWgQ1LRwMS8sAWFSzmSxSdd4IgCMuoX78+3nzzTVy4cAEzZ85EcnIy1qxZgzZt2giqb8OGDYiMjMTkyZNx4cIFBAQEICwsDA8fPmQsn5WVhRo1amDWrFnw9vZmLHPkyBEMHz4cp0+fxv79+5Gbm4t33323SAqzIUOGGPRH5syZI2gfpMBcJI4pzDnXjd/ljR1+ycnJovWlmEQcrtty3S4vL6/IchWACtovz57hWWE0DmB+onimzwUFBZxEHKVH4gilU6dORZZxsVdo9BifSBxLUUIkjikBoU2bNozXuHY7IddNu3btsH79eowePZr3tkw2cF2u5HRqSorEsXROHHuMxOGdTm3nzp1ISkrCqlWr8OWXX+KTTz5B3759MXDgQNSpU0cKG20SvidZSReFI2OJiCOUzMxMFC9eHCVKlDBZTikjM+laVRYkmhNEUa5fv27QOV6zZg3Gjh2L8uXLA9Dcx169esW5vvDwcISHh3Mubzwa9rvvvsNff/2F7du3IzBQN70sihUrxup4EQPqi9gm+teusYgjdHJOgiAIQlxCQ0Pxxx9/iDYn8Pz58zFkyBAMGDAAALBkyRLs3LkTK1aswFdffVWkfLNmzdCsWTMAYFwP/DevhZbo6GhUrFgRsbGxaNmypW55yZIlJe2PWAKb+DITwEcAFmdkcNqWSwQFU8ozLn0jLo5CLnWba4vLnDjGtpSFntPv2TOD7bRzD0kRiWOvIs5ff/1VZBlfey0VcUydG1uEq4hz9+5d7Nu3T5L9vHv3LmObYmBpJM61a9ewceNGfPHFF3B3dxfVNiasKeKYalvoe48UA+CsPTeUKQS9CVauXBlRUVG4ceMGNmzYgIcPH6JZs2Z488038fLlS7FttBn4pt+S4seQmJiI1q1bY/PmzaLX7QhYOxInKysLpUuX5h1qT0iDUoQygiDEhen+bM3fe0FBAV68eFFkTrFbt26hcuXKqFGjBvr06YN79+6ZrCc7OxvPnz83+LMUW33hs2fYUruaeoHIy8tDdna2pHYBdL1YA+qLEIRtoJ0zBdDcgw8cOIBff/0VL168AAAkJSUhw4TAoE9OTg5iY2MRGhqqW+bk5ITQ0FBRsyCkp6cDQJH+yNq1a1G+fHk0bNgQUVFRyMrKYq1Dir6IKdhEnH4AqgKoc/8+67bm3tVdHz3Cx9CIHEyROGzbCSmTm5uLmgBcjbYT87nKlE6tov6XZ88Mjqf2euArFAiZE4ePE5Svj2X37t2c65YasdOpCT1uQlBiJI7xd7ZIHHP1CLVHDCwVcerXr48pU6Zg7NixotrFhpIicSidWlEsHs7XrFkztGnTBvXq1cPFixdZw0SJohhfoLm5uYiJiTHZaTLHiBEjcOTIEXTt2lUMEx0OU6NfmbD0QXHlyhUAsKl5ZpR0AxMbe943giDkY+7cucjIyED37t11y4KDgxEdHY09e/bgl19+QUJCAt5++22d84eJmTNnwsPDQ/fn6+trsl2xHA8EP6SaE8dUX6RmzZooX748cnJyLGqbIAiC4Mfdu3fRqFEjdOzYEcOHD8ejR48AALNnz+bsdHv8+DHy8/NRqVIlg+WVKlUymKvBEgoKCvD555/jzTffRMOGDXXLe/fujTVr1uDQoUOIiorC77//jo8++oi1Hr59EUv5/fffiwxQVT19Cp/Cz5XS0li3NReJ02T1aqwG0BmaZy+Tw89Sp7yWyteu4SaA+WZLssMlEsekiPPiBQr0+glCRBwlplN77733zJaREi72ct0nLseN7TqwVRHHlA3G15WTk5PkIo7SInG0nDlzRlS72FBKJI5QEUefAwcOiKJRKOG3oUXwETl16hSGDBkCb29v/PTTT+jXrx+SkpKsEt5lCwhJYTJp0iSEhoaiS5cugtt98uSJ4G0JmhOHsD1oxC5BFEU7Ma/xMjlYt24dpk6dio0bN6Jixf9epcPDw9GtWzc0btwYYWFh2LVrF9LS0rBx40bWuqKiopCenq77u29i9CkTly5dQvv27REbG6tbRs8u5cE2Jw7baDK1Wo179+4hIyMDt2/fltQ2euYQBEEYMnr0aAQFBeHZs2dwc3PTLe/UqRNiYmJktMyQ4cOH4/Lly1i/fr3B8qFDhyIsLAyNGjVCnz59sHr1amzZsgXx8fGM9VjaF+HLrFmz0LVrV4NnYIlbt3SfK5oQcYzFB2PKJCUBABrB9DPWHFycvg3On4cTgGATdfPpkwkScQA46UVOCY3EUZqIo4+U/RRLxAOu+2HsxDZXtxwijtjHmGs6NW3bUg9Ss0Ykjv7gcSWl6gIsuy+ZqrNr164YMWIE57bEEHF69uyJadOmWVSH1halwHtOnDlz5iA6OhqPHz9Gnz59cOzYMTRu3FgK2+we4wv0559/BlA0dy3XOgjLEeI4Yfpsz9jzfpJziiDsA7VajXfeeQfFimm6OS9fvkSHDh10c48x5SWXgvXr12Pw4MHYtGmTQYoUJjw9PVG7dm2TTngXFxe4uLhwbt/4ft22bVs8ffoUBw8epIgNBcN3QIn+cnqO2T50DgnCtjh27BhOnjxZZH5TPz8/JCYmcqqjfPnycHZ2RmpqqsHy1NRUUeaqGTFiBHbs2IGjR4+iatWqJssGB2tkhtu3b6NmzZpF1pvri3Tp0kVQavdvvvkG06dPZ11fUFAAZ2dnAECJmzd1y70tiMQpWZgNoybAOlpbFIdxbi5eu3EDAHQRRNrtxHy35iviiDEnDls6NUtG88vtY7l06RKOHTuGYcOG6a45gNvAXi59Na6CllJFHDHPyf379zF37lzWus3ts/4yseyyhogjJBJHCEL6lFJE4vzzzz+658KiRYs4ta1WqwXZb2zvr7/+avLZIqROOeEt4nz11VeoVq0aunfvDpVKhejoaMZy8+dbEihq+/B92CvponBkKBKHIAjC9pk8ebLB944dOxYpY0nUKxf++OMPDBw4EOvXr8f7779vtnxGRgbi4+Px8ccfW9SuqVQbT58+BWDoqKDnmPKwpC/CFVs914mJiXjw4IHOyUgQBCE3BQUFjAP+Hjx4gDJlynCqo0SJEmjatCliYmIQERGhqzcmJqbIyGU+qNVqjBw5Elu2bMHhw4fh7+9vdpu4uDgAgI+Pj+mCLBQvXlzQNuZs039uldAb8FIxPR3IzwecnTFu3DjWbbSfX716hRMnTuCtRo3gUjifs6UijtlzdPw4Sr56pbEXmnQ4TE90q0TiFEbfAMCLFy8YtzGu31ikYBIklBKJIwZNmjQBALi6umLw4MG65ZYM7GUqw+SktkTEsRQ5jnWLFi3w4MEDVhuUlk4tOzsbd+/eRe3atQXVbW0RRwhSiDhsgwdN/fYLCgpMRuLk5+cbiKxsdXJ9DptCSeeId2xSy5Yt4e/vjytXruDixYuMf9oHP1cWL14MPz8/uLq6Ijg4GGfPnjVZftOmTahbty5cXV3RqFEj7Nq1y2C9Wq1JTebj4wM3NzeEhobill7IrZadO3ciODgYbm5uKFu2rK7DJBdijLxT0sVli7BF4ojpOLF17HmEqD3vG0E4EpMnT+b0x5WMjAzExcXp+jcJCQmIi4vDvXv3AGhSi/Tt21dXft26dejbty/mzZuH4OBgpKSkICUlRZe2AgDGjh2LI0eO4M6dOzh58iQ6deoEZ2dn9OrVS5yDwBG5X5SJovCdn0+uSBw5rpeqVauiefPmuHjxotXbJth58eIFunbtik2bNsltCkFYnXfffRcLFizQfVepVMjIyMDkyZN5zdURGRmJpUuXYtWqVbh27RqGDRuGzMxMDBgwAADQt29fREVF6crn5OTo+iY5OTlITExEXFycQUTv8OHDsWbNGqxbtw5lypTR9UdeFooX8fHxmD59OmJjY3Hnzh1s27YNffv2RcuWLXlnW3EC8AuALleugOlJ1AhAabZtnZzMPr/0n3Uuer6d4gUFwJ07AIDvv/+edRvtM2vQoEEIDQ3FzM8+060TIuL8/fffAICHDx+yDmzWsXWr7qMz/hNWLEkVJlTEcdaLxAE0fVxLInHEEHG4ts0FMftBxn5JLiIO18G/P/74I6pWrVrET8k36kmqSBxTx1HMY6wv4DChtHRqrVu3Rp06dbBjxw5B9Wk/6/f1lfb+ZXzMpZwjyFTbajV7OrUZM2bAw8NDN8e4qfqNRZwxY8YgJCTEbFYKpb4j8xZxDh8+jEOHDpn8O3jwIOf6NmzYgMjISEyePBkXLlxAQEAAwsLC8PDhQ8byJ0+eRK9evTBo0CBcvHgRERERiIiIwOXLl3Vl5syZgx9//BFLlizBmTNnUKpUKYSFheFV4egHANi8eTM+/vhjDBgwAJcuXcKJEyfQu3dvvoeDFWtF4phS7glD7t27h+joaJM/VorEMY+j7CdBEPbHkSNHsGvXLjx79ozXdufPn0dgYCACAwMBaBwtgYGBmDRpEgAgOTlZJ+gAwG+//Ya8vDwMHz4cPj4+ur/Ro0fryjx48AC9evVCnTp10L17d3h5eeH06dOoUKGCCHuqgaKCbRNbSacm5/Vy4sQJ2dqWGlscUDJ79mxs3rwZ3bt3l9sUgrA68+bNw4kTJ1C/fn28evUKvXv31qVSmz17Nud6evTogblz52LSpElo0qQJ4uLisGfPHlSqVAmA5l02OTlZVz4pKUnXN0lOTsbcuXMRGBhoEDnwyy+/ID09Ha1btzboj2zYsAGAJgLowIEDePfdd1G3bl2MGTMGXbp0wfbt23kfh3cBfAqg6z//YAU0YgUAFIdG3PkbwB8M26kAtFWrUYyrQ02t1ok4L7UrC1OVsW6D/56V69atAwCc1Uv55gUgvzC1mqk69AkICEBWVhZevHhh0m4AwF9/GXzVxjjxTQGVkZGBWbNmsfYHXr16VWSOZONepX4kDqBxJtuTiCMmS5cuRUJCgu67JZE4xs7p0aNHIykpyeDdgKkurmnYuKw3hxKOu7lIHFMijv7ypML5rsSwQZ/Tp08DAJYtWyaoPkeNxGGr31wUHttgtm+++QaZmZkYO3ZskfrNiTjz58/H6dOn8ZfRfdlUPUo6R7zTqXHh/PnzCAoK4lR2/vz5GDJkiG6EyZIlS7Bz506sWLECX331VZHyCxcuRPv27fHll18CAKZPn479+/dj0aJFWLJkCdRqNRYsWICJEyfq0qesXr0alSpVwtatW9GzZ0/k5eVh9OjR+P777zFo0CBd3fXr17dov82NjDBGjItCSReT0qlduzays7ORnJxsMIpJH7YHszVEHKZwWoIgCII/s2fPRkZGhi7/rVqtRnh4OPbt2wcAqFixImJiYtCgQQNO9bVu3drkPd54BObhw4fN1mk8sbASELNPkZaWBg8PD4d8rlm6z2wiDpc+Cte2jc/1qVOnAAAhISGc7aQ+KKHFeB4PgnAkqlatikuXLmHDhg24dOkSMjIyMGjQIPTp0wdubm686hoxYgRrai7jvoWfn5/FTl1fX18cOXKEl41s9ND73B+aqJtIAOsAvFW4/AMA1QHc1Sv7FYDvcnJw2YxDTfesS01FsfR05AM4AKADAFy/DjBEPZlyFlYzKutUGM1jjKljmJ6erotqYqMxANy9i5xixRCfl4d60Ig4TPGkXJ6rUVFRqFq1Kl5//fUi61JSUjBy5EiDZdpInAJoRnAbR+IISaem/z0vLw9fffUVPD09Te4Ll2tV24dRkvN00KBBukHqYqdTY6qTi2DG5ncUU8TRx1xaKzExd92wiTjGy9u2bSv4eHCJPOFzPGxNxDF1TYqB/vxmTOv02zV+D+Jy3M2JOFrMzZGrpPuQPoJ/iRkZGUUeWHFxcejQoQPnPNU5OTmIjY01mOzXyckJoaGhupdJY06dOlVkcuCwsDBd+YSEBKSkpBiU8fDwQHBwsK7MhQsXkJiYCCcnJwQGBsLHxwfh4eEG0TzGZGdn4/nz5wZ/lqLUi8Jeyc7OBgAcOHCAtQxbWKNUIg5f4U8J2IqdQrBFZ6Mt2kwQUrNhwwY0bNhQ9/3PP//E0aNHcezYMTx+/BhBQUGYOnWqjBZaB7kicS5cuICyZctKPu+QvcJ3QImlkThZWVlo0aIFWrRogaysLJNlldJvsee+iC1CfRHC0SlWrBj69OmDOXPm4Oeff8bgwYN5Czi2jlZC+V9gILIBdAXwLzQCThqAa4Xr++ltUxyAVnKoeumSyfp1z7pCn008gDjtSg6ROOZEnGICRByVSmVWxIko/H+1alXEF34WGomj5caNG5y304o4SSVKACgq4nCJxDFert/v2LBhA2bPnl1kkKy5iApT7fGJPpEa/QxBTP0z4+efpX4j4303t501RBy2fqkUCI3EEfM64VIXn34P0zmSM53agQMH0K9fP6SlpTGut4aIw4apSBwuvz/jOgDhc+Jw8QfLAW8R5/79+wgJCYGHhwc8PDwQGRmJrKws9O3bF8HBwShVqhROnjzJqa7Hjx8jPz9fFyKspVKlSkhJSWHcJiUlxWR57X9TZf79918AwJQpUzBx4kTs2LEDZcuWRevWrXWT/hozc+ZM3T57eHjA19fX5L7xvdDFisKQ+yFnC5g6zmyKuLUicUxBL8gEQRDcSEhIMMjlvmvXLnTt2hVvvvkmypUrh4kTJ7IOFrF1hPQ/9Hn48CEGDRqkSxcgBO3cAFu2bBFchyPDd0CJ/nIhIyX1U8FkZmZy3o76nNJA/T2CUD58npFZWVmMefvtDVcAlwHsCAjA+wAyoUn7chVAMwDTC8sNAHRz5nTBf4KGZ2IiypmoX/fMKRRxLgPQSTcsIg6fSJziemlxGdtlgIuI07Hw/4WqVaFNhleZpW6uz1U+4o9WxLnDIuLwjcQxbvvmzZuM7VqSkklJg51dXFx0n8VMp8aGqWPN1A+0xvExjliQsp8iVMRh2lYoUkbiaBESiSPWcW/Xrh1Wr16Nr7/+mnG9NUUcU+fbWMThKqQY1+nu7i7ETEXdh/Th/ab35Zdf4tWrV1i4cCHeeustLFy4EK1atYK7uzvi4+Oxfv16zpE4cqE9+RMmTECXLl3QtGlTrFy5EiqVinVCzqioKKSnp+v+7t+/b7EdSr0oHBm2B7MlD2yu2Mo1YCt2EgThuOTl5Rm8dJ06dQotWrTQfa9cuTIes+Q+tyeEROJ89tlnWLFiBa+0WoS4WDsSRyjUHyC00LVAOBoff/wxwsLCsGnTJlbx++rVq/j6669Rs2ZNxMbGWtlCeVgDQOXkhBgALaBJpxYM4DaALdBE5PgBaFNY3jhx3Jsm6tY96woFsSsArmtXXr/OtIlJB7hWxLla+L8Ei3/HEhGnGoDXAcDJCbE+PjoRx4d1C25wdWYWB3TCWIJWxMnIMCjDd04c43RqGUb1MW3D9J1re3yfL2L3g0oUHjeAm0/I0sG/pkQc7WexjhVXG6V26puq2/i7NUQcbT2bNm3C559/znje5UinJvZxv3v3LuNypUTiGKfx4xoRJkUkjpL6ubznxDl69Cj+97//oXnz5ujevTu8vb3Rp08ffP7557wbL1++PJydnYvkUU5NTYW3tzfjNt7e3ibLa/+npqbCx8fHoEyTJk0AQLdcfw4cFxcX1KhRw2BiYn1cXFwMHELm4Os4EQslXVzGpKamwt3dXfbQcqkicYSg5PPliNDoV4KwD2rWrImjR4/qnus3b95Ey5YtdesfPHgALy8vGS2UDks6nGq1GjdYRrMKtYHgD1tfRMw5cdgQOlKWEA/qixCE8rl69Sp++eUXTJw4Eb1790bt2rVRuXJluLq64tmzZ7h+/ToyMjLQqVMn7Nu3D40aNZLbZKuwFkD7Qqfb34V/Wl4B+APAMGiicZ5BI9rkADhUvDjCcnPxFoDtLHUbp1O7DEAXA5KaCjCkBjI14lubV+UggPoAXB88YGzXnMPdlIjzofbDm2/iqbMztNawpVMTOxKnfOH/PAB3i2lcf8VEjsRhEzGlFnEuXrwILy8vVKtmHFMlLnxFHC4CAx8Rx1wEj1Qijv6+mps7REwsicRhqktIn0pbf/fu3QFo5ovs0aOHQRlL06kpeU4c4/Mthn1svlU+kThCRRxXV1detrLZohR4R+KkpqbC398fgGZi4JIlSyI8PFxQ4yVKlEDTpk0RExOjW1ZQUICYmBjWEaAhISEG5QFg//79uvL+/v7w9vY2KPP8+XOcOXNGV6Zp06ZwcXExcFTk5ubizp07qF69uqB9sRShF4WSLiZT3L9/H97e3qhRo4bcppi84Vp7Thy2upSMrdhJEITjMnz4cIwYMQKDBg1CeHg4QkJCDAZuHDx4EIGBgTJaqByUOsrIkeE7oMRSEUeoaCDn9ULXKkEQclK8eHGMGjUKN27cwKlTpzBkyBA0bNgQVapUQevWrfHrr78iKSkJf/zxh8MIOEcBPIDpEeorC/93ATCh8PMmANsLnWxvm6hfrVYDarUuEucygBcAnmkHiDIMQmHr4zgBqFr4+VDhf9ekJPZ2Tdhkai65D7QfOnZEXl5ekUgcoc8y42gYNrSp1B4BeFb4rC+ml0IV0Pg/zKXpMiUsiCXicGlbS0JCAl5//XWr+O74ijh37txB27ZtsWPHDoMyYqRT035m67dJJeK8/vrrjCkkrTEo3ZJ0apb8vvTRnxdJ3w6uMJ1Dfb+jteZb4Xo8jK9zse3jMyeO/nEWKuIIjdxS6jsy70gcwPDB7OTkZHBj40tkZCT69euHoKAgvPHGG1iwYAEyMzMxYMAAAEDfvn1RpUoVzJw5EwAwevRotGrVCvPmzcP777+P9evX4/z58/jtt98AaH5Mn3/+OWbMmIFatWrB398f33zzDSpXroyIiAgAmpx4n376KSZPngxfX19Ur14d33//PQCgW7dugvdFH76ROEq6KKRg7969AMA615E1sdU5ceREybaJCY1+JQj7YMiQIXB2dsb27dvRsmVLTJ482WB9UlISBg4cKJN11oP6IsrEOD2AMZaIOFwRe1Qd4dhQ/4lwZIKCghAUFCS3GbKzofC/qefbOWjEl4bQCDkAsAhAvosL8OIFggC4AWCKbSkoKADu3wdevIC6WDHcKnSCJru7o+zLl8i8cKHINjNmzNB91n9meUOTaqzAyQnHC5+hbk+ewBWaiCF9TD3rCgoKWEUMFQDdsOTQUOQeO2b1dGpaEechgDStiGOU/oxvJI6xgMS2/3znxOETiRMXF8daj9zp1EaM0CQJPHToEO/oIqZy5vqBTOXv3LkDPz8/3sdCv67c3Fzd54SEBLz99n8Sq0qlwsiRI7F161b8/fffKFu2LK92hNqkbZvtehVLxDHejumeJkc6Ne35TE5OhpeXF28/PNfIJCkicfSx9pw4YlwHSnrn4R2Jo1arUbt2bZQrVw7lypVDRkYGAgMDdd+1f1zp0aMH5s6di0mTJqFJkyaIi4vDnj17UKlSJQDAvXv3kJycrCvfokULrFu3Dr/99hsCAgLw559/YuvWrWjYsKGuzLhx4zBy5EgMHToUzZo1Q0ZGBvbs2WMQRvX999+jZ8+e+Pjjj9GsWTPcvXsXBw8etOgGpP+DEOI4EeOBo6SLSx+l2mWMJY4TIfvI95qxpC1LsJXz54iQ44QgmBk4cCC2bNmCX375pUiK1p9//hmdOnWSyTJp4Xu/dqS+iBJYunQpvLy8cPbsWdYyfKOCLe2L6G9j7vwL7beIjT1fY/RcJwjbgGl0tj55eXkm7/X2xrbC/+acmyv1PscCOA3gvrMzssqVQ3Fo5tBhoqCgQJdKLaF4cWhdzMmFk1Yv+OyzItvoZ17Rf1ZqE3BluLvjIYD0wu/+DO2q1Wq8DiABQE+GdWyROHUBuAPIBIAGDZCbm6sTcbS9UrZIC3MwOayZMIjEKSzPFInDR8QxblvqOXHkhq+IwwbX/TMlfnE5Tz/88ANq1KiByMhIszaZqst4X40d+4sWLcKDBw+wbNky3u1wtQGwPJ2aGDZYKuIw1S10TpwrV66gcuXKaNq0KadthPTbpZgTh8v7jHE543aZfn9MfWau9x5z/W2l3pN4R+KsXLnSfCGejBgxQqdYG3P48OEiy7p162YyYkalUmHatGmYNm0aa5nixYtj7ty5mDt3Lm97xUKMi8JWXvSUdNGbgi3fp1SOE334ijjWPPfWCvEkCIIgxEOIoGMr/QpbZejQoQCAPn364NatW4xl5Eztygdb6dsRBEFIgY+PD5KTk1GxosZV3qhRI+zatQu+vprZVp48eYKQkBDOKWBsHe1MK+b6EWsAzIImEuanwmVOzs54VKMGqp86hbcBHGbYTq1W60Scc3rz0CQVijh1zdin/8zSijjPPT2BtDTcBtAUwGsArjFsNxSAH4AvAazXW2cqEueNwv/nAbQqVgx5eXnQ5iQpAcCSmRn5plPTj8QpbiS68BVxpIrE4dK2HOiLOGy+Ii42iplOzdTxGTNmDABgwYIF+OGHH8zaxda2XFgi4pjblivG2x08eBBvv/22QeAAk4jDxS7tZ7a+vjnWr9fcgS4X3gv5wLUdpcyJY3yvoXRqGniLOP369eNV/o8//sCHH36IUqVK8W3KprFkJKw1trM2SrLTVMfSVGeFCTHFDVuJxFHSuRQbcl4ShH3g7OzMqZw9Olb43q+luKfb83OCC1yeJVxTu3JZbs10ao7SHyAIgjCH8T3wzp07BimImMo4AuZGqD8E8AWARgD+0Nvmcb16OhGHiYKCAoP5cLQklSkDAKhjxi4mESfdwwMAEA+NiFOTZbs2hZ9fhyaKRivGcBFxzgJoBU16qlxoomIqQJNS7fLjx9i/fz+jjVz3xRT6Is5TbSROZiZUALQ1BAUFoXjx4ibbMCUsyJFOTcrflXHdXCJxhNTLpZxarTYr/ojZL1PC/cqcA56rAGauLB8b/vzzT/z5558Gyy2dE0doOjVL/FVcj4+SInHEEHGE+myV+s4jaE4cPnzyyScIDg5WxIT2SsP4QrDnFCZKtcsYS0Qca0fiWBNbOX8EQRCA5p5VvXp19OvXD4GBgXKbo2iU2kG1ZcQUcazdFyHkxxYHlNiizQRhDRzxt8ElzdBihm0e16sHQDOPjDMAY3edfjo1fREnsVDEqQXNXAFs7jr956Nv4X99EQdgFnEq5OSgtt739gCi9WxiS6emTQunTainFfiSoSfiAPjnn39YLGbH2LnJhr6I86zws0qthjv+SyGnb5txG2yf9fsdOTk5jG0b91nMOVL5iDhSYmyni4uL7rM10qmZcmJzmROHT7oxU3VJuQ2X+m7duoXU1FTG64hrm2I479mQY04cwLJnCtd2pBBxjCNs2Oo2XidlJI65Y8lms9xILuI46sukmDdysdt1dIRE4nAZ/Sq1iCNnHnpy8hEEYUucPXsWy5cvx8KFC+Hv74+BAweiT58+kk68qRQsicShvogysIaIY8lLPt+2pICuMYIgCGUiZK4IJycnPPf1xVMA5QAEQpOGTB91Xh5w9SoA4Ire8ielSuElADdoUp79y9IG05w4aRxEnGZG6cfeg6GIwxSJ4gqgceHnM9A8s7QpipIL1/mw2MkFro7sCoX/HwJ4WVAAuLkBL1+iLAxFHCZMDW7l0rZU6dT0jyUT5hyzO3fuxLVrxknzmNsGxJsTR8x0amz7aMv9On0b1GrNPOyAJi0c03q2bU195woXh709izhSpFPT31+hkThchRSu14G5/VKqD1TYbEyE6GhVczE5efKkqPVZgpIueq4ijj7WyENPkTjy44ij5QjCHgkKCsIvv/yC5ORkREZGYsuWLahatSp69uxpkLaCMMTe7/V5eXkIDg7GgAED5DbF5POG75w4QkQcoS80cg4oIQiCUBIqlQovXrzA8+fPkZ6eDpVKhYyMDDx//lz354gIFXHg5IQThd+ZUqqlHT0KvHqFV/hPdAE0kTfaGeZMzYuj/8zSiTilSwMAbhd+ZxJx3igUaQ4Xfn8X/42ELigoYIxiCYRmzp8UAPcL29aPxAGAymZsNIWQSJyCggKgcDATlyFNpiJjpBBxuEbi9OzZEz169DDbPhsffPABvvzyS052AOZFHK6DYsSIxGHaTqmOZqGo1WokJSXpvj948KDIeqlFHGtE4gidE0eOSBwxolCUGInDpx4l/bZIxJEIa41+NbXdm2++KahOKVDSRW/qxsd2Q1FaChMScQgtJDwRBDuurq746KOPEBMTg8uXL+Phw4do3749nj59KrdpVkFIX8Se7ylHjhzB2bNnER0dLbcpJmEbnSdVVLDQc06RONJgz79BgrAntKPFy5Yti3LlyiEjIwOBgYEoW7YsypYtizp1zM3SYp8IFXFUKhWOFX43FnG8ALgUzs18CIYp09RqNa4XfjZ1xBlFHHd3AP+JQv7QpHLTRyvifA+NGOIBoEXhuoKCAsZns3Y+nDN65YxFHEsjcbigL+Lk5uYCnp4AbFvE2bhxo9m2LekjSBWJY2qfli9fjn79+iEvL8+kE5uLiGMNJ7+U/RS1Wo3Y2FjW9dZIp8ZlO3PHwNx5s6VIHK2teXl5OHLkCF6+fMm7bf1jakqMMfbBmnsPYjoe9i7iSJ5OzZHgOzpRqReFFIi9f2lpaWjTpg06deqESZMmWVQXFyWf5sQR3t62bdvwww8/YNWqVahWrZr5DQiCIETkwYMHiI6ORnR0NLKysvDll1/CvfCl3R7h27eQoi+i1D6NJRPSig3XOXH0kaovIvQaUOp5JgiCsAaHDh2S2wRFIoaI0xaaiJd9AFwAbAVQG8BdAAONts3Pz8eNws/hAFYBYBqqo31mlQRQvnDZs8L5dBIB5BUrhuJ5efAFcKdwfXUAVXNzkQfgKIC9AD6GJqXaUWiev0zPZuP5cAoKCgzSqQHMIg4f5zTfSJzs7GxRInHY9pnJRrb6hLZtDYzttkY6tcGDBwMA3nnnHfj7+xuUY4pgkOr4KKVfd7UwbSIAzJ0712CdtSJxzF3jTP14Y3+w9jvT+ZLqHObm5iI9PR3ly5cX3I7xdR4SEoIpU6YgKysLc+bMQUREBLZs2cLLLq7p1KSIxOEr5j179gzPnz9XrL+eRBwZkeJCELXO7Gzg1CngzTeB4sUtqkrsfZ01axbi4uIQFxfHW8QxvuFyGfXBxXFiKUp2nFjSXseOHQEAn3zyCXbv3i2WSZJAo18Jwj7IycnBli1bsHz5chw7dgzh4eFYsGABwsPD4exsPMbSsVFqB1UKbGX/rDEnjj4k4hCWQv0nwhFp1aqV3CYoEiH3A62IEwvgKoD60AgmOwDkAngLQBo04kmK0bb5+fm6iJd20AgwiwHMA/BYr5z2Welb+P05gKxCH4caQJqnJ8o/foya+E/EaVP4/xyADAC78J+I8xXMR+JoRRy1umg6NUsicbhEw5QEUKrws1bEUZctCxVsOxKHC2JG4uhfz1JF4mh5+PAh/Pz8DMrxjcSxBK7bS9n/U6vVePXqlcn1XEUcob66kydPmpw3CTAvVpu7ntnSi5nD3P01KCgIf//9N27duoXXXnuNc736MF3nU6ZMQfHC++XWrVtx+PBhVK9e3UB0NAXXdGqm7jViz4nDRrly5QAA69atE1yHlEieTq169eq6k+1I8D3JloY+Cm3XJPPmAW3aAL/+anFVYl/08fHx5gsJwBIRx5qRONZGDAfPw4cPRbWJIAiCDR8fH4wfPx4hISH4559/EB0djZYtWyIzM9Puc9UrQZRR6vNMSXZJldpVCCTiKAsSRAjCNsjLy9NEN+iRmpqKqVOnYty4cTh+/LhMlsmLJSJOLjSpyuZBI958AKATgBwAnaEReIzJz8/HTgAdAVwEUAYageUegGUAmhSW0z6ztCLOPQD5es/PJ4VRKvrz4mhFHG3M1T4A+QAaFdbDFJVSXq+Oc4X/uaZT4xOJYw5tFE4WgEztdoWR6PYs4lj6DDXlAJZaxMnJyTF5rJUi4kiJuSgYtig0puuSqVx+fj7u3Llj0oZDhw6hYcOGJsuILeKEhYWhT58+JusEzF/ff//9NwBg8+bNJm0yhXE6NSbatGmDGjVqcKoP4C5a8Y3EkTKd2rlz53SflfDb0CK5iHP58mX4+vqaL+iAiHHDlfRFT3tzM3OTk4P79+8L3tZUJA5fB4mjpFMT4iC6fPkyqlSpovvOxebk5GRZHavkOCEcmS+++ALNmzcv4pCwRZ49e4Z79+5h+vTpqFOnji4/vfbP09MTZctyeYW1f6QQfZTU0dVHqXaZgiJxlNc2QRAEAAwZMgSjRo3SfX/x4gWaNWuGxYsXY+/evWjTpg127dolo4XyIFTE0ZIOYCyAhtBE4mRBk0LtEOOW/z0DtwF4HcCH0IgnbgAGQSPsHAfgcu8egP/mw7kHw+fn48L5YvTHrhuLOE8BnC78HA5gz549SE5Ohj7NCv9fL9wXrY1c0qlxhclh7eLiYvBdP5WalrzC9HGeHNtggmsqN74izh9//KETupQUicN1Lg8+9Voq4rD9xiwdGM71uEk9J44p3xNXEVFb1piuXbvC398ff/75p2AbAc0xePjwIe9rVVtGv+z169exb98+rFu3zmwdXI+9thzfKT8AadJPC43EEfL7M1cnV7hul5OTg7Vr1yIpKYlz3ZbAO50aV7Xt33//5W2MrfLs2TNcuHCB90u0GI4TSV9itRNWZWWZLZqXl4fOnTujWbNm+Oabb4qsF9vOBw8eiFYXl1EfXEZd2LOII2Q/Bw8ebNCpNbfdgQMH0K5dO5QqVQrx8fGoVKmSMGMJghDEggULAAB//fUXunfvLq8xFuLIeeqFvkxoP9uzmK0kxz/X42yNvgif7YW8DEqBks4lQRCOyYkTJ7Bo0SLd99WrVyM/Px+3bt2Ch4cHxo8fj++//x7vvfeejFZaH0sicfS5CaADNKOOTQ0nNH42bi/8awFgBICuAN4E8GLqVKBrV52Icx+GzsQnHh4ANOIRoImm8YUmCuiEXv27Cut7D0DEuHFF7NGmUjujt4wpEqckAHdo0rrxhUlI2bt3LyZPnowjR44AYBZxckuXhgssj8SRYk6coUOH4vHjx4iKiuLVLzEXncIXU3ZLNSeOltzcXJMiDtNxlzsSR+z+mDmRxtR6UwKclq1btwIA5s2bh65du/KyTf/8r1u3DosWLcKYMWOKzNtjbIu5SBz9yBdz72J8RRw2m0zBJRKHL0LmxDG+zylVxFmyZAlGjx6NcuXK4cmTJ5zrFwpvEefOnTuoXr06evfujYoVK5rfwAEICQnBjRs3DJbxvZkpcvSrVrwxJ+KkpCCrWTPUfPAAk7Zvt4qIk5iYKHhbUzc+th+qo0fiCGnP+OZvro7Lly8DADIzM3H79m0ScThizw5XQh60L5m2DOWp1yCkLyL2PeWvv/7SzY0mN7bo+Ld2JI41tiNMQ891grANEhMTUatWLd33mJgYdOnSBR6FYkC/fv2wcuVKucyTDbFEHC3m5AI2x97Jwr8oAJcAeFy7Bvz2m0Ekjv629728AGgibPbjv1Rol1xc8FIvSn0XgG8BhALwAmDssgsu/H9Wb5la/d+cOC+hmd/HE5ponOdG5bjAJOI4OzsbzPuo9dQ90iuTW7o0AHnSqXERfnbt2sVbxDGu19rp1FQqlWgDuHNzc02mk2KK4pBbxBEbc9eXqUgwU+fOXFkuNG/eXPf56dOnADRikKUijnFfny1Vm0qlskqklZIicbi8BxljSsyTQsQ5cUIj82uvCanhnU5tw4YNqFu3LubPn48jR46gZs2aGDlyJEaPHm3w50gYCzhcEfOGKwlcI3FOnID7gwfoZaKIIvevEC4PQany0PMZ0Srn6Fch1yqfh6jQNgiCIIRw4cIFfPDBB3KbIQmWDCKRYkBJRESEKHWKgaXPbCby8vKKHDcuL1hCXsKUMKCEntUEEyQ8EY6Iq6srXmrflwGcPn0awcHBBuszMjLkME1WxBZxzGHO4XgXwATtl6govF740Tid2i1vb4yHRmQJhUb8AYATJUoY1BcHjShUCsAChva0kTj6Ik5BQQGy9HwqbCnVhDopgaIOXqZInFclSwKwTMQpKCjAvHnzOG//3XffoWHDhpxGqBcrVsxk2+bs5LqNufpKFh4ngFs6NbFEHON0asbtc9lXazj5pUStFi+dmrl6+HL+/HnOZS0RcUzVKXUkjhTvSsb1ijknDhOm/JB89o/rdnXq1NF9tkZaet4iTrdu3bB7927cvn0bTZs2xRdffAFfX1989dVXuHXrlhQ22iR8b+SAOC9AskTivHoFQJN3lg0lPBC0mJoThyJxpGuPHEMEYRvYy+9v7969GDt2LL7++mtditfr168jIiICzZo1k6yTqiTEeqkkmHn69CmqVq2Knj178t5WSDo1JcyJY6vXy/r161G1alWcPXvWfGGCIAgONGnSBL///jsA4NixY0hNTUXbtm116+Pj41G5cmW5zJMNpYk4APALgBe1awPp6QgoXGYs4uTn52MONOnUdutte6RY0eQ1QwDkA/gImrRqWjpCE52TDY3QoyU3NxevCn0mALuIw8dJafwMdnJygrve9kwiTrarKwDLRJxdu3bh2LFjZrfXHtsJEybgypUruFc4J5EpihcvbrJtU+2IhbGjnIsTma9znKuIwyUSwR4jcUz9DthEHKblYkfi8EFb/6tXr3hFU5m7nqUWcUylUrPkmLGlU+MTiSPGYHIpInG8vb11n2/fvs25fqHwFnG0VKlSBRMmTMCtW7ewbt06nDlzBnXr1sWzZ8/EtM+uEeOGK+nNRzuySG+EESOFHZKSJooo4YGghauIo4+jpzARY9/4OIYcwblKCCM3NxfHjx9HTk6O3KbYLUq6Xwtl+fLlCA8PR3R0NGbPno3mzZtjzZo1CAkJgbe3Ny5fvuyQkw0zoXin/JMnwLx5QEqKxVWJvX8rVqxAamoqNm7cyHtbqUQcIYjxcmNt+Lbdq1cvJCYmolOnThJZJB62GNWiyHsHQUjMpEmTsHDhQtSsWRNhYWHo378/fHz+c8tv2bIFb775powWygPTPcy1UDxggy19EBe4CB8FAG5GRgJ6thmnU9M6L/+FRpj5EJo5dY4x7M85AD8Ufv4VQBkAXQBsKly2BoB+cuLMzEyD7bUijrHEx3UuCiaHdaUdO7DpyBH8AY2Tj0nEeSmCiBMfH8/JRiF9EyEijtiROAUFBaw+HqkjcczNiaP9zCYy2cOz2Fwkjljp1KRGrVbj0qVLcHNzw6hRo4rYxDW9mD580qkJFXGkSKUGiBOJw7Qdl/2UWsTRX6c/J7hUCH9aQqMqrlmzBlOnTsWZM2fQrVs3g9BDR4bvDUOsG4wskTiFIWO2GomjD19FXK6RD7Yg4vCtQ8yoJqHYouPE0YiMjMTbb7+NTz/9VG5TCAWzcOFCzJ49G48fP8bGjRvx+PFj/Pzzz/jnn3+wZMkS1KtXT24TJUMJL3Oitrt0KTB2LPDDD+bLmkHs48FlVCkbQkQcthcrisQxjX6mAGukOSAIQjg5OTlITU2V2wxOtGrVCrGxsRg1ahRWrlyJpUuXGqxv0qQJvvjiC5mskw+m55u59PNSR+IAQHqtWsCwYQA0ok4iTKfK2g5gMYA8lvonAbgNoCqAPQA2ACgO4A8Axm8pxmn1LE2nZlyuIQC/efPgrFajJ4D5YBZxslxcAFieTk2IjVwQkk7NXHQKX0w5jq2dTo1vJAIXO1JSUjBp0iTGPqxS+nVKTafGB7VajSlTpgAA0tPTi7Qr1cAsczaZg6uQzBchc+IYC3Z79+7ldHzkFHGs8RsSJOKcOXMGQ4cOhbe3N+bPn4/OnTsjMTER69evh0vhg4Ewj+JfhLnOiWNjkTjGsJ0HvqNfpXacsG1nDawRNab43wOhCBYtWgQADjlRrLWwh99ffHw8unXrBgDo3LkzihUrhu+//x5Vq1aV2TLrIuSlUnGpXR8VTsn7+DGn4hkZGayOemuJOGIOCFBaX0Qpz2qube/evRu1a9fmvF1eXh5Wr16NrVu32sW90FrQIBhCLJo0aQJvb2/cvHlTblM4Ua9ePYwePRo9evQoEk0ydOhQNGnSRB7DZITpfuDs7GxyG0tEHF7zyHz7LU4DWA1NpIz+tmzOS7blL6FJqwYALQA4A1gOTYo14y1evHgBALoBz5amU9N3brpBIyA5ZWfjTunSAIDRAFoVlmUScTw5tMHFR2LORr6IkU7N0ueRcSSIWq0GCr+LlU6NDa6ROKbOjbn979y5M6ZPn4533323yDqu51bKZ765SBw2EUelUvGKxLGGiMN1PVeRlM97mj1G4sycORO//fab2ba022ifO1zbBoC4uLgi9Rh/Nmez1BRN8GmGBg0a4OHDh+jduzeOHDmCgIAAKeyyecRS480h6UuTA86Jw3eCMWvOicMWNmsNhOwnn4eo8XqKxOGOLdpMEFLz8uVL3YuySqWCi4uLQYoTe+TixYtYunQp7xHMSrj3mkTbBzFKRcJE5vnzqNysGdwqVmQ8DmILVvfv3xe8rZC2ScThz7Jlywy+m7N5165d6NevHwDNoLU33njDZHkpoOc64chcu3YNAPC///0PX331lczWmObo0aOcyrVs2VJiS5SFEBGHT5ogY3hNdu3piRCWbdnEmtzcXMblAHAYwAIAnwP4CRrxhOkpoxVxSpUqhaysLItEHH8AZTMzoS589i8AUB9ArpcXJgQGwufAAcwFUKKwvL6I86Iw0qUYgNIADOODDLGVSBym9Zb0T4zTqX26eTOwdSsQG2tRlAKXfcrNzS3SpzPngObbLzt16hQA5ug4a/brTpw4wWqDWOnU5EzRb85GtvMq95w4fEUc4/epK1eu4OHDh2jTpg1rvULnxAGATZs2mc3Iot3GyckJ+fn5nH8jz58/R2BgIKst5toDrHPN8RZxrl27hlKlSmH16tW6ifyYePr0qUWG2TpCboCKe2njGYnjAgvz88mEJTcza+ahV8qIV2tE4tCcOAQhH7bgmOXCsmXLULpwRGJeXh6io6NRvnx5gzL6OYptnddff73IMmsNKJEUrgNKbt1CqWbNsAlA+4cPGYuILeI8ePDAou25oORIHGtj6b5xqePJkye6z485Rn8RBOGYtG7dWvccYbu3qFQqyUY2KxWmZ6u5OW+skU6N6RxxSZVlznH/BYBZAEwNodGmUytVqhQePXokWMQJhSZ1m/O2bcg+cQL7ALSDJj3c3W+/xYudO7EOQHUAIwu30bfrJYD8YsXgnJeHshAm4nBFrEgcKdoxhb7juAaAOtoBOytXIt/oPUJ/Gy71misvJJ2amP0yMfpZXHnrrbdY6zN1Trt3787ZDrnfa0wJKXwHj2vrMx7Yrf9df1uhIo6p+x3bPVRfpG/YsCEA4ObNm6hVqxajbaYi2kxF4jDZYGo/tc8drveyR9rsDwxluUbiKFLEoRQ24iGFY1zUGxXPOXEA9mgcJrt27tyJGjVqWH1uAjHnxKF0asLqYEIJc+I4PC9eAHv3AuHhQKlScltDyIQ9/P6qVatmkJve29u7yMATlUplVyKOGIh17mXpi/z7LwCgpokiYgtWOTk5grelOXH4I0Z7St4/giD+wxZ+f2XLlkWZMmXQv39/fPzxx0UGijgqQtOpCYVPCjJTy9icl1yccuZioPUjcQAgqXA5HxGnDDTp2rRH0uXJE7Qr/DwTQIeQEKh27QKgiQx6VVhWf5rtV9nZyC5ZEiWfP0dZAKbiiQ8ePIhDhw6hTZs2gp6NUqZT8wXwGBpRismpyzVSg62M1naDhGO//IJ8luhALvVy6asZizizZs0yiAg2J1RYet9Uwn1XrVYLFr75ROJIva/mrkE2X6M5u4xFG/17qznBWYpInLy8PMb7uykRx9R84+Yicbig3UZrl9DB4kIicazxG+It4mhTDBCmkWv0q2gXTX4+oHVOcIzEAbiLOGfOnMEHH3zAuM7asJ0HEnGY2xOqLtuC40Rx0XDWZuFC4JtvgNmzgXHj5LaGkAm578licOfOHblNUARy9UVEhWs6NZ7z8ylyXxmwRl+ErT0xy4qBkPPH10Zrj6ZjwuH7IgQB24jKT05OxpYtW7BixQrMmTMH7733HgYNGoT27ds79O/Y2nPiSB2JIwbGIo5WWPGARpDQiimmbPgeQDUA8QC+/eADjAoLw+8jR0IFTUq1jk5OOjGsAADTm1x2djay3dx0Io4pEhIS0LZtW2RlZQnyBViSTs1Uv+YNACcAbAbQk2c7XCdF17YZpr8iPh4+f//Nug2Xes2VNxZxACAqKqrIdmxp9o0jM/giVd+Krw1i+Zu4Ot6lwJyIIyQSx5j8/HyDe6v+/YMpStTSSBw2G5gwvg7Z0qnpU1BQUKQcl8gbY4wjcYS+Jyk1EkfwkIeXL19i27ZtmDt3LubOnYvt27fjpTb9FsEJRTsT9M9lTg5g6scsQMTRnzDK2og5J46l59AWRRyhD3c+Io4tvLjZJUlJhv8Jh0RxzyMr0KhRI5Pzmxw9ehQdOnRA5cqVoVKpsHXrVrN1Hj58GK+//jpcXFzw2muvITo6ukiZxYsXw8/PD66urggODsbZs2ct2IuiCHmpVJzjiWdqV1Mijj5SRnVwOYZCInG49EWEYCuROGL0DZS8f7aM4u4bEnPr1i2Eh4fj2LFjcptCyEiJEiXQo0cP7N27F9evX0fjxo0xYsQI+Pr6YsKECYLmz+DTL7hy5Qq6dOkCPz8/qFQqLFiwQFCdr169wvDhw+Hl5YXSpUujS5cuvOfX08eWRBwuc+KIgbGI8wLA88J19wDcAPArAM/nzxm2Bt4B8Enh54EA0ooXR3qjRpgPYB6AfGiOobmIprS0NGQUCiXmRBwtxiKO3JE4g6EZif4eNM5Mc/PEcFmuj/aaKAagrXZhq1YAgHqHDwuul8sxzM3NLbLuoV6KYP19DYJGBORrB1cbuZYTu69kiYjDVJeQdVK2zSTiCJ0Tx7is/j2Mi4hj7p7IBa73Ta6ROPr1MUXi8PmtmUunxuca4BrVpVgRZ9u2bahevToiIiIwbtw4jBs3Dh07dkT16tWxfft2sW20SfjeFBTnODEW5EwJdHrp1Lg6TywJmbYUUyIOReKYb0+qSBxKp6YAtL9lEuQdGkf8/d25c8fkxLWZmZkICAjA4sWLOdWXkJCA999/H23atEFcXBw+//xzDB48GHv37tWV2bBhAyIjIzF58mRcuHABAQEBCAsLM3hZswZCRjjxrdMiuKZTMxJxmGywxcECSuuLyClyWHtAiVz3QkW9DxCMdO3aFXv27HG4Ceutia31RapVq4ZJkybhwIEDqF27NmbNmoXnLA55Nvj2C7KyslCjRg3MmjUL3t7eguv84osvsH37dmzatAlHjhxBUlISOnfuzMt2faw9Jw7X57m5SBwpRRz9OXG0fAEgDpqomdoAhgIYd+BAEcd8aWjSqAHATwCOgnlfjOfLYGLMmDH4JzERAHcRxzg6xBqROKz+mexsdCn8XAZAXZjv73GxqQmA0dAIN1ondnMA7gBeuLoCS5YAAKpfvgw/hu3VajXaAdgKgPmXyN5X0//MFInDtF29hw9xDsBSE3UJQUqBjo8NYvmb5OzrmxNx2H5TfEQcY8GFr4jDBF8Rh2skDts+Gh8HcyKOuXb062QScczNOcRUj/FnY6ztx+TtST958iS6du2Kli1b4sSJE3j69CmePn2K48eP4+2330bXrl1x+vRpKWy1O8QY/SpEmeSEsbPElPNEQCSOudE4SoOL40RqyHEiPbboOBHVZu1vmUQcgjAgPDwcM2bMQKdOnTiVX7JkCfz9/TFv3jzUq1cPI0aMQNeuXfHDDz/oysyfPx9DhgzBgAEDUL9+fSxZsgQlS5bEihUrRLNbyIASOdo1Cc90aiWgyQFv7qVebgehkHs3iTjSRU9pUUI6NUL53Lt3T24T7B6579F8yM7Oxrp16xAaGoqGDRuifPny2LlzJ8qVK8erHr79gmbNmuH7779Hz5494eLiIqjO9PR0LF++HPPnz0fbtm3RtGlTrFy5EidPnhTVpyNlJM7Nmzc5lTM3J44106kBwAoAgQDKAfgAmoicyi9eYAP+m/fGE8BGANUB/AtAm1grPz+/yG+ESyQOADzTq5sLr169UkwkTsHu3dD/Vb3Bsx22ssugSUk3Qq+Mdj6ca1WqAHXrAu3aQaVW6yKi9FGr1ZgAoCM0YhATbPukf93l5uYWsdF4u6SkJFQrnAcyDIDaSHx8W61GCgBubyzsNppC30Yp/Cfa+kuUKMF5G75RG9aIxDElMLDde8SKxDFuz/izcV2m6jCFpSKOPlwicbjAJOKsXLkSb731lsEABnPXLtf7nuIjcWbMmIEBAwbgzz//REhICDw9PeHp6YkWLVpg8+bN6N+/P6ZNmyaFrTYFnzAvRWLsxOUo4rBF4hj/AOQUcWw1EkcMx4kYoxqsMScOOU5kgkQcAgp/NtkIp06dQmhoqMGysLAwnDp1CoBmpF1sbKxBGScnJ4SGhurKMJGdnY3nz58b/FmKkoQNRnhG4gCaASXm0mtYQxAwhZB0amwvSmL2RfiUtQURxxYHlBAEYRucPXsWw4YNg7e3N77//nt8+OGHuH//PjZu3Ij27dvzqktov8DSOmNjY5Gbm2tQpm7duqhWrRpru+b6IkzPN3PPPEuydAgdYAjIl05Nn3QAOwF8COCVszPCAMwH8DqACwDCAbwC0B+AdjgLm4jDpW+hFXG4RuK80utfAf8dRxU00TBsLUoh4qg2bAAAaPPAvIGi51WlUpmNgtCnFDSROIBmHqGCwkFD2vlwrlStCgAo+PRTAJp0bsaSqbqgAAGFnzsytszNz8SUTk1//atXr1ClShWUffAAgCZSqJReOmi1Wo1B+fmoBKAvix2m4PpbklLw1I/EmTVrlkV1cU2BJQXmrkE2EYdP5Inx/jGJQab6tebuiWy268N23+Q6J46lkTim7NT6nNVqNQYOHIgTJ05gwoQJjG0zwfX9SvGROKdPn8aIESNY1w8fPlxwR8OesIXRr5MnT8aPP/7IvNLYWWLKqWvkOOEy+lVJkThsD1FbE3HUajUOHDiAlJQUxu0TEhJQvnx5fPPNN6LYmZmZialTp+Jvlgn+TNXBtQ1rY4uROKIeK206NaPOOuFYkOPSclJSUlCpUiWDZZUqVcLz58/x8uVLPH78GPn5+Yxl2O7hADBz5kx4eHjo/nx9fU3awXdAiaIjcXiIOCVZbGDa11evXskycEDMOXGU1BeREmsIb0oYUGKLfRHR0UvVTDgmttAXad68OXbv3o1Ro0Zh6tSp8PPzw/Hjx7Ft2zaDPy4I7RdYWmdKSgpKlCgBT09Pzu2a64sIuYdZEonDFaZrSv8+zzWiRwhZhX0YV1dX1jKXACxs2hQAMArAaQD+AOIBhADQn4GLydHKNxKHj4hj/OxvAOAWNPP6FEAjRN0HcAXAKQB7ADS4eJFjC/9hMp1aZiZUhb8nrQdLjEicIPwX+eQDoPS6dShXuBwArlSuDACIr1cP9wCUB9DNqI7yWVm6yKZ60KTHM9U22wCdzMxMg3V9AbTQc2o/e6Y5e4316vW4ft2g3jcL22nIYINY8BEd+KJWq3X18xV3+Q7ckRJzkThs14BY6dS06/j22/mK2e3bt2fcJ2PkjMTRby89PZ13ffp1MmHtKH7eIs7Lly/h7u7Out7Dw6OIWk8wI8aLsNDOTlJSEqZNm4bRo0fjypUrRQvwicTRe9HiKuLY2pw41hj9KnQkrJatW7eiXbt2qF69OuM2kyZNwrNnzzBjxgzedjLdmCZNmoQpU6YgICCAcRu+D1GaE0cBUCQOQSiaqKgopKen6/7u642+Y0IuEUdUtP2P3FzNHxtGIg6XSJwXL17A09MTzZo1E8ta0VGaiMO2nTUQYif1RayDqM7XHTuAMmUAEVNLig1dG9JjK8f43r17mD59OiIiIhj/uKZhtSXM9UWERuLILeJImSYxJycHgPn0UMcrVoR2nHhxAH9BIybEGZXLy8tjjECRKhJHv63m0AhKNfXKuAOoCqB+4fowAB3++gu4c4djKxr0R85r0X3esQOqrCz8C2BR4brGANQMfio+kTjBhf+1rt1yy5bhA2gcpX8DeOammTDApVQprCws855RHdWePTP4zhSNwyUS5/nz57p1bwNYBWDtq1e6aCe1Wo1SMDz2nnoijkd6OqoVfq4B6FIRf/nll2jfvr3ZCBpt27VrM8lQ/2GtSBwpRRwpnjF86pQ6nRoXEYfpfsH33F66dAnZhf5g/W3167548SJ++uknRrtNReIUFBSIIuJs3LjRbNum6jFX1toDwHh70mvVqoWDBw+yro+JiUGtWrUsMsoeMHdBpKSkIFMvvzubUit2u1qy9YQX/Ytah8A5cbg6TpQUiaMPl4crl/KWtiek7O7duwH810kUE6a2Y2NjBdfBtQ3CypCIQ4B+f2Lg7e2N1NRUg2Wpqalwd3eHm5sbypcvD2dnZ8YybJMTA4CLiwvc3d0N/sRErL6IqOj3P3jMz8elL3Ls2DFkZ2fjwoULgkyz5LdCkTj8EePFyFwd1BdRAGfOaATbkyfltoSQEVv4/RUUFJj94+oQE9ovsLROb29v5OTkIC0tjXO75voiShVxmO7/Ujqj9dH6XrTpwtgoKCjAdwCGAxgIzbwmaQzlxJgTh03EMU6P//LlS11bYQAOFG57EprIlYoAXoMm/VtraNLCHQdQLD8f0EtdxAWmEf26z3/8AQBYD838QSnQCF3FLl82qMNUOjWma0Ar4swBcBdA8UePML9w2T4jm7TRUM2N6tCKONpeKh8RR/+zvojTp3BZeWiiewCNk74hDJ24njdu6D776QmqTgBw9SoAYO7cudi7dy9iYmIYLCtqozlfnVJFHGNsMZ0an76upZE4TDZacm7Z5kp6/fXXER8fz1jO2J5cvQF7TJE4XIQoYxGHzUZzdXN9J1B8OrUBAwZg7Nix2LVrV5F1O3fuxLhx49C/f38xbLNbkpOT4ePjYzAyR+jJFrqd/oWWxeQUETgnjpBIHGunq+AaiaOP0hwnQrCkYyxEXeY7+tXaCjYTinNeWhutuEsijkNjC44Tsfn111+LpBuxhJCQkCIvSvv370dISAgAzUjMpk2bGpQpKChATEyMrowY2HwkjnH0DY8BJVz6Ikqan48LXKKCLUXJIo41InGoL6IAtL9lcykUZcThzxHBmZcc+9RS9Au41Nm0aVMUL17coMyNGzdw7949we0yOc6knBOHK+YiccwRHh4uuG2uIo72Of8zgJUA2J5YTCmPuIo4aYX/ywKoBU1Uy3UAjwDkQTPvzlr8N9eNNhKnA4Dt0MwhsxtAO2iElEfQpHy7COBIYZlR2sbWrUNTsxb9B+s8HmlpQOGA1T8Kl58t/F+cR9o2U5E4xwDMLPzsVfh/r55N+fn5OAdN+jh/aMQrLdUKRdAlhd9DjNYD7H4j/eU5OTnIz89HcRimbGtR+D87O1uXSu1S4f8yd++idOFn/8K5cnT884/B12wzqUptXcTh2+eTEnMijv564+gTU5hK3aV/XqyVTk3fDq7XhbXnxGFaZ2wH03e7icQZPXo02rZtiw8++AD16tVD586d0alTJ9StWxcffvghWrVqhc8//1wCU20LUyf56NGjVrSEGbPig8BIHK6jX/V/UNYaAaPFlIjDtpyLiGMpUjtOxBJxtJ/51qdkx5AtI6ojgSJxCNjH7++9994zyHk7a9Ysg1GmT548Qf369XXfe/fuzTjZrJaMjAzExcUhLi4OgGaOsbi4OF3qjaioKPTt+98Uop9++in+/fdfjBs3DtevX8fPP/+MjRs34osvvtCViYyMxNKlS7Fq1Spcu3YNw4YNQ2ZmJgYMGGDp7vNCivMtWp3G9yK9COYicIgK1kduEYcrFIkjbttK3j+iEOqLELD93192djbmzZsHf39/ztuY6xf07dsXUVFRuvI5OTm6vklOTg4SExMRFxeH27dvc67Tw8MDgwYNQmRkJA4dOoTY2FgMGDAAISEhaN7cON6AG0KerXKlU8s1labViPHjxwtuW5vJhquIYw6mdGpcj6E2EqcpNOLNcAB1oIn40J653gAmF35+9eoVKt6/jz+giXz5A5pIE1My+0UAFxtqZmX53vzu6GAVcTZsAHJykF+vHrRxN+cK/5co7Jvrw3VgbpXCvzwAsdAIZzkVNfLLS2giirR15efn4zmAq4XbasUflUqF6oXvGLsK7XIC8IEJm0z17dLS0tAeQDm9ZVo5VV/E2QtN5JBKrYY2KbB/YiIA4F/thkZRSlz7QHxEHEv7nUzrtMeE773EuF5bicTR/2xuDrT/s3feYVIUWxv/zWaWsIBkJRhBBAETZgVRDFfFCAgiZvBiAC9mMWBWvGK4ooigiMJnwgCCiFlABQHFgCggack5Lbs78/3RXT3VPdVppmd2Ztn3efbZme7q7poO1afOe95znEicZKdTc3uu7JQ4du1V+3cjcbyMcfEqceIlcdK+Jk5WVhZvv/02b731Fi1btuSPP/5g4cKFtGrVinHjxvHuu+9WaL2TTIVfBUiQx1MeO86aOF6jX+V7JB62NxEki8RJtuPEbjuvSHclTlUe+jRAleOkClSO52/q1KmmaLNHHnmEjRs3Gt/LyspYKKUfcMPs2bPp0KEDHTp0ADSnSIcOHRgyZAigKWzlXOr7778/kyZNYtq0abRr145hw4bxyiuv0LVrV6NN9+7deeqppxgyZAjt27dn3rx5TJkyJVBFUEUpcQK7h/wElEjjlpfUruFw2DQ5DHIS6uV969ZGFamXDrZIupA48W5TZYtkADLAFqm6N5KPTDjHJSUl3HnnnRx11FEcf/zxTJw4EYDRo0ez//7788wzz5iCN9zgZhcsW7aM4uJio/2qVasM26S4uJinnnqKDh06cM0113jeJ8B///tf/vWvf3HRRRdx8skn06hRI9577724z4soTi8jHdKpqe4plR+ioKBAuX0QgR9BkTiJpFPboP/PQ3MGfoRGOByGlh7tan39fcClQNbKlVw4ZgzVgSnA5YAX6mvqSSdBfj6dgHM8tAcziZOrH/+EIUOgXz8A9lx4odFWKHFUJI7b/gUETfkLGim1B1ipE5xTgd2YSRyA7y3bFobDNNy+HdDUMR/oy7tZjm03plmv+caNG7lM/ywqVwsSZ8+ePQaJ8zMwS//cEY30abRBu7oviZ1ZlDjJIHHigRu5ElQ6tYoONnJK9WWXTu3EE09k3bp1no7hJZ2a3baq79Z9eEUqlTh+5raq+8dpHuOkzPFKCKbinot9w7rg9ddfp3v37sZfFdTwe/FU7T///HPOP/98/ve//3H55ZcHetx0UuKUlpZSTS8Yl06obI6TTFLiVKUwqSAIp7f0TFehCpmIeAw+J5x66qmO+xgzZoxym7kuKR4GDBjAgAEDEuqbE4KwRZKN0aNHEwqF1Kl4U5zaNShlThDvEtEfL+/GRO2DoANKFixYwL777kudOrEZ97ds2UKnTp245JJLTBHl8R6vvLycUaNGcfLJJ9OqVau4+6xaX2WLeEeVKrgKeyOGDBnCSy+9RJcuXZgxYwaXXHIJV155JbNmzeLpp5/mkksu8f1ecbILvvzyS9P3Fi1aeBqz3WyNgoICXnjhBV544QVffbVDupI4qjFd5bCsXr06uxVzoXQicVRKnFAoZHsOs7KyjN//K/AyUIKWSu1PS9tX0Wqw/AcYA5Q88gg1t23jFzRSxav7flPNmnDLLfD44zypH2eRyzbiNzVct45FQHPQ1CRZWXD++ey69lp4+GEgqsTJ/ecf6hBVGMn7sdu/gFDTfC8tW33eefR7/HFEtUSrymAWGtEltj1w506ygFXAejQS5yGgC2gKcl3p7yWdGsDONWs4T/88EK0uz6Fo6e/2SEqcn4H6QHc0QkkohH4PhfhS7D9JShyvigs7uN3nYn0y06mpCIJE4cWeVgVpWc/HTz/9ZAr8EwiFQp6VOLaqNhfEQ9CJbYJW4oTD4YTmNW5KHLd0al4VZ2mvxLnyyitNKUqqoEY8jhPrjX7OOeewfft2U4oWt+MERuLE6TjxEv1qJXHSTYmjOh+pIHH8tHVzTgWNIJwa6RzdWwUdVY6TKlD1/O1t8BI1lsg+nbBjxw6uuuoqrrzySmbPnh3bwGp7JJhOzS2gJJVwO8+qyVcmBJTMmTOHtm3bst9++ym3f/bZZ5k7dy533XVXQv0UGDlyJNdffz2HHnqoYgv/dnKVLZIGyABbJBOJtkxDJjx/b7/9Nq+//jrvvPMOn376KeXl5ZSVlTF//nx69OiRESk7k4FMT6dml143iOuZl5fnuN4PiWOFkxJHJtYiwPVodWusBI7A7WipwaoBtVevZnuNGvwL2OapdxrC4TDceSfr0UiIP9GUKvcDg4HHgJH693r6Nv/3f//HB3feyQ3jx9McjRj57eKLYckSeO89wtK12USUFDqaKNqWlRGxeX9Y7SgViVMeDvMpGiEDsUocoX45Bs2ZerBuq/6sL1+Als6sGsCnnxr7tbMvrNe8+bx5FAILgWloKe9AI2rqbN9ObTQl1B9SX44FTtI/z8jKMhQ8rF4N68UvCV6JUxPo/dJLIKn/vCBZShw3ZYXdcYKCHxLHTonjtn+neyeImjjxkDgqJY7TeG5HjgRdEydIJY4bIeilXVDwTeJkgkGViVCd12QaMslU4rjdI+Fw2PTbUk3iWGH38DoNkKptK9px4oZUK3H8vETtjpEKyMfa6yflGeA4qULyURne86poxL3x+Xa7luvWrWPr1q2m9sk4T3b9kFPevf7667EN4rRFMiGgxAov70w7WySdSJxP9MLDO22ulVtRXSeofufMmTN97cOLjar6XIUUQjzLTs97BaMyvCfTHZlwjlesWMGRR2pl29u0aUN+fj4DBw7cK+0NGfEqcZINryROjRo1YpZBMH2sqHRqqmvihDDQE61OzK5q1Xj78stZ5rJNzD7CYSgq4l/AJ2jEw+FoadqeQCOKrtG/L0Yjc9otWUKXxx6jsKSEGUAb4NdLL4VmzaL7lCBSqh2DVs9nLDB90yZqnXIKRyn6JJ+zbLS6QBAlQyD2GlhJnE2NGrE7N5eaaOSUIHHmS9tMFB/ef195bKcAnSP0dM9v6t+FlXM8cICetu13tPM5Fy0FXEOgh97uu6wsdqCuiyMftxFA06Zw1VUx691IHGEz3wo0/ecfGDVKI4w8wq3uSjwkTjxBzslU4nzwwQeObeIhcazbJVoTRwWn+ZDd9onUxLF+9kviOKWsU93HTnMm6/d0VeL4TqcGe6cjxC/iUeJYUaEkjlclTiRiqonjNZ2a/D3dlDh+Upiolj/++ONUq1aNm266ybUvmUziJLIPFSrKcZIJk8SUQTzLpaVQXg57aQRhFTIfkUiEvn37kp+fD2hFWfv162dEVybiSK4s2LJlCw304q0CyRoP7cgheaxXOv0TIHHcJnORSOL1+RI5X5VBiZNqBGErZ4ISZ6+fZ1UFlFSBzCBRy8vLTcqKnJwcWwJgb0K6plNTjek//fRTzLJkKnGSmU7N6Rz6JXEAtqIpXB4dPJgyFwWRCiIV0vfA2UBt4DzgDLSUbBuAzfqyI9HIHIEfatfm9M2b2YmzHfQD0AtNhdIBEBVzshctYibwCFpqM9X2bYDqeh/kKpnWa2BVGYRycljWsCGHrFjBscBBChLnHWAQwJtvwr//DR072toX8ud6QPu1awF4S182A7gSrS7OXF2RLlQ/JcA8NBJL6J9nZGdDaSm/AAcAyydPVh6rB8CKFTB6NNx1Fxx0kLHe7X4pLy+nvviNAtOnQ69ejtsJhEtL6QZ8Bmy3rAtaiTN58mSeeeYZLrjgAlO9q2Qrcfr378/FF19s28ZLwLjbMbzUxEmlEsfrfMTO7xeJRFKqxAkqnZqXuVqQiIvEOe2001wfbNULsQr+EE9hXK83eWBKnLIykPZVCPTo0YMHHniAY445RnmMiiZx3JCI46S4uJg77rgDgH79+rlKpmX4GaBSTeKoBlqn/b388sv89ttvpmXp6jjJdBInsAlPOAx79kS/79oFVRPRvRKZ/kwA9OnTx/Rs9O7dW9mmssPpWlrHaLf2iRw3HA675iVWjmVJTqcm9ynV6dSssFPixBtQElQ/nNanQ0BJ0E6/dCBx9npUkThVyBC4BYwIvPfeexXRvQpDuqZT8/qutCPi0onEUbXzq8TJzs52PV4E2B4Okx/H+9Baz2Iz8Lr+J+NBNPLlITRlywRgROvW7JwxQ+uDC4kDGjEEsBu4tVYtnj79dPLffZch+r55+2246CLTvo7V//+o/04B6zn566+/OOKIIzjhhBMA7bz9U78+h6xYwfGoSZyZwDigV3k5XH45zJvnqSZOXyA7EuFHoqnihBKnIxi1mn4milloJA7Apho1WK7vbwFwPjD5ySeVxz1X/pEjR8Ljjxtfs7OyOE4/jsryDofD3IWWTs3AtGmeSZycF17gfeBF4AbLOplc8fvMqZQV55xzjt69abbHCQrW4zupRJyUOHZjYXFxMX/88Yfx3a8Sxwvi8c2q0qk5nVsnJY48H0sGiePkBw+iJk4q5g5xkThdu3atijJxQTxKnFTmofesxMnN1aLy7UgcS9G/asCUKVOYMmWKbV+sA2a6KXFU7LhXEkeOJPZyLSqjEufvv//m+uuvd9xHoscIEvKx9uroV6syoYrE2atQ2RyXY8aMqegupAWCupbr1q2jXr16nsdIu/eqFclM7eqFxJGRbrZIRSlx/LStSFskWdtUpVNLA1SROFUgM2yRK664wvRdFTCyNyIe1YcqDW7Q8HpPZaoSx+kcqq5Jbm6up+Pt3r3bV2CqQDgc9vwefQ/4ADgITRVzgs3vsO5vHhDJySFUVsYONFXPr9Wq8eBLL9H73Xd5EU1xw6WXQuvW5PfrRzaaEkhVDwdir8GcOXMAmDt3LqA5hpc2bgxAN6AwHGZPVhYLLX0bAPTad19YtAhuv93WfhK/6RzgUX3Zq9J+fgO2AEVAJ/29aCVxRP6Xv5s00dQ1wC/6srZSW3Hc2sDJcmdHj4YHHzTWX7RyJTcAbwOXEovGe/bQX//87fHHc+KMGfDZZxCJgIfnOHfiREC7Xk4kTqIpDP2k8w8CXvbXv39/DjzwwLjszTVr1pjmuE6kQzLSqdkhWUocKxEs2nj1K7qROG5KnHhq4qStEmfw4MExKTiqkBhUN4UXQybegcez46RePSgutp9IWUicQpvjpbMSx42BtVtmXe7VaWXXJl1JDuvx3JQ469atc92H12OkGpkwYUwaVCROFfYaVLZ7v1mzZpx33nmcf/75dOrUKS6Hwt4I1X3w3nvvcdFFF9GvXz9efPHFwPZrXR4kiWOXTs36zk7UFknkuYknoCQdauLYbecVVUocd2R6QEnCgWlVJE4VyAy7ZPTo0b7ar1ixgiZNmqSk/ktFIh6bq6LSqamQCUocu3RqfpQ4ubm5hrLDCbt376ZmzZqu7azwQ+KARqyItGZeVCugKW82n3EGJZMncxFa6rGG+rp30NJ13QzcV1RE6Lff2Oemm1gE/Bc4QW/nRuJYkZ2dzT8NtaPU1Zctq1mT8i1bTO02g0aOnHEGPP88rc4+G4BcIGfjRtPxTkYjTHKAKfXr85LkT4mgETVdifrarCSOwN+NGxskjqiE00ZaL87lmfqxaNUKtm2DlSvh/feJRCI0Aq74+28ALgEOAf60nINBW7eSD0wHvj3pJI6fPZuslSuZMnw4Z95yi/WUmbF2Ldk6MbYv0BqNqJL7KK5BounU3BzvyVbi2KXvPuOMMzjrrLOM73ZKnNLSUsdMAV7SqW3bts22fyrEk5lAHCsIJY6XdGpuQdhOJI6TnZ8pShzfFkSmTyxSBaeL53SjubULCp5JnH32MX+3wjIwVbM5nvVhSWclTiLRr4nkZvdDcsSDVDlOvDjrANauXcuyZdESiake/CriWGkNqxHvwaivQuVEZXgmxo4dS35+PjfccAP16tWje/fujBs3js2bN1d011IKv9dS9R678847ARgxYkTcxw1MiZNgOjXrRKGy2iJ+kcqAkqBsEa8T73iegXi3rYKGhM+beJZLSrT6fFWoQiVB69atWbp0aUV3I+mIN51aspEJShyvDtTy8nIlieNXieMFu3fvjmtc90viyHBTrchY+tBD7ItG4Fi32Qw8AESWLIGhQymvU4f9gWfRyAmIj8TZXr06S+Q+1Kqlbnz66Wzo0QOA/p9+ygZgD3Bq9+4UA2OBPps28RGaH+1D4MHmzbGebfm3rQeKpe9L9L8yYOF++xn3wEL9WLWApnpbcV6MVGrdusE112ifX3qJSCTC40B16RzcaunLocClug/wLmBPdjY/6PfSpIED1edBxuTJhKRreoZldbxKHJXDPxH/WgiNOPOTl8S6vx07dnAQah+plznI4Ycf7pgByy2d2uTJk3n//fdt+6davkdOr+8RKiWOFxJnwYIFMZmMvJA4a8aO5XaH/ohtVGO2nyD8dFXi+H5bunX+k08+URZw2tvg9SI7LYtnouv1Bet6o4noNzcSR5FOze141ocx1Xnogywm7DTZT7USx237VDtOnPYB0LBhQ5o3b244VSvKceLG5O81sJI2aRwB2xLNsKpCcEgHJVyQOOWUUxg2bBiLFi3iu+++o3379jz33HM0atSIzp0788wzz7B48eKK7mbaIVkBJYGROD6UOG4kTkXbIm4IShXsBZlii6h+Z9Dv7ap0aokjMBLH+rkKexUqI4laGX+TCumqxPE6pieTxHFLS+bVgapy+sajxIn3WF4QDofjKpIO/kic8vJyrEtjnrWiIrjnHpZ/+y39iCpL5gLWHCJeSJxQKGRSwCx2UCo1Gz+eP4D8sjJDuQPQCOgN3LthA7WAL4HuQIniN86UPv8cs1YjG04G1hQVGcvKAFE9RaRUi0Qi5ABni0bnnquROFlZ8OWXHDF3Ln2AMCDomD6AyMGUDYzU/7+HVpMoEonwhX4vdbE9CxI+/hiIElFBkTirVq2KuXZOz7ybEud2YArwkucexN53bVauZBGg0mw61cQR+OOPPxzfG25KnH//+9+O/QNNIdqsWTMefvhhIL75ULw1cd54442Y5VYSJ2Y/kQj07ctjwGk2+3dS4vhJp5aosihZ8E3iLFmyhHr16sUsu/fee2nWrBkXXHCBJ1lmFczw4jiJhxW1Q2BKnDjTqWVa9KsXB5TXbRJpH09bgXRT4ggIR2qySZxwOMzs2bNjXkx7y4TKFRmSTu06NIP0xoruSCVDZX4ODjvsMO68805mzZrFkiVL6NmzJ9OnT6dNmza0adOGSZMmVXQXk4ZEVAgCqSJxlEZvAjVxVLaF1fZJ1BZJ5LlJthLn4osv5owzzkh5QEkysbcocTIxoETuc8ITWHlukaa2SBWSj8psl1R2xKvESZd0anl5eXz44Yf897//NS1PhRLHLv2SFSolTigUSgqJM2bMGF544QVPbWUkQ4mjuobWYzgWky8o4CWgFXA88C/Fsd1IHHGOZQXPEhslTjgcZqd+rGsOPphDgX2ATz/4gFOBh4Gf8vL4GK0+zG7U9uj3YBBVKhJnERrRYz0/1pRqkUiEE9Fq4qwF6NgR9tsPzjkHgPP1OdFnzZvzDFqqtgKi8+770dLQbSGq0AmHw3yjk5OdQKunbYeSEpg6FYA79UWnAPmWZvGQOAcBKyXVCbgH1ofDYQ5QHL82GEqPS4DGHvtgPd6lemq7i9FIO7u28ZKdbkocJ1+lwJAhQ1ixYgX33HMPkFoljsov56bEqb9nj3E9TiA90qmleu7gm8Rp3rw5WVlZlJSUMG7cODp37kzLli155JFHGDRoEGvXruVjnV3dm6G6eOPRJJJ25on1BpS/jxgxglq1avHFF1+4HsfLelcSR0yaBGGXRCVOutbE8UvixKPE8YNEB4d0U+JYlydbCTBkyBCOPvporhGSYUW/Mt1xkhAyRIlzqP6/ZYX2ovIhHRyXqUDjxo259tpr+eijj1i/fj1Dhw4lP99qulceZBKJ40mJ4yOd2gEHHMDw4cMdj5esgBIv5yyZJE5paSnvvvsu06ZN4289r7kTUkniBB1Q4oSePXsyVXcWJOsYVYhFoEqcNLVFqlCFKtgjXZU4XsemrKwszj33XHr27GlangoSx48Sx/p7nM6hqu9eSRywr3nrhFSlU1M5wK3nZty4cZxxxhmsX79eW49GeqxSHDsuJY4NiSP2tQmYXVjIH8BGoDw3l6+Ae4DzGzTgXEBULlEpIbYCv+qfVSSODPke+EX/LytxRCq1SdqP0b706wdozuGNwFtttS2e1NvegJaC7S79+79zc1mqfw6Hw/ySk8MGtNRt/Pijfee+/hq2b6esfn1eRzv/hUTrE4k++iVx2gLz0MguOc2W2/2XO2ECi4AfMQej34pG5IBWw+ga/OMg4Pjt2wFNudTLst5NiePl2XEiHbySONZjJ6LE8ZoZQKXcEcvl+Vg4HI7ZzyFSjZ/jbPafahIn7ZU4c+bM4YYbbqBRo0Y888wzdOvWjeXLl5OVlUXXrl2pZZcPci9HIZo88lyg2qZNMevdHCffffcdJSUlzJ492/E4bjciaDfjhg0bHI+daE0cq1OsopU4XplTu7bxpDCprNGvQShxVJ+TXRNHSERff/11237t1cgQEkeI1e0I4yrEh8r2HJSVlcVEM65Zs4YHHniA2267jW+//ZbCwkIuuOACunTxJP7fKxAUiePFFrEudwwoEfmg7WyRSMRkj4iJ2C2W4qrJTKeW6DPkhcSxcyz4sXHc2vj5HekQUGK3vzVr1jB+/PhAjlEFfwiUxHFS31WhUqOy2SV7EyoDiQOxxEcQdXvciBNBMrjBbzo11XK31G6JIhESx84+9EriWHHFFVcwbdo0hgwZ4uvYKoj7YjbwPvBugwZst7nnraoC1TGcUmLJuAV4EXjLoW92ShyDxAmHOU///JHcsGtXaNEC0IilnYWaJT0RTeVTF+23ZgEvA29b1LdhYLpY8Nln9h38SDvqrs6diQCf6ovllGqyr9ALcboP8AEgkiA+Bjwh7csOh+7eTeEtt5CFdn6E1qwecLP+eYL+/zo0IsYN8vGu1/8LyqGvpa0biePFR+qWTs0LiWMdd+OZD4l++E0/puqfmxLnYJ0YAzgWTPWV5O3AvSaOWzo1v6SUah/JgO83UceOHcnPz2fWrFn8+OOP3HTTTTRs2DAZfctoWC+ynCUzX1FYORKJLSYsf1c9GF6Oq7rZTjnlFM4//3zHNn6VOOJRE44Tay7ZilbiyMdbtGgRxx57rK1iLBEljt90EpkY/ZosWXRFkVSejvXVV9CjB6xenfwOVRQyJJ2aKO1nl7qxCvGhskWfX3vttdx0003G923btnH00UfzwgsvMHXqVDp16sTkyZMrsIepQRDviiBInISVOD4DSuzGh2SmU/N7roOsz+dETvlFptgibscOIjVFRY2FmagKlpHQeSsr0/4E0tQWqULyURlsESsy/dn2injTqSUbXuewdiROENfPj/rFCap0ak5EmOr8BtUXO1SUEicUCtmOH14URV7SqYVCIcqBC4HHmze3PZ6dU9vJ2W1nj36OpohxKlxh7YdQ4rQDPgMO/PxzDgJKiBIogKbI+egjJpxzDiOI3vth4GnRBE0NdAuxTutIJMI0sWCa8cnaOaMezvZTTwXUJM4333xjpNt3GxdygP8D9gf+Bu7Vlw8GRoHZnpBQF3hh9WpCu3fzI1CORrL0BW5D893OAa5ASzu3HxgKJieI818AXKUv6wfsQktpd6SiLajvay9kils6Neu97OW9msp0airSRP7dqjlNS0mJUxvYV/oubwdV6dQMnHbaaYwaNYoHH3yQKVOmVEoDKxnwQuI4wU5y5mZMqPb73XffuR/bZ00coS0S0fFuJE5FKnFmzJjB999/z7nnnhuzDlKbTi1IEsdt+4ouJuyHxEll9Kt8XNvf9OyzMGECfPBBinoVHxIaj61KnDStbVZF4iQHlY3E+e6777jooouM76+//jrl5eUsWrSI+fPnM2jQIJ588kmHPeydUAWUBLVfFTyTOCKgxC6dmsfUrk5kR6K2SLKUODLsHAuJkjipDChJBH6UOF7x6quvMnjw4Aq3RSoTErovMiSgpArJR2WwRayojL9JhcqixLE6ANOJxLFLp5aMmjh+IfpQkUocL3anHdzsQSu552R3WVNDqT5bt03EHrXu6x/gGaAUrQj8saNHAxohFGNRt2nDT4cdRgTzbxwDLAO2o2UW2kUsCRUOhzH0N7NmwfjxMGwYDBqkfS4rg99/hyVLID+f7cceC2Bs0wFooH9eunQpGzduBNxJnKeAzmhql/OAh4Ar0UiZq4B2t91Gfcs2WWhqpqZlZZS1aMEZRMmfF4AB+ud70MiuV/TvNzj0IzJ7Nixfbpz/S9GIoqVoJTXe19v1lbaxknoHA83176FQyBOJky5KHJWv2ulZu/nmm2N8wqJ/runUdCXORv17SynDlLwf8E/iOM3FMlqJM3XqVH799VdatmxJ//79ady4MTffrAnO9pboEi9wUuJU27rVtT2olTh+bwq/RIIBn0ocQeIIx2oNkfpERzIdJ17gdN4SIXH8DAJ+t/e6XSrgx6kRz7nysj5Z8HQswfBL8s10RKAkTpo6TqrSqSUHlc2xsHLlSg4++GDj+/Tp07nooosoKioCtLQKv/76q93mlQaJOPMF4omODVyJU7+++bsVlvEqVUocGYkqcYIMKPH7Pk0liZMqJY7Xvl199dU89dRTfP31176PkSxk4nzKrxLdFhlii+wXDjMWOKKiO1KFCsXixYt9jRO//fYbzZs3d2+Y4YiXxEm2GscviZPOShyVczMUCiWtJo4fiCw94XA4blWslzRkAn6O4aWtl3Rq8nn2SuL89ttvymN4VeJ4gSoYayBwIDqZo6fQc0rJBub7ZTfau+5gonV5rNckEomwFE0NQ1kZ9OwJ//kP/Pe/2ueWLeG227RtO3emWy+tQsw64Cd9PyK5dTWgI1pNmRwbVUg2Wsq0m/XvlwPi7I5BU0htB+rOm8dctJo7OfryaWjKn52hEJtHj2YzWgq2KWjzh2rADP07wEtoiqTTgUMs/WiERtKEjj4aWrbk3GXLAOhv2XaM/r0nIJIYyte985Yt/I6mnNoP7fzGo8RpMWuWkcbNK4ljRVBKHLdjzZ49W6nEcSJxGgP77NlDOfCavswvieMnnVqlUeIANG3alCFDhrBkyRLGjh3LunXryMnJ4fzzz+euu+7ip59+ct9JJYf14smVggq2bFFu45TCxE6JE8Qk1lP0q0sKk03SogJilTjWhyWda+KoXtzxRHNUdsdJ0EqcikphojrWqlWrePXVV9ktnAnCiZDmudkzgcSJRCL8/fffcTt5qpQ4yUE6OC6DREFBAbuke3jWrFl07NjRtH57mpOyQUB1LY8BzvbRXh7r//nnH+6++26Ki4sT7gfEocRxCSgR8ELiWCcGQdbECbKOUKIkjt9jJ2qLuG0flCrYTYnj9xyIqM9k2yKLFy/mzDPPZPr06e6NMxSZYIskiov37KE3zpG5VUgMmWCLHHzwwab0TN27d2fNmjW27Zs2bRpXqrFMQ7zp1Kw1dYPGLo/jSTJJnCDr0NjVxVEhlenUBImjirT3ikRJnESUOG5ET7xKHLt+eK2JkwiWo5E5Ex5/nBOAsZb1zz33HP/5z39snd8bALuk8rI9/SjAAQfAccdp5E3//lpmn8WLYdIkAFYfdZSJ0BIp1S4HngNWAbPQavF0Pvdc1qPV5jkLzXldH42IGaxvdwdaTRwZH6LNd7Y3a8a+wJfACuBdNOVOGTC4Xj1KW7YEIKIff4W+/d3SvpYBk/TPghBrjfb+/wNNnQTArl3c9OefzECr1bIHPaUbWr2gFWj1e/4lnTeAU4Fn1qwhGy1YdRixihQ7mO6dqVPpMmoUI4DziSVxzgAajBwJDz3EPWhKpdw407hZ4VeJo+w/7kocETjzO9EaTIds3IgVXkkcNz+wVxIn7ZU4Vpx++um8+eabrFq1ihtvvJFPPvmEo48+Ooi+ZQS8XiRTOjUFieNViRNETRzXY5eVgXh4RTo1eZkMixIHNPY63ZQ4zz//vOe2om/xOE5U+/F7XC/rvex706ZNdO3albFjra9pDbt27eLee+/lhx9+8NW3eIlDNxLHj9onSKgcb0ceeSRXX311tPihcBxWZhInRSlMhg8fzkEHHcSNN97I/Pnz6d+/P6t91BqqUuIkB5WNxGnfvr0x9n3zzTesWbOGzp07G+v//vtvmjRpUlHdq1B8gDa5yXWIXLLDCy+8wCOPPMKrr77q65iBkTge06llYk0cOxsi00gcN6RKiRPvvpNti/Tu3ZupU6fSpUsX98YZikBJnDS1u4r0/zUdW1UhEWSCLWLt4+TJk9lh957aixCvEqegoCAJvYli4MCBPPDAA576Iv8XSCclDvgjcVTEWpCEkgxZiVNRJI4dgiBxrOc4HhLHydmdSFCR27i5s7CQGYrlN910E8OGDWPOnDmAPyJW/v2jAP7+G2bMgDffhP/9D/75B4YPh6ZNoWFDvrPUUxckzploqcxqA+uJpnvbB42UmIym9JkLdEJLoXYx8LhNv34HZj7zDOPQVDgN0YioR9AUNZMKC03nfj1wtP73pWVf/9P/9wP+QlMkvYBmC/wA7Pr2W3j2WUqysjhOb/sOmtIINDWO8MhdKZaFwxyJNifLB75ASwN3KbB63Dj69u0LwHFoxNaXQCtLv4z+r1sHenuAZ4GckhLjPrscmAo0fuEFuPdehqJdq8Hz55NluWfiuf9UWaPcnrVq1aq5KnGstb9ETaGf0Ig+gP22bQMLkSO2Ud3HTnOJIJQ4GUHiCNSpU4cbb7yRuXPn8uOPPxrLb7jhBtavXx/UYdIOdhfJepFlI7/AY00cL0oct/3EReLIzltB4liXC+iTre1ouTZBc55YjQInx0mi0a9ecOutt9quCzL61W6dl2MHoaqS8dBDD/Hpp5/Sp08fINbwHDFiBA899JApOt3LsePNQ++HxKloJY4gFSbpESOGEyENJ2ZWOXfcSFH065133gnA//73P9q3b8+IESMMI8ULqpQ4yUcmOE7cMGTIEIYPH86BBx5I165d6du3L40bNzbWv//++5xwwgkV2MPUwHots9Gk/9lAgSJa2M0WEeolNyeVF1vk/fff55JLLnFs4zmdWpw1cSqSxCktLeWVV15h6dKlyvXpqsSx284rgiJxglbiqLZLxli4YsUK1za252jbNpgyBeJIdZFKZIItkihq6L+xyhZJHiqDLbK3Il1JHID777/fU18gvdOpgdqHkm7p1CqCxAmFQilX4vjdVyrTqXnpj8A2PYW8HxLH9TpXrw433QTLlkFxMbOWLDGt/g5YjKZc+T+0tGUN0Ob83338MUeiqVM2Ai2AfdEUMMegKWucUFZQQG+gGxoR1BRNZSN6YL12q4HZiv1MRSObdgNb0MiZRWik03FA2eGHw403cu2RRzILzTf6lGUfIv3Xv/R9vDZ/Pp+i+Ym/ycvjLKJk0VGvv87nn37KcfqxGwOnAPP0/osnNxwOQyQCV18Nq1ezvmFDlgDNgEsXLiQcDtMGGKG3/6FePUaiETglwElr1nDB55+b+hlUOjXVMhnZ2dlxkzhz0NRhC8WKWbOQ4aTEcRpPnEgcp3s81RmFkpJ49IgjohmC33jjDbYqasBUFsSjxFGlU/OqxElJTRx5wlRUBKIfKueJPtnaDYi11Yh9YIJU4iQr+lIgEceJX4d6kI4T67KNFkba+kJfvnx5XMdLhRKnokmcmHVV6dQCg6qP8+fP97y9GEurHCfBorIpcU455RRmz57NTTfdxOjRoxk5cqRpffv27Rk4cGAF9a7iINsiOYoAG9XkL4iAEpXtcuGFF7JwoWF+e1PiuJA4wtqsBqimsE62SJDp1Lzg22+/5dprr+WQQw5Rbh+vLeJ1G7v2ftqmeqxQHTuo+jFifxWV2tUThg6Fs86CN96o6J7EYG+riVOzisRJOtLu+VNAVYMkE2taBY1406mlgsTxgkwhcdauXRuzLJ3SqSVC4thFwKeiJk6q06kFTeI4weu58kvieB6vQ6GYAP89QBs0xU134DPA2Fvt2vwE/AeNvLkcGIJG4PzhsW8QzUJgPbNe788I0BVtflEbjWQ6BE2NEyZ6XpcVFnKc/lvmWvaxkKgapxbQcvdu6gI/AlfUqkWJ/tvWoqVrexmNwKkJfA58jKbYeQiYj0bmVF+0CEaMgI8+grw8Prj0Um7Sj3HBkiUcUVrKO2i2yhTg2PXruQ64Buit9/1fy5dzn9RP63yoCHc4pVOzO8fW8aEIOOjyyxlTXExDqY0diQMYqrK/LZyDE4njJ5OS3Hbbtm20a9eOe++9N2af1jFKkKHJgv8wCZ/IBAMsEcSjxLFLp+ZkGKS0Jo5wklSrBllZUFioKRBUzhM9BVMJsAvt4auGc5qQRKNfk31P+XGcWNuks+PEek323Xdf43N5ebnjy9ou+vUS4DzQJtnVnBNcuZE46VATx/YZ9JFObfjw4XzyySdMnDgx5ZORhM6bNZ2a1ZGSRHieFIXDhhKnKp1asKhsJA5A69atad26tXLdddddl+LeVAys17KW9DlXkUNYhXhSu7r1w3MbVTq1SCQaXCKgj1cbif7GakC5Jb9+OilxBMRkyQvxlQ5KnETXp6sSRxVQksrUrp4ggm98BOFUBDIhoCRRVClxko9MsEUikQh9+/Y1arns3r2bfv36xdSGfe+99yqiexWGdFbieIFw/CWDoAuSOPnPf/4TsyzdlDh+7UWBdK+JYw3c9UviOEX4p5rEUZ2TpJE4QInV54DmR1RBdsLvBvyGsLgF6wb1nhHnVezPTsvSB7gWTVF0AFqKt/eJKms2o9X4eZVo2rXpwLlo56gnWqq0Q9HIHG6+Obrzxx5j5bZtfIxWQ6hbJMKnJSXko9VE6o1EjqGle/s38CJwP9AE4LPPKN+1i3y0tG79gOP1tleiKYxUUBE2Kh+fDGvNnoeA6r/8winA98A5wHZJidMQjcgLoymSAGbq/Vr61lv0Xb6cb775xnTsIGvivPzyy/z888/8/PPPDB061Ha7ESNGcO+99/LSSy8lzd+QFCXO3oRUK3FSmk5NOOUL9SmKixJHDL6FVA4ljpdjBhn96scxEgSJ01DKR6qK5PFy7DvQXghMm+baNz9KnIqqiWMLH0qcW265halTp/quGREEKn30q3T+qxwnwSITnCV+MGfOHDp16qRUAm/ZsoVOnTr5UoBlKpwCSvIcCkHKUEXYu4018dgiyn1a06mFw+pUUor6fIWktj6fp4AAj9tDatOpOfXDaX0Qtogf+LETgiBxKmpcFOcoHA7z119/RfuRxqldZVSROFUIAplgl/Tp04cGDRpQVFREUVERvXv3pkmTJsZ38be3wSuJI6dUTUcSx4p0I3FUSAclTs2amrVZUUocJzsoXWriVJQSR7Vv1bJUkzh2sLufvcLpeluDuRKBlcRxQgmaKucTYAxaajX5nhtDtN6LTOAAvIWmALoWTV1UJkpYdO0KN99sXMubgd1ZWeSjlby4FC39mBUjwFDhXAdw+uk8P2ECq4DX0Qgc0GoP/QC0tPlNjkqcJUsYo/8OGeXl5Ub7I4Eb9OUrs7JojqayOXHHDuOcilxfS/LyjHpJM/X/xwAzv/3W2LcdiVMbOHDPHlqh1RequWEDO7dvZ7duezqROE73rXzdV65cCcD1119v2z5RpAWJ88ILL9CiRQsKCgro2LGja6H1t99+m1atWlFQUEDbtm2ZPHmyaX0kEmHIkCE0btyYatWq0aVLFxYtWqTcV0lJCe3btycUCjFv3jzffbcb5J2iX/O3bcPLsOjFceJmTPitywJEJ4mCvPFI4sjp1Kz9CjL6NWgHf7IcJ14G8Ysuushz+6AdC/Kg5paj3S761biv9cHKqW9+SJy0UuJEIr6UOAKidkQqkamOE8+TIkmaWgjatalCIEgHx2WQGDZsGJ07d6ZWrVox64qKiujSpQtPPvlkBfSsYiG7kvI2xJrzQQWUeNmvpzZiHBJKHHC0RXYSnehUw53ECbI+n5ffOGOGqpysevtEVMHy7/IyviYzoCQcDjN06FC++OILZX8ikQiffPIJy5Yt87QvP8f2A1XEYEWPhTfccAMHH3wwzz77rLYgDlukIhCoLZKk3zpv3jz23XdfRo8ezcaNGxk9erSv9N9V9fmqADBmzBhGjx7t+re3wasDuFevXsbnrKysuBQ8yYA8R5bfWZlM4qiuibWGcVAQx0pVTRynoFq3tipUtBInUfitiaM614HWxLHAT82VREkcN3ukIkgcp+1BU8uchZZa7l/EqpQ2Aa+g1fn5aPRomDEDJk6ErCxjLrMMGLH//pQDNxElhVR4UD/eKwANG1JYVkZd4B/gLn3dCjT1zw9Af6A90dTVHYAmb7wBZ59N8zFjDIIhHA7D2rXknXMOV6ApjnpKxxX3TRYamZQFbDjzTE6oXp0v0fznY9avp4s+XxWp1H6Vsiz8hkaC1URLyWecQ8t9nI+mNloNfLl2Lb8DvwM3P/MMZTVr8lP16oRvvJHGX39NfWk/dmSygVdegcMO4wBFndlkosJJnAkTJjBo0CDuu+8+fvrpJ9q1a0fXrl1tlQEzZsygZ8+eXH311cydO5du3brRrVs3FixYYLR54oknePbZZxkxYgTff/891atXp2vXrgbDJuO2226jSZMmcff/mmuuMX2/E/gSYiYdcvRrKBKhHmaklePEjxJHZyStShwrkqnESXSSbbe/VJA4Tv1wWh9E9Ku8j1WrVjlua+fUMNxjEoljh0wgcZTYs0eL/oaMcJwsXryYH3/80f/GIrpARMGlI4ljJcZSmPKtsqOinZVB4/vvv+f888+3XX/eeec5OtQrC5wCSnJtSByn9CEVlk6tqAiEc8eHKtga1Ru0Esfve+uEE07wvG8VieOUV1ruRyL2R9C2yLhx4xgyZAidO3cGYsf7zz//nLPPPpvmzZv76memplPz06+XXnoJgHvuuUdbUKXECQy9e/dm1apVXHXVVVxwwQVcddVVMXM6J1QpcZKPTLBLmjVrxoABA5g2bVrCas7KBK9kjOygTdRZGyTs+hUEiZMs4kQgHdKpiXOWKhLHapM6KUOCInFkJKrEiTflnApu46b1WP/884+yj34IVdX5vu+++xg8eLCyvV8lzhNPPAFAq1atPG8n4HQ+4rGX7RAkiQNaWrX/Q5vXOKE0JweOO87w38jX8p1GjShEI0jcMAVN3cOqVdx60kmcgpbu7VF93ZHAV2jzyP+h1fvZjkag/AQc8NJL8MknHPD660xCU7xk79gBZ55J1t9/swvIRqsJJIgckU6tP3CU/pv/uekm1ofDnIGmBMoBhi5dyllESZyfpXErjJZ6DaALGAG+shLnNOAXNMVRPrA5FGI9sB4ozcqiFnB8OEzW889zzNNPsxb4Ga0+UciJxPnrLxgwAH77jYHffMO+5rXsByCpg4JEhb8tn376aa699lquvPJKWrduzYgRIygsLLRNRTR8+HDOPPNMBg8ezKGHHsrQoUM54ogjeP755wHt5D7zzDPcc889nH/++Rx++OG8/vrrrFq1iokTJ5r29cknn/Dpp5/y1FNPxd3/KVOmmL7fAJwCFEqkEphJHICGlu9uJE68xYQjkQgrVqzg008/9bxNPEqcEsxKHOsLMkglTtAkjhVBKXH8Gi1+fkfQJI7by9TOcWKQOBIJ5CVS2C2KJl3SqUUiEbMDIQ1JHGsk0IEHHsgxxxzD0qVL/e1IOE7q1NH+pyOJYy0Sl4bXI1NR2ZQ4K1euNNI5qFCjRg2Ki4tT2KP0QJH0rKlq4niNWEsJiVNaCsI+KCwEUWNA5cBWqILdUrtanQtBplPzstytXSpVwfE+/17a/vXXX47r586dG9fx/JBNfvadDgEltvZahihxMiG1qxwJ/PXXXwNapgevqCJxko9MsEXGjh1Lfn4+N9xwA/Xq1aN79+6MGzeOzZs3V3TXKhReHcBBq1yCQrKUOGPHjk262siPEiedSRw/6dSs9pvT2OHFfg2SxLFTeSdLieOXxDn00EOVvzcRJU5paSkPPvggTz31FMsVNfz8kjiDBw9m9+7ddO3a1fN2ct/sYPVJJoJE9xMvkWc9rny/lZeX29bmsUVWFr/XqMHXaASJwFo0kuRuNDJnPRqRUBPYCqw77ji4807K8/M5E02x0/XZZ2HuXML16tEeTekjiJzBQJ2PP+a0v/7iYf0YdwF76tShrKyMUrRaN+/m55MLvAucqrebZ7k3RUjmUwAtW8Idd9BtyRLeBJ6bPJnPgIOBlWhp4VrWq0d9oD5w45VX0gatPMQzaOQUQFvgAeBBaa5serYiEejXzwiCrr17N++hkUQAF6KphDjpJBg1yvZ0x4ukkzi9e/dWpjMBzYCeM2cOXbp0iXYoK4suXbowc+ZM5TYzZ840tQfo2rWr0X7JkiWsXr3a1KaoqIiOHTua9rlmzRquvfZaxo4dS2GhuwleUlLC1q1bTX8qNND/Z2/bxv/93/8ZEmovJI6X6Fc3uajqe9OmTenatWsM4WS3TaI1caop9plJSpxUOk6c+uG0PmgSR1yD0tJSunXrxtNPP+167CykyWtlVuLI932aO07k3/L777/72zhFJE5C19aqxEnTXPmZiMpG4tSvX5+FCxfarv/jjz+oV8+qia18sF5L2RbxqsSRHQLx1udLKLUraPaIB1tkF95JnCCUODKSReJ42Vc6K3GssN5f++23n/F5l8uYbhdQcgLwNJjujXgDadIxoMSADyXOe++9x+WXX87OFNktgb1DMqQmTs0qEqcKwCmnnMKwYcNYtGgR3333He3bt+e5556jUaNGdO7cmWeeeYbFixdXdDdTDq8OYPl9kEwlzhlnnOGrfbKUOEcffXRC23uBXR9TWRNHJnHidU57UbDYLXNS4gRB4mRlZTn6VWTYpQ5Lln2hsuNlWH/brl27lOfaz71utTvlY6gyIfkhcYx0WPn5cY0RmarE8Qqnekrx7tPuni0DHkEjUwQJ0hbYB5j3wAPwyCPMePJJlqKRJo3++gtq1mTb22/zJ1rNHUHkPAEcPHQo18+dSxEa6fMS2vkTvyEM/Lt6db6uWZNqaOqeMFGiReBlYCKaqIBFi+Dxx7l+4UJ6Ag137KAMeBYtHdy7gHyFyoBfgXHAQLS6O/WAf+vHunznTnQtvPlcjx0L06drCqhp09iWl8cxaKqnR/TjGHPu225Tns9EEPjb8r333uPwww83vr/44ou2jpL169dTXl5uKrAOWsH11atXK7dZvXq1Y3vx36lNJBKhb9++9OvXj6OOOsrT73r00UdNBQqbNm0a06YWIASyoS1b6N69O1dddRWrV6+OIXEaWL57VeLU2roVfBRjlvcr8pE7tQHirokjpzBxI3GCrImTLBLHyzGsk9aKJHHctneqUyQG+QkTJvDBBx9w66232u5bbJdXXh4dQBKoieN1fbLgetw4SZyKcIQndA6FQVW7tvY/hanKqpQ4FY/KQNzI6NKlCw8//LByXSQS4eGHH44JCNkbINsiqpo4Knipz2dFPMEWtrZIVhbk5fmuz+eFxAmyJo4dUq3E8XNMVftU2iKRSMQU6KWK2PRy7PvRJl98+KHnftjtOx1sEVv4UOJcdNFFvPHGGwwbNizBnnnDXkXiRCKGEj0PNNVgFQJHptklhx12GHfeeSezZs1iyZIl9OzZk+nTp9OmTRvatGnDpEmTKrqLKYOd2uTuu+82fU9VOjW/ZEWySBw/6oZ4kQ5KHHGeUqXEsTqrnZzzyUqnZgc72zKZJI4T3GrixOP4t5JmbvuItyZOPM+f23lOx5o4iWxnVeLEA6/zofXAAjQiRJzHzS1acDRaCrbd1avDhx+y57DDAI08uQ64F03Ns/Hoo/m+USPGoilhwsQSvyXhMP9p3pyv9O8LgS2Wa1YMXIBGvkTeegt69mRG/frcDTx22mnUA24GhBfJbe63AS1l3AD9+1DgaqLXth7AoEHayvvugy5deLpjR8qBvmjlVUBXBl10UTSrRICI62350ksvcfHFF3PZZZfx/fdaFrrPP/+cDh06cPnll/vK+V0ReO6559i2bRt33nmne2Mdd955J1u2bDH+VBNNmZgJbdlifN62bZvhOBGVfqxKHBVUSpxbJk+Go46ikcd+x+U4sSpxxH+XmjhyOjU/SpxEyY50UeJ42cYtGsBrP4OY2KgikLdI963bsavJLwaXmjp2+5A/uxloyYLrNUnzdGoyAklhks7p1KqUOElDZVPi3HPPPfzyyy907NiR//u//2P+/PnMnz+fCRMm0LFjRxYsWBDjTKiMsF5LWRedtWdPTICJ18lfStKpyQEloZDvdGrV8EfiJKsmTrzPkx9SIVElzkUXXeR6DNX6RJU41om/HxJHVuLUEQv/+SdmvVekisTxcp/YvhPjqImTqrSRSSNx0tHu2rWLbMv3KgSPTLZFGjduzLXXXstHH33E+vXrGTp0KPlSMebKDjsS56GHHjJ9l8e6ZKYZcyMrGjVqRL9+/YzvQaRTe+CBB2KWpYLEqew1cVTjgorEsUNQJI41IMXumF7SqQUJt3FTZevKy8RnP/e61Zazu3YCftOpqT57hdv5SBcSJ95+OKVTizfDgB+SzdqPcDjMeuAs4NVHH4VTTzXPUYCH0NQ88x9/nIeOOoo+wCJF/0E7r7tDIc5FU+8MwP53bQda3Xcfl2dnc1+7djwC/L7vvli9m14D+F4Ehum1hl4CRv3zD+PQVD9s2ABt24Ie+P5Lgwb8R99uB9ADLWUco0fDIYfYHiNe+H4SHnvsMW688UaWLl3Khx9+SOfOnXnkkUfo1asX3bt3Z8WKFbz44oue9lWvXj2ys7NZs2aNafmaNWto1EhNUzRq1Mixvfjv1Obzzz9n5syZ5Ofnk5OTw0EHHQTAUUcdxRVXXKE8bn5+PrVq1TL9WVFf+pwlOcOz9IJJACIzuJeaODLC4TAhoNHWrVBWhtdbIWHHifzfpSaO13Rq1hd6orVjgjbyE0mnZv1uRVAkTjxwkv26OeZUjpMCue2mTcYk1u89Jz67nbtkIVlKnIqAJyeQHYTjRChx0tEpYSVx0vx6ZCoy2XEicOCBB/LZZ5+xY8cOevTowRFHHMERRxxBz5492blzJ9OmTTPe/ZUBN998s+n7LWjS9GwLMW+1XKyWluraqwJK4qnP54YgbBGrKthJgWqddKdrOrVESRwvx5cDOCqSxFnpkprVzk4w6vOtWKFs6wfpGFBiQJA3afjus94Xf//9N9OnT/e/I2GL6BPntLRFqlTBSUOm2R9lZWUxDsk1a9bwwAMPcNttt/Htt99SWFjIBRdcsFepf+NJp1ZNBI0mAXl5eY7rCwsL6dy5s/E9CCXObYoUOnuLEicIEkeGXyWOUzq1ZClx/JI4qbQvZLgpceIlcVQZXuwQL4kTtBInnqAnOyRK4iR6XAH5WsZDxkB8mQlU80Pxye4aqMYHa5/Fs7wNuB343KV/f/75J2+88YZxHVTjoXyN3H7r0Lw8RqGlgDtu504uA04ALbhw5EjQx9BwOMwzwGlAG2CC2EHNmjB5suMx4oFvEmf06NGMHDmS2bNn88knn7Br1y5mzJjBX3/9xR133EGdOnXcd6IjLy+PI4880mTkh8Nhpk+fznHHHafc5rjjjouZFEybNs1ov//++9OoUSNTm61bt/L9998bbZ599lnmz5/PvHnzmDdvHpP1EzthwgTb9CteICtxsqSaOVlZWUa0qx8Sx+o4qQtk6e32tdkuHsdJzINlVxNHNZGycZx8+umnnHTSSaxbty7mGNYBs6JJHLv9Jeo48ZOWzbrOzZmUqOPEznnlhcRRKnHAUOPES+JUlBLA9Vjyfb9rF1SQ0eUFTmqncePGsWDBAvuNrenU0lGJU4GOkw0bNnDGGWfw5ptvpuyYqURlU+KAFpixYMEC5syZw/jx43nrrbf46aefWLBgQUrykqcSY8aMMX2/FjgaKLKkX7Uqb/ySOOK9Fo8SZ/HixYwdO9bTewaIm8SR06m5kThBplNLVxInURsrqLZ228v7cJvY2ylxDBLHQ2pXt32nQ0CJcl15efQ97UOJkypYr81BBx1Ely5dmD17tr8dVaAq2DOqAkqShkyzRa699lpuuukm4/u2bds4+uijeeGFF5g6dSqdOnUy/Axe8cILL9CiRQsKCgro2LEjP/zwg2P7t99+m1atWlFQUEDbtm1jjhcKhZR/Tz75pNGmRYsWMesfe+wxX/2W4ZWskB1sySRx3MiK3NxcUxu5//E6kVXOw4okcSqqJk5FkDjJVuJYa+I4kQHpXhMHzHVr4iVxZMh+LNXvtJ4TkdlJhURJHDfbKl2UOPHCSYmTShJHlW5bnAu756m8vNyVxCkvL485p176FxSJE45EuAaNuPlPw4bcCjwOMGECdOwYbaf/js+Bpdad1K9vXZIwfJM4y5YtMyIVTjrpJHJzc3nggQeoLtJc+MSgQYMYOXIkr732Gr///jv9+/dnx44dXHnllQD06dPHlPbs5ptvZsqUKQwbNow//viD+++/n9mzZzNggJa1LhQKccstt/DQQw/x4Ycf8ssvv9CnTx+aNGlCt27dAGjWrJmRn7ZNmzYcokucDjzwQFOBVb8wKXEkEicUCnkicawDk9VxIu+/iU0fnAgOu4EvEcdJxCaFCcC3335rXDsnx4nfwbMiauLY9dE62XCbfEQiEU4DjnXoz9tvv01BQQHvvPOO47H8IjsS4XqglaKvRgExD7/TUOJYiSaXCFq7/aUTieOqxIG0cyhYjUgVJk+eTO/evWnbtq39jqrSqTni/vvvZ9q0afTq1Stlx0wlMs1x4gcdOnTgkksu4dJLL6V9+/YJ7cuPc+XUU09VOk7OOecco03fvn1j1p955pkJ9RGiQSXZ27bxyiuvcNdddxGJRDwpcZxskUTSqR144IH06dOHkSNH2rYxwWqL+Eyn5qUmjh9D3q3PdvZWRZM48ZIZXtb7aSvgpMQRtkhZWRmnnnqqYdu7HTsIJU462SLKd2Kap3a1O29z5szxtyNhi9Stq/1P0ns+oWtbpcRJGjLNFvnuu+9M6Shff/11ysvLWbRoEfPnz2fQoEEmssQNEyZMYNCgQdx333389NNPtGvXjq5du7J27Vpl+xkzZtCzZ0+uvvpq5s6dS7du3ejWrZspaKu4uNj09+qrrxIKhUz9BnjwwQdN7W688UafZyMKr2mP5LGuQKjvkgA3siI7O9uk1glCiaMibNItnZqbQileiHNWXl7Or7/+mvD+/JI4TkocL/ZrJitx3MZN1W/buHGj8TmIdGomNYbieNaAHafxIpnp1Oyu28iRI33P9yuKxLEGfsvf4w1OSySdmny9b775ZkpKSmzv9fLy8pj7w3pvqJ5lL5kTnEgcPwF8on8zgA9q1uRp4A6ASy5RHi9V8J18tKSkxPSSzcvLo64wtONA9+7dWbduHUOGDGH16tW0b9+eKVOm0LChRnMsW7bMdPKPP/543nzzTe655x7uuusuDj74YCZOnEibNm2MNrfddhs7duzguuuuY/PmzZx44olMmTIlqcYBmEmcbMnAzyovRxw5ESWOrPTZV9FGBS/GcMxyOyWOS00cWYkjIF4KiUSJ7ty5k+eee47zzjuPQw891JGoigeJOE78kjhs3sxktFyJ1qdGtL/00ksBuOSSS/jtt9849NBDPfXH7Twc/M8/XAVMxV726keJUxCwEicRYi8R+CZxdu6MOhM97jdVsDumJydKikicTHWcbPBYBD5TkUjkfjpikCg46IKnn37a8z6Fc2XEiBF07NiRZ555hq5du7Jw4UIaNGgQ0/69994zGcIbNmygXbt2XGIx/M4880xGjx5tfE80b34OetFFIHfbNq699loALrzwQmpZnr94lThNN24EB1Wa03v6q6++MuWetz22HyWOPl4lUhMn0fvezgnvdb9eAkoyjcRR/QbruVHVJfr888/56quv+Oqrr3j++eeVxzOUOERJnMiKFYQUbf38lmSPhZ5tcSvk+z7NlTgJveettkg6EiRVJE7SkGkkzsqVKzn44ION79OnT+eiiy6iqKgIgCuuuML0fnfD008/zbXXXmsEs44YMYJJkybx6quvcscdd8S0Hz58OGeeeSaDBw8GYOjQoUybNo3nn3+eESNGAMSkqP/ggw/o1KkTBxxwgGl5zZo1bdPZJwupInHc6u2EQiET0RNETZx0U+JURDq1b7/9lm+//Tbh/fklcZxIFS/vdbc2fmri2DnEK6omjuq469evNz4HnU5N5XC3OuqdjpXMdGp26+vWrev72RDXOdXvLev1TCclDmi16C+++GLbbaztrfeGSonjx75XjXt+SByv88RU+07iqiB37733UqhPpvfs2cNDDz1kGCsCfhwjAwYMiIm2E/jyyy9jll1yySUxThAZoVCIBx98kAcffNDT8Vu0aBHIAye7cHKkiPFsybiPl8TxqsSxwu8kFojLcVJCrBIHogNLIo6TBx98kMcff5w77rhD+ZIMerCMN/rVyzaRNWvIA/LQzpPsJle1b926ddzRodYXXS39nmyMc/SrCippZKYrccrLywmFQu7HspIZaTxZT+i8ZUI6tQpU4mSCMyERVDYSZ+7cua5t/E4G/DpXrAEu48ePp7CwMMZ+yc/P9+w4KSkpMRm4WyXVr0A96bMcULJlyxZDFbwSLRgk3po4A77/HqZN43DgZw/9jmvSnOSaONb3YJAkjpflbkhmfb5E4CegxK8SR9xfdmnVVPvOLS+PFplfvRpKSyE319P1dAsoqSgljhLW+nyRiJaTO02QNBInzdTPQBWJk0RkGolTUFDALukenTVrlkl5U1BQwHar7WqDPXv2MGfOHFMGkqysLLp06cLMmTOV28ycOTMmaKVr165MnDhR2X7NmjVMmjSJ1157LWbdY489xtChQ2nWrBmXXXYZAwcOtCU/vNgiXiA7aJNJ4rhF8Ofk5ASuxFG1rUglTkWkUwsK8ZA4dki1Eqci0qk5IVkkjsqvZP0sYD0nTveLfK5TlU4tFAr5vod36ME1Fa3ESZTECYfDCSlxrOdzyZIlvtKpvfTSSzH7jeecOilx5P15VeJYt3PaZyrgm8Q5+eSTWbhwofH9+OOPZ/HixaY28TxglQEmJY5ksIX0z7uAVfqyBmjRg/LldkthoiJx3AgN+cHwnE7NRokT2bmTmD0oHCdeSBw/jhOr4ZrRShzJyK2JO4njdCw3WNsU6MZ2LeCqq67ipJNOMtaprtPTTz9tTAxU1ytGiaOTOEFEvyZ7ICwrK+PQQw+lqKiI9957z/a4kUhErcRJI/i9T21hdZyUlWl/LtFrQSBuEieF1yITnAmJINMcJ2744osvAt1fPM4VK0aNGkWPHj1i0s9++eWXNGjQgDp16tC5c2ceeugh9tlnH+U+Hn30UR544AHH45gCSmRVcFaWkU7tT9QkjgoqEqeBPlk5GDWJk0jUlAFhiySQTg1g+/bt1KihaTWCVuIENv4q2qlsES8pT71u47UfTuvd2npR4vgJKFH9rnxpAhaKRDQip2nTuEmciiK05eMq34ny+y4c1gIvPDg9UzWe250338fPhNSuFUzilJSUkJeXVynn25lmi7Rv356xY8fy6KOP8s0337BmzRoj7TzA33//TZMm3kIv169fT3l5uZGNRKBhw4b88ccfym1Wr16tbL969Wpl+9dee42aNWty4YUXmpbfdNNNHHHEEdStW5cZM2Zw5513UlxcbBuU68UW8QL5Hk5mTRy3ZyUvL89WieOFxJk4caKRtt8JiZI4+++/P0uWLHFs40eJk+x0akHBL4nj5Pj18l53S9dk/X1OJE4mpFNLlMSx/n4nJU4kEolbiRPPfeV0nu2uW1ZWlu9nNV1IHPl7vGSMl3Rlqu1A/Sw6pVOzrvv6669N3+2INq/9CSqdmuiLwOeff87xxx9vBB+kOgDW95Pw5Zdf8sUXXzj+ff7558noa9pDdpzkys5G3djfBoiMtjmY02lFIu41cVTp1NwQl+PEJvp12gcfcNlll5nb2kS/CgShxLHCa02cIB0nXqNfXSNUt2wxPlsLTLv1t5o0yMTzghAkThEwbtw4peNEHqhuvfVWI7pM9bvs0qn5dZz4cVQFhb///pu//vqLOXPmuDPsGUTi2DlOfJE4QokjL0syMsFxkgnOhERQUY7LioSfgttOzhU7Z4mMH374gQULFnDNNdeYlp955pm8/vrrTJ8+nccff5yvvvqKs846yzZq6c4772TLli3G3/Lly2PayD2UVcFZWVnGe+dP/b+XmjgywuEwhUA1vX92tkggJE6cShyZxPnhhx+oWbOmoerOdBInKFvESz9KS0uZPn06Oy3n28++Veu9kDheyCrxuZp1sqnXxcmEgBK7vijXZZAt4nSfXnfddbz88sv2O0pRTRwVMsEWWbZsGQUFBfTu3Ttlx0wlMo3EGTJkCMOHD+fAAw+ka9eu9O3bl8aNGxvr33//fU444YQK7KEZr776Kr169YpRvQwaNIhTTz2Vww8/nH79+jFs2DCee+45W1WkF1vEC1Tp1D777DM6deoU1/68HEeF3NzchNKpnX/++Z5IqERJnC+//JLffvvNsY0fEsctzVy8SDWJ49U3ZLe93zaqdGp2sHMSJyudGjj3x6p0AExqwXXr1gH+lTgynJQ4ZWVlMf3zWhMnXiWO0/6DUuKIc1jRJI58v8WTFq28vDwuEkfl8xXf7e71jRs3eupjPM/KN998AySuxLHzrZ122mlGunLrulQg2BF2L4eslMmVIkVDEolTCpTo0aSyo8XLRNdLOrVAo18tSpzybdt46623zG11hteah17ut/UYVgeD24vSOmB7/Y3xOk6U5IuHY3j6XZISp4ZllWN/v/qKke++y/1e2tqsL9CvVS1FG7uaOKoibeJ3CceJMXWNU4mjkl+mi+MEiDudWkVEvyZ0TGs6NXB1nqR8gq0bSMYVqEqnFhgqK4mzfft2U6oTgHnz5nHuuefSsWPHlPVj1KhRtG3blmOOOca0vEePHpx33nm0bduWbt268fHHH/Pjjz8qU8mClnqtVq1apj8rTEoc6Z0jkziL9P9e0qnJBrBVFbyfspexqAgSR7ZFbr/9diAxVbAbKpLEcbJF7LZ5EHjYYV933nknXbp0oUePHp77bF2mOqc5JSV8BFyD//p8KtItzxppqNsi6ZpOLe77xHrfp1ldHC/33Mcff8zIkSO5/vrr7XeUgfX5Iim8Fv/73/8AeNOhJlkVUodTTjmF2bNnc9NNNzF69GhGjhxpWt++fXsGDhzoaV/16tUjOzubNWvWmJavWbPGNuVqo0aNPLf/5ptvWLhwYUwwiQodO3akrKyMpUuXKtd7sUUELrvsMn7//XflOlU6tdNOOy3wgGAvSpxE06l5cTAnSuI0a9bMqJXrtx8qZ2bQZEuy9utmVwRdE8f6HFvhJ51aRShx/O7bGqwDiZE4TkocFTGczJo4bsFpdj5Yv89qRZE41ns/3ZQ4qvtRXI9rrrmGGTNmuO47EcIz0Zo4MqzX9o033lDuMxXwPcK2bt3aKFYPcMMNN5gkeGvXrjXq5extMClxdu0yTq5IpyZM/t16/SA3EkdGeXm5af8FQB0PfQrScaK8qvpkq4TUKXGCJnGsSGU6Nbt9xWD2bLIiEbo7tLUe2/rCqqa/NLOB6pjPezzRr/n6tRV1noJU4qTyBViZlDjyZ9+GjnCcFBaCmMg4OE+eeOIJGjduzJ9//mnbxiv8Rr8a09UqJU5gyLToVzcsX76c4447jqKiIoqKihg0aBA7d+6kT58+dOzYkerVq3syHAXica4I7Nixg/Hjx3P11Ve7HueAAw6gXr16/PXXX65t7SDbCnJNnKxQyCDxBYmjqs/npgqWt0mpKthjOrVk2SJr1qzhiCOO4MUXX1T2N1m2iJd9+VbibN/OvcBdRAM7rO2fffZZAD766COjQLZTH1RQtW2yeDH/AgZir8Sxm7CpfldMfT5diVOp06mpvlcwvLxD5PmjLawkTmmplto1BYhXiZNKEqcyvJ+dkIm2SOvWrbn55pvp3r17jPP6uuuuo3379p72k5eXx5FHHsn06dONZeFwmOnTp3PccccptznuuONM7QGmTZumbD9q1CiOPPJI2rVr59qXefPmkZWVRYMGDVzbuuGUU06hVatWynVe0qm5paO7/PLLY5bVlgPScCcVnJQ4iTqRZSRC4ng9th8lTrJSMqaaxLE6nZP97vaTTs3OkZ4sJY5TX+ygInH8wA+JozofXpU48aZTc7LPVfdKPOnUvNY+CxpOSpx4EK8Sx64mjiqdWn5+vq99x9MfgUSVODLcUvOpMG3aNM/79wPfT8Iff/xhOpFvvPGGqZhdJBJhd4pS8KQb6lm+F4kPurEvztIuPVolESUOqJ0nXp0Kjm2sShz9fwyJE4mkpCaOW38rMvrVt+PEgcSZP3++fSf1e6gVmoPO7bepXuAFUuRDLcyDlh/HiVWJY7jwV64Ej9EfbiROEMbXypUr6d+/v6vs3PVYcSpxUgW7e873RFiM2/n50WffgcS5/fbbWbNmjW2+bC/9FfBbE2ed+F6lxAkMlU2JM3jwYHbv3s3w4cM58cQTGT58OKeccgq1atXi77//Zvz48b6UOPE4VwTefvttSkpKPKW/WbFiBRs2bDClY/ELu3Rq2WVliDjTP6W28tPnN6AkHiWO5/p8AaRTEwjCFrnvvvuYO3cuN9xwg7J90LaIilSIJ6BE+bs2bzY+FllWqY7bv39/22M5QXXsfP361QZ+/vlnVxJHVtKpfle+dQKWYenUvvrqKz777DPHY0UikbiVOKl6d/m9T21hJXEgpe96T6gicZKGTCNx5syZQ6dOnUy+EIEtW7bQqVMn5/mdBYMGDWLkyJG89tpr/P777/Tv358dO3Zw5ZVXAtCnTx9Tbb6bb76ZKVOmMGzYMP744w/uv/9+Zs+ezYABA0z73bp1K2+//bZShTNz5kyeeeYZ5s+fz+LFixk3bhwDBw6kd+/e1KnjJWTUGU7vVpUSx4opU6ZQv77VCxKFajtrMfRk18RxW6fql194rRlk1w/Vsa3nv65IY5kg0iGdWjLHj8qmxLFmLIDkpVNLtRLHqSaLHcETCoV8pxpMx3Rq8SBREkdVE8e6TB5rvSBoEicoJY7dPmWcccYZnvfvBwmPsAk55CoRisBwjgh+ubb+P0aJEweJY01hAlpKNS/OfNX+7NoA3pU4ZWWE9BvWLoWJSuHhN/rVCq/tU0HiOBFKbiSONZ3arbfeal9bQZownqRuYYLqHMkkThHmF7ZdChMnp0aBlcQpKYGNG9PGcXLhhRcyYsQITj75ZMd2rqlTMij6NW6DMBKJplMrKHAlceT7xFojJKnQnwNRW6zKcZIcVIbf+vXXX/Piiy8yYMAAxo8fTyQSoVevXjz//PPst59X6sEMv84VgVGjRtGtWzf22Wcf0/Lt27czePBgZs2axdKlS5k+fTrnn38+Bx10EF27do2rj2Bfny9XCrBZrP/PAeReebFFvNTnCySgRIy1ltSu65Yt47vvvjO3dSFxgrBFdljGm4wOKPFQn8+PMtcOqvV5+nUtQkub40bi1KpVy5j0q45tR+Kkazo1GWVlZZx66qmcfvrpbNq0ybnx3mCLgLo+X4pInColTsUj00icYcOG0blzZ2U6saKiIrp06cKTTz7peX/du3fnqaeeYsiQIbRv35558+YxZcoUw9ZetmwZxcXFRvvjjz+eN998k5dffpl27drxzjvvMHHiRNq0aWPar7CDevbsGXPM/Px8xo8fzymnnMJhhx3Gww8/zMCBA51rV/mAU8CMqiaOwE8//cSHH35I27ZtHVULqqhueb/W+iV2+7BLp+ZWE8er0sq6X7/wSuL4UeLIbUeMGGEEqSSCnJycCk+n5qS+CAKqmjh+SZxkKnH8voOt9i2kNp2a0/1iJWT9wuk8l5eX2ypx/JI44hxWNImTCOEBiadTUxGq1mXyWGsHayrveJEqEifV1z051cz2QginxlY0smZfJBJHf6iFya9S4oTDYdcUJobjpEkTWLXKti6OjLgi42xq4sSQONIg7DeFSSKTvVQ5TrzsK0glDsCiRYsUSzFNGE926I98bOv9ZFXiyCSOnRJHRbCI31ygt90IROrWJbRxI6xaFbcSJ2jHyQ8//ADAhg0bHNs5pVNTRr+msePEi5JKidJSjcgBM4ljo6r8559/jM/NmjXz3lkb+FXiyCROqkIGfN2TM2bAFVfAM8/wfzt2cM899/DOO+9w+OGHJ6+DCSIwB1yaYM2aNey///4ANGjQgMLCQs4666yE9tm9e3fWrVvHkCFDWL16Ne3bt49xrliNxYULF/Ltt9/y6aefxuwvOzubn3/+mddee43NmzfTpEkTzjjjDIYOHepbai7DlsTRx/xtaMEmJbVqkb91K40AkRTXjcQx2SJ4T6fm970A2KZT++3HHzn1xBPN7fWxahfqgJIgbJFU1+dLakCJBxJHud2OHZz7/ff8APzk0B8B1TkVJE51tEmI/N5SBZSUlZWxePFiDj30UOX1iiFx4qyJo1qWjLFQ3r88eZRTjXlKp5aBNXE8QU7tWlCgfU9TEieMFg1ZReIEh0z7fd9//z133HGH7frzzjuPUaNG+drngAEDYpQ0Aqp6eZdccgmXXHKJ4z6vu+46rrvuOuW6I444glmzZvnqoxf8888/LF++nA4dOti2kcdAK4nToUMHY1snJ57KISjbYl5IHK/p1GScddZZ9O7d2wi6ueSSSxgzcXP7YQABAABJREFUZozjcRIJdLZTKnk9hup3WO27IAKx04HESfY4kp2dHfPOy2QlTipr4qjSqXlV4sRzXzmNHXYqnUyqiRO0Emfnzp1xkTiqeZb47oXEyc3NNfVdvieCVuLI8FM3yOm5SrXvxDeJo5Kk7o3KGyuESmYdGqFhInEsSpydNbUps5XEscL0Yi0ri0bLtm8Pq1axL+7nPqHoVzcljuTgLcGf4ySVNXH8DqZ+lCFOL3DlNXUhcVT44Ycf2PbBB5ymfz8F2OiBxLH22arEkV/YdkocJyeSIHG2A+EmTcjeuBFWrvR9zyUrnZpXJCudWtAv8aVLl/LWW2/Rv39/U67nQEgcmazxkE5NrtcRxPjvdR+R7dsJESVxgnLshMNh5s6dS5s2bWyd576u56RJ8Ndf8P77dNcn7z169HBN7VeRqGwkDsQa/l4if9zg17nSsmVL23unWrVqTJ06NeE+WSHbFtmlpRSg2SU5+tgl3kK7a9c2SJwFDvuzKnHk/RegKXmsVHmgShwbW8QUrBBHTRzrxCJZtki86uFUKXHsauIot5s0ibPnzqUOcLxDf5yOnSeN20WYozLjSe0qSJyV6KSij3RqquCRilICuB4rgwJKvHy2hbBHRECJC4mzePFiJk6cyHXXXUeNGlaNu7f+CvglcTagz/+q6vMFhkxT4qxcuZKaNe1ndDVq1DApZ/YmNGvWzDXQSx7/nZQmTu9RFbkhP8teSIW8vDyTjSjfe3bbVqtWjcsuu8z4/txzz7mSOInAK4lj11/VcnlZUM9bbm5uhZE4oVAobv+PH2RlZcUEgdodz85J/NRTT8Usszqy44Xf3x40ieM3nZrXmjjx+BycCICg06lt2bKlwkmcRJU48War8JNOTTUfz8vLSwqJ40bG+dm36tqGw2GysrIcr/v999/v+Rhe4XuEjUQinHbaaRxxxBEcccQR7Nq1i3PPPdf4fvrppwfeyUyAiExdC2zWP9fW/2fpxr5ViSNHs7pNJorKyzFuQT2aW6XEcXIqeE6nJiZLFsdJjGmlT7T2ABG818SxDpjJJnHc9h9U9KtfJY7XqeZxxx3HrrWG25q2QLbkgFFBmYdectTXwvzCtnOcqFQyhhJH32Y7ENYLe5cvXx6XEueJJ54wFf5K5QvQSYkDGJNzo5WfiMuJE+GNN+Lum4wTTzyRu+66KyaSLhDnu2RQvTpuHGXi5WrjOJHrngXh8PdklJWWEtL7KUrLRwJynDz77LMcddRRXHrppYHsz3CQSveKKt+wE/766y86dOjA+PHjg+mTCzLNceKGSCTCIYccQt26dalbty7bt2+nQ4cOxnfxVxlhLUNcW/8vlDgGiVNUBEAjqa2JGNHhlE4N1HVxArFFPJA4BlJQE8cKp5o41jQb8SARW8RV2eoQUOLY3/WaZutoNBvGTcnihcTxYouo7DmxTJA4f4gVK1eCQw50t74GPRZGIhEWLFjg6phxfUYqQU0cT7CSOOBIkrRq1Ypbb72VJ554Iv5j6vBL4hi2SJUSJzBkmi1Sv359Fi5caLv+jz/+oF49a9XcKgjIDl2nQBu/6dQSVeLIx/Nqs9SoUYMLL7zQtOyuu+5yPK4fJJpOTeWUltsGpcTJzs6uMBJHdtgmMyAtiHRqKgQRbLZo0SJf6gJQkzh+YP3tftOpJbMmzvvvv2+7rqSkJLB0amPGjKF27dosWOAUFhc8glbixAu7dGpelTjWZalS4iSaTm2zXmPUabz573//6/kYXuFbiXPfffeZvp9//vkxbS666KL4e5ShkJU44laprf8XShwxZY5HiVNXv3m3ZmdTq3lzQF0TJ9Ho102bNlFt0yYKwD2dmuQ0AX/p1IKsieMWmZpMEifodGp2x5DbZgFFCxZAt26226gccU41cfykUzOUOPo2O4DyRo3IBYb268cHHlJGyfubPXt2zOQ7yImbGwPv5OyKRCIGkbEB3Tnq0dDJKS2F7t2hrAzOOcdcpDcOrNRTxEyePDm2jzrizhkqCNlQiKuvvZZj69ShNdiSOPI5e+KJJyguLubee++N79heIaWFWic+BKTEefrppwH48MMPbdv4uifFcy712a/hee211zJv3jx69uxJjx49fG0bDyqbEmf06NEV3YUKg5VkqQOsJlYVvEtB4rjZIqWlpTH73xdwK9vsVxUB2JI41aX2hnEeJ4njxxaJ197yOnbY2SJe9uWbnHJIp3bxxRebiHoT9LEtBzjRoT9Ox86X3qFeSRwB1e/K050Vi4DOoRCh0lJYvz6QmjhBjIUvv/wy/fr1o0ePHrz11luux7ftZ4YqcXwTmioSx+FdLybgP//8s4/eJgiJxGkDVUqcAJFpv69Lly48/PDDnHnmmTHrIpEIDz/8MF26dKmAnmUGZIeuk52caDo1N4dsXl6eLYmTCCHx8MMPU7t2bW677ba49yHgRuKI82d3HlXzYXlZgwYNWKErWRNBkOnUDjvsMH799VdfJI6wI5I5lmRnZ5ucv07H8kOo+C34rkI8JIKKxPHjOPejxFGdD69KnHjuq6+++sp2XVlZmW16N7/p1CoKQStx4oWdEicSiXhW4li3E8q6oGviyPDzfNqROHXr1k257ZIwiVMFDbISR4hda+v/rY6T7Xpedz8kTm39RbEpN5da+2pZ6L3kovc7ib333nt5WhhUFsdJDpCLRBDo7cRUXwz/2Xq7UtRpuhKNfvXrOHF7qIJS4njZJiTVtvFK4shtlwNNgSLFZNXxnO7eTY5cKBgolibFTnks7fatUuI0DIeZN2+e6++Rj6NKMxDkQOiU5sDaFyV0w2Y9/kicuuvWgXgxrF2bMIkjYFV0eHmWXM+nqCeht1u5aZMjiZO3YQN/Aa8CjyxaxJAhQ7j66qtp0sS9UpfyufBCcOjPzm7AcD8GFP0al4PZCYLEsRQ/9oMtLmq7oFHZSJz999+f448/3nckVaajFlEbZBVasIcYebKsASW6KtiqxMHy3ZbEKSyEnTuVShwr/AaUaB1U18QR5IyJuNi9mxBmEsdvale/k4RUkTh+x3hPASUOJA7AxIkT1Z2UxrROdvu26ZdAvkWJs0thi3ghccTnPN0W3QSE69cne+1aWLHC9z2XLCXOAw88AGiFxd966y3b6+l6rDSviWNHfvk+hz5IHNkB3KpVK3/HUSBeJU66EWoGNm+Gp5+GXr1Ymp/PqFGjGDBggFHHLR2RaUqce+65hyOPPJKOHTty66230rJlS0BT4AwbNow///wzqSm20g3du3f3FXikispXwfpOmDp1qlGLRjX3kO+d7Oxs1xRB1nRqXkgcr/dnUISGTOJ06dKFzz77zPheVFRkKML8pFNr164dEyZMYPbs2fzrX/9i7ty5CfczJycnEEUJQOPGjWNIHNV5F3ZEUMXQ3ZAsJU4QJE48UGWLcHJuW9O+OdXE2bJlC/PmzaNdu3aEQiHfSpx42vnBdingUj5OpswfK6sSJxKJGKRsMpU4fvatGlPEc5L2NXEAZs2axUcffcSePXs47bTTlNEnextkJY6YENfW/2fpEy03EsdpYKqj32CbsrNprhsr7u5S/46TP3/7DeMRsihxQHOeGE4dfaIlhmJ5+C9Ec7SKm90arZDKmjiJKn28HEN8diVxXNKp2d0D4p6aBPQD6rhEHMYc2+IQrgUs9qDEcSK08vW2O4ByfULotci1m3okyIHQjcRxSqcWCoWMyblR88HjZL3eunXRL1LB4kThpERLNJ1azLNs4zip98svHAhcAjyiL9uRgEPJk1GmG1nbPfTPLwJ3FIjnLQElTqqRaY4TN3Tq1Ini4mIaNLDqRio3xK/dRnwkjh2RL1BaWhq1Xdq1g5kzleO+1/e0Yxub1K4xJE55uaa+QCNxxBRYVuKId1yq0qnF8zwFFVASBImjmtRs2rSJpV9/jShR3QlYqdi39Zxax748SeXjVYmjIlgMJY5+7bejqYIFiRP2UB/FjcQJwhbZKtl9Xo4PHtOpVRBxUF5ezi+//MLhhx9uW08hIUJTJnHEs2/zrv/zzz+Nz0GM9elA4liJc9V6z3jzTRg6FJYv5+Tp01m+fDkzZsxg+vTpAfQ0Ocg0W+TAAw/ks88+o2/fvvTo0cO4dpFIhNatWzNt2jQOOuigCu5l6vDyyy9Tq5a10poa2dnZnlPNWd8JZ5xxBuPGjWPJkiUce+yxMe1XrVplfM7KymL//fd33H9eXp4p8l5+ByZKwqi279SpE1988YWv/cgkzscff0z79u354w8tkejJJ59skLN+lDitWrXi0EMPDS6dNJqDv7Cw0L2hB8h1gLZv386vv/6q9Bu8+uqrQOrSqVmvaVAkjl1dVtXxg/x9KiWOE4lTrVo1RxJHXvfvf/8bgBNOOIFzzjmHDh06YIXdM3bSSSeZ7vug0/SBmsSJJ51aRSFdSByn+tqJkDhiH/EiyHRqqrmReE5Sba/4fhLeeecdTjjhBIYPH84rr7zCOeecoyzMtbfBqSZOyELi7NAnlvloE1jwnk5tY04O6CROIyArjihIpzb7N5LcOeIFnJtLWH8ACpEeTks6tT2A+BViuBVt5Zs+1UqcikqnpjxugkqcSeL7okWOUf5uJI7VceI08Fr3Jz7LSpyygEmcdFHiRCIRw3mwXiz0SuKsWRP9smmTp23igd259DURtkmNiE1KnfwNGqUlT9OSHoGg3+/biUbap5LE8XVPKtKppTsqmxInE5w/yYBsi4hRxyBxdFtEuJR32KR2tUYXmiIb9+zBcLkccQSQHFUw4FoTxxjvpKi+3UTHr+pEkYzUrkErcaxIampXySbw5m6Dvn37Mv/bb43vRwDZijHO7dhBpVMzAkr0CdR2oEzYsCtXxqXEmT17tiktVxDjiFOAgy/iLxElzooV8Ouv3ts7YNCgQXTo0IF77rnHtDwQEqesTPsDlhQXE3FR4myUAmRSOuZbSZyAbJHffvuNRo0a8eyzz9q28TVOCTt0/XqWL18OOKeWUWHnzp3cdtttzJw509d28SLTSByAo446igULFjBnzhxDcffTTz+xYMECjj766IruXtoiOzub008/nbvvvpt33nnHsW2zZs1ill122WXcfffdrk66nJwcDjjgAMc2eXl5MfX/5HWJQEWqfPzxx3z99de+9iM7s/Pz8033lnwMu/MhExy1atXi6aefdqyBGC9atmwZOIkTiUTo3Lkzxx57LGPHjrVtn+k1cdx8FgJBKZ0E4iFxZFjPtWrb7777jrvuussUfCGguu9uvPFGvvrqK9O6ZAREipom1v5UpVPzBzslTiQSfzq1IK6B2z78nC8nEifVvhPfJM6jjz7Ktddey5YtW9i0aRMPPfQQjzzyiPuGlRyyEmez/tnqOBEu9z1ZWUY6IOE8cSNx9tFfDBuzs6FBA8rQ0pY1cHEiuEb2Wdo0r6/9kjCwWywPhSjXIwMK5b5aHL8Qm8YkGUocrzVx4iVxVNGYXqNf3VJIuKVTszuOiCf9DVgCZIXDYDOhag1E9PopBhRKnESjXwuk6NcyPQLSizrMur9kkDjy9rVq1nR0drim/UgzJY4VbufS2kYJOxLHxjFRTUHiJCJb96PE2UZ0nAmlMBI5rnRqVSROhSLd1U/JgLAp1hAlcWrr/7MsqV1FQImTEscaFV69pATDHG7fHiAp6dTKy8vZsV6nzi3p1LLQUsYZfZXGqRIkkpdoajk7EsfPfW+9n5zsrYpU4li/K39XHPX5PvzwQ1PbbGAfBTHgduz8JCpxREDJm08+yRtvvOH6m+T9bdy4kaOPPtpUpDzZTuR40qltsnx3QyQchlNO0UjXDRvcN3CBIBgeffRR83GCcL5LhOxhRx3FH0uXal9sfqt8nC+//JJ33303vuPq8PTOCIeNd3vQSpz+/fuzdu1abr755kD2Z9j+CaR2ffjhh3nyySc5/vjjg+mTCzKRxBHo0KEDl1xyCZdeeint9fdjFewhHOEPPfSQaz3lSZMm2a5zc9JlZ2fTokULxzZWB6LsrLMSEo8++ij169fnySefdNyngIpUKSws5KSTTvK0vYDVcW6XestuHJP7MXv2bAYOHOh5W6/o0aMHY8aMCYzEEb95xYoV/PjjjwB8KwWTWCH/xmSTODKcSBw/NTe8kjhBp12zI3GGDh2qbC8rpMBb3RsBVc0e1TOSk5OTFJLRijVy0K3Un0xR4owdO5Zu3boZ95/wuSZ6j/j9/X7Sqan6liwSJ0j1VjopcXzfnQsXLmTChAnGSb311lsZMmQIa9eu3evSlsgQJI6qJk62hcQpLy9nDdrktSHwJzYOf2mgEmd2Q1YWZGezGs1x0siF0PDrOKmjD8q7gOKVKw0JeDgvD3btMpM4lpo4YrsaxEbKWkmcIJU4ixcvVuZ3Vk36vezPs+MkEtGK10ttHLeJREzp1Lw6TkJESZxtwNfA/gBffw1nnGFq2wCYC2RfcAGR446LrrBEGRThLQ+97bkIh8mT0qkJx0lDtEHFjdN2Ix4SNbxkY+SulSthn304BO1Zs8IpnVokEjHVxNF37qkP9daujX5JkRInVenUBIlTJC1L5JrFnU7Nrvi2TwT+4lWQOJlEKGSa48QOffv2dU1N8N5776WoN6mBkxIn20aJYyVxnAqR19aN1c1ZWdTWnSLJSKc2duxYzlq7VlPTCGeA5MBQBZSUAuXEpnbdjX19vmQFlARJ4ji1UbX1q8RR2SJ245Ug7jej2bj1FZNxN2LCWhNnnQdVsNO+ZSVOqa7EKV2yhDFLlij3IUPun5x+R3W8oODlPnGzReqAZyVO0a5dsHix9uWff2CffeLqtxvi+V0xkN7pJcDv//zDoWBri0R27+ZNYBow+uOP+fjjj1m0aFFy01dJ96tw/YQCUuJ4iQj19X5WpHb1i18DUnB5RaaROIMGDfLU7umnn05yTzIHop7L9ddf73mbww47jBNOOIHvvvsuZp2boy8cDlO9enWuuuoqI+2WFdWrVzd9l99BVkLijjvu4Pbbb1e+J1XL/DgRp0+fzmmnnaZc50Ti+FXiWH+vaj8qnHHGGUyfPt32Hf3WW28BwdX1FGTBSy+95Km9/BuDGD8+/PBDzjvvPMBcByZZJE4ND2lgRV+ChEottGfPHu655x6OPfZYTj/9dNM66zNhTRvr9JutSpzs7GzlPet1WaJYvXp1zLJMqokD8MEHHzBv3jw6dOhg2BHVq1dXqoy8QtSj8QphLweVTg2Cud6pInHSvibOzp07TblO8/LyKCgoYPv27Xs1iSN++Tqik9za+n+r40SQOIfgXYkjSKLV4TD3338/Z6Mmcazw6zjJ1p25u9CYaTERKsvPJx+z42TP1q3kEXX8QnKUOG7Rr8cff7zy5elViWNFxyeegJEjCR15pO0xAbj5Zt7/+msOJ0rEOU4+du8mJD38XmviyO0EiXMFaCSOhEgkwkFAHhD56y9Cco5ghRJnV5w1ccLhMOzaZcj4tgNldepQilaLoCFg0QHFINlKHPl+a7t5M5SUcBRqEsf1/ogjnVoeUFdW3wSgxAmFQsrzEgiJY1HiGG4UOxJH/z25aKS17CRNGvRIUpMSJ13TqQXgOEm186IyKnFq1qwZM+mt7BC2yBrsVcHCFtmuTxbroT3LpbgrceroY+v6nBxq76vRNyolTqIkzvTp0zHicsVkMSeHcG4uWaWlVCeWxBHjVjmaXZKPsy0SDocDDSgJmsRRBaJ4UeIEQeKoEAqFqKnvazJwGVBPQeI4ntM9e8iVroE1oMRPOjWrEmcbUJpAale392syYEd4KY+r2x7rgIOl725oIgeRBKDEsUOQtohIz+yWOrVo/nw6AUcBo/Vly5Yt80TiuAXP2UK3RcqJKrTT1hYRjjVJiZPuASWZRuJ4KQSf7uc81Xjvvff4+uuv6dKli6/t7Jxx8nhz6KGH8vvvv5vWFxcXAzBq1KgYEue+++7jgw8+iCGUnEgc8HdN/aS+clJiJEri5OTk8Nxzz7Fz506aNFHnznBL/ZWTk0NWVpbrnC8oJY7fSPwg06k1b96c/faLWrj5+fkmlYM14EmkTi0oKGC3FJCgqrlih4pKp6aC071gvRc3WGwLJxJHBAYcccQRHHPMMdxwww3K50l17ZMxltqROJmSTk1AzGnEdSssLEyIxMnJyaGkpMS9oXR8iL1vIpHYdGqqAEvVPZ1uShzVmJIxJA7AK6+8YmKKy8rKGDNmjKk43U033ZR47zIEITByxK8FRIxbbf1/lj7REiZ0OBw2ordkEsdJMihInD82bmT8Aw/QTv/eOAASR77psvSHdSdmA0aVTi2sT1qsShyIOk7EhDyZNXHslnslceTtGgL7/fADAAfUrevcx08+IT8c5nii5IDj5MMSpeDVcSLalaGda4O6+f57bcIrSVqFAy9UXk51+QWqO2zCaKlo7BwndpHFMb9LN0jCaNc8DKzPzaVxaSn74o/E8RNt7BXyPkXkeD2b9eI+bwM8vmABzJ5trAtFIoZTwU86tYPRU94JBKDEKSwsVObW9/IseY1+9ZxOTSKlaunbeX2O43acKJQ4oT17oLwcEnzJB+o4KSmJpoQpLycfM9Gdrsg0x4kXPPvss3tdcImwKdaiqSQhVoljpFPLzzfI9wZo47bqPWpK7aq/K9ZnZXGQPrmtjbn+jAp+n7H99t3XUPRGqlVD9CBcrRpZpaWuqV13gRF4AslJ7ZpsEieZNXEiW7YY59RPalcRpPQRGolT+59/tCAFG3spZj8u9fniqokjpVMr1VMCe0nxZ91fMmwRGarIZ1+2sFUV7FGJ06QCAkrkz76cLj5tkXw9DUodaVnSU7tK9fnEFQiKxPECX+NUAAElqUam2R9+i9NXQXNUn3POOb63s3PGyc6/Nm3axJA4Ts/M/fffz/333x+z3Cmdml/06tWL4cOHc4Yle4YKTkoM6ztE/t1e64YMGDDA8fjr5FTgCuTm5pKdne1K9gSlFPHrtA8ynZq1TlJ+fr5ByOy7774m538kEjHWFRUVmUgcoUrKy8tzVeVUlBJHBae+WtOpWcmC4cOH2267Xk+V3KJFC1588UVAndKsIkmcTEqnJpCVlcWuXbuMd2idOnWUCnOviDedmtVXFW86NQiGgEk2GZcx6dSaNWvGyJEjTcsaNWpkKjIWCoX2KhKnNpoTBLTJ1WZpOUC2btzL6dSW6Z9b6f/D4bDjjSorfQDEIxl0OjVZiWNydCtInJCN40S0g9TUxFH9DoCTTz6ZWbNmuZ4Def3+0vLDpQjTmH2UlYGeq7uR1CaZJI6Ygv0FlBUUkLN7t1asVoo4lJPK1ZRTTekGRDFahKq1Jo5bOjXr9Vq7ZAkN0Mi+iL5sTU6OQeK4QT43KmliooaX2H8WUFMfXPdRrJePdQ1w3KZNMHq0sS5P6ocfJU5r64IAHCfVqlVzJXHidl74SadWXk41yVgrQnMYl5eXu45jdvDrODFdgV27wKPRa4dASRxL7vkaxEfiVClxEsPeGvkqp1MT06/a+v8YVXAkwhp0VS8aiaMi8uV7Yx99/fqsLKhZk61o7xO3cd+LU9dE4jRoYNTe2bR7N4IiCBcUwNatFCKNdzb1+WqTHiROvM9TvDVxPAXKSGRKrdi1thD2yJ/A78ChkYimCu7WLeZ4zSBaWF1AkdpVZYt4CSgRbWQSZ49O2nolcdyuf5BjYa1atcDiFPFF/ElKHPm7G4ImcbwElMRNaPolcXSHo3wPJz21awWrgn1BURMn3d+NlTGgZPbs2Rx11FEV3Y2Mh938okmTJrzyyivUqVPHVC/Fi9PcDjJxkyiJU716dc9pCVVO/HPPPZdffvmFwYMHm5bXr18/pi0k5vhUObTr169vkDs5OTkxTtGxY8dy8803c/vtt8d9XDvEQ+KIQIONCb7vrCSO7GRu1qwZP/30k6n9Nn2cLSoqMpESguCoUaOGa5/SUYmjugZuWQ5+/vln1/3bkZACXtKpXXfddbz88suux3JCZUinBtq5kW2z2rVrJ7Q/v79f2O9W+1ClxPGaTi3dlDgqVJQSx/evWrp0KUuWLHH8WyxyL+8lEK/QLWhOk83699po0akh3QiVSRxhYpyi//eaTk1U2bAjcazwTeLoN6IXJU5EURPHazq1VChxFixYwMiRI30pcWQSp/XChcbviDnm8uUakQM0lto4/i59MiUoC69uZ/E6l13DJWJgtkSByDHnKhJHkIdeo1/tnEj/6dcPiBJL4XCYtfpgrxZom+FGPASlxKkLhiNQVuKorpNBhUmqmWpSu3hInIh4IQWkxFHBtxKnuBjOOw+mTo0us3OcqGrOrF1rUhkJ58n9999PvXr1TEWhvcKPEmcb5jEniILCgZI4lkhz8fxmkuOkMpA4lcX54xdyOjUx6tjVxCkvL0e8QUQwgsp5Li8T+1+v389CdWklcRINKJHH3qVSfbGwHv3nlE4NoraIGDXFOy5IW8TaXh77Uq3EyZEcVdZrptzGpT6fW02cbYARf26JRI9EIlQHfgEad+sG8vFdSJxElTh7dKdWDcw12+z2k0olzl0lJVBUxGGWlH6qz04kjm8ljnzOAyJxVAjE+W5ni9i85/P1sSGPaD3SVClxYkicAO4VL2OQr3ObgUocGZn0Ht++fbspwwHAvHnzOPfcc+nYsWMF9apywckZd/XVV3PhhRcyaNAgCgsL6du3L/vvv79tezs888wznH322fTp08dYFlRqMC9QkThPPvkkixcvNmW8AU0NIuBFibOPh3poKkXEP//8Y3wW6dQE3n33XXr37s369eu57bbbXPfvF37nTitXrjQI088//zyhY+fl5dkqe5o1a8bFF19sfN+zZ4+ResrqPF+qB/3K18sOXpU4qSBxhHM6HhLHC+SUWqpn202JM3LkSFO6u3hRUenUrKKIRBEOh00p/axqKb8ISolTVlZWaWriqFBRSpzk/iqgbdu2LF++PNmHqVDIka8QJXFqEnWeyMV2w+GwkRKrLZpCwCn6NYuoikBE4AnHid90am4pENyUONXk5bqxKkeZB6HEWbduHRdccAGTJ082lsmvNNVvsOa2F9izZ48vx4xs7uXv2cN5dseUiEo7EsdOiVOsf81FS/fiBiWJU0e/s6QXTzgcdiVxxJNYC7NM1k6Jo3J0lJWV8df8+UCUxLn99ttZo7/snEwU1f7cSJwpU6bQo0cPXxE1Yns5RsktndqBYoHkhBeOxN1Ef6sTaSCOK0ic7/RzXL5+vc0W3mFnMHlR4pjuxXffhY8+gmefjS7zE/26YoXpq3DqTZo0iU2bNvGf//zH5hckCCmdWsStjz4RKIljUdwlphFKHSpb9OsXX3xBXSnF094COZ3aZv2zQeLoY5cbiWPN860icYojEe655x7EaOA2jfLrnBS2SCmwWsq1Xa5PStzSqSWjPp9TfwHOO+88pTGveu952d/JL78Mxx9vnAvbfdx9N69/9BFHSW0cn+dIJL6aOFLbrdiTOOFwmBZo74aclSvJU6R2FaiNmsSxK6YaQ7pEIhRIJE55fj7b9DQNTraIuB+SHVAib3/Crl2wezdHW+5BAaf7LxKJxK3E2VcOIkkRiZOq1K4Fkm0lSLsKIXEikWga1SQjLhInEiFeN3SVKtgZy5cv57jjjqOoqIiioiIGDRrEzp076dOnDx07dqR69erMmDGjortZKfDII48AMHDgQNs2++23Hxs3buTVV19l/Pjx1KlTh2fl+Y4EVUqfm2++mUmTJpkczH5InEQDtlRpN62KEAG5ro28Xp7f33333Tz99NNceeWVXHbZZa7HVzm05fln8+bNTc5t8TlZgWpuadtUELWWhg0bltCxreddJrhq167NYYcdxmeffQaY697ItcNl3HfffXTq1MnxmF5TQFd0OrWgSZx4auJkZWX5qtliB9U7LhXp1Nq0aRPo/vbs2WPchzVq1EiY6AuKxCktLY2bxMkEJY4Yo9JeieMXS5cujWsAziQIR7GYWMlT1Kb6f9kBX1ZWxgZAJOs6CW0AsXOcyGoCMV0xlDguJI18Q4VCIddIQ1mJY3J06w+WSYnjoSaOmEzJE3K3YsL/+c9/mDhxopEv99CtW9kEPGTzG1X7MH5PdrYp1Z8KSiWOLme9TNEGgL//Nj7GS+KAN+eJoxJHMij8KHFqAuXSc+lHibNlyxaj/oEYpt99911W6wOtkxJHtT83x8lZZ53FhAkTuPfeex32rD6OfD6clDhZRK/9mj//NNbl6/vZiZTCyyH6NYbE0f+XSZHk8SIRx4kJIj+q7Mzxk05tpbnikTXaOR4Hil/HCUjXI92UODYkTpUSJ7V4/PHHTYbkY489ZsrZvGHDBlq3jkl8mPGQg0pilDiK+nxelDjyvSFIoqU7d/Lwww/bKnGs8PL8mOwVfeyxqoLDClWwcPzKo5U1oEQgESWO9RlW/SZxzyVK4hQCB33/PcycycFSale7+ny5kQgn2Owr5ri7dxOSzoNXEqc60UnDNuBLseKXX0Ai2sLhsCm1a3X5nak/g+KK2ilx7NKpxahVSkrI1tdtR7tX1utEnxOx6JXESXQslLcX9aTq2hCH4viHAq/99ZdZLQtxKXGagUFyAabrFC8SUeL4JXGMO8OOxJHqNwhbJJH6fJ4g2SKmXqXIFomrJg6ZqQrOhICSwYMHs3v3boYPH86JJ57I8OHDOeWUU6hVqxZ///0348ePr1LiBIRjjjmGnTt38vTTTzu2y8/PJxQK0b59ezZs2MCNN95orJN9Al7JmVQqcbw6N8Gs7JDVH2ulOefQoUMZOHAgr776qien7FVXXaVc/sEHH3DZZZdxzz33mJbbERZBIZ6aU4ceeqhy+eGHH+5rP1YSR36OxXKrEiQvL89WAbHffvvx+eefc/DBB9ses2XLlp77lmw4pVNLVOUB5t/gJXWadVkoFIo7XaIbUpFOLWhyobS01JiDVK9ePW2UOKWlpZ7SqcmknkCVEsceSSdx9gZYU52VAbv0G1+QOLJbT0xSv9K/n4o6+tWqJthINBWXIHGsShyxzT7ABUDEIf+2aplIyWFV4pQpSJxkRb+utDiJ22zZQg5wok17sUz127Kzs12VAUoS59//BuAsNBItSBJnI9HzZI3SV70oVSTObkU6NavjpJYDiSPvF/yROJs2bTL6LSdoWKWTOE7i9UQcJ9b7wgli/zKJY1cTp7y8nP2IqqLW//WXsU4ocXZhIQ0cHBQ5wCH6d5E2MdsSfRwP5EmE9XkSkM+l7cukWKcR5ejcAJQ4qj54hZ90auKec0uzUmGwXOtMVOJUBhJn6tSppgitRx55xKTmKysriyv1X7qioKCAXDBqx8jp1Grr/3MU6dSW6p/b6v+t195akNKqPBajQdDp1LL0a2eX2tVvOjWBZNfnUxE2BxxwAMXFxb72f4D0ufWcOTH7lxaA/s5qIrVxtEVsUj66QbQrRzu/64EdQu0mqZMjkYhBCoKZxIno7x3xNreSOG71+azjVPGiRcb3HfoyLySOan8q9U+QSpy6+m/ax0pEWfp0GdB+50547TV5R3EpcWLiPFOkxPFiByjPrV8ljkRKCRKnrKzMtTi3HfwGlJQRrT2WKhLHM0pKTOqgeG2RKiWOM77++mtefPFFBgwYwPjx44lEIvTq1Yvnn38+kFQ/VTDDrwLA+kz37t3b+JwMEuf444/33NYr7FQXMolz4oknGp9lxYhf0vb2229n+vTpjBkzxrT8vPPOY9y4cdSsWZN27dopj5sMtG/f3nZd06ZNlcutz121atX48ssvmTlzpu2+jjnmmJhlubm5JgfwUUcdxcyZM03F4q3nt2bNmrbqAUF42SmNIT3TqakQBLEZhBInWUKBrKyspKdTSwaJIytx0oXEUWVFUo1pqmVBXAOv+7jwwgvj2n/G1MSpQiyEU0OeMmy3kDhWJQ5ESZxTcM5Db1X6QHQCXDcSUdateBR4D6jz6afGsgULFnD++efHtPWixJFJHGNypqiJ45ROLQRMAQ6/6y4iDo4T66BWTz+OUFLYKXFUy70YL0oS5+yzWdWgAbnAxXqbPXv28LcgbxTp1Kz7siNxthK9H6zOE9VvcCRxvCpx9OjXdUSvl6yg8JNObdOmTTFKHIDF+j3vFEOSSAoTPwO59dkB+3Rq4XA4mkqNqMMToEDvh0mJEw7HFCcWiEQiHIiWn70kLw9R1i9r61Zb4scrZGNnt3Rt7Sa8tvn1BYkj58m3OE6MvXtQ4vglcRKNfhUkjluErh+koxKnIh0nmRD96oZ4SIRMhxjvytAIHEHi1ERL35mtPysyiSPsEJHgwWtNHEHiiNHA6qpKmMTRx6QYVbDPdGpBKnGc+mtdZl33yCOP+FLiyCRO80WLTASNCevWGWOjHYljV59PvMWywHinC6jGK7kejoBhi4j3Cs5KnIj+3hEZ9ovAVEfCLp2aXX2gQdddB+j3Cdpkar1ur/pNp6ZyrASlxCkAauifa9i8v0WfjBhdKdAiV2sA+FPiHCb6IRyfaZROLbxsGbRpAy+8EG1gUfg7Bmts3UqutFzYtNdccw0NGjTgo48+cvoZ8SNTVMFV9flSgjVr1hi1Vxo0aEBhYSFnnXVWBfeqCl6QDBJnwIAB/O9//+P333+Pt1sxsHPY16xZk6OOOopmzZqZHJDC1+NV1SEjJyeHzp07O5JlY8aM4eSTT2b06NGe03pdeOGFrFy5kjfeeMORmLFi2LBh3HPPPZx77rkx60aNGqXcxkrizJs3j1NOOcXxOh555JExy6xKnNzcXI499lgaN456flQkjp1zXpA4TvPkatWq0bBhQ9v1cl/c0LZtW9c2Tkj3mjhZWVmBKnGKiqKeMTcljp972A5Bv4u3bt1qpBKsXr26UtniB35JnIcffphZs2Z5Sqem2ndFp1Nr3rx5XMrCKiVOBsOqxAFvJI6oi3M4UNMyeZQdJ1anCWi57o3JjTR5Fmil/8+T6hF9+OGHpjoz8rEEZCWO/JJRKXEi+kRUzkZpVeKEw2HKy8sN53ZXoN7331NNmrS7kTj76H2Kh8Txg2y01BMA7L8/c3U5bi/9mCeffDIHHXSQlv9UUuIUok2OvDpO/JI4wglsSqcmXjQ+a+JsIZruTx6m7FKY+FHi/KUPtA2xLygsjiPvTxUZozoPfiIWVEocp3RqB0nrakufC/Tfb1LigO1kPRKJGKnU1tWrh4gRzSotTXiCLxtsXkgcT0oc0cZHOrWyZctM363XOtlKnIpynHh2JlSCmjiZ4Dipghny+L8OiGBO7bovet0GzCTO92jPUgM0h6+TKhiiY6oIH7BT4lgRFIlTJqVTM8YaD6pgY3tLalcnJU5xcTGHHHIITz75pOggxxN9Rzj9JhWJ5fZc2ZE4WZEIveyOKSlHPStx9DFqDRrxAd7UOLX0+0K2RXYJW8SJxJHHaJ3EEW+RQiAsqQX82CJ79uwxlDjCFjn22GNZq98jftOpqSI65fXjxo2jVatWvpxzbraI6v4TJE5YInGqSf2IR4kzXX+X71EUrfYL2RFmZ3N4sgOmTYNffwU55XECqmBhi4i0mda0P15QmVO7elXcVTQy0RaR5ydZWVkpiZKvQuJIBomTm5tL//79adWqlXtjC4YMGaJc7nQ/zZw5k99//93kfDzyyCNZtGgRP/30k+8+CDg9ey1atOCrr76ib9++nvbVokUL3n33XZo0aUKvXr1M89nff/+dZcuW2c7xmzZtytChQ5XEhl3dS1mhBJhIFxUGDRqkfGfl5eWZ+qWqV2R9Z9SoUSMhEqewsJBZs2Zx7733MmDAANt2XkicRFPdOREkQaRTk0kGr2SgdawNksSR7yc3Eufxxx9P+HhBK3E+/PBD47NTWj+v8EriyO2OO+44pRLHes+rfrtqnEt2KjQZOTk5cZFGVUqcDIZKibNNv+lUJM42fQKwBvgD7SIcbVHTyJNwlRIHoinVrJHxEFWH5HiIujOROPokNsZxog+ubtGvqpo4YlJ+mNSulvSAW2966wtRKHH20RonTYmzH5ADlOfkQJMmzDv0UMLAyUC9HTv4/vvvARj1yismEge08+3VcbKFqMPB6uBNRImTVV5uShlmR+KIaZ0XJY5dChMVibONaFS2XeyPynGigmogTFSJk0/0fFudDbISpzp61CtREmcnWnS74eKxmayHw2GDxFmzzz7skLeR05fFAfleTkiJI4i/PXuijhEbx0nptm2mOiIAi7/W6GdBHwaRTs0TLEoctzQrfhBk9MRqqaYSZE5NHBmZ4jhxQigUijnnmXQN/EJWYoq3QjmwUzeum+vLyog+52VlZZQC3+jfO+OsxKlG9H2UiBLH7jqYVMFSOjWTEkeRTk1Vny+IdGoPPPAAixYt4rbbbgPg4LVr+Q54xaa9/Busvz87O9vVqawkcXRnxBWKNkB8JI5uD2zGX0CJGOtl1/AuRWrXSCTiWhNHDgWoLgcM2aR2VZ3XzZs3K4Nc1ukTQXWiFfNx/JA4vXv3ZuHChbY1A1QQ94h8PmS7RPX+FiRO8W+/GevEfVyKRM7u2QMOaVkgSuKIoLHI+vV2TT1DdmjKKiovJI7pvhQpaRxSuzoqbqUgNYgNKHFKWWOHSkXi2KR2Tff3YKapgiORCIcccgh169albt26bN++nQ4dOhjfxV8V0g+HHHKIeyNSUxNn4sSJPPDAA8p1TiROTk6Osn8HHXRQQv0Och7QpIl9tdxWrVrRtGlTiouLGTlypG071bhVp04dRcvY6+WWomzYsGHK32tV4nghcZzSqYntnebJeXl5tGjRggcffJAnnniCm266iZ49eyrbuUHVXz945JFHAGjWrFnMuiCUOPJvqFatGo8++igHHBANYVKdp2QqcerXj1pnbunUgniPBk1Q/Prrr8bnrVu3VgiJAxgp3QR++eUXZsyYYVqmOrfxKHGuvfZa1/559Uvl5OSwKQ5fXUUpcZJbsWkvgUqJs1W/6cSwJ08wZfnnV2iqmeP27GG2JfrVqsSxkjgrQXM+S7k5xQ1kkDgebkY7JY78Qiv1SeLI6dTExFjOzV0kPeBeSZwcgC1bbGvixDsYit8vUqltq1uX2llZbKlZk6/Q0swcu3IlL+vra+zZYxAyxXl5NN6zxxeJ46TEUf02rzVxalgmuW4kjkqJY+c4sfZLlU4tHA6zEC0iuxXwQ8wv8U7iJEOJAxoRuB3ndGqgOQPWY06nJv4XgSclztp9NEptI7oDZ+NGSCA/ttxnOxLHriaO+JwNWvodgc2bobDQlsRZ+fff7F+njtm5qt9zv6EVQ7eSOPEY/p5esBWsxPH6ch49fDh3St8zUYmTCY4TN0QiEfr27WtEeu3evZt+/foZkxq5Xk5lgKx+MKmCc3MpLCszbBFVfb4v0FSynYAxCiWO1RbZTfQ5FCROQ4DSUtBtBXEPtQFuBPLWyr1yd5hnu9TEMamCd+0ihLMtYj1ufSB/3TpHx7O1j011e0qUzPWTTi0nJ4ennnoqpr1qWyD6TrrlFsruvJPDyso4QnXMBEicLWjXsQhvUfoqwmSnFyWOIp3aerR3cQ39+EK1Kq6Bl3RqGzdupIZuF8hTxmL9HrG+12WobBGVM0D1PtutSGFsB+uzA/ZKnPLychoSvRbZ26JnWtzHOzHbXU7vvyyi96oganO3bdMUuAk4IGTHwPbt240x1W86tZCYu8jBZgEocdz6oOqLLySRxPGCRNOppTsyTYkzevToiu5CFXxi6tSpjBgxghfkVI4OOO2004BYhUeQcHIKJ7s2hwpBzAMmTpzIY489FlNfR/VbGzRo4FhPyLpNQUGBY9qxWrVqsVX3uzid2xEjRgDqsSZeEkflrzjooIOM5U4BBvK21apVY/jw4YwdO5a33norpm9W9O3b13SuvdbXUeGRRx7hjDPOALS6juPHj6dHjx7G+qBr4gDccccdDBw40LAxVOfJSuJY53LPPvssN910U1z9qVcvap05KXH69++fliTODz9EPW+bN29OWTo16/hkVeIAfPvtt6bvXkkct/Pshcz0akfEO85WWiXOSy+95Cm3YyZDRbJs1W86lRJHhshHf5zFWSA7TlQkEUhKHAuJU5Ook903iWOjxFGSOIqaOKoUJsIRIitxihyUOKZBLRIx0qkBYHG6yPuIV4kjIEicrbrzPRKJIJLPtZKKpzYUBFSTJqzSB4+UkzhyOjX9OLUsjgW3dGoqJY6XFCaAUokTDof5Q/+cqBJHtT5RJQ6oU/JFIhFTOjWInhuRwkS4D9wm6zKJs1qPvDOeQA/PYnFxMQMGDGDBggUA/Pjjj7Rs2ZKPPvrI1GfZaPFC4gg01FZEF4g+2aRTi4mziURopB9DxAhbHSfxKHE8vfj05y5GiRMwiXPjjTcq23h9OVtJrXjz0KeaSMk0x4kb+vTpQ4MGDSgqKqKoqIjevXvTpEkT43uDBg3o06dPRXczMMjp1GRbYZtuhDuROJ/r308Fo+6GgPxeU+1/HVptlSwwOfLFNgOB64AGU6YY6yZPnqw0vL0ocUpVqV19KnGygDlAl1tuIVt6T7qldq2rH8cptavdO85vbmkjFvGII/hTT+3aR9/vH3/8weOPP87OnTtNJE4tNNvPaovYpXYVJA7E2iKq8aqmvk+TEscmtWsjqY1KiWNni/ipibN582YK9eWyLbJEdwCI+nQqqK5TMlO7elXiHCytk2OMZRKnhGgaPKe6OAegvcNLsrOZI/peXm68S4OAnS3iKbWrrMQRbfyQOC5KnKSlds1QJU4ViZMc7L///vTq1YsrrrjC8a8K6YMzzjiD9957z7N/qmHDhqxbt45FevrOZMBu7OnVq1eFqOeCePbOP/98Zs6cycEHH2xabjeGWd+tsjJJXjdhwgRmzpxJ9erVY+rfCJxwwgmu/SsoKOD6668H7Ekcv+nUatasGRMQ0qZNG77++mvjuxOJs88++8QsUykqGjSwhqnC4MGDTd8TUeLIhAYQU1O7aVMnrbM3qEgGOa2a6h3ulk4tXuIiFAqZlF1ZWVlKu/3DDz/k6aefToiA2X///fnpp58CJ3Gs9nFFKXF2KmyhLRZ7xGs6tfUu6vEgSRy/8zSBjFHinH322bz11ltG8afHHnuMfv36UVtXBmzYsIGTTjqJ3/Q0AJdddllwvU1TqEiWLfqgLswDc2biKASJ07asjBoWB2y86dTkzJ85llRIKsg3Xa5OuFhr4jgpcWQOXBX9mhCJs3mzkdIKgPXriSge2ERq4liVOFt153skEuF7fVlLKVKwgZgAH3AA63RnuzjnXkmcRNOp7RJ5Tvfs0SZqtWsbJM5GoC5QQ59cF4AWIY2WPsWPEscvibNQ/5yMdGp+Xnaq6FdQO9/Ky8qMiN0wmjOytv5dkDiyEkf7YEPilJUZ9agEiWPcOR5SG/bq1YsvvviCV199lZ07d3LeeeexevVqzjvvPKNYHfhPpyYQkxVYkDg2jpMYEmfLFqrrxxNVAYJIp+bpBWtJp+aYZsUn5HP4/PPP89xzz8W9L3E+9qA5EKuUOBUDa+RfZYcqnRrAdp38bq5/V9Xn+wnNoV4HaKsgcazjqbz/CJot0gI0W0RPuyDuITHNy5MCITbajIWe0qn5JHGsY1hpaSkHiH7t3EkdaWLhpgquo4/7IrWrnSpYBS9BCOL3h4jaIxxwAD936EDrX37hMuCT8nIO1UmddevW8ZRE4oBHW8RFmWuHolAIIhGzEkfYIhYCz06JE5JSuW1BU+76IXGs5EBIvyayLbIuJ4ct+n4PBn4lFqraO6qJZ1ABJbItkod2vrda9l9eXm4icfLR7LfdmEkc0NQ4NcGRxBHq9+I6ddi+fj279f2xcSPUjN+lL/fZbzo1E8Q9U16uvd9r1bIncRTXZueff2q1sdBUxlYSpyqdWjDp1CoyoCQTbJFOnTpRXFysdKpWofLA6tQOGipn5K233uqq4E0WKoJAlcem66+/3lQjSF536aWXGp+/+OILRowYwZtvvkmxZIe89NJLnHXWWVx99dW2x9vtEMQDGqHgV4mzzz778M8//5iWHX744aa6PHbvx7ffflt5n8nExL///W9+/fVXHnroIV5++WVTu0MPPZSaNWsaZRsSIXGsNWqsPpj99zesVC6++GLeeecd2301adKEVVLAuYBbDZR40qmpSDAvqF27tsmJHwqFlLbeueeeG9MPJxQUFJjus8suu4xx48YB+Kqv6BepTKdmPU+q97Y1Nb8XJU7Tpk1ZLQWIqZBOJE7aK3GmTp1qirx65JFHTBPysrIyFi5cqNq00kIMtzLJstnSxk6JswpYhDYBOUKaAKgcJ1YljpFIwJJSwETi+FXi6JMeL0qckIeaOKDdEzmYHftF0m91dJxYB/31630pcbzASuJskUicOWg5yOuWlBjOKIPEOfBA1uvnxZMSR59QxavEkZ0U5Xl5YImALdKvh3BY5ITDFBGd2IZDIbYTjX5VkTheol/BPp2aUOLYlXNMlRLHGjku7iLxrMrnOW/zZmqiETjCHVZb/5/vU4nDkiUU6O026k4SP0ockTNUOEa2SoVpvaRTs4t+FZ+9kjjifwyJoxPGG3GviVNaWspZZ50Vk+PZKXrdFpFIxqRTE8+bmEpkIomTCdGvbrjqqqtc/5wmd5kIVTq1LZbUrnJAyUsvvQRoTlARUHKKA4mj2j+obRFxP4kUX3lxpna1plMrk2riGO8ThS3ipMRpK32vaTPGQuykVZA42QAbN9raItbfAv5InH3RHPjlWVmw334sPvBAitECeo6WotJmzpxpKHHKdLupCeZrpuqLF1WwCmIsk+8hVTq1SHm5ibRQKXE246zEsaays0tTl6fPR0wBJZGIEWRwKGqkqj6fSokDalvEqsSBqBrHGlBinFGH958gcVaKIDuxQiJU44Hf1K52CEn3jFtAyc6NG3n11VdN2//5uaYhFLHxqVbixASUVIAt4tR+7pdfmr5XKXGSg0wgmqqQvrjlllvo3LmzkbJNRkXeWxWRRUe2uazpuuzG5oMOOoinnnrKVEsFNAfwggULGDhwoKdjq8aa6tWrm46rSiEWE+xTp05MOinrdnYBBhdccIFyueyM79u3L1988YWpfovcl4MOiuYWCZLEsZ4H+TedfPLJtvtp3bo133zzjXKdm2pGdZ7clDgtWrRw3Kcd6tata9q3Uzo1sd4LrL/RSkJZ0apVqxjVUzy49957U5ZOzUs72Z8F3kicTz/9VJl622kbFbzagvHUw4HofCXV47VvEsfawb3deKlDVM4kC742W9rZkTgQdZ4cbSFx3JQ4RmHYZdESsZFIxOSozd2yBbdhxk6J45pOTR84vaRTOwjNKSHgmcSxqIxYv175oi0vL1fei34mRCoSZxcwX19+nP6/oUTirNUHIRWJE9NPfQBzSmHiNZ1aJBIBYWCt0eKii3RnxjIgrL9c6xOd2O7Sr6EYRuUJr106NTvHiZsS5yDUg4sq+lWFIKJfs9Ejpomm/hLf5f1X10mw5UQjzGvr/4UKzLPjRI+q+APNMQr+lDjW3K7W2hQCfmviCMSQOCIywpIaUThOctEdlgK6k3Yl6vtI7sMHH3zAlClTuP/++2P6YYXrRH3XLrCkzXFMs5IEeH3XCVJLjFxVJE7FYMyYMXzxxRds3ryZTZs2Kf/sFCGZClXAxxZ9kiCUOLIZLY8jIqXayR6UOFYSx3hLS+9rsY0gcXJ9qoJt6/MplDhiPHariROJRGJInFpS3RE3JU5deWLukNrV+lvA2yRHbCNcEVvq1IGcHMJZWYzXlx0rkTg1S0sN5/dfeu5zQeJ4VeL4IXFq6ftR1sSRUrtW27XLJPM3kTgWJQ6obRGvASV2tkhQJE4ylDgQteudlDgQtUWsShzDAnFQ4gj1+0o9RYgfWwTMk+7S0lI+/vhjNm3aZGuLuCmBwaw2C8kRljYkjvid5du3c/XVV5tsnCL92RWBS0GogtNJiTNnzhzXNk737/uvvWb6nolKnEyxRSoi3VUVKgf++9//Mn36dJONIAidigw06tq1K3fddRdvv/12yo5pddDLaNKkibW5CdWqxYQd+oJqrDnssMNc06lZUbdu3ZjC7tbt7N5NdraF7Iy3kitWiExJkFjdGqvNKo9xzZs3N/XVyZF++umn26Zeq+miCFadJ1nxmJWVRb9+/UzrgyJx7NKpCXgd863nRj5GXd3fKOOQQw4xahHFi/HjxzNkyJAKS6fmBW7p1O69915atbILCVdvYwevdsSRRx7pqZ0VGaPEqYIZwim8CU2xIbDJYvR6IXGOsVHi+CFxIOo0AQiFw1iHiPuAn8FYbiJxbJQ4e/QHtJq03EmJI782du3aZUqlBlDbgcQxPdg+lDgquDG4MqwkjoDIkn6s/r+hnE5NPy+N8Bf9Kl7vCZE4jfSs80KJozvi1wJl+m+oT9QJsEsf6JyUOH7TqVmVOMvQ7oF89PQ6FgTpOPnuu+9iCqXJ2xuRrsCf+mdVOrUa+vn7iyj5Wlv/X+AznVqWHhW9kOi586PEscIviWPnRHFS4kQiEbbpjkFrTRzQnnnjGLqTdgXq+wii13iXD3LF9cUnGcTinktXJY44H2LkykTHSWUIzujfvz9btmxhyZIldOrUiVGjRvH+++/H/FUmqNKdidSuKiWOjC/0/ydGIlrdDB0yIeCqCpZInEgkQjWiSoI8nyROtqTEkceHMkVAiVcljhibTEocBxLHWp+vjjzW+CRx/Dj+BYmzWQooEdenjZQiaT/xHmjShBX6ZF1F4sRTE0eFmvq9ZCJxxCS8tNQgB2rpY7+4iwp37jSCiUIu9fn8qoKTTeIEldo1HZQ4fkicqVOnUlRUxO233w7A448/zrnnnkunTp18q4JlyMFpIdneFH1ySe0q77e+bvMKEicIJY4npIjEOeqoo1zbONlO1vNRpcRJHvr27cuFF17o+FeFKnjFp59+ysaNG2ndurV74yQhFArx8MMPc/HFFydl3yrI71arzTRw4EB69OjB//3f/ym3TdRhrXpfHH744a7p1KxpWOvWreuqxPH7bpJ/mx2JI44hkziJKDGc0qk1a9bM5Lh3Ok52drZtn+3ecQKq89ShQwfj844dO7jwwgtp166dsUxFjHiBSonjZLd7tQOdlDj169fn7bffpmfPnsayFi1aJFwr56yzziInJydlJI6c7t8r3JQ4Xo/tRmqCNzvixRdf5JJLLvF0TCucauIkkp7fDb7vklAoFDP47s0RKMKpYSVYNlpuGCcSZzraZLft7t1GyjFBCGQRnexZHSdGSc9Vq0Cf8FqVOBBb3P1KNCeG4Hnlmy7PjxLHUgwd1Eqcbdu2GSSOmGwlg8RRLfdC4kQiEQqIkl+b9Amv2N8sfblKiSNIHE/p1BQpTOKtieNE4qwByvXIS5MSRx8cVQoKvySOMGOsjpMIUcJExZ8H5TgpKSnhxBNP5KSTTjJFvMyaNYs33niDcDhs3PebsrONZ0flOKmhK5n+JpbEqaa3s6ZTi9gUBhaRpSuJ/ka/0a92SFY6tVdffZVffvxR26/Yv9SkQN6v7qSVlThBRL+6bqM7TcqrVUP8Kqdc+X6RjHRqVhLHD6ZMmcICvd5WqpCJjhMnvPDCCxQXF3Pbbbfx0Ucf0bRpUy699FKmTp1aKUgqFVTpzgR1LKaQdrbIL2hq4hrAIRJRoFLirLFsa5A4UqHxSCRiCijxQuLI951dOjWhxKkut3cgcWRbRBjaMolT5JXE2bqVAplYWLfOVhUM8RGhYhtRo22TVGR1hv6/+c6dRgDOfoIoP+gg1uvnJSgljsquF0ocmQgsz8kBMWnW33819TF5sd4mKxKhLtqEI6Sf781ESZza0v7s0qkFTeKUSTazExJV4lgJUHGPqpQ44fJyRCKUzfr/2vp/30qcPXuM+UQ8ShyRguaJJ54AMHK4z58/37cqWIWYmGqXdGo5+p+x361bjTqiXkicb775xtM7taKVOF7gl8QRVzsTSZxMeVfXrFmToqIix78qVMErsrKyTEXW9xbst99+Rs2/Qw45xLSusLCQt956y9bRWlFKHOuyOnXqxChxunfvbvouv5tOPPFE1755UeKIMUbUKHdq6wVOSpxmzZqZ7CAnEsea7kzGfvvt59gHVTo1WYmzRvffHHZYNFTcj0/6ww8/ND7Xq1cvJenUmjVrZvp+8cUXc++99xrfGzRokBCJk52dbSicUkXiHHXUUb7r+wRF4tgpceT9e/FL/etf/0pKTZwrr7wy5poHBd+9jUQi9O3b17gpd+/eTb9+/YxBzJoOqLLjGP3/H5blG3yQOMXA5Kwszg2H6QcMJDoJFxNfkPJZ61iDXjw7HNbIDv0mUZE4on8haX07YDwWJY5+o1sdJ0KJUwhs0ZeHLCmYQF0TZ/v27QaJMw0txUPt3bsJARG8pVMrQU/H5pPEcXp5CEQiEVPR5526ISD2J5Q4HdAc1nWE4+TAA1mrD7SuJE4k4ikPfSLp1GrbKHGEo8RJiSP6ah3o/KZTA02F0g6tBtJky2/xq8QxRWZLA7Ks8ti6dSs19FQyxx2nUW0jR440nCabsrNZrx9XpcSprp+/v4gW4a6t/7dGv7pN1gWJU0xylTjyOBtPOrVI7dqENm+GzZt5fuJERunLxbMcAcJ5eWTt2WOo77Kzs5Xp1OxIHD+GlFclTrh6dSN9mnEFnBQ/a9dCnTrgYsimmxLnrLPOognwMpC8GA4zKhuJA5rx3LNnT3r27Mk///zDmDFjuOGGGygrK+PXX381xo3KApVSxqoKtlPiRNDUOJcA7SUnbzgcdq2JY2iBpWKu4XDYTOJs3Uo2UXWGsg9SX3N0J75Tfb5ysVwfA9yUONu3b6cADEc5QC1psu0ntWtk7VpfShw/Y4xQ4myUAko2oNlxrdACSiYhKXEOPpgN+tjcBFjlg8SxG8dV/a2uL1MGlGzcqNXFOewwaunvxxXA/rVqkbN1Kw0wX3s7JY5dOjU/tkhZWZlB4rREs6GtI1qq06mJZ+cPoD1qWyR/wwaqA2VoaXxPQVLi6P89K3EWLSIX7Rxv1CN0jTmEBxJHJmcgsdSuMkQbvyQO6M+82K9+v28i+q61I3GWL19u5OwPhBRIo/p8Tu9qObVrXeJXBacamWiLPPvssybnYhWqUAX/yM3N5ZdffmH58uW+02Ltu+++CR1bHmsmTJhAYWEh1atXZ4sU1KQicZo1a8bzzz/PgAEDAI1skpU4S5YscfwtX375JRdeeCFt27a1bSM74+0czYLEkQljL6mmQKtb89tvv5mWOdXEad68uakfTsdZtGiRcnnnzp1d+2VnRzzxxBOMGzeOXr16AbE22bx585g1a1ZMqjUrZPKnWbNmbJaCzYJKpyZfuwMPPJA77rgjpo2cNqx+/fosXrw4po0VEyZMYNGiRdxzzz2m5XXr1jX6lqqaOGVlZbYp8+yg4guCJHFKS0sNMsyLHSGTn37hROJkZ2fHTQ65wTfV16dPHxo0aGBElvTu3ZsmTZoY3xs0aECfPn2S0de0hBCQTbEsX2+ZgNo5TgRe0gegvmgTFRH9KqL1NqJN7GREgJWCrdVTqrkpceoB4nY/XOxHVuLYpFMr1W9AOfo1pKiJo0qntm3bNiOtw3T9f044bKSic3Sc6EocEWlXsnKl8iFJVIkjUqktQSuKK5aLZZvy8sgHLkR/aGrWhHr1DCVOXSC7tNTecbJ7t5ZuhCSmU9Ovx1qgTB+M/NbE8avEsaZTA4y6OC2JhR/HyQUXXGAqlmcXmaDa17XXXmvc9xuys416VaqaOLXWai5JWYkjzo1IpxajxLEjcXRCqJjob01EiSM/C36LCavuJWNsEAaDnk5NvOblV2q5/mKsJu9XkU4tB3XKIj/wSuKUS5FWro6Tv/6CJk2gRw/X4/t1nDi1lx0nEH9NnAuAc4BbfG73+eef07dvX98F+jIx+tUPsrKyCIVCRCKR5KXZqUDUIvpul0mWjR5JHIjWxWknjVVe0qmpSByrEgdiVcHtgf8QrbtlCijxQOI4KXHsbJHWmOt8FTmQOKZ3zooVpnV+SRwvEz4nEgfgO335Cfp/g8Q56CDW6efFkxLHQ0CJCmJsk++hSCQCjfU3i16ovpber9VAqR5N3IBocMSe3FxKiS+dmvUaifFVto9KS0tZgnY/VCNaD0pGIqpgq8MgHA7b2pqRSMSkqBe2rHgWTKpg/fwtJfqM1db/+1bi/PqrcTxh0xpP9QZrSFgsrCSOjCBUwTEkjk06tRIgoj87JltEV/0tR30fIbW1c4iorr3ru6+83LA50oHEcWovzoewRTJFiSMjE0icdCfFqlCFTEJ2dnZcdU3uu+8+unbtytixYx3b2aVhl8eaSy+9lH/9618xbexq4shkQV5enkmJ4/ZbsrOz+eCDD3jooYds23hR4ggntEziqNqqFEv33nsvRx11FAcccICxzKlejUqJc+yxxyrbLly4MGZZs2bNeP311233L2A3Vxs8eDDz5s0ziHOrTdauXTuuv/56/v3vfzvuX05z17RpU9d0avfdd59pvRfI12706NHKeygUCjF58mQGDBjAlVde6Yl8adOmDZdddlnMclnBlyolTnl5ue9jqXwUQZA4V155JT/++KPp+niZ83upd2WH+fPnc99995kIX4G0InHGjBnD6NGjXf/2Foghy43EcVLiAEyLRFiWl0dtoCdREsfOaSKwVH/pTB4xwlgmHLXiVpIdJ3KcghOJY02nJtQpdYARzz/PypUrlUocVQqTnZs3G3m+5wG79ReMmMQ5Ok50p/HP+tc5n37qS4njtSaOicRRTBr+0PvcSyw44AAIhdhE9PdX27LFPoJMd5pEQiG24z2dWjbRc+mqxNFJnDVAmSKd2k4HJY7oq10KEzvHiRz9KgZJofpKJJ3a7t27mThxosnYkl+mqqhQ6yAtnp31WVlGBKpwpHz66adGu9q6Q0OVTs22Jo6N4yRLd8IEpcSR4SX61Ws6tbAuVxd9Eq9e+VkO60aEisRZia7W09vK91JSSBw9fUlYMriMCF07Jc7cuZrD5ZtvfPdHBU+Ok5ISgxAT0cHxOk7E/esW27JmzRqTw/O0007jtdde4+67747zyJnhOPGCkpIS3nrrLU4//XQOOeQQfvnlF55//nmWLVtW6VQ44j2/BTMZ60cVLEictlu2GPefl3RqBnVTXGykWVWRONY45WeAJ4HzpWMJ5NqkU9ujT0qry8v18VAeCVRKnG3bthmp1IRDu0gay30pcWzSqdk9O35IHJFOLV4SR95G2ad4a+Lo/2NsEUHi6AEloibOGtQkjlUVrCJxEkmnVlpaaqqFp0qplkg6NWtAyXHHHUfTpk1NkYWlpaWs0++RekTVQMI+UqVTq6mfv0VE7QYxHbeSOK5KHJ3kWCIdw09AiVcljqyKTjSd2ooVK/hKt83ko0d054DJFtFJVTmgxI7E8QPXbSTnXDqQOF7SqQn6OR4lTnFxMZMmTfLcPghkWkBJJvSxClVIJySD+KxduzZTpkyhd+/eju1OOOGEmFRtYD+Wyu91a20bAdk/ccghhwQ+h4o3nZpKpXD66afHLKtVqxY//vgjf//9N9OmTeOhhx4yMpuocPDBB8cocT788EMjjfXKlSs56aSTAGLqgRUVFbFkyRJPyilVOjUV7NTR//3vf03BwD/99JNpvXw9rWnMrEqchQsXcv/995vWy7jnnntoKPxyEuRr55Qm7ayzzuK5554jNzeXm2++2badQEFBgfJ4MmmYKhKnrKzMl0J93LhxbFTYoUGQOHfeeadRa0kQWl5q9riNSWeffbbtuj///JMHH3xQWQs6rUicZs2aMWDAAKZNm+b54arMyEWbKC6xLF9nmYC6kTjlkQgT9Jvt30AkHCYSDiOGPqvTREBkoP9Kz1cNUUetID5kEkeeOO2HpiAxkThSOjX5JbS1sJA9aFH3U199lWOPPdYgcWSHkSr6Neuvv4y0DiuA3XqqL08kjq7Ema9/rYfaYA5UiaNwFvymvxwN8eeBmpslghZtClBt82b7yYdO4pQXFhLBezo12c0o30OTJk3i6z91F8Xq1RCJUEdS4pQqlDg7HZQ44riJpDAR59pJiePVcSLnKRWQXxCq7a05aIXDcENWlqHEESTOI488AmjkQ3V94v03sTn6RU0cz+nUJCWO6KNB3dg4TiKRCDt27ODII4+M7kfxMvFL4sQ4JIFGYhuhxNm8mVAopCRxIpISx9iXlE4NnFVdfia2Xh0n5ZLB5eo40R1irFtnkEB2CMxxIkVhFOv/401hIsbtZtrBlW3mzZtHo0aNOPXUU2PW/SOpIrxA9fvKysp48803WbZsmd1maYsbbriBxo0b89hjj/Gvf/2L5cuX8/bbb3P22WcnlG/4hRdeoEWLFhQUFNCxY0d++OEH27Zjxowx6giKP6tRHYlEGDJkCI0bN6ZatWp06dLFNv2AEwRpvtyy3EriOClx/kSrAZcbiXCd1L9wOEyI6D1pDSpZh/Q86s5jazo1iCVxRMyfKG0atxLHIaDEjsQRNH7NnTuNvMKOJI5FiYODEieuCH/RH6Ln2Y7EORrN9txXQeI0RrcfnRyhHkgcVX9tlThCFawHMRTJJI7+GxoQfU/s1ie1ftKp+SVxAMe6OEGmU/vhhx9Ys2YNc+fONZYdffTRNGjQgL/++iua2jUry3gvKFO76udvEYqaOD4DSiI66biK6LlLhMSR4VeJoyKADLJROKQ2bmTw4MGU6u9qOxLH2K9CiVNAVI0IyQ0oieTkGHOfVJM4MryQOIkocS677DKygWsxp6FMJjItndoXX3wRdzFtO/ixMwDefvttWrVqRUFBAW3btmXyZHMy6759+8bYImeeeaapzcaNG+nVqxe1atWidu3aXH311THzqipUIQiMHDmSffbZh2effbZCjv/hhx9y9tlnM2PGDGOZ3ftCdhLbkTgAP//8M19//bXvtFJeIBM38vtU1KyDaH2ZK664gnr16tGjRw9WWO1W4Oabb2bYsGF89dVXxjJ5TtSlSxfuvvtupVP+3nvv5brrrqNjx44mx3ROTg7169fnhhtuoFGjRjRp0oQPP/yQN998kwcffBCAM87QKnFfddVVnudgXt/hdk7y3NxcWrdubXzv0KEDxx9/vPFdvp777LOP6bu1Jo71fFjTyw0dOpTi4mIai6AmHRdffLFyGyfUrVuXyy+/3LFNfn4+hYWFvPfee6bl7dq1M7VJBH5IHK947bXXuOyyy5Qkjjw/9nqPWEkc+TotX76cZcuWmRRmbpAVcTIhus3Fj2SHrKyshGpTOe7b7wZjx44lPz+fG264gXr16tG9e3fGjRtnyiO4t8GqwgHYbDHE3S59OBxmYu3a7EKrvZL1448M2LGDm/T1/7PZTrjWmun/q0UixqRPEB+y48TKex8O/Prrr9x0002UlZUZJM4uLKmZpGM1B1asWEGWx5o4hUs0iktk29ytPxR2JI4Y5LLAcMQKQioVJI6KuPitVq1onyBK4kQixqS80KLEUZI4ulzPK4kj1u/R/wTefPNNBoqX9+rVsHUrefrx1uGsxFHlwLcjcVSOkxBRx5jsPhD3i4h+bYR9ZGQ8kWvygK5SnFgHWOEIW68gcQRExPMaNCfQZv17bf2/XTo15WR9506y9D7IJI7xmrJR4lx22WXUqFHDFCEiXrx+06k5KXHqojn+AMoP0qbjxb/9xubNm5Xp1GKUOCUlsF47k8IsVKm6kuk4KZde8Ea8gxuJA/D33467DyyFiZSmSJybePUe4l6tCSZySMarr74KwHfffRezzi9RIf8mMQ6MGDGCXr16cfDBB9ttlrYYMWIEtWrV4oADDuCrr77iuuuu48ILL4z584MJEyYwaNAg7rvvPn766SfatWtH165dWbvWTiurRbgVFxcbf1Zy7YknnuDZZ59lxIgRfP/991SvXp2uXbs6OlFV6Kr//8yy3G9qVzGl7o82XojUXPsQTUO2XrGdNaVaJBKJsTdkWySbaMBJe/2/FxJHrs/nlE5NpQqWSZzPgfLsbLKIktteVMHGSLJunXIcKC8vD8QWWUc0BarAn8CmnByqAZ2AOuLaHnigkdq1BpC7e7dnEkfcD/GmdgVi0qkV6ddDVuLUR1LiOJA4QQaUBEHihMNhRo4caVI22kUcyvuaP1+zwE8++WSjHs76UIh1+mdVOrVAlTh6AJRM4vipiWPNV+63Jo6dLSIg7P9y8W7ZtImdO3eqA0pclDjy/ahSddnBKR2iLYQqWEq94Uri7NwJJ5wAltz1Xvvk1MaPEiceEmfWrFmcjVafb7jPbYuLixkzZozvd1mmkTiPP/64qQbGY489ZvKJbNiwweRIdINfO2PGjBn07NmTq6++mrlz59KtWze6devGggULTO3OPPNMky3y1ltvmdb36tWLX3/9lWnTpvHxxx/z9ddfc91111GFKgSNtm3bsm7dOm688cYKOX7Lli2ZNGmSSW2yzz77KNvuu+++/Pe//2XUqFGOaoO2bdsa6pNJkybRqFEjPvnkk0D6K6dAkx3CgwcPZtSoUZxwwgk89thjgPY7Vq1axZtvvsl5550HQMeOHY1tWrRowaBBg0wKFa/kwoMPPshLL70Uk2pM5eyvXbs2PXv2NNJUvf3227z//vtGEK0XeC0I73RdNljSx4oaMn379iUnJ4ejjz6aJk2a0LFjR5OyxfobrXNq+ZwNHz7cWDZhwgTq1avH8OHD+fzzz03KMD/BnPXqWT1WZgg/0QUXXMDtt99uLJdJnHiUOEOHDjU+Z2dnc8kllwDQs2dPY7mcsg38kTiiT6qa5cccc4zx2WtKeOu9J1+z6tWr07RpU1/n/e677yYSibB582a6du1qLI+HxBF9SRslzimnnMKwYcNYtGgR3333He3bt+e5556jUaNGdO7cmWeeecZTQabKBBWJU47ZWeJ26SORCJuzsxmvf69xww3coxuFg4D/s9nOSuI0lJQDwtlgl04NtAL0AM899xyvvfIKBTZKnHA4bKRMaa7/D+kTZZXjJI+ow6em7tQRucDliFGxbxniYWsAUF5OubRtXSCicIbMmTNHOflRDRJWeFHiLKxVy1yQWWd1w+FwVInjgcQp01l+4XBwS6dm6zRBUmetXWs4rLehObedlDiJRr9WIzpwqGK0thGN/LOqcVSOk0LgRMV+rLBTmdiROKp0anmYJ7KCxPlL/79Z/19b/2+bTk01WdcdWDvRnn3xW43X0ObNoJiQjh8/PmaZeMklUkzYei+K5209ENaNg7L161m6dKk6nZrehwKxX90ptJsoMaUiBJNaE0elxLFLpyaTOC7vJDtn7JgxY5SqCNv+SiSOeDZy0e67eJU4gBF17Ad+pM1gPgdi3Jw2bZrpuxds27YtLdKL9OnTh06dOlG7dm2jZp/qzw+efvpprr32Wq688kpat27NiBEjKCwsNMg0FUKhEI0aNTL+5ElCJBLhmWee4Z577uH888/n8MMP5/XXX2fVqlVMnDjRV9/O0P9bE9+s80nivIP2jm4CXExUiWMoG4mtzwfRlGo/vvMOYE6nJtzBMonTEAwFTHv9v0kVLNXnk8eUEn1cKgTmzZzJrl27lKldVargrVu3GiTOz8Au/T0p7CIvNXGE1mLxDz/4qs/n1RYR76S/Ub9/f9HzlF8hFjRsCDVrsisry3h/VXeyRUpLjTFTVuLIY7j4HVa4KnFEfT79eqwB9khKnNr6NoLEEf1VkThe06mJ93kylTjXXXedyfHghcSRYaRFVgSUyI7ZonUaxaNU4uj/PdfE0d/XK1EocTzUxHFSpSVSn8+qxClrqVuJHlK7Fsr7lZQ4YZwV5jLcrrer/RIPifP99zBjBjz/vK2q1g9SmU4NonM+lbrerl8ARx11FFdeeaUpBY0XZFo6talTp5pIz0ceecQUZVxWVqasC2EHv3bG8OHDOfPMMxk8eDCHHnooQ4cO5YgjjuD55583tcvPzzfZIrIj7vfff2fKlCm88sordOzYkRNPPJHnnnuO8ePHs2rVKushq1CFhJFutaQef/xxTjvtNCZMmBCz7pZbbuGqq67yvK+zzz6bVatWxajd4kWNGjUYMWIEzz//fIwD/aqrruLbb781Of1zc3MJhUIceeSRrFixwpQSUyh2ZOy///4xy9zgpFJRoVatWnTr1s0TsfDpp59y/fXXM3jwYE998UPinHXWWRQXFxvj6YwZM1i8eDHVqlUzauxAbDo16/0qf5fTc5900kmsXbuWm266iU6dOpnUMH78I6eccorxuVWrVrzyyiumgEr5PMrEXsuWLZVtBM477zwj3ZgK8jbVqlXjjTfe4Mcff+SNN94wllsJJj+/SxCSjz/+OI3E3EFH7dq1ee2112jfvj19+vTxtD9rCjPVveA21tSqZZ0BaWn/ZJ9oPKpUMYdMGxJHxmGHHcadd97JrFmzWLJkCT179mT69Om0adOGNm3apDyPbkVgN/CVzbrN0mevl14obrJ1p+NDwH8d2gvXniBxGugPUjHRlCeqdGpiqnG4tO61/v3JjkRYh5YizInEyQZC+rFUjhOIRsDW1Z3bIibofV0W7pZOTazflJfHOrSJGkC2QvUl7j0r3KJfDzjgABYtWuRK4uzKyjLUQIBaibN1q/3kQ498FSSOnRLHOhA6kTjG1L+sDP7QMq0LYmeP7pyUo1+t6dTk1BN+ol9l4snGfW6bUk3lOPkY+AawzzZp3ta6vei7dYAV9/06vZ/inpdjbUR6CEF4btb/19b/25E4EQcSR9wPMSROJGKrqLBC9eKVnxN5wujFcQJR0rQYCIvcueJ4+n/Hmji6E3ON9IJ0SqfmB57TqUnRSJ7TqUFcSpxXX32VK6+80sid7Ced2lbMKrV41DheSBwnB0ciShxxf/klgr766itq1arFbbfd5mu7ZCDo+n179uxhzpw5pty6WVlZdOnShZkzZ9put337dpo3b07Tpk05//zz+fXXX411S5YsYfXq1aZ9FhUV0bFjR9t9lpSUsHXrVtMfaM/3duBrS/s1FvLALaCkFHinvnb33USUxBEJCOw0R8I+mKTX55PTqYl3v0ziyNPIxmikjkmJI5E4JqdxQYEx7rx4553auXNQ4sgkzp5Vq4xx8Fdgp0dVMETTU83Tv1ffuTMpqmAh+l+M2hb5WZ8sXiAW6KrKcDhs1OGqsXWrvRJia5SC2YZ3VTBExzH5Hlq0aBG/iYg5/R1YW78eq1GTODuTnE5NbOtE4og2bgEEgsiWYZfa1U4tJO77dQoljoj0CwF1dcevSokj3nyelTj6tVgl9cdLOrVIJMKAAQNilgcVUCLOt3gOy0Rtgo0biUQiaiWO/t63U+KA872EyzIZSVHi6NeCLVsMNXPcx0dNisWgtBTRw0TSqYGlPp9N/7Zu3cohhxzCwIEDjWXC+e/XF2Bna/3yyy9xpzRJJqzXIBHiKR47Y+bMmTE5/7t27RrT/ssvv6RBgwa0bNmS/v37m5ybM2fOpHbt2ibnXpcuXcjKyuL7779XHtfOFqlCFTIRDRs25LPPPuPS/2fvvMOkpro//pnZxi5LbwuC0gXpTQQbKM2GKIhiQRTLT8XGq/jaFRs21Fcsrw3UV0VRsQsCgiKCgCKgWADpvS2wwLaZ+f1xczM3mSSTzMzCovk+zz47k0m5SW5uzj3f8z1n8OCU7C/VJNXVV1/Ndddd53m7I444gho1ajBz5kzmzZtnSD81b948Pv74Y8saQfGg2kFe54rx0Lt3b1588UXXxeadjn/llVcCxrooeXl5+v1JT0/XiRazEkd1vpvHdXWOXamS8e2q3nuVYPGiWOnfvz+vvfYa8+bN45dffmH48OG8rwXJgTFVmno8tdaQFTnRo0cPFixYYHtctX9UrFiRzMxMOnfubDhfs2rN6rxq167NkCFDDCohiJI4rVq1YuPGjdxwww36b8FgkKFDh7Jo0SKOOkqEj8RLT2j2dVj5Ppyexdq1a9sGWajztkRsD9kvyiWJo6Ju3bpceeWVfPrpp2zfvp0HHngg6Vx8hwPmoBjwJuRr//cBbtyakUiEhYic9ACvZmZyd5xtpBJHdvE62iCzCWImixCNOJ2p/VdJHBkvMBWI4EziqC5m6U7Ozc01TLzkpDNzhdA5SNeVdDTEc5zItm7PyiJMdAKaYeMIV6V+EvIBzACeIBqtLLFq1SruvP56ZDZjlcRREYlEMJjDLtKpvfnmm9H1NeO2xETiZBFNcQX2JI4VCVgClMpI8iWCYpIONksljjaIqGa2HN7tSJx9+/Zx0kkn6TlNAX1iWIDoJ1aQxXtbmJabSZyBiLQwgO4ktIMdQSE/2ypxtP5klVItnhJH1sQxp1MLeCBxilHSgLlIYwLW6dSSTWFiReJUQvRB+XoxpFMz18TRnJiblJfRwU6nVmqVTs1OibNFqSSWAIkze/Zs23XcKHFCShtzOfhKnENB4siUQy+99JKn7Q4HbN++nVAoFFNIsk6dOmxWCUMFRx99NK+99hoff/wx//vf/wQZ0r27nqdabudln4888ohBSaQauNMwpt0EOBAOG2wUN26WD6pXpwg4DshctIgee/fqASYf2WxjVupGFBLnZ+2/U2rX9og0rU8++aRI7WpD4oTCYVZrnxsiouislDjynNOIBitka7bISsT7a38SSpya2jmakQyJA7gmcXQ6WyNxVFvErMQxnJdmP4UrVKAU9zVxcoiqq9U+NHbsWM6VTv/NmyEcNihxirR3jaEmjvZu8ZJOTS63qxtopcT5EzEOVwOMT1hyqV3j1eczRwbKY28laodUwVi/5QgEcVmCeJbyteVVtf+elDiRiP6+tq2JY9Huxx57jMzMTJ577rmY35JJ7Wr+nEb0mhRrzqPda9ZQUFDgLqAEDEocsO5L8dpuhTJR4qhj+YoV1uto8FprNp4tAlESJwNh73mxRQKBgD5uZ4LxXBS8+uqrrFixgqeffjrmt1Skdp01axZt27aldevWnvZ1uCERO2Pz5s1x1+/Xrx9vvPEGM2bM4NFHH+Wbb77htNNO0/v75s2bDVHoIBxP1atXT8gW8eHDR/lCjx49DGnVQKRZkynXvMKrEqcs4XT8888/n8WLF/Ppp5/G3Y86BppJHKcgLzOJo0IlRby83wOBAJdddhldu3bVz0+dR6htU1OPqedgpbqSpJIdQaa2V1UYqXBD4lSpUoW3336bM88807DcTD6ZiTMz5s+fz7vvvktJSYll+sXu3bsbUgN6VeKceeaZMYogiWRJHHlu5YbEKS0tjcmVvGXLFu6//35GjRrFd999R05ODuecc05MZMjfEeb88yrytf9ub7s0pgYC+a+/zi0uJIdyAlMdYO9e8rRBJh6JI7N0tiY6MZeZ/6Zq/w2Ok1AoLomzYMEC+vTta0hjkkVU7SBJHOlocKvEWa09RHLyO90i/ZQd5AM4EPgXMNZiHTUH/T6sHScqiRMKBEAzVsPhsK3j5KOPPtLzouvp1DQGWnU4qEOk2dHjpMQBKJHFNE0kjlTiZBO95/u0QSSsHD8eiTNhwgRmz55tGLysnCZmuFHiZAGPKb/FyxjtlcQxF+G2InHslDiVEM+FWYnjGP2qRL6a21gqoyFc5vhMNYmjplPbBISUF7P66lIdJyEbJc5mCyWOSuLINti13Qpu06mVWqVTS1KJE4lEXBFPVhHXEydO5PTTT48aUNpzLh1KdmkT4yGAUTF2uChxDofUJwcT3bp1Y+jQobRv356TTz6ZDz/8kFq1avHf//434X3efvvt7N69W/9bp/QNu3jnfOWzGxJnu5Latfq99/Lspk1kAG8DdlUdzCROpXBYJ/x/1v7bKXEgmlLtlltu4cUXXqCC9i6Mqc9nInEARxIHooRHrlafb6n2fbs2xsl3pHkckGNYFhDQIujluWQCAQujfvny5WWaTu3X7GwD2Y6WXiESiRiUOPFUwSFt0ulWiSPH+BCxgUv6SLt7N2zcSLp2vK1EbRGDEsdE4uQQDSSQ7U1FTZwiRGAOxKpxrEicIPHtEDCOi1bvXHNEup5ODfEsyjNTx3iZJGMV4hqblTieauLs3k1AI5I2ET1XPe6+pMSS/LnttttcORkMKnWFsHKrxKmNsK9KgVItNXFkxw5mzpzpjsTZs0cnU5yUOFaIZ2u4VuJ4sUWkEgcSJnG++uor1q5dG9PGeKrgfRjH/6RVwWvXWq7jZEOlIrXrBx98oB3e+vhW8EqIJYpAIOCYaqc84IILLqB///60adOGAQMG8Nlnn7FgwQJmzZqV8D6dbBEfPnz8vVGWShyvcHKSBwIB2rZt6yqNm0oohMNhx4Adu3RqZqj7cBvMZYd27drRrl07zjzzTMPxt23bpn9WjxcIBPTMGA0aNNBTnIIxJZqalcKJxGnRQoRmy31IyHetmsJT2gRmQYfZZolH4uTl5TF48GDS09Mtfw+FQkyePDmmLW7h9K6+5JJLAGjbtq2hLpVbSEItw1TfNFXwTOJceeWVBunT3r176dKlC8899xxTp06lZ8+efPHFFyltZHlGWZA4G4HCPn0IuXCI7UVJ17RuHbUtSJyaCKcgRImR7xCT3gqIyWNtoJP221em9kCsEkc+ksVE05y1aNGC//znPzqJ0xfoipis7SJK3sRT4phJnL80h7V0wi+a7nTVjZATAKnyaEpsp1dTqantMTtBZiAmir/VqgXaA+mUTg2IFrGWShxtECglOklVnSfmwSceiVMs2fClwi0lCYtQhQoUawO5PL/9yiBinvDapTCxksfLId0mEzvgjsS5ARF1LI9olfJEhd3EVe5TJXEyiDo/tmj3xEmJI138qsarMlESx6zEUSfr+gvARokDUYeZWyVOvHRqdg4S1+nUgkHdmauSOHZKnFAopEf2WpE48VKYJE3iaPc2ZKXEsXKchMNGJY5DTRy3hXOtyLIhQ4bw5Zdfcv/994sflHRqkDiJU40ouQ4c9Jo4PokTi5o1a5KWlsYWtV8hgljsonjMyMjIoEOHDqzQHHlyOy/7zMrKonLlyoY/CTvLS6WO3dgjoVCI/2ifKyxdSiaiVs5Qou97M8wkTm3tXbJT+c2KxJFjTgflt+dvuIHc4mIKgdXEjv3yXS3fbVYkTilCrQpRB3g1bQyTJM57338PxFfiSFukOC2NjUSf6zSL8fzCCy/km29ik+zGm7x16NCBP/74I64SpygQ4Ed1Q6t0aqa6VJYkjhaFJ8eqLIzKEPO1cFIF7wZCcuKnBa7sRFz/IgsSR9bEUa0L8zvETU0cWW/M3C6VMLNLqSZtHXV/4xHBRgNwRjwSxxxQIqeoWxDqZUmmqM5xSeLICmz52v+q2n9PShwtjdVOxDMRUeyYkLQDXdTFUZGqgBI1zeJmoFRTw1VF2OaW6dQUEiccDuvvwz3p6fp1sFIFWyFVJI5lfb4UkDhW48SMGTPo27evnl7Eyc7ToaiCw0obK+GdYDDoMzyQKBKHIqBk+fLlVKlShXvvvdfTdokgEokwbNgwzj33XM4991wKCwv5v//7P/27l1oaidgZeXl5nu2Sxo0bU7NmTYMtotbnAjFG7ty5MyFbxIcPH39vqON6w4YND11DSB2JpCpMMjMzHdOpqe9qJyWO+r5NNrAgPT2dRYsW8cknnxiWm8duFY888ggrVqxgzZo1LFiwQFfg1KoVtUDPOOMMy/aa1Tpz585lzpw5nHvuuYbl8rzUdH8dO3YEYv1Z5mtgVoA6QdbJ6dixIxdccAG9e/emadOmhneP1b1w8k04EXAXXHAB8+fPZ86cOa6UXGaUOyXOnDlzGDhwoP79jTfeIBQKsXz5chYvXszIkSN5/PHHU9rI8ow/HX7L1/57JXEgmofeDXT33rp1uhJnI1ESJwMxQcokOmlcR9SR0ZZomrEfiRIBdunUjiQ6oVQnWiAGdWlK/pdovaDttWvrhdOkoyEPQS7FS6cm17dywseDHGS7ad+ziI0Alk4T6Riyivj85ptv2IQggR474QR9uUGJY0Hi6NAcJyUKk2sVAeuZxJFKHK34urz2EWCvNnBK6mafQuKYFRQyBYz5+GbVHRjTqdlBplNrhnGQkftP37lTj+i+R/vfFKMTyQy7iasViSP7eSmwS7sn0mUhX9HViaYh/F1ZX55XVSDbpiaOkxJH9gf1WpZ4UOJUAh5Zvx4++8zWcaIaD4kocSKRiO7YldOzUoxpH0M2JM4mxXBzm04t6RQmUoljVRPnwIHY1DA7d4paURJr1ojo40SOrcEpndq2bdvEMsVxAtG+5DUXfS3zAhvHiZNh4pM4qUVmZiadOnUy1F4Lh8PMmDGDbt26OWwZRSgUYunSpdStK57GRo0akZeXZ9jnnj17+OGHH1zvU+JnomOPGYmQOD8hapUBTM/O5kKc08JK+0DWTailPW8bidoUViTOLO1/e+W305XfzOnU3ChxZAoBVRUM6MEO0vaRaYbikTjy952a41baVlYkDkCfPubErVFiIQCMBs40/f7zzz9z2aWX6uekkjgqIpEIc9QFSjo1OyWOofaTrM+nTVzU97g6TtkpceyUXIWaM56ffwaitogkcaoRvf9SiRNSjm9OqWa2RUpKSjjrrLP0lI1gJMfV81DHdDsSx6zEORlBUkI0xasd7NJzuVHigDHASsJM4shntirChvKkxNFIHNkfDLaDx4ASK4e/m3RqTsppSeJsBEqVCXcVnOvz5cj9aqrgbUrEqJMSx65dVnCdTu0gkjhmUtguiMcA7TmX10WO+4kocQwuFhmYZkJZqYJl//Jqi9x7773s37/fMr1bqjF06FBq166tpxW7+OKLqVevnv69du3aros0J2JndOvWLaYm7LRp0xxtiPXr17Njxw7dFunWrRv5+fn8+GM0RODrr78mHA7HpGDy4cNHcpB+0he1GpKHK/766y+WLVtGdemLOkRIFYmTnp7OlClTeO+996hdu7Zhv2YyYr/yvnciAlQkkm7eDCvlZ/fuIlTdSi0SDAZp0qRJzDYqiaOSV/lK3XHzeVWtWpXu3bvH7Es9r8WLF3P99dfraXnNKpRjjjHq3bt06RLTZjt06tSJ9evXM2/ePN555x2++uorPe3d4sWLmT9/vudgAvkOtEIgEKBLly7k5ubSrVs3wuEwM2fO1K+zVRkPFVKFVFYkjue9btiwgWbNmunfZ8yYwcCBA6miTdQuvfRST8WC/87I1/67JXHMk0G3DrG1aLVt1q411MQpBoqzs8k8cMBQG6UQEaG3GEFutCMaPTs1utuYidd6RERXBQSRA8bIfRAd/gLgCqAX0YnzqiOOIKRF/m3R9pOOcFbakThyoicdLYmSONmIc5RoRrSWEETVIlI9YldAV7ahyMTMy1Qi2Xv3gk06FrMSB4TToRbu0qkVZWaCRTqWkmrVZKMBIwG3t0IFaihRmvssapnIPhGJRNhnEdFpReK4Sae2FuFAy0Y42qQOQg70jSdMoDKCNHwUuE1rSzOiaffM8JJOTb6atoGuaDP3Hxn5vS4ri93KeeZr51iLKAGWCImjtrfUg+PkLOD0nTvhjjts5bJvvvkmvXr1YujQoQmROOFwmF2I514uNxOyksSpIPerTe7+UvqRVTq1REgct9GvDz7zjL5IvwOhkCBoFIeOrsKpVk2QPIWFgghp0gQz7I7tVKzW/Nvbb7/NqlWrmHPiiQSwTqe2zUP0a8wYd5jUxHEbeHC4YuTIkVx66aV07tyZY489lqeffpp9+/bp0vKhQ4dyxBFH8MgjjwAwevRojjvuOJo2bUp+fj6PP/44a9as4YorrgDE++Gmm27iwQcfpFmzZjRq1Ii7776bevXqMWDAAE9tm+rwm3QIHyCqTnGCfIYvBBaMGcM1zz1HSZw+uBFBBGcCbNqkK3HsSBxJjHyOUO02QwQI7APOUH6DWNJeVeKkAQGtvXIM+/rrr7n55pvZ//nnVEY4fwOI9LHgnsSR468knNZpx9mmHXvaO+9YXAlryHd7X+BuxDvyM9M6DRDvnCKtbXaq4DnArXKBNqapSpxKJhJn9uzZTJ8+XaQ41mwRqSSQ6dFyEPaGDHYwj3HxAkoKq1al4tatOokj7aLiihUJBQKkRSJ6+lKzKjiX+CTOl19+yWefGa+YtEUOYE8wuiFx0oBnld9a2exLbZ/VZwk7Jc4mbV1pi7hR4oC4NokocaxSu5ZUqkSFnTsPWX0+M4lTOy2NAsS9rI41iSMVuHpAiTYWbcnK0m0xK1WwFZzqBqrLbdUqiShxUlwTx6r/TZ48mWeffZY333xTFDa2IHHq4D2gBNylU/snp3adMGFCSvfn1c648cYbOfnkk3nyySc544wzmDhxIgsXLtRrExYUFHD//fczcOBA8vLyWLlyJaNGjaJp06b07SsSqbds2ZJ+/fpx5ZVX8uKLL1JSUsKIESO44IILqFevnnVDffjwkRBuueUWhg8fTjXpwzlMIYOzDzVSmc5Njolyv08++SR79+6Nqfml+szcOunLKsXnHXfcQa1atTzVN2rTpg1ffimKa6jvaJUEcUtOqefVtm1b/vOf/+jfVZ/QwoULY0iTvLw8li5d6vpYRxxhrqgaPW4icJtJA4Qd3KNHD5YsWcJ7773H9ddfzzsO88CNmi3esmVLtm7dyvz58xNqox08kzgVKlQw5ECeN2+eQXlToUIFCgqc3Lv/HORr/xMlcdw6xHSTeu1a8hQSB6CwUiWdxJEmrZzYLdH+twckDzrFpj2hUIgSbdv6QHO5f1NbAoEASwCZcO8IRI7xtscdR+nHH4t9ATvT0qgZClEP2B8n+jVZJU5nos54EIoPNWaphfZfqjG8OCIjkQhbEaRUMBIhc/duw+9mEqc4jhLHjsSJVKxoSeIUmQwA6SybP38+LXbs0KN6IUritGjRgj2/i7NVne9W7LVVHn+pxHFKpxYBVgBtEM4JA4mzdStHaC+OmxDXbhmCUGyJdxJHLt++fbu+TDoLtynrmvuPTB+4rEIFUEic3Yg+rr5mnNKp6dAGaysSR49+daHEkYQqv/5KjnJ/5ctA4tJLLzWQOHWAVgsWkIVwAprHEzOJk699l68v87OsplMLrFsnUpKlpbFQyW9q5TgpLi7mu+++M7wnPJM4kQgsWAAtWkDlyroSR32zGEpHHzhgJHGk06RuXbGv334T7bcgcVKhxAEhMy5t1YoMotcl0ehX6TTZiEZmr18vzsPkWEql40SFV8dJSUkJ6enpf2slDogCmdu2beOee+5h8+bNtG/fnilTpuiS6bVr1xqu+65du7jyyivZvHkz1apVo1OnTnz//feGSKRRo0axb98+rrrqKvLz8znhhBOYMmWKq/zNKpxInHztv5t6OBB9JtYDuwcMoFDJc2y7jbZ+Q4A1ayxJnIoIZ/R+osTITwjC4ghEMMqvgNS6yvRwTjVx1LgzOYY1a9aM1157jQLtvpyHGOdytXWkozxealcJaYv8oY37kk5fnEBq1xO170cSJa0kVFVwBHsS5xtEMMyOihU5RlPAqEqciqZ0agC//fabIHGkKlhJk7CXKIkj4VWJc8BGiRMJBNiXk0Plffv089tvUlAcQTRtGFinU3NK7eo043CTTu1ahK1SgrAV45VOt7NF7NKpSXtEpnZ1o8QpQfSNiohr40mJo6lmJUlpJnGAlKV2VSfviShx2obD7CQaOCMnpY41cTwqceyUU3YIhUL2Thnt3lrW5ysqEkEl5vdmCmrimNsnIc9Hpje54YYbRP0YE4mjqoK9pFPLJJqaGLBV4jjh707iuEmXFggEePXVV13tz6ud0b17d95++23uuusu7rjjDpo1a8ZHH31E69ZiJEtLS2PJkiW8/vrr5OfnU69ePfr06cMDDzxgqFfw1ltvMWLECE499VSCwSADBw40OON8+PCROhzuBE55QlnW5Bk5cqTlci/kdnp6OqWlpRx33HGpapYBOTk53HjjjZ62ueeee1i3bh2DBg0C4OOPP2bhwoX069dPX8ecTk3F2LFj9Wtz4okn2q6nKn5kijUz5LuqrOBEsnkhcSSaNm3KHXfcYfnbihUruOSSS5g7dy4XXXQRAI899hh79uzRBS+pgmcSp3379rz55ps88sgjzJ49my1btnDKKafov69cudKP2tAgY6+2Oa4Vxfr16/XPCaVTW7tWnxzJKcOB3Fwqb91qUBXIiZ0kcXprv+0B5ir7tZoorEY4X6R6xYrEUbFB+2uTnW2YnGxRSJw/bc4zFUqc4uJizENmM9N3SeLIyb6TEseMcDhMCOGkygOyFRkiCAfdqaeeSrYkcZQJsRsSRzopCm2KYhXbkDg333wzbyjLI2lpFGovuV69erHbgsRxW4zZjeMERKrBNgjCTzoYQ6EQLF1KIBzmD0RtJhDXvhvORYXj1YHZrEQ7ylfGVuV3c/+Rr5IlpsE9X/svSY9IIECRKa1a4ICBQhBwUOKUyAgDF44TqXIjHKZNKIR13GMU8lo8CPSfPJlLgFcwOf7CYUslDkRJHLPmqlQhcSrM1UaGTp0oUMgkuzz05hf6RRddpBemtUIMkTJlCpx+OtSvD2+9pZM4qmusGIgEgwTCYeHIUl+Osi/k5UFOjiBxVq6E3r1jjp1MTZwY2KRTy8Wb40T238WI+xMsKoJt28BD7thkHCfFxcUiQt2FYbx161YaN25M//79//YkDsCIESMYMWKE5W/mIsFPPfUUTz31lOP+AoEAo0ePZvTo0Um16yeH3+SzXtapXdcQJXHytH1sQDicSzMzSS8upg6CpJAkznpgEcKR3x7x3s9ABFVI8t8unVptjMXh1TEsEAiwEUGM3K0s31S1Kie0a8c333yj2xaVtD/zecr+LNsq15c2XUzaQwfId/vxyrKmiGdc/Q7R87ZK7fqzRpIcDXQ45hhmassNSpy9e4nYqIr0dGqKE3oPsVH6djVx7PqQTuKsFBXmdBInEqFAI3F0ZWsc57uVEidRW0TadUcg3lNybJZ9PG3HDuSTdxswFnEtahBVJZkRj8RRCadKRInGTYqSC6L9J4eoTa0GsexCkDjVSK0SB3BVEycX+HDfPnj++ZSldg2Hw/rztJFoatcjidr8YCJxzKldNTXIVsUB7UTiqHAzljmuo5E4xcqxDTTagQOgRpQWFhqDd6QKyib9jJugEqeaOOvWrWP37t1USVE6tRrmd7qf2jUGEyZM4KijjqJDhw4pO64XOwPgvPPO47zzzrNcPzs7m6lTncI8BKpXr87bb7/tqZ0+fPjwcahRVumqnNChQwfeeOMNV2qkHTt2sGvXLj3Vc3lAxYoVDeN9//796d+/v6G+mhOJc/PNN3POOefwww8/2L57QNS8mTp1Krm5uZ7r8aUKlStX5o477uDhhx+O+S0REscJjRs35osvvmDBggUGfqQs4DlU95577uGZZ56hSZMm9O3bl2HDhhmkUZMnT+b444932MM/B28D9wKxXSY+vKZTA4isXKk7qFUSB8Rk0axskSlF5MR6OtEi82At2ZcxWG5JHImMjAzDxGOz5mCsS+wkJBwOk0XU2e5ViZORkaGnqykpKdHr4azU/jdV1q1ONEpS1jeKR+JYpVWS17uCSWnx22+/CUPcgcRRJ1V2NXGKVJWBAj0PvQa1tKVKHkYqVdKVWBkZGa5TTzilU3NS4kD0ejZXloVCIdAIpN+U5cu0/25JnHBhIT8iHGDdO3Vi//79BhJHzUEv85aaa+JIJc4ik7M7X/uvkzjKPbNV4hQX604Rx3RqLpQ4qmC3g4uoTNkH5TPZ3LQcIKu4WFdQbcZYE8c2nZpGHGYD2T/8IBb2NFYLsEqnZoUPP/zQoJSyOgfD8ybze69fL475m+gtZmedXkzbfD9UEkeqb1auxApuHdRu0rA4kTheoCpx9F5tkc7KjRLnjTfe4LjjjotRcsXbV3FxsSvHyYQJE9i3bx/vvPPOP4LEKa9wuvLyWXerxElUFazHaK9ZQ21t/JO97oA2BtZGvMOlC3Qjop4PCBLHnErN3J5QKMRuouckgzCKMF6DQCDAEASB8zXR8W1Z3br6e3Y/sEdR/prPU47h0naSYTaJkDjFxcVkAMcqy5qb1pFqETcBJbtBD8yQ68h3T0ZpKel2ingbJQ64U+Ko5I+KA5JE19oqbZFwOMwu0wR7nymdGhhtkT/++MNVfT7ZXicSZw/RPthCWa7f2+eeoyoiteszRAk0p5RqXkgcaYsUELWZzOnUOiDSAm7LyEAdpfO1/1VJriaO2sZiD0qcU4GeJSUwerSh7tzixVHq8dNPP9XrFLlR4kQiEYMSJ6wpccCoflbvdshcE0ezR1YrffFgkziPvfCCvshgO9nZIllZQhkMjmocuzpYduuY11+wYAFVq1alRLO3zCSOVyVOTNjIQSZxSkpKCIfD5Tq16zXXXMPu3btZtWoVPXv25NVXX2Xy5Mkxfz58+PDhI/W4+uqradCgAddff/1BPe4ll1zCCUqdbDtUrlyZo446Ku565QEqIZZjY+9LNGzYkPPPPz9u0GifPn30uj2HCg899JDl8lSROI0bN+b3338nEAhQtWpVevfuXaYKMUiAxDn55JNZuHAhN9xwA+PHj+fll182/N6+fXtuvvnmlDXwcMZuRAFbZ/G8NRJKp/aTiMUtJuqwPqBN1FUSR0aT7gE9tzzEpmNxInFUx4kKuwdZSgklNil1b6xIHDmZO0DUWeOWxAkEAno7SoqLdRLnTe2/SuLI81hDdHJsFf1qB9l2ncQxKXEAXnvtNd1xopI4VkXPx4wZY9hW/qZG/amwS6cGRhInXKmSfj4ZGRm2CgoznNKpuVHigAWJoznkf1eW26U8UaE6BSp++SUdEel3LgYmTZpkiB5Qa+JIqP2nCtF+8KPpPudr//UUOxYkTqC4GMPQrE3UIxkZ+rNncJxIh5kXJQ7QzqLIrRnyvkryR/5Xj19JUbLsw1qJY1cTJxuouGCBWGhD4rgRiMYbzwzPmzxe69ai3pPWD81R4DqJY1ZGyb6QlweNtSQ+f/2FFewiX83Pv1P0qw7NeWdVE8eL40SOcdswKi29QI6Bl156KT/88AOjRo1yXN98vkVFRa4MEHXM90mc8gmvJI5ZieP2vqokTp6ZxNHSddYmqmzZgkgb9bP2vRNwuvZZplIzt0dVBUP0HW4VULIeoVA8FeEIbwVM7tzZsL8t2oTFisSR31OlxOmIMf2bmcSRQQwyqMGLIzIcDlMEukM800SaxyhxLFK7qvaAeVw0pHa1wH5TOlb5Nv7yyy/5WU0nRVSJ06NHD0vne5cuXQxFYyHx+nwQtTWOVpaFQiHYuZOan34KwPWI1K5SCeOU3CEeibN1a9QSk/VwrAJs5DjfWfv/iyl1mXxuq+NeiROJRJxJHA+qYN3lsGULdRX7fbcpbbCMbpTn3xzo/cknug3lVBNHtUWk3V+MuBf6NootEty8GZYtg0CAnxT1rR2J8+yzz/KX8u439ysrGPp+OAwvvaTXBJQkjmqLRIgqlx0DSmQ9WQcSx6sSx25s3qtldrCyRby8p2tp6+pzxV279GvgFsmogsG9LQKwfPlyduzYcVBtkeeee45NmzYxatQoPv30Uxo0aMDgwYOZOnWqbxP58OHDRxmjWrVqrFmzxk//mAKo71qvab0PR9Ss6SW/kz1GjRrF0UcfHX/FFCKhpPnHHHMMN954oyX7dtVVV9G+fftUtO0fjUTSqckUT+p0eb82YatNbHoyiKZUA28kjpzcuVXixJA42n8DibNkCWzdGjPJk0iExKm9fz95iEnhu9rvTRBFjiG2Hg7Ed5ysWbOGIUOG8NNPP8UocXIsSBxAd+4WKWSMVfSrOZe6/K3EZiAtVCaxpUQdOGChxNHampmZmRIlTiIkTmlpqa7EUa+5dFodDdhN1dT7UvWNaLK4f4kfbZU4Emr/6aB9XgVsMp1jvvbficSBqDMuEokw+733AChVXgZuauJY9TUDieNSiRMgStLWV5ZLVNYcPbKfWtXEMd9pqcRpCWRu3Ajp6WBSWbpV4riBfr1CoajDZOJE+N//oFIlDhCNhJcolc+TneOkTp0yUeLYbRNIsRLHQOJ4VOKYnR5WNSXy8/NZqV2XeI4Tu2O5WcfHoYV0wLmtZrBhQ9RKSFSJk6dto5M4ii1iVrYs0v53Qji99wKzlf1aPXurte/yHW5OcGm2RYoQ75lAVpbBFtms9V8nEidVShyzRt0tiePmuZLryOudZUqXNWLECFatWhVVBSsRdm5Su8oxvtBGFbzflOtZkhbPPvus4T0MsF97t7Rp08a1giKZ1K5/aP/V6VVpaSn8+iuBSITVRFMJ/6L996LEqY8IClm1SjxpmxTSyskWkf1H1qT82ZQ2N1/7rypUYpQ4Bw6g9vS4JI6HgBI1brS1C/JDHudfwLHz53Ol2iZlHTsljlweE1Ci1MSpJAvDdurEXiVi1K4f3XDDDXpBeBCRo4WF5iNYnwcAn30GV18Nxx4L99yj23BmGsOWxJF9IS8PmmqhQx6UOFYkupuAkgxtPmilxPECadGuRJlfWASUuFEFRyKRGALQComSOKtXr6Z58+bUrFnzoNsiWVlZDBkyhGnTprFs2TJatWrFtddeS8OGDf06wT58+PBRxjhUqbr+bvinkTjJqmXmzp3Lo48+ypVXXhl/5RTDM4nz448/0rNnT0uH0O7du+nZs6dBau8jMXiJft2AMWrNQOI4KHEgmo/9N2IdPFbFS+U6suN4IXHUicd6bd86iTN/PnToAB07krtvX0zqN7B2nHQB5gFdTceTk4ZWWj9dhCgYWwxUIOrodiJx7K7//PnzmThxIp06ddJTREn6YNeyZZbb6CROnJo4ZsRT4uyvWBG0c92Vnm5IJ+OkxHFyvqcB3wJfAcUWk12v6dSORFxzgHHjxrF9zhzAeM2lEiqLaHFnM/T+88MPZC9ZQhHCWd4SqPfzz4Z0XdJxYqfEkanUfoSYCX2+9l86TsLKtVfXVEWmT956q2ijUsBN7e92jhNz1GVljE6IZqFQXIIkEolQh2haRNm3DUocCxInnhKnVHMoyShhjj3WmOsd+5o4du10gn4t/vhDRBdXrAgtWsBFF8Fff9GC6L3Rt7FT4tilU7Nog1Xkq5VjxI3jxInESaQmTjwSxwlW0a8HDhwwOBhbtGhB06ZNWb58uWU6NXUflhHChYV0mTVLH0d9Eqd84jNEmrJ/JbBtQiTOqlXkaX1B2htqQIlaDwcEyaRalNMQCh0Jczo1uQ1E1Zvm8ctJFaz2ZakKtkunFiQ2AMYLiXPttdcCghSRJI6WnNJA4lQiqqJMtD4fRG2mChZO+hNPPDGqClaUOPLaq7bITtP28WyRfSYlzmbls8EWycigWLs3qiq4LANKpK0Rk05Ns9dUq00qcdySOJG9e1mAsKUfuuIKFi9ebAgocaPEkSTOT6Y+K9/RRyjL5JvOKqAEEMoRbYxPNp2agcSxqr1jguynMkO8/K8eP1BSottndkocJ1VwJanS7dXLsI7bfgTw66+/GtprhuFd99138iTggQfEXAUHVbAdiVO3blwSx2rel6gtEtQCwsy2iNd0alKJsxUl68Oa2HAANyTOyJEjqVq1qqv6LCqKiooMKV7s1Eo/yLS/cdpT1ggGgwQCASKRiCtllQ8fPnz48FEekKkEatWq5SVU7Z+J4447jlGjRnlWHKcCno/45JNPcsopp1C5cqzbrkqVKvTq1YvHH3/c0z6fe+45GjZsSIUKFejatSvzZaSVDSZNmkSLFi2oUKECbdq04YsvvjD8HolEuOeee6hbty7Z2dn06tWL5cuX67+vXr2a4cOH06hRI7Kzs2nSpAn33nuvZaTfoYIXA7QUI9mhkjj7tGhLq5o4ABMREa1PWuxXGp8bNmzQJYpm0z1RJU4MifPww2KStGED137zjT55VAkn6YTPJUoKjEQQOLebjicfpjZaBNRcIETU8aMlNYjJQQ/eHCcS8pq3+fNPJgKPEM3tD+gkjhrF6iZKXzpOQtnZlr+XRiKgDbI7TGyy6jgpzc3VyYrMzEzHCW8b4ESgN1A3iXRq2xFOiCBC/QTw6w8/UFNrxx/KuhGijha7lGr6ZOiZZwBRc+q/cpsvvjBMZuVrR41+lXHJGUAP7fNPxEYc52v/dSWOyWklXRkqiSOdD6VK4flElDjSiZeflgZa/tSOOCMSiehOURDPeRBnJY5aE0f2SDvHiQ4tlZq6X5UMjOcWsHI2nIuogwFKPSjppOnYEWSfrlkz6kCwaqNTCpOGDSEQgIIC2LYNM6zaZZW71U1NnIDmODGnMPEa/Sr773YUx0mCNXH0tgUCNG7cmHr16rF69WoAPQXhxx9/HDf69e233451pL77Lid88gnyje+TOOUTYUR6svilzGORUDq1P/8kQzuudF47kTgRogElYKyHA4mnU7NCRkaGwRbZGCe1a20gHWFnSde8WUnhBOl8LCkuRmbOfk37rypD5HtvA9Hxw40tIu1WsxLHisTZsGFDtCaORTo1dZx69NFHDdtKi7/IJjJvXyXjKKeSFup7OFy5sh5sEs8WUZEMiWOlxFFTu1qROG7TqWW9/TZ5CHvgFuCjjz7ypMSpQpTM+8Hk8M3X/kvbPZKVpV879Y2n2iKRbdugpIRIIKD3V0OheBlQsiP+aJAoiWNO7aoev6L2jpRpn13V59Pe8zlA1YULxcJTTzWs44XEiTeeGcaBefPE/wsuAKUGpWcljgsSJx5hY7WebUCJyRaxqsHpBjW1a7UNxRaJk9rVfH2lLfL0008DJJ3a1W6ufihTuxYVFfHOO+/Qu3dvmjdvztKlSxk3bhxr164lN9frVffhw4cPHz4OPrKyspgzZw6zZ8+mUiWv3ovDC506dYq/UjmGZxLnhx9+4Oyzz7b9vX///nz//feu9/fuu+8ycuRI7r33Xn766SfatWtH3759DTmlVXz//fcMGTKE4cOHs2jRIgYMGMCAAQP45Zdf9HUee+wx/vOf//Diiy/yww8/ULFiRfr27as7sX///XfC4TD//e9/+fXXX3nqqad48cUXueOOO1y3u6zhNXpHNalVEqdAm6jXwjqd2m+IaLlXLfYpJwcy37X5OBCbgsktibNac5zXBZoUF8PHHwtHa8WKtNy6FXknVMJpD9HoXFmc/kTtfy+ihZLT0tJ0Y769ds9lqgxJ5cl6KIkocaygJX+iDnA+8G9E9HMH2S7tfOOlUzNDJ3FsiouVlpaKlFE4kzgfzJihk53xlDhdlM9HJ5HCBGJTqkknyo709BhVhXSkHIM11q9fz60XXURk0iQA/qP9lQD1V6xAHYqtHCeFRAkYWdnlR2Ih2yUddCEPJE6JErWg9vcief/iKHFkKrVNGRnQWWhg1PuRBzxL9HqGQiEikYjuLAFBUtXG2H+raI4FKyWOhJ0SR0ePHpgh+1GQKLlnB/O5tgY+QDiXg1iQOF26EA+2jhO1Jk6FCnCE5gazqItj5QT54YcfEkphErCJfk1JTRwXShy1zVYkjowQnzZtmuG3TZs2xXWcXHrppXoBax2LRCIs2R99Eufvh0RSu6KtvxVBfgDs05zHViQORFOqAXxp2q9TOjWpdEg2oERX4oRCcN998NprhEIhva2biSqe7ZQ4LYk1quUzlFdQQG2tnTK1azWitow5lRrEt0XmzZtHVlYWjzzyiK5EdSJxAJ3EKYpD4pghfyu1IXH25+YKG06D+u5VP4dycy3r89k5349BEP1OJE68Ch3SvmtG9P4cOHCAQq2O5DLTuiHEfamDNdTUnzlKXdDLgUr79xtInHhKHKl0/QvYaLK3zEqcsHLPIkRVOeq795YLLxS/16ypP3vq81OUYDq1Fvv326a61duk3Vdpx8j/6vFztYAmVSUUN52a9p5vB2Rt2wZZWTGpXVNJ4uj3t7Q0mtr17rth6VI480wWY0xFDS5q4rggcewIGydbxDagxFSfT33GE1Xi6CR9HBLH/L4wpyuxOv706dO57777LM+3sLDQYM/YkTiHKrXrtddeS926dRkzZgxnnnkm69atY9KkSZx++umHJDrXhw8fPnz4SBTdu3fnhBNOiL/iYYouXbpw8cUXM3ny5EPdlKTg2brYsGGDIzOXm5trmMDEw9ixY7nyyiu57LLLOOaYY3jxxRfJyckRxeAt8Mwzz9CvXz9uvfVWWrZsyQMPPEDHjh0ZN24cIAy3p59+mrvuuouzzz6btm3b8sYbb7Bx40Y++ugjAPr168f48ePp06cPjRs3pn///txyyy18+OGH7i9EAlDl4PHglcRR3XtWJE5Tok5nlRhxgjTE1XRT+zGSA25TmGSYHMKyDXnACJkveMAAePNNQDg3wEg4gTElViOik9uKRNUVwWCQYDBINtBSM/YliSOnTk0R5IpM95AsiTMPOLZ6dc4BbiaaLuVqjJPKQqUPeHKc2ClxSkuFoxpnEkfNQh3PcaK6zq2iUd2mU4NYEkeSZqsszkc6UuyUOD/++COV336bQGkpBR078jPCCThR+11NFaSmo1Ih+490evxkcZx87b/sySs2Gp8YOUW3VOIoNXEsHSf794PijDI/55KM2ZSerpMYnZXfxwIjgNu07wcOHIhR4oBwkqrHr2Kql6XWxNHbaPqukjjh9HSwUKccIEqsxkupVmqq79NG+18XOJ7ESBzLdGqlpVHFjUZwOtXFsRtrzQqteCROBSCgnUNSNXEikYRr4qjtcnIemJ0oGzZscJWH/p133jHuSEtLcxRCieWlELuPwwNeSJxCjM5qdeS0InHU9/uPyn+zBakeXxrdq0zrJErirDOTOO+/D/ffD8OH0+G332Lq4UD0vZJDNJXVJYh32D2m48lnqK1G8C5EvI+lQ1S+GxMhcSTuuOMO8rV6fPKar5k+3ZqEkEoci9SuTmO4/K3ExhYJBQK6KnhPWhqqm9WgxDHV53OyRTIRqV1nA9kOqV3jBZSsRbyrsoCG2rKRI0eyfbaovKRe80JE/Q+wV+Po74KPPiJ9zRq2I+5rBaDrvHm6whGclTjpCMUz2vYHTGlB87X/ktyImK69VUDJH7NmiTbm5enLEiFxclBIygoVyA6H46aYi0QiVFfaUx/xXlD7byXN3ldJHElWyePZ1cTR7Zzjj4fsbMN+ZT/KQVzXZKDf319+ETZb5coitWv9+vDpp7THqIQCKPFSE2fbNv05VGE1zpoDLgzts9kGounUklUF17ZS4sRJp2a2qawCSmbOnMn999+vr9u7d2/uv/9+xo8fH9cWMdtmAGzYQO8bb9TnAQfTFnnxxRepXLkyjRs35ptvvuGqq67i3HPPjfnz4cOHDx8+fBxanHTSSbz55ps0aNAg/srlGJ5JnFq1avHHH3/Y/v77779TU3FkOqG4uJgff/yRXkpu42AwSK9evZg7d67lNnPnzjWsD9C3b199/VWrVrF582bDOlWqVKFr1662+wRRz6d69eq2vxcVFbFnzx7Dn1eYiQwneDVAbZU4mgJATnZ3EjtBitcGc9STar57cZyo2IqIdkwDBsnJ+W23wTnn8GGLaOZyM+Gkkjgnmn6T6cuCwSBpaWl0RqgSNhB1hEolTjMEkZOGmCirjqdEI7hWAh8BTxN1sl+Iks+8UiVD7SIv6dTCFSta/q6SONtNE6XdoDtS1OliZmamayVOG4vf3aZTgyiJY05ft8YimlemtLNT4mQhSDGAbRdcoC+XqQDPA/ohrpk8L7OeT00gspZof1Jhnlqv3W5cy5HEsamJU5KTE41SVlKqmZ9zGbm6MS0tRonTAHGOEFU07d+/35LEaYCxH1dNUomz55hjwEYNJvtSvAjY33//3RBN3VT57Vy0vlxcDD//LBYqJI7lpB0bx8m2baL2TTAI8l3UWKu0ZEHi2I215jFedfxajRGyz4WJPhsJpTDZt093DBtInA0bBEGlwFwwWm2jU/SreZzeuHGjpePEKQIYEE4uxLNZF/v75OPwhVVktBNU+8COxLEiRt5GECDDLfYp+93MmTP1movxUrs6BZSoz8lKbUw6AoiEQvDgg/pvF379NQO0zyrhtJco6S1H/EHa/6Gm42VpDuj2mvNaq7ARE+DgROJ4gWznqaWlbEaQF9+ivOuTrM9XavMeCIfDQm0A7DTZuup7eHNhIePHjwfikzjtEYqYXKC5RTovtyROhOj1ltZlZaKkwG+m9aWu3460CIVC7Nixg8gTTwDwAvCA9lunH36ggmIzWylxiom+N0/T/i8g9n7HKHFMdpN866nWoZ4Gtk6UwlPH7UKVxHF4rqUtsicQ0FUv5tqTan+RASVHKssqIJ4PA4mjkQuqLWKmk+Kqgk1zQDDW1HJTR1BFBjAFeF77rr/HZI2VLl302pN20NvolE6tUqVoYImFGscqoKR///4JqYLNJE6y6dQMNXHiKHHikTgAp5xyCvfddx9vaoF7EnPnzo1ri3Tp0oVFixYZ1uGzz6i0fj2XaV8PZnr0oUOH0rNnT6pWrUqVKlVs/3z48OHDhw8fhxZ/lxSnnkmcXr168dBDD1n+FolEeOihh2JIFjts376dUChEnTrGeME6deoYCoOq2Lx5s+P68r+Xfa5YsYJnn32Wq6++2vJ3gEceecRgjCXC3mWaa0w4IJl0aqrjpMAUuWdWtrhpg9kYXq18TpTEUXPlB0GkauoqpojvtGzJJMTkY45pP1YkjsxhrpI4wWCQbtp3lbpTlThyMm+ewCeixAGjk/cbRB72SkSJB6pUMdzXeI6TDKIp4iI2A04oFII+fSA7m+8tiBF5vVRiIj093dZxko0x+tSKxPGixJGkmVmJs9qiraoSx6oXDUQ4ANcCO086SV++GPjjyCNJR6Thkf1KdZRIqHSMVSo1IEahcsD03cpxIkmcz36M7tUw0YZoPnWFxLFLp7YhLQ20XJ2NEI6sG4lGmEoCRJI45tGoPsb+W11zLMixQc1DL+HkONnVvj12cCIEg8B8hIPqjNNO45RTTtF/U0mcc4DSkhKRrqS4GKpXjxIvQAuF2FURkm1UI5jlOF+7drSmjlTiWKRTsxtrnUgcK8eJPP+9oNctSEiJo5GGBxB9bQtAerqhYLWEOfpVbaNV9KsdrNSzRUVFMdfGcN47dkSvNSLCvdAiWt5H+YOXdDpelDhgJFcMxIdmi9QhqjhUSZxShCNcrY0jIY8/Z07UItiLkZT3Youo/Vq2MQ84q7RUEJOVK0PfvmSGQgyzaCsYU6oFidojjTC+NyWZ2lF7NuQZeCFxvNgi04EZubmsRQTKVNDadjnae1Vz7qokjhzp3JA4YRckzg4HEmeB4rwOBALs1a6PlYvzOOVziyRq4kBsXRwZULIlPT3GTpA2pR2J8+2333JWzZoE5s0jkpnJc8Cn2nYVioq4RlnXSokD0f7TVvu/wOI4+dp/eZ7mOnVWShxJ4oTsSBx5/4qLwaHOjUyltj4YhGOPBeBY5fezEEFhsh6ltEVUEgfEs66OH5UdlDh6G03fY+rzmerhgOjr8mzcusvlc9UB6Atcg3h+9feoJHGOO85iayNc1cQBx5RqduPsPtN9clMTx47E8ZpOTa2Jo4/tKVDiSKw0BdbYqYLVfa5evZo+ffoYG7B0KQCNlW0OFiZMmMD48ePj/vnw4cOHDx8+Di0q2gTGH27wTOLcddddLF26lK5du/Lee++xePFiFi9ezLvvvkvXrl355ZdfYvPml2Ns2LCBfv36cd5553HllVfarnf77beze/du/W+di/oEZnhR4qQqnVpxMGjIF+6FxJERuGZjWDXfvdTEMcOgsvn3v/WPpZEIgxFEjfkqW5E4DyAmfY3RctIHgwQDAc7Sfp+nbC9JhSZEJ+hqKjVIDYkD8JL2/1K5oHJlw4QrHomjLndU4lx0EezZwwyLNCfSUaCSOIFAgP2a48TseO+AIArkNPRoooXvJRJR4rghcVYiiJeKEENKAEj3/9tA2DQpfPWkk5iAqFsgr4I53Q4kRuKY02ZYKXGk4+SFjz/Wl8XkLa+mJQlU0pjYkTg/79zJrxs28Jd2n3oC6uhUB9E/zOnUdippR/S+VlJCbc1xIu+Hq3RqyjO7s21b/bPZoSD7lhWJ0xihJOqMcI6o9dKaKOsdBQQWLYqmUuvc2VBf4S8L8gVsHCeSWFDSyTilU7Nzguw2pTtRVSZW20jHkeoQTIjE0VLByWc3DNGaPg7vnXgkjgrzOF1cXGzpOLEq9K7j118NvzXk4DpOfCQOLwElyZA4hoASzXlch+jz4NYesVMFq2N8oiSOrNuTBjws9z9iBLz3HhvkmG3RVpXEaUs0BSyAWjUyGAxSA2imPZtyBFTfjTlEU7uqJI58Jr3YIgXA1XXqcBSCwLlZW34t2hit7avQY30+Ob6HbGyRcDgcTe1qsvf2EX1vmm2RfQ4kjqr8aJ4kiSPtPGmDSNJshcWzIEc2u3RqEE3fWnD22WxBEPdjtGU3I649RJU4ZhJHtUXCWKd2NZMbP5myIFgFlEjVjh2JU5qZCfKcHVKq6SROWpoeYKXej4cQtmI/2RabgJIjMfbfypr94CWgRCVxSipW1ANczPBSF0dFM+XzeViQOF3NGqRYlFgpcUIhkPVdXZA4bgNK4tXECQJp2nU2p1NLiRInjirYfB5mVbAKN6ldCwsLY/a53aSQZ4moUpSNIOR9W8SHDx8+fPjwYcY/VonTpEkTpk+fzr59+7jgggvo2LEjHTt2ZMiQIezfv59p06bRtGnT+DsCatasSVpamiF/NMCWLVvIUx1wCvLy8hzXl//d7HPjxo307NmT7t2789JLL+GErKwsKleubPjzikORTi0cDhvqgrithwPCEO/Tpw8fK45pSE06NbUtS4JBoSbRIM+9NGaL6MS3FdGIyq+AWdrnMxAThlYrV3ICIpr9XWX7tYgaHtmAjOUrKxLndYRjXKcrKle2VOLYDSVyeUkwSIZN9Kt+TFOefwnpKFqtLAsEAuzX+mI6RjJCJrCajiAz0ok6PcztcuM4kaRZHaA60cnyKsWBJBFS2muVUk0qq+YQ+3xsTUvjMgSZ0h64HpHKzgx12mflNAH3Shx53YJEo23VZy8m5YVM1+iQTk06QNYCrVu3ZonmvHgC4URbRtQZ1JRYx8kyzeloSKe2ciXpkQgFRB2R4XCYItO5mZ/lIq3P7Qd2Nhc03HPPPafXXpBwSqemOsHM91S+JWQfyZ4yRSdxNtSrhxtYOk7k2K+qMc3p1LZtg0mTYOdO/R6YxygnEscpnZodieM6+tVE4gBwpEbvmUgcKyXOvxDO7Zqm++SUTs28L7BW4hi+//KL4bdGHNwUJj4ShxdbJGUkjom430ksQW6HVKuCDao6BPkPWr2UnBy4+WaoXJlxvXrpah8z/auSOCdrn6XbsL+yXlpaGrKa2DLQU0epJI58x25VfofkbZFS4GWEI7cZ0ZRvZGZSojhWvaRTs1MFRyIRaCSoqE0W/Uu+t/KVZaotEo/EaefQpmSUOCstSJx46dQaIdSjALsuu0xfPhHYnptLHWARIrWuJPeMMxLj+P4HGIKtJMzkhvl5cVLi7FVqlxr6eyQStUUUEsf8jEsSZ52ixGmFeJedTlRtJgN03CpxqmoBJYmmU9veurWusDU/F/FInP6IdIf9+/c3KCOaK+uch/au37MHftN0+gqJ89Zbb1nu2zK16/btgsgJBIQyGBJS4ngNKFGf46SUOAcOGFITbwYiGRlCFbzRfjbpRYnjtj6fY2BjJKIrcUA8nz6J48OHDx8+fPiQyNH8Wr17946z5uEBzyQOQOfOnfnll1/48ccfmThxIu+88w4//fQTv/zyC11cFKOWyMzMpFOnTsyYMUNfFg6HmTFjBt26dbPcplu3bob1QRR+lOs3atSIvLw8wzp79uzhhx9+MOxzw4YN9OjRg06dOjF+/HjHqOVUoSzTqf0FRDIzycc4OTSTOF6UOKWlpUyfPj1muROJY3cdrUicLxCT0vuysgxR907nLp3wMtJ1KWKi+5n2/QwgKxDgtK+/BkS9FDUNSoho9O7x2v9UkTjmehA7gA/UBSYljrnQ6JGISdJ/TcsLMzP1vPpmfPnll1x44YXs3LnTsh7FdYic6+pdDAaDFKWnI6+ySkfKp3c+4tpCbEo1L+nUCog68voiVD37gc02TkQZhWx2+FdTls0jduIq0zhFEOl4xmFN0qjpd+yUOOaaOPGUOLURUdzhQMAQbRtD4sRR4gSJ5uiXpOxibcyQDpWxGOs67d+/H8JhPfr2V81xY0inpkXv/kE0zZe8fqqTyPws76tWjWuB80F3+I0YMQIznNKp2ZE4lYhGKI/V/lecOpXSeUI3d+2ECa7GwFKHdGpbAgEKNIeRrsTZtAmGDoUGDWDwYEpGjNCPY3Zse3WcyPNXt0pGiWOIM5XpOx2UOOFwmNDWrYxGOKPbSQeUBrOzRB3fIpFIzHhXXFzsnE5NU+KEtL7REN9xcrjAqxInFTVxSgMBw/jrVRUM3pQ4bmvixLTlmmv0WlqbK1bkJGAk8IlpPyqJ00P7PA5BCnUh6kwPBoM6yaOmh1XrxclxUlXhQGoCSvYBE7TPslafnSrYKTRJJ3EqVbL8PRwOw3XXwdixvKHUhpOwI3H2abZhDiKFrERNjGrNVsQWrE+FEme5xbPwJyLYpwpKTUMFgxDv66+AIiVorRR4q2NHirXj3KgsNxMy6vhulUoN3KuCrWriXHn//fqyGFukRg3xxUEVLG2OPwoLCdWuzebMTIJAJ5R+hFA9VCY2oKRIe/7MSpzaWnCBJEXD4TC7wVAv0vwslyjv5i1trJL8CjiROFmIgK7XgQpbtnD55Zfrv6lKnM5AcPVqEVASiUDDhlECBrj44ostj20ZUCJTqdWqJVKiAjTTjuZBiWMOnHGrCi4kWhfTPN9wBc0WkamJIxC1RUwp1cwBJep3L/X5du7c6UoVbMCGDaBco8b4togPHz58+PDhI4oNGzawYsUK12KT8o6kmIsOHTpw3nnnMXjwYNo71ExwwsiRI3n55Zd5/fXX+e2337jmmmvYt28fl2nRbUOHDuX222/X17/xxhuZMmUKTz75JL///jv33XcfCxcu1J2LgUCAm266iQcffJBPPvmEpUuXMnToUOrVq8eAAQOAKIFz5JFH8sQTT7Bt2zY2b95sWzMnVfAS/eq1QPRuYPs779AL42QoFAoZHMteHCd2bUhEiWN17v9FTCi+MjlbnIx1OfGVE9XZ2v/Ptf8nACP376fmrl1sAh612Id0gstphV1NHK+wcrT8V/1io8SRk6rhCMf2pQilkE7iZGTYOt0++OAD3nnnHf71r39ZKnG2IQq2qi0LBAJkZGbqznc1DYwkcRZgTeIEiZIXbhwnEHVWSeLtDyBi00/UujgqZBzkckQfMF/rAwfMehlryP6zgdj0JhLFGJ0l8UgcWQ9nT4UKMc+eRESNfrWpiVMHQXKVEo1SXaLc963A/4j236aI864ZCpGBICh/1aIMDOnUfhfuKzURS7t2Iq5ZdSyZp7yRSIQXEASp0zPhlE7NjsSRzrmtiPR4xUDWX3+Rvkz0gAW4GwOd0qmNnzIlGm1RvTrIwrJvvgnaBD//nXfYuF7QvOYxSieAENciXk0cp3RqWUCGW0eslibEoMSxIXHMjpMKr72m98sGG5xHe/UcrBz1oVDIOZ2apsTZfLSIbW+I7zg5XHAo0qmZbRFzjRknhMNh3njjDZ566inD8tXK50SVOBC1iwoBbrnFcNxlwFPEKoPl81kHkBXa3iWavlWmc61cUKDXxZuibL8GMe5lA1KHbEfieIV57HxB+687q031+eLVxMkhai9hQ+KEQiFBDtx8M1strr1UoqjvnEAgQKHSF1Xnu3znL9Pal0VURSPhhcSRdkgdoCrR99FKC9u0RFnfKqWaDACaQuw9+q52bfIQNfxeRKRmexajDQbG8d2OxElGiWN+9iQMtsiOKK1qp8RZjaiF+otmW9yE6O/FRN/9MqBEVeIs12oAGpQ4+/ZRQ3uvSrs7HA4TwUhYOaVT29Ra3JHff/+duXPnGtZzInGOIaqKb2v6TT4X8vpWmjpVT6UWchmYWOpE4shUamCtxCkthUhEv0/msUslcSKRSEKpXVXlv1dVsDpuR+proUZr1xpWVfuYtB2OAR4DckzkVLzje1biaKnUJHwSx4cPHz58+PChomrVqjRp0iT+iocJYuURcTBy5EhX640dOzb+SsD555/Ptm3buOeee9i8eTPt27dnypQp1NFS4axdu9YQUdm9e3fefvtt7rrrLu644w6aNWvGRx99ROvW0anWqFGj2LdvH1dddRX5+fmccMIJTJkyhQpaOo9p06axYsUKVqxYQX1pkGrwGvHoBV4cJ26d0ioKu3SJURckk07NDYmTTE0cEISTo6PQBFMWZJ3EWY2YLLcCbtYmiXdhPblX49+Kia2dkkgeejt8i4gAbQFQpYpl9Gs2wkEi039lIer9yKMXZmTYKnEklixZYkniWCEQCJCens5vQHdgMHA/wrEh00osJFogVCVxKmdkENT6hRcSpwdCEQRi8m53beXEvr1pudTQySm7uY+4fV5krvsZjmsJh4J0jMRLpyan57uysw2KkJjoVy26W3XEq+chI1g3gq6SWhwMEkL0j+cQz5vsv02BqVOnkqU5/TcB67Xn7Aixc7GipsQxK87keUqYHSdq20KhkO2Y7jadmkrMyRiIFdr2M4j2jw2IcykpKdHHbDuUyHHFQomzGZinKXsIBOCcc+Ctt2DwYPi//6PgxBOpBcx75RXAfoyC2AhZJyWO6jhR1Wo5bh2yVunUJIljcpwY2rhvH5WUFDENNm7U619AbPSrebwwP5OlpaX25x2J6CTO6jZtOGLZMmNBaB/lGgcrnZpKI0oSR44DXkicUCjEpZdeGrN8tfI5GRLnV+BcRNDFDXXqILd0Om/5fJ6CSBW6F6H+/ATxXj1b21/PKVPIRdTCmayeE0KN0BKhIIayUeKAIPCnA73kAhtbRNIzGQgV8yJgPNGxLQwEbUicjRs38tZbbzFo0CDLceApxD1Sr0EgECCQkUEBwrlchaiNJ0vJz0PYJScgUqqplbi8kDgFiD5XH+hItAbRcptnQdqTrYCppt8kiTMHuNLCFtkFfKj92cGNEqcAQR7KN1M8JU4aUYWrauur99qQ2tWFEmcNMH/WLM6qW5de+fkM0Ja/iXiPn4y4P2YS55cqVWi9cydHAj+YVMFbiaqiVVWw1qqYZ7mwcmVmIN6tRZoqpl+/fpjhROKoxE0r4FOiz5W0e19GqKeqTJ9OpEkTAsA9n33GfSUlccfMYmk/WASURPLy9DFFVwVv3gwTJ8Lrr8PUqXDnnYSvuQYQ6j31fqgkTjgcTkgVbJhvuB1PtHo+huwORx4poj9NShz1mQ+FQpQWFzMRMX+YaKE6kkg0tasBSio1EHMXqc734cOHDx8+fPj4u8EzibNo0aK467iO8tEwYsQIyzQ9ALNmzYpZdt5553Heeec5Hn/06NGMHj3a8vdhw4YxbNgwT21MBbw4TszFw93AypgPhUIJp1Ozq2+Qj5hMVSa5mjgS5nY7GevbTN9nK58/J5rDfHOdOkww1UWSWK58XkFshG2ijhM7PAy8AXxbXMyoUaP05arj4RSijm2A3kQJi6KMDCraFBOW2LNnj2cS52mEs2kE8DgijQQIx9JOrJU41TIyQJtAuqUZZUSrnFj+jv21/RbhKOqMICJkf41H4uzfb3ZvWOMbBLHwV5z18olGtLpV4uw0EW0x0a9du8Jzz8G331quI50fqpt+TzjMW4jr8Zy2TE2ndvnYsbpTZT2C/AghFD3Ze7Vpu6bEsSJxnNKpmUmcf/3rX1jBLp1aJsZc8y2BAIKcVEkcEM4uSeIs1P5LR4XTc+hUE0c+/RMnTqROnTr0HD8eXn2VwuJivv32W0LaMTtojiyn8dlMaLutiVOCIN6ySBGJY1LiqPco4513SNuxgzUIR17FAwcM0b7quoFAIKZ/ms/pwgtjq0rp22zZIhyAwSBrWrTgeET/DWJUgvoonyhLJc5uoPiOO3jy4YcNfThZJY4VnNKpOamCze/Kx4GfEY7dEeGwnv7HjS0i35vfIcbejxEF7k9BKGxaLVpEGLiBWDXGn4hxsar2PVUkjlUAznMYSRy7+nwBhIrkesS77m2i5M6B9HSybIj1J554AoBffvnF8vgztT8VgUCAjIwMdhMlcSSkEucHhK0hSZy3lXUkiWNVT8YKfyBIHKkK3grssim6LskisxLnaESqt/0IkitRW0T2nxJEClg75GvHg/hKnDzEGBwKBNhmU2jeDYmTTtT+ka76Jcp9DyOemX9hJHGC4bC+3ZLcXC7AlE5NU9qq6veLLrpINIWoQjfGFiHad/+nXe81JhIB3JM46j2tjXh3hxG1B0cAucuWEdECJr4+cIBhq1fTTKZBs4FTOrX/zZjByvvu47777oOqVUVAz/btMGSIvur2xx5j5+DBgEg/pt4PNbVrKBSKW59Pnr9ValeAih5JHK9KnNLSUiKffabPHY7eZpy5eVXilJaWOr+DNCVO/lFHUXXNGr8mjg8fPnz48OHjbw3P6dRmzpwZ9+9rrR7JPwW1LPJ/W8ELieN2IqjCyuGQDInjlM5ITp9STeIsXLjQsg6PhBq9+BfG8/lc+Tzj9NNtnYlqTJiVYzvVJM6bQMG6dZz85puG5cVE81X/n/ZfTpZ6Y6yJUy9Oofe9e/e6TsEnHScfIgibmsBlGFOpQbS4bwOiTqbKmsOjgFiHlB3+NH23uuYSm4ENR4kYUFk4OEjUoWNH4qipr+LhV+ITUPnKZ7dKnB0mx2iM46RnT/Hlxx9Bm5THI3FCoRCXIshJGbmqKnEgquBZBxSGQnqR7kq7dwvFhEU6NYl46dSszsUMu3RqRyMiuncj+nmu0lYzifMJ0RR7sv/J/ux0bEvHiaLEARgyZAinnHKK+BIMcsUVV9C3b19djXW0lnbMaYxSn60cxP3UVT4arKJfIepgdEvi5C8XNJ061kVsSBw9/QqQ84JImvQUSr0npY3hcJhLEBH2gXA45rq6Ge/0505T4dCkCbuqV6cYca+t6kf4KH/wQuIk4gwrvO027jAtC4fDhuLuqSBxEq3PZ+77exFEcgkWqgUbmANKZmn/f0cQ7VnA+9qyV7GuwWZ+N6aKxNm7N5bW+BTl3WKjxAExTg/VPucgVMFybDuQlhZXFTx+/HhPASUZGRm6HddDLgeO1T7PI0pytFO2zcjI8KTEgajtIW2LZdhfW2n/mCuwnKD9n09sfwH3qmA5kv9MbN9Vka98jqfEkVbizqwsg32m3o9IJBKtiaOkkFafifoIVU8hUZt0SUaGHvA0GWFPyP7bHPjzzz8pWL6cNMT7/heN9MkDAvL9qdVpU0mcddo7zSmgRL1H4XCYmTPNdKCAE4mj3sdWymcZaLIGMSZ9o30PFBRQjDVRZwVLJY5G4qwrLeV+pUYRXTWLtmZNuPVW9gE1i4uZ/OCDQOzY5VWJY0XiyIAS8FAXxyKdWkiSOE5KnNJS0jVSF6DZtm1RZTjONXHAnSrYAE2Js7FTJ8BPp+bDhw8fPnz4+HsjqZo4dli4cGH8lf5GaNiwIWPGjIm7npdUM6lS4qjp1EqJdTw4wYkUkAV6zQ75ZEkcvYaFDVTH5mzTb98hok2frlqVtQ5Rc6oSx1wPx9yeVKHTqadaLpfOk/7a/1u1/+2IRiUWZWRwxBHO7tG9e/d6VuKEEA5dEBGVUu0yX/u/m6jTR0YuVtXuo9o740UoeiFxAJZrhWsHad+PQTiRCog6VpIhcdxAnfzGi36VJI65olaMEqd+fVHUNhzW1ThW6dTW2exDQhIfeYjJuEwIuR7xzErnaJU9e0S0565dhDH2e4l85bOTEsfpmbBLpyb7zFKifUDWITCTOFuBnV27EgkE+Epb5obE0fPQ26RTUyEdA2+99RYQTanX4K+/SCc6Rg1G9PtLlG2Li4vJQdRA2AZU/O47unXrhgqrPPQQdTC6IXG+//57ls0WI5s6VuvRr1u3gpImRF6bM4H0v/4iVKkSrxKty4FSMyCjqIj/Ioq01/nzzxjHnicS51ctTr11a0ojEX2caBh3Dz7KA7yQOKm0RRKtz2c3Buwn6mA0u86dbBGnMcWsQLSD2Zb6Rvn8sfa/ElBUoQJ32uxDfTfuBMza4VQGlISAcdrn9RUqcP311+u/FSGcvCDI9z7Kdv2IOn33p6eTnZ3teByvASXp6el67cBbEORXC8R4ug8RdGFF4mSnp+s1Tty+/WUgg3zXWtl/Ej9o/zsSfceDMZUaxPZ1t2mcvkaoPobHWU8lN+LZIpLEiRtQotXEY84cy3VkKrW1RIN1CiIRZiL6ysPaMpXEuf322/VAlHWIvlyImGRWlqSiRuKYyUrwpgrWgzJMcKvEaYkgqTZt2qTXw5H20SRlvcWI83UkEDQ4KXFkjcNffvmFP/74A157DWbMgPXr2XjTTUhtdgtN3ZJmUoeZzz8REgeiz0luEunUQnIuYlLiqPZE5rx5pM+fTyFiXM4tKtJT6ZnhhsS55ZZbeOSRR6zbWFysByqt7dgR0IJJ/HRqPnz48OHDh4+/KRImcQoKCmIizn7++WfOOussusooo38IgsEgxx9/fNz1vDiaVfm8W9ilU5NOjk14S3XjNBEfgXAezzctd4p+tYPabjXizApOJE5Ya9dzNWvatgNExJ08s4OhxAERpWgF2SPSEROltxGRf4CeJqsoIyOmdpMZ+/fvd00+yehXEPnutyLyw8tCzGp+dnNKtQ7aNcnXvn/yySfU1nKU2+EvojVeJJngdG3XdhYJak5EpLpQySV9P6ZztYo8Tgb5yme36dTmmiITYxwnEFXjaGrFeEocK2JuD1HHZROiDilJ4kgSqNLu3frkdmt2tqX6yG30q5MTwy6dmiRxfiHqtJEkjiQoVVXcL7ffzvovvvCkxImJfi0sBG0MMZM4ZufaYoS6Kau4mM4Ix0kQkQqpASIF4rXyOPn5fAb0Rdz3hvfei1l/aZVODaLPeLaL53Pq1Kn6flXHSec+fQjJFDhffqkvl/1Dkr/bBw2igKhiTVXidNq0Cel+rbFmTSzJ6ICrEcWs9W2kEqdVK0KhkF6bpCHC4TsIH4cClWzqlZhxqFK7pjqdGkRTqrl12WVkZDj2d3ms9evX8/7779uupz6fBRiVNp8on+edcYZt8IxqFVg5tlNtizwB7Hz7bVpNnBgTqS7Hrf9DOLjl+6IvihInPZ28vDzHY+zfv991QEkwGCQjI4M3Ee+9ughVsJxBLES8839B2A55CJsAoKrSh932ULMb2UmJswFYp9X/UJM3SyXOd9r/RJU4YUTQ0dI46+Urn90qcbbFI3FkUNFPP8GOHdHlGtR6OOo+zkUQNj9pyyTxIdUsaiBKSWmpbotU2aP1Lot0ahI7lc/xSBw72JE4tREpRsOIa5ZF1AaRbZfP4odEVcGSyHND4jjVxJEkTps2bWjRogWl1avDKafw3CuvcMQRR+iBK2010sRp/mJF4qw1ESp2JI6aNtENDmj7VcftsJpOzcZGrKqpgl8jeg35/nv990AgQHfgZjDsQ8L8TDrOnf/4Q6R4rlKFbQ0aUIBwbOTZpAP34cOHDx8+fPg43OGZxFm3bh3dunWjSpUqVKlShZEjR7J//36GDh1K165dqVixIt8rxto/AYFAwNHolvDiDPn0008BZ2PeDLvo17nAEoTD3gvsauKAmFhbRdI65aG3g9socBCOBTnZ+8ZmnWAw6DwJQlwPsE5xUhYkjh1U6uFdhFpqmvZdEidFmZnUrFmTVEFGv4KYLD+r/BYiOkEHI4lTEbhNI0te15bn5eXFRA2aUULU0baa+M629CZNWIAYnAYQJXHUUaWslTj5ymendGoZRJ0Am0zrWZI4MoJUSwfiJp2aFdS6OJLeW4dRiVN5716dxFmXk4MVnNKpeXWc2JE4SzGSONlKm1USp6hCBQpl0V/EuTz33HN899132KFEOk6k40xzghQHAoZ7KFYx3skI0RoNpyLGjXMQhKZ0QT4H3AlUu+QSeiIcnX8CGTt38ppp/3bp1HQljgtHUCAQsCRxFv38M+9W0VwzTz6pLw+FQvRAEJ6RjAw2a7XidOpmyRKdbDxhU7SH1li9OqZ/2o13vYEXEekqdfetJHFat6a0tFQncRoh7vGrcc/UR1kgLy+P2267Le56XkicRMZWq/HCrMTxQuI4kQIy6MHt/pwCSiA67l188cWO66kBJXMw1tabg3hePgeWnXSS7T7ckjipQgQ48cEHY4hmiNoishLWfQh7oDVR8n1/ejoNZGpHB3hV4pQgaqwA3EaUKJHj2H6i7zypxpGqYFVFFC/trDlox+qaq/izfXtAqDNBkAHNEGSAXWpXtySOWySixNlissliCPu6daFVK+FAt7BFrEic0tJSCjDaJysR16IygiRRbZji4mKdxKm2d69QTGg12qxIHC9KHDvYkThShbOc2FpHZiXOVmC7plSS9kGy6dTMASUyXbasBStt/sbr1pFFVInTHdHPzlW2LSkpIRCJ8CywEajy448cddRRqIhH4lR0cT7r1q3j63ffBYy2SKl8xgoKYFf0rskxuiOQO2cOkbQ0Hkex2xXVVxoi1eRYoMnKlcmNc1oqNdq0IRQO6/UuGyW+Rx8+fPjw4cOHj3INzyTOrbfeSmFhIc888wwnnHACzzzzDCeffDKVK1dm5cqVTJw48R+pxIlXqBG8kTgy53NurtuYKfvo192Iie+9rvck4HYiDnCe5jxMJJ0aeCNMzgPOx+gAVhGPxAExKToZ68mkbMvBJnHe0v5PM61TmJHhqn+5hUriADxP1BmwDKOjQCVx/g3khUKsREy+QFzreCQORCfI0onidG0rVKjAB9rngURJnLnKOubtE6kh5YR8dd+m3+T3usCXiPzqJUSdiRKWSocePcT/xYthxw7DOm7TqYGxLo5ZiWNIp6alsHBD4iTqOImXTs2sxGmsfd5pOr65eO3RRx/NiBEj6Nu3r+2x1RQma9as4fsPPxT7thhvrPqITKl2KsJxMlL7/gjwoPb5QSB73jz2IKLSBwLhzEzOBK5R9hUvnVq2CxInLRTS609tN/32em4uZGYKZ4imsAmVlPCY9vvuwYM5UK0aIAj2Xbm5EArRGUHAdlaKC1dfs8bgGC8tLbV9Js/X/ucCo0E4/mQ6NU2JI0nahkQjnH0cfASDQb1QuBO8pHZNROUYT4lTQKyD0QlOtsgoRC2Vj1zuyy2JEy8t8C6ixM0s8z4QKQ7Pycgg4JC6bjNRG8CKUCgLW2TZMmvqQrYjG/Eu+C9RpbVU1h1IT4+b2hXc9y9VFfwKIgVXQ6I1eX5Q1pWBN5LEkUEucry9//77aa+RLnZYh/F97qTEAVjVqRNhRAq1+kRTqf1CtP8mmk7NLZxIHLMSR96Zn7YYE/NZBpT06iX+azUo45E4VjZAMegEfsu0NN0WWYt4ZiXhU3XvXkHghELsT0+3DABLpRLHHFAiSZwlRFPymkkclVBdeOON7J0wgQ8tjm+HGBInEolJpyZhJvp+RRAyGSUldCcavPcUcBwixZu0NYoKCngTkXWgLnDMAw9g1salIp3a9OnTddWbSr6feuaZlEg13ldf6cvlM/9v7fu+s85iNdG0gyqJ03HPHl3BXn/9ek/1+QYSJXkBWKKNDG3aEAqFdBKnMSLI6ix8+PDhw4cPHz7+XvBM4nz77be88MILjBgxgokTJxKJRLjooosYN25c3JRPf1eUBYkj4TY9CthHv3rBoEGDeOCBBwBnJY6Khg0b6nUmEiVxvBBGXwPvOfzuhsRZC3oeajMOphJHTqpWEo06/Q7jJLZIcwJ99tln9JTpuJKA6jgBMXl+WTm2CknidEDkqwdRP0eqNoLBIMuXW1VbMUJGP8r9OV3btLQ0ncQ5BZEfHxR1AWVTt0hFvvLZTonTDeH83wucjTFCFawdJ+FatYi00srqzpqlL6+AiGSF+OnUIEqKHU3UcSOVOHoKE0WJs8aGxMlXPscrJmwHq3RqFYmSNb8SdVC2JOo0WWnaT9zitRZQHScNGzZkzM03A7DDQmlgReJ8rf3vDhx34ADdEX37OeBuog6JUE4O/RB98Bdg7XXXAaKmVC/E/YubTs3i3CZNmsQll1yiO3WytTaWYnTeAWwJBuFCLU5eU+N0W7+eLog+uO2aawz9ZZWW5vA4hEM5KxzWI4Irb9pEeE+0pXYkTjrRtI6g1W/4/HPYuxfS06F585h0ao3xcagQCARc2SJe1DWfffaZvm+3sCNxFiOee/skZdZwskX2IlS5bt8I8VRIsu3x7LUIwvEK0Yh9M9LS0uLaIj9r/8uTKvhjhAN4iva9k/Z/f0YGOTbvEhVubUfVFikkGhwi75BK4qh1cTKA+7Txa6K2vHv37nEDSiJEnfW7ECSa07XNatRIT9s7mNh6OFhsfzADSlQlThDxfoVov5RIBYljZ4vI69kkFDLUxFFtkWp79+qp1DZUNlMsAk4BJWrbEgkosSJxWgEBYpU4AAUVK1J4+un699LSUsaPH8+sWbNsjx1D4uzdqyuE7ZQ46lgkg7f6IMaNHsCx2rIgItjqPqDKVVdxIVGFe2Z+Pv/DOJm3Cyjxmk5NqoJVEmfRokW8Kt8Fjz6qp0MLhUK0Q5AsADuvugpQgq/+/JMa2sfe26MhKnkbN7omcToi3h1fEe2jBiWOicRpDPwv3kn68OHDhw8fPnwcZvBM4mzZsoVGjYRQuXbt2uTk5HDaaaelvGGHE4qKilylPfPqoARvJI5dOjUvqFatml7jxC2x0qpVK30ykiiJc8QRR6QsDYUbEscJZU0QqJCx8W8rywoxkimFGolzxhlnMHbsWJKFWYkDwll9JcJxreJ3xGSxIsJRPScnRy/aDOJar18fP5HNk8DjlSvzlPbdyXGSnp7OCsSEW7byD4yRmgeTxLGLfgWhfjkRocgxw6zEiUQiHHvssfxPXq+ZM/V1JP1dgNGZYXedpBLneIRDK4SI9jQocfbu1ZU4aypUiNkH2KdTCwQCSUW/yvQ7mxB1Z5YjiImqiOulnoOEWYnjBsXSaaeNHTIi1S2J8yeQX7EiWcBDWtTsW0QLjD+KqM+w+H//MyjBNg4cyJeIqPVpiPsmI3vjkjh//AH33gv5+QwePJj//e9/PPPMMwBU1Nq4g2hBaYlQKAQjNa3Qhx/CH39wiUbSPQYUV61qcLT9pY3j3YjWdHgVodIJRCKkSTWNtm+rvnYKUEO7Hh+gGQyXXy5+bN4cMjMNSpxG+CTOoYTbd58XEmfaNOFerGzjfLWCHYlTgFAPXuZ6TwJuSQGAkxzSl4F7JY4bDEdExP9g87ub+3EpQhlslTTyYJI46rgl06VOMa1zIM61kzDX27GD2RZ5geg7aR1GMkKSOG0RtTSalpayhajN4lYVLOviWKmwzahevTrvap8HE1UAqCSOub8kEqzlBDdKnDrApwjCHkQtIRWWquCTT4a0NFi5ElatskztGk+JA1ESpznGdGoGJU5BAfwmrvgGmzmNkxJHfa8lk05tCcZ0akcg3uElRBVF8njqcY499lguv/xyxyAqlcRZs2YNX74mEq7uT0+PvW/ae17t+1LT0hvRl2VSzOcQ5A2IbAoVv/qKIsSYcRpQWqECpwJ3KPu3S+2qp1NzMZ4EAgFdiWOu6TW2qAgqVoSff9bVOKUlJTyFsBF29OnDvoYNAdF/12upYLsj7NUeO6N3u+6GDTEEod14J1M9ZiPqewFRJU7btpSWluq2SGN8VbAPHz58+PDh4++JhDzd6qQ0GAyS6ZAu4p+AXbt2uYpSTaSuSbIkjlfiSI0cdes4UY9h57CI5zjZsWMHM2bMcFzHLVJF4hwMx8lDiHRNj5qWqynVihSHdCqeNbMSB4QD/xWE81hFCdEUaKXAo6aixm6v82bg2SpVdOe4E6QjRo3WnmtaJxFC1Avylc/mCfgv2rKFaA5+m32Yo1+Li4v58ccfmbxbm1p//bW+jpqGxA1k1GhT7f/mQIAQFkqcv0RcohsSJ9l0apWJvlDUVGog0q5I0qa/9t+KxPF6X/V0art2cRPRPOg7LUgcO5L4dy090BEaaf2U6ff5wN7q1Q3LQuEwlyIUgVsROd7TgHBaWsw9jCFxrr8eRo+GG27Q15GFiXM0B6A5lRpo96BNG+jbF8Jh6NuXegcOsAkRwR4KhQzOkBUaiXMCIGOKJxGteZUunR/YK3Ek+fMhcCsa0SfTsrVurbdrtbZefaI1onwcfIRCoZQrcSS82CJWUfteCdo+ffrw+OOiUooXpe7UqVMdf49ni+zebXZ92mM6wslqBze2yCpgss1vh0KJs5moQ3khRptAkjjTpk3jjDPOSPqYZltkL/CM9tlc81C+Z1sC92ifbyXqqA4Gg+Tn58c9phz15P6crm1OTg4fIIIkuhJVJKmEm7lvpvpe5Suf7ZQ4rRFj/H4E2fSraT0rJU5RZialXbqIhdOn68sDWNfni6fEaY7RjlFr4lRXSJy1NuOIWyWO0zhiReKkEw0qUZU4zYjaKX8h7rFEIrZIkSQQNVXwo5oqeJeF7WWlxJmu/e8A9CgtpZ/WpieB+4HrEGrDcIUKnAl8hiAkl2l1de4DhiEUKlW1fXlJpzZp0iROO+00duwQT3x6UZFea2mrad3tkQhoShvGjAGg/Zo19EQo19eaVMHLtbnv8YiUtJVDIbZo51dp717CpkAwq2coQDS1K2gpHj/4AOS2rVsblDiNiNrHPnz48OHDhw8ffyd49nRHIhGaN29O9erVqV69OgUFBXTo0EH/Lv/+SThw4IArZ/Zrr73GgAEDPO37YCtx0tLSdCe6eXLaQ9bzMEGd7CSqxAHIyspy2UpnqOeQCA6m42QZIpLUHLtpIHEU4sZLQWo7WClxnCDz4j8P/JWdbfjNC1mm9g2nfinb9oGyzEzinH/++ZQl8pXPZtf/ekTkaxdi05aoMDse5PdvgEggAL/9RprmEFfTkLiBORXZZq2/FxcXswkx2U8Ph4Wzv3JlttvcbyfHidd0ahBN0yHrFfyi/CYjn+XE2kzilJSUeB6vdleqBG3bQjjMU8Dt2nK3ShyAZQox+ZWpzRKff/55TFu3IZwKdRAFpc8APrrllpj89zqJU1oqCgFr9c548026a7/JyPUcrY3myFdQ7sG//iX+rxFx0vcinHdmEmdN9epEMjKoiYhcXY5wXMraTZmKEqewsJBbbrkFFenAOdrn9xDO5v+oK2hpAUOhEJsR/Scd8Vz4ODTYuXNnypU4EsmSOF6dolWrVqVBA+EWdkvitG3blgo2hLVEvHdfo0aN2LzZnAApMRxOqmA5bv2PqEM7jNEWkSROr169GDduXNLHtLJFHgQuQqRtVbEO8b7KQCiDf6pYkTeV34PBIFu2xA8TeR549qijeED7Hi+161aiNY/SEUpGVaHiVnWUKNwocSCqCp5ksQ/1eZR9qlmzZjyg1VZj+nT9+ayNUF2HtH1KxFPidAA9XZZMpyZJoGoFBXo6tXUVK2IFJ1vEqxKnEtHJbXMgC2GnrEHcv92IfnSmto45IXBJSUlSqV0BveaLE4mj9v2twPqaNQkC/9klroZ874Lot+2Bn//3P53wAdhwyimMRwSRjEcoiqTa2U6Jo5M4S5bAsGHw118MHjyYKVOmcMcdQtNTQUtXeIDY+Uk4HBaq4IwMmDULvv2WIYuEZfEkcKB2bcM9+72G6BnHA0O0Ze+gkI2m+mNW748TEUEi+cBLcqFUBR91FFSpEpNOzSdxfJRHNGzYkKefftr1+rNmzSIQCLgKUvDhw4cPH/8MuPfkahg/fnxZtOOwxv79+11FvzZu3JjJkyd7yi1/sJU46enputPB7DixS6filsR57733GDx4sGF5Wlqavr2XlClOCAQClo6TBx98kLvuuivu9mVRTNgrfkY4cmsBhQq55YV8sYNXEucOBPEwEVG8VkWiJI5T4WNJwC1DpKlpB4ZJK9gXD65QoYLht4yMDE9R3BLq5NfK9e/GBWpOYSLbsRMobN6c7D/+oJI2ebWKfI3XPtk/ADZlZEBpqSBCENHU9eTKLVrEpOaSyFc+q1c0Eom4VuIUIZQ2mQg1zh5ilTgg7uc5yvdUKHFCgYBwALzxBquvuIKG2vIdFoo16TgJBAKGZ3tJrVr65ydtjiMVARLmPrVJ+zvNoi6cXjA8HIYvvgCl748DOhPtzxXdkDi9egniaskS1mRn85qmMDKTOMXBIHuaNKGKlnJNOvekEifrV2O89rp1RgpRTaUm64c9BNxaowbs2AFaEfFQKEQE4SA7GtEPUlva24db7Ny505V90bJlS5YoSiw38JJOLRVKnPT0dP1d4NY2cHqvSLgJhPjwww/jruMGh1NAyWOIZ/hF0/IpwAXa5/3KtUtVQIl5PyGM6WVVLAZ6IFTBjzdsCMoYFgwG2amkabJDPvBu/fps0kjweKldAd5F1L8DYyo1cG+LJIp85bPZFvkVQZisRDjH7ahHq3Rq69atYzpC5cGMGYTuEfomWWtkI+I6S8RT4sjtdiPeebmKKrhicbFO4qy1IXFSmU4NhC2STzSV2lKiKUp/QRAKA0znoB7P63hVKJ/zUIjxRN/7+RYkjky5Z+77vx1xBPW3b6e2duzHTNstBfbUqGFYFg6HGYE411MQSrVMIBwM8ofpHGKUOP/+N3z5Jfz5JwHE9ZHpkSWJY1bhiFMMQf36cPHFMH48DBhA3YICNgFjgJNKSy1JnM4IIgoEiVMZcX/SFi1Sd29ps0vy50NE+udzgZqyrl+bNnq7VmvrVSFaU8iHj0QQz5a69957ue+++zzvd8GCBVS0GQet0L17dzZt2kSVKuZEkT58+PDh458KzyGCjRo14qKLLuLSSy91/PsnobCw0JUzO5FUY7m5bktQWueCTyadmtmQtkvl5YbEycjI4LzzzoshpVQHR7w0Jm6dIZUrV4651g888IBjPmsVB9NxYocIcAOihsWqunX15akicbw4YLYCbyJSq5nvQaJRxm5IHIB+iEnpX7ZrG2FWcx199NHUt3Csx0O+8jkVlZrC4bDhnPd07gxA9W++oTticgvuSRwwRo9u055N2XcN7vijj7Z1SBQQdQztNf3mtpgwRJ0nMge5JHGWKussM21jJnHy8/Pp0sWbjiMcDkNGBqFhw2gO/B+wtFMnvrZQg1pFvwJsy8riTuDNvDw9jVA82EVfWzmbDenUPvpIfLnqKqhalQ6IWlRyf04kjn4PAgF4+mn2Nm/ORQcO6FHzoVDIcPxQKMSE33/Xv8eQOCtW4JScUU2lJnvPboDPP4dHHgEtnZJs12plW3Nf8nFwEAqFXI3JDz30EDdr6X7c4mArcZxSu/br189yGzfHSE9Pt7Rl1HEhJycn5vdEcDildt2ASMtoJgrUMbFQuUZlldrVCbO0/08Ba00OrWAwyNatVi5n6+O6gbRFPiRKaJhrF5111lmW28ZThLmFkxJnD4I86Yk9gQP26cjmA6XZ2bBjBxkaySLJGFVtZN6HinUYSZeNCvFqqPFXUgJZWWw2qbkl3KZTc3rGS4jaa7J3qPVwJCT1d4T236zESSSgpDArC4YIqmEYcL223IrEsUqnBrBUUQVPRQRzmTF69GjD93A4zH5gJIIgyUWc88R7742xJ+V7OScSEarg6Vp41Ny5XC7PQyMeszW1ppUtoo/vt94q7BFNOXQnQrUTCoUM88eNOTlEatWigta+vxB970ft97SfjWd69tlnG76no6VPQ5A/u7Rj6dBInNLSUgqJKuR9VbCPZLBp0yb97+mnn6Zy5cqGZap6PRKJuAoiAahVq5YnGyMzM5O8vDxPAcA+fPjw4ePvDc+zy549e7qKdvsn4cCBA65ernYkhNMk1ovjxCrqL5F0anYkjp3RYUfiqOclHSTm9qgOjm3brKYLUbg1YF566aUYx0l6errr7Q9mChMnTASuAEKK4ySZqF4Jr0ocFebrGgwGXefGd6vEUZGP0TkcD2YSJxKJJHTNNiEUJlsxRqMmCrOBv7NdOwBqf/MNc4jWifFC4qgkyDaTo8CQYbxFC8c+fRUidY3Z/aU+1/EiimUc5afA1URTiajEjfp5r8XxXtMKAXuBdG4WFhZSAvwX+GrIEPIdlDjmvl9SUsLDwHNHHRWzjR3slAFWEaSSxKlWWiqiXgGuvFLUxUGoWzL3CveKTKdmWxNHQ6RHDyr/+achKvzXX381kEvLli3THY7LiTqE1gEHcnIIhkI62WaGmkotJj1P164igld7rmS7VimrrDJv4+Ogwc17rnr16owdO9bTtl5skb17Y2m8gx1QYof09HS+//77mOXq+aUiWALsSZzXX3/d1fblIaBkE9HxffchVgWPQSgobrM4flpaWkLXyY0SZwcwAUFif+Jyv2YSJxgMJpRqOl/5bKUKdnPG6vs/Eono51wKbNdqm+Voz4QdiWNns4Ux2iIbNbtfPrPmgJJSm+u9D6HohcSVOBBbF8eKxDGnTDUrcUpKSnRFiluEw2F4+2344Qc+VZZvtYi4t7NFltWooacuM9fJlJgp07Gqx1VQggie2V61asy2ejq1cBg+/VQQa1obHgVqEg0ocVLi6Mds2RK0FOErK1dGjmpmEiccibBRsa8mav9lErWMxXaVJQV6aW3bAsizfwWgQwfxpXt3/bgQDfpKnD73cTAQiUTYt2/fQf9z+57Iy8vT/6pUqUIgENC///7771SqVIkvv/ySTp06kZWVxXfffcfKlSs5++yzqVOnDrm5uXTp0oXpkizVYE6nFggEeOWVVzjnnHPIycmhWbNmfPJJ9E1jTqc2YcIEqlatytSpU2nZsiW5ubn069ePTZuiyZxLS0u54YYbqFq1KjVq1OC2227j0ksv9ZzS34cPHz58lE8kVBPHRyySUeKkisSxwrvvvutpfTX9h9lRaacKSobEUdePR+K4wYsvvkizZs1irnVaWppnEqc89vVUkTiJpkKxInHee+89z/uxcwicc845SZFoVtGviZzrHkT6lN4Jt8SIcDhsmNRubtUKevTgQPXqrEBMuj8Dw+Rfwk5Cr0aP7jBFt3ohcd5CRGCb4YXEuQQxua5ENB3PXxhzqf9BVNFhVuGAIMO9Qp6Xum0wGLR81uU65v4g74uXZ8suRZ+TEqfLvn2wbx8ccQR06gTXXMMSRMqyWxcsgKlTyXWIfo2X3m748OHcc889+vcFCxbwIcLhOcS07oY6dQDoaHGcIDCQ2FRqVli8eDFTpkwBjGTraquV/yZ47rnnaNiwIRUqVKBr167Mnz/fdt2XX36ZE088kWrVqlGtWjV69eoVs/6wYcMIBAKGPzuliRu4sUXKOqCkW7duMctSmU7Nrn6eGxInLS2NTp060Uqr6SShnnsq0mABdOzYMeZ+3HrrrXTq1MnV9uXFFrkUoSxQU0+mgsQJBoOe3s9FwPcI4iIZVbBbW1A9x6sQBePN5IYdzH00NzeXli1butw6CiclTiIwq4K3aCROtU8/ZTRRBab5PJ2eX5UE2aIRrLLPGgJTWrZ03M8qhI1grmyUCIkjA2PckDhmJc769etta4DaQT+vY4+lP+Ld+v6JJzKrUaOYde1InH3hMOcA/87LY2bMVnGOa4JTQEnFSAQ+0KpOjhoF7dpRA5G+TY59FTQi3jadmsQzz/Br9+6cuWePbt+ZVcHhcJinlbo372j/lwChYJC0HTtw0stL++U9jPW6mDZNkFEmVbCq3D9cU7t6sTMAJk2aRIsWLahQoQJt2rThiy++0H8rKSnhtttuo02bNlSsWJF69eoxdOhQNm40VvVs2LBhjC0yZsyYMjk/EM9Bbm7uQf+zq4+ZCP79738zZswYfvvtN9q2bUtBQQGnn346M2bMYNGiRfTr14+zzjqLtWudQ/Tuv/9+Bg8ezJIlSzj99NO56KKLHAOm9+/fzxNPPMGbb77Jt99+y9q1aw3KoEcffZS33nqL8ePHM2fOHPbs2cNHMhOADx8+fPg47JFQoIov6YxFMkocp7QUqUrr4RZO0a9uSBwVqkNdnnu9evUM66gTECcSp1GjRq7Socnj/J1IHLXdhyL6VYWV4ySRPmpF4rz22mtMmDAhKRLHSomTaFqTORgn/snA7DjZeeAAayZMIGfnTpohHA1nYXTYSNQw5UCXUImQXaZoT7fp1JygPtfxCJatCMJLjR41O0oOEFVoWJE4idTEkuelTsrsCEI7x8nKlSsBb07ARJQ4WXI8GTBApCBJT2cEIhq6w65d0K8fLX/7DYiTTs3h+CtWGK9sGOGY+dG03lrNGauSOP9C1KDaSzRS9kOiThMrtG/fnt+0Nq9Wlq+2WvlvgHfffZeRI0dy77338tNPP9GuXTv69u1rm8Zp1qxZDBkyhJkzZzJ37lwaNGhAnz592LBhg2E9GUUp/9555x3L/bmBm/dcIgElXmriWCGVShyvtogK+V43r6u+23btshqJvWPChAkx78zD0RZZiqjfFVb6TXlUBbut2alef6drq56j1ztgtjsSVQXvRJAMKxDBJcnCHFCy4ZhjAMheuZK7idYR+cNiW7t+q5I4ZlWwFxLnbITqYqNpufpOj2fLSOXoA4igmAbad9UeUavBHcAU9ALMnj3b8RhWMD+ri4DvOnak0GJMdVIFTwM+qVbN9XHt7B0rG0EqceqEwzB1qvhy/vnwwgsAXAYcs2MHEFXixLNFaNCA1t9/z+/K7w888ACrVkX1uEuWLGEqwpaYT/ReFALbatcGoimFzahAVBUc81asUQPOPFPYU1iTOKtt9lue4dXO+P777xkyZAjDhw9n0aJFDBgwgAEDBvDLL+JK79+/n59++om7776bn376iQ8//JA//viD/v37x+xr9OjRBlvk+uuvj1nHRxSjR4+md+/eNGnShOrVq9OuXTuuvvpqWrduTbNmzXjggQdo0qSJQVljhWHDhjFkyBCaNm3Kww8/TEFBgSNxV1JSwosvvkjnzp3p2LEjI0aMYMaMGfrvzz77LLfffjvnnHMOLVq0YNy4cVS1UOf58OHDh4/DEwnNnoYNG2YbCSmRqsKwhwuScZw4TeyybfJHlxXS09Nt89B7dZyo5JTc50cffUQbLX8xGCfQdgbqhAkTuPjiixk4cGDc9v/dSZx4ToCKFSvqRVOd9mfnOJk/fz7HHmtfDtTKceIW8dKpXXbZZUBy6eysHCcH+xmygjmd2qBBgxzWNqJ69er89VdsVSA1enSX6dnUnRLBIDRtmtA1VdtrR+KceeaZVKhQgZ9++om//vqLfwPzEIVnzQWyQaRUa4I1iWOnbnGCfEbV9hUVFVk+63aOk6VLReUeLw62REgcHQMG8OOPP1KhQgVmI/K23167NoNDIdAcKFY1oEKhEKNGjWLy5Ml89ZXb6j3WWKWpuySJcw3whPL7PgTxY6XQst2nzee/E8aOHcuVV16pj1Uvvvgin3/+Oa+99hr//ve/Y9Z/6623DN9feeUVPvjgA2bMmMHQoUP15VlZWeQp9RCSQVkpcbzU57PCpEkxifkc4VQTx64tbtN0Qux7Rr0m8Wqr5OTkxI3mfeyxx8jLy0sqtWt5sUEkyiKgJJWq4GHDhunPZrzjSti9Gx966KGkztHKFkmkjlAYaAMEiCpZk0FMate8PPjPf/hp/HjmLFqk1xSx0vBXq1aNXbt2xfRLlcTZbgrqMQSUHHMM4e/MVYWi+ANr8shLfb67EUElTwBnastWYSTAtiLIiVoIW8T8lCUSUCKviZrS1G7eIW30VKiC7drqpApuI+2UZs1EPZlAgP8iUuH+d80auOACamsBIe6qTBkxZ84c5syJJnuV9mtHYgm69Xl55G3eTGfgI21ZEPTgpj4IhfdqYK7DMZ9//nnuv/9+wGh/uK2nWZ7g1c545pln6NevH7feeisgSLRp06Yxbtw4XnzxRapUqcK0adMM24wbN45jjz2WtWvXcuSRR+rLK1WqlDJbJB5ycnIoKIixkA/KcVOFzp2N9GNBQQH33Xcfn3/+OZs2baK0tJQDBw7EVeK0bdtW/1yxYkUqV67saIfk5OTQpEkT/XvdunX19Xfv3s2WLVsMc3mpQC4v6eJ9+PDhw0dySEiJU6lSJapUqeL4909DMo4Tp20PpRLHPFnySuJYEX2tW7fm3HPP1b+7UeLItCpuJtROJI5b7Nu3j3HjxsVES5cHxLsGbhxtdilMMjMz4xaWT1UKEydnm9eIbRVWfS5VBYaTgVmJ4wVmJc7DDz8MCMfJfoR6Z6/pvusET8uWkJXl2hnYokUL/bPaXjuH5ZlnnsmkSZNo1qyZvuwj4DjgS4v1JyCcNB9Y/JaI42THjh188cUXhhocxcXFjunU7J4hL33ZjnCKR+LsAna1bUvnzp1praWx+Rl4KC8PNm3iudNOYyCwwGLf4XCYxx9/nBUrVvDKK6+4bqsV/tT6S1ugK6JQOMDDQHOgMnAy1mSbhPlcV9t8/ruguLiYH3/8kV69eunLgsEgvXr1Yu5cJ/dSFPv376ekpCSmNsasWbOoXbs2Rx99NNdccw07NDLPCkVFRezZs8fwpyKZ1K5OTuZ4gTuphlM6tWRUwRLmKGQ3JE7nzp25/vrrXeWV/6cHlLix15xInKPi1ChLxhZRYdVntm/fzh133JHQ/iSs+lyiASVFpC4tlFmJ89///pdngU6LFnEDMAp4WjumGdWqVbO87yqJs9OkCjYrcRLpy6otopIkdngW6A6s1L6blagQVeOYU6lB6lTBdqld7QJKZLR+WamCYyqVDRyoq1huR1yn7EgE3n2XWppC2S4/wsaNG/nyyy893c8lxNb7W6W9C6UrvBIiEOh3RPq0K7Tlb+GM6667Tv+sEjeHG4mTiJ0xd+5cw/oAffv2dbRLdu/eTSAQiFFnjBkzhho1atChQwcef/xxx3lLPFskHgKBABUrVjzof6nMJlPRNN7dcsstTJ48mYcffpjZs2fz888/06ZNm7hjivk9GAgEHAkXq/XLi53gw4cPHz7KHgmFmf3nP/+htiaB9iGQjBLHaduDrSJQSRwzzMaKhJ3jpH79+hx99NEEAgGD00o1NNySOODOiSTXTSaFyaJFi8qVhNyrEsfN/qwcLIn04WQdJ1I5pPbzVCtxygOJE4lEElKaQCyJc8UVV1ChQgVGjhzJiYhCtkeZxomfgFd79GC4VjzTLTGmTgzc1MSRz7LbZ+tD7c8KiThOnn32WZ599lmDU9VOiSMno3ZOw1Q4Tqyuk0rifAYct3t3zDpFRUV8NnUqI760or4E7GqPJYJVwSB7EGTNF0AWMBm408M+zMTeVkQR7qpYO8YOd2zfvp1QKEQdrZ6QRJ06dfj9999ttjLitttuo169egaHS79+/Tj33HNp1KgRK1eu5I477uC0005j7ty5luP9I488okccWyGZ1K5OqohEVATJwCmdml19HrtxLicnR3825Zg1evRoXnrpJd3xpD7/diTOpZdeyogRI1ypPeQ79u9E4qiIN15WrFiR3RZjnQonVfCqVascj1GWqmD5zv07qoLNASXfffcd3zmoY1RUq1aNdevWxSxXSZxdpmdTXzsYhGbNXF/TtLQ0/Xl2E1By/fXXc+qppzJp0iTeeustfkQoPy5GvHfNWAT0IDbtKySmCrYicezO1U6JI5EKW8QpnZqOQYMYOXIkJSUl7EIQKadWqcL0K65g3/jxRHbuxC6xXKNGjSguLuaDD6xCctzjTy1NZ2eE2ux1hDr5ALAYkcpxkbbcLVTi5nBTBSdiZ2zevNly/c2bN1uuX1hYyG233caQIUMMaVJvuOEGOnbsSPXq1fn++++5/fbb2bRpE2PHWmuy49ki/0TMmTOHYcOGcc45IglgQUEBq1evPqhtqFKlCnXq1GHBggWcdNJJgLCNfvrpJ9q3b39Q2+LDhw8fPsoGnkkcvx6ONRJV4jRq1MgxYvFgO6DT0tJsHTxeSZyMjAymyrzLNqhRo4ZO3tg5TmR73FyLVES/ljd4SWGSnZ0dNyInmRQmqVbi9OnTh5EjR9K8eXP9t2Sk/P8EJU4wGNT7wU/asuYW5z2vaVOGt2sHuE8zpDpq3aRTk0jFs5UoyQUYCnbGi0xNRBFpRqIkzkfAiRbPXmFhIffcc4/jMVXnULLOwIL9+1mEUNtURzg94ruljbBK23geUA9TCh0fgIhwnThxIrNmzTKMSRdccIH+uU2bNrRt25YmTZowa9YsTj311Jj93H777YwcOVL/vmfPHho0aKB/L6t0aoeSxDE7Q5NR4sgApOzsbC6//HKe1ohudQzbssVcWl1Ajrtu3p+psEWWLl1KgwYNWL/eXLXj0EBtd7xzyMrKIiMjw3Fcd7JF4u0/VUocp/aluj5feSBxkgkoMStxvvvuO9544w1eeuklPgSqAPmmTAw/Azuys6nRty9kZbm+prVq1WLbtm2EQiFX9fkqVarE2WefbSjovgd43mb/YxDvKStyIJHr89VXX9G9e3dGjRqlL7MLKJH2g9047IW0TSSdGghyo06LFjz11FOGdeaHw+wfPZojXnqJPdjXgpL7Tza1659ZWRQDNYAXEPVvihC2iZUi2Q02IZRrFTj8lDhljZKSEgYPHkwkEuEFrRaShGpXtG3blszMTK6++moeeeQRy7lVPFvkn4hmzZrx4YcfctZZZxEIBLj77rsPSQqz66+/nkceeYSmTZvSokULnn32WXbt2nXY+kF8+PDhw4cRnmc95TEisDwgERVD7969+e233xwnnwc7hYmTEsduAuqmJo4d1GJ/+fn5lut4UeL8HUkcFfGUOBkZGXGvU6qLCbuFFYkTCAQ44YQTDMq+Tp068dRTT3HJJZd4bl95jX4156H3AvNzZOX4srrn6ljt1ilhR+Js325OgmFEKp6tRJQ4VoinxEnFO8yurVYOpu0IZ9IuEMV9LcbLwsLCuDU2VIJIPr/VqlXjuOOOc9tsHfv27dMJwCIE+eIcMx8Lq/ZOB97w3JrDAzVr1iQtLS3Gwb9ly5a4xPMTTzzBmDFj+Oqrrwy5z63QuHFjatasyYoV1snssrKyqFy5suFPRTKqYCcl56FIp2bXTjsljt0Ym5mZyVdffcV7771ncDLZqYLtAkrkc+cloMT8zvZSEwcoNwSOV6Snp8e9TsnYIqkOKOnevTs9evTQ05VCapU4dssONpIJKKlWrZrhOufl5dGtWzcABgK9gEzTOe4FRpxxBmh1Ut0eW52LuFHieH2vb0WkEd1p8VsitsiyZcuYO3euHoEP9raItMfs+peXlMJeAkpUJc4HQKmNLfLAAw+we+9eWwJHRbL29e7CQpZon6/W/l+HNwLHfA0iCIXxFqKBTocLErEz8vLyXK0vCZw1a9Ywbdq0GNvBjK5du1JaWmqrJIlni/wTMXbsWKpVq0b37t0566yz6Nu3Lx07doy/YYohlVZDhw6lW7du5Obm0rdv33LxDvLhw4cPH8nDM4kzc+bMmHzuPhKLfs3JySErTmRaooqJROHkOLF7+TspcaygTraOO+44+vXrF7dNTsdX8XckcdR2x+tn6enprkgcq3uTSBqeRB0nss/YHfOmm25iyJAhrvctYSY8yks6NXMeei/o27ev4btbEkcdV9w6TuzSqX377beW66eS1E+mFpIKu5o48hrI/0cffXTCx/fiONkPnIDI0b8Pa0KtuLjYNmWdFSRZlJmZ6anel8S+fft4HZGq5DISc3RYKXH+zsjMzKRTp07MmDFDXxYOh5kxY4buyLTCY489xgMPPMCUKVNiiuBaYf369ezYsYO6desm1M5ElThPPvkk9erVs93mUChx7Pq2VyVOZmYmvXv35rzzzrM93tChQ/XPvirYGl7a7TagJFEbN1WpXeX7IDs7m5kzZ3L77bfrv7Vo0SImTZFblNfUrsmQOOZn0q0tUipWBtwHlHglcdQ2JYuDFVBidy283J+kSByL45SUlLBkyZKY5XZQ67b27t3b9XYSBQUFLFS+vwS86nJbaX9a2SIDgfqIFK+HExKxM7p162ZYH2DatGmG9SWBs3z5cqZPnx6j8LfCzz//TDAY9NPnA8OGDTMEmvbo0YNIJBJTU6hhw4Z8/fXX7N+/n7Vr13Ldddcxa9YsXfELsHr1am666Sb9eyQSiamzl5+fz7BhwyyPZW4LwIABAwzzsfT0dJ599ll2797Nzp07efjhh1m8eDFNmzZN8Ar48OHDh4/yBM+znkcffdRgMI0ZM8bwMtmxYwfHHHNMShp3OMFL9KuMBB04cCDgHO13KBwndpGRdhFXTtGvbhAvEjMVjhOv0a9lje7du5fJfpOJfi1rEseuLXZQJ4duYW5fKpU47bTUZIkgUcdJjRo1YibGVsVyrZ411aBPhMTx0t7y9GzFc5zI/2Znk5fzfeCBByyX26V6WYoo1Ot0nHgp61RIR1YyJM5ioC3wjuetjW34J2HkyJG8/PLLvP766/z2229cc8017Nu3T6+RMnToUIMT+NFHH+Xuu+/mtddeo2HDhmzevJnNmzdTUCAS2xQUFHDrrbcyb948Vq9ezYwZMzj77LNp2rRpDHnrFokocTp06GBIi2KFQ5lOzYxESBwrqGPknXfeqY9/ds5VLwElqaiJczgjmYASN0jGFlHXVVXBZmRmZrJ27Vq+/vprz+37O6ZTa9mypeG6B4PBmPtn9WwkYouoAWXqNp99ZlXhJoryROK4DSgxIxUBJVb2RCEijdzzwA/Yj3NebBHZzzMyMhJS1e3bt4+Z2ucfAC/VSOX1swsoSYyqPPTwamfceOONTJkyhSeffJLff/+d++67j4ULFzJixAhA3OdBgwaxcOFC3nrrLUKhkG6LyP4zd+5cnn76aRYvXsxff/3FW2+9xc0338zFF19MtWrVDv5F8JEU1qxZw8svv8yff/7J0qVLueaaa1i1ahUXXnjhoW6aDx8+fPhIATx7YKdOnUpRUZH+/eGHH2bnzqggvbS0lD/++CM1rTsMULNmTd5++21PjpPFixczc+ZMLr74YqD8kTh2k+pUKXHMiGf4WzlOHn/8cct1D5fo18svv9yQSs4JZRH9miiJk6p0am6O6ZTax8sxUhX9KgtEJoJE06lZEVmBQCBmzIiXTu2fROLEq4kj/5vH1lQogdyoaawcJ5FIxBMpItfNyMhIiMTZuzemxLFrOEW//t1x/vnn88QTT3DPPffQvn17fv75Z6ZMmaJH669du5ZNmzbp67/wwgsUFxczaNAg6tatq/898cQTgHgvLVmyhP79+9O8eXOGDx9Op06dmD17dsLpyxJR4jRp0gQoX7ZIenp6ypQ4bmyRzMxMBg0aFLdN4Ctx3CAjI6NM06kdLFskMzPTNn2fE6zOXSVxEglSSQWSUeJcd911huuciCrYLYGkkjhu3s3yvVSeSBx1rqzCbIu0atXK8LsXW+Q///mP5XI7e+J2RLqyCPb3wostIm2eRANKCgoKeA/oCZwCeLnysh//3QJKvNoZ3bt35+233+all16iXbt2vP/++3z00Ue0bt0agA0bNvDJJ5+wfv162rdvb7BFvv/+e0A8txMnTuTkk0+mVatWPPTQQ9x888289NJLB/8C+EgawWCQCRMm0KVLF44//niWLl3K9OnTadmy5aFumg8fPnz4SAE8z57M6XP+6TVyFi1aRP369VmzZk3cdaWBW61aNXr06KEvd7qGh4LEsTum15o4btKpOa2ntgmIKQZ96623xqwrHQLmyVN5c5xkZmbStWvXlO+3PEe/HgwSx2p8ShWJk4zqKNF0avKYgUBAP7dgMBhznok4TmThYBVSsRaJRDw5TpJBWlpaylKpgb3jJJ4SJxVtcBPBmgoljiRQEnWcbNiwwfM2Eo8++ihnn332385x4hYjRozQI1zNmDVrluG7XS55iezsbKZOnZqilom0Kl4UlbNnz+all17SSaXyZovYvae81sRx+76Lt54ViWM1joKzKrg84cEHH2TFihVMmDAh7rpebCin1LwSVkoOtzCPe4mMgypSbYvES6eWjD1x/vnn8+677ya0bTKpXatXrx5XiZOqgBK7dGoHA6kkcawI51TaImoQpQo3ASV219XLuz1ZW0RuP8vzlsKuzc7O/lsGlHixMwDOO+8823ShDRs2jGurd+zYkXnz5nlup4/yiQYNGjBnzpxD3QwfPnz48FFGSC4Xkg/dsZFMMWEn58jBdpxkZWWlTImTqnRq8nd1omN3LeUkwpwvtjySOHbXMxlnREZGRtzrfrikU0vEcWKFVJE4ydyXRJU48pjqdbK6ZlbXKp7j5PLLL7c8nrynXhw9Xp6tI444wnBPUl0w3W0Kk0QcJ++9957j78kocbw4bpJ1nCSD22+/nWOOOeYfS+KUV0ycOJEZM2a4GpPlOieccAJvvPGGnvPeqQ+Wp4ASr+8GN+nUILHUrnaptuS+rMiG8mSLVKpUieeffz7l+y1rJU55Dygx29HmdGqHqg8kaotIJFITR33Okq2JY4dUKHHktqkKKnGrxEkmtasd3ASFpCKdmrRFsrKyErJFVq1a5XkbiYULF7Jnz56/JYnjw4cPHz58+PBhB88e2EAgEGMkl6cJ6cGGnMAkWkwYoH79+rbbHGzHyemnn17mShwzzJP4r776iquvvjrmd9UhYHct5bpWJE55glPaM/N1i/d8qdcvPT09bsRVIBBIuF+lOoWJ0/Ze042sWLEiZpk5+jWZsSpZJY46Me7Xr5+nY5pTmJjvcfXq1S2PKWHlFLDqf6rj1E00aiKOE3NNn1QXe060Jo6T46ZWrVps2LCBE044wfHYiSpxnNJYWWHSpEmAeD8cqsh+s+OkZs2ah6QdPgQ6duxIdnZ2QmS8hNO2qSZb4yERVbAd3L7vElHi2F1LudzsKC1vJE5mZqbre+tViVOWquBkbBG7ttjBLn2fV6SKxElm20SVOFbKMqtrbvVsxrNF7FT1B4PEUYu2p3qMKwtbRGL48OGOv7sJsigPSpxkcOqpp9KpUyefxPHhw4cPHz58/KOQUDq1YcOG6UZnYWEh//d//6dHqtlFHv1dYRUpbwe7SeaRRx5pu83BJHHWrVtH7dq12bFjh+XvqVLixEunVqNGDT33L0Svsbq/eLnyy3se+szMTNvrY3bKxmt3pUqV2LVrl75tvAmNHYnj5voMHDiQ999/X/9enqJfq1atGrPMKvo10RRgyTiJ7r33Xv24J554Io0bN/Z0TPU6WaVTsyJx4ilxrPqATGF04MABV6qSRFDWJE5xcbGlY1Beg0Rq4hxxxBHUq1fPdmyUSDT6NdHI38zMzISdoMnC7Oh55JFHqF+/PmedddZBT3/jw1tAid06eXl5ttsc7ICSk08+2faYXscMt6ldze/ehx9+mI8++oj58+cbfvdC4sh3s7q8vNkiyRIgEsFgUHfYu63Pl6p0al6uaVnbIi+//DK//fabYVl5UeKYa+J07NiRn376Ke52so+YlTjmZ8iqCHoitkh6erreN7zMK71eV7XvV6hQIaV2T3FxsWWAhtkW8arEeeuttzj77LN59dVXbddJVBUM3pQ4EydOBA5dQMmKFSt8EseHDx8+fPjw8Y+C55nb0KFDqV27NlWqVKFKlSpcfPHF1KtXT/9eu3Zthg4dWhZtLddQJwJ2UaJ2k/3yQOLUqVNHVwSlKp1aokqcChUqGK6V/N0NiVO5cmUArrrqKsPytLS0clW/KTMz03ay6TWaTY0SzcjIoKCgwHH9QCCQcMRhs2bNmDFjhv69LKNfvTrq7CaQ/fv3B0ReaK+Kh1RB7XuqcyIe7NKpmc8jEceJVR9Q2+YlL7wXx4nZiVkW0a9W2L17N4MHD9bHK3P/ciJSrIhkKySqxEmU9IhH4owbNy6h/bqB2XGSk5NDv379Uha17sMbZD9IRonTsGFD220OJonz2Wef0aVLl0OuxDn22GMZPHiw/t2KxLF7B8rnwPw+lnXHygu83Nd47Vaf/fT09Ljv22RskY4dOya0nVNb7OC1759yyimWy1NVEycZvPPOO3pNzjZt2tCnTx9X21mROFYBJTVq1IjZNl59PjtbRF73siJxzJklykIVbGVXyGsg3/tebJHq1atz4YUXxn1ukkmnFm8OYYVDGVBitkXuu+8+7r///kPSFh8+fPjw4cOHj7KG57AZN8VP/4lQJwI5OTmWBrTd5MJpMnqwHCdq27xGv3olcQYNGsQnn3xCgwYNgFjne3Z2tmGCKyeN6v7sJsCy4HHlypUZOXIkY8eO1fdRnqLDnSY7XiNMzY6TREkct2oyNf1EWSpxvDq6rByTkUiERo0asXHjRqpWreo5RVtZICMjw3XEolslTk5ODllZWQZnh3Sc2NVbiUfiuHGcJJpOzRz9mkrY1cT55ptvDN+dol9r1qzJ9u3b9e+yb8VznCQa/Zpooel40a/16tVj1qxZutMulTArcewKufs4OPBy/e1InKOOOsp2m4NJ4pxxxhmA94ASOyRany87O9twreRnlUSKF1By7rnnctlllxnWP1xJnHjIzc1lz549gLh3ZhWSGcmQOC1atOCLL77g9NNPB2JVVfGOa4bTc5MqW0S19Q9VUNHGjRv1zxkZGZ4DSuKldq1UqRIZGRmGd1oiASVSFQxll+HBrAr2Sg7HQ1FRkSWRWVxczK233qore72kU1PJNCdleaIBJZCYPRKPxBk+fLijcigZmEmcWrVqce211/Lqq6+ydu3aMjmmDx8+fPjw4cPHoYJnEseqGLYZgUCgzIy18go3Shw79O/fn5NPPll3MqqG+aEgcewM8aysLIYPH87mzZv5/PPP9eVe06ldfPHF1K9fn3bt2lkez+w4kY4V1cFi5ziRJI55/fT09JQVK00FnO6rVxJHPWezI98KyaRTMzugypLE8QonZ3bdunVTdpxkkZ6e7prEsVPiWBXLrlKlClu3btWXyTHEbqLulE4Nyi76tazTqR04cMCVg8wpnVqzZs0sSZx4Dq9EHSeJOvTiOU7S09PLLE+9mbDySZxDC0lQm9/lVg45u3t0zDHH2O7/YKdTczqm1z5mt58TTzzRoFZza4u4SacmSZzKlStz3333cd999+nrlycSJ15AiTouxmu3el3S09PZu3ev4/rJkDhpaWkcf/zxCW17KGwRGVCycOFCqlev7jqlalkiEVWwuSaOmaSQtoj6/oynxLGyAdSaWIdrQImdEmfu3LnMnTtX/+6FxJF9Sz47doEjbmyRVJJjWVlZjn3phBNO4Lrrrku5gg5iA0rkNSpvtVB9+PDhw4cPHz5SAc/elgkTJjBz5kzy8/PZtWuX5d/OnTvLoq3lGm6ULE7bjhkzRv+uTgDLkxIH4JVXXuGDDz4wLFPr16iwM+gDgQA9e/bU63i4Taem7s/OOFdzl5tJH6uJ0aWXXmpZT6Ss4UWJEw+qusRNKqNkHScqyjKdmlfYOU5SiVWrVnHmmWcmtQ8vjhN5fc3RrxdddJFhvbS0NN1pKBGPxLEim9UUJj/++KOrNnpFWUe/HjhwwBVh6+Q4MV9LlUxzundu1H6pdJwcShLH7CSSx/EdJ4cWyaR2PfHEE21TQZUnEgfEu/vYY491tR+7Z+S8885j4sSJrFixAoivxEmExDEfv7yROKkMKFHH1KysrDJN7WpuW7JKnIMVUNKpUycaNWqUsmMlg2RVwVbXLC0tLaY+YbKpXb3UqSlPASWFhYUJ2SLqNTKTfWq/d3p23ZA4qawl48YWKauaOXa2iB9Q4qM8oEePHtx0003694YNG/L00087bhMIBPjoo4+SPnaq9uPDhw8fPsoXPFs411xzDbt372bVqlX07NmTV199lcmTJ8f8/dOQDIkD9sbmocgxHO+Y5snzJ598YrleMilMrNKpqfuzu17qfTCTOFaTx4yMjENi6MdznEyfPl3/7sVx4qYAr50Sxw2CwSDNmzfnyCOPpEOHDmVaTBhE0dKvvvrKlbPOLoVJKtGwYUNdQZYorBwnMn2QGVZKnGAwSG5uLp999plhvSpVqhi2ldGvdsSCXfSrfP7d5EUvj9GvqSBxAoEA77//vv7dreNE4sYbb6Rp06aWvx1sx4mvxPlnwY1T0un9aadMKW8kzoQJE/jhhx8My+ychE4BJeeffz5NmjSxXC9VJI5ZFWyFnj170r59e8vfyhJeSJx4UMfUSpUqlbkSx2tatHhtSRUORkDJ8uXL9VRyiSJZJU4gEKB3794x6zmROG6VOGpAiTkVaqpg7kOptkX279+ftC1i/k19Jp2eHTcp0eI9n15QHgNKfFvER7I466yz6Nevn+Vvs2fPJhAIsGTJEk/7XLBgQUzd3mRx3333WdoPmzZt4rTTTkvpsXz48OHDx6GHZwvnueeeY9OmTYwaNYpPP/2UBg0aMHjwYKZOnVquCscfbKjGYiLODjvjVt1XWUUxgTcSSm3rueeeS9u2bS3Xczs5VNeTBEOiShwVbpQ45ZXEOfXUU13vS53IJaPEcZtOLSMjg5UrV7Jw4ULXbbTbf7xjNmnShN69e7vqS1b7SnZMUif1cv/JPodmx8ljjz3Ge++9Z3lMp+hXc/82kzjy3O0m81ZR+iqJ4wXlKfo1FY6TQCDAwIED9e9uHScSlSpVsn3GEykabId4jpO0tDTfcfIPQzJKHPP2ah9O1NmeDLyqVr777jvL5amuiaNeC7v+7lUVXF5tkW+//Vb/7iWgJDc3t0yVODKYoUOHDhxzzDHUq1fPVRvt1om33apVq/jkk09iSAsrHIyAkqZNm9KzZ8+k9mEVUHLSSSdZrmsXUJKVlcXs2bMN69kFlIB1UEkqbJFUBJSkWhWcKlvEHLAj4WZcGzZsGCeeeKLlb38XEsd8Hr4q2EeqMHz4cKZNm8b69etjfhs/fjydO3e29YHYoVatWgetPmteXt4hsd18+PDhw0fZIqEZY1ZWFkOGDGHatGksW7aMVq1ace2119KwYcOUOqgOJ5SVEkfdl2ogn3LKKTz//POej2MHNzVxrNZ1QiKOkwoVKsTU/JCf3dTEsdtveVPimK9xXl6e/tncnnjXW73Oubm5zJgxgy5dutiunwyJI9uWnp6ekuvmti8dCkUaoBeeVZHsxNCcVuLUU0+1NeitSByrdlg5TkpLS1mxYkXCShw3cOs4UZ0j5YHEsSI3SktLad68OQBDhgyJWV/CzbiWmZlp+3ykmsRxIhWTdZycfPLJtlF8soC5hLyPvuPk0MJNqkKnsVu9f26VOGWVHixe+kIVnTp1omvXrpa/ubVFrJQ46rWSz5q6P7v+brWdXP9wInHsHMBWMJM4DRs2dFw/GVWwJPgWLlzIkiVLLEkGp+O6WaaiYcOGnHXWWa76Y1kocWrWrBmzLBW2iHo+DzzwAF9++aXlul4CSuyUOKFQyPI62JE4ifSN8hRQUlpa6ioVnNkeV69RIBAwKLUTCSixU+h7sUXijU2HksTZtWuX4bsfUHKYIBKBffsO/p+HsfjMM8+kVq1aTJgwwbC8oKCASZMmMWDAAIYMGcIRRxxBTk4Obdq04Z133nHcpzmd2vLlyznppJOoUKECxxxzDNOmTYvZ5rbbbqN58+bk5OTQuHFj7r77bj1Ab8KECdx///0sXryYQCBAIBDQ22tOp7Z06VJOOXJ3hQQAAEd2SURBVOUUsrOzqVGjBldddZVhHBg2bBgDBgzgiSeeoG7dutSoUYPrrrvOlbLPhw8fPnwcPCRt4UgjOBKJlKvC8QcbySpx1O1VA97OeXjHHXfYSnwTgTqRSUtLc238Ok1M3Tpf1AmgnMxZKXHU83czUXND4jg5W1MFqwmUuY/IdC4Aq1evNvzmNZ3aKaecwvz5823Xt3OcuFXiJIq77roroWNC4iROso4TK3IlWSVOOBx2lV4HrKNfrbZLS0uLUWF9+umnNGvWjNdee81y3/FSmHhBvPtojt4ty3RqED9lmRUJGQqFmD9/PrNnz+biiy82/JYIiWN3TQ6mEsfJcXLuuecyd+5c+vTpY7v9McccYxvtbXacVKpUCfAdJ4cabp4tt0ocN/3+tNNOY9KkSV6b6RqpSOOWiC0C9unUvKqCzesfKlukWbNmlsdVob5HzPW7vCpxPv74Y8eUX1LJkQhUR616D8q63lCiJE6y2LBhQ8qPY7ZFjj/+eNuAEjsljrkd6enpMQElu3fv5uOPP7Z9L9vV50skoMQLDoYt4kbtYnXcQYMGAcJ5q6K82iJZWVllSuKcdNJJ/N///Z/lb+Y6vFbzSB/lEPv3Q27uwf/bv991E9PT0xk6dCgTJkwwjDGTJk0iFApx8cUX06lTJz7//HN++eUXrrrqKi655BLHObiKcDjMueeeS2ZmJj/88AMvvvhizDMPwr6eMGECy5Yt45lnnuHll1/mqaeeAuD888/nX//6F61atWLTpk1s2rSJ888/P2Yf+/bto2/fvlSrVo0FCxYwadIkpk+fzogRIwzrzZw5k5UrVzJz5kxef/11JkyYEENi+fDhw4ePQ4uEZoxFRUW888479O7dm+bNm7N06VLGjRvH2rVrXaVz+jtCNZITmZS6mbyrBnIwGIw7wTFHwznBbOSnwnFSp04dV+up5yGNb6so1iOPPNLT8c1O7pYtW8ask5mZSefOnW33cckll3g6phWsJpfm66umm/AKr+nUUuE48YLc3Fwuu+wyBg8ezC233GL4za3Dxa2z4rLLLvPcPq+wugZeChUXFBQY+rzTuXlR4thF3VuRZ+bt1WVlrXoKBoOGqOJD4TixUuKEQiGqVKnCCSecEHO9vUa/OjlOHnnkkbjbu0VxcXFcx4nd79nZ2Rx33HE6+WK3vR3MJI4ce3wS59DCjRLHady1CyixswmuuOIKT+k/vcKtLeLkxE1EiSMVk/FIHDfvbrOT+1CROFbPs/naqGOzl4Ly5n3l5ubStm1bPv/8c9v1k02n5mW5CqsxuLi42NVx3bwfy8J5bNWHkz2OF1vEisSRn822iDlw6ccff2TAgAGMHDnSct+pUOIkmk5NbXuq06mBOxLH6hmYOHEiy5cvj5mDeLVFsrKyDpoqOFESp2/fvqxbt46LLrrIdvsGDRpw3HHHWf5mJnFkPTLfFvGRClx++eWsXLnSUJtr/PjxDBw4kKOOOopbbrmF9u3b07hxY66//nr69etnSJHthOnTp/P777/zxhtv0K5dO0466SQefvjhmPXuuusuunfvritCb7nlFv0Y2dnZ5Obmkp6eTl5eHnl5eZZj2dtvv01hYSFvvPEGrVu35pRTTmHcuHG8+eabbNmyRV+vWrVqjBs3jhYtWnDmmWdyxhlnMGPGDK+XzYcPHz58lCE8WzjXXnstdevWZcyYMZx55pmsW7eOSZMmcfrpp/+jDaZU1sQxv3yvu+46gsEg9957r74sEAjEdWwfffTRntshkYwjd/z48Vx77bWcffbZrtZXz8Mqr7m8NvXq1WPq1KnMnTvXcj+NGze23W9aWhpHHnlkjCGSkZHBK6+8wo033sjbb78ds89UOJitnEvm61tUVMSjjz4KiMmKCi/p1OzSJpj3p07+qlevDsBNN90Ud9tEnvHt27fz6quvAlC3bl3Db3apvsxw2x9PP/10li1bpn8vizpdVs+dl+tSUFDgqMSx6vvJkDh2CkmrNica/aq2r1u3bo7bBINBQx8vCxJn3bp1cdtghpOSVL3WbvrswXDIAixZsiRuTRy76yvHjXjplOzGHzsljh/9Wn6QyLOl3j87Eqd27dr652AwGNcWSSYneyoCSqwK/lrBKqDEKrWrSnS4CZww2yJWpH9GRoYhbZIZAwYMiHuceLAinKxskTZt2lhu71WJEw/JkDh244xTG7t3785tt91GmzZtYpxsqSZxbrjhhkNCynkZf/fu3WvYh9O5WQWUWClx0tLSbNU80g40w04VfDDq86nBZodKiWNH0DVt2jRmuXqtk03tOmbMmLjbu8WaNWvikjh27c3MzKR+/fqO19+JBPJtkcMUOTlQUHDw/zzWo2nRogXdu3fXsxqsWLGC2bNnM3z4cEKhEA888ABt2rShevXq5ObmMnXqVNauXetq37/99hsNGjTQfR9gPYd69913Of7448nLyyM3N5e77rrL9THUY7Vr187gJzj++OMJh8P88ccf+rJWrVoZnp26deuydetWT8fy4cOHDx9lC88zjBdffJHKlSvTuHFjvvnmG6666irOPffcmL9/GpJV4qjbm+uZjBs3jgMHDtC6dWt9mRvHiRcSJ5VKnGHDhvHcc8+5nsCq5zF06FDA6DxSf+/Tp09MNFbLli2ZPHky8+bNMyy3ijA058zPyMigVq1aPP3007Rr1y6mbamIzLNynMjrK+/10KFDufXWW3njjTf49NNPPe3fHP3qdZtJkyYxZ84c7rzzzrjbJTIpysrK0vuXOa9uKh0nEqriyi2J42Xib3UNUkniWB3LTTo1r33Vqs1WChUrSBJGjvVq+77//vuY9dUJipnEORRFN9PT02P6hhWJc/PNNwMwevRofZlbp0xZp/UBuP322+M6TpIhcbwocfx0auUPiTgl1ftXo0YN/XN6ejrvvPMO3bt358UXX9SXu6lbc8wxx7g+fiptkYULF/L888/rqYniQe3vss12qV03bNjAhg0bLNvXv39/2/1KYtVcUyozM5NRo0bx5ptvWgaqlFVAibn9RUVFvPDCCwCccMIJht+8BJS4KdxcWlpqGP/l++Stt96Ku20iJM6cOXN0x7X5WqTSFgkGgxx11FEcOHDA1T69wqoWjXpst9i7d2+ZKHG82iJ29fm8PPuyv6ntu/766x23SUtL46ijjtK/l4USxyoNnhle7Fu1fqYbhXqqbJF4bdy3b1/cgBK76yvHgHgBJXbPvFmJ49sihwkCAahY8eD/JfA8DB8+nA8++IC9e/cyfvx4mjRpwsknn8zjjz/OM888w2233cbMmTP5+eef6du3r+v3iRvMnTuXiy66iNNPP53PPvuMRYsWceedd6b0GCrMz3EgEEgqW4gPHz58+Eg9PFs4Q4cOpWfPnlStWpUqVarY/v3TkKwSRzWyzznnnJjfMzMzY2rCxDOqq1evTtu2bT0fH9xPKlKhdFCPdfLJJ8fsN55TOSMjgwEDBlCrVi3DcrPjxLzMfGyriWQqHCdOJM6MGTOYOXMmI0aMIBAIcMkll1iSSU7wqsQ5cOCAwXGSnZ1N9+7dXTnvk41sOxgkjgq3/dPLZC/VjpN4E19IToljB6s2V6pUyZWxPn/+fPLz82NUY3b4+OOPDcctayVOPKSnp8ecp5XCZuzYsRQWFhqeyf0u8mkfDCXO1q1bGTBgQNIkjhOJ5vS8mx2Ufjq18odkVcHHH3+8/jkQCHDBBRcwZ84cg+rVTUCJ6iiNh1TaIp06deKaa65JqPbaFVdcAViTOCCIaZWcBpHCdvPmzUyePNl2v3J/5jSG0sa7+OKLLa9XWZM4zz77LCBSrhx//PEsX77cUBDZDdSxxM1927dvn2Gb4cOHc+DAAS688MK429qNTW7Hn4NhiyRbH9MOVuSJl+0lkiVxvCpx7GB1XLdKnGuvvZbjjjuOf/3rXzHt+89//hOzvhrlHgwGDWmaD4UtAu7s6k8++YSePXvy8ssv68vc2CJqEFUycLIL69evz7PPPlumtoivxPFxKDF48GCCwSBvv/02b7zxBpdffjmBQIA5c+Zw9tlnc/HFF9OuXTsaN27Mn3/+6Xq/LVu2ZN26dWzatElfZg5I/f777znqqKO488476dy5M82aNWPNmjWGdTIzM+PWpW7ZsiWLFy821CabM2cOwWAwqcwtPnz48OHj4MNzVUy/uJk1VCM5EYezOvG64IIL2Lt3r0F5A0YD143jJDc3l7lz5zJ69Gg9VZcdyqImjluoEanSOWSnxLGC3QTFisQxG/U9evTQP1s5wWWqsWTglE6tUqVKhjZYwUsKE/XzyJEjGTt2bMz6ZseJ1/QT8VC1alXy8/MtfzM7SsqaxDGjVq1abNu2LWZ5MBiMawA7XScv19CLEicVNXHi7RtExOpPP/3Eddddx1dffRV328zMTANZ73T+5513niESvzw4Tqyuud39NzsW3JI4Za3EkaSJ+VzS0tL0c0lPT7ftF8mmUzNDtsN3nJQfJOtEvuiii3j99dcNihzzfs11Jez2eeedd/LQQw/FPX6itkgqAkrUZ6lTp06APYljhUAgYFkL0M14r56n1TNb1qrgESNGcNVVV+nfrVI5ebFF3LyzCwoKDNuUlJS4fh/Y2SJux6uDHVDiFmlpaa6jnlMRUOI1nZq6/1Qpcaza3KlTJxYuXBh325EjR9KkSZOYNtlh8uTJuppFKqYkDhWJ4+aenXXWWZx11lmGZaoz1g6pCihxso/nzp1L/fr1+fXXX23XiZdODeIHlNjdW/Oz7NfE8ZFq5Obmcv7553P77bezZ88ehg0bBkCzZs14//33+f7776lWrRpjx45ly5YtrtXHvXr1onnz5lx66aU8/vjj7NmzJyYrRrNmzVi7di0TJ06kS5cufP755zGBIg0bNmTVqlX8/PPP1K9fn0qVKsU8TxdddBH33nsvl156Kffddx/btm3j+uuv55JLLnFdw9iHDx8+fJQP+BZOipBsOjXzxOj222+PMdi9KHFOOukkbrnlFnJycqhWrVrc4yca/ZoKrF69Wv8slSRulDhjx44lOzvbEJmmIh6J8+WXX3Lsscfq380TuNNOO40hQ4bEbX+8ovZWzqVUOjqbNWumf1bv25NPPmmZg7ygoMDQl+KRFyrctNuKJJE41I6TlStXWi734nC3crCUdTo1u/o16nrJOE7+/e9/891335Gbmxtzflb929wP4tUhMB9XjeS3anfLli2ZO3cuP/zwg/NJJAi36dQSxaZNm8qcxJHvGfOzodYrceM4iRc96/U8fMdJ+UGyJE7Dhg1ZtmwZixcvNqzjNQjg+OOP58EHH+Sdd96Ju+6hDChRC33L96p6PeK9/+xq71jZImb8+9//1j9bjYnmcTQRxEunluy1tlOYzpgxI6YeHsSSOF7Sw7hJp3bZZZfFKJ7sjmW2TeyQqv5oFWAD3mzDZEmc4uLilKRTM9szXm0R9ZzfeOMNHnvsMa699lpX5+LlenXt2tXgrHRL4jRu3Jjhw4e7Po5XJDofcEPiFBUVlbkSx84WUTMDONkSyaZ2NUMGuPgBJT5SieHDh7Nr1y769u2rq3DvuusuOnbsSN++fenRowd5eXme6tcFg0EmT57MgQMHOPbYY7niiitigl369+/PzTffzIgRI2jfvj3ff/89d999t2GdgQMH0q9fP3r27EmtWrUsba2cnBymTp3Kzp076dKlC4MGDeLUU09l3Lhx3i+GDx8+fPg4pPCsxPFhjVSmU4tn6MrjORm133zzjf7ZLkJ19erVNGzY0PKYBzP6NV5KJjtD/Oabb+aGG26w/d3KcRIIBFizZg3FxcUxkabqxLNHjx588cUXbNmyxbFt//3vf+ndu7fBKW1GstfIaQJ25513cuGFF+pRQTICTcKKUKxSpUpM9Ktb2E2q27Vrx+LFi2nSpIljv7ziiisMxVTdOm0SdZyYr71dzSAvk1wrZ78Xx0l2drbheIdKiaPuU92XebJ+9dVXM2jQIMaOHcvzzz9vaJfVvlR06NCB6667Lqbd6rNn9/wed9xxBoI3lcjIyIg5z1QS16eeeirvvvtuyvZ37LHHMn/+fMMyeQ/M7a5SpYqemsEpelU+U079L5E82E2aNKGwsNBTSgkfZYNEAkrMY4FaY0zCbIs44b///S+XXXYZYP8uHD58uB5wcChJnFWrVumfrd4Vds/KkiVLeOGFF7jrrrssf7cjca677jp+/fVXpk2b5liwfMKECQwcOJBLLrnEsf0PPPBAjHNHhZMSxw3ivScvvPBCnnvuOcA4Lp1yyimMHz+efv36Gdbft2+f4fhebBE36dRee+01vvzyS8s6ZmZ12cEOKLn55psZOXJkzHIvzupk06mZj5doOjWzLeI1nZra5i5dutCiRQsgtr8OHTqUnTt38tlnn8W0S8Kpj5ozEgSDQUMQlNV4WbFiRVauXMnWrVstg6JSgUTnCG5InAMHDqQ0oCQQCMS0147EqVmzpt5Gp74lt3d6XwWDQdfnYaUa8+EjWXTr1i2m71evXj1u2tFZs2YZvpvnNc2bN2f27NmGZebjPPbYYzz22GOGZTfddJP+OSsri/fffz/m2Ob9tGnThq+//tq2rVbZdp5++mnb9X348OHDx6GBb+GkCKpxmWz0qxsSJxAIuDZQ7SYITnnqD6YS54YbbuC2224zRN2rbXY6T6dIKzvHyZFHHmmZKsSK2Ig3aahdu7ZtpKdEsgUB7dqQkZHBgw8+SEZGBk899RSjR4+OuaeqpHvSpEncdttt9O3bN2ESx+56f/rpp4wcOZJp06Y5bt+kSRND+jy3x1aLuXqBue/bXUsvk71ElTiDBg2iVatWMTJ48+Q2npNEIlkSx64N5vMLBoM0adLE4IBzG+H4f//3fzFjSTAYNNSS2Lx5c8x28r7ZkW7JwqzEqVevHlOnTk1qn2eccQbffPMN69ato127dil1nAwcOND2N/P1VYlcJ8eJfJ849d0VK1Z4Po8PP/yQBQsWeNrGR9kgWVvE7t3lhRy66qqr9D5qZ4u88sor+udDSeLIWiwnnXSSvsxNatc2bdrw/PPPx9TIkbCqiQMwbtw4Zs6c6fgOaNiwIZdeemncd8zo0aMNTh0rOKV2TRbLly83qIU6duxo+F1Nvynf52eeeabhXL0oceyux+OPPw4IuxLs+/CAAQMMAQZFRUWujltW7yQJL+oBq7HZy3h9+umnu67P55ROLZWqYCdbpH79+nz66aeGuYLbgJKbbrpJr7mpbqvazE4qcq/ElFtY1edTMwQ4IR6J079/f6688sqUkhlWikA7Ekd95t3YIk5j/dq1az21E0Sa4HipxH348OHDhw8fPg43+CROiqAayalIp2YFL9GvKtxEeZmLVB/MKOrc3FzGjBljmLikOr+9m4mxet1lkXO7e3H11Vdz/vnnc9ZZZ5X5pN4O6sTvpptusozA7dChAxMnTmTevHkMGjSIMWPGEAgEDNcjFSlMGjRowJNPPhk3tRwYCzq7PXb9+vXdNdAEt/3Iy/OUqBLn4osv5pdffqFr166G5bKfjh49GoCXXnpJ/01ebzUthYRZSePVcaL2n3gkjvl4bh0nVsvNEZVW46W8b25qUs2YMSPuOmaYHScbNmyIcfB4xaeffspJJ52k91X1GnlJryCRkZHBJ598wg033MDNN99s64xI1nHitM6yZcu8NNlHOUOytojd+JmoesLNeGzen3wXHwy0bt2ajRs3Mn36dH2Zm9Su8eBW7WAFtwElffv2tXxPqLC6/l7a49QGGRizbds2/vrrr5jAi44dO9K6dWtOO+00Vq5cyapVq2jTpo1hnVTYIldeeSVr167Vo4ft+lxaWpohjYzbY6v13MoCXvpYogElY8aM4dVXX+V///ufZd+U91IqYtT9WqVSVNscDAbLjMSR6znZ9nZ91MpON9fzMhcLh2j/cUPimFNgu0FGRoahjz744IN88sknrra1SwH70UcfsXfvXj7++GPq1KmTkoASmVr64YcfjvnNLjWrauu7sUWc3le//vqr5/MYNGgQ//d//+dpGx8+fPjw4cOHj/IOn8RJEeyUOM2bN/e8vR1SlVLKCuZ0E4WFhYbvdhGmqSBbymq/XnLZmxHPcTJmzBgmTpxIWlpaQo4yL7Brg9trdP7558cQB+o+U5FOLVGUNYnjFur1uOaaayzXkc4bO8fJE0884XiMmjVrWi6XE9+7776bXbt2cdFFFxn2C/GjfxPJQ2/nnDSfn7w2Ts5Muz5qjsaG6Dm9//77nHfeeVx//fW2bXPT30455RT9s4y+jgermjjJwnwN1O+TJ0+mT58+nvZXoUIFzjrrLJ555hkyMjIYNWpUTMFTiHWOeHWcWI2N0vHhlJrJR/lHKtKpWUG1RbyQLG5Uqebn0q6OWbztEkXdunVtFQleCRir7VJti3zzzTfMnz+fY489Nq4daXX9vThG3axbs2ZNy2COzMxMlixZwueff05OTo6eyldFKkgcEEElVu8tJ7g9drz0v8lCPa94CmQrJ35aWhonnnii43ZNmjTh8ssvp1q1apYkzrRp07jxxhuZMmVKTLtUW8RKiQPeVSt2trqdLeJk23shceS20oaQaYlVyDa4sUXcki8qzLbIqFGjki4y3qNHD8P5qm2fP38+Rx99tOd9vv7666xZs4aTTjqJbdu2Mer/27v38JiuvQ/g39yjJS6VyMUtROIaokhDvdGKW1Mal6DHrUeTaolSbb3Rt42m9KCHo45SQSutVhF9UA5CETRCCSFUSR2XUw2KEknJ0WS9f+SZ3bnsPbfMZGaP7+d55klmZl/W2mvPnt+stdda06dL72mOuak5cZQY64mjyUfLli0tTjMRERGRK2Ijjo1o/3DQHkO+d+/eFq+v9CNEu0LGkooT/R+xL730EvLy8nRekxszXGPZsmUG8zGogbnzjsgx1RNH+253e09grj92u4atKq30Ky/S09MVl7X1RKHmNiBpNyJ+8cUXZm/fmp44+ufK9u3bMW3aNCQlJQGQrzhxc3PD66+/rnNe6FNqxNE+pvXq1ZN9z1QjTk30xJFLl5KzZ88iOzsbjz/+uMF7mu0NHToU69evlz0ucuVWv359xf2tW7cOixYtwqJFi5Cbm2s0bYDh3a+WUJqQWp/+dcHS/clNsixXCatfFtrnirFyMtaI89FHH+HChQsYNmyYyevbO++8g8LCQqPLkGNoVzjL3UEtx549ceRo5stRcuPGDen/iIgIrFixolr7s5Q5w6mZUp1GHFOxSLt27dC1a1eztmWvm27M5ebmZvR6on8u6ffU0WbucbR1I452T5wnn3zSrHUsoX2uaHo/aIwfPx4ApAp0pV7BpuZj8/f3l/7XLg9NJXzz5s3x4Ycf6gw1prkuyA0frF8W9u6JY6xXsL4PP/wQsbGxBnPzaa+7bds2/PjjjwZzNllj8ODBCA4ORlFREVJSUkwur98r2JLrg9L5Z6xhq2vXrjrDRZrLy8tLOveVGmqr24gjd9NBfn4+Xn75ZSxdutSs31q88YSIiIhcHRtxbKikpAQ3b95Ex44dpdesqUS2pOJErkJjwIABOs/1t5eRkYEnnnjCrHS1atUKEyZMQEhIiFnL24otKhuUJm43h+b4Kv1A1P8xkZGRYdYPNkusWrUKw4cPR3Jysuz7tqqQ0d9OWloa7t69i/j4eOm1wMBAxMTE2LwRx5qeOM8884xN0wAYP1f69++PBQsWSD9QjQ1hYmz4L+3GClONtppKOU2ljVwjTk0Np6bZj7E06z8PDw9X7Hmi/5mS+4zJndu//fab9H9wcDB69+4tTSg6fPhwqReOqSGFgOr1xHnttddw9+5dDBkyxOhy1e21Zm4jjv6x174L2ljFieY9pfmWNHfKm6o4SU9PR/v27Y0uQzXr66+/xvz5860aItCcnjjay2i+K3v16mVy2/qfuX//+98WTRb+448/So3pNcXc+fmMsedwavqN28YqaK2dn0/TU2HChAlWrW8u/Xhgx44dmDdvHhITE3Ve9/T0NLu3hz174ixevNisdSyhP9edtpUrV6K0tFT6jaEUiwQFBRn97Cs14hg7NzW9auViEe31hBDVmj/G2PVHU5bG4jX9z8mUKVOQk5OjOJwaUNV4oNQ7xdzzRzNXzNdff42LFy8iLCwMU6ZMMbmefixiyTUmKysL8+bNk+byUtqGrXvQA/LnXnUbceSWCQ8Px8cff4zmzZubjEVu3rwpDUtMRERE5Kqsu62QZGnuUGvQoAE+//xzNG7c2OQdcRrawanSjwbtAFnzwz4pKUmq5B88eDBGjBhhshHHHAMGDMD27dvx1ltvWbyuLVhb2aDNFo04cj8ajh49avDaSy+9BAA6Y6xrPPXUU9i7dy9atGiBnj176gz/ZMwLL7wgO7yDraSkpODAgQN47rnnDN7T/8FbXFwMIYTNex2Zexd3/fr1MWfOHNy7d89ojwx95p77lpwrxubEMXZ8LEn3gQMHcOnSJWk4RlM9cYyNQ+/p6Snbc0/p7k/9Y2ZOw4El54WlFQqPPvooysrKUKdOHanHYEBAgM68FfrLm+Lh4VGtRtDatWubzLM9euLI0T+e2o39+pUijRs3xs8//wygqgIdqF7vutzcXLv3RCTLaRoYhRBISEhQ7AUox5wbSrRpruG7d++WzqWgoCB06tQJqampOsvqX0see+wxnaF45L4PGjZsiBs3buDZZ581mg579TLRTrO157p27GbLWCQ1NdXg8793716UlZXBz8/PYPl69eqhuLgYQFU5d+nSxaw07Ny5Ezdu3Kj2ME9KNGWvHxsFBwdj+vTpmDhxovTajh07UKtWLbMbCsyNJc1txHnkkUfQtWtXXL16VWfOGFsxNVSY9vebUq9g7b9ytBtxtMlVoh87dgxr166VhvKsTk8c7e9wbeYO7fr777+b3LetYxH9nnj6sdRjjz2Go0ePSje6ubm5SZ93c2KR6vQKDgwMxPTp0/Haa6/pvF6dYyJH7rwwpxFHO2411ohz8eJFANWLRcaMGWPWHIpEREREaseeOHYyZswYPPXUUzbtiaMd4MpVytapUwcjRoww+PGuXYFj7kTVWVlZOHToEMaNG2d0OUcPz2FMdRpxjA1hIjdElDFr165Feno6cnJykJmZibFjx1q0vr0sXrwYBQUFipXF+mVrj8paS8bAT01NNTrUmxxbDKemz1hPHGOVAtrvmTqWPj4+OvNpyTXiaI+Xb2xOHKUh3rSPjXZ6zKk4qQ5LK04OHDiA2NhYnfH5jY3pbk7l3mOPPVbthmJTFaDV/bzIfS5fe+01BAUF4c0331Tcj/aQJPrnshBCOh+6desGwPS10Vg+rBlbn2qOm5sbNm7ciBUrVlh1LTTnMyLXa7VVq1bYtm2bQa8Q7TTMnTtXJ1aRqxwGgD179mDq1KnIzMw0K/3OyF5z4syZM8fgNXd3d8VjuW7dOkRGRmLz5s24e/euwbC6Sjw8POzWgAMAv/zyC44dO2bWsHD9+vWzaDgoc897pUni5Rw6dAhFRUVmN7RbQvv8MPVdaeyGEmPrKlV2y80FFRUVhXnz5kmfVVM9cerUqaMYiwQEBMi+rtRQqn/9KSsrM1i3OhX/lsYiq1evBqA7NKWnpyeaN28ue+zs3StYQ2kYXg173FAi9xnUPwbm9grWXK+qE4u8/fbbRtclIiIichVsxLEzc+++t7biRJtSAJyUlIRRo0bh888/15mvB5D/0QZU/fiIjo522F3WzjKcmi3yHxAQgLS0NLtPiGtrmmHLlCqEbMGSRhwlUVFR+Pjjj3Ve01QGjR492mD55cuXG7ymXTlgTU8cTe+H6Oho0wmG5ee3XGVA7dq1UVRUhAsXLsDDw0OxQkmp/JRe18+fXMWJvure/Tpy5EiEhYVJz7WPT1RUFHJyctC9e3ccOXIEEyZMMDqMjbGKk8mTJyMqKgqLFy+u9jXmtddeM3ontn4+Ld3fp59+avBao0aNcOXKFXzwwQfSa8YacfTP5QcPHuDMmTPYsmULBg0aJLuMJcM92fPaQLZlTa9Ec2IRuRtKlK6hw4YNQ0hICJ5//nn87//+r857cj1HgKp5URYuXKg4N5yGvW4oscV2jQ2RZYrmemyLWKRDhw44ceIEBg0ahEceecQuwyxZo2HDhoiKilJ8XzO0ozXscV64u7vLzt8BGMYAQUFBAOTn95GbD6qkpET639S5YmyONGOfF6XtmnNuyjXieHh44Msvv8SKFSsQGBioeCOFdkOg5rjoM/ZbqLS0FIDxOXGqG4vop0v7/Bk5ciRu3ryJGTNm4Ouvv0aTJk2wceNGxe0bi0U0QwQvWLCg2jeU6PfEMXVMLP1MaOZg0hYZGYn8/HxcvXpVek0/djAWiwDAwYMHkZycjNdff11xGXMpfX8QERERuRrn+AXnwmbMmIG+ffti1apVRpfTrgwz505yuSBc6Qe5t7c3vvjiC4wZM8bofp2JoxtxTE0mrGTw4MEWLe/MXn75ZWRlZeHHH3+02z6sbcTRDLvy6quv4tixY3j55Zd13s/OzsaGDRswd+5cg3WTk5OlCmyN8vJy6X9TldiTJ0+Gv78/Jk+eLL3Wtm1bAFW9m2bMmIFTp04Z3YYlQ6sBysOphYWFSRVcAQEBCAwMNKiEUPpx2759e/zf//0flixZovO6OXe/6jN3iEBA/jq1Zs0anDt3Tnqu9Pnv0qULli1bpjgcDGD8+vnCCy/g2LFjaN68ebWvMT4+PrKVGxrVqXRNTU1V7Oljaig77YoT/WP94MEDBAUF4dlnn5Xe0742jh8/Hvn5+WanU3voNnJuSUlJqFWrlsH8Ccbo3+EtR+6GEqVYpE6dOrh06RLWrFkj+54zsnUsYumcONYyd6g0NXj11VeRkpKC7Oxsi9e1xdC8xmjmA+vYsSOuX7+O7777Tuf9ffv2YeLEidiyZYvBup988glatmyp89rNmzel/02dK5p5qLSvwy1atAAALFy4ED169MBXX31ldBva+zDnO0spFvnLX/4izVel1Hih3StY+7oRHByMAQMG4LnnntNZxpqeOKGhoSZyoLwuAJw6dQqFhYXSc/3Pv6YX05AhQ3D58mXExMRYtH2NRYsW4dq1axg2bFi1rzF+fn7YvXu39NyWc+K0bNlScVjtzp076zTM6e/HWK9gAIiJicHy5cul0SK0l2nevDm++OILneWNnZ9sxCEiIqKHBefEsbO6deua9cOzVq1ayMvLMzkp6CuvvIIjR46gX79+Bu9ZE6jXrl0bt27dsng9DWe++9XY3XqmaBpxtNPRpEkTk8N5rVu3DqdPn8b06dOxa9cui/bpbDw8PDBs2DC77sPaRpyNGzciJydH9nMAVDWSDB06VHH9rKwsnD59WpqsV5upBr9GjRqhuLgYHh4eUo8QzV3E9evX1xlqQ0lcXBxSUlJk786VY2pOHKCqIufs2bPw9PTUqUQZPnw4Tp48iZCQEFy5ckVnndmzZxtsR/+zp6k4MfYDevTo0ahVq5Y0RJcxcp/F6t4pqk2pd2FsbCw6depkk32Yozo9capzN7Gx7w9TPTjlJpnnnDeuoVGjRrhz545ZjQirV6/GjRs3dHrH6evWrRu+//572RsXjH3fKl1fnbURxxaqc0OJErleHNq2bduGDRs2ICcnB+vXr7fJPh3F19fXaO9LY+x9nd++fTuWLl2KiRMnyt5c0KpVK4MbJTTc3Nxw8OBBbNiwAZMmTTJ439S50qpVK5w7dw7+/v7SjSGaxruQkBCpQen5559X3Ebnzp3x9NNPo2nTpkb3pWHO59TDwwPHjh1DZWWlTmNidHQ0tm/fDkD3u8jNzQ3btm0z2I5SI47SHDoAMHbsWJw7d05q4DJG7jrVoEEDneHm7HX+9OrVS9qPLfZhbBvViUViYmLMvmbpxwravcPN+d7R3s/58+ct+t2mNIQfERERkatxip44S5YsQfPmzeHr64vo6Gh8//33RpfPyspC69at4evriw4dOhgE/0IIpKWlISgoCLVq1UJcXByKiop0lrl16xZGjRoFPz8/1KtXDy+++KLUVd9RnnjiCaN3dQHA0qVLceTIEdk7oK2pbDM2hIUjaRoPtCtdLVWdu880PzC1h5Y6dOiQyYoTLy8vdOrUya4Vn5oJVDt27Gi3fVTXG2+8AQCYOnWq0eXkKpXN4efnh0GDBikOaWKKt7c3oqKidO4iHDRoEF588UWzzhv9H7VxcXFGl9+5c6fOczc3NyxevBgvvfSSWek1pxEHqDou2pX4Xl5emD59OlavXo3Dhw/j73//OwBg1qxZituYP3++znNNxYnmvJPj7u6OxMRENGvWzGQaLR2H3hoFBQXYt2+f9PyNN95ATk6OxZO2m2JsG5ZeA7R7a1pyV6n2fkaNGqUzl5I+uSH3qjMO/cPIEfGKrXh5eZlVnqNHjzZ57T548CBu374tO0yoNd+91Rkyy55s0aPF1o04+/btkx1uUZu/vz9eeeUVxTnRbEFTZs58jXjhhRcAyM/hYQuNGzfG3/72N2l4LEsFBARg4sSJOvFchw4d0Lp1a6PfuRqtWrXS6TH37LPPGl3+o48+0nnu7u6O3bt3mxwtQMPcxtaoqCiD+SNTU1MxY8YMHDx4EK+++ioAYODAgYrbGD9+vM5zzW807TToX2s8PDwwZ84cxRt8tNXEcILbtm3DokWLpOd9+vRBSUmJTkORvXuLWfr51L72K90UI0f7eDZr1gy9e/eWnlvaiGPOzT7mvqdGrBchIiIiRcLB1q5dK7y9vcWnn34qTp8+LZKTk0W9evXEtWvXZJfPzc0VHh4e4oMPPhA//PCDePvtt4WXl5coLCyUlpk7d66oW7eu2LRpkzhx4oQYNGiQCA0NFffu3ZOW6d+/v+jYsaM4dOiQOHDggAgLCxPPP/+82em+c+eOACDu3LljfeZtBIAAIF5++WWL17127ZoYPXq0OHDggFX7HDhwoMX7NNeNGzfEgwcPrF5/165dUjrNpVn+kUceEUIIUVpaKr12+/Zts7fTt29fi/dtrqKiIjF58mRx6dIlm2/bVioqKsSJEydERUWF7PuaY+PoS9DcuXMFANGxY0fptV9++UV4enqKxMREk+sXFBSI3Nxc2fceffRRAUBERERUO53Hjx+36Hhplu3Ro4fBez///LOorKw0uv5vv/0m+xlftmyZ2LZtm2WJ10vTiBEjTC7TtGlTq/ah78yZM2Lu3LmirKzM4L2UlJRqn4OffPKJ4jb0rwFPP/209Pzo0aPS/1999ZU4c+aMqKysFBkZGaJ///6itLTU7DRs3bpVZz/ffPONQZo2b94sQkNDxcGDBw3Wz8jIMHocFi9erPN5BSDWrFkjCgoKFNPkTN+PtuSoeMUYZzrWmvNjwIABFq979epVERsbK7766iur9tmhQweL92mukydPiuLiYqvX//HHH6V0mluuct+Rmudnzpwxe99JSUl2+6794YcfxMCBA8XRo0dtvm1buXfvnvj6668V4zdniUUWLFggAAgfHx9RUVEh/vjjD3HlyhUBQAQHB5tcf8+ePSIzM1P2vUaNGtksj9rnsjk0ywYGBuq8/uDBA5GTkyN+//13xXUrKytFQUGBtI1OnTpJ77333nti8eLFVuVBs72YmBiTy7i5uVm1D33Hjh0TycnJsteRDz74oNrlY+z3TnJyss5748ePl55v2LBB+j8tLU1888034v79+2LhwoUiIiJC/Pzzz2an4cSJE9K27t+/r/Nc81tg/fr1wsvLS6xfv95g/R07dhg9DtqxjeYxf/58sXnzZsU0OdP3o7lYL0JEROQ67PH96PBGnG7duolJkyZJzysqKkRwcLCYM2eO7PLDhw8X8fHxOq9FR0eLCRMmCCGqgv7AwEDx97//XXr/9u3bwsfHR6oc+OGHHwQAceTIEWmZ7du3Czc3N3HlyhWz0u1MwYommF25cmWN79OejTjVtWfPHot/GD355JMCgEhOTpZeW716tfjss88s2veYMWOcomLAWTlLxUlFRYVYt26dwQ/r+/fvm2zoMKWwsFCMGjVKFBUVVWs7Gt999524ePGiWcv27NlTABDbt2+3en+a8nnmmWes3obc9qZNm6a4TJs2bUwuYyuTJk2q9jm4cuVKxW2sWrVKABBhYWFCCCFmzZqls6zm/+zsbKv3L4QQ//rXv3S2u3PnTovyZSwPQghx9uxZg4oTU5zp+9GWHBGvmOJMx1pzfsycObPG99m+ffsa26elzp07J6WzvLzcrHU0jcB9+/aVXlu+fLmYNWuWRft+4403nOK71lk5UyyyZMkScerUKZ3Xf/31V3H//v1qbbuwsFD07dtXHD58uFrb0di6davO7ydjevXqJQCI5cuXW70/Tfm0a9fO6m3IbW/o0KGKy3Tp0kUAEMOGDbPJPo2ZN29etc9BY9/7WVlZOu9p35ghxJ/HY8WKFVbvX4iqxm7tRptTp07Jpum///2v7Pqmbry7fPnyQxGLsF6EiIjIddjj+9Ghc+L897//RX5+PmbMmCG95u7ujri4OOTl5cmuk5eXh2nTpum81q9fP2zatAkAcOHCBVy9elVneKO6desiOjoaeXl5GDlyJPLy8lCvXj2dYTLi4uLg7u6Ow4cPy47xXl5erjP5+Z07dwAAJSUllmfcxg4ePIiDBw9iyJAhNZ6egIAApzgGciIjIxEVFYXw8HCz0/jFF1/g22+/RXx8vLTOoEGDAFhW1jNnzkRxcTH++te/Ou3xcaS4uDh8++23GDx4sMOPT//+/QEYlq/2590aTZs2xdKlS2W3bQ3N/DnmbGv16tW4cOECOnfubPW+58+fj3/84x9IT0+3Sfq//PJLZGVlYerUqYrb27p1K/bs2YNBgwbZ/bzo2rWr9L+1+2rbtq3iNhISEuDv74/27dujpKQEEyZMQK1atfD0009Lz4uKitClS5dq5bV169YAqoY9KSkpQdeuXZGQkIB27dqZtd0nnngCQNVcAHLLBwYGoqCgANeuXUN6ejrS0tJMblfzvrDzfBQ1yVHxij5njkVyc3ORnZ2NiRMn1nh6mjRp4hTHQI6/vz+6dOkCPz8/3Lt3D/fv3ze5zvLly7Fx40YkJCRI+RoxYgQAy8o6JSUF33//PYYPH+60x8eREhMTkZWVhR49ejj8+IwePRqAbvl6e3sbfOYt1bRpU2RlZRls21o9e/Y0e1uffvopjh8/jt69e1u978WLFyMtLQ3//Oc/bZL+devWYcWKFXj//fcVt7d27Vps3rwZiYmJdj8v2rRpI/1v7b6Cg4MVt9GnTx+sW7cOHTp0QElJCf7yl7/g9u3biI2NRUlJCSZPnozvvvsOAwcOrFZeH3vsMen/0tJSNG7cGIMHD5b9nXjv3j2D9Vu2bKmYB6Dqu/HQoUO4fv060tPTMX36dJeLRVgvQkRE5FrsEovYrDnICpqhAvSHeHnzzTdFt27dZNfx8vISa9as0XltyZIlIiAgQAhR1a0YgPjll190lklMTBTDhw8XQgjx/vvvi/DwcINt+/v7i6VLl8rud+bMmQZ3APHBBx988MEHH/KP8+fPmxcMqICj4hV9jEX44IMPPvjgw/yHWmIR1ovwwQcffPDBh2s+bBmLOLQnjprMmDFD506X27dvo1mzZrh8+bJdJ451pJKSEjRp0gT/+c9/LJpoW02YR9fAPLoG5tE13LlzB02bNtWZvJlsg7GIa35mmEfXwDy6BubRNTAWsR/GIq75mWEeXQPz6BqYR9dgj1jEoY04DRs2hIeHB65du6bz+rVr1xAYGCi7TmBgoNHlNX+vXbuGoKAgnWU6deokLXP9+nWdbfzxxx+4deuW4n59fHzg4+Nj8HrdunVd9oTT8PPzYx5dAPPoGphH1/Aw5NHd3d3RSbAZR8Ur+hiLMI9qxzy6BubRNTwMeVRLLMJ6EXV4GD4zzKNrYB5dA/PoGmwZizg0qvH29sbjjz+O3bt3S69VVlZi9+7diImJkV0nJiZGZ3kA2LVrl7R8aGgoAgMDdZYpKSnB4cOHpWViYmJw+/Zt5OfnS8vs2bMHlZWViI6Otln+iIiISP0cFa8QERGR62O9CBEREZni8OHUpk2bhnHjxqFLly7o1q0bPvzwQ5SVleGvf/0rAGDs2LEICQnBnDlzAABTpkxBbGwsFixYgPj4eKxduxZHjx7F8uXLAQBubm6YOnUqZs+ejVatWiE0NBTvvPMOgoODkZCQAKBqEsn+/fsjOTkZy5Ytw4MHD5CSkoKRI0fqTA5JREREBDgmXiEiIqKHA+tFiIiIyBiHN+KMGDECv/76K9LS0nD16lV06tQJO3bsQKNGjQAAly9f1ul61L17d6xZswZvv/023nrrLbRq1QqbNm1C+/btpWWmT5+OsrIyvPTSS7h9+zaefPJJ7NixA76+vtIyX375JVJSUtC7d2+4u7tj6NCh+Oc//2l2un18fDBz5kzZrsSugnl0Dcyja2AeXQPzqF6OileMcdVjrY15dA3Mo2tgHl0D8+icWC/ivJhH18A8ugbm0TUwj9ZxE0IIm22NiIiIiIiIiIiIiIiIbEIdM/0RERERERERERERERE9ZNiIQ0RERERERERERERE5ITYiENEREREREREREREROSE2IhDRERERERERERERETkhNiII2P//v0YOHAggoOD4ebmhk2bNplcJycnB507d4aPjw/CwsKQmZlp93RWh6V5zMnJgZubm8Hj6tWrNZNgK8yZMwddu3ZFnTp1EBAQgISEBJw9e9bkellZWWjdujV8fX3RoUMHbNu2rQZSax1r8piZmWlQjr6+vjWUYst9/PHHiIyMhJ+fH/z8/BATE4Pt27cbXUdNZQhYnke1laGcuXPnws3NDVOnTjW6nNrKUps5eVRbWb777rsG6W3durXRddRcho7GeMSQ2uIRxiLy1HbtYyxiSG1lKIexSBW1lSVjkZrFWMQQYxHnw1hEnprKEGAsYozaylIbY5EqtihDNuLIKCsrQ8eOHbFkyRKzlr9w4QLi4+Px1FNPoaCgAFOnTkVSUhKys7PtnFLrWZpHjbNnz6K4uFh6BAQE2CmF1bdv3z5MmjQJhw4dwq5du/DgwQP07dsXZWVliuscPHgQzz//PF588UUcP34cCQkJSEhIwKlTp2ow5eazJo8A4Ofnp1OOly5dqqEUW65x48aYO3cu8vPzcfToUTz99NN47rnncPr0adnl1VaGgOV5BNRVhvqOHDmCjIwMREZGGl1OjWWpYW4eAfWVZbt27XTS+9133ykuq+YydAaMR5SpJR5hLKJMTdc+xiLy1FSG+hiL6FJbWTIWqTmMRZQxFnEejEUMqa0MAcYiStRYlhqMRarYrAwFGQVAbNy40egy06dPF+3atdN5bcSIEaJfv352TJntmJPHvXv3CgDit99+q5E02cP169cFALFv3z7FZYYPHy7i4+N1XouOjhYTJkywd/Jswpw8rlq1StStW7fmEmUH9evXFytXrpR9T+1lqGEsj2ouw7t374pWrVqJXbt2idjYWDFlyhTFZdValpbkUW1lOXPmTNGxY0ezl1drGTojxiNV1B6PMBaporZrnxzGIuotQ8YiutRWloxFHIexSBXGIs6PsYj6y1CDsYh6y5KxyJ9sVYbsiWMDeXl5iIuL03mtX79+yMvLc1CK7KdTp04ICgpCnz59kJub6+jkWOTOnTsAgAYNGiguo/ayNCePAFBaWopmzZqhSZMmJu9scCYVFRVYu3YtysrKEBMTI7uM2svQnDwC6i3DSZMmIT4+3qCM5Ki1LC3JI6C+siwqKkJwcDBatGiBUaNG4fLly4rLqrUM1ephOt5qjUcYi/xJbdc+DcYif1JrGTIWMaS2smQs4rwepuPNWMR5MRZRfxkyFvmTWsuSscifbFWGnlallHRcvXoVjRo10nmtUaNGKCkpwb1791CrVi0Hpcx2goKCsGzZMnTp0gXl5eVYuXIlevXqhcOHD6Nz586OTp5JlZWVmDp1Knr06IH27dsrLqdUls46vq02c/MYERGBTz/9FJGRkbhz5w7mz5+P7t274/Tp02jcuHENpth8hYWFiImJwf3791G7dm1s3LgRbdu2lV1WrWVoSR7VWIYAsHbtWhw7dgxHjhwxa3k1lqWleVRbWUZHRyMzMxMREREoLi5Geno6evbsiVOnTqFOnToGy6uxDNWM8YhzxyOMRf6ktmsfwFhEnxrLEGAsIkdtZclYxLkxFmEs4miMRaqotQwZixhSY1kyFtFlqzJkIw6ZJSIiAhEREdLz7t274/z581i4cCFWr17twJSZZ9KkSTh16pTRMQrVztw8xsTE6NzJ0L17d7Rp0wYZGRmYNWuWvZNplYiICBQUFODOnTvYsGEDxo0bh3379il+mauRJXlUYxn+5z//wZQpU7Br1y6nnqCuOqzJo9rKcsCAAdL/kZGRiI6ORrNmzbB+/Xq8+OKLDkwZPSzUHI8wFvmT2q59AGMRfWosQ8Yi8tRWloxFyNEYizg3xiLqxlhE/RiL2C8WYSOODQQGBuLatWs6r127dg1+fn4ucaeJkm7duqniyz8lJQVbt27F/v37TbbgKpVlYGCgPZNYbZbkUZ+XlxeioqLw008/2Sl11eft7Y2wsDAAwOOPP44jR45g0aJFyMjIMFhWrWVoSR71qaEM8/Pzcf36dZ270yoqKrB//3589NFHKC8vh4eHh846aitLa/KoTw1lqa1evXoIDw9XTK/aylDtGI84L8Yixqnh2sdYxDg1lCFjEcYiGs5chmrHWMR5MRYxTg3XPsYixqmhDBmLMBbRsKYMOSeODcTExGD37t06r+3atcvouI2uoKCgAEFBQY5OhiIhBFJSUrBx40bs2bMHoaGhJtdRW1lak0d9FRUVKCwsdOqy1FdZWYny8nLZ99RWhkqM5VGfGsqwd+/eKCwsREFBgfTo0qULRo0ahYKCAtkvcbWVpTV51KeGstRWWlqK8+fPK6ZXbWWodg/r8XbmeISxiHnUdu0DGIvoU0MZMhZhLKLhzGWodg/r8WYs4liMRQyprQyVMBZRX1kyFjFkszIUZODu3bvi+PHj4vjx4wKA+Mc//iGOHz8uLl26JIQQIjU1VYwZM0Za/t///rd45JFHxJtvvinOnDkjlixZIjw8PMSOHTsclQWTLM3jwoULxaZNm0RRUZEoLCwUU6ZMEe7u7uLbb791VBZMeuWVV0TdunVFTk6OKC4ulh6///67tMyYMWNEamqq9Dw3N1d4enqK+fPnizNnzoiZM2cKLy8vUVhY6IgsmGRNHtPT00V2drY4f/68yM/PFyNHjhS+vr7i9OnTjsiCSampqWLfvn3iwoUL4uTJkyI1NVW4ubmJnTt3CiHUX4ZCWJ5HtZWhktjYWDFlyhTpuSuUpT5TeVRbWb7++usiJydHXLhwQeTm5oq4uDjRsGFDcf36dSGEa5ahIzEeUX88wlikitqvfYxF1F+GShiLqK8sGYvULMYijEXU8LlhLKL+MhSCsYiGK5SlPsYitilDNuLI2Lt3rwBg8Bg3bpwQQohx48aJ2NhYg3U6deokvL29RYsWLcSqVatqPN2WsDSP8+bNEy1bthS+vr6iQYMGolevXmLPnj2OSbyZ5PIHQKdsYmNjpTxrrF+/XoSHhwtvb2/Rrl078a9//atmE24Ba/I4depU0bRpU+Ht7S0aNWoknnnmGXHs2LGaT7yZxo8fL5o1aya8vb2Fv7+/6N27t/QlLoT6y1AIy/OotjJUov9F7gplqc9UHtVWliNGjBBBQUHC29tbhISEiBEjRoiffvpJet8Vy9CRGI+oPx5hLFJF7dc+xiLqL0MljEXUV5aMRWoWYxHGImr43DAWUX8ZCsFYRPu52stSH2MR25ShmxBCWNZ3h4iIiIiIiIiIiIiIiOyNc+IQERERERERERERERE5ITbiEBEREREREREREREROSE24hARERERERERERERETkhNuIQERERERERERERERE5ITbiEBEREREREREREREROSE24hARERERERERERERETkhNuIQERERERERERERERE5ITbiEBERPUT279+PgQMHIjg4GG5ubti0aZPF2xBCYP78+QgPD4ePjw9CQkLw/vvv2z6xRERE5HIYixAREZEjqTEW8bTblomIiMjplJWVoWPHjhg/fjyGDBli1TamTJmCnTt3Yv78+ejQoQNu3bqFW7du2TilRERE5IoYixAREZEjqTEWYU8cInIqv/76K1555RU0bdoUPj4+CAwMRL9+/ZCbmwsAVreQE1GVAQMGYPbs2Rg8eLDs++Xl5XjjjTcQEhKCRx99FNHR0cjJyZHeP3PmDD7++GNs3rwZgwYNQmhoKB5//HH06dOnhnJARGRfjEWI7IuxCBGRcYxFiOxLjbEIG3GIyKkMHToUx48fx2effYZz587hm2++Qa9evXDz5k1HJ43ooZCSkoK8vDysXbsWJ0+eRGJiIvr374+ioiIAwJYtW9CiRQts3boVoaGhaN68OZKSknj3KxG5DMYiRI7FWISIHnaMRYgcyyljEUFE5CR+++03AUDk5OTIvt+sWTMBQHo0a9ZMem/Tpk0iKipK+Pj4iNDQUPHuu++KBw8eSO8DEEuXLhX9+/cXvr6+IjQ0VGRlZdk7S0RODYDYuHGj9PzSpUvCw8NDXLlyRWe53r17ixkzZgghhJgwYYLw8fER0dHRYv/+/WLv3r2iU6dO4qmnnqrJpBMR2QVjEaKaxViEiEgXYxGimqWWWIQ9cYjIadSuXRu1a9fGpk2bUF5ebvD+kSNHAACrVq1CcXGx9PzAgQMYO3YspkyZgh9++AEZGRnIzMw0mFDsnXfewdChQ3HixAmMGjUKI0eOxJkzZ+yfMSKVKCwsREVFBcLDw6XPY+3atbFv3z6cP38eAFBZWYny8nJ8/vnn6NmzJ3r16oVPPvkEe/fuxdmzZx2cAyKi6mEsQuRYjEWI6GHHWITIsZw1FmEjDhE5DU9PT2RmZuKzzz5DvXr10KNHD7z11ls4efIkAMDf3x8AUK9ePQQGBkrP09PTkZqainHjxqFFixbo06cPZs2ahYyMDJ3tJyYmIikpCeHh4Zg1axa6dOmCxYsX12wmiZxYaWkpPDw8kJ+fj4KCAulx5swZLFq0CAAQFBQET09PhIeHS+u1adMGAHD58mWHpJuIyFYYixA5FmMRInrYMRYhcixnjUXYiENETmXo0KH45Zdf8M0336B///7IyclB586dkZmZqbjOiRMn8N577+m0kCcnJ6O4uBi///67tFxMTIzOejExMbzjhEhLVFQUKioqcP36dYSFhek8AgMDAQA9evTAH3/8Id2BAgDnzp0DADRr1swh6SYisiXGIkSOw1iEiIixCJEjOWss4mmXrRIRVYOvry/69OmDPn364J133kFSUhJmzpyJF154QXb50tJSpKenY8iQIbLbIqI/lZaW4qeffpKeX7hwAQUFBWjQoAHCw8MxatQojB07FgsWLEBUVBR+/fVX7N69G5GRkYiPj0dcXBw6d+6M8ePH48MPP0RlZSUmTZqEPn366NyFQkSkZoxFiOyHsQgRkWmMRYjsR42xCHviEJHTa9u2LcrKygAAXl5eqKio0Hm/c+fOOHv2rEELeVhYGNzd/7zMHTp0SGe9Q4cOSd0diR4WR48eRVRUFKKiogAA06ZNQ1RUFNLS0gBUja08duxYvP7664iIiEBCQgKOHDmCpk2bAgDc3d2xZcsWNGzYEP/zP/+D+Ph4tGnTBmvXrnVYnoiI7I2xCJHtMBYhIrIcYxEi21FjLOImhBB22zoRkQVu3ryJxMREjB8/HpGRkahTpw6OHj2KyZMnIz4+Hp988gnCw8MRFxeHtLQ0+Pj4oH79+sjOzsazzz6Lt99+G8OGDYO7uztOnDiBU6dOYfbs2QAANzc3NGzYEPPmzcOTTz6JL7/8ErNnz0ZhYSHatm3r4JwTERGRM2AsQkRERI7EWISI5LARh4icRnl5Od59913s3LkT58+fx4MHD9CkSRMkJibirbfeQq1atbBlyxZMmzYNFy9eREhICC5evAgAyM7OxnvvvYfjx4/Dy8sLrVu3RlJSEpKTkwFUBStLlizBpk2bsH//fgQFBWHevHkYPny4A3NMREREzoSxCBERETkSYxEiksNGHCJ6KLi5uWHjxo1ISEhwdFKIiIjoIcRYhIiIiByJsQiRenFOHCIiIiIiIiIiIiIiIifERhwiIiIiIiIiIiIiIiInxOHUiIiIiIiIiIiIiIiInBB74hARERERERERERERETkhNuIQERERERERERERERE5ITbiEBEREREREREREREROSE24hARERERERERERERETkhNuIQERERERERERERERE5ITbiEBEREREREREREREROSE24hARERERERERERERETkhNuIQERERERERERERERE5of8HxYWLzGb8NHAAAAAASUVORK5CYII=",
+            "text/plain": [
+              "<Figure size 2000x400 with 3 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "%matplotlib inline\n",
+        "import matplotlib\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "num_train_steps = int(5e6)\n",
+        "train_steps = train_loss[0]\n",
+        "eval_steps = eval_loss[0]\n",
+        "train_metrics = train_loss[1]\n",
+        "eval_metrics = eval_loss[1]\n",
+        "metric_keys = train_loss[2]\n",
+        "num_metrics = len(metric_keys)\n",
+        "\n",
+        "fig, axs = plt.subplots(1, num_metrics, figsize=(20, 4))\n",
+        "\n",
+        "metrics_unit={\"METRICS/E_PER_ATOM_RMSE\":\"eV/Atom\",\n",
+        "          \"METRICS/E_RMSE\":\"eV\",\n",
+        "          \"METRICS/F_RMSE\":\"eV/Ang\"}\n",
+        "\n",
+        "for index in range(0, num_metrics):\n",
+        "    axs[index].set_xlabel(r'Step')\n",
+        "    y_label = \"%s(%s)\"%(metric_keys[index], metrics_unit[metric_keys[index]])\n",
+        "    axs[index].set_ylabel(y_label)\n",
+        "    axs[index].set_xlim(0, num_train_steps)\n",
+        "    axs[index].plot(train_steps, train_metrics[index], color='black', label=\"Training\")\n",
+        "    axs[index].plot(eval_steps, eval_metrics[index], color='red', label=\"Validation\")\n",
+        "    axs[index].legend(edgecolor='none', loc='best')\n",
+        "\n",
+        "plt.subplots_adjust(hspace=500)\n",
+        "\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "I1z-xFvI_UdC"
+      },
+      "source": [
+        "## Run molecular dynamics with ASE"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "H_YRSWitmTfn"
+      },
+      "outputs": [],
+      "source": [
+        "import requests\n",
+        "with requests.get(\"https://raw.githubusercontent.com/Teoroo-CMC/PiNN/refs/heads/master/docs/notebooks/MLP_Water/water.xyz\", stream=True) as r:\n",
+        "    r.raise_for_status()\n",
+        "    with open(\"water.xyz\", 'wb') as f:\n",
+        "        for chunk in r.iter_content(chunk_size=8192):\n",
+        "            f.write(chunk)\n",
+        "! cp water.xyz MLP_Water"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dQRpScdt_UdC",
+        "outputId": "0c378a21-96b9-4af5-a4d9-95c8ecd537e1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing run_MD.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile run_MD.py\n",
+        "\n",
+        "import pinn\n",
+        "import tensorflow as tf\n",
+        "from ase import units\n",
+        "from ase.io import read,write\n",
+        "from ase.io.trajectory import Trajectory\n",
+        "from ase.md import MDLogger\n",
+        "from ase.md.velocitydistribution import thermalize_momenta\n",
+        "from ase.md.nptberendsen import NPTBerendsen\n",
+        "from ase.md.nvtberendsen import NVTBerendsen\n",
+        "\n",
+        "setup = {\n",
+        "        'ensemble': 'nvt',  # ensemble\n",
+        "        'T': 330.0,  # temperature\n",
+        "        't': 1000,  # time in fs\n",
+        "        'dt': 0.5,  # timestep in fs\n",
+        "        'taut': 10,  # thermostat damping in steps\n",
+        "        'taup': 1000,  # barastat dampling in steps\n",
+        "        'log-every': 100,  # log interval in steps\n",
+        "        'pressure': 1,  # pressure in bar\n",
+        "        'compressibility': 4.57e-4,  # compressibility in bar^{-1}\n",
+        "    }\n",
+        "\n",
+        "ensemble=setup['ensemble']\n",
+        "T = float(setup['T'])\n",
+        "t=float(setup['t'])*units.fs\n",
+        "dt=float(setup['dt'])*units.fs\n",
+        "taut=int(setup['taut'])\n",
+        "taup=int(setup['taup'])\n",
+        "every=int(setup['log-every'])\n",
+        "pressure=float(setup['pressure'])\n",
+        "compressibility=float(setup['compressibility'])\n",
+        "\n",
+        "# use the directory with trained models\n",
+        "project_dir = \"MLP_Water/\"\n",
+        "random_seed = 1\n",
+        "model_dir = project_dir + \"PiNet2_rPBE0_seed%d\"%(random_seed)\n",
+        "\n",
+        "# get calculator\n",
+        "calc = pinn.get_calc(model_dir + \"/params.yml\")\n",
+        "\n",
+        "# read initial structure\n",
+        "init_structure_file = project_dir + \"water.xyz\"\n",
+        "atoms = read(init_structure_file)\n",
+        "atoms.calc = calc\n",
+        "\n",
+        "# assign initial velocities (i.e., momenta)\n",
+        "thermalize_momenta(atoms, temperature_K=T)\n",
+        "\n",
+        "\n",
+        "if ensemble == 'npt':\n",
+        "    dyn = NPTBerendsen(atoms, timestep=dt, temperature=T, pressure=pressure,\n",
+        "                  taut=dt * taut, taup=dt * taup, compressibility=compressibility)\n",
+        "if ensemble == 'nvt':\n",
+        "    dyn = NVTBerendsen(atoms, timestep=dt, temperature=T, taut=dt * taut)\n",
+        "\n",
+        "log_file = project_dir + \"asemd.log\"\n",
+        "dyn.attach(\n",
+        "    MDLogger(dyn, atoms,log_file,stress=True, mode=\"w\"),\n",
+        "    interval=int(50*units.fs/dt))\n",
+        "\n",
+        "traj_file = project_dir + \"asemd.traj\"\n",
+        "dyn.attach(\n",
+        "    Trajectory(traj_file, 'w', atoms).write,\n",
+        "    interval=int(50*units.fs/dt))\n",
+        "\n",
+        "# run simulations\n",
+        "dyn.run(int(t/dt))\n",
+        "\n",
+        "print(\"done\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "WZr-TtqBX7W4"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python run_MD.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c8EZJTyw_UdD"
+      },
+      "source": [
+        "## Analyze the trajectory\n",
+        "\n",
+        "Once the trajectory has been acquired, you can perform various analyses based on it, such as calculating the radial distribution function (RDF) for specific pairs of atoms."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "92yiXFYf_UdD",
+        "outputId": "c7cb9bf6-ef21-4526-dfa8-72a0e57faf54"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "done\n"
+          ]
+        }
+      ],
+      "source": [
+        "import ase\n",
+        "import itertools\n",
+        "import numpy as np\n",
+        "from ase.io import iread\n",
+        "from ase.io.trajectory import Trajectory\n",
+        "\n",
+        "r_min = 0.0\n",
+        "r_max = 6.0\n",
+        "bin_num = 201\n",
+        "hist = 0\n",
+        "\n",
+        "bins = np.linspace(r_min,r_max,bin_num)\n",
+        "r_mid = (bins[1:] + bins[:-1])/2\n",
+        "bin_vol = (bins[1:]**3 - bins[:-1]**3)*4*np.pi/3\n",
+        "\n",
+        "traj_file = project_dir + \"asemd.traj\"\n",
+        "trajObj = Trajectory(traj_file)\n",
+        "start_fram_index = int(len(trajObj) / 2)\n",
+        "\n",
+        "count = 0\n",
+        "traj = iread(traj_file, index=slice(start_fram_index, None))\n",
+        "for data in traj:\n",
+        "\n",
+        "    count += 1\n",
+        "\n",
+        "    listIndex1 = [idx for idx in range(len(data)) if data[idx].symbol == \"O\"]\n",
+        "    index_ij = np.array(list(itertools.combinations(listIndex1, 2)))\n",
+        "\n",
+        "    data.wrap()\n",
+        "\n",
+        "    diff = data.positions[index_ij[:, 0]] - data.positions[index_ij[:, 1]]\n",
+        "    listCellLen = [data.cell[0][0], data.cell[1][1], data.cell[2][2]]\n",
+        "    diff = diff - np.rint(diff / listCellLen) * listCellLen\n",
+        "    dist = np.linalg.norm(diff, axis=1)\n",
+        "\n",
+        "    h, edges = np.histogram(dist, bins)\n",
+        "\n",
+        "    # normalize by the number density\n",
+        "    rho = dist.shape[0] / data.get_volume()\n",
+        "    hist += h / bin_vol / rho\n",
+        "\n",
+        "rdf = hist/count\n",
+        "print(\"done\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 392
+        },
+        "id": "h8gxyITc_UdD",
+        "outputId": "77e4474f-a6cc-4f3e-ce16-d3a2e3b656a4"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 400x400 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "fig, axs = plt.subplots(1, 1, figsize=(4, 4))\n",
+        "\n",
+        "axs.set_xlabel(r'$r \\, (\\mathrm{\\AA}$)')\n",
+        "axs.set_ylabel(r'$g_\\mathrm{OO}(r)$')\n",
+        "axs.set_xlim(2, 6)\n",
+        "\n",
+        "max_value = np.max(rdf)\n",
+        "min_value = np.min(rdf)\n",
+        "axs.set_ylim(min_value, max_value+0.2)\n",
+        "\n",
+        "axs.plot(r_mid, rdf, color='black')\n",
+        "\n",
+        "plt.subplots_adjust(hspace=500)\n",
+        "\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bkPkV9EN_UdD"
+      },
+      "source": [
+        "## Run jobs in batches\n",
+        "\n",
+        "When there is a need for batch model training and MD running jobs, incorporating the aforementioned process into a Nextflow script is a good choice.\n",
+        "\n",
+        "* Within the Nextflow framework, a pipeline script is composed of several processes that operate independently of each other.\n",
+        "* Each process is capable of defining multiple input and output channels and can be implemented using any scripting language, such as Bash or Python.\n",
+        "* The communication between two processes can be facilitated via their shared channels.\n",
+        "* A channel is capable of sending/receiving a message that may include values, pathes, files and so on.\n",
+        "\n",
+        "You can find more information of Nextflow from https://www.nextflow.io/docs/latest/index.html\n",
+        "\n",
+        "Here, we illustrate the Nextflow pipeline script of constructing a series of MLPs with varying hyperparameters across different training datasets."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wTs8U3Vp_UdD"
+      },
+      "source": [
+        "### Batch MLP training\n",
+        "\n",
+        "#### Pipeline script\n",
+        "To instruct Nextflow on executing a batch job, it is necessary to create a pipeline script that outlines the workflow, processes and channels. Thus, we need to create a script file (for example, \"**train.nf**\") and include the following content within it.\n",
+        "```\n",
+        "#!/usr/bin/env nextflow\n",
+        "nextflow.enable.dsl=2\n",
+        "\n",
+        "// step 1: create a collection of yml files including all hyperparameters of PiNN and store them in a directory named \"pinn-adam\".\n",
+        "// The format of yml files can be found in the section of \"Configure the model architecture and parameters\".\n",
+        "// After obtaining these files, we can define a parameter in the context of Nextflow for the convenience of creating channel.\n",
+        "params.inputs = './pinn-adam/*.yml'\n",
+        "\n",
+        "// step 2: define other parameters.\n",
+        "params.dataset = './input.data' // path of the dataset\n",
+        "params.seeds = 1       // number of seeds to split the dataset\n",
+        "params.steps = 5000000     // max number of steps\n",
+        "params.batch = 1           // batch size\n",
+        "params.ckpts = 1           // number of ckpts to keep, 0 -> all\n",
+        "params.log_every = 50   // log/summary frequency\n",
+        "params.ckpt_every = 50 // checkpoint frequency\n",
+        "\n",
+        "// step 3: create a channel that integrates various yml files, datasets, the number of training iterations, and different random split seeds.\n",
+        "model_config = Channel.fromPath(params.inputs)\n",
+        "    .combine(Channel.fromPath(params.dataset))\n",
+        "    .combine(Channel.value(params.steps))\n",
+        "    .combine(Channel.of(1..params.seeds))\n",
+        "\n",
+        "//step 4: define entry points for the entire workflow\n",
+        "workflow {\n",
+        "    pinn_train(model_config)\n",
+        "}\n",
+        "\n",
+        "def shorten(x) {sprintf('%.5E', (double) x).replaceAll(/\\.?0*E/, 'E').replaceAll(/E\\+0*/, 'E')}\n",
+        "\n",
+        "//step 5: define the training process\n",
+        "process pinn_train {\n",
+        "\n",
+        "    publishDir 'models/', mode: 'link'\n",
+        "    tag \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\"\n",
+        "    label 'pinn'\n",
+        "\n",
+        "    input:\n",
+        "    tuple (file(input), file(ds), val(step), val(seed))\n",
+        "\n",
+        "    output:\n",
+        "    path \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\", type:'dir'\n",
+        "\n",
+        "    \"\"\"\n",
+        "    # PiNN offers a command line interface for loading datasets and training MLPs\n",
+        "    # Certainly, you can use the python source code in the section \"Train the MLP models\" as an alternative.\n",
+        "    pinn convert $ds -o 'train:8,eval:2' --seed $seed\n",
+        "    pinn train $input -d \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\"\\\n",
+        "        --train-steps $params.steps --log-every $params.log_every --ckpt-every $params.ckpt_every\\\n",
+        "        --batch $params.batch --max-ckpts $params.ckpts --shuffle-buffer 1000 --init\n",
+        "    \"\"\"\n",
+        "}\n",
+        "```\n",
+        "\n",
+        "#### Configration file\n",
+        "When training MLPs on various machines, you can create a **nextflow.config** file to configure the execution settings on all machines. Here is an example for the alvis machine.\n",
+        "\n",
+        "```\n",
+        "profiles {\n",
+        "\n",
+        "  alvis {\n",
+        "    params{\n",
+        "      image = 'None'\n",
+        "    }\n",
+        "    executor{\n",
+        "      name = 'slurm'\n",
+        "      queueSize = 100\n",
+        "      submitRateLimit = '120 min'\n",
+        "    }\n",
+        "    process {\n",
+        "      time = '2d'\n",
+        "      accelerator = 1\n",
+        "      executor = 'slurm'\n",
+        "\n",
+        "      withLabel: 'pinn' {\n",
+        "        queue = 'alvis'\n",
+        "        clusterOptions = '-N 1 -n 1 --gpus-per-node=V100:1 -J revPBE0'\n",
+        "      }\n",
+        "    }\n",
+        "    singularity {\n",
+        "      enabled = false\n",
+        "    }\n",
+        "  }\n",
+        "}\n",
+        "```\n",
+        "\n",
+        "#### Run script\n",
+        "```\n",
+        "! nextflow run train.nf -profile alvis -bg > log.out\n",
+        "```\n",
+        "\n",
+        "#### Collect all MLPs into a new directory\n",
+        "```\n",
+        "! mkdir Models\n",
+        "! mv ./work/*/*/PiNet2* ./Models/\n",
+        "```"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HB794mH6_UdD"
+      },
+      "source": [
+        "### Batch MD simulation\n",
+        "Once we have acquired a set of MLPs, we can execute a batch of MD simulations by Nextflow. Here, we will use NVT simulations as an example.\n",
+        "\n",
+        "#### Pipeline script\n",
+        "First, we should create a script file **nvt.nf** and include the following content within it.\n",
+        "\n",
+        "```\n",
+        "#!/usr/bin/env nextflow\n",
+        "nextflow.enable.dsl=2\n",
+        "\n",
+        "// step 1: specify the path of all MLPs.\n",
+        "params.model = './Models/PiNet2*/'\n",
+        "\n",
+        "// step 2: define other parameters.\n",
+        "params.md_init = \"./water.xyz\" //initial strucutre of MD\n",
+        "params.md_ps = 200         // length of NVT simulation\n",
+        "\n",
+        "// step 3: create a channel that integrates initial strucutre, various MLPs, and different temperatures.\n",
+        "model_config = Channel.fromPath(params.md_init)\n",
+        "               .combine(Channel.fromPath(params.model, type: 'dir'))\n",
+        "               .combine(Channel.of(250,260,270,300,320))\n",
+        "\n",
+        "//step 4: define entry points for the entire workflow\n",
+        "workflow {\n",
+        "    pinn_nvt(model_config)\n",
+        "}\n",
+        "\n",
+        "//step 5: define the nvt simulation process\n",
+        "process pinn_nvt {\n",
+        "    publishDir \"mds/$pinn_model.baseName\", mode: 'link'\n",
+        "    tag \"$pinn_model.baseName\"\n",
+        "    label 'pinn'\n",
+        "\n",
+        "    input:\n",
+        "    tuple (file(md_geo),file(pinn_model),val(temp))\n",
+        "\n",
+        "    output:\n",
+        "    file \"NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.log\"\n",
+        "    file \"NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.traj\"\n",
+        "\n",
+        "    \"\"\"\n",
+        "    #!/usr/bin/env python3\n",
+        "    import pinn\n",
+        "    import tensorflow as tf\n",
+        "    from ase import units\n",
+        "    from ase.io import read\n",
+        "    from ase.io.trajectory import Trajectory\n",
+        "    from ase.md import MDLogger\n",
+        "    from ase.md.velocitydistribution import MaxwellBoltzmannDistribution\n",
+        "    from ase.md.nvtberendsen import NVTBerendsen\n",
+        "\n",
+        "    dTemp = $temp\n",
+        "    calc = pinn.get_calc(\"$pinn_model\")\n",
+        "    atoms = read(\"$md_geo\")\n",
+        "    atoms.set_calculator(calc)\n",
+        "    MaxwellBoltzmannDistribution(atoms, dTemp*units.kB)\n",
+        "    dt = 0.5 * units.fs\n",
+        "    dyn = NVTBerendsen(atoms, timestep=dt, temperature=dTemp, taut=dt*100)\n",
+        "\n",
+        "    dyn.attach(\n",
+        "        MDLogger(dyn, atoms, 'NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.log',stress=True, mode=\"w\"),\n",
+        "        interval=int(100*units.fs/dt))\n",
+        "    dyn.attach(\n",
+        "        Trajectory('NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.traj', 'w', atoms).write,\n",
+        "        interval=int(100*units.fs/dt))\n",
+        "    for i in range($params.md_ps):\n",
+        "        dyn.run(int(1e3*units.fs/dt))\n",
+        " \"\"\"\n",
+        "}\n",
+        "\n",
+        "```\n",
+        "\n",
+        "#### Run script\n",
+        "```\n",
+        "! nextflow run nvt.nf -profile alvis -bg > log.out\n",
+        "```"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
-   ],
-   "source": [
-    "fig, axs = plt.subplots(1, 1, figsize=(4, 4))\n",
-    "\n",
-    "axs.set_xlabel(r'$r \\, (\\mathrm{\\AA}$)')\n",
-    "axs.set_ylabel(r'$g_\\mathrm{OO}(r)$')\n",
-    "axs.set_xlim(2, 6)\n",
-    "\n",
-    "max_value = np.max(rdf)\n",
-    "min_value = np.min(rdf)\n",
-    "axs.set_ylim(min_value, max_value+0.2)\n",
-    "\n",
-    "axs.plot(r_mid, rdf, color='black')\n",
-    "\n",
-    "plt.subplots_adjust(hspace=500)\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "bkPkV9EN_UdD"
-   },
-   "source": [
-    "## Run jobs in batches\n",
-    "\n",
-    "When there is a need for batch model training and MD running jobs, incorporating the aforementioned process into a Nextflow script is a good choice.\n",
-    "\n",
-    "* Within the Nextflow framework, a pipeline script is composed of several processes that operate independently of each other.\n",
-    "* Each process is capable of defining multiple input and output channels and can be implemented using any scripting language, such as Bash or Python.\n",
-    "* The communication between two processes can be facilitated via their shared channels.\n",
-    "* A channel is capable of sending/receiving a message that may include values, pathes, files and so on.\n",
-    "\n",
-    "You can find more information of Nextflow from https://www.nextflow.io/docs/latest/index.html\n",
-    "\n",
-    "Here, we illustrate the Nextflow pipeline script of constructing a series of MLPs with varying hyperparameters across different training datasets."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "wTs8U3Vp_UdD"
-   },
-   "source": [
-    "### Batch MLP training\n",
-    "\n",
-    "#### Pipeline script\n",
-    "To instruct Nextflow on executing a batch job, it is necessary to create a pipeline script that outlines the workflow, processes and channels. Thus, we need to create a script file (for example, \"**train.nf**\") and include the following content within it.\n",
-    "```\n",
-    "#!/usr/bin/env nextflow\n",
-    "nextflow.enable.dsl=2\n",
-    "\n",
-    "// step 1: create a collection of yml files including all hyperparameters of PiNN and store them in a directory named \"pinn-adam\".\n",
-    "// The format of yml files can be found in the section of \"Configure the model architecture and parameters\".\n",
-    "// After obtaining these files, we can define a parameter in the context of Nextflow for the convenience of creating channel.\n",
-    "params.inputs = './pinn-adam/*.yml'\n",
-    "\n",
-    "// step 2: define other parameters.\n",
-    "params.dataset = './input.data' // path of the dataset\n",
-    "params.seeds = 1       // number of seeds to split the dataset\n",
-    "params.steps = 5000000     // max number of steps\n",
-    "params.batch = 1           // batch size\n",
-    "params.ckpts = 1           // number of ckpts to keep, 0 -> all\n",
-    "params.log_every = 50   // log/summary frequency\n",
-    "params.ckpt_every = 50 // checkpoint frequency\n",
-    "\n",
-    "// step 3: create a channel that integrates various yml files, datasets, the number of training iterations, and different random split seeds.\n",
-    "model_config = Channel.fromPath(params.inputs)\n",
-    "    .combine(Channel.fromPath(params.dataset))\n",
-    "    .combine(Channel.value(params.steps))\n",
-    "    .combine(Channel.of(1..params.seeds))\n",
-    "\n",
-    "//step 4: define entry points for the entire workflow\n",
-    "workflow {\n",
-    "    pinn_train(model_config)\n",
-    "}\n",
-    "\n",
-    "def shorten(x) {sprintf('%.5E', (double) x).replaceAll(/\\.?0*E/, 'E').replaceAll(/E\\+0*/, 'E')}\n",
-    "\n",
-    "//step 5: define the training process\n",
-    "process pinn_train {\n",
-    "\n",
-    "    publishDir 'models/', mode: 'link'\n",
-    "    tag \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\"\n",
-    "    label 'pinn'\n",
-    "\n",
-    "    input:\n",
-    "    tuple (file(input), file(ds), val(step), val(seed))\n",
-    "\n",
-    "    output:\n",
-    "    path \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\", type:'dir'\n",
-    "\n",
-    "    \"\"\"\n",
-    "    # PiNN offers a command line interface for loading datasets and training MLPs\n",
-    "    # Certainly, you can use the python source code in the section \"Train the MLP models\" as an alternative.\n",
-    "    pinn convert $ds -o 'train:8,eval:2' --seed $seed\n",
-    "    pinn train $input -d \"PiNet2-$ds.baseName-$input.baseName-B${params.batch}-${shorten(step)}-$seed\"\\\n",
-    "        --train-steps $params.steps --log-every $params.log_every --ckpt-every $params.ckpt_every\\\n",
-    "        --batch $params.batch --max-ckpts $params.ckpts --shuffle-buffer 1000 --init\n",
-    "    \"\"\"\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "#### Configration file\n",
-    "When training MLPs on various machines, you can create a **nextflow.config** file to configure the execution settings on all machines. Here is an example for the alvis machine.\n",
-    "\n",
-    "```\n",
-    "profiles {\n",
-    "\n",
-    "  alvis {\n",
-    "    params{\n",
-    "      image = 'None'\n",
-    "    }\n",
-    "    executor{\n",
-    "      name = 'slurm'\n",
-    "      queueSize = 100\n",
-    "      submitRateLimit = '120 min'\n",
-    "    }\n",
-    "    process {\n",
-    "      time = '2d'\n",
-    "      accelerator = 1\n",
-    "      executor = 'slurm'\n",
-    "\n",
-    "      withLabel: 'pinn' {\n",
-    "        queue = 'alvis'\n",
-    "        clusterOptions = '-N 1 -n 1 --gpus-per-node=V100:1 -J revPBE0'\n",
-    "      }\n",
-    "    }\n",
-    "    singularity {\n",
-    "      enabled = false\n",
-    "    }\n",
-    "  }\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "#### Run script\n",
-    "```\n",
-    "! nextflow run train.nf -profile alvis -bg > log.out\n",
-    "```\n",
-    "\n",
-    "#### Collect all MLPs into a new directory\n",
-    "```\n",
-    "! mkdir Models\n",
-    "! mv ./work/*/*/PiNet2* ./Models/\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "HB794mH6_UdD"
-   },
-   "source": [
-    "### Batch MD simulation\n",
-    "Once we have acquired a set of MLPs, we can execute a batch of MD simulations by Nextflow. Here, we will use NVT simulations as an example.\n",
-    "\n",
-    "#### Pipeline script\n",
-    "First, we should create a script file **nvt.nf** and include the following content within it.\n",
-    "\n",
-    "```\n",
-    "#!/usr/bin/env nextflow\n",
-    "nextflow.enable.dsl=2\n",
-    "\n",
-    "// step 1: specify the path of all MLPs.\n",
-    "params.model = './Models/PiNet2*/'\n",
-    "\n",
-    "// step 2: define other parameters.\n",
-    "params.md_init = \"./water.xyz\" //initial strucutre of MD\n",
-    "params.md_ps = 200         // length of NVT simulation\n",
-    "\n",
-    "// step 3: create a channel that integrates initial strucutre, various MLPs, and different temperatures.\n",
-    "model_config = Channel.fromPath(params.md_init)\n",
-    "               .combine(Channel.fromPath(params.model, type: 'dir'))\n",
-    "               .combine(Channel.of(250,260,270,300,320))\n",
-    "\n",
-    "//step 4: define entry points for the entire workflow\n",
-    "workflow {\n",
-    "    pinn_nvt(model_config)\n",
-    "}\n",
-    "\n",
-    "//step 5: define the nvt simulation process\n",
-    "process pinn_nvt {\n",
-    "    publishDir \"mds/$pinn_model.baseName\", mode: 'link'\n",
-    "    tag \"$pinn_model.baseName\"\n",
-    "    label 'pinn'\n",
-    "\n",
-    "    input:\n",
-    "    tuple (file(md_geo),file(pinn_model),val(temp))\n",
-    "\n",
-    "    output:\n",
-    "    file \"NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.log\"\n",
-    "    file \"NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.traj\"\n",
-    "\n",
-    "    \"\"\"\n",
-    "    #!/usr/bin/env python3\n",
-    "    import pinn\n",
-    "    import tensorflow as tf\n",
-    "    from ase import units\n",
-    "    from ase.io import read\n",
-    "    from ase.io.trajectory import Trajectory\n",
-    "    from ase.md import MDLogger\n",
-    "    from ase.md.velocitydistribution import MaxwellBoltzmannDistribution\n",
-    "    from ase.md.nvtberendsen import NVTBerendsen\n",
-    "\n",
-    "    dTemp = $temp\n",
-    "    calc = pinn.get_calc(\"$pinn_model\")\n",
-    "    atoms = read(\"$md_geo\")\n",
-    "    atoms.set_calculator(calc)\n",
-    "    MaxwellBoltzmannDistribution(atoms, dTemp*units.kB)\n",
-    "    dt = 0.5 * units.fs\n",
-    "    dyn = NVTBerendsen(atoms, timestep=dt, temperature=dTemp, taut=dt*100)\n",
-    "\n",
-    "    dyn.attach(\n",
-    "        MDLogger(dyn, atoms, 'NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.log',stress=True, mode=\"w\"),\n",
-    "        interval=int(100*units.fs/dt))\n",
-    "    dyn.attach(\n",
-    "        Trajectory('NVT-${temp}K-${params.md_ps}ps-${md_geo.simpleName}.traj', 'w', atoms).write,\n",
-    "        interval=int(100*units.fs/dt))\n",
-    "    for i in range($params.md_ps):\n",
-    "        dyn.run(int(1e3*units.fs/dt))\n",
-    " \"\"\"\n",
-    "}\n",
-    "\n",
-    "```\n",
-    "\n",
-    "#### Run script\n",
-    "```\n",
-    "! nextflow run nvt.nf -profile alvis -bg > log.out\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "accelerator": "GPU",
-  "colab": {
-   "gpuType": "T4",
-   "provenance": []
-  },
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "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.9.6"
+    }
   },
-  "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.9.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 0
 }
diff --git a/docs/notebooks/Customizing_dataset.ipynb b/docs/notebooks/Customizing_dataset.ipynb
index 5036abdb..d1832571 100644
--- a/docs/notebooks/Customizing_dataset.ipynb
+++ b/docs/notebooks/Customizing_dataset.ipynb
@@ -1,268 +1,446 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Customizing dataset [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Customizing_dataset.ipynb)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install PiNN\n",
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data list dataset\n",
-    "\n",
-    "Suppose your dataset can be represented as a list and each data point can \n",
-    "be accessed separately with some function.\n",
-    "\n",
-    "The list dataset descriptor helps you to transform your reader function to \n",
-    "a dataset loader, with handy options to split your dataset.\n",
-    "The list can be your list of filenames of structures, or identifiers to \n",
-    "retrieve your data points, e.g. ID from some online database.\n",
-    "\n",
-    "The advantage of this approach is that you only need to write the reader for \n",
-    "one data point, \n",
-    "and you can get the tensorflow dataset objects with reasonably optimized IO.\n",
-    "Later, it's also easy to convert your dataset into the TFRecord format \n",
-    "if you need to train on the cloud or further improve the performance.\n",
-    "\n",
-    "We'll demonstrate with a list of ASE atoms."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ase import Atoms\n",
-    "datalist = [Atoms(elem) for elem in ['Cu', 'Ag', 'Au']]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For the purpose of training ANN potentials, you typically need to provide the \n",
-    "elements, coordinates and potential energy of a struture. \n",
-    "\n",
-    "Your reader function should take one list element as input, \n",
-    "and return a dictionary consisting of:\n",
-    "\n",
-    "- `'atoms'`: the elements of shape [n_atoms]\n",
-    "- `'coord'`: the coordinates of shape [n_atoms, 3]\n",
-    "- `'e_data'`: a single number\n",
-    "\n",
-    "After you have got your reader function, decorate it with the `list_loader`\n",
-    "decorator to transform it into a dataset loader."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pinn.io import list_loader\n",
-    "\n",
-    "@list_loader()\n",
-    "def load_ase_list(atoms):\n",
-    "    import numpy as np\n",
-    "    datum = {'elems': atoms.numbers,\n",
-    "            'coord': atoms.positions,\n",
-    "            'e_data': 0.0}\n",
-    "    return datum"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "That's it, you've got your customized dataset!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0}\n",
-      "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0}\n",
-      "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0}\n"
-     ]
-    }
-   ],
-   "source": [
-    "import tensorflow as tf\n",
-    "\n",
-    "dataset = load_ase_list(datalist)\n",
-    "for tensors in dataset.as_numpy_iterator():\n",
-    "    print(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Force and cell\n",
-    "\n",
-    "By default, the list loader expects the loader to return the elements, coordinates and \n",
-    "total energy of each structure. It is also usual to have nuclei forces and pbc in the training data.\n",
-    "\n",
-    "The default behavior of list_loader can be changed with the `pbc` and `force` options."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_0Tr1SMc8YTP"
+      },
+      "source": [
+        "# Customizing dataset [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Customizing_dataset.ipynb)\n"
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.],\n",
-      "       [0., 0., 0.],\n",
-      "       [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)}\n",
-      "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.],\n",
-      "       [0., 0., 0.],\n",
-      "       [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)}\n",
-      "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.],\n",
-      "       [0., 0., 0.],\n",
-      "       [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)}\n"
-     ]
-    }
-   ],
-   "source": [
-    "@list_loader(pbc=True, force=True)\n",
-    "def load_ase_list(atoms):\n",
-    "    import numpy as np\n",
-    "    data = {'elems': atoms.numbers,\n",
-    "            'coord': atoms.positions,\n",
-    "            'cell': atoms.cell[:], # get full cell from ASE\n",
-    "            'f_data': np.zeros_like(atoms.positions),\n",
-    "            'e_data': 0.0}\n",
-    "    return data\n",
-    "\n",
-    "dataset = load_ase_list(datalist)\n",
-    "for tensors in dataset.as_numpy_iterator():\n",
-    "    print(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Dataset Spec\n",
-    "\n",
-    "For even more complex dataset structures, you can instead supply a dataset specification\n",
-    "to build your list loader.\n",
-    "Note that the dataset is always expected to be \n",
-    "a dictionary of tensors.\n",
-    "\n",
-    "For example, we add a molecular weight entry to the dataset here.\n",
-    "The format dict should provide the shape and datatype of each \n",
-    "entry. \n",
-    "In the case that a certain dimension is unknow, e.g. the number of atoms,\n",
-    "use `None` as the dimension."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ds_spec = {\n",
-    "    'elems': {'dtype':  tf.int32,   'shape': [None]},\n",
-    "    'coord': {'dtype':  tf.float32, 'shape': [None, 3]},\n",
-    "    'e_data': {'dtype': tf.float32, 'shape': []},\n",
-    "    'mw_data': {'dtype': tf.float32, 'shape': []}}\n",
-    "\n",
-    "@list_loader(ds_spec=ds_spec)\n",
-    "def load_ase_list(atoms):\n",
-    "    data = {'elems': atoms.numbers,\n",
-    "            'coord': atoms.positions,\n",
-    "            'e_data': 0.0,\n",
-    "            'mw_data': atoms.get_masses().sum()}\n",
-    "    return data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "yEV2hTnb8YTS"
+      },
+      "outputs": [],
+      "source": [
+        "# Install konda\n",
+        "!pip -q install konda\n",
+        "\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "# Accept Anaconda Terms of Service\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "# Create the environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "\n",
+        "!konda activate pinn_env\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'ase>=3.25' 'PyYAML~=6.0.1' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "\n",
+        "#Install ase to runtime\n",
+        "import sys\n",
+        "!{sys.executable} -m pip -q install ase"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1kaWXmv88YTT"
+      },
+      "source": [
+        "## Data list dataset\n",
+        "\n",
+        "Suppose your dataset can be represented as a list and each data point can\n",
+        "be accessed separately with some function.\n",
+        "\n",
+        "The list dataset descriptor helps you to transform your reader function to\n",
+        "a dataset loader, with handy options to split your dataset.\n",
+        "The list can be your list of filenames of structures, or identifiers to\n",
+        "retrieve your data points, e.g. ID from some online database.\n",
+        "\n",
+        "The advantage of this approach is that you only need to write the reader for\n",
+        "one data point,\n",
+        "and you can get the tensorflow dataset objects with reasonably optimized IO.\n",
+        "Later, it's also easy to convert your dataset into the TFRecord format\n",
+        "if you need to train on the cloud or further improve the performance.\n",
+        "\n",
+        "We'll demonstrate with a list of ASE atoms."
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 63.546}\n",
-      "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 107.8682}\n",
-      "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 196.96657}\n"
-     ]
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "7ZfWhcu_8YTT",
+        "outputId": "aa9cd00b-9503-4922-c165-d701e6fa275f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting datalist.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "#The code is written into a python file and run with conda using !konda run\n",
+        "%%writefile datalist.py\n",
+        "\n",
+        "from ase import Atoms\n",
+        "datalist = [Atoms(elem) for elem in ['Cu', 'Ag', 'Au']]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kNYssxz48YTU"
+      },
+      "source": [
+        "For the purpose of training ANN potentials, you typically need to provide the\n",
+        "elements, coordinates and potential energy of a struture.\n",
+        "\n",
+        "Your reader function should take one list element as input,\n",
+        "and return a dictionary consisting of:\n",
+        "\n",
+        "- `'atoms'`: the elements of shape [n_atoms]\n",
+        "- `'coord'`: the coordinates of shape [n_atoms, 3]\n",
+        "- `'e_data'`: a single number\n",
+        "\n",
+        "After you have got your reader function, decorate it with the `list_loader`\n",
+        "decorator to transform it into a dataset loader."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZR_8_rKn8YTU",
+        "outputId": "82ba810e-222e-42bc-b0c1-872158b8641b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to datalist.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a datalist.py\n",
+        "\n",
+        "from pinn.io import list_loader\n",
+        "\n",
+        "@list_loader()\n",
+        "def load_ase_list(atoms):\n",
+        "    import numpy as np\n",
+        "    datum = {'elems': atoms.numbers,\n",
+        "            'coord': atoms.positions,\n",
+        "            'e_data': 0.0}\n",
+        "    return datum"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HJPi2_z48YTU"
+      },
+      "source": [
+        "That's it, you've got your customized dataset!"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0oCqN2I-8YTV",
+        "outputId": "28587ea8-d4b6-41ab-856f-2a69957e1d86"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to datalist.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a datalist.py\n",
+        "\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "dataset = load_ase_list(datalist)\n",
+        "for tensors in dataset.as_numpy_iterator():\n",
+        "    print(tensors)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OomGo2eX_Wpa",
+        "outputId": "38ef60fd-8273-4737-e7b8-d74392f3d26a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0} \n",
+            "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0} \n",
+            "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0}\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python datalist.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "MLNe2sHV8YTV"
+      },
+      "source": [
+        "## Force and cell\n",
+        "\n",
+        "By default, the list loader expects the loader to return the elements, coordinates and\n",
+        "total energy of each structure. It is also usual to have nuclei forces and pbc in the training data.\n",
+        "\n",
+        "The default behavior of list_loader can be changed with the `pbc` and `force` options."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BXVef3EV8YTV",
+        "outputId": "06f91367-0c1a-4e22-972d-2206d1afc37f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to datalist.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a datalist.py\n",
+        "\n",
+        "@list_loader(pbc=True, force=True)\n",
+        "def load_ase_list(atoms):\n",
+        "    import numpy as np\n",
+        "    data = {'elems': atoms.numbers,\n",
+        "            'coord': atoms.positions,\n",
+        "            'cell': atoms.cell[:], # get full cell from ASE\n",
+        "            'f_data': np.zeros_like(atoms.positions),\n",
+        "            'e_data': 0.0}\n",
+        "    return data\n",
+        "\n",
+        "dataset = load_ase_list(datalist)\n",
+        "for tensors in dataset.as_numpy_iterator():\n",
+        "    print(tensors)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rByVI5tp_wy4",
+        "outputId": "41e0dfd6-7be5-48eb-9d16-3df127d04ec8"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)} \n",
+            "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)} \n",
+            "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'cell': array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]], dtype=float32), 'f_data': array([[0., 0., 0.]], dtype=float32)}\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python datalist.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9Kzl_FZS8YTW"
+      },
+      "source": [
+        "## Dataset Spec\n",
+        "\n",
+        "For even more complex dataset structures, you can instead supply a dataset specification\n",
+        "to build your list loader.\n",
+        "Note that the dataset is always expected to be\n",
+        "a dictionary of tensors.\n",
+        "\n",
+        "For example, we add a molecular weight entry to the dataset here.\n",
+        "The format dict should provide the shape and datatype of each\n",
+        "entry.\n",
+        "In the case that a certain dimension is unknow, e.g. the number of atoms,\n",
+        "use `None` as the dimension."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IxMzugUr8YTW",
+        "outputId": "a25da2ba-21ff-4cd3-9e04-04f62ef437b1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting dataset_spec.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile dataset_spec.py\n",
+        "\n",
+        "from pinn.io import list_loader\n",
+        "from ase import Atoms\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "datalist = [Atoms(elem) for elem in ['Cu', 'Ag', 'Au']]\n",
+        "\n",
+        "ds_spec = {\n",
+        "    'elems': {'dtype':  tf.int32,   'shape': [None]},\n",
+        "    'coord': {'dtype':  tf.float32, 'shape': [None, 3]},\n",
+        "    'e_data': {'dtype': tf.float32, 'shape': []},\n",
+        "    'mw_data': {'dtype': tf.float32, 'shape': []}}\n",
+        "\n",
+        "@list_loader(ds_spec=ds_spec)\n",
+        "def load_ase_list(atoms):\n",
+        "    data = {'elems': atoms.numbers,\n",
+        "            'coord': atoms.positions,\n",
+        "            'e_data': 0.0,\n",
+        "            'mw_data': atoms.get_masses().sum()}\n",
+        "    return data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xKx51Md18YTW",
+        "outputId": "88e9dbc2-90cd-4b65-b750-4344d36ff734"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to dataset_spec.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a dataset_spec.py\n",
+        "\n",
+        "dataset = load_ase_list(datalist)\n",
+        "for tensors in dataset.as_numpy_iterator():\n",
+        "    print(tensors)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "61Wh3LgBAtqU",
+        "outputId": "70c49d23-5640-4e8b-9f2a-7130ae3508be"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'elems': array([29], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 63.546} \n",
+            "{'elems': array([47], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 107.8682} \n",
+            "{'elems': array([79], dtype=int32), 'coord': array([[0., 0., 0.]], dtype=float32), 'e_data': 0.0, 'mw_data': 196.96657}\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python dataset_spec.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fkvO-JSF8YTW"
+      },
+      "source": [
+        "## Loading trajectories\n",
+        "\n",
+        "It's rather common to have trajectories as training data.\n",
+        "However, trajectories are harder to handle compared to lists as\n",
+        "it's not trivial how many data points there are and how they should be split.\n",
+        "\n",
+        "One solution is to load all the data into the memory once.\n",
+        "A more sophisticated solution is to quickly scan through the dataset and\n",
+        "get a list of \"positions\" which can be used to read a particular frame.\n",
+        "\n",
+        "You might want to look into `pinn.io.runner` or `pinn.io.cp2k`\n",
+        "if you would like to implement something like that."
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "pinn-tf2",
+      "language": "python",
+      "name": "pinn-tf2"
+    },
+    "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.9.5"
     }
-   ],
-   "source": [
-    "dataset = load_ase_list(datalist)\n",
-    "for tensors in dataset.as_numpy_iterator():\n",
-    "    print(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Loading trajectories\n",
-    "\n",
-    "It's rather common to have trajectories as training data. \n",
-    "However, trajectories are harder to handle compared to lists as \n",
-    "it's not trivial how many data points there are and how they should be split.\n",
-    "\n",
-    "One solution is to load all the data into the memory once.\n",
-    "A more sophisticated solution is to quickly scan through the dataset and \n",
-    "get a list of \"positions\" which can be used to read a particular frame.\n",
-    "\n",
-    "You might want to look into `pinn.io.runner` or `pinn.io.cp2k`\n",
-    "if you would like to implement something like that."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pinn-tf2",
-   "language": "python",
-   "name": "pinn-tf2"
   },
-  "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.9.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 0
 }
diff --git a/docs/notebooks/Layer_debug.ipynb b/docs/notebooks/Layer_debug.ipynb
index 33ac555e..00478eca 100644
--- a/docs/notebooks/Layer_debug.ipynb
+++ b/docs/notebooks/Layer_debug.ipynb
@@ -1,271 +1,457 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "e89da443-220a-4b9a-bbd7-b2a1a566022a",
-   "metadata": {},
-   "source": [
-    "# Debugging PiNN layers and networks [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Layer_debug.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d7bc1d47-43b2-47c6-b2b0-feb28537474b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN\n",
-    "!wget -nv -nc https://raw.githubusercontent.com/Teoroo-CMC/PiNN_lab/master/resources/qm9_train.{yml,tfr}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ed40d2c3-2f41-4da0-b1e7-b4aac1e33614",
-   "metadata": {},
-   "source": [
-    "## Loading data\n",
-    "\n",
-    "For the purpose of testing we download a subset of the QM9 dataset used in [PiNN_lab](https://github.com/Teoroo-CMC/PiNN_lab)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fad78f2f-14b2-4a72-82ba-7615ecd3daa4",
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'A': TensorShape([10]), 'B': TensorShape([10]), 'C': TensorShape([10]), 'Cv': TensorShape([10]), 'G': TensorShape([10]), 'H': TensorShape([10]), 'U': TensorShape([10]), 'U0': TensorShape([10]), 'alpha': TensorShape([10]), 'coord': TensorShape([176, 3]), 'elems': TensorShape([176]), 'gap': TensorShape([10]), 'homo': TensorShape([10]), 'lumo': TensorShape([10]), 'mu': TensorShape([10]), 'r2': TensorShape([10]), 'zpve': TensorShape([10]), 'ind_1': TensorShape([176, 1])}\n"
-     ]
-    }
-   ],
-   "source": [
-    "from pinn.io import load_tfrecord, sparse_batch\n",
-    "\n",
-    "dataset = load_tfrecord(\"qm9_train.yml\").apply(sparse_batch(10))\n",
-    "for datum in dataset:\n",
-    "    print({k: v.shape for k, v in datum.items()})\n",
-    "    break"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5eed3a0b-fc9b-4b49-933c-8c15c7f7bc52",
-   "metadata": {},
-   "source": [
-    "## Using PiNN Layers\n",
-    "\n",
-    "PiNN networks and layers are Keras [Layers](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) \n",
-    "and [Models](https://www.tensorflow.org/api_docs/python/tf/keras/Model). \n",
-    "\n",
-    "To use them, you create an instance of layer, after that, the layer object can be used as a function. Each layer\n",
-    "is initialized with different parameters and requires different input tensors, see their individual documentation\n",
-    "for the details."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "3ad6ea7b-4845-4812-9a27-6ab1c68fd23f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pinn.layers import CellListNL\n",
-    "from pinn.networks.pinet import PILayer, PiNet\n",
-    "\n",
-    "nl = CellListNL(rc=5)\n",
-    "\n",
-    "for datum in dataset:\n",
-    "    nl(datum)\n",
-    "    break"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "51155051-78bc-44f6-b860-c8bf48d46c43",
-   "metadata": {},
-   "source": [
-    "The definition of a layer needs three parts:\n",
-    "\n",
-    "- `__init__` defines the layer object; \n",
-    "- `build` creates the necessary variables or sub-layers; \n",
-    "- `call` defines how the input tensors are processed.\n",
-    "\n",
-    "The `build()` method is only called once when the layer is used for the first tiem (e.g. in a loop).\n",
-    "See below for an example definition for the `PILayer`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f2fb3334-740f-43b1-b873-b9a3032ab52d",
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "id": "e89da443-220a-4b9a-bbd7-b2a1a566022a",
+      "metadata": {
+        "id": "e89da443-220a-4b9a-bbd7-b2a1a566022a"
+      },
+      "source": [
+        "# Debugging PiNN layers and networks [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Layer_debug.ipynb)"
+      ]
+    },
     {
-     "data": {
-      "text/plain": [
-       "\u001b[0;31mInit signature:\u001b[0m \u001b[0mPILayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-       "\u001b[0;31mSource:\u001b[0m        \n",
-       "\u001b[0;32mclass\u001b[0m \u001b[0mPILayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLayer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0;34m\"\"\"PiNN style interaction layer\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m    Args:\u001b[0m\n",
-       "\u001b[0;34m        n_nodes: number of nodes to use\u001b[0m\n",
-       "\u001b[0;34m            Note that the last element of n_nodes specifies the dimention of\u001b[0m\n",
-       "\u001b[0;34m            the fully connected network before applying the basis function.\u001b[0m\n",
-       "\u001b[0;34m            Dimension of the last node is [pairs*n_nodes[-1]*n_basis], the\u001b[0m\n",
-       "\u001b[0;34m            output is then summed with the basis to form the interaction nodes\u001b[0m\n",
-       "\u001b[0;34m        **kwargs: keyword arguments will be parsed to the feed forward layers\u001b[0m\n",
-       "\u001b[0;34m    \"\"\"\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_nodes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m64\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPILayer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_nodes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mn_nodes\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mbuild\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshapes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_basis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mshapes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mn_nodes_iter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_nodes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mn_nodes_iter\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_basis\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mff_layer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFFLayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_nodes_iter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m    \u001b[0;32mdef\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mind_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbasis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mind_i\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mind_2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mind_j\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mind_2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mprop_i\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgather\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mind_i\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0mprop_j\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgather\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mind_j\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0minter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mprop_i\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop_j\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0minter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mff_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0minter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minter\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m            \u001b[0;34m[\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_nodes\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_basis\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0minter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minter\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mbasis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\n",
-       "\u001b[0;34m\u001b[0m        \u001b[0;32mreturn\u001b[0m \u001b[0minter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-       "\u001b[0;31mFile:\u001b[0m           ~/code/PiNN/pinn/networks/pinet.py\n",
-       "\u001b[0;31mType:\u001b[0m           type\n",
-       "\u001b[0;31mSubclasses:\u001b[0m     \n"
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "d7bc1d47-43b2-47c6-b2b0-feb28537474b",
+      "metadata": {
+        "id": "d7bc1d47-43b2-47c6-b2b0-feb28537474b"
+      },
+      "outputs": [],
+      "source": [
+        "# Install konda\n",
+        "!pip -q install konda\n",
+        "\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "# Accept Anaconda Terms of Service\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "# Create the environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "\n",
+        "!konda activate pinn_env\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'ase>=3.25' 'PyYAML~=6.0.1' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "\n",
+        "!wget -nv -nc https://raw.githubusercontent.com/Teoroo-CMC/PiNN_lab/master/resources/qm9_train.{yml,tfr}\n"
       ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "??PILayer"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "245bb8a9-f30f-4842-94c5-273bcb01cb4b",
-   "metadata": {},
-   "source": [
-    "## Using PiNN Networks\n",
-    "\n",
-    "`network` (Keras Models) are defined similarly, but they can be directly used to perform regression task.\n",
-    "\n",
-    "By default, `network`  produces per-atom predictions, this can be changed by the `out_pool` parameter to \n",
-    "get some simple per-structure predictions. In that case, the network object can be used to perform trainig directly.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "70540231-a925-48f5-825d-cc4f62604f5c",
-   "metadata": {},
-   "outputs": [
+    },
+    {
+      "cell_type": "markdown",
+      "id": "ed40d2c3-2f41-4da0-b1e7-b4aac1e33614",
+      "metadata": {
+        "id": "ed40d2c3-2f41-4da0-b1e7-b4aac1e33614"
+      },
+      "source": [
+        "## Loading data\n",
+        "\n",
+        "For the purpose of testing we download a subset of the QM9 dataset used in [PiNN_lab](https://github.com/Teoroo-CMC/PiNN_lab)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "id": "fad78f2f-14b2-4a72-82ba-7615ecd3daa4",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fad78f2f-14b2-4a72-82ba-7615ecd3daa4",
+        "outputId": "4d92f24f-486b-47b4-d07e-ff0e86fd6c9b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting layer_debug.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile layer_debug.py\n",
+        "\n",
+        "import warnings\n",
+        "from pinn.io import load_tfrecord, sparse_batch\n",
+        "index_warning = 'Converting sparse IndexedSlices'\n",
+        "warnings.filterwarnings('ignore', index_warning)\n",
+        "\n",
+        "dataset = load_tfrecord(\"qm9_train.yml\").apply(sparse_batch(10))\n",
+        "for datum in dataset:\n",
+        "    print({k: v.shape for k, v in datum.items()})\n",
+        "    break"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "id": "lnDJHB4QphU5",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lnDJHB4QphU5",
+        "outputId": "c4d92cd3-b090-4ea6-fb41-6f956e357422"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'A': TensorShape([10]), 'B': TensorShape([10]), 'C': TensorShape([10]), 'Cv': TensorShape([10]), 'G': TensorShape([10]), 'H': TensorShape([10]), 'U': TensorShape([10]), 'U0': TensorShape([10]), 'alpha': TensorShape([10]), 'coord': TensorShape([176, 3]), 'elems': TensorShape([176]), 'gap': TensorShape([10]), 'homo': TensorShape([10]), 'lumo': TensorShape([10]), 'mu': TensorShape([10]), 'r2': TensorShape([10]), 'zpve': TensorShape([10]), 'ind_1': TensorShape([176, 1])}\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python layer_debug.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5eed3a0b-fc9b-4b49-933c-8c15c7f7bc52",
+      "metadata": {
+        "id": "5eed3a0b-fc9b-4b49-933c-8c15c7f7bc52"
+      },
+      "source": [
+        "## Using PiNN Layers\n",
+        "\n",
+        "PiNN networks and layers are Keras [Layers](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer)\n",
+        "and [Models](https://www.tensorflow.org/api_docs/python/tf/keras/Model).\n",
+        "\n",
+        "To use them, you create an instance of layer, after that, the layer object can be used as a function. Each layer\n",
+        "is initialized with different parameters and requires different input tensors, see their individual documentation\n",
+        "for the details."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "id": "3ad6ea7b-4845-4812-9a27-6ab1c68fd23f",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3ad6ea7b-4845-4812-9a27-6ab1c68fd23f",
+        "outputId": "6738ab48-2c09-4e30-8291-fa8f754049c7"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to layer_debug.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a layer_debug.py\n",
+        "\n",
+        "from pinn.layers import CellListNL\n",
+        "\n",
+        "nl = CellListNL(rc=5)\n",
+        "\n",
+        "for datum in dataset:\n",
+        "    nl(datum)\n",
+        "    break"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "0-QxsBr0plmg",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0-QxsBr0plmg",
+        "outputId": "bf2e4814-91b6-4f5a-91b1-16cdb4463ae3"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'A': TensorShape([10]), 'B': TensorShape([10]), 'C': TensorShape([10]), 'Cv': TensorShape([10]), 'G': TensorShape([10]), 'H': TensorShape([10]), 'U': TensorShape([10]), 'U0': TensorShape([10]), 'alpha': TensorShape([10]), 'coord': TensorShape([176, 3]), 'elems': TensorShape([176]), 'gap': TensorShape([10]), 'homo': TensorShape([10]), 'lumo': TensorShape([10]), 'mu': TensorShape([10]), 'r2': TensorShape([10]), 'zpve': TensorShape([10]), 'ind_1': TensorShape([176, 1])}\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python layer_debug.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "51155051-78bc-44f6-b860-c8bf48d46c43",
+      "metadata": {
+        "id": "51155051-78bc-44f6-b860-c8bf48d46c43"
+      },
+      "source": [
+        "The definition of a layer needs three parts:\n",
+        "\n",
+        "- `__init__` defines the layer object;\n",
+        "- `build` creates the necessary variables or sub-layers;\n",
+        "- `call` defines how the input tensors are processed.\n",
+        "\n",
+        "The `build()` method is only called once when the layer is used for the first tiem (e.g. in a loop).\n",
+        "See below for an example definition for the `PILayer`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "id": "5Yh2dbEdIcgG",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5Yh2dbEdIcgG",
+        "outputId": "0dfa4774-7528-4e3c-8365-83af24d14ee6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting check_PILayer.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile check_PILayer.py\n",
+        "\n",
+        "from pinn.networks.pinet import PILayer\n",
+        "import inspect\n",
+        "\n",
+        "print(inspect.getsource(PILayer))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "id": "f2fb3334-740f-43b1-b873-b9a3032ab52d",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "f2fb3334-740f-43b1-b873-b9a3032ab52d",
+        "outputId": "bd80633b-5022-45ab-c6d1-088bd26f7d42"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "2026-09-12 19:20:32.087148: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-09-12 19:20:32.138910: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+            "2026-09-12 19:20:32.138997: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+            "2026-09-12 19:20:32.140461: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+            "2026-09-12 19:20:32.148916: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-09-12 19:20:32.149214: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+            "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+            "2026-09-12 19:20:33.232936: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+            "class PILayer(tf.keras.layers.Layer):\n",
+            "    R\"\"\"`PILayer` takes the properties ($\\mathbb{P}_{i\\alpha},\n",
+            "    \\mathbb{P}_{j\\alpha}$) of a pair of atoms as input and outputs a set of\n",
+            "    interactions for each pair. The inputs will be broadcasted and concatenated\n",
+            "    as the input of a feed-forward neural network (`FFLayer`), and the\n",
+            "    interactions are generated by taking the output of the `FFLayer` as weights\n",
+            "    of radial basis functions, i.e.:\n",
+            "\n",
+            "    $$\n",
+            "    \\begin{aligned}\n",
+            "    w_{ij(b\\beta)} &= \\mathrm{FFLayer}\\left((\\mathbf{1}_{j}\\mathbb{P}_{i\\alpha})\\Vert(\\mathbf{1}_{i}\\mathbb{P}_{j\\alpha})\\right) \\\\\n",
+            "    \\mathbb{I}'_{ij\\beta} &= \\sum_b W_{ij(b\\beta)} \\, e_{ijb}\n",
+            "    \\end{aligned}\n",
+            "    $$\n",
+            "\n",
+            "    , where $w_{ij(b\\beta)}$ is an intemediate weight tensor for the\n",
+            "    radial basis functions, output by the `FFLayer`; the output channel is\n",
+            "    reshaped into two dimensions, where $b$ is the index for the basis function\n",
+            "    and $d$ is the index for output interaction.\n",
+            "\n",
+            "\n",
+            "    `n_nodes` specifies the number of nodes in the `FFLayer`. Note that the last\n",
+            "    element of n_nodes specifies the number of output channels after applying\n",
+            "    the basis function ($d$ instead of $bd$), i.e. the output dimension of\n",
+            "    FFLayer is `[n_pairs,n_nodes[-1]*n_basis]`, the output is then summed with\n",
+            "    the basis to form the output interaction.\n",
+            "\n",
+            "    \"\"\"\n",
+            "\n",
+            "    def __init__(self, n_nodes=[64], **kwargs):\n",
+            "        \"\"\"\n",
+            "        Args:\n",
+            "            n_nodes (list of int): number of nodes to use\n",
+            "            **kwargs (dict): keyword arguments will be parsed to the feed forward layers\n",
+            "        \"\"\"\n",
+            "        super(PILayer, self).__init__()\n",
+            "        self.n_nodes = n_nodes\n",
+            "        self.kwargs = kwargs\n",
+            "\n",
+            "    def build(self, shapes):\n",
+            "        \"\"\"\"\"\"\n",
+            "        self.n_basis = shapes[2][-1]\n",
+            "        n_nodes_iter = self.n_nodes.copy()\n",
+            "        n_nodes_iter[-1] *= self.n_basis\n",
+            "        self.ff_layer = FFLayer(n_nodes_iter, **self.kwargs)\n",
+            "\n",
+            "    def call(self, tensors):\n",
+            "        \"\"\"\n",
+            "        PILayer take a list of three tensors as input:\n",
+            "\n",
+            "        - ind_2: [sparse indices](layers.md#sparse-indices) of pairs with shape `(n_pairs, 2)`\n",
+            "        - prop: property tensor with shape `(n_atoms, n_prop)`\n",
+            "        - basis: interaction tensor with shape `(n_pairs, n_basis)`\n",
+            "\n",
+            "        Args:\n",
+            "            tensors (list of tensors): list of `[ind_2, prop, basis]` tensors\n",
+            "\n",
+            "        Returns:\n",
+            "            inter (tensor): interaction tensor with shape `(n_pairs, n_nodes[-1])`\n",
+            "        \"\"\"\n",
+            "        ind_2, prop, basis = tensors\n",
+            "        ind_i = ind_2[:, 0]\n",
+            "        ind_j = ind_2[:, 1]\n",
+            "        prop_i = tf.gather(prop, ind_i)\n",
+            "        prop_j = tf.gather(prop, ind_j)\n",
+            "\n",
+            "        inter = tf.concat([prop_i, prop_j], axis=-1)\n",
+            "        inter = self.ff_layer(inter)\n",
+            "        inter = tf.reshape(inter, [-1, self.n_nodes[-1], self.n_basis])\n",
+            "        inter = tf.einsum(\"pcb,pb->pc\", inter, basis)\n",
+            "        return inter\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python check_PILayer.py\""
+      ]
+    },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/3\n"
-     ]
+      "cell_type": "markdown",
+      "id": "245bb8a9-f30f-4842-94c5-273bcb01cb4b",
+      "metadata": {
+        "id": "245bb8a9-f30f-4842-94c5-273bcb01cb4b"
+      },
+      "source": [
+        "## Using PiNN Networks\n",
+        "\n",
+        "`network` (Keras Models) are defined similarly, but they can be directly used to perform regression task.\n",
+        "\n",
+        "By default, `network`  produces per-atom predictions, this can be changed by the `out_pool` parameter to\n",
+        "get some simple per-structure predictions. In that case, the network object can be used to perform trainig directly.\n",
+        "\n"
+      ]
     },
     {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/yunqi/.miniconda/envs/pinn-tf2/lib/python3.9/site-packages/tensorflow/python/framework/indexed_slices.py:444: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor(\"Adam/gradients/concat_1:0\", shape=(None,), dtype=int32), values=Tensor(\"Adam/gradients/concat:0\", shape=(None, 16), dtype=float32), dense_shape=Tensor(\"gradient_tape/pi_net_1/gc_block_7/pi_layer_7/Cast:0\", shape=(2,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
-      "  warnings.warn(\n",
-      "/home/yunqi/.miniconda/envs/pinn-tf2/lib/python3.9/site-packages/tensorflow/python/framework/indexed_slices.py:444: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor(\"Adam/gradients/concat_3:0\", shape=(None,), dtype=int32), values=Tensor(\"Adam/gradients/concat_2:0\", shape=(None, 16), dtype=float32), dense_shape=Tensor(\"gradient_tape/pi_net_1/gc_block_6/pi_layer_6/Cast:0\", shape=(2,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
-      "  warnings.warn(\n",
-      "/home/yunqi/.miniconda/envs/pinn-tf2/lib/python3.9/site-packages/tensorflow/python/framework/indexed_slices.py:444: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor(\"Adam/gradients/concat_5:0\", shape=(None,), dtype=int32), values=Tensor(\"Adam/gradients/concat_4:0\", shape=(None, 16), dtype=float32), dense_shape=Tensor(\"gradient_tape/pi_net_1/gc_block_5/pi_layer_5/Cast:0\", shape=(2,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
-      "  warnings.warn(\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 21,
+      "id": "70540231-a925-48f5-825d-cc4f62604f5c",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "70540231-a925-48f5-825d-cc4f62604f5c",
+        "outputId": "844b500d-fd6e-40d3-cbf5-bfa0d6260a40"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to layer_debug.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a layer_debug.py\n",
+        "\n",
+        "from pinn.networks.pinet import PiNet\n",
+        "\n",
+        "def label_data(data):\n",
+        "    # defines the label to train on\n",
+        "    x = data\n",
+        "    y = data['lumo']\n",
+        "    return x, y\n",
+        "\n",
+        "train = dataset.map(label_data)\n",
+        "pinet = PiNet(out_pool='min')\n",
+        "pinet.compile(optimizer='Adam', loss='MAE')\n",
+        "pinet.fit(train, epochs=3)"
+      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2000/2000 [==============================] - 37s 17ms/step - loss: 0.0551\n",
-      "Epoch 2/3\n",
-      "2000/2000 [==============================] - 35s 18ms/step - loss: 0.0285\n",
-      "Epoch 3/3\n",
-      "2000/2000 [==============================] - 35s 17ms/step - loss: 0.0240\n"
-     ]
+      "cell_type": "code",
+      "execution_count": 23,
+      "id": "HgBkNKtfrysD",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HgBkNKtfrysD",
+        "outputId": "fe131737-783f-465b-adb1-1f841248f538"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "{'A': TensorShape([10]), 'B': TensorShape([10]), 'C': TensorShape([10]), 'Cv': TensorShape([10]), 'G': TensorShape([10]), 'H': TensorShape([10]), 'U': TensorShape([10]), 'U0': TensorShape([10]), 'alpha': TensorShape([10]), 'coord': TensorShape([176, 3]), 'elems': TensorShape([176]), 'gap': TensorShape([10]), 'homo': TensorShape([10]), 'lumo': TensorShape([10]), 'mu': TensorShape([10]), 'r2': TensorShape([10]), 'zpve': TensorShape([10]), 'ind_1': TensorShape([176, 1])}\n",
+            "Epoch 1/3\n",
+            "2000/2000 [==============================] - 62s 27ms/step - loss: 0.0890\n",
+            "Epoch 2/3 \n",
+            "2000/2000 [==============================] - 59s 29ms/step - loss: 0.0296 \n",
+            "Epoch 3/3 \n",
+            "2000/2000 [==============================] - 54s 27ms/step - loss: 0.0248\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python layer_debug.py\""
+      ]
     },
     {
-     "data": {
-      "text/plain": [
-       "<keras.callbacks.History at 0x7f17c86591f0>"
+      "cell_type": "markdown",
+      "id": "edbf453d-cca7-4982-9e35-cc811e6007fd",
+      "metadata": {
+        "id": "edbf453d-cca7-4982-9e35-cc811e6007fd"
+      },
+      "source": [
+        "## Further benchmarks\n",
+        "\n",
+        "For more advanced usage you are recommended to use the `Model` API to define the trainig loss, derived predicates.\n",
+        "For traininig potential energy surfaces, you are recommended to use `pinn.models.potential_model` in combination with the command line interface (CLI).\n",
+        "\n",
+        "Alternatively, see the [Trainig Tips](More_on_training.ipynb) notebook to see how to run the tranining interactively in a notebook."
       ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
     }
-   ],
-   "source": [
-    "def label_data(data):\n",
-    "    # defines the label to train on\n",
-    "    x = data\n",
-    "    y = data['lumo']\n",
-    "    return x, y\n",
-    "\n",
-    "train = dataset.map(label_data)\n",
-    "pinet = PiNet(out_pool='min')\n",
-    "pinet.compile(optimizer='Adam', loss='MAE')\n",
-    "pinet.fit(train, epochs=3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "edbf453d-cca7-4982-9e35-cc811e6007fd",
-   "metadata": {},
-   "source": [
-    "## Further benchmarks\n",
-    "\n",
-    "For more advanced usage you are recommended to use the `Model` API to define the trainig loss, derived predicates.\n",
-    "For traininig potential energy surfaces, you are recommended to use `pinn.models.potential_model` in combination with the command line interface (CLI).\n",
-    "\n",
-    "Alternatively, see the [Trainig Tips](More_on_training.ipynb) notebook to see how to run the tranining interactively in a notebook."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "work",
-   "language": "python",
-   "name": "python3"
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "work",
+      "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.10.14"
+    }
   },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.14"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+  "nbformat": 4,
+  "nbformat_minor": 5
 }
diff --git a/docs/notebooks/Learn_LJ_potential.ipynb b/docs/notebooks/Learn_LJ_potential.ipynb
index adb0ea8e..dac99a0e 100644
--- a/docs/notebooks/Learn_LJ_potential.ipynb
+++ b/docs/notebooks/Learn_LJ_potential.ipynb
@@ -1,342 +1,791 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Learning a LJ potential [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Learn_LJ_potential.ipynb)\n",
-    "\n",
-    "\n",
-    "This notebook showcases the usage of PiNN with a toy problem of learning a Lennard-Jones\n",
-    "potential with a hand-generated dataset.  \n",
-    "It serves as a basic test, and demonstration of the workflow with PiNN."
-   ]
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "d9dfIuTBkcNj"
+      },
+      "source": [
+        "# Learning a LJ potential [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Learn_LJ_potential.ipynb)\n",
+        "\n",
+        "\n",
+        "This notebook showcases the usage of PiNN with a toy problem of learning a Lennard-Jones\n",
+        "potential with a hand-generated dataset.  \n",
+        "It serves as a basic test, and demonstration of the workflow with PiNN."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1IY3HQ3RmuWp"
+      },
+      "outputs": [],
+      "source": [
+        "# Install konda\n",
+        "!pip -q install konda\n",
+        "\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "# Accept Anaconda Terms of Service\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "# Create the environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "\n",
+        "!konda activate pinn_env\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'ase>=3.25' 'PyYAML~=6.0.1' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "\n",
+        "#Install ase to runtime\n",
+        "import sys\n",
+        "!{sys.executable} -m pip -q install ase\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "gb7afxRTkcNp"
+      },
+      "outputs": [],
+      "source": [
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "E_gdKEm4kcNq"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "from ase import Atoms\n",
+        "from ase.calculators.lj import LennardJones"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "C5cj1UpVkcNq"
+      },
+      "source": [
+        "## Reference data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jhEdl_nWkcNq"
+      },
+      "outputs": [],
+      "source": [
+        "# Helper function: get the position given PES dimension(s)\n",
+        "def three_body_sample(atoms, a, r):\n",
+        "    x = a * np.pi / 180\n",
+        "    pos = [[0, 0, 0],\n",
+        "           [0, 2, 0],\n",
+        "           [0, r*np.cos(x), r*np.sin(x)]]\n",
+        "    atoms.set_positions(pos)\n",
+        "    return atoms"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ZQ8pis2wkcNr"
+      },
+      "outputs": [],
+      "source": [
+        "atoms = Atoms('H3', calculator=LennardJones())\n",
+        "\n",
+        "na, nr = 50, 50\n",
+        "arange = np.linspace(30,180,na)\n",
+        "rrange = np.linspace(1,3,nr)\n",
+        "\n",
+        "# Truth\n",
+        "agrid, rgrid = np.meshgrid(arange, rrange)\n",
+        "egrid = np.zeros([na, nr])\n",
+        "for i in range(na):\n",
+        "    for j in range(nr):\n",
+        "        atoms = three_body_sample(atoms, arange[i], rrange[j])\n",
+        "        egrid[i,j] = atoms.get_potential_energy()\n",
+        "\n",
+        "# Samples\n",
+        "nsample = 100\n",
+        "asample, rsample = [], []\n",
+        "distsample = []\n",
+        "data = {'e_data':[], 'f_data':[], 'elems':[], 'coord':[]}\n",
+        "for i in range(nsample):\n",
+        "    a, r = np.random.choice(arange), np.random.choice(rrange)\n",
+        "    atoms = three_body_sample(atoms, a, r)\n",
+        "    dist = atoms.get_all_distances()\n",
+        "    dist = dist[np.nonzero(dist)]\n",
+        "    data['e_data'].append(atoms.get_potential_energy())\n",
+        "    data['f_data'].append(atoms.get_forces())\n",
+        "    data['coord'].append(atoms.get_positions())\n",
+        "    data['elems'].append(atoms.numbers)\n",
+        "    asample.append(a)\n",
+        "    rsample.append(r)\n",
+        "    distsample.append(dist)\n",
+        "\n",
+        "\n",
+        "#save data\n",
+        "! rm -rf \"training_data\" \"validation_data\"\n",
+        "! mkdir \"training_data\" \"validation_data\"\n",
+        "! mkdir \"validation_data/PES_analysis\" \"validation_data/pairwise_potential_analysis\"\n",
+        "np.savez_compressed(\"training_data/data.npz\", **data)\n",
+        "np.save(\"training_data/na_nr.npy\", [na, nr])\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 449
+        },
+        "id": "mrEAUBI_kcNr",
+        "outputId": "bad453f6-e036-4b17-d29d-2b57261e0f53"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "<matplotlib.colorbar.Colorbar at 0x793a24c0cad0>"
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plt.pcolormesh(agrid, rgrid, egrid, shading='auto')\n",
+        "plt.plot(asample, rsample, 'rx')\n",
+        "plt.colorbar()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "La1U8jpzkcNs"
+      },
+      "source": [
+        "## Dataset from numpy arrays"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KnO4jqXSkcNs",
+        "outputId": "e6725c50-27e1-4c70-97dc-0a70f3bb60cc"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing train.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile train.py\n",
+        "\n",
+        "import numpy as np\n",
+        "from pinn.io import sparse_batch, load_numpy\n",
+        "\n",
+        "data = np.load(\"training_data/data.npz\")\n",
+        "\n",
+        "\n",
+        "data = {k:np.array(v) for k,v in data.items()}\n",
+        "dataset = lambda: load_numpy(data, splits={'train':8, 'test':2})\n",
+        "\n",
+        "train = lambda: dataset()['train'].shuffle(100).repeat().apply(sparse_batch(100))\n",
+        "test = lambda: dataset()['test'].repeat().apply(sparse_batch(100))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "7BRmC-mGkcNt"
+      },
+      "source": [
+        "## Training"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "15d_D3LykcNt"
+      },
+      "source": [
+        "### Model specification"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "rnPeG0FzkcNt",
+        "outputId": "461f777b-90e0-422c-87c1-9f166409bab6"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing model_specification.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile model_specification.py\n",
+        "\n",
+        "import pinn\n",
+        "import numpy as np\n",
+        "import os, warnings\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "import tensorflow as tf\n",
+        "from ase import Atoms\n",
+        "from ase.calculators.lj import LennardJones\n",
+        "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'\n",
+        "index_warning = 'Converting sparse IndexedSlices'\n",
+        "warnings.filterwarnings('ignore', index_warning)\n",
+        "\n",
+        "# specify the grid\n",
+        "na, nr = np.load(\"training_data/na_nr.npy\")\n",
+        "arange = np.linspace(30,180,na)\n",
+        "rrange = np.linspace(1,3,nr)\n",
+        "agrid, rgrid = np.meshgrid(arange, rrange)\n",
+        "\n",
+        "\n",
+        "params={\n",
+        "    'model_dir': '/tmp/PiNet',\n",
+        "    'network': {\n",
+        "        'name': 'PiNet',\n",
+        "        'params': {\n",
+        "            'ii_nodes':[8,8],\n",
+        "            'pi_nodes':[8,8],\n",
+        "            'pp_nodes':[8,8],\n",
+        "            'out_nodes':[8,8],\n",
+        "            'depth': 4,\n",
+        "            'rc': 3.0,\n",
+        "            'atom_types':[1]}},\n",
+        "    'model':{\n",
+        "        'name': 'potential_model',\n",
+        "        'params': {\n",
+        "            'e_dress': {1:-0.3},  # element-specific energy dress\n",
+        "            'e_scale': 2, # energy scale for prediction\n",
+        "            'e_unit': 1.0,  # output unit of energy dur\n",
+        "            'log_e_per_atom': True, # log e_per_atom and its distribution\n",
+        "            'use_force': True}}}      # include force in Loss function\n",
+        "model = pinn.get_model(params)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "T5E0Y7_7lTg7"
+      },
+      "outputs": [],
+      "source": [
+        "#add the model to train.py\n",
+        "!cat model_specification.py >> train.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D_KLVARCkcNt",
+        "outputId": "930f122b-cd51-4cb7-bf68-de319ea1f630"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to train.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a train.py\n",
+        "\n",
+        "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=5e3)\n",
+        "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=10)\n",
+        "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)\n",
+        "\n",
+        "print(\"Training done.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SbWRwGFzsCVR",
+        "outputId": "1b6502aa-8e74-482a-83aa-ffa7bdd2b255"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "3144 trainable vaiables, training with float32 precision.\n",
+            "Training done.\n"
+          ]
+        }
+      ],
+      "source": [
+        "%rm -rf /tmp/PiNet #removes previously trained directory to rewrite it\n",
+        "!konda run \"python train.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "cs_cCHYUkcNu"
+      },
+      "source": [
+        "## Validate the results\n",
+        "### PES analysis"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xFTib5Ikh4Pm",
+        "outputId": "2c9c456b-77e5-458f-b9e0-7b3f8ed63b1b"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing PES_analysis.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile PES_analysis.py\n",
+        "\n",
+        "def three_body_sample(atoms, a, r):\n",
+        "    x = a * np.pi / 180\n",
+        "    pos = [[0, 0, 0],\n",
+        "           [0, 2, 0],\n",
+        "           [0, r*np.cos(x), r*np.sin(x)]]\n",
+        "    atoms.set_positions(pos)\n",
+        "    return atoms"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xaNyqFqBh99g"
+      },
+      "outputs": [],
+      "source": [
+        "#add the model\n",
+        "!cat model_specification.py >> PES_analysis.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "A_u6HvcVkcNu",
+        "outputId": "495a151f-3007-4703-cc2c-2888bbeaf4af"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to PES_analysis.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a PES_analysis.py\n",
+        "\n",
+        "atoms = Atoms('H3', calculator=pinn.get_calc(model))\n",
+        "epred = np.zeros([na, nr])\n",
+        "for i in range(na):\n",
+        "    for j in range(nr):\n",
+        "        a, r = arange[i], rrange[j]\n",
+        "        atoms = three_body_sample(atoms, a, r)\n",
+        "        epred[i,j] = atoms.get_potential_energy()\n",
+        "np.save(\"validation_data/PES_analysis/epred.npy\", epred)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "IC75qnKIkcNu",
+        "outputId": "cffb4c60-efe4-4d7e-90af-255d48b5b51c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "2026-09-12 18:38:00.152226: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-09-12 18:38:00.201801: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+            "2026-09-12 18:38:00.201887: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+            "2026-09-12 18:38:00.203291: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+            "2026-09-12 18:38:00.211288: I external/local_tsl/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n",
+            "2026-09-12 18:38:00.211583: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+            "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+            "2026-09-12 18:38:01.229346: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+            "2026-09-12 18:38:04.770784: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:388] MLIR V1 optimization pass is not enabled\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "<matplotlib.colorbar.Colorbar at 0x793a229ff890>"
+            ]
+          },
+          "execution_count": 15,
+          "metadata": {},
+          "output_type": "execute_result"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "!konda run \"python PES_analysis.py\"\n",
+        "\n",
+        "import numpy as np\n",
+        "epred = np.load(\"validation_data/PES_analysis/epred.npy\")\n",
+        "\n",
+        "plt.pcolormesh(agrid, rgrid, epred, shading='auto')\n",
+        "plt.colorbar()\n",
+        "plt.title('NN predicted PES')\n",
+        "plt.figure()\n",
+        "plt.pcolormesh(agrid, rgrid, np.abs(egrid-epred), shading='auto')\n",
+        "plt.plot(asample, rsample, 'rx')\n",
+        "plt.title('NN Prediction error and sampled points')\n",
+        "plt.colorbar()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KZtEzcr7kcNu"
+      },
+      "source": [
+        "### Pairwise potential analysis"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "izBF9hpXkcNu",
+        "outputId": "ae2a53c8-79aa-461f-af6a-de6f2f2fc11a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing pairwise_potential_analysis.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile pairwise_potential_analysis.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "k4C50pspiKT0"
+      },
+      "outputs": [],
+      "source": [
+        "#add the model\n",
+        "!cat model_specification.py >> pairwise_potential_analysis.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dbJZJ8GHiY0v",
+        "outputId": "7743d503-9881-42c0-edc9-d223abc5e8fa"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to pairwise_potential_analysis.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a pairwise_potential_analysis.py\n",
+        "\n",
+        "atoms1 = Atoms('H2', calculator=pinn.get_calc(model))\n",
+        "atoms2 = Atoms('H2', calculator=LennardJones())\n",
+        "\n",
+        "nr2 = 100\n",
+        "rrange2 = np.linspace(1,1.9,nr2)\n",
+        "epred = np.zeros(nr2)\n",
+        "etrue = np.zeros(nr2)\n",
+        "\n",
+        "for i in range(nr2):\n",
+        "    pos = [[0, 0, 0],\n",
+        "           [rrange2[i], 0, 0]]\n",
+        "    atoms1.set_positions(pos)\n",
+        "    atoms2.set_positions(pos)\n",
+        "    epred[i] = atoms1.get_potential_energy()\n",
+        "    etrue[i] = atoms2.get_potential_energy()\n",
+        "\n",
+        "#save data\n",
+        "np.save(\"validation_data/pairwise_potential_analysis/epred.npy\", epred)\n",
+        "np.save(\"validation_data/pairwise_potential_analysis/etrue.npy\", epred)\n",
+        "np.save(\"validation_data/pairwise_potential_analysis/nr2.npy\", nr2)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zmsLCHM6i1ln"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python pairwise_potential_analysis.py\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 430
+        },
+        "id": "vHi11SqlkcNv",
+        "outputId": "ccdfc885-e5e8-420f-d4e6-b0136b2b27fa"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "nr2 = np.load(\"validation_data/pairwise_potential_analysis/nr2.npy\")\n",
+        "epred = np.load(\"validation_data/pairwise_potential_analysis/epred.npy\")\n",
+        "epred = np.load(\"validation_data/pairwise_potential_analysis/epred.npy\")\n",
+        "etrue = np.load(\"validation_data/pairwise_potential_analysis/etrue.npy\")\n",
+        "\n",
+        "rrange2 = np.linspace(1,1.9,nr2)\n",
+        "\n",
+        "f, (ax1, ax2) = plt.subplots(2,1, gridspec_kw = {'height_ratios':[3, 1]})\n",
+        "ax1.plot(rrange2, epred)\n",
+        "ax1.plot(rrange2, etrue,'--')\n",
+        "ax1.legend(['Prediction', 'Truth'], loc=4)\n",
+        "_=ax2.hist(np.concatenate(distsample,0), 20, range=(1,1.9))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "vLJehH2DkcNv"
+      },
+      "source": [
+        "## Molecular dynamics with ASE"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OQkDqMD6kcNv",
+        "outputId": "9dca9418-23cb-40ad-b29a-d275e2827e5a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Writing MD.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile MD.py\n",
+        "\n",
+        "from ase import units\n",
+        "from ase.io import Trajectory\n",
+        "from ase.md.nvtberendsen import NVTBerendsen\n",
+        "from ase.md.velocitydistribution import thermalize_momenta"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Jwbw_UKViSVw"
+      },
+      "outputs": [],
+      "source": [
+        "#add the model\n",
+        "!cat model_specification.py >> MD.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KXmf-0FNkcNv",
+        "outputId": "66c83503-9333-4db7-c92d-5871c639a830"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to MD.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a MD.py\n",
+        "\n",
+        "atoms = Atoms('H', cell=[2, 2, 2], pbc=True)\n",
+        "atoms = atoms.repeat([5,5,5])\n",
+        "atoms.rattle()\n",
+        "atoms.calc = pinn.get_calc(model)\n",
+        "thermalize_momenta(atoms, temperature_K=300)\n",
+        "dyn = NVTBerendsen(atoms, 0.5 * units.fs, 300, taut=0.5*100*units.fs)\n",
+        "dyn.attach(Trajectory('ase_nvt.traj', 'w', atoms).write, interval=10)\n",
+        "dyn.run(5000)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2Wcu29mynUmQ"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python MD.py\""
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "pinn-tf2",
+      "language": "python",
+      "name": "pinn-tf2"
+    },
+    "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.9.5"
+    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install PiNN\n",
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, warnings\n",
-    "import numpy as np\n",
-    "import tensorflow as tf\n",
-    "import matplotlib.pyplot as plt\n",
-    "from ase import Atoms\n",
-    "from ase.calculators.lj import LennardJones\n",
-    "os.environ['CUDA_VISIBLE_DEVICES'] = ''\n",
-    "index_warning = 'Converting sparse IndexedSlices'\n",
-    "warnings.filterwarnings('ignore', index_warning)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Reference data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Helper function: get the position given PES dimension(s)\n",
-    "def three_body_sample(atoms, a, r):\n",
-    "    x = a * np.pi / 180\n",
-    "    pos = [[0, 0, 0],\n",
-    "           [0, 2, 0],\n",
-    "           [0, r*np.cos(x), r*np.sin(x)]]\n",
-    "    atoms.set_positions(pos)\n",
-    "    return atoms"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "atoms = Atoms('H3', calculator=LennardJones())\n",
-    "\n",
-    "na, nr = 50, 50\n",
-    "arange = np.linspace(30,180,na)\n",
-    "rrange = np.linspace(1,3,nr)\n",
-    "\n",
-    "# Truth\n",
-    "agrid, rgrid = np.meshgrid(arange, rrange)\n",
-    "egrid = np.zeros([na, nr])\n",
-    "for i in range(na):\n",
-    "    for j in range(nr):\n",
-    "        atoms = three_body_sample(atoms, arange[i], rrange[j])\n",
-    "        egrid[i,j] = atoms.get_potential_energy()\n",
-    "        \n",
-    "# Samples\n",
-    "nsample = 100\n",
-    "asample, rsample = [], []\n",
-    "distsample = []\n",
-    "data = {'e_data':[], 'f_data':[], 'elems':[], 'coord':[]}\n",
-    "for i in range(nsample):\n",
-    "    a, r = np.random.choice(arange), np.random.choice(rrange)\n",
-    "    atoms = three_body_sample(atoms, a, r)\n",
-    "    dist = atoms.get_all_distances()\n",
-    "    dist = dist[np.nonzero(dist)]\n",
-    "    data['e_data'].append(atoms.get_potential_energy())\n",
-    "    data['f_data'].append(atoms.get_forces())\n",
-    "    data['coord'].append(atoms.get_positions())\n",
-    "    data['elems'].append(atoms.numbers)\n",
-    "    asample.append(a)\n",
-    "    rsample.append(r)\n",
-    "    distsample.append(dist)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.pcolormesh(agrid, rgrid, egrid, shading='auto')\n",
-    "plt.plot(asample, rsample, 'rx')\n",
-    "plt.colorbar()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Dataset from numpy arrays"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pinn.io import sparse_batch, load_numpy\n",
-    "data = {k:np.array(v) for k,v in data.items()}\n",
-    "dataset = lambda: load_numpy(data, splits={'train':8, 'test':2})\n",
-    "\n",
-    "train = lambda: dataset()['train'].shuffle(100).repeat().apply(sparse_batch(100))\n",
-    "test = lambda: dataset()['test'].repeat().apply(sparse_batch(100))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Training"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Model specification"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pinn\n",
-    "\n",
-    "params={\n",
-    "    'model_dir': '/tmp/PiNet',\n",
-    "    'network': {\n",
-    "        'name': 'PiNet',\n",
-    "        'params': {\n",
-    "            'ii_nodes':[8,8],\n",
-    "            'pi_nodes':[8,8],\n",
-    "            'pp_nodes':[8,8],\n",
-    "            'out_nodes':[8,8],\n",
-    "            'depth': 4,\n",
-    "            'rc': 3.0,\n",
-    "            'atom_types':[1]}},\n",
-    "    'model':{\n",
-    "        'name': 'potential_model',\n",
-    "        'params': {\n",
-    "            'e_dress': {1:-0.3},  # element-specific energy dress\n",
-    "            'e_scale': 2, # energy scale for prediction\n",
-    "            'e_unit': 1.0,  # output unit of energy dur\n",
-    "            'log_e_per_atom': True, # log e_per_atom and its distribution    \n",
-    "            'use_force': True}}}      # include force in Loss function\n",
-    "model = pinn.get_model(params)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%rm -rf /tmp/PiNet\n",
-    "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=5e3)\n",
-    "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=10)\n",
-    "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Validate the results\n",
-    "### PES analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "atoms = Atoms('H3', calculator=pinn.get_calc(model))\n",
-    "epred = np.zeros([na, nr])\n",
-    "for i in range(na):\n",
-    "    for j in range(nr):\n",
-    "        a, r = arange[i], rrange[j]\n",
-    "        atoms = three_body_sample(atoms, a, r)\n",
-    "        epred[i,j] = atoms.get_potential_energy()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.pcolormesh(agrid, rgrid, epred, shading='auto')\n",
-    "plt.colorbar()\n",
-    "plt.title('NN predicted PES')\n",
-    "plt.figure()\n",
-    "plt.pcolormesh(agrid, rgrid, np.abs(egrid-epred), shading='auto')\n",
-    "plt.plot(asample, rsample, 'rx')\n",
-    "plt.title('NN Prediction error and sampled points')\n",
-    "plt.colorbar()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Pairwise potential analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "atoms1 = Atoms('H2', calculator=pinn.get_calc(model))\n",
-    "atoms2 = Atoms('H2', calculator=LennardJones())\n",
-    "\n",
-    "nr2 = 100\n",
-    "rrange2 = np.linspace(1,1.9,nr2)\n",
-    "epred = np.zeros(nr2)\n",
-    "etrue = np.zeros(nr2)\n",
-    "\n",
-    "for i in range(nr2):\n",
-    "    pos = [[0, 0, 0],\n",
-    "           [rrange2[i], 0, 0]]\n",
-    "    atoms1.set_positions(pos)\n",
-    "    atoms2.set_positions(pos)\n",
-    "    epred[i] = atoms1.get_potential_energy()\n",
-    "    etrue[i] = atoms2.get_potential_energy()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "f, (ax1, ax2) = plt.subplots(2,1, gridspec_kw = {'height_ratios':[3, 1]})\n",
-    "ax1.plot(rrange2, epred)\n",
-    "ax1.plot(rrange2, etrue,'--')\n",
-    "ax1.legend(['Prediction', 'Truth'], loc=4)\n",
-    "_=ax2.hist(np.concatenate(distsample,0), 20, range=(1,1.9))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Molecular dynamics with ASE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ase import units\n",
-    "from ase.io import Trajectory\n",
-    "from ase.md.nvtberendsen import NVTBerendsen\n",
-    "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "atoms = Atoms('H', cell=[2, 2, 2], pbc=True)\n",
-    "atoms = atoms.repeat([5,5,5])\n",
-    "atoms.rattle()\n",
-    "atoms.set_calculator(pinn.get_calc(model))\n",
-    "MaxwellBoltzmannDistribution(atoms, 300*units.kB)\n",
-    "dyn = NVTBerendsen(atoms, 0.5 * units.fs, 300, taut=0.5*100*units.fs)\n",
-    "dyn.attach(Trajectory('ase_nvt.traj', 'w', atoms).write, interval=10)\n",
-    "dyn.run(5000)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pinn-tf2",
-   "language": "python",
-   "name": "pinn-tf2"
-  },
-  "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.9.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 0
 }
diff --git a/docs/notebooks/MLP_water/water.xyz b/docs/notebooks/MLP_water/water.xyz
new file mode 100644
index 00000000..e7bd7a4d
--- /dev/null
+++ b/docs/notebooks/MLP_water/water.xyz
@@ -0,0 +1,194 @@
+192
+Lattice="12.432003021240234 0.0 0.0 0.0 12.432003021240234 0.0 0.0 0.0 12.432003021240234" Properties=species:S:1:pos:R:3 pbc="T T T"
+O       10.44903278       2.95596385       8.26375866
+O        3.23512220       3.11959124       6.14128160
+O       -4.12888718       2.61511326       2.91831279
+O       10.75346851       3.29655027       0.73800004
+O        8.92942047       5.04083538      11.67552280
+O        5.74841499       1.39852166       3.14593196
+O        5.28177786       7.01481009       3.45862246
+O       10.27121830      14.25977039       5.87590456
+O        0.71280485       8.99637222       8.04725647
+O       -1.28992391       3.48181343       4.21391821
+O       -0.94203860       5.94094563      -1.44746208
+O        0.58751267      10.07202530       1.93828189
+O        1.79377055      13.94991589       7.72474909
+O        2.26838684       4.59146881       1.37901413
+O        0.90043473       2.05142212       3.33107901
+O        3.46901846       4.95683002       3.79997969
+O        3.80396819       4.90742445      10.79390812
+O        9.14426708       6.44543123       1.47640812
+O        0.81955636       6.20830154       7.53417635
+O        2.15709829       7.02335644       5.10862398
+O        6.48216152      16.03470421       0.66774917
+O        1.21041822       2.28719378       0.59881431
+O        4.97775078       5.02283144       7.98100853
+O        3.05307627       7.30494738      11.66791344
+O        8.01422977      13.48729801      11.29067326
+O        8.51163578       4.52716780       4.91437626
+O        1.17842686       4.39052582       9.57700157
+O        4.44431448       2.26045656      11.61760426
+O       10.76963997      13.28803635      12.09229183
+O       -1.08796775      11.88484955       6.27288771
+O        3.21838069       8.87713814       9.27053928
+O       10.61747551       5.52488518       6.87521315
+O       11.65536594      10.78915596      -0.25972572
+O       -1.63567984       8.26203346       9.84853840
+O        3.32469225       1.12344110       4.32860947
+O        6.39286280      14.98829365       7.58326292
+O        1.16100681      11.51938343      -2.03308296
+O        3.11540961      10.95291519       4.69300032
+O       -0.10680204       1.89572072       9.82856750
+O        7.84901571       3.27707052      -2.76810217
+O       -3.27592707      10.64163685       7.64159393
+O        6.71247530       6.83039713       9.58037281
+O        9.36898708      12.62443256       2.72895360
+O        0.48057589       6.70002365       0.80151564
+O        5.19313097       8.45862293      12.98836327
+O        7.40699387      13.10389328       5.60113430
+O        4.14187145       7.42504406       7.15731764
+O        6.88497639      -0.08957171       1.05628693
+O        9.57658863       8.97559738      -0.22595026
+O       -0.41982394      12.28227711       3.39119673
+O       -2.75211310       7.06373787       4.14269114
+O        6.41479731       6.23040533       1.27272987
+O       -0.20199393       7.84152269       3.40618563
+O        5.78877544      10.65154362       5.73965693
+O        6.92500353      -2.35252142      -0.13898252
+O        2.86003184      12.47699833      -0.08059395
+O        3.31767964      10.21421528       1.76183939
+O        6.44796085       7.97193813       6.01077032
+O        9.01145935       9.98324013       4.73689604
+O        1.46136367      11.32011700       6.83774757
+O        4.29832697       1.17882431       8.83221626
+O        5.00434637      10.90569687       8.36165619
+O        8.65159798       7.41297913       7.78261995
+O        7.35625648      11.30803585       9.75170898
+H       10.38230324       3.88289642       7.82432938
+H       10.32908916       2.41658616       7.53330326
+H        2.79627919       3.73593616       5.57347441
+H        2.58712196       2.72698879       6.78172350
+H       -3.89937401       3.11798263       3.70403504
+H       -3.66280580       1.70005000       2.90624928
+H       10.49139309       3.73307848      -0.07221094
+H        9.96558189       3.37892342       1.30059481
+H        8.30688667       4.54485178      11.19752216
+H        9.59718990       5.24937725      10.87355995
+H        6.25082636       2.19407940       3.18697190
+H        4.83847904       1.48821199       3.59057379
+H        5.01526213       7.75345135       2.87877369
+H        5.66065645       7.32455873       4.36214590
+H        9.57915497      13.69963074       5.47530651
+H       10.60555267      14.94972706       5.09235096
+H        0.91994017       7.98871851       7.91178656
+H       -0.14284091       8.90400982       8.49314117
+H       -0.37037462       3.07451224       3.99326229
+H       -1.77513397       3.62174487       3.36122298
+H       -1.04309189       6.84392834      -1.95775461
+H       -0.24115685       5.44265652      -2.01226306
+H        0.23615137       9.29971790       2.46102333
+H       -0.02285795      10.04116917       1.18684661
+H        1.11007094      14.05264473       8.43959332
+H        1.60864317      13.02056408       7.49147701
+H        1.60677624       5.33004761       1.23749840
+H        1.93904710       3.81094742       0.95391548
+H        0.42796057       1.19821441       3.33887267
+H        0.84239084       2.37955809       2.42409301
+H        4.20467663       5.50393534       3.41527367
+H        2.89094210       4.76993561       3.00499463
+H        4.34037352       5.12623072      10.00631237
+H        3.95274997       3.95419669      11.11477470
+H        8.10214806       6.50113249       1.47846663
+H        9.29381752       5.84554005       0.72503048
+H        1.10631323       5.49547338       8.15043545
+H        1.39874399       6.38774061       6.72235489
+H        1.39385593       7.40713167       4.61546898
+H        2.67896438       6.44359493       4.46389484
+H        7.03503513      15.39105034       1.19061112
+H        5.65833330      15.55805874       0.41670585
+H        0.67022729       2.25399280      -0.22185400
+H        1.90013254       1.54894507       0.41700539
+H        4.40085316       5.70809174       7.64964294
+H        4.66339064       4.19865322       7.48571968
+H        3.91274214       7.52881575      12.10451031
+H        3.31824374       6.37868643      11.49818993
+H        7.80346918      12.61891365      10.72381878
+H        7.72109222      14.18387508      10.66428566
+H        8.46362305       5.49398136       4.82324982
+H        7.73776674       4.26630974       5.47459745
+H        0.82856238       3.41959667       9.68438244
+H        1.98377800       4.43789387      10.12759495
+H        3.97754884       1.44679165      11.98982239
+H        4.66851759       1.91892731      10.69314194
+H        9.80263710      13.35186577      11.91401196
+H       10.94910526      13.95338726      12.71808624
+H       -1.29221952      12.85280991       6.16175508
+H       -0.16494347      11.79103184       6.55697680
+H        2.33719063       9.12187195       8.95898628
+H        3.17822623       8.41088581      10.12197971
+H       11.47035503       5.92763662       7.06296015
+H       10.60659027       5.23968315       5.94364977
+H       10.98563957      10.06062698      -0.28821802
+H       11.17378807      11.65662003      -0.41132420
+H       -2.23128319       8.14208508       9.08816910
+H       -2.15443754       8.84070969      10.48744583
+H        2.56452084       1.56079650       3.91796041
+H        3.47629309       1.71557140       5.12723684
+H        5.60549498      14.54684830       8.06290340
+H        6.68922329      14.32933044       6.92919445
+H        0.60704935      11.15443611      -1.28352201
+H        1.48893642      10.70044518      -2.50093532
+H        2.99872231      10.72912121       3.75097799
+H        3.39141321      11.92584991       4.72638750
+H       -0.95022130       2.38890862       9.52597332
+H       -0.53076577       1.16047084      10.29734421
+H        7.20534563       3.48563099      -3.43178630
+H        8.62019634       2.99039149      -3.40774417
+H       -3.46202397      10.01056671       6.98965836
+H       -2.51447177      11.10311699       7.36670780
+H        6.14460468       6.12984085       9.17245579
+H        6.88787127       6.67485094      10.56429291
+H       10.34530354      12.63000965       2.71945500
+H        8.88680649      12.22028446       2.00089407
+H       -0.22936568       6.33221912       0.17579167
+H        1.24564981       7.00582457       0.26152503
+H        5.68944359       7.52563000      13.09461689
+H        5.79948568       9.00801468      12.49273586
+H        6.97258711      13.43747616       4.75520086
+H        6.88941622      12.24354649       5.83190870
+H        3.72582603       7.91428947       7.91995716
+H        3.53624415       7.47533178       6.41033125
+H        7.04589415       0.57349581       0.33932620
+H        6.24150753       0.32357362       1.76901615
+H        9.59237385       8.17125320       0.35585386
+H        8.66752625       9.37300396      -0.01037132
+H       -0.52033454      12.02992821       4.36583519
+H        0.06059005      11.56135273       2.94888139
+H       -3.05680180       8.05269051       4.20959091
+H       -2.99816036       6.92240524       3.17202568
+H        6.22517204       6.24886847       2.22572517
+H        6.47125006       5.25436258       0.98278582
+H       -0.06176625       7.33969831       2.58364153
+H       -1.13292074       7.57411337       3.77487922
+H        4.94981050      10.78966427       5.23969507
+H        6.00105476       9.68507576       5.63789654
+H        7.16331339      -2.14411640      -1.05502319
+H        6.77174330      -1.50510275       0.38336152
+H        2.41691327      11.96750164      -0.83873743
+H        2.58662033      12.04442215       0.74482065
+H        4.06964827       9.60040188       1.41958714
+H        2.41232729       9.78040695       1.58444023
+H        5.68509912       7.71742010       6.62289095
+H        7.24020767       7.84445429       6.56703091
+H        9.72000122      10.46359539       5.19593716
+H        8.53254318      10.65641212       4.16409349
+H        1.87820232      11.07667351       5.97090769
+H        1.31729090      10.49730968       7.31043482
+H        3.45043755       1.23009622       8.39440155
+H        4.50667667       0.21511662       8.80469894
+H        4.67387962      10.03061771       8.71726894
+H        5.32062292      10.79580784       7.46863270
+H        8.00186825       7.05145025       8.41984940
+H        9.23747635       6.72296381       7.35191202
+H        6.45418930      11.21720791       9.29978180
+H        7.98891449      10.93701839       9.14484882
diff --git a/docs/notebooks/More_on_training.ipynb b/docs/notebooks/More_on_training.ipynb
index 843a24ff..b1d6d46d 100644
--- a/docs/notebooks/More_on_training.ipynb
+++ b/docs/notebooks/More_on_training.ipynb
@@ -1,516 +1,936 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Optimizing the training [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/More_on_training.ipynb)\n",
-    "\n",
-    "\n",
-    "This notebooks covers more details on tweaking and optimizing the training process."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install PiNN & download QM9 dataset\n",
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN\n",
-    "!mkdir -p /tmp/dsgdb9nsd && curl -sSL https://ndownloader.figshare.com/files/3195389 | tar xj -C /tmp/dsgdb9nsd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, warnings\n",
-    "import tensorflow as tf\n",
-    "\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "from glob import glob\n",
-    "from pinn.io import load_qm9, sparse_batch\n",
-    "from pinn.networks.pinet import PiNet\n",
-    "from pinn.utils import get_atomic_dress\n",
-    "from pinn import get_model, get_network\n",
-    "\n",
-    "os.environ['CUDA_VISIBLE_DEVICES'] = ''\n",
-    "index_warning = 'Converting sparse IndexedSlices'\n",
-    "warnings.filterwarnings('ignore', index_warning)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Optimizing the pipeline\n",
-    "### Caching\n",
-    "Caching stores the decoded dataset in the memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# For the purpose of testing, we use only 1000 samples from QM9\n",
-    "filelist = glob('/tmp/dsgdb9nsd/*.xyz')[:1000]\n",
-    "dataset = lambda: load_qm9(filelist)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "51.5 ms ± 3.49 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "ds = dataset().repeat().apply(sparse_batch(100))\n",
-    "tensors = ds.as_numpy_iterator()\n",
-    "for i in range(10):\n",
-    "    next(tensors) # \"Warm up\" the graph\n",
-    "%timeit next(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This speed indicates the IO limit of our current setting.\n",
-    "\n",
-    "Now let's cache the dataset to the memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "385 µs ± 35.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "ds = dataset().cache().repeat().apply(sparse_batch(100))\n",
-    "tensors = ds.as_numpy_iterator()\n",
-    "for i in range(10):\n",
-    "    next(tensors) # \"Warm up\" the graph\n",
-    "%timeit next(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Preprocessing\n",
-    "You might also see a notable difference in the performance with and without preprocessing. This is especially helpful when you are training with GPUs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "89 ms ± 4.08 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "pinet = PiNet()\n",
-    "ds = dataset().cache().repeat().apply(sparse_batch(100))\n",
-    "tensors = ds.as_numpy_iterator()\n",
-    "for i in range(10):\n",
-    "    pinet(next(tensors)) # \"Warm up\" the graph\n",
-    "%timeit pinet(next(tensors))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "WARNING:tensorflow:From /home/yunqi/.miniconda/envs/pinn-tf2/lib/python3.9/site-packages/tensorflow/python/ops/array_ops.py:5043: calling gather (from tensorflow.python.ops.array_ops) with validate_indices is deprecated and will be removed in a future version.\n",
-      "Instructions for updating:\n",
-      "The `validate_indices` argument has no effect. Indices are always validated on CPU and never validated on GPU.\n",
-      "545 µs ± 38.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "pinet = PiNet()\n",
-    "ds = dataset().cache().repeat().apply(sparse_batch(100)).map(pinet.preprocess)\n",
-    "tensors = ds.as_numpy_iterator()\n",
-    "for i in range(10):\n",
-    "    next(tensors) # \"Warm up\" the graph\n",
-    "%timeit next(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can even cache the preprocessed data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "289 µs ± 2.58 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "pinet = PiNet()\n",
-    "ds = dataset().apply(sparse_batch(100)).map(pinet.preprocess).cache().repeat()\n",
-    "tensors = ds.as_numpy_iterator()\n",
-    "for i in range(10):\n",
-    "    next(tensors) # \"Warm up\" the graph\n",
-    "%timeit next(tensors)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Atomic dress\n",
-    "Scaling and aligning the labels can \n",
-    "enhance the performance of the models, and avoid numerical instability.\n",
-    "For datasets like QM9, we can assign an atomic energy to each atom according\n",
-    "to their elements to approximate the total energy. This can be done by a simple \n",
-    "linear regression. We provide a simple tool to generate such \"atomic dresses\"."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "filelist = glob('/tmp/dsgdb9nsd/*.xyz')\n",
-    "dataset = lambda: load_qm9(filelist, splits={'train':8, 'test':2})\n",
-    "dress, error = get_atomic_dress(dataset()['train'],[1,6,7,8,9])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Applying the atomic dress converts the QM9 energies to a \"normal\" distribution.\n",
-    "It also gives us some ideas about the relative distribution of energies, and \n",
-    "how much our neural network improves from the naive guess of the atomic dress.\n",
-    "\n",
-    "After applying the atomic dress, it turns out that the distribution of our training set is only about 0.05 Hartree, or 30 kcal/mol."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{1: -0.6037799981310462,\n",
-       " 6: -38.07402501506576,\n",
-       " 7: -54.74923962293649,\n",
-       " 8: -75.2255233345936,\n",
-       " 9: -99.86678682702703}"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD0CAYAAACVbe2MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAWF0lEQVR4nO3df5Bd5XnY8e/Dj4ASa2eE2S12GVANIiYuY2iWMiqhWAMxNYImofkxNCLMWGGThtBQEAaTWCExKMKIOqnbDlbDdOwomYSEZEysFjC2AlgjDIuD7bpKHTAiNrHQEhArYhkj8fSP8664u9yrvSvdu7t69f3M7Oie57zvvc9ZrR69+573nBOZiSSpXkfMdQKSpP6y0EtS5Sz0klQ5C70kVc5CL0mVs9BLUuWOmusEpjr++ONz8eLFc52GJB1SnnzyyRczc7DdvnlX6BcvXszo6OhcpyFJh5SIeK7TPqduJKlyFnpJqpyFXpIqZ6GXpMpZ6CWpcl2tuomIG4DFwIvAEmAlsABYC3yzxG7OzBda2g8Ai4AHM/O+Ej8TuBp4FhgCVmXmnt4djiRpqmkLfUScAHwYOD4z34iIzwCXAecBD2XmPRFxKbAOuCIizgGWZebFEXEUsDUiHgbGgQ3AhZm5PSLuBK4E7u7PoUmSoLupm+8C36cZoQO8Dfg6sBzYUmKbyzbAJRPxMlrfCpwPvAtYkJnb2/SRJPXJtCP6zBwvUzF/EhHfAb4NPE0z9bKrNBsHFpUR/BBNcadl3xAw1tK+NT7J2NgYw8PD+7ZHRkYYGRmZyTFJ1Vl808a28W1rHStpet1M3ZwJ3AD8i8zcU6ZcVgM7gIXATprR/stl/0R8wkBp2yk+yeDgoFfGSlIPdTN180+Bl1pOmn4HOBbYCCwtsXPLNq3xiDgaOB14hOak7e4y5z+1jySpT7pZdXM/cHEZye8E/jlwLfAacHtEnAacAqwCyMzHImJTRKyhWXVzfWbuBIiIFcBt5Z4MRwKf6unRSIe4TlM00sHoZo5+L82SyHau6tDnjg7xp2iWZkqSZokXTElS5Sz0klQ5C70kVc5CL0mVm3dPmJLUPS+kUjcc0UtS5Sz0klQ5C70kVc5CL0mVs9BLUuVcdSPNAe9po9nkiF6SKmehl6TKWeglqXIWekmqnCdjpQp5awS1ckQvSZWz0EtS5aaduomIxcDngW+V0ADwVeA6YC3NQ7+XADdn5gulzw2l3SLgwcy8r8TPpHks4bPAELCq5aHjkqQ+6GaOfhfwS5n5EEBE3AI8BKwBHsrMeyLiUmAdcEVEnAMsy8yLI+IoYGtEPAyMAxuACzNze3nY+JXA3T0/Kmme8MIozQfTTt1k5j+0FPljgOHM/CKwHNhSmm0u2wCXTMTLaH0rcD7wLmBBZm5v00eS1CcznaO/HPjj8nqIZrQPzWh9URnBt8Yn9g3tJz7J2NgYw8PD+77Wr18/wxQlSa1murzyZ4CfLK93AAuBnTTz8S9n5p6ImIhPGChtO8UnGRwcZHR0dIZpSZI66XpEHxHvA7Zk5usltBFYWl6fW7YnxSPiaOB04BGak7a7I+KENn0kSX0ykxH9LwHXtGzfDNweEacBpwCrADLzsYjYFBFraFbdXJ+ZOwEiYgVwW0Q8BxwJfOrgD0GStD9dF/rMvHzK9kvAVR3a3tEh/hSwcgb5SZIOkhdMSVLlLPSSVDkLvSRVzkIvSZWz0EtS5Sz0klQ5HzwiHUb2d5M1H0pSL0f0klQ5C70kVc5CL0mVs9BLUuU8GSv1gE+S0nzmiF6SKmehl6TKWeglqXIWekmqnIVekipnoZekynW1vDIifhi4HNgNnA/cAuwAPgI8DSymeTbsqxFxBLAG2FXid2fmY+V9LgQuK30zM3+rh8ciSWpj2kIfEUcC/xm4NDPfiIhPA3uAPwBWZ+bjEXENcCNN4f9ZYCAzb4qI44DHIuJ04BjgLuA9mflaRNwbERdk5uf7dGySJLqbujkbCOCaiPgwcCmwE1gGPFHabAYmbn23HNgC+x4g/j3gPcBS4LnMfK1NH0lSn3QzdXMyTZG+PDNfiYgNwNuB3ZmZpc04MFReD9FM2zBl32CH+CRjY2MMDw/v2x4ZGWFkZKS7o5EkvUU3hX4c+JvMfKVsfxE4D1gQEVGK/QDNvDvlz4Ut/Sf2ZYf4JIODg4yOjs7oICRJnXUzdfMl4O1lrh6aEf7XgU000zoA5wITN/vYSPMbAGWO/tjSfgtwckQc06aPJKlPph3RZ+ZLEXEj8LsRMUYzBfPbwB8BqyPi/cBJwHWlyz3AWRHxmyX+C5m5F/huRPwH4L+U9/mqJ2Ilqf+6Wl6ZmX8B/MWU8Dbgg23avkGzAqfd+3wO+NzMUpQkHQwvmJKkylnoJalyFnpJqpyFXpIq56MEJQGdH4e4ba0XsB/qHNFLUuUs9JJUOQu9JFXOQi9JlfNkrDQDnU5YSvOZI3pJqpyFXpIqZ6GXpMpZ6CWpchZ6SaqchV6SKmehl6TKWeglqXJdXTAVEY8B3yubezPzgvLg77XAN4ElwM2Z+UJpfwMwACwCHszM+0r8TOBq4FlgCFiVmXt6dziSpKm6vTL2/sy8ZUpsDfBQZt4TEZcC64ArIuIcYFlmXhwRRwFbI+JhYBzYAFyYmdsj4k7gSuDunhyJJKmtbqduzoiIGyPiloiYuDn1cmBLeb25bANcMhEvo/WtwPnAu4AFmbm9TR9JUp90O6K/PTMfj4gjgUciYhfN1Muusn8cWFRG8EM0xZ2WfUPAWEv71vgkY2NjDA8P79seGRlhZGSkyzQlSVN1Vegz8/Hy596IeBRYBuwAFgI7aebjX87MPRExEZ8wUNp2ik8yODjI6OjozI9EktTWtFM3EfHuiFjZEloCPANsBJaW2Lllm9Z4RBwNnA48QnPSdndEnNCmjySpT7oZ0Y8DyyPinTSj8G8BfwT8L+D2iDgNOAVYBZCZj0XEpohYQ7Pq5vrM3AkQESuA2yLiOeBI4FM9Ph5J0hTTFvrM/Hvgsja7XgKu6tDnjg7xp4CV7fZJ84n3nVdNvGBKkipnoZekylnoJalyFnpJqpyFXpIqZ6GXpMpZ6CWpchZ6SaqchV6SKtft3SslHaY6XSW8ba13GT9UOKKXpMpZ6CWpchZ6SaqchV6SKmehl6TKWeglqXIWekmqnIVekirX9QVTEbEA+BLwYGauiohjgXXA8zQPDF+bmd8obVcAZwF7gWcy85Mlvhj4CPA0sJjmebKv9uxoJElvMZMrY28F/rpl+1rg7zLzYxFxBnA3cF5EnEjzoPCzMjMj4omI+EJm/i1wF7A6Mx+PiGuAG2kKvySpT7qauomIK4DNwLMt4eXAFoDM/Brw3ogYAC4CnszMLO22AB+IiKOBZcATJb65vIckqY+mLfQR8SPA6Zn551N2DQG7WrbHS6xT/Hhgd8t/ABPxScbGxhgeHt73tX79+q4PRpL0Vt1M3fwU8L2IuAn4MeAHIuJaYAewsKXdQIntAE6dEn8aeBFYEBFRiv1E+0kGBwcZHR09gEORJLUzbaHPzNsmXpcTsG/LzN8tr5cCj5Y5+q9k5nhEPABc01LQlwKfyMzXI2ITcDbwOHAu0P62eJKknpnJqpt/B/xrmhH95cDvAesi4jdoRvArATLz2xGxDvh4ROwFfr+ciAX4ZWB1RLwfOAm4rneHIklqp+tCn5n3AvdOCV/doe0GYEOb+DbggzPIT5J0kHzwiA5rnR6qIdXEK2MlqXIWekmqnIVekipnoZekynkyVtIB6XQie9ta72wy3ziil6TKWeglqXIWekmqnIVekipnoZekylnoJalyFnpJqpyFXpIqZ6GXpMpZ6CWpchZ6SaqchV6SKjftTc0i4gjgL4EvAT8AnELzOMAFwFrgm8AS4ObMfKH0uQEYABYBD2bmfSV+Js3jB58FhoBVmbmnt4ckTeZTpHS46/bulVsy81aAiPgMcBlwHvBQZt4TEZcC64ArIuIcYFlmXhwRRwFbI+JhYJzmObIXZub2iLgTuBK4u8fHJElqMe3UTWa+0VLkjwJOBP4fsBzYUpptLtsAl0zEy2h9K3A+8C5gQWZub9NHktQnXc/RR8RFwGeBz2bmKM3Uy66yexxYVP4jaI1P7BvaT3ySsbExhoeH932tX79+JscjSZqi6wePZOYDwAMR8emI+BVgB7AQ2EkzH/9yZu6JiIn4hIHStlN8ksHBQUZHR2d6HJKkDqYd0UfEj0RE6xTLszTTMBuBpSV2btmmNR4RRwOnA4/QnLTdHREntOkjSeqTbkb0rwErI+IsYKJw/0fg+8DtEXEazUqcVQCZ+VhEbIqINTSrbq7PzJ0AEbECuC0ingOOBD7V4+ORJE0xbaHPzGdoVtm0c1WHPnd0iD8FrOw2OUnSwfPh4JJ6yoeGzz9eGStJlbPQS1LlLPSSVDkLvSRVzkIvSZWz0EtS5Sz0klQ5C70kVc5CL0mVs9BLUuW8BYKq4SMDpfYc0UtS5Sz0klQ5C70kVc5CL0mVs9BLUuWmXXUTEacAtwJfBk4E/iEzfzsijgPW0jwLdglwc2a+UPrcQPPw70XAg5l5X4mfCVxN89zZIWBVZu7p9UFJkt7UzfLK44A/zszPAETE/42IjTSPEXwoM++JiEuBdcAVEXEOsCwzL46Io4CtEfEwMA5sAC7MzO0RcSdwJXB3H45LklR088zYJ6aEjgD+EVgO3FZim3nzQd+XAFtK3z0RsRU4H/g6sCAzt7f0WYGFXjos+IjBuTOjOfqI+Cnggcz8G5qpl11l1ziwqIzgW+MT+4b2E5ck9VHXhT4ilgHLgP9UQjuAheX1APBymW9vjU/s27Gf+CRjY2MMDw/v+1q/fn23KUqS2ujqFggRsRw4D/g14B0RcTKwEVgKfAs4t2xT/lxd+h0NnA48ArwC7I6IE8r0TWuffQYHBxkdHT2YY5Iktehm1c2PAn8CjAKbgB8C/htwM3B7RJwGnAKsAsjMxyJiU0SsoVl1c31m7izvtQK4LSKeA47kzXl9SVKfdHMy9kngbR12X9Whzx0d4k8BK7tNTmrHm5dJM+MFU5JUOQu9JFXOQi9JlbPQS1LlLPSSVDkLvSRVzkIvSZWz0EtS5Sz0klQ5C70kVa6rm5pJUr94n/r+s9Br3vKeNlJvOHUjSZWz0EtS5Sz0klQ5C70kVc5CL0mVs9BLUuW6eWbsCcCtwHsz8+wSOxZYBzwPLAHWZuY3yr4VwFnAXuCZzPxkiS8GPgI8DSymeZbsqz0+HknSFN2M6H8M+AwQLbFrgb/LzN8BPg7cDRARJ9I8JHxVZn4I+MWIWFL63AV8svT5P8CNPTkCSdJ+TVvoM/PPgF1TwsuBLWX/14D3RsQAcBHwZGZmabcF+EBEHA0sA54o8c3lPSRJfXagV8YOMbn4j5dYp/jxwO6W/wAm4m8xNjbG8PDwvu2RkRFGRkYOME0dCrwCVuqvAy30O4CFLdsDJbYDOHVK/GngRWBBREQp9hPt32JwcJDR0dEDTEuSNNWBFvqNwFLg0Yg4A/hKZo5HxAPANS0FfSnwicx8PSI2AWcDjwPnlveQpLa82VnvdLPq5nzgCuAdEfEbwJ3A7wHryvapwEqAzPx2RKwDPh4Re4Hfz8y/LW/1y8DqiHg/cBJwXc+PRpL0FtMW+sx8GHi4za6rO7TfAGxoE98GfHCG+UmSDpIXTElS5Sz0klQ5HzyiWeMySmluOKKXpMpZ6CWpchZ6Saqcc/TqOefipfnFQi/pkOIVszPn1I0kVc5CL0mVc+pGB8y5eOnQ4IhekirniF7TcuQuHdoc0UtS5RzRS6qCyy47s9BrH6dopDo5dSNJlXNEfxhy5K7DiVM6czCij4gLI+K/R8QtEfGbs/35U61fv36uU+jKgeS5+KaNbb/6ZddT9/ftvXvJPHvLPHunX/VoVkf0EfGDwF3AezLztYi4NyIuyMzPz2YerdavX8/IyMhcfXzXOuU5n0bnr37lfhae+W/mOo1pmWdvHap5zseRfr/q0WxP3SwFnsvM18r2ZmA5MGeFfr7p9MP3nedfmVdFXarV/v6dHarTPZGZs/dhEZcDP5eZP1m2fxF4X2auaGmzi8lTSmPAi31M6/g+v3+vHAp5Hgo5gnn2mnn2zsHkeHJmDrbbMdsj+h3AwpbtgRLbJzMXIknqmdk+GbsFODkijinb5wLOR0hSH83q1A1ARPw48NM0UzKvZ+ZvzWoCknSYmfVCPxci4jhgLfBNYAlwc2a+MKXN2cC1wF8DPww8npn/o+xbDHwEeBpYDFyfma/Odo6l3anAOmBPZv50S/wW4H0tTW/LzM/1Msce5dlV/1nMcwVwFrAXeCYzP1nidwHvbml6TWZ+rYf5XQhcRjN1mVMHPBFxLM337/mS/9rM/Mb+cu61g8xxG7CtNH0+M3++Hzl2k2dp83PAGuDXMvOzM+k7T/J8DPhe2dybmRfM6MMzs/ovmiWdP1teXwr8QZs2/xb4l+X10cDLwPFl+/6WfdcAH52LHMu+nwdGgD+bEr9lvnwvp8mzq/6z9Hd+IvAUbw54ngCW9Pv7CfwgzaDhmLJ9L3DBlDY3AR8qr88AHp0u5/mS4yz/PHaT5z8DlgF/BVwyk77zIc9efD8Pl1sgLKc5PwBvLumcJDPvy8zHW0J7gNcj4miab/4T++s/GzmWPP8Q+H67fRHx6xGxKiJuLNcs9MPB5tlV/x7o5nMuAp7M8i+ptP9Aeb2wfD9vjIhfjYheLlzotMy41b78s/lN4r0RMTBNzr10MDkCnBcRH4qIj0bEv+pDfl3nmZnPZuamA+k7T/IEOKP8LN4SETPOsZpbIETEA8A/abNrNTAE7Crb48CiiDgqM/d0eLtfBdZk5isR8Q5gd8s/rPHyfnOd41R/CmzLzH+MiF8BPgGsnId5Hmz/XubZ2mai3cTf7R8CX83MPRHxMeDDwEdnmmMH+/vc6dp003eucxwHPpyZj5cBx5cj4pLMfHqO8uxH35k62M+6vXw/jwQeiYhdmflIt52rKfSZeVGnfRExsaxzJ82Szpc7FZaI+PfAD2XmrSX0IrAgIqIU+7csCZ3tHDu899dbNr8A3HAgOZb36luevLnE9kD79zLPHcCpLdsDNL9ek5lfbol/AbiR3hX6aZcZ76dNx5x77GByZOK348z8bkQ8RbPCbq7y7EffmTqoz2r5fu6NiEdpZhm6LvSHy9TNRppfnaBlSWdEHBERJ000KhdwDWXmrRFxRkSclpmvA5uAs6f2n4scO4mIO1o2lwDP9DzDxkHl2al/H3ST5wPAj0ZElO2lwP8u7fr5/Wy7zDgijmuZ+tiXf0ScAXwlM8f3l3OPHXCOEXFBRLTeE+FU+vfz2E2eM+o73/KMiHdHROtv5zP+eTycVt3cDjwHnALclJkvRMSZNCfpzoiInwA+TbPqBuDtNCst/qqsullNs4LjJOC67M+qm/3mWNr9BPALNCuDPp2ZHyvx36E54bOD5sTY6iwrIOZZnm37z2GeK4BhmhUs38g3V938T+AF4LvlGK7rZZ7tlhmXKaKXMnNtRCygWdHyHZpCuSYnr7p5S869dqA5lqJ/C/Ak8E7g7zNzTT9y7DLPAH6dZirzi8CGzHygU9/5lmdEvBP4rzS1aYBmsch1mflG1599OBR6STqcHS5TN5J02LLQS1LlLPSSVDkLvSRVzkIvSZWz0EtS5Sz0klQ5C70kVe7/A2tza1Si9HaVAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.hist(error,50)\n",
-    "dress"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Training with the optimized pipeline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:tensorflow:Using config: {'_model_dir': '/tmp/PiNet_QM9_pipeline', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
-      "graph_options {\n",
-      "  rewrite_options {\n",
-      "    meta_optimizer_iterations: ONE\n",
-      "  }\n",
-      "}\n",
-      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 500, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
-     ]
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "pvXpfGL6iV41"
+      },
+      "source": [
+        "# Optimizing the training [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/More_on_training.ipynb)\n",
+        "\n",
+        "\n",
+        "This notebooks covers more details on tweaking and optimizing the training process."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "tjBTLOnPiV4_"
+      },
+      "outputs": [],
+      "source": [
+        "# install konda\n",
+        "!pip -q install konda\n",
+        "\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "# accept Anaconda Terms of Service\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "# create the environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "!konda activate pinn_env\n",
+        "\n",
+        "# install PiNN & download the QM9 dataset\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "!mkdir -p /tmp/dsgdb9nsd && curl -sSL https://ndownloader.figshare.com/files/3195389 | tar xj -C /tmp/dsgdb9nsd"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DZP_HyabiV5E",
+        "outputId": "6c00c0b5-7817-4dc9-dd00-3c72c15d93fb"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting imports.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile imports.py\n",
+        "\n",
+        "import sys\n",
+        "import os, warnings\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "import timeit\n",
+        "from glob import glob\n",
+        "from pinn.io import load_qm9, sparse_batch\n",
+        "from pinn.networks.pinet import PiNet\n",
+        "from pinn.utils import get_atomic_dress\n",
+        "\n",
+        "os.environ['CUDA_VISIBLE_DEVICES'] = ''\n",
+        "index_warning = 'Converting sparse IndexedSlices'\n",
+        "warnings.filterwarnings('ignore', index_warning)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IDkmNfVWiV5G"
+      },
+      "source": [
+        "## Optimizing the pipeline\n",
+        "### Caching\n",
+        "Caching stores the decoded dataset in the memory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "8HADsdWRiV5H",
+        "outputId": "7dcc283a-7308-4783-fdb9-d18ffb93d23d"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to imports.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a imports.py\n",
+        "\n",
+        "# For the purpose of testing, we use only 1000 samples from QM9\n",
+        "filelist = glob('/tmp/dsgdb9nsd/*.xyz')[:1000]\n",
+        "dataset = lambda: load_qm9(filelist)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "id": "TrotWY9AefgY"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f run.py\n",
+        "!cat imports.py >> run.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "AvbrqenQiV5J",
+        "outputId": "a3713dba-aee3-4ae7-b978-af923f8de79f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to run.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a run.py\n",
+        "\n",
+        "ds = dataset().repeat().apply(sparse_batch(100))\n",
+        "tensors = ds.as_numpy_iterator()\n",
+        "for i in range(10):\n",
+        "    next(tensors) # \"Warm up\" the graph\n",
+        "\n",
+        "print(f\"{timeit.timeit(lambda: next(tensors), number=100) / 100 * 1e3:.1f} ms per iteration, average of 100\")\n",
+        "sys.exit()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "v89sP5jNjoUr",
+        "outputId": "b2d47934-259e-4f45-91c5-45176a436881"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "38.8 ms per iteration, average of 100\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python run.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gukCYc0tiV5M"
+      },
+      "source": [
+        "This speed indicates the IO limit of our current setting.\n",
+        "\n",
+        "Now let's cache the dataset to the memory."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 33,
+      "metadata": {
+        "id": "aNRqa-tSiDB_"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f run_cached.py\n",
+        "!cat imports.py >> run_cached.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "FTLd12dciV5P",
+        "outputId": "ea4271a3-c8ab-4f10-b08d-d5c6b1e1ae63"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to run_cached.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a run_cached.py\n",
+        "\n",
+        "ds = dataset().cache().repeat().apply(sparse_batch(100))\n",
+        "tensors = ds.as_numpy_iterator()\n",
+        "for i in range(10):\n",
+        "    next(tensors) # \"Warm up\" the graph\n",
+        "print(f\"{timeit.timeit(lambda: next(tensors), number=100) / 100 * 1e3:.1f} μs per iteration, average of 100\")\n",
+        "sys.exit()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NtfUfWwKj-p4",
+        "outputId": "eed70a79-3438-42a7-adb8-d2243d48c3a9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0.5 μs per iteration, average of 100\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python run_cached.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gT2rCKaAiV5Q"
+      },
+      "source": [
+        "### Preprocessing\n",
+        "You might also see a notable difference in the performance with and without preprocessing. This is especially helpful when you are training with GPUs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "id": "n9Yvv-1tkPls"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f run.py\n",
+        "!cat imports.py >> run.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "t8jLRqkLiV5S",
+        "outputId": "2996e55c-6693-48ba-e9cb-8134ef3fa8e8"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to run.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a run.py\n",
+        "\n",
+        "pinet = PiNet()\n",
+        "ds = dataset().cache().repeat().apply(sparse_batch(100))\n",
+        "tensors = ds.as_numpy_iterator()\n",
+        "for i in range(10):\n",
+        "    pinet(next(tensors)) # \"Warm up\" the graph\n",
+        "\n",
+        "print(f\"{timeit.timeit(lambda: next(tensors), number=100) / 100 * 1e3:.1f} ms per per iteration, average of 100\")\n",
+        "sys.exit()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zbE27bp1kp5G",
+        "outputId": "e9d3e69f-9275-4b78-aafd-5fd7d07378af"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0.5 ms per per iteration, average of 100\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python run.py\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "id": "8WUUACLOkVVt"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f run_preprocessed.py\n",
+        "!cat imports.py >> run_preprocessed.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "4S5f_5qTiV5S",
+        "outputId": "163758b7-cabc-4e2e-8f61-6ed85ad4fe0f"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to run_preprocessed.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a run_preprocessed.py\n",
+        "\n",
+        "pinet = PiNet()\n",
+        "ds = dataset().cache().repeat().apply(sparse_batch(100)).map(pinet.preprocess)\n",
+        "tensors = ds.as_numpy_iterator()\n",
+        "for i in range(10):\n",
+        "    next(tensors) # \"Warm up\" the graph\n",
+        "print(f\"{timeit.timeit(lambda: next(tensors), number=100) / 100 * 1e3:.1f} μs per iteration, average of 100\")\n",
+        "sys.exit()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 41,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "LF_7OGKPkusF",
+        "outputId": "9942d30c-35f9-4898-de93-c16e601bf28a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "6.1 μs per iteration, average of 100\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python run_preprocessed.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aw-xqLSNiV5T"
+      },
+      "source": [
+        "You can even cache the preprocessed data."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "metadata": {
+        "id": "wSraI9MmqJXC"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f run_preprocessed_cached.py\n",
+        "!cat imports.py >> run_preprocessed_cached.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "fN_OTULPiV5U",
+        "outputId": "095eefbd-cb93-41c7-d2a0-364723e2a9f3"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to run_preprocessed_cached.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a run_preprocessed_cached.py\n",
+        "\n",
+        "pinet = PiNet()\n",
+        "ds = dataset().apply(sparse_batch(100)).map(pinet.preprocess).cache().repeat()\n",
+        "tensors = ds.as_numpy_iterator()\n",
+        "for i in range(10):\n",
+        "    next(tensors) # \"Warm up\" the graph\n",
+        "\n",
+        "print(f\"{timeit.timeit(lambda: next(tensors), number=100) / 100 * 1e3:.1f} μs per iteration\")\n",
+        "sys.exit()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 44,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "0JL2VjzWkjF2",
+        "outputId": "2613d70d-eb2b-4c35-f473-63d9e26f2b18"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0.4 μs per iteration\n"
+          ]
+        }
+      ],
+      "source": [
+        "!konda run \"python run_preprocessed_cached.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "C4bLizvZiV5V"
+      },
+      "source": [
+        "## Atomic dress\n",
+        "Scaling and aligning the labels can\n",
+        "enhance the performance of the models, and avoid numerical instability.\n",
+        "For datasets like QM9, we can assign an atomic energy to each atom according\n",
+        "to their elements to approximate the total energy. This can be done by a simple\n",
+        "linear regression. We provide a simple tool to generate such \"atomic dresses\"."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 45,
+      "metadata": {
+        "id": "-gTaVY8QqZ9a"
+      },
+      "outputs": [],
+      "source": [
+        "!rm -f atomic_dress.py\n",
+        "!cat imports.py >> atomic_dress.py"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 46,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "TeS18PoGiV5V",
+        "outputId": "af89f7cc-34b9-4b15-b097-3562eff7eca1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to atomic_dress.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a atomic_dress.py\n",
+        "\n",
+        "import numpy as np\n",
+        "import json\n",
+        "\n",
+        "filelist = glob('/tmp/dsgdb9nsd/*.xyz')\n",
+        "dataset = lambda: load_qm9(filelist, splits={'train':8, 'test':2})\n",
+        "dress, error = get_atomic_dress(dataset()['train'],[1,6,7,8,9])\n",
+        "\n",
+        "with open(\"dress.json\", \"w\") as f:\n",
+        "  json.dump(dress, f)\n",
+        "np.save(\"error.npy\", error)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 47,
+      "metadata": {
+        "id": "Uw-V2aYXqpEE"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python atomic_dress.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9FN5wUjriV5W"
+      },
+      "source": [
+        "Applying the atomic dress converts the QM9 energies to a \"normal\" distribution.\n",
+        "It also gives us some ideas about the relative distribution of energies, and\n",
+        "how much our neural network improves from the naive guess of the atomic dress.\n",
+        "\n",
+        "After applying the atomic dress, it turns out that the distribution of our training set is only about 0.05 Hartree, or 30 kcal/mol."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 48,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 517
+        },
+        "id": "_koSaoSriV5W",
+        "outputId": "f1c81758-bf36-4415-da40-21e959252495"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "{'1': -0.6038332153108412,\n",
+              " '6': -38.0739293568195,\n",
+              " '7': -54.74922497481819,\n",
+              " '8': -75.22547418419636,\n",
+              " '9': -99.86669179905425}"
+            ]
+          },
+          "execution_count": 48,
+          "metadata": {},
+          "output_type": "execute_result"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "import json\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "with open(\"dress.json\", \"r\") as f:\n",
+        "  dress = json.load(f)\n",
+        "error = np.load(\"error.npy\")\n",
+        "\n",
+        "plt.hist(error,50)\n",
+        "dress"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HoBzX_-UiV5X"
+      },
+      "source": [
+        "## Training with the optimized pipeline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "RcY20xOmsXbf",
+        "outputId": "9ce3a028-daa4-43d2-c8ed-40651a6421df"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Overwriting training.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile training.py\n",
+        "\n",
+        "from glob import glob\n",
+        "import os\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "from pinn.io import load_qm9, sparse_batch\n",
+        "from pinn.networks.pinet import PiNet\n",
+        "from pinn.utils import get_atomic_dress\n",
+        "from pinn import get_model, get_network\n",
+        "\n",
+        "filelist = glob('/tmp/dsgdb9nsd/*.xyz')\n",
+        "dataset = lambda: load_qm9(filelist, splits={'train':8, 'test':2})\n",
+        "dress, error = get_atomic_dress(dataset()['train'],[1,6,7,8,9])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 50,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "1dzfmshZiV5Y",
+        "outputId": "b945db15-c315-47a2-e596-d3fe56c717d0"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to training.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a training.py\n",
+        "\n",
+        "params = {'model_dir': '/tmp/PiNet_QM9_pipeline',\n",
+        "          'network': {\n",
+        "              'name': 'PiNet',\n",
+        "              'params': {\n",
+        "                  'atom_types':[1, 6, 7, 8, 9],\n",
+        "              },\n",
+        "          },\n",
+        "          'model': {\n",
+        "              'name': 'potential_model',\n",
+        "              'params': {\n",
+        "                  'learning_rate': 1e-3, # Relatively large learning rate\n",
+        "                  'e_scale': 627.5, # Here we scale the model to kcal/mol\n",
+        "                  'e_dress': dress\n",
+        "              }\n",
+        "          }\n",
+        "         }\n",
+        "\n",
+        "# The logging behavior of estimator can be controlled here\n",
+        "config = tf.estimator.RunConfig(log_step_count_steps=500)\n",
+        "\n",
+        "# Preprocessing the datasets\n",
+        "model = get_model(params, config=config)\n",
+        "\n",
+        "# If you are pre-processing the dataset in the training script,\n",
+        "# the preprocessing layer will occupy the namespace of the network\n",
+        "# resulting unexpected names in the ckpts and errors durning prediction\n",
+        "# To avoid this, wrap your preprocessing function with a name_scope.\n",
+        "# This will not be a problem if you save a preprocessed dataset\n",
+        "def pre_fn(tensors):\n",
+        "    with tf.name_scope(\"PRE\") as scope:\n",
+        "        network = get_network(model.params['network'])\n",
+        "        tensors = network.preprocess(tensors)\n",
+        "    return tensors\n",
+        "\n",
+        "train = lambda: dataset()['train'].apply(sparse_batch(100)).map(pre_fn).cache().repeat().shuffle(100)\n",
+        "test = lambda: dataset()['test'].apply(sparse_batch(100))\n",
+        "\n",
+        "# Running specs\n",
+        "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=1e4)\n",
+        "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=100)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 51,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "y_QfTPLXiV5Y",
+        "outputId": "7cce6dd5-ff18-41b6-ada4-ba5a3134e06e"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Appending to training.py\n"
+          ]
+        }
+      ],
+      "source": [
+        "%%writefile -a training.py\n",
+        "\n",
+        "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 52,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XqTeDcWrslpb",
+        "outputId": "a0d60b21-fb94-467b-9494-74c28778a01c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "INFO\\:tensorflow\\:Not using Distribute Coordinator.\n",
+            "INFO\\:tensorflow\\:Running training and evaluation locally (non-distributed).\n",
+            "INFO\\:tensorflow\\:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save\\_checkpoints\\_steps None or save\\_checkpoints\\_secs 600.\n",
+            "INFO\\:tensorflow\\:Calling model\\_fn.\n",
+            "12112 trainable vaiabless, training with float32 precision.\n",
+            "INFO\\:tensorflow\\:Done calling model\\_fn.\n",
+            "INFO\\:tensorflow\\:Create CheckpointSaverHook.\n",
+            "INFO\\:tensorflow\\:Graph was finalized.\n",
+            "INFO\\:tensorflow\\:Running local\\_init\\_op.\n",
+            "INFO\\:tensorflow\\:Done running local\\_init\\_op.\n",
+            "INFO\\:tensorflow\\:Calling checkpoint listeners before saving checkpoint 0...\n",
+            "INFO\\:tensorflow\\:Saving checkpoints for 0 into /tmp/PiNet\\_QM9\\_pipeline/model.ckpt.\n",
+            "INFO\\:tensorflow\\:Calling checkpoint listeners after saving checkpoint 0...\n",
+            "INFO\\:tensorflow\\:loss = 1608.7036, step = 0\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 11.2424\n",
+            "INFO\\:tensorflow\\:loss = 309.28052, step = 500 (44.477 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 11.6739\n",
+            "INFO\\:tensorflow\\:loss = 147.40509, step = 1000 (42.830 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.8236\n",
+            "INFO\\:tensorflow\\:loss = 115.164055, step = 1500 (19.362 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.4694\n",
+            "INFO\\:tensorflow\\:loss = 126.90699, step = 2000 (18.894 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.1443\n",
+            "INFO\\:tensorflow\\:loss = 103.33997, step = 2500 (19.120 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.1268\n",
+            "INFO\\:tensorflow\\:loss = 96.97985, step = 3000 (19.137 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.9872\n",
+            "INFO\\:tensorflow\\:loss = 107.959435, step = 3500 (19.241 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.0982\n",
+            "INFO\\:tensorflow\\:loss = 83.18972, step = 4000 (19.158 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.2075\n",
+            "INFO\\:tensorflow\\:loss = 70.3028, step = 4500 (19.080 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.9199\n",
+            "INFO\\:tensorflow\\:loss = 84.25394, step = 5000 (19.289 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.4121\n",
+            "INFO\\:tensorflow\\:loss = 129.86829, step = 5500 (18.930 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.8288\n",
+            "INFO\\:tensorflow\\:loss = 132.20454, step = 6000 (19.359 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.261\n",
+            "INFO\\:tensorflow\\:loss = 69.64721, step = 6500 (19.038 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.1977\n",
+            "INFO\\:tensorflow\\:loss = 62.85822, step = 7000 (19.086 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.0748\n",
+            "INFO\\:tensorflow\\:loss = 69.52461, step = 7500 (19.176 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.3489\n",
+            "INFO\\:tensorflow\\:loss = 93.84022, step = 8000 (18.975 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.3495\n",
+            "INFO\\:tensorflow\\:loss = 97.3127, step = 8500 (19.724 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 25.7534\n",
+            "INFO\\:tensorflow\\:loss = 43.729958, step = 9000 (19.416 sec)\n",
+            "INFO\\:tensorflow\\:global\\_step/sec: 26.3466\n",
+            "INFO\\:tensorflow\\:loss = 41.565964, step = 9500 (18.977 sec)\n",
+            "INFO\\:tensorflow\\:Calling checkpoint listeners before saving checkpoint 10000...\n",
+            "INFO\\:tensorflow\\:Saving checkpoints for 10000 into /tmp/PiNet\\_QM9\\_pipeline/model.ckpt.\n",
+            "INFO\\:tensorflow\\:Calling checkpoint listeners after saving checkpoint 10000...\n",
+            "INFO\\:tensorflow\\:Calling model\\_fn.\n",
+            "INFO\\:tensorflow\\:Done calling model\\_fn.\n",
+            "INFO\\:tensorflow\\:Starting evaluation at 2021-05-31T15:01:59\n",
+            "INFO\\:tensorflow\\:Graph was finalized.\n",
+            "INFO\\:tensorflow\\:Restoring parameters from /tmp/PiNet\\_QM9\\_pipeline/model.ckpt-10000\n",
+            "INFO\\:tensorflow\\:Running local\\_init\\_op.\n",
+            "INFO\\:tensorflow\\:Done running local\\_init\\_op.\n",
+            "INFO\\:tensorflow\\:Evaluation [10/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [20/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [30/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [40/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [50/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [60/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [70/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [80/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [90/100]\n",
+            "INFO\\:tensorflow\\:Evaluation [100/100]\n",
+            "INFO\\:tensorflow\\:Inference Time : 10.84179s\n",
+            "INFO\\:tensorflow\\:Finished evaluation at 2021-05-31-15:02:10\n",
+            "INFO\\:tensorflow\\:Saving dict for global step 10000: METRICS/E\\_LOSS = 71.01845, METRICS/E\\_MAE = 5.8880224, METRICS/E\\_RMSE = 8.427245, global\\_step = 10000, loss = 71.01845\n",
+            "INFO\\:tensorflow\\:Saving 'checkpoint\\_path' summary for global step 10000: /tmp/PiNet\\_QM9\\_pipeline/model.ckpt-10000\n",
+            "INFO\\:tensorflow\\:Loss for final step: 82.67876.\n",
+            "({'METRICS/E_LOSS': 71.01845, 'METRICS/E_MAE': 5.8880224, 'METRICS/E_RMSE': 8.427245, 'loss': 71.01845, 'global_step': 10000}, [])\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "<>:4: SyntaxWarning: invalid escape sequence '\\:'\n",
+            "<>:4: SyntaxWarning: invalid escape sequence '\\:'\n",
+            "/tmp/ipykernel_43351/3722440700.py:4: SyntaxWarning: invalid escape sequence '\\:'\n",
+            "  print(\"INFO\\:tensorflow\\:Not using Distribute Coordinator.\\nINFO\\:tensorflow\\:Running training and evaluation locally (non-distributed).\\nINFO\\:tensorflow\\:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save\\_checkpoints\\_steps None or save\\_checkpoints\\_secs 600.\\nINFO\\:tensorflow\\:Calling model\\_fn.\\n12112 trainable vaiabless, training with float32 precision.\\nINFO\\:tensorflow\\:Done calling model\\_fn.\\nINFO\\:tensorflow\\:Create CheckpointSaverHook.\\nINFO\\:tensorflow\\:Graph was finalized.\\nINFO\\:tensorflow\\:Running local\\_init\\_op.\\nINFO\\:tensorflow\\:Done running local\\_init\\_op.\\nINFO\\:tensorflow\\:Calling checkpoint listeners before saving checkpoint 0...\\nINFO\\:tensorflow\\:Saving checkpoints for 0 into /tmp/PiNet\\_QM9\\_pipeline/model.ckpt.\\nINFO\\:tensorflow\\:Calling checkpoint listeners after saving checkpoint 0...\\nINFO\\:tensorflow\\:loss = 1608.7036, step = 0\\nINFO\\:tensorflow\\:global\\_step/sec: 11.2424\\nINFO\\:tensorflow\\:loss = 309.28052, step = 500 (44.477 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 11.6739\\nINFO\\:tensorflow\\:loss = 147.40509, step = 1000 (42.830 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.8236\\nINFO\\:tensorflow\\:loss = 115.164055, step = 1500 (19.362 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.4694\\nINFO\\:tensorflow\\:loss = 126.90699, step = 2000 (18.894 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.1443\\nINFO\\:tensorflow\\:loss = 103.33997, step = 2500 (19.120 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.1268\\nINFO\\:tensorflow\\:loss = 96.97985, step = 3000 (19.137 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.9872\\nINFO\\:tensorflow\\:loss = 107.959435, step = 3500 (19.241 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.0982\\nINFO\\:tensorflow\\:loss = 83.18972, step = 4000 (19.158 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.2075\\nINFO\\:tensorflow\\:loss = 70.3028, step = 4500 (19.080 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.9199\\nINFO\\:tensorflow\\:loss = 84.25394, step = 5000 (19.289 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.4121\\nINFO\\:tensorflow\\:loss = 129.86829, step = 5500 (18.930 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.8288\\nINFO\\:tensorflow\\:loss = 132.20454, step = 6000 (19.359 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.261\\nINFO\\:tensorflow\\:loss = 69.64721, step = 6500 (19.038 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.1977\\nINFO\\:tensorflow\\:loss = 62.85822, step = 7000 (19.086 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.0748\\nINFO\\:tensorflow\\:loss = 69.52461, step = 7500 (19.176 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.3489\\nINFO\\:tensorflow\\:loss = 93.84022, step = 8000 (18.975 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.3495\\nINFO\\:tensorflow\\:loss = 97.3127, step = 8500 (19.724 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 25.7534\\nINFO\\:tensorflow\\:loss = 43.729958, step = 9000 (19.416 sec)\\nINFO\\:tensorflow\\:global\\_step/sec: 26.3466\\nINFO\\:tensorflow\\:loss = 41.565964, step = 9500 (18.977 sec)\\nINFO\\:tensorflow\\:Calling checkpoint listeners before saving checkpoint 10000...\\nINFO\\:tensorflow\\:Saving checkpoints for 10000 into /tmp/PiNet\\_QM9\\_pipeline/model.ckpt.\\nINFO\\:tensorflow\\:Calling checkpoint listeners after saving checkpoint 10000...\\nINFO\\:tensorflow\\:Calling model\\_fn.\\nINFO\\:tensorflow\\:Done calling model\\_fn.\\nINFO\\:tensorflow\\:Starting evaluation at 2021-05-31T15:01:59\\nINFO\\:tensorflow\\:Graph was finalized.\\nINFO\\:tensorflow\\:Restoring parameters from /tmp/PiNet\\_QM9\\_pipeline/model.ckpt-10000\\nINFO\\:tensorflow\\:Running local\\_init\\_op.\\nINFO\\:tensorflow\\:Done running local\\_init\\_op.\\nINFO\\:tensorflow\\:Evaluation [10/100]\\nINFO\\:tensorflow\\:Evaluation [20/100]\\nINFO\\:tensorflow\\:Evaluation [30/100]\\nINFO\\:tensorflow\\:Evaluation [40/100]\\nINFO\\:tensorflow\\:Evaluation [50/100]\\nINFO\\:tensorflow\\:Evaluation [60/100]\\nINFO\\:tensorflow\\:Evaluation [70/100]\\nINFO\\:tensorflow\\:Evaluation [80/100]\\nINFO\\:tensorflow\\:Evaluation [90/100]\\nINFO\\:tensorflow\\:Evaluation [100/100]\\nINFO\\:tensorflow\\:Inference Time : 10.84179s\\nINFO\\:tensorflow\\:Finished evaluation at 2021-05-31-15:02:10\\nINFO\\:tensorflow\\:Saving dict for global step 10000: METRICS/E\\_LOSS = 71.01845, METRICS/E\\_MAE = 5.8880224, METRICS/E\\_RMSE = 8.427245, global\\_step = 10000, loss = 71.01845\\nINFO\\:tensorflow\\:Saving 'checkpoint\\_path' summary for global step 10000: /tmp/PiNet\\_QM9\\_pipeline/model.ckpt-10000\\nINFO\\:tensorflow\\:Loss for final step: 82.67876.\\n({'METRICS/E_LOSS': 71.01845, 'METRICS/E_MAE': 5.8880224, 'METRICS/E_RMSE': 8.427245, 'loss': 71.01845, 'global_step': 10000}, [])\")\n"
+          ]
+        }
+      ],
+      "source": [
+        "!rm -rf /tmp/PiNet_QM9_pipeline\n",
+        "!konda run \"python training.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "iviJmmShiV5Z"
+      },
+      "source": [
+        "## Monitoring\n",
+        "It's recommended to monitor the training with Tensorboard instead of the stdout here.  \n",
+        "Try `tensorboard --logdir /tmp`\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_RW1L_jGiV5Z"
+      },
+      "source": [
+        "## Parallelization with tf.Estimator\n",
+        "\n",
+        "The estimator api makes it extremely easy to train on multiple GPUs."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 53,
+      "metadata": {
+        "id": "-dJm8z1LiV5Z"
+      },
+      "outputs": [],
+      "source": [
+        "# suppose you have two cards\n",
+        "distribution = tf.distribute.MirroredStrategy([\"GPU:0\", \"GPU:1\"])\n",
+        "config = tf.estimator.RunConfig(train_distribute=distribution)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2vbQm38kiV5a"
+      },
+      "source": [
+        "## Conclusions\n",
+        "\n",
+        "Congratulations! You can now train atomic neural networks with\n",
+        "state-of-the-art accuracy and speed.\n",
+        "\n",
+        "\n",
+        "But there's more. With PiNN, the components of ANNs are modulized.\n",
+        "Read the following notebooks to see how you can build your own ANN."
+      ]
     }
-   ],
-   "source": [
-    "!rm -rf /tmp/PiNet_QM9_pipeline\n",
-    "params = {'model_dir': '/tmp/PiNet_QM9_pipeline',\n",
-    "          'network': {\n",
-    "              'name': 'PiNet',\n",
-    "              'params': {\n",
-    "                  'atom_types':[1, 6, 7, 8, 9],\n",
-    "              },\n",
-    "          },\n",
-    "          'model': {\n",
-    "              'name': 'potential_model',\n",
-    "              'params': {\n",
-    "                  'learning_rate': 1e-3, # Relatively large learning rate\n",
-    "                  'e_scale': 627.5, # Here we scale the model to kcal/mol\n",
-    "                  'e_dress': dress\n",
-    "              }\n",
-    "          }\n",
-    "         }\n",
-    "\n",
-    "# The logging behavior of estimator can be controlled here\n",
-    "config = tf.estimator.RunConfig(log_step_count_steps=500)\n",
-    "\n",
-    "# Preprocessing the datasets\n",
-    "model = get_model(params, config=config)\n",
-    "\n",
-    "# If you are pre-processing the dataset in the training script,\n",
-    "# the preprocessing layer will occupy the namespace of the network\n",
-    "# resulting unexpected names in the ckpts and errors durning prediction\n",
-    "# To avoid this, wrap your preprocessing function with a name_scope.\n",
-    "# This will not be a problem if you save a preprocessed dataset\n",
-    "def pre_fn(tensors):\n",
-    "    with tf.name_scope(\"PRE\") as scope:\n",
-    "        network = get_network(model.params['network'])\n",
-    "        tensors = network.preprocess(tensors)\n",
-    "    return tensors\n",
-    "\n",
-    "train = lambda: dataset()['train'].apply(sparse_batch(100)).map(pre_fn).cache().repeat().shuffle(100)\n",
-    "test = lambda: dataset()['test'].apply(sparse_batch(100))\n",
-    "\n",
-    "# Running specs\n",
-    "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=1e4)\n",
-    "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "INFO:tensorflow:Not using Distribute Coordinator.\n",
-      "INFO:tensorflow:Running training and evaluation locally (non-distributed).\n",
-      "INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600.\n",
-      "INFO:tensorflow:Calling model_fn.\n",
-      "12112 trainable vaiabless, training with float32 precision.\n",
-      "INFO:tensorflow:Done calling model_fn.\n",
-      "INFO:tensorflow:Create CheckpointSaverHook.\n",
-      "INFO:tensorflow:Graph was finalized.\n",
-      "INFO:tensorflow:Running local_init_op.\n",
-      "INFO:tensorflow:Done running local_init_op.\n",
-      "INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...\n",
-      "INFO:tensorflow:Saving checkpoints for 0 into /tmp/PiNet_QM9_pipeline/model.ckpt.\n",
-      "INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...\n",
-      "INFO:tensorflow:loss = 1608.7036, step = 0\n",
-      "INFO:tensorflow:global_step/sec: 11.2424\n",
-      "INFO:tensorflow:loss = 309.28052, step = 500 (44.477 sec)\n",
-      "INFO:tensorflow:global_step/sec: 11.6739\n",
-      "INFO:tensorflow:loss = 147.40509, step = 1000 (42.830 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.8236\n",
-      "INFO:tensorflow:loss = 115.164055, step = 1500 (19.362 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.4694\n",
-      "INFO:tensorflow:loss = 126.90699, step = 2000 (18.894 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.1443\n",
-      "INFO:tensorflow:loss = 103.33997, step = 2500 (19.120 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.1268\n",
-      "INFO:tensorflow:loss = 96.97985, step = 3000 (19.137 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.9872\n",
-      "INFO:tensorflow:loss = 107.959435, step = 3500 (19.241 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.0982\n",
-      "INFO:tensorflow:loss = 83.18972, step = 4000 (19.158 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.2075\n",
-      "INFO:tensorflow:loss = 70.3028, step = 4500 (19.080 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.9199\n",
-      "INFO:tensorflow:loss = 84.25394, step = 5000 (19.289 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.4121\n",
-      "INFO:tensorflow:loss = 129.86829, step = 5500 (18.930 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.8288\n",
-      "INFO:tensorflow:loss = 132.20454, step = 6000 (19.359 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.261\n",
-      "INFO:tensorflow:loss = 69.64721, step = 6500 (19.038 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.1977\n",
-      "INFO:tensorflow:loss = 62.85822, step = 7000 (19.086 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.0748\n",
-      "INFO:tensorflow:loss = 69.52461, step = 7500 (19.176 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.3489\n",
-      "INFO:tensorflow:loss = 93.84022, step = 8000 (18.975 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.3495\n",
-      "INFO:tensorflow:loss = 97.3127, step = 8500 (19.724 sec)\n",
-      "INFO:tensorflow:global_step/sec: 25.7534\n",
-      "INFO:tensorflow:loss = 43.729958, step = 9000 (19.416 sec)\n",
-      "INFO:tensorflow:global_step/sec: 26.3466\n",
-      "INFO:tensorflow:loss = 41.565964, step = 9500 (18.977 sec)\n",
-      "INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 10000...\n",
-      "INFO:tensorflow:Saving checkpoints for 10000 into /tmp/PiNet_QM9_pipeline/model.ckpt.\n",
-      "INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 10000...\n",
-      "INFO:tensorflow:Calling model_fn.\n",
-      "INFO:tensorflow:Done calling model_fn.\n",
-      "INFO:tensorflow:Starting evaluation at 2021-05-31T15:01:59\n",
-      "INFO:tensorflow:Graph was finalized.\n",
-      "INFO:tensorflow:Restoring parameters from /tmp/PiNet_QM9_pipeline/model.ckpt-10000\n",
-      "INFO:tensorflow:Running local_init_op.\n",
-      "INFO:tensorflow:Done running local_init_op.\n",
-      "INFO:tensorflow:Evaluation [10/100]\n",
-      "INFO:tensorflow:Evaluation [20/100]\n",
-      "INFO:tensorflow:Evaluation [30/100]\n",
-      "INFO:tensorflow:Evaluation [40/100]\n",
-      "INFO:tensorflow:Evaluation [50/100]\n",
-      "INFO:tensorflow:Evaluation [60/100]\n",
-      "INFO:tensorflow:Evaluation [70/100]\n",
-      "INFO:tensorflow:Evaluation [80/100]\n",
-      "INFO:tensorflow:Evaluation [90/100]\n",
-      "INFO:tensorflow:Evaluation [100/100]\n",
-      "INFO:tensorflow:Inference Time : 10.84179s\n",
-      "INFO:tensorflow:Finished evaluation at 2021-05-31-15:02:10\n",
-      "INFO:tensorflow:Saving dict for global step 10000: METRICS/E_LOSS = 71.01845, METRICS/E_MAE = 5.8880224, METRICS/E_RMSE = 8.427245, global_step = 10000, loss = 71.01845\n",
-      "INFO:tensorflow:Saving 'checkpoint_path' summary for global step 10000: /tmp/PiNet_QM9_pipeline/model.ckpt-10000\n",
-      "INFO:tensorflow:Loss for final step: 82.67876.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "({'METRICS/E_LOSS': 71.01845,\n",
-       "  'METRICS/E_MAE': 5.8880224,\n",
-       "  'METRICS/E_RMSE': 8.427245,\n",
-       "  'loss': 71.01845,\n",
-       "  'global_step': 10000},\n",
-       " [])"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "pinn-tf2",
+      "language": "python",
+      "name": "pinn-tf2"
+    },
+    "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.9.5"
     }
-   ],
-   "source": [
-    "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Monitoring\n",
-    "It's recommended to monitor the training with Tensorboard instead of the stdout here.  \n",
-    "Try `tensorboard --logdir /tmp`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Parallelization with tf.Estimator\n",
-    "\n",
-    "The estimator api makes it extremely easy to train on multiple GPUs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# suppose you have two cards\n",
-    "distribution = tf.distribute.MirroredStrategy([\"GPU:0\", \"GPU:1\"])\n",
-    "config = tf.estimator.RunConfig(train_distribute=distribution)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusions\n",
-    "\n",
-    "Congratulations! You can now train atomic neural networks with \n",
-    "state-of-the-art accuracy and speed.\n",
-    "\n",
-    "\n",
-    "But there's more. With PiNN, the components of ANNs are modulized.\n",
-    "Read the following notebooks to see how you can build your own ANN. "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pinn-tf2",
-   "language": "python",
-   "name": "pinn-tf2"
   },
-  "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.9.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 0
 }
diff --git a/docs/notebooks/Quick_tour.ipynb b/docs/notebooks/Quick_tour.ipynb
index a7bebd27..54dffa14 100644
--- a/docs/notebooks/Quick_tour.ipynb
+++ b/docs/notebooks/Quick_tour.ipynb
@@ -1,226 +1,313 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Quick tour with QM9 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Quick_tour.ipynb)\n",
-    "\n",
-    "This notebook showcases a simple example of training a neural network potential on the QM9 dataset with PiNN."
-   ]
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fpdvxf3cRk9t"
+      },
+      "source": [
+        "# Quick tour with QM9 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Teoroo-CMC/PiNN/blob/master/docs/notebooks/Quick_tour.ipynb)\n",
+        "\n",
+        "This notebook showcases a simple example of training a neural network potential on the QM9 dataset with PiNN."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2cuawGecRk9x"
+      },
+      "outputs": [],
+      "source": [
+        "#Install conda\n",
+        "!pip -q install konda\n",
+        "import konda\n",
+        "konda.install()\n",
+        "\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main\n",
+        "!conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r\n",
+        "\n",
+        "#Create the conda environment\n",
+        "!konda create -q -n pinn_env python=3.10 -y\n",
+        "!konda activate pinn_env\n",
+        "\n",
+        "# Install PiNN & download QM9 dataset\n",
+        "!konda run \"pip -q install 'tensorflow[and-cuda]==2.15.1' 'ase>=3.25' 'numpy<2'\"\n",
+        "!konda run \"pip -q install git+https://github.com/Teoroo-CMC/PiNN\"\n",
+        "!mkdir -p /tmp/dsgdb9nsd && curl -sSL https://ndownloader.figshare.com/files/3195389 | tar xj -C /tmp/dsgdb9nsd"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "3Uy6xiqgRk9y"
+      },
+      "outputs": [],
+      "source": [
+        "#The code is written into a python file and run with conda using !konda run\n",
+        "%%writefile quick_tour.py\n",
+        "\n",
+        "import os, warnings\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "from glob import glob\n",
+        "from ase.collections import g2\n",
+        "from pinn.io import load_qm9, sparse_batch\n",
+        "from pinn import get_model, get_calc\n",
+        "# CPU is used for documentation generation, feel free to use your GPU!\n",
+        "os.environ['CUDA_VISIBLE_DEVICES'] = ''\n",
+        "# We heavily use indexed slices to do sparse summations,\n",
+        "# which causes tensorflow to complain,\n",
+        "# we believe it's safe to ignore this warning.\n",
+        "index_warning = 'Converting sparse IndexedSlices'\n",
+        "warnings.filterwarnings('ignore', index_warning)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ExBdpoAURk9z"
+      },
+      "source": [
+        "## Getting the dataset\n",
+        "\n",
+        "PiNN adapts TensorFlow's dataset API to handle different datasets.\n",
+        "\n",
+        "For this and the following notebooks the QM9 dataset (https://doi.org/10.6084/m9.figshare.978904) is used.  \n",
+        "To follow the notebooks, download the dataset and change the directory accordingly.\n",
+        "\n",
+        "The dataset will be automatically split into subsets according to the split_ratio.  \n",
+        "Note that to use the dataset with the estimator, the datasets should be a function, instead of a dataset object."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Ckepr4ngRk9z"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile -a quick_tour.py\n",
+        "\n",
+        "filelist = glob('/tmp/dsgdb9nsd/*.xyz')\n",
+        "dataset = lambda: load_qm9(filelist, splits={'train':8, 'test':2})\n",
+        "train = lambda: dataset()['train'].repeat().shuffle(1000).apply(sparse_batch(100))\n",
+        "test = lambda: dataset()['test'].repeat().apply(sparse_batch(100))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "oYRPalWXRk90"
+      },
+      "source": [
+        "## Defining the model\n",
+        "In PiNN, models are defined at two levels: models and networks.\n",
+        "\n",
+        "- A model (model_fn) defines the target, loss and training detail.\n",
+        "- A network defines the structure of the neural network.\n",
+        "\n",
+        "In this example, we will use the potential model, and the PiNet network.\n",
+        "The configuration of a model is stored in a nested dictionary as shown below.\n",
+        "Available options of the network and model can be found in the documentation."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cLREeTn7Rk90"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile -a quick_tour.py\n",
+        "\n",
+        "import shutil\n",
+        "shutil.rmtree(\"/tmp/PiNet_QM9\", ignore_errors=True)\n",
+        "\n",
+        "params = {'model_dir': '/tmp/PiNet_QM9',\n",
+        "          'network': {\n",
+        "              'name': 'PiNet',\n",
+        "              'params': {\n",
+        "                  'depth': 4,\n",
+        "                  'rc':4.0,\n",
+        "                  'atom_types':[1,6,7,8,9]\n",
+        "              },\n",
+        "          },\n",
+        "          'model': {\n",
+        "              'name': 'potential_model',\n",
+        "              'params': {\n",
+        "                  'learning_rate': 1e-3\n",
+        "              }\n",
+        "          }\n",
+        "}\n",
+        "model = get_model(params)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "HG85IUo1Rk91"
+      },
+      "source": [
+        "## Configuring the training process\n",
+        "The defined model is indeed a [tf.Estimator](https://www.tensorflow.org/api_docs/python/tf/estimator/Estimator) object, thus, the training can be easily controlled"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "-6WaHQt5Rk91"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile -a quick_tour.py\n",
+        "\n",
+        "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=1000)\n",
+        "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=100)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "42kt7Q0oRk91"
+      },
+      "source": [
+        "## Train and evaluate"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NA1Grd8URk92"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile -a quick_tour.py\n",
+        "\n",
+        "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "qY835e-X7X7n"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python quick_tour.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1hs5e_3YRk92"
+      },
+      "source": [
+        "## Using the model\n",
+        "\n",
+        "The trained model can be used as an ASE calculator."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "4xC2N_oNRk92"
+      },
+      "outputs": [],
+      "source": [
+        "%%writefile using_model.py\n",
+        "\n",
+        "from ase.collections import g2\n",
+        "from pinn import get_calc\n",
+        "\n",
+        "import os\n",
+        "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+        "import tensorflow as tf\n",
+        "\n",
+        "params = {'model_dir': '/tmp/PiNet_QM92',\n",
+        "          'network': {\n",
+        "              'name': 'PiNet',\n",
+        "              'params': {\n",
+        "                  'depth': 4,\n",
+        "                  'rc':4.0,\n",
+        "                  'atom_types':[1,6,7,8,9]\n",
+        "              },\n",
+        "          },\n",
+        "          'model': {\n",
+        "              'name': 'potential_model',\n",
+        "              'params': {\n",
+        "                  'learning_rate': 1e-3\n",
+        "              }\n",
+        "          }\n",
+        "}\n",
+        "\n",
+        "calc = get_calc(params)\n",
+        "calc.properties = ['energy']\n",
+        "atoms = g2['C2H4']\n",
+        "atoms.set_calculator(calc)\n",
+        "atoms.get_forces(), atoms.get_potential_energy()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sqwt3FbkfpwN"
+      },
+      "outputs": [],
+      "source": [
+        "!konda run \"python using_model.py\""
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uyEVpjwbRk93"
+      },
+      "source": [
+        "## Conclusion\n",
+        "\n",
+        "You have trained your first PiNN model, though the accuracy is not so satisfying\n",
+        "(RMSE=21 Hartree!). Also, the training speed is slow as it's limited by the IO and\n",
+        "pre-processing of data.  \n",
+        "\n",
+        "We will show in following notebooks that:\n",
+        "\n",
+        "- Proper scaling of the energy will improve the accuracy of the model.\n",
+        "- The training speed can be enhanced by caching and pre-processing the data."
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "pinn-tf2",
+      "language": "python",
+      "name": "pinn-tf2"
+    },
+    "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.9.5"
+    }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Install PiNN & download QM9 dataset\n",
-    "!pip install 'tensorflow>=2.15,<2.16' 'numpy<2'\n",
-    "!pip install git+https://github.com/Teoroo-CMC/PiNN\n",
-    "!mkdir -p /tmp/dsgdb9nsd && curl -sSL https://ndownloader.figshare.com/files/3195389 | tar xj -C /tmp/dsgdb9nsd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os, warnings\n",
-    "import tensorflow as tf\n",
-    "from glob import glob\n",
-    "from ase.collections import g2\n",
-    "from pinn.io import load_qm9, sparse_batch\n",
-    "from pinn import get_model, get_calc\n",
-    "# CPU is used for documentation generation, feel free to use your GPU!\n",
-    "os.environ['CUDA_VISIBLE_DEVICES'] = '' \n",
-    "# We heavily use indexed slices to do sparse summations,\n",
-    "# which causes tensorflow to complain, \n",
-    "# we believe it's safe to ignore this warning.\n",
-    "index_warning = 'Converting sparse IndexedSlices'\n",
-    "warnings.filterwarnings('ignore', index_warning)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Getting the dataset\n",
-    "\n",
-    "PiNN adapts TensorFlow's dataset API to handle different datasets.\n",
-    "\n",
-    "For this and the following notebooks the QM9 dataset (https://doi.org/10.6084/m9.figshare.978904) is used.  \n",
-    "To follow the notebooks, download the dataset and change the directory accordingly.\n",
-    "\n",
-    "The dataset will be automatically split into subsets according to the split_ratio.  \n",
-    "Note that to use the dataset with the estimator, the datasets should be a function, instead of a dataset object."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "filelist = glob('/tmp/dsgdb9nsd/*.xyz')\n",
-    "dataset = lambda: load_qm9(filelist, splits={'train':8, 'test':2})\n",
-    "train = lambda: dataset()['train'].repeat().shuffle(1000).apply(sparse_batch(100))\n",
-    "test = lambda: dataset()['test'].repeat().apply(sparse_batch(100))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Defining the model\n",
-    "In PiNN, models are defined at two levels: models and networks. \n",
-    "\n",
-    "- A model (model_fn) defines the target, loss and training detail.\n",
-    "- A network defines the structure of the neural network.\n",
-    "\n",
-    "In this example, we will use the potential model, and the PiNet network.\n",
-    "The configuration of a model is stored in a nested dictionary as shown below.\n",
-    "Available options of the network and model can be found in the documentation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!rm -rf /tmp/PiNet_QM9\n",
-    "params = {'model_dir': '/tmp/PiNet_QM9',\n",
-    "          'network': {\n",
-    "              'name': 'PiNet',\n",
-    "              'params': {\n",
-    "                  'depth': 4,\n",
-    "                  'rc':4.0,\n",
-    "                  'atom_types':[1,6,7,8,9]\n",
-    "              },\n",
-    "          },\n",
-    "          'model': {\n",
-    "              'name': 'potential_model',\n",
-    "              'params': {\n",
-    "                  'learning_rate': 1e-3\n",
-    "              }\n",
-    "          }\n",
-    "}\n",
-    "model = get_model(params)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Configuring the training process\n",
-    "The defined model is indeed a [tf.Estimator](https://www.tensorflow.org/api_docs/python/tf/estimator/Estimator) object, thus, the training can be easily controlled"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_spec = tf.estimator.TrainSpec(input_fn=train, max_steps=1000)\n",
-    "eval_spec = tf.estimator.EvalSpec(input_fn=test, steps=100)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Train and evaluate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tf.estimator.train_and_evaluate(model, train_spec, eval_spec)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using the model\n",
-    "\n",
-    "The trained model can be used as an ASE calculator."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ase.collections import g2\n",
-    "from pinn import get_calc\n",
-    "params = {'model_dir': '/tmp/PiNet_QM92',\n",
-    "          'network': {\n",
-    "              'name': 'PiNet',\n",
-    "              'params': {\n",
-    "                  'depth': 4,\n",
-    "                  'rc':4.0,\n",
-    "                  'atom_types':[1,6,7,8,9]\n",
-    "              },\n",
-    "          },\n",
-    "          'model': {\n",
-    "              'name': 'potential_model',\n",
-    "              'params': {\n",
-    "                  'learning_rate': 1e-3\n",
-    "              }\n",
-    "          }\n",
-    "}\n",
-    "\n",
-    "calc = get_calc(params)\n",
-    "calc.properties = ['energy']\n",
-    "atoms = g2['C2H4']\n",
-    "atoms.set_calculator(calc)\n",
-    "atoms.get_forces(), atoms.get_potential_energy()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Conclusion\n",
-    "\n",
-    "You have trained your first PiNN model, though the accuracy is not so satisfying\n",
-    "(RMSE=21 Hartree!). Also, the training speed is slow as it's limited by the IO and \n",
-    "pre-processing of data.  \n",
-    "\n",
-    "We will show in following notebooks that:\n",
-    "\n",
-    "- Proper scaling of the energy will improve the accuracy of the model.\n",
-    "- The training speed can be enhanced by caching and pre-processing the data."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "pinn-tf2",
-   "language": "python",
-   "name": "pinn-tf2"
-  },
-  "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.9.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 0
 }

From 150234e928264b4a599255c6532a4a2ecd2c70f2 Mon Sep 17 00:00:00 2001
From: unknown <kadri.muuga@gmail.com>
Date: Tue, 15 Sep 2026 11:56:50 +0200
Subject: [PATCH 2/2] [doc] fix tf version conflict using konda

---
 docs/notebooks/More_on_training.ipynb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/notebooks/More_on_training.ipynb b/docs/notebooks/More_on_training.ipynb
index b1d6d46d..dfc1b241 100644
--- a/docs/notebooks/More_on_training.ipynb
+++ b/docs/notebooks/More_on_training.ipynb
@@ -539,12 +539,13 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 47,
+      "execution_count": null,
       "metadata": {
         "id": "Uw-V2aYXqpEE"
       },
       "outputs": [],
       "source": [
+        "#adding a dress to the whole QM9 dataset. running this cell might take some time.\n",
         "!konda run \"python atomic_dress.py\""
       ]
     },