{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "            " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 5 - Excitation transfer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Last time](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/04-spin-boson-model.ipynb), we explored the spin boson model and found the surprising physics of down conversion. This is where many bosons are emitted/absorbed (rather than a single boson) when a two state system (TSS) makes a transition. This is not what's usually taught to be possible in introductory quantum mechanics courses.\n", "\n", "Today, we are going to extend the spin boson model by adding another TSS into the mix. What new lessons does mother nature have for us... the clue is in the name of the tutorial 😉 .\n", "\n", "This tutorial is split up into the following sections:\n", "1. [Recap](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.1---Recap)\n", "2. [Adding more two state systems](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.2---Adding-more-two-state-systems)\n", "3. [Structure of the Hamiltonian](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.3----Structure-of-the-Hamiltonian)\n", "4. [Parity](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.4---Parity)\n", "5. [Energy level landscape](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.5---Energy-level-landscape)\n", "6. [Crossings and anti-crossings](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.6---Crossings-and-anti-crossings)\n", "7. [Excitation transfer](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/05-excitation-transfer.ipynb#5.7---Excitation-transfer)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Libraries and helper functions\n", "\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "from IPython.display import Image\n", "\n", "import numpy as np\n", "from itertools import product\n", "import pandas as pd\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "from qutip import *\n", "\n", "from scipy.optimize import minimize_scalar\n", "\n", "# The helper file below brings functions created in previous tutorials and adds an extra one\n", "# make_df_for_energy_scan - we made this in tutorial 4\n", "# make_braket_labels - we made this in tutorial 4\n", "# simulate - we made this in tutorial 4\n", "# plot_prob - made from code used for plotting in tutorial 4\n", "# prettify_states - nice way to display many QuTiP states for side by side comparison\n", "# \n", "from libs.helper_05_tutorial import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5.1 - Recap\n", "\n", "Let's remind ourselves of the Hamiltonian that we used in the last tutorial ([Tutorial 4](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/04-spin-boson-model.ipynb))\n", "\n", "$$H = \\frac{\\Delta E}{2} \\sigma_z + \\hbar\\omega\\left(a^{\\dagger}a +\\frac{1}{2}\\right) + U\\left( a^{\\dagger} + a \\right)\\sigma_x$$\n", "\n", "where we recognise $\\Delta E$ as the transition energy of the TSS, $\\hbar\\omega$ the energy of a single boson and $U$ as the strength of the interaction between the TSS and the boson field.\n", "\n", "We described the states of the system above using the notation $|n,\\pm \\rangle$.\n", "\n", "To help us move towards systems with many TSS, let's enumerate the states for the Hamiltonian above using an example where we only allow max_bosons=4." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "max_bosons=4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We [previously](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/04-spin-boson-model.ipynb#4.3---Structure-of-the-Hamiltonian) enumerated the states by doing:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# map from QuTiP number states to |n,±> states\n", "possible_ns = range(0, max_bosons+1)\n", "possible_ms = [\"+\",\"-\"]\n", "nm_list = [(n,m) for (n,m) in product(possible_ns, possible_ms)]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(0, '+'),\n", " (0, '-'),\n", " (1, '+'),\n", " (1, '-'),\n", " (2, '+'),\n", " (2, '-'),\n", " (3, '+'),\n", " (3, '-'),\n", " (4, '+'),\n", " (4, '-')]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nm_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and we represented these states in QuTiP using the tensor product (see [Tutorial 3](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/03-a-two-state-system-in-a-quantised-field.ipynb#3.5---Describing-coupled-systems-in-QuTiP)). For example, the state $|1, +\\rangle$ can be represented in QuTiP by:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "Quantum object: dims = [[5, 2], [1, 1]], shape = (10, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}0.0\\\\0.0\\\\1.0\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\\\end{array}\\right)\\end{equation*}" ], "text/plain": [ "Quantum object: dims = [[5, 2], [1, 1]], shape = (10, 1), type = ket\n", "Qobj data =\n", "[[0.]\n", " [0.]\n", " [1.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# bosons, TSS, \n", "tensor(basis(max_bosons+1,1), basis(2,0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We also used tensor products for the operators that make up the Hamiltonian (see [Tutorial 4](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/04-spin-boson-model.ipynb#4.2---Stationary-states)). Specifically:\n", "- two_state = $\\frac{1}{2}\\sigma_z$\n", "- bosons = $a^{\\dagger}a +\\frac{1}{2}$\n", "- interaction= $\\left( a^{\\dagger} + a \\right)\\sigma_x$" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "a = tensor(destroy(max_bosons+1), qeye(2)) # tensorised boson destruction operator\n", "sx = tensor(qeye(max_bosons+1), sigmax()) # tensorised 𝜎𝑥 operator\n", "sz = tensor(qeye(max_bosons+1),sigmaz()) # tensorised 𝜎𝑧 operator\n", "\n", "two_state = 1/2*sz # two state system energy operator 𝜎𝑧/2\n", "bosons = (a.dag()*a+0.5) # boson energy operator 𝑎†𝑎+1/2\n", "number = a.dag()*a # boson number operator 𝑎†𝑎\n", "interaction = (a.dag() + a) * sx # interaction energy operator (𝑎†+𝑎)𝜎𝑥 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we have recalled what we did before, we are in a good place to extend these ideas to include an extra TSS." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5.2 - Adding more two state systems\n", "\n", "For this tutorial we will consider 2 identical TSS (TSS_1 and TSS_2) whose interaction with the boson field is also identical. In this case, we can extend the single TSS Hamiltonian in the following way:\n", "\n", "$$H = \\frac{\\Delta E}{2} (\\sigma_{z1} + \\sigma_{z2}) + \\hbar\\omega\\left(a^{\\dagger}a +\\frac{1}{2}\\right) + U\\left( a^{\\dagger} + a \\right)(\\sigma_{x1} + \\sigma_{x2})$$\n", "\n", "where subscripts 1 and 2 refer to TSS_1 and TSS_2 respectively.\n", "\n", "We will be referring to this Hamiltonian a lot in figure titles, so we'll create a variable for the corresponding Latex so that it's easy to refer to later." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "H_latex = \"$H = \\Delta E /2 (\\sigma_{z1} + \\sigma_{z2}) + \\hbar\\omega(a^{{\\dagger}}a +1/2) + U( a^{{\\dagger}} + a )(\\sigma_{x1} +\\sigma_{x2} )$ \"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "How shall we describe the states of the system above? We can add another $\\pm$ \"index\" to the state notation like this:\n", "\n", "$|n,\\pm, \\pm \\rangle$\n", "\n", "Let's enumerate the states for the Hamiltonian above (again using max_bosons=4) by extending the ideas that we used for the single TSS - we just need to add an extra argument to the product function." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# map from QuTiP number states to |n,±, ±> states\n", "possible_ns = range(0, max_bosons+1)\n", "possible_ms = [\"+\",\"-\"]\n", "nmm_list = [(n,m1,m2) for (n,m1,m2) in product(possible_ns, possible_ms, possible_ms)]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(0, '+', '+'),\n", " (0, '+', '-'),\n", " (0, '-', '+'),\n", " (0, '-', '-'),\n", " (1, '+', '+'),\n", " (1, '+', '-'),\n", " (1, '-', '+'),\n", " (1, '-', '-'),\n", " (2, '+', '+'),\n", " (2, '+', '-'),\n", " (2, '-', '+'),\n", " (2, '-', '-'),\n", " (3, '+', '+'),\n", " (3, '+', '-'),\n", " (3, '-', '+'),\n", " (3, '-', '-'),\n", " (4, '+', '+'),\n", " (4, '+', '-'),\n", " (4, '-', '+'),\n", " (4, '-', '-')]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nmm_list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The tensor products can also be extended by adding an extra argument. For example, the state $|1,+, + \\rangle$ is represented by:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "Quantum object: dims = [[5, 2, 2], [1, 1, 1]], shape = (20, 1), type = ket\\begin{equation*}\\left(\\begin{array}{*{11}c}0.0\\\\0.0\\\\0.0\\\\0.0\\\\1.0\\\\\\vdots\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\0.0\\\\\\end{array}\\right)\\end{equation*}" ], "text/plain": [ "Quantum object: dims = [[5, 2, 2], [1, 1, 1]], shape = (20, 1), type = ket\n", "Qobj data =\n", "[[0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [1.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]\n", " [0.]]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# bosons, TSS_1, TSS_2\n", "tensor(basis(max_bosons+1,1), basis(2,0), basis(2,0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we do the same for the operators:\n", "\n", "- two_state_1 = $\\frac{1}{2}\\sigma_{z1}$\n", "- two_state_2 = $\\frac{1}{2}\\sigma_{z2}$\n", "- bosons = $a^{\\dagger}a +\\frac{1}{2}$\n", "- interaction_1= $\\left( a^{\\dagger} + a \\right)\\sigma_{x1}$\n", "- interaction_2= $\\left( a^{\\dagger} + a \\right)\\sigma_{x2}$" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "a = tensor(destroy(max_bosons+1), qeye(2), qeye(2)) # tensorised boson destruction operator\n", "sx1 = tensor(qeye(max_bosons+1), sigmax(), qeye(2)) # tensorised 𝜎𝑥1 operator \n", "sx2 = tensor(qeye(max_bosons+1), qeye(2), sigmax()) # tensorised 𝜎𝑥2 operator \n", "sz1 = tensor(qeye(max_bosons+1), sigmaz(), qeye(2)) # tensorised 𝜎z1 operator \n", "sz2 = tensor(qeye(max_bosons+1), qeye(2), sigmaz()) # tensorised 𝜎z2 operator \n", "\n", "two_state_1 = 1/2*sz1 # two_state_1 energy operator 𝜎𝑧1/2\n", "two_state_2 = 1/2*sz2 # two_state_2 energy operator 𝜎𝑧2/2\n", "bosons = (a.dag()*a+0.5) # boson energy operator 𝑎†𝑎+1/2\n", "number = a.dag()*a # boson number operator 𝑎†𝑎\n", "interaction_1 = (a.dag() + a) * sx1 # interaction_1 energy operator (𝑎†+𝑎)𝜎𝑥1 \n", "interaction_2 = (a.dag() + a) * sx2 # interaction_2 energy operator (𝑎†+𝑎)𝜎𝑥2 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5.3 - Structure of the Hamiltonian\n", "\n", "In [tutorial 4](https://nbviewer.jupyter.org/github/project-ida/two-state-quantum-systems/blob/master/04-spin-boson-model.ipynb#4.3---Structure-of-the-Hamiltonian), we learnt a lot from looking at the Hinton diagram of the Hamiltonian. What will we learn this time?\n", "\n", "We'll use an example Hamiltonian with $\\Delta E = \\omega = U = 1$ for this visual exploration." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "H = 1*two_state_1 + 1*two_state_2 + 1*bosons + 1*interaction_1 + 1*interaction_2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's not forget to make the pretty bra-ket labels for plotting. We are making use of the make_braket_labels function that we created last time and have imported from a helper file at the top of the notebook." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "bra_labels, ket_labels = make_braket_labels(nmm_list)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfMAAAGtCAYAAAACi53MAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3debglV13u8fftkwlIGDRAgAQ792EwiAMQZgJRmVGQiygSkBZFMQpGDdybwPUGRZRHRQmDGIc0oHiFyxQlPAlEoxFkCBAQiJFcOIwhJjaBbiBTn9/9o+rE3Tv77FO1a1qr6vt5nnqSvXet2mudpPt3Vg3rdUQIAADka8fQHQAAAM1QzAEAyBzFHACAzFHMAQDIHMUcAIDMUcwBAMgcxRyjZfsk2+d3cNzdtl/a9nFTZfuetj9me6/t5w/dH0myfXvbl9k+rMK++2z/tw768Hzbv9v2cYFVUMzRK9vrtq+3feTc+5fYDts7KxxjZ7nvQcv2i4i/iohHN+txHqr+TFb0QkkXRsQREXHmgu++0PbPzb13ou0vddCXTf9T0tkRce1MH64tC/fm9mBJiojDI+Kzq3yJ7bPKXxo2bO+a+/gsSc+wfYcmAwHaQDHHED4n6ac2X9j+Xkm3aPMLOipqU/Vdkj41dCc22T5U0rMk/eXcR79cFu7N7V9a+LqPSzpZ0kfnPyh/kXi3pJ9u4XuARijmGMIbdeBfgM+S9IbZHWw/oTy1+w3bX7R9xszH/1T+85rNGZjtXbbfZ/sPbe+RdEb53j+Xx3uI7attH1O+/n7b19j+7kUdtP3dtt9je085M/uJrQZj+0fKMwvX2H6/7e+b+Wzd9gtsf8L2N23/ue072n53edr6vbZvN7P/g8pjXGP747ZPnPnsQtu/VY5zr+3zZ85wLPqZ3M32P9r+ejn2v1kyhifa/lT5vRfaPq58/+8l/aCkV5fHvcdWx+jRAyVdExGVZv7lGYu7lf/+nbb/tvz/6sO2X7r5/8giEfGaiLhA0rVb7HKhpCfU7D/QOoo5hvABSbe2fZztNUk/qZvPsr6pouDfVsVflr9o+8fKzx5e/vO2czOwB0r6rKQ7SPrt2YNFxPsl/Ymk19u+hYpfKF4cEf823znbt5L0HklvKo/1U5Jea/t7Fux7X0l/IekXJH1n+R3nlLPHTU+R9ChJ95D0oypmc6dLOlLFn8Hnl8e6i6R3SXqppO+QdKqkt9q+/cyxni7pZ8p+HVLus9XP5LcknS/pdpKOlvSq+f6X33sPSX8t6RRJt5d0rqS/tX1IRPyQpIv0X7Pef190jJ59r6TLVmz7GhX/bx2l4pfIZzXsy6WSvr/hMYDGKOYYyubs/FGS/k3Sl2c/jIgLI+JfI2IjIj6hotg8YptjfiUiXhURN0bEtxd8foak20j6kKSvqPiLfZEfkbQeEWeXx/qopLdK+vEF+z5H0p9ExAcjYn9EvF7SdZIeNLPPqyLiyoj4sorC+MGI+FhEXCfp7ZLuU+73DEnnRsS55bjfI+liSY+fOdbZEfHv5fjeLOkHlvw8blBxivzOEXFtRGw1A/1JSe+KiPdExA2Sfl/FZY+HLDn2vDPLWf01tq+R9Hc12tZ1W0l7t+nDzU6Ll784PkXS/46Ib0XEpyW9vmFf9qr4fwoYFMUcQ3mjilnmLs2dYpck2w+0/Q+2r7L9dUnPVTGTXeaLyz4sC9VuSfeW9AexdcrQd0l64FxxOknFbG7Rvr8+t+8xku48s8+VM//+7QWvD5851lPnjvUwSXea2f+rM//+rZm2i7xQkiV9qDyF/uwt9ruzpM9vvoiIDRU/y7ssOfa850fEbTc3Fb8QdeVrko7Ypg/3XfD57SUdpAP/P1n6/0wFR0j6esNjAI1RzDGIiPi8ihvhHi/pbQt2eZOkcyQdExG3kfQ6FYVJkrYqwksjAMvT2P9b0tmS/mDuVPisL0r6x9niVJ5i/sUt9v3tuX1vGRF/vawvS773jXPHulVEVHn86WZjj4ivRsRzIuLOKi4DvHbz2vGcr6j4RUKSZNsqfiH58oJ9U/AJFZcs6rpK0o0qLjlsOqZhX45TcZMcMCiKOYb0s5J+KCK+ueCzIyTtiYhrbT9AxSx+01WSNiRVfna4LFC7Jf15+b1XqLimvMjfSbqH7WfaPrjc7r95U9icP5X03PJMgm3fqrx5b9HMcTt/KelHbT/G9prtw1w84nX0ti0X/ExsP3Wm7ddUFPz9C9q+WdITbP+w7YMl/bqKSwXvX2EMffiQpNuWv5xVFhH7VfzieIbtW5Y3Py69E932IS6eZbekg8v/JrN/bz5CxT0QwKAo5hhMRPy/iLh4i49PlvSbtvdK+g0VBWez3bdU3OD2vvJ09IO2OMas50u6o6T/VZ5e/xlJP2P7hAX92ivp0ZKepmLW+lVJL5d0s5l82f/nSHq1ioJ5uYpLB7VFxBclPUnFzXFXqZipv0AV/pxu8TO5v6QP2t6n4izHr0TE5xa0vUzF9fpXSbpaxU16PxoR168yjq6V/dqtos91/bKKa9xfVXGp569V/OKylfNVXAp5iIrnyr+t8mbDssg/Xs2vuwONeevLhgCQpvIO/4sk3WeLmx2rHuflko6KiNp3tdt+norLQC9c9fuBtlDMAUxGeWr9EEn/quLMxbmSfi4i3jFox4CGWCULwJQcoeLU+p0l/YekP5D0zkF7BLSAmTkAAJnjBjgAADJHMQcAIHMUcwAAMkcxBwAgcxTzxNg+2vYhQ/ejT4x5GqY25qmNF8OimCfA9n1sv8T2x1UEXlxt+y22n2H7tkP3rwuMmTGPccxTGy/SQTEfiIss7zNtf17SBZLuLullKrKnH6YivOFXJF1p+4JytamsMWbGrBGOeWrjRZp4znwgtp8l6XgVC1ZcGBE3brHfXVSs1/3EiHhsj11sHWNmzHP7jWLMUxsv0kQxBwAgc5xmBwAgcxTzxNh+qO2bRW2OGWOehqmNeWrjxbAo5ul5t6S7rNKwyaMwAz9Gw5hrYMz9tW1o5fFK2Y4ZA6GYp8e1dm7wKExCj9Ew5u12Zsw5jrnWeKVRjBkDoZhnqMmjMLk+RsOYGbMY82jGjPZxN/vAbP/G3FsvkvTHkvZsvhERvznXZuVHYZq0bQtjlsSYJY1rzKuMt2m/hx4z0kExH5jts+feOknSOZL2lq8jIp7db6+6xZglMWZpZGOe2niRFop5YmzvlfT9EfHZFdo+VNLFEXFd+z3rDmOu3ZYxZ6DJeMv22Y0Zw+Ga+bg0uVs418doGHMNjDkrUxwzVkQxH5fad8/OGOwxmoYYcz2DPB7WAsZcT65jxooo5ul5mWZumOlRr4/RzGHM/ent8bAFpjbmocYrDfvfGQOgmCcmIn4nIq5ZsfkvSLqyzf7M6+JRGMZcW6dj7upxp6mNueF4pQzHjOFwA9xEDfEYzdAYs6SOHw9LAWOWNIEx40AU84ma4mM0jFkSY5YYM0aIYg5J03yMhjHXbpvdeCXGvELbLMc8dVwzR1sa3RmeqamNeWrjlRgzMkExR1uaPEaTq6mNeWrjlRgzMkExT5ztu9pe6b9TzbZDPkZzAMbcaVvGPJAm412hfRJjRn8o5ulbl/Rx2w/vsm1ij9GsizF30jaxx8PWNa0xr2v18dZqn9CY0RNugEuc7V2SjpX02Ih4YF9th8SYGXOXbYfStM85jhn9oZgDAJA5TrMDAJA5inli3CDtqEnbITHm/toOaWpjbtrnHMeM4VDM09PkGc/Wng/t+c5bxlxPEmNeoe3Uxty0zzmOGQPhP1B6mjzj2ebzoevq6c5bMea6Uhlz3bZTG3PTPuc4ZgyEYo6tPFvS2yT93kDth8CY+2s7JMbcX1v0hLvZB7ZqklfTtkNizJIYs6Rxjblpn3McM9Jx0NAdgI6de21JR0u6Tfl62W9bTdoOiTEzZml8Y27a5xzHjEQwM09Mw7SjwZKSmrRnzL22bdLnpj+vSY25hVS+7MaM4XDNHJuSufO2R4y5v7ZDYsz9tcVAKObYlNKdt31hzP21HRJj7q8tBkIxT0+TtKNck5IYc39thzS1MTftc45jxkC4Zg5Jku2nS3pnRHxziPZDYMz9tR0SY+6vLYZDMQcAIHOcZgcAIHMUcwAAMkcxBwAgcxTzxA2VdtRzglj2bYf87hzbDvndObYd8rtJTcsD/4HSt65h0o6atB3yu4dqO+R359h2yO/Ose2Q392kLXrC3eyJs71LxZrNj42IB+bQdsjvZsx5tB3yu3NsO+R3N+03+kExBwAgc5xmB4CO2D54qPZDtcUwKOYDs3207d+2/Q+2L7X96fLfX2r7mBTbttF+yXGPsf0XObWt0t72bW0/wfZDbHvus1v55lnWWbct97m37efY/p7y9b1s/6ntN9h+9NjabuGbto9boV0b7YdqiwFwmn1Ath+mIqHoCknnS7pSRcjBHSQ9StKdJD0uIt6XSts22m/zM/l+SR+NiLVc2m7XviwM75V0exW/QH9U0lMi4vPl53eU9JWxtC0/f7ykd0jaK+lWkp4s6Q2SLimP9wgV12DfO5K2Zy76OUj6JUl/rXKN9Yh4/qKdmrQfqi3SQjEfkO2LJb1/yR/wV0p6SETcP5W2LXz3Ty9qM+Oukl6yRYEZpG0L332OpBslPVPSrSW9UtJDJP1gRHxmm6KaXduy/fsl/X1EvNj20yS9VtIfR8SLys9/R9L9IuJms91M225I+rika+Y+eoSkiyV9U1JExA9t8fNauf1QbZGYiGAbaJP0bUn3XPL5d0v6dkptW/juDUn7VMx+Fm3flLQ/pbYtfPd/SPqeufdeIenLku4h6Y5jalvu+3VJdyv/fYekGyTdd+bze0v66ojani7ps5JOnHv/Bkn32urn1Eb7odqypbVxzXxYV0h66JLPH1ruk1Lbpu2/IumnI+KIRds2xx2qbdP2h0o64BRYRPyapDdL+kdJy65N5th200bZbkPStTpw9rdX0m3G0jYiXibp6ZL+zPbLbNe6XNOk/VBtkZaDhu7AxP2+pNfZfoCk96i49hySjlJx7XmXpFMSa9u0/Uck3VfS27b4PFRcf0+pbdP2l0k6XtKnD2gQ8asuVtZ655LvzbGtVCw0cncVsz5JerCkL8x8foykr46orSLiA7bvJ+ksSR+wfdJW+7bdfqi2SMjQpwamvkn6SUkfUHFaa6Pcbijf+4kU2zZpL+kEFTfHbfX5rSQ9IqW2LXz3aZLevaTtayRtjKVt+fnJkn50yee/I+nssbRdsO9zVFyq2K8VTlc3aT9UW7ZhN26AS4SL5zqPLF9eHRE3pN62jfbAWNm+h4rZ/dsj4ht9th+qLYZDMQcAIHPcAAcAQOYo5gAAZI5iDgBA5ijmAABkjmIOAEDmWDRmILY/p7kVtir6I0m/OkTbiDgzx343aTvFMTdpy8+rXttcf14RsVVACwbCo2kDsf2IFZuuS9o5RNuI+HyO/W7SdopjbtKWn1e9trn+vKJMz0M6KOYAAGSOa+YAAGSOYg4AQOYo5gAAZI5iDgBA5ijmibL987m1HfK7GXMebYf87hzbDvndQ44Z9VHM09XkD8NQbYf8bsacR9shvzvHtkN+95BjRk0UcwAAMkcxT9dZGbYd8rsZcx5th/zuHNsO+d1Djhk1sWgMAACZY2YOAEDmKOY12f552xeXGzd5AAAGx2l2AAAyx8wcAIDMUcwBAMgcxRwAgMxRzAEAyBzFHACAzFHMAQDI3EFDd2Cqvn3ttV+VdMeh+wEAK7ryFocddtTQnUCBmflwKOQAcsbfYQmhmAMAkLlaxdz2ybZ3dtOVdNg+0fb60P0AAKCKytfMbR8j6Y8kvWnmvZMlvUDSnSR9StIpEXFR252cgsuuvlb7l6ysu2bpnkce1l+HMnDFvhu0seBntsPSnQ4/uLO2AJCaOjPzH5P0TxFxjSTZ/klJr5T0Mkn3kfR+Se+2fdcmHbK92/YZTY7R5fG6sqyQV/l8ihYV42Xvt9UWAFJTp5g/SdI7Z17/mqTdEfGnEXFpRDxP0hWSfrHNDgIAgOUqFXPbt5X0cEnnlK8PkXQ/SefP7Xq+pIe02cHUEIEKAEhN1WvmPyLpUxHx+fL1kZLWJF05t9+Vkh7ZUt+SFBFnSTpr6H4AALCp6mn2x0s6d8H781cYveC9pWyfbnvf5ibpJEkHvGf7hKGOBwBA6qrOzNcl7Zx5fbWk/ZLmV/+5g24+W9/O6yS9eeb1yyV9WdKZM+99ecDjIVE7vPiGtR3uti0ApKZqMX+HpPNsHxQRN0bE9bY/IulRkt4ys9+jJL21TgciYo+kPZuvbe+VtCciLq9znK6O15c1L79jfY0iczNNHiHj8TMAY1K1mH9Y0rckPULSBeV7r5D0RtsfkvQ+Sc+VdGcVM2PUxDPkAIBVVbpmHhGh4k72J8289zeSTpH0YkmXSHqYpMfP3CQn27tsR5urxnVxTAAAclYnNe2dKmbdz998IyJeK+m1S9ocK+nTkr5U9UsiYtc2u9Q6ZoXjAQCQtTqLxvy9pNvZ/oEabR4v6Zcj4sZ63er9mAAAZKvyzDwirpd0mzoHj4j71+7RAMcEACBnRKAutq4iVAYAgOS1VsxHFo+6U8XNfQAAJK/ODXBbIh4Vq8o1inRRv1PvM4DxamtmnmU86tjsu26/9s5s+67bP3SXtpVrFOmi/qXeZwDj1VYxJx41AfO1hNoCANPQuJhPLR6VCFQAQGrauGY+qXhUIlABAKlp4zR7FvGotk8aewzqfBYL2SwAMA1tzMzXlUc86jmSPrhCu2wcfuja0F2oLdco0kX9Tr3PAMarjWKeRTxqROyVtLduO3Qr10e5cu03gHFq4zT7bDzqpldI2mX752wfZ/uVIh4VAIBONC7mxKMCADCsVlaAU6bxqAAAVLHj1keHbry28v7x7f88LyIe22GXDtBWMb8pHjUiLqnYhnhUAEAebrxWB93ziZV3v+GSs4/ssDc300oxJx4VADBqtrwj3SeG2pqZj826iEAFAMxIuZgTgbrYThGBCgC4STEzr7r1rZViPhOBes3Meyfb/pzta21/ZIwrrgEAJsJpF/O2TrNvFYF6sqR/Lv/5btv3iogvtPSdldneLWk9Is7o+7uxHHnmAHJgSV5L9zR7W8V8ywjU8vXzbD9WRQTqaS19J1q077r9Byycb/WzPCx55gCyYGvHmK+ZTy0CdazIQgeA5VI+zd7GNfM6Eajz4SvZIc8cACZoAtfMO4lAtX2SpD+ZeetxEXFRxbanSzp95q1DJYXtU1c53izyzAFgeixrx0Hp3hOTcgRqk8jSNqNTJ2H+N62+0jyJQAWQhQksGtNJBGqTyNI2o1OnYqgs9Fzv/s613wBWN/ZiPhuBekH53iskvdH2hyS9T9JzRQQqACBXdtKPpmUXgUrMKQCgb1bad7NnFYG6arsK0akAAGxtAtfMpX4jUIk5BQD0LO1FY7KLQCXmFADQO4//BrgxWhcRqACAkjWN0+yjEhHropgDAGakXMxbyzNfJresc9sn2l4fuh8AgERMYDnXpWayzt80897Jkl4g6U6SPiXplFWWVsW0NYlPzTV6FcBQOM2edNY52rHjW1+TZxaEDVkbt7xdp9/ZJD411+hVAANx2nnmfZxm3zLrPCIujYjnSbpCRdY5MuW5DJ351wCQs80b4FI9zd5pMR9j1jkRqAAwQRO/Zl4n6/yRHfelFUSgAsA0pXzNvOvT7J1lndveN7Od0GU7bC/mQlPnXwNA7nbscOWtb13PzNeVVtZ5k4x0LNH1zW6LNMlCzzVHHcAwbMsJ/wXRdTFPKuu8SUY60tPkETIePwNQlz3dYk7WOQBgFIY4fV5Vp9fMyToHAIyCJe9w5a3SIe012x+z/XdNu9fHc+bvlPTE2Tci4rURsTMiDo2I+0XEP8216S3rHACA7VjW2tqOyltFvyLp0jb610cxvynrvEYbss4BAOloeWZu+2hJT5D0Z210r/PlXMk6BwCMQct3s/+RpBdKOqKNgxGButi6iEDt1NsvvUrX7l++tMBha9aTj7t9Tz0CgK3ZtW+AO9L2xTOvzyoXHZPtH5H0HxHxEdsnttG/WsW8TDs7t8z7HrOdKm7So6B3ZLtCXnUfAOiL612Yvjoijt/is4dKeqLtx0s6TNKtbf9lRDxj1b5VLubzUaa2Hy7pVBVrrd9Z0s9ExO5VO4JmmkZ6LmpPHGhaLt9zrbb6/WbN0t2+47BO2wNT19Zz5hFxmqTTymOeKOnUJoVcqncD3AFRppIOl/RJFXfjfbtJJ2bZ3m37jFSPl6qmkZ6L9iMONC3LTlRUOYnRtD0wZXb1pVxTX871gCjTiDhX5brrtne32y0AANLSxXKuEXGhpAubHqfSzHw+ynTKiEAFgGlqe9GYNlWdmc9HmU4WEagAMEGWdoxgbfatokwbs326pNNn3jpUUtg+dea9x0XERUMcDwAAq5vT7G2pWszXdWCUaZteJ+nNM69friKa9MyZ9+pElbZ9vCw0jfRc1D7h/28nac1b36i2VuG/VdP2wLSNIwL1gCjTNjsQEXsk7dl8bXuvpD0RcXkKx8tF00fIeAQtfU0fHePRM6CB+ovG9Krqo2mzUaaSJNuH2/6Bcs31HZLuWr6+awf9xMgcVmEqWGUfAOiL7cpb3yrNzCMibG9GmW7mkh8v6R9mdntJub1e0i6piCSVdLakY9taNa6LY6J/LNMKICfFNfOhe7G1Os+Zv1PF9ejnSzc9G7fdrx+1I0kjYlebx6xwPAAAlhvJaXap3yjTvo8JAMBSY3jOvNco076PCQDAcsNcC6+KCNTF1kViGgCgtEIEaq9au5xv+2TbO9s63sB2qohABQBA0khOsy9DPGo7msaYDmWofl929fJIz3semd5z1bnGkObab6AttrQ2gZl5lvGoqWkaYzqUofqdY6Rnjn2W8u030Ka1Ha689a2ta+bEowIARsu2Djko3QfNG/dsavGoRKACwPRY45+ZTyoelQhUAJgeWzpo5NfMO41Htb1vc5N0kqQD3rN9QsVjnbRKOwAApjAzX1ce8ajnSPrgCu160zTGdCi59hsAKvMwRbqqNop5FvGoEbFX0t4Wu9e6lB8/W2aofueYz51jn6V8+w20pZiZp3sDXBvFfDYe9QKpiEeVdLfy85viUVUU4i+08J1Aks+RbyfX57Fz7TfQppRn5o1/zYiIUHEK+0kzbx8v6WPldgsV0agfk/SbmzvY3mU72lw1rotjAgCwuWjMmK+ZS5nGowIAUIWV9jXzti4AEI8KABi1Nbvy1rdWZubEowIAxiz1tdmJQF1sXUSgAgBmpFzMiUBdbKeIQAUAlDZXgKu69Y0IVEzSUPGpuUaJ5tpvoC2p3wDX1mn2rSJQ31BugyqT29Yj4oyBu7IUeeb9GSrSM9co0Vz7DbRpCsWcCNQWkGcOAGlK/QY4IlBrIgIVAKZnCkErRKACAMZt7DNzdRSB2iSytM3oVAAANm+AG/PMfF3dRKA2iSxtMzq1N7lGiebabwCoI+WZebIRqE0iS9uMTu1Tqnd+byfHfg8V6ZlrlGiu/QbakvoNcESgYpKGik/N9XnsXPsNtMWWDjmovTzzcn2WN0g6StKGpLMi4pWrHi+7CFRiTgEAfbOqh6xUDFq5UdKvR8Rxkh4k6Zds32vV/mUVgbpquwrRqQAALLWjxTS0iLhC0hXlv++1famku6iob/X71lK/+oxAJeYUANArq7g/pOpW69jFmeb76MCbvmvJLgKVmFMAQO8s7ah3A9yRti+eeX1WuU7JgYct7jF7q6RTIuIbq3aPCNTF1kUEKgCgVMzMaxXzqyPi+KXHtA9WUcj/KiLe1qB7FPNFImJdFHMAwIw2r5nbtqQ/l3RpRLyi6fF6Kea2T5Z0blkkk2f7REm7I2LnwF0BbtI0hpQYU2B1m9fMW/RQSc+U9K+2LynfO70MKqut82JO1nk/msaQLmqfcoTpFDWNISXGFGjArnvNfKmI+Gdt/9RXZX3MzJPOOh+LpjGki/YjwnRr+67br/kfjyUdfujaEN0B0DGr3dPsbeujmJN1jtFZ9HsOv/sA45by0sXtrU23wBizzskzB4Dp2ZyZV9361vXMfHRZ5+SZA8AEJR600unMXIllnTfJSAdmLfojne4fcwBNTX1mvq60ss6bZKQnrWmm+KL2Cf8SOrghbnRrGkNKjCnQTMp/Trou5kllnTfJSE9d00fIeAQtfU2fA+c5cmB11jAz7qq6LuZknQMA8jfla+ZknQMAxqC4Zl5961sfz5knnXUOAEAVNYNWetX13ewSWecAgMxN/W52ss4BSS8+7zPae93+SvseceiaXvqYu3fcIwC1WFrrY/q7IiJQF1sXEahoUdVCXndfAP0Y1drsuUWZNrBT0imioCetSaQncaB5+OgV+3TjxtafH7RDuu+dDm+9LTDPsg7eke7UvHLPZqJMrylfn2b7w7a/Yfsq239r+95ddRSY1yTSkzjQPCwrxtt93qQtcDPlafaqW9/qfOV8lOmJkl4r6SGSfkjSjZLea/s7mnTI9m7bZzQ5RpfHAwBMz5hugJuPMn3M7Ie2nynp65IeKulvW+kdAACJSPiSebWZecUo0yPK432thX4liwhUAJimHXLlrW9VZ+ZVokxfKekSSf/SuFcJIwIVAKbHSntmXrWYL40ytf0KSQ+T9LCIqPVcje3TJZ0+89ahksL2qTPvPS4iLhrieAAASGknSVYt5uvaIsrU9h9KepqkH4yIz67Qh9dJevPM65eriCY9c+a9OlGlbR8PiWoS6UkcKIBaPI6Z+cIoU9uvVFHIT4yIf1ulAxGxR9KemWPuVZGgdnkKx0O6mjwLznPkeThox/JHyA5actdPk7bAPA90LbyqqsV8UZTpayQ9U8Uja1+zfVS5776I2Nd2R4GcHXHoWq3lXFFosqgLC8KgbdnPzCMibG9GmV5Qvn1y+c8L5nZ/iaQzpCKSVNLZko5ta9W4Lo4JdI211oH8jeGauXTzKNMqw6odSRoRu9o8ZoXjAQCwrYRrea0V4PqMMu37mAAAbGk0K8D1GWXa9zEBANhO9tfMJ2hdJKYBAGak/ABEa8V8ZPGoO0UEKhLy9kuv0rUV4twOW7OefNTn8LIAABFLSURBVNzte+hRdcuiSFONISU+FfNsyQlPzVsp5jPxqG8qX58m6b9Luqek6yR9QNJpEfHJNr4P45BrpvgQ/a5SyOvs16cmMaVDIT4Vi6R8N3tbZw2yjEfFsHLNFM+13wCasatvfWvrNDvxqACA0bLSvmbeuG9Ti0clAhUApsl25a1vbczMJxWPSgQqAEyQx3/NvGo86lNWiUe1vW9zk3SSpAPes31CxWOdtEo7AACs4gbXqlvf2piZryuPeNRzJH1whXYAAIz+0bQs4lEjYq+kvav0A93INVM8134PZVkUaaoxpMSnYl6xnGuLx7Mfq+IS9JqkP4uI321yvDaKOfGoWEmqz5FvZ4h+H7bmyovGpCbHxVVy7DO619afLttrkl4j6VEqQsM+bPuciPj0qsdsXMyJRwW6l9qqbsD0tBqg8gBJl29efrb9f1TU0OGKeSnLeFQAACppdzGYu0j64szrL0l6YJMDtnXlh3hUAMBoOaLWJunImTVJ5tclWfRrQaP1I1uZmROPCgAYvai1KP/VEXH8Fp99SdIxM6+PlvSVVbslEYG6lXWRmAYAmOF6xXyZD0u6u+1jVTwm/TRJT29yQCJQF9spIlAxIlUiVFOMTwXSEXVn5lsfKeJG278s6TwVj6b9RUR8qskxiUDFYIhA7U+Vx9q6ik8lzxyjEe39GYmIc7Vk9dS6sopAXRXRqWnKNUo0134PhTxzjEKUM/OqW8+IQAUAoIIWr5m3jgjUmohABYCJGvnMnAhUAMDItXcDXBeSjUBtElnaZnQqAAAKjX5mvq5uIlCbRJa2GZ0KAJi8kDbSnZknG4HaJLK0zehUdCfXKNFc+z0UIlAxFinfAEcEKgaT4vPYVeTY7yoRql3Fp+b4PHaOfUYPxlzM+45AJeYUqI+V3YCGIlpdNKZtWUWgrtquQnQqAADLJTwzzzEClZhTAEDvHBuVt75lF4FKzCkAoH8hbaQ7hyQCdbF1kZgGANgU4180Zlu2T7a9s4/vaslOFRGoAADImsBp9mWIR0VXmkSR5hhjOqTLrl7+87rnkd38vJpEkRJjitYlvGhMHzPzpONRka8mUaTEmNYz1M+rSRQpMaZoV/zX42lVtp71cc2ceFQAQN4212ZPVKfFfCYe9WeX7DaaeFQAwHilvJxr16fZRxePSp45AExRJJ2a1nUxTyoetUms6qaIOCsiji83cs0BYCoSLuZdXzNfV1rxqE1iVQEAUxUhbVSec/au62KeVDxqk1hVpKdJFCkxpvUM9fNqEkVKjCnaFgk/mtZ1MSceFZ1p8iw4z5HX09Vz5Ntp8hw4z5CjXWnPzDv93TQiQsWp7SfNvH2yijvYL5B0xcx26uYOtnfZjrqrxq3aDgCApUJFMa+69ayP58yTjkcFAGA7oVDsn+jMvEQ8KgAgb6FiOdeqW886n5kTjwoAyF/a18yJQF1sXUSgAit76lkf1te+dUOtNre75cF6y8/z+zgSFaGgmOclItZFMQdWVreQr9oG6NVYHk2zfbKkc8tiN1q2T5S0OyJ2DtwV4CbEgU7DRZ//hq7f2Dp165Ad1gnfdevW22I7ac/MK98AN5NLfk35+pdsf8L2N8rtX2w/oauOAlNHHOg0LCvG233epC22kfijaXXuZp/PJf+SpP8h6b6Sjldx1/o7bH9fkw7Z3m37jCbH6PJ4AIApitHczT6fS/7Ouc9fZPsXJT1Y0ida6BsAAGmIUNxw/dC92FKlmflMLvk5W3y+Zvtpkg6X9P72upceIlABYII2g1YSPc1edWa+MJfc9veqyCE/TNI+SU+OiH9tt4tpKWNPiT4FgIlJOWil6jXzrXLJL5P0A5IeJOmPJb3e9r3rdMD26bMZ45JOknTAe3Vyx9s+HgAANy0a08PM3Pbv2f638ibzt5dnx5eqOjNf14Jc8nJ1t8vLlxfbvr+kX5X0sxWPKxXrtr955vXLVeSMnznzXp3c8baPBwCYus272fvxHkmnRcSNtl8u6TQVN5xvqWoxX5hLvsAOSYdWPKYkKSL2SNqz+dr2Xkl7IuLyrVv1dzwgFWR7T8MhO7zts+JdtMVyoejtNHtEnD/z8gOSfny7NlWL+aJc8t+V9C5JX1QRafp0SSdK4llzoANke09Dk0VdWBCmQ/3OzGc9W9LfbLdTpd/Ht8glP0rSX6q4bn6BpPtLelxEvHtzhy7yxcksB9J3u1se3EsboD+1r5kfOfPk082efrL9XtufXLA9aWafF0m6UdJfbde7Os+Zz+eS76rQpna+eIXj1jpmxX4CaBGBKRidUN0886sj4vgtDxfxyGWNbT9LxZNkP1xOqJeqU8xvyiWPiEsqtukiX5zMcgBAz6K3ld1sP1bFDW+PiIhvVWlTuZj3mUve9zEBANhWf9fMX63iZvL32JakD0TEc5c1IAJ1sXURgQoM5sXnfUZ7r6v2F+cRh67ppY+5e8c9wuT1mGceEXer26a1Yj6yeNSdkk4RBR0tyzWKdFm/u+hz1UJed98+bBdDKqUZRUp86vbGsALcUsSjAtXkGkXaJF51aqrEjKYYRUp86jYiFPs3Km99a2tmvlU86mdU/MLwLBXxqPeLiJUT1WzvlrQeEWc06y4AANVFaJAiXVVbxZx4VADAiPW3AtwqGp9mn1o8KhGoADBB5cx8zKfZJxWPSgQqAExTyqfZ27gBLot4VNsnEYMKAFhFRGhj//7KW9/amJmvK4941HMkfXCFdgAAJH3NvI1inkU8akTslbS3bjugTblGkS7rd6p9Hsp2MaSb+6SG+NRtlI+mpaqNYk48KlBRigvCVNF3v484dK3WCnApyXVhlVz73adRF/OICNub8agXlG9vxqMeJenrKh5He1xEnLfZzvYuSWdLOratVeO6OCaA/rE8K1ITEdp/Q7r5Xm09Z55lPCoAAJVMZNEY4lEBAOM1gWvmxKMCAEYtNP672cdoXSSmAdmqGqFKfCoqm8LMXCICFaiCCNR+VL0Tvov4VCJQxyvlYk4EKtAjIlDHjwjUkQppY2Oj8ta3rCJQV0V0KgCgidA0TrMTgQoAGK+QYoA116siArUmIlABYIqKPPOqW9+IQK2JCFQAmKDEF41JNgK1SWRpm9GpAACovGZedetbyhGoTSJL24xOBQBMXIS0kfDMPNkI1CaRpW1GpwJtIgJ1/IhAHasY/QpwRKACFaW2uEpVufZ7CLkurJJrv3sz9mvmEREqTok/aebtzQjUy1QU+PuriEB99+YOtnfZDts763zfqu0ATEfVjPPUstCRsJBif1Te+pZVBOqq7Sr2B8BIsN462haKpK+Zt3W166YI1BptVo0rJeYUANCvkGIjKm99yy4ClZhTAMAQNgY4fV4VEaiLrYvENABAKRK/Aa6XYp5hPOpOEYEKTNbbL71K124zCztszXrycbdv/bubRJESY9qhGObGtqo6L+Yz8ahvKl//kqRf0H8tNPMpSS+NiHd13RcgZ02y0HPNUR/KdoW86j6raBJFSoxph0Laf326QSt9zMyTjkcFctEkCz3XHHUgFSFpI+Ffhvoo5sSjAgDylvhp9k4XYhxjPCoRqAAwTRv7Nypvfet6Zj66eFQiUAFgeqJcAS5VXUckJBWP2iRWFQAwYQMs52r71HL58iO327frmfm60opHbRKrCgCYrH6Xcy2fBHuUpC9U2b/rYp5UPGqTWFVgaE3iU3ONXgWSUS7n2qM/lPRCzdxAvkzXxZx4VKAlTZ4D5xnyeg5bc6VFY7rQJFecTPLuhPpbztX2EyV9OSI+blf7b9ZpMY+IsL0Zj3pB+fZmPOpRkr6u4nG0x0XEeZvtbO+SdLakY+usGrdqOwCY1cXKblU1WaGN1d06FFF3OdcjbV888/qs8gZqSZLt96qog/NeJOl0SY+u82V9PGeedDwqAABV1Lyx7eqIOH7LY0U8ctH75dNex0ranJUfLemjth8QEV/d6nh9FPOb4lEj4pKKbYhHBQAkI6Kf0+zlY9p32Hxte13S8RFx9bJ2nRdz4lEBTMEJLzpf/7n3+lptvvOIQ3TRb9c6m4oBxUa66x4TgbrYukhMA1BD3UK+ahsMJGKQPPOI2FllP4r5AuXNcxRzAEAh8RXgahXzDHPJV2L7REm7q/5GBKAbZHsjFSHVvZu9V5WXipjJJb9mwWenl0vOvbrNzgGYNrK9kYzyBriqW9/qrPs0n0suSbL9IEnPUUvxpbZ32z6jjWN1cTwAwBRVX5d9iNPxdYr5AbnkkmT7NpL+SsWa6l9rsV8AACQjQtqIqLz1rVIxX5JLfpak/xsRf992x1JFnjkATNP+iMpb36reAHezXHLbz5F0N0nP7KJjqSLPHACmJyQlfDN75WJ+QC657XtKepmkE8pFYVZm+3QV69BuOlRS2D515r3HRcRFQxwPAABJg8y4q6pazNd1YC75gyUdKemTM4kua5Iebvu5km4VEddVPPbrJL155vXLVeSMnznzXp3c8baPBwCYuI1I+wmIqsV8Ppf8HZIuntvnbEmfUTFjrzxbj4g9kvZsvra9V9KeiLi86jG6PB6A4RAHipSM4TT7Abnk5eNp84+ofVNF0fxku10EMFXEgSIVoWFubKuq0t3sEREq7mR/Up2D295VLiazs37X+jsmADT1nUcc0ksbDGPzBriqW9/qLOd6QC75vIg4ccHbtfPFK+Sd1zpmxfx0AGiE9LPxS/k0e51FY27KJa/Rpot8cTLLAQC9ihjHc+a95pL3fUwAGNpTz/qwvvatGyrvf7tbHqy3/Dx/HfYp5Zk5EaiLrYsIVAA9qlPIV9kfzRTXzNOt5q0V85HFo+6UdIoo6EAj28WQSmlGkRKfinmprwBX55r5lohHBbBIlUU2UlyIg/hULDKKa+bb6C0eVdJ6RJzRxvEAAKgiBnrkrKpWZuYiHhUAMHIpz8wbF/OpxaMSgQoA0xOSNmpsfWvjNPuk4lGJQAWAKRrBcq7b2Coe9aQ24lFt79vcJJ0k6YD3bJ9Q8VgnrdIOAIAxLee6lXXlEY96jqQPrtAOADBxU3jOPIt41IjYK2lv3XYAVrddDOnmPqkhPhU3k/jd7G0Uc+JRASyU68IqufYb3Ul9Zt74mjnxqADQ3O1ueXCn+6O5sV8zlzKNRwWAVBCakrbUZ+ZtFfOb4lEj4pKKbYhHBQBk4Spdf95r4/NH1mhydWedWaCVYk48KgAMh/jU7kXEY4fuwzJtLec6NusiMQ1AJohPBRGoi+0UEahAY0SgAv0gAhVAZ4hABfrR1mn2XiJQV2V7t+0zhuwDAABdIQIVAIDMEYFaExGoAIDUEIFaExGoAIDUJBuB2iSytM3oVAAAUpdyBGqTyNI2o1MBAEhashGoTSJL24xOBbA6IlCBfhCBCqAzuS6skmu/MV3ZRaAScwoAByI+FVlFoK7arkJ0KgBki9AUtLVozE0RqDXarBpXSswpAAAzsotAJeYUAIADtZaaNjLrIjENwES8+LzPaO91+yvte8Sha3rpY+7ecY9QVy/FPMN41J0iAhUYXJMoUmJMq6tayOvui/60dc18S8SjAlhVkyhSYkwxJZ0XcyUejwoAQO76KObEowIA0KFOi/kY41GJQAUApKbrG+BGF49KBCoAIDVdn2ZPKh61SawqAACp6npmvq604lGbxKoCAJCkrot5UvGoTWJVAfSvSRQpMaaYkq6LOfGoAFbWZFEXFoTBlHR6zZx4VABI3xGHrnWyL/rTx3KuScejAsDUsdZ6/vpYNIZ41MWuHLoDANAAf4clpPOZOfGoi93isMOOGroPAIBx6GNmnqN1kZgGAMiEi3vUAABArpiZAwCQOYo5AACZo5gDAJA5ijkAAJmjmAMAkDmKOQAAmaOYAwCQOYo5AACZo5gDAJA5ijkAAJmjmAMAkDmKOQAAmaOYAwCQOYo5AACZ+//JVv43w8z1vQAAAABJRU5ErkJggg==\n", "text/plain": [ "