diff --git a/.github/workflows/flare.yml b/.github/workflows/flare.yml index cf09ba3df..84b2abfce 100644 --- a/.github/workflows/flare.yml +++ b/.github/workflows/flare.yml @@ -112,6 +112,18 @@ jobs: cd tests pytest test_lammps.py + - name: Run tutorial + run: | + pip install -U jupyter nbconvert + cp tutorials/sparse_gp_tutorial.ipynb tutorial.ipynb + jupyter nbconvert --to script tutorial.ipynb + sed -i '/^get_ipython()/s/^/# /' tutorial.py + sed -i '/^plt/s/^/# /' tutorial.py + wget http://quantum-machine.org/gdml/data/npz/md17_aspirin.npz + wget https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy + python tutorial.py + rm Al* aluminum.txt aspirin.txt md17_aspirin.npz tutorial.ipynb tutorial.py + - name: Install Sphinx and Breathe run: | sudo apt-get update @@ -141,23 +153,3 @@ jobs: # Change the directory if changes in Doxyfile publish_dir: ./docs/build/html if: github.event_name == 'pull_request' && matrix.lapack == 'on' && matrix.omp == 'on' - -# - name: Run tutorial -# run: | -# cd tests -# # Download colab notebook -# export fileid="18_pTcWM19AUiksaRyCgg9BCpVyw744xv" -# wget -O tutorial.ipynb 'https://docs.google.com/uc?export=download&id='${fileid} -# # Convert notebook into python script -# pip install -U jupyter nbconvert -# jupyter nbconvert --to script tutorial.ipynb -# # Remove bash commands in the notebook -# sed '/!/d' tutorial.txt > tutorial.py -# cat test_tutorial.py tutorial.py > tuttest.py -# # Download datasets needed for the tutorial -# wget http://quantum-machine.org/gdml/data/npz/aspirin_dft.npz -# wget https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy -# # Run script -# pytest -s tuttest.py -# # Remove output files -# rm Al* aspirin_dft.npz tutorial.ipynb tuttest.py tutorial.py tutorial.txt diff --git a/.gitignore b/.gitignore index 24805b29f..6537c090e 100644 --- a/.gitignore +++ b/.gitignore @@ -73,3 +73,7 @@ _C_flare* **/xml **/dist **egg-info +tutorials/Al* +tutorials/*txt* +tutorials/*npz* +tutorials/*checkpoint* diff --git a/README.md b/README.md index fb849ff13..bf84bcc61 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,5 @@ [![Build Status](https://github.com/mir-group/flare/actions/workflows/flare.yml/badge.svg)](https://github.com/mir-group/flare/actions) [![pypi](https://img.shields.io/pypi/v/mir-flare)](https://pypi.org/project/mir-flare/) [![activity](https://img.shields.io/github/commit-activity/m/mir-group/flare)](https://github.com/mir-group/flare/commits/master) [![codecov](https://codecov.io/gh/mir-group/flare/branch/master/graph/badge.svg)](https://codecov.io/gh/mir-group/flare) -***NOTE: This is the latest release [1.3.3](https://github.com/mir-group/flare/releases/tag/1.3.3) which includes significant changes compared to the previous version [0.2.4](https://github.com/mir-group/flare/releases/tag/0.2.4). Please check the updated tutorials and documentations from the links below.*** - # FLARE: Fast Learning of Atomistic Rare Events

@@ -16,24 +14,16 @@ FLARE is an open-source Python package for creating fast and accurate interatomi

-Note: - -We implement Sparse GP, all the kernels and descriptors in C++ with Python interface. - -We implement Full GP, Mapped GP, RBCM, Squared Exponential kernel and 2+3-body descriptors in Python. - -Please do NOT mix them. - ## Documentations and Tutorials Documentation of the code can be accessed here: https://mir-group.github.io/flare [Applications using FLARE and gallery](https://mir-group.github.io/flare/related.html) -### Google Colab Tutorials +### Tutorials -[FLARE (ACE descriptors + sparse GP)](https://colab.research.google.com/drive/1QcHf5FVU_juZOvQ49FliJVzhon8MJ6PO) -The tutorial shows how to run flare with ACE and SGP on energy and force data, demoing "offline" training on the MD17 dataset and "online" on-the-fly training of a simple aluminum force field. +[FLARE (ACE descriptors + sparse GP)](https://github.com/mir-group/flare/blob/notebooks/tutorials/sparse_gp_tutorial.ipynb) +This tutorial shows how to run flare with a sparse Gaussian process model trained on energy and force data, demoing "offline" training on the MD17 dataset and "online" on-the-fly training of a simple aluminum force field. [FLARE (LAMMPS active learning)](https://bit.ly/flarelmpotf) This tutorial demonstrates new functionality for running active learning all within LAMMPS, with LAMMPS running the dynamics to allow arbitrarily complex molecular dynamics workflows while maintaining a simple interface. This also demonstrates how to use the C++ API directly from Python through `pybind11`. Finally, there's a simple demonstration of phonon calculations with FLARE using `phonopy`. diff --git a/docs/source/tutorials/colabs.rst b/docs/source/tutorials/colabs.rst index 218e3b6da..e2ae13d6b 100644 --- a/docs/source/tutorials/colabs.rst +++ b/docs/source/tutorials/colabs.rst @@ -1,20 +1,23 @@ FLARE: Active Learning Bayesian Force Fields ============================================ -We have a few Google Colab tutorials that you can check out and play with. +We have a few tutorial notebooks that you can check out and play with. -`FLARE (ACE descriptors + sparse GP `_. -The tutorial shows how to run flare with ACE and SGP on energy and force data, demoing "offline" training on the MD17 dataset and "online" on-the-fly training of a simple aluminum force field. All the trainings use yaml files for configuration. +`FLARE (ACE descriptors + sparse GP) `_. +This tutorial shows how to run flare with a sparse Gaussian process model trained on energy and force data, demoing "offline" training on the MD17 dataset and "online" on-the-fly training of a simple aluminum force field. `FLARE (ACE descriptors + sparse GP) with LAMMPS `_. The tutorial shows how to compile LAMMPS with FLARE pair style and uncertainty compute code, and use LAMMPS for Bayesian active learning and uncertainty-aware molecular dynamics. -`FLARE (ACE descriptors + sparse GP) Python API `_. -The tutorial shows how to do the offline and online trainings with python scripts. -A video walkthrough of the tutorial, including detailed discussion of expected outputs, is available `here `_. +`FLARE (LAMMPS active learning) `_. +This tutorial demonstrates new functionality for running active learning all within LAMMPS, with LAMMPS running the dynamics to allow arbitrarily complex molecular dynamics workflows while maintaining a simple interface. This also demonstrates how to use the C++ API directly from Python through `pybind11`. Finally, there's a simple demonstration of phonon calculations with FLARE using `phonopy`. -`FLARE (2+3-body + GP) `_. -The tutorial shows how to use flare 2+3 body descriptors and squared exponential kernel to train a Gaussian Process force field on-the-fly. +.. `FLARE (ACE descriptors + sparse GP) Python API `_. +.. The tutorial shows how to do the offline and online trainings with python scripts. +.. A video walkthrough of the tutorial, including detailed discussion of expected outputs, is available `here `_. + +.. `FLARE (2+3-body + GP) `_. +.. The tutorial shows how to use flare 2+3 body descriptors and squared exponential kernel to train a Gaussian Process force field on-the-fly. `Compute thermal conductivity from FLARE and Boltzmann transport equations `_. The tutorial shows how to use FLARE (LAMMPS) potential to compute lattice thermal conductivity from Boltzmann transport equation method, diff --git a/tutorials/sparse_gp_tutorial.ipynb b/tutorials/sparse_gp_tutorial.ipynb new file mode 100644 index 000000000..95ec0de8e --- /dev/null +++ b/tutorials/sparse_gp_tutorial.ipynb @@ -0,0 +1,3717 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "17b6981f-25a2-4ddd-91aa-ea4904347199", + "metadata": {}, + "source": [ + "## Learning many-body force fields on the fly: A tutorial introduction to the FLARE++ code\n", + "### Jonathan Vandermause (jonpvandermause@gmail.com)" + ] + }, + { + "cell_type": "markdown", + "id": "a4423b03", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/intro.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7b4a8630-5df7-4be6-8616-1860b20d8d3d", + "metadata": {}, + "source": [ + "**Learning objectives:**\n", + " * Train many-body sparse Gaussian process models on _ab initio_ force data using the [flare_pp](https://github.com/mir-group/flare_pp) code.\n", + " * Use the uncertainties of the sparse GP to train a force field on the fly using the [flare](https://github.com/mir-group/flare) code." + ] + }, + { + "cell_type": "markdown", + "id": "c484d882-308e-4416-9d40-fe636f51ea67", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, + { + "cell_type": "markdown", + "id": "e2fdf409-c4ca-43ce-bafb-16db431b3f11", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/md_review.png)" + ] + }, + { + "cell_type": "markdown", + "id": "0c7595d5-3b77-45bc-97c1-5a249afafd0a", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/flare_overview.png)" + ] + }, + { + "cell_type": "markdown", + "id": "01f9499c-e133-4de5-8f77-f2f4bcba4b35", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "c9c19d11-bf68-45a4-9d14-cb5c761fca23", + "metadata": {}, + "source": [ + "We can now import everything we'll need for the tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "26a415d3-d08e-4f7c-9a88-556ce770189a", + "metadata": {}, + "outputs": [], + "source": [ + "# Import numpy and matplotlib\n", + "import numpy as np\n", + "from numpy.random import random\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "\n", + "# Increase the matplotlib font size.\n", + "font = {'size': 22}\n", + "\n", + "matplotlib.rc('font', **font)\n", + "\n", + "# flare++ imports\n", + "from flare.bffs.sgp import SGP_Wrapper\n", + "from flare.bffs.sgp.calculator import SGP_Calculator\n", + "from flare.bffs.sgp._C_flare import B2, NormalizedDotProduct, SparseGP, Structure\n", + "\n", + "# flare imports\n", + "from flare.learners.otf import OTF\n", + "from flare.io import otf_parser\n", + "\n", + "# ASE imports\n", + "from ase import Atoms, units\n", + "from ase.calculators.eam import EAM\n", + "from ase.build import supercells\n", + "from ase.visualize import view\n", + "from ase.md.velocitydistribution import MaxwellBoltzmannDistribution, \\\n", + " Stationary, ZeroRotation\n", + "from ase.build import fcc111, add_adsorbate\n", + "from ase.io import write" + ] + }, + { + "cell_type": "markdown", + "id": "bac8a434-f120-4b8e-bcb0-c4692594c615", + "metadata": {}, + "source": [ + "## Training a many-body force field on static data" + ] + }, + { + "cell_type": "markdown", + "id": "9a084618-f3eb-443d-a6a8-f893ea5e8039", + "metadata": {}, + "source": [ + "Let's start by training a force field \"offline\" on an already existing dataset of _ab initio_ forces." + ] + }, + { + "cell_type": "markdown", + "id": "a2ba851f-4597-4fb1-b83e-873bf88491e9", + "metadata": {}, + "source": [ + "### Training data" + ] + }, + { + "cell_type": "markdown", + "id": "4ae37fa7-f1f5-48bd-a513-f74f0be27597", + "metadata": {}, + "source": [ + "To train our model we'll use the MD17 dataset introduced in Refs. [1-3], which contains energies and forces from _ab initio_ MD trajectories of eight small organic molecules.\n", + "\n", + "[[1] S. Chmiela, A. Tkatchenko, H. E. Sauceda, I. Poltavsky, K. T. Schütt, K.-R. Müller. Sci. Adv. 3(5), e1603015, 2017.](https://advances.sciencemag.org/content/3/5/e1603015)\n", + "\n", + "[[2] K. T. Schütt, F. Arbabzadah, S. Chmiela, K.-R. Müller, A. Tkatchenko. Nat. Commun. 8, 13890, 2017.](https://www.nature.com/articles/ncomms13890)\n", + "\n", + "[[3] S. Chmiela, H. E. Sauceda, K.-R. Müller, A. Tkatchenko. Nat. Commun. 9, 3887, 2018.](https://www.nature.com/articles/s41467-018-06169-2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "711de343-5dbd-40d5-9d00-754584cbfbe1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-15 14:59:48-- http://quantum-machine.org/gdml/data/npz/md17_aspirin.npz\n", + "Resolving quantum-machine.org (quantum-machine.org)... 130.149.80.145\n", + "Connecting to quantum-machine.org (quantum-machine.org)|130.149.80.145|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 202398748 (193M)\n", + "Saving to: ‘md17_aspirin.npz.2’\n", + "\n", + "md17_aspirin.npz.2 100%[===================>] 193.02M 9.10MB/s in 18s \n", + "\n", + "2024-09-15 15:00:07 (10.5 MB/s) - ‘md17_aspirin.npz.2’ saved [202398748/202398748]\n", + "\n" + ] + } + ], + "source": [ + "# Download the data.\n", + "! wget http://quantum-machine.org/gdml/data/npz/md17_aspirin.npz" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c37f836-b24c-4542-8580-50c6aac3325b", + "metadata": {}, + "outputs": [], + "source": [ + "# Load training data.\n", + "data_file = \"md17_aspirin.npz\"\n", + "data = np.load(data_file)\n", + "n_strucs = len(data['E'])\n", + "\n", + "# Define species as ints starting from 0.\n", + "species = data['z']\n", + "species_code = {'6': 0, '8': 1, '1': 2}\n", + "\n", + "coded_species = []\n", + "for spec in species:\n", + " coded_species.append(species_code[str(spec)])\n", + "\n", + "# Define positions, forces, and the unit cell.\n", + "forces = data['F'] # kcal/mol/A\n", + "positions = data['R'] # A\n", + "cell = np.eye(3) * 100\n", + "noa = len(species)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bb253fd4-2772-4af2-9e49-2dad9cb6d9d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + "\n", + " ASE atomic visualization\n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize an aspirin molecule.\n", + "frame = 100000\n", + "structure = Atoms(\n", + " positions=positions[frame],\n", + " numbers=species,\n", + " cell=cell\n", + " )\n", + "view(structure, viewer='x3d')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7a65be7b-ef3a-4b51-96da-83874297cd2f", + "metadata": {}, + "outputs": [], + "source": [ + "# Choose training and validation structures.\n", + "training_size = 100\n", + "validation_size = 20\n", + "np.random.seed(1)\n", + "shuffled_frames = [int(n) for n in range(n_strucs)]\n", + "np.random.shuffle(shuffled_frames)\n", + "\n", + "training_pts = shuffled_frames[0:training_size]\n", + "validation_pts = shuffled_frames[training_size:training_size+validation_size]" + ] + }, + { + "cell_type": "markdown", + "id": "aa718222-4a5e-4b4f-9c90-3a896c55af55", + "metadata": {}, + "source": [ + "### Training a many-body sparse GP model" + ] + }, + { + "cell_type": "markdown", + "id": "95c3a02c-2ce6-4bcf-9a8e-0d05feb57dce", + "metadata": {}, + "source": [ + "We're now ready to train a sparse GP force field. Our approach follows the Gaussian Approximation Potential framework first introduced in Ref. [4] (see [5] for an excellent introduction), with a multi-element generalization of the Atomic Cluster Expansion [6] used to build rotationally-invariant many-body descriptors of local atomic environments.\n", + "\n", + "[[4] Bartók, A. P., Payne, M. C., Kondor, R., & Csányi, G. (2010). Physical review letters, 104(13), 136403.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.104.136403)\n", + "\n", + "[[5] Bartók, A. P., & Csányi, G. (2015). International Journal of Quantum Chemistry, 115(16), 1051-1057.](https://onlinelibrary.wiley.com/doi/full/10.1002/qua.24927)\n", + "\n", + "[[6] Drautz, R. (2019). Physical Review B, 99(1), 014104.](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.99.014104)" + ] + }, + { + "cell_type": "markdown", + "id": "e1c6c8eb-779c-4745-86fa-297a08f812c6", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/mb_models.png)" + ] + }, + { + "cell_type": "markdown", + "id": "1837af40-6a99-4914-8d2a-62b97d3fcc29", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/mb_descriptors.png)" + ] + }, + { + "cell_type": "markdown", + "id": "1775c7c3-a59e-4e93-86b0-3d46dd76a218", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/gpff.png)" + ] + }, + { + "cell_type": "markdown", + "id": "5902effc-6cf1-47ed-9598-641f9d572515", + "metadata": {}, + "source": [ + "To define a sparse GP force field, we need to choose a descriptor $\\vec{d}(\\rho_i)$ of local atomic environments $\\rho_i$ and a kernel $k(\\vec{d}_1, \\vec{d}_2)$ for comparing these descriptors.\n", + "\n", + "We'll use the $B_2$ descriptor from the Atomic Cluster Expansion, which requires us to define:\n", + "\n", + "\n", + "* The cutoff function and radius.\n", + "* The type and number of radial basis functions.\n", + "* The number of spherical harmonics.\n", + "\n", + "These are hyperparameters of the model, and it's generally a good idea to check how different choices of hyperparameters influence model accuracy. Here we'll use values that work well for the MD17 dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1a55e007-bc1f-46b3-874e-4e4a0fcad886", + "metadata": {}, + "outputs": [], + "source": [ + "# Define many-body descriptor.\n", + "cutoff = 3.7 # A\n", + "n_species = 3 # Carbon, Oxygen, Hydrogen\n", + "N = 12 # Number of radial basis functions\n", + "lmax = 3 # Largest L included in spherical harmonics\n", + "radial_basis = \"chebyshev\" # Radial basis set\n", + "cutoff_name = \"quadratic\" # Cutoff function\n", + "radial_hyps = [0, cutoff]\n", + "cutoff_hyps = []\n", + "descriptor_settings = [n_species, N, lmax]\n", + "\n", + "# Define a B2 object.\n", + "B2_descriptor = B2(radial_basis, cutoff_name, radial_hyps, cutoff_hyps,\n", + " descriptor_settings)\n", + "\n", + "# The GP class can take a list of descriptors as input, but here\n", + "# we'll use a single descriptor.\n", + "descriptors = [B2_descriptor]" + ] + }, + { + "cell_type": "markdown", + "id": "baa578ed-2330-4d79-8f03-5512e6c78729", + "metadata": {}, + "source": [ + "Next, we define our kernel function. We'll use a simple normalized dot product kernel:\n", + "\\begin{equation}\n", + "k(\\vec{d}_1, \\vec{d}_2) = \\sigma \\left(\\frac{\\vec{d}_1 \\cdot \\vec{d}_2}{d_1 d_2}\\right)^2.\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0391c0bf-1bb4-4950-9ae9-c0c5bddd5728", + "metadata": {}, + "outputs": [], + "source": [ + "# Define kernel function.\n", + "sigma = 2.0\n", + "power = 2\n", + "dot_product_kernel = NormalizedDotProduct(sigma, power)\n", + "\n", + "# Define a list of kernels.\n", + "# There needs to be one kernel for each descriptor.\n", + "kernels = [dot_product_kernel]" + ] + }, + { + "cell_type": "markdown", + "id": "bd8ad198-1f66-435f-8d14-f53f501aebfe", + "metadata": {}, + "source": [ + "With the kernel object defined, we can construct a sparse GP object. To do this, we need to choose noise values for each type of label: energies, forces, and stresses (though in this example we'll train on forces only). It's a good idea to initialize these values to the expected error level for each quantity." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2050d858-926e-41d8-bc0c-a73b19095ea3", + "metadata": {}, + "outputs": [], + "source": [ + "# Define sparse GP.\n", + "sigma_e = 0.12 * noa # Energy noise (in kcal/mol, so about 5 meV/atom)\n", + "sigma_f = 0.115 # Force noise (in kcal/mol/A, so about 5 meV/A)\n", + "sigma_s = 0.014 # Stress noise (in kcal/A^3, so about 0.1 GPa)\n", + "gp_model = SparseGP(kernels, sigma_e, sigma_f, sigma_s)" + ] + }, + { + "cell_type": "markdown", + "id": "f83b659b-659c-4381-9013-9c20e28b6f1d", + "metadata": {}, + "source": [ + "We now compute the descriptors and descriptor gradients of the training and validation structures and assign force labels to the training structures." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9c3a736e-9049-433c-9c45-c7fd12fe234a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing descriptors of validation points...\n", + "Done.\n", + "Computing descriptors of training points...\n", + "Done.\n" + ] + } + ], + "source": [ + "# Calculate descriptors of the validation and training structures.\n", + "print(\"Computing descriptors of validation points...\")\n", + "validation_strucs = []\n", + "validation_forces = np.zeros((validation_size, noa, 3))\n", + "for n, snapshot in enumerate(validation_pts):\n", + " pos = positions[snapshot]\n", + " frcs = forces[snapshot]\n", + "\n", + " # Create structure object, which computes and stores descriptors.\n", + " struc = \\\n", + " Structure(cell, coded_species, pos, cutoff, descriptors)\n", + " validation_strucs.append(struc)\n", + " validation_forces[n] = frcs\n", + "print(\"Done.\")\n", + "\n", + "print(\"Computing descriptors of training points...\")\n", + "training_strucs = []\n", + "training_forces = np.zeros((training_size, noa, 3))\n", + "for n, snapshot in enumerate(training_pts):\n", + " pos = positions[snapshot]\n", + " frcs = forces[snapshot]\n", + "\n", + " # Create structure object, which computes and stores descriptors.\n", + " struc = \\\n", + " Structure(cell, coded_species, pos, cutoff, descriptors)\n", + "\n", + " # Assign force labels to the training structure.\n", + " struc.forces = frcs.reshape(-1)\n", + "\n", + " training_strucs.append(struc)\n", + " training_forces[n] = frcs\n", + "print(\"Done.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d1c69ba6-0661-4548-95e6-cde2dbe4278a", + "metadata": {}, + "source": [ + "Finally, we train the sparse GP and check its performance on the validation set as more data is added. When we add structures to the GP, we need to choose which environments get added to the sparse set. For simplicity, in this example, we'll add all environments to the sparse set (which is theoretically accuracy-maximizing but may introduce redundancy). In our second example below, we'll use the GP uncertainties to select the sparse environments in an online fashion during molecular dynamics." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8df7b8c9-a487-4294-9778-15a785289b7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training the GP...\n", + "Batch 1 MAE: 7.10 kcal/mol/A\n", + "Batch 2 MAE: 4.29 kcal/mol/A\n", + "Batch 3 MAE: 3.17 kcal/mol/A\n", + "Batch 4 MAE: 2.61 kcal/mol/A\n", + "Batch 5 MAE: 2.22 kcal/mol/A\n", + "Batch 6 MAE: 2.02 kcal/mol/A\n", + "Batch 7 MAE: 1.86 kcal/mol/A\n", + "Batch 8 MAE: 1.68 kcal/mol/A\n", + "Batch 9 MAE: 1.57 kcal/mol/A\n", + "Batch 10 MAE: 1.49 kcal/mol/A\n" + ] + } + ], + "source": [ + "# Train the model.\n", + "print(\"Training the GP...\")\n", + "batch_size = 10 # monitor the MAE after adding this many frames\n", + "n_strucs = np.zeros(batch_size)\n", + "mb_maes = np.zeros(batch_size)\n", + "for m in range(training_size):\n", + " train_struc = training_strucs[m]\n", + "\n", + " # Add training structure and sparse environments.\n", + " gp_model.add_training_structure(train_struc)\n", + " gp_model.add_all_environments(train_struc)\n", + "\n", + " if (m + 1) % batch_size == 0:\n", + " # Update the sparse GP training coefficients.\n", + " gp_model.update_matrices_QR()\n", + "\n", + " # Predict on the validation set.\n", + " pred_forces = np.zeros((validation_size, noa, 3))\n", + " for n, test_struc in enumerate(validation_strucs):\n", + " gp_model.predict_SOR(test_struc)\n", + " pred_vals = test_struc.mean_efs[1:-6].reshape(noa, 3)\n", + " pred_forces[n] = pred_vals\n", + "\n", + " # Calculate and store the MAE.\n", + " batch_no = int((m + 1) / batch_size)\n", + " mae = np.mean(np.abs(validation_forces - pred_forces))\n", + " n_strucs[batch_no - 1] = batch_size * batch_no\n", + " mb_maes[batch_no - 1] = mae\n", + " print(\"Batch %i MAE: %.2f kcal/mol/A\" % (batch_no, mae))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5899fbd6-81f1-4874-856d-cbed9e86ae34", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the learning curve.\n", + "plt.figure(figsize=(16, 8))\n", + "plt.loglog(n_strucs, mb_maes, label=\"flare++\")\n", + "plt.loglog(1000, 0.0429 * 23, 'g.', markersize=20, label=\"GDML\")\n", + "plt.loglog(1000, 0.0295 * 23, 'r.', markersize=20, label=\"sGDML\")\n", + "plt.title(\"Learning curve\")\n", + "plt.xlabel(\"Number of training structures\")\n", + "plt.ylabel(\"MAE (kcal/mol/A)\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b2785640-0653-4193-b04d-853dd7d2f297", + "metadata": {}, + "source": [ + "### Mapping the trained model" + ] + }, + { + "cell_type": "markdown", + "id": "8de44f0e-a90e-4737-a0ed-9b2475a7e097", + "metadata": {}, + "source": [ + "We can map the trained sparse GP onto a fast quadratic model implemented in lammps with the following lines:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01f5c6fc-9532-440b-a23f-6d350032b758", + "metadata": {}, + "outputs": [], + "source": [ + "# Write lammps potential file.\n", + "file_name = \"aspirin.txt\"\n", + "contributor = \"Your Name Here\"\n", + "\n", + "# The \"kernel index\" indicates which kernel to map for multi-descriptor models.\n", + "# For single-descriptor models like this one, just set it to 0.\n", + "kernel_index = 0\n", + "\n", + "gp_model.write_mapping_coefficients(file_name, contributor, kernel_index)" + ] + }, + { + "cell_type": "markdown", + "id": "e5825173-1b93-4dd6-80d9-ce9c38985eaf", + "metadata": {}, + "source": [ + "If you click on the Files tab on the left hand side of the screen, you'll see the lammps potential file that we just wrote. This can be used to perform efficient MD simulations in lammps using the custom \"flare\" pairstyle." + ] + }, + { + "cell_type": "markdown", + "id": "eb4ff8d2-2e59-4660-92f0-41190bf8ea26", + "metadata": {}, + "source": [ + "## Learning a many-body force field on the fly" + ] + }, + { + "cell_type": "markdown", + "id": "be3b1daf-e4e6-4bae-850d-62447ebf732e", + "metadata": {}, + "source": [ + "We're now ready to train a force field on the fly. In real applications, you would want to use a DFT code or some other quantum solver to compute reference energies and forces, but here for simplicity our goal will be to re-construct a many-body EAM potential on the fly." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5cf27ac0-b4d7-4911-96fa-1851867280b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2024-09-15 15:01:56-- https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy\n", + "Resolving www.ctcms.nist.gov (www.ctcms.nist.gov)... 129.6.13.19\n", + "Connecting to www.ctcms.nist.gov (www.ctcms.nist.gov)|129.6.13.19|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 780452 (762K)\n", + "Saving to: ‘Al99.eam.alloy.2’\n", + "\n", + "Al99.eam.alloy.2 100%[===================>] 762.16K --.-KB/s in 0.08s \n", + "\n", + "2024-09-15 15:01:56 (8.98 MB/s) - ‘Al99.eam.alloy.2’ saved [780452/780452]\n", + "\n" + ] + } + ], + "source": [ + "# Download an aluminum EAM potential from the NIST potential database.\n", + "! wget https://www.ctcms.nist.gov/potentials/Download/1999--Mishin-Y-Farkas-D-Mehl-M-J-Papaconstantopoulos-D-A--Al/2/Al99.eam.alloy" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9ff97c98-a8d1-4f37-9d2c-472e808f5f96", + "metadata": {}, + "outputs": [], + "source": [ + "# Define modified EAM calculator with null stress.\n", + "from ase.calculators.calculator import all_changes\n", + "class EAM_mod(EAM):\n", + " implemented_properties = [\"energy\", \"forces\", \"stress\", \"stresses\"]\n", + " def calculate(self, atoms=None, properties=['energy'],\n", + " system_changes=all_changes):\n", + " super().calculate(atoms, properties, system_changes)\n", + " self.results['stress'] = np.zeros(6)\n", + " self.results['stresses'] = np.zeros(6)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7d3fc3fc-52a7-4999-bda5-94e7c830722f", + "metadata": {}, + "outputs": [], + "source": [ + "# Define ASE calculator.\n", + "eam_potential = EAM_mod(potential=\"Al99.eam.alloy\")" + ] + }, + { + "cell_type": "markdown", + "id": "79ad9211-c522-4524-a8cf-b81f233148f4", + "metadata": {}, + "source": [ + "To train a sparse GP on the fly, we follow four basic steps." + ] + }, + { + "cell_type": "markdown", + "id": "1ea3fa89-f9dd-4e5f-a195-dceb27112026", + "metadata": {}, + "source": [ + "### Step 1: Choose the initial structure." + ] + }, + { + "cell_type": "markdown", + "id": "d9720954-105a-4c01-a3f0-66042b268a6f", + "metadata": {}, + "source": [ + "We'll simulate an adatom on an aluminum slab to illustrate what happens when one local environment doesn't resemble any of the others in the structure." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a2a72795-c4ef-4a8d-8751-44c14a169669", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + "\n", + " ASE atomic visualization\n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a slab with an adatom.\n", + "atoms = fcc111(\"Al\", (4, 4, 6), vacuum=10.0)\n", + "add_adsorbate(atoms, \"Al\", 2.5, \"ontop\")\n", + "n_atoms = len(atoms)\n", + "\n", + "# Randomly jitter the atoms to give nonzero forces in the first frame.\n", + "jitter_factor = 0.1\n", + "for atom_pos in atoms.positions:\n", + " for coord in range(3):\n", + " atom_pos[coord] += (2 * random() - 1) * jitter_factor\n", + "\n", + "view(atoms, viewer='x3d')" + ] + }, + { + "cell_type": "markdown", + "id": "dd25ea69-af3f-4240-a96a-6c28cc2feaa8", + "metadata": {}, + "source": [ + "### Step 2: Choose molecular dynamics settings." + ] + }, + { + "cell_type": "markdown", + "id": "df739f0d-7fc1-4aa3-a5ec-6ee53c24b565", + "metadata": {}, + "source": [ + "We'll set the initial temperature to 200 K and simulate in the NVE ensemble. In many applications, it's useful to add thermostats and barostats to control temperature and pressure." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "5e1617ba-3768-4912-bf61-4a20e4dc8bcf", + "metadata": {}, + "outputs": [], + "source": [ + "# Set MD parameters.\n", + "md_engine = \"VelocityVerlet\"\n", + "md_dict = {}\n", + "\n", + "# Set the initial velocity to 300 K.\n", + "temperature = 300 # in K\n", + "MaxwellBoltzmannDistribution(atoms, temperature_K=temperature)\n", + "Stationary(atoms) # zero linear momentum\n", + "ZeroRotation(atoms) # zero angular momentum" + ] + }, + { + "cell_type": "markdown", + "id": "78338421-cfd2-40d3-a1fc-51553a351b6e", + "metadata": {}, + "source": [ + "### Step 3: Choose model settings." + ] + }, + { + "cell_type": "markdown", + "id": "64a9ad05-694a-4ba7-b0e0-0670bf187fab", + "metadata": {}, + "source": [ + "In addition to the quantities we encountered earlier (cutoff, basis set, and noise values), we'll also choose the type of uncertainties we want to compute and choose settings for hyperparameter optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "126a63fc-3ab6-4bc3-876a-4bf2d6672826", + "metadata": {}, + "outputs": [], + "source": [ + "# Create sparse GP model.\n", + "species_map = {13: 0} # Aluminum (atomic number 13) is species 0\n", + "cutoff = 5.0 # in A\n", + "sigma = 2.0 # in eV\n", + "power = 2 # power of the dot product kernel\n", + "kernel = NormalizedDotProduct(sigma, power)\n", + "cutoff_function = \"quadratic\"\n", + "many_body_cutoffs = [cutoff]\n", + "radial_basis = \"chebyshev\"\n", + "radial_hyps = [0., cutoff]\n", + "cutoff_hyps = []\n", + "n_species = 1\n", + "N = 8\n", + "lmax = 3\n", + "descriptor_settings = [n_species, N, lmax]\n", + "descriptor_calculator = B2(\n", + " radial_basis,\n", + " cutoff_function,\n", + " radial_hyps,\n", + " cutoff_hyps,\n", + " descriptor_settings\n", + ")\n", + "\n", + "# Set the noise values.\n", + "sigma_e = 0.001 * n_atoms # eV (1 meV/atom)\n", + "sigma_f = 0.05 # eV/A\n", + "sigma_s = 0.0006 # eV/A^3 (about 0.1 GPa)\n", + "\n", + "# Choose uncertainty type.\n", + "# Other options are \"DTC\" (Deterministic Training Conditional) or\n", + "# \"SOR\" (Subset of Regressors).\n", + "variance_type = \"local\" # Compute uncertainties on local energies (normalized)\n", + "\n", + "# Choose settings for hyperparameter optimization.\n", + "max_iterations = 20 # Max number of BFGS iterations during optimization\n", + "opt_method = \"L-BFGS-B\" # Method used for hyperparameter optimization\n", + "\n", + "# Bounds for hyperparameter optimization.\n", + "# Keeps the energy noise from going to zero.\n", + "bounds = [(None, None), (sigma_e, None), (None, None), (None, None)]\n", + "\n", + "# Create a model wrapper that is compatible with the flare code.\n", + "gp_model = SGP_Wrapper(\n", + " [kernel],\n", + " [descriptor_calculator],\n", + " cutoff,\n", + " sigma_e,\n", + " sigma_f,\n", + " sigma_s,\n", + " species_map,\n", + " variance_type=variance_type,\n", + " stress_training=False,\n", + " opt_method=opt_method,\n", + " bounds=bounds,\n", + " max_iterations=max_iterations,\n", + ")\n", + "\n", + "# Create an ASE calculator based on the GP model.\n", + "flare_calculator = SGP_Calculator(gp_model)" + ] + }, + { + "cell_type": "markdown", + "id": "5eab7b5f-734f-4c0c-8ed7-cf0b30d259d8", + "metadata": {}, + "source": [ + "### Step 4: Choose on-the-fly settings." + ] + }, + { + "cell_type": "markdown", + "id": "c2a821dc-88f4-4912-8f70-596a55b3820f", + "metadata": {}, + "source": [ + "There are two important choices to make here:\n", + " \n", + "\n", + "* The uncertainty tolerance (defined as `std_tolerance_factor` below) determines when calls to DFT are made. Because we are computing normalized uncertainties on local energies, a reasonable value is around 1%. A higher value will trigger fewer DFT calls but may reduce the accuracy of the model, so in practice it's a good idea to try out a few different values. Note that a positive `std_tolerance_factor` defines the tolerance as a fraction of the noise parameter, while a negative value defines it in absolute terms.\n", + "* `update_style` specifies the strategy for adding sparse environments to the GP. Here we set it to the `threshold` style, which only adds sparse environments if their associated uncertainty is above the defined `update_threshold`. This helps eliminate redundancy from the sparse set." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "89b2d2d2-5ae9-4d15-8392-10494f27e035", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonpvandermause/opt/anaconda3/envs/flare/lib/python3.8/site-packages/ase/io/extxyz.py:302: UserWarning: Skipping unhashable information adsorbate_info\n", + " warnings.warn('Skipping unhashable information '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing KnK for hyps optimization\n", + "Done precomputing. Time: 0.0010421276092529297\n", + "Hyperparameters:\n", + "[2.0e+00 9.7e-02 5.0e-02 6.0e-04]\n", + "Likelihood gradient:\n", + "[ 3.88454269e+00 -2.53811289e+01 -4.61502958e+03 0.00000000e+00]\n", + "Likelihood:\n", + "496.9523422459526\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00084172e+00 9.70000000e-02 -9.49999646e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 8.81171283 9.53863317 294.70584229 0. ]\n", + "Likelihood:\n", + "-273.13980132875474\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00021607e+00 9.70000000e-02 -2.06703902e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[-5.56211555e-01 2.56149274e+01 1.27550367e+03 0.00000000e+00]\n", + "Likelihood:\n", + "143.0220439002223\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00004998e+00 9.70000000e-02 -9.38200937e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 1.38830809e+01 6.59317595e-01 -6.88773446e+02 0.00000000e+00]\n", + "Likelihood:\n", + "764.9631346072256\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00029524e+00 9.70790601e-02 -1.98005747e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[6.24527236e+00 1.37850193e+01 8.68110959e+03 0.00000000e+00]\n", + "Likelihood:\n", + "688.9928437406343\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005588e+00 9.70019002e-02 -9.63242489e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 12.46534312 -1.73945138 482.45900702 0. ]\n", + "Likelihood:\n", + "764.9854752482242\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005634e+00 9.70009901e-02 -9.52933390e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 12.37820449 -13.43240518 17.10528882 0. ]\n", + "Likelihood:\n", + "765.0119620311032\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005918e+00 9.70000000e-02 -9.52550002e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[10.53359104 -3.69629167 -0.3691925 0. ]\n", + "Likelihood:\n", + "765.0119614664445\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005716e+00 9.70007056e-02 -9.52823231e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[11.23037361 6.71823909 11.85842682 0. ]\n", + "Likelihood:\n", + "765.0117510453636\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005636e+00 9.70009834e-02 -9.52930819e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 9.91067212 -2.52377854 17.79785914 0. ]\n", + "Likelihood:\n", + "765.0118090780127\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005634e+00 9.70009901e-02 -9.52933387e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[12.98822593 5.28487879 17.29337001 0. ]\n", + "Likelihood:\n", + "765.0117304692324\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005634e+00 9.70009901e-02 -9.52933390e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[12.7411176 5.71404932 17.71057732 0. ]\n", + "Likelihood:\n", + "765.0116997917396\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005634e+00 9.70009901e-02 -9.52933390e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[11.75848148 4.58594837 17.7926624 0. ]\n", + "Likelihood:\n", + "765.0118232404598\n", + "\n", + "\n", + "Precomputing KnK for hyps optimization\n", + "Done precomputing. Time: 0.0007660388946533203\n", + "Hyperparameters:\n", + "[ 2.00005634e+00 9.70009901e-02 -9.52933390e-03 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 20.91042177 -22.5002633 -6848.65832138 0. ]\n", + "Likelihood:\n", + "1631.5422400563862\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00310954e+00 9.70009899e-02 -1.00952467e+00 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 0.64989133 21.29972502 562.89216246 0. ]\n", + "Likelihood:\n", + "-564.7398429483189\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00069489e+00 9.70009900e-02 -2.18668838e-01 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[7.88271332e-01 4.00970265e-01 2.50054513e+03 0.00000000e+00]\n", + "Likelihood:\n", + "290.29623270911554\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00013675e+00 9.70009901e-02 -3.58666676e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[-4.30678130e-01 4.16004056e+00 1.31926232e+04 0.00000000e+00]\n", + "Likelihood:\n", + "1229.1052404109846\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006267e+00 9.70009901e-02 -1.16033678e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 13.60532614 -23.49856093 9859.02773984 0. ]\n", + "Likelihood:\n", + "1625.6259977706663\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00005828e+00 9.70009901e-02 -1.01660095e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 20.01157677 -52.5244595 113.76639985 0. ]\n", + "Likelihood:\n", + "1633.572846724618\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006008e+00 9.70000000e-02 -1.01556158e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 14.44517786 -29.66308222 14.42346671 0. ]\n", + "Likelihood:\n", + "1633.574350072291\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006179e+00 9.70000000e-02 -1.01539206e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 18.37554921 -15.97436039 0.69332392 0. ]\n", + "Likelihood:\n", + "1633.5754467699167\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006965e+00 9.70000000e-02 -1.01492970e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 19.00618218 3.66934723 -44.56860562 0. ]\n", + "Likelihood:\n", + "1633.5751068463132\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006228e+00 9.70000000e-02 -1.01536330e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 16.61479847 -26.33821817 -4.33796968 0. ]\n", + "Likelihood:\n", + "1633.573692926107\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006179e+00 9.70000000e-02 -1.01539203e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[16.88594609 24.9079317 -0.69107137 0. ]\n", + "Likelihood:\n", + "1633.5748342539732\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006179e+00 9.70000000e-02 -1.01539206e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[ 18.58037145 -15.41727721 -0.6506331 0. ]\n", + "Likelihood:\n", + "1633.5747576596177\n", + "\n", + "\n", + "Hyperparameters:\n", + "[ 2.00006179e+00 9.70000000e-02 -1.01539206e-02 6.00000000e-04]\n", + "Likelihood gradient:\n", + "[12.85278617 17.20242214 -0.63220595 0. ]\n", + "Likelihood:\n", + "1633.574867664227\n", + "\n", + "\n" + ] + } + ], + "source": [ + "# Set up OTF object.\n", + "init_atoms = list(range(n_atoms)) # Initial environments to include in the sparse set\n", + "output_name = 'Al' # Name of the output file\n", + "std_tolerance_factor = -0.01 # Uncertainty tolerance for calling QM\n", + "train_hyps = (0, 2) # Freeze hyperparameter optimization after second QM call\n", + "min_steps_with_model = 10 # Min number of steps between DFT calls\n", + "update_style = \"threshold\" # Strategy for adding sparse environments\n", + "update_threshold = 0.005 # Threshold for determining which sparse environments to add\n", + "force_only = False # Train only on forces or include energies and stresses\n", + "\n", + "otf_params = {\n", + " 'init_atoms': init_atoms,\n", + " 'output_name': output_name,\n", + " 'std_tolerance_factor': std_tolerance_factor,\n", + " 'train_hyps': train_hyps,\n", + " 'min_steps_with_model': min_steps_with_model,\n", + " 'update_style': update_style,\n", + " 'update_threshold': update_threshold,\n", + "}\n", + "\n", + "# Create OTF object.\n", + "timestep = 0.001 # units of ps\n", + "number_of_steps = 500\n", + "test_otf = OTF(\n", + " atoms,\n", + " timestep,\n", + " number_of_steps,\n", + " eam_potential,\n", + " md_engine,\n", + " md_dict,\n", + " flare_calc=flare_calculator,\n", + " force_only=force_only,\n", + " **otf_params,\n", + ")\n", + "\n", + "# Run on-the-fly dynamics.\n", + "test_otf.run()" + ] + }, + { + "cell_type": "markdown", + "id": "1074d8cc-d529-450a-aced-a550af0fccd1", + "metadata": {}, + "source": [ + "### Analyzing the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "695843a1-af37-404d-a7fc-bb7431170bf0", + "metadata": {}, + "outputs": [], + "source": [ + "# Parse the output file.\n", + "output_file = 'Al.out'\n", + "otf_trajectory = otf_parser.OtfAnalysis(output_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "807816de-ce87-4c15-ac9e-d70e92d6c71b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqEAAAHOCAYAAACo6NBMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADirklEQVR4nOydd3gU5drG79mW3nsjgVBDV8CCNJUiYgdBUBQR0SOWY0PxS0xBUJGjHD0qiuWgCBxFaUoXpAkiCEFqgATSey9b5/tjdiYb2CRbZrYkz++6crHJvjPzJmyy9zzlfhiWZVkQBEEQBEEQhAOROXsDBEEQBEEQROeDRChBEARBEAThcEiEEgRBEARBEA6HRChBEARBEAThcEiEEgRBEARBEA6HRChBEARBEAThcEiEEgRBEARBEA5H4ewNEIQ5DAYDCgoK4OfnB4ZhnL0dgiAIgiAsgGVZ1NbWIjo6GjJZ27FOEqGES1JQUIC4uDhnb4MgCIIgCBvIzc1FbGxsm2tIhBIuiZ+fHwDuRezv7+/k3RAEQRAEYQk1NTWIi4sT3sfbgkQo4ZLwKXh/f38SoQRBEAThZlhSSkeNSQRBEARBEITDIRFKEARBEARBOBwSoQRBEARBEITDIRFKEARBEARBOBwSoQRBEARBEITDIRFKEARBEARBOBwSoQRBEARBEITDIRFKEARBEARBOBwSoQRBEARBEITDIRFKEARBEARBOBwSoQRBEARBEITDIRFKEARBEARBOBwSoQThglQ3alGn1jl7GwRBEAQhGQpnb4AgiGYaNDq8/uNJbDheAIWMwdxR3fDS2F6QyRhnb40gCIIgRIUioQThQsxfxwlQANAZWPxn90V8vOeCk3dFEARBEOJDIpQgnERqaioyMjKEz3efLcGmEwWQyxiMbdqP68p2AAD+teM8soprnbVNgiAIgpAEEqEE4STkcjlSUlIEIfrRbi7i2fXKFqxY9jYGx4dgbFIEDCzwwc4sZ26VIAiCIESHakIJwkkkJycDAFJSUpBTVo+jXiNQ+/sa7Nr7LdLT05GcnIyzRTXYcboYv/xdiNyKBsQFezt51wRBEAQhDiRCCcKJJCcno7pRi6WLMwD5UkCvEwQoAPSO9Mfw7iE4cKEc3/+ZixfH9XLyjgmCIAhCHCgdTxBOpvcdjwFyBaDXQaVSCQKUZ9rQLgCA74/mwWBgnbBDgiAIghAfEqEE4WQ+ef9dQK+DQqmERqNp0awEAGOTIuCjkqOwugmZ+dVO2iVBEARBiAuJUIJwImlp6Tj203IE3DIDf2WXIj09vUWzEgB4KuUY0zscALD17yJnbZUgCIIgRIVqQgnCSWRkZCA19U0E3DIDXW57BH2i/NHPpFkJaG5emtAvEpszC7HjdBFeu6O30/ZMEARBEGJBIpQgnIRer8cDc17En8G3YlCXIMiNU5F44anX64W1I7qHgWGAi6X1KKpuQmSAp1P2TBAEQRBiIboI1Wg0qKqqQmNjI7y8vBAUFASlUin2ZQjC7UlNTcWrP5zAn3/mYUBMQIvnrm5OCvBWol90AE7mV+P3S2W4b3CsI7dKEARBEKJjtwj9448/sHXrVhw6dAiZmZkoKioCyzZ38DIMg8jISAwcOBA33ngjxo8fj2HDhtl7WYLoEGTmcY1G/WMD2lkJ3Nw9BCfzq3HwQjmJUIIgCMLtsUmE5ubm4tNPP8U333yD/Pz8Fs+ZClD+88LCQhQWFmLr1q1ITU1FTEwMHnnkEcydOxddunSxffcE4cY0avTIKqkDAAywRIQmhmL5b5dw8GI5WJYFwzBSb5EgCIIgJMOq7visrCzMmDEDiYmJePvtt5GXlweWZYUPDw8PREdHo3///hg+fDj69euHqKgoeHh4tFiXl5eHt99+G927d8eMGTNw/vx5qb4/gnBZThfWQG9gEebngUj/9ms8hyYEQSlnkF/ViCsVDQ7YIUEQBEFIh0WR0MrKSrzxxhtYsWIF9Hq9EO0cMGAARo8ejRtvvBE33XQT4uPjWz1HdnY2Dh06hEOHDmHv3r04ceIEdDod1qxZg++//x5PPPEE3nrrLQQFBYnznRGEi5OZVwUAGBATYFFU01ulwOC4IPyRU4GDF8sRH+Ij8Q4JgiAIQjosEqE9e/ZERUUFWJZFdHQ0Hn/8ccycORPdu3e3+EJdu3ZF165d8dBDDwEALl68iP/+97/48ssvUVBQgOXLl+OHH35ASUmJbd8JQbgZJ62oB+W5KTEEf+RU4PeL5XhoGJWyEARBEO6LRen48vJyJCYm4osvvkBOTg7S09OtEqDmSExMRHp6OnJycvDFF18gMTER5eXldp2TINwJfvqRJfWgPNfHc5mC47lVUmyJIAiCIByGRSL0P//5D86cOYNZs2ZBoRDX1UmhUGDWrFk4c+YMPvroI1HPTRCuSqNGj4ulXFNSvxjLRejAuEAAwJWKBpTXqaXYGkEQBEE4BItE6NNPPw25XC7pRuRyOZ5++mlJr0EQrsLF0jqwLBDso0K4n+XG8wFeSnQL42pBTxhrSgmCIAjCHaHZ8QThBLJKagEA3cN9rT52kDEaevxKlYg7IgiCIAjHYrEI/fTTT1FTUyPlXgii05BVzKXie9ggQgcbRehfVBdKEARBuDEWi9B//OMfiIqKwsyZM7Fnzx4Jt0QQHR/epN4WEToojmtOOpFbBYOBbWc1QRAEQbgmVqXjm5qasGrVKtx2223o3r07Fi1adM3EJIIg2ueCUYT2jPCz+tjeUX7wUMhQ06RDdnm92FsjCIIgCIdgsQi94447IJPJhKlH2dnZSE5ORkJCAiZOnIh169ZBp9NJuVeC6BA0afW4bBSP3SOsj4Qq5TKho57qQgmCIAh3xWIR+vPPP+PKlStYtGgRevbsKYhRvV6Pbdu24cEHH0R0dDRefPFF/P3331LumSDcmkul9TCwXKd7mK+HTefgvUX/LqgWc2sEQRAE4TCsSsdHRUXhtddew9mzZ7Fv3z7MmjULvr6+giAtLy/HsmXLMHDgQNxwww347LPPUFtbK9XeHUJ5eTl++uknLFiwAOPHj0dSUhLCw8OhVCrh7++P3r17Y8aMGVi/fj0MBoNV5964cSOmTJmChIQEeHp6Ijw8HDfffDOWLFliVRNYXV0dli1bhrFjxyIyMhIeHh4ICwvDsGHDsHDhQhQXF1v7bVvEhQsX8Morr6Bfv34ICAiAr68vevXqhWeeeQbHjx+X5JodAb4zvke4r0XjOs3RN5oToacKqFmQIAiCcFNYO6mvr2e//PJLduTIkSzDMMKHTCZjZTIZ6+Pjw86cOZPds2ePvZdyCkuWLGEBWPRx3XXXsVlZWe2es7a2lr377rvbPFdcXBz7+++/t3uuX3/9lY2IiGjzXMHBwey6devE+HEILF++nPXy8mr1mnK5nE1LS7P5/NXV1SwAtrq6WsRduwbvbTvLxs/fzL627oTN5ziVX83Gz9/M9kvZyhoMBhF3RxAEQRC2Y837N8OyrGjttRcvXsQXX3yBb775pkXDEh/t6datGx5//HE8+uijiI6OFuuykvLee+/htddew8CBAzFkyBD07NkTUVFRUKlUqKysxNGjR7F27VpUVVUBACIjI3HixAmEh4ebPZ9er8ekSZOwdetWAEBERATmzJmDpKQkVFRUYPXq1Thw4AAAICgoCAcOHECfPn3Mnmvfvn24/fbbodFoAACDBw/GQw89hPj4eFRXV2PHjh1Yt24dDAYDFAoFNm7ciDvuuMPun8m3336LRx55BAAgk8kwbdo03HbbbVAoFDhw4AD++9//Qq3mpvm8/fbbmD9/vtXXqKmpQUBAAKqrq+Hv72/3nl2Jp745iq2nipA8KQmzb+lq0zm0egP6pmyDRm/A3lfGoEuIt8i7JAiCIAjrser9WwoVbDAY2C1btrBTpkxhPTw8romOKhQKduLEiaJH56TgypUrbGVlZZtrysrK2GHDhglRwH/84x+trv3000+FdUlJSWxRUdE1a1566SVhzYgRI8yeR61WswkJCcK6F154wWxEbMeOHayHhwcLgI2IiGBramra/obboaSkhPX392cBsDKZjN2wYcM1a37//XfW29ubBcAqFAr27NmzVl+nI0dCb1u6h42fv5ndc67ErvPc+e+9bPz8zewvmQUi7YwgCIIg7MOa929JRKgp5eXl7LJly9jBgwe3SNczDMPK5XKpL+8wjh492iKVbg6dTsdGRUUJ644ePdrqukGDBgnrtm3bds2atWvXCs8PHjyY1ev1re4tPT1dWJuenm7bN2jk1VdfFc717LPPtrpu6dKlwrqHHnrI6ut0VBGq0xvYHgt+YePnb2avlNfbda5Xvz/Bxs/fzC7Zar3IJwiCIAgpsOb9W/KxncHBwXjuuedw7Ngx7Nq1C9HR0UJ6nhWvEsDp9O3bV3hcVFRkds3evXtRWFgIABg1ahSuu+46s+vkcjmee+454fPVq1dfs2bXrl3C45kzZ0Ima/2/ctasWcLjVatWtbrOEtauXSs8/uc//9nqujlz5sDHh5txvnHjRjQ2Ntp13Y5CUU0TNHoDlHIG0YFedp0rKZpLc5wupOYkgiAIwv1wyOz4Xbt2YcaMGZg0aZIgwjoaFy5cEB5HRkaaXbNlyxbh8cSJE9s8n2ntpulxPHl5ecLjXr16tXmu2NhYeHtzNYPnzp1DVlZWm+tb4/Tp07h8+TIAoE+fPujatfV6Rj8/P4wYMQIAUF9fj99++82ma3Y0cso4f9C4YG/IZbZ1xvP0NYrQU2TTRBAEQbghkonQnJwcvPnmm0hISMC4ceOwZs0aNDY2CnZOvXr1wjvvvCPV5R1KXV0dnn32WeHzyZMnm1138uRJ4fHQoUPbPGdkZCTi4uIAAMXFxSgtLW3xvD1R5MzMTJuOs2b/V68xPbYzk2M0qU8I8bH7XL2j/MEwQHGNGmV1arvPRxAEQRCORCHmyZqamvDDDz/gyy+/xN69ewWhxP/r4+ODBx98ELNnz8bNN98s5qUdQklJCQ4ePAgAMBgMqK6uRmZmJtasWSOk4K+//nqkpqaaPf7cuXPC47aiiKZrcnNzhWPDwsKE50yjrefPn2+z6z0/Px8NDQ3C52fPnm332uawZf/mju3MXC7n/h/iRehm9/VQICHEB9ll9ThVUINRPcPaP4ggCIIgXARRROihQ4fw1VdfYe3atYI5vWmk7sYbb8Ts2bMxdepU+PpaP6bQVTh27Bjuu+8+s8+FhYVh1qxZSEtLg6enp9k1vI0TAISGhrZ7vZCQELPHAsCIESPw1VdfAQBWrlyJ5557rlXj86+//rrVfViDmPu/GrVaLdg6AbDKrN+d4NPxXUPtj4QCXF1odlk9TpMIJQiCINwMm9PxxcXFWLJkCZKSkjB8+HCsWLECNTU1Qro9LCwML774Ik6dOoWDBw9i9uzZbi1A22PkyJEYOXJkqwIU4NL2PG2t4/Hyam5cuXry1OTJkxEcHAyAE8evvvqq2RT97t27sXDhwhZfs1Xgibn/q1m8eDECAgKED74UoaPBp+PjRUjHA1QXShAEQbgvVolQvV6Pn376CXfffTfi4uLw2muv4dy5c4LwlMvlmDhxIn744Qfk5+fjvffea9VoXSxGjx4NhmFE+VizZk2b15owYYLwvep0OhQWFmL9+vW47bbbsG7dOkyaNAnTp09vkfqWCj8/P/z73/8WPn/vvfcwdOhQLF26FN9//z1WrFiBadOmYezYsWhqakJiYqKwtq1Oemfx+uuvo7q6WvjgyxA6EgYDK6TjE0Qyl+fHd56m8Z0EQRCEm2FxOv7FF1/EqlWrUFZWBqBlup2fhPTYY4+5zSQke5HL5YiMjMQ999yDe+65BwsWLMDixYsFO6XvvvvummN8fX1RWVkJgKufbS8ybGpr5Ofnd83zM2bMQGNjI+bNmwe1Wo2jR4/i6NGjLdbIZDKkpaWhsrISH3zwAQBuEpMtmO63qamp3fXt7d8UDw8PeHh42LQvd6G4tglqnQEKGYMYO+2ZeJKiuEhodnk96tU6+HiIWuZNEARBEJJh8TvWBx98AIZhBPHp6emJBx54ALNnz8bo0aOl2l+7TJ48GYMGDRLlXO1ZHbVFRkYGfvjhB2RlZWH16tVISUlB7969W6wJDAwURGhZWVm7IrS8vLzFseZ44oknMGHCBHz88cfYvn07Ll68iPr6ekRGRmLkyJF49tlnccMNN2DmzJnCMa1ZSLWH6R74mxF799+ZyCnjoqBxwd5QyO2LRqempkIulyM5ORnBPipU1GtwubwBSdH+yMjIgF6vb7VBjiAIgiBcAavCJizL4rrrrsPs2bMxffp0BAQESLUvi5k3b56ztwCAi4yOGzdO8ODcs2fPNSK0V69eyM7OBgBkZ2cjISGhzXPya/ljWyM2NhaLFi3CokWLWl1z6tQp4fGwYcPavG5rmO7BdG+tYen+OwvN9aD2p+LlcjlSUlIAAOF+o1BRr0FZnRoZGRlISUlBenq63dcgCIIgCCmxWITOmzcPs2fPxsCBA6Xcj1tjmnLmI56m9O/fH1u3bgUAHDlyBGPGjGn1XMXFxUJdZHh4eAt7JmspLy8XfDp9fX0xePBgm87Tv39/4fGRI0faXW+6pl+/fjZdsyMhpkdocnIyACAlJQUD7nkS6H03Pn7/Haz9dCnS09OF5wmCIAjCVbE4J/jvf/+bBGg7mE4iMicaJ0yYIDw2NwXJlF9++UV43N50pfb45ptvoNVqAQCPPPKIzbWXSUlJ6NKlCwDgzJkzyMnJaXVtXV0d9u3bBwDw9vbGqFGjbLpmRyK3gkvHdwkWpykpOTkZ6enpyNzwGS6/dy8JUIIgCMKtEL1NOi8vD9u3b8eaNWuwcuVKsU/vsly5cqWFsBw+fPg1a0aNGiXUY+7ZswfHjh0zey69Xt+i833atGk276ugoEBIzapUKjz//PM2nwsApk6dKjz+17/+1eq6zz77DPX1XOTv7rvvFsaGdmbyKrlGrTiRRCjACVG5QgnodZArlCRACYIgCPeBFYkvvviCTUpKYmUyWYuPq1m4cCE7duxY9vHHHxfr0pJRWFjIpqamsuXl5W2uO3fuHNu3b18WAAuAHTNmTKtrP/74Y2Fd37592eLi4mvWvPzyy8Ka4cOHt3quS5cusTk5Oa0+//fff7O9evUSzrV48eI2vw9+HQA2Ozvb7Jri4mLWz8+PBcDKZDJ2w4YN16w5dOgQ6+3tzQJgFQoFe+bMmTava47q6moWAFtdXW31sa7K4PTtbPz8zezpAvG+p/T0dO7/TK5gAbDp6eminZsgCIIgrMWa92+GZe0YQg7Ohmfy5MlCraPp6RiGgV6vb7F+27ZtuOOOO8AwDP7++2/JfUTtIScnB127doVCocDo0aMxbNgwJCYmwt/fHxqNBnl5edi3bx+2bdsmpLtjYmKwd+9edOvWzew5dTodJk6ciB07dgDgOtXnzJmDpKQkVFRUYPXq1di/fz8ArqN8//796Nu3r9lz/fDDD5g6dSqGDx+O0aNHo0ePHvD09ERRURF2796NTZs2QafTAQBmz56Nzz77rE2PUNOJS201Tv33v//FY489BoCzgOL9SOVyOQ4cOID//ve/goXTW2+9hQULFrR6zdaoqalBQEAAqqur4e/vb/Xxrka9Woe+b24DAGSmjoO/p9Luc/JNSA89/TIO+o+G/5kNOLnxc0rJEwRBEE7DqvdvexXv5MmTWYZhWIZh2K5du7ILFixgn376aZZhGLORUL1ez4aHh7MymYx999137b28pGRnZ7eIDrb3MW7cuDYjkzw1NTXspEmT2jxXbGwse+DAgTbP8/3337e7J29vb3bx4sWswWBod1+mx7UWCeX5+OOPWU9Pz1avK5fL2ZSUlHav2RodLRJ6trCGjZ+/mR2Quk2U8/ER0PT0dHZ/VikbP38ze/vSPS2+ThAEQRCOxpr3b7ucrXft2oV169aBYRhMmzYNX3/9NZRKJTZs2IBPP/3U7DEymQxjx47Fd999h/379+OVV16xZwuSkpCQgBMnTmDnzp04fPgwTp8+jby8PNTW1kKpVCIgIAA9evTAsGHDMHXqVIutj/z8/LBp0yZs2LABK1euxJEjR1BSUgI/Pz8kJibi/vvvx9y5c9u1wBozZgyWL1+O3bt3IzMzE8XFxaipqUFoaCi6deuGO++8EzNnzkRMTIwYP44WPP3007j99tvx6aefYuvWrcjNzYXBYEB0dDRuu+02PPnkkzZ34XdE8ip5j1BxTOr1er0Q8TxfzI1ELatTIzklWXieIAiCIFwZu9LxjzzyCFatWoXExEScPn0aSiWXYtywYQPuu+8+s+l4AFiyZAnmz5+P7t274/z587bvnuiwdLR0/H8P5uDNjacwoW8kPn3kelHPXVGvwXUZXHnH+YV3QKVwvbGsBEEQROfAmvdvu96tDhw4AIZhMHPmTEGAWgI/2rOoqMieyxOE28BHQmODxImEmhLkrYSvcVznZaMXKUEQBEG4OnaJ0OLiYgDWT8Px9PQEYNn8cYLoCPD2TFKIUIZh0COCGwF7zpiaJwiCIAhXxy4RKpfLAQAGg8Gq4yoqKgDQPHGi89AsQqXxS+0VwU3rOldEIpQgCIJwD+wSoREREQCACxcuWHXc0aNHAQBxcXH2XJ4g3AYhHS9SY9LV9CQRShAEQbgZdonQm2++GSzLYv369RYfU19fj++//x4Mw+CWW26x5/IE4RbUqXWobDD6yAZKI0J7R3Ii9Dyl4wmCIAg3wS4ROmXKFADAX3/9hS+//NKiY55++mlUVlYCAGbMmGHP5QnCLeCjoIHeSviJYFJvjp5GEXq5ogGNGrJnIgh7+Tu/Gst2ZuHXs8Www0SGIIg2sEuETpo0CTfeeCNYlsVTTz2FxYsXo66uzuzav/76C3feeSdWrVoFhmFwxx13WOyrSRDuTF6FdE1JPKG+HgjxUYFlgawSioYSjkerN+DrA9lY88cVt78R2nu+FPd/chDv7zyPx7/+E18dyHH2lgiiQ2K3oeDatWsRGRkJnU6H//u//0N4eDheeOEF4fmhQ4ciKioKQ4YMwdatW8GyLOLi4vD111/be2mCcAuEetBAaZqSeHpFUl0o4RwMBhYvrD2O1E2n8dqPJ/Hol39Ab3DP6KFWb8CCn05CozNALuNGGb/1yxnklJH9GUGIjd0iNC4uDocPHxYiok1NTbhy5Yowh/zYsWMoLubSGSzL4oYbbsDBgwcRGhpq9+YJwh2Q0p7JFL45iepCCUfz69kS/JxZKHz+R04Fvjt82Yk7sp2fjuUjr7IRob4e+Dt1PEb2DIPewOKL/dnO3hpBdDhEGa0SFxeHgwcPYsOGDbj//vsREhIiiE6WZeHr64s777wT//vf//D7778LZvUE0RlwlAjlI6FnKRJKOBheoM0d2Q0pk5IAACt/v+yWtZTfH80FADwxoiu8VHI8Naqb8PUGjc6ZWyOIDodds+Ov5q677sJdd90FAGhoaEBVVRV8fX07xNhFgrCVvCp+bry06XiKhBLOILeiAb9fKoeMAWbenABfDwXe3noWWSV1OFVQg34xAc7eosWU1DThz8tc4+zdA7lgyU3dQtAl2BtXKhqw93wZJvSLdOYWCaJDIdmQaW9vb0RHR5MAJTo9UhvV8/Q0Tk0qrlGjqkEj6bUIgmf3uRIAwJCEYMQEeiHAS4nb+4QDAH45WdjWoS7H9tPFYFlgcJdARBvt1BiGwbikCOPzNGqaIMREMhFKEARQ26RFFe8RKnE63s9TKfiQni8271JBEGKz51wpAGBMr3Dha/zjQ5fKnbInWzl4sQwAcFvv8BZfH2sUobvPlsDgpg1XBOGKkAglCAnho6BB3kr4eoha/WKW5g75GsmvRRAanUEQbqN7hQlfv7FbCAAgM68a9Wr3qKNkWRZ/ZHMjpW8w7p/nuvggeCnlqGzQ4kIp3eARhFhYJEJfeeUVVFdXS7qRkpKSFtZOBNER4EWo1FFQHmF8J9WFEg7gbFENmrQGBHgphaldAFf/HBPoBZ2BxVFjjaWrc7G0HmV1GngoZBgQ27KOVSmX4br4QADAYaNQJQjCfiwSoUuXLkViYiLS0tKEaUdiUV5ejvnz56Nbt2748MMPRT03QTibomqjCJVoXOfVCOM7iyhaQ0jPX1eqAHA1lLwtH8+wrsEt1rg6f+Zw4nJQXCA8FPJrnh+awH0/R0iEEoRoWCRCe/XqhYqKCqSnpyM2NhazZs3C7t27bbbf0Ov12LhxIyZPnozY2Fi89957aGhoQK9evWw6H0G4KoXVTQCASH9Ph1zPNBLqjvY4hHvx1xUuKDE4Luia5/iu+FMF0mbRxOJkPrfPQV0CzT4/zChC3SWySxDugEVFaidPnsS//vUvLF68GNXV1Vi5ciVWrlyJkJAQDB8+HDfeeCNuuOEG9O7dG8HBwVCpVMKxGo0GFRUVOHPmDA4fPozDhw9j//79qKjg7iZZlkVAQAAWLFiAf/7zn9J8lwThJIp4ERrgmEhotzAfyGUMqhu1KK5RIzLAMeKX6JycyGtduPWN5pxRThW4R33y38Z99m/FUqqfMUWfX9WIynoNgnxUZtcRBGE5FolQhUKBV199FXPmzMGSJUvw6aefoqqqCmVlZdi4cSM2btzYYr23tzf8/PxQU1ODxsbGa87HR2iCgoLwj3/8Ay+99BICAwPt/24IwsXgI6FRDhKDnko5EkK8cbG0HueKa0mEEpJRr9Yh2zjKsl/0tVZ8Scav5Vc1oqpBg0Bv1xVtWr0BZwo5Edov2rwI9fdUIiHEGznlDTiZX42RPcPMriMIwnKs6o4PCgrCokWLkJubi08++UQY1Xn1R319PYqLi9HQ0HDNcwBwyy234LPPPkNubi4yMjJIgBIdlqIaPhLqODHYO5J78z9Pk5MICeGHIoT5eSDE1+Oa5/09lehiHNBw2sWjoRdK6qDRGeDnoRD2bA6+xOBvNykxIAhXxybPGB8fH8ydOxdz585FUVERtm3bhsOHD+PkyZPIyclBRUUF1Go1PD09ERISgq5du6J///648cYbMW7cOISHh7d/EYJwc1iWRaGxMclRkVCAqwv9+WQhje8kJIV/fZl2xV9Nr0g/XKloQFZJHW7uHuqorVkNHwXtE+0PmYxpdV2/mABszizE3/kkQglCDOw2LoyMjMSjjz6KRx99VIz9EESHobpRiyatAQAQ4aDGJADoHcWJgtOFrh19ItybcxaI0O7hvthxuhgXSlzbrSHLuD9+6lhrJEVxWQa6wSMIcSCzeoKQCL4eNNhHBU/ltZYvUsE3hFwoqYVGZ3DYdYnOxVnjQIReka2PZk4M40TdRRc3eM8yThjrEd66oAaah0HklNWjSauXfF8E0dEhEUoQEiHUgzowCgpAmN+t1bNC3R5BiM2lUq4pqXt469HDxDAfAHD5SOiFEu73pEcb3wsAhPt5IMBLCQPb/P0TBGE7JEIJQiKKHNwZz8MwjJA2pJQ8IQX1ah1KatUAgK4hPq2uSzSKupJaNWqatA7Zm7U0afW4UtEAAOgR0XYklGEYIWVPN3gEYT8kQglCRFJTU5GRkQGgOR0fYRShGRkZSE1Ndcg+eHscV+9KJtyTy+WcaAvyViLAW9nqOn9PJcL9uM55V40cXiqth4EFAryUCPVt30aKRuMShHiQCCUIEZHL5UhJSUFGRoYwsjPK3xMZGRlISUmBXO6Y2tBmo3Dq4iXEJ6ecE5TxbURBeRKMay6Xu6YI5b1Ou4X5XDN61Bx8yt7VSwwI1+JMYQ3e+vm0UPpBcNjdHU8QRDPJyckAgJSUFAy4Jw/ofTf2f78c/1u+FOnp6cLzUtPXaLh9prAWBgPbpu0MQVgLL0K7hrYvQruEeOOPnApcMUZPXQ3he2lHUKempkIul2Pk1Ke448qaRXVGRgb0er3DMh2Ee3HsSiVmfH4YjVo9vj10Bf+bexP6x5ofitDZoEgoQYhMcnIy0tPTkbnhM1x+716HC1CAi+qoFDLUqXVCvRtBiAUvwOJDWjd25+HN3131dch/LwntCGo+y7Hp6w8BcCUJegPr8CwH4X68v+M8Go1uCo1aPT78NcvJO3IdSIQShAQkJyeDkSsBvQ5KlcqhAhQAlHKZ4N9IzUmE2OQYo5qWREJ5oXrZVUVouWUilL+5XLo4A7W/r4FGb8D8/3sTKSkpDr/JJNyHi6V12JdVBoYBvpo1FACw40yxy2YGHA2JUIKQgOQ308DqtYBcAa1GIzQrORK+LvQkTXchREaIHlpQExpnjITmuqgIzS7j9pVgQVSXF6IVe7/F5ffuxdLFGSRAiTbZ+ncRAGB0zzCM6RWOmxNDwLKcECVIhBKE6GRkZGBheioCbpmBfv+3Genp6UKzkiMZEBsIAMjMq3LodYmOjak9kyUilE/HF9U0uZzBe51ah7I64/diQVQX4ISoTMFlORRKx2c5CPfiwIUyAMCtvblx5aN6hrX4emeHRChBiAhfHzb7+dcQOPwhRAV4CtETRwvRgbwIza2GwcA67LpEx8ZSeyaeEB8VfFRysCyQX9Uo9fasgo/OBnor4e/Z/vcCcL/jBh2X5dBpnZPlINyDJq0ef16uBADclBgKABjenfv38KVyaPU00Y664wlCRPR6PdLT09H7jsew84dMYWY8Hy3R6x0XCeoZ4QtPpQy1ah0uldW3OdmGICzFGnsmgDN4jwr0woWSOhRWNQmjPF2B/EpOFMcGeVm0nr/JnPzkizgSdCuCzm1ESkoKAFBElLiGv65UQaMzINzPQ5gelhTlj0BvJaoatDhVUINBcYHO3aSTsSsSumDBAuTk5Ii0FYJwf1JTU5GcnGx2WlJycrJDLVwUchn6x3A2ICdyqxx2XaJjY409Ew//e1BQ7VqR0LxKLhIaE9i+COUFaHp6Ol58dQEAwP/maU4rtyFcn7+N9fjXxwcJHrQyGSOUSpGPs50i9O2330b37t0xYcIErF+/3qFRHoJwZQr5ufEBlkVYpIJPyZ+gulBCJC4bG3n4Wk9LiDb+HhRWNUmyJ1vhywNig9r/XvgsR3JysiDA8yobMf/1N5Cenk7vf8Q18CKTH6PMI4xVpol29qfjDQYDduzYgR07diAyMhKzZ8/GE088gS5duoixP4JwS5w1N/5qBhhTPSfy6I6bEAc+mhlnhQiNCuR+DwpdLBLKi1BLIqGmWYwIfw94KeVo1OqRW9lAqXjCLLw9Xt+Yq0SoMNGORKhdkdCvvvoKN910E1iWBcuyKCwsxFtvvYXExERMmjQJmzZtgsFAhbdE54OfGx/pZBE6yBgJPVNQA7WOIjWE/fB1lNGBlr+2+UhoQbVrRULzrKwJ5WEYRuimN52cRBA8TVo9LpZyr42kqJbTkXj7vLNFNdB38qZRu0Too48+igMHDiAzMxPPPPMMAgMDwbIs9Ho9tmzZgnvvvRfx8fFIS0tDXl6eWHsmCJdHmBvvZBEaF+yFIG8lNHoDzhTSzGLCPliWtSp6yCNEQl2sO54X1DFWilAA6BrKRYKzSYQSZsgqroPewCLYR4UIf48WzyWE+MBTKUOT1oDL5Z379SOKRVO/fv3w4YcfoqCgAF9++SVuvPFGITqan5+P9PR0dO3aFffccw9++eUXsGznVv5Ex6ZJq0dlgxYAEOXv3JpQhmEwuEsQAODPnAqn7oVwfyrqNVDrDGAY66L8UXxNqAtFQhs0OpTXawBYVhN6NXw5Ah9NJQhTLpXVAQC6h/kKTUk8chmDrqGcS0QOiVDx8PT0xGOPPYaDBw8iMzMT//jHPxAQECBERzdv3oy77roLCQkJWLhwIQoKCsS8vCSUl5fjp59+woIFCzB+/HgkJSUhPDwcSqUS/v7+6N27N2bMmIH169dbXXqwceNGTJkyBQkJCfD09ER4eDhuvvlmLFmyBDU1lteK1NXVYdmyZRg7diwiIyPh4eGBsLAwDBs2DAsXLkRxsXiTGViWxaFDh7Bw4ULceeedSEhIgJeXFzw9PREdHY0JEyZg2bJlqKqqEu2a7kaxsSnJSymHv5fzXdCGJgQDAI6QCCXspMDYWBTm6wEPheWz0vnUfZ1ah5omrSR7s5YCY1TWz0OBAC/LPEJNiTVGgl3N+5RwDS4ZU/Hdwsy7SHQzlnPw6zotrMQ0NDSwX375JXvjjTeyDMMIHzKZjFUqlex9993Hbt++Xept2MySJUtYABZ9XHfddWxWVla756ytrWXvvvvuNs8VFxfH/v777+2e69dff2UjIiLaPFdwcDC7bt06u38W586dY2NjYy36WYSEhLA//PCDzdeqrq5mAbDV1dV279vR/H6xjI2fv5kds2S3s7fCsizL/plTzsbP38wOTt/OGgwGZ2+HcGO2nCxk4+dvZu/5aL/Vxw5M28bGz9/Mnil0jd/p3WeL2fj5m9nx7/9m0/G/nuGOn/DBXpF3RnQE5n13jI2fv5n9dM8Fs8+/u/UMGz9/M/vGT5kO3pn0WPP+LXmYxsvLC7NmzcKDDz6I119/HR999JEQmtbpdNiwYQM2bNiAPn36ICMjA/fdd5/UW7IauVyOgQMHYsiQIejZsyeioqKgUqlQWVmJo0ePYu3ataiqqsKxY8cwYsQInDhxAuHh4WbPpdfrMWXKFGzduhUAEBERgTlz5iApKQkVFRVYvXo1Dhw4gNzcXEycOBEHDhxAnz59zJ5r3759mDBhAjQaLqU0ePBgPPTQQ4iPj0d1dTV27NiBdevWoaKiAlOnTsXGjRtxxx132PxzqKioEGp7PTw8MGbMGAwfPhxdunSBh4cHLly4gFWrVuHMmTMoLy/Hgw8+iNWrV+PBBx+0+ZruCN8ZzxvVO5v+MYHwUMhQUa/BxdI6dA/3c/aWCDfFlnpQnqgAL1Q1aFFY1YTekf7tHyAxtjYl8fDH8V6jBGFKtjEd362V4Qx8Or7T1xRLrYj/+usv9qmnnmIDAgJYmUzGymQylmEYVi6Xsz179mwRGZXJZOz06dNZnU4n9bYs5sqVK2xlZWWba8rKythhw4YJUcB//OMfra799NNPhXVJSUlsUVHRNWteeuklYc2IESPMnketVrMJCQnCuhdeeMFslGvHjh2sh4cHC4CNiIhga2pq2v6G2+D3339n4+Li2H//+99sRUWF2TVarZZ95plnWkRh2/v5mcOdI6Ef777Axs/fzP5zzV/O3orA1OUH2fj5m9lVhy47eyuEG5O+6RQbP38z+9bPp60+9vGv/mDj529mvz2UI8HOrOftLVwkKmX9SZuOr1dr2fj5m9n4+ZvZqgaNyLsj3BmDwcAmJW9h4+dvZrOKa82u+TOngo2fv5m9adFOB+9Oeqx5/5ZkdnxDQwNWrFiBYcOG4frrr8dnn32GmpoasCyLkJAQvPrqq8jKysK5c+fw119/Yc6cOVCpVGBZFmvWrMHy5cul2JZNxMXFITAwsM01ISEh+OSTT4TPN23aZHadXq9HWlqa8Pk333yDiIiIa9a98847GDRoEAAu2rl9+/Zr1qxfv16YVjV48GAsXbr0muJnALj99tvxxhtvAACKi4vxwQcftPm9tEX//v1x4cIFPPvsswgKCjK7RqFQ4MMPP8R1110HgIuerl+/3uZruiN8Z7yz7ZlMGUZ1oYQI8HWU0Ta8tps75F2jOak5Emp9UxIAeKsUCPZRAWjusicIACitVaNeo4eMaX2oAz/woKC6CU3azmufJ6oI/euvv/DUU08hKioKc+fOxdGjR4Uu+ZtvvhnffPMN8vLy8Pbbb6Nr164AgIEDB2L58uXIzMxEly5dwLIsPv/8czG35RD69u0rPC4qKjK7Zu/evSgsLAQAjBo1ShBqVyOXy/Hcc88Jn69evfqaNbt27RIez5w5EzJZ6/+Vs2bNEh6vWrWq1XXt4ePjA5VK1e46hmEwZcoU4fPMzEybr+mOFLqIUb0pQ7tyIvSPbBKhhO0IItTGdDzgOqM78/mRnTam4wFKyRPmyTW+HqICvKBSmH9vDvJWwkfFNfd15uY2u0VofX09Pv/8cwwdOhRDhgzB559/jtraWrAsCx8fH8ydOxcnTpzA/v37MWPGjFZFTI8ePfDyyy8DAC5evGjvthzOhQsXhMeRkZFm12zZskV4PHHixDbPZ1q7aXocj6nvaq9evdo8V2xsLLy9ubuxc+fOISsrq831YuDv31zz1djYuX7BilxkZKcp13UJglzGIL+qEbkV9IZJ2Ea+HSI02sUiofbUt/I0i9DO9TeOaBtL6o0ZhhGi8J05km5XY9LcuXOxZs0a1NVxBbis0f+zX79+ePrpp/HII4/A19d8Ua45EhMTAXDC1p2oq6vDs88+K3w+efJks+tOnjwpPB46dGib54yMjERcXBxyc3NRXFyM0tJShIWFCc+zdnitZmZmokePHjYfbwmm32t8fLyk13I1XGVkJ09qairkcjkGxd2Go5crceBCGaYN48bqZmRkQK/XtxhJSBDmaNLqUVbH+2raHgl1hdGdOr0BpbVqAM1lArYQQzZNhBn4G/32RtvGBHnhXHFtp76JsUuEfv7552AYBizLQqVS4YEHHsDTTz+NW265xabztZVSdgVKSkpw8OBBAIDBYEB1dTUyMzOxZs0aIQV//fXXt/qGfu7cOeExX47QFl27dkVubq5wrKkINY22nj9/vs2u9/z8fDQ0NEe/zp492+617aGyshJr164VPr/zzjslvZ4rodUbUFrHvbm5Sk2oXC5HSkoKJswsA6LGYb9RhGZkZCAlJQXp6enO3iLhBvBlJt4quU2+mtEmhvUsy5qtYXcUpXVqGFhAIWMQ6uPR/gGtwEeyKB1PmGKp8wL/fH5V53392G3R1KVLF8ydOxezZ89uIZJsYfz48S49a/7YsWOtWkiFhYVh1qxZSEtLg6enefFhauAeGhra7vVCQkLMHgsAI0aMwFdffQUAWLlyJZ577rlW/6h//fXXre5DCl566SVUVlYCAO6++27079+/3WPUajXUarXwuTVm/a5ESa0aLAuo5DIEe7dfP+sIkpOTAQApKSkIuKUcB30eRXp6Ot58802kp6cLzxNEW5jWg9oiIMONowvVOgNqmnQ2CVmx4LMV4X4ekMlsF8OUjifMwb8e4tppeuMj6Z359WNX6HHz5s24dOkSXnvtNbsFqLszcuRIjBw5slUBCkAoWwDQ5joeL6/mu6ja2pZzvydPnozgYK7Z5NixY3j11VfNpuh3796NhQsXtvialALv008/FcRxYGAgli1bZtFxixcvRkBAgPARFxcn2R6lhO+Mjwiw781NbJKTk/Fmahqq96/CX2kTSYASVmNPPSgAeCqbI6glNc6tC+WnmkXYma2ICaJ0PHEtfGNS+5FQqgm1S4ROnDjRqSkVABg9ejQYhhHlY82aNW1ea8KECUK3v06nQ2FhIdavX4/bbrsN69atw6RJkzB9+vQWqW+p8PPzw7///W/h8/feew9Dhw7F0qVL8f3332PFihWYNm0axo4di6amJqHeFpCu7OHnn38WamNlMhm++uorJCQkWHTs66+/jurqauGDL0NwN/iUZaSLGNWbkvpmChi5EtDroFSqSIASViHUOtvx2g7346KhxTXqdlZKS5FIv6d8JKuqQYtaFxlHSjgXg4EVsgaxFtSEAhQJJWxALpcjMjIS99xzD3bu3InXX38dAGen9MQTT5g9xrRJq6mp/UiAaVe5n9+1U25mzJiBzz//HB4e3B/2o0eP4uWXX8aDDz6IOXPmYO3atWBZFmlpabjrrruE41rz+LSHnTt3YvLkydDpdGAYBp999hnuvfdei4/38PCAv79/iw93RHhzc6HOeJ6MjAywei0gV0Cr1SAjI8PZWyLcCDGih/wUsZJa50ZCi4wi2N6pZn6eSgR6c9FdioYSAFBer4FWz4JhgAi/tuuNeb/dktom6PSuW4ooJZKP7ZSayZMnC8bu9tKe1VFbZGRk4IcffkBWVhZWr16NlJQU9O7du8WawMBAoVayrKysXeeA8vLyFsea44knnsCECRPw8ccfY/v27bh48SLq6+sRGRmJkSNH4tlnn8UNN9yAmTNnCse0ZiFlK7/++ivuvvtuNDU1gWEYfPLJJ5g9e7ao13AXXNEjFIDQhHTHo8/hdOQ4xGb/gpSUFACgiChhEcWCcLO+kYd3aAjvdVeLcwHOcWgQc6BETCA3jjS/stElxpESzoW/WQv19YBC3nacL8TXA3IZA72BRWmdWnCQ6EzYJUK7detm03EymQx+fn4IDg7GwIEDMWbMGNx55502pYnnzZtn0x7ERi6XY9y4cYIH5549e64Rob169UJ2djYAIDs7u91UNb+WP7Y1YmNjsWjRIixatKjVNadOnRIeDxs2rM3rWsOvv/6Ku+66S4ja/uc//8HcuXNFO7+7IVaaT0xMu+Cvv/cJ/GPVMYSMeAjp/SJJiBIWw0cvI/ysf23zDg1jHykFoscLb9TOcmjgvXzFuFmMCvDEqYIa4QaU6NxY8x4glzGI8PNAQXUTiqqbSIRaS05OjmDRxGNaI3q1DYe5dXv27MGyZcvQpUsXfPbZZxg7dqw9W3IqpilzPuJpSv/+/bF161YAwJEjRzBmzJhWz1VcXCzURYaHh9vV+FVeXi74dvr6+mLw4ME2n8sUXoDyNbAffvghnn76aVHO7a6I+eYmFnq9XmhCyinjPHjPFNbiu5TXhecJoj34N1dbUtgtHRoqUNL/ny0EqKNvgopFSscDruV/2tGpbtAiwNt5rgqWUMzfrFmYMYgI8ERBdZNwY9bZsEuEdunSBQzDQKfToaCgQGjaAbj0sY+PD+rr61tYAjEMg+joaADcXHE+gnb58mXccccdWLNmTatm766O6SQic6JxwoQJWLJkCQBuCtKrr77a6rl++eUX4XF705Xa45tvvoFWyxXNP/LII0INqT1cLUCXLVvmMlFpZ9JcE+o6ItQ0zRkf4o34EG9cLm/A/gtlFAElLEKnN6DM6H8bEWDb34/k5GScL67Ft/9ZguWH/geDTusUAcqyrKgZiygXmwTVEams12De6mM4cKEcD9/YBRn39HN6U3RrFFt5s8a/BjtrJN2uxqScnBwcOHAACQkJYFkWt9xyC9atW4eKigpUVFQgNzdXePzDDz/glltuAcuySEhIwB9//IH6+npkZmZizpw5ADgD+Mcff7xFLaS7cOXKlRbjNYcPH37NmlGjRgn1mHv27MGxY8fMnkuv17fofJ82bZrN+yooKBBSXSqVCs8//7zN5+LZs2dPCwH6wQcftJh131nRG1jhbtZV0yoMw2BMr3AAwO6zJU7eDeEulNdrYGC59GGIHebuz7/8GiBXwKDTQqVyjkNDTZMOjVou+i/GzaKpCT8hDR/sPI8DFzhd8O2hK/j+z7x2jnAefJTd0hsc/jVY1EkjoXaJULVajUmTJuHgwYNITk7G3r17cd99913TRBMYGIj7778fe/fuxRtvvIEDBw5g0qRJ0Gg06NevH5YvX44PP/wQADeyc/ny5fZsSzSKioqQlpaGioqKNtedP38eEydOFETZmDFj0KdPn2vW8XVRPDNnzkRJybVC4LXXXsPx48cBcGJ2/PjxZq+bnZ2Ny5cvt7qvU6dO4dZbbxVKA9LS0tqsLTW1q8rJyTG75rfffsOdd97ZQoCKIWw7AuV1augMLOQyBmHtdEU6kzG9jSL0XIld41+JzgN/cxVmbKSwle+Wvw/odWDkCmg0znFo4L+XAC8lPJVyu8/HiwhKx0tDWZ0aa45wpWkD4wIBAN8ebv19z9nwYtLaSGhxJ72JsSsdv3z5chw/fhw33XQT0tLSLDomIyMDu3btwuHDh7F8+XLBV/KZZ57BF198gRMnTmDHjh1YsGCBPVsThaamJqSmpmLhwoUYPXo0hg0bhsTERPj7+0Oj0SAvLw/79u3Dtm3bhHR3TEwMVqxY0eo558yZg59++gk7duzAqVOnMHDgQMyZMwdJSUmoqKjA6tWrsX//fgCceG9LkB89ehRTp07F8OHDMXr0aPTo0QOenp4oKirC7t27sWnTJuh0OgDA7Nmz20z/W8Lx48dbCNDx48cjPj4e69evb/O40NBQm0e5uhOFJlNY7HmjlpobugbDSylHcY0apwpq0C8mwNlbIlyc5npQ22+uMjIy8P7bCxFwywwEDn8IMz3/dEpjnNjNg640jrQjsv1UMdQ6A/rHBODLR4fghkW7kJlXjaziWvSIuNa60NlYa2XWfBNDItRqVq9eDYZhrE4XT5s2DYcOHcLq1asFEQoA9957L44fPy75bHNr0el02LlzJ3bu3NnmunHjxuGzzz5DfHx8q2sUCgXWrVuH6dOnY/PmzSgqKjIbDYiNjcXatWvRt2/fNq9pMBiwb98+7Nu3z+zz3t7eSE5Oxvz58+3+43j8+HHU19cLn2/btg3btm1r97hRo0Zhz549dl3bHSi0o3HDkXgq5RjePRQ7zxRjz7kSEqFEuxTX2tfIwzchpaWlYZVmKNQ6A+Y89wqUcpnDhWiRSNOSePgaWbXOgMoGLYJ9XGNcb0dhX1YpAGBsUgRCfD0wulcYdp4pwfbTxa4tQi1tTBK8c507wMFZ2CVCL1y4AACIioqy6jh+vWkjDwB0794dgPnOcmeQkJCAEydOYOfOnTh8+DBOnz6NvLw81NbWQqlUIiAgAD169MCwYcMwdepUi62P/Pz8sGnTJmzYsAErV67EkSNHUFJSAj8/PyQmJuL+++/H3LlzERDQtjgYM2YMli9fjt27dyMzMxPFxcWoqalBaGgounXrhjvvvBMzZ85ETEyMGD8Ooh1470FX6oxvjdv6hGPnmWJsP12Mebf2cPZ2CBenxMoU49WYOjRse/tX5Fc1orROLQhPRzo0FIsw+ckUD4Ucob4eKKtTo6CqkUSoiOj0Bhy4UAYAGNEjFACMN9AlOJLTdpmcM2jS6lHZwGVFLY20h/pyYrWMRKj18FGxgoICq44rLCwEgGvGW/Jd25bMVXcUAwYMwIABAyQ59z333IN77rnH5uNDQkLw5JNP4sknnxRlP+3VBz722GN47LHHRLlWR6SwxvU641tjbFIE3vjpJDLzqpFb0YC4dsbLEZ0ba6M7V2Pq0BDqq0J+VaPwpuvo5iSxI6EAd+NZVqdGYXUTZRZE5ExhLWqadPDzVGBAbCAAYGhCMADg6OVK6I01+K5CqfE1rVLIEOBlmZVUmFGE1qp1aNLqRalTdifsakyKi4sDwKXlrYFfHxsb2+LrZWXcHU9ISIg92yIIp1DsotOSzBHq64EbunK/Z1v+LnTybghXh+/4DRcheshHfsrrNXafyxZ4QS3mQIkoak6ShL8LqgEAA2MDBbHZO9IPvh4K1DbpcL641pnbu4Yik9eWpeVv/l4KqIyTlXgbtM6EXSJ0/PjxYFkWf/zxB9544w2LjlmwYAEOHz4MhmEwYcKEFs9lZmYCsD69TxCuQKELz403x8T+nF3YLyeLnLwTwtURU7g5O/3IR6vCRXSwiA4kmyYpOGUUoX2jm8ehKuQyDIzjos2ZeVXO2Far2PJ7wjAMQn25Eo6yOufcmDkTu0Toyy+/DB8fHwDA22+/jZEjR+LHH3+8xtKooqIC69atw4gRI/DOO+8A4BpmXnrppRbrtmzZAoZhRB0rSRCOwhWnJbXF+H6RYBjgeG4V8qsogkO0TrGdNaGmhPrxb7jOEaF8A4iYNmpCJJR+j0TlVEENACDJRIQCQO9I7vOzRS4WCeUdUqwsWwn167x1oXZPTPrqq68wffp06PV6HDhwAAcOHAAA+Pv7w9vbGw0NDaipqRGOYVkWCoUCX3/9Nbp06SJ8fe/evSgpKYG3t7dddZIE4QxYlm2OhLp4dzxPuJ8nhiUE43B2BX7JLMSckd2cvSXCBVHrmpst7LFo4uHN7suckI43GFhB/IopQvk68AKKhIqG3sDiTCGnHfpGt6yz7RXJdcWfczERamvGQMgOUDreeiZPnozt27eja9euwthOlmVRXV2NoqIiVFdXt/h6YmIiduzYgQceeKDFeUaOHIm6ujrU1tZi1KhR9m6LIBxKZYMWGp0BgOtbNJly10BuhO6Pf+U7eSeEq1JSY32zRVs4M+pT3aiFVs81YPJv/GLQnI6nSKhY5FY0oElrgIdChq6hPi2e6+2yItQ2K7PmdDyJUJsYPXo0zp07h3Xr1uGRRx5B79694e/vD5lMBn9/f/Tu3RuPPPIIfvjhB5w9e5ZEJtHh4N98Qn1VUClE+bVyCJMGREEll+FMYQ1OF9S0fwDR6Si2odmiLZz5hltqvGaQt1LU31M+HV9crYbBQFPIxOBSWR0AoGuozzUd8D3C/cAwXHNbqQulsG11XuBviFzpe3EUdqXjTZHL5bjvvvtw3333iXVKgnAbhCksblIPyhPorcLtSeH45WQR1h3LQ1J0krO3RLgAqampkMvlSE5ONonucG+UGRkZ0Ov1LWyXrKE59ej4dHypBPWgABf5YhhAozegvF7j0mN73YVLpZwFZLcwn2ue81LJ0SXYG5fLG5BVUusyP+8yG5venPk74WzsuhW89dZbceutt7aYh04QnZHmelD36Iw35f7BnFXahuP50OoNTt4N4QrI5XKkpKQgIyNDiISG+3sKk4/kctu9DPk33OrG5hIWRyGVCFXKZYLfI6XkxeFSmVGEhvqafZ5P0V8ubzD7vDPgI+3Wlnrwr8fSTpiOtysS+ttvvwEA7r//flE2QxDuSrGbdcabMqpXGEJ8VCir02Dv+VLc1ifC2VsinAxvIJ+SkoLbHy4FYsbjzM9f4ePvPhImH9lKoJcSchkDvYFFRb3GodkDQYSKWA/KExXohZJaNQqqmjAgtv31RNtkGyOhV9eD8iSE+AAoRU55vdnnHY1ap0dtkw5Ac8mJpXTmxiS7RGhoaCjKysoQGRkp1n4Iwi0pdNN0PMBFce4ZFIMvD2Rj3bE8EqEEgJZCFPJPcFmvs1uAAoBMxiDYR4XSWjXK6tSOFaESdMbzRAd44kRu8/hewj6EmlAz6XgAiA/hprxdLnONSGiF0e1BIWOsbuAL423LOmFNqF3p+G7dOEuX4uJiUTZDEO5KkRtNSzLHA9fHAAB2ni5BVUPnq0sizJOcnAyZQgnodVAoVaKN2HRW5EeqdDwARAWQYb1YNGn1Qi1y15C2IqFwmUhoWS33dzPEV2V1Ax//+1DTpINapxd9b66MXSL03nvvBcuy2Lx5s1j7IQi3hK8Dc8dIKMD58PWO9INGb8DGEwXO3g7hImRkZMCg0wJyBXRaDTIyMkQ5r7MmxEgrQskrVCzyKrm/p74eCgR6m48qJpjUhLKs8x0Jyuq51xbvg2sNAV5KKOWccC3vZM1JdonQp556CnFxcdi+fTvWrFkj1p4Iwq0wNaqPcpORneZ4cEgcAGDtkVwn74RwBfgmpLDRjyD+5fV4Yf7/Cc1K9uL0SKiv+DeLUYHcOSkdbz95lVyKPTbIq9WoYmyQF+QyBo1avTAFy5nw4jHEynpQgBvdKQxx6GR1oXaJ0ICAAGzYsAGxsbGYOXMmXnrpJeTk5Ii0NYJwD2rVOjRouBSKu0xLMsd9g2OgkstwqqAGf+dXO3s7hBPhBej/paTC+4apAICFaW8iPT1dFCHKR0LLHS1CJawJ5W9AC6qcFwn9M6cCs776A3O/+RMXSuqctg974SOhsUGt39Qr5TLh7y2/3pkIk7hsbHpz9jhbZ2FXY9Ktt94KgBOjubm5+OCDD/DBBx8gOjoasbGx8PJqOyrEMAx27dplzxYIwunw9aABXkp4qWy3rnE2QT4qjOsbgc2ZhVh7JBf9YgLaP4jokOj1eqSnp2P6U//EN0t/g5+HAj4eCqEmVK+3r27NGb6IWr1BaB6RMh1fXNMEvYG9xmBdav7Or8bML/8QboiPXq7EpmdvccvsTLMI9W5zXUygF/KrGpFf1Yjr44McsbVW4W+obImEAs3itbMZ1tslQvfs2SOEyvl/WZZFQUEBCgraritjWVaU6RsE4WwK3bwpyZSpQ+OwObMQ64/n4407+8BT6b6imrAd3oj+4MUyAEC4ycx4MZqTnJGO56+lkDEIFGH86NWE+3lAxgA6A4vyOjXCHZwVWfjzaTRo9OgV4YdGrR5XKhrw4a8XsOi+/g7dhxiYpuPbIibIC8gB8l0gEtqcjrcxEtpJDevtnltmOheeLw6++mvmPgiio1DsxvZMVzM8MRQxgV6obdJh699Fzt4O4WRKbJyF3R4hTmhM4iNMob4ekEkQpVTIZcLPydHNSX9kV+DQpQqo5DJ8NWso3psyEADw/Z+5KKlxv0ap/Kr20/EAFwnl1jvfpslWo3qeUL/OGQm1S4QaDAa7PuxN6RCEK9CRIqEyGYMpQzinbWpQIvghDGKLUGdEQqXsjOfhb0QLqxwbmfvfn9zv6v3XxSA60AvDugZjUFwgtHoWv5wsdOhexICPbMYEtp2Ojw50fh0ujz2NSUDz70R5PUVCCYKwgqIaoz2TG47sNMeUIXFgGOD3S+W47CIefIRzKJJIhPJCsKJeA4PBMZkxR4jQaCd4hTZp9dhmzFrcNzhG+PqkAVEAgC1ultHQ6g1CVLG97FKMMVLqEul4o0VTqA0WTQAQ7MOViHQ2n2YSoQRhJx0pEgpwKa4RPcIANEdYiM5JczpeXOEW7MNFi/QGFpUOetPlRWi4hCKU/xvgyPnxBy6UoVatQ6S/J4YmBAtfv6M/J0L/yKkQGrLcgZJaNVgWUMoZhPi0HVVsTsc3OrXMz2BghUgo3+VuLUHe3HHu9H8lBiRCCcJOijpQTSjPVKNn6A9H86DTG5y8G8JZSJWOV8plggm5o9KPUtoz8QjpeAdGQveeLwUA3J4U3qLWNSbQC70i/MCyXM2ou8D7rIb7ebZbu8uL0Dq1DrVqneR7a42aJi10xoh+cDvCuTV4EVrZyUSoXd3xV1NYWIhdu3bh9OnTqKiogFarxRdffCHmJQjC5ehokVCAe0ML8laiuEaNvVmluLU3zZPvjBTX8iJUfOEW6uuBqgYtymrV6BnhJ/r5r8Yh6fhAx6fj913gHAz47IUpw7oG41xxLf7IrsCEfpEO25M9FFVz/0+W/D31Usnh56lAbZMOJTVq+HuK73pgCXxts5+nAh4K2xxFePFaQel46ykvL8fMmTMRHx+PRx99FO+88w4+++wzfP3119esfeqpp6BSqZCYmCjGpQnCqTRodKhu1ALoWJFQD4Uc9w2mBqXODMuywvxusSOhAIRUa6mDmpOapyV1nMak/KpGXCqth1zG4KbEkGueH9aVS88fzi53yH7EwNoRyPxr05kuALzLgz2vrSDj70OT1oBGTedp2rZbhGZnZ2Pw4MFYtWoVdDpduxZMTz/9NHQ6HXJycrB37157L08QToVPxfuo5PBz0l24VEwdyqXkd50p6XS2IQRQ1aCFRseVYkgRPeQtaRw1K9sR6Xi+Mam4Vg29AxqujhjT7P1iAsxGAXkRerqwBvVOTFdbA18CYun0OT5Kz0ftnYG9nfEA9x6iknOSzFF10q6AXSJUr9fj7rvvRl5eHliWxfTp07Ft2zZ89NFHrR4zcOBA9OzZEwCwbds2ey5PEE6H7x7uSFFQnl6RfhgUFwidgcVPf+U5ezuEg+Hf1IN9VDanGNsizME2TY5Ix4f5eUAuY6A3sA65cTt6uRIAMKSVaUER/p6I8PcAywJni2ok348YFFpZYx/hx0+qct6NMv8aDrGxMx7gBv7wddKdqTnJLhG6cuVKnDp1CgzDYNmyZfj2228xduxYxMTEtHncmDFjwLIsDh8+bM/lCcLpFAn1oB3Dnulq+GjomiO5NGSik8G/qUvVTR7q67hZ2fVqnTDO0lYzcUuQyxhEGH9ejuiQ50VoWyMr+0Zz43f/zncPEVps5Y09P5mq2InpeH5kp62d8Tx8XShFQi1k3bp1AIBbbrkFzz77rMXH9evXDwBw/vx5ey5PEE7H2rt2dyI1NRWnfv4SXko5LpXWC294AJCRkSGMdiQ6JlJPAuPHGzoiHc9HJX1Ucvh4iNqPew1RDmpOqlPrhOhmWyK0X7Q/AG62vDtQIlhpWZeOL3FmJNQYuQy2IxIKdE6bJrtE6F9//QWGYXD//fdbdVxoaCgArqGJINyZog7YGc8jl8vxVnoags9vAgD8bJy8kpGRgZSUFMjlNFe+IyPYM1koBqzFkVOTShyQiufh/xYUSNycdLqgBgaWu15bjWN9Y4yR0AL3iIRaWzbBi9USJ9aEVvAeoXbUhAImkdBOJELtuiXkRWRsbKxVx8lknPY1GMh/kHBvOnIkNDk5GQCQkpKCgFuqcaLL04IATU9PF54nOiZS2jMBpul4x0VCHSlCiySOhJ4u4CKbfY2RztZIiuKev1hSB53eAIXcde3BGzSmZROWCTqhMcmJkVA+fc5HMm2FrwmtbNDavSd3wS4R6uPjg6qqKjQ0NFh1XGEhF1EJDg5uZyVBuDb8yM6OGAkFOCFaUa/BB+8sxPrf1+InvY4EaCdBqAmVwJ4JaBkJZVkWDNO2Mbk9lBoFtWNEqGPS8aeMkU1eZLZGTKAXvJRyNGr1uFLRgG5hvpLuyx7Kajkx56mUwdfCsokIk5pQqV9HrSGWCKWaUCuJi+OaFjIzM606bt++fQCAHj162HN5gnA6wrSkDjI33hxLF6WDkSvB6nVQqlQkQDsJ1lrlWAsvQtU6A+oktg8S7JkkbEricdToztOFRhFqbDxqDZmMQWK4DwAgq6RO0j3ZS2kd95oL9fWwWEzyNxZqnQE1jc6xoaqo5yKXQT722fRRTaiVjB49GizLYs2aNdBoLPuhZWdnY+PGjWAYBmPGjLHn8gThVNQ6vZBK7IjpeJ633loIVq8F5ApoNRpkZGQ4e0uEA5BqZCePl0oOHxVXVyx1St6h6XgHNCZpdAacL64F0H46HgB6hHMTqS64ugg1RkKt+X/yVMqFNLYzvEJZlkVVA9+YRJFQa7FLhM6aNQsMw6CgoADPP/98u+srKiowZcoUaLVaKBQKPP744/ZcniCcCt+NqVLIEOTdsYzqefga0DsefQ7xL6/H9ffPRUpKCgnRDo5ObxCEm1Q1oUBzh7zUzUmOFKHRAc3pYZ1emr6HCyV10OpZ+HsqEBvUfhame7ivcJwrw0esrbXRavYKdbwIrVXrhLnx9qbj+alJfGS1M2CXCB04cCAee+wxsCyLzz77DBMmTMDOnTtRW1srrGloaMDZs2fx/vvvY+DAgUJH/fPPPy+k8wnCHeGN6qMCPJ1ShyQ1pk1I7y3iRGdd0j1IfjOVhGgHp7RODQMLKGSMpL6afPNJudQi1AHTknhCfD2gkDEwsNKNJD1lbEpKiva36G9PD6MIzSqpbWelcymz8WYh3InNSXwnu5dSDk+lfY4hfDCjqhNFQu02TPvkk09w6dIl/Pbbb9ixYwd27NgBAMIvhp+fn7CWN7seP348Fi9ebO+lCcKpCJ3xEqUrnY1erxeakFiWRWyQF/IqGzF82lyky2XQ6zvPfOPOBl/rHOHvCZlMuhssXuCWOiod7yv976pcxiDC3xP5VY0oqGqSZJCFUA8a1XY9KE+3MK4m9HJZg9OadyzB1kioM22aKurFScUDLWtCXfn/SUzsFqEqlQo7d+7E//3f/2HZsmVoamp+ETAM02LKioeHB5577jksWrSIPAYJt6eoumN3xpua0TMMg3FJkfjyQDa2nyrGUmpO6tA0i1BpI4dCOl7CEZcGAyvUnIZL/P3wRAVwIlQqmya+M96SelAAiA3yBsNwqeOKeo3wc3c1hEiolX6bzjSsFzrj7WxKApqFrFpnQKNWD2+VtIMVXAFRvkO5XI7FixfjxRdfxNq1a7F3717k5OSgqqoKvr6+iI2NxahRozBt2rR2R3oShLvQ7BHacTvjTRnXNwJfHsjGrrPFLu83SNhHc6mJtK9tXmyU10snHiobNNAbWDCMONEqS4gK9AIuV0rSIc+yLM4aI6F92rFn4vFUyhHl74mC6ibklDe4rgi1sWwiwomjOyv5zng760EBwFslh0ohg0ZnQEW9hkSotYSFhWHevHmYN2+emKclCJekI09LMseQ+CAEeStR2aDFkZxK3JQY4uwtERJhmo6XklA/PhIqXTqeT/EGe6ugdNCNU7Rg0yS+KCqtVaOmSQcZA8F6yRLiQ3xQUN2Ey+X1bY75dCY2NyYJNaFOEKEieYQCXMYpyFuJ4ho1qhq0iHXN/yZRoVAGQdhIR56WZA6FXIbb+kQAALafLnLybggpMW26kxJHjO50ZGc8T6SEXqF8h3uXYG94KCwva0sI9QYA5JRbN1zGUbAsK9yMWPt/xa8vkbCsozXErAkFOp9XKIlQgrCRYge9UbsS45KMIvRUcYt6b6Jjwd9gRUj82g7x4dPxEkZCnSBC+TKGgirxI3MXSjkR2j3cr52VLYkP4aKmOWX1ou9JDOo1ejRq+ZGd1v1f8evLHTAC9mr4EZtiREKBzucVSiK0HcrLy/HTTz9hwYIFGD9+PJKSkhAeHg6lUgl/f3/07t0bM2bMwPr162EwWOcJt3HjRkyZMgUJCQnw9PREeHg4br75ZixZsgQ1NTUWn6eurg7Lli3D2LFjERkZCQ8PD4SFhWHYsGFYuHAhiouLrf22bWL37t2QyWRgGAYMwyAhIcEh13UGOr1BuOvuqN3x5hjRIwyeShnyqxqFDl2i4+GoUpPmdLx0EawSodnFcSI0OlC6+fF8JJT3/rSULsFcJDSv0jUjofxrwFslh4+FIzt5+BrXRq0eDRrHTk2qFCKh4nhFd7ZIqCg1oXq9Hps2bcKWLVvw999/o7KyskWXfGswDIOLFy+KsQXJ+Oqrr/DKK6+Yfa62thbnzp3DuXPn8N133+G6667D2rVr0b179zbPWVdXhxkzZmDjxo0tvl5aWorS0lL8/vvv+PDDD/G///0PN954Y5vn2r17Nx566KFrhGZZWRnKyspw5MgRvP/++/j8889x//33W/Ad20ZDQwOeeOKJThMdK6vjmh0UMsZli/ylwEslx8geYdh+uhjbTxWjbzsjAwn3g2VZIR0v9Q0WH8GqVevQpNXb7bNoDmem40tqm0Rv4ssqtk2ExgRKF50VA1vrQQHARyWHp1KGJq0BZbUadAlxXENPhTFiGShSJDRQ8ArtHIb1dv9PnT59GlOnTsXp06dbfN0SMeIuHlhyuRwDBw7EkCFD0LNnT0RFRUGlUqGyshJHjx7F2rVrUVVVhWPHjmHEiBE4ceIEwsPDzZ5Lr9djypQp2Lp1KwAgIiICc+bMQVJSEioqKrB69WocOHAAubm5mDhxIg4cOIA+ffqYPde+ffswYcIEYWTq4MGD8dBDDyE+Ph7V1dXYsWMH1q1bh4qKCkydOhUbN27EHXfcIcnP6PXXX8elS5fg4+OD+nrXTPeICV/rFeHvCbmEPoquyLi+kZwIPV2Mf47t6eztECJT2aCFRsdldaS2NPL3VEAll0GjN6CsTo3YIG/Rr+EMERrq4wGlnIFWz6KkVo3oQPFcBprT8daJUH4PxbVN0OgMUClcKxHKR0JDrbRnAjgtEeLjgfyqRpTVq9ElRPzXUWtUilwTyovQ6kYSoe1SWlqK2267DSUlJYLoVCgUCA0NhYdHx4gOTZ06FU888QQCAwPNPj9nzhy89dZbmDhxIv744w8UFRUhLS0N//nPf8yuX7FihSBAk5KS8OuvvyIiIkJ4/plnnsHLL7+MpUuXorKyEnPnzsXevXuvOY9Go8HMmTMFAfrCCy/gX//6VwthP2fOHOzcuROTJk2CWq3GrFmzkJWV1WKAgBgcPHgQH330EQBg4cKF+Oc//ynq+V2Rok7WlGTKbb3DIZcxOFNYg9yKBsQFO+4PPiE9/Gs7xEdlVeOLLTAMgxBfFQqrm1Bep+kwIlRmNKzPq2xEYXWjaCK0ulErfD+JYZZ3xgOcuOPtf4prmlzu99ZWeyaeUD9OhDq6LlTsmtAAr84lQu26FVqyZImQBh40aBC2bNmCuro6FBQUIDs726IPVycuLq5VAcoTEhKCTz75RPh806ZNZtfp9XqkpaUJn3/zzTctBCjPO++8g0GDBgHgop3bt2+/Zs369euRk5MDgIuALl261Gxk+fbbb8cbb7wBACguLsYHH3zQ5vdiLU1NTXj88cdhMBjwwAMP4N577xX1/K5KZ+uMNyXIR4WhCZx3yPbTjqk3JhxHUQ0X5XfUa1vqDnlhZKeDy2aiJWhO4utBI/094edpXQ0iwzBCSj6vUvyufXsprbU9HQ8AocZIpJROC1fDsqzQQCRaJNSLO09nGd1plwj9+eefAQDdu3fH/v37MX78eKhUjjEDdjX69u0rPC4qMm9fs3fvXhQWFgIARo0aheuuu87sOrlcjueee074fPXq1des2bVrl/B45syZkMla/6+cNWuW8HjVqlWtrrOFN998E+fOnUNgYKAQDe0MCBY2nagpyZRxSZEAgO2nyKqpo1FUzb2JO8r1IcRXWvHgjEgoAERJ0Jx00camJJ7mulAXFKHGCKatIpR/HZU7UITWNOmgN3BZYD6Nbi8BfE0oRULb5/Lly2AYBk8++SS8vV0rtO9oLly4IDyOjIw0u2bLli3C44kTJ7Z5PtPaTdPjePLy8oTHvXr1avNcsbGxwv/PuXPnkJWV1eZ6S/nzzz+xdOlSAMC7777b6vfdEenMkVAAGGu0ajqSU9Fpujg7C0Um9c6OoDkSKv7rSK3TC2lNR4tQ/m9DgYheobbWg/LwXfuuKEL52soQG2pCAWlfR63B79lbJRetqY7S8VagVHI/rI5sxWMJdXV1ePbZZ4XPJ0+ebHbdyZMnhcdDhw5t85yRkZGIi4sDwKXRS0tLWzxvTxd6ZmamzcfyaLVaPP7449Dr9Rg9ejSeeOIJu8/pThQLFjadY2Tn1cQFeyMpyh8GFth1hlLyHQlHGdXzSJmO5wWJUs4Ib+6OItYYdcwXMfVtqz0TD1+bmu+KItSYfrb1/ynEAYMPrkbMaUk8QmMSdce3T7du3XD8+HFUVFSItR+XpqSkBAcPHgQAGAwGVFdXIzMzE2vWrBFS8Ndffz1SU1PNHn/u3DnhcdeuXdu9XteuXZGbmyscGxYWJjxnGnU8f/58m13v+fn5aGho9oY7e/Zsu9duj4ULF+LkyZPw9PTEZ5995jZOB2JR6OC6OVdkXN8InC6swfbTxZgyJM7Z2yFEotBBIzt5QoV0vPgRLNM6Q0f/jeKbrMSsv8wqqQVgfzreFUVolZ0NPqFCOt6BkVCR60EBk5rQRi1Ylu3w7612RUIfeOABsCyLnTt3irUfl+bYsWO47777cN999+GBBx7A448/jg8++ABFRUUICwvDq6++iv3798Pf39/s8VVVVcLj0NDQdq8XEtI8m9v0WAAYMWKE8HjlypVtRka//vrrVvdhCydOnMDixYsBACkpKejRo4dd5wMAtVqNmpqaFh+uisHAothYN9epRaixLnRfVikaNXon74YQiyIHR/mbp92IH8EqMUZ1wx2cigeA2CC+CUgcc/gmrV4QtB1RhNobVRReR/WOi4RW1HPCWax6UNNz6Q0s6tSONd53BnaJ0GeeeQZxcXH48ccfceDAAbH25JaMHDkSI0eOhKdn66Kkrq5OeNzWOh4vr+Y3gdra2hbPTZ48GcHBwQA4cfzqq6+aFaK7d+/GwoULW3zNHoGn0+nw+OOPQ6vVYuDAga0a+VvL4sWLERAQIHzwpQiuSEWDBhq9AQzjnDc3V6FPlB9ig7zQpDVgb1Zp+wfYSKNGj+2nivDd4Ss4XeC6NycdBcGoPsAxr20p0/HCtCQ/x98sxhhFaE2TDjVN9qdWL5bWgWU5kRJiY+SN31NBVaNLDRZhWVZoxLFV0IVIGFFvDbE9QgHAUykXPFw7Q12oXSI0ICAA69evR2hoKO68806sXLnS6tGV9jJ69GhhTKS9H2vWrGnzWhMmTADLsmBZFjqdDoWFhVi/fj1uu+02rFu3DpMmTcL06dNbpL6lws/PD//+97+Fz9977z0MHToUS5cuxffff48VK1Zg2rRpGDt2LJqampCYmCisbauTvj3effddHDt2DHK5HCtWrIBCIc5kitdffx3V1dXCB1+G4IrwkaJQXw8oRZyE4m4wDGPSJS9eXWhqaioyMjLAsiz+ezAHNy7ehSe/OYoFP53EzVP/gZunPAWt3rF/ZxwNy7L4ObMQT/z3CF7+/gQulda1f5AI1Kt1qG3ioi+RjoqE+kmfjpfadN8c3iqFIE7EqAsV6kHDfG1O0fKZmyatQfC3dAUatXphQEKQjYKOv5mpbNBA56C/D1LUhAJAoFfnmZpkl4J4/PHHAXD2RL/++itmzZqFV155BUOHDkVoaGi7YodhGHzxxRf2bMFpyOVyREZG4p577sE999yDBQsWYPHixYKd0nfffXfNMb6+vqisrATA+Wv6+radUmlsbP7DZc5gfsaMGWhsbMS8efOgVqtx9OhRHD16tMUamUyGtLQ0VFZWCh6hQUFBVn2vPGfOnEF6ejoA4LnnnsOQIUNsOo85PDw83GbAQXm9fVYiHYlxfSPw5YFs7DpbLNp4QrlcjpSUFPx2vhQXYsYD4NKINb+vweX9q3D6lhl4bd1JLH1woN3XclU++vUClu44L3y+5WQhvptzIwbGBUp6XT4K6uuhgK+V87ttJcSnpXgQc8SlM+bGmxIb5IWKeg3yKhvRJ8p8mZal2GvPBAAeCjnC/DxQWqtGfmWjqBE8e+AFsVLOwEdlW5d5kLcKMgYwsFy2KtwB0W8pakIBLhpcUqvuFJFQu/7KfP3118IdGf9vWVmZWUuh1rBXhE6ePFkwdreX9qyO2iIjIwM//PADsrKysHr1aqSkpKB3794t1gQGBgoitKysrF0RWl5e3uJYczzxxBOYMGECPv74Y2zfvh0XL15EfX09IiMjMXLkSDz77LO44YYbMHPmTOEYW6yUDAYDHn/8cajVaiQkJCAjI8Pqc3QUyoUZx67xB9yZDIkPQpC3EpUNWhzJqcRNiSHtH9QOycnJOJ5biR8/fx8Bt1TgnYVpKPptFVI3fo7Hnn0Ve31HYd2xPNzWJxwT+0eJ8F24Fn9kV+BfOzkB+tCwLjhXVINjV6owb/UxbH1+JHwkFIfOmAQW7COdeCitNdaEOiESCnAiNDOvWpS6UHvtmXhiAr04EVrViP6xAXbvSwz4tHagt8rmKK9cxiDYR4WyOg3K6xwjQnl7uiARa0KB5uYkEqEWYE9diRhdX/PmzbP7HGIgl8sxbtw4wYNzz54914jQXr16CVOisrOz27W2Mp0o1ZZAjo2NxaJFi7Bo0aJW15w6dUp4PGzYsDava46TJ0/i0KFDALjI9/vvv292nWnTU3V1dYt61FdeecVtop1Xk5qaCrlcjuTkZKH7kq/LysjIgF6vb9UVoSOjkMtwa+8IrDuWh22nikQRoeeLa3EyfCwCbilB9f5VeG7c99BoNEhPT0dycjLe23YOH+2+gEW/nMHtfSJcbga2PbAsi3e3ngXLApOvj8Xi+/ujulGLicv2IbeiEV8dyMa8W+1vBGwNQYQ6cAiDqXgoqxVbhBrT8U6oCQXE7ZC3156JJybQC8dzq1yqOam5M94+MRfi4yGIUEdQaWxMsrWEoDX8KR1vGe4wdtORmKbM+YinKf379xfmxh85cgRjxoxp9VzFxcVCXWR4eHgLeyZrKS8vFzxKfX19MXjwYKvPYXqz8fPPPwvTstqiqqoKycnJwufz5s1zWxHKp4gBQDGE84EN8fVARkYGUlJShDKFzsiEfpFYdywPv5wsRPKkJMhltt9canQGvLDmODQ6A+59/Dms/oMToCqVSngtPTOmO9YcyUVeZSN+PJaHacO6iPWtOJ3D2RX483IlPBQyvDKeu/EM8FLi1Qm98Pya41i+9xIevTnB6pGNltLclORY0caLB7Gbk0qcNC2JJ0Ykr1Cd3oDssnoA9otQ3rC+0IVEKJ/WDrSztjLEVwUUO84rVEjHi10TKkxN6viDQOwKIcTHx9v90ZEwnURkTjROmDBBeNxeycIvv/wiPG5vulJ7fPPNN9BquTuqRx55xG2FoDNJTk5Geno6UlJSsPlrbjzpHz9+JghQU7Hd2RjZMxT+ngqU1KpxOLu8/QPa4NPfLuJ0YQ2CvJWIvPizIEA1Go1QAuKlkuOpUd0AAF8fzHGpLl97+d8R7sbz/utiWvh03jUgGt3CfFDbpMP64wWSXb/QON3HUUb1PHxzkpj2OgYDK4gRZ7lYCDZNVfal4y9XNECrZ+GllAsz6W2Ff13xAt0VqGoQJ60tpdOCOYTGJLFrQr06j2F9x8ljOZkrV660EJbDhw+/Zs2oUaOEesw9e/bg2LFjZs+l1+tbdL5PmzbN5n0VFBQIUTqVSoXnn3/epvMMGjRIcAZo68M0Oh4fH9/iudbqWt0FXoge/N/HuPzevdj81bJOL0ABrtmBr83caIdAyq1owH92c+Nv+xTtwDtvpSM9PR1qtVq4AeCF6JTr4+ChkOFsUS1O5FXb/024ALVNWvzydyEAXGP+L5MxePgG7qZ91aHLkgnvwirnREIF8VArXuSnqlELrZ5tcX5HI1Y6nk/FJ4b7QGZHpgEAwo0itLhGvJn29lJpp1E9jzA/3gGjhA0GVrR9X01nGt1JIrQNioqKkJaW1u5EqPPnz2PixImCNdOYMWPQp0+fa9aZpnQBYObMmSgpKblm3WuvvYbjx48D4MTs+PHjzV43Ozsbly9fbnVfp06dwq233iqUBqSlpbVZW2pqV5WTk9Pqus5McnIyZHIloNdBqVR1egHKc/fAaADAlr+LBKsVa1n482modQb4ndmA1Z+810Lgm0aiMzIyEOCtxJ1G4bvuaJ4434ST2XOuFE1aA7qF+mCwmS74B66LhcoovM8W1V57AhHgxRKfRnYUfIe8mBGsEmNTUpC30ml1w7wvZ1WD1i7jcVN7JnuJMEaFXSkSKlY6vvlmRvrvrbZJB72Bu8kR06ze9HxUE2olWq0Whw8fxunTp1FRUQGNRtNCdLkbTU1NSE1NxcKFCzF69GgMGzYMiYmJ8Pf3h0ajQV5eHvbt24dt27YJ6e6YmBisWLGi1XPOmTMHP/30E3bs2IFTp05h4MCBmDNnDpKSklBRUYHVq1dj//79ALiO+OXLl7d6rqNHj2Lq1KkYPnw4Ro8ejR49esDT0xNFRUXYvXs3Nm3aBJ2O+8M3e/ZsvPrqqyL+dDonGRkZMOi1gFwBrZZLEZMQBW7oFoJwPw+U1Krx2/lSjE2KsOr4386XYtupYshlDEb1CMGDZiLM/Od6PTed6a5B0fjxr3xsPVWEtLv72h0hcjY7z3Beq2P7Rpht2gzwVmJ0zzBsP12MnzML7bb8uRqWZYVmFT6C5yik8Ap1dlMSwFldBXorUdWgRX5lI3pFXmu1Zwli2DPxRJhEQl1lLKR4jUmOi4TywtlHJYen0jZbqdYI8OZHd3b8mlBRRKhGo8HChQvx0Ucfobq6ZWrsahH6yiuvYMOGDYiLi8OuXbvEuLzk6HQ67Ny5s93xpOPGjcNnn33WZq2rQqHAunXrMH36dGzevBlFRUVm7Y5iY2Oxdu1a9O3bt81rGgwG7Nu3D/v27TP7vLe3N5KTkzF//nyX+GPjzvBNSMEjH4bfTdMwWXZYeH13diEqlzG4e2A0VuzPxtojuVaJULVOj9SNnHvDYzcnIHlS6zXQpj/n4Ymh8PNUoLRWjaNXKjE0Idj2b8DJ6PQG7D7LZUXG9mn9Z3fngChOhJ4sxMvjbbeUM0d1Y3O0ztGRUClq+UpqnNuUxBMb5IWqBi3yKhtsFqHN9ky2HW8Kb1fVoNGjTq2TrMnNGsQyfQ92oAitkKgeFDCpCW3s+GM77Rah5eXlGDt2LE6cOHFNnZI50XPvvfdi6dKluHjxIv78809RDc/FJiEhASdOnMDOnTuFCG9eXh5qa2uhVCoREBCAHj16YNiwYZg6darF1kd+fn7YtGkTNmzYgJUrV+LIkSMoKSmBn58fEhMTcf/992Pu3LkICGjbw23MmDFYvnw5du/ejczMTBQXF6OmpgahoaHo1q0b7rzzTsycORMxMTFi/Dg6NbwAfSPlTXyrHsp9LfVNBHgpSYgamTasC1bsz8avZ4uRX9VosZD5Yn82ssvqEebngRdut9x+SKWQ4bbe4Vh/vAC7zpS4tQjNzK9GTZMOAV5KDO7S+jCJ2/pEQClnkF1Wj+yyenQN9RFtD3wqPtRXBS8bDcNtJVQYuShmOt65TUk8cUHe+Du/BpfLbWtOMhhY0eyZAG6Sk5+nArVNOhTXqF1EhIozg52vCa1wwPz4ynpppiUBJjWhDRQJbZcHHnigRf3izJkzkZ+f36plzfDhwxEbG4v8/Hxs2bLFpUUoAAwYMAADBgyQ5Nz8tCVbCQkJwZNPPoknn3xSlP2I0eyQkJDQobqVefR6PdLT0/HQ3Bfw7b/2ws9TAS+V/JoUcWeme7gvbk4MwcGL5Vh9+IpFkbqCqkZ8uItrRlowsbfVb4ijeoVh/fEC7D1fitfu6N3+AS7K7xc5V4EbuwW3aXHl66HA0IRgHLxYjt/OlaBraFfR9uCselCgORIqpr9jqZPtmXjiQ7gbhcvl9TYdX1jThAaNHgoZg/gQccokwv08UNukQ0lNkyjC1l6qxLJoMtYWVzjAJ1QwqpciEipYNHX8mlC7qrV//PFH7N27FwzD4OWXX8a+ffswZ86cdn0ob7/9drAsi4MHD9pzeYJwGKmpqUhOTkZRNffGZmrmnZyc3CmN6s3x8I1cKcqaI7kWNSgt/Pk0GrV6DE0Iwr2DrI/Yj+jBWaGdLqwRRIc7cugSJ0Jv6ta+2f+ontz3vOd8qah7cFY9KGAiQuvVot3E8o1JzhahXUO5n2e2jZFQPgqaEOoDpUgjTV3NpqlSpMlDwcZIaL1GjyattIEBvo41WOSmJKB5YlKDRm9zo6e7YNcrmp+PPmDAALz77rsWH8dHFs+dO2fP5QnC4fA+io62sHEXxiZFINzPA2V1amw80bZd009/5eGXk0WQyxik3d3PpprlUF8P9I3mGnQOXiyzac/ORqc34M8czsHipsTQdteP7hUOgBOuYr7R8qMl+Y5uR8KnUbV6VjRbGqExyYHTn8yRYIyE5pTZFgkVszOeJ8KFbJr0BhY1TVzto72RUD8PBZRy7u9IhcR1oVLWhPp5KsD/OezoNk12idA//vgDDMPgoYcesuq4iAiu8L60VNw7eYKQGv6PtiPHGroTSrkMs4ZzKeL/7L4And78XfyV8gYkr+eakZ6/rQeSom3v9OZrQY9dvnZKmTtwsbQejVo9fFRy9LAgNdozwheR/p5o0hpwOLtt+zhr4Kf6xDpBhHoo5PDz5KrDxOqQF9LxTvII5eHrdvMqG2yKap032nH1tLGpyRx8c1JxjfMjoaYiy96aUIZhmpuTJE7JS1kTKpMx8Pfkm5M6dl2oXSKUF5HdunWz6jilkvvhajQd+4dLdDwKjbO1HT1Rxp2YeVM8gryVyC6rx3vbz1/zxlvdqMXcb4+iTq3DsIRgPDOmu13XG5LANfL86aYi9FQB5yiSFO1vkc0UwzBCSv63c+LdyDuzJhRoFotiNScJjUn+zhWhYX4e8FbJYWCB3ErrU/LnijkR2itCPBEaYbStKq51fiSU74znopj2lxsE+zSXdkiJlDWhQOfxCrWrMcnT0xMajcZqMcmL16Cg1rtACcIV4SOhESRCzZKamgq5XI4Xbn8Eb248hU9/u4gfjubhg6mDsHvNJyiqasCF2DtwrrgWob4eeH/aILtmzQPA9fHc35EzhTWoV+vg4yGq/bHk/J1fAwDoG922G4Ypo3qFYe2fudh/QTwR6syaUIArrbhUVi+KCG3Q6AS7KWd3xzMMg/gQH5wprEFOWT0SrUirGwwssngRGil+Or7EBdLxQlOSjzi1lbxXqNTp+OaaUIlEqJcSl0Hp+DaJiuImlpw5c8aq4w4dOgQA6NpVvM5OgnAEFAltG34qWM6OlUKTTVmdGpMefwEpKSlY9UcuzhXXIszPA9/MHiZK1C0qwAsxgV4wsMCJ3Cq7z+do+EhovxjLRegNXbkShPPFdUJa0B5qm7TCm50zakKB5rpQMabd8Kl4T6UMvi5wUyI0J1lZF5pf1Yh6jR4quUzosheDCBdKx1fWizv6stmmyVE1odJYXPl7dY5IqF0idMSIEWBZFt9//73FHY1lZWVYt24dl1IaNcqeyxOEwxEioVQTahZ+vGZq6ptIKt6B0+njkXBlC6r3r0LALTMQdMtDuLN/FDbNu0XUiT/XGaOhR90sJW8wsDhdwEdCLf95hPh6CNY6f+TYXxfKR0EDvZVOE23NHfL2i4cSk2lJrjCkQ2hOstKm6bwxCtotTLzOeKB5ihQ/NcmZiDWyk8dRhvVS1oQCzT+Pjm7TZNer+uGHHwYAZGVl4a233mp3vUajwcMPP4yGhgYwDIPHHnvMnssThENR6/RC00RUgHOiRe6A6Zz3ID8f/Lb6P/i/lFQc/v4THE8Zh//MuE50d4HruwQCcJ+60NTUVGRkZCC3sgG1ah1UCpkgKjMyMiyy/OKjoX+I0JyUV+HcelBA3KlJruIRypMQynuFWlcTKtSDitiUBDTXyap1BtQ4eSqPWCM7eYR0vISNSQYDK4jDYKlqQjuJYb3dkdA777wTLMvizTffxNy5c3HhwoVr1jU0NOCnn37CDTfcgB07doBhGDz88MPo3dt9zaWJzgc/BlClkIn2B7OjkpycDJVKBY1GA5VKhYy0N9Er0k+YBCI2Q/gO+SuVMBhcf1gCX7bwRkoaAKB3pB+UcpkwmUsub39i0TCjCD2cXW73fgR7JieKUD6NWlorQiTUmLFwdj0oD98hb206XuiMF7EpCQA8lXLhd7HEyc1JYo3s5HFEY1Jtkw56498Zezv6W0OYmkSR0Lb59ttv0adPH7AsixUrVqBXr16YPn268HxYWBgCAgIwefJkZGZmgmVZDBw4EB9//LG9lyYIh1JkYs/kCik+VyYjI0MQoBqNBhkZGZJer3ekH7yUctQ26XDJRj9GR8JHi1d9vARVB1ajb3SAIEDT09MtGgF7Q1eu5vZ0QQ1qmux7o8oxRugSRBwDai2mhvX2UlrnGiM7efhJRwVVjVDrLPd2PVfMeYSKLUIB59aF8pkA4NqRnZZmAlrDEel4vh7U10MBD4U0I247y9Qku0VoQEAADh06hKlTp4JlWbAsi8bGRuFNury8HHq9XnhuypQp2Lt3L7y9ndOBSRC2UlRNHqGWYCqm1Gq1kJqXUogq5DL0juLeqM8U1kh2HTFJTk7GwHufRPX+VXhv2hCrBCjADUyID/GGgQWO5thXhsBH6MScRW8tYX7izY/nsxauko4P8/WAr4cCBpbzyLUEnd6Ai6WcCBXTnomHrwt1RiSUzwRkZGQI3fFB3iqrMgGt4YjGJP7cUkVBgeZIKDUmWYCfnx9Wr16NEydO4MUXX8SQIUMQEhICuVyOwMBA9OvXD8888wwOHz6MtWvXwtfX+bNqCcJaBBFKnfGtYi6aZ1ojKqUQ5RudTruJCAUAj6FTALkCOi0XNbZUgPLcIKTk7asL5RtmnClChZpQMdLxJo1JrgDDMEgM4362WcYJSO1xuYIzt/dSyiUZIBDqK57otxbTvwn7v18OANj27X+svhEzhyNqQnnhLFU9KNDcmNTR0/GitkH2798f7733npinJAiXQUjHkwhtFb1eb/ZNhP9cr5dunnOSUYS6SyS0ulGLc1u+BvS6FmUL1rwBD+sagv/9mYc/7KgL1egMyK3gonPOFKEhRhHaqNXb7ffqao1JAJdSP5FXjfPFtZjYP6rd9aeMrgk9I/0sGmJgLc2NYM5pfOFf5ykpKcDPX+GyXme3AAWAEGNNaK1aB7VOL0m6vELiznig89SEOt9AjSDchCIa2dkubdVy2fvm0h5CJLTAPUToa//3Jqr3r0Ls7Y8hd8dXQhQZsPxnxUdCM/Oq0aDRwVtl/Z/0KxUNMLCAt0ru1BpKH5Uc3io5GjR6lNSq0dUOEVrioiIUALKKLYuEZho9bwfGWu4faw2hfnzk2XleocnJyXgzLQOsXgulDZkAc/h7KaCQMdAZWFTUayRxMql0SCSUT8dTdzxBEKB0vKvTO9IPDMMJkHInpBitISMjA5/+azECbpmB0dOeAmBb2UJskBeiAzyhM7D460qVTXvJMakHdWbDHcMwwg1esR2TfLR6g9Dc5OyRnabws99526X2yMznhhj0t2KIgTXwkdBSJ/6upKeng9VrAbkCWpEaGBmGEUZpSjU/vqK+ZTOVFASaRELdwfHDVigSShAWwotQMqp3TXw8FEgI8UF2WT3OFNbilh6uI0CuRq/XY8z0ebgUN6FF57O1ZQsMw2BY12CsP16Aw5fKMbx7qNV7cYWmJJ5wf250pz0itKRWDZYFlHIGoT6u8xroGcH1QuSU1bebJtYbWJwyitCBcYGS7EeYUOWkdHxGRgbefPNNBNwyA4HDH8LDHkeszgS0RoiPCqW1asmak3ijeqlGdgLNE5MMLFCn0cHfs2PaApIIJQgLMBhY4Y0xOpBEqKvSJ8oP2WX1OF1YjVt6WC/IHEVqaioe+eIwLmWVoUd4y0ZNq5uTuoVg/fECHLKxOYm3tOrmAiI0QoRIaFF1o3AuKWopbSXS3xMBXkpUN2pxoaQOfaNbj3BeKq1DvUYPL6Xcqlnz1hAm4nAAa+FLT15ekIzv9TdAIWOQkfomPBRyUYRosMTz4wVvUwnT8Z5KOTyVMjRpDaiq13ZYEUrpeIKwgLJ6NXQGFjKm+Y834Xo0NydZlvJ0JnxtYA877Xf4utDjuVVo0lrf+JVdxu2ja5griVDbhVGhMWMR5WJlMwzDoF8M9/r82xjlbI3MPO75fjH+kEskpPl0fEW9xuHpXr6B8bFnXgLAdYIzDCOUpNjbwBgi4ghYcziiJhQAAr06foc8RUIJwgIKq/gJLJ5QiDjDmRAXd2lOqm7UCo1uPSLsi3R1DfVBqK8HyurUOJFbhRu6hVh1fE6Z0ag+xJVEqD2RUNctm+kXHYADF8rxd34Npg5tfV1mXhUAYEBsoGR74dPxegOLygaNINwcAd/AeOBCGYCWIzvFaE4SbJokmprkCJ9QgOuQL6pp6tAilN5NCcICCqkpyS3obRShF0vroNUbnLyb1rlg9IqM9Pe0O83GMAxu6GabX2i9WieIYVeoCW2e4mO/CHW1SCgA9DU2Gf1d0E4k1BgpHSBRZzwAKOUyQUQ5qy5U7JGdPMESNybxU56kjoR2BpsmEqEEYQF8nZkrvrERzUQHeMJbJYfOwOKyhZNpnEGWsUPa3igoz402zpHnTeqDfVSCObYzESUdL/j5im/NYy/9opsj9a3dJGn1BiGSL1VnPE+oE+tCgWtHdoqFlKM7DQa22axe4t+ZAGF0Z8e1aSIRShAWUEhG9W4BN5mGE3b8yENXhJ+a0yNcnHGMw4xz5I9eroRGZ3kEmI/IJrpAPSiAFhZNLGtbnaIrR0ITQnwQ6K2EWmcQzOivJjOvCmqdAUHeSslLJJw5NQkAqiQyfQ+RsDGppkkLvoRW6hs3ioQSBAGg+Y0t2gWjK0RLuhu7zS9YOB7RGVwyCuTEcHFERo9wXwR5K9GkNeBkO00vpvANXL0ixZ9Nbgu8ubxaZ7D5jdeV/XxlMgZD4rmo9Z855ksnfr/IRbNv7BYieXe/s6cmCZFQH2kioVKIUP6cfh4KqBTSSijBK7QDz48nEUoQFkA1oe4DH9W76MIiNMdYKtBVpEiXTMb5hQLWpeTPFXHRuN6R/qLsw148lXIhNWtLSt7USs1VJ5sNTQgCAPzRSv3u75e4/7+bEq1rMLMFZ6fjqySqCRW64yX4vvg6VrGFszkoEkoQBADXTvERLREioS6ajtfpm2e1J4jYDMSn5A9fsrw56WwRFwntE+UakVAAdk1NamGl5kIjO00ZksDdLPyRUwH9VdZIDRod/sypBADcZKXLgS2EOXl0Z3NjkriCjk/H1zTprCpPsQR+WpLU9aCA6ehOEqEE0WlhWdalU3xES3gRerGkzua6QinJq2yEzsDCQyETNVrH+4UevVwJnQXOANUNWiHC39NOr1IxCbdDhBZXN8+MV7qoldrA2AAEeClR1aDFsSuVLZ777Vwp1DoDugR7C69jKeHFmvMbk8QVdAFeSsFftVLk2euOMKrn8e8EkVCLfEJvvfVWSS7OMAx27dolybkJQiwq6jXQ6A1gGM4nlHBt4kN8oJAxqNfoUVjdhOhA16rjzTZ2pCeE+Iha89cnyh9+ngrUNunwd0ENBrUz7pG3CYoL9oKfC01jifCz3aap0Ohi4Yqd8TwKuQxjeoVh/fEC7DxTjKHGyCgAbD9dDAAY3zcCDCP9tCdn14RKlY6XyRgEeStRVqdBeZ1GVM9YR4zs5OkM6XiLROiePXtE/4VgWdYhv2QEYS98tCjU10PyQnTCfpRyGbqEeONSaT0ulNS5nAjNkWhWu1zG4ObEEGw7VYz9WaXtitATDjBEtwU+22BLTSjveRrlovWgPLcnRWD98QL8nFmIV8f3hlzGoKZJi22nigAA4/tGOmQfoX6uYdEkdjoe4JqTyuo0ojcnVfA1oQ5Jx3f8iUkWv6OyLCvqB0G4C646BpBone4ubNPEi1Ax60F5RvQIAwDszSprd+2J3CoAwCAXE6H2pOPdpYHwtt4RCPBSIq+yEXvOlQAAfvgzDw0aPXpG+OL6+CCH7IO3aCqv0zj8fVlvYFHTJE06HjD1ChVXYAuRUGpMEgWLRKjBYJDkw975sAThCHijelfttiWuxZVtmrL5zvhQb9HPPdIoQo9drkS9WtfmWn4+uZRTeWzBnnR8sZuIUC+VHFOHxgEA/rXjPIqqm/DxngsAgJk3JTgsS8in4zV6A2oa2369iE11oxas4LcpvqDjO+TFjoQK0VsH1ITyFk11ap1LT4CzB8otEkQ7UCTU/RCak1w5EiqBEXmXEG/EBHpBZ2Bx3BjpNEdhdSMKq5sgY4B+Ek/lsRZeQPK/d9ZQ4EY3jE/c0hWB3kqcKqjBjYt3oaxOg14RfpgyJNZhe/BUyuHnwVXllTo4Jc/Xg/p6KCRpIpPKsN6RNaF8YxIA1HTQaCiJUIJoh+bOeNeqLSRah091u9roTo3OgLxKPhIqzTQcPpXLW/2Y45DRi7J/TAB8PCxqDXAYMcYa3pJaNdQ667JleZWcCI0Ncv3f1XB/T7z/4CB4Krm34Qh/Dyx7aBA8FHKH7sNZdaFSjezkCRY6/923JlQuY4SbhI6aknetvz4E4YJQJNT94KOMhdVNaNLq4al07Bt7a+RWNsDAAj4quWQ+lkMSgrDxRAH+vNy6X6gwlccBhujWEuyjgpdSjkatHgVVTRaLdZ3eIPyuxgWLX+ogBWN6h+P3127D2aJaDIwLgLfK8W/Job4qZJfVO1yEStUZz9McCZWqJlR6EQpw8+Nr1TpUdVARSpFQgmgHoeOWRKjbEOSthJ8n94Z+pcJ1oqF8Kj4+xEeyuj8+EvrXlSqzkUSWZYWpPDc6wBDdWhiGESKZ+cbIpiUUVjdBb2ChUsgQ5uuaRvXmCPJR4abEEKcIUMDEpsnBhvXSR0LFrwnVG1hBDAY5oDEJ6PjNSaK+6vV6PTIzM5GXl4eamhqLGo9mzpwp5hYIQlRYlhW8B6MoHe82MAyDhBAfnMyvRk5ZvcuYsfPjOhNEbkpKTU2FXC5HcnIyekf6I9LfE0U1Tdh9tgRHfloBvV6P1NRUAMD54jrkVjRCpZBhmIlHpSsRG+SFrJI6oXTBEvgpVLFBXpLPXO9IOMsrVOpIaHN3vHjfV41JM5VU+74aXqR31PnxoojQ/Px8pKWlYfXq1WhosPyPBsMwJEIJl6a6UYsmLdeVGO7vPtEVAogP8cbJ/GqXqgvlhZLY6WK5XI6UlBQAQHJyMu4ZHI3lv13C/72ZhqM/Lkd6erqwdsvfhQCAkT1CXa4elCfGGAnNsyISmmsUrHFB7pGKdxV4ESq2lVF7SDWyk4e3nxIzEsrXg/p5StNMZQ6KhLbDkSNHMHHiRFRUVJD/J9Hh4GvMQnxULlNXSFgGXxeaY5xQ5ArkSSSUkpOTAUAQotOefAHvLHoLl/evwkuvJwvPsyyLzZmcCJ3QL0rUPYhJrPHnY10klBOsccGUsbCGEKNYK611bCRUqpGdPHwktKpBC63eIIpo5OtBHRUFBZpFaEedH2+XCK2vr8d9992H8vJyyGQyzJgxA7fccgueeuopMAyDefPmoVevXsjOzsbWrVtx6tQpMAyDhx9+WLJRoAQhJjQz3n2JD+GEjGtFQnmhJH60zlSILly4EBqNBgG3zIDvjVOFNfsvlOFCSR28VXKMTYoQfQ9iEUuRUIfRnI53VmOSNJHQQG8VGAZgWS7qKsbIZT6q6giPUJ4Ar449NcmuW4MvvvgCBQUFYBgG//3vf7Fy5Uo8+eSTwvO33XYb/vGPf2DJkiU4efIkVq9eDT8/P6xevRpKpRKPPvqo3d8AQUgJdca7L7xNk6tEQlmWFZqk4iSyEEpOToZKpYJGo4FSqULg8Ifw7aHLOFtUA72BxbKdWQCAB4fECREWV4SPhOZXWSFCJSp16OiE+fFWRg5Ox9dLa/oulzFCxFKslDwfjQyWSDibo6On4+0SoT///DMAYPjw4ZgxY0a766dOnYqffvoJer0ec+fOxcWLF+25PEFIDt+URJFQ94OPhBZUNVrtNykF5fUaNGr1YJjmmkexycjIgEajgUqlglarQWjWJugMLB7/6ghmfX0Ef16uhI9KjidGdJXk+mLBR0KLapqg0Vk2KSbXGDWlSKh1mEZCHVlSV+kAv00+JV8hUtMVXxPqyEio0JjU6NhyCUdhlwg9efIkGIbBpEmTzD5vrjt+zJgxuPvuu9HQ0IDly5fbc3mHUF5ejp9++gkLFizA+PHjkZSUhPDwcCiVSvj7+6N3796YMWMG1q9fD4PBurFaGzduxJQpU5CQkABPT0+Eh4fj5ptvxpIlS1BTU2Pxeerq6rBs2TKMHTsWkZGR8PDwQFhYGIYNG4aFCxeiuLjY2m/bYiorK/Hhhx9i7Nix6NKlCzw9PREcHIw+ffrggQcewEcffYT8/HzJri81zZFQqjNzN8J8PeCtksPAWpfWlQo+Uhfh5ymJIXlGRgZSUlKQnp4OtVqN9PR0HP1xOZi/1qGgugl7z5cCANLv6SdEGl0VrgZbBpZtvhFsiyatHqVGiyGqCbUOXoQ2aQ2o1zjuZo2PKkqVjgeavULF6pB3Zk1oR42E2lUTWlHBmSEnJCS0PKlCAb1ej8ZG8388JkyYgA0bNmDLli1499137dmC5Hz11Vd45ZVXzD5XW1uLc+fO4dy5c/juu+9w3XXXYe3atejevXub56yrq8OMGTOwcePGFl8vLS1FaWkpfv/9d3z44Yf43//+hxtvvLHNc+3evRsPPfTQNUKzrKwMZWVlOHLkCN5//318/vnnuP/++y34ji3n66+/xssvv4zy8vIWX1er1aisrMTZs2fx448/QqfT4YUXXhD12o5CqAl1gzGAREsYhkF8iA/OFNbgcnk9EsN8nbofPlLXRYJ0sakA5WtDTWtEx0X4ou+dj2PykFjcnBgq+vXFhmEYxAR64WJpPfIqGxHfzohTvoHJz0Ph0mUGroiPh0IYDlBep4avgxwTKiW2aAKam67ESsdXONioHmieH0+NSWaQy+XQarWQy1ve1fv5+aGqqgpFRUVmjwsK4syU3SVCJpfLMXDgQAwZMgQ9e/ZEVFQUVCoVKisrcfToUaxduxZVVVU4duwYRowYgRMnTiA8PNzsufR6PaZMmYKtW7cCACIiIjBnzhwkJSWhoqICq1evxoEDB5Cbm4uJEyfiwIED6NOnj9lz7du3DxMmTIBGw/1iDB48GA899BDi4+NRXV2NHTt2YN26daioqMDUqVOxceNG3HHHHaL8TNLT0/Hmm28CAJRKJe666y6MHDkSkZGRMBgMyM3NxeHDh7F9+3ZRrucsmj1CSYS6Iwkh3jhTWIOcMuc3Jwk+lhJE6vR6fQsBysN/rtfrkTp1kOjXlZLYIG9cLK23yLCeb/iKCfKSbAhARybEV4W8ykaU1WnaFfxi0KjRQ20ss5DKrB4w8QoVqd7VEcL5avwpEto6ERERuHz5Mqqqqlp8PS4uDlVVVTh58qTZ4y5fvgwArUZKXYmpU6fiiSeeQGBgoNnn58yZg7feegsTJ07EH3/8gaKiIqSlpeE///mP2fUrVqwQBGhSUhJ+/fVXREQ0d6k+88wzePnll7F06VJUVlZi7ty52Lt37zXn0Wg0mDlzpiBAX3jhBfzrX/9q8Qd4zpw52LlzJyZNmgS1Wo1Zs2YhKysLfn72GXevXr1aEKADBw7EDz/80Gr0V61Wo7q62q7rOQvOqJ66490Z/g3VFaYmSWXPBEAwojfH1cLUXWjukG///07ojKemJJsI8fVAXmWjaGKtPXgxp5AxkkZe+alJoqXj+cYkB01LAkwsmjqoCLWrJjQpKQkAcP78+RZfv/7668GyLDZt2oT6+padqQaDAStXrgQAxMTE2HN5hxAXF9eqAOUJCQnBJ598Iny+adMms+v0ej3S0tKEz7/55psWApTnnXfewaBBgwBw0U5z0cT169cjJycHABcBXbp0qdkIwO2334433ngDAFBcXIwPPvigze+lPcrLyzFv3jwA3P/fr7/+2mb5gYeHR6tRYVenVq1Dg7FGimpC3YvU1FRkZGQgwdicZNohn5GR0aZokwop7Zk6Inzdaq5FkVCyZ7KHUAmmC7VFlYlHqJSR6+b58e5bE8pHijU6A5q0zm+wFBu7ROjw4cPBsiwOHjzY4uuTJ08GwDWt3H///Thz5gw0Gg1Onz6NBx54QPALHTt2rD2Xdyn69u0rPG6tDGHv3r0oLOSMokeNGoXrrrvO7Dq5XI7nnntO+Hz16tXXrNm1a5fweObMmZDJWv+vnDVrlvB41apVra6zhM8//1yoBc7IyEBwsGuO/RMDvh400FsJLxUZ1bsT/AShX1dzN4e8VyhfO3l1CZEjaPaxpBsaS+BrZy2x2LpUyq3pFiZ9KrkjwtdOOioSWiV0xksbURR7dKczuuN9PRSQG8fQdsSUvF0ilK8vPHz4cAvhdccdd+Dmm28Gy7LYuXMn+vXrBy8vL/Tv319oxvH29m614ccduXDhgvA4MjLS7JotW7YIjydOnNjm+UxrN02P48nLyxMe9+rVq81zxcbGwtub+4N+7tw5ZGVltbm+Lb744gsAgEqlwtSpU9tZ7d4UUlOS25KcnIz09HR8/sHbqDqwGrkVDUhLS7+mecdR6A2sUNtIkVDL4AXlpdL6dq2DLpbWAYDTm8/clRAHz4+vdEBnPCBuY5JOb2j2CXWgCGUYpkNPTbJLhA4aNAhpaWl46aWXrmkyWrduHQYMGACWZa/58PPzw/fff49u3brZtXlXoa6uDs8++6zwOR8JvhrTGtmhQ4e2ec7IyEjExcUB4NLopaWlLZ63x88tMzPTpuMKCwsFsd2vXz94e3sjKysL8+bNQ/fu3eHl5YXg4GBcf/31eP3111FQUGDzHl2BImpKcmuSk5ORlpaG6v2rcPHde5Ca+qZTBCjANbjpDCyUcgYRdFNjEV1DfcAwXPSnLRGh1umFmt/EcIqE2oKjpyY5wiMUAEKMNaFiiFA+Csowjk3HAx3bpsnuiuDW/qBHREQInePbt29HUVERfHx8MHToUMyePRthYWH2XtrhlJSUCKUHBoMB1dXVyMzMxJo1a4RI8PXXX99qvdm5c+eEx127tm8W3bVrV+Tm5grHmv7MTKOt58+fb7PrPT8/Hw0NzcX9Z8+ebffa5jhy5IjwuEuXLvjmm28wd+7cFg1mTU1NqKysxLFjx7Bs2TIsX74cjzzyiE3XczbNTUmUPnVXUlJSkJq+EKxeC6VS5bQmHaF7O9BLSK0RbeOplCM6wAv5VY24VFYvROuu5nJ5Awws4OepQFgra4i2CRXS8Y6qCZV2ZCcPH7GsbNBAb2Dt+t3jfzbB3iqH/w77C5HQjmdYL6khmFwux/Tp0zF9+nQpL+Mwjh07hvvuu8/sc2FhYZg1axbS0tLg6Wk+0mHqIhAa2r5XX0hIiNljAWDEiBH46quvAAArV67Ec88912qB99dff93qPqyBr2cFuKjupk2boNfrMXz4cDz44IOIjIxEfn4+Vq9ejSNHjqCxsREzZ86Ej49Pux6larUaanXzXbg1Zv1SUVhFIzvdnYyMDLB6LSBXQKvVICMjwylClLq3baNbmA8nQkvrMDTBfP35xZLmVDzZM9lGiNBF7qhIKJ+OlzaiyItcfn58qB03KbwI5VP8jiSwA0dC7UrHE82MHDkSI0eObFWAAlzanqetdTxeXs0RuNra2hbPTZ48WWgKOnbsGF599VWzKfrdu3dj4cKFLb5mq8CrrKwUHl+8eBF6vR5vvvkm9u/fj+eeew4PPvgg/vnPf+Lw4cN4+eWXhbVPPvnkNS4JV7N48WIEBAQIH3wpgjMprCF7JneGb0K6dcY8xL+8Hrc9/CxSUlKQkZHh8L3k8R6h1L1tFd1CufT6xdLW/36cL6Z6UHsJcXAk1FHpeIVcJjQ/2ZuS5wU6L9gdSUdOx7u9CB09ejQYhhHlY82aNW1ea8KECUJdq06nQ2FhIdavX4/bbrsN69atw6RJkzB9+vQWqW+p8PPzw7///W/h8/feew9Dhw7F0qVL8f3332PFihWYNm0axo4di6amJiQmJgpr2+qkb4urx5KOHDnSbOkBwzB45513cP311wPgbJ2+/fbbNs/9+uuvo7q6WvjgyxCcCdWEui+mE4QefvpFAEDPCY8iPT3dKUJUmGtOIyWtokcE52l8rqi21TV/F3A+xEnR/g7ZU0dEaOAxpq2lxhEjO3maDevtE6FlzoyEendcEeqY+VwdELlcjsjISNxzzz245557sGDBAixevFiwU/ruu++uOcbX11eIJjY1NcHXt+07d9NaS3MG8zNmzEBjYyPmzZsHtVqNo0eP4ujRoy3WyGQypKWlobKyUvAI5SdWWcvVe5g7d26ra2UyGebMmSPs59dff21zvYeHBzw8XKueq3luPIlQd8N0gtCO09xI27zKRnxsMkHIkfA+llKM7OzI9InihOWZwtazN6fyORHaj0SozQQbI5JipK0twVGRUAAI9fHApdJ6+yOhxqYtqX825ujIkVCLRGh6errwOCUlxezXbcX0fLYwefJkwdjdXtqzOmqLjIwM/PDDD8jKysLq1auRkpKC3r17t1gTGBgoiNCysrJ2RajpTPbWDPOfeOIJTJgwAR9//DG2b9+Oixcvor6+HpGRkRg5ciSeffZZ3HDDDZg5c6ZwTGsWUu1xtXjlI52tMWTIEOHxxYsXbbqms6hT61DbpANAjUnuiGmEvnnyDndT59SaUErHW0XvSD8wDFBSq0Z5nfqa5qTyOjUKjDeLFAm1HYVchiBvJSobtCivk16EOiMSWmFnvSsvYkMcaM/E05EtmiwSoampqULBt6loNP26rdgrQvnpPc5GLpdj3Lhxggfnnj17rhGhvXr1QnZ2NgAgOzsbCQkJbZ6TX8sf2xqxsbFYtGgRFi1a1OqaU6dOCY+HDRvW5nVb4+rvJyAgoM31ps+7QqORNfBG9X4eCknHyhHSE2MUoRX1GtSrdfBx8P9nk1aP4hruDZAak6zDx0OB+GBv5JQ34ExhLW7p0VIcnSrg/q50DfWBn6fjRil2REJ9PVDZoEVZnRq9YN9o5/aodKDpe7AxfW6vB2pzOp4ioWJicXFga76U5nxALf3oaJimq02beHj69+8vPDa1OzJHcXGxUBcZHh5ul6VVeXm54FHq6+uLwYMH23Sevn37QqFofgNvbya86fPtCVZXgxehUYGUind3/D2Vwh/x/Kr2R0CKDX9NH5XcIZGfjgafkj9deO3fG74etC9FQe0mRBBr0nbIGwysIKaknpgEiDe6U2hMckJNaEeeH29RSGD37t1Wfb2zYjqJyJxonDBhApYsWQKAm4L06quvtnquX375RXjc3nSl9vjmm2+g1XIv3kceecTm2ksvLy+MHj0aO3fuBAAcPXq0zQjtn3/+KTy2p9TBGRQam5IoFd8xiA3yQnWjFnmVDegZIW2U52p4I/W4YG+yELKBAbGB2PJ3EY5drrrmuVP5XCS0X4x73eS6InyET+oO+epGLfgYVKCXAyKhYonQOuel4/na2ZrOKkJHjRpl1dc7I1euXGkxXnP48OHXrBk1ahQiIyNRVFSEPXv24NixY2bnx+v1+had79OmTbN5XwUFBULtrkqlwvPPP2/zuQDg4YcfFkTo8uXLW/WANRgM+Pzzz4XP2zLTd0WESChNt+kQxAZ54VRBjVAX6kjInsk+hiZwteh/Xq4Ey7IthDwfCe0XTSLUXkKFOevSRkL5VLyfhwIqhfQGPcEifV98YxKl48XF7S2apKSoqAhpaWmoqKhoc9358+cxceJEwZppzJgx6NOnzzXr5HJ5ixrYmTNnoqSk5Jp1r732Go4fPw6AE7Pjx483e93s7Gxcvny51X2dOnUKt956q1AakJaW1mZE0tSuKicnx+yahx9+GElJSQCAvXv3Ii0t7Zo1LMti/vz5Qmd8QkICHnzwwVav64qQR2jHgheAzhChZM9kH/1iAqCSy1BWp8bl8mb7u+pGrfA5pePtx1GRUKEz3scxpSl8k5U9kdBGjR71Gs5Rw9kWTR2tlNGuCv0rV64A4GoWLTFf51Gr1Sgu5mxTunTpYs8WJKWpqQmpqalYuHAhRo8ejWHDhiExMRH+/v7QaDTIy8vDvn37sG3bNiHdHRMTgxUrVrR6zjlz5uCnn37Cjh07cOrUKQwcOBBz5sxBUlISKioqsHr1auzfvx8A1xG/fPnyVs919OhRTJ06FcOHD8fo0aPRo0cPeHp6oqioCLt378amTZug03Ed3rNnz24z/W8pcrkc//3vfzFmzBjU1dUhNTUVO3bswNSpU4WJSd99951Q86pSqbBq1Soole5VC1dYRR6hHYnmDnnpPXyvhrdnos542/BUytE/NgBHL1ficHY5vv5oCeRyOUZNfQoANwqVb3DJyMiAXq9vdXQy0TohIjXwtEdlPfdeGeyg+eti+ITyUVSVXAY/JzSq8pFQvYFFnVrXoZrw7PppJiQkQCaT4ccff8Tdd99t8XF79uzBHXfcAZlMJogkV0an02Hnzp1CGro1xo0bh88++wzx8fGtrlEoFFi3bh2mT5+OzZs3o6ioyKxxdmxsLNauXYu+ffu2eU2DwYB9+/Zh3759Zp/39vZGcnIy5s+fL1o92pAhQ/Dzzz9jxowZyMvLw4EDB3DgwIFr1oWHh2Pt2rW4+eabRbmuI2meG08itCPg3Egojey0l1E9w3D0ciW2nSpGV2NGaeSZYqDLHRjenRtvbDqggLAePmIodTq+woEeoUBzDWdlgwYGAwuZDXPfTUd2OqOu21Mph0ohg0ZnQFWDlkSoKfaEhl09rJyQkIATJ05g586dOHz4ME6fPo28vDzU1tZCqVQiICAAPXr0wLBhwzB16lSLrY/8/PywadMmbNiwAStXrsSRI0dQUlICPz8/JCYm4v7778fcuXPb7SgfM2YMli9fjt27dyMzMxPFxcWoqalBaGgounXrhjvvvBMzZ85ETEyMGD+OFowcORKnTp3CihUr8NNPPyErKwsVFRUICAhAUlIS7r77bsydO7ddL1RXpaiGN6qnFGpH4GqvUEeSW0HpeHu5o18k/rXjPPZnlWFZ8mtgWRZvvvkmAm6pwh2z/tVCgDrDB7YjEOqg7vgqowgNdlCDDx8lNxiN+G2p6RQ8Qp2QiucJ9FKipFaN6kYtnD/UWjzIALEdBgwYgAEDBkhybn7akq2EhITgySefxJNPPinKfqy9KfD398eLL76IF198UZTruwqNGr1gCkyR0I6Bs7xCa5q0QjMBpeNtp3u4LxLDfHCxtB7/+zMPQ++bg4Ad51G9fxUmDPgeGo2GBKid8DPRpa4Jrah3nD0TACjlMgT7qFBRr0GpmYEHlsALc2fMjecJMIrQjtYh75TGpNpabg6wtzf9USZcDz4K6q2Sw9+T7tM6As7yCs0zRkGDfVQON8nvSDAMgydGdAMAZGw+jadXHUPg8IcgVyqh0WigUqlIgNoJH+Vr0OjRoJGuTE6IhDooHQ8AYUbhWVJjW5S33BUiod4d0yvUKSKUr62MiopyxuUJok2aPUI9ydexA8Gn5K+UO645qXlcJ6Xi7WXK9bHoZeLxqvvze+i1WqhUKmg0GrO19YTl+JpYJkkZDeVT24EO9NsM9zeK0FobRagT58bzdFSbJotvzX/77Tf89ttvZp9bs2aNYCnUGizLor6+HseOHcPu3bvBMIxbNqwQHZ/CKr4elFLxHYkuwd44VVAjCENHwNegkkeo/SjkMnw35wb8a8d5/Lr6Exza9V8hBc/XhAKgiKiNMAyDUB8VCqqbUF6vkayRji91cmgk1I8Tj6U2i1DnGdXzBBiN/Tva/HiLReiePXvMdh2yLIu1a9dadVGWZaFUKvHcc89ZdRxBOIICY7o2mpqSOhT8myo/wcgR5ApG9fRaEoMQXw94/r0eh77/pEUNKP8vCVH7CPH14ESohM1JfHe8I0fYhvtxAYWS2iabji+rd2wzlTk6fSQUaHt+vDVcd911WLRokdlpQQThbAqM9kzRgSQcOhK8COW71R2BEAkleybR0Ov1ZpuQ+M/1er0zttUh4DvkpUzH8zWhQQ4UdHwk1NZ0PB9B5c/jDJpFqLSNY47GYhH62GOPYfTo0cLnLMvi1ltvBcMwyMjIMDum0hSZTAZfX1907doVgYGBtu6XICSHrwmNDqR0fEeiiyBCHZmOp0io2LRlRE8RUPvgO8dLJYqEsiyLSmM6OciB6fhwO9PxJcZm1QgnjnE2nZrUkbBYhMbHx7dqwt6vXz+aI090GIR0PEVCOxRdTNLxV88glwKWZYVIKNkzEe5AiMSR0JomHfQGLnPqKIsmwD4RqtEZhO74cJeIhHZSEWqO3bt3A+BEKEF0FJobk0iEdiSiAz3BMECjVo+yOo3kqbXqRi3q1JzVDUVCCXcg1EfaqUmVRjHnrZLDUymX5BrmCDdGMPmIpjXwHqFKOePQ6O3VBPAWTZ21MckcFP0kOho1TVrUGoUDpeM7Fh4KOaL8PVFQ3YTcygbJRShfexrm5+HQN1yCsBWpI6GVQlOSY8Uc/7ter9FbPayi2Chcw/08bRr5KRYdNRLqFJ9QgnBV+ChooLcS3ioyF+9oxDmwLpTqQQl3g68JlWp0pyBCfRw7+9zXQwFvFXcjaG1KvrjG+U1JgIkIpUho6xgMBly8eBGVlZVoarIs7D1y5Egxt0AQdsHXg1IqvmPSJdgbh7MrHGJY32xUT/WghHvA+2DyNZBiU1nv+KYknnA/D+SUN6CkVo2EUB+Lj+NtnSL8nStCA40itFatg05vgELeMWKIoojQgwcP4t1338WOHTssFp8AZ46r00k3HowgrKXA2BkfQ6n4DkkXB3qFNhvV0w0N4R7w0b6Keg0MBlb09LOz0vEAl07nRKh1daH8qE9ndsYDgL9Xc/S4pknnVM9SMbFbhC5duhTz588Hy7JW+4UShKtBkdCOjZCOd8DUpGajeoqEEu4BLw71BhbVjVrRvTx5EeoMASV4hVo5P765JtS5kVClXAZfDwXq1DpUN2pJhALAvn378Morr4BhGLAsi5iYGIwZMwaxsbHw8HDufxhB2AJfE0r2TB0TRxrWC/ZMwfRaItwDlUKGAC8lqhu1KKtTiy5CK4zpeEfaM/EIozutrHctNtaQhjs5EgpwdaG8CO0o2CVCly1bJjzOyMjA66+/DpmsY9QpEJ2TAjKq79Dw6fiC6kZodAaoFNL8vTL1CKVIKOFOhPiqjCJUgx4R4p67yomR0HB/2yKhJS4SCQU4EZpf1Sj8HDsCdv0F/v/27js+qirtA/jvZjLpvUxCICSBQCBUaSJIEoqAgBTBRSwEEBBR0LUhsOkI8orL+rKKbQVECagsLL0KS6TJC0JoQsCEUNLLpE7KzH3/mNxLQqbXO5Pn+/nk4yRz7j0nYUyeec45zzl9+jQYhsHkyZOxfPlyCkCJzXtAmVC7FuDhBFexCCwL3C83Xza0pLoetQ1yMAy9oSG2xZy1QkubNjz5WGFNaKAHd3SnnmtCK4WxJhSwzzJNRkWNJSUlAIBnnnnGJIMhxJoUChb5Uq5QvfV/4RDTYxiGnx43Z5kmLgsa5OkCZ0eqEUpshzlrhXKF1v2ssTGpKYjUp0RTfaOCD5wpCDUPo4LQgIAAAIC7u+7lDggRquLqOtTLFXBghPELh5iHJXbIcwEurQcltiagKWNYYoZaoaU1XCbU8mtCg5t+p+frcWpSUYvTkiw/5kfx58fbUa1Qo4LQvn37AgBu375tirEQYlXcpiSJpwvEdlKDjbRmiYL1tB6U2CouE1ps4lqhLMtadU0otyymvKYB1XW6lYZsfloSw1jvtCQOZUIf8corr4BlWWzdutVU4yHEavjyTLSGz65ZJBPKF6qnTCixLf5myoRW1TWiQa4s42iNOqGeLmJ4uij3YudJdVsPzm9KsnKheg5/fjwFoUpTpkzB1KlTkZmZiffff99UYyLEKh5IaVNSW8CdYGTOWqGUCSW2KqApS1ls4jWh3HpQF7EDXJ2ss066fdPvdu7/T224TUlC2BkPPMyEltN0/EPff/89XnjhBXzyyScYOXIkdu/ejeLiYlOMjRCL4jKhIbQpya519G/KhJrx6M57pXRuPLFN5sqEcht8rJEF5XBBKFcFRRtuOl4oewS4DV32VKLJqDqhItHDdzMsy+L48eM4fvy4ztfTsZ1ESPL4GqEUONgzLhNaIWuEtKaBn+IyFYWCxb1yrlA9ZUKJbTHX7nhrHtnJCeGDUN0yodw+AaEEodzhAaV2FIQalQnljurkjuts/rmuH4QIBffumI7stG+uTiL+9BRzrAstqqpDfaOyykIwZdWJjeHqhFbWNULWIDfZffkg1N16u8y5IFTXGsFcO6HMaHABfJmJN41Zk1GZ0JiYGEHsGCPEFLh3x+0pE2r3Qn1dUVRZh7tlNejVwduk977XtNa0nbcrVVkgNsfL1RFiEYMGOYvS6nqTzQyVNR3ZadXpeF/DglCh/E3gAnhpbQPkChYiB9uPv4wKQvWZeidEyOobFXxNONodb/86+rnhQm65WTKh3Ln0QsmeEKIPhmHg7+6M/AoZSqpMGIQKYDq+fdPvdl2m4+XNDi8RyhItH1flz07BAhW1Dfz0vC2jt+mEQLkAnWUBJ0cH+NvB/9hEM3OWaeIyobQelNiqh7VCTbc56eF0vPXXhOZLZZArNC8HLKqsQ2NTtlEou+OdHB3g6azMHZbZybpQCkIJQcud8bTExP6Zs2A9ZUKJreN2yBfrccSlNg+n4623JlTi6QJHBwaNClbrGfL3y5W/G4K9XOAooGU1XBBPQSghduQB7YxvU0LNmAnl7tmRMqHERnG1QktMuAFGCCWaRA4Mv1nwvpZaofebNqoKZT0ohwviS6vto1aoUWtCm1MoFNi+fTsOHjyIa9euobS0FA0NDa2O9Lxy5QoqKirg7e2NHj16mKp7QoxCO+PblnB/dwDKotUNcoVJNxDdKakGAIT5UxBKbNPDMk2my4RyQSh3Nr21hPi44l5ZLe6X12KAhnZckNpeYDMa9pYJNUkQevLkScycORM5OTn811iWVTmtuX37dqSmpsLLywt5eXlwcaFNIMT6uBqh7WlTUpsQ5OUMF7EDZA0K3CurRUSAu0nuW9coR15Tgeswf9PckxBLe1iw3nSBTknT+lIuwLWWDj6u+A3aC9bnlirfTAptRsPeyjQZ/fb/0KFDGDFiBHJycsCyLEQiEby91Zc8mT9/PgCgoqIC+/btM7Z7QkyCz4QKbOqFmAfDMHw2NKe42mT3vVtaC5YF3J1EtMGN2CwuW1lsokBHrmD5TKi1/794WCtU81KcnGLl80Kb0eCCUHspWG9UEFpeXo4ZM2agoaEBHh4e+Oqrr1BeXo4NGzaovaZdu3YYPHgwAODo0aPGdE+IyXAbk9pRcfE2gw9CS0wXhPLZE3932uBGbJapp+PLa+rBbUa3dlkhbnqd20CozsNlNcKa0fBrqhVabidrQo0KQj/77DOUlZXB0dERBw4cwNy5c+Hmpv1dw5AhQ8CyLC5cuGBM94SYDL87njKhbUZ4gOkzoXeazqMPE9gUHiH64E5NMtV0PLfBycdNbPUDHHR58ylreLisJlxgmVAfyoQ+tG/fPjAMg6lTp+KJJ57Q+bqoqCgAwJ9//mlM94SYhLS2ARWyRgBUVqct4f64ZJeYboc8H4QGCOsPFyH64DOh1XUmOV67uCmjau2peADoHKgMQu+W1qC+UaGyzb2yGrAs4OHsCD8BjLk5bjzlFIQCN2/eBACMHDlSr+t8fHwAAFKp1JjuCTEJbhekn7sT3JxMVjCCCByXCb1jwul4fgrPT1hTeITogwt0GuQsKmobjb4fl1H1t/LOeAAI9HSGu5MICvbh8plHNV8PKrRlNT58iSYKQlFRUQEA8PPz0+u6hgblWgZHR/qDT6yPOx+YsqBtC7cjnivTZAp3SoW5mYEQfbiIRfzJPKY4NYlbWxpg5Z3xgHJTYkRTNvTPItVB6O2iKgAP36gKiR9foonWhPLBZ0lJiV7XcaWcAgICjOmeEJPgjlmkILRtkXg6w1UsglzBmuTkJLmCxb2mzQ5CK+tCiL4CPE23LrSE3xlv/UwoAHQK8AAAZKtZD36zQBmEdpV4WmxMuvJzezgdr9By9KgtMCoIjYyMBACcPn1ar+sOHDgAhmHQp08fY7onxCTulXGZUAoc2hKGYfiM5R0TrAvNr5ChXq6AWMTQBjdi87j1m6bYIV/MT8dbPxMKAJ2aMqG3CpXBZnJyMtLS0vjnsworAQBRwR5IS0tDcnKyxceoDrcxScECFTLbz4YaFYSOHj0aLMvi559/Rn5+vk7XHD16FBkZGQCAMWPGGNM9ISbBZUKFdjwbMT9uSl5dRkQf3HrQUF83iByEtY6MEH1xAaMpaoVygawQ1oQCQLdgZYbzer5ySaFIJEJiYiLS0tKgULDIasqEHvz+cyQmJkIkElltrI9ycnSAR9NSCXuYkjcqCJ0/fz7c3NxQXV2NadOmad1odPr0acyYMQMA4Ovri/j4eGO6t4iSkhLs2LEDy5Ytw5gxYxAdHQ2JRAKxWAwvLy9069YNL774Inbu3AmFQr91Zbt27cJzzz2H8PBwuLi4QCKRYMiQIfj444/59ba6qKqqwqeffoqnnnoKwcHBcHZ2RmBgIAYNGoQVK1agoKBA329bK5lMhk2bNmHSpEkICwuDm5sbnJycIJFIEBMTg5SUFNy9e9fk/ZoDrQltu/gyTSbYnMRlUzvSelBiB7iC9UWVJlgTyh3ZKZCd5t3beQFQTrs3yhVISEhAamoqEhMT8d7yJNQ2yFF5eiv+sXoFUlNTkZCQYOURt2RPm5OM2hkUFBSElStX4q233sLp06cRFRWFuXPnQi6X82327duH3Nxc7N+/H3v37oVCoQDDMPjHP/4Bd3fhLfp91IYNG/Dee++pfK6yshI3btzAjRs3sGXLFvTr1w/btm3jlymoU1VVhRdffBG7du1q8fWioiIUFRXh9OnTWLduHX788Ue+sL86x44dw4wZM1oFmsXFxSguLsa5c+ewdu1afP3113j22Wd1+I61u3jxIv7yl78gKyur1XPc95CRkYGPPvoIq1evxuLFi03Sr7nQdHzbFeGveYOCPrhsarjAilsTYgiJp/LgjqJKzcdb6oI/LUkgmdBQXze4O4lQXS/Hn8XV6BrkyQeaiYmJgMgRkDcKMgAFlJuT7pXVGnV05y9/FGDDyRwMjQzAgtjOJhydfozenr548WIUFhZi1apV/H8B8GUNnnnmGb4tV28sJSUFL730krFdW4xIJEKfPn0wYMAAdO3aFe3atYOTkxPKyspw/vx5bNu2DeXl5bhw4QKGDRuGS5cuQSKRqLyXXC7Hc889hwMHDgBQBvLz5s1DdHQ0SktLkZ6ejpMnT+Lu3bsYN24cTp48ie7du6u8V0ZGBsaOHYv6euUL8bHHHsOMGTMQFhYGqVSKw4cPY/v27SgtLcX06dOxa9cuPP3000b9LO7evYsRI0agrKwMACCRSDBr1ix07doVzs7OyMnJQXp6Oq5duwaZTIY333wTbm5umDt3rlH9mkulrAHlTVMa7SkT2uZ0lig3KHBrw4zxZ9OOWu6ehNgyiZcyYCyoMMWaUGGcG89xcGDQrZ0Xzt8pw7UHFegapJyeT0hIQEpaGuQNDRA5igUZgALNzo83olZoVkEVMrKK+Yy31bAmsn//frZfv34swzBqP3r16sXu3bvXVF1aRG5uLltWVqaxTXFxMTto0CAWAAuAXbhwodq2X3zxBd8uOjqazc/Pb9XmnXfe4dsMGzZM5X3q6urY8PBwvt1bb73FKhSKVu0OHz7MOjs7swDYoKAgtqKiQvM3rMUrr7zC9zl69Gi2urq6VRuFQsEuW7aMbxcYGMg2NDTo1Y9UKmUBsFKp1KjxanM9T8qGLdnD9kk5aNZ+iDCV19SzYUv2sGFL9rAVtfVG3Svu42Ns2JI97MmsIhONjhDrOXItnw1bsocd/78njLqPrKGR/3+svNq4/8dMKWHnZTZsyR42edcV/mupqanKv1siRxYAm5qaasURqvdm+gU2bMke9ovjtwy+x4o9V9mwJXvYD/deM+HIlPT5+22y87PGjh2L8+fPIzMzE//85z/x7rvvYu7cuXjrrbewZs0anDt3DpmZmRg3bpypurSI0NBQvri+Ov7+/li/fj3/+e7du1W2k8vlSElJ4T/fvHkzgoKCWrVbvXo1+vbtC0CZ7Tx06FCrNjt37uRLXT322GP45JNPVBbVHTVqFJYvXw4AKCgowD/+8Q+N34s2XAYXANauXavymFaGYZCamsp/b0VFRfjjjz+M6tdcuJI6tB60bfJ2FSOwqRTNbSOm5OsbFchtKvNEmVBiD4K8lNPxhUZmQrmpeEcHBl6uwqkNPjBcWWLy7J+lAIC0tDQkJiai3YiZCHt3Jxa+s4zfrCQ0fk2lroxZE8qt9Q20cibU5K+Inj17omfPnqa+reD16NGDf6yuUsCJEyeQl5cHAIiNjUW/fv1UthOJRFi8eDHmzJkDAEhPT8fo0aNbtDl69Cj/eObMmXBwUP9+Yvbs2cp1LgB++OEHo6YYCgsL+cddunRR204kEqFTp078WtWqKuOnO82B35TkQ+tB26rIQA8UVdbhVmEV+ob6GHSP3NJqyBUs3J1EkHgKY90bIcbgXsfFVXWQK1iDKz6UNCvPJKTThx7vpAxCr+dXYHliMlampeDtDxKwnX0cYhGDv69IRbC3C/+3U0hT8wGeyun4IiPKZ3HXcveyFpNlQtu6W7du8Y+Dg4NVttm/fz//WFtGuPnazebXce7du8c/joqK0nivDh068BnLGzduqNxQpKvma125Y1tVkcvluH37NgDlyVjaxmgtVKiedAkyfl0ol0XtLPEQ1B9aQgzl7+EMB0ZZj9KYWqEPz40X1psziacLOgW4g2WB3OIqpKamoueE2QCAvqE+cHYU8bvmm2+2FgJuHWexEQcJPMyEuphkTIYyKgh1cHCAo6Njq13e2hw8eBAikchuju2sqqrCokWL+M+nTZumst3ly5f5xwMHDtR4z+DgYISGhgJQTqMXFRW1eJ5lDT8pITMz0+BrJ0+ezD/+61//ipqa1kW+WZZFQkICnzWdM2cOfH19De7TnB7ujKcgtK2KNMHmJO6Yv04CPOaPEEOIHBg+2Ck0okxTicAK1TcX0zUQAOAz7EUkJCTg0FXlzN2YHg8TSQkJCYIqVg88nEI35s0BH4RaeebG6CjQ0GDImCDKWgoLC3Hq1CkAgEKhgFQqRWZmJrZu3cpPwffv31/tC/bGjRv844iICK39RURE8LU2b9y4gcDAQP655tnWmzdvatz1fv/+/RbBojHrM5OTk3Ho0CFkZWXh8OHDiIiIwOzZs9G1a1c4OTnhzp07SE9Px9WrVwEolwp8+umnBvdnblwQ2p7KM7VZkYFcEFpp8D24Ek+dAmk9KLEfEi9nFFbWoaBChp7tvQ26R0k1d268sDKhADC1XwdsPJWDg1fzceluOX7LUa4PbR6EChF/kICBQWiDXMEXurf5ILQtuXDhAqZMmaLyucDAQMyePRspKSlwcVGd3i4vL+cfBwQEaO3P399f5bUAMGzYMGzYsAEA8N1332Hx4sVqpwE3btyodhz6CggIwNmzZ7Fw4UL8/PPPKCwsxOrVq1u1GzVqFJYtW4bhw4frdN+6ujrU1T38H0qfYv3GoOl4wmVCc0trIGuQw0Ws/+koXCa0MwWhxI4oa4VWGJUJ5aaM/QRSqL65nu290C3YE3/kV2LSZycBALFdAxHqJ+ykRACfCVWeH++g53pdLjvt6MDAx1Vs8vHpwyprQrmsnLpgzRbFxMQgJiZG4/fUfHOOLt+7q+vDwKiysmWWZtq0afDzUy6svnDhAt5//32V2eVjx45hxYoVLb5mbIDn6+uL1atX47XXXlPb5pdffsGqVatw8eJFne65atUqeHt78x/cUgRzqq5r5N8NUo3QtivQ0xmeLo5QsIadnMSybLNMKE3HE/vBbU4yZod8YYWsxb2EhGEYfDilJ8QiZRDn5OiAhAmq63ILCZcJbVSwkNbqf3QnNxUf4OGsdwBralYJQs+cOQMAagu66yMuLg4Mw5jkY+vWrRr7Gjt2LFiWBcuyaGxsRF5eHnbu3ImRI0di+/btmDBhAl544QWV6yRNzdPTE//7v//Lf75mzRoMHDgQn3zyCX766Sd88803eP755/HUU09BJpOhc+eHJyJo2kmvizVr1qBTp05Yt24dXn75ZZw6dQqVlZWQyWS4du0akpOT4eTkhMOHD2PYsGEtyjqps3TpUkilUv7DEkd+cjvjvV3F8HKx7rtBYj0Mwxi1LrSkuh7S2gYwzMOz6AmxB5KmMk0FRpyaxGVRuZJPQtM/zA+bZg/Ce2OisG/xk4iUeFp7SFo5O4rg5aKcyOaWO+ijqEr572ntqXhAj+n4zMxMtVmtX375ResUL8uyqK6uxoULF/D999+DYRitm3OETCQSITg4GJMmTcKkSZOwbNkyrFq1Cunp6QCALVu2tLrGw8ODP2lIJpPBw0Pz1F1tbS3/2NOz9f8YL774Impra/HGG2+grq4O58+fx/nz51u0cXBwQEpKCsrKyvgaocZsEmpeN+3jjz/Gu+++2+L57t27IykpCaNGjcKIESNQVVWF559/HllZWS3WtD7K2dkZzs6W/R+Cm4pv70NZ0Laui8QDv+eW42Z+JdBbv2tvNwWu7X1cDZrKJ0SoTJEJLeAyoV7WD3jUGRIZgCGR2pfICUmApzMqZI0oqqxHpJ75vIeZUOsvkdA5CN2xYwdSU1NbfZ1lWaxbt06vTlmWBcMwWLBggV7XqTJt2jS+sLuxjCkjlJaWhp9//hlZWVlIT09HYmIiunXr1qKNj48PH4QWFxdrDUJLSkpaXKvK3LlzMXbsWHz++ec4dOgQbt++jerqagQHByMmJgaLFi3C448/jpkzZ/LXqCshpc2DBw/w0UcfAVD+rN555x21bYcOHYqZM2fim2++gVQqxYYNG/D+++8b1K+50M54wunezgsAcC1P/6Uq15uu6RYs/AwKIfrgglBjzo/nAljuLHpiGgHuzvizqNqgzUlC2RkP6LkxSd2Odn13ugcFBeHDDz/EiBEj9LpOlTfeeMPoe5iCSCTC6NGj+Rqcx48fbxWERkVFITs7GwCQnZ2N8PBwjffk2nLXqtOhQwesXLkSK1euVNuG260OAIMGDdLYrzqHDh1CQ4Ny/cmoUaO01kMcPXo0vvnmGwDA2bNnDerTnB4GocJehE7Mj9v5e/WBIUGocr02F8gSYi+4KXRDz4+vqW9EZV1j072sH/DYE67IfJsJQidPntwqaJo9ezYYhsEbb7yh9vQfjoODAzw8PBAREYFevXpBJLK/aavmU+ZcxrO5Xr168esjz507p3HneEFBAb8uUiKRaJzK1qakpISvUerh4YHHHnvMoPs8ePCAf+ztrb1cR/PsrRBPTLrbdMwibUoi3dt5gWGAPKkMpdX1eu3kvZ7PZUIpCCX2hZtCL66qM2gXNpcFdXMSwcOZivGY0sOC9foHoVzFAmsf2QnoEYT26dMHffr0afG12bOVpwuMHDkSEydONO3IbFDzk4hUBY1jx47Fxx9/DEB5CpKm6el9+/bxj7WdrqTN5s2b+Qzmyy+/bPDay+ZBti4bh+7cucM/bl5uSijulCiD0DCBl+Mg5ufh7Ihwf3dkF1fj6gMphnXR7U2fXMHiRj6XCaXpeGJfAjycwTDKXdilNfV61/rk1oMGebnQSWIm1rxMk74eZkKtv0TCqG3SGzZswLfffqs1C9oW5Obmtjhec+jQoa3axMbG8usxjx8/jgsXLqi8l1wub7Hz/fnnnzd4XA8ePODX8jo5OeHNN980+F69evXiH+/Zs0drqacffviBf2zoEgBzYVkWuU2Z0DB/CkIJEB2izGTqMyWfXVyNukYFXMUihPnTznhiX8QiB/i5KWcFuIBSHwUCmva1N8ZkQrlz44Xw72JUEBofH4/4+Hh06NDBVOMRlPz8fKSkpKC0tFRju5s3b2LcuHF8aabhw4eje/fWtcZEIhESExP5z2fOnMkfbdncBx98wFciGDp0KMaMGaOy3+zs7BbZxkddvXoVI0aM4JcGpKSkaFxb2rxcVU5OTqvnhw4dio4dOwJQLjeYMWMGqqtb11VkWRbLly/H8ePHASjrnf7lL39R2681lFbXo6pprZLQCxMTy+hhQBDKbUqKCvaEyMr19ggxB65MkyE75AubZUKJaXG1QouMyoRaPwg12yKN8vJyVFZWwtPTU+3ObqGTyWRITk7GihUrEBcXh0GDBqFz587w8vJCfX097t27h4yMDBw8eJCf7m7fvj2/GUeVefPmYceOHTh8+DCuXr2KPn36YN68eYiOjkZpaSnS09Px66+/AlCuqfzyyy/V3uv8+fOYPn06hg4diri4OHTp0gUuLi7Iz8/HsWPHsHv3bjQ2KgOtV155xejd6WKxGOvWrcOUKVOgUCiwb98+dO3aFS+//DJ69eoFsViMP//8E9u2bWtRzmvlypUICQkxqm9T47KgwV4uVFaHAAB6hHCbk6Q6X8MFobQpidirEG8XXM+rwANprfbGj+BrhAog2LE3fCZUz9Osauob+QSMXQWh1dXV+Pbbb/Hvf/8b586da1Hj0tXVFQMHDsS0adMwa9YsuLvb1rRVY2Mjjhw5giNHjmhsN3r0aHz11VcICwtT28bR0RHbt2/HCy+8gD179iA/P5+vu9lchw4dsG3bNvTo0UNjnwqFAhkZGcjIyFD5vJubGxISErBkyRKTrMmZOHEitm7dildffRVlZWV48OCBymM7AWXtz48++ghvvfWW0f2aGheEdqSpeNKEy4RmF1ejuq4R7jpspOCC0GhaD0rsVEhTHeUH5foHoQWUCTUbblNRSXUdX/ZSF8WVysypi9gB7k7WT8CYJAg9fPgw4uPjUVBQAKB1yaaamhqcOHECJ06cwMqVK7Fp0yaMGjXKFF2bVXh4OC5duoQjR47g7NmzuHbtGu7du4fKykqIxWJ4e3ujS5cuGDRoEKZPn67zukdPT0/s3r0b//nPf/Ddd9/h3LlzKCwshKenJzp37oxnn30Wr776qtYd6MOHD8eXX36JY8eOITMzEwUFBaioqEBAQAA6deqE8ePHY+bMmWjfvr0pfhy85557DiNHjsTmzZtx4MABZGZmorS0FHK5HD4+PujevTuGDx+OV155xSLHbxqCNiWRRwV4OCPIyxkFFXW4lleBgeF+Wq+h8kzE3j0MQvVfE8rXCKXyTCbHlWiSNShQXS/XufoAd1qSctOZ9ZcQGR2E7t+/H5MnT0ZjYyMffLq7uyMyMhIeHh6oqqrC7du3+RI9eXl5GD9+PP7zn/9g7NixxnZvdr1790bv3noeoaIj7rQlQ/n7+2P+/PmYP3++ScajT71XPz8/vPnmm0ZtdLImPgilTChppncHHxy+VoDfc8u0BqHFVXXIb8r0RFGhemKnQnyUWUyDMqGV3LnxlAk1NTcnR7g5iVBTL0dxZZ3OQWieVPlv0s5bGP8mRm1MkkqlePnll9HQ0ACWZTF27FicOHECFRUV+P3335GRkYHff/8dUqkU//3vf/H0008DABoaGvDSSy9p3V1NiLnklio3VHWkHc2kmQFhyiNt/y+ndZ3fR13MLQcAREo84OkiNuewCLEaPhNqyJrQCu7ceMqEmgO3OUmfHfJ55VwQKoz62EYFoevXr0dpaSkYhkFSUhL27duHJ598slWKl2EYDBs2DHv37kVKSgoA5e7q9evXG9M9IQaj6XiiyoBwZRB6/k6Z1pmBC7nKQLVfRx9zD4sQq+GC0HypDAqF7rNl1XUPN8BIaE2oWXDrQgv12JxkV5nQvXv3AgAGDx6MpKQkna5JSEjAE088AZZlsWfPHmO6J8QgtfVy/n9amo4nzfVs7w0nRweUVNcju7h1+bHmfm/KhD7W0dcCIyPEOoI8neHAAA1yVq+MG/c71p1OSzKbYG/uWFXd1+vmNWW07SIIvXnzJhiG0buYOtf+5s2bxnRPiEG4nfFeLo7wcdP9eEZi/5wdRXgs1AcAcPJ2idp2DXIFLt0rBwA8RplQYsccRQ787vb7eqwLpZ3x5sf9bPP1CEIfcJlQHzuYji8vLwcAtGvXTq/ruFODuOsJsaQ7JcoMF51wQ1SJ6ao8sjPjZpHaNpn3pKipl8PXTYyuEtqUROybITvkuSBUCLUo7RUXhBZIdf93yW/KhIbYw5pQX1/lNNSDBw/0ui4vLw8AbLaIPbFtVCOUaPJkZAAA4PTtEjTKFSrbnL5dDAAY3MkfDnRSErFzXBCap8fmJC5gbS+QjJs9CuaCUB1Ps2qQK/hlEsH2MB3ftWtXsCyLrVu36nXdtm3bAEDjEZKEmEv3dl54aXBHxDVlvAhprmd7b/i5O6GyrhFn/lR9ZO+ppqn6IZ39LTk0QqwixFv/6fj75co3+yEUhJoNnwnVcTq+oEIGlgWcRA7wdxfGUjSjgtBx48YBAM6ePYsVK1bodM2HH36I06dPg2EYjB8/3pjuCTHI0MgArJjcC88NEGYhfWJdIgcGY3oolwztvdx6lqdC1oBzOcrgdGhT1pQQe8ZnQvWYjuczob4UhJoLl83Mr5DpVOeb2xkf7O0imBkco4LQ1157DX5+yoLOSUlJmDhxIk6ePKmy7cmTJzFx4kQkJiYCUE7lv/baa8Z0T4jOkpOTVR6PCgBpaWlITk627ICIoE3orVznvv9KPmQN8hbPHb9RhAY5i86B7ugU6GGN4RFiUYbUCuWK21Mm1Hy4+qs19XJUNpXD0qR5ECoURgWh3t7e+O677yASKc8f3bt3L2JiYuDp6Ym+ffti6NCh6Nu3L7y8vBATE4O9e/eCZVk4Ojpi8+bN8PKio+6IZYhEIiQmJrYKRNPS0pCYmMi/hgkBgMcj/NDexxXlNQ3Y+ft9/uu/ZZfira2/AwBGN2VLCbF3hpyadL9M2ba9j3ACHnvj5uQITxdl+StdNiflcW8M7CUIBZRT8rt374ZEIgHLsmBZFtXV1bh8+TLOnDmDy5cvo6qqin8uKCgIe/bs4U9PIsQSEhISkJqa2iIQ5QLQ1NRUJCQkWHmEREgcRQ6YPTQcAPDB8gQkJaegqq4Rb2y5AAULeLuKMX1AKGXRSZvA7aQurqpvNTOgSoWsgc/MUSbUvLh/mwe6BKECK88EmCAIBYAxY8bg1q1b+PTTTxEXFwc3Nzc+6GRZFu7u7oiLi8O6detw69YtjB492hTdEqKX5oGos7MzBaBEo+kDQyHxdEa5TI7UlGQMe/51FFbWIcTbBUfficXm9X+nLDppE3zcxHB3Ur7O75Vpz4ZyWVBfNzHcnKhQvTlxa27v6/DvwmWyhVKoHgBM9upwd3fHokWLsGjRIgBARUUFKisr4enpSdPuRDASEhKwYsUK1NfXw8nJiQJQopanixirp/bGnKoZAICLO7+CX0wNVn/zd6xf+z/0Joa0GQzDoKO/O67nVSC3tBqREs1roblAlTYlmR9XAourRqAJV9ReKOfGA0YEoffv30dmZiakUim8vb3Rq1cvdOjQgX/ey8uLgk8iOGlpaXwAWl9fj7S0NAoiiFrDu0mwafYg/DPMD3/4u+Hyf77GqJ4/or6+ngJQ0qaE+bnhel4F7pRoD3b4A0H86EAQc9MvEyqsc+MBA4LQ3377DX/9619x5syZVs8NHjwYa9euxaBBg0wyOEJM6dE1oNznACiYIGrFdA1UnqK04Ak4O2+iLDppk8KaDvfQJQilA0EsR9fTrOoa5SiuUhaqF1IQqtea0EOHDiEuLg5nzpxpseaT+zh9+jRiY2Nx8OBBc42XEIOo2oSkarMSIeqoyqIT0lZwASUXYGrCBaphfhSEmtvD6XjNmVBuiYSbkwh+AilUD+gRhFZWViI+Ph4y2cOiqJGRkRgyZAgiIyP5dnV1dYiPj0dFRYXpR0uIgeRyucrpUy4Qlcu17/gkbVfzNzF1dXX05oW0OeH+yql1bqpdE64NZULNr0PTdHx+hUztMcMAkNv0xqCjnxsYRhiF6gE9puM3b96MgoICMAyD/v37Y9OmTejevTv//B9//IFZs2bht99+Q1FRETZv3ozXX3/dLIMmRF+ayujQtCrRRF0WHQAt5yBtRsemrObd0lrIFSxEak7caZQr+KxbmD+tCTW3QA9nOIkcUC9XIE8qQ6ia7DP3xiBcYP8mOmdC9+/fDwAICAjAwYMHWwSgANCtWzfs378fEomkRXtCCLFllEUnRLn20NlRGezc1TAlnyeVoVHBwknkgGAv4aw9tFcODgyfcc7RkKXO4ZZICCw7rXMmNDMzEwzDYObMmfD19VXZxtfXFzNnzsSaNWtw+fJlkw2SEEKshbLohAAiBwadAj1wPa8CtwqrEB6gOqN2q6gKABAe4KY2W0pMK9zfDbcKq5BTXI1hXQJVtuHW8gotO61zJrS0tBQA0LdvX43t+vTpAwAoKSkxfFSEEEIIERSuPigXaKpyq0D5XBeJp0XGRB5OsedoqFzAZUmFlgnVOQitrlZ+A56eml9YHh7KF2ltre5nzBJCCCFE2CIDm4LQQg1BaNNznbUUtCemw2Wlc4pVT8c3yhW4V8qt07XRIJQQQgghbRefCdUQhGYVVgIAulAQajEPM6Gqg9CckhrUyxVwcxLxZ80LBQWhhBBCCNGqa5AysLxZUAmFgm31PMuyyGoKULsEURBqKeEBD2u4qirTlFWgfGMQKfGAg8DW6eodhAqpvhQhhBBCLCMiwB0uYgfU1MuRrSLrlieVoVLWCJEDI7hSQPYsxNsV7k4iNMhZldlQ/o2BANfp6n1s5+TJk3Vqx7IsRCKRxjYMw6CxsVHfIRBCCCHEwhxFDohu54ULueW4cl+KzoEts52X70sBAF2DPOEi1vz3n5iOgwODqGBPXMgtx/W8SkQ+EmzebMqECjE7bdB0vKojO7kPQBlcMgyjsV3z9oQQQggRvp7tvQEAVx+0PhXx8j1lENq7qQ2xnKhgLwDAH/mt/12ymioWdBVgEKpXJlSXoJECS0IIIcQ+9QxRBpiZ98pbPZfZlAnt1YGCUEvr3k6Z/fwjr7LF16vrGvnNYtHthPfvonMQqlCoP5OUEEIIIfbvsY4+AICLd8tR1yiHs6Ny2l2hYHG5KTDtTUGoxXVryoRey2uZCb18XwoFCwR7uSDYW3gnWNHueEIIIYToJFLigQAPJ8gaFLiYW85//Xp+BcpqGuDmJOIDImI5PUK8IHJgkCeV4V7Zw6L1F++WAwD6hvpYZ2BaUBBKCCGEEJ0wDIPHO/kDAE7/+fBkxIysYgDAE5384eRIoYWluTs78ut1z+WU8l/n3ij0bcpgCw29UgghhBCis6GdAwAAR68X8l/LyCoCAAzrEmCVMRHg8Qg/AMBv2cogtEGuwMnbyjcHA8P9rDYuTSgIJYQQQojOxvQIgqMDg8v3pbhVWIn75bU4fVuZFY2Nklh5dG0XF4Qev1EEuYLFb9mlqJQ1IsDDSbDT8XrXCSWEEEJI2+Xv4Yy4KAmOXC/AxlM58HQRQ8Eqp+IjAqhIvbUMjQyAl4sj8qQynL5dgv1X8gAAI7pJIBLYSUkcCkIJIYQQopc5Q8Nx5HoBvj+Ty38tfkiYFUdEXMQiTOwbgu/P5GLOpnNoaDrCc1Lf9lYemXo0HU8IIYQQvQyJDED8Ew+Dzmn9O2BMj2ArjogAwKwh4XARO6C+UQGWVa7RHRop3HW6DEvV5YkAVVRUwNvbG1KpFF5eVO6DEEKEhmVZ/N+dMpRU1WNUdwkcRZTXEoLD1wqQsPMKeoR4IW1yT4T4uFq0f33+flMQSgSJglBCCCHE9ujz95vethBCCCGEEIujIJQQQgghhFgcBaFalJSUYMeOHVi2bBnGjBmD6OhoSCQSiMVieHl5oVu3bnjxxRexc+dOKBQKrfeTy+W4cuUKNm7ciEWLFuGJJ56Am5sbGIYBwzCYNWuWQeO8desW3nvvPfTs2RPe3t7w8PBAVFQUXn/9dVy8eNGgewqxT0IIIYTYCZZo9PHHH7MAdPro168fm5WVpfF+zz77rMZ7xMfH6z3GL7/8knV1dVV7T5FIxKakpBj4E7BOn1KplAXASqVSE46aEEIIIeakz99vqhOqA5FIhD59+mDAgAHo2rUr2rVrBycnJ5SVleH8+fPYtm0bysvLceHCBQwbNgyXLl2CRKL61Ai5XN7icz8/P/j7+yMrK8ugsX3//fd49dVXAQAODg54/vnnMXLkSDg6OuLkyZPYtGkT6urqkJSUBGdnZyxZssSgfqzdJyGEEELsC+2O1+Lu3bvw9PSEj4+P2jYlJSUYN24cfvvtNwDAwoUL8dlnn6lsu3LlSlRWVqJ///7o378/IiIisHHjRsyePRsAEB8fj40bN+o0tqKiIkRGRqKiogIODg7YsWMHJk6c2KLNmTNnMHLkSNTU1MDR0RFXrlxBVFSUTve3Zp+0O54QQgixPbQ73oRCQ0M1BqAA4O/vj/Xr1/Of7969W23bZcuWYdWqVZg2bRoiIiKMGtuaNWtQUVEBAHj99ddbBYMAMHjwYKSlpQEAGhsbkZKSYnN9EkIIIcT+UBBqIj169OAf5+fnW6TPbdu28Y//+te/qm03b948uLsrz/PdtWsXamtrbapPQgghhNgfCkJN5NatW/zj4GDzH1127do13LlzBwDQvXt3jVlVT09PDBs2DABQXV2N//73vzbTJyGEEELsEwWhJlBVVYVFixbxn0+bNs3sfV6+fJl/PHDgQK3tm7dpfq3Q+ySEEEKIfaLd8XooLCzEqVOnAAAKhQJSqRSZmZnYunUrPwXfv39/JCcnm30sN27c4B/rsra0eZvm1wq9T0IIIYTYJwpC9XDhwgVMmTJF5XOBgYGYPXs2UlJS4OLiYvaxlJeX848DAgK0tvf391d5rVD6rKurQ11dHf85t/mJEEIIIfaJpuNNJCYmBjExMRYJQAHlEgCOLn26urryjysrKwXX56pVq+Dt7c1/hIaGGjRGQgghhNgGmw9C4+Li+CMvjf3YunWrxr7Gjh0LlmXBsiwaGxuRl5eHnTt3YuTIkdi+fTsmTJiAF154ATU1NRb67u3H0qVLIZVK+Y+7d+9ae0iEEEIIMSOajjeQSCRCcHAwJk2ahEmTJvH1P9PT0wEAW7ZsMWv/Hh4e/GOZTKa1ffMSSZ6enoLr09nZGc7Ozvzn3BkKNC1PCCGE2A7u77YuZyHZfBA6bdo09O3b1yT3MuYkobS0NPz888/IyspCeno6EhMT0a1bN5OMS5XmBfSLi4u1ti8pKVF5rVD75KbvaVqeEEIIsT2VlZXw9vbW2Mbmg9A33njD2kMAoMyMjh49mj8D/vjx42YNQpsHzNnZ2VrbN29jaLBtyT5DQkL4I1MZhtHrWm0qKioQGhqKu3fv0pGgxObR65nYG3pN2zaWZVFZWYmQkBCtbW0+CBWS5lPOZWVlZu2rV69e/ONz585pbd+8Tc+ePQXfp4ODAzp06KDXNfry8vKiX3DEbtDrmdgbek3bLm0ZUI7Nb0wSEi4LCihLNplTdHQ0OnbsCAC4fv06cnJy1LatqqpCRkYGAMDNzQ2xsbE20ychhBBC7BMFoSaSm5uL/fv3858PHTrU7H1Onz6df/z3v/9dbbuvvvoK1dXVAICJEyfCzc3NpvokhBBCiP2hIFSD/Px8pKSkoLS0VGO7mzdvYty4cXxppuHDh6N79+5mH9+7777LLwH47LPPsGvXrlZtzp49i4SEBACAo6MjkpKS1N6vebkqdVlOU/dpDc7OzkhKSmqxG58QW0WvZ2Jv6DXddjCsLnvo26icnBxERETA0dERcXFxGDRoEDp37gwvLy/U19fj3r17yMjIwMGDB9HQ0AAAaN++PU6cOIFOnTqpvGd2djb+9a9/tfhaZmYmdu/eDQDo3bs3nnnmmRbPjxgxAiNGjFB5v02bNmHWrFkAlOson3/+eTz11FMQiUQ4efIkNm3axJdT+vDDD7Fs2TK132/zDUDZ2dkIDw83e5+EEEIIaZsoCNWAC0J1NXr0aHz11VcICwtT2+b48eMYPny4XuNISkrSeB79+vXr8fbbb6ut3SkSibB8+XKkpKRo7EfXINSUfRJCCCGkbaLd8RqEh4fj0qVLOHLkCM6ePYtr167h3r17qKyshFgshre3N7p06YJBgwZh+vTpGDRokFXG+dprr2HUqFH44osvcODAAdy9excKhQIhISEYOXIk5s+fj8cee8zm+ySEEEKI/aBMKCGEEEIIsTjamEQIIYQQQiyOglBiU3bt2oXnnnsO4eHhcHFxgUQiwZAhQ/Dxxx+b7Zx5a/RJ2gZLvbYqKyuxfft2vPHGGxgyZAgCAwMhFovh5eWFbt26YebMmThw4IBOZz0TookQfl/OmjWrRbUXTXsqiJWxhNiAyspKduLEiSwAtR+hoaHs6dOnbbpP0jZY8rX1ySefsC4uLhr74j6GDRvG3rlzxwTfIWlrhPL7ct++fa36TUpKMmufxHC0JpQInlwux4QJE3DgwAEAQFBQEObNm4fo6GiUlpYiPT0dJ0+eBAD4+vri5MmTRtdptUafpG2w9GtrwYIF+PLLLwEoS8iNGjUK/fv3h0QigUwmw5kzZ/D999+jqqoKABAREYEzZ85AIpEY+Z2StkIovy8rKirQs2dP3L17F+7u7vyBKdoqzBArsnYUTIg2X3zxBf+ONjo6ms3Pz2/V5p133mmRzbHFPknbYOnX1oIFC9jRo0ezhw4dYuVyuco2OTk5bFRUFN/n7NmzjeqTtC1C+X05f/58PuP69ttvUybUBlAQSgStsbGRbdeuHf/L5Pz582rb9e3bl2938OBBm+qTtA3WeG2VlJTo1O7ixYt8f25ubmx1dbXBfZK2Qyi/L48ePcoyDMMCYHfv3s0mJSVREGoDaGMSEbQTJ04gLy8PABAbG4t+/fqpbCcSibB48WL+8/T0dJvqk7QN1nht+fn56dSuT58+iIqKAgDU1NTg1q1bBvdJ2g4h/L6sqanBvHnzwLIspk+fjgkTJpjs3sS8KAglgrZ//37+8bhx4zS2ffrpp1VeZwt9krZB6K8tLy8v/nFtba1F+iS2TQiv6aVLl+LPP/+En58fPv30U5Pdl5gfBaFE0C5fvsw/HjhwoMa2wcHBCA0NBQAUFBSgqKjIZvokbYOQX1v19fW4efMm/7mm44cJ4Vj7NX3q1Cn885//BACsWbMGQUFBRt+TWA4FoUTQbty4wT+OiIjQ2r55m+bXCr1P0jYI+bW1ZcsWSKVSAEC/fv0QHBxs1v6IfbDma1omk2HOnDlQKBQYOXIkZs+ebdT9iOVREEoErby8nH8cEBCgtb2/v7/Ka4XeJ2kbhPraKioqwpIlS/jP//a3v5mtL2JfrPmaTkxMxI0bN+Dq6sqXISO2hYJQImhc7UIAcHFx0dre1dWVf1xZWWkzfZK2QYivrfr6ekydOhWFhYUAgMmTJ2PKlClm6YvYH2u9ps+dO4e///3vAICUlBR07tzZ4HsR66EglBBC2iiFQoE5c+YgIyMDANC5c2d8++23Vh4VIZrV19djzpw5kMvl6NevH95++21rD4kYiIJQImgeHh78Y5lMprV98x29np6eNtMnaRuE9NpiWRYLFizADz/8AADo2LEjjhw5Al9fX5P2Q+ybNV7TK1aswJUrVyASifD1119DJBIZdB9ifRSEEkHz8fHhHxcXF2ttX1JSovJaofdJ2gahvLZYlsXChQvx9ddfAwA6dOiAX375BeHh4Sbrg7QNln5NX7p0CR999BEA4O2331Zbl5TYBkdrD4AQTaKiopCdnQ0AyM7O1vpHkmvLXWsrfZK2QQivLZZl8frrr+OLL74AoDxP/tixY7SmjhjE0q/pjRs3oqGhAQ4ODhCLxVixYoXKdidOnGjxmGsXFRWF5557Tu9+iXlQEEoErVevXjhw4AAA5UL04cOHq21bUFCAu3fvAgAkEgkCAwNtpk/SNlj7tcUFoOvXrwcAhISE4NixY4iMjDT63qRtsvRrmmVZAMr1zCtXrtTpmmPHjuHYsWMAgEmTJlEQKiA0HU8EbezYsfxjbSds7Nu3j3+s7eQOofVJ2gZrvrYeDUDbtWuHY8eOoUuXLkbfm7Rd9PuSGMWK59YTolVjYyMbHBzMAmABsOfPn1fbrm/fvny7AwcO2FSfpG2w5mtr4cKF/P2Cg4PZP/74w+h7EiLU35dJSUl8X0lJSWbtixiOMqFE0EQiERITE/nPZ86cydczbO6DDz7AxYsXAQBDhw7FmDFjVN5v48aNYBgGDMMgLi7OIn0SwrHG6xkAFi1ahM8//xyA8ujE48eP0/plYhLWek0T+0BrQongzZs3Dzt27MDhw4dx9epV9OnTB/PmzUN0dDRKS0uRnp6OX3/9FYByt6UpTs6wRp+kbbD0a+tvf/sbf7Y2wzB48803cf36dVy/fl3jdf369UPHjh2N6pu0DfT7khjM2qlYQnRRUVHBTpgwgZ9eUfXRoUMH9uTJkxrvs2HDBr59bGysRfok5FGWfD3HxsZq7Efdx4YNG0z/jRO7ZY3f0ZrQdLxtoOl4YhM8PT2xe/du7Ny5E88++yxCQ0Ph7OyMgIAAPP7441i9ejWuXLmCIUOG2HSfpG2g1xaxN/SaJoZgWLap3gEhhBBCCCEWQplQQgghhBBicRSEEkIIIYQQi6MglBBCCCGEWBwFoYQQQgghxOIoCCWEEEIIIRZHQSghhBBCCLE4CkIJIYQQQojFURBKCCGEEEIsjoJQQgghhBBicRSEEkIIIYQQi6MglBBCCCGEWBwFoYQQYgOSk5PBMAwYhsHx48etPRzBKCsrQ2BgIBiGwbp166w9HI1kMhk6duwIhmGQnJxs7eEQYnUUhBJCiBnk5OTwQaOxH7NmzbL2tyNYy5cvR3FxMSIjI7FgwQJrD0cjFxcXpKWlAQBWr16NnJwc6w6IECujIJQQQohNunnzJr7++msAwNKlSyEWi608Iu1eeuklREREQCaTISEhwdrDIcSqGJZlWWsPghBC7E1NTQ0OHTqk9vkrV67wQUiPHj2wYsUKtW07duyIfv36mXyMtu6FF15Aeno6QkJCkJOTYxNBKAB89tlneOONN+Dg4IArV66ge/fu1h4SIVZBQSghhFjB8ePHMXz4cABAbGwsrfPUU05ODiIjIyGXy5GQkIDU1FRrD0lnFRUVCAkJQXV1NebOnctncwlpa2g6nhBCiM358ssvIZfLAQDx8fFWHo1+vLy8MHnyZADA999/D6lUat0BEWIlFIQSQogN0LY7vvlGKG4jU35+PpYvX46ePXvCy8sLAQEBGDZsGH788Uc8Ogl25coVzJs3D1FRUXBzc4O/vz/Gjx+vV4Y2Pz8fqampePLJJxEcHAwnJycEBARgyJAhWLFiBcrKyoz4CTykUCiwefNmAECfPn3QuXNntW1V/Vzu37+PpUuX8j8XLy8vPPbYY0hNTUVFRYXW/m/fvo33338fAwcOhK+vL8RiMfz8/NClSxfExMTg7bffxokTJzTeY+rUqQCUO+a3bdum43dOiJ1hCSGEWNyxY8dYACwANjY2Vmv7pKQkvv2xY8daPZ+dnc0/Hx8fz/7666+sRCLhv/box/z581mFQsGyLMt++eWXrKOjo9q269ev1zq+Tz/9lHVzc1N7DwCsr68ve+DAAX1/VK2cOnWKv+fixYs1tn3053Ls2DHW399f7RhDQkLYCxcuqL3fv/71L9bZ2Vnj9wmAdXd31ziukpISlmEYFgA7ZswYg34OhNg6R/OEtoQQQqwlNzcXkydPhlQqxaxZsxAbGwsXFxecO3cO69evR21tLb766is88cQT8PLywquvvoqAgADMmTMHffr0QWNjI/bu3Ysff/wRALB48WLExcWhW7duKvv729/+hg8//BAA4O7ujmnTpuGJJ56Av78/SktLcfToUWzfvh1lZWWYMGECfvnlFwwbNszg7+/gwYP848GDB+v1c5k6dSpKS0sxYcIETJgwAT4+PsjKysKmTZtw69YtPHjwAKNGjcKFCxcQFhbW4vrff/8d8+fPh1wuh0gkwpgxY/DUU09BIpHAwcEBhYWFuHTpEg4fPozS0lKNY+Eypzdv3sTx48chk8ng4uKi3w+CEFtn7SiYEELaInNmQgGwfn5+7P/93/+p7JfLwIWHh7P+/v7swIED2ZKSklZtExMT+fstXLhQ5bj279/P32/w4MHsvXv3VLb79ddfWU9PT77fhoYGrd+zOmPHjuXHdfv2bY1tH/25iEQidsuWLa3a1dbWslOmTOHbqcpOvv766/zzu3btUtunQqFg//vf/2r9PuLj4/n7nT59Wmt7QuwNrQklhBA7tG7dOvTv37/V1+Pi4jBy5EgAyvWSVVVV+Omnn+Dn59eq7QcffAAPDw8AwIEDB1T2s3z5crAsi8DAQOzduxft27dX2W7o0KH45JNP+H63b99u0PcFAJcvXwYAODk5oVOnTnpd++abb2LGjBmtvu7i4oLNmzcjNDQUgDLbmpmZ2aLNrVu3AACBgYF45pln1PbBMAxiYmK0jqV5aaZH+yKkLaAglBBC7IxEIsH06dPVPv/kk0/yj5955plW084cV1dXDBgwAACQnZ0NmUzW4vnLly/jwoULAIC5c+eqDGSbe+GFF+DoqFwF1nxKXR/19fV48OABAMDX11evax0cHPDOO++ofd7d3R0LFy7kP//5559bPQ8AJSUlJjntqPnPi05PIm0RrQklhBA7M2DAAIhEIrXPBwcH848HDRqk8V5cW5ZlUV5e3uLa5jvA5XI5du7cqXVsHh4eKC8vx7Vr17S2VaW8vJzf2e/v76/XtdHR0QgJCdHYZtSoUVi6dCkA4Lfffmvx3OjRo/Hvf/8bCoUCcXFxWLp0KSZPnoygoCC9xsFpPn5ta0gJsUcUhBJCiJ3RFpw5Ozsb1PbRTGjz7N3//M//6DFCw4Ouuro6/rGnp6de13bp0kWvNlzGlTNnzhz89NNPOHr0KO7cuYMFCxZgwYIF6NatG4YMGYKYmBiMHz8eAQEBOo3Hy8uLf1xbW6vjd0GI/aDpeEIIsTMODrr/aten7aPKy8sNvra+vt6g65oHxbrU9GyOm07XtU1lZWWL58RiMfbv34+1a9e2qE36xx9/4Ntvv8WsWbPQrl07vPjii8jLy9PaV/Mi9a6urrp8C4TYFQpCCSGEGITbtAQAu3btAsuyOn8YugbS19eXD5z1zaZWV1fr1UZVplUsFuOtt97CrVu38Mcff+Bf//oXXnnlFX6DVGNjI7Zs2YIBAwa0yqQ+qqSkhH+sbT0tIfaIglBCCCEG6dChA//47t27FulTLBbzO/D1DUK53e26ttG2fjQqKgpz5szBN998g9u3b+Ps2bPo1asXAOVU/qpVqzRe33z84eHhWsdGiL2hIJQQQohBYmNj+cf79++3WL9coNfQ0IDbt2/rfN3Vq1e1ZiePHDnCP3788cf1GtegQYPw3Xff8Z9nZGRobN98c1afPn306osQe0BBKCGEEIP0798fPXv2BADs3bsXJ0+etEi/zU9JOnv2rM7XKRQKrF27Vu3zNTU1+Pzzz/nPp02bpvfYIiIi+MeNjY0a2545cwaAskYpBaGkLaIglBBCiEEYhsFHH30EQFnCafLkyS0yiao8ePAAycnJRhVnHzt2LP9YnyAUANauXcsfR9pcXV0d4uPjkZuby/fBZVw5b7/9Nk6dOqXx/s2D2L59+6ptV1paiqysLADgj1UlpK2hEk2EEEIMNn78eKSmpiIxMRHFxcV46qmnMGzYMIwdOxbh4eEQi8UoLy/HjRs3cOrUKZw5cwYsy2LUqFEG9zlgwAB07NgRubm5+OWXX3S+Li4uDpmZmZg+fTp++OEHjB8/Hj4+Prh16xY2btzIB4V+fn744osvWl3/73//G2vXrkVYWBieeuop9O7dG4GBgZDL5bh//z527drFZ4PFYjHee+89tWNpXmN1ypQpOn8PhNgTCkIJIYQYJSEhAWFhYXjrrbdQVlaGjIwMjeshPT094e3tbXB/DMPgpZdewsqVK3HlyhVcvHhRY9aRExYWhuTkZEydOhW7du3Crl27WrVp164d9uzZo/IUKYZhAAB37tzBN998o7Yff39/bN68WeMUO3dsqYuLi8bTrQixZzQdTwghxGgzZ87EnTt3sG7dOkyYMAGhoaFwdXWFWCxGQEAABg0ahAULFuCnn35Cfn5+q6lufb366qv8EaDNNwNpExsbi0uXLmHJkiWIjo6Gh4cHPDw80Lt3byQnJ+P69evo16+fymvPnz+PLVu24LXXXsPgwYMhkUggFovh5OSE4OBgjBw5EmvWrEFWVhaefvpptWOoqKjAjh07AAAvvvgifHx8dP/GCbEjDMudf0YIIYTYkJdeegk//PADgoKCkJubCycnp1ZtcnJy+M1C8fHx2Lhxo4VH2drnn3+O119/HQ4ODrh8+TKio6OtPSRCrIIyoYQQQmxSYmIiHB0dUVBQgK+//traw9GJXC7HJ598AgCYMWMGBaCkTaMglBBCiE3q2rUr5s2bBwBYuXJlq7PtheiHH37An3/+CRcXF6SlpVl7OIRYFQWhhBBCbNaHH36IgIAAPHjwoEV5JCGSyWRISEgAACxZsqRFTVFC2iLaHU8IIcRm+fr6oqioyNrD0ImLiwvu3Llj7WEQIhiUCSWEEEIIIRZHu+MJIYQQQojFUSaUEEIIIYRYHAWhhBBCCCHE4igIJYQQQgghFkdBKCGEEEIIsTgKQgkhhBBCiMVREEoIIYQQQiyOglBCCCGEEGJxFIQSQgghhBCL+3+LV4p7YAp+1QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot temperature and energy vs. simulation time.\n", + "times = otf_trajectory.times\n", + "eam_times = otf_trajectory.dft_times\n", + "\n", + "temps = otf_trajectory.thermostat['temperature']\n", + "eam_temps = otf_trajectory.gp_thermostat['temperature']\n", + "\n", + "gp_energies = otf_trajectory.thermostat['potential energy']\n", + "eam_energies = otf_trajectory.gp_thermostat['potential energy']\n", + "\n", + "plt.plot(times, temps)\n", + "plt.plot(eam_times, eam_temps, 'kx')\n", + "plt.xlabel('Time (ps)')\n", + "plt.ylabel('Temperature (K)')\n", + "plt.show()\n", + "\n", + "plt.plot(times, gp_energies)\n", + "plt.plot(eam_times, eam_energies, 'kx')\n", + "plt.xlabel(\"Time (ps)\")\n", + "plt.ylabel(\"Potential energy (eV)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "110d41c5-ebcd-46dc-bb7c-aa526c72819c", + "metadata": {}, + "outputs": [], + "source": [ + "# Write xyz file to visualize the simulation.\n", + "position_list = np.array(otf_trajectory.position_list)\n", + "cells = np.array(otf_trajectory.cell_list)\n", + "uncertainties = np.array(otf_trajectory.uncertainty_list)\n", + "\n", + "# Create list of atoms objects.\n", + "atom_list = []\n", + "spec = otf_trajectory.gp_species_list[0]\n", + "skip = 1\n", + "for n in np.arange(0, len(position_list), skip):\n", + " atoms_curr = Atoms(\n", + " spec,\n", + " positions=position_list[n],\n", + " cell=cells[n],\n", + " momenta=uncertainties[n],\n", + " pbc=True)\n", + " atom_list.append(atoms_curr)\n", + "\n", + "# Dump atoms.\n", + "write('Al.xyz', atom_list, format='extxyz')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "cffe48f8-38d2-4147-ada2-88ab62d5f1f8", + "metadata": {}, + "outputs": [], + "source": [ + "# Write lammps potential file.\n", + "file_name = \"aluminum.txt\"\n", + "contributor = \"Your Name Here\"\n", + "kernel_index = 0\n", + "gp_model.sparse_gp.write_mapping_coefficients(file_name, contributor, kernel_index)" + ] + }, + { + "cell_type": "markdown", + "id": "90b0a373-e2a0-46e8-8a1c-04512d017abc", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/al.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "71e2c10f-5038-438f-842a-1489d3dc65dd", + "metadata": {}, + "source": [ + "![image](sparse_gp_tutorial_images/conclusion.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "258d6df4-797a-42e3-85f9-d7e107e68e45", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.19" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/sparse_gp_tutorial_images/al.gif b/tutorials/sparse_gp_tutorial_images/al.gif new file mode 100644 index 000000000..cb4ec7c13 Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/al.gif differ diff --git a/tutorials/sparse_gp_tutorial_images/conclusion.png b/tutorials/sparse_gp_tutorial_images/conclusion.png new file mode 100644 index 000000000..c0e130a7b Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/conclusion.png differ diff --git a/tutorials/sparse_gp_tutorial_images/flare_overview.png b/tutorials/sparse_gp_tutorial_images/flare_overview.png new file mode 100644 index 000000000..1f3002cf7 Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/flare_overview.png differ diff --git a/tutorials/sparse_gp_tutorial_images/gpff.png b/tutorials/sparse_gp_tutorial_images/gpff.png new file mode 100644 index 000000000..94c94d94e Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/gpff.png differ diff --git a/tutorials/sparse_gp_tutorial_images/intro.png b/tutorials/sparse_gp_tutorial_images/intro.png new file mode 100644 index 000000000..afd42e7f0 Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/intro.png differ diff --git a/tutorials/sparse_gp_tutorial_images/mb_descriptors.png b/tutorials/sparse_gp_tutorial_images/mb_descriptors.png new file mode 100644 index 000000000..c82bb222e Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/mb_descriptors.png differ diff --git a/tutorials/sparse_gp_tutorial_images/mb_models.png b/tutorials/sparse_gp_tutorial_images/mb_models.png new file mode 100644 index 000000000..861915dd8 Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/mb_models.png differ diff --git a/tutorials/sparse_gp_tutorial_images/md_review.png b/tutorials/sparse_gp_tutorial_images/md_review.png new file mode 100644 index 000000000..e9803e98e Binary files /dev/null and b/tutorials/sparse_gp_tutorial_images/md_review.png differ