From 48351dd80117f39d3df8f2e076beb931218ac02a Mon Sep 17 00:00:00 2001 From: Andrew Hardy Date: Wed, 4 Jun 2025 19:45:25 -0400 Subject: [PATCH] data --- .../06-Discrete_Lehman_Representation.ipynb | 201 +++++ .../06s-Discrete_Lehman_Representation.ipynb | 685 ++++++++++++++++++ 2 files changed, 886 insertions(+) create mode 100644 ModelDMFT/06-Discrete_Lehman_Representation.ipynb create mode 100644 ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb diff --git a/ModelDMFT/06-Discrete_Lehman_Representation.ipynb b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb new file mode 100644 index 0000000..f680c95 --- /dev/null +++ b/ModelDMFT/06-Discrete_Lehman_Representation.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# A DLR DMFT calculation\n", + "\n", + "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "\n", + "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + "\n", + "## Discrete Lehman Representation\n", + "Here we take advantage of the spectral representation of the Green's function\n", + "\\begin{equation}\n", + "G(\\tau)=-\\int_{-\\infty}^{\\infty} K(\\tau, \\omega) \\rho(\\omega) d \\omega\n", + "\\end{equation}\n", + "with the fermionic kernel being given by \n", + "\\begin{equation}\n", + "K(\\tau, \\omega)=\\frac{e^{-\\omega \\tau}}{1+e^{-\\beta \\omega}}\n", + "\\end{equation}\n", + "The kernel $K$ can be approximated by a low rank decomposition. This has some negative consequences, such as the ill-conditioning of analytic continuation (which you make have seen in the Pade approximates used in previous tutorials), but it also has some benefits. This behaviour can be exploited to provide a compact representation of $G$. \n", + "\\begin{equation}\n", + "G(\\tau) \\approx G_{\\mathrm{DLR}}(\\tau)=\\sum_{k=1}^r \\frac{e^{-\\omega_k \\tau}}{1+e^{-\\omega_k}} \\widehat{g}_k=\\sum_{k=1}^r \\widetilde{g}_k e^{-\\omega_k \\tau}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", + "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", + "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", + " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", + "\n", + " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f916c67b", + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c53fb03e", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "741f5e46", + "metadata": {}, + "outputs": [], + "source": [ + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "# careful! does not work without symmetrize=True\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + ] + }, + { + "cell_type": "markdown", + "id": "cbef9746", + "metadata": {}, + "source": [ + "### A word of caution\n", + "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cef335d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.50000001+2.1345501e-16j]]\n", + "[[0.00044346+2.40809328e-11j]]\n", + "[[-0.50000001-5.37912629e-16j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[nan+nanj]]\n", + "[[nan+nanj]]\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(2)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", + "\n", + "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", + "print(G_dlr(0)) # evaluating at iw_0 for int\n", + "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", + "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", + "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", + "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", + "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", + "\\end{equation}\n", + "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + ] + }, + { + "cell_type": "markdown", + "id": "1b42178d", + "metadata": {}, + "source": [ + "### Optional Exercise 1b\n", + "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 10, 20$ should be slow enough. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "45fedad2", + "metadata": {}, + "source": [ + "### Exercise 2 \n", + "\n", + "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb new file mode 100644 index 0000000..3222d42 --- /dev/null +++ b/ModelDMFT/solutions/06s-Discrete_Lehman_Representation.ipynb @@ -0,0 +1,685 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "329ad08d", + "metadata": {}, + "source": [ + "# A DLR DMFT calculation\n", + "\n", + "The goal of this notebook is to make a more economical DMFT calculation using the Discrete Lehman Representation of Green's functions (DLR). If you are interested in more of the theory behind this method,a good first reference is [(here)](https://doi.org/10.1103/PhysRevB.86.085133), which this tutorial follows closely. \n", + "\n", + "You will construct first a simple self-consistent loop for the Sachdev-Ye-Kitaev model, and then an IPT calculation with a more compact and economical framework than in Tutorial 1. \n", + "\n", + "## Discrete Lehman Representation\n", + "Here we take advantage of the spectral representation of the Green's function\n", + "\\begin{equation}\n", + "G(\\tau)=-\\int_{-\\infty}^{\\infty} K(\\tau, \\omega) \\rho(\\omega) d \\omega\n", + "\\end{equation}\n", + "with the fermionic kernel being given by \n", + "\\begin{equation}\n", + "K(\\tau, \\omega)=\\frac{e^{-\\omega \\tau}}{1+e^{-\\beta \\omega}}\n", + "\\end{equation}\n", + "The kernel $K$ can be approximated by a low rank decomposition. This has some negative consequences, such as the ill-conditioning of analytic continuation (which you make have seen in the Pade approximates used in previous tutorials), but it also has some benefits. This behaviour can be exploited to provide a compact representation of $G$. \n", + "\\begin{equation}\n", + "G(\\tau) \\approx G_{\\mathrm{DLR}}(\\tau)=\\sum_{k=1}^r \\frac{e^{-\\omega_k \\tau}}{1+e^{-\\omega_k}} \\widehat{g}_k=\\sum_{k=1}^r \\widetilde{g}_k e^{-\\omega_k \\tau}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "id": "fee0f10b", + "metadata": {}, + "source": [ + "### Constructing DLR Green's Functions\n", + "The DLR Green's function is constructed on $r$ Matsubara frequency points which are uniquely determined (independent of $G$) by a error $\\epsilon$ in the accuracy of the representation and a high-energy cutoff. $\\Lambda = \\beta \\omega_{max}$. \n", + "These values are given to TRIQS via the parameters `dlr_error` and `w_max` . In general, these should be convergence criterion. \n", + "Particular care is needed when approximating stochastic data, such as quantum Monte Carlo data, which might include statistical noise.\n", + " For the determinstic Dyson equations solved here, these should be made quite large and small respectively. Here you will see that the representation needs only $\\mathcal{O}(10^2)$ points to converge correctly, compared to $\\mathcal{O}(10^8)$ with a uniform Matsubara grid. \n", + "\n", + " The example below shows how to construct a fermionic Green's function in both Matsubara frequencies and imaginary time. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f916c67b", + "metadata": {}, + "outputs": [], + "source": [ + "from triqs.gf import *\n", + "from triqs.gf.tools import *\n", + "from triqs.operators import *\n", + "from triqs.gf.block_gf import *\n", + "from triqs.gf.descriptors import Function\n", + "import h5\n", + "import numpy as np\n", + "from triqs.plot.mpl_interface import *\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import json, sys, os\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c53fb03e", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "741f5e46", + "metadata": {}, + "outputs": [], + "source": [ + "gf_struct =[('up',1), ('dn',1)]\n", + "iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + "# careful! does not work without symmetrize=True\n", + "G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + "G_tau = make_gf_dlr_imtime(G_iw)\n", + "Sigma_iw = G_iw.copy()\n", + "Sigma_tau = make_gf_dlr_imtime(Sigma_iw)" + ] + }, + { + "cell_type": "markdown", + "id": "cbef9746", + "metadata": {}, + "source": [ + "### A word of caution\n", + "The DLR representation now allows one to evaluate $G(\\tau)$ for any $\\tau$, even if it is not included in the original grid. While these are faithful representations, the current TRIQS implementation does not impose additional properties of Green's functions, such as antiperiodicity. See the below examples for some subtleties in evaluating $G(\\tau)$. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cef335d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.50000001+2.1345501e-16j]]\n", + "[[0.00044346+2.40809328e-11j]]\n", + "[[-0.50000001-5.37912629e-16j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[-0.06406086-4.89547088e-17j]]\n", + "[[nan+nanj]]\n", + "[[nan+nanj]]\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(2)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "G_dlr = make_gf_dlr(G_iw[\"up\"]) # the DLR coefficents \n", + "\n", + "print(G_dlr(0.0)) # evaluating at tau = 0.0 for float\n", + "print(G_dlr(0)) # evaluating at iw_0 for int\n", + "print(G_dlr(50.0)) # evaluating at tau = beta gives density\n", + "print(G_dlr(45.0)) # evaluating at tau = 5.0\n", + "print(G_dlr(-5.0)) # evaluating at tau = -5.0 does not obey G(-tau) = -G(beta - tau)\n", + "print(G_dlr(-150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n", + "print(G_dlr(150.0)) # evaluating outside the range of the DLR coefficients does not wrap back around\n" + ] + }, + { + "cell_type": "markdown", + "id": "d5547d81", + "metadata": {}, + "source": [ + "### Exercise 1 \n", + "Now we are going to evluate the self-consistent Dyson loop for the $O+1$D (impurity) Sachdev-Ye-Kitaev (SYK) model. The Hamiltonian is given by \n", + "$$H = \\sum^N_{ijkl} J_{ijkl} c^\\dagger_i c^\\dagger_j c_k c_l$$\n", + "where the $J_{ijkl}$ couplings between $N$ fermions that are random Gaussian couplings with constant variance $J^2$.\n", + " This model has many interesting applications for non-Fermi liquids, or strange metals, and quantum criticality. You can read more about the model and its' extensions [(here)](https://doi-org.myaccess.library.utoronto.ca/10.1103/RevModPhys.94.035004). Here we are just interested in the simple form of the self-energy in the large-$N$ limit of the model which is exactly solvable. Here we have (up to some prefactors)\n", + "\\begin{equation}\n", + "\\Sigma(\\tau) = -J^2 G^2(\\tau)G(-\\tau)\n", + "\\end{equation}\n", + "which has a superficial resemble to the IPT equations (except with the local $G$ rather than the Weiss $\\mathcal{G}_0$). Now it is your turn to write a self-consistent loop to solve for $G$. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5711f528", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.001559070505714749 5\n", + "1.0349249103620503e-05 10\n", + "1.8579473901673987e-07 15\n" + ] + } + ], + "source": [ + "G_iw << SemiCircular(1.0)\n", + "G_tau << make_gf_dlr_imtime(G_iw)\n", + "error = 1.0\n", + "iter = 0\n", + "while error > params[\"threshold\"]:\n", + " for block, g in G_tau:\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", + " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", + " for block, g in G_tau:\n", + "\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", + " #G_tau << make_gf_dlr_imtime(G_iw)\n", + " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", + " # right now the spin blocks are the same / irrelevant. \n", + " iter += 1\n", + " if iter % 5 == 0:\n", + " print(error, iter)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c0669c9e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f728e5fc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", + "plt.xlim(-20,20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1b42178d", + "metadata": {}, + "source": [ + "### Optional Exercise 1b\n", + "To really see the power of DLR, try converging these equations down to lower $T$. To do this, take a higher $T$ solution as a guess and continue lowering $T$. Steps of $\\beta = 50$ should be slow enough, although you can optimize this with your $\\alpha$ mixing parameter. As you approach the $\\beta = \\infty$ limit, your result should begin to match the conformal solution to these equations. Try comparing!\n", + "\\begin{equation}\n", + "G_c(\\tau)=-\\frac{\\pi^{1 / 4}}{\\sqrt{2 \\beta}}\\left(\\sin \\left(\\frac{\\pi \\tau}{\\beta}\\right)\\right)^{-1 / 2}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f5c2940", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.80,\n", + " \"w_max\": 20.0,\n", + " \"dlr_err\": 1e-10, \n", + " \"J\" : 1.0,\n", + " \"max_iter\": 1000,\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0ac25f3a", + "metadata": {}, + "outputs": [], + "source": [ + "betas = np.array([50.0,100.0, 150.0, 250.0, 350.0,400.0,450.0 ,500.0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "aaf1d1d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.00018642980121496007 20 50.0\n", + "1.0551719818406181e-06 40 50.0\n", + "0.0010133481924638882 20 100.0\n", + "9.020256563906696e-06 40 100.0\n", + "9.256213401949465e-08 60 100.0\n", + "1.2355223139904116e-05 20 150.0\n", + "5.130730897831215e-08 40 150.0\n", + "1.3878098026234743e-05 20 250.0\n", + "5.989698240910868e-08 40 250.0\n", + "9.581600005583062e-06 20 350.0\n", + "4.130081612291154e-08 40 350.0\n", + "4.113186540783512e-06 20 400.0\n", + "1.7995074533369348e-08 40 400.0\n", + "3.6162068025034036e-06 20 450.0\n", + "1.608034789948581e-08 40 450.0\n", + "3.390955130622913e-06 20 500.0\n", + "1.43680989989107e-08 40 500.0\n" + ] + } + ], + "source": [ + "for i, beta in enumerate(betas):\n", + " gf_struct =[('up',1), ('dn',1)]\n", + " params[\"beta\"] = beta\n", + " \n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps = params[\"dlr_err\"], symmetrize = True)\n", + " # careful! does not work without symmetrize=True\n", + "\n", + " G_iw = BlockGf(mesh=iw_mesh, gf_struct=gf_struct)\n", + " G_tau = make_gf_dlr_imtime(G_iw)\n", + "\n", + " if i == 0:\n", + " G_iw << SemiCircular(2)\n", + " if i > 1:\n", + " tau = np.array([x.real for x in G_tau.mesh.values()], dtype=np.float64)\n", + " old_tau = np.array([x.real for x in G_old.mesh.values()], dtype=np.float64)\n", + " old_beta = np.max(old_tau)\n", + " tau_prime = tau*old_beta/params[\"beta\"]\n", + " G_dlr = make_gf_dlr(G_old)\n", + " for block, g in G_tau:\n", + " g.data[:,0,0] = np.array([G_dlr[\"up\"](t)[0,0] for t in tau_prime])\n", + " G_iw << make_gf_dlr_imfreq(G_tau)\n", + " G_tau << make_gf_dlr_imtime(G_iw)\n", + " Sigma_iw = G_iw.copy()\n", + " Sigma_tau = make_gf_dlr_imtime(Sigma_iw)\n", + " error = 1.0\n", + " iter = 0\n", + " while error > params[\"threshold\"]:\n", + " for block, g in G_tau:\n", + " Sigma_tau[block].data[:,0,0] = params[\"J\"]**2/4 * g.data[:,0,0]**2*np.flip(g.data[:,0,0])\n", + " #Sigma_tau[block].data[:,0,0] = params[\"J\"] * g.data[:,0,0]**3 # works only for particle hole symmetric systems\n", + "\n", + " Sigma_iw << make_gf_dlr_imfreq(Sigma_tau) \n", + " for block, g in G_tau:\n", + "\n", + " G_iw[block] << inverse(iOmega_n - Sigma_iw[block])\n", + " G_old = G_tau.copy()\n", + " G_tau << params[\"alpha\"]*G_old + (1-params[\"alpha\"])*make_gf_dlr_imtime(G_iw)\n", + " #G_tau << make_gf_dlr_imtime(G_iw)\n", + " idx = np.where(G_old[\"up\"].data[:,0,0] == 0.0)[0]\n", + " G_old[\"up\"].data[idx,0,0] = 1.0\n", + " error = np.mean(np.abs((G_tau[\"up\"].data[:,0,0] - G_old[\"up\"].data[:,0,0]) / G_old[\"up\"].data[:,0,0]))\n", + " # right now the spin blocks are the same / irrelevant. \n", + " iter += 1\n", + " if iter % 20 == 0:\n", + " print(error, iter, params[\"beta\"])\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break\n", + " G_old = G_tau.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0454b32d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1sAAANGCAYAAAALdJRAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACfq0lEQVR4nOzde3hU5b33/8/M5IiYICQkAXOAoKCCZwSts0sqFYtadAxUEX+ttWrd27aAxa0tz7bdxdrdjSFPbXetbbXdDy0qYbQttra2NjoqSOqhosQTQogxgSRAAiTkMLN+fywmyUASEjLJmrXm/bquuTKZtWbmGzJkvp+573Uvl2EYhgAAAAAAUeW2ugAAAAAAcCLCFgAAAAAMA8IWAAAAAAwDwhYAAAAADAPCFgAAAAAMA8IWAAAAAAwDwhYAAAAADAPCFgAAAAAMA8IWAAAAAAwDwhYAAAAADAPbhq2f/OQnKigoUEpKimbNmqUtW7b0u//69es1bdo0paSkaMaMGfrjH/84QpUCAAAAiEe2DFtPPPGEli9frvvuu0+vv/66zjnnHM2bN0979uzpdf9XXnlFN9xwg2655Ra98cYbuuaaa3TNNdfo7bffHuHKAQAAAMQLl2EYhtVFDNasWbM0c+ZM/fjHP5YkhUIh5ebm6mtf+5ruueeeY/b/whe+oEOHDmnjxo1dt82ePVvnnnuuHn744RGrGwAAAED8SLC6gMFqb2/Xa6+9pnvvvbfrNrfbrblz52rTpk293mfTpk1avnx5xG3z5s3T008/3efztLW1qa2trev7UCikvXv3aty4cXK5XEP7IQAAAADYlmEYOnDggCZMmCC3u+/JgrYLWw0NDQoGg8rKyoq4PSsrS++++26v96mrq+t1/7q6uj6f54EHHtB3v/vdoRcMAAAAwJGqq6t16qmn9rnddmFrpNx7770Ro2FNTU3Ky8tTdXW10tLSRrSWyy+/XK+++mrEbas/m6RvPtd+zPdHf/3rTamaOdH8NQeqOnXVulb99aZUHe5U1/WZExMitoX372nLx5367NpWSTpmn/7uO9DH3bhxo7xeb5//BoFAQFddddWgHudE7hOt5x6OxxjJx43V5x0su9Q5ULHw88RCDSMp/PNKx/7tC3Pqz8zrLHrs8vM47T0llt6/Y7WP6atPO5G+sL8+s+dj9tWz9ud4dVx55ZX67W9/2+9jRFtzc7Nyc3N18skn97uf7Y7Zam9v16hRo1RWVqZrrrmm6/YvfvGL2r9/v373u98dc5+8vDwtX75cS5cu7brtvvvu09NPP61//vOfA3re5uZmpaenq6mpacTDVlNTk8aMGSO3JJckt1u6fLJbb9eH1NAiuVzSnHy33q43ND3TvD38dcZ4j56+PlVul0vBkKEpDx3UjPFubViUqtN/fKhru2HoyLbu/cNChqFrnjisra3m6OCM1N16+gspXfuEH3d6plu/u2FUxH07giGN/eFBfTo/Qb+/offHfftwtj7YvkMej6fPf4NgMKgpkwuOee7+HudE7hOt5x6OxxjJx43V53VqnQMVCz9PLNQwkoLBoAon5atxd42KCjx6+vpRx/zMn1/Xqm3tOY76ma3+HcdCDdFkl5/Hae8psfT+Hat9TF99Wn+9XV99Yc9ecsOilIg+s2cfOj3TdUzPunVPUA0t5uMbhtQelDyS2gwpwS1dUejptY4F61r07Pag9jUd0OjRo/v8NxgOA84Ghg1ddNFFxp133tn1fTAYNCZOnGg88MADve6/aNEi46qrroq47eKLLzZuv/32AT9nU1OTIcloamo6saKHqLCw0JAUcbkgx9113XXke5dkXHjU16tP9xivfHmU0XzPycb3P5NkuCTjytM8XdevOrJ97bUp5vende//ypdHGVdPTTRcLpexYcMGY8OGDYbL5TKunpoYsc+FEzyGJOOq0xOPua8kw+XSMffp+bgD0ddz9/c4J3KfaD33cNUyUo8bq887WHapc6Bi4eeJhRpG0oYNG7r+zl51euTfxytP8xgulxz5M1v9O46FGqLJLj+P095TYun9O1b7mL76tP56u776wp695NF9Zs8+9Pxeetaj+9yjL0f3p1edZtY3c+bMAf0bRNtAs4Etw9bjjz9uJCcnG7/61a+Mbdu2GbfddpsxZswYo66uzjAMw7jpppuMe+65p2v/l19+2UhISDBWr15tVFZWGvfdd5+RmJhobN26dcDPaXXYMozuwOU6cklwmy8+t8u8hL/v62v4Mj5znJGVOa7r+6O3Jyd6Ir6flJ8b8Z95w4YNRkHeqcfss2LFil5vD/9n7GvbYJzI41j53MNVy0g9bqw+72DZpc6BioWfJxZqGEkbNmwwMjPGHfP3Mnt8hqN/Zqt/x7FQQzTZ5edx2ntKLL1/x2ofcyK9XX+P27OX7K8PPbpXDfe0bpfZ67pd6vNxEtzWBS3DGHg2sN00wrAf//jH+u///m/V1dXp3HPP1Y9+9CPNmjVLkjRnzhwVFBToV7/6Vdf+69ev18qVK7Vz506ddtpp+uEPf6j58+cP+PmsnEbYU1NTk+bNm6c33nhDnZ2dSk9P19SpU3X22WfrlFNOUU1NjU499VRlZGRo/Pjxamxs1Lhx49TY2KjMzExNnDgxYi5wbW2txo8fL0nas2ePcnJydMkll+iVV15RbW2tcnJy5PV6jxmeDgaDXffvuU9ft/d3n8E6kcex8rmHq5aRetxYfd7BskudAxULP08s1DCSgsGgysvLVV5eLsl8r5kzZ47jf2arf8exUEM02eXncdp7Siy9f8dqH3MivV1fj9uzlzy6z+zZh9bU1Ki+vr6rVx03bpzq6+tVX1+vXbt2KRgMqqGhQQcOHND777+vQ4cOKSEhQUVFRXriiSdGfOpgTwPNBrYNWyMtVsIWAAAAho9hGOrs7FQwGLS6FFjI4/EoISGhz1M+DTQbsBohAAAAIHMhttraWrW0tFhdCmLAqFGjlJOTo6SkpBN+DMIWAAAA4l4oFNKOHebKfhMmTFBSUlKfoxpwNsMw1N7ervr6eu3YsUOnnXZavycu7g9hCwAAAHGvvb1doVBIubm5GjVqlNXlwGKpqalKTExUVVWV2tvblZKSckKPc2IRDQAAAHCgEx3BgPNE47XAqwkAAAAAhgFhCwAAAACGAWELAAAAAIYBYQsAAABAVDQ2Nmr8+PHauXPngO9z/fXX68EHHxy+oixE2AIAAACiKBgMqry8XOvWrVN5efmInCD5S1/6klwul1wulxITEzVp0iTdfffdOnz4cFQef+vWrbrppps0ceJEJScnKz8/X1deeaXKysoi9rv//vu1YMECFRQUDPixV65cqfvvv19NTU397veTn/xEBQUFSklJ0axZs7Rly5ZB/QxDvf+JIGwBAAAAUeL3+zVpcqGKioq0ePFiFRUVadLkQvn9/mF/7iuuuEK1tbX66KOPtGbNGv3sZz/TfffdN+THLSsr04UXXii3263HH39cH374oZ555hnNnTtX//mf/ynDMCRJLS0t+uUvf6lbbrllUI8/ffp0FRYWau3atX3u88QTT2j58uW677779Prrr+ucc87RvHnztGfPngE9x1Dvf6IIWwAAAEAU+P1+FRcXqzEpS9lLVit32XplL1mtxqQsFRcXD3vgSk5OVnZ2tnJzc3XNNddo7ty5eu6557q2h0IhPfDAA5o0aZJSU1N1zjnnHDMydbQ33nhDN9xwgx544AH9+te/ltfrVW5urqZPn65ly5bpn//8Z9fJn//4xz8qOTlZs2fP7rr/ggULukbcjr78/ve/79rv6quv1uOPP95nHSUlJbr11lt1880368wzz9TDDz+sUaNG6dFHHx3Qv81Q73+iCFsAAADAEAWDQS1dtlyphTOV4Vup5InT5E5KVfLEacrwrVRq4UwtXX7XiEwplKS3335br7zyipKSkrpue+CBB/S///u/evjhh/XOO+9o2bJlWrJkiV544YU+H2fZsmW69NJLtXz58l63h4OWJAUCAV1wwQUR2x999FHV1tbqgw8+kGQGstraWtXW1mr+/Pld+1100UXasmWL2trajnmO9vZ2vfbaa5o7d27XbW63W3PnztWmTZuO8y8x9PsPBWELAAAAGKJAIKDqXVVKm71ILldki+1yuZU2e6Gqq3YqEAgMWw0bN27U6NGjlZKSohkzZmjPnj1asWKFJKmtrU3f//739eijj2revHmaPHmyvvSlL2nJkiX62c9+1uvjVVVV6YUXXtAdd9zRdVtra6vS09M1evRojR49WnfffXfE/hMmTIh4jHHjxik7O1v19fVyuVzyer3Kzs5Wdna2EhISuvabMGGC2tvbVVdXd0wdDQ0NCgaDysrKirg9Kyur1/2jff+hSDj+LgAAAAD6U1tbK0lKzMzvdXtiRn7EfsOhqKhIP/3pT3Xo0CGtWbNGCQkJuu666yRJH374oVpaWvTZz3424j7t7e0677zzen28rVu3SjJHncISExP12muvyTAMnX322Tr99NO7trW2tiolJaXXx3rrrbdUUFCg0aNH97o9NTVVknncl5MQtgAAAIAhysnJkSR11FcpeeK0Y7Z3NFRF7DccTjrpJE2ZMkWSOX3vnHPO6Vqw4uDBg5KkZ555RhMnToy4X3Jycq+Pd+DAAUmKGIFKSEjQlClTtGPHDh0+fFjnnHNO17aMjAzt27ev18d66623dPbZZ/dZ+969eyVJmZmZx2zLyMiQx+PR7t27I27fvXu3srOz+3zMaN1/KJhGCAAAAAyR1+tVbl6+mjc/KcMIRWwzjJCaN69Xbn6BvF7viNTjdrv1rW99SytXrlRra6vOPPNMJScna9euXZoyZUrEJTc3t9fHOOussyRJL7300jHb3n77bbndbk2fPr3rtvPOO0/btm3r9bF27typqVOn9lnv22+/rVNPPVUZGRnHbEtKStIFF1ygv/3tb123hUIh/e1vf9PFF1/c52NG6/5DQdgCAAAAhsjj8ah0TYlat1eowb9KbTWVCrW1qK2mUg3+VWrdXqHSkgfl8XhGrKaFCxfK4/HoJz/5iU4++WR985vf1LJly/TrX/9a27dv1+uvv66HHnpIv/71r3u9/9lnn62rr75aX//61/Xoo4/qvffeU2VlpdatW6f77rtP06ZN65r+J0nz5s3TO++80+voVigUUlVVlWpqarqWiu8pEAjo8ssv7/NnWb58uX7+85/r17/+tSorK3XHHXfo0KFDuvnmmwf0bzHU+58wAwPS1NRkSDKampqsLgUAAABR1traamzbts1obW0d0uNs2LDByM3LNyR1XXLzC4wNGzZEqdLeffGLXzQWLFhwzO0PPPCAkZmZaRw8eNAIhUJGaWmpMXXqVCMxMdHIzMw05s2bZ7zwwgt9Pu7hw4eN73//+8ZZZ51lpKamGmlpacbs2bON+++/32hsbDxm/4suush4+OGHj7n9j3/8o3HqqacaJ510khEMBiO2tba2Gunp6camTZv6/RkfeughIy8vz0hKSjIuuugiY/Pmzf3uP9T79/eaGGg2cBlGL9ESx2hublZ6erqampqUlpZmdTkAAACIosOHD2vHjh2aNGlSn4s8DFQwGFQgEFBtba1ycnLk9XpHdETLSs8884xWrFjRNc1wIH7605/qqaee0l/+8pdhrm5w+ntNDDQbsEAGAAAAEEUej0dz5syxugxLXHnllfrggw9UU1PT57FgR0tMTNRDDz00zJVZg7AFAAAAIGqWLl06qP2/8pWvDOn5du3apTPPPLPP7du2bVNeXt6QnuNEEbYAAAAA2NaECRP05ptv9rvdKoQtAAAAALYVPvdXLGLpdwAAAAAYBoQtAAAAABgGhC0AAAAAGAaELQAAAAAYBoQtAAAAABgGhC0AAAAAGAaELQAAAAAYBoQtAAAAABgGhC0AAAAAGAaELQAAACCKgsGgysvLtW7dOpWXlysYDFpd0ohobGzU+PHjtXPnzgHf5/rrr9eDDz44fEVZjLAFAAAARInf79eUyQUqKirS4sWLVVRUpCmTC+T3+4f1eb/0pS/pmmuuGZbH3rp1q2666SZNnDhRycnJys/P15VXXqmysrKI/e6//34tWLBABQUFA37slStX6v7771dTU1O/+/3kJz9RQUGBUlJSNGvWLG3ZsmVQP8NQ73+iCFsAAABAFPj9fhUXF2tGym5tumWUDtx7sjbdMkozUneruLh42APXcCgrK9OFF14ot9utxx9/XB9++KGeeeYZzZ07V//5n/8pwzAkSS0tLfrlL3+pW265ZVCPP336dBUWFmrt2rV97vPEE09o+fLluu+++/T666/rnHPO0bx587Rnz54BPcdQ7z8UhC0AAABgiILBoO5a9g1ddVqCnr4+RbNPTdDoJJdmn5qgp7+QoqtOT9A3ly8dkSmFc+bM0de+9jUtXbpUp5xyirKysvTzn/9chw4d0s0336yTTz5ZU6ZM0Z/+9Kd+H+eNN97QDTfcoAceeEC//vWv5fV6lZubq+nTp2vZsmX65z//KZfLJUn64x//qOTkZM2ePbvr/gsWLJDL5er18vvf/75rv6uvvlqPP/54n3WUlJTo1ltv1c0336wzzzxTDz/8sEaNGqVHH310QP8eQ73/UBC2AAAAgCEKBALauetjfcubKPeRABLmdrl076cStaOqWoFAYETq+fWvf62MjAxt2bJFX/va13THHXdo4cKFuuSSS/T666/r8ssv10033aSWlpY+H2PZsmW69NJLtXz58l63u3r8nIFAQBdccEHE9kcffVS1tbX64IMPJJmBrLa2VrW1tZo/f37XfhdddJG2bNmitra2Y56jvb1dr732mubOndt1m9vt1ty5c7Vp06bj/jsM9f5DRdgCAAAAhqi2tlaSNH28p9ft4dvD+w23c845RytXrtRpp52me++9VykpKcrIyNCtt96q0047Tf/xH/+hxsZGvfXWW73ev6qqSi+88ILuuOOOrttaW1uVnp6u0aNHa/To0br77rsj9p8wYULEY4wbN07Z2dmqr6+Xy+WS1+tVdna2srOzlZCQ0LXfhAkT1N7errq6umPqaGhoUDAYVFZWVsTtWVlZve4f7fsPFWELAAAAGKKcnBxJ0tt7ep8mGL49vN9wO/vss7uuezwejRs3TjNmzOi6LRw++jpuaevWrZLMUaewxMREvfbaa3rjjTcUDAZ1+umnd21rbW1VSkpKr4/11ltvqaCgQKNHj+51e2pqqiT1O8pmV4QtAAAAYIi8Xq8K8k7V91/qUOjIohFhIcPQAy93aFJ+rrxe74jUk5iYGPG9y+WKuC08BTAUCvV6/wMHDkhSxAhUQkKCpkyZooSEBB0+fFjnnHNO17aMjAzt27ev18d66623IsLf0fbu3StJyszMPGZbRkaGPB6Pdu/eHXH77t27lZ2d3edjRuv+Q0XYAgAAAIbI4/HowTX/Vxvf79Q1TxzWpupOHWgztKna/H7j+51aXVIqj6f3aYax5qyzzpIkvfTSS8dse/vtt+V2uzV9+vSu28477zxt27at18fauXOnpk6d2udzvf322zr11FOVkZFxzLakpCRdcMEF+tvf/tZ1WygU0t/+9jddfPHFx/05hnr/oUo4/i4AAAAAjsfn86msrEx3LfuGLnn0467bJ+XnqqysVD6fz8LqBufss8/W1Vdfra9//etqaWnRpz71KYVCIb355pv67//+b02bNq1r+p8kzZs3T/fee6/27dunU045JeKxQqGQqqqqVFNTowkTJkQsrCGZi2tcfvnlfdayfPlyffGLX9SFF16oiy66SKWlpV0rKw7EUO8/FIQtAAAAIEp8Pp8WLFigQCCg2tpa5eTkyOv12mZEq6f169erpKREJSUluvPOO5WYmKgzzzxTxcXF+upXvxqx74wZM3T++efrySef1O233x6x7etf/7puu+02TZ06Vc3NzRFh6/Dhw3r66af17LPP9lnHF77wBdXX1+s//uM/VFdXp3PPPVfPPvvsMYteDNf9h8JlGEdNKkWvmpublZ6erqamJqWlpVldDgAAAKLo8OHD2rFjhyZNmtTnQg/o3zPPPKMVK1Z0TTMciJ/+9Kd66qmn9Je//GWYqxu8/l4TA80GjGwBAAAAGLIrr7xSH3zwgWpqapSbmzug+yQmJuqhhx4a5sqsQ9gCAAAAEBVLly4d1P5f+cpXhvR8u3bt0plnntnn9m3btikvL29IzzEUhC0AAAAAtjRhwgS9+eab/W63EmELAAAAgC2Fz/0VqzjPFgAAAAAMA8IWAAAAAAwDwhYAAABwRCgUsroExIhovBY4ZgsAAABxLykpSW63W5988okyMzOVlJQUcfJdxA/DMNTe3q76+nq53W4lJSWd8GMRtgAAABD33G63Jk2apNraWn3yySdWl4MYMGrUKOXl5Q34BM29IWwBAAAAMke38vLy1NnZqWAwaHU5sJDH41FCQsKQRzcJWwAAAMARLpdLiYmJSkxMtLoUOAALZAAAAADAMGBkCwDgHIYhdXZKHR29X9rb+9420O2GIbndUlKSlJjY92Uo2z0eiQPzAcD2CFsAgIExDOnQIenAAam52bwcOCC1tEQvyPS3faD7OMVwhrnBPsZJJ0lpaebl5JPNrykpBEIAOA7CFgA4mWFIbW2RASkckgZ7/cAByY7nn3G7oxtQPB4pGIxuuDSMY+tubzcvsSohoTt49QxhR1/vb1v4OsfGAHAowhYA2MHhw9Lu3VJdXeTX/fuPH5aiPdrjdkc2yqNGRXfEZSjbe9s2hCV7R0wwGP3pjtHa3t4eOaJ54IBZc2entG+feRmqlJTjB7JTTpGys6WsLPNrdraUmUlQAxDTCFsAYJXOTmnPnu7wFL709v3+/UN/vtGjozMSMWoU08eizeMxLykpVldyfKGQGb6GOlLa3Cy1tpqPefiweamvH1wtLpc0blx3+Do6jPX8ftw4ewRvAI5C2AKAaAqFpL17jx+e6uqkhobep4/1JSkpsoHMyjI/7R9IQBo92mzmgaFyu83X1MknSxMnDu2xOjsHHs4aGyP/L+3ZY44INjSYl7ff7v+5PJ7u/zfHC2fp6XygACAqCFsAcDyGYTZ8xwtP4Qaws3Pgj+12D7wBHDOGBhDOkpBgfmBwyimDv28oZAawgX6wEQxKn3xiXo4nOfn4I2Xhy6hRg68dQNwgbAGIXy0tA5vCV1dnTnEajMFMbWLECRg8t9s8ZiszU5oxo/99OzoGPmW3qclcVKaqyrwcz+jR/f9f7zkSnZQUnZ8dgG0QtgA4V3u7tH279O675uW996SPPupurMIH+g9UWlrfTVXP6+PHc9A+EEsSE80pjwOZ9tjaeuxiNL0Fs7o6c9+DB6UPPzQvxzN2rPm3IidHmjJFmjat+5KXxwcvgAO5DGMwBwzEr+bmZqWnp6upqUlpaWlWlwOgp717u8NUOFi9+64ZtILB/u+bmjqw6UJZWea+ACCZ04sPHhzY9OLdu4+/KmhKinT66Wbwmjq1O4Sdfro5egYgpgw0GzCyBcAegkFp585jA9W77/a/gtnJJ0c2LlOmSBMmdAeok0/mOCgAg+dydS8Uctpp/e9rGOYS+eHwVVMjvf9+99+wDz4wpyq/9ZZ5OVpubuQoWDiQTZjA3y8gxjGyNUCMbAEj5ODB3gPVBx+Yx1H0pbdmZNo0c7oOzQiAWBYMmseHHf1373gfJo0e3fvfvSlTzEU+AAybgWYDwtYAEbaAKDIM85Pdo5uK996TPv647/slJ3ePUjHNBkA8aGw0/zYOZpq02y1NmtR7EMvIGNn6AYcibEUZYQs4AYcPmyNSPcNU+PqhQ33fLysrMkxxADkARDp6AaDw39jKSvNUFX0ZN+7YD6ymTTPDWQJHlwADRdiKMsIW0I/GRmnbtmNHqnbs6PukvR7PsatxhRuAEznnDgDA/Ju7e3fvUxL7W8o+MdE89uzoIHbmmcwcAHpB2IoywhZwhGGYy6e/9FL35d13+94/PV0644xjA9XkyZxzBgBGUkuLuTDH0VMS33vPXMa+Nx6PdN550qWXmpdPfcpcYAiIc4StKCNsIW51dkr//GdkuKqrO3a/goLejw8YP54FKgAgloVCUnX1sVO+Kyt7/3s/ZUp3+Lr0UvO4Wf7OI84QtqKMsIW4cfCg9Oqr3cFq06Zjj69KTJRmzux+o73kEvM4AACAs+zaJb38cvd7wtatx04Pz8iIDF/nncfMBTgeYSvKCFtwrN27I0et3njj2BWu0tPNqSPhN9ILL+QEvwAQj/bvNz+EC79nbNliLobUU2qqNGtW93vGxRdL9E5wGMJWlBG24AiGYa4O+NJLUiBgfv3ww2P3y8uL/JTyrLPMpYQBAOiprU16/fXID+327o3cx+2Wzj478n1l4kRr6gWihLAVZYQt2FJHhzlS1fNN8OgTZLpc0owZkQc/5+VZUy8AwN5CIfOYr57vOx99dOx+BQWS19v93jNtGh/qwVYIW1FG2IItHDwovfJK9xvc5s3HrjCVnHzs9I4xYywpFwAQBz75JPK4rzffNENZT2PHRk5XnznTPD4YiFGErSgjbCFm7dsn/eEP0oYN0p//bE7p6Gns2MipG+efbwYuAACscOCA+WFgzw8GW1oi9xkzRlqwQLruOumzn5VSUiwpFegLYSvKCFuIKfX10u9+Zwasv/7VXJ49rKBA+pd/6Q5XU6cyNQOIgmAwqPLycpWXl0uS5syZozlz5sjj8VhbGGB3HR3maFc4fL34otTQ0L199Gjpqquk4mLpiiukk06yrFQgjLAVZYQtWK62VnrqKamsTHrhhcgpGNOnm5/+XXedeZ3znQBR5ff7ddvtX1VjY6NkdP/fG5c5Xo88/FP5fD4LqwMcJhg0px1u2CD5/dLHH3dvS02VPvc58/3uqqtY5RCWIWxFGWELlti1y3yz2bDBPBar53/X88/vDlhTp1pXI+JWMBhUIBBQbW2tcnJy5PV6HTnK4/f7dd1110mSUgsvUvrFi5SYma+O+io1bXpCrR/9QxvKyhwZuOLld4wYFgpJFRXd74U9F9tISpIuv9x8H/z8581p88AIIWxFGWELI+bDD7vfVCoqIrfNnt0dsCZNsqY+QGYAWbpsuap3VXXdlpuXr9I1JY4KHcFgUAWTJqumbo9S8s5W5nUr5XJ1T8s1jJDqN3xPGR312vHRh44KIvHyO4aNGIY53TD8Hvnuu93bEhKkoiLz/fGaa6SsLKuqRJwgbEUZYQvDats2842jrEx6663u210u8/ir666Trr1WOvVU62pETLFyxMHv96u4uFiphTOVNrt7lKd585Nq3V6hMgeN8pSXl6uoqEiSlL1ktZInTjtmn7aaStWtXaG///3vmjNnzghXODxi6XfM6Br6tG2b+b65YUPke6fbbS4rf911ks/HOb0wLAhbUUbYQlT19+mcxyN95jN8Ooc+WTniEAwGNWlyoRqTspThO3aUp8G/SuM69mjHdmeM8qxbt06LFy+WJOUuWy93Uuox+4TaWlRduki//e1vdcMNN4x0iVEXS79jRtcwYOFZIWVl0j/+Ebnt4ou7Z4UUFFhSHpxnoNmAJcqAkXTokPSzn5mLWJx/vnT//WbQSkqSrrxSeuwxac8e6S9/kW6/naCFY4RHHBqTspS9ZLVyl61X9pLVakzKUnFxsfx+/7A+fyAQUPWuKqXNXhTRhEuSy+VW2uyFqq7aqUAgMKx1jJScnJyu6x31Vb3u09FQdcy+dhYrv2OrX+uwmSlTpH//d3P6/c6dUkmJed4ul0vatEn65jfN6fdz5piLbvRcxRcYRoQtYCTs3CmtWGFOA/zqV82pD6mp5tTA3/zGDFgbN0pf+hIH+KJPwWBQS5ctV2rhTGX4Vip54jS5k1KVPHGaMnwrlVo4U0uX36VgMDhsNdTW1kqSEjPze92emJEfsZ/deb1enZqbJ1diipo2PSnDiDwRq2GE1LTpSeXmFcjr9VpUZXTFwu84Fl7rsLH8fGnZMnMZ+Y8/ln78Y/N4LrfbXM33uuvMcPbf/y3t3Wt1tXA4whYwXAxDKi8354sXFkqrV0v795vXS0vNpdz9fmnxYik93eJiYQexMOIQHr2Jl1Eej8ej/1u6RkbHYbVu36L6DavUVlOpUFuL2moqVb/he2r96B8qXfOgI6ZNSrHxO46F1zocYsIE6d/+TXr+eXOF329/W8rIkKqqpLvv7v4Q9J13rK4UDkXYAqKttVX6xS+kc84xP0l76ilz6drLLzdHr95/X/rGNwhYGLRYGHHwer3KzctX8+beR3maN69Xbr5zRnkkyefzacOGDRqXkanWj/6hurUrVF26SHVrV+ik5irHLfseC7/jWHitw4EmTpRWrZKqq6VHHzXfp1tbu6f3z50r/f735nm+gCghbAHRUl0t3Xuv+SnZrbdKW7dKo0ZJd9xhfmL25z+bx2W5+W+HExMLIw4ej0ela0rUur1CDf7IUZ4G/yq1bq9QaYlzRnnCfD6fdtfV6q/P/UUrV67UypUr9de//lV1tZ84KmhJsfE7joXXOhwsJUW6+WbpjTekF180pxW63dLf/iYtWCCdfrq0Zo05GwUYIlYjHCBWI0SvDMOcE/6jH5kjWOFPwwoKpK99zfxjfsoplpYIkxOWj475VeLyC1Ra8qDjwke8svJ3HEuv9Whzwt8iR9q1S/qf/5F+/vPu47hOOkn64hfN9/Npx572AfGNpd+jjLCFCIcPS48/boasN97ovv0zn5G+/nXpqqvMJdwRE5y0fHTk+Y8WKjEjXx0NVWrevJ7zHyHqYud8bta+1qPFSX+LHKulxVy46kc/kt5+u/v2efPM9/crrmCGCiQRtqKOsAVJ5tzukhLp//5fqb7evC01VVqyxPzka8YMa+vDMWLp5KzRwqgS4oWTXutO/FvkaOFFrn70I+l3vzO/l8xVDL/9ben/+/8IXXGOsBVlhK04ZxjmiRK/+U1zqoEk5eZKd94p3XKLNG6ctfWhV0xFAuzPCa91J/8tigs7dkg/+Ym5+FVTk3nbhReaQezii62tDZYhbEUZYSuOvfmmuXrgiy+a3+fmSj/4gbRokZSQYGlp6F95ebmKioqUvWS1kiceO9++raZSdWtX6O9//7vmzJkz8gUCiAv8LXKIgwelhx+Wvvc9qbnZvG3JErMnmDjR2tow4gaaDRj/BPpSXy/dfrt0/vlm0EpNlb77Xendd81zYxG0Yh7LRwOIBfwtcojRo80ZLu+/L33lK5LLJa1da65eeP/95qEGwFEIW8DROjrMkw6fdpr0yCPmFMLrrzdD1n/8h7mcO2yB5aMBxAL+FjlMVpa5amFFhfSpT5mLaqxcKZ15prRhQ/fxXYAIW0CkZ5+Vzj5bWrbMnJd93nnmqNa6dVJentXVYZBi4eSsAMDfIoe64AIpEDB7hFNPlXbulIqLpcsuk956y+rqECMIW4BkTgm46irpc58zR7AyM7s/teLNz7Zi4eSsAMDfIgdzuSJnv6SkSH//u/lh7b/+q9TQYHWFsBgLZAwQC2Q4VFOTtGqVuZR7R4d5HNY3viH9n/8jpadbXZ0t2GGlMCctHw3Avuz0t8gOf9tjUlWVdPfd0pNPmt+PGWMe733HHVJioqWlIbpYjTDKCFsOEwxKv/qV9K1vSXv2mLfNn2+eQ2vqVEtLsxM7naCTxgFALLDD3yI7/W2PWS+8YH54+89/mt+fcYZ5PPjll1taFqKHsBVlhC0Heekl8w/g66+b359+urRmjRm2MGCcoBMAnIe/7VEUDEq//KV5EuTwdMLPf1568EHz5MiwNcJWlBG2HODjj82h/XXrzO/T0qT77jNPTJyUZG1tNsMJOgHAefjbPkz27zenEv74x1JnpzmdcNkycwXDk0+2ujqcIM6zBfT0l79I55xjBi2XS7r1VumDD6TlywlaJyAQCKh6V5XSZi+KeDOWJJfLrbTZC1VdtVOBQMCiCgEAg8Xf9mEyZow5g+att6R588xjxH/4Q2nmTKmy0urqMMwIW3A2w5AeeEC64gpp715zmdbXXjPPnzV+vNXV2RYn6AQA5+Fv+zA74wzpT3+SNm6UJk6U3ntPuugiye+3ujIMI8IWnKu5WbruOnMRDMOQbrnFPF7rvPOsrsz2OEEnADgPf9tHgMslXXmledz4pz8tHTxo9ir33mse4wXHIWzBmSorzU+LnnrKnCb4yCPSL35hnv8CQ8YJOgHAefjbPoLGj5f++lfzcAZJ+sEPzHN9cl4uxyFswXn8fjNovfeeOUz/4ovmMVqIGk7QCQDOw9/2EZaQYK5MuG6dNGqU9Nxz0oUXdq+WDEdgNcIBYjVCGwgGzZV9fvAD8/tPf1p64gkpK8vauhzMTifoBAAMDH/bLbB1q3TttdL27eYsnIcflr74RaurQj9Y+j3KCFsxrqFBWrzY/FRIMoflf/CDuDpbu1UnyrTDCToBAIPDe4oF9u+XliyRnnnG/P5f/9VcxZBVk2MSYSvKCFsx7PXXJZ9Pqqoyh+F/+Uvp+uutrmpE9fopZF6+SteU8CkkAMAWeC+TFApJ3/ue9J3vmN9ffLFUViZNmGBpWTgWYSvKCFsx6te/lr76VenwYamw0FwQY8YMq6saUX6/X8XFxUotnKm02YuUmJmvjvoqNW9+Uq3bK1RWVhY/b1IAAFvivewoGzeao1xNTVJ2trR+vXTppVZXhR4IW1FG2Iox7e3m2df/53/M76+8Ulq71jxxYBwJBoOaNLlQjUlZyvCtjDgJpWGE1OBfpXEde7Rj+4fxMw0DAGArvJf14cMPzeO43n7bXEyjpES6805z+XhYbqDZgNUIYT/790tFRd1B6777pN//Pu6CliQFAgFV76pS2uxFEW9OkuRyuZU2e6Gqq3YqEAhYVCEAAP3jvawPU6ZImzebh0Z0dkpf/7r05S9zPi6bIWzBXjo6pOJi6ZVXpPR06Q9/MOc1u+PzpVxbWytJSszM73V7YkZ+xH4AAMQa3sv6cdJJ0m9/a45qeTzSr34l3X231VVhEOKzQ4U9GYa5Ms/f/mb+8fn736WrrrK6Kkvl5ORIkjrqq3rd3tFQFbEfAACxhvey43C5zEMn1q41vy8pMZeGhy0QtmAfDz4o/eIX5ijW449L551ndUWW83q9ys3LV/PmJ2UYoYhthhFS8+b1ys0vkNfrtahCAAD6x3vZAF1/vblSoWQeu/WXv1hbDwaEsAV7eOqp7mHzkpK4H9EK83g8Kl1TotbtFWrwr1JbTaVCbS1qq6lUg3+VWrdXqLTkwfg6oBgAYCu8lw3Ct78t3XSTedzWwoXSO+9YXRGOg9UIB4jVCC30j39I//IvUmurOY3wxz9mJZ6j9HpukvwClZY8GF9L5QIAbIv3sgFqa5Muv1x68UUpP1969VUpK8vqquIOS79HGWHLItXV0kUXSXV10hVXmAtiJCRYXdWQBINBBQIB1dbWKicnR16vNyqf1g3X4wIAMFJ4jxygxkZp9mxzefhZs8zj2FNTra4qrhC2ooywZYEDB8wT+L31ljR9uvTyy5LN/+17/dQuL1+la0r41A4AgGHg2Pfe9983A9e+feaUwscfj9vVma3AebZgb52d5oGgb71lDo1v3OiIoFVcXKzGpCxlL1mt3GXrlb1ktRqTslRcXCy/3291iQAAOIqj33tPP908pj0xUVq/XvqP/7C6IvSCka0BYmRrhH3969JDD5lD4uXl5lRCGwsGg5o0uVCNSVnK8K2MOGmjYYTU4F+lcR17tGP7h/ae1gAAQIyIm/feX/9a+tKXzOuPPdZ9HcOKkS3Y10MPmRdJ+n//z/ZBS5ICgYCqd1UpbfaiiD/2kuRyuZU2e6Gqq3YqEAhYVCEAAM4SN++9X/yiuUqhJN12m/khNWIGYQux5Y9/lJYuNa//4AfSdddZWk60hM96n5iZ3+v2xIz8iP0AAMDQxNV773/+p7RokdTRIfl85vFciAmELcSOt96SvvAFKRSSvvzl7vNqOUD4rPcd9VW9bu9oqIrYDwAADE1cvfe63dKvfmWuTLhvn3TlleaKhbAcYQuxobbWPFHxwYNSUZH005866lxaXq9XuXn5at78pAwjFLHNMEJq3rxeufkF8nq9FlUIAICzxN17b2qq9LvfSQUF5pLw115rnpMLliJswXqHDkmf/7x5Tq2pU6UNG6SkJKuriiqPx6PSNSVq3V6hBv8qtdVUKtTWoraaSjX4V6l1e4VKSx609wG6AADEkLh87+25gnMgIN16q8RaeJZiNcIBYjXCYRIKScXF5tKl48aZZ0EvLLS6qmHT67k+8gtUWvKgvc/1AQBAjIrL996//EWaP18KBqXvfU9audLqihyHkxpHGWFrmPz7v0s//KE5kvW3v5knMY5h0TgDvePOYg8AQIyLy/fvn/1M+upXzevr1pnnL0XUELaijLA1DH7xC3N4W5LWrpVuvNHaeo7DsWegBwAA/bJtD3DXXVJJiZScLP3979LFF1tdkWMQtqKMsBVlf/ubdMUVUmen9J3vSPfdZ3VF/QqfgT61cKbSZi9SYma+Ouqr1Lz5SbVur1BZWVls/7EFAAAnxNY9QDBonkbnd7+TMjOlzZulyZOtrsoRCFtRRtiKospK85OVpiZp8WJzVCuGVx6MmzPQAwCACI7oAQ4dkrxe6Y03pDPOkF55RRozxuqqbG+g2YDVCDGy6uvNcz80NUmf+pT0y1/GdNCS4ugM9AAAIIIjeoCTTpL+8Adp4kTzA++FC82TH2NEELYwcg4flq65RtqxwxzCfuopKSXF6qqOK67OQA8AALo4pgeYONFcEv6kk6S//lX6t39jSfgRQtjCyPn+97uHrp95xpw7bANxdQZ6AADQxVE9wLnnSo8/Lrnd0s9/Lj39tNUVxQXCFkbGRx+ZS7xL5n/wadOsrWcQ4u4M9AAAQJIDe4CrrjJPuyNJy5dLra3W1hMHCFsYGcuWSW1t0ty55qo4NhKXZ6AHAADO7AG+/W3p1FOlnTu7PwjHsGE1wgFiNcIh+NOfzLOYJyRIb71lroRjQ3F5BnoAAOC8HuDJJ6UvfME8dr6yUioosLoi22Hp9ygjbJ2gtjZpxgzpgw/ME+utXm11RUNiu7PHAwCAqHBUD2AY0mWXmSc6vvZaye+3uiLbIWxFGWHrBP3Xf0n33CNlZ0vvvSfxbwcAAGC9t982F80IBqU//1m6/HKrK7IVzrMF69XUSN/7nnn9hz8kaAEAAMSK6dOlO+80r3/961J7u7X1OBRhC8NnxQrzrOWXXCItWWJ1NQAAAOjpO9+Rxo83Zx/96EdWV+NItgtbe/fu1Y033qi0tDSNGTNGt9xyiw4ePNjvfR555BHNmTNHaWlpcrlc2r9//8gUG89eeEFat05yuaSHHjK/WigYDKq8vFzr1q1TeXm5gsGgpfUAAID4FFM9yZgx0g9+YF7/7nelTz6xrhaHsl3YuvHGG/XOO+/oueee08aNG/Xiiy/qtttu6/c+LS0tuuKKK/Stb31rhKqMc52d0te+Zl6//Xbp/PMtLcfv92vS5EIVFRVp8eLFKioq0qTJhfJzMCgAABhBMdmTfPGL0qxZ0sGD3efgQtTYaoGMyspKnXnmmaqoqNCFF14oSXr22Wc1f/58ffzxx5owYUK/9y8vL1dRUZH27dunMWPGDOq5WSBjEH78YzNsjR0rvf++NG6cZaX4/X4VFxcrtXCm0mYvUmJmvjrqq9S8+Um1bq9QWVmZPZdsBQAAthLTPck//iFddJG5SuFLL0mf+pQ1ddiII1cjfPTRR3XXXXdp3759Xbd1dnYqJSVF69ev17XXXtvv/QcTttra2tTW1tb1fXNzs3Jzcwlbx3P4sHmuht27pf/5H+mOOywrJRgMatLkQjUmZSnDt1IuV/dArmGE1OBfpXEde7Rj+4f2XboVAADEPFv0JLfeKv3iF+aS8H/9qzU12IgjVyOsq6vT+PHjI25LSEjQ2LFjVVdXF9XneuCBB5Sent51yc3NjerjO9b//q8ZtHJzpa98xdJSAoGAqndVKW32oog/apLkcrmVNnuhqqt2KhAIWFQhAACIB7boSf7P/5ESEqS//U167TXr6nCYmAhb99xzj1wuV7+Xd999d0Rruvfee9XU1NR1qa6uHtHnt6VgUPrv/zavL18uJSZaWk5tba0kKTEzv9ftiRn5EfsBAAAMB1v0JHl50g03mNf/67+sq8NhEqwuQJLuuusufelLX+p3n8mTJys7O1t79uyJuL2zs1N79+5VdnZ2VGtKTk5WcnJyVB/T8Z5+WvrwQ+mUUywf1ZKknJwcSVJHfZWSJ047ZntHQ1XEfgAAAMPBNj3JihXS//t/0oYNZk83ZYq19ThATIxsZWZmatq0af1ekpKSdPHFF2v//v16rcfQ5vPPP69QKKRZs2ZZ+BNAhtH9Kci//Zs0erS19Ujyer3KzctX8+YnZRihiG2GEVLz5vXKzS+Q1+u1qEIAABAPbNOTzJghzZ8vhULSgw9aW4tDxETYGqgzzjhDV1xxhW699VZt2bJFL7/8su68805df/31XSsR1tTUaNq0adqyZUvX/erq6vTmm2/qww8/lCRt3bpVb775pvbu3WvJz+FI5eVSRYWUktK97LvFPB6PSteUqHV7hRr8q9RWU6lQW4vaairV4F+l1u0VKi15kMUxAADAsLJVT3L33ebXxx4zj8PH0Bg209jYaNxwww3G6NGjjbS0NOPmm282Dhw40LV9x44dhiTj73//e9dt9913nyHpmMtjjz024OdtamoyJBlNTU1R/Gkc5IorDEMyjDvusLqSY2zYsMHIzcuP+N3n5hcYGzZssLo0AAAQR2zRk4RChjFrltnXffvbVlcTswaaDWy19LuVOM9WP/75T+nccyW3W/rgA2nyZKsrOkYwGFQgEFBtba1ycnLk9Xpj49MjAAAQV2zRkzz1lOTzSWPGSLt2SSefbHVFMWeg2SAmFsiAzf3wh+bXhQtjMmhJ5vD9nDlzrC4DAADEOVv0JJ//vHT66dL770s//7m5yjROiK2O2UIM2rlTeuIJ83p4ji8AAADsy+MxVyaUpDVrpPZ2a+uxMcIWhqakxDy/1ty50vnnW10NAAAAouGmm6TsbOnjj6V166yuxrYIWzhxDQ3SL35hXv/3f7e2FgAAAERPcrK0dKl5/Yc/NJeDx6ARtnDifvITqbXVHNG67LIRe9pgMKjy8nKtW7dO5eXlCgaDI/bcAAAAI82y3uerXzUXx9i2TfrjH0fmOR2GsIUT09IiPfSQef3uuyWXa0Se1u/3a9LkQhUVFWnx4sUqKirSpMmF8vv9I/L8AAAAI8nS3ic93QxckvRf/zX8z+dALP0+QCz9fpSyMnP1wfx86cMPpYThX9jS7/eruLhYqYUzlTZ7kRIz89VRX6XmzU+qdXuFysrK5PP5hr0OAACAkRATvc8nn0h5eeYx+tu3x+zK0yNtoNmAsDVAhK2j3HCD9Pjj5ko14aXfh1EwGNSkyYVqTMpShm+lXK7uQVnDCKnBv0rjOvZox/YPY+9cFQAAAIMUU73PZZdJzz9v9nzhVQrj3ECzAdMIMXiHD0sbN5rXr7tuRJ4yEAioeleV0mYvivhjI0kul1tpsxequmqnAoHAiNQDAAAwnGKq9wn3exs2DP9zOQxhC4P33HPSwYPSqadKM2eOyFPW1tZKkhIz83vdnpiRH7EfAACAncVU73Pttebx+a++ai4FjwEjbGHwwgdk+nySe2ReQjk5OZKkjvqqXrd3NFRF7AcAAGBnMdX75ORIl1xiXn/qqeF/PgchbGFwOjqk3/3OvD6Ci1F4vV7l5uWrefOTMozI8zwYRkjNm9crN79AXq93xGoCAAAYLjHX+4T7PqYSDgphC4NTXi7t2yeNHy9deumIPa3H41HpmhK1bq9Qg3+V2moqFWprUVtNpRr8q9S6vUKlJQ+yOAYAAHCEmOt9wmErEJD27BmZ53QAwhYGJ/xpxjXXSCMcbHw+n8rKyjSufbfq1q5Qdeki1a1doXEde1j2HQAAOE5M9T4FBdIFF0ihkPT00yP3vDbH0u8DxNLvMs+vMGGC+WnGn/8sXX65RWUEFQgEVFtbq5ycHHm9Xka0AACAY8VM7/PAA9K3viXNmyc9++zIP38M4TxbUUbYkvTii9KnPy2NGWMGrsREqysCAADASHn/fWnqVCkhwewFTznF6oosw3m2EH3hVQg//3mCFgAAQLw5/XTprLOkzk7pD3+wuhpbIGxhYAyjO2yN0ImMAQAAEGM4wfGgELYwMBUVUnW1NHq0ZcdqAQAAwGLhsPXnP0sHDlhbiw0QtjAw4U8vrrxSSkmxthYAAABYY8YMacoUqa1N+tOfrK4m5hG2cHyG0R22mEIIAAAQv1wuphIOAmELx/fWW9L27eaI1uc+Z3U1AAAAsFI4bD3zjNTaam0tMY6wheMLL4wxb555zBYAAADi14UXSrm50qFD0l/+YnU1MY2wheNjCiEAAADCXC7J5zOvM5WwX4Qt9O+996R33jHPq3X11VZXAwAAgFgQ/hD+D3+Q2tutrSWGEbbQv/CnFZddJo0ZY2kpAAAAiBGXXCJlZUn790t//7vV1cQswhb6xxRCAAAAHM3jka691rzOVMI+EbbQtx07pNdfl9xuacECq6sBAABALAkft/X001IwaGkpsYqwhb499ZT59V/+RcrMtLYWAAAAxJY5c6RTTpHq66VAwOpqYhJhC31jCiEAAAD6kpjYPfspfKogRCBsoXeffCK98op5PTwfFwAAAOgp/KG83y+FQtbWEoMIW+hdeArhxRdLEydaWwsAAABi02c/K518slRTI23ZYnU1MYewhd4NwxTCYDCo8vJyrVu3TuXl5QpyICUAAMCIGZZeLDlZuuoq8zqrEh6DsIVjNTdLL7xgXo/SFEK/369JkwtVVFSkxYsXq6ioSJMmF8rP/F4AAIBhN6y9WHhVwj/8YeiP5TCELRzr1VfNObeTJ5uXIfL7/SouLlZjUpayl6xW7rL1yl6yWo1JWSouLiZwAQAADKNh78U+8xnz63vvSQ0NQy/YQVyGYRhWF2EHzc3NSk9PV1NTk9LS0qwuZ3h997vSd74j3XijtHbtkB4qGAxq0uRCNSZlKcO3Ui5Xd743jJAa/Ks0rmOPdmz/UB6PZ4iFAwAAoKcR68XOOEN6911zdCs8rdDBBpoNGNnCscKrEF5yyZAfKhAIqHpXldJmL4r4zy1JLpdbabMXqrpqpwKcmwEAACDqRqwXC/eN4T4SkghbOFowKG3ebF6PQtiqra2VJCVm5ve6PTEjP2I/AAAARM+I9WKErV4RthBp2zZzgYzRo6Xp04f8cDk5OZKkjvqqXrd3NFRF7AcAAIDoGbFeLBy2tmyROjqG9lgOQthCpE2bzK+zZkkJCUN+OK/Xq9y8fDVvflKGEXmiO8MIqXnzeuXmF8jr9Q75uQAAABBpxHqxqVOlU06RWlult94a2mM5CGELkaJ4vJYkeTwela4pUev2CjX4V6mtplKhtha11VSqwb9KrdsrVFryIItjAAAADIMR68Xcbunii83rTCXsQthCpCiHLUny+XwqKyvTuPbdqlu7QtWli1S3doXGdexRWVmZfOFzMwAAACDqRqwX47itY7D0+wDFxdLv9fXS+PHm9X37pDFjovrwwWBQgUBAtbW1ysnJkdfrZUQLAABghAx7L/b3v5vn3MrLk6p6P0bMKQaaDYZ+UA6cI3y81plnRj1oSeYw9pw5c6L+uAAAADi+Ye/FZs40pxPu2iV9/LF06qnD91w2wTRCdBuGKYQAAACIE6NHS+ecY14Pf4gf5whb6EbYAgAAwFBw3FYEwhZM7e1SRYV5nbAFAACAE0HYisAxWzC9+aZ0+LA0dqx0+ukn/DAsggEAAGA/UevhwmHr9dfNc26lpka3UJthZAumnlMIXa4Tegi/369JkwtVVFSkxYsXq6ioSJMmF8rv90exUAAAAERTVHu4/HwpJ0fq7JT+8Y/oF2szhC2Yhni8lt/vV3FxsRqTspS9ZLVyl61X9pLVakzKUnFxMYELAAAgBkW9h3O5mErYA+fZGiDHn2crL0+qrjbPjzDIJUGDwaAmTS5UY1KWMnwr5XJ1Z3jDCKnBv0rjOvZox/YPmVIIAAAQI4ath3vwQemb35SuuUZ66qnoFx4DBpoNGNmCtH+/GbQk6dxzB333QCCg6l1VSpu9KOI/qSS5XG6lzV6o6qqdCgQCQ68VAAAAUTFsPdx555lft26NUqX2RdiC9Pbb5tfc3BM6mXFtba0kKTEzv9ftiRn5EfsBAADAesPWw82YYX796CPp0KETrs8JCFvoDlvTp5/Q3XNyciRJHfVVvW7vaKiK2A8AAADWG7YeLjNTGj9eMgxp27Yh1Wh3hC10D/GGP4UYJK/Xq9y8fDVvflKGEYrYZhghNW9er9z8Anm93qFWCgAAgCgZ1h4u3FfG+VRCwhaGPLLl8XhUuqZErdsr1OBfpbaaSoXaWtRWU6kG/yq1bq9QacmDLI4BAAAQQ4a1hwuHrXCfGac4qXG8M4whj2xJks/nU1lZmZYuW67qtSu6bs/NL1BpWZl8Pt9QKwUAAECUDVsPF/4QP85Htlj6fYAcu/T7J59IEydKHo908KCUkjKkh4va2ccBAAAwYqLew23ZIs2aJWVnSw5cJG2g2YCRrXgX/rThtNOGHLQkczh6ziDP0wUAAABrRb2HO/NM82tdndTQIGVkRO+xbYRjtuLdEI/XAgAAAI4xerQ0ebJ5PY6P2yJsxbsoHK8FAAAAHIPjtghbcY+RLQAAAAwHViQkbMW1YFB65x3zOiNbAAAAiCbOtUXYimsffSQdPiylpnbPqQUAAACiITxz6u23zdMNxSHCVjwLf8pw5pnm0u8AAABAtJx+upSYKB04IO3aZXU1lmDp93g2hMUxOJ8WAACA8w2p50tMlKZNM3vOrVul/PzhLTYGMbIVz05wcQy/369JkwtVVFSkxYsXq6ioSJMmF8rv9w9DkQAAALBCVHq+OF8kg7AVz05gZMvv96u4uFiNSVnKXrJaucvWK3vJajUmZam4uJjABQAA4ABR6/nifPl3l2HE6dFqg9Tc3Kz09HQ1NTUpLS3N6nKG7vBh6aSTpFBIqqmRJkw47l2CwaAmTS5UY1KWMnwr5XJ1Z3XDCKnBv0rjOvZox/YPmVIIAABgU1Ht+TZulK6+Wjr7bOmf/xzmykfOQLMBI1vxqrLSDFpjx0o5OQO6SyAQUPWuKqXNXhTxn06SXC630mYvVHXVTgUCgeGoGAAAACMgqj1feAZVZaXU0TEM1cY2wla8qqw0v551luRyDegutbW1kqTEzN4PbkzMyI/YDwAAAPYT1Z4vL08aPdoMWtu3R61GuyBsxaudO82vgzi/Vs6REbCO+qpet3c0VEXsBwAAAPuJas/nckmTJpnXq3p/PCcjbMWr8It9EEtwer1e5eblq3nzkzKMUMQ2wwipefN65eYXyOv1RrNSAAAAjKCo93zhfpOwhbhxAmHL4/GodE2JWrdXqMG/Sm01lQq1taitplIN/lVq3V6h0pIHWRwDAADAxqLe88Vx2OKkxvHqBMKWJPl8PpWVlWnpsuWqXrui6/bc/AKVlpXJ5/NFs0oAAABYIKo9XxyHLZZ+HyBHLf1uGOay762t0gcfSFOmDPohhnQ2cQAAANhCVHq+J5+UvvAF6VOfkl56aXgKHWEDzQaMbMWj+nozaElSbu4JPYTH49GcOXOiVxMAAABiTlR6vjge2eKYrXgUfqHn5EjJydbWAgAAAGcLh61PPom7c20RtuLRCR6vBQAAAAza+PHmB/yhkPTxx1ZXM6IIW/GIsAUAAICR4nabJzeW4m4qIWErHhG2AAAAMJLi9LgtwlY8ImwBAABgJBG2EDcIWwAAABhJhC3EDcIWAAAARhJhC3GhuVnav9+8TtgCAADASCBsIS6EX+CnnCKdfLK1tQAAACA+hMPWrl3mEvBxgrAVb5hCCAAAgJE2caK5BHx7u7R7t9XVjBjCVrwhbAEAAGCkJSaagUuKq6mEhK14Q9gCAACAFeLwuC3CVrwhbAEAAMAKhC04HmELAAAAViBswfEIWwAAALACYQuOdviwVFdnXidsAQAAYCQRtuBo1dXm19RUKSPD2loAAAAQX3qGLcOwtpYRQtiKJz2nELpc1tYCAACA+JKXZ349cEDav9/SUkYKYSuecLwWAAAArDJqlJSZaV6Pk6mEhK14QtgCAACAleLsuC3CVjwhbAEAAMBKhC04FmELAAAAViJswbEIWwAAALBSnIWtBKsLwAgJBqWPPzavHydsBYNBBQIB1dbWKicnR16vVx6PZwSKBAAAgN0MqnckbMGRPvlE6uyUEhKkCRP63M3v92vpsuWq3tX9HyA3L1+la0rk8/lGolIAAADYxKB7xzgLW0wjjBfhF/Spp0p9fNLg9/tVXFysxqQsZS9Zrdxl65W9ZLUak7JUXFwsv98/ggUDAAAglp1Q7xgOW/X1UkvLyBZsAZdhxMnpm4eoublZ6enpampqUlpamtXlDN5vfiMtWSJ9+tNSefkxm4PBoCZNLlRjUpYyfCvlcnXncMMIqcG/SuM69mjH9g+ZUggAABDnTrh3NAwpPd08sXFlpTRtmgXVD91AswEjW/HiOItjBAIBVe+qUtrsRRH/WSTJ5XIrbfZCVVftVCAQGO5KAQAAEONOuHd0ueJqKiFhK14cJ2zV1tZKkhIze9+emJEfsR8AAADi15B6R8IWHOc4YSsnJ0eS1FHf+4u+o6EqYj8AAADEryH1joQtOM5xwpbX61VuXr6aNz8pwwhFbDOMkJo3r1dufoG8Xu9wVwoAAIAYN6TekbAFx6muNr/2EbY8Ho9K15SodXuFGvyr1FZTqVBbi9pqKtXgX6XW7RUqLXmQxTEAAAAwtN4x3I/u2jWyRVuA82zFg0OHzIskZWf3uZvP51NZWZl5roS1K7puz80vUGlZGefZAgAAQJcT7h3D/eiePSNQpbVY+n2AbL30+44d0uTJUkqKeT4Dl6vf3Qd1FnAAAADEtUH3jpWV0plnSqecIu3dO3KFRtFAswEjW/Ggvt78mpl53KAlmcPCc+bMGd6aAAAA4AiD7h0zM82v+/ZJHR1SYuKw1BULOGYrHoSHaMePt7YOAAAAYOxYyX0khjQ0WFvLMCNsxYOeI1sAAACAldxuKSPDvB7uUx2KsBUPGNkCAABALAn3pQ5fJIOwFQ8IWwAAAIgl4RlXhC3YHtMIAQAAEEvCgwBMI4TtMbIFAACAWMLIFhyDkS0AAADEEka24BiMbAEAACCWMLIFRzAMRrYAAAAQWxjZgiMcOCC1tZnXCVsAAACIBXEyspVgdQEYZuFPC0aNkk46qdddgsGgAoGAamtrlZOTI6/XK4/HM4JFAgAAwCkG1FsysgVHOM7xWn6/X5MmF6qoqEiLFy9WUVGRJk0ulN/vH8EiAQAA4AQD7i3DI1tNTd2zsByIsOV0/Ryv5ff7VVxcrMakLGUvWa3cZeuVvWS1GpOyVFxcTOACAADAgA2qtxwzRko4MsmuocGSekeCyzAMw+oi7KC5uVnp6elqampSWlqa1eUM3C9+Id16q3TlldLGjV03B4NBTZpcqMakLGX4Vsrl6s7dhhFSg3+VxnXs0Y7tHzKlEAAAAP06od4yJ0eqq5Nef1067zyLKj8xA80GjGw5XXhk66hphIFAQNW7qpQ2e1HEfwZJcrncSpu9UNVVOxUIBEaqUgAAANjUCfWWcXDcFmHL6cLHbB01jbC2tlaSlJiZ3+vdEjPyI/YDAAAA+nJCvWUcrEhI2HK6Pka2cnJyJEkd9VW93q2joSpiPwAAAKAvJ9RbMrIF2+tjZMvr9So3L1/Nm5+UYYQithlGSM2b1ys3v0Ber3ekKgUAAIBNnVBvycgWbK+Ppd89Ho9K15SodXuFGvyr1FZTqVBbi9pqKtXgX6XW7RUqLXmQxTEAAABwXCfUW4b7UweHLU5q7HT9LP3u8/lUVlampcuWq3rtiq7bc/MLVFpWJp/PN1JVAgAAwOYG3VuG+1MHTyNk6fcBsuXS74YhJSdLHR3Srl1Sbm6vuw3oLN8AAADAAAy4t3z6aenaa6VZs6TNm0e8zqEYaDZgZMvJmprMoCX1OrIV5vF4NGfOnJGpCQAAAI424N4yDka2OGbLyfbtM7+mpkopKdbWAgAAAPQ0dqz5NdyzOhBhy8nCL9xTTrG2DgAAAOBo4R51/34pFOp3V7sibDnZ/v3m1zFjrKwCAAAAOFa4RzUMqbnZ0lKGC2HLyRjZAgAAQKxKSek+1CU8SOAwhC0nC79oCVsAAACIReE+1aHHbRG2nCz8omUaIQAAAGJRuE9lZAu2wzRCAAAAxDJGtmBbLJABAACAWMbIFmyLkS0AAADEMka2YsvevXt14403Ki0tTWPGjNEtt9yigwcP9rv/1772NU2dOlWpqanKy8vT17/+dTU1NY1g1RZhZAsAAACxLNynErZiw4033qh33nlHzz33nDZu3KgXX3xRt912W5/7f/LJJ/rkk0+0evVqvf322/rVr36lZ599VrfccssIVm0RRrYAAAAQy3qe2NiBEqwuYDAqKyv17LPPqqKiQhdeeKEk6aGHHtL8+fO1evVqTZgw4Zj7TJ8+XRs2bOj6vrCwUPfff7+WLFmizs5OJSTY6p9gcFj6HQAAALHM4dMIbZU0Nm3apDFjxnQFLUmaO3eu3G63Xn31VV177bUDepympialpaX1G7Ta2trU1tbW9X2zHc9q3c/S78FgUIFAQLW1tcrJyZHX65XH4xnZ+gAAAOBox+05WSAjdtTV1Wn8+PERtyUkJGjs2LGqq6sb0GM0NDToe9/7Xr9TDyXpgQceUHp6etclNzf3hOu2TB8jW36/X5MmF6qoqEiLFy9WUVGRJk0ulN/vH/kaAQAA4EgD6jkdPrIVE2Hrnnvukcvl6vfy7rvvDvl5mpubdeWVV+rMM8/Ud77znX73vffee9XU1NR1qa6uHvLzj6jWVik8MtdjZMvv96u4uFiNSVnKXrJaucvWK3vJajUmZam4uJjABQAAgCEbcM/p8AUyXIZhGFYXUV9fr8bGxn73mTx5stauXau77rpL+3r8Mjo7O5WSkqL169f3O43wwIEDmjdvnkaNGqWNGzcqJSVlUDU2NzcrPT29awpizKutlSZMkNxuqbNTcrkUDAY1aXKhGpOylOFbKZerO2sbRkgN/lUa17FHO7Z/yJRCAAAAnJBB9Zxbt0rnnSdlZ5v9q00MNBvExDFbmZmZyszMPO5+F198sfbv36/XXntNF1xwgSTp+eefVygU0qxZs/q8X3Nzs+bNm6fk5GT9/ve/H3TQsqWex2u5XJKkQCCg6l1Vyl7ytYgXvSS5XG6lzV6o6rUrFAgENGfOnJGtFwAAAI4wqJ6zoMDc4NCRrZiYRjhQZ5xxhq644grdeuut2rJli15++WXdeeeduv7667tWIqypqdG0adO0ZcsWSWbQuvzyy3Xo0CH98pe/VHNzs+rq6lRXV6dgMGjljzO8eln2vfbIpwWJmfm93iUxIz9iPwAAAGCwBtVzhnvVtjbp8OERqW8k2SpsSdJvfvMbTZs2TZdddpnmz5+vSy+9VI888kjX9o6ODr333ntqaWmRJL3++ut69dVXtXXrVk2ZMkU5OTldF9sdhzUYvZzQOCcnR5LUUV/V6106Gqoi9gMAAAAGa1A958knd83CcuLoVkwcs2UHtjtma+1a6aabpLlzpeeekzTI+bMcswUAAIATMOiec+xYM2ht2yadcYaFlQ/cQLOB7Ua2MEC9LPvu8XhUuqZErdsr1OBfpbaaSoXaWtRWU6kG/yq1bq9QacmDBC0AAACcsEH3nA5e/j0mFsjAMOjjhMY+n09lZWVaumy5qteu6Lo9N79ApWVl8vl8I1gkAAAAnGhQPaeDl38nbDlVHyc0lswX/4IFC/o/mzcAAAAwBAPuOcP9arh/dRDCllP1MbIV5vF4WN4dAAAAw2pAPaeDR7Y4Zsup+hnZAgAAAGKGg0e2CFtOdZyRLQAAACAmMLIF22lqMr+mp1tbBwAAANCfcNgK968OQthyqkOHzK+jR1tbBwAAANCfk04yv4b7VwchbDlV+MUafvECAAAAsYiwBds5eND8ysgWAAAAYlm4Xw33rw5C2HIqRrYAAABgB4xswVba26XOTvM6YQsAAACxjLAFW+n5QiVsAQAAIJYRtmAr4fmuSUlSYqK1tQAAAAD94Zgt2ArHawEAAMAuGNmCrRC2AAAAYBfhnrW1VQoGra0lyghbThQegiVsAQAAINb1PFVRS4t1dQwDwpYThUe2OMcWAAAAYl1qquRymdcdNpWQsOVETCMEAACAXbhc0qhR5nXCFmIeYQsAAAB24tBFMghbThQ+ZotphAAAALADhy7/TthyIka2AAAAYCeMbME2CFsAAACwE8IWbIOl3wEAAGAnTCOEbbD0OwAAAOyEkS3YBtMIAQAAYCeELdgGYQsAAAB2Ep6RRdhCzOOYLQAAANhJuG/lmC3EPI7ZAgAAgJ0wjRC2wTRCAAAA2AlhC7bBNEIAAADYCUu/wzaYRggAAAA7YWQLtsE0QgAAANgJYQu2YBiELQAAANgLS7/DFlpbzcAlEbYAAABgDyz9Dlvo+WnAqFHW1QEAAAAMlEOnESZYXQCiLPwCTU2VPB5JUjAYVCAQUG1trXJycuT1euU5sg0AAAAYSb32poQt2MJRx2v5/X4tXbZc1buqunbJzctX6ZoS+Xw+KyoEAABAnOqrN/3Zt7+lz0mELcS4HufY8vv9Ki4uVmrhTGUv+ZoSM/PVUV+lxs1Pqri4WGVlZQQuAAAAjIj+etMlt9+uRklqb5c6OqTERKvLjQqXYYRXU0B/mpublZ6erqamJqWlpVldTt+ef1667DIZZ52l/AMH1ZiUpQzfSrlc3YfnGUZIDf5VGtexRzu2f8iUQgAAAAyrYDCoSZML++xNmzf8p/Zt/4d5w7590pgx1hQ6QAPNBiyQ4TRHhl4PBIOq3lWltNmLIl7MkuRyuZU2e6Gqq3YqEAhYUSUAAADiSCAQ6Lc3TZm9SB3hGxw0lZCw5TRHphG2us1fbWJmfq+7JWaYt9fW1o5MXQAAAIhb4Z6zz940s0BdEctBy78TtpzmyCcBniNDrx31Vb3u1tFg3p6TkzMiZQEAACB+hXvO/nrTrrDFyBZi1pEX59jcXOXm5at585MyjFDELoYRUvPm9crNL5DX67WiSgAAAMQRr9d73N60LeHI2n2ELcSsIy9O9+jRKl1TotbtFWrwr1JbTaVCbS1qq6lUg3+VWrdXqLTkQRbHAAAAwLDzeDzH7U3H5uaaOxO2ELN6LP3u8/lUVlamce27Vbd2hapLF6lu7QqN69jDsu8AAAAYUcfrTcdMnGju6KBjtjjPltOEPwkYPVqS+aJesGDBsWfpZkQLAAAAI6zf3vSRR8ydHDSyNaSw1dHRobq6OrW0tCgzM1Njx46NVl04UeEX50kndd3k8Xg0Z84ca+oBAAAAeuizNz0yWOCksDXoaYQHDhzQT3/6U336059WWlqaCgoKdMYZZygzM1P5+fm69dZbVVFRMRy1YiB6TCMEAAAAbCPcvzpoGuGgwlZJSYkKCgr02GOPae7cuXr66af15ptv6v3339emTZt03333qbOzU5dffrmuuOIKffDBB8NVN/rSy8gWAAAAEPPC/auDRrYGNY2woqJCL774os4666xet1900UX68pe/rIcffliPPfaYAoGATjvttKgUigE66pgtAAAAwBbiPWytW7eu6/rGjRs1f/58ud3HDo4lJyfrq1/96tCrw+AxsgUAAAA74pitbgsWLFBDQ0M0a0E0cMwWAAAA7Cjej9nqyTCMaNaBaGEaIQAAAOzIgdMIh3RS4zfffFMtLS0Rt33yySdKS0sbUlEYAqYRAgAAwI4cOI1wSOfZ+tznPieXy6WCggKdffbZmjp1qqqqqjRmzJgolYdBYxohAAAA7MiB0wiHFLbef/997dmzR1u3btVbb72lrVu3KhQK6ZHw2Z8xsoJB6fBh8zphCwAAAHbiwGmEQwpbJ598sgoLC3XxxRdHqx4MRc8pnRyzBQAAADtxYNg64WO2Pv/5zysxMTGatWCowi9Ml0tKSbG2FgAAAGAwOGar29NPPx3FMhAVPY/XcrmsrQUAAAAYDAceszWk1QgRY1iJEAAAAHbVcxqhQ04zNaiwtWvXrkE9eE1NzaD2xxBxji0AAADYVbiHDYWktjZra4mSQYWtmTNn6vbbb1dFRUWf+zQ1NennP/+5pk+frg0bNgy5QAwCy74DAADArnr2sA6ZSjioY7a2bdum+++/X5/97GeVkpKiCy64QBMmTFBKSor27dunbdu26Z133tH555+vH/7wh5o/f/5w1Y3eMI0QAAAAduXxSMnJ5qjWoUNSRobVFQ3ZoMLWuHHjVFJSovvvv1/PPPOMXnrpJVVVVam1tVUZGRm68cYbNW/ePE2fPn246kV/jppGGAwGFQgEVFtbq5ycHHm9Xnk8HgsLBAAAAEy99qonndQdthzghFYjTE1NVXFxsYqLi6NdD4aix8iW3+/X0mXLVb2rqmtzbl6+SteUyOfzWVQgAAAAoD571Xfdbo2S4jtshXV0dKiurk4tLS3KzMzU2LFjo1UXTsSRF+WuxkYVFxcrtXCmspd8TYmZ+eqor1Lj5idVXFyssrIyAhcAAAAs4ff7++xVd+7aojMlx4StQS/9fuDAAf30pz/Vpz/9aaWlpamgoEBnnHGGMjMzlZ+fr1tvvbXfBTQwjA4fliS9/PobSi2cqQzfSiVPnCZ3UqqSJ05Thm+lUgtnaunyuxQMBi0uFgAAAPEmGAxq6bLlffaq7cmjzP3iMWyVlJSooKBAjz32mObOnaunn35ab775pt5//31t2rRJ9913nzo7O3X55Zfriiuu0AcffDBcdaM3R5bI3HvooNJmL5LLFfnrdbncSpu9UNVVOxUIBKyoEAAAAHEsEAioeldVn71q58nmohjb3njDivKiblDTCCsqKvTiiy/qrLPO6nX7RRddpC9/+ct6+OGH9dhjjykQCOi0006LSqEYgCMjW4clJWbm97pLYoZ5e21t7UhVBQAAAEjq7kH76lXbU06WJDXv2TNiNQ2nQYWtdevWdV3fuHGj5s+fL7f72MGx5ORkffWrXx16dRicIyNbbZI66quUPHHaMbt0NJgHIebk5IxkZQAAAEBXD9pXr9oW7JAkjXXIqYwGfcxW2IIFC9TQ0BDNWjBUR0a2ktPT1bz5SRlGKGKzYYTUvHm9cvML5PV6ragQAAAAcczr9So3L7/PXvVgszmiNTW/95EvuznhsGUYRjTrQDQcCVuXf/7zat1eoQb/KrXVVCrU1qK2mko1+FepdXuFSkse5HxbAAAAGHEej0ela0r67FVbDu2XJLk7OqwtNEpOOGxJ0ptvvqmWlpaI2z755BOlpaUNqSicoCPTCGdccIHKyso0rn236tauUHXpItWtXaFxHXtY9h0AAACW8vl8ffaqs+fMMXc6Mohgd0M6z9bnPvc5uVwuFRQU6Oyzz9bUqVNVVVWlMWPGRKk8DEr4RZmSIp/PpwULFhx7Vm5GtAAAAGCxPnvVf/1XqbycsCVJ77//vvbs2aOtW7fqrbfe0tatWxUKhfTII49Eqz4MxpGRLaWkSDKHaeeEPx0AAAAAYkivvWpysvk13Nfa3JDC1sknn6zCwkJdfPHF0aoHQxH+BCD8IgUAAADs5MiggVNGtk74mK3Pf/7zSkxMjGYtGKoe0wgBAAAA22Fky/T0009HsQxERfhFycgWAAAA7IiRLcQsRrYAAABgZ/Ectnbt2jWoB6+pqRnU/hgiwhYAAADszGHTCAcVtmbOnKnbb79dFRUVfe7T1NSkn//855o+fbo2bNgw5AIxCEwjBAAAgJ05bGRrUMdsbdu2Tffff78++9nPKiUlRRdccIEmTJiglJQU7du3T9u2bdM777yj888/Xz/84Q81f/784aobvWFkCwAAAHYWzyNb48aNU0lJiWpra/XjH/9Yp512mhoaGvTBBx9Ikm688Ua99tpr2rRpE0HLCoxsAQAAwM7ieWQrLDU1VcXFxSouLo52PRgKRrYAAABgZ+E+Nh5HtiRpw4YNOvfcc7u+v+eee/TYY4/p9ddfV5tD/lFsKRiUOjvN64QtAAAA2FF4hla8jmw99thj+tKXvtT1/U9+8hMFg0EdPnxYHo9HZ5xxhl588UWNGTMmimXiuHoGXaYRAgAAwI4cNo1w0CNb77zzji6//PKI27Zu3aqPPvpIfr9fiYmJevjhh6NWIAao5wuSkS0AAADYUTwvkCFJtbW1Sk9P7/re4/HI5XKpoKBAV199tVasWKE//OEPUS0SAxB+QXo8UsIJHYoHAAAAWCveR7YyMjK0c+fOru/r6uqUn5/f9f25556rbdu2RaU4DEL4BckUQgAAANhVvC+Q8ZnPfEa//OUvu75PSUmRx+PpfkC3Wx0dHdGpDgPHSoQAAACwu3hfIGPFihWaOXOmzjnnHH3jG984ZvvLL7+syZMnR6U4DEKPc2wFg0EFAgHV1tYqJydHXq83IhADAAAAsaJn75qfnKxLJDNsGYbkclld3pAMOmzNmDFDa9eu1eLFi/WHP/xBd9xxh2bOnKmEhAS99NJLuvfee7Vs2bLhqBX9OZL+DwWDOmNyoap3VXVtys3LV+maEvl8PquqAwAAAI7h9/u1dNnyrt51jKR9khm0OjulxEQLqxu6QU8jlKTi4mK9+uqr6uzs1MKFCzVp0iTl5ubq+uuv16xZs7R8+fJo14njORK2qvbsUWNSlrKXrFbusvXKXrJajUlZKi4ult/vt7hIAAAAwOT3+1VcXBzRu465/oGu7b9/8kkLq4sOl2EYxlAeYNeuXdq6dasOHDigs846SzNmzIhWbTGlublZ6enpampqUlpamtXlHCP4xz/Kc+WV+mfSKH1+6eNyubpztGGE1OBfpXEde7Rj+4dMKQQAAIClgsGgJk0uVGNSljJ8K7t6V5cR0o4ffl6SdM6puXp9546Y7F0Hmg1OaGSrp7y8PF155ZW6/vrrHRu07GDb669LkjrSMiOCliS5XG6lzV6o6qqdCgQCVpQHAAAAdAkEAqreVaW02YsiBwlcbrW7zSOdGj+utn3vOuSwhdjQVF8vSWpPGd3r9sQMc3n+2traEasJAAAA6E24J03MzD9mW1uCeZxWiuzfuxK2HGLcqFGSpLZgZ6/bOxrMgw5zcnJGrCYAAACgN+GetKO+6pht7R4zbCXL/r0rYcshph45sfTB5t0yjFDENsMIqXnzeuXmF8jr9VpRHgAAANDF6/UqNy9fzZufPKZ3bUtIkiQVZOfYvnclbDmE+8iJpFsO7VeDf5XaaioVamtRW02lGvyr1Lq9QqUlD8bkAYYAAACILx6PR6VrStS6veKY3rX18AFJ0oqv3Wn73nXQ59lCjDqy9PvsOXM07qMdql67omtTbn6BSsvKOM8WAAAAYobP51NZWZl5nq0evWvnkXNrzZk926rSooaw5RRtbZKk/NNO046//rXrLNw5Oebwq90/FQAAAIDz+Hw+LViwIKJ3Pf2b35Ree61rMMHOCFtOcSRsKTlZHo9Hc+bMsbQcAAAAYCCO6V2TzGO21N5uST3RxDFbThF+MYZfnAAAAIAdEbYQc44skEHYAgAAgK2F+9lwf2tjhC2nYGQLAAAATsDIFmIOYQsAAABOQNhCzAm/GI8slQkAAADYEmELMYeRLQAAADhBePCAsIWYQdgCAACAEzCyhZhD2AIAAIATELYQc1j6HQAAAE7A0u+IOYxsAQAAwAkY2ULMYTVCAAAAOAFhCzGHkS0AAAA4AWELMYewBQAAACcgbCHmELYAAADgBJxnCzGHsAUAAAAnYGQLMYewBQAAACcgbCHmhM9DwGqEAAAAsDPOs4WYw8gWAAAAnICRLcQcwhYAAACcgLCFmEPYAgAAgBMQthBTDIOwBQAAAGdg6XfElGDQDFwSYQsAAAD2xsgWYkrPFyJhCwAAAHZG2EJM6bksJku/AwAAwM5Y+h0xpWfqJ2wBAADAzhjZQkwJvxATEiQ3v1IAAADYGGELMYWVCAEAAOAUhC3EFMIWAAAAnIKwhZhC2AIAAIBTcJ4txJTwC5HFMQAAAGB3PVcjDJ9L1qYIW04QXhaTkS0AAADYXc+etrPTujqigLDlBEwjBAAAgFP07GltPpWQsOUEhC0AAAA4BWELMYWwBQAAAKfweCSXy7xO2ILlCFsAAABwCpfLMcu/E7acgNUIAQAA4CQOWf6dsOUE4dUICVsAAABwAka2EDPCS2IStgAAAOAECQnm12DQ2jqGiLDlBOGwFX5RAgAAAHYW7ms5zxYsR9gCAACAkxC2rLF3717deOONSktL05gxY3TLLbfo4MGD/d7n9ttvV2FhoVJTU5WZmakFCxbo3XffHaGKRwBhCwAAAE5C2LLGjTfeqHfeeUfPPfecNm7cqBdffFG33XZbv/e54IIL9Nhjj6myslJ//vOfZRiGLr/8cgVtPge0C2ELAAAATuKQsGWr7ryyslLPPvusKioqdOGFF0qSHnroIc2fP1+rV6/WhAkTer1fzzBWUFCgVatW6ZxzztHOnTtVWFg4IrUPK8IWAAAAnISwNfI2bdqkMWPGdAUtSZo7d67cbrdeffVVXXvttcd9jEOHDumxxx7TpEmTlJub2+d+bW1tamtr6/q+ubl5aMUPpyMvwpDHoxfLy1VbW6ucnBx5vV55PB6LiwMAAACOLxgMKhAIqLa2VlcfPqzRku3Dlq2mEdbV1Wn8+PERtyUkJGjs2LGqq6vr977/8z//o9GjR2v06NH605/+pOeee05J4fX7e/HAAw8oPT2969JfMLPckRfhE2UbVFRUpMWLF6uoqEiTJhfK7/dbXBwAAADQP7/fr0mTC7t62fc++kiS9PILL1hc2dDERNi655575HK5+r0MdUGLG2+8UW+88YZeeOEFnX766Vq0aJEOHz7c5/733nuvmpqaui7V1dVDev7htG3rVknSQc8oZS9Zrdxl65W9ZLUak7JUXFxM4AIAAEDM8vv9Ki4uVmNSVlcv6xpnDnT8YNUqW/eyLsMwDKuLqK+vV2NjY7/7TJ48WWvXrtVdd92lffv2dd3e2dmplJQUrV+/fkDTCCWpvb1dp5xyin7xi1/ohhtuGNB9mpublZ6erqamJqWlpQ3oPiMhGAzqx2PH6RvNTfrV+VfqO5+9o2ubYYTU4F+lcR17tGP7h0wpBAAAQEwJBoOaNLlQjUlZyvCtlMtljgWVrV2hC2sq9YXs07QpuSPmetmBZoOYOGYrMzNTmZmZx93v4osv1v79+/Xaa6/pggsukCQ9//zzCoVCmjVr1oCfzzAMGYYRcUyWXQUCAbU0N0mSgu7IX6fL5Vba7IWqXrtCgUBAc+bMsaBCAAAAoHeBQEDVu6qUveRrXUFLkoJuM1idfNpsVQf+n2172ZiYRjhQZ5xxhq644grdeuut2rJli15++WXdeeeduv7667tWIqypqdG0adO0ZcsWSdJHH32kBx54QK+99pp27dqlV155RQsXLlRqaqrmz59v5Y8TFbW1tV2JudN9bNpPzMjv2g8AAACIJeEeNTEzP+L2TrcZU5JHj43Yz25sFbYk6Te/+Y2mTZumyy67TPPnz9ell16qRx55pGt7R0eH3nvvPbW0tEiSUlJSFAgENH/+fE2ZMkVf+MIXdPLJJ+uVV145ZrENO8rJyekKW0H3sb/Ojoaqrv0AAACAWBLuUTvqqyJuD7rMQQRX0+6I/ewmJqYRDsbYsWP129/+ts/tBQUF6nkY2oQJE/THP/5xJEqzhNfr1Y7RJ0sHD6jTFRm2DCOk5s3rlZtfIK/Xa1GFAAAAQO+8Xq9y8/LVuPnJiGO2wjO2Oj581da9rO1GthDJ4/Ho05dcLElqfu9ltdVUKtTWoraaSjX4V6l1e4VKSx6MqQMKAQAAAMnsZUvXlKh1e4Ua/Ku6etn2dnOWWmjPDlv3srYb2cKxJuflSZKSgodUt3ZF1+25+QUqLSuTz+ezqjQAAACgXz6fT2VlZVq6bLmqj/Syh45s+9fbbtN5Nu5lCVtOcOSkxt/897t10cUXq7a2Vjk5OfJ6vbb9FAAAAADxw+fzacGCBQoEAqqtrZX3kUek8nKdN2OG1aUNCWHLCY6ELXdSki2XxAQAAAA8Hk93L7txo/n1SJ9rVxyz5QThF2EC2RkAAAAOEO5rCVuwHGELAAAATkLYQswgbAEAAMBJCFuIGYQtAAAAOAlhCzGDsAUAAAAnIWwhZhC2AAAA4CSELcQMwhYAAACchLCFmEHYAgAAgJMQthAzCFsAAABwEsIWYgZhCwAAAE5C2ELMIGwBAADASQhbiBmELQAAADgJYQsxg7AFAAAAJyFsIWYQtgAAAOAkhC3EDMIWAAAAnISwhZhB2AIAAICTOCRs0Z07wZEXYcUbb+jD999XTk6OvF6vPB6PxYUBAAAAAxcMBhUIBJTyj39otiSjo0Muq4saAka2HKCtpUWS9KVbb9XixYtVVFSkSZML5ff7La4MAAAAGBi/369JkwtVVFSk/3nkEUnSC88/b+uelrBlc36/Xy3NzZKkU66+W7nL1it7yWo1JmWpuLjY1i9OAAAAxAe/36/i4mI1JmUpe8lqpX/u65Ikw5Vk656WsGVjwWBQS5ctV4LL/DW6c06TOylVyROnKcO3UqmFM7V0+V0KBoMWVwoAAAD0LtzTphbOVIZvpZInTlMoMVWSlJKRZ+uelrBlY4FAQNW7qpTgNn+NQXf3MVoul1tpsxequmqnAoGAVSUCAAAA/Qr3tGmzF8l1ZBCh80hfmxAK2bqnJWzZWG1trSQpwTAkSZ3uyF9nYkZ+xH4AAABArAn3qomZ+V23BbvCVtDWPS1hy8ZycnIkSYkhc0i158iWJHU0VEXsBwAAAMSacK/aUV/VdVt4EMFjBG3d0xK2bMzr9So/N6/r+84eYcswQmrevF65+QXyer1WlAcAAAAcl9frVW5evpo3PynDCEnqHkTwhIK27mkJWzbm8XhU+t8/7Pq+pe5Dhdpa1FZTqQb/KrVur1BpyYOcbwsAAAAxy+PxqHRNiVq3V6jBv0ptNZXqCJrnkXXtr7N1T+syjCMH/KBfzc3NSk9PV1NTk9LS0qwup9uhQ9Lo0ZKkkyS1HLk5N79ApSUPyufzWVYaAAAAMFB+v19Lly1X9a4qeSW9KOnDhAS99cQTMdfTDjQbELYGKGbDVnOzlJ4uSXrhz3/WJ42NysnJkdfrtWX6BwAAQPwKBoMKBALqeOEFffY735ExZYpcH3xgdVnHGGg2SBjBmjAcOju7rn76ssskAhYAAABsyuPxaM6cOdKoUdJ3viNXj17Xjjhmy+56vgDd/DoBAADgAAlHxoQIW7BU+AWYkCC5XNbWAgAAAEQDYQsxoWfYAgAAAJyAsIWYQNgCAACA0xC2EBMIWwAAAHAawhZiAmELAAAATkPYQkwgbAEAAMBpCFuICYQtAAAAOE3PsGUY1tYyBIQtuyNsAQAAwGl69rahkHV1DBFhy+4IWwAAAHCanr2tjacSErbsjrAFAAAApyFsISYQtgAAAOA0hC3EBMIWAAAAnIawhZhA2AIAAIDTuN2Sy2VeJ2zBMoQtAAAAOJEDzrVF2LK7Iy++/YcOad26dSovL1cwGLS4KAAAAODEBINBlZeXq/PIyFawrc3iik4cYcvmXn35ZUnSG1u3avHixSoqKtKkyYXy+/0WVwYAAAAMjt/v16TJhSoqKlJLe7skac6lXtv2toQtG/P7/fpRSYkkyZ19mnKXrVf2ktVqTMpScXGxbV+UAAAAiD9+v1/FxcVqTMpS9pLVCiWfJEk6kDjOtr0tYcumgsGgli5brlHjJ0uSjNQ0uZNSlTxxmjJ8K5VaOFNLl9/FlEIAAADEvHBvm1o4Uxm+lUqeOE2dHvOYrYy5t9u2tyVs2VQgEFD1riqNnnyhJKnT3f2rdLncSpu9UNVVOxUIBKwqEQAAABiQcG+bNnuRXC6zrw26PZKkRCNk296WsGVTtbW1kqTkk8ZI6n4xhiVm5EfsBwAAAMSqcM+amJnfdVuny+xvPaGQbXtbwpZN5eTkmFea6yVJnUeFrY6Gqsj9AAAAgBgV7lk76qu6bgsembmVEAratrclbNmU1+tVbl6+One8JilyZMswQmrevF65+QXyer1WlQgAAAAMSLi3bd78pAwjJKl7MMET7LBtb0vYsimPx6PSNSUyGnZJktoPH1SorUVtNZVq8K9S6/YKlZY8KI/Hc5xHAgAAAKwV7m1bt1eowb9KbTWVCh45z9bBF35l296WsGVjPp9PX7rpJknSgR2vq7p0kerWrtC4jj0qKyuTz+ezuEIAAABgYHw+n8rKyjSufbfq1q5Q694aSdLYjn227W0TrC4AQzNj2jRJ0rwrr9Rvb7xROTk58nq9tkv9AAAAgM/n04IFCxQIBHTqzTdLO3dq7WOPyjN/vtWlnRDClt11dkqSJuTm6oYbbrC4GAAAAGBoPB6P5syZI2VmSjt3ymMYVpd0wphGaHdHwpYSyM0AAABwkHB/G+53bYiwZXeELQAAADgRYQuWI2wBAADAiQhbsBxhCwAAAE5E2ILlCFsAAABwIsIWLEfYAgAAgBMRtmA5whYAAACciLAFyxG2AAAA4ESELViOsAUAAAAnImzBcoQtAAAAOBFhC5YjbAEAAMCJCFuwXPjF5/FYWwcAAAAQTeH+lrAFywSD5lfCFgAAAJwk3N+G+10bImzZXShkfiVsAQAAwEnC/W2437UhwpbdhZO+m18lAAAAHCTc3zKyBcswjRAAAABOxDRCWI5phAAAAHAiphHCckwjBAAAgBMxjRCWYxohAAAAnIhphLAc0wgBAADgREwjhOWYRggAAAAnYhohLMc0QgAAADgR0whhOaYRAgAAwImYRgjLMY0QAAAATsQ0QliOaYQAAABwIqYRwnJMIwQAAIATMY0QlmMaIQAAAJyIaYSwHNMIAQAA4ERMI4TlmEYIAAAAJ2IaISzHNEIAAAA4EdMIYTmmEQIAAMCJmEYIyzGNEAAAAE7ENEJYjmmEAAAAcCKmEcJyTCMEAACAEzGNEJZjGiEAAACciGmEsBzTCAEAAOBETCOE5ZhGCAAAACdiGiEsxzRCAAAAOBHTCGGlYDCoYEeHJGnzli0K2jj1AwAAAGHBYFBvb9smSdq/d69t+1zClk35/X5NmlyozrY2SdLCG27QpMmF8vv9FlcGAAAAnLhwn7vyO9+RJG3butW2fS5hy4b8fr+Ki4vVmJQlt8v8FY7z/R81JmWpuLjYli9EAAAAoGefmzbnZklSckaebftcwpbNBINBLV22XKmFM5XhWymPYUiSEnNOV4ZvpVILZ2rp8rtsO9QKAACA+HRMn5uRJ0lKSEi2bZ9L2LKZQCCg6l1VSpu9SC655JYZtoJut1wut9JmL1R11U4FAgGLKwUAAAAGLqLPdbkVOjKDy2OEbNvnErZspra2VpKUmJkvt9G9MkvwyIsxMSM/Yj8AAADADnr2uVJ3fxvuee3Y5xK2bCYnJ0eS1FFfJU+PsGW4XObtDVUR+wEAAAB20LPPlaTQkf7WfWTpdzv2uYQtm/F6vcrNy1fz5iflCnZ23R50uWUYITVvXq/c/AJ5vV4LqwQAAAAGp2efaxghhdzd0wjt2ucStmzG4/GodE2JWrdXaN/vftB1e2vdB2rwr1Lr9gqVljwoDyc5BgAAgI307HMb/Kt0uLFakuTqOGzbPpewZUM+n09lZWXKbN/Tddsnj39b4zr2qKysTD6fz8LqAAAAgBMT7nPHte9W/V9+Kkkymutt2+e6DOPI2uHoV3Nzs9LT09XU1KS0tDSry5EkBRsa5MnMlCS98NxzurSoyFZJHwAAAOhNMBjUP3/2M53/b/+m1pwcJVVXx1SfO9BskDCCNSHKPEcOGpSkT3/mM5KbgUoAAADYn8fj0fkzZ0qSUpOSpBgKWoNBd25nPU/o1iN4AQAAALYXHkiw0UmMj0bYsrPwC8/tJmwBAADAWcKjWYQtWOLIOQfsOqwKAAAA9Cnc44ZC/e8XwwhbdtZzZAsAAABwEqYRwlLhFx4jWwAAAHAaphHCUkwjBAAAgFMxjRCWYhohAAAAnIpphLAU0wgBAADgVEwjhKWYRggAAACnYhohLMU0QgAAADgV0whhKaYRAgAAwKmYRghLMY0QAAAAThXucQ3DvNgQYcvOmEYIAAAAp+rZ49r0uC26dBsLtrdLkg60tqq8vFxBGw+xAgAAAD317GxfeP55W/a6hC2b8vv9WlhcLEmq3bNHRUVFmjS5UH6/3+LKAAAAgKHx+/2afu55Xd/Pu/xyW/a6hC0b8vv9Ki4u1sGEUyRJ7lMmKHvJajUmZam4uNh2L0IAAAAgLNzrNiSN77ptwvX327LXJWzZTDAY1NJly5VaOFOneG+SJBluj5InTlOGb6VSC2dq6fK7bDnMCgAAgPgW0esuuKfr9tTs02zZ6xK2bCYQCKh6V5XSZi/q+uWFXC5JksvlVtrshaqu2qlAIGBdkQAAAMAJ6Nnryp3Qdbtbhi17XcKWzdTW1kqSEjPz5T6yBGbI1f1rTMzIj9gPAAAAsIuevW54QEGSXEf6Xrv1uoQtm8nJyZEkddRXdb3ojB4vxI6Gqoj9AAAAALvo2ev2DFtuw1z63W69LmHLZrxer3Lz8tW8+Um5DHOuanhkyzBCat68Xrn5BfJ6vVaWCQAAAAxaz16351FZbsOwZa+bcPxdEEs8Ho9K15SYqxEe2i9JChmG2moq1bx5vVq3V6i0rEye8Bm3AQAAAJvo2es2PHV/1+0dn7ynhn8+a7tel5EtG/L5fCorK1N65z5J0uE9H6lu7QqN69ijsrIy+Xw+iysEAAAATky41x3XvrtrdKthw3/astd1GcaRA3/Qr+bmZqWnp6upqUlpaWlWlyNJCj79tDzXXquGKVP09s9/Lq/Xa5uUDwAAAPQnGAzKlZwsdzCoV558UrN8vpjpdQeaDZhGaGOeIwcNZmRmas6cOdYWAwAAAESRx+ORPB4pGNQls2eb122GaYR2FjJXZZGbXyMAAAAcKNznhvtem6FLtzPCFgAAAJyMsAXLELYAAADgZIQtWIawBQAAACcjbMEyhC0AAAA4GWELliFsAQAAwMkIW7AMYQsAAABORtiCZQhbAAAAcDLCFixD2AIAAICTEbZG1t69e3XjjTcqLS1NY8aM0S233KKDBw8O6L6GYehzn/ucXC6Xnn766eEtdCQQtgAAAOBkhK2RdeONN+qdd97Rc889p40bN+rFF1/UbbfdNqD7lpaWyuVyDXOFI4iwBQAAACezedhKsLqAwaisrNSzzz6riooKXXjhhZKkhx56SPPnz9fq1as1YcKEPu/75ptv6sEHH9Q//vEP5eTkjFTJw4uwBQAAACezediyVZe+adMmjRkzpitoSdLcuXPldrv16quv9nm/lpYWLV68WD/5yU+UnZ09oOdqa2tTc3NzxCWWBINBvf/uu5Kk+sZGBYNBiysCAAAAoicYDKq1vV2S9FpFhS37XVuFrbq6Oo0fPz7itoSEBI0dO1Z1dXV93m/ZsmW65JJLtGDBggE/1wMPPKD09PSuS25u7gnXHW1+v1+TJhfq/5aWSpL+/uKLmjS5UH6/39rCAAAAgCgI97ufHOnx7/y3f7NlvxsTYeuee+6Ry+Xq9/LukVGcwfr973+v559/XqVHgslA3XvvvWpqauq6VFdXn9DzR5vf71dxcbEak7I05sJrJElJ+eeqMSlLxcXFtnsBAgAAAD317HddJ2dIkjIv/zdb9rsxEbbuuusuVVZW9nuZPHmysrOztWfPnoj7dnZ2au/evX1OD3z++ee1fft2jRkzRgkJCUpIMA9Tu+666zRnzpw+a0pOTlZaWlrExWrBYFBLly1XauFMZfhWKik9U5LkGpWuDN9KpRbO1NLld9lyiBUAAAA4ut81EpMlSckZubbsd2NigYzMzExlZmYed7+LL75Y+/fv12uvvaYLLrhAkhmmQqGQZs2a1et97rnnHn3lK1+JuG3GjBlas2aNrr766qEXP4ICgYCqd1Upe8nX5HK55TYMSVLI5ZLL5Vba7IWqXrtCgUCg3yAJAAAAxKKj+11D5kribsOwZb8bE2FroM444wxdccUVuvXWW/Xwww+ro6NDd955p66//vqulQhramp02WWX6X//93910UUXKTs7u9dRr7y8PE2aNGmkf4Qhqa2tlSQlZuZLklyGuSpL6Mhy9okZ+RH7AQAAAHZydL8bcpkT8cKDDHbrd2NiGuFg/OY3v9G0adN02WWXaf78+br00kv1yCOPdG3v6OjQe++9p5aWFgurHB7hJes76qskdb/ojCMvwo6Gqoj9AAAAADs5ut8NDyqEBxns1u/aamRLksaOHavf/va3fW4vKCiQcSSE9OV422OV1+tVbl6+Gjc/qQzfyohphIYRUvPm9crNL5DX67W4UgAAAGDwju53DVf3NEI79ru2G9mKZx6PR6VrStS6vUIN/lUKNe2WJHW0NKvBv0qt2ytUWvKgPB6PxZUCAAAAg3d0v9vZaZ5nK9hQZct+l7BlMz6fT2VlZRrXvluH3vyTJOnQ9i0a17FHZWVl8vl8FlcIAAAAnLie/W77vk8kSfuf/4Ut+12XYdc5dSOsublZ6enpampqipll4HfdeqsmPfaYPrn6amU99ZRtEj4AAABwPMFgUIfOOktp772nt77/fZ11990x0+8ONBvY7pgtmDwejyblm6uxTDj1VClGXngAAABANHg8HqWlp0uSzp4+3Zb9LtMI7SxkrsoiN79GAAAAOFC4zw33vTZDl25nhC0AAAA4GWELliFsAQAAwMkIW7AMYQsAAABORtiCZQhbAAAAcDLCFixD2AIAAICTEbZgGcIWAAAAnIywBcsQtgAAAOBkhC1YhrAFAAAAJyNswTKELQAAADgZYQuWIWwBAADAyQhbsAxhCwAAAE5G2IJlCFsAAABwMsIWLEPYAgAAgJMRtmAZwhYAAACcjLAFyxC2AAAA4GSELViGsAUAAAAnI2zBMoQtAAAAOBlhC5YhbAEAAMDJCFuwDGELAAAATkbYghWCwaD21NVJkj7Yvl3BYNDiigAAAIDoCrlckqQ3X39d5eXltut5CVs25Pf7NWlyoV4oL5ckrfnRjzRpcqH8fr+1hQEAAABR4vf79WRZmSTpiccfV1FRke16XsKWzfj9fhUXF6sxKUujcmdIkk6+yKfGpCwVFxfb6sUHAAAA9Cbc87Z6RkmSTrnkemUvWW27npewZSPBYFBLly1XauFMZfhWKiHlJEmS+5QJyvCtVGrhTC1dfpfthlcBAACAsJ49b9Kk8yVJHrdHyROn2a7nJWzZSCAQUPWuKqXNXiSXyy23YUgy57K6XG6lzV6o6qqdCgQCFlcKAAAAnJiePa/hMuNKuO+1W89L2LKR2tpaSVJiZr4kyWWYq7KEDxxMzMiP2A8AAACwm549b+iosCXZq+clbNlITk6OJKmjvkpS94sunPg7Gqoi9gMAAADspmfPGx5UCA8ySPbqeQlbNuL1epWbl6/mzU/KMELdYUsuGUZIzZvXKze/QF6v1+JKAQAAgBPTs+cNhy3PkbBlt56XsGUjHo9HpWtK1Lq9Qg3+VdLhA5Kk9v21avCvUuv2CpWWPCiPx2NxpQAAAMCJ6dnztn64xbyxs0NtNZW263kJWzbj8/lUVlamce271V77viRp3yuPa1zHHpWVlcnn81lcIQAAADA04Z43OdQiSTrwj6dVt3aF7Xpel2H0ONoMfWpublZ6erqampqUlpZmdTkKBoNqmjVLY197Tdu+/W1N/e53bZHuAQAAgIEKLVsmd2mptl19tfYsXy6v1xsTPe9As0HCCNaEKPJ4PBqbni5JOvOss6QYeNEBAAAA0eQ+0uOeOXWqzpwzx9piTgDTCO0sPCh55MBBAAAAwFHCfa5NJ+MRtuws/KJz82sEAACAA4X7XMIWRlzoyPkGGNkCAACAE4X73FCo//1iFGHLzphGCAAAACdjGiEswzRCAAAAOBnTCGEZphECAADAyZhGCMswsgUAAAAnY2QLlmFkCwAAAE7GyBYswwIZAAAAcDIWyIBlmEYIAAAAJ2MaISzDNEIAAAA4GdMIYRmmEQIAAMDJmEYIyzCNEAAAAE7GNEJYhmmEAAAAcDKmEcIyjGwBAADAyRjZgmUY2QIAAICTccwWLMMCGQAAAHAyphHCMkwjBAAAgJMxjRCWYRohAAAAnIxphLAM0wgBAADgZEwjhGWYRggAAAAnYxohRlowGFR5ebkONDWZ39s06QMAAAD9OjKytaeuTuvWrVN5ebmCwaDFRQ0cYctm/H6/Jk0uVFFRkXbv3i1Jum7RF+T3+y2uDAAAAIiuN996S5JUXl6uxYsXq6ioSJMmF9qm9yVs2Yjf71dxcbEak7KUvWS1ktLGS5L2J45VcXGxbV50AAAAwPH4/X794pe/lCSl5p2t3GXrlb1ktRqTsmzT+xK2bCIYDGrpsuVKLZypDN9KJU+cJteRYdX0OTcrtXCmli6/y1bDqgAAAEBvwr1vQma+JCkhZbTcSalKnjhNGb6Vtul9CVs2EQgEVL2rSmmzF8nlMn9triMHChpuj9JmL1R11U4FAgErywQAAACGLNz7Jk+6QJLkUvcCGS6X2za9L2HLJmprayVJiUfSvdQjbMmlxIz8iP0AAAAAuwr3tO6TMyR1971hdul9CVs2kZOTI0nqqK/qui2c8A2XSx0NVRH7AQAAAHYV7mk7D+6VJLmPClt26X0JWzbh9XqVm5ev5s1PyjDMpd7DCT8kQ82b1ys3v0Ber9fKMgEAAIAhC/e+hz76x5FbusOWYYRs0/sStmzC4/GodE2JWrdXqMG/Sm01lXIfCV37nv+FWrdXqLTkQXk8HosrBQAAAIYm3Pu21++UJBmtBxRqa1FbTaUa/Kts0/sStmzE5/OprKxM49p3q27tCoUO7ZMkpXXuU1lZmXw+n8UVAgAAANHh8/l0x7/+qySpo6ZS1aWLVLd2hcZ17LFN7+syjKMmQKJXzc3NSk9PV1NTk9LS0iytJRgMKhAIaNY11yi1qUnBN96Q59xzLa0JAAAAiLpf/Uq6+WY1zpqlv3zjG8rJyZHX67V8RGug2SBhBGtClHg8Hs2ZM0dKSjK/T+DXCAAAAAc6cl7ZcWPG6IYbbrC4mMFjGqGdhQcl3fwaAQAA4EDhPtemk/Ho0u0sZC6QEU78AAAAgKOE+1zCFkZc+EVH2AIAAIAThfvc8CCDzRC2bCgYDKq8vFztbW3m9zZN+gAAAEC/jkwj3Ld3r9atW6fy8nIFg0GLixo4wpbN+P1+TZpcqKKiIrW2tEiSii6bK7/fb3FlAAAAQHRtqaiQJL3xxhtavHixioqKNGlyoW16X8KWjfj9fhUXF6sxKUvZS1bLnZQqSdqXmKHi4mLbvOgAAACA4/H7/SpZs0aSlDJ+snKXrVf2ktVqTMqyTe/7/7d398FRlvf+xz/3brIhiEmAhGR5CpAi0SqMBYypbivC4AM/D7JGEfDUWo+MFU7l4TgH+0NplY5UEamOWns6U53SgpLf+gAHaFEMRgSMEQZUpJIDSYoJIXBIeAjJsnv9/kh2YSFAUpLcudP3a+Yesvd9bfju7Hcy3+9c931dNFsOEQqFNGv2HCVmjVaqf74S+mUr8qRW8q0zlZg1WrPmzHXUtCoAAADQnEjtG5fxHUmSO6G7XJ5EJfTLVqp/vmNqX5othygsLFR5WamSrr9HltX4tblMZDVCl5Kuv1vlpftUWFhoY5QAAADApYvUvt2G5jaeOGONAstBtS/NlkNUVFRIkuLTMqPnrKacM5ZL8amZMeMAAAAAp4rUtK7k9MZ/z1oQzim1L82WQ3i9XklS8GBp9FxkZstYUrC6NGYcAAAA4FSRmvZU7UFJkqXYZssptS/NlkP4fD4NGJip2i1vyURuH2xKurAxqt2yUgMyB8nn89kXJAAAANAGIrXv8b99IumMx2ckGRN2TO1Ls+UQbrdbS19YorqSIlUHFqp+/y5ZTdOp1eteUl1JkZYueV5ut9vmSAEAAIBLE6l9T1Z+I0kyDXUK159Q/f5dqg4sdEztS7PlIH6/X/n5+erdcECVyx6TK9y4+krPYLXy8/Pl9/ttjhAAAABoG36/X/85b54k6VR1mcqX3qPKZY+pd7DKMbWvZcxZT5uhWbW1tUpOTlZNTY2SkpJsjSUUCqmwsFA/uPlmuYxRqLxc7v79bY0JAAAAaHOrV0t33KHaYcP03wsWyOv1yufz2T6j1dLeIK4DY0Ibcbvduummm06/jo+3LxgAAACgvbgab8RL6tFDU6ZMsTmY1uM2QgcKhUIqKCiI7jcQCocv/AYAAADAiSxLknS0tlbLly9XQUFBp9/I+Ew0Ww4TCAQ0eEiWxowZEz33vdHXKRAI2BgVAAAA0PY+/qRxNcI933yjqVOnasyYMRo8JMsxtS/NloMEAgHl5eXpkCddfac+Gz1/2JOmvLw8xyQdAAAAcDGBQEBPL1woSYrv2VcDZq9Uxn2LdciT7pjal2bLIUKhkGbNnqPErNFK9c9Xt37Dotd6/p//UGLWaM2aM9dR06oAAABAcyK1r6dvY83rjvPI5UlUQr9spfrnO6b2pdlyiMLCQpWXlSrp+ntkWa7oHluSJJdbSdffrfLSfSosLLQvSAAAAKANRGrfblfeJEkxta9luRxT+9JsOURFRYUkKT4tU5LkOiPhjGUpPjUzZhwAAADgVJGa1p2SLkmyFLtblVNqX5oth/B6vZKk4MFSSbEJZ2QpWF0aMw4AAABwqmjtW1MlSbLO2hnYKbUvzZZD+Hw+DRiYqdotb8mYcHTZd0kKyah2y0oNyBwkn89nY5QAAADApYvUvsd2FUiSXOb0VkfGhB1T+9JsOYTb7dbSF5aorqRI1YGFCn77dfRa9XvPqq6kSEuXPG/7btoAAADApYrUvif3N9W8p+oVrj+h+v27VB1Y6Jjal2bLQfx+v/Lz89W74YCqVvzf6PmewYPKz8+X3++3MToAAACg7fj9fj319NOSpHDtQZUvvUeVyx5T72CVY2pfyxhjLj4MtbW1Sk5OVk1NjZKSkmyNJRQK6ZO//EW+CRMaXx87Jvdll9kaEwAAANDmNm2SbrxRJ/r107vPPSev1yufz2f7jFZLe4O4DowJbcTtdst3ww2nX8fxNQIAAKALsixJUvdu3TRlyhSbg2k9biN0qph9tvgaAQAA0AVF6txw+MLjOimqdKc6M+GaOn4AAACgS4nUuQ598olmy6nOTDiaLQAAAHRFNFuwBbcRAgAAoKvjNkLYgtsIAQAA0NUxswVbODThAAAAgBaj2YItIgnHLYQAAADoqriNELaIJBy3EAIAAKCrYmYLtmBmCwAAAF0dM1voaKFQSJs3bZIkhZteAwAAAF1O08xWQ0ODli9froKCAkfVvjRbDhMIBDR4SJYmT54sSWoIBjV4SJYCgYDNkQEAAABta/3770uSao4c0dSpUzVmzBhH1b40Ww4SCASUl5enQ550pd/5c0mSccfrkCddeXl5jkk6AAAA4GICgYAenT1bkuT2dNeA2SuVcd9iR9W+NFsOEQqFNGv2HCVmjVaqf74S0odIkozLpVT/fCVmjdasOXMdNa0KAAAANCdS+yYMvEaS5HK55PIkKqFftqNqX5othygsLFR5WamSrr9HluVSZA1CI0uW5VLS9XervHSfCgsLbY0TAAAAuFSR2veyEbdJkqwzViN0Uu1Ls+UQFRUVkqT4tExJpxMu3PTQYHxqZsw4AAAAwKkiNa2rd39Jsc2W5Jzal2bLIbxeryQpeLBUkuQyjctfmqY5rmB1acw4AAAAwKmite//fitJshTbbDml9qXZcgifz6cBAzNVu+UtGRM+fRuhZcmYsGq3rNSAzEHy+Xy2xgkAAABcqmjtu32NJEVrX0mOqn1pthzC7XZr6QtLVFdSpOrAQp2q3CNJCpuwqgMLVVdSpKVLnpfb7bY5UgAAAODSRGvf0h2SJFfolML1J1S/f5ejal+aLQfx+/3Kz89X74YDql71nCQp3FCn3sEq5efny+/32xwhAAAA0Db8fr9eefXVxhehoMqX3qPKZY85qva1jDnraTM0q7a2VsnJyaqpqVFSUpKtsYRCIRX/8Y+67oEH1JCcLPehQ52+qwcAAABaraxMysxUOD5eb77xhrxer3w+n+21b0t7g7gOjAltxO1267pRoyRJHo9HotECAABAV9S08rbLsjRlyhSbg2k9biN0qsiEpGVdeBwAAADgVJFa16E349FsOUwoFFJBQYHWrmlcmcW4+AoBAADQRTXVuiYU0vLly1VQUKBQKGRzUC1Hpe4ggUBAg4dkacyYMXp83jxJUtXBgwoEAjZHBgAAALS9NWvXSpLC4bCmTp2qMWPGaPCQLMfUvzRbDhEIBJSXl6dDnnRl3LdY3mnPSpJCcikvL88xCQcAAAC0RCAQ0IP/9m+SJEuWBsxeqYz7FuuQJ90x9S+rEbaQnasRhkIhDR6SpUOedKX658uyXPpu5R799xuz9O3lqRqaPkS9g1XaW7LH9pVZAAAAgEsVqX9drl7at2+bJGnQf66W1LipcXVgoa31b0t7A2a2HKCwsFDlZaVKuv4eWVbjV+Zq6pGNLCVdf7fKS/epsLDQzjABAACANhGpf3uMmnj6ZFP9a1kux9S/NFsOUFFRIUmKT8uMnrPU1GxZluJTM2PGAQAAAE4WqWtdqQOj5yL1ryTH1L80Ww7g9XolScGDpdFz0Zkty1KwujRmHAAAAOBk0fr30N+j51xnPP3klPqXZssBfD6fBgzMVO2Wt2RMWJJkRW8jlGq3rNSAzEHy+Xw2RgkAAAC0jWj9+9k70XPR+teEHVP/0mw5gNvt1tIXlqiupEjVgYWq379LpuGkJCl44ojqSoq0dMnzLI4BAACALiFS/x7f+3n0nKk/ofr9u1QdWOiY+pfVCFvIztUIIwKBgB6dPUd/LyvV9yVtkrQ3Lk7b3nxTfr/flpgAAACA9vLesmX6l3/9V0lSN0n1ktLS0/XySy/p7rvvti0uViPsqiKrsERe2hcJAAAA0K7+ZeLp1Qgj9e/BAwc09z8ec8Q+WzRbDhHZ1PhwQoYy7lusjLufkiQFrTjHbOoGAAAAtMa7q1ZFf/be+yvHbWzMbYQt1Nk2Nc4p26k3lz+uPb36a0SvvmxqDAAAgC4lFArpykGD9be/l0uSrpq9Uic8iZLs39iY2wi7kOY2NY7sMxB20KZuAAAAQEsVFhaqrKnRkk6vRig5Z2Njmi0HaHZT4+g+W87Z1A0AAABoqYqKipj1CVxnrVbghBqYZssBmtvU+PQ+W2xqDAAAgK7H6/XGtFfWWU8/OaEGptlygGY3NW66FrYsx2zqBgAAALSUz+dTvwEDm73mlI2NabYcoLlNjdVQJ0k6VVPlmE3dAAAAgJZyu916/vnF0denvv1aYYdtbMxqhC3UWTY1njV7jsrLSjVe0l8kfRHv0d9WLGdTYwAAAHQ94bDU1EylSjrUdHpA5iAtXfK8bTVwS3sDmq0W6gzNliQ1NDTolVdekWfDBj2yapXC114r1+ef2xYPAAAA0G6MkVyNN+O99vTT+uLAAWVlZemRRx6Rx+OxLSyarTbWGZqtM2e2bpO0RtIOj0d7ljOzBQAAgC7KalytIF1SVdOpAQMztfSFJZ1+ZotnthwiEAgoLy9PhzzpyrhvsfpMnCdJClrxjtg9GwAAAGitQCCgUNPPGf4nNWD2SmXct1iHPOmOqIFpthwgFApp1uw5SswarVT/fCX0y5YrrnHa1NWrnxKzRmvWnLkKhUIX+U0AAACAM0Rq4MhteCbcoLo9n8qEGtT7zscdUQPTbDlAYWGhystKlXT9PbKsxq/Mako7S3LE7tkAAABAa0Rq4MimR9XvLFL1qud0YPnP9e1/PSxP3+xOXwPH2R0ALi6yK3Z8Wmb0nNXU4htZjtg9GwAAAGiNSG1rmiYZet54n+ov7y0TrFfd3mId+eiPMeM6I8fNbB0+fFjTpk1TUlKSUlJS9OCDD+rYsWMXfM9NN90ky7JijocffriDIr50ffr0kSQFD5ZGz0Vmtox1evfsyDgAAADA6fr06SNZruhthDUfL9Phtb/R/77/WwWrS+VJz5Isd6eugR03szVt2jRVVFRo/fr1CgaDeuCBBzR9+nT9+c9/vuD7HnroIT311FPR1927d2/vUNuW5VLN5reUdtd8WZZLVtMikkaWajavlKzOu5kbAAAA8A8x4WizlT5pvlyDRih4sFQ1W95S3Z4iSZ17YXVHNVu7du3SunXrVFRUpFGjRkmSXnrpJd1+++1avHix+vbte973du/eXRkZGR0VapuqrKyUTFh1JUU6GFgof/+rlXOkUpLUcPjvqjt5XJJpHAcAAAB0AZWVlU0zW0YyRjefrNVqWarrl600/3wd/H8LVfc/xZ26BnZUs7V582alpKREGy1JGjdunFwul7Zu3apJkyad971/+tOftGzZMmVkZOiOO+7QE088ccHZrfr6etXX10df19TUSGpcU7+jlZeXS5KSv3+vjn7xvn6951NdLqlW0tGGk0r+/mTVfLJC5eXltsQHAAAAtLXy8nLJhFXjcqvBhPTE2hc1Yu82/fzWf5ckXT7yDtWVfGpLDRz5/y66ZbFxkF/96lfmiiuuOOd8WlqaeeWVV877vtdee82sW7fO7Nixwyxbtsz069fPTJo06YL/14IFC4wa5yU5ODg4ODg4ODg4ODjOOcrLyy/YU3SKma158+bp17/+9QXH7Nq16x/+/dOnT4/+fM0118jr9Wrs2LEqKSlRVlZWs+95/PHHNWfOnOjrcDisw4cPq3fv3rKadrG2S21trQYMGKDy8vIL7lgNRJAzaC1yBq1FzqC1yBm0VmfKGWOMjh49esHHmKROchvh3Llz9eMf//iCY4YMGaKMjAxVVVXFnD916pQOHz7cquexcnJyJEl79uw5b7OVkJCghISEmHMpKSkt/j86QlJSku2JBmchZ9Ba5Axai5xBa5EzaK3OkjPJyckXHdMpmq20tDSlpaVddFxubq6OHDmi4uJijRw5UpK0YcMGhcPhaAPVEtu3b5ckeb3efyheAAAAALgYR+2zdeWVV+rWW2/VQw89pE8//VSbNm3SzJkzde+990an8Pbv36/s7Gx9+umnkqSSkhI9/fTTKi4u1r59+/Tee+/pRz/6kX7wgx9o+PDhdn4cAAAAAF2Yo5otqXFVwezsbI0dO1a33367brzxRv3ud7+LXg8Gg9q9e7dOnDghSfJ4PHr//fc1fvx4ZWdna+7cubrrrru0atUquz7CJUtISNCCBQvOuc0ROB9yBq1FzqC1yBm0FjmD1nJizljGXGy9QgAAAABAazluZgsAAAAAnIBmCwAAAADaAc0WAAAAALQDmi0AAAAAaAc0Ww708ssva9CgQerWrZtycnKiy9zjn8tHH32kO+64Q3379pVlWXrnnXdirhtj9OSTT8rr9SoxMVHjxo3TN998EzPm8OHDmjZtmpKSkpSSkqIHH3xQx44d68BPgY70zDPPaPTo0br88svVp08f3Xnnndq9e3fMmJMnT2rGjBnq3bu3evToobvuuksHDhyIGVNWVqYJEyaoe/fu6tOnjx577DGdOnWqIz8KOsirr76q4cOHRzcQzc3N1dq1a6PXyRdcyKJFi2RZlmbNmhU9R87gbL/4xS9kWVbMkZ2dHb3u9Jyh2XKYN998U3PmzNGCBQv0+eefa8SIEbrllltUVVVld2joYMePH9eIESP08ssvN3v92Wef1Ysvvqjf/va32rp1qy677DLdcsstOnnyZHTMtGnT9OWXX2r9+vVavXq1PvroI02fPr2jPgI62MaNGzVjxgxt2bJF69evVzAY1Pjx43X8+PHomNmzZ2vVqlVauXKlNm7cqG+//VZ+vz96PRQKacKECWpoaNAnn3yiN954Q6+//rqefPJJOz4S2ln//v21aNEiFRcX67PPPtPNN9+siRMn6ssvv5REvuD8ioqK9Nprr52zpyk5g+Z897vfVUVFRfT4+OOPo9ccnzMGjnLdddeZGTNmRF+HQiHTt29f88wzz9gYFewmybz99tvR1+Fw2GRkZJjnnnsueu7IkSMmISHBLF++3BhjzFdffWUkmaKiouiYtWvXGsuyzP79+zssdtinqqrKSDIbN240xjTmSHx8vFm5cmV0zK5du4wks3nzZmOMMWvWrDEul8tUVlZGx7z66qsmKSnJ1NfXd+wHgC169uxpfv/735MvOK+jR4+aoUOHmvXr15sf/vCH5tFHHzXG8DcGzVuwYIEZMWJEs9e6Qs4ws+UgDQ0NKi4u1rhx46LnXC6Xxo0bp82bN9sYGTqbvXv3qrKyMiZXkpOTlZOTE82VzZs3KyUlRaNGjYqOGTdunFwul7Zu3drhMaPj1dTUSJJ69eolSSouLlYwGIzJm+zsbA0cODAmb6655hqlp6dHx9xyyy2qra2NznagawqFQlqxYoWOHz+u3Nxc8gXnNWPGDE2YMCEmNyT+xuD8vvnmG/Xt21dDhgzRtGnTVFZWJqlr5Eyc3QGg5aqrqxUKhWKSSZLS09P19ddf2xQVOqPKykpJajZXItcqKyvVp0+fmOtxcXHq1atXdAy6rnA4rFmzZumGG27Q1VdfLakxJzwej1JSUmLGnp03zeVV5Bq6np07dyo3N1cnT55Ujx499Pbbb+uqq67S9u3byRecY8WKFfr8889VVFR0zjX+xqA5OTk5ev311zVs2DBVVFTol7/8pXw+n7744osukTM0WwDwT2jGjBn64osvYu6LB5ozbNgwbd++XTU1NcrPz9f999+vjRs32h0WOqHy8nI9+uijWr9+vbp162Z3OHCI2267Lfrz8OHDlZOTo8zMTL311ltKTEy0MbK2wW2EDpKamiq3233OCiwHDhxQRkaGTVGhM4rkw4VyJSMj45yFVU6dOqXDhw+TT13czJkztXr1an344Yfq379/9HxGRoYaGhp05MiRmPFn501zeRW5hq7H4/HoO9/5jkaOHKlnnnlGI0aM0G9+8xvyBecoLi5WVVWVvve97ykuLk5xcXHauHGjXnzxRcXFxSk9PZ2cwUWlpKToiiuu0J49e7rE3xmaLQfxeDwaOXKkPvjgg+i5cDisDz74QLm5uTZGhs5m8ODBysjIiMmV2tpabd26NZorubm5OnLkiIqLi6NjNmzYoHA4rJycnA6PGe3PGKOZM2fq7bff1oYNGzR48OCY6yNHjlR8fHxM3uzevVtlZWUxebNz586YRn39+vVKSkrSVVdd1TEfBLYKh8Oqr68nX3COsWPHaufOndq+fXv0GDVqlKZNmxb9mZzBxRw7dkwlJSXyer1d4++M3St0oHVWrFhhEhISzOuvv26++uorM336dJOSkhKzAgv+ORw9etRs27bNbNu2zUgyS5YsMdu2bTOlpaXGGGMWLVpkUlJSzLvvvmt27NhhJk6caAYPHmzq6uqiv+PWW2811157rdm6dav5+OOPzdChQ82UKVPs+khoZz/96U9NcnKyKSgoMBUVFdHjxIkT0TEPP/ywGThwoNmwYYP57LPPTG5ursnNzY1eP3XqlLn66qvN+PHjzfbt2826detMWlqaefzxx+34SGhn8+bNMxs3bjR79+41O3bsMPPmzTOWZZm//vWvxhjyBRd35mqExpAzONfcuXNNQUGB2bt3r9m0aZMZN26cSU1NNVVVVcYY5+cMzZYDvfTSS2bgwIHG4/GY6667zmzZssXukGCDDz/80Eg657j//vuNMY3Lvz/xxBMmPT3dJCQkmLFjx5rdu3fH/I5Dhw6ZKVOmmB49epikpCTzwAMPmKNHj9rwadARmssXSeYPf/hDdExdXZ155JFHTM+ePU337t3NpEmTTEVFRczv2bdvn7nttttMYmKiSU1NNXPnzjXBYLCDPw06wk9+8hOTmZlpPB6PSUtLM2PHjo02WsaQL7i4s5stcgZnmzx5svF6vcbj8Zh+/fqZyZMnmz179kSvOz1nLGOMsWdODQAAAAC6Lp7ZAgAAAIB2QLMFAAAAAO2AZgsAAAAA2gHNFgAAAAC0A5otAAAAAGgHNFsAAAAA0A5otgAAAACgHdBsAQAAAEA7oNkCAAAAgHZAswUAAAAA7YBmCwAAAADaAc0WAAAXMXHiRFmW1ezx3nvv2R0eAKCTsowxxu4gAADozA4dOqRgMKhjx45p6NChWrNmja699lpJUmpqquLi4myOEADQGdFsAQDQQps3b9YNN9yg2tpa9ejRw+5wAACdHLcRAgDQQjt27NCgQYNotAAALUKzBQBAC+3YsUPDhw+3OwwAgEPQbAEA0EL79u3TsGHD7A4DAOAQNFsAALRQOBxWaWmp9u/fLx55BgBcDM0WAAAt9LOf/UybNm3SsGHDaLYAABfFaoQAAAAA0A6Y2QIAAACAdkCzBQAAAADtgGYLAAAAANoBzRYAAAAAtAOaLQAAAABoBzRbAAAAANAOaLYAAAAAoB3QbAEAAABAO6DZAgAAAIB2QLMFAAAAAO2AZgsAAAAA2sH/B3dQpFL+XtMoAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "t = np.array([x.real for x in G_tau.mesh.values()])\n", + "Gconformal = -np.pi**(1/4) / np.sqrt(2*params[\"beta\"]) * 1/np.sqrt(np.sin(np.pi * t / params[\"beta\"]))\n", + "oplot(G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G(\\tau)$\")\n", + "plt.plot(t, Gconformal, label = r\"$G_{conformal}(\\tau)$\", color = \"red\")\n", + "plt.ylim(-0.5,0)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "45fedad2", + "metadata": {}, + "source": [ + "### Exercise 2 \n", + "\n", + "Now that you see the power of DLR, try repeating Tutorial 1 to converge the IPT equations for a given $\\beta$ and $U$. See how much quicker your calculations are compared to Tutorial 1. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba3aecc3", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from triqs.gf import *\n", + "import numpy as np\n", + "from triqs.operators import *\n", + "\n", + "class IPTSolver:\n", + " def __init__(self, params):\n", + " self.params = params\n", + " # Matsubara frequency Green's functions\n", + " iw_mesh = MeshDLRImFreq(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G_iw = BlockGf(mesh=iw_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G0_iw = self.G_iw.copy() # self.G0 will be set by the user after initialization\n", + " self.Sigma_iw = self.G_iw.copy()\n", + "\n", + " # Imaginary time\n", + " tau_mesh = MeshDLRImTime(beta=params[\"beta\"], statistic='Fermion', w_max= params[\"w_max\"], eps =params[\"dlr_err\"], symmetrize = True)\n", + " self.G0_tau = BlockGf(mesh=tau_mesh, gf_struct = [('up',1), ('dn',1)] )\n", + " self.G_tau = self.G0_tau.copy()\n", + " self.Sigma_tau = self.G0_tau.copy()\n", + "\n", + " def solve(self):\n", + " error = 1.0\n", + " iter = 0\n", + "\n", + " \n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0287d987", + "metadata": {}, + "outputs": [], + "source": [ + "params = {\n", + " \"beta\": 50.0,\n", + " \"mu\": 0.0,\n", + " \"alpha\" : 0.5,\n", + " \"w_max\": 10.0,\n", + " \"dlr_err\": 1e-8, \n", + " \"U\" : 3.0, # In the Mott state, U > 4, you run into trouble, but this is also why the IPT tutorial just stops at small iteration number. \n", + " \"t\" : 1.0,\n", + " \"max_iter\": 1000, # small iteration number is ~ 25\n", + " \"threshold\": 1e-8,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc6182a2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Green Function G composed of 2 blocks: \n", + " Greens Function G_up with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " \n", + " Greens Function G_dn with mesh DLR imfreq mesh of size 36 with beta = 50, statistic = Fermion, w_max = 10, eps = 1e-08 and target_shape (1, 1): \n", + " " + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S = IPTSolver(params)\n", + "S.G_iw << SemiCircular(2*params[\"t\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d32a671", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration: 0\n", + "Iteration: 1\n", + "Iteration: 2\n", + "Iteration: 3\n", + "Iteration: 4\n", + "0.0016821665998838229 5\n", + "Iteration: 5\n", + "Iteration: 6\n", + "Iteration: 7\n", + "Iteration: 8\n", + "Iteration: 9\n", + "3.707673734909233e-05 10\n", + "Iteration: 10\n", + "Iteration: 11\n", + "Iteration: 12\n", + "Iteration: 13\n", + "Iteration: 14\n", + "8.68261338822299e-07 15\n", + "Iteration: 15\n", + "Iteration: 16\n", + "Iteration: 17\n", + "Iteration: 18\n", + "Iteration: 19\n", + "2.081733772436832e-08 20\n", + "Iteration: 20\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_109476/735204175.py:15: RuntimeWarning: divide by zero encountered in divide\n", + " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n" + ] + } + ], + "source": [ + "error = 1.0\n", + "iter = 0\n", + "while error > params[\"threshold\"]:\n", + " print(\"Iteration:\", iter)\n", + " for block, g in S.G0_iw:\n", + " g << inverse( iOmega_n - params[\"t\"]**2 * S.G_iw[block] )\n", + " S.G0_tau << make_gf_dlr_imtime(S.G0_iw)\n", + " S.Sigma_tau << (params[\"U\"]**2) * S.G0_tau * S.G0_tau * S.G0_tau\n", + " S.Sigma_iw << make_gf_dlr_imfreq(S.Sigma_tau)\n", + " G_old = S.G_iw.copy()\n", + " S.G_iw << inverse(inverse(S.G0_iw) - S.Sigma_iw)\n", + " S.G_iw << params[\"alpha\"]*S.G_iw+ (1-params[\"alpha\"])*G_old\n", + " G_tau_old = S.G_tau.copy()\n", + " S.G_tau << make_gf_dlr_imtime(S.G_iw)\n", + " error = np.mean(np.abs((S.G_tau[\"up\"].real.data[:,0,0] - G_tau_old[\"up\"].real.data[:,0,0]) / G_tau_old[\"up\"].real.data[:,0,0]))\n", + "\n", + " iter += 1\n", + " if iter % 5 == 0:\n", + " print(error, iter)\n", + " if iter > params[\"max_iter\"]:\n", + " print(\"Maximum number of iterations reached without convergence\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "50b5146d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.G_tau[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65fb461e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.G_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$G$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8703f85", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA10AAANBCAYAAAAbb9S/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjx0lEQVR4nO3df3wU9b3v8fdmEtjkyAYVQtbmFxTrL6K0qEjotOFKxf6UrtsrRVv15NjWqx4EPNVwPdp72grXAoFWW1sfpra3Xk3dbvGc9Fx7LC3tQNfqwdIaf6GUkICbBGpNUkNCMpn7BydbgiFkSSazu3k9H499mP3Od2Y/S2aF936/8x2f4ziOAAAAAACuyPK6AAAAAADIZIQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFyU7XUB6aS/v19vvvmmpkyZIp/P53U5AAAAADziOI46Ozt11llnKStr+LEsQlcS3nzzTRUXF3tdBgAAAIAU0dzcrKKiomH7ELqSMGXKFElH/2ADgYDH1QAAAADwSkdHh4qLixMZYTiEriQMTCkMBAKELgAAAAAjuuyIhTQAAAAAwEWELgAAAABwEaELAAAAAFzENV0AAADAOLFtW729vV6XgRHIycmRYRhjcixCFwAAAOAyx3HU0tKit99+2+tSkISpU6eqsLBw1PfoJXQBAAAALhsIXAUFBcrLyxv1P+LhLsdx1NXVpba2NklSMBgc1fEIXQAAAICLbNtOBK4zzzzT63IwQrm5uZKktrY2FRQUjGqqIQtpAAAAAC4auIYrLy/P40qQrIHf2WivwyN0AQAAAOOAKYXpZ6x+Z4QuAAAAAHARoQsAAAAAXMRCGgAAAEAasG1blmUpHo8rGAzKNM0xu48U3MVIFwAAAJDiotGoZs56rxYtWqTly5dr0aJFmjnrvYpGo66+7g033CCfzyefz6ecnBzNnDlTX/7yl9Xd3T1mxz32UVlZOex+Dz74oMrKyuT3+zV//nw999xzSb3uaPc/VYQuAAAAIIVFo1GFw2H9edIMFV63XsUrn1Thdev150kzFA6HXQ9eV155peLxuP70pz+ppqZG3/3ud3XvvfeO6pjLly9XTk6Ovv3tbysejycew72Xuro6rVq1Svfee69eeOEFXXTRRVqyZEniXlonM9r9R4PQBQAAAKQo27Z1+8pVyn3vJZoWuluT33OusiblavJ7ztW00N3Kfe8lun3Vatm27VoNkydPVmFhoYqLi7V06VItXrxYzzzzTGJ7f3+/1q5dq5kzZyo3N1cXXXSRIpHIsMe84oorVFtbq9WrV2v37t0qLCxUYWGhzjjjjBPus3HjRt1000268cYbdf755+uhhx5SXl6eamtrR/Q+Rrv/aBC6AAAAgBRlWZaam/YpcNl/l883+J/uPl+WApd9Rs37GmVZ1rjU09DQoN/+9reaNGlSom3t2rX64Q9/qIceekgvvfSSVq5cqeuuu06//vWvhz3Wddddp69+9av61Kc+pT/+8Y/D9j1y5Ih27typxYsXJ9qysrK0ePFixWKxk9Y92v1Hi4U0AAAAgBQVj8clSTnTS4fcnjOtdFA/N9TX1+u0005TX1+fenp6lJWVpQceeECS1NPTo/vuu0+/+MUvtGDBAknSrFmztH37dn33u9/Vhz/84WGPvXr1au3atUsf/ehH9cYbbyg3N3fIfocOHZJt25oxY8ag9hkzZujVV1896XsY7f6jRegCAAAAUlQwGJQk9R7cp8nvOfdd23sP7RvUzw2LFi3Sd77zHb3zzjuqqalRdna2rr76aknSG2+8oa6uLn3kIx8ZtM+RI0f0/ve//6THPnDggH7+85+rqqrqhIErExC6AAAAgBRlmqaKS0r152d/rGmhuwdNMXScfnU8+6SKS8tkmqZrNfzd3/2dZs+eLUmqra3VRRddpEceeURVVVX661//Kkn62c9+pve85z2D9ps8efKwx+3r69M111yj888/X1/72teG7Ttt2jQZhqHW1tZB7a2trSosLDzpexjt/qPFNV0AAABAijIMQ5tqNurwnud1KPo19Rx4Rf09Xeo58IoORb+mw3ue16aNG8btfl1ZWVlas2aN7r77bh0+fFjnn3++Jk+erKamJs2ePXvQo7i4eNhj3XnnnXrjjTf0+OOPn7T+SZMmad68edq6dWuirb+/X1u3bk1Ma3Rz/9FipAsAAABIYaFQSJFIRLevXKXmH/1Tor24tEybIhGFQqFxreczn/mM/umf/kkPPvig7rjjDt1xxx1auXKl+vv79cEPflDt7e3asWOHAoGArr/++iGPsWXLFtXU1Oixxx6Tz+dTS0uLpKMhc/r06UPus2rVKl1//fW6+OKLdemll2rTpk165513dOONN46o7tHuPxqELgAAACDFhUIhXXXVVbIsS/F4XMFgUKZpjtsI17Gys7N166236v7779fNN9+sr371q5o+fbrWrl2rP/3pT5o6dao+8IEPaM2aNSc8xpYtW+Q4jpYvXz6ovbS0VI2NjUPuc8011+jgwYO655571NLSorlz5+rpp59+1+IYJzLa/UfD5ziO4/qrZIiOjg7l5+ervb1dgUDA63IAAACQBrq7u7V3717NnDlTfr/f63KQhOF+d8lkA67pAgAAAAAXEboAAAAApLWmpiaddtppJ3w0NTV5Wh/XdAEAAABIa2eddZZ27do17HYvEboAAAAApLXs7OzEvcRSEaELADBh2badEiuBAQAyG6ELADChDAStp556SnWPP6Z468HEtrKSIm2o2Tzu97wBAGQ2FtIAAEwY0WhUs2eVadGiRdq0aZPmBd5SrCpPndVTFKvKU3luq8LhsKLRqNelAgAyCKELADAhRKNRhcNhzZncorOm+PTJ9xl66rN5uqwoW6dN8umyomxtucavT7wvW3esul22bXtdMgAgQxC6AAAZz7ZtrV65Qp84O1srF+TozU5Ha8zJyvL5BvXL8vlUvTBHe/c1y7Isj6oFAGQaQhcAIONZlqXGpv1aY+ao9a9H2+YUDL1gxkB7PB4fr/IAABmO0AUAyHgDAWpOgaHglKOjWw1tQ08fHGgPBoPjUxwAIOMRugAAGW8gQDW02TJLDJVN9ek+64j6HWdQv37H0dodvZpZWizTNL0oFQBOyLZtbdu2TY8//ri2bdvGtadphNAFAMh4pmmqrKRI923vlc8nbbjCr/rdfVr6xGHFmvvU2eMo1tynpXXdqt/dp/UbN3G/LgAp5djVV5cvX65FixZp9qwy11dbveGGG7R06dIxP6bP53vXo7Kyctj9HnzwQZWVlcnv92v+/Pl67rnnknrd0e4/GoQuAEDGMwxDG2o2Hw1add0KnubT//m0XzvftFVR26XAuk5V1HapobtQkUiE+3QBSCkDq6+W+1sz4jYXy5cvV05Ojr797W8rHo8nHsO9j7q6Oq1atUr33nuvXnjhBV100UVasmSJ2traRvSao91/tAhdAICMZ9u2zjjjDK1YsUL/+fZUVdR26bqfduvNvzoqnDFdt99+u371q1/p9T17CVwAUsqxq69uWeb39DYXlZWVuu2223T77bfr9NNP14wZM/Twww/rnXfe0Y033qgpU6Zo9uzZ+n//7/8Ne5wrrrhCtbW1Wr16tXbv3q3CwkIVFhbqjDPOOOE+Gzdu1E033aQbb7xR559/vh566CHl5eWptrZ2RLWPdv/RInQBADLa8TdEjrce1IyCaYmgtf9AXDU1NaqsrGRKIYCUc+zqq6lwm4sf/OAHmjZtmp577jnddtttuvnmm/WZz3xGFRUVeuGFF3TFFVfoc5/7nLq6uoY9znXXXaevfvWr+tSnPqU//vGPw/Y9cuSIdu7cqcWLFyfasrKytHjxYsVisZPWPNr9xwKhCwCQsU40JefS09u1efNmvfXWWwQtACnt2NVXhzLet7m46KKLdPfdd+vss89WdXW1/H6/pk2bpptuuklnn3227rnnHv35z38+aZCSpNWrV+uTn/ykPvrRj+rw4cMn7Hfo0CHZtq0ZM2YMap8xY4ZaWlpO+jqj3X8sELoAABkplabkAMCpOnb11aGM920uLrzwwsTPhmHozDPPVHl5eaJtINiM5FqpAwcO6Oc//7k+//nPKzc3d+yLTSGELgBARkq1KTkAcCqOXX01FW5zkZOTM+i5z+cb1Ob7r//f9vf3D3ucvr4+XXPNNTr//PP1ta99bdi+06ZNk2EYam1tHdTe2tqqwsLCk9Y82v3HAqELAJCRUm1KDgCciuNXX82U21zceeedeuONN/T444+ftPZJkyZp3rx52rp1a6Ktv79fW7du1YIFC076WqPdfyxkj8urAAAwzo6dknNZ0bv/ujt+So5t27IsS/F4XMFgUKZppt0/YgBkplAopEgkotUrV6iidn+ifWZpsSKRTWm36uqWLVtUU1Ojxx57TD6fL3FdlWEYmj59+pD7rFq1Stdff70uvvhiXXrppdq0aVNi1cSRGO3+o0XoAgBkpL9NyWnVlmuMQVMMj5+SE41GtXrlCjU2/e0fM2UlRdpQsznt/jEDIDOFQiFdddVVGfHl0JYtW+Q4jpYvXz6ovbS0VI2NjUPuc8011+jgwYO655571NLSorlz5+rpp59+1+IYJzLa/UfL5zjHTQ7FCXV0dCg/P1/t7e0KBAJelwMAOImB1Qs/8b5sVS/M0ZwCQw1tttbu6FX97j5FIhFJOtrn7GytMf/W577tf+tD8AIwGt3d3dq7d69mzpwpv9/vdTlIwnC/u2SyAaErCYQuAEg/Q41izSwt1vqNm3TVVVdp9qwylftbtWWZ/12jYUvrutXQXajX9+xNy2+TAaQGQlf6GqvQxfRCAEBGG25KzrZt29TYtF+PV+WdcIXDitqjKxxWVlZ68wYAAMNqamrS+eeff8LtL7/8skpKSsaxoncjdAEAMp5hGEOGJlY4BID0d9ZZZ2nXrl3DbvcaoQsAMGElu8IhACD1ZGdna/bs2V6XMSzu0wUAmLBS7aajAIDMROgCAExYmXrTUQBAaiF0AQAmtIGbjr54eIYqarsUWNepitouNXQXslw8gDHFouHpZ6x+Z1zTBQCY8DLppqMAUk9OTo4kqaurS7m5uR5Xg2R0dXVJ+tvv8FQRugAA0IlXOASA0TIMQ1OnTlVbW5skKS8vT77jblOB1OI4jrq6utTW1qapU6eO+ks4QhcAAADgssLCQklKBC+kh6lTpyZ+d6NB6AIAAABc5vP5FAwGVVBQoN7eXq/LwQjk5OSM2TRzQhcAAAAwTgzD4HrRCYjVCwEAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEUvGAwAygm3bsixL8XhcwWBQpmmyLDMAICUQugAAaS8ajWr1yhVqbNqfaCsrKdKGms0KhUIeVgYAANMLAQBpLhqNKhwOq9zfqlhVnjqrpyhWlafy3FaFw2FFo1GvSwQATHA+x3Ecr4tIFx0dHcrPz1d7e7sCgYDX5QDAhGfbtmbPKlO5v1VblvmV5fMltvU7jpbWdauhu1Cv79nLVEMAwJhKJhsw0gUASFuWZamxab/WmDmDApckZfl8ql6Yo737mmVZ1oiPadu2tm3bpscff1zbtm2TbdtjXTYAYILhmi4AQNqKx+OSpDkFQ49iDbQP9DsZrg0DALiBkS4AQNoKBoOSpIa2oUejBtoH+g2Ha8MAAG7hmq4kcE0XAKSWxDVdua3acs2pX9PFtWEAgGRxTRcAYEIwDEMbajarfnefltZ1K9bcp84eR7Hmo8/rd/dp/cZNJw1KblwbBgDAAEIXACCthUIhRSIRvXh4hipquxRY16mK2i41dBcqEomM6Fqssb42DACAY7GQBgAg7YVCIV111VWyLEvxeFzBYFCmaY54KuCx14ZdVvTuvxqTuTYMAIDjcU1XErimCwAy01hdGwYAmDi4pgsAgCSM1bVhAAAMhdAFAIDG5towAACGwvTCJDC9EAAyn23bp3xtGABg4kgmG7CQBgAAxzAMQ5WVlV6XAQDIIEwvBAAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcFG21wUAADBStm3LsizF43EFg0GZpinDMLwuCwCAYRG6AABpIRqNavXKFWps2p9oKysp0oaazQqFQh5WBgDA8JheCABIedFoVOFwWOX+VsWq8tRZPUWxqjyV57YqHA4rGo16XSIAACfkcxzH8bqIdNHR0aH8/Hy1t7crEAh4XQ4ATAi2bWv2rDKV+1u1ZZlfWT5fYlu/42hpXbcaugv1+p69TDUEAIybZLIBI10AgJRmWZYam/ZrjZkzKHBJUpbPp+qFOdq7r1mWZXlUIQAAwyN0AQBSWjwelyTNKRh6FGugfaAfAACphtAFAEhpwWBQktTQZg+5faB9oB8AAKmG0AUASGmmaaqspEj3be9V/3GXIfc7jtbu6NXM0mKZpulRhQAADI/QBQBIaYZhaEPNZtXv7tPSum7FmvvU2eMo1nz0ef3uPq3fuIlFNAAAKYvQBQBIeaFQSJFIRC8enqGK2i4F1nWqorZLDd2FikQi3KcLAJDSWDI+CSwZDwDesm1blmUpHo8rGAzKNE1GuAAAnkgmG2SPU00AAIyaYRiqrKwcl9ci4AEAxgqhCwCA40SjUa1euUKNTfsTbWUlRdpQs5mpjACApHFNFwAAx4hGowqHwyr3typWlafO6imKVeWpPLdV4XBY0WjU6xIBAGmGa7qSwDVdAJDZbNvW7FllKve3assyv7J8vsS2fsfR0rpuNXQX6vU9e5lqCAATXDLZgJEuAAD+i2VZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAgHSU1qHrwQcfVFlZmfx+v+bPn6/nnntuRPs98cQT8vl8Wrp0qbsFAgDSSjwelyTNKRh6FGugfaAfAAAjkbahq66uTqtWrdK9996rF154QRdddJGWLFmitra2YfdrbGzUHXfcIdM0x6lSAEC6CAaDkqSGNnvI7QPtA/0AABiJtA1dGzdu1E033aQbb7xR559/vh566CHl5eWptrb2hPvYtq1rr71W/+t//S/NmjVrHKsFAKQD0zRVVlKk+7b3qv+4S577HUdrd/RqZmkxX9wBAJKSlqHryJEj2rlzpxYvXpxoy8rK0uLFixWLxU6437/8y7+ooKBAVVVVI3qdnp4edXR0DHoAADKXYRjaULNZ9bv7tLSuW7HmPnX2OIo1H31ev7tP6zduYhENAEBS0jJ0HTp0SLZta8aMGYPaZ8yYoZaWliH32b59ux555BE9/PDDI36dtWvXKj8/P/EoLi4eVd0AgNQXCoUUiUT04uEZqqjtUmBdpypqu9TQXahIJMJ9ugAASZsQN0fu7OzU5z73OT388MOaNm3aiPerrq7WqlWrEs87OjoIXgAwAYRCIV111VWyLEvxeFzBYFCmaTLCBQA4JWkZuqZNmybDMNTa2jqovbW1VYWFhe/qv2fPHjU2NuqTn/xkoq2/v1+SlJ2drddee03vfe9737Xf5MmTNXny5DGuHgCQDgzDUGVlpddlAAAyQFpOL5w0aZLmzZunrVu3Jtr6+/u1detWLViw4F39zz33XL344ovatWtX4vGpT31KixYt0q5duxi9AgAAAOCatBzpkqRVq1bp+uuv18UXX6xLL71UmzZt0jvvvKMbb7xRkvT5z39e73nPe7R27Vr5/X7NmTNn0P5Tp06VpHe1AwAAAMBYStvQdc011+jgwYO655571NLSorlz5+rpp59OLK7R1NSkrKy0HMgDAAAAkEF8jnPcjUhwQh0dHcrPz1d7e7sCgYDX5QAAAADwSDLZgKEgAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXZXtdAAAAqcq2bVmWpXg8rmAwKNM0ZRiG12UBANIMoQsAgCFEo1GtXrlCjU37E21lJUXaULNZoVDIw8oAAOmG6YUAABwnGo0qHA6r3N+qWFWeOqunKFaVp/LcVoXDYUWjUa9LBACkEZ/jOI7XRaSLjo4O5efnq729XYFAwOtyAAAusG1bs2eVqdzfqi3L/Mry+RLb+h1HS+u61dBdqNf37GWqIQBMYMlkA0a6AAA4hmVZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAgHRD6AIA4BjxeFySNKdg6FGsgfaBfgAAnAyhCwCAYwSDQUlSQ5s95PaB9oF+AACcDKELAIBjmKapspIi3be9V/3HXfbc7zhau6NXM0uLZZqmRxUCANINoQsAgGMYhqENNZtVv7tPS+u6FWvuU2ePo1jz0ef1u/u0fuMmFtEAAIwY9+kCAHgmVW8+HAqFFIlEtHrlClXU/u0+XTNLixWJbOI+XQCApLBkfBJYMh4Axk463Hw4VUMhAMB7yWQDQlcSCF0AMDYGbj78ibOztcbM0ZwCQw1ttu7b3qv63X2KRCIpE7wAABgKocslhC4AGD1uPgwAyATcHBkAkLK4+TAAYKIhdAEAxhU3HwYATDSELgDAuOLmwwCAiYbQBQAYV9x8GAAw0RC6AADjipsPAwAmGkIXAGDcDdx8+MXDM1RR26XAuk5V1HapobuQ5eIBABmHJeOTwJLxADC2uPkwACBdJZMNssepJgAA3sUwDFVWVnpdBgAArmJ6IQAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOCibK8LAAAgldm2LcuyFI/HFQwGZZqmDMPwuiwAQBohdAEAcALRaFSrV65QY9P+RFtZSZE21GxWKBTysDIAQDpheiEAAEOIRqMKh8Mq97cqVpWnzuopilXlqTy3VeFwWNFo1OsSAQBpwuc4juN1Eemio6ND+fn5am9vVyAQ8LocAIBLbNvW7FllKve3assyv7J8vsS2fsfR0rpuNXQX6vU9e5lqCAATVDLZgJEuAACOY1mWGpv2a42ZMyhwSVKWz6fqhTnau69ZlmV5VCEAIJ0QugAAOE48HpckzSkYehRroH2gHwAAwyF0AQBwnGAwKElqaLOH3D7QPtAPAIDhELoAADiOaZoqKynSfdt71X/cpc/9jqO1O3o1s7RYpml6VCEAIJ0QugAAOI5hGNpQs1n1u/u0tK5bseY+dfY4ijUffV6/u0/rN25iEQ0AwIgQugAAGEIoFFIkEtGLh2eoorZLgXWdqqjtUkN3oSKRCPfpAgCMGEvGJ4El4wFg4rFtW5ZlKR6PKxgMyjRNRrgAAEllg+xxqgkAgLRkGIYqKyu9LgMAkMaYXggAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALsr2ugAAQHqxbVuWZSkejysYDMo0TRmG4XVZAACkLEIXAGDEotGoVq9cocam/Ym2spIibajZrFAo5GFlAACkLqYXAgBGJBqNKhwOq9zfqlhVnjqrpyhWlafy3FaFw2FFo1GvSwQAICX5HMdxvC4iXXR0dCg/P1/t7e0KBAJelwMA48a2bc2eVaZyf6u2LPMry+dLbOt3HC2t61ZDd6Fe37OXqYYAgAkhmWzASBcA4KQsy1Jj036tMXMGBS5JyvL5VL0wR3v3NcuyLI8qBAAgdRG6AAAnFY/HJUlzCoYexRpoH+gHAAD+htAFADipYDAoSWpos4fcPtA+0A8AAPwNoQsAcFKmaaqspEj3be9V/3GXAvc7jtbu6NXM0mKZpulRhQAApC5CFwDgpAzD0Iaazarf3aeldd2KNfeps8dRrPno8/rdfVq/cROLaAAAMARCFwBgREKhkCKRiF48PEMVtV0KrOtURW2XGroLFYlEuE8XAAAnwJLxSWDJeAA4uny8ZVmKx+MKBoMyTZMRLgDAhJNMNsgep5oAABnCMAxVVlZ6XQYAAGmD6YUAAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIu4OTIAACdh27Ysy1I8HlcwGJRpmjIMw+uyAABpgtAFAMAwotGoVq9cocam/Ym2spIibajZrFAo5GFlAIB0wfRCAABOIBqNKhwOq9zfqlhVnjqrpyhWlafy3FaFw2FFo1GvSwQApAGf4ziO10Wki46ODuXn56u9vV2BQMDrcgAALrJtW7Nnlanc36oty/zK8vkS2/odR0vrutXQXajX9+xlqiEATEDJZANGugAAGIJlWWps2q81Zs6gwCVJWT6fqhfmaO++ZlmW5VGFAIB0QegCAGAI8XhckjSnYOhRrIH2gX4AAJwIoQsAgCEEg0FJUkObPeT2gfaBfgAAnAihCwCAIZimqbKSIt23vVf9x13+3O84WrujVzNLi2WapkcVAgDSBaELAIAhGIahDTWbVb+7T0vruhVr7lNnj6NY89Hn9bv7tH7jJhbRAACcFKELAIATCIVCikQievHwDFXUdimwrlMVtV1q6C5UJBLhPl0AgBFhyfgksGQ8AExMtm3LsizF43EFg0GZpskIFwBMcMlkg+xxqgkAgLRlGIYqKyu9LgMAkKaYXggAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALgorUPXgw8+qLKyMvn9fs2fP1/PPffcCfs+/PDDMk1Tp59+uk4//XQtXrx42P4AAAAAMBbSNnTV1dVp1apVuvfee/XCCy/ooosu0pIlS9TW1jZk/23btumzn/2sfvWrXykWi6m4uFhXXHGFDhw4MM6VAwAAAJhIfI7jOF4XcSrmz5+vSy65RA888IAkqb+/X8XFxbrtttt01113nXR/27Z1+umn64EHHtDnP//5Ifv09PSop6cn8byjo0PFxcVqb29XIBAYmzcCAAAAIO10dHQoPz9/RNkgLUe6jhw5op07d2rx4sWJtqysLC1evFixWGxEx+jq6lJvb6/OOOOME/ZZu3at8vPzE4/i4uJR1w4AAABgYknL0HXo0CHZtq0ZM2YMap8xY4ZaWlpGdIw777xTZ5111qDgdrzq6mq1t7cnHs3NzaOqGwAAAMDEk+11AV5Yt26dnnjiCW3btk1+v/+E/SZPnqzJkyePY2UAAAAAMk1ahq5p06bJMAy1trYOam9tbVVhYeGw+65fv17r1q3TL37xC1144YVulgkArrJtW5ZlKR6PKxgMyjRNGYbhdVkAAOA4aTm9cNKkSZo3b562bt2aaOvv79fWrVu1YMGCE+53//3366tf/aqefvppXXzxxeNRKgC4IhqNavasMi1atEjLly/XokWLNHtWmaLRqNelAQCA46Rl6JKkVatW6eGHH9YPfvADvfLKK7r55pv1zjvv6MYbb5Qkff7zn1d1dXWi///+3/9b//zP/6za2lqVlZWppaVFLS0t+utf/+rVWwCAUxKNRhUOh1Xub1WsKk+d1VMUq8pTeW6rwuEwwQsAgBSTtkvGS9IDDzygb3zjG2ppadHcuXP1zW9+U/Pnz5ckVVZWqqysTI8++qgkqaysTPv27XvXMe6991595StfGdHrJbMsJAC4wbZtzZ5VpnJ/q7Ys8yvL50ts63ccLa3rVkN3oV7fs5ephgAAuCiZbJDWoWu8EboAeG3btm1atGiRYlV5uqzo3Zflxpr7VFHbpV/96leqrKwc/wIBAJggMv4+XQAwUcXjcUnSnIKhR7EG2gf6AQAA7xG6ACCNBINBSVJDmz3k9oH2gX4AAMB7hC4ASCOmaaqspEj3be9V/3Gzw/sdR2t39GpmabFM0/SoQgAAcDxCFwCkEcMwtKFms+p392lpXbdizX3q7HEUaz76vH53n9Zv3MQiGgAApBBCFwCkmVAopEgkohcPz1BFbZcC6zpVUdulhu5CRSIRhUIhr0sEAADHYPXCJLB6IYBUYtu2LMtSPB5XMBiUaZqMcAEAME6SyQbvXm8YAJAWDMNgWXgAANIA0wsBAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXZXtdAAAA6cC2bVmWpXg8rmAwKNM0ZRiG12UBANIAoQsAgJOIRqNavXKFGpv2J9rKSoq0oWazQqGQh5UBANIB0wsBABhGNBpVOBxWub9Vsao8dVZPUawqT+W5rQqHw4pGo16XCABIcT7HcRyvi0gXHR0dys/PV3t7uwKBgNflAABcZtu2Zs8qU7m/VVuW+ZXl8yW29TuOltZ1q6G7UK/v2ctUQwCYYJLJBox0AQBwApZlqbFpv9aYOYMClyRl+XyqXpijvfuaZVmWRxUCANIBoQsAgBOIx+OSpDkFQ49iDbQP9AMAYCiELgAATiAYDEqSGtrsIbcPtA/0AwBgKIQuAABOwDRNlZUU6b7tveo/7hLofsfR2h29mllaLNM0PaoQAJAOCF0AAJyAYRjaULNZ9bv7tLSuW7HmPnX2OIo1H31ev7tP6zduYhENAMCwCF0AAAwjFAopEonoxcMzVFHbpcC6TlXUdqmhu1CRSIT7dAEATool45PAkvEAMHHZti3LshSPxxUMBmWaJiNcADCBJZMNssepJgAA0pphGKqsrPS6DABAGmJ6IQAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALgo2+sCAMAttm3LsizF43EFg0GZpinDMLwuCwAATDCELgAZKRqNavXKFWps2p9oKysp0oaazQqFQh5WBgAAJhqmFwLIONFoVOFwWOX+VsWq8tRZPUWxqjyV57YqHA4rGo16XSIAAJhAfI7jOF4XkS46OjqUn5+v9vZ2BQIBr8sBMATbtjV7VpnK/a3assyvLJ8vsa3fcbS0rlsN3YV6fc9ephoCAIBTlkw2YKQLQEaxLEuNTfu1xswZFLgkKcvnU/XCHO3d1yzLsjyqEAAATDSELgAZJR6PS5LmFAw9ijXQPtAPAADAbYQuABklGAxKkhra7CG3D7QP9AMAAHAboQtARjFNU2UlRbpve6/6j7tktd9xtHZHr2aWFss0TY8qBAAAEw2hC0BGMQxDG2o2q353n5bWdSvW3KfOHkex5qPP63f3af3GTSyiAQAAxg2hC0DGCYVCikQievHwDFXUdimwrlMVtV1q6C5UJBLhPl0AAGBcsWR8ElgyHkgvtm3LsizF43EFg0GZpskIFwAAGBPJZIPscaoJAMadYRiqrKz0ugwAADDBMb0QAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARdleFwAAQLqwbVuWZSkejysYDMo0TRmG4XVZAIAUR+gCAGAEotGoVq9cocam/Ym2spIibajZrFAo5GFlAIBUx/TCNGTbtrZt26bHH39c27Ztk23bXpcEABktGo0qHA6r3N+qWFWeOqunKFaVp/LcVoXDYUWjUa9LBACkMJ/jOI7XRaSLjo4O5efnq729XYFAwJMa+KYVAMaXbduaPatM5f5WbVnmV5bPl9jW7zhaWtethu5Cvb5nL1MNAWACSSYbMNKVRvimFQDGn2VZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAgFRH6EoTtm1r9coV+sTZ2dqyzK/LirJ12iSfLivK1pZr/PrE+7J1x6rbmWoIAGMsHo9LkuYUDD2KNdA+0A8AgOMRutIE37QCgDeCwaAkqaFt6C+1BtoH+gEAcDxCV5rgm1YA8IZpmiorKdJ923vVf9xl0P2Oo7U7ejWztFimaXpUIQAg1RG60gTftAKANwzD0Iaazarf3aeldd2KNfeps8dRrPno8/rdfVq/cROLaAAATojVC5Pg5eqFidWzclu15RpWzwKA8TbU6rEzS4u1fuMmVo8FgAkomWxA6EqC10vGD6xe+In3Zat6YY7mFBhqaLO1dkev6nf3KRKJ8Bc/ALjItm1ZlqV4PK5gMCjTNPmiCwAmKEKXS7wOXRLftAIAAACpgNDlklQIXRLftAIAAABeSyYbZI9TTRhDhmGosrLS6zIAAAAAjACrFwIAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALjrlmyP39vaqpaVFXV1dmj59us4444yxrAsAAAAAMkJSI12dnZ36zne+ow9/+MMKBAIqKyvTeeedp+nTp6u0tFQ33XSTnn/+ebdqBQAAAIC0M+LQtXHjRpWVlen73/++Fi9erC1btmjXrl3avXu3YrGY7r33XvX19emKK67QlVdeqddff93NugEAAAAgLfgcx3FG0vGzn/2s7r77bl1wwQXD9uvp6dH3v/99TZo0SX//938/JkWmio6ODuXn56u9vV2BQMDrcgAAAAB4JJlsMOLQBUIXAAAAgKOSyQasXggAAAAALjrl1QuP9fLLL+upp57S1KlTdcEFF6i8vFynn376WBwaAAAAANLamIx0fepTn1JeXp7eeecdPfLII7r88sv13ve+dywODQAAAABpbUxGugoLC7VixYpBbbZtj8WhAQAAACCtjclI1+WXX67vf//7g9oMwxiLQwMAAABAWhuT1Qs//vGPq6GhQVlZWbrkkkt00UUX6cILL9QnP/nJsagxZbB6IQAAAAApuWwwJtMLf/azn0mSOjs71dDQoIaGBm3dujXjQhcAAAAAJOuUQtf999+vXbt2qaWlRbm5ubrgggv06U9/WgsWLEg8AAAAAACneE3Xt771LR06dEgFBQWSpMcff1wLFy7UlVdeqfb29jEtEAAAAADS2SmNdDU3N7+r7dlnn9XNN9+sW265RT/60Y9GXRhOzLZtWZaleDyuYDAo0zRZuAQYQqZ/Vrx6f2P5uskea7j+I9028IVhW1vbkD+3tLTo4MGDOvPMM3Xw4EEdPHhQTU1NOtkl0FlZWSouLta0adNUUFCgP//5z5o+fbre8573qKKiQr/97W+Hff1jaz7V9zlWf85uHyddXnc8TYT3CIxWWn9OnDH0+9//3pkyZcpYHnJYDzzwgFNaWupMnjzZufTSS53f/e53w/b/8Y9/7JxzzjnO5MmTnTlz5jg/+9nPknq99vZ2R5LT3t4+mrJH5Sc/+YlTXFLqSEo8iktKnZ/85Cee1QSkokz/rHj1/sbydZM91nD9k9rmyxr+50Sbb+SP4/c99riSY+RMOvnr/1fN//RP/3RK79Pt31kmnHOpaiK8R2C0UvFzkkw2GHXoqq2tdZ588knn3/7t35yqqiqnrKxstIcckSeeeMKZNGmSU1tb67z00kvOTTfd5EydOtVpbW0dsv+OHTscwzCc+++/33n55Zedu+++28nJyXFefPHFEb+m16HrJz/5iePz+Zy82Zc6hdetd4pXPukUXrfeyZt9qePz+fifM/BfMv2z4tX7G8vXTfZYw/U/Gl5Ovm3qh653JJ+T+96hf540Y/Yx/1VSj8H7Hj1u4XXrnTM/ccewrznQb6DmSYVHXzvZ93miP/+x+p1lwjmXqibCewRGK1U/J8lkg1EvGf+lL31JTz75pN5++219/OMf19e//nWVl5eP5pAjMn/+fF1yySV64IEHJEn9/f0qLi7Wbbfdprvuuutd/a+55hq98847qq+vT7Rddtllmjt3rh566KERvaaXS8bbtq2Zs96rP0+aoWmhu+Xz/e1yPMfp16Ho13Rmb5v27nkjfYZZARdk+mfFq/c3lq+b7LGG699v92r/5s/KX1Ku6Vf/8wm3Tfv0Gr358Jc0aXqppi2tftfPOdNK1Hton3KmlerIwUb1d3WM6M/F5/NpcnG5ev98dN/eQ/s0aXqZpofulhxHB773hRO+5qTppZp+zPtx+m0d+N5NmjStTNOvHvn7PNGf/1j9zjLhnEtVE+E9AqOVyp+TZLLBqG+O/NBDD+nQoUOqr6/Xn/70J73wwgujPeRJHTlyRDt37tTixYsTbVlZWVq8eLFisdiQ+8RisUH9JWnJkiUn7C9JPT096ujoGPTwimVZam7ap8Bl/33QySZJPl+WApd9Rs37GmVZlkcVAqkh0z8rXr2/sXzdZI81XP8jB16R09ut/AXXDLvtyIFXZLe3Kv+y/z7kz7kz58lub1PuzHnq7zgo9fWM6OH0dit31t/2tdvblP9fdfbsf2nY18w/7v0c7d+m/AXJvc8T/fmP1e8sE865VDUR3iMwWpnyOTml0PWhD31Iv/vd7xLPfT6fPvrRj+pHP/qRqqurx6y4Ezl06JBs29aMGTMGtc+YMUMtLS1D7tPS0pJUf0lau3at8vPzE4/i4uLRF3+K4vG4JClneumQ23OmlQ7qB0xUmf5Z8er9jeXrJnus4frbf/3LiLad7GdfzuRB/03G8fsO1DKS1z+V9zKUof78x+p3lgnnXKqaCO8RGK1M+ZycUui64IILtHDhQlVUVGjDhg36j//4D/32t7/VI488osOHD491jZ6prq5We3t74jHUqo3jJRgMSpJ6D+4bcnvvoX2D+gETVaZ/Vrx6f2P5uskea7j+xmmnj2jbyX52ensG/TcZx+87UMtIXv9U3stQhvrzH6vfWSacc6lqIrxHYLQy5XNySqHrO9/5jv7whz/ofe97n/7lX/5FV155pT74wQ/q29/+9pDXU421adOmyTAMtba2DmpvbW1VYWHhkPsUFhYm1V+SJk+erEAgMOjhFdM0VVxSqo5nfyzH6R+0zXH61fHskyouLZNpmh5VCKSGTP+sePX+xvJ1kz3WcP0nvec8+XL8ao/VDbtt0nvOk5E/Q+3P/njInw/v3Skjv0CH9+5UVmC6lD15RA9fjl+H//S3fY38ArX/V52Tiy4Y9jXbj3s/R/sXnPS9jPTPf6x+Z5lwzqWqifAegdHKlM/JKV/TdcEFF+jRRx/VW2+9pVdffVXPPvus3nzzTd15551jWd+QJk2apHnz5mnr1q2Jtv7+fm3dulULFiwYcp8FCxYM6i9JzzzzzAn7pxrDMLSpZqMO73leh6JfU8+BV9Tf06WeA6/oUPRrOrzneW3auIELbTHhZfpnxav3N5avm+yxhuv/5y1r5fR26/Cf/nPYbX/eslZTLlqiw288r0M/fffP3Xv+U4Y/oO49/6ns3Pykrunq/tPziX0Nf0CH33heB3/yNR2J79ZU87r/ep37hnz9gz/5W81H4rtl5AaSfp8n+vMfq99ZJpxzqWoivEdgtDLmczLSJRGvu+46p6ury3Ecx9m3b9+prqw4Zp544gln8uTJzqOPPuq8/PLLzhe+8AVn6tSpTktLi+M4jvO5z33OueuuuxL9d+zY4WRnZzvr1693XnnlFefee+9NuyXjHecE9ygoLWNJWeA4mf5Z8er9jeXrJnus4fontS2V79NVWjb0fbpG8D7d/p1lwjmXqibCewRGKxU/J64sGf+lL31J69at09SpU5WVlaXTTz9dF154oebOnauLLrpIc+fO1QUXXKCcnJyRHG5MPPDAA/rGN76hlpYWzZ07V9/85jc1f/58SVJlZaXKysr06KOPJvo/+eSTuvvuu9XY2Kizzz5b999/vz72sY+N+PW8XDL+WGl9N25gHGX6Z8Wr9zeWr5vssYbrP9JtBQUFkqS2trYhf25padHBgwd15pln6uDBgzp48KCampp0sr8us7KyVFxcrGnTpqmgoEB//vOfNX36dL3nPe9RRUWFfvvb3w77+sfWfKrvc6z+nN0+Trq87niaCO8RGK1U+5wkkw1O6T5d+/bt0x/+8Aft2rUr8d/GxkZlZ2fr3HPP1R/+8IdTLj6VpUroAgAAAOCtZLJB9qm8QGlpqUpLS/WpT30q0dbZ2aldu3bpj3/846kcEgAAAAAy0imNdE1UjHQBAAAAkJLLBiNevbCpqSmpIg4cOJBUfwAAAADIRCMOXZdccom++MUv6vnnnz9hn/b2dj388MOaM2eOfvKTn4xJgQAAAACQzkZ8TdfLL7+sr3/96/rIRz4iv9+vefPm6ayzzpLf79df/vIXvfzyy3rppZf0gQ98IOlVAQEAAAAgUyV9Tdfhw4f1s5/9TNu3b9e+fft0+PBhTZs2Te9///u1ZMkSzZkzx61aPcc1XQAAAACkcVgyfqIidAEAAACQXFpIQ5L+23/7b3r77bdPuP3QoUOaNWtWMocEAAAAgIyWVOjatm2bjhw5knje09MzaLtt29q3b9/YVAYAAAAAGSCp0HWshoYGzZ49W3fffbeYoQgAAAAAQzul0GVZlj70oQ9p0aJFevjhh7V48WK1tbWNdW0AAAAAkPaSDl0//elPdeWVV+ruu+/WD3/4Q73wwgvq6enR3LlztW3bNhdKBAAAAID0ldTqhVlZWZo0aZIeeeQRXXvttYl227b15S9/WZs2bUo8z0SsXggAAABASi4bjPjmyJJ0/fXXa/ny5frIRz4yqN0wDG3YsEGmaeqpp55KvmIAAAAAyFDcpysJjHQBAAAAkFy8TxcAAAAAIDmELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABdle10AAAAAAJyMbduyLEvxeFzBYFCmacowDK/LGhFCFwAAAICUFo1GtXrlCjU27U+0lZUUaUPNZoVCIQ8rGxmmFwIAkATbtrVt2zY9/vjj2rZtm2zb9rokAMho0WhU4XBY5f5Wxary1Fk9RbGqPJXntiocDisajXpd4kn5HMdxvC4iXXR0dCg/P1/t7e0KBAJelwMAGGfp/k0rAKQb27Y1e1aZyv2t2rLMryyfL7Gt33G0tK5bDd2Fen3P3nGfaphMNmCkCwCAEciEb1oBIN1YlqXGpv1aY+YMClySlOXzqXphjvbua5ZlWR5VODKELgAATsK2ba1euUKfODtbW5b5dVlRtk6b5NNlRdnaco1fn3hftu5YdTtTDQFgjMXjcUnSnIKhR7EG2gf6pSpCFwAAJ5Ep37QCQLoJBoOSpIa2ob/UGmgf6JeqCF0AAJxEpnzTCgDpxjRNlZUU6b7tveo/bimKfsfR2h29mllaLNM0PapwZAhdAACcRKZ80woA6cYwDG2o2az63X1aWtetWHOfOnscxZqPPq/f3af1Gzel/P26WL0wCaxeCAATU2L1rNxWbbkmtVbPAoCJYKjVY2eWFmv9xk2erR6bTDYgdCWB0AUAE9fA6oWfeF+2qhfmaE6BoYY2W2t39Kp+d58ikQjLxgOAi2zblmVZisfjCgaDMk3T0y+6CF0uIXQBwMSWit+0AgC8QehyCaELAJBq37QCALyRTDbIHqeaAADICIZhqLKy0usyAABphNULAQAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXJTtdQEAAAATnW3bsixL8XhcwWBQpmnKMAyvywIwRghdAAAAHopGo1q9coUam/Yn2spKirShZrNCoZCHlQEYK0wvBAAA8Eg0GlU4HFa5v1Wxqjx1Vk9RrCpP5bmtCofDikajXpcIYAz4HMdxvC4iXXR0dCg/P1/t7e0KBAJelwMAANKYbduaPatM5f5WbVnmV5bPl9jW7zhaWtethu5Cvb5nL1MNgRSUTDZgpAsAAMADlmWpsWm/1pg5gwKXJGX5fKpemKO9+5plWZZHFQIYK4QuAAAAD8TjcUnSnIKhR7EG2gf6AUhfhC4AAAAPBINBSVJDmz3k9oH2gX4A0hehCwAAwAOmaaqspEj3be9V/3GX2Pc7jtbu6NXM0mKZpulRhQDGCqELAADAA4ZhaEPNZtXv7tPSum7FmvvU2eMo1nz0ef3uPq3fuIlFNIAMQOgCAADwSCgUUiQS0YuHZ6iitkuBdZ2qqO1SQ3ehIpEI9+kCMgRLxieBJeMBAIAbbNuWZVmKx+MKBoMyTZMRLiDFJZMNssepJgAAAJyAYRiqrKz0ugwALmF6IQAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIm6ODABAkmzblmVZisfjCgaDMk1ThmF4XRYAIEURugAASEI0GtXqlSvU2LQ/0VZWUqQNNZsVCoU8rAwAkKqYXggAwAhFo1GFw2GV+1sVq8pTZ/UUxaryVJ7bqnA4rGg06nWJAIAU5HMcx/G6iHTR0dGh/Px8tbe3KxAIeF0OAGAc2bat2bPKVO5v1ZZlfmX5fIlt/Y6jpXXdaugu1Ot79jLVEAAmgGSyASNdAACMgGVZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAgFRF6AIAYATi8bgkaU7B0KNYA+0D/QAAGEDoAgBgBILBoCSpoc0ecvtA+0A/AAAGELoAABgB0zRVVlKk+7b3qv+4y6H7HUdrd/RqZmmxTNP0qEIAQKoidAEAMAKGYWhDzWbV7+7T0rpuxZr71NnjKNZ89Hn97j6t37iJRTQAAO9C6AIAYIRCoZAikYhePDxDFbVdCqzrVEVtlxq6CxWJRLhPFwBgSCwZnwSWjAcASEeXj7csS/F4XMFgUKZpMsIFABNMMtkge5xqAgAgYxiGocrKSq/LAACkCaYXAgAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLsr0uAAAAYDi2bcuyLMXjcQWDQZmmKcMwvC4LAEaM0AUAAFJWNBrV6pUr1Ni0P9FWVlKkDTWbFQqFPKwMAEaO6YUAACAlRaNRhcNhlftbFavKU2f1FMWq8lSe26pwOKxoNOp1iQAwIj7HcRyvi0gXHR0dys/PV3t7uwKBgNflAACQsWzb1uxZZSr3t2rLMr+yfL7Etn7H0dK6bjV0F+r1PXuZagjAE8lkA0a6AABAyrEsS41N+7XGzBkUuCQpy+dT9cIc7d3XLMuyPKoQAEaO0AUAAFJOPB6XJM0pGHoUa6B9oB8ApDJCFwAASDnBYFCS1NBmD7l9oH2gHwCkMkIXAABIOaZpqqykSPdt71X/cZef9zuO1u7o1czSYpmm6VGFADByaRm63nrrLV177bUKBAKaOnWqqqqq9Ne//nXY/rfddpvOOecc5ebmqqSkRP/4j/+o9vb2cawaAACMlGEY2lCzWfW7+7S0rlux5j519jiKNR99Xr+7T+s3bmIRDQBpIS1D17XXXquXXnpJzzzzjOrr6/Wb3/xGX/jCF07Y/80339Sbb76p9evXq6GhQY8++qiefvppVVVVjWPVAAAgGaFQSJFIRC8enqGK2i4F1nWqorZLDd2FikQi3KcLQNpIuyXjX3nlFZ1//vl6/vnndfHFF0uSnn76aX3sYx/T/v37ddZZZ43oOE8++aSuu+46vfPOO8rOHtk9olkyHgCA8WfbtizLUjweVzAYlGmajHAB8Fwy2WBkaSOFxGIxTZ06NRG4JGnx4sXKysrS7373O336058e0XEG/nCGC1w9PT3q6elJPO/o6Dj1wgEAwCkxDEOVlZVelwEApyztphe2tLSooKBgUFt2drbOOOMMtbS0jOgYhw4d0le/+tVhpyRK0tq1a5Wfn594FBcXn3LdAAAAACamlAldd911l3w+37CPV199ddSv09HRoY9//OM6//zz9ZWvfGXYvtXV1Wpvb088mpubR/36AAAAACaWlJleuHr1at1www3D9pk1a5YKCwvV1tY2qL2vr09vvfWWCgsLh92/s7NTV155paZMmaKf/vSnysnJGbb/5MmTNXny5BHVDwAAAABDSZnQNX36dE2fPv2k/RYsWKC3335bO3fu1Lx58yRJv/zlL9Xf36/58+efcL+Ojg4tWbJEkydP1r/+67/K7/ePWe0AAAAAcCIpM71wpM477zxdeeWVuummm/Tcc89px44duvXWW7Vs2bLEyoUHDhzQueeeq+eee07S0cB1xRVX6J133tEjjzyijo4OtbS0qKWlRbY99J3uAQAAAGAspMxIVzIee+wx3Xrrrbr88suVlZWlq6++Wt/85jcT23t7e/Xaa6+pq6tLkvTCCy/od7/7nSRp9uzZg461d+9elZWVjVvtAAAAACaWtLtPl5e4TxcAAAAAKblskHbTCwEAAAAgnRC6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwUbbXBQAAkI5s25ZlWYrH4woGgzJNU4ZheF0WACAFEboAAEhSNBrV6pUr1Ni0P9FWVlKkDTWbFQqFPKwMAJCKmF4IAEASotGowuGwyv2tilXlqbN6imJVeSrPbVU4HFY0GvW6RABAivE5juN4XUS66OjoUH5+vtrb2xUIBLwuBwAwzmzb1uxZZSr3t2rLMr+yfL7Etn7H0dK6bjV0F+r1PXuZaggAGS6ZbMBIFwAAI2RZlhqb9muNmTMocElSls+n6oU52ruvWZZleVQhACAVEboAABiheDwuSZpTMPQo1kD7QD8AACRCFwAAIxYMBiVJDW32kNsH2gf6AQAgEboAABgx0zRVVlKk+7b3qv+4S6L7HUdrd/RqZmmxTNP0qEIAQCoidAEAMEKGYWhDzWbV7+7T0rpuxZr71NnjKNZ89Hn97j6t37iJRTQAAIMQugAASEIoFFIkEtGLh2eoorZLgXWdqqjtUkN3oSKRCPfpAgC8C0vGJ4El4wEAA2zblmVZisfjCgaDMk2TES4AmECSyQbZ41QTAAAZxTAMVVZWel0GACANML0QAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARdynCwAAjAg3hAaAU0PoAgAAJxWNRrV65Qo1Nu1PtJWVFGlDzWaFQiEPKwOA1Mf0QgAAMKxoNKpwOKxyf6tiVXnqrJ6iWFWeynNbFQ6HFY1GvS4RAFKaz3Ecx+si0kVHR4fy8/PV3t6uQCDgdTkAALjOtm3NnlWmcn+rtizzK8vnS2zrdxwtretWQ3ehXt+zl6mGACaUZLIBI10AAOCELMtSY9N+rTFzBgUuScry+VS9MEd79zXLsiyPKgSA1EfoAgAAJxSPxyVJcwqGHsUaaB/oBwB4N0IXAAA4oWAwKElqaLOH3D7QPtAPAPBuhC4AAHBCpmmqrKRI923vVf9xl4H3O47W7ujVzNJimabpUYUAkPoIXQAA4IQMw9CGms2q392npXXdijX3qbPHUaz56PP63X1av3ETi2gAwDAIXQAAYFihUEiRSEQvHp6hitouBdZ1qqK2Sw3dhYpEItynCwBOgiXjk8CS8QCAicy2bVmWpXg8rmAwKNM0GeECMGElkw2yx6kmAACQ5gzDUGVlpddlAEDaYXohAAAAALiI0AUAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALsr2ugAAANKVbduyLEvxeFzBYFCmacowDK/LAgCkGEIXAACnIBqNavXKFWps2p9oKysp0oaazQqFQh5WBgBINUwvBAAgSdFoVOFwWOX+VsWq8tRZPUWxqjyV57YqHA4rGo16XSIAIIX4HMdxvC4iXXR0dCg/P1/t7e0KBAJelwMA8IBt25o9q0zl/lZtWeZXls+X2NbvOFpa162G7kK9vmcvUw0BIIMlkw0Y6QIAIAmWZamxab/WmDmDApckZfl8ql6Yo737mmVZlkcVAgBSDaELAIAkxONxSdKcgqFHsQbaB/oBAEDoAgAgCcFgUJLU0GYPuX2gfaAfAACELgAAkmCapspKinTf9l71H3dZdL/jaO2OXs0sLZZpmh5VCABINYQuAACSYBiGNtRsVv3uPi2t61asuU+dPY5izUef1+/u0/qNm1hEAwCQQOgCACBJoVBIkUhELx6eoYraLgXWdaqitksN3YWKRCLcpwsAMAhLxieBJeMBAMeybVuWZSkejysYDMo0TUa4AGCCSCYbZI9TTQAAZBzDMFRZWel1GQCAFMf0QgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAF2V7XQAAAHCXbduyLEvxeFzBYFCmacowDK/LAoAJg9AFAEAGi0ajWr1yhRqb9ifaykqKtKFms0KhkIeVAcDEwfRCAAAyVDQaVTgcVrm/VbGqPHVWT1GsKk/lua0Kh8OKRqNelwgAE4LPcRzH6yLSRUdHh/Lz89Xe3q5AIOB1OQAAnJBt25o9q0zl/lZtWeZXls+X2NbvOFpa162G7kK9vmcvUw0B4BQkkw0Y6QIAIANZlqXGpv1aY+YMClySlOXzqXphjvbua5ZlWR5VCAATB6ELAIAMFI/HJUlzCoYexRpoH+gHAHAPoQsAgAwUDAYlSQ1t9pDbB9oH+gEA3EPoAgAgA5mmqbKSIt23vVf9x12+3e84WrujVzNLi2WapkcVAsDEQegCACADGYahDTWbVb+7T0vruhVr7lNnj6NY89Hn9bv7tH7jJhbRAIBxQOgCACBDhUIhRSIRvXh4hipquxRY16mK2i41dBcqEolwny4AGCcsGZ8ElowHABzPtm1ZlqV4PK5gMCjTNFNu9CgdagSAdJNMNsgep5oAAMg40WhUq1euUGPT/kRbWUmRNtRsTqlRJMMwVFlZ6XUZADBhMb0QAIBTEI1GFQ6HVe5vVawqT53VUxSrylN5bqvC4bCi0ajXJQIAUgTTC5PA9EIAgHR0ut7sWWUq97dqyzL/oJsP9zuOltZ1q6G7UK/v2cs0PgDIUMlkA0a6AABIkmVZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAgFRC6AIAIEnxeFySNKdg6FGsgfaBfgCAiY3QBQBAkoLBoCSpoc0ecvtA+0A/AMDERugCACBJpmmqrKRI923vVf9xl0b3O47W7ujVzNJimabpUYUAgFRC6AIAIEmGYWhDzWbV7+7T0rpuxZr71NnjKNZ89Hn97j6t37iJRTQAAJIIXQAAnJJQKKRIJKIXD89QRW2XAus6VVHbpYbuQkUikZS6TxcAwFssGZ8ElowHABzPtm1ZlqV4PK5gMCjTNBnhAoAJIJlskD1ONQEAkJEMw1BlZaXXZQAAUhjTCwEAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBFhC4AAAAAcBGhCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXpWXoeuutt3TttdcqEAho6tSpqqqq0l//+tcR7es4jj760Y/K5/Npy5Yt7hYKAAAAYMJLy9B17bXX6qWXXtIzzzyj+vp6/eY3v9EXvvCFEe27adMm+Xw+lysEAAAAgKOyvS4gWa+88oqefvppPf/887r44oslSd/61rf0sY99TOvXr9dZZ511wn137dqlDRs26D//8z8VDAbHq2QAQIazbVuWZSkejysYDMo0TRmG4XVZAIAUkXYjXbFYTFOnTk0ELklavHixsrKy9Lvf/e6E+3V1dWn58uV68MEHVVhYOKLX6unpUUdHx6AHAADHikajmj2rTIsWLdLy5cu1aNEizZ5Vpmg06nVpAIAUkXahq6WlRQUFBYPasrOzdcYZZ6ilpeWE+61cuVIVFRW66qqrRvxaa9euVX5+fuJRXFx8ynUDADJPNBpVOBxWub9Vsao8dVZPUawqT+W5rQqHwwQvAICkFApdd911l3w+37CPV1999ZSO/a//+q/65S9/qU2bNiW1X3V1tdrb2xOP5ubmU3p9AEDmsW1bq1eu0CfOztaWZX5dVpSt0yb5dFlRtrZc49cn3petO1bdLtu2vS4VAOCxlLmma/Xq1brhhhuG7TNr1iwVFhaqra1tUHtfX5/eeuutE04b/OUvf6k9e/Zo6tSpg9qvvvpqmaapbdu2Dbnf5MmTNXny5JG+BQDABGJZlhqb9uvxqjxlHbdAU5bPp+qFOaqobZZlWaqsrPSmSABASkiZ0DV9+nRNnz79pP0WLFigt99+Wzt37tS8efMkHQ1V/f39mj9//pD73HXXXfqHf/iHQW3l5eWqqanRJz/5ydEXDwCYcOLxuCRpTsHQC2YMtA/0AwBMXCkTukbqvPPO05VXXqmbbrpJDz30kHp7e3Xrrbdq2bJliZULDxw4oMsvv1w//OEPdemll6qwsHDIUbCSkhLNnDlzvN8CACADDKyC29Bm67Kid/912tBmD+oHAJi4UuaarmQ89thjOvfcc3X55ZfrYx/7mD74wQ/qe9/7XmJ7b2+vXnvtNXV1dXlYJQAgk5mmqbKSIt23vVf9jjNoW7/jaO2OXs0sLZZpmh5VCABIFT7HOe5vCpxQR0eH8vPz1d7erkAg4HU5AACPDaxe+In3Zat6YY7mFBhqaLO1dkev6nf3KRKJKBQKeV0mAMAFyWSDtBzpAgAgFYRCIUUiEb14eIYqarsUWNepitouNXQXErgAAAmMdCWBkS4AwFBs25ZlWYrH4woGgzJNU4Yx9AIbAIDMkEw2SLuFNAAASDWGYYzbsvAEPABIP4QuAADSRDQa1eqVK9TYtD/RVlZSpA01m5nKCAApjGu6AABIAwOLdpT7WxWrylNn9RTFqvJUntuqcDisaDTqdYkAgBPgmq4kcE0XAMALtm1r9qwylftbtWWZX1k+X2Jbv+NoaV23GroL9fqevUw1BIBxwuqFAABkEMuy1Ni0X2vMnEGBS5KyfD5VL8zR3n3NsizLowoBAMMhdAEAkOLi8bgkaU7B0KNYA+0D/QAAqYXQBQBAigsGg5KkhjZ7yO0D7QP9AACphdAFAECKM01TZSVFum97r/qPuxS733G0dkevZpYWyzRNjyoEAAyH0AUAQIozDEMbajarfnefltZ1K9bcp84eR7Hmo8/rd/dp/cZNLKIBACmK0AUAQBoIhUKKRCJ68fAMVdR2KbCuUxW1XWroLlQkEuE+XQCQwlgyPgksGQ8A8Jpt27IsS/F4XMFgUKZpMsIFAB5IJhtkj1NNAABgDBiGocrKSq/LAAAkgemFAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLsr0uAACATGHbtizLUjweVzAYlGmaMgzD67IAAB4jdAEAMAai0ahWr1yhxqb9ibaykiJtqNmsUCjkYWUAAK8xvRAAgFGKRqMKh8Mq97cqVpWnzuopilXlqTy3VeFwWNFo1OsSAQAe8jmO43hdRLro6OhQfn6+2tvbFQgEvC4HAJACbNvW7FllKve3assyv7J8vsS2fsfR0rpuNXQX6vU9e0c81ZBpigCQ+pLJBox0AQAwCpZlqbFpv9aYOYMClyRl+XyqXpijvfuaZVnWiI4XjUY1e1aZFi1apOXLl2vRokWaPauM0TIASGOELgAARiEej0uS5hQMPRI10D7QbzhMUwSAzEToAgBgFILBoCSpoc0ecvtA+0C/E7FtW6tXrtAnzs7WlmV+XVaUrdMm+XRZUba2XOPXJ96XrTtW3S7bHvp1AACpi9AFAMAomKapspIi3be9V/3HXSbd7zhau6NXM0uLZZrmsMcZ62mKAIDUQegCAGAUDMPQhprNqt/dp6V13Yo196mzx1Gs+ejz+t19Wr9x00kXwhjLaYoAgNRC6AIAYJRCoZAikYhePDxDFbVdCqzrVEVtlxq6CxWJREZ0n66xmqYIAEg9LBmfBJaMBwAMZzRLvSeWns9t1ZZrxmbpeQCAe5LJBtnjVBMAABnPMAxVVlae8r4bajYrHA5raV23qhfmaE6BoYY2W2t39Kp+d58ikZNPUwQApB6mFwIAkCLGYpoiACD1ML0wCUwvBACMh9FMUwQAjA+mFwIAkMZGM00RAJB6mF4IAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLsr0uAACATGPbtizLUjweVzAYlGmaMgzD67IAAB4hdAEAMIai0ahWr1yhxqb9ibaykiJtqNmsUCjkYWUAAK8wvRAAgDESjUYVDodV7m9VrCpPndVTFKvKU3luq8LhsKLRqNclAgA84HMcx/G6iHTR0dGh/Px8tbe3KxAIeF0OACCF2Lat2bPKVO5v1ZZlfmX5fIlt/Y6jpXXdaugu1Ot79jLVEAAyQDLZgJEuAADGgGVZamzarzVmzqDAJUlZPp+qF+Zo775mWZblUYUAAK8QugAAGAPxeFySNKdg6FGsgfaBfgCAiYOFNAAAGAPBYFCS1NBm67Kid//12tBmD+onscohAEwUjHQBADAGTNNUWUmR7tveq/7jLpfudxyt3dGrmaXFMk1T0tFFN2bPKtOiRYu0fPlyLVq0SLNnlbHYBgBkIEIXAABjwDAMbajZrPrdfVpa161Yc586exzFmo8+r9/dp/UbN8kwDFY5BIAJhtULk8DqhQCAkxnqPl0zS4u1fuMmhUIhVjkEgAyRTDYgdCWB0AUAGInhrtXatm2bFi1apFhV3pDXfsWa+1RR26Vf/epXqqysHOfKAQAjlUw2YCENAADGmGEYJwxMrHIIABMP13QBADCOjl3lcChDrXIIAEhvhC4AAMZRsqscAgDSH6ELAIBxlMwqhwCAzMA1XQAAuOzYhTUKCgqUn5+vFStWqO7xx1RRezDRb2ZpsSKRo6scAgAyB6ELAAAXHb+EfHaW1Nf/t+0zCqbps8uv01VXXTVolUMAQOZgeiEAAC459ibIay+fJJ+kj842Bt0Q+dLT27V582a99dZbBC4AyFDcpysJ3KcLADBSx94E+Sf/fbLe98A7Ki8wtGVZLjdEBoAMkEw2YKQLAAAXWJalxqb9WmPmaEdzvxrfdrTGnDQocElSls+n6oU52ruvWZZleVQtAMBNhC4AAFxw7E2Q451O4uehcENkAMhshC4AAFxw7E2Qg1N8iZ+Hwg2RASCzEboAAHDBsTdBXlicpbKpPt1nHeGGyAAwARG6AABwwbE3Qb76yR594QM5qt/dp6ue6OKGyAAwwbB6YRJYvRAAkKyT3adrZmmx1m/khsgAkG6SyQaEriQQugAAp8K2bVmWpXg8roKCAklSW1ubgsEgN0QGgDSVTDbIHqeaAACYsAzDUGVlpddlAAA8wjVdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAAALiI0AUAAAAALiJ0AQAAAICLCF0AAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuyva6gHTiOI4kqaOjw+NKAAAAAHhpIBMMZIThELqS0NnZKUkqLi72uBIAAAAAqaCzs1P5+fnD9vE5I4lmkCT19/frzTff1JQpU+Tz+bwux1UdHR0qLi5Wc3OzAoGA1+UAnJNIKZyPSCWcj0glE+l8dBxHnZ2dOuuss5SVNfxVW4x0JSErK0tFRUVelzGuAoFAxn9gkF44J5FKOB+RSjgfkUomyvl4shGuASykAQAAAAAuInQBAAAAgIsIXRjS5MmTde+992ry5MlelwJI4pxEauF8RCrhfEQq4XwcGgtpAAAAAICLGOkCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEbpwQj09PZo7d658Pp927do1aNsf//hHmaYpv9+v4uJi3X///d4UiYzW2NioqqoqzZw5U7m5uXrve9+re++9V0eOHBnUj/MR4+nBBx9UWVmZ/H6/5s+fr+eee87rkjABrF27VpdccommTJmigoICLV26VK+99tqgPt3d3brlllt05pln6rTTTtPVV1+t1tZWjyrGRLJu3Tr5fD7dfvvtiTbOx8EIXTihL3/5yzrrrLPe1d7R0aErrrhCpaWl2rlzp77xjW/oK1/5ir73ve95UCUy2auvvqr+/n5997vf1UsvvaSamho99NBDWrNmTaIP5yPGU11dnVatWqV7771XL7zwgi666CItWbJEbW1tXpeGDPfrX/9at9xyi5599lk988wz6u3t1RVXXKF33nkn0WflypX6t3/7Nz355JP69a9/rTfffFOhUMjDqjERPP/88/rud7+rCy+8cFA75+NxHGAI//7v/+6ce+65zksvveRIcn7/+98ntn372992Tj/9dKenpyfRdueddzrnnHOOB5Viorn//vudmTNnJp5zPmI8XXrppc4tt9ySeG7btnPWWWc5a9eu9bAqTERtbW2OJOfXv/614ziO8/bbbzs5OTnOk08+mejzyiuvOJKcWCzmVZnIcJ2dnc7ZZ5/tPPPMM86HP/xhZ8WKFY7jcD4OhZEuvEtra6tuuukm/Z//83+Ul5f3ru2xWEwf+tCHNGnSpETbkiVL9Nprr+kvf/nLeJaKCai9vV1nnHFG4jnnI8bLkSNHtHPnTi1evDjRlpWVpcWLFysWi3lYGSai9vZ2SUr8/3Dnzp3q7e0ddH6ee+65Kikp4fyEa2655RZ9/OMfH3TeSZyPQyF0YRDHcXTDDTfoS1/6ki6++OIh+7S0tGjGjBmD2gaet7S0uF4jJq433nhD3/rWt/TFL34x0cb5iPFy6NAh2bY95PnGuYbx1N/fr9tvv10LFy7UnDlzJB39/92kSZM0derUQX05P+GWJ554Qi+88ILWrl37rm2cj+9G6Jog7rrrLvl8vmEfr776qr71rW+ps7NT1dXVXpeMDDbS8/FYBw4c0JVXXqnPfOYzuummmzyqHAC8d8stt6ihoUFPPPGE16VggmpubtaKFSv02GOPye/3e11OWsj2ugCMj9WrV+uGG24Yts+sWbP0y1/+UrFYTJMnTx607eKLL9a1116rH/zgByosLHzX6jMDzwsLC8e0bmSmkZ6PA958800tWrRIFRUV71ogg/MR42XatGkyDGPI841zDePl1ltvVX19vX7zm9+oqKgo0V5YWKgjR47o7bffHjS6wPkJN+zcuVNtbW36wAc+kGizbVu/+c1v9MADD+jnP/855+NxCF0TxPTp0zV9+vST9vvmN7+pr33ta4nnb775ppYsWaK6ujrNnz9fkrRgwQL9z//5P9Xb26ucnBxJ0jPPPKNzzjlHp59+ujtvABllpOejdHSEa9GiRZo3b56+//3vKytr8AA95yPGy6RJkzRv3jxt3bpVS5culXR0mtfWrVt16623elscMp7jOLrtttv005/+VNu2bdPMmTMHbZ83b55ycnK0detWXX311ZKk1157TU1NTVqwYIEXJSODXX755XrxxRcHtd14440699xzdeedd6q4uJjz8Tg+x3Ecr4tA6mpsbNTMmTP1+9//XnPnzpV09OLdc845R1dccYXuvPNONTQ06O///u9VU1OjL3zhC94WjIxy4MABVVZWqrS0VD/4wQ9kGEZi28A3ZZyPGE91dXW6/vrr9d3vfleXXnqpNm3apB//+Md69dVX33WtFzCW/sf/+B/6v//3/+qpp57SOeeck2jPz89Xbm6uJOnmm2/Wv//7v+vRRx9VIBDQbbfdJkn67W9/60nNmFgqKys1d+5cbdq0SRLn4/EY6ULS8vPz9R//8R+65ZZbNG/ePE2bNk333HMP/8DFmHvmmWf0xhtv6I033hg0jUY6+q2vxPmI8XXNNdfo4MGDuueee9TS0qK5c+fq6aefJnDBdd/5znckHf2H7bG+//3vJ6Zr19TUKCsrS1dffbV6enq0ZMkSffvb3x7nSoGjOB8HY6QLAAAAAFzE6oUAAAAA4CJCFwAAAAC4iNAFAAAAAC4idAEAAACAiwhdAAAAAOAiQhcAAAAAuIjQBQAAAAAuInQBAAAAgIsIXQAAAADgIkIXAAAncPPNN+uDH/zgkNuKioq0bt26ca4IAJCOsr0uAACAVPTSSy/pe9/7nizLGnL7eeedp127do1vUQCAtMRIFwAAQ/jGN76hSy65RBUVFUNuP+OMM9TS0jLOVQEA0hGhCwCA4/T19Skajerqq69OtH3xi1/UI488knje2dmp3NxcL8oDAKQZQhcAAMfZs2ePOjs7VV5eLknq7+/Xk08+qSlTpiT6/PGPf9T5558vSfrYxz6me+65RwsXLtSsWbPU0NDgSd0AgNRE6AIA4Dhvv/22JOm0006TJP385z/XX/7yF/n9fknSs88+qwMHDujTn/60JKmhoUElJSXasWOH/vEf/1FPPfWUJ3UDAFITC2kAAHCc0tJS+Xw+Pf744/q7v/s73XHHHfr4xz+up556SsXFxfrSl76kxYsX64Mf/KA6Ojrk8/n0D//wD5Kk3t5eTZ061ds3AABIKYx0AQBwnMLCQn3961/Xj370I330ox/V6tWr9fWvf11bt26VaZo677zz9OMf/1jS0VGuSy65JLHviy++qAsuuMCr0gEAKcjnOI7jdREAAKSr733ve2ptbdU///M/S5Le//736xe/+IXOPPNMjysDAKQKRroAABiFhoYGXXjhhZKOrnr49ttvE7gAAIMw0gUAAAAALmKkCwAAAABcROgCAAAAABcRugAAAADARYQuAAAAAHARoQsAAAAAXEToAgAAAAAXEboAAAAAwEWELgAAAABwEaELAAAAAFxE6AIAAAAAFxG6AAAAAMBF/x+7pXoJq5p8/AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(S.Sigma_iw[\"up\"], marker = \"o\", markeredgecolor = \"black\", name = r\"$\\Sigma$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1fa86573", + "metadata": {}, + "outputs": [], + "source": [ + "G_w = Gf(mesh=MeshReFreq(window = (-5.0,5.0), n_w=1000), target_shape=[1,1])\n", + "G_iw = make_gf_imfreq(S.G_iw[\"up\"], n_iw = 2**14+3)\n", + "G_w.set_from_pade(G_iw, 100, 0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f18b5166", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10,10))\n", + "oplot(-np.imag(G_w)/np.pi, marker = \"o\", markeredgecolor = \"black\", name = r\"$A(\\omega)$\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}