diff --git a/__init__.py b/__init__.py index 15fb04108..724c0ddb3 100644 --- a/__init__.py +++ b/__init__.py @@ -91,6 +91,8 @@ to_smiles, writepdb, yield_coords, + to_image, + get_reaction_image, ) from scm.plams.interfaces.thirdparty.cp2k import Cp2kJob, Cp2kResults, Cp2kSettings2Mol from scm.plams.interfaces.thirdparty.crystal import CrystalJob, mol2CrystalConf diff --git a/doc/source/examples/MoleculeFormats/MoleculeFormats.ipynb.rst b/doc/source/examples/MoleculeFormats/MoleculeFormats.ipynb.rst index d68aa79f2..1e5fd8b9d 100644 --- a/doc/source/examples/MoleculeFormats/MoleculeFormats.ipynb.rst +++ b/doc/source/examples/MoleculeFormats/MoleculeFormats.ipynb.rst @@ -1,8 +1,5 @@ -Worked Example --------------- - Complete guide to storing and converting PLAMS Molecules between Python libraries and file formats -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-------------------------------------------------------------------------------------------------- .. code:: ipython3 @@ -16,6 +13,7 @@ Complete guide to storing and converting PLAMS Molecules between Python librarie AMSHOME = os.environ["AMSHOME"] cif_file = f"{AMSHOME}/atomicdata/Molecules/IZA-Zeolites/ABW.cif" xyz_file = f"{AMSHOME}/scripting/scm/params/examples/benchmark/ISOL6/e_13.xyz" + badxyz_file = f"{AMSHOME}/scripting/scm/plams/unit_tests/xyz/reactant2.xyz" assert Path(cif_file).exists(), f"{cif_file} does not exist." assert Path(xyz_file).exists(), f"{xyz_file} does not exist." @@ -140,12 +138,6 @@ library, for example ASE or pymatgen. type(mol)= -.. parsed-literal:: - - /home/user/adfhome/bin/python3.8/lib/python3.8/site-packages/ase/io/cif.py:401: UserWarning: crystal system 'orthorhombic' is not interpreted for space group Spacegroup(74, setting=1). This may result in wrong setting! - warnings.warn( - - .. image:: MoleculeFormats_files/MoleculeFormats_15_2.png @@ -381,6 +373,78 @@ Convert RDKit Mol to PLAMS Molecule .. image:: MoleculeFormats_files/MoleculeFormats_36_1.png +Convert problematic PLAMS Molecule to RDKit Mol +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. code:: ipython3 + + mol = Molecule(badxyz_file) + mol.guess_bonds() + plot_molecule(mol) + + + + +.. parsed-literal:: + + + + + + +.. image:: MoleculeFormats_files/MoleculeFormats_38_1.png + + +This molecule will fail to convert to an RDKit Mol object, because RDKit +does not like the AMS assignment of double bonds. + +.. code:: ipython3 + + try: + rdkit_mol = to_rdmol(mol) + except ValueError as exc: + print ("Failed to convert") + + +.. parsed-literal:: + + [13.12|17:47:23] RDKit Sanitization Error. + [13.12|17:47:23] Most likely this is a problem with the assigned bond orders: Use chemical insight to adjust them. + [13.12|17:47:23] Note that the atom indices below start at zero, while the AMS-GUI indices start at 1. + Failed to convert + + +.. parsed-literal:: + + RDKit ERROR: [17:47:23] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14 + [17:47:23] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14 + + RDKit ERROR: + + +The problem can be fixed by passing the argument ``presanitize`` to the +``to_rdmol`` function. + +.. code:: ipython3 + + rdkit_mol = to_rdmol(mol, presanitize=True) + rdkit_mol + + +.. parsed-literal:: + + RDKit ERROR: [17:47:06] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14 + [17:47:06] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14 + + RDKit ERROR: + + + + +.. image:: MoleculeFormats_files/MoleculeFormats_42_1.svg + + + SCM libbase UnifiedChemicalSystem Python class ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_38_1.png b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_38_1.png new file mode 100644 index 000000000..69d6cc59e Binary files /dev/null and b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_38_1.png differ diff --git a/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.png b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.png new file mode 100644 index 000000000..2499c7b76 Binary files /dev/null and b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.png differ diff --git a/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.svg b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.svg new file mode 100644 index 000000000..8e31d1ee9 --- /dev/null +++ b/doc/source/examples/MoleculeFormats/MoleculeFormats_files/MoleculeFormats_42_1.svg @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +O +O +H +H +O +H +H +H +C- + diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D.common_footer.rst b/doc/source/examples/PlotReaction2D/PlotReaction2D.common_footer.rst new file mode 100644 index 000000000..dca217012 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D.common_footer.rst @@ -0,0 +1,5 @@ +Complete Python code +-------------------- + +.. literalinclude:: ../../../../examples/PlotReaction2D/PlotReaction2D.py + :language: python \ No newline at end of file diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D.common_header.rst b/doc/source/examples/PlotReaction2D/PlotReaction2D.common_header.rst new file mode 100644 index 000000000..c569e9132 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D.common_header.rst @@ -0,0 +1,4 @@ +To follow along, either + +* Download :download:`PlotReaction2D.py <../../../../examples/PlotReaction2D/PlotReaction2D.py>` (run as ``$AMSBIN/amspython PlotReaction2D.py``). +* Download :download:`PlotReaction2D.ipynb <../../../../examples/PlotReaction2D/PlotReaction2D.ipynb>` (see also: how to install `Jupyterlab <../../../Scripting/Python_Stack/Python_Stack.html#install-and-run-jupyter-lab-jupyter-notebooks>`__ in AMS) diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D.ipynb.rst b/doc/source/examples/PlotReaction2D/PlotReaction2D.ipynb.rst new file mode 100644 index 000000000..c864872e2 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D.ipynb.rst @@ -0,0 +1,79 @@ +Worked Example +-------------- + +Creating 2D images of molecules +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. code:: ipython3 + + from IPython.display import SVG + from scm.plams import ReactionEquation + from scm.plams import from_smiles, to_image, get_reaction_image + + aspirin = from_smiles("CC(=O)OC1=CC=CC=C1C(=O)O") + text = to_image(aspirin) + SVG(text) + + + + +.. image:: PlotReaction2D_files/PlotReaction2D_1_0.svg + + + +It is also possible to write the image to file in a range of different +formats (SVG, PNG, EPS, PDF, JPEG) + +.. code:: ipython3 + + text = to_image(aspirin, filename="aspirin.svg") + text = to_image(aspirin, filename="aspiring.png") + +Creating 2D imageas of reactions +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +We can have aspirin react with water to form acetic acid and salicylic +acid + +.. code:: ipython3 + + acetic_acid = from_smiles("CC(O)=O") + text = to_image(acetic_acid) + SVG(text) + + + + +.. image:: PlotReaction2D_files/PlotReaction2D_6_0.svg + + + +.. code:: ipython3 + + salicylic_acid = from_smiles("O=C(O)c1ccccc1O") + text = to_image(salicylic_acid) + SVG(text) + + + + +.. image:: PlotReaction2D_files/PlotReaction2D_7_0.svg + + + +We can create a 2D image of the reaction as well, and optionally store +it to file + +.. code:: ipython3 + + reactants = [aspirin, from_smiles("O")] + products = [acetic_acid, salicylic_acid] + text = get_reaction_image(reactants, products, filename="reaction.svg") + SVG(text) + + + + +.. image:: PlotReaction2D_files/PlotReaction2D_9_0.svg + + diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D.rst b/doc/source/examples/PlotReaction2D/PlotReaction2D.rst new file mode 100644 index 000000000..2b875965c --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D.rst @@ -0,0 +1,11 @@ +.. _PlotReaction2DExample: + +PlotReaction2D +============================== + +.. + Feel free to modify the above label, header, and add any custom information here + +.. include:: PlotReaction2D.common_header.rst +.. include:: PlotReaction2D.ipynb.rst +.. include:: PlotReaction2D.common_footer.rst \ No newline at end of file diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_1_0.svg b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_1_0.svg new file mode 100644 index 000000000..c3610edb0 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_1_0.svg @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + +O +O +O +HO + \ No newline at end of file diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_6_0.svg b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_6_0.svg new file mode 100644 index 000000000..71a6c8e4a --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_6_0.svg @@ -0,0 +1,12 @@ + + + + + + + + + +O +OH + \ No newline at end of file diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_7_0.svg b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_7_0.svg new file mode 100644 index 000000000..846174ff4 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_7_0.svg @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + +O +OH +OH + \ No newline at end of file diff --git a/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_9_0.svg b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_9_0.svg new file mode 100644 index 000000000..4f5a7bc30 --- /dev/null +++ b/doc/source/examples/PlotReaction2D/PlotReaction2D_files/PlotReaction2D_9_0.svg @@ -0,0 +1,73 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + +O +O +O +HO + + + + +O +H +H + + + + + + + +O +OH + + + + + + + + + + + + + + + + + + +O +OH +OH ++ ++ + + + \ No newline at end of file diff --git a/doc/source/examples/examples.rst b/doc/source/examples/examples.rst index 351f43872..7dff22cc9 100644 --- a/doc/source/examples/examples.rst +++ b/doc/source/examples/examples.rst @@ -36,6 +36,7 @@ Molecule analysis PlotCorrelation/PlotCorrelation MapMoleculesAndConvertToDCD HydrogenBondsFromMD + PlotReaction2D/PlotReaction2D MD trajectory analysis ---------------------- diff --git a/examples/MoleculeFormats/MoleculeFormats.ipynb b/examples/MoleculeFormats/MoleculeFormats.ipynb index 64e0143c6..cd5991943 100644 --- a/examples/MoleculeFormats/MoleculeFormats.ipynb +++ b/examples/MoleculeFormats/MoleculeFormats.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 20, "id": "f609f4c1-5dab-4349-9250-d4bb89ddb656", "metadata": {}, "outputs": [], @@ -25,6 +25,7 @@ "AMSHOME = os.environ[\"AMSHOME\"]\n", "cif_file = f\"{AMSHOME}/atomicdata/Molecules/IZA-Zeolites/ABW.cif\"\n", "xyz_file = f\"{AMSHOME}/scripting/scm/params/examples/benchmark/ISOL6/e_13.xyz\"\n", + "badxyz_file = f\"{AMSHOME}/scripting/scm/plams/unit_tests/xyz/reactant2.xyz\"\n", "\n", "assert Path(cif_file).exists(), f\"{cif_file} does not exist.\"\n", "assert Path(xyz_file).exists(), f\"{xyz_file} does not exist.\"\n", @@ -56,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 21, "id": "9ad1c2c4-29e9-4320-bf8b-1df2df7b7831", "metadata": {}, "outputs": [ @@ -69,14 +70,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -100,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 22, "id": "8f21e769-031a-414a-ac65-cb5cfe5a193b", "metadata": {}, "outputs": [ @@ -137,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 23, "id": "c50ddd01-c601-4bb1-855c-5c57370123b7", "metadata": {}, "outputs": [ @@ -150,14 +149,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -181,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 24, "id": "01e5758f-cefa-4d80-8c75-2ec08fc0ff33", "metadata": {}, "outputs": [], @@ -192,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 25, "id": "e6299460-fde0-4f9f-9df2-5d9cdf61a3fa", "metadata": {}, "outputs": [ @@ -232,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 26, "id": "bd212e28-b10d-46c3-b1e8-e5022d19efee", "metadata": {}, "outputs": [ @@ -243,24 +240,14 @@ "type(mol)=\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/user/adfhome/bin/python3.8/lib/python3.8/site-packages/ase/io/cif.py:401: UserWarning: crystal system 'orthorhombic' is not interpreted for space group Spacegroup(74, setting=1). This may result in wrong setting!\n", - " warnings.warn(\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -287,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 27, "id": "4de4e588-9f26-48b8-a306-c7ad498ef511", "metadata": {}, "outputs": [ @@ -322,7 +309,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 28, "id": "2026498d-f78e-4337-993a-109a05094a8d", "metadata": {}, "outputs": [ @@ -353,20 +340,18 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 29, "id": "1846a459-afdc-48d6-98c6-3741c41d1453", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -397,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 30, "id": "13ba6b79-71e3-4cdb-bd9c-cebbfb25c9e6", "metadata": {}, "outputs": [ @@ -436,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 31, "id": "9d4538fe-ebf2-483e-9cb9-2bb79e74265d", "metadata": {}, "outputs": [ @@ -449,14 +434,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -488,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 32, "id": "f475f91d-b65c-4566-a35d-dba3fd11c041", "metadata": {}, "outputs": [ @@ -504,14 +487,12 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAGdCAYAAACFNaNaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC+jElEQVR4nOydd3gUVReH39meRuiQ0HsJPQFCF6SJglQVUXrvoAiogCCIVCkSeu/Sq6AIIi2BhN57h9BSIMn2+f6gfCIt2exmZpN5nycPD7tz7/3tlHvmlnOOIIqiiIKCgoKCQhpDJbUABQUFBQUFKVAMoIKCgoJCmkQxgAoKCgoKaRLFACooKCgopEkUA6igoKCgkCZRDKCCgoKCQppEMYAKCgoKCmkSxQAqKCgoKKRJNFIL+C92u53bt2/j4+ODIAhSy1FQUFBQcDNEUeTx48f4+/ujUr15nCc7A3j79m1y5coltQwFBQUFBTfnxo0b5MyZ843fy84A+vj4AE+Fp0uXTmI1CgoKCgruRmxsLLly5XphT96E7Azg82nPdOnSKQZQQUFBQcFh3rWMpmyCUVBQUFBIkygGUEFBQUEhTaIYQAUFBQWFNIliABUUFBQU0iSy2wSj4Fye+8PcuXOHuLg4rFYrgiCg0WjIlCkT2bNnR6fTSS1TQUHhX4iiyMOHD4mMjMRoNGK1WlGr1eh0OrJmzUqWLFlQq9VSy3R7FAOYioiOjubgwYOEhoYSFhrK+fPnuH3nDvHxCW8tlzlTJvz9/ShTthzBwcEEBwdTsmRJNBrl9lBQcDW3bt16+syGhXEwLIwrVy5zN/IeZrP5jWXUajVZs2Qmd+7cBJWvQHBwMBUrVqRgwYJKAJEkIIiiKEot4t/Exsbi6+tLTEyM4gbxDux2Ozt37mTZsmUc2L+Ps+fOA5AhnTeBAfkpms8fvywZyJ7Zl2yZ0uPj5YH6WVQEi9XKw+jH3H0Yw937Udy694gjZ69z8sI1rFYbHh4GggKDeK9mTdq3b0/evHkl/KUKCqkHo9HI6tWrWb9+PWGhB7h56zYAObNnJrB4Pgrmykb2LOnJlik92TL54mHQoVapsIsiJpOF+1Gx3H0Qzd0H0Vy9fZ/DZ65y4erTOjJlzEiFChWo/8EHtG7dmvTp00v4S6UjsXZEMYBuSFRUFAsXLmR6SAjnL1ygcN4cVCtXhKASBShfogAFcmVz+C0wwWjm2LlrHDp5kYjTl9kZdorHcQl82KAB3Xv0oF69em8NLaSgoPB6rly5wsyZM5k7Zw4PHj6kYqlCBJcqRFCJAgQF5McvSwaH646KeULE6cuEn7rMwRMX+SfiDDqdjpYtP6dHjx6ULVvWib9E/igGMBVy+PBhpk2bxvLly7BYLHxcM4gOzWpRqXRhl017xCWYWL39AHPW7uLE+Wvkz5ePrt260b59ezJlyuSSNhUUUgs2m43t27cTMm0aW3//nXTennz+YRXaN6lJoTx+Lmv37oNoFm3czYL1u7l97xHBFSvSvUcPWrRogcFgcFm7csFlBvCff/5h3LhxREREcOfOHdatW0fjxo1ffC+KIsOGDWP27NlER0dTpUoVpk+fTqFChZwq3JmIosilS5d4+PAhWq32pe/8/Pzw83v1Rr1z5w537txJkWMvX77M+HHjCDt4kBzZMtGucQ2+bFSdbJnSJ/YnJhtRFDl08hJz1uxk/V+HEFQqWrVqRd++fbFYLC8dK4dzphyrHCvlsbdv32bGjBnMmzeXW7duU6pwHjo2r0WzOsF4eehfOd5VWK02ft97lDlrdrL70CkyZEhP3779GDhwIHr9/3Wk1Dmz2+1ERkZSrVo1l/bvibYjYhLZunWr+N1334lr164VAXHdunUvff/zzz+Lvr6+4vr168Vjx46JjRo1EvPlyycmJCQkqv6YmBgREGNiYpIqzWEiIiJEQPzoo49E4KW/YcOGvbbMsGHDUuxYQKxQspC4ZEwv8cHeuWJ06AJJ/y7+PkUc1r25mMHXR/T09JDlOVOOVY6V6tgLFy6I+fLmFQGxyfsVxB1zhohRB+ZL/tweWjla7NyitqjRqMViRYuK+/btk+ScAeKff/4pPn78+LVlnEFi7UiypkAFQXhpBCiKIv7+/nz11Vd8/fXXAMTExJAtWzYWLFjAZ5999s46pRgBRkREEBQURIMGDWjUqBE5c+Z88TYj1Vvmzp07GTvmZxLi4xneowXtmrwnu7W3+49iGTRpGWv+CKVSpWC+++77F79Lrm/myrHKsa461mq1MnHiRIYNG0q2jL5MHtSG9yoEvFKP1Jy6eIPeoxdw+PRlevTowU8//cSTJ09S5JytX7+eH3/8kbZt29KyZUsqV66Mt7e3k37Z/0mRNcD/GsDLly9ToEABjhw5QpkyZV4cV6NGDcqUKcPkyZOdJtyZHDp0iAoVKnD06FGmT59OixYtKFy4sCRpmR49ekTnTp1Ys3Yt9auVZcKAL8mRNWOK60gK2/Ye5atxi4l+ksDYsePo1q2bshVbIU1x5swZvmjViqPHjtHt0zp827lpik51JhWbzc7MVX8ycuZaMmXKwoKFC6lVq5bL2509ezZdunQhJiaGr776isaNG1OjRg28vLyc2k5i7YhThxR3794FIFu2bC99ni1bthff/ReTyURsbOxLfymN3W4HnvrWTJ8+ndWrV3P69Glu3ryZojrOnDlDxQoV2PnXn8z7sRvLx/aWvfEDqF+1DAeWjeTTuhXp0aMH7du3x2QySS1LQSFF2Lx5MxUrViA+5j475nzPqD4tZW38ANRqFd0/q8eBpSPJlz0ddevWZcqUKSRjPJQo7HY7KpUKHx8fxo4dy9atW/nzzz9JSHi7r7KrkHxObfTo0fj6+r74k2LU9dwAqlQqBEFg2rRpbNq0iePHj3P79u0U0bBlyxYqVqyAFhO75g2haZ2KbjWKSuflwcSBbZg+tBPLly2l5nvvvfGlR0EhNSCKIj///DONGjWiWtnC/Dn7O8oVzy+1rCSRxz8L6yZ/TbdP69CnTx86dOjg0pfX5wYQIH369AwfPpy9e/eyadMmjEajy9p9E041gNmzZwcgMjLypc8jIyNffPdfBg8eTExMzIu/GzduOFNSosifPz+zZs16MYetUqmYNGkS27dv59ChQy7vyOfNm0fDhg2pWqYQf8z6jrw5srq0PVfSskEVtoQM4sqlcwRXrMjly5ellqSg4HTsdjtdu3Zl8ODBfNX2I5b83BMfLw+pZTmEWq1iZO/PCBnSkaVLltDggw+Ii4tzSVs1atRg+vTpL/6fKVMmBgwYwPHjx1m9evVbo9+4AqcawHz58pE9e3b++uuvF5/FxsYSFhZGpUqVXltGr9e/SH4rVRLcbNmy0alTJzJk+L8jqkajYfz48ezZs4e9e/dy7949l7Q9c+ZMOnToQLvG77F0TC+3fYj+TVCJAuyY8z1q0Uz1atW4ePGi1JIUFJyG3W6nQ4cOzJ49m6nftef7Ls1kt0HNET7/sCrrpnzNwbBQPqhfnydPnji9jeLFi9OhQ4eXPsuWLRvdunXj6tWrLF68GKvV6vR230SSr9qTJ084evQoR48eBZ5GNzh69CjXr19HEAT69u3LyJEj2bhxIydOnKB169b4+/u/5CvoLmi1WkaNGkVERAQ7duzgwYMHTq1/wYIFdO3alc4tajPhm9ap4iF6Ts5smdg6fRAeWpH3a9Xi2rVrUktSUEg2oijSrVs3Fi5cyIyhnfiyYXWpJTmVKmWLsHbyVxw5HEGjhg1TbG0uR44cfPnll0RHRzN79mxsNluKtJvkXaB///03NWvWfOXzNm3asGDBgheO8LNmzSI6OpqqVasSEhJC4cKFE1W/HCPBJCQkMGbMGHLnzk2TJk1eGik6yl9//UW9evX4smE1fhnYxq3W+5LC7XtRfNBtNN6+mTkQGoqPj4/UkhQUHGb06NF8++23TP2ufaozfv9m/9FzNOs7kcZNmrB06bIU658uXbrE9u3bsVqt9OzZ0+FBgRIKzck8efKEKVOmkCFDBj7//HN8fX0druvSpUuULx9E2cK5+G1CXzSa1J3W5OyVW9TpOJJa79dh7bp1qWqkq5B22LRpEx9//DFft2vId52bSi3H5azbcZB234fw888/M3DgwBRr9+zZs+zfv5+oqCj69+/vkPGVxA3CXYmJiSE8PPytu5+8vb3p0aMH8fHxzJs3z+H58djYWBo1bEhGHw/m/dg11Rs/gKL5cjB7eBc2btrEsGHDpJajoJBkTp8+TatWn9OgejkGd2wstZwUoUntCnzdriGDBw9m8+bNTqnzzp07L5bP3kTRokWpWLEifn5+jBs3zqWuGYoBBEJDQylfvvw7N7r4+vrSrl07dDodv/76q0Pz419//TXXr11l+dhepE/nXOdPOVO/ahmGdG3GyJEj2bt3r9RyFBQSjcViodXnn5MjS3pmDO2YpmYwvu3UhHpVy9C2TRvu37+f7PoWLVrE+++//87jAgICKFGiBAUKFODnn39OdrtvIu1cybfwbz/Ad5ExY0Y++eQTMmfOzLhx45LkM7N7925mz57ND92bUzivv8N63ZU+XzSgfMmCdOzQQRKfHwUFR5gwYQLHT5xg+pAOqWKXdlJQqVRMHdwOu81C3759kl3fv/0A30WpUqXIly8fAQEBjBo1Ktltvw7FAJI0AwiQJUsWPvroI/Lnz8+PP/74SjaE15GQkEDHDh2oVLoI7Zu+uokoLaBWq5gyuB2Xr1xm5MiRUstRUHgn58+f54cffqBHy7qULZZPajmSkCVjOn7q8xnLli1ny5YtyaorKQYQoFy5cvj5+VGuXDl+/PHHZLX9OhQDCC/mmJNyYbJnz06tWrUoVaoUQ4YMeafvyvDhw7l+/TqTB7dJU1Mo/6VY/hz0b/0hY8aM4fjx41LLUVB4I3a7nU4dO+KXJT2DOzWRWo6kfPZBZWpVLEm3rl15/Pixw/WIopjk/q98+fJkzJiRSpUqMWLECIfbfh0ap9bmpiR1BPgcf39/KleujF6vZ+DAgfTv3/+VKDh+fn5ERkYyfvx4Bnf8+MXU590H0dx9EP3Ssdkzpyd75vSvtJPaju3f5iM27IqgQ/v2rFu//pW1V7lF+VeOTZvHrl27ln/27GHiN62JfZKAp+HV+J7u8Lw569jOzWvRbsiMp24gU6e+dGxiz6/dbkcURQ4fPvzOY/9dr1ar5ebNm2TNmpUBAwYwbty4V451CNdkY3IcKfIBRkVFiYcOHRLNZrND5Q8ePCj6+fmJbdq0eW2erBYtmosF8/iJ9/fOeZGba2CHj185dmCHj1+bxys1Hrtl+mAREFu2bOk2ed6UY9PusXJ8hqQ4tkZQcVGr1Yp37txx6PzeunVL7NKlS7KuhY+PjxgZGfna45+TIvkAXYFc/QDfxo0bN8idOzfLli2jSJEiL30nCAIVKlRgVO9P6fJJnRefy/ENLyWPFUWR99qNIJNfXsaNH//Sse4wOlCOTd3Hrlixgv79+zNzWGeK5POX5TMkxbGeeh012g3nu++H8N133734PKWu2z///EO/fv24e/fuK1mH/o3iCJ+CXLt2jbx58/LHH39Qp06dl74bMWIEY37+iTObfsHX21MihfJk0cbd9Bm9gIsXL5I/v3tF0VdI3dSvV4/7Ny+yc95QqaXIjl6j5vH3kctcvnIFjSZlV9E2bNhA48aNuXfvHlmyZHnjcYojfArypjVEi8XCzBkz+KReJcX4vYbmdYNJ5+3JzJkzpZaioPCCixcvsv2PP+iQRndrv4sOzWpx4+bNZO8IdQRH92u8CcUAOoE3XZRNmzZx+84dOjRzfaZld8TToOfzD6swd84cxS9QQTbMmDGDDL4+NK1dUWopsqRM0bwElShIyLRpKd62YgBdwMWLF5k9e7bDaTh8fX0ZMGAAuXPnfunzab/+SnDpwpQslPsNJRU6NK3Fw0ePWLVqldRSFBRISEhg3ry5fPFRFTwMOqnlyJaOzWryx59/cuHChSSVCwsLS9azXrhwYQYMGIDBYHC4jn+jGECehkLr3LmzwwYwc+bMjB07lgIFCrz47MyZM+zctUuZRnkHBXNnp2bFEpK8TSoo/JeVK1cSFRVN+ybKrM3baFyrPBnT+zBjxowklVu1ahVDhgxxuN2SJUsyduxYPDycE5FHMYA4f1gNTxdrvT09aFQzyGl1plZafViV0LCwV3aGKSikNOvWraVKuaLky5lVaimyxqDX0bxORdauWZ2kckmNBONq5KNEQlxhAMPCQilXPB96ndZpdaZWgksXAp5OjygoSIUoioQeCKVSqUJSS3ELKpUuzNVr19+ZRODfyM0AKpFg4EX24S1btvDgwQOMRiM2mw2DwYCPjw8lSpSgWLFiid7y+/xBalW/vCtlpxpyZM2IX9aMhIWF0bhxY6nlKKRRrl27xr379wkqUeDdBysQGPDUdSksLIyGDRsmqoxiAGXC2bNnWbFiBeGHDrFv926AF52vTqVCLQgYbTaeO0l66PWULlmSwIoVqVevHg0aNECtfprLz2azERcXh5eXF2q1mhs3bnA3MpLAAOVBSgyCIBBYLB+hBw5ILUUhDRMaGgpAUIDik5oYcmXPRLbMGQgNDU0xA2g2mzEajfj4+DglS718THEKYLFYWL16NbVq1KBYsWJMGTUK259/0sNiYa3BwDUvL2ze3pi8vIj39MTm7U20tze7PTwYBRQ4epQ/Zs+mUaNG5M+dm59++onIyEiOHz+Or6/vi0SPyoOUdMqXKMCh8EMvRuMKCilNWFgYeXNmI3MG9wjAITWCIBBYPB9hz/q7xDBlyhTCw8MdbnPp0qX4+vq+WLZKLmliBCiKIrNmzWLE0KHcvnePKjodSw0Gmmk06N/yFiEIAr5AdY2G6v/6PFyjIeT+fX4cMoQfhg2jfv36wP/XEA8ePEge/6xkzeTrwl+VuggMyE9cXDynT5+mZMmSUstRSIOEhYYSVDxtpjxylKCA/PyyZFuiR3YqlSpZI8DngcsUP8BEcu3aNerUqkXXrl15PyqKo56e7NXr+VyrfavxextBajXzDAZueXryk1rNrt9/B+Dvv/8G4MqVKxTM/eY4dQqvUihPduDpuVNQkIIrVy5TMHd2qWW4FQVzZ+fx4yc8evQoRdp7PvJzxvQnpOIR4PNR39f9+pHBamW7hwd1nRy3LqMg8LVOR1FBoKHNRv/+/Qk/dIhrV69QxE8Z/SWFzOnToVaruH37ttRSFNIgVquVyHv38XtNUGiFN+OXJT0At2/fJnPmzC5vz9mbaFLlCNBms9G5Uye6du3KZ1YrJ/R6pxu/f5Pp2QX5Sadj66pVnDx2HE8likSSUKtVZM2UXvEFVJCEe/fuIYoi2RQDmCSyZUoPkGLPrWIA34HVaqXV558zf948FhgMzDYY8HXScPlNFBQElhoMdNfpiNDryWa3s2bbfi5dv+vSdlMb2TKl5+5d5ZwppDzP77tsyrp9knh+vhL73C5atIiJEyc63N7777/P4sWLHS7/X1KVAbTb7XTs0IE1q1axSq+njTZlnNCzqFR8rtXiKwjkV6kI9fQkq9FC4x4/czPyYYpoSA14GHRKUGwFSUhISAB4bdZ3hTej12lRq1Uvzt+72LFjB+vXr3e4vUKFCvHZZ585XP6/pCoDOHz4cBYtWsQivZ4mKWT8XoefSsUOgwFV1GOa9xpHgtEsmRZ3Qq0SHI7HqqCQHJ7fd2p1quoSUwS1Sp3o51YURVk5wstHSTIJDw9n1MiRDNPpaCmh8XtOTpWKrTo9V25GMmrWWqnluAV2u/giuICCQkry/L5zln9ZWsIu2hP93MotEox8lCQDk8lE2y++oJRGw7c6+Ww+Ka5WM0KjZdrybYQdT1rakLSI2WJFK4OXF4W0h17/dOrTaLZIrMS9sNnsWK02dInsdxUD6AJGjBjB+QsXWKDRoHXxhpfX8UgU2W21YhTFV77rr9NRXqOhx/BZylToO7j/KJasWZUo/AopT5YsWQB4EPVYYiXuxf2oWIBEP7e5cuUif37HI2Rdv36dffv2OVz+v7i9Abx69Spjfv6Z7zUaSkk0fRZus/FeQgL3X2MANYLAAq2O67cfMH3lHxKocw9EUeTugyj8/PyklqKQBsme/akD/N0H0dIKcTOen6/EPrdjx45l1qxZDre3YsWKRMcdTQxubwBnzpyJt0rFVxJOfT5fNXjTySymVvO5RsO8VTuw2ZQ1htcRHRuHyWzB399faikKaRCDwUDGDBkUA5hEnp+vlHpuFT/Af2EymZgzcyZtBQEvCaY+n/PcpL1NQQ+tlpsPotm+71hKSHI7rt15AEDOnDklVqKQVsmVKyfXbt+XWoZbce32fbRabYotXSgG8F+sXr2aB1FRdJN448u7RoDwNH5oea2Guat3pIQktyPi1GU0Gg2lS5eWWopCGiUwqDyHz1yVWoZbEXH6MmVKl0p0rtTkohjAfzFn5kxq6XQUkXhXUWIMIEB3tYa/Dp7i+rPRjsL/CT91idKlSuLh4SG1FIU0SnBwMKcu3iAuwSS1FLch4vRVgitVTrH2nO1H6LYG0Gq1EhoWRkMJpz6fU1Ot5rSnJxnfoeWjZ5t0Dp28mBKy3Irw01dS9EFSUPgvwcHB2O12jpxRMpIkhkcxT7h0/Q7BwcGJLvPVV18xePBgh9vs1q3bi6w7zsBtDeDp06cxms0EysCnxEcQKKZWo3mHAcysUpFbq+Ho2aspI8xNiI6N48LV21SsWFFqKQppmOLFi+Pt7UX4yUtSS3ELIk5dBkjSc3v69GnOnz/vcJuZM2emcOHCDpf/L9JbDwcJDw9HAMq6WeSQIBGOnlbeMP9N+KmnHU5S3iQVFJyNWq2mfFB5DioGMFEcOnWJzJkyJcmvT3GEdxIREREU0evxlsEUaFIIVKk4fvbqi8zGCrD6zzDy5slDwYIFpZaikMapW68eO8NOEhXzRGopssZut7Pmz4PUrVc3SclpFQPoJC5dvEhRm01qGUmmmEpFTIKJh9FKxAmAh9GPWbfjIN26d3dalmcFBUdp3749NrvI0i17pZYia/4JP8Ol63fo1q17ksopwbCdRMKTJ3hJLeIZZ202JpnNWBIxqvN81skrMQefsnTzHhBUtG/fXmopCgpkzZqVFi2aM2/d30pg7LcwZ+1OSpYoQZUqVZJUrnbt2lSrVs3hdvfs2cPChQsdLv9f3NYAmkwm9DIZMUTY7fQzmUjMePR5tjGzWUn7Y7PZmbvubz755BMyZ84stRwFBQC6d+/B5Rt32XXwlNRSZMnNyIds/ecI3Xv0SPKszaBBg+jePWmjxn+zceNGfvrpJ4fL/xe3NYA6nQ6zTNbREusHCPA8HLZWmzKOo3Lmr7ATXLt1L1kPhIKCs6lcuTKlSpZkzpqdUkuRJQvW/42XlyetWrVK8bYVR/hneHh5ES+1iGc8H/kl5mTGPzPaHnol7c/cNTspW6aM4v6gICsEQaB7jx5s33dMCVrxH8wWK4s27qF16zb4+PikePuKAXxGvgIFOCcTF4ikjADP2e34GHRk9PV2pSTZc/XWPf7Yf9yhaRQFBVfTqlUrvLw8mb9ul9RSZMXGXeHcexhNt27dJGlfMYDPCAoK4ozZTJwMpkEFQMfbg2E/J8Jup2ThPLLaCZXSiKLIwIlLyZ4tGy1btpRajoLCK3h7e9OtW3emr/yTS9fvSi1HFjyOS2B4yGo+qF+fgIAASTSo1WoMBoPT6nPbXjgwMBC7KHJMBju12mm1mHx8EjWSCRegTHHHE0KmBtbuCGP7vmOETJ+Ol5dc9vIqKLzM0KFD8fPzp8+YhYrfLvDjjDU8jI1jWkiIw3VUrVqVnj17Olx+4sSJHDp0yOHy/8VtDWBAQAA6rZYIN/IFfCSKXLFYKVM0j9RSJONRzBMGTlxO82bNaNy4sdRyFBTeiJeXF7Nmz2ZvxBkWb/xHajmScvDERWav/ouRI0eRL18+h+tJSEjAapXPDni3NYA6nY7y5crxuxu9mW17duHtdvfR7GwGT1qGVYSpv/4qtRQFhXdSu3Zt2rZty5Bff+PO/Sip5UiCyWyh10/zCQoMpHfv3smqS26RYNx6L36HLl3o0L49l7Va8svopL6JELudjL6+jJ67gfrVypDeJ21N/23be5SVv+/H19ubKhUqkDN3bgIrVCAwMJCgoCAKFSokq4dDIW2RkJDA8ePHiYiIICIigiMHD/Lo0SPi4+OJTzDS9+cFLB/XJ83do2PmbuDSjUgi1m9FncyNh3a7Pdl1OBO3vpKffvop6dOlY4bZ/O6DJeaYzcY+s5nhI0cSE2ei09CZ2GzSr1+mFOev3qbjkOkUU6vpZzLxSWQk2cLC2DBtGl988QVFixYlU/r09OnTh7Nnz0otVyGNYLfb2b59Ox83bEg6Hx+Cg4Pp07MnR5Yupdy5c3zx4AF94uP5FIHt+44xdt5GqSWnKBt2HmLiws2MGDGCUqVKJbs+uY0ABVFmq7uxsbH4+voSExNDunTp3nn8V199xYIpU7hpMOAh0Xb6P6xW1litzHzL7qSuRiMb06fn2q1b7Nq1iw8++ICeLesxotenKahUGqJj46jd7ge0kVGEGgyk+891eiSKHLbZ2GGzMU8UuW+xUKtGDbr36kXjxo1l9caokDqIjo5m7ty5TJ86lUvXrlFap6O9IFBZraakSvXaKFMjTSaGmM0sGt2TRjWDJFCdspy4cJ16nUfRsNHHLF++winuSosWLSJXrlzUrFnTofJz5szh7t27fP/99289LrF2RD6m2EG6du1KlM3GrxbpYmuesttZ9pb2L9ntLLLb6dy9O1qtlrp16zJhwgSmLP2dxZtS9+K6yWyh7eBfeXj3IRv1+leMH0BGQaC2RsPPej039HqWGgyYDhygefPmvFetGhcuXJBAuUJqZcOGDRQtVIhvv/mG4Nu32efpyRGdjt46HUFq9RtDLH6n09FCq6XrsJmpPmnu7XtRtPpmKkWKFGPevPlO89Vt3bq1w8YPnsYC3b59u1O0QCowgIUKFaJv374MtVg4J5FLhJ03n0i7KNLeYiGbnx9ff/31i8/79OlD165d6TN6Aav/CE0RnSmN2WKl3bfTOHDkLGt0egomYupDLwh8rtWyV6/nbw8PboeHU7pkSSZNmqQEJ1ZIFg8fPqTV55/TuHFjysfEcNnDgyUGA5XV6kR18IIgsECvp5Qo0rTnWI6fv5YCqlOeew9j+LjXONAY2LBxI56enlJLeoHiCP8aRo4cSa48eWhnsWCTYEb3bQYwxGLhH7OZuQsX4u39/+gvgiAwbdo0WrduTecfZrHi930pojWlMJrMtB44lR37jrFOb6CmJun7rWpoNBzX6+lot9OvXz/eq1aNe/fuuUCtQmpn9+7dBBQtytZVq1hoMLBRryeHAx2ppyDwu95AfrOFj7v9zNGzV50vVkJu34viw+5jiDOL/LVzJ7ly5ZJa0ksoBvA1eHp6Mm/RIkItFn6RYCrULoqvPZGX7HYGWq1069qVWrVqvfK9SqVizpw5tGvXjm4j5jBp0ZZU4XD7ICqWZr3H8XfocTYYDHzggPF7jpcgMMVg4G8PD84fPEj1ypW5ceOGE9UqpHY2b95MvTp1KB4Twym9ntZabbKm9NILAjv0BgqbLTTs+hPb9x11nlgJOXHhOvW7/ITJrmb3P//IMkG1YgDfQNWqVenfvz+DzGY2prCjpZ9KRfn/bNS4Z7fzodlM9hw5GDtu3BvLqtVqZs2axbfffssPIavoPGwWCUb572p9Eycv3KBW62GcP3mZP/UG6ifD+P2bGhoNe/V6jNevU6NKFW7duuWUehVSN5s3b6ZJ48Z8CPyu1+PvpM4zvSDwp95ATZudz76axOTFW9365XXDzkPU6zyKTNlysHffPpcZv4sXL3L//n2HyxcsWJDixYs7TY/b7wL9N1arlc8++YTNGzawQa+nnpM636TyUBSpYzZzO1069h44kOibaeXKlbRr15aief2ZM7wzBXJnd7FS5yGKIqu2H6Df6PkUsols0OvJ7YLtztftdqqazfjky8c/+/eTKVMmp7ehkDrYvXs39evW5QNR5De9Ho0LdonbRZGhZjOjzGaa16nI+G9au5V/r9liZezcDYxfsIlPPmnB/PkLXLrmlzdvXr788kt+/PFHl7UBaWgX6L/RaDQsXb6c2vXq0chkYq0E06G37Haqm83c9Pbmz507k/Qm9emnn7J37z6iE+xU+XIokxZtwWqVf6i3m5EP+az/RDr/MIuP7bDXYHCJ8QPIrVLxp07H3cuX6dali0vaUHB/Hj16xGctWhAsiix3kfEDUAkCI/V6VhgM/LHzEMGfDGLT3xEuacvZhJ+8xHtthzNpye+MGjWKFStWunzDi91ul1X2l1RlAAH0ej1r16+nSfPmNDca+cpoJCGFBrkbLBYCTSYeZ8rEnv37KVmyZJLrKFeuHCdOnqRHz16MmLGGWh1+5Ng5ee42s9vtzF69g+BPBnPi0GnWGwwsNRjwcvENXkSlIkSjYdWaNaxatcqlbSm4J7179SLh0SOW6HRvdGtwJp9qtZw2eFDhiZEvB03ly4FTuPsg2uXtOsKTeCODfllKnU4j8UyflfDwcL799tsUMUxyc4SXjxInotPpWLpsGWPGjmUaUMZkYr8Lg2Y/EkW+MBppbDRSvm5dwiIiKFKkiMP1eXl5MX78eEJDQ0HnQ632IxgydYVsHihRFAk9doEGnUcxYPwSPreLnDZ48LE25ZL8fqLR0FSrpXuXLslaU1BIfWzYsIGly5YxWat1aKeno+RQqViv17PSYCBs3zGCPxnErFU7iEswpZiGt2G12lj/10EqtxrCwo17GDduHAdCQyldunSKaZCbAUxVa4Cv48yZM7Rr3ZqD4eF012rpr9M5LW5onCiyzGJhiM2GycODKc/CejnzTcpisTBu3DhGjRqJ2Wym4XuBdGhaiypli6T4VMKTeCOrth9g7m9/cvLKbYpqNczQaKkh0VprpN1OgMlE7SZNWPHbb5JoUJAX0dHRFCtcmMDoaDbp9ZJNtz0URb42mVhkseDtoadlw+p0aFqTwnn9U1zLnftRLNywm4Ub/uHO/UfUrVOHkOnTKVCgQIpryZ49Oz179nxnJJfkklg74nQDaLPZ+OGHH1iyZAl3797F39+ftm3b8v333yfqZnS2AXyu6ZdffuGnH38kOjaW+jod3dVqPlCrUTvwgJyz25luNrNAFIm12ShdqhQZM2Xir7/+core1xEdHc2iRYsImfYr585foGj+nHRo+h6fflCFdF4eLmsX4OyVW8xds5MVm/cQZzTTUKuhu0ZLbbUalcTz+XPNZjqaTJw/f55ChQpJqkVBeiZOnMigAQO47OFBThmMNK7Z7cyyWJhtt3HfaqN62SJ0aFGbBtXLonXhi6Moiuw5fJa5a3ayeXcEBoOBL774km7duqXoiO+/7N+/H39/f/LmzetQ+Z49e6LVavnll1/eepxkBvCnn35i4sSJLFy4kICAAMLDw2nXrh2jRo1KVCoNVxjA58THx7Ny5UqmTZ5MxLFj5NBqqSKKBKpUBKrVlFOryfCfDt0iipy024mw2Yiw2wkXBMLNZjJnyEDHLl3o3Lkzs2fPZuXKlVy6dMmpel+HKIrs2rWLkJBprF+/AYNOS7M6FagWWIyggALkzZEl2W+9JrOFE+evc+jUJbbsCmfv0fNk1ajppFLTWat12QYXRzCKIjmMRtr27s2ECROklqMgIXa7nSIFClD+1i2WOTFruDMwiSJrrVZCbFb2Wqxky5COzz6sSnDpQgQFFCBLxuT3dTFP4jly+gqHTl5i9Z9hnLtyi2JFi9K9Rw++/PJLfH19nfBLpKVBgwZ4eHiwZs2atx4nmQH86KOPyJYtG3Pnzn3xWbNmzfDw8GDJkiXvLO9KA/hvDh06xPLlywkPC+PwkSPEJSQA4KVWY1CpUPO0c42z2bCJIiqViqIFChAYHEzdunVp3rw5hmcP2aBBg1izZk2Kx6y8desWs2fPZumSxVy8dBmATBnSEVQ8H0EBBShWIAd+mTOQLbMv2TL5vvLG+TgugciHMdy5H8Wte484cuYqEaevcPzcNcwWCypBoLpGTRe1hqYaDToZ7d76N98Yjczx8ODmnTuyCtukkLL88ccf1KtXjz0eHlSVaFo+MRyz2RhtNrNGtGN9lhEmj39WggLyERiQn4K5s5M9c3qyZ0pP5gw+L62ZiaJIdGwcdx5EE/kgmqu37xNx+jLhp65w7sotRFEkXTof6tatS/fuPXjvvfdktesyudSvXx8fH593bn5LrB1x+l1SuXJlZs2axfnz5ylcuDDHjh1j7969TJw48bXHm0wmTKb/LxLHxsY6W9JrKV++POXLlweeTpGeP3+ew4cPc+/ePYxGIzabDYPBgLe3NyVLlqRMmTJ4eb3ev0eqhd0cOXLwww8/8MMPP/DgwQMOHjxIaGgoYaGhTPvtL6KjY1463sOgR6NWIYpP/X/M/3ETKZA/H8GVKtPok9YMGzaMSVotvfT6lPxJDtFVp2N8bOwzP8p2UstRkIiQX3+llE5HFZlnDymtVrPCw4P6RiN3ihbj2yFDCAsLIyw0lOHT177UH6pUKgx6LWqVCrtdxGSxvOQapVKpKFWyBDXqfMjA4GAqVqxIkSJFZLXRxJk4u691ugEcNGgQsbGxFC1aFLVajc1mY9SoUbRq1eq1x48ePZrhw4c7W0aSUKvVFCtWjGLFijlUXg6+LZkzZ6ZBgwY0aNDghaYHDx5w+/Ztbt++zZ07d4iLi8NisaBSqdBoNGTKlAl/f3/8/Pzw9/fHx8cHgJCQENRAW51Owl+UePKrVNTUalmzerViANMoRqORLVu3Mk6jkfxZTCwd1Go+OXWKKlWq8OmnT9OiWSwWIiMjXzyzd+7cwWQyYbVaUavVaLVasmXL9uK59fPzezETlRZwdl/rdAP422+/sXTpUpYtW0ZAQABHjx6lb9+++Pv706ZNm1eOHzx4MP3793/x/9jY2BQPwLpjxw58fHyoWLGiQ+UrVar0wnjIBZVKRdasWcmaNStlypRJUtmIiAhK6nT4uElHAlBJEJh78KDUMhQk4sSJE1htNiq7wYzFcyo9G6lGRESQM2dOALRaLTlz5nzx/9TGqlWrKFWqlMNuYg0bNnwpqUBycfoaYK5cuRg0aBA9evR48dnIkSNZsmRJojJ9p9Qa4L+pUqUKRYoUYd68eSnSntwpHRBAhQsXmO1Gb5brLBaaGo3cunULf/+U32quIC3Tp0+nd48ePPbywuAmL26iKJLdZKLzwIEuDw0mF7y8vBg9enSiNkQmB8lCocXHx78yR6tWq2Wdy01uzplSkpCQwKmzZwlys/MR+K+3aYW0R0REBCV0OrcxfvA0JVogEHHokNRSUgy59bVOV9KwYUNGjRrFli1buHr1KuvWrWPixIk0adLE2U05DbldFCk5deoUNrudcjLfSPBfcgkCmbVaDh8+LLUUBQk4Gh5OORm/ZL+JcoLAkTT00ia3vtbpa4BTp05lyJAhdO/enXv37uHv70+XLl0YOnSos5tyGnK7KFLy6NEjALK50Zs0PH2bzqpSERUVJbUUBQl49PCh292z8PQ5i4qJefeBqQS59bVON4A+Pj5MmjSJSZMmObtql5HcnUXPy7vL7rO3YTQaAXBtbBnX4MH/9SukLYxGo9vesyaLBVEUU0X/8S7k1tfK11s0Bdm9e3ey3kq6du3K0aNHOZgKdiHKLDRsknF3/QqO4e7XPa0YwEePHiXLbSM4OJgyZcowa9Ysp+hRDCAke1ut3Ib1ycHD4+l7tDuOo4z8X79C2sLDwwPj48dSy0gyRkCv1aaa/uNdJDccm7P72rRx1l1MajKAz2/Q+274Rv3Abk8x1xkFeeHr6+ue96woks6Jfm2pHcUAypDUZABLlCiBSqXiiAvzJ7qC23Y7kRZLkp3+FVIHpYOCOOKGU4iHRZEy5cpJLcNtUAygDElNBtDLy4uiBQoQ4WZbyp/rDQwMlFiJghQEBgZy3GrF7GajwAgg8FlMYoV3oxhAFzBu3Di2bt3qcPl27doxYMAAJyqSlsDgYCLc7G06wmYjc/r05M6dW2opChIQGBiI2W7nlBu9uN2127ltsaSZlzaLxcLAgQM5evSow3UMHTr0RdxUZ6BsggFmzZpFs2bNXgSSTio1a9Z0siJpCQwM5LelS0nQ6fBwE0MYJooEli//0k66+Ph47ty5w+3bt7l37x4mkwmbzYZGo0Gv15MtW7YXAYWVzTPyICEh4cU1i4yMxGw2vwgE/d9r9u/UV2XKlEGlUhFqs1HWTYI4hD1bZkgrBtBsNjN27FjKlCnj8FJF8+bNnapJMYCkrilMZ/DRRx/Rt29fVlqttNVqpZbzTm7Z7fxptdKlUCGGDx9OWGgohw4d4sHDh4muI2uWLJQvX57gSpUIDg6mfPnysk8gGhkZyZEjR3j48CEJCQmIoojBYCBdunSUKlWKvHnzynprfXR0NIcOHXqRwuvgwYPcf/Ag0eUzZ8r04ppVrFiRGtWqsfDAAbq5ULMzWWizEVCkiMPZ0d2N5+Ew5dTXKgYQxQD+lwIFClC/Th1Cdu+mrdRiEsFsiwVEkZCQEDKk8yYoID8dGlclf85sTxOLZk5P1ozp0D/Lq2az2zGaLNx7FMPd+9HcfRjNpRuRRJy6woRxu4mOjUMQBIoVLULDRh/TpUsX8uXLJ/XP5OzZs6xevZrwQ4eICAvjZmTkS98LwL9XwDKkS0dgUBCB5cvToEEDqlWrJrlBvHz5MjNmzGDzpo2cOXsOgPTpvAgsnp92H1chf86sL5I4Z83o+yIXns1ux2SycO9RLHcfRHP3QTSXb0YScfoKkyaMIyr2yYs2IjSaF7Fh5cpNu50NViu/9ukj+TVJKeRoAJ2eDSK5SJENIk+ePLRp04YRI0akSHvuwKZNm2jUqBGHPD0JknFnYhFFcsXHU6RcEX75pg35c2VLdqSJi9fvcujkJQ6euMiGneHEPImnwQcf0K17d+rXr486Bc+HxWJh48aNhEydys7du/HVaCgvCAQKAoEqFYFqNX6CgJ6nBtAMPBJFjtjtRNhsRIgih4DbFgsBRYrQvXdvvvjiixR1F7HZbPz++++ETJvGtu3b8fX25ONaQVQsVYjyJQpQIFe2ZHWKoihy6UYkoccv8O34xTS3icyVeSaToSYTv6jV3I6MlF0qNVcRFRVFxowZWb16Nc2aNXNpW4m1I4oBBKpWrUrz5s3p27evQ+UvXrwIQMGCBZ2oSlpsNhv5c+fmvfv3WSjjzmSlxcJnRiP7lvxIQEHn55GMN5pY/Ucoc9bs4vi5q+TNk4eu3brRvn17smTJ4vT2nmO325kxYwajhg/n9r17VNHp6K5S0UyjQZ9EAy+KIjttNkKsVjZYrXgYDHTt0YMffvgBLy8vF/0CuHfvHvPmzWPG9Olcu36dMsXy0bFZLZrWroCnwTV5+8bP38iE2eu47uFJZhmNNP5NgiiS32SiaadOTJs2TWo5KUZ0dDTlypUjJCSE+vXrO1THiRMnyJgxIzly5HjrcYoBTEEaN26M1Wpl8+bNUktxKr/++iu9evVit4cH1TXymy2PFkVKGBMICCrGb5O+dmlboigSceoyc9buZN2Og4gIdOrUiZ9++snp9+nly5dp36YNu/fupa1WSz+tllJOGnXetNuZYbEwwWolR65czF+8mGrVqjml7ufExMQwePBg5s6di4BIszoV6disFuWK53dqO6/j/qNYyjf/hgYWG0tl+uI2wGhkKnDi1CkKFSoktRy3Il++fLRq1YqRI0e+9TjJ8gGmRVLrGmL37t2pWqkS7axW4uT1ngRAf5OJx1oNEwe3c3lbgiAQVKIAM4Z24vTGiQxs35D58+YQULw4W7ZscUobdrudadOmUapECa6FhfGXhwfzDQanGT+AnCoVI/V6jnl4kO3OHWrUqEHfvn2Ji4tzSv0bN24koHhxFi2Yz6AOjTiz6RdChnRMEeMHkCVjOn4e8CXLLBbWWywp0mZSOGCzMdFqZcTIkYrxcwDFD1CGpFYDqFKpmL9oEXdUKgabTFLLeYnfrVbmWyyM7Pc5ObNlStG2M6X34au2DTmwdCSFc2bko48+4vPPW3L//n2H67RYLLRp3ZqePXvS2mrlhF5PLReOugurVPyj0zFep2Pm1Km8V60aD5KwA/O/REZG8umnn/Dxxx9TPE9mQpePon+bj8jom/Jhvj6tX5n6VUrT1WrhoYxe3BJEkXYWC0HlytG/f3+p5bglyc0m8V9SX68tAaIopkoDCE/XNUePGcNUi4XNVqvUcoCn03gdLWberxDAlw2rS6Yjj38W1kzqz4xhndi2dQvFihZlw4YNSa7HbDbTvGlTVi5fzgqDgRCDAe8U2BmoFgT663TsNxi4duIENapU4e7du0muZ926dRQrVpQdf2xj1g+d+W1iP3JlT9mXkn8jCAKTBrfDpNPSwWTEJgMjKIoi/UwmrgILFi9GI8MlBXdAGQHKkNQ6AnxOr169aNyoES1MJv6R2Ajet9upYzKhyZCOX4d0lHwLuSAIfPZBFQ4uH0VwyXw0btyYkSNHJjo9j81m44vPP2fb1q1s0Ov5VAK/y7JqNXv1emKuXKFurVqJTipst9v54YcfaNq0KVVLF+Tg8lF8Ur+y5NcEIHvm9Ewf3oXNNhudTSbJ0yUNNZuZabHwa0gIxYoVk1SLO6MYQBfQtGlTVq1a5XD5yZMnM3r0aCcqkhcqlYrlK1dSpXp1GpjN7JTICN6x26llNvHQy8C6aQPxy5JBEh2vI0vGdCwe3YNBHRszZMgQPv30k0Stqw0YMIC1a9eyUqfjAwlHBYVVKv7Qarl94QIff/QRtncEQ4+Li+OTFi0YPnw433dpyqLRPcicQV6b1j6oVpZpQzoyz2Khk8kkyUhQFEWGmEyMNJsZM2YMHTt2THENcuHevXvUrVuXw4cPO1zH77//Tvv27Z2mSTGAwF9//cX169cdLl+4cOFUv6BtMBjYsHkzVWrWpIHJxNJnWaxTihM2G9VMJh75eLF5xrcUyJ09xdpOLCqVikEdG7NodE+2bt5Mvbp1iY2NfePxu3fv5pdffmGsTkdjGUTcKa5Ws06rZe/+/UyaNOmNx8XExFCndm22b/udpWN783W7RrIY9b2Ozz6owvShnZhvtfKpyUh0Ct6zCaJIt38Zv2+++SbF2pYj8fHx/Pnnn4meYXgdZcqUeacLRFJQDCCpfwrTWXh5ebFx82aaf/opXxiNNDeZiHRx8GGLKDLKZCIwIQFdjiz8Pud7iuTzd2mbyaVRzSDWT/2akyeOUbdOndcawbi4ONq3bk1VnY6+MjB+z6mm0dBHq+X7b7/l3Llzr3z/3PidOXWCjb8O4MPq8k/l07JBFRb93JM/1CpKGBP4PQVmMA7YbJQ1mVgAzJ49O80bP5BnJBj5KJEQxQAmHr1ez5Jly/jtt9/4x9ubAJOJFS4aDZ6w2Qg2GRlmtdC79Yf8vXgEefxd53zuTMqXKMiGqQM4e+YUDT74gPj4+Je+Hzx4MHdu3WKeVotKZqOnUXo9uUSRdq1bvzQVGhcXR4MPPuDCuTNs+PWbFHNtcAYf1Qhk/4rRFC5TmAYJCbQ3umY0mCCKDDAaqZqQgG+pUhw5dixNT3v+m+cGUE6zBUqvT+rexekqWrRowelz56j18ce0NBoJMpuZazYTn8xOxS6K7LBaaWI0UiY+ngT/LOyYO5Qh3Zqj18lnpJQYyhTNy+pf+nHkSATt27d78ZJw4sQJpk6dyk8aDYVkeN95CgLzNRpCDx5k4cKFwNNnpG2bNhw7eoQ1k76idJE8EqtMOrmyZ2Lt1G+YPKgtq9UC+RLi6W80ct4Jsxg37HaGmEzkM5mYCvw8Zgz7QkOVDS//QhkBypRGjRpRoEABh8tv2rSJ3bt3O1GRe5AlSxZ+W72abdu24ff++3Qym8lhNNLPaGSP1cqTRBpDqyhy3GZjotlMMZOROgkJXMiRhXEDWvP34hGULSZ9IGpHKV+iICHfd2Dlyt/4+eefAQgJCcFPq6WHjKY+/0sVjYYPtVp+nTQJURQZOXIkq9esYcawTgQGuM/I778IgkCbxu8R+tvPtGlZn4V6LUXi4qhrTGCFxcI1uz3Rsxl37HbWWyw0MRrJGx/PZI2GFl26cOLUKQYMGKC4OvwHLy8vmjRpQubMmR2uY+HChZw8edJpmpRQaE6gSpUqFC5cmPnz50stRVKuXLnCzJkzmTtrFg+iohCAIno9gTYbJVQqvAUBA2ABEoBLdjsRwDGbFaNdRKtW8XGt8nRo9j7BpQvJaqokufw0ex3j5m1k+fLldGzXjq9sNn7QuyYeprP43WqlQUICY8aMYeDAgXzbuQnftP9YallOxWgys37nIeat2sHB01cAyKxRU46nwcazCQLPM0UagQeiyBFRJAK48yzSTMlixejRpw+tWrXC2zvlHf/TEt7e3owaNYo+ffq89TglFmgKUqlSJYoXL87cuXOlliILrFYrp0+fJiIigvDwcCLCwjh77hwJRiNmqxUV4KnX4Z8lPWVKFKBM0byUKZqXUoXz4O0pz/iNycVut/P5wKnsP3qBJ4+fcN3Lixwymgp6HXZRpKDJxG1BoHalkiz5uWeqein5L3cfRHP07FWOnLnC0TNXOXHmCvdiHmO1P+0iDTodvj4+lClXjsDy5QkMDCQoKIhcuXKl6vMiJzw9PRkzZgy9evV663GJtSPKGN0JKJtoXkaj0VCqVClKlSpFu3b/j9PZtEkT9v6zi4PLR5FBghBZUqJSqZg8qA1BLQaRS6WSvfEDUAkC3VQqBplM/Njzk1TfyWfPnJ76VctQv2qZF589inlC+U+/peb7dVi1erV04hQAxRFeligG8N2sXbuWdevXM+6rVmnO+D0nW6b0jOrbkmt2O3/IJKzcu2ioVmMHbtx9KLUUScjo682Y/p+zes0ah8LcKTgXxQDKEMUAvp2oqCh6dO/OB9XK8nGt8lLLkZQvG1anetkidLGYE71JSEoKq1R4q1QcPXtVaimS0axORepVKU33bt2IiYmRWk6aRgmG7WSsVitZsmRhxYoVDtdx8OBBfv31VyeqSl0MHDiQ+LjHTBjQOtVPo70LQRCY/F0H7goCP8gsw8brUAkCZdVqjp69IrUUyRAEgQnftCY2JprBgwdLLcdtOXr0KFmyZEnWLk6j0UinTp2cpinNG0C73c6DBw8wm80O16FWq1E7MWdbauLu3bssWLCAAe0a4p9VPrE7pSRfzqz0+rIB0222FA3N5SiBwJGTl6SWISk5s2Xiq7YfMnfu3GSlvUrLWCwWHjx48MIf0BE0Go1T+1rFAMrQOTM1MXfuXDRqlaRpi+RI+yY1MQOLZJi09b8UV6m4GvkoWR1XaqDNx+8hIDJv3jyppbglcuxr5aNEIuR4UVILVquVmTNm0LxORdKn85Jajqzwy5KBj2qUI8RmkzxVz7vwejZtbTTL31i7koy+3jStXZEZ06e/M1uGwqvIsa+VjxKJkONFSS1s2bKFGzdv0qFZLamlyJIOzd/nnNXKLpl3ps/d9c1m99i56ko6NqvF1WvX2LZtm9RS3I7nLw1y6mvlo0QitFotI0aMoGTJkg7XMWLECNatW+dEVamDkGnTCCpRkDJF80otRZZULVeUIrmyMV3m06DPV8e1WsVtuFzxfJQplo+QadOkluJ25M6dmxEjRjgcCs1sNtOjRw8OHTrkNE1p3gDq9XqGDBlCQECAw3UsXryY0NBQJ6pyfy5cuMAff/5Jh6Y1pZYiWwRBoMMndVhns3JbxutrCc/+NbhZMHJXIAgCHZrW5Pdt27h8+bLUctyK3LlzM2TIEIcNoMViISQkhIsXLzpNU5o3gM5AySbxKjNmzCCDrw9N3k/bfn/v4tMPKmPQaZkt41HgObudHBl9UauVexye+gX6ensyc+ZMqaWkKZ6vlSuO8DJDcYR/la1bNtO4ViAGvU5qKbLG19uTBjUC2SrjjTARop0yJdw3A4Sz8TToaVQzkK1bNkstJU3hiv0aSq/tBBQD+DJRUVGcPXeeCiULSS3FLShfsiBHrFaMMjSCoihy2C5Spqj7pqRyBeVLFuTU6TPExsZKLSXNoBhAF2Cz2bh58yZGo9HhOgoXLky2bNmcqMq9eb5IXb6E4zkW0xLlSxTAIoockeE64BVRJMpmUzYy/YfyJQogiqJTN2SkdhISErh586bDLiSCIFCiRAl8fX2dpinNG8DIyEhy5crFzp07Ha7jjz/+oGfPnk5U5d6EhoaSIZ03BXIpLwWJIaBgLgxaDWEydIfYZrU+DYdWLK/UUmRF4Tx+pPP2JCwsTGopbsOuXbvIlSsXkZGRDpX39fXlxIkT1K5d22ma0rwBVPwAnU9YaCjliudL83E/E4tOq6F04dyEyswAiqLIdLuNBtXKkjmDe+TmTClUKhXliucjNPSA1FLcBjn2tfJRIhGu2FmU1jl06BCBAcqmiaQQWLIQh2T2vrDXZuOkxUrH5u9LLUWWBBXPz6GDB6WW4TbIsa+VjxKJkONbiTuTkJDA/QcPyJcjq9RS3Ip8ObNww2rDLqONMCFWKwVzZKF6UDGppciSvDmzcjfyHiY3yOohB+TY18pHiUTI8aK4M3fu3AHAL3N6aYW4GdkzZ8AiijyUiQE8ZbOx2mqlfYvayrPxBp7f43fv3pVWiJsgx75WPkokIlu2bGzatIlSpUo5XEf9+vVZunSpE1W5L88NYDbFACaJ7Jmf7my7IwMDaBVF2lrMFMyVjfZNlEg+byJbpvTA/+95hbcTHBzMpk2b8Pb2dqj83bt3qVKlCgedOO2c5g2gp6cnH330kcPheeDprkflIXjK8x1eWTMqmyaSQpaMTw1gpAwM4FizmcNWG9OGdVYCGbyF5/e4o7sa0xp+fn589NFH6HSO3VNGo5H9+/c71fcyzRtAZ6A4wv+f5+sheiVuZJJ4HmfT8bTMzuGkzcYPFgt9vmygbGR6B3r9s2uWjGTaColHcYSXKYoB/D/PnVzVyvlIEs/Pl1XCEeAtu52GZhMFc2dnYIePJdPhLjy/ZkpuwJRBMYAyRQmG/X80mqcpc2wyjGoiZ56fL41EvpORdjt1TSas6X34bfLXytRnInhxzTRKmqiUQAmG7QJiY2PZtGkTUVFRDtfRsmVLihYt6kRV7ote/zR9qtGkTAslhefZ1s9KMJq4ZrcTHB/PfS8D66YNJFf2TCmuwR0xmZ5eM0fXtNIaN27cYNOmTS9GcknF29ubL7/80qlhJ9O8Abxy5QqNGjVKVo6pOXPmULduXSeqcl+e35yRD2MkVuJe3Ht2vgZZLPxsMqXYVOgai4XyJhM3RZGJg9tRKI9firSbGoh89PSaZc+eXWIl7sHOnTtp1KiRw1PGfn5+LFq0iCJFijhNU5o3gHL0TXFn/P39AcUAJpU795/OQHTv1YvvLBYqm82cduFo8L7dzqdGI82NRsrXro0VUKlkFopG5ty9Hw087ZgV3o0c+1r5KJEIOV4Ud+b52/DdB9HSCnEzIh/GoNPpmDRpEvsPHOBx7tyUNRoZZjIR6cT11DhRZJbZTIDJxA5PT5YvX87GzZvRaDREKtcsSdx9GA2gZIJJJHLsa+WjRCLkeFHcGYPBQPZsWbl8Q/GNSgqXbkSSO1dOBEGgYsWKHDlxgn4DBjBOEMiVkMDnRiN7rdYXGwGSynm7nX5GIzmMRrqazdRs3JjT587x2WefoVaryZ0rJ5eUa5YkLt+IxN8vu7IGmEie97VyCpKf5nt9OQZodXfKV6hA+OnLUstwKyJOX6FicKUX/zcYDPz888/cunOHMePHE54zJ9USEihmNtM+IYEQs5kwm42E1xhEqyhy0mZjocVCb6ORYJOJInFxLPH2ptvXX3Pp0iVWrlr10silfIWKRJy+kiK/NbUQfuoKFYODpZbhNshxt7y81EhAmTJluHnzpsO7OG02G56enixevNjJytyX4OBKHD59xeHdXmkNk9nC8XPXqFix4ivfZciQgX79+nH24kX++OMPqrdpw7HixelrsxEcH49PXBxZjEZymUzkMZnIajTiHR9Pyfh42hqN/JErFwWaN2fx4sXcvHOH0aNHky/fq9ndg4ODOXr2KharNSV+sttjs9k5cuYKFSsqBjCxtGrVimvXrjlc/vDhw3h6enLs2DGnaUrzDiw6nY4cOXI4XN5ut5OQkKB09v+iYsWKxD6J5/y1OxTN5/i5TSucOH8ds8VC8FtGEyqVijp16lCnTh3gacSdEydOcPjwYR4+fPjiHvTw8MDHx4fSpUtTtmxZ0qVLXEi6ihUrYjSZOXXxppL9PRGcvXKLJ/EJb71mCi/j5eWFl5eXw+VtNhsJCQlOVKQYwGTzfEuv3Ib2UlK+fHkEQSD81GXFACaCQ6cuodfrKV26dKLL6PV6goKCCAoKcoqGsmXLotVqOXTyomIAE0H4yUuoVCoCAwOllpJmcMV+DcUAJpPnF0WtVkusRD6kS5eO4sWKEnbsAl98VM0lbZgtVs5cvsXRM1c4eu4qp89dJ/ZxHEazFUEAD72OTBnTUapYPsoUzUuZonnJnzOrLF9Uwo5foFzZspJupjAYDJQpXYqw4xfp1Ly2ZDoc5Um8kRPnr3P03FWOnLnChUu3iE8wYrJY0ahVeOh1+PtlpnSxfJQp8vR+8MuS3uENGaHHL1CyRIDDmQ0Uko4r+lrFACYTZRfp62nY6GOmT5vKz/1b4eWhd0qdNpudHaHHmbvqL/4OP43ZakMFFNdqKSOKZBQEDIKAKIokAHdu3WfzyUv8anm6rpXOQ0+j9yvQsfn7shnlRMU8YdveYwwZOkxqKTRs9DE/jx5F9OM40vs4PlWVUsQbTazdcZD5q3Zw+Pw1RBH0gkBpjYZygA9P/299dj9cvnmP+QdPcd/6dNbGP2M6PmtYnbaN3yO3X+KzwTyOS2Dz7sP07tvfJb9L4fW4oq8VREf3VbuI2NhYfH19iYmJSfT6RXK4cuUKS5YsoVevXqRPnz7J5c1mM7/++isffvihUyMUuDtXr14lf/78TB7UltYf10hWXQ+jH7N44z/MW72D6/eiKKfV8KVKTQW1mtIqFV7veIt/KIpE2Gzss9mYb7dxw2ojsGheOrSoTdPaFSSNe/nrsm0Mn76GmzdvkjVrVsl0wNO8drlz52Zkr0/p+mkdSbW8jcs3Ipm7difLNu4mOs5Ifa2WZioVQWo1xVUqtG+5H0RR5Oaz++Evm41FdhuP7XbqVSpNxxbv835wyXeOCuet3cnX45dw9epVcuXK5eyfl2o5cOAAe/bs4ZtvvnGo/K1bt1i5ciVt27YlY8aMbz02sXbEJQbw1q1bDBw4kN9//534+HgKFizI/PnzE7VekdIG8M8//6Ru3bpcvXqVPHnyuLy9tETDjz7i2oVT/LNwmENTTaIosnLbfgaNW0yC0cRnag3dtVrKq1QOT11ZRZGtNhshVivbLRYK5czKtGGdqVCyoEP1JQe73U7Qp98SXK0mS5cuS/H2X8enn37CkbB9HFwxSlb+WvB02nv8gk1MnL+JdIJAB5WKLjodBZIxIogTRZZbLEyz2zhqsVKjXFGmDun4xhGhKIpU/XIYhQLKsm79eofbTYuMHz+ekSNHEh0d7fK2EmtHnD5vFxUVRZUqVdBqtfz++++cPn2aCRMmkCFDBmc35RSUKUzX0b1HD06cv0r4qUtJLnv3QTQtv55E1+GzaWCxccPDkwUGAxXU6mR1zBpBoJFGwzaDgZOenmSMfET9zqMYMnUFCcaUDeD996HTXL5xl+7de6Rou2+je/ceXLh2m38izkgt5SWOn7/G+22GMXHeRr7VaLjp4cFYgyFZxg/ASxDoqNNxWG/gdw8PLh+/QOXPvmX+ul2vDToQeuwCpy5ep3sP+Vwzd8Fut8tur4TTe/0xY8aQK1cu5s+fT4UKFciXLx9169alQIECzm7KKSgG0HXUq1ePfHnzMmfNziSV27w7guBPBnEk7CTrDAaWGgxkccH1CVCr2ac38LNOx6zl26n+xfecvnTT6e28iTlrdlKqZEkqV66cYm2+i+rVq1O8WDHmrtkltRTg6Yhr4sLN1Go7HOFGJAc9PBiu1+Ph5NGpIAjU12g4afCgpV2k35iFNOk5lkcxT146bu7anRQqWJD333/fqe2nBeSYN9XpajZu3EhQUBAtWrQga9aslC1bltmzZ7/xeJPJRGxs7Et/KYliAF2HSqWiW/furNtxiIfRjxNVZvGmf2g96FdqWaycMnjQWOvazPJqQWCATscRgwcekY9o0HkU4SeTPmJNKjfuPmTb3qN079FDVlONgiDQvUcPtvwTwe17jqcIcwZ2u51vJixhxPTVfKPRcEhvoKyLRxDpBIFZBgN/eHhw6th5GnQa+eI83HsYw4Zd4XTr3l3pLxwgTRjAy5cvM336dAoVKsT27dvp1q0bvXv3ZuHCha89fvTo0fj6+r74S+lFZa1WS5YsWRwemlutVs6dO8eTJ0/efXAapF27dggqFfPWvntEsXD93/QaNY9OGg2/6Q1kSkHDUEytZrfeQIDZwsc9fna5EZyz+i+8vDxp1aqVS9txhC+//BIPDw/mrvlLMg2iKNJ/zELmrP6LmXo9o/R6dCl4P9TRaNijN/Dk9n0+7DyKuw+imbduFxqNhrZt26aYjtSEh4cHmTMnfrftf3ny5Annzp3DYrE4TZPTN8HodDqCgoLYv3//i8969+7NoUOHOHDgwCvHm0wmTCbTi//HxsaSK1euFNsEk1zu3LmDv78/W7ZsoUGDBlLLkSV9+/Zl9qwZ7F86krz+WV57zLodB2n/fQjdtFp+1euTPSr6926/CLudYzYbMYBRFBEAgyCQSRAoq1IRqFYTqFKRVaUiThSpZzJySqdl66zvKF4gZ7J0vI6zV25RrfUwvvlmICNHjnR6/c7g22+/ZeKE8exdPEKSHIHDfv2NyUu2Mt9goK0TZgHsosgFUSTcZiPCZuO03U48T+8HDU/vB39BeHEvlFWr8REErtjtVDMZ8ciWiZsPouneoycTJkxIth6FpPP777/ToEEDbt68+c7oXZJtgvHz86N48eIvfVasWDGuX7/+2uP1ej3p0qV76c+dkGOEc7nx448/kilTFvqNWfjajQWXb0TSffgsWmq1TE2m8Yuw2ehgNJI9Lo7ccXE0MRqZbbFgAXIJAiXVagLUanIIAtGiyASzmQYJCWSLiyP3kycMMZmYpNWR22yh7cCpTs9sb7PZ6f3TAvLlzcf333/v1LqdyZAhQ8iVKze9f1qQ4mH+Nu+OYPKSrUzU65Nl/GyiyFarlUbx8aR/8oSicXF8YTSy3mrFIAjkFQRKq9UUVanIJghcstv51mSiRkICvk+eEBAXx0qLhZVaHfdu30et1jBixAgn/lKFpOAWkWCqVKnCuXPnXvrs/PnzqdbFQFlDfDc+Pj7MnDWLBg0asHzrPj7/sOqL7+x2Oz1GzMZPhFkGPSoHjF+CKPKb1UqI2cxBu53cgkBHrZaKz97m/QXhjUZVFEUuPxsp7rfZWGy18ovFQmWVitM3Ixk5Yw0j+7R0+Lf/l7lrd3LwxAV2796NwWBwWr3OxsPDg1mzZ1OrVi0WrP+b9k1rpUi7j2Ke0P+n+TTUaunroPF7YLczz2JhhsXCFVGkrErFtzodQWo15dRqMr7lHrOKImfsdiLsdnZZrQw3m7ED5VUq9sXHs3XrVlq0aOHgr1NIDq7I3OP0Xrtfv36Ehoby008/cfHiRZYtW8asWbPokUq3DSsGMHF88MEHtGr1Od9NXsG9f2WLn7lqBwdOXGSuVvtOh/bXscNqpWhcHG2NRjIKAhs9PLjs5cUovZ5GGg053uEzKAgCBVQqPtFqmWQwcMPLi8UGAyJgBWYs387yrXsd+MWvcuPuQ0ZMX0OXLl2oXr26U+p0JTVr1qRDhw4Mm7aKW/cepUibA8cvwfwknhk6XZJnAkRRZKbZTL64OIaazVRTqwn19CTC05NBej21NZq3Gj946iZTUq2mrVbLQg8Pbnl785Nez91nnW/rVq04efKkw79PwXFc0dc6vdcuX74869atY/ny5ZQoUYIff/yRSZMmyXKx3xkoBjDxTJo0GbVWT5+fn06rXbl5jxG//kZPrZb3NEmbjHgsinQ1GqmTkEABlYqzXl787ulJQ40GdTKmUA2CwBdaLfu9vAj19KSISkWPEXMYOWMNZovjqYKsVhs9R83DN30Gxo4d63A9Kc348ePx9vGl16j52GyunQrd+s8RVv0ZyhStDv8kPk/X7HbqJiTQ1WTiM62Wm15eLPTwoGIy/UYzCgJf6XSc9/LiN4MBL6uV8mXLsmTJEoeTEys4hlsYQICPPvqIEydOYDQaOXPmDJ06dXJFM05hz549NG3aFKPR6FD57Nmzs3PnTsqWLetkZamPzJkzM2/+fLbtPcrPczfw67Jt+IoiP+uTFit0v81Gybg4llgshOj17PDwoIgLXkAqqtUc9vTke52OSQs28X6bYVy4dsehuob++ht7D59l4aJFbrXOnT59ehYuWsTfh04xPGSVy9oRRZExs9byvlbDF0l8GVpksVAiLo5zdjvbPTyYbTCQ2cn3g0oQaKHVcs7Li8Y83SnbuFGjFIlqklpYvHhxsmYCq1Spws6dO536/KT5YcuNGzdYt26dw29zHh4e1KxZ852x6RSe0rBhQ0aOHMnYuRtYtukfOqvUSZr63Gq18n58PDlVKk54edFNp3No3TCx6ASB4Xo9Bz09sVyPpH7HHzl69mqS6li6eQ8hK7bzyy+/uKUDdZ06dZgwYQJTlv7Oyt/3v7uAAxw+fYVjF2/QT6NN0ohtjMlEG6ORZhoNJ7y8qJtE45lUMgkCyz08WGcwsGfbNmpWr05kZKRL20wtnDhxgj///NPh8lmyZKFmzZponegbnOYNoLKLM+UZPHgw5cqVw2Sx0ikJN/Nmq5WPExKop9Gww8ODfCk47VxWrWavwUB+o5lG3UYn2gjuDj9NvzGL6NChAz179nStSBfSp08f2rZtS+/R89njgjBpc9b8RV6NhvpJ8Mf90WRikNnMEJ2O+QYDvin4DDfWavlHp+Pu2bPUqFKFe/fupVjb7kqacIR3N5Q1PGlIePKERhoNORN53v+2WmmekEBDjYZVBgMGCV5YMgkCf+kNFLXaaNZrLOeu3H7r8fuOnKPlgMnUrFmTkJAQt37JEgSBGTNmUL16DT77ejKhxy44re5HMU9Y+0coXVWqRK/fTjWbGWo286NOxwgn+I06Qgm1mn90OqKvXaNe7drExMS8u1AaRhRF2fWz8lIjAYoBTHnOnj3LmfPnEz36i7TbaW40UlWtZrnB8NZ0N67GRxD4XW8ge4KZ1t9MfqOf4O5Dp2nRfyLBwZVZt369pMlunYVer2f9hg2Ur1CRZn0nOC1g9ra9RzFZbbRL5P2wz2qlj8lEf62W7yQ+r4VUKv7U6bh65gxdu3SRVIvcUUaAMsTPz486deo4fGGio6NZsWIFDx8+dLKy1Et4eDgAlRMx3SWKIt1NJgRgmcGAXgajqIyCwEqdjis37/HznPWvfL9k8x5a9P+F6tXfY/OWLXh4eKS8SBfh6enJlq1bqVylKi36TWT51n3JrvPImSsU1mrJmohnMF4UaWc0UlGlYqxEI7//UlKtZppGw4qVK1m7dq3UcmRL4cKFqVKlisPlr1y5wooVK7DZbE7TlOYNYL169fjjjz8cNoDXr1+nZcuWXL582cnKUi8REREU1OlIn4jO6zerlbVWKyF6faI6yJQiQK3mB62WKUt+fxE31Gq1MXjSMnqOnMuXrVuzYePGVGX8nuPp6cmmzZv5vNUXdBsxm++nrEiWi8Sx05cJesMmtFt2O2ssFr4xGqmfkECe+HiuiiLzDYZkubs4m5YaDY21Wrp16sSDBw+kliNLunXrxsyZMx0uv2fPHlq2bKkYQDmhTKEmnYiDBwlMRHite3Y7PUwmmms0tHBxVghHGKDTUVatpsfwWVy8fpemfScwa9VfTJ06ldmzZ6eKac83odfrmTt3LpMnTyZkxR806zeBm5FJnwWxWm2cuHCDwGezAQ/sdiabzTRPSCBnQgI54+JobjSyPJ0nMcXz8dBuZ5ReT1GZ5ZUTBIHpOh3W2Fh6ufFmJznjNn6AaQnFACYNURQ5cvQo5RJxvqZYLJhFkWlJ9BNMKTSCwHydjnM3Iglu+R2Xbkfzxx9/0LNnT1lMzbkaQRDo3bs327dv5/yNRwS3/J7Zq3ckKXboxRt3SbBYMQCtjUZyJsTzjdXK3YB8NP+sLot/7sWZTb9wcstkPHQaSms09JfhyxBAdpWK8c+mQk+fPi21nFSHYgBliGIAk4bZbCYuIeGdkT7Moshsi4XWiVwbkoqSajW11WpEmw29Xs/Ro0d59ChlwobJhdq1a3P6zBk+/+JLBoxfwgddR79zhyxAvNHE8q37UKtU9DCZ+CejD991b8GZLZPYMvM7hvf8hIbvBeKXJQMXr99lV/gZ+iUz0o+raaXRkFWrZfr06VJLSXW4wmVNvj2Lm6D4ESaNhIQEAN4VBnqt1co9UaSbTN/2/00vnQ4bkC+rN4MGDSRHDn/at2/PzZspl11eanx9fZk5cyZ///03j+JFqrUexg/TfuPG3VenRaMfx/H9lBUUa9iPKUt+p1bFEqya2J8j68bT+4sGZErv80qZeWt3kVGt5hMXO7onF50g0EkQWDhvnpIj1MnY7XaEtwS2d4Q0bwAXLFjwSvqmpFCuXDmioqKSVUda4nnEnXfdwiEWCzWepS6SOx+q1eTWaMie2ZfTGybyTbuGbN20nuLFizFjxowUTyckJTVq1ODY8eMM+OYb5q7/h9JNB9Bq4FR2hZ3Ebrez6e8Iglt+x8L1f9Ou8XscWTOWVb/0p07lUm+cRYk3mli2cTcdVCpJ/D+TSmetlriEBJYsWSK1FFnxzTff0KxZM4fLt23b1um77dO8AYyJiXljrsLEoNFoSJ8+PRqZv5nKhecpgN4WefW23c4emy1JUWKkRC0IdFCpWL8jjIy+3vRv8xFhy0fSpGY5unXrxns1arySIiw14+HhwciRI7l16zYhISFcf2iiSZ/x5K7dnS8HTaVssbyErRjNDz0+eWOC5H+zM+wk0fFGOrnJpqLcKhUfaDSsWLpUaimy4v79+9y9e9fh8jqdjgwZMjhRkWIAZemcmZrR6/VoNRoeviX2avizEVN1Nxj9PaeqWk2cycKF60+DZaf38WLKt+3ZOG0gN69eoHTp0owePTpNjQZ9fHzo0qUL/b/6Ch9vb3Q6LfNHdmfZ2D74Z018R3b0zFWya9QUdIPR33OqCgKHDx9OU9f7Xcixr5WXGgmQ40VJzahUKkoWL87Rt/jyRNhsZBEEcrpRh1fumbH+b4zQ6oHF2L/kR7q2eJ/vvvuOxh9/TGxsrAQKUx6LxUK3bt1o164dH1YvTfjK0TSpXSHJazhHz1wh0MlrP64mUK3mcXw8Fy44L2ScuyPHvlZeaiTg+cKqQsoRWLEiEW8Z3UXYbAS+I5Gt3EgvCBTQal4bJNvDoGN4z09YOaEvu//eSeVKlbh06VLKi0xBHjx4QJ3atZk7dw6TB7VlxtBOZPT1TnI9oihy9PQVAgX36qqevxBFRERIrEQ+KAZQhpQvX57evXs7XP7ixYsMHDgwzW19Tw6BgYGcMptJeMM06GG7/YVjtDsRKMKxU2+OCFS3cml2zPke45MoKlQon2o7x6tXr1KxQgVOnTjGhqkDaNP4PYfrun0/igeP49zufsgkCOTV6VLtNXaEjz76iM8++8zh8v/88w/Dhg1zoiLFAPLee+8xfPhwh8tfvXqVsWPHpplpLWcQGBiITRQ5/IZp0Hui6FbTn8/JKQg8ePT2+6BwXn/+mvM9BXJkolatmoSFhaWQupTh8uXLVK9WDbslnr/mfk/lMkWSVd/9Z+fTLe8Hnm78UHhKy5Yt6ZKMgOEHDx5k8uTJTlSkGMBkozjCJ50yZcrgnzUri63WV76ziiI2cIvt7v/FQxAwmS3vPC59Oi/WTvqKgHz+1KtXl8OHD6eAOtdz/fp1ar73HjqVja0hg8iTiB2e7+L5+XyX36gc8RBFjMa37XdWSAqumEJVeu1kohjApKPRaOjcvTtL7HZi/jMN+nxM6F4TXk9RAbZE7vrz8fJg5cS+FMyZhQ/q10+WK44ciI2N5YP69RHsJjb+OiBJuzzfxvPzKefoL29CBU4N3JzWUQygDFEMoGN06tQJoyiy2PLyiEn1zCAa3+ImIVeMoohel3jfxXReHqwc3weDBhp//DHx8fEuVOc6bDYbrT7/nJs3rrFqQl9yZM3otLoNz86nW94PgvDC71Uh+SgG0AUkJCQka/3OYDCQN29exRE+ifj7+9OkSROmiSK2f3VuA8xm1ECUG3Z40YCXZ9I6vMwZ0rF0bC/OnTtD+/btXkTKcSeGDBnClq1bmTOiC4Xz+ju1bu9n59Mt7wdBwNs76TtfUytPnjwhLi7O4fLp0qUjd+7cTlSkGEB++uknSpYs6XD5WrVqceXKFbJmzepEVWmDr77+mnMWC5OfjQI3W61MtljIlT0Tx9zQgfgoULxIniSXK1koN9OHdGTlyt+YM2eO03W5kr/++ovRo0fzQ/cW1K1c2un158uZFb1G7Xb3g0kUOW02J6tvSW20bNmSzz//3OHyPXv2fJFM21mkeQMoR9+UtEJwcDC9e/fmO4uFwzYb3SxmalcIoE7VMoS72ZqPRRQ5brVSpmheh8p/XKs8rT6qxoABX3P79rszKciB+Ph4OnfqRJVyRenVqr5L2tBqNJQokJNwN1tLO2m3YxFFAgMDpZYiG+TY18pLjQTI8aKkJUaNGkWOXLloYDQSpVYxcXA7yhbLx3mLhVg3mvY6ZbdjEkXKFs3ncB2jen+GXqOiR/fubjEVOnToUG7fvsWUQW1d+gyVLVGACJV7vRBF2GyoVSpKl3b+qNhdkWNfKy81EiDHi5KW8PLyot+AAUTa7Qzp/gm5/TK/GEVFuNFb/yGbDZUgULKw42sU6dN5Me6rVqzfsIG1a9c6UZ3zCQ8P55dffmFQh48pkDu7S9sqXTQvZ83u9UJ0yG6neOHCeHp6Si1FNsixr5WXGgmQ40VJSxiNRqZOmUJgQAE6NX8fgCJ5/cmRyZelr/ETlCvL7HYqliiAl0fystc3qhlEg+rl6NG9O1FRUU5S51wsFgsd2rcnoGAuenxez+XtvVc+AARYaXm3j6UcSBBF1ooidT/8UGopskKOfa281EhAq1atmDBhgsPl//77b+rVq/ci0atC0li6dCnnL1xg6rftUKuf3o5qtYq2zd5nmc3mFrv/Ttls/G2x0PGT2smuSxAEJgz4ktjYGKZNm+YEdc5n9erVHD9xgimD26JNgd3PubJnol7l0kyz29xianil1cojq5WuXbtKLUVWfPvtt8kKOzlv3jzatWvnREWKAaRMmTJ89NFHDpe/c+cOf/zxh1s8mHJDFEWm/fordSqVoniBnC991/rj6liAhW7w1j/dYiGrrzcN3wtySn1+WTLQom5FZs6YgVWGo+CQadOoFlicssUcX+9MKh2bv88xi5UDbrAbNMRup36dOhQsWFBqKbKiZs2aVKlSxeHy586dY9++fU5UpBjAZKM4wjvOwYMHOXL0KB2a1Xzlu2yZ0tOoZhAhdttLfoJyI1YUWWS30bppTXRa542G2jetxc1bt9i8ebPT6nQGx48fZ+++fXR8zTVzJbUqliBv9kz8ajGnaLtJ5ZDNxiGzme69ekktJdWhOMLLkOcG0J1S98iFkJAQ8vhnpXZwqdd+371lPS5YrEyR8ShwsMmETa2mXRPnGoQyRfNSvmRBQmQ2DTp9+nSyZ8lAg+plU7RdlUpFjy8+YIXFyh4ZjooBbKJId5MJb4OBBg0aSC0n1eGK1HWKAUwmygjQMR48eMDKlStp17jGi7W//xJUogCdW9TmW4uZCzKc+tpltRJisTCs5ydODf/1nA5Na/Lnjh2cP3/e6XU7QmxsLIsXL6JNo+opsvb3X9o3qUWFgPy0s1iIl+GswESLhQibjSdGIydPnpRaTqpDGQG6gHPnziUrukCuXLlo0qSJYgCTyPz58xHtdr5oWO2txw3r3gK/rBlpZzbJair0iSjS3mKmcqlCL3avOpvGtcqTMb0PM2bMcEn9SWXx4sUYjUbafPyeJO2r1SqmDevMLQG+NZkk0fAmzthsDLGY6fppHfyyZGT69OlSS5IdERERnDt3zuHyJUuWpHbt5G80+zeCKLPdG7Gxsfj6+hITE0O6dOlc3l7Xrl2JiIjg0KFDLm9L4Sl2u51CBQsSVMSPWT90fufx+46c48Nuo/lJp2OwPnluBs5AFEU6mEysFGDfslHky+m6MHjDfv2NhZv3cevWbUl9ykRRpERAAAWze7NodA/JdAD8umwbQ6asYLuHB3VkEIM3QRSpYTISlTUDe5aOYvKSrUxd/ge3b99JkT7MXQgODqZkyZLMnj3b5W0l1o6k+WGLHH1TUjsRERFcvnKF1o2qJ+r4KmWL8HXbhnxrNjNfBuuBQ5/pGPtNa5caP4DWjaoTHR3Dn3/+6dJ23sXp06c5feYMrRu9fcSeEnT7tC61KgTQxGTioMTBEsyiSHOTkVOCwMwR3fAw6GjdqAZxcfFs3bpVUm1yQ459rbzUSIAcL0pqJzQ0FJ1WS/kSBRJd5rsuTWn7cQ06Go2SuUaIosgPJhMjzWZG9PyELz5yvTHInysb2bNkIDQ01OVtvY3Q0FBUKhUVSxWSVAc8nQpdNKY3JYrlpb7JRKhERtAoinxqMvGn3c6ScX0IDMgPgH/WDOTLlV3yayY35NjXSj9/IDGu2Fmk8HbCwsIoVSRPknLnCYLAhG/aANB2w27uiSJfabWoUujamUWRr00mplosDO3WnN5fpMwuP0EQCCyej7AkdqZ2u51Lly5x9epVEhISMJvN6PV6PDw8KFiwIHny5EnSfR8WFkax/Dnx8fJI6k9wCV4een6b/DWf9ZtI7VOX+U2vp0EKToc+EkU+MZnYh8iSsb2pVbHES98HFcub5GuW2pFjX6sYQBm+laR2Qg/sp3ZQ0p2E1WoVvwxqSwZfb75ZtIVtdhtzdXryuvj6HbXZaGsxc9JmY8KA1nRoVsul7f2X8gEFGL9oKzabDbVa/dpjzGYzW7ZsYf/+/UQcPMjhw4eJefLkjXVm8vUlsHx5AsuXp2rVqtStW/etOS1DD+wnKCDlHN8Tg6+3J2umDqDd4F/58MAJOmm1jNfrSefiTnaDxUIXqwWTTsvq8X2pWq7oK8cElSjAhl9XYTKZ0Mtg3VoOyLGvlZcaCRg9ejRLly51uPycOXOcnqQxNfPgwQMuXb6SpOnPfyMIAsO6t2Dt5K857+tNyYQEZpjNLonEY3425Vk+IQFrjqz8NW9Yihs/gMCA/Dx5Esfp06df+e769et899135PLzo2nTpqyaMoUMBw7wjdnMNg8PLnt5cdfLi0fe3tzx8uKilxebPDzolZCAfvduFk6YwIcffkj+3LkZNWoUkZGRr7Tx+PFjTp0+82KKT054GvQsn9CPCQNas0wFJY0J/OkiP8FHosgXRiONjUbKlC/OgZWjX2v8AIICCmA2mzl27JhLtLgj69evZ8iQIQ6X79evn9P9K9O8AfTz8yNPnqQnMX1OfHw8Dx8+dKKi1E1YWBjw9A05OdSqWIL9K0fTrGE1uplMBJmMzLdYSHCCIYwWRSabzZQwGRlptdCvXUN2LR7hcK6/5FK2WD5UKtWLcwdw/vx5GjdqRL68efl17Fg+ffyY056eXNXrWWMw8K1eTz2NhnwqFdlUKjIIAtlVKgqoVHyk0TBMr2ejwcAtvZ4IT0/qPXjAqGHDyJUzJ5+3bMmNGzdetBUeHo7dbqd8CXmG9lKpVHRoVov9y38ib6lC1E1I4EOjka1Wq1NcZ67Z7XxrMlHEmMAWrZrpQzuxYmJ//LJkeGOZkoVzo9dplXXAf5E3b16yZcvmcPmYmBhiYmKcqEgxgMlGjsN6OXPx4kUMeh15/DInu650Xh5MHtyOjdMGkqlcUTqYjORISOAro5FjtqSFUDOLIgdsNjoYjfjHx/O1xUKpGuXYteAHvuvc1KlhzpKKt6eB3H5ZuHjxIjabjYkTJ1K6ZElObtvGdJ2OWwYDUwwGir1hevRdlFOrmW0wcMvDg3FqNbvXrKFEsWLMnTsXURS5ePEigiBQyMVpj5JLHv8srP/1G6YP7cTNPNn5MCGBQkYjY0wmrtjtSZoleCKKbLFaaWQ0kj8ujmlqgWZNa3Fg5WhaNqjyzrUsnVZD/lzZuXjxYnJ/lsIzXNHXpvk1wOSiGMCkcefOHbJnzuDUxfDqgcWoHliMKzfvMX/dLuav/5uJcfF4qlSUUasJ5Gknn0kQ8ADsgBG4a7cTYbcTAZywWjGLIjkzp+erZrX4slF1smVK7zSNySVbJl/OnTtHjapV2R8aSh+tllF6PZ5OPI8ZBIE+Oh1tRJH+JhMdO3Zk9cqVFC9ZkiwZfdFoHDOwKYlKpaJlgyp89kFlIk5dZs6avxj2ZxiD4sxkVKsJVAkECipKqVSkEwQMgJWnvnxXRZFwm40IAc5ZrIhAyQI5+aVFbZrXq5TkVFfZMqXjzp07rviZaRLFAMoQm82mGMAk8NQA+rqk7nw5szKi16cM7tSE8FOXOHr2KkfPXmXryUtMvfPgleNVgkCx3NkpXaIAnxbNS5mieSlXLJ8sO/rsmdOxedMm8qpU7PbwoJoLdzymFwTmGQw012jo/Pff7N69mxzZM7msPVcgCAJBJQoQVKIAo/t+zsGTFzl69hpHz1xh4alL3Il6/EoZg1ZDiYI5qRqQn57F8lGuWD6K5c/h8Mta9szpuXH7VnJ/isIzXNHXpnkDuGnTJqxWK02aNHGofJUqVRg8eLCTVaVe7ty+TdaMro2O4WHQUS2wGNUCi734LN5o4kmckQSTGUEQ8NDr8PEyYNDrXKrFWWTLlB4vlcBRvR6vFNpK3kCj4YRaTYOEBCJu3mVPxJmXzqm7kMHXm3pVylCvSpkXn8XGJRCfYMJoMqPRqPHQ6/D19nTqy0/2TL6EnT7ltPrcnXnz5lG4cGGqVq3qUPlmzZrx5C07mx0hzRvA+fPnYzQaHTaAlStXpnLlyk5WlXqJj48jc/qU3xbuadDjaXDf7eheHnoyQIoZv+dkEAR2eHjQyJjAZ/0nsmHaoGRvYJID6bw8SOdin0ZPD72SKPtfjBo1ik8//dRhA9i0aVMnK1I2wShreCmM1Wp9Y/YHhTejVquQKuiXlyCw0eBBGbtI8z7juXr7vkRK3AuNWo3FIs/UTVIgx75WXmokQI4XJTWjVquRV/h190C0i0i5MuklCGzWG/A1men145wXacAU3ozdblde9v6FHPdLyEuNBCgGMGXRaLTKW7EDmK1WNBKHkUovCMzT6thz5Bzz1u6SVIs7YLba0GoTH+4vtSPHvlZeaiRAq9ViMBgcLh8bG8vdu3edqCh1kzlLFh5Ev7oDT+HtPIh6TBYZjJxraTR00WoZNnWFMhX6Dh5GPSZz5uT7u6YW9Hp9sl4IHj586PSgI2l+E8y6deuSVX7cuHEsWrSIa9euOUlR6sbf359zxx1PQJxWibwfhZ9M5o7H6fVsMyYweMISlk/oJ7Uc2XL3YTT+/jmkliEbLl26lKzy7dq1QxAENmzY4CRFyggw2chxWC9n/Pz8uPMgWmoZbsfdyEf4yySSvo8gMFSjZdv+Y8oo8C3cfRCDn7+/1DJSDa7IJqH03MlEFEXFACaBnDlz8ig6lifxRqmluA12u52b96PIIRMDCPCZRoOvSsWCdcpa4OsQRZEbdx+SI4cyAnQWrhhsKD13MlFGgEmjbNmyABw5c0ViJe7DpRuRxCaYKOdgrE9X4CkItFWpWbz+b4wms9RyZMete4+49zCacuXKSS0l1aAYQBmiGMCkUbx4cby9vQg/lbz1gLRE+KnLAFSQkQEE6KrT8fBxPJv+jpBaiuyIeHbNKlasKLGS1INiAF3AyJEjmTVrlsPl27Zty/Tp052oKHWjVqupUL7Ci05d4d2En7xEUa2G9DKaAgUoolJRQqtl/9FzUkuRHYdOXiJP7lz4+flJLUU2dOnShW3btjlcfsSIEXzzzTdOVKQYQLZt28b+/fsdLl+8eHFq1Ur5JKnuTMXgYMJPXXFJEtvUSPjx81SU6akKFEWOnlReZv5LxOkrVAyuJLUMWbFs2TLOnj3rcPng4GCCgoKcqEgxgMoUpgQEBwcT+SCKG3eVRMLvIt5o4tTl2wTLbPrzOYFqNacu38KsBDd4gcVq5ejZqwQHB0stRVa4YhdncknzPb+yizPlqVKlCjqdjg07D0ktRfZs/ecIVrudmi5Mf5QcAtVqzDYbpy/dlFqKbPhj/3ESjCZlZug/yHGwIS81EiDHi5LayZQpEy1atGDeur+VmJLvYO5vf1JTq6GITO/REs90XbyuREN6ztw1uwiuWJHSpUtLLUVWyLGvlZcaCShRogQFCjie3uXEiRPs2bPHiYrSBt27d+fKzUh2HVTypb2JkxducODkJbqr5Tn6A/B+9m+80SSpDrlw6fpddoadoHuPHlJLkR0VK1ZM1qagvXv3cuzYMScqSgED+PPPPyMIAn379nV1Uw4xd+5cBg4c6HD5adOm0a+fEg4qqVSqVInSpUoyZ81OqaXIlnlrd+KnUfOxTKc/AVSCgFYQMJktUkuRBfPW7SJTxoy0aNFCaimy459//klWTr8BAwYwdepUJypysQE8dOgQM2fOpFSpUq5sRlLkOKx3BwRBoHuPnmzfd4zrdx5ILUd2xMYlsHLrXjqr1GhltnHg34iiiEUU0cnYSKcU8UYTy7bso0PHjskKsK/wetzKD/DJkye0atWK2bNnkyFDBlc1IzmKAXSczz//HG9vLxau/1tqKbJj5e/7MJotdJJ5Op3nE596vbx1pgRrdxwk+nEcXbp0kVpKqsStDGCPHj348MMPqV279luPM5lMxMbGvvTnTigG0HG8vb1p06YtCzfuUabQ/oXdbmfubztootaQQ+b31sVnm5hyZM0osRJpEUWROWt28kH9+uTPn19qOakStwmGvWLFCg4fPszo0aPfeezo0aPx9fV98ZcrVy5XSHIZihtF8ujRowfRj+P4ZdEWqaXIhkUb/+Hs9bv0kfnoDyDimQEsXTSvtEIk5rdtBzh65gp9lf0ALsMtRoA3btygT58+LF26NFHz4IMHDyYmJubF340bN5wt6a00atSI8ePHO1x+woQJrFmzxomK0hZFihRh4MCBTFi4mTOXb0ktR3Lu3I9i6OTltNNqqeoG62oRNhsF/bOQzstDaimS8SAqlsGTl/PZZ59Sp04dqeXIErPZTMmSJdm0aZPDdWzbto2RI0c6UZULDGBERAT37t2jXLlyaDQaNBoNu3fvZsqUKWg0Gmw220vH6/V60qVL99JfSnLu3DkiIyMdLp8xY0ayZcvmREVpj++//578+fLTe/R8bLa06xcoiiJfjV2Ih8XKBL1eajmJ4qDdTqniaXvKb/Avy0GlYfLkKVJLkS02m42TJ08ma4krW7ZsTt9P4nQD+P7773PixAmOHj364i8oKIhWrVpx9OhR1DIL6aSs4UmPwWBg9pw5HDpxkTlr/pJajmRs3BXO1j1H+UWjJYOMd34+55EocthmIz4h7foAbt93lFV/HOCXXyaRNWtWqeXIlucBL+TW1zp9jsXHx4cSJUq89JmXlxeZMmV65XM5oBjAlCchIYHjx48TERFBeHg4l86fx5iQQKYMGfhh2irqVSlN3hxpqzN5EBXL1+OXIAhgc5Mg4QssFuyCwK5Dpzh35TZF8qWt7OfRsXH0Gb0AXx8fZk6bxupVqyhbrhxBQUEEBgbir2SDf0GaMYDuhmIAU4a4uDiWL1/OnBkzCD9yBJvdjlYQKKHTUdRmw0sQKCWKrBZFPu3/CzvmDcUnjawrmS1WWn8bAiotVYIrMT0igi+kFvUO7KLIdFGkWfPmnDhxglaDprJjzvek9/GSWlqKYLXaaPfdNGKiYmkiqNAePswdQSBk+3YeWJ7uaPbLkoXmn31Gt27dKFasmMSKpUWuBlAQZZaTJjY2Fl9fX2JiYlJkPXDo0KEEBQXRqFEjh8qvXr0as9nM559/7mRlqYNz584xffp0FsydS+yTJ3yo1fKRSkWgWk1JlQr9f6b6TtlsVDIZqV65FIvH9JbdA+MK+o9ZyOLNe9m5cyf37t2jWbNmHPH0pIzMlgv+zR9WK/USEti7dy/ZsmWjQoXylCuSi98m9EOtTv3X7LvJy5mxYjvbDR68/6/NSqIockMUibDZ2G+zsQi4Z7FQs3p1uvfqxccff4zWDXb3OpuEhAS+/vprOnToQLly5RyqY9q0aRQrVixRQcYTa0fSvAFMLs2aNSM+Pp7ff/9daimyIj4+nu+++47JkyeTWaOhoyDQWaslbyIM2iarlY8TEujX5iOGdmueAmqlY+ZvfzJw4lJmz55Nx44dsVqt5M2Zk8qPHvGbTKOJ2EWRWiYTUYUKcfTkSQRB4M8//6R+/fp0bvE+o/t+Lru0N85k0cbd9P5pPpP1enrrdG891iyKrLVamWa3s9dspmSxYsxfvJjAwMAUUpt6KFCgAJ988kmi3OsSa0dS/6uai7Hb7bLb2CM1e/fupXRAADOmTGGsTscNvZ6f9PpEGT+AhhoNY/V6Ji7czMSFm12sVjqWbt7DwIlL6d+/Px07dgRAo9EwduJEVlksrLXIMzjATIuF3RYLEyZPfmHo6tSpw9SpU5mx8k9GzVorsULXsebPUPqOXkAXrZZeiRjJ6QSBz7Ra9uj1HPL0RH3xIhUrVGDIkCGYTGl385AjuKKvVQxgMlHWEP+PzWbj66+/pnr16mS5fZujHh58rdO9Ms2ZGL7W6Rim0zFi+mrGz9/oArXSsmjjbnqOmkenTp1e8UNt2bIlHzdsSDebjQcySxd11W5ngNVK506dXony1L17d8aMGcP4+ZsYOWMNMptcSja/bdtPp6EzaaXREKLXJ3mUG6RWc1CvZ6hGw8+jRhFUtixnzpxxkdrUh1s4wqc1FAP4FLPZTMvPPmPSxImM1enYo9MlO4fdMJ2O4TodI2eu5dtJy7Fabe8uJHNEUWTSoi30/mk+Xbp0YcaMGa90pIIgMGPWLKyenvQ0myVS+ip2UaSDxUKmbNkY94bgEd988w1jx45l/IJNfD1uMRar+2eKF0WRkBXb6fLDLFprNMzX61E5OMWrFQSG6vWEe3hgv3iRapUrExER4WTFqRPFALoAq9WarKSsPj4++Pr6OlGR+2GxWGjetCkb1q5ltV7P1zodaiesAQnPOospej0zV27n034TiX4c5wTF0pBgNNN52Cx+CFnF999/T0hIyBsf6OzZs/Pr9OmstFgYK4OpMlEUGWAysdNsZu7ChW9dVxkwYACzZs1i4cZ/aNJnAg+jH6egUudiMlvoOXIu305azldaLXP1eqfc26XVavbo9RSMj6dm9eqEh4c7Qa18EUURq9WarFmBDBky4OXl3F3GaX4TTKZMmfjmm2+SlRMwLWO32/nyiy9YtXIlG/V66rsofNcOq5VPzCYyZsvEorG9CSjoXjFjr96+T7vvpnP26m0WLFjIJ598kqhyQ4cO5ccffyREr6fbOzZcuApRFBlhNvOD2cyvv/5Kj0Qme/3nn39o1rQpXgY1C0d1p4ybxQu9GfmQDt9O4+iZK8zW6fnSBbs3H4sidc1mLnh6smf//lTrLnHjxg1y587Ntm3bqFevnsvbUzbBJBIlmHXymDJlCsuWL2epTucy4wdQW6PhoMEDj/tR1Gg9jFGz1rpFBgmbzc605dup3Op7HsVZ2bdvf6KNH8Dw4cPp26cP3U0mxkswHSqKIoOeGb+ffvop0cYPoHr16hwKDydjFn/e7/AjP0z7jQSjfKZ034Tdbmf26h0EfzKYm+eusdvg4RLjB+AjCGzR6fCLi6Npo0YYjUaXtCM1z8dZcutr5aVGApQ1PMe5cOEC3w4aRC+tlhYp4NtUUKUiXG/gW42GSfM3Ue3z7wk9dsHl7TrKyQs3qNNpJN9PWUGHjp05cfIkZcuWTVIdgiAw8Zdf+P777xlgMtHWaCQ6hSZtIu12mppMjDWbmTx5MoMHD05yHXnz5iXs4EGGDx9OyModVPlyKHsi5Lvx49yV23zQaSQDxi/hc7vIKYMHFV28yzujILBCq+Xy5csMGzbMpW1JhVwd4eWlRgIUA+gYdrud9m3a4G+3MzoFAzfrBYHhej2HPTzIEPmQD7qMYsC4RUQ+jE4xDe8iOjaOkTPW8F67H0iw69i3bx9TpkzBx8fHofoEQeDHH39kwYIFrNPpCDCZ2OrCzSWiKLLcYqG4ycR+Hx/WrVtH7969Ha5Pq9Xy3XffcezYMfxzF6BhjzH0GT2f2/einKg6ecQ8iWfM3A1U+2IIUeevs9vDg5kGA74p5M8YoFbzg0bD+HHjCA0NTZE2UxLFAMoUxQA6xtSpU9l74ADzNBq8JHB6LqFWs09v4Be9nmXr/qZEo/50+D6E/UfPSbb9/ujZq/QcNZdijfozeek2vvvue44cPUqlSpWcUn+bNm04dfYspWrW5MOEBNoajVxyspvEKZuNZmYznxuN1GnalFPnztG4cWOn1F20aFF2//MPISEhrN0ZQckmX9Hm22n8E3FGsmt24sJ1+v68gOIf9mHcnPV8pVZzTG+gugSpqAbodARqtbT78stUNxUqVwOY5jfBLFiwgKCgIIcDdQ8ZMoQsWbIk6w3Z3TCZTOTy86PxkyfMkkG0kihRZKHFQojNxgWrleJ5/OjwSR0+qV/J5fFEE4xm1v11kLlrdxFx6hK5cuakS9eudOjQgezZs7ukTVEUmT9/PgP69+dRTAz1dTq6q9U0UKsd2qFoFkXWWa2E2O38YzbjlzUrU0NCaNasmQvUPyUmJobFixcTMm0aZ86epXDeHHRo+h6fNaiCr7eny9qFpzs7N+4KZ+5vOwg9dQl/jZrOKjWdtFr8Je6gT9hslIqPZ8GCBbRp00ZSLc4kJiaGVatW8eGHH+Ln5+dQHV9++SUtWrRIVNhKJRRaClGtWjXy58/PwoULpZaSYixbtoxWrVpxxtOTojKKgmMXRXbabIRYLWywWPHQ6/jsw6rUqVyKoID8ZM7gnPsp+nEch09fYWfYSZZu2UdUzGPq1qlD9x49+PDDD9Gk0OghISGBlStXEjJlCoeOHCG3VksdIPBZrNVSKhWG1xjEeFHkqN1OhM1GhM3GNkEg0mKhRtWqdO/Vi8aNG6NLoR2noiiye/duQkKmsW7denRaNS3qBlOvShmCAvKTNZNzXIxinsRz5PQVdh08xdKNu3kQG0ctrYbuag2NNBq0MgrdVs9kIrpECcIU/8CX8PHxYcSIEfTr1++dxyoGMIWoUqUKhQsXZv78+VJLSTGqVqqE/vBh/pJx0tYbdjuzLRYm2GzEP0vCnDdnNsoXz0dgQAFKF8mDf9YMZM+cHr3u9Rt4zBYrkQ9juPsgihPnrxN+6jLhp69w/srTzPWZMmakTdu2dO3alUKFCqXYb3sd4eHhzJ07lwN79nDq7FmsNhsaQSCPTocnoANMQDxw1WzGLorotFpKBQRQpUYNOnXqREBAgKS/4fbt28yZM4c5s2dz4+ZNAPL4ZyUoIB+BAfkpUzQv/lkzkj2TLwb96w20xfrsmt2P5uTFG4SfukT4qSucu3ILURTxVatoo1LTTauV1cvbv9lgsdDYaOTQoUMEBQVJLUc2eHl58dNPP9GnT593HqsYwBSicuXKFCtWjLlz50otJUU4duwYZcqUYbXBQDM3iGq/0WLhY6ORkSNHcv/+fcJCQzl85Ajmf7kUZPD1IX06L7QaNQICFquNmCdxPIz6f/ZqtVpN6VIlCa5UmYoVKxIcHEyhQoVkGfTZaDS+yLd45coVjEYjJpMJvV6Ph4cHhQoVIjAwkICAgBQb6SUFURS5fv06YWFhhIaGEhYaSsThwy/FzsyQzpv0vt4vXbPYuHgeRsW+tOW+VMkSBFeqzB/bt5Pt5k32JiOKS0phFUXym0zU+eIL5s6bJ7Uc2eDp6cmYMWPo1avXO49NrB1J8/kAk0ta20SzcuVKsmi1NJJgk4AjfKjR4K/VEhUVxaRJk4Cna5jnz5/nzp07L/6ioqKw2WzY7Xa0Wi3p0qXDz88Pf39//Pz8KFSoEJ6erl2bchYGg4EKFSpQoUIFqaU4hCAI5MmThzx58rzwmTSbzVy4cIHbt2+/uGaPHj166Zr5+Pi8cs28vLy4fv06M2bMYLTBIHvjB6ARBNoLAhNWrmT2nDlpqn95G67oa92jF3MRoigSHh5O3rx5yZIli0N1lC9fnvz58ztZmXwJP3iQSiCrNZO3oRYEKoki4WFhLz7T6/WULFmSkiVLSqhMISnodDoCAgIcmqZ9HmasqkynPF9HNbWa4fHxnD9/nqJFi0otJ9nExcVx+vRpihcv7nA4s1q1apErl3MjQKXpVwtRFKlQoQKbNm1yuI6pU6cmalE2NSCKIhGHDhHoJsbvOYEqFYcPH05WzFcF9yUiIoLsMtjhmRTKPTPWqSVQ9rlz56hQoQLnzp1zuI6tW7c6nLj8TbjPHeEC5OqbIleuXbvGo9hYAt3oTRogUK3mcXw8Fy9elFqKggREHDqEu6WfzSAI5NfpUo0BlGtfKy81KYxcL4pcOXz4MPB0ROVOPDfYz/UrpC0Oh4e73awFQKDdzuFDh6SW4RTk2tfKS00KI9cArXLl/v37qIBsbtaZZBIE9CoV9+/fl1qKQgojiiL3o6LI4Wb3LEAOQeB+ZKTUMpyCXPtaealJYeT6ViJXjEYjBrVallv/34WHSpXqwkspvJvn7i4e7njPCkKquWfl2tfKS00Ko9frCQ8PT1Z+qrp16zJq1CgnqpIvdrvdbW8YlSBgs7l/RnmFpPG843U/8/e0c04t92zJkiUJDw8nX758DpU3m83kz5+fdevWOVVXmnaDUKlUBAYmb3n8+vXrREXJJ6q9KzEYDJjcdCel0W7Hw8O1cUEV5If+WbQik7zifSQKoyjiIYNYu87A29s7WX2t3W7nypUrxMXFOVFVGh8BOoO05Ajv7e2NRRR54madiVEUSbDZ8Pb2llqKQgqjUqnwNBhwx1fUKMDbDaJhpQSumkJNGz23C0lLBvC54/gxN5uWOW63I4Li+J5GKRkQwFE3u2cBjgoCJZOYQDm1ohhAmZKWDGBAQAB6rZZwN5sGjbDZ0KjVlCpVSmopChIQWLEiEW7mu2oSRU5YLMleokktKAbQBSQkJDB79myuXbvmcB2dOnWievXqTlQlX7RaLaVLliTCzd6mI+x2ShQrhiGVrKcoJI2goCDOmUw8dqOp+xN2OxZRTDXZIG7evMns2bN58uSJQ+W1Wi0DBgxweli4NL0JJjY2ls6dO7Np0yby5MnjUB2DBw92sqqUQRRFHj58yO3bt4mJicFqtSIIAhqNBl9fX/z9/cmYMeMrLg+BFSuy6+RJiVQ7xiFBoHzFilLLUJCIwMBAROCwzUYNNwnifshmQ61SvTJrYbVauXfvHnfu3CE+Ph6r1YpKpUKj0ZA5c2b8/f3x8fGRSPWbOXXqFJ07d6Z+/foOrcV7eHgwduxYp+tyj7vBRSR2WB0ZGcmFCxdISEjAZDKh0+kwGAzkzZuXXLlyyd4v7tGjRxw8eJCwsDDCQkM5deokd+5GYrFY3lpOp9Phlz0bJUqUJLhSJSpWrEi1atWYPn06ERqNW4REO2Gzcdxs5vtkuLoouDcBAQHkzJ6dpQ8fuo0BXCqKBFeowJYtW16khLp48QL37j94Z0xbLy9Pcvj7Uy4w6EXqrrJly77YESsFcvUDdI+7wUW87qLY7Xb++ecf9uzZQ0R4OOGhody6d++NdWROn56gChUILF+eSpUqUbduXbQS58kTRZE9e/awYMEC9u3dw/kLT2NgZvD1Iah4PprVLI1/1gxky5QevyzpSefliVbz1JhZrDaiH8dx90E0dx9Ec+d+FMfP32D82N3EPH66Bdmg0TDNYmGeGxjAEIsFvyxZaNy4sdRSFCRCrVbTpUcPRv/wA2NFkfQyf2E9ZrOxz2yG0FD2tWhBLr8sBBbPS5WPKuGX5WkS5+yZ0+PloUetUiGKImarjYfRj188tzfuPuTo6cOsW7sGk9mCVqulTOlS1Hq/Np06daJAgQIp+psUAyhD/n1RoqKiWLBgAdOnTuXClStk0GgIFAS+EAQCDQaKq1R4CQJ6wAzEiyIXRJGI+Hgidu1i7q5djLJY8M+alc7du9OpUyf8/f1T9PfExsayZMkSQqZN49Tp0xTI7UetCsX56vNaBAXkJ3+ubA6PVu12Oxev3yX81GXmrvmLpaevMEGvJ4OMO5NYUWSx3c7X3btL/lKiIC0dO3Zk+A8/sNBioY8MkwD/mxCLhXQGHVOGdiS4VGGyZ07vcF1mi5VTF29w6OQlwk9eYtb0aYwdO5b69erRvUcPPvjgA9Qp8CIrVwOYpjPCX7t2jbx58/JB/fr8vWsXVouF5mo13TQaqiYy5FeMKGIA9ILAcZuN6RYLi+12jKJIkyZNGP3zzxQsWNClv+PkyZOEhISwePEiEhISaFCtHB2b1aJ6UDGXTM/eexhDQKN+jNZo+UrGnclUs5l+FgvXrl8nR44cUstRkJjPPv2UI+vWcVqvRy3TF7doUSRHfDy92zdiUMfGTq8/wWhm7Y4w5qzdxZHTl8mTOzddu3WjQ4cODudETQwbNmygcePG3Lt3z6F27HY7jx8/xsvLC00iprETa0fkZY5TEFEUOXDgAJnSp+fQjh18L4rc8PBgmcFANY0m0YajQFwcvzyLN1hKrWa6wcBtDw8ma7WEb9xIqRIlmDJlikty0UVERFCjenVKlizJ2lUr6P5pbY6vG8/in3tSo3xxl61NZs3ky6cfVGak1cJtmbpERNrtDLfZaPnZZ4rxUwCgX//+XLBamfKOtW8p+dpkQqXV0Lbxey6p38Ogo9VH1dg1byg75/2vvfuOb6r6Hz/+StKsDsqm7CVYdqGFMlWGOJAhWwGZglAQxAmKfBUB/bhZZYMgW0UElb2VAm0pUqCATKVlCRQ6crPO7w+gP5ECHUlv2pzn45E/mpzc8+5tT973npzxPs3qVOCD/xtPuXLl6N+/v9sWjO/QoQN2u53ixYvn6P2JiYkULlyYzZs3uzQur0yAly5doluXLrzwwgu0TE3lsNHIWKORUjm4PXcKcc9JLKTREGEwcMhoZKDTyciRI3miRQuX7UeXlpbGW2+9RaNGjbh64SwLJw4j/sdPGfvy85QtWdQldTzMhBE9MQb4MdhqxcM6ERBCMNRqRRsQwBdffaV2OJKHCA8PZ8SIEYy12TjugRduG+125tlsfDiyZ666PbOqQc0qzBg3iCM/fcG4Ic/z04/fUyM4mG+//dblbVqj0aDLxUL67tpNwusS4B9//EG92rXZsXYtK00mVplMlMzFSXVya6HlzPhrNEw1mdhmNvP3/v2E1K2b6yuYrVu3UrdOHaZ8/RXvDenMtgXv06l1I/R5PLqtSKA/X44dwM82G4vt9jyt+2FW2O2sttmYMXu2W7t1pPxn0qRJlC1fngE2Gw4PunBLFoJBNiuPNwim//Mt87TuooH+jOj1DHuXTqRlWHX69OnDs888k6v50a4mJ8K7wN69e3m8eXOCrl/nkNFINxcMjHDy8JP4hI8PfxiNtLDbaffMM6xZsybb9aSnp/Pyyy/TunVrSgUa+O3bCYzu+1yeJ75/e/ax+nRv25iRNisnPeSK+ozTyXC7nW5du9K1a1e1w5E8jJ+fH/MXLeI3q5VPbn91oTYhBMMVhWs6HVPHDVJtWlWJooWY++ErLP9sFIfioqlVqyazZs3yiB4emQBz6Y8//uDpJ5+kpsXCNqORIBedyKwkQLh1N7jGaKSDRkO3rl3ZuHFjluv4+++/adG8OUu+XcwXb73Euulv8UiFoBzH7EqfvN6b4kHFaKNYOK9yErzgdNLGaiWwTBmmz5ihaiyS53rsscd47733eNdqZb7K3wcKIXhLUfjWZuOLMf2oUDpn35G50tPNQ9iz9CO6t23EK6+8wuDBgzP2VVSLTIC5kJiYSNtWrahisfCL0ejSeUDzTSaezuIwYoNGw1KjkbYaDc937EhcXNxD3xMVFUXDsDAuJp5j/ayxDOjcyqOGEhcJ9Gf19HewFw6glVXhnEpJ8LzTSWubjfQiRdi8fbvs+pQe6MMPP+SVIUN4WVFUS4JCCMZarXxms/Hxa73o/nRTVeLITCE/M1++3Y9p7w1k0Tff0LpVKy49YD70w+zbt49hw4blOJGWLFmSpUuXUqNGjRzHkJkCPw1CCEH7du2I2byZPwwGSnhA8kgXgiaKgqhenf2xsRjuM5Xgl19+oXPnztQPrsiiSRGULBaYx5Fm3em/L9Fx2GTE1RusMxipm4eT5I84HLSz2XAUL87m7dupXr16ntUt5V9Op5OIYcOYOWsWHxsMvGkw3Pf7fFezCMEIRWGuzcbEkS8Q8YLnrlS0948T9BkzHf9CRdi6bVuOlo1cvHgxL730EhaLJU9WpJHTIG5btGgRP//6K7N9fDwi+QGYNRoW6vUcOXKEjz76KNMya9eupVOnTrQOr8WaqW96dPIDqFyuJOvnvk+hcqUIS09noqJgd/O1lV0IPlEU6lssmCtVYndUlEx+UpZptVpmREYyduxY3rFaaW21cioPejD2OxyEKha+cTqY+u4Aj05+AOF1q7Fpzrs4bWk81qIFZ86cyfYx3DWKM7c8KxoXO3/+PCOHD6ePXk97D1sDMESn4z29nkkTJxIbG3vXaxs2bKBr16480zyEbyYNw2jIH6uYlClZhC3f/B/D+zzL+zYbjRUL8W7aOeKow0Ezq5WxNhuvjh5NzMGDVKhQwS11SQWXRqNh4sSJbN68mdMlSlDXYmG61YrTDRdvihCMURQap6VhqFSGHYs+pE/7/LGTTMUyJfh5xtvohJVWLVty/vz5bL3fU1eC8axoXOyN11/HrCh8peIisA8y1mCgjo8PrwwalHGFFB8fT9euXWjZqCbzJgxRdZRnTpiMBsYP68bmeeNILV2cBunp9LZY+N3hyPVoMiEEex0O+loshFgsJJcvz+7ffuPTTz/FbDa76DeQvFHr1q05dPQofQYNYrii0MBqZY7VSqoLEuEVp5P/KQrBFgufO+yMHdKZTQvep2bVci6IPO+ULVmUn6a9hc2SQvvnniMtLS3L75UJMI8lJiayatUqxmq1FHVjv/52u52kHHab6DUaJul07D9wgL179/LPP//QsUMHKpUuxrwPX8l3ye/fGtSswvbFHzJ+RA9+L1aIZmlp1FcszLZaOe90ZisZJjqdzLNaCbNaaZyWxs5SpZgweTIHDh2iSZMmbvwtJG8SEBBA5MyZ7NixgwpPPskQq5WyFgsjLRZiHA5s2fifTReCHXY7L1kslEtP432ng8ZPNmLn4gm80b9Dvm3b5YOKsezTVzl27CgDBvTPcjsuXLgwderUyfEUj5SUFLZv387Nmzdz9P77KbCDYD744AM+nTCB82YzgW5KgEIItCkpzDOZGJDDOYVOIXhEUWjavTtJiYkcjIth67xxVCxTcEYxOp1Otu6NZ973W9nw20GcQlDKR0eYRkOoRksNrRZfjQYD/3+h8QSnkxghiAGSbDY0Gg3PPv00w4YP56mnnsqTBXwl73bmzBlmz57N3JkzuXztGkatlno+PoQKQX2tlmIaDWaNBie3BrVcEIIYh4NojYYjdhsOARVLFWVgtzb0eq4FxQp73j59ObVm6376jp3OxIkTGTt2rNvrO3DgAA0aNCA6OprQ0NCHls9qHimQCdBms1GpXDnaX7vGTDfuAu4QAp+UFBaYTPTLxaT6T29/l+UQgrXT36Z5A9fueuxJLly5zv74kxxMOEPc0dPEHTnNldvbLP1b8cKFCW3Y8NYjNJTw8HC5pqekCkVR2L9/PzExMbceUVEknDx5z/q+ep2WmpXLEFKrKiHBlQgJrkS9Ryt6XLefq0yc/QOfL1zH3r173b5zfUxMDGFhYcTGxlK/fv2Hls9qHsmf9+EPsW7dOhIvXWKor69b67nz75/b+8v+Pj68qyg0qf9ogU5+AEHFC9P+iVDaP3HrKk4IQUqahTc/W8xPOw7w22+/U7VqVfz9/T1+o2HJOxiNRpo3b07z5s0znlMUhSVLljBw4ECmjOlPh1Zh+JmN+bZrMyfeGtCB9bsPMnDAAKJjYty65ZicCJ8N27dvp6rBQD03d5PdSYC5PYnFtVqe0OnwzSejPV1Jo9EQ4Gfmk9d7E+hnZtx778nkJ3m81NRUxrzzDu2fCOOljo9TOMDPq5IfgN7Hh6lj+3P4yBE+++wzt9YlE2A2xOzbR1gezOdxVQIEaKjTcSjhjAuOlD8F+vvy2Zu9Wffzz6xYsULtcCTpgV5//XUUSxqfvtFb7VBUFRJcieEvPMUHH3zAsWPH3FaP3A0iixwOBwfi4gjLg0ESRuCory/PueDKL0yr5WJyCkmXr+U+sHyq3WMN6NiqIa+OGMHVq1fVDkeSMrVlyxYWLlzIhOHd82TbIk/3zqBOlC1ZhJf/NZ3rv5YvX06rVq1yXEe9evU4evSoyzcXL3AJ8NixY6RZLITmwRfPWo2GYJ3OJaNMQ28n7DgvvgsE+N/rvbh58wazZ89WOxRJytRHEyYQVrsqfTrkj0ns7mY2Gfjf6BfZtXs3u3btyrRMYmIi0dHROa/DbCY4ONjly6gVuASYkJAAQO18NvKqvEZDIZ2W42eS1A5FVaWKFaZzm0bMjIzE4aZVZCQpp44cOcL2HTsY2uNJ+T31v7RuXIdqFcswY8b0TF93Op0eORrW8yLKpdTUW0PqA/LZP6dGo8FfqyXNoqgdiuoGdWnF2XPn+PXXX9UORZLuEhkZSYmigbR/wr3D/vMbjUbDwM4t+f77H7hw4cI9r8sEmEcU5VYC8czFzx7MhAbFqu7+ZJ6gQc0q1K9ZhRnTM7+alCQ1pKSk8M03C+nb4TEMeu8a8ZkVPZ9tikGvY+7cufe8JhNgHvG5PSDFngd1pQnBl1bX7YZuQ+DjI1c4ARjYuSXrN2zg5MmTaociSQAsWbKE1NQ0+nZ6Qu1QPFLhAD+6tW3MrJkzsdvv/gSuVasWPXr0yPGxz549y5dffsmNGzdyG+ZdClwCvLMocnoe1JUiBKMVhSMuSoDpQmA2Zr43oLfp3KYRhQP8mDVrltqhSBJCCGZMn87TzUMoH1RM7XA81sAurfj7/HnWrVt31/Pt27dnei56dI4dO8bo0aO5fv16LiO8W4FLgOXK3VphPS/29XLlPMBkIbhid1CmZFEXHC3/8zUZebFdM+bNnUt6el5czkjS/f3+++/8cegQg7rkfCi/N6hbvSKN6lRj+rRpLj2unAifRSEhIWi1WmLyYAThnRpccRIP3I43JLiSC45WMLzYrjlXr13j999/VzsUycutWbOG0iWK8kTDmmqH4vFebNeMrdu2uXTnhjsjwmUCfAg/Pz+Cq1YlJp/dAcY4nfga9FSvWNoFRysYalQpS2CAH1FRUWqHInm5qD17aFSnqkcO5PA04XWr4XQ6czXv77/kHWA2hDZuTHQeTIMQgAlwxbCVaIeDOtXKo9MVyD9Jjmi1WhrUqEzUnj1qhyJ5MZvNRnRMNGG1qqgdSr7waKXSFPL3demFq0ajwWQyuXwbtAL5aRseHk6c3c4VN98FVtBqSQ8IoE0ul0KzC8EOBA3quHaZn4IgrHYV9u7dm+vd5CUpp+Lj40lPt9CwtmyfWaHVaqlfozJ79/7/BDh+/Hhq1KiR42M+99xzpKenU6KEa/dJdXkCnDx5Mg0bNiQgIICSJUvSqVMnty6SmpkePXqg1elYYM+LyRC595PdTpLdwQvPNlM7FI8TVqsKl69c4fTp02qHInmpqKgofHx01Hu0otqh5BthNSsTtScq48JVURRsNs+b4+zyBLhjxw4iIiKIiopi06ZN2Gw22rZtm7FCS14oXrw43Xv0INLpxJkP7hxmOByE16pC3eqygf1XWK2qAOzbt0/lSCRvtW/fPmo9UgGzSU5Ryqqw2lW5eOkSf/31F+BFE+HXr19Pv379qFWrFvXq1WPhwoWcO3eOmJgYV1f1QEOHDeO0zcYGD19P8pjTyRabjQFd26gdikcqVjiAIoX8OXPmjNqhSF7qzOnTPFK+pNph5CtVy5cCyGi3XpMA/ys5ORmAokUzn9+mKAo3bty46+EKjRs3JqROHT622z36LvBjq5ViAb50bCXXFryfoBJFSExMVDsMyUslJp6X2x5lU1CJIgAZ7dYrE6DT6WTUqFE0a9aM2rVrZ1pm8uTJBAYGZjzKly/vkro1Gg2ffvEFO202Zrqp7/m800nf9HT+zOFgmw12OwttNsZFdMckV4C5r1LFCpGU5N27ZEjqSbpwQSbAbArwNeFrNma0244dO/L222/n+Hh79uyhb9++WK1WV4UIuDkBRkREEB8fz/Lly+9bZsyYMSQnJ2c87vQZu0KbNm0YMngwb9ntnHbDiNBrQrDIbuefHNxhJgvBIJuVlmE16NvxcZfHVpCUKhbIBZkAJRWkpaVx82YKJYsGqh1KvqLRaChVvEjGzhCPP/44ffv2zfHxTp48yaJFi1w+GtxtCXD48OGsW7eObdu2ZSxPlhmj0UihQoXuerjSp599RvGgIAbabC7vCr2TUnMy43C0opDso2PKe4PkvmIPYTYaUBSL2mFIXshiufV/JwfAZJ/ZaMg4f7l1ZyK8qz8rXZ4AhRAMHz6c1atXs3XrVipXruzqKrIlICCAed98wzarlbcUxaVXEDldCSbSamW+zcZHo16UC+tmgU6rvWd1eUnKC3f+7+QCFdmn02pc1m7zzUowERERfPvttyxdupSAgAAuXLjAhQsXVF3QuHXr1kyZMoXPbTYmuLAPOScJ8FubjQhFYWjPtrwkuz6zxCmcLl8BQpKy4s7/ndPpuQPpPJXTKVzWbt2VAF2+q2NkZCQATzzxxF3PL1iwgH79+rm6uiwbMWIEN2/e5N133yUNmGww5Pp22hdorNXin8XjRFqtRCgKvdu3YOKrPWXXZxZZFBsGg+yCkvKe0Xhra225UXX2Way2jPOXlJSEoihUqlQpR8cqUaIEjRs3dvlnpssToCcvWTV27Fh8fX157bXXOCEEkQYDJXNxRRGs07HHz++h5VKE4G1FYYbNRpVyJfl6TH+PHBLsqS5fu0nJUnIdRinv+fn5YTabuHQ1We1Q8p3LV5MpWfLW/Mn333+fQ4cO5Xh90Pbt29O+fXtXhgcU0LVAH2TUqFF899137PT3p6bFwko3L8+z3W6nrqKwUKejYcOGlCxWWCa/bLr4TzKlS8tdMqS8p9FoKB0UxMUrMgFmR2q6wo2UtIx263Q6PbLHyys/ibt06cLhhATK1apFD4uFrhYLx1w8TeJvp5MIi4WW6emUa9iQP+LjadmyJRevumaivzdJunKdMmXKqB2G5KXKlClL0pVraoeRr1y8ch0go9165UR4T1ayZEle6tsXo9HIrkKFCE5NpY2i8IPNhj2H3bhCCLbY7XSxWKiUlsYivZ6vv/6a7bt2UbVqVcqXL8/5C/9gtckRjVl1MzWdK1eTXbZAgiRlV/kKFTibeEXtMPKVs4mXATLarUyAHkgIgdFo5Nz583z77bekhYTcSl6KwmCLhVlWKzEOB8p9EqJdCOIdDr6x2RhhsRBstdImPZ1jVaowZdo0zicl8eqrr2b84cPCwrDabBz+03WT/Qu62KO3doFo2LChypFI3qphw4YcPHYWm5yKk2XRh09RuHAgVaveWszeUxOgywfB5Cfdu3cnPDwco9FIr1696NWrF3FxccyZM4ddW7cy//hxHIqCXqPhEYMBP8AIWIF04ITVmpEcq1euTOMWLZgzcCAtWrTItL+7fv36GAwG9sefpH4NdedH5hfR8ScpVCiA4OBgtUORvFR4eDgWxcrhP/8mJLiS2uHkC9FHTtGoYaOMpDd27FgURcnx8b799lumTZvm0k12wcsTYPny5e/pWgsJCWH69OkApKenc/DgQWJiYjhx4gTp6ekoioLBYMBkMtHCbicyMpK4uDjq1av30PqMRiMh9eoRffgkg7vJ3R+yIvrw3Q1JkvJa/fr10ev1RMeflAkwC4QQRB8+RcSIDhnP5WYzXIDLly9z5MiR3IZ2D69OgA9jNptp3LgxjRs3zvT1LVu2EBkZSWBg1tcJbNykCetWr3JViAXanYY0eOizaocieTGz2Uy9unXYf/gkg7q2Vjscj3c28TL/XLtBeHi4y47pri5UmQBzISerE4SHhzNlyhSuXLtB8SKuXfc0L6SkWfjj+FniEs5w8NhZrl67iUWx4nQ6MRkN+PubqVm1PCHBFQkJrkSpYoVzXNfZxMtcvpp83wsQScorjZs05ec13yGEcNtw/pQ0C4eOnyPu2K229c/VG3e1LT8/MzWrliMkuBIhwZU8doeKfYf+BJAJsKDLyQKtrVu3xsfHh1Uboxjao627QnOppMvX+GbNDlZv2MPxvy8iBBg1Gur5+FBGCIpza0FwBbiqgZk7DnDt9kbEpYsE0KZ5CAO7tM5299HKDXvw9TXTokULV/9KkpQtTz/9NNOmTSP2yGlCa7luUYaL/1xn0Zqd/LD+d479dRGnEBg1Gur6+FD2P23rGjB75wGu3m5bQYUDaNWsHoO6tKJBTc9ZKGLVhigahoVRrJjr1jl21zxCr06Ahw4d4tSpU3Ts2DFH7y9XrhxDhw7F398/y+8pVaoUXbp0Zt4P23il+5MeOTkUbnU/7opNYN53m1m3IxYTGrprtbxlNBGq1VJTq0V/n9iFEJwRghiHg30pFpb/+juL1+4iLLgSA7s/yfOtGz50/0O73cHCH3fw4ou9stXFLEnu8PTTT1OpYkXmfr8l1wlQCMHvcceZ990WftoWjR5Bd50PrxsMhOp01HpI2zp7u23tT1NYviGKpT/vpsGjFRnYrQ2d24SrunPF6b8vsTnqEPPnz7/r+Z07dyKE4PHHc7b+cUhICAMHDnRFiHfRCA9bu+zGjRsEBgaSnJzs8q2R/mv8+PHMnz/fpXsQZsXOnTt5/PHHWTP1LR5vWDNP686KM+cvMXzCXHbHHaeG3odhWh199HoCc5is7ULws93ODIedjTY75YoXZsq4QbQKz3yTZIC122Po885UDhw4QEhISA5/E0lynU8++YTx74/j6NovKRqY9YvefzuXdIURE+ayIzaB6rfbVl+9nsI5bFsOIfjF4WCG3c56m43SRQvx9XsDadv04YPy3OH9qStY/Msezp9PxGw2ZzzfqVMnHA4Ha9euzZM4sppHvHponVpzU1q0aEGtmjWZ+/3WPK/7QZxOJ7NXbabpC+/yV/xJfjGbOWw0MdxgyHHyA/DRaOio17PBZCbBz4/g5FQ6j/yMVyfN50Zq5ruEzPthG00aN5bJT/IYffr0wWZ3sGTdrmy/VwjBgtXbaNpzLKf+OMFPZjMJRhMjDYYcJz8AnUZDex8ffjWZOO7nR92b6XQf/SXDPpzD9ZupOT5uTqRbrCxet5sBAwbelfzAc+cBel5EeUitP4pGo2FYRAS/7Irl/KWreV5/ZhIvXaP90I956/NveUnAIZOZZ3x8XN5F+6hWy0ajkZlGIz+s203THmPYHZtwV5kTZ5PYvi+eocOGubRuScqNXbt24XQ6mbdyc8b3/1lx8Z/rdIr4hNc++YaeTkG8yUx7N7StalotvxqNzDUaWbdhD026j2FHtOunDtzPj1v3cy35JkOGDLnnNZkAPZCaf5TevXtjNpv5Zs0OVer/t9N/X+LpQRM4c/gkW8xmIk0mAtz43aRGo2GIwUC82UzV5BQ6j/iUn3fGZrw+f/U2ihUtSrdu3dwWgyRl14ypUwnx8eHMxX/Yujc+S+85m3iZZwZ9xPE/TrDBbGaOyUQhN7etgQYD8SYzNVPS6DryM9Zs3e+2+v5t3g/baPvkk1SrVu2e1zw1AXr1IBin04nFYiEmJuaeq7HSpUvfswNBUlISSUlJd71fCEHZsmXvWaz5v2X/e9xChQrRp89LfLNqOaNfavfQQSHucuqvizw7+CMKpaSzyWiiQh7+k1bUatloNNFbUXjpnanM/2gYrcJrs2Tdbp7v0i1j4mtW/hZ3yLKyrDvK/vnnn+z87TeWG41M1sDsFZto06TuPcf4t7OJl3n25Y8wJqfym9FE5TxsW+W1Wn41muinKPR/dwazPxhC17bum04Ue+QU0fF/8uNHn2V6fq9fv86NGznfCMBdG+IiPExycrIARHJystvrOn78uKhZs6YA7nmMHz/+nvLjx4/PtOw777yT5bL/Pm5CQoLQ6/XijX7txfWohXn+OPLTl6JCiSKiut5HXPDzEyIgQJWH3d9fvKDXC71OK55pUV9otZoc/y1kWVnWXWWLg1D8/cUSk0kAYsXno+7bto79/JWoHFRcVPXxEedVbFsOf3/RV68XPlqtWP7Z/ePNzeOf3+aLsNqPiBrBwcJms933/DZt2lTs27fvnnOcFWPHjhWVKlXKcvms5hGvHgUKsGfPHj7++GM6dOhASEhIxp1gVq4cN27cyJgxYzhx4gSPPPLIA8ve8d/jfvDBB3z00QS2L/g/alfLux0PHA4nzw7+iMRjZ9mdx3d+mbEJQSfFwgabnf6DBjF06NCM1zz97kCWLdhlExMTebJlS4YoCpONRoQQPK1YOFzIj6iVHxPgd++Ajw7DPuZU/El+M5qopHLbsgtBN0VhkxZ+XzaJimVKuPT4M5Zv4N2vl7N7926aNm2a6fkVQnD48GGSkpJo0aIFTZs2zVYdY8aMYeXKlZw8eTJL5bOaR7w+AQIcO3aMr7/+mm7duvHEE09k+cvpZcuW8eKLL5Kamoqvr2+O6rZarTSoXx+DsLBpzrv4+OhydJzsmr5sA+99vYwdZjMtfDyjJ/y6EASnplKvdWvWb9zosXMkJe9y9uxZKlWqxFqzmedut5UzTie109N5sXNLPn2jz13l53y3mTc/+5YtZjOtPKRt3RCCOpZ0KtWtxo/T3nJZV+KZxMs07fUeAwa+zNSpUx9YVgjB6tWr+fvvvwkJCeGxxx7Lcj1vv/02P/zwAydOnMhSeTkNIhseffRRhg0bxi+//MKmTZvI6jWBK/qlDQYDc+fNIy7hNJErNub4ONnx57kLTJixilf1eo9JfgCFNRrmm0xs3Lz5nom0kqSW6OhoAEL/1c4rabVM1OuZ+90Wog7+/w/lM+cv8X9TV/CKXu8xyQ+gkEbDXL2BnbEJLFi93SXHFELw2iffUKxYCSZNmvTQ8hqNhs6dO1OqVClOnDjB1q1ZnwbmrkE0MgHeVrt2bV588UV27drFL7/8kqUk6KovZhs3bsyIESOYNOdHjp1OzNWxHsbpdDL8wzmUFTDRaHRrXTnxrI8P/fR6Ro8cmecLFEhSZmJiYiit11P6P+18uF5PI70PIybM4WZqOkIIhk+YS3GHk/95YNt60seHl/V63p+yLGPD2txYtGYH2/bGM3PWLAICArL8vh49emA0GklKSmLTpk1Zeo9MgHmgfv36tG/fnvj4eH766aeHlm/cuDGzZ89Gp8t9t+XEiROpXLkKL749les33DeBdXPUIaLiTzJbr8fPQ7sYvzQaMSgKn332mdqhSBKx0dGEZvK8TqNhod7AhaQrDBk/i2374tkdd5yZeoNbpxHlxudGIwEOJ18v/iVXx9l36E/e/HwJgwYN4tlns79bS+/evbHb7SQnJ7N+/fqHlu/WrRsffPBBTkJ9IPkdYCZ2797NgQMHKFOmDF26dMmzek+ePEnDhmHUr16elZ+Pcsv3gT1e+5zL0UeJNpo8+ju2MYrCDL2exIsX8fPzUzscyYuF1atH6NGjzDKZMn19rd1Ox/R0qlUIwpB0hT88vG39n6LwmUZw9JcpFPrPAJ6sOH/pKi37f0j14Fps2boVgyHnU7jmzp1LqVKl0Ol0OUqk9yO/A8yF5s2bU7t2ba5fv86KFSvyrN6qVauyatV37Ig+wpivlmb5u8isOpN4mY1Rhxim1Xl0AwUYotdzMzWVpUuXqh2K5OUsFgsPShPtfXx4S6/nxLkL+aJtvazXY7HaWPHrb9l+b3JKGi+8OQWj2Z/vf/ghV8kPYNCgQSQlJaHVavn5559zdayckAnwPlq2bEn58uWx2+0sWbIkz+pt3bo1kZGRzPluC+OnrXRpElzwwzYCtVpe0Otddkx3qaTV8pzBwIwpU1x+ISBJ2eF0OnlYStMDvkDvfNC2ymq1dPLRM2/l5my1rZQ0C91Hf8m5i9dYu24dJUuWdEk8gwcP5syZMxiNxjxbLPsOmQAfoG3bthQpUgSTycTixYvzrN6XX36Zr776iilLfuW9KctdlgC+//U3emt1+Hr4Feodg3U64uLjSUhIeHhhSXITk8mE8pAyy+12eun1Hvvd338N9vEh4dwF4v/M2kCz5JQ0Oo/8nCOnk9iwYSP16rl2t4lXXnmF48eP4+/vn6dJUCbAh3j22WfR6/UULlyYhQsX3vXapUuXiI2NzfyNuTRy5EimTZvG9GUbeOXDOVgUa66Od+mfZP7+J5nHXDBgJ6+0uB3rnWHokqSGgMBArj7gIvSaEPwpRL5qW810OrTAgaOnH1r2bOJlnn3lY47/dYktW7bSqFEjt8Q0bNgwDh8+nGkSPHv2LEePHnV5nTIBZkGHDh2w2+0EBQXdlQRXrVpFkyZN3FZvREQEy5YtY822GNoN+4Sky9dyfKy4Y2cACM1HjTRQo+ERg4GYmBi1Q5G8WN369Yl7QLuJub1De6gHLvZ8P34aDcEGPQcTzj6w3O7YBFoNnECaXcuuXbtp2LChW+MaPnw48fHxBAQEsG7duoznJ06cSL9+/VxeX/75i6ns+eefJzU1lXLlymVM0s6LFc579uzJrl27uXAtnZYDPmRnTM6ugg4cPUMRnY7K+aSL5o5Qp5PovXvVDkPyYqGhoRxXFG7e5y4wxuHAH6iejxIgQKhTcCA+86XFHA4nM5ZvoNOrn1IvJJT90dHUrn3/DaxdacSIERw6dAg/P7+MgTFyHqAH6NKlC9euXaNy5crMnz8/z7b4CAsLY390NNWDa9Mh4hNenTQ/25tdHkw4QwOtxuNHqP1XqE7Hgbi4bO2/JkmuFBoaigAO3L7T+68Yp5P6Oh3afNi2Dp/6G5vdftfzR0+d5+lXJjH2q2VERAxn/YYNFCtWLE9jGzFiBPHx8ZhMJn799ddbA5HccH5lAsymbt26cfnyZSpXrkxUVFSe7XFVunRptm3fTmRkJKu3xRL+wnv8tC3r341duXKdCvlwMGUFjYY0i4W0tDS1Q5G8VI0aNTAbjey7z0XYJSGokM+SH9xqW4rdQUqqBQDFamPynNU81nc8NxQtu3bt4quvvkKv0sjWESNGcPToUTQaDX/99ZdbPms9Z7G6fKR79+6sWLGCIkWKYLfbMx0I464V6zt27Mhzzz3HsKFDeWnMNJ57IpQBnVtStJD/PWWDihcmqHhhANItVkz5sJHemXq8d+9eihQpkvG8J+8eIMsWvLJPPvkkizdu5HUhuCAESf/qDr3idFJYpyPJ6bxnuTRPdufzICVdIeqPE3wQ+T1/nrtARERExnJldz7bMjtnkPl5c2XZpk2bsnLlSq5fv05KSkqOf9f7ytamTHkgL/cDzK2ZM2eKXr16qbJnmdPpFCtWrBBly5TJtBwg3h7YMWPPrloVS4vher1q+5Ll9LHWbPaoPeFkWe8su379egGI33x9xXiDIfOyBoPq7SU7j42321aZEkVv7dfXpIk4ePBgpucis3N2v/PmrrJDhgzJtGxm5H6AeUTtq1ebzcaiRYuYNWsW+/fvx9/XRIeWYXR4IpSQGpUz7gBbvfQ+DU4nMec+yzl5qu9sNrpZLGzfvv2uBXc96e5Ali34ZZ1OJ9WrVKFxYiKfGgx33QEOsFgop9Ewx2TKV3eAP91ewq1Hjx68/vrrGSM83X1X5+qymZH7AXqhhIQEBg4cyN6oKJzCyZPhdWjVpC4Na1dl/NTlBMWfYpU5+2v/qWme1cogRUFRlFwvuyRJufH5558z9q23OGs2E/SvRPd0WhpGjYY1+axtLbbZeMliISUlpcCttysToJe6fPkyj1SuTC2LBY1WS7TdjlUItBoNFTUaTuWzf/QRFgsby5Xj2KlTaociebmrV69SrUoV2qalsexfPSlvWCx8Z7dzxv/e7+E92esWCz+ULMnpv/9WOxSXk4the6kSJUrw1dSp7HE4eMfHhxt+fkT5+vKCTsdpp5Nkz7reeagYjYYwNy42IElZVbRoUabOmMFym40fbLaM50N1Os4KwT/5sW01bqx2GKqSCbAA6tevH88+/TRD7HbSgHCdjndudx/eby6TJ7ILQZzdTmhoZruxSVLee+GFF+jYvj1DHQ6u3J4WcWd1pZh81LacQhDrcBAaFqZ2KKqSCbAA0mg0zJ47lzSjkSGKglMIgrVazEB0PppQftTpJN3plAlQ8hgajYaZs2dj9/XlZasVhxA8otFQCIjORwnwhBDcdDi8vm3JBFhAlS1blrkLFvCd3c5IRUEHtNbpWGqz5ZvthZba7QT6+7t9/UFJyo6goCAWLFrET3Y7wxQFDfCkjw/L7Pb807ZsNvzNZhrLLlCpoOratSszZ85kms3Ga4rCEL2eA07nfVe08CSKEMx1Ouk3cCC+vr5qhyNJd+nQoQNz581jts3GcEVhiI8P8U4nu/PBXaBNCOYIQZ9+/e6aWuSN5EowBdzgwYNxOBxERETwjxBU0miYYbUS7uFDtr+z27litzN06FC1Q5GkTPXv3x+Hw8HgwYO5KgTVNRpm2Gy08PHsj9U1djtJNptsW8hpEF5jyZIlDBowAD+7nRSnk7/8/CjhoZN2hRA0s1rxbdqUzdu2qR2OJD3QqlWr6NunD742GzecTs76+Xn0hPiWioIjLIydv/2mdihuI6dBSHfp1asXcX/8QeV69bADbygP2+NaPcvtdvZYrbz2xhtqhyJJD9WtWzcOHjpEtdBQnMBoD25b39tsbJdtK4NMgF7k0UcfJWr/frp0784iu52f/7MNiie44HQy3G6ne7dutGvXTu1wJClLqlWrxm9RUbzQuzfL7XZW/2ueoKe47HQy1G6nU4cOdOrUSe1wPILsAvVCQggeb9GCE3v2cMTXlyIeskuEEILOisJvAQEcTkigRIkSaockSdkihODJ1q35Y8cOjvr6UsxD2hZAD4uFzb6+HE5IICgoSO1w3Ep2gUr3pdFoWLp8OWlmMxGK4jFDtxfa7fxosxE5e7ZMflK+pNFoWLxkCXZ//4w5uJ5gic3GSpuNaZGRBT75ZYdMgF6qXLlyzJo7l2U2G296QBL82W5nsKIwoH9/unTpomoskpQbpUuXZu6CBfxgtzPKalW9bW202+lvtdL7xRfp2bOnqrF4GpkAvVjPnj2ZMmUKn9tsjFWxof5it9NVUXiufXtmzZ6tSgyS5EqdO3dm5syZTLVaeUPFC8yNdjvPW620feop5i9ciMaDumQ9gWdPWJHcbsSIEdjtdkaPHs01IZhiNGLIw0ay2GZjgKLQ7rnnWL5yJT4ePodKkrJq8ODBWK1WRowYwXVghtGIMQ/b1nKbjZduJ79V33+PXq/Ps7rzC3kHKPHaa68xd+5c5jmdhFmtxObBahaXnU56WCy8ZLHQq08fvvvhB4xGo9vrlaS8NHz4cBYtWsRiIWhgtbI/D9rWP0LQy2LhBYuF7j16sHrNGswevvCFWmQClAAYOHAg+6Oj0VavTqP0dMYpClY3ddt8Z7NRS1HY4ufHsmXLWLBwobzzkwqsPn36EHvgAOYaNWicns4YRUFxU9v60WajlsXCLybTrcS7ZIm883sAmQClDCEhIeyPjWXc+PF87HBQS1H42mrlugsaq10IVttstFYUulksNG/XjsMJCfTs2VN+LyEVeLVr12bP/v18OGECnzud1FQUvrRaueaCtuUQgjU2G20tFp63WGj01FMcOXaMPn36yLb1EDIBSnfR6/WMHz+emNhYQp9/njfsdsqmpzPYYmGfw4E9Gw1WCMFpp5MJikIlRaGzxUJ6vXp8//33fL96NaVKlXLjbyJJnkWv1/Puu+8Se+AA4V268LbDQdn0dAZaLETloG2ddTqZpChUURQ6WSzcqFuXFStWsGbtWkqXLu3G36TgkBPhpQdKSkpi7ty5zJo+nfMXL2LWaqnn40OoEITqdJTRaDBz60rKAlwTggNOJzFCECME/9jt+JpM9OrTh6FDh1K/fn2VfyNJ8gwXL15k3rx5zJw2jb+SkjD9p22VzaRtxd1uW7HAZZsNs9HIi716MXTYMK/f2+/fsppHZAKUssRut/P7778THR1NTEwMMVFRHD99OtPh3aVLlCC0YcNbj9BQWrRoQeHChfM+aEnKB+x2O3v27CEmJuZW+4qK4tipU5m2raDixQlt1IjQsLCMtlWkSBEVovZsMgFKbpeSksLVq1exWCw4HA7MZjP+/v4UL15c7dAkKV+7X9sqVqyY/F4vC7KaR+TQOynH/P398ff3VzsMSSpwZNvKG3IQjCRJkuSVZAKUJEmSvJLbEuD06dOpVKkSJpOJ8PBw9u3b566qJEmSJCnb3JIAV6xYwejRoxk/fjyxsbHUq1ePp556ikuXLrmjOkmSJEnKNrckwC+++IKXX36Z/v37U7NmTWbOnImvry/z5893R3WSJEmSlG0uHwVqtVqJiYlhzJgxGc9ptVratGnDnj177imvKAqKomT8nJycDNwaxipJkiRJ2XUnfzxslp/LE+CVK1dwOBz3LHNVqlQpEhIS7ik/efJkPvjgg3ueL1++vKtDkyRJkrzIzZs3CQwMvO/rqs8DHDNmDKNHj874+fr161SsWJFz5849MHBvdOPGDcqXL89ff/0lFwn4F3le7k+em8zJ83J/BeHcCCG4efMmZcqUeWA5lyfA4sWLo9PpuHjx4l3PX7x4kaCgoHvKG43GTPeBCwwMzLcn390KFSokz00m5Hm5P3luMifPy/3l93OTlRsolw+CMRgMhIaGsmXLloznnE4nW7ZsoUmTJq6uTpIkSZJyxC1doKNHj6Zv376EhYXRqFEjvvrqK1JTU+nfv787qpMkSZKkbHNLAuzRoweXL1/m/fff58KFC4SEhLB+/fos7f9mNBoZP358pt2i3k6em8zJ83J/8txkTp6X+/Omc+Nxu0FIkiRJUl6Qa4FKkiRJXkkmQEmSJMkryQQoSZIkeSWZACVJkiSv5HEJUG6jdLfJkyfTsGFDAgICKFmyJJ06deLYsWNqh+WRPv74YzQaDaNGjVI7FNWdP3+e3r17U6xYMcxmM3Xq1CE6OlrtsFTncDgYN24clStXxmw2U7VqVSZMmPDQNSMLop07d9K+fXvKlCmDRqPhxx9/vOt1IQTvv/8+pUuXxmw206ZNG06cOKFOsG7iUQlQbqN0rx07dhAREUFUVBSbNm3CZrPRtm1bUlNT1Q7No+zfv59Zs2ZRt25dtUNR3bVr12jWrBl6vZ5ff/2VI0eO8Pnnn1OkSBG1Q1PdJ598QmRkJNOmTePo0aN88skn/O9//2Pq1Klqh5bnUlNTqVevHtOnT8/09f/9739MmTKFmTNnsnfvXvz8/HjqqaewWCx5HKkbCQ/SqFEjERERkfGzw+EQZcqUEZMnT1YxKs9y6dIlAYgdO3aoHYrHuHnzpqhWrZrYtGmTePzxx8XIkSPVDklVb7/9tmjevLnaYXikdu3aiQEDBtz1XOfOnUWvXr1UisgzAGL16tUZPzudThEUFCQ+/fTTjOeuX78ujEajWLZsmQoRuofH3AHe2UapTZs2Gc89aBslb3Vnu6iiRYuqHInniIiIoF27dnf973izn376ibCwMLp160bJkiWpX78+c+bMUTssj9C0aVO2bNnC8ePHATh48CC7d+/mmWeeUTkyz3L69GkuXLhwV5sKDAwkPDy8QH0eq74bxB3Z3UbJGzmdTkaNGkWzZs2oXbu22uF4hOXLlxMbG8v+/fvVDsVjnDp1isjISEaPHs3YsWPZv38/r776KgaDgb59+6odnqreeecdbty4QXBwMDqdDofDwcSJE+nVq5faoXmUCxcuAGT6eXzntYLAYxKg9HARERHEx8eze/dutUPxCH/99RcjR45k06ZNmEwmtcPxGE6nk7CwMCZNmgRA/fr1iY+PZ+bMmV6fAFeuXMmSJUtYunQptWrVIi4ujlGjRlGmTBmvPzfeyGO6QLO7jZK3GT58OOvWrWPbtm2UK1dO7XA8QkxMDJcuXaJBgwb4+Pjg4+PDjh07mDJlCj4+PjgcDrVDVEXp0qWpWbPmXc/VqFGDc+fOqRSR53jzzTd555136NmzJ3Xq1KFPnz689tprTJ48We3QPMqdz9yC/nnsMQlQbqOUOSEEw4cPZ/Xq1WzdupXKlSurHZLHaN26NYcOHSIuLi7jERYWRq9evYiLi0On06kdoiqaNWt2z1SZ48ePU7FiRZUi8hxpaWlotXd/7Ol0OpxOp0oReabKlSsTFBR01+fxjRs32Lt3b4H6PPaoLlC5jdK9IiIiWLp0KWvWrCEgICCj/z0wMBCz2axydOoKCAi457tQPz8/ihUr5tXfkb722ms0bdqUSZMm0b17d/bt28fs2bOZPXu22qGprn379kycOJEKFSpQq1YtDhw4wBdffMGAAQPUDi3PpaSk8Oeff2b8fPr0aeLi4ihatCgVKlRg1KhRfPTRR1SrVo3KlSszbtw4ypQpQ6dOndQL2tXUHob6X1OnThUVKlQQBoNBNGrUSERFRakdkqqATB8LFixQOzSPJKdB3LJ27VpRu3ZtYTQaRXBwsJg9e7baIXmEGzduiJEjR4oKFSoIk8kkqlSpIt59912hKIraoeW5bdu2ZfrZ0rdvXyHErakQ48aNE6VKlRJGo1G0bt1aHDt2TN2gXUxuhyRJkiR5JY/5DlCSJEmS8pJMgJIkSZJXkglQkiRJ8koyAUqSJEleSSZASZIkySvJBChJkiR5JZkAJUmSJK8kE6AkSZLklWQClCRJkrySTICSJEmSV5IJUJIkSfJKMgFKkiRJXun/Ab/XNo1txJUiAAAAAElFTkSuQmCC\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -540,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 33, "id": "3cf52bd7-5892-48f7-bc6b-9a5f24ca6ae2", "metadata": {}, "outputs": [ @@ -553,14 +534,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -590,7 +569,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 34, "id": "a9d0f944-cfcf-40bd-b874-0d4b081788af", "metadata": {}, "outputs": [ @@ -669,10 +648,10 @@ "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -704,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 35, "id": "2154888a-8305-423b-8d99-341e5a52f44a", "metadata": {}, "outputs": [ @@ -718,14 +697,12 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -739,6 +716,175 @@ "plot_molecule(mol);" ] }, + { + "cell_type": "markdown", + "id": "dde8fe19-556c-4c9e-b6cf-2d0dd5a34ef3", + "metadata": {}, + "source": [ + "#### Convert problematic PLAMS Molecule to RDKit Mol" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "7da2ed9d-f9b5-4fec-86d6-c37af291b3ff", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mol = Molecule(badxyz_file)\n", + "mol.guess_bonds()\n", + "plot_molecule(mol)" + ] + }, + { + "cell_type": "markdown", + "id": "c84e4100-2347-4490-b216-cd23a48b78e2", + "metadata": {}, + "source": [ + "This molecule will fail to convert to an RDKit Mol object, because RDKit does not like the AMS assignment of double bonds." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "8fe9140c-8de7-4c01-a64b-49ca37ca97a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[13.12|17:47:23] RDKit Sanitization Error.\n", + "[13.12|17:47:23] Most likely this is a problem with the assigned bond orders: Use chemical insight to adjust them.\n", + "[13.12|17:47:23] Note that the atom indices below start at zero, while the AMS-GUI indices start at 1.\n", + "Failed to convert\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RDKit ERROR: [17:47:23] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14\n", + "[17:47:23] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14\n", + "\n", + "RDKit ERROR: \n" + ] + } + ], + "source": [ + "try:\n", + " rdkit_mol = to_rdmol(mol)\n", + "except ValueError as exc:\n", + " print(\"Failed to convert\")" + ] + }, + { + "cell_type": "markdown", + "id": "dce54ed2-5913-4230-9990-7f8f16c66fb9", + "metadata": {}, + "source": [ + "The problem can be fixed by passing the argument `presanitize` to the `to_rdmol` function." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "be1209b5-08a8-490f-a28c-961f423d9b9b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RDKit ERROR: [17:47:06] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14\n", + "[17:47:06] Can't kekulize mol. Unkekulized atoms: 10 11 12 13 14\n", + "\n", + "RDKit ERROR: \n" + ] + }, + { + "data": { + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "O\n", + "H\n", + "H\n", + "O\n", + "H\n", + "H\n", + "H\n", + "C-\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rdkit_mol = to_rdmol(mol, presanitize=True)\n", + "rdkit_mol" + ] + }, { "cell_type": "markdown", "id": "3d18c8c5-a1f6-4ef7-bb63-44d14faa3333", diff --git a/examples/MoleculeFormats/MoleculeFormats.py b/examples/MoleculeFormats/MoleculeFormats.py index 8c6f20f9e..426573b05 100644 --- a/examples/MoleculeFormats/MoleculeFormats.py +++ b/examples/MoleculeFormats/MoleculeFormats.py @@ -13,6 +13,7 @@ AMSHOME = os.environ["AMSHOME"] cif_file = f"{AMSHOME}/atomicdata/Molecules/IZA-Zeolites/ABW.cif" xyz_file = f"{AMSHOME}/scripting/scm/params/examples/benchmark/ISOL6/e_13.xyz" +badxyz_file = f"{AMSHOME}/scripting/scm/plams/unit_tests/xyz/reactant2.xyz" assert Path(cif_file).exists(), f"{cif_file} does not exist." assert Path(xyz_file).exists(), f"{xyz_file} does not exist." @@ -190,6 +191,27 @@ def head(filename, n: int = 4): plot_molecule(mol) +# #### Convert problematic PLAMS Molecule to RDKit Mol + +mol = Molecule(badxyz_file) +mol.guess_bonds() +plot_molecule(mol) + + +# This molecule will fail to convert to an RDKit Mol object, because RDKit does not like the AMS assignment of double bonds. + +try: + rdkit_mol = to_rdmol(mol) +except ValueError as exc: + print("Failed to convert") + + +# The problem can be fixed by passing the argument `presanitize` to the `to_rdmol` function. + +rdkit_mol = to_rdmol(mol, presanitize=True) +rdkit_mol + + # ### SCM libbase UnifiedChemicalSystem Python class # # #### Convert PLAMS Molecule to UnifiedChemicalSystem diff --git a/examples/PlotReaction2D/PlotReaction2D.ipynb b/examples/PlotReaction2D/PlotReaction2D.ipynb new file mode 100644 index 000000000..d9995ea53 --- /dev/null +++ b/examples/PlotReaction2D/PlotReaction2D.ipynb @@ -0,0 +1,322 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6223ccee-4f30-47da-9796-3f08b3387fae", + "metadata": {}, + "source": [ + "## Creating 2D images of molecules" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "d8479d8e-8f2b-4882-94a9-0914e838ffc8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "O\n", + "O\n", + "HO\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import SVG\n", + "from scm.plams import ReactionEquation\n", + "from scm.plams import from_smiles, to_image, get_reaction_image\n", + "\n", + "aspirin = from_smiles(\"CC(=O)OC1=CC=CC=C1C(=O)O\")\n", + "text = to_image(aspirin)\n", + "SVG(text)" + ] + }, + { + "cell_type": "markdown", + "id": "530d601b-eac3-4849-b5a3-1f7418c3edd0", + "metadata": {}, + "source": [ + "It is also possible to write the image to file in a range of different formats (SVG, PNG, EPS, PDF, JPEG)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "7b452b79-2c62-4bdd-b129-268ff0c0117c", + "metadata": {}, + "outputs": [], + "source": [ + "text = to_image(aspirin, filename=\"aspirin.svg\")\n", + "text = to_image(aspirin, filename=\"aspiring.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "79095131-3e8b-4abb-8dfd-5fa7ea11ca49", + "metadata": {}, + "source": [ + "## Creating 2D imageas of reactions" + ] + }, + { + "cell_type": "markdown", + "id": "a2c93688-af57-416d-ba52-389b69314435", + "metadata": {}, + "source": [ + "We can have aspirin react with water to form acetic acid and salicylic acid" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "5366f0ff-6435-4b6c-802f-f521ced86d4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "OH\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "acetic_acid = from_smiles(\"CC(O)=O\")\n", + "text = to_image(acetic_acid)\n", + "SVG(text)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "5316bb6a-c850-41ac-b3dd-9a33eec653a5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "OH\n", + "OH\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "salicylic_acid = from_smiles(\"O=C(O)c1ccccc1O\")\n", + "text = to_image(salicylic_acid)\n", + "SVG(text)" + ] + }, + { + "cell_type": "markdown", + "id": "ed975357-5d66-4090-ac85-a13cad4cc95c", + "metadata": {}, + "source": [ + "We can create a 2D image of the reaction as well, and optionally store it to file" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "2169688f-97ff-4777-b01b-747c643f06d6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "O\n", + "O\n", + "HO\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "H\n", + "H\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "OH\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "O\n", + "OH\n", + "OH\n", + "+\n", + "+\n", + " \n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reactants = [aspirin, from_smiles(\"O\")]\n", + "products = [acetic_acid, salicylic_acid]\n", + "text = get_reaction_image(reactants, products, filename=\"reaction.svg\")\n", + "SVG(text)" + ] + } + ], + "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.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/PlotReaction2D/PlotReaction2D.py b/examples/PlotReaction2D/PlotReaction2D.py new file mode 100644 index 000000000..2151dcf56 --- /dev/null +++ b/examples/PlotReaction2D/PlotReaction2D.py @@ -0,0 +1,40 @@ +#!/usr/bin/env amspython +# coding: utf-8 + +# ## Creating 2D images of molecules + +from IPython.display import SVG +from scm.plams import ReactionEquation +from scm.plams import from_smiles, to_image, get_reaction_image + +aspirin = from_smiles("CC(=O)OC1=CC=CC=C1C(=O)O") +text = to_image(aspirin) +SVG(text) + + +# It is also possible to write the image to file in a range of different formats (SVG, PNG, EPS, PDF, JPEG) + +text = to_image(aspirin, filename="aspirin.svg") +text = to_image(aspirin, filename="aspiring.png") + + +# ## Creating 2D imageas of reactions + +# We can have aspirin react with water to form acetic acid and salicylic acid + +acetic_acid = from_smiles("CC(O)=O") +text = to_image(acetic_acid) +SVG(text) + + +salicylic_acid = from_smiles("O=C(O)c1ccccc1O") +text = to_image(salicylic_acid) +SVG(text) + + +# We can create a 2D image of the reaction as well, and optionally store it to file + +reactants = [aspirin, from_smiles("O")] +products = [acetic_acid, salicylic_acid] +text = get_reaction_image(reactants, products, filename="reaction.svg") +SVG(text) diff --git a/interfaces/molecule/rdkit.py b/interfaces/molecule/rdkit.py index d5c6ef7c2..8a5e601e8 100644 --- a/interfaces/molecule/rdkit.py +++ b/interfaces/molecule/rdkit.py @@ -1,6 +1,7 @@ -from typing import List, Literal, Optional, overload, TYPE_CHECKING +from typing import List, Literal, Optional, overload, TYPE_CHECKING, Sequence, Dict, Any import random import sys +import copy from warnings import warn from scm.plams.core.functions import add_to_class, log, requires_optional_package @@ -32,6 +33,8 @@ "get_conformations", "yield_coords", "canonicalize_mol", + "to_image", + "get_reaction_image", ] @@ -108,7 +111,11 @@ def from_rdmol(rdkit_mol: "RDKitMol", confid: int = -1, properties: bool = True) @requires_optional_package("rdkit") def to_rdmol( - plams_mol: Molecule, sanitize: bool = True, properties: bool = True, assignChirality: bool = False + plams_mol: Molecule, + sanitize: bool = True, + properties: bool = True, + assignChirality: bool = False, + presanitize: bool = False, ) -> "RDKitMol": """ Translate a PLAMS molecule into an RDKit molecule type. @@ -119,6 +126,8 @@ def to_rdmol( :parameter bool sanitize: Kekulize, check valencies, set aromaticity, conjugation and hybridization :parameter bool properties: If all |Molecule|, |Atom| and |Bond| properties should be converted from PLAMS to RDKit format. :parameter bool assignChirality: Assign R/S and cis/trans information, insofar as this was not yet present in the PLAMS molecule. + :parameter bool presanitize: Iteratively adjust bonding and atomic charges, to avoid failure of sanitization. + Only relevant is sanitize is set to True. :type plams_mol: |Molecule| :return: an RDKit molecule :rtype: rdkit.Chem.Mol @@ -213,10 +222,11 @@ def plams_to_rd_bonds(bo): if sanitize: try: - Chem.SanitizeMol(rdmol) + if presanitize: + rdmol = _presanitize(plams_mol, rdmol) + else: + Chem.SanitizeMol(rdmol) except ValueError as exc: - # rdkit_flag = Chem.SanitizeMol(rdmol,catchErrors=True) - # log ('RDKit Sanitization Error. Failed Operation Flag = %s'%(rdkit_flag)) log("RDKit Sanitization Error.") text = "Most likely this is a problem with the assigned bond orders: " text += "Use chemical insight to adjust them." @@ -1290,3 +1300,737 @@ def canonicalize_mol(mol, inplace=False, **kwargs): ret = mol.copy() ret.atoms = [at for _, at in sorted(zip(idx_rank, ret.atoms), reverse=True)] return ret + + +@requires_optional_package("rdkit") +@requires_optional_package("PIL") +def to_image( + mol: Molecule, + remove_hydrogens: bool = True, + filename: Optional[str] = None, + fmt: str = "svg", + size: Sequence[int] = (200, 100), + as_string: bool = True, +): + """ + Convert single molecule to single image object + + * ``mol`` -- PLAMS Molecule object + * ``remove_hydrogens`` -- Wether or not to remove the H-atoms from the image + * ``filename`` -- Optional: Name of image file to be created. + * ``fmt`` -- One of "svg", "png", "eps", "pdf", "jpeg" + * ``size`` -- Tuple/list containing width and height of image in pixels. + * ``as_string`` -- Returns the image as a string or bytestring. If set to False, the original format + will be returned, which can be either a PIL image or SVG text + We do this because after converting a PIL image to a bytestring it is not possible + to further edit it (with our version of PIL). + * Returns -- Image text file / binary of image text file / PIL Image object. + """ + from io import BytesIO + from PIL import Image + from rdkit.Chem import Draw + from rdkit.Chem.Draw import rdMolDraw2D + from rdkit.Chem.Draw import MolsToGridImage + + extensions = ["svg", "png", "eps", "pdf", "jpeg"] + + classes: Dict[str, Any] = {} + classes["svg"] = _MolsToGridSVG + for ext in extensions[1:]: + classes[ext] = None + # PNG can only be created in this way with later version of RDKit + if hasattr(rdMolDraw2D, "MolDraw2DCairo"): + for ext in extensions[1:]: + classes[ext] = MolsToGridImage + + # Determine the type of image file + if filename is not None: + if "." in filename: + extension = filename.split(".")[-1] + if extension in classes.keys(): + fmt = extension + else: + msg = [f"Image type {extension} not available."] + msg += [f"Available extensions are: {' '.join(extensions)}"] + raise Exception("\n".join(msg)) + else: + filename = ".".join([filename, fmt]) + + if fmt not in classes.keys(): + raise Exception(f"Image type {fmt} not available.") + + rdmol = _rdmol_for_image(mol, remove_hydrogens) + + # Draw the image + if classes[fmt.lower()] is None: + # With AMS version of RDKit MolsToGridImage fails for eps (because of paste) + img = Draw.MolToImage(rdmol, size=size) + buf = BytesIO() + img.save(buf, format=fmt) + img_text = buf.getvalue() + else: + # This fails for a C=C=O molecule, with AMS rdkit version + img = classes[fmt.lower()]([rdmol], molsPerRow=1, subImgSize=size) + img_text = img + if isinstance(img, Image.Image): + buf = BytesIO() + img.save(buf, format=fmt) + img_text = buf.getvalue() + # If I do not make this correction to the SVG text, it is not readable in JupyterLab + if fmt.lower() == "svg": + img_text = _correct_svg(img_text) + + # Write to file, if required + if filename is not None: + mode = "w" + if isinstance(img_text, bytes): + mode = "wb" + with open(filename, mode) as outfile: + outfile.write(img_text) + + if as_string: + img = img_text + return img + + +@requires_optional_package("rdkit") +@requires_optional_package("PIL") +def get_reaction_image( + reactants: Sequence[Molecule], + products: Sequence[Molecule], + filename: Optional[str] = None, + fmt: str = "svg", + size: Sequence[int] = (200, 100), + as_string: bool = True, +): + """ + Create a 2D reaction image from reactants and products (PLAMS molecules) + + * ``reactants`` -- Iterable of PLAMS Molecule objects representing the reactants. + * ``products`` -- Iterable of PLAMS Molecule objects representing the products. + * ``filename`` -- Optional: Name of image file to be created. + * ``fmt`` -- The format of the image (svg, png, eps, pdf, jpeg). + The extension in the filename, if provided, takes precedence. + * ``size`` -- Tuple/list containing width and height of image in pixels. + * ``as_string`` -- Returns the image as a string or bytestring. If set to False, the original format + will be returned, which can be either a PIL image or SVG text + * Returns -- SVG image text file. + """ + extensions = ["svg", "png", "eps", "pdf", "jpeg"] + + # Determine the type of image file + if filename is not None: + if "." in filename: + extension = filename.split(".")[-1] + if extension in extensions: + fmt = extension + else: + msg = [f"Image type {extension} not available."] + msg += [f"Available extensions are: {' '.join(extensions)}"] + raise Exception("\n".join(msg)) + else: + filename = ".".join([filename, fmt]) + + if fmt.lower() not in extensions: + raise Exception(f"Image type {fmt} not available.") + + # Get the actual image + width = size[0] + height = size[1] + if fmt.lower() == "svg": + img_text = _get_reaction_image_svg(reactants, products, width, height) + else: + img_text = _get_reaction_image_pil(reactants, products, fmt, width, height, as_string=as_string) + + # Write to file, if required + if filename is not None: + mode = "w" + if isinstance(img_text, bytes): + mode = "wb" + with open(filename, mode) as outfile: + outfile.write(img_text) + return img_text + + +def _get_reaction_image_svg( + reactants: Sequence[Molecule], products: Sequence[Molecule], width: int = 200, height: int = 100 +): + """ + Create a 2D reaction image from reactants and products (PLAMS molecules) + + * ``reactants`` -- Iterable of PLAMS Molecule objects representing the reactants. + * ``products`` -- Iterable of PLAMS Molecule objects representing the products. + * Returns -- SVG image text file. + """ + from rdkit import Chem + + def svg_arrow(x1, y1, x2, y2, prefix=""): + """ + The reaction arrow in html format + """ + # The arrow head + l = ['<%sdefs> <%smarker id="arrow" viewBox="0 0 10 10" refX="5" refY="5" ' % (prefix, prefix)] + l += ['markerWidth="6" markerHeight="6" '] + l += ['orient="auto-start-reverse"> '] + l += ['<%spath d="M 0 0 L 10 5 L 0 10 z" />' % (prefix, prefix, prefix)] + arrow = "".join(l) + # The line + l = ['<%sline x1="%i" y1="%i" x2="%i" y2="%i" ' % (prefix, x1, y1, x2, y2)] + l += ['stroke="black" marker-end="url(#arrow)" />'] + line = "".join(l) + return [arrow, line] + + def add_plus_signs_svg(img_text, width, height, nmols, nreactants, prefix=""): + """ + Add the lines with + signs to the SVG image + """ + y = int(0.55 * height) + t = [] + for i in range(nmols - 1): + x = int(((i + 1) * width) - (0.1 * width)) + if i + 1 in (nreactants, nreactants + 1): + continue + t += ['<%stext x="%i" y="%i" font-size="16">+' % (prefix, x, y, prefix)] + lines = img_text.split("\n") + lines = lines[:-2] + t + lines[-2:] + return "\n".join(lines) + + def add_arrow_svg(img_text, width, height, nreactants, prefix=""): + """ + Add the arrow to the SVG image + """ + y = int(0.5 * height) + x1 = int((nreactants * width) + (0.3 * width)) + x2 = int((nreactants * width) + (0.7 * width)) + t = svg_arrow(x1, y, x2, y, prefix) + lines = img_text.split("\n") + lines = lines[:-2] + t + lines[-2:] + return "\n".join(lines) + + # Get the rdkit molecules + rdmols = [_rdmol_for_image(mol) for mol in reactants] + rdmols += [Chem.Mol()] # This is where the arrow will go + rdmols += [_rdmol_for_image(mol) for mol in products] + nmols = len(rdmols) + + # Place the molecules in a row of images + subimg_size = [width, height] + kwargs = {"legendFontSize": 16} # ,"legendFraction":0.1} + img_text = _MolsToGridSVG(rdmols, molsPerRow=nmols, subImgSize=subimg_size, **kwargs) + img_text = _correct_svg(img_text) + + # Add + and => + nreactants = len(reactants) + img_text = add_plus_signs_svg(img_text, width, height, nmols, nreactants) + img_text = add_arrow_svg(img_text, width, height, nreactants) + + return img_text + + +def _get_reaction_image_pil( + reactants: Sequence[Molecule], + products: Sequence[Molecule], + fmt: str, + width: int = 200, + height: int = 100, + as_string: bool = True, +): + """ + Create a 2D reaction image from reactants and products (PLAMS molecules) + + * ``reactants`` -- Iterable of PLAMS Molecule objects representing the reactants. + * ``products`` -- Iterable of PLAMS Molecule objects representing the products. + * Returns -- SVG image text file. + """ + from io import BytesIO + from PIL import Image + from PIL import ImageDraw + from rdkit import Chem + from rdkit.Chem.Draw import rdMolDraw2D, MolsToGridImage + + def add_arrow_pil(img, width, height, nreactants): + """ + Add the arrow to the PIL image + """ + y1 = int(0.5 * height) + y2 = y1 + x1 = int((nreactants * width) + (0.3 * width)) + x2 = int((nreactants * width) + (0.7 * width)) + + # Draw a line + black = (0, 0, 0) + draw = ImageDraw.Draw(img) + draw.line(((x1, y1), (x2, y2)), fill=128) + + # Draw the arrow head + headscale = 20 + xshift = width // headscale + yshift = img.size[1] // headscale + p1 = (x2, y2 + yshift) + p2 = (x2, y2 - yshift) + p3 = (x2 + xshift, y2) + draw.polygon((p1, p2, p3), fill=black) + + return img + + def add_plus_signs_pil(img, width, height, nmols, nreactants): + """ + Add the lines with + signs to the SVG image + """ + black = (0, 0, 0) + + I1 = ImageDraw.Draw(img) + y = int(0.5 * height) + # myfont = ImageFont.truetype('FreeMono.ttf', 25) + for i in range(nmols): + x = int(((i + 1) * width) - (0.05 * width)) + if i + 1 in (nreactants, nreactants + 1): + continue + # I1.text((x, y), "+", font=myfont, fill=black) + I1.text((x, y), "+", fill=black) + return img + + def join_pil_images(pil_images): + """ + Create a new image which connects the ones above with text + """ + white = (255, 255, 255) + + widths = [img.width for img in pil_images] + width = sum(widths) + height = max([img.height for img in pil_images]) + final_img = Image.new("RGB", (width, height), white) + + # Concatenate the PIL images + for i, img in enumerate(pil_images): + pos = sum(widths[:i]) + h = int((height - img.height) / 2) + final_img.paste(img, (pos, h)) + + return final_img + + nreactants = len(reactants) + nmols = nreactants + len(products) + + if not hasattr(rdMolDraw2D, "MolDraw2DCairo"): + # We are working with the old AMS version of RDKit + white = (255, 255, 255) + rimages = [to_image(mol, fmt=fmt, as_string=False) for i, mol in enumerate(reactants)] + pimages = [to_image(mol, fmt=fmt, as_string=False) for i, mol in enumerate(products)] + blanc = Image.new("RGB", (width, height), white) + + # Get the image (with arrow) + nreactants = len(reactants) + all_images = rimages + [blanc] + pimages + img = join_pil_images(all_images) + + else: + # We have a later version of RDKit that can regulate the font sizes + rdmols = [_rdmol_for_image(mol) for mol in reactants] + rdmols += [Chem.Mol()] # This is where the arrow will go + rdmols += [_rdmol_for_image(mol) for mol in products] + + # Place the molecules in a row of images + subimg_size = [width, height] + kwargs = {"legendFontSize": 16} # ,"legendFraction":0.1} + img = MolsToGridImage(rdmols, molsPerRow=nmols + 1, subImgSize=subimg_size, **kwargs) + + # Add + and => + img = add_plus_signs_pil(img, width, height, nmols, nreactants) + img = add_arrow_pil(img, width, height, nreactants) + + # Get the bytestring + img_text = img + if as_string: + buf = BytesIO() + img.save(buf, format=fmt) + img_text = buf.getvalue() + + return img_text + + +def _correct_svg(image): + """ + Correct for a bug in the AMS rdkit created SVG file + """ + if not "svg:" in image: + return image + image = image.replace("svg:", "") + lines = image.split("\n") + for iline, line in enumerate(lines): + if "xmlns:svg=" in line: + lines[iline] = line.replace("xmlns:svg", "xmlns") + break + image = "\n".join(lines) + return image + + +def _presanitize(mol, rdmol): + """ + Change bonding and atom charges to avoid failed sanitization + + Note: Used by to_rdmol + """ + from rdkit import Chem + + mol = mol.copy() + for i in range(10): + try: + rdmol_test = copy.deepcopy(rdmol) + Chem.SanitizeMol(rdmol_test) + stored_exc = None + break + except ValueError as exc: + stored_exc = exc + text = repr(exc) + # Fix the problem + rdmol, bonds, charges = _kekulize(mol, rdmol, text) + # print ("REB bonds charges: ",bonds, charges) + # print (rdmol.Debug()) + # rdmol = to_rdmol(mol, sanitize=False) + # print (rdmol.Debug()) + + if stored_exc is not None: + raise stored_exc + else: + rdmol = rdmol_test + return rdmol + + +def _kekulize(mol, rdmol, text, use_dfs=True): + """ + Kekulize the atoms indicated as problematic by RDKit + + * ``mol`` - PLAMS molecule + * ``text`` - Sanitation error produced by RDKit + + Note: Returns the changes in bond orders and atomic charges, that will make sanitation succeed. + """ + from rdkit import Chem + + # Find the indices of the problematic atoms + indices = _find_aromatic_sequence(rdmol, text) + if indices is None: + return rdmol, {}, {} + + # Set the bond orders along the chain to 2, 1, 2, 1,... + altered_bonds = {} + if len(indices) > 1: + emol = Chem.RWMol(rdmol) + if use_dfs: + # It may be better to create the tree first, and then start at a leaf + altered_bonds = _alter_aromatic_bonds(emol, indices[0]) + indices = list(set([ind for tup in altered_bonds.keys() for ind in tup])) + else: + indices = _order_atom_indices(emol, indices) + altered_bonds = _alter_bonds_along_chain(emol, indices) + _adjust_atom_aromaticity(emol, altered_bonds) + rdmol = emol.GetMol() + # Adjust the PLAMS molecule as well + for (iat, jat), order in altered_bonds.items(): + for bond in mol.atoms[iat].bonds: + if mol.index(bond.other_end(mol.atoms[iat])) - 1 == jat: + bond.order = order + break + + # If the atom at the chain end has the wrong bond order, give it a charge. + altered_charge = {} + atom_indices, dangling_bonds = _get_charged_atoms(rdmol, indices) + if len(atom_indices) > 0: + iat = atom_indices[0] + ndangling = dangling_bonds[iat] + altered_charge = _guess_atomic_charge(iat, ndangling, rdmol, mol) + rdmol.GetAtomWithIdx(iat).SetFormalCharge(altered_charge[iat]) + for k, v in altered_charge.items(): + mol.atoms[k].properties.rdkit.charge = v + + return rdmol, altered_bonds, altered_charge + + +def _find_aromatic_sequence(rdmol, text): + """ + Find the sequence of atoms with 1.5 bond orders + """ + indices = None + lines = text.split("\n") + line = lines[-1] + if "Unkekulized atoms:" in line: + text = line.split("Unkekulized atoms:")[-1].split("\\n")[0] + if '"' in text: + text = text.split('"')[0] + indices = [int(w) for w in text.split()] + if len(indices) > 1: + return indices + line = "atom %i marked aromatic" % (indices[0]) + iat: Any + if "marked aromatic" in line: + iat = int(line.split("atom")[-1].split()[0]) + indices = [iat] + while iat is not None: + icurrent = iat + iat = None + for bond in rdmol.GetAtomWithIdx(icurrent).GetBonds(): + if str(bond.GetBondType()) == "AROMATIC": + iat = bond.GetOtherAtomIdx(icurrent) + if iat in indices: + iat = None + continue + indices.append(iat) + break + elif "Explicit valence for atom" in line: + iat = int(line.split("#")[-1].split()[0]) + indices = [iat] + return indices + + +def _alter_aromatic_bonds(emol, iat, depth=0, double_first=False): + """ + Switch all thearomitic bonds to single/double, starting at iat + + * ``emol`` -- RDKit EditableMol type, for which bond orders will be changed + * ``iat`` -- Starting point for depth first search + """ + from collections import OrderedDict + from rdkit import Chem + from scm.plams import PeriodicTable as PT + + # Use OrderedDict, so that the leaves of the tree + # will be at the end + bonds_changed = OrderedDict() + + at = emol.GetAtomWithIdx(iat) + valence = PT.get_connectors(at.GetAtomicNum()) + bonds = at.GetBonds() + are_aromatic = [str(b.GetBondType()) == "AROMATIC" for b in bonds] + int_orders = sum([b.GetBondTypeAsDouble() for i, b in enumerate(bonds) if not are_aromatic[i]]) + numbonds = len([b for i, b in enumerate(bonds) if are_aromatic[i]]) + valence -= int(int_orders) + # Here I place the double bond first. + # I could also start with a single bond instead. + orders = [1 for i in range(numbonds)] + if valence > numbonds: + for i in range(min(numbonds, valence - numbonds)): + if double_first: + orders[i] = 2 + else: + orders[numbonds - i - 1] = 2 + + for i, bond in enumerate(bonds): + jat = bond.GetOtherAtomIdx(iat) + if are_aromatic[i]: + pair = tuple(sorted([iat, jat])) + order = orders.pop(0) + bond.SetBondType(Chem.BondType(order)) + bond.SetIsAromatic(False) # This is necessary with the newer RDKit + bonds_changed[pair] = order + d = _alter_aromatic_bonds(emol, jat, depth + 1) + bonds_changed.update(d) + return bonds_changed + + +def _alter_bonds_along_chain(emol, indices): + """ + Along the chain of atoms (indices), alternate double and single bonds + """ + from scm.plams import PeriodicTable as PT + from rdkit import Chem + + if len(indices) > 1: + # The first bond order is set to 2, if aromic + # Else it is flipped + first_bond = emol.GetBondBetweenAtoms(indices[0], indices[1]) + if str(first_bond.GetBondType()) == "AROMATIC": + new_order = 2 + else: + new_order = first_bond.GetBondTypeAsDouble() + new_order = (new_order % 2) + 1 + # Unless this breaks valence rules. + iat = indices[0] + at = emol.GetAtomWithIdx(iat) + valence = PT.get_connectors(at.GetAtomicNum()) + orders = [b.GetBondTypeAsDouble() for b in at.GetBonds()] + jat = indices[1] + at_next = emol.GetAtomWithIdx(jat) + valence_next = PT.get_connectors(at_next.GetAtomicNum()) + orders_next = [b.GetBondTypeAsDouble() for b in at_next.GetBonds()] + if sum(orders) > valence or sum(orders_next) > valence_next: + new_order = 1 + # Set the bond orders along the chain to 2, 1, 2, 1,... + altered_bonds = {} + for i, iat in enumerate(indices[:-1]): + bond = emol.GetBondBetweenAtoms(iat, indices[i + 1]) + bond.SetBondType(Chem.BondType(new_order)) + bond.SetIsAromatic(False) # This is necessary with the newer RDKit versions + altered_bonds[iat, indices[i + 1]] = new_order + new_order = ((new_order) % 2) + 1 + return altered_bonds + + +def _order_atom_indices(rdmol, indices): + """ + Order the atomic indices so that they are consecutive along a bonded chain + """ + # Order the indices, so that they are consecutive in the molecule + start = 0 + for i, iat in enumerate(indices): + at = rdmol.GetAtomWithIdx(iat) + neighbors = [b.GetOtherAtomIdx(iat) for b in at.GetBonds()] + relevant_neighbors = [jat for jat in neighbors if jat in indices] + if len(relevant_neighbors) == 1: + start = i + break + iat = indices[start] + atoms = [iat] + while 1: + at = rdmol.GetAtomWithIdx(iat) + neighbors = [b.GetOtherAtomIdx(iat) for b in at.GetBonds()] + relevant_neighbors = [jat for jat in neighbors if jat in indices and not jat in atoms] + if len(relevant_neighbors) == 0: + break + iat = relevant_neighbors[0] + atoms.append(iat) + if len(atoms) < len(indices): + raise Exception("The unkekulized atoms are not in a consecutive chain") + indices = atoms + return indices + + +def _adjust_atom_aromaticity(emol, altered_bonds): + """ + Assign aromaticity to the atoms based on the new bond orders + """ + indices = list(set([ind for tup in altered_bonds.keys() for ind in tup])) + for ind in indices: + at = emol.GetAtomWithIdx(ind) + if not at.GetIsAromatic(): + continue + # Only change this if we are sure the atom is not aromatic anymore + aromatic = False + for bond in at.GetBonds(): + if str(bond.GetBondType()) == "AROMATIC": + aromatic = True + break + if not aromatic: + at.SetIsAromatic(False) + + +def _get_charged_atoms(rdmol, indices): + """ + Locate the atoms that need a charge + """ + from scm.plams import PeriodicTable as PT + + atom_indices = [] + dangling_bonds = {} + for iat in indices[::-1]: + at = rdmol.GetAtomWithIdx(iat) + valence = PT.get_connectors(at.GetAtomicNum()) + bonds = at.GetBonds() + orders = [b.GetBondTypeAsDouble() for b in bonds] + ndangling = int(valence - sum(orders)) + if ndangling != 0: + dangling_bonds[iat] = ndangling + atom_indices.append(iat) + return atom_indices, dangling_bonds + + +def _guess_atomic_charge(iat, ndangling, rdmol, mol): + """ + Guess the best atomic charge for atom iat + """ + # Get the total charge from atomic charges already set + charges = [at.GetFormalCharge() for at in rdmol.GetAtoms()] + totcharge = sum(charges) - charges[iat] + + # Here I hope that the estimated charge will be more reliable than the + # actual (user defined) system charge, but am not sure + est_charges = mol.guess_atomic_charges(adjust_to_systemcharge=False, depth=0) + molcharge = int(sum(est_charges)) + molcharge = molcharge - totcharge + + # Adjust the sign based on the estimated charge + sign = ndangling / (abs(ndangling)) + if molcharge != 0: + sign = molcharge / (abs(molcharge)) + elif est_charges[iat] != 0: + sign = est_charges[iat] / abs(est_charges[iat]) + + # Then use the over/under valence with the new sign as the atomic charge + charge = int(sign * abs(ndangling)) + # Perhaps we tried this already + if charge == charges[iat]: + charge = -charge + altered_charge = {iat: charge} + return altered_charge + + +def _rdmol_for_image(mol, remove_hydrogens=True): + """ + Convert PLAMS molecule to an RDKit molecule specifically for a 2D image + """ + from rdkit.Chem import AllChem + from rdkit.Chem import RemoveHs + + rdmol = to_rdmol(mol, presanitize=True) + + # Flatten the molecule + AllChem.Compute2DCoords(rdmol) + # Remove the Hs only if there are carbon atoms in this system + # Otherwise this will turn an OH radical into a water molecule. + carbons = [i for i, at in enumerate(mol.atoms) if at.symbol in ["C", "Si"]] + if remove_hydrogens and len(carbons) > 0: + rdmol = RemoveHs(rdmol) + else: + for atom in rdmol.GetAtoms(): + atom.SetNoImplicit(True) + + ids = [c.GetId() for c in rdmol.GetConformers()] + for cid in ids: + rdmol.RemoveConformer(cid) + return rdmol + + +def _MolsToGridSVG( + mols, + molsPerRow=3, + subImgSize=(200, 200), + legends=None, + highlightAtomLists=None, + highlightBondLists=None, + drawOptions=None, + **kwargs, +): + """ + Replaces the old version of this function in our RDKit for a more recent one, with more options + """ + from rdkit.Chem.Draw import rdMolDraw2D + + if legends is None: + legends = [""] * len(mols) + + nRows = len(mols) // molsPerRow + if len(mols) % molsPerRow: + nRows += 1 + + fullSize = (molsPerRow * subImgSize[0], nRows * subImgSize[1]) + + d2d = rdMolDraw2D.MolDraw2DSVG(fullSize[0], fullSize[1], subImgSize[0], subImgSize[1]) + if drawOptions is not None: + d2d.SetDrawOptions(drawOptions) + else: + dops = d2d.drawOptions() + for k, v in list(kwargs.items()): + if hasattr(dops, k): + setattr(dops, k, v) + del kwargs[k] + + d2d.DrawMolecules( + list(mols), + legends=legends or None, + highlightAtoms=highlightAtomLists or [], + highlightBonds=highlightBondLists or [], + **kwargs, + ) + d2d.FinishDrawing() + res = d2d.GetDrawingText() + return res diff --git a/unit_tests/test_identify.py b/unit_tests/test_identify.py index de61464da..91f8cf650 100644 --- a/unit_tests/test_identify.py +++ b/unit_tests/test_identify.py @@ -1,10 +1,7 @@ import pytest -from scm.plams.tools.periodic_table import PT from scm.plams.mol.molecule import Molecule -PT.set_connectors("Mg", 4) - class TestIdentify: """ diff --git a/unit_tests/test_molecule_interfaces.py b/unit_tests/test_molecule_interfaces.py index 0f705672c..93ed460dc 100644 --- a/unit_tests/test_molecule_interfaces.py +++ b/unit_tests/test_molecule_interfaces.py @@ -6,7 +6,15 @@ from scm.plams.interfaces.molecule.ase import toASE, fromASE from scm.plams.unit_tests.test_helpers import get_mock_find_spec, get_mock_open_function from scm.plams.core.errors import MissingOptionalPackageError -from scm.plams.interfaces.molecule.rdkit import from_rdmol, to_rdmol, from_smiles, to_smiles, from_smarts +from scm.plams.interfaces.molecule.rdkit import ( + from_rdmol, + to_rdmol, + from_smiles, + to_smiles, + from_smarts, + to_image, + get_reaction_image, +) from scm.plams.interfaces.molecule.packmol import packmol @@ -22,7 +30,16 @@ def plams_mols(xyz_folder, pdb_folder, rkf_folder): water_molecule_in_box.lattice = [[100, 0, 0], [0, 100, 0], [0, 0, 100]] benzene = Molecule(xyz_folder / "benzene.xyz") chlorophyl = Molecule(xyz_folder / "chlorophyl1.xyz") + chlorophyl.guess_bonds() chymotrypsin = Molecule(pdb_folder / "chymotrypsin.pdb") + chymotrypsin.guess_bonds() + o_hydroxybenzoate = Molecule(xyz_folder / "reactant2.xyz") + o_hydroxybenzoate.guess_bonds() + hydronium = from_smiles("[OH3+]") + # Remove the charge, so that it becomes a difficult molecule for RDKit + for at in hydronium.atoms: + if at.symbol == "O": + del at.properties.rdkit.charge return { "water": water_molecule, @@ -31,6 +48,8 @@ def plams_mols(xyz_folder, pdb_folder, rkf_folder): "benzene": benzene, "chlorophyl": chlorophyl, "chymotrypsin": chymotrypsin, + "o_hydroxybenzoate": o_hydroxybenzoate, + "hydronium": hydronium, } @@ -177,7 +196,19 @@ def roundtrip_and_assert(self, molecules, from_mol, to_mol, level=4): def test_to_rdmol_from_rdmol_roundtrip(self, plams_mols): from_mol = lambda mol: to_rdmol(mol) to_mol = lambda mol: from_rdmol(mol) - self.roundtrip_and_assert(plams_mols, from_mol, to_mol) + from_bad_mol = lambda mol: to_rdmol(mol, presanitize=True) + + # These molecules throw errors when sanitized by RDKit + badmolnames = ["chlorophyl", "chymotrypsin", "o_hydroxybenzoate", "hydronium"] + + # Most molecules do not change at all during round trip + molecules = {k: v for k, v in plams_mols.items() if k not in badmolnames} + + # This molecule needs presanitization, meaning bond orders and charge change + badmols = {k: v for k, v in plams_mols.items() if k in badmolnames} + + self.roundtrip_and_assert(molecules, from_mol, to_mol) + self.roundtrip_and_assert(badmols, from_bad_mol, to_mol, level=1) @pytest.mark.parametrize("short_smiles,ff", [(True, None), (False, None), (False, "uff"), (False, "mmff")]) def test_to_smiles_from_smiles_roundtrip(self, plams_mols, short_smiles, ff): @@ -189,7 +220,10 @@ def test_to_smiles_from_smiles_roundtrip(self, plams_mols, short_smiles, ff): # For chlorophyl we get a kekulize error... # For chymotrypsin we get a aromatic error... - err_mols = {k: v for k, v in plams_mols.items() if k in ["chlorophyl", "chymotrypsin"]} + # For o_hydroxybenzoate we get a kekulize error... + # For hydronium we get a valence error... + errmolnames = ["chlorophyl", "chymotrypsin", "o_hydroxybenzoate", "hydronium"] + err_mols = {k: v for k, v in plams_mols.items() if k in errmolnames} # Everything else should match up to bond order level lvl2_mols = {k: v for k, v in plams_mols.items() if k not in lvl1_mols.keys() and k not in err_mols.keys()} @@ -230,6 +264,38 @@ def test_to_smiles_and_from_smiles_requires_rdkit_package(self, plams_mols, smil with pytest.raises(MissingOptionalPackageError): from_smiles(smiles[0]) + def test_to_image_and_get_reaction_image_can_generate_img_files(self, xyz_folder): + from pathlib import Path + import shutil + + # Given molecules + reactants = [Molecule(f"{xyz_folder}/reactant{i}.xyz") for i in range(1, 3)] + products = [Molecule(f"{xyz_folder}/product{i}.xyz") for i in range(1, 3)] + + # When create images for molecules and reactions + result_dir = Path("result_images/rdkit") + try: + shutil.rmtree(result_dir) + except FileNotFoundError: + pass + result_dir.mkdir(parents=True, exist_ok=True) + + for i, m in enumerate(reactants): + m.guess_bonds() + to_image(m, filename=f"{result_dir}/reactant{i+1}.png") + + for i, m in enumerate(products): + m.guess_bonds() + to_image(m, filename=f"{result_dir}/product{i+1}.png") + + get_reaction_image(reactants, products, filename=f"{result_dir}/reaction.png") + + # Then image files are successfully created + # N.B. for this test just check the files are generated, not that the contents is correct + for f in ["reactant1.png", "reactant2.png", "product1.png", "product2.png", "reaction.png"]: + file = result_dir / f + assert file.exists() + class TestPackmol: """ diff --git a/unit_tests/xyz/product1.xyz b/unit_tests/xyz/product1.xyz new file mode 100644 index 000000000..9c479f92e --- /dev/null +++ b/unit_tests/xyz/product1.xyz @@ -0,0 +1,5 @@ +3 + +O -0.0898298722 -0.1823078766 -0.4030695566 +H 0.0892757418 0.7223466689 -0.0923666662 +H 0.0251541304 -0.7229767923 0.3978492228 \ No newline at end of file diff --git a/unit_tests/xyz/product2.xyz b/unit_tests/xyz/product2.xyz new file mode 100644 index 000000000..6d6089de6 --- /dev/null +++ b/unit_tests/xyz/product2.xyz @@ -0,0 +1,18 @@ +16 + +C -0.5058742951 0.7197846249 1.4873502327 +O -1.8467123470 1.0371356691 1.5578617129 +O 0.2426104621 0.8031328420 2.4444063939 +H -1.2336711895 -0.1871011373 -3.0847664179 +H 1.1181735289 -0.9674586781 -3.3575709511 +O -2.2996282296 0.6761194013 -0.9441961430 +H 1.8534242875 -0.1774201547 0.8154069061 +H -2.5401517031 0.9226546484 -0.0164069755 +H 2.6629785819 -0.9669531279 -1.4040236989 +H -2.0724918515 1.3639645877 2.4489574275 +C -1.0116321368 0.2602883042 -0.9839670361 +C -0.5476048834 -0.1835433773 -2.2354228233 +C 0.7686298918 -0.6221529110 -2.3859139467 +C 1.6373720529 -0.6205255079 -1.2863630033 +C 1.1825135366 -0.1770749455 -0.0425597678 +C -0.1335817057 0.2638847621 0.1265310905 \ No newline at end of file diff --git a/unit_tests/xyz/reactant1.xyz b/unit_tests/xyz/reactant1.xyz new file mode 100644 index 000000000..81b5ba591 --- /dev/null +++ b/unit_tests/xyz/reactant1.xyz @@ -0,0 +1,6 @@ +4 + +H -0.2376962379 -0.7861223708 -0.7251893655 +H 0.2018867953 0.7880914552 -0.7285471665 +O -0.2208830412 0.0589617158 -0.1564035523 +H 0.2343924838 -0.0668018003 0.7570340842 \ No newline at end of file diff --git a/unit_tests/xyz/reactant2.xyz b/unit_tests/xyz/reactant2.xyz new file mode 100644 index 000000000..3e4b30bae --- /dev/null +++ b/unit_tests/xyz/reactant2.xyz @@ -0,0 +1,17 @@ +15 + + C 1.57069295 -0.27708399 0.90970331 + O 2.12128736 0.87456945 1.36157624 + O 2.07282352 -1.37947564 1.11228461 + H -1.99350927 2.19343258 -1.05192987 + H -3.07456482 0.09440138 -1.81135919 + O 0.21528019 2.32492362 0.26785454 + H 0.15858899 -2.19801533 -0.12644583 + H -1.98350403 -2.08943892 -1.37694501 + H 2.92149221 0.61570028 1.85487304 + C -0.27365246 1.24312943 -0.09274131 + C -1.53614397 1.22738446 -0.83792248 + C -2.13094250 0.06375743 -1.26848661 + C -1.51494870 -1.17520266 -1.01801439 + C -0.30749228 -1.23200960 -0.31149813 + C 0.30093635 -0.08278875 0.15391948