From a885c29e79cb33b8d7d11865d8e10f45cbaf395f Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Thu, 30 Nov 2023 23:15:05 -0500 Subject: [PATCH 1/9] Made a python file using code from compphys --- nacl_6and7.py | 109 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 nacl_6and7.py diff --git a/nacl_6and7.py b/nacl_6and7.py new file mode 100644 index 0000000..7abc8d3 --- /dev/null +++ b/nacl_6and7.py @@ -0,0 +1,109 @@ +# -*- coding: utf-8 -*- + +import numpy as np +import matplotlib.pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +import itertools +import scipy.optimize + + +ke2 = 197 / 137 # eV-nm Coulomb force charge +alpha = 1.09e3 # eV parameter of model +rho = 0.0321 # nm parameter of model +b = 1.0 # eV regular +c = 0.01 # nm + +# Helpful solution to convert itertools combinations to numpy arrays here: +## https://stackoverflow.com/questions/33282369/convert-itertools-array-into-numpy-array +def cp(l): + return np.fromiter( + itertools.chain(*itertools.combinations(l, 2)), dtype=int + ).reshape(-1, 2) + + +class Cluster: + def __init__(self, r_na, r_cl): + """ + Inputs the list of Na and Cl positions. Na has charge +1, Cl has -1. + The array of ions itself does not change throughout the calculation, and + neither do the charges. As such, we can just compute the combinations one time + and refer to it throughout the calculation. + """ + self.positions = np.concatenate((r_na, r_cl)) + self.charges = np.concatenate( + [np.ones(r_na.shape[0]), np.full(r_cl.shape[0], -1)] + ) + self.combs = cp(np.arange(self.charges.size)) + self.chargeprods = ( + self.charges[self.combs][:, 0] * self.charges[self.combs][:, 1] + ) + self.rij = np.linalg.norm( + self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 + ) + + def Vij(self): + """Calculate a numpy vector of all of the potentials of the combinations""" + self.Vij_ = np.zeros_like(self.rij) + pos = self.chargeprods > 0 + neg = ~pos + self.Vij_[pos] = ke2 / self.rij[pos] + b * (c / self.rij[pos]) ** 12 + self.Vij_[neg] = ( + -ke2 / self.rij[neg] + + alpha * np.exp(-self.rij[neg] / rho) + + b * (c / self.rij[neg]) ** 12 + ) + return self.Vij_ + + def V(self): + """Total potential, which is a sum of the Vij vector""" + return np.sum(self.Vij()) + + def get_vals(self): + """Positions interpreted as a flat shape""" + return np.reshape(self.positions, -1) + + def set_vals(self, vals): + """Inputs flat shape of positions, used by __call__""" + self.positions = vals.reshape(self.positions.shape) + self.rij = np.linalg.norm( + self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 + ) + + def __call__(self, vals): + """Function that scipy.optimize.minimize will call""" + self.set_vals(vals) + return self.V() + + +a = 0.2 + +r_na = np.array([[0, 0, 0], [a, a, 0]]) +r_cl = np.array([[a, 0, 0], [0, a, 0]]) + +cluster = Cluster(r_na, r_cl) +vals_init = cluster.get_vals() +print("initial Na positions:\n", r_na) +print("initial Cl positions:\n", r_cl) +print("initial positions flattened shape:\n", vals_init) +print("initial V :", cluster.V()) + + +res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method="BFGS") +cluster.set_vals( + res.x +) # For some reason, "minimize" is not updating the class at the last iteration +print("Final optimized cluster positions") +print(cluster.positions) +print("Final potential:", res.fun) + + +fig = plt.figure() +ax = fig.add_subplot(111, projection="3d") + +charges = cluster.charges +x, y, z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2] +ax.scatter(x, y, z, c=charges, cmap="coolwarm") +ax.set_xlabel("x") +ax.set_ylabel("y") +ax.set_zlabel("z") +plt.show() From 65e32d5f07f33266e3287766e6186a1ba54c3076 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 02:47:02 -0500 Subject: [PATCH 2/9] Deleted .py file in favor of making a jupyter notebook --- nacl_6and7.py | 109 -------------------------------------------------- 1 file changed, 109 deletions(-) delete mode 100644 nacl_6and7.py diff --git a/nacl_6and7.py b/nacl_6and7.py deleted file mode 100644 index 7abc8d3..0000000 --- a/nacl_6and7.py +++ /dev/null @@ -1,109 +0,0 @@ -# -*- coding: utf-8 -*- - -import numpy as np -import matplotlib.pyplot as plt -from mpl_toolkits.mplot3d import Axes3D -import itertools -import scipy.optimize - - -ke2 = 197 / 137 # eV-nm Coulomb force charge -alpha = 1.09e3 # eV parameter of model -rho = 0.0321 # nm parameter of model -b = 1.0 # eV regular -c = 0.01 # nm - -# Helpful solution to convert itertools combinations to numpy arrays here: -## https://stackoverflow.com/questions/33282369/convert-itertools-array-into-numpy-array -def cp(l): - return np.fromiter( - itertools.chain(*itertools.combinations(l, 2)), dtype=int - ).reshape(-1, 2) - - -class Cluster: - def __init__(self, r_na, r_cl): - """ - Inputs the list of Na and Cl positions. Na has charge +1, Cl has -1. - The array of ions itself does not change throughout the calculation, and - neither do the charges. As such, we can just compute the combinations one time - and refer to it throughout the calculation. - """ - self.positions = np.concatenate((r_na, r_cl)) - self.charges = np.concatenate( - [np.ones(r_na.shape[0]), np.full(r_cl.shape[0], -1)] - ) - self.combs = cp(np.arange(self.charges.size)) - self.chargeprods = ( - self.charges[self.combs][:, 0] * self.charges[self.combs][:, 1] - ) - self.rij = np.linalg.norm( - self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 - ) - - def Vij(self): - """Calculate a numpy vector of all of the potentials of the combinations""" - self.Vij_ = np.zeros_like(self.rij) - pos = self.chargeprods > 0 - neg = ~pos - self.Vij_[pos] = ke2 / self.rij[pos] + b * (c / self.rij[pos]) ** 12 - self.Vij_[neg] = ( - -ke2 / self.rij[neg] - + alpha * np.exp(-self.rij[neg] / rho) - + b * (c / self.rij[neg]) ** 12 - ) - return self.Vij_ - - def V(self): - """Total potential, which is a sum of the Vij vector""" - return np.sum(self.Vij()) - - def get_vals(self): - """Positions interpreted as a flat shape""" - return np.reshape(self.positions, -1) - - def set_vals(self, vals): - """Inputs flat shape of positions, used by __call__""" - self.positions = vals.reshape(self.positions.shape) - self.rij = np.linalg.norm( - self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 - ) - - def __call__(self, vals): - """Function that scipy.optimize.minimize will call""" - self.set_vals(vals) - return self.V() - - -a = 0.2 - -r_na = np.array([[0, 0, 0], [a, a, 0]]) -r_cl = np.array([[a, 0, 0], [0, a, 0]]) - -cluster = Cluster(r_na, r_cl) -vals_init = cluster.get_vals() -print("initial Na positions:\n", r_na) -print("initial Cl positions:\n", r_cl) -print("initial positions flattened shape:\n", vals_init) -print("initial V :", cluster.V()) - - -res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method="BFGS") -cluster.set_vals( - res.x -) # For some reason, "minimize" is not updating the class at the last iteration -print("Final optimized cluster positions") -print(cluster.positions) -print("Final potential:", res.fun) - - -fig = plt.figure() -ax = fig.add_subplot(111, projection="3d") - -charges = cluster.charges -x, y, z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2] -ax.scatter(x, y, z, c=charges, cmap="coolwarm") -ax.set_xlabel("x") -ax.set_ylabel("y") -ax.set_zlabel("z") -plt.show() From 5dd030d119180eae78c82b5d8a615a5d0c6b2e68 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 02:48:13 -0500 Subject: [PATCH 3/9] Created notebook for configurations 3 and 4 --- nacl_3_4.ipynb | 1 + 1 file changed, 1 insertion(+) create mode 100644 nacl_3_4.ipynb diff --git a/nacl_3_4.ipynb b/nacl_3_4.ipynb new file mode 100644 index 0000000..4bcfe98 --- /dev/null +++ b/nacl_3_4.ipynb @@ -0,0 +1 @@ +d From 6b224c3a2f530e0e298d20610ee7b9cf7d6aab37 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 03:16:25 -0500 Subject: [PATCH 4/9] Delete nacl_3_4.ipynb --- nacl_3_4.ipynb | 1 - 1 file changed, 1 deletion(-) delete mode 100644 nacl_3_4.ipynb diff --git a/nacl_3_4.ipynb b/nacl_3_4.ipynb deleted file mode 100644 index 4bcfe98..0000000 --- a/nacl_3_4.ipynb +++ /dev/null @@ -1 +0,0 @@ -d From f1ce64fca71dc7e300a46aeee8d1100863fe527d Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 03:17:33 -0500 Subject: [PATCH 5/9] Created 3, 4 notebook using Colaboratory --- configurations_3_4.ipynb | 254 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 254 insertions(+) create mode 100644 configurations_3_4.ipynb diff --git a/configurations_3_4.ipynb b/configurations_3_4.ipynb new file mode 100644 index 0000000..bdefa6d --- /dev/null +++ b/configurations_3_4.ipynb @@ -0,0 +1,254 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMEYv32+7Idw5ehdmp3SABo", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "1GeaDxEAXJ_T" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import itertools\n", + "import scipy.optimize" + ] + }, + { + "cell_type": "code", + "source": [ + "ke2 = 197 / 137 # eV-nm Coulomb force charge\n", + "alpha = 1.09e3 # eV parameter of model\n", + "rho = 0.0321 # nm parameter of model\n", + "b = 1.0 # eV regular\n", + "c = 0.01 # nm" + ], + "metadata": { + "id": "uZScXL7gXXXa" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def cp(l):\n", + " return np.fromiter(\n", + " itertools.chain(*itertools.combinations(l, 2)), dtype=int\n", + " ).reshape(-1, 2)\n", + "\n", + "class Cluster:\n", + " def __init__(self, r_na, r_cl):\n", + " \"\"\"\n", + " Inputs the list of Na and Cl positions. Na has charge +1, Cl has -1.\n", + " The array of ions itself does not change throughout the calculation, and\n", + " neither do the charges. As such, we can just compute the combinations one time\n", + " and refer to it throughout the calculation.\n", + " \"\"\"\n", + " self.positions = np.concatenate((r_na, r_cl))\n", + " self.charges = np.concatenate(\n", + " [np.ones(r_na.shape[0]), np.full(r_cl.shape[0], -1)]\n", + " )\n", + " self.combs = cp(np.arange(self.charges.size))\n", + " self.chargeprods = (\n", + " self.charges[self.combs][:, 0] * self.charges[self.combs][:, 1]\n", + " )\n", + " self.rij = np.linalg.norm(\n", + " self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1\n", + " )\n", + "\n", + " def Vij(self):\n", + " \"\"\"Calculate a numpy vector of all of the potentials of the combinations\"\"\"\n", + " self.Vij_ = np.zeros_like(self.rij)\n", + " pos = self.chargeprods > 0\n", + " neg = ~pos\n", + " self.Vij_[pos] = ke2 / self.rij[pos] + b * (c / self.rij[pos]) ** 12\n", + " self.Vij_[neg] = (\n", + " -ke2 / self.rij[neg]\n", + " + alpha * np.exp(-self.rij[neg] / rho)\n", + " + b * (c / self.rij[neg]) ** 12\n", + " )\n", + " return self.Vij_\n", + "\n", + " def V(self):\n", + " \"\"\"Total potential, which is a sum of the Vij vector\"\"\"\n", + " return np.sum(self.Vij())\n", + "\n", + " def get_vals(self):\n", + " \"\"\"Positions interpreted as a flat shape\"\"\"\n", + " return np.reshape(self.positions, -1)\n", + "\n", + " def set_vals(self, vals):\n", + " \"\"\"Inputs flat shape of positions, used by __call__\"\"\"\n", + " self.positions = vals.reshape(self.positions.shape)\n", + " self.rij = np.linalg.norm(\n", + " self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1\n", + " )\n", + "\n", + " def __call__(self, vals):\n", + " \"\"\"Function that scipy.optimize.minimize will call\"\"\"\n", + " self.set_vals(vals)\n", + " return self.V()" + ], + "metadata": { + "id": "T2pmvPVZXZpg" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Determining Optimized Configurations\n", + "\n", + "From here we have two paths to follow. The method I used for determining the optimal configurations for 3 and 4 is essentially a brute force method. The following block initializes random positions for all Na and Cl ions, then optimizes. It checks to see if the potential is around the range we expect, as well as excluding several common configurations we were not searching for (see the relevant comments.) The result is that the loop runs indefinitely until it finds a configuration that works, with some being somewhat strange, and some being the desired configurations. In our case #3 and #4 from the paper." + ], + "metadata": { + "id": "-riHDt7ZXl7p" + } + }, + { + "cell_type": "code", + "source": [ + "a = 0.2\n", + "\n", + "while True:\n", + "\n", + " r_na = np.random.rand(4, 3)\n", + " r_cl = np.random.rand(4, 3)\n", + "\n", + " cluster = Cluster(r_na, r_cl)\n", + " vals_init = cluster.get_vals()\n", + " # print(\"initial Na positions:\\n\", r_na)\n", + " # print(\"initial Cl positions:\\n\", r_cl)\n", + " # print(\"initial positions flattened shape:\\n\", vals_init)\n", + " # print(\"initial V :\", cluster.V())\n", + "\n", + " res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method=\"BFGS\")\n", + " cluster.set_vals(\n", + " res.x\n", + " ) # For some reason, \"minimize\" is not updating the class at the last iteration\n", + "\n", + " if (\n", + " res.fun < -26.9999\n", + " and not np.isclose(res.fun, -28.2358, 0.0005) # cubic potential\n", + " and not np.isclose(res.fun, -26.1369, 0.0005) # just a straight line...\n", + " and not np.isclose(res.fun, -27.7824, 0.0005) # octagon\n", + " ):\n", + " break\n", + "print(\"Final optimized cluster positions\")\n", + "print(cluster.positions)\n", + "print(\"Final potential:\", res.fun)" + ], + "metadata": { + "id": "_WPPizyPXgL3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Once the optimal configurations are determined and logged, we can then simply plot them using the same method without the guesswork. For the rectangular" + ], + "metadata": { + "id": "sug0P3bmZwXh" + } + }, + { + "cell_type": "code", + "source": [ + "r_na = np.array([[0.34208776, 0.11363288, 0.08778884],\n", + " [0.60453043, 0.18689002, 0.73993221],\n", + " [0.2680503 , 0.48180208, 0.41112085],\n", + " [0.21504881, 0.17410125, 0.19846736]])\n", + "\n", + "r_cl = np.array([[6.85172252e-01, 7.43407844e-01, 5.63663853e-01],\n", + " [6.68399008e-01, 2.68417208e-01, 8.71809252e-02],\n", + " [3.16302762e-01, 1.16067563e-01, 2.93976875e-04],\n", + " [3.96530654e-01, 1.65817255e-01, 1.15196282e-01]])\n", + "\n", + "cluster = Cluster(r_na, r_cl)\n", + "vals_init = cluster.get_vals()\n", + "\n", + "res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method=\"BFGS\")\n", + "cluster.set_vals(\n", + " res.x\n", + " )\n", + "\n", + "%matplotlib inline\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "charges = cluster.charges\n", + "x,y,z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2]\n", + "ax.scatter( x,y,z, c=charges, cmap='coolwarm' )\n", + "ax.text(1, 1, 1, 'Final Potential: -27.72984', color='red')\n", + "ax.set_title('Configuration 3 - Rectangular')\n", + "ax.set_xlabel('x')\n", + "ax.set_ylabel('y')\n", + "ax.set_zlabel('z')\n", + "plt.show()\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 437 + }, + "id": "isG4DNcFZvBS", + "outputId": "b65b5d0b-0616-4842-d58d-59b576341d0d" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "Dpohbm4KabcM" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 130a7b1e58f01c21ffdb618996f59a384f849ab4 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 03:32:12 -0500 Subject: [PATCH 6/9] Created Revised Version using Colaboratory --- configurations_3_4.ipynb | 130 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 120 insertions(+), 10 deletions(-) diff --git a/configurations_3_4.ipynb b/configurations_3_4.ipynb index bdefa6d..67a8637 100644 --- a/configurations_3_4.ipynb +++ b/configurations_3_4.ipynb @@ -4,7 +4,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyMEYv32+7Idw5ehdmp3SABo", + "authorship_tag": "ABX9TyMn4DE31+2Z6VnAEt/cTT5h", "include_colab_link": true }, "kernelspec": { @@ -26,9 +26,24 @@ "\"Open" ] }, + { + "cell_type": "markdown", + "source": [ + "# Finding Equilibrium Configurations for NaCl\n", + "\n", + "Note: Optimization functions are largely taken from https://github.com/ubsuny/CompPhys/blob/main/MinMax/nacl.ipynb\n", + "\n", + "Here we aim to find the equilibrium positions of the third and fourth configurations of the NaCl tetrameters as shown in this paper (https://pubs.aip.org/aapt/ajp/article/66/3/231/1044856/Evolving-few-ion-clusters-of-Na-and-Cl)\n", + "\n", + "I opted to use a randomized guess to find the most stable configurations, then selected those most similar to the two I was seeking. The definitions below are all from the cited notebook." + ], + "metadata": { + "id": "EtEvUmvyfesO" + } + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": { "id": "1GeaDxEAXJ_T" }, @@ -41,6 +56,13 @@ "import scipy.optimize" ] }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "cR0FdXbRgA1B" + } + }, { "cell_type": "code", "source": [ @@ -53,7 +75,7 @@ "metadata": { "id": "uZScXL7gXXXa" }, - "execution_count": 5, + "execution_count": 3, "outputs": [] }, { @@ -120,7 +142,7 @@ "metadata": { "id": "T2pmvPVZXZpg" }, - "execution_count": 6, + "execution_count": 4, "outputs": [] }, { @@ -168,10 +190,31 @@ "print(\"Final potential:\", res.fun)" ], "metadata": { - "id": "_WPPizyPXgL3" + "id": "_WPPizyPXgL3", + "outputId": "44060b7c-b66a-4a2e-90f6-580ff1286fcc", + "colab": { + "base_uri": "https://localhost:8080/" + } }, - "execution_count": null, - "outputs": [] + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Final optimized cluster positions\n", + "[[ 0.29080935 0.38842798 0.6701392 ]\n", + " [ 0.28860656 0.2112047 -0.10049432]\n", + " [ 0.43670676 0.40617825 0.33924627]\n", + " [ 0.14273259 0.19342553 0.23040046]\n", + " [ 0.36971515 0.31186562 0.11353969]\n", + " [ 0.4873078 0.49095195 0.56897054]\n", + " [ 0.20972141 0.28774438 0.45610812]\n", + " [ 0.09211242 0.10866851 0.00067172]]\n", + "Final potential: -27.729842280010452\n" + ] + } + ] }, { "cell_type": "markdown", @@ -225,9 +268,9 @@ "height": 437 }, "id": "isG4DNcFZvBS", - "outputId": "b65b5d0b-0616-4842-d58d-59b576341d0d" + "outputId": "cdc37c7d-e442-44a0-a9a6-386a32ae253b" }, - "execution_count": 15, + "execution_count": 6, "outputs": [ { "output_type": "display_data", @@ -241,11 +284,78 @@ } ] }, + { + "cell_type": "markdown", + "source": [ + "And then for configuration 4 we have the same deal" + ], + "metadata": { + "id": "5lshOIS8ejy7" + } + }, + { + "cell_type": "code", + "source": [ + "r_na = np.array([[0.65287885, 0.59653953, 0.41133422],\n", + " [0.49587511, 0.52735101, 0.31884368],\n", + " [0.06693635, 0.64654088, 0.33324918],\n", + " [0.61851165, 0.39232723, 0.57213152]])\n", + "\n", + "r_cl = np.array([[0.19212266, 0.73724567, 0.60953698],\n", + " [0.74117061, 0.32366411, 0.24546768],\n", + " [0.25779923, 0.13569068, 0.49482468],\n", + " [0.0475842 , 0.50957145, 0.50969428]])\n", + "\n", + "cluster = Cluster(r_na, r_cl)\n", + "vals_init = cluster.get_vals()\n", + "\n", + "res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method=\"BFGS\")\n", + "cluster.set_vals(\n", + " res.x\n", + " )\n", + "\n", + "%matplotlib inline\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "\n", + "charges = cluster.charges\n", + "x,y,z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2]\n", + "ax.scatter( x,y,z, c=charges, cmap='coolwarm' )\n", + "ax.text(1, 1, 1, 'Final Potential: -27.33085', color='red')\n", + "ax.set_title('Configuration 4')\n", + "ax.set_xlabel('x')\n", + "ax.set_ylabel('y')\n", + "ax.set_zlabel('z')\n", + "plt.show()" + ], + "metadata": { + "id": "Dpohbm4KabcM", + "outputId": "af502caf-59ce-44b3-c092-451b883f34bd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 431 + } + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, { "cell_type": "code", "source": [], "metadata": { - "id": "Dpohbm4KabcM" + "id": "Sx0i99WZfZ1u" }, "execution_count": null, "outputs": [] From decd611f1a3dae9c9b16d65a28c7430d639c6db6 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 03:36:09 -0500 Subject: [PATCH 7/9] Fixed some text errors --- configurations_3_4.ipynb | 36 ++++++++++++++++++++++++------------ 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/configurations_3_4.ipynb b/configurations_3_4.ipynb index 67a8637..e6ac0e6 100644 --- a/configurations_3_4.ipynb +++ b/configurations_3_4.ipynb @@ -4,7 +4,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyMn4DE31+2Z6VnAEt/cTT5h", + "authorship_tag": "ABX9TyPK0WoBMFGCECTBuGC6DlRu", "include_colab_link": true }, "kernelspec": { @@ -35,7 +35,9 @@ "\n", "Here we aim to find the equilibrium positions of the third and fourth configurations of the NaCl tetrameters as shown in this paper (https://pubs.aip.org/aapt/ajp/article/66/3/231/1044856/Evolving-few-ion-clusters-of-Na-and-Cl)\n", "\n", - "I opted to use a randomized guess to find the most stable configurations, then selected those most similar to the two I was seeking. The definitions below are all from the cited notebook." + "I opted to use a randomized guess to find the most stable configurations, then selected those most similar to the two I was seeking. The definitions below are all from the cited notebook.\n", + "\n", + "Final note to reader: Plots are still rendering incorrectly (though they render correctly for me on my machine), still trying to figure that one out." ], "metadata": { "id": "EtEvUmvyfesO" @@ -43,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": { "id": "1GeaDxEAXJ_T" }, @@ -75,7 +77,7 @@ "metadata": { "id": "uZScXL7gXXXa" }, - "execution_count": 3, + "execution_count": 13, "outputs": [] }, { @@ -142,7 +144,7 @@ "metadata": { "id": "T2pmvPVZXZpg" }, - "execution_count": 4, + "execution_count": 14, "outputs": [] }, { @@ -196,7 +198,7 @@ "base_uri": "https://localhost:8080/" } }, - "execution_count": 5, + "execution_count": null, "outputs": [ { "output_type": "stream", @@ -219,6 +221,7 @@ { "cell_type": "markdown", "source": [ + "## Plotting Optimal Configurations\n", "Once the optimal configurations are determined and logged, we can then simply plot them using the same method without the guesswork. For the rectangular" ], "metadata": { @@ -268,9 +271,9 @@ "height": 437 }, "id": "isG4DNcFZvBS", - "outputId": "cdc37c7d-e442-44a0-a9a6-386a32ae253b" + "outputId": "ca5d5288-ebbe-45da-ad4b-915073463d7e" }, - "execution_count": 6, + "execution_count": 15, "outputs": [ { "output_type": "display_data", @@ -322,7 +325,7 @@ "charges = cluster.charges\n", "x,y,z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2]\n", "ax.scatter( x,y,z, c=charges, cmap='coolwarm' )\n", - "ax.text(1, 1, 1, 'Final Potential: -27.33085', color='red')\n", + "ax.text(.15, .15, .25, 'Final Potential: -27.33085', color='red')\n", "ax.set_title('Configuration 4')\n", "ax.set_xlabel('x')\n", "ax.set_ylabel('y')\n", @@ -331,13 +334,13 @@ ], "metadata": { "id": "Dpohbm4KabcM", - "outputId": "af502caf-59ce-44b3-c092-451b883f34bd", + "outputId": "9b4eb068-fd09-4eda-f2f6-223b4f67f6f6", "colab": { "base_uri": "https://localhost:8080/", "height": 431 } }, - "execution_count": 9, + "execution_count": 16, "outputs": [ { "output_type": "display_data", @@ -345,12 +348,21 @@ "text/plain": [ "
" ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAGeCAYAAACgibcyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2GUlEQVR4nOy9eXgb5bn+f2uxvO+W13jfktjxvsRhp4GwJ7T0AOe0gZRyKBRKm7YUCg2U0lJoS0MLlJbvKaH01x7aEnYISyCsKQHb8r7vqyRrsS3J1jbz+yPnHSRZsrWMNGN7PteVq0WWNKPtved53vt5HhFN0zQEBAQEBASCjJjrExAQEBAQ2BwIgiMgICAgEBIEwREQEBAQCAmC4AgICAgIhARBcAQEBAQEQoIgOAICAgICIUEQHAEBAQGBkCAIjoCAgIBASBAER0BAQEAgJAiCI8A7BgYGcOGFFyI+Ph4ikQgvvvgijhw5ApFIhNHRUa5Pz29OnDgBkUiEEydOcH0qAgKcIAiOgFuGhoZw0003oaCgABEREYiLi8MZZ5yBRx99FEtLS0E99nXXXYeOjg78/Oc/x7PPPou6urqgHo9tnnjiCRw5coTr0/CI1WrF9u3bIRKJ8Otf/5rr0xHYREi5PgEB/vHaa6/hq1/9KsLDw7F//36Ul5fDYrHgo48+wg9/+EN0dXXhT3/6U1COvbS0hJMnT+Luu+/Grbfeytz+9a9/Hddccw3Cw8ODclw2eeKJJ5CSkoLrr7/e6fazzz4bS0tLkMlk3JzY//H73/8e4+PjnJ6DwOZEEBwBJ0ZGRnDNNdcgNzcX7777LjIyMpi/ffvb38bg4CBee+21oB1frVYDABISEpxul0gkkEgkQTuuJ2iaxvLyMiIjIwN+LrFYjIiICBbOyn9UKhXuv/9+/OhHP8KhQ4c4PReBzYeQUhNw4uGHH4bBYMD//M//OIkNoaioCLfffjvz3zabDT/72c9QWFiI8PBw5OXl4cc//jHMZrPT4/Ly8nDZZZfho48+QkNDAyIiIlBQUIC//OUvzH3uu+8+5ObmAgB++MMfQiQSIS8vDwDc7uFQFIX77rsPmZmZiIqKwnnnnYfu7m7k5eU5RRf33XcfRCLRitfi7jnJeb755puoq6tDZGQk/vjHPwIAnn76aZx//vlITU1FeHg4tm/fjj/84Q8rXmdXVxfef/99iEQiiEQinHvuuQA87+H885//RG1tLSIjI5GSkoKvfe1rmJqacrrP9ddfj5iYGExNTWHfvn2IiYmBXC7HD37wA9jt9hWvzRN33nknSktL8bWvfc3rxwgIsIUQ4Qg48corr6CgoAC7du3y6v7f/OY38cwzz+Cqq67C97//fXz66ad48MEH0dPTgxdeeMHpvoODg7jqqqtwww034LrrrsOf//xnXH/99aitrUVZWRm+/OUvIyEhAd/73vdw7bXX4pJLLkFMTIzHY9911114+OGHcfnll2PPnj1oa2vDnj17sLy8HNB70NfXh2uvvRY33XQTbrzxRpSWlgIA/vCHP6CsrAxXXHEFpFIpXnnlFdxyyy2gKArf/va3AQCHDx/GbbfdhpiYGNx9990AgLS0NI/HOnLkCA4cOID6+no8+OCDUCqVePTRR/Hxxx+jtbXVKdKz2+3Ys2cPGhsb8etf/xrvvPMOfvOb36CwsBA333zzmq/r1KlTeOaZZ/DRRx+5FWABgaBDCwj8H/Pz8zQAeu/evV7dX6FQ0ADob37zm063/+AHP6AB0O+++y5zW25uLg2A/uCDD5jbVCoVHR4eTn//+99nbhsZGaEB0L/61a+cnvPpp5+mAdAjIyM0TdP07OwsLZVK6X379jnd77777qMB0Ndddx1z27333ku7+6q7PqfjeR47dmzF/U0m04rb9uzZQxcUFDjdVlZWRp9zzjkr7vvee+/RAOj33nuPpmmatlgsdGpqKl1eXk4vLS0x93v11VdpAPShQ4eY26677joaAH3//fc7PWd1dTVdW1u74liuUBRFNzQ00Ndeey1N057fZwGBYCKk1AQYFhYWAACxsbFe3f/1118HABw8eNDp9u9///sAsGKvZ/v27TjrrLOY/5bL5SgtLcXw8LDP53r8+HHYbDbccsstTrffdtttPj+XK/n5+dizZ8+K2x33cebn5zE3N4dzzjkHw8PDmJ+f9/k4n3/+OVQqFW655RanvZ1LL70UW7dudbtX9q1vfcvpv8866yyv3r8jR46go6MDDz30kM/nKSDAFoLgCDDExcUBABYXF726/9jYGMRiMYqKipxuT09PR0JCAsbGxpxuz8nJWfEciYmJ0Ol0Pp8reW7XYyclJSExMdHn53MkPz/f7e0ff/wxdu/ejejoaCQkJEAul+PHP/4xAPglOOQ1kJSdI1u3bl3x/kVEREAulzvd5s37t7CwgLvuugs//OEPkZ2d7fN5CgiwhbCHI8AQFxeHzMxMdHZ2+vQ4b/cDPLnM6CBPOfd0fp4229050oaGhvClL30JW7duxSOPPILs7GzIZDK8/vrr+O1vfwuKolg9Z3f469L79a9/DYvFgquvvpoxSExOTgIAdDodRkdHkZmZybldW2DjI0Q4Ak5cdtllGBoawsmTJ9e8b25uLiiKwsDAgNPtSqUSer2ecZwFA/Lcg4ODTrdrNJoVV/wk4tHr9U63u0YQq/HKK6/AbDbj5Zdfxk033YRLLrkEu3fvditO3goweQ19fX0r/tbX18fa+zc+Pg6dToeysjLk5+cjPz+fSW3+4he/QH5+Prq7u1k5loDAagiCI+DEHXfcgejoaHzzm9+EUqlc8fehoSE8+uijAIBLLrkEwGlnliOPPPIIgNN7EcHiS1/6EqRS6Qpb8mOPPbbivoWFhQCADz74gLnNaDTimWee8fp4JLpwjMbm5+fx9NNPr7hvdHT0CnFzR11dHVJTU/Hkk0862cjfeOMN9PT0sPb+fec738ELL7zg9I9Yva+//nq88MILHtOIAgJsIqTUBJwoLCzE3/72N1x99dXYtm2bU6eBTz75BP/85z+ZGpfKykpcd911+NOf/gS9Xo9zzjmHsd7u27cP5513XtDOMy0tDbfffjt+85vf4IorrsBFF12EtrY2vPHGG0hJSXGKMi688ELk5OTghhtuwA9/+ENIJBL8+c9/hlwu97ri/sILL4RMJsPll1+Om266CQaDAU899RRSU1MxMzPjdN/a2lr84Q9/wAMPPICioiKkpqbi/PPPX/GcYWFheOihh3DgwAGcc845uPbaaxlbdF5eHr73ve8F9ib9HzU1NaipqXG6jaTWysrKsG/fPlaOIyCwFoLgCKzgiiuuQHt7O371q1/hpZdewh/+8AeEh4ejoqICv/nNb3DjjTcy9/1//+//oaCgAEeOHMELL7yA9PR03HXXXbj33nuDfp4PPfQQoqKi8NRTT+Gdd95BU1MT3nrrLZx55plOrq+wsDC88MILuOWWW/CTn/wE6enp+O53v4vExEQcOHDAq2OVlpbiX//6F+655x784Ac/QHp6Om6++WbI5XJ84xvfcLrvoUOHMDY2hocffhiLi4s455xz3AoOcDrCiIqKwi9/+Uv86Ec/QnR0NK688ko89NBDK7otCAisd0R0sHdsBQRCiF6vR2JiIh544AGm8FJAQIAfCHs4AusWd12ryX4SaScjICDAH4SUmsC65bnnnsORI0eYFjgfffQR/v73v+PCCy/EGWecwfXpCQgIuCAIjsC6paKiAlKpFA8//DAWFhYYI8EDDzzA9akJCAi4QdjDERAQEBAICcIejoCAgIBASBAER0BAQEAgJAiCIyAgICAQEgTBERAQEBAICYLgCAgICAiEBEFwBAQEBARCgiA4AgICAgIhQRAcAQEBAYGQIAiOgICAgEBIEARHQEBAQCAkCIIjICAgIBASBMEREBAQEAgJguAICAgICIQEQXAEBAQEBEKCIDgCAgICAiFBEBwBAQEBgZAgCI6AgICAQEgQBEdAQEBAICQIgiMgICAgEBIEwREQEBAQCAmC4AgICAgIhARBcAQEBAQEQoIgOAICAgICIUEQHAEBAQGBkCAIjoCAgIBASBAER0BAQEAgJAiCIyAgICAQEgTBERAQEBAICYLgCAgICAiEBEFwBAQEBARCgiA4AiGHpmnYbDZQFMX1qQgICIQQKdcnILC5oCgKFosFJpMJYrEYUqkUUqkUEokEEokEYrFwDSQgsFER0TRNc30SAhsfmqZht9thtVpB0zQsFgtEIhEoigL5CgoCJCCwsREERyDo0DQNq9UKu93O3GaxWJzEhKZpRnxomoZIJIJIJBIESEBgAyEIjkDQICJCohoiIuQ2kUi05mMdv54URcFutyMuLg4SiQRSqXTV5xAQEOAXwh6OQFAgxgCbzQYAjNg4/p3c7g6RSASJROJ0/4WFBXR3d6OxsREikQhisZgRHhIFCQIkIMBfBMERYB0SwRAXGhtpMEcBCgsLc4qeyH4QEaCwsDAmBScIkIAAfxAER4A1HEWAoiiIxWJWF3zH53IUIBItuRMg1z0gQYAEBLhDEBwBVnA1BrAtNo7HcYUcx50AWSwWmM1mQYAEBHiAIDgCAUMiC7vdHjShATzv93i6nzsBMpvNsFgsANzbsAUBEhAIHoLgCPiNa22Nt2ITyKLuj6nSUYAkEgljvaZpeoUAkf0fqVQaVPEUENiMCIIj4BeBptD8WcjZWvwdHXOuArS8vMzchwgQiYAEARIQCAxBcAR8hkQ1wTAGrEUwysa8ESC9Xo/w8HAkJiYKAiQg4CeC4Ah4jWttTagX3FAdy50Azc7OIjY2FpGRkcx9XGuABAESEFgdQXAEvMK1tsa1kDNUcNEYg7xWkmIj0Q9FUUwEJBaLV5gQBAESEHBGEByBVQl2bY0v8GXx9pSCs9vtsNvtWF5eFgRIQMANguAIeISmaRgMBkxPTyMnJ4cXCyYfW/85RkAAVggQqQMiKTjHPnBcv58CAqFEEBwBt5CoxmQyYXBwEHl5eVyfEqeLsy9C50mAbDYb07TU3R6QIEACGx1BcAScIFfmZCInSRnxBT6di7f4IkCOfeCEUQwCGw1BcAQYPNXW8GWR3yhX/4IACWxWBMERAOC5tkYsFvNGcAhkts5GYS0BUqvVkMlkkMvlwjA6gXWNIDibHMfaGnftaUiEw4dFnuvjhwpXAdLpdIiKikJCQgLTCVuYhiqwHhEEZxNDURRsNtuq7WnIf7MtOIGk6rgSPy4FjwgM4GxVt1qtTn93dcEJCPAJQXA2IZ5GP7vDMc3DNZt1AXUVWHfTUF1nATkKkDANVYAvCIKzyVhr9LMrjhEOX+DTuYSCtSI6bwRImIYqwAcEwdlE+DO3htyHtLThks28QPraidsbARJmAQmEGkFwNgGutTW+dAzgU0qNwKdzCQWBvl5P47iFaagCoUYQnA0OW3Nr+LDIb+YFkM1ZQIAwjluAGwTB2cCQRYSNppt8EBwCn84lFATz9boTIMdpqCaTCePj4ygsLHQaRicIkIA/CIKzAfF39LM7iKmAD4v8Zl3gQmkDd+2EbbVaMTk5icLCQpjNZqcISJiGKuArguBsMAJNoblDJBLxwjRA4IP4hRqua4BIVCOM4xYIBEFwNhCOUQ2bnYeD1d7G1yv3zbqAcSmw7mqA1hrHLUxDFfCEIDgbAF9ra3yFLyk1Ap/OJRRw2VaIpGQ94UmAhGmoAu4QBGed4zr6ORj9tPgiOMICFXooivI5CvUkQGazWZiGuskRBGedEsrRz8IeDrdwHeEEcmzXaNvTNFSyByRMQ93YCIKzDgmGMWA1+DKiYL1M/AwG61VwXPE0ioEUJgvTUDc2guCsM/xpTxMofEmpEfh0LqGAT6YBtllrFhBFUZidnUVOTg5kMpkwimGdIwjOOoEU4qlUKqSkpIQ05812Sm1hYQFdXV2QSqVISkpCYmIiYmJifOrttpngOqUWysXdVYCWlpYwNDSEzMzMFRGQMA11/SEIzjqApNAMBgPa2tpwwQUXhHQBYivCoWkak5OT6O3tRXZ2NiQSCXQ6HUZGRiAWi5GYmIjExEQkJSUhMjJy1efZbHAlOL6aBtiGiG1YWBjz344REAC3bXgEAeInguDwHMfRzxKJhJMFgI09HJvNhu7ubszNzaGmpgaxsbGgKAq5ubmgKAoLCwvQ6XSYnZ1Ff38/wsPDGfFJTEyETCYDsHkjHC6PzbXgOIqHpxScp1lAggDxC0FweIprbQ2xkpK/racIZ3FxEQqFAjKZDLt27UJERARzdQqcfm0JCQlISEhAfn4+7HY79Ho9tFotxsbG0NXVhejoaCQlJTHvCxdwXe3PBVwLzloXWO4ESJiGyl8EweEhrrU1rj8qEu2EikD2cKamptDd3Y3c3FwUFRV5daUpkUiQnJyM5ORkAIDFYmEEiKZpNDc3Iy4ujknBxcfHb+gr2M0c4RDLv7cI01D5jSA4PGKt2houBcfXRc9ut6O7uxsqlQpVVVWQy+V+H18mkyE1NRWpqalQKpUoLy+H2WyGTqfD9PQ0bDYbEhISmBSctwaE9QKXi76vCz7fji9MQ+UXguDwBG9qaxwFJ5T4uodjMBigUCgglUqxa9euVQ0AviISiRAeHo7k5GRkZmaCpmkYjUbodDrodDqMjo4yKTqy/xMZGbnuF5DNnFJjU/C8FSBhFlBwEASHB3hbW0NuD7Xg+BLhzMzMoLOzEzk5OSguLva4WLA1m0ckEiEmJgYxMTHIzs4GRVFYXFyEVquFUqlEf38/ZDIZIz6JiYkIDw/3+9hcsJlTasG2ZTsKkKdhdBaLBWFhYYiOjhYEKEAEweEQX0c/k/wzHwXHbrejt7cXMzMzqKysRGpq6qr393cRXeuHLhaLER8fj/j4eCcDgk6nw8TEBLq7uxEdHc2IT2JiIqRSfv8MuK7D4TrCCWW9GbByGur4+DjEYjHy8/OFCChA+P1L28D4255GLBZzIjirHdNkMkGhUEAkEmHXrl2IiooK6vn4IlauBgSr1cqk34aGhrC0tITY2Fhm/ycuLi6k+2PeslkKP13hcg+JvOc0TTMCQ87JbDbDYrEAcF8HJAiQewTB4QDH2hpfOwZw0ddstWPOzs6is7MTWVlZKC0tDfriEOgPOSwsjDEgAMDy8jJ0Oh20Wi26urpgs9kQHx/PpOBiY2M5Xzw2c0qNa9MCcPr36igi7obRuZuGSizYQifsLxAEJ4Q41tb4O/qZqwjHddGjKAp9fX2YmppCeXk50tPTQ3Y+bC7AERERyMjIQEZGBmiahslkglarhU6nw9jYGAAgMTERS0tLsFgsnCzAXLvUNrvgeDoHT6MYhGmonhEEJ0RQFAWbzRZwh2c+CM7S0hIUCgUoikJTUxOio6NDei7BfO7o6GhER0czBgSDwQCtVgu9Xo+xsTHMzMw4teAJlQFhs+7hcJ3SA76IcNbCWwHazNNQBcEJMo62SzZGP3O9h6NSqdDR0YH09HRs3bqVk/2OUKWYxGIx4uLiEBcXh4WFBSQkJCAmJgY6nQ6Tk5Po6elBVFQUIz4JCQlMzy822ewpNa4XY3+jLE8C5DgNdbMJkCA4QSQYo5+5EBxyzL6+PoyPj6OsrAyZmZkhPQcClz9EsViMpKQkJCUlobCwEFarlXHADQ0NwWQyITY2ltn/iY+PZ02QBdMAd7B1DqsJ0GaZhioITpAI1twaLmzRdrsdKpUKYWFhaGpqQkxMTMDPyVYdDpeEhYVBLpczXRTMZjOz/9PT0wOr1Yr4+HgmAvLXgMDl6+U6wuCD4HibUvMV1wvQ1aahvvbaa9ixYwfKy8tZP49QIggOy/haW+MroXapzc3NYXZ2FpGRkWhqauLcMszllf5ahIeHrzAgEAv2+Pg4ADi14ImKivLq9Wz2OhyuBSdU5+CpE7bdbsdvf/tbfOc73xEER+ALQjH6OVQpNZqmMTg4iNHRUSQmJjJV1nyALxHOajgaELZs2QKaprG4uAidToe5uTkMDQ1BKpU6jWCIiIhY9fm4gOuUGtfHB0Lfu5DgKEAmk4mVzALXCILDEqQdRjCiGkdCIThmsxltbW0wm83YuXMn0yCTTfx9f9ZrLlskEjEGhNzcXNjtdiwsLECr1WJqagq9vb2IjIx06oDgOHSMK/gQ4XB9oUPS4lxB+gUKgiPAhLzEhRbsDb5gC45Go0FbWxuSk5NRU1PDFK7xKarg07n4i0QiYYQFOD2gjqTfRkZG0NnZyXRAIBvLXMB1hLGZUmqrIQiOQEhSaK4ES3Bomsbw8DCGh4dRWlqK7Oxs5rVwYVTwxHqNcNZCKpWuMCAQAaJpGp9//vkKA0IoFsHNbhqgKAo0TXMeZQmCs8lxjGrYsDt7SzAWf4vFgvb2dphMJjQ2NiIuLm7FMdmOKsiGqL+P5YJQLrzh4eFIT09Heno60xB1aWkJWq0WExMToGnaaQRDdHR0UM6P65QaHyIsAJyfg8lkCmmBdbAQBMdHaJqGwWCAwWBAQkJCSMUGYD/C0el0UCgUSEhIQFNTk9vCRT6l1DZqhOMJ8r5HRUUhKSkJWVlZzHdQp9NBo9E4GRDIP7ZmEHEtOHyIcABwGuEYjUYAQGxsLGfnwBaC4PgAqa1Rq9UYHx9HU1NTyM+BrcWfpmmMjo5icHAQJSUlyMnJWXUOD18EB9gYezi+4vjZiEQixMbGIjY2Fjk5OaAoCvPz89DpdJiZmUFfXx8iIiKcOiDIZDK/jssHweHy+CRdzuU5EMERIpxNguvoZ6lUytmeBhsRjsViQUdHBxYXF1FfX4+EhIRV788nwdmsEc5qiMXiFQYE0gFhdHQUBoMBMTExjADFx8d7PQOIDyktro/P9bgBo9EImUy27gYHukMQnDVwZwzgor0MQSwWM+fiD3q9HgqFArGxsdi1a5dXV758Mg0AQoSzFlKpFCkpKUhJSQFw+gKDjGDo6+uD2WxGXFwcs/8TFxfncVHnOsLgWnC4tkQDpwXH2yJhviMIzip4ak8jkUgCWvQDQSwWw2q1+vw4mqYxNjaGgYEBFBUVIS8vz+svsLCHwx1svO8ymQxpaWlIS0sDAMZ8QJqQUhTFdEBITExETEyM0/CxzW4a4FpwDAbDhkinAYLguGWt9jQSiWRdpdSsVis6Ozuh1+tRV1fHpF68hU8pNWBzRTjktbK56EdGRiIrK2uFAYHUADmm6Ox2+6aPcPhiid4IF1uC4LjgTW1NoGmtQPA1vTU/Pw+FQoHo6GicccYZfm0eB0NwAuk0sJkEhxCsxcadAWFhYQE6nQ6zs7NYXFzEwMAAdDodk4Lz14DgD5s9pQdgw1iiAUFwnPB29DPXezjeLLg0TWNiYgJ9fX0oKChAQUFBQIs8n/ZwNhNcjBNPSEhAQkIC8vPzcerUKaSkpMBut2NsbAxdXV2MASExMREJCQleGxD8gesFnw8RjpBS22C4zq1Zq2OA4yyLUF99eSN2NpsNXV1d0Gq1qKmpQXJycsDH5EtUIUQ4oYWmacTFxTkZEPR6PbRaLQYGBrC8vIy4uDhGgOLj41kVCK4Fh+vjA6dTaoLgbBAc7c6Ad0PSyBfQbrcH9erO07FXE5zFxUW0trYiIiICu3btYsVKyaeU2maDa3F1vaiSyWRITU1FamoqgNMGBLL/Q5q8OnZACHTvQTANbJy2NsAmFhzX2hpf+qCREJuLNNNqgkPGHufl5aGoqIjVoW9cL3yEzSZUwTAN+Hr81Y4dGRmJyMhIZGZmMl2NXQ0IjgIUGRnp02vhesHnQ0pNiHDWOYE23XSMcEKNO8Gx2Wzo7u7G3NwcqqurmfQHWwRrD8ffRZQv4hdK+Co4johEIsTExCAmJgbZ2dmgKAqLi4vQarVQKpXo7++HTCZjxCcxMXHVCJykrYUIRxCcdQsbo5/JUCQuIhzXaMNgMEChUCAsLAy7du1adYiXv7C9h0Oahc7PzzPV70lJSV6dO58nfm6k4xICWXDFYjHi4+MRHx+P/Px82O12pgPCxMQEuru7ER0d7dQDzjFF7Zjm5go+zOMxGo1MDdV6Z9MIDtujn7myRjsK3fT0NLq6upCTk4Pi4uKgXYmxmVIjNu2YmBhs374d8/PzmJ6eRl9fHyIjIxnxWc39xPUiHEr4nlLzBYlEguTkZMbEYrVamfTb0NAQlpaWmBlAZAQ3wG2nZr50GhD2cNYRwZhbw1XxJxG6zs5OKJVKVFZWMhu4wYItwSF7TAUFBcjLy4PVakVycjIKCgpgtVpXuJ/i4+MZAYqNjQ15Z26+wHWlf7COHxYW5mRAWF5eZlrwdHV1Ma7RyclJp+9AKKEoym0H9VAi1OGsI7ytrfEVriIci8WC5eVlLC4uYteuXay1oV+NQPdwKIpCd3c3lEols8fk+nxhYWFOA8hI+xWtVovx8XEAQGJiIpaXl2GxWPx/MesMrqO5UFr/IyIikJGRgYyMDNA0zYzOWFhYcPoOkH+h6C9mt9uDkqb2BdJ8dSOwYQXHsbYmGKOfuYhwZmdn0dnZCZFIhMbGxpCF+oHs4SwtLUGhUACATwLp2n5lYWGB6f81MjKC2dlZJvpxzf1vJDZrLzORSISIiAiIxWJUVFQwBgSdTge1Wo3BwUGEhYUx4pOUlBSUbsp8MQ1shFk4wAYVHIqiYLPZgjr6OZQRDkVR6O3txfT0NIqLizE4OBjSH4G/KbW5uTm0tbUhLS0N27Zt83vzVSQSMZvPi4uLiI+PR3R0NLRaLZP7J8WHycnJQRu/zNXCz7XgcHV8x7Y2jgaEvLw82O12ZgYQSdWSIXWkAwIbqTA+mAZMJhOzn7Xe2VCC41hbE+zRz6GKcEwmk1OEQFEU+vv7g35cR3wVHJqmMTw8jOHhYWzbtg1btmxh9VzEYrFT+/3l5WUm/TY1NQWKopzcb77WfvAJLlNqXHXTIKwWXUgkEubzLSwsZPYAiQHBZDKt6IDgj3BwbRogtU1ChMMzXNvTBHuDORQRjkqlQnt7OzIzM7F161aIxWKYTKaQL0K+7OFYrVZmuFtDQwPi4+NZPx/X1x8REYHMzEym+JDUfqjVagwMDCA8PNwp/cb1JrCvcG0F5/L43i72rnuAZrOZScH29PTAarUiPj6euRDx1oDAhwhHcKnxDDZqa3wlmHU4JIqZmJhAeXk5MjIynI4b6itP8qNf65ikrU5UVBSampqC0lV4rdcsEokQFxeHuLg4JvVC3G8jIyPo7OxkrnzJ9Euuc/SrwXWEA3BnSw5k/yQ8PNzJgGAymRgLNjEgkBlAxILt7rvFdYQDCILDG9iurfGFYKXUlpaW0NbWBrvdjl27dq2wQ5IvfyivvLwZxkVqgthuq+MOXxZh19oPcuVLrLd2u51pvbLawsMVXKa0uI5w2NqwF4lEiI6ORnR0NLZs2cJEwTqdDnNzcxgaGoJUKmXEJzExkXGmcW0asNvtWF5eFmzRXBOM2hpfCEZKTa1Wo729fdVNdq4FxxWKotDX14epqal1URPkeuVrNBqh1Wqh0WgwNDSEsLAwZtFJSkoK6ewXT2xmwQnGsR2j4NzcXNjtdsYFOTU1hd7eXkRGRiIxMZHZD+YKg8EAAMIeDpdQFIXZ2VlERUUhIiKCkx8Em2OmKYrC4OAgxsbGsH37dmRlZXm8r6PghApPIre8vAyFQsFEY+vNSePY+ysnJ4dxPpHan+7ubsTExCApKcmpo3go4XKx47q1TKiiC4lEwpgLgNO9CUn6zWazoa2tjemAQBxwobrYMxqNACCk1LiApNCsViu6urqwbdu2kBQ+uoOtPZzl5WW0tbXBYrGgqalpzS8W+fGHcvFzF+FotVq0tbUhOTkZZWVlIY22grUIOzqfgNNFtiT9ZjAYMDAwgLm5OeY+0dHRIVmMN3OEw0U6SyqVMgaE6elpVFZWwmw2Q6fTobe3FxaLZYUBIVjnaTKZEBERsWHqzNbNq3BNoUmlUk6nUEokElit1oCeQ6PRoK2tDSkpKaitrfXqS0Xcd6G88nUUHJqmMTY2hoGBAZSWliI7O5tXex5sIpPJkJ6ejvT0dCwvLzMFplqtFsPDw5BKpU7pt2AUHnJtGuCynRDXnaJJmQVJr6Wnp4OmaWYGkFarxcTEBGiaduqAwOaFiMFg4N2+YiCsC8EhUY3jD4DNlJY/BLKHQ9M0hoaGMDIygm3btiErK8vn8QhcRDhWqxU9PT3Q6XSor69HQkJCyM7B8Vy4WIRFIhHCw8ORmZnJtN4n6TdSeBgdHe3UfJSNqI9r0wDXnZq5Hk0AOLv0RCIRoqKiEBUVxXTBMBgM0Ol0zD4gMSCQf4FkYTbSeGmA54KzWm2NRCJhbucCf11qZrMZ7e3tWFpaQmNjI+Li4nx+Dq4Ep6WlhdVJousZsVjMLCik8JAsOn19fTCbzU7ut0AmX260Tfv1dHwAq144iEQixMbGIjY2Fjk5OcyFiE6nw8zMDPr6+hAREcFEwQkJCT4ZUYglWohwgozr6GfXK531GOGQfY/ExERUV1f7nZcNteAolUoAQFJSErZv387pVSdff3iOnY9J2oXs/4yOjjIC5cvsH0CIcLi2JAO+1SE5XogApw0IpAPCyMgIIyCOArSaoG2ktjYADwXH29HPXAuOLxEOTdMYGRnB0NAQK/seoRIciqIwMDCAiYkJiMVi5OXlcV4Ex6dx155wTLts2bIFFEUxttv1NPtnswsOG7V9UqnUqQ2TxWJh9n9IJBwXF8fsBcbFxTm95o3UKRoAeFViTYwBFotlzQ7PXAuOtxGOxWJBS0sLJiYm0NDQgJycnIB/xMEa+eyI2WzG559/DpVKhZ07d7I+9XMzIRaLkZCQgIKCAtTV1eHMM89EYWEhaJrGwMAAPvzwQ7S0tGB0dBQLCwsr3ufNvGnPdYTD9vFlMhlTZ7dr1y7s3LkT6enpMBqN6OjowIcffoi2tjYMDQ3h1KlTWFxc9HsP5/HHH0deXh4iIiLQ2NiIU6dOefW4//3f/4VIJMK+ffucbqdpGocOHUJGRgYiIyOxe/duDAwM+HROvIlwfG1Pw7XgeBPh6PV6KBQKxMXFYdeuXaz18Ap2hEPOOyEhATU1NZBKpSEROW9YDxHOWng7+ycpKYnzCIPr4/MhwgkmrmM4iAGhpaUF//3f/w2ZTIakpCQ89dRT2L17N/Lz87163ueeew4HDx7Ek08+icbGRhw+fBh79uxBX1/fqsXZo6Oj+MEPfoCzzjprxd8efvhh/O53v8MzzzyD/Px8/OQnP8GePXvQ3d3tdYqY8wiHGAMsFotPvdC4FpzVFn2apjE6OorPPvsMeXl5qK6uZrVhZLCiDZqmMT4+zpx3ZWUlk+oJxjH5uh8Tasiis2PHDpx11lmorKxETEwMZmdn0dvbC5PJhL6+PqjV6pAaZfiQUuPy+Ha7PaSNO4kBIScnB/v27cP4+Di+8pWvICEhAc8++yxKS0tRUFCAhYWFNZ/rkUcewY033ogDBw5g+/btePLJJxEVFYU///nPHh9jt9vxX//1X/jpT3+KgoICp7/RNI3Dhw/jnnvuwd69e1FRUYG//OUvmJ6exosvvuj1a+RUcEgKjViefcmXSqVSzgXH3fGtVitaW1sxOjqK+vp65OXlBWUWD9vRht1uR0dHBwYHB1FbW7vivIMRWZC6Hn8et1Ehs3/y8/NRW1uL7du3M900hoaG8OGHH6K5uRnDw8OYn58PatTJB8HZ6BHOakRERCA8PBxnnnkmPvjgA+h0OvzP//zPms5Wi8WC5uZm7N69m7lNLBZj9+7dOHnypMfH3X///UhNTcUNN9yw4m9k6KHjc8bHx6OxsXHV53SFs5RaoKOfuY5w3KXU5ufnoVAoEBMTg127dgWtDxfbgmMymdDa2gqJRIJdu3a5DY/5ksrabFGRWCyGVCpFSUkJgNDO/hEEhx+jCUirq+joaJx33nlrPmZubg52ux1paWlOt6elpaG3t9ftYz766CP8z//8DzN7y5XZ2VnmOVyfk/zNGzgRHJJGC2T0Mx/qcIjgkVRUf38/CgsLkZ+fH/RZPGwJjlqtRltbG7KyslBaWurxB86XPRyAuwiHDxM/Qzn7h+tNe66Pz4fRBCaTKeiFn4uLi/j617+Op556inHTBQtOBIdMbQzkCorrCIcs+jabDZ2dndDpdKitrWX6cAUTNhZ/mqYxODiI0dFRlJWVITMzc9X788WlxpdIK1Ss9lq9mf0TGxvLCJCvs3+ECIcfEY6vtuiUlBRIJBKmfo6gVCqRnp6+4v5DQ0MYHR3F5ZdfztxG1hepVIq+vj7mcUql0mk+l1KpRFVVldfnxllKLdAeTXwRnE8++QSRkZEhrb4PNMKxWCxob2+HyWTCzp07vWp9zqeFni/nEQp8WfTZnv3D9aY918fnQ4TjTx2OTCZDbW0tjh8/zlibKYrC8ePHceutt664/9atW9HR0eF02z333IPFxUU8+uijyM7ORlhYGNLT03H8+HFGYBYWFvDpp5/i5ptv9vrceGOL9hUuBYemaebqISMjI+gDx1wJRHAWFhbQ2tqK2NhYNDU1eZ1yYVtw1lubFy7x9zUHOvtHiHC4PT5wOqXmzyycgwcP4rrrrkNdXR0aGhpw+PBhGI1GHDhwAACwf/9+ZGVl4cEHH0RERATKy8udHk/6JDre/t3vfhcPPPAAiouLGVt0Zmbminqd1eA0wgkErgTHZrOhu7sbc3NzAIDc3NyQ/yj9TW+RJpMFBQUoKCjw6byDsYfj7/u22SIcNvBl9g9JvwmCw4+Umj+tba6++mqo1WocOnQIs7OzqKqqwrFjx5hN//HxcZ/f2zvuuANGoxH//d//Db1ejzPPPBPHjh3zugYHECIcnzAYDGhtbYVMJsOuXbtw4sQJTjbSfY1wKIpCT08PZmdnUV1d7dfGoLCHww3BWvRXm/3T09MDq9XKLCSkY3GoxWezmwZIVOrvtM9bb73VbQoNAE6cOLHqY48cObLiNpFIhPvvvx/333+/X+cDrGPBIfNwQnUVNjU1he7ubuTm5qKoqIhx13ERZfkiOEtLS1AoFKBpGrt27fK7VfpmW+g3G46zf2iahslkwtDQEObn5/H5558zLfeJSIViv1KIcE5HOMJ4AhZgI6UGnL4KCeY0PLvdjp6eHsaNQdqRkHPgKsLxRug0Gg0UCgXTuymQHw9fBIcv5xEquEhriUQiREdHIyEhASKRCGVlZSGZ/eMKH0wDwaql8xZ/93D4yrqNcMgX3GazBU1wjEYjFAoFUxDpGh0EMoQtENbaT3HsTr1t2zZs2bIl4GOGeiQC3+BS5LgeTxDK2T+O8CHC4fL4VqsVZrNZiHD4QLBTWjMzM+js7ER2djZKSkrcfvG4jHA8HddqtaKzsxPz8/NoaGhAfHw8K8fkS2TBl/MIFXwcTxCs2T+ucL3gc51SMxgMACBEOHwhGMYBiqLQ29uL6elpVFZWrtpZlasIx9MG/uLiIlpbWxEVFcV6ax22F/r5+XkMDg4iJiYGycnJiIuL25SW57XgegDbWgs+m7N//Dl+MOHaNGA0GgFAiHDYgI0fEduCYzKZoFAoIBKJsGvXrjXtiHyKcEhElpeXF5S6IDYFZ3p6Gl1dXcjIyIDJZMLk5CQAMItScnKyx03pzRbhAOtrxDSZ/UPm/1itVqb7wcDAAJaXlxEfH4/ExEQkJycjNjbW4zH4EOFweXyTyYTIyEjOjQtsIkQ4/4dSqURHR8eaPcUc4TLCIYJDURT6+vowNTW1ZkQWCGzU4VAUhf7+fkxOTqKystIp3ed6VRwVFYXk5GTmqph8HpstCuJjSs0XVpv9MzExAQArmo+SY/PBNMB1So0LO3owWdeCw8aIAscFu7y83G2vIU9wHeEsLy+jra0NNpvNq4gs0GMGsvhZLBa0tbVheXkZTU1NiIqKgsViAfBFS37Slt9qtTKLUnd3N2w2G3NFTKbBbia4Ng2wievAMXKhMTs7i/7+fkRERDAXGQA2dYSz0SzRwCZPqZEaFYqi0NTU5POHy5VzSywWw2Kx4OTJk0hOTkZZWVnQr8QCSWUtLi6ipaWFaacjlUpXfa6wsDCkpaUhLS3NqSWLWq2GXq+HSCRCX18f05YlmLZ4ruH7Hk4guF5o2Gw2Jv02PDwMAOjo6GCin7i4uJAKANcRDhEcIcJhiUDz8YGMKFCpVOjo6EB6ejq2bt3q1xeLi5QaTdOYm5vD4uIitm/fjuzs7JB8If39rGZnZ9HR0YH8/HwUFhb6PNTNtSXL2NgY1Go1RCIRBgcHmT0Bkn5jy5LLF9Z7Ss0XpFIpUlJSkJKSAqvVig8//BDp6enQ6/VBn/3jDiHCYZ91fWnoT4RDURQGBgYwPj7uVVv+tY4fygiHjELQaDSIiopCTk5OyI7t6x4OTdMYGBjA2NgYKioqVgxu8heJRAKZTMYMJFtaWoJGo2EsuY4tW9w1pFxvcBnhcLmHQr5rWVlZ2LJlS9Bn/3g6B673cHztFM13NpXgkD0Pq9WKpqamgD/MUEY4RqOR6eO2bds2JuUQKnzZw7FarWhvb4fRaGTlfV6NyMhIbNmyhbHkujakjI2NZaKfUKdk1jt8EDty/GDP/nGFpmle2KKFCIdH+CI4c3NzaG9vh1wux/bt21m5cglVhEMcdNnZ2SguLoZOpwv53pG3EY7BYEBLSwuioqJ8Gn/gC56Ez7Ui3nEeTEdHB2iaZswH/hQkcrH4cr2Hw7XgeILt2T+ukO8YlxFOKKZ9hpp1v4ezluA4TrZkq80LQSwWB3XMtWP6b8eOHYyDjguzgjeflUqlQnt7O3JyclBcXByUxcqX53SdB7O4uAiNRoOZmRnGeh3sfmBssFFNA6vh6/5JoLN/3B0f4NYl58+0T76z7iMcq9Xq8e9msxltbW0wm81eT7b09fjE2ss2rjZixy8eV4Lj6Zg0TWNoaAgjIyMoLy93GkEbDPy5SHFMyRDrNekH1tvbC6vVioSEBCb68fWKOFhsJtOA67H9Xez9mf3jerFBLmS5FBxhD4dnrFaHo9Fo0N7ejqSkJNTU1ATFOhusPRy9Xg+FQoGEhARUV1evOHcuqu097eHYbDZ0dHRgYWEBjY2NiIuLC+p5sPXaXfuBmUwmaDQa5opYJpMxXQ8SExNZOHP/4HNaK9jHZmux92b2j2P6LTo6mnntXHca8Gd2FZ/hPKUWCO5SajRNY3h4GMPDwygtLQ2qbZjtSIOmaUxMTKCvrw9FRUXIy8tze+58SakRI0N4eDiamprWrSOMtOOPjo5mroj1ej0jPktLSxCLxVCr1YiOjg659Xqz7uEEa7F3N/uHCNDw8DCkUimTDTGbzSGZ/eMOwTTAM1wFx2KxoL29HSaTKSRX22y21rHb7eju7oZarUZtbS1zNeYOPgiOWq1GW1sbtmzZ4rGbdijOIxi4bkiTAuHl5WW0tLRALBYz0U+wrdebNaUWqujK8WIjOzubcTrOzMwAAD7++OOQzP5xRyDTPvnKhhEcnU6HtrY2xMfHB80d5e74bCz8JpMJra2tzNydtdxTJL0VygWBLPSOs3a2b9+OrKysgJ6Xy0XNWyIjIxEeHo7MzEykpqZiYWEBGo0GExMTjPWaLTuuO9bjPkqgcFV0SZyOwOnUdn19fUhm/7hDiHBYho2UmtVqxcjICAYHB1FSUoKcnJyQ/UDZ2MNRq9Vob29HRkYGtm7d6nXTUCC0hWnktba1tUGv17M6a8cXuO4W7dgNubCwkNkP0Gg06OzsZKrhSfTj70hvwmaIMjwdmw991EI1+8cdgkuNZ9A0jeXlZYyNjaG+vp5p+BcqAolwHJ1dvnY84EJwiKsrLi4OTU1NnOW1ucKTyLnuBxgMBmg0GiiVSvT39zOzYJKTk/1Kx3AZZaxXlxobuPttBXP2jzuECIdH6PV6dHV1gaZp1oeNeYu/eykWiwUdHR0wGo1+2bUdBScUaDQaZjO1vr6e04WA6whnNUQiEWJjYxEbG4u8vDzYbDandIzFYmHSMcnJyV5brwXTQOjxpssAm7N/XCG1RMIeDov482WmaRrj4+Po7+9HdnY2xsbGOHNH+ZNSW1hYQGtrK2JiYvzeayLvW7AXXpqmMTY2hoGBAaSnp8NkMnHeGobv+z2OSKVSZhaMOzcUKUYk1mt33wXBNMAN/giev7N/PCFEOBxjtVrR2dkJvV6Puro6REZGYnR0lLMfhq8ptampKXR3d6OgoAAFBQV+nzPpMRXMCMdut6OrqwsajQZ1dXVM6pIP8DXCWQ1XNxQpRtRoNBgZGUFXVxfi4uIYASJXw5s1rcWHCCfQdLW3s388jdkwmUwbbg9n3XQyXFhYwMmTJ2G323HGGWcgMTGR+UJwMXUT8D7CoSgKXV1d6O3tRXV19Yo2/f4eO1iCs7y8jFOnTjHNNxMTE3mTylpPEc5qkGLE4uJiNDY2oqmpCRkZGTAYDFAoFPjoo4/Q1dUFk8nE2fdbMA2wd3wy+yc/Px+1tbU466yzmPZPQ0ND+PDDD9Hc3Izh4WF0dXXBaDTCarX6lVJ7/PHHkZeXh4iICDQ2NuLUqVMe73v06FHU1dUhISEB0dHRqKqqwrPPPut0n+uvv565yCX/LrroIp/PC1gHKTXHYkjXyMBRcLgYwkUinNWuQkkNB9lrCtS1RAiW4Oh0OrS2tkIul6OsrMxptDMfBGejEhERgczMTGRmZoKiKKbvm1arxfz8PHQ6HRP9BMN67Y7NGl0BwR++5jj7Bzh9kUfSbzfddBOGhoaQmpqKv//979i7d6/XF6nPPfccDh48iCeffBKNjY04fPgw9uzZg76+Prfj55OSknD33Xdj69atkMlkePXVV3HgwAGkpqZiz549zP0uuugiPP3008x/+2sa4nWEY7PZ0N7ejqGhIdTU1Kx408ViMUQiEacRDuB5816j0eCTTz5BbGwsGhsbWRMbcmy2BWd8fByff/45CgsLUV5e7vSDZzuFF0g6caMLn1gsRnx8PAoKCpCUlITc3Fzk5ubCYrGgq6sLH374Idrb2zE5OYmlpaWgnQfXezgbKcJZC3LBUV5ejg8++AB//OMfsby8jNdeew1lZWUoKCjAK6+8subzPPLII7jxxhtx4MABbN++HU8++SSioqLw5z//2e39zz33XFx55ZXYtm0bCgsLcfvtt6OiogIfffSR0/3Cw8MZN2Z6errf7Z54u4ezuLgIhUKB8PBw7Nq1y6Oislnt7yvkCsjVQulYHMl2h2oCmwJAURS6u7uhUqk8djnwZR6Ot2yU9FiwkUgkTiO3DQYDtFotVCoVBgYGEBERwdT9OKaaA4XrPRyuTQNcdQ+XSCQoKSmB3W7HO++8g6WlJXz44YcoLi5e9XEWiwXNzc246667mNvEYjF2796NkydPrnlcmqbx7rvvoq+vDw899JDT306cOIHU1FQkJibi/PPPxwMPPMB04vAFXgrO5OQkenp6kJeXh6KiojXnYgRzRMBqkB+j3W5nHEakmeX8/HxQiyPZEoDl5WUoFApQFIWmpiaPURhfIgu+nEeocI0yHK3Xubm5sNlsTN+3/v5+p0r45ORkREdH+71wcx3hhKJbiCe4StMTDAYD89lFR0d7tWcyNzcHu92+YrpuWloaent7PT5ufn4eWVlZMJvNkEgkeOKJJ3DBBRcwf7/ooovw5S9/Gfn5+RgaGsKPf/xjXHzxxTh58qTPosyrPRzHfmLV1dVedUrlMsIhKT0SaSwuLqK1tRVRUVFBrw1iI6Wm1+vR2tqKpKQklJeXr/rl2WwLPZ9YbdF33Qsg1mvifpNKpUz0k5SU5NMizrXgbKaUmiuhtETHxsZCoVDAYDDg+PHjOHjwIAoKCnDuuecCAK655hrmvjt27EBFRQUKCwtx4sQJfOlLX/LpWJxHOGQhI+6csLAwr/qJEbgUHOALp9rMzAw6Ozu9isrYOm4ggkOiyNW6UjsSbBu2t3ApfFxN/PQF10p4Uog4Ojq6wnodFxe36mviMq3FtWmAy5QacFpwfJ3JlJKSAolEAqVS6XS7Uqlkhje6QywWo6ioCABQVVWFnp4ePPjgg4zguFJQUICUlBQMDg6uP8EBgOnpaXR1dTGTIn35oq02EycUiMViDA8PQ61Wo7Ky0q0TJFjH9UcAKIpCX18fpqenvY4iyfGEPZzQE0iUQbpaJyUloaioCGazmXG+TU5OAgDz9+Tk5BX7pJs5wvGm00Aw8aePmkwmQ21tLY4fP459+/YBOP0+Hj9+HLfeeqvXz0NRFMxms8e/T05OQqPR+DVokVPBoWkanZ2dmJ2d9Xux5jLCMZvNTA69qakppFXB/giOxWKBQqGAxWJBU1MToqKivH5sMCILf59vs6X22Fr0ScfrzMxMp0JE0gcsKiqKSb+RvcfNbBrgetqnP+vJwYMHcd1116Gurg4NDQ04fPgwjEYjDhw4AADYv38/srKy8OCDDwIAHnzwQdTV1aGwsBBmsxmvv/46nn32WfzhD39gzuOnP/0pvvKVryA9PR1DQ0O44447UFRU5GSb9hbOIxyy3+GvZZgrwdHpdFAoFBCLxdi6dWvIW1D4muJaWFhAS0sL4uPj/ZqAypc9HL6cR6gI1mslhYikGNFqtTJ1IN3d3YwRZ2ZmBqmpqYiMjAypAHC94Ae7Dmct/O0ycPXVV0OtVuPQoUOYnZ1FVVUVjh07xhgJxsfHnd5Xo9GIW265BZOTk4iMjMTWrVvx17/+FVdffTWA0+tre3s7nnnmGej1emRmZuLCCy/Ez372M79qcTg3DRQWFga0NxBqwXHsL1ZSUoKJiQlOrsR8iXBIyjKQljqbbaHnE6H4foWFhTlZrxcWFtDc3AytVouRkRGEh4c7Wa+D7eDiWnC4Pn4gpoFbb73VYwrtxIkTTv/9wAMP4IEHHvD4XJGRkXjzzTf9Og93cB7hBEoobdE2mw1dXV3QarWoq6tDYmIipqenOYmwvNlToWka/f39mJiYCHh/iYspo+7YbMLHxWslbfgBoKKiAiKRCDqdDlqtFoODg0wXZLL3E4whZFybBriOcDbiLBxggwhOKBZ8o9GI1tZWxkVHwkmuUnprCYDFYkFbWxuWl5exc+fOgL+8wVjo7Xa7z1eSm81owNXGPfmsRSIRJBKJk/V6aWmJMR+MjY0xfeHIPzbKAbiOMLg+vsFg2HCjCQAeCA5bUz+DiVKpREdHB7Zs2YKSkhKnLyJbY6Z9ZTXBIfVAZAQCG+kPx5EIbCyAOp0OLS0toCiKuVJ255Ryx2aKcABu7djuFt3IyEhs2bKFsV7Pz89Dq9VifHycGblN0m9xcXF+Ldx8MA1wvYezmpV5vcK54ARKMCMMmqYxMDCAsbEx7Nixw+0XgKtUk6fjzs7OoqOjg/V6ILJosCE4pAaosLAQsbGx0Ol0mJmZQV9fH6KjoxnxcbdYcVkXspmO6+13moxYTkxMZJxOxHzQ0dEBmqadRm57W1/HdYTBB1v0RpuFAwiC4xHHlFRTU5PHlJQ/Q9jYwNWlRtM0BgcHMTo6ioqKihXtLdg4HhDYQkDTNPr6+jA1NYWamhrEx8fDZrMhPj4eeXl5jFNKo9EwixWJfpKSkpjoZzNFOFym1Egrel8IDw9HRkYGMjIyQNM00/WaXFBERUU5jWD2FEVwKTg0TYOmaWEPJwhwLjiB/piCUfip1+uhUCgQHx+/ZkqKDyk1q9WK9vZ2v0dWe0OgU0ZtNhva2tpgMpmwc+dOREdHrzB7uDqlyGI1NTWFnp4exMbGIiYmZs2REBsNLgUnEEQiEeLi4hAXF8dYr4n5oLe3F1arFQkJCcwFhWNlPZemAbKecB3hCILDQ9iMcGiaxuTkJHp7e71u+cJVhCMWi2Gz2WAwGNDa2orIyEi/R1Z7QyCCYzKZ0NLSgoiICOzcudOrc3RdrCwWCzMt0W6348MPP2QWquTkZM7GjAcbLlN5bC+4YWFhSE1NRWpqKjNyW6PRQKPRYGhoCDKZjPk8uUxpkQs5LgXHZDIJKTU+wpbgODYOramp8br1NpcutaWlJfz73/9GdnY2SkpKgnol7JhS8wWtVovW1lZkZmaitLR0xYwdb5HJZEhPT0dMTAyam5tRWVkJjUbD7AeRHmEpKSnMeOaNANcptWDhOHI7JycHdrud6fs2NDTEjMyQy+VISkoK6WfKteDQNC1EOMGCDZdaoHU4JpOJ6RrgS+NQ4PSX0mKxBHR8X6FpmklNVFRU+NXTyFf8iXAmJibQ29uLrVu3Ijs7m9XzIVXyBQUFsFgszJWyQqGASCRycr6Fos29RaUBZbEiPCuN9YVxIwqOKxKJhPm8ioqK8N5770Eul2NxcRFjY2NMXzgS1QYzoiXRFZcXLYItmqcEGmGo1Wq0t7cjIyMDW7du9fmqJtR7OI7zdhITE0MiNgCYDWRvBMexQaingW6BnIcrMpmM2aimKAoLCwvQaDQYHx9n9n6Sk5ORkpISUJGiu8cZe4cxcPAXWPi3AgAQkZ+Nwge/j+QLz/TrGK5w6VI7PU2Xxrsfa/Hhv3UwGO0o3xqNi8+XIyPNvxHD3h4bADIzMyGTyZw+04mJCcZ6TcwHZOQ2TdOgzRaIZGEQBRCdcG2JBvxvbcN3Nq3g0DSNoaEhjIyMoKysDJmZmX4dP5S2aLIXIpPJUFBQAJ1OF5LjErwRHKvV6uTuW61BKHEDsYlYLEZCQgISEhIYmy6JfsbHx5kixZSUFCQmJgYU/VjUWrRd8k3YFg3Mbcujk+j6z4OofPVPiN9ZxcIr4rIOR4Qnjkzgw091oGlALAYmppZxsnkeh75XiOws7zMBvh/7i5SW62dK9vO0Wi06OztBURRihqYh/qAV9OwcZEkJSLn8fKR+ZQ/EMt8/X64t2SSlJuzhBAE2Umq+upbYdHWFyjQwNzeHtrY2Zi9kamoq5O64tRqGGo1GtLS0ICoqCjt37gxKvy1fOx44dkgmRYpkOBmZD0OiH1+nY87+5QXYFgyA43tC04BYhPHfPo0dzz3qy0tzC5emgWmVBB9/podMJkZE+OkFmKJp6PQ2HH1didtvzA3Kscl3zNNnQfbz0tPTQdM0pl5+BxN/fhE24xKoCBlEc1os/GYY+qFRFN91s8/RymqGBYuVQv+QCRPTy5BIgIKcKBTkRkIsZu+iYHl5GXa7XUip8RHyZfJ2JOzCwoJTFX6g+f1gmwZomsbo6CgGBwexfft2ZGVlAeCm4HS1/m1k/4R0Y+Djpr1jkWJRURGWl5eZ6GdsbAxSqdRpn2Ct75Ohrfe0wLhip2Bo7WblnLk0DYxNiUHZaYRHfbH4ikUihIWJ0NKxCIqiWV1oCT5t2tvtmH/+LYRBhLiyYtAUDYvVCrNaA9Wr72G2OAPxJQXMZ+rNRYWnlJrZQuHlN1XoGTCevsagaXymWEBDVTy+dFYSa++F0WgEACGlxkfIouCN4ExNTaG7uzugrsmuBHMPx263o7OzE1qtFvX19UhISGD+FoyBaGvhKboYHx9HX18ftm3bhi1btnj1XDRNw263w263O1lw11pk2OzpFhERgaysLGRlZTHTMTUaDYaHh9HV1YX4+HhmI9vdMcPSUiCSiEHbXC44RCLI0rwbbOcNXAmORAK4e6dpGpBIgGCdFtk/8uZ1W1RaWKZVCEs6Pb9HJBYhPFwGWVY6lobGkRWdCHtKCrRaLYaHhxEWFsZcVHhKqXqKcDp7DejuNyJNLmMivoVFGz5rm0dRfhTyc/wbseKK0WiESCTye2QLn+FccNgoLju9uek5yqAoCj09PZidnfVpyqU3BCvSWFpaQmtrK+Occ+0xxkWE47rYk/dVqVQy3bO9gYgN8IVwEqehSCRiHEKhzKM7TscsLi5mGlSS9BtN05iamoJIJGLa82d8fS9m/vwvdy8QGTdcxcp5cWkaKMkDPusQwbREISpSzJgIbDYau+oSgiaEvuyhSKIjIQqTgrI491OkLVaIpFJEpyQhPjsb2dnZsNvtblOqRICI9drT8fuHjJBIwIgNAMTFSqHRWTE2ucSq4ASjAzcf4FxwAoV0s/UkOMvLy2htbQVN0z5PufSGYOzhkPRUeno6tm3b5vbLz7XgkOmhVqsVTU1NXl+NEbEhaQupVAqKopz+Ob6fYrGY+ed6DsHEsUGl3W7HZ599BrFYzLTnJxXyOQ8exMQ9h09HOSIRQNNIv/4ryNh/JSvnwWVKLU0uwpUXp+Lo6yosLNhB4/S55GyJwJcvZbd1kuuxvRUcaXwsEs5pgPqFtyCJioQkKgKU1YbliVlEFeUgtno7c1/HrtbA6bWBtFIic63I39y95zTt+QKZza8kmfYpCE6QCHQR8VSLo9Fo8O777ZhWxYEWJ2JyTo8z6sXIymDPXcNmSo2maYyPj6O/v3/N2hWu9nAoioLBYEBLSwtiYmJ8mh7qKCqOdQ6OgkIMIOR+rtEPec2hXIiJMGZkZCA1NdWpQl5fkoGwI/cjqnMY0VIZMi45F7FbC0NyXsGEvL9XXZaG7SUxOPm5HqYlO0oKo3FWYyKio4JnG/a1U3TWf18N85QSBkUPLP93sRKRm4ncu74Fcbjnep2IiAgnQ4lj3zez2YxTp04x0U98fDyK8qPQP2SExUpBFnb6+2o02REWJkZ2JntrykbtMgDwRHACxTXCoWkaIyMjePeDUZxsi8eyWQyxeB6fKebx/kktbr4uF+Vb2XGA+BLhUFYrFlu7YRwcg1gqRWzlNkSV5DEpQdLpwJv0lK8jpgPBYqFgsVKgIYJer8fIyAhycnJQXFzs1cJA7M+OaTRPjyPCQzZtXaMfg8Hwf+dkgUQicRIrb7EvLQM0IInyb5GIiopCVFQUk6bR6XTQFOZhTqPB9OwEEpYXmb2fQCNqLiMc8jmVlcagrDR0G9i+2pLDkhJQ8tsfY+HzTiyPTUGaGI/4pmpIY71ftMViMVNMLBKJYDQaIZfLodFo0NXVBbvdjqioBKSlhGNiikK4TAKKPh3UVpfHsZZOA05HOI595TYSG05wSGGkRjuP7mE5LBYbMtLCmShKqTLjb0en8LMflUIiCZ1pwL5sxvhjf4H+kxZQFhtAA9K4t5B21UWIv+QcKBQKAPC600EoTANmMwVF1zz6hoywWOzQqClkTY3g/HO2e1235BitAF/suXmLo6DMzs4yYw0kEonPez9W/QIMbb1YHp8BQCM8Kw0xFVshS/Fu78kdjsPJHPuDzc3NYXBwEBEREYz4rNYdeTW4WHi4nEfjTx2MSCpF/M4qVmqfKIqCVCp1aiRrMBig1WpRvU2DcKkRugUZYmOiUbY1AXVViaysJYSN2tYG4IngsJFSs9vtTCPLiIgIZGRVQTc/isREGfPDEYlESEgIw6zKjLHJJRTkBr6fQyKcta5Ete/9G7r3P0d4TjqkMdGgaRoW5Rwm//4Kuk16yKvKsH37dq8XpGCn1GiaxkefatHes4C4GAnm9Rpo9AAkcixbE7x+DrJfE4gJgFjDR0ZGUF5ezozKJvs9RNRW2/uxm5ahe+/fME/MIkyeBIgAY9cgrBo9kvecBWlc4D9w1/5gNpvtdPSj0TDdkclsmOTkZK/2vTZqL7XV4Lrw0tUWLRKJEBsbi9jYWOTm5qKuzsY4GjWacXzyyQASEhKY9Fug+y9kD2cjwgvBCRSJRAKtVouuri7k5uaiuLgY/UPG05t8LvcV4fQGH1vRAflirvUD1Z9shUgmhTTm9BdJJBLBEhUOXf8QMow2lJWX+3zlH0zBUc1ZMDBiREqSFFrNNMQiChmpYbDapejoWUB+TuSq5+soNoH0pSJOOI1Gg7q6OsTFxTF/c7f3Q47pGFWJxWIsjUxgeXwGUUU5EP3fZyaNi8HS4BiWRiYRW7nVr/NbDalUCrlcDrlczlSPazQaqFQqDAwMIDIy0in6cbfIcln4yeWwO66Hr61WnyeVSp1GbptMJsZ8MDo6yvSFIwYFX2v9hD0cHkNRFJaWlqDT6VBVVcVc/ebnRCElWQaV2oJUuYyJonTzVmSlRyAni52cK3MFvUY7dcpshkj6f1dNNA2tVguj0YjYuDgk/1/e2NfjBlNw5hesWDQsw7CgQmRkJDIzszA2NoboaDE0OgvMFgoR4e6jMbbEhrTJsdlsaGhoWDXV6G7vh5wDTdMwa7SgxSLYaRpiigJwOuISR4TDqtaueS6BLvwikQgxMTGIiYlBbm4ubDYbs0h1d3fDbrc7RT+Or5XLPRwu4MN4aV9eO9nTIyO3SdfrsbGxFdbruLi4NV+bkFILMv5+ucxmMxQKBSwWC7KzsxmxAQCZTIz/uCIT//P/jWNGaYZUKoLNRiM2Ror/uCITYWHs/JgcF7jViKsph6FzANZlMzR6HSiKQmpsPOxmClEl+T4fl2lWGKQrUaNRD7VaifzcBGRkpEKE0xukZjOFpEQpwqTur8ZJestx09m/4xuhUCgQHR2N6upqn/c+XKOf8Lg4mP7vM6KY/wVsy2aIo0NfYCeVSp1mwxgMBmg0GszOzqK/vx9RUVFITk52itRCyXrbw2H7+P4273Ss5wLAjNwmozQAMH9PTk5eUV8HnE6pbVTB4e5TDRCdTodPPvkEERERSEtLc/sFaahOwB23FuKCs1OwrTgGF54rx49uLURNRTxr50F+lGs51ZLPb0JYQTaUnykgUmoQb7TANjuHxLPq/ErnOC6mbEIcfsrpHmwvTYPZGgOL5bSAmJYA0zKFbcXRKzZJHfdR/B1PTNBqtfjss88gl8tRWVkZcOdesViM6PwtCE9OAqXUQAIxRDRgmVVDHBUJ6ZY0WCwWWK1WJioKJWSPIC8vD7W1tTjzzDORl5cHi8UCu90OhUKBjo4OTE9Pw2w2h+ScNvMeDpvD38jI7fLycpx11lmorKxEdHQ0pqen8cknn+DTTz/F4OAgtFot873zt1P0448/jry8PERERKCxsRGnTp3yeN+jR4+irq4OCQkJiI6ORlVVFZ599lmn+9A0jUOHDiEjIwORkZHYvXs3BgYGfD4vR3gR4fgCTdMYGxvDwMAASkpKkJOTg76+Po8zcQrzolGYF7x8KCk8XWuRUluWoDynAmmluQifVEMSEY6EXdVIOqcRYj+aXAY68tkdFEWhs7MTGo0GTU0NsFGReP8TLWaUS7DaAZtdhPJt4Sss5SSF5trl1x+mp6fR09OD0tJSr9vkeENYUgISz67H/KdtME9MAxAhPCkOsbXliNiS4VXRaahwHLWtUqmwbds2GI1GTE9Po6+vD9HR0UzqLS4uLijnt5kFJ1jjCUQiEWO9dhy5rdFo0NPTg9bWVrzyyiuIj4/3ua3Nc889h4MHD+LJJ59EY2MjDh8+jD179qCvr88p80NISkrC3Xffja1bt0Imk+HVV1/FgQMHkJqaij179gAAHn74Yfzud7/DM888g/z8fPzkJz/Bnj170N3d7dPMMEfWleDYbDZ0dXVBq9U61apIJBJYrdY1Hh08VqvFcZwNU3XOmZDL5awdkzw/G5jNZqeODOQLtfeiNMyqzDBbKIyPaVCQFwGpQzrNUWwCiWrIuIiJiQlUVVV5PXHVFyLztyA8MxUWlQagaYTJkyCJ/OKHs1rRqePtoV4Mo6OjkZqa6jRqW6PRoKOjAzRNOw2bY2swGdd7OBslwlkN15HbpO7npZdewttvv43XX38dF110ES677DJcfPHFqz7XI488ghtvvBEHDhwAADz55JN47bXX8Oc//xl33nnnivufe+65Tv99++2345lnnsFHH32EPXv2gKZpHD58GPfccw/27t0LAPjLX/6CtLQ0vPjii7jmmmv8es28EBxvFimj0YjW1laEhYWt6C3G1Zhnx+O7W/hJ+xeLxYKdO3ey6jxhU3AWFhbQ0tKCxMRElJeXO13dSSQipjODXuNc+8OWOYA0KV1cXER9fX1Q89ficBkist0PrfNkPJidnYXJZIJMJmMEKJTRj+P76tqanwwmI6O2ybA5bzeoPcG1S209mQbYQCQSoaSkBPfeey9aW1txyy23oLS0FMeOHcMLL7ywquBYLBY0NzfjrrvuYm4Ti8XYvXs3Tp48ueaxaZrGu+++i76+Pjz00EMAgJGREczOzmL37t3M/eLj49HY2IiTJ0+ub8FZC6VSiY6ODqb1veuXgWvBcecYI2MQ4uLifGr/4i0kmghUcJRKJdrb273qoE2O52gOCFRsiPFDLBajoaEhqKODfUUkEmFiYgJjY2OorKxEYmKiU92Po+2afB5sL1SrpUwdUzSuo7YnJyeZ3mD+jGUWUmrcTfw0mUxITk7GJZdcgksuuWTN+8/NzcFutyMtzbm/XVpaGnp7ez0+bn5+HllZWTCbzZBIJHjiiSdwwQUXADhdZE2ew/U5yd/8gdeCQ9M0BgYGMDY2hh07diA9Pd3t/fggOI7Hn5mZQWdnJ6tjEDwd11/BoWkaw8PDGB4eRkVFxYovlqfjeVps/WFxcREKhQIJCQkoKyvjdJFxxbX+hwzDco1+3HVSYLPbtS8Lv+uo7cXFRczNzWF8fBzd3d3MsDnHzsie4HLR5VpwQpVS80Sopn3GxsZCoVDAYDDg+PHjOHjwIAoKClak29iEF4Lj7otvsVicRhWvlmaRSqW8SKnRNI3+/n5MTEygsrLS7WYdm/grOCSFpdPp0NjY6FRMuRqk55tPA7I8oFar0dnZidzcXOTn5/Oqb5TNZkN7ezvMZrPH+p/Vik5djQeBRj/+vDeOvcHcjdoWi8WM+LgrTuQ6wuEywuDy+KRA2JdpnykpKZBIJFAqlU63K5VKjxfpwOnvSFFREQCgqqoKPT09ePDBB3Huuecyj1MqlcjI+CIFrVQqUVVV5cMrcoYXguPK/Pw8WltbER8fj6ampjXTUXyIcEge1WQyYefOnSHx0fsjOGRcg0gkQlNTk9s6AHeQBYiMtpbL5X7vEYyPj2NgYABlZWWr/iC4YHl5GQqFAjKZDPX19V6lQtcqOvU3+iHpNDYWfk+jtkdHR1dEPzExMZwLTqCTeAOBDxGOL+uHTCZDbW0tjh8/jn379gE4/R4eP34ct956q9fPQ1EUY7vPz89Heno6jh8/zgjMwsICPv30U9x8881eP6crvBIcmqYxOTmJ3t5eFBUVIS8vz6svPdeCQ9M0BgcHGYEM1Y/F1x508/PzaGlpQXJyMsrLy73+UZGr98LCQiQkJECj0aClpQVisZhp8ZGcnLzm4kxRFPr7+zE7O4va2lqnCaZ8gPTiS0pK8jiHyBt8iX5WMx4Eq62NWLz6qG2JRAKJRILY2FjYbDbW9x/XgmvDAtcpPX9SagcPHsR1112Huro6NDQ04PDhwzAajYxrbf/+/cjKysKDDz4IAHjwwQdRV1fHRL+vv/46nn32WfzhD38AcHpt+e53v4sHHngAxcXFjC06MzOTETV/4IXguLbnr6mp8ckWy6XgKJVKzM/PIykpCTU1NSH9ofgS4czOzqKjo8MnIQecxwPIZLIVV8lqtRpDQ0Po6OhAYmIi5HI5UlJSVrTlJ2mq5eVlNDY28m58rkajQXt7O+spPsfoh3xWjtGPN92ug/2dcjdqu6+vDzqdDh9++KHTqO1QDAbjcsEnnxHXKTVfMyRXX3011Go1Dh06hNnZWVRVVeHYsWPM3ixJoxKMRiNuueUWTE5OIjIyElu3bsVf//pXXH311cx97rjjDhiNRvz3f/839Ho9zjzzTBw7dszvGhwAENFcdQd0wGQy4dNPP4VIJEJ1dbXPL8hgMODkyZOMwyIUkKhmdHQUsbGxSE1NRUFBQciODwAfffQRSktLV63tIfUto6OjqKio8HpfydexAiaTCXNzc1Cr1dDpdIiKimKin/DwcLS3tyM8PBw7duzgNF3iDlJsum3bNq/HLrCB66wfx58iMWh8+OGHOPPMM0Pu3uvo6EB8fDxTG6LVaqHVahEWFsaIDxm1zTbt7e1ITExcdQBhsLBarfjwww9x9tlnhzyyA06vZZmZmVAqlUHfA+YCXkQ4pLI6Pz/frysbEuGEKhQnV+uLi4vYuXMnRkdHOYmw1opw7HY7Ojo6MD8/j8bGRq83Iv3pHBAVFYWcnBymLb9Wq4VarUZ7ezusVisiIyOZ2SJ8gbTxGRsbC1qx6WqsNel0eXkZwOnvm0QiCYrt2hPkt+Q6aps0phwaGsLS0hIzapsMm2Pj97eZIxyTyQQAG7aXGm8Ep7DQ/7G85Mtht9uDflViNBrR0tKCiIgINDU1QSaTsTpm2hdWq8NZXl5GS0sLJBIJc57ewEZ9DWlMSVEUZmdnkZOTA4lEgomJCfT09CA+Ph4pKSmQy+WczW73ZHvmClfjgdFoRGdnJ+Ry+QoXZiiKTt11GiBt95OTk1FcXOzUln94eBgymcwp+vF30eZScOx2e0AdMwLFYDBAIpF4beZZb/BCcAKFiEywBUetVqOtrW1FAepqrW2CiacIR6/Xo7W1FXK5HNu3b/fZHBBoMafjwLSKigom5Uc2qOfm5jA3N8csUmTfJ5BFyhe8sT1zyeLiIlpaWpCWlobS0lKnEd3uZv0Eo+jUm2yBY1t+Ev1oNBr09/fDYrGsiH7YPHaw4NqSTQwDfKpJYxPeCE4gUz/JDy5Yiz5JvQwNDaGsrGxFnl8ikXhsHhpM3AnO9PQ0urq6UFxcjNzcXL/MAYEOTOvu7oZWq0V9ff2KyCEiIsIpRaPT6TA3N4eenh5YLBYkJyczez/BEAJiCw8PD/fa9hxKtFot2trakJeXx5g7yGfBtu16NXwdT+Ap+vFn1DbXEQ6Xi/1GHk0A8EhwAoF0bA6G4NhsNnR2dkKv16OhoQHx8StHG3AZ4RCRJl0ZxsfHUVVV5XWTUMerZ/Kc/ooNKda12+1obGxcMy0gkUgYcSktLYXRaIRarcbMzAx6e3sRExPDRD+B9AUjLC4uorW1FcnJyQHZnoOFUqlEZ2cntm7diqysLI/389V2Tf6/LwQSZTiO2s7OzobN9sVIZm9GbXO9h8Pl98JkMvkUDa43NoTgAMGxRptMJrS2tkIqla5aJMnVHg6JcEiKyGAw+FR06moOCCR3TZqrxsbGrmgA6g2OEzFJV2SNRgO1Ws1YOn2p+XElWLZntpiYmMDAwIBTCtIb1io69cZ27Q4201qOI5lLSkpgMpmYz9bdqG2uBYcPKTW+fT/ZgjeCE0hKDWBfcDQaDRQKBTIyMrB169ZVfwCB9DQLBLFYDLPZjE8//RRhYWHYuXNnSM0BBJIG2rJlC4qKilj5sbj2BdPr9Zibm/Oq5scVrmzP3kBs65OTk6ipqQm4GNY1+nH852vRaTAWfcfohzgaHWfC2Gw20DQNjUaDqKiokO+vCSm14MIbwQkUtgTHccDbtm3bvBoCxlVKzWq1QqVSITMz06cUEVvmAACYmppCb2/vmmmgQBCLvxjbS66QSc0PGcdMXG/x8fHM+0AalJI0Y6htz2tBnHJkvhPbC81atuvVop9QbdxLpVLI5XLI5XKm6LG5uRk6nQ6Tk5PMqO3k5GSnzzZYcB3hmEymkDTu5IoNJTiBbtzb7XZ0dXVBo9Ggvr7e66tNLjodTE1NQaPRICkpCWVlZV4/ji1zACl8nZycRHV1NTPDPRS41vxoNBrMzc2hvb0dFEUxxgONRgOdTscL27Mrdrud6bxQX18f9Ct5d6m31aIfX00DbEDSqiKRCNu2bUNERAQT/XR1dcFutzsNmwuGdZgPEY4gOCEg0C93oIv+0tISWltbIRaLnSZeenvsUKXUSEfqyclJyOVyrzcY2TQHOA5Ma2ho4PQHIpVKmXHMZCCZUqlEb28v7HY74uLiMDc3x6Ry+JAbJ4P5RCIR6urqOOm84Ml4QNM0zGYzLBYLKIqC1WplddyCN5CLIdeJmAaDARqNBjMzM0Ebtc21acCftjbrCd4ITqAEMqJAq9VCoVAgNTXVp7oVQqj2cGw2G9ra2piO1BMTE17te7FpDuD7wLTw8HBoNBokJCSgtLSUsV1zVfPjCrmwiY6O9stcEQwco5+lpSW0t7czxZuOFynkvsEuOnW36ItEIsTGxiI2NhZ5eXmwWq0eR20nJSX5Hf3Y7XbOTQOC4KwD/IlwaJrGxMQE+vr6UFpaipycHL+OHYo9HJPJhJaWFoSHh2Pnzp0ICwuDWCyG1Wpd9XGO+zWBXqUSW3FSUpJfwhxs3Nmeo6OjnWp+1Gp1yGp+XDEYDGhpaYFcLsfWrVt5EW05Qs4vNTUVpaWlThNeQ1V06u2sJdIOi0S2i4uL0Gg0mJqaCmjUNh8iHL7tNbIJbwQn1Ck1UqCoUqlQW1sb0B5EsFNqWq0Wra2tyMzMRGlpqVNtxWrHZdMcoFar0dHRgfz8fJ+6TYeKtWzPjjU/JD0zNzcXtJofV3Q6HRQKBW9t2WQGVXZ2ttOU2mDN+vGEL/37CCKRCHFxcYiLi2Ms9ST6aWtrAwCnYXOrReVcmwaMRiNyc3M5O36w4Y3gBIovgkOGbFEUhaampoBb5QczwpmYmGBcYK7dc1cTHDbb1IyPj2NoaAjbt2/n3cA0wHfbs2N6ZrWaH7lcjqSkpIC7EahUKnR2dqKkpMQr12OoIQtzUVHRmlE+W7N+POEoYP4ik8mQnp6O9PR0Zl9Po9FgYmJizVHbXKfUBJfaOkEikTDT6laD9BlLTk5GWVkZK1+uYEQ4FEWhr68P09PTHiMwd8072TQHkHMgUaC7Lgtc4mh7DsQp56nmZ3BwECaTCUlJSUx05GsV+OTkJPr7+1FeXs7LdvMqlQodHR1+1SgFo+jU25Sat4hEImbUdkFBAcxmMxP9TExMQCQSOUU/XE8bFepwQgQbKbW1bNGTk5Po6enxuc/YWpAWM2zlf61WK9ra2rC8vIympiaPi5xrhOPrDJu1zqGjo4NpcMm3gWmONSz19fWs/Uj9rflxxVEM2SjoDAbT09Po7e3Fjh07WBFDNopO2YhwViM8PNzp4oJEP2NjY+ju7oZUKkVsbCwWFxcZi3YoESKcdcJqKTWKotDb24uZmRmfp4l6e2xynEAFh4w/iIqKws6dO1dN5zgKDpvmAOKkioiI4GWDS+LWs1qtQa9h8VTz09bWBpqmmcgnJSWFuTKmaRo9PT2Ym5tjVQzZZGxsDMPDw6iqqgpKDZW/Rads7Df6co4JCQlISEhgRi23tbXBbDYzoz0co59Q/A4El9o6wZPgEBuvzWZbNVoIBPLDCnQ8Ammnk5WVxbiE1jqua+v6QH+ser0eCoUC6enpTiMY+IJjt+e6urqQiqG7mh+1Wo2xsTF0dXUxo5i1Wi1vRx+4ttIJRZrUU+qNiJDj79ZqtXJmqAgPD4dMJkNqairS09MxPz8PjUaDkZERp883WKO2SacFvhUps8mGFhzivElISEBtbW3QFifHKzl/GR8fR19fn9ftdMhxHfPmgYrN7Owsuru7vdo85gJie05JSVmzv12wcdwbIHN+lEolhoeHYbPZEBERgdHRUU5rflyhaRq9vb1Qq9VBaaXjLasVnc7Pz0MqlcJisbA6bsFbSKcBsViMxMREJCYmMp+vRqOBRqPB6OgopFJpUEZtm0wmIcIJBYFeLbgWfpK5MIWFhUG3oZIfhD9ONZLum52dRV1dHRITE716HOl1ZTKZMDk5idTUVL+L3Rz3G3bs2OFTt+JQwfduz8DpdkOJiYnYvn075ufnmTk/VquVMR7I5XJOpjlSFIWuri4sLCygvr6eN3tyjtHP5OQkRkdHmYJYx+jHsd4n2EWn7i4OIiIikJWVhaysLMZYotFoWB+1TbpFb1R4IziBQiIciqKY1i++zIVh4/i+RjhkfozFYvHJnk1SEfHx8diyZQump6fR19eHuLg4phGityE/qUfia88x4Avb8/bt25GRkcH16azAYDAwzkcSeTk2pCQ1P2STPtg1P66Qvm1msxl1dXW8HF9MrPfV1dXMRVeoi07JMdd6PkdjSXFxMZaWlpjoJ5BR2xRFCXs46wXiUmtubobZbEZTU1NIrxR8jXBIVXdMTAwaGxu9Dskd0w9SqRSFhYXMhqdarYZarcbw8DDCw8OZRS8hIcHtj4gIHkVRaGho4N1CxJbtOZgQm31OTo5TwSTBXc0PGbEdjJofV6xWKxQKBQCgtraWU8uvJ0ZGRjA2NrZiTynURaeAf807IyMjnabYkuhnYGAAy8vLSEhIYOY4RUZGerzAMBqNAMDLiz624I3gBHqVt7y8DKvVColEsqa7Kxj4EuGo1Wq0tbUhJycHxcXFXr/21cwB4eHhTl96UsjY0dEBiqIY8SHDywIdmBZsgmV7ZhNS0FlcXLyiKNcTMpkMmZmZyMzMdKr5GRgYwNLSklPqLdC0l8ViQUtLC2QyGSorK3n3GTsaGGpra9dcaINddEqeN5D3ydHZBoAZNkfSb+Hh4R5HbZtMJgAQUmp8Z3Z2Fh0dHQCAqqoqTjaTvWng6Thrp6yszKdCO0cr6VrmAIlE4tRld35+Hmq1mhleFhMTA6PR6LUbLtSE0vbsL6Sgs6ysDGlpaX49h2vNj9FoXFHzQ1Jvvs6CWVpaQktLC+Li4lBWVsY7tyHpeq5UKlFfX+/zIusY/bg6NQOZdMr2eIKoqChERUUhOzub6een0WjQ19cHi8XCjNqWSCQwmUwICwvzOdPw+OOP41e/+hVmZ2dRWVmJ3//+92hoaHB736eeegp/+ctf0NnZCeB01PuLX/zC6f7XX389nnnmGafH7dmzB8eOHfPx1a+EV4Lj69RPmqYxMDCAsbExbN++nbma50pwVkupkb0StVrt06wd8mMiPyRfnWgikYipNSguLsbw8DCGh4cRFRWFyclJ6HQ6JvoJxX7CWnBpe/YGmqaZFJDjfgMbkEmYubm5Xtf8uIMMMeNrk1Dilpubm0NdXV3ApQquezmBTDoNZi81135+jqO2r732WohEIsjlcrz99ts455xzvLrQeu6553Dw4EE8+eSTaGxsxOHDh7Fnzx709fW5LeY9ceIErr32WuzatQsRERF46KGHcOGFF6Krq8tpgOJFF12Ep59+mvlvttLtIjqQuc4sY7FYvBYcq9WK9vZ2GI1G1NTUIDIyEm+//TbOO+88TvYiPv30U2RnZ7uNWiwWC1pbW2G321FTU+P1FTubnQOIOE9PT6OiogJJSUmwWq3MFbVGo2F+EGQ/IdQpGD7Znt3haCuurq4OWa7dseZnbm4OBoMB8fHxTPTjaBBZWFhAS0sLtmzZgsLCQt6JDbnw0uv1qKurC3r06q7o1HFMh2vR6YkTJ3DGGWeEfA3R6XR46qmn8MQTTyAqKgparRbnn38+HnnkERQXF3t8XGNjI+rr6/HYY48BOP16s7Ozcdttt+HOO+9c87h2ux2JiYl47LHHsH//fgCnIxy9Xo8XX3yRldfmCL8uH72EbLhHRUWhqakJYWFhzJeIi1HPgOcIZ3FxkUlt7Nixwy9zAHl+f7Hb7ejo6IDRaHRKX4SFhTm1+SDt+3t7e2G1WpGcnMwsasGee0Nsz3l5ebzsRk2GzpH3MJS2Ync1P+RCgewLkBELw8PDKCws5GXHYYqi0NnZCYPBgPr6+pAs6r4UnbLdx80XEhMTUV1djZSUFPT29qKrqwuvv/76qhG0xWJBc3Mz7rrrLuY2sViM3bt34+TJk14d12QyMbZ9R06cOIHU1FQkJibi/PPPxwMPPMBKhxZeCY43KTWVSoX29vYVG+4ikYiTUc8Ed6YBcq65ubkoKiryyRzAxhho4IvO2FKpFA0NDR5TMWKxmNnMLC0thcFggFqtZjrskitqMmWUTUGYmppCb28vb23PxOlF0zTq6uo4HzoXERHhZBDRarWYmJhgmlHq9XpIpVKkpKTwxnnoas3m6j1czXiwsLDAnCvJJoSy6JTU4IhEIpSXl6O8vHzV+8/NzcFut6/YQ0xLS0Nvb69Xx/zRj36EzMxM7N69m7ntoosuwpe//GXk5+djaGgIP/7xj3HxxRfj5MmTAWc9eCU4q0EcLSMjIygvL3e7MAUy9TNQHCMcmqYxOjqKwcFBj+fqCTbb1CwsLEChUDgNJPMGRysv6bBLLNdDQ0OIiIhgUm+eLNfesB5sz2RPKSIiAhUVFbxzekkkElitVuh0OuzYsQPR0dGYm5tzGkRGPivXVvyhwm63Q6FQwG6388qa7Rj96HQ69PT0oKSkBFKpNGi269UIdafoX/7yl/jf//1fnDhxwim1ec011zD/f8eOHaioqEBhYSFOnDiBL33pSwEdc10Ijs1mQ0dHBxYWFrBz506PuXM+RDgkbaDRaNDQ0OBTryrHjc5AxYZYdtkYmObJct3e3g6apldYrr3BseCUr7Zn0kg1KSnJJ8EOJePj4xgcHERVVRWT8uCq5scdNpsNra2tEIlEqKmp4Z0JBDi9f9La2uo0r8gb2zX5/2xhMpl8MlCkpKRAIpFAqVQ63a5UKtecW/XrX/8av/zlL/HOO++goqJi1fsWFBQgJSUFg4ODG0tw3C2KpF4kPDwcTU1Nq4biXAqOWCyGxWLBqVOnQNM0mpqafDIHsDXDhlivh4eHA7LsemIty3VSUhKz7+Npn4MYPqxWKy8LToEvmpjydfOdRIcTExMeZxW5q/lRq9VBqflxh9VqRUtLC8LCwnhZBwScnqarUChQWlrq5NIKxqyftfA1wpHJZKitrcXx48exb98+5jyPHz+OW2+91ePjHn74Yfz85z/Hm2++ibq6ujWPMzk5CY1Gw0q6m1eC4wopkNyyZYtXnYu9mYkTLOx2O5RKJVJTU30qpGTTHED6sqnV6pAMTHO1XJtMJqjVaiiVSvT19TEtXBzTOXy3PQNfjNPmaxNTmqaZwXjeNuF0rPkpLS1ltebHHaTolKQi+RgdehIbd7Ax62ct/Glrc/DgQVx33XWoq6tDQ0MDDh8+DKPRiAMHDgAA9u/fj6ysLDz44IMAgIceegiHDh3C3/72N+Tl5WF2dhYAEBMTg5iYGBgMBvz0pz/FV77yFaSnp2NoaAh33HEHioqKsGfPHp9fkyv8+7Xji1qHoaEhnwokuYpwlEolZmZmEBsbi4qKCk7MASRqsFgsnA1Mi4qKQm5uLnJzc50s1+Pj45BIJIiPj4dWq0VqaipvU1RTU1Po6+sLSnTIBo624kDcco41P1arFVqtlrnA86Xmxx1msxnNzc2IiYlBeXk5Lz9nIjZbt271a9Kpa4d4NqIffxp3Xn311VCr1Th06BBmZ2dRVVWFY8eOMd9dkkol/OEPf4DFYsFVV13l9Dz33nsv7rvvPkgkErS3t+OZZ56BXq9HZmYmLrzwQvzsZz9jJRPBqzocu90Os9mMjo4O6PV6VFdX+3SVTvLteXl5wTtJB0haY3h4GKmpqRCJRGvmQx0fy5Y5wGQyQaFQIDIy0ifrdaigKApjY2MYGhpiKsNDabn2BmL0GB0dRWVlJS8NDMTevrS0hJqamqCkIkmalOz9rFbz446lpSU0NzczXbP5looETlvw29ra/BKbtXCNfhyX17Win+985zuQy+V4+OGHWT0nPsGrlclkMuGzzz6DVCpFU1OTzz+oUEY4pC5Dp9OhsbERGo0G8/PzXj2WTXMA2WvIyMhASUkJL3/gMzMzGBkZQVlZGdLT00NqufYGkqJSKpW87Zhts9mgUChAURTq6uqC5vRyTJOuVvMjl8uRmJjotHiaTCY0Nzczhbt8/C4Ssdm2bVtQLPirzfpZK/oxGAwoKChg/Zz4BK8ER6vVIjEx0e8q81AJDtmHEIlEjDDq9fo1j82mOQA4vZB3d3ejpKTE6+aRocTR9uw4ytjRcu26oEVERDDiw8ZewloQV+Hi4iJnqci1cGzCWV1dHdLNd3c1P3Nzc+jq6oLNZkNycjJjEOno6EBGRoZPDWlDydzcHNrb24MmNq74UnQqFos3/CwcgGeCk52dvaadbzVCITjz8/NoaWlBcnKyU356readruaAQNvUkIW8srISKSkpfj1PMPHW9uy6oBHLdVtbGwAwV9O+WK69xWq1oq2tDXa7HfX19bxI7bmyvLzMjLHgej9EIpEwFwNbt25l5vyMj4/DYDAgPDwcEokEi4uLnNX8eIKIzfbt2wNaYwJhtaLT5eVlfPbZZ8jPz+fk3EIFrwQnUKRSKcxmc9Cen3SlLioqWlHbslrzTjb3a+x2u9OmMR/rV/y1PXtruZbL5QH34DKbzWhpaUF4eHjIowZvIXVApHCXTws4KQ6mKAqjo6PIz89HVFQUI0COjSpJN2SuIK5DLsXGFcfox2q14lvf+hbi4+Nx4403cnxmwWVDCU6wIhzS5YBsKLvrwuppHg6bYmOxWJhhWnytX3GszA/E9uyP5dpbyEJONrb56KIiTTizsrJ8aosUSnQ6HRQKBQoLCxn7uLuan46ODiQmJq5ZnxUMiNjw1XVos9lwww03YGhoCJ988onbtWUjwSvBCfRHFYw6HOIMmp+fR2Njo8cNZXcRDpvmADLGOD4+HmVlZby8Ig9mt2dPluuxsTFIpVJGfNYa6Ts/P4/W1tZ1sZCTLhF8hGy+O1bnEzzV/KhUKvT19bFe8+MJ0g2jvLycl2Jjt9vxrW99C11dXXjvvfc2vNgAPBOcQGE7wiH5c4lE4lWXAxLhsG0OIJ2Us7OzeVn1DnyRI2ejlc5aeOpy3dPTs2qXa3KOfC3oBL64Ine3kPMFco7ebr6vVvMDgPm8kpOTWXPfqVQqdHR08FpsbrvtNnz22Wc4ceIEb1J9wUYQHA+QWfVyudyrtAuJcNicYQMAExMT6O/vx7Zt21ivGWALLrs9e9vlmhgtiDWbjxDXIV8XSeB0kXNnZ6ff5xgWFoa0tDSkpaU51fyMjIygs7MTCQkJzN7PWjU/niBis2PHDl5GDRRF4Xvf+x4++OADvPfee2t2OdhICILjhunpaXR1daG4uBi5ublefelJhEP2awLtrURG8M7MzKCmpobVyZJsQfa2JiYmeNHt2bXL9fLyMtPpwGQyITw8HAsLCwgPDw+J5doXJiYmMDAw4NSEk29MT0+jt7cXFRUVkMvlAT+fu5ofMmRurZofTxBB5LPY3HHHHXjrrbdw4sQJXs4tCia8Ehw29nACERwyFZPUjfjyoxKJRLDb7VCr1UhOTg5oMSPdsU0mExoaGgIewRsM1kO35/DwcJhMJthsNtTV1cFqtYbMcu0tjiOra2pqvB49HmomJyfR39+PysrKoAliREQEsrOzkZ2dvWrNj6c5P0Rs2BJEtqEoCvfccw9eeuklnDhxYsMXebqDV61tAN/GTLsyPz+P5uZmnH/++T4/lizyi4uLqKmp8WkBpWkaVqsV/f39UKvVsNvtSElJQWpqqs+LGRmYFhYWhoqKCt7MDnHE0fZcXV3NS7ccKehcWFhATU2Nk2g7Wq7VajVMJhOrlmtvIVHs7OwsampqeNnhAADTfby6upoTQaRpmkmVzs3NYWFhYcWcHzKOg69iQ9M07r//fjzzzDN47733sG3bNq5PiRM2lOAYDAacPHkSF1xwgU+PW1paYtqoV1VVeV0ASMwBpIjLca68SqViFjOyKSqXy1ddnBcWFhiXF1+bWzranvnYtw04ffHQ1tYGm82G6urqNT9Px87Jer0+IMu1t1AUhZ6eHuh0uhWCyCccB+QFu/u4t5A5P2q1GhqNBiKRCDabDfn5+cjPz+edg5Omafzyl7/Ek08+iXfffRc7duzg+pQ4Y0MJztLSEt5//33s2bPH60WCDF9KS0vzaZH31hxgNBqhVquhUqmwsLDAbGKnpqY6LTLkCq2goMDrfaNQE0zbM1uYzWa0trZCJpOhoqLCZ0F0tFzPzc05Wa6TkpJYec2kD5/RaERNTU3IIipfIPtzU1NTvI6+iGElOTkZBoMBZrOZs5ofd9A0jd/+9rd45JFHcPz4cVRXV3N6PlzDO8GxWq2rtohZDYvFgnfffRcXXHCBV1c5U1NT6O7uRmlpqU82WX9n2JBRzSqVClqtlqlHsNvtmJqa4u1GJxBa27O/mEwmtLS0ICEhgZWCTkfLtVqtXtVy7S0k+rLb7aiuruZlypSk+pRKJWpra3nb32tmZgY9PT2oqKhg2ju5RqvR0dFM6i0+Pj6k31uapvHYY4/hl7/8Jd588000NDSE7Nh8ZUMJjt1ux9tvv43zzz9/1cWA/KAmJyd97kXGVucAm83GtG1ZWlqCTCZDWlqaT46cUMGl7dlbSEFnZmZmUJpHOu4jqNVqLC4uOnW59mZRtlgsaG1thVQqRWVlJS/TkTRNo6enBxqNBrW1tbxN9RGxWc3EYLVaodFomFELAJza7QRT7Gmaxp/+9Cfcd999eOONN7Br166gHWs9saEEh6ZpvPnmmzj77LM9/lDIFabJZEJNTY1PV29stqkhjSNtNhsqKiqY1i0qlQoURTELGdcOKmJ75uuMGOCLqvfCwsKQ2Uwdu1xrtdo1u1yTIuLo6Gjs2LGDVxcUBOI8nJ+fR21tLS9TfcAX9mxfHHOONT9qtRpGo5Gp+WF7LAZN0zhy5AjuuusuvPrqqzj77LNZed6NwIYSHAB4++23sXPnTrc5Z5JyCQ8PR1VVlddXOI7mALYGprW2tiIqKmrFxjtN006mAzJ7PjU1FXK5PGQdjR1tz9XV1by0PQNfFEtyGX3ZbDamel6tVgNwtlxbLBY0NzcjKSmJt2YQiqLQ0dEBo9GI2tpaXjoPAf/Exh1LS0tM5KPVahEeHs6kSgPJMNA0jb/+9a/4wQ9+gJdffhnnnXee3+e4EeGd4NhstoBqad577z239k2tVsukXEpLS1k3B3iLTqdDW1ub1wPTjEYjIz6rmQ7YxDH64qvtGQBGR0cxPDwc1NoQX3FnuQbANArlehPbHXa7He3t7TCbzaipqeHlmAbgi/HfjrOV2IDU/BCjiDc1P+6gaRr/+Mc/cNttt+H555/Hnj17WDvHjcKGE5wPPvgAZWVlTgvQxMQEent7sXXrVp8GlflrDvDE9PQ0enp6UFpa6lefLFKJTdI40dHRjPiwZd9dWlpCa2srb8dVAyu7MMTFxXF9Sm7R6/WMicFut2N+fj4klmtfsNvtUCgUvDYxAMETG1c81fyQ6Ge1z+zo0aO46aab8Nxzz+Gyyy4L2jmuZzac4Hz88ccoLi5GamoqKIpCX18fpqenfW69wuZ+jeNeSEVFBStX42RDVKVSYW5uDmFhYYz4JCQk+CWOpA4oNTXVpygwlFAUha6uLszPz/O6foW4+oqLi5mLHIvFwgyYC5bl2hdsNhszubaqqoqXFxfAF10OqqurQ97iybXmRyqVMunSpKQkxg376quv4sCBA/jrX/+KK6+8MqTnuJ7gneDY7faARgz8+9//Rm5uLlJSUtDW1obl5WWfFya2B6Z1dXVhYWEBVVVVQdkLoSgKWq2WSb05mg5SUlK8soiTBZLPdUA2mw3t7e2wWCy8TvXNzs6iq6tr1UahwbBc+4LVamWKnSsrK3lXLEngUmxcIZ8ZEaC33noLH3/8MXbs2IFnn30WzzzzDP7jP/6D03PkOxtOcD777DMkJSVhenoaUVFRPttP2ZxhYzabmb5dvnQwCATHPQSVSoXl5WWnTgfuzmFychJ9fX28tj1bLBanBZLvV+OOtSFrQdI4JFr1x3LtC8TEEBkZiYqKCl5GssDpVPjg4CBnLXVWg6Zp9PX14bHHHsMbb7wBtVqN7du347LLLsOVV16J+vp6rk+Rl2w4wfn3v/+NhYUF5OTkoLS01GvBYNscQAamkSJELq4gaZp26nRAFjIyxjkiIoJJ9VVVVXF+BekJ4i4kw+f4ukCOjIxgdHQ04PfSV8u1r8/d0tKCmJgYlJeX8/a95LPYED744AN89atfxe9+9zvs27cPb7/9Nl599VWkpKTgkUce4fr0eAnvBIeiKFitVr8eOz4+jp6eHqSmpvrUQoJtc8Dc3Bw6OjqQk5ODgoIC3qSniOlApVJBp9NBIpGApmmUlZUhNTWVN+fpCNlXSk9P98rVxwWkyzgxMbDZBmYty7Uvkd7S0hKam5sZxxwf30vg9O94aGiI12LzySef4Mtf/jIefvhh3HTTTbx9L/nGhhAciqLQ29uL2dlZxMfHIzY2FiUlJV49lkQ2drs94BQa8MXAND6np6xWK1pbW2E2mxETEwOdToewsDCm1sdf0wHbkEmnfB61TNM0uru7odVqfS4k9udY/na5NplMaG5uhlwu9ynyDzVEbGpqanjTLNSVU6dOYd++ffjZz36GW2+9lbfvJR9Z94JjsVjQ1tYGi8WCmpoajI6OAoBX7b/ZdqL19fVhdnYWVVVVvL0yc7Q9V1RUMDOEHK+iaZp2Gq/ARTqQbLzzedKpY7EkF004SbpUrVavark2GAxobm5GRkZGUNr+sAUZg8BnsWlpacHll1+Oe+65BwcPHuTte8lXeCc4NE3DYrF4dV+DwcDko0ln4IGBAZjNZpSXl6/6WDbNAWSWztLSEqqqqnhr1fXG9kyuolUqFVQqFcxmM5KTk5GamhoS9xRweuEZGhryaeM91Pg6AiHYuLPvEsPB0NAQ79K7rqwHsWlvb8ell16KH/zgB7jzzjt5+17ymXUrOGRyY05OjtNV2/DwMBYXF1FZWenx+UlkAwRuDlhaWoJCoWDa4fO1cM4f2zMxHRC79eLiIhISEpjUG9tV8zRNY3BwEFNTU7yav+IKSUmKxWJe1q8Q++7k5CRUKhVEIpGTTZ5rcXRldHQUIyMjqK2t5W0Rb3d3Ny6++GJ8+9vfxr333iuIjZ/w65fiBTRNY2xsDAMDAygrK1uRblltzLSrOSBQsZmfn4dCoYBcLuftfBjgC9vzanUh7hCJRIiJiUFMTAwKCgqcTAf9/f1MCic1NRUxMTEBvZekd5ter0d9fT1vW+KbzWa0tLQwnRj4WL8iFoshFouh1WpRUlKCpKQkqFQqjI+Po7u7O6iWa18ZHR3F6Ogor8Wmr68Pl112GW688UZBbAKEdxEOcPpH7Q6yKKnVao8OlsnJSczMzKzwwbNtDlAqlejq6kJhYSFycnJ4+SV07HDAtu2ZDCpTqVTQaDSQyWROnQ58eT/WS0En2/N2ggXpnl1aWoqsrCynv7m2R4qMjGTEx9fPLVBGRkYwNjbG6/ZEg4ODuPjii3HNNdfgV7/6FW8/8/XCuhEcMkuE9HzylM6ZmZnB6OgompqamNvYNgeQFEB5eTlvB6aRFjB6vT7o7iliOiCpNwBO4xVWiwLWw4wY4IuNdz7bs4EvJsdu27ZtTZekzWZzarUD+G+59hUiNrW1tbydJjo6OoqLLroIe/fuxaOPPiqIDQvwUnBcx0wvLi6ipaUFcXFxazaUJOmeM888EwC75gAyh16j0aCqqoq3V2Wk27PdbkdVVVVIIwaapqHX65nUm9lsZhYxuVzutMe1tLSElpYWxMbG8roIUa/Xo7W1Fbm5ucjPz+et2BBnnz+TYx0/N8exGN5Yrn1leHgY4+PjvBabyclJXHjhhbjooovwxBNP8Pa7ud7gveCoVCq0t7cjNzcXRUVFa/7YNRoNOjs7cfbZZ7NqDnBs2V9VVcXb4VTubM9c4dh5V6VSwWAwMPPmo6Ki0NXVhbS0NF7XhZD0VFFRkU9jyEMNmRPDlrPPW8u1r5AUL5/FZmZmBnv27MHZZ5+Np556ipf7dOsVfuYv8EXqanBwEOXl5V4XUUqlUtjtdlbNAUajEQqFAtHR0aiurubtF5Bv3Z5FIhFiY2MRGxuLgoICLC0tQa1WY3p6GouLiwgPD0dYWBgMBkPApoNgoFQq0dnZyesiXuB0sfHAwACrrfujo6MRHR2NvLw8J8v12NiY312uidjU1dXxdqCfUqnEpZdeip07dwpiEwR4KTgURaGzsxNzc3NoaGjwyR4rFoths9lgMpkQGRkZ8KKr1WrR3t6OzMxMXhfNrYduz5GRkQgPD4fRaERpaSmkUinUajVGR0cRHh7u1OmA6/Mn81cqKiogl8s5PZfVcKxfCVaxsUwmQ2ZmJjIzM5nO5Gq1Gt3d3cywstUs1zRNY3h4GJOTk7wWm7m5OVx++eWoqKjAkSNHBLEJArxLqdE0jU8++QRWqxXV1dU+pa5IDU97ezu0Wi3i4uKYRpX+FGMGOjAtVPhrew414+PjGBwcxI4dO5wWcbvdzmxeO5oOUlNTnWaOhApiCqmsrAzqsK9AIXshXLm8aJrG4uIi87kZDIYVlmvilJyamkJtbS1vxUar1eLSSy9FQUEBnnvuOd7VKm0UeCc4wOl9m5iYGJ8WGlcnmtVqZfYONBoNoqOjkZqairS0NERHR696BU0KECcnJ1kbmBYMgml7ZhNynpOTk2sWdFIU5dTpgMyJIZ0OgllY61h4ymerLjnP6elp1puFBoI7y3VYWBiMRiPq6+t5KzZ6vR6XX3450tPTcfToUd7a8jcCvBQcX6Z+etM5wLFmZG5uDhEREUzkExcX53R/u92Ozs5OLC4uorq6mvPCOE84Tr7k+3n29PT41dzScU4MuYImpgMyXoEtaJpmHIjBtpEHAunZp1KpUFtby9vztFqt6OrqgkajYdyhobJc+8LCwgL27duHuLg4vPzyy7w1A20U1rXg+DPDxm63O4mPVCplxCcyMhJtbW0Qi8WorKzkbVjNpe3ZF+x2O9rb27G8vOxzetQdxHSgUqmg1+uZWfOpqalrRq2rQfYMFxcXUVNTw3rLHrZwFMW6ujpen+fg4CBmZmZQW1uLqKgoJ8v18vIyc+HAtuXaFwwGA7785S9DJpPh1Vdf5W0PxI3EuhUcxxSaSCTyyxzgOJpZqVTCZrMhKioKJSUlSE5O5tzl5Q4+2Z5Xw2KxQKFQMOLNdiqMOKdIypSYDlJTUxEfH++1+Njtdqdu43y9yCBdNubn51FbW8vbK3EyG2h2dtZjBObJcs1GiyRvMZlMuOqqq0BRFF5//XXepvs2GutScNjsHACcbgTa3t6O9PR0SCQSqFQq2O125kfAVYt+Vxxtz1u3buXcyeUJUtBJpkoG+71zNR04NqtczXRgtVqhUCgAANXV1bxJ87hCxiCYTCbU1NTwNqKlaRr9/f1QKpWoq6vzKmJw7XIdFhbGON58sVz7wvLyMq6++moYDAa8+eabIdmre/zxx/GrX/0Ks7OzqKysxO9//3s0NDR4vL9er8fdd9+No0ePQqvVIjc3F4cPH8Yll1wS9HMNJrwUnNXGTLMtNuPj40wjUOLwomkaCwsLUCqVUKlUsFgszHyYlJQUThYmtVqNjo4OXtuegS+6QnAlihRFOXU6sFqtzN6Bo+mANOGMiIjgdaRI0pJms5nXERgRG7K35E96ym63Q6fTMRcO3liufcVsNuO//uu/oFar8dZbb4XEaPPcc89h//79ePLJJ9HY2IjDhw/jn//8J/r6+tx2hLBYLDjjjDOQmpqKH//4x8jKysLY2BgSEhI8dsFfL6wbwSHmADbb1PT39685MM1x41qlUjFTFtPS0kLW6n292J61Wi3a2tp40wLG9bMzGo1ITExEYmIipqammFHLfEydAqd/BwqFgukfyNfRF8TIoFar/RYbd8+5luXaVywWC/bv34/x8XEcP348ZO7TxsZG1NfX47HHHgNweu3Jzs7GbbfdhjvvvHPF/Z988kn86le/Qm9vL28/c39ZF4LjjzlgNUh3YrKZ7cvmK5kPo1KpsLi4iMTERGbvgO1Uh6NNt7Kykre2Z+CL7tnuOhTzhaWlJUxMTGB8fBw0TTN1WmQB41ogHbHZbGhtbYVIJOLlzB2Co9gE08jgarmOiopixMebPTubzYZvfOMb6O3txXvvvReyYl6LxYKoqCj861//wr59+5jbr7vuOuj1erz00ksrHnPJJZcgKSkJUVFReOmllyCXy/Gf//mf+NGPfsTbSNxbePktdvzyuM6wCfRqlAxMCw8PR319vc9XENHR0cjPz0d+fj7jmpqdnUVfXx/i4+OdHG+B4Gh75vN8GOCL1iquBZ18w2KxYHp6Gvn5+diyZQuzdzA8PMxY5b1dwIKJ1WpFS0sLwsLCUFlZydtFhqZp9Pb2Ym5uLuiuuYiICGRnZyM7O9upyzXZgyNpN3eWa5vNhptuugnd3d149913Q/odnZubg91uR1pamtPtaWlp6O3tdfuY4eFhvPvuu/iv//ovvP766xgcHMQtt9wCq9WKe++9NxSnHTR4KTgEtvdryMA0tnqNRUZGIicnBzk5OTCbzcy+wcDAAGJiYpwKTX3B0fZcX1/P601iUngazNYqbKDVaqFQKJyacGZlZSErK4sxHahUKmaSp2Ong1Cm3CwWC5qbmxEVFYUdO3bwNt1HxIYLi7ZUKkVaWhrS0tKYQmG1Wo3BwUF0dnYiMTERYrEY8fHxyMnJwW233YbPP/8cJ06c4HVKmkBRFFJTU/GnP/0JEokEtbW1mJqawq9+9StBcIIFTdNMWo0NsZmdnUV3dzeKioqQnZ3N+hVseHg4tmzZgi1btjh1ORgZGUFkZCQT+azVadfR9sznRqEURTELDp+ryIEvZsRs3bp1xYRY4PSUWPL5ENOBSqVCT08PYzogbsVg5tSXl5eZcQ1lZWW8FhtSzFtbW8tpPZBYLGb25UpKShjL9ZEjR/Cb3/wG2dnZmJ+fx9/+9je3n32wSUlJgUQigVKpdLpdqVR6FL+MjAyEhYU5/fa3bduG2dlZWCwW3hpHvIGXgvPmm2+Cpmk0NTVBJpMFPDBtZGQEo6OjIUv5hIWFMc0OSfivVCrx+eefQyaTeawXIbZnvrfst9vt6OjowNLSEurr63lbEwJ80bbf22F5YrEYSUlJSEpKQmlpKRYXF5kLh87OzqDNiFlaWkJzczNjZODrZ+8oNnV1dbz77EmX60OHDkGv1+ODDz7Atm3b8NWvfhVJSUm44YYbQholyGQy1NbW4vjx48weDkVROH78OG699Va3jznjjDPwt7/9jcnsAEB/fz8yMjLWtdgAPBWctrY2PPLIIwCASy+9FFdeeSXOPvtsn99sUiyn1WpRX1/PSc8px/DfcTKmQqGASCRixIe01OG77dlqtTKb2XV1dbx20YyNjWFoaMjvtv0ikQhxcXGIi4tDUVERTCaT055dXFycU6cDfzEajWhpaYFcLuf1hQZN0+ju7oZOp+Ol2BAoisLdd9+N1157DSdOnEBxcTGWl5dx4sQJaLXakJ/PwYMHcd1116Gurg4NDQ04fPgwjEYjDhw4AADYv38/srKy8OCDDwIAbr75Zjz22GO4/fbbcdttt2FgYAC/+MUv8J3vfCfk5842vHSpAac3+j744AP861//wosvvojl5WVceuml2LdvH84777w1v+wWi4XZB6murubdPghFUdDpdFCpVJiZmYHdbkdiYiJyc3N52+WApHyio6NDUtDpL740C/UXi8XCpE1Jo0oiPq79+VaDjK7OyMjg9fgLIjZ6vZ73nQ5++tOf4i9/+QtOnDiBrVu3cn1KAIDHHnuMKfysqqrC7373OzQ2NgIAzj33XOTl5eHIkSPM/U+ePInvfe97UCgUyMrKwg033LAhXGq8FRxH7HY7Pv74Yzz//PN44YUXMD8/j4svvhh79+7FBRdcsML3bzQa0drayowu5uuH5NiVurCwEEtLS07FimlpabxpdGgwGNDS0oKUlBRs27aN1wsjaW5ZU1MTkr0lR9eUWq2GWCxmHG+rmQ4WFhbQ0tKC7OxsFBQU8Po9JY5JvovNgw8+iD/+8Y947733UF5ezvUpCbiwLgTHEYqicOrUKfzrX//CCy+8AKVSiQsvvBD79u3DRRddhBMnTuC5557DoUOHvBpJzRWeuj2TgjdS67O0tMS055fL5ZyksHQ6HRQKBXJycni9MDq+p1xtZpPIlUQ/drvdqdMBuXjQ6/VobW1Ffn4+8vLyQn6e3uIoNnV1dbzLFBBomsYjjzyCw4cP4/jx46iqquL6lATcsO4ExxGKotDa2op//etfOHr0KCYmJkBRFPbv34+f/vSnPqU2Qomj7bm6unrVvSnHSnmDwYCkpCRm3ycUG4jE4VVSUsLrIXSOLWD4kkIlLZKI+JAuFdHR0ZicnERxcTFj0eYjNE0zXbRra2t58Z66g6Zp/P73v8fDDz+MN998E/X19VyfkoAH1rXgECiKwp133ok//vGPuPLKK9Hc3Iz+/n6cf/752Lt3Ly677DIkJibyQnyI7ZnUWfiS7iMpN6VSiYWFBcTHxyMtLY312TCEyclJ9Pf3e+3w4grHJpxVVVW8NTIYjUaMjo5ienoaAJhCYX9btQQTEi2uB7H54x//iPvvvx9vvPEGmpqauD4lgVXYEIJz//3349lnn8Vrr72GkpISJo9PIp/Ozk6cffbZ2LdvHy677DLI5XJOxIdN2zNp9aFSqaDT6RAbG8tEPoEuXmQG/fj4OK8niQKnN+9bWlogk8l4XZUPnI4WOzo6sH37diQlJTF7PhqNBlFRUYz4cB2Zk/lABoOB92Lz9NNP48c//jFeffVVnH322VyfksAabAjB0Wq1oGnabTM+4lh6/vnncfToUbS0tGDXrl3Yu3cvrrjiCmRkZITkxx3Mbs+OjinHcdr+zBchdRZzc3Mh23T3FzIGgZhD+OjsI8zOzqKrqws7duxYES0S0wEZCiiRSBjHG6maDxVEbIxGI2pra3lb90HTNP7617/iBz/4AV5++WWcd955XJ+SgBdsCMHxFpqmMT4+zojPp59+ioaGBlxxxRXYu3dvUDoQAF/0GisrK1vRU4ltbDYb5ubmoFQqMTc3h/DwcCbtttaVMynoJHNX+OpGAk6np5qbmyGXy3k9Gwj4ovi0oqICKSkpq97X0S6vVqsZ0wHpdBBMx+J6Ept//OMfuO222/D8889jz549XJ+SgJdsKsFxhKZpTE9P4+jRozh69Cg++ugjVFVVYd++fdi7dy8r7fUduz2vNgIhWDj2CFOr1U4tXFz3tMg+CE3TvG6FD3xhJ96yZQsKCwt5LTbkYsOf4lN3pgMyH0Yul7Oa6nIc8sZnsQGAo0eP4qabbsJzzz2Hyy67jOvTEfCBTSs4jtA0DaVSiRdffBFHjx7FiRMnsH37dkZ8SkpKfF7UyNXiwsKCk+2ZKxzHaavVatA0zYhPVFQU2traEBkZ6bORIdSQmTt8txMDwOjoKEZGRlBdXc3KxQbpE6ZSqRjTCEm9BTKDhojN0tISr4e8AcArr7yCb3zjG/jrX/+KK6+8kuvTEfARQXBcoGkaWq0WL730Ep5//nm88847KC4uxt69e3HllVd6VfRIogWKota0PXMBTdNMg0rSEDAyMhJFRUWQy+W8FRyyD8bnmTvAF/37xsfHUVNTE5QRxo7dycl8GH9MBxRFMbOh+C42b7zxBvbv34+nn34a//Ef/8H16Qj4gSA4q0DTNObn5/Hyyy/j6NGjeOutt5CdnY29e/di3759qKioWLGhG4jtOdSQ4sPU1FSEhYVBpVLBbDYzewZyuZwXXQ4AYGZmBt3d3SgvLw/6PlggkDTq9PQ0ampqQtK/j+zbqdVqxnRAPr/VTAcURaGtrQ1msxm1tbW8TqMeP34c1157Lf74xz/iP//zP3mdRhXwjCA4PrC4uIjXXnsNzz//PN544w2kpqbiiiuuwJVXXona2lp89NFHePnll/HNb36T100YgS+iheLiYmRnZwM4vVgajUYolUpmJLNjlwOurn7Hx8cxODiIysrKkI0F9gfHtjq1tbWcpFFJ6pREPxRFMXs+jqYDIjYWiwU1NTW8FpsPPvgAX/3qV/G73/0O119/Pa9/VwKrIwiOnxiNRhw7dgzPP/88XnvtNURHR0On0+FrX/safvOb3/AmMnDH1NQU+vr61nTNmUwmpsvBwsICM06b7db8niD1QBMTE0FrwskWfJoR43hOCwsLzL7d0tISkpKSkJKSApVKBZvNxnux+fjjj/GVr3wFv/71r3HjjTcKYrPOEQSHBR599FHceeedOOuss/D5558jIiICl19+Oa688krs2rWLN+JD9hbGxsZQWVnpk2tqeXmZER+9Xo+4uDgn00EwzrWvrw9KpRK1tbW8rgciVfkLCwu8bm5JotexsTHYbDamU4VcLg/KZxgop06dwt69e/Hzn/8c3/72twWx2QAIghMgv/3tb/Hzn/8cL730Es444wxYLBa8++67eP755/Hiiy9CJBLhsssuw5VXXomzzjqLs7SUY7qnuro6oL0Fi8XCiI9Wq2XGaZMuB4EuDGSOEWmFz4dowROOduKamhreVuUDp23ybW1tsNls2L59O9NkVKvVIjo6mnG8rTWVNhS0tLTg8ssvx09+8hN873vf4/x8BNhBEJwAGRkZgdVqRUlJyYq/kZk+//znP/Hiiy/CbDbjsssuw969e3H++eeHbHEiw90MBgNqampYXcCtVivm5uaYKvmIiAim0NSfhctxmuh6WMBJw1C+O7wcxaampsYp6rZarU6dDsLCwhjxSUhICHkHh/b2dlxyySW444478KMf/UgQmw2EIDghgsz0IWMVFhcXmZk+u3fvDlpKg3SmpigKVVVVQV0U7XY7Iz5qtRphYWFM5JOQkLDmwmGz2Zzs5HzeW7DZbE4dv/l8rna73el9XS3F665ey7HTQbBdl93d3bj44otx66234tChQyETm8cff5wZkFZZWYnf//73aGhoWPNx//u//4trr70We/fuxYsvvhj8E13nCILDARRF4dNPP2XER61WMzN99uzZw9p+xfLyMlpbWxEREYGKioqQWrQpinLqcuA4TtudVddisaC1tRVhYWG8b8JJ6qxEIhGqqqp4s0fnDl/ExhVSFkAcb8vLy06dDti+eOnr68PFF1+Mb3zjG/j5z38eMrF57rnnsH//fjz55JNobGzE4cOH8c9//hN9fX2rdkkfHR3FmWeeiYKCAiQlJQmC4wWC4HAMRVFoaWlhOltPTk5i9+7d2LdvHy6++GK/OwcbjUa0tLQgKSkJ27Zt47SxJUVRTKEpGUoml8uRlpaGpKQkWK1WtLS0ICYmhvdNOMm5rgdhtNvtaG1tZdoVBSKMxDJPxGdxcREJCQlM6i3QNO3g4CAuvvhiXHvttXj44YdD+h1obGxEfX09HnvsMQCnv6/Z2dm47bbbcOedd7p9jN1ux9lnn41vfOMb+PDDD6HX6wXB8QJBcHgEaYdDxGdwcJCZ6XPppZd6PdNHr9dDoVDwstcYuWom4mM2mwGcng1TWVnJ69SU2WxGS0sLU9TLZ2EkYgMgKFEYGY/haDrwt0P56OgoLrroIuzduxePPvpoSN9Xi8WCqKgo/Otf/8K+ffuY26+77jro9Xq89NJLbh937733or29HS+88AKuv/56QXC8RBAcnkLTNHp7exnx6erqwjnnnMPM9ElJSXH7oyYFnUVFRbyeJgmcbsLZ3NyM6Oho2Gw2XozT9sTy8jKam5sRFxeHsrIyXouNzWZDa2srRCIRqqurgx6FEeMI6XRA9u7kcvmapoOJiQns2bMHF110EZ544omQv6/T09PIysrCJ5984jS87Y477sD777+PTz/9dMVjPvroI1xzzTVQKBRISUkRBMcH+Jt83uSIRCJs27YNP/nJT3DPPfdgcHAQzz//PJ555hl897vfxRlnnMHM9ElPT4dIJMI//vEPJCQkoLKyktftXwBAp9NBoVAgLy8P+fn5AE6nAVUqFcbHx9Hd3c0UmqampnLqVltaWkJzczMSExOxfft2XkWMrhCxEYvFqKqqCknKLywsDBkZGcjIyIDdbmc6HXR0dICmaadOB47nMzMzg0svvRTnn38+Hn/8cV6LOGFxcRFf//rX8dRTT605akJgJUKEs86gaRpjY2PMTJ9Tp06hoaEBcrkcb7/9Nl5++WXej9kli1FJSQm2bNni9j5knLZKpcL8/DwzjpmN/QJfIHN3UlNTed+uiAuxWQ136dPJyUksLi7inHPOwf79+9HQ0IAjR45wdq6+ptQUCsWKqJGiKACAWCxGX18fCgsLQ3Lu6xFBcNYxZKDc17/+dXz22WdISUlBRkYGM1YhLy+PdwskacJZVlaG9PR0rx5jNpuZRUun0yEmJoap9QlmvzKDwYDm5mZkZmaiqKiId++lIzabDS0tLZBIJLwQG1eI6eDvf/87nnjiCQwODiI5ORl33nknvvzlL3M6aqKxsRENDQ34/e9/D+C0gOTk5ODWW29dYRpYXl7G4OCg02333HMPFhcX8eijj6KkpITX9VhcIwjOOsZsNuPrX/86FAoFjh07hqioKLzwwgs4evQo3n//fZSVlTHiU1xczPmCSYaReTP50hNWq9VpnHZkZCRSU1ORlpbm82b1apAhb9nZ2SgoKOD8vVsNIjZSqZT3zjmNRoNLL70UW7ZswUUXXYRXXnkFJ06cwJVXXol//OMfnJzTc889h+uuuw5//OMf0dDQgMOHD+Mf//gHent7kZaWhv379yMrKwsPPvig28cLezjeI+zhrGNIJ+CPP/4YcrkcAHDzzTfjW9/6FjQaDTPT5xe/+AVKSkqYsQrezPRhE8cebjU1NQENIwsLC0NmZiYyMzOZtvwqlQqfffYZZDIZk3aLj4/3+zWSsQ3rYcib1WpFa2vruhAbvV6PvXv3IicnB0ePHoVMJsN3vvMd6HQ6jI2NcXZeV199NdRqNQ4dOoTZ2VlUVVXh2LFjzD7o+Pj4uthfWg9wEuH4UtXb1dWFQ4cOobm5GWNjY/jtb3+L7373uwE952bCcabP888/j7feegu5ubmM+ATb3kvTNPr7+zE7OxvU+TBks1qpVK4Yp+1LexatVguFQuE0toGvrKeaoIWFBezduxcJCQl46aWXeNvgVCC4hFy2n3vuORw8eBD33nsvWlpaUFlZiT179kClUrm9v8lkQkFBAX75y196zPn7+pybCZFIhISEBOzfvx8vvfQSlEol7r33XgwNDeGCCy5AZWUl7r77bnz++efM5idbkCacKpUK9fX1QR1GJpFIIJfLUV5ejnPOOQdlZWWgaRodHR344IMP0NXVBbVaveprnJubg0KhQGlp6boRG5lMxss9G0cMBgOuuuoqREdH48UXXxTEZhMT8gjHn6peQl5eHr773e+uiHACec7NjNFoxBtvvIHnn38er7/+OhISEnDFFVdg3759aGhoCGgRIw1DjUYjampqOFtkHMdpkxkwpDdYSkoK8xpVKhU6Ojqwfft2ZGRkcHKu3mK1WtHc3Izw8HBUVlbyOt1jMpnwla98BTRN4/XXX+f1mAmB4BPSPRyLxYLm5mbcddddzG1isRi7d+/GyZMnefOcm4Xo6GhcddVVuOqqq7C0tIS33noLR48exVe/+lVERkbi8ssvx759+3ye6UMaW9psNtTV1XHq2hGJREhMTERiYiJKSkqwuLgIlUqFwcFBdHZ2IiUlBTKZDFNTU6ioqFi1dxYfIGJD+uPxWWyWlpZwzTXXwGq14tixY4LYCIRWcObm5mC321cUJaalpaG3t5c3z7kZiYyMxN69e7F3715YLBa88847OHr0KL7+9a9DJBIx4nP22Wev2gGANOGUSqWora3lVWNLkUiEuLg4xMXFobCwEEajEYODg5icnIRIJMLk5CQsFgtSU1N5aW21WCxoaWlZF2JjNpvxta99DfPz83j77bcRFxfH9SkJ8AD+fmMFOEMmk+GSSy7B//t//w/T09P4+9//jrCwMNx4440oKCjAzTffjGPHjjF90AhGo5GZeBpos8hgIxKJoNPpmJHQu3btQlJSEqanp/HBBx/g888/x/j4OJaXl7k+VQBfRPKRkZG8FxuLxYL9+/djdnYWx44dC8iVKLCxCOm3luTMlUql0+1KpdLrIsBQPKfAF4SFheFLX/oSnnzySUxNTeHo0aOIi4vD7bffjvz8fNxwww145ZVX0NzcjIaGBuj1et43tgRON4wcHBxETU0NkpKSEBUVhby8PDQ0NODMM89EWloaVCoVPvroI5w6dQqjo6MwmUycnCsRm/XQNNRqteKGG27A6Ogo3nrrLSQnJ3N9SgI8IqTfXJlMhtraWhw/fpy5jaIoHD9+3O92LMF4TgH3SCQSnHPOOfj973+PsbExvP7668jIyMD3v/99XHjhhcjKysLS0hKWlpa4PlWP0DSNoaEhjI6Oora21u3Vd0REBLKzs1FXV4ezzz4bWVlZ0Ol0+OSTT3Dy5EkMDQ3BYDAgFH4bIjbR0dG8FxubzYZvfetb6Onpwdtvv83UhgkIEEKe8zh48CCuu+461NXVMVW9RqMRBw4cAIAVVb0WiwXd3d3M/5+amoJCoUBMTAyKioq8ek4B9hGLxdi1axcA4Omnn8aBAwcQExODn/3sZ/jWt761YqYPH6BpGoODg5ienkZdXZ1Xm9gymQxZWVnIyspyGqc9OjqKiIgIptbH37lFq+EoNnyfE2S323HrrbeiubkZJ06cELILAm7hpPDzscceY4o0q6qq8Lvf/Q6NjY0AgHPPPRd5eXk4cuQIgNOpD9JN2JFzzjkHJ06c8Oo5BYLDwsICCgsLcf/99+Pmm28GcDq6bG9vZ5qLDg0N4Utf+hIz08ebUdPBgKZp9PX1QaVSoba2NuAebHa73WmiqVQq9Wmc9lqYzWY0Nzevi6F0FEXh9ttvx4kTJ/Dee+/xfiyGAHcIvdQEAmJmZsZj3QpN0+jp6WFm+nR3d+Pcc8/F3r17V53pwzY0TaO7uxs6nQ61tbWsd5umKAparZap9RGJRMxEU3fjtNeCiE1sbCzvZ+9QFIUf/vCHeP3113HixAm3F4cCAgT+fpODxOOPP468vDxERESgsbERp06d8njfrq4ufOUrX2G6Lh8+fHjFfe677z6IRCKnf1u3bg3iK+AXqxVJikQibN++HYcOHUJrayu6urpw3nnn4ciRIygqKsJll12GP/3pT5idnQ3afgiZoqrX61FXVxeU0QZisRgpKSnYvn07zjnnHGavpaurC++//z46OzuZ0dprQcQmLi5uXUQ2d999N1555RW88847gtgIrAl/v81BIBhtdQCgrKwMMzMzzL+PPvooWC9h3SISiVBcXIy77roLp06dQn9/Py699FL84x//QGlpKfbs2YPHH38ck5OTrIkPRVHo6OiAwWBAXV1dSLodiEQiJCUlYevWrTjrrLNQU1OD8PBw9Pf34/3330d7eztmZ2dhs9lWPNZsNuPzzz9nporyuUM1TdO4//778Y9//APvvPMOiouLuT4lgXXApkqpBaOtzn333YcXX3wRCoUiSGe9saFpGpOTkzh69CiOHj2KTz75BDU1NcxYhdzcXL8WXrvdjra2Nlit1v+/vXsPiqru/wD+BgQUMBFZbhbXAiuFBblkSDChXB5F1yeLgAKFaMZLNyQtG6DSwmW2JLUHkhlCtp4BBFS8QUkuWSCjhoJADBoTg7BI5ILIoAjf3x/+OI+bZnLZswv7ec3sjG7fPfs9pn483/M97w/c3d3V/iAnYwx9fX3cslt/fz/MzMy4VszDw8M4d+4cZs2aNSmKTWpqKvbu3YsffvgB8+fPV/eUyCShNVc4Izt+lixZwr03URE4zc3NsLGxgaOjI6KiotDa2jre6WoNHR0dPPbYY9xN59bWVsTExKC8vBxubm7w8/ODRCJBc3PzQ1/5jHS+vH37Njw8PNRebIA75zlz5kw4OTlh0aJFeOaZZ2Bqaoq2tjb8+OOP+Pnnn6Gvr6/xjd4YY/jss8+QkZGB7777jooNGRWtKTgPisCRy+VjPq6Pjw9ycnJQWlqKjIwMtLS0wM/PD9evXx/vlLWOjo4OrK2tsX79enz//ffo6OjAhg0bUFVVBW9vbyxatAipqaloaGj42+IzkqKso6MDDw+PB8bwqJOxsTEcHBzg5uYGAwMDrnncyIOmv//+u8Y9z8QYw65du5Ceno7S0lIIhUJ1T4lMMpqbPTJJhIaGcj92dXWFj48P7OzsUFBQgLi4ODXObHLT0dGBubk54uLiEBsbC4VCwfX0kUgksLe3x4oVK7Bq1Sru5rpcLodMJoOLiwtcXV01OrIfuNOu+OzZszA3N+ea4t28eZPraNrc3AwTExNuu7U6wy8ZY8jMzIRYLMbx48fh5eWltrlomtzcXLzzzjtob2+HoaEh975IJMLMmTMhlUrVODvNojVXOHxF4JiamsLZ2fmevudk7EYSn2NiYlBSUoLOzk4kJSXh0qVLCAwMhFAoxLvvvovAwEAcOnRI45uRAXeSlM+ePQszMzOlDqyGhoZ49NFH4eHhAX9/f9ja2qK3txfV1dWorKzEpUuX0Nvby0vKwQjGGLKzs/HRRx/h8OHDvCZ4jGZXaVZWFvz8/Lh08CVLljxw/ER58cUXMTQ0hJKSEu69q1ev4ujRo4iNjVX5908mWlNw+IrA6evrw+XLlzW+p8pk9sgjjyAyMhJFRUXo7OxEYmIipFIpbt++jdraWrz//vs4ffr0Q21DVoeRYjNnzpwHtvseaactFArh7+8PJycn9Pf34+zZs/jpp5/Q1NQEhUKh0uLDGINUKsXWrVtx6NAh+Pn5qey7/mq0u0plMhkiIiJw8uRJVFVV4bHHHkNQUBCuXLmi0nnOmDEDkZGR+Prrr7n3vvnmG9ja2iIgIECl3z3ZaNUutfz8fMTExOCrr77iInAKCgrw66+/wtLS8oGxOv/6178QFRWFqKgopVidxMREhIWFwc7ODu3t7UhJScH58+fR0NBAWVI8aGlpQWBgIAIDA7Fz506urcLhw4dhZGTENZRbtGiRRqRXjxQbc3NzzJs3b8w78EYeNO3q6oKOjg637DaWB03/DmMM+fn5ePPNN1FcXIygoKAJOe7DGm9jxaGhIcyePRt79uxBdHS0SudaU1MDLy8v/P7775g7dy5cXV3x4osvIikpSaXfO9mo/08gj8LDw9HV1YXk5GQuAqe0tJTbSNDa2qr0h7W9vR3u7u7czyUSCSQSiVKsTltbGyIiItDd3Q2BQIDFixfj9OnTVGx4cubMGaxYsQKff/45dHV1IRKJIBKJMDAwgPLychQXFyMqKgp6enpcTx8/Pz+1bCYYKTYCgQAuLi5j3o020k57ZDv1tWvXcPXqVVy8eBGMMQgEAlhYWGDOnDnjKj7FxcV44403UFBQwHuxmYjGiv39/RgcHISZmZmqpslxd3eHm5sbcnNzERQUhPr6ehw9elTl3zvZaNUVjib48ssvucw3Nzc37N69G97e3vcdm5WVhdzcXFy8eBEAsHDhQnz66adK4xljSElJQVZWFhQKBXx9fZGRkUEP4t1lcHAQFRUVKCwsxMGDBzE4OIiwsDCsXLkSAQEBSjd6VaW/vx/nzp0bd7F5EMYYenp6cPXqVXR2dmJwcBDm5uawtLTEnDlzRnWFV1JSgri4OHz77bcQiUQTPtd/0t7ejrlz56KyslJpyXvz5s2oqKhAdXX1Px5j/fr1KCsrQ319PS8P/WZkZCA9PR1Lly5Fc3MzysrKVP6dk43W3MPRBKpYk05LS8OuXbuQmZmJ6upqGBsbIzg4WGMah2kCfX19LFmyBJmZmWhra0NRURFMTEzwxhtvwMHBAa+99hqOHDmism3II/ddLCwsVFZsgDubK0Y2rSxevBienp4wMjLC5cuXUVFRgfPnz6O9vR2Dg4MPPM7x48cRFxeHnJwctRSbibBjxw7k5eXhwIEDvBQbAIiMjERbWxuysrJos8DfoCscHk30mjRjDDY2Nti0aRMSExMBAD09PbC0tEROTg5efvlllZ7PZDc0NITTp09zVz7d3d0IDg6GSCRCUFDQuBOlgf8VG0tLSzg7O6vtoc67Uw76+vqUUg7uvsIrLy9HREQE9u7di4iICLXN99atWzAyMkJhYaFS0YuJiYFCocChQ4f+9rMSiQTbt2/HiRMn4OnpycNs/yc6OhpHjx69Z4s0uYOucHgyEUkHf12TbmlpgVwuVzrmrFmz4OPjM+70BG2gp6cHX19f7Ny5E5cvX+YCKD/88EPY29sjMjISBQUF6O3tHdPxR1puW1lZqbXYAICJiQkcHR3xzDPPwNfXF3PmzEFHRwdOnTqF9957D9u3b8f+/fsRERGBPXv2qLXYAGPfVZqWloZt27ahtLSU92IDAFeuXEFUVBQVm79BBYcnE5F0sGXLFtjY2HAFZuRzE52eoI10dXXh7e2NtLQ0NDU14aeffsL8+fORlpYGe3t7vPTSS/j2228fehvy3cXmiSee0Ki4mhkzZsDOzg5eXl7w8/ODra0tjh07htjYWAgEAnR0dGjEc2QJCQnIysrCvn370NjYiHXr1t3TrPHuTQVisRhJSUnIzs6Gvb095HI55HI5+vr6VD7Xa9eu4cCBA5DJZNiwYYPKv2+yooIzSahjTVpb6erqwt3dHdu3b0d9fT3OnTvHLYXa29vj3//+N3JycvDHH3/ct/iMFBsbGxuNKzZ/ZWhoiIULF6KlpQWffPIJkpKSUFlZifnz52Pjxo1qnVt4eDgkEgmSk5MhFApx/vz5e3aVdnR0cOMzMjJw69YtrF69GtbW1txLIpGofK7u7u5Ys2YNxGIxXFxcVP59kxXdw+GJKtakf/vtNzg5OaGmpkYp18rf3x9CoRBffPGFKk5FazHG0NzczDWUu3DhAvz8/LBy5UqEhYXB0tISNTU1OHLkCCIjI+Hk5KTRxQYAfvnlF4SFhSEpKQnvvPMON9/e3l50d3dTjxsyoegKhyeqWJN2cHCAlZWV0jFHYlD4jB/RFjo6OnB2dsbWrVtx5swZNDU1ITQ0FHl5eXBxcUFgYCDCwsLQ2dkJR0dHjS82Fy5cwIoVK7BlyxalYgPcSXOgYkMmGl3h8Gi0SQdisRjJycn473//C19fX+44JiYmXJCjWCzGjh07sG/fPjg4OCApKQm1tbVoaGigpTeeMMZQXl6OVatWwdbWFr/++iu8vLywcuXKcfX0UaX6+nqEhobizTffRFJSksbNj0xRjPBq9+7dzNbWlhkYGDBvb292+vRp7r/5+/uzmJgY7ud2dnYMwD2vlJQUbszw8DBLSkpilpaWzNDQkAUGBrKmpiYez4jU1dUxgUDAPvzwQzY8PMyuXLnC9uzZw55//nk2bdo05uHhwT7++GN24cIF1tfXx27cuKHW17lz55iFhQXbunUrGx4eVvcvH9EidIVDyDjV1dWhrKyMexZqBGMMf/zxBw4ePIiioiL88MMPmDdvHtfNdKxZauPR3NyM0NBQREVFQSwWT1juGiEPg363aZmJjntfs2YNdHR0lF4hISGqPg2NsmDBgnuKDXDnno9AIEB8fDyOHz8OuVyOhIQE1NTUwNfXF15eXvj4449RV1eH4eFhlc+zpaUFy5cvx+rVq6nYELWgKxwtkp+fj+joaGRmZsLHxwfp6enYv38/mpqaYGFhcc/4qKgo+Pr64tlnn8X06dMhFotx4MAB1NfXY+7cuQDuFJzOzk6laHZDQ0PMnj2bt/OajHp6enDkyBEUFRWhrKwM1tbWWLlyJVatWgWhUDjhxaC1tRUhISEICQnBf/7zHyo2RC2o4GgRVcS9r1mzBgqFAgcPHlTl1Ke0vr4+HDt2DEVFRTh+/DjMzMy4tgpeXl7jbibX3t6OkJAQ+Pv7Y+/evRrfnI5MXfTPHC2himidETKZjAumXLduHbq7uyd07lOdiYkJXnrpJeTn50Mul2Pnzp24du0aXnjhBTz55JNITEzEqVOncPv27VEfWy6XY9myZVi0aBEVG6J2VHC0hCqidQAgJCQEubm5KC8vh1gsRkVFBUJDQzW226amMzIywqpVqyCVStHR0YHMzEwMDAwgMjISzs7OeOutt3Dy5Ml/THwGgK6uLoSFhcHd3R1ff/01FRuidlrVgI2M3Ui0jkwmU3q+5+5E6gULFsDV1RVOTk6QyWQIDAxUx1SnjOnTp2P58uVYvnw5BgcHIZPJUFhYiNjYWAwNDWH58uUQiUQICAiAgYGB0me7u7sRFhYGFxcXSKVSjeh2Sghd4WgJc3Nz6OnpobOzU+n9zs5OWFlZPfCzEokEO3bswHfffQdXV9cHjnV0dIS5ublGhD9OJfr6+li6dCm++uorXLlyBYWFhTA2NsaGDRvg4OCA+Ph4HDlyBAMDA1AoFNwDp3l5eWrpbkrI/VDB0RJ8xb23tbWhu7sb1tbWEzJvcq9p06YhICAAX375JVpbW3H48GEIBAJs3rwZdnZ2cHV1xezZs7F///57rnwIUSs1PnRKeJaXl8cMDQ1ZTk4Oa2hoYK+//jozNTVlcrmcMcbYq6++yt577z1u/I4dO5iBgQErLCxkHR0d3Ov69euMMcauX7/OEhMTWVVVFWtpaWEnTpxgHh4e7IknnmADAwNqOUdtNjQ0xH788Ufm7+/P/T8iRJNQwdEyExmt09/fz4KCgphAIGD6+vrMzs6OxcfHcwWMEELuRs/hEEII4QXdwyG8Gk20TnFxMTw9PWFqagpjY2MIhUJIpVKlMYwxJCcnw9raGjNmzMCSJUvQ3Nys6tMghIwBFRzCm/z8fCQkJCAlJQW//PIL3NzcEBwcjKtXr953vJmZGT744ANUVVWhtrYWa9euxdq1a1FWVsaNSUtLw65du5CZmYnq6moYGxsjODgYAwMDfJ0WIeQh0ZIa4c14o3UAwMPDA8uWLcO2bdvAGIONjQ02bdrEhWf29PTA0tISOTk5Ss8IEULUj65wCC/GG63D/r/JWVNTE5577jkAd9KP5XK50jFnzZoFHx+fh47rIaM3mmVRANi/fz/mzZuH6dOnY8GCBTh27BhPMyWahgoO4cVYo3V6enpgYmICAwMDLFu2DLt378bSpUsBgPvceOJ6yOiMdlm0srISERERiIuLQ01NDUQiEUQiES5evMjzzIkmoIJDNNrMmTNx/vx5nDlzBp988gkSEhIgk8nUPS2t9fnnnyM+Ph5r167FU089hczMTBgZGSE7O/u+47/44guEhITg3XffxZNPPolt27bBw8ODW1Yl2oUKDuHFWKN1dHV18fjjj0MoFGLTpk1YvXo1UlNTAYD73FjiesjojWVZtKqqSmk8AAQHB9OSp5aigkN4MdZonb8aHh7GzZs3AQAODg6wsrJSOmZvby+qq6tHdUzycMayLCqXy2nJk3Co4EwBXV1dsLKywqeffsq9V1lZCQMDA6W/jNUtISEBWVlZ2LdvHxobG7Fu3TrcuHEDa9euBQBER0fj/fff58anpqbi+++/x2+//YbGxkZ89tlnkEqleOWVVwDcaeH89ttvY/v27SgpKUFdXR2io6NhY2MDkUikjlMkhDwAZZZPAQKBANnZ2RCJRAgKCoKLiwteffVVbNy4UaNaBISHh6OrqwvJycmQy+UQCoUoLS3l/gXc2tqq1Pr4xo0bWL9+Pdra2jBjxgzMmzcP33zzDcLDw7kxmzdvxo0bN/D6669DoVBg8eLFKC0tVWqhQCbGWJZFraysaMmTcOg5nClkw4YNOHHiBDw9PVFXV4czZ87A0NBQ3dMiU4iPjw+8vb2xe/duAHeWOG1tbbFx48b7PksVHh6O/v5+HD58mHvv2WefhaurKzIzM3mbN9EQaktxIxOuv7+fOTo6Mn19fVZbW6vu6WisPXv2MDs7O2ZoaMi8vb1ZdXX1344tKipiCxcuZLNmzWJGRkbMzc2N5ebmKo2JiYm5J+A0ODhY1aehFqNNHP/555/ZtGnTmEQiYY2NjSwlJYXp6+uzuro6dZ0CUSMqOFNIXV0dmz59OtPT02MlJSXqno5GysvLYwYGBiw7O5vV19ez+Ph4Zmpqyjo7O+87/uTJk6y4uJg1NDSwS5cusfT0dKanp8dKS0u5MTExMSwkJESphcOff/7J1ynxbjSJ44wxVlBQwJydnZmBgQF7+umn2dGjR3meMdEUtKQ2Rdy6dQve3t4QCoVwcXFBeno66urqYGFhoe6paZSJjtcBgDVr1kChUODgwYOqmjYhUwLtUpsiPvjgA/T09GDXrl3YsmULnJ2dERsbq+5paRRVxOuMkMlksLCwgIuLC9atW4fu7u4Jnz8hkx0VnClAJpMhPT0dUqkUjzzyCHR1dSGVSnHq1ClkZGSoe3oaQxXxOgAQEhKC3NxclJeXQywWo6KiAqGhoRgaGlLZuRAyGdG26CkgICAAg4ODSu/Z29ujp6dHTTOaWkbidfr6+lBeXo6EhAQ4OjoiICAAAJRSqRcsWABXV1c4OTlBJpNp1LZ0QtSNCg7RGuON1wEAoVCIxsZGpKamcgXnrxwdHWFubo5Lly5RwSHkLrSkRrSGKuJ17qetrQ3d3d2wtrYe13wJmWroCodolYSEBMTExMDT0xPe3t5IT0+/J15n7ty5XEBoamoqPD094eTkhJs3b+LYsWOQSqXcvbG+vj589NFHeOGFF2BlZYXLly9j8+bNePzxxxEcHKy28yREE1HBIVplouN19PT0UFtbi3379kGhUMDGxgZBQUHYtm0bpTwQ8hf0HA4hhBBe0D0cQgghvKCCQwghhBdUcAghhPCCCg4hhBBeUMEhhBDCCyo4hBBCeEEFhxBCCC+o4BBCCOEFFRxCCCG8oIJDCCGEF1RwCCGE8OL/AOZbKXSlB11NAAAAAElFTkSuQmCC\n" + "image/png": "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\n" }, "metadata": {} } ] }, + { + "cell_type": "markdown", + "source": [ + "So we now have plots and potentials of our optimized NaCl configurations" + ], + "metadata": { + "id": "oTSG6KU_g4Ou" + } + }, { "cell_type": "code", "source": [], From c825cfafb3c774e9a478fe620399c9a5347eed1f Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 12:19:41 -0500 Subject: [PATCH 8/9] Included Proper Configuration Plot for Configuration 3 --- configurations_3_4.ipynb | 60 ++++++++++++++++++++++++---------------- 1 file changed, 36 insertions(+), 24 deletions(-) diff --git a/configurations_3_4.ipynb b/configurations_3_4.ipynb index e6ac0e6..64fbc4e 100644 --- a/configurations_3_4.ipynb +++ b/configurations_3_4.ipynb @@ -4,7 +4,7 @@ "metadata": { "colab": { "provenance": [], - "authorship_tag": "ABX9TyPK0WoBMFGCECTBuGC6DlRu", + "authorship_tag": "ABX9TyOXEerchrWdLJwS6LrMtlI8", "include_colab_link": true }, "kernelspec": { @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": { "id": "1GeaDxEAXJ_T" }, @@ -77,7 +77,7 @@ "metadata": { "id": "uZScXL7gXXXa" }, - "execution_count": 13, + "execution_count": 2, "outputs": [] }, { @@ -144,7 +144,7 @@ "metadata": { "id": "T2pmvPVZXZpg" }, - "execution_count": 14, + "execution_count": 3, "outputs": [] }, { @@ -193,27 +193,27 @@ ], "metadata": { "id": "_WPPizyPXgL3", - "outputId": "44060b7c-b66a-4a2e-90f6-580ff1286fcc", + "outputId": "83da4393-70f1-4f1d-c545-43c7bb97cdf1", "colab": { "base_uri": "https://localhost:8080/" } }, - "execution_count": null, + "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Final optimized cluster positions\n", - "[[ 0.29080935 0.38842798 0.6701392 ]\n", - " [ 0.28860656 0.2112047 -0.10049432]\n", - " [ 0.43670676 0.40617825 0.33924627]\n", - " [ 0.14273259 0.19342553 0.23040046]\n", - " [ 0.36971515 0.31186562 0.11353969]\n", - " [ 0.4873078 0.49095195 0.56897054]\n", - " [ 0.20972141 0.28774438 0.45610812]\n", - " [ 0.09211242 0.10866851 0.00067172]]\n", - "Final potential: -27.729842280010452\n" + "[[0.37370486 0.3663673 0.68633102]\n", + " [0.21406818 0.35775747 0.36147251]\n", + " [0.69055059 0.44873685 0.49566194]\n", + " [0.85019143 0.45735322 0.82051268]\n", + " [0.45295514 0.4041349 0.41894122]\n", + " [0.91879478 0.49004909 0.58903489]\n", + " [0.14546106 0.32505694 0.59295008]\n", + " [0.61130251 0.4109706 0.76304605]]\n", + "Final potential: -27.729842281439847\n" ] } ] @@ -257,23 +257,22 @@ "charges = cluster.charges\n", "x,y,z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2]\n", "ax.scatter( x,y,z, c=charges, cmap='coolwarm' )\n", - "ax.text(1, 1, 1, 'Final Potential: -27.72984', color='red')\n", + "ax.text(.25, .5, .5, 'Final Potential: -27.72984', color='red')\n", "ax.set_title('Configuration 3 - Rectangular')\n", "ax.set_xlabel('x')\n", "ax.set_ylabel('y')\n", "ax.set_zlabel('z')\n", - "plt.show()\n", - "\n" + "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 437 + "height": 440 }, "id": "isG4DNcFZvBS", - "outputId": "ca5d5288-ebbe-45da-ad4b-915073463d7e" + "outputId": "daa85f69-d2c2-4e9d-b51a-cfcd3ea736a8" }, - "execution_count": 15, + "execution_count": 18, "outputs": [ { "output_type": "display_data", @@ -281,7 +280,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } @@ -290,7 +289,20 @@ { "cell_type": "markdown", "source": [ - "And then for configuration 4 we have the same deal" + "As noted above this plot is consistently rendering strangely in colab (and not configuring final positions properly), though it works on my local machine running spyder in a regular python file. Locally the output looks as follows\n", + "\n", + "![rectplot.png](data:image/png;base64,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)\n", + "\n", + "So I assume it has something to do with the machinery being different on colab that I'm struggling to parse." + ], + "metadata": { + "id": "r8AKPb9CW5uP" + } + }, + { + "cell_type": "markdown", + "source": [ + "And then for configuration 4, we run the same procedure with somewhat nicer results here" ], "metadata": { "id": "5lshOIS8ejy7" @@ -340,7 +352,7 @@ "height": 431 } }, - "execution_count": 16, + "execution_count": null, "outputs": [ { "output_type": "display_data", From 41fb8407beb3fa1c86f0a0923eed1f2618708483 Mon Sep 17 00:00:00 2001 From: James McAllister <94491866+WildJimmy@users.noreply.github.com> Date: Fri, 1 Dec 2023 12:30:31 -0500 Subject: [PATCH 9/9] Added python file used for local testing/position finding --- position_guess.py | 129 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 position_guess.py diff --git a/position_guess.py b/position_guess.py new file mode 100644 index 0000000..2b6141c --- /dev/null +++ b/position_guess.py @@ -0,0 +1,129 @@ +''' +This is the "brute force" python file I was using to find/test +different initial positions, which I've added here for completeness. +It's sloppy but (I think) it was able to converge on most of them given the +proper filters +''' + +import numpy as np +import matplotlib.pyplot as plt +from mpl_toolkits.mplot3d import Axes3D +import itertools +import scipy.optimize + + +ke2 = 197 / 137 # eV-nm Coulomb force charge +alpha = 1.09e3 # eV parameter of model +rho = 0.0321 # nm parameter of model +b = 1.0 # eV regular +c = 0.01 # nm + +# Helpful solution to convert itertools combinations to numpy arrays here: +## https://stackoverflow.com/questions/33282369/convert-itertools-array-into-numpy-array +def cp(l): + return np.fromiter( + itertools.chain(*itertools.combinations(l, 2)), dtype=int + ).reshape(-1, 2) + + +class Cluster: + def __init__(self, r_na, r_cl): + """ + Inputs the list of Na and Cl positions. Na has charge +1, Cl has -1. + The array of ions itself does not change throughout the calculation, and + neither do the charges. As such, we can just compute the combinations one time + and refer to it throughout the calculation. + """ + self.positions = np.concatenate((r_na, r_cl)) + self.charges = np.concatenate( + [np.ones(r_na.shape[0]), np.full(r_cl.shape[0], -1)] + ) + self.combs = cp(np.arange(self.charges.size)) + self.chargeprods = ( + self.charges[self.combs][:, 0] * self.charges[self.combs][:, 1] + ) + self.rij = np.linalg.norm( + self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 + ) + + def Vij(self): + """Calculate a numpy vector of all of the potentials of the combinations""" + self.Vij_ = np.zeros_like(self.rij) + pos = self.chargeprods > 0 + neg = ~pos + self.Vij_[pos] = ke2 / self.rij[pos] + b * (c / self.rij[pos]) ** 12 + self.Vij_[neg] = ( + -ke2 / self.rij[neg] + + alpha * np.exp(-self.rij[neg] / rho) + + b * (c / self.rij[neg]) ** 12 + ) + return self.Vij_ + + def V(self): + """Total potential, which is a sum of the Vij vector""" + return np.sum(self.Vij()) + + def get_vals(self): + """Positions interpreted as a flat shape""" + return np.reshape(self.positions, -1) + + def set_vals(self, vals): + """Inputs flat shape of positions, used by __call__""" + self.positions = vals.reshape(self.positions.shape) + self.rij = np.linalg.norm( + self.positions[self.combs][:, 0] - self.positions[self.combs][:, 1], axis=1 + ) + + def __call__(self, vals): + """Function that scipy.optimize.minimize will call""" + self.set_vals(vals) + return self.V() + + +a = 0.2 + +# r_na = np.array([[0, 0, 0], [0, 0, 2*a],[0,a,a],[0,2*a,-0.5*a]]) +# r_cl = np.array([[0, 0, a], [0, a, 2*a],[a,a,0],[a,- a,0]]) + +while True: + + r_na = np.random.rand(4, 3)*.75 + r_cl = np.random.rand(4, 3)*.75 + + cluster = Cluster(r_na, r_cl) + vals_init = cluster.get_vals() + # print("initial Na positions:\n", r_na) + # print("initial Cl positions:\n", r_cl) + # print("initial positions flattened shape:\n", vals_init) + # print("initial V :", cluster.V()) + + res = scipy.optimize.minimize(fun=cluster, x0=vals_init, tol=1e-3, method="BFGS") + cluster.set_vals( + res.x + ) # For some reason, "minimize" is not updating the class at the last iteration + + if ( + res.fun < -26.9999 + and not np.isclose(res.fun, -27.7298, 0.0005) # rectangular potential + and not np.isclose(res.fun, -28.2358, 0.0005) # cubic potential + and not np.isclose(res.fun, -26.1369, 0.0005) # just a straight line... + and not np.isclose(res.fun, -27.7824, 0.0005) # octagon + and not np.isclose(res.fun, -27.3422, 0.0005) + ): + break +print("Final optimized cluster positions") +print(cluster.positions) +print("Final potential:", res.fun) + + + +fig = plt.figure() +ax = fig.add_subplot(111, projection="3d") + +charges = cluster.charges +x, y, z = cluster.positions[:, 0], cluster.positions[:, 1], cluster.positions[:, 2] +ax.scatter(x, y, z, c=charges, cmap="coolwarm", s = 200) +ax.set_xlabel("x") +ax.set_ylabel("y") +ax.set_zlabel("z") +plt.show()