diff --git a/Tests/.DS_Store b/Tests/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..cdf8c4c0fabcc31aab1ff4995a25512e10de48c0 Binary files /dev/null and b/Tests/.DS_Store differ diff --git a/Tests/.ipynb_checkpoints/test1-checkpoint.ipynb b/Tests/.ipynb_checkpoints/test1-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..65d907498a701bb8b05ec1ba04c1d5c63fce1fe6 --- /dev/null +++ b/Tests/.ipynb_checkpoints/test1-checkpoint.ipynb @@ -0,0 +1,2312 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "d6682c69", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'block_diagonalize'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/_c/qqbkxzc571n6hcyyj207lmhw0000gn/T/ipykernel_18540/1893085187.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msparse\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mspr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mblock_diagonalize\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'block_diagonalize'" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from qutip import * \n", + "\n", + "import scipy.sparse as spr\n", + "import block_diagonalize\n", + "import time\n", + "import os\n", + "import pickle\n", + "import matplotlib.image as mpimg" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f7f68665", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.colors import LinearSegmentedColormap \n", + "import matplotlib.colors as colors\n", + "\n", + "greiner = { 'red': ((0., 1, 1,), (.2, 0, 0), (.48, 0, 0), (.728, 1, 1), (0.912, 1, 1), (1, .5, .5)),\n", + " 'green': ((0., 1, 1), (.2, 0, 0), (.3, 0, 0), (.5, 1, 1), (.712, 1, 1), (.928, 0, 0), (1, 0, 0)),\n", + " 'blue': ((0., 1, 1), (.2, .5, .5), (.288, 1, 1), (.472, 1, 1), (.72, 0, 0), (1, 0, 0)) }\n", + "greiner = LinearSegmentedColormap('greiner', greiner)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "107f7025", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0886a3e9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba6d2e59", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5e80c9bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20.10335111618042\n" + ] + } + ], + "source": [ + "a=destroy(28)\n", + "\n", + "parity=1.j*np.pi*a.dag()*a\n", + "parity=parity.expm()\n", + "\n", + "Delta = 10\n", + "U = 0.1\n", + "eta = 0.1\n", + "\n", + "Grange = np.geomspace(5e-2, 3e3, 31)\n", + "c_ops = [np.sqrt(eta)*a**2]#, np.sqrt(beta)*a.dag()*a]\n", + "\n", + "num_even = np.zeros(Grange.size)\n", + "num_odd = np.zeros(Grange.size)\n", + "gap_even = np.zeros(Grange.size, dtype='complex')\n", + "gap_odd = np.zeros(Grange.size, dtype='complex')\n", + "gap_even_odd = np.zeros(Grange.size, dtype='complex')\n", + "gap_odd_even = np.zeros(Grange.size, dtype='complex')\n", + "evals_list = []\n", + "\n", + "t1 = time.time()\n", + "for g in range(Grange.size):\n", + " H = -Delta*a.dag()*a + Grange[g]/2 *(a.dag()**2 +a**2) +U/2 *a.dag()**2*a**2\n", + " LL = liouvillian(H, c_ops)\n", + " \n", + " P, block_bfs, block_sizes = block_diagonalize.PermMat(LL)\n", + " bd_L = np.dot(P, np.dot(LL.data, np.transpose(P)))\n", + " num_blocks, blocks_list, bl_indices = block_diagonalize.get_blocks(bd_L) \n", + " \n", + " num_keep = 15\n", + " evals_keep = np.zeros((num_blocks, num_keep), dtype='complex')\n", + " \n", + " done=False\n", + " for i in range(int(len(blocks_list))):\n", + " block = blocks_list[i]\n", + " evals, evecs = Qobj(block).eigenstates() \n", + " evals_keep[i,:] = evals[-num_keep:]\n", + " \n", + " ss_block_form=evecs[-1]\n", + " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", + " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", + " evec2 = evec2.tocsr()\n", + " evec2=np.dot(np.transpose(P),evec2)\n", + " ss= Qobj(evec2, dims=[LL.dims[0], [1]])\n", + " ss=vector_to_operator(ss)\n", + "\n", + " if ss.tr()>0.05:\n", + " ss=ss+ss.dag()\n", + " ss/=(ss.tr()) \n", + " if expect(parity, ss)>0.5:\n", + " num_even[g] = expect(ss, a.dag()*a)\n", + " gap_even[g] = evals[-2]\n", + " else:\n", + " num_odd[g] = expect(ss, a.dag()*a) \n", + " gap_odd[g] = evals[-2]\n", + " elif done==False:\n", + " gap_even_odd[g] = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", + " gap_odd_even[g] = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", + " done=True\n", + " evals_list.append(evals_keep)\n", + " \n", + "print(time.time()-t1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dc957fcc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fd7f50e3820>" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "style_list=['ro', 'g^', 'yx', 'cs']\n", + "parity_list=['+,+', '+,--', '--,+', '--,--']\n", + "\n", + "plt.xscale(\"log\")\n", + "for i in range(num_blocks):\n", + " plt.plot(np.abs(np.real(evals_list[0][i,:])), np.imag(evals_list[0][i,:]), style_list[i], label=parity_list[i])\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "cf16363e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<video width=\"432\" height=\"288\" controls autoplay loop>\n", + " <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQAA01BtZGF0AAAAUmW4AAQA\n", + "AF5MUAAQ5JNScnJycnJycnJycnJycnJycnJycnJycnJydar//8VhXwHAAKAFBRGW8ABPI4iDqQxR\n", + "EpXXXXXXXXXXXXXXXXXXXXXXXXgAAAK+ZQbuAAEAABeTFAAEOSTXcQGAR48JQAEyMxKhSDHt5A5f\n", + "h4CwVwmLSKNYEVP7yMiGikKjielH8Ayo6AuC36TMf8tcAahfJDMqUWQYdNrLIg0Qcd5P5s+er1kY\n", + "aKMlxbDSD1ewjIMowl9PyrP2uxWI4h/FfMiMaoQiOL6Eeu25+0MHAAEAECEC0zF75gPMSpg1Gst8\n", + "RxHD4JDt5LAD1KMAwhhp9NgjaC01MvLfDnZI3HgEQo+2EO+g3k+YAI229FNgwqwaDorqH4ACMiMz\n", + "IiIzGiL//+ADRoehTsYCJEcR8PwQ8ABNmN5sUMdXISeHEcR4fwQQAzNPiMv9/d9999999999999+\n", + "Im4jrHH4RfFwGAFo6TBqSAzDnhQABrCQS5YHARi3JnJlb72HAKWzlf+/+Duhdi9Cto/5EAQACAIf\n", + "UWfPFfq35Q3AAX8C1QX34R/nzeEJizmDOcsXdN2p+PmzYPH/GVYjDEf+HsAB8hxnFnIIU1qqYAAQ\n", + "AgQ0mE5OtV11sfhgH71wMnJV2psKlC/nO2iRtX6h0HEPCkQz/4AEn8imeRN0IVhMEuBa6+28HnCB\n", + "EtAibs8Qm+8PT4HeyZDiOclv+BQIwG836fIjwh/wxg0wN9ihxd1b7/ABNAT+FIHFNCs7mAYAIIPo\n", + "TAs4wZTIoHJWJv/wGXcDGv3avm74BGkaYnykV2UwIjlJnGzGsFj72jRav/+97ZtjfqVXdQUMPA3i\n", + "CKVDQdFWPShpaWlpaWlpaWlpaWlpYWUABU60rxnrRn/gB7CRz0hs+EEBb3hoJK1vv4RN9cEfvbB1\n", + "zi2/WAAvGpZpIxVQ9JVIsQs+et4Ecm+Q1wQ/3e4KNJzKIAx3PuUOXe7xdgkJ8i+CzHP8/f+ZG0YE\n", + "PJvN37/gWCcDuyHwR1B0ubSFzppXTDTbyRnaaN+79ha/rdGio7hPXXXgAAADqmUDa4AAQAAF5MUA\n", + "AQ5JNfARxXDC8ABMyMSjITnNPHYXAATIjGqEIji+hH4CIoanGC36eXTf5+8zIxLyFRhcSjLMjCcf\n", + "CnGvcbtUIwB9BiEPAsSfXNZEGiDocW8oo9XvIyIaKQqOJ6UfgKSA7dbKkyUf/w/0jDKPmmuCE0eO\n", + "f97CMgyjCX0/Kt/a7/7B6hD4mCgOAAIAIEIEpgCZGZoTZTqzLjjCMPUFEmPJa4fMXTDwAC0OGPAA\n", + "EAECEC0z+YvHnn8ADqWRg1cgnim3++DQAKqT2HiAEGG/fvwAy7+tdq0/TFvAAmbv2D7VsIUCX8GH\n", + "RLAKjAzYTMbIub4Qmo6pwFFjkBE3Z5Ec3z/j/+EMYAJkY/CmYoEPn8ACILclM2kzAikNlst+L//f\n", + "nbaBoYf8DnlPY2QTgifI0mg5fB/z3pFvJCRqvVqpLtB/gAyaNIyZhKiriTAgdM1pCkEu+AAZMhpi\n", + "k7mchXD4grXYC7fWUqi/+DCGYJmaYRMVzDzFc/DzFcw8xXPycnJycnJycnJycnJyf/HwgEOcAKqU\n", + "YBhDC39MBDtoFpsY5//wDpyVdqbCpRhhSGAEcsVI5Wc3aLBgUwCTvUb79ik4rbbEAD6Y/MJS5hJ/\n", + "/g2ywBsC5Xd/X+YhDCvMAXySwAXr+OJJ/77HgEvaWAAppr13vVR0GAE0qDZ5Iio//ZW0G8AGnQ8x\n", + "XIx6vcaUmW2Yj0s2VbXZdltqrjcJKu7TIGxvZ5bxSVRF71v3nYqRghw9hGLjpvh//D2A4AAgFAEN\n", + "CUzk5OtV11l8R3x4T1xibIyMfD19qcSXfQMX//1e/4AimwMZz61ei6DAAObk3U+vgYG4IEJjwlb5\n", + "tK/KnO7D0d2VmACH5og1mMBytEQQ4HfD/wgl4ACT9E3TakzAACInNlnwiIf8KfTQXe8OpGLIN+wJ\n", + "/tQaYVLSWltPV7/4AqbMLLPu5Y173wEAq+B72OkpVF94wo/XLWm79/fpdLS0tLS0tLS0tLS0tL/m\n", + "FqoYuvgAc+kUYD4zm9vwu4DeU/BDfdnggQt2hUBXQor/WDrH6HPvbXAeY5WwhRP/8UmR0Yt8z2rZ\n", + "LPINEG/v+CQsUPuz4wEarKMJPIcNEId9BhGqYozatx5+/DUxQIJH4YSfa/JY/ONUmFA1/6AiR68G\n", + "lNT98V16UAYO3/9XP2YMjGKLS0OATAvYz0RtoQfffnugYXJp738CmO+2P4c4nQYGl/hI9CPvPXIY\n", + "eh/jXVD9YyMojs+XXXXgAAADB2UBRuAAEAABeTFAAEOSTXx5ifDvgAJkRjVCERxfQjy77AB8yMSq\n", + "QqMLyUd55DjEFnIIaQ1vkZENFIVHE9KP8ADtFZXrE37h15BpwBGNQ9xj0HVwNC9hA2mLLl1W8/9x\n", + "BoB+SjMOvhZsa/WRBog7CC3mMPV5gBIAwRB8iXTYRkGUYS+n5Vn7XcPRoAoiMTgOAAIAIEIEpgeP\n", + "mLph4ABbgQLRSfATIzNCbKdWZccYRh6gokx5LXA48AAQAQIQJTOMX/+GsAI5YqRys5u1jaAwYMAZ\n", + "3f+P+/36dSbgJG+fRvrfPP95faB+AAm2222223gAWjgO6EFQqXofB///CGABgGqbbm//+B5iuYCA\n", + "85kQv//5OTk5OTk5OTk5OTk//+4nBdAB7sJjnhBlmA5Urw+PbApaHlJXIrlFkbxCErRfAhIjCAAj\n", + "vdwN4sOAF+VsNAKDv+YNBzw7BQ7InyFLNg8CMUD5a1VVCHLIP3cDACNnYUu75cs/ZJYJFf2pDjsJ\n", + "H8xut5oiCQB4MEAEAAjQF4Z8HCgn8BPnYbDwcIgBP/+AfQpHReAHBf8bBsEOyEYbwA+ObEqI/Q//\n", + "+/+RAxGQBScPsRyk1enohAAD4DIMAAQPIAAID/NHyD43GxYFRqYzIkHAob1CG0gjUQLoQAAmGXh/\n", + "/D2A4AAgFAENCUzk5OtV3+sbQLvrrrrrrrr//+EF2ABbkqDUhVDIJ+AAYXkpnpNapCYVEc0NcARC\n", + "UnwOou4FBIT5f8KfYLfxOuh0s10Ci8i79tdddf//OaBdAha2sZG1vl4PM58ghRP/8BKTfASpxCTl\n", + "/w/QD7og7GF4iNj4evd8tNjA9hI56QxcAAXjUs0kYqq6bbmtUguYLeiemXdU6v8Jf+A4DCAI/hoa\n", + "2wdj8ZSpsz7t/5qAckfa4hwVwnXACgVNYixFb74+gklgASqca0aIywxK1uAH5qzStf9hvHEEy5vk\n", + "v+/YRSFqQvFPW1BhJ9rBCcnyhspIkagEqDKNaiW2N3b+cWRm7kMLTrmxCZy2u8lD04a668AAAAL9\n", + "ZQGy4AAQAAF5MUAAQ5JNf/82wQwAXGQZBtLeY55u0AuQ4xBZyCGlNbAIxM+UxYAE1Z5IjzHf+vH0\n", + "GJJwXS8PC3EYTwHAAEAECECUzh/cjM0Jsp1ZlxxhGHqCiTHktc8X/+HrBdwAR2SiAkGcAP6Avy8P\n", + "kSil98CUmEATnNwSIqFwAX3RQ+gFp6/+74YLePAjFAtMwkeYICGSXig9Lx16YAW17ycnJycnJyf8\n", + "R/8FkACEWsjmLqnMTM5YP7CR9n8Ej2z3//8FcIAs4auqm7Qf6Rf+n3333x+H2W8Im+v//xi/+PgR\n", + "v6YDCAt7w0ElFtb/DABbQkq3EaYX8ACEC+wNCRBggX3TNZAcMOrrIAQEtBYQavDAAJ8EYTvHNlOW\n", + "RUUCgsfXgIW7Vo4tueAj6ix5ALb1KZmiGE6q9Ed3+PBdlGX4CwrmmbO10dm353/2HSQdLkSf/9sN\n", + "T9YP8ADfbo6RAgv3HgAPAcBGLYmYZzhIAcGAg19Zx+47j6iI9eZrmrTnbAlZ4FpEF8ksjz+iIQqZ\n", + "zCPxlPh//D2A4AAgFAENCUzk5OtV/ow/+H+AZpoH6DDGt1f7AI88DZJhjWev9/3eH/8PQx4AAgAg\n", + "QgSmcn+jh/0CyBn8mHahA7e77D9PJDRhcftf4BIQLO0xEzf4QGhriBq/O/AA//wV+maGqXoYe1Aw\n", + "6AF473xRgDmP+uuuuuuuFiQEj1vz//BC1VgJTrJi5eHaT8LP/8wvERvh6/+4TN22/0TS0tLCygAJ\n", + "pNtJJtpP//gAe5Kg1IVQyPi81eEe5SMADh9eFyRxCxy5/1+lnAUqQtHV4dLTHCMVUXa6D/+AMjRk\n", + "Rj4esZDvJMuBlWiN5Rt2CGeGABGoMBM3z5YVFvq22MIrY15A1/nUqikRgNDgl6Xe4Qx4JvXhuUpq\n", + "DId//9DwEYtkt+A5tjRJ1MPSgYfAn1nirk0KvBkO8ky7AvPeI8Gxha/v3iLQYAYaFPKPN+MN1JRd\n", + "NNv6owdRSqNjmHG+A4zhqXc0uOJPXXXgAAACymUAh7gABAAAXkxQABDkk1J/D/+HsBwABABAhAlM\n", + "5MXJycnJycnJycnDGAAiMiMjIyMjMj+AB6jmZKK6BE30H/wrTYJQmUcv4X5YABi20CHSdqWB8tys\n", + "oBAH6XLfbPDgfpYcD9L//iAEyaPhV/8R5Ek5OT/uP/gsgAYXkpnpNSkImZnwADr336LWRzF1TmJm\n", + "csFaYVpwG5lzwGlGLn7vd2/0GuNFVMGIo0A5n+l63osl4FnDV1U3af37nmjz2ROO8cppUH7QEf+5\n", + "x51Kykg22wv3vvBRZhAAiJaiOSKXt/79+0OwXpZ/KYJAf/cXG7/64CRsJyAKIPpvPGiWy11wqlv0\n", + "a0/HiVKfl9eTA0ocfnIlcjHAAEAyPAw//wHAjlPlgDPr9WP2PSGksACOlm9EjNBrgQAxOPS3W8RL\n", + "jw13LLZLejDGguNkAzZfTWf4iZSxGD8RS8P/4ewHAAEAoAhoSmcnJ1r/j/w/wAEjIhopCo4npR5f\n", + "9iQT4YBwlAD4ZSFAYe8RDbUAOZmNQKlOgI7cUpnA3CCErSpYN3+SLz3gMpUBsRmeAma9RGnxETFw\n", + "iEO4GWVVBvwalKPlLxS0UsL/4zJCw6E7wNsoaX8RBife4hKd5NcO//yIpIyMPh+IyIaKQqOJ6UWo\n", + "gzj1BZJr9d/D/9dddddddddddddddf95/8FkAHuwmOeEGWYDlSvD49sCloeUlciuUWRvEIStF8CJ\n", + "kYQACM90DeLDwAvythoBQd+YNBwOH7DUFDsifIUs2HgACA/tVVQQ5ZR+7g8BGLdLABY4rDwnmA5U\n", + "rw+e2AhR8Fbs/XJORmEISli/wShDABFgDPg4WCXQE+d+HRsOEQAlf9AfYrHVcAHBf8MMAH/DUPRS\n", + "BW4pbIAsiu9OhmtfXpGlyECMyAK6xdisVtXgoJmCAEA5okx3aQNM2L/uD7SMErHFljWsQ+kD9PXX\n", + "XgAAAj1lAKK4AAQAAF5MUAAQ5JNSfw//h7AcAAQAQIQJTOTFycnJycnJycnJycnJycnJyfz2eOo/\n", + "gAy/pZM/kCdXTeiSD/fX3tWWZubim1GGjE4bS/ttp/G8vfses0YhZsuTsd/cfcshO6O/AYP4GBxw\n", + "uTAEXzkR6jY+JZ7fdsuAjUyKPtR9n3QMkZ9x43lzTK8Fe//NVjm4kcoL+e0Y0lu3ze1sjQfv4g3a\n", + "G/sJHF74C4AZ/jMatzMC/mtsZWdPE5R2pX006f3G/W23tmP/3h/DTbCUxA/98VNOgWVyxoPf6J4R\n", + "NWTX8RhpF4f/w9gOAAIBQBDQlM5OTrX//HghgAJGRDRSFRxPSjy/4P9+cIYBfAA+AaDJRuPLMDCL\n", + "fcAOZGQZcK8OVgiXIfiImLjIQ7gZZVUG/BqUo+UvFLRSwv/jDXOKOzSlqLfwvAAAUGMS9yYemkH/\n", + "jMkLDoTvA2yhpnxEGJ97iEp3k1wYY7AAguZlpERB/D/xGRDRSFRxPSi1EGceoLJNfrg//rrrrrrr\n", + "rrrrrrrrrr/7+Y6DmAEIUKlcjObtAATFLF/U+ECH89/YBkDWmZc7xQojTnU2D13EYuf+8MsQFsBI\n", + "OKWWxMTrWb79gDXOAEwLtf39QN5D1wtLiEH//cwoIX3fWDHXX1v1+A2jg/7Nidv3w8KDQiADkVC7\n", + "oV/f1e6kwC6pLAcoU81ild+/b9Jpf5wEJANRXVQXEuVNdfMQvlg7NoBC9Kb/4KYoAws9oESyOkUD\n", + "iAJmlp/XXXgAAAfuZQC9uAAEAABeTFAAEOSTUn8P/4ewHAAEAECECUzkxcnJycnJycnJycnJycnJ\n", + "ycnDGAl9aDq/gBju9Rem+EbfuRP58thHjaInoZ7P5PsCCMuuCJtuYZgmzBYrpWaKqAUwUk8+itbg\n", + "/o36KkM7/30/6Ek1/q5jsulVhr/RkT/3B/3QD6TL2S0sGHBgaAz5alYbeWd6ZOIyhuskBt9WcwCF\n", + "us+DNO1EYjp14f/w9gOAAIBQBDQlM5OTrX//xgh4ACRkQ0UhUcT0o8v+/8weYYVgAIjCE+81Kf3k\n", + "AKGeAEhSMEF4VQ6+dt2siIMo9FvNaSbtYAJFHDf18h+fnnzxETFxkIdwMsqqDfg1KUfKXilopYX/\n", + "xmSFh0J3gbZQ0z4iDE+9xCU7ya7/8MAggh/IyIaKQqOJ6UeX/f/AMAkH4ACIjIyIyMyMjP/wAHiI\n", + "hIhCDns5A8P3x+AAjMjIiMyIjIz/+AA+RmJUKQY9vIHYd8fgAIyIzMiIjMyI//+AA6MIT7zUj1q2\n", + "x598fgAIzIyIjMiIyM//gAOzDF+qxI5alNfw74/AARkRmZERGZkR//8AB4iISYhBz2Yoe++PwAER\n", + "GRkJUVUdlf/wAHyMxLikGPbyBwfvj8ABEZkRkRmRmRH//gAOjCE+61I9atseDfa/fwYIQBeADPIo\n", + "wamMUBsHRSOc32YD00yMZk6jqBgiN6Bkm7FcDAFmGL9VSRzFMY+uCBhx/2PgoAEIx23LNwC9KOPn\n", + "nHgBTL1PB1iXRQNZwwNQfkcX3W7X82UNyzmb//i/wQeAAlEUZhxIcpylXXXff7w//CEQe/ABeQSj\n", + "vS4oHKiJ6vYCjUnYTdTx/ghov/1iNgDBHYglL3G7UeAASAMCHkyAsCMOU942Im1MYAATAMC3EwAA\n", + "AwECIYGgIZzhNKVQfZ99+eAEcLUMRjQjoKt+M8DxuPfzMzGqlKri+lPhlpkAEhlosjkXNdmhZY+8\n", + "IBoMlG48swMIt9wE8NVIwQjDLPN/28MBkH0VXCXm1CL3YP/IUdATBk81cpJSGg0L2EEUxZdhu//c\n", + "H/Dz8AhCnABcYaKMh5bjHnq8BMDhxc1mEYUWfP8ABGEuYVCdz87UfZEQbj4W015Ju1jUIcIY3+Rk\n", + "Q0UhUcT0o8AUEvcRKdzt8BWBnw3SIdBKvfSRTQ4zgAHsgCcIKxltZFYz/+EAAEgABADAKQEAAFAA\n", + "BADAIQeMNc4o/NKWoZK4X4EQmbKofxd2yhj9gCyDF6gymCC9Fn/1DD9MRAhH4T4C4DVXUDJMd7Th\n", + "xn/+5QjJhoS+FQa/sMwlArkOKGtqfebwjJSDKZN7aJ/fD84OaBAAXfAD0IhSgOOefDbUBrIwHQhU\n", + "k7Lms/98ZBi9W4hPZ6c8E9ABiVN24mr+zoABJFiCiXNKgCg/AIK+HK98XkyAolJnFdqfO40Uv/3C\n", + "ADTg7EP39wRlb8IAAIEYAAgCMGAAEwHBIEEzKkAQImbIWJz3/+ZmY1UpRjm+kcxERDwAhL3DgbkG\n", + "QbcNeU5sv//uA1GAYRzniveo2R79gajAHwM4x6AhrIJvN/jCXMKhO5+dqP4BKMhDcdjmtt8+DD8K\n", + "iO2R2f8rPD/lQw/+fgEIU4ALjDRRkPLcY89XgJgcOLmswjCiz5/gAIwlzCoTufnaj7IiDcfC2mvJ\n", + "N2uynF8ILC/xEEJ17qEdvp3wBQS9xEpvO3wFYGfDdIhUEq9SkimhwcABARylNwGIR3yUs8kgAAkA\n", + "AIAYBCAgAAoAAIAYBCDxhrnFH5pS1DJXC/AiEzZVD+Lu2UMfvRMCEWO7a6aW1//Qfl3jnupgIa74\n", + "AehEKUBxzxENtQEsjAdCFSTsshtfMzMaqUquL6U+CegAxKm7cTl/ZuApIOWp23wMsyAIDtxQ5UF9\n", + "MAKJSZxXanzuNFL/9wgA04OxD9/cEZW/CAACBGAAIAzBgABMBwSBJMupAECJshYnP7v+ZmY1UpRD\n", + "m+kcxGPCEfwnDhYCMah7pMeZYDRKGfSXC/UVbeb7gRkEqDoeU8xp6vcYZQf0ZhvN45534MP/+kwh\n", + "TgAuINB3ocWDlBE9XgJEUubIjgfxTS/7Ap8gYPVkOSP+DAUZSqqgypYxgnj/9oAyD8QZueQgRhbt\n", + "MAAM4AGO/rSNMT5SK7KC+MJM4qEbvZup4ZJYAgBGNQ9xj0HUAvDVSMEkjDLPP/+IAAJgACAEAQgL\n", + "AAEGT4g07iJRm9u4ngwRmYRRtKea4k3a0GhewgimLLrN3/7v8fkvBNPTTBJLSS8euEAG43wAXkEo\n", + "70uKByoierwCjUnYTdTx/ghov/3jIMXq3EJ7PTnh2I2AMEdiCUvcbtYmQ8AAkAYEPJhgABMAwLcT\n", + "AFgRhynvGxE2pgNAQznCaUqg+z7788AAAIEQ8ARwtQxGNCOgq3h3E0xqcfhPgBIZaLI5FzXZoWWP\n", + "uUI2w0JfCoNf3toE8EZiFFUSonwjJSDKZN7aJ/Qw/8/MIQpwA9CIUoDjniIbagNZGA6EKknZY1n/\n", + "gZZkAQHbihyoPymAKJSZxXanzuNFL/9wgA04OxD9/cEZW/Yu4UHWwDT+IghOvdQjt9O+Hl0AGJU3\n", + "biav4AcR2Fsw8mR0oT+W/kRQSIJSycRR5YYgAAgRgACAMxwzQhTEipG6WK4YsqQBAiZshYnPf/5m\n", + "ZjVSlDCO3y4x5FHEUGpTwoqQw75Ouuuuuu+u+8Nd4b77w33hrvvDXf677/XXXXgAAAAJYeAAQACc\n", + "i8G8AAAAL2EG+AAQACci998Ac/cP89/3AHHrx/nv/DnJgDd6qPfXJgTvw/z3/Qn8iiRRQoUgAAAA\n", + "O2EDbgAEAAnIvfE8AcevH+e+U/cP89/4U4vgO9SwjbgH6sJ2J+PxPNhC5P2DrkmMJqGKYV8r/lfK\n", + "/4UgAAAASWEBR4ABAAJyL3xPAHHrx/nvlP3D/Pf+Cc/m/+4UwW4AFqbsNCEUMkn4AATLtIGKowtn\n", + "+195kyAO0ewKmwqbwI7JK9+BHYkV7xkAAACzYQGzgAEAAnIvNDMOeAYjrgkUCvggEhC8CxMzbgB2\n", + "4hgpRhXbBx//////jfWaI3//DUAGcJhWiJahLXx+Zb8M4ve/f+/9D/zofl/CR9n/xvpFE+J8T4V/\n", + "hE31//xi8NYEoOxKNY+AsILs8SAxMN+OhXhNJc2/7j2uW/P5/P5/P5/OTnJw2SAh978/8AkaMifD\n", + "0ZDvJC7m7q2VOCLpet/zvn8/n65KBAY2fR/EcDq2jm3n38sAAABUYQCH4ABAAJyLx4nw7gAIkSRm\n", + "aSGru4Ad1vRCYPPZE475MebAw4Tv9f/hLbQBD1ENLcwf/PyYIXk/XPxHAD2df4f97/4AbvfU/6t/\n", + "3+AOfvH+f+GIAAAAKGEAouAAQACci8PcngCd76f998sAU/fL3/f8J8RGix/AUek/IOukwsAAAAFs\n", + "YQC94ABAAJyLw7zcBf2b/2DgL5pbxfAem3Sfj4Ane+n/ff+L/ABCu7u1/6HgL5pbBwF80sDgL5pa\n", + "I18XwBP69p/9R4C+aWwcBfNLA4C+aWiP4vgOAvmlgE7utJ/9ceAvmlgcBfNLRHhTAARkRmZERGZk\n", + "R//8AB0YQn3WpHrVtrz4vwAzr+qf397mce6T+r1zeAK6+1v+oR/LwAXPZnWkn/nrm4AXl3uh/xZ+\n", + "+L8AOl27QX5jwF80sDgLo0tEP8vAcBfNLAM79cOf+k/NwBg//j4++DLu+n97YvFwAtqxLag/6zww\n", + "N3W763Mftwff0QBFZtyQdXgf+/+lP/2vE8AMu7+f+tew3dgf7X8OThHKv/D/PfgBx+uz7/vhgbut\n", + "31uY/fB9/RAEVs3IDzeeG79dL/q8sMu++f/Xx4fzeAS7uD//jh8X4Awf/x8ffYRdd9H/9t/vgR7g\n", + "P4cf5vAI/bg+/o8v8Abv3G/uRwj8JQAAAAph4ACAARyDvBvAAAAAC2EG+AAgAEcg7wbwAAAAGmED\n", + "bgAIABHIO8EYXUMUwbuau5+ruau5/UKQAAAAQmEBR4ACAARyDvBWb/+bJBdAAubpCjgumGF9hh/9\n", + "D/pAg3uu70YY27QwfHljvv/QhIjCEiPgF0oVQTcAZbhQ3/nhkAAAAQ1hAbOAAgAEcg7y1DHAAmCl\n", + "jqrj4UDD+2bRlkNCKAAIIqwWUhjhXQo8szwpMwgAQrCMCIcLKuHgAFraCpRKH/vhkGnNGRvMnBjD\n", + "fAATsSSwIgGzujU4GD4CJGeEwy+BMFhLpeJN8f/QLIAUAAJySAOHwfLvc2Q8dugvIX3hikIMLsvw\n", + "auXyhX+AMX747Az//i+Fd02WMGk8Y6f8tFGYNLUgEBtQdb/ttsNSi2laXP+B3YQExDQCx4N/wn5m\n", + "YGYCL058apt/zvl8X/DPVimrtzsJvb7IEV/IS20xSfxcSOeOf51zrnXOudc62G3AEKTaTfn/+AAf\n", + "NbosS/gK3M4liuoBF4EXZHet+hf7OudYiAAAAD9hAIfgAIABHIO8IB3AAisEUksMU5j+AB7UysP1\n", + "CG//LemTx/wf//KOO+eNk2xtT//wiZGwArUJLC26X5lOCeAAAAAMYQCi4ACAARyDvBvAAAAAQWEA\n", + "veAAgAEcg7wRBT/+YyYzmMmMoR4UwAENmd3ZmZ3dmf//gAOJxCF3ntBpLOvKHCmGmW/8xoxrMaMa\n", + "OIeCgRwlAAAACmHgAMABnIGvBvAAAABqYQb4ADAAZyBrwY4kOYQ4L0/zwid99wEe+83jYACSGR6u\n", + "IrqQelB4HxJuNxRUIEN39B/Dg59qLj/kZuMAAQE2msAEEVK+MB6IHWjL9GduhhnnAv4iUQQPFplQ\n", + "1POpkgwRjOGzl33CdDkywAAAABphA24ADAAZyBrwR8TA/kxh/JjD+TGH8mMKQAAAAGVhAUeAAwAG\n", + "cga8FYbwAEGQhSlIQhClKQhf/+ABdg4a7oQFFsHH/5AR4AzbfRnADHVvSOTf+6ewWwAHFneRQ6Ci\n", + "mhyJP4P6w9eKxLAusyN33+j9ggiRmEFnfbOIh/XfjusIw/rvFwAAARJhAbOAAwAGcga8uDH4c4AC\n", + "Wgb/cDqKhAwJC0wBFLAAEBVMQra4BGAxiYpj7gA9lEAC4FHyy8peG+WAAILuEtIIAmOfgJjbtX44\n", + "CvYEOPNtXiQ7gAIjIjIyMjIzI/gAT54EKZNyKVbUh//OoCRvn0/AGL98dv+GZgAB0AFAWdlgBzMb\n", + "upzq4/rX+HwHW+t88/7fW+ef8gd/gAiNp2tof7/tv//7CB45/xZ1+GviMkC3DlVxnAWJFfd4Ae6l\n", + "UAwN6BsGGgLihEj2r7fgfjkMC2WIlZQfwYAwiQ3gARH6r+v//gA/SaWDpjfmAReACC8lb0j4bcAC\n", + "D0nemm//BzSFFdTMkEZ5bSfn9/AFcGXW6az/f4uAAAAAT2EAh+AAwAGcga8IB3AAhHuaa2n8AHOF\n", + "srqxioR+rTa19/8AlgBs861x//DPQOlrkI8PlUAHic+1pptrAbv/7/wQLu7VdfAYq7+g/jHfBNAA\n", + "AAAMYQCi4ADAAZyBrwbwAAAARGEAveAAwAGcga8EQU//pp6aaCn/8xkxnMZMZ8X0ksAJxHad0dnO\n", + "nCICcKYaZb/2EwthMI4UcO5b/zmjms5o5oFAjhKAAAAACmHgAQACHICbwbwAAAALYQb4AEAAhyAm\n", + "8G8AAAAMYQNuABAAIcgJvBvAAAAAFmEBR4AEAAhyAm8FZ/gxniu/hqf4wxcAAAD2YQGzgAQACHIC\n", + "bzQQQx4YQAVg4BDCEkwHAANgBgEmkwohCRHqAHjWSD5OvbgAvwCpeQOsdonve+JG8qZuI//hrAAw\n", + "YAAQCdpMAAIAYATIfQ/MSuI1B5GsGpLLpBhzoRaAK02p4Zx23j5/gBvZZGa+1Px9tsHv8gdwEX7f\n", + "ngAYrtOZNrfv/7/A//+wId42p/8ZNCuALCYG2kK0ZviRRn33jckCGYwlsOg+/ziFaYBVuvXJxpSR\n", + "n+ADppZzKRVP/KZ/u6hb9Zz/FH8N4AgFmdnZzam/+AAbRi7ohlCL/MCXCWZT4TNIt+8S04AEuVyb\n", + "myVTTsmTT7xcAAAAIGEAh+ABAAIcgJvCAn4MYJcOwdG8IyX2LT5HzZRpECaAAAAADGEAouABAAIc\n", + "gJvBvAAAADlhAL3gAQACHICbwRBT/+wmFsJhIKYdy3/mMmM5jJjIgKYaZb/zGjGsxoxo4Uf/5zRz\n", + "Wc0c0CgRwlAAAAAKYeABQAKcgMvBvAAAAAthBvgAUACnIDLwbwAAAAxhA24AFAApyAy8G8AAAAB3\n", + "YQFHgAUACnIDLwWG//4QXYADgDYZ2UgEqmC7YIJCn4ABMhHO6CFIeesop/wgCNIIEPDqipE5CkIA\n", + "TGOEAAjOfwAbyn7AMMI2/cAG6Ke2AGBB236b/Cn2C2H84AKiVEIv1RFIDAFAFwVuZbFUUe/AtnRi\n", + "6k7OeKgAAAFfYQGzgAUACnIDLzQcw54AFkYhFOdgAOAlEb1+6CAJzmCAAEAUAYML8APAfkMoYSr1\n", + "7gAW8AAQAEMXAoSoN0lj5Y+GOFUwABACVZAABAA3kAJFJS1hWVAC1BxWW5temYQAEI8kIAAQEwAF\n", + "AoUwWojQAYMF1IEFvYewFgA1zHCNAZEKiSM1sbtkflgUb4//BZAAQjmGJcs49RI5FdZEwAQUSrLB\n", + "4BIVpwBEyiG+Dz8AOTKEUqD5/wzAFYjcDizNbTFVLdSpDD9z779/n+D/v32/e2B/H8NWBaAkDEvB\n", + "idC6DRh/GfCAWKwQABoDim4LgqqtwqDGnPwODA/aYQewDGwmuPfx8K7TBTHBrETOTN/O8CLKcKgH\n", + "QhTSIuvU+GX0z8IBOU4QAAgBADBRaTYIMQK26oD2fv8NMA3wAoDRUzSHRP30RpSWf4qDmHPDSGhL\n", + "wBKq+3/fn4OZ64ZevvO/v8VAAAAAYmEAh+ABQAKcgMvCJvuL/8FkADC8lb0t4ACswfCSTnYdQugb\n", + "9aTTI0xdU7ffh/noQAEdzwFwAPpj+TrAMLYv/fgdT7+GfeBoDZTjLYaTB8ops5Q3KrwYS22iyFe/\n", + "SlOB/+CWAAAADGEAouABQAKcgMvBvAAAADVhAL3gAUACnIDLwRVF9JdUkFMO5b/zmjms5o5oQb/x\n", + "/BBwO20Zwo4dy3/nNHNZzRzQKBHCUAAAAAph4AGAAxyA68G8AAAAlWEG+ABgAMcgOvBlxsAMTX3O\n", + "63+BoAgeSF4iS6KaQ8wAgRQFdLivIbSw+dT3YRI2ZjEIMo9XvAFgCwTQ9rSe4anPi/gADAR4Z7vM\n", + "VJYc6vewYdjIY0mJhLPr/d3/DACJDMIAHjMWVpqxXe+Jk5685AsM7xp8i7fMvKif4ASiu+f98CPV\n", + "Y7/ALERkWRVi7tV+3zf//bLAAAAAmmEDbgAYADHIDrwY4kb4AqdVYG//44AzMi0RtA3IZ+yPJTNp\n", + "ND2nxkB/6IwtaLuQf//g+eCQBVPDM2vZ+cf/7wAAQEnD0B7SxyG5RRdmZ4AQP3PYkdCdG935/vAE\n", + "A6w5J7qZ/kQoqiqRFiEwHsgHig5rDv8MApMj3SM/3wACv8crbmDx/2BO+3wpDQQBxMjN3Co/+gWt\n", + "kzTn9zQAAAATYQFHgAYADHIDrwWH+DGoApUKgAAAAOJhAbOABgAMcgOvMb//c4d8ABBirp9IIcsA\n", + "oNdFXgANcMAC2wDjg5wCJM0D5GhwIAAsUHQEAAIEYDAFP4APYFoU7F5mOBK0IiHFG89XsAEwEAO3\n", + "xRBlrRVn4C8gBFBRqbxQGE/q9G9MhQn4MYZlCALTHGoHXhxvf8eamIR/0GvwDHvyRCJePZOFgfPS\n", + "KGZeUtosMJB54VsRTM0Sz/X4QACw/BAACAgBQIZAuYemRcnKj9STQ85iARBz/AUThBHZ02ip1XzS\n", + "NjAMkOBGnBb4I/jg/n/FHfgxnlTgTfjFriw0u3ioAAABK2EAh+ABgAMcgOvCInw7gAITMzAFCSNr\n", + "WNkTZs2ABZDtIKISLh2XcDD+0AIIkgrdCOyYKxMv/wGEkEtNiUp6+q0YXoiVoT4P///CAAMgUSyF\n", + "SQAF7B8ScGQWtYrh/B/AGq/Log/lL/8QNgDk2S05w4OnnganylasDeR1g1Ukv7tRrW87b+z2G8n7\n", + "/Kf/92vbb22/f+/PD3XyBE3fdoPUrkfD+emDG1COefIvUlqZAvBiQAFvxzft/cPRVevFSBUdtVnp\n", + "//OxrXbQSjCkwe7K0vr/rAH1dvaZf+77dQC/uYWtA2X+ILwrfeRNJgATzStvi/JXWmBw3gjVGgEA\n", + "KUQCDhTM/skly5Nf4h6ZDSGwO9JdXL/y7pnZYV9z/AoC+jj3tpFMGxrTFILz/v8sAAAA72EAouAB\n", + "gAMcgOvCz4gbgCx8pwH39UJt5yv++AaABqG0donTXU0EH/33DwzSD5Fexm73ADA5nFGpJStQT7aP\n", + "+1H2E6X7DEJj/vzMO/0/938aZgtRLUluv/9sB+oZOYU5gB4pU3l/3FIJmMikgRzNcnP/97RfQ2JA\n", + "HfTZ5YERxlmh0if9vNb0vdPEh3S+q/b/uss1q/1W/tisLJVJcK15pHfPRGI+eyFTq+F1zm1F4G/+\n", + "uivqunXeVqVzk3/oASMIQYUQKc4gYWceaBwZQCRKAMuqRf+pbnH5+pf/DcR00OSZnKL1yVll+296\n", + "PzsrPAEEAAAAEmEAveABgAMcgOvBJxfd93AkwAAAAAph4AHAA5yA68G8AAABCGEG+ABwAOcgOvC6\n", + "4kbAE7ZMyttTlNonq+4EAnAA0+qg9uRyJ7/3r8aURABcwdVOL1GnppeEsfg8XZooDf/1BRSdLQj1\n", + "dCbt6LGJZ78nCNsf/CdoSEQCAVun8/7YFNv6ovdtJCqjmAD1AGxRuudv+4o6SxjgqpEPrOcmFme7\n", + "A2oicb6LYCAARD6Zld3EViWq+AGKK7OLbifapplBLBgAPZCBVhJyddmAN4Fn/eAyAACAAQhqwV/M\n", + "DetpLYSWY7qWLG77FQ22wxYTx02mKpaP0TibM+v+9sw3/pQOD7lwwxJAsT/DvhyYALAGKmtLc/ci\n", + "dCauOOEvWnGtzAFmpgctZvuqn/69a//5FgAAAJVhA24AHAA5yA68L8bzWAAgYAOqg74KTdTp4ilP\n", + "KQZl1KAFlOxft1lj/3qAjAATAKwZKt+H515fAA+VlAAIAUa1B8WQr2/+PcY2ZFgduR4GKAKkjTPP\n", + "nJf4Q4BAAEQt0AC7atP////iq3oUAayI/2awm7/mXtb/yAA9RDt2ovkcf53bi9FuAUBHpTKZDM+d\n", + "1Um5Mb7wQQAAABFhAUeABwAOcgOvBbBjN3MwKgAAARBhAbOABwAOcgOvNUMcAFAK2DgP9q4BYN33\n", + "gFJmdHKCngJCvL+Nd/34Mo55OMQJp7yzw8e+Bq4DFoRwBI2YT9E2oYhAACAuQABkhAACEEA4AAgV\n", + "vYABzeQAoHKoPRPwLK8sAUIxUcpT7AAeIMwnF4A2483rHXbQAHFQQdcFID/nAG94jeIAARCIQAAQ\n", + "FAAFQuDHHxUKwHxAOgwsDSwmmtaMCX/+0GOhDfhj7CnHiXf4P/AGFY5RijxE8UgIrHfgag8FXo4K\n", + "ZEiGQWpZbDDCAAEABwCeEAAIJIIAAlQG+HQWSbUMm8twrwSClmg/K3/yRBANN0AVYcsTntWkgYPf\n", + "IAL2OpHwWYmD8ZBjBJz0RJkKgAAAAHBhAIfgAcADnIDrwkHcABAAMCC1WCREkwqwUImyhuABkXyU\n", + "zaXlojJifKRXbgAArGA/Fi2krPW/7XwcwVHkmEkC131+3s23xRCiq+SHKd4eGHhAAFAKYJCU0AO3\n", + "aSDqBQBGydjALQa3r3/AnUSWm+CWAAAADGEAouABwAOcgOvBvAAAAAxhAL3gAcADnIDrwNsAAAAK\n", + "YeACAAQcgOvBvAAAAJphBvgAgAEHIDrwvPGwTNrxSExKWzQBZODCndPhsiqgcHL/vz45gZ178b/V\n", + "S4NEAASByif4Dpm0wBWQ61ZYKEbfIP/eBBs3hCUt32jDvcg4fryK2MQnItzXyvfvgP4FgqEFAZwI\n", + "QEjD+5Fk3JpgFFZa2brZUZqluQAetIAFQPJ593XIA6GrqSaeAloRbqPz7QyyAgFYJCb+z4EEAAAA\n", + "DGEDbgAgAEHIDrwbwAAAABBhAUeACAAQcgOvBbBj4McTAAABamEBs4AIABByA68skOeAGdAAEA4A\n", + "AQFoiAAKAAEANeBAXKwQABkGEL8AUZoBDkp83AD0EUR4PicECq4IQxzF6wABEr2/gAIM58LSiCFD\n", + "Ax4WFgAHYQABWAkhAACBFwABAHrHSiMAYUo21AOsq1NgA+DHYPgGcLJQCpCz1doBTIMSlPJ9TABG\n", + "guU+G/4GpQGNQpABb4hP4VAlDCGEFncIAAyBRDHnuxVw1kE+v+CZVqQwPwobsatgxcGP6lSN4awB\n", + "QRQhZAWywQHPnRWVA3hhCRkEAAQCkExxSA8Itt+HoCFWCvlyjb+gcBXOwABARkAAEBQADYgACAOv\n", + "9f/4GVSAo58J0VeTsgSpgYYYgARBCAAEAmABYhjkwChhrap/BKoJ5JG5v/GgFyB7ZYG3LnT2guZs\n", + "oCkY4AlIQav3/4Z+AMVqwjvTwhXo3yH7+IYYcITMwgACAQgi/o3qj+1Yf/GJkYGO4wHKFi0/4vxU\n", + "AAABRWEAh+ACAAQcgOvCQdwAECOYItS1EkEkLJIJ+ABZDtIKISLh2XcDD+gYSQS02JSnr7/4QEpC\n", + "gLgAXqC8UXGkY0578EjNpv4Z8AEES4rbHdkwViZB3/8HdowvRErQm+8IAEVrQA2BuLES/xcF3R/B\n", + "/kFJZr+1hqHoAWvJ2TTTzruPMDfb9o1te/izOUnb2a3X/X5mM/+KNJs8/J0/4ye7P78vJ1JN/+fv\n", + "8qEABLZLAKf6gcIg2EyYQAFSjADho+G0A8eomvb/uPFAKGFWrk3gAxqntN/bsiWch3os7mBHTIAC\n", + "BQm8KFHn2w2+ICsADl5Zy9Vf/oGp3UHfq/cdeRn24PvNA+T46xMeVq22dvhhlUWEhXie3bB0g3dw\n", + "N33h9r9KQjIwFeOK9U0XNQGyr3UfgA/7zuNrv2CXADRouKBF+6t+LrS76aAAAABiYQCi4AIABByA\n", + "68GOIC82AAJIPwAKHGJoTWOrmTgAN5e5Oz08p1JTegtV12/jfeAYyWIXS1kPiL7fDCuwgWRYCEAH\n", + "TVakD54rWj+f7oAFmt8iA1w+bkgSRzBCcxqkul7nxoAAAACzYQC94AIABByA68GXG8AFo2qv+P04\n", + "BQYKsgsayqxMoqxKX/vgnBSCVC3CQ3/doVOQYGtKkbOTn//tqwAC4AsA8qlAQ561pefX0IUQqjwO\n", + "3KdgACAoAAIC8RIAODZPMWqWGspYIOC2EAAuACMAC0JocpPkrnh2mNHS0geh2hGs5aKnzAvMRN2o\n", + "ACzIECezmwkrrS+3wLQDjlMQRLtOAKYkAyMrzIni6cXE5EAUzBkLJSuvA7gAAAAKYeACQAScgOvB\n", + "vAAAAAthBvgAkAEnIDrwbwAAAZdhA24AJABJyA68LYkL8AA9er7t/qAUCHS1CvWoh8q7//4cB9li\n", + "nDrCyJEwt1H1sAuwPMACB5y3kTKxM9/4NphASp4ABbhSrG9X7piQXi19SABZmMFJ3HKS+XOfQJR3\n", + "5AA/BpiS4iJD/DAAQilGdU6S1iI1NZdUEIAHB1mgAEB5OF4rlliRXTBsomIOhAA57xbiWzSf8emh\n", + "THkbD5g6pxwg3IIpL26ghTVxapieD5Tg/hq0l2er0oQ7JbVjwaeyhf4YAP05uRbd3z/AEiUD9+Hq\n", + "m9ZFL0AB82DNJexkdBX/NAyqGFEi8sx6L6Ir/7SYYEzRf+SQXn/vCKIrbBNT6zvDaAwWsBd7I7T5\n", + "/sg0BABPa/4z3/w/hgFgLu7GnX9GEcqC59G0+twAgBg4VmjtsNaukXlV7hAinjF7FC/pD9oIBlhu\n", + "DDL8dyT1n3cAGBV6b/M/RGHoQ7tNa9a9wAQEfmmEddUP0vD//Ufh+3rEf/X8hqS/wFEHjtRvxMG2\n", + "VFASM2lZEin2UfBobgPSdtRCe//YFy0QUcvRYAAAAh9hAUeACQAScgOvCuJDkBEXTOwk368D92wi\n", + "CtO4z1eY18huehz3wAoLtqyVvoQ7ZQBfAmX3VOr1fEBiFtqboPlPFYAAgfWQAAQEAeH1+9IX7V5f\n", + "3Uabv+vBxu7QZ3oF7tPaTf7ns6ltFNp/2cVNJMDbDwJaIIgurMwhDm0bJ1+xhFqJKeuDjLlQItbM\n", + "xHUigpW+oB8pTnHp5f8p8MQJIzHMJ7GvJ+1f8AERx7IQL7jSP0/KRluAQJOaUdp7h+Bmv3JV0uAd\n", + "054FNuRRKQsVEMKl5zQD2aZjpMvONGmTNm3fzmQFTEakCGYJupp4XxNZrMoVv6Cx/g5nlEo4AoMX\n", + "OO/eC6+b/wAccXcct/9Qnk3Pf6UREhyABNPqv6/4VDr41VrYZR2bZv97QlJgSr8AD3Ieu0i6b/t/\n", + "AsZbMuYMQAEDKN6s6F5T/eUoOUmAGtAFkJi8fg0XI8mI99AAXupqrZ+5+GYS9VP9//WVOLann9+4\n", + "DnkXz79BDkgmj/weApjrqiS7/+Dncj0/+Nn1uY93wIDROpHX9+w85c879VL4bE/jYIYcNjlwYRJK\n", + "++Yhys+UndP4a/yksMRtVrsnxiMvtf/UFrKTUaPK1mSyO6Pc0i+I7mu+gCi3JWbS8K00rOMb//3L\n", + "qatK3/9u+Pt+bfgY0JMMWWHGtGzlA8XIl7G5ZwXgiz3rive+x2QAGOHykI76pe+7qnmWn7kVbI5E\n", + "sNMjIsAAAAH6YQGzgAkAEnIDry4IfhjwBiAAEBIAAQE5iAAKD5M8AARK4AzoAAgIWQAAQWwABArv\n", + "OCACHaUEAAIBIADAgXwBxyJnngl0QkKcBWer2ACU54JzzYUVoEMQRJYtF4lEGE/m8MfwAEGc+FpR\n", + "BChgY8LCwADv8DUoDGoUgAt8Qn8KgShhDCgBcFCAEAAQA1AOwIbJTpsAHwIdnuxVw1kE+sBTMMSt\n", + "PJtSgBHAyT8EyrUhgfhQ3Y1bCxPwcz18J2HdX9Zw1ARCtOPTkX4+vV/kFgBlVq//9O/4s65oRAI/\n", + "6DWAKDOEIYk8TtIggyylDMAWjywErDCQeeFbEUzNIo/1+EAiJYEAAeADjjYynRyZlJNDzmIBkHP8\n", + "HCVBeWRrWHLGAZIcCNOC3wR/Hf81IN/9Br/gYdd6OVFZ4b0TARouyH4AYqSyLsIhckXSH1VgYcDg\n", + "ANHCCACcDMr7F+GSaR71n+N64+vaH/wJyJfgKqlANcGmeMTMgMdxgOWMFoH4s/wcz0qwBqIt1h//\n", + "nmH1z/57ycbABeSPhLL199Ig5Fnb8BjdcJRD7z/4AHgQf0KSPik9+EXvABQMVg7lX/1ihFyZnwFU\n", + "w2X8TDW/nhEReCCwk5ZAMonR7ADywtTOTHqz/86aBlW6dbAAu+U38nf8Qm9228P+aTNf+efEjI01\n", + "aLAAAAFlYQCH4AJABJyA68JCfDuAAhAE7gi5G5qxq5E3c3AAsAwiCSs0J7NgpEw//QnZh+ipWlPt\n", + "DHYSUSkXHs+4GX8HrTYSw3JCnj7//8JAA+BRKQALCYWYh/ioLuD+0lh6ILrScae9/gJs070y4yab\n", + "8nGwALmMVTXMJSqsv5oAQCAI5cp6FdPuoIffwA6MaZURUZyo+zdlo0tK5cjiGrJ+vB8SRJELIyIy\n", + "Aw/gAUAdGAo6XxLrJJQsV4EPPW69f7vClIMTkABYOdIla6qV3/8vH5+oQWU3pPAQgBo74j/8JP8T\n", + "wDsjDVDZ3OFopBvQ2NohU8AHkGLghG2ooX5fveAQHQssFdaS+03RAvwasvn43OnPntYNQDh/9Q4S\n", + "fkW5m32y0GcF8m7w4ALNiFLTMXyH/r3+QKOa2Wm1taR6gnI72BykDgAERUNNT/t7Q05PtVu8NiLU\n", + "3Hetg+yB1HZo66AjqjaRsgWfXAywAAABa2EAouACQAScgOvC3Cu3LRhAAqiA9RvhC///98EQlFuH\n", + "clvR//3rAdLxTrbAQbiv/qRQr4QIL3kFvnmubTf3AARiHVs4eUB8LkP/3AAAgBZGcAGaJtIvdNhH\n", + "//cDHxRVABqHa1LDGSf+4ANQRr1obphXpGsf//jMHRU+3bxfRX+8ClB+GppR31YoJfz8DPq6j1FS\n", + "+6rC9COgsAAr1R8eK+efQOsllLoqvX/v6IQZewR71hiey179qjF+8MNcL4ADh0mgAMDyeZqlliRX\n", + "/QTGxGACQQVCVovkNdN7H/9hhq0EAT2QBl3c4/oYycybIaAA7CsxSdcVMpvVgyXHCJcehxNxGN08\n", + "8zJ1P/iA0RCBxBOPBNYuToGvvAFiMK34UQ5L7pU+AHKbeOBw/cBtw7yOf+CLJSO33cP4a1maYTlb\n", + "n5a57iTQTngWi1X+pPanlcfP/YHfd4HkF2jEOU16hkIYk9G8tpwC2hrG1H/LlgAAAURhAL3gAkAE\n", + "nIDrwtiAvgIm0172hLF9aD9NBfe+uG/a+sAFx/CX6Wf/+8QYyztZxvTxsYVgD1Pa5cz79hUnuzDf\n", + "em0T0P9Ywo3caD/FDN3h/+z/yXc97HEdg5XT83/n/KWzebYkf8MGeMFaRH0DksUkagGLExURVR2/\n", + "1EsyRD+/7a8Nr98ACdJPbsrf8i+h4KBIxXZePfBnffv38DfG8AB8AGAg7WXU+zZUeFG7wAQBhFDg\n", + "pK+olns7OaTvrpYAAgI+AACAiABoJv7+b/AQ4lFy09wSqekIp11IDA2eEtcheL31l/9uxgfG9eZH\n", + "UAAQEcAAICAAGggH383gsDhtCAIfuA3raRlGn7zFH5lPmAmlkHi3/Zn/9E0rJnf1AShuRFKEsvyF\n", + "seojwZwmUVT92gFBlOwUZ16Wub7RmiLBnC3RdM3aB3AAAAAKYeACgAUcgOvBvAAAAWBhBvgAoAFH\n", + "IDrwvxsBHX22teHNVCGwRfARAAEA9QAnWoUUqGeyAQtTiAAcQFIAQs1QpgHhgsf/4POwABATlnAA\n", + "EFgAAQLF/7vwCOAA5EAeJfwtLxc6vb3gGBXMEF0iSipVwTH3F958QIhghAW0phAgNk/TvN0AAICF\n", + "lAAEBMADIAm/dtw7DAAEBHygACAqABcQ+PPCAntCAAPgE7gAPxoQb05q10zf9AjK0RsWdAY0TRBQ\n", + "SfSl8hD5zE5AAOCA1kizaTSqBQlPZug2QDCmcotpubtcMCHJZSzxfTOGGnmABkAMgMfQ6QaQMYkS\n", + "HMAnzVH1d0DRhEWvn8EWxhcSFsMABwABAKHAKEdoVvqHRzYjG2L6u+1+vt3lBCQ6DKVA6EnIcIEC\n", + "A1RRAmtr03DYj/AgQ0NCYg3QIyDmrsls2+DBG4hJ02Lh8SrWRo/VEdh4izpaBaFihlyZZ+6gxid6\n", + "/XhYAAABhmEDbgAoAFHIDrwtwv4AFmYEtqnFnnW1W7/6PAAEA8AYwPTIASAYEJOFpIzl1LX1l+A8\n", + "I4QSgOEQALkZtCbKd2IQebBsOyFkGQAHQZQhiliXesFEm3fE0AG6KwBhZo7ckJ0JExIb4DAABARA\n", + "HODv4GAHSwA7+OeSghRX94IErECAALAGPHxx+p/xaHpGYJESFBHr5b/6s1xhMyKLbT//tPeCPgMI\n", + "YPV7/LgRZQfcomZClijMBqJEhyAB2G6OlihCSC//QEhgkHaCSPeGin6O+ACEK2lIuv62JW0jgIE4\n", + "Cb3dlYVPWOjSf4IFmdR9YAerk+qfAgBBvTt7iMJvfTDGrAC3Lk3L9/Do5GBvYmn/DEAWhuUWidxK\n", + "06j+MBiEik6vd0rB6Rf/2CMQuPi6Kb+e/uADAQD0clP2xJIjbevsABg6CkjIw2xut367/CGSx4hR\n", + "X1Y2/K2C/CAqxg52Wx9Xxp8R9rA8zTO3v/mBNJ579/lVbXpp//v9ylohQPIbaUyR95v/Ol+cFgAA\n", + "AfthAUeACgAUcgOvCsTDmOora++vAFQy1bjvNnACzgA1RAmQ1/3ZkYYgA4IMLQjzDztViLSkwnog\n", + "E0ARBB4/yF2zpoScAPsbwvzGXBH98wgACAOAC5Ya3GAhkxBnJaK9V03zcABZCABAEkr7z0P6IyJy\n", + "2BkRwqHGleY//7hoCczA476ohimXoYCuEF3IkmFHoj4HdzwaNvCcZX9MnDBGMas3SSq0d/+eAXfs\n", + "EuNgClSC4S+QtiTWNgAdmyeZZDq//3EhROnN1IrV/+UQoqvkhyi+kMPog+A7ywH6JUGZiB5frqGf\n", + "2dO+7wDAHk4AAgAgBJyNHAkoXkd9/whgSBAAGhBPwCH2hX1uM6qLtprpgiVb29WSV5m/XYFNAgOv\n", + "+/A2uYGlQsMAKPoo//tMPOO/crnQQxgvBiJPXhIw7+8CRvO/8mg8hMEEaQ29wBzyAcLbN8/fABeh\n", + "HVCkZxEn/7/fAFgYUsar1EnOK86uFAYKAC9iO2KUjGKf/v9OYgCwEFLGJ6RJVkzKzhUIcBcIAREo\n", + "8I4FSWmKVr8AFhNcveFbnrLzOE35E/+9Q19eUiIADDBdoUKuPNmxZNlEe+KLPf70vlxJOHdPZmPr\n", + "JH/rYFNrXd399/hHerkr3AH/3DOIYC9P8d3dTIGyt5hqgr4WRYQlS6bR+ohAO0e5L/A+AZYAAAJq\n", + "YQGzgAoAFHIDry8MeAC8AA0cAEBATeyLDIjcwECyBFMKOwoUwQWAAEN/wiQAOhXCFVHx7gmBOaQg\n", + "ACIYgsIAAQEgABADAsewAxlTPkcA5kng6Ybw5G+wAJcTblF9RHLfwOhH+5UhFiInoMe1YZnlT+AP\n", + "KbtrmCQApAxXOuj8ucEIb4AwAACAmAAICcRAAFh8ngNCCzvgSjE2XPvwbktG8kiXE+bxkGIkNRo/\n", + "+WQYAQCdVHj//8AgMPPz/+f/POCHz+wL/SE8bAAdgyoFjNes/nnr/6nSc5tO9fh+IskAEgxFi0Jd\n", + "SX1fds+/oeCFsD6CAPbPjp/wvaGowN2HjDs0BdAArs3j6+//vosezPMgd2bpP+HrP9McOQApVyGe\n", + "Gfmu3v70Ly+LaLpkP0PbRXCuAaICPqSg9QqJXp1iWH4gAlocQZXzRLYOAnrAp8IgAQYRCF4PgzKb\n", + "i1r/BhhAEVTQgABADADBZoYvr47Wb1mJh3je7d/85smht0KjPgFTYVBAlUQVHSr7g/rz18Du297/\n", + "/h8EhiESXrn6gQMMwBYZhyGpMEkxtDhyUuww5EELNxgyKXvv/Rj7ncoe0vOf8ZiFlwYQ3wAEzihr\n", + "mUpIxyhrgDH9czP9F/4ITxsAt03Lmv/g9oODfgjZDWZ7t/P4CYvY7Euyf5/8ABI84S9kKWMYvZ1b\n", + "aCU9L9wCpgA1aYAhwLE62zhvAyONU0Mmjs+GY+7Xm8JW0h3xDekw2kWrn+2zEKV7/i8Z9pF/fplO\n", + "2o3fPKm9JMc3794W4RDf+AAgJg1pLRoj6BDgq//+BAgBQBfmJa0+P1BAGspEw9lgAAACMGEAh+AC\n", + "gAUcgOvCZvzf/gsgAUsO4IjiTSSBS94AAdrgfyxTSdn7f+b40MqTxnaKv//2a6F5SNX/7wIAAsDn\n", + "HhKagAqAz9MxgEoNa178CFZNab7L/EIREjbAwAP7ID7mGU08x+IITCETC0fVQf+tvBMKwCcr7qxY\n", + "KX8ZIbIPHLnPHK5vft+Ob89t3cREjMcTFKdy3wAWZquHVaF0i+DE3T5f3vwwBQbmCODF17oEB0o3\n", + "ehhAFzcNTQAIo2SxfxzlAJtCIipSF+UYaimtWAzE2CQd7resAQbWW0431LEgtSxKEp9dzh3rCCrx\n", + "blshTdy+0AIcYsfCSyihbmmg/f8oAAcsAIMUs6OlPsvwEAukv4ADiGtvnLNcIfQRJY/aMQpgeazt\n", + "y2YjaBBicggCYpbBwvmJbnb//yBAOzKY6uG5LRvFGIdsPfmD0eCBUsEaS2fTYLPeGYmGoIH10gGd\n", + "R+bH9YA40v16qzvZs/83dwC2ACUr5a/St/vfgAtkAG2rUNlt/982eK+cKxoxNAABARAAEBUADwTb\n", + "8bntHf7wBYGQVxYAYsuTG/XpOV6P/3rN6/wQdNkBQU3oqzveodngIw6gIAGi7LU8Rz8l8/WQ1LY/\n", + "0Qj8jvg4YxZ+hKFkOB4JQDw3Lrl8SI5pw/bGobbQwBI2VhEd/tXyXrvNevm9g/ACE990/gGlxLbT\n", + "tXybz/9vnBw0CEKhALlLW6ZHiczwmn/JH//56C9mF847CSuPFDvsv2WAAAABx2EAouACgAUcgOvC\n", + "xfKiGOZw9KJABIAaBIBPKkJ7dQq9v90wjEHbV4sqFkf64AAEANAIM1Rl+tt3s9XswMcZRiW9wAGH\n", + "thKztGJVbJkZf/6xhIinZiiak//+4fysBBdOK2AB4yOiysVq87rDKxKYRkIqfzdDcZY0HhAIp+z9\n", + "L9XvZF2N6AACANigEcWEQzWyVVO/uEAjEMxgilkYiH/9wZGZ8DOQHTunSncQDOApMxakWB+f47wA\n", + "AQC2LuoBPe88nwY6nuAU2gOALAmP/u1iEcpfIQw+RHLcGpXKiFqi561/y/fkYYzoweZOWDDB5k5b\n", + "EE0bhsHfnaqQ0/95AACKzcl5K3fsuvLP0GnJZxDhwY2Ho7dgxlT7v++P7pweBrQajorAAkADBBJJ\n", + "RBfjMUV2py/7fcAAQDwBDg1e/AgJSHCAAOgINcgBnuHDBd5BihF9u+b6AA44hjkcGsLFMN9yXZZB\n", + "oUjO0VfugYfMjGYqCs1BKHLVxjWAQYYkK/uGDokNoPzAAZBQVMxYXRyUkpt9+zzUCACMhAQAAgBg\n", + "AUeXtzMoACB9uF/VDYH8T19eiGaKM+wAkLXVUoH5wR2W9Q5DeKhER9OeDTlgAAABPGEAveACgAUc\n", + "gOvC0SIPiwkc2/4iFoAokQ6YoG+FPCQzPYzv0WJ8BIAAgHiq2Q0nQSQ455pNWeQEiCOUw4w6AKTo\n", + "Kp6CZfYkjdvvA3dqQgjFMIIcxAYYY7gRgTAlI9XytP31BuzTSST9XwtGdaWrUbtp9i/SAGbKP9fP\n", + "7Zfz/rIXIK1Laj5YGg3xuAAjBkFIeFMK4QIjZRw7AAcMIYc1vHj0WHviz3/3jGcOW1Yt9F06yTKv\n", + "ygABAQtkAAEBUACogiXeu28vgGEPOY9Bw9Jh/4y6/94wABAMygA54C3JU0qBAZyFoMEHCUAAIIEo\n", + "AAgKg8EA+c7+4gOIgABQUgwjGmhVFP/MlnmkfkBhbRzxtaj+milNG+6AlmEIkpqvNnnkEsQRgmSZ\n", + "L2dASA2Mca7dxx6MJKKYDH/Xex27QO4AAAAKYeACwAWcgOvBvAAAANFhBvgAsAFnIDrwuXwVwJES\n", + "EYRG+AA4PjBGRSZrasmMTiclJI9EEpSMeRCp734bxgQc8PSRszwzUAEL19tSDC2IzQAYa3/fngAP\n", + "wi9ndGVCP78qdPv++sBcKQ6beAQOxVf/vBsdDQtaIJquJDcACwCKABV2qaBhy95BO4BQIwKWTej4\n", + "VZp0qZ/gFAai1AAAgGb3ki6Amc7mjwgAHqQyA5L5ClhW/yKBiviF1TAFGRE8F2Uz/f4IRDRLa+q+\n", + "f5lg04ATkSZmBDdl4/caDb1Pttz/iwAAAVphA24ALABZyA68LRIRDlAEABmQnSmOOI9fpFr4ZhDx\n", + "P9OEo0Ed0k8gV6CAERTeAHtrDbuP6o4AF0wSwWBzdcQYdUSIhj5mYyvzi6klK2p8QH6YCGl9C2kK\n", + "MLDD8M6Yw61Zq+RjVhh40Ake6P62DCX43brqMEAS+7qeNvz1ROKWWX2+j71J8Zg0i4kOQAHDGSjm\n", + "oQ3GLS8r/zgAIDBJMUwpzA3wp4jMEjKUVmyiP/vAABADcAOcw/WPhgAEa/fgnEH6+BRqNADxP6Gy\n", + "Htiq//8/wJAdScAunJqFlX+9L5eJEEEB+ABPrmtGrV4BBXQ+DOyVOEa5QMPwAGErC9Fs9K6NUYHw\n", + "AAIAA4QjDH3ClFZnP594BuEWqIxPYfgtRoPwEMrcYxD/L9kfAYKsMR+Ez1m+OA9QuBUVETPtVrY3\n", + "rGsIJCL/4A7LTF9WcqFsF+rGkOxpr/zwXnu9OFRYAAAB6mEBR4ALABZyA68K4k9KPADJ7cr3+cAD\n", + "yefsqQilv+sTBBHmj4ADgwUh6jiBq2HWBW91/+DwMgDBZeejTY9eEbs//eeShgwGxhA3IEAEIS01\n", + "ShKWCKlpMPe9/8ABlXj/KP/mNYpVPwP2uViiqEdtaeMAAQBXYZUA6DlItliIdgA+ESmEwqXS7+l4\n", + "ADIAKBKDEmuE8IRXsv4dBo9y4FNKMf9/IP4ACQnIKxBpHtEfSR+G3387fOiGijAAV0xTkXsb50jW\n", + "Uqv/ctmZyFJ5+YOS21zt8+gto+OP8tZ5zHN0TD847AwHu0HD8wuf4OYb8AE30ttLd8uANjnlH+Xv\n", + "4AmDX7SPlz8QYL4AKIBAUdah4RI0Te++AGbf1mDf9+/LDpgKPsdYVJMvj8WAuGZXpuT6Ym6q+IEZ\n", + "sSsVKhWI8Oug99g7wWiMFxVs4Uo4CDDxED8AD1oNTd6Q8J6YDAlwrhxMYLLZXefBE2QTvb2V8K+r\n", + "Xr3/9gkBaeberUZzv/2lJR8obu77iSRAPD5FbUT4wvfEh+BIDHJ0niOmIKif+8CP/kBAHoMAOyhe\n", + "7x6w7P3YCJidMUncT0JSDAhJEIEquM6WhNnuQm3QUVaZSoi9o/+xFVyy3WXtpEQkwWYp55bX/n42\n", + "G/3u9MK/3e4IMsAAAAH+YQGzgAsAFnIDry4IT1/hqXViAQBjwAEMlADKXwlNV8f4JgTGn3AaiADA\n", + "AEA+oAAEDMAIv/orXvoBwAwUIIAvhmADjaBIUW1KOBOCWjNeI436vYA8wRkvCUXDWiJMcBpEgA8F\n", + "IB5gSL1pp/eGifg5njoF4Ag3x2wP4AwNL5tosHv9cNXAAQGhADWtw9Vb9y2Ndh/LBAArUNFu6T39\n", + "fgCr3fbt/o4nG9QBhcqumVzDUXvBFdUG+mdCUo8zAOArRhcQAjjnMx0owDMTX+4YHEYVP9KFocz/\n", + "wMYfgATclULTZwtzAGH9NXjwnPKFxRuiD7byTqZtw3+gEV5+lf7f2VsnjOq7RyRYdj6xTiU22b3/\n", + "BiVp8ff248j3p8wk668K/DIAGHOmfseC0puLGv9D44MQ08Ob+Lu0jEfu6df6xz+oPwMAwoQIG8UA\n", + "yJ2Q8pFVqMGripafbTTgfgLkGK78JMWUN8ovQCAM4QYcKBi5Q+OB+NP8HM8EtwAPYntmyXyX/sWm\n", + "HUuj8QHMI/jkBAGoMlkpfkWAgxzsBvJ+Xt3AEPQotf/9L/xAmHOAAZfFAzjz5EWf+wHgMKQXYUQq\n", + "RILrv99wkkzuhMB7WALcKNTq+CIXf+HMfiHZf8Tw5wAJyrWr/y8R3/gxLQlj/hxFY8lR2oYz60Zn\n", + "A/ARUtruw6ptNMWAAAACQ2EAh+ACwAWcgOvCYn5IZgAWQ7yiCPPfjVAcP/1wAQRLitsd2TBWJkHf\n", + "/wEFIJaaEpT0v12jC9EStCb4IAAuDnnhUkAB+wfEwZBa1itvoP4BVeWgl/8ogNQBiAt8ycTnPat4\n", + "YE/LRXYZaiXgBu7FPvf/0/gBuLMS6e/92MZv6f9VeJgvgAIAAIBJx3AVO1Cksq6X33gAAQBYUCBA\n", + "ngmVSdtSMXXP/+GMgAeABcFgWnMC1Ch8qIJv7xQBZbnl9octgCwlfz91sT/vAlq965X/1TZilvm/\n", + "vGUr8+coEsjiNHpoif/3Ug1VMRit6ujYjoCG72MmPfpfiREKKIDsEYAF7AAEBIRvB5VJm5YaI3ec\n", + "N3CCFYaxBKt9qzDP/Bh2m2AAZcPrPa4LQ7Q7mAqEAlYveSLEkSyPBzDAgACYqmRhtNIz2YVT+f71\n", + "ryY2dKT58M7hoW+est33/98J+olxNoMikC4YJksjB3SX8Nt7hnnrADj3qbi8/4EmTV0SylUnb+Jh\n", + "WAB5FAYMKy0bbCFwRvT/94GAoQIQ5glF1ez64te6//B2BGphGRBAAIr2162P2TpKABloqJnl/LAS\n", + "4fmvc8BN3jjKFcte/WjkAAIBTpSUAMLlBV/77cv3YgTEB/ucDAARg+jip/sUj0OU/XuvjB+ACdEH\n", + "pTFMUqAC4QDzyWhxITU2fOF/oaFGTBVJvwZkTfwCgGC1zk2OjP7yM6/4MDizwaHBhkGurCeqTZ8C\n", + "Oih2Mom659Wq6vKKACr0+ZDK9bm/ugysWAAAAaphAKLgAsAFnIDrws4g8K0RJ0BgA4ACcLITKkvT\n", + "QWm+mhoxzXqbAEjAZ694JwQRffkbe1NzEp2QKsT/W9D77wmcCmATBP6Pf6WAiBlR/1tVP7f9Pyhh\n", + "AF0aGq1WSsOgjTmEDY2IgEFqdSDUlajL0FWDFgAQDoocn8k1YXgwX/tFhfDCoQYUww4+B03L6coq\n", + "Uj7U5BofFpDUn1wDgACAnAABASAAsEKmACRuYdk8Spi83q/f4OMj7DRHYQJxmaAMeK3ZRsVmw9YA\n", + "oE2t29bqfv8Bs2kT1Bkv0HREqaalvfn8izQ4WYBRmMcWS8YhOjH6DJ8NRMNYACIGIce5IwnOh5cn\n", + "e3zSG6oQw4rt9EWgKYILiNgA43EG3sVPdrgAXtgEIl8jncUys6KGpuHzmGzJJSy41PP5EYisAAIB\n", + "a2alwYMVlPgLBfKANrqPOkmLdL70X04IycgR6t1PsWj/9ZnGakSIj1eDGhDAAShk6wkfnqE4fz0b\n", + "l3d4BE0aQ26kVnUShDAGu5GyjcaLVj3IZBfT3/3+6S58dip1yCdoH1jNKW9W2UOqm/0/tUj4DLAA\n", + "AAC0YQC94ALABZyA68LxIQDMJmDqHqIcwIAgOIloAHgXg/XezMb+6gKFJmvcV8fvUAHmmn6Lrv89\n", + "ItNk8p67ps9WHjoy3+BsvxEQIDIMAyFsJuDpnAAdGACDHxHQOBeQ2FrZ+4gAH0DEAIVc9YHxduC1\n", + "/4MMMeQQABBFOAAVhrtAcy6k/+PGaQN2wZFELei67vgwAuwHgM5a9AOH6KaH/5wQ7LeocA0QiAh9\n", + "AqLLPaMce+PBxwdwAAAACmHgAwAGHIDrwbwAAAFRYQb4AMABhyA68LmEXiN/5rgAZF6UzaX+fwQ7\n", + "ijynjHfLlmX3FTAlEXLA1QyymEell8YAIOLZluCMNBZY2GoFXzLr9DgAIAYZkhCaAiQwJkOguaDj\n", + "h2G4AAgAAk9KzptQ+YvgBXAAGgCjedc4Y4ePi4QAX7hAAE0AIJCFphgMgsaXQSN7wCj1GRP/1rvG\n", + "dmj8I+EATfqPcs4CxtdAlf3gFMjd/bZglEk6CKxAIEMs1W0JrpUG4kFY30sEAIZSgRYoILCBh9+g\n", + "IyBFI4R+NOaWQSYkdLFx+mAAHQADgBIRlgJhEFaJjSJdsq67a+m+N7qAB7Cazv7II0/7wAAQCw7o\n", + "bfH9N+GoQX/8ALMAPuU8xYB3Ad++8HANQYAKD4wuzHxD2yG+vegJaRejGj8iP1Lo1glIVPqKyMFz\n", + "WPvf5IG5BCzLMb+/DbmVnB9OPIekvTT6lgAAAO5hA24AMABhyA68LQiCHL4gTEeFrAYADgAMAjnN\n", + "EJlNmW2aiVf98AEA5FixDtdRXlJnlT1DAAYC2BtL8VRbL5WroMQEGCzMADxOTLISId//lQuprf78\n", + "BzROQ0+OAhAAti+NdJK//f5AtZJrP+/AYYIqYdXpKWpY+6zR//vBpYRCIcoEABa0GsNS0h4R5i4B\n", + "hUDBXqeLPhrx0lt/6vAAsDCIxtsv+1fS/VQIARf3Z//p1iBIZjVPEoAgTuoXokiIXvg11MT5v+8h\n", + "hfRbZdd0bEVIra3/1u0N5QrVmy81aziDWwgKdf//vIdWbs336DIsAAACOGEBR4AMABhyA68KwiJP\n", + "XhA1fPABFzs4UWv+l+J4gdBBgAWmoAYFy/IvI3vvwAEQZRCGJNPSQMQXXS3jgACCOAAICUxAFB82\n", + "g9ay9MADgwOSlYR0OQzUZYj+OTRGYRI3AB8585Gv+eAMVnoKXvltxMyIaWL/QI2/u/AwNCuahsWJ\n", + "rTj9hMAXHYYSWcbiT/1CBJ4IJBjlY/GDehTyw1HYmhXqU//B4ACGR8wGC0p2z1tBVwMA0MFqUfMw\n", + "v5X9//tPM7TRtfxlithinTRTk4sO7IyRYhJ7v+tSFEpu2//3fEiAAEAHNlAKMIdzFC0hrbkitPe4\n", + "MQciT14CMmizvf3AEdoaJTvf2oXwAHcg9Z9ywxzIewwALABiNYThh9C6++j+wCJTdXwAPDMSHqLF\n", + "6T9Yqmj4b6fH/WhBx0b4DiUAwCDs5ZiO/sEzxj6lwd60rEznFcMMwAA2gY2W8GcpMYOSuigQUbL4\n", + "15t4RgCAYFPol+8FR8UxybIfOEEAFgMEJhRrOaEbbP//uHJsQF0ZRZF3/8ze7rSce2gmXf/qS8hK\n", + "9mfv95UYIRRdEwjd/95I4qV/7jI5Jdn7Orob8Aw/DEu3JUJ/D/xmSGQIweNX4EXsDe2AEDCHfomO\n", + "l5YYa7lXhsCjlHXel7PK/e/GYAIAti4DE10edN8n/9wDH9Vt9jsKcwk3/whmBwAaemP3qV38P+2m\n", + "+YMoJbIJMLdtY2BJNT903u2EIDMUwgUwp69T/0uzIbRzeNWbteDYgSwAAAK6YQGzgAwAGHIDrzQI\n", + "EMcADhgAHXMgXYc2kVAwNl9qGHGxEYS0ggAiNbgAavSxoxa5j8AB2DgmPXxxI1yyxUP1MKNg5Ehq\n", + "2ZfFIQYAK9d2zx3wh5sDXUnNj71/DuADghWMaxrGsaxrWN/AAsDFJtEhSkEkqE6vf/wg5sBwA0QM\n", + "AC442TCWDJJY/3wwm/PL8TxDEB74AAwXVBdZuwgsndGXwYGHgA8DBHLNd6x2m39/uv4AOg5SgACA\n", + "8P/tsNLft+CxQU+wbZvHYqv+/LxGsvPwD3mRV79gBbAZm7b/f8G4CkohLZ2vP6X8sogogO+ADYAU\n", + "2iSyScG6IkPf/2BcFKwjQutEkFX//kH/gBsp+MMU5onyRPhjEbekPp0Up/8H+AA0lcaE4cX3En4m\n", + "sGMpBuPgpFBA30ClBytWZdnYAFAlZsXEzsdOpgbDfx+XDCbmo37illaPnJnBhGGGEmtBSZ1aMVdK\n", + "QDoZCTc4FcMwBPgDCFGHBtRT8wJ0QVEwGEHCpIIATnOCquFiEjEW5/ymA12UCtEkasug2HHBvAAh\n", + "4ADAgiMYMssMM//4AFgQhNJgKVgknQlV4BQCIXgFuUohg7jTYQAIjGgH4AFQ6xpu75Bx0+GgRUdY\n", + "meKYCOGBGZ69/+AKOk+vXJf3LKgQQJLgGZKDGAdKznTl/4bj/gAotBoU1KIlwuBx0gBBenAMVryY\n", + "J13UP8GMEXcwkQpg6CO+OkICAs5lJfzzHvp8flYA8Eu/+HVjf/SDrBvacpbV/36rGz7z0cfNTiDB\n", + "/4BiO5rj26SzTFMNqUTm8leB/y2CEABjMhIpS9hEJT34AIQJBnrahPJTTjdmG2PyE4z0YScs0d1Z\n", + "lM4CUxwDoRiS9/6IuRdRRlN6tr9/zp8Zw0bRX8sGArZnR7LtYTH/lCAqJ+ryhRvWNNAPKYykJ9H8\n", + "4sAAAAKeYQCH4AMABhyA68KB3AARkZkAAIAQBQilaECJEgR8ABwBSnAKue+FAK1/2gEEampMC40T\n", + "SoTeD//CAAJByiwFwAPBGMCdJku+w2vX4E4vI/6T/EwvuhkvgAIgGBTAQ0qZzP5VwwFCcsIj+DAH\n", + "P9HfOIObimekc8ALr/+mu8gQzBElKOlhGLfWcIDZAGANcJKLiUKSfv6qC6B8AzBBQl5lFNu15U93\n", + "fvGGAYCIkPhFnzeKExZVkEMP8R+mgcljUj+KECSaYG0HXH6B5n/qgABASgAAgLAAYCEzgA5qAewj\n", + "QsmLDqzNs9f4IAE2cIAA8AUSs3A7/63ZGYHzi77Yn3dNdtJf9utizxXykEwczW361wFFwvlJVw9z\n", + "RGDuMJHr+s1CA/2KmkwikRKolEEEjdaCFRJz2T9yMIEcpRLzFNHbDH/+8PAAalwddQU25t/33EgA\n", + "+AXUtIcL8qTO/3hwAHuMAYQZiNy7pR50AJqOevkKf4tJBbTQIXkjE+ikV2VHVfa3YGDpOTAZTCJI\n", + "efrXGOrfQgZIt6p6vNgGUhT+Nvja+w2YePsd9/9HkXZXNvdhIAePUPIFJ6rr+r6RGcgl4GYkIZfe\n", + "JGBEgQGw/DMIWStRgoE3CG/QsE8MbhwHAABAA0wk2hrFSwnHNQ+ACsYXx0KQRJ+/qwJHAIJiyWry\n", + "VYR/+/wJDLoH+7MEYxE3/Ag5uIAATDiK6yGhTT2SfXZ0ZVxxmabjXc16iXextm4ywsXKOosyniNI\n", + "yABECLaITX4lt4MJXxEbrz9L4ifERAV6AY6jFII8yuW0v//D+CN4XU/NQQcAgOIlGPq/cvVzhcGH\n", + "YCd6y2a2f+f2AiSaFLtr/fckEGZFMEeWa0gtsXaaZNpW6w5Gt8/9u0N9E/yVda/+LAAAAVthAKLg\n", + "AwAGHIDrwtGhoPYACwnF2lRFUuU9BrwA3D818orqDrapfhBDK4w1PmIF0yd//Bl4dfAj3j/egBAw\n", + "J08CVEV6QQJKkHw5MCJtAAynunL76gFDapdKX9/z8zBmaXvoAP5teL/fyg6SOP7iMS+zIwxgAOAC\n", + "ABRfhbKn+XD3N0gc/pWkAAIB8AAEBEACwRHx+b0eQU14SrT5tlsiqiAAEEUAAQFAIBGdgA4VcsAB\n", + "weS4wUYKmf9AjDDQZkEQABAEcAWXU9MavXbutt97l/+3wp9FUuWzZY7Gd9j/2D2PVf7bT9qim3Kb\n", + "esMgRQPPJ9xQR/bSGzFIDd54xTaL/4NPEiNRAgQFoCQe4JhCRdFsOlLuggGHwAEi3iTuhC1zEDE0\n", + "MTOCkolIW2Hj2lpAgSl4k3/RMf/7mAAV9WSK0T3+Aywy/jr1Ja1rHp0Wj//PGQcWWx/1xxvto3pF\n", + "gAAAASBhAL3gAwAGHIDrwuXxIKMTiAtAAy3pyaagfxESQmyERmQMMAC0GDyxMBSxc+SPFd/0CkMm\n", + "AMA2TYLJbggXRggACgMWJAB6JJxQ/leqMz/3q3/wDVUGUZU+T5PLQi5fvwAbtz14+avb9v0+AliC\n", + "xtJGOHyeGBhrJkEsjg51J//3A2akRLxhAFwBARUCHTAJpYoQYGV+EPwEKjxLbAWkp4sazk5BxBBo\n", + "JJNY5jzy/bBhwAGyMzQmylVmUABAABABAoGhVXhlw1BAQsG7onv7a/b6fm6a2TTfnkOIj9IYpnLa\n", + "SIiIWyS+mKFsSM33WIjAIITigyqbBUVHzswkKO7k738Ym+j36lQasY7PgQT6nEtgTpx3+cHX6Bxd\n", + "VIpLK0W8MHcAAAAKYeADQAacgOvBvAAAAJphBvgA0AGnIDrwuGMhLSS0kv8cYhNBs3/82eC6AAh0\n", + "hyAAhponDA+hBMjGnzAA0OAQXvjOPFshJaS+eECoXYh3pgZoQ8pjx/CEkwgAI73cAHhqo2OgIQ+Z\n", + "T9wAKAACAJ4GMBvzs5ATarh5N/5/YLYcAO2AccHOARJmgfI0eeEJkQQAEZ6cJHQaGOUT1e/ozAE6\n", + "gIWPKOF/V7yQAAACI2EDbgA0AGnIDrwsN5kVUCELApEDcAB83jKCL3ViFLof9zLpZ8v7cEKaHEl/\n", + "CkvGUcqbW0qwVAAECeSJcYADqf/bxAiiFkOGsZTKMvPslj0BuVAQU4sQn3GfvAw7A59kYuRaFEDt\n", + "Kp/+0QIfxOBvaKtKRF5tXAGDtKv0HiAgwN1b84cAACAdx1QBRs9o2P4uSog+8ARoBQIzOYhztjER\n", + "auwgABBJAAEDABg2EAAIIgcB/QDVpdgDaRZB7g5wHL/YAzGZu1b/Whj+0bLU7llyjWHwAwlw41Pm\n", + "nDVCCI2gRki08BrIAW4AfzgLwWqDA4KBrCt5URJhvv/srqUCIHQt8FggzW+okHCHF5eoGHD+RDEb\n", + "2EmLLGdUXTDDCzMIHutkCSoNjDMIKHBn5Or2MG9KF95vvLHg297bPDJ34dAhgg+PBi6EERSWuMib\n", + "kbRuYAAIFYAAgegACA6AzLeAAwBjOCxNMqrv2uR0/8cEBE4JGGcEMUqIW2Gz8zwAGGzFZxG8tyVq\n", + "Wvml5QHwwABAXBBAigKYJLhL4/2yb+MAAEEUAAQFgIBOWCCWUIFDH8DaViSSD/wKNcGrI18Ic6Qv\n", + "/CIoED3PEULjvgEx57/q4AEGPLE01V14kzUkhhSFvgxWlnltGu9XLruurhhwBgAAEBMAAQE4iAAL\n", + "D5PAFhmHIakwSTG0OHJS7DDE0wgAiPe3399v7WRSma98ff/pv12Xi4UXOkyZ5IAAAALrYQFHgA0A\n", + "GnIDrwqN6dYIQchfAj3764Dc81xpNWhhKQVTZREv79XxSGGAEY8/q3w2g/O7tl/4Ih074Ee+eGiZ\n", + "cRL4QaZVONgprQ5ay0395pmQZMVGitX+uAABAXcmYeSwwd1uQMy3/tHAO3uiqoOsE+8HBqK1r2Bn\n", + "jzvsBg0fPiQW29n68AmGFEqoiuHUqWL2BvwgCJ9CBp/aRVf/gw/BQAAQG3nyF4xLobuW+bcQh0C/\n", + "cI2vVuMrf/YUpKSSVd5RCiqXJDnOUoYAneExvDAXz1X2w0nqNKbiMuugEM/pYqo5u4Hlp4dDbzAv\n", + "TsIu6c9mT3x131LVym//yoDsee7Wb/vxwPA38iGM1GEnLLGdWZTD8GK0s8to13q5dd11cMyBsg5p\n", + "7WKv5SvTQdXhc/hvAAQDKM9BghXPsKMsKs/+AA+Jh2p4g5RY/qzHAGFZHfJIqr4JalRfhgAPHnCX\n", + "shTxjCWgs/AA5siUbLMp8GerekOwAObIWj9KrR9+FQgCCAAkDCACu+uogFyiLclJhrNAACAfZAAB\n", + "ATAAmII/a0IDhJVB3eRsSdEjGgv/5GAAICIAAgKAAWCT1q9wAYzhJJKJFIs7QRCiylEaMqw230Hg\n", + "DiYVqeIOUWN6swr4BjsjtkkRV8ENSovKQwAQYthAACAkAODioAVVzpkrqthPNsBAhvtEGJEI20xD\n", + "SpVzkSNkOT/vAaqCO3Nv0C77VDxApHGUxwEhN6KY7vLk2SMC51xUBJxUbAUbvnAAEBMwA2nDiXx6\n", + "//eEZOYIpm+vUa1ekBuwENDieSgvB9N++bz+hauTyAEFbEWlyHP7xh7MKtGX+diUhjPBlDi/b9Pf\n", + "gQHcog9RPYlN8ALIRShzB2rZLkTTxMAC4eq3XdNV/+wd69rWx+6wtsHm6wS4tmv//dGeuSWf/req\n", + "4xRKsU0fLZ9PG7VhlHei31Fsc//9AIJy+r5Sttc5//19HKcv95sJIB5MmHuC1zxzQ/GK1++N/WSA\n", + "AAAEomEBs4ANABpyA680IsMYDzJywAhIaOjKg6gICyBFWQdhArCgAn/+IQrud8QCAApGWU0AoDra\n", + "RoRvtP0AAQEAABASiAAMAAEAcRnBAAEgMWLCAAEBsAAQGQFApgAnBRngsg2Zw5vgPJVimdwAS0A0\n", + "YAFyQAAgFqBTtDpAFKgnI7/AOoAMR1kD0nADN34TeG+YvWAAIle3hAJSECAAPAMPfw8pHADDmdu/\n", + "lAAERWyUAiIw9Xa8aJ+BJCIawAMI8lM2k31pGmJ8pFdlGsXgAdbKKkT01DcSDq/wA6MxRNkT0XSV\n", + "/L4EAJCQmICGGfACzsAUoujkh1EpB3+7wA6Be95jyBbN/39vzbb4iFOr5MUpylggARSSQYqBCAIk\n", + "I2NRHsLeHTmo5db98SDilPz4N1F7fBABKQMRN1CvT0ymAcAUgLO44XlG4dgAeAOBAjai+AvPdhx+\n", + "cABBDOYQhxiBVk1xX/4AYCYYroxykJsT13hgSnQlQC+NzbdP/2AAAgDqG8N8lK15kjT/924MUFpq\n", + "zX3kLZoh8QhleAAVrAAagLKxcF59JPF/gIkKBsAGqfmZKAJHPQB+GGAAmQymdh3e4TxJNCykVBI2\n", + "l/94EAECqPCAAJBXFgAeAY9rteVuM7u/7QOKPMa1f4QcIc4goc5pTdcBIAGANGjt3toUaBIbtLh2\n", + "Ap9oL0AuzAQWJ5hCz4uCi1DPyIYjewkxZYzqy6YehgKeke2OI1q0kQhaSX+8JbYQ5n3jPiMbZihh\n", + "+fEm0JzkiDhgnE6Cv/IAL0OIormSG9D+hzD8CogUaSJLkSgNt39KEo8gihCSAtlgkNfOi0qByGGE\n", + "AAgrzQgABAMAAEAIGDwWIMaUgj5chZ2PfgN+oA96Ej/AmYBACTQNk5QBlgOGd9yJhndwEKcSAWu2\n", + "EXh+Gc7AAEBGQAAQEgANiAAIA6/1/wgoyBAAFwKeJdpMAkCOtL/yEBSBWAWmKq/tf8afzf+Zh4dg\n", + "AVaYSU+JCmpfrlkFqKlSE33hiLex6KOhbVwCj/gAx1kqyDjuCMYb2V+GAAmJh2p4g5RY/qzCYQAB\n", + "YCHiQlpYAFyB4SNGwWvYph/N36fTAGt2fRDPv6O0v+EQwIYfx9y4aQRjDgAOLHJHMC6ctI7D/7RA\n", + "3MNjUoLWOSf/PDD2KnaasY7IPkxjLwAIgFIdpMhcRKGOXteEAIyniHFo1R3uholF1ywZJoiLe3AR\n", + "AIWk2jCecJYmxYddVq/vH/76QQDlHuJmPKMPSaNWVe1a/5Z971YsNB/4MbqeaQVqXIJ8siyC9fX5\n", + "rD/9/ofgCgYAK5zGhg1ob39sexNoBIWZvHCJUSnvvUABgAoTCC5mby2SgCAu0wADD1Koa8gSvJv3\n", + "+A0q5r04rOtb/9wDcfEzXMD11jHzuGSACjQwqCs89v9wQBGj2KOv5+WbNhLb4IAAuCCFQMACrFQB\n", + "1IVl5/4tBOPPRjd1loU/+0hxCEYC19lKOf+2yAI2IoW4vSMn/4PjXjmV0bHM10OF8Ybtf//5obcA\n", + "QABGe9znvj3+BIxbRCdMUlR3D3/fgxmUZaWJKQYP/z/CCzuA3AmLYk8KFi4Nd/cMeZIAAALgYQCH\n", + "4ANABpyA68KCfhkMBmABYNQr2YUQko4lxfv7RgnONrEoKSPSf/P8IFVVAA9CJnStWFflg/h6XD/1\n", + "hEQF4AFqQL0SEStspepowVoiVoSPv8ABycoAAgBBeskMEQKUP2Aa//p0AAICclAAEBMACQ+3T3BG\n", + "ADrYGtpg6TOmXeSPSfAAEBGQAAQFAANiCS/AgAJxUBAACASAICi4JW3jcGK25s//WyqnAGoFaquM\n", + "dvgCN72fu6RZSwt0tgodP/YCkMgDlcYYcCwz99L4gSPBAZFHDYYACREIlWmQlctKAAhkMOS1RhiC\n", + "RaKiiKAAAgIAACAqABkAToB4AsAAkCmlTcCs5hR7fwA4/Hd32bPmTKkiADAGVyA053eY3KKvS3uE\n", + "L560xwiA8GHwxlJ1IsvvcBh2OOFiCLaH5XDKy/8neeAj4ANA98BxY9SV1jK4v/1Zee212ggHhGBA\n", + "ACAEQAFBMSNoXUDuflRMC52ervQAP2FsHzyp0sQnpZexK3/+8AmDMNcPPKcn2IBBZ8X4vwsql7f+\n", + "0EVgAXnvBGgDlXj9EcAMDncMniul36LxjhZhb8RcJIt6zquDLA68BFREiVESUGjaD/LumNooYEea\n", + "Pz+d0HIfgANkZmhNlKrMv59d93/q7TmTafAADkKF0oWypuCCQL/+8yyhp3Qpo5i+CCsUNt/hmxFB\n", + "l/jIQABUEEMgyRlc04bU4G4EsKLf0K42U3T92CVS8BRq2m5zsSFg/DD4GCAdNqMbm3wfVoRwtfB4\n", + "YDQTWmGEAVwa4f+uAjABAFKMKkbql/ESv/vHYmBgLa5jSQOhPKcfFghLCSInLVKRtSNm3LsHQCHC\n", + "AAkcoUKWIDFSvl25ghzLUO+7sDZeomzCtW3rCiSJJLf//r1aGhWMKnP+eZT1Y/yuoSb7ZoGp1P/6\n", + "jNvX2P/ffEAvC31NGkNupFZ1D74+35tvB+RRwkzqUsc5Qw545lK9NB1fPx97zP/8kAAAAkthAKLg\n", + "A0AGnIDrwsN6dS+GgYA7BAFBTY3ADUAAQEJZQABATAAoPn3gAEAGzBRRDmS+CAM4yGFhfpwCABhp\n", + "tDjcob54z9b//hjIIBAGRtTz7eA0IAj0YsBzwlPM3BNW8DQJZhSwFsx4Kfii2z/gq6q+w+AgVnHj\n", + "mXrwk3G9P/e2YZXU4/tLS97dBkY9I1UBdFNO9crDrECUSa8V5fBEAEHDwgABABAAUAYBAAD4A4bK\n", + "oTDDxTItGyYrlqSqAWMQmpU9CGDaFWdOBOzJDMoVUPgAJBgAJ4T9ZIVxIygtKOMaASTzXimGII3p\n", + "wDDCzKDxcS9/VnV4uTNY3KPukpfCHQ/S+EALPLhaAB3I3hABwD+RwC5LoPxhkHIakwSTG0OHJS7D\n", + "D+ZxRnCUpIxyhhhTMIAEVrWUgWw2e+dna5mfrsvFxxc6TJgYcMn+HwLA2GAA4AingDJ0+6INhZH5\n", + "/BAKSQYVYqF+sl6eloAAwYIxatWSKRI3cx/zgbUAXQirkCWTfU4/3AN2ARJQIRK3pZJo9//9cCVX\n", + "A9PUNX+V7/ABxIgOEOTbVJAlNiUp6X6BxtAkhacl4HdowvRErQm+DAUgUL4FslKeqOmRQ2K/iAAB\n", + "CEgAAg1+DCrIIATBCaWzKC5db9tAMp7fUNkBE0//yQXak9SqTSCKffdFobeEENUfqUfGZ72A5lwD\n", + "IvwB8CHMIgXgtvAEbGW6zCj8vxsH8UrohM3n/ACTgtQFEhKG7NtmtZ/+DHChUZ315ClQg7jmc57K\n", + "quvvpmoN4RSmhDt5IAAAANlhAL3gA0AGnIDrwuwNMEwdC8ACoQGgiQquwxtcscgA1uMTzkwauPPA\n", + "GgMkbgIwQcbQf8lxwiAZZD9oAQCc0pSW6AD/EgK+fwPwBJkqrPADwQyYnhK5QlVk2QCAAEAMAwSQ\n", + "CAARjTIAD4BWohwxf+D7lA3PVZAAsAAQB+4Q0GZFpcDpyrFRB1LNiaO5zAhBwM57AAEBCygACC2A\n", + "AIFd5wYcQkIQACO98s+EhDMJVeD/REAbIApYSVdM+rwYcNG/8fwQcABAABABAoGhVXhlw1BAQsG7\n", + "onv4NA7gAAAACmHgA4AHHIDrwbwAAAAOYQb4AOABxyA68GR/OskAAAGEYQNuADgAccgOvC8CCC0O\n", + "YACMIoUpaDxBQbQ4cFDv4eMETVyGqMhaZ7VGETMggBMY/ACuZjE7Sar3ACxCLRDY6RXEvgYAWYE0\n", + "VhvwRwangrC6XoCmD+xyGAPxBQEPi3VDDQvPXkAWFcoIWTRd4XrIFvF0hGBQIKWm2TcLBAACBGAA\n", + "IA4BgSCAAEB4AAQBAHjuB7JsDMQB1CZhgeE/x/eLUMgbrHmFhf/68NQag5C/5iYdqeIOUaP6swr4\n", + "BgJzwcbLppokhD8ZO7wMSEQnDVpUd45//oYEgE4V3AWH1YilIw7eQVgMPOSqbJWh/Ez0wrSef/LC\n", + "wdC3gY3CKSJeQUYELttvJ/OvuACAPrYBSk6+WAk9zAP//vBilWOT+Wq6Iz/Sv2fAzHDmcAbWtxJH\n", + "WhEf77oL00UsJBU6jKNbDSMFuPZAPv+MW2mBAAEAgCRkIAAQPQABAhAFBrkK19fGYAJAObDwsSHK\n", + "7EBEkAP799nnJmCrY///z+PDBGqU+yXAAF7AZDgMkAAAApFhAUeADgAccgOvCwnzfw/4cwAEYABH\n", + "EKH8KQRmSHWoTF+YCmVMgA4Ag5vkTymEHiUVEu/JIAAQH8wU08IHvtNGPIQLbhKAAgLABwJWC3gi\n", + "6dTkDRqEiT0YlZSGCAA+QMDmLQPOIMhHpl14EciA6NDJ4VuRsSwRhULfPAxWAUNYdT5EK8uIwj6Q\n", + "AKSIAATYADqBSqhOW+wABErHNPGAACAiAAICoAGgimaWABgkhefA3JarIAtv7hBOK5RMA8PwXwH5\n", + "b3gBg6HHkgOlafogvnjdx5gPQAoXLgJ+ktEWEAJoQAB8B0pwcw1HibDUxOY4PA4xCoJJRQU4t+vy\n", + "oAEBAEVkwBoqC6foPghAr41Tmto9b0n/9YYYP5/gWwJ4IIADhBWQ5Pe3BuyDT+sgDGFr1QgKfsA8\n", + "/v3sEHBfaaGcMDKFYLlALuIYanBM14g8BtZCqgALxAKCDl7DZGZLCO+AQVwohov6PRJWyTqQJQAk\n", + "JgDJwAEAcqVmYAJ64ghCXtCWa6L72DqZxgKjEgTtKWEwLi+C27w8gKog8FsIcFVMvAAQ8PGHUQgf\n", + "iMnjCgg0hCOG3fnbiYXoe78EAAIA4AAgAODQgACIAKAddMCdMMoxUoGOkQs/YAA0H7fRBnMPjQAl\n", + "hYHNmGMFDLp95YABgQg4kSdpI9i2gAPEOK1CGsFQXS9ng0A2znESM+T4dQ22KB8FqDk6naIEFxym\n", + "PzWUCTO/3BwlKA4UtzZQEPlYC//uXh3hU+815Ite4SIxhTqWASQSQAZGvtBuU8KWKAuiW2+tQ6YP\n", + "vibzkqRj/7f4SbIeQqKmCASg54MC/TAgXSCBcmUnk1IL+OwA257T85wPofLMTA54zZayLU0Q8Ihf\n", + "Jk4WOJ/3vJAAAAZAYQGzgA4AHHIDrzQ/DHgAFEMwBTlgEZFZ5my2AodoLb/Nklp4vYBB4ZT9XcBQ\n", + "QC24Qy6KouhAAGADiSQQAAgXgACBoAOARwAdKcqkEr2nAH4DVDQCIPD4DabABLADcgCEDTOSBb4A\n", + "sgDAGILCchlCVDKScnXHMNwHmTlgh9785CyBlWUIoo1pYAV//cCIgA6IYWePEKnW9/4IAAQAADBJ\n", + "MIAAQRwABArAA4C3sMKK4fzBlwh+/v9DUME5ScGuiE74AlXn944T8BMgpBBuABWOC8OhYSiL/3jA\n", + "xiSiYFQtufRil/wAEMlADIXwlVMiP8EwJDTiPzGQosoUk9wAZQuFPpgRIowZgDv/vYu4RbCztKGs\n", + "EFwABDfwgACaoADcAAIDoxMuuDU8EAAgQcdCAALAAKNGABjZT5/1zlGFS41XDvMUCB/choUrsIHE\n", + "B3l6mOpAAGJ3wAS+rSPl+/U57L1M7/AyGMztSPVeOWIkTh0wMavEQbB2opNLAQQEBBkbAARAEYTg\n", + "Bbc4YsAONfwyh8GAnlljFrEiYKuW6Uv3AGuU4cEEtPo2eqJ/rAABAFBkNFsCptSSfjXveAXaGMLQ\n", + "NmEaKyOIq4NWpZQ8g70wK2g9+8MAoTrr9hW+XGXEynz8ABGAQNGi/Ka2BBeK2bw78MDAGFW2KwM6\n", + "08D/cPP//4CAoqxeBOOqCG70zBz5PymvRlGOtHC1ddXcp3gAihNKdTR0yrBmIO/+sAUAAEA6hUrF\n", + "pAATmAWjKAAEAaZKYHooAAQBgALV2DCsQQAAgIgACBcAL4EAAIEGAAEBYAvS2BV3AZNGrBnXaOxw\n", + "jG1EAEgWrf9hYDRAEUKsioK0n/aYdPKp8Yc0BNXYhjPDFhGDVMqeJttFYYMMXxGCewNki0MKGPb+\n", + "M+69FE1RUt+kBhBF3SH9WdhQ4W70+mmnT/B6wXEYQ+6MFtRzf3+BB+XpQGXJdMAvEHKuZwwAABEr\n", + "gDOgACAhZAABBbAAECu84IAE5DBAACAoABgEi89FaO/2Dsz0PIKJqXkt9aE1o1r9g+NYBccTkmm0\n", + "tkNMwxKlwrgCg1wzEieemVSe3qHgHFXgkmqr1gACBRe4FRzB/1zDY4aXVulv/gpDmkFX67eDCAAK\n", + "gMaOCAAECAAAQHwCAbB1pi7FzFOZKCcgfCR3hT75/gZQCLqIJ4uS228aGgcaxF8a1bCPmY11+/8i\n", + "DPxABLQ4ii+6Ib0EdD3xAICOQYQNxHhkmIx3hhhAAGQcSuEAAIEwAAgGAHBjDbJhiSoauL83f/QV\n", + "EYagcdwXBgoBMmPv+OP5p4gWcWxX9oADA4RvDPN5MePhQn8AQhNJgKVgknQlUX94wAkgcSM7Uy5V\n", + "NPN2/kBgvwhoJCKQUT4CClNHgCIXgPcpRDB3Gmz/CQADAA5tOH8mD2gwXg0//ZAACwoT1QopSouJ\n", + "8f8AEIF7aSV+z7xgIISPhwAAQKwKBMAGg18oAQPwrABAACAOEAAVACIcBOkCLQnzevQY/aIh6w4a\n", + "fGr6TfgFCOJD4hCZsRNVTGZ1RkK7xwAt/+AuQY7vws5JAvyTOkDsPWAEaaBSwKHj/o75pvh6u+C1\n", + "wCLHsOYXjetphJRY72Sv77gSKVRUETqWsif+9gBA857ngVkiw3p4E+AAygPkqAoohKnWPgI74xLI\n", + "pBDFbxxHGyITu4hNZJBLhwACAAhuuHckDmgwXQ0//cAQj4TAUrBJOhKov7xBgDhMCJUEo9VrF4di\n", + "sg8hg3iSR10eM1RAEbNn/7QsIAUuyViHN4xonJ7uMAAQAQvP8kNPAHVjMyoAabkE4Q9i3NkxwABK\n", + "YAAg//eAAQNsoHN+4iCaKJXH34ILeLeGxCN7ympDWFPAw8Q6xKKdXY2aD3/+CAAEA4AAQPQBZwIA\n", + "AQOwCAACAkCukhiZGhetVsas/tGiEuQScQsCIPUER1AFxRAeK60sIIq3CUYfC4lo73aZAwF6YkIX\n", + "9XMX/2Ngzwc3QmiOTe7QFTgHkWgU0Fb1RvCcYz4oOx6CmNODl8SCILTAABARAAEBQADQABAJlgFs\n", + "MJBpoUSiIpmYxef9gTarCvJOz/9+HoJJSVFuqW/t6aXAphAExjBAACAKAKFk6gn8OJwzHs9hn/7u\n", + "/QwDIcCNEE3QR9OenqvRkgAAApphAIfgA4AHHIDrwqJ8T6EBsCuCcbAAfA6AqlnyF4mEdlu3//84\n", + "AggJvOiYiKo+5RvnmyEAiQZiw1+zWK77zDXjpSaXbwtUi2zgBUaXWefYRCIKX7QIHQ4Se1JpEG5F\n", + "Rz/XsDF8Gdlurxl/oaKh7wAhNz8lKRoXQ8VgBv/gHeNBywXMTSViUlS2D/wGwS68UMo4ppmxBgl8\n", + "QFUgMAZrlNMA4OKQz28zDvHSv133qANAPAPfs8KTNj8kB+HATwgABBCAAEB4AAQJCgAGEAfYViiF\n", + "9z6IAJGAcSrJoA4VHc1/RDaniwiGxAwp6LZX/sAB+yAIIsL8PuPwwQvrjhAqcTyklPHhGfLLozSA\n", + "AwqgW5wOL96wQlwt0eABAA+HFJWKYiFhFv+pahoQ5TE1e4CYMQ8kTpF4iVAITAN/2du9c2evQgAC\n", + "BHbAABArAAEAOAE/c8IhAB2ZCD/AacoLAhLLgABKXgc6CwztNNetPBAqCmhABET+ggjJMVCuWGQM\n", + "EX+D0Lk9KdA/br6fvwZo7DYxjmJ+g+E4HfnIDMz0khhk/m+kP9Bz/GBAACABIS5U+RSGaC67XeBh\n", + "h9cXjAc3hoiUpP6CcAD8AQAUr1Hh5B4IeHbf4EABHc8IAESr8CGAyAnea/iynNCu6AFYQJeDcrRf\n", + "YCsQQkXuxBidiLbG/EGUEOMJBJlZ0LJHe0wI4eMPsN+AB4QM5HFZZH677CXeEI4LxSdPwdxqAj/w\n", + "A2HkpBh8CdS/RP3hipkklpsgAsVjxhGhQDDAEMNyGjVkv7UU6m6x4EEgTJZChdQoJxJ1iQIAAQAw\n", + "DgLGwgACQYAwKaBI0KcBEKwWYNht35wcD5nAEeDnfP1gD6AMAw/Av6gRgEjfohkoHHiking3Ihan\n", + "LyQAAAHIYQCi4AOABxyA68Lm/h/w5gAOAxFBy87imhBNwchkFH6YAAICwAKLOJkAGhgalgoud6GS\n", + "TxpzN/4AYM7XiUMYdRlwWX/wQkCOEACJdQAU1hF8BEl0EHOTYIPlner0AC7DESge1q4R8cWkCMoz\n", + "QuhUXmsFIRwt5doAAQJtLrQABCjsAAQeeDDKo0ABOHkUDuuHkyxYRCW95jA1AjeRKLlTIoiZqeGB\n", + "DvKJBzN+zB1VUGP+8OhF8UUfVLAhsSYsQgACAQe+EAAIAwA0RmAFz4xQqS0kHghROASUYSGLlc/n\n", + "mZgCDB2SbAooZIA8DKiBhc64qXkmbw0b+H8EHMyNlTIASwgaWogLWLnokzxffMiGV0EZiSUsYn5G\n", + "DEKzTzQgT6y1eMxAWIQABQFiYMbSMXuKUGb6RnIReWyJMZRj2YkZ4yQldGFWURrT5sI9z/huWaGA\n", + "WUqYYBR3lgJdAAoDHC4hmErLDL+cECX6xhud4JLvgCA3//3H1Q2rhvIJf6cv2zJ4kAGBib1hQDD3\n", + "0lyIyGAAIAQMthAACCCAAcOh2ykJXIF5phgenEyQi8Ipwx1fwxMK1J7ihoh2mfvw9AJQVxKTxXhV\n", + "KxNzheSAAAAAVGEAveADgAccgOvC+BKw7gAIAYcsssSyymmmyyyyyAA8CRAzAEqLUSaB8a1OMzGV\n", + "1FbqSUtaGGH/8DjmEFmYAGATOoxvwH8AB9mZhDO27IMOUGHAqwAAAAph4APAB5yA68G8AAAAfmEG\n", + "+ADwAecgOvBmbjjYFD0G+AEGAAICNloAAgtQAAIFZ3gEsKg0EsC1ywgpZqP73+AA80wwFPycBJs6\n", + "TI94wRRSCVCVsoEVGmVggARQggEAAIBQAYADQKgAguHNLxj6PGEUNDgNxngAU2QkA3pvlAWEqQ7R\n", + "rEEWYSEAR5HeSAAAARphA24APAB5yA68LifE8NIOoQKC+AAlmUyFVhymYvnQc4b8eUSSIXvgrATw\n", + "nhSlTpxQARKxTwDHR7PcmAk5kDz//QIAAQCgA4SQCAAEFcAAQOgADgF4AHfFqeIWkhiDY2GhVeXQ\n", + "B40Ji5+oAfIm8AAQAcAUkWYeAAWfYejdmJ5yalm5v5wCJo0ht1IrOvgAAgEBvUBpI0ijMWWe8PHf\n", + "/X7ezbbDGqBqqeEFrTzG6V45ddTYAAga4AQSkjZHXWigFiEJb/ttmZjBBFZzUAAEEv4YAAICIAAg\n", + "KAAaAAIBKZ6qmqoEAAIB4AOU4IAAQSgABAuAB4PgSkxizKUIERYTf79FQKngRGYSeceBmTMJ+b+Q\n", + "4w9kJebyxgg9DJAAAAIdYQFHgA8AHnIDrwvOGQvAAhAAG/rgBhBsTjTNFfBKCBVOJZehjJQAHwE8\n", + "HzxAxoRFciElOJNT7vAEUMGo0aUSABKaZXQBW8DSgQg1w06PSZxYx+AkAA0BxAABAeAAEAMwAfAM\n", + "6kEMn/EH90FjEILF0+e8XcOQAHgziOqBZedQLeH7bwZhDS084CrtATrNCOikGBgLcAqF07EJ8ONU\n", + "IX7wQBuDS2u/PJDB41WITXRAHygKUedAKoS2BL1xEJDQWhZMd1JTIXfvAfAW5utJR5Xpdlm4XpiE\n", + "GZB/u74PGLwLdiOL1aFNf/3CQgfpu7CBSNsJW//wgABkDwgABAFAOAsb1l3DBX8wwUuErwPBuAIo\n", + "5L6AJ2Fb/8/TwPRQECouAEfAHPcD0GCg8igSOJqCxE+Ekx3ho3w/xBhzG1EABCQOCXdvN/Dj4kyZ\n", + "Nx6ABheSt6W8GOSgen8z6M0iPpz8DDWdglK5VgyeoVElOgBGCEEyF9UH1vmw1fBAAEQgpsCScEIa\n", + "5mW84nf/+UDKBApeoFbg/FYk+4sCiohykfIf+gkgQ4tUiIMECe2TCwB+/2G4fBMHWTHQePNeNLo/\n", + "gQPyFuxGZVKrKKkPxsRUm7oiK1cCQAE1KAMEcjCq1SfH/9zNx/8SjQg+uyCBUCAAKAjyQgACYcCB\n", + "DMoMXEWpCv33doj0OkyAITCCfV3gA6RAaXOFz6vMvx88AIZR4EuBv7XkgAAAA59hAbOADwAecgOv\n", + "NBAwxKcAeZOWAAZyZMjTI2TMAAKg5r5YQ+35w4bxp+9wGAABAApXOACjxphW7MWBowABAFsAcswI\n", + "Bk5V4uAAWAQBFWwIAAQAwAgUZxuQAUzahbiQe0sARPuUHAMjCFMXp73AuoYXMEBPwFeC0b4AFsGx\n", + "xtahBSRyb/5AAsAhdKQgGDlGUWU4AF/f4BR4xcQ4Phykjrv/vBcI+A1S4USYwMxeQBfgKAYRDyss\n", + "f2bBSJgHf/2mzD9OU5Sj7SAAEAPDhCtVV3dknQZ+7wheBNXdkbbC6CEzAmReIACAKk0wwBwqqh79\n", + "vitQS4ABseokwAaYQBwCAAEB4AO08IAAQKQABAIJOAAexk3yK6O5EoRMeYUkI6a3/tYEwsxD/FQX\n", + "aH9qQYsMSOy/5sdfv+OIEAOGNBzSVB2WjJEwCL/wJBTWa4waAE/SvnyS2cAZYC2BthbgAAhzm5gs\n", + "W+hfC8Kr7tBlKeFLFAXRbbfXEIphT3wGGhdOUkYr4PwiAwu72fICqjUcb65r4i8SVYi3psN0L9Ag\n", + "AEKNfCAAEAAAhxmAPhfuI/z/DSv4Hhju/p8O0lf+v1gcAe5BdrMNE2hgDgkjMGinKbxKkwr0jQlu\n", + "yrsnwwAA6QIbLf8QMFcT7wjrj6hY75wDGEWvw8TQGWxuGFYJQMMIEjkCAALAKcNJ+tHE20BkBFr9\n", + "35E7uYlHZMsQnAQ2PoMMIH+HQLQ2A4jdZbwBCk1vD9noCf7Zz8gACkJBYV4NFJqZVqL9xAACASAF\n", + "BdqJs6GF1LgOCU8oQEbO48A8Pa7RolekkRKIqJL//5oAAQDRRV7CD1GwY4Owg/7BHgYAwqq4pAm3\n", + "I372frfAf//PQSwAgAXz80So38pYL/8BwLYhM3k5kU6ZqctfCBGg9dmTtKgWXfFFoEYfBBBuP3qa\n", + "Z4BdhvOAx/4IAAsKEfDAAEEcAAQSQfBqyRIgOW/n/pthFRmSgBUg55+b/rOwlZoKFdFDLN7/1ABY\n", + "ZjdB5kkAekBIICwJgRagwXKTyvAtzgP2BDipxmYfOkLaDDhPc1IcSqfC9I9JjAn8CQPYbg4CL67j\n", + "v8AUAAIAAoriEUxHNZ/ueZ6vg1J+cBAQ8CKcPERr8soPq7uD0IdsSUYLNM/QE0gAyaa9aeCAALAw\n", + "A8PhAACA2AAcAAQDgCmkg8Lfr6wIuKK3/fZQUJm2+AAEBH/n6MNjIJzrPBMgmkd/Axcr2pBqVuiS\n", + "9YEgZIAAAAItYQCH4APAB5yA68LoLgoYLAvABeu5Vmj/e7gBiGpmpiJ4MImhfgMy25Se1/nGoAgp\n", + "JCQJPQqcaCP9vHhhBBGEdrn1y5Ek8i+ERQhEUxFCm1VVyIMAAbASGCABAPAStXzgKjEN+oIaPIUR\n", + "iR+AZEZyCoaHiyCXtOALmQndJ4BlhpOpgEB/4WFjwMYZFQOcBQbZ4KipUEBiBWFvACGy4UJfQY+Z\n", + "6sj/1mINsJpc9+n/p99sutdaQwUbPgZ5M0SY+gdPKgACQDBUGpjw1gA28g8YdXXZJixFO06E6N/5\n", + "tNaG+cAFAG72D5i/+CAAIhSCAgAIz2wE0CT8p03sHZw0QNZBZHV/nvtNYP/GFm/fQdDgSnKHI9/e\n", + "f/hqcWF/mBuzsIlAnaaloXAMUeziyQAWj2+yAvbaAIQjC8BbkkCYWOMxnJugAouDQokpUlzgQEkn\n", + "+GIxGOdNB7W/BAAEQhx4QkAAYDb4JCsD66vxA8hP1DaXdoDNoKoIo7GqBkDJH9tAmwhd4qllNJUL\n", + "dMCOHj/hv4AGcahKrSrlbkLRqnrQAAgAko55DgWJX8pn/7hgDHNLbC0PKsoMIf/7gITdVxXg2l0p\n", + "gB4HXvzcD+vQGEzW4IIgfhxgztkrNc+V/uAY0ObgCl06TfP9V//eEc7GIAgeVL3oGWGKUIAAQCQA\n", + "BAVBtQgAmCv4PursQGrylBFBUPbAEoOExhGVEIlXv0KhKnBvqwm+m677LZCELnCQN//7d5IAAAEh\n", + "YQCi4APAB5yA68L2JC8ACVhaniPSQj9wwEOVaKJSANiy8ACPsHwgiFUAX5HjWZwZlYM744AyA3eW\n", + "vm+xgIM/GIlOdiLTAmvFrBAAFQQ84IAAQKAABANAEBmADMogQShdUj50Jlw7jF/q9AA6W6OKLL1D\n", + "lxKFShXxDQtZ//9eFs6UAKADg4BIfH5vEQGM0s8UgTAojSLVYO+GKgSljrn1RJx+1q//uIOg8EBU\n", + "CQnIxGK58//egM8AaBi62YI11kAjkAGD8kaqLTEhcIJoZHgH++C4INmga/92kt6g0MFaQz+8EAAQ\n", + "CHHBAACBiAAICoGi8hAUOuAE0AZ4Id0hAXrkJKiMiv4yRnADA4I8mGYwJUEPTIBC0hi3N8FJZPDQ\n", + "jxH5IAAAAIdhAL3gA8AHnIDrwwaLB5h/GwAigACAlLKAAICoAFQBEfvEDKIQQ8SvlAgoyypnuGAL\n", + "TpgL4AduAYABDD/w+gDQ+hu4QdB4IWFLlhGNQzVf3hhABMAQcEAAIBYAcADQKgDKUNTgPxgYFRgp\n", + "5cMdR4AKEtQVZhAQBDkcGBGZiUD+i+WBYTpDAqwAAAAKYeAEAAgcgOvBvAAAAYthBvgBAAIHIDrw\n", + "vw5gAYXkrelvgYSzsPI8NYMnqFRJSgI8Akf6L/dwAQ63T6TtxsADCLiUx1k4YvgXBAuccfGYEGzw\n", + "GgX//3CICADmchATcVXPARmP/8yjKFvyv3BDZZRFocM1PBIAAQ194gAPGHKA5MPKYc5RCUxTIAAE\n", + "CoAAQpQABB9ZcBuZQBAySPkQfkPRKzwGXhwgAIwLNhAAFAgHioAPk8A8GzRFf4DsawMTLdrDz+vA\n", + "B8jwAeAneEX/gPBk8AwmWV7h7+eGliCBzAAbAzhroSlTbKSXN74ztNZ6vBCRGEAAQCkkfgAaq5jY\n", + "5o4h+AA8aAN2UgGPDCd2juKEhbhgAJg0UIvijaKF78p3gjjS1pVLkWs2otHoAAQg2l42AGBSaxha\n", + "qcUcAsL+CAHJhJKZDtbCK/ASP/gWdwU08G2JkShkhmIQAAgIAAQB4+EAAIM4AAglgACB0ACQRghP\n", + "4QUj1+/ZQGtJqAxJgeJveBBNBji1sTu6cE9A+AH6MKSUKnWAq+Nw0KAZIAAAAYlhA24AQACByA68\n", + "L8OeAAmRDK6GMhR0qUlf4ARP8r1+8LQAKQAGAUbi10dDDYgDQFv/9ggwDlyggBqOggDkX3+7ezM4\n", + "JIB9L884A+L5pT4AYY8V8TaySrk5+UsRruADCIeVlj+zYKRMA7/+4YDEJKJSJj2fcDL/+8QAvw5Q\n", + "Pd/RB0mABKoBHwe0JgKCOohBOoavcIAAIEIAAgCxAABAXAAcgAsqaGBPImpXrBgLGCgTGedIqVUU\n", + "QwA4HAgq7hHaDB8y+FeLYxP5M0J+Bho3wh/oOfkYMQrNPNCBfrLUkbw+ABheSt6WAJCBZ2gCMaMS\n", + "tn34DMAdLxkkG042HNt8wdPQbsAAF+oAgPuQjaCCiyCHaOMiBkl5Lf/zTmALI6YABbcAYABDj/w+\n", + "ADQ+hu0QdB4IWFLlhFMzVf3vAbgBRzMseK4BBhAOFUyhgYAAsYAgQBAAcBID9GGjjTRpoNqceAAL\n", + "aDRoLxwigi4/vsEAxcHA+mQk6C6gOIIGAAIAcsC5sgAw7trAHiPL4MkAAAHhYQFHgBAAIHIDrwu8\n", + "MoL4ADxhVUA3tOkbJ1a8OAUIfhRw/RFGIlfeACByVOITlFgXsQePf+8wAYFDbKfRYHFVxYFAK4IA\n", + "AmGQkISAAQHgAPlDVcxuwXWJ4DhrHiDvpwQIAPYpVGPuoEF6CmmhMHJSQGa7CALQtGSCALGCSYTU\n", + "mAHyBArNl/eDF60FyzSgqqwXVCjwGiEKDLQ5LwAbJQGu8BgYtxo5LqkwYGkNf/eYZgzUCTD9GykJ\n", + "BJZ4BXQA/eEoKa9qPgDPDYjswLBCgUqaRX8EBQAw4IAA8AGAGhG8AAOLdxANx7sTXc4MosN46E00\n", + "JUj0OhsGEazWDxaLf/quqEbXDHLFBMHOjABFQw/9YMNG+FfwNBD9sAAQATABTzzZgwD7jJMTePzA\n", + "hTNnRSrKirgAJZiio3WHKZiw/4vkpm0n6mjSG3Uis6hAEphwgAC4IedCZ5bDBCxH/bAAZFuSs2kz\n", + "zTQ2pwJNuHELktbadfYEz9gwJhb4BcgCghvNCKSz1TrAAAg++AwdLFhbbKkJm2wiainTYRB0HCCz\n", + "LIL5l+3gBlLgC1CUwwfxts/4ba/fN+EAAIBYAcGnwgADAEDCmgP9AqVFJM8oW2+89KS+sAxSyzQT\n", + "HD3juggGzSCXmz3kgAAAA11hAbOAEAAgcgOvMX/CE8MZSCAAhnKh8QMQAvYY4Jicexn35//UpBYI\n", + "cWAAIEgAAgGwLGj+sCwDR2kMStlnggAiNaEAAIA4AcONYAIIvNFgALgQW/GMFEUaT9gAON2EV3OW\n", + "TwAbwETCzhfIGSWTpG39G9Kggbjdw/hHYAFaDnCJ4kwkkUvdBFIeELVATRbTfXgABSsB+KFNp2et\n", + "75vqOkrfFIE1gd/uuGlCPpoZOr1dZEgbI0DiYJn+/qDAUuB6GXxf1nwm+LCv/8AEBwABARtkAAEF\n", + "oAAQKzeDNhAAHgAfCwgABAXAAMBB8AB0HZDF9YWokjCAJK2EtQvDbu/gwJ8KOTpQpFBNUCJsZvI6\n", + "khlLAkKj5D9CVln5AkwLC4JAsHQt0ID0XQBEPHQg4FxRCQaeOEABpCBK1da0TfPAABABQ6Cicxjl\n", + "sy5KwAFODegKEWqWr0EJnLQE33nADCrgV+Lrs3BBHZodU7gCPSweuOGC5//F0cnp8QMM6yC3nmBB\n", + "EIAAuDgkyEAAIAQAwONcE6nCcYoXnj2QxuHqBZzIFhMNeD2X94IJMcA56DQ24CNTfB420xgaGNED\n", + "ST+7xLCFwr8AMfnrzhszMRnEpRldVfdXfQf6tkKFENm8ln19DBWTDRiLRHDTrHhhALlcIAA8BBzA\n", + "VPhoCpNLX8nyZ27d/8IsBszANT4AKcCTi5Pdiub8nfB/PhhA3hAPi6IIQBDQIJz5FfiWXnCrLnof\n", + "QIrizbIOaQW0PwAik4BbhCZYO420f4ADlwPQy+L+WGyN8LmX/8AAgAEQKXk00C2BRglEW1f7LyVv\n", + "S3uDArPWPILkAXvtM8/Bg3nQaY0LYKmpExRKEAAgjCwjAACAcAAsBYarkoLcvLFENAAab4hZS9mL\n", + "LMWmUNQhv2oEsgBDcsYskkQFy25gANGfEFnOpCFljNohQaggn7VhkL4W/4SeJ4hc6YPgABjqFYjy\n", + "2QgV80hwof94AwKRDvONck8Muwu/5AMEKQoFyGpLhc7ekYi+CDBUiqJPzBWXgQjMwrVAACBRIAAI\n", + "U4AAg+MaXBkEOgKYrZuoFxy2P3/4IAAiFc4IAAQPAABAgABYO0xKNLtulHr/tv05jnCRcyK7Zv0s\n", + "OVhy2IXqwU/fpgFgLo15a5IoCHhq3kgAAAHXYQCH4AQACByA68Lm8X/4R2AAh84+hBESlrlIm5Gy\n", + "bwzt5YBRlFLfeltf8zs/sOAA0U44lYslD4mlWJkv2YBWmuyzRAA8i0ypB6EAsMSEAAIAQA41gADF\n", + "a07TalJnQylUHgwlPJnB5OFf8gAMRaycybVQxvI5xdT4MDAod2IFSOGJWZOYKAVBv4BkVgCFAoKz\n", + "zd8pQ0WDzlgBKcAILPjlbB+1emmQGAP4aoSMcRqOAALetDBw7MUBGPrnBQDMJNwQABgCD3wwACAa\n", + "2TE7mCfEqY4EiB3/u8wI0FLX60AbABYg/RASp4+f/eGjfOn0gg5+AYsmT3TDQURjxAJ9ALHAgVZJ\n", + "4mBW1goMfqAoGQOPwgmsQsvt0SZ//25weY4iF55/zwQABgCmGhAAFQRCYGgY0RO/BZUPAr6gLHWJ\n", + "Z7tf4IgcORQSgmTXV+kAAEgHDrk0q4WJPw34WBuHWFRRSMXbmHNiYdA803QwSUNH//1wDCrZBGAx\n", + "2lniRkZvA1Wg6AE13K7NxCSjzNsbq/tV/6GGABZwdpgklIgcKiIzfvfBANAAIBQQAAgUEAAECcL4\n", + "BtSLAdHfJ4UMk4d2a1IcVPV6frGKT/iNdj42BKx/32sAiODtEEvOtvPJAAABoWEAouAEAAgcgOvC\n", + "4dwAEAxh33/+e88/9/zz/wALGJSIThq0qO8c/7/8AB8gYpW4eYAgH+8tBoBIXCC5SQANF9Bo5qUh\n", + "D2JGNGz6N6QANAOs46SDKebcG+FusED+cSBif/vgcRPv/bRAAIwARzA7EOOTKEn/gBMRM4wuNi/8\n", + "AZMGsFhKLtThuczebbX3VjjzoDuoAwCWHG5PDsrq0oP+4xBxMnGBKhQ8XMAViD/4IAAwBIoIAAQG\n", + "QAHAICHeAAJVSgXEQsXtIPDBJ/DubODaPAG+hA2Si0U/oPEgBh4MHeXD7wLUY+8NcNfkZCKymOhR\n", + "krUmGv/em6da/f8LfBADkwkkOiW1sIrwjZAx8CIuBbB81xH9X+Yk/3KAAwCjcWujoYbEAaAt//sE\n", + "GAcuUEANR0EAci+/3b1JQQAAgCyioMAAEAcAjCP/MQqQps6XQ6SFz87Tn/ABBUOK2h/JsFYGAd//\n", + "cIBCEFEIER7LuRl//AQAAIDIABRBOBMNP+74BLJUWeBOQSjS0XNaU1Mv77MGCuGMEUjhgCVzfeMw\n", + "D2oc2f7PJAAAATNhAL3gBAAIHIDrwuX8QTw1gArbRIboRz1egqAASKAD6oBVDqPHAiNFCAAJhiyo\n", + "AL8oeYX8oge/AAmCIFmDniTCifxOHxwW8IxGoDkhK2HKBKo1/+8I4ANAoiqXedqWEcIpfY8oReFH\n", + "4UNhtQAT4GVABFSwo8eI1O97/xiZuWb7+/O/CAAECUAAQCQDQuEAAISwAAg9AACCAADGjjD1ZRRE\n", + "vTF0HvvRAAG4EeWPwkC+oh4l5BmY0qu88N8LQAK0HGKEt5jxSK+0EQp6UkUBNFNt9cAACAJaGXly\n", + "rGI5wAAgV//uAUdwH/W1w6zhUb/7QAuKF9nDdhSbOoxv7QAg217hstN6mbH+v8IAAiFAWNgQBIAA\n", + "4BLFRUQXyDsAx8PQRkUEqTPZ/gm77xLbHiLZHcj7JwdQAAAACmHgBEAInIDrwbwAAAElYQb4ARAC\n", + "JyA68LxM9f4cYGZofgBaSM8i2vvaU1AmArgGbxxAHZnAfByPn/bYAIffWBUiDo+C4+P/vBgq4W/T\n", + "kPNAUQCE2XADCEhHYG3gD7K9EC6rp/7wGd2BxgGyWajilc2KFvg3KChwi3WMN8k1me5av30/3DhA\n", + "AEg2YEAAIMIAAgigACBYAFAAjYCoWcEw/IMDaWsE/YxJ/14ARuACoPaAmX/A+QAxamjhfdA/Ufkx\n", + "EGGhC5fQRwqG8NwAKgEgcwGvjeDzb5VW797ZB8DBc1KKmxTVZB2gADk3OAAYyi2AAEsbEEo8wjvT\n", + "UgACBB/gQAAgMgAFAUNBAACEcAAIOQAAgagBu4TycAMShoRwKwWL9nr27RgBz5wunEnmAHFwSBEp\n", + "HkgAAAHqYQNuAEQAicgOvC4dwAECOYxzHMcxzHOY/wAMQABv64AYUdE40zaH/oBMAGRvuuz8ADLn\n", + "PnWoeKEBbYZ+E3Z0QUm5fcEMg5wWtJBZIbK5T3gEkFSH5IF33g56VYGA58E0UrAAYvYZ4CgIcAe8\n", + "BEQBe2wk4CGfKgSFnuEQeKRCqITZpwAAhc/9oCeAYWXI1sqkHwS5H//xgg6rlg9sDSOzknA9BAAC\n", + "ACAUACgIBAACB4AAIEQAAgsgAf1PDgbO9PhxuDgwPO6mWh1uwcP4sgeEtiYISAsIYB8PgFFQPMBQ\n", + "MfvmYYaN//SsOeAAhjUDovsXdI7O4GAqKPBkAY02NW9X6Dr8oCYDBSk8SFGg23sVCJRAoAAgFCEg\n", + "GNABwaoMh5uuKOQMyzUMwdE+c0ADrARJTg7TB2F2yArE4VS+aKronprswXT2Zl+G4wwABARtAAEB\n", + "QADwSHP53jCIFJJC2GOJvjRbw+8MM4XMvhBaBAmYCrPXyJATaDEHhaHMFW/ADYBX6F1Kdc+qucWN\n", + "2B4KbxobhGh8u54AAYNQm/k0XXB3C6O7nxD4OPlaEkSeSgP6cBAAGDgA/hAACAcAAIBXLnIgaQAQ\n", + "AYzz9+hCtZiUtowbXR19/BswuilF0q4H04I8wdDAIHrEeKJFl755IAAAAZVhAUeAEQAicgOvC5v4\n", + "fDgswALAgwLrfI/MqymIAbBfvQBDQgDGoWsAouFZ/C2oqCAAIBSCQgAEZ7oAfs8Qfgy96/AA4XCQ\n", + "NawX0FK3KF/37BcIPC3DAAgMwJ+0rkHyVQA/9/cAQroTIWpFJOhOgv7gMwkJpLzQ0LdFZIAj/8GC\n", + "KABwaWsFxRuPco8IAAQDwAcHnQgABAWAAIAoc1idEUTKNRIkIvg29ZuQuX8AN9VAQKXdweB3MvGg\n", + "fKpJEpEkQYaN8TPx8OQAaog9REqSm+Ag2gkh+SlNC/ACAh+KduG1pgTHjgT4EEUQojIOkJi2XR/7\n", + "RAmMNjEILSPVf/OBcREJWZhy1j7u/vDCAAjhBEChKABegXEnRsVrWKZf0DWMtLe94U2bQBvfnUWR\n", + "kvW5v82r8Nw9yiD1ESpKb4CDaCSH5KU0L94Ah+KdeH1pgTHjgR4QCGcQUrWWS2wl3/7xARDCMxJC\n", + "O0sseZ0Ah2OiekYvlBWP+BAAHgYauE5VRppbG3/rf6AY942YGbSrZXb7wbjDd6ns7yQAAAMSYQGz\n", + "gBEAInIDrzG//7wXcAMGqoAARKzsDA+AAICIAAgKTFAAaCDYEAASHLcEAAIDIABAEDPACrCTKoB8\n", + "qvcAFYLg7UkFSAAhPzeG+AIznwtKIIUMDHhYWAAd+BqUBjUKQAW+IT+FQJQwhAAFAQ00IAAQHwAB\n", + "ADAcPYIXHh0Tkgi71+BEA2KJSIGULrtAO7BhBghgmheAAkBEM6uAeaPBMakgJcGRFWAnyrjbErbx\n", + "DYhdP0oFUMXc8aEA7284GKLn/lHEw/AFgo/rq1FO0AKUAj8pQABMAAQG1gAdkjKHN5bAwgADYGNM\n", + "CAAKAv9AA/HntZTAjTiu0C0Tp9qcReJaAB9fpIw7IfQFhkFlixDfmCM1VtoP9EDAT4KBvhjW1D0l\n", + "+3AQJzKdRYyNm7kS//cQAxhJWtOaVPWAUKQMf/2gF2grR8Hss/MIft4wxvEdBhBjog/NQb5InAgG\n", + "FsLEqJ2Dakdwor5gYGYAAIAwAOCiaZWMYcjqvfeYCcrpmEBIUoQAB8AsRgAMeobrwyEbl7fcHRkz\n", + "TglA+q+v6IPSfpQJ4U6HSGAU2kLE9PQR4k3kEf9AsgEQTYAAgFiMxoSECnxt4wiBSSQthjir40W7\n", + "PAwwgARGsCAAEAoAOCjcYhmQIBsM/B08onsJCwftOf8M/AyqQFHPhOirydgCVKDD4AxWtHd6ePdS\n", + "Gch+/iKGGEACK1oQAAgFABgUaz7PBGUKE1+7/6ISZROC4EUhIRUH3/CBvQf4QQcgSAEAJTCx+cEl\n", + "lDZ9I2IPgAOIWkwjTVJWdw5//vCGdBlJami0GKJ/0MIATWBAACAAAUc/BHgb30OLoQi90BcXyFZ1\n", + "R2RSeUEDEVhQQg8IblaSWWzgpC0AHzAJQE/QzaDiLmyjgIFwCqgMHECMVpEg3ekAu/7SWCwAKr/k\n", + "A0CtoCx/eAzAEUAjpzNiZUnIaxLNAwdgpdhyFeiommjN39LaNOEwl3AhiAACAqAAsICQAAQJAAI1\n", + "wXITdCBCwFXf34YzFcrMYOWB+93yAIsNiJGAIyc3gbPcg65wEABVz3kgAAAB3WEAh+AEQAicgOvC\n", + "5v6e0cOcABDYFFEN6XvV0EajoJCT4zITLcIs0RBQi34GK2pb0BDipWpgac+AfFEU9OPbelS6sgww\n", + "gARBDIQABEIOfgAmYtToTOanoMJgIaXfgTe+gAfwyaj8ykus9BhDAEGspPAvN9NFk9Rx8NwAEAgr\n", + "Z7pIFUfBPUqLinyE4zUA5Fbab3AAX5B9qAAwL8qS4sfcYFjHfrIwABABC1gu15LwP++aUhDg9v3j\n", + "4XMU5D33hjLecJSMubWFUC5Si8MIABAonIQABMBwlW0eeC0IpVzL0HekOyUVsr9+0PFkC0OtUpt/\n", + "B5s4O6cKTJ/vDRv/4TQc8ABopxxKxZKHxNKsTJfjMAMClxiDxwA5VltIDvywv4oGjm5og38EAATD\n", + "GGhAACAEAcEmIFR+Vvp/0C2PTMggfpBj/6AsbISKV+hGd+A2r8MQ0OEc1hrtgoYWgAvYRhKohzlK\n", + "M9/AOBdChhX9xfoxxqYA/cGcJ+HlBQv7loQAbh+ABUA7WiGodCEJ3NEJjr4SgO3oYIF4K9JCgGIs\n", + "hAACAgABANFQgABAjAAEAcACAKalxgiHaQItz//+0gYT62d9QAT/338x7jGlhiMNGyBcgHwIZB8Z\n", + "QSv8NFC8VCMGSAAAAYdhAKLgBEAInIDrwub/+EIcwAHAStQH/OWgK868J/94gAYMYtEVo0E6TIUN\n", + "L4ELAPtiraxDoQ6KV7iGETAQ4FCUAF2Kiu5+L0R/1Bwuh0KJa1HIAOybZEmGcgSg0KIlUTUpjXcN\n", + "hb4AMTi8KIcGqPMP9DDDgGoAX1g0JoHbiERZ1wn3gIBe0baFXqiXKIeUQZ/AQxJRqKSO6RNTeH3P\n", + "o6wRgT9mvmjYA7yAt4KgAcRHO0cgPiXSTZ68jBqs/aOvfy8fQQAAgCgCgAkGQgACIUAoJWA1PaYo\n", + "aRY2t+B1SAsTAdgCWZ9+MIarTpw8KTE2noPgohoADgCRu2KfAVqlgMNmDPzEvw3AFhkFc1Zx6igt\n", + "JthLzCIO97DjnFjU1FETAk/TBmAAPgaAQloKua4JSUL63fPIbIt2IURP+8AAa2lHDKkfID+qrYc/\n", + "sWwADHfqzwAnDIcCAALAylBAAEw4APB8oVgzdbs8DAIrlPVWBAYUZPpsA6fAGC4wwv14GyApxM5U\n", + "ABpdAeSAAAABKGEAveAEQAicgOvC7wIMNYACZZQ07oUkcxYZ0wBibW0Z/8GQQCvASFKB/kkFvmxE\n", + "UGxjRQbxgj1ru+EUAiAAeBD0CIrJEib2iP//8QNmDhrm06fC30BZS2BM2t+eDA4QAAgNAACAAAoa\n", + "CAAEJkAAQfQABA/ABnWHSzkHWE9Ji27+BeAoAFgASjG4F/cYBboTG/sB1WL9WGzVQG+IYAh8ABBi\n", + "tptKIIUMDHhYWAAd+BnDjrzjcV1YIrSUR7PAw670cqKzw2omAjRdngDFa0I708eGhH5pEGoaOy8l\n", + "b0t4gRRCynDVsplmXnWYzu7tmUvW4D4PYQAAgBgHDSoQAAgnAACBkAAgDAAHpdqYAFQI1p70HkWf\n", + "YARAx62MXqABdg+mVBwv2ponvwdQAAAACmHgBIAJHIDrwbwAAAFuYQb4ASACRyA68MGERcRdx4wx\n", + "sACMKZJyMDGpYd6YAAQEAABAUmJAA4aN4YWr7b4DgIxrpb5gHAACH9j/wAHQUB4ICyaxYRhGHJ5/\n", + "p61Xjn9sICQBBgQAB0BwA8FQA1DuqcB9LBhFAfrcENsd4AJB4Cy1BBKgAIS0GA/GLgyE1ywPCFAY\n", + "alhfAAWEBX3BQcoVE70yxLswACRwAUEBN5ItMiNyBReV/W/0AQw1nYJSuTWLnqExBOBNhACZ0gB2\n", + "cj0Kn6GR76k+gATFBbgi1lY2z+br6fLv+mYTDwSfw398AFv0AJNgqT05h+Geqx2UFlPDMQb8AMoU\n", + "pRhoAQtB+lAfF5M0BgX7YSDJ3ELCyeWvEEAx4dySCHPhC5JH97QgvDnol+FgRlJzIs8Io0G9ZUFh\n", + "3+8HWgQAAgAAMCSoQAAgLAAQNf6i7Twf95YCnw8kUthAR6nP/z8AZ4HIeGEFPuABc2PfqwKWwSBi\n", + "fkk3/eSAAAABiGEDbgBIAJHIDrwub/+MIc8ABI84S9kKeMYv+L5KZtJ/ARQFcKriEuHx+l8KmECi\n", + "YSk4AZ6t6Q6IRIUrGz3AAmjPhEznUhLBgFwYwtAA7GEQtADwpbAABAWAGLB7KDWhLf3sWS/ASIhT\n", + "0pIoCaKbb64AAgfoRwlNcQUcpgQSf3Pg5gqPeY8gWvcMEAAUIhZfxUKawGBoAM7gmoIuhLVUUmcE\n", + "X/wQAAgAAEAaPhFAAICYEdkZShfsvibB4gCRIiOV0OAAICd94AE6BN1ICHBDFvGg7bNhwAIBhjpw\n", + "o88NG+0/9As+DcKWm1PECSGxKmw/eGAXQOqOS5yRMv4IAIrGhAACACAQJIQRNQ1wruaM7f4YJgKh\n", + "IKq4yXaDN+/YKBOFuE6E4ACoidAAEBQAAQUXueDFaWeW0a71cuu66v4OUB+AxzLBtqYTE9zyGHAJ\n", + "H6g//4p4QAAgAgFEshAACBcAAIBwBQQ4/ImwKQ4KoSMhrcoV2vQCGx67WAfc0SDaINn+8F2Qv36K\n", + "U55IAAABbGEBR4ASACRyA68Lm+Kn5vw5AAsZCHpCVQF0U031ysOqQJRJpQNQNYBzH8ERzz3lCF7w\n", + "AB2jy8sU0ra9u/N6cYaTwjt///tmuheUlR/+9/4QABgCjHQlNQAHAByN2zqhgdw57JIpyjNvrcAR\n", + "/W2bD+AsQYhb5nFDXMpSRjlD7Q01smmwegIFQ35GtRd51of/cAIArDgFXG5KgFa98OgCARScAtwh\n", + "MsHcbaP8AQroTIWpFJOhOgv4IAAQAAGDSYSyJlS2Z83n2AjkAP/4gghqPz7w4BKG+3xF4aOvCgWC\n", + "3xgiClluGLYTLsvOM7oZry099wCOgAuIcH2aZ60ADAF/uEgIAc7uULmIsiIPS7/+4PBpQAMEIMKm\n", + "EQIZhh3gEPT0iBqX6tcbyBuomHSGLOIHepURtSln7+oqSSqjAgBOxALAAEAUAUFDmrBYKfCN33gb\n", + "eAiiZsJ0a4e8DaHZQXBWLkt9eBTDgbtWUDhOTyQAAAKxYQGzgBIAJHIDry8OeAM6AAICAAAgJRAA\n", + "GAACAPecEF3YIAAuDHH8AOMyAoK/q4AegnEeD4nBAqsMsMcxesAARK9vKcAeZOWABcYAGigDXwFl\n", + "s2PV70WQIiyhFEmoaWAFQgABAHCByIQAAgrAAKAAeKYgpGAYcrtQMhE71gB9A4tfYfAMVpQCBp2b\n", + "agFSZgYFOkVRcBDIErrg8KG7jmyAAEAMFqCjB+cOq7v/rlbXy9//1ZC9DVKuP++eEOF6ANAMABDM\n", + "cIUvhJdskCGRL/l8AGJZnCH/05YE7jIjJkAgywJBaAA8H6xHPJ60TPBvSnf7oAyLyEv/fQHsy4ZO\n", + "QXEJwQHC0ABBMwu3pYbKP94MCwfDACDAxG8X7/CGBNkv629hqUWUrS5wYgbn6KYVoy+m3ISD//+8\n", + "oL80UsJBVutpU/UaemAAIle45CAAMAYW3yF6F6D8UUFfJWDwtBw7CdSwS7z36c40eeHIAAQgHkuA\n", + "bELEhd4jhrAGCKEJIC2WCQ186LSwG8MISMggACAUgmOKQHhFtvw9AQqwV8uUbfpmwrnYAAgIyAAC\n", + "AkABsQABAHX+v+AjAWAtWOzOCDPYR4gAlDiBPeebanzXgJeDLHggADRQMkIAAQMwCABZB2JMAkCO\n", + "tK1rBa4AhYLaW/3CAgrANTFVtpaHjHpABWoSABo0ESuf+Cierffx/8//0SITSImv/79/4Q4X8ABB\n", + "jTlr474zhM22ugMIFI8gvgT5h+CB518JTQQkJ4KK8NWNHKumU6+PfqnqigBFZIad0FVXuoEI4IAg\n", + "C0AQMHVhQ9VbWUfIcZTD8gGAAcQdS81NAPWanhae21QkIaEMbQEPwAEAAyjFbGqApkTXohHsXgwi\n", + "QIwQAJ1emkcRjcpLfvrqTh5UH7wVcAAj7lCJw2fdTZNBo6N95IAAAAFvYQCH4ASACRyA68LifN/m\n", + "wv8N8AC2DY42tQgpI5V/8AUeETCFm4cpI67/4BQBjKbyLNE1YYY4J//uGAyAVjfsNjTrW+/9dsw/\n", + "RUrSm+5psKLDckKKv//BAARgkiBZIAD0MkJc9wUybBgbMFhMGTWvYrf68Eea9b8BuuyqLw1CQ0L+\n", + "AAgMc4axZrr6yyBk90qABqgbwiIQpQ7vt4BGBpaob5RM8Ov7z3IAQoQF0PLXQJmHMF6L4QfAAECa\n", + "DJN4HgCtYLnAgJSkCAAEEsAAQLgACAEYIvnfzgC5g6wqcoog9p/oAGPcvmavEQY5s6Gy2S0ClYXW\n", + "Gj4WgKXA9DL4v5YbI3wuZf/3hKA7ehggXgr0kKAYizwIBTQ9w+/GBoLCRJJQyvGLgvJAJ2SZNCIR\n", + "N/kEHM7td9+D8IRAvSXOGVSonQnXpQwgADIFEshAAHwHCSeSM6/UDS5irvr31q/36/Fhix95IYoh\n", + "6/77fT15T/dvJAAAAfNhAKLgBIAJHIDrwvIGwvgAOPf+sDvUNMDwnIH/fBexF4HPb6XB2xAM1mgB\n", + "mMHFZwRohOhR//3o6zjGAAQJpGUVB5jpFKcggADIEe4IAAQCgA4tqAD/SQwi5QCQgTkRm6CnDuU/\n", + "/QARASME+cZLSCC0zAYAE5ocfiH/b2MGhb4AOAA4qlqsEOHwFInNgA096ZNifIVHZLBhmn9o/ujj\n", + "IAAhCG714awAbeQJcsMb8oQ8K3sAELwSQWC0Ufn6woZFsbFt+X54DTBsTzAWYCfVu4wXdeRuCUpo\n", + "wqdBAACAIAIEEAgABAPABwBQaowuaRs4cBC/tg8TIRGUgx1DpD9nADKtAvvC+srv/8PrIwsQBspk\n", + "OiNo6DDUqC/4R6WXDV0Gb7wbQHXYhqiKbOCD/74IVhR5TRjvFyy7ri8MImRlwMcXDrHiUQxfzZbH\n", + "5ZrY976/DwcG+AAMHeQZsqAm1d8KAJf9mAGSLJ/X/+60iAEEpQK8JKrmCYWveDcGSdGR2h4xK4EK\n", + "341QNVTjyjAAEDkyLw4Jd4s4TAQMEkT8EJDbN6tY+0xwTCkcYcAUB/AJO9qhqgm5hu4Rrg1VPVUC\n", + "AAEBEACgGhUIAAwBAHD2scPMoVyGzAANP5qM3gAbMzgBdsPBMESzCuOSEAxe/aHdXASm2M+Qf+8k\n", + "AAABdmEAveAEgAkcgOvC+NC+BM3G+Fgl8lNtJnoCYM4S6NKAUD++GQ2X/kZCKymOhRkrUkCiwguU\n", + "kEvj5sgPmhspM9wAHjQ1ZWMcI/VH2QCcWFoAmEati3LBEW1G9EAT8DKFahGCEqLCENTUT8ACHTGR\n", + "uOBWDZgoABP3A0KUzilPsMX/MV/cCZT0FC+1Td4FU8G8FwL3B9hBR0pJe5UkHLwABABQOoIN88Il\n", + "IWQv//xMNQBaS2EAAigGhkI/wQAAgdgACBC94QAAgwAACCIAAkDIGgACAALH3DsGOegn+B49mCoj\n", + "S9BYvP88AD4ZK6s6i5qD+D4wL0B5bwa0PYDIqVgw2Yxw4AHAI/wwGwM0kETLeFLGs7f/69+t3Hee\n", + "MGQUgkKYXwgRGyjh2+Hrvu0wClKmeACcWwlW9zDawGDwHAEKeTLYQABsDsYEAAIFwAAgJAs2DvP3\n", + "gAI3K8dFszAAEAR9e+wsZRK5WABZPg7wbi4ZyCCqAAWp5vB1AAAACmHgBMAJnIDrwbwAAAERYQb4\n", + "ATACZyA68MGEViL+HxsAVA7hzqJflKx2ERXQfAIISllAWte9hNz8VkHhjLecJWMubWFUSxSiMEhp\n", + "LeHDDAAQEKaMWyh5tVZN0l50MITG4QJSqAMqOQJEu/0GZfXI9b8AJPD1wJUruwYFXX1drw0hEEM8\n", + "K5ge6AFiEtY+1Jx+ABcMT3sTSjRCvuv/37BMGcLdAJAG+EgUrqtuAHgBOgFZgAVXuACDRMgnZErn\n", + "AID6BlNLFkcuLPgNAG/gAxZdRBzl8LBnA3GLjohJJiIxIzIBgL4PFcQWgQN6ImigMIAAQCwA4JMh\n", + "AAEgwprCCS5J/gmAEn3jOujdVe/ugAGBTRrknAs1YNywOYKQUzNd/V5IAAAAg2EDbgBMAJnIDrwu\n", + "HcABEZgACAGiKoBAgiRoQIEf/4ADgDtMAVUd0KAXr3ugGKTaJClIJJUJ1eCAAJhiCQD8ACwzDmTJ\n", + "d/PM8KdwEQ1mf8ZS+BAg5hgThvwAx1s7AQcooWJau/8HwOwLE1cHeZcE4MILKW4GCpLWs/1HX7nj\n", + "DQhcQoZIAAAAqGEBR4ATACZyA68LifE8NG//4QXYACYmHaniDlFj+rMJ+DAQ7xzo6jU8LCRGwIQS\n", + "kwhIj4AGMUtkQb5DcACnmk2JjnzDYQBSFoADgACAEDSX0mAbFAXxLJ0G8ACCGwBNrL4gtqVJI+AF\n", + "KcAq5zYUArn/B/QCGamJMDbJpUJi/vHxBhAYcIARSSRCRAA8TBwmnEa6UYNW67bw1oP14AzB6eN+\n", + "q/v/07fnkgAAAYdhAbOAEwAmcgOvK8EPWCmGPAQAACAhMAAIK4AAgW75jwACwAoOMpgAOGpwEPQr\n", + "gDfAEqeiohAvCAALmBlhAACBMAcA8lgBwGZlYrpXgQltAA+Bl2EWWwAe4AEjinuPGLerwEABwWoY\n", + "0ARoE/qhLbjeIAJkIAAICAAFQQ4X8AC4ZEHUlii/KHvf5AUQt/KNMUhp/BL3/QxAWsAB8qY0T9k/\n", + "Lp9i7HjFOQJHobx+5DRAQiYb6GK95ZIm+o6GKnn6AUZ43KoOrlG8Mc/7iDCAE5hAN8OB/miEqmGE\n", + "U779DeYrl+IOvwrgDIMaSzwiJKQioYi19h+TMTM5zhBvtbJO8D4FhknACFgQ3gE/Uj/BhhAAEChE\n", + "hAACAmDAWsDi2yY8ynLeKYGkzFi6D3+CzD1iiVGJFoHOgjA/40A2w/mkNL/DncMILDLJ4AE9XvSn\n", + "pL5JYOOGYARlTWnjiYE1KiWmACAE8OA2GIhGikEZ1ml56vBEiIIKMQYEVOwvO6v+AK5xjWIfCkfz\n", + "+lJAAAAA32EAh+AEwAmcgOvC/DWABbEdRloakpBY5//ICjNmhUBVpUd45//gguzsAC45iXUgWLkx\n", + "34eGPPL5QQ4oYSFvABsE4om2j6kmjEQd/9bbw1KLKVpc4YEOSUTInPZ9GaH/+55BfmilhIcveAGo\n", + "Awi8UB9LTXNDsDQm8cAAhzO554HhDkiLX/+8ARDCagA9lJA0gAw9dANfOAAEAABga+dpqIgSlRWK\n", + "T+EAAbA5pYQAAgFABgkjhCsNgGR3neF/oMECJa+xJRuG8Z77RO6BgXCHn86AyC3k14aP4QUNdN+m\n", + "8kAAAACHYQCi4ATACZyA68LifE8NIMCBMNQAVUw1IJSVocAUQNOSwCytnW6ECA9vGUgQAmKQK04A\n", + "HzISxa4PArZ/vwAbGyeTvTf//l6FfhbxmwC6/hmrqYr/+DBDsUACvCzlHtxRAtFjeRbyWNCFrmIB\n", + "YEh4cMFBJR15eKw6qQ7Ad4MmkzuO++gVdXJAAAABIWEAveAEwAmcgOvC5fwQ8RC/gAJkQyuhjIUd\n", + "KlJ8IZsPlkXOQtPf/2g7iZz9jFMCSJhEzKygAHc0wQ+xiO9ABm2/lZ//gTMLiwqBL1r5VfYEAPBa\n", + "AA+JOnAQ90CVFpDAP2MEKODCwfhRpFgj9Ep+DwIQko1wXn3huY5f/mAFARWUGKUoeP1XTCFVwAg7\n", + "Gt1IXdmxer7aDHp+GvXpscDTP94IAAQKgABAMA0XCAAEEkAAQLQAOAsABMwM4jn/jGLcYHwBUP1r\n", + "sZCHkXFQXD0D4NgaRJJJq3KfuB6xAWRzS/SuwQ7EBqbw2Yf/+gWwAG1mhK0VhXa3wSDlJIYL1/JJ\n", + "dptf7zcU24I0J/xaRPYtEQIk2hwBIZPBV8Tf/AiHUf8+8HUAAAAKYeAFAAocgOvBvAAAAGdhBvgB\n", + "QAKHIDrwvw1s4AFoZ0GUlqS0GDnf8CtHsADRviCRz8hDlJUJHNvYOIOYZgBm3xiX/WwfABFCaURT\n", + "QiZVgzEG//W1sJSiShaXAgARWtADgzCHWzch3GHkGHMV+0X+B/DQjz8kAAAAqGEDbgBQAKHIDrwu\n", + "J8Tw2aoBhiZ/DcABy4HoZfF/LDZG+FzL/+8EoDmzkYD8Zm4ERrp4EAp4e4ffj4GigSJPHK8YuC8n\n", + "lhTJoRoUOWHNphJT4kKal+uWQWoqVITfeGIt7Hoo6FtXAKP+ADHWSrIOO4IxhvZUCwABATAA4QAA\n", + "gCgCi2wANRni9KBpIYpeBsgeEsbBa+C1vrwAOYMWPvJCoqIeXwi3oVHkgAAAADthAUeAFAAocgOv\n", + "DHDMABx85YxgTTlJH2f/aME5xtYlBSR6T/4H4QLu6AB6ESFla4KXFg/hy7f8NH8/JAAAArFhAbOA\n", + "FAAocgOvNHwx4ADjOLDaUQUHBjoqJQEv/vwNTgIahSAC3T12g0CPRqBOIkUvs6Kap4j4CAAIBiSw\n", + "gABAXAAcDhbAAubSaChwBbCizgc4GqUAAQDpgAWesABwxnSstiR8ywCFgpc9EwE4A1kS/AABBptM\n", + "AAoS/4R4b4CiMpjlCgOfNdbDJJNBhAAI7nBAACAcADA8/gUVKBwQJk689+ArBokHWkKuZApWdCUM\n", + "IIHrwv4ACZCFb+EHKLG9WYT6GBjEjnR1GrWEiEKiO/wABwAAgMagAjFC6na7bA0IAAiEKLmHIAxE\n", + "AyShTP30Aj30X0gYwAItijJDxSvDUweILWXjgAIACG64dyQOaDBdDX/8HLAAECmWUAAQPgABAbiA\n", + "AIPugQwwIHdyeZNlBVWfv6v8KgBhwMQAGBwCex7hvIJ/mDpUcoANwKSZ9eRs4N5h/8wdqUHtAOsJ\n", + "X08TSCsap4GL6kmFhe/bH5DvMN8PwBitWEdsePZ8LtZR7Y0zwAEMPFa0tvhUi8v4PwgATirCAAEA\n", + "gAQEFAZWwIpQGaNa76lbwAa5QADgWf+f+hKmVgBxkWgfUHBi7rYPGQAAQDiEkAACB9CYAx4eFYZ+\n", + "BAx0gXNVNVUosWEmFQYcIAmMYIAAQAwDhZOSgRoQBFCGDP/pQYu6GlbkQbSmJW3/CFQ9gBibvsz+\n", + "iIAAQAShZ044owcpX/ff4AFsR3GWhqykFjH/8gKM2aFQFWlR3jn/+hgVYQXRYGx4Rl5mrEE7+gov\n", + "h5zVyLoD+GdaUL7TUkly2iVEYWgAsDMAFC3qbScQfdvv4AMgTDH28fMowYiDv/qH4blFlLUmcMCH\n", + "JKJkTns+jND//c8gvzRSwkOXgwwlgAwcNbWoVPqFjKHVJIt+rRBqdMg7T1vfuTERmGPpvrdEmNY/\n", + "kgAAAE9hAIfgBQAKHIDrwuJ8Tw2G8ABAYrGsOOPaxhx5x5//gAPiYdqeIOUWP6sxwBhWR3ySKq+C\n", + "WpUX4cAUKm8ADmyJRssyn34AHNkLR+lVo+8kAAAAuWEAouAFAAocgOvDHC0AD2GAYquJAejsIA4F\n", + "9/u2kABAEG5xhHYw3IA1BZf/ACQimHCBNN5Vs0NRTmVf6JMAAQKVSo4AAgbgACAvUBPwAyEwBalC\n", + "JYP400f4AxHSiAtWKSVCVBf3AGMxEyaFwoklQkL+8AHIYAqp3ZUAvX/h0IAmAAKAkIAAQAwDnngB\n", + "UZgECYcehjgwNBkIAXr9RUlKV14AKvTACgG4U7rQMxh/98G8NH8IKGvQX/kgAAAAiWEAveAFAAoc\n", + "gOvC7wU1yxvToNcOYAIQABlTABBR8drYPmvyNlyafgCICPACW5zkl3e4AIp4+csnWFOFuAAgMUwa\n", + "phD7aiiTZL7YfgEEMoNxXAe1UJWCA3ABGumh/n3ulS8v/Xywbggsc4QARHvAl9vj6tKcMOSbn94A\n", + "yN3YPfvhE0WcC4eLXg6gAAAACmHgBUAKnIDrwbwAAABRYQb4AVACpyA68LwzUVxWQpkJJJaSX/hs\n", + "3/xwwW8ABCZa49CJysTTEOl/DAAwQqR/0FWRjqprvggJClAFwAJ41gtdFBREg8AC5mJJHVLdH3kg\n", + "AAAAbmEDbgBUAKnIDrwxwzAAQAZAAZq0ueNrK8hAfGfwABuAlA+OkcLkv7Hj8Ah8QRBHCD5hLHhQ\n", + "tP1BbhZBgACAK3sLAAWAVtFd+CAAEAUAUNKhACc5wAL2DrbgGoIwwf8+D+ADlB3kgbcX9A/hs/JA\n", + "AAAADmEBR4AVACpyA68MCeH4AAADFGEBs4AVACpyA68vDngDCgACAjZAABBaAAECu84ImZBAAIRx\n", + "PAD/BqYxRevcAHxgGzgIUPKuGPV7ghDfPAAESuAMAAAgJgACAnEQABYfIEACKxgQAAgEABASZxFT\n", + "AYFdOb8H8GOtgMiHGM6ONfYwahYMcAB0wYAuJDtjFxTA5bFHvRZgirKEUQaOgroAv9EUAAIBelAB\n", + "XIw4A8Fff3hAAQGePCAAEA8AAQIwcD2ABmRaoLCg/J4pTJXG9pmuLOYASRHQHTxYImTAW+C9z6xA\n", + "ci5OBaxgfyYtghwvgAJZiio3WFKZi9NgLEKAW4AqJmE36AogptjXAtxCktK5he1Q/gMImmBIlAB/\n", + "iLEL2hjkcUyZM/79Qkc2gFXGCcgtKacsPQ/C3uvIrPSd6mjSG3Uis68AAKQFwoIIo4a1roDt3x9v\n", + "ZttvSDMAFKoG3YJPD+YgzeRRwkjqU8c5T0pjsAAkAAIBUzIABwABUQQABcHa0IAAsGe/CzB/rmwB\n", + "Ah2/8HykQn/bDMSa8OLMxGJvowngSFhsjwkjxHDWAvhBYMNCycRBMzGDz/oYSmggCcx4OuYux4xT\n", + "n4LQBFMBWHhGWXDn6gSMMzAABARAAEBQADQABAJlgBYZhyGpMEkxtDhyUu8MICQhAgADoCjXXdsC\n", + "YEU2/7hAYigayE07bSn5hPb/6DX5EBH1JQesVEr06xLpAFXAwS7OYgTHLV534P9BEGQR2YYUPfjf\n", + "/d/wgR/eEAAWADHAqtIpQRYlBV7vifmPqXu/h4HGdAW8kBpANNT3EIgjkYQcooZxRbwwguNC/wAL\n", + "QzIOpLEEpKGuf5AgAPAzWJ4oGl5FAQKX2zDcBhohTPOQMX7BmEJcEJCeAuUjDZF7N1LPpLVegUAD\n", + "3BWH6HxOEEviOUI4W5hbr/6gBQIP4daExv5NOxMu7w/YTgoGTYRgqWE4nTEAc+pi+nMpRpUtLIAA\n", + "QKdgABA7AAEBsBfqbwZxzS2+We8sT9NP4QUIQIAAgMGkZaSLgDOZ37vGcACq4xvveCIh7LCgy4tf\n", + "dBXaOFUAcgeb9u8kAAAADmEAh+AFQAqcgOvBmfkgAAAAbWEAouAFQAqcgOvDAnhs3/FhDwWwAHYI\n", + "PfschyRbJJZ+8Ax2RTT/HXJhTiMjh4bAAvhicWJWqq8S//vCAZhAbPccnxJ//kVwhAACAIAIGlQg\n", + "CY58AD5PsAAQAYAZaAM98/ABYIo85NSqWYP/eSAAAABsYQC94AVACpyA68McMwAHEoYISZcSaUJC\n", + "prwV+8WIig4NZ7TfQVHcVpDDCAE5zgOgA+IUHrKPGw3aD+AE253Gf/rYfw1w5gAigAFkOAFFnhyp\n", + "i/afJStpuADgH4ATdrW2u73ABCGytbjdEcHUAAAACmHgBYALHIDrwbwAAAB5YQb4AWACxyA68McL\n", + "cABDYOKIb0veroI1HQSEvbACWHACCz45SuftduBlFx9QcMHHkzYSAT/vA6FHVpLArB9bM2B2FUMM\n", + "IAIglkIAAgEHvgAmYpToTOangwYTAQ0u/Am994AH8Mmo/MpLrPBgwhgEGkpPAvN94bOskAAAAA5h\n", + "A24AWACxyA68MCeH4AAAAHRhAUeAFgAscgOvC/DmABYyEPSEqgLoppvqBCw7giOea8gUvBCRG8AB\n", + "2FbDk8YW4gjhLwzZ4bgQsOsQJTzXikF95nFDXMpSRjl8AAO1wP5YppOz9v/Af7Q01smmwQABYGPP\n", + "CWl4YDU9JGQDKFE9fgo7IYMPwAAAAcFhAbOAFgAscgOvLgh+HPAAQZz4WlEEKGBjwsLAAOwgBMY4\n", + "QAAgCAChpTKaAAlyV02AD4MdgX9gAEmQZ604nUKAO4GSfwx/A1KAxqFIALfEJ/CoE4YQ8AZ0AAQE\n", + "AABAUiAAOAAEAe84xesAARK9ggADRQOgIAAQMwGACn/fbZYw0uJfB8SdUALuvfBMq2YY1AgdoZuK\n", + "geAr0EFgAIS9XghwvgAPxDRXyUhDu3vFvCgXvINc4Wt9wNimKaIAuCGWn4+IC0uAD6MVUmenOQHs\n", + "y4xdjoxYQtMOtL1Ag4bgTLEzhJcW4UitsAuZY1rIQ1YxN2GEtJD78FEh1UIbH/xB1zfSP+gWfgYd\n", + "d6OVFZ4b0TARouyGEF2cIAAyBBLHK+xfhklke9/4E5EvQCqpQDXBpnDqDjCvwBitaO708e6kM5D9\n", + "/EUMOAMEUISQFssEhr50WlgN52AAICMgAAgJAAbEAAQB1/oPwgACZA6AgABAYAUBDtXhrVC2lo52\n", + "7YIBrx/4YkEgcpZIYs8WTKKXGQwwaBGw+/wgsFPL5uD7hmwYEt3LsABgXZ2g32oAJWBMsLhvAslw\n", + "r9IPWHz/gBhSD1hTG/f8kAAAAK5hAIfgBYALHIDrwxw3wAEBimDVMIfbUUSbJfbDXAl9vj8AZG7s\n", + "HvDRv5/8FmABiAAMrDABBR8drYPmv3gWwUFmu3TuCFxebHfgrTCJkcACXxaliFrQ0OABTPC3PGPy\n", + "QSH4Z6Agb6YQDEQsvsLC8ACegGTTXrTxAAAgVAACFKAAIPrLwIJR+HEcGsmT9CompCAAJhyywgAD\n", + "IFEs49swJdThvCa/+NmxjfUvOWC6/5IAAAAOYQCi4AWACxyA68GZ+SAAAAB7YQC94AWACxyA68MD\n", + "enQb4WgA1RB6iJUlN8BBtBJD8lKaF+AUAgqHFbQ/k2CsDAO//uEAhCCiECI9l3Iy//tECYw2MQgt\n", + "I9N/84FzEjnBMOWkfd/94YQACOEkQIJAAfoFxNGxWtYpf68DWMtLa94UubeAXvOQS+xdvB1AAAAA\n", + "CmHgBcALnIDrwbwAAAAUYQb4AXAC5yA68MBTISSS0kv/D8AAAABbYQNuAFwAucgOvDHDcABwCIF0\n", + "p1sHyKsGIA7/7RCMgykMSWgse//nCAhiCiJEY7LozS//3Ajd4RARaVnePf/4IAA8Aw10JaWABYDo\n", + "fY06Es85Y934A0bcjk3h+AAAAA9hAUeAFwAucgOvC4nxPD8AAAEnYQGzgBcALnIDrzPCogOYACul\n", + "e2lPvM3VOCeBYLdZ68zggJSkCAAPgIOd4ATCsHWUY8T6vbCAB8MAqPAooOkrQs9Xpv/cdaDsOGAA\n", + "gzjiU6cw3L3lnhw7/Azhx1ZxuK6sEV5KI9wYQAgAygeEAAIAQAAgqhYAhgvxeGFDYtFlvANtj7Uo\n", + "bQKRwJwtQKVYXMwAhII3VwCkyrUARR/Chu4FPgNG+Ef9As+HhBYOPC/REEzNKq/0MJTQQBOY8HWm\n", + "LsfMU5+C0ARTAVh4Vllw5+YO3/0GoL4AwrCFGKPOnOoCxB/D8AMVJZF2EQuSLpD6q4MOEEAvBIQA\n", + "BkAAQLBIGIaCOUAjRbi2s/xvXHNB/Q/9LmFgBQibwFURsbvsYmZgY7jAcOBlmn+FYAAAABFhAIfg\n", + "BcALnIDrwwJ4aP5+SAAAAI1hAKLgBcALnIDrwZBvAAQMxzGOY5zHMY5j/wAMQABv64AYUdE40zb4\n", + "egEwAz630O/ACGym9Ie/NAE8P8FcABATgBB7M8bK7BBnAFCcfe0016095CRiEYRwGg/lVcNWfwgj\n", + "hsLVjOCtKZ/QIAAqCmmhAAGQKLbBObRlQRWCHfP3NQN8M0IrBnYEE/Pzy8kAAAAPYQC94AXAC5yA\n", + "68GYjg6gAAAACmHgBgAMHIDrwbwAAAALYQb4AYADByA68G8AAAAOYQNuAGAAwcgOvDAnh+AAAAAM\n", + "YQFHgBgAMHIDrwbwAAAA2GEBs4AYADByA68w3lRlDuAAgAAgWgACAkAODpaWlxcXFxaWlpcXFv//\n", + "AB8AASEABOYAyx5A4ETMggACIQgngAcymoNSGpRVwALwgvsbYzzpezhheG+YvWAAIle3hALkYIAA\n", + "8Aw9/EFIwBhyu1fh8AxWlAIGnZtq8Mn830/9AswFgAYFe4JJowZeOBdyooYSmggAisbAqitiqHhD\n", + "vvwFmIx/jAvFhl3yEPwznYAAgIyAACAkABsQABAHX+v+EFmYIAAuDnnuxJgEgR1pf9wgIKwDUxVb\n", + "aX/CkAAAAAxhAIfgBgAMHIDrwbwAAAAPYQCi4AYADByA68GR/PyQAAAADGEAveAGAAwcgOvA2wAA\n", + "AAph4AZADJyA68G8AAAAC2EG+AGQAycgOvBvAAAADGEDbgBkAMnIDrwbwAAAAAxhAUeAGQAycgOv\n", + "BvAAAADQYQGzgBkAMnIDrzwlDnABUADSAAML/ypu0nD2FbQQAIjG8AKgaxX8LvzgA8gHyzxzHrsd\n", + "OYTYbgPMnLYAOI5uPvksQAQGYGXb0MIACM94QAAgHgA4OPYGoAet5RuFVebH4GAGAARqEIFCvJnc\n", + "fmB4ahKGoCtAAQB6tYlukXEMX4HDhKaCC7PAzjskdV2aL8BwIGRM6UU5Kyfh+GfAE8A55QGLUFtk\n", + "rNPXwYcIATnOEAAIAQBgolpQhKlOIo9YlV9/+BuDgnsqOIkfhhEYPAw4UgAAAAxhAIfgBkAMnIDr\n", + "wbwAAAAMYQCi4AZADJyA68G8AAAADGEAveAGQAycgOvA2wAAAAph4AaADRyA68G8AAAAC2EG+AGg\n", + "A0cgOvBvAAAADGEDbgBoANHIDrwbwAAAAAxhAUeAGgA0cgOvBvAAAADbYQGzgBoANHIDrzxEOdoA\n", + "KNp1xAraCASELwBGNkRnr3ABqGloRRJZB3n9g5hvghgACADigBg4Kv5FBgASOADCQhhFHELA4gs8\n", + "mDoQABwBhr4QAAgegACBCADAcwN4SYoVJCbAVa+/A0XA6/HCHS/a4GNe+8NRENUMGRcuvT93fAWE\n", + "F2eKiyOR+fgoJaw/NI17B78vhsn4Z8sBYC5YzMUF+yn/7iACUOIEd55tqfNdgj4MseCAAJhyywgA\n", + "BAYAAYBAta0wWsAIWDXFun/BwRyACrR4AGjQQK57gvhSAAAADGEAh+AGgA0cgOvBvAAAAAxhAKLg\n", + "BoANHIDrwbwAAAAMYQC94AaADRyA68DbAAAACmHgBsANnIDrwbwAAAALYQb4AbADZyA68G8AAAAM\n", + "YQNuAGwA2cgOvBvAAAAADGEBR4AbADZyA68G8AAAAHNhAbOAGwA2cgOvERMN8AbgACAcAAICkyAB\n", + "QID9hGQLPCAXI2ADuKTOuSr99VcY8wALyAgPdVbzCPah/+D63tEf/54bXhmAKBHGJYg8QUGEGPBU\n", + "6BgEOdBEiIOptnvRnt1vgaVMNUuUxFM78gNEiq+ff4UgAAAADGEAh+AGwA2cgOvBvAAAAAxhAKLg\n", + "BsANnIDrwbwAAAAMYQC94AbADZyA68DbAAAACmHgBwAOHIDrwbwAAAALYQb4AcADhyA68G8AAAAM\n", + "YQNuAHAA4cgOvBvAAAAADGEBR4AcADhyA68G8AAAAbRhAbOAHAA4cgOvPBCw5ghFdzoAOCox75mw\n", + "F9X1gYJGoQACM54QAAgHAA4PPcADn60CgoXV4k9wALMiIcg4bk0Bi4/E72PQY/wQrJbankLFBnws\n", + "LTNpAANgNIAAgMACCdMCBg9qScHE6HGQvqg3PCKYUwXRM4ydIANYIAAQIFAAEAXAgABChBAABBIV\n", + "wTqMdXACWBhfvgN2FXICJPEUCfp+wFFhYWUIwhDoCNgfuWmCEHyUIj/BIZ5gUKj+2YN/7MK+5JFy\n", + "sT+3iwYQ5QQAEZ78PGDQhyic9+BeAX/4GLGlIuFW8MyoNQ3WeAIdTgVKP1EFYKiPjvDCAlIUIAA+\n", + "Aw96CJ2CPCgZZ5wfgcGJvBZLLwIoCYln8Ywr8BFY4KP8EKrfpP35an/IF5Kgzu2iEBh8AmAdFwMX\n", + "Ef1UIoqE54IZRBJA8ZU2cpmiQaWwwwgABANYAF4IAAQZAOAAIBjelJeB3cAV4a+9Q2sAfD6IGpxv\n", + "/ganCzVAq28AIMhkvcbgQSV4AzQxsYg1qBh484Z2MMhgjUmFCEEj//7/8KkggBOc9JJCRiRiHP/g\n", + "wGW04O00fllsf8JwAAAADGEAh+AHAA4cgOvBvAAAAAxhAKLgBwAOHIDrwbwAAAAMYQC94AcADhyA\n", + "68DbAAAACmHgB0AOnIDrwbwAAAALYQb4AdADpyA68G8AAAAMYQNuAHQA6cgOvBvAAAAADGEBR4Ad\n", + "ADpyA68G8AAAAIVhAbOAHQA6cgOvOJ8v/BS4c4ADmTgBEJ4SnQb2JMOf/DbAQCQhQgADgHGtcAHw\n", + "APUOcUqSFnOAA+wGAAIByYrgEBd2lqcosI4ZP5fggfw18YCApKjyB1ocMEz8vm2eoDwiZGEAARCE\n", + "kQJoIJk2xjE6333xiLwNQOBqsqeNnSrShpTDxuE4AAAADGEAh+AHQA6cgOvBvAAAAAxhAKLgB0AO\n", + "nIDrwbwAAAAMYQC94AdADpyA68DbAAAACmHgB4APHIDrwbwAAAALYQb4AeADxyA68G8AAAAMYQNu\n", + "AHgA8cgOvBvAAAAADGEBR4AeADxyA68G8AAAAW1hAbOAHgA8cgOvNw54AzoAAgIAACAlEAAYAAIA\n", + "95wQXdggAC4McfwBamQCFJnNwBCCKI8HmhBPm8N8xesAARK9vCASkIEAAeAYe/iCkYAw5Xavw+AY\n", + "rSgEDTs21fE+X/Ag8MeAA0XUIlhZ2lC1iCoBPsgACRgAQEhN5IsMyNzwgACgENEhAACBKAAICoBg\n", + "IYAVACxRYBcTxxdAi2tlpj2AA4VoAeBLV4HpgFJgrI/XDb0gvKJ5rgxw1gDBFCEkBbLBIa+dFpYD\n", + "eGEJGQQABAKQTHFIDwi234egIVYK+XKNv+Gc7AAEBGQAAQEgANiAAIA6/1/wgszBAAFwc892JMAk\n", + "COtL/uEBBWAamKrbS/8/mMdv/oNQAEyAAwOO3hfm8mPHQkS+MAJIHEjO1MuVTjrdyGH94b/lH9pf\n", + "vJeGHCAEVbQgABACADBRoDaUmQmCPH8+7fv/7/P/QPn4qCRMVxFYdK33KRESE2QiM3hhOAAAAAxh\n", + "AIfgB4APHIDrwbwAAAAMYQCi4AeADxyA68G8AAAADGEAveAHgA8cgOvA2wAAA45tb292AAAAbG12\n", + "aGQAAAAAAAAAAAAAAAAAAAPoAAAYOAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEA\n", + "AAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACuHRyYWsAAABc\n", + "dGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAYOAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA\n", + "AAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABsAAAASAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAA\n", + "GDgAAAAAAAEAAAAAAjBtZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAACgAAAD4AFXEAAAAAAAtaGRs\n", + "cgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAHbbWluZgAAABR2bWhkAAAA\n", + "AQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAABm3N0YmwAAACn\n", + "c3RzZAAAAAAAAAABAAAAl2F2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAABsAEgAEgAAABIAAAA\n", + "AAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAlYXZjQwFCwBX/4QAO\n", + "Z0LAFYyNQNhKQDwiEagBAARozjyAAAAAHHV1aWRraEDyXyRPxbo5pRvPAyPzAAAAAAAAABhzdHRz\n", + "AAAAAAAAAAEAAAAfAAAIAAAAABRzdHNzAAAAAAAAAAEAAAABAAAAHHN0c2MAAAAAAAAAAQAAAAEA\n", + "AAAfAAAAAQAAAJBzdHN6AAAAAAAAAAAAAAAfAAAZ0wAAA3cAAAIqAAACxAAAAbIAAAK6AAAEegAA\n", + "A3AAAASkAAAJ+QAADKgAAAreAAAMdAAAEHgAAA9DAAALUwAADScAAAxsAAAMFQAABnQAAAW2AAAE\n", + "8gAABB0AAAJ8AAABTgAAAUEAAAFMAAAA5AAAAiUAAAD2AAAB3gAAABRzdGNvAAAAAAAAAAEAAAAw\n", + "AAAAYnVkdGEAAABabWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAAAAAAAAAAAAAt\n", + "aWxzdAAAACWpdG9vAAAAHWRhdGEAAAABAAAAAExhdmY1OC40NS4xMDA=\n", + "\">\n", + " Your browser does not support the video tag.\n", + "</video>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from celluloid import Camera # getting the camera\n", + "from IPython.display import HTML # to show the animation in Jupyter\n", + "\n", + "style_list=['ro', 'g^', 'yx', 'cs']\n", + "parity_list=['+,+', '+,--', '--,+', '--,--']\n", + "fig, ax = plt.subplots(); # creating my fig\n", + "ax.set_xscale(\"log\")\n", + "ax.set_ylim(-60,60)\n", + "\n", + "camera = Camera(fig)# the camera gets the fig we'll plot\n", + "for i in range(Grange.size):\n", + " for j in range(num_blocks):\n", + " ax.plot(np.abs(np.real(evals_list[i][j,:])), np.imag(evals_list[i][j,:]), style_list[j], label=parity_list[j])\n", + " if i==0: ax.legend()\n", + " camera.snap(); # the camera takes a snapshot of the plot\n", + "animation = camera.animate(); # animation ready\n", + "HTML(animation.to_html5_video()) # displaying the animation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a788023", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "734325af", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "<video width=\"432\" height=\"288\" controls autoplay loop>\n", + " <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQAApkxtZGF0AAAAUmW4AAQA\n", + "AF5MUAAQ5JNScnJycnJycnJycnJycnJycnJycnJycnJydar//8VhXwHAAKAFBRGW8ABPI4iDqQxR\n", + "EpXXXXXXXXXXXXXXXXXXXXXXXXgAAAGnZQbuAAEAABeTFAAEOSTXcQGAR48JQAEyMxKhSDHt5A5f\n", + "h4CwVwmLSKNYEVP7yMiGikKjielH8Ayo6AuC36TMf8tcAahfJDMqUWQYdNrLIg0Qcd5P5s+er1kY\n", + "aKMlxbDSD1ewjIMowl9PyrP2uxWI4h/CXzIjGqEIji+hHrtuftDBwABABAhAtMxe+bx5offfffff\n", + "fffffffffffiMxF/r/CL4oAWjpMGpIDKOe4DoI4UIc4DRu7X2h0+NrsaPv6XAfwcUBhCJAJHlnoL\n", + "G899o04ANro2JlL5/SmZoTjIqveBQzqkM8IjDEQj+F4LKlgFyHGcWcghT2qiwABAemAAEAIEMJi+\n", + "IIGhACAZE5OtV11quuuuuuuuuuuuuuuuuuv7hM/F/wAF41LNJGKqAFsJHPSGLmkqkWIWfPe8HA3l\n", + "Pziwu/egVGjx4JhTRpvngYQFveGgkotrXKHLvd4u/7SRJmGFsrzt+rYyHyqvzf4KAAQNg0BiRSmu\n", + "mKooEVM1tP/YcTqAGR55JsPlfWc1aZu3t4MZHQBJwAI2+vq//4iJXIx89///RNLgAAACjGUDa4AA\n", + "QAAF5MUAAQ5JNfARxXDC8ABMyMSjITnNPHYXAATIjGqEIji+hH4CIoanGC36eXTf5+8zIxLyFRhc\n", + "SjLMjCcfCnGvcbtUIwB9BiEPAsSfXNZEGiDocW8oo9XvIyIaKQqOJ6UfgKSA7dbKkyUf/w/0jDKP\n", + "mmuCE0eOf97CMgyjCX0/Kt/a7/7BjUIB4TgoDgACACBCBKYAmRmaE2U6sy44wjD1BRJjyWuDHgAC\n", + "ACBCBaZyak5OTk5OTk5OTk5OTk5OTk5P//hCHPAATrLgyzHwEEFf8C7wKnqDwiGWBILQIXoNT2ja\n", + "AEBb0FncIYlaBwh/jj5wCAhX38A8kj0dm9vwA0cyxRz7A2yLjDEpd8XqYBnLFSOVnN2ug+fAA/LI\n", + "50jI376ekhAQRA4ABYAAQB0GNXoh8ZfE9sdrM8CXDReCXa64ywkKjCvGa2byU8wYNSxlbKIhxEBq\n", + "hQmMwoAcq6XD/+g3gOAAIBQBDQlMCKUOEcjubtB6qIC6TAx3OrV4HDBQoABqAb2mzLQmblx1pePh\n", + "MuXvekzDVzHCCDGlk5OtV11trrrrrrrrrrrrrrrrrr/4c3QXQQ4AFqbsNCEUMkn5KbbmgAEy7SBi\n", + "qMLZ/oF+jFPGd0W2vvMmQB2j2YT7r3iX9DRKBzPeZh//bBJEMD0d2hHoVQbR873HECJqOo2FMcZ/\n", + "zVQR0CP/ErW4/je6Sip4/2DD8ngSIEICJ/Yni1XTpiN/uwAAqUGG51GBfDkh5sK36AF40ayJePEK\n", + "2xjrtKdgfCG+y/8BZlYKX3BChKGHv/wuqe1vleE/PvV/9sH4GP0ElhTnovzQ/pT7BbnnZIzbPfNm\n", + "dbhHOeCFgC7sZx6MPej9LRm2lpcAAALnZQFG4AAQAAF5MUAAQ5JNfHmJ8O+AAmRGNUIRHF9CPLvs\n", + "AHzIxKpCowvJR3nkOMQWcghpDW+RkQ0UhUcT0o/wAO0VlesTfuHXkGnAEY1D3GPQdXA0L2EDaYsu\n", + "XVbz/3EGgH5KMw6+Fmxr9ZEGiDsILeYw9XmAEgDBEHyJdNhGQZRhL6flWftdw+0AEQwngOAAIAIE\n", + "IEpgeAmRmaE2U6sy44wjD1BRJjyWuBx4AAgAgQgSmE1JycnJycnJycnJycnJycnJ//9xOC6AD3YT\n", + "HPCDLMBypXh8e2BS0PKSuRXKLI3iEJWi+BCRGEABHe7gbxYcAL8rYaAUHf8waC6DsFDsifIUs2A5\n", + "NDcrEBD12qxVpMb/9/wJ6kEADVErCUKunXf/YDo5L9qbC+rAYAAvQYIEAAQCOANwZ2w0/QGM8wmv\n", + "YPfYeE7RXfANo7CqjYjx4/4/0HYI2gtNTLy3w8CgXpbKrbRI2r8GAKc2TIh9K//+8JdbUH2LcH1h\n", + "QHxggBABlA/JqjAaNNHAx6NT8LzDF8jAIukFyhA9iMRLl4f/oN4DgACAUAQ0JTPtnhIUKEBA6RXX\n", + "l5Ehl4zKIXUL9ogQxZYj9J1qu/1irXXXXXXXXXX//8ILsADn0ijAfGc3tA1mdbQAjCeLP/AIgI8E\n", + "oolrcEoolrf86B7Bban6A35eoOdse/OAKALkMzD3iFSee9ddddf//OaBdAha2sZG1vl4PM58ghRP\n", + "/8BKTfASpxCTl/wwDQD7Kg7GF4iNj4evd8tNjfAAg2o1sXReACmV0MpAz//us2TYcRSgeP74HAEy\n", + "CZP8aH2D6exS0Y4nL/gCjryoQDAPQ+KCEAG8xekUrLfGd/u+6/9dNtzCVrcW7068hn/+lR+yKJ43\n", + "+uAG6Wk2jMWUOn8wgiIcBLq7gQ4+OOCdi/YDmGGpH8ENhWiqKbCkHjrT6R7o8Ot+KOz6H//hvcy3\n", + "wJm9M+G73u394aDRBEWSPo+FW1rb554ddeAAAANLZQGy4AAQAAF5MUAAQ5JNf/82wQwAXGQZBtLe\n", + "Y55u0AuQ4xBZyCGlNbAIxM+UxYAE1Z5IjzHf+vH0GJJwXS8PC3HH4DgACACBCBKZw/uRmaE2U6sy\n", + "44wjD1BRJjyWu/AB7sJjnhBlmL/AGF5Xmf/c+EO8HKleHxbYFDsifI5ZsyAEBBqCxCYhAAE8GvAt\n", + "FzYQsfXsD59FGHgVV8FGZohhOqvf/QcAgt4AqmN1Kse8QLoDAAFaCfPgqnnvJqTk5OTk5OThjAAR\n", + "GRGRkZGRmR/AFgAyQFGwuf/3MMuP4EX6efj//4K4BVRw0uKzOQMOkXT99x/4jsScnJycIfwib6//\n", + "/HH76eBG/pn/AAr9sE0YaBqD/899N0vA/wAJili/qfCBD+vQmuDkfb/w0zORv34WBGgoHnAzsCAE\n", + "oTILJ2MCyLGxHfQIsxungAFr4swsCrvq96A4givVxxf/13/IgkIRj52O5rwqpHftf84bwDocFdoR\n", + "kSmi09a//ABHZKICwzn9YhOsYIDpgVbCBHURgF0QH4mIICxGEoD3u44DLBd12AaHfqkAgtt/dS6N\n", + "CeuRTeH4fgrz98zPHw9GAACAUAQ0LTPxCNCAAFwIm9/2wYf/xGK4pOtV/ow/+H+AZpoH6DDGt1f7\n", + "AI88DZJhjWev9/3eEI/HQahjwABABAhAlM+CloeUlciufX9X/Xm3Af+g1osjPEISlF8vFWkY4f/e\n", + "v+lpjhGKrLtdB/EWIQAaJIKOeFPlhfWaNhIZtOpVFIhguHP+EP/8FcBsK9HGjE3/Bh0Kkv7/d/n3\n", + "/XXXXXXXXC2ABEfqv6//+AEX9LJvi8BI/1rfws4AEH133f/4Ze1Ze5v9er+fomlpaWlhZQAE0m2k\n", + "k20n//wAPclQakKoZHxeavCPcmI2CGH0O6ZlzvFCiNLJsPXQTLTff8/BdBnhfumaGqXoYe1PDwAh\n", + "M15Rm5gZt88kfwN2BAYRgU5wSreI9Zly9KGezYbBP05CFVJwS9LvQuvg2MWqmY1U6Y4YDeyQHIlU\n", + "V0N+i2zz7/4FFySmb0Ar1MTiWhv52HTrT2LgOWZNmCWgirhHIRBMxsGujZPfaZ0/qsXUZMoOaAvF\n", + "F+StEiFE/fHm/KSNeycQ9E0uAAAC82UAh7gABAAAXkxQABDkk1J/D/+HsBwABABAhAlM5MXJycnJ\n", + "ycnJycnDGAAk0mmmmm0/gA/U1HoTf/ume/Y/4BLAQuTK9N/73//wV8fc/PBPH//4B1wttzeBwNIt\n", + "9e89//JycnJyf9x/8FkADC8lM9JqUhEzM+AAde+/RayOYuqcxMzlgusK04Dcy54DSjFz7uVx/8Nc\n", + "aKqYMRRoBzP8CV4FnDV1U3a8AAvSWfwI7//LCWknIbLH/fSH25mw9uAoswHAAIUaj4VDYqhyi/kt\n", + "x1f7+7/9dMtKf0gBgv7tgiPp4IpgFFH/vxRDZJiHH5dd9dx+7irHbSJbGP/9cUKJ4LQ/1PjKn4+3\n", + "fzwP4DgRyny3+Y7awGL3f//WBmwODSpdRPiBmNZpw9RwAfKRwUeTJYyAteqeFGT4bU+If/ob7ADJ\n", + "PTtDAOAz8YAAIBQBDRqYMEb7/i9g4EiDOAtcA02fAJnzaOP+KhvEOFLaVXzwhI5ZOTrX/H/h/gAJ\n", + "GRDRSFRxPSjy/7EgnwwDhKAHwykKAw94iG2oAczMagVKdAR24pTOBuEEJWlSwbv8kXnvAZSoDYjM\n", + "8BM16iNPiImLhEIdwMsqqDfg1KUfKXilopYX/xmSFh0J3gbZQ0v4iDE+9xCU7ya4d//kRSRkYfD8\n", + "RkQ0UhUcT0otRBnHqCyTX67+H/66666666666666666/7z/4LIAPdhMc8IMswHKleHx7YFLQ8pK5\n", + "FcosjeIQlaL4ETIwgAEZ7oG8WHgBflbDQCg78waCg8P2GoKHZE+QpZsIAQEHoLxVpMdP/vdLTHCM\n", + "VWXawARQDu9OC7Zm/vug9tk/DUKqnXf/ALCCVlDLwydAMZwUdnhVvDEqRV/cwIs/CijbI8f+/7gL\n", + "4B/w1BiE1wcjy4OybD10MnLfBjADYyc3PoHtGmX6Y6bTXHg2duC7cCUgMDVilMBrFQaxWDXP+XZA\n", + "xVTYMbpMJYYLXjan/x//8Ff+Bli8ACRmLr+Mooh5wv2v+nrwAAACX2UAorgABAAAXkxQABDkk1J/\n", + "D/+HsBwABABAhAlM5MXJycnJycnJycnJycnJycnJyf1ETCO6/gDI0ZEY+HqFdb0TJPjuDzF2dWiN\n", + "kOI3bB+yJ3bGq2lTBqQQ4T++Yj2mfPOpWUkGybCpvfe/Cmhlgi6GbwHv1UL1O7LjwQjEHqk0xmbi\n", + "ziEQHjenyzNDG62z32XNMrwV7/80kT5WWhcvbrP5komzP3VxslcO/6Axv7R6qJjlIFAr1UQ6iBD8\n", + "Z3zREPnv6KI7YY+t2kap4GAY4VRTWPkVdyft8R/xrXfnwBSGg2GXRKdz0d/ngfcPH/BXkXyFs6D+\n", + "9jAABAKAIaPTLPzuNG2ftBgcANEVws1jZ/D5Nyda//48EMABIyIaKQqOJ6UeX/B/vzhDAL4AHwDQ\n", + "ZKNx5ZgYRb7gBzIyDLhXhysES5D8RExcZCHcDLKqg34NSlHyl4paKWF/8Ya5xR2aUtRb+F4AACgx\n", + "iXuTD00g/8ZkhYdCd4G2UNM+IgxPvcQlO8muDDHYAEFzMtIiIP4f+IyIaKQqOJ6UWogzj1BZJr9c\n", + "H/9dddddddddddddddddf//TQc8ACEC+wNCRBggX4XJHELHLn/XywKBaFVI2iP8GgIi9AoU/xCLa\n", + "0HmcPN4D7vvACEKFSuRnN2uA0PgZjMAKhu74l4+KjC0aM95AHEkWDs3tz8AXKRGKsUWlv3Tfla6/\n", + "xCSBgAEKhyzLzxMw2KivL91jB4jslFQ4nOMILs45wAFz90RFGQSMJtqn7v6f9bnD7/2CuAKb0hNC\n", + "Upf7f8AIQmZlKufDBjDkgpbw668AAAfRZQC9uAAEAABeTFAAEOSTUn8P/4ewHAAEAECECUzkxcnJ\n", + "ycnJycnJycnJycnJycnJyfz3MECIQ+AEO71EZ6YMjM2EQqeAha0w/khK0GnCS71geXXisOLugjb3\n", + "Jf/86hJNf3zCov/vDonB/cbt3vNuLYL4+yhO/9/hdAMG8Am2yu0vUFF6QhcWPHMMG2Po4oEoeYZi\n", + "VW8XD+P4XhJ9rHgACAUAQ0LTCRqe239rf8QAhFybk61//8YIeAAkZENFIVHE9KPL/v/MHmGFYACI\n", + "whPvNSn95AChngBIUjBBeFUOvnbdrIiDKPRbzWkm7WACRRw39fIfn5588RExcZCHcDLKqg34NSlH\n", + "yl4paKWF/8ZkhYdCd4G2UNM+IgxPvcQlO8mu//DAIIIfyMiGikKjielH+IwhPvNSPWrS3mf/gGAS\n", + "Pj8ABGZGREZkRGRn/8AB4iISYhBz2Yofh33x+AAiIyMiMjMjIz/8AB2YYv1WJHLUpr4fvj8ABGRG\n", + "ZkREZmRH//wAHyMxLikGPbih3/wD4IOYAAVAKCyMtvj8ABGRGZkREZmRH//wAHiIhIhCDns5A8f/\n", + "/GjJjOYyYy+PwAERmRGJFVFdkf//AAdGEJ95qR61bY8G++PwAEZkZERmREZGf/wAHyMxKhSDHt5A\n", + "7Dvv/3whgC+ADPIowamMUYGfs4uLDN/bmCI3oGSbsVyALMMX6ykjmKWx9cOCBnwGFATgCL8qeEBE\n", + "rWeb3yevADA9XnYDu9HI2AkAewuxWLz0vokJgqKr3D+D+wQeAAlEUZhxIcpylXXXfhwCHpMIUhhg\n", + "AuINB3ocWDlBE9XgJEUubIjgfxTS/7Ap8gYPVkOSP+DAUZSqqgypYxgnj/9oAyD8QZueQgRhbtGE\n", + "YJAABw3D8ZBi9W4hPZ6c8AWEmcVCN3s3U8Mkg4AfCKUBh72CIdj0gJEbwgMzRN4c6y8QAATAAEAI\n", + "AhAWAAIMnxBp3ESjN7dxPBghEwBgj9Q5LiTdrxgfwdilG4+eX6/D7h4x/CfAGMkxCHaSdxjQJqG4\n", + "AAVHKQ5iSTam//8zhhAL8AFxhooyHluMeer2BMDhxc1mEYUWfABQS9xEpvO3wFaGfwAEYS5hUJ3P\n", + "ztR/kAAEgABAFAKQWREG4+FtNeSbteMNc4o/NKWoZK4X63gIyFR7/MzMaqUquL6U/4bpEOglXqUk\n", + "Y0GDDgAeyAJwgrGW1kVjP/4AuA1V1AyTHe04cZ//hAACgAAgCqfwRCIRJJKLLWtDAUZCi8oKQt22\n", + "GM///2GYSgVyHFBLKn3mD8I4ACSF20bu/ZXL8REQkQhBz2cgeH/CCTsIhG7+9qQw/x+AUA8AvwAX\n", + "EGg70OLBygier2BIilzZEcD+KaX/YAWEmcVCN3s3U9BT5AwerIckf9AUZSqqgypYxgnj/8GQAATA\n", + "AEAIAhBoAyD8QZueQgRhbt4g07iJRm9u4ns6xGEAx38RBCde6hHb6d8MZJAAPYRYKKZjBSkKN/9u\n", + "ARhqgjeoxNqYBcNAN6EYG2lVlUt+LAAEGTYiYAwR+oclxJu0H/AMqOgfBeF5ro1veYZQf0TmG81A\n", + "j6gYZd8R/C8Qe/ABeQSjvS4oHKiJ6vfIyIaKQqOJ6UeAo1J2E3U8f4IaL/9YjYAwR2IJS9xu1HgA\n", + "EgDAh5MgLAjDlPeNiJtTGAAEwDAtxMAAAECIYGgIZzhNKVQfZ99+eAEcLUMRjQjoKtvB9NWt7h8T\n", + "IAOwlDrHQjBaEt37/+AMRQSIJSyaRR5IeBL0gwJpkHaVX3/8P/Io4ig1OeFFSGHX84upgIa74Aeh\n", + "EKUBxzxENtQGsjAdCFSTssaz/3zMzGqlKri+lPgnoAMSpu3E1f17gKQctTt3gMsyAIDtxQ5UH5TA\n", + "FEpM4rtT53Gil/+4QAacHYh+/uCMrfhAABAjAAEARgeAARAcEgSTMqQBAiZshYnPf/5mZjVSlEOb\n", + "6RzEY8YRiPCcOFgIxqHukwkywGiUM+kuF+oq2833AjIJUHQ8p5jT1e4wyg/ozDebxzzvwYY/AARl\n", + "0ZeR1kP+AD4w0UZDy3Ger3/gAOwlzCoTufnaiNRmohAIOd8CwOuPCocyH7vgBQS9xEp3O3wFYGfG\n", + "QYvVuIT2enPD8N0iHQSr30kU8usuyAACQAAgBgEILIiDcfC2mvJN2vGGucUfmlLUMlcLkAAFAABA\n", + "DAIQfATGyJfFOmLPg+4et3EOE+AHHTwN9c7VbHngShfj0m/m1z9/gBzMxqpSq4vpTvh/8AwScKeA\n", + "C4g0HehxYOUPnq9BT5AwerIckf9AUZSqqgypYxgnz/9nAIHgCqG/1pGmJ8pFdlAkRS5siOB/FNL/\n", + "t4wkzioRu9m6ng5aaAAsEeHAYbGDULQdv4MgAAmAAIAQBCDQBkH4gzc8hAjDHbxBp3ESjN7dxPFg\n", + "ACDJ4kNeJ2rkxGOyDD5jiJx/CfAXh9zEJhlO4LI/+D4DUqjEKuJSxLW8GH4jj+k4U8AFxBoO9Diw\n", + "cofPV6CnyBgtaQ5I/6AoylVVBlSxjBPn/7CAA4YAUqf4iCE691CO307oEiKXNkRwP4ppf9vGEmcV\n", + "CN3s3U8H4JQepEaSQ/JpV2uDDIAAJgACAEAQg0AZB+IM3PIQIwx28QadxEoze3eT3hUR2yOz/lZ4\n", + "f8qGHfXXXXfeGu+8N999999d4a77/Xff777/XXXgAAAACWHgAEAAnIvBvAAAABphBvgAEAAnIvff\n", + "AHP3D/Pf9wBx68f57/wZwAAAACVhA24ABAAJyL3xPAHHrx/nvlP3D/Pf+FObBB8eu/y+wYIvTwH4\n", + "AAAATWEBR4ABAAJyL3xPAHHrx/nvlP3D/Pf+Cc/m/+AUw7gAW5Kg1IVQyCfgAGF5KZ6TWqQmFRHN\n", + "DXPiddDpZgbsKm8DqLkCiwKCQnyIu/YZAAAA6mEBs4ABAAJyLycOeAFmDcxqUdWL/AJO+s4GcMcL\n", + "HExzsMuPgGGkvKTAAECNgAACA7mQSLPhxSgda7MoBd5GHQh9AjH7VG8yYniBPmiN//w1AAhFrI5i\n", + "6pzEzOWDwgCzhq6qbtB/ToJH2f+CR7Z0/rieQK/wib6///m8D00wI4awV7F0eMVHPr+32PwwFdFw\n", + "8pK7KZuXR7MCB5An/n+YAjFg2W+RAYYzHmxGXeMQMZbIx4YHXLtf8X6iT+G8BI3ZtTf+CFqrASnW\n", + "TF2YXiI3w9eVOHaTCZu23z83JiFrAg/H/ER7TlvwHactyQAAADBhAIfgAEAAnIvHifg5rr////E8\n", + "RwA9nX+H/e/+AG731P+rf9/gDn7x/n/hTkx5MckAAAAiYQCi4ABAAJyLw9yeAJ3vp/33ywBT98vf\n", + "9/wp3QMEj08ckAAAAUFhAL3gAEAAnIvDHNhyH+/v+J65uAv7N/7BwF80t4vgPTbpPx8ATvfT/vv/\n", + "L+AAWp3fc//+g/K/gP9hl83AEJuck/PfL4AzvdS/0ubgCJrc0/P8XwHAXRpYHAXRpbBwF0aWBwF0\n", + "aWiP4vgOAujSwOAujS2DgLo0txHiP4vgOAvmlgDIjti6Id5hev3wf/bY8BfNLRHiPCmAAjMjIiMy\n", + "IjIz/+AA+RmJcUgx7eUOw8R4j+L4DgL5pYTKs3+8eAujSwOAvmlui8HAXzSwDO/XDn/pn8/fN4BL\n", + "u4P/+OCcvAIP/h/3nvXNwBl3fD/h8ehP83ADB//n9/cNvrA/2w3xcAOP12ff98MDd1u+tzH7cH39\n", + "EARWzcgPN54rfrk/3Plhl33z/6+PDrm4CD/gf7Y/fLwBl3fD/h8e+XgBX13Q/4evD8AAAAAKYeAA\n", + "gAEcg7wbwAAAAAthBvgAIABHIO8G8AAAAAthA24ACAARyDvBvAAAAFFhAUeAAgAEcg7wVm//7wXY\n", + "ADlFWTi8xiRW2fgAJTjWXIOSQOb//a2vGRSA9yf4EJEYQkR8CMsSK9wBf0YTK9CbgAQfXfd/+HAY\n", + "l0yZi6OH4uAAAAC4YQGzgAIABHIO8uB9DnigACB3AOECzPwLTNpcAXTMBjO7V4b4DgAggsJpmA0I\n", + "kZ4xa95PYIws5vieJN8f/gsgAV3hFEm5IeWx8GHAJAJhIL2fwCHTcPn/cABu2bY36lV3UMOUK/wB\n", + "i/fHYGf/8UvDWA4AIILCctwFhEyOGsnzx1TAlFVaX/DMBzbDRCje400CQYckJbMfkh/YXg+Uob/i\n", + "T/BzDnOAAE1V4S4d7fhd//gDK306r3+0XAAAABphAIfgAIABHIO8IQcw1hluNB5YA965el/BPAAA\n", + "AAxhAKLgAIABHIO8G8AAAAAwYQC94ACAARyDvBSI5RGHctEeFMABDdnZmd2ZnZ3/+AA+JymKgrDA\n", + "tHXjmHiPEcHcAAAACmHgAMABnIGvBvAAAABUYQb4ADAAZyBrwZuJxujAGR+7H/PUEGaOnuR5z7e8\n", + "CKmg8GiwXn4jxwx62tkVsPwx6ziWozfR3fq62ftoHygSfx3+7UOo2UmdlE4gw7LdjCRdXYSAAAAA\n", + "C2EDbgAMABnIGvBvAAAAUGEBR4ADAAZyBrwVn83/30w7gAOLO8ih0FFNDkSfwAD2DhruhAUWwcL/\n", + "/vrD14rEsC6zI3Dvv9H7BeEFncICQpcAR/QzEj78APNtkMZUfvFwAAAAtWEBs4ADAAZyBry4HkMc\n", + "AC9toiQQCIGOADvQ4CLEQSAAICYs8AAQXcQmIQABWAk4BGCQFUFKaAjdu1YAHTk2QaSwTJMw/DgK\n", + "qwIcebav/EifgQcod/gAiNp2tof7/tv//bCB45/xRkHh/6DUBca3mKC3rCASyh/2Lgoqlc5jgGOD\n", + "/niCYhAAeNY4JEDvK2boYSaX+Bi2oBBZeEW04zojQF88m0v+fij/AgwxxsEjxXXDc+mH4uAAAABC\n", + "YQCH4ADAAZyBrwgJ/hWAFotFdWI5NA6WuQjw8VQAeBmVpua7Saba059r8Bu//v/BhAu7oAPb6SBQ\n", + "VBvAg/jvfBNAAAAADGEAouAAwAGcga8G8AAAABVhAL3gAMABnIGvBSI5+XsGFRNgPYAAAAAKYeAB\n", + "AAIcgJvBvAAAAAthBvgAQACHICbwbwAAAAxhA24AEAAhyAm8G8AAAAAmYQFHgAQACHICbwWQcw5t\n", + "gAurvf0f+tevAC7611/a4Affa+vbhcAAAAC4YQGzgAQACHICbyF/B9wQQ/jqYrUxWpgBI9PaqcGw\n", + "UyjA4CAy4GDQeU31QBwgEhC8AO48iMd57gApoHqEUWeUI/17H1MkZBzDWCZ+zuvwkfZ+UO4CL9vz\n", + "wAMV2nMm1v3/9/gf/6ZQId42p/8S8Jw79amK1MPOghowaFEbEC4Htf1qYrUwAsImRwZRtaOR/PwW\n", + "gTsFQ12tcc/XuAvK5+6r/+cE1KbfgfjIOYc5T4+FhXgBWdL+bP3i4AAAAElhAIfgAQACHICbwib7\n", + "j/4LIADwbkMRR4+PwcT/uBGUhLTFwhZT1f/qKiYoiuv+tqcy8XVOPggAisaAuACd4sEhVUbn1+H5\n", + "yeCaAAAADGEAouABAAIcgJvBvAAAABlhAL3gAQACHICbwUhTDuW/85o5rOaOaAiQAAAACmHgAUAC\n", + "nIDLwbwAAAALYQb4AFAApyAy8G8AAAAMYQNuABQAKcgMvBvAAAAAYGEBR4AFAApyAy8Fh/lYbgAI\n", + "EKmcyWGYeAT8cfN/IjBFZBSkvOSUW/WDAdtUSoGFqCA6CTfYQwFfPMAnuBQNTW/3YIAIjWhAAEAh\n", + "JOAD3HA8GqTtOvwAeeXD0IpF6514qAAAARVhAbOABQAKcgMvIX/4OS8gLD7Bmb//F4d8EGAAEN/a\n", + "wAfE5THIHIQ8X5JDftMwh6F+novbD9AgAGjQEAAIBmABbwBa0QCHJ7UEQOHSALLB32wBCAjHHBp4\n", + "QNtQEw1oerFSdBiZSeveG/ZAAsgAgSJrokhGzc9CWljGfWmZ+A/GXiOhBcWoMWJ+DmqdjVBB5oRD\n", + "/6DWA0AAEAewAAQAAAsIGet/xgsRQrFE55yS+vzALQcsHoXn7BZRE2GGEAYaBAACACoBdDnaA4Iu\n", + "2r0ITVgJ6zrf4eIGMsEfOlLS09DqAOJkqH7viVf/hnzMOuZePRbL7fKtgw6AF/v+2//YKURSFkQM\n", + "OLP8HM8AVwAfGKyzzXfdf4qAAAAATWEAh+ABQAKcgMvCIn4uGYADgZiDlRpJJxmeCAj/3DAzCub5\n", + "splPA0//Lh9ubHbFyVo5Xf+fggAEV7QAgApizbgQy4F/+3h/A7pJ+CWAAAAADGEAouABQAKcgMvB\n", + "vAAAABVhAL3gAUACnIDLwUm/8fwQceaMCJAAAAAKYeABgAMcgOvBvAAAAKBhBvgAYADHIDrwZ8bh\n", + "N3hoCFuP9OANAEBSkz3SXRCWOcAQAQKF6k9Lbk9kSvONaRFCMzaIyN/3zA3zDvzp4MNRHhLGP7hS\n", + "s/J7KDxPN8yAQBtHmrwQYS8nGfGxOJcu+YaR8//4MMMBJEMRABWjcK2rP3fAVmoFGxbD90BlCya6\n", + "X3/YM2HuspY79ASO0fp+16o+0ge0lY/L6agpr5rvtfokAAAAdGEDbgAYADHIDrwZYkEHAI/dQAjz\n", + "ClPCRzV/0AOf7oP9esMUsfv5hO6o0O9+/PAGAQ/TCYIvHqCZqZX43PTsABsFGUa51W/9H7Qlwc7g\n", + "RN538MAHOjyrtXYejgPDxFN2/0ETt7qAErKx2Jv37rb2a0xL8/FgAAAALWEBR4AGAAxyA68FsHMO\n", + "QyiaNUNeAiEy8JHNgHQZpoq+7BEfaYBUB000U+nCoAAAAT5hAbOABgAMcgOvJw/jdKuho6fABeAA\n", + "aOACAgJvZlhkRuAILMMxRxg5Akk0bAAEJMBEICUpOAD+ALAckVadr+zgAOBPQAK2LgAIFDPWrXTA\n", + "vQ38A4C01AlPDL+ACW+AvzGUAp6wH3E5pvgQAB0DjGggABA4AAEBoAEgvhKRCcoB6A8sPf4JmEBR\n", + "r9ngMXgmcb743mRUMg5hqcxIHxz46wI28f6n+E7jvpxvDuN0q6fIgI+pKD1ColenWJfBBF0SUF5u\n", + "sgXDgV2Quhh1dKugBIQk1BRgGSgjytvbev8DCA4jawTUPcKrLj36awzsA8AgTLEU6AtC+8+8DPCg\n", + "idBVl0yBRysfDCAAKBjCggABAdAAEAEBo7T4ItcDFApgb/5BCePcswCrsKUs9/5+Mg5hzjpoXA4V\n", + "4B4yPR3Twi5dMVAAAAGWYQCH4AGAAxyA68JB3AAQADAgtVgkRJMKsFCJsobgAZF8lM2l5aIyYnyk\n", + "V24AAKxgPxYtpKz1v+18HMFR5JhJAtd9ft7Nt8UQoqvkhyneHhh4QABQCmCQlNADt2kg6gUARsnY\n", + "wC0Gt69/wJ1Elpvm42AFjyefwi7dJ1ey9/OBFJdJO/+9RkcnG/fv/jCrpdc25ZetLLzP3VFtasO9\n", + "8TG6ix8f/c/BE88bf8AXpG2tG83//qAEBAZ6Sxwb7niwrefcOw5tBAKQoAZNxfaeg89vdvYbdps4\n", + "+JB55EIvngAOv+7Fd/+9ZvNbRA+y2+OwihPhJxVlMT6uIC25tTT2n8FrAbHMwu/m9zswVB+4qcmp\n", + "1/+BvIrMi75uPCU1K/n9hjZcwiFSP275vDXCsAKtI5UI+7QAwQ4o9HTz/fMD3p+ltf/SL0wLqRxV\n", + "HRr/gBIfhwAg17UkF2+FVg2OEKDYwsuJHzdWv8yE3Pv8KctxIm/9mibgBjInLZqy1XexB14W9uYb\n", + "XvfXsx5mJmBB0SY6nE/gyCro/7P+4AAAARFhAKLgAYADHIDrwvobgAe1bL2Bzx7eguTxoynt//ra\n", + "yju8ZF8Vv994hv0ZzjOLLg4Y3oOFUVdo28+E/+7QSChd71hQ1zGy//egb3Tjizb933915O16/f/m\n", + "DUK88FEWb/IjhN628MKawwrEAC3adpuvffV6cQ0Tft4BldpzTdC5pGkXbwl4ZsDR6GtR/86yBMjT\n", + "c0SHeGjwBVjmqhOf//v4AAYKFZoVhh6XXiuttaCOiKqlaNV2uAAYcbOBWl3vEiVtE/+ainGd80D3\n", + "Rp00Pj9eQiL07Se8oVIzzab//+Lz0Zxu5wQvNEDDjAtuED0Y0fehaKmQsui6v9TRkpPATmGWLz3n\n", + "VMZnEqX/9DBqSHgxYfgAAAAMYQC94AGAAxyA68DbAAAACmHgAcADnIDrwbwAAAEBYQb4AHAA5yA6\n", + "8MLiRuAJ2yZits4EhPQANPsoPbkepH/luU2k5q+MARCzJZfstIZGtZfboT3fq3/1Lei4tCF5rPaz\n", + "7//nTVWZPnguN7BShGIEsdgznDr5Vpxf34zi9yzfAAenpTA35M//vQn7NNkq+6GBZSiE2xT5/wbf\n", + "EhfwAEgDHMGJVJ/7JaTVyvhGlgiKu72Lu/BFAAEALw4Z0bQxQLYM6vLyY4hqiHq9vBtNptN/ve2Z\n", + "sb9Sq7qEFZTGFMOxlZY8wED0fdx428fuKjYcwwQDy/RMfm/EjcDlSYDDlSYnMHLJd9v39hBUmH+/\n", + "8uxBUmJzpvW2ae1ir62ylemg6vcAAACVYQNuABwAOcgOvDHG8BK2nd3qp6WwAcMB8UcCQLINr0OR\n", + "a79ONRPzCf+IWtmb/wDmn9bT3/4Phx0po/mX5/AzHAN66CNwGAoEAD8F4BKDydVSTMbSvikfA4Go\n", + "MAIuoAoKZR/qwTJNdMT6wPx0XR33/mXwb6VMxz+AGIPp8ufsbTWwsI0VeAhtX8te+9rtgEy/orqG\n", + "cH4AAACZYQFHgAcADnIDrwxcMQALUuAUNesFv/2AyAwHTYJpxbTunlmAogi71WRxY79xLAHJgDqI\n", + "A+Rlb3gJMT3OJcSaIS/KP/AemVDv6DjdpEAAVAwSx/DAAYYRMDAAIDwBAACAeMDusyEgAsK1aVpp\n", + "1/BSJJgAz96T/wA7TxK3XAAewNQa+wMXlmf37g+HJXNV4BxqHFlwrAg+BBxMAAABC2EBs4AHAA5y\n", + "A68jwVQ5wGgAEgGCGiWABWAB6VwAylgJoclEZBCifABoPatA8yQ5wALZgAEnU6AfwEUoLmDNhuA8\n", + "ycsEPvfnIWYZVlHUUK0sAI//uBGYAVUuLPHiFTbe34IAAQAgCBZEIAAQRwABApAA4CmBzJGMe3DL\n", + "hD++/AkfCF+UMPaETfgCVaf3xPGQIP6p2MeDRBqADEyMkNBCKuiFYBAhswOZ99xteR//D9AJh8tE\n", + "FCW+X4DwwsXT5bIXCbcPLDPyACWhzsNXhSVAErA3wgEBGIMcNx4uTPz//wYYQABkHErhAACBQAAI\n", + "BgAgMW/LDEQNXFd9u/+gVMgVA4vAmCxQCZKff8b4qAAAAQZhAIfgAcADnIDrwkHcBE3ce+ABkXyU\n", + "zaXlojJifKRXb4eASwB27SQdX/ywz8AAKxgPhotpKz1v+Af58HMFR7zHkC17vvt+e3vKIUVXyQpT\n", + "uUIAAuHPLCpIFAEbJ2IB6DW9eD+Ccklzfy8P09vgAIwyCues4tBA9JdZT42lZj6NlXAykIUWcLVw\n", + "ANNfy/W//0EoAL5N6un/5+ApqYVFdfo7EosN8K9kAATMACcwBljiHHIIYGtFJeXZOUf//IwAAqAI\n", + "BJZM6B5RkuLxhLDOkGAARHgCAAEBJwANoAPJX6BWR18c42Iuk7g5dbyvDBQAGGMY8DDeU/M7OAmD\n", + "jP3vZgLOLbOUfUGSAAAADGEAouABwAOcgOvBvAAAAAxhAL3gAcADnIDrwNsAAAAKYeACAAQcgOvB\n", + "vAAAAAthBvgAgAEHIDrwbwAAAAxhA24AIABByA68G8AAAAAqYQFHgAgAEHIDrwWn+DmeYTDgKvS/\n", + "+wHJq5neWYAp2r1+cgpNUdDb14TAAAABIGEBs4AIABByA68hf/ghDHgAXo+0AAIAQAAgE1VgAMB+\n", + "+xgAAEBMAAQE4iAALD5PEUgoBcLgCObIjHzwyCiPyLYAOYNOEUWeQd6vArhdRkvIpBPmwUw3wCR7\n", + "gABEq+tuQQgJinCAAPgFHEMHMpuYIM3f/LcIOBLQEFtTJVQbAbUP8D63tLn/XPjBPwczzp8Mpfzp\n", + "8YoKMK4AwbkGIaLTUEUW3pkUw/GGYchqTBJMbQ4clLsMOJSEABFQPbLRxGZODJRIz/BcErD80rXk\n", + "HKMfcXVk69pz/8MxUAAICFoAAgKgAdAAAQBk2dAPwhDUoQABYGOOqv/BuHT/LONf+hcjWmmwAhQH\n", + "PPzBiRV65/4KMbBzPKnADILlPv++CFOdHfz/EwAAANNhAIfgAgAEHIDrwkJ+DmeQUAPcnbq9vs2n\n", + "PIdv3d/+Uv/EYb8ABAw/c4JDHFVedjlPu8FLDWngUGKtNBmAGwOWYJ7z3uiDT7CsADl5Zy9Vf/pL\n", + "If4YVqpqn7Oka6/hf9AeS5YAHXDqUmLjUo0iwABAxABAZAbo8MK5WPLM724gobEIRKwQF2KAGp74\n", + "qv+oV0Z7JG5f1gAwk1Rkd/0IQyVAJ+6biHB+6wzDBAgwAEDBf4kJC3NlmVzhPw9oSZsoA6VeXL5p\n", + "ds2EABBdgphctENuceSAAAAAuGEAouACAAQcgOvBliAvsKEwoeXAPu0rv/r+FadgDIyjru6KvUmf\n", + "3bACaRmWQi//6sHqeRo0n//142AB1AGAgUIzYTkzsics3NYZDgG9dEFG3W+0BUmZJmb+/wNbDvHg\n", + "2BAAEAHCN/5WlWF3uaEvgbtNAf9xC20ic0f//+IC5DAAIG7D6IUy+940jbP91AmY/9K+f9iKSlv+\n", + "/gIGelcoWEMpuKwtH6forusLGEZe2nmpTJ2iU18f4kAAAAAMYQC94AIABByA68DbAAAACmHgAkAE\n", + "nIDrwbwAAAC0YQb4AJABJyA68McL0DRgNAAEAwAY0PCcCJu7ewASAAIAIDlBSSDmXIRTVdj//261\n", + "GS4fhoIsIEgDjIAVLwSiuU+q9A9n5h9zqpRABcQAcIwBTAo6RPe70BYggjMwgRpQlxhzxtQBDauj\n", + "/n0wAACAmAAICcUABYb34gOiYDefjDMOQtJgkmNocNyluQVJgMOVJicxPAoAEV6ZGy54OcGSkjPt\n", + "4XoiXlS4nzB0z6nU49rac8PQAAACBGEDbgAkAEnIDrwviQv4A61bA/3/gg0VJNL79+2/JcEpOwBI\n", + "9TR/dsZcou7ugBduImbJ//9QlmZHEMn/+rzDbUDgQDgNF4Ia7meyhYQ8AAmA1Fy2AEthch8GuHtC\n", + "rEf/eQlYpAB2qtLgMG61zcbj99+9ANQCUA4+PIhFatZozGAAHShipav/1dfRkipbwEA6dEJVR5hX\n", + "aOEpGAACBeABgYEZYcCAwAD8rhVP3O/1RySczKXOhderrqb2HblmOIL6JnHf+7uReFQf0T6DhN9U\n", + "cGjC1kL/n+v6LPjqBkbdyhb1AympTFZm7Xxh0qHveBNugMXpykL3/PIg8kApMYOhX6q91yF97E6A\n", + "8M7Z7ezO0P/J46GdAg+AAVoNTUtIdn/n6VaNhBD14AEAUVZVKq9kukJJ0/74AAuCYE7g/C6C0kEf\n", + "4Ri5V9iAlB7I6R/2vMfL3w/6mRDzshKqPzIDweAAEJ3Bv3Z1nq0vW/YYh6iXW7E4Evz3IwxiX8NR\n", + "pHia+f+v6O/hgJiU9uAkAAiDit05+RbKCtO+AUAEBqbtD25TxNhSveDOMQ+zPla4Y/H2A1GKIVQy\n", + "BJep/v5wzOHJoPrAyKBLusqu6IWgCEiZioTM4gx//hx2uUAHdOe4st8kXPVwnd/0G+nFt6L+f/7/\n", + "D2ifEiPfvd+QBfjuVJHeafGK43xXn/+w9wAAAmJhAUeACQAScgOvC0SJDkJsDe0AfV1HTZ+uyul6\n", + "K8a201vkK+4ANins9fk///5CPcgB5gA1NuwTsuTX+zCAxAUBI4AwqXpqtWmLLIv2lomaBimRnL/u\n", + "4CwOCxOmV1+THCDRiHv9GgACIDRGFmPk7OpgAkQDGn/OEXpSQa6PHYDTg0AANP4gFpK1v4+BDBAF\n", + "ToEAAVwaaYKHLq2Ipn3YKqnWjAymhDw0HzKa0e0j6kXn6hsuDGF10wfvZYY0dgb2JWj92wCoBBao\n", + "MCLSKvPnpj9/tqZgrIPGor1rQAAgGpaBUUFRNIrv1bAAEEmWgACAqBUA8+UAIBgVYV1fvSCPfbpb\n", + "RP0MAAEBsABUwmCJCEABg9pSlBKryQNYXtFZq//89oZclDGCBoKLSWYXXAaaFDq7g476RBb6C0HM\n", + "9eAdU9v/gDUcrZ+3/g5ngCgC4Czqzne6vxAalWdes9IQIiQ5AAmn1X9f8Kh18aq1sMo7Ns3+9oSk\n", + "wD/gAe5D12kXTf90HIGFsy1DEABAyjerOheU/3lKDlJgBrQBZCYvH7wAY2k3qd+OU0asYDXZNNp8\n", + "b9aRyinxjjv2Gi0cnpcgaPRju221Q/4ZdOPf3cPDApfl5DYAe24qTk/8b8AUCIIQ4LYUwgQGynh3\n", + "DsIgUeVQwfE2qVnfUba/bt/v+X+AjCXXb/deYr+009s55EnvX8lpJaJsc/nA5fXqbf+gGQya2TT0\n", + "ic16ZiL5sHyNPRKn+gZ6EELDxxmaTf51bUr6IKQul1P+Hs7Kj1XcgdYSjbblrYn2BCM5734h54nt\n", + "/lm1LOdFV813//tJAAAB+GEBs4AJABJyA68nDHgAcyuYAAgBgACARN0AA0Hr7GcAAQEgABASmZAA\n", + "oPEGFAAEBGyAACC0AAIFd5whMRAACIQcAQxIzIXPB4epUDaXz2AFAD4FWUYSfVeBaYADNxBiIzc6\n", + "9XsCTDHJAABAPlAAEFoAAQL9aGgAAgIgACArEAAWCI+/D6/SEAuRggADQGFt5SQ3C9OalxvfhcwY\n", + "PBxgFMlXg9Utsj//P89cB2ctM71n4PMBhLpdJQ/7s8bBz+enYQuXiP4IHjvsP6oSGoB2dg/wkjB0\n", + "oEOv9YAO3rS5/9t+OZ8SoIMNfAXwgsGGhZOIgmZjB5/0MJTQQBOQ/g60xdj4hTn/BcAimA7Dx2W3\n", + "Dn/DPTCHkwWTiREFTEXP9/vGGYchqTBJMbQ4clLvwwgoyBAAFQ5pb0JiQbG1pb/9wKhijSQei2Ri\n", + "TIu//89STfn/mf+g+73T5k/75/xvDfgAOnhy5jFSupP4wuAlVP7yiwfvf89cBbkPdMf/5/+TjYA1\n", + "epG/v5ngM5PwC2K27YivlDZZv6f/AC3bS8hDjVAaaXMcxziQvH//3YCsDGJHI1JI2iy5Yj/+4GBX\n", + "JYsRPEtsRqn+CSQws0AHptGziQuCFt9tQGzcUb6i/voBF8pFE9HQADW/qdv94q3Ko8Cm/Uftf+vy\n", + "ndUyX/1EgAAAAixhAIfgAkAEnIDrwmHcABAjmCLUtRJBJCySCfgAWQ7SCiEi4dl3Aw/oGEkEtNiU\n", + "p6+/+EBKQoC4AF6gvFFxpGNOe/BIzab+GfABBEuK2x3ZMFYmQd//B3aML0RK0JvvCABOKsANgbix\n", + "Ev8XBd0fwf5BSWa/k43ACrJn63v3IF00mmTMm+8AAEAsOakCr6KJTZ6pu3vEEKoSl531Z0Xha24M\n", + "SkSiT7mx3IS+kYTkXwBAhCizGBdQBvhSAMTCKyHE1JC1NT4fEAdGAo6VxD7JJYsV7wAwCuQKEU6S\n", + "63vZBkl/CEXgRHyBLh87BYLxXth4l2BrfCXolajmPAqALEtVZv0gBRcOkq7f/FAaM3myphmJhqCB\n", + "9dIBnUfmx/WAONL9eqs72bP/N3cAtgAlK+Wv0rf734ALZABtq1DZbf/fNniywrAkz0AM+2yPIG4I\n", + "Df75rAAEAkAAQApUFoLngxTT9X4hLbC3k4G+GQhVxpw09LGbN/xabAAD6AGDuiSJNiZJAA7+G2LY\n", + "IH7i8BtyGDxvusCYRWn9g3xrGqy+nz/BBIQTLvk1IR+vwNciYxHo3v++G0n54erGpnrxQBBuuyea\n", + "sksuf//vcBlkjQk/feAyqG9Do4xR+C1yJpTTDAABAbAAdMJi6bHf9gCYRr+CQL8+1oajNpoZYcAG\n", + "qIPURKkpvgwOSEAhfLNB0D6CgPuiFMv//5gu2Sm5r/1vPNBloTnhXusMCIQnTQgrKiQ/7/JAAAAB\n", + "mWEAouACQAScgOvDHCsAHSwtS70L3//vwABAwTghXZGfHyndO+BeQ2kWxFet3AAIECMEq6fl0iX7\n", + "tr2gEDMlRjvXATt2P/u8AAEBB2IABm0Pt2XIpqd8w4yA5dUS9NJpHgBg5MEtYiuygIKfs4AFgIbY\n", + "WUWfv0gSGpMOSlCYnvW//7WFBg0E1B25BChzJp7p//PG9JfiPxuAfWUcH3nAecgqrd39O3d397u7\n", + "uClg0tPzM4cWn0GGLrtafemaXwGwp5OQ0VAw1mGwAHDzG4AAgAAg3+JH74gi/xgABUBsLlib2C3o\n", + "ADRqchQMkVlhdqCtzAADgABgBgQltWiG9sYx1a3mZGJwBlfWNA8coYgCzlAAQGGscbEtVa2/GAAH\n", + "Shipb/Rg/SjsXMWcKU/934y1SX3KaA3VhhlbCAAIj5YDAAyayH4TOgdL8p7mNJ1uqYAFfPYAVe85\n", + "l+ZCYCQthwDdf+xUihSMwJnfdgpj6TUpbzjYB49yXhm67ntK3Xndu7un2gXb8t3d0ULPj77fH/eH\n", + "ollpGd/77fP6dXcAAAHKYQC94AJABJyA68MYgbgm2n+gBqVtqxFf3LkpmUxx6YFntbPpY//97i+j\n", + "pjzV7vsJrz+SDV+9qV+MlX1734Ftf9u3//eaXfdtv7H/Br7UH/fmkK0/OhH79f4JQaCAALBFn6eo\n", + "XJr+UAAJ6RKbEByJlKM436cdmf3/5wAXy/qu///jhv6M/fRhndJ8T4R/U6r/3+N2+TjHJyn9eBjT\n", + "eKX0bu7vY7ez/s30fsbu7jqRFKWzPm8+Pv/jbw/w09iRvgAJDAowhrLqe4srOCTn4B44FIAIQBjG\n", + "byh7yJf/VAAAgI26AACAiABcQ+tfCKHeO1f8OVEomqdcA71LYW8jsmOo933CDcQqNkSsKUU64//M\n", + "AACAj0AAEBYADYgtGr4DJneV6uMHPioQAKIcIAAQABRKwFmfELKVWY74AG1uI1pD+eEvL95nuwbN\n", + "AKnrjoWkASjGmUoqeIprX2kQAHgy5DXjgj5muYDB0hYFuE4i0HKAIMVoTYh5IsTKEPG7GGCAAICY\n", + "AAgJxEAAWHxujd3fxhmHIakwSTG0OHJS7BjMWlLAD2aNtRNF+3hW/biVAsAEVmyNlnvnBkUkZ4Ti\n", + "9ES8phfq99M1U6nH1bTng5gAAAAKYeACgAUcgOvBvAAAAaxhBvgAoAFHIDrwww7DUbR3AAoIHfcF\n", + "ByhMTvSKEIAHMHN6ENgquD9gHVDhYprVFIwPgk7O3hGTkCBuqz3fAAhSHGzAAJnABQQE3Ui8yI3P\n", + "+BCYawBa4UQ9VYRhR1KZgAAgIAACAqABgJy2jDFk48Mnk8XPlC9/jAABARAAEBUADwRlggCe8IAA\n", + "QBQGRwAx7fXW4QJadh17itQhwYS5ltHOUjCTCalutloAFNkJO79iI78AAwDnKCHThJL5NR9kz1Y2\n", + "8KJ6ieY/gxWlC00TKjxrxyhjULbD4YYNK02ELFjkSQgmwN+IIoxKkGiOqkEWG1Q/GDOKS1ZpqyRq\n", + "KqqIZyIBYrpucr29tNe/iJsxZ+jOvYOCIlV6xafvDUSJC/9mAAgAOADAbFCbMDEXrZZoAAmExzjq\n", + "OKQWFpsOM+AAEgAEiCKDIP0B2CAM5HgAIOgN7tCSRtg9AXXOz+iCBCVhouhnyvz/5CGSSvLW+thu\n", + "LKOXfd3BCSpfGciv706M/pZHl0mbrYN9iltZUd/SgithNKpD/dfOG+8dOmmpv0hIYjDTMKi773it\n", + "oe+inHD/cAAAAVxhA24AKABRyA68LxM9L4Ag8aO/fwTPD8aAGcB6UI12xEv2IEhbgAOwBIKJA/lj\n", + "DtcbEGoj4Eg4AFgQ1gPCa+SmRQ1TOHlvDE9BgAQlMAmGLF/5Fo0OIp4v27gwX1t+uA7ogxrJQa73\n", + "yZGMto+a0KwFl0+Uhq/9gx+8TtmY5G/vPQ9r/kvR6+lJX3Pm8MxIkMa2NGABaYXVgSCNltH90BYY\n", + "A1hOUvVTsIVs4v/+EAozmH1hI8KgA+wREeqnI1ZbTjgl/HUGQA1NtD/23hiAoAAgBDv8aqw5GpSS\n", + "Kqv4uAieAAFwZ7gnGS0lFbuc/8GAEgCAgnyMSFb2K8lpn9oAAUA6hvYNZjxLqv794CAKYWJk8kip\n", + "TSO7rcMAIOYFGKztPHYU9BmHBn/hNILCG6UV8Q/f++gaKCwbyLmcTP0NeGx48nHwHvr7FHXi2eS/\n", + "sfPRSniUua94ypVD+8sDb3AAAAGSYQFHgAoAFHIDrwvw5gAJpgLfKDvEEpMkWvpjFVltOIFkdMPM\n", + "pjwBV1Nr73pQAP0aF8UsIxf/eX9iYmIBBABuiC9EQpCL7jGWUtjzhTZJvDGogAIECJ8kIC/NdmV7\n", + "hJs9BAYIgQgAEQBLxwW49miCjPSKyEDGIA4hAAEFFgtgIFUiFDfRwKZT7gOhJqZF+AGKzr4CMdXT\n", + "x//hClQFl+zBLv8w3ABBeioWlhNtQ3lfp+i7+YZI4jIbkyAv7TjeIbNbD4m37zHrCp/gQRJ642L9\n", + "LFlbBBOw+SUTDmO32AdeAPAq6Wr+f/huAPjGZlIV2FUf/v98AUAghQxLXiVJLSs6XDCpu/AH7Mh2\n", + "k4nJ//W//xAegAMCyBmAJUWkk0D41qL/tmMquc6lHW1awwwwAEBg68LHhjmijDB0h4dwyn8YFWIm\n", + "IYAYIwYLZ0zNn+WlJ8/AXbMwjCXNuKMRNIvRkvUDw0J/Xha3tZuG/PcAKmllSe+/vBz55527/O8w\n", + "kTYciXfN1g7T41rX+3ypBlKnL275uebgAAABF2EBs4AKABRyA68hf/ghPX+GmBOGZ5hCpvBEd6Yh\n", + "hjbmwD2yQysbrwSDszQPbl/Xo3pUNE/AgiT1AGyp8/xRbt36/gC7U+ngoTef3ef6iZ6wBsI9lh//\n", + "n/8SoIPXngBCFmyM23qett2eDlo0xd2OUlYokEhRv7/n4078CDqJhzwA269IMQkAiAg8AGRbkptf\n", + "/XACabaV3/++8bABQ7vtPLv/2gtijR2H/4U/4H5/6nc9A2rP7fh/4AxDGajCTlljOrMph4AX62vn\n", + "n8QeLcB9/UIwBmwAP1zPkVpwKAstIC2XtxPwAe7/SZ/MBilJEaNW//115/vXZPZxL/xGFud0//AB\n", + "szAvB8Srj//7rS1GDAfwNlO2P/y8kAAAAhlhAIfgAoAFHIDrwmJ8O4ACGAT/CLEbGrmrETdjcACy\n", + "HaQUQkXDsu4GH9AwkglpsSlPX2gBBEkFboR2TBWJl/+Dq0YXoiVoT7//8KAB4CiUgAL1BeKLjSMa\n", + "c9YG4sRL/FwXdH9/gkZtM0ZJXpv1Ew1AC9e/sRX/83bSsMcb1T7xyzHx1e1gZaAIVABwp775pvfv\n", + "wAcFvet92/vNtO4l/EcwgbeB32h9SgYiErNf7A3pTrDZ+ux/FfsdvSN84BykfT9/v+bWvs0V34AD\n", + "oMSTzgqGYnyp4kVv8MABC5xMjZ1NQpsoB3QEDTm23989AvaKt/w+Bi38p9/DSqs7be/V5bfUqvGi\n", + "MboZsp3ZL6pXnW1L8RExOH/QMACjoS+/aVdvDwwAEBAiUvCAv3XVle6TbPfWBHABwEksx8weYLm8\n", + "8MWUIQCwdjgrJ3/n7SpNvoDq9RjxWN8qAYomD8SHcf2K9gJxD1VL9mHPFJoNcK3bzeP70iAUWLwA\n", + "4MJR1BYuuTMe6Ofv/9yMAAEEIAAQFQLBCWAEIMvSxSjOdJdTywkDLQSBchvdGtDnywuHn9ypYPoM\n", + "vfb6BHk4fh+AO/r8PfBBhgAIECd5AQF+K6ccXaLl0GxQgABBDtgAAgKgRAEOX/AARgiClluGLYTL\n", + "svOM1xu7x8ImgOABoik3JXEyJ0qNdzbvch1OSBiZNItLY9Ye0CEfrdW7fXhN31dvfyQAAAGKYQCi\n", + "4AKABRyA68LziArgA/WuWzT/vygfEbSl7n7mHCelEmqmbf/vfCBgcoVFWtF0dEB4n/UDeO7eQJTv\n", + "7/tGgABAFAffEODVmns5L9wQFWUK7ADj1rdf1SAAQ8VSbRlNVve7AB2saPdCT3ZFmhXnLjjF2V7v\n", + "cAACAkgcCFly0+3n5jZDoEg2lRUD53nkAhjBSViXuSWk3YrpBCcI5p7FJMTr/9cAACAEA5VIMWUK\n", + "QJ/OIr/YMPFBSZxzI1v/zwznHJX/vanrcooQQ0G85ZC4WYSpTuv0BkfFcWJvv3/9cu9N3QIbavM/\n", + "YCxXW9NGX/3zlEneeOgSymdHVgaiZ6LHADdkRur89+ABWICfzBXkKn7vlLaC1eHYAWBZev6Jh/z+\n", + "f1UQAHEDqQHkoC8i2p8cVFXwMH7DYc48HECfHjIfFFxX8iMR2Q5u4yWLWe/EMAfYcxWrfK4Zg0WC\n", + "ruM8t2y9GH7x4nYr/x//aISs4eu2y6CaPkA9k+DI0IknnEHovb0x8M4v/33e8sFXuAAAAXxhAL3g\n", + "AoAFHIDrwxEiA1AA8AIHhMKSi5R3v/20AAQHCCQrnNDkHYqoC4hmmrUV2c1ZZn/uAEA4VTJFtz/S\n", + "sHl++CmRwAAfohzpHj3bAGZPdyNTa32ObJrX39Y97bb39/8ES40CCofJmp66n/6ahESyVjavEMLX\n", + "jbsDznDT7x5gMGqq//v/4tFfvrG7w4f4azjfAAfIAQAOTPhhomxwuuW+AAdBiSecFQzE+XPEi8YA\n", + "AICAAAgKgAYCMt4BDHDEupspKcKkxH9SNCvzIIAAQCBN5HB1ZHSn+G5CUEF7AAWUAcKPp6lARNBz\n", + "+ZvDOmIOAHcpfNgurtJgcMIHJggADBRWhkfq9NCjTquWqwOdiVjxi2aM9GZBtmzs//AATRm0Jpyq\n", + "yUHQoheOPLXSO+7gAH+IBWHhE2XOAIDY0gQiwv9v8GG/C0AHQI4hLFGmLJGIqKoht9/+4/wIMvyx\n", + "CS+cJdTyskGGwCQiLM70dWWRV4cy3o6579f23yXJ/3g5gAAAAAph4ALABZyA68G8AAABi2EG+ACw\n", + "AWcgOvDDEwhC/AAaAF+BgJ6oV9QKgjurgpcRcBgYAwul8QRifK/f95EIZSOKOUABRTjTguM/gAgB\n", + "UlqNFBdBNSsfrBX/28edoAAQgrAABBreAoACOEFQAOCAm37Ay0YLCNpSSyOfxF9/diuAmJisAUGs\n", + "ADCPU3pH2hBlsCcnzWSbQ837fwKTkaMXVh7Q1HT3h67uWmQIBI0vidx+FvhBA6kQFsFj5MQTPP75\n", + "+AAIIQAAgIREAWCIkf4UDhW0U0Hgkyp2zWkoYQmkEAASCLW89afkG2wJqYx1ftaeQ8xc7AfPtNlg\n", + "GAs5IaGGsIjfMuH5qYALoZLUz1c5AEzSqOjqr7ukeAoGcBiySOcqEB9aCHvAABAHOANJRryoDXQr\n", + "bSLk7wAQQUEYeZPEF8bKN6OfXAAIEFVLeNYYWIJVHOMF2giNU9gQEOw+BAHgAmdsqQdBkf/9v4Bg\n", + "zivADgecap+MotMw//eG4fzgBA5RBEvxIjLwq1DFYFv+DttbLTOeCXZnRlmLop7gAAABYWEDbgAs\n", + "AFnIDrwvhHQkSeGIAF7eAHACkwDYUZvfgESIWzMjGRiIALAyHIFfyrSURbVh8wZTNllYhgq69UmV\n", + "Jmzu50gAAXNADhx0X0yEAaLgQAAgBjBnUwxgMC6Qw/MAvb0Amvcy/AX8vSe+YA9FgtsPNyY+9pBC\n", + "EdWeBLOMOPv1iBGGYACFTCWPIic9EpG3JWbUMOLwB0CuPv9vYGHAbr83tvYYcMxIg8D1gVfABZox\n", + "1IlSOnv3xvAAbwSyek1bv+voLwAk4OvKI6vEKYWl/4wAAoA1kyweAAkQzF2UZLVby/9KMBioOEUV\n", + "I/SY/wAUBQPTkwPppk/kgteftACygLeZyg5yMzv++CEKKEwheRUvWwejcTYYrqfv55cFbZXYy7/s\n", + "8vb9n+8Za+2HLnQ/M//W8lkwaQzvOYLQA4cdoACAwhpkk2VM/6/4LGwANCW2AYNVUg8aHIEds2xv\n", + "1OruGDBXAAAB6WEBR4ALABZyA68LRIk9N4Ad3N05zuABZFk+3chO6v3hzwAGwMUjcPMAQD/eWgyX\n", + "wfsFnBkpYIrNIspP/Kk7MRDr0V30NBsYEg3wRdrouib9z2k0AlQJBosglpN//S/miJYXgAWAZAFD\n", + "cJUWk3pWi//rgxHl46XHvGzlOX/3hwAHpllJvDNC/AY2mGACOFl0wDkEcIAAoDniAJ91I6lLTh+i\n", + "rlu03WUsenTUACuUOLWnC1HozesfIYBVU43+lUSDkdWv/ngR3AAEAmkLIAUHieyXfPUNw5k21gMA\n", + "AAgJgACArEQABYfILmESMNm73v8/wKJE4/r3va3vR/OHUgIo7SXWUhfXuoLQIPg58QQL4ADA0QLO\n", + "cbRJktIXDgBFxwuyubtQJALUBkvu8M21beARdlL+QC79fS/aC9Nr01//v/lFwNcga/IyEVlMLiXJ\n", + "WpMMoC4G1sIv9RTyJKlL/99ppsm2u+f/5fG2HL5p/he4EEAeweRVOL71pOt/neDLQQJHY0F+Nwun\n", + "BjoynNVE7D8A8C6s/h/2Bpiq/SrJ75W35gEg0zWf//7oBFAYCG/7Nlid5IVfriHgi78bD+Gb9asz\n", + "HjDMOQ1JgkqNocOSl34YoAhMzY7XF637ichrof9+vswNJTCqpJOD3jAUuAAAAXJhAbOACwAWcgOv\n", + "Jw54ACBKQBzUqSAW8ITeFQJAwhAkYoQABgDiWuAGcihQ+kELzgAObI18ODpFDVjNz4b8rYAAgUgA\n", + "CB3MgACA+A7et0IAUIBKQmHnIxshee6F2SA2wVhgmKLXm8fAg/qnbUTjYAPk3vlXv7M/7ROI//VV\n", + "nexhQ4ktTYH+Mw1OQEH/Yk8GR7v63Ai/76gX860t//zvwYDqz51/hs/Xf/QbuDDIAAklbmRtfUsZ\n", + "ceZ/9uDXlK2//26Ps0jNbhjgIRvejWgD0rZHJH/bB41ukr/xtBvabdgq/tmuZ9YJHxzhYyx+JWPE\n", + "rBYxRljFGD2zJgfd/u/UCNM8Up/zcNfgCFYwdzp89xIYyH78IsMImRhAAIxJEISJ442rUH+IbKwK\n", + "Z5QPUKFZ/wz8M4h4hlUoVFTdegRjNdGFYcB0ILM1P82w73Odf7cCRgiHCKIJPOgvj/WIX+vD9EdL\n", + "4T8HfuzzKfGwoAdbVGn/DflgAAAChWEAh+ACwAWcgOvCgdwAECOYItS1EkEkLJIJ+ABZDtIKISLh\n", + "2XcDD+gYSQS02JSnr7/4QEpCgLgAXqC8UXGkY0578EjNpv4Z8AEES4rbHdkwViZB3/8HdowvRErQ\n", + "m+8IAE4qwA2BuLES/xcF3R/B/kFJZr/L/EYkQeUlwGiU56fAYJWL0wGPf0/5eCCcMBj8ABoOcEoj\n", + "xcFMOlLu6CLAAWfUFHCqxNcp/e/AAcJoACwlMBJwowWZM//hLEMBJQ5X4zlDwFlrJIf/8ISurLOP\n", + "nUR/9hJXvvLCHa2kbH0ZCuPuIxkZBp/80t3VEuGNj4k0Y7taRDv/+4BA0ygOCPlNerXzlx/34ZFh\n", + "hwATudt0Cqy4i0xq73hClYpp/4EImcIAAgByRAczBHLIb7oBxiZd41Kphl//9S0YAdBpupu3/4DW\n", + "ACACksc8EPE5TM3/9ahv2ELUAHQRhiGIMEFRtBhwUu5CIlVA4e6TR/negHA3AtbRWqlZGDwxEiD1\n", + "gBRvtW6f/wFMkv82chayw88NfrBiEZZ5oCgf6y1Gi6wYYxISTKzeXosd/+3MEbFS7PvdMvgIyBZz\n", + "FyXTr5m6AAK3QCHik9Q+/g/l9SyyQ9DDgAIgTGCOC2FLIPDJTs7Qnkzru/XBLuCjUoAAQD7JQABA\n", + "TAAuIfLg/gBLtQ2KiLtAKAICC0lZPRzB/mLP/AwHgQADAuP4P7qyiYA+EPKrUo8AuMrdX7zA2tms\n", + "hejWo0TMA+jMbXNAMSQGRigKkjm3L799dnIP6IJXEha3WvTTkAAQEwABAVmJAAsPk//wAiF4BblK\n", + "IYO402fDCAtVCBdVcs2Rivdn6SaHHauE1jX75YACQZhLqLRVe/N24AAAAdBhAKLgAsAFnIDrwvEi\n", + "DxMOBDAAOGU9HTeJiamX34ALvC3kv03f/0oWh6AA6gh4iRUYShB5X7ACqEsGTNXWPb9B2mTTs9RI\n", + "kocK5b54CYBw2dbuKJDHnE+JHwAAIAJwCioluCKXNVvfEePMGUKW/TT2kmpW9dgQQvh6yRfnn9Xw\n", + "fgAOAIHNwoQmjhFPnmFf+MAAEEMAAQEgKBGWDvQYDuaAMbcnfr7nNl/1AI5i8Sb1r/11Ob8quOhS\n", + "ruVttmWRkzb9ZoUSomKj+34CiO0U2Ro4UGTlgSvsXfCmYwW8QnztJEqfT/g517uH/F3/wBzgyiRC\n", + "o9Jrr0oJ7lv15dDlh42dkn77wzz2YLKLVYKAFkxWyLbxMOvr+jKhsABxIYE0jTfSsYcpz5TZJU9o\n", + "fhhhMF6Ek+bJrFwABzxOwTCTsxpABlsBw5/58gnszrxBB1oALLHN2TYNwE13BAJe6AUnRGBEz75r\n", + "/wlozO0wfGLDAAWmfESYasi5HNbLTdwQAwsCAAEAJwDJCLSCSaCj7UmTngISZ4p/tKL64f/LGVM4\n", + "qQn/cxKH7RgGYO7WIBZvFGR1/jFtwITGh7shsLRheMneCGYRyQ7Ndz/1t6gwVq96P5vD9wAAAadh\n", + "AL3gAsAFnIDrwxhAK5D9GAEmRToXUacbCp///AAAgM7lVAABAHcO2bzzndwCHRb+tnwQktxP+4Qi\n", + "GsoE4RXTUWoCmELlBIA8AMa4uvTeRH7e8RwQEAWFfbs2sv7Q5uzFBdzhnuh8DrlO4778Hobim0an\n", + "qG/b6j14SbbpjuO+6v9zsGCDjAU7FtcNPDQsb4ALgAE7AAoJCDydeZkTgACABKQwAF8JfOyLCgmu\n", + "fhD9bIIFLCM10beLuAACBv4QT1mp0VOYwc5P1TX0Vw5wsuk+gJKm4mJMBMMHZNEhi5QTsTL0kPwg\n", + "1y0EdfzLyLoBb4CLRg6HJhjSgDIDxIUIPwuACHCAASAACASDgAVl56JGY4DeBdAT4tXAoNmGZU5P\n", + "9pLDVEUcuweAArIb+EE5pPsdxAS8B+JANYzouuATARdKIepHzkd2zQCIMSR/4QcUd9UcG4W38WwA\n", + "BBAAAEBCZAsEz/nv8CYFCP53xgMOL9OUr0Phhg0LTAUwWPQJCCbBhwiSQQABMOlIxMQUpjf33937\n", + "2x7+fNG0YBgL9aGh8pELZiIwnIUGDmAAAAAKYeADAAYcgOvBvAAAAXthBvgAwAGHIDrwxAkw9Ro3\n", + "eACsYm+OOVz75wBQEYQ4QJqPqNmRqKcynDAAQBiMaO7w+f4kM5D5+EXGNQADDj0qOhQXbxrd8ITh\n", + "AE9kAbcdREf1QFcEeEUdPIKqiYApx2sz/dAUAnAUKmRSEPu/3ddqzAkQtzkF7MHERVvwfTkwABAp\n", + "VOjgACBuAAIDNQEwawAAIBsAAEFoAAQKE/PQZmTHAOFjKYRZzF69//iAvCAAJgqlO1ixI8/A7aNg\n", + "lOO1C2p70JgUE3/5B8i6BSHBKDx4w+SNBhqJBiGPAAcBC6bsMOHN8yyqS/fASgFfyhwTmuc2MDUH\n", + "7hiMOnmmKEiM5wTCv8EAARGIeEKI8fAAIQNG+/hYAMzXWe/xhoUnma0UK/39AkQAHqwE1Sgt/zwB\n", + "jpa/n6dG6AqLWq13BiFo8AAQQwABAWAgE0zABwxCxaVN4WTS0qvZMMP5CKM1HEnNNGfWZVDCqggF\n", + "ynhLGuu1jxm9GArjAxS6as568b83AAABoWEDbgAwAGHIDrwuJ+EQQh7AAQIBDQt8UE+HLLhS1xI6\n", + "fYfgCBy3jCoL4aWWxFzZKQ+AIDB4/HBXCgtXE282p2H5g3KFNLCVbpm3SpF2GgMAC4AZQwewSjif\n", + "29kt/gyNUBYBHABoy+5aVAdi0VFv/n4RRvkj/egAUhsvn2uVslVbRVrPH/3AXBOVmVm7w4pCsIIL\n", + "eBOAAIAdjexwE8FDWJyKf/4PgGMaeKgqSRaqZF41/8GHAEihxyVGKMrpLr8UyGELbCTGs/szTD/Y\n", + "N+vff9/0b0O90U5wO3HSzInb/fhmEQiHPABcTIPOalM7nvAB+rd9JPfWIEgvx4ABQAYHFEwACOJg\n", + "IcRWcyDL7DPgIGVJgU09OuatV/3Bhzta2794QLOwQABYCiF2gcYLFBidlCdgLAY0xez01uuqOJmh\n", + "RYv/r3wMMG1ll4KrsJv0F4IWH/aEisW6o15ViBgWmAACCGAAICgEAimegi8APbIDDpZQqoZ9/f8A\n", + "CzKLqdf5Rinuzf/+FSQQAirXR1sNZYgvP8tZ9BiXd0oYtW2fhvvfHD8vcAAAAklhAUeADAAYcgOv\n", + "C0IiT0p/gDI9X/tL/E4gSGpAAgBJHsGbORPxkToYrYQonBIdGpAlyXuko3OZQh08QLiNCXT0+73z\n", + "gtBU8plvUIEmh/7zDKqikpeet5bwQBD4ADj8YAg0WoimcNTlQX3GGOvMSGqRHZV5WZ22Hs1YBOGr\n", + "WUxgvrYKQYBKoEAAIAZwDICjhqv7qv7uxhkzVtrnz/8IwKrDnEmlQepHLk6Z+aBxZoyNcrvUVNQa\n", + "31f/NoDCAm0EqkiBu3SszUMEq4U8txqxHjECAzAAcJgA0Hk0FdYL3wUCv8H/RJgACBSqVHAAEDcA\n", + "AQF6gJhhCbMIFXW294okrFb/gw+Wd/ImpKfvBhwsf4EESev6EEbP/7UL4AMMyyDRnRP8ACwQch6t\n", + "kRp+mIJ98EqymWEAFbNOLGm37RxtbQP13nh+BVwOvI0NP/QGKrcYfF9vz/wBAATjtC6Us9C2Lo5x\n", + "aqFkaIyOYCYgM64QpBInKSiPhEAAEAgivwoDK4Ect7xWGDMwYAlIC2x3+kKijnAASC4me+3/FINl\n", + "3mjIvd672xCdcMr//zuxoGVRUe53of8BvRc8edk/vS+cQsIY2eUPAtKGNZpgZs+TEEif/X5dp+S6\n", + "NACANl0CCGDAfRrtOajd9wAdHz+jpWv//+/hJGQQAQVxdnhzmczvVdoQAacRdq215wAnqSOhxrJF\n", + "ZGQ0tb+68QRANdqgJYIqKUUwJaAFvAg2SSi+p7S/d3N5PQO7ar9/eG+AIA8FsyCjQL6zwt73MbxE\n", + "0/q//3AAAAKyYQGzgAwAGHIDryPAgQ5wAUAAkYAEHCTqZcQNHPQPnwBm8vu73AAfHsxXJuVGx+48\n", + "T8CCJPOhfGzNO4/gl/HvVF+f/DWAAgBFJwC3CEywdxto/DCJkb4AFzSHGeONrWP3/He9g4ERI3wA\n", + "g7OT4XieE0HZHfwOHAhGsZfhW1nTzcNceAHb8hpg/C3ElTu/lgA4RAo3eNKOpQVa2KvfPGfghoVP\n", + "dDxcRRJwOjFEdabJvDiQX3raHqI8jEGYp/O/f8r6AbYeE5f/7yDiC8UkP7eAF1nh7I36/64hoAql\n", + "bMiqr0mxL808RQegSAwpBjg1Fp6ERTLb//4Hlqv49IWxP+BBh+l2JPus+dQxkC8fAwGg6KRmFKjU\n", + "0fIWBckVDZX//qa42mFYGmOfdxPIxut30w1izRJYv76BKTbKf9/wBYAsBJIpvDieYgQFoAHog+rg\n", + "7vtUnv2g/4AwAACAmAAICcRAAFh8niCyEEivT3TzjGu0HOvEeKq94JwnF6Il5TC/V7zPoNQBIwPI\n", + "LS8Mw/MI18ZA0DDoVp20ykhLf0oyQ1c7l9XvhA/xAoMbwALAMTlA/kWsnVKnN/2wFB5mSYF35VBR\n", + "f/wYHzMsAF6THSR3jf+eA2W96lk/nHu8OeACUANTABBR8drYPmr0ARAR/ABjarekPABBHkpnojw5\n", + "wAWBgj4Ye7kjtun//3AUADBgrJGuiMuPFu7d8EJIYpWzArT+Ofxf0703dnLAKD1f1C+5H/oGx6KM\n", + "7/eaRAg0RFW7amH/6ZvTa798LocBriAzNNA8w/QQELQ/SuX298BHLyzR9r+oDOSifFzUf+9M0mXr\n", + "XIACAiqGLNYxe+A9hWP7I9qgnxEzSd84YC0AWGQchaThJMbQ4clLcGMFY1YwAZ1v3/+eMYQs+cGl\n", + "JGeCA9M+p3OPa3nPLxD3AAACOGEAh+ADAAYcgOvCgnw7gAIwABACVQCYE0IVIUIkaEYAFgYRiLk0\n", + "LhRJKhJ7/AA5DAFVP/KgF6/8MP/gYAAnA5EACkRmQPFCNI3vcBnFl8wlMWJmqr4YQ82MGkk+Hr+X\n", + "8TyoLzNWC60BcAA0AZClEIfautr/csMAfc6a5wwBTtOr1zkQS/mjQhEAvgAxiDIIvKJ0hvXICA54\n", + "KI7rVcY9/yw/eH5gH8JRkEyMq9+cuALGQhcXy8+m5HQlTaOJ8C7q9H+4PqW+6wDRxPBSJr1RxEQH\n", + "IACZEMroYyOFSpSfYW4cjBbEkyWdN5DMAAEA4Ac8MTAgKvAgADIxRcqlSbvIRHo+XuNzykFXKZMt\n", + "59biOQZQjEkvfgnlKIzXh9DRI/4aMBmAPE8KedTldA9pAYciNSMICqmBA2MQIDMABAiAGQEhM34u\n", + "xebHmCcdhhqEvYSzblWOO4cDBge4LSyljlQMtDQwxCIQ1xAV5cwAEwZApRIQ0yRG0LkqKQxkYAAQ\n", + "DvAAcAcHxAx99w/CSaCACcZpUoPxxYIsMbRxao675sIDHgH8DaTQaQyRf7xS/rERAL8AOfCb6PKb\n", + "GEJRr+AB8RBJjctYp37vdCDZsIAuR8bHLayt77/7N3OjQlP9aH4tRvtR/7AjLXsWSpv/NCGEZhCz\n", + "KS/JS0uToZFGTGnNNKsod9aby+kghTSnckb/v/DcAC4zEjLaoUoo3/14EhQHPaEGbFjOqcf54QWV\n", + "c/AUDFi6mKlXVVLDD2YeCbgAAAFmYQCi4AMABhyA68LwiGA1IAIAOZlQQlTUoJYpJhMaGeXACwAX\n", + "m1l8Z1/5fEcSIiA94QnhyMLk4urn/gQBDoHLTLQBcAAmAIDyzfnhQywIAAmMUfZdlX5j/e+GRxJH\n", + "qV/qfA3Z3UCQ57/8ACq7mZ/lYJrQ1n3nQgJAiBNr/0LTJSIUf/sQIC0AFcjFeIlfJvg/gAWM3ABK\n", + "XAabLKlFDPv7x4AAgigACAoBAIpmEJqCAIi13Er0k//3sO4vg3tqa3gwF6zF2KpIxa1MfDDIhdcQ\n", + "F+AA7AKsGBDJKGI/a2S/+hwAEAxzDXTtw7yuSX3hAAGYECVqYPoVk2hAIKIQEu4cXutm++8luHsv\n", + "gAXK1fFTxpiAuBo5WZ2z4RpKNA8ntTy/+veFvgYhYtK2cMJpcTXwmGH0ZFo2AOAkSUb7/v8Mchoz\n", + "t/flL0GnSoYQFncRZb7cP/wXyHEzVyMFPe/FEt8k27//081dNwAAAYVhAL3gAwAGHIDrwxHgoD1A\n", + "YAHoharClXRn//5/6MButXxJTIbv2GCYSaysMWY179f4aQ2wAHIxTDuAD1fX2sPEmIhACQQ/ALZh\n", + "pkwONooJzn9X0AIDTNjljgUzIIABGIJAImu3x24HQ7s9RXz8DZgdyxgRKNLP/0AEBQ08+W5QFwzA\n", + "BOaVokfQf5RuscIC3WthLDUkKc/3+D/oGTgAlLoNOmFSihn395gAAghgACAsBAJpmEJ0EAERrZy9\n", + "//aDvHg1vqbnjCL6zF2KhIpS1MfDDRvR/H6CHwAhUGOqwuFihRIfU2aBHIAFC5vVYJAaUTs++D/A\n", + "d1SwAOAAIAIFA0Kq8OOGoICFg1ck8gwAKtMJKfEhTUvwfzI8maMxE5AiYRQgADIGFsQFsih4psZ+\n", + "Fu+ryR/nJhcAbByfEdaJ7JqYGKjGS9LqEYIQt4DEH+p0d0V5XCOqqfMGHuWQWoqVITff+i2maMxE\n", + "7BiLhEiKjVGzczF8WnKW+HV+uAWK9DMKKtRB4M4OYAAAAAph4ANABpyA68G8AAABBmEG+ADQAacg\n", + "OvDEHMM0d3QEf4AII8lbaRg4haAEMAGS8MJgpngwHpoAAQKEXKwAAgbAACAtIBIGDUAC4OAskBRJ\n", + "QqIi/k8f3vCC1oQjGcAHKDtLUnQYSyOYSs6feAK0Dp6xfgdmI5QRMcPSbYTw1B2MDmAC2Rd4dMYV\n", + "9mBgaGGm2gCjYrTkZ8EDaAOEAAIAQBwkhwAV6zRGiNf/1WWAEYIM3YcFvjDitiY8FAbgDgAWDrFm\n", + "XhXIiV2h9mMfkRiKyHMpRkqavwFhhdqzyKbktVLcKl8wAAQJwABAnABIRTAgSsgQmIld6fFt6YIb\n", + "u8tQ+j/g5ilEiU+fwI0AuhJ0mM6Fkylk8DcAAAHwYQNuADQAacgOvDEFIFkL4ACRkIrKY6FCJapM\n", + "G4AD4AZTDPQtM8lQk5BuK58MAAQCgKYPlnKmb4QR9wQkmDtgSPY4csEQazOtzUz/IAK3d3WKCiw3\n", + "vikT//7WCoD4FvsGDyAlLb/2vcBAlJAc+BikGnNSYNso35NN8wJWVMMAAEBwAAQJAd5M4AAEAQP5\n", + "YXJ4cwalaCMZI/3kJxG9hJgODXlu20fhAAxImr3uCqx3D7wDonsFADAWQAaD6WBAACAsAAwWVCAA\n", + "EAEAvpFcNyMCd7B6ExMNRWoxRAgKv38oggnZAZZ7ezuw9DUqDxBZcAr/RR//eGT+X4YFRcMQvwwA\n", + "KCgzRKqCRx02K1X9wBhhBtHgxFbxOvmQ+cvfd6MwAQAsg4qG1ZgKDKd6CZ2KFSNtCfBAAjKWEAAI\n", + "BAAcLKBxLPoh0nSB4lhpgkAsZoIhTqMJlibwAWqW2Vv+uasGBpQPwrkUloUvwgbTX7/+AwQhY8m0\n", + "WQPhy9DUI7MJwt/BJAACBSiRGAAEDcAAQF6AJ+Aw5ot9f5MuADwWbbeEniSGYAAIWwAAg4AALADq\n", + "ZucAMBoAAQPAABAMmQeGz/nPnfAe63wDOBA9S2uvgOCSlXvfWUJZjCE1VOOWcXbR7L1BTPzoQwsR\n", + "DZExvvhCHGcvApWe4AAAAp9hAUeADQAacgOvCwn4IQcnr8NJaoAYH6s7+d/QovEQ9OBOHU7EAFti\n", + "OSHI3Tn/rYO4YH+cdrTzTpoDANQB8pShSSfTcL/wyEAfhPMR4AH9bWp4p/y+BMJ7pF/XgdlvV/33\n", + "YEVKeqtUrr+GmJHbJCzjjskqPXz5lHvhl4tG1/v7YYEhbgAIAAICjAC+E4itZDgBOrgIt/kQxmow\n", + "k5pozqy6fB8BQBvjC38CpxAlAMon/QjIAAQNQABBDkAAQFwET6yShMbDSqRHU3gMOaLfV+TLqkTr\n", + "ZEmyFIAw4VfZ1HqCKIkA5N4EE2C5/b9GNimsQflbHP/weoEJW3IVQohCai8Ln83/z+C3gAIBBWz3\n", + "SQKo+CepUXFOiIaLN6+KzfABQqbwAO6MlmijLffgAd0YtXyRWr78SEAQYACQRAhRAS00RGUDcpKQ\n", + "xHCovMAAQEbQAUAaHhKxnr74AF4Njja1CCkjk3/wBR4xYxwXDmJHZf/fhgAIBDtnukgVR8EdSouK\n", + "QwAneEAAQOEaACUr5VslT9A7nQhVxy1uBCGQny2DmTpnFi09WN8AlkADQy5gnbeFv9qQX4ydPDnI\n", + "qvP9Nnb8102G1aKFhj//wgEA/4GrAACAKF72RwSApO/Zhr/+D8MSAV3ZVpMHip2y5xRgmH8hOI9G\n", + "EnLLGdWZTuUQcoiWLTfYE/FizoorsW/wAoEUQspg1bKZZlx1kIIisCAAOgFCS9EhLhbraEFLI2xm\n", + "nksV1//S++UPGXtYDUWS3eHaygiGxZDk7DVNcj//7yYVRhNmp8gUn5qv+PC0BIDkEAk2W1FFggsX\n", + "K0UYlRVlj/1sGPAALhUEJgTsPuIGogchTnkSM9A/5DMMptt783t4yhv5/hnkMpaZsIr+fmyMXamG\n", + "7B/73AAABGphAbOADQAacgOvI8Sw5ASPW/B8ycsBonQGLJpKXEAKC7/ngjiS2fJISMDcjQtEIQAA\n", + "gBgECiIQAAgjAACBWAB4FuABZS+Fg8EH+AQscACgA1IJozZyouSdAToeBIhjwwBhQABARsgAAgtA\n", + "ACBXedngACJXAGAAAQEwABATiIAAsPkCCH8oIAAuAAQ4BOFDwakMUWq8IkjAYORObojANlAQoeVc\n", + "Lerw4AIVrgcGGafMEBPwLIRPPPADmiyWieg/gBcloVTdq9B/oCFAoBAKwALBzmmOWWzNt1YXqFme\n", + "VSraQaP7lh2KgZOACyIADhqMsGNCjBCev/3lPbt8xuUd6zy/ePVXZVBk0EWmAC5kKCX1RMfhz+Uy\n", + "oxRJ7R3WH1Djj5SAVL8piPGAIcBD3MqpH/98grbaLf9/0M4e8BUAFk/5oBPihuYmc//uAA4MFdSh\n", + "FXAdjsy6eAxDRbEN0eVYoirRPxARBjERxSnLs9onwIGQFOIatCPI0bgN6wMEZ+EhMUMRbJP9wB4p\n", + "sT6hLTMt///gMtO4BhfGEyVc1imGGhqGMOGt9AGEmFWlOpSjJfcQcX12SKPcLdAPIxbL1wuscLfE\n", + "9uYe1jPQ2ok1NZrDAyJsWyxaEKjond8X+6hggRC3gKZtSBhhUisCgRNrBAJowZbyMYANBM94CKqg\n", + "ACAiECqP+7DA6bmgF/gY7BqiO1DMLH/EzYuGGATiwABBCAAEBACwTDvfnhAACACA4lcJMAMPqK6I\n", + "BEKBGHKIvwdLo0RzKt9m4wdVQTsz/8+HTxfjJJIcX6veYv4leGoCgEFaW7WdDwiZUoR/vAisUFHo\n", + "BKqvyb8hK04YYQABgCiGQgABArAAEA4AWGoMhmIZxR4CfH+/4YlU/IBQJmfHSoFXOHXhWGAvhBYM\n", + "NCycRBMzGDz/oZgAAgIgACAoABoAAgEywAsMw5DUmCSY2hw5KXeGEIEogQABAAOQC6bmLseMU47t\n", + "gTAim3/QgCKYCsPCMsuHHIDMYAOJCaVt/hA/m/8z+C2ADVEHqIlSU3wEG0EkPyUpoX4AQEPxTtw2\n", + "tMCY8cCfAgiiFEZB0hMWy6P/BAAGAIJZCWlgAXoFxJ0bFa1imX9+AN786i+sIhgOYADggV4EZhlf\n", + "ExLeJfdmAvOYAGCItZmlEEpoLA+GAKde47zddm/gCDyzxpUp1oAgsXNSjYJpnPwLKkSzRav8/Myk\n", + "qHLgINFkWElTj5O8eUrECQ5AEAKB6Kko0C+sAEAzBpxFgknMgSU1cmBoMQMoRVbg0WJpVemiAiAE\n", + "NCNiP3eNsbb7/hKIziHZOMjj+//sbDEAOWIUC7EdjsJW/2mgYdl2U92xdvzeqhiwIED3FLVka7yX\n", + "/QYoLQBEgcI/nfGAs4v05TvQw/DGHWWQIEVxdPAKo5h+8iGMmo1wOBCaOBRZwAEPpuJigAK62uKh\n", + "kc/+7wC6hUcYI+syXBAAHgGEsgwAJwUYikWfo7YBtoOwIS4y/++mNVF9Zetac+T4sR4xW+89wAAA\n", + "AtVhAIfgA0AGnIDrwqJ+C8IBmAAgIIQ4RKdGMJUrmV+BcxI5wTDlpH3f/BhhLZoAD6bUPbxDnwYf\n", + "6CwgwQC+ADdsO05TlLffgAIRCBCiAlpomNonZSVhegdTAACAfeACgDw4JWXX3Cs0EACIQSDuaANk\n", + "1rW/9egB0MtW1Ee7LzZCF+Uf/oA193XIWmc4BFgA1RAmRDf+vcMxLxiZs8Ock6tQgSGBAIIAP0Y2\n", + "rK1r/3/vgoIRA1w/DkB1g+XsAbAACAhLJQABAVAAqAI1zBJxwKZI0kdZAHHQIf/cDMA4JezLZYDB\n", + "pnCas//7gXUZLCTrIEsEFWnCAFwxpKQsg8HDBTwF//2AwASOkCwVg36G2h5f//cGCAct+1WgGCAH\n", + "wQIAAwBjR6YaFQE9g1XNVHVWP0oVmwfCCqviIN8gzmitj0AKhlEMQwWnlRz+HcbATnQI4OxITM9/\n", + "05HADSMe//zwgCALQ7W8oCYQBqIhNgr7ncU/5qCBnwABkPExziAA0d455oejH4ilWp0YYrDkt0zC\n", + "c1P7XvlT7z4OymxohzOpP/+vDB/DigAJrDn1IM9MIc//wAHsxRUbrDlM39dBzhE8SYSSKUDRFIeE\n", + "LVATRbXQQkJzfAaLclNtLwg7IYvrC1EkTdvPa528jITYzeYIRAIPAA+C68GRfupp7/oBYLAYu8DR\n", + "WAg48LgX/9s2HAUhnAk6zrWDTDh/tv9wBgoSMZRMWlfyRwKfMn+gIjXkf0OxUUmQehyGKQfBAAEB\n", + "a0CZl9vA2BlEVF3aZMj/wsm3QCEK6JiU2svWubh+6JQNhGKOhy99sEBA3ZmNt8z9POJC25RB6mKY\n", + "pb4y/uPrbgAAQAACsOBmccGv3MmxOEf/7wje0IzoCT/LcMt6ExwoNEVGPVR16fju/W8wb2nOeY//\n", + "foPwgAEd5IRIMtmENOoN1lGJz++qPel7rPdb9WR0YLlJ8q+Ai6qPaSQO9wAAAglhAKLgA0AGnIDr\n", + "wuJ+CkCAF4AeAAICEsoAAgKgAVAEQNoWUAAw8/WdnegHlgaoAbCBJHkROKOQpcl91SIAAsAODi9e\n", + "cAwR0vL/li/FiTRj/9gBAdw0wEkkswx3zVx+7Az8IFPggADAO544N4A+DS2iaEz2eXjXlp9qEQQi\n", + "KgRxLX+APZqb/AwPAYuu4EqAYoQBa/gCJz5Mu/+/pwGHkWbFab5ytK7f/2CgIBbM0gABAQAAEBGg\n", + "AOBNt8MAAECkAAQKQASPpnAGpgMDmAylSMz5a+6Cl4GOQec1Jg0XK+7syNf7H+OJXLox+IpVqdKH\n", + "owbHG1qEFJHKu/gNGCWUxy3H/79BAARogIAA+A5ptaKYAGjt92B4Q0XHjqgqE3fbQyissAUiwz7X\n", + "g+UkJmE6sUhCAw1BSEAvgAORQCmAyRX9ndsJBB7+Ik4AAkAgedinXikDRQyn//ocABMiGV0MZCjp\n", + "UpIGZitYLAaSTp/iX3o0qXH/vnwwDvKat0Gbv6vNYKAEDhbwAIAP6MhQekDeX0Ukbwz+UK3pCT/b\n", + "dMt8gHQIQaPQp+AIW8BCj79R9be9mNe79Sq7uH5EAB4AFgChuTBBQgFmoU/AhCDhHMKOC5X1dkRr\n", + "wgABAZAAKCTIQAAgJAAaqsQhpIKm/UPDub6XDIov0+t5+Rg3F+CDlihb5+vQY1yF0e8iJXv73AAA\n", + "APphAL3gA0AGnIDrwwb+f/BZgAImAEBibxpYJZ+ksAB4Dnx3WJ44bySH+CC7OEAAXDHlQANUuMMg\n", + "7KSUfgAUxB25ZAx08V64Nw+DEM/AQzFxkmhaZ1NWmwABBNMAAECkAAQJwASEUzwAI4nsODmlr24X\n", + "ABOIE/mZjK6nO5R0rWsIAIjGBLb1QfKpTzjYKSfwf+BlQEgccfELHW6Uh+DL8Tho3/j+CDgO6pYA\n", + "HAAEAECgaFVeHHDUEBCwauSeQfC0ABEDIIS4KWVsiQGijp0GHABsjD8EQtKL7wCoqaLIhvHDEWQi\n", + "SQAnfNtgd45W9yw6vAKQmNsIpiE+/4OYAAAACmHgA4AHHIDrwbwAAAAQYQb4AOABxyA68GY3mtcH\n", + "NwAAAI5hA24AOABxyA68MCfNw//hvAcAAQtgABBwAAWAHUy1iAApC1tQdt3vMghIAuV/AwFMRzDR\n", + "/DagAIAYco0ooos0OLKJqFy8DgAFAibkASIHnFiVp0n5/wUCon+iKyid9QFiBCFZhxgEgr1loOfh\n", + "wqG4QCUxgAH0k5+a1QcvYGa2J+fwAJYAD9lDCleST6G4AAACL2EBR4AOABxyA68LifE+o1A0C0A4\n", + "AAgDUAGBD1zAYiVQM7x42gAcCUXp5q1alRwTlowAAqFQQmGBK3TAEQYZ9QWFKHBS9VRSADQA+FeF\n", + "4fOEiaroEToMOEUAAIAqQwALXAvTYi//BBIrhCYAgwAVsckKPHewYHKHoruZkDH//wALmgRcZC/A\n", + "h3P+DA0ZWE07Zs9TyLvDB/P5fODmCkwKAwBSGwBm9dX33A2kiFIJ3Iy/gEyM2AAIB6NlcAAQDgAX\n", + "QNB+AAmEw7bYKY0ijMoSyA4AAgIgACAoABYIS3mAwGEW0ffDMNMB4vBYQwwALMJrwt5YpUL7vNt/\n", + "fABYJuVsz1Fy8YwUX+MEGzgEIuLgWAn+AM4GUwcQNkGTqRErEW8QQihyQywys+UFoz4JuEU2HlYR\n", + "uXdwLOBqCileqYBB1WWwQAAgIA4vQRAAECGgACAsAFZH4mEsHguwqxygEQ6uCjiwpOMODkIHnVuA\n", + "AIAEg879ADwQYtFmWAAMAAIlVRhGmSK1SgAaTD2CrDhSNuVu0zAwAxaqsL4AVTswYP0wV+N/sN/A\n", + "MKyO+SRVXwS1KjMlBeIYIAxdWQ3tBfR6xVfuDFR5BpJiczSLn//eGcoXzQMzFFEmaDhwT4MOqKuN\n", + "NCZE3X++uGC+IxujgDU8K/9xEBwjMOaG9pcuTwQABAIEugWACP2ggo0WgFKSEPgi4Negf/wrAp1g\n", + "VrBFwbBiUwmAzC7DHy4ehST8OlwSYbHFre4AAAZGYQGzgA4AHHIDryF/+DkOeAMQAAgJAACAnMQA\n", + "BQfIAcIFmfgDVyJnz3ACU9RueSwr1ehxQAEAAECYgAAgFgHZE9WVBPSz01Zaf+WJ6AGdwABAQsXg\n", + "ACC3vMBRitptKIIUMDGhMWcBqUBjUKUAW+IT6EwJwgABAFBgxcIAAQUAABARAAJDmErRBIcVrPV4\n", + "ELRsOickBV3rBeQAinAUscUIF/V4BcAbFEoqBlC7LQAL7BET7AgwQRvgAhAAGVMAEFHx2tg+a/AA\n", + "EcEeAYRuLBRb6xggH4BKBoJoxw744x2ODEAHeEaLQDQXsQ3+9AUJjqAKGTR+iD0h6JGehkAACBUA\n", + "AIUoAAg+svAgmDZMIaZTFXsXKdrAEMowkTBwg8ECQAY2lZ8hxjSJeoZGBVykAGRdiXKTqlEkNRYW\n", + "031egAQR5KZtIlzLGBJEE7/ADsRrE+cyu2RDKfSByRfal8HAIghByLBWCMbAAciIqxwWC9YKqtcA\n", + "MCLQMj2eNYRf87/7wbhjWCdkqa/uRiYnwDnDrLCDGCeSWNkbgDjnBjkHELqS0t/+4CKYdDRTatSo\n", + "FxlVTf9wAxeghZI1gyCVTIhJf+4BsMSBgrVxZa21QkAa/7wGF86JsMo+NFEhGS/6MDAGFWyKsa07\n", + "/kPIH9zdU0B9q4PQAIAgmcpI7Fm8RAGYLZwAZQuFPpg6RRgzAHf/ASAYBDTAZp2BEPsyHuz+VEkg\n", + "7SI/9WA4AAgJADgkIAAQFQDAAhnBwqQzqoJ4Kvf7SsBH6LaAC6AHOv7QCgREPINqowAuz/2oYdbE\n", + "GC5a3EL6NzE5wh7GnaQBKi3+ECKUZA5hr9APKqzThirMg7BOGUWRCfgRACiHa7iSRE0lTIR2CcN4\n", + "W8Bl058lAGoFjJ+I+u9+AAIGAAAgaXIKkfvdoEQA4EDpRZML2nOgXf9uNkAAIBBqIBmkhapMpb/v\n", + "BCsWQAJocb26FmQxbmmwEGBKnh3DwlZ7pz1eMAAJhgABAkAAimGAAFwCgA8H0wIAAQEAAYY0EAAI\n", + "AIBQJE+McIz8P7xJx8KLg8QJAznV1C2Yr/+/2SQEJzSgCaDq9fg9BUAA9FvSUAMWNJxfbzKCDDWA\n", + "KDOMQxJokkNoMOSh3DQrTmU6c/ffguEqC4t1pYc/MIRRx/6DUwBJCy2iwwkHnhXRFMzUKv9f+Bh1\n", + "3o5UVnhtRMBGi7vADKLZBfwETSLkjQ/cGGEAAaHFfCAAEDEADABIlSTQ85oYhzPseCMoOBNfu/7G\n", + "AZIcCNOC8uvjuEJssEQFwIqBgNqHhhE/m9HMIQLBfAAcQtJhGmqSs7hz//AAIGHXejlRWeG9IwEq\n", + "Lu8AMotkF/ARNIqSODtnBHDuIcbO6/Qp4z+5RBbGvLSU794QzoMpLU0WgxRP+h+ACKN6HcWKjRFy\n", + "pA34gwLgVrInRo3qRUKm4YYQXAYCQgABALABAWe2n3CRz1iGHDjBcohA/KN4BcXyFZ1R2RSYYbHe\n", + "D3gnJFPfycc20JkRRFBcCaAofZPlLZJqtijV26YAJIGbcQ/4gzhCGJPE7SIIMtqc2mFafElGl/3h\n", + "QBQLZl5VioNS4CRQCbpgCDtU9jKeXoYv/dogABAFBh7xybxVgb7mmbUPUABebzCQAQAncIDwAY6y\n", + "VZRx3BGsN7K+KAAwAOunBaUwW0uFjAEX1ni4AAgD/aAeLjJtUqGgADAC4eDxLa2Vq2GMxSAwFQAG\n", + "sAhU9OgAl8DhsK/+8JwO8HIZLqaZ0SmEGfiN4QAcsCNqk2xI/VoPCpTEABQpRnLA9qxJ3FYwAAgF\n", + "yQAAQQQADzsEAEHsAWEAAXGOBPC4A6lHpyycARGxBhLsCLYlESt1pmZhEHEkX/e+AlJ1YNTA4iVb\n", + "/MKDTEhAQAoqb9twbhTQmlvB3EvxrlScIaoEV4+u2JUH1egPDsOaSKT6P9WhE/90FtiAHSABR740\n", + "wTiYlv14DDmC3lfki4REO21ha1PwEtxQ0Akht1KxCgr5IMZcQkxpZmsJb4YkhOHE9k1wJiuh9n3+\n", + "aAZvRkjT6HFBli8YgnEyI2XhJ5FI0EsIVoyo3zSxrb97BAACAuAA4KNBAACAUACAWK6IMFyYpq1O\n", + "8ql+oZwiWtILEpnRMiPtACAAEAKG4BU345Iuv4z8AGQaCaHYYcEw3AAAAcdhAIfgA4AHHIDrwsJ8\n", + "T5utxH58dgAIiADAhc6g4FA5XluCYFPx+YEKZs6KVZUVesMwTtPLaIcSXItaoOgAou9IaBqNMyVk\n", + "IBTgfaw6kVL0l9wLCohKjdOWkdZ/9/BB1uIdsm6/RxIz/3kkglpsSlPS/BAIqAkIAgAE4BQAK3Zo\n", + "GGgk4W0gLo2I4ACxQa94E6gvFFxpGNOeAA6VKioCJCB2NsUmiQDACtvaH8Ae9wCh/vmM2m0HAt8A\n", + "IPPNwPPY7YT/B/OQ/IQcsbqzrp4NKd/9o/CgCgaf1Sznig5L0bEGtidaEBwWQQ+UY69IAAQB3AR7\n", + "wVAsZUxoDgf6JJLY+VSgA4H/bDzCXAAIAGwhkDxu2xgDwAoPTAgABALADgaLhAACBEAAIA2Zo8GF\n", + "7ofgDjSg56g9OMOfvAcJ2XbfcehIdspQFoWMtyX5/g5YDnKAAIAFKV0rwyfxC5hD//QbgotBoUSU\n", + "qS5yiAAEABkSABkOBhDEP/wEMwtzxC0kMXtPMAG/AODg4thRiBQ+B8HAAoGDE1RIZ98StUM1oIAT\n", + "itCJBEAzAl/XDnRV8+DBLlUfeX3/4C8AbCRKNIfbc8Pg0MFTW6zL5DZDcAAAAMhhAKLgA4AHHIDr\n", + "wwJ9ICIwIYWgAJC2IIhyESxSCo0QAAgAkkYAH4oBdDbpk4DVPHXYoKwHkjHdQ0dSHAAEAoABVbTE\n", + "rnIWghhQzmiDDjC3/eGcCaCN3PTLi8SSRij4chz0ylDqD1i1zRi/Qsz52QIASQgCb8AFB7kaopA7\n", + "lgwXDlJm4j2Hd4AFmQMv5WeQSbCngYGn35eXuUp1P+8NH80P/9BuGIbwAaDtczIyuer3gFAGJG9m\n", + "a84hEWdXzPjHNV354S9J3+89wAAAABJhAL3gA4AHHIDrwwN6dcHECpAAAAAKYeADwAecgOvBvAAA\n", + "AAthBvgA8AHnIDrwbwAAAIZhA24APAB5yA68M4O4b0FsAIqradN9APwrIQwxCEVkgDCgACAjZAAB\n", + "BaAAECu87jY8WPAAOAPnWIIvfgJBiHBa8YkE26bAFg7/u1A6B8oNnGT8LWfwQABEKYYEAAIDAABA\n", + "GjoAQ2pP//zvBbmJHgA8fy/n/hucPAIRgAIqwoAAgdNQhf2/3AAAARthAUeADwAecgOvDLh3C0AB\n", + "AVCD61lkVh+smbA8Cq4AIcTtVVtdB1eZEMrsIzEkpYpPhEoG/sLBiZEaxXL0/rBiFZZpoHA/1lqM\n", + "l+uwABAjAAEDe4sAAQHwHbQOAoGHu9JT74wLq/D//hCYBjhAACAKALMgAV8BJmzECJlfh1Qhd0xG\n", + "Yf/2/wADCA7c6QK2Q0kM3/4YLQAYDIlACyf8jW/r/DR/ND8KfYbzxTAAHLgehl8X8sNkb4YMv/70\n", + "rEIpVyn1e1egAxAvhLXUkaXKoX/7wzwFGC9w1UWweQGUhTeQ//tAQZMrMdNx+7v/oIAIglUQF4Cu\n", + "F5ry4kpKHxQGBI3ULQEZh64YG6A01ViMqU94EShQ9tgIMSsw6yG4AAAC6GEBs4APAB5yA68jwUT0\n", + "w8B6M2/4AfgMVzrjHB6X9wUghBPDfAGAAAQEwABATiIAAsPk8BoRIzwJAYjZde/BUV6jJeRCib3h\n", + "IT5v/zMThzgAWwbHG1qEFJHKv/gCjwiYQs3DlJHXf/AKAMZTeRZomrDDHBP/94DKCEkk3ycPB6/C\n", + "LF2zD9FStKb7mDIGR7SQKBGyqE0dwQABMMFEwgCcVkAD0MkJc9wUybQJjCg1VIV7uCMX/QR5r1uA\n", + "E5QnfMFW4r/N4SC0ABEGGHXqhAiI1rYWACRc8QXBdRnjc7bqjGGyABygACAdigYBBKalY614BA3h\n", + "PVkPiah85rVkTLgQAz9juf1gII4FLP/ephqmcLSj9LGNOCADAFnNB5MJnGwQCTEgYe2CAEpXCAAE\n", + "C4AAQEgCghpsOCwsIw8jcXgfB6QWYG5gUw2lOZF+8DQEocxwoiiAusqLOtg+IAyGAFXwsVbjzXGh\n", + "OAZi/go+esEdtvz/B8FoYxNZ++/L8EH4ZgCwzDkNSYJJjaHDkpdhhwAhCZmF5SKRZ0P9sfqnc4X3\n", + "vHf8JH+GQJAegDXPt+DxDdZb/wBCkzbBKpaR35oipzgoc1w5HUFkWC49//+IAAQCQAoE0o+zF4wq\n", + "KDZyaQwAOLkKOYmfCVcIzx5xszAAEAIAAQEabLQFj8j3a8D4r0BIjeirQfLaUUAYYZiAgABAUAAK\n", + "AAoBMBDlPVhBpUVxNzbcd5VfudbAC2yQZcYhMDsAdBQ1cAhFQHy2fUm+tZWjWJysl0+EaX/aBmFp\n", + "gAB0BwLJphgAAgPAACBQAhZM8DAV6jXgAp1LtQJmvQy2+AQI8Uip7Zh4QYSoo+9MADEB3XE/Ng7e\n", + "8EyG+0AkAlUMQhoooQKnwAQCB1D+biTCEcA2hGUbPWP9gxChM1T47QgABMPCAAEB8AAQAwFDmPAJ\n", + "1IAVw2M3jpfgWBXxl/BhBZXv//B4yBxCT5AyAKSW5hEHogQQIr2XugivvfqD3AAAAR9hAIfgA8AH\n", + "nIDrwwJ/BkFoADjcAHv7eCUcEejSIHX5xOGtvA+2zgADBrIioAaVGrsmjVt/B6ga5RiHiP9sygAC\n", + "M4iDE65hJ7FcaSAoipnmH2QyJFJf9oYy5lp1YK2lSgEsIgQAAgAAE3QALBjmni6czlwgQLcf/gwF\n", + "CG/88mnA78rorhgAEggzLpw1eN0PvgwFNSDF1liwqmny6QBhvAoBaGAnAAagC3Y/N09p5MlQAGoG\n", + "KRuHmAIB/vDIZLvvDOFuzS2iWUUX2fIyEVlMdihEtYnYwB8oCkjSd2yLfzgCHUmoLCoURQqUF/YG\n", + "+jFVralf/+8IkBihEgENSn48kjb3/wJsMiqguOy2ev0OBWZSDGn75tP3gbuHNbipL397gAAAAJBh\n", + "AKLgA8AHnIDrwzh8LQALUGe3cA/KoAAQGAA739oQFVMqBLpsXmVqfQCcILBhoWRiIJmIweb9wGO5\n", + "Bj0mEb4zy0P/9wQwEAwANABiBpvxQUoQxMEXwIACMUUEAAIDYABwPFwAfmCmnoAVcn/QYcUu/SPA\n", + "A4QyguOb4iAlKilf/4YasnXvDw2E8MqZ7v97+4AAAAAMYQC94APAB5yA68DbAAAACmHgBAAIHIDr\n", + "wbwAAAALYQb4AQACByA68G8AAAAlYQNuAEAAgcgOvBoG8ACO9X9VQCJDezXnf//6AE4lwBdp689/\n", + "3AAAAUdhAUeAEAAgcgOvDOHgtABY1nGLbo7n1P3mIIKcENtGCLTJoh4BISh5g5ACQerzoGq8a8E7\n", + "oIAIAUmkiCRo0DL7vqfvu8BBs5BxCkGDrWkUcAUuB6GXxfyw2Rvhcy//vUkRIJnB1cgElQgACgJt\n", + "hAAGQKeeADvJSgHev72GBuAk+UOSIjJLB7jABakgHQCkgR4hj/7gwNPOHIi6ET0n3/e8NBvASPW/\n", + "P/8ACsjM0JspVZuzdNbJpgIvAHc00Nqf7B6N8HQByRj4Q4buPiFPjBa41QwABAED7wnkpeOG3niz\n", + "G2KBQACIF6ryOMFMsUwe1pisAAQVAJIYEtV7wABAAByXT63gEByNeP17mxu7rQABBQAdaeAQEzBT\n", + "LFMP8IAA+A7GAiov2zK92/Cht8Ye4u6+vAkzIbH4BDGYkF5d4OC9QBA2tLqqr3AAAAKLYQGzgBAA\n", + "IHIDryPGQx4AB4ABs4AICAm9kWGRH5gIJGEcgwrxpBBgGT2KAAEAYACxMgoroIQSHCAAJAKWMwAx\n", + "lTHdjgF4KraM8kdHxFsADuJpXF9RXNeAKSYAFwrMB54QPZGJ9Y3BCev/DCHwVBM39/+CyABCu05k\n", + "2n4AAcjgfyhbaVn7e8An5llDTuhTRzF9Owaq4WXr/0+EAAWBzjwlNQALwFFPD90AzBZJ78BJejTl\n", + "/jwt0QBAONnW8UBrcVllgf7zwNwWILaAOAQtvpEyVwBwAEH/1oqx4F+VAJ3DdAYLECYhYVRasNwV\n", + "O0QNtS9YAjgS+Yv7HODYorPUtJwAsNyi/bSWGF+scwmMHLgiQAIECAAJhwPGcMDbCNvZATe6P98G\n", + "CCRBcltfflf9vwTAAwLyvcAFQWxHoMDOAKuvAIJInJkDLeZ4iFcA0QEfUlB6hUSvTrEcPRCp4ME3\n", + "LhfJ6J2P1Ov9Y5/V/hTRhACGWUMX18dqMNSnKcHtZZz/AjNk0NuhUZ+UAgCEVAoo0QCmCR0GHL/B\n", + "B56cf4ZntT4TN//wguwAEAAyBCsimAWyKMUoi2L4ACYmHaniDlFj+rMJ/BAzIggOKB1lcqJQahAA\n", + "IznhAAFQQw3gA3RT2wAwYdt+4AJyaLeoHgcWu4SC3hjDW2uKwiIaCBBR0cQ47IVzYGDDiRcRswJU\n", + "xEI2D/cZgJQCfYHCBRcuuKm3+5gBnDRKEApayOwAEQOpEAAIGwAAgkAACAsBzWeNgFAA1IDXhXdk\n", + "wdA7ptAAAgaAACCJAAAgJAa3UEJgAQECAAPAIDTYEjIklolQ6ucv0l73sAAQC2pq/3gWgYDV3h64\n", + "itY9p2/TDYHyrAMSGqLGO69wAAABVWEAh+AEAAgcgOvDHDUABBCsKPKaMd4uWXdcXMAAECsAAQPQ\n", + "ABAfAZlg8K0wrTgByZRBlw+fgBQjaRjnQHv8HAWgCIchg9MqRRlEFXKMxtigABAkAAECSJgAOHAe\n", + "CP37KCKQs/hrn/IwABAoAAECgAEBD+BgBzKARO0DCBwxBgw5oABLwABAG6oMBJ8LMMfylw+hvgN/\n", + "PINmEABGYyRZmzAAEAdYM/6wMF7VGp9c/b22bAAEBAAf70awYLmCtyhxCW/9/nhvDoW6MUa3KYea\n", + "Rf73PDPIHJcIXRRYSgBCFyPyabdhEX1l6BEEIqOqEIf34cACCiBsRU3lgQdXgY7zzyWnjwoKMtG2\n", + "6LAKEtWp1aofu28iBDEI4wRxQl5ppYIAAuD7oQAAgAAEa0BQWUHXt0wkI1rtg6WmhwWZ5c//AVDo\n", + "ATJRAWwmrclsPDwfkAMSBFIE8b3uAAAAHmEAouAEAAgcgOvDOBIDfgDBDe3Neck/gC2Tvz3h6AAA\n", + "AAxhAL3gBAAIHIDrwNsAAAAKYeAEQAicgOvBvAAAAAthBvgBEAInIDrwbwAAAD1hA24ARACJyA68\n", + "GgbwBFNtpIOrgAaSXwb31H3+HtwbzXuqDCB8lZ3l///+eSEeb93PgBR66/88l3x+svuAAAAA4WEB\n", + "R4ARACJyA68M4CBDMACEAAb+uAGFHRONM2W+RIEzIIQAaB/KqwI2kPRAACAC0jAA4Fht3IrLXYEC\n", + "7ugBbHIGNl41uD+ABYIdYuVfUYtybM3/g/ho38/nw5gAVaYSU+JCmpfvhiLex6KOhbVwCj/gOirz\n", + "IwVdyFV1//9DCJgQpsAC5weqiY0nGHPQdyYvTOVk+gi7aabfk0D+P9hvcsgtRUqQm+/wAY6yVZBx\n", + "3BGMN7Kh8ME5xt5iUFU0wn+DDhAJQpIAQQGwszLvFQWdH9/FCIn6oyO5VDCJm1em/IMPcAAAAnJh\n", + "AbOAEQAicgOvIX/4IQx4AKAAJ2ABQSEHUq0zInPwBiAAEBIAAQE5iAAKD5BFIQAnWAGReimzgyzy\n", + "JmuvYAHIb+MJiyfYwA46no3PfCiJN/7nxQd7sGMADtgHHBzAESZoCJGhzAEJSAOalSwC3hCbwsBM\n", + "GHwQrLbcEkLGBmpsWkAQAAgCgwYuEAAIKAAAgGgAEhjBq0gkOLKWeYEKZjLBPWAyz1gvIARTgKWO\n", + "KPF/V4BYAbkEsqRlS7DgAL7hMO4ACAGGKLLLKKKKLLLKKL//4AZWAAEBIAAQFZiAAKHAHCBZn4A1\n", + "WRM+e4ASj1EQ8thXq94WgAPqCkCdxBjnCFoPQiGhjErAJgppr4BjJ0yM75//eAIjGAApDECgrTmU\n", + "6Ne929/77cMIkJAHQALQV1MSoJF05/g6ry7n/+6/AHt9jsR+DQ+kWaxb/7+ZQQYawBQZxiGJNEkh\n", + "tBhyUO4YCwiZH4r6OR5/wRBWMVihta4e/MIRT/6DUwBJCy3CwwkHnhW5iKZmkVf7D8AIVBRGWEws\n", + "SKJD6u7wIqFBR6wSqr8mazlpAGGEAAaDikwgABAxAAwASJUk0POZCEOZrHAjICgTT7v+hgGQ4Eac\n", + "F9ffOcMT9aIkLiRVCgbUfDCZvhH/QLMAUGcIQxJ4nqhBBllKGAsImRxlOjkzPwcJUF5ZGtYc/zBb\n", + "Y0AAIBo5WeDFkRGS+AnEFRnGuIfKWIvgEa2JyIpufFTmBBDIpBkwzOUqSGz/z0CkziPJR9bIATjC\n", + "hCub39ocavQ2Jn/4MIkCMEAAXB2tpaF+WOTL+XgbaP5glxSf1+N5kBGwR6Bv+7wtobMdye+9wAAA\n", + "AOlhAIfgBEAInIDrwwb/+EIc8ADEAAZWGACCj47WwfNfvgLhB9byyKuwqmRu2InwwhIIoQLGPABB\n", + "eSt6RAsWZYaHCQ0ggAZF8lM2l2CrtRcaZRJxwIYWnpD4AQg3VJJPvNc48RE8H4ToDpU4FPGwpg0C\n", + "bKCWGHCCxShASCtW/Pn34AkTUfnk6750rWmdg8egRkqUPxYm3hsNqAAgBBizS2tYaIYa4067WQQH\n", + "4ADxAhCsw4wA0DPWWgrABxaDQokpUc1oNGZAoSZbkuyg/wgJClCAE4jPgBeH6OR0ddO/4ADnnBOq\n", + "6eOZzf3w3AAAAEdhAKLgBEAInIDrwzhYLQAJWFqLHJlEMX3kLDoUhzyxN+RV6HD83uPrqLAXuYnd\n", + "AOare7zgltoAK7oXJO82B/BE2lrxjRHMPQAAAAxhAL3gBEAInIDrwNsAAAAKYeAEgAkcgOvBvAAA\n", + "AAthBvgBIAJHIDrwbwAAAGJhA24ASACRyA68M8N5WIACQnDNRhIhVtr6SvU/AJHvrz/y0wAa1N3q\n", + "2eG8DCGf30m1AACBiAAIHcRAAAgEgV+ZjFX+relbfSnwlthBIQg4CxSZdZ7/gKNh2Kz+WcX60NDD\n", + "uAAAAG9hAUeAEgAkcgOvDKgRZwtAAtg2ONrUIKSOTf/MkJZOa2//6AUAwiHlZoT2bBSJgG//2GDH\n", + "bVizO6bNvuXbMP0VK0pvgYH8IAAqCnngBAA8CDTv9RpHMFK/sGA3X7e37DAD39eacSg4mr308NH8\n", + "/cAAAAHiYQGzgBIAJHIDrycMeABsj9AACAEAAIA9VYADAf+sYAABATAAEBOIgACw+QZQABATAAEB\n", + "KJkACw8QDsggkcuAE1xshK/q8cGIGY3OMAJQ0oRRZ5B3q8VAAIVwoYVN9xghHhjgTo4yCEPbChTO\n", + "8AgWQIoFJLUSaqAjoAa/ECwLwhTSs3b4BMv//rQEAVvKkAOSAXEL8duCAAIAYkWEAAIDIAAgLgIB\n", + "LAEYNEegABADHBxBgUYC7BVNSEWd3fYCwqoX5JM54AGHAD4j0YAgA7C4AomSeArJybIKcLeAHgDI\n", + "eTTW1AkBgo5X+TTBo1l4SUa/MgTNRnfe0t9eu+H1k8Adic0+W9eZQxhXAGDcgxDRaagii29MimH4\n", + "wzDkNSYJJjaHDkpdhhxKQHABooyh0cjMhZSKKz7/BcErD80rXkHLMO1yuUPK3j3/UMYVgDD0cjk8\n", + "6P9/EAEtDiAvvTJlWOqNYQQw/CwaTkrdpI1HHzZXiAPQ7YFxQAWWBwtNv+DDCABDtLCAAEAoAAgK\n", + "GLmmC0AxYesv22w1UX/0+9Lfv/Q4x+MF7tkGXQySzhCCDvKSOLLJBirB14YU4WzApiACA6Pu/LiM\n", + "vOiGp3oz8gzCL5PZ9hiV446Ts2e+GX6f36f/wDhqR7cAAACqYQCH4ASACRyA68MCfwLYWwAN2J4Y\n", + "YhGZ0fECxDFzLkgjdyN/kBX0mgeB08CKF6AVI5VlX8POu/hvQW8ABGCIKWW4YthMuy84yWctAlDB\n", + "caIjKDiB8DQLf3aoxFbHb4oUn/uBCEAAICECpMawABWoDkbQIJI+PsG8smWT53+8EBIc4QAAgBAG\n", + "BJkEuzv24BBT8ghlMSJH+8AdzmhtT8BViOcqmAY0DMPN1DcAAABSYQCi4ASACRyA68M4YC2YMGAS\n", + "xJO59agQMBG1BIKdMnvkDL7kADjACgNBdvMrMXb0CJNhACcxgn0c/AIhWqKq4zDnhys8AKQA1DTC\n", + "sGLyRr8MPQAAAAxhAL3gBIAJHIDrwNsAAAAKYeAEwAmcgOvBvAAAAEVhBvgBMAJnIDrwaaDOABQw\n", + "EbUFgp0ye+SMvuiAAEAFpGABwLDbuRaXuwJbYQBMQwAPUO+lZJDvv+ADwGoyKFLy7Ppz+HcAAABS\n", + "YQNuAEwAmcgOvDOBtDcAFFwaFElKkuAQQIZimWeNRx9PfAdmFqdC0hiv3e8hYdCkEElib+in0ICQ\n", + "paWmABVF0fBgkTNB4Hbyw2aGP/0Hvgx7gAAAABlhAUeAEwAmcgOvDOBghsJ//4AuttyDq/uAAAAB\n", + "EGEBs4ATACZyA68jwI0MeACXKYAAgBgACANN0AA0Hn/MASKgFbllSCRAgxIYM+A5gWm8bBbBL+gC\n", + "QIAAQBAHDXggABBPAAECAABwO4A2KMyLngXkYQ2kjKD/6mwAmCWBUlGEm+rwGiweDAk+gJHOYEC4\n", + "fpf8F/Df5YABrooAf2gfM3/YGAQGhASFLhxh4j9DH34IM06gRY9qKTK3hovwQAwfhrp4ABMDmGiW\n", + "3iJIhn/f8QDvIE1LsPJGLANf/vZPmb7OCAAMgQSwEAAIFwAAgJgDg/4O7GPbTzAEKnP+BxDM04Ga\n", + "OBwhBWiXf8M/GMNwRm5jXVeEsMqgwCHIghGrzgDGSbGf/JN64F0Snf6N7/heAAAAE2EAh+AEwAmc\n", + "gOvBoYQy//D2h7gAAABfYQCi4ATACZyA68MqoOVTw2G8ABAYrVNCiRLWMEyRMmTgAwgfJWV5f/4A\n", + "GIAA39cAMKOicaZxxCQhCMI4AaAvlRcP/hww/whMzCExuAE1BuS0m3n/AAOKsG4kyqr3/cAAAABG\n", + "YQC94ATACZyA68M8N2CAASICEMyjCgBIGertBWp/Mw3F/UreST7dsIkZhACcxsAEj7IGSRdd4/O4\n", + "AS0MN0XTRi96+2GBUgAAAAph4AUAChyA68G8AAAAEGEG+AFAAocgOvBoaGP/0RwAAAAPYQNuAFAA\n", + "ocgOvDK4ECHoAAAADWEBR4AUAChyA68Gh+4AAAHBYQGzgBQAKHIDryPEsOTiEB5pywAKYANFAEvA\n", + "JLXoer3IUYZWkHUUK0oAJ//ggADoCDHQgABA0AAEBkANBTOEwAZCQ3rAC2Bxa+4ADpNgwKdIii4H\n", + "sgRuuG0GP8IkADoZwpVIiPcEwJy9ogJjARchFZrujZh92AJMgFM/7Bn3GmQ6mKHVtT48EABDvKCA\n", + "AEBEAAgEDOEmHngAAgETIB6vAUiSDggbImU58w8owRdSEsgAdmgAu4YPaBWrHXLgcvEzeFOFvAEH\n", + "JWfT1AFhg1hW7iEP7GJNE1Uw4fAHGdZq75wVgA+z5Gp3q95i/yeGoCMBQD5YVOuqNz7rxABLQ4gR\n", + "1piyr412CUMseCAAJByiwgABAbAAMAsag1sElwBCwa0t/ocYWUBv6bAm6CRVP14V8IgAQQRIQng/\n", + "OzmoWkr+4EDb5K0uEwh88fFP/wYekAAgQNRd+mQk8OJkHTN/9Ln+EAiJYEAAIAAAUIMz8QAcAAPE\n", + "AS74lQRoQBGCmjP/UKRCYAAQCkwkAAQNqgCj/9sGVVAFCbvg2nNTFv8KcLeAAkoDl6jtJT+7PiBO\n", + "N/o1LcpH7QxF0F8rvdf/77xDNTs9/9wAAAAMYQCH4AUAChyA68G8AAAAD2EAouAFAAocgOvBofOu\n", + "4AAAABFhAL3gBQAKHIDrwzgQVSECpAAAAAph4AVACpyA68G8AAAAC2EG+AFQAqcgOvBvAAAADGED\n", + "bgBUAKnIDrwbwAAAAAxhAUeAFQAqcgOvBvAAAAHeYQGzgBUAKnIDryF/+CEMeADaegABACAAEAmr\n", + "AAYD5/zsILAACAiAAICUxQAGgACAO+eFD5AgAQCMCcAgBZEZmXgs2ZAcFcB2AEoeoRBZpB3q8D0G\n", + "8EeDInD8eh3AAQAAQRQABAoAAwColZWRkZGRlZWVkZGX//gAOMVtNpRBChgY8LCwIATGOEAAIAgB\n", + "Q0h+ABTMkumwAPgx34ADmQYlaeTqlACOBkp8N/wNSgMahSAC3xCfwqBKGEMILO4QABkCiGPPdirh\n", + "rIJ9f8EyrUhgfhQ3Y1bBhPhbACEz+cjeWVCagBwhBMS9pH4vCCVoo/+vyLngDvXxq7+AHTsnrSve\n", + "Z4JgoHsAYNyDENFpqCKLb0yKYfGCHCc2e0RENxddRyneZGZDQqdHRHwYebISFyBAAQFcNGUORyMy\n", + "DBTBkEOA7/BcErDoeZryDlSNwFSkBbYmxT7/0BADX4GVSAo58J0VeTsASpQYYYQXZwgADIEEsfdf\n", + "i/DJLI/u//AlIl6AVVKAa4MM4fhn4AxWtHd6ePdSGch+/iKGHCEzMIAAgEIIv6N6o/tWH/xiZGBj\n", + "uMByhYtP+E+FvAAfeCsiCOIRmZ///MGg+Z9Kdc/0Wn9/VL5wNQgi/upf///7xV163B7/7gAAAAxh\n", + "AIfgBUAKnIDrwbwAAAAMYQCi4AVACpyA68G8AAAADGEAveAFQAqcgOvA2wAAAAph4AWACxyA68G8\n", + "AAAAC2EG+AFgAscgOvBvAAAADGEDbgBYALHIDrwbwAAAAAxhAUeAFgAscgOvBvAAAAF3YQGzgBYA\n", + "LHIDryYIQ7UDpaY9u/AAQDAggmbIsCjTpWSq2jRX4DoINgINi2HSIRLLYnra/jTzNmvr4Y8ABBnP\n", + "haUQQoYGPCwsAA7/A1KAxqFIALfEJ/CoEoYQwoAXBQgEAAQA0AOwAJcldNgA+DHb7bF3DWQS+wAk\n", + "yDPWnv1CgBHAyU8ILv9hDUCB2pm48MeAQaoAARK9sYUAAQEQABASiAANAAEAe87wOAATgYIIABPA\n", + "TiBaIAQcvtQimQDFInNuIBCLLASNPDbUHoMojwcaEU+YMqBQvNSLf/Qa/Aw670cqKzw3omAjRdkP\n", + "wAxUlkXYRC5IukPqrAw4HAAaOEEANwKyvsX4ZJZHvWf43rj+1of/AnIl6AVVKAa4NM8YmZgY7jAc\n", + "oWLQP5oRx/6DWGGAAICNlAAEBQADwQe/53/GEQKSSFsMaTfGi3Z8GHAwAGDBCAAIBqgB3RNAHhn2\n", + "k6pAWMZt/wCAcCNAxMTWW04gMVYL6VKtv8LQAAAADGEAh+AFgAscgOvBvAAAAAxhAKLgBYALHIDr\n", + "wbwAAAAMYQC94AWACxyA68DbAAAACmHgBcALnIDrwbwAAAALYQb4AXAC5yA68G8AAAAMYQNuAFwA\n", + "ucgOvBvAAAAADGEBR4AXAC5yA68G8AAAARxhAbOAFwAucgOvKb//cUHfACKwAAgJAACArMQABQIj\n", + "veQACCcII/fnVYoprPCzMIIvsCAAKgDGB+ARCyIz68BjA6iQGYeNii42AEo9REPLYV6vAKZuAGwl\n", + "+gFmwwcRMDnghDf8Ec3FtRJCxgZ8LC0ADsMIAiLaEAAIAoA4YWwL5p8mACUCHv3/BEFctVZqVAGo\n", + "BsmLJmGjQiH/0GsAUGcIQxJ4n6hBBllSGYAtPLeAEHeWR7pRBIRUqUI4YQiVggAIHcLMp0afvrEC\n", + "ekDoJES8oO/wcJUF5ZGtYc5wDAFETk+NftC29iQ+HwQBn4EVCgo98JUV+TMASpYYQw4QLu4QABgG\n", + "ELbFePzh0lkvf/g3K92AirUA5gWaAzDhaAAAAAxhAIfgBcALnIDrwbwAAAAMYQCi4AXAC5yA68G8\n", + "AAAADGEAveAFwAucgOvA2wAAAAph4AYADByA68G8AAAAC2EG+AGAAwcgOvBvAAAADGEDbgBgAMHI\n", + "DrwbwAAAAAxhAUeAGAAwcgOvBvAAAADKYQGzgBgAMHIDryhFaVfttzf/7jDvgAvAANnABgQE3sy4\n", + "yI3MC3QGt6gBQsF1pM8MDgACAiAAICkgAeCQj1wIAAoFNICAAEB8ADAOE8AMZUz0jgVYSZVAPlV7\n", + "AAlwm1KL6iOa+3BcHakgiQAOT8waP5o5BH/QawDRAR9SUHrFRK9OsSw9TNgACAaIzGjwgU+Np4wi\n", + "BSSQthjSr40W6PvDCAARHsCAAEAwAcGFwKjd2vidDMgQDUZ/85mRobdCoz3Z5RPYSFg/a8D8LQAA\n", + "AAxhAIfgBgAMHIDrwbwAAAAMYQCi4AYADByA68G8AAAADGEAveAGAAwcgOvA2wAAAAph4AZADJyA\n", + "68G8AAAAC2EG+AGQAycgOvBvAAAADGEDbgBkAMnIDrwbwAAAAAxhAUeAGQAycgOvBvAAAADVYQGz\n", + "gBkAMnIDrzRUMeAAYAGSYAAQADElaDQDofntEAAsAOBBklgAOGrgENQjgCRkyp6KMwxCAAOkARIQ\n", + "AAgcAOACXsAFA7KxlGgl9AhLNAAfARth3FsAB3MAAQBojoHDVjtxZZqAHAsOaAI8CaiwY5XwbXhX\n", + "AUhCA/7qjdrCpN+IyKh+mwiIpxXDfa2Sf8AMpQc7MYAgicv0E8TsMMIAAo4J4QAAgPggD1ANgrZ1\n", + "bnQRIx4pcCWYho+w/+oGA/RLiBPiiZ17ihCH/xIBuB/1QfbhhhaAAAAADGEAh+AGQAycgOvBvAAA\n", + "AAxhAKLgBkAMnIDrwbwAAAAMYQC94AZADJyA68DbAAAACmHgBoANHIDrwbwAAAALYQb4AaADRyA6\n", + "8G8AAAAMYQNuAGgA0cgOvBvAAAAADGEBR4AaADRyA68G8AAAAQlhAbOAGgA0cgOvMxGCEOcAZ0AA\n", + "QELIAAILYAAgV3nAjAANHABAQE3siwyI3Au4IBIQuggAXD83ZAs2QtwAKj4G60pYLRGJLm/hvgIF\n", + "kCKYUdhQpggsAAIb/hEgAdCuEKqPj3BMCc0hAAEAhJIQAAgMgAFAQMYHNTYOmCaGI33+g6Ef7GBF\n", + "iIrkL+z+8NF/g28NQNWMMJIEoiZFyM2d/lxAgIvJKDViYlalXI7wwmcEErFSBsskSAohnn+gnD1c\n", + "EpJWC7qlT+WGfiACWhxBlXNFMg4CWsCjwiABBhEIXg+DMpuLWv8GGEACK1oQAAgDABA4xZvWYmHe\n", + "N7t3/wCpsKggSqIKjhV93/CsAAAADGEAh+AGgA0cgOvBvAAAAAxhAKLgBoANHIDrwbwAAAAMYQC9\n", + "4AaADRyA68DbAAAACmHgBsANnIDrwbwAAAALYQb4AbADZyA68G8AAAAMYQNuAGwA2cgOvBvAAAAA\n", + "DGEBR4AbADZyA68G8AAAAGJhAbOAGwA2cgOvNEz0D54DiU2oCPXtsAegCgdKjc4AFP5FGH2QeeAK\n", + "A3D89c0MvwQPOapuXOz28Nc9C6wwk2XUYCT4HEA4L3Lyjte52trD89ACGd+v/7t/+JJVJoyRIMOF\n", + "YAAAAAxhAIfgBsANnIDrwbwAAAAMYQCi4AbADZyA68G8AAAADGEAveAGwA2cgOvA2wAAAAph4AcA\n", + "DhyA68G8AAAAC2EG+AHAA4cgOvBvAAAADGEDbgBwAOHIDrwbwAAAAAxhAUeAHAA4cgOvBvAAAAGP\n", + "YQGzgBwAOHIDrzQQsOQHmTliEK7nABIzitj3OQIC0TQoEfeAdHEfhGQ7VvbQ4I24QAAgDgDBxcIA\n", + "AQVAABA5AANAU4AHlU9ceymJAFfP3AAqAGwdnCoGvC6tAAj1YXQY9kAAZAJMgACAwAcVgHYhwgDn\n", + "JAIyJz0fvgO0F1qTZLWeL2AScG6gRv2bYIPBPMh1//wQAB4A48kEAAIIYAAgXAAUBvBOWtV0AkWf\n", + "eBsyCGwkbQI/O30QADdsYMIRDc8xRgJQkGjxHFkdZgRLp+DWg18DLyBxmx+ijqfNSUP/AMKbgOrB\n", + "ZBB9F8qM9hhhAAGgOKbCAAEDMAAQFgAsEoF+0bAVGWNH633+iEQxRmA/B0kCwOrj79M+FeNHBMUA\n", + "OpagABAUAGG+sEGc4RiTShKCUX//3T37nB40GHSdpohwmuACx3gkDmta9jShiyTBRwS0Zu5wYQAB\n", + "0BBrgQAAgdAACAyACgVljNHAA4C/v1JMgHhxHhrg5/20AE9GaUkAq4Qe/rDCql4M6cDrUGaWO/wr\n", + "AAAADGEAh+AHAA4cgOvBvAAAAAxhAKLgBwAOHIDrwbwAAAAMYQC94AcADhyA68DbAAAACmHgB0AO\n", + "nIDrwbwAAAALYQb4AdADpyA68G8AAAAMYQNuAHQA6cgOvBvAAAAADGEBR4AdADpyA68G8AAAALNh\n", + "AbOAHQA6cgOvMJ8v+houGPAA8A/YQYUvPMMVGAJEMEcjijhptriR0vKe0AAIBQAAgBgHDb/vwDHM\n", + "IQDQJgAiC4hZTqRnwdDcvEp5p7AApmBGRQp6zAjjLeFAB5scEUDYZOXg0f3GD4VkfayTNDZSOer3\n", + "/EKAPXRgLJi7OZOQt/nIk2YEFqrcsMvlwiLQgEiAqDacy2iW7bx9f33/xkMpnQVmqLUxupAkkMIh\n", + "AimlEH4VgAAAAAxhAIfgB0AOnIDrwbwAAAAMYQCi4AdADpyA68G8AAAADGEAveAHQA6cgOvA2wAA\n", + "AAph4AeADxyA68G8AAAAC2EG+AHgA8cgOvBvAAAADGEDbgB4APHIDrwbwAAAAAxhAUeAHgA8cgOv\n", + "BvAAAAFBYQGzgB4APHIDry8MeAM6AAICAAAgJRAAGAACAPedmL1gACJXt4GAAJ0MECAATgE4AtTI\n", + "BDkzmEFEYAw5XasAQgiiPB5oQT5g+AYrSgEDTs21IT8HLDcB5k5YhCu5wAOMVdNryHKGBqJsWH/g\n", + "HRxHYTkN1b2zOCVuEAAIAQBgsmEAAIJYAAgZgAKA9gAeVnrh5EWyFpz9+AB0ANimwEAVQL7/AZ1n\n", + "94Y4VwBgihCSAtlgkNfOi0sBvDnYAAgIyAACAkABsQABAHX+v+BwA0QIgACAagAccUgPCLbOxJgE\n", + "gR1pf4egIVYK+XKNnCAgrANTFVtpf6P7ITDPwMroChFwrNR1XutKHvADHW8ET8winFUV9d/gwwgA\n", + "DIFEshAACBUAAICQAoPAnybAFQyxY3Se/4EogjBXMAbYXSGQLrj7/hSAAAAADGEAh+AHgA8cgOvB\n", + "vAAAAAxhAKLgB4APHIDrwbwAAAAMYQC94AeADxyA68DbAAADjm1vb3YAAABsbXZoZAAAAAAAAAAA\n", + "AAAAAAAAA+gAAAwcAAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA\n", + "AAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAK4dHJhawAAAFx0a2hkAAAAAwAA\n", + "AAAAAAAAAAAAAQAAAAAAAAwcAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAA\n", + "AAAAAAAAAAAAQAAAAAGwAAABIAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAAMHAAAAAAAAQAA\n", + "AAACMG1kaWEAAAAgbWRoZAAAAAAAAAAAAAAAAAAAKAAAAHwAVcQAAAAAAC1oZGxyAAAAAAAAAAB2\n", + "aWRlAAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAAAdttaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAA\n", + "AAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAGbc3RibAAAAKdzdHNkAAAAAAAA\n", + "AAEAAACXYXZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAGwASAASAAAAEgAAAAAAAAAAQAAAAAA\n", + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAACVhdmNDAULAFf/hAA5nQsAVjI1A2EpA\n", + "PCIRqAEABGjOPIAAAAAcdXVpZGtoQPJfJE/FujmlG88DI/MAAAAAAAAAGHN0dHMAAAAAAAAAAQAA\n", + "AB8AAAQAAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAAcc3RzYwAAAAAAAAABAAAAAQAAAB8AAAABAAAA\n", + "kHN0c3oAAAAAAAAAAAAAAB8AABf6AAADMgAAAZ8AAAHxAAABjQAAAiQAAAVcAAAEggAAAyIAAAzL\n", + "AAAK+gAADG0AAA1kAAAQAQAAC94AAAZ5AAAFqwAABQEAAAPwAAACogAAAkMAAAJPAAAB6AAAAY0A\n", + "AAE7AAABRgAAAXoAAADTAAACAAAAASQAAAGyAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAA\n", + "AFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0\n", + "b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjQ1LjEwMA==\n", + "\">\n", + " Your browser does not support the video tag.\n", + "</video>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import animation\n", + "from IPython.display import HTML\n", + "\n", + "style_list=['ro', 'g^', 'yx', 'cs']\n", + "parity_list=['+,+', '+,--', '--,+', '--,--']\n", + "\n", + "# First set up the figure, the axis, and the plot element we want to animate\n", + "fig = plt.figure();\n", + "ax = plt.axes(xlim=(1e-14, 10), ylim=(-60, 60));\n", + "ax.set_xscale(\"log\");\n", + "lines = []\n", + "\n", + "fig = plt.figure();\n", + "ax = plt.axes(xlim=(1e-14, 5), ylim=(-60, 60));\n", + "ax.set_xscale(\"log\");\n", + "for j in range(num_blocks):\n", + " temp_line, = ax.plot([], [], style_list[j], label=parity_list[j]);\n", + " lines.append(temp_line);\n", + "\n", + "# Initialization function: plot the background of each frame\n", + "def init():\n", + " for j in range(len(lines)):\n", + " lines[j].set_data([], []);\n", + " return lines\n", + "\n", + "# Animation function which updates figure data. This is called sequentially\n", + "def animate(i):\n", + " for j in range(num_blocks):\n", + " lines[j].set_data(np.abs(np.real(evals_list[i][j,:])), np.imag(evals_list[i][j,:]));\n", + " return lines\n", + "\n", + "# Call the animator. blit=True means only re-draw the parts that have changed.\n", + "anim = animation.FuncAnimation(fig, animate, init_func=init,\n", + " frames=31, interval=100, blit=True);\n", + "\n", + "plt.close(anim._fig);\n", + "\n", + "# Call function to display the animation\n", + "HTML(anim.to_html5_video())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4c494cd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "827580b8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a606aa37", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "30c48fa7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5af81bcd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3e7dce67", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xscale(\"log\")\n", + "plt.plot(Grange, num_even, 'bo-', ms=5, label=\"even\")\n", + "plt.plot(Grange, num_odd, 'rs-', ms=5, label=\"odd\")\n", + "\n", + "plt.xlabel(r\"$G$\")\n", + "plt.ylabel(r\"$\\langle a^{\\dagger} a\\rangle$\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50f826f2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "22984485", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.plot(Grange, -np.real(gap_even), 'bo-', ms=5, label=\"even\")\n", + "plt.plot(Grange, -np.real(gap_odd), 'rs-', ms=5, label=\"odd\")\n", + "\n", + "plt.axhline(1, c='k', ls='--')\n", + "\n", + "plt.ylabel(r\"$-\\Re(\\lambda_1)$\")\n", + "plt.xlabel(r\"$G/U$\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2ae076ca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.xscale(\"log\")\n", + "plt.plot(Grange, -np.real(gap_even_odd), 'g^-')\n", + "plt.plot(Grange, -np.real(gap_odd_even), 'yh-')\n", + "\n", + "plt.yscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "277b6ed2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2217ee9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bdefffd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "136fadfe", + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"GoverDelta_scan.pckl\", \"rb\") as fp:\n", + " Deltarange, results = pickle.load(fp)\n", + "\n", + "Grange, num_even, num_odd, gap_even, gap_odd, gap_even_odd, gap_odd_even = list(list(zip(*results)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7f9574e3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.yscale(\"log\")\n", + "plt.xscale(\"log\")\n", + "plt.pcolormesh(Grange[0]/Deltarange[0], Deltarange, num_even, shading='auto', cmap='viridis', vmin=0, vmax=11)\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36413363", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Tests/.ipynb_checkpoints/test2-checkpoint.ipynb b/Tests/.ipynb_checkpoints/test2-checkpoint.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..e8441906e0757ee53330de43fe30c49055e71f75 --- /dev/null +++ b/Tests/.ipynb_checkpoints/test2-checkpoint.ipynb @@ -0,0 +1,591 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "466e6e45", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(1, '/Users/lucagravina/dptqm/Strucutral codes/Liouvillian block diagonalization')\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from qutip import * \n", + "\n", + "import scipy.sparse as spr\n", + "import block_diagonalize\n", + "import time\n", + "import os\n", + "import pickle\n", + "import matplotlib.image as mpimg\n", + "\n", + "from collections import deque\n", + "\n", + "\n", + "from matplotlib.colors import LinearSegmentedColormap \n", + "import matplotlib.colors as colors\n", + "greiner = { 'red': ((0., 1, 1,), (.2, 0, 0), (.48, 0, 0), (.728, 1, 1), (0.912, 1, 1), (1, .5, .5)),\n", + " 'green': ((0., 1, 1), (.2, 0, 0), (.3, 0, 0), (.5, 1, 1), (.712, 1, 1), (.928, 0, 0), (1, 0, 0)),\n", + " 'blue': ((0., 1, 1), (.2, .5, .5), (.288, 1, 1), (.472, 1, 1), (.72, 0, 0), (1, 0, 0)) }\n", + "greiner = LinearSegmentedColormap('greiner', greiner)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a967f6f9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "4b11dd09", + "metadata": {}, + "outputs": [], + "source": [ + "class Parameters():\n", + " def __init__(self, Δ, N, Grat, ηtilde, Utilde):\n", + " self.Δ = Δ\n", + " self.N = N \n", + " self.ηtilde = ηtilde \n", + " self.Utilde = Utilde\n", + " self.U = self.Utilde/self.N\n", + " self.η = self.ηtilde/self.N\n", + " \n", + " self.Gc = np.abs(self.η*self.Δ/np.sqrt(self.η**2+self.U**2))\n", + " self.G = Grat*self.Gc\n", + " self.n_sc = lambda g : self.U*self.Δ/(self.U**2+self.η**2)*(1+np.sqrt((g**2-1)*np.heaviside(g-1,1)))*np.heaviside(g-1,1)\n", + "\n", + "class Kerr_2γ():\n", + " def __init__(self, Nfock, p):\n", + " self.Nfock = Nfock\n", + " self.a = destroy(Nfock)\n", + " self.parity = 1.j*np.pi*self.a.dag()*self.a\n", + " self.parity = self.parity.expm()\n", + " \n", + " self.p = p\n", + " self.c_ops = [np.sqrt(p.η)*self.a**2]\n", + " self.H = -p.Δ*self.a.dag()*self.a + p.G/2 *(self.a.dag()**2 +self.a**2) + p.U/2 *self.a.dag()**2*self.a**2\n", + " self.LL = liouvillian(self.H, self.c_ops)\n", + " \n", + " def bd(self):\n", + " P, block_bfs, block_sizes = block_diagonalize.PermMat(self.LL)\n", + " self.bd_L = np.dot(P, np.dot(self.LL.data, np.transpose(P)))\n", + " self.num_blocks, self.blocks_list, self.bl_indices = block_diagonalize.get_blocks(self.bd_L) \n", + "\n", + " done=False\n", + " for i in range(int(len(self.blocks_list))):\n", + " block = self.blocks_list[i]\n", + " evals, evecs = Qobj(block).eigenstates() \n", + "\n", + " ss_block_form = evecs[-1]\n", + " evec2 = spr.dok_matrix((self.LL.shape[0], 1), dtype='complex')\n", + " evec2[self.bl_indices[i]:self.bl_indices[i]+self.blocks_list[i].shape[0]] = ss_block_form.data\n", + " evec2 = evec2.tocsr()\n", + " evec2 = np.dot(np.transpose(P),evec2)\n", + " ss= Qobj(evec2, dims=[self.LL.dims[0], [1]])\n", + " ss=vector_to_operator(ss)\n", + "\n", + " if np.real(ss.tr())>0.05:\n", + " ss=ss+ss.dag()\n", + " ss/=(ss.tr()) \n", + " if expect(self.parity, ss)>0.5:\n", + " num_even = expect(ss, self.a.dag()*self.a)\n", + " gap_even = evals[-2]\n", + " else:\n", + " num_odd = expect(ss, self.a.dag()*self.a)\n", + " gap_odd = evals[-2]\n", + " elif done==False:\n", + " gap_even_odd = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", + " gap_odd_even = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", + " done=True\n", + " return num_even, num_odd, gap_even, gap_odd, gap_even_odd, gap_odd_even\n", + " \n", + " \n", + "def get_cutoff(p, c0=5, cmax=100, step=5, precision=0.005):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " k = Kerr_2γ(Nfock=c0,p=p)\n", + " nprev = k.bd()[0]\n", + " c = c0+step\n", + " while c<cmax:\n", + " k = Kerr_2γ(Nfock=c,p=p)\n", + " n = k.bd()[0]\n", + " if metric(n,nprev):\n", + " c -= step\n", + " while 1:\n", + " step = np.max([step//2,1])\n", + " k = Kerr_2γ(Nfock=c-step,p=p)\n", + " if metric(k.bd()[0],n): \n", + " c -= step\n", + " elif step==1: return c \n", + " else:\n", + " nprev = n\n", + " c += step\n", + " return np.inf\n", + "\n", + "def map_cutoff(Utilderange, Δrange, Grange):\n", + " C = np.zeros((Utilderange.size, Δrange.size, Grange.size),dtype='float')\n", + " for i in range(Utilderange.size):\n", + " Utilde=Utilderange[i]\n", + " for j in range(Δrange.size):\n", + " Δ=Δrange[j]\n", + " for k in range(Grange.size):\n", + " Grat=Grange[k]\n", + " p = Parameters(Δ=Δ, N=10, Grat=Grat, ηtilde=1, Utilde=Utilde)\n", + " C[i,j,k] = get_cutoff(p, c0=5, cmax=100, step=5, precision=0.005)\n", + " return C" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d73b1b75", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8f886292", + "metadata": {}, + "source": [ + "# Symmetry-preserving 1st order PT\n", + "\n", + "In this case we look at the model \n", + "\n", + "$$\n", + "\\hat{H}=-\\Delta \\hat{a}^{\\dagger} \\hat{a}+\\frac{U}{2}\\hat{a}^{\\dagger^2} \\hat{a}^2 + \\frac{G}{2} \\left[\\hat{a}^{{\\dagger}^2} + \\hat{a}^{\\dagger^2}\\right]\n", + "$$\n", + "\n", + "with\n", + "\n", + "$$\n", + "U=\\tilde{U} / N, \\quad \\eta=\\tilde{\\eta} / N\n", + "$$\n", + "\n", + "and two-photon dissipation $\\eta\\mathrm{D}\\left[a^2\\right]$.\n", + "\n", + "Here we have a strong-parity symmetry which is preserved in the 1st order PT. In particular we have a 1st order PT for each of the two NESS with opposite parity: within each parity sector we have a level touching with subsequent PT.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "375b8dd0", + "metadata": {}, + "source": [ + "### General example\n", + "\n", + "We are interested in the PT in $G$. In the following we observe for $\\tilde\\eta = 1$, $\\tilde U/\\tilde\\eta = \\Delta/\\tilde\\eta = 10$ and $N=10$ a typical 1st order PT in both NESS.\n", + "\n", + "The level touching is observable in both symmetry sectors. \n", + "\n", + "The question is: how does the hysteresys area change in the remaining parameters ($\\Delta$, $U$)?" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3004e4b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed: 20/20" + ] + } + ], + "source": [ + "Grange = np.linspace(0,2,20)\n", + "\n", + "num_even = np.zeros(Grange.size)\n", + "num_odd = np.zeros(Grange.size)\n", + "gap_even = np.zeros(Grange.size, dtype='complex')\n", + "gap_odd = np.zeros(Grange.size, dtype='complex')\n", + "gap_even_odd = np.zeros(Grange.size, dtype='complex')\n", + "gap_odd_even = np.zeros(Grange.size, dtype='complex')\n", + "\n", + "\n", + "for i in range(Grange.size):\n", + " Grat = Grange[i]\n", + " p = Parameters(Δ=1.5, N=10, Grat=Grat, ηtilde=1, Utilde=1)\n", + " k = Kerr_2γ(Nfock=40, p=p) \n", + " num_even[i], num_odd[i], gap_even[i], gap_odd[i], gap_even_odd[i], gap_odd_even[i] = k.bd()\n", + " print(\"\\rCompleted: %d/%d\"%(i+1,Grange.size),end='')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bfe6d8e7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 2160x648 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize=(30,9))\n", + "\n", + "g=np.linspace(Grange.min(),Grange.max(),1000)\n", + "\n", + "ax[0].plot(Grange, num_even/p.N, 'bo-', ms=5, label=\"even\")\n", + "ax[0].plot(g, p.n_sc(g)/p.N, 'g-', lw=3, label=\"SC\")\n", + "ax[0].plot(Grange, num_odd/p.N, 'rs-', ms=5, label=\"odd\")\n", + "ax[0].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", + "\n", + "#ax[0].set_xscale(\"log\")\n", + "ax[0].set_xlabel(r\"$G\\,/\\,G_c$\")\n", + "ax[0].set_ylabel(r\"$\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", + "ax[0].legend()\n", + "\n", + "ax[1].plot(Grange, -np.real(gap_even), 'bo-', ms=5, label=\"even\")\n", + "ax[1].plot(Grange, -np.real(gap_odd), 'rs-', ms=5, label=\"odd\")\n", + "ax[1].axhline(-np.real(gap_even)[0], c='k', ls='--')\n", + "ax[1].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", + "\n", + "#ax[1].set_xscale(\"log\")\n", + "ax[1].set_yscale(\"log\")\n", + "ax[1].set_ylabel(r\"$-\\Re(\\lambda_1)\\,/\\,\\tilde\\eta$\")\n", + "ax[1].set_xlabel(r\"$G\\,/\\,G_c$\")\n", + "ax[1].legend()\n", + "\n", + "\n", + "ax[2].plot(Grange, -np.real(gap_even_odd), 'g^-')\n", + "ax[2].plot(Grange, -np.real(gap_odd_even), 'yh-')\n", + "ax[2].set_xlabel(r\"$G\\,/\\,G_c$\")\n", + "ax[2].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", + "\n", + "#ax[2].set_xscale(\"log\")\n", + "ax[2].set_yscale('log')\n", + "\n", + "fig.tight_layout()\n", + "#fig.savefig(\"PL_Delta=Utilde=10_N=10.png\", dpi=500)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d909281", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "a199be0e", + "metadata": {}, + "source": [ + "## Estimating convergence of Hilbert space truncation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "971b6bfa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "33.93870401382446" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "step = 1\n", + "cuts = np.arange(10,50,step)\n", + "\n", + "num_even = np.zeros(cuts.size)\n", + "num_odd = np.zeros(cuts.size)\n", + "gap_even = np.zeros(cuts.size, dtype='complex')\n", + "gap_odd = np.zeros(cuts.size, dtype='complex')\n", + "gap_even_odd = np.zeros(cuts.size, dtype='complex')\n", + "gap_odd_even = np.zeros(cuts.size, dtype='complex')\n", + "\n", + "Grat=1.8\n", + "p = Parameters(Δ=1.5, N=10, Grat=Grat, ηtilde=1, Utilde=1)\n", + "\n", + "t1=time.time()\n", + "for i in range(cuts.size):\n", + " k = Kerr_2γ(Nfock=cuts[i], p=p) \n", + " num_even[i], num_odd[i], gap_even[i], gap_odd[i], gap_even_odd[i], gap_odd_even[i] = k.bd()\n", + "time.time()-t1" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "1b5e0401", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c= 35 time= 4.905393362045288\n" + ] + } + ], + "source": [ + "t1 = time.time()\n", + "c = get_cutoff(p,c0=36,cmax=60,step=6,precision=0.01)\n", + "print(\"c=\",c,\" time=\",time.time()-t1)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "6876c0dd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax = plt.subplots(1,3,figsize=(18,5))\n", + "\n", + "ax[0].plot(cuts,num_even,'o-')\n", + "ax[0].plot(cuts,num_odd,'o-')\n", + "ax[0].axvline(c,c='r',ls='--',lw=2)\n", + "ax[0].set_xlabel(r\"$N_{cut}$\")\n", + "ax[0].set_ylabel(r\"$n\\,(\\,N_{cut}\\,)$\")\n", + "\n", + "ax[1].set_yscale(\"log\")\n", + "ax[1].plot(cuts[1:],(np.gradient(num_even,cuts)*100)[1:],'o-')\n", + "ax[1].plot(cuts[1:],(np.gradient(num_odd,cuts)*100)[1:],'o-')\n", + "ax[1].axvline(c,c='r',ls='--',lw=2)\n", + "ax[1].set_xlabel(r\"$N_{cut}$\")\n", + "ax[1].set_ylabel(r\"$\\partial_{N_cut}\\,n\\,(\\,N_{cut}\\,)$\")\n", + "\n", + "ax[2].plot(cuts[2:],(np.gradient(np.gradient(num_odd,cuts),cuts)*100)[2:],'o-')\n", + "ax[2].axvline(c,c='r',ls='--',lw=2)\n", + "ax[2].set_xlabel(r\"$N_{cut}$\")\n", + "ax[2].set_ylabel(r\"$\\partial^2_{N_cut}\\,n\\,(\\,N_{cut}\\,)$\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7aa3b8c2", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2edda78b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbccad86", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "76680780", + "metadata": {}, + "outputs": [], + "source": [ + "Δrange = np.linspace(0.,3.5,11)\n", + "Utilderange = np.linspace(1,1,1)\n", + "Grange = np.linspace(0.1,2,10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b123bbf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b041c2e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b45cdb9", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44386e9c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "22ab118b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d0839e6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93df735b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7171447", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da108646", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "53d5cb37", + "metadata": {}, + "outputs": [], + "source": [ + "def get_cutoff_MK1(cuts, p, precision=0.01):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " q = deque()\n", + " \n", + " k = Kerr_2γ(Nfock=cuts[0], p=p)\n", + " q.append(0)\n", + " q.append(k.bd()[0])\n", + " \n", + " for i in range(1,cuts.size):\n", + " k = Kerr_2γ(Nfock=cuts[i], p=p)\n", + " ni = k.bd()[0]\n", + " μi = metric(ni,q.pop())\n", + " q.append(μi)\n", + " print(q[0],q[1],i)\n", + " if (q.popleft())*(q[0])==True : \n", + " return i-1\n", + " q.append(ni)\n", + " \n", + " if q[0]==True:\n", + " print(\"Carefull: Convergence on border\")\n", + " return i\n", + " else: return np.inf\n", + " \n", + " \n", + " \n", + " \n", + "def get_cutoff_MK2(p, c0=5, cmax=100, step=5, precision=0.005):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " k = Kerr_2γ(Nfock=c0,p=p)\n", + " nprev = k.bd()[0]\n", + " c = c0+step\n", + " while c<cmax:\n", + " k = Kerr_2γ(Nfock=c,p=p)\n", + " n = k.bd()[0]\n", + " if metric(n,nprev):\n", + " c -= step\n", + " while 1:\n", + " k = Kerr_2γ(Nfock=c-1,p=p)\n", + " if metric(k.bd()[0],n): c -= 1\n", + " else: return c\n", + " else:\n", + " nprev = n\n", + " c += step\n", + " return np.inf\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5385b39", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Tests/Ramp_G/.DS_Store b/Tests/Ramp_G/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..1eefd3ca3ea01eea95e8188f65466a20c5f74b6a Binary files /dev/null and b/Tests/Ramp_G/.DS_Store differ diff --git a/Tests/test1.ipynb b/Tests/test1.ipynb index b49813ba05675298af5528976aebb19bb3bb3a9b..43c5e77f455e3236026fb999aa2b0a377b5c77b8 100644 --- a/Tests/test1.ipynb +++ b/Tests/test1.ipynb @@ -2,11 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "d6682c69", "metadata": {}, "outputs": [], "source": [ + "import sys\n", + "sys.path.insert(1, '/Users/lucagravina/dptqm/Strucutral codes/Liouvillian block diagonalization')\n", + "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from qutip import * \n", @@ -16,9 +19,16 @@ "import time\n", "import os\n", "import pickle\n", - "import matplotlib.image as mpimg\n", - "\n", - "\n", + "import matplotlib.image as mpimg" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f7f68665", + "metadata": {}, + "outputs": [], + "source": [ "from matplotlib.colors import LinearSegmentedColormap \n", "import matplotlib.colors as colors\n", "\n", @@ -31,14 +41,14 @@ { "cell_type": "code", "execution_count": null, - "id": "f7f68665", + "id": "bfaa372d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "5e80c9bb", "metadata": {}, "outputs": [ @@ -46,19 +56,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "20.10335111618042\n" + "1.5653400421142578\n" ] } ], "source": [ - "a=destroy(28)\n", + "a=destroy(10)\n", "\n", "parity=1.j*np.pi*a.dag()*a\n", "parity=parity.expm()\n", "\n", "Delta = 10\n", "U = 0.1\n", - "eta = 0.1\n", + "eta = 1\n", "\n", "Grange = np.geomspace(5e-2, 3e3, 31)\n", "c_ops = [np.sqrt(eta)*a**2]#, np.sqrt(beta)*a.dag()*a]\n", @@ -90,7 +100,7 @@ " evals_keep[i,:] = evals[-num_keep:]\n", " \n", " ss_block_form=evecs[-1]\n", - " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", + " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype='complex')\n", " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", " evec2 = evec2.tocsr()\n", " evec2=np.dot(np.transpose(P),evec2)\n", @@ -117,23 +127,23 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "dc957fcc", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "<matplotlib.legend.Legend at 0x7fd7f50e3820>" + "<matplotlib.legend.Legend at 0x7fa12a218c40>" ] }, - "execution_count": 8, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD8CAYAAACSCdTiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAf20lEQVR4nO3dfXBc1Z3m8e/PIOI4yLhtjBXZ6IUswVFIxiQymZTD2ErCkiUJJBlWRa1ICJsqBS+ZSmp2i8FonQyotJVoKt7JLF4TxUTOzihDBIQ1RZgNAWSIbQZsYyXYzZsTW23RknHsxtteFUiWzv7R3XK31C1L6nu729fPp0rV6nNfzs9u6blHp2/fa845REQkmOYUuwAREfGPQl5EJMAU8iIiAaaQFxEJMIW8iEiAKeRFRALs/GIXkO7iiy92NTU1xS5DROSssmfPnj855xZnW1ZSIV9TU8Pu3buLXYaIyFnFzPpyLdN0jYhIgCnkRUQCTCEvIhJgJTUnn83IyAj9/f288847xS7Fc3PnzmXZsmWUlZUVuxQRCaiSD/n+/n7Ky8upqanBzIpdjmeccxw7doz+/n5qa2uLXY6IFNhAfICbH7mZX9z0CyourPCtn5KfrnnnnXdYtGhRoAIewMxYtGhRIP9CEZEza32ule2R7bQ+2+prPyUf8kDgAj4lqP8uEZnaQHyAzt5OxtwYnb2dDJ4c9K2vsyLkRUSCpPW5VsbcGACjbtTX0XzwQr6rC2pqYM6cxGNXl2e73rZtG1//+tente6aNWs4dOiQZ32LSDCkRvHDo8MADI8O+zqaD1bId3VBczP09YFzicfmZk+DXkQkH+mj+BQ/R/PBCvmWFhgaymwbGkq0i4iUgOf7nx8fxacMjw6zs3+nL/2V/CmUMxKJzKx9mj7xiU/w7rvvcvLkSY4fP86KFSsA+MEPfsB11103vl5nZyc/+tGPADhw4ADXX389F1xwAbW1tTz66KN51SAiwbD3m3sL2l+wQr6qKjFFk609Dy+88AKQmJPfsmULW7Zsybrebbfdxm233QYk5uS3bNmCrqopIsUUrOmatjaYNy+zbd68RLtP7rvvPu677z7f9i8iko9ghXxTE3R0QHU1mCUeOzoS7T559dVXWbRokW/7FxHJR7CmayAR6D6F+po1a1izZk1G26FDh9iwYcOkdbdt2+ZLDSIiM+HJSN7MFpjZw2b2qpm9YmafNLOFZvYbM3sj+Rjyoq9S8/jjj3PBBRcUuwwRkay8mq75EfB/nHPLgT8DXgHuAp52zl0OPJ18LiIiBZR3yJvZfOAvgAcAnHPDzrm3gRuBnyVX+xnwpXz7EhE5a/n4afypeDEnfxlwFOg0sz8D9gDfBpY45wYAnHMDZnZJto3NrBloBqjK81RHEZGSlPo0/tAQFY88wpGFCxPtae/dLSkrY3DVKs+79mK65nzgY8Am59xVwP9jBlMzzrkO51y9c65+8eKsNxsXETm7pX0afzzgJzgyMuJL116EfD/Q75x7Ifn8YRKhf8TM3g+QfHzLg75ERM4+eX7qPh95h7xzbhA4bGZXJJs+A4SBx4Bbk223Alvz7UtE5KxUxKlor86u+Sugy8x+D6wA/hvwfeBaM3sDuDb5vCAG4gOs3rLa80t3zuRSwyIi47J9Gr9APPkwlHOuF6jPsugzXux/ptJvq7Xx8xuLUYKIyGmpD2gW4Yq4wbqsAYW9rZaIyLQ1NcGhQywpK8u6OFd7vgJ3WYNst9XKdzQ/3UsNi4iciR+nSU4lUCGf67Za61evp+LCilnvdzqXGh4dHeXjH/84ADfccANXXXUV99xzDwCbN2+mvj7bbJaIiL8CFfJT3VbLr7n51GWGv/Wtb9Hb25ux7Mtf/rIvfYqITFeg5uQLfVst0KWGRaS0BWok7/dttWZyqWERkVIQqJAvhscff7zYJYiI5BSo6RoRkVLi1wczZ0IhLyLik9QHM7t3foVYrCdj2R+iD3P3Ly/z/QCgkBcR8UH6BzN//voe9u2/aTzoY7Ee3njtq/z68CFan231tQ6FvIiID9JP6d77Njwdv4ZwuJGDB7/Lvv038b39o7z0tvP9k/kKeRERj2X7YGb7S08y/+Kv0tfXyu+Haul924DTn+Xxi0JeRMRj2T6YeeX8EaLRTSx6/3dYZnuoK8/8ZL5fo/lAhXwk0j7pzY1YrIdIpL3gtdTU1BS8TxEpDRM/mLliAdx9xSk2H17KpgPv0vbq+XzvQ4l28Hc0H6jz5MvLVxION1JX100o1EAs1jP+XESkUCZ+MDMSaae8fCVfCjVw1Y+vovf4Ke55BZaXQ+/b/n4yP1AhHwo1UFfXTTjcSGXlWqLRTeOBLyJSLFVVd45/P/EA8M8+9x2o6RpIBH1l5Vr6+lqprFxb0IBva2tjxYoVrFixgmg0Ov79HXfcUbAaRETSBWokD4k5+Gh0E9XV64lGN7FgQUPeQb9x40Z+8pOfALB48WKOHj1KfX09mzdvzlivpaWFluSdX2pqaiZdlVJEpNACFfLpc/ChUAMLFjRkPJ+tO+64I+dofN26dVx99dW6rLCIlKRATdfE47syAj01Rx+P7/Ktz5dffpmKitnfkERExE+ejeTN7DxgN/Cmc+4LZrYQ+AVQAxwCGp1zMa/6yyb9zY2UUCj/6ZqpjIyM8MlPfnJS+6FDh3zrU0RkurwcyX8beCXt+V3A0865y4Gnk88D59e//nWxSxCRUtDVBTU1MGdO4rGrq9gVAR6FvJktAz4PpL8TeSPws+T3PwO+5EVfIiIlp6sLmpuhrw+co2LDBmzpUmzbtoyviq1bC34Q8Gq65u+BO4HytLYlzrkBAOfcgJldkm1DM2sGmgGqqqo8KkdEpIBaWmBoaPzpkYULs6525KKLxg8CRxYuhG3bMpYvKStjcNUqT0vLeyRvZl8A3nLO7ZnN9s65DudcvXOufvHixfmWIyJSeJHIjFbPeRAYGfGimgxeTNesAm4ws0PAg8CnzeyfgCNm9n6A5ONbHvQlIlJ6SngWIu+Qd86tc84tc87VADcDzzjnbgEeA25NrnYrsDXfvkRESlJbG8ybV+wqsvLzPPnvA9ea2RvAtcnnIiLB09QEHR1QXQ1mxa4mg6efeHXObQO2Jb8/BnzGy/2fScWOHVnntPx4M0NEJENTU+ILWJIri06cKPhBIFCXNcj1poUfb2aIiOQy5aBybCz3QaCszPNaAhXyIiJng0LOLATq2jUiIpJJI/lpmM6lhg8fPswXv/hFAG6//XZGR0fHt3niiSeorKwsfOEics5TyE/DdC81PPH68bpZiIgUW6Cma3K9aeHHmxkputSwiJSyQI3ki3GaZK5LDYtIcA3EB7j5kZv5xU2/oOLCivEbdadf1jwW6yEe35X1EuiFFKiRfDHoUsMi557W51rZHtlO67OtAJSXryQcbiQW6wFO36WuvHwlA/EBVm9Zzf431o8vT4nFeohE2n2tVSEvIjIDA/EBOns7GXNjdPZ2MnhycPwudOFwIwcPfjfjtqOpA8JDB17OeiAYOf8yVm9ZzeDJQV/qVciLiMxA63OtjLkxAEbd6PhoPhRqoLJyLX19rVRWriUUasg4ILS/9CQVtfdPOhD8cO8zGX8VeO2sCHnnXLFL8EVQ/10iQZUK7eHRYQCGR4fHR/OxWA/R6Caqq9cTjW4iFuuZdEDYsPeZjAPBO+cvn/RXgddK/o3XuXPncuzYMRYtWoSV2IV/8uGc49ixY8ydO7fYpYjINKWHdsqoG+X+397OtfN3jE/RLFjQwL79N7HnYJzh0cTlC4ZHh9lzcDP9F104fiB48tXfTfqrYOPnN3pac8mH/LJly+jv7+fo0aPFLsVzc+fOZdmyZcUuQ0Sm6fn+58dH8SnDo8PET75I3Z93j59dEwo18FT8U1z+vl/x4rHEeisWwF1XDPN0/Br+tvZext7zUT62/99TVw69b5/+q2D96vVUXOjdadklH/JlZWXU1tYWuwwREfZ+c++0130sEqF3cHT8+fJyuCcMzO3jb4Ef7n2G3X88n+Xlp+h9O7GOH6P5kg95EZGz0ZkOCM/3P0/v8VPsOn66bXh0mJ39Oz2tQyEvIlIEM/mrIB9nxdk1IiIyOwp5EZEAU8iLiASYQl5EJMDyDnkzu9TMeszsFTPbb2bfTrYvNLPfmNkbycdQ/uWKiPioqwtqamDOnMRjV1exK8qbF2fXnAL+s3PuJTMrB/aY2W+ArwNPO+e+b2Z3AXcBf+NBfyIi3uvqguZmGBpKPO/rSzwHaGoCoGKKG3APrlqV2EdLC0QiUFUFbW1U1NRk3+bECQa//OXx9VJ9eM28vn6KmW0F7kt+rXHODZjZ+4Ftzrkrptq2vr7e7d6929N6RESmpaYmEewTVVfDoUMA2LZtOTd3b76ZeZAAmDcP+9Wvcm6z5PhxjixcOLk9ddCYJjPb45yrz7bM0zl5M6sBrgJeAJY45wYAko+X5Nim2cx2m9nuIF66QETOEpHIzNonamnJDHiY/HyCbAEPZB35z5ZnIW9mFwKPAN9xzv3f6W7nnOtwztU75+oXL17sVTkiIjNTVTWz9ommezAoME9C3szKSAR8l3Pul8nmI8lpGpKPb3nRl4iIL9raYN68zLZ58xLt0zHdg0GBeXF2jQEPAK845zakLXoMuDX5/a3A1nz7EhHxTVMTdHQk5uDNEo8dHdN/QzTXQaLIvBjJrwK+CnzazHqTX9cD3weuNbM3gGuTz0VESldTU+JN1rGxxOOEgF9SVpZ1syVlZTkPEjm3OXHC4+Kz8/zsmnzo7BoROZec8ZTMaZrq7BpdhVJEpEhmEuSzpcsaiIgEmEJeRCTAFPIiIgGmkBcRCTCFvIhIgCnkRUrMQHyA1VtWM3hysNilnFMikXZisZ6Mtlish0ikfcrtJr5eU+0nte7+N9bPqq/ZUMiLlJjW51rZHtlO67OtxS7lnFJevpJwuHE8fGOxHsLhRsrLV0653cTXa6r9pNZ96MDLs+prNvRhKJESMhAf4LJ/uIx3Tr3De89/L3/89h+puLCi2GWdM1JhW1m5lmh0E3V13YRCDTnXz/V6ZdvPO+cvz1j35dv+kcGDt0+7r6kU7FLDIpKf1udaGXNjAIy6UY3mCywUaqCyci19fa1UVq49Y+jmer2y7Wfiuhv2PjOjvmZLIS9SIgbiA3T2djI8OgzA8Ogwnb2dmpsvoFish2h0E9XV64lGN02aN0831es1cT9/iD48ad09BzfT/+bGafWVD4W8SIlIH+mlaDRfOKkplrq6bmpr76Wurjtj3nyiXK/X/b+9fdJ+3njtq3xk/qnx9VYsgLuuGObp+DXT6isfCnmREvF8//PjI72U4dFhdvbvLFJF55Z4fFfGvHgo1EBdXTfx+K6s6+d6veInX5y0nwcOL+UD7zsd8svL4Z4wbI30TauvfOiNVxGRs5zeeBUROUcp5EVEAkwhLyISYAp5EZEAU8iLiASYQl5EJMB8v8ermX0O+BFwHrDZOfd9zzvp6oKWFohEoKoK2tom3WU9xasb54rIOeQMGTNlrhw6NL5txaOPcuSii7Kv51P++BryZnYesBG4FugHdpnZY865sGeddHVBczMMDSWe9/UlnkPWoM/2QkzVLiLnuGlkzJS5krZttoCfansv+D1dczVwwDn3R+fcMPAgcKOnPbS0nP7PTxkaSrSLiOQr34yZuG2B+R3yS4HDac/7k23jzKzZzHab2e6jR4/OvIdIZGbtIiIzcZZnjN8hb1naMq6j4JzrcM7VO+fqFy9ePPMeqqpm1i4iMhNnecb4HfL9wKVpz5cBUU97aGuDefMy2+bNS7SLiOQr34yZuG2B+R3yu4DLzazWzC4AbgYe87SHpibo6IDqajBLPHZ05Dy7ZklZ2YzaReQcN42MmTJX0rZdcuJE7vV84vtVKM3seuDvSZxC+VPnXM7Dn65CKSIyc1NdhdL38+Sdc08AT/jdj4iITKZPvIqIBJhCXkQkwBTyIiIBppAXEQkwhbyISIAp5EVEfDAQH2D1ltUMnhwkEmknFuvJWB6L9bDvjf86vo5fFPIiJSJXEEQi7UWq6NyUHs5TOdPr1fpcK9sj22l9tpXy8pWEw43j68diPYTDjTx04OXxdfyikBcpEbmCoLx8ZZErO7ekh/NUpnq9BuIDdPZ2MubG6Ozt5N2yD1FX10043MjBg98lHG6konYT7S89Ob6OX6N5hbxIiQiFGiYFQV1dN6FQQ7FLO2dMDOepgneq16v1uVbG3BgAo26U1mdbCYUaqKxcS19fK5WVa/nh3mcmreMHhbxICZkYBAr4wsoWzlPJ9nqlDhTDo8MADI8O09nbyR+ijxCNbqK6ej39b25kz8HNk9bxYzSvkBcpIbFYz3gQRKObJs35in9yhfNUwZvt9Uo/UKRcOX+EA6/dQl1dN7W19/JU/FOsu2KEFQtOr+PXaF4hL1IiUnO6qSBITQUo6AsjWzhPFby5Xq+jx54cP1CkfOB9p9h8eOn4X2aPRSLcE4bl5afXGR4dZmf/Tm//URTgKpQzoatQyrksEmmnvHxlxhRNLNZDPL6Lqqo7i1jZueGqH19F72DvpPYVFSvY+829k9pL6fWa6iqUCnkRkbPcVCGv6RoRkQBTyIuIBJhCXkQkwBTyIiIBppAXEQkw3+/xKiJyLqvYsYMjIyOT2pecOAGjoxxZuHDysrIyBlet8qT/vEbyZvZ3Zvaqmf3ezB41swVpy9aZ2QEze83Mrsu7UhERv3V1QU0NzJmTeOzqylhcsWMHtm3bpK+KHTtybp8t4AGOXHRR1oAHcm4zG/lO1/wGuNI591HgdWAdgJnVATcDHwY+B/xPMzsvz75ERPzT1QXNzdDXB84lHpubM4I+Z2CPjOTevsjyCnnn3JPOuVPJp/8KLEt+fyPwoHPuXefcQeAAcHU+fYmI+KqlBYaGMtuGhhLt+WxfZF6+8fofgX9Jfr8UOJy2rD/ZNomZNZvZbjPbffToUQ/LERGZgUhkZu2zXa/AzhjyZvaUme3L8nVj2jotwCkg9XeNZdlV1usnOOc6nHP1zrn6xYsXz+bfICKSv6qqmbXPdr0CO2PIO+c+65y7MsvXVgAzuxX4AtDkTl8Ipx+4NG03y4Co18WLiHimrQ3mzctsmzcv0Z7H9ktGR7OuvuTECZYcP559WVnZ9PqchrxOoTSzzwF/A6x2zqVPPj0G/NzMNgCVwOXAi/n0JSLiq6amxGNLS2LqpaoqEdypdhLhm/V0yLKynNsPfuYzhag+p7yuQmlmB4D3AMeSTf/qnLs9uayFxDz9KeA7zrl/yb6X03QVShGRmZvqKpR5jeSdc/9mimVtwDT/zhERET/osgYiIgGmkBcRCTCFvIhIgCnkRUQCTCEvIlJAA/EBVm9Zzf431hOL9WQsi8V6iETaPe1PIS8i4pFUgA+eHCQSac8a4t3Pf4Xtke08dOBlwuHG8XVisR7C4UbKy1d6WpNCXkRkmnIFd2r03fpcK9sj22l9tpXy8pWTQnzf/pv4+et7GHNjtL/0JBW19xMON3Lw4HcJhxupq+smFGrwtGaFvIjINGUL7tToeyA+QGdvJ2NujM7eTt4t+xB1dd0ZIf5U/FP0vp24tNeoG2XD3meorFxLX18rlZVrPQ94UMiLiExbKNQwKbhTo+/W51oZc2NAIsBbn20lFGoYD/H5F99C+0tPMjw6DMDw6DB7Dm6m/82NVFevJxrdNOmvBC8o5EVEZiA9uFOj79QoPj3AO3s7+UP0EaLRTVRXr+fN6P18ZP6p8f2sWAB3XTHM0/FrqK29d/zg4XXQK+RFRGYgFusZD+7U6Dt9FJ9y5fwRDrx2C3V13dTW3ssDh5dy9xWnWLEgsXx5OdwThq2RPuD0Xwnx+C5P69WNvEVEpik1B5+aolmwoIFwuJGjxy4aH8WnfOB9p9h8uJrrGhLz7A997QCxWA9bl++iqurOrPsPhRo8n5fP6yqUXtNVKEWklEUi7ZSXr8wI4lish3g8d3AXgm9XoRQROZdkC3I/Rt9e0py8iEiAKeRFRAJMIS8iEmAKeRGRANMbryIihdDVNX6T74pHH+XIRRdNWmVJWRmDq1Z52q1CXkTEYxU7dnBkZCSzcelSlmzYwOBf/mXWgAcmb+MBT6ZrzOy/mJkzs4vT2taZ2QEze83MrvOiHxGRktXVBTU1MGdOzrA+snBhYWvCg5G8mV0KXAtE0trqgJuBDwOVwFNm9kHn3Gi+/YmIlJyuLmhuhqGhYlcyiRcj+f8O3Amkf3T2RuBB59y7zrmDwAHgag/6EhEpPS0tJRnwkGfIm9kNwJvOud9NWLQUOJz2vD/ZJiISPJHImdcpkjNO15jZU0BFlkUtwN3Av822WZa2rBfJMbNmoBmgqqrqTOWIiJSeqiro65veumYsOXEi59k1XjtjyDvnPput3cw+AtQCvzMzgGXAS2Z2NYmR+6Vpqy8Dojn23wF0QOICZTMpXkSkJLS1ZczJLzl+POubrEvKymBsjMECljbrN16dcy8Dl6Sem9khoN459yczewz4uZltIPHG6+XAi3nWKiJSmpqaEo/J8+AH//qvE8Gfai8iX86Td87tN7NuIAycAu7QmTUiEmhNTSUR6hN5FvLOuZoJz9uANq/2LyIiM6dr14iIBJhCXkQkwBTyIiIBppAXESmgSKSdWKwnoy0W6yESafelP4W8iEiBDMQHWL+zi337bxoP+lish3C4kfLylb70qZAXEfFYrtF69/Nf4Z9e38fT8WsIhxs5ePC7hMON1NV1+3YzcIW8iIjHystXEg43ZozW9+2/iZ+/vocxN0b7S08y/+Kv0tfXSmXlWt8CHhTyIiKeC4UaqKvrzhitPxX/FL1vJy7rdeX8EaLRTVRXryca3TRp1O8lhbyIiA9CoQYqK9fS19fK/Itvof2lJxkeHWbFArj7ilN8b/8Y7138n8YPBn4FvUJeRMQHsVjP+Gj9zej9fGT+KQCWl8M9r8Det6H12dbxUX88vsuXOhTyIiIeS50xU1fXTW3tvTxweCl3X3GKFQvgwcPQ+zYMjw6zs38nkBj1V1Xd6UstupG3iIjH4vFdGWfMPPS1A8RiPWxdvsu3MM9FIS8i4rFsQR4KNfh6Fk0umq4REQkwhbyISIAp5EVEAkwhLyISYAp5EZEA09k1IiKF0NUFLS1UbNjAkYULJy1eUlbG4KpVnnerkBcR8VtXFzQ3w9BQ1oAHODIy4kvXeU/XmNlfmdlrZrbfzNrT2teZ2YHksuvy7UdE5KzV0gJDQ0XpOq+RvJk1ADcCH3XOvWtmlyTb64CbgQ8DlcBTZvZB59xovgWLiJx1IpGidZ3vSH4t8H3n3LsAzrm3ku03Ag865951zh0EDgBX59mXiMjZqaqqaF3nG/IfBK4xsxfM7FkzS92/ailwOG29/mSbiMi5p60N5s0rStdnnK4xs6eAiiyLWpLbh4A/B1YC3WZ2GWBZ1nc59t8MNANUFfFoJyLim6amxGNLC0uOH895do0fzhjyzrnP5lpmZmuBXzrnHPCimY0BF5MYuV+atuoyIJpj/x1AB0B9fX3WA4GIyFmvqQmamhgscLf5Ttf8b+DTAGb2QeAC4E/AY8DNZvYeM6sFLgdezLMvERGZoXzPk/8p8FMz2wcMA7cmR/X7zawbCAOngDt0Zo2ISOHlFfLOuWHglhzL2oC2fPYvIiL50bVrREQCTCEvIhJgCnkRkQBTyIuIFFAk0k4s1pPRFov1EIm059giPwp5EZECKi9fSTjcOB70sVgP4XAj5eUrz7Dl7OhSwyIiBRQKNVBX10043Ehl5Vqi0U3U1XUTCjX40p9G8iIiBRYKNVBZuZa+vlYqK9f6FvCgkBcRKbhYrIdodBPV1euJRjdNmqP3kkJeRKSAUnPwdXXd1NbeOz5141fQK+RFRAooHt+VMQefmqOPx3f50p/eeBURKaCqqjsntYVCDXrjVUREZk4hLyISYAp5EZEAU8iLiASYQl5EJMAscSOn0mBmR4G+YtcxwcUkbmlYilTb7Ki22VFts1OI2qqdc4uzLSipkC9FZrbbOVdf7DqyUW2zo9pmR7XNTrFr03SNiEiAKeRFRAJMIX9mHcUuYAqqbXZU2+yottkpam2akxcRCTCN5EVEAkwhLyISYAp5EZEAU8jPkJldZmYPmNnDaW0fMrP7zexhM1tbgvVNaismM6szs24z22RmNxW7nnRmdk3ytdxsZjuLXU86M1tjZr9N1rem2PWkK6XfgYlK8Oe/oPWcUyFvZj81s7fMbN+E9s+Z2WtmdsDM7ppqH865PzrnvjGh7RXn3O1AIzDrDz34WN+ktmLWCPw74H8459YCX/OiLq9qc879NvlaPg78rJRqAxxwEpgL9JdSbV79DvhUm2c//17UWYh6Mjjnzpkv4C+AjwH70trOA/4AXAZcAPwOqAM+QuIXPf3rkrTtHp6w7xuAncB/KMX6crUVo8bk10bg74AdJfr6dgPzS6k2YE5yuyVAVynV5tXvQKF/J4pRZyHqyaitEJ2U0hdQM+GF+CTw67Tn64B109hP1hcI+FWp1ufVD5WHNZ4HbC211xeoAn5Swj97F3gdEF7Vllw3r98BH//ffA3VmdZZqJA/p6ZrclgKHE573p9sy8rMFpnZ/cBVZrYu2bbGzP7BzH4MPFGC9U1qK3KNNWbWAfwvEqN5P82otqRvAJ2+VXTaTP/fvpL8GftH4L4Sq83P34F8a/P75z+XrHUWuh7d4xUsS1vOT4g5544Bt09o2wZs87Sq07yob1Kbx2Za4yGg2bdqMs2oNgDn3Pd8qmWimf6//RL4pX/lZJhpbdvw73dgorx/Jwoka52Frkcj+cTR9dK058uAaJFqyabU64PSrlG1zY5qy19J1KmQh13A5WZWa2YXADcDjxW5pnSlXh+Udo2qbXZUW/5Ko85CTPyXyhfwz8AAMELiKPuNZPv1wOsk3glvUX1nZ42qTbUV66uU69QFykREAkzTNSIiAaaQFxEJMIW8iEiAKeRFRAJMIS8iEmAKeRGRAFPIi4gEmEJeRCTAFPIiIgH2/wEpT5c9q9gxfwAAAABJRU5ErkJggg==\n", "text/plain": [ "<Figure size 432x288 with 1 Axes>" ] @@ -156,1994 +166,23 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "cf16363e", + "execution_count": 12, + "id": "af20938c", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "<video width=\"432\" height=\"288\" controls autoplay loop>\n", - " <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQAA01BtZGF0AAAAUmW4AAQA\n", - "AF5MUAAQ5JNScnJycnJycnJycnJycnJycnJycnJycnJydar//8VhXwHAAKAFBRGW8ABPI4iDqQxR\n", - "EpXXXXXXXXXXXXXXXXXXXXXXXXgAAAK+ZQbuAAEAABeTFAAEOSTXcQGAR48JQAEyMxKhSDHt5A5f\n", - "h4CwVwmLSKNYEVP7yMiGikKjielH8Ayo6AuC36TMf8tcAahfJDMqUWQYdNrLIg0Qcd5P5s+er1kY\n", - "aKMlxbDSD1ewjIMowl9PyrP2uxWI4h/FfMiMaoQiOL6Eeu25+0MHAAEAECEC0zF75gPMSpg1Gst8\n", - "RxHD4JDt5LAD1KMAwhhp9NgjaC01MvLfDnZI3HgEQo+2EO+g3k+YAI229FNgwqwaDorqH4ACMiMz\n", - "IiIzGiL//+ADRoehTsYCJEcR8PwQ8ABNmN5sUMdXISeHEcR4fwQQAzNPiMv9/d9999999999999+\n", - "Im4jrHH4RfFwGAFo6TBqSAzDnhQABrCQS5YHARi3JnJlb72HAKWzlf+/+Duhdi9Cto/5EAQACAIf\n", - "UWfPFfq35Q3AAX8C1QX34R/nzeEJizmDOcsXdN2p+PmzYPH/GVYjDEf+HsAB8hxnFnIIU1qqYAAQ\n", - "AgQ0mE5OtV11sfhgH71wMnJV2psKlC/nO2iRtX6h0HEPCkQz/4AEn8imeRN0IVhMEuBa6+28HnCB\n", - "EtAibs8Qm+8PT4HeyZDiOclv+BQIwG836fIjwh/wxg0wN9ihxd1b7/ABNAT+FIHFNCs7mAYAIIPo\n", - "TAs4wZTIoHJWJv/wGXcDGv3avm74BGkaYnykV2UwIjlJnGzGsFj72jRav/+97ZtjfqVXdQUMPA3i\n", - "CKVDQdFWPShpaWlpaWlpaWlpaWlpYWUABU60rxnrRn/gB7CRz0hs+EEBb3hoJK1vv4RN9cEfvbB1\n", - "zi2/WAAvGpZpIxVQ9JVIsQs+et4Ecm+Q1wQ/3e4KNJzKIAx3PuUOXe7xdgkJ8i+CzHP8/f+ZG0YE\n", - "PJvN37/gWCcDuyHwR1B0ubSFzppXTDTbyRnaaN+79ha/rdGio7hPXXXgAAADqmUDa4AAQAAF5MUA\n", - "AQ5JNfARxXDC8ABMyMSjITnNPHYXAATIjGqEIji+hH4CIoanGC36eXTf5+8zIxLyFRhcSjLMjCcf\n", - "CnGvcbtUIwB9BiEPAsSfXNZEGiDocW8oo9XvIyIaKQqOJ6UfgKSA7dbKkyUf/w/0jDKPmmuCE0eO\n", - "f97CMgyjCX0/Kt/a7/7B6hD4mCgOAAIAIEIEpgCZGZoTZTqzLjjCMPUFEmPJa4fMXTDwAC0OGPAA\n", - "EAECEC0z+YvHnn8ADqWRg1cgnim3++DQAKqT2HiAEGG/fvwAy7+tdq0/TFvAAmbv2D7VsIUCX8GH\n", - "RLAKjAzYTMbIub4Qmo6pwFFjkBE3Z5Ec3z/j/+EMYAJkY/CmYoEPn8ACILclM2kzAikNlst+L//f\n", - "nbaBoYf8DnlPY2QTgifI0mg5fB/z3pFvJCRqvVqpLtB/gAyaNIyZhKiriTAgdM1pCkEu+AAZMhpi\n", - "k7mchXD4grXYC7fWUqi/+DCGYJmaYRMVzDzFc/DzFcw8xXPycnJycnJycnJycnJyf/HwgEOcAKqU\n", - "YBhDC39MBDtoFpsY5//wDpyVdqbCpRhhSGAEcsVI5Wc3aLBgUwCTvUb79ik4rbbEAD6Y/MJS5hJ/\n", - "/g2ywBsC5Xd/X+YhDCvMAXySwAXr+OJJ/77HgEvaWAAppr13vVR0GAE0qDZ5Iio//ZW0G8AGnQ8x\n", - "XIx6vcaUmW2Yj0s2VbXZdltqrjcJKu7TIGxvZ5bxSVRF71v3nYqRghw9hGLjpvh//D2A4AAgFAEN\n", - "CUzk5OtV11l8R3x4T1xibIyMfD19qcSXfQMX//1e/4AimwMZz61ei6DAAObk3U+vgYG4IEJjwlb5\n", - "tK/KnO7D0d2VmACH5og1mMBytEQQ4HfD/wgl4ACT9E3TakzAACInNlnwiIf8KfTQXe8OpGLIN+wJ\n", - "/tQaYVLSWltPV7/4AqbMLLPu5Y173wEAq+B72OkpVF94wo/XLWm79/fpdLS0tLS0tLS0tLS0tL/m\n", - "FqoYuvgAc+kUYD4zm9vwu4DeU/BDfdnggQt2hUBXQor/WDrH6HPvbXAeY5WwhRP/8UmR0Yt8z2rZ\n", - "LPINEG/v+CQsUPuz4wEarKMJPIcNEId9BhGqYozatx5+/DUxQIJH4YSfa/JY/ONUmFA1/6AiR68G\n", - "lNT98V16UAYO3/9XP2YMjGKLS0OATAvYz0RtoQfffnugYXJp738CmO+2P4c4nQYGl/hI9CPvPXIY\n", - "eh/jXVD9YyMojs+XXXXgAAADB2UBRuAAEAABeTFAAEOSTXx5ifDvgAJkRjVCERxfQjy77AB8yMSq\n", - "QqMLyUd55DjEFnIIaQ1vkZENFIVHE9KP8ADtFZXrE37h15BpwBGNQ9xj0HVwNC9hA2mLLl1W8/9x\n", - "BoB+SjMOvhZsa/WRBog7CC3mMPV5gBIAwRB8iXTYRkGUYS+n5Vn7XcPRoAoiMTgOAAIAIEIEpgeP\n", - "mLph4ABbgQLRSfATIzNCbKdWZccYRh6gokx5LXA48AAQAQIQJTOMX/+GsAI5YqRys5u1jaAwYMAZ\n", - "3f+P+/36dSbgJG+fRvrfPP95faB+AAm2222223gAWjgO6EFQqXofB///CGABgGqbbm//+B5iuYCA\n", - "85kQv//5OTk5OTk5OTk5OTk//+4nBdAB7sJjnhBlmA5Urw+PbApaHlJXIrlFkbxCErRfAhIjCAAj\n", - "vdwN4sOAF+VsNAKDv+YNBzw7BQ7InyFLNg8CMUD5a1VVCHLIP3cDACNnYUu75cs/ZJYJFf2pDjsJ\n", - "H8xut5oiCQB4MEAEAAjQF4Z8HCgn8BPnYbDwcIgBP/+AfQpHReAHBf8bBsEOyEYbwA+ObEqI/Q//\n", - "+/+RAxGQBScPsRyk1enohAAD4DIMAAQPIAAID/NHyD43GxYFRqYzIkHAob1CG0gjUQLoQAAmGXh/\n", - "/D2A4AAgFAENCUzk5OtV3+sbQLvrrrrrrrr//+EF2ABbkqDUhVDIJ+AAYXkpnpNapCYVEc0NcARC\n", - "UnwOou4FBIT5f8KfYLfxOuh0s10Ci8i79tdddf//OaBdAha2sZG1vl4PM58ghRP/8BKTfASpxCTl\n", - "/w/QD7og7GF4iNj4evd8tNjA9hI56QxcAAXjUs0kYqq6bbmtUguYLeiemXdU6v8Jf+A4DCAI/hoa\n", - "2wdj8ZSpsz7t/5qAckfa4hwVwnXACgVNYixFb74+gklgASqca0aIywxK1uAH5qzStf9hvHEEy5vk\n", - "v+/YRSFqQvFPW1BhJ9rBCcnyhspIkagEqDKNaiW2N3b+cWRm7kMLTrmxCZy2u8lD04a668AAAAL9\n", - "ZQGy4AAQAAF5MUAAQ5JNf/82wQwAXGQZBtLeY55u0AuQ4xBZyCGlNbAIxM+UxYAE1Z5IjzHf+vH0\n", - "GJJwXS8PC3EYTwHAAEAECECUzh/cjM0Jsp1ZlxxhGHqCiTHktc8X/+HrBdwAR2SiAkGcAP6Avy8P\n", - "kSil98CUmEATnNwSIqFwAX3RQ+gFp6/+74YLePAjFAtMwkeYICGSXig9Lx16YAW17ycnJycnJyf8\n", - "R/8FkACEWsjmLqnMTM5YP7CR9n8Ej2z3//8FcIAs4auqm7Qf6Rf+n3333x+H2W8Im+v//xi/+PgR\n", - "v6YDCAt7w0ElFtb/DABbQkq3EaYX8ACEC+wNCRBggX3TNZAcMOrrIAQEtBYQavDAAJ8EYTvHNlOW\n", - "RUUCgsfXgIW7Vo4tueAj6ix5ALb1KZmiGE6q9Ed3+PBdlGX4CwrmmbO10dm353/2HSQdLkSf/9sN\n", - "T9YP8ADfbo6RAgv3HgAPAcBGLYmYZzhIAcGAg19Zx+47j6iI9eZrmrTnbAlZ4FpEF8ksjz+iIQqZ\n", - "zCPxlPh//D2A4AAgFAENCUzk5OtV/ow/+H+AZpoH6DDGt1f7AI88DZJhjWev9/3eH/8PQx4AAgAg\n", - "QgSmcn+jh/0CyBn8mHahA7e77D9PJDRhcftf4BIQLO0xEzf4QGhriBq/O/AA//wV+maGqXoYe1Aw\n", - "6AF473xRgDmP+uuuuuuuFiQEj1vz//BC1VgJTrJi5eHaT8LP/8wvERvh6/+4TN22/0TS0tLCygAJ\n", - "pNtJJtpP//gAe5Kg1IVQyPi81eEe5SMADh9eFyRxCxy5/1+lnAUqQtHV4dLTHCMVUXa6D/+AMjRk\n", - "Rj4esZDvJMuBlWiN5Rt2CGeGABGoMBM3z5YVFvq22MIrY15A1/nUqikRgNDgl6Xe4Qx4JvXhuUpq\n", - "DId//9DwEYtkt+A5tjRJ1MPSgYfAn1nirk0KvBkO8ky7AvPeI8Gxha/v3iLQYAYaFPKPN+MN1JRd\n", - "NNv6owdRSqNjmHG+A4zhqXc0uOJPXXXgAAACymUAh7gABAAAXkxQABDkk1J/D/+HsBwABABAhAlM\n", - "5MXJycnJycnJycnDGAAiMiMjIyMjMj+AB6jmZKK6BE30H/wrTYJQmUcv4X5YABi20CHSdqWB8tys\n", - "oBAH6XLfbPDgfpYcD9L//iAEyaPhV/8R5Ek5OT/uP/gsgAYXkpnpNSkImZnwADr336LWRzF1TmJm\n", - "csFaYVpwG5lzwGlGLn7vd2/0GuNFVMGIo0A5n+l63osl4FnDV1U3af37nmjz2ROO8cppUH7QEf+5\n", - "x51Kykg22wv3vvBRZhAAiJaiOSKXt/79+0OwXpZ/KYJAf/cXG7/64CRsJyAKIPpvPGiWy11wqlv0\n", - "a0/HiVKfl9eTA0ocfnIlcjHAAEAyPAw//wHAjlPlgDPr9WP2PSGksACOlm9EjNBrgQAxOPS3W8RL\n", - "jw13LLZLejDGguNkAzZfTWf4iZSxGD8RS8P/4ewHAAEAoAhoSmcnJ1r/j/w/wAEjIhopCo4npR5f\n", - "9iQT4YBwlAD4ZSFAYe8RDbUAOZmNQKlOgI7cUpnA3CCErSpYN3+SLz3gMpUBsRmeAma9RGnxETFw\n", - "iEO4GWVVBvwalKPlLxS0UsL/4zJCw6E7wNsoaX8RBife4hKd5NcO//yIpIyMPh+IyIaKQqOJ6UWo\n", - "gzj1BZJr9d/D/9dddddddddddddddf95/8FkAHuwmOeEGWYDlSvD49sCloeUlciuUWRvEIStF8CJ\n", - "kYQACM90DeLDwAvythoBQd+YNBwOH7DUFDsifIUs2HgACA/tVVQQ5ZR+7g8BGLdLABY4rDwnmA5U\n", - "rw+e2AhR8Fbs/XJORmEISli/wShDABFgDPg4WCXQE+d+HRsOEQAlf9AfYrHVcAHBf8MMAH/DUPRS\n", - "BW4pbIAsiu9OhmtfXpGlyECMyAK6xdisVtXgoJmCAEA5okx3aQNM2L/uD7SMErHFljWsQ+kD9PXX\n", - "XgAAAj1lAKK4AAQAAF5MUAAQ5JNSfw//h7AcAAQAQIQJTOTFycnJycnJycnJycnJycnJyfz2eOo/\n", - "gAy/pZM/kCdXTeiSD/fX3tWWZubim1GGjE4bS/ttp/G8vfses0YhZsuTsd/cfcshO6O/AYP4GBxw\n", - "uTAEXzkR6jY+JZ7fdsuAjUyKPtR9n3QMkZ9x43lzTK8Fe//NVjm4kcoL+e0Y0lu3ze1sjQfv4g3a\n", - "G/sJHF74C4AZ/jMatzMC/mtsZWdPE5R2pX006f3G/W23tmP/3h/DTbCUxA/98VNOgWVyxoPf6J4R\n", - "NWTX8RhpF4f/w9gOAAIBQBDQlM5OTrX//HghgAJGRDRSFRxPSjy/4P9+cIYBfAA+AaDJRuPLMDCL\n", - "fcAOZGQZcK8OVgiXIfiImLjIQ7gZZVUG/BqUo+UvFLRSwv/jDXOKOzSlqLfwvAAAUGMS9yYemkH/\n", - "jMkLDoTvA2yhpnxEGJ97iEp3k1wYY7AAguZlpERB/D/xGRDRSFRxPSi1EGceoLJNfrg//rrrrrrr\n", - "rrrrrrrrrr/7+Y6DmAEIUKlcjObtAATFLF/U+ECH89/YBkDWmZc7xQojTnU2D13EYuf+8MsQFsBI\n", - "OKWWxMTrWb79gDXOAEwLtf39QN5D1wtLiEH//cwoIX3fWDHXX1v1+A2jg/7Nidv3w8KDQiADkVC7\n", - "oV/f1e6kwC6pLAcoU81ild+/b9Jpf5wEJANRXVQXEuVNdfMQvlg7NoBC9Kb/4KYoAws9oESyOkUD\n", - "iAJmlp/XXXgAAAfuZQC9uAAEAABeTFAAEOSTUn8P/4ewHAAEAECECUzkxcnJycnJycnJycnJycnJ\n", - "ycnDGAl9aDq/gBju9Rem+EbfuRP58thHjaInoZ7P5PsCCMuuCJtuYZgmzBYrpWaKqAUwUk8+itbg\n", - "/o36KkM7/30/6Ek1/q5jsulVhr/RkT/3B/3QD6TL2S0sGHBgaAz5alYbeWd6ZOIyhuskBt9WcwCF\n", - "us+DNO1EYjp14f/w9gOAAIBQBDQlM5OTrX//xgh4ACRkQ0UhUcT0o8v+/8weYYVgAIjCE+81Kf3k\n", - "AKGeAEhSMEF4VQ6+dt2siIMo9FvNaSbtYAJFHDf18h+fnnzxETFxkIdwMsqqDfg1KUfKXilopYX/\n", - "xmSFh0J3gbZQ0z4iDE+9xCU7ya7/8MAggh/IyIaKQqOJ6UeX/f/AMAkH4ACIjIyIyMyMjP/wAHiI\n", - "hIhCDns5A8P3x+AAjMjIiMyIjIz/+AA+RmJUKQY9vIHYd8fgAIyIzMiIjMyI//+AA6MIT7zUj1q2\n", - "x598fgAIzIyIjMiIyM//gAOzDF+qxI5alNfw74/AARkRmZERGZkR//8AB4iISYhBz2Yoe++PwAER\n", - "GRkJUVUdlf/wAHyMxLikGPbyBwfvj8ABEZkRkRmRmRH//gAOjCE+61I9atseDfa/fwYIQBeADPIo\n", - "wamMUBsHRSOc32YD00yMZk6jqBgiN6Bkm7FcDAFmGL9VSRzFMY+uCBhx/2PgoAEIx23LNwC9KOPn\n", - "nHgBTL1PB1iXRQNZwwNQfkcX3W7X82UNyzmb//i/wQeAAlEUZhxIcpylXXXff7w//CEQe/ABeQSj\n", - "vS4oHKiJ6vYCjUnYTdTx/ghov/1iNgDBHYglL3G7UeAASAMCHkyAsCMOU942Im1MYAATAMC3EwAA\n", - "AwECIYGgIZzhNKVQfZ99+eAEcLUMRjQjoKt+M8DxuPfzMzGqlKri+lPhlpkAEhlosjkXNdmhZY+8\n", - "IBoMlG48swMIt9wE8NVIwQjDLPN/28MBkH0VXCXm1CL3YP/IUdATBk81cpJSGg0L2EEUxZdhu//c\n", - "H/Dz8AhCnABcYaKMh5bjHnq8BMDhxc1mEYUWfP8ABGEuYVCdz87UfZEQbj4W015Ju1jUIcIY3+Rk\n", - "Q0UhUcT0o8AUEvcRKdzt8BWBnw3SIdBKvfSRTQ4zgAHsgCcIKxltZFYz/+EAAEgABADAKQEAAFAA\n", - "BADAIQeMNc4o/NKWoZK4X4EQmbKofxd2yhj9gCyDF6gymCC9Fn/1DD9MRAhH4T4C4DVXUDJMd7Th\n", - "xn/+5QjJhoS+FQa/sMwlArkOKGtqfebwjJSDKZN7aJ/fD84OaBAAXfAD0IhSgOOefDbUBrIwHQhU\n", - "k7Lms/98ZBi9W4hPZ6c8E9ABiVN24mr+zoABJFiCiXNKgCg/AIK+HK98XkyAolJnFdqfO40Uv/3C\n", - "ADTg7EP39wRlb8IAAIEYAAgCMGAAEwHBIEEzKkAQImbIWJz3/+ZmY1UpRjm+kcxERDwAhL3DgbkG\n", - "QbcNeU5sv//uA1GAYRzniveo2R79gajAHwM4x6AhrIJvN/jCXMKhO5+dqP4BKMhDcdjmtt8+DD8K\n", - "iO2R2f8rPD/lQw/+fgEIU4ALjDRRkPLcY89XgJgcOLmswjCiz5/gAIwlzCoTufnaj7IiDcfC2mvJ\n", - "N2uynF8ILC/xEEJ17qEdvp3wBQS9xEpvO3wFYGfDdIhUEq9SkimhwcABARylNwGIR3yUs8kgAAkA\n", - "AIAYBCAgAAoAAIAYBCDxhrnFH5pS1DJXC/AiEzZVD+Lu2UMfvRMCEWO7a6aW1//Qfl3jnupgIa74\n", - "AehEKUBxzxENtQEsjAdCFSTsshtfMzMaqUquL6U+CegAxKm7cTl/ZuApIOWp23wMsyAIDtxQ5UF9\n", - "MAKJSZxXanzuNFL/9wgA04OxD9/cEZW/CAACBGAAIAzBgABMBwSBJMupAECJshYnP7v+ZmY1UpRD\n", - "m+kcxGPCEfwnDhYCMah7pMeZYDRKGfSXC/UVbeb7gRkEqDoeU8xp6vcYZQf0ZhvN45534MP/+kwh\n", - "TgAuINB3ocWDlBE9XgJEUubIjgfxTS/7Ap8gYPVkOSP+DAUZSqqgypYxgnj/9oAyD8QZueQgRhbt\n", - "MAAM4AGO/rSNMT5SK7KC+MJM4qEbvZup4ZJYAgBGNQ9xj0HUAvDVSMEkjDLPP/+IAAJgACAEAQgL\n", - "AAEGT4g07iJRm9u4ngwRmYRRtKea4k3a0GhewgimLLrN3/7v8fkvBNPTTBJLSS8euEAG43wAXkEo\n", - "70uKByoierwCjUnYTdTx/ghov/3jIMXq3EJ7PTnh2I2AMEdiCUvcbtYmQ8AAkAYEPJhgABMAwLcT\n", - "AFgRhynvGxE2pgNAQznCaUqg+z7788AAAIEQ8ARwtQxGNCOgq3h3E0xqcfhPgBIZaLI5FzXZoWWP\n", - "uUI2w0JfCoNf3toE8EZiFFUSonwjJSDKZN7aJ/Qw/8/MIQpwA9CIUoDjniIbagNZGA6EKknZY1n/\n", - "gZZkAQHbihyoPymAKJSZxXanzuNFL/9wgA04OxD9/cEZW/Yu4UHWwDT+IghOvdQjt9O+Hl0AGJU3\n", - "biav4AcR2Fsw8mR0oT+W/kRQSIJSycRR5YYgAAgRgACAMxwzQhTEipG6WK4YsqQBAiZshYnPf/5m\n", - "ZjVSlDCO3y4x5FHEUGpTwoqQw75Ouuuuuu+u+8Nd4b77w33hrvvDXf677/XXXXgAAAAJYeAAQACc\n", - "i8G8AAAAL2EG+AAQACci998Ac/cP89/3AHHrx/nv/DnJgDd6qPfXJgTvw/z3/Qn8iiRRQoUgAAAA\n", - "O2EDbgAEAAnIvfE8AcevH+e+U/cP89/4U4vgO9SwjbgH6sJ2J+PxPNhC5P2DrkmMJqGKYV8r/lfK\n", - "/4UgAAAASWEBR4ABAAJyL3xPAHHrx/nvlP3D/Pf+Cc/m/+4UwW4AFqbsNCEUMkn4AATLtIGKowtn\n", - "+195kyAO0ewKmwqbwI7JK9+BHYkV7xkAAACzYQGzgAEAAnIvNDMOeAYjrgkUCvggEhC8CxMzbgB2\n", - "4hgpRhXbBx//////jfWaI3//DUAGcJhWiJahLXx+Zb8M4ve/f+/9D/zofl/CR9n/xvpFE+J8T4V/\n", - "hE31//xi8NYEoOxKNY+AsILs8SAxMN+OhXhNJc2/7j2uW/P5/P5/P5/OTnJw2SAh978/8AkaMifD\n", - "0ZDvJC7m7q2VOCLpet/zvn8/n65KBAY2fR/EcDq2jm3n38sAAABUYQCH4ABAAJyLx4nw7gAIkSRm\n", - "aSGru4Ad1vRCYPPZE475MebAw4Tv9f/hLbQBD1ENLcwf/PyYIXk/XPxHAD2df4f97/4AbvfU/6t/\n", - "3+AOfvH+f+GIAAAAKGEAouAAQACci8PcngCd76f998sAU/fL3/f8J8RGix/AUek/IOukwsAAAAFs\n", - "YQC94ABAAJyLw7zcBf2b/2DgL5pbxfAem3Sfj4Ane+n/ff+L/ABCu7u1/6HgL5pbBwF80sDgL5pa\n", - "I18XwBP69p/9R4C+aWwcBfNLA4C+aWiP4vgOAvmlgE7utJ/9ceAvmlgcBfNLRHhTAARkRmZERGZk\n", - "R//8AB0YQn3WpHrVtrz4vwAzr+qf397mce6T+r1zeAK6+1v+oR/LwAXPZnWkn/nrm4AXl3uh/xZ+\n", - "+L8AOl27QX5jwF80sDgLo0tEP8vAcBfNLAM79cOf+k/NwBg//j4++DLu+n97YvFwAtqxLag/6zww\n", - "N3W763Mftwff0QBFZtyQdXgf+/+lP/2vE8AMu7+f+tew3dgf7X8OThHKv/D/PfgBx+uz7/vhgbut\n", - "31uY/fB9/RAEVs3IDzeeG79dL/q8sMu++f/Xx4fzeAS7uD//jh8X4Awf/x8ffYRdd9H/9t/vgR7g\n", - "P4cf5vAI/bg+/o8v8Abv3G/uRwj8JQAAAAph4ACAARyDvBvAAAAAC2EG+AAgAEcg7wbwAAAAGmED\n", - "bgAIABHIO8EYXUMUwbuau5+ruau5/UKQAAAAQmEBR4ACAARyDvBWb/+bJBdAAubpCjgumGF9hh/9\n", - "D/pAg3uu70YY27QwfHljvv/QhIjCEiPgF0oVQTcAZbhQ3/nhkAAAAQ1hAbOAAgAEcg7y1DHAAmCl\n", - "jqrj4UDD+2bRlkNCKAAIIqwWUhjhXQo8szwpMwgAQrCMCIcLKuHgAFraCpRKH/vhkGnNGRvMnBjD\n", - "fAATsSSwIgGzujU4GD4CJGeEwy+BMFhLpeJN8f/QLIAUAAJySAOHwfLvc2Q8dugvIX3hikIMLsvw\n", - "auXyhX+AMX747Az//i+Fd02WMGk8Y6f8tFGYNLUgEBtQdb/ttsNSi2laXP+B3YQExDQCx4N/wn5m\n", - "YGYCL058apt/zvl8X/DPVimrtzsJvb7IEV/IS20xSfxcSOeOf51zrnXOudc62G3AEKTaTfn/+AAf\n", - "NbosS/gK3M4liuoBF4EXZHet+hf7OudYiAAAAD9hAIfgAIABHIO8IB3AAisEUksMU5j+AB7UysP1\n", - "CG//LemTx/wf//KOO+eNk2xtT//wiZGwArUJLC26X5lOCeAAAAAMYQCi4ACAARyDvBvAAAAAQWEA\n", - "veAAgAEcg7wRBT/+YyYzmMmMoR4UwAENmd3ZmZ3dmf//gAOJxCF3ntBpLOvKHCmGmW/8xoxrMaMa\n", - "OIeCgRwlAAAACmHgAMABnIGvBvAAAABqYQb4ADAAZyBrwY4kOYQ4L0/zwid99wEe+83jYACSGR6u\n", - "IrqQelB4HxJuNxRUIEN39B/Dg59qLj/kZuMAAQE2msAEEVK+MB6IHWjL9GduhhnnAv4iUQQPFplQ\n", - "1POpkgwRjOGzl33CdDkywAAAABphA24ADAAZyBrwR8TA/kxh/JjD+TGH8mMKQAAAAGVhAUeAAwAG\n", - "cga8FYbwAEGQhSlIQhClKQhf/+ABdg4a7oQFFsHH/5AR4AzbfRnADHVvSOTf+6ewWwAHFneRQ6Ci\n", - "mhyJP4P6w9eKxLAusyN33+j9ggiRmEFnfbOIh/XfjusIw/rvFwAAARJhAbOAAwAGcga8uDH4c4AC\n", - "Wgb/cDqKhAwJC0wBFLAAEBVMQra4BGAxiYpj7gA9lEAC4FHyy8peG+WAAILuEtIIAmOfgJjbtX44\n", - "CvYEOPNtXiQ7gAIjIjIyMjIzI/gAT54EKZNyKVbUh//OoCRvn0/AGL98dv+GZgAB0AFAWdlgBzMb\n", - "upzq4/rX+HwHW+t88/7fW+ef8gd/gAiNp2tof7/tv//7CB45/xZ1+GviMkC3DlVxnAWJFfd4Ae6l\n", - "UAwN6BsGGgLihEj2r7fgfjkMC2WIlZQfwYAwiQ3gARH6r+v//gA/SaWDpjfmAReACC8lb0j4bcAC\n", - "D0nemm//BzSFFdTMkEZ5bSfn9/AFcGXW6az/f4uAAAAAT2EAh+AAwAGcga8IB3AAhHuaa2n8AHOF\n", - "srqxioR+rTa19/8AlgBs861x//DPQOlrkI8PlUAHic+1pptrAbv/7/wQLu7VdfAYq7+g/jHfBNAA\n", - "AAAMYQCi4ADAAZyBrwbwAAAARGEAveAAwAGcga8EQU//pp6aaCn/8xkxnMZMZ8X0ksAJxHad0dnO\n", - "nCICcKYaZb/2EwthMI4UcO5b/zmjms5o5oFAjhKAAAAACmHgAQACHICbwbwAAAALYQb4AEAAhyAm\n", - "8G8AAAAMYQNuABAAIcgJvBvAAAAAFmEBR4AEAAhyAm8FZ/gxniu/hqf4wxcAAAD2YQGzgAQACHIC\n", - "bzQQQx4YQAVg4BDCEkwHAANgBgEmkwohCRHqAHjWSD5OvbgAvwCpeQOsdonve+JG8qZuI//hrAAw\n", - "YAAQCdpMAAIAYATIfQ/MSuI1B5GsGpLLpBhzoRaAK02p4Zx23j5/gBvZZGa+1Px9tsHv8gdwEX7f\n", - "ngAYrtOZNrfv/7/A//+wId42p/8ZNCuALCYG2kK0ZviRRn33jckCGYwlsOg+/ziFaYBVuvXJxpSR\n", - "n+ADppZzKRVP/KZ/u6hb9Zz/FH8N4AgFmdnZzam/+AAbRi7ohlCL/MCXCWZT4TNIt+8S04AEuVyb\n", - "myVTTsmTT7xcAAAAIGEAh+ABAAIcgJvCAn4MYJcOwdG8IyX2LT5HzZRpECaAAAAADGEAouABAAIc\n", - "gJvBvAAAADlhAL3gAQACHICbwRBT/+wmFsJhIKYdy3/mMmM5jJjIgKYaZb/zGjGsxoxo4Uf/5zRz\n", - "Wc0c0CgRwlAAAAAKYeABQAKcgMvBvAAAAAthBvgAUACnIDLwbwAAAAxhA24AFAApyAy8G8AAAAB3\n", - "YQFHgAUACnIDLwWG//4QXYADgDYZ2UgEqmC7YIJCn4ABMhHO6CFIeesop/wgCNIIEPDqipE5CkIA\n", - "TGOEAAjOfwAbyn7AMMI2/cAG6Ke2AGBB236b/Cn2C2H84AKiVEIv1RFIDAFAFwVuZbFUUe/AtnRi\n", - "6k7OeKgAAAFfYQGzgAUACnIDLzQcw54AFkYhFOdgAOAlEb1+6CAJzmCAAEAUAYML8APAfkMoYSr1\n", - "7gAW8AAQAEMXAoSoN0lj5Y+GOFUwABACVZAABAA3kAJFJS1hWVAC1BxWW5temYQAEI8kIAAQEwAF\n", - "AoUwWojQAYMF1IEFvYewFgA1zHCNAZEKiSM1sbtkflgUb4//BZAAQjmGJcs49RI5FdZEwAQUSrLB\n", - "4BIVpwBEyiG+Dz8AOTKEUqD5/wzAFYjcDizNbTFVLdSpDD9z779/n+D/v32/e2B/H8NWBaAkDEvB\n", - "idC6DRh/GfCAWKwQABoDim4LgqqtwqDGnPwODA/aYQewDGwmuPfx8K7TBTHBrETOTN/O8CLKcKgH\n", - "QhTSIuvU+GX0z8IBOU4QAAgBADBRaTYIMQK26oD2fv8NMA3wAoDRUzSHRP30RpSWf4qDmHPDSGhL\n", - "wBKq+3/fn4OZ64ZevvO/v8VAAAAAYmEAh+ABQAKcgMvCJvuL/8FkADC8lb0t4ACswfCSTnYdQugb\n", - "9aTTI0xdU7ffh/noQAEdzwFwAPpj+TrAMLYv/fgdT7+GfeBoDZTjLYaTB8ops5Q3KrwYS22iyFe/\n", - "SlOB/+CWAAAADGEAouABQAKcgMvBvAAAADVhAL3gAUACnIDLwRVF9JdUkFMO5b/zmjms5o5oQb/x\n", - "/BBwO20Zwo4dy3/nNHNZzRzQKBHCUAAAAAph4AGAAxyA68G8AAAAlWEG+ABgAMcgOvBlxsAMTX3O\n", - "63+BoAgeSF4iS6KaQ8wAgRQFdLivIbSw+dT3YRI2ZjEIMo9XvAFgCwTQ9rSe4anPi/gADAR4Z7vM\n", - "VJYc6vewYdjIY0mJhLPr/d3/DACJDMIAHjMWVpqxXe+Jk5685AsM7xp8i7fMvKif4ASiu+f98CPV\n", - "Y7/ALERkWRVi7tV+3zf//bLAAAAAmmEDbgAYADHIDrwY4kb4AqdVYG//44AzMi0RtA3IZ+yPJTNp\n", - "ND2nxkB/6IwtaLuQf//g+eCQBVPDM2vZ+cf/7wAAQEnD0B7SxyG5RRdmZ4AQP3PYkdCdG935/vAE\n", - "A6w5J7qZ/kQoqiqRFiEwHsgHig5rDv8MApMj3SM/3wACv8crbmDx/2BO+3wpDQQBxMjN3Co/+gWt\n", - "kzTn9zQAAAATYQFHgAYADHIDrwWH+DGoApUKgAAAAOJhAbOABgAMcgOvMb//c4d8ABBirp9IIcsA\n", - "oNdFXgANcMAC2wDjg5wCJM0D5GhwIAAsUHQEAAIEYDAFP4APYFoU7F5mOBK0IiHFG89XsAEwEAO3\n", - "xRBlrRVn4C8gBFBRqbxQGE/q9G9MhQn4MYZlCALTHGoHXhxvf8eamIR/0GvwDHvyRCJePZOFgfPS\n", - "KGZeUtosMJB54VsRTM0Sz/X4QACw/BAACAgBQIZAuYemRcnKj9STQ85iARBz/AUThBHZ02ip1XzS\n", - "NjAMkOBGnBb4I/jg/n/FHfgxnlTgTfjFriw0u3ioAAABK2EAh+ABgAMcgOvCInw7gAITMzAFCSNr\n", - "WNkTZs2ABZDtIKISLh2XcDD+0AIIkgrdCOyYKxMv/wGEkEtNiUp6+q0YXoiVoT4P///CAAMgUSyF\n", - "SQAF7B8ScGQWtYrh/B/AGq/Log/lL/8QNgDk2S05w4OnnganylasDeR1g1Ukv7tRrW87b+z2G8n7\n", - "/Kf/92vbb22/f+/PD3XyBE3fdoPUrkfD+emDG1COefIvUlqZAvBiQAFvxzft/cPRVevFSBUdtVnp\n", - "//OxrXbQSjCkwe7K0vr/rAH1dvaZf+77dQC/uYWtA2X+ILwrfeRNJgATzStvi/JXWmBw3gjVGgEA\n", - "KUQCDhTM/skly5Nf4h6ZDSGwO9JdXL/y7pnZYV9z/AoC+jj3tpFMGxrTFILz/v8sAAAA72EAouAB\n", - "gAMcgOvCz4gbgCx8pwH39UJt5yv++AaABqG0donTXU0EH/33DwzSD5Fexm73ADA5nFGpJStQT7aP\n", - "+1H2E6X7DEJj/vzMO/0/938aZgtRLUluv/9sB+oZOYU5gB4pU3l/3FIJmMikgRzNcnP/97RfQ2JA\n", - "HfTZ5YERxlmh0if9vNb0vdPEh3S+q/b/uss1q/1W/tisLJVJcK15pHfPRGI+eyFTq+F1zm1F4G/+\n", - "uivqunXeVqVzk3/oASMIQYUQKc4gYWceaBwZQCRKAMuqRf+pbnH5+pf/DcR00OSZnKL1yVll+296\n", - "PzsrPAEEAAAAEmEAveABgAMcgOvBJxfd93AkwAAAAAph4AHAA5yA68G8AAABCGEG+ABwAOcgOvC6\n", - "4kbAE7ZMyttTlNonq+4EAnAA0+qg9uRyJ7/3r8aURABcwdVOL1GnppeEsfg8XZooDf/1BRSdLQj1\n", - "dCbt6LGJZ78nCNsf/CdoSEQCAVun8/7YFNv6ovdtJCqjmAD1AGxRuudv+4o6SxjgqpEPrOcmFme7\n", - "A2oicb6LYCAARD6Zld3EViWq+AGKK7OLbifapplBLBgAPZCBVhJyddmAN4Fn/eAyAACAAQhqwV/M\n", - "DetpLYSWY7qWLG77FQ22wxYTx02mKpaP0TibM+v+9sw3/pQOD7lwwxJAsT/DvhyYALAGKmtLc/ci\n", - "dCauOOEvWnGtzAFmpgctZvuqn/69a//5FgAAAJVhA24AHAA5yA68L8bzWAAgYAOqg74KTdTp4ilP\n", - "KQZl1KAFlOxft1lj/3qAjAATAKwZKt+H515fAA+VlAAIAUa1B8WQr2/+PcY2ZFgduR4GKAKkjTPP\n", - "nJf4Q4BAAEQt0AC7atP////iq3oUAayI/2awm7/mXtb/yAA9RDt2ovkcf53bi9FuAUBHpTKZDM+d\n", - "1Um5Mb7wQQAAABFhAUeABwAOcgOvBbBjN3MwKgAAARBhAbOABwAOcgOvNUMcAFAK2DgP9q4BYN33\n", - "gFJmdHKCngJCvL+Nd/34Mo55OMQJp7yzw8e+Bq4DFoRwBI2YT9E2oYhAACAuQABkhAACEEA4AAgV\n", - "vYABzeQAoHKoPRPwLK8sAUIxUcpT7AAeIMwnF4A2483rHXbQAHFQQdcFID/nAG94jeIAARCIQAAQ\n", - "FAAFQuDHHxUKwHxAOgwsDSwmmtaMCX/+0GOhDfhj7CnHiXf4P/AGFY5RijxE8UgIrHfgag8FXo4K\n", - "ZEiGQWpZbDDCAAEABwCeEAAIJIIAAlQG+HQWSbUMm8twrwSClmg/K3/yRBANN0AVYcsTntWkgYPf\n", - "IAL2OpHwWYmD8ZBjBJz0RJkKgAAAAHBhAIfgAcADnIDrwkHcABAAMCC1WCREkwqwUImyhuABkXyU\n", - "zaXlojJifKRXbgAArGA/Fi2krPW/7XwcwVHkmEkC131+3s23xRCiq+SHKd4eGHhAAFAKYJCU0AO3\n", - "aSDqBQBGydjALQa3r3/AnUSWm+CWAAAADGEAouABwAOcgOvBvAAAAAxhAL3gAcADnIDrwNsAAAAK\n", - "YeACAAQcgOvBvAAAAJphBvgAgAEHIDrwvPGwTNrxSExKWzQBZODCndPhsiqgcHL/vz45gZ178b/V\n", - "S4NEAASByif4Dpm0wBWQ61ZYKEbfIP/eBBs3hCUt32jDvcg4fryK2MQnItzXyvfvgP4FgqEFAZwI\n", - "QEjD+5Fk3JpgFFZa2brZUZqluQAetIAFQPJ593XIA6GrqSaeAloRbqPz7QyyAgFYJCb+z4EEAAAA\n", - "DGEDbgAgAEHIDrwbwAAAABBhAUeACAAQcgOvBbBj4McTAAABamEBs4AIABByA68skOeAGdAAEA4A\n", - "AQFoiAAKAAEANeBAXKwQABkGEL8AUZoBDkp83AD0EUR4PicECq4IQxzF6wABEr2/gAIM58LSiCFD\n", - "Ax4WFgAHYQABWAkhAACBFwABAHrHSiMAYUo21AOsq1NgA+DHYPgGcLJQCpCz1doBTIMSlPJ9TABG\n", - "guU+G/4GpQGNQpABb4hP4VAlDCGEFncIAAyBRDHnuxVw1kE+v+CZVqQwPwobsatgxcGP6lSN4awB\n", - "QRQhZAWywQHPnRWVA3hhCRkEAAQCkExxSA8Itt+HoCFWCvlyjb+gcBXOwABARkAAEBQADYgACAOv\n", - "9f/4GVSAo58J0VeTsgSpgYYYgARBCAAEAmABYhjkwChhrap/BKoJ5JG5v/GgFyB7ZYG3LnT2guZs\n", - "oCkY4AlIQav3/4Z+AMVqwjvTwhXo3yH7+IYYcITMwgACAQgi/o3qj+1Yf/GJkYGO4wHKFi0/4vxU\n", - "AAABRWEAh+ACAAQcgOvCQdwAECOYItS1EkEkLJIJ+ABZDtIKISLh2XcDD+gYSQS02JSnr7/4QEpC\n", - "gLgAXqC8UXGkY0578EjNpv4Z8AEES4rbHdkwViZB3/8HdowvRErQm+8IAEVrQA2BuLES/xcF3R/B\n", - "/kFJZr+1hqHoAWvJ2TTTzruPMDfb9o1te/izOUnb2a3X/X5mM/+KNJs8/J0/4ye7P78vJ1JN/+fv\n", - "8qEABLZLAKf6gcIg2EyYQAFSjADho+G0A8eomvb/uPFAKGFWrk3gAxqntN/bsiWch3os7mBHTIAC\n", - "BQm8KFHn2w2+ICsADl5Zy9Vf/oGp3UHfq/cdeRn24PvNA+T46xMeVq22dvhhlUWEhXie3bB0g3dw\n", - "N33h9r9KQjIwFeOK9U0XNQGyr3UfgA/7zuNrv2CXADRouKBF+6t+LrS76aAAAABiYQCi4AIABByA\n", - "68GOIC82AAJIPwAKHGJoTWOrmTgAN5e5Oz08p1JTegtV12/jfeAYyWIXS1kPiL7fDCuwgWRYCEAH\n", - "TVakD54rWj+f7oAFmt8iA1w+bkgSRzBCcxqkul7nxoAAAACzYQC94AIABByA68GXG8AFo2qv+P04\n", - "BQYKsgsayqxMoqxKX/vgnBSCVC3CQ3/doVOQYGtKkbOTn//tqwAC4AsA8qlAQ561pefX0IUQqjwO\n", - "3KdgACAoAAIC8RIAODZPMWqWGspYIOC2EAAuACMAC0JocpPkrnh2mNHS0geh2hGs5aKnzAvMRN2o\n", - "ACzIECezmwkrrS+3wLQDjlMQRLtOAKYkAyMrzIni6cXE5EAUzBkLJSuvA7gAAAAKYeACQAScgOvB\n", - "vAAAAAthBvgAkAEnIDrwbwAAAZdhA24AJABJyA68LYkL8AA9er7t/qAUCHS1CvWoh8q7//4cB9li\n", - "nDrCyJEwt1H1sAuwPMACB5y3kTKxM9/4NphASp4ABbhSrG9X7piQXi19SABZmMFJ3HKS+XOfQJR3\n", - "5AA/BpiS4iJD/DAAQilGdU6S1iI1NZdUEIAHB1mgAEB5OF4rlliRXTBsomIOhAA57xbiWzSf8emh\n", - "THkbD5g6pxwg3IIpL26ghTVxapieD5Tg/hq0l2er0oQ7JbVjwaeyhf4YAP05uRbd3z/AEiUD9+Hq\n", - "m9ZFL0AB82DNJexkdBX/NAyqGFEi8sx6L6Ir/7SYYEzRf+SQXn/vCKIrbBNT6zvDaAwWsBd7I7T5\n", - "/sg0BABPa/4z3/w/hgFgLu7GnX9GEcqC59G0+twAgBg4VmjtsNaukXlV7hAinjF7FC/pD9oIBlhu\n", - "DDL8dyT1n3cAGBV6b/M/RGHoQ7tNa9a9wAQEfmmEddUP0vD//Ufh+3rEf/X8hqS/wFEHjtRvxMG2\n", - "VFASM2lZEin2UfBobgPSdtRCe//YFy0QUcvRYAAAAh9hAUeACQAScgOvCuJDkBEXTOwk368D92wi\n", - "CtO4z1eY18huehz3wAoLtqyVvoQ7ZQBfAmX3VOr1fEBiFtqboPlPFYAAgfWQAAQEAeH1+9IX7V5f\n", - "3Uabv+vBxu7QZ3oF7tPaTf7ns6ltFNp/2cVNJMDbDwJaIIgurMwhDm0bJ1+xhFqJKeuDjLlQItbM\n", - "xHUigpW+oB8pTnHp5f8p8MQJIzHMJ7GvJ+1f8AERx7IQL7jSP0/KRluAQJOaUdp7h+Bmv3JV0uAd\n", - "054FNuRRKQsVEMKl5zQD2aZjpMvONGmTNm3fzmQFTEakCGYJupp4XxNZrMoVv6Cx/g5nlEo4AoMX\n", - "OO/eC6+b/wAccXcct/9Qnk3Pf6UREhyABNPqv6/4VDr41VrYZR2bZv97QlJgSr8AD3Ieu0i6b/t/\n", - "AsZbMuYMQAEDKN6s6F5T/eUoOUmAGtAFkJi8fg0XI8mI99AAXupqrZ+5+GYS9VP9//WVOLann9+4\n", - "DnkXz79BDkgmj/weApjrqiS7/+Dncj0/+Nn1uY93wIDROpHX9+w85c879VL4bE/jYIYcNjlwYRJK\n", - "++Yhys+UndP4a/yksMRtVrsnxiMvtf/UFrKTUaPK1mSyO6Pc0i+I7mu+gCi3JWbS8K00rOMb//3L\n", - "qatK3/9u+Pt+bfgY0JMMWWHGtGzlA8XIl7G5ZwXgiz3rive+x2QAGOHykI76pe+7qnmWn7kVbI5E\n", - "sNMjIsAAAAH6YQGzgAkAEnIDry4IfhjwBiAAEBIAAQE5iAAKD5M8AARK4AzoAAgIWQAAQWwABArv\n", - "OCACHaUEAAIBIADAgXwBxyJnngl0QkKcBWer2ACU54JzzYUVoEMQRJYtF4lEGE/m8MfwAEGc+FpR\n", - "BChgY8LCwADv8DUoDGoUgAt8Qn8KgShhDCgBcFCAEAAQA1AOwIbJTpsAHwIdnuxVw1kE+sBTMMSt\n", - "PJtSgBHAyT8EyrUhgfhQ3Y1bCxPwcz18J2HdX9Zw1ARCtOPTkX4+vV/kFgBlVq//9O/4s65oRAI/\n", - "6DWAKDOEIYk8TtIggyylDMAWjywErDCQeeFbEUzNIo/1+EAiJYEAAeADjjYynRyZlJNDzmIBkHP8\n", - "HCVBeWRrWHLGAZIcCNOC3wR/Hf81IN/9Br/gYdd6OVFZ4b0TARouyH4AYqSyLsIhckXSH1VgYcDg\n", - "ANHCCACcDMr7F+GSaR71n+N64+vaH/wJyJfgKqlANcGmeMTMgMdxgOWMFoH4s/wcz0qwBqIt1h//\n", - "nmH1z/57ycbABeSPhLL199Ig5Fnb8BjdcJRD7z/4AHgQf0KSPik9+EXvABQMVg7lX/1ihFyZnwFU\n", - "w2X8TDW/nhEReCCwk5ZAMonR7ADywtTOTHqz/86aBlW6dbAAu+U38nf8Qm9228P+aTNf+efEjI01\n", - "aLAAAAFlYQCH4AJABJyA68JCfDuAAhAE7gi5G5qxq5E3c3AAsAwiCSs0J7NgpEw//QnZh+ipWlPt\n", - "DHYSUSkXHs+4GX8HrTYSw3JCnj7//8JAA+BRKQALCYWYh/ioLuD+0lh6ILrScae9/gJs070y4yab\n", - "8nGwALmMVTXMJSqsv5oAQCAI5cp6FdPuoIffwA6MaZURUZyo+zdlo0tK5cjiGrJ+vB8SRJELIyIy\n", - "Aw/gAUAdGAo6XxLrJJQsV4EPPW69f7vClIMTkABYOdIla6qV3/8vH5+oQWU3pPAQgBo74j/8JP8T\n", - "wDsjDVDZ3OFopBvQ2NohU8AHkGLghG2ooX5fveAQHQssFdaS+03RAvwasvn43OnPntYNQDh/9Q4S\n", - "fkW5m32y0GcF8m7w4ALNiFLTMXyH/r3+QKOa2Wm1taR6gnI72BykDgAERUNNT/t7Q05PtVu8NiLU\n", - "3Hetg+yB1HZo66AjqjaRsgWfXAywAAABa2EAouACQAScgOvC3Cu3LRhAAqiA9RvhC///98EQlFuH\n", - "clvR//3rAdLxTrbAQbiv/qRQr4QIL3kFvnmubTf3AARiHVs4eUB8LkP/3AAAgBZGcAGaJtIvdNhH\n", - "//cDHxRVABqHa1LDGSf+4ANQRr1obphXpGsf//jMHRU+3bxfRX+8ClB+GppR31YoJfz8DPq6j1FS\n", - "+6rC9COgsAAr1R8eK+efQOsllLoqvX/v6IQZewR71hiey179qjF+8MNcL4ADh0mgAMDyeZqlliRX\n", - "/QTGxGACQQVCVovkNdN7H/9hhq0EAT2QBl3c4/oYycybIaAA7CsxSdcVMpvVgyXHCJcehxNxGN08\n", - "8zJ1P/iA0RCBxBOPBNYuToGvvAFiMK34UQ5L7pU+AHKbeOBw/cBtw7yOf+CLJSO33cP4a1maYTlb\n", - "n5a57iTQTngWi1X+pPanlcfP/YHfd4HkF2jEOU16hkIYk9G8tpwC2hrG1H/LlgAAAURhAL3gAkAE\n", - "nIDrwtiAvgIm0172hLF9aD9NBfe+uG/a+sAFx/CX6Wf/+8QYyztZxvTxsYVgD1Pa5cz79hUnuzDf\n", - "em0T0P9Ywo3caD/FDN3h/+z/yXc97HEdg5XT83/n/KWzebYkf8MGeMFaRH0DksUkagGLExURVR2/\n", - "1EsyRD+/7a8Nr98ACdJPbsrf8i+h4KBIxXZePfBnffv38DfG8AB8AGAg7WXU+zZUeFG7wAQBhFDg\n", - "pK+olns7OaTvrpYAAgI+AACAiABoJv7+b/AQ4lFy09wSqekIp11IDA2eEtcheL31l/9uxgfG9eZH\n", - "UAAQEcAAICAAGggH383gsDhtCAIfuA3raRlGn7zFH5lPmAmlkHi3/Zn/9E0rJnf1AShuRFKEsvyF\n", - "seojwZwmUVT92gFBlOwUZ16Wub7RmiLBnC3RdM3aB3AAAAAKYeACgAUcgOvBvAAAAWBhBvgAoAFH\n", - "IDrwvxsBHX22teHNVCGwRfARAAEA9QAnWoUUqGeyAQtTiAAcQFIAQs1QpgHhgsf/4POwABATlnAA\n", - "EFgAAQLF/7vwCOAA5EAeJfwtLxc6vb3gGBXMEF0iSipVwTH3F958QIhghAW0phAgNk/TvN0AAICF\n", - "lAAEBMADIAm/dtw7DAAEBHygACAqABcQ+PPCAntCAAPgE7gAPxoQb05q10zf9AjK0RsWdAY0TRBQ\n", - "SfSl8hD5zE5AAOCA1kizaTSqBQlPZug2QDCmcotpubtcMCHJZSzxfTOGGnmABkAMgMfQ6QaQMYkS\n", - "HMAnzVH1d0DRhEWvn8EWxhcSFsMABwABAKHAKEdoVvqHRzYjG2L6u+1+vt3lBCQ6DKVA6EnIcIEC\n", - "A1RRAmtr03DYj/AgQ0NCYg3QIyDmrsls2+DBG4hJ02Lh8SrWRo/VEdh4izpaBaFihlyZZ+6gxid6\n", - "/XhYAAABhmEDbgAoAFHIDrwtwv4AFmYEtqnFnnW1W7/6PAAEA8AYwPTIASAYEJOFpIzl1LX1l+A8\n", - "I4QSgOEQALkZtCbKd2IQebBsOyFkGQAHQZQhiliXesFEm3fE0AG6KwBhZo7ckJ0JExIb4DAABARA\n", - "HODv4GAHSwA7+OeSghRX94IErECAALAGPHxx+p/xaHpGYJESFBHr5b/6s1xhMyKLbT//tPeCPgMI\n", - "YPV7/LgRZQfcomZClijMBqJEhyAB2G6OlihCSC//QEhgkHaCSPeGin6O+ACEK2lIuv62JW0jgIE4\n", - "Cb3dlYVPWOjSf4IFmdR9YAerk+qfAgBBvTt7iMJvfTDGrAC3Lk3L9/Do5GBvYmn/DEAWhuUWidxK\n", - "06j+MBiEik6vd0rB6Rf/2CMQuPi6Kb+e/uADAQD0clP2xJIjbevsABg6CkjIw2xut367/CGSx4hR\n", - "X1Y2/K2C/CAqxg52Wx9Xxp8R9rA8zTO3v/mBNJ579/lVbXpp//v9ylohQPIbaUyR95v/Ol+cFgAA\n", - "AfthAUeACgAUcgOvCsTDmOora++vAFQy1bjvNnACzgA1RAmQ1/3ZkYYgA4IMLQjzDztViLSkwnog\n", - "E0ARBB4/yF2zpoScAPsbwvzGXBH98wgACAOAC5Ya3GAhkxBnJaK9V03zcABZCABAEkr7z0P6IyJy\n", - "2BkRwqHGleY//7hoCczA476ohimXoYCuEF3IkmFHoj4HdzwaNvCcZX9MnDBGMas3SSq0d/+eAXfs\n", - "EuNgClSC4S+QtiTWNgAdmyeZZDq//3EhROnN1IrV/+UQoqvkhyi+kMPog+A7ywH6JUGZiB5frqGf\n", - "2dO+7wDAHk4AAgAgBJyNHAkoXkd9/whgSBAAGhBPwCH2hX1uM6qLtprpgiVb29WSV5m/XYFNAgOv\n", - "+/A2uYGlQsMAKPoo//tMPOO/crnQQxgvBiJPXhIw7+8CRvO/8mg8hMEEaQ29wBzyAcLbN8/fABeh\n", - "HVCkZxEn/7/fAFgYUsar1EnOK86uFAYKAC9iO2KUjGKf/v9OYgCwEFLGJ6RJVkzKzhUIcBcIAREo\n", - "8I4FSWmKVr8AFhNcveFbnrLzOE35E/+9Q19eUiIADDBdoUKuPNmxZNlEe+KLPf70vlxJOHdPZmPr\n", - "JH/rYFNrXd399/hHerkr3AH/3DOIYC9P8d3dTIGyt5hqgr4WRYQlS6bR+ohAO0e5L/A+AZYAAAJq\n", - "YQGzgAoAFHIDry8MeAC8AA0cAEBATeyLDIjcwECyBFMKOwoUwQWAAEN/wiQAOhXCFVHx7gmBOaQg\n", - "ACIYgsIAAQEgABADAsewAxlTPkcA5kng6Ybw5G+wAJcTblF9RHLfwOhH+5UhFiInoMe1YZnlT+AP\n", - "KbtrmCQApAxXOuj8ucEIb4AwAACAmAAICcRAAFh8ngNCCzvgSjE2XPvwbktG8kiXE+bxkGIkNRo/\n", - "+WQYAQCdVHj//8AgMPPz/+f/POCHz+wL/SE8bAAdgyoFjNes/nnr/6nSc5tO9fh+IskAEgxFi0Jd\n", - "SX1fds+/oeCFsD6CAPbPjp/wvaGowN2HjDs0BdAArs3j6+//vosezPMgd2bpP+HrP9McOQApVyGe\n", - "Gfmu3v70Ly+LaLpkP0PbRXCuAaICPqSg9QqJXp1iWH4gAlocQZXzRLYOAnrAp8IgAQYRCF4PgzKb\n", - "i1r/BhhAEVTQgABADADBZoYvr47Wb1mJh3je7d/85smht0KjPgFTYVBAlUQVHSr7g/rz18Du297/\n", - "/h8EhiESXrn6gQMMwBYZhyGpMEkxtDhyUuww5EELNxgyKXvv/Rj7ncoe0vOf8ZiFlwYQ3wAEzihr\n", - "mUpIxyhrgDH9czP9F/4ITxsAt03Lmv/g9oODfgjZDWZ7t/P4CYvY7Euyf5/8ABI84S9kKWMYvZ1b\n", - "aCU9L9wCpgA1aYAhwLE62zhvAyONU0Mmjs+GY+7Xm8JW0h3xDekw2kWrn+2zEKV7/i8Z9pF/fplO\n", - "2o3fPKm9JMc3794W4RDf+AAgJg1pLRoj6BDgq//+BAgBQBfmJa0+P1BAGspEw9lgAAACMGEAh+AC\n", - "gAUcgOvCZvzf/gsgAUsO4IjiTSSBS94AAdrgfyxTSdn7f+b40MqTxnaKv//2a6F5SNX/7wIAAsDn\n", - "HhKagAqAz9MxgEoNa178CFZNab7L/EIREjbAwAP7ID7mGU08x+IITCETC0fVQf+tvBMKwCcr7qxY\n", - "KX8ZIbIPHLnPHK5vft+Ob89t3cREjMcTFKdy3wAWZquHVaF0i+DE3T5f3vwwBQbmCODF17oEB0o3\n", - "ehhAFzcNTQAIo2SxfxzlAJtCIipSF+UYaimtWAzE2CQd7resAQbWW0431LEgtSxKEp9dzh3rCCrx\n", - "blshTdy+0AIcYsfCSyihbmmg/f8oAAcsAIMUs6OlPsvwEAukv4ADiGtvnLNcIfQRJY/aMQpgeazt\n", - "y2YjaBBicggCYpbBwvmJbnb//yBAOzKY6uG5LRvFGIdsPfmD0eCBUsEaS2fTYLPeGYmGoIH10gGd\n", - "R+bH9YA40v16qzvZs/83dwC2ACUr5a/St/vfgAtkAG2rUNlt/982eK+cKxoxNAABARAAEBUADwTb\n", - "8bntHf7wBYGQVxYAYsuTG/XpOV6P/3rN6/wQdNkBQU3oqzveodngIw6gIAGi7LU8Rz8l8/WQ1LY/\n", - "0Qj8jvg4YxZ+hKFkOB4JQDw3Lrl8SI5pw/bGobbQwBI2VhEd/tXyXrvNevm9g/ACE990/gGlxLbT\n", - "tXybz/9vnBw0CEKhALlLW6ZHiczwmn/JH//56C9mF847CSuPFDvsv2WAAAABx2EAouACgAUcgOvC\n", - "xfKiGOZw9KJABIAaBIBPKkJ7dQq9v90wjEHbV4sqFkf64AAEANAIM1Rl+tt3s9XswMcZRiW9wAGH\n", - "thKztGJVbJkZf/6xhIinZiiak//+4fysBBdOK2AB4yOiysVq87rDKxKYRkIqfzdDcZY0HhAIp+z9\n", - "L9XvZF2N6AACANigEcWEQzWyVVO/uEAjEMxgilkYiH/9wZGZ8DOQHTunSncQDOApMxakWB+f47wA\n", - "AQC2LuoBPe88nwY6nuAU2gOALAmP/u1iEcpfIQw+RHLcGpXKiFqi561/y/fkYYzoweZOWDDB5k5b\n", - "EE0bhsHfnaqQ0/95AACKzcl5K3fsuvLP0GnJZxDhwY2Ho7dgxlT7v++P7pweBrQajorAAkADBBJJ\n", - "RBfjMUV2py/7fcAAQDwBDg1e/AgJSHCAAOgINcgBnuHDBd5BihF9u+b6AA44hjkcGsLFMN9yXZZB\n", - "oUjO0VfugYfMjGYqCs1BKHLVxjWAQYYkK/uGDokNoPzAAZBQVMxYXRyUkpt9+zzUCACMhAQAAgBg\n", - "AUeXtzMoACB9uF/VDYH8T19eiGaKM+wAkLXVUoH5wR2W9Q5DeKhER9OeDTlgAAABPGEAveACgAUc\n", - "gOvC0SIPiwkc2/4iFoAokQ6YoG+FPCQzPYzv0WJ8BIAAgHiq2Q0nQSQ455pNWeQEiCOUw4w6AKTo\n", - "Kp6CZfYkjdvvA3dqQgjFMIIcxAYYY7gRgTAlI9XytP31BuzTSST9XwtGdaWrUbtp9i/SAGbKP9fP\n", - "7Zfz/rIXIK1Laj5YGg3xuAAjBkFIeFMK4QIjZRw7AAcMIYc1vHj0WHviz3/3jGcOW1Yt9F06yTKv\n", - "ygABAQtkAAEBUACogiXeu28vgGEPOY9Bw9Jh/4y6/94wABAMygA54C3JU0qBAZyFoMEHCUAAIIEo\n", - "AAgKg8EA+c7+4gOIgABQUgwjGmhVFP/MlnmkfkBhbRzxtaj+milNG+6AlmEIkpqvNnnkEsQRgmSZ\n", - "L2dASA2Mca7dxx6MJKKYDH/Xex27QO4AAAAKYeACwAWcgOvBvAAAANFhBvgAsAFnIDrwuXwVwJES\n", - "EYRG+AA4PjBGRSZrasmMTiclJI9EEpSMeRCp734bxgQc8PSRszwzUAEL19tSDC2IzQAYa3/fngAP\n", - "wi9ndGVCP78qdPv++sBcKQ6beAQOxVf/vBsdDQtaIJquJDcACwCKABV2qaBhy95BO4BQIwKWTej4\n", - "VZp0qZ/gFAai1AAAgGb3ki6Amc7mjwgAHqQyA5L5ClhW/yKBiviF1TAFGRE8F2Uz/f4IRDRLa+q+\n", - "f5lg04ATkSZmBDdl4/caDb1Pttz/iwAAAVphA24ALABZyA68LRIRDlAEABmQnSmOOI9fpFr4ZhDx\n", - "P9OEo0Ed0k8gV6CAERTeAHtrDbuP6o4AF0wSwWBzdcQYdUSIhj5mYyvzi6klK2p8QH6YCGl9C2kK\n", - "MLDD8M6Yw61Zq+RjVhh40Ake6P62DCX43brqMEAS+7qeNvz1ROKWWX2+j71J8Zg0i4kOQAHDGSjm\n", - "oQ3GLS8r/zgAIDBJMUwpzA3wp4jMEjKUVmyiP/vAABADcAOcw/WPhgAEa/fgnEH6+BRqNADxP6Gy\n", - "Htiq//8/wJAdScAunJqFlX+9L5eJEEEB+ABPrmtGrV4BBXQ+DOyVOEa5QMPwAGErC9Fs9K6NUYHw\n", - "AAIAA4QjDH3ClFZnP594BuEWqIxPYfgtRoPwEMrcYxD/L9kfAYKsMR+Ez1m+OA9QuBUVETPtVrY3\n", - "rGsIJCL/4A7LTF9WcqFsF+rGkOxpr/zwXnu9OFRYAAAB6mEBR4ALABZyA68K4k9KPADJ7cr3+cAD\n", - "yefsqQilv+sTBBHmj4ADgwUh6jiBq2HWBW91/+DwMgDBZeejTY9eEbs//eeShgwGxhA3IEAEIS01\n", - "ShKWCKlpMPe9/8ABlXj/KP/mNYpVPwP2uViiqEdtaeMAAQBXYZUA6DlItliIdgA+ESmEwqXS7+l4\n", - "ADIAKBKDEmuE8IRXsv4dBo9y4FNKMf9/IP4ACQnIKxBpHtEfSR+G3387fOiGijAAV0xTkXsb50jW\n", - "Uqv/ctmZyFJ5+YOS21zt8+gto+OP8tZ5zHN0TD847AwHu0HD8wuf4OYb8AE30ttLd8uANjnlH+Xv\n", - "4AmDX7SPlz8QYL4AKIBAUdah4RI0Te++AGbf1mDf9+/LDpgKPsdYVJMvj8WAuGZXpuT6Ym6q+IEZ\n", - "sSsVKhWI8Oug99g7wWiMFxVs4Uo4CDDxED8AD1oNTd6Q8J6YDAlwrhxMYLLZXefBE2QTvb2V8K+r\n", - "Xr3/9gkBaeberUZzv/2lJR8obu77iSRAPD5FbUT4wvfEh+BIDHJ0niOmIKif+8CP/kBAHoMAOyhe\n", - "7x6w7P3YCJidMUncT0JSDAhJEIEquM6WhNnuQm3QUVaZSoi9o/+xFVyy3WXtpEQkwWYp55bX/n42\n", - "G/3u9MK/3e4IMsAAAAH+YQGzgAsAFnIDry4IT1/hqXViAQBjwAEMlADKXwlNV8f4JgTGn3AaiADA\n", - "AEA+oAAEDMAIv/orXvoBwAwUIIAvhmADjaBIUW1KOBOCWjNeI436vYA8wRkvCUXDWiJMcBpEgA8F\n", - "IB5gSL1pp/eGifg5njoF4Ag3x2wP4AwNL5tosHv9cNXAAQGhADWtw9Vb9y2Ndh/LBAArUNFu6T39\n", - "fgCr3fbt/o4nG9QBhcqumVzDUXvBFdUG+mdCUo8zAOArRhcQAjjnMx0owDMTX+4YHEYVP9KFocz/\n", - "wMYfgATclULTZwtzAGH9NXjwnPKFxRuiD7byTqZtw3+gEV5+lf7f2VsnjOq7RyRYdj6xTiU22b3/\n", - "BiVp8ff248j3p8wk668K/DIAGHOmfseC0puLGv9D44MQ08Ob+Lu0jEfu6df6xz+oPwMAwoQIG8UA\n", - "yJ2Q8pFVqMGripafbTTgfgLkGK78JMWUN8ovQCAM4QYcKBi5Q+OB+NP8HM8EtwAPYntmyXyX/sWm\n", - "HUuj8QHMI/jkBAGoMlkpfkWAgxzsBvJ+Xt3AEPQotf/9L/xAmHOAAZfFAzjz5EWf+wHgMKQXYUQq\n", - "RILrv99wkkzuhMB7WALcKNTq+CIXf+HMfiHZf8Tw5wAJyrWr/y8R3/gxLQlj/hxFY8lR2oYz60Zn\n", - "A/ARUtruw6ptNMWAAAACQ2EAh+ACwAWcgOvCYn5IZgAWQ7yiCPPfjVAcP/1wAQRLitsd2TBWJkHf\n", - "/wEFIJaaEpT0v12jC9EStCb4IAAuDnnhUkAB+wfEwZBa1itvoP4BVeWgl/8ogNQBiAt8ycTnPat4\n", - "YE/LRXYZaiXgBu7FPvf/0/gBuLMS6e/92MZv6f9VeJgvgAIAAIBJx3AVO1Cksq6X33gAAQBYUCBA\n", - "ngmVSdtSMXXP/+GMgAeABcFgWnMC1Ch8qIJv7xQBZbnl9octgCwlfz91sT/vAlq965X/1TZilvm/\n", - "vGUr8+coEsjiNHpoif/3Ug1VMRit6ujYjoCG72MmPfpfiREKKIDsEYAF7AAEBIRvB5VJm5YaI3ec\n", - "N3CCFYaxBKt9qzDP/Bh2m2AAZcPrPa4LQ7Q7mAqEAlYveSLEkSyPBzDAgACYqmRhtNIz2YVT+f71\n", - "ryY2dKT58M7hoW+est33/98J+olxNoMikC4YJksjB3SX8Nt7hnnrADj3qbi8/4EmTV0SylUnb+Jh\n", - "WAB5FAYMKy0bbCFwRvT/94GAoQIQ5glF1ez64te6//B2BGphGRBAAIr2162P2TpKABloqJnl/LAS\n", - "4fmvc8BN3jjKFcte/WjkAAIBTpSUAMLlBV/77cv3YgTEB/ucDAARg+jip/sUj0OU/XuvjB+ACdEH\n", - "pTFMUqAC4QDzyWhxITU2fOF/oaFGTBVJvwZkTfwCgGC1zk2OjP7yM6/4MDizwaHBhkGurCeqTZ8C\n", - "Oih2Mom659Wq6vKKACr0+ZDK9bm/ugysWAAAAaphAKLgAsAFnIDrws4g8K0RJ0BgA4ACcLITKkvT\n", - "QWm+mhoxzXqbAEjAZ694JwQRffkbe1NzEp2QKsT/W9D77wmcCmATBP6Pf6WAiBlR/1tVP7f9Pyhh\n", - "AF0aGq1WSsOgjTmEDY2IgEFqdSDUlajL0FWDFgAQDoocn8k1YXgwX/tFhfDCoQYUww4+B03L6coq\n", - "Uj7U5BofFpDUn1wDgACAnAABASAAsEKmACRuYdk8Spi83q/f4OMj7DRHYQJxmaAMeK3ZRsVmw9YA\n", - "oE2t29bqfv8Bs2kT1Bkv0HREqaalvfn8izQ4WYBRmMcWS8YhOjH6DJ8NRMNYACIGIce5IwnOh5cn\n", - "e3zSG6oQw4rt9EWgKYILiNgA43EG3sVPdrgAXtgEIl8jncUys6KGpuHzmGzJJSy41PP5EYisAAIB\n", - "a2alwYMVlPgLBfKANrqPOkmLdL70X04IycgR6t1PsWj/9ZnGakSIj1eDGhDAAShk6wkfnqE4fz0b\n", - "l3d4BE0aQ26kVnUShDAGu5GyjcaLVj3IZBfT3/3+6S58dip1yCdoH1jNKW9W2UOqm/0/tUj4DLAA\n", - "AAC0YQC94ALABZyA68LxIQDMJmDqHqIcwIAgOIloAHgXg/XezMb+6gKFJmvcV8fvUAHmmn6Lrv89\n", - "ItNk8p67ps9WHjoy3+BsvxEQIDIMAyFsJuDpnAAdGACDHxHQOBeQ2FrZ+4gAH0DEAIVc9YHxduC1\n", - "/4MMMeQQABBFOAAVhrtAcy6k/+PGaQN2wZFELei67vgwAuwHgM5a9AOH6KaH/5wQ7LeocA0QiAh9\n", - "AqLLPaMce+PBxwdwAAAACmHgAwAGHIDrwbwAAAFRYQb4AMABhyA68LmEXiN/5rgAZF6UzaX+fwQ7\n", - "ijynjHfLlmX3FTAlEXLA1QyymEell8YAIOLZluCMNBZY2GoFXzLr9DgAIAYZkhCaAiQwJkOguaDj\n", - "h2G4AAgAAk9KzptQ+YvgBXAAGgCjedc4Y4ePi4QAX7hAAE0AIJCFphgMgsaXQSN7wCj1GRP/1rvG\n", - "dmj8I+EATfqPcs4CxtdAlf3gFMjd/bZglEk6CKxAIEMs1W0JrpUG4kFY30sEAIZSgRYoILCBh9+g\n", - "IyBFI4R+NOaWQSYkdLFx+mAAHQADgBIRlgJhEFaJjSJdsq67a+m+N7qAB7Cazv7II0/7wAAQCw7o\n", - "bfH9N+GoQX/8ALMAPuU8xYB3Ad++8HANQYAKD4wuzHxD2yG+vegJaRejGj8iP1Lo1glIVPqKyMFz\n", - "WPvf5IG5BCzLMb+/DbmVnB9OPIekvTT6lgAAAO5hA24AMABhyA68LQiCHL4gTEeFrAYADgAMAjnN\n", - "EJlNmW2aiVf98AEA5FixDtdRXlJnlT1DAAYC2BtL8VRbL5WroMQEGCzMADxOTLISId//lQuprf78\n", - "BzROQ0+OAhAAti+NdJK//f5AtZJrP+/AYYIqYdXpKWpY+6zR//vBpYRCIcoEABa0GsNS0h4R5i4B\n", - "hUDBXqeLPhrx0lt/6vAAsDCIxtsv+1fS/VQIARf3Z//p1iBIZjVPEoAgTuoXokiIXvg11MT5v+8h\n", - "hfRbZdd0bEVIra3/1u0N5QrVmy81aziDWwgKdf//vIdWbs336DIsAAACOGEBR4AMABhyA68KwiJP\n", - "XhA1fPABFzs4UWv+l+J4gdBBgAWmoAYFy/IvI3vvwAEQZRCGJNPSQMQXXS3jgACCOAAICUxAFB82\n", - "g9ay9MADgwOSlYR0OQzUZYj+OTRGYRI3AB8585Gv+eAMVnoKXvltxMyIaWL/QI2/u/AwNCuahsWJ\n", - "rTj9hMAXHYYSWcbiT/1CBJ4IJBjlY/GDehTyw1HYmhXqU//B4ACGR8wGC0p2z1tBVwMA0MFqUfMw\n", - "v5X9//tPM7TRtfxlithinTRTk4sO7IyRYhJ7v+tSFEpu2//3fEiAAEAHNlAKMIdzFC0hrbkitPe4\n", - "MQciT14CMmizvf3AEdoaJTvf2oXwAHcg9Z9ywxzIewwALABiNYThh9C6++j+wCJTdXwAPDMSHqLF\n", - "6T9Yqmj4b6fH/WhBx0b4DiUAwCDs5ZiO/sEzxj6lwd60rEznFcMMwAA2gY2W8GcpMYOSuigQUbL4\n", - "15t4RgCAYFPol+8FR8UxybIfOEEAFgMEJhRrOaEbbP//uHJsQF0ZRZF3/8ze7rSce2gmXf/qS8hK\n", - "9mfv95UYIRRdEwjd/95I4qV/7jI5Jdn7Orob8Aw/DEu3JUJ/D/xmSGQIweNX4EXsDe2AEDCHfomO\n", - "l5YYa7lXhsCjlHXel7PK/e/GYAIAti4DE10edN8n/9wDH9Vt9jsKcwk3/whmBwAaemP3qV38P+2m\n", - "+YMoJbIJMLdtY2BJNT903u2EIDMUwgUwp69T/0uzIbRzeNWbteDYgSwAAAK6YQGzgAwAGHIDrzQI\n", - "EMcADhgAHXMgXYc2kVAwNl9qGHGxEYS0ggAiNbgAavSxoxa5j8AB2DgmPXxxI1yyxUP1MKNg5Ehq\n", - "2ZfFIQYAK9d2zx3wh5sDXUnNj71/DuADghWMaxrGsaxrWN/AAsDFJtEhSkEkqE6vf/wg5sBwA0QM\n", - "AC442TCWDJJY/3wwm/PL8TxDEB74AAwXVBdZuwgsndGXwYGHgA8DBHLNd6x2m39/uv4AOg5SgACA\n", - "8P/tsNLft+CxQU+wbZvHYqv+/LxGsvPwD3mRV79gBbAZm7b/f8G4CkohLZ2vP6X8sogogO+ADYAU\n", - "2iSyScG6IkPf/2BcFKwjQutEkFX//kH/gBsp+MMU5onyRPhjEbekPp0Up/8H+AA0lcaE4cX3En4m\n", - "sGMpBuPgpFBA30ClBytWZdnYAFAlZsXEzsdOpgbDfx+XDCbmo37illaPnJnBhGGGEmtBSZ1aMVdK\n", - "QDoZCTc4FcMwBPgDCFGHBtRT8wJ0QVEwGEHCpIIATnOCquFiEjEW5/ymA12UCtEkasug2HHBvAAh\n", - "4ADAgiMYMssMM//4AFgQhNJgKVgknQlV4BQCIXgFuUohg7jTYQAIjGgH4AFQ6xpu75Bx0+GgRUdY\n", - "meKYCOGBGZ69/+AKOk+vXJf3LKgQQJLgGZKDGAdKznTl/4bj/gAotBoU1KIlwuBx0gBBenAMVryY\n", - "J13UP8GMEXcwkQpg6CO+OkICAs5lJfzzHvp8flYA8Eu/+HVjf/SDrBvacpbV/36rGz7z0cfNTiDB\n", - "/4BiO5rj26SzTFMNqUTm8leB/y2CEABjMhIpS9hEJT34AIQJBnrahPJTTjdmG2PyE4z0YScs0d1Z\n", - "lM4CUxwDoRiS9/6IuRdRRlN6tr9/zp8Zw0bRX8sGArZnR7LtYTH/lCAqJ+ryhRvWNNAPKYykJ9H8\n", - "4sAAAAKeYQCH4AMABhyA68KB3AARkZkAAIAQBQilaECJEgR8ABwBSnAKue+FAK1/2gEEampMC40T\n", - "SoTeD//CAAJByiwFwAPBGMCdJku+w2vX4E4vI/6T/EwvuhkvgAIgGBTAQ0qZzP5VwwFCcsIj+DAH\n", - "P9HfOIObimekc8ALr/+mu8gQzBElKOlhGLfWcIDZAGANcJKLiUKSfv6qC6B8AzBBQl5lFNu15U93\n", - "fvGGAYCIkPhFnzeKExZVkEMP8R+mgcljUj+KECSaYG0HXH6B5n/qgABASgAAgLAAYCEzgA5qAewj\n", - "QsmLDqzNs9f4IAE2cIAA8AUSs3A7/63ZGYHzi77Yn3dNdtJf9utizxXykEwczW361wFFwvlJVw9z\n", - "RGDuMJHr+s1CA/2KmkwikRKolEEEjdaCFRJz2T9yMIEcpRLzFNHbDH/+8PAAalwddQU25t/33EgA\n", - "+AXUtIcL8qTO/3hwAHuMAYQZiNy7pR50AJqOevkKf4tJBbTQIXkjE+ikV2VHVfa3YGDpOTAZTCJI\n", - "efrXGOrfQgZIt6p6vNgGUhT+Nvja+w2YePsd9/9HkXZXNvdhIAePUPIFJ6rr+r6RGcgl4GYkIZfe\n", - "JGBEgQGw/DMIWStRgoE3CG/QsE8MbhwHAABAA0wk2hrFSwnHNQ+ACsYXx0KQRJ+/qwJHAIJiyWry\n", - "VYR/+/wJDLoH+7MEYxE3/Ag5uIAATDiK6yGhTT2SfXZ0ZVxxmabjXc16iXextm4ywsXKOosyniNI\n", - "yABECLaITX4lt4MJXxEbrz9L4ifERAV6AY6jFII8yuW0v//D+CN4XU/NQQcAgOIlGPq/cvVzhcGH\n", - "YCd6y2a2f+f2AiSaFLtr/fckEGZFMEeWa0gtsXaaZNpW6w5Gt8/9u0N9E/yVda/+LAAAAVthAKLg\n", - "AwAGHIDrwtGhoPYACwnF2lRFUuU9BrwA3D818orqDrapfhBDK4w1PmIF0yd//Bl4dfAj3j/egBAw\n", - "J08CVEV6QQJKkHw5MCJtAAynunL76gFDapdKX9/z8zBmaXvoAP5teL/fyg6SOP7iMS+zIwxgAOAC\n", - "ABRfhbKn+XD3N0gc/pWkAAIB8AAEBEACwRHx+b0eQU14SrT5tlsiqiAAEEUAAQFAIBGdgA4VcsAB\n", - "weS4wUYKmf9AjDDQZkEQABAEcAWXU9MavXbutt97l/+3wp9FUuWzZY7Gd9j/2D2PVf7bT9qim3Kb\n", - "esMgRQPPJ9xQR/bSGzFIDd54xTaL/4NPEiNRAgQFoCQe4JhCRdFsOlLuggGHwAEi3iTuhC1zEDE0\n", - "MTOCkolIW2Hj2lpAgSl4k3/RMf/7mAAV9WSK0T3+Aywy/jr1Ja1rHp0Wj//PGQcWWx/1xxvto3pF\n", - "gAAAASBhAL3gAwAGHIDrwuXxIKMTiAtAAy3pyaagfxESQmyERmQMMAC0GDyxMBSxc+SPFd/0CkMm\n", - "AMA2TYLJbggXRggACgMWJAB6JJxQ/leqMz/3q3/wDVUGUZU+T5PLQi5fvwAbtz14+avb9v0+AliC\n", - "xtJGOHyeGBhrJkEsjg51J//3A2akRLxhAFwBARUCHTAJpYoQYGV+EPwEKjxLbAWkp4sazk5BxBBo\n", - "JJNY5jzy/bBhwAGyMzQmylVmUABAABABAoGhVXhlw1BAQsG7onv7a/b6fm6a2TTfnkOIj9IYpnLa\n", - "SIiIWyS+mKFsSM33WIjAIITigyqbBUVHzswkKO7k738Ym+j36lQasY7PgQT6nEtgTpx3+cHX6Bxd\n", - "VIpLK0W8MHcAAAAKYeADQAacgOvBvAAAAJphBvgA0AGnIDrwuGMhLSS0kv8cYhNBs3/82eC6AAh0\n", - "hyAAhponDA+hBMjGnzAA0OAQXvjOPFshJaS+eECoXYh3pgZoQ8pjx/CEkwgAI73cAHhqo2OgIQ+Z\n", - "T9wAKAACAJ4GMBvzs5ATarh5N/5/YLYcAO2AccHOARJmgfI0eeEJkQQAEZ6cJHQaGOUT1e/ozAE6\n", - "gIWPKOF/V7yQAAACI2EDbgA0AGnIDrwsN5kVUCELApEDcAB83jKCL3ViFLof9zLpZ8v7cEKaHEl/\n", - "CkvGUcqbW0qwVAAECeSJcYADqf/bxAiiFkOGsZTKMvPslj0BuVAQU4sQn3GfvAw7A59kYuRaFEDt\n", - "Kp/+0QIfxOBvaKtKRF5tXAGDtKv0HiAgwN1b84cAACAdx1QBRs9o2P4uSog+8ARoBQIzOYhztjER\n", - "auwgABBJAAEDABg2EAAIIgcB/QDVpdgDaRZB7g5wHL/YAzGZu1b/Whj+0bLU7llyjWHwAwlw41Pm\n", - "nDVCCI2gRki08BrIAW4AfzgLwWqDA4KBrCt5URJhvv/srqUCIHQt8FggzW+okHCHF5eoGHD+RDEb\n", - "2EmLLGdUXTDDCzMIHutkCSoNjDMIKHBn5Or2MG9KF95vvLHg297bPDJ34dAhgg+PBi6EERSWuMib\n", - "kbRuYAAIFYAAgegACA6AzLeAAwBjOCxNMqrv2uR0/8cEBE4JGGcEMUqIW2Gz8zwAGGzFZxG8tyVq\n", - "Wvml5QHwwABAXBBAigKYJLhL4/2yb+MAAEEUAAQFgIBOWCCWUIFDH8DaViSSD/wKNcGrI18Ic6Qv\n", - "/CIoED3PEULjvgEx57/q4AEGPLE01V14kzUkhhSFvgxWlnltGu9XLruurhhwBgAAEBMAAQE4iAAL\n", - "D5PAFhmHIakwSTG0OHJS7DDE0wgAiPe3399v7WRSma98ff/pv12Xi4UXOkyZ5IAAAALrYQFHgA0A\n", - "GnIDrwqN6dYIQchfAj3764Dc81xpNWhhKQVTZREv79XxSGGAEY8/q3w2g/O7tl/4Ih074Ee+eGiZ\n", - "cRL4QaZVONgprQ5ay0395pmQZMVGitX+uAABAXcmYeSwwd1uQMy3/tHAO3uiqoOsE+8HBqK1r2Bn\n", - "jzvsBg0fPiQW29n68AmGFEqoiuHUqWL2BvwgCJ9CBp/aRVf/gw/BQAAQG3nyF4xLobuW+bcQh0C/\n", - "cI2vVuMrf/YUpKSSVd5RCiqXJDnOUoYAneExvDAXz1X2w0nqNKbiMuugEM/pYqo5u4Hlp4dDbzAv\n", - "TsIu6c9mT3x131LVym//yoDsee7Wb/vxwPA38iGM1GEnLLGdWZTD8GK0s8to13q5dd11cMyBsg5p\n", - "7WKv5SvTQdXhc/hvAAQDKM9BghXPsKMsKs/+AA+Jh2p4g5RY/qzHAGFZHfJIqr4JalRfhgAPHnCX\n", - "shTxjCWgs/AA5siUbLMp8GerekOwAObIWj9KrR9+FQgCCAAkDCACu+uogFyiLclJhrNAACAfZAAB\n", - "ATAAmII/a0IDhJVB3eRsSdEjGgv/5GAAICIAAgKAAWCT1q9wAYzhJJKJFIs7QRCiylEaMqw230Hg\n", - "DiYVqeIOUWN6swr4BjsjtkkRV8ENSovKQwAQYthAACAkAODioAVVzpkrqthPNsBAhvtEGJEI20xD\n", - "SpVzkSNkOT/vAaqCO3Nv0C77VDxApHGUxwEhN6KY7vLk2SMC51xUBJxUbAUbvnAAEBMwA2nDiXx6\n", - "//eEZOYIpm+vUa1ekBuwENDieSgvB9N++bz+hauTyAEFbEWlyHP7xh7MKtGX+diUhjPBlDi/b9Pf\n", - "gQHcog9RPYlN8ALIRShzB2rZLkTTxMAC4eq3XdNV/+wd69rWx+6wtsHm6wS4tmv//dGeuSWf/req\n", - "4xRKsU0fLZ9PG7VhlHei31Fsc//9AIJy+r5Sttc5//19HKcv95sJIB5MmHuC1zxzQ/GK1++N/WSA\n", - "AAAEomEBs4ANABpyA680IsMYDzJywAhIaOjKg6gICyBFWQdhArCgAn/+IQrud8QCAApGWU0AoDra\n", - "RoRvtP0AAQEAABASiAAMAAEAcRnBAAEgMWLCAAEBsAAQGQFApgAnBRngsg2Zw5vgPJVimdwAS0A0\n", - "YAFyQAAgFqBTtDpAFKgnI7/AOoAMR1kD0nADN34TeG+YvWAAIle3hAJSECAAPAMPfw8pHADDmdu/\n", - "lAAERWyUAiIw9Xa8aJ+BJCIawAMI8lM2k31pGmJ8pFdlGsXgAdbKKkT01DcSDq/wA6MxRNkT0XSV\n", - "/L4EAJCQmICGGfACzsAUoujkh1EpB3+7wA6Be95jyBbN/39vzbb4iFOr5MUpylggARSSQYqBCAIk\n", - "I2NRHsLeHTmo5db98SDilPz4N1F7fBABKQMRN1CvT0ymAcAUgLO44XlG4dgAeAOBAjai+AvPdhx+\n", - "cABBDOYQhxiBVk1xX/4AYCYYroxykJsT13hgSnQlQC+NzbdP/2AAAgDqG8N8lK15kjT/924MUFpq\n", - "zX3kLZoh8QhleAAVrAAagLKxcF59JPF/gIkKBsAGqfmZKAJHPQB+GGAAmQymdh3e4TxJNCykVBI2\n", - "l/94EAECqPCAAJBXFgAeAY9rteVuM7u/7QOKPMa1f4QcIc4goc5pTdcBIAGANGjt3toUaBIbtLh2\n", - "Ap9oL0AuzAQWJ5hCz4uCi1DPyIYjewkxZYzqy6YehgKeke2OI1q0kQhaSX+8JbYQ5n3jPiMbZihh\n", - "+fEm0JzkiDhgnE6Cv/IAL0OIormSG9D+hzD8CogUaSJLkSgNt39KEo8gihCSAtlgkNfOi0qByGGE\n", - "AAgrzQgABAMAAEAIGDwWIMaUgj5chZ2PfgN+oA96Ej/AmYBACTQNk5QBlgOGd9yJhndwEKcSAWu2\n", - "EXh+Gc7AAEBGQAAQEgANiAAIA6/1/wgoyBAAFwKeJdpMAkCOtL/yEBSBWAWmKq/tf8afzf+Zh4dg\n", - "AVaYSU+JCmpfrlkFqKlSE33hiLex6KOhbVwCj/gAx1kqyDjuCMYb2V+GAAmJh2p4g5RY/qzCYQAB\n", - "YCHiQlpYAFyB4SNGwWvYph/N36fTAGt2fRDPv6O0v+EQwIYfx9y4aQRjDgAOLHJHMC6ctI7D/7RA\n", - "3MNjUoLWOSf/PDD2KnaasY7IPkxjLwAIgFIdpMhcRKGOXteEAIyniHFo1R3uholF1ywZJoiLe3AR\n", - "AIWk2jCecJYmxYddVq/vH/76QQDlHuJmPKMPSaNWVe1a/5Z971YsNB/4MbqeaQVqXIJ8siyC9fX5\n", - "rD/9/ofgCgYAK5zGhg1ob39sexNoBIWZvHCJUSnvvUABgAoTCC5mby2SgCAu0wADD1Koa8gSvJv3\n", - "+A0q5r04rOtb/9wDcfEzXMD11jHzuGSACjQwqCs89v9wQBGj2KOv5+WbNhLb4IAAuCCFQMACrFQB\n", - "1IVl5/4tBOPPRjd1loU/+0hxCEYC19lKOf+2yAI2IoW4vSMn/4PjXjmV0bHM10OF8Ybtf//5obcA\n", - "QABGe9znvj3+BIxbRCdMUlR3D3/fgxmUZaWJKQYP/z/CCzuA3AmLYk8KFi4Nd/cMeZIAAALgYQCH\n", - "4ANABpyA68KCfhkMBmABYNQr2YUQko4lxfv7RgnONrEoKSPSf/P8IFVVAA9CJnStWFflg/h6XD/1\n", - "hEQF4AFqQL0SEStspepowVoiVoSPv8ABycoAAgBBeskMEQKUP2Aa//p0AAICclAAEBMACQ+3T3BG\n", - "ADrYGtpg6TOmXeSPSfAAEBGQAAQFAANiCS/AgAJxUBAACASAICi4JW3jcGK25s//WyqnAGoFaquM\n", - "dvgCN72fu6RZSwt0tgodP/YCkMgDlcYYcCwz99L4gSPBAZFHDYYACREIlWmQlctKAAhkMOS1RhiC\n", - "RaKiiKAAAgIAACAqABkAToB4AsAAkCmlTcCs5hR7fwA4/Hd32bPmTKkiADAGVyA053eY3KKvS3uE\n", - "L560xwiA8GHwxlJ1IsvvcBh2OOFiCLaH5XDKy/8neeAj4ANA98BxY9SV1jK4v/1Zee212ggHhGBA\n", - "ACAEQAFBMSNoXUDuflRMC52ervQAP2FsHzyp0sQnpZexK3/+8AmDMNcPPKcn2IBBZ8X4vwsql7f+\n", - "0EVgAXnvBGgDlXj9EcAMDncMniul36LxjhZhb8RcJIt6zquDLA68BFREiVESUGjaD/LumNooYEea\n", - "Pz+d0HIfgANkZmhNlKrMv59d93/q7TmTafAADkKF0oWypuCCQL/+8yyhp3Qpo5i+CCsUNt/hmxFB\n", - "l/jIQABUEEMgyRlc04bU4G4EsKLf0K42U3T92CVS8BRq2m5zsSFg/DD4GCAdNqMbm3wfVoRwtfB4\n", - "YDQTWmGEAVwa4f+uAjABAFKMKkbql/ESv/vHYmBgLa5jSQOhPKcfFghLCSInLVKRtSNm3LsHQCHC\n", - "AAkcoUKWIDFSvl25ghzLUO+7sDZeomzCtW3rCiSJJLf//r1aGhWMKnP+eZT1Y/yuoSb7ZoGp1P/6\n", - "jNvX2P/ffEAvC31NGkNupFZ1D74+35tvB+RRwkzqUsc5Qw545lK9NB1fPx97zP/8kAAAAkthAKLg\n", - "A0AGnIDrwsN6dS+GgYA7BAFBTY3ADUAAQEJZQABATAAoPn3gAEAGzBRRDmS+CAM4yGFhfpwCABhp\n", - "tDjcob54z9b//hjIIBAGRtTz7eA0IAj0YsBzwlPM3BNW8DQJZhSwFsx4Kfii2z/gq6q+w+AgVnHj\n", - "mXrwk3G9P/e2YZXU4/tLS97dBkY9I1UBdFNO9crDrECUSa8V5fBEAEHDwgABABAAUAYBAAD4A4bK\n", - "oTDDxTItGyYrlqSqAWMQmpU9CGDaFWdOBOzJDMoVUPgAJBgAJ4T9ZIVxIygtKOMaASTzXimGII3p\n", - "wDDCzKDxcS9/VnV4uTNY3KPukpfCHQ/S+EALPLhaAB3I3hABwD+RwC5LoPxhkHIakwSTG0OHJS7D\n", - "D+ZxRnCUpIxyhhhTMIAEVrWUgWw2e+dna5mfrsvFxxc6TJgYcMn+HwLA2GAA4AingDJ0+6INhZH5\n", - "/BAKSQYVYqF+sl6eloAAwYIxatWSKRI3cx/zgbUAXQirkCWTfU4/3AN2ARJQIRK3pZJo9//9cCVX\n", - "A9PUNX+V7/ABxIgOEOTbVJAlNiUp6X6BxtAkhacl4HdowvRErQm+DAUgUL4FslKeqOmRQ2K/iAAB\n", - "CEgAAg1+DCrIIATBCaWzKC5db9tAMp7fUNkBE0//yQXak9SqTSCKffdFobeEENUfqUfGZ72A5lwD\n", - "IvwB8CHMIgXgtvAEbGW6zCj8vxsH8UrohM3n/ACTgtQFEhKG7NtmtZ/+DHChUZ315ClQg7jmc57K\n", - "quvvpmoN4RSmhDt5IAAAANlhAL3gA0AGnIDrwuwNMEwdC8ACoQGgiQquwxtcscgA1uMTzkwauPPA\n", - "GgMkbgIwQcbQf8lxwiAZZD9oAQCc0pSW6AD/EgK+fwPwBJkqrPADwQyYnhK5QlVk2QCAAEAMAwSQ\n", - "CAARjTIAD4BWohwxf+D7lA3PVZAAsAAQB+4Q0GZFpcDpyrFRB1LNiaO5zAhBwM57AAEBCygACC2A\n", - "AIFd5wYcQkIQACO98s+EhDMJVeD/REAbIApYSVdM+rwYcNG/8fwQcABAABABAoGhVXhlw1BAQsG7\n", - "onv4NA7gAAAACmHgA4AHHIDrwbwAAAAOYQb4AOABxyA68GR/OskAAAGEYQNuADgAccgOvC8CCC0O\n", - "YACMIoUpaDxBQbQ4cFDv4eMETVyGqMhaZ7VGETMggBMY/ACuZjE7Sar3ACxCLRDY6RXEvgYAWYE0\n", - "VhvwRwangrC6XoCmD+xyGAPxBQEPi3VDDQvPXkAWFcoIWTRd4XrIFvF0hGBQIKWm2TcLBAACBGAA\n", - "IA4BgSCAAEB4AAQBAHjuB7JsDMQB1CZhgeE/x/eLUMgbrHmFhf/68NQag5C/5iYdqeIOUaP6swr4\n", - "BgJzwcbLppokhD8ZO7wMSEQnDVpUd45//oYEgE4V3AWH1YilIw7eQVgMPOSqbJWh/Ez0wrSef/LC\n", - "wdC3gY3CKSJeQUYELttvJ/OvuACAPrYBSk6+WAk9zAP//vBilWOT+Wq6Iz/Sv2fAzHDmcAbWtxJH\n", - "WhEf77oL00UsJBU6jKNbDSMFuPZAPv+MW2mBAAEAgCRkIAAQPQABAhAFBrkK19fGYAJAObDwsSHK\n", - "7EBEkAP799nnJmCrY///z+PDBGqU+yXAAF7AZDgMkAAAApFhAUeADgAccgOvCwnzfw/4cwAEYABH\n", - "EKH8KQRmSHWoTF+YCmVMgA4Ag5vkTymEHiUVEu/JIAAQH8wU08IHvtNGPIQLbhKAAgLABwJWC3gi\n", - "6dTkDRqEiT0YlZSGCAA+QMDmLQPOIMhHpl14EciA6NDJ4VuRsSwRhULfPAxWAUNYdT5EK8uIwj6Q\n", - "AKSIAATYADqBSqhOW+wABErHNPGAACAiAAICoAGgimaWABgkhefA3JarIAtv7hBOK5RMA8PwXwH5\n", - "b3gBg6HHkgOlafogvnjdx5gPQAoXLgJ+ktEWEAJoQAB8B0pwcw1HibDUxOY4PA4xCoJJRQU4t+vy\n", - "oAEBAEVkwBoqC6foPghAr41Tmto9b0n/9YYYP5/gWwJ4IIADhBWQ5Pe3BuyDT+sgDGFr1QgKfsA8\n", - "/v3sEHBfaaGcMDKFYLlALuIYanBM14g8BtZCqgALxAKCDl7DZGZLCO+AQVwohov6PRJWyTqQJQAk\n", - "JgDJwAEAcqVmYAJ64ghCXtCWa6L72DqZxgKjEgTtKWEwLi+C27w8gKog8FsIcFVMvAAQ8PGHUQgf\n", - "iMnjCgg0hCOG3fnbiYXoe78EAAIA4AAgAODQgACIAKAddMCdMMoxUoGOkQs/YAA0H7fRBnMPjQAl\n", - "hYHNmGMFDLp95YABgQg4kSdpI9i2gAPEOK1CGsFQXS9ng0A2znESM+T4dQ22KB8FqDk6naIEFxym\n", - "PzWUCTO/3BwlKA4UtzZQEPlYC//uXh3hU+815Ite4SIxhTqWASQSQAZGvtBuU8KWKAuiW2+tQ6YP\n", - "vibzkqRj/7f4SbIeQqKmCASg54MC/TAgXSCBcmUnk1IL+OwA257T85wPofLMTA54zZayLU0Q8Ihf\n", - "Jk4WOJ/3vJAAAAZAYQGzgA4AHHIDrzQ/DHgAFEMwBTlgEZFZ5my2AodoLb/Nklp4vYBB4ZT9XcBQ\n", - "QC24Qy6KouhAAGADiSQQAAgXgACBoAOARwAdKcqkEr2nAH4DVDQCIPD4DabABLADcgCEDTOSBb4A\n", - "sgDAGILCchlCVDKScnXHMNwHmTlgh9785CyBlWUIoo1pYAV//cCIgA6IYWePEKnW9/4IAAQAADBJ\n", - "MIAAQRwABArAA4C3sMKK4fzBlwh+/v9DUME5ScGuiE74AlXn944T8BMgpBBuABWOC8OhYSiL/3jA\n", - "xiSiYFQtufRil/wAEMlADIXwlVMiP8EwJDTiPzGQosoUk9wAZQuFPpgRIowZgDv/vYu4RbCztKGs\n", - "EFwABDfwgACaoADcAAIDoxMuuDU8EAAgQcdCAALAAKNGABjZT5/1zlGFS41XDvMUCB/choUrsIHE\n", - "B3l6mOpAAGJ3wAS+rSPl+/U57L1M7/AyGMztSPVeOWIkTh0wMavEQbB2opNLAQQEBBkbAARAEYTg\n", - "Bbc4YsAONfwyh8GAnlljFrEiYKuW6Uv3AGuU4cEEtPo2eqJ/rAABAFBkNFsCptSSfjXveAXaGMLQ\n", - "NmEaKyOIq4NWpZQ8g70wK2g9+8MAoTrr9hW+XGXEynz8ABGAQNGi/Ka2BBeK2bw78MDAGFW2KwM6\n", - "08D/cPP//4CAoqxeBOOqCG70zBz5PymvRlGOtHC1ddXcp3gAihNKdTR0yrBmIO/+sAUAAEA6hUrF\n", - "pAATmAWjKAAEAaZKYHooAAQBgALV2DCsQQAAgIgACBcAL4EAAIEGAAEBYAvS2BV3AZNGrBnXaOxw\n", - "jG1EAEgWrf9hYDRAEUKsioK0n/aYdPKp8Yc0BNXYhjPDFhGDVMqeJttFYYMMXxGCewNki0MKGPb+\n", - "M+69FE1RUt+kBhBF3SH9WdhQ4W70+mmnT/B6wXEYQ+6MFtRzf3+BB+XpQGXJdMAvEHKuZwwAABEr\n", - "gDOgACAhZAABBbAAECu84IAE5DBAACAoABgEi89FaO/2Dsz0PIKJqXkt9aE1o1r9g+NYBccTkmm0\n", - "tkNMwxKlwrgCg1wzEieemVSe3qHgHFXgkmqr1gACBRe4FRzB/1zDY4aXVulv/gpDmkFX67eDCAAK\n", - "gMaOCAAECAAAQHwCAbB1pi7FzFOZKCcgfCR3hT75/gZQCLqIJ4uS228aGgcaxF8a1bCPmY11+/8i\n", - "DPxABLQ4ii+6Ib0EdD3xAICOQYQNxHhkmIx3hhhAAGQcSuEAAIEwAAgGAHBjDbJhiSoauL83f/QV\n", - "EYagcdwXBgoBMmPv+OP5p4gWcWxX9oADA4RvDPN5MePhQn8AQhNJgKVgknQlUX94wAkgcSM7Uy5V\n", - "NPN2/kBgvwhoJCKQUT4CClNHgCIXgPcpRDB3Gmz/CQADAA5tOH8mD2gwXg0//ZAACwoT1QopSouJ\n", - "8f8AEIF7aSV+z7xgIISPhwAAQKwKBMAGg18oAQPwrABAACAOEAAVACIcBOkCLQnzevQY/aIh6w4a\n", - "fGr6TfgFCOJD4hCZsRNVTGZ1RkK7xwAt/+AuQY7vws5JAvyTOkDsPWAEaaBSwKHj/o75pvh6u+C1\n", - "wCLHsOYXjetphJRY72Sv77gSKVRUETqWsif+9gBA857ngVkiw3p4E+AAygPkqAoohKnWPgI74xLI\n", - "pBDFbxxHGyITu4hNZJBLhwACAAhuuHckDmgwXQ0//cAQj4TAUrBJOhKov7xBgDhMCJUEo9VrF4di\n", - "sg8hg3iSR10eM1RAEbNn/7QsIAUuyViHN4xonJ7uMAAQAQvP8kNPAHVjMyoAabkE4Q9i3NkxwABK\n", - "YAAg//eAAQNsoHN+4iCaKJXH34ILeLeGxCN7ympDWFPAw8Q6xKKdXY2aD3/+CAAEA4AAQPQBZwIA\n", - "AQOwCAACAkCukhiZGhetVsas/tGiEuQScQsCIPUER1AFxRAeK60sIIq3CUYfC4lo73aZAwF6YkIX\n", - "9XMX/2Ngzwc3QmiOTe7QFTgHkWgU0Fb1RvCcYz4oOx6CmNODl8SCILTAABARAAEBQADQABAJlgFs\n", - "MJBpoUSiIpmYxef9gTarCvJOz/9+HoJJSVFuqW/t6aXAphAExjBAACAKAKFk6gn8OJwzHs9hn/7u\n", - "/QwDIcCNEE3QR9OenqvRkgAAApphAIfgA4AHHIDrwqJ8T6EBsCuCcbAAfA6AqlnyF4mEdlu3//84\n", - "AggJvOiYiKo+5RvnmyEAiQZiw1+zWK77zDXjpSaXbwtUi2zgBUaXWefYRCIKX7QIHQ4Se1JpEG5F\n", - "Rz/XsDF8Gdlurxl/oaKh7wAhNz8lKRoXQ8VgBv/gHeNBywXMTSViUlS2D/wGwS68UMo4ppmxBgl8\n", - "QFUgMAZrlNMA4OKQz28zDvHSv133qANAPAPfs8KTNj8kB+HATwgABBCAAEB4AAQJCgAGEAfYViiF\n", - "9z6IAJGAcSrJoA4VHc1/RDaniwiGxAwp6LZX/sAB+yAIIsL8PuPwwQvrjhAqcTyklPHhGfLLozSA\n", - "AwqgW5wOL96wQlwt0eABAA+HFJWKYiFhFv+pahoQ5TE1e4CYMQ8kTpF4iVAITAN/2du9c2evQgAC\n", - "BHbAABArAAEAOAE/c8IhAB2ZCD/AacoLAhLLgABKXgc6CwztNNetPBAqCmhABET+ggjJMVCuWGQM\n", - "EX+D0Lk9KdA/br6fvwZo7DYxjmJ+g+E4HfnIDMz0khhk/m+kP9Bz/GBAACABIS5U+RSGaC67XeBh\n", - "h9cXjAc3hoiUpP6CcAD8AQAUr1Hh5B4IeHbf4EABHc8IAESr8CGAyAnea/iynNCu6AFYQJeDcrRf\n", - "YCsQQkXuxBidiLbG/EGUEOMJBJlZ0LJHe0wI4eMPsN+AB4QM5HFZZH677CXeEI4LxSdPwdxqAj/w\n", - "A2HkpBh8CdS/RP3hipkklpsgAsVjxhGhQDDAEMNyGjVkv7UU6m6x4EEgTJZChdQoJxJ1iQIAAQAw\n", - "DgLGwgACQYAwKaBI0KcBEKwWYNht35wcD5nAEeDnfP1gD6AMAw/Av6gRgEjfohkoHHiking3Ihan\n", - "LyQAAAHIYQCi4AOABxyA68Lm/h/w5gAOAxFBy87imhBNwchkFH6YAAICwAKLOJkAGhgalgoud6GS\n", - "TxpzN/4AYM7XiUMYdRlwWX/wQkCOEACJdQAU1hF8BEl0EHOTYIPlner0AC7DESge1q4R8cWkCMoz\n", - "QuhUXmsFIRwt5doAAQJtLrQABCjsAAQeeDDKo0ABOHkUDuuHkyxYRCW95jA1AjeRKLlTIoiZqeGB\n", - "DvKJBzN+zB1VUGP+8OhF8UUfVLAhsSYsQgACAQe+EAAIAwA0RmAFz4xQqS0kHghROASUYSGLlc/n\n", - "mZgCDB2SbAooZIA8DKiBhc64qXkmbw0b+H8EHMyNlTIASwgaWogLWLnokzxffMiGV0EZiSUsYn5G\n", - "DEKzTzQgT6y1eMxAWIQABQFiYMbSMXuKUGb6RnIReWyJMZRj2YkZ4yQldGFWURrT5sI9z/huWaGA\n", - "WUqYYBR3lgJdAAoDHC4hmErLDL+cECX6xhud4JLvgCA3//3H1Q2rhvIJf6cv2zJ4kAGBib1hQDD3\n", - "0lyIyGAAIAQMthAACCCAAcOh2ykJXIF5phgenEyQi8Ipwx1fwxMK1J7ihoh2mfvw9AJQVxKTxXhV\n", - "KxNzheSAAAAAVGEAveADgAccgOvC+BKw7gAIAYcsssSyymmmyyyyyAA8CRAzAEqLUSaB8a1OMzGV\n", - "1FbqSUtaGGH/8DjmEFmYAGATOoxvwH8AB9mZhDO27IMOUGHAqwAAAAph4APAB5yA68G8AAAAfmEG\n", - "+ADwAecgOvBmbjjYFD0G+AEGAAICNloAAgtQAAIFZ3gEsKg0EsC1ywgpZqP73+AA80wwFPycBJs6\n", - "TI94wRRSCVCVsoEVGmVggARQggEAAIBQAYADQKgAguHNLxj6PGEUNDgNxngAU2QkA3pvlAWEqQ7R\n", - "rEEWYSEAR5HeSAAAARphA24APAB5yA68LifE8NIOoQKC+AAlmUyFVhymYvnQc4b8eUSSIXvgrATw\n", - "nhSlTpxQARKxTwDHR7PcmAk5kDz//QIAAQCgA4SQCAAEFcAAQOgADgF4AHfFqeIWkhiDY2GhVeXQ\n", - "B40Ji5+oAfIm8AAQAcAUkWYeAAWfYejdmJ5yalm5v5wCJo0ht1IrOvgAAgEBvUBpI0ijMWWe8PHf\n", - "/X7ezbbDGqBqqeEFrTzG6V45ddTYAAga4AQSkjZHXWigFiEJb/ttmZjBBFZzUAAEEv4YAAICIAAg\n", - "KAAaAAIBKZ6qmqoEAAIB4AOU4IAAQSgABAuAB4PgSkxizKUIERYTf79FQKngRGYSeceBmTMJ+b+Q\n", - "4w9kJebyxgg9DJAAAAIdYQFHgA8AHnIDrwvOGQvAAhAAG/rgBhBsTjTNFfBKCBVOJZehjJQAHwE8\n", - "HzxAxoRFciElOJNT7vAEUMGo0aUSABKaZXQBW8DSgQg1w06PSZxYx+AkAA0BxAABAeAAEAMwAfAM\n", - "6kEMn/EH90FjEILF0+e8XcOQAHgziOqBZedQLeH7bwZhDS084CrtATrNCOikGBgLcAqF07EJ8ONU\n", - "IX7wQBuDS2u/PJDB41WITXRAHygKUedAKoS2BL1xEJDQWhZMd1JTIXfvAfAW5utJR5Xpdlm4XpiE\n", - "GZB/u74PGLwLdiOL1aFNf/3CQgfpu7CBSNsJW//wgABkDwgABAFAOAsb1l3DBX8wwUuErwPBuAIo\n", - "5L6AJ2Fb/8/TwPRQECouAEfAHPcD0GCg8igSOJqCxE+Ekx3ho3w/xBhzG1EABCQOCXdvN/Dj4kyZ\n", - "Nx6ABheSt6W8GOSgen8z6M0iPpz8DDWdglK5VgyeoVElOgBGCEEyF9UH1vmw1fBAAEQgpsCScEIa\n", - "5mW84nf/+UDKBApeoFbg/FYk+4sCiohykfIf+gkgQ4tUiIMECe2TCwB+/2G4fBMHWTHQePNeNLo/\n", - "gQPyFuxGZVKrKKkPxsRUm7oiK1cCQAE1KAMEcjCq1SfH/9zNx/8SjQg+uyCBUCAAKAjyQgACYcCB\n", - "DMoMXEWpCv33doj0OkyAITCCfV3gA6RAaXOFz6vMvx88AIZR4EuBv7XkgAAAA59hAbOADwAecgOv\n", - "NBAwxKcAeZOWAAZyZMjTI2TMAAKg5r5YQ+35w4bxp+9wGAABAApXOACjxphW7MWBowABAFsAcswI\n", - "Bk5V4uAAWAQBFWwIAAQAwAgUZxuQAUzahbiQe0sARPuUHAMjCFMXp73AuoYXMEBPwFeC0b4AFsGx\n", - "xtahBSRyb/5AAsAhdKQgGDlGUWU4AF/f4BR4xcQ4Phykjrv/vBcI+A1S4USYwMxeQBfgKAYRDyss\n", - "f2bBSJgHf/2mzD9OU5Sj7SAAEAPDhCtVV3dknQZ+7wheBNXdkbbC6CEzAmReIACAKk0wwBwqqh79\n", - "vitQS4ABseokwAaYQBwCAAEB4AO08IAAQKQABAIJOAAexk3yK6O5EoRMeYUkI6a3/tYEwsxD/FQX\n", - "aH9qQYsMSOy/5sdfv+OIEAOGNBzSVB2WjJEwCL/wJBTWa4waAE/SvnyS2cAZYC2BthbgAAhzm5gs\n", - "W+hfC8Kr7tBlKeFLFAXRbbfXEIphT3wGGhdOUkYr4PwiAwu72fICqjUcb65r4i8SVYi3psN0L9Ag\n", - "AEKNfCAAEAAAhxmAPhfuI/z/DSv4Hhju/p8O0lf+v1gcAe5BdrMNE2hgDgkjMGinKbxKkwr0jQlu\n", - "yrsnwwAA6QIbLf8QMFcT7wjrj6hY75wDGEWvw8TQGWxuGFYJQMMIEjkCAALAKcNJ+tHE20BkBFr9\n", - "35E7uYlHZMsQnAQ2PoMMIH+HQLQ2A4jdZbwBCk1vD9noCf7Zz8gACkJBYV4NFJqZVqL9xAACASAF\n", - "BdqJs6GF1LgOCU8oQEbO48A8Pa7RolekkRKIqJL//5oAAQDRRV7CD1GwY4Owg/7BHgYAwqq4pAm3\n", - "I372frfAf//PQSwAgAXz80So38pYL/8BwLYhM3k5kU6ZqctfCBGg9dmTtKgWXfFFoEYfBBBuP3qa\n", - "Z4BdhvOAx/4IAAsKEfDAAEEcAAQSQfBqyRIgOW/n/pthFRmSgBUg55+b/rOwlZoKFdFDLN7/1ABY\n", - "ZjdB5kkAekBIICwJgRagwXKTyvAtzgP2BDipxmYfOkLaDDhPc1IcSqfC9I9JjAn8CQPYbg4CL67j\n", - "v8AUAAIAAoriEUxHNZ/ueZ6vg1J+cBAQ8CKcPERr8soPq7uD0IdsSUYLNM/QE0gAyaa9aeCAALAw\n", - "A8PhAACA2AAcAAQDgCmkg8Lfr6wIuKK3/fZQUJm2+AAEBH/n6MNjIJzrPBMgmkd/Axcr2pBqVuiS\n", - "9YEgZIAAAAItYQCH4APAB5yA68LoLgoYLAvABeu5Vmj/e7gBiGpmpiJ4MImhfgMy25Se1/nGoAgp\n", - "JCQJPQqcaCP9vHhhBBGEdrn1y5Ek8i+ERQhEUxFCm1VVyIMAAbASGCABAPAStXzgKjEN+oIaPIUR\n", - "iR+AZEZyCoaHiyCXtOALmQndJ4BlhpOpgEB/4WFjwMYZFQOcBQbZ4KipUEBiBWFvACGy4UJfQY+Z\n", - "6sj/1mINsJpc9+n/p99sutdaQwUbPgZ5M0SY+gdPKgACQDBUGpjw1gA28g8YdXXZJixFO06E6N/5\n", - "tNaG+cAFAG72D5i/+CAAIhSCAgAIz2wE0CT8p03sHZw0QNZBZHV/nvtNYP/GFm/fQdDgSnKHI9/e\n", - "f/hqcWF/mBuzsIlAnaaloXAMUeziyQAWj2+yAvbaAIQjC8BbkkCYWOMxnJugAouDQokpUlzgQEkn\n", - "+GIxGOdNB7W/BAAEQhx4QkAAYDb4JCsD66vxA8hP1DaXdoDNoKoIo7GqBkDJH9tAmwhd4qllNJUL\n", - "dMCOHj/hv4AGcahKrSrlbkLRqnrQAAgAko55DgWJX8pn/7hgDHNLbC0PKsoMIf/7gITdVxXg2l0p\n", - "gB4HXvzcD+vQGEzW4IIgfhxgztkrNc+V/uAY0ObgCl06TfP9V//eEc7GIAgeVL3oGWGKUIAAQCQA\n", - "BAVBtQgAmCv4PursQGrylBFBUPbAEoOExhGVEIlXv0KhKnBvqwm+m677LZCELnCQN//7d5IAAAEh\n", - "YQCi4APAB5yA68L2JC8ACVhaniPSQj9wwEOVaKJSANiy8ACPsHwgiFUAX5HjWZwZlYM744AyA3eW\n", - "vm+xgIM/GIlOdiLTAmvFrBAAFQQ84IAAQKAABANAEBmADMogQShdUj50Jlw7jF/q9AA6W6OKLL1D\n", - "lxKFShXxDQtZ//9eFs6UAKADg4BIfH5vEQGM0s8UgTAojSLVYO+GKgSljrn1RJx+1q//uIOg8EBU\n", - "CQnIxGK58//egM8AaBi62YI11kAjkAGD8kaqLTEhcIJoZHgH++C4INmga/92kt6g0MFaQz+8EAAQ\n", - "CHHBAACBiAAICoGi8hAUOuAE0AZ4Id0hAXrkJKiMiv4yRnADA4I8mGYwJUEPTIBC0hi3N8FJZPDQ\n", - "jxH5IAAAAIdhAL3gA8AHnIDrwwaLB5h/GwAigACAlLKAAICoAFQBEfvEDKIQQ8SvlAgoyypnuGAL\n", - "TpgL4AduAYABDD/w+gDQ+hu4QdB4IWFLlhGNQzVf3hhABMAQcEAAIBYAcADQKgDKUNTgPxgYFRgp\n", - "5cMdR4AKEtQVZhAQBDkcGBGZiUD+i+WBYTpDAqwAAAAKYeAEAAgcgOvBvAAAAYthBvgBAAIHIDrw\n", - "vw5gAYXkrelvgYSzsPI8NYMnqFRJSgI8Akf6L/dwAQ63T6TtxsADCLiUx1k4YvgXBAuccfGYEGzw\n", - "GgX//3CICADmchATcVXPARmP/8yjKFvyv3BDZZRFocM1PBIAAQ194gAPGHKA5MPKYc5RCUxTIAAE\n", - "CoAAQpQABB9ZcBuZQBAySPkQfkPRKzwGXhwgAIwLNhAAFAgHioAPk8A8GzRFf4DsawMTLdrDz+vA\n", - "B8jwAeAneEX/gPBk8AwmWV7h7+eGliCBzAAbAzhroSlTbKSXN74ztNZ6vBCRGEAAQCkkfgAaq5jY\n", - "5o4h+AA8aAN2UgGPDCd2juKEhbhgAJg0UIvijaKF78p3gjjS1pVLkWs2otHoAAQg2l42AGBSaxha\n", - "qcUcAsL+CAHJhJKZDtbCK/ASP/gWdwU08G2JkShkhmIQAAgIAAQB4+EAAIM4AAglgACB0ACQRghP\n", - "4QUj1+/ZQGtJqAxJgeJveBBNBji1sTu6cE9A+AH6MKSUKnWAq+Nw0KAZIAAAAYlhA24AQACByA68\n", - "L8OeAAmRDK6GMhR0qUlf4ARP8r1+8LQAKQAGAUbi10dDDYgDQFv/9ggwDlyggBqOggDkX3+7ezM4\n", - "JIB9L884A+L5pT4AYY8V8TaySrk5+UsRruADCIeVlj+zYKRMA7/+4YDEJKJSJj2fcDL/+8QAvw5Q\n", - "Pd/RB0mABKoBHwe0JgKCOohBOoavcIAAIEIAAgCxAABAXAAcgAsqaGBPImpXrBgLGCgTGedIqVUU\n", - "QwA4HAgq7hHaDB8y+FeLYxP5M0J+Bho3wh/oOfkYMQrNPNCBfrLUkbw+ABheSt6WAJCBZ2gCMaMS\n", - "tn34DMAdLxkkG042HNt8wdPQbsAAF+oAgPuQjaCCiyCHaOMiBkl5Lf/zTmALI6YABbcAYABDj/w+\n", - "ADQ+hu0QdB4IWFLlhFMzVf3vAbgBRzMseK4BBhAOFUyhgYAAsYAgQBAAcBID9GGjjTRpoNqceAAL\n", - "aDRoLxwigi4/vsEAxcHA+mQk6C6gOIIGAAIAcsC5sgAw7trAHiPL4MkAAAHhYQFHgBAAIHIDrwu8\n", - "MoL4ADxhVUA3tOkbJ1a8OAUIfhRw/RFGIlfeACByVOITlFgXsQePf+8wAYFDbKfRYHFVxYFAK4IA\n", - "AmGQkISAAQHgAPlDVcxuwXWJ4DhrHiDvpwQIAPYpVGPuoEF6CmmhMHJSQGa7CALQtGSCALGCSYTU\n", - "mAHyBArNl/eDF60FyzSgqqwXVCjwGiEKDLQ5LwAbJQGu8BgYtxo5LqkwYGkNf/eYZgzUCTD9GykJ\n", - "BJZ4BXQA/eEoKa9qPgDPDYjswLBCgUqaRX8EBQAw4IAA8AGAGhG8AAOLdxANx7sTXc4MosN46E00\n", - "JUj0OhsGEazWDxaLf/quqEbXDHLFBMHOjABFQw/9YMNG+FfwNBD9sAAQATABTzzZgwD7jJMTePzA\n", - "hTNnRSrKirgAJZiio3WHKZiw/4vkpm0n6mjSG3Uis6hAEphwgAC4IedCZ5bDBCxH/bAAZFuSs2kz\n", - "zTQ2pwJNuHELktbadfYEz9gwJhb4BcgCghvNCKSz1TrAAAg++AwdLFhbbKkJm2wiainTYRB0HCCz\n", - "LIL5l+3gBlLgC1CUwwfxts/4ba/fN+EAAIBYAcGnwgADAEDCmgP9AqVFJM8oW2+89KS+sAxSyzQT\n", - "HD3juggGzSCXmz3kgAAAA11hAbOAEAAgcgOvMX/CE8MZSCAAhnKh8QMQAvYY4Jicexn35//UpBYI\n", - "cWAAIEgAAgGwLGj+sCwDR2kMStlnggAiNaEAAIA4AcONYAIIvNFgALgQW/GMFEUaT9gAON2EV3OW\n", - "TwAbwETCzhfIGSWTpG39G9Kggbjdw/hHYAFaDnCJ4kwkkUvdBFIeELVATRbTfXgABSsB+KFNp2et\n", - "75vqOkrfFIE1gd/uuGlCPpoZOr1dZEgbI0DiYJn+/qDAUuB6GXxf1nwm+LCv/8AEBwABARtkAAEF\n", - "oAAQKzeDNhAAHgAfCwgABAXAAMBB8AB0HZDF9YWokjCAJK2EtQvDbu/gwJ8KOTpQpFBNUCJsZvI6\n", - "khlLAkKj5D9CVln5AkwLC4JAsHQt0ID0XQBEPHQg4FxRCQaeOEABpCBK1da0TfPAABABQ6Cicxjl\n", - "sy5KwAFODegKEWqWr0EJnLQE33nADCrgV+Lrs3BBHZodU7gCPSweuOGC5//F0cnp8QMM6yC3nmBB\n", - "EIAAuDgkyEAAIAQAwONcE6nCcYoXnj2QxuHqBZzIFhMNeD2X94IJMcA56DQ24CNTfB420xgaGNED\n", - "ST+7xLCFwr8AMfnrzhszMRnEpRldVfdXfQf6tkKFENm8ln19DBWTDRiLRHDTrHhhALlcIAA8BBzA\n", - "VPhoCpNLX8nyZ27d/8IsBszANT4AKcCTi5Pdiub8nfB/PhhA3hAPi6IIQBDQIJz5FfiWXnCrLnof\n", - "QIrizbIOaQW0PwAik4BbhCZYO420f4ADlwPQy+L+WGyN8LmX/8AAgAEQKXk00C2BRglEW1f7LyVv\n", - "S3uDArPWPILkAXvtM8/Bg3nQaY0LYKmpExRKEAAgjCwjAACAcAAsBYarkoLcvLFENAAab4hZS9mL\n", - "LMWmUNQhv2oEsgBDcsYskkQFy25gANGfEFnOpCFljNohQaggn7VhkL4W/4SeJ4hc6YPgABjqFYjy\n", - "2QgV80hwof94AwKRDvONck8Muwu/5AMEKQoFyGpLhc7ekYi+CDBUiqJPzBWXgQjMwrVAACBRIAAI\n", - "U4AAg+MaXBkEOgKYrZuoFxy2P3/4IAAiFc4IAAQPAABAgABYO0xKNLtulHr/tv05jnCRcyK7Zv0s\n", - "OVhy2IXqwU/fpgFgLo15a5IoCHhq3kgAAAHXYQCH4AQACByA68Lm8X/4R2AAh84+hBESlrlIm5Gy\n", - "bwzt5YBRlFLfeltf8zs/sOAA0U44lYslD4mlWJkv2YBWmuyzRAA8i0ypB6EAsMSEAAIAQA41gADF\n", - "a07TalJnQylUHgwlPJnB5OFf8gAMRaycybVQxvI5xdT4MDAod2IFSOGJWZOYKAVBv4BkVgCFAoKz\n", - "zd8pQ0WDzlgBKcAILPjlbB+1emmQGAP4aoSMcRqOAALetDBw7MUBGPrnBQDMJNwQABgCD3wwACAa\n", - "2TE7mCfEqY4EiB3/u8wI0FLX60AbABYg/RASp4+f/eGjfOn0gg5+AYsmT3TDQURjxAJ9ALHAgVZJ\n", - "4mBW1goMfqAoGQOPwgmsQsvt0SZ//25weY4iF55/zwQABgCmGhAAFQRCYGgY0RO/BZUPAr6gLHWJ\n", - "Z7tf4IgcORQSgmTXV+kAAEgHDrk0q4WJPw34WBuHWFRRSMXbmHNiYdA803QwSUNH//1wDCrZBGAx\n", - "2lniRkZvA1Wg6AE13K7NxCSjzNsbq/tV/6GGABZwdpgklIgcKiIzfvfBANAAIBQQAAgUEAAECcL4\n", - "BtSLAdHfJ4UMk4d2a1IcVPV6frGKT/iNdj42BKx/32sAiODtEEvOtvPJAAABoWEAouAEAAgcgOvC\n", - "4dwAEAxh33/+e88/9/zz/wALGJSIThq0qO8c/7/8AB8gYpW4eYAgH+8tBoBIXCC5SQANF9Bo5qUh\n", - "D2JGNGz6N6QANAOs46SDKebcG+FusED+cSBif/vgcRPv/bRAAIwARzA7EOOTKEn/gBMRM4wuNi/8\n", - "AZMGsFhKLtThuczebbX3VjjzoDuoAwCWHG5PDsrq0oP+4xBxMnGBKhQ8XMAViD/4IAAwBIoIAAQG\n", - "QAHAICHeAAJVSgXEQsXtIPDBJ/DubODaPAG+hA2Si0U/oPEgBh4MHeXD7wLUY+8NcNfkZCKymOhR\n", - "krUmGv/em6da/f8LfBADkwkkOiW1sIrwjZAx8CIuBbB81xH9X+Yk/3KAAwCjcWujoYbEAaAt//sE\n", - "GAcuUEANR0EAci+/3b1JQQAAgCyioMAAEAcAjCP/MQqQps6XQ6SFz87Tn/ABBUOK2h/JsFYGAd//\n", - "cIBCEFEIER7LuRl//AQAAIDIABRBOBMNP+74BLJUWeBOQSjS0XNaU1Mv77MGCuGMEUjhgCVzfeMw\n", - "D2oc2f7PJAAAATNhAL3gBAAIHIDrwuX8QTw1gArbRIboRz1egqAASKAD6oBVDqPHAiNFCAAJhiyo\n", - "AL8oeYX8oge/AAmCIFmDniTCifxOHxwW8IxGoDkhK2HKBKo1/+8I4ANAoiqXedqWEcIpfY8oReFH\n", - "4UNhtQAT4GVABFSwo8eI1O97/xiZuWb7+/O/CAAECUAAQCQDQuEAAISwAAg9AACCAADGjjD1ZRRE\n", - "vTF0HvvRAAG4EeWPwkC+oh4l5BmY0qu88N8LQAK0HGKEt5jxSK+0EQp6UkUBNFNt9cAACAJaGXly\n", - "rGI5wAAgV//uAUdwH/W1w6zhUb/7QAuKF9nDdhSbOoxv7QAg217hstN6mbH+v8IAAiFAWNgQBIAA\n", - "4BLFRUQXyDsAx8PQRkUEqTPZ/gm77xLbHiLZHcj7JwdQAAAACmHgBEAInIDrwbwAAAElYQb4ARAC\n", - "JyA68LxM9f4cYGZofgBaSM8i2vvaU1AmArgGbxxAHZnAfByPn/bYAIffWBUiDo+C4+P/vBgq4W/T\n", - "kPNAUQCE2XADCEhHYG3gD7K9EC6rp/7wGd2BxgGyWajilc2KFvg3KChwi3WMN8k1me5av30/3DhA\n", - "AEg2YEAAIMIAAgigACBYAFAAjYCoWcEw/IMDaWsE/YxJ/14ARuACoPaAmX/A+QAxamjhfdA/Ufkx\n", - "EGGhC5fQRwqG8NwAKgEgcwGvjeDzb5VW797ZB8DBc1KKmxTVZB2gADk3OAAYyi2AAEsbEEo8wjvT\n", - "UgACBB/gQAAgMgAFAUNBAACEcAAIOQAAgagBu4TycAMShoRwKwWL9nr27RgBz5wunEnmAHFwSBEp\n", - "HkgAAAHqYQNuAEQAicgOvC4dwAECOYxzHMcxzHOY/wAMQABv64AYUdE40zaH/oBMAGRvuuz8ADLn\n", - "PnWoeKEBbYZ+E3Z0QUm5fcEMg5wWtJBZIbK5T3gEkFSH5IF33g56VYGA58E0UrAAYvYZ4CgIcAe8\n", - "BEQBe2wk4CGfKgSFnuEQeKRCqITZpwAAhc/9oCeAYWXI1sqkHwS5H//xgg6rlg9sDSOzknA9BAAC\n", - "ACAUACgIBAACB4AAIEQAAgsgAf1PDgbO9PhxuDgwPO6mWh1uwcP4sgeEtiYISAsIYB8PgFFQPMBQ\n", - "MfvmYYaN//SsOeAAhjUDovsXdI7O4GAqKPBkAY02NW9X6Dr8oCYDBSk8SFGg23sVCJRAoAAgFCEg\n", - "GNABwaoMh5uuKOQMyzUMwdE+c0ADrARJTg7TB2F2yArE4VS+aKronprswXT2Zl+G4wwABARtAAEB\n", - "QADwSHP53jCIFJJC2GOJvjRbw+8MM4XMvhBaBAmYCrPXyJATaDEHhaHMFW/ADYBX6F1Kdc+qucWN\n", - "2B4KbxobhGh8u54AAYNQm/k0XXB3C6O7nxD4OPlaEkSeSgP6cBAAGDgA/hAACAcAAIBXLnIgaQAQ\n", - "AYzz9+hCtZiUtowbXR19/BswuilF0q4H04I8wdDAIHrEeKJFl755IAAAAZVhAUeAEQAicgOvC5v4\n", - "fDgswALAgwLrfI/MqymIAbBfvQBDQgDGoWsAouFZ/C2oqCAAIBSCQgAEZ7oAfs8Qfgy96/AA4XCQ\n", - "NawX0FK3KF/37BcIPC3DAAgMwJ+0rkHyVQA/9/cAQroTIWpFJOhOgv7gMwkJpLzQ0LdFZIAj/8GC\n", - "KABwaWsFxRuPco8IAAQDwAcHnQgABAWAAIAoc1idEUTKNRIkIvg29ZuQuX8AN9VAQKXdweB3MvGg\n", - "fKpJEpEkQYaN8TPx8OQAaog9REqSm+Ag2gkh+SlNC/ACAh+KduG1pgTHjgT4EEUQojIOkJi2XR/7\n", - "RAmMNjEILSPVf/OBcREJWZhy1j7u/vDCAAjhBEChKABegXEnRsVrWKZf0DWMtLe94U2bQBvfnUWR\n", - "kvW5v82r8Nw9yiD1ESpKb4CDaCSH5KU0L94Ah+KdeH1pgTHjgR4QCGcQUrWWS2wl3/7xARDCMxJC\n", - "O0sseZ0Ah2OiekYvlBWP+BAAHgYauE5VRppbG3/rf6AY942YGbSrZXb7wbjDd6ns7yQAAAMSYQGz\n", - "gBEAInIDrzG//7wXcAMGqoAARKzsDA+AAICIAAgKTFAAaCDYEAASHLcEAAIDIABAEDPACrCTKoB8\n", - "qvcAFYLg7UkFSAAhPzeG+AIznwtKIIUMDHhYWAAd+BqUBjUKQAW+IT+FQJQwhAAFAQ00IAAQHwAB\n", - "ADAcPYIXHh0Tkgi71+BEA2KJSIGULrtAO7BhBghgmheAAkBEM6uAeaPBMakgJcGRFWAnyrjbErbx\n", - "DYhdP0oFUMXc8aEA7284GKLn/lHEw/AFgo/rq1FO0AKUAj8pQABMAAQG1gAdkjKHN5bAwgADYGNM\n", - "CAAKAv9AA/HntZTAjTiu0C0Tp9qcReJaAB9fpIw7IfQFhkFlixDfmCM1VtoP9EDAT4KBvhjW1D0l\n", - "+3AQJzKdRYyNm7kS//cQAxhJWtOaVPWAUKQMf/2gF2grR8Hss/MIft4wxvEdBhBjog/NQb5InAgG\n", - "FsLEqJ2Dakdwor5gYGYAAIAwAOCiaZWMYcjqvfeYCcrpmEBIUoQAB8AsRgAMeobrwyEbl7fcHRkz\n", - "TglA+q+v6IPSfpQJ4U6HSGAU2kLE9PQR4k3kEf9AsgEQTYAAgFiMxoSECnxt4wiBSSQthjir40W7\n", - "PAwwgARGsCAAEAoAOCjcYhmQIBsM/B08onsJCwftOf8M/AyqQFHPhOirydgCVKDD4AxWtHd6ePdS\n", - "Gch+/iKGGEACK1oQAAgFABgUaz7PBGUKE1+7/6ISZROC4EUhIRUH3/CBvQf4QQcgSAEAJTCx+cEl\n", - "lDZ9I2IPgAOIWkwjTVJWdw5//vCGdBlJami0GKJ/0MIATWBAACAAAUc/BHgb30OLoQi90BcXyFZ1\n", - "R2RSeUEDEVhQQg8IblaSWWzgpC0AHzAJQE/QzaDiLmyjgIFwCqgMHECMVpEg3ekAu/7SWCwAKr/k\n", - "A0CtoCx/eAzAEUAjpzNiZUnIaxLNAwdgpdhyFeiommjN39LaNOEwl3AhiAACAqAAsICQAAQJAAI1\n", - "wXITdCBCwFXf34YzFcrMYOWB+93yAIsNiJGAIyc3gbPcg65wEABVz3kgAAAB3WEAh+AEQAicgOvC\n", - "5v6e0cOcABDYFFEN6XvV0EajoJCT4zITLcIs0RBQi34GK2pb0BDipWpgac+AfFEU9OPbelS6sgww\n", - "gARBDIQABEIOfgAmYtToTOanoMJgIaXfgTe+gAfwyaj8ykus9BhDAEGspPAvN9NFk9Rx8NwAEAgr\n", - "Z7pIFUfBPUqLinyE4zUA5Fbab3AAX5B9qAAwL8qS4sfcYFjHfrIwABABC1gu15LwP++aUhDg9v3j\n", - "4XMU5D33hjLecJSMubWFUC5Si8MIABAonIQABMBwlW0eeC0IpVzL0HekOyUVsr9+0PFkC0OtUpt/\n", - "B5s4O6cKTJ/vDRv/4TQc8ABopxxKxZKHxNKsTJfjMAMClxiDxwA5VltIDvywv4oGjm5og38EAATD\n", - "GGhAACAEAcEmIFR+Vvp/0C2PTMggfpBj/6AsbISKV+hGd+A2r8MQ0OEc1hrtgoYWgAvYRhKohzlK\n", - "M9/AOBdChhX9xfoxxqYA/cGcJ+HlBQv7loQAbh+ABUA7WiGodCEJ3NEJjr4SgO3oYIF4K9JCgGIs\n", - "hAACAgABANFQgABAjAAEAcACAKalxgiHaQItz//+0gYT62d9QAT/338x7jGlhiMNGyBcgHwIZB8Z\n", - "QSv8NFC8VCMGSAAAAYdhAKLgBEAInIDrwub/+EIcwAHAStQH/OWgK868J/94gAYMYtEVo0E6TIUN\n", - "L4ELAPtiraxDoQ6KV7iGETAQ4FCUAF2Kiu5+L0R/1Bwuh0KJa1HIAOybZEmGcgSg0KIlUTUpjXcN\n", - "hb4AMTi8KIcGqPMP9DDDgGoAX1g0JoHbiERZ1wn3gIBe0baFXqiXKIeUQZ/AQxJRqKSO6RNTeH3P\n", - "o6wRgT9mvmjYA7yAt4KgAcRHO0cgPiXSTZ68jBqs/aOvfy8fQQAAgCgCgAkGQgACIUAoJWA1PaYo\n", - "aRY2t+B1SAsTAdgCWZ9+MIarTpw8KTE2noPgohoADgCRu2KfAVqlgMNmDPzEvw3AFhkFc1Zx6igt\n", - "JthLzCIO97DjnFjU1FETAk/TBmAAPgaAQloKua4JSUL63fPIbIt2IURP+8AAa2lHDKkfID+qrYc/\n", - "sWwADHfqzwAnDIcCAALAylBAAEw4APB8oVgzdbs8DAIrlPVWBAYUZPpsA6fAGC4wwv14GyApxM5U\n", - "ABpdAeSAAAABKGEAveAEQAicgOvC7wIMNYACZZQ07oUkcxYZ0wBibW0Z/8GQQCvASFKB/kkFvmxE\n", - "UGxjRQbxgj1ru+EUAiAAeBD0CIrJEib2iP//8QNmDhrm06fC30BZS2BM2t+eDA4QAAgNAACAAAoa\n", - "CAAEJkAAQfQABA/ABnWHSzkHWE9Ji27+BeAoAFgASjG4F/cYBboTG/sB1WL9WGzVQG+IYAh8ABBi\n", - "tptKIIUMDHhYWAAd+BnDjrzjcV1YIrSUR7PAw670cqKzw2omAjRdngDFa0I708eGhH5pEGoaOy8l\n", - "b0t4gRRCynDVsplmXnWYzu7tmUvW4D4PYQAAgBgHDSoQAAgnAACBkAAgDAAHpdqYAFQI1p70HkWf\n", - "YARAx62MXqABdg+mVBwv2ponvwdQAAAACmHgBIAJHIDrwbwAAAFuYQb4ASACRyA68MGERcRdx4wx\n", - "sACMKZJyMDGpYd6YAAQEAABAUmJAA4aN4YWr7b4DgIxrpb5gHAACH9j/wAHQUB4ICyaxYRhGHJ5/\n", - "p61Xjn9sICQBBgQAB0BwA8FQA1DuqcB9LBhFAfrcENsd4AJB4Cy1BBKgAIS0GA/GLgyE1ywPCFAY\n", - "alhfAAWEBX3BQcoVE70yxLswACRwAUEBN5ItMiNyBReV/W/0AQw1nYJSuTWLnqExBOBNhACZ0gB2\n", - "cj0Kn6GR76k+gATFBbgi1lY2z+br6fLv+mYTDwSfw398AFv0AJNgqT05h+Geqx2UFlPDMQb8AMoU\n", - "pRhoAQtB+lAfF5M0BgX7YSDJ3ELCyeWvEEAx4dySCHPhC5JH97QgvDnol+FgRlJzIs8Io0G9ZUFh\n", - "3+8HWgQAAgAAMCSoQAAgLAAQNf6i7Twf95YCnw8kUthAR6nP/z8AZ4HIeGEFPuABc2PfqwKWwSBi\n", - "fkk3/eSAAAABiGEDbgBIAJHIDrwub/+MIc8ABI84S9kKeMYv+L5KZtJ/ARQFcKriEuHx+l8KmECi\n", - "YSk4AZ6t6Q6IRIUrGz3AAmjPhEznUhLBgFwYwtAA7GEQtADwpbAABAWAGLB7KDWhLf3sWS/ASIhT\n", - "0pIoCaKbb64AAgfoRwlNcQUcpgQSf3Pg5gqPeY8gWvcMEAAUIhZfxUKawGBoAM7gmoIuhLVUUmcE\n", - "X/wQAAgAAEAaPhFAAICYEdkZShfsvibB4gCRIiOV0OAAICd94AE6BN1ICHBDFvGg7bNhwAIBhjpw\n", - "o88NG+0/9As+DcKWm1PECSGxKmw/eGAXQOqOS5yRMv4IAIrGhAACACAQJIQRNQ1wruaM7f4YJgKh\n", - "IKq4yXaDN+/YKBOFuE6E4ACoidAAEBQAAQUXueDFaWeW0a71cuu66v4OUB+AxzLBtqYTE9zyGHAJ\n", - "H6g//4p4QAAgAgFEshAACBcAAIBwBQQ4/ImwKQ4KoSMhrcoV2vQCGx67WAfc0SDaINn+8F2Qv36K\n", - "U55IAAABbGEBR4ASACRyA68Lm+Kn5vw5AAsZCHpCVQF0U031ysOqQJRJpQNQNYBzH8ERzz3lCF7w\n", - "AB2jy8sU0ra9u/N6cYaTwjt///tmuheUlR/+9/4QABgCjHQlNQAHAByN2zqhgdw57JIpyjNvrcAR\n", - "/W2bD+AsQYhb5nFDXMpSRjlD7Q01smmwegIFQ35GtRd51of/cAIArDgFXG5KgFa98OgCARScAtwh\n", - "MsHcbaP8AQroTIWpFJOhOgv4IAAQAAGDSYSyJlS2Z83n2AjkAP/4gghqPz7w4BKG+3xF4aOvCgWC\n", - "3xgiClluGLYTLsvOM7oZry099wCOgAuIcH2aZ60ADAF/uEgIAc7uULmIsiIPS7/+4PBpQAMEIMKm\n", - "EQIZhh3gEPT0iBqX6tcbyBuomHSGLOIHepURtSln7+oqSSqjAgBOxALAAEAUAUFDmrBYKfCN33gb\n", - "eAiiZsJ0a4e8DaHZQXBWLkt9eBTDgbtWUDhOTyQAAAKxYQGzgBIAJHIDry8OeAM6AAICAAAgJRAA\n", - "GAACAPecEF3YIAAuDHH8AOMyAoK/q4AegnEeD4nBAqsMsMcxesAARK9vKcAeZOWABcYAGigDXwFl\n", - "s2PV70WQIiyhFEmoaWAFQgABAHCByIQAAgrAAKAAeKYgpGAYcrtQMhE71gB9A4tfYfAMVpQCBp2b\n", - "agFSZgYFOkVRcBDIErrg8KG7jmyAAEAMFqCjB+cOq7v/rlbXy9//1ZC9DVKuP++eEOF6ANAMABDM\n", - "cIUvhJdskCGRL/l8AGJZnCH/05YE7jIjJkAgywJBaAA8H6xHPJ60TPBvSnf7oAyLyEv/fQHsy4ZO\n", - "QXEJwQHC0ABBMwu3pYbKP94MCwfDACDAxG8X7/CGBNkv629hqUWUrS5wYgbn6KYVoy+m3ISD//+8\n", - "oL80UsJBVutpU/UaemAAIle45CAAMAYW3yF6F6D8UUFfJWDwtBw7CdSwS7z36c40eeHIAAQgHkuA\n", - "bELEhd4jhrAGCKEJIC2WCQ186LSwG8MISMggACAUgmOKQHhFtvw9AQqwV8uUbfpmwrnYAAgIyAAC\n", - "AkABsQABAHX+v+AjAWAtWOzOCDPYR4gAlDiBPeebanzXgJeDLHggADRQMkIAAQMwCABZB2JMAkCO\n", - "tK1rBa4AhYLaW/3CAgrANTFVtpaHjHpABWoSABo0ESuf+Cierffx/8//0SITSImv/79/4Q4X8ABB\n", - "jTlr474zhM22ugMIFI8gvgT5h+CB518JTQQkJ4KK8NWNHKumU6+PfqnqigBFZIad0FVXuoEI4IAg\n", - "C0AQMHVhQ9VbWUfIcZTD8gGAAcQdS81NAPWanhae21QkIaEMbQEPwAEAAyjFbGqApkTXohHsXgwi\n", - "QIwQAJ1emkcRjcpLfvrqTh5UH7wVcAAj7lCJw2fdTZNBo6N95IAAAAFvYQCH4ASACRyA68LifN/m\n", - "wv8N8AC2DY42tQgpI5V/8AUeETCFm4cpI67/4BQBjKbyLNE1YYY4J//uGAyAVjfsNjTrW+/9dsw/\n", - "RUrSm+5psKLDckKKv//BAARgkiBZIAD0MkJc9wUybBgbMFhMGTWvYrf68Eea9b8BuuyqLw1CQ0L+\n", - "AAgMc4axZrr6yyBk90qABqgbwiIQpQ7vt4BGBpaob5RM8Ov7z3IAQoQF0PLXQJmHMF6L4QfAAECa\n", - "DJN4HgCtYLnAgJSkCAAEEsAAQLgACAEYIvnfzgC5g6wqcoog9p/oAGPcvmavEQY5s6Gy2S0ClYXW\n", - "Gj4WgKXA9DL4v5YbI3wuZf/3hKA7ehggXgr0kKAYizwIBTQ9w+/GBoLCRJJQyvGLgvJAJ2SZNCIR\n", - "N/kEHM7td9+D8IRAvSXOGVSonQnXpQwgADIFEshAAHwHCSeSM6/UDS5irvr31q/36/Fhix95IYoh\n", - "6/77fT15T/dvJAAAAfNhAKLgBIAJHIDrwvIGwvgAOPf+sDvUNMDwnIH/fBexF4HPb6XB2xAM1mgB\n", - "mMHFZwRohOhR//3o6zjGAAQJpGUVB5jpFKcggADIEe4IAAQCgA4tqAD/SQwi5QCQgTkRm6CnDuU/\n", - "/QARASME+cZLSCC0zAYAE5ocfiH/b2MGhb4AOAA4qlqsEOHwFInNgA096ZNifIVHZLBhmn9o/ujj\n", - "IAAhCG714awAbeQJcsMb8oQ8K3sAELwSQWC0Ufn6woZFsbFt+X54DTBsTzAWYCfVu4wXdeRuCUpo\n", - "wqdBAACAIAIEEAgABAPABwBQaowuaRs4cBC/tg8TIRGUgx1DpD9nADKtAvvC+srv/8PrIwsQBspk\n", - "OiNo6DDUqC/4R6WXDV0Gb7wbQHXYhqiKbOCD/74IVhR5TRjvFyy7ri8MImRlwMcXDrHiUQxfzZbH\n", - "5ZrY976/DwcG+AAMHeQZsqAm1d8KAJf9mAGSLJ/X/+60iAEEpQK8JKrmCYWveDcGSdGR2h4xK4EK\n", - "341QNVTjyjAAEDkyLw4Jd4s4TAQMEkT8EJDbN6tY+0xwTCkcYcAUB/AJO9qhqgm5hu4Rrg1VPVUC\n", - "AAEBEACgGhUIAAwBAHD2scPMoVyGzAANP5qM3gAbMzgBdsPBMESzCuOSEAxe/aHdXASm2M+Qf+8k\n", - "AAABdmEAveAEgAkcgOvC+NC+BM3G+Fgl8lNtJnoCYM4S6NKAUD++GQ2X/kZCKymOhRkrUkCiwguU\n", - "kEvj5sgPmhspM9wAHjQ1ZWMcI/VH2QCcWFoAmEati3LBEW1G9EAT8DKFahGCEqLCENTUT8ACHTGR\n", - "uOBWDZgoABP3A0KUzilPsMX/MV/cCZT0FC+1Td4FU8G8FwL3B9hBR0pJe5UkHLwABABQOoIN88Il\n", - "IWQv//xMNQBaS2EAAigGhkI/wQAAgdgACBC94QAAgwAACCIAAkDIGgACAALH3DsGOegn+B49mCoj\n", - "S9BYvP88AD4ZK6s6i5qD+D4wL0B5bwa0PYDIqVgw2Yxw4AHAI/wwGwM0kETLeFLGs7f/69+t3Hee\n", - "MGQUgkKYXwgRGyjh2+Hrvu0wClKmeACcWwlW9zDawGDwHAEKeTLYQABsDsYEAAIFwAAgJAs2DvP3\n", - "gAI3K8dFszAAEAR9e+wsZRK5WABZPg7wbi4ZyCCqAAWp5vB1AAAACmHgBMAJnIDrwbwAAAERYQb4\n", - "ATACZyA68MGEViL+HxsAVA7hzqJflKx2ERXQfAIISllAWte9hNz8VkHhjLecJWMubWFUSxSiMEhp\n", - "LeHDDAAQEKaMWyh5tVZN0l50MITG4QJSqAMqOQJEu/0GZfXI9b8AJPD1wJUruwYFXX1drw0hEEM8\n", - "K5ge6AFiEtY+1Jx+ABcMT3sTSjRCvuv/37BMGcLdAJAG+EgUrqtuAHgBOgFZgAVXuACDRMgnZErn\n", - "AID6BlNLFkcuLPgNAG/gAxZdRBzl8LBnA3GLjohJJiIxIzIBgL4PFcQWgQN6ImigMIAAQCwA4JMh\n", - "AAEgwprCCS5J/gmAEn3jOujdVe/ugAGBTRrknAs1YNywOYKQUzNd/V5IAAAAg2EDbgBMAJnIDrwu\n", - "HcABEZgACAGiKoBAgiRoQIEf/4ADgDtMAVUd0KAXr3ugGKTaJClIJJUJ1eCAAJhiCQD8ACwzDmTJ\n", - "d/PM8KdwEQ1mf8ZS+BAg5hgThvwAx1s7AQcooWJau/8HwOwLE1cHeZcE4MILKW4GCpLWs/1HX7nj\n", - "DQhcQoZIAAAAqGEBR4ATACZyA68LifE8NG//4QXYACYmHaniDlFj+rMJ+DAQ7xzo6jU8LCRGwIQS\n", - "kwhIj4AGMUtkQb5DcACnmk2JjnzDYQBSFoADgACAEDSX0mAbFAXxLJ0G8ACCGwBNrL4gtqVJI+AF\n", - "KcAq5zYUArn/B/QCGamJMDbJpUJi/vHxBhAYcIARSSRCRAA8TBwmnEa6UYNW67bw1oP14AzB6eN+\n", - "q/v/07fnkgAAAYdhAbOAEwAmcgOvK8EPWCmGPAQAACAhMAAIK4AAgW75jwACwAoOMpgAOGpwEPQr\n", - "gDfAEqeiohAvCAALmBlhAACBMAcA8lgBwGZlYrpXgQltAA+Bl2EWWwAe4AEjinuPGLerwEABwWoY\n", - "0ARoE/qhLbjeIAJkIAAICAAFQQ4X8AC4ZEHUlii/KHvf5AUQt/KNMUhp/BL3/QxAWsAB8qY0T9k/\n", - "Lp9i7HjFOQJHobx+5DRAQiYb6GK95ZIm+o6GKnn6AUZ43KoOrlG8Mc/7iDCAE5hAN8OB/miEqmGE\n", - "U779DeYrl+IOvwrgDIMaSzwiJKQioYi19h+TMTM5zhBvtbJO8D4FhknACFgQ3gE/Uj/BhhAAEChE\n", - "hAACAmDAWsDi2yY8ynLeKYGkzFi6D3+CzD1iiVGJFoHOgjA/40A2w/mkNL/DncMILDLJ4AE9XvSn\n", - "pL5JYOOGYARlTWnjiYE1KiWmACAE8OA2GIhGikEZ1ml56vBEiIIKMQYEVOwvO6v+AK5xjWIfCkfz\n", - "+lJAAAAA32EAh+AEwAmcgOvC/DWABbEdRloakpBY5//ICjNmhUBVpUd45//gguzsAC45iXUgWLkx\n", - "34eGPPL5QQ4oYSFvABsE4om2j6kmjEQd/9bbw1KLKVpc4YEOSUTInPZ9GaH/+55BfmilhIcveAGo\n", - "Awi8UB9LTXNDsDQm8cAAhzO554HhDkiLX/+8ARDCagA9lJA0gAw9dANfOAAEAABga+dpqIgSlRWK\n", - "T+EAAbA5pYQAAgFABgkjhCsNgGR3neF/oMECJa+xJRuG8Z77RO6BgXCHn86AyC3k14aP4QUNdN+m\n", - "8kAAAACHYQCi4ATACZyA68LifE8NIMCBMNQAVUw1IJSVocAUQNOSwCytnW6ECA9vGUgQAmKQK04A\n", - "HzISxa4PArZ/vwAbGyeTvTf//l6FfhbxmwC6/hmrqYr/+DBDsUACvCzlHtxRAtFjeRbyWNCFrmIB\n", - "YEh4cMFBJR15eKw6qQ7Ad4MmkzuO++gVdXJAAAABIWEAveAEwAmcgOvC5fwQ8RC/gAJkQyuhjIUd\n", - "KlJ8IZsPlkXOQtPf/2g7iZz9jFMCSJhEzKygAHc0wQ+xiO9ABm2/lZ//gTMLiwqBL1r5VfYEAPBa\n", - "AA+JOnAQ90CVFpDAP2MEKODCwfhRpFgj9Ep+DwIQko1wXn3huY5f/mAFARWUGKUoeP1XTCFVwAg7\n", - "Gt1IXdmxer7aDHp+GvXpscDTP94IAAQKgABAMA0XCAAEEkAAQLQAOAsABMwM4jn/jGLcYHwBUP1r\n", - "sZCHkXFQXD0D4NgaRJJJq3KfuB6xAWRzS/SuwQ7EBqbw2Yf/+gWwAG1mhK0VhXa3wSDlJIYL1/JJ\n", - "dptf7zcU24I0J/xaRPYtEQIk2hwBIZPBV8Tf/AiHUf8+8HUAAAAKYeAFAAocgOvBvAAAAGdhBvgB\n", - "QAKHIDrwvw1s4AFoZ0GUlqS0GDnf8CtHsADRviCRz8hDlJUJHNvYOIOYZgBm3xiX/WwfABFCaURT\n", - "QiZVgzEG//W1sJSiShaXAgARWtADgzCHWzch3GHkGHMV+0X+B/DQjz8kAAAAqGEDbgBQAKHIDrwu\n", - "J8Tw2aoBhiZ/DcABy4HoZfF/LDZG+FzL/+8EoDmzkYD8Zm4ERrp4EAp4e4ffj4GigSJPHK8YuC8n\n", - "lhTJoRoUOWHNphJT4kKal+uWQWoqVITfeGIt7Hoo6FtXAKP+ADHWSrIOO4IxhvZUCwABATAA4QAA\n", - "gCgCi2wANRni9KBpIYpeBsgeEsbBa+C1vrwAOYMWPvJCoqIeXwi3oVHkgAAAADthAUeAFAAocgOv\n", - "DHDMABx85YxgTTlJH2f/aME5xtYlBSR6T/4H4QLu6AB6ESFla4KXFg/hy7f8NH8/JAAAArFhAbOA\n", - "FAAocgOvNHwx4ADjOLDaUQUHBjoqJQEv/vwNTgIahSAC3T12g0CPRqBOIkUvs6Kap4j4CAAIBiSw\n", - "gABAXAAcDhbAAubSaChwBbCizgc4GqUAAQDpgAWesABwxnSstiR8ywCFgpc9EwE4A1kS/AABBptM\n", - "AAoS/4R4b4CiMpjlCgOfNdbDJJNBhAAI7nBAACAcADA8/gUVKBwQJk689+ArBokHWkKuZApWdCUM\n", - "IIHrwv4ACZCFb+EHKLG9WYT6GBjEjnR1GrWEiEKiO/wABwAAgMagAjFC6na7bA0IAAiEKLmHIAxE\n", - "AyShTP30Aj30X0gYwAItijJDxSvDUweILWXjgAIACG64dyQOaDBdDX/8HLAAECmWUAAQPgABAbiA\n", - "AIPugQwwIHdyeZNlBVWfv6v8KgBhwMQAGBwCex7hvIJ/mDpUcoANwKSZ9eRs4N5h/8wdqUHtAOsJ\n", - "X08TSCsap4GL6kmFhe/bH5DvMN8PwBitWEdsePZ8LtZR7Y0zwAEMPFa0tvhUi8v4PwgATirCAAEA\n", - "gAQEFAZWwIpQGaNa76lbwAa5QADgWf+f+hKmVgBxkWgfUHBi7rYPGQAAQDiEkAACB9CYAx4eFYZ+\n", - "BAx0gXNVNVUosWEmFQYcIAmMYIAAQAwDhZOSgRoQBFCGDP/pQYu6GlbkQbSmJW3/CFQ9gBibvsz+\n", - "iIAAQAShZ044owcpX/ff4AFsR3GWhqykFjH/8gKM2aFQFWlR3jn/+hgVYQXRYGx4Rl5mrEE7+gov\n", - "h5zVyLoD+GdaUL7TUkly2iVEYWgAsDMAFC3qbScQfdvv4AMgTDH28fMowYiDv/qH4blFlLUmcMCH\n", - "JKJkTns+jND//c8gvzRSwkOXgwwlgAwcNbWoVPqFjKHVJIt+rRBqdMg7T1vfuTERmGPpvrdEmNY/\n", - "kgAAAE9hAIfgBQAKHIDrwuJ8Tw2G8ABAYrGsOOPaxhx5x5//gAPiYdqeIOUWP6sxwBhWR3ySKq+C\n", - "WpUX4cAUKm8ADmyJRssyn34AHNkLR+lVo+8kAAAAuWEAouAFAAocgOvDHC0AD2GAYquJAejsIA4F\n", - "9/u2kABAEG5xhHYw3IA1BZf/ACQimHCBNN5Vs0NRTmVf6JMAAQKVSo4AAgbgACAvUBPwAyEwBalC\n", - "JYP400f4AxHSiAtWKSVCVBf3AGMxEyaFwoklQkL+8AHIYAqp3ZUAvX/h0IAmAAKAkIAAQAwDnngB\n", - "UZgECYcehjgwNBkIAXr9RUlKV14AKvTACgG4U7rQMxh/98G8NH8IKGvQX/kgAAAAiWEAveAFAAoc\n", - "gOvC7wU1yxvToNcOYAIQABlTABBR8drYPmvyNlyafgCICPACW5zkl3e4AIp4+csnWFOFuAAgMUwa\n", - "phD7aiiTZL7YfgEEMoNxXAe1UJWCA3ABGumh/n3ulS8v/Xywbggsc4QARHvAl9vj6tKcMOSbn94A\n", - "yN3YPfvhE0WcC4eLXg6gAAAACmHgBUAKnIDrwbwAAABRYQb4AVACpyA68LwzUVxWQpkJJJaSX/hs\n", - "3/xwwW8ABCZa49CJysTTEOl/DAAwQqR/0FWRjqprvggJClAFwAJ41gtdFBREg8AC5mJJHVLdH3kg\n", - "AAAAbmEDbgBUAKnIDrwxwzAAQAZAAZq0ueNrK8hAfGfwABuAlA+OkcLkv7Hj8Ah8QRBHCD5hLHhQ\n", - "tP1BbhZBgACAK3sLAAWAVtFd+CAAEAUAUNKhACc5wAL2DrbgGoIwwf8+D+ADlB3kgbcX9A/hs/JA\n", - "AAAADmEBR4AVACpyA68MCeH4AAADFGEBs4AVACpyA68vDngDCgACAjZAABBaAAECu84ImZBAAIRx\n", - "PAD/BqYxRevcAHxgGzgIUPKuGPV7ghDfPAAESuAMAAAgJgACAnEQABYfIEACKxgQAAgEABASZxFT\n", - "AYFdOb8H8GOtgMiHGM6ONfYwahYMcAB0wYAuJDtjFxTA5bFHvRZgirKEUQaOgroAv9EUAAIBelAB\n", - "XIw4A8Fff3hAAQGePCAAEA8AAQIwcD2ABmRaoLCg/J4pTJXG9pmuLOYASRHQHTxYImTAW+C9z6xA\n", - "ci5OBaxgfyYtghwvgAJZiio3WFKZi9NgLEKAW4AqJmE36AogptjXAtxCktK5he1Q/gMImmBIlAB/\n", - "iLEL2hjkcUyZM/79Qkc2gFXGCcgtKacsPQ/C3uvIrPSd6mjSG3Uis68AAKQFwoIIo4a1roDt3x9v\n", - "ZttvSDMAFKoG3YJPD+YgzeRRwkjqU8c5T0pjsAAkAAIBUzIABwABUQQABcHa0IAAsGe/CzB/rmwB\n", - "Ah2/8HykQn/bDMSa8OLMxGJvowngSFhsjwkjxHDWAvhBYMNCycRBMzGDz/oYSmggCcx4OuYux4xT\n", - "n4LQBFMBWHhGWXDn6gSMMzAABARAAEBQADQABAJlgBYZhyGpMEkxtDhyUu8MICQhAgADoCjXXdsC\n", - "YEU2/7hAYigayE07bSn5hPb/6DX5EBH1JQesVEr06xLpAFXAwS7OYgTHLV534P9BEGQR2YYUPfjf\n", - "/d/wgR/eEAAWADHAqtIpQRYlBV7vifmPqXu/h4HGdAW8kBpANNT3EIgjkYQcooZxRbwwguNC/wAL\n", - "QzIOpLEEpKGuf5AgAPAzWJ4oGl5FAQKX2zDcBhohTPOQMX7BmEJcEJCeAuUjDZF7N1LPpLVegUAD\n", - "3BWH6HxOEEviOUI4W5hbr/6gBQIP4daExv5NOxMu7w/YTgoGTYRgqWE4nTEAc+pi+nMpRpUtLIAA\n", - "QKdgABA7AAEBsBfqbwZxzS2+We8sT9NP4QUIQIAAgMGkZaSLgDOZ37vGcACq4xvveCIh7LCgy4tf\n", - "dBXaOFUAcgeb9u8kAAAADmEAh+AFQAqcgOvBmfkgAAAAbWEAouAFQAqcgOvDAnhs3/FhDwWwAHYI\n", - "PfschyRbJJZ+8Ax2RTT/HXJhTiMjh4bAAvhicWJWqq8S//vCAZhAbPccnxJ//kVwhAACAIAIGlQg\n", - "CY58AD5PsAAQAYAZaAM98/ABYIo85NSqWYP/eSAAAABsYQC94AVACpyA68McMwAHEoYISZcSaUJC\n", - "prwV+8WIig4NZ7TfQVHcVpDDCAE5zgOgA+IUHrKPGw3aD+AE253Gf/rYfw1w5gAigAFkOAFFnhyp\n", - "i/afJStpuADgH4ATdrW2u73ABCGytbjdEcHUAAAACmHgBYALHIDrwbwAAAB5YQb4AWACxyA68McL\n", - "cABDYOKIb0veroI1HQSEvbACWHACCz45SuftduBlFx9QcMHHkzYSAT/vA6FHVpLArB9bM2B2FUMM\n", - "IAIglkIAAgEHvgAmYpToTOangwYTAQ0u/Am994AH8Mmo/MpLrPBgwhgEGkpPAvN94bOskAAAAA5h\n", - "A24AWACxyA68MCeH4AAAAHRhAUeAFgAscgOvC/DmABYyEPSEqgLoppvqBCw7giOea8gUvBCRG8AB\n", - "2FbDk8YW4gjhLwzZ4bgQsOsQJTzXikF95nFDXMpSRjl8AAO1wP5YppOz9v/Af7Q01smmwQABYGPP\n", - "CWl4YDU9JGQDKFE9fgo7IYMPwAAAAcFhAbOAFgAscgOvLgh+HPAAQZz4WlEEKGBjwsLAAOwgBMY4\n", - "QAAgCAChpTKaAAlyV02AD4MdgX9gAEmQZ604nUKAO4GSfwx/A1KAxqFIALfEJ/CoE4YQ8AZ0AAQE\n", - "AABAUiAAOAAEAe84xesAARK9ggADRQOgIAAQMwGACn/fbZYw0uJfB8SdUALuvfBMq2YY1AgdoZuK\n", - "geAr0EFgAIS9XghwvgAPxDRXyUhDu3vFvCgXvINc4Wt9wNimKaIAuCGWn4+IC0uAD6MVUmenOQHs\n", - "y4xdjoxYQtMOtL1Ag4bgTLEzhJcW4UitsAuZY1rIQ1YxN2GEtJD78FEh1UIbH/xB1zfSP+gWfgYd\n", - "d6OVFZ4b0TARouyGEF2cIAAyBBLHK+xfhklke9/4E5EvQCqpQDXBpnDqDjCvwBitaO708e6kM5D9\n", - "/EUMOAMEUISQFssEhr50WlgN52AAICMgAAgJAAbEAAQB1/oPwgACZA6AgABAYAUBDtXhrVC2lo52\n", - "7YIBrx/4YkEgcpZIYs8WTKKXGQwwaBGw+/wgsFPL5uD7hmwYEt3LsABgXZ2g32oAJWBMsLhvAslw\n", - "r9IPWHz/gBhSD1hTG/f8kAAAAK5hAIfgBYALHIDrwxw3wAEBimDVMIfbUUSbJfbDXAl9vj8AZG7s\n", - "HvDRv5/8FmABiAAMrDABBR8drYPmv3gWwUFmu3TuCFxebHfgrTCJkcACXxaliFrQ0OABTPC3PGPy\n", - "QSH4Z6Agb6YQDEQsvsLC8ACegGTTXrTxAAAgVAACFKAAIPrLwIJR+HEcGsmT9CompCAAJhyywgAD\n", - "IFEs49swJdThvCa/+NmxjfUvOWC6/5IAAAAOYQCi4AWACxyA68GZ+SAAAAB7YQC94AWACxyA68MD\n", - "enQb4WgA1RB6iJUlN8BBtBJD8lKaF+AUAgqHFbQ/k2CsDAO//uEAhCCiECI9l3Iy//tECYw2MQgt\n", - "I9N/84FzEjnBMOWkfd/94YQACOEkQIJAAfoFxNGxWtYpf68DWMtLa94UubeAXvOQS+xdvB1AAAAA\n", - "CmHgBcALnIDrwbwAAAAUYQb4AXAC5yA68MBTISSS0kv/D8AAAABbYQNuAFwAucgOvDHDcABwCIF0\n", - "p1sHyKsGIA7/7RCMgykMSWgse//nCAhiCiJEY7LozS//3Ajd4RARaVnePf/4IAA8Aw10JaWABYDo\n", - "fY06Es85Y934A0bcjk3h+AAAAA9hAUeAFwAucgOvC4nxPD8AAAEnYQGzgBcALnIDrzPCogOYACul\n", - "e2lPvM3VOCeBYLdZ68zggJSkCAAPgIOd4ATCsHWUY8T6vbCAB8MAqPAooOkrQs9Xpv/cdaDsOGAA\n", - "gzjiU6cw3L3lnhw7/Azhx1ZxuK6sEV5KI9wYQAgAygeEAAIAQAAgqhYAhgvxeGFDYtFlvANtj7Uo\n", - "bQKRwJwtQKVYXMwAhII3VwCkyrUARR/Chu4FPgNG+Ef9As+HhBYOPC/REEzNKq/0MJTQQBOY8HWm\n", - "LsfMU5+C0ARTAVh4Vllw5+YO3/0GoL4AwrCFGKPOnOoCxB/D8AMVJZF2EQuSLpD6q4MOEEAvBIQA\n", - "BkAAQLBIGIaCOUAjRbi2s/xvXHNB/Q/9LmFgBQibwFURsbvsYmZgY7jAcOBlmn+FYAAAABFhAIfg\n", - "BcALnIDrwwJ4aP5+SAAAAI1hAKLgBcALnIDrwZBvAAQMxzGOY5zHMY5j/wAMQABv64AYUdE40zb4\n", - "egEwAz630O/ACGym9Ie/NAE8P8FcABATgBB7M8bK7BBnAFCcfe0016095CRiEYRwGg/lVcNWfwgj\n", - "hsLVjOCtKZ/QIAAqCmmhAAGQKLbBObRlQRWCHfP3NQN8M0IrBnYEE/Pzy8kAAAAPYQC94AXAC5yA\n", - "68GYjg6gAAAACmHgBgAMHIDrwbwAAAALYQb4AYADByA68G8AAAAOYQNuAGAAwcgOvDAnh+AAAAAM\n", - "YQFHgBgAMHIDrwbwAAAA2GEBs4AYADByA68w3lRlDuAAgAAgWgACAkAODpaWlxcXFxaWlpcXFv//\n", - "AB8AASEABOYAyx5A4ETMggACIQgngAcymoNSGpRVwALwgvsbYzzpezhheG+YvWAAIle3hALkYIAA\n", - "8Aw9/EFIwBhyu1fh8AxWlAIGnZtq8Mn830/9AswFgAYFe4JJowZeOBdyooYSmggAisbAqitiqHhD\n", - "vvwFmIx/jAvFhl3yEPwznYAAgIyAACAkABsQABAHX+v+EFmYIAAuDnnuxJgEgR1pf9wgIKwDUxVb\n", - "aX/CkAAAAAxhAIfgBgAMHIDrwbwAAAAPYQCi4AYADByA68GR/PyQAAAADGEAveAGAAwcgOvA2wAA\n", - "AAph4AZADJyA68G8AAAAC2EG+AGQAycgOvBvAAAADGEDbgBkAMnIDrwbwAAAAAxhAUeAGQAycgOv\n", - "BvAAAADQYQGzgBkAMnIDrzwlDnABUADSAAML/ypu0nD2FbQQAIjG8AKgaxX8LvzgA8gHyzxzHrsd\n", - "OYTYbgPMnLYAOI5uPvksQAQGYGXb0MIACM94QAAgHgA4OPYGoAet5RuFVebH4GAGAARqEIFCvJnc\n", - "fmB4ahKGoCtAAQB6tYlukXEMX4HDhKaCC7PAzjskdV2aL8BwIGRM6UU5Kyfh+GfAE8A55QGLUFtk\n", - "rNPXwYcIATnOEAAIAQBgolpQhKlOIo9YlV9/+BuDgnsqOIkfhhEYPAw4UgAAAAxhAIfgBkAMnIDr\n", - "wbwAAAAMYQCi4AZADJyA68G8AAAADGEAveAGQAycgOvA2wAAAAph4AaADRyA68G8AAAAC2EG+AGg\n", - "A0cgOvBvAAAADGEDbgBoANHIDrwbwAAAAAxhAUeAGgA0cgOvBvAAAADbYQGzgBoANHIDrzxEOdoA\n", - "KNp1xAraCASELwBGNkRnr3ABqGloRRJZB3n9g5hvghgACADigBg4Kv5FBgASOADCQhhFHELA4gs8\n", - "mDoQABwBhr4QAAgegACBCADAcwN4SYoVJCbAVa+/A0XA6/HCHS/a4GNe+8NRENUMGRcuvT93fAWE\n", - "F2eKiyOR+fgoJaw/NI17B78vhsn4Z8sBYC5YzMUF+yn/7iACUOIEd55tqfNdgj4MseCAAJhyywgA\n", - "BAYAAYBAta0wWsAIWDXFun/BwRyACrR4AGjQQK57gvhSAAAADGEAh+AGgA0cgOvBvAAAAAxhAKLg\n", - "BoANHIDrwbwAAAAMYQC94AaADRyA68DbAAAACmHgBsANnIDrwbwAAAALYQb4AbADZyA68G8AAAAM\n", - "YQNuAGwA2cgOvBvAAAAADGEBR4AbADZyA68G8AAAAHNhAbOAGwA2cgOvERMN8AbgACAcAAICkyAB\n", - "QID9hGQLPCAXI2ADuKTOuSr99VcY8wALyAgPdVbzCPah/+D63tEf/54bXhmAKBHGJYg8QUGEGPBU\n", - "6BgEOdBEiIOptnvRnt1vgaVMNUuUxFM78gNEiq+ff4UgAAAADGEAh+AGwA2cgOvBvAAAAAxhAKLg\n", - "BsANnIDrwbwAAAAMYQC94AbADZyA68DbAAAACmHgBwAOHIDrwbwAAAALYQb4AcADhyA68G8AAAAM\n", - "YQNuAHAA4cgOvBvAAAAADGEBR4AcADhyA68G8AAAAbRhAbOAHAA4cgOvPBCw5ghFdzoAOCox75mw\n", - "F9X1gYJGoQACM54QAAgHAA4PPcADn60CgoXV4k9wALMiIcg4bk0Bi4/E72PQY/wQrJbankLFBnws\n", - "LTNpAANgNIAAgMACCdMCBg9qScHE6HGQvqg3PCKYUwXRM4ydIANYIAAQIFAAEAXAgABChBAABBIV\n", - "wTqMdXACWBhfvgN2FXICJPEUCfp+wFFhYWUIwhDoCNgfuWmCEHyUIj/BIZ5gUKj+2YN/7MK+5JFy\n", - "sT+3iwYQ5QQAEZ78PGDQhyic9+BeAX/4GLGlIuFW8MyoNQ3WeAIdTgVKP1EFYKiPjvDCAlIUIAA+\n", - "Aw96CJ2CPCgZZ5wfgcGJvBZLLwIoCYln8Ywr8BFY4KP8EKrfpP35an/IF5Kgzu2iEBh8AmAdFwMX\n", - "Ef1UIoqE54IZRBJA8ZU2cpmiQaWwwwgABANYAF4IAAQZAOAAIBjelJeB3cAV4a+9Q2sAfD6IGpxv\n", - "/ganCzVAq28AIMhkvcbgQSV4AzQxsYg1qBh484Z2MMhgjUmFCEEj//7/8KkggBOc9JJCRiRiHP/g\n", - "wGW04O00fllsf8JwAAAADGEAh+AHAA4cgOvBvAAAAAxhAKLgBwAOHIDrwbwAAAAMYQC94AcADhyA\n", - "68DbAAAACmHgB0AOnIDrwbwAAAALYQb4AdADpyA68G8AAAAMYQNuAHQA6cgOvBvAAAAADGEBR4Ad\n", - "ADpyA68G8AAAAIVhAbOAHQA6cgOvOJ8v/BS4c4ADmTgBEJ4SnQb2JMOf/DbAQCQhQgADgHGtcAHw\n", - "APUOcUqSFnOAA+wGAAIByYrgEBd2lqcosI4ZP5fggfw18YCApKjyB1ocMEz8vm2eoDwiZGEAARCE\n", - "kQJoIJk2xjE6333xiLwNQOBqsqeNnSrShpTDxuE4AAAADGEAh+AHQA6cgOvBvAAAAAxhAKLgB0AO\n", - "nIDrwbwAAAAMYQC94AdADpyA68DbAAAACmHgB4APHIDrwbwAAAALYQb4AeADxyA68G8AAAAMYQNu\n", - "AHgA8cgOvBvAAAAADGEBR4AeADxyA68G8AAAAW1hAbOAHgA8cgOvNw54AzoAAgIAACAlEAAYAAIA\n", - "95wQXdggAC4McfwBamQCFJnNwBCCKI8HmhBPm8N8xesAARK9vCASkIEAAeAYe/iCkYAw5Xavw+AY\n", - "rSgEDTs21fE+X/Ag8MeAA0XUIlhZ2lC1iCoBPsgACRgAQEhN5IsMyNzwgACgENEhAACBKAAICoBg\n", - "IYAVACxRYBcTxxdAi2tlpj2AA4VoAeBLV4HpgFJgrI/XDb0gvKJ5rgxw1gDBFCEkBbLBIa+dFpYD\n", - "eGEJGQQABAKQTHFIDwi234egIVYK+XKNv+Gc7AAEBGQAAQEgANiAAIA6/1/wgszBAAFwc892JMAk\n", - "COtL/uEBBWAamKrbS/8/mMdv/oNQAEyAAwOO3hfm8mPHQkS+MAJIHEjO1MuVTjrdyGH94b/lH9pf\n", - "vJeGHCAEVbQgABACADBRoDaUmQmCPH8+7fv/7/P/QPn4qCRMVxFYdK33KRESE2QiM3hhOAAAAAxh\n", - "AIfgB4APHIDrwbwAAAAMYQCi4AeADxyA68G8AAAADGEAveAHgA8cgOvA2wAAA45tb292AAAAbG12\n", - "aGQAAAAAAAAAAAAAAAAAAAPoAAAYOAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEA\n", - "AAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAACuHRyYWsAAABc\n", - "dGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAYOAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA\n", - "AAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABsAAAASAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAA\n", - "GDgAAAAAAAEAAAAAAjBtZGlhAAAAIG1kaGQAAAAAAAAAAAAAAAAAACgAAAD4AFXEAAAAAAAtaGRs\n", - "cgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAHbbWluZgAAABR2bWhkAAAA\n", - "AQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAABm3N0YmwAAACn\n", - "c3RzZAAAAAAAAAABAAAAl2F2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAABsAEgAEgAAABIAAAA\n", - "AAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY//8AAAAlYXZjQwFCwBX/4QAO\n", - "Z0LAFYyNQNhKQDwiEagBAARozjyAAAAAHHV1aWRraEDyXyRPxbo5pRvPAyPzAAAAAAAAABhzdHRz\n", - "AAAAAAAAAAEAAAAfAAAIAAAAABRzdHNzAAAAAAAAAAEAAAABAAAAHHN0c2MAAAAAAAAAAQAAAAEA\n", - "AAAfAAAAAQAAAJBzdHN6AAAAAAAAAAAAAAAfAAAZ0wAAA3cAAAIqAAACxAAAAbIAAAK6AAAEegAA\n", - "A3AAAASkAAAJ+QAADKgAAAreAAAMdAAAEHgAAA9DAAALUwAADScAAAxsAAAMFQAABnQAAAW2AAAE\n", - "8gAABB0AAAJ8AAABTgAAAUEAAAFMAAAA5AAAAiUAAAD2AAAB3gAAABRzdGNvAAAAAAAAAAEAAAAw\n", - "AAAAYnVkdGEAAABabWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAAAAAAAAAAAAAt\n", - "aWxzdAAAACWpdG9vAAAAHWRhdGEAAAABAAAAAExhdmY1OC40NS4xMDA=\n", - "\">\n", - " Your browser does not support the video tag.\n", - "</video>" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAEACAYAAABWLgY0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAATG0lEQVR4nO3cf5BdZX3H8fc3BGWkdhDJD8gPCWMkxRarrNGObYeW+KM0GIeipUMlpU7TolUZ61Bg7fSPupahU4rairMqlmgszaS0RCtMAcUOzqBurKCGbEkRAyZs1p+lTYFs9ts/7k28CXfZvXvO3Xvz5P2a2bn3POfc83w3OfvZZ5977hOZiSSpTPN6XYAkqXsMeUkqmCEvSQUz5CWpYIa8JBXMkJekgtUS8hFxUkRsiYgdEfFgRPxSRJwcEXdGxEPNxxfU0ZckaebqGsl/ELgjM1cBLwMeBK4C7s7MlcDdzW1J0hyKqh+GioifBe4HzsiWk0XEKHBuZu6JiFOBezLzzEqdSZI6UsdI/gxgHPhkRPxHRHw8Ik4EFmXmHoDm48Ia+pIkdWB+Ted4BfDOzPxKRHyQDqZmImIDsAHgxBNPPGfVqlU1lCRJx45t27Z9PzMXtNtXx3TNYuC+zDy9uf0rNEL+xXQ4XTMwMJAjIyOV6pGkY01EbMvMgXb7Kk/XZObjwKMRcTDAzwO2A1uB9c229cBtVfuSJHWmjukagHcCmyLiOcDDwGU0foFsjoi3AbuAN9fUlyRphmoJ+cz8BtDuT4Xz6ji/JGl26hrJd822bduYP7/vy5y1iYkJzjnnnF6XIalQfZ+e8+fPZ9GiRSxcuJB588pZhWFycpK9e/cyNjbW61IkFeyoSM3SAh5g3rx5LFzoRwckdddRkZylBfxBpX5fkvqHKSNJBSsv5G+8EU47DebNazzeeGNtp/7c5z7HhRdeOKNjV69ezejoaG19S9Js9P0brx258UZ4z3vgyScb23v2NLYBLr+8d3VJUo+UNZL/i7/4acAf9OSTjXZJOgaVNZJ//PHO2mfo7LPP5umnn2bfvn385Cc/4eAiau9///u56KKLDh13ww038NGPfhSAXbt2cf7553P88cezbNky7rzzzko1SNJslBXyixc3pmjatVfwwAMPAI05+Ztuuolbb7217XFXXHEFV1xxBdCYk//Upz7FmWe6hL6k3ilruubP/gxOOOHwthNOaLR3ydDQEENDQ107vyRVUVbIX345XH89nHoqRDQer7++q2+6jo6Ocsopp3Tt/JJUReX15OvUbj35+++/n5e97GU9qmh65557LnfccQcnHPkXxAz1+/cnqf8923ryZc3J98A999zT6xIkaUplTddIkg5jyEtSwQx5SSqYIS9JBTPkJalghrwkFazIkH/kR4/wyuFX8t0ff7fW83ay1LAk9YMiQ/59X3wf2/ZsY/ALg70uRZJ6qriQf+RHj7Bl+xaSZMv2LbWP5iXpaFLcJ17f98X3MZmTAEzmJINfGOTTF3660jlnutSwJPWbokbyB0fx+yf3A7B/cn8to/kHHniAHTt28JGPfITzzjuPHTt2sGPHjsMCfmJiglWrVrFq1Sre/e53c/PNNx/a/tKXvlSpf0maraJG8q2j+IPqGs1P5eAyw4ODg+zYseOwfevXr+9Kn5I0U0WN5Ed2jxwaxR+0f3I/I7tHpnhFdS41LKmf1TaSj4jjgBHge5m5NiJOBv4ROB14BHhLZv6orv7a2fHHO6Y/qIK1a9eydu3aw9p27drF8PBwV/uVpNmqcyT/buDBlu2rgLszcyVwd3O7OPfcc8+s15KXpG6rJeQjYinwm8DHW5rXATc3n98MvKmOviRJM1fXSP4G4Eqg9V3PRZm5B6D5uLCmviRJM1Q55CNiLbA3M7fN8vUbImIkIkbGx8erliNJalHHSP41wBsj4hHgFuDXI+LTwFhEnArQfNzb7sWZOZyZA5k5sGDBghrKkSQdVDnkM/PqzFyamacDFwNfyMzfBbYCB28UXw/cVrUvSVJnunmf/LXAayPiIeC1zW1J0hyqNeQz857MXNt8/oPMPC8zVzYff1hnX+08/PAg4+OfPaxtfPyzPPzw3K9Gedppp815n5J0pKI+8fr857+a0dFLDwX9+PhnGR29lOc//9U9rkySeqOotWsWLLgA2Mjo6KX8+MeXMja2kTPP3Nhsl6RjT1EjeWgE/aJFl/K9732IRYsundOAv/LKKw+tPDk+Pn7o+Vvf+tY5q0GSWhU1kofGFM3Y2EaWLHkXY2MbOemkNZWD/gMf+AAbN24E4OSTT+aHP/whZ599Nps3bz7suOuuu47rrrsOaMzJH7kqpSTNtaJC/uAc/MEpmpNOWsPo6KVAtSmba665hmuuuabtvre//e286lWvcllhSX2pqOmaJ56477A5+AULLuDMMzfyxBP3da3P7du3s2TJkq6dX5KqKGokf8YZQ89oW7Dggq7Oy09MTLBmzZpntO/evbtrfUrSTBU1ku+Fe++9t9clSNKUDHlJKpghL0kFM+QlqWCGvCQVzJCXpIIZ8pJUsKLukz/l3nv5wcTEM9pfOH8+3//lX+5BRZLUW0WN5NsF/LO1S1Lpigp5SdLhDHlJKlhRc/LdMpOlhh966CEuuKCxRs5ll13GgQMHDr3m9ttvZ8WKFXNfuKRjniE/AzNdavjI9eOneo0kzZWipmteOL/976yp2uvgUsOS+llRI/le3CY51VLDktQPihrJ94JLDUvqZ4a8JBXMkJekgh0VIT85OdnrErqi1O9LUv84KkJ+7969xQXi5OQke/fu7XUZkgrX93fXTExMMDY2xtjYWK9L6YoJ19WR1EWVQz4ilgEbgcXAJDCcmR+MiJOBfwROBx4B3pKZP+r0/Oecc07VEiXpmFXHdM0E8CeZ+XPAq4F3RMRZwFXA3Zm5Eri7uS1JmkOVQz4z92Tm15vPnwAeBJYA64Cbm4fdDLypal+SpM7U+sZrRJwOvBz4CrAoM/dA4xcBsHCK12yIiJGIGBkfH6+zHEk65tUW8hHxM8A/AVdk5n/P9HWZOZyZA5k5sGDBgrrKkSRRU8hHxPE0An5TZt7abB6LiFOb+08FvF9QkuZY5ZCPiAA+ATyYmde37NoKrG8+Xw/cVrUvSVJn6rhP/jXAW4FvRsQ3mm3XANcCmyPibcAu4M019CVJ6kDlkM/Me4GYYvd5Vc8vSZq9o2JZA0nS7BjyklQwQ16SCmbIS1LBDHlJKpghL0kFM+QlqWCGvCQVzJCXpIIZ8pJUMENekgpmyEtSwQx5SSqYIS9JBTPkJalghrwkFcyQl6SCGfKSVDBDXpIKZshLUsEMeUkqmCEvSQUz5CWpYIa8JBXMkJekghnyklQwQ16SCja/2x1ExBuADwLHAR/PzGu73Wc3LP7ylxnbv/8Z7YuOP57HX/OaHlTUtGkTDA7Crl2wfDkMDcEll/SuHkkALL77bsaOO67j180DDpx7bm11dHUkHxHHAX8H/AZwFvA7EXFWN/vslnYB/2ztc2LTJtiwAb77XchsPG7Y0GiX1DubNs0q4AEmay6l29M1q4GdmflwZj4N3AKs63Kfx47BQdi37/C2ffsa7ZJ6p49+Brsd8kuAR1u2H2u2HRIRGyJiJCJGxsfHu1xOYXbt6qxd0tzoo5/Bbod8tGnLwzYyhzNzIDMHFixY0OVyCrN8eWftkuZGH/0MdjvkHwOWtWwvBXZ3uc9jx9AQPO95h7c973mNdkm900c/g90O+a8BKyNiRUQ8B7gY2NrlPrti0fHHd9Q+Jy65BIaH4UUvgojG4/Cwd9dIvXbJJSw6cGBWL607lCMzpz+qSgcR5wM30LiF8qbMnPJX3MDAQI6MjHS1HkkqTURsy8yBdvu6fp98Zn4e+Hy3+5EkPZOfeJWkghnyklQwQ16SCmbIS1LBDHlJKpghL0kFM+QlqWCGvCQVzJCXpIIZ8pJUMENekgpmyEtSwQx5SSqYIS9JBTPkJalghrwkFcyQl6SCGfKSVDBDXpIKZshLUsEMeUkqmCEvSQUz5CWpYIa8JBXMkJekghnyklQwQ16SClYp5CPiryJiR0Q8EBH/HBEntey7OiJ2RsRoRLy+cqWSpI5VHcnfCfx8Zp4N/CdwNUBEnAVcDLwUeAPwkYg4rmJfkqQOVQr5zPy3zJxobt4HLG0+XwfckplPZeZ3gJ3A6ip9SZI6V+ec/O8DtzefLwEebdn3WLNNkjSH5k93QETcBSxus2swM29rHjMITACbDr6szfE5xfk3ABsAli9fPoOSJUkzNW3IZ+aaZ9sfEeuBtcB5mXkwyB8DlrUcthTYPcX5h4FhgIGBgba/CCRJs1P17po3AH8KvDEz97Xs2gpcHBHPjYgVwErgq1X6kiR1btqR/DT+FngucGdEANyXmX+Umd+OiM3AdhrTOO/IzAMV+5IkdahSyGfmi59l3xAwVOX8kqRq/MSrJBXMkJekghnyklQwQ16SCmbIS1LBDHlJKpghL0kFM+QlqWCGvCQVzJCXpIIZ8pJUMENekgpmyEtSwQx5SSqYIS9JBTPkJalghrwkFcyQl6SCGfKSVDBDXpIKZshLUsEMeUkqmCEvSQUz5CWpYIa8JBXMkJekghnyklSwWkI+It4bERkRp7S0XR0ROyNiNCJeX0c/kqTOzK96gohYBrwW2NXSdhZwMfBS4DTgroh4SWYeqNqfJGnm6hjJ/w1wJZAtbeuAWzLzqcz8DrATWF1DX5KkDlQK+Yh4I/C9zLz/iF1LgEdbth9rtkmS5tC00zURcRewuM2uQeAa4HXtXtamLdu0EREbgA0Ay5cvn64cSVIHpg35zFzTrj0ifgFYAdwfEQBLga9HxGoaI/dlLYcvBXZPcf5hYBhgYGCg7S8CSdLszHq6JjO/mZkLM/P0zDydRrC/IjMfB7YCF0fEcyNiBbAS+GotFUuSZqzy3TXtZOa3I2IzsB2YAN7hnTWSNPdqC/nmaL51ewgYquv8kqTO+YlXSSqYIS9JBTPkJalghrwkFcyQl6SCGfKSVDBDXpIKZshLUsEMeUkqmCEvSQUz5CWpYIa8JBXMkJekghnyklQwQ16SCmbIS1LBDHlJKpghL0kFM+QlqWCGvCQVzJCXpIIZ8pJUMENekgpmyEtSwQx5SSqYIS9JBTPkJalghrwkFaxyyEfEOyNiNCK+HRHXtbRfHRE7m/teX7UfSVLn5ld5cUT8GrAOODszn4qIhc32s4CLgZcCpwF3RcRLMvNA1YIlSTNXdSR/OXBtZj4FkJl7m+3rgFsy86nM/A6wE1hdsS9JUocqjeSBlwC/EhFDwJPAezPza8AS4L6W4x5rtj1DRGwANjQ3/yciRivWNFOnAN+fo746ZW2zY22z06+19Wtd0H+1vWiqHdOGfETcBSxus2uw+foXAK8GXglsjogzgGhzfLY7f2YOA8PT1VG3iBjJzIG57ncmrG12rG12+rW2fq0L+ru2I00b8pm5Zqp9EXE5cGtmJvDViJik8RvuMWBZy6FLgd0Va5UkdajqnPy/AL8OEBEvAZ5D40+YrcDFEfHciFgBrAS+WrEvSVKHqs7J3wTcFBHfAp4G1jdH9d+OiM3AdmACeEcf3lkz51NEHbC22bG22enX2vq1Lujv2g4TjUyWJJXIT7xKUsEMeUkqmCEvSQUz5Jsi4oyI+EREbDmi/cSI2BYRa/uptoh4U0R8LCJui4jX9VltJ0bEzc36LulVbS31LI+IrRFxU0Rc1et6WkXEvIgYiogPR8T6XtdzpH64/tvpl+u/pZ6+uuZbFRHyzR/evc27fFrb39BcIG3ndD/cmflwZr6tza4/BTb3W22Z+S+Z+QfA7wG/3U+1ARcCW5r1vXE2tdVZI41PZv9rZv4+cFaVerpQ2zoanwbfT+PzJf1UG1S8/rtVWx3Xf8111nbN1y4zj/ov4FeBVwDfamk7Dvgv4Awa9+/fT+MH/BeAzx3xtbDldVtanq+hsdDa7wFr+6m2lra/Bl7RT7UBVwO/2Hz+mV7/3wIvBL4IfAG4rJ+uO+Aq4A+n+v/tcW2Vr/85uO5mff3XXGdt13zdX1Xvk+8LmfnvEXH6Ec2rgZ2Z+TBARNwCrMvMvwRm+qfnrwEn0vhP/L+I+HxmTvZDbRERwLXA7Zn59U5q6nZtNEakS4FvUPGvxTpqjIj3An/ePNcW4JNVaqq5tsdofMYEoLbPktRUW+Xrv4u1Vb7+66yTGq/5uvVVMTVbAjzasj3lImkAEfHCiPgo8PKIuBogMwcz8wrgM8DH6rjA66oNeCeNkdZFEfFHNdVVV223Ar8VETcCn62xtlnVCNwBvKtZ5yNdqKdVp7XdCrw+Ij4M/Hs3C6PD2rp4/Veuje5d/9OZqs5uX/OzVsRIfgozXiQNIDN/ALS9WDLz72uq6aDKtWXmh4AP1VwX1FPb/wKX1VxXq05r/BZwUffKOUynte0D2r0X1A0d1XbogPqv/3Y6/Xfr1vU/nbZ1zsE1P2slj+T7eZE0a6umn2u0ttnp59paHS11HlJyyH8NWBkRKyLiOTTeQNra45oOsrZq+rlGa5udfq6t1dFS50/1+p3fOr6AfwD28NPb0N7WbD8f+E8a74YPWtvRU9vRUKO1lVfb0VjndF8uUCZJBSt5ukaSjnmGvCQVzJCXpIIZ8pJUMENekgpmyEtSwQx5SSqYIS9JBTPkJalg/w/zMsbdYYGeTAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "<Figure size 432x288 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from celluloid import Camera # getting the camera\n", - "from IPython.display import HTML # to show the animation in Jupyter\n", - "\n", - "style_list=['ro', 'g^', 'yx', 'cs']\n", - "parity_list=['+,+', '+,--', '--,+', '--,--']\n", - "fig, ax = plt.subplots(); # creating my fig\n", - "ax.set_xscale(\"log\")\n", - "ax.set_ylim(-60,60)\n", - "\n", - "camera = Camera(fig)# the camera gets the fig we'll plot\n", - "for i in range(Grange.size):\n", - " for j in range(num_blocks):\n", - " ax.plot(np.abs(np.real(evals_list[i][j,:])), np.imag(evals_list[i][j,:]), style_list[j], label=parity_list[j])\n", - " if i==0: ax.legend()\n", - " camera.snap(); # the camera takes a snapshot of the plot\n", - "animation = camera.animate(); # animation ready\n", - "HTML(animation.to_html5_video()) # displaying the animation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0a788023", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "734325af", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/html": [ - "<video width=\"432\" height=\"288\" controls autoplay loop>\n", - " <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQAApkxtZGF0AAAAUmW4AAQA\n", - "AF5MUAAQ5JNScnJycnJycnJycnJycnJycnJycnJycnJydar//8VhXwHAAKAFBRGW8ABPI4iDqQxR\n", - "EpXXXXXXXXXXXXXXXXXXXXXXXXgAAAGnZQbuAAEAABeTFAAEOSTXcQGAR48JQAEyMxKhSDHt5A5f\n", - "h4CwVwmLSKNYEVP7yMiGikKjielH8Ayo6AuC36TMf8tcAahfJDMqUWQYdNrLIg0Qcd5P5s+er1kY\n", - "aKMlxbDSD1ewjIMowl9PyrP2uxWI4h/CXzIjGqEIji+hHrtuftDBwABABAhAtMxe+bx5offfffff\n", - "fffffffffffiMxF/r/CL4oAWjpMGpIDKOe4DoI4UIc4DRu7X2h0+NrsaPv6XAfwcUBhCJAJHlnoL\n", - "G899o04ANro2JlL5/SmZoTjIqveBQzqkM8IjDEQj+F4LKlgFyHGcWcghT2qiwABAemAAEAIEMJi+\n", - "IIGhACAZE5OtV11quuuuuuuuuuuuuuuuuuv7hM/F/wAF41LNJGKqAFsJHPSGLmkqkWIWfPe8HA3l\n", - "Pziwu/egVGjx4JhTRpvngYQFveGgkotrXKHLvd4u/7SRJmGFsrzt+rYyHyqvzf4KAAQNg0BiRSmu\n", - "mKooEVM1tP/YcTqAGR55JsPlfWc1aZu3t4MZHQBJwAI2+vq//4iJXIx89///RNLgAAACjGUDa4AA\n", - "QAAF5MUAAQ5JNfARxXDC8ABMyMSjITnNPHYXAATIjGqEIji+hH4CIoanGC36eXTf5+8zIxLyFRhc\n", - "SjLMjCcfCnGvcbtUIwB9BiEPAsSfXNZEGiDocW8oo9XvIyIaKQqOJ6UfgKSA7dbKkyUf/w/0jDKP\n", - "mmuCE0eOf97CMgyjCX0/Kt/a7/7BjUIB4TgoDgACACBCBKYAmRmaE2U6sy44wjD1BRJjyWuDHgAC\n", - "ACBCBaZyak5OTk5OTk5OTk5OTk5OTk5P//hCHPAATrLgyzHwEEFf8C7wKnqDwiGWBILQIXoNT2ja\n", - "AEBb0FncIYlaBwh/jj5wCAhX38A8kj0dm9vwA0cyxRz7A2yLjDEpd8XqYBnLFSOVnN2ug+fAA/LI\n", - "50jI376ekhAQRA4ABYAAQB0GNXoh8ZfE9sdrM8CXDReCXa64ywkKjCvGa2byU8wYNSxlbKIhxEBq\n", - "hQmMwoAcq6XD/+g3gOAAIBQBDQlMCKUOEcjubtB6qIC6TAx3OrV4HDBQoABqAb2mzLQmblx1pePh\n", - "MuXvekzDVzHCCDGlk5OtV11trrrrrrrrrrrrrrrrrr/4c3QXQQ4AFqbsNCEUMkn5KbbmgAEy7SBi\n", - "qMLZ/oF+jFPGd0W2vvMmQB2j2YT7r3iX9DRKBzPeZh//bBJEMD0d2hHoVQbR873HECJqOo2FMcZ/\n", - "zVQR0CP/ErW4/je6Sip4/2DD8ngSIEICJ/Yni1XTpiN/uwAAqUGG51GBfDkh5sK36AF40ayJePEK\n", - "2xjrtKdgfCG+y/8BZlYKX3BChKGHv/wuqe1vleE/PvV/9sH4GP0ElhTnovzQ/pT7BbnnZIzbPfNm\n", - "dbhHOeCFgC7sZx6MPej9LRm2lpcAAALnZQFG4AAQAAF5MUAAQ5JNfHmJ8O+AAmRGNUIRHF9CPLvs\n", - "AHzIxKpCowvJR3nkOMQWcghpDW+RkQ0UhUcT0o/wAO0VlesTfuHXkGnAEY1D3GPQdXA0L2EDaYsu\n", - "XVbz/3EGgH5KMw6+Fmxr9ZEGiDsILeYw9XmAEgDBEHyJdNhGQZRhL6flWftdw+0AEQwngOAAIAIE\n", - "IEpgeAmRmaE2U6sy44wjD1BRJjyWuBx4AAgAgQgSmE1JycnJycnJycnJycnJycnJ//9xOC6AD3YT\n", - "HPCDLMBypXh8e2BS0PKSuRXKLI3iEJWi+BCRGEABHe7gbxYcAL8rYaAUHf8waC6DsFDsifIUs2A5\n", - "NDcrEBD12qxVpMb/9/wJ6kEADVErCUKunXf/YDo5L9qbC+rAYAAvQYIEAAQCOANwZ2w0/QGM8wmv\n", - "YPfYeE7RXfANo7CqjYjx4/4/0HYI2gtNTLy3w8CgXpbKrbRI2r8GAKc2TIh9K//+8JdbUH2LcH1h\n", - "QHxggBABlA/JqjAaNNHAx6NT8LzDF8jAIukFyhA9iMRLl4f/oN4DgACAUAQ0JTPtnhIUKEBA6RXX\n", - "l5Ehl4zKIXUL9ogQxZYj9J1qu/1irXXXXXXXXXX//8ILsADn0ijAfGc3tA1mdbQAjCeLP/AIgI8E\n", - "oolrcEoolrf86B7Bban6A35eoOdse/OAKALkMzD3iFSee9ddddf//OaBdAha2sZG1vl4PM58ghRP\n", - "/8BKTfASpxCTl/wwDQD7Kg7GF4iNj4evd8tNjfAAg2o1sXReACmV0MpAz//us2TYcRSgeP74HAEy\n", - "CZP8aH2D6exS0Y4nL/gCjryoQDAPQ+KCEAG8xekUrLfGd/u+6/9dNtzCVrcW7068hn/+lR+yKJ43\n", - "+uAG6Wk2jMWUOn8wgiIcBLq7gQ4+OOCdi/YDmGGpH8ENhWiqKbCkHjrT6R7o8Ot+KOz6H//hvcy3\n", - "wJm9M+G73u394aDRBEWSPo+FW1rb554ddeAAAANLZQGy4AAQAAF5MUAAQ5JNf/82wQwAXGQZBtLe\n", - "Y55u0AuQ4xBZyCGlNbAIxM+UxYAE1Z5IjzHf+vH0GJJwXS8PC3HH4DgACACBCBKZw/uRmaE2U6sy\n", - "44wjD1BRJjyWu/AB7sJjnhBlmL/AGF5Xmf/c+EO8HKleHxbYFDsifI5ZsyAEBBqCxCYhAAE8GvAt\n", - "FzYQsfXsD59FGHgVV8FGZohhOqvf/QcAgt4AqmN1Kse8QLoDAAFaCfPgqnnvJqTk5OTk5OThjAAR\n", - "GRGRkZGRmR/AFgAyQFGwuf/3MMuP4EX6efj//4K4BVRw0uKzOQMOkXT99x/4jsScnJycIfwib6//\n", - "/HH76eBG/pn/AAr9sE0YaBqD/899N0vA/wAJili/qfCBD+vQmuDkfb/w0zORv34WBGgoHnAzsCAE\n", - "oTILJ2MCyLGxHfQIsxungAFr4swsCrvq96A4givVxxf/13/IgkIRj52O5rwqpHftf84bwDocFdoR\n", - "kSmi09a//ABHZKICwzn9YhOsYIDpgVbCBHURgF0QH4mIICxGEoD3u44DLBd12AaHfqkAgtt/dS6N\n", - "CeuRTeH4fgrz98zPHw9GAACAUAQ0LTPxCNCAAFwIm9/2wYf/xGK4pOtV/ow/+H+AZpoH6DDGt1f7\n", - "AI88DZJhjWev9/3eEI/HQahjwABABAhAlM+CloeUlciufX9X/Xm3Af+g1osjPEISlF8vFWkY4f/e\n", - "v+lpjhGKrLtdB/EWIQAaJIKOeFPlhfWaNhIZtOpVFIhguHP+EP/8FcBsK9HGjE3/Bh0Kkv7/d/n3\n", - "/XXXXXXXXC2ABEfqv6//+AEX9LJvi8BI/1rfws4AEH133f/4Ze1Ze5v9er+fomlpaWlhZQAE0m2k\n", - "k20n//wAPclQakKoZHxeavCPcmI2CGH0O6ZlzvFCiNLJsPXQTLTff8/BdBnhfumaGqXoYe1PDwAh\n", - "M15Rm5gZt88kfwN2BAYRgU5wSreI9Zly9KGezYbBP05CFVJwS9LvQuvg2MWqmY1U6Y4YDeyQHIlU\n", - "V0N+i2zz7/4FFySmb0Ar1MTiWhv52HTrT2LgOWZNmCWgirhHIRBMxsGujZPfaZ0/qsXUZMoOaAvF\n", - "F+StEiFE/fHm/KSNeycQ9E0uAAAC82UAh7gABAAAXkxQABDkk1J/D/+HsBwABABAhAlM5MXJycnJ\n", - "ycnJycnDGAAk0mmmmm0/gA/U1HoTf/ume/Y/4BLAQuTK9N/73//wV8fc/PBPH//4B1wttzeBwNIt\n", - "9e89//JycnJyf9x/8FkADC8lM9JqUhEzM+AAde+/RayOYuqcxMzlgusK04Dcy54DSjFz7uVx/8Nc\n", - "aKqYMRRoBzP8CV4FnDV1U3a8AAvSWfwI7//LCWknIbLH/fSH25mw9uAoswHAAIUaj4VDYqhyi/kt\n", - "x1f7+7/9dMtKf0gBgv7tgiPp4IpgFFH/vxRDZJiHH5dd9dx+7irHbSJbGP/9cUKJ4LQ/1PjKn4+3\n", - "fzwP4DgRyny3+Y7awGL3f//WBmwODSpdRPiBmNZpw9RwAfKRwUeTJYyAteqeFGT4bU+If/ob7ADJ\n", - "PTtDAOAz8YAAIBQBDRqYMEb7/i9g4EiDOAtcA02fAJnzaOP+KhvEOFLaVXzwhI5ZOTrX/H/h/gAJ\n", - "GRDRSFRxPSjy/7EgnwwDhKAHwykKAw94iG2oAczMagVKdAR24pTOBuEEJWlSwbv8kXnvAZSoDYjM\n", - "8BM16iNPiImLhEIdwMsqqDfg1KUfKXilopYX/xmSFh0J3gbZQ0v4iDE+9xCU7ya4d//kRSRkYfD8\n", - "RkQ0UhUcT0otRBnHqCyTX67+H/66666666666666666/7z/4LIAPdhMc8IMswHKleHx7YFLQ8pK5\n", - "FcosjeIQlaL4ETIwgAEZ7oG8WHgBflbDQCg78waCg8P2GoKHZE+QpZsIAQEHoLxVpMdP/vdLTHCM\n", - "VWXawARQDu9OC7Zm/vug9tk/DUKqnXf/ALCCVlDLwydAMZwUdnhVvDEqRV/cwIs/CijbI8f+/7gL\n", - "4B/w1BiE1wcjy4OybD10MnLfBjADYyc3PoHtGmX6Y6bTXHg2duC7cCUgMDVilMBrFQaxWDXP+XZA\n", - "xVTYMbpMJYYLXjan/x//8Ff+Bli8ACRmLr+Mooh5wv2v+nrwAAACX2UAorgABAAAXkxQABDkk1J/\n", - "D/+HsBwABABAhAlM5MXJycnJycnJycnJycnJycnJyf1ETCO6/gDI0ZEY+HqFdb0TJPjuDzF2dWiN\n", - "kOI3bB+yJ3bGq2lTBqQQ4T++Yj2mfPOpWUkGybCpvfe/Cmhlgi6GbwHv1UL1O7LjwQjEHqk0xmbi\n", - "ziEQHjenyzNDG62z32XNMrwV7/80kT5WWhcvbrP5komzP3VxslcO/6Axv7R6qJjlIFAr1UQ6iBD8\n", - "Z3zREPnv6KI7YY+t2kap4GAY4VRTWPkVdyft8R/xrXfnwBSGg2GXRKdz0d/ngfcPH/BXkXyFs6D+\n", - "9jAABAKAIaPTLPzuNG2ftBgcANEVws1jZ/D5Nyda//48EMABIyIaKQqOJ6UeX/B/vzhDAL4AHwDQ\n", - "ZKNx5ZgYRb7gBzIyDLhXhysES5D8RExcZCHcDLKqg34NSlHyl4paKWF/8Ya5xR2aUtRb+F4AACgx\n", - "iXuTD00g/8ZkhYdCd4G2UNM+IgxPvcQlO8muDDHYAEFzMtIiIP4f+IyIaKQqOJ6UWogzj1BZJr9c\n", - "H/9dddddddddddddddddf//TQc8ACEC+wNCRBggX4XJHELHLn/XywKBaFVI2iP8GgIi9AoU/xCLa\n", - "0HmcPN4D7vvACEKFSuRnN2uA0PgZjMAKhu74l4+KjC0aM95AHEkWDs3tz8AXKRGKsUWlv3Tfla6/\n", - "xCSBgAEKhyzLzxMw2KivL91jB4jslFQ4nOMILs45wAFz90RFGQSMJtqn7v6f9bnD7/2CuAKb0hNC\n", - "Upf7f8AIQmZlKufDBjDkgpbw668AAAfRZQC9uAAEAABeTFAAEOSTUn8P/4ewHAAEAECECUzkxcnJ\n", - "ycnJycnJycnJycnJycnJyfz3MECIQ+AEO71EZ6YMjM2EQqeAha0w/khK0GnCS71geXXisOLugjb3\n", - "Jf/86hJNf3zCov/vDonB/cbt3vNuLYL4+yhO/9/hdAMG8Am2yu0vUFF6QhcWPHMMG2Po4oEoeYZi\n", - "VW8XD+P4XhJ9rHgACAUAQ0LTCRqe239rf8QAhFybk61//8YIeAAkZENFIVHE9KPL/v/MHmGFYACI\n", - "whPvNSn95AChngBIUjBBeFUOvnbdrIiDKPRbzWkm7WACRRw39fIfn5588RExcZCHcDLKqg34NSlH\n", - "yl4paKWF/8ZkhYdCd4G2UNM+IgxPvcQlO8mu//DAIIIfyMiGikKjielH+IwhPvNSPWrS3mf/gGAS\n", - "Pj8ABGZGREZkRGRn/8AB4iISYhBz2Yofh33x+AAiIyMiMjMjIz/8AB2YYv1WJHLUpr4fvj8ABGRG\n", - "ZkREZmRH//wAHyMxLikGPbih3/wD4IOYAAVAKCyMtvj8ABGRGZkREZmRH//wAHiIhIhCDns5A8f/\n", - "/GjJjOYyYy+PwAERmRGJFVFdkf//AAdGEJ95qR61bY8G++PwAEZkZERmREZGf/wAHyMxKhSDHt5A\n", - "7Dvv/3whgC+ADPIowamMUYGfs4uLDN/bmCI3oGSbsVyALMMX6ykjmKWx9cOCBnwGFATgCL8qeEBE\n", - "rWeb3yevADA9XnYDu9HI2AkAewuxWLz0vokJgqKr3D+D+wQeAAlEUZhxIcpylXXXfhwCHpMIUhhg\n", - "AuINB3ocWDlBE9XgJEUubIjgfxTS/7Ap8gYPVkOSP+DAUZSqqgypYxgnj/9oAyD8QZueQgRhbtGE\n", - "YJAABw3D8ZBi9W4hPZ6c8AWEmcVCN3s3U8Mkg4AfCKUBh72CIdj0gJEbwgMzRN4c6y8QAATAAEAI\n", - "AhAWAAIMnxBp3ESjN7dxPBghEwBgj9Q5LiTdrxgfwdilG4+eX6/D7h4x/CfAGMkxCHaSdxjQJqG4\n", - "AAVHKQ5iSTam//8zhhAL8AFxhooyHluMeer2BMDhxc1mEYUWfABQS9xEpvO3wFaGfwAEYS5hUJ3P\n", - "ztR/kAAEgABAFAKQWREG4+FtNeSbteMNc4o/NKWoZK4X63gIyFR7/MzMaqUquL6U/4bpEOglXqUk\n", - "Y0GDDgAeyAJwgrGW1kVjP/4AuA1V1AyTHe04cZ//hAACgAAgCqfwRCIRJJKLLWtDAUZCi8oKQt22\n", - "GM///2GYSgVyHFBLKn3mD8I4ACSF20bu/ZXL8REQkQhBz2cgeH/CCTsIhG7+9qQw/x+AUA8AvwAX\n", - "EGg70OLBygier2BIilzZEcD+KaX/YAWEmcVCN3s3U9BT5AwerIckf9AUZSqqgypYxgnj/8GQAATA\n", - "AEAIAhBoAyD8QZueQgRhbt4g07iJRm9u4ns6xGEAx38RBCde6hHb6d8MZJAAPYRYKKZjBSkKN/9u\n", - "ARhqgjeoxNqYBcNAN6EYG2lVlUt+LAAEGTYiYAwR+oclxJu0H/AMqOgfBeF5ro1veYZQf0TmG81A\n", - "j6gYZd8R/C8Qe/ABeQSjvS4oHKiJ6vfIyIaKQqOJ6UeAo1J2E3U8f4IaL/9YjYAwR2IJS9xu1HgA\n", - "EgDAh5MgLAjDlPeNiJtTGAAEwDAtxMAAAECIYGgIZzhNKVQfZ99+eAEcLUMRjQjoKtvB9NWt7h8T\n", - "IAOwlDrHQjBaEt37/+AMRQSIJSyaRR5IeBL0gwJpkHaVX3/8P/Io4ig1OeFFSGHX84upgIa74Aeh\n", - "EKUBxzxENtQGsjAdCFSTssaz/3zMzGqlKri+lPgnoAMSpu3E1f17gKQctTt3gMsyAIDtxQ5UH5TA\n", - "FEpM4rtT53Gil/+4QAacHYh+/uCMrfhAABAjAAEARgeAARAcEgSTMqQBAiZshYnPf/5mZjVSlEOb\n", - "6RzEY8YRiPCcOFgIxqHukwkywGiUM+kuF+oq2833AjIJUHQ8p5jT1e4wyg/ozDebxzzvwYY/AARl\n", - "0ZeR1kP+AD4w0UZDy3Ger3/gAOwlzCoTufnaiNRmohAIOd8CwOuPCocyH7vgBQS9xEp3O3wFYGfG\n", - "QYvVuIT2enPD8N0iHQSr30kU8usuyAACQAAgBgEILIiDcfC2mvJN2vGGucUfmlLUMlcLkAAFAABA\n", - "DAIQfATGyJfFOmLPg+4et3EOE+AHHTwN9c7VbHngShfj0m/m1z9/gBzMxqpSq4vpTvh/8AwScKeA\n", - "C4g0HehxYOUPnq9BT5AwerIckf9AUZSqqgypYxgnz/9nAIHgCqG/1pGmJ8pFdlAkRS5siOB/FNL/\n", - "t4wkzioRu9m6ng5aaAAsEeHAYbGDULQdv4MgAAmAAIAQBCDQBkH4gzc8hAjDHbxBp3ESjN7dxPFg\n", - "ACDJ4kNeJ2rkxGOyDD5jiJx/CfAXh9zEJhlO4LI/+D4DUqjEKuJSxLW8GH4jj+k4U8AFxBoO9Diw\n", - "cofPV6CnyBgtaQ5I/6AoylVVBlSxjBPn/7CAA4YAUqf4iCE691CO307oEiKXNkRwP4ppf9vGEmcV\n", - "CN3s3U8H4JQepEaSQ/JpV2uDDIAAJgACAEAQg0AZB+IM3PIQIwx28QadxEoze3eT3hUR2yOz/lZ4\n", - "f8qGHfXXXXfeGu+8N999999d4a77/Xff777/XXXgAAAACWHgAEAAnIvBvAAAABphBvgAEAAnIvff\n", - "AHP3D/Pf9wBx68f57/wZwAAAACVhA24ABAAJyL3xPAHHrx/nvlP3D/Pf+FObBB8eu/y+wYIvTwH4\n", - "AAAATWEBR4ABAAJyL3xPAHHrx/nvlP3D/Pf+Cc/m/+AUw7gAW5Kg1IVQyCfgAGF5KZ6TWqQmFRHN\n", - "DXPiddDpZgbsKm8DqLkCiwKCQnyIu/YZAAAA6mEBs4ABAAJyLycOeAFmDcxqUdWL/AJO+s4GcMcL\n", - "HExzsMuPgGGkvKTAAECNgAACA7mQSLPhxSgda7MoBd5GHQh9AjH7VG8yYniBPmiN//w1AAhFrI5i\n", - "6pzEzOWDwgCzhq6qbtB/ToJH2f+CR7Z0/rieQK/wib6///m8D00wI4awV7F0eMVHPr+32PwwFdFw\n", - "8pK7KZuXR7MCB5An/n+YAjFg2W+RAYYzHmxGXeMQMZbIx4YHXLtf8X6iT+G8BI3ZtTf+CFqrASnW\n", - "TF2YXiI3w9eVOHaTCZu23z83JiFrAg/H/ER7TlvwHactyQAAADBhAIfgAEAAnIvHifg5rr////E8\n", - "RwA9nX+H/e/+AG731P+rf9/gDn7x/n/hTkx5MckAAAAiYQCi4ABAAJyLw9yeAJ3vp/33ywBT98vf\n", - "9/wp3QMEj08ckAAAAUFhAL3gAEAAnIvDHNhyH+/v+J65uAv7N/7BwF80t4vgPTbpPx8ATvfT/vv/\n", - "L+AAWp3fc//+g/K/gP9hl83AEJuck/PfL4AzvdS/0ubgCJrc0/P8XwHAXRpYHAXRpbBwF0aWBwF0\n", - "aWiP4vgOAujSwOAujS2DgLo0txHiP4vgOAvmlgDIjti6Id5hev3wf/bY8BfNLRHiPCmAAjMjIiMy\n", - "IjIz/+AA+RmJcUgx7eUOw8R4j+L4DgL5pYTKs3+8eAujSwOAvmlui8HAXzSwDO/XDn/pn8/fN4BL\n", - "u4P/+OCcvAIP/h/3nvXNwBl3fD/h8ehP83ADB//n9/cNvrA/2w3xcAOP12ff98MDd1u+tzH7cH39\n", - "EARWzcgPN54rfrk/3Plhl33z/6+PDrm4CD/gf7Y/fLwBl3fD/h8e+XgBX13Q/4evD8AAAAAKYeAA\n", - "gAEcg7wbwAAAAAthBvgAIABHIO8G8AAAAAthA24ACAARyDvBvAAAAFFhAUeAAgAEcg7wVm//7wXY\n", - "ADlFWTi8xiRW2fgAJTjWXIOSQOb//a2vGRSA9yf4EJEYQkR8CMsSK9wBf0YTK9CbgAQfXfd/+HAY\n", - "l0yZi6OH4uAAAAC4YQGzgAIABHIO8uB9DnigACB3AOECzPwLTNpcAXTMBjO7V4b4DgAggsJpmA0I\n", - "kZ4xa95PYIws5vieJN8f/gsgAV3hFEm5IeWx8GHAJAJhIL2fwCHTcPn/cABu2bY36lV3UMOUK/wB\n", - "i/fHYGf/8UvDWA4AIILCctwFhEyOGsnzx1TAlFVaX/DMBzbDRCje400CQYckJbMfkh/YXg+Uob/i\n", - "T/BzDnOAAE1V4S4d7fhd//gDK306r3+0XAAAABphAIfgAIABHIO8IQcw1hluNB5YA965el/BPAAA\n", - "AAxhAKLgAIABHIO8G8AAAAAwYQC94ACAARyDvBSI5RGHctEeFMABDdnZmd2ZnZ3/+AA+JymKgrDA\n", - "tHXjmHiPEcHcAAAACmHgAMABnIGvBvAAAABUYQb4ADAAZyBrwZuJxujAGR+7H/PUEGaOnuR5z7e8\n", - "CKmg8GiwXn4jxwx62tkVsPwx6ziWozfR3fq62ftoHygSfx3+7UOo2UmdlE4gw7LdjCRdXYSAAAAA\n", - "C2EDbgAMABnIGvBvAAAAUGEBR4ADAAZyBrwVn83/30w7gAOLO8ih0FFNDkSfwAD2DhruhAUWwcL/\n", - "/vrD14rEsC6zI3Dvv9H7BeEFncICQpcAR/QzEj78APNtkMZUfvFwAAAAtWEBs4ADAAZyBry4HkMc\n", - "AC9toiQQCIGOADvQ4CLEQSAAICYs8AAQXcQmIQABWAk4BGCQFUFKaAjdu1YAHTk2QaSwTJMw/DgK\n", - "qwIcebav/EifgQcod/gAiNp2tof7/tv//bCB45/xRkHh/6DUBca3mKC3rCASyh/2Lgoqlc5jgGOD\n", - "/niCYhAAeNY4JEDvK2boYSaX+Bi2oBBZeEW04zojQF88m0v+fij/AgwxxsEjxXXDc+mH4uAAAABC\n", - "YQCH4ADAAZyBrwgJ/hWAFotFdWI5NA6WuQjw8VQAeBmVpua7Saba059r8Bu//v/BhAu7oAPb6SBQ\n", - "VBvAg/jvfBNAAAAADGEAouAAwAGcga8G8AAAABVhAL3gAMABnIGvBSI5+XsGFRNgPYAAAAAKYeAB\n", - "AAIcgJvBvAAAAAthBvgAQACHICbwbwAAAAxhA24AEAAhyAm8G8AAAAAmYQFHgAQACHICbwWQcw5t\n", - "gAurvf0f+tevAC7611/a4Affa+vbhcAAAAC4YQGzgAQACHICbyF/B9wQQ/jqYrUxWpgBI9PaqcGw\n", - "UyjA4CAy4GDQeU31QBwgEhC8AO48iMd57gApoHqEUWeUI/17H1MkZBzDWCZ+zuvwkfZ+UO4CL9vz\n", - "wAMV2nMm1v3/9/gf/6ZQId42p/8S8Jw79amK1MPOghowaFEbEC4Htf1qYrUwAsImRwZRtaOR/PwW\n", - "gTsFQ12tcc/XuAvK5+6r/+cE1KbfgfjIOYc5T4+FhXgBWdL+bP3i4AAAAElhAIfgAQACHICbwib7\n", - "j/4LIADwbkMRR4+PwcT/uBGUhLTFwhZT1f/qKiYoiuv+tqcy8XVOPggAisaAuACd4sEhVUbn1+H5\n", - "yeCaAAAADGEAouABAAIcgJvBvAAAABlhAL3gAQACHICbwUhTDuW/85o5rOaOaAiQAAAACmHgAUAC\n", - "nIDLwbwAAAALYQb4AFAApyAy8G8AAAAMYQNuABQAKcgMvBvAAAAAYGEBR4AFAApyAy8Fh/lYbgAI\n", - "EKmcyWGYeAT8cfN/IjBFZBSkvOSUW/WDAdtUSoGFqCA6CTfYQwFfPMAnuBQNTW/3YIAIjWhAAEAh\n", - "JOAD3HA8GqTtOvwAeeXD0IpF6514qAAAARVhAbOABQAKcgMvIX/4OS8gLD7Bmb//F4d8EGAAEN/a\n", - "wAfE5THIHIQ8X5JDftMwh6F+novbD9AgAGjQEAAIBmABbwBa0QCHJ7UEQOHSALLB32wBCAjHHBp4\n", - "QNtQEw1oerFSdBiZSeveG/ZAAsgAgSJrokhGzc9CWljGfWmZ+A/GXiOhBcWoMWJ+DmqdjVBB5oRD\n", - "/6DWA0AAEAewAAQAAAsIGet/xgsRQrFE55yS+vzALQcsHoXn7BZRE2GGEAYaBAACACoBdDnaA4Iu\n", - "2r0ITVgJ6zrf4eIGMsEfOlLS09DqAOJkqH7viVf/hnzMOuZePRbL7fKtgw6AF/v+2//YKURSFkQM\n", - "OLP8HM8AVwAfGKyzzXfdf4qAAAAATWEAh+ABQAKcgMvCIn4uGYADgZiDlRpJJxmeCAj/3DAzCub5\n", - "splPA0//Lh9ubHbFyVo5Xf+fggAEV7QAgApizbgQy4F/+3h/A7pJ+CWAAAAADGEAouABQAKcgMvB\n", - "vAAAABVhAL3gAUACnIDLwUm/8fwQceaMCJAAAAAKYeABgAMcgOvBvAAAAKBhBvgAYADHIDrwZ8bh\n", - "N3hoCFuP9OANAEBSkz3SXRCWOcAQAQKF6k9Lbk9kSvONaRFCMzaIyN/3zA3zDvzp4MNRHhLGP7hS\n", - "s/J7KDxPN8yAQBtHmrwQYS8nGfGxOJcu+YaR8//4MMMBJEMRABWjcK2rP3fAVmoFGxbD90BlCya6\n", - "X3/YM2HuspY79ASO0fp+16o+0ge0lY/L6agpr5rvtfokAAAAdGEDbgAYADHIDrwZYkEHAI/dQAjz\n", - "ClPCRzV/0AOf7oP9esMUsfv5hO6o0O9+/PAGAQ/TCYIvHqCZqZX43PTsABsFGUa51W/9H7Qlwc7g\n", - "RN538MAHOjyrtXYejgPDxFN2/0ETt7qAErKx2Jv37rb2a0xL8/FgAAAALWEBR4AGAAxyA68FsHMO\n", - "QyiaNUNeAiEy8JHNgHQZpoq+7BEfaYBUB000U+nCoAAAAT5hAbOABgAMcgOvJw/jdKuho6fABeAA\n", - "aOACAgJvZlhkRuAILMMxRxg5Akk0bAAEJMBEICUpOAD+ALAckVadr+zgAOBPQAK2LgAIFDPWrXTA\n", - "vQ38A4C01AlPDL+ACW+AvzGUAp6wH3E5pvgQAB0DjGggABA4AAEBoAEgvhKRCcoB6A8sPf4JmEBR\n", - "r9ngMXgmcb743mRUMg5hqcxIHxz46wI28f6n+E7jvpxvDuN0q6fIgI+pKD1ColenWJfBBF0SUF5u\n", - "sgXDgV2Quhh1dKugBIQk1BRgGSgjytvbev8DCA4jawTUPcKrLj36awzsA8AgTLEU6AtC+8+8DPCg\n", - "idBVl0yBRysfDCAAKBjCggABAdAAEAEBo7T4ItcDFApgb/5BCePcswCrsKUs9/5+Mg5hzjpoXA4V\n", - "4B4yPR3Twi5dMVAAAAGWYQCH4AGAAxyA68JB3AAQADAgtVgkRJMKsFCJsobgAZF8lM2l5aIyYnyk\n", - "V24AAKxgPxYtpKz1v+18HMFR5JhJAtd9ft7Nt8UQoqvkhyneHhh4QABQCmCQlNADt2kg6gUARsnY\n", - "wC0Gt69/wJ1Elpvm42AFjyefwi7dJ1ey9/OBFJdJO/+9RkcnG/fv/jCrpdc25ZetLLzP3VFtasO9\n", - "8TG6ix8f/c/BE88bf8AXpG2tG83//qAEBAZ6Sxwb7niwrefcOw5tBAKQoAZNxfaeg89vdvYbdps4\n", - "+JB55EIvngAOv+7Fd/+9ZvNbRA+y2+OwihPhJxVlMT6uIC25tTT2n8FrAbHMwu/m9zswVB+4qcmp\n", - "1/+BvIrMi75uPCU1K/n9hjZcwiFSP275vDXCsAKtI5UI+7QAwQ4o9HTz/fMD3p+ltf/SL0wLqRxV\n", - "HRr/gBIfhwAg17UkF2+FVg2OEKDYwsuJHzdWv8yE3Pv8KctxIm/9mibgBjInLZqy1XexB14W9uYb\n", - "XvfXsx5mJmBB0SY6nE/gyCro/7P+4AAAARFhAKLgAYADHIDrwvobgAe1bL2Bzx7eguTxoynt//ra\n", - "yju8ZF8Vv994hv0ZzjOLLg4Y3oOFUVdo28+E/+7QSChd71hQ1zGy//egb3Tjizb933915O16/f/m\n", - "DUK88FEWb/IjhN628MKawwrEAC3adpuvffV6cQ0Tft4BldpzTdC5pGkXbwl4ZsDR6GtR/86yBMjT\n", - "c0SHeGjwBVjmqhOf//v4AAYKFZoVhh6XXiuttaCOiKqlaNV2uAAYcbOBWl3vEiVtE/+ainGd80D3\n", - "Rp00Pj9eQiL07Se8oVIzzab//+Lz0Zxu5wQvNEDDjAtuED0Y0fehaKmQsui6v9TRkpPATmGWLz3n\n", - "VMZnEqX/9DBqSHgxYfgAAAAMYQC94AGAAxyA68DbAAAACmHgAcADnIDrwbwAAAEBYQb4AHAA5yA6\n", - "8MLiRuAJ2yZits4EhPQANPsoPbkepH/luU2k5q+MARCzJZfstIZGtZfboT3fq3/1Lei4tCF5rPaz\n", - "7//nTVWZPnguN7BShGIEsdgznDr5Vpxf34zi9yzfAAenpTA35M//vQn7NNkq+6GBZSiE2xT5/wbf\n", - "EhfwAEgDHMGJVJ/7JaTVyvhGlgiKu72Lu/BFAAEALw4Z0bQxQLYM6vLyY4hqiHq9vBtNptN/ve2Z\n", - "sb9Sq7qEFZTGFMOxlZY8wED0fdx428fuKjYcwwQDy/RMfm/EjcDlSYDDlSYnMHLJd9v39hBUmH+/\n", - "8uxBUmJzpvW2ae1ir62ylemg6vcAAACVYQNuABwAOcgOvDHG8BK2nd3qp6WwAcMB8UcCQLINr0OR\n", - "a79ONRPzCf+IWtmb/wDmn9bT3/4Phx0po/mX5/AzHAN66CNwGAoEAD8F4BKDydVSTMbSvikfA4Go\n", - "MAIuoAoKZR/qwTJNdMT6wPx0XR33/mXwb6VMxz+AGIPp8ufsbTWwsI0VeAhtX8te+9rtgEy/orqG\n", - "cH4AAACZYQFHgAcADnIDrwxcMQALUuAUNesFv/2AyAwHTYJpxbTunlmAogi71WRxY79xLAHJgDqI\n", - "A+Rlb3gJMT3OJcSaIS/KP/AemVDv6DjdpEAAVAwSx/DAAYYRMDAAIDwBAACAeMDusyEgAsK1aVpp\n", - "1/BSJJgAz96T/wA7TxK3XAAewNQa+wMXlmf37g+HJXNV4BxqHFlwrAg+BBxMAAABC2EBs4AHAA5y\n", - "A68jwVQ5wGgAEgGCGiWABWAB6VwAylgJoclEZBCifABoPatA8yQ5wALZgAEnU6AfwEUoLmDNhuA8\n", - "ycsEPvfnIWYZVlHUUK0sAI//uBGYAVUuLPHiFTbe34IAAQAgCBZEIAAQRwABApAA4CmBzJGMe3DL\n", - "hD++/AkfCF+UMPaETfgCVaf3xPGQIP6p2MeDRBqADEyMkNBCKuiFYBAhswOZ99xteR//D9AJh8tE\n", - "FCW+X4DwwsXT5bIXCbcPLDPyACWhzsNXhSVAErA3wgEBGIMcNx4uTPz//wYYQABkHErhAACBQAAI\n", - "BgAgMW/LDEQNXFd9u/+gVMgVA4vAmCxQCZKff8b4qAAAAQZhAIfgAcADnIDrwkHcBE3ce+ABkXyU\n", - "zaXlojJifKRXb4eASwB27SQdX/ywz8AAKxgPhotpKz1v+Af58HMFR7zHkC17vvt+e3vKIUVXyQpT\n", - "uUIAAuHPLCpIFAEbJ2IB6DW9eD+Ccklzfy8P09vgAIwyCues4tBA9JdZT42lZj6NlXAykIUWcLVw\n", - "ANNfy/W//0EoAL5N6un/5+ApqYVFdfo7EosN8K9kAATMACcwBljiHHIIYGtFJeXZOUf//IwAAqAI\n", - "BJZM6B5RkuLxhLDOkGAARHgCAAEBJwANoAPJX6BWR18c42Iuk7g5dbyvDBQAGGMY8DDeU/M7OAmD\n", - "jP3vZgLOLbOUfUGSAAAADGEAouABwAOcgOvBvAAAAAxhAL3gAcADnIDrwNsAAAAKYeACAAQcgOvB\n", - "vAAAAAthBvgAgAEHIDrwbwAAAAxhA24AIABByA68G8AAAAAqYQFHgAgAEHIDrwWn+DmeYTDgKvS/\n", - "+wHJq5neWYAp2r1+cgpNUdDb14TAAAABIGEBs4AIABByA68hf/ghDHgAXo+0AAIAQAAgE1VgAMB+\n", - "+xgAAEBMAAQE4iAALD5PEUgoBcLgCObIjHzwyCiPyLYAOYNOEUWeQd6vArhdRkvIpBPmwUw3wCR7\n", - "gABEq+tuQQgJinCAAPgFHEMHMpuYIM3f/LcIOBLQEFtTJVQbAbUP8D63tLn/XPjBPwczzp8Mpfzp\n", - "8YoKMK4AwbkGIaLTUEUW3pkUw/GGYchqTBJMbQ4clLsMOJSEABFQPbLRxGZODJRIz/BcErD80rXk\n", - "HKMfcXVk69pz/8MxUAAICFoAAgKgAdAAAQBk2dAPwhDUoQABYGOOqv/BuHT/LONf+hcjWmmwAhQH\n", - "PPzBiRV65/4KMbBzPKnADILlPv++CFOdHfz/EwAAANNhAIfgAgAEHIDrwkJ+DmeQUAPcnbq9vs2n\n", - "PIdv3d/+Uv/EYb8ABAw/c4JDHFVedjlPu8FLDWngUGKtNBmAGwOWYJ7z3uiDT7CsADl5Zy9Vf/pL\n", - "If4YVqpqn7Oka6/hf9AeS5YAHXDqUmLjUo0iwABAxABAZAbo8MK5WPLM724gobEIRKwQF2KAGp74\n", - "qv+oV0Z7JG5f1gAwk1Rkd/0IQyVAJ+6biHB+6wzDBAgwAEDBf4kJC3NlmVzhPw9oSZsoA6VeXL5p\n", - "ds2EABBdgphctENuceSAAAAAuGEAouACAAQcgOvBliAvsKEwoeXAPu0rv/r+FadgDIyjru6KvUmf\n", - "3bACaRmWQi//6sHqeRo0n//142AB1AGAgUIzYTkzsics3NYZDgG9dEFG3W+0BUmZJmb+/wNbDvHg\n", - "2BAAEAHCN/5WlWF3uaEvgbtNAf9xC20ic0f//+IC5DAAIG7D6IUy+940jbP91AmY/9K+f9iKSlv+\n", - "/gIGelcoWEMpuKwtH6forusLGEZe2nmpTJ2iU18f4kAAAAAMYQC94AIABByA68DbAAAACmHgAkAE\n", - "nIDrwbwAAAC0YQb4AJABJyA68McL0DRgNAAEAwAY0PCcCJu7ewASAAIAIDlBSSDmXIRTVdj//261\n", - "GS4fhoIsIEgDjIAVLwSiuU+q9A9n5h9zqpRABcQAcIwBTAo6RPe70BYggjMwgRpQlxhzxtQBDauj\n", - "/n0wAACAmAAICcUABYb34gOiYDefjDMOQtJgkmNocNyluQVJgMOVJicxPAoAEV6ZGy54OcGSkjPt\n", - "4XoiXlS4nzB0z6nU49rac8PQAAACBGEDbgAkAEnIDrwviQv4A61bA/3/gg0VJNL79+2/JcEpOwBI\n", - "9TR/dsZcou7ugBduImbJ//9QlmZHEMn/+rzDbUDgQDgNF4Ia7meyhYQ8AAmA1Fy2AEthch8GuHtC\n", - "rEf/eQlYpAB2qtLgMG61zcbj99+9ANQCUA4+PIhFatZozGAAHShipav/1dfRkipbwEA6dEJVR5hX\n", - "aOEpGAACBeABgYEZYcCAwAD8rhVP3O/1RySczKXOhderrqb2HblmOIL6JnHf+7uReFQf0T6DhN9U\n", - "cGjC1kL/n+v6LPjqBkbdyhb1AympTFZm7Xxh0qHveBNugMXpykL3/PIg8kApMYOhX6q91yF97E6A\n", - "8M7Z7ezO0P/J46GdAg+AAVoNTUtIdn/n6VaNhBD14AEAUVZVKq9kukJJ0/74AAuCYE7g/C6C0kEf\n", - "4Ri5V9iAlB7I6R/2vMfL3w/6mRDzshKqPzIDweAAEJ3Bv3Z1nq0vW/YYh6iXW7E4Evz3IwxiX8NR\n", - "pHia+f+v6O/hgJiU9uAkAAiDit05+RbKCtO+AUAEBqbtD25TxNhSveDOMQ+zPla4Y/H2A1GKIVQy\n", - "BJep/v5wzOHJoPrAyKBLusqu6IWgCEiZioTM4gx//hx2uUAHdOe4st8kXPVwnd/0G+nFt6L+f/7/\n", - "D2ifEiPfvd+QBfjuVJHeafGK43xXn/+w9wAAAmJhAUeACQAScgOvC0SJDkJsDe0AfV1HTZ+uyul6\n", - "K8a201vkK+4ANins9fk///5CPcgB5gA1NuwTsuTX+zCAxAUBI4AwqXpqtWmLLIv2lomaBimRnL/u\n", - "4CwOCxOmV1+THCDRiHv9GgACIDRGFmPk7OpgAkQDGn/OEXpSQa6PHYDTg0AANP4gFpK1v4+BDBAF\n", - "ToEAAVwaaYKHLq2Ipn3YKqnWjAymhDw0HzKa0e0j6kXn6hsuDGF10wfvZYY0dgb2JWj92wCoBBao\n", - "MCLSKvPnpj9/tqZgrIPGor1rQAAgGpaBUUFRNIrv1bAAEEmWgACAqBUA8+UAIBgVYV1fvSCPfbpb\n", - "RP0MAAEBsABUwmCJCEABg9pSlBKryQNYXtFZq//89oZclDGCBoKLSWYXXAaaFDq7g476RBb6C0HM\n", - "9eAdU9v/gDUcrZ+3/g5ngCgC4Czqzne6vxAalWdes9IQIiQ5AAmn1X9f8Kh18aq1sMo7Ns3+9oSk\n", - "wD/gAe5D12kXTf90HIGFsy1DEABAyjerOheU/3lKDlJgBrQBZCYvH7wAY2k3qd+OU0asYDXZNNp8\n", - "b9aRyinxjjv2Gi0cnpcgaPRju221Q/4ZdOPf3cPDApfl5DYAe24qTk/8b8AUCIIQ4LYUwgQGynh3\n", - "DsIgUeVQwfE2qVnfUba/bt/v+X+AjCXXb/deYr+009s55EnvX8lpJaJsc/nA5fXqbf+gGQya2TT0\n", - "ic16ZiL5sHyNPRKn+gZ6EELDxxmaTf51bUr6IKQul1P+Hs7Kj1XcgdYSjbblrYn2BCM5734h54nt\n", - "/lm1LOdFV813//tJAAAB+GEBs4AJABJyA68nDHgAcyuYAAgBgACARN0AA0Hr7GcAAQEgABASmZAA\n", - "oPEGFAAEBGyAACC0AAIFd5whMRAACIQcAQxIzIXPB4epUDaXz2AFAD4FWUYSfVeBaYADNxBiIzc6\n", - "9XsCTDHJAABAPlAAEFoAAQL9aGgAAgIgACArEAAWCI+/D6/SEAuRggADQGFt5SQ3C9OalxvfhcwY\n", - "PBxgFMlXg9Utsj//P89cB2ctM71n4PMBhLpdJQ/7s8bBz+enYQuXiP4IHjvsP6oSGoB2dg/wkjB0\n", - "oEOv9YAO3rS5/9t+OZ8SoIMNfAXwgsGGhZOIgmZjB5/0MJTQQBOQ/g60xdj4hTn/BcAimA7Dx2W3\n", - "Dn/DPTCHkwWTiREFTEXP9/vGGYchqTBJMbQ4clLvwwgoyBAAFQ5pb0JiQbG1pb/9wKhijSQei2Ri\n", - "TIu//89STfn/mf+g+73T5k/75/xvDfgAOnhy5jFSupP4wuAlVP7yiwfvf89cBbkPdMf/5/+TjYA1\n", - "epG/v5ngM5PwC2K27YivlDZZv6f/AC3bS8hDjVAaaXMcxziQvH//3YCsDGJHI1JI2iy5Yj/+4GBX\n", - "JYsRPEtsRqn+CSQws0AHptGziQuCFt9tQGzcUb6i/voBF8pFE9HQADW/qdv94q3Ko8Cm/Uftf+vy\n", - "ndUyX/1EgAAAAixhAIfgAkAEnIDrwmHcABAjmCLUtRJBJCySCfgAWQ7SCiEi4dl3Aw/oGEkEtNiU\n", - "p6+/+EBKQoC4AF6gvFFxpGNOe/BIzab+GfABBEuK2x3ZMFYmQd//B3aML0RK0JvvCABOKsANgbix\n", - "Ev8XBd0fwf5BSWa/k43ACrJn63v3IF00mmTMm+8AAEAsOakCr6KJTZ6pu3vEEKoSl531Z0Xha24M\n", - "SkSiT7mx3IS+kYTkXwBAhCizGBdQBvhSAMTCKyHE1JC1NT4fEAdGAo6VxD7JJYsV7wAwCuQKEU6S\n", - "63vZBkl/CEXgRHyBLh87BYLxXth4l2BrfCXolajmPAqALEtVZv0gBRcOkq7f/FAaM3myphmJhqCB\n", - "9dIBnUfmx/WAONL9eqs72bP/N3cAtgAlK+Wv0rf734ALZABtq1DZbf/fNniywrAkz0AM+2yPIG4I\n", - "Df75rAAEAkAAQApUFoLngxTT9X4hLbC3k4G+GQhVxpw09LGbN/xabAAD6AGDuiSJNiZJAA7+G2LY\n", - "IH7i8BtyGDxvusCYRWn9g3xrGqy+nz/BBIQTLvk1IR+vwNciYxHo3v++G0n54erGpnrxQBBuuyea\n", - "sksuf//vcBlkjQk/feAyqG9Do4xR+C1yJpTTDAABAbAAdMJi6bHf9gCYRr+CQL8+1oajNpoZYcAG\n", - "qIPURKkpvgwOSEAhfLNB0D6CgPuiFMv//5gu2Sm5r/1vPNBloTnhXusMCIQnTQgrKiQ/7/JAAAAB\n", - "mWEAouACQAScgOvDHCsAHSwtS70L3//vwABAwTghXZGfHyndO+BeQ2kWxFet3AAIECMEq6fl0iX7\n", - "tr2gEDMlRjvXATt2P/u8AAEBB2IABm0Pt2XIpqd8w4yA5dUS9NJpHgBg5MEtYiuygIKfs4AFgIbY\n", - "WUWfv0gSGpMOSlCYnvW//7WFBg0E1B25BChzJp7p//PG9JfiPxuAfWUcH3nAecgqrd39O3d397u7\n", - "uClg0tPzM4cWn0GGLrtafemaXwGwp5OQ0VAw1mGwAHDzG4AAgAAg3+JH74gi/xgABUBsLlib2C3o\n", - "ADRqchQMkVlhdqCtzAADgABgBgQltWiG9sYx1a3mZGJwBlfWNA8coYgCzlAAQGGscbEtVa2/GAAH\n", - "Shipb/Rg/SjsXMWcKU/934y1SX3KaA3VhhlbCAAIj5YDAAyayH4TOgdL8p7mNJ1uqYAFfPYAVe85\n", - "l+ZCYCQthwDdf+xUihSMwJnfdgpj6TUpbzjYB49yXhm67ntK3Xndu7un2gXb8t3d0ULPj77fH/eH\n", - "ollpGd/77fP6dXcAAAHKYQC94AJABJyA68MYgbgm2n+gBqVtqxFf3LkpmUxx6YFntbPpY//97i+j\n", - "pjzV7vsJrz+SDV+9qV+MlX1734Ftf9u3//eaXfdtv7H/Br7UH/fmkK0/OhH79f4JQaCAALBFn6eo\n", - "XJr+UAAJ6RKbEByJlKM436cdmf3/5wAXy/qu///jhv6M/fRhndJ8T4R/U6r/3+N2+TjHJyn9eBjT\n", - "eKX0bu7vY7ez/s30fsbu7jqRFKWzPm8+Pv/jbw/w09iRvgAJDAowhrLqe4srOCTn4B44FIAIQBjG\n", - "byh7yJf/VAAAgI26AACAiABcQ+tfCKHeO1f8OVEomqdcA71LYW8jsmOo933CDcQqNkSsKUU64//M\n", - "AACAj0AAEBYADYgtGr4DJneV6uMHPioQAKIcIAAQABRKwFmfELKVWY74AG1uI1pD+eEvL95nuwbN\n", - "AKnrjoWkASjGmUoqeIprX2kQAHgy5DXjgj5muYDB0hYFuE4i0HKAIMVoTYh5IsTKEPG7GGCAAICY\n", - "AAgJxEAAWHxujd3fxhmHIakwSTG0OHJS7BjMWlLAD2aNtRNF+3hW/biVAsAEVmyNlnvnBkUkZ4Ti\n", - "9ES8phfq99M1U6nH1bTng5gAAAAKYeACgAUcgOvBvAAAAaxhBvgAoAFHIDrwww7DUbR3AAoIHfcF\n", - "ByhMTvSKEIAHMHN6ENgquD9gHVDhYprVFIwPgk7O3hGTkCBuqz3fAAhSHGzAAJnABQQE3Ui8yI3P\n", - "+BCYawBa4UQ9VYRhR1KZgAAgIAACAqABgJy2jDFk48Mnk8XPlC9/jAABARAAEBUADwRlggCe8IAA\n", - "QBQGRwAx7fXW4QJadh17itQhwYS5ltHOUjCTCalutloAFNkJO79iI78AAwDnKCHThJL5NR9kz1Y2\n", - "8KJ6ieY/gxWlC00TKjxrxyhjULbD4YYNK02ELFjkSQgmwN+IIoxKkGiOqkEWG1Q/GDOKS1ZpqyRq\n", - "KqqIZyIBYrpucr29tNe/iJsxZ+jOvYOCIlV6xafvDUSJC/9mAAgAOADAbFCbMDEXrZZoAAmExzjq\n", - "OKQWFpsOM+AAEgAEiCKDIP0B2CAM5HgAIOgN7tCSRtg9AXXOz+iCBCVhouhnyvz/5CGSSvLW+thu\n", - "LKOXfd3BCSpfGciv706M/pZHl0mbrYN9iltZUd/SgithNKpD/dfOG+8dOmmpv0hIYjDTMKi773it\n", - "oe+inHD/cAAAAVxhA24AKABRyA68LxM9L4Ag8aO/fwTPD8aAGcB6UI12xEv2IEhbgAOwBIKJA/lj\n", - "DtcbEGoj4Eg4AFgQ1gPCa+SmRQ1TOHlvDE9BgAQlMAmGLF/5Fo0OIp4v27gwX1t+uA7ogxrJQa73\n", - "yZGMto+a0KwFl0+Uhq/9gx+8TtmY5G/vPQ9r/kvR6+lJX3Pm8MxIkMa2NGABaYXVgSCNltH90BYY\n", - "A1hOUvVTsIVs4v/+EAozmH1hI8KgA+wREeqnI1ZbTjgl/HUGQA1NtD/23hiAoAAgBDv8aqw5GpSS\n", - "Kqv4uAieAAFwZ7gnGS0lFbuc/8GAEgCAgnyMSFb2K8lpn9oAAUA6hvYNZjxLqv794CAKYWJk8kip\n", - "TSO7rcMAIOYFGKztPHYU9BmHBn/hNILCG6UV8Q/f++gaKCwbyLmcTP0NeGx48nHwHvr7FHXi2eS/\n", - "sfPRSniUua94ypVD+8sDb3AAAAGSYQFHgAoAFHIDrwvw5gAJpgLfKDvEEpMkWvpjFVltOIFkdMPM\n", - "pjwBV1Nr73pQAP0aF8UsIxf/eX9iYmIBBABuiC9EQpCL7jGWUtjzhTZJvDGogAIECJ8kIC/NdmV7\n", - "hJs9BAYIgQgAEQBLxwW49miCjPSKyEDGIA4hAAEFFgtgIFUiFDfRwKZT7gOhJqZF+AGKzr4CMdXT\n", - "x//hClQFl+zBLv8w3ABBeioWlhNtQ3lfp+i7+YZI4jIbkyAv7TjeIbNbD4m37zHrCp/gQRJ642L9\n", - "LFlbBBOw+SUTDmO32AdeAPAq6Wr+f/huAPjGZlIV2FUf/v98AUAghQxLXiVJLSs6XDCpu/AH7Mh2\n", - "k4nJ//W//xAegAMCyBmAJUWkk0D41qL/tmMquc6lHW1awwwwAEBg68LHhjmijDB0h4dwyn8YFWIm\n", - "IYAYIwYLZ0zNn+WlJ8/AXbMwjCXNuKMRNIvRkvUDw0J/Xha3tZuG/PcAKmllSe+/vBz55527/O8w\n", - "kTYciXfN1g7T41rX+3ypBlKnL275uebgAAABF2EBs4AKABRyA68hf/ghPX+GmBOGZ5hCpvBEd6Yh\n", - "hjbmwD2yQysbrwSDszQPbl/Xo3pUNE/AgiT1AGyp8/xRbt36/gC7U+ngoTef3ef6iZ6wBsI9lh//\n", - "n/8SoIPXngBCFmyM23qett2eDlo0xd2OUlYokEhRv7/n4078CDqJhzwA269IMQkAiAg8AGRbkptf\n", - "/XACabaV3/++8bABQ7vtPLv/2gtijR2H/4U/4H5/6nc9A2rP7fh/4AxDGajCTlljOrMph4AX62vn\n", - "n8QeLcB9/UIwBmwAP1zPkVpwKAstIC2XtxPwAe7/SZ/MBilJEaNW//115/vXZPZxL/xGFud0//AB\n", - "szAvB8Srj//7rS1GDAfwNlO2P/y8kAAAAhlhAIfgAoAFHIDrwmJ8O4ACGAT/CLEbGrmrETdjcACy\n", - "HaQUQkXDsu4GH9AwkglpsSlPX2gBBEkFboR2TBWJl/+Dq0YXoiVoT7//8KAB4CiUgAL1BeKLjSMa\n", - "c9YG4sRL/FwXdH9/gkZtM0ZJXpv1Ew1AC9e/sRX/83bSsMcb1T7xyzHx1e1gZaAIVABwp775pvfv\n", - "wAcFvet92/vNtO4l/EcwgbeB32h9SgYiErNf7A3pTrDZ+ux/FfsdvSN84BykfT9/v+bWvs0V34AD\n", - "oMSTzgqGYnyp4kVv8MABC5xMjZ1NQpsoB3QEDTm23989AvaKt/w+Bi38p9/DSqs7be/V5bfUqvGi\n", - "MboZsp3ZL6pXnW1L8RExOH/QMACjoS+/aVdvDwwAEBAiUvCAv3XVle6TbPfWBHABwEksx8weYLm8\n", - "8MWUIQCwdjgrJ3/n7SpNvoDq9RjxWN8qAYomD8SHcf2K9gJxD1VL9mHPFJoNcK3bzeP70iAUWLwA\n", - "4MJR1BYuuTMe6Ofv/9yMAAEEIAAQFQLBCWAEIMvSxSjOdJdTywkDLQSBchvdGtDnywuHn9ypYPoM\n", - "vfb6BHk4fh+AO/r8PfBBhgAIECd5AQF+K6ccXaLl0GxQgABBDtgAAgKgRAEOX/AARgiClluGLYTL\n", - "svOM1xu7x8ImgOABoik3JXEyJ0qNdzbvch1OSBiZNItLY9Ye0CEfrdW7fXhN31dvfyQAAAGKYQCi\n", - "4AKABRyA68LziArgA/WuWzT/vygfEbSl7n7mHCelEmqmbf/vfCBgcoVFWtF0dEB4n/UDeO7eQJTv\n", - "7/tGgABAFAffEODVmns5L9wQFWUK7ADj1rdf1SAAQ8VSbRlNVve7AB2saPdCT3ZFmhXnLjjF2V7v\n", - "cAACAkgcCFly0+3n5jZDoEg2lRUD53nkAhjBSViXuSWk3YrpBCcI5p7FJMTr/9cAACAEA5VIMWUK\n", - "QJ/OIr/YMPFBSZxzI1v/zwznHJX/vanrcooQQ0G85ZC4WYSpTuv0BkfFcWJvv3/9cu9N3QIbavM/\n", - "YCxXW9NGX/3zlEneeOgSymdHVgaiZ6LHADdkRur89+ABWICfzBXkKn7vlLaC1eHYAWBZev6Jh/z+\n", - "f1UQAHEDqQHkoC8i2p8cVFXwMH7DYc48HECfHjIfFFxX8iMR2Q5u4yWLWe/EMAfYcxWrfK4Zg0WC\n", - "ruM8t2y9GH7x4nYr/x//aISs4eu2y6CaPkA9k+DI0IknnEHovb0x8M4v/33e8sFXuAAAAXxhAL3g\n", - "AoAFHIDrwxEiA1AA8AIHhMKSi5R3v/20AAQHCCQrnNDkHYqoC4hmmrUV2c1ZZn/uAEA4VTJFtz/S\n", - "sHl++CmRwAAfohzpHj3bAGZPdyNTa32ObJrX39Y97bb39/8ES40CCofJmp66n/6ahESyVjavEMLX\n", - "jbsDznDT7x5gMGqq//v/4tFfvrG7w4f4azjfAAfIAQAOTPhhomxwuuW+AAdBiSecFQzE+XPEi8YA\n", - "AICAAAgKgAYCMt4BDHDEupspKcKkxH9SNCvzIIAAQCBN5HB1ZHSn+G5CUEF7AAWUAcKPp6lARNBz\n", - "+ZvDOmIOAHcpfNgurtJgcMIHJggADBRWhkfq9NCjTquWqwOdiVjxi2aM9GZBtmzs//AATRm0Jpyq\n", - "yUHQoheOPLXSO+7gAH+IBWHhE2XOAIDY0gQiwv9v8GG/C0AHQI4hLFGmLJGIqKoht9/+4/wIMvyx\n", - "CS+cJdTyskGGwCQiLM70dWWRV4cy3o6579f23yXJ/3g5gAAAAAph4ALABZyA68G8AAABi2EG+ACw\n", - "AWcgOvDDEwhC/AAaAF+BgJ6oV9QKgjurgpcRcBgYAwul8QRifK/f95EIZSOKOUABRTjTguM/gAgB\n", - "UlqNFBdBNSsfrBX/28edoAAQgrAABBreAoACOEFQAOCAm37Ay0YLCNpSSyOfxF9/diuAmJisAUGs\n", - "ADCPU3pH2hBlsCcnzWSbQ837fwKTkaMXVh7Q1HT3h67uWmQIBI0vidx+FvhBA6kQFsFj5MQTPP75\n", - "+AAIIQAAgIREAWCIkf4UDhW0U0Hgkyp2zWkoYQmkEAASCLW89afkG2wJqYx1ftaeQ8xc7AfPtNlg\n", - "GAs5IaGGsIjfMuH5qYALoZLUz1c5AEzSqOjqr7ukeAoGcBiySOcqEB9aCHvAABAHOANJRryoDXQr\n", - "bSLk7wAQQUEYeZPEF8bKN6OfXAAIEFVLeNYYWIJVHOMF2giNU9gQEOw+BAHgAmdsqQdBkf/9v4Bg\n", - "zivADgecap+MotMw//eG4fzgBA5RBEvxIjLwq1DFYFv+DttbLTOeCXZnRlmLop7gAAABYWEDbgAs\n", - "AFnIDrwvhHQkSeGIAF7eAHACkwDYUZvfgESIWzMjGRiIALAyHIFfyrSURbVh8wZTNllYhgq69UmV\n", - "Jmzu50gAAXNADhx0X0yEAaLgQAAgBjBnUwxgMC6Qw/MAvb0Amvcy/AX8vSe+YA9FgtsPNyY+9pBC\n", - "EdWeBLOMOPv1iBGGYACFTCWPIic9EpG3JWbUMOLwB0CuPv9vYGHAbr83tvYYcMxIg8D1gVfABZox\n", - "1IlSOnv3xvAAbwSyek1bv+voLwAk4OvKI6vEKYWl/4wAAoA1kyweAAkQzF2UZLVby/9KMBioOEUV\n", - "I/SY/wAUBQPTkwPppk/kgteftACygLeZyg5yMzv++CEKKEwheRUvWwejcTYYrqfv55cFbZXYy7/s\n", - "8vb9n+8Za+2HLnQ/M//W8lkwaQzvOYLQA4cdoACAwhpkk2VM/6/4LGwANCW2AYNVUg8aHIEds2xv\n", - "1OruGDBXAAAB6WEBR4ALABZyA68LRIk9N4Ad3N05zuABZFk+3chO6v3hzwAGwMUjcPMAQD/eWgyX\n", - "wfsFnBkpYIrNIspP/Kk7MRDr0V30NBsYEg3wRdrouib9z2k0AlQJBosglpN//S/miJYXgAWAZAFD\n", - "cJUWk3pWi//rgxHl46XHvGzlOX/3hwAHpllJvDNC/AY2mGACOFl0wDkEcIAAoDniAJ91I6lLTh+i\n", - "rlu03WUsenTUACuUOLWnC1HozesfIYBVU43+lUSDkdWv/ngR3AAEAmkLIAUHieyXfPUNw5k21gMA\n", - "AAgJgACArEQABYfILmESMNm73v8/wKJE4/r3va3vR/OHUgIo7SXWUhfXuoLQIPg58QQL4ADA0QLO\n", - "cbRJktIXDgBFxwuyubtQJALUBkvu8M21beARdlL+QC79fS/aC9Nr01//v/lFwNcga/IyEVlMLiXJ\n", - "WpMMoC4G1sIv9RTyJKlL/99ppsm2u+f/5fG2HL5p/he4EEAeweRVOL71pOt/neDLQQJHY0F+Nwun\n", - "BjoynNVE7D8A8C6s/h/2Bpiq/SrJ75W35gEg0zWf//7oBFAYCG/7Nlid5IVfriHgi78bD+Gb9asz\n", - "HjDMOQ1JgkqNocOSl34YoAhMzY7XF637ichrof9+vswNJTCqpJOD3jAUuAAAAXJhAbOACwAWcgOv\n", - "Jw54ACBKQBzUqSAW8ITeFQJAwhAkYoQABgDiWuAGcihQ+kELzgAObI18ODpFDVjNz4b8rYAAgUgA\n", - "CB3MgACA+A7et0IAUIBKQmHnIxshee6F2SA2wVhgmKLXm8fAg/qnbUTjYAPk3vlXv7M/7ROI//VV\n", - "nexhQ4ktTYH+Mw1OQEH/Yk8GR7v63Ai/76gX860t//zvwYDqz51/hs/Xf/QbuDDIAAklbmRtfUsZ\n", - "ceZ/9uDXlK2//26Ps0jNbhjgIRvejWgD0rZHJH/bB41ukr/xtBvabdgq/tmuZ9YJHxzhYyx+JWPE\n", - "rBYxRljFGD2zJgfd/u/UCNM8Up/zcNfgCFYwdzp89xIYyH78IsMImRhAAIxJEISJ442rUH+IbKwK\n", - "Z5QPUKFZ/wz8M4h4hlUoVFTdegRjNdGFYcB0ILM1P82w73Odf7cCRgiHCKIJPOgvj/WIX+vD9EdL\n", - "4T8HfuzzKfGwoAdbVGn/DflgAAAChWEAh+ACwAWcgOvCgdwAECOYItS1EkEkLJIJ+ABZDtIKISLh\n", - "2XcDD+gYSQS02JSnr7/4QEpCgLgAXqC8UXGkY0578EjNpv4Z8AEES4rbHdkwViZB3/8HdowvRErQ\n", - "m+8IAE4qwA2BuLES/xcF3R/B/kFJZr/L/EYkQeUlwGiU56fAYJWL0wGPf0/5eCCcMBj8ABoOcEoj\n", - "xcFMOlLu6CLAAWfUFHCqxNcp/e/AAcJoACwlMBJwowWZM//hLEMBJQ5X4zlDwFlrJIf/8ISurLOP\n", - "nUR/9hJXvvLCHa2kbH0ZCuPuIxkZBp/80t3VEuGNj4k0Y7taRDv/+4BA0ygOCPlNerXzlx/34ZFh\n", - "hwATudt0Cqy4i0xq73hClYpp/4EImcIAAgByRAczBHLIb7oBxiZd41Kphl//9S0YAdBpupu3/4DW\n", - "ACACksc8EPE5TM3/9ahv2ELUAHQRhiGIMEFRtBhwUu5CIlVA4e6TR/negHA3AtbRWqlZGDwxEiD1\n", - "gBRvtW6f/wFMkv82chayw88NfrBiEZZ5oCgf6y1Gi6wYYxISTKzeXosd/+3MEbFS7PvdMvgIyBZz\n", - "FyXTr5m6AAK3QCHik9Q+/g/l9SyyQ9DDgAIgTGCOC2FLIPDJTs7Qnkzru/XBLuCjUoAAQD7JQABA\n", - "TAAuIfLg/gBLtQ2KiLtAKAICC0lZPRzB/mLP/AwHgQADAuP4P7qyiYA+EPKrUo8AuMrdX7zA2tms\n", - "hejWo0TMA+jMbXNAMSQGRigKkjm3L799dnIP6IJXEha3WvTTkAAQEwABAVmJAAsPk//wAiF4BblK\n", - "IYO402fDCAtVCBdVcs2Rivdn6SaHHauE1jX75YACQZhLqLRVe/N24AAAAdBhAKLgAsAFnIDrwvEi\n", - "DxMOBDAAOGU9HTeJiamX34ALvC3kv03f/0oWh6AA6gh4iRUYShB5X7ACqEsGTNXWPb9B2mTTs9RI\n", - "kocK5b54CYBw2dbuKJDHnE+JHwAAIAJwCioluCKXNVvfEePMGUKW/TT2kmpW9dgQQvh6yRfnn9Xw\n", - "fgAOAIHNwoQmjhFPnmFf+MAAEEMAAQEgKBGWDvQYDuaAMbcnfr7nNl/1AI5i8Sb1r/11Ob8quOhS\n", - "ruVttmWRkzb9ZoUSomKj+34CiO0U2Ro4UGTlgSvsXfCmYwW8QnztJEqfT/g517uH/F3/wBzgyiRC\n", - "o9Jrr0oJ7lv15dDlh42dkn77wzz2YLKLVYKAFkxWyLbxMOvr+jKhsABxIYE0jTfSsYcpz5TZJU9o\n", - "fhhhMF6Ek+bJrFwABzxOwTCTsxpABlsBw5/58gnszrxBB1oALLHN2TYNwE13BAJe6AUnRGBEz75r\n", - "/wlozO0wfGLDAAWmfESYasi5HNbLTdwQAwsCAAEAJwDJCLSCSaCj7UmTngISZ4p/tKL64f/LGVM4\n", - "qQn/cxKH7RgGYO7WIBZvFGR1/jFtwITGh7shsLRheMneCGYRyQ7Ndz/1t6gwVq96P5vD9wAAAadh\n", - "AL3gAsAFnIDrwxhAK5D9GAEmRToXUacbCp///AAAgM7lVAABAHcO2bzzndwCHRb+tnwQktxP+4Qi\n", - "GsoE4RXTUWoCmELlBIA8AMa4uvTeRH7e8RwQEAWFfbs2sv7Q5uzFBdzhnuh8DrlO4778Hobim0an\n", - "qG/b6j14SbbpjuO+6v9zsGCDjAU7FtcNPDQsb4ALgAE7AAoJCDydeZkTgACABKQwAF8JfOyLCgmu\n", - "fhD9bIIFLCM10beLuAACBv4QT1mp0VOYwc5P1TX0Vw5wsuk+gJKm4mJMBMMHZNEhi5QTsTL0kPwg\n", - "1y0EdfzLyLoBb4CLRg6HJhjSgDIDxIUIPwuACHCAASAACASDgAVl56JGY4DeBdAT4tXAoNmGZU5P\n", - "9pLDVEUcuweAArIb+EE5pPsdxAS8B+JANYzouuATARdKIepHzkd2zQCIMSR/4QcUd9UcG4W38WwA\n", - "BBAAAEBCZAsEz/nv8CYFCP53xgMOL9OUr0Phhg0LTAUwWPQJCCbBhwiSQQABMOlIxMQUpjf33937\n", - "2x7+fNG0YBgL9aGh8pELZiIwnIUGDmAAAAAKYeADAAYcgOvBvAAAAXthBvgAwAGHIDrwxAkw9Ro3\n", - "eACsYm+OOVz75wBQEYQ4QJqPqNmRqKcynDAAQBiMaO7w+f4kM5D5+EXGNQADDj0qOhQXbxrd8ITh\n", - "AE9kAbcdREf1QFcEeEUdPIKqiYApx2sz/dAUAnAUKmRSEPu/3ddqzAkQtzkF7MHERVvwfTkwABAp\n", - "VOjgACBuAAIDNQEwawAAIBsAAEFoAAQKE/PQZmTHAOFjKYRZzF69//iAvCAAJgqlO1ixI8/A7aNg\n", - "lOO1C2p70JgUE3/5B8i6BSHBKDx4w+SNBhqJBiGPAAcBC6bsMOHN8yyqS/fASgFfyhwTmuc2MDUH\n", - "7hiMOnmmKEiM5wTCv8EAARGIeEKI8fAAIQNG+/hYAMzXWe/xhoUnma0UK/39AkQAHqwE1Sgt/zwB\n", - "jpa/n6dG6AqLWq13BiFo8AAQQwABAWAgE0zABwxCxaVN4WTS0qvZMMP5CKM1HEnNNGfWZVDCqggF\n", - "ynhLGuu1jxm9GArjAxS6as568b83AAABoWEDbgAwAGHIDrwuJ+EQQh7AAQIBDQt8UE+HLLhS1xI6\n", - "fYfgCBy3jCoL4aWWxFzZKQ+AIDB4/HBXCgtXE282p2H5g3KFNLCVbpm3SpF2GgMAC4AZQwewSjif\n", - "29kt/gyNUBYBHABoy+5aVAdi0VFv/n4RRvkj/egAUhsvn2uVslVbRVrPH/3AXBOVmVm7w4pCsIIL\n", - "eBOAAIAdjexwE8FDWJyKf/4PgGMaeKgqSRaqZF41/8GHAEihxyVGKMrpLr8UyGELbCTGs/szTD/Y\n", - "N+vff9/0b0O90U5wO3HSzInb/fhmEQiHPABcTIPOalM7nvAB+rd9JPfWIEgvx4ABQAYHFEwACOJg\n", - "IcRWcyDL7DPgIGVJgU09OuatV/3Bhzta2794QLOwQABYCiF2gcYLFBidlCdgLAY0xez01uuqOJmh\n", - "RYv/r3wMMG1ll4KrsJv0F4IWH/aEisW6o15ViBgWmAACCGAAICgEAimegi8APbIDDpZQqoZ9/f8A\n", - "CzKLqdf5Rinuzf/+FSQQAirXR1sNZYgvP8tZ9BiXd0oYtW2fhvvfHD8vcAAAAklhAUeADAAYcgOv\n", - "C0IiT0p/gDI9X/tL/E4gSGpAAgBJHsGbORPxkToYrYQonBIdGpAlyXuko3OZQh08QLiNCXT0+73z\n", - "gtBU8plvUIEmh/7zDKqikpeet5bwQBD4ADj8YAg0WoimcNTlQX3GGOvMSGqRHZV5WZ22Hs1YBOGr\n", - "WUxgvrYKQYBKoEAAIAZwDICjhqv7qv7uxhkzVtrnz/8IwKrDnEmlQepHLk6Z+aBxZoyNcrvUVNQa\n", - "31f/NoDCAm0EqkiBu3SszUMEq4U8txqxHjECAzAAcJgA0Hk0FdYL3wUCv8H/RJgACBSqVHAAEDcA\n", - "AQF6gJhhCbMIFXW294okrFb/gw+Wd/ImpKfvBhwsf4EESev6EEbP/7UL4AMMyyDRnRP8ACwQch6t\n", - "kRp+mIJ98EqymWEAFbNOLGm37RxtbQP13nh+BVwOvI0NP/QGKrcYfF9vz/wBAATjtC6Us9C2Lo5x\n", - "aqFkaIyOYCYgM64QpBInKSiPhEAAEAgivwoDK4Ect7xWGDMwYAlIC2x3+kKijnAASC4me+3/FINl\n", - "3mjIvd672xCdcMr//zuxoGVRUe53of8BvRc8edk/vS+cQsIY2eUPAtKGNZpgZs+TEEif/X5dp+S6\n", - "NACANl0CCGDAfRrtOajd9wAdHz+jpWv//+/hJGQQAQVxdnhzmczvVdoQAacRdq215wAnqSOhxrJF\n", - "ZGQ0tb+68QRANdqgJYIqKUUwJaAFvAg2SSi+p7S/d3N5PQO7ar9/eG+AIA8FsyCjQL6zwt73MbxE\n", - "0/q//3AAAAKyYQGzgAwAGHIDryPAgQ5wAUAAkYAEHCTqZcQNHPQPnwBm8vu73AAfHsxXJuVGx+48\n", - "T8CCJPOhfGzNO4/gl/HvVF+f/DWAAgBFJwC3CEywdxto/DCJkb4AFzSHGeONrWP3/He9g4ERI3wA\n", - "g7OT4XieE0HZHfwOHAhGsZfhW1nTzcNceAHb8hpg/C3ElTu/lgA4RAo3eNKOpQVa2KvfPGfghoVP\n", - "dDxcRRJwOjFEdabJvDiQX3raHqI8jEGYp/O/f8r6AbYeE5f/7yDiC8UkP7eAF1nh7I36/64hoAql\n", - "bMiqr0mxL808RQegSAwpBjg1Fp6ERTLb//4Hlqv49IWxP+BBh+l2JPus+dQxkC8fAwGg6KRmFKjU\n", - "0fIWBckVDZX//qa42mFYGmOfdxPIxut30w1izRJYv76BKTbKf9/wBYAsBJIpvDieYgQFoAHog+rg\n", - "7vtUnv2g/4AwAACAmAAICcRAAFh8niCyEEivT3TzjGu0HOvEeKq94JwnF6Il5TC/V7zPoNQBIwPI\n", - "LS8Mw/MI18ZA0DDoVp20ykhLf0oyQ1c7l9XvhA/xAoMbwALAMTlA/kWsnVKnN/2wFB5mSYF35VBR\n", - "f/wYHzMsAF6THSR3jf+eA2W96lk/nHu8OeACUANTABBR8drYPmr0ARAR/ABjarekPABBHkpnojw5\n", - "wAWBgj4Ye7kjtun//3AUADBgrJGuiMuPFu7d8EJIYpWzArT+Ofxf0703dnLAKD1f1C+5H/oGx6KM\n", - "7/eaRAg0RFW7amH/6ZvTa798LocBriAzNNA8w/QQELQ/SuX298BHLyzR9r+oDOSifFzUf+9M0mXr\n", - "XIACAiqGLNYxe+A9hWP7I9qgnxEzSd84YC0AWGQchaThJMbQ4clLcGMFY1YwAZ1v3/+eMYQs+cGl\n", - "JGeCA9M+p3OPa3nPLxD3AAACOGEAh+ADAAYcgOvCgnw7gAIwABACVQCYE0IVIUIkaEYAFgYRiLk0\n", - "LhRJKhJ7/AA5DAFVP/KgF6/8MP/gYAAnA5EACkRmQPFCNI3vcBnFl8wlMWJmqr4YQ82MGkk+Hr+X\n", - "8TyoLzNWC60BcAA0AZClEIfautr/csMAfc6a5wwBTtOr1zkQS/mjQhEAvgAxiDIIvKJ0hvXICA54\n", - "KI7rVcY9/yw/eH5gH8JRkEyMq9+cuALGQhcXy8+m5HQlTaOJ8C7q9H+4PqW+6wDRxPBSJr1RxEQH\n", - "IACZEMroYyOFSpSfYW4cjBbEkyWdN5DMAAEA4Ac8MTAgKvAgADIxRcqlSbvIRHo+XuNzykFXKZMt\n", - "59biOQZQjEkvfgnlKIzXh9DRI/4aMBmAPE8KedTldA9pAYciNSMICqmBA2MQIDMABAiAGQEhM34u\n", - "xebHmCcdhhqEvYSzblWOO4cDBge4LSyljlQMtDQwxCIQ1xAV5cwAEwZApRIQ0yRG0LkqKQxkYAAQ\n", - "DvAAcAcHxAx99w/CSaCACcZpUoPxxYIsMbRxao675sIDHgH8DaTQaQyRf7xS/rERAL8AOfCb6PKb\n", - "GEJRr+AB8RBJjctYp37vdCDZsIAuR8bHLayt77/7N3OjQlP9aH4tRvtR/7AjLXsWSpv/NCGEZhCz\n", - "KS/JS0uToZFGTGnNNKsod9aby+kghTSnckb/v/DcAC4zEjLaoUoo3/14EhQHPaEGbFjOqcf54QWV\n", - "c/AUDFi6mKlXVVLDD2YeCbgAAAFmYQCi4AMABhyA68LwiGA1IAIAOZlQQlTUoJYpJhMaGeXACwAX\n", - "m1l8Z1/5fEcSIiA94QnhyMLk4urn/gQBDoHLTLQBcAAmAIDyzfnhQywIAAmMUfZdlX5j/e+GRxJH\n", - "qV/qfA3Z3UCQ57/8ACq7mZ/lYJrQ1n3nQgJAiBNr/0LTJSIUf/sQIC0AFcjFeIlfJvg/gAWM3ABK\n", - "XAabLKlFDPv7x4AAgigACAoBAIpmEJqCAIi13Er0k//3sO4vg3tqa3gwF6zF2KpIxa1MfDDIhdcQ\n", - "F+AA7AKsGBDJKGI/a2S/+hwAEAxzDXTtw7yuSX3hAAGYECVqYPoVk2hAIKIQEu4cXutm++8luHsv\n", - "gAXK1fFTxpiAuBo5WZ2z4RpKNA8ntTy/+veFvgYhYtK2cMJpcTXwmGH0ZFo2AOAkSUb7/v8Mchoz\n", - "t/flL0GnSoYQFncRZb7cP/wXyHEzVyMFPe/FEt8k27//081dNwAAAYVhAL3gAwAGHIDrwxHgoD1A\n", - "YAHoharClXRn//5/6MButXxJTIbv2GCYSaysMWY179f4aQ2wAHIxTDuAD1fX2sPEmIhACQQ/ALZh\n", - "pkwONooJzn9X0AIDTNjljgUzIIABGIJAImu3x24HQ7s9RXz8DZgdyxgRKNLP/0AEBQ08+W5QFwzA\n", - "BOaVokfQf5RuscIC3WthLDUkKc/3+D/oGTgAlLoNOmFSihn395gAAghgACAsBAJpmEJ0EAERrZy9\n", - "//aDvHg1vqbnjCL6zF2KhIpS1MfDDRvR/H6CHwAhUGOqwuFihRIfU2aBHIAFC5vVYJAaUTs++D/A\n", - "d1SwAOAAIAIFA0Kq8OOGoICFg1ck8gwAKtMJKfEhTUvwfzI8maMxE5AiYRQgADIGFsQFsih4psZ+\n", - "Fu+ryR/nJhcAbByfEdaJ7JqYGKjGS9LqEYIQt4DEH+p0d0V5XCOqqfMGHuWQWoqVITff+i2maMxE\n", - "7BiLhEiKjVGzczF8WnKW+HV+uAWK9DMKKtRB4M4OYAAAAAph4ANABpyA68G8AAABBmEG+ADQAacg\n", - "OvDEHMM0d3QEf4AII8lbaRg4haAEMAGS8MJgpngwHpoAAQKEXKwAAgbAACAtIBIGDUAC4OAskBRJ\n", - "QqIi/k8f3vCC1oQjGcAHKDtLUnQYSyOYSs6feAK0Dp6xfgdmI5QRMcPSbYTw1B2MDmAC2Rd4dMYV\n", - "9mBgaGGm2gCjYrTkZ8EDaAOEAAIAQBwkhwAV6zRGiNf/1WWAEYIM3YcFvjDitiY8FAbgDgAWDrFm\n", - "XhXIiV2h9mMfkRiKyHMpRkqavwFhhdqzyKbktVLcKl8wAAQJwABAnABIRTAgSsgQmIld6fFt6YIb\n", - "u8tQ+j/g5ilEiU+fwI0AuhJ0mM6Fkylk8DcAAAHwYQNuADQAacgOvDEFIFkL4ACRkIrKY6FCJapM\n", - "G4AD4AZTDPQtM8lQk5BuK58MAAQCgKYPlnKmb4QR9wQkmDtgSPY4csEQazOtzUz/IAK3d3WKCiw3\n", - "vikT//7WCoD4FvsGDyAlLb/2vcBAlJAc+BikGnNSYNso35NN8wJWVMMAAEBwAAQJAd5M4AAEAQP5\n", - "YXJ4cwalaCMZI/3kJxG9hJgODXlu20fhAAxImr3uCqx3D7wDonsFADAWQAaD6WBAACAsAAwWVCAA\n", - "EAEAvpFcNyMCd7B6ExMNRWoxRAgKv38oggnZAZZ7ezuw9DUqDxBZcAr/RR//eGT+X4YFRcMQvwwA\n", - "KCgzRKqCRx02K1X9wBhhBtHgxFbxOvmQ+cvfd6MwAQAsg4qG1ZgKDKd6CZ2KFSNtCfBAAjKWEAAI\n", - "BAAcLKBxLPoh0nSB4lhpgkAsZoIhTqMJlibwAWqW2Vv+uasGBpQPwrkUloUvwgbTX7/+AwQhY8m0\n", - "WQPhy9DUI7MJwt/BJAACBSiRGAAEDcAAQF6AJ+Aw5ot9f5MuADwWbbeEniSGYAAIWwAAg4AALADq\n", - "ZucAMBoAAQPAABAMmQeGz/nPnfAe63wDOBA9S2uvgOCSlXvfWUJZjCE1VOOWcXbR7L1BTPzoQwsR\n", - "DZExvvhCHGcvApWe4AAAAp9hAUeADQAacgOvCwn4IQcnr8NJaoAYH6s7+d/QovEQ9OBOHU7EAFti\n", - "OSHI3Tn/rYO4YH+cdrTzTpoDANQB8pShSSfTcL/wyEAfhPMR4AH9bWp4p/y+BMJ7pF/XgdlvV/33\n", - "YEVKeqtUrr+GmJHbJCzjjskqPXz5lHvhl4tG1/v7YYEhbgAIAAICjAC+E4itZDgBOrgIt/kQxmow\n", - "k5pozqy6fB8BQBvjC38CpxAlAMon/QjIAAQNQABBDkAAQFwET6yShMbDSqRHU3gMOaLfV+TLqkTr\n", - "ZEmyFIAw4VfZ1HqCKIkA5N4EE2C5/b9GNimsQflbHP/weoEJW3IVQohCai8Ln83/z+C3gAIBBWz3\n", - "SQKo+CepUXFOiIaLN6+KzfABQqbwAO6MlmijLffgAd0YtXyRWr78SEAQYACQRAhRAS00RGUDcpKQ\n", - "xHCovMAAQEbQAUAaHhKxnr74AF4Njja1CCkjk3/wBR4xYxwXDmJHZf/fhgAIBDtnukgVR8EdSouK\n", - "QwAneEAAQOEaACUr5VslT9A7nQhVxy1uBCGQny2DmTpnFi09WN8AlkADQy5gnbeFv9qQX4ydPDnI\n", - "qvP9Nnb8102G1aKFhj//wgEA/4GrAACAKF72RwSApO/Zhr/+D8MSAV3ZVpMHip2y5xRgmH8hOI9G\n", - "EnLLGdWZTuUQcoiWLTfYE/FizoorsW/wAoEUQspg1bKZZlx1kIIisCAAOgFCS9EhLhbraEFLI2xm\n", - "nksV1//S++UPGXtYDUWS3eHaygiGxZDk7DVNcj//7yYVRhNmp8gUn5qv+PC0BIDkEAk2W1FFggsX\n", - "K0UYlRVlj/1sGPAALhUEJgTsPuIGogchTnkSM9A/5DMMptt783t4yhv5/hnkMpaZsIr+fmyMXamG\n", - "7B/73AAABGphAbOADQAacgOvI8Sw5ASPW/B8ycsBonQGLJpKXEAKC7/ngjiS2fJISMDcjQtEIQAA\n", - "gBgECiIQAAgjAACBWAB4FuABZS+Fg8EH+AQscACgA1IJozZyouSdAToeBIhjwwBhQABARsgAAgtA\n", - "ACBXedngACJXAGAAAQEwABATiIAAsPkCCH8oIAAuAAQ4BOFDwakMUWq8IkjAYORObojANlAQoeVc\n", - "Lerw4AIVrgcGGafMEBPwLIRPPPADmiyWieg/gBcloVTdq9B/oCFAoBAKwALBzmmOWWzNt1YXqFme\n", - "VSraQaP7lh2KgZOACyIADhqMsGNCjBCev/3lPbt8xuUd6zy/ePVXZVBk0EWmAC5kKCX1RMfhz+Uy\n", - "oxRJ7R3WH1Djj5SAVL8piPGAIcBD3MqpH/98grbaLf9/0M4e8BUAFk/5oBPihuYmc//uAA4MFdSh\n", - "FXAdjsy6eAxDRbEN0eVYoirRPxARBjERxSnLs9onwIGQFOIatCPI0bgN6wMEZ+EhMUMRbJP9wB4p\n", - "sT6hLTMt///gMtO4BhfGEyVc1imGGhqGMOGt9AGEmFWlOpSjJfcQcX12SKPcLdAPIxbL1wuscLfE\n", - "9uYe1jPQ2ok1NZrDAyJsWyxaEKjond8X+6hggRC3gKZtSBhhUisCgRNrBAJowZbyMYANBM94CKqg\n", - "ACAiECqP+7DA6bmgF/gY7BqiO1DMLH/EzYuGGATiwABBCAAEBACwTDvfnhAACACA4lcJMAMPqK6I\n", - "BEKBGHKIvwdLo0RzKt9m4wdVQTsz/8+HTxfjJJIcX6veYv4leGoCgEFaW7WdDwiZUoR/vAisUFHo\n", - "BKqvyb8hK04YYQABgCiGQgABArAAEA4AWGoMhmIZxR4CfH+/4YlU/IBQJmfHSoFXOHXhWGAvhBYM\n", - "NCycRBMzGDz/oZgAAgIgACAoABoAAgEywAsMw5DUmCSY2hw5KXeGEIEogQABAAOQC6bmLseMU47t\n", - "gTAim3/QgCKYCsPCMsuHHIDMYAOJCaVt/hA/m/8z+C2ADVEHqIlSU3wEG0EkPyUpoX4AQEPxTtw2\n", - "tMCY8cCfAgiiFEZB0hMWy6P/BAAGAIJZCWlgAXoFxJ0bFa1imX9+AN786i+sIhgOYADggV4EZhlf\n", - "ExLeJfdmAvOYAGCItZmlEEpoLA+GAKde47zddm/gCDyzxpUp1oAgsXNSjYJpnPwLKkSzRav8/Myk\n", - "qHLgINFkWElTj5O8eUrECQ5AEAKB6Kko0C+sAEAzBpxFgknMgSU1cmBoMQMoRVbg0WJpVemiAiAE\n", - "NCNiP3eNsbb7/hKIziHZOMjj+//sbDEAOWIUC7EdjsJW/2mgYdl2U92xdvzeqhiwIED3FLVka7yX\n", - "/QYoLQBEgcI/nfGAs4v05TvQw/DGHWWQIEVxdPAKo5h+8iGMmo1wOBCaOBRZwAEPpuJigAK62uKh\n", - "kc/+7wC6hUcYI+syXBAAHgGEsgwAJwUYikWfo7YBtoOwIS4y/++mNVF9Zetac+T4sR4xW+89wAAA\n", - "AtVhAIfgA0AGnIDrwqJ+C8IBmAAgIIQ4RKdGMJUrmV+BcxI5wTDlpH3f/BhhLZoAD6bUPbxDnwYf\n", - "6CwgwQC+ADdsO05TlLffgAIRCBCiAlpomNonZSVhegdTAACAfeACgDw4JWXX3Cs0EACIQSDuaANk\n", - "1rW/9egB0MtW1Ee7LzZCF+Uf/oA193XIWmc4BFgA1RAmRDf+vcMxLxiZs8Ock6tQgSGBAIIAP0Y2\n", - "rK1r/3/vgoIRA1w/DkB1g+XsAbAACAhLJQABAVAAqAI1zBJxwKZI0kdZAHHQIf/cDMA4JezLZYDB\n", - "pnCas//7gXUZLCTrIEsEFWnCAFwxpKQsg8HDBTwF//2AwASOkCwVg36G2h5f//cGCAct+1WgGCAH\n", - "wQIAAwBjR6YaFQE9g1XNVHVWP0oVmwfCCqviIN8gzmitj0AKhlEMQwWnlRz+HcbATnQI4OxITM9/\n", - "05HADSMe//zwgCALQ7W8oCYQBqIhNgr7ncU/5qCBnwABkPExziAA0d455oejH4ilWp0YYrDkt0zC\n", - "c1P7XvlT7z4OymxohzOpP/+vDB/DigAJrDn1IM9MIc//wAHsxRUbrDlM39dBzhE8SYSSKUDRFIeE\n", - "LVATRbXQQkJzfAaLclNtLwg7IYvrC1EkTdvPa528jITYzeYIRAIPAA+C68GRfupp7/oBYLAYu8DR\n", - "WAg48LgX/9s2HAUhnAk6zrWDTDh/tv9wBgoSMZRMWlfyRwKfMn+gIjXkf0OxUUmQehyGKQfBAAEB\n", - "a0CZl9vA2BlEVF3aZMj/wsm3QCEK6JiU2svWubh+6JQNhGKOhy99sEBA3ZmNt8z9POJC25RB6mKY\n", - "pb4y/uPrbgAAQAACsOBmccGv3MmxOEf/7wje0IzoCT/LcMt6ExwoNEVGPVR16fju/W8wb2nOeY//\n", - "foPwgAEd5IRIMtmENOoN1lGJz++qPel7rPdb9WR0YLlJ8q+Ai6qPaSQO9wAAAglhAKLgA0AGnIDr\n", - "wuJ+CkCAF4AeAAICEsoAAgKgAVAEQNoWUAAw8/WdnegHlgaoAbCBJHkROKOQpcl91SIAAsAODi9e\n", - "cAwR0vL/li/FiTRj/9gBAdw0wEkkswx3zVx+7Az8IFPggADAO544N4A+DS2iaEz2eXjXlp9qEQQi\n", - "KgRxLX+APZqb/AwPAYuu4EqAYoQBa/gCJz5Mu/+/pwGHkWbFab5ytK7f/2CgIBbM0gABAQAAEBGg\n", - "AOBNt8MAAECkAAQKQASPpnAGpgMDmAylSMz5a+6Cl4GOQec1Jg0XK+7syNf7H+OJXLox+IpVqdKH\n", - "owbHG1qEFJHKu/gNGCWUxy3H/79BAARogIAA+A5ptaKYAGjt92B4Q0XHjqgqE3fbQyissAUiwz7X\n", - "g+UkJmE6sUhCAw1BSEAvgAORQCmAyRX9ndsJBB7+Ik4AAkAgedinXikDRQyn//ocABMiGV0MZCjp\n", - "UpIGZitYLAaSTp/iX3o0qXH/vnwwDvKat0Gbv6vNYKAEDhbwAIAP6MhQekDeX0Ukbwz+UK3pCT/b\n", - "dMt8gHQIQaPQp+AIW8BCj79R9be9mNe79Sq7uH5EAB4AFgChuTBBQgFmoU/AhCDhHMKOC5X1dkRr\n", - "wgABAZAAKCTIQAAgJAAaqsQhpIKm/UPDub6XDIov0+t5+Rg3F+CDlihb5+vQY1yF0e8iJXv73AAA\n", - "APphAL3gA0AGnIDrwwb+f/BZgAImAEBibxpYJZ+ksAB4Dnx3WJ44bySH+CC7OEAAXDHlQANUuMMg\n", - "7KSUfgAUxB25ZAx08V64Nw+DEM/AQzFxkmhaZ1NWmwABBNMAAECkAAQJwASEUzwAI4nsODmlr24X\n", - "ABOIE/mZjK6nO5R0rWsIAIjGBLb1QfKpTzjYKSfwf+BlQEgccfELHW6Uh+DL8Tho3/j+CDgO6pYA\n", - "HAAEAECgaFVeHHDUEBCwauSeQfC0ABEDIIS4KWVsiQGijp0GHABsjD8EQtKL7wCoqaLIhvHDEWQi\n", - "SQAnfNtgd45W9yw6vAKQmNsIpiE+/4OYAAAACmHgA4AHHIDrwbwAAAAQYQb4AOABxyA68GY3mtcH\n", - "NwAAAI5hA24AOABxyA68MCfNw//hvAcAAQtgABBwAAWAHUy1iAApC1tQdt3vMghIAuV/AwFMRzDR\n", - "/DagAIAYco0ooos0OLKJqFy8DgAFAibkASIHnFiVp0n5/wUCon+iKyid9QFiBCFZhxgEgr1loOfh\n", - "wqG4QCUxgAH0k5+a1QcvYGa2J+fwAJYAD9lDCleST6G4AAACL2EBR4AOABxyA68LifE+o1A0C0A4\n", - "AAgDUAGBD1zAYiVQM7x42gAcCUXp5q1alRwTlowAAqFQQmGBK3TAEQYZ9QWFKHBS9VRSADQA+FeF\n", - "4fOEiaroEToMOEUAAIAqQwALXAvTYi//BBIrhCYAgwAVsckKPHewYHKHoruZkDH//wALmgRcZC/A\n", - "h3P+DA0ZWE07Zs9TyLvDB/P5fODmCkwKAwBSGwBm9dX33A2kiFIJ3Iy/gEyM2AAIB6NlcAAQDgAX\n", - "QNB+AAmEw7bYKY0ijMoSyA4AAgIgACAoABYIS3mAwGEW0ffDMNMB4vBYQwwALMJrwt5YpUL7vNt/\n", - "fABYJuVsz1Fy8YwUX+MEGzgEIuLgWAn+AM4GUwcQNkGTqRErEW8QQihyQywys+UFoz4JuEU2HlYR\n", - "uXdwLOBqCileqYBB1WWwQAAgIA4vQRAAECGgACAsAFZH4mEsHguwqxygEQ6uCjiwpOMODkIHnVuA\n", - "AIAEg879ADwQYtFmWAAMAAIlVRhGmSK1SgAaTD2CrDhSNuVu0zAwAxaqsL4AVTswYP0wV+N/sN/A\n", - "MKyO+SRVXwS1KjMlBeIYIAxdWQ3tBfR6xVfuDFR5BpJiczSLn//eGcoXzQMzFFEmaDhwT4MOqKuN\n", - "NCZE3X++uGC+IxujgDU8K/9xEBwjMOaG9pcuTwQABAIEugWACP2ggo0WgFKSEPgi4Negf/wrAp1g\n", - "VrBFwbBiUwmAzC7DHy4ehST8OlwSYbHFre4AAAZGYQGzgA4AHHIDryF/+DkOeAMQAAgJAACAnMQA\n", - "BQfIAcIFmfgDVyJnz3ACU9RueSwr1ehxQAEAAECYgAAgFgHZE9WVBPSz01Zaf+WJ6AGdwABAQsXg\n", - "ACC3vMBRitptKIIUMDGhMWcBqUBjUKUAW+IT6EwJwgABAFBgxcIAAQUAABARAAJDmErRBIcVrPV4\n", - "ELRsOickBV3rBeQAinAUscUIF/V4BcAbFEoqBlC7LQAL7BET7AgwQRvgAhAAGVMAEFHx2tg+a/AA\n", - "EcEeAYRuLBRb6xggH4BKBoJoxw744x2ODEAHeEaLQDQXsQ3+9AUJjqAKGTR+iD0h6JGehkAACBUA\n", - "AIUoAAg+svAgmDZMIaZTFXsXKdrAEMowkTBwg8ECQAY2lZ8hxjSJeoZGBVykAGRdiXKTqlEkNRYW\n", - "031egAQR5KZtIlzLGBJEE7/ADsRrE+cyu2RDKfSByRfal8HAIghByLBWCMbAAciIqxwWC9YKqtcA\n", - "MCLQMj2eNYRf87/7wbhjWCdkqa/uRiYnwDnDrLCDGCeSWNkbgDjnBjkHELqS0t/+4CKYdDRTatSo\n", - "FxlVTf9wAxeghZI1gyCVTIhJf+4BsMSBgrVxZa21QkAa/7wGF86JsMo+NFEhGS/6MDAGFWyKsa07\n", - "/kPIH9zdU0B9q4PQAIAgmcpI7Fm8RAGYLZwAZQuFPpg6RRgzAHf/ASAYBDTAZp2BEPsyHuz+VEkg\n", - "7SI/9WA4AAgJADgkIAAQFQDAAhnBwqQzqoJ4Kvf7SsBH6LaAC6AHOv7QCgREPINqowAuz/2oYdbE\n", - "GC5a3EL6NzE5wh7GnaQBKi3+ECKUZA5hr9APKqzThirMg7BOGUWRCfgRACiHa7iSRE0lTIR2CcN4\n", - "W8Bl058lAGoFjJ+I+u9+AAIGAAAgaXIKkfvdoEQA4EDpRZML2nOgXf9uNkAAIBBqIBmkhapMpb/v\n", - "BCsWQAJocb26FmQxbmmwEGBKnh3DwlZ7pz1eMAAJhgABAkAAimGAAFwCgA8H0wIAAQEAAYY0EAAI\n", - "AIBQJE+McIz8P7xJx8KLg8QJAznV1C2Yr/+/2SQEJzSgCaDq9fg9BUAA9FvSUAMWNJxfbzKCDDWA\n", - "KDOMQxJokkNoMOSh3DQrTmU6c/ffguEqC4t1pYc/MIRRx/6DUwBJCy2iwwkHnhXRFMzUKv9f+Bh1\n", - "3o5UVnhtRMBGi7vADKLZBfwETSLkjQ/cGGEAAaHFfCAAEDEADABIlSTQ85oYhzPseCMoOBNfu/7G\n", - "AZIcCNOC8uvjuEJssEQFwIqBgNqHhhE/m9HMIQLBfAAcQtJhGmqSs7hz//AAIGHXejlRWeG9IwEq\n", - "Lu8AMotkF/ARNIqSODtnBHDuIcbO6/Qp4z+5RBbGvLSU794QzoMpLU0WgxRP+h+ACKN6HcWKjRFy\n", - "pA34gwLgVrInRo3qRUKm4YYQXAYCQgABALABAWe2n3CRz1iGHDjBcohA/KN4BcXyFZ1R2RSYYbHe\n", - "D3gnJFPfycc20JkRRFBcCaAofZPlLZJqtijV26YAJIGbcQ/4gzhCGJPE7SIIMtqc2mFafElGl/3h\n", - "QBQLZl5VioNS4CRQCbpgCDtU9jKeXoYv/dogABAFBh7xybxVgb7mmbUPUABebzCQAQAncIDwAY6y\n", - "VZRx3BGsN7K+KAAwAOunBaUwW0uFjAEX1ni4AAgD/aAeLjJtUqGgADAC4eDxLa2Vq2GMxSAwFQAG\n", - "sAhU9OgAl8DhsK/+8JwO8HIZLqaZ0SmEGfiN4QAcsCNqk2xI/VoPCpTEABQpRnLA9qxJ3FYwAAgF\n", - "yQAAQQQADzsEAEHsAWEAAXGOBPC4A6lHpyycARGxBhLsCLYlESt1pmZhEHEkX/e+AlJ1YNTA4iVb\n", - "/MKDTEhAQAoqb9twbhTQmlvB3EvxrlScIaoEV4+u2JUH1egPDsOaSKT6P9WhE/90FtiAHSABR740\n", - "wTiYlv14DDmC3lfki4REO21ha1PwEtxQ0Akht1KxCgr5IMZcQkxpZmsJb4YkhOHE9k1wJiuh9n3+\n", - "aAZvRkjT6HFBli8YgnEyI2XhJ5FI0EsIVoyo3zSxrb97BAACAuAA4KNBAACAUACAWK6IMFyYpq1O\n", - "8ql+oZwiWtILEpnRMiPtACAAEAKG4BU345Iuv4z8AGQaCaHYYcEw3AAAAcdhAIfgA4AHHIDrwsJ8\n", - "T5utxH58dgAIiADAhc6g4FA5XluCYFPx+YEKZs6KVZUVesMwTtPLaIcSXItaoOgAou9IaBqNMyVk\n", - "IBTgfaw6kVL0l9wLCohKjdOWkdZ/9/BB1uIdsm6/RxIz/3kkglpsSlPS/BAIqAkIAgAE4BQAK3Zo\n", - "GGgk4W0gLo2I4ACxQa94E6gvFFxpGNOeAA6VKioCJCB2NsUmiQDACtvaH8Ae9wCh/vmM2m0HAt8A\n", - "IPPNwPPY7YT/B/OQ/IQcsbqzrp4NKd/9o/CgCgaf1Sznig5L0bEGtidaEBwWQQ+UY69IAAQB3AR7\n", - "wVAsZUxoDgf6JJLY+VSgA4H/bDzCXAAIAGwhkDxu2xgDwAoPTAgABALADgaLhAACBEAAIA2Zo8GF\n", - "7ofgDjSg56g9OMOfvAcJ2XbfcehIdspQFoWMtyX5/g5YDnKAAIAFKV0rwyfxC5hD//QbgotBoUSU\n", - "qS5yiAAEABkSABkOBhDEP/wEMwtzxC0kMXtPMAG/AODg4thRiBQ+B8HAAoGDE1RIZ98StUM1oIAT\n", - "itCJBEAzAl/XDnRV8+DBLlUfeX3/4C8AbCRKNIfbc8Pg0MFTW6zL5DZDcAAAAMhhAKLgA4AHHIDr\n", - "wwJ9ICIwIYWgAJC2IIhyESxSCo0QAAgAkkYAH4oBdDbpk4DVPHXYoKwHkjHdQ0dSHAAEAoABVbTE\n", - "rnIWghhQzmiDDjC3/eGcCaCN3PTLi8SSRij4chz0ylDqD1i1zRi/Qsz52QIASQgCb8AFB7kaopA7\n", - "lgwXDlJm4j2Hd4AFmQMv5WeQSbCngYGn35eXuUp1P+8NH80P/9BuGIbwAaDtczIyuer3gFAGJG9m\n", - "a84hEWdXzPjHNV354S9J3+89wAAAABJhAL3gA4AHHIDrwwN6dcHECpAAAAAKYeADwAecgOvBvAAA\n", - "AAthBvgA8AHnIDrwbwAAAIZhA24APAB5yA68M4O4b0FsAIqradN9APwrIQwxCEVkgDCgACAjZAAB\n", - "BaAAECu87jY8WPAAOAPnWIIvfgJBiHBa8YkE26bAFg7/u1A6B8oNnGT8LWfwQABEKYYEAAIDAABA\n", - "GjoAQ2pP//zvBbmJHgA8fy/n/hucPAIRgAIqwoAAgdNQhf2/3AAAARthAUeADwAecgOvDLh3C0AB\n", - "AVCD61lkVh+smbA8Cq4AIcTtVVtdB1eZEMrsIzEkpYpPhEoG/sLBiZEaxXL0/rBiFZZpoHA/1lqM\n", - "l+uwABAjAAEDe4sAAQHwHbQOAoGHu9JT74wLq/D//hCYBjhAACAKALMgAV8BJmzECJlfh1Qhd0xG\n", - "Yf/2/wADCA7c6QK2Q0kM3/4YLQAYDIlACyf8jW/r/DR/ND8KfYbzxTAAHLgehl8X8sNkb4YMv/70\n", - "rEIpVyn1e1egAxAvhLXUkaXKoX/7wzwFGC9w1UWweQGUhTeQ//tAQZMrMdNx+7v/oIAIglUQF4Cu\n", - "F5ry4kpKHxQGBI3ULQEZh64YG6A01ViMqU94EShQ9tgIMSsw6yG4AAAC6GEBs4APAB5yA68jwUT0\n", - "w8B6M2/4AfgMVzrjHB6X9wUghBPDfAGAAAQEwABATiIAAsPk8BoRIzwJAYjZde/BUV6jJeRCib3h\n", - "IT5v/zMThzgAWwbHG1qEFJHKv/gCjwiYQs3DlJHXf/AKAMZTeRZomrDDHBP/94DKCEkk3ycPB6/C\n", - "LF2zD9FStKb7mDIGR7SQKBGyqE0dwQABMMFEwgCcVkAD0MkJc9wUybQJjCg1VIV7uCMX/QR5r1uA\n", - "E5QnfMFW4r/N4SC0ABEGGHXqhAiI1rYWACRc8QXBdRnjc7bqjGGyABygACAdigYBBKalY614BA3h\n", - "PVkPiah85rVkTLgQAz9juf1gII4FLP/ephqmcLSj9LGNOCADAFnNB5MJnGwQCTEgYe2CAEpXCAAE\n", - "C4AAQEgCghpsOCwsIw8jcXgfB6QWYG5gUw2lOZF+8DQEocxwoiiAusqLOtg+IAyGAFXwsVbjzXGh\n", - "OAZi/go+esEdtvz/B8FoYxNZ++/L8EH4ZgCwzDkNSYJJjaHDkpdhhwAhCZmF5SKRZ0P9sfqnc4X3\n", - "vHf8JH+GQJAegDXPt+DxDdZb/wBCkzbBKpaR35oipzgoc1w5HUFkWC49//+IAAQCQAoE0o+zF4wq\n", - "KDZyaQwAOLkKOYmfCVcIzx5xszAAEAIAAQEabLQFj8j3a8D4r0BIjeirQfLaUUAYYZiAgABAUAAK\n", - "AAoBMBDlPVhBpUVxNzbcd5VfudbAC2yQZcYhMDsAdBQ1cAhFQHy2fUm+tZWjWJysl0+EaX/aBmFp\n", - "gAB0BwLJphgAAgPAACBQAhZM8DAV6jXgAp1LtQJmvQy2+AQI8Uip7Zh4QYSoo+9MADEB3XE/Ng7e\n", - "8EyG+0AkAlUMQhoooQKnwAQCB1D+biTCEcA2hGUbPWP9gxChM1T47QgABMPCAAEB8AAQAwFDmPAJ\n", - "1IAVw2M3jpfgWBXxl/BhBZXv//B4yBxCT5AyAKSW5hEHogQQIr2XugivvfqD3AAAAR9hAIfgA8AH\n", - "nIDrwwJ/BkFoADjcAHv7eCUcEejSIHX5xOGtvA+2zgADBrIioAaVGrsmjVt/B6ga5RiHiP9sygAC\n", - "M4iDE65hJ7FcaSAoipnmH2QyJFJf9oYy5lp1YK2lSgEsIgQAAgAAE3QALBjmni6czlwgQLcf/gwF\n", - "CG/88mnA78rorhgAEggzLpw1eN0PvgwFNSDF1liwqmny6QBhvAoBaGAnAAagC3Y/N09p5MlQAGoG\n", - "KRuHmAIB/vDIZLvvDOFuzS2iWUUX2fIyEVlMdihEtYnYwB8oCkjSd2yLfzgCHUmoLCoURQqUF/YG\n", - "+jFVralf/+8IkBihEgENSn48kjb3/wJsMiqguOy2ev0OBWZSDGn75tP3gbuHNbipL397gAAAAJBh\n", - "AKLgA8AHnIDrwzh8LQALUGe3cA/KoAAQGAA739oQFVMqBLpsXmVqfQCcILBhoWRiIJmIweb9wGO5\n", - "Bj0mEb4zy0P/9wQwEAwANABiBpvxQUoQxMEXwIACMUUEAAIDYABwPFwAfmCmnoAVcn/QYcUu/SPA\n", - "A4QyguOb4iAlKilf/4YasnXvDw2E8MqZ7v97+4AAAAAMYQC94APAB5yA68DbAAAACmHgBAAIHIDr\n", - "wbwAAAALYQb4AQACByA68G8AAAAlYQNuAEAAgcgOvBoG8ACO9X9VQCJDezXnf//6AE4lwBdp689/\n", - "3AAAAUdhAUeAEAAgcgOvDOHgtABY1nGLbo7n1P3mIIKcENtGCLTJoh4BISh5g5ACQerzoGq8a8E7\n", - "oIAIAUmkiCRo0DL7vqfvu8BBs5BxCkGDrWkUcAUuB6GXxfyw2Rvhcy//vUkRIJnB1cgElQgACgJt\n", - "hAAGQKeeADvJSgHev72GBuAk+UOSIjJLB7jABakgHQCkgR4hj/7gwNPOHIi6ET0n3/e8NBvASPW/\n", - "P/8ACsjM0JspVZuzdNbJpgIvAHc00Nqf7B6N8HQByRj4Q4buPiFPjBa41QwABAED7wnkpeOG3niz\n", - "G2KBQACIF6ryOMFMsUwe1pisAAQVAJIYEtV7wABAAByXT63gEByNeP17mxu7rQABBQAdaeAQEzBT\n", - "LFMP8IAA+A7GAiov2zK92/Cht8Ye4u6+vAkzIbH4BDGYkF5d4OC9QBA2tLqqr3AAAAKLYQGzgBAA\n", - "IHIDryPGQx4AB4ABs4AICAm9kWGRH5gIJGEcgwrxpBBgGT2KAAEAYACxMgoroIQSHCAAJAKWMwAx\n", - "lTHdjgF4KraM8kdHxFsADuJpXF9RXNeAKSYAFwrMB54QPZGJ9Y3BCev/DCHwVBM39/+CyABCu05k\n", - "2n4AAcjgfyhbaVn7e8An5llDTuhTRzF9Owaq4WXr/0+EAAWBzjwlNQALwFFPD90AzBZJ78BJejTl\n", - "/jwt0QBAONnW8UBrcVllgf7zwNwWILaAOAQtvpEyVwBwAEH/1oqx4F+VAJ3DdAYLECYhYVRasNwV\n", - "O0QNtS9YAjgS+Yv7HODYorPUtJwAsNyi/bSWGF+scwmMHLgiQAIECAAJhwPGcMDbCNvZATe6P98G\n", - "CCRBcltfflf9vwTAAwLyvcAFQWxHoMDOAKuvAIJInJkDLeZ4iFcA0QEfUlB6hUSvTrEcPRCp4ME3\n", - "LhfJ6J2P1Ov9Y5/V/hTRhACGWUMX18dqMNSnKcHtZZz/AjNk0NuhUZ+UAgCEVAoo0QCmCR0GHL/B\n", - "B56cf4ZntT4TN//wguwAEAAyBCsimAWyKMUoi2L4ACYmHaniDlFj+rMJ/BAzIggOKB1lcqJQahAA\n", - "IznhAAFQQw3gA3RT2wAwYdt+4AJyaLeoHgcWu4SC3hjDW2uKwiIaCBBR0cQ47IVzYGDDiRcRswJU\n", - "xEI2D/cZgJQCfYHCBRcuuKm3+5gBnDRKEApayOwAEQOpEAAIGwAAgkAACAsBzWeNgFAA1IDXhXdk\n", - "wdA7ptAAAgaAACCJAAAgJAa3UEJgAQECAAPAIDTYEjIklolQ6ucv0l73sAAQC2pq/3gWgYDV3h64\n", - "itY9p2/TDYHyrAMSGqLGO69wAAABVWEAh+AEAAgcgOvDHDUABBCsKPKaMd4uWXdcXMAAECsAAQPQ\n", - "ABAfAZlg8K0wrTgByZRBlw+fgBQjaRjnQHv8HAWgCIchg9MqRRlEFXKMxtigABAkAAECSJgAOHAe\n", - "CP37KCKQs/hrn/IwABAoAAECgAEBD+BgBzKARO0DCBwxBgw5oABLwABAG6oMBJ8LMMfylw+hvgN/\n", - "PINmEABGYyRZmzAAEAdYM/6wMF7VGp9c/b22bAAEBAAf70awYLmCtyhxCW/9/nhvDoW6MUa3KYea\n", - "Rf73PDPIHJcIXRRYSgBCFyPyabdhEX1l6BEEIqOqEIf34cACCiBsRU3lgQdXgY7zzyWnjwoKMtG2\n", - "6LAKEtWp1aofu28iBDEI4wRxQl5ppYIAAuD7oQAAgAAEa0BQWUHXt0wkI1rtg6WmhwWZ5c//AVDo\n", - "ATJRAWwmrclsPDwfkAMSBFIE8b3uAAAAHmEAouAEAAgcgOvDOBIDfgDBDe3Neck/gC2Tvz3h6AAA\n", - "AAxhAL3gBAAIHIDrwNsAAAAKYeAEQAicgOvBvAAAAAthBvgBEAInIDrwbwAAAD1hA24ARACJyA68\n", - "GgbwBFNtpIOrgAaSXwb31H3+HtwbzXuqDCB8lZ3l///+eSEeb93PgBR66/88l3x+svuAAAAA4WEB\n", - "R4ARACJyA68M4CBDMACEAAb+uAGFHRONM2W+RIEzIIQAaB/KqwI2kPRAACAC0jAA4Fht3IrLXYEC\n", - "7ugBbHIGNl41uD+ABYIdYuVfUYtybM3/g/ho38/nw5gAVaYSU+JCmpfvhiLex6KOhbVwCj/gOirz\n", - "IwVdyFV1//9DCJgQpsAC5weqiY0nGHPQdyYvTOVk+gi7aabfk0D+P9hvcsgtRUqQm+/wAY6yVZBx\n", - "3BGMN7Kh8ME5xt5iUFU0wn+DDhAJQpIAQQGwszLvFQWdH9/FCIn6oyO5VDCJm1em/IMPcAAAAnJh\n", - "AbOAEQAicgOvIX/4IQx4AKAAJ2ABQSEHUq0zInPwBiAAEBIAAQE5iAAKD5BFIQAnWAGReimzgyzy\n", - "JmuvYAHIb+MJiyfYwA46no3PfCiJN/7nxQd7sGMADtgHHBzAESZoCJGhzAEJSAOalSwC3hCbwsBM\n", - "GHwQrLbcEkLGBmpsWkAQAAgCgwYuEAAIKAAAgGgAEhjBq0gkOLKWeYEKZjLBPWAyz1gvIARTgKWO\n", - "KPF/V4BYAbkEsqRlS7DgAL7hMO4ACAGGKLLLKKKKLLLKKL//4AZWAAEBIAAQFZiAAKHAHCBZn4A1\n", - "WRM+e4ASj1EQ8thXq94WgAPqCkCdxBjnCFoPQiGhjErAJgppr4BjJ0yM75//eAIjGAApDECgrTmU\n", - "6Ne929/77cMIkJAHQALQV1MSoJF05/g6ry7n/+6/AHt9jsR+DQ+kWaxb/7+ZQQYawBQZxiGJNEkh\n", - "tBhyUO4YCwiZH4r6OR5/wRBWMVihta4e/MIRT/6DUwBJCy3CwwkHnhW5iKZmkVf7D8AIVBRGWEws\n", - "SKJD6u7wIqFBR6wSqr8mazlpAGGEAAaDikwgABAxAAwASJUk0POZCEOZrHAjICgTT7v+hgGQ4Eac\n", - "F9ffOcMT9aIkLiRVCgbUfDCZvhH/QLMAUGcIQxJ4nqhBBllKGAsImRxlOjkzPwcJUF5ZGtYc/zBb\n", - "Y0AAIBo5WeDFkRGS+AnEFRnGuIfKWIvgEa2JyIpufFTmBBDIpBkwzOUqSGz/z0CkziPJR9bIATjC\n", - "hCub39ocavQ2Jn/4MIkCMEAAXB2tpaF+WOTL+XgbaP5glxSf1+N5kBGwR6Bv+7wtobMdye+9wAAA\n", - "AOlhAIfgBEAInIDrwwb/+EIc8ADEAAZWGACCj47WwfNfvgLhB9byyKuwqmRu2InwwhIIoQLGPABB\n", - "eSt6RAsWZYaHCQ0ggAZF8lM2l2CrtRcaZRJxwIYWnpD4AQg3VJJPvNc48RE8H4ToDpU4FPGwpg0C\n", - "bKCWGHCCxShASCtW/Pn34AkTUfnk6750rWmdg8egRkqUPxYm3hsNqAAgBBizS2tYaIYa4067WQQH\n", - "4ADxAhCsw4wA0DPWWgrABxaDQokpUc1oNGZAoSZbkuyg/wgJClCAE4jPgBeH6OR0ddO/4ADnnBOq\n", - "6eOZzf3w3AAAAEdhAKLgBEAInIDrwzhYLQAJWFqLHJlEMX3kLDoUhzyxN+RV6HD83uPrqLAXuYnd\n", - "AOare7zgltoAK7oXJO82B/BE2lrxjRHMPQAAAAxhAL3gBEAInIDrwNsAAAAKYeAEgAkcgOvBvAAA\n", - "AAthBvgBIAJHIDrwbwAAAGJhA24ASACRyA68M8N5WIACQnDNRhIhVtr6SvU/AJHvrz/y0wAa1N3q\n", - "2eG8DCGf30m1AACBiAAIHcRAAAgEgV+ZjFX+relbfSnwlthBIQg4CxSZdZ7/gKNh2Kz+WcX60NDD\n", - "uAAAAG9hAUeAEgAkcgOvDKgRZwtAAtg2ONrUIKSOTf/MkJZOa2//6AUAwiHlZoT2bBSJgG//2GDH\n", - "bVizO6bNvuXbMP0VK0pvgYH8IAAqCnngBAA8CDTv9RpHMFK/sGA3X7e37DAD39eacSg4mr308NH8\n", - "/cAAAAHiYQGzgBIAJHIDrycMeABsj9AACAEAAIA9VYADAf+sYAABATAAEBOIgACw+QZQABATAAEB\n", - "KJkACw8QDsggkcuAE1xshK/q8cGIGY3OMAJQ0oRRZ5B3q8VAAIVwoYVN9xghHhjgTo4yCEPbChTO\n", - "8AgWQIoFJLUSaqAjoAa/ECwLwhTSs3b4BMv//rQEAVvKkAOSAXEL8duCAAIAYkWEAAIDIAAgLgIB\n", - "LAEYNEegABADHBxBgUYC7BVNSEWd3fYCwqoX5JM54AGHAD4j0YAgA7C4AomSeArJybIKcLeAHgDI\n", - "eTTW1AkBgo5X+TTBo1l4SUa/MgTNRnfe0t9eu+H1k8Adic0+W9eZQxhXAGDcgxDRaagii29MimH4\n", - "wzDkNSYJJjaHDkpdhhxKQHABooyh0cjMhZSKKz7/BcErD80rXkHLMO1yuUPK3j3/UMYVgDD0cjk8\n", - "6P9/EAEtDiAvvTJlWOqNYQQw/CwaTkrdpI1HHzZXiAPQ7YFxQAWWBwtNv+DDCABDtLCAAEAoAAgK\n", - "GLmmC0AxYesv22w1UX/0+9Lfv/Q4x+MF7tkGXQySzhCCDvKSOLLJBirB14YU4WzApiACA6Pu/LiM\n", - "vOiGp3oz8gzCL5PZ9hiV446Ts2e+GX6f36f/wDhqR7cAAACqYQCH4ASACRyA68MCfwLYWwAN2J4Y\n", - "YhGZ0fECxDFzLkgjdyN/kBX0mgeB08CKF6AVI5VlX8POu/hvQW8ABGCIKWW4YthMuy84yWctAlDB\n", - "caIjKDiB8DQLf3aoxFbHb4oUn/uBCEAAICECpMawABWoDkbQIJI+PsG8smWT53+8EBIc4QAAgBAG\n", - "BJkEuzv24BBT8ghlMSJH+8AdzmhtT8BViOcqmAY0DMPN1DcAAABSYQCi4ASACRyA68M4YC2YMGAS\n", - "xJO59agQMBG1BIKdMnvkDL7kADjACgNBdvMrMXb0CJNhACcxgn0c/AIhWqKq4zDnhys8AKQA1DTC\n", - "sGLyRr8MPQAAAAxhAL3gBIAJHIDrwNsAAAAKYeAEwAmcgOvBvAAAAEVhBvgBMAJnIDrwaaDOABQw\n", - "EbUFgp0ye+SMvuiAAEAFpGABwLDbuRaXuwJbYQBMQwAPUO+lZJDvv+ADwGoyKFLy7Ppz+HcAAABS\n", - "YQNuAEwAmcgOvDOBtDcAFFwaFElKkuAQQIZimWeNRx9PfAdmFqdC0hiv3e8hYdCkEElib+in0ICQ\n", - "paWmABVF0fBgkTNB4Hbyw2aGP/0Hvgx7gAAAABlhAUeAEwAmcgOvDOBghsJ//4AuttyDq/uAAAAB\n", - "EGEBs4ATACZyA68jwI0MeACXKYAAgBgACANN0AA0Hn/MASKgFbllSCRAgxIYM+A5gWm8bBbBL+gC\n", - "QIAAQBAHDXggABBPAAECAABwO4A2KMyLngXkYQ2kjKD/6mwAmCWBUlGEm+rwGiweDAk+gJHOYEC4\n", - "fpf8F/Df5YABrooAf2gfM3/YGAQGhASFLhxh4j9DH34IM06gRY9qKTK3hovwQAwfhrp4ABMDmGiW\n", - "3iJIhn/f8QDvIE1LsPJGLANf/vZPmb7OCAAMgQSwEAAIFwAAgJgDg/4O7GPbTzAEKnP+BxDM04Ga\n", - "OBwhBWiXf8M/GMNwRm5jXVeEsMqgwCHIghGrzgDGSbGf/JN64F0Snf6N7/heAAAAE2EAh+AEwAmc\n", - "gOvBoYQy//D2h7gAAABfYQCi4ATACZyA68MqoOVTw2G8ABAYrVNCiRLWMEyRMmTgAwgfJWV5f/4A\n", - "GIAA39cAMKOicaZxxCQhCMI4AaAvlRcP/hww/whMzCExuAE1BuS0m3n/AAOKsG4kyqr3/cAAAABG\n", - "YQC94ATACZyA68M8N2CAASICEMyjCgBIGertBWp/Mw3F/UreST7dsIkZhACcxsAEj7IGSRdd4/O4\n", - "AS0MN0XTRi96+2GBUgAAAAph4AUAChyA68G8AAAAEGEG+AFAAocgOvBoaGP/0RwAAAAPYQNuAFAA\n", - "ocgOvDK4ECHoAAAADWEBR4AUAChyA68Gh+4AAAHBYQGzgBQAKHIDryPEsOTiEB5pywAKYANFAEvA\n", - "JLXoer3IUYZWkHUUK0oAJ//ggADoCDHQgABA0AAEBkANBTOEwAZCQ3rAC2Bxa+4ADpNgwKdIii4H\n", - "sgRuuG0GP8IkADoZwpVIiPcEwJy9ogJjARchFZrujZh92AJMgFM/7Bn3GmQ6mKHVtT48EABDvKCA\n", - "AEBEAAgEDOEmHngAAgETIB6vAUiSDggbImU58w8owRdSEsgAdmgAu4YPaBWrHXLgcvEzeFOFvAEH\n", - "JWfT1AFhg1hW7iEP7GJNE1Uw4fAHGdZq75wVgA+z5Gp3q95i/yeGoCMBQD5YVOuqNz7rxABLQ4gR\n", - "1piyr412CUMseCAAJByiwgABAbAAMAsag1sElwBCwa0t/ocYWUBv6bAm6CRVP14V8IgAQQRIQng/\n", - "OzmoWkr+4EDb5K0uEwh88fFP/wYekAAgQNRd+mQk8OJkHTN/9Ln+EAiJYEAAIAAAUIMz8QAcAAPE\n", - "AS74lQRoQBGCmjP/UKRCYAAQCkwkAAQNqgCj/9sGVVAFCbvg2nNTFv8KcLeAAkoDl6jtJT+7PiBO\n", - "N/o1LcpH7QxF0F8rvdf/77xDNTs9/9wAAAAMYQCH4AUAChyA68G8AAAAD2EAouAFAAocgOvBofOu\n", - "4AAAABFhAL3gBQAKHIDrwzgQVSECpAAAAAph4AVACpyA68G8AAAAC2EG+AFQAqcgOvBvAAAADGED\n", - "bgBUAKnIDrwbwAAAAAxhAUeAFQAqcgOvBvAAAAHeYQGzgBUAKnIDryF/+CEMeADaegABACAAEAmr\n", - "AAYD5/zsILAACAiAAICUxQAGgACAO+eFD5AgAQCMCcAgBZEZmXgs2ZAcFcB2AEoeoRBZpB3q8D0G\n", - "8EeDInD8eh3AAQAAQRQABAoAAwColZWRkZGRlZWVkZGX//gAOMVtNpRBChgY8LCwIATGOEAAIAgB\n", - "Q0h+ABTMkumwAPgx34ADmQYlaeTqlACOBkp8N/wNSgMahSAC3xCfwqBKGEMILO4QABkCiGPPdirh\n", - "rIJ9f8EyrUhgfhQ3Y1bBhPhbACEz+cjeWVCagBwhBMS9pH4vCCVoo/+vyLngDvXxq7+AHTsnrSve\n", - "Z4JgoHsAYNyDENFpqCKLb0yKYfGCHCc2e0RENxddRyneZGZDQqdHRHwYebISFyBAAQFcNGUORyMy\n", - "DBTBkEOA7/BcErDoeZryDlSNwFSkBbYmxT7/0BADX4GVSAo58J0VeTsASpQYYYQXZwgADIEEsfdf\n", - "i/DJLI/u//AlIl6AVVKAa4MM4fhn4AxWtHd6ePdSGch+/iKGHCEzMIAAgEIIv6N6o/tWH/xiZGBj\n", - "uMByhYtP+E+FvAAfeCsiCOIRmZ///MGg+Z9Kdc/0Wn9/VL5wNQgi/upf///7xV163B7/7gAAAAxh\n", - "AIfgBUAKnIDrwbwAAAAMYQCi4AVACpyA68G8AAAADGEAveAFQAqcgOvA2wAAAAph4AWACxyA68G8\n", - "AAAAC2EG+AFgAscgOvBvAAAADGEDbgBYALHIDrwbwAAAAAxhAUeAFgAscgOvBvAAAAF3YQGzgBYA\n", - "LHIDryYIQ7UDpaY9u/AAQDAggmbIsCjTpWSq2jRX4DoINgINi2HSIRLLYnra/jTzNmvr4Y8ABBnP\n", - "haUQQoYGPCwsAA7/A1KAxqFIALfEJ/CoEoYQwoAXBQgEAAQA0AOwAJcldNgA+DHb7bF3DWQS+wAk\n", - "yDPWnv1CgBHAyU8ILv9hDUCB2pm48MeAQaoAARK9sYUAAQEQABASiAANAAEAe87wOAATgYIIABPA\n", - "TiBaIAQcvtQimQDFInNuIBCLLASNPDbUHoMojwcaEU+YMqBQvNSLf/Qa/Aw670cqKzw3omAjRdkP\n", - "wAxUlkXYRC5IukPqrAw4HAAaOEEANwKyvsX4ZJZHvWf43rj+1of/AnIl6AVVKAa4NM8YmZgY7jAc\n", - "oWLQP5oRx/6DWGGAAICNlAAEBQADwQe/53/GEQKSSFsMaTfGi3Z8GHAwAGDBCAAIBqgB3RNAHhn2\n", - "k6pAWMZt/wCAcCNAxMTWW04gMVYL6VKtv8LQAAAADGEAh+AFgAscgOvBvAAAAAxhAKLgBYALHIDr\n", - "wbwAAAAMYQC94AWACxyA68DbAAAACmHgBcALnIDrwbwAAAALYQb4AXAC5yA68G8AAAAMYQNuAFwA\n", - "ucgOvBvAAAAADGEBR4AXAC5yA68G8AAAARxhAbOAFwAucgOvKb//cUHfACKwAAgJAACArMQABQIj\n", - "veQACCcII/fnVYoprPCzMIIvsCAAKgDGB+ARCyIz68BjA6iQGYeNii42AEo9REPLYV6vAKZuAGwl\n", - "+gFmwwcRMDnghDf8Ec3FtRJCxgZ8LC0ADsMIAiLaEAAIAoA4YWwL5p8mACUCHv3/BEFctVZqVAGo\n", - "BsmLJmGjQiH/0GsAUGcIQxJ4n6hBBllSGYAtPLeAEHeWR7pRBIRUqUI4YQiVggAIHcLMp0afvrEC\n", - "ekDoJES8oO/wcJUF5ZGtYc5wDAFETk+NftC29iQ+HwQBn4EVCgo98JUV+TMASpYYQw4QLu4QABgG\n", - "ELbFePzh0lkvf/g3K92AirUA5gWaAzDhaAAAAAxhAIfgBcALnIDrwbwAAAAMYQCi4AXAC5yA68G8\n", - "AAAADGEAveAFwAucgOvA2wAAAAph4AYADByA68G8AAAAC2EG+AGAAwcgOvBvAAAADGEDbgBgAMHI\n", - "DrwbwAAAAAxhAUeAGAAwcgOvBvAAAADKYQGzgBgAMHIDryhFaVfttzf/7jDvgAvAANnABgQE3sy4\n", - "yI3MC3QGt6gBQsF1pM8MDgACAiAAICkgAeCQj1wIAAoFNICAAEB8ADAOE8AMZUz0jgVYSZVAPlV7\n", - "AAlwm1KL6iOa+3BcHakgiQAOT8waP5o5BH/QawDRAR9SUHrFRK9OsSw9TNgACAaIzGjwgU+Np4wi\n", - "BSSQthjSr40W6PvDCAARHsCAAEAwAcGFwKjd2vidDMgQDUZ/85mRobdCoz3Z5RPYSFg/a8D8LQAA\n", - "AAxhAIfgBgAMHIDrwbwAAAAMYQCi4AYADByA68G8AAAADGEAveAGAAwcgOvA2wAAAAph4AZADJyA\n", - "68G8AAAAC2EG+AGQAycgOvBvAAAADGEDbgBkAMnIDrwbwAAAAAxhAUeAGQAycgOvBvAAAADVYQGz\n", - "gBkAMnIDrzRUMeAAYAGSYAAQADElaDQDofntEAAsAOBBklgAOGrgENQjgCRkyp6KMwxCAAOkARIQ\n", - "AAgcAOACXsAFA7KxlGgl9AhLNAAfARth3FsAB3MAAQBojoHDVjtxZZqAHAsOaAI8CaiwY5XwbXhX\n", - "AUhCA/7qjdrCpN+IyKh+mwiIpxXDfa2Sf8AMpQc7MYAgicv0E8TsMMIAAo4J4QAAgPggD1ANgrZ1\n", - "bnQRIx4pcCWYho+w/+oGA/RLiBPiiZ17ihCH/xIBuB/1QfbhhhaAAAAADGEAh+AGQAycgOvBvAAA\n", - "AAxhAKLgBkAMnIDrwbwAAAAMYQC94AZADJyA68DbAAAACmHgBoANHIDrwbwAAAALYQb4AaADRyA6\n", - "8G8AAAAMYQNuAGgA0cgOvBvAAAAADGEBR4AaADRyA68G8AAAAQlhAbOAGgA0cgOvMxGCEOcAZ0AA\n", - "QELIAAILYAAgV3nAjAANHABAQE3siwyI3Au4IBIQuggAXD83ZAs2QtwAKj4G60pYLRGJLm/hvgIF\n", - "kCKYUdhQpggsAAIb/hEgAdCuEKqPj3BMCc0hAAEAhJIQAAgMgAFAQMYHNTYOmCaGI33+g6Ef7GBF\n", - "iIrkL+z+8NF/g28NQNWMMJIEoiZFyM2d/lxAgIvJKDViYlalXI7wwmcEErFSBsskSAohnn+gnD1c\n", - "EpJWC7qlT+WGfiACWhxBlXNFMg4CWsCjwiABBhEIXg+DMpuLWv8GGEACK1oQAAgDABA4xZvWYmHe\n", - "N7t3/wCpsKggSqIKjhV93/CsAAAADGEAh+AGgA0cgOvBvAAAAAxhAKLgBoANHIDrwbwAAAAMYQC9\n", - "4AaADRyA68DbAAAACmHgBsANnIDrwbwAAAALYQb4AbADZyA68G8AAAAMYQNuAGwA2cgOvBvAAAAA\n", - "DGEBR4AbADZyA68G8AAAAGJhAbOAGwA2cgOvNEz0D54DiU2oCPXtsAegCgdKjc4AFP5FGH2QeeAK\n", - "A3D89c0MvwQPOapuXOz28Nc9C6wwk2XUYCT4HEA4L3Lyjte52trD89ACGd+v/7t/+JJVJoyRIMOF\n", - "YAAAAAxhAIfgBsANnIDrwbwAAAAMYQCi4AbADZyA68G8AAAADGEAveAGwA2cgOvA2wAAAAph4AcA\n", - "DhyA68G8AAAAC2EG+AHAA4cgOvBvAAAADGEDbgBwAOHIDrwbwAAAAAxhAUeAHAA4cgOvBvAAAAGP\n", - "YQGzgBwAOHIDrzQQsOQHmTliEK7nABIzitj3OQIC0TQoEfeAdHEfhGQ7VvbQ4I24QAAgDgDBxcIA\n", - "AQVAABA5AANAU4AHlU9ceymJAFfP3AAqAGwdnCoGvC6tAAj1YXQY9kAAZAJMgACAwAcVgHYhwgDn\n", - "JAIyJz0fvgO0F1qTZLWeL2AScG6gRv2bYIPBPMh1//wQAB4A48kEAAIIYAAgXAAUBvBOWtV0AkWf\n", - "eBsyCGwkbQI/O30QADdsYMIRDc8xRgJQkGjxHFkdZgRLp+DWg18DLyBxmx+ijqfNSUP/AMKbgOrB\n", - "ZBB9F8qM9hhhAAGgOKbCAAEDMAAQFgAsEoF+0bAVGWNH633+iEQxRmA/B0kCwOrj79M+FeNHBMUA\n", - "OpagABAUAGG+sEGc4RiTShKCUX//3T37nB40GHSdpohwmuACx3gkDmta9jShiyTBRwS0Zu5wYQAB\n", - "0BBrgQAAgdAACAyACgVljNHAA4C/v1JMgHhxHhrg5/20AE9GaUkAq4Qe/rDCql4M6cDrUGaWO/wr\n", - "AAAADGEAh+AHAA4cgOvBvAAAAAxhAKLgBwAOHIDrwbwAAAAMYQC94AcADhyA68DbAAAACmHgB0AO\n", - "nIDrwbwAAAALYQb4AdADpyA68G8AAAAMYQNuAHQA6cgOvBvAAAAADGEBR4AdADpyA68G8AAAALNh\n", - "AbOAHQA6cgOvMJ8v+houGPAA8A/YQYUvPMMVGAJEMEcjijhptriR0vKe0AAIBQAAgBgHDb/vwDHM\n", - "IQDQJgAiC4hZTqRnwdDcvEp5p7AApmBGRQp6zAjjLeFAB5scEUDYZOXg0f3GD4VkfayTNDZSOer3\n", - "/EKAPXRgLJi7OZOQt/nIk2YEFqrcsMvlwiLQgEiAqDacy2iW7bx9f33/xkMpnQVmqLUxupAkkMIh\n", - "AimlEH4VgAAAAAxhAIfgB0AOnIDrwbwAAAAMYQCi4AdADpyA68G8AAAADGEAveAHQA6cgOvA2wAA\n", - "AAph4AeADxyA68G8AAAAC2EG+AHgA8cgOvBvAAAADGEDbgB4APHIDrwbwAAAAAxhAUeAHgA8cgOv\n", - "BvAAAAFBYQGzgB4APHIDry8MeAM6AAICAAAgJRAAGAACAPedmL1gACJXt4GAAJ0MECAATgE4AtTI\n", - "BDkzmEFEYAw5XasAQgiiPB5oQT5g+AYrSgEDTs21IT8HLDcB5k5YhCu5wAOMVdNryHKGBqJsWH/g\n", - "HRxHYTkN1b2zOCVuEAAIAQBgsmEAAIJYAAgZgAKA9gAeVnrh5EWyFpz9+AB0ANimwEAVQL7/AZ1n\n", - "94Y4VwBgihCSAtlgkNfOi0sBvDnYAAgIyAACAkABsQABAHX+v+BwA0QIgACAagAccUgPCLbOxJgE\n", - "gR1pf4egIVYK+XKNnCAgrANTFVtpf6P7ITDPwMroChFwrNR1XutKHvADHW8ET8winFUV9d/gwwgA\n", - "DIFEshAACBUAAICQAoPAnybAFQyxY3Se/4EogjBXMAbYXSGQLrj7/hSAAAAADGEAh+AHgA8cgOvB\n", - "vAAAAAxhAKLgB4APHIDrwbwAAAAMYQC94AeADxyA68DbAAADjm1vb3YAAABsbXZoZAAAAAAAAAAA\n", - "AAAAAAAAA+gAAAwcAAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA\n", - "AAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAK4dHJhawAAAFx0a2hkAAAAAwAA\n", - "AAAAAAAAAAAAAQAAAAAAAAwcAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAA\n", - "AAAAAAAAAAAAQAAAAAGwAAABIAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAAMHAAAAAAAAQAA\n", - "AAACMG1kaWEAAAAgbWRoZAAAAAAAAAAAAAAAAAAAKAAAAHwAVcQAAAAAAC1oZGxyAAAAAAAAAAB2\n", - "aWRlAAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAAAdttaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAA\n", - "AAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAGbc3RibAAAAKdzdHNkAAAAAAAA\n", - "AAEAAACXYXZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAGwASAASAAAAEgAAAAAAAAAAQAAAAAA\n", - "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAACVhdmNDAULAFf/hAA5nQsAVjI1A2EpA\n", - "PCIRqAEABGjOPIAAAAAcdXVpZGtoQPJfJE/FujmlG88DI/MAAAAAAAAAGHN0dHMAAAAAAAAAAQAA\n", - "AB8AAAQAAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAAcc3RzYwAAAAAAAAABAAAAAQAAAB8AAAABAAAA\n", - "kHN0c3oAAAAAAAAAAAAAAB8AABf6AAADMgAAAZ8AAAHxAAABjQAAAiQAAAVcAAAEggAAAyIAAAzL\n", - "AAAK+gAADG0AAA1kAAAQAQAAC94AAAZ5AAAFqwAABQEAAAPwAAACogAAAkMAAAJPAAAB6AAAAY0A\n", - "AAE7AAABRgAAAXoAAADTAAACAAAAASQAAAGyAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAA\n", - "AFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0\n", - "b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU4LjQ1LjEwMA==\n", - "\">\n", - " Your browser does not support the video tag.\n", - "</video>" - ], "text/plain": [ - "<IPython.core.display.HTML object>" + "[<matplotlib.lines.Line2D at 0x7fa12bb72430>]" ] }, - "execution_count": 57, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 432x288 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from matplotlib import animation\n", - "from IPython.display import HTML\n", - "\n", - "style_list=['ro', 'g^', 'yx', 'cs']\n", - "parity_list=['+,+', '+,--', '--,+', '--,--']\n", - "\n", - "# First set up the figure, the axis, and the plot element we want to animate\n", - "fig = plt.figure();\n", - "ax = plt.axes(xlim=(1e-14, 10), ylim=(-60, 60));\n", - "ax.set_xscale(\"log\");\n", - "lines = []\n", - "\n", - "fig = plt.figure();\n", - "ax = plt.axes(xlim=(1e-14, 5), ylim=(-60, 60));\n", - "ax.set_xscale(\"log\");\n", - "for j in range(num_blocks):\n", - " temp_line, = ax.plot([], [], style_list[j], label=parity_list[j]);\n", - " lines.append(temp_line);\n", - "\n", - "# Initialization function: plot the background of each frame\n", - "def init():\n", - " for j in range(len(lines)):\n", - " lines[j].set_data([], []);\n", - " return lines\n", - "\n", - "# Animation function which updates figure data. This is called sequentially\n", - "def animate(i):\n", - " for j in range(num_blocks):\n", - " lines[j].set_data(np.abs(np.real(evals_list[i][j,:])), np.imag(evals_list[i][j,:]));\n", - " return lines\n", - "\n", - "# Call the animator. blit=True means only re-draw the parts that have changed.\n", - "anim = animation.FuncAnimation(fig, animate, init_func=init,\n", - " frames=31, interval=100, blit=True);\n", - "\n", - "plt.close(anim._fig);\n", - "\n", - "# Call function to display the animation\n", - "HTML(anim.to_html5_video())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c4c494cd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "827580b8", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a606aa37", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "30c48fa7", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5af81bcd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "3e7dce67", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 432x288 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.xscale(\"log\")\n", - "plt.plot(Grange, num_even, 'bo-', ms=5, label=\"even\")\n", - "plt.plot(Grange, num_odd, 'rs-', ms=5, label=\"odd\")\n", - "\n", - "plt.xlabel(r\"$G$\")\n", - "plt.ylabel(r\"$\\langle a^{\\dagger} a\\rangle$\")\n", - "plt.legend();" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50f826f2", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "22984485", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 432x288 with 1 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.xscale(\"log\")\n", - "plt.yscale(\"log\")\n", - "plt.plot(Grange, -np.real(gap_even), 'bo-', ms=5, label=\"even\")\n", - "plt.plot(Grange, -np.real(gap_odd), 'rs-', ms=5, label=\"odd\")\n", - "\n", - "plt.axhline(1, c='k', ls='--')\n", - "\n", - "plt.ylabel(r\"$-\\Re(\\lambda_1)$\")\n", - "plt.xlabel(r\"$G/U$\")\n", - "plt.legend();" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2ae076ca", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 432x288 with 1 Axes>" ] @@ -2156,16 +195,13 @@ ], "source": [ "plt.xscale(\"log\")\n", - "plt.plot(Grange, -np.real(gap_even_odd), 'g^-')\n", - "plt.plot(Grange, -np.real(gap_odd_even), 'yh-')\n", - "\n", - "plt.yscale('log')" + "plt.plot(Grange, num_even)" ] }, { "cell_type": "code", "execution_count": null, - "id": "277b6ed2", + "id": "40dc25c3", "metadata": {}, "outputs": [], "source": [] @@ -2173,63 +209,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c2217ee9", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3bdefffd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "136fadfe", - "metadata": {}, - "outputs": [], - "source": [ - "with open(\"GoverDelta_scan.pckl\", \"rb\") as fp:\n", - " Deltarange, results = pickle.load(fp)\n", - "\n", - "Grange, num_even, num_odd, gap_even, gap_odd, gap_even_odd, gap_odd_even = list(list(zip(*results)))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "7f9574e3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "<Figure size 432x288 with 2 Axes>" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.yscale(\"log\")\n", - "plt.xscale(\"log\")\n", - "plt.pcolormesh(Grange[0]/Deltarange[0], Deltarange, num_even, shading='auto', cmap='viridis', vmin=0, vmax=11)\n", - "plt.colorbar()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "36413363", + "id": "5fec5b88", "metadata": {}, "outputs": [], "source": [] @@ -2237,7 +217,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2251,7 +231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.7" }, "latex_envs": { "LaTeX_envs_menu_present": true, diff --git a/Tests/test2.ipynb b/Tests/test2.ipynb index f947a10356b6f9295732c4f8ce8c0d8b85a997ba..e8441906e0757ee53330de43fe30c49055e71f75 100644 --- a/Tests/test2.ipynb +++ b/Tests/test2.ipynb @@ -7,6 +7,9 @@ "metadata": {}, "outputs": [], "source": [ + "import sys\n", + "sys.path.insert(1, '/Users/lucagravina/dptqm/Strucutral codes/Liouvillian block diagonalization')\n", + "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from qutip import * \n", @@ -18,6 +21,8 @@ "import pickle\n", "import matplotlib.image as mpimg\n", "\n", + "from collections import deque\n", + "\n", "\n", "from matplotlib.colors import LinearSegmentedColormap \n", "import matplotlib.colors as colors\n", @@ -27,122 +32,118 @@ "greiner = LinearSegmentedColormap('greiner', greiner)" ] }, - { - "cell_type": "markdown", - "id": "25e250bd", - "metadata": {}, - "source": [ - "# First order PT with symmetry breaking \n", - "\n", - "We take: \n", - "\n", - "$$\n", - "U=\\tilde{U} / N, \\quad \\eta=\\tilde{\\eta} / N\n", - "$$\n", - "\n", - "within the Hamiltonian \n", - "\n", - "$$\n", - "\\hat{H}=-\\Delta \\hat{a}^{\\dagger} \\hat{a}+\\frac{U}{2}\\hat{a}^{\\dagger^2} \\hat{a}^2 + \\frac{G}{2} \\left[\\hat{a}^{{\\dagger}^2} + \\hat{a}^{\\dagger^2}\\right]\n", - "$$\n", - "\n", - "We conider both one- and two-photon decay. For $\\Delta > 0$ there is a first-order phase transition associated to a symmetry broken phase, example which seems in contrast with our general theory. The symmetry is broken because of the one-photon dissipation." - ] - }, { "cell_type": "code", "execution_count": null, - "id": "12b14f7f", + "id": "a967f6f9", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": null, - "id": "bb1fd10c", + "execution_count": 29, + "id": "4b11dd09", "metadata": {}, "outputs": [], "source": [ - "a=destroy(30)\n", - "\n", - "γ = 1\n", - "ηtilde = 1\n", - "Utilde = 10\n", - "Δ = 10\n", - "\n", - "Grange = np.linspace(0,15,15)*γ\n", - "\n", - "gap = np.zeros(Grange.size)\n", - "n = np.zeros(Grange.size)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2b01d874", - "metadata": {}, - "outputs": [], - "source": [ - "Nvals = np.array([1,5,10,20])\n", - "\n", - "fig,ax = plt.subplots(1,2, figsize=(15,5))\n", - "ax[0].set_xlabel(r\"$G/\\eta$\")\n", - "ax[0].set_ylabel(r\"$\\langle{a^{\\dagger} a}\\rangle/N$\")\n", - "ax[1].set_yscale(\"log\")\n", - "ax[1].set_xlabel(r\"$G/\\eta$\")\n", - "ax[1].set_ylabel(r\"$-\\Re(\\lambda_1/\\eta)$\");\n", - "\n", - "for j in range(Nvals.size):\n", - " N = Nvals[j]\n", - " η = ηtilde/N\n", - " U = Utilde/N\n", - " c_ops=[np.sqrt(η)*a**2, np.sqrt(γ)*a]\n", + "class Parameters():\n", + " def __init__(self, Δ, N, Grat, ηtilde, Utilde):\n", + " self.Δ = Δ\n", + " self.N = N \n", + " self.ηtilde = ηtilde \n", + " self.Utilde = Utilde\n", + " self.U = self.Utilde/self.N\n", + " self.η = self.ηtilde/self.N\n", + " \n", + " self.Gc = np.abs(self.η*self.Δ/np.sqrt(self.η**2+self.U**2))\n", + " self.G = Grat*self.Gc\n", + " self.n_sc = lambda g : self.U*self.Δ/(self.U**2+self.η**2)*(1+np.sqrt((g**2-1)*np.heaviside(g-1,1)))*np.heaviside(g-1,1)\n", + "\n", + "class Kerr_2γ():\n", + " def __init__(self, Nfock, p):\n", + " self.Nfock = Nfock\n", + " self.a = destroy(Nfock)\n", + " self.parity = 1.j*np.pi*self.a.dag()*self.a\n", + " self.parity = self.parity.expm()\n", + " \n", + " self.p = p\n", + " self.c_ops = [np.sqrt(p.η)*self.a**2]\n", + " self.H = -p.Δ*self.a.dag()*self.a + p.G/2 *(self.a.dag()**2 +self.a**2) + p.U/2 *self.a.dag()**2*self.a**2\n", + " self.LL = liouvillian(self.H, self.c_ops)\n", + " \n", + " def bd(self):\n", + " P, block_bfs, block_sizes = block_diagonalize.PermMat(self.LL)\n", + " self.bd_L = np.dot(P, np.dot(self.LL.data, np.transpose(P)))\n", + " self.num_blocks, self.blocks_list, self.bl_indices = block_diagonalize.get_blocks(self.bd_L) \n", "\n", - " for i in range(Grange.size):\n", - " G = Grange[i]\n", - " H = -Δ*a.dag()*a + G/2*(a.dag()**2 + a**2) + U/2*(a.dag()**2 * a**2)\n", - " LL=liouvillian(H, c_ops)\n", + " done=False\n", + " for i in range(int(len(self.blocks_list))):\n", + " block = self.blocks_list[i]\n", + " evals, evecs = Qobj(block).eigenstates() \n", "\n", - " evals, evecs = LL.eigenstates()\n", + " ss_block_form = evecs[-1]\n", + " evec2 = spr.dok_matrix((self.LL.shape[0], 1), dtype='complex')\n", + " evec2[self.bl_indices[i]:self.bl_indices[i]+self.blocks_list[i].shape[0]] = ss_block_form.data\n", + " evec2 = evec2.tocsr()\n", + " evec2 = np.dot(np.transpose(P),evec2)\n", + " ss= Qobj(evec2, dims=[self.LL.dims[0], [1]])\n", + " ss=vector_to_operator(ss)\n", "\n", - " gap[i] = -np.real(evals[-2])#-np.abs(evals[-1])\n", - " n[i] = np.abs((vector_to_operator(evecs[-1]) * (a.dag()*a)).tr())\n", - " print(\"\\rCompleted %d/%d\"%(i+1,Grange.size),end=\"\")\n", - " \n", - " ax[0].plot(Grange/γ,n/N, '.-')\n", - " ax[1].plot(Grange/γ,gap/η, '.-')\n", - " print(\"\\rCompleted %d/%d\"%(j+1,Nvals.size),end=\"\")" + " if np.real(ss.tr())>0.05:\n", + " ss=ss+ss.dag()\n", + " ss/=(ss.tr()) \n", + " if expect(self.parity, ss)>0.5:\n", + " num_even = expect(ss, self.a.dag()*self.a)\n", + " gap_even = evals[-2]\n", + " else:\n", + " num_odd = expect(ss, self.a.dag()*self.a)\n", + " gap_odd = evals[-2]\n", + " elif done==False:\n", + " gap_even_odd = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", + " gap_odd_even = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", + " done=True\n", + " return num_even, num_odd, gap_even, gap_odd, gap_even_odd, gap_odd_even\n", + " \n", + " \n", + "def get_cutoff(p, c0=5, cmax=100, step=5, precision=0.005):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " k = Kerr_2γ(Nfock=c0,p=p)\n", + " nprev = k.bd()[0]\n", + " c = c0+step\n", + " while c<cmax:\n", + " k = Kerr_2γ(Nfock=c,p=p)\n", + " n = k.bd()[0]\n", + " if metric(n,nprev):\n", + " c -= step\n", + " while 1:\n", + " step = np.max([step//2,1])\n", + " k = Kerr_2γ(Nfock=c-step,p=p)\n", + " if metric(k.bd()[0],n): \n", + " c -= step\n", + " elif step==1: return c \n", + " else:\n", + " nprev = n\n", + " c += step\n", + " return np.inf\n", + "\n", + "def map_cutoff(Utilderange, Δrange, Grange):\n", + " C = np.zeros((Utilderange.size, Δrange.size, Grange.size),dtype='float')\n", + " for i in range(Utilderange.size):\n", + " Utilde=Utilderange[i]\n", + " for j in range(Δrange.size):\n", + " Δ=Δrange[j]\n", + " for k in range(Grange.size):\n", + " Grat=Grange[k]\n", + " p = Parameters(Δ=Δ, N=10, Grat=Grat, ηtilde=1, Utilde=Utilde)\n", + " C[i,j,k] = get_cutoff(p, c0=5, cmax=100, step=5, precision=0.005)\n", + " return C" ] }, { "cell_type": "code", "execution_count": null, - "id": "bd572225", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c1548313", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c10aab12", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a967f6f9", + "id": "d73b1b75", "metadata": {}, "outputs": [], "source": [] @@ -186,54 +187,22 @@ "The question is: how does the hysteresys area change in the remaining parameters ($\\Delta$, $U$)?" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "fc227a61", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "30b74167", - "metadata": {}, - "outputs": [], - "source": [ - "a=destroy(30)\n", - "\n", - "ηtilde = 1\n", - "Utilde = 10\n", - "Δ = 10\n", - "\n", - "Grange = np.linspace(0.1,8,35)\n", - "\n", - "N = 10\n", - "η = ηtilde/N\n", - "U = Utilde/N\n", - "\n", - "c_ops=[np.sqrt(η)*a**2]" - ] - }, { "cell_type": "code", "execution_count": 3, - "id": "28ebc4a6", + "id": "3004e4b2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Completed 35/35\n", - "Time: 33.25240898132324\n" + "Completed: 20/20" ] } ], "source": [ - "parity=1.j*np.pi*a.dag()*a\n", - "parity=parity.expm()\n", + "Grange = np.linspace(0,2,20)\n", "\n", "num_even = np.zeros(Grange.size)\n", "num_odd = np.zeros(Grange.size)\n", @@ -241,61 +210,25 @@ "gap_odd = np.zeros(Grange.size, dtype='complex')\n", "gap_even_odd = np.zeros(Grange.size, dtype='complex')\n", "gap_odd_even = np.zeros(Grange.size, dtype='complex')\n", - "evals_list = []\n", "\n", - "t1 = time.time()\n", - "for g in range(Grange.size):\n", - " H = -Δ*a.dag()*a + Grange[g]/2 *(a.dag()**2 +a**2) + U/2 *a.dag()**2*a**2\n", - " LL = liouvillian(H, c_ops)\n", - " \n", - " P, block_bfs, block_sizes = block_diagonalize.PermMat(LL)\n", - " bd_L = np.dot(P, np.dot(LL.data, np.transpose(P)))\n", - " num_blocks, blocks_list, bl_indices = block_diagonalize.get_blocks(bd_L) \n", - " \n", - " num_keep = 15\n", - " evals_keep = np.zeros((num_blocks, num_keep), dtype='complex')\n", - " \n", - " done=False\n", - " for i in range(int(len(blocks_list))):\n", - " block = blocks_list[i]\n", - " evals, evecs = Qobj(block).eigenstates() \n", - " evals_keep[i,:] = evals[-num_keep:]\n", - " \n", - " ss_block_form = evecs[-1]\n", - " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", - " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", - " evec2 = evec2.tocsr()\n", - " evec2 = np.dot(np.transpose(P),evec2)\n", - " ss= Qobj(evec2, dims=[LL.dims[0], [1]])\n", - " ss=vector_to_operator(ss)\n", "\n", - " if np.real(ss.tr())>0.05:\n", - " ss=ss+ss.dag()\n", - " ss/=(ss.tr()) \n", - " if expect(parity, ss)>0.5:\n", - " num_even[g] = expect(ss, a.dag()*a)\n", - " gap_even[g] = evals[-2]\n", - " else:\n", - " num_odd[g] = expect(ss, a.dag()*a) \n", - " gap_odd[g] = evals[-2]\n", - " elif done==False:\n", - " gap_even_odd[g] = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", - " gap_odd_even[g] = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", - " done=True\n", - " evals_list.append(evals_keep)\n", - " print(\"\\rCompleted %d/%d\"%(g+1,Grange.size),end=\"\")\n", - "print(\"\\nTime:\",time.time()-t1)" + "for i in range(Grange.size):\n", + " Grat = Grange[i]\n", + " p = Parameters(Δ=1.5, N=10, Grat=Grat, ηtilde=1, Utilde=1)\n", + " k = Kerr_2γ(Nfock=40, p=p) \n", + " num_even[i], num_odd[i], gap_even[i], gap_odd[i], gap_even_odd[i], gap_odd_even[i] = k.bd()\n", + " print(\"\\rCompleted: %d/%d\"%(i+1,Grange.size),end='')" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "bfe6d8e7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "<Figure size 2160x648 with 3 Axes>" ] @@ -309,29 +242,34 @@ "source": [ "fig, ax = plt.subplots(1,3, figsize=(30,9))\n", "\n", - "ax[0].plot(Grange, num_even/N, 'bo-', ms=5, label=\"even\")\n", - "ax[0].plot(Grange, num_odd/N, 'rs-', ms=5, label=\"odd\")\n", + "g=np.linspace(Grange.min(),Grange.max(),1000)\n", + "\n", + "ax[0].plot(Grange, num_even/p.N, 'bo-', ms=5, label=\"even\")\n", + "ax[0].plot(g, p.n_sc(g)/p.N, 'g-', lw=3, label=\"SC\")\n", + "ax[0].plot(Grange, num_odd/p.N, 'rs-', ms=5, label=\"odd\")\n", + "ax[0].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", "\n", "#ax[0].set_xscale(\"log\")\n", - "ax[0].set_xlabel(r\"$G\\,/\\,\\tilde{\\eta}$\")\n", + "ax[0].set_xlabel(r\"$G\\,/\\,G_c$\")\n", "ax[0].set_ylabel(r\"$\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", "ax[0].legend()\n", "\n", - "\n", "ax[1].plot(Grange, -np.real(gap_even), 'bo-', ms=5, label=\"even\")\n", "ax[1].plot(Grange, -np.real(gap_odd), 'rs-', ms=5, label=\"odd\")\n", - "ax[1].axhline(1, c='k', ls='--')\n", + "ax[1].axhline(-np.real(gap_even)[0], c='k', ls='--')\n", + "ax[1].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", "\n", "#ax[1].set_xscale(\"log\")\n", "ax[1].set_yscale(\"log\")\n", "ax[1].set_ylabel(r\"$-\\Re(\\lambda_1)\\,/\\,\\tilde\\eta$\")\n", - "ax[1].set_xlabel(r\"$G\\,/\\,\\tilde\\eta$\")\n", + "ax[1].set_xlabel(r\"$G\\,/\\,G_c$\")\n", "ax[1].legend()\n", "\n", "\n", "ax[2].plot(Grange, -np.real(gap_even_odd), 'g^-')\n", "ax[2].plot(Grange, -np.real(gap_odd_even), 'yh-')\n", - "ax[2].set_xlabel(r\"$G\\,/\\,\\tilde\\eta$\")\n", + "ax[2].set_xlabel(r\"$G\\,/\\,G_c$\")\n", + "ax[2].axvline(1,c='grey',alpha=0.5, ls='--', lw=3)\n", "\n", "#ax[2].set_xscale(\"log\")\n", "ax[2].set_yscale('log')\n", @@ -343,1924 +281,132 @@ { "cell_type": "code", "execution_count": null, - "id": "75c91a3d", + "id": "2d909281", "metadata": {}, "outputs": [], "source": [] }, { - "cell_type": "code", - "execution_count": null, - "id": "269ac485", + "cell_type": "markdown", + "id": "a199be0e", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "## Estimating convergence of Hilbert space truncation" + ] }, { "cell_type": "code", - "execution_count": 7, - "id": "f5b4e87e", + "execution_count": 5, + "id": "971b6bfa", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "<video width=\"432\" height=\"288\" controls autoplay loop>\n", - " <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQABcmhtZGF0AAAAXmW4AAQA\n", - "AF5MUAAQ5JNScnJycnJycnJycnJycnJycnJycnJycnJydar//8ThXwAEzIxKMhOc08dhf8zIxLyF\n", - "RhcSjPPIcYgs5BDSGtXXXXXXXXXXXXXXXXXXXXXXXXgAAAN3ZQbuAAEAABeTFAAEOSTXcVxD4cJQ\n", - "AEyIxqhCI4voR+gRFCVQxi8NH4nf3eRkQ0UhUcT0o/AUkB262VfJR//sRgD6DGARj+QSPV6yINEH\n", - "HeT+bPnq9pGGUfNNcEJp8e/72EZBlGEvp+VZRa7F4jw/ivmRGNUIRHF9CErtuftDBwABABAhAlMx\n", - "e/gFHlh5VNy3BcRxHCPpDt5LACqlGAYQwt/TYI2gtNTLz3wp7JPj4BEKPthDvoN5PmACNtvRTYMK\n", - "sGg6K6h+AAjIjM0REZsi//6mtoAGmh6FLiAyRHEfDxgh4ACbMbzYoYyuQksOI4jwD8EEAMwrall7\n", - "9WL77777777777778RmI/847AhVOZAsigyRgh3F5vrJxurUkNUQji270P4MAldpzJtM7eWkzxfdi\n", - "j5uoEVn0URjPzBjNBENhQI2lPJoc6t4DJ/xWu4BGMlPBLnAEmjxFZ08iOI7iX4bh1qfQYcCAo5BI\n", - "QHcbNs3a8OGDFgcAAlwJMeD3hw/kzEj88G/3/fT4jDEfHw9gAPkOM4s5BCmtVTAACAECGkx58J1q\n", - "v/+FeFYALjDRRkPLcY89XgBRBife4hP735n+A0QrgzkIClprKqMWCQuDUa92NIP9/UBigf5+YE5B\n", - "rf9cMMD1zU4IrRekWP5wBHNQx5BCDqHYAEZiI+RGQ1//gKg17CJTmfvYixPAGCuqEEKfrv+ABgH7\n", - "1wHTkq7U2FSjQ8qttEjav1DoOIeFIhn/wAMLyUz0m7EFYTBJjBLbu8HnCBEtBD80xCb7D0+B3mTI\n", - "cRzlX/4FAjE7zfp8q+4Q/4YwaYGuzhxc077/ABNAS+FYOKYEZ3MAwERT6EwSZgymRQKSs1r/gIu4\n", - "MaZ12r5eARpGmJ8pFdlMIQikzjZmcBx/8Ci1f/972zbG/Uqu6hhh4IyCKVCYVEWL0oaWlpaWlpaW\n", - "lpaWlpaWFlAAhHuaa2n8ALGwmOeEGMg5aHlJXIc/+nGvAGvXul79zMDZxEIR1g5Urw+PbAodkT5C\n", - "lmyiyN4hHr6+UpLBqFJMFfz0nPQtKcT4krJpLMfVA/+PAjlPluACOlm9Ema+clqNpmKKXEzj+YQa\n", - "UQ7ALZBiGqCAAIAxSQFazWqcGVjr9TBS35GA2EGBlyp8HLgyAAoRbDhBtIaTUBK2CTgEfXfd//w4\n", - "XxK5qQ+f+komuvAAAAQzZQNrgABAAAXkxQABDkk1xxf/4SgAvIJUHQ8p5jz1e8Zhi/WYlP53Znh2\n", - "DUvD2a52sIP9/Vr4F8bmB+81v+v/w//hKGA4AAgAgQgSmcfMtMPAAJf4C/zz+AB1LIwbuQTRTL/f\n", - "G8AFaT2PEANA5ufgQtaZMjenrwk+1g8zlbCFE//wSNQGjgZsJmNkXN8M9CqcEjjkBE3Z5Ec3z///\n", - "whTABNMfhSMUGPn8ACIvkpm0mYBOEXLX4v/9+6Lg0IL9Bji3sbIJwT9d5NBS+D/nvRFvEyIlHCkl\n", - "V4H+ADJppGTYui+yYECpmtIUgm+AAZMhpik7mchXD4grXQC3fWUrCf+DH7ITo3GImVzDzK5+HmVz\n", - "DzK5+Tk5OTk5OTk5OTk5OT/6+YjhzAAg2o1sXReABuWsqwpTAMPv/UbJsNOUD1/bAfmBc0MiAvHu\n", - "MJRrkm/we4hHgMUUSiQhOlEAUdeVDMsen/EZhKwK/DA4EBR7L80cHvxCAx/AAbF+sx1AIwfcdkfO\n", - "hURLXgTN6YAC3vTaDkDl/UN3vdv6l2TgcXL+32TegYkVeJcmGSjMz71fH3+x8DFMIAhSTK340Scn\n", - "wH/4hLbmXiOxNPksSun2oQ4aKsBy/nhg5e4aUCYNeof/wVwA3ZApdXNH3/4YccAxAACRUn3+v+v3\n", - "/bw///4ewHAAEAoAhoSmcnJ1qv/nIYQe+AIARjUPcY9B1AaA1GdjteS3HS+YAjVRPLtKdOFX3lTj\n", - "h9zEIgyncEv/+AHIjGqEIji+hH6AHIU5dsGprVft5GRDRSFRxPSjy/7gaifaUiy2F70SMVmYSqMp\n", - "xTinHq8GANEUZhxIcoqUjsADC5mXERMf/YfwFYS5hUJ3PztRY3ACBHVCSFv1wf/9YPj4HrjE2Rkx\n", - "8PX26iT76Q39rf8ARTYGM59avRdBgAHNybqfXwMDcECEx4St82sqTndh6O7KzABD80QazGA5WiII\n", - "cDvh/4EBLwAGfom6epMwAAiYh5ZzCIB/wp9NBd7wqkYlxf2D/ahphUtJaS89Xv/gCpoh6Z/6Y73v\n", - "gIBUuB52ESQqCe+YUL1y0kSdeDS6WlpaWlpaWlpaWlpYWUACIP0k3pP/+ADnoWUtYhyDzYbHNCjG\n", - "IqOvAEvV7pf9zYBwhDAn9tb4G/suTBEUffAufWqNrbdDl0PdodZS1MtPhUK36WhvmKCIP1e4ggxa\n", - "EAAV4JHAVqNaiZl8DD17oOnUMg4bsMSBdd8qhMAFz+Lf/9o+5tmH/W8C8tZVhSmAYff+/NqNbF0X\n", - "mARigfLUbJ4acoHr+2B4H5gXNDIgLx7n645PTjYJ9KIgBEJfAa85fif/87je6Sip4/wSBbhBBWaO\n", - "vN9bg18DCotwZHOTX99BC0HrzcOzMMMs/vFtZ+yH8JfYbgBVNZGMyfjqBhx6Q9LYcAIQLu5xh+NJ\n", - "1AGHP+uuvAAAA4VlAUbgABAAAXkxQABDkk1J/D/N+EsBwABABAhAlM4+ZNMPAAJTb/+GJOW4Rf/4\n", - "awAjlipHKym7TSXgwYAZ3f/v/XPp1JuAkb59G+t88/3g0PwAE22222222AB6cB3RhUIaj78H//8I\n", - "YAhbbbo8B5lcwEi9aXN///JycnJycnJycnJycnJ/6j4+CyA4EYoHpngEVEyiGV/9bdBhKaCACKxs\n", - "Fz94CAogB7H+IxamCuJ8UAAQHMACEC+wNCRBgg/umayA4YdXQAR8lZxm5q37k1/3sMDmXaQMVhhb\n", - "P9hckcQscsf9QMwKU5zHr7/ZcMBCpkExl85TZB/LwhTUR32RyDPV/BM3fwwAHiwOAAICQEGQnFBJ\n", - "q76VooWbrlpeCsrPqLGiAXXpuPWrAyqY2D2opXIfMgERw5TXr8QMcRhucb/6TYctQU9Lsfi7xKxY\n", - "Q5Lvfp08bw1gBQwN9Nc2+uL5wVJ572/G9GNf4fj+CLAcAAQCgCGj0z5Sbk//+IBCvgAuMNFGQ8tx\n", - "jz1eAcAAoAUFPy3wiAm6gZBp+gnPxjB/8P8EEAF5GEQfCnmPebteAqIAMQ+9ejt9Jxn/B5wpgGAc\n", - "JQAXkEqDoeU8x56vAfDw7jLizQSyuAHIjGqEIji+hH2RkGQaS3mMebtALEAA0ZB0OPZw9UG/7cjw\n", - "YpJMPLb84zAAasoyQynbPKDP8GOwC/IilGRjX4ADxkQ0UhUcT0otRBnHqCyTX67+H/61XXXXXXXX\n", - "XX/AEjh4a8AQiRysZ48ABqS+V6MkV4n9+/cagw9RRpaCmO+2P4c4VphEyOBJiNbb8AkZRDs++nrr\n", - "rjv/BH5pvmehV+YeWPP4BFNJmigN/aAwatzM/5+ABEW4lMfRP2NXa2X+rNeszfVA/+1DlOoamKDT\n", - "b9CIgFmKgO0//IJsYSlgB6vli6DeZ38/tQ2i1dwAwL+WI3sOAGhvMFSEIAJqbBBcqziTxgjdUzwA\n", - "oin2PFUSv/8ClD1Xedz/vQMzavxO//PtTtwCIzk9H/rj3TkqLZ/8MzlE2OL8qWmOEYrou1tpXjr4\n", - "Qcr++myZE0NR/zkBhsIAdQTxKSHJuGI7yp+Vet/ZDz+8GMU0QYLJ3+xzuOOpoAUaoltwTwAV9huC\n", - "MnIES7qVzwwA6mN4pVhsQQGwr0aNGLf9KbbmDElAgAAiOZHZj3XvIkXcFtRACBE9e9+o+K8H1uuv\n", - "AAAD0WUBsuAAEAABf8f6+KigACBBABeQSoOh5TzHnq9/zMjEoHQkNX7YS+78YaZhUozfwBNMi3jD\n", - "TMKhGb+Hg7JnyIiEg6EZzBL+F80sDLApZb3v3ARgDEZDRCkVxAEYyGYEIhGAce++HY9cbB5QHAIT\n", - "8DKon2nHceAhtU1+D4ETi/Sddx3ilV/wfJBR3KjIpS9YPhEEHdemPQhzhpP/wf/wCbYIYALjIMg2\n", - "lvMcSbtALkOMQWchzSGtgEMJnymLAAmrPeI4x3/qo+gxRNVL/+/+3P4DgACACBCBaZ+eH9yMzQmy\n", - "lVmXDIwiDoWU8zAtrsVqBcdu915kJay0BI8HsAdzaWeCvyZiR6r3/75jDvAB7sJjnhBlmA5Urw+L\n", - "bYKHZE+RyzZ4G7CENCYdJcQdtNhL1YFArU4HORohxWOPUnJycnJycnJycnJycnJyf//iEO+ABCBf\n", - "YGhIgwQL+6ZrIDhh1dDwI5T0wqEASLAqpGwco+wAyL0ChT/AQfUAcOE//T944d3QQgAcqA4yMQCG\n", - "qAasrM84GCDpzP7wYNU82fzwAJiln6KfCRO+z+wDJF4RMjC9wBXfB4+uQFszLdxp7I+eQB+ePhAq\n", - "Ut53MNTx/9EA4VDCSnE88f0H4b4qSUX4Mj//IOsOlnm7q3/ADqY3jusPA4ABS4GAANgyjzvz34MF\n", - "/gqnnv8P/4IsBwABAKAIaPTO0mKyf4/1NHhSGBqIAwgv//e81Qj34ABEGvYRCcz9PB2DPiIITr3U\n", - "I7fTqfAhIiXQnFtWS8Nf8QE3L2C4zSxGE1PEBlAo5HFNWvW1YB3QZOVwhXpwqOdv/uX/+E+gMfUp\n", - "12texzv9//4SCE6bYpVXT//e/4zCF6s1KOz1X4fhEJm0tnC2SS8P6OH/h/gGaaB8gwxrdX+wC8PW\n", - "DQYYx9r/f9lgA/+g1DCgXAd2uCPR4/TmxUrFYi7X/RFpnQxtxo2ms+kfPZ5mZ/wMLB/6DUFLQ8pK\n", - "5FcosjPEISlF8/5jKUZj/7+/4DoUWZDmuV3+vntwNgia6txpKRIkf7666666666666666+keH+g1\n", - "4XJHELHLn/X/0s4ClSFo6v2VbPRI2gwzoQkhH+DIj75+EW1oPM4R+QCxBH3n/D/+4LGiVh75KisV\n", - "cv/fmgGZTCJu2un/gAK5LUbTMUWABz6RRgPjOb2op4vvqr91tPbrgJqRQf2CSTGyYhta99Hx2e/f\n", - "eHd/hYuly1mErCyl99CDkMhBmXvnmi4g9CHzp9huA2FejRoyv+DDtT9Ab8vQFnMPecUon8sxh7f+\n", - "eWffApLPeiRD0tLgAAADVWUAh7gABAAAX/xP/hKKAAIEHgAvMwijOKeaDwTN2iAACoAAgCD0AAog\n", - "hOvdQjt9O/zYcZyI6IUuW4f+AYJ5YAAgyYcABEGvYRKcz97EeXWgP8+YBAgPfAD0IhSgOOeIhtqA\n", - "mBw4uazCMKLNmAKCXuIlO52+ArAzoMpFItlEljW/wEI2AMM7EPS9xu0M8EImAMEfqHJc83aAURSZ\n", - "8H3OFrot5/6rUACUF0QVKegspjwZVQdKsXVcsL2jwIhM2VQXxd2yhj94fjERwngOAAIAIEIEpn4A\n", - "Og17CJTmfvYj8E8AYK6oQQp5LXB+TUnJycnJycnJycnDGAAjSTTM2Q0IQ/CHfXgmbbPBP6rAAe89\n", - "GajqkN/ezEj47zYuj75mb4egkiNoDgB41TjNNHiMV1JycnCGABDa+vq//4AtEjlY2e/4cwQMIfAA\n", - "1JfK9GSK8T+/fABl/SyZ/IE6um9EkH++3GoMPUUaWgpjvtj+HP//Hf3HwzjQGmYJG3QffORHqEAT\n", - "em8BPtecHIEf03vGLI/gH33uViU3P7H8wsJ0MYAayo4hynxWV1//xAgGL6yPrwBScAAhNpEkBtZo\n", - "X0+Y4TS6HgrUqtTR5hsYIS3y4XtzfwGL1W9W4ljt9SBLKJN+yqbINNxEniYBHQCJEMIdLfDsldXr\n", - "Aa6D/594x9HCi8AG7ywnZfUlD9TOeBPaWjEcNZvv6L0/J/hv/VGhpcVGdgwQMAHIqF3Qq+/qDzoA\n", - "CmWErwwFv5eMMHAAOFZCd219kLu77tcRgnCwcwkTQQU167v+H/8PYDgACAUAQ0emcmKyddd/rrrr\n", - "rrrrrrrrtaWlpaWl//4QQLoAOaG+YoIg/V7i1UYRMyCAAIjOf4Tj4vACp+WIbCcgBWAASyMr4HAQ\n", - "EHoAAE0tcGWJUEYfR6wK0xz1d7gwAQShxnfHCvGBYMnUR/cA0a/ycgNCe/+7gXeBctQdX/+3jt5A\n", - "UOOrqNhBCzwpLYZsMHqmaSjH1QAWws5axFzojKLmQWDp/AcI6AwACoAAgCBcCMLJ1ydGhXE44JGj\n", - "bZmABjtiYPSi1cYbErEj6y+zxqgE16fIrQAAgAedkoedfw3PHuRkbSkY+q9xjkPFAvrPDhsFCFm5\n", - "ytszO+23w9eH+sQ9deAAAAMcZQCiuAAEAABeTFAAEOT/j4jGH+AAiDXsIlOZ+9iPGiWMIkF88LgB\n", - "6EQpQHHPPhtq4ZIQsoF1WpZvK0BMQbgcQ1jF5r1pv/cDJ35VA0HirUbveIJe4iU7nb4CsDPAyk7c\n", - "NueKuTbMf9lqoAEoLoguW0GFwykKAw94iG2ryAOOFodCeYTelWvh+DKqDpVi6pCwvaPAiEzZVD6L\n", - "u2UMfgw7/GP+EoYDgACACBCBaYAAiDXsIlOZ+9iPwTwBgrqhBCnva7n8nJycnJycnJycnJycnJyc\n", - "nDGABCPc01tP4AWNhMc8IMZBy0PKSuQ5/9AXXgDXr3S9+4mEXiH6DWlUrw+PbZByJ8piAFAU9vqL\n", - "I3iEevr5SksGoUkwR/PfikNNMhxcWMkQ4QNWhAAFIGgBWs1qwS/1uVPg5cGRChy/7/vzJ1DgJMpU\n", - "PA/ABfR1HEQz8wAKR+GkhgBALNzXpRgjwwdx+LOUx/Znh97xvKiD1Ux7MUf3sABbkqDUhVDIJ+Lo\n", - "ZbskY5GqDE+CBwABATUMEARi4ZQGEroJBDLIg1HoR6Sd+hD10npt+PYN+NgD6UOaQeWEwiaWAFOv\n", - "++PoNwAABAC+CAI0FsOYDm2NEnUw9KBgcAApFCCBfBRDlLDuUt4wbpDqWHdSxtPaAMOERpL8P/4I\n", - "sBwABAKAIaPTO5JisnWr///nCvAARhDV7UG6/sO0w/hExiEoF1MVuUyzfAy9/QPiOFFnKhnaCEhd\n", - "IvLxVFk+l11111111111111111wsoAREPekgjV74AILyUz0gAMTNeVua0yyyHcpPfd4Keks/gX/+\n", - "VEtLLQ3//dKDxzXD1gCibCRTrcBsVQ5RfBAdsxlNxNdqkJhURzQ1xgquh2bCARa8EAWcNXVzdoHG\n", - "IlhzjcsfXMh6kUjrfUqSjHIDqf6SWZgTFCovPf+BwEBB7IGEBSVNylh/UqqRo9//mk8bIXdOvR5t\n", - "b2BwHMIABIB0NVkH5R/6W5J38a6Y4/3AMOmjP9qdahrQLgwyyxqyfaptCvUiBJT4MYYf//MLxEb4\n", - "ev8gjX9ubtt4f82If1LS4AAACbxlAL24AAQAAF5MUAAQ5P4//D8ABGEuYVCdz87UeMEg8RPq//CU\n", - "AiDKDHFjlZkcP+/fzMzGoiU6Ajqz2TID+MhTZcQ50L7zIzEqFIrC8hPWRkGQZxbzAeCZu0QAAUAA\n", - "EAUeg4oiKGbE5Sqv9pszPY1X3/9+xhh/4egA7CXMKhO5+dqPwbgBBXDWs9xDbXB7qCbk5OTk5OTk\n", - "5OTk5OTk5OTk4YwAIg/STek//4AOehZS1iHIPNhsc0KMYgH68Aa9W6XvXF3RgE2RcUAAQH8AVFjd\n", - "3V+AOAiFsTAJUczJRXADgQl05O2wYG/suTBEUffUT61Rtbbocuh7tDrKWplp8KhW/i3Epj6Jw+mO\n", - "7HLzAIE//rwAyLLFp/94GFlQQABkUpYFFPynAHkhwK1GtR1UWkwAtbChRtJpEOOK21PXug7eGTtl\n", - "CJYBjf7+AFHobetGIHLfbP//xACRDiaPhV/w//D/+HsBwABAKAIaEpnJyda///gh4ACRkQ0UhUcT\n", - "0o8v+/94T4VgAfANBko3HlmBhFvuAHMjIMuFeHKwRLkPGGucUdmlLUW/heAAAoMYl7kw9NLxETFw\n", - "iEO4GWTVBvwalKPlLxS0UsL/4zJCw6E7wNsoaX8RBife4hKd5NZ/wwwCCCH8jIhopCo4npR5f89x\n", - "+AAiIyMiMjMjIz/8AB0YQn3mpHrVtjwfvj8ABGRGZkREZmRH//wAHiIhIhCDns5A8f//BhMLYTCf\n", - "H4ACMyMiIzIiMjP/4AD5GYlQpBj28odh33x+AAiIyMiMjMjIz/8AB0YQn3mpHrVtrwfvj8ABGRGZ\n", - "kREZmRH//wAHiIhIhCDns5Q8fhplv/BhMLYTCfH4ACMyMiIzIiMjP/4AD5GYlQpBj28gdh33x6gA\n", - "IiMjIjIzIyM//4ADowhPvNSPWrbHg/iGY/hAEEOcQCmZ0B2m+7V3pirDuJZ/eBr2LOViOerw2QYA\n", - "Xni+7FHzdWHumYVn0iiMb8Brh23NicQcACKYHew7vACX13/kY+cZfW8a4Z5nxiEIVU5ozD8AwBj/\n", - "wACZnZQoQpVfozBC3ig+AAkREJEIQc9nIHrkgQmnouRoPYFJpr1pnuMbMavz3//B/ICDgwYACURR\n", - "mHEhync6WlrvvDeHH4BSeAX4ALiDQd6HFg5QRPV7AkRS5siOB/FNL/sALCTOKhG72bqegp8gYPVk\n", - "OSP+gKMpVVQZUsYwTx/+DIAAJgACAEAQg0AZB+IM3PIQIwt28QadxEoze3cT2c9BCAffxkGL1biE\n", - "9npzwxkkABQI8OAw2MINQtB29MBRAmujRekOs/7wEiTDlNekIp04q/vFgACDJsRMAYI/UOS4k3aD\n", - "+wBoO/X48luvPn/sZgGEe5z3E/v77/5dK4/hABuF8AF5BKO9LigcqInq8Ao1J2E3U8f4IaL/98zM\n", - "xqpSq4vpT9iNgDBHYglL3G7RaZDwACQBgQ8mGAAEwDAtxMAWBGHKe8bETamA0BDOcJpSqD7Pvvzw\n", - "AAAgRDwFHC1DEYxHQVbf+DvMBoOItHcOAEhlosjkXNdmhZY+sRMAYI/UOS4k3awBiKCRBKWTiKPL\n", - "DwwGQfRVcJebUIvdvARCKygNur+jn4b4fA1KojuupehpJPBh//9Jwp4ALiDQd6HFg5QRPV6CnyBg\n", - "9WQ5I/6AoylVVBlSxjBPH/7tAAcFDlv8jIhopCo4npR4EiKXNkRwP4hhn9vGEmcVCN3s+04Dxggg\n", - "AdFdAxdN29Zz/gcgAAqAAIAgBSDQBkH4gzc8hAjC3bxBp3ESjN7dxPFgACDJsRMAYI/UEJc83aD/\n", - "mPkH8J8AYCFS04jNOZ7EraHpgoYTMZhOFlnz//1GGEAvwAXGGijIeW4x56vYFgdceFQ5kP3fACgl\n", - "7iJTudvgKwM/gAIwlzCoTufnaj+yAACQAAgBgEILIiDcfC2mvJN2vGGucUfmlLUMlcL4qI3CBDiF\n", - "/GQYvVuIT2enPD8N0iHQSr30kU8ussAVLGAZlNC2i/LL+8gAAoAAIAYBCD8EQiESSSiy1rQxICQB\n", - "gh98ul97xz3UwENd8APQiFKA454iG2oDWRgOhCpJ2WNZ/75mZjVSlVxfSnwT0AGJU3biav69wFIO\n", - "Wp27wGWZAEB24ocqD8pgCiUmcV2p87jRS//cIANODsQ/f3BGVvwgAAgRgACAIwPAAIgOCQJJmVIA\n", - "gRM2QsTnv/8zMxqpSiHN9I5iMeIhEQ8Jw4WAjGoe6TCTLA8BIUENSEKqvOvABYS5hUJ3PztRvCJi\n", - "ELQKqtVf+cwYf/+k4U8AFxBoO9DiwcoInq9BT5AwerIckf9AUZSqqgypYxgnj/9i0IAChy3+RkQ0\n", - "UhUcT0o8CRFLmyI4H8Qwz+3jCTOKhG72facDjBBAAdAIL5LjUZ5BxqPA5AABUAAQBACkGgDIPxBm\n", - "55CBGFu3iDTuIlGb27ieLAAEGTYiYAwR+oIS55u0H/McAcP4T/nGZgiCQRCCMHvh6kAWIExBHJcu\n", - "3/7/8AzwwgF+AC4w0UZDy3GPPV7AmBw4uazCMKLPgAoJe4iU7nb4CsDf4ACMJcwqE7n52o/yAACQ\n", - "AAgBgFILIiDcfC2mvJN2vGGucUfmlLUMlcLwFRGGDDjv4yDF6txCez054fhukQ6CVe+kjGh4AHsg\n", - "CcIKxltZFYz/+eQAAUAAEAUAhB8BGZNPUQ6l04MAWQYvUGUwQXos/+oYdr/gFJ4An8AFxBoO9Diw\n", - "coInq98zMxqpSq4vpT4EiKXNkRwP4ppf9vGEmcVCN3s3U9BT5AwerIckf9AUZSqqgypYxgnj/8GQ\n", - "AATAAEAIAhBoAyD8QZueQgRhbt4g07iJRm9u4nrw//wnDDwZAE4QVjLayKxn/8/xkGL1BlMEF6LP\n", - "/qGHXXXXXXffXf677/Xw/4BpGfDgOAAUAKCiMtAATMjEoyE5zTx2F4ZbaABACVA5xeoTn76UCPli\n", - "CNq0f7gOknb/uHhYIS3D4ACZkYlUhUYXko78zIxLyFRheWjg+BDV7dFq5WWXzQxrQOO7iYIW+QP9\n", - "eYANVEDfV8j+nnnzgQLX0kX/BhsZkln3jMIXqzUj16XwgxZmEqjJeU4156vYwBhiZacW1STNZcMw\n", - "NsOKzGlLvsZ3ngagn74ACZEY1QhEcX0I/jIcYgs5BDSmtuyMgyDaW8xzzdoDRUWUQQ22lQ2/B2Qa\n", - "oMlxskFuP/3+3DNgGB9nR65+VmEqjIcYwHpHT/9/oz/MjMSoUgQO7bBAt+GRhFHC3kvKy+13c4hB\n", - "/4ThhgDGaBMB43+6sG6zIABTeYoHCMMvniIMT73EJ/UfnZezwA66uAAQBkMAAJAMCiCYG++/133h\n", - "rvvrrwAAAAlh4ABAAJyLwbwAAABwYQb4ABAAJyL33AHHrx/nvlP3D/Pf9wBR66Xv8D+E1xJ6/swi\n", - "99fDcAJiZJ0V3btf9fwJ3/7PvQns/8sAY2q8f8X3/XJgF3qSz4SfOF4dQSxgW4AMlNxDJyn8AmTf\n", - "EUz0T+0KWDpidIw05/+GnKxOSAAAAHNhA24ABAAJyL33AGXfeP+L4P4U4qAAW1xMRUKzz+iNJKj7\n", - "/w7B/vPdNL/r+U/8sAcevH+e+U/cP89/ywAtuu+Hx74//mwhcn7B1yTAlw5Ab6tQQvSOAaqW1KAt\n", - "JMb35E/XfXgCPy2zO7/xPAdrTP9d/XkgAAAA7WEBR4ABAAJyLwvwvADSzMySfrnno7bz/rf/AA6y\n", - "GG6L+mr0rCkWOEjEo/AVdXPC08Lqf+NY87IN7v/QMrNxEAZd94/4vvKPXj/PfgAfX+8ayZ//tQgv\n", - "41mQ//tDRC5v4fDgswAthI56QxcgdH4ZwaIUga1AEgEwQsg94Ci0Qe8ygf/9grgORlFzE0Cr/B5o\n", - "ZMS2HR+rwHQltiJo19v+EXSHe2/5eF4B3EVi1cGAyPfZsBJqdYRiewOvX7wM5VMCLfnM98sJmUNG\n", - "deAYBribGv2U2HrE8LQ8HOMb3mJc8P8NLjdAd+rJbZpur2/8kAAAAMFhAbOAAQACci/yYAW9X/D4\n", - "1b74Y8A4gqCkHWHAQEGIMqEUuEfPmBHTeeGKaIatVewQwx4C18n68AAytXVD8UIdsAcIEjF8BN0z\n", - "578AAxSWKfDyQ4eG+PARiwameQqbyHu+MhMWc3xvihfkgAvq7+s//9x/6hj+GoI9lviRbGwzpME3\n", - "x+AsImRzVk2zwPxyplgmtVd/wzAYuaRhKQd4WDDoS28Hfb4DXcN/wiX/2QVgOqct4Ef4D2kCd8Dp\n", - "InYm1gxYAAABEWEAh+AAQACci98V4Ah6vwP9j34APq7/5//vvlgC/1YH+1/D64nihP8L+CJtuaAY\n", - "zy/BH//KEfJWcZuYWjwImyz3+FuQ946N+ikJwr/30+97lmj/ngQtw+rczPU/y8EEAFt0UFf3hv+t\n", - "o3HWqtLfvBXsgEOj/nG7gBNosNSI67UEaBWuylokHufgZorbBXSv3ny3WzBsJ3GZ1Kehh/BI1HoH\n", - "MlMVKQ/KziMLdmMN0uKOX70GGB5NMB8fI7FY2pqByfiGRkLSKhzvk//Gq+vuwNWMXrrfM/4lYX4e\n", - "/gC1X8B/p/+PAAICpdLABC9pOX6X+wwA+PsSOdoAjwZC1Q1oQk/7ZiNGnj2DAx5PzyNhzD2oywAA\n", - "AJdhAKLgAEAAnIvC5fxOIiAQcAD2i3uUnP+/hAbBzIXNQAsSiN8WON7mD+x3GkY5+f/tB/TpoEn2\n", - "EiUruH6OAmO5T843zYgRiYAiJXIxXjwYcImB3f///C3JgBGdJtE8/oDMuNaHkVEv8T4Xh1C5fwRP\n", - "GUAYeEqLop+65UFw1EC/DeABB9d93/+C6z6KI/zf4sg6zIxuPX5IAAAB7GEAveAAQACci98RADb9\n", - "9P6+H/gBu/9Qj1r3AFt3YH+1/DhPhqoAhcR5Cr/gBI3SC6GJVgieP4f/zBnRJ0OPKr914Pmtd41/\n", - "/8T3zcBf2b/2DgL5pbxfAnfqD7+9+AG739P+/v/F/gEZ64Pv7geAvmlsHAXzSwOAvmlojeFMABER\n", - "kZEZGZGRn/4ADowhPutSPWrbXg/iP4vgOAvmlgcBfNLYOAvmlgE/V+n/1m/8fwQdmmXEeFMABGZG\n", - "REZkRGRn/8AB8jMSoUgx7eQOw8R4jwpgAIiMjIjIzIyM//AAdGEJ95qR61bY8H8R4UwAEZEZmRER\n", - "mZEf//AAeIiEiEIOezkD4Uw0y3/gwmFsJhRHhTAARmRkRGZERkZ//AAfIzEqFIMe3lDsPEeI/i/A\n", - "cBfNLYOAvmlgcBfNLeL4OAvmlgGQR1ZMOfxhgAZasqXn84vgOAvmlgcBfNLYOAvmlvy8AIiO2Loh\n", - "3gZ366e/+R+bgDLu+H/D498X4AQP//H7/+dt1wH//9/34BG1WH//D/XLwBl3fD/h8eQ/8XADj9dn\n", - "3/fDA3dbvrcx+3B9/RADLxrZEd53it+uT/c+WD2674fHvjw65eAMu74f8Pjy83AGXd8P+Hx4R4uA\n", - "MW+4Rv/v/gETfYd7+/98AcevH+e+NgAAAAph4ACAARyDvBvAAAAAkWEG+AAgAEcg7wvwvCJ4E1Z0\n", - "sDgAgwtZM8AbuwlIchyfrw8AA2CKNluLRGKbwpGyoATqkfu9voh0yQu1sTC1Pap3wGoARobhem8p\n", - "3aTwYdAF1HYMLJHdmyn4VL/84e2ErGgGG3U4GABPUTbRAxtWTbwZgiBMeickxQagSjiAm2c8fIGC\n", - "AbpNv1kRfA0qVAb+R8kAAADDYQNuAAgAEcg7wu8SJC8AErQAIikFNlo55tQiG/IRFQoKff7gYeUy\n", - "GYX2MYisMN20MQGAFX/TJHxsHj1+ydNL4jm4IZ9QZj/Tyn4VxIegAb7Hy/1WpP3wPE+8fVR/8L/U\n", - "Q+AUaQaEFSxGrwfRSJgAQQUomYAUSSIkgkREAA6jjUxdX9/vYaNHfIS9T9oG4HdADr/1I27Jc3WA\n", - "xv0d64ttCe/94HZ0SW1/YYmFvyt0w4QcbNskeueq+z6IoVahaT/a8GHJAAABLWEBR4ACAARyDvC6\n", - "zwQUDD6DMYAqRZd+M541hn+AAeYm3KSEfPAvtTzJok/Zf3Bjw1UTADJJIiSIhInUaEKYzKB3jIR/\n", - "wb6IpeBuqKIihYICSvNBm5J4aboCPX5gInUOfy8uNLevLEiZAtSqUrwQCgwDAM7rvXeG/RXkP9l0\n", - "+5D7HowoIXN8ASOHhrwBAgmOKpy48ABdgnWcvBGhign9+/saSBgXKoa6xJDls8q1/rgiZGEF2eAM\n", - "jJQn8+zAGRiUEXz5ZoXnGvCRh/rAF8L6C3hD048/ns9lOEhRE7xriKJ3tYdnWLAoVCIXKCmHSUG1\n", - "ngimkZibu6jlRmVo0f77BAC4LcbNx5pEBitnqxMzx784dsHVvzwlthAEhjDIOZzDM8Yrpl3EYcRr\n", - "Bxzw5IAAAAEKYQGzgAIABHIO8sNQxwBE2SbUebwQKOIauZOSYtOg8AAkoBwxMG0Bg18CPbzyYcml\n", - "gBcOxiOUhv94Kh9j0aCV17N/CHBfgB4iy9IL4f9nKDub5NCZ/7/3jkVOoDGWPk/DE8/AHiYb4BQA\n", - "ZQAgPHrB4AIKLVTBcgiJVLoH4RjG38AYxHGxvVe8RcK+DC1Mj0GkP0vciKCZp+yY0IlF9Q15rv8i\n", - "EE0Zvd3npAZNy/BSFY6KSu2yRGtWhZsnz/UEOEOHMAD+IfyVI/R/wJODWnGp09rhd5bwJvx/2F+J\n", - "EBaFiYA1DHaUDa0AfMnkYY/5pr/DoYn/n1CN5CEsamhjO1L8OUJGwNWXym1+pkgAAAFBYQCH4ACA\n", - "ARyDvCInw7gAIaIip3fsdhGP4Az7+jt8MAYvWv7XhwBh92qrwAHnXqO6R5tIY+zZjEj4LNjUXV8f\n", - "x13/MEJCLYSsXTIQQWckly53q5OV8w2gEYIBGxN4AscLpJZuZD/1DeNP3Ynd9PgjYEIyZtl+kzxa\n", - "NngATI35Eah3fQWsPBQZUvMfclYABKHKIXGdq9cnbEYXaQkChFwy6Ag1eNAgFGVm9z0/QWglsbQZ\n", - "hoNVdBdQyp79HE19jj+TrZ6Pn99Whd+HswAA0CrMTIBECrsvjOy88ZAADQa7pZ4MgAAYBGmztgxC\n", - "R2O1Vvfr35lTHGgJrGBWOuDTgIA01Cu4O56fV/lBWF7MB0UKsAqDj2O21j72Y2QLfBJ/aA1ROSH6\n", - "8K9/ge+BWJ4us2/+Mj/9c0aa7Pr4ZypM03gKDD5IAAAAu2EAouAAgAEcg7wu84gLwALFi711hEcI\n", - "WBhaKLlub/coRImAS4gbN5B87/vL4ITM2dyNYMSlkFWsoaAuv8/6JBJ+/mi0buGYAHQsTbs5nICH\n", - "X+DBgqszzDVmLy675wxGJ29LwziAvgAmTDsE5aeh//9/iKooHrDc05rh/2+4nDHgOAAaBFmy1gwA\n", - "qmmRhjdeluYHLCzLD69/+tIluCyAgJq7Eru4/6pB+ZALN3pm6YBCuS7xf2xp5xFXJIAAAAE8YQC9\n", - "4ACAARyDvC2I+F46kkNoH2DBG0uzRxGpYR8fAXK9jNZZpIjyulwulOKutTcvSS8vABaS731H/qf4\n", - "vpJaSSN/4/gg4L1LcR4UwAEN2dmZ3Zmdnf/4AD4nKYqCsMC0deOYeI8R4UwAEJnZ2Z2d2dnf/wAH\n", - "E4hC7z2g0lnXlA/iPCmAAhszu7MzO7sz//8AB4TEMRBGGhaGvHZv/H8EHAbxHhTAAQ3Z2ZndmZ2d\n", - "//gAPicpisKwwLR1w5h4jxH4kvHTh4kSCCABcVoQB9lJoSrr++x2jAAEAUucCiplH7zx4ABgEabL\n", - "QBC6HaU/6ss6HQA8F9RmTS1v1z+nHBVI0TcsMWwl7sAErWj/+Qt//0wAdr9jxMb6JeamNxfh/8AJ\n", - "jjEG6rqyE6TwYcF17onJjGi9/xgy55/wkfgogAAAAAph4ADAAZyBrwbwAAABImEG+AAwAGcga8Ls\n", - "XLD2MhIgBMwSkFIY2Dx4hZz/wDK0vu4HhMTgNXlEgsPJb35AcNjm4qBu3OiX9eAyjIJa0lvOITAA\n", - "e8qM6BKVL/teZBjTcGNPQmwd7DBasAk38B/NVzQ3ufGjJm734ASb+A/7OLYpSF5/3XGHZB1FZr3r\n", - "JC0cb9QAAnYAAIAEgEVgA7hLRJspn+erxgABABQU/LT2Bg8QEs3njAACYDgl2WATszNjfqdXdQhN\n", - "QQAEa7RZd8vTsXzmgiJm26ifA3cFkCal2vKfhQWt+hIehtAEZi82I4LHjDUeE6+6vixmXRBtYwBY\n", - "HjpIESTXUwcSEVICTzH4ygJ5KudO4EP23oQAfPPaMdRf1gyg2/nAUFn4oRV35Q6JErKSAAABF2ED\n", - "bgAMABnIGvC7EiREEEACGFJjcQ1nLGK6JgFZ7QAcCYykAhQ2BteYEKZOyITZUTcADgxYgtRDTiPf\n", - "1YQ+DlT/A/xXkGDQAjZ1DAxKgJQlcIyZgB728id6AB60X1PioTnLJlSgEESLGh1yjEUB7O2tYioI\n", - "icMy6Drgk/0P2x71v43CU/CuIGwFZn1AEMxnTC/+kR20lSKLtweinwCpKIz1lA1M9q8hDwABAHAU\n", - "ocmThecNYATsH8gP5O4GYJK4AHw06fHxI/vnaCcWGRKrW3M73gYdBACboIqrY/HML/9S53DHSOad\n", - "Ts0jDCBvjrOzN3o5/5kDhWwqFTofexIRC3+PhnDwL0FCe06Hyde/Q9yPLGiHZYnkgAAAAOphAUeA\n", - "AwAGcga8LviRvhtF+RhWi3mUgItcB+twNu3ZaZp//6v/YaADQiyxXBBDJ0t3+gGSgYhsVAlJhNAG\n", - "YMkwB4urO1SYIGsnmjUwJlxLVw4Imu7eq6wYIGJgSwHO1Hx4P6r5QrBzDXhLwfgK/BI9Hv8HMMwg\n", - "98voYCDVB3181dzj5C/EgkBlc4IIAsRutXmua1ENxaJaS15u1/gAYxdzh2K//YpoehU+cj///K/h\n", - "Qv4dW//zsAUYXvTObkJfvnGZBwCcDxcBBVFgLroih4AmSx6F/tODd3d93wZSYN9ijk/vwTO6AYDn\n", - "fyQAAAFyYQGzgAMABnIGvLHwx4ABjTsGqiEiwqvrAezTQ2EbiDK/9hbJidsVhAP/7gwAESwIAAQD\n", - "HAB+wJYI4s5hTDMCy4o0sAGEmgq4AuhhQASdSC9Iqbo1E1emKhvgoFMEeedBA9lz4gN6LN/+DnI0\n", - "RzI54RL8TxAgQF46ACmvDMuwADjDHipgTax//5HSq4FA0+6SNgvcWoWmB3qD/52hjTrkBsfn/gCo\n", - "ABEFFuly48WwCdmbzGYJ96U4awhGjA+kpXb8vB1Dm3zAB96F3dB8F4iLhXBRIGC1fBLh83/t3/ag\n", - "urRWgT7dWijOI6IgAOgDoPwwNIwgABABQAuDg0HiO2dBZA1tc2/wV7AlqgEaPYDa8OAp8ngagcPv\n", - "v/wzsw1cf2l68lrn/X/mNKlJH3/CPGzEQQ7N/94LjjA31yEXnQf+ETA6BlBANCWBwHAUyOAQAkyK\n", - "SE1uKwbOOwgCxzD7i6tZlPKJOXw8I3bE575dIPkBA1BzkgAAASdhAIfgAMABnIGvCQdUAQojaI49\n", - "/ACEy9tLX3wc8XysrmKguaaeCpzfmAq2Am/T6Q4p6OJ39n+FvR21gAU13rvaBQsYhXhoigA8T77X\n", - "R6HFZSs4q19vb1eCCjujI5g4pJQeOL6X+TjZQgFcA0GlPdSUYADG0Swz9CMV0WggqIAAiAgJerxP\n", - "F75yUwAajMTkKRUORHyGMBiWIJSYC/Uw0dIMi7Wm882AOJkLnzwfdgDfLmWhxOMSIDf5BB1Na85A\n", - "Ws32gsXQaDpIAIsKcQuYEdxcGSDAJYtrWa9odUgd4oA/7MvQOw69qkQ9co7w0X/4gb3Ggc4A1qbn\n", - "qgEJGtDRCoJNwiEbFcP8Etz5xNPvuxwVVhmJS8/ZshvmqwUMT6IBYKDgj/GDdvJAAAABKWEAouAA\n", - "wAGcga8Ll+IxIk8bJ+NmQ0B2wAAm+K4AAxCE6Z1A1et88WgByqcLdIlBRM7/2MrP0EEsQyIuRum5\n", - "/9fiFmHUMH11B+UEdHuAXTv5z++YBCbq/+f0+4WUAHx3Ca/034Jc/PhFw0WQ13LE6C0AHJsLl/Hv\n", - "SVJxBwYyMJJbkVJd+UYRR5nzm7WP4+XzThnhfABQrKKkgpprs/g/boGOIZdkDzE2Og/3Az7ExEb1\n", - "AAGgMAn/dNXv6vBK+B1Sb4GzXATcW0o9/zABAPxhWwrX3+gCwACAQW4YLQjcGnPuG/CTL/TsDDIH\n", - "7qDvq1MG52lQtlNEZ3gSf/3w5T9+sReDj3kLHkMl8Q8W8N9ogBibXPO2gsi5Mda9g+/8XzcFvft7\n", - "IX/1f/P/JAAAAddhAL3gAMABnIGvCwn4mN0o5dgC2CeqQC9YXC6YTLAkVnB6yvACbdOAAhvr0gzk\n", - "Eb/+0QscjIEbiqPP/8sKKHuYIREln+97iPAe142zFkG/+B7QasZh+eBAg9j8ZUzDeiAKhkbym2sA\n", - "Frja3FfrNC1R36UviRGED4Ztz3gR9xi/vo4Nwf/D/GG/8fwQcB3IpbiPCmAAgZzHMYxzmMY5jn/+\n", - "AA7CKK5qDTBwj3hoQYeI8R4UwAECMcxzGOY5zHMc//gAOCKCCv1xlUIsLcNPg/iPCmAAgZjHOcxj\n", - "GOc5jH//4ADoIgjmIMMHiPWGhDEYaZaI8KYACBnMcxjHOYxjmOf/4ADsIormqNMHCPd2hBh4jxHx\n", - "E3MRMRm8cMZpoIftZBkEst5THm7UtlMAD0ZOGJH9LDX+aGJpy0PgeBUXed0waJ8AkOlJTjIJyXvd\n", - "fm+zmPwNAcNUKYR/ASLJbPAAi7cyMX/3rSQtpi5T/vPB1pgiDthBRyBDkaZDymVSWLeH4BDQAUkm\n", - "AUGSb9TIyQ26mUjqYAARAUEvy1/cDB5mQllwgAAkAAIAIBDK1B7CzpLV+er3/2DDCU6FVBAAI93B\n", - "+U/l6YPfLHQA1oExY75QCd5EFxAPeEj8FEAAAAAKYeABAAIcgJvBvAAAASZhBvgAQACHICbwuXyx\n", - "GJOJD1HgAIxjZORNxFbk2pswIbN+qndiJ/nnEM4cpQyjq1yrZwIPp06+4iIRGQhgamIUZ//vplZ2\n", - "/1zb8HegYFIA3397ey+yVX2174AZt/RmeKH7BKSvdraesLRjYWzMAAEBYAFFnJYAPxIAEDF7CzWl\n", - "Ge4HXmgNnQDZsAAQGJ84AME0N/9x2SAAgIRHNIeaf/4QTIQAEaZYP2G3J+yle2wSAaHQeBmTbA9h\n", - "SOQl/94ZFrfL8Qwi6EgvhGwepGyjgoWjZDEbABrMMpQzW9pI40uloimiAeC06dDsaAX2Vs0bBoRl\n", - "OZaP0B1Cj++pPM4eG3X76dcKVCqKe/UMMBfyxVF9tGP0exgj2MeciEq9HOdLy3Midc3hfJAAAAF3\n", - "YQNuABAAIcgJvC2JC+wMAkb9Je4h7fjGV2D4kOV3Vf94vB6Ad1zWnJyLDquxEfw0DGjkwZpt73L+\n", - "PxARjcoYDv9/AsAISABwcRZAxvWRi9y7eouB12uPrDpgsghkEAQFVuJkRuq2BARUwlBk1LgLH0ZJ\n", - "93bsNrtmyHBK4ZkB4CqNDhGrlCZo6XT62auqYnC2uwDwsT7zwtlmfqJEO/XWDfqlfMHZnXa5aX9b\n", - "6i3csZYZfEgg7pyJskOV8Cb2BbUK+BOZ74HzdD8lPkAwBhCuUfgIP2//jY0n4HX6pV28TGwNBhbv\n", - "Dh0MbXRl96QTe4BKoj/5foMjahAn3UDAB4yCKRRGkhCGemSVjAATMhkdRG4glTWIDOkZgAGQAkwB\n", - "5rO0fDaHUwMsgC+t7bOu7E95TbSnhnvDGGidH//uUYOqsyAqVz0Arc60v6T4liHpp71iahbDghhl\n", - "BbevAFhFR/wkvRaYb3vJ3CZ8kVjvhafBW89fABnHbbkgAAAA1WEBR4AEAAhyAm8LF/ieg1Ly2CPw\n", - "7q6jEBYrUAf/7V/AGGDsb53/H+IG1VgAVwYIAD6JjVCSM7is/7wo5APrbl1Bl+YT/RdrTTa4t//S\n", - "+2EmhenL4HuxLDEXDKW/FrANCJX8rr0yX/yCXgGFkzxnjReXGrCu6eH7ULHXghhXSKIVgGOoEhgO\n", - "gOgDjdS8p//IX/xMbsICZr31/aEw7DrPKPhQwx8DgwNEdF40vRFrhueBAimHVmmSy6II/8WH0Kj5\n", - "wqPi0AHoU0/X37z7e4gXA3fY7f0/JAAAAjdhAbOABAAIcgJvI+B9D9zLu5d1iYCH7UNW9YH8vP8U\n", - "AAQlYRMyCAAIhCCc1AJiEU/asHUsAKgWcoDhBA21eGOA4ABsAMAkAymeACoHuBDg0jJg8VcAVSCR\n", - "iCQpzClAACESCABwlhAACAMcAdXBjck5jCwOhFDrHRMTgQ4WnzAYvMNG3ANwFl39nA+Bv0HMdmux\n", - "xyu4O1n/96/BcZIaMsuOeES/iYmEI2MeYGDwHX2855oAQqXVM5dJ8kVv7wTUmDjZsK/17cAFALoD\n", - "146rOLuf8doGDtCgC4VAYAP+aazRH9gBwGsjrnmhLcLmgDAyl/30AB/DtQE419nOPS+YFR6V9V7E\n", - "CQtD3UGY/AB2zMb051OL72pGSeOomiUf9V+Qe+DBY+8Z/Hn4d+rMrKgOAAbADAJAMy3ysyshKNBA\n", - "BOItGIuBxn0vgi0O8MHHQKOA3i2lXv8HKDsBKIMpQ7GEhCJA2ZAmGCwQLDmbaMJteOcgucRa9pWo\n", - "PQA/vDWsIAKjeEAAIBYIC1DQMRORBoAigVxbfuwXUF00ttY0aAGXKAA4QHGK3/uGZ5QcG+q/fs38\n", - "iSqUq///8Il88R2IGwg39+vwRHA/TaxGPfw120vT1WGY38eBDgCFkZGk/ASsk89QEd/0AnEc6fZP\n", - "jKomADUPcRd5DXCH//3B0EgOADRQnstGhKcZVSmXhcxkqfo+JYDdCLGD88pJrj6nvB0686nMaVVw\n", - "+d1EKG9uGjywBW83F/OZhYcGvps0skAAAAHWYQCH4AEAAhyAm8JDV9m4eZi5f4AFNWluMxZbsvVb\n", - "63+bprZNNh0sXzo6kdRoBYWkVaYFQjArAJRkcR7AXHc/rK0E8cNNkTcn32v7NKbM4xrgwgAjPJAa\n", - "AO3XHet3O1A0F779mE4kiN9/Pm8w8hAtYgOYJnh/r+vHNOEzG18SN4fQ/gIDN+vHxmhNwe++A3av\n", - "nZGfx/fpZAU/769jzyiCFof4+YufvK62nb9+d72AY9a8e6h4CZe8/e+X94gSIG+wyz50FgSEwj12\n", - "m7muMRf/YATDXKWTUyy2fgr6Hiog/v9H5NgAplcWUzO/+/zAnrUjwqgaIAOGwZrc/WITzG3kQJEt\n", - "hAgSAZE2f80dDDz79Cvjsw0gSPXm1yVgcCwGxDf5iFBzv7OIC1MMG/DaVcwUnFnPMMGChmTDAFSt\n", - "O/dr7C63vZgaisTfRPIUNlYpkKJvu4EwyX34jDHYENeDUFBrS4dmS2g1r+BA3t3+BE3HfCJmHpZ/\n", - "1cv4jiYezccBQ9NcGxgylvthAQBaAmhARRQqyTCh4YCfjoQCgVYQsH+nGTaDkplapJewA8HVLJlL\n", - "99r2TGut+/JH285aZsM9tYYmNmbbX/rXEL+B/e761M888hQYevy11kgAAAGGYQCi4AEAAhyAm8K4\n", - "gNYDGmcohfJ2CJtrvgTKWOHD98SFfhNy3oEjcAupLeP9q1RImK/g7x6Z+5/aG6fA3oSXzopJJxqu\n", - "u63/cQPjfBgBiBZbIy/1tA7WhnoitWQ9u9GiOziNr2e9ybv7eOOnf/iFgE9/yKtyqX5UQijRkewe\n", - "gsiMXBSySFM/fzmAnR6YJ3DfS0XBKD//XqCrLRFLQrCJYDAwTEMzEALfSfys3/SHZB7ePd34I3Dd\n", - "+S5eazd98gwIaz+0BE2b5BTxsrf2IDvyyFwpIudIlXyrr5dA3GD8ApXGTkYAN5pshzPnbBpUNifk\n", - "9x38/e69vx3TPDRf33Gw6h2BeAAVETgC5AwXKF+Uiq8w/d7e/DG9p13Poh2gJes0BQ4qn/Zamd8b\n", - "GqAnd5D/+AycEM7HnOylUSZsgiWPnEI1MJI10167DS4U5dJjkuNu/uIwt4QhEuqMTJ0CFFv8HyCE\n", - "IzHIy2qJGvgwQBDUWUfZ7l9Jlskmr9n20MZ9WY5ClkOpYeHJAAACD2EAveABAAIcgJvC+IG4EbWa\n", - "C8HuMgBaW0emQvr/LQhi8ZDIDC+T14AgAk2CJNlkaUV5oNNfuDgDBH5wgUHK5tFi3/tYYBBSEMI/\n", - "P9+kIf971wF90DsPETXeZE7DXNsAl+k/cAf8YWcQp5wL3UAI905fk57EmYdAZJopnH5xCj2MT3+Z\n", - "4WlgcABnMskSRu1+HgiveoUu/cRBU0G0f/+ihxhv/H8EHAccTS3EeFMABAGFIJIIIJJIIIeQS//4\n", - "ADjEaWcW4a4cC6Xb46w8RnpEeFMABAEEJIJIIJIJJIeQS//wAHAIUYUXz7roNk2e3ywP4jPSFMAB\n", - "AGEIJJJIIIIJJeQQ///gAOIRhRxThjh0LpNvjuYP+AYBBBy20cR4UwAEAYUgkgggkkgggkgkn/4A\n", - "DjEaWcW4a4cC6Xbw6w8R4jo3xhMZvr4AP7JDiKy/62/zIwyOhxCglHHDBEHdFY1ZFHwIoC4ldnSC\n", - "anYOE/97j270WTwMqlTQRlEZTfLTGgUvj7vv/3sxe5YMQI6CC6KJHqeBv2Vw38hEechTZ7BCyaT1\n", - "RWv7/eDEzgh7qCjBp8fIgVsThaIAAIHQAAgQ0ALAbgBpdAINn73a4D+B9u4OAAZAAEBgAEMgahnP\n", - "DwAQONHD1eAHHYrusyIsbAyEAmIQABkCzI1JrEjj3/Zg+Hn45oUg5SYH/N8uEn5gQZgHvB1AAAAA\n", - "CmHgAUACnIDLwbwAAAFQYQb4AFAApyAy8Ll8bNYmJG6BQAPwEV0809k/7wAm+tDmdtDZPgLhM/kH\n", - "KohB0iP/2nMF0HhG82EPbUD+4MAlsB6tGcWMGBYKFCHtfHwAw9fef3u05+Qdgj4b9Bi7Kf/+ADF7\n", - "Tu//8Jcwu4s30vg+g5hEImh24lDGhiwgo0awu2EFNBqC4MG9NUjNraTHQzuVBkNy6FgGDQgyLWnV\n", - "CImNsGHINAhxD3bl+kAejMTugNRZph+bzDRwl742ST0oOz2inF/VOY00o8IJ3hWtCKOqptHQu2AD\n", - "lRKbhkkcaNouuB2jwzD5JwwZRZ4fubJoyZDydI2C2P8vwvAt32wCBzoEVYtqILOCwCHlOK9t3X/P\n", - "AKVu7T200v6ZP9/oKArqtncWPelGqz8YBrgxcZEfV2i5GQnOGeqiDwtXOx/M8vhgPM+vUv6hyrq+\n", - "r0xi/Y88ufkgAAABNWEDbgAUACnIDLwtEwv1H2Y0J14g+YwBt5+fs10KayAG3juntc4nJc3NL8Ti\n", - "MSCDAY3HtmQNPw4AC2MMMzcpFci5E6R7+/wjwfztZxZMDCrBVKEVSmWu/9sGPP3v7eG5m2jvfFMS\n", - "UVjcicOIrJ2OkvhKDhAOwSO9HrlBgHMQG4AOgAEuAcKQX5Gb8xNM0DgIwBp6A1MoH4fu8JdFXiDo\n", - "IfOn/gh7RBPApCdH+8NcbGgx8AUBDwETh0AHg0ygAoDiMISaOFywywQT3Ji4rCfD0lcAVsoAR6Uz\n", - "NoWVUzvTmmpt0AlOEBZGS0/7Jmd68jsJbrWM24JDr1LwegJvJkDbsLWJFgsJJhjmL+H+CvxAUwyJ\n", - "7lN8224MOEBIQgQAAgBgHHv78Xmex9VPD8kQiEIEZijmFEBhyQAAAT5hAUeABQAKcgMvC+JC8ATO\n", - "qcZbgvxJcsUx2CsIEv/4BHeuJkOo7eA3FnlYFEJNPIXsuWkUEWGIjgxyNGYAsaHw0T86tUf7gO63\n", - "DQBvQBjXqC79e6acYwHgG3YvZrf+G8xE732IG+BlK0wQRJC3s5d8NZwBu8AsR/oE4XVJ/8C9VBV6\n", - "rhAlKUANsifsp7qCt4F/Oco2/4WghhqMv3Wx7BdYInzajsDCDDP1yPQkbgAIGETjDyHpQ1TEkNPQ\n", - "MGCQsJlAA44FJoABQQN+ADiYqF61qokKa0uiFcUSAgCDIAUcvMJxEdUwZlV8EZB5WJr76+9xicvX\n", - "tL6YNYXv3+fRZwfZv/jhYLfAbgACANQABAAACoAA6Z4AQ0BKRyAp4Y1lUTUBAJSECAAPAMEkeDvZ\n", - "IxkB+U3/AKludSCCw5ac8kAAAALxYQGzgAUACnIDLyPghG6zetbYEz3+birVf4bz1gSQQBjwAEDc\n", - "WfrHENCxzBwVkuDgDQAAQBwABABiAB46Pgg5+EAAXKDIwAfgLQV6tlXHB97SuAQCAAqbDjxNaxdU\n", - "4agCQSRdEatMghwx4Q8HQsDttx/5wB6AAEBL8AUAsS3kSImbgPNBEzLBHs/uQCqbrZq3GAFe7av/\n", - "/mBjHsznVDMd36X+JEXBBAAcTGzVSZhJQxX9wBcHwi7JzPg5g34PpmDMKio9Vm1///qAATFQCcvj\n", - "XlHgSkLUQw7UUoDATuCwVN23TCBBsNCAALAACAWSA5DAB7VMe2J///SCg7IMh5cuKHoYmKFAQQ+V\n", - "egCeZYXx5gEYwABAAJ4cACjzw9QxfwQAgwuLgLmJ8VexIgLdAFgouNLVQW6L0A/f/emYDeK4GeHP\n", - "1aIgALjZoMeLPQpK0yD5BAAFAxRQQAAgFgBQab06IAYVKUeRIck4NRcqazlsAEJrFgBvarwcWBMc\n", - "+ncH3neAkAcHr4TuTo/14VoXgDFirxBrUmgaiIqUZFAcb9WH4bXmNjiJ8gsadZ4mNrfDEWIQAHDU\n", - "CZg9WKyd59G1SR+ApKCBn40q28uj5zqmBMp5Uw+Lw0iCHCuAzPXa/+PjIAECQMAOqroIKtJZdQdP\n", - "lISTICXK5KPn6M5/X/tQnNO9khtl/m/o+ID0GAvUAAdDGlCqtMuE3Y4h8oa/sQoMtwS2O4vO4bYq\n", - "ADidAAcmrMAy2O7mGSooIPBjtuIwlLcwqmQYQrUEAIAIWBGOI4R0KNbWHzsF+B/ErtrLuwQhtFtR\n", - "YnzuaBgUjaPDFSAngmUyBtAQwoAIWDRQDwwgHWScNCWqYTC0BVmwAGByo6WFMEs+D5x0se2VqoPi\n", - "EqCxpGtyp2P1PIWp1ZnH3fcAAQIf71oAAg6SAa0YBhteSITBhRLwlD/eCAAQpRQQABwBAkmIqqWe\n", - "/TzaIAlZwthqD/d4mGslOUr9z/7+OxVAvr+skBnTy5pIAAAB92EAh+ABQAKcgMvCZvwzid/4ACuU\n", - "yLcNyI/2XkrelvU00jJsXRf0o7BdCkK4yyBJOxYz3g1mmG9eABWIFx2a+A6E5CfffbBCXNlMd4Es\n", - "CPCgJOiJ71TiUbG8V3CAEEUJAMgAZH5K3qbg3DanxDshHtYslE0gVxIStgVBo17CLhmwJ1aScmX+\n", - "I4MA7wkwJ0rXpLXCLjrm0ikSiOpxwAgnVp7LJ+rg7E/DDEPPaRWxgIPL/4lDaouGh7AgPDUO+TAC\n", - "UAfhgBAtuWU2ECDv/IBhIwBPUwMHtOWoQoA07IqPW3/f3FDggSWPHCAPgOsV1bQkvh8Ynn/w1Qg1\n", - "IqD72D5ekfJqtla9rTqxcbgUyLUrsm/fnDsUEdedzT6dQ4EEwWia8oOAH8AZgxoLsvHhhENFekw2\n", - "AHLHoAxwnGXrD7BgxsAjQAAfA11Mj0LpE/BsjSbXmj8ZIOk75baB+iDgmAfFhE8jz3hp8SN10yBP\n", - "vO+wgBYlOYpA5HsE8S/661SWrwABAwAAEAOA0eftnvDKPdveCgtnbieEw0M4wbG+/nS6QvHVXUh8\n", - "kRCTGJmE7kcfUBEGYcWGhtsCALgl8xvBhBGklEqvYUSXWhX/6ABqpd5n2pNkAgxv6oF+r2QUoOnF\n", - "r1y+7n/w3aoyXhn9+ILDI3rXs8OYT5F2feSAAAABtmEAouABQAKcgMvC74gbD0L/AmZTi2NWRb/Y\n", - "EGBMCqWIvSME5y//gYGELFqwtgD/wAQ+avpEQ0r2b//vsH5417rwzgA+RZgACAgAAIAYTOEnThQw\n", - "LjoEEoAV801z98syPnWhXv8HGmu3//UKhS/I9zMCNrrIYE/CTlLWMzlMIw7yFYuZMP/Da4Ocf5gO\n", - "DB5Ny0NsMIE3eDFIA1YVKf74N38n17//Az/mArJWJn82NQ4fm7hsrOmWf++Bhk3xn99BzgAXiKpi\n", - "sdxuJEL/4AoGQzIXgpNmFKKD//AKZM0fBU+gjRC//cMRzkDjZ1zKOVs/gwwrABA4isACwQ8Rdo+M\n", - "L0Z5QJ8ojCyYxwflBLecymx+S/iRAkRh6wYfZ/I5sw6pVzi6AS0CticMJCagsRwTaSnit3bG94Zj\n", - "NSWrKbZJv/31rf9e55oISWR8a/5wPQ9zDPuK/fmfiLuXqFowFoBC4dJXR0/1sDkx2EZ1QfASgMgz\n", - "0eaiuQDRD+vAQ3MJuz2yWNjEoFOKBJXOFon8O0R+4g0YuhWcfjiTv4IAAuCnGAa9dJHLngeU0kKL\n", - "qTr375p5K79/8s55IAAAAbphAL3gAUACnIDLwuX3OIUeEBuAAxwAMQJOMIumWjc+hAAQknGJTamz\n", - "Yy9pygwF3EEMACpAqXPgFLGxGLxghaGgQENAWp0CzABUALqAYIEl0aQkZOBjaBGImwMBEkAN90nf\n", - "22V6JX1Xdg+pUpLwAC0ZBFz77isS//YV43Vp+eH/+xNxlm/c6lH1rT7FkD+J2zvA/SeLEAc3HhWA\n", - "DsBKkKAAIBImUOpaQmPSwAD9ttAMFrb/YZm+7f//r8QhMSBw9nvlq8ODCw7fRCZ7+4MdxF33fhT/\n", - "+mnppxGGmW8Rd934U//pp6afiLvu/N/4/gg420cR4UwAEADBzjzjhC66yyzLC7P/wAHBghosg2ob\n", - "NBAR98GohYeI8R0b4odRoEF/AAs2YtZrwezDDesBiDkISlkrMcTtM6Q1aXp7/9QGIOgJkOFW4wm5\n", - "hvnLTX3gAdp6cKYYTn4tYT2mmkLXEY/nfhzcaqX2+CATGBxUAATTNoiRh9k561EziQyXu042jSYt\n", - "+TSNkAA6BxL/zag2mB6XS+izAwEhASH4e5jkAWSQBgYll8cHwN2BiEwBCbMVMweSAMlcZz9wNI6T\n", - "+DqAAAAACmHgAYADHIDrwbwAAAGEYQb4AGAAxyA68LsNwpGy0vABrvEsZamuBwFCg4F/oqZ6kvYk\n", - "JCL94TK7oinYwW2lOgAtBg4dzIj0rTNlZ+/q+wAAIO8gAAgeACoAMyXhCmi7hN+2nltUPFTFf5dA\n", - "GhgmVBgiWoAOPkymdfYEY0MdL8BmuXFVUAFHqYpe8vgCIZl3XsnyBJ0dDvvUeLEggly8tjVRvKwA\n", - "jxcegfljMskGtjPPPfGcoJpjoCJcbyE/eCIqQk00n//3DUQJG8ZTDgghxjoHSB81LWLGerAgcJcK\n", - "JjBhbar35w+4AA/AEEIJwJfk7Agst3/jQVRgEBCAUfCAEggLTdMU+q4jPIJfdNCqUzpjfq10W5ka\n", - "Un8C/CGlF+o9e/6oPkY0I/7wPBOolr2VTPu1ZqTbsd7q2UP+1s3orO3tpkZieIdFZPAABATQNIOX\n", - "ZMz5eXmNEK1bGqu+r2gZh/yfee3SUl/tr0L0k7xil7/g9/7uVgMKR2yBRWgsymM/fA7UntRZnr/+\n", - "aVntr9ob6AQfkgAAAX1hA24AGAAxyA68LYkL7wj49EGUJLYo8YLARMJHDsvtAmcUyuP5YA769Y/T\n", - "IdbYUU/fpxMbwBNc6d1thLEfKbA3U9PwY7QCv7v8evwirvEzUDGCSPgAOAYZoApycfmhMxJ4ZRl/\n", - "/g3KEAKBE1u8HgM9FsTz7ALwT2JGaxWaCbks3e8GRdTp3cZEG7hcUeIrjeZjUQkZ71skYZSWtQmm\n", - "O+S/uJpAvvejphxsxBsA5Iu4zz+HB6pgI0VHfvn8MD1mQ72222+xOIBBg/AWCR8DbQQCAR3bzGrr\n", - "erDjtpqhuQuAGsYQJWb4AWDpp0xnp6K1vnN+AA8ACpdVWk5RRPqua5qf/+/l/P8bcFbUPS9oCRnV\n", - "vs8cNVsIFl8ajygBAQUkIKalcmiWYhasC4abxEAHQIoxbkHnLJGIqKohjBbYE4Y8DHRsHSINXRf/\n", - "raprn6SecLUBcQl0nbqvam5bC002Tu5Of+rJ7ud3sEIlrpNzVT+3PfDX4o8PA8UIiQunhyQAAAKE\n", - "YQFHgAYADHIDrwtEnCsAKCVAQUXpcumwfx/atYO/48rur//MOVAoEqHwHHPWjontlz3IAACBNAAB\n", - "ALFjFTITcAZ6xoqAu5lGN3pufgAe/Dmj15of/+IjBOw8uMOdQTTwT7G5L4G+28AQgRfmilGc8U6n\n", - "lhQOAFhUNZdGxBwnwkAoCC+tPBhqipkryr3x/Qm1IQfjXM+bHkVMuI5yHmmRoSA4EuDBUZvBpq+8\n", - "sYUp2zW1/3eBsrmJJU3+WuNCi6un75nAHoOu6Ymf/Kz55Xd8BKgx5jeNLu+Lf/dwKMAHmdzQIvZQ\n", - "70RAwd+CiGGc52hv/sM0NW7mjHK83AAGLJr2tUMRu9GxP/+rXl3n4GWnz09/xbzPMNXdQROs9hhL\n", - "bIbY6veoxhJ//uDTGh7z2Ihnw4WghkhI3o8RWP/wQ3wzCGdvIQbgAIh0HhnyFLlDsCR0kGkP6DXR\n", - "pS+AjEHfYH7KthP34ZqACIWgWqmRHeCYExpAIwsU7GhfH9+oDbiMgMR7D2GNuDWTGalg4ue4AAID\n", - "6DrBAuR/AfbDgRohrnZFZz/9/vgMI0Jp/iXLCbrchCZ/4GtAKGrztpcRxyXTf7zB8Ek02gU0A+yk\n", - "ULAhBgGMIAQlqmn43yhZAmc4Rn74AWMRdyVEX7cvNTIJKIbsZr6fANQS4xXHRn2TCKiCQ1NYsJp3\n", - "/5NcfR9QGFO9AlyMjvjELHBjC0P7F1CLYWdpQtgguAAIb9kAASMACAkJvJFhmRueYASQFEmVM1S4\n", - "DgJa4Kv2YFfMlhq5UTvTrUoYIQSwAGBwgAIwAQCG7UbdABcBj39+F4u6GcHWJ6e8CWSIGEUrUgF8\n", - "Bskf34HMdgYkSgEkRUsPeSAAAAO5YQGzgAYADHIDryoZBgw/mYmYAeZcsQhXc4AHGc+FryCEDA1I\n", - "2Kj3wDooj8IyG7N66HBG34YBBqgABEr2CAAEBABAJdCAAEHcAAQGQABAeBTAAtZHngPhGLAFdBAt\n", - "EAIFL7VgAVAGQK7hVDXBdWgAR7HEAhGlgJGHhtqwI8N8UdgACAqAAIDAAHgoHe/B4ABIGKcmAbsI\n", - "BKQmQIsk+LUAQckLpiCBf/BhDnABUAB9wAUeKu5VpC3c8jCLNZCwAM19bSPf+4ADoX7kQqoR1USX\n", - "4mI8bM4SegPt/vgKGcX1xy7STTSX/3gzGAzV9wfpk9MmWKh+GQZJr1FVGOe8S1loAXeUBlP9aI0x\n", - "PlIrsuOgOEJNBTRgB2WrtzTY32HymXKDngZtfuq3AQatIBkE1hFQ5lKIXG4sgt+N86gwADeRZJRI\n", - "AAgBogGvuAJYOgEbxbKUwE/QqvAkFYD7s7mxYKY8ZI++J0A6rCoav/gVQVdv9vZtvveUQp++SHKd\n", - "yzCwABASAAEBG4AAgEV88VgACJWMIOAjuAAICFkAAEF0AAQLX+d4QABsAO/QgABAYAAEB5B+AACw\n", - "HOGWnnHMZvQdtnybAuAr9YKDQaEO4lV7AbPRlgb+UbnTH/eHEAQrWA8NMjXMC8wCdQELCSjhn1eE\n", - "JLCvwN1YFCEgnNR5X+QlSnwDDl6DqIIMQdRfGUfoYywGMQAAgI2AACAkABsAABAHX+vhAACAKHDU\n", - "wgABBMAAEAAABg4A3bMwFRmix+10TQBoEfaQf8ExCFgjgJsfLAsDzE4IDCNAxMVWWkH8viv8IF/B\n", - "l8K4JWzPI+BnAkBn+mGzpAXWv//UA6Okpcxe0RfvDLCbh4ryhveOlqffEQjr4FeqIZgNhj/9+X/5\n", - "hsMzGvQf97j8F7A//XoJeG57EyBJURAAUu+jkz/23kYLD1J3mh1FZmyVo8zLR6qIP9/NwEw1TIbI\n", - "QIS9I2Va4GZCxyXzfnXU/50EALAyTpX5slL0WSFEb5/8QBCAH1hosvVc+2QbAEI4Uw5obsuLFrLi\n", - "BkTmAACAiAAICwAFgACATLaAAGYQMRusXsPxIniX7B8WGEg88KJREUzMYvf+DD8YkAN2FCyEwS3y\n", - "LlP3hsBiSIaiEg0USRCXjrQCgHxnrcGl7ib3HQSqcKWAMHc4Tc4//l95P9zFvTHUCAAKAMuQgADo\n", - "ABUj8u4zJA8DL+UlIWY0YhzCAqLOqYpZ0RfwYIgG0wkoDmwn8P6hgGUUT1cjll05gkAmb8oQ55om\n", - "5fea4SAAAAIVYQCH4AGAAxyA68Jm/h5mLw5wAEsxRUbrDlMxf4vkpm0nzocom41TVlE3gACsYH4j\n", - "vJgCoTkEdBFIeELVATRbTfXXDShH00MnV6uCAAMgQY6FbUALSOWoyb63AUAFY/fuiGBnD3uAIa3p\n", - "mwI8SIBBAAQKAAIaCqy2HrzMilkfAsyjUnQAIAJhECBe/73iwQmhJEVnojIW5Gzb8MgAQc+YTAQD\n", - "EhuL2r8cELwAEgyDEsSceFjCDPsrdFm3wyQAMtvClVHh3cmBOaARFoDhCSAGMEDQBhYYSFBKixox\n", - "GP+gDLeiDQIrmHiv3QALQpnQEpA+U0BIAB1IwaiOpbzmuBXg/LgWcv1hsFAZC3mYyKlZoQN+Uakz\n", - "t4ShRnJ2sqwl/qgBsHNiEhyEYwc9Bd94wiiuEny6WfCpWfqS0MNswnwJoUIAAuCiWdaIhOHhp8FG\n", - "W/4Mazy4A3Qw4cmKTQqdAw3DJf8TEiA5BL5/HjB8AhFlwSNjRUAgXDLL128yDyesA+MmHeQGdtsL\n", - "gQdWdPP7EiAQQQVgeT8QHCNeEcYhhhOw2otHAn08AJYACAULpVRiWJb+fPSAPgTgCcEBM04vvd7H\n", - "eaUeAYRoEAAQuwUvZqibfGipWTQp8/wAzSvSlYeDwxr7DCdjyff1rVGxncVd65jGMudZH+8tZmrH\n", - "a4///bCIQDMwxVT84uteZdm4BcDmQetu/is1BIAAAAGfYQCi4AGAAxyA68KifiYVgFfeV20cO6PA\n", - "CQPAXPAJQRIBTg3Ej5Y8VKX5kAAICFoAAgLAAUCT6YYEB5BhGgOABogAWek3M6tIAxVmH4AHg63v\n", - "QnakMdV4F7VBDtT7/l+EOJExvw7B4voKyUWgcABszJoxKhczoZSGDBDpqAAmxCsTpBqjBvl2FhtA\n", - "H0zsr6214QAEWoxOnYcA9iNi8P663PIxuDHQ6ADYNL0h/l42rdo/PYuGjBaA800wSAATAs2JAAEE\n", - "YPBHOnLwBLRkwABAOZRS9AFgQxAUeGAEccw5RYWf/vmBuwAr1IL9pOOe3BAAh2mhAACAgAAIAAMG\n", - "AwCZtC4BC8cp6xstZnm8AjQZAh2PNYABpurrEC3whyuCvWwve+DDRf+IxsAB4y2Yp6Uh2JB65lIC\n", - "iMJjGX7/BDMIOKYMc8wUWecWBAIOBLZigJK2sKZcbf5g0CL5mJVD4O8YYdSOAIlh5du5TCfGqN+9\n", - "GLf3V9GglhvAwGHJj//fPOKqlNtkQNUjpMADAif//+X4nvg284gWxYAANNDAMKAiQAAAAb5hAL3g\n", - "AYADHIDrwuhIgSIG4ACGYpwjUHmJKGoLKpDrEvAghgAAgJAACAkABgJSwA8GLBxwZDMDxY8SLd+M\n", - "TMV0Qdoh6LJV7Qr9vcGB0B8wACBxETwK/nh2vC73vhhVWEACihAA7U58XZEvpgaj6D5rkPfVQzkp\n", - "lp1AAWFa8OUabl1eSWgp6GIEH9wXYY0Jr1mL3/VPQhlOtDu2sSICARGwQbCTvHdeWnhjQKYACAwR\n", - "XEi1FN5SQR2ukYAAIIgAAgLgWCEtwBbCFOOC4aOFTxMq194VHhAALjcHa5sUcgyq53D8HHRJgjAV\n", - "o4CEaGyFb8io48KYaZb/zabc2m2I6CmGmW/82m3NptXF933fxfd938X1FHqvi+q6r4vquqo35hjL\n", - "BfABRaDQokpUlzAEBMPrito3JCVHOBPRCMgykMSWg0e//kCGYW54haSGLxqB8EYRnMU9TSGlip/u\n", - "BCWmEYYtazvHu/8GGFYACAKDNCHW75fu9oAw1xVt+eO8KTRhbTRp7RQ46nR0FJG5Xh/rZxysmYNI\n", - "rtVEhASG4LHwLaZmNUrN9fOudH39gy+pELcTXfCfsM7Q13+t/4mOGyQwdQAAAAph4AHAA5yA68G8\n", - "AAABcWEG+ABwAOcgOvC8MwvsBwAEGHWBLUURGqseqGvLMF4AC2WEBwwwywNkom2K9/cQACAMNyCV\n", - "GNbZqORWKdAAJCKYcIE03lWzQ1FOZV92yYAAgUulzgACByAAICtQFQgAEaLCAAIho1oAMesUOX/2\n", - "QV3DJBvCKRygA5uSYKDp/9kD3vBmgZIItG9WICB+R2WSS4sGUITd0CINrngMuAYaiBIIIYZxIAFo\n", - "PK5isQW1H//3jpY4Hg2nNkTGh6vQEaRkwlikd2UWoMmkACs5N00t7yasNzgaVVJ6/7V/cnhL+3gA\n", - "WIVntZDPSrE+or61nv1AKPl6yO/5TM8h4cWhDZnmGhAWgA7D5i1hYQ9y/AZSlD/EQILPNP/vASIh\n", - "T12jgJoplvrgAFuBWFtUzQKS48BHu8AOwXvJMeQJZu++3s22/3lEKKr5IUp3KEAASDElgQEgAtBp\n", - "NlPwmnlX/weFACNEYwhfDU/68Z0X4R2r/MH0uouLyQAAAMhhA24AHAA5yA68Ll8SJEiRBokNwAH2\n", - "omxS+J///DQZwYBKQZBHaQjSG9+4wTFH+qVicf6v/wQnQREmAUbKG6BgCk077hH/97acABGRiXL7\n", - "14PQuAEFVfpNsRBfzMaNgaudEwI8anHLul4ZL/6Dp8DD/CAVAnL8+DmJheAD1IJCCQhSDPA2TDmP\n", - "UIUxH79f4yDlrCBywPmhIATukU90g5SVIKE+/K+mOh5Wl0sVMKl/4b8NJPs8UOGMTXO8+/4IxBrt\n", - "7G9MK2f7kgAAApdhAUeABwAOcgOvCxf4nPDVZg+xmIRNcAd/3N3fTAgIA5SD0067zZbLe8vxAkSa\n", - "cIh6AQaqD9nUGAIYdWFCU1rbT0lZdMNAMABnkLUr1CI5W8/udppNQADjFx2ErPAeZAjCc/LP6lYY\n", - "0WppLHe9eNgGU8jDUDAtQQCxkuTlIxSsRz1eCsMwQACYIXN/bqHbytmD1hL8DpH838/K8vInXvPp\n", - "R2FgwN8UNwBGEwYg39sTDfgIJHCpACZTjkrSeJJDSHHkodBglAkxJQ4sSvNN/62HZszPMeWf83jQ\n", - "50mkDQw9LYc8LPDIk9YAhlb7P/VFAEPEm733aZ6wyJPQHQecqzp/+75L6+9YKlUklXRd73xh+9Hf\n", - "X4bwBCmmk0HV/AA7GF8eoWEpnfBx6CQosoUc+WwBma3Kq9CLc7pfu98vxMGPh/gUTrua9+Cx5y1h\n", - "/t2wBTXVLLfeXZ0nV3///xgAfE1vvMjuhmGfenX+wbjAKmH057g/f2Aiap9EX/X8ZL3EjukBW7nU\n", - "RiUcyaRjl3cl/eIKKBBBPs4EAB4zEQinF1BCGrV0QAKZEHuIlSU3wKuYSkFjl85gABgY6D0ASeys\n", - "uXLf+4HbQtC1nI7/3t4ZvyCoaBjFAP1HS1RoCEVGcTmuNU8v9vAziLMmHC0Mu0+CSMGUBCCBjyDB\n", - "UUceAeBH+6jU3pw/9j/8BF1QgP3BxHTrdBHgT3/ZCa33FICsApgWQi6aVLhfC0bDAbzsyf+d/EAp\n", - "yBsQ/TSxq4DX/7TgABABYHMMEOECJIjj/f40GQoNpoxs0yAodyE4AU2kktCngg8ig//BAACA2AAc\n", - "DBQIAAQlAABB4AAECsAJk13ORFTkAWwu4hze/wJrQnrv6QkBcoIq+D1gsoFUMkAAAANNYQGzgAcA\n", - "DnIDrywUQxwAHMoAZK0iVFXh/clBMaMHnDASLBCyQQAEZ78ATDEB45MHGRPRs8wAbphhvLDMkCvo\n", - "HYFRWuy3E8ieEFhKGOABrEGYA5ywCtis9HwAczDOUodsA1lFUoC34COEhO8WYPIB3gmljrsAAQEg\n", - "ABATmIAAoAAQCDAgABALoASAgABBaIAAIIKcAEMB/QE40qgSm/gUgD0WgVwqZR/7wAHGmBFEFyA9\n", - "cIO7R98wYDAAz7I4AYfD8NQrP/8vnsSbh6AMZ67HP/5qFIUbW771/8AAWDYEbi9DCC80PfwYaOBJ\n", - "vWK0AC2GPBdBNI1Pyszf/3x6jn9xCLZADojkWHfzwOz8G9jSkP8GKgAdTJin/STABaDFr9q+lUO/\n", - "/gjQYARPRQezlj//VL44MY0InCIdgAIQ+29CqFQpsqzMOf8sOEErsSKalwQSR8uPKVRKiM1Sv//e\n", - "ADDtajsc5AYU3BcPhwd/B07oJRQqrS0VUF9MhnRUkKCFmG/+loAAQD6AAIEwAfrG/SkKwCFhFDLg\n", - "XxvQ42nMiCS/4OxBCXEdsLNjTp6fXkKrtyuDlDgeCRBU0vELwr4ZgAwp8yiwgFojYWNn4MPCBgX7\n", - "cAIQCUpQ0qQSEYxTtOe/vwPY1Ud+tG/ZXEiD0oiVXv/ef8/hBJYVgCCFtAjVz+GEyZZy0+MbQJo2\n", - "FauvDCD7/8GH4BKwKJXiJTb/IEt+8viDOMQxBokkNoGp8UAiDDCAANQDQEAAIGbgACAr4KoOUemv\n", - "YEdtZQjEtDIKWJ/97/9EwGBJ1gEdNGjoFUhwbgoa/S0B/1vCmNIfDl/JEyiAvAENkE8XhD8qtZRj\n", - "NM8H2QeAB4v6ZarRbH/YCSc5ms6ta8/cBIKFOpsQgL6WGfzSIIKtRgyv9+lX3wIEA8AxPBcBboTL\n", - "3U4AQtfH9a0BjTlU2ESvIYgYYGvAYBUoJG/Swp74AER5X9/36oeJebq/b1j+H5ja+D/++PMZByHv\n", - "EMkRv/bcrf+GAI1DJESokjGDvF9aPDGuIAIgBkcDuMmfAO1Nxo4OMKUeGwxMQHPfCJ3uNsQgt+EA\n", - "AIAYBzjnCa+Xj8GzGcXeU3SDN79TAPWQw6u1fL+JjEzin43x1Aj2GSAAAAHsYQCH4AHAA5yA68Jw\n", - "zPLeAFFUyOT3vP8LcABaZmhNlKrMoeVpOybTu8BciRljQpIURODANQBvaaR//nhwABEuJuolxd5/\n", - "ticwegAOAAIAHA4T2rD0q6lkjTgYC0AAEAQZ5o67jdy1FEUP2DAAsBdQD0nNBKEpQOfsYAAICAAA\n", - "gLgAYCaYAOJzhHjW1rpGRszQkfiBnCFOWeJJDv2XJU9xak0QZwTCzjIDAx8tFUp+cRJNQ8JAZAIO\n", - "AB8gSVMUo/zX+2Q+Ci1cRTvjE9ggB02fSP6dhfgt3QC4wr++8FfmQncIhQ6xgXKYOx7xrQegMAMD\n", - "oYy3nVtd026/9dBjBUqec3Vns9fwahqGGZ5LCpIIFVWRJc6x//cDD65G9kAzaPHwIw4axA2zhNgf\n", - "4DQQE44DQ1YQsUEETBR/e0xQEtqglQqeKiCf+8H4AOhEGIZxhyihyCzCQfiBHGJVxpyyx31l0wQK\n", - "AA7QAFwFz0PNAQEH4xZP/zH4kCEoJeFZKIiVoRM2gGAVwQBi4CM8Rn5hHWnmUf+03vcfjXIWYt2t\n", - "P+/ABYDEIdplCr/9+IiFDCslEGE+UDzIWpIaP7/mugLORSwdfrCIgM9GGDLTAUsWEIES5Nr/jsIq\n", - "g67b3mN7a5a0/vCRUhIhMxB7YYXOW/JAAAABEGEAouABwAOcgOvC5fE8QImC8AHgAGAi2QAkYruU\n", - "qP389oZHfXgRKBp/uoEDMyaKB49Az9qQAA+AzGgeMVWqVT9c+4gPYACZkMzqI/nGsJKIgMOKR0Wz\n", - "wnJRBCznWAaEFc2GtYqJPM7+ITJe0vwu70gEutb4vAAj3eKqfL7rTI5cRYL54aAqNPtgXFgHBurR\n", - "tJPb94cBVhB5jvcxqbWoMMvz1gA9DSZd/pv/lDyJPdednr8v5oIQwPgv+SISaZkRsibguluOJbAv\n", - "jjrXgwcABIo4SZ1KWOcoYcTiEIkU+N6aehd3hnd7/YjqEjR+9/6sUNzdHTDsHaISQAGd4Myzz1bI\n", - "tsb+v/o2YRjVjZFevDkgAAABHGEAveABwAOcgOvC8SIDPjALp4bJABl3Ny3sfh3IHSTSpbr4/J5w\n", - "AFixUfu15jFd9PHyIjrwDRit9jW+leK++nFF837qrwYQtsx4Yv0BgCUAAQDpYAAILMgACBVXMFIz\n", - "CAARXID79KZ3pA4RhdwYvYPvknvKKbfnB70YDCxMHcGrvrvHDRvib4x6CEABxYVEJUbpy0jrP/uE\n", - "Dcw2JalBdKMJ/uCDrcQ7ZN1+jiRn/uAECJKIuzCeEFSDaX/7NTySQS02JSnpfrtGF6IlqF3wfhAA\n", - "GgOEEQkjvAFgGGj+sTZavnNbQlkzcxv/634f9Pee5dNoSEQgIDsPOMgMJ66sYkHD99GgwKouviY1\n", - "dx+7J15J+BoI7Pe67X2M9A6gAAAACmHgAgAEHIDrwbwAAAFVYQb4AIABByA68Lo8IhEKy0h+ABLp\n", - "W3pX///QBmCJpwxd0f+P3x5eB+wlOgBDXWkbHfgAgjN1kQ1P04kIh+ACm0LV1ZlvpRE8IcZLTwP7\n", - "BAAPkxgcLMMSZGyQR7FaG0aKJ3wABEq71BG0AAICAAAgKzIAGAACAMXeCAAIiFFhAACAYAAUEjwJ\n", - "QAX0zSx6kX4cBdpQGlJMt7xvpcQF5R6ndMg8tQ3AAgSj0wABOFMGogQeOo9AhF1pCnz7P/UGG0nI\n", - "/yhr2/d70ABdH+eoIjqATmJyLUdNdH/+BLejAI+SFjK/1BCIQ5COqoOTfhMzH4bhwAKtMJKfEhTU\n", - "v1yyC1FSpCb7xgRx3PRR0LauAUd8AGOslWQcdwRjDeyvAdFbmRgy7kJrs//7hgnONvMSgqHmE/wQ\n", - "ABwBBbYEBanJsimYv/Ww8ACDz/2IstTzutvBLw9pvWe5eSAAAADnYQNuACAAQcgOvC0SJP47gBja\n", - "r8//MaymSc0AIL0r9//Bpv3i3TZfEggnr0Z6c4XyhdxtkY1QD5Ge9+FNRaHHjv68/jOgHoP0Ugq8\n", - "vfA+UXqq65KIJoyNH/f/cg4YFoADkZaMqU4hcpYjBgigAIhNRFcReptkrSHzCRQsbxVPNYQv/97B\n", - "zhkCGU4eLCJF635PwduXfSfekaNv1lOfOViozu/7w0XxMSTEQ1oAkn8qC0SWlmrn88ieZ/+7/d4d\n", - "DZ50Q+3ZQVPwAqBsWPWS9JfE/zxFkCMoejhYxmMDAD6VpbeUJLefaUyQAAACGGEBR4AIABByA68L\n", - "o4kSJD0ABJkEockfUKt1/6ujgGLwzmClLSUNCe/eG5IZTIhQWJRF0gAVbMeP3YiH/rYbpsdO8V36\n", - "GxAegWAAgMgIL/jfUEkUFF+pBgUmFxCABgylT88uPL//je2zR8+AwA0Zn//3gAHXGmGdYX8Z9GGT\n", - "XdwBJNoKpkoibd7U2Mb0kOIzv/vNxvAAeFAeHBZNQsIwjDk8/xI+AHOBDkXLA446jQGgIZ2AAICM\n", - "lAAEFqQABArX+gwAABErw/FoLcAIDjoQLGxX5WvgAcGUEE+xzqankE2OphhUAAQEbJQABAVAAuII\n", - "7v+BgABAAgAIEBAAEA9AAHgamOqxUEO00P1cTMbwVLQjXWRAkVeZdu+6fVCRk+y3EDMCqEk0ng93\n", - "1GMVzhDhZgwD+7VyMTenSiU9nrJIGceaJJJXr4LQj4Rr31LU8TBBGbjwbgB6BmBxBTJ8uIJE5u02\n", - "AD4zCsFQnuH0AQABAHEXYGpRLVptXXGeeQAAICIAAgtAACBag9AAwHotnBQUgixjXoUXBQLAlaGE\n", - "cApARmxTBAQqyggACoIMf4BmI29uO/AALDNv08i1/bWy5eIUW2teP94G4tyx0Nl5P/wNQ8C4huYR\n", - "nlnjj7mkxywwGMMyAABAQAAEF0AAQLUHg6ACgMcdIAkNlJi//u8ILMwQABcHEs9kumQhuvCgw/DG\n", - "wrE+4saI92avQw5IAAADr2EBs4AIABByA68s8MdmAJAACIEiIJAAEMGLApscABAP8UDCLgBEc3PT\n", - "DlcHhfooVA5CAAEAEYI+EAAIIwAKAB5zACgP0biPeuvARKTxcC2IdmeawAsQARDuBUA0QXLrwCkD\n", - "6tWnPAd4Om1gXqoQ4c8Ag1QAAiV7BARUsCAAPgMOf4AsWiAEHL7VwBCAQjSwEjTw21S/4IuGOBxe\n", - "QUEhKqGk5JjgFRAACAj3kAAEAMB1Q1FABNY395upgF5kAAEAsAWGIAAWB0FAAEClQABAKwJUPRYP\n", - "LkwVzwI2BKtBGiXlnfP7A0zB2+yAR4y0O+3/gJEIC4JegE1hUcwE541CROHsABwABADoFHcmw9Km\n", - "73fr0PgAAQAcBR/KMOyruliNODGhgoXABOACzABqQAqhznHoEojCAAJCpcAD5nkLKjb33lnx7B8s\n", - "jfn8GHQDCnIpteeAHMiFJ4DiUb9RL9BggQAvxowk6hh1EdL6IaFyGIFoAPLOqABLwCiRT//NpB4o\n", - "QRzNUCDWFt+A0IXfPHneZsoJEb//8/A6VEKUCISAlNXgGODE91z//R4w3ctm60GUOWaDee3/AQBM\n", - "DGB1LLnmAFRStC0ewdzk3ZhG4fRiqSqQQZBVg116+mInhXAjIzAAEA+IKR4AoCNoCv6H04SVThjy\n", - "saEL/cAQWJ1YVuSp6IEbhz+DGWAgADBwIsIAAQKwGAFvBQNqUWmL8xZWEGsw4kPSn+CDBalmE4CE\n", - "TpIe4xQQlOBIRsekrIcefDCHDWMQAAgI2AACAkABsAABAHX+vhAmcwQABYHOPjhNAGgR9pfh4gMI\n", - "0DExVZaX7Diwr8xOUjg5Ii7jKx5GXAQ+FAKWBdxxR1ngEFr8WPAlzYKK40Kk9gsTb4MOGAAToeDg\n", - "ACAoAAyw2lCEpTPE6vWYN6UOkkXlVUe/9EYRBcLE2VFenCt9bBADHDBxA2LtnhJs/5f+IEwvgIgB\n", - "qAVCAbvCSJXrSkNA4ACBDNMX1Uw15aBPFAYwMKYQCQpPA7D1jKm748AXzt9voXklWFl0jeAsYEBl\n", - "znmnFrYYkbF+tb1xl8YJnBiCOg78KFEkJ6ISUxkfHbLSpACjkoA4EXIpsDMKUSNjoo4Tdca+n/u+\n", - "mAUIwcYrSE2l2YQvb//Bt9/fneAoz8mKoMpKjOHv/8HaiMMRiSSkp/fcBRKOrZ4jy/YF0IeCQ3FC\n", - "IRBKONk6AAJUP6KZNNDlYIFLybjxh7/wOnozF8FTy//wSs40sVcY/++KW1UMoZIAAAJeYQCH4AIA\n", - "BByA68Jwj/eID0ABwABACA1NHzfZlTVXrW+D4AAEAACa0dUgzO+qPZr8GYKgA4GZQMrEp0AsLP6C\n", - "KutHYgYOxYUG1C9EJHs9XgAeAfoNAAgOwFcJhfbx4MLAh0lDMTxUTUKSwABCFAAEGhgMQATEIAAQ\n", - "AgH2ABdQJhMXiUDkZRANzDW942Rbs3VJIAwBUFJzPSArCcHRbGhHmxGhB8j4/ENiF6c53KcKAjEB\n", - "kLfEAHqHEeS1NLuqq78DBU8SLXVxhDieFkAw/E0AOgsxZ2gDCACxKrBgRAAAgIAACC2AAIFqDCAA\n", - "Jh0YEAAIBwAMtbsGwez9DwPT2ONCkEhSBR9UTDTAYoIeD8HxBMIRUIOGn0oWCIYZXEBjmABHBUOl\n", - "QZXF0MkD4Da8NwQb+u5RADmmU7QAPFC88S2mV/8VIHJJKu1QnheAAgIoYUjXW01PopLbSDBjQccE\n", - "QAA7ASYH9B2vHw45/61nAKCp93N2BPMMI2IAUdPSM9lFF0Z3nvVdBH1oeunRKrQHrwTFMhRXv2Yg\n", - "NwuTvuduYf+v5NWhvNvF4RcSEBsAWRBDzwvET5URRp2u6PoBAA8CoFL4c8yZ6g93fYYAABAStkAA\n", - "EBMACg+fveyujAAYMUsHHgzk1EqRso9/cAejHAQkKiSUKCQv5PPv4AAARK+vwABAQllAAEFsAAQK\n", - "9/1vDAAOwAJCAAIgACAEUADdaiJt4iE9QbLWZNfawinIiBAWTgsUtIZYN7hxukAbyip+zSXvfBem\n", - "CMPRBJTd2gIaEQZomdFUluj1kMQl50Di7BkG9fEgAAABR2EAouACAAQcgOvC2IPOg/QGtm/gf4AW\n", - "0E8kwzfXY8/ovt//hGGoAHszQEJSxPVFERIJ4AAgFgAMBxl1+L1+AjYGY5jFEbN/vvqREQEJihGl\n", - "lkgYgCFQADwBvhkdma+/ATCovJt/vfssakF5ecgMivyl/xFt99P1BYTEBb2hpraaZg/ftszH3Kru\n", - "4ZeExymL6+T66uoMEWqxv/cYwy8jC8AC2LO6Nqq7fvgJRDRa3gKgsoj7AEj2jsm0/AABAF5eBUiE\n", - "n6Ii8Wl9vGTQ0XxU3Ze23ODpa49tQfiXYAHtCLKJdN1kb6ZTpNvip/YxCIdgbIDgimrUxsV/78Hr\n", - "zNgYtrE9XXTQeGkHYfQ/8uS1A5ZZv/r/gQsCNnA4p1xiOfNT214v57ZvM8w+qsMzHbrw79FKeRZB\n", - "pSonf/f7LC0F6IQVWXvnqVHRIAAAAQVhAL3gAgAEHIDrwvEhAF+wI1wDlp6WNiYAWfRtfvhGPLw3\n", - "EAGq+Is3/6WxANJA7CJiYfgUluUdHqXD47nsTCARDfgAWZASGokJXLHiZ8tv+4ayReH9YDHUzl9u\n", - "8bF8CGyJYy9jIUp6ccNThELwALhoQrFPAnNun+AXAGMSEJ1eTxTsnC//+AR+ibr1L8AAEAOh6AxN\n", - "hyFYpIL1JZMaGmKzOl+qKlVW/nv8pcAF1guHmGIJjdSqnpDan4b+hP5gH8MMAY/wMW0QnTFJUdw1\n", - "3/g+GMyjLSzqKQY1/+DBL8ABAEBBBA0QYFGheEaJq6GEhhAuc4EbSLYk8KCxcHu8R4RZJ47cwdQA\n", - "AAAKYeACQAScgOvBvAAAASdhBvgAkAEnIDrwvDMOeABeLkAoYWZWGyUSbFW/ioS1wAXtxCndWwcA\n", - "Am2hEnF9GTCUO2wAhkrG5Ee+cAYLIGYAlRaiTAOjOov2ZIevI5HKAfmZjK/OdSjpa1YYADjH9JKy\n", - "YcUQSR0cD4BAnFAU/H5LgNhASz/90IROEARIwAxHWS+bQY20kuwXIufeACXBmBJiqNskztdeqWoR\n", - "ETsBKMkvgw1YkNYAkIhhwoVUeUbMjUT5lVoNEdACrK/f/cUpr6/Aag6xU+b/U+Pvr3QAtIJyqmSz\n", - "7tMaLqpH01j/8BPCBvq4siCeW//W2baRCjZusTCIkM/6kwABApdqjgACBuAAICtwEww41gOxsW8+\n", - "vzOiyCJLXkSO/3Abn5m//++Yds3zzy6VMBkgAAABEmEDbgAkAEnIDrwtEiTxascAA4tNm5av7gAG\n", - "hVFVViVL+vEwzz4zWAqqzdpDXss1//1JpnKhlO7EsBC3Ru0yuWybTf/ct02vD3hAx+As2RW+dLXc\n", - "2JYMug+6fCCJXgz7X3hnnh/BAWH4AhPpi31UweD3wAf4Q0ov1Gp3/UD/i7m2OSsSJDGAC2zGh+WE\n", - "MT/P3waMg5DkMUl9/xBngEBFFZG/ExEfmpURKMcVf/caly55t7dfyp/VGH/PxlLm/9OIMO8ABPAC\n", - "BxUpeThuluGTPCCgPBAWTWLCMIw5PP9z1qvHP7fhzJBgAHuAeD8dlg96GqyQEsZipyCo3afwgAWs\n", - "gZRHFWSWJKJALxHGcJwUdLN7tEgAAAIwYQFHgAkAEnIDrwshInPNDRPAHM1Mb9VrNfZoAPM/E1f2\n", - "qJT6vgit/mXbems9n8F8ABBBYN04vAxc0fqUFVXiFgTkAACArgkwaPAEhd2SwwRIjK8AEcABIZ3E\n", - "SSy1a9o9kmK8Gob716P/djf5s+V+kkSFkA4+N6XfSliv6iYvvnDIAGhuhIERc8TgiqIcIIia/fUI\n", - "BMGASDfhgihTZMRXfwol5cVgvNuuAyUwVRQuia3r3AeDh0Ib9Rd26Hy3eMTFABLJAVBRHhcEt4xu\n", - "nwMvbHAKUpKnCn8/8HQfhEKLKFJM8AbheMJpgRSBRY3AHfD0xmUZaWJKQUPf/z/hgAEgxKCAEpV4\n", - "yNATiKPPNPCaQk7EriSpZmEDp0Gm4FXdW3cRJkEyL3dFLdscKWuOJXffGxORLTkz0V/PIWEfDM88\n", - "4gDob/EH9K6pWRsf/D4AdA++eIfTpjwegal5/9MTECAt2zmI+BAVYev6ALHFlkH/ufBYSNSSRPv/\n", - "//5Qt4TuP+XeGQ6CCoCDVaQBASgoxKIJ2b65ZuiqwTzbAAsAAQAhXGjrttVLUVSU/aYAAIIYAAgK\n", - "AQCKZ4A8jg7FhS5Y+UEVB6vBuSCmCH8Clvwo2KVAAOI78id4nbP9AsLO5N9Hxlv+L4NnDhOqsmAe\n", - "xO3nqAuDZBNeji886ye4QDMO5gACCCAAICkA4E3dn+GY45Tw1djaj4+V8uwwqRBAAirXR8bPjQhg\n", - "wS6ZgJF4RxCpKSawYckAAAM5YQGzgAkAEnIDrycMbEVdopgEGqAAESvYYUAAQEQABASiAAPAAEAe\n", - "84IAAgFLICAAEBkAAgHDOZIALDorgF6vaMAFYXB2pIKkADlfN4Y/gTvgACJQrsAQnMAp/o0A3ALW\n", - "cEw6TC+TwkAFgcIIAAgG+AIxBTMAwxXagjj0wAFwMJDC4BiskoBAy7TdQDcADkYT2oAH8DpYEIKo\n", - "Y8AZ+AAgABBch4AAgM3vmGZvr17gFEGwERSQrE7JCYSGn/8IAJhCAALID7gTRO/agFZQBXLRy3fD\n", - "OwAqBRafA4hhdeAlMADrkQEFL2r/bYK4Y+M5aYAYA3cLAsAQHfwCMAAQEQABASiQALBCz4DAeUIA\n", - "BAdw709S8mMSXNfxUzNLPYXCIKQD4GxAqgfF8P7iGk1XpfPFiXw9gBYHNP3fsP/jj/jMIFE1TzJJ\n", - "BOliWodBoQWEsQYH/JYQClwQZ3ACtOadX75b26smBE+k4x5ZhS2FdkvH/yEBBzivqFbxUqMtP2UE\n", - "AqcELM5jPn5WIn/YnS7v8BntJowv0tF3+YM/uGfh3MojiYGIAAQEbAABASAA2AAAgDr/XmEQKSSF\n", - "sMExr90WloN/DrExWJgIAERbggABAKADgo2gxQzIEA2Z8o+Dp5RPY8LB+05/wrDDoAAgHSQAAQEw\n", - "AMiAAIAg8/4BCkUK4SMjkK5MQ1iBKDDgYAAjAoSAAIC3AARgUwC4VmlXEcoKk169v9wgIKoC0hRX\n", - "aWtg8jAbE4A54eaL/CCJwrgCQzxTMf2JCxlfx/+Wwz+x54DHFupJ56wjB2RAmSwwgPJwgFSqFO1u\n", - "J+UGH6CC3Za8Of4LwezFYTSVHMLCGTUwSxvT/8//CvyGgi+BXldKvA+WbAIhosHQYAsIw5K0GCCY\n", - "0hx6KXkMDjmEAECKOuHmPuVSv4fQsmvbf7kBGIACOBRRtTPcTVPxjTn/WJEAwgwZ5cACwABAEHcW\n", - "Ou65UtRdJT9oCgACAFgIP7Jl+teWsQpwRcQQN/kaiaGmkYv0euEPa/udMabPpgsbEktx1/3plhUQ\n", - "hNEseqkf98ZF17/nKX3kbWv7ysTPQq/oD2CIkSpJvf/c8NECrmlnIaf+9+SAAAAC22EAh+ACQASc\n", - "gOvCkYhvABriScqsin/7/QUj+Ig61//zYCJo0ht1IrOoYEmwTvSLmoZTXGjb77wAApWA/FCG1bPW\n", - "98B8CQIV1NnLuMmN/5xnkGVheWcSJUV+74+3s22wfkUcJM6lLHOUMIJFOLIAhTr47cz6bv+7AUAj\n", - "xefjqpwOpccZrezPm8wBbVmGX7PifiYd47cXDggAGMrNvYB0pGv96weAAdAdagEDFlqlS/XOpjGh\n", - "HhB8KJ2AI/ZpHfn+AMT4VGr1OKQvhq2/X6QYAXboyL2942t5/dQ1ab878wLL4gQJnxAejDgAngAB\n", - "ADABQJQQNlV1HyQIHX/uwwwAEIpBiWLOPCxr7HkpeVQAAgggACAlAEAmJhglwGAA09xBKpZOCAii\n", - "XpEgdA0JcaUbjI+M/+uimV5EL/X7hjLBT6/qDw+Ki6/WcQ4VTKgN2huVJBn1tqH7WsxYsAPrl4pY\n", - "gNhbqBCa8BKDVaBZysPu+TLj2bBxkJl6EZEv3P9tt5tt/8AKBnGKICm18pEhFdynytIcxcrbz2IR\n", - "bxYnZ4XvFaYQ/sY3AIoIwSwDCyioWQjCf7wcFhoqx5799aCgC9oMau9wdoDN+AhLlectf+8M89fg\n", - "xilF8AMIN4nl/f9Ivtfu0bgw3AAtBiQeeGRyfKHyRa/wIFKCAgANUTHs6kJXO3ACIF5dgwvIoXWx\n", - "p/gGBBgAsgAoG+KvTN/WR9Tb330bYiWS+4YmfplpZibAS0ADQRMMshRMrf/tESoQsKZcMh9zyatG\n", - "ABgLF3q/djoLE4IRsGVHABKO7hFEmuMJe72BeAF4cAILPjla5+z29kAoDYgIQCRbgthTJHuCf//A\n", - "wXjCKOQ1RpgYBT3DYsAS8BuZQDBkkeIg/IeiVngw4QCs4QABoBln5t4LKLtZAi3etMe2JkyBpwEe\n", - "altvN436lVVLGhRL4YzQQFs6a2WmYTiHQRMgbA4cHXmexlqnVykgAAABWGEAouACQAScgOvC0TPD\n", - "fBCEIAo3LX1TxpSz7/AB8Ga1Hp2Lb9Q+x9z1yjf9FUQFaO8JGHaYEiX8Cp4I/WsLsf/gAh+13Lf/\n", - "/YykoiIl/waRsEKDADwCcj5FnfHAAbBq+Y/GiCq2l0+DDkPogCYDLerOL+AuSm0un0z3i//w10AQ\n", - "y/qhj8cFCiKvv3DDgNBIUSWLCEIx5PP8GHO/XY5/b9OTYJNMAIEBRE+8MIBAAIkBARAAEAVAD7WO\n", - "kd+4C9Yt9V5EKmIIjdoPwN4wRwT40IVZaKiEYd4nBV0u7u0H4ZN/P46DmABbBscbWoQUkcq/+QFA\n", - "GMpvIs0TVhhjgn/+3bMP0VK0pvvhAARyCQFwALAQXaqEqvTUEBDQF5mrk1N0AQ1rzPU/eJEHnC0U\n", - "iIx6bjwYbDL7z0H8JsLBXkQb8ABAYhgtXCP2ll0miP3DK4J973zRjCPK8HvJAAAA/2EAveACQASc\n", - "gOvC8SIDngAVcwolPjQpi//4XockAD+i5nnIvdGO63vukZ/8q5wADhHUPPaiCqdqX8GW3+/sQvfW\n", - "7Zeud/+5UUq9//NL4nxDnovSbxPLI08UEu9KYn6GcoJcho3znj9Av/DEW9j0UdC2rgFH/AdFXmRg\n", - "q7kKrr//7NSEAE4jQfuBeWRXOwV2LGL/ymYe/h/4PqBSHKRFBTCs8jYdgBB9pDWeYWBop++/+AA0\n", - "PKGaAhReSTYPjSovzCEYkt5EYishzKUZKlpDrBpJJD7whMGcIE5hOARorVxGuQewtYbCh2Mk93Az\n", - "M66eeDfBFAkRYmSreKrppB1A6gAAAAph4AKABRyA68G8AAAA0WEG+ACgAUcgOvC8IwQy0h77CUdD\n", - "sAH024k3D4wAEGFrSwz7uhHroCQ6H8BWV4p7B4aSV5ej8w+BIIxXgQfokFcnpE69BgCcDCJUp4Sq\n", - "YKMlhJY2W4C+6iShAAi/oFgv75eAdceSLE6uwA4BKCzIiXp0CIGdHaVGjt/veGkICIRCJ/OoEvo1\n", - "c6i4+SgS1zfmwg3hBhaekEE6LswALQTmHxiUlqHpOfkBQCCpIL2h3JLlYGQa//BAAEwrnAQto353\n", - "S8D1fidA3lj9+9FTy6juEeSAAAAA3WEDbgAoAFHIDrwtEiT14Ad3J9Xe7gBaTk3K4vEiTxSihlAZ\n", - "1nN3L8UANsV3cX8aNvCASDNDAA7+Hj8sIaE+u4KI0BEtF94H8+7B2GcQeiMPwA0GzS03vnPwAfjD\n", - "bjmtqV73yF3CmJgwsENg26KUAG4qfEonaQ+dAPQ6qRD9r8KYaVj2MBqwRvelwgCYMQAELB9N3ZEs\n", - "DBHE9ECtyTMgGW7UGrH94Y4D4UaFLdaEguTzYkdhuiAABOgJhdTb7SEtIQUPwBMNMLGdTaQMzz4A\n", - "E3BwgLGIQ2nRermh/MSAAAACkmEBR4AKABRyA68LITEiQ1QEAJCAAIIdoAAgLg4Eg+c63N3t86A9\n", - "oGY0AG6uChHbvt7KX2AHrNR2ARECLi0Bx8FIa+wtZrTtHfWokTDsZv/AA8AxhoWyh8qPXsO44f9+\n", - "+AAjCc4z1HlJIHpMLpBhw0VQHTCRv98wPunW6f8g7vf2O6rRekETJNkpXNMnLTT8Tv9bzBsq1Pp6\n", - "WLwne68qfsoTYgbDAAQjGCFODWGCoFED0rK8vMGYBzEtAQjwniQyTeMAAEBEAAQFwANAAEAaWIAA\n", - "EBMAAQXAABAsQcYSFH0C+WyhgBbMCT+kIAYKabABwYKi4TbugTqdbgQVVPJc9/xMPgoVwRqrpICu\n", - "raD35+Ndb/0PwwADAB3MIAAQHwABAKASFu2SQj/fEPZsACw7EmH+owbReFyCyxowQJjSs0BqOK76\n", - "zWGIVjSifJfe4vATPwFJCBGRiiWM3SGj/D/f2joF4Rq9PET9dOAMZWek2PsQAQxopjqf9/xELyGQ\n", - "AEEYECkq72wGX+Oe6B4gV92AAIIoAAgJzAEB43zoWEHEsBswKCvcNt3AEzHHKeo8RtIiksukHjAk\n", - "gGSn4TDDBkmm/y0h7SQt33ukUNIh9I9/wGZXptJ9lGuWAEH1zX/5iRpTzWhn7hDIgXLK2axd7QSB\n", - "AODAf+EcghbAxZfSbw4UbPAw5P71v9AEBQgAKXBiQAb5R1o4A4AEfmyGR1IdCHIUhPAEKpg7nT57\n", - "iQxoEJAEXwRzcW1EkLGBnwsLQAOw/AioUFHvhKivqZgCVNDCGECATAsIAAsAAIFJYADIa/PePA6X\n", - "BqgWnWFfAJznps6ieCf1IQjEyBEEcDwyOaML30AyiQOVL2B97RCBtVlBf1lDagDj/EgAAAMgYQGz\n", - "gAoAFHIDryF/+CE9Mv4L3Tzf/fPDvAAMgADboNI9fseAPBq2d4AFtgHHBzgESZoHyNDnhCAaBAgA\n", - "CAACEgbgAnjmKoGksv/QSOg0Mconq9gB4gwnoLp9AJsNOn+BeYAnUBCx5Rwv6vD4OJ5heAPtlbXO\n", - "AHEDgjH3jieY+GOAevR3AFgDAoTghGQX8hnYhM9mBxSQmQkZEuDgAR3kK96kHggx+EAC4nYAdqBb\n", - "0VqkxzHmnmRn+3OBM80PIxQGksJfwGY3xCzn7ESbnjcABzUFwEJd7qCJ+pzn/+h8AAQOFYJUwQlw\n", - "mU51v3IbFSBamGJqYg/BCqAJRxfw9hdHTeKWrAcAAmDmkpgAeAAJbEACh4SVRoTUmIfgEoAAgIgA\n", - "CAlEgAWCG/BChUIACoCqAAtgngi8fU/1S/2GcQPVZlOH+/EqVG29UiekGuYLrE7DCdia8q4ADUzc\n", - "IZv6yn/WawX2Bypoa/3y+JhApp4WhqGh8DUbpd/h+XA3Ed+MBhedQceYxwj/0GoAkUBQSYxUmQ/H\n", - "izI0/IGNoD9FhhIPPCtiKZmiWf6/4UCwgQACAO8PBgOfYDQM3ykkhZjZiHP8BdjPZg1fQEIjaihg\n", - "GU4FaeF5ZdOB+Pjp5BYIprb/8LglhyH2vfP46Gti8QGowAQQTCzwMyHAtan/1+AsICUhWlSaH/z7\n", - "0mtB5nXf4PtIecZ+NFdXWPpucw2AEYetRxSdrXtcQwdH54UmUO0ICaoGHwDUWzwFG1+wF3E0B3/3\n", - "gYB2hs00zgWRvsUHRnuC2MhHLDM9mP+/eAB0AIFP7WOqt08y/4ADY9u6MhTKd7xGrWdhBcIEqfLA\n", - "5KuVS18C6GQ+NXycUgl374MAlzCAAOhC2IaUc54mAz9xkP7DQWkbihBz7+AlaaGsUvffQgtCSYEB\n", - "kP/RUc2xpr6MUi39YlCxA3CoAAQQbQABAUBwIh85wA5qIYATKv6CU6kAxoAHAAxCOaFMprN25p/+\n", - "c3v/Hg/BlYMCOXyRhEBYwQCOskBsKhiXb5E9EQpzOAAEZl8em2AxwDJ+B/DoJ5b2G7j/jjBUDJAA\n", - "AALgYQCH4AKABRyA68KKCEWQb4AFsGxxtahBSRyb/5gKPGLGOC4cpI67/4MA+knXHABhJJDqT11m\n", - "xSPnP/wAhgrAubIEpn1OAxFK994wGI8Z+6zNMTxhN0PgJSmaid9GUgjgYQJW4pYAD2MidGV0cpEo\n", - "miHqRyOn2LBMebFfef93KbyUfjiqcQL6hLy2D//BQFePAL8ABaAAw6LQVxJBH6FeAQd4E5hhfMBL\n", - "iJdjhaygEPH/QERjZlxjlrft+CgNLxozDCFY/zZieIQBpeN/P5fEiTiBhxJg7DAAQEwKFwCZI2wt\n", - "4XP26X4MM8LiQBAE2BWeTLwupqRIgc8BAlJkAnhvGQ88Ifv3AAfCRx6W7G2rar+EkgsQ7BYTMmp6\n", - "bn99pCbMenql7GrTvlikAexka7N/jJRmGYw5vsZ9Uzcsh1ot+0v7ygUhDDtuWmt+AKMGOB0W3W0W\n", - "yJ00FpO9DRgpAU0v0SUNiI3BX4DQwBCVJ0AR9mBAJlCHwDGiHnLAVOGMthJy3XIvT88GIqmwt5PU\n", - "AKaDrcQmJnpgO4AAUgOALBOEqMDaq+EAAQAAKwAkIAAQEwABB4CQAKZxWhoHPOAFf72wd+wSlqMU\n", - "Ae/zPEP7sB8E7oUzgGh4CgQf0Af8MMCYxaQLj8gVHUoGlQsG+DmMav/QwmGYkwb8YH+hNeNi8ADL\n", - "ubrewSzSCWz7teAH2Tk/R31AAsWfP1b8xnd9o8R2F2B8fWnp6gqbBhhgAIgymGYs833DkmV0gYCg\n", - "AJbFuzdcUpiH8AGMlSdDDtFyxXdXvgYdgxSGMjnDUe5nzzrn18wNTIW7kIX/gH3HQJzxv74oawER\n", - "ezmnfIoBfKnpf4fZ05v8Jnhh3/F8lM2k/UyMkNupFZ18AAVjA/Ed5MAVCch/koAGMH/fWYb+Dzxf\n", - "4OmmGaYQEO1wHAAOEAUOBtmNxYzAZZYzcEsZipyHJu0HAIjBmBkeGqrOJ8C8RxnCcFHSzu7RIAAA\n", - "AMBhAKLgAoAFHIDrwtEiD9EwgAFKaVW6+Gx34AFjFb7Gwv0rxSVWCpa3+/X/iRAIsOy4hwbES4QB\n", - "SFYAgjGV0KUAD0bAauLeeRThJi8pY5z+AEzUBrlCJaO60wefG/tbB5LYB78ILEYB0AEizBmYCST4\n", - "rQ2i+AQu0Li/n5Jk7vP/hnngEsAAnk1xDsQ/+7EfvCIKD8oIDKIyM6IiJ/N0B6bhlD/mv0DvNDfg\n", - "AJDcZnaSeswZxddRMGG53fgJPWh8zyQAAAC6YQC94AKABRyA68LoIhASED1QLACGen1eb5fDLBxq\n", - "gzvZkYS2YG3Gl7ud6jsX/gCKCV9RaWD+Gl56wRkyNHer93//bCOH4ACQDCJAzn2whFGzudxIugWk\n", - "wSZOgi7YQKk4aSkkCMqS6jMFjBFEM/XvDwADgBweOOile6fkJOpGOKPgBzIZHUx0IOhakBz8dttn\n", - "nhEgiBSMPCAcKLAmkaq1xvvbQ22/3dDCDBvywCLE6Bbp0sXcOVrWKgdQAAAACmHgAsAFnIDrwbwA\n", - "AAAtYQb4ALABZyA68LwjXShSxJ8TP8JeH/jhrCPw5ye8AoBlWv7P+JAAMn/4/9GSAAAA8WEDbgAs\n", - "AFnIDrwtEiT14AcWlvr2/gBRaK21+/3iRJ4W8CHwXGpW0Q79vWBtj028+Qt/7/hmInivjecYBIX6\n", - "OHn6Cz92AAeVWUVkVSf/878daWP1sFMRD+gOACi0GhRJShbkCGYW54haSGL0MsC9eU4eaI43Nsif\n", - "DeFgAms9SKi6QYfatKaTn7P976ZuilzzEHAIJx4gFAbgAIADcIV8WwCmRVikEe5eD8wQRASjo90g\n", - "O1KaS4ABF5mI5lUQlBQnSaiAQACFcwIAAiKUZ6DCb7IA+OKvgmu6+cG7q/qCV9fIKqCc7Ciyz17S\n", - "eBnRUWt3hIAAAAIfYQFHgAsAFnIDrwsokSJCuPOXwAEYMhwj1nG84akuopMAAEBAAAQFAAMBBMCt\n", - "MIBMdggFiTiPjST1ndz0AFi9Hxgkau9yBpjAxtR7XzxuF2sdH/dD8SHe+39Xz7xjIcRPuehhqnuU\n", - "YkcmGAACAUAAIAgBwsmBgAS6FKq2bef/6/NGZOMSouywBxQAAggUAAQFQJBADzO6F8GE4MBCAcPj\n", - "3ms+PqtA76InTz9ps02pt75gwDlrMDPVWpB/TcYRAoK96rr3Kv1kQB/iMXc2jZbEoCgGYwLAA7Ai\n", - "DlvUcIKjn+exW8BGGLwKQkCCztbQ4bDEOC8aOJqicY04Gnfs7kYXhHXD/AASLPIsaELXIwe1rTpz\n", - "U+8AyIkiFkIjMgcAEF6t6t/oCgMZwV+sS/YqWuIM/ucAALcIvSZv1kfF5EA3wdIlEpEXH3z3vl5j\n", - "B/xsWgBx5TdfvpfzYQEiAXwAHOKmAHkXDEFpEIf/tBIDIYAFpvzLjm6wc/AZmAAFQGwlM+GACVB6\n", - "mViw5n7sLEEWgeswyCLkWxR4H74ymG/6KFGjSbO/9bGIbW4ywlUnA6h/rXWCTDklWK93yTuD5iYT\n", - "EPUP4bnoMABEYhAV5phluv58+RzAWQqYAB2BsAARH7A1oTUu64QdB4IaFLlhGFIzUf3hgZABAIEA\n", - "CKAWEwXzOQeKFIHv3jBTy4Y6j9NBKYbLWM28KNQPnMxKB/RfLAsJ0hkgAAAC8GEBs4ALABZyA68n\n", - "DngAIZKAGQvhKqpEf4JgSGkIUjCAAivZwAUbkFii6pQ7gAdMMqJePRcNcfJmGYb/sXcItxZ2lDWC\n", - "CoAAhv0wQAAgPKnAAUA2FNzX/7/QgAiNaEAAIA4A4cWwcm8bAJIh0fvwGggYysFSXBWQtNgx8HEN\n", - "+ACyAAEAD7B4JkXsixUSuCWgkyLADHUz0jgGzwc1MY/m/fsACXE2ri+wjmvo1ArTiuzf/vOCFYuB\n", - "BBAf4YA46vXv6G1mj7wAPmMRFW1KKif34F8tM56389YiEYewALYjKOtCkFJLHvf5/wAAQBxkWBiE\n", - "TN66TzxjvAAwCiqrJ1VsnwjROv/XbMO0VK0pvua2F4JfQlcJ+8MATgACAgAAICUzIAFAgK8IMEsI\n", - "mNgAKHOpFRFR+h4AR62UcyXHUgwjfWZI/9eIEATFY968AiQewvOJaR6vS/E+IEBvgAOGopRQkISE\n", - "DB1apXhzjAABARAAEBcADQRlggfsEAASMcHfTerc9sUqeKjYN5eY8m01EIfSFOAwzM6hlKuq5oAA\n", - "/PgQ6X/KQB0MhJucH4a+GQAMOIjG8XwYlNxY1/oYBCEAkKSBdOyHlJ3Y/AXIYrvwkxZQ3yi8OvDP\n", - "xgBJA4k2pmqWgcBPVBTwzAAMAAQERsbh0jK+YdX/72H4QCUpQgADwCDnIUNEAqTzS25/gcFihiMP\n", - "hjoifF/x5fMT8M4CBgFNFJI6apGqc7bhnQRRIItOZbS6iAvYOxuTx77/5xjIqHE1RKGNgQ9SO1t7\n", - "4H8e9HHzX54TwriArNQeTesLX/OMh47+dB3nGIW4f/Js0Y09Rdb/+9mx44or57/sRiAXwBghXEqQ\n", - "eIJDCDHgodBh8AEEeSbZTf4BUwACqQOEulgxEnJ1wAkIGcmMI+828BmDjqb374H4PDkMhBqUwwAH\n", - "ZN6EiqcBAO8TDPwRg4QnPuGAo8xy3QvQwYCihhCNVeMiJZ8iLUXUdB9M1UqnH1rzjBALifOrc3+S\n", - "AAACDGEAh+ACwAWcgOvCkIwtwAEkMi3xnXo8QPr26bclXwfiJByrXOXVkMGBeKIEV0+d5JWkfPZu\n", - "CfTE4g/TwGk8hy8PIdI+tPw35A8ul4AhhV+0P9fh+YZaN9aXy/iROIh7AAQYjyTi2DXOsF1nHWIY\n", - "NMBQAPQMQ8wMhsRTsESdr74AeASuAAgfojE8HYqoAxgCfAAoGCeGN5NtZCZnELEOyArkjY+6/6X7\n", - "vlbb7DqwFaleV+EZ7uXdxkjG6M2UpWYZjb0jLL8AHQmGnXH59QOAThESHYAehnQmKYxl4P5M3Bws\n", - "spdc5JcKoPGABcEGxI5XVKFfVOUjlA3Mg2GuPm6gCIAAQDsAID4slyrBh/XzBAAFgQooIAAQHwAB\n", - "ABA0VyPA8NGyMN4MGk1P8fiMyAJAAjQmbiwLhRTDyeHtInd7/eGX4c4ACMZwABAIE3udGlcdKn8b\n", - "EIGDC7ggATCNw3nqEpDqs9eANQUaV0f9pAfoS9uKKkgz28OWCAAbSzJDViVzkR/vW/RJtB3sNmwr\n", - "3k+v/5qbkTXNmMhx6Zbk/VlDT7mmQOGYLCJzYlcOCBJn0vc1FsRIgFIwM3LX9oahQQhAMhvpg2Fd\n", - "rUIKSOTf/AFDwiY5Z+HKSOu/+9wxSp2MnCLDShXxgGISUSmRcez3gZehAAFAY08JaQcDQENd4wTd\n", - "bLGoZ4cAmFppu/61dsxIAAAA2GEAouACwAWcgOvC8SIDWAAtsmjLIGjOhwgIMDHRiAHAZF0lvugE\n", - "TaGPye0Kq/fvVAD45akluvgJGrPv0WTWgVsV/+7sQCkM/AAD8UGaJKrJbOou0AS0KiVeESzt/NXq\n", - "sVQo0uLIFIseZ5Y/WxCVDECAAJAhRgQn+jAMvOp6UoELICmBRkY6Qowo3QET8vDL89YAPjRiVEVZ\n", - "+/q/8v4lYmeI7A5jwQrGwiKvpn9DU+GtBoa7BtIMBn2+jsHPOxV/5d54yQgEt4O11vdsvAbAGTpU\n", - "89WbCJLXkgAAAJ1hAL3gAsAFnIDrwvCIg8sWuALP9GOwn+ADoDiZrYUJ7/384QEhuADVEHKIlS03\n", - "wEtoJILKJSqEvASFwIfHsoON8E/veeQJgylU0VKNF7mxMIACM1YufwANiG9Kj9I0x0O8YCuBMrvr\n", - "r/DUI9gw4ZgKgREDdVOKH1L3T/cC5iRzgmHLSPu/+GRcMITMyCCGG/51qhy438/6zFL4TIHUAAAA\n", - "CmHgAwAGHIDrwbwAAABDYQb4AMABhyA68MBzAARmJWZlVmZWVSazS63WazW63eAA4MUwathD7aiy\n", - "TpL+HXAIv/I9X/ABD1ffT7w1CIR4RCKvJAAAANJhA24AMABhyA68LDeZCE1L+EQiERNHpXgEv7V9\n", - "b/AEPXZV9P67DUbGr9CIquAY99yxDuADuwVmtROahwzQGYmHOGURvThQQJHjqIBanaf39/UgAfbz\n", - "kUj3/2AbsQqJxqEXEfv3nzHc0ACvdVxr/z/w8BIrNLz/hZLWaRBjYfcIAgDexgAILAO3YaIFoLNJ\n", - "SkGItcFgPg2+a9WGiF+LmT/8ECUhAgARWIIVv4Hr5pDCgJR94njosGo2AJ5L0f9ieBi1Ru0gXR+Q\n", - "CcPNC6JsAs2j5yQAAAHVYQFHgAwAGHIDrwshMSJDWAC2EcGEk8HiwijSG7WS8BfJBTA/QetQMwsz\n", - "qbrrKsmte/wA2NKOO+ewEzwyiHEbv3f/eC4CfCqXkzRyokTD8PmUMIAHDcGC0Ma62F3d2eyR5DDw\n", - "AEhKjsFWrUuFE8tCExCAAIoE8yXzT4WyaV2BQJyrCIrx5UAjzWDOX6QKKURabzzAMDvA4Q9yFyKq\n", - "jDsTC3Hjh5VEIAAQELYAAICYAFRBPteDswpBlAjejT57vluvMX2+8AcflDjjStmmEIXEkPObrvC8\n", - "IiTzCLVBD8/7aCoNfz84BRnR/0+iA0vvmniIX4ADdGTYnyFR2QP8VSUikoP35Y17IQlIJwYXNMxN\n", - "3Da04WRDnDP+Ejppf8RwX/gAakFAqnHRGJK3zHyBz2GcGeGFGCwgL+D6er2eKAwgAEMaQEAAIDQA\n", - "DgcNhgpQ8kID2cGrw6DNETr7k1dj+CDfgzS9GhqgjGC8AdAdNGrLeQfhavgABASAAEFkAAQLwPcQ\n", - "AtAweXBRJQuIjHg8Pd6AEGOOEhkrKjANtQYIGccQwU2IKGSRMbtf88QlzImC7HAmKV973tb2730/\n", - "QfQgYfhclQP5qUL5e4fOB0QjZBFZzlf/hfKokAAAA01hAbOADAAYcgOvIX/xIZPX+AM+/o7YEmHO\n", - "ACtlgAqnUAAQBwDgAFg6AGWtJ5QBoCDvknIi8IAAwDiVggABArAAEBAAUHeAAbCtQAiw20j997DF\n", - "6+u74BSBJH0gnQC6AYV55OqYEiG/OAABATAAEBOIgACw+TwGhBZ3yrEbLPf1YvREvKYX6veNg+KH\n", - "MAML1/f+7wHhJ4CrbWmMAwf8EDm4QAEd7uAFg/GY4sqcZwACYAJqcApYQcsTMn2cgb/P6R3wERK+\n", - "JbQbN/BsxmDhLxPa7WPVOmuC/AAQQrCjymjHeLll3XF4eqWShAlbm3IP4AxfvjswL8InG/+th/3q\n", - "BwfMv4CClCGc8TbSXf5ReQYOxmwof7cEAUyQyiy6ON//cDYp96Wjb1P3mPOIeAJHrfg+ZOWAnzHQ\n", - "xYq5B0i07/owAAQDQABAFAPG5YaODa2rfgAPhucVPvelpq3kt0AYWUcEIhDRRmRwnP/AllhAAYFk\n", - "zr2+75qABa9fJLtdBmVWb++or+0Vf6n4tm9t3gCAgFi8xD7cZrkZpoXUXEZbJSW/6X5vUP3aZsYq\n", - "QPthwIB6IJGIQ1trLe/4MOAISCC1K5mFE8t3JPtAm3F6gAJIiFfyI3d+oYzwAwagABAvABwYOP/f\n", - "4EAC4nBAACAIBA1mPr3t8fuL5UxJRgDwcpGkItrrPM/PEFrdXDtAd0ed1IPxhF4n/V46hjXteGoC\n", - "2ZWQIJIvrQiy/3g8cA4LRLpEioOMiKpEXhhhAAERiXBAACAoAAUDBmCMMWbH3dqgYmPfjK6PaQQC\n", - "B0q4Brgyyajmcf/hn4wzDkNSYJJjaHDkpdhhwAhCZnODIpIz/0z6nU49rac/42IIGvphrduoEkSS\n", - "I/6GEcsIATHNAxEdkGjm5SL8Bchh2bRYr6xXjTsPwzjz14fc7/nEJbbLKEixUGDVQ2/9eZ+Yfc6l\n", - "KB/ZfmzYgF8vh4h74StAmAYRtTv/94x/gIAaqvj//PF58UOHuGoBuah8KX1Ndw74QEYUG3dbZS0I\n", - "IJt/4N3+XAb+fSfrBHYFAD2YjtCkJ9z/1t/4ACRDEXmPKSSI2kr8MIKNggACIUssZgNgyGI+Tabh\n", - "qe228e3fYgTqCz0gtcyRGDbvp918kAAAAbhhAIfgAwAGHIDrwpCMLcABEhkW+Mq9HiB6ezdNuRL7\n", - "/eApbHldxU1KMR/Bg+6AMfu4Hgyla0M9Ww9MaFbgQBXDWAAWUDTiNUo8x1AUMRNM2G9ZKCGu/wSR\n", - "ooJgAdVmpGEtx3v/YmJEBzAATDKOS8KZZJDn7oqKgb/AAkMYADasaISI22I/QOYQABAFNcEAAIDo\n", - "AAgAAIG5AACOllVa670fdz2VAGxzBDW0PPQsBAo5/iNm8EQlHxWhZ/BoBhe8LWHAB5wGKOgSFyso\n", - "Lnd1bJLDFeIWKbPGBBIoN2vVgACAhQABAUAAoAAQCVWwAOgZBDXBizOk3hwq2eBiPMIAAkCakK2Z\n", - "bFF/fB4enG2MHp7N/eBHEc3UYtDhcMpH5OrwJIcyhkIEQCVa5akbHzsMxIg9xADubVd58ASF7Un9\n", - "WbG8J5Ze/oAPga4RC9mIOAAOlswDNokJHXDQiFRgHOvLzv6hIjDOxwAEEwYKQvvrAZc257pngDoR\n", - "QsH7acs+UfLY37MTqafA2AdtUgi1Xfi2BXMPVxWV+8VgRovRnKH4bkAiQyJ/HIJQAeDJaj66TfVN\n", - "flqP7j+rDgayQAAAAM5hAKLgAwAGHIDrwshIjPSgAiU+QSn6//f/v/8AC+Lo5QZGUwiExEyNtN//\n", - "/7E4g94aIDFYrDQgwwi4/wgCkMwAEAOwgBFRuSsBO/IhzQGFUi4LCqoJzJCnvJrA2IGEAAQDFEA6\n", - "YAEeDD03qCLf8GrLsuGLoXpKVN8rmtMjK7zlABNLKM/a0AES7N2kMiPL/vEHi+gPABO6aKe6f/GA\n", - "9+HouHhEQG+ABHAAJf9QI8S9NgiyGMkMQ+gB39cz8fsDFSByST/MNkG75xw2k9t5IAAAAGNhAL3g\n", - "AwAGHIDrwvCIQVjXEhjYHPMfLz57ZACAACMuypDfywAz+G+FYAFm4pLb5L/GIOJffvDhVU1GEzbQ\n", - "oxprw/e2bY36lV3UMOEUSOIIIR1ZSqhDo2o+/+Nv8E767+9EDqAAAAAKYeADQAacgOvBvAAAAEdh\n", - "BvgA0AGnIDrwwFOTWaXW6zWa3W7/hqERJ5wHf8APUs8hd9++ERIZ0FLQ6GqAP/TtBBbW1Gn+IA3e\n", - "jdgEBtY0PTrYv/35IAAAAW5hA24ANABpyA68Ll/GsSJkC8AAzBUecSYbji2NmgSMAUUejCRMqPdN\n", - "88NGpuZ8fumUhM1ABTc1+kT+8AsR1D+vBuAA8YRnEb1chq6JAEMJ+0h/WAzynPe2P5/t+kgz75p2\n", - "epBHav22fvzhg/QMyzsjd7xoFk2yP5wzEiT1wA1ZT6f1IT3r+ABZ4jyl+xm6vAo15GiZd/+X+Lys\n", - "L8ALEhO8IheP+f8DtaOeKPW74BGyEnKXoJydrwAA0ignhDZ1Sj8FuY0xVGKx06m1/3+bEb1wVZpZ\n", - "dBtrQECOSF8X9RNaoduwwFwKWPCutRoQJKg5Ifr/+fAgDXggVBAFAgEQfoCAARhucdqzy/ePTZVT\n", - "APjSIP6GcylBD0k/A/zjtaeXgID4MpaeOqFALoll38wAQAyQQBsLxENFJFHZNqzl34JYQgDxgSTo\n", - "52j34abow9455x0c89/m/9z3gPZqMpqMeGWLI6A8kYT2rB0iasQjdwkAAAIxYQFHgA0AGnIDrwtE\n", - "iQv4ACIGQYtyTjw0cQY8lbqyAAEA8AAQEpoACQQD3xCcHABEgAbM508vn+nAxjsz/DyjGmWeAAsn\n", - "EI1H2qH1nv9gxqZatCGd7fbxAIiXPUXnsTBhy4z+AA7IETFIYoCkGgkiCGCACKtQQAAgEgDAgyJ9\n", - "1QZJpAcBKQBOFttk8ALafxx0AFK5+HKDU4oMKXBnUyMs+rCAYDVEuI6HGAMXnpX/hcN3AyQ9YAQv\n", - "W+n8XikdNK8XR82XMgvCNe4nm6Z1QXP/AAsZCHpCVQF0U030A5j7ECU894hJfemdEG5J+3//14Dm\n", - "P4IjnmvKEL3gADtHl5YppW17f+d84xxFbLDFOxc10LykrP/3v8nUy8VT0P3tm2Zsxq7uGEAEQS+B\n", - "cgALYQsX1WiLeRCrSvWmOBUBn6ZjAJQa1rzKvTQdQJW1634hWTWm+X1c1iA17cZW0AAIFd1AAEA7\n", - "76ALBGHLeoQsVHP89it4EAJDmCAAEAAA4UTDBcrZEAA4BDR/DQTis/rgMC8BegzuQQkTIEpS14AL\n", - "w3zU/rwOgyKwrHgAEgABALAAEAADMsAEhOAQLSnHAupef2BQ/YEfPJi4yLBIZxyPT3/6GAAIBdsA\n", - "AEAMATAbGgwQABATAAEBWIgACwRG0I5xinceesoZNf/++MMw5DUnCSY2hw5KXYHAPIEAQDoHgTYB\n", - "zqo18RP8zuWPbItB/oDQABEucUD0FRWbrdqEHKPwiOd/T7/JAAAD8mEBs4ANABpyA68nDngAICUg\n", - "CmpUkAt4Sm8KgSBhCBIRwgACwFEscAEPcUMPZBDuAA5kZKuKC+IGLGrmb/xfcEHf4IVltuCSFjAz\n", - "c8LXWPMDVQAwAgyTBNwHDTgN2neEABAAO8BQQAAgGgACDsDAATwH0aGlugASA8zDKCUPgBqSbXwS\n", - "DkLMPRybAAEAG4DQ6ggDFC0hjUDL6m1E8bAgQ5wANEAKZ1AaeIAsCvsBIh7yjiUmB6HRJT/eCAEx\n", - "hQgABAMABwae4APiwNZ4AAhwHq92Q0AB6RjARxajAABAJsC4Te1hXhvgsAFuPZQO3JfW7tfSbghM\n", - "iCpvBtFnEDpzBwLBOF7hFvRWL164awAEGI0s4tg1zqxdZx1aHrBF6PtAXwErdf2/5fEiSqYsLwAX\n", - "Y5KteLf9e4ABDmIHJwJub019Vr//h5NNbkHVwTSHwFqOfKpI6Ce35w0LAagg54vhg+6VPkYSxAAC\n", - "AAC/BBY3Fn1t38NmxfDHHbX9X9WAGJFTNfOqn/3/wkHZSa2L/nrnsO2lWv6PSHl+AE5sAAmepgP/\n", - "ZPy+QokUUwMIf8ICzYkBTJcPgy//2zkbSNqL1yDIE1oWQoQuRdWj+kABuABI6Q9k4P/mwPwJ3TkA\n", - "AIBgB43TQg8ACKJMAAQKVSo4AAgbgACAvUBMMOEACqUIACBGm2g1XLDj0tNB2bApDDt2F95hQJjd\n", - "193gtEyxvzgPQTAAsX8hZwopEgq14BMOw5S/Xx+GvwBCsUO50+e0kMZD8gCLDCJoYQACM90GXkOK\n", - "NrVT/CGyoCmeUDVCxWfmhEP/oNfAioUFHrBKqvyZrOWvvEEUISQFssbTeGi3l8GHPWq4c/s/4QCA\n", - "MkOCAAPAACCKOAI3FXAYB2Bjv//IYomAQEAZ62v/QalVcoASbAAQfA6cP/QEAhSWAaCYN9ttf8/G\n", - "l/E/DUAWH4wOJYJSc0wi2EQQzxq8IJWKEAAVBDTEBhAjSIAXSR4fgSx+WgyqUAUkIOn7+KIGYEiI\n", - "YY0XFauO6V/vg7H7CCzMEJjWlIgsQJjnHP/Rg1cKl5uvJOf9sTiAQQQTgDB42iRulKh49/ffiADA\n", - "UI7h1LsWFHxJu8PAATBo4ybxvciTGm8BsM3UataGOKSb/+oxhjCKwwxUoPlxItl6ABcNpqthRJ10\n", - "a86P/lsgwXN8nSUIe4cQIYj09S//JfNBBEzw70hLLu5P9N++78AFXYSsLCE8f/v9ACbr6+33NNkF\n", - "OKliEj7kADot6hDhXUo8tdkRdWsebF/ACAcwBKVf5AqtsxXs0asW9Wn7rg9oCxbiGrlPZeu9card\n", - "Tt627OD5hwAEBlDmmoRvefhy/L+beveSAAAB32EAh+ADQAacgOvCjnCJlwqJEHiOIjiAKhvWoi+h\n", - "POR9f/rwBUD/HZF9ydUdQLsf/i/eLEBeAMjXd7/D8ABIZTCI95KXGMa9nwYRxouMJFGyFYwCLQAJ\n", - "XEAGuQAg0bzmjOYAxQPtVF8CwQAEOW4IAAQEwAMBAmAPmFCIJfVc/+cSYy8AY9AeYASwkj2zi0AG\n", - "bPfEef/YCshVS5wAhJYAD9AQEmhIW0AixGboAAQDrAABAVAAqIAAgDdoCRQ4kmiSWRFMzTKv9YBB\n", - "RBPQpDiT68NtWvrDMOccGlRBOwGD0btBRO4QABEOKYBhiWooui+MiW93MA6javgSq0IKiUont2ls\n", - "BLMO2nQoBR9KcYWNgSRvqX8YtvHDLExIRDnABYDClGlgaL56anJz++/v4AlSpuf80BX8md1fXwAs\n", - "GCE3aoQl/3YBMQHWRTmGnYpvDUBfAPaqBHiicmCLDgBgD3ANDUEkuMgvjVTdwYYQAIjVBAACAQAO\n", - "HGwNDeJpubQPYDqFLt8Xt8AdsAHmp8ywjQZCgEesAKKguUd82kN7cD8LfMwAYcTEShoh+OJH4s7h\n", - "h5p4RBNggAC4FFt5wDjEyAzCCMusCQQNlarZJZ+Zn0bx//+0nBhyQ1WKIRSuWrg8YfckAAABQ2EA\n", - "ouADQAacgOvC0TPygCr30dv4T7t//gBYaRvNl7+vGRJFS1z/sSIiAxwBAOD0VJRoF9YAoDIG5mgs\n", - "vUoWUtt/vLYf50NCmI/d7wg5+cPgCAEkvnGR7nOHTTemMggfL+GAdhAFeH40bwAdBlEKckSrlBxJ\n", - "VdDMAAEBEAAQFAAPBJMTABlIiA2SZApOLR27AAEA7XsAAIA4AqY+6RgAEQcskrb8I5TBCBzK+UCB\n", - "s4yVDCR+BAECd4AddQ/sY+GINYxZ7wmPJe+QABEtiFOEdqzw0N3PAFmy2gFfSgvEWpPA98LD/XBo\n", - "vog4bhEIBmBIBgQpLaLHxSNKJq9/7gecgFriQukIzsx//gc6NPVP/qZNM7vIcgaZsGmrVS5le/B+\n", - "UaRw+g+cXoIgiz/k4q8v1ss9cAfI2Ed7m7d88UC6XpS/9/8kAAAAKmEAveADQAacgOvC8IhDXEnh\n", - "51goALE7xp/LJ/68coix+/HDiH/OGCBVgAAAAAph4AOABxyA68G8AAAASWEG+ADgAccgOvBlDIk9\n", - "eEjmzeAMxm+RlBGGob4ACBMdoDAdN+JAZe5PIQxGQqTAcAlR9HLMMGUoDmZcBTCpeRXMhd7mgkin\n", - "+EgAAAD9YQNuADgAccgOvC8IhHL+VBAsIBuQMIALeAFARp4AnoKFBue/UDTFJOaFdievIlZrhqQg\n", - "LKUfY4AXWPdMrXxzPGlKyABUg9HPYTpAmmLqDYRDMSJPSrAGF6rv//x3d2/+8AFxmQk/X7f//+Be\n", - "QbkWIqRP+xMEmYEMMote+hALBwQDviugAmVCxBIQpHhcqAF4sVuAAQACZykAofu8ALDOKS1Z5qyR\n", - "qK66IYfAA0E3ILNoMKLCirfwMD8AZkQFZMXqB6WrCIIMIAJlOBfC+nixZ/3AdenxRf/3QCmokFch\n", - "2OQxSnhuQDFUWy+NtQGUbQJJLr3f/44/7RkxfBBSQAAAAehhAUeADgAccgOvC0SJP9AkbkDhsHIt\n", - "53pf4AKrNNGQ2797ihg/3cyTDp5Xhy+J/FByAAkmjJDTqR2VV43LV4ZzikvWeessemyun4RQVDWL\n", - "Cgou42xFMHqEASnIEAAfAYcRfd5Zw/MO3xwDGzaQBByV/0i5GBJR4fvzrr439CpnIJb735PCbKJy\n", - "XgJmLMJficIBjDfAAcJjqAKGTR+iD0h2ImeDwMgpx4XHB4ofJlmvgpNtgYG0NM3xY/MOn6OALkoc\n", - "kZDri5+oLwjXuJ8RPExQEjK0ee1Pcvz2C2CV68JFT0oBDO8/kd935f2E/DUG/gIgDL5BQCPrn8FZ\n", - "eKJBp6nCSeQLBMcEATmF8DPBbha7TXFaSHx0qm9H9/GITRv9CVu+BAvf3AkfNlQ6QZEQr4+UAF+E\n", - "LwJMeFXtBh2BJLurOgxUKdfbwNjoYAQ8zPEG33QvL4brw+AciIskwj7QIiF4AZAnFEgrpOsCzAHY\n", - "ybxCoHlHSH+UPxJqe8OHC1Yi8kcbNClqzrQXpoAIB0MQGFnAYAAQHUAAOEAAcAAECoUBjQykYvAy\n", - "1FmBkbmCYEYRQIjhUwmXP5U11/agszJMbjQEAN4JNWCdGaD8a1/hqQBwckG24ikMyIgoAkstGc9m\n", - "AKmGmSpfSb/xIAAABBJhAbOADgAccgOvI8GEMeABxgAG0cAEBATdyLjIhvfgBkQABARAAEBKJkAC\n", - "Q8MJaAwADRMAJdKZ5I4ZwxmiMvYAEuE25RfURzX1RWD+4h5fq9L/wQgQYb/gDEAAICQAAgJzEAAU\n", - "HyANCJGeKHReevwPHZ4Mh5cIKLj+M4c8AF4ABo4AICAm9kWGRG4YQiZlwAxlTPSOcACXE2pRfURz\n", - "X4ERhiA8ycsDzJy3JIAJiiAZNTU4Bp33AAMoAclKmgwRm+oSU2YRN7j/AhIMlSHlDBOW2UGE8AAA\n", - "RLYQAAgGAEBpEIAAQOQFABDmCyquIlwL6HFC5wE442FohJoVDJV++YdDVDrBSYjdYMZtIjhlhOig\n", - "ZaF3q84mfxiKeAFFKfTb3zADI99SfAK0CF+olXJ+ZRL4kTxEQGpgfzhY6F4EAtw4InYvrPZ+4Hqb\n", - "AQaZj/BAMGesUQbHQLdywAB1t8U3WAAQGIcNVx/7Sy6TRP7QILQEDdTSAX8Lr7SstAAmqyAB4wA4\n", - "g8O1MXzIsAASBfC0C68jmgkrjQeWlgANwHmJGgpPm48AYc+z7VigzIS6KmQmQCYkSjtyAMAMVdFg\n", - "Ao5wc/7xBMxjMIiuUhHZ0GAAe4hANkgS0JTf/8MIAAuyhAgAIgEpSRRJWiV7/XbVxDKPR5WgG4Xp\n", - "CkLyxyCXKjAsJ4PB+JbBVLhFOHwetoAFBAO7XkGivYsSO69GoELTC2PCHxy/v4VwDRAR9SUHqFRK\n", - "9OsSw+EKWeiTM0haf/70CCJN1GQPINptGR4MMNuBw1gx+18M1Ltmp//zmyaG3QqM9JrBKb4nsD+a\n", - "EQCP+g1DAFBnCEMSeJ2kQQZZShmALR5YAOsMJB54V0RTM0ij/X4QCIlgQAB4AccXjp0afvgcTQ85\n", - "mAyDn/aJagvLItLBwLYBkOBGnBbod/Of43hrANEBH1JQeoVEr06xLDIgFxi+vjt/zmyaG3QqM8Ow\n", - "cR0Kw+GBhSzySxt+VFLKGP+DGbA+MAAQAQAXD0ODRIj0tIIxN5+K7Mew/CAAIgKSNCACCMMv4pgF\n", - "QAgkXRf7WZZnmA+cXd/02PoVQpgK/u1ZgN1tFW2uwf+/2uJP5xHeMrX7/tc7fvT9G2BVkWxZ2jff\n", - "v7EoWUP4ACRewgWbqt5mEw8ADwQ+27JLkY3yz//4AobiHK0T/MlJJVddiEisRiFF5J//9/CpsXvp\n", - "4LJ45Fx6jasTOuG/uV6RUBomBPL8uLgmON+ABgWRk7JHZLViLyLCwMMABsmaMyjEQ6twagCHDJUT\n", - "W7l1PFv/B7Us3oLKuACwryOQ8qb2zzXNJp4m8jQlIWkOTBgoahFBIEAAVUH8FcfqryIybUMf2N/X\n", - "7MdrRjfeB8oEBEVkuKYJy+nqqJIEyBkEOf8CAQZIAAACoWEAh+ADgAccgOvCjlGmC/AAmp8tq+//\n", - "uACDCdZi8nFQyhBJX8/HrOD/fBP+DpwIRrOEI3aAaitrTp37sUokhZEn/BR2MAC2LR7drV2f/oPA\n", - "J2fJX3fuUtYdh6nhb4ASLAPc2ZRkHv/77/ABAQupZQojJ4mxeiYb41T88CxNrIuwqR/zB5bOvpv7\n", - "/eu74fIz8BvgAVSXvib15afl/S9ePwAOot76iPditnywy8jvn/+YkQHMADUfmGQ822FP3QBeACBR\n", - "Gsy6QNvHbxWC7ggExhQeACWzaS1u/c1oUz8AKvCsC32lOJvQHUF4ADoMTBuLiVXej1a6soQJgvD+\n", - "o6+vgiiIBqajN2B78EiOa7wmAcolg8wwOPMK3853r3YAAgF/dSgACAHYAAhy3+sQ2CmT8Fw6Tc+M\n", - "AAEA0AAQBQDxmWABww6VEiU1UPMKf88wYAASBzCZb1aGyOnVlR1AzwQgSD9QBzHzzjijCZEG+ZPF\n", - "X3V+LeNW29AHwDoZHm5xwNQg9VNU+tSgSL/kGExCYelE+Jov4GcQeXngJG+r3Q0BlSpO353ABRRt\n", - "MyEvfvAL4wb6qYJgmfVL+gy+GoACIEcISxRpGnhCKSauhC2LYnYR8RclFHH9uEIPCOgW2IoYOSFv\n", - "gQwgATHIEAAIAgBwoqP1yTQ6mDkLO+bz6q/OGAJ3fiS+32YMZZmGtAZEVSXUqkQDSC3//zp9wz1Q\n", - "QC0QHYMEArDFk40MjmJ4qfJF7oMhD0hKoC6Kab6MAAEBEAAQFQANBGW8YM4pLVmmrJGoqqo8rDrE\n", - "CU814pBfeZxQ1zKUkY5fgAIwZDhi3jl8JFWH3GAw24UGheMo8eQ04tqzHrRBFmJw39/PG+67oDfE\n", - "aIxKQsUylSoDHbkEmicp9Om3d/YM2SAAAAE2YQCi4AOABxyA68LRIg9OgCH3d//7/f9/9/4ALyMx\n", - "LlT6f//+kkExGREk+7/xMOTegHKCGPCCgB0MXpfHxxw9OQ/If9+gwEv6pcYK2m4rDAKRvQDAAQil\n", - "GKYk81JAxBVdLMAAEBEAAQFAALBCWAHoGIeeFbPlj5IsbtAAQAADc2wA4o4IxJ2y4GYZif4ACIah\n", - "VKS0QWCKGjYuI/EEUQlijTlkjEVF0QxEsIAEjiJbjQkv4jC4BV9CzSV71ktvYpJf/71zPPiLPLnI\n", - "xqdmRRTBuLHgBW3D5OEev1M2ZoXrJ7qDRf/iD5KAR60uP3+z+7f/5fEgoCOIoLYALI4x54d0+YEU\n", - "iY3agiYAMHAMivELFmxQbr/8YH5gOh1AUDHsrtr/74aU5C0wNQwfTkbghfcI/3FCCTzkgAAAAH1h\n", - "AL3gA4AHHIDrwuJ83/wMCw7gAOIWkwjTVJWdw5//vCGdBlJami0GKJ/3BHDuIcbO6/Qp4z+5RBbG\n", - "qlpKcveACKE9TuNERp96pA7bWwlKJKGrcCAAQCOCQM5MOABeUxpoQLNwY4DWH6ZQEQhByAv9Ag1Y\n", - "9EMeANX3kigFWAAAAAph4APAB5yA68G8AAAAEmEG+ADwAecgOvBmPev4Im9mSAAAAOJhA24APAB5\n", - "yA68Ll9RYRGjxJg3sDgEn+g/Z/kDKfwIieIZVbUV4Zf8QCgMBALR4q+AbHAB5gxx8nACYhwrMm6x\n", - "xLxrAsJAA4ZzKM/zgYJNNNMJXQbhQCYwBqJNzTCZlz/8HqwbHGaQtwvy3TwzCIk9A+P8CF6DAud9\n", - "0Xu7ZZ/HYe5wm99K8QM4CF6/bw396/gP6Nw9AARhHFclDykuNYQSoYQ2EWO5AY+0D3Df17gQAMAJ\n", - "BzCoUlB/R38f4r/zwhykKHMOoeKx8Wa5iAACF+RKaMvx71p7i7/wlb33zkNhoPkgAAACGGEBR4AP\n", - "AB5yA68LQiJPFsCmgCV7R6bz4BX3HzlAk4kMRfKhRoX/4cwAL0QAICyTLgG1Bx8I6MHeEGBhfsuf\n", - "LABTqdDYBnjsIARELDHJsAcVf95gFmhOkjgp0XHulV7L+Dyz2GUAJ1rIs3a4sAYUQzTKBoXpqlRY\n", - "gMjYADgDQPAlO+CsquOlAY//2lCyr1MIf59d/8PQaGyDrAguQAAICIAAguAACBeyACWGDStMhi5c\n", - "9EkIpcLAAEStjTQPhGiC4H2sCpaEb8GgY8AAQEaAAILQAAgWxIAXcAHAU0yQDgwVmL/+4JAYGDgg\n", - "ABAGAAEB4Eg+AHZDdsppwaDCn/i0L+GCuU4rxAHARQt67bU4xcJ1uxVcH/rXGAyAg6MEkmB4pWlg\n", - "BCIOeX5BgLGu2C8I1Kn/EeIDXwE0KAQoE2CEKbFejT//7/AACC+IBXCyFWXmQusIFlb5FHlsjE/7\n", - "b/8mjDZTMcb04XBCxIkK4+AAWoAgOgAqGfjQEHNcg4D7gZ+gMjgZ3F1waMGPIhkpuIgpYpE9+4Ax\n", - "XX0hKUU0pk6AACBD7gA3JgGhHgzr/WwHRn+8MbaIwAusLRKgq5SofIMZFgkqI6eQYr0tsIQAAgWj\n", - "AC+BAACDkMAAIDGNWDrNgizjRRNttPgECT/8F8ZcWf7CfLl4bg+MCChjCr5MXXGZEQixm4jgBqgT\n", - "DjwY/4Os4wu3m+UbqYS33uSAAAACpGEBs4APAB5yA68hf/ghDHgAuAAJ2ABQSEnUq8zInPwBhQAB\n", - "ARsgAAgtAACBXecBgegQCCINwAwC9KbHBw4amMUU09gATQ38IJiydYzE4AMnAQweVi4W9sCRjYKI\n", - "c6AQADgC3OAENafQaBK1rwk/BKTCAAIhCCeACzQn+uL2b/twAHoGIuLw5JY+pByuDkN/QaDuCCXE\n", - "MmqLA+Mb+8ICQpfgcwl60bWnFG3/v149Pz5f8CjzzCFJngTX2e4sAK/IxkIVde9RM8WgZPGoERvy\n", - "FD8rNrsAAt8iRj6MAQPOa7Uudn1iYfw2v8P2MAEL+AAICYAAgJRMgAWHvrsbsAJF+AAIIYAAgKSD\n", - "ATd32CFiIAAhByuMebPFHRMeewmFcKlxDTfV4KgO4nNJYVVevFQQWHPJWKAKDgAVavEJNvDmpPfI\n", - "DDON4ASDKPL8Ry4HIMSN//BhAAEVGwIAAQDggE/YJID2ABWYEPNXRaj0sAkKubAWIBAACAqqd8B4\n", - "aIE1b5LpEYl2iwBaGuP8dwhhvwR7T9L5Vk1r358MLgvDkLNe+fHcNfkACAjOEwGf40cenyLSGBmY\n", - "QABIKUTA2u4mSbVv7MwMC7Siwrpt7/1f4Ngz8AIMDkMkRFNRSiSnSsVnUMOEAnKUJbeG2Yyi2sXd\n", - "df5/5nPYbvVe/8vgUf56EtuBq5z/g99tjqqZ/1zxSBry0ndmdr863fgk7TtNoaRJUmjJJPv+X2Cg\n", - "TQhT0LzTfL+GRoIAsBIle6eP/ehtcV6DBfzNsOqowR4f8Q5fXYgdCvQ6BIHrKs/fw+YNf/75/4H1\n", - "k/8ADFQpRkFXo2DLzf5hsIA4kCAAOuAdeMwvxTWrRzuunI+Hyv7ny1K+ph8JAAQACGXrw40UdXPs\n", - "7e5AtcBFCFnn/pb+QZIAAAIJYQCH4APAB5yA68KPCNYv+IPEdCOgGPRgX6l3f4TcegbgEA6rgPuV\n", - "rT/8r6x0WVzw54AFTAIw0YoK15YJ6LvQTJhATlI//WvH6f7/n3j+BMzFKsn8RnB24AA7CMgVaDlr\n", - "McSs+X4jiRAfDEuAAII4ixuLnms2E1KyCWEAAVsoAgPgAmOeZhgARGyUEWAVX0PS4SiAACEGAAIM\n", - "1AAEkBI94AAgE0AQGISePyQMMIAAwAIeEhAACA+AAIFYBAEhq1SRzkBK5WDrMOOCG63JC5xd9XgA\n", - "jNdZf+02dc5uIGFBKyTxMaVFZSRidgsyEUKSe4KgYW8wZ54tQGXfAE1ci03HgJBWs/DlAkouOVdK\n", - "pR4XEBqOpj0BgoEopVx4wAYR4OFAHvgwYI8MiUWMCAx5Prz+NCACKxsDdCUtRgcROOfv7/YfB4cQ\n", - "tjK7JwZkwgUBgx0IC8SNl0YXgqQAK08RokfKJZdSJoAAEgGuC6NUtSCi/Rf+9roOAACAl5EkmAAl\n", - "Mhv/AcCwoQ4ZtOvi/Hv/8AALxAPhYtpSz2O+Af00HIOpJJTSBK5gGyHuz5SK6LD0AH2ARC4t4BKO\n", - "lQxu8GOQRX2NLUjZ1Fg14YQAAgFAAdDwgACJitlXoyDJXE3tAAKK/IZ+QEMOHoMj3bS/sseD5fB1\n", - "8Kt/7aEuDSRXP/GhsrkcF/rh6Of/ZrBQpJIAAAE7YQCi4APAB5yA68LQiIPQMz8M2IF7dXZ+69/x\n", - "AawAGZgjJxS0kCNJqoP4AMAhODjZAvXCNnKpIr4YA19cfP1RcAUvxLiQUCgIA2HDAAdBg8qTAUsX\n", - "OxKHi+yAABARAAEFoAAQK2QAu4AOA5pwAiIYKzF//UOANgABAQ3AAEBMADg/ce/AEjnEIcFMr7QI\n", - "DpRy7DCBzmCAAJDuDwBSOwi9By2NsaNFcQngO9xI32qJNxkfkP+4xN3fiIzWxncQ3MIg4kv3HAsW\n", - "zpZAzDWSSUrdrVAzkM4Yt2XhIGliRB6AjRw0nS4AbNqbK7+qXwgD0IRIjCuFFlmRyFag8AGAACA4\n", - "DIlIxAyN7e8NQvyuoP8vnwBQhMhAl8kQl7yWBA6RVbelj7/e8CXQBEHWWeYor5eDwYANBORqia3j\n", - "L7yQAAAAFGEAveADwAecgOvDAR6+Cd/Z/AqwAAAACmHgBAAIHIDrwbwAAAANYQb4AQACByA68GZ3\n", - "kgAAAVRhA24AQACByA68LifYREhAEAfgAIanCprMW1PIZiAwYCAAQzMcK9ZxyCx6CqyHw+QXQM9j\n", - "OKgcFmCQL8wAAQEAAIAAID4AzCYyxgiD4QjCOCAALAYDRcADuR5GHEMNuv/AjBchtMCNGvI1/D98\n", - "9AAOQhZSDXBFfwJiOXCZe+dgcKBBc/hFgcHrTX9NALpV3s+BmEeoR1gUzfucDMAAV+AEVgABASAA\n", - "EBWYgACgRHe8gALbAOODnAIkzQPkaHAAKtMJKfEhTUv3iGcI7LWa8ormvV4Yi3seijoW1cAo/4AM\n", - "dZKsgwRYhjDeypgABsAw9KW0WGEg88K2IpmaJZ/oPwgACgGAmwRAwABAQABpiFkRn14KihEQ4o/l\n", - "V4DZAcG2RLXcFpfdSTQ85iARBwGo9xEPLlRXmsyAEUFGpkC0QWT+YFwnR0HI8tRyhgGQ4EacFvgn\n", - "+cJAAAACIGEBR4AQACByA68LQjX7UEIkSGMmTAeAjAAEBOwAAQWgABArtYYIAggyDmHhZUQUMRg9\n", - "m7QQATisCAAEAMAQOLt4AVJbAp8DgEHCiUsErQzUBnDAGLCgmlwgf+oIBoMChsACxn4jMODCj0Mr\n", - "dv7UAXFER0lvhy5q/77oEGMsYACNCVZ+m+RbAZDwADQDgACA2AJywAOowDhocAKJdIwMiv5gAAgH\n", - "gACAkABYcluADwFEb21tbD/GeOPAFDgAHL7Dx7LgrMs0FXgjD2X1LewYRq2eMIAA0QA4JVNpKGVB\n", - "OYIksolAgICvEBQE44AFoIJNb2s3v/kDO8wWd0BGav+Aka1hBV6W7NvKQRVbONdstAYC6ygbUZjv\n", - "4BRpUXh0bOKKMkLn+ERJ5CQhDhk/Iy2vT4ZQyLEjs0Jf6hnPBSsrGhagHgA0qtPq+/39Vn8BeynE\n", - "9W8tipc18xriQ7ABwGYZoR8kfP6SF8nA8FLzAE4AAgFBJAgObyjKepJlpv8GNgYXSg+DXHmUCkLj\n", - "VwMCYeaCHTJHoSICCwEf/5AAAQEQABAWAA2AeowI4wlkpmIioZpEzXEAACAiAAILQAAgWMuLwA6C\n", - "mwbAAiAYKC7+GLBB4OAAbB0EAEAAQJEABWGHzeB85hrxh/9hQ7W9RARHh/aUa8jRLmnF5+GAIARA\n", - "JhAIbpcyiFUMeWBqGxgnHl+j/vmFxQ3uVSr97DK2MLURaF/95IAAAANiYQGzgBAAIHIDryF/+CEM\n", - "eABsm+AAEAIAAQCaqwAGA/8zwABErgDAAAICYAAgJxEAAWHyBAEdJAQAB0ACDBHADvNkJXTPB8SK\n", - "Fk8gNYAOYPUIos0g71eGIAQr3AQGGbXzTf+HdId/gAIZKACIWgSqqRH+CYExp/ZdxC8CUK+EaKk9\n", - "HNBCbpjCxuEqPrggEGQeEAAeAAEAMePYOH0MhRbUo4BTUbdABcBj39gZMEZEvCUXjXCJUAlkiBhF\n", - "M3wC+A6TP4bFwx4ADjCSaeRRyhuZwGGfpr0AqAAIAzaDOc0FPETkBXf9wBCob3wPWgn5N4Z/8EAI\n", - "ZRYQEpSYADx7Ql7I5cxoDDHgEZeKnkwJWs+/oCsiHiiygVBE+/7MwxZ7AgaSyQ5NSJwf3P6dLgOE\n", - "5HTAhMkEAAjuZmAsOlb/X4GkCsuyB6DhnhEoPwSo9eA5Pmo4A+AOhuSbnChGr6icOcMINzvAs0Pn\n", - "Y+L+ad5MAVzXZ+HKtQrx20/Tl+IwhEQxwAwUAAICYAAgKxAAFh9y++wMACfN0wABAMANFUaF/A0E\n", - "DicIAAwUD9wBQGzIzLngdg5fWGU/f/L4AOi/onvKYWp/ATQGBtzsPgFwInH+OoWwrgDBuwxDRaag\n", - "ii29MCmGYAAICIAAgKAAaAAIBMsAuGI0o1QkiNq/Ly9n+wwhBKQIAAoAcwLFXRxH5CSMwEgZ3t/g\n", - "4JWHQ0rXkHO6hXApEuAtMfV+HNOIt/6DUPzIADA4RvDPN5LeOhIlh+MAJIHEi+1MuVTTrdz9sN/S\n", - "j+033lvDDCCLzQgAC4AQ8EdonGQ8pFK1YBHICrFoqvB/xiKK5KiTllDfLL4HXcwJeyAwkHGh4Pxs\n", - "MQr8CDmXYY+J602Oqzw//0PwAQKDFMtqhKeG9kXOtc/FBMcpAAv1CAkNrG4YYSPuEAAVMCqyivkO\n", - "xxFu3/USbh/jyvXt/gonkHnNymHctEO8AOvPAAJwUAj4djRUgZ4IBBjT81otFEyTZ/v/QgJiGX76\n", - "/nkDTTfxEEM5HFCNJEPMMBh/PfEGrouo8DkAqJ/ryjrr31vl8RExMTCsATKYchaTBJUZQ4clLsMP\n", - "YwC+EGLXl/rLn7OhBrUIAAmgfDBoW3vpiTQPlK/pcLhA6fU7nC6tpzQ+KTMMptBmnnH7/JAAAAHz\n", - "YQCH4AQACByA68KQEiXNz82H6DfAAcCEJpMBSsEk6Eqi/vAEzqA+3/U4Z5hk/IAAWFC+qFFJTFxP\n", - "jgCCN2pENySisl0r7UkGFEAUJEKgAVDrGk7vkHHTBhYAjGBMkyXfYbXroQaBFR+E4viP+c+LCNYQ\n", - "rBjPMhaShghjNYsB9VzB5lUTf8Uhc0HYACBKQBzUqWAW8ITeFgJgw+CFZbbgkhYwM1Ni0g8AIVBR\n", - "FWEwsSLJDqu7wEeAOsagLKsM0K3i24P4DGPGrcJJOKrMDBNk04ZAMK05wUa1AUrYrf8EAAIBgMDU\n", - "wgABBpAAEAEAAQEhwrkMfaAPRpZ4ABMBiUPcCRnkJFOQCo2BH4d5XUBgBhGpp3SACWQTadvugY3T\n", - "qRe2CS4e/DOIPCawg/zgC3VFD8E4EiuG1OCxIeLHh3q7VAoEBCGsBgAAgHwAAQWgABArJKALMg8G\n", - "CSpUQUMRg9t9BAAIy1BAACAIAOFFcAJ0UwJewONzvt2KcQXIBlKYArsLAcMXTDFS5fCwRhEIhgwS\n", - "CsvDR4gA1xTADIIAnZvizws442DGiXw98cozMDh8B4AhkQoZDpgqBOvz1igGOuZ5eMUf//cGCRBA\n", - "CUpdXbJEmjQCf//AKB3a9p1bZJz8DPlN4yYV6aiNJPXjnVx13nTmDPfkgAAAARlhAKLgBAAIHIDr\n", - "wsEetAuCV4d5XwiIPAR+Hk/kAWAGFiNZo/vr/y/EBASMCJI2NA/8GAAjCOOQ1BogkNocOCh2YM4P\n", - "ZVlEA8RIHHRoIRgDSghJhbC2Hq904EoMFlwUSWKiMAx4PG94Yd4GAAKlYAPqaJN/Is1mhKRBEW7C\n", - "5H9cADh9BOW+1MOQ/+htX+4TSYcCU3/+WEO7CM1A/hFbfg0IXYRCEMhbJgABAPAAkgACA8AL/t4A\n", - "nCHKAGMNEWXH/gTohf8dHABbzoAQFSJIYQBIBCggABADAUASPgC3I2J1BlhRNn+8wn2bnvBpY2Fp\n", - "rFJ30GBIBFKCIPFeC6oXwW5Of14QIZEWgh2++CDOLAhstswZMub6T7z9EgAAABNhAL3gBAAIHIDr\n", - "wxz18EGtn8CrAAAACmHgBEAInIDrwbwAAABEYQb4ARACJyA68GZv/D0YLuAA6QADAA5tOH8mDmgw\n", - "XA1//Wpmo56R+/QQCxHCAExj8AHDiqRBvKbTgAug47mYMkQj4JAAAAFMYQNuAEQAicgOvDCCIlAg\n", - "GwAENzhU5WLWnkMxHBALhQhEK7bP+GlqJDBr9wABB+tT0A+gCcC9k5vIBY3pAAQ6GAp/j3R5GrWk\n", - "iMKyO/3kQAIGZtpOABIGM98xZhDAAsioUzmtQqz9+juVSJ7//DCWjBal39FRiRe+ahhwgADQCDGA\n", - "gAD4AAgxngACBKACQHfhDJDulxM/rQ4g+0MMpieVUMP65wVS9/1sAC3gACAoyKAHWAuIG1QoNRpw\n", - "EQrjAc2IsrLh2AXs+o20k//8Us9KPHzgyP6/wRfsYREniWQ/uBGZiNwnW1U4EIpiO/1iPd73phLT\n", - "8SGOAAgGMt03Ig7L7y81znsIPQGNXUL0yBOzjK30QjIMpDEloLHv/54YC1BWfroAdgkQHthXpP2X\n", - "P3DaRAxcq0opCS8RXf9Dar3Ct26KV/2R+ECTEX8e+xIAAAIOYQFHgBEAInIDrwtCIk8AkMSbgBur\n", - "q01+dkUAH1CK3/R/35JffPfL/zRIX8AD0GIecGQyfLnihdr6BpUHg0yTwDoBksNXvXwMnBCQI6Y5\n", - "akDNv+vP+8DOacYrioyqRjHJFk/bjJGG+ITKdUYPhGIR6PINQSI6mpL/hAIBAKB/ceAAICAAAgKg\n", - "AYCcsADoEcYlyjTFljE1l0w/AQOnyBSq+tJ/Q0wnGgpwSB7gBcT64u5Ugg/iFaWADApptwQV1I7v\n", - "/nPlgYQQBLxAJAAJjy3G28eNuH9OrCSuvr/QVTj2CCKbPrqCEfcOLMS3wdGgh7rY+MP7Ab4asIi0\n", - "qIZx/wYhmecReABD9b5fnTnmmOt0vKL634Af3TcT6tG/Z4bs7jtzGL23/OeAiU/ADwBTC5ExD4m/\n", - "/BXh2fHheU2QO+AAXoTljGf570AoDCuQm2nWNDmJMVk/FmPp+ADVi38vk/5DwALsxaRV3+j6YHmZ\n", - "AIRh0GoACwgK+4KDlCYnemWI/QAAgA4wCyYd6pcDNVD9mAATOADnhg5MvXpHNMPN3z1CQUvv7xsA\n", - "EHMsDaUoyEjFGbgg4QIEokk1xDniVc/vDLAARC0iFH/j/BOweBhAAFQBzQWEAAIEAAAggAFALAwg\n", - "nj+dqAE71MskGSWjiV/zxJpeKWBOPQYhQr32E6ALv9zIFWTuA2LQx3nC0V/XfItSyQAAAklhAbOA\n", - "EQAicgOvIX/4IQ34AHNLsAAQAwABAIm6AAaD14ARCBKxMAPYozkLj8AHYLwdJBjz/V6c3fPG9Khp\n", - "v/9MO+AA5gWHZIU2O9Q4UCwSf/vgdAfhDXtsFN4VXFazAANnABgQE3sy4yI3AMAAWoOEGvMACxsS\n", - "ixfKSPm04/4EZBrw1kus54+wALQ1TXyL5kcA6wkSnO5ATFk4IYboGjBElokvLP/+50YubjHu+r/X\n", - "769yP8fhH9YtuGp/+kHkXPwAtUvbKf/f9ROeASASRWAdbFEaxp4BvPVn/ygNwAVdMKJG+yBagMJd\n", - "LpMo/68HiBAYvAJAABAQAAEBOZAA4E7Oru1WAJOmAGAarkEkjwCsMAGWvxaQVGX+qi/EvBAAQd5g\n", - "QAAgIgACAMBQRDgBUMqKvXU/AfD6UDcN1Irs8DAbYAPSAHaOY5Dk+rwCwQojUP2BHM0S3i7EdQQZ\n", - "6df/I6+x5+NhCGuhAGOBaqSlzwbpLghfH94G0ANQY0fPkAmqIR49Dx4YQAmOYIAA8AUcR6gTumA4\n", - "L6BFa/wHgpgErAAmghYiG8rv+GfghrvynJ+uT/9gYcgBFEm1q3N/7qoSITEI8//qnSfn9o7d+JGJ\n", - "lvf/l/6iA5x8Hl4FwdQN537ji8AF0HDLRa6M/97oOle7fNv++f4aS0qFxAkKwzNrr1f+ZwwVojsS\n", - "r6jIZIe8M9KZ6ABA1hMUW1W1oEhr7ywwgRPUEAAYACiDKK4o52rxrlCqEdHgfw9IC5px/P9bANEU\n", - "CGNMAwiHVh/ARIAAAAJrYQCH4ARACJyA68KwqhvAAfhECycmI4nUo+4AICE61zhckCriMFf3wEZJ\n", - "CMuwuv9f+D3LZ0BQ5Wd4QziCyEiHcVo/HK3h+BBF/7kKLihvlb5DDhiaaABbCjHvRHPMR/7TNRDV\n", - "pfEr/+Am5kOTzqivTa9m3mfkMeK0H9BgnaX+b6iXAG7Oq/0+CXdCWHOAAgM4YSlTWWUkuJrZTTjd\n", - "0z4ALWInVUWLf/P/Y0GgsAiA1HnvsoREMMQA8w8pHR5eBH5mNarrf/eAfwAAgH9PlAAEAYAmo4d7\n", - "DIA6Vi2hr5q/ktJPAMswrfsWncv6AFg2KEJWIRtx3yKnOiAWAAEAmSAsdk7CZbRvvBbBeaF4kxAF\n", - "r3T8BYEIJDhAAFgAokgHAC2RHkF/X1wHH+7VKF5CCASP6R/1bJ15YBIo5ZHY0bqHj7SDOBHccTDQ\n", - "MJtk3/gzzzEMK1zR+QX8jPqA4ohq27yC6hFb/o/788Lw+ACzgNBRsngHhouMz3/KCDOOceGbEFLN\n", - "IpN2vgzQiYEPgAnikY6hK5/8oKrN+dNLP9WeHICITCv1bjFEiZ2UgYxyLJeziMiGymfKYrtY4Kzj\n", - "YCRfmHH/xGiIjtSs8M6mCqEShNFBRoLdKAwRMVUwEFhj0eFyjdBx98fcsvm56/AiYdrhO8318Xlm\n", - "TepgR9gFqFCW3UEDAEAoCRGW4M4+3CVrSXPvTAAxtETN6IjNYEwCg9G1wNP2zIMh1f+AwwBiDEb3\n", - "EnLLHdWZVDCEAQXggCihY++ZZfbYjiMsTlUOwPcJwrmWrPn8r7bTLkRMwM+f3XsOygF3+q9pgocC\n", - "pURePrsiQAAAATZhAKLgBEAInIDrwtz1+Aiz5DZ/CIQUjzUSEBIVoDQDgDUAAQEAABAVmAAKBHXH\n", - "EHCBgABAPAAEBGZkADwTN4M1gACAlcAAIK4AAgWL7wOWBAANHkAMnyFXWkMBjQihyjXczarOMAF+\n", - "HoMh77QU6sxATy5eN4KSv/P6mctFf3Y3vs4bL5gQwyEQQY3gAJGAIoD5YUhnTLql5N8pW/wwfgDo\n", - "4L49QsJTFDDAQLoFU4sRVNxsguAQ2loNCiSlSXLT0EhR7Qpbn+AEQLpRFsCaQKrGIA3pCMgykMSW\n", - "gsJf/wIAAQCSgDWEAAIGAAAgIAEjYBWHOqZNd76ctpW8+gU4CIWhLBJgv/t2AA+JManVHWFK+8AH\n", - "SAwb7UQS99L59HRllG2ARgMACoNOvAfIBSQbkCCsIkcufPkSAAAAS2EAveAEQAicgOvDHCuABTML\n", - "c8QtJDF6HwgIYgoiRGOy6M0v/9wI3eEQEWlZ3j3/+DDCAioaAsAYfa1Ve0UOOp0fCvG5X/CA3OBV\n", - "gAAAAAph4ASACRyA68G8AAAAFWEG+AEgAkcgOvBniT1/GzUhfX3okAAAAXFhA24ASACRyA68MIeE\n", - "BJxsAm31b79wAwNZw0U0RJquxHaRRxTWuPe8IADq92DVnnCYLda+MDKKeTQ9vvy+NEdeF2ABV4Ay\n", - "w352oEhsXYM0AAUllAHAor1+2wABACmwlAwrAyAgKLf4AhwrgSqmlYRxvMYz6CH4Edigo3IUop8m\n", - "3Ulr2wAaAFBeGDXCehZU4H4UACEFhAAIAAgHgaDQAHDqFIyCLetlmjBD/xz8JUYgRABEawQtNGbX\n", - "WDClbA1UArwl33gALMNzRjbaps4aKE6GgLuoA5pSnPAs0NxOAsGGWgPNZLAygJituBqd6QQFYngD\n", - "DIYLAZP8IhHiDB/gAnACU4AQWfHK2D9q9PAUNTKAYMkjxEH5DsRs8HQ7CUh4xyGAKAAIA4EQBu4T\n", - "MV1TfVjV+ADTOPOgSrFwpEWSbhhg1mFhqBbdO2XMDBU4e048Se//0AURuUoiH6pXNVINOy2TR2DA\n", - "y2P1zqov/4Mjr/r/tJAAAAGzYQFHgBIAJHIDrwtDIRPfAGMaSPf/f/4ALZEBL4O8jJ//3MVubaX8\n", - "MAgxAgOYALMw4hkqVEEzEYPZu18DLggBEYtK7FvNYUGAdVhdCsX99QuR/Bwn+/8b/76uv6qrf11i\n", - "AI9YDsPHRVcHXxIdgARRJobdCoypoDDOVBI+WFlMGBP4CMEA+AyGICquLKGoYwJ/4MP4ACMIo7lo\n", - "NOWUPQUXSA4AAgIAACC6AAIFqD2AEjgCyDZCUyeMoOYigJAA2UIACAY0WAGUQfYeGlUkp/YBnPBa\n", - "26fL3/escF1FxU4TgM27p6JGtv6gaetafWtPALgdBAcqTomNbrNyBezdl9wYhESf+iHhaADRXXd3\n", - "JuSeddKIBV6H67AMEu2OU3IrTPTfCB6/AEAVOSPIf9vP8OIf9eEQyHPAAQAAQCQYEZ7rMV5vN5Hv\n", - "CES0AjV6noDZUqoxz//k+29QO8aBO0PUfz4R6rbSDCIkNQAWRAdwaTXLnwEGI6PV4gAAQEQABBaA\n", - "AECpl8MIJ0KEAAbAIJWc1dSNGYpVCUeOweYRFEB2uvZX//owMvU4v75pwFV7G/erGq2//tEgAAAC\n", - "NGEBs4ASACRyA68nDHgBlgACAkAAICcxAAFAiozwABErgDOgACAhZAABBbAAECu84IAIVpAQAAgE\n", - "gAEBAzgDjkmeeCooTIU4HZVewAlOUzCksK9XgXiCJNFpvFAYT+r3hvgCEpAHNSpIBbwhN4VAkDD4\n", - "I5uLaiSFjAz4WFoAHYQABQENNCAAEB8AAQAwHD2CFZ4cE9IIs9fgQANyCWiRlS6zQDu4Y2JnlEJl\n", - "4AoPJde/wHhxd4kqv+jAkez/vkCHk2Qneon+bDPG8qcFM8whU3gTfs9+AH/JjZi9e+HcABAMZz3v\n", - "c5znve5z//+AD8AA2cAGBATezLjI4AiEc7gBjKmekc4AEuE2pRfURzX4R6whn4VwBQZxiGJNEkht\n", - "BhyTO4ZgAAgIgACAoABoAAgEywC2GEg00KJREUzMYvP+wwgEZbAgADwAUcZFXRyflJNBo5iAZBz/\n", - "BwlQXFka1hy0wGY4GacFvgj68//DPwBCsYO50+e4kMZD9+EXwIqFBR74Sor8mYAlSwwhhhAAitaE\n", - "AAIBQAYFGs1nAjIFCafd/9GJeonhcSKYkIqL7/jeGqCHAQJAtAJDWm01P+uSOUU6bY//AstNHONy\n", - "/XqRs/89AdkGmq+Dv5sx91Of/w54ACMEQUstwxbCZdl5xkWov8CR6bIcAM+t9D9L/rEBv9ppr1p4\n", - "MqR8IE+wBcOIqY/av9cSG4ACBEF5t/Kr8iGEkhuOSIAgAwYB9sO8V3BBE/GRc3N7+73+SAAAAZhh\n", - "AIfgBIAJHIDrwrCM9fh6H/JeJEHlsAFYsmzaVv3f8AA0KovVZrr+/L+I4ielyvltr79Nl7WIvOPr\n", - "vrpWTZNl7/6gR+AGwJklPJPPDGgI4ALIIBsYAOgRBiCAthgmN/OystBwoAAIB9AAEBMAD4AACANc\n", - "BAAjKaEAAIAwAKCS0/5mSbd9f+SPsN6Qcq4hqDYUAD5siZ6r9/lvWQ3J5G///9hKgZPqta/tqPPe\n", - "5CiiEgzagzz0VqjgBXZk1376ATd6htAWZAb64Z5C5y5f/DARDXgAshHHiCpU+WEBg9m7QHLgiAYi\n", - "ylgqVh9CKX98ErdLjfPkzw3/jMXpyv/+bEAZ4gGcJfio8OwZWARH5WcxPfUnGTLu/f7S+EAnCI1B\n", - "EUHYALI4x5YYUEdsxmUzdoDZrML1nyrwyLSW8CC/rBCPdYR3rSXwXy+DfQIA7yRKSaewECC5/CfZ\n", - "PlA2wePN4GgirWldifO/90ERSBAAEwVaYRQsxma88WREhbyKUX/7fQYddWesWTXbPfDEbgMosVJN\n", - "oSxu1I/xckAAAAFxYQCi4ASACRyA68LwiIPOB1AC1Xy/l0HnPS8m7/6/USEBId4ADgiD8+/ZKSqY\n", - "S/+rsAAQEgABAVmIAAoETMeAAICIAAgIgAeCaYAjswABASuAAEFkAAQKv75rg5gveSYSQLXAQEAN\n", - "EKKrxIcp3KGEGVQwAGjuSTmcC5669CAUzKHgxM9klISqXtygMAHR7wRDy2FKf1DgAEPDRvBq176v\n", - "Yb3htDWLDI2GWwAU3JN9bgCgwkUBGZwdRM18Etf+NiPwMiCFjsBK+9BDmmMXfWDL6HLKCE0elng7\n", - "TcuPSwQKMEHc7F4uIY/d2e0oxMDClGjChJxT5Wu1fnf8KAIBFQgIYB9GqEHYc3yBqayCPiAERqDI\n", - "1xGJwfeAHAAMiGhIAAgdACgMA41sINjRN1FABnuge3AZ4Q6+KnjbQWtAeCSqWparKynABdgBBqke\n", - "fRMBrZ2QgEkzp+AbZ4ACTgHTJ8CqA9fjgjLU39JB5agBEyW3fYSAAAAADGEAveAEgAkcgOvA2wAA\n", - "AAph4ATACZyA68G8AAAAZWEG+AEwAmcgOvBnIYMcBLTTA1uQC4AbgVNhvXjyoDFhME4JeNlcAgAC\n", - "AZAAIJA2kjsT9MDuWKtbUf/3eEEf3CAAFgdYBKKBQpQOBaqh0Fo8wWAFSZBFAWxTQPAag4qvEoCe\n", - "KXBIAAABNWEDbgBMAJnIDrwxEhAK4DgACCEAAICgFgmmQBXCc3vDPLY+bwACRAA0APUsR4ArcYuA\n", - "023v/xgABcAUHl5b789mPqVVXhAEVjwgADYBB7wAFPaErozujTRMgNxbpTSMEXf/wfYADmNiHnlH\n", - "EniGFU88IPDcQCi8YdbNxWX3hpKfa5S/vA1CIk/vBF9YnsFAi3oOfECA/wAHAgAC+bsEAHsHDdLB\n", - "EZwfgZhwvyz5YwTELgda4oSdX9KZ5EwYDDoAwicnRDueL2fFP2AUrBeU10tILEdTek0GYg6rSc8o\n", - "knQIJhB5ZRliYvvH5z0HMFR7zCSBa8EAATMYOEBQK8AZlbEjvTyWWPnOdAKJ3zcBRv32AC3zjP1k\n", - "FOTeBDp5ZipCqcShh5jD8OWCSiADUO+7Wexq2GWUSAAAAhFhAUeAEwAmcgOvCw3p1L4REhAJBETh\n", - "fAAtkEcthmKsT/ftdoK4A9hDnHhpMQTMxg8m7XwMuCARuWAx8n81qetP9wMtThtTx85i6FyOAAvM\n", - "KNZR2/6ukOXkVruu7/A8BtPDReS//60yAIpHMBWCXMruHMN+QNUDM402yhW/K90gYG4l5AGpZfUU\n", - "Nd/wYJCudCiSlX+eQGjB6my8afghdriIkZjiQ5TqW8Agi14IVh+3UxSKt7pBEwzEM8tBo9//AsEG\n", - "OAFshkw3Kg21/gMHVxA1dTW0+JaVTCqrAAEBGQAAQWAABAvE90BQ+gM675BgAFxPhgACAAAbXbhE\n", - "k1FOxYtAB0/xY4LB2DqrCgkmw79j8Pj5E5hIiAMHP3eDbKd58UzjXVgNwFJ9awKEtJdrz5stw7Pw\n", - "YhmeLQwwCymof/PQMHtS7s99ALDMkP/nhLwzYCmqJrtr3Enr/wDpQ0H3///PHf/MagPQ6qJT9q/x\n", - "9N442CN8vhEMjhIgIwiHf4ACCKcAmdpiwFjj3cgltAATNBiLDkOy4yBAwwEnqRJRCyJtt4Q5CoMC\n", - "uFH6JhYLjwu/AwI+oLDlSYhekWoYYACIEUQspw1bKZZl51kMImQwgAEENKvILhS1I/ym7BlIITmq\n", - "3g4TnMnfvxoq9nvX4hqgytP+Yzm3rTAJ0AEHOmYC2Nj9iGdocIvrqrPYRzMAz1Wzb/RIAAADDWEB\n", - "s4ATACZyA68hf/ghDfgE4AAgJgACAlEgAWCCTwAiECViYA7m0We/ACgbBfYQ0mq9P8yJv/8TQd8A\n", - "MGqoAARKztgPbWmQAgC3QKL//vRYAKt12gIXSIGxGYIATmMEAAIAADBL+AKC0QAg5ZtqAcZKoAHw\n", - "Yu4KwD0AQjSwExGnibQCmoxLf/wCsBVxVO3GwzPMLhxOuAIZoK2Ppf3/TgDwx7If8/CMMcAHqQSE\n", - "NCCIM6coXHQocJ1CBUcMJZxZ318Gj9d1rAE35FMfZrwIPKbXU+cjyN4gACMhAABAUAAVYKZ7+A5P\n", - "TUcAfAHQyEm5x4awAE4xxFbLCFOxYYtsADFdp2m1h/l+QMDQhwt6LtdptO97Y/1fu7urhh4hYnjY\n", - "sulsbU4i5IfqFbTrpvPAw4C1tGfoAD0gYibhXpyf/fX4eur76sMQXwAHAzhLRIWpFNCpOgt7wBu2\n", - "AJUITLR/W2D3gB2GAZEbkrAX33w9wBjs6YNCoVQRqUFvLADOgACAgAAICURAAHAk7HhAAHQGDWA0\n", - "DMxnFr1//728gBdmBZJSr8GYLMkbg8GD3M09r73mNZpUoPQVBBLSvV4ER1BBn0An/5Kofmt2/9Br\n", - "CCwAAgI2wAAQFAAPBI/f839YtO4rDyMWObNCMMojqwwoe/G/+7/CCzMEAAXBTzRwmgDQI+0sOeKV\n", - "AjnSz/u/w8QDCNAxMVWWlwJSIB7w0D4Hz9oF/DG88gpE8w6wWNIvvP6r+ZO4z14ZgLIAYBcwPgsW\n", - "gTgIJuBgMOFlHGIDERGbyfv199/f/dXZQvUf1pEkpOMkk/f87/PfDRaRdR1EkBUT/XlHi+ASA7L/\n", - "iBAiekFo3x3z+pDBB91WreWP/3zfH3llL78IwvgAJhMOSSwQwRGv9dit9DAAQSAO34aIFoqtJSkG\n", - "IscFgLQut7orDRG/FzJ/+8x8F9IBWSbJsRCNu8ggcDAU8OcPPwgbDAlRiUMQIAA0BTzAgADQHDy3\n", - "gDEM1uMQIBiAJIn9A8ktUCMAHR5RNYTTHnCA8C0Y0ZeyExV/xEgAAAHwYQCH4ATACZyA68KwzPE8\n", - "qGgYwCBq0Jbl+///6FSinGkUf/5CPjtLAPECD1DCXlqf+Gp0vL/E8QfjzVZvP/hCn+z/y+MFFMJh\n", - "YIh+ADqMK0RLULHw2IbrlgBeAAEAAPsEGj8YdSjvYAmQAoNLVkm8zQpg+PE8PwYhCYNC/E36KBgL\n", - "zwu/YwK+ZLD1SYjelVo/ISMIriiMYcwohwMID4YRANwgA5ERrT+tmN6tHfQGRtlmS/akUrmYSW+q\n", - "/wAlMzUdaKn/vlnSZN3r/88A8xk8KZxCec/FgAZYwEC2TdDDW/+GTvl/8IBkF/gAfBBDzg2JM+UE\n", - "hc8tfD5QQA8O1CIDMKAbTeNEYBdY+hM5TAa3m8KlkIBAEAT88TmR/6BCAZYIK4qRyw4PA9kFSyDQ\n", - "3+Y+IYWXwgH4k7QbD8AKIAAgGsAB4AHARDhTVsAIwn4gsgn+JUrXPsYzgghy5IQfcNDdqxKlEFkR\n", - "B27AA3AAf3YAYCwJr40QomNctpL3yT///5CzGZhGcopjiAABAb0BDFDVJW+6qYPf/++8BCmilMoe\n", - "dVWTbJedGxiEAAfACBRUIAAgAK8iQAYRTlxjUwGENXCjk5Avg0MJ5gsZQr69aAAEAJ6AUoMIdJu0\n", - "HSJArdu3jrrRZoNCH//LViJhJaxrIDPPEgAAAXBhAKLgBMAJnIDrwuHcABYAHAJMCYsMwYiwz/AA\n", - "sCCsTUGhUKJpVJPfAUAik4BbhCZYO421DAkAIofLABWMyMFihWEb3oEzSHGeKE1rH6Ejm1EmVQtC\n", - "4dgAPMtskbMh5LgbCC6oaIkTi1KhckcAJSgK2KdAoFNk1DXA+gMCpk54MQCjDe0uC2uaAAEAxXcA\n", - "OCBtbAtrSOBiJdLJ5hm3wBClcuyVUFGVhX7/gRcZjqI1WmIZiQYQABIHUPCBBPEaBDEkzBsIoqyP\n", - "dyymBAymQwsQTV4ZsR14elKaS2QweJGQSkDoXefaYqCKXaSEoNDqPpeu+GGy+ERIkIiAmyggobB1\n", - "gAIBgUM4kpiuC5XhMu4sdg/5fAcFoXTOaaWkvvg8gTkAKJvVb/ldM6eAVBZdIYIGM+FSoy4IAEgi\n", - "wgABAEAUNaDgBiSa48f/Ak4I70LWaYtmy/KrgDN7uv+6ABkMioCqWjyqpcYgUX7a/tEipbaVCQAA\n", - "AF5hAL3gBMAJnIDrwxwrgAJgOAk+ESLLGjkwPrBzD4MK17zwcnDePA3EKf/gw4QgJRgoADwHACbQ\n", - "9jsQo/YY3EYZG0MWeWt/gA/GY4InxyrayfWQhHvFx0XdMv6+/wKsAAAACmHgBQAKHIDrwbwAAABC\n", - "YQb4AUAChyA68Ga4YDk+jbGADkgH4bW+9qCz2F2KmIK2hLHAHffjMBQdnkjD///cAH0GSyvkifAj\n", - "DpjZjOQi3/iQAAABcmEDbgBQAKHIDrwwoQKGArgAIIAG6w5NlFe5fCfEFIIDMAAEA4AIeHywAgAI\n", - "GKAD2Np6GZqiaI+kixs+FDxQgABAGAcMbAEk2F3bmsWJFUuFlrf/y/SoAFsEtGewTaCaiF3/tIAa\n", - "QOCg0qiu1MEKl/3tb8/88NQiEcvsFJAwLiBg3ABeAAaOACAgJu5FhkRuAAIAAIBrAIGRlBxUR2Gc\n", - "OE1QaoVOAEANxcHCl9PAIFkCKCUlqJNC5HoBr4ExgLyV+W0fraQqvDbHscrhgCgZQhTEmiSQ2gy3\n", - "JnfjJQ05UKaOYu8GK4lycY1iH0WpWrBHOGhAoisRSxb1vAAEAijoJeaaPLsgWwGWVjkwBcF5+7BA\n", - "ACAEAcosIAAQLQABAeAB4KAAW6yMsNMnj/9xGCKrBMIsgasO8gd7S2Q4l/5oANjdqaLQKKb0gAPg\n", - "DYKQ3EVx+ke//ABgglJRkJ3s9Gpk7BMoAuErHQo1vYcksyHEDxjewkAAAAH1YQFHgBQAKHIDrwvC\n", - "IkL4APYAKAx58gCQ0VGLf7pAAAgIgACC0AAIFqCALM45wkpHogpYpFLX0AQnBAj98dZC7i/LhI9C\n", - "UDIEABFCiYBa/R14wGRNaMMZG6XQHGU98ePZSxoAFlVnFZU1if/8/hkYGEXSyhwj3dg+Dx2mwSHC\n", - "z8TCoqLKpBftw7CAQG/EAH+EFcV1JHu7qc8DAuKEMs8l/rC0n+h6GjTrxWLxUbren05pqf7llsxb\n", - "0pDsS4AAEAwcKVrCTBEgpxxRz7BERAhMUK4sooBAAAg7y0ACwAAIFkjwYFexo1NOklNL+W4gAAIC\n", - "AAAgKAAZAEKOAWwEdgggbE01mRORg/DD0mgDAAHBeDAAEAEALzhOZoMzX/EobBd1cjZY+UiCXiLa\n", - "BS3bjBAzIrFuJNbBbSBfzHb99sAWKUDln8gNKCQ9bwldvDEMiT4gIwE+v/v6GF3lMt5ADC9Kev//\n", - "6Em88W6byvP78TS+WN38RKXyHXfL+IieeV/FLaZbi78AHyDhlHrqr/1sP6MgJ0HY/pz1eGhafwiH\n", - "fXkAAQEQABATmJAAsESgAdAAEBCWWAACAoABUAQgPipjwVYvgAICFNGLbQ82qom2S86GUCunZkxK\n", - "iOb9oHou8erdB44AyDEsPdhZJxy/aH6GEYa61//QMBEgAAABk2EBs4AUAChyA68nDHgAdAAEAOSl\n", - "AAggXc0KDoxmAgWQIphR2FCmCCwAAhv+ESAB0K4Qqo+PcEwJzSEAARDEGhAACAoAAIAIGjmAGcqZ\n", - "tIcBsZJsHTBtDk77AAvMTalOpBOWsAkdCPSxQVgmK5DHw/onjYIf/8TPS+APyZzN/wBFAYrnXR+X\n", - "P0EBIQhW5CHwAMLyVvS3wMJZ2HkeGsGT1Cokp5YAPWInVU63/1uOPVF/+qnLTxXOWm/6xgYBN30e\n", - "/UAHqltlP+/6FAY11K6T3/fLECAhXU/CuBIIIXVuCbMilatkxP+IAJaHEGV80S2DgJ6wKfCIAEGE\n", - "QheD4Mym4ta/wYYQBFYsIAAQBQAgaYFX74bW/WYkHaN7t3+BGemjXGk8AqTHYIJVPGgaUfcH8+GN\n", - "9898DXbcvf34fBIYhtr1z64cwAEj3CXshSxjF/xfKm2k+olvxzf+dvoEZtx//ntr0M2g8bJr/fJA\n", - "eV9Pkz+vBqlbj//PDsRwYQBkf61/u/6KcAqdvoC1BCu70AjggSC3fckAAAJbYQCH4AUAChyA68Kw\n", - "yIC/YGOD1GYb8GABfSHPsp+yP/QVmyy1//59/nq5Iva6dw++Le3tvw/l+JEcITzgNYAdbKK0T2DA\n", - "fgGWyhz/ACo1iiaNXoPwA4gcEY+8cTy1HBgPx8QoAcuCmCoR46C85sLG39sBUGAqEeJoV+HODMNC\n", - "3uLDRSOxczp4JWIxgABAvABwYOB3vzReQAAICAAAgtgACBYyALEAIEOg8ASGyguE3yDAGBwIAAQA\n", - "pAAEABZ1pSxh5QUP/n96zPhj5k1r28HPQSglgAB4CwC3AVV09Z2oyLLyDXf92/dWTDsYZ6pbfpqQ\n", - "ZXOgRDx6g/YBphEQOHhfAAvCCnCSsAVM2SpvQPrAAKDAjagsOVKiF6Zal9jKccWc/2e/mDTolhAA\n", - "CACkYAFBITeyLzMlPFmngD5YZBbh08k3aCsRQgAEYWwCzBJgpuQNFTVt3AUVedeO/u3jtW4ALL9n\n", - "IErfe/HgjP+Ax5FEto8EHFtMLd50f/4wkJkYZCHIYRel9jY9sweG4YAAgNzoAAIEAABMwa63AMRq\n", - "hcHm03SeGRVXGAACB4BKAHS3gBMChmOKYZV4R3QIb+AAIDGvPL1yzDEES/6OBCXP2nubtDedvrHA\n", - "AYILfSuggN0JO1qif7OcPAR4AXWE8YFsLzJMmFQABWQAAQDABzFIBWBwBEz4c4alnNM+cAgBkggD\n", - "cAXiEbU1er1e+zwQABIBRPAwACAZWT4VSkYp3mi55eJ0rr+7+6AL4Qz1qDHGH/YgObApDa0LRJBM\n", - "iQbJlWF5lq/u0yDpHHc3jWg2T+JAAAABD2EAouAFAAocgOvC8IiMv4QD+EAiHbBRtMAA7CFJIag8\n", - "QUG0OHRQ7AA88cxNXzlcEf9AnYgSGGdOgNxUcP3MA8AAIBaACucrAUYYnVP/7noAAgJAACArEWAB\n", - "QIqXwgACIiSAgK0CgAvFdV/xo+/dh/oJI54BXH4FsZfn36faRJ0GaQAcNWMxwtqccvoGlK7MBL/1\n", - "4JBfCoeU0pfXnJ4g1Xp+HKG1CMIhjwAHAAIDGHiCM35kdw573/6wWgHihTksoggrSFrgAwKgxRq6\n", - "Y4UmuQa//BCBQUMIHcvIynKcADjZBOujvmI7geMrnB4qpYUgnwRlC6zIc3QAB8FNwUhCbUZ5ZeAD\n", - "pAgxrsFW+qve+JAAAABUYQC94AUAChyA68MYZCvgAIh6qZ23brlRggAEI1UxmACT2cHYjXX+bdJM\n", - "rv+0JmNWaoBsEMNdAe0WEjwqA1bHLkT5V/v/wIgYt/nM0VrVHU/9YFWAAAAACmHgBUAKnIDrwbwA\n", - "AABnYQb4AVACpyA68GeGAxvAAQDDFPaW5b+MAAhAHxCwfgEAiXkhTy7aRIimyYJcBCB6h+hHViTq\n", - "ZEEiz8IKQQFD3ACI5simY8DYaN43n+v+Ej3yAfv+nzABeH2eEQ5awxbgarDX4/diQAAAASNhA24A\n", - "VACpyA68MISIwrgCVmtOnvv9/5XtADAAEAcWokQVeCNm+l757/AIQn8dRQB8zHU6Frnr8ASMaNF/\n", - "9Wn8QBBjWljV4/f9+QZw0P6/yo5fEBESPEmMHhvAARgiHDkuGLYTKsvON+HgxolhWL1N7hqVwAKs\n", - "CoHDzTGWxCbMn8eMAC4IPmTuqmUJoVOU2/A7beYAAQBpAc3OFeVBeadwEKHsH4jFDkUaVFw2xCqA\n", - "w6B/No/3j71/QAyh1Lo4niC3oXd0EDMIAAQCwDAW0EAAILwAAgXgACAcBkADYduYxDhVkOAhgAEF\n", - "+HkBs+PAUQSrJEM+doz92jfIADuAQhCx5NMgeYIlW55EAAIB+oMpoOkADlCeQ5gEoRKEE7X3r09L\n", - "8SAAAAGIYQFHgBUAKnIDrwvCIkNYBUAAQD5AABBaAAEC0DiQQZhzhJUqIJmIwezdoIBI7BAAGgFF\n", - "OjISgBx9QYadg8QDKzr3/86YcfFAD1Wehd9+/EZoCzucAwCaIZCgLQaTmevm//57GPvZLkS/fYQD\n", - "A30NgfgArAqUzrGUhvAAEAzBhatkftKJpNEeuFkDoPAUAAEBEAAQFAANBJfW4A1AUd+7l9IKyIrI\n", - "AGIAAQEZaAAILUAACBcvzxgLgZQ9VE68BYguEiYg+znE4hpNMIFkuujKjgxHvKJkXns9jND3/baC\n", - "9Mp4SHL3gkAAoChAAFwKUIhLl1l/3XL695AwzwguZl0dSW4RPRmABF2wEUafEVc0P+ff3ZOgUAY/\n", - "UjQ20/3lbem8DEEPhGveJP//ACoZ+lvj9zx0ZDXQ/79f/L4RDJBIjhbvUbUdAgAMr0rfXvECKIWU\n", - "watlMsy86yEqwwAq7slJrn3Ij0vfoKFVtnSV97hXrwT/b61OyNNPhiYnmT3zsMAGgndqic3jL4kA\n", - "AAJXYQGzgBUAKnIDryF/8SPDHgAEAAIAVhgAKeBgxSpOzBbAFicAA3AlT0nxu34SrlrzAAlcWHDS\n", - "kUgE1hqUABaEALEKEAAIAAFCVsAasp7YBeJ6DlmBecZgAXIx/ENnF9CABROFZiwidq5Ht1pDlhv5\n", - "QALEADcwBljyQAAgkthi9YAAiV7BAAEQpBAQAAgJAAYCxPtrC5FKagKsd/ZAGwHQNQcK0BhEO8aN\n", - "5k4If+J/PRSsAepHzXPADsCorXZriefhCFYAJWFqdC0hiv3e6CTGoEeedInDv/eHYBBSyMCiNSJJ\n", - "Rf99w/hCeMQKiAB33oloXOj9TNEjq/Tm/0Hf6aMutM2oyWEACTehZS9GPgWPObalisv1L4jQQgoh\n", - "rukVlgwvBgOTaagxp9PAHwB0Mjzc4OX5iip5wrAGZu+X/v0xPRkmq4Jso2p+3/4DgBRumJzfyK4L\n", - "HSj7wPSAFCy5yNXgIBIj9B5DDCJkYQABMIWR8FCkDW1yDfDErl6L9YGW2gu6AnhgR27/6DP0gBqA\n", - "Vgad3pRE0An8B7OwABARkAAEBIADYgACAOv9B+EAERjAgABAHAHDy9vezZhkA3j3/6CEVWMMUUKd\n", - "BXYMONP/VOnz1Ac7Tq9c/4Wg0pimX3vn/l+8QIiTyCI43nFG/irG3e9eEHOZbQ9xEklEaMWTTP39\n", - "jM5fwxGokF+tQAHADQaA/kyU9upXc3+0DMSrAeLIVEF/dxhGYdtXkpKhbv94AAfhgAczDxVYN8Ve\n", - "iEVt8NF0XUAA8yA8X2XTUaeDDA5AXE/15QCvDsDvUkAAAAGbYQCH4AVACpyA68KwQiFKih4Zz/F6\n", - "QBYABL7RKXj27VHGPB2BAHb4Qn/gLotx20km/PnJ+BOCKcf9pHKX+fOX/M/+LAPgtgBFAAEBKWUA\n", - "AQFQAKgCI/ACgZRCCHiV8oEFGWVM9wwBadMCAALg5xAQAAgUAACAUAJC/QUAZShqcB+M8OAChLUF\n", - "WYQEAQ5HeGi/ERGEAyHIACCA2uwRQioMGztqc8WhhsSYaOAFU8d6+n42Ejw9h5lwJSKBBuMi2O7n\n", - "/VNjYCcAAhYAWYKX6AV5A1ADQAqYEKLTm1/h4ABwAgAAgNgCUt4wgABAMAeI5Uz05fTsDV1h4QwC\n", - "DVPtap8KSXbl49uwBGEUaAb4LkBMbtIgAC4A4PMvW4M4LJRg6fZnCB4gUqPgAAwEgdud2tjztry6\n", - "0//yYIZgAAgIAACAuABgIy2hwh6DCCujxcQRp/9fhAAQBWGhACABocAzijD3nwgibbSACtgoV8iD\n", - "8Vr7deBHbKuy/1oa0BzlJ9IEvL+BQB4JerIFzL0e/5dB97P3f5xGmYQJ1b2mNSSAAAABT2EAouAF\n", - "QAqcgOvDFiRsAC8GxxtehBSRyb/5wHhExyz8OUkdd/8AIADIBmuTIE2yoC2adFD4w2D2DY0I5qmK\n", - "uIVuEZkCij6pEe//fS7GcH8m0E4guvJTeBxQA12+WiymYknl8DcUs+wXm6cSx7/u0YAAgGKUpQDj\n", - "g6o6nBI7v/vAu2uya7//pkikwwAAQLwAIDB9MBBgA42HNZiUOexTyUPCABHLSEACoAYoABwCBNt9\n", - "oYmUFujphMHoS99+YHXI6AVgtyUnvj9DsjEABY1IZucXUHKW80T9gsmXhVUgFIrB0qSwIbPG9uDc\n", - "KGwXlFkaDcSJBBUOh8ACzBhKKiueaaSIlS1/rgKAQBheH0KV2xDF8z/7wAQCDZ/tPtVoUXtLwQCI\n", - "hYQAEFad/gCesfTewEnGgjlr9QpN5VB+ACsSwbwIhvj+AVTOAMHgqix+hFESAAAAcWEAveAFQAqc\n", - "gOvDChnCuAB4QxQ94/6I+0IF7Rrv+EphE2Vq1J8cWqQ8AwfNQNT1K1CGCE6gwDgTENzMwGwQw0/O\n", - "DOUDAAMDgBWa0yQ+JAAKkhZWM7/f5/wASoRTFxSFUb5iRJDRmU7in1BrGT77OBVgAAAACmHgBYAL\n", - "HIDrwbwAAACGYQb4AWACxyA68GbhiOBBwBwAAnaAAIBIAB4GezvoUABsAsB9gdVMhZmpkgAIIc0U\n", - "xt9B1VZUSf4MgQuA4FJycUtWEDrMf1nsa1mZtPdwgOIQABwBf4BirDNIDpT20X42AeKIiiHP6gDo\n", - "RfgzSAQngMcjEEIJ3aEnI1+V2BD7fm0i2vKf/EgAAAD8YQNuAFgAscgOvDGEArgAPrmn3WvoYMwA\n", - "Lb51K0/7++KYQABQDkG+AI5pkZeexZGGKq1DWxXUvKvkdMDWIPX+CPY31l+CGICIRCCG4ADZM2hN\n", - "lKrMv3JjXEbOV2Za87q0+v7PDQP4NgK0RS8qwbC1pScHIDgACAgAAICoAGAjLeEYohbFHnLLHJqL\n", - "p8BhipvwLk14QCCvBc/+wNQkVnEEEV1vf84YwYFJzLSbM5OWHU/BhAAITFhAACAkAHC3AB98qNwE\n", - "oNo1d4AMAIZHjpDiXYcwlOFYt4ST7v4AMWfV7+uZAGzpSm5wx3U4fq6FamGeMMorZgVf/Q8oEHok\n", - "AAAB1GEBR4AWACxyA68Ll+F4cCIRCMK+AA+Jinz0TFzkx//wIfb86e1KvghUGijR00oqoA7sExq+\n", - "snhkEiH3/G7QSTIIAIVhIRPYgUfLQhbtS9+AFVFY1RAe5HRMt9MSaGYQK+CBWzoIDb6wALQYOpYV\n", - "URYxoCLN5hYAAgiUAAQFQLD1TcBAmvJCmm0a5ZqFLP+GTrgABD/CGBqG2nq9sxtCP+AAs1oBIIMU\n", - "P6Okb4o/veQeB/KLUEeTM5IJf8AAXB8AxiQzrHro12q00bgiGBpppi2v79oCFUojBYY992jZj397\n", - "8AB2mGuzKIuwgTIODAARMjLZFgntARgeFRJ9Xp8ZmP/YDRnAhaxUpaa0pktacgP5hS2D0H4EfGMw\n", - "ftSZGMBso+4liK2F7fz80MH+GRJ5RE44AHxjsX2Zqh/T9DN4NB3wAtDLY62YnZ/jd6PmzEiD/6gD\n", - "42JOss1/d8DUtumk7/1+YBMQBh/Cht+pDAAfDD0QSUx7HHl82G6DwEYtiYGADmd+K1b/m0t+7DDw\n", - "AEBCmjFsoebVWTdJedCAAIAzjggABATAAEAsDQ6DjkNxVpFInK6pEWQji+9O0DoYBFOBjgQScBNk\n", - "cpHkFWWTTRJwMbW+lbBkgAAAAlxhAbOAFgAscgOvIX/4KVI2b//fDvgAvAANnABgQE3sy4yI3MCA\n", - "UgIpRkMasDVRv94hMI5ijjGlhCTSoHQhCQoQABIByx2AGMqZ6RwIIDTwQMmgX+2ABLhNqUX1Ec1+\n", - "jG0BsoIqXARoZjJ7w3416wABEr28IBOQwQAB4Bh7+IKRgDDldq/D4BitKAQNOzbV42CH//EzyqKc\n", - "Awclm5x4A9AFA/oNzjoIQxPUAkZrnF3kKXytHX//AL5fEcKVDE9IAJgAJmABHABYxMqHNdsz9mbz\n", - "cABJGgAdSuONsBigUz5/8EIJBQgAIA5YIBuAMYphdnaYEMAC1gU0pdlKHRwzAA3RirC0oTZVR+0m\n", - "AQAAgIrjwFBZ2ksco3x1BBnpx+HuP5o5v/6DWAaICPqSg9YqJXp1iWHpAFSgIEuzmIExy1fd+4QC\n", - "6g7hIqhpnOEzRv/3hhR5wgAQZpwFRu7TcXVgyQgBUvG2/+czIyG3QqM+ijBwgAg+roEtFBog/8M5\n", - "2AAICMgAAgJAAbEAAQB1/r/hBZmCAALg557sSYBIEdaX/cICCsA1MVW2l/xvteedHQYU8uo+BxAP\n", - "C9i8o/ZGFYY8ABMhCtThBiixvVFk/wGqAACAgB/6UUiA0Y0aJAQhhKRhJI4wHcqIAbzX6IT//6pw\n", - "xASP02A/Iae9CUhf7ULxIegQDCk3zQSNwmfb2g5//Pw1SvB+l//3wQjgjWrdwS4P5krkjweQhIFs\n", - "I8YQACQdSK/jpxwxciaQtHavGIOIsx+1zImYPn3EUmGhmXT/9wJQYFJzpt8g2qgQ+MhAEGDJAAAC\n", - "EmEAh+AFgAscgOvC0KmGwAqEjwzhdQOf1cJIBg5tBjmk/3+x//gBUQBg61BDVM3ZjtDgAHRWklkj\n", - "Odi9WxH//aMdSldqpmd/7wYxLZmPdlI5WKbtVptbTM/wC4t5mzD7uoYcjQAPAHajNooWXK/o4wfO\n", - "KKpW/7/vpkA+8IF/oqzwUzqkzf455/2l/gB/mnd76Cppt9tf+Ih6AAzSNMT5SK7L3x9vZttgw/KI\n", - "UVXyQpTuUMPgAsYHYSDGjIvYqbKz/9/oMzznOr8I6Fd11N6NLvr9vzbYoGubH3rStr+eCaYAH5/j\n", - "CXMWjv/cERaahXyf/7w1oL0aA2Bj5eQCGACgMfB4AkNFBi3/VIAAEBEAAQWgABAtQBASqgQABsBj\n", - "hILM2oCbVLd+YGOTaMMZF6S+ABy+jhVVfeC0YGV5Vc854Y/20buGE5xtQ04cI+2XOMIBEbAAt4Yp\n", - "hgZmIgN+WATvcAIhV2wppKgGAX3DekSOAfgABAcoAFq5QwNUVkkJ7VPgABYAAQBAnge/pFMj/BEt\n", - "/zN+9dtl5GRA2Uw+LIW9jfBDQfRDMCWS52BE+VHgACCGAAIC4EAlLeAwVfFi1V8aQ4nhZT223o1Q\n", - "Ye5EIWBd6EgDUFCAAEAIQHKWMfSQWd4u38yo8aRCiJ3fMJ6DL5+jtrnxFARmC9bFjLCn2Nhxc7wK\n", - "lb/unwBCaZgZK74iWVhPfe5IAAABdGEAouAFgAscgOvC4dwAEEUhCkKQpCkKUhfgA8zjnCSmxBSx\n", - "Sbtf/0ShgAh+dzrPwAHjIhspHymd2h0MQ0JjfAj5yEAAEAU1qlhIBNAX/9oADB77QFk0Uz5X2B93\n", - "EQaAGUhoN2rc48DX/eQATANAtgoUPzCegnqafJMBMpQA0mpA00J9fFgaHBgmllD6QzI9yAIBT/2E\n", - "gABACI1CAt2Ma17//AQjqhMBas006kqC3kAjAACAyUo0ECmSMItazY7B8JgAgwmErQIAvIaC9s/A\n", - "w9Gbzu/o7zwwABALAJ8IAAQAQABAKAWa4ADIAlt5RqmaPxIMWvkBvgIaCGde0GxgeKIXEMoVED4F\n", - "wo5a6bJVs058Te6MIIN64kuxY/EFyJ/sQAxQyJ1LSbL2mD4sBqDeJDHgAfDi8jox1aP//vqAKAEF\n", - "MHqULodm1F+5bgAQN+lqwJhLz6EIf4BBCEkfw7FGgLb9BU11fEAO31oPcHgeQh5EK/3cSAAAAIBh\n", - "AL3gBYALHIDrwxhkK4ACIMY09HjCCpIyu8dJRlngAAQBBXoXPE/ofMZWg4//aAjAwG8m6I/3o8Fz\n", - "b74EB6DPmLwVSFH4Oc94IExSBAAFAKYLACLMjrX77sAIEq6Lzmy/YrZEGAD9YRfl1ZXewJkxXgxT\n", - "6Gq38L8/vRLM7HAqwAAAAAph4AXAC5yA68G8AAAAjmEG+AFwAucgOvBmX4Yhh4TDGAAkZkJO79DM\n", - "7oABAKqUlStGQgA6fxQBGbAjO+///ACvArYC0TzBsxQeSgEwPmQHTr1ix/r4CB1dNUy7ucEJLCAA\n", - "EDIAAQKQAsFA0zQR/XQMSjLVwFlGZ/hlV0AOCviGZipKo36gLTYSCU3yHet+4B0M23MYENlypIGx\n", - "sSAAAAE4YQNuAFwAucgOvDGID2ACL3dqdu+GADOP/VT/n8APAAEBCWcAAQEwAKgCIGAFAymCEBTK\n", - "uUCA2UcuykIAA2Ay3QTLztTg7F2MACtsmhp86IvAnZBUCmP02QFn2gdcADbIORKfBrCGXzhGOEj2\n", - "xuAAkeON+ZhWwhzfF5IyIDKGxLe//iJJquCqZ2gDAvKICdJZtVvZD/WCQ4CCkY7b2ks/2eBiPW5O\n", - "J66zUL/8AAmICQCc2Eo+VUQ4g9XvQCMAUYVrna2/qkCn/rxgGEYCPkiintXDJdqFfKICC7/ixfaB\n", - "tnp2gAhgyQjs0qYTuxfU+oMMAVCMIAAQEA4NsAK41rPw5Qd5CXM5FV6BeScLHcHcv/mcRomUgpyu\n", - "ADGdTaXq8584jGg9wLUGKm7DJNMm9g2WbAMdIrZI97iQAAABr2EBR4AXAC5yA68LqJCIkNZwEPwo\n", - "A8jjHnBhQ+ZEBi+G7QlwcASEAE+L9Mp2xj0Py5esRIQAD4Jhn2zCWkByfX9g+WJasOSN9L8MRIkS\n", - "yB/gAIwiikLQWYsgb5ZdD/BmELfsKMYSu8Rfg0GNrTFfQ/7nkeYH3BtOZNpvbMxoVgABAIQWGic/\n", - "BhgwyRewSZEUUe//gAM6ACgnKc1EgevINHP/7niLaOquc1SkAjGQRMj4jySMa3ER1noNNOdzqcxf\n", - "Flbfv6uDA+NQf6N6h1ikJd5kKnI9/VzVArdO13j2pxggTscZDcmVz/9hmGZ/+AlOnH/GwOJ/G2j+\n", - "4wBVWnRwdQ4I7VXnfmOJPKhiHYYfADj1Zp/w3hd7pdLKQ64QC/uDacybTe9s2xv1KrutSAAICEso\n", - "AAgKgAVAPj7xBlEKIDGVcoEBso5dngACJXMAAEBEAAQFAANAAEAlMAJxAAEBC0AAQWwABArD7+YB\n", - "YOg8EBRJUsIwjHm8/wQABoDj3ggABArAAEA4ACgL/WAGGRkFpV94MUL3PhzkW8EoyYEssska9vf7\n", - "Aiox8C4h4jpwN+kgAAACyWEBs4AXAC5yA68sVDHgAUMHtiTgQToeZC+v2+PYzCmJw0YuRIAMMbPW\n", - "AgDT3AwBFrggReYEAAUABDQbgAHBeUdJAqCrOhAAFnAAEA+PAHRYAFkegVHoApoVMaSIweBdAACA\n", - "reDiAACEuwClPrECcN8BQkYAsJTo+/LsDL3/gwgLFcIAAyBRDGC8ErhEknaQWc/AyEAciZOA14SJ\n", - "cmr48bDM8wuEjmwBYMJV8bK/7bgB4Y9s0r/h9idQQ94QEhzwAPAGD6zApMFPCDM5HL//7gmRhASl\n", - "JAEAWQiaU/4UwjU/cQn9QTvn/bQA+JilFUisdpJb/1QgOEBjgKBlHKH0xECokS6FK+LP/GUpMAAQ\n", - "AGQIVkUoC2RRilEWxhDXzQFdIATh0PqbJw80ke0e/4IzMIAAQBUAN5+7dXkz0er0YIgv75tfuJEC\n", - "sQpXpem9hKtemaEQpWkPAgXJ8o7rAYAJUcwW+QdmQQEcK/jYAFQHONP8JQJljlaQ9YeMAmiZI5uO\n", - "fGW+4yCLnKQgGcYCXgT3hhEJCBAAIDvHg6aON7DeIJOOwACyqAAIA1YApt/gaQMTmijqhcJct2wl\n", - "AeAAIBphAAAgp7RADsu/8QIDPwUBsEIowpn6M1ypUMOELNhAARnO68b+lOpR/W0MPwghDjlIGFki\n", - "AhskTBhxvPIKAg+utPrJjvj72/0//9fX3j6pdkdjfsAwH0zCfJGHzzAifHOB0h9YAoPsiX+//MDA\n", - "wDYjIbPlMc7F8pkyAiotGXy90ENF2SMhI8mWlA745t7YZerlFGY4kOUVKYzOGmJKzvB+Yz6BIE4V\n", - "4nSRjC/694//sDXZCoCWH7e0//8g/AGFskIlIWosUdZS3koYQNCJCCFwkF3YbvW2/NiAiPmR+4Ex\n", - "d/BdsjSZ3/eaYx8etNqRRxTX/4LDIYGM7Wj7+DQHBqUK0JFXllyanthfIbRIAAABUmEAh+AFwAuc\n", - "gOvC0MiAzAA9wOEnYxSqz//1DYAIKA7SGKkKpHMQ6jI4AA48jUh0i/+5QGURkZ0RE/q9pvGOkgxc\n", - "f8/xAk9Qw2iF//USIEhzgAIJwo7k6WVZS/1biof6DXfcC5ERaq//XtRCBzE1mvLAwDXxJvcE6BNj\n", - "Dl9Eb8DSiIgOYAeAAVoAAgGQcAPiGTAznsAhAoHQLZB+ygH6PBbp8oAPEtLVineL/5DDzA3A3q8b\n", - "+C88TKX8QEIRiQ7QgAEAEBSbcQlA7BcF7Sw0L/gNDCg1JcCk6dMRH5LHPSDpSloDBBAk3+7/AQpo\n", - "xbL/G1VFQESGwDrhYQ0nmhpWAinZjB4/2pJP8Ph8AHBAq/KFLr60n9DCyYRGhQgADoDBbAD3EYi2\n", - "eGuwiAiMhMgYRQof/11fnAywjQLF601LD/WbgBnEYLM8D+X/Ke5TwiYwYREgAAABPmEAouAFwAuc\n", - "gOvC+JPWGUV+8AHOZMuf+/3/L9RhzISNgAXYcJwInhTj7tv68RDcaySh/luklrCYD2BTg+xRhRbW\n", - "dwABAwBm7JbkneGpgQZ95EIYhDlRVSkw8CQQLwGCqZKUajbEHzzF+IABUAuPsdcvVgnv3B8a4hmg\n", - "51N96PfBhNOQeQkNcPiEyVstxsfqvz/lVrvBIMYjO5iSkOKFXo/2k9I94wAA2QMemBAAFh2eEAAI\n", - "BoAAgABJYDUQbfHKFIct2+17+Mf+HIPeKK+j5nTIMX3vdAA53cdJilmi+AMUgqkt4Yy+bIAusibn\n", - "yd72QSDVl8iFKwN4kMeACXTxIUrGK8/sCMg4xQ1knEjE19oTOeHNHARIplnsJZAwgzeO+lgAxAmq\n", - "OX/x5U+EaOkACMbb4k2aGQqsyM3OGG0RIAAAAJ9hAL3gBcALnIDrwwXyhcQIi7D2ABYAiAPEjk/2\n", - "IMt0uQJNQj/OtEHFybXt5AJeAAIBYjar9EthYIa1XxQKt+PSBTaZGV/KwDBKADKmEpog/XoIuIhN\n", - "6gScFSS5yBxgAHCABCPKCAAIhiWAjO1lQGp6MHsoY8h14Ea++qr3XzgArMhotms/c4Cok3CiG/MB\n", - "XHhUBfpvC/yi4GdIqLd2gKsAAAAKYeAGAAwcgOvBvAAAALJhBvgBgAMHIDrwxwx4ALQQO4LKrFhE\n", - "Ycns9XtUAAQEQABBaAAECs+WIAkQSAAsB8AKWbgkK4PBW2KnIcn2sAHwzmBEePVaWT4F4jjOE4KN\n", - "lnd2g2oYiAx4AZ9vpnYABACIAxIG+LnYpiU5sgVCmNn1dvs/oQEHu9qexwugPRhAACBuAAIEgAYB\n", - "Hqvc0OrbCdVJ29yhAy3+dsByfecCMjMyIWcvYmDAAY00cJ8IPrhs2niQAAABGGEDbgBgAMHIDrwx\n", - "iA5x0f/oGZswNdz0yDRlwZgIW+zWbYmSeZbr95jwBULT4/MNYg9/8ARPEs8Pw5ZfEiaExA0bgA9N\n", - "B4pqUxTIGMxaniFpDF7/vZgKFh6EEkE89LAM5rwu/7iAAEABeCEgasVSq3RY9//APMnLYTzxBBNI\n", - "f5d/rwOAAIBoAAgCgHjctzAgB3AH9fWKOgjVHot/7CS0Mcl5oemXftcIRjhImve2Zmv/97ACgQ0W\n", - "uMb8rC+VswZ8MEWAxw+3JCyNt6hgglFwIAA6AMQNABzmmp6/f1cB5idQdEJlJnoBVRJsx/GH9ZLZ\n", - "hG/CTQ/BKNXQDA4UkBvVVNuX8AuKXivRHXRWL1gLgBmFBjKLLyA85CQAAAGXYQFHgBgAMHIDrwus\n", - "IiQ1gAszDiGSeBBMzSpjdo4AHxjEEsBEOuWGs7JXEAChtXbiTaLbieGCjP5LFdal+IiBrYkPwYwz\n", - "EFwAcDBlcSErLb2l5Pa6AALANAON8hhxdaM3NLLaBFY5zZd8AMggK6qYPdCrepKTkurECMKFWVMm\n", - "G8j/v4FeEo7qUbZB+kBqzCZ7uvZt9wAJUAE8wDigijsuWTa//724eVceYeF1QQABAUtgQJmKeij5\n", - "B6g7hV2QqCQq/wFIa8aqGxsv8sRc0TORg77YYCBxQbKThVqG99+/aYaOhVToGw4t/4MwyJPARCZf\n", - "ABWF7c0m+9S6M6ADsEt+JIn3rz9CtHErLdnh4iXXTnZ6w5NRDLh86WwfsQEIRBB4BCimn/bQVDpF\n", - "XIge//WQuqmZyi6k//+/HBBZMMCycBBOyGDx/g8AB81DXMpTRjl2LADpABDgaMzrHTN6BoYxDWtr\n", - "6dEMWIkWCmTvtWGx6q1HJKwq//dNraRvmWEVyAYrC1Xxtq5F0OM5+hBYrsmkMRv63iazIkAAAAJD\n", - "YQGzgBgAMHIDrycMeABMm/gABAQAAECeKkAAQKADv34GpQGNQpABb4hP4VAlDCGEgocIAgDrDsAG\n", - "usWcsYnmBm7FShrIJ9YAPyAnQHaIcVf9XgFJn90MD8IG6mbisTDnIGAgAdzrgABAkkvAAEKMAAQe\n", - "L8EFXQIAAqDGH/gCfQKCt6YNAA6TFz8AeQ4tWjelQ2CHvEz0q4TcPz+AIVLbI//z/PXA2crO/cfg\n", - "8oDCXS6Tz/uz8RVNvCAkOeAA4MYw5r0CX0WHvizv/wN4RZpwAPw/008SeWjfbS89QFABQpZTqQRL\n", - "V/1CAQBAQHYAEG6NbTTYwT97M2xv1KruoMBcABEDcwQp41e6RZh91ju/nJzoH8AsENK3fAIJharU\n", - "jwKQQwYXCEyKHVhXw/f28vf9/Odrqtu8PkU7ABCJrnc9//wTB/X8pXfwfRMxnz9TqQM/Cv4Q62HC\n", - "Ey7pAMtES0cNsPwBitaO708e6kM5D9/EUMOBgGFCEABKBgf0PO1VjLX5j6i+1dv8F4GxQyyhdklz\n", - "m0JkYGOQYDlDBRf8v4n4agAzfX1b3v+IxcHEGuJLBVe+DErXhoGZ/YpPhlFrOy/Phjeevwn1dPfn\n", - "pF94iJYmW9//z1Ka/O6z/0HSvNvmT/Xn/9U4S/+EBB8X/+EmHfDL78ScIh34gABAABFguD7u3RCF\n", - "9Z8RxIp/bhODbe5hnT+GUHTfwAYc7XN34CvYI4Vt0RpH9BrkDFNM3AbgGIjsz0B2OdNejnsgMV4r\n", - "fEPbqBQgZ/WSAAAB/2EAh+AGAAwcgOvC0MwtAAcl5Z0YxUrqT+BLqj/Scnr4PxYiLd3ZVRugICDh\n", - "xQ4f3sDQsosRdriYnv5QocTBniBAc4ACZEMroYyFHSpSfIH0DMAQqvNBoHxlVXeFNwYAwTqHbv+e\n", - "ItU8wBgyHC9//zgNByG8lYxVl/FgtEBERD2AAkwHAbtN67G+aWZh6YCUqRQgvolKjAc/93hZFcqj\n", - "gk6HOYanINQFJEruADniVYgk/mAr/72AUB/SGnLFSXRxORheGGACJ29JbR4QAAgRgAGAJGggABBI\n", - "AAEDEADgM8MnEDQvzoitYgVRRYGwfa4jAtEv7UmFhmlfuxodAojgG2ChFTD5UcQCMKW2kG2pmAvN\n", - "EGc4aURhzABbBDnHhejxQ+VLG7UBVBBIPODdREUzJGq/wCCEFXbtSAISjRiSuqQIshSgFAQ8nQkg\n", - "2TdPpfRDEhGUbAASQFhOoQQCpjhd4EaryQwxo9yu8EUQ54S+8zMGV1OOt5aXkt4ZgMBUBxNh5Vp3\n", - "Mb//abAIgYRvazaLsDz/9/gMQwarhHrCiqThPrgMw/AYIvChai+dJ6Q2smCHGHrr7p4CFMFJ5Q+2\n", - "oqm0S+4WAABDWgoBAwpAwt4JIttMDneY2NVf16I5395ODt0S3iuwBcZ/BY1W8HSs5aSJEsDYLf8c\n", - "5piXa9RoK+zdugkAAAEMYQCi4AYADByA68L4RJjiH5fPMFhIQCRhs9YABwJA6y78ZQVYqZXBpSwF\n", - "hgACACUQfmCe8CTZz3+4AYBXWmjCEsWCoimHaVAvzklF9r/fcABgtd9C2odr8nJz6Wn4OH7jiu/g\n", - "KAC0GDh2sn2jpYWWn7+rwFzgONmyJyUGX6/gkU6UMYsakiWQZ4Bg++MgADsgABABYEUZ2gAGBTVr\n", - "CFZ2ycquRAgABARAMBQVCAAEBwHDwoAB4lKboLOuQ8jvrahCKzIUj/3sjem3swXqiUZIigvfABMJ\n", - "LHcNQbu+WEZByeUWabwXf/KKm0g6rZBEc6lGQFHvbg2uJPSv64MYID87oiF50DDxtkYJzhZyQAAA\n", - "ASxhAL3gBgAMHIDrww2GUKG4ACsAAIAyy4AB3sAKiJ0ydoNQhqItZHVfzgAGKcsTWKENJVC9Q27w\n", - "BguRRK9lvN1oDgh5QI0wACcTgv4p5zDoCDTzkDIynFxVnf+gigd/NmIUp6vR4ABogc9MorwABA/l\n", - "wAAgDgDANb/3BmAAEgcomWsIAIcosIAAQAgCsHgBWays67+qwDFyfduSiCdsH3V7DjIvBlpoyABW\n", - "PC+PlI3//q0wMKukGZbmhBN0B+DJ46Mk+UxkJJQGgItXwbSPhWAGX8vnd5YABUELs15qOp3vfANl\n", - "mj1jYit3Vd00u/7RvAAEBAgASagWxEnvgfqolEUhZEgYUecJAC4ICNSWeEU7YdRwX3pQS/wV1gyU\n", - "wKgosepIkAiMAzBjSff0gdQAAAAKYeAGQAycgOvBvAAAAIthBvgBkAMnIDrwwuGD1/AUdU44nCiX\n", - "ecNroEGRgABAARRyfnVgQwKrkQj1rwcAgervu2O9pNAfbDvBsAB2oyNGW8159IL8SZHMSulyr+GT\n", - "GBzlNQfh+ogoiCUO56AOyT2JU8cOlN7ayALhVno38wJWFTn+XlUuQObIjHKk/f1YMIMtYv1qqnit\n", - "O/EgAAABHGEDbgBkAMnIDrwwuHQx4ACR5wl7IUsYxfnIOIUJbzGnEm7QRCnrkigJYhlnoIQmcD2W\n", - "AM23yMAlBiRHXaYp5FoeHKAL40LWVDGxdLl0w1EhBXy/goAkHwyNwYFAATCMKaSocthMq284zwAA\n", - "XQY8W2SaQLUysAv9z4OYKj3mPIFrzsTZmNUHV5RCiq+SFKdy8EB6wEE4lDtNrwrAEABA/F2BY4/v\n", - "p4SFHbIlr4+/eyLgEPCGHuinByRsJ22kGm4xUGh4XAmqWEBhzef/wQAAgAAPiwgABAHAGDDNuKM2\n", - "AEZGUkGEyJqvAD2yR5ACB9xA/9ipmNLBzheL/ABjat8r7qF4UUpEJwAVDoauvTSSlZe4ESgU6mCD\n", - "e0Thf/hIAAABy2EBR4AZADJyA68LoWIEhENYADiF6WkLduU2Zj/FEBB+ATAIRsSzr2nicoAbxawr\n", - "kB/4S70V5/9bUb9VogABBBS/8AAQEwZMOeCVgF0eZXMKGSJMaNLwww4CAyqIYW+6z4ABcwAMbdh5\n", - "BtQ2TGQ2LlrBHIQ5zH1/ffgMoAKCzNNbLUAtwLl9r+D/wo2BC0wTxVRTBsWREqhyyin/+oEQGGTY\n", - "IWlCdLqJASAMeAgACwR0R5XgHr/oaM0gQblXjiWZrt/e2mpk35X+wxexV+XIAT/9paRmGUwqzNUA\n", - "BkCWcH6sO6KZU5AM4pTMSbagzDIk8BECr4AOqX+0K37gAfwtd/V+a/9L/hERhzwALYNjja1CCkjk\n", - "3/wJSPETe1iqO20nXvfixk3yK6O5kgdKzqOneDtstOvby6MWX/GCwgGRvxUGpSgKLy6P9t27MMOx\n", - "4WDMQxynht+/9AL4AD4gwveHpd1tfE4cApsYVUNE4atlyrfrEAByi2ENiVi+Rv/8ABEAiQNQOm4t\n", - "ik59ssEIYcFCBoFln3P8/ZOIejxJb5VkKH4Na1fdf9CN1n/b/kiISIN2cVWK1IAvHeCSvC/Nt02L\n", - "c6bFmgBfaFODanf4SAAAAqJhAbOAGQAycgOvI8TDHgAOwi8ZaD3IC0HnXP++AwR9jLypLJqZkSZ/\n", - "1kAASMADAkJvJFxiRuBCiYQABA4VWPsgEJ7SCXXtgAp5Jji1E/e4DWRhMpK4sC0KwhPSrE2ytrni\n", - "kAGCMfdOJ5/xsMz14AfbKOW+OPwkcf9/PQPnhoycTb180On6tgD9kvt1/u8BZvkSYfZjE+Iqly/i\n", - "OVBzjFAB+AAaOACBwRdyLDAhcFqCCro1AHqT5rgBjUpvRD2AIYCFa6tPy4BnE2pRdURzWlCEHGNg\n", - "ANBiFnP9AXKDsctk38u0vHv8yGVkrEVmvThqBtAAgBQhVwCKIKUIzlHKY5GDIOBJQRWHEQ4I0g15\n", - "eAAgAAgDA4fhDeoLQdasP+kAYPCAAImBXBAAR8SAD0xzeqF4lf3bpkZARi4oQUU4u2jtPnK/3PX1\n", - "AAbTtOYv0ONDORTlEShpo3OG1F9M1//UojqrPpff0OX5hL8KwBmbvl/77XxA4xTnx++//+AwJaIh\n", - "Z7a94KVFM/swK+5JD1SonenWpXa2378DC6wgEhSVDjRsfVvwm4fv1Y2bI2YCEOQu//PUPbTX++f+\n", - "CC8FQuqvfOr47nrFXaOnE8//wzkIN0AmlF/Kfu/Ezzb++pTFdp2TaH+JnqgU+//Rf5MQIDXANEBH\n", - "1JQeoVEr06xLDLCVwM7TX8+dNr4zmipZIHoNJREqu/+85zMnDboVmf06KLdNeN8gKjjuM3gh/tWv\n", - "cGGUCQAEABgpanqIQgh1u/2wQewCAA6DB5UmApYudiSPF98AsYDiohHWTEukGF9B/3gAQRAmPQv/\n", - "zle+ZUr1wQABIO8oIEZBqeYfoAYGHdNwlN9YCA18IQTSYH+CyLlNv37vKPXO3VMfyGju5m4KnDY5\n", - "AnPbFkXnyQAAAbxhAIfgBkAMnIDrwtDIgKwAPcDhp0MUqs//9QYIgO0hipCqRzUMU67XGRAdEcAF\n", - "4pWoqapEx+icP7whC8ABBjPLOLcNc6sXWcdW9UiSIkQkRMGHx1swRUZsxq6qt/f1L7z8Z8BMy267\n", - "5oAztfpv79gTo4EU/0Yl6l8TDBoRhEOwwHAAEBIAAQFQAMBNMgA4h6Z5TUFkDWrqkm32itBoFhle\n", - "Rcv1iC7bACE/NM/YOwkl66GADvgnIQDjMtj3rZuxDCA0hQgBOPAUcVxan9WGNFpj9vIdf/vTTspv\n", - "9mDzbt8rYtXFUSRDRA9kwD8gzyPTP97m0ZNgT5B6tGtAH6haJaOK8DRf/hE/4jA3Tue/A7RzC7Ly\n", - "Kf9itM+/qhAiJG9IAAQBRA3ObgSIlcCs7HN+A0yAZwL2IHTz1QyWT+EBAEMfpI5nHSGg3Z0DDRwA\n", - "GyZmhNlK7MoBoAAgiwAAQFAIBGbbgF3UAOBJafpuElCJ3yacvE0GHCAFBUBAAFghC7Y1RUp3OUVf\n", - "3CoHzit9v8tDgU/yINSOZT+L9Y6AQCVvWgRZZYg5igJkTEIRSi3/uJmBJNwVphxJh8rEY2iH8JAA\n", - "AAFxYQCi4AZADJyA68LxInbikNgPFomARxhCCRdjQfR8ICxvyCCx+AFxQX1YubW2gMEHdxbwBgcg\n", - "kV7WPfJgLTpgJfuJgMVI4QoJnKar12N//aAYA7g66pNe9DDJVLv9rMAVsvASg4G63KTx96ZmYRf6\n", - "cIZ7rQByEFf+ECuLkfrNL8AACACEsFFmcqdJruYAeAMP/9SKCQ7GMcr/1XiCMIUxxhynDBWTYXcY\n", - "BkAAQasam6AlB4kLEf+CAAIAAoFkAkAAQBgAGCQAHmAYQyreSgmsgRQjIJJaBESXpSmoeTx62fzE\n", - "bFBgsgP+AALCHbjiBpjsC/79xWwAJQVK7nADU5BJk5o2RzE5bAb8KBZbZ/wbL8WNBCbEAg6aIAQS\n", - "ysaASMp/Qt/3/qwAxoKvBvBZL6kLhDUNVnuMTM5bgAhsSmbSa97/hAACAKAYNKBAAHgHCCPhqAI8\n", - "E5IDqGptdsfPgpg+gaVlyA9f3ZoHLsMXplX//qSAAAAAuWEAveAGQAycgOvDDhmEBuAAxwAAgCdF\n", - "QAArDQBExfzfYwADIcAEaIG5lnvDgxV8vRwFjeJYykLWOTQ4AABARktAAEBIAC4AgBuGGAAAQEJI\n", - "AAICQAHRBRz14aQwIACOSwADah2Nbnsf8oAS5PTp1rhIB1MXfUAFiYRyUpGn7XFNU4Tf//c7bqMk\n", - "A20BV0EwIfaDa8M8iggdUAdJ/wz3OAvJC/P8AtFR2ROTbv/eA+ACBL3dPfn/hA6gAAAACmHgBoAN\n", - "HIDrwbwAAACEYQb4AaADRyA68MLhgN8rGiENYSPdQw1yGzUg+vnAdJzmSfsGgnz2a7QbxAdwAEM5\n", - "xy3hi6+03xwq5eQzAABASAAEBQADAQlugPNmAwCGAFQkBL8maA5rEPv+84zBuu/9AchodMFU5qfU\n", - "8xEG0ogordoFPkm9X//99MJnHH+lCNyH4OJAAAABUWEDbgBoANHIDrwwX4jzhQOQAHRGngACAua4\n", - "HUAAIBSQAn/3BOBtPD7IsrFtAstEpgAEODJtmQACY42OAAlCAsC2y8CNB1BAACAsAA4CRYIAAQOQ\n", - "ABAaABwEUgzLlG28DX6B0bD3ngJW6KlAOrueOtxAhojQABMccV48HkIaxB6CHwwy/DUU4y+JE7EC\n", - "AkNwAe+CQosoUsz/AMA5oh9EspQn9sCa1X72BF4M8PiWmwmRCM6fSqCaNIGIiH/0gjSHKQ0ZdoZL\n", - "hACQAwYesQhvcIFdmkVP6l8AYAAgFhndBF42MbnSUue6CAqhrSNZyD6QZJKt16EFBBWFXwwgWGVr\n", - "YifH9ljqnlCECB0BWAAgcJBXx9/3YCylhilFjDN78DWxVSoM9KIHC/gOJnriI9/Y7Lw0ywBlbUAo\n", - "u/fAKRewjKSkT71oi+iApAJpunO0Jbm/4kAAAAFqYQFHgBoANHIDrwugLMIiT+8EXj4E8AHsUq63\n", - "b/v95fcC0EIkQEAxGgKEAewAUBjz5AExDRUYl5SAFBmGJUkwSC7pBjyWCkD/M3VxJ3wHEjqcqwWk\n", - "MZ4MHlft1j/+SA4MIEABCFlpJgvJsswSKOufwUN/cl8/BVz1/YBD2pxPGBqKh57+6wzDM9eAHH5X\n", - "3394Afbkv7+2l/xIgRPKBQtRBQaXONfevhlndlD/4Lscm8WPvvQcv4kwQEhAeN/AAGAxqXEoZ4LE\n", - "HWbnmr65GTE+Uiuy8BAMTIdGsvMyuWTP+40gIoBgzsW8TUIo/7fjt7P233FIVV9oUpXP6GADVkFq\n", - "KlSE33QIAWhKu/RPEWwGH4IwwjPikRHRirYKFPWhx8AYKWjZNhV133wQABwA7hYQABMGtQaR/PO1\n", - "b3ULwR0ENIE8NsgnmrdTX3/eOtvDQWA8UnDRfROJMCmMW10tkjNJfT7uqKzZhzKNZIAAAAKEYQGz\n", - "gBoANHIDryPEwx4ADkWIdlBHoGJtvuf9+z6hUtJP0sSyRVAIeGXgBFr88oQ8O6ktkQQABgAcWWCA\n", - "AEDMAAQPAAwBnABUrKdxHQt9Aq8ggmFiaBHpewAKaABqnYAxwWfqUOaBcJBoTAXveFmIPlEieOE/\n", - "DM8ouAC0bCl7xLP383HcAWDGt8P+n/if9BCIhrAAQYz3jO0RQrD0HXCuhmO7YMYWa/7+QRMT7AA2\n", - "sTx4pK4yAF0zvzwbR6AByBwVjtpxPPoIBEMQ/89AAMMiFF4UQT2hoM/BBoeBGZ2Y3ES3jYXAiDgA\n", - "ODBSbG5rGWjFjggy/B6gBuLCSJXHB4RZCKb0AQb79EapBMNl/Bgbfy+Xo//Nj9H/DIB730f6r4C5\n", - "pEG5N3ZkPPF9W/9cneJYVkC/ghZnCGtZUBOnEfQ/GAeRg/qI00qRi4DmyAAZQc00Q44SJEsf7+o6\n", - "ofnrgwgACoCGjAgABAgAAEB8AgGwdaMLkPmKcpRiHp5xQHKHP/liCNqyBfmSnW3tZikRZYFbPBd+\n", - "CdBQfz/jj/zwHQHQswtU1h/0pGmu/zPCWh9l/5ghDfGo0hf7ZOxDtv/XPbfcj3QWq9v8PgkEUqqv\n", - "XP8AVHKfoa+qxvwBhYVLEhOocg6geUspwA7LASDfeBgFRJo1oaIqAp4gWmoW7pP1u4GUq/jeQQkr\n", - "539GNVJ7v57ekW8hNkhoCACIwAAgJAACArMQABQfV0DDDMIAAgHSwAAQWZAAEDF7/kBgYFkgKIBR\n", - "OvkF7Hp3gYBGAgACYMwPMo0pJ97Uv5Ie31wTJVtMf66w3QCuRyjpUVQ0Rs2H/V5cJvTaZDZvSYKu\n", - "kIOMFBkrBsuopPGmCZIAAAGkYQCH4AaADRyA68LPDIg9YAshmfenzf/+X8ICcRDWSmC0QWgWaNCx\n", - "/6Qfh5fqD0Qx+AMhZ6LX/7y/iAoJmEDeAAiDOMQxJ4kkN/YclDuHpZIAAQEUCw4s5RBK4CyqHNI/\n", - "OSV9R7TPPb5JviUtwALQDE484wCwgr7VL+r8ABYAGQIVgN4J8sl6pdb9/fcZejSNNXIBICFVAQkO\n", - "KPMXTH2jBCsOO4yQRA0FSe/BAACAGACECQgACQB/cAQt018azSX2m8O2QI+WaQ+iL/tYNu5wn0w4\n", - "oEF0ADiIbLqirvf5TJNGBv9esFI74JuoSl/5hmLEH2VCW0yxwa5/x+DwvKn65H78/7EBeJDsABwA\n", - "hhtoqpmFnwWiCtYawNeAszACxgaVtsLShA6GzmICD32lKqtc3lHHBgCAhghZzaPfVNorqgMjNAAA\n", - "QD4AKILWNRmzNjWyP78AgGGA4ABMGNdLAA2szA206hH4oIBE9QRADEJBSKoDoR7S/9v2dEC8VXUi\n", - "+oPjiA3xPDAMC3XpCtyOizBlTrgB0oVDDzEMXjJRO0M7ADsY+apIAAABX2EAouAGgA0cgOvC+Ecv\n", - "mnCwkRFh6dgAHAYjqm5B8ygIdsOvgj6MCAKQHfoi0wgZEXH/nAH/QFmAziZZNMRUftBA3gE81mYQ\n", - "jMIJy/doAGAUugu7zrOGdkCH993h9yJOCYCoIRo92mnwB64CQv55EIwnY4hBBzCDCAFHT8yjdHIJ\n", - "YwF//aAFcAsmhUX4OOxWfggRElBAAHgBQFBEACqHiFYpQINaszKAFyi4Igas70ek6wCaQmGqo4ZM\n", - "thwAF4EDvYvg4TbOY1VpwBgq2agIi1RRGoXSmXPKN905IKRQcvkQPyM/htgxioewAWgwcO1k+0dL\n", - "Cy0/f1fVAACBTAABA8AAEB0mqdwMDn+NbGkfNKsiQySMN4ADgAPCjFAehjsjbkJi4FzY6a2WRtBA\n", - "AHgDiHQgABAHAMW4TN0e2ehKbiC8jfbeGJuONHc12tc9KBH+9Y0FKA94EIyMkDbqCLMJJAAAAKBh\n", - "AL3gBoANHIDrwxiQ/h+Bu/AA/DBJeFEkyokMebw93uEAAICAAAgswAAIFQHnOoDFAwwACrgJAWbj\n", - "5hBYAb5ZJ0P+gDtYfZm0trQFxvXaCRnioGlJIk8rIJ7/gF7BugGUeeD1LC/E8J8Ra3aDahHDXgzD\n", - "Bf4gDUJVfXzsiWuR86Vucd/ngOdBPan3v/VnIDPrHi1vwxNNLB6MGJEh8B1AAAAACmHgBsANnIDr\n", - "wbwAAAD2YQb4AbADZyA68Mcb4ACMMo5bwplkkNfuioqBzogABAQAAEBQADAABAHnbnhAHYAOZzDl\n", - "PDFmSo7+9KisHW+TAABAQAAEBcADAABAIlsRAAREAIAAgLkAUWgLHO2dkmAaBXWkFSZpg0MSPS0a\n", - "thOY37QAhAhFgnpYo2kIDtHYBCIkt+0C0wBhHLUFIvk0+oNhDDi2glUyc3aDahAQIDGAAiDh1I7C\n", - "TyfosiHogCAa3Bi7CoUn3ca3gBJgQA1yUHAndnTtQLW/sMISEoYABuAT/gB7kcnq9+C5exNKt3t/\n", - "gAOxCQf+CIrkoqwK6QGjDBn+X062fIMSAAABHGEDbgBsANnIDrwwwQwQBAOShAEgkAA4jjTR/w3U\n", - "Bh+5S12npo00r+CCq4RjbgBBAXaUojeX6AU0qeZXW3hrHBfwAU9FMdRO5i+hx3hD9fWeuy8EXQ6a\n", - "/L50FExKHjcAIbdd57///oYAhmM4sJX2eUUN+tpmgGkBaLSoZljeG/whdPpFq50b+DFxXQ64BmcJ\n", - "129FtoxKvrfMAAQQtpgABATB4ePXu9kAIsLLMHXn5AzAsCZb4ADCQ4XZk4ra+8i51/3BKcwQR8Vs\n", - "bYqdOqZOvTk+4/+BAAcHwIAAqwBFhhNKnpCvRmY3wQzCv/AzP/TNiDVauC5xwABakP2Eire5WRkg\n", - "bVyOQUCGYYlDf+rBFQ73WB4gpkkcKm8jN8SAAAABiGEBR4AbADZyA68LrEiT0BHgDC9X3/f3AA+M\n", - "bESu/03/+XySiGWID+ABcMGwL5st/uFn0//9AgwA2InQrKq/wAVALMBxA/fzRcRTuCcCUAb1pYoA\n", - "wUeMPeeowIWoaKIyLbWZPgglDAAQAQRLvWTjDSU81RQYDZCAjToAxM18YiMp08bESuncAFObVmh7\n", - "XgBm6ZEdRD8wB8X3x59GkmNKQDuKJY9DmRajR30Bk/rCMOeAA2TNoTZSqzKVFCFLmtf+/gA9Nx4r\n", - "Ux0dNAiChiqS5KPyJeAASEq2R6S9sDdHKGId/6xACtqXAKykHa3W+XwhWMNcs49RYQmysnwAAIBp\n", - "zIAEKAKslDgVGVjH/3AAwBVDQYuVWWnrQhIMBp/3mNSloAAgE1+6IA2Mayvrxhxb7sGzZNkn+ofa\n", - "aa2TTbzyOIh3YjiekIACHcaEAhkus4ino40P+0oAiSSowAvgSXf8wRtHuO9bW2XPzsTDCrT39xE+\n", - "fpaBhthwMFILnNr1nf+qXyICWC1//zkgAAAC0mEBs4AbADZyA68jwlDHgBYf4HnoA4VpYAiOJbZ5\n", - "7OoA1oMNRDfWAAEA4AAQGZiAAYCY4IAECKFhAACAMAAICoeCGAHgymYVqndeAn0cNfcABLDhN/7A\n", - "A/IAFCpQBTw4QSsd/wEkwpixSGJfAE6hiVn/vDfPAAESuAM6AAICFkAAEFsAAQK7zggAEdzggABA\n", - "QAAgEiOFRiCQpwFZVe/BeQBFBRqbxQGE/q94+GZ64AeDmq63P+6E/TMf/PwA+2rufHWHP2f99idI\n", - "MiQzDWABCtadk2v5llGWNCkjmKKzANeWER+R99LHk3NQBi92+APAHwDobkm5xQYhiDDoAAICumgQ\n", - "sLUmDcqBjv/cth/hU+SWSSLZuAZBd/NEFysV7Mvf9oNynhSxQFsSy31uhhAJSnhwAB9yBcu0LIJg\n", - "+BrQzOAD679S/+sfqwlN3uCD871CuAseyTDpwRBoIL/9D8AgswktAGTQukmF1JD4g3MCKSWNcCvm\n", - "XZAQghhhBC8SEAAZAAYSLA4XQqFEtKjjqA6AFaPJnI/wWwBmCjkWjOniZzg3KviAATL4AAQBjANC\n", - "rw/DMwAAQEQABAUAA0AAQCZYBbDCQaaFEoiKZmMXn/YYQBMYwQAAgBgHCydJaHnMQDIOf+hgMhwI\n", - "04LdBH05/x/PUTPOjc4DOLz3//fP8iJ/r6L/xAgQG+AB8C9LTrCEQ7//bYV6iBozUvKAAfiL8jKu\n", - "u+cDUDkBcT/XlCA9gTXjYACaTGuZspVZFzoq8bKiGD8EcEfo7E5HP/3+9D48AB0GDyxMBSxc/Eoe\n", - "K46QwAAQEgABAVAAoE0zxAjiEkAB662USQ4WdifS0ADBwD4SWmFC7cn9/6IAAQEQABATAA0EwnCA\n", - "ABAQAAEFsAAQLEBkEBDJJA66kd9hAVs//vBHqmwm8O67oDO6wRL94ZhM4gA+eKo5BDUwQKXEMgIl\n", - "RxXgto0kuDJIAAABlmEAh+AGwA2cgOvC0MgcMv/hADCGYADoBikFEJEw7LuBh//cAEES4rbHdkwV\n", - "iZB3/9ySQS02JSnpfrtGF6IlaE3wQABkHErhhJwAD9g+JgyC1rE7fT8btvvB48Sb6OAFV+SCeBdX\n", - "MyDJFM3gmwCS8K12RP79L4YAw4vDIILQZRatFgAfrLDtEiUwfgB4h9YRE5+hOl07r4SgwreLrbE0\n", - "HWut5B0zrXlptzjkQfSGKZy3gABUXZo3+DRmZujJyTz8EeYD8eP6yi2qEACMwkIIqUJt598Utkh2\n", - "SfgHgELN7c4ZxRd/A0gGC8C9c45HXN3wIgxLrE6+CSNgaqeVDBPoDgha9tFpIAFlW3okbl8xYkg2\n", - "EQ7ABgHm4wYZnS9hW9Jtz7PGKsszUpN//JjYeaAIWq8BcicnB70RNoMpAtKuK6EHF3hcCqAOxlXb\n", - "FdcjRIEDuAB6BgpQRpPRl8tr8CgrggAED2kJLNhI/df5Z6SVNSH/syPKZjbH+Gxh0huPhFcoeul5\n", - "Z/P0R2U/3eY5Q+vQghKQqyRXzkgAAADDYQCi4AbADZyA68L4k/ip+oJWVOhF620vulEAgEh6BPWl\n", - "v2AuAgCPnz1DUAWqGLEQfD5KTMAYgFmq6rqDNWWH6vJuTaemRq1hhJ7Hyq0ohOeMAwV8uQADmlCy\n", - "oRRtQVeAyDmEWJRDSA00ZoU1eXkYrTHFQvfAvwgADYhqAgABAWAHBxsANbDMOpZ169gdRGp17gL5\n", - "n203CkV6S/+/wKYACwzTnlBdihd9ogiCrkgvBSAS8RvmTWY3TxsTDYQWv/8EvrBIAAABN2EAveAG\n", - "wA2cgOvDCECYkK4ALRhmJDnJdz/1tAZgU+HjRVV+b9AozCx6QOxU/PI0iH0hHM5fAABAGUAMB9tZ\n", - "DkVk91El1PBGYbkVRGc6ER//wgNagcNwAPaEq6tlU5YCW/uuSIo/9aS1TgjX3eHZWAB4LhZh0EmJ\n", - "Wf9YNCca+9dcp337SZfaQ3xuAAjDMUM8KWTJjaN2TFoOPMDgGxCQmDXPoZ/1agACAh7gABAVABwA\n", - "AgDPrnvxawAeAEkCa2JTb6/5ABlCcM+TNEiDBwFTQFMPCngACAmAFDJLBoU5Rxf7X/GAkHAAEAio\n", - "A8szwAWBaA6GFVQBcHzu8ByDIeVTJU/SLwIRnO6m7wAA1sGQgJABdxrHftFgGoRz+XoAZsErgBYO\n", - "U4MWMrObTrKGhoNo90rLVHy5FMB1AAAACmHgBwAOHIDrwbwAAACqYQb4AcADhyA68MF/E4YhgbgA\n", - "RlYt5lOJS/iCIMU4LYY4o8NlfD0wCOU+WAIlqMti6LzAABARAAEBUACwTlvGMc0Tu75Fk2dZIiqu\n", - "fUoPQdZghA9OHkwhDdQCY08x5lBaKUdH7jLf4AOwnHjddjk+4AnHNx8nOHJocu/FexmHa/u75g3i\n", - "A5YCHjfyo4w1DVBKxaun7YzfhD8AG0fhLHfv7gVyEQ9jgq67xIAAAACuYQNuAHAA4cgOvDAR6/Cd\n", - "+cNYgL+ETg84fAARDn5HROi/Oi/ASPLP+/Wn4deIDEgkAA404NFeWIT3FL7H9j23yTknfeaAAEBU\n", - "BAm+2BeoSWZyVIbfUCAI3x8BH5ioSxrJvBAvaeOCWUlt2rpP2QjR99+5ZbBAe8DAAN8DMAaty0/r\n", - "yimCK1Ybkb6YTxUJk8CjogEtHp+/nVd4HwjNApgpMYDmhPuzUTQsJ8Br9+SAAAABemEBR4AcADhy\n", - "A68LifL6iwgLCIlDcAB5x4nYjmhX//++MEYUlqDDlEjUVlE7EIBQSdtYdJTNaR3wYMTH4QYpCNfo\n", - "gX6o5OjHgAbSHYToVR+4aCDXt2EssMJP0//8IAAQC7aAAIAYAmI2NACAwywhC5lNEsydPom43wgJ\n", - "agcrW71jKOQwqSMWvL/wQASlgQAIGQ0ATdluNcV93mzd8A6G8Q2UXUYfYkPXWcgJsAAB2FzocjhL\n", - "w/CPwoRiMTMEQrt+0jMAknAsWZRrH9zhuJvkqSokNmiGkJCIREnoBMdbA6le/gCW+cnf2B1K9/RI\n", - "OThWJqrbm4DoK9i5FeHCeFkR2AANwOlmjQ0//eBFdAIU0LyobioiYGdAY5Q02/SCyQ2UTV33AQ6U\n", - "BYvnpztIz3JGDwDFJXaPGTvnNQilNfDKABRKFuLM6F454OdAkdUIgmNJfvo09yyAEYxFnC6Lb+7i\n", - "4uA2Kwk4mFLfRF2MHlKDXApIhHbx8YHrxkM5SQAAAndhAbOAHAA4cgOvI8OHDHgAV6sVAAoAFUzM\n", - "AbCZAeZOW0jAj7jBexqve1N7+4GK18BPuIFAojgMgl4IAAuEEfCAAECwADgDRLAFx9md88CXSWWA\n", - "AIBbgBA7/WAAWB1PAZh41Rzf8BLBCLetRdcAAIASwDo5f+wIpg3/AaijdagB+gaIdS8oi7wYRIzC\n", - "AAIhSCMD4e9iUaVPPvwFgigyeivLUD7EzwMh8MzwEXCRzYAsGNf2u7/s0gBAYtulP/77E/6CAkRP\n", - "C/iAkEB5o56M7v83/UgjQeb37PAGTR8/MZx/93//QBzxsTO9V6neTG1YtaggJDEPwAHDMFFCvmck\n", - "uzXhPxf+0ZhzoQGdktsT/XrgwUVdTcUkUaXJeB0OgCfaVvBYViXxYh+AQpoxbPvNqrJukuOww6gA\n", - "8AAQFpAAwDxXeBT80KA6bDM+AABnYBYWSrl2eV3wIJIaC8gBWP+Tp9zlV8jL6jYIAql6pygJsYmV\n", - "S19ts58cvwVBgZGxoagWSkpFJWeBldgUcVCc1HVIuspBj8MIAnMcIAAQAQDBJLwKrJgK8BGi1n/f\n", - "8BSdtziAu0MAysMCeHXhn4DLyAAyUgFAtM4nRHJiH40SDhLbCAJDEuLNpg+U+n/02GLFEKWoEccJ\n", - "Pgf4/nkFAibrHy5O3vPb/W/0VhhvtYQn6ISEh+aaRoPUXg9smQ4imU/zzHXc5/AUv6icQCCA0ZYB\n", - "44GL+zrKhimIqf2MwgAIwjjkNQaIKDaHDgodsFPwABAQAAEBOIkACg+EbYr6SGIpBkEFXid+jl6A\n", - "FuJ5SWFb5kb9dAMenbpwqlLH/wAP5hLFM8G/92WuQK3Tp/MSAAABZGEAh+AHAA4cgOvC5fCPxAg9\n", - "AR/gB21O073VEYIJRuXY2CAAOMLwWeShSX79IwBQN0EYklN0pSfoAdQARAKooayscg2N7eYAZUMD\n", - "pB3ofXOGZ+4AwgIScvm3cNxFrSf+0BgDVCxoS7XtLYHAquCECYKBgAEoMfTJZQ4AWMkNGtZ/7z4A\n", - "uFvqI6NswkgND41MZw/hGv3AFBdRVLa3lLuy0WZDi+kWYLt/hoQuX8gRJIJG0AoBFcVvqH/frAGD\n", - "4Eoh8SPoG4ywsN7PMzAC6vwABARADT/1t4GKskGeUoqsmivt34i2DAABAIAAEALw1M+EUwhLFmHq\n", - "JGJqrI/qbcRTDVEVGAAICIAAgKgAaCL1gFKkEk08LjgRSsUaX/169lrx+DFyCg2AoFsRtDyt1R9w\n", - "4byluZzqF+ocZCjTWROOb0awDtRg1ny7n/YtBYjlA4zaFffgRGKt45l8981xmKqu+UOa//yQAAAA\n", - "vWEAouAHAA4cgOvC+EQSYaT8P7L8dGpxwdgAIAAwMYw8rXtNMWAAIA8fAIecAAIAsACuwNgUOQLt\n", - "lvGJOlqAxH879i5p/+05/VwcbhlDfV4RgwQpsqJSBNqiUnvAIU3CpMralYududgKAZFIA2U0pA/f\n", - "lyH/oYSAA2HCACAEQFAA/HSGUngPaqw2Loxc2HHR+ghhzJAaCLfYGwAHG3BK9dklPygGWwTQzwbV\n", - "+wGyPRXk3chjQ3z1//gGKadgkAAAARJhAL3gBwAOHIDrwxiQ1y8i5YnYDc4t8gNDa3X2SS3+oMqz\n", - "9r/KACWjWXH//JFoJ3sOj9+qr4Wr98IN8bgAIgiiEuC11MpkBop5dfEKA8EBMSbJkRhGHF8YAAEA\n", - "+UAAQEgAJgCEl8SgACAjLQABBcAAECxP8wCJkaht1IpHX5gBEC+N8SN8PMnQUuL/fHF1vUR1sZdA\n", - "ACAkAEDZrhsUZFl/teoIwTKMKASD/GGQ1XzAIQwiW3Gqqqf4GAAO5hCAAIGDkACtGD9NDTyyHHUa\n", - "oh2NzwO4IpJilIOn2CQMdq8fhDcOsALsDFUFRhrRPJcqMCwRwL78RvXbtALgrCAOIdzD6zSpTgGM\n", - "srgY8WTcZMkERsHUAAAACmHgB0AOnIDrwbwAAACWYQb4AdADpyA68MGEcRv/w1JYA1mhUrkZzdot\n", - "gtWADBzjwBAbKjF/2oEDAAglo2tkCFtX+C0D7x1BKpPJAltgJC5AgAgOweABWozRbJHjmgme8X0T\n", - "wPwAHIVOuIaXyCVu4yhDBQlidvGFm0+D8N4g/jyxhHhuSBXzabxKTu/NDCNhu7ABcazErTrP//u4\n", - "gqlCiSp+/0SAAAAA02EDbgB0AOnIDrwZYQDmAA2mbhNlKrMsMtmLxsvvl84QZELSG3gJg+oDHASw\n", - "leZQABACAT6OxEqvMvhAAdpQrE0UPrgmxIBFt+DGTyiSlkjl3G2ezaAAEBX7oAAIDAAGzBD/vA1Y\n", - "wRrzA8lM2lOxZEAASBjHFbeABY+GvCD3B0qlIFQwZ+QyiKaUY1KBb5hIiDAggCzlCAVGIAk/dqCW\n", - "SziMj/sDRV7kyoo0SIRFZEqFe4AVAD3F4VC7a4ahRdesA8MCVYNjjeM3QNlIGCkRcLYSgEgAAAF1\n", - "YQFHgB0AOnIDrwwbxucJgH4ADBzDiFyycPiSVamS+DSEn6gGANvLAGDv1kIBTgfaw6mXL018Dlbk\n", - "AH2AccHOARJmwfI0eeJjMScVFoi3lfusx0ISRMpmmNfsCoqRvPdRLFeNX7hAw0lljqdmbJHyBaxI\n", - "DQAS2Fiv264f3hILZd6TFQU0p5YQCEJQETAAECIAAQGQBokybve9mOxUQUvQ2ywDzYVh0yuyN0hg\n", - "icVC5h3AqQAE2BtYUExI2ymuYUBuryC3hw1kLrOQItYuOE1qj1GAMxwM0wLdBP04GoREns/wEbff\n", - "3/QkSGBIVjQ9t48lvk++wBE4Px15KBA+5jbDZr8AAEBAWT2KPFitlTqkyENjwhF21QX/sqI3AKXA\n", - "w4CgcKjHpYzIH5qwr1uAjMhXAHAEWF8ErEKBy+CgGgcIAAiAQ8dQplxBpIv+nQAJBqzXUmRomnSN\n", - "l/SGCBvQfsYXppRz1Y8dJ4Apg4Jdu06/739+HfpyQAAAAjBhAbOAHQA6cgOvIX/4KeDmHOAFNsAA\n", - "QQwABAQgCgTEeueJYhALEfCRh1gAIwvKQpb4d9gAfW85FLP/eA0gHRd0NcalDlxg4hvgDAAAICYA\n", - "AgJxEAAWHyeA0ILO+VYjZZ78JxeiJeUwv1e8dCPwQ8Igg0EBIQnnR0CR6MtrH6QEX5Bkodtz+uG6\n", - "ghCELQAeAAYCLUAkYrsUqIf1WiAYn3OfB1/gn9AeGZmSXgVaBj/euYAGAZiSaBotLtqr8o/+8MAC\n", - "TAANYoALqwE1N93+DDWSCAAkUHAkIV0L1LCIijynxj9UUmkGjHhTHCxLB2+61//9KXIK3fL3sC2A\n", - "IpQEJGlMtETj9HM+vB1BBnpx+HEfrw1AEbAgT/G+sBltdlykehhziEHt01qKeP1VWaL/e/ql0o41\n", - "/vaRAgZUQUU7bbb+//DMAWGYchqTBJMbQ4clLsMOAEITM5wZFJGf+mfU6nHtbTn/HfHvHY1kgNXC\n", - "QVXDwLA8Gwv9cQf/Hx9ADIOvp+4hf1j9frECRvzMAJACJ0Fc2r4hplUMOMg4MLwBwAAQEAABAVmA\n", - "AKD+dBGQAToAU4PNERBOerwMFAACAjLwABATAA2IKv3oAWEcO54SusCD31yUlOUSAAICNoAAgKAA\n", - "XEPXNwsGGo80MBIxZpGNY8/wHkgiDBVgpUhZGzIPH5PXeAFZOaz/+uvgBqkswxSAP4GdeKaksb1N\n", - "efV8au/n0W2vGnacI2mLO4DoUJ5+IqzeJAAAAYphAIfgB0AOnIDrwvCIg8tBihXgHgJVrz+v+NP/\n", - "0NEiI3wAHjFFRqsOUzFvsjyVm0t6mjSG3Uis/fqh7hv4koksUvfOIARcoxpw3naoZ4AAEAIEc1Zo\n", - "5wiiBa2tih/9wIgxdb7wLoX/k0Of+8BnBe2T9AIiQkQFW+fhgvOGR4ign+B2YMDYIAAwUHgMAAmb\n", - "GcHJTN12d6c5G+YIgeYy+KzN7vrCCIpfMNLUFv94BK16LcREksDRH4/phDfakg9pN7CsnDEmJeDb\n", - "eERsABo+o5IGOqzRKgwLLqx5gBYAhFnONWEBrK+DwPwJx9Z6qshZCXzXDsfKUF008keqA85mDL3V\n", - "oA8BxfOzbHoPQEUAPGoDjpZSJdYvvfAGYADhIxVjvpHn9MpJifNJEZiRbvBpGGB+IBAQdzYaIzJe\n", - "Su+8IAAQDQAYEnAgABAOAAog6GUDPWZN87nICqugVDx0g9tcW7vOOxKnX4DVlYA+RgotH/3c8DHR\n", - "krR87oBugcKwXEutajnNzEco3xxbiVEgAAAA0mEAouAHQA6cgOvC+JDmAA2Rm4hZzqzPDHbYOANe\n", - "+ljlQDfeM5Ih/rznL80fkMNgAIAIOk1DS8KOPYBgE7zbwDF5oq9+XQYRw/q1e9KpvjQMwtKrZyrj\n", - "e+eMJxSngNXUygRAqPbLGCl83fZ9NNZN/9QSMOsy7HK0W/B+BKIEEx0oYvxP2f9ACJzNXhwlFL8b\n", - "d3wwwUOBEASBAAemWydBf/z7gmeNX4eYp6aGikRbSJh31eUVvrYGsE4iTV3jTWd39nQIziowQgt7\n", - "fn78N6b013ag/AAAAVlhAL3gB0AOnIDrww4mxvgAewujHIUonJl//9wALUDcHVk6O4773tmc15ab\n", - "fcMBiPFJzY3iX1oO//tIIpDldz7sO2+gu3GyEroe9ARpGTE+Uiuy8AATAcT53+MpKdMEp7iCKw7l\n", - "F9dvnM/+y/zPezZ/cpTZyg3O5YNmggET8AsqbQLh6Zkvk3/zASN110sIm0mna8YADJbifE36BXyi\n", - "/+XrWof9M+16Mp57ebZ7A3xuHABeMEJCCS5cQF/N6PV7w0gAAgHAACC2AAIFj/IAIxk8SxCo7IgL\n", - "QQ0GnBYKmbFMyqHn+8ol7STbbjAABAQAAEBYADAQlsIoiIgBAE7AQQf68GAw0qlSgQXUoQABcCOC\n", - "gd0SsGpCBbmSDSiepeuApC7TRMaP9tApX7jJX9JYEYjHBVygIUfZSyGajvFZLvGXt9AKbKYy4vCJ\n", - "NQcXwELQXmDGFDLxBybwOoAAAAAKYeAHgA8cgOvBvAAAAEVhBvgB4APHIDrwwFOTWaXW6zWa3W7/\n", - "hvEBqVXegwNQSObA70RkhtsOsz6w0hHjYA6MXiU1t4AfPIyMtxcoDDH/Eog78JAAAADOYQNuAHgA\n", - "8cgOvBliA5gANShqhP2z90hs/DE4cJfesfnfCA2AAgADAxjDygv+11MtIebGcDAARiZiuiDtEORX\n", - "KkPwQEYoYXCuN1ExMtKi4Rc+Zt0SclsVpevcnfeAOmAASiGL+geRzKAx+gBAeG0UH+OVyIQtaBAQ\n", - "fhoOUHFGAb9hhy9C7QbQwgFJQgACBQqACa9Hn38AQvyT0m8gyKSxw3uv5DUeoE5inAHpayIF07cB\n", - "sWzmZCt379gOgSSQbGFdKI2HNsAUFSdz/HsE1iQAAAFVYQFHgB4APHIDrwwX5IxlEg1G4ACBBbJo\n", - "c3RJQvPMx5vkLH07TccX72QgHBJ21B0jM15HfBh4CiC4rxStustSv2X/93AoPajoddW8AuZ+TtD7\n", - "gBwABAFyAzggjAp4XHB8qfKl2vga8TgEAAbCISAHG073x6WfW35s/vgJxTcqZZ2dH/6pjjMoGvu+\n", - "gA/EqFZ50T9/VySQhEEIjinOUCjaKwi0j+zmvBcW2LuS3mhqGZ68Aqo0jv5/AF9w0Q7+fL4gSYhS\n", - "xIdx2bQjsB9sOgSEQLEkEtFPbZMkACQAItESA8mx6HQdQU3+AFglUESPdKb1cIsVJX9CSnIwAiAw\n", - "kgMIlmECMZXgnKzIb/kCIAwIQkAgZawS+vOmz//0MIEhSBAAFIxQewp+mb126jAJGDZHEKUvqjQK\n", - "MpdfA2CxLCvbY51/X+OzTADKlnAFCZ26X2Qxc9wZ0kAAAANZYQGzgB4APHIDryxUMcAChgW1JODi\n", - "cjzIV1QbnhFIKYJwycZPlAFN+G4UC1bckPxxe4QqhT4GpQGNQpgBeVqtBoLagQAAgS8AAQCKCAAE\n", - "KwgAAhIpwAP8UUg2liLBPs/AsSlwD4FbmNTKMACwJAeyB8BPR4X6gVKAB4AMJQRsHMRPemHe3qN4\n", - "gACMhAABAQAAqHQzPQEeAFg5qu9kf9O4AXbV1z9355653ra/n/Bbz/vl/nlTgFVPR/6ic+fXmAFj\n", - "AQ+yqke/7sD63tI//z6xE8sVMswCXq79fz36g0M0qEvKc/X89/y+EphIico2ABZossxe1tT3vMyG\n", - "jOYJhoPm882CDnhFivNj/t7rGpnDUUBOUaCzFY+w1OLKVpGDBgaC/QE4CH8kZ9dBFV5PfgAERAgy\n", - "EtJZAHrskZCQeAIOaMctUmq0J+k7/92AEnEYu8N9Xid/bTBCEFNN6ixK+1b7kfQKt8DNItqqr8Eg\n", - "MwYIAAoAEEiuhQaMu/qlXsP1/EfvVVt+p1I4AHgUy8w3oUxH0sLDbuFHPGa+0jrEEq5jEIf/4G0B\n", - "9RZK8Ay447v2g2U0KC2kkzZW//hCEcK+AMQL/SaRkR7osNIxBtGAWbAxoDf9KDhV5/0H3wAw6iFE\n", - "cednQBZ4f/7gGCk6DqIeWfRfGUfv/BhiAACAkABhCAAEHvgACC/YKs0YA+HaIGqxzgeBDrPA+bl/\n", - "gTGEEKW4B3BpUXgzyPsVAAdaAACAaAXwMAmld9/zuGO56dRPM6Pyj1tCKfz3jOLbfv+uf//5/Sr/\n", - "x3f99b/8HhpG+TP39eKGJKe//7nCcOcABwZAooV8xkn6b8J+rf2mw+xAaSMltie4ISI3mVgAOZSO\n", - "G1qHwjVIrYFBD8+ybEYgb4AMEcw3H5bA+Rx9j/tBSj9BUPt5FNe+YjJifKyuy+GQgU1/EEcaFqpI\n", - "L84RQMALd1e/hIgnN94ADAU+VtsIkxhgwsbFfKIWVXmxSnc4Ye67wABASAAEBGokACA/t4GkVCiJ\n", - "VOSnafu8HAHNgASuqgBBJsUlUNVIICDDiQgEArwNCU4f0wYhFq0Eas+PBiL1WE/kisv1GrRJtMvd\n", - "gGxIJXAJxg98XzPsMwHkEcl3pC6n7JWth9o433Swqo/Tm67+hIAAAAEOYQCH4AeADxyA68LwyIPI\n", - "LADw10q1VP8v/8MCAQcOIuEae4ACGTEKcgj3iEt9bWACcAPgIZ1SganOJUS//19bp3d/+NgJ3AzB\n", - "RAPdeL3m5hMAAIEn+IYsFUTXaY2BAAIjnhAAEAc8pfPMp71IAIKYPrEE8M245rD8J2ALtngVzdOA\n", - "f3/DahGERv4AIApVjzREpTKF3aKoeMAQACvKLsBEEndYH3wGQICDAm3gf7VpgwOAA6ABvAIVKJ0A\n", - "EvgcNhb/z8F4VOYgAc0oTlYeQgkRzSGBwxQwCHGIAOOi3k+P3DFgRps0Ek5VZJZIPcZLFg8AEUix\n", - "7VRM32h8Q1IMxZ5PuHKLq2eCDvGf0bcKvL8SAAABJWEAouAHgA8cgOvC+EQSeAAkOXkXJ0fo7Vow\n", - "ihsAVz649wgC4yHrBhgoG8y8ky8AIACAc5YlMI22a5VNUFzDQAAuAHHKk2xbUyQmHAs3tMABAYWn\n", - "2E6ASzdvgb5wjACOAw7bCq4rKSui5wAASKEhPD06K8d9D/9oEYUD72lVsjK+4/9xiTpbQNgusQ91\n", - "QTs1/5vhPpQBgWi9WUwylv/LTd/6gBhsBev3v9Gauvf9wBwEHI2jtlI745YKf/DbAYQAAgHAACAW\n", - "ADAIhAACBuAAIIQAAgYgAQABQDlPGBBdqav/YPAFIo8ikuBIn3gxgyrN/8+xhcRIT/mkRVnT3wAD\n", - "iLDKIQ2R4p7PRvww+AHj7eIgM4K2o+TUItXcJhM4gcp2m2gscaB+AAAAaWEAveAHgA8cgOvDGJDm\n", - "0ePgaSGXbanXHD/QFf8fNyoAA2L+Z6QADlNZxR+/X4ZOxnn72af8hdDj1f3fSGwpgAIAAIAIBAgi\n", - "RfIPECBF9155///ACPv6ocAoCAgggaIMCjQvCNE1dDCDqAAAAAph4AfAD5yA68G8AAAAa2EG+AHw\n", - "A+cgOvBm4iEA9oBQAExdEKzlY5mcReCgARmfORxpAAeQDpoMKNG9+CYRPL//7vUBcGqhV0XcqXKu\n", - "+GEpGEAEKtiDhxOqApIrEvHwALmyJnafv7vAeZi8KlxWT4SmAYcv9otxV/EgAAABBmEDbgB8APnI\n", - "DrwZY4L4AD5UNL8qTp9DgDr3PTfSngk/OPCXVZSI6hCJG/AQpgpfKHW1lU2iH2gYwwALBkCHrXgY\n", - "TJeKyl8AARgMhwMoYmRw40fHNWPYaa2Wm9WIAcgAoPgX9/noA8QAqeJBtirPkk0AG68Al/UAAQCA\n", - "ADogS/7wA1QAjGKIjw1bwkkMg+AIFnPhA/BKOSEysehlo2NE5P22gQ7cK+p0f9Qkb+710ZATedAj\n", - "MQEAGMHCAAMgSAQAMe/p/nwM08DNboBK93DRtZ5ODO9rIIPRM39QAPzC6UOsgRRFd4BSQPJNFDY+\n", - "9EVn40jJCMFWgk4CmEm1MNtRhkq3W71/xIAAAAFaYQFHgB8APnIDrww3QQD+AAgYYXYk2orOCM9U\n", - "OG+GAGwIxevmBi8P/qBFCHSWRFLKFO9x/+spuIw9thwAAtG08g0AAQAEADTASBUbvG0NoCaYSZHB\n", - "/95iyi4MylD6AiQWtfIMoQhwQuv9R4bLN34NcDAAI6gAPy+Mljmv9m6u9+Aag2grEkXOPv/v0QSt\n", - "DgLRF0WAmT/8AA8OEpHg+edL0Ksha22lsjhpYrTmobUgAEh8aZwADIMGoREnr/CXl9lYgTEh3AYj\n", - "yUz0tb+80aXAAAgDBT6J0AJZLdML+6Nf94GG1ThoTRxzeoiFxIq2siQKGEYYorrgEQbmX7KQRbCC\n", - "P6ApsBQMJRJmZk12iwDw9/fDEaScSwa51Yqs46wF4MIEM1graalZ0hBEDJyF6LZ7wPqnayMv7yOK\n", - "0M0gvhEnekcvueuteD6oATP/81GjGgWG9+XvNRFPxw3JIAAAAp1hAbOAHwA+cgOvLC8McB5k0wAH\n", - "GcqHxBiBpMKcFEAV/FkKsbgcelGZsj+9jrh9ak+ySzxvQCggAAgEABRCAAEFvgACB9WABTZIjiYw\n", - "B7DjFtBpRPeBEiYqrAAdghjVmkJe4QA1YOX3kKAsBCtDah4AdpFxgHwj+pU4meiWOQ4AHFJ6Wj1z\n", - "ADF++u+wEtAhfqVcv5lD9QgSEJ74BOIpJ3P3P/ADrbBSK4/c/9jhCh2AAwZgDNpKgpk+a2eDP+gA\n", - "KAW0mQIngTjji/73gR3eGUhNHKw7PREDEMQQwxvmKUb4QiEOIYzMpPNeSGHD0g+zE4LfEb+/34Pa\n", - "oGEGNgnM+AbLyJEgPFzV2b8zbNmY8MCv0VdJG1//eMCBlvHb9+IS4VgIiyHKyr33gDCxaTEAbNG6\n", - "aoZUEPh+IDodiEzBZo/kX2fYAPQEm+dJdPAZMHgwxAAD4DiIAAIHgAAgQDtbsCWqAZ4W49bZwBj2\n", - "sH+JFx3/wJRGROAlDCQHVwqXcRBHaBh7hoA0tE7tcH4//V9eeUAnfGVq9v+mRfBVw5NYVZFnnaN/\n", - "33/4cgAPGKKjVYcpmLfxfJTbSfADCJV+hx2i5gnu7n2gW4aiiAomjNmYj//AkkefwA8gZDogKgw/\n", - "7b8ER2vTUqjaqlA8ABAQKn3CE0+aVR9xhPMAAEEcAAQFAIBGWADhV3gAKDyGmCjBUz/r40ZQyV2U\n", - "ivwoBGGl4Jmq9gRdW/tTgAZbc1U4DlfdhkxKitGIIh+/Y8ScmAACBMAAIBY0aTPACAZxYwwE0nsd\n", - "t7NYvQeRAgSwWLpUOSOhG02JAwE2YQABoA/wGyEeAJepsh4gUkps7+fbJev5KaIgATdEh2bTwDMJ\n", - "IhlVjDjMwIJ4VK7JGo3+AkObZL1nsSAAAAFzYQCH4AfAD5yA68LwiIPWAIIk+vp2Vvw/Lp9iIgSN\n", - "gAJFHCTOpSxzl4jFFRusKUzFg8vIwV5hVqXfv4vkUzaT8kyNIbVSKzr4AEMxIPygKe15daKeX/PG\n", - "Ltvmsld9nQFNBSq0nEWL0x33fMghXp4g5RY/6zCfgABmKQAXSzAfRM4XWJClkUDRkYOfhZ//9w/C\n", - "AAIB70cRZvCj+e1Hv2izDFXSolzEFuCkNLk7791iAoNGqRhxBH72DwItLV8cj9a5fm3AVOMiBmvW\n", - "uJMD65tnrkGy+JEcTDI38EO4g8p453zJZd1xeGHAAQEELdZJ2gTcafdxPZKHABAxxoAmAbKjB9ag\n", - "BNpzrleQBgADOEBhZMmT2p+x54Z8xK5ijtdaizx/W/COQwUgKWXwmQGCjh4GGFMAgUIEYStUFQ2W\n", - "1BCNuTBJD4/wJMVVt4BBvI45dgecMO4jrz3DCIKTJOCMK5IH7AvIP4TPaivV7BGLhLTEyQOnsSAA\n", - "AAEiYQCi4AfAD5yA68L4sL+ACnopjqJ3PDgjz7Lw7bXgEX9NxfrL7MnEhALDcAB4sAWvBhmMyXXX\n", - "/gNADoQBBKPqxH1OZQdYaQzjBW2donD/+u0aAuY9B4BVC85P+fjfH7G3mADOc4CpVodAVpFIjf7w\n", - "bOAE/TR9plLlZAPD6ZkOwXkADAByrwQIZorfYGKoAKAC/CiDqe5IdUcSJ+DVNCGPlWizneAYZRIi\n", - "UytavEIVLA/4wMIsV2tEYVpVIRb3bMP0VK0pvtabCWGpIU7/f4IAAQBQBKJCAALADgREAb+6WH00\n", - "sZFViAST/Eyf/guYVcRY77t1kMTFYKSvgjf/yABeTJhYodV82xQAzqegeQjx7/f7CjGcRUtPKAWs\n", - "U/fNu//5h+AAAABMYQC94AfAD5yA68MYkNc4AAUYP0D9B2dMeLqaRL7H79B4Au6WynPnAD2RuIne\n", - "30atgIysWf/xEZx9/Ute4lCf/9Q3zcAID1ft33g6gAAAAAph4AgAEByA68G8AAAAVmEG+AIABAcg\n", - "OvDHDnAAQEKaMUyh5tVRNsl5sNeETF+PgBF31dt/hvEHjHwEz9eVhL5XE/lfccAHxshK/zX9/vjL\n", - "RRT2Roisf+DvTmj/v1A/FoKF/zkgAAAA9GEDbgCAAQHIDrwxlDfAATBooZoCFF6JNg6Mqi75EYis\n", - "hzKUZKlpAFA6rAGK9Nf3PjHAC1kNnSeeGsUGvAAo+RNuSff8sZ0/3cIDYfiZhGZRV2pyGt63euc0\n", - "h+4uAM6ggOOjRHD0Rln3DAAEAICCi1gvnrvuKY6Y2d4Bj92QhPfsttTgwf+NxUiDf1c394CIAtms\n", - "FC8TaatRej7xgWRx1ISljvWSwGA/AwyccPYXzZHynWEwbECiCAEowWYukzq2Ce9KIi9XhZ3zn65a\n", - "PzkC3LDVs6pDAIJiwhDlOCnm+7wEoRXBTqzv6pw4B10wGGEISnsh1kkAAAFSYQFHgCAAQHIDrwxi\n", - "BuAAhocdFbilo5bcX8BB0aSIVU1tJH/GUgRoA+MB3DuAfzEOZE/rWnAqj0AODScdrE2Chb/0GBQA\n", - "Wh5VI7MdSH//3DDsuTCACPiQgACYJaAAdtqvr12kWk8AuDNfvELcha6XbU8iX96AF3om88Cj5BI4\n", - "8Bur2iobAGxd0bQahESev8JWH36oRDAkbjttBHYD7YdAaKZdxuwAgACAcOsx8geqW1kQuJJxNwaA\n", - "mkhP3fCb6seWmTeAB7AENKIWACiY3Fsr8OuAiCcy/ZHEWwgj+AAtAAMCEA5AIkVIRRePAVP24AGN\n", - "GPNAh2kiLA622ADCcZqMJOWWM6syqGDh0QUBhPCAEACATgfbQn3AoNkU/sHqjMffACDEv05nIz5k\n", - "nns74wAHAAG7iRy3x56JoI+VADAKQGA0YqcEVzK7KyrtShHbV97f9QkAAAJLYQGzgCAAQHIDrycM\n", - "eABy/HgAIABtdSAHAlfYAiObi2okhYwM+FhaAB2GECNxIQABYACngRgC0Wd2JngI6a/pgAuBD8AA\n", - "7AouB2nDFXf7wCoEK5aORqVACeBcowYQ3wAPxl/gAAgCAAHzrcASABM0whohAJSECAAPAMPf2UxB\n", - "yypzfwwAThjQHRGiEqvHifhGeuPpj/Ezy4cALtW5Nf95wALSBmL5DOVq7/9L+IE4QnnQJSAI/9dN\n", - "/i7ZTf8CNloPcMz3U+8c4GMx90flyX8ICDVDuAAwAMWcM1KnEg2UtH/mABgHJ7MBwQWPa5ULAp8A\n", - "GDmy+ag6hiEooTDD9AABADECqpfN3KX2LeE/d8M0wgEo79BtdEXFA4zXUX/5lSSQ/+fXBT9a76DA\n", - "xjT7kCDUcYcDxnulr7SaQGfhXAEQrWHELCXSQZcdMRkzw/AioUFHvhKivqZgCdNDCGHCIPHCAAQD\n", - "PCgctGjFVY5cVj/DpLf/d/gvBsUMkgTZBU5oNSrmBlWoBjQ0ye/68MwEAMoGFJHiJM8DLIzGTUEo\n", - "EAg4QWZggAC4Oee6JIAkCMbf9wQBhXgemKr23/Hn657swalP+6fgg6/WreXP/335f/EQ5495OuGD\n", - "qab/t8dvJyC4qF1F65/y+uJ4YgAuYzMpHdikP/3+gSgzAQ1Xii4puphg/55AIYoclpAlSDELOlfc\n", - "xs+KRWOxHJ/gAAwoLEu7sNksJt34kO//8CAIP0JNBsDABOy2glsIP7+GZ8sm7/A4AUEWXFiiX54y\n", - "8shn/BIAAAEYYQCH4AgAEByA68Lwjy+EBBFxI2ABYQR3XVjMORmuzf/oAGYFoqzCw/es8ASgWMDS\n", - "mEkBGGnNBH4AYYRvMIvpyUNJQRV2Pc+X1+9oN5gVHBKNIxs1/+JrB/f4zHsrRYYoqEyAPjCQhzkE\n", - "aswpbRq2li7OEtxbhSLC56zPEhCVhFYMMIEK+w3mAD3kYOKV3Y9UDUaiOq0pn/rgql3fx+5+2kh1\n", - "UYSgAejdOmFP9/p8j/n/DkCcAX5C+dHMN74GGG1EwiHcGBwAZHelNx2AIADAKCDrDBjajxEvEBVc\n", - "EQMD7BmABUMoAgzEhdGyx7bYM/g0mwxwRwHKWXBsVk8AK73ILHbj8AJvFYdCkN4AHEJT/EIUo/Np\n", - "0vqZIAAAAS9hAKLgCAAQHIDrwvhE2NBhgI36u916X4qMiYRG4ADhEBtQTAMjhuLP/QBwACcAhbq2\n", - "6TzlcDLtIS9k1/+0DomCY1lNWIFvFjadABBjLkQG4y8rMffeAMHtbwtCjU0xM1imL+A6QgEEMpVI\n", - "qG+dpgBAxCxqmN8aVWU3VCfhKDhqmKvGKpYdii9goyG6dCF6X5+N+A/NwABAKdoyMH8OgegskAb/\n", - "7QhgRBDD4TamTns5AX/v3GACAECBFAnq2lpjFNZVvMAgMQKWtk5LxVcP9tQwABALAJSCAAEDoAAQ\n", - "Fx6AAB7Eiy6dOe1Hx0OVVJCmmtIBbvQeJ0L+umiFq6ARlKGwf8AA8YCw9F9LDbMNFaIAVcAoCx3y\n", - "OAnKRrrbcGE66M4S1oGAVai5fqiZDxap+D8AAACFYQC94AgAEByA68MYkMYADmayDsnavty//3ML\n", - "NkWx75wAMgoIztJ22o+9l14AQaPlFPnVkEkNTwAAICSBAJWZNz5af2uE+4QGQCsYE2rWDcYUFhEa\n", - "4gbIfl4cCHrHDlBABROy2G4k/3gBR0m0f9+mPi5ONs4ObLh5Uy//3kkgy0kE5uwCrAAAAAph4AhA\n", - "EJyA68G8AAAAWmEG+AIQBCcgOvDFQ5wAEAAEAECDJJ03T/2CuR5IShgIgI8AE3Tak07cACeOV6ky\n", - "YbxB50DdBIzfKY46MhA6256AB2Ia2Ii05JOiWMZve+rqsuvgRDSYn//7JAAAAM9hA24AhAEJyA68\n", - "MMSEBE9FLwCNl2Zf/gAtZ2UNuj/PDR/L4nmCKjeADkCISqRSveATA8WkupjLC9/AAISEMSrzEIpT\n", - "uXwsYTrvUI7/bqQy4KCZO64+4AIMU+cLAPydrmQ068gRoreebCViFlAD0Pm8bX4EKzSeunMBcDB0\n", - "1/zQI4ve4NsIgAEgE0v+CpBAACASCDGRXzUicXV1UgZggibpjdhMQ/9HwedP+Fgk+hu6wopyzBoY\n", - "ChHHFrLMv6OOwWnngDwqIA4UXUxQo2nrMkAAAAFQYQFHgCEAQnIDrwwojG4ACMEB1gV5+7Took1f\n", - "z6xoJcCFdGC7z3CxoVnVWljEg00KyfKCKRN/oEIsREABLImyHU5yGckZR93zXNE1viIiQmyGZmQE\n", - "AQwgIdDQgAECPOAGWpNidfVNpwAvgnN76Aqs7Uct/z//SxUwAl1MhxDl1rIM8Q/FJc10uEGj+uPG\n", - "5gwQAHYAAgCgAYGa3gNITMQ45Hc5XGGqgIMMXpccfGzQm78YZsOvmLJUjGrwfBB0ACyXIkejozTI\n", - "WUvf/7BpmJ9FQpJPAHww8pskd2kQ7EIKYdMjgEADAyuyDQUWKr9wNwKWtY9tUuXZKv/wfrFnQG3Y\n", - "jhaycwwNATA4AAgJgOAjMEml5VOnRbQgNVC6ROgqkX9I6OjMav/eQADkCXYmSv5yQaQeT5tGJ1Md\n", - "GFQtGgaC2P5GdcNrZff9yUJEzGmMzMSAAAADRWEBs4AhAEJyA68hf/EhMMeAB11C4AFAAyWZgDYS\n", - "PsAd4AAgEDYKIx6KmpgNz9O4aBgQlCXSKLkGOgACGvggACbBEhAACAoBwNawBc2JnLngMzoaFhAP\n", - "RwhYAKYDqcEYeNUc93gFLjsuRiblXwSpKS+sMBIN/HAACAAjAAgeEXUi4xI2zwBQlpYO3rxXc5/1\n", - "oaWkFxRPNYGEIZYYwReA34wA8WKlR2Q/2/pgACAWDVofnE0lFLIFfIAita9fHYYPj5/MgqbwAfM0\n", - "TJef//9GK77P/wAx8ow0J9vYtMQsv8ThCeQWBN3D9+mvgIzbj/v0YS6A5fwwIVxuAA4AGAxZhl+4\n", - "Xoi24Fjf/fA40C+53BqnKugIBj4AMKJ3e0vLTcYimoiDYNU/AA0UonJYKdl3qbn2S42B/3AwAEBl\n", - "BRaNtaVTR8ktpLDCAONggAC4HGsgTiMOgkg0sQpVVk0pKbdBqVX/h+8V+f2uuW4YiiqfCzBwr/lk\n", - "8Dp2jTL0qALaL5telncMA0gv+MBAV6DXDMQ4YJn6d8YALQOJot2qGtBHU9BQ+DbTAQABgHEMhAAC\n", - "BWAAIBQAsLeBZRYRoYBDwPYffBkbX3x/tA6dQ6B5eZMFygEiW+//DPmMHfMlhqpMRvTrUYMOgBr7\n", - "/+x3/5SIiQmyERmDDhBeFYGaNeQclMXPACBDGWMzBGKv/iOrC4uvMEbrLcQXLwYolSBcFZ3/g3+v\n", - "9+eItABBDzHI1Vuj/rCJMiImzL/+v8LUyR8b4QEcXm/2////VPl/+IP7QKAPROlh82fUoYCY2ABj\n", - "qB/xADAPiJf9wMVjyLx6lLULwt+4ZOE/PJ+tX/3gkcGUJQ0T/6ZNP6/cBthQpgwfV7uCY4RcwRhC\n", - "cfG/cbHVgACRM+JGadv+4EY4DJYiUPkEn1GP/2ydZglPLJFILrSBgRLf4Qyv6taX/ACABnC2NqRv\n", - "R0hCScQR0JAABALuNEhtbL7aEhG3/jJKlg/CA1zuhbwjA0d3hNwJtKY0xUVM/v1BgVAFAgACIZAo\n", - "AfK8B/yBub/qMLdHkGxK+XDBweXwR2Mchg/rjhEf6GON4I74peADvf9lDlUmWlBVaBEYprwYLsjT\n", - "e9TjY+klfdvEgAAAAU5hAIfgCEAQnIDrwuHcACF7u77+AA/GOIrZYYp2h/4BLAAxWtOybUP7EhAQ\n", - "Exva7TmTa1gBA9PqQNIZSOvE3/754eA4Gw2zTAL6zwAAQBB7WD9qPKSyEEkGdYfgABDhVjlcZHm5\n", - "qWaQF78GH+AAmIgrfwgxRY3qzCegaBX/5bdE1pdu/weEJIERd2LYmXZ8ALAIIa9lrco8pXiZhgDw\n", - "6DBHQYWYK2pJ1GPWACBIipm0wn/2rCJLRnAqvQ4a1vgAsEUrrIWbOX3d3wApEFQ5+LMfCsVw8q/5\n", - "So9poImn+G8SN/ABAFIsaaIlLZQu7ZVCCDDBDHhn7FAAQnlEQrQC/GiwiTUmbQ0wCgAAXAFB8StA\n", - "AfGOUUOj2JggcIErBAjQkMgBkSl5CSspbwBRisyJH0jEEESdK8iv5lABlnn/0ACeEdUd0SsQ5YAF\n", - "pWKVJU4kAAABPGEAouAIQBCcgOvC43pFL5pwiJFggB0NgLEacesAjCC0usSDWpFzO//dgwJBaMwY\n", - "3LZA+/Axk2ACAxxeZVsfrJV8dOogdBgAOgZuBSA0lTKGeOy//eA+5QuGghbp621U0S2MQrYjQawF\n", - "Mbi4QHZ4J/34BR4xYxwXDlJHXb/cAGEQ8rLH9mwUiYB3/9wwGISUSkTHs+4GXf8EAAIAIBgQqGAA\n", - "eHEoAD0YBsqEeMpbqReFaQpa/+/Qt0A0xXT/1YAINWXhIyWFt/+QAFjGCvMrE/kl9ucg2hCx54n3\n", - "JXeUYLoClkACjnYRT3+UXPZ5mG7CIVgC2P4AAQAxLdKSIaaf79+GAbxfML4g/jl+8Z8Nvr2f/PbJ\n", - "vNPb/hAAIr2hAAEghRAGrG16PinAfz4GC+CzC5yhKqCxrifLg2O8n8kAAAB2YQC94AhAEJyA68MY\n", - "kN4+CI4tWYB6c7+gKtvFQWxLLZNLvrgja6gNeBnNdST97gA31suHkpWEb+3E3/9Q3wrgAJllDTuh\n", - "SRzFh8vDqlC280kWivtBlKeFLFAXxbbPQfhEaOgMTa9GaMMWL+6TFtJlf/0MXT4OoAAAAAph4AiA\n", - "ERyA68G8AAAAZmEG+AIgBEcgOvDBf/hCG8QFcABGEVgi+PWo1hCxCsGAfZqpXcd+pat7V+wwAc4L\n", - "dZKQlQMsiuaQMMR0EAAgRrgdoADq4/O/Fn4AE0jcJehFV9J5kYAHnXgB2iH6NDrd7RGreX8xIAAA\n", - "APlhA24AiAERyA68MYoMQAHMRCzbUIwqrXyHf1mhq1ip9L7f0S4BIhtdvAbA4LuduPVnfz/EBgEN\n", - "sgTWjTZw+/XwC4gjUKhV6aRo9f/4JFnAFwBczrCG24a0NI4ktSwAvjcmJFz9PtYMZEcf6DZfviYg\n", - "b2FwwAYgoKQRCkIvwC+AAIAAFBdIpcpKMRF1/7QIBBH4GQIa/E+UQ9DifcH+OBLqFWQc80p5/QBc\n", - "EdZ+yeM6t4BArLe5MkeIF5mTdoDBgzQEMAoMA1UMYLJP51NMXlX/sBDWaYp0V08/Ftun/WwrABey\n", - "Q6xoSwd/5T1zhI7kfCT/tvfQ/5kj+JAAAAFMYQFHgCIARHIDrwwoQw7gAIYZbRkkaFNuUdKydggM\n", - "bEOAlAAEBGYAAQEgAJiCCaABYJjh3hbCmESI0V8POAAgYyKfsMj6JSUwkMsaCAEZZACXr0/3NBOS\n", - "dgZp7kWPpn/FoSQAgUcNG4ebGbADZIqgGC6F5soYboSN9kaowSPCbtIIuAAtTGsiakOcR/94e48l\n", - "E0V6iUorQBAwt2n9CCz+1xpR6QcBxApA5j8vmhAk+aMISITAihFnKev3ZmO64S2OdA6I6RVHD6NO\n", - "/v8UZr2bkGjTUHiOl9wBA5YfSU1CjwsgoXu7RQYn+YWaGqE8z9wP6MAKD2JQwnYfXQxVm3qZDTFJ\n", - "1M7FUGWBBMAXgQ0Rl8cyH/Y2N6H2rLEtzuCnlNwL7ktXN51/cwAajwjnmQmd/gOuCSzmBgiQA6AA\n", - "YGuSS2pI5XfQAH0aMRBX7xIAAAMJYQGzgCIARHIDryPEw5x8fUAyN2ICB9LFRwAPredKWf+9g4Fh\n", - "vgAOIhAdEWakfC+B9z+DCCzuEAAZAohjBeCdwiSTvINOfgRwIA5l2IF/mhTo3IA5v/98O+AGDVUA\n", - "AIlZ2wYHwABARAAEBSYoADQQbPA4ABOBgggAE8BOAKC0QAg5ZtqEUyAYpE5sAQgCEaWAkaeG2oPQ\n", - "ZRHg40Ip8w+EZp2JAQP1wy/+EOX4kIBAQaUbQBAAoAKACAlkJrmKYR5c6MIfdC4A8is8JFZH5gcF\n", - "f+fWaYAAgFrvFAAEAcALqE+++35ttgwwAO08AAQDdqoAAgAAFwFO+8YAGcG5hgtX6ySjRNMfIqWv\n", - "TwAAgHADTIkzt9YCOUjgBMkAUIQlR+/wASZDDVAzlOaYosk+NUbU0RAAEEMAAQFIgCARDuwQABQE\n", - "3QgABAFAAfywAJ5GgzKOISz1nMFjumvU//2QqSuCulUMHVh2UwZVYABY2KplKYBAJjiQSfqftB+9\n", - "z+7cBpdBZX61RaJ/5hj7RmIH1AU4Ry/icueumYOUcgIGBiih1T8e/SCWGfBAmHFlxiXk2aFlYMOE\n", - "JmYQAEZzuvG/pRdWT7Whh+EEIccpAwok8IbJEwYfwrjEAAICNgAAgJAAbAAAQB1/r/mEQKSSFsME\n", - "xr90WloNww4GADBAhAAEA1QA44TQBoEfaTqkBYRTb/DxAYRoGJiqy0nEBirBfy5Vt/j/Rf/8viGy\n", - "oWyjaG/1oagPnaGiaH6bKxc+vwTUMewJd5FdwIEfb60x01KwGBdSVaMIgUmGih/rpOq//u5IjALA\n", - "BeTpwIXUFv9xCozySPqks1zoACwIwWtCGYJdsQuL+vBIDpJglkM4IjxM2AuYAwqyUnEYVIe4UeAE\n", - "ARLxOJpJYfgU6XXG2EQABtwxhLOGCIcLeFIL+LyP1hHEUaoWm4itO/+ERBzQwAKBoEgTh4+qRqIn\n", - "1LEj0K9vJb8BIJh8PUpJ5w1TOH0oitm6YHgH0AVIUV7Ew6CcVsNFYetPMKhojxOJewtnQnGbG/CQ\n", - "AAABG2EAh+AIgBEcgOvC4ny/EXQgIh3AAQACA4zJtBUkwom4TD+yvYAwp57YZz2BTx/+/30BRnAw\n", - "FxXXHcxO9wO/gxXlnlvGu9XLsuts0IMI5MFOGo6f+7A/wArFuVyMUHBCzYAAAIAPZZsawik971Ge\n", - "DF9qbXvrfM/+k6U7VYtrvYADwDMQTeTv0wuv72EUlyJjLewKK3Sm1v5lxz/x8v/0Gy+hLEROH8BR\n", - "FQf2kRgeQOCeyf/9MAAJgxLEzAoAD4IgPYpMj9RJQYre//o+PxEAAIB4AhgeGWAEAMOU5zjlqPJS\n", - "W0g4IARMJCACKkgCoNpzJsgaUjHsfRHzBCEP1Ccx14DGkaxPGVe/4bVgboSrdqmdfrhcegBJmLA1\n", - "YSAAAAFRYQCi4AiAERyA68MF+4+NjBtwALzDSyh4Qu5vf/QJ2A2IHYSRg6NMvg4AgACAABhc30iS\n", - "OvRg6rIgGAAjBMcFJsUtZMnHDWeAAh/SLjlxycrE68/8hiJVNHPqv/m8AIVBxYsoxCNgE1bRk98E\n", - "xyApBQ8xUqaZQI98wDDM0jDAI8u578wABBF8GUIGVt6CZ0Hlu1ZWAhCQIjhAACAwAAIBoCxYAC9K\n", - "HWvbLyv0wIS0jvH/f+Dj2Jprb76uAAwL6Ln9ROySd4AHPkCKVjuzGf6uiti6OcMzukj/e6I5gACA\n", - "Rgn8G9fBPh/wbV4VgByjtZrFsl/8kIyTPfKI3bA0RBSCIUpF9yaINKfFpDUn3gAgAiHUB8x2bjTT\n", - "l/YJeAACAJwEZZ1byzpcufDODDCADxLCAEZLhM8gcHuWAoSEjCIuG3/X5sLcYE9IRPBKvr44ZRfk\n", - "gAAAAERhAL3gCIARHIDrwxiTyoGBqLSQR7b3DwBar5adngAZjN6jI63LL/0FFrKGleuaQRa2opon\n", - "g2vPOiJe2jdfn3fP//wdQAAAA55tb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAbWAABAAAB\n", - "AAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAA\n", - "AAAAAAAAAAAAAAAAAAAAAAACAAACyHRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAAAAAb\n", - "WAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABsAAA\n", - "ASAAAAAAACRlZHRzAAAAHGVsc3QAAAAAAAAAAQAAG1gAAAAAAAEAAAAAAkBtZGlhAAAAIG1kaGQA\n", - "AAAAAAAAAAAAAAAAACgAAAEYAFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZp\n", - "ZGVvSGFuZGxlcgAAAAHrbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAAJGRpbmYAAAAcZHJlZgAA\n", - "AAAAAAABAAAADHVybCAAAAABAAABq3N0YmwAAACnc3RzZAAAAAAAAAABAAAAl2F2YzEAAAAAAAAA\n", - "AQAAAAAAAAAAAAAAAAAAAAABsAEgAEgAAABIAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n", - "AAAAAAAAAAAAAAAY//8AAAAlYXZjQwFCwBX/4QAOZ0LAFYyNQNhKQDwiEagBAARozjyAAAAAHHV1\n", - "aWRraEDyXyRPxbo5pRvPAyPzAAAAAAAAABhzdHRzAAAAAAAAAAEAAAAjAAAIAAAAABRzdHNzAAAA\n", - "AAAAAAEAAAABAAAAHHN0c2MAAAAAAAAAAQAAAAEAAAAjAAAAAQAAAKBzdHN6AAAAAAAAAAAAAAAj\n", - "AAAfqwAABk4AAAbtAAAI5gAACz4AAAxFAAAO2gAADF8AAAzXAAAM/gAAC+QAAAnYAAAJSgAAC04A\n", - "AAu+AAAJMgAACiwAAAn9AAAIrAAACqAAAAkkAAAI7gAACeIAAAmXAAAKBQAACiQAAAmQAAAKJgAA\n", - "CKYAAAjtAAAIhwAACHMAAAfdAAAI6AAACI4AAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAA\n", - "Wm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRv\n", - "bwAAAB1kYXRhAAAAAQAAAABMYXZmNTguNDUuMTAw\n", - "\">\n", - " Your browser does not support the video tag.\n", - "</video>" - ], "text/plain": [ - "<IPython.core.display.HTML object>" + "33.93870401382446" ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from matplotlib import animation\n", - "from IPython.display import HTML\n", - "\n", - "style_list=['ro', 'g^', 'yx', 'cs']\n", - "parity_list=['+,+', '+,--', '--,+', '--,--']\n", - "\n", - "# First set up the figure, the axis, and the plot element we want to animate\n", - "lines = []\n", - "\n", - "fig = plt.figure();\n", - "ax = plt.axes(xlim=(5e-15, 25), ylim=(-40, 40));\n", - "ax.set_xscale(\"log\")\n", - "ax.set_xlabel(r\"$-\\Re(\\lambda_1)$ [$\\tilde\\eta$]\")\n", - "ax.set_ylabel(r\"$\\Im(\\lambda_1)$ [$\\tilde\\eta$]\")\n", - "\n", - "for j in range(num_blocks):\n", - " temp_line, = ax.plot([], [], style_list[j], label=parity_list[j]);\n", - " lines.append(temp_line);\n", - "\n", - "# Initialization function: plot the background of each frame\n", - "def init():\n", - " for j in range(len(lines)):\n", - " lines[j].set_data([], []);\n", - " return lines\n", - "\n", - "# Animation function which updates figure data. This is called sequentially\n", - "def animate(i):\n", - " for j in range(num_blocks):\n", - " lines[j].set_data(np.abs(np.real(evals_list[i][j,:])), np.imag(evals_list[i][j,:]));\n", - " return lines\n", - "\n", - "# Call the animator. blit=True means only re-draw the parts that have changed.\n", - "anim = animation.FuncAnimation(fig, animate, init_func=init,\n", - " frames=Grange.size, interval=200, blit=True);\n", - "\n", - "ax.legend()\n", - "plt.close(anim._fig);\n", - "\n", - "# Call function to display the animation\n", - "#anim.save('spectrum.gif',dpi=300);\n", - "HTML(anim.to_html5_video())" + "step = 1\n", + "cuts = np.arange(10,50,step)\n", + "\n", + "num_even = np.zeros(cuts.size)\n", + "num_odd = np.zeros(cuts.size)\n", + "gap_even = np.zeros(cuts.size, dtype='complex')\n", + "gap_odd = np.zeros(cuts.size, dtype='complex')\n", + "gap_even_odd = np.zeros(cuts.size, dtype='complex')\n", + "gap_odd_even = np.zeros(cuts.size, dtype='complex')\n", + "\n", + "Grat=1.8\n", + "p = Parameters(Δ=1.5, N=10, Grat=Grat, ηtilde=1, Utilde=1)\n", + "\n", + "t1=time.time()\n", + "for i in range(cuts.size):\n", + " k = Kerr_2γ(Nfock=cuts[i], p=p) \n", + " num_even[i], num_odd[i], gap_even[i], gap_odd[i], gap_even_odd[i], gap_odd_even[i] = k.bd()\n", + "time.time()-t1" ] }, { "cell_type": "code", - "execution_count": null, - "id": "e6242fc5", + "execution_count": 30, + "id": "1b5e0401", "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "63fa2557", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "540f7b9f", - "metadata": {}, - "source": [ - "### Phase diagrams \n", - "\n", - "We explore the dependence of the \"Dicke\" phase on $\\Delta$ and $U$." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18ee4130", - "metadata": {}, - "outputs": [], - "source": [ - "a=destroy(30)\n", - "\n", - "ηtilde = 1\n", - "Δrange = np.linspace(0,20,31)\n", - "Utilderange = np.linspace(0,20,30)\n", - "G = 3.5*ηtilde\n", - "\n", - "N = 10\n", - "η = ηtilde/N\n", - "\n", - "c_ops=[np.sqrt(η)*a**2]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bdf0cc84", - "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c= 35 time= 4.905393362045288\n" + ] + } + ], "source": [ - "parity=1.j*np.pi*a.dag()*a\n", - "parity=parity.expm()\n", - "\n", - "num_even = np.zeros((Utilderange.size, Δrange.size))\n", - "num_odd = np.zeros((Utilderange.size, Δrange.size))\n", - "gap_even = np.zeros((Utilderange.size, Δrange.size), dtype='complex')\n", - "gap_odd = np.zeros((Utilderange.size, Δrange.size), dtype='complex')\n", - "gap_even_odd = np.zeros((Utilderange.size, Δrange.size), dtype='complex')\n", - "gap_odd_even = np.zeros((Utilderange.size, Δrange.size), dtype='complex')\n", - "\n", "t1 = time.time()\n", - "for k in range(Utilderange.size):\n", - " Utilde = Utilderange[k]\n", - " U = Utilde/N\n", - "\n", - " for j in range(Δrange.size):\n", - " Δ = Δrange[j]\n", - "\n", - " H = -Δ*a.dag()*a + G/2 *(a.dag()**2 +a**2) + U/2 *a.dag()**2*a**2\n", - " LL = liouvillian(H, c_ops)\n", - "\n", - " P, block_bfs, block_sizes = block_diagonalize.PermMat(LL)\n", - " bd_L = np.dot(P, np.dot(LL.data, np.transpose(P)))\n", - " num_blocks, blocks_list, bl_indices = block_diagonalize.get_blocks(bd_L) \n", - " \n", - " done=False\n", - " for i in range(int(len(blocks_list))):\n", - " block = blocks_list[i]\n", - " evals, evecs = Qobj(block).eigenstates() \n", - "\n", - " ss_block_form = evecs[-1]\n", - " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", - " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", - " evec2 = evec2.tocsr()\n", - " evec2 = np.dot(np.transpose(P),evec2)\n", - " ss= Qobj(evec2, dims=[LL.dims[0], [1]])\n", - " ss=vector_to_operator(ss)\n", - "\n", - " if np.real(ss.tr())>0.05:\n", - " ss=ss+ss.dag()\n", - " ss/=(ss.tr()) \n", - " if expect(parity, ss)>0.5:\n", - " num_even[k,j] = expect(ss, a.dag()*a)\n", - " gap_even[k,j] = evals[-2]\n", - " else:\n", - " num_odd[k,j] = expect(ss, a.dag()*a) \n", - " gap_odd[k,j] = evals[-2]\n", - " elif done==False:\n", - " gap_even_odd[k,j] = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", - " gap_odd_even[k,j] = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", - " done=True\n", - "\n", - " print(\"\\rCompleted (%d/%d) -> %d/%d \"%(k,Utilderange.size, j+1,Δrange.size),end=\"\")\n", - "print(\"\\nTime:\",time.time()-t1)" + "c = get_cutoff(p,c0=36,cmax=60,step=6,precision=0.01)\n", + "print(\"c=\",c,\" time=\",time.time()-t1)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "e2e2b274", + "execution_count": 41, + "id": "6876c0dd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1296x360 with 3 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "fig, ax = plt.subplots(1,2, figsize=(15,5))\n", - "\n", - "im0 = ax[0].pcolormesh(Δrange, Utilderange, num_even/N, shading='gouraud', cmap=greiner)\n", - "#ax[0].plot(Δrange, Δrange**(2)/N)\n", - "ax[0].plot(Δrange, Δrange**(1))\n", - "fig.colorbar(im0, ax=ax[0], label=r\"$\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", - "\n", - "ax[0].set_xlabel(r\"$\\Delta$ [$\\tilde\\eta$]\")\n", - "ax[0].set_ylabel(r\"$\\tilde U$ [$\\tilde\\eta$]\")\n", - "ax[0].set_ylim(0,20)\n", - "ax[0].set_xlim(0,20)\n", - "\n", - "\n", - "im1 = ax[1].pcolormesh(Δrange, Utilderange, np.gradient(num_even, axis=1)/N, shading='gouraud', cmap=greiner)\n", - "ax[1].plot(Δrange, Δrange**(2)/N)\n", - "ax[1].plot(Δrange, Δrange**(1))\n", - "fig.colorbar(im1, ax=ax[1],label=r\"$\\partial_{\\tilde U}\\,\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", + "fig,ax = plt.subplots(1,3,figsize=(18,5))\n", "\n", - "ax[1].set_xlabel(r\"$\\Delta$ [$\\tilde\\eta$]\")\n", - "ax[1].set_ylabel(r\"$\\tilde U$ [$\\tilde\\eta$]\")\n", - "ax[1].set_ylim(0,20)\n", - "ax[1].set_xlim(0,20);\n", + "ax[0].plot(cuts,num_even,'o-')\n", + "ax[0].plot(cuts,num_odd,'o-')\n", + "ax[0].axvline(c,c='r',ls='--',lw=2)\n", + "ax[0].set_xlabel(r\"$N_{cut}$\")\n", + "ax[0].set_ylabel(r\"$n\\,(\\,N_{cut}\\,)$\")\n", "\n", - "\n", - "#plt.contour(Δrange, Utilderange, gaussian_filter(num_even/N,1), colors='k', alpha=0.3)#, levels=contours)\n", - "#plt.contour(Δrange, Utilderange, num_even/N, colors='k', alpha=0.25)#, levels=contours)\n", - "#plt.savefig(\"Utilde_Delta_PD_v1.pdf\")" + "ax[1].set_yscale(\"log\")\n", + "ax[1].plot(cuts[1:],(np.gradient(num_even,cuts)*100)[1:],'o-')\n", + "ax[1].plot(cuts[1:],(np.gradient(num_odd,cuts)*100)[1:],'o-')\n", + "ax[1].axvline(c,c='r',ls='--',lw=2)\n", + "ax[1].set_xlabel(r\"$N_{cut}$\")\n", + "ax[1].set_ylabel(r\"$\\partial_{N_cut}\\,n\\,(\\,N_{cut}\\,)$\")\n", + "\n", + "ax[2].plot(cuts[2:],(np.gradient(np.gradient(num_odd,cuts),cuts)*100)[2:],'o-')\n", + "ax[2].axvline(c,c='r',ls='--',lw=2)\n", + "ax[2].set_xlabel(r\"$N_{cut}$\")\n", + "ax[2].set_ylabel(r\"$\\partial^2_{N_cut}\\,n\\,(\\,N_{cut}\\,)$\");" ] }, { "cell_type": "code", "execution_count": null, - "id": "36d60d3c", - "metadata": {}, + "id": "7aa3b8c2", + "metadata": { + "scrolled": false + }, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "93c8b23c", + "id": "2edda78b", "metadata": {}, "outputs": [], "source": [] @@ -2268,119 +414,27 @@ { "cell_type": "code", "execution_count": null, - "id": "2c48075b", + "id": "fbccad86", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": null, - "id": "689ba054", - "metadata": {}, - "outputs": [], - "source": [ - "a=destroy(30)\n", - "\n", - "ηtilde = 1\n", - "\n", - "Δrange = np.geomspace(1e-2, 1e2, 31)\n", - "Grange = np.geomspace(1e-2,1e2,30)\n", - "\n", - "N = 10\n", - "η = ηtilde/N\n", - "\n", - "c_ops=[np.sqrt(η)*a**2]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b7ed719b", + "execution_count": 85, + "id": "76680780", "metadata": {}, "outputs": [], "source": [ - "parity=1.j*np.pi*a.dag()*a\n", - "parity=parity.expm()\n", - "\n", - "num_even = np.zeros((Δrange.size, Grange.size))\n", - "num_odd = np.zeros((Δrange.size, Grange.size))\n", - "gap_even = np.zeros((Δrange.size, Grange.size), dtype='complex')\n", - "gap_odd = np.zeros((Δrange.size, Grange.size), dtype='complex')\n", - "gap_even_odd = np.zeros((Δrange.size, Grange.size), dtype='complex')\n", - "gap_odd_even = np.zeros((Δrange.size, Grange.size), dtype='complex')\n", - "\n", - "t1 = time.time()\n", - "for k in range(Δrange.size):\n", - " Δ = Δrange[k]\n", - " Utilde = Δ\n", - " U = Utilde/N\n", - "\n", - " for j in range(Grange.size):\n", - " G = Grange[j]*Δ\n", - " \n", - " H = -Δ*a.dag()*a + G/2 *(a.dag()**2 +a**2) + U/2 *a.dag()**2*a**2\n", - " LL = liouvillian(H, c_ops)\n", - "\n", - " P, block_bfs, block_sizes = block_diagonalize.PermMat(LL)\n", - " bd_L = np.dot(P, np.dot(LL.data, np.transpose(P)))\n", - " num_blocks, blocks_list, bl_indices = block_diagonalize.get_blocks(bd_L) \n", - " \n", - " done=False\n", - " for i in range(int(len(blocks_list))):\n", - " block = blocks_list[i]\n", - " evals, evecs = Qobj(block).eigenstates() \n", - "\n", - " ss_block_form = evecs[-1]\n", - " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", - " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", - " evec2 = evec2.tocsr()\n", - " evec2 = np.dot(np.transpose(P),evec2)\n", - " ss= Qobj(evec2, dims=[LL.dims[0], [1]])\n", - " ss=vector_to_operator(ss)\n", - "\n", - " if np.real(ss.tr())>0.05:\n", - " ss=ss+ss.dag()\n", - " ss/=(ss.tr()) \n", - " if expect(parity, ss)>0.5:\n", - " num_even[k,j] = expect(ss, a.dag()*a)\n", - " gap_even[k,j] = evals[-2]\n", - " else:\n", - " num_odd[k,j] = expect(ss, a.dag()*a) \n", - " gap_odd[k,j] = evals[-2]\n", - " elif done==False:\n", - " gap_even_odd[k,j] = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", - " gap_odd_even[k,j] = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", - " done=True\n", - "\n", - " print(\"\\rCompleted (%d/%d) -> %d/%d \"%(k,Δrange.size, j+1,Utilderange.size),end=\"\")\n", - "print(\"\\nTime:\",time.time()-t1)" + "Δrange = np.linspace(0.,3.5,11)\n", + "Utilderange = np.linspace(1,1,1)\n", + "Grange = np.linspace(0.1,2,10)" ] }, { "cell_type": "code", "execution_count": null, - "id": "65ea2c81", - "metadata": {}, - "outputs": [], - "source": [ - "plt.xscale(\"log\")\n", - "plt.yscale(\"log\")\n", - "\n", - "plt.pcolormesh(Grange, Δrange, (num_even/N), shading='gouraud', vmax=1.4, cmap='viridis')\n", - "plt.xlabel(r\"$G\\,/\\,\\Delta$\")\n", - "plt.ylabel(r\"$\\Delta\\,=\\,\\tilde U$ [$\\tilde\\eta$]\")\n", - "plt.colorbar(label=r\"$\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", - "\n", - "#plt.contour(Grange, Δrange, gaussian_filter(num_even/N,2), colors='k', alpha=0.3)#, levels=contours)\n", - "#plt.contour(Grange, Δrange, num_even/N, 4, colors='k', alpha=0.25)#, levels=contours)\n", - "#plt.savefig(\"G_Delta=Utilde_PD_v2.pdf\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dfe2e1ed", + "id": "2b123bbf", "metadata": {}, "outputs": [], "source": [] @@ -2388,7 +442,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0ef04a03", + "id": "9b041c2e", "metadata": {}, "outputs": [], "source": [] @@ -2396,7 +450,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ded378b7", + "id": "4b45cdb9", "metadata": {}, "outputs": [], "source": [] @@ -2404,7 +458,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c9f86334", + "id": "44386e9c", "metadata": {}, "outputs": [], "source": [] @@ -2412,172 +466,23 @@ { "cell_type": "code", "execution_count": null, - "id": "a3946cf1", + "id": "22ab118b", "metadata": {}, "outputs": [], - "source": [ - "a=destroy(30)\n", - "\n", - "ηtilde = 1\n", - "Utilde = 5\n", - "Δ = 10\n", - "\n", - "Grange, dG = np.linspace(0.1,14,75, retstep=True)*ηtilde\n", - "\n", - "N = 10\n", - "η = ηtilde/N\n", - "U = Utilde/N\n", - "\n", - "c_ops=[np.sqrt(η)*a**2]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a9decc16", - "metadata": {}, - "outputs": [], - "source": [ - "parity=1.j*np.pi*a.dag()*a\n", - "parity=parity.expm()\n", - "\n", - "num_even = np.zeros(Grange.size)\n", - "num_odd = np.zeros(Grange.size)\n", - "gap_even = np.zeros(Grange.size, dtype='complex')\n", - "gap_odd = np.zeros(Grange.size, dtype='complex')\n", - "gap_even_odd = np.zeros(Grange.size, dtype='complex')\n", - "gap_odd_even = np.zeros(Grange.size, dtype='complex')\n", - "evals_list = []\n", - "\n", - "t1 = time.time()\n", - "for g in range(Grange.size):\n", - " H = -Δ*a.dag()*a + Grange[g]/2 *(a.dag()**2 +a**2) + U/2 *a.dag()**2*a**2\n", - " LL = liouvillian(H, c_ops)\n", - " \n", - " P, block_bfs, block_sizes = block_diagonalize.PermMat(LL)\n", - " bd_L = np.dot(P, np.dot(LL.data, np.transpose(P)))\n", - " num_blocks, blocks_list, bl_indices = block_diagonalize.get_blocks(bd_L) \n", - " \n", - " num_keep = 15\n", - " evals_keep = np.zeros((num_blocks, num_keep), dtype='complex')\n", - " \n", - " done=False\n", - " for i in range(int(len(blocks_list))):\n", - " block = blocks_list[i]\n", - " evals, evecs = Qobj(block).eigenstates() \n", - " evals_keep[i,:] = evals[-num_keep:]\n", - " \n", - " ss_block_form = evecs[-1]\n", - " evec2 = spr.dok_matrix((LL.shape[0], 1), dtype=np.complex)\n", - " evec2[bl_indices[i]:bl_indices[i]+blocks_list[i].shape[0]] = ss_block_form.data\n", - " evec2 = evec2.tocsr()\n", - " evec2 = np.dot(np.transpose(P),evec2)\n", - " ss= Qobj(evec2, dims=[LL.dims[0], [1]])\n", - " ss=vector_to_operator(ss)\n", - "\n", - " if np.real(ss.tr())>0.05:\n", - " ss=ss+ss.dag()\n", - " ss/=(ss.tr()) \n", - " if expect(parity, ss)>0.5:\n", - " num_even[g] = expect(ss, a.dag()*a)\n", - " gap_even[g] = evals[-2]\n", - " else:\n", - " num_odd[g] = expect(ss, a.dag()*a) \n", - " gap_odd[g] = evals[-2]\n", - " elif done==False:\n", - " gap_even_odd[g] = np.real(evals[-1])+1.j*np.abs(np.imag(evals[-1]))\n", - " gap_odd_even[g] = np.real(evals[-1])-1.j*np.abs(np.imag(evals[-1])) \n", - " done=True\n", - " evals_list.append(evals_keep)\n", - " print(\"\\rCompleted %d/%d\"%(g+1,Grange.size),end=\"\")\n", - "print(\"\\nTime:\",time.time()-t1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "89a3ea87", - "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plt.subplots(1,3, figsize=(30,9))\n", - "\n", - "ax[0].plot(Grange, num_even/N, 'bo-', ms=5, label=\"even\")\n", - "ax[0].plot(Grange, num_odd/N, 'rs-', ms=5, label=\"odd\")\n", - "\n", - "#ax[0].set_xscale(\"log\")\n", - "ax[0].set_xlabel(r\"$G\\,/\\,\\tilde{\\eta}$\")\n", - "ax[0].set_ylabel(r\"$\\langle a^{\\dagger} a\\rangle\\,/\\,N$\")\n", - "ax[0].legend()\n", - "\n", - "\n", - "ax[1].plot(Grange, -np.real(gap_even), 'bo-', ms=5, label=\"even\")\n", - "ax[1].plot(Grange, -np.real(gap_odd), 'rs-', ms=5, label=\"odd\")\n", - "ax[1].axhline(1, c='k', ls='--')\n", - "\n", - "#ax[1].set_xscale(\"log\")\n", - "ax[1].set_yscale(\"log\")\n", - "ax[1].set_ylabel(r\"$-\\Re(\\lambda_1)\\,/\\,\\tilde\\eta$\")\n", - "ax[1].set_xlabel(r\"$G\\,/\\,\\tilde\\eta$\")\n", - "ax[1].legend()\n", - "\n", - "\n", - "ax[2].plot(Grange, -np.real(gap_even_odd), 'g^-')\n", - "ax[2].plot(Grange, -np.real(gap_odd_even), 'yh-')\n", - "ax[2].set_xlabel(r\"$G\\,/\\,\\tilde\\eta$\")\n", - "\n", - "#ax[2].set_xscale(\"log\")\n", - "ax[2].set_yscale('log')\n", - "\n", - "fig.tight_layout()\n", - "#fig.savefig(\"PL_Delta=Utilde=10_N=10.pdf\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6394fce7", - "metadata": {}, - "outputs": [], - "source": [ - "dGnum_even = np.gradient(num_even,dG)/N\n", - "dGnum_odd = np.gradient(num_odd,dG)/N\n", - "\n", - "plt.plot(Grange, dGnum_even, '.-')\n", - "plt.plot(Grange, dGnum_odd, '.-')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9f9de67b", - "metadata": {}, - "outputs": [], - "source": [ - "overlap = (dGnum_even*dGnum_odd).sum()*dG/np.sqrt((dGnum_even**2).sum()*dG)/np.sqrt((dGnum_odd**2).sum()*dG)\n", - "print(overlap)\n", - "\n", - "M = Grange[np.argmax(dGnum_even)] - Grange[np.argmax(dGnum_odd)]\n", - "m = 0.5*(Grange[np.argmax(dGnum_even)] + Grange[np.argmax(dGnum_odd)])\n", - "print(M,m,M/m)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "5f12a50d", + "id": "4d0839e6", "metadata": {}, "outputs": [], - "source": [ - "plt.plot(Grange, num_even/N, 'bo-', ms=5, label=\"even\")\n", - "plt.plot(Grange+M, num_odd/N-1/N, 'rs-', ms=5, label=\"odd\")\n", - "plt.axvline(m)" - ] + "source": [] }, { "cell_type": "code", "execution_count": null, - "id": "1c932396", + "id": "93df735b", "metadata": {}, "outputs": [], "source": [] @@ -2585,7 +490,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9a8214ad", + "id": "b7171447", "metadata": {}, "outputs": [], "source": [] @@ -2593,23 +498,70 @@ { "cell_type": "code", "execution_count": null, - "id": "2ed104db", + "id": "da108646", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": null, - "id": "371fe39b", + "execution_count": 17, + "id": "53d5cb37", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def get_cutoff_MK1(cuts, p, precision=0.01):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " q = deque()\n", + " \n", + " k = Kerr_2γ(Nfock=cuts[0], p=p)\n", + " q.append(0)\n", + " q.append(k.bd()[0])\n", + " \n", + " for i in range(1,cuts.size):\n", + " k = Kerr_2γ(Nfock=cuts[i], p=p)\n", + " ni = k.bd()[0]\n", + " μi = metric(ni,q.pop())\n", + " q.append(μi)\n", + " print(q[0],q[1],i)\n", + " if (q.popleft())*(q[0])==True : \n", + " return i-1\n", + " q.append(ni)\n", + " \n", + " if q[0]==True:\n", + " print(\"Carefull: Convergence on border\")\n", + " return i\n", + " else: return np.inf\n", + " \n", + " \n", + " \n", + " \n", + "def get_cutoff_MK2(p, c0=5, cmax=100, step=5, precision=0.005):\n", + " metric = lambda x1,x2 : ((np.abs(x1-x2)/np.abs(np.min([x1,x2])))<precision)\n", + " k = Kerr_2γ(Nfock=c0,p=p)\n", + " nprev = k.bd()[0]\n", + " c = c0+step\n", + " while c<cmax:\n", + " k = Kerr_2γ(Nfock=c,p=p)\n", + " n = k.bd()[0]\n", + " if metric(n,nprev):\n", + " c -= step\n", + " while 1:\n", + " k = Kerr_2γ(Nfock=c-1,p=p)\n", + " if metric(k.bd()[0],n): c -= 1\n", + " else: return c\n", + " else:\n", + " nprev = n\n", + " c += step\n", + " return np.inf\n", + " \n", + " " + ] }, { "cell_type": "code", "execution_count": null, - "id": "455a526c", + "id": "b5385b39", "metadata": {}, "outputs": [], "source": [] @@ -2617,7 +569,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2631,7 +583,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.7" } }, "nbformat": 4,