diff --git a/examples/seismic/tutorials/16_variable_z_topography.ipynb b/examples/seismic/tutorials/16_variable_z_topography.ipynb new file mode 100644 index 0000000000..c04e2bb524 --- /dev/null +++ b/examples/seismic/tutorials/16_variable_z_topography.ipynb @@ -0,0 +1,616 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variable-z curvilinear topography\n", + "\n", + "In this notebook, we will create a simple implementation of a cosine hill topography based on coordinate transforms. This approach to irregular topography is commonly used in industry and academia, and is based upon creating some coordinate transform which maps the curved free-surface to a horizontal, grid-coincident plane in the iteration space. The most straightforward way of achieving this is by stretching the grid in the z axis, often referred to as \"variable-z\". This yields a transformed wave equation which can be solved with an explict FD solver.\n", + "\n", + "The isotropic acoustic wave equation in 2D is given as\n", + "\n", + "$\\frac{\\partial^2p}{\\partial t^2} = c^2\\left(\\frac{\\partial^2}{\\partial x^2}+\\frac{\\partial^2}{\\partial z^2}\\right)$,\n", + "\n", + "where $p$ is pressure and $c$ is wavespeed. To transform this equation from Cartesian dimensions $x$ and $z$ into a domain based on curvilinear dimensions $x'$ and $\\zeta$, spatial derivatives in this equation must be replaced with their transformed equivalents. Given that only the vertical dimension is stretched, these transformed derivatives are of the form\n", + "\n", + "$\\frac{\\partial^2p}{\\partial x^2} = \\frac{\\partial^2p}{\\partial x'^2} + \\frac{\\partial^2p}{\\partial x'\\partial \\zeta}\\frac{\\partial\\zeta}{\\partial x} + \\left(\\frac{\\partial^2 p}{\\partial x' \\partial\\zeta}+\\frac{\\partial^2 p}{\\partial\\zeta^2}\\frac{\\partial\\zeta}{\\partial x}\\right)\\frac{\\partial\\zeta}{\\partial x}+\\frac{\\partial p}{\\partial\\zeta}\\frac{\\partial^2\\zeta}{\\partial x^2}$,\n", + "\n", + "and\n", + "\n", + "$\\frac{\\partial^2p}{\\partial z^2} = \\frac{\\partial^2 p}{\\partial\\zeta^2}\\left(\\frac{\\partial\\zeta}{\\partial z}\\right)^2$.\n", + "\n", + "Note that we now have several derivatives pertaining to the transformation, $\\frac{\\partial\\zeta}{\\partial x}$ for example, which will require evaluation.\n", + "\n", + "## The topography\n", + "The surface topography for this particular example corresponds to\n", + "\n", + "$z_M = z_b + \\frac{h\\left(1 - cos\\left(\\frac{2\\pi(x-x_m)}{w}\\right)\\right)}{2}$,\n", + "\n", + "where $z_b$ is the baseline from which the topography rises, $h$ is the height of the topography, $x$ is the horizontal dimension with $x_m$ being its lower bound, and $w$ is the width of the domain. This surface represents the maximum extent of $z$, which will be mapped to the maximum extent of the vertical iteration dimension $\\zeta$. The minimum $\\zeta$, $\\zeta_m$ will be mapped to $z_m$.\n", + "\n", + "By constructing a linear function $\\zeta(x, z)$ using these two points, derivatives of $\\zeta$ with respect to these variables can be calculated. Note that the horizontal component $x'(x, z) = x$. In this case, since $z_m$ and $z_M$ are defined as above, these derivatives can be calculated analytically. In practice, more complex topographies may require calculation via finite-difference approximations.\n", + "\n", + "Note that that this transformation is not a conformal mapping, simplifying this process as some of these derivatives go to zero or unity.\n", + "\n", + "## The transformation\n", + "\n", + "To implement our curvilinear solver, we need to know the transformation required to map the surface onto a horizontal plane, in this case the maximum of the iteration space. For simplicity, we apply a linear warping of the z dimension.\n", + "\n", + "Firstly, we define a function to create a symbolic linear fit between two points:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sympy as sp\n", + "\n", + "def linear_fit(A, b, z):\n", + " \"\"\"Fit a linear function symbolically\"\"\"\n", + " sol = A**-1*b\n", + " \n", + " # Form the function\n", + " poly = sol[0] + sol[1]*z\n", + " return poly" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use this to create a function to generate symbolic expressions for $\\zeta(x, z)$ and derivatives, its inverse $z(x', \\zeta)$, and the equation of the surface $z_M(x)$, and return them as Python functions." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def zeta_derivs():\n", + " \"\"\"\n", + " Generates an expression for Z position of\n", + " cosine hill of height h, with a baseline\n", + " at z_b. Then gets functions evaluating derivatives\n", + " of zeta with respect to x and z. Uses a linear\n", + " warping of the z dimension to map the surface\n", + " z_s to the maximum extent of the vertical iteration\n", + " space.\n", + " \n", + " Returns\n", + " -------\n", + " zeta_xz : function or SymPy expression\n", + " Zeta with respect to x and z\n", + " zeta_dx : function or SymPy expression\n", + " First derivative of zeta with respect to x\n", + " zeta_dz : function or SymPy expression\n", + " First derivative of zeta with respect to z\n", + " zeta_dx2 : function or SymPy expression\n", + " Second derivative of zeta with respect to x\n", + " zeta_dz2 : function or SymPy expression\n", + " Second derivative of zeta with respect to z\n", + " z_zeta : function or SymPy expression\n", + " Z with respect to zeta\n", + " z_s : function or Sympy expression\n", + " Z position of the surface with respect to x\n", + " \"\"\"\n", + " # Get the cosine hill expression\n", + " x, h, xM, xm, zb = sp.symbols('x, h, x_max, x_min, z_b')\n", + " cos_centre = zb + h/2\n", + " w = xM-xm # Wavelength\n", + " zs = cos_centre - h*sp.cos(2*sp.pi*(x-xm)/w)/2\n", + " \n", + " # Create the linear variable-z warp\n", + " sym_names = \"\"\"zeta_min, zeta_max, zeta, z_min, z\"\"\"\n", + " zetam, zetaM, zeta, zm, z = sp.symbols(sym_names)\n", + "\n", + " # Set up a linear system and solve for the linear fit\n", + " A = sp.Matrix([[1, zm],\n", + " [1, zs]])\n", + "\n", + " b = sp.Matrix([[zetam],\n", + " [zetaM]])\n", + "\n", + " poly = linear_fit(A, b, z)\n", + " \n", + " # Inverse of the linear warp (used for plotting)\n", + " C = sp.Matrix([[1, zetam],\n", + " [1, zetaM]])\n", + " d = sp.Matrix([[zm],\n", + " [zs]])\n", + "\n", + " polyinv = linear_fit(C, d, zeta)\n", + " \n", + " # Make a list of functions to return\n", + " funcs = []\n", + "\n", + " # zeta(x, z) and its derivatives\n", + " params = [x, z, xM, xm, zb, zm, zetaM, zetam, h]\n", + " funcs.append(sp.lambdify(params, poly)) # No derivs taken\n", + " for i in range(1, 3): # Symbolic derivatives\n", + " funcs.append(sp.lambdify(params, sp.diff(poly, x, i)))\n", + " funcs.append(sp.lambdify(params, sp.diff(poly, z, i)))\n", + " \n", + " # z(x, zeta) to be used for plotting purposes\n", + " paramsinv = [x, zeta, xM, xm, zb, zm, zetaM, zetam, h]\n", + " funcs.append(sp.lambdify(paramsinv, polyinv))\n", + " \n", + " # Function of the surface\n", + " paramssurf = [x, xM, xm, zb, h]\n", + " funcs.append(sp.lambdify(paramssurf, zs))\n", + "\n", + " funcs = tuple(funcs)\n", + " return funcs\n", + "\n", + "zeta_xz, zeta_dx1, zeta_dz1, zeta_dx2, zeta_dz2, z_xzeta, z_s = zeta_derivs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up subdomains for the free surface\n", + "\n", + "For an MPI-safe free surface implementation, it is necessary to set up subdomains to avoid the need for hardcoded indices. See `userapi/03_subdomains.ipynb` for more detail on this functionality." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from devito import SubDomain\n", + "\n", + "so = 8 # Space order\n", + "\n", + "\n", + "class MainDomain(SubDomain): # Main model domain\n", + " name = 'main'\n", + " def __init__(self, so):\n", + " super().__init__()\n", + " self.so = so\n", + " \n", + " def define(self, dimensions):\n", + " x, zeta = dimensions\n", + " return {x: x, zeta: ('middle', 0, 1+self.so//2)}\n", + "\n", + "\n", + "class FreeSurface(SubDomain): # Free surface region\n", + " name = 'freesurface'\n", + " def __init__(self, so):\n", + " super().__init__()\n", + " self.so = so\n", + " \n", + " def define(self, dimensions):\n", + " x, zeta = dimensions\n", + " return {x: x, zeta: ('right', 1+self.so//2)}\n", + " \n", + "\n", + "main_domain = MainDomain(so)\n", + "freesurface = FreeSurface(so)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate derivatives needed for the transform\n", + "\n", + "To apply the transformation to the wave equation, the z dimension is parameterized as a function of zeta. To get the equation in terms of x and zeta, the chain rule must be applied, which yields an expression containing derivatives of zeta with respect to x and z.\n", + "\n", + "As the expression for the topography is known, it is possible to evaluate these expressions algebraically and plot the curvilinear grid.\n", + "\n", + "Setting up the grid to start:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "from devito import SpaceDimension, Grid, Function\n", + "\n", + "# Grid parameterisation\n", + "x_m = 0 # Minimum x (m)\n", + "x_M = 1000 # Maximum x (m)\n", + "z_m = 0 # Minimum physical z (m)\n", + "z_b = 1000 # Baseline physical z (m)\n", + "z_M = 1000 # Maximum physical z if deformation not applied (m)\n", + "zeta_m = 0 # Minimum iteration z (dimensionless)\n", + "zeta_M = 1 # Maximum iteration z (dimensionless)\n", + "\n", + "h = 200 # Height of topography above baseline (m)\n", + "\n", + "# Setting up the grid dimensions\n", + "x = SpaceDimension(name='x') # Physical x\n", + "zeta = SpaceDimension(name='zeta') # Iteration z\n", + "\n", + "# Set up a grid with a square topology\n", + "grid = Grid(shape=(101, 101), extent=(x_M-x_m, zeta_M-zeta_m),\n", + " origin=(x_m, zeta_m), dimensions=(x, zeta),\n", + " subdomains=(main_domain, freesurface))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The functions defined earlier can now be used to evaluate the requisite derivatives pertaining to the transformation. These values will be discretized as `Function`s onto the finite-difference grid." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Get surface profile\n", + "x_vals = np.linspace(x_m, x_M, grid.shape[0])\n", + "zeta_vals = np.linspace(zeta_m, zeta_M, grid.shape[1])\n", + "surface_z = z_s(x_vals, x_M, x_m, z_b, h)\n", + "\n", + "# Derivatives of zeta can be precalculated\n", + "# As the surface is analytic, these can be calculated straightforwardly\n", + "# dzeta/dz is constant wrt z (only needs dimensions of y)\n", + "# dzeta2/dz2 is thus zero\n", + "zeta_dz = Function(name='zeta_dz', shape=(grid.shape[0],),\n", + " extent=(grid.extent[0],), origin=(x_m,),\n", + " dimensions=(x,))\n", + "\n", + "# Z doesn't really matter here, so set to baseline value\n", + "zeta_dz.data[:] = zeta_dz1(x_vals, z_b, x_M, x_m, z_b, z_m, zeta_M, zeta_m, h)\n", + "\n", + "# Make an x-zeta meshgrid (for precalculating values)\n", + "x_msh, zeta_msh = np.meshgrid(x_vals, zeta_vals, indexing='ij')\n", + "\n", + "# Z mesh for plotting and evaluating derivs\n", + "z_msh = z_xzeta(x_msh, zeta_msh, x_M, x_m, z_b, z_m, zeta_M, zeta_m, h)\n", + "\n", + "# dzeta/dx\n", + "zeta_dx = Function(name='zeta_dx', grid=grid)\n", + "\n", + "zeta_dx.data[:] = zeta_dx1(x_msh, z_msh, x_M, x_m, z_b, z_m, zeta_M, zeta_m, h)\n", + "\n", + "# dzeta2/dx2\n", + "zeta_dxx = Function(name='zeta_dxx', grid=grid)\n", + "zeta_dxx.data[:] = zeta_dx2(x_msh, z_msh, x_M, x_m, z_b, z_m, zeta_M, zeta_m, h)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting the curvilinear grid:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "tags": [ + "nbval-ignore-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAGzCAYAAAAlsgzRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAADfzElEQVR4nOxdd1QUyde9Q84ZQcCAYE5gzhhWRTGviTWirnGNa9bVNa2u2TXnnDAnFJUkGDAQzYKAZCQOOc37/vBHf9PMoKCTwL7n1Dkz3f36varuvl1d9eo9HhEROHDgwIFDlYOSvA3gwIEDBw7SAUfwHDhw4FBFwRE8Bw4cOFRRcATPgQMHDlUUHMFz4MCBQxUFR/AcOHDgUEXBETwHDhw4VFFwBM+BAwcOVRQcwXPgwIFDFQVH8By+Cm9vb/B4PFy8eFHepsgNx44dA4/HQ2RkJLOta9eu6Nq1K/M/MjISPB4Px44dk7l9iojS7VMWSu4vb29vqdv0M4Ij+J8QPB6vXEUeDx2fz8eqVavQvHlz6OjoQFNTE02aNMGiRYsQFxcnc3t+NoSEhMDFxQXW1tbQ0NCAjo4O7OzssHDhQnz8+FHe5nGoIFTkbQAH2ePkyZOs/ydOnMC9e/dEtjds2BBv3ryRmV0fP37EL7/8gk+fPmHYsGGYPHky1NTUEBISgsOHD+PKlSt4//69zOwpwZgxYzBy5Eioq6uXeUytWrWQm5sLVVVVGVomWRw8eBDTpk2DiYkJRo0ahQYNGqCoqAgvX77EiRMnsH37duTm5kJZWfmb57p7964MLObwLXAE/xNi9OjRrP9PnjzBvXv3RLYDkBnBFxUVYciQIUhMTIS3tzc6derE2r9u3Tr8+++/EtGVl5cHNTU1KCmV7wNWWVn5m6TG4/GgoaEhCfOkhpycHGhpaYnd9+jRI0ybNg0dO3bEzZs3oaury9q/ZcsWrFu3rtw61NTUJGIzhx8DN0TDoVwQCARYt24drKysoKGhgR49eiAsLEzkOH9/fzg6OkJfXx9aWlpwcHDAw4cPv3n+S5cuITg4GMuWLRMhdwDQ09NjEUzt2rUxfvx4keNKj/2WjPGeO3cOy5cvh6WlJbS0tBAQEAAej4fjx4+LnMPd3R08Hg83b94EIH4MvjTEjcGPHz8eOjo6iI2NxaBBg6CjowNTU1PMnz8fxcXFLHmBQIDt27ejcePG0NDQgJmZGaZMmYK0tDTWcdeuXYOTkxMsLCygrq4OGxsbrFmzRuR8Xbt2RZMmTfDixQt06dIFWlpaWLp0aZn2r1q1CjweD6dPnxYhdwDQ0NDAmjVrWC+6r+kQNwYfExODQYMGQVtbG9WqVcPcuXORn59fpk0cfhxcD55DubBhwwYoKSlh/vz5yMjIwMaNGzFq1Cj4+/szx3h6eqJPnz5o2bIlVq5cCSUlJRw9ehTdu3eHr68v2rRpU+b5r1+/DuDLcIg0sGbNGqipqWH+/PnIz89Ho0aNUKdOHbi6umLcuHGsY8+fPw9DQ0P07t37h/UWFxejd+/eaNu2LTZv3oz79+9jy5YtsLGxwbRp05jjpkyZgmPHjsHFxQWzZs1CREQEdu3ahcDAQDx8+JAZ+jl27Bh0dHQwb9486OjowNPTEytWrACfz8emTZtYulNSUtCnTx+MHDkSo0ePhpmZmVgbc3Jy4Onpia5du8LKyqpC9SuvjtzcXPTo0QOfPn3CrFmzYGFhgZMnT8LT07NC+jhUEMThp8eMGTOorFvBy8uLAFDDhg0pPz+f2b5jxw4CQKGhoUREJBAIqG7dutS7d28SCATMcTk5OWRtbU09e/b8qg329vakr69fbptr1apF48aNE9nu4OBADg4OIvbXqVOHcnJyWMcuWbKEVFVVKTU1ldmWn59PBgYGNGHCBGbb0aNHCQBFRESUqSciIoIA0NGjR5lt48aNIwC0evVqkbq2bNmS+e/r60sA6PTp06zj7ty5I7K9dB2IiKZMmUJaWlqUl5fHsg8A7du3T+T40ggODiYANGfOHJF9KSkp9PnzZ6YI3wNf01G6fbZv304AyNXVldmWnZ1Ntra2BIC8vLy+aSeHioMbouFQLri4uLDGVTt37gwAjGdFUFAQPnz4gN9++w0pKSlITk5GcnIysrOz0aNHDzx48AACgaDM8/P5fLFDA5LCuHHjoKmpydo2YsQIFBYW4vLly8y2u3fvIj09HSNGjJCY7qlTp7L+d+7cmeWRcuHCBejr66Nnz55MuyUnJ6Nly5bQ0dGBl5cXc6xwHTIzM5GcnIzOnTsjJycHb9++ZelRV1eHi4vLN+3j8/kAAB0dHZF9derUgampKVNKvrQqqsPNzQ3Vq1fH0KFDmW1aWlqYPHnyN2U5fD+4IRoO5ULNmjVZ/w0NDQGAGSP+8OEDAIgMdwgjIyODkSsNPT09qbrhWVtbi2xr3rw5GjRogPPnz2PixIkAvgzPmJiYoHv37hLRq6GhAVNTU9Y2Q0ND1tj6hw8fkJGRgWrVqok9R1JSEvP71atXWL58OTw9PRliLkFGRgbrv6WlZbkmO0terFlZWSL7rl27hsLCQgQHB2P+/Pki+8urIyoqCra2tuDxeKzt9evX/6Ysh+8HR/AcyoWyvEjofxkfS3rnmzZtgp2dndhjxfUQS9CgQQMEBgYiOjoaNWrU+KY9pYmiBMXFxWJtLd17L8GIESOwbt06JCcnQ1dXF9evX4ezszNUVCTzaJTHpVAgEKBatWo4ffq02P0lL4j09HQ4ODhAT08Pq1evho2NDTQ0NBAQEIBFixaJfCGVVefSsLW1hYqKCl6+fCmyz8HBAQDKbI/y6uAgH3AEz0EisLGxAfClJ/7LL79UWL5///44e/YsTp06hSVLlnzzeENDQ6Snp4tsj4qKQp06dcqtd8SIEVi1ahUuXboEMzMz8Pl8jBw5siKm/zBsbGxw//59dOzY8auE6e3tjZSUFFy+fBldunRhtkdERPyQfm1tbXTt2hU+Pj6IjY2FpaXlD51PHGrVqoWXL1+CiFgv53fv3klcF4f/BzcGz0EiaNmyJWxsbLB582axn/qfP3/+qvzQoUPRtGlTrFu3Do8fPxbZn5mZiWXLljH/bWxs8OTJExQUFDDbbt68iejo6ArZ3bBhQzRt2hTnz5/H+fPnUb16dRZ5ygLDhw9HcXEx1qxZI7KvqKiIeZGVfA2UfDUBQEFBAfbs2fPDNqxYsQLFxcUYPXq02OsnrPN70LdvX8TFxbFCXuTk5ODAgQM/dF4OXwfXg+cgESgpKeHQoUPo06cPGjduDBcXF1haWiI2NhZeXl7Q09PDjRs3ypRXVVXF5cuX8csvv6BLly4YPnw4OnbsCFVVVbx69QpnzpyBoaEh4ws/adIkXLx4EY6Ojhg+fDjCw8Nx6tQp5kuiIhgxYgRWrFgBDQ0NTJw4sdwLoCQFBwcHTJkyBevXr0dQUBB69eoFVVVVfPjwARcuXMCOHTswdOhQdOjQAYaGhhg3bhxmzZoFHo+HkydP/jD5Al8mfnft2oWZM2eibt26zErWgoICvH//HqdPn4aamhrMzc2/6/y///47du3ahbFjx+LFixeoXr06Tp48WebCKw6SAUfwHCSGrl274vHjx1izZg127dqFrKwsmJubo23btpgyZco35W1tbREUFIRt27bhypUruHr1KgQCAWxtbTFp0iTMmjWLObZ3797YsmULtm7dijlz5qBVq1a4efMm/vzzzwrbPWLECCxfvhw5OTkS9Z6pCPbt24eWLVti//79WLp0KVRUVFC7dm2MHj0aHTt2BAAYGxszdVy+fDkMDQ0xevRo9OjRQyI++9OmTUP79u2xbds2XLhwAQkJCVBVVYWNjQ3GjRuHadOmfdcLFPjiMePh4YGZM2di586d0NLSwqhRo9CnTx84Ojr+sO0cxINHknj9c+DAgQMHhQM3Bs+BAwcOVRQcwXPgwIFDFQVH8Bw4cOBQRcERPAcOHDhUUXAEz4EDBw5VFBzBc+DAgUMVRZX1gxcIBIiLi4Ourm6ZcUs4cODAoTKAiJCZmQkLC4sKLcSrsgQfFxdXrqBVHDhw4FBZEB0dXaGkLFWW4EtCoEZHR0NPT0/O1nDgwIHD94PP56NGjRoVzplQZQm+ZFhGT0+PI3gOHDhUCVR0uJmbZOXAgQOHKgqO4Dlw4MChioIjeA4cOHCoouAIngMHDhyqKDiC58CBA4cqCo7gOXDgwKGKgiN4Dhw4cKii4AieAwcOHKooOILnwIEDhyoKjuA5cODAoYqiwgT/4MED9O/fHxYWFuDxeLh69Sqzr7CwEIsWLULTpk2hra0NCwsLjB07FnFxcaxzpKamYtSoUdDT04OBgQEmTpyIrKws1jEhISHo3LkzNDQ0UKNGDWzcuPH7asiBAwcOPykqTPDZ2dlo3rw5du/eLbIvJycHAQEB+OuvvxAQEIDLly/j3bt3GDBgAOu4UaNG4dWrV7h37x5u3ryJBw8eYPLkycx+Pp+PXr16oVatWnjx4gU2bdqEv//+GwcOHPiOKnLgIB0QEbKzs5GdnQ0ikrc5HDiIgEc/cGfyeDxcuXIFgwYNKvOYZ8+eoU2bNoiKikLNmjXx5s0bNGrUCM+ePUOrVq0AAHfu3EHfvn0RExMDCwsL7N27F8uWLUNCQgLU1NQAAIsXL8bVq1fx9u1bsXry8/ORn5/P/C+JvpaRkcEFG+PwXSCBAKkfPiAlNBT8d++QFx2N4pQUUHo6kJOD4vx8hLx4AQLQvGVLKGtqAjo6UDIygoqJCbSsraFXvz6q2dtDx9xc3tXhUInB5/Ohr69fYT6TejTJjIwM8Hg8GBgYAAAeP34MAwMDhtwB4JdffoGSkhL8/f0xePBgPH78GF26dGHIHQB69+6Nf//9F2lpaTA0NBTRs379eqxatUra1eFQBSEoLsa7W7fw+f59FAcFQePjRxilpMAiLw/GAIy/Ituj5MeLF1/V8ZnHQ4K2NtLNzVHcoAHUW7WCZb9+qNGiBZeQhoPUIFWCz8vLw6JFi+Ds7My8dRISElCtWjW2ESoqMDIyQkJCAnOMtbU16xgzMzNmnziCX7JkCebNm8f8L+nBc+BQGnnp6Xh7/DjSr16FTmgobFJT0ZAIDcs4PpnHQ6q6OjK1tFCgqYkibW0INDVRrKQE/8BA8AC0sbODcnExlLOzoZqTA/XcXOjn5MC4sBB6AEyJYJqVBYSFfSk3bwJ//41PKiqIqV4dhe3awXLUKNj07w9eBTL2cODwNUiN4AsLCzF8+HAQEfbu3SstNQzU1dWhrq4udT0cKh9IIMBHNzdEHzwIXT8/NE5NhV2pY/IAhALIsbEBNWkCbTs7GLdpA8tOnWCipwcTMefNzs5GDx0dAECWnx+0tbXF6s/49Alxvr5Ie/4cBcHBUHv3DsZxcagPoGZREWpGRwPR0cCFC/jM4+F9zZpA375oMHs2jOvXl1xDcPjpIBWCLyH3qKgoeHp6ssaMzM3NkZSUxDq+qKgIqampMP/fOKW5uTkSExNZx5T8N+fGMjmUAyQQ4PXx4/i8fz9qBQTAprAQNkL7E5WUEG5lhcK2baHXuzfaTpqEQgBZwcFlEvX3Qr9mTeiPGgWMGgXgy4tBR0cHegDurF6NfG9v6AYFoUFq6peeflQUsHcvivfuRZC+PjK6d4ftggWwbN9eonZx+AlAPwAAdOXKFda2goICGjRoEDVu3JiSkpJEZF6/fk0A6Pnz58w2d3d34vF4FBsbS0REe/bsIUNDQyooKGCOWbJkCdWvX7/ctmVkZBAAysjIqGCtOFRWCAQCennxIt1v354iVVSIAKbkAfTM2Ji8Bw2isBs3SFBczMhlZWURAAJAWVlZ5dYnabn8zEwK+u8/8mrfnt5qaLDsJ4AC9fTIY9gwigkJIYFAUG59HCo/vpfPKkzwmZmZFBgYSIGBgQSAtm7dSoGBgRQVFUUFBQU0YMAAsrKyoqCgIIqPj2dKfn4+cw5HR0eyt7cnf39/8vPzo7p165KzszOzPz09nczMzGjMmDH08uVLOnfuHGlpadH+/fvLbSdH8D8P+LGx9GDsWArR1mYRYiZAD2vUoIdz5hD/f50HcVAUgi+NaD8/8h48mIL09Ki41MvKz8qKnv/zDxUXFpZbL4fKC5kRvJeXF3NzCpdx48ZRRESE2H0AyMvLizlHSkoKOTs7k46ODunp6ZGLiwtlZmay9AQHB1OnTp1IXV2dLC0tacOGDRWykyP4qo/3ly+TT+PGxBciv0KArgPkPXUqZSUmlus8ikrwwoh98oTuOzpSYKlefaSKCnn17Usp79+XWz+Hyofv5bMf8oNXZHyv3ygHxYagqAjPV62C6q5dsE9PZ7ZHqKriY/fuGOXujkQAWVlZ5R5LLxkTRyWRswOwtVEj2L95A4P/Pb55AJ7Wrw+Lf/+F7cCB5Tofh8qD7+Uzzh+LQ6VAPp+PB6NHI0pLC23WroV9ejqKADy2tETg5s2onZeHdpcuIfGbZ6r8CALQ5ulTqCUlwXfcOLzR1IQGgC7v3sF20CA8NzFB4NatIIFAzpZykDc4gueg0MhKSIC3kxPSDA3R5fRpWBcWIgOAd5s2SHryBO1jYmD/558/pe+4lokJOh87hgZZWQjZswePLS1RDKBVSgrs//wTr/T04L90KUf0PzF+vqeCg8KDiJAYFgaPX35BvoUFurq5wVwgQJyyMnwGDYJyfDy6+vvDom1beZuqEOApKaHZtGloHxODWC8v+DRpglwATbKz0Xb9erzT1saDuXORmZHBxcz5ycARPAeFQk5yMjz79IFK3bro4eEBYyJEqKrC18UFJunpcLhyhYvr8hXU7NoVDqGhyAoNhXf79sgE0CAvD122b0e4gQEecT36nwocwXNQCBRkZcFn5Ehkmpmhh7s7jAG8A+A9cSJq8PnofOQI1P43Mcnh2zBt0gRdHz1C4fv38GjXDnwAdgA6btiAl/r6CNq+Xb4GcpAJOILnIFeQQIBHc+ci3tAQDufPw0wgQLSyMsYDaAyg9Y4dUNHQkLOVlRdGdeui3f37sAbwL4AcAE2zsmA3dy6eVauG9xcvytlCDtIER/Ac5IaQPXvwSk8PHbZvR62iIiQpKcFn2DDoxMbiOIBieRtYhZAKYDGAz0+ewKdpUxQCaP35M2yHDYNv3bqIf/5czhZykAY4gucgc3zy9sZjKys0mzEDTbKzkQXAu2tXaMXGwsHVlRuKkSJMmjSBQ0gIYu/exWMrKygB6BwWBr3WreHdtSuyS8WJ4lC5IfV48Bw4lCAzLg4vhgxBe39/1MSXHvrDBg3Q4Px5dG3WTN7msZCZmYmIiAhERUUhPj4eiYmJSEpKAp/PB5/PR05ODvLy8pjjnZycoKmp+SWI2P9SUZqZmcHc3BwWFhaoXbs2atasycpxIE/U7tkTtaOj8fLQIdDcuWialYWuPj6Ir14dQVOnosPOnT+l62mVgxRW1SoEuFAFioPiwkLy/f13SlBSYpbYPzcyoveXL4s9XpYhAHJzc1nhNzp27EgmJiZlhtz4kaKkpES1a9em3r17M9sCAgKoWCjwmaTrVx45QXExPZo7lz4JBWgL1tWl16dOlVsHB+mCC1VQClyoAvmDiBB89CiUZs9Gs/8lVY9UVUXSokVovWpVmT1EaYYASE5Oho+PD/z8/ODr64vg4GAUFRWJPZ+xsTFq164NCwsLmJubw9TUFPr6+tDX14eWlhaKi4vh4uICADh8+DCUlJSQlZUFPp+PtLQ0JCYmIjExETExMYiIiEBubq5YPXp6emjbti06d+6Mzp07o3379mJzG0g7NEJuair8R4xA6/v3oQ1AAOBB/fqwOXsWVnZ2XOYpOeK7+UwabxtFANeDly/SPn4kz0aNmCiImQB5OTpSXjmuhyR7qkVFReTr60uLFy+mFi1aEI/HE+lZC/fYDx48SC9evCjXfVMROwUCAcXHx5O3tzdt27aNkVNXVxexR1NTkxwdHWnr1q30XiiImKy+bOKePSO/WrWY3nwyQB4jRnCRK+UImUWTrCzgCF4+EBQXk++kSZTE4zEEcQag8AcPyn0OSRDZhQsXaOzYsWRsbCxCoE2aNKHp06fTmTNnKDIykjIzM+UWTTI9PZ2CgoJo165dNGLECDI3Nxext0GDBrRo0SLy8/OTqZ3+mzZRsFDkylBtbW7YRk7gCL4UOIKXPd5fvkxBenoMIXxQU6OuMiKkoqIiunHjhtixb0NDQ/rtt9/oxIkTFBcXJxF90pITCAQUEhJCW7ZsoR49epCKiorYOgUEBMjETmWAZgOU8b9rWgSQd9OmlB4VVe7zcPhxcARfChzByw5ZiYnk1aYNFfyPBLL+NxyTmpAgdeIMCwujJUuWkJWVFYsAzc3NadasWeTt7U2F3xhaUCSCL4309HQ6e/YsDR06lDQ0NFh1bNu2Le3bt++b97gk7Ix49Ig1bJOgpEQPZ85kZcbiID1wBF8KHMHLBv5//UXRysrMg/+4enWKefSIiKRHgAUFBeTq6krdu3dnEZ6+vj7zm8/nS0yfosglCL0wlZSUmN9aWlo0YcIEVhpMadn54t9/6aOqKnO9nxkbU6SHR7nPyeH7wBF8KXAEL13EPXtGjywtmQc9WlmZ/JcvZx0jaQJMTEykNWvWkKWlJbOfx+NR79696cKFC5SSklIpiFoScuHh4bRlyxZq0KAB6yXXrl07OnXqFCtFpqTtzMvIIK9u3Sj3f9c+ByCvnj0pv1RWNg6SA0fwpcARvHRQlJ9P3kOHMmOyhQB5tW4tNj2epIjl9evXNGnSJJbHSbVq1WjZsmUUEREhcX2VSU4gEJCvry/99ttvpKqqyuwvSXOZmpoqNTsj7t6l50ZG/z/noq5Owbt3l/v8HMoPjuBLgSN4yUEgEFBWVhYFnzhBoUKJrUO1tendhQtlykmCWPr27cvqobZu3ZpOnTpFeXl5UtFXmeUSEhJo9erVLE8cHR0dmjVrltTsFBQXk9+0aSyvKZ/69SkmNJSysrJIIBCUWx+HssERfClwBC85JH78SP/+r7dOAKUD5D1iBBUJDQOIw/cQmUAgoJs3b7JIncfj0aBBg8jX1/erhKFohCsvuby8PDp27Bg1a9aM1Y4A6NWrV1KxMzUsjB7Uq/f/k7AAjQQoswJzIRzKxvfyGRdsgsNX8Wz1auTXrYuF+BK46KGlJXJfvIDDuXNQlmBcFSLC/fv30aVLF/Tr14/ZPmbMGLx58wZXrlxBp06duNWU5YC6ujrGjRuHoKAguLm5oUOHDsy+Zs2aYeLEifj48aNEdRra2KDzu3cI/u8/hKupwQzAWQCvra0R/eCBRHVxqACk876RP7ge/I8hITCQHtaowfTIIgFyklKP08fHh7p06cIcq6amppA946ogV1JUVFRoypQp9OnTJ4nrS4mLo+UA5f3v3skGyKtPHyrIzi73OTiwwfXgOUgEgqIiPPjtN2jY26NDdDSKAXja2aExgFsS1hUQEABHR0c4ODjgwYMHUFdXx6xZs/Dq1SsJa+JQAg8PD/Tu3RtFRUXYv38/bG1tMXfuXHz+/FliOtT19LAWQFMAAfr60ALQ9fZtRBgb4+WhQxLTw6EckNILR+7gevAVx7sLFyhER4fptb/S0qLXp05JvMf54cMHGjFiBKs3OW3aNIqOjv6q3Pfq4+RE5Xx9falr167Mdl1dXVq1ahVlCrk6SkJfJp9PvpMmUfL/JmGLAfJp1IjSIyPLfT4O3CSrCDiCLz+yEhPJq3VrZhKVD5D3kCHMJKqkiCUpKYlmzpzJLL/n8Xg0evRoCg8P/6rc9+rj5L4uJxAI6O7du9SiRQtmv5mZGe3bt48KCwslqi/57VvytbFhOg+JSkr08I8/uJWw5cT38hmX8OMnh//SpbDauBFdi78kyHtsaYnaV6/CoVUrierZsmULNm/ejMzMTABAnz59sGHDBjRTsEQfBQUF+PTpEyIiIhAZGYno6Ggm7G9KSgqT8CM3NxcFBQWMnIWFBdTU1KCjowNdXV3o6+vD1NSUSfpRq1Yt1KpVCzY2NjA0NJRjDf8fPB4PPXv2RI8ePXDx4kUsXboU4eHhmDp1KrZv3461a9dKTJdx/froFBaGoO3bobdoEeoUFKDarl14ceYMjM6cgXXv3hLTxUEIUnrhyB1cD/7riPb1pSdmZqyVqE9XrhR77Pf25ISjNJaUFi1akMc3lrbLqocbFxdH165do6VLlzJywiEApFU0NTWZ3xs2bCAfHx/W0Ii82iU/P5927twpNuGJJPXlZWSQV/fuzErYPIC8OnemnJSUcuv42cAl/CgFLuGHKIgIqXFxCBo9Gh28vaEJoBDAw/bt0eb6dWiZmIiV+55EE8+ePcMff/yBp0+fAvjSw/3333/x22+/QekbqeCkkdiCiPD+/Xt4enrC19cXjx49QlRUlNjz6OjowMbGhkmzZ25uDjMzM5iYmEBfXx+6urrQ1NREYWEh7OzsAACBgYFQUVFBdnY2+Hw+0tPT8fnzZyQlJSE2NhZRUVHMV4G4BCNKSkpo3rw5OnTogK5du6Jr164wKXU9pJ3wowQZGRn4559/sG3bNhQWFgIAXFxcsGHDBlSrVk1i+qI8PZE0YgRaJycDAD6pqCB6/nzYLV8OLS0tziVWCFzCj1LgevCi8Fu6lN7j/+N7BxgY0Idr174pV5GeY1xcHI0bN06kB5iUlFRuOyXVU01LSyNXV1dycXEhCwsLEZuUlJSoSZMm5OzszGz78OFDuVdffo+dBQUFFBAQwMg5OTmJRMIsKc2bN6dFixaRj48PFRQUyHzs/uXLlyx79PT0aPPmzaw4Nz+qT1BcTI/mzaNYoYB11wF6e+tWue38GcBNspYCR/D/j0gPD9ZwTCxAXpMnl3uCqzwPbF5eHm3YsIF0dHSYY4WJU9aTid26dSNlZWUWQamrq1O3bt1o1apVdP/+fSbipCJMekZHR5OrqyvNmjWLmjZtKkL2BgYGNHLkSLnZ2bx5c+Z3/fr16fbt2xLVlxkfT/dbtWJCTucC5NWxo9gYRz8jOIIvBY7gifixseTVrh2z4KQAoI0A6UqYIG7dukV169Zljmnbti35+/vLjDiTk5Np37591KlTJxFibNiwIc2bN4/u3btHubm5EtEnC7nExEQ6ffo0jR49WuyY+IgRI+jGjRtUUFAgEzv5fD4dPnyYqlWrxmzr378/hYWFSVRffYDchb4yY5WVyW/69J/e24Yj+FL4mQm+KD+fHowfTwlKSsyD8tzIiF5euCBRQgoLC6N+/fox+8zNzen48eNU/L+HUZoEWFBQQNevX6chQ4awoiiWlLVr19KHDx8kpk+eciV5Zf/44w+RepqamtLs2bMpMDBQJnamp6fTn3/+ybi6qqmp0dKlS1nnlYS+B3Pn0icVFeb+DdHRodBDh8p9rqoGjuBL4Wcl+BcbN9JbDQ3mwYhQVSX/5ctJUFwssQc9KyuLli1bxoQUUFFRofnz54u0tTQI8OPHj7R06VKR3KV2dna0du1ahSZqScpNmzaNzMzMWG3QsmVLOnDggEiyE2nY+fr1a+rZsyezv0aNGuTq6spEHpWEvpyUFPL65RfKFOrR+9WqRdF+fuU+Z1UBR/Cl8LMR/LsLF+ipqSnzIKQD5NWvH+UJ1V8SD96pU6eoRo0azP+ePXvSmzdvvin3Iw96cXExubm5Ud++fYnH4zH7qlWrRn/++SeFhIRIVF9lkSssLKRbt27RsGHDWPF7dHR0aMaMGcx1kZadAoGALl++TLVq1WKO6969Oz1//lyi+uKePaMHtrZUDKHx+VatKFXM8FBVBUfwpfCzEHy0ry/52tgwN38BQN7NmlHy27cix0riQS8ptWrVosuXL0s9fO+WLVtY4/slL5ULFy6IeHPIm3DlKZeUlESbN2+mevXqibTVlStXpGpnTk4OrVy5kskZKzy5LUl9b86coQADA6YTk8bjkVefPpT9+XO5dVRWcARfClWZ4AUCAX308yPPRo0oX+jz9ZGVFUXcvVum3PcQC5/Ppzlz5jByampq9Ndff1F2OSIDfi+RhYeHi7xQ9PX1ac6cOfT+/XuJ66tKcgKBgO7du0cDBw4Uu2grNTVVanZ+/PiRBgwYwNJ35MgRibqdCoqL6enff9N7dXVWAvD7gwZRSlxclU0wwhF8KVRVgo9/8YI8mjWjHCFif25kRC+PHPmmbEUeWIFAQGfPnhXxHy8ZDikPKkoQ4eHhNHXqVNZwg7W1Ne3atUshVnpWNrmPHz/S3LlzSVtbm5GrXr06bdmyRarteenSJdY906VLl3LdNxXRV5SfT76TJrEmYqMA8hg6lDUsWVXAEXwpVDWCj/bzI++mTZnl3QSQH0BPNmwo9znK+wCFhoayIg3Wrl1bqoT0+vVrGjNmjIjfekWvn6ITrrzkYmNjRdrVyMiI1qxZQ2lpaVK1U3jYZvbs2RLXl5+ZSR5Dh1IM2K6V3kOGVKmhG47gS6GqEPyHq1fJt04dZgEIARSkq0u/SIEg0tLSaPbs2QzRamho0KpVqyg5OVkqhPTq1SsaMWIEa+LU0dGR7ty5UymIszLK7d69mzWnoa+vTytWrBBLvJLQ9+bNG/r111+Z/9WqVaMjR44wrrSS0qcO0AyAYoVcgz/zeOTVo0eVmIzlCL4UKjPBC4qL6dnatfTM2Ji5WUuGYgI2b6ZMPl+iBFFcXExHjhxhLWIZPHgwRUREfFXue/W9ffuWnJ2dWcQ+aNAgevbsmVT0cXJsuaKiIjpz5gw1btyYRfSrVq1iPS+StPPu3btUv359Znvbtm3p6dOnEq9fckwM+Tg7U5TQ0E0WQN5NmtDHO3fKfU5FA0fwpVAZCT49MpK8Bw+mcDU15uYsAuiRpSW9OnaMOU6SD97jx4+pdevWzPYGDRqQu7v7N+W+R19ERAS5uLiwJv8GDx5MQUFBUtHHyX1drri4mFxdXVlEb2xsTBs3bqTs7GyJ68vPz6dNmzYx4Sx4PB5NmDCBEhISJF6/wtxc8ps+nbUmhAB6ZmxMT5Yu/WbCeEUDR/ClUBkIXiAQUCafT/6bN9MDGxvKEroR+QB529lRlJeXiJwkHoQPHz7QmDFjmP+6urplBpKShL6pU6eyVpz279+/zNWXikKApVGyiCc+Pp4+fvxIQUFBjFxwcDBFRkbS58+fKS8vT652VlSuuLiYzp07x+phm5ub07Zt26SiLy4uTuTe27RpE6Wmpkpcn6C4mAK2bCH/atUYV2ICKEZZmTw7daJ3d+5QVlaWwnvfcARfCopO8B/v3KH7nTqxojsSQO/V1cln5Ejix8aWKSuJB104JrmLiwvFx8dLXF98fDwjV1J++eUXevLkSbntlDUB3rx5k/bt20dLliyhUaNGkYODAzVs2JCMjY0rFCteTU2NLCwsqHnz5tSrVy+aNGkSrV69mk6ePEne3t4KRfAlKCwspGPHjrEm1UtK6dWxktD36NEjatWqFXNsnTp1pFq/SA8P8mrdmlL+lz6wpHgB5DFyJKV9/FhunbIGR/CloGgELygupg/XrpFXjx70WlOTdYPxAfK2taWQffvKFVTpex50gUBAR48eZT207du3J39/f4nrE5c4omXLlt9M9PG9+ioqV1hYSIGBgbRv3z6aMmUKtWnTptzEXTK0oKmpSbq6usw2HR0dUldXr9B5AFCPHj1owYIFdP78eYqIiJD6wrHyXr9du3aRqakpI2dvb0+enp4S11cy/1M69MTjx4/Lpaui+oiIctPS6OHMmfTM0JDVq88DyL9aNXowbhx9fv263PplAY7gS0ERCD4zPp6e/v03eTdtSpFCkz4EUCFAT0xM6DeAtKX8wD58+JDatWvHeoAkvQCF6MtL5MKFC2RjYyNCZOXxu/7e+n1LLicnh+7du0d//fUXOTg4sL5eShdbW1tycnKiP/74gzZu3EhnzpwhDw8PCg0Npbi4OMrMzGTaTezYb2EhpaWlUWRkJD1//pxu375NR44coVWrVtGECROoa9euImQmXKpVq0ZDhgyh7du3U2BgIMvbRNZfNgkJCSL29enTh0JDQyWuj8/n07x581i6Jk6cSHFxcd+U/ZF2qQnQQkBkrL4IXwKceXXvTq+OHZP7mL3MCN7Hx4f69etH1atXJwB05coV1n6BQEB//fUXmZubk4aGBvXo0UNk9WFKSgr99ttvpKurS/r6+jRhwgQRAggODqZOnTqRuro6WVlZ0b///lshO2VJ8CVjsxGPHtHjRYvIq21bCtHRYZJYl9VDkPYD++7dOxoyZAhzrJaWltT0PXz4kNq3b88cZ2ZmRtu3b5cpIQnLPXv2jDZu3Ei//PKL2J61vr4+9ezZkxYvXsz6spG1nf/99x9NmzaNWrVqxURoFC6mpqbk7OxMx48fp4iICLnZOWXKFMY+JSWlr5KvJPQJ37MrVqz46hCRpJ6jsr6wCV9iO/lXq0ZeffpQwLZtlBgeLtOxe5kRvJubGy1btowuX74sluA3bNhA+vr6dPXqVQoODqYBAwaQtbU1Kxa3o6MjNW/enJ48eUK+vr5ka2tLzs7OrMqYmZnRqFGj6OXLl3T27FnS1NSk/fv3l9vO72mQEqL+2oUrys+nuKdPKXD7dnowfjx5tW5N/sbGrIUWwiVaWZl8GjSgJ0uWiIyrS4vg4+Pjafr06SIPZFhYmMT1hYWF0bBhw1gP5MqVKykzM1OmPc7i4mK6e/dumT1jS0tLGj16NB04cIBev34t155xWXK5ubnk5+dH69evJ0dHR1bylNJFmiuKy5J7//49y6ddW1ubVq1aJXJOSei7f/8+66uzWrVqtGvXLqk5AZSWi3n0iHxGjaLH1atTupjnugig1wD5WVqSV/fu9HDWLHp1/DilhoWVOcxaHn4pC3IZoilN8AKBgMzNzWnTpk3MtvT0dFJXV6ezZ88S0ZdViyU9rBLcvn2beDwexf6PAPfs2UOGhoasi7lo0SKqX79+mbbk5eVRRkYGU6KjoyvcIB88PGgbQLsA8qpXjx7Y2tIjS0t6YWhIrzU1KV5JiYrKIPKSi/5OXZ0e1KtHvpMmUbSv71f1SfrGTEtLo6VLl7J66k5OTswntST1paWl0fz585mwAuJ6ddImToFAQI8ePaI//vhDZNhDVVWVHB0daceOHfTmzRuFGNuuqFx+fj75+PjQsmXLyM7OToTk7ezsaP369RQZGSlTO0sP+VlYWNDRo0clngdAIBDQxYsXydbWltlubW1Np06doqKiIqnVrzSK8vPp9cmT5NWvHz2ytKQYofSC4koOQFEqKhSio0NPTUzoYY0a9KBuXfKqX5/+A2hlBe0kUhCCLwkSVdr9rUuXLjRr1iwiIjp8+DAZGBiw9hcWFpKysjJdvnyZiIjGjBlDAwcOZB3j6elJQNnBklauXCm2p1ORBgk8fPirF66kFAIUqaJCz42MyLtpU/IYPpzaQ/pj6WXJ8fl8Wrt2LRkYGDDb27ZtS16lXCwloS8tLY127dpFxsbGzLZevXqJ7VFK68ELDw+nFStWsLwugC85Q0t+l/hWS0Kfosi9e/eOkSvt0dO5c2c6ePCg2PtdGnYKBAI6f/48WVtbM8e0aNGCvL29Ja4vPz+f9uzZw4p/37hxY7p48SIVSzDPQUXkzAHqBdB9R0fytbGhYF1dVoKdr5VPlZXgHz58SABExuaGDRtGw4cPJyKidevWUb169UTOZWpqSnv27CEiop49e9LkyZNZ+1+9ekUA6HUZs9uS6MFHPHpE/wC0CqD7Dg7k1bs3eQ8bRn7TppH/X3/R65MnKf7FCyoslfpNngSxatUqlrdKo0aN6MqVK2J7rJLQJxyOtlGjRuTm5ibV+pXI5eTk0MmTJ8nBwYFFbNra2jR69Gi6deuWVPyoFVUuMjKSDhw4QF27dmWtCNbU1KQxY8bQgwcPvjoZLCk78/LyaNOmTayXa//+/aWiLysri9atW8fqyNjZ2dGZM2cU5vrlpKRQlJcXBe/ZQ48XLiTfiRPJe/Bg8urVi+536UKr8WVSlyP4ChJ8aXxPg1SWBz0mJoZFcgCobt26dPr0adanq6T0PXnyhKXLxMSE9uzZQ4WFhVKpn7BcQEAAzZkzhwwNDZltPB6PevXqRadPn2adt7JcP0nLRUdH04YNG6hBgwas69SwYUPavn07636Rlp1JSUk0ffp0kYBxMTExEteXlpZGf/31l9g5iqr4vBMpCMHLc4imNKoiwcfHx9PChQtZN7atrS2dOHHim2T7PfoSExNp8uTJrB7i7NmzKT09XSr1KwFfKNaOcKlZsyatXr2aPn36JFF9VUVOIBDQ48ePadKkSawQwcJuodK289WrV/TLL78wckZGRrRz506pJAdPTk6mZcuWsZ4HGxsbOnjw4DdXE39v/eQhR6QgBF8yybp582aWYeImWZ8/f84c4+7uLnaSVfimWLJkyVcnWUujKhF8SEgIubi4sOKkS7PHkpubS+vXr2ct5JFFu2RlZdHu3btF/Oj79+9Pbm5uX/06+R59VVkuIyOD9uzZw4ozA3xJqXf79u1yeXFIws6S0qBBA7p586ZUJrtLhmOFi7m5Oa1du5aSk5OlWr8qR/CZmZkUGBhIgYGBBIC2bt1KgYGBFBUVRURf3CQNDAzo2rVrFBISQgMHDhTrJmlvb0/+/v7k5+dHdevWZblJpqenk5mZGY0ZM4ZevnxJ586dIy0tLam7SSrSBS8qKqKrV6+yekMAqEOHDuTq6iq1HuDZs2dZOTZbtWrFcj+URrskJibS8uXLWcMwJeVbi2q+R9/PJCcQCMjNzU2kXZs0aULHjx8X63YoSTu3b9/OmiP65ZdfRILLSVLfP//8Q5aWlqyvl99//52Cg4Oloq/KEbyXl5fIzQKAxo0bR0T/v9DJzMyM1NXVqUePHvTu3TvWOVJSUsjZ2Zl0dHRIT0+PXFxcvrrQydLSkjZUILEFUeUl+NjYWFq7di2LZJWUlGjo0KHM8m1p2Pnw4UNq27Yts9/KyopOnjwpVS+FkgxOwguRbGxsaPPmzXK/DlVVbsaMGawvM0tLS9q6davY80nKzvT0dFq4cCHzBVoSRTJWSutC8vPz6eTJkyKupZ07d6aTJ09STk6ORPVJW46IC1UggspG8KdPn6YBAwawJqmMjIxo0aJFTFx2adj54cMHGjp0KLNdW1ubVq9ezcq5Kul2efXqFY0ePZpV1zZt2tClS5eoqKio0jx4lVUuLS2NNmzYwKxGB76ECV61ahVrjkvSdn78+JFGjBjB7BNeFCcNfQKBgHx8fGjYsGGse83AwIBmzJhBPj4+leL6EXEELwJFJ/iioiK6deuW2K+hTp060fHjx5mehjTsjIyMpFmzZjEhfJWUlGjSpElil59Lql2Cg4Np2LBhrEnb3r17k7e3N2tsVt4E+LPI5eXl0cGDB1kLifT09GjZsmWUnJwsNTsfPXrECmthbm5O+/fvp/T0dKm1S0xMDK1evZr1ZSxcygpd/b36JClHxBG8CBSR4HNzc8nNzY2mTp3KWrQBfEmGvHDhwnK5gUrCTuHP9G8FkJKEvgEDBrDqO2TIENZEu6T1cXLllysqKqKzZ89SkyZNmON0dHRo/vz5UrNTXGA64TUW0mqXoqIiunPnDjk7OzP5YktKs2bN6O+//6aAgACFWvlMxBG8CBSB4AUCAb1794527txJAwYMYLmulXwqlvyWtp0FBQX033//sfTb29vTvXv3pKKPiOjp06csfTwej0aMGCGVaITSkhMIBJSRkUHh4eH07Nkz8vLyohs3btCFCxdYQcqOHTtGFy9eJDc3N/L19aWgoCCKjo5mORcoYv2EUVxcTJcvXyZ7e3uRHm50dLRU7MzPz6ft27ezVkYDEMkqJil9woiLi2PkSvvvW1lZ0cSJE+n8+fMinjgcwSsA5EXwHh4etGPHDho2bJjYsLCWlpY0depUun37NqWlpUn9RinJ1iOcaBkAHT58WGzi4x/VR/RlSb2zszNL36+//kqvXr2Sir4flYuNjWXkFi5cSM7OztSpUyeqXbu2WNfUihZdXV1q2LAh9ezZkyZOnEirVq1i9pV3XYcs20UgENDVq1epadOmjJyenp5IzlZJ2pmens76YgBAffv2LdPj5kf1lZb79OkTHTlyhAYPHsyK5VRSGjduTFOmTKETJ07Q8+fPKw3B84iIUAXB5/Ohr6+PjIwM6OnplUsmOzsbOjo6AICsrCxoa2uLHENESElJQUREBD5+/Ih3794hJCQEly5dEntONTU1dOrUCT179kSvXr1gb28PHo9Xbn0/YueNGzfw119/ISQkBABgYmKC5ORkqegDgKioKKxevRrHjh2DQCBg7ZOGvu+RS0hIgL+/P168eIEXL14gJCQEMTEx3zy3lpYWjIyMoKurCx0dHWhoaEBJSQk+Pj4AgC5dukAgECA7OxtZWVng8/lISUlBUVHRV8+rrKyM+vXrw87ODi1btkTLli3RqlUrsbZLs13EITMzU+TZMTY2xuLFizFjxgxoampKVJ+wnJKSEnMPDR8+HKtWrUKDBg2kpk9YLi8vD97e3rh37x7u3r2Lly9flnmOcePGoXnz5rC1tUWdOnVQu3btMvV/r53A9/EZAHA9eCG8efOGecO6uLjQ+PHjaejQodSrVy9q3bo11axZ85tZe6pVq0ZOTk60du1a8vHxKXOilEh6Qwpubm6sLEUlvS/hFHqS7HkkJCTQrFmzWL3dfv36MaErJK2vInIfP36kQ4cO0ZgxY0SCk4krEyZMoI0bN5Krqys9fPiQIiMjWR5FFbFTIBBQeno6vX37ljw8POjYsWP0999/08iRI79qg4qKCrVq1YrmzJlDV69epbS0NIm3S0Xljh07xsrZamFhQXv37hW7QlUS+oKCgljtpKSkRGPGjBHJLSEpfV+TS0pKoitXrtC8efOoY8eOX00YU/K81atXjzp27Eh9+/alkSNH0oQJE2jChAky78FzBC8EX1/fcn92W1hYUKdOnWj8+PG0bt06Zru8MhcJBAK6ffs2y5ddU1OTFi1aRCkpKRLXR/Tls3rZsmWsuYXu3btL1V+/vHITJkwQm1uUx+NRkyZNaPz48bRz507y8/OTSayWsuTevXtHbm5utHbtWho0aBBrkY4wubVu3ZoWLVok1xdmYWEhHTlyhOWJYmNjQ6dPn5ZafP3g4GAaOHAgs11ZWZnGjRvHInpZ32cl3AKAFi9eTEOHDqUWLVqw5tS+VTiC/0F8T4MIJ8RYvnw5rV+/nnbt2kUnTpyga9eu0ZMnTygyMlJk4kyeRMbn8+nq1aus5MWampo0b948kZC5krIzJyeHNm3aREZGRsz21q1b0/3796Wi71uIiYmh3bt3U/fu3UUeJBUVFerYsSMtX76c3N3dxcbRUaRJT4FAQFFRUXT27FmaOnUqq9csXJydnenSpUvl0itpO/Py8mjnzp1UrVo1Zn/z5s3p1q1bTFILSbfLs2fPyMnJifXSc3Z2ppcvXyrU9Sv5YvPx8aELFy7QkSNHaPv27fTPP//QsmXLOIKXFBTBi0YWcsIRBLW0tGjevHkUHx8vNX27d+8mKysr5n/Dhg3p8uXLUgtPXJZcbGwsbd++nTp06CCWAKdOnUo3b94s1xeVol/3mJgYOnr0KCubkvA1HzZsGLm6un73UNL32pmZmUlr165lhQru0qULeXh4SK1d/P39qV+/fqw26Nu3r0Jfvx+VI+IIXgRVleDT09NZQ0LAFy+NxYsXU1JSklTszMzMFCGWmjVr0tGjR6USnrgsuYyMDDp8+DB1796dtVgK+BKjZ+3atQp//SQl98cff7CSbQBffNfHjh1L7u7uMs14lJycTAsWLBDxK5dmuwQEBNCQIUNE7oMzZ858Myjd9+iTpxwRR/AiqGoE//79e5o9e7ZIDOxVq1Yxk3DSsNPT05NatmzJyBkZGdHWrVvF+ndLQl9pOT6fT/fv36dRo0aJTG516NCBduzYwcQcV+TrJw05gUBAz58/p0WLFonMN1haWtKSJUvo/fv3MrMzOjqaJk2axMo2NWrUqG+mFPxefURfHCPGjBnDqruNjQ3t2LHjm2Gt5X39KgKO4EuhKhB8UVER3bhxgxwdHVk3sPCwjLTsfPHiBfXu3VukR1Y6QJSk9JUlV5q4GjRoQOvWrROJzyMpfZVVTiAQkJ+fH02bNo01NwJ8CbIlSztfvHjB0q+mpkZz586lz58/S0WfsJzwRKeOjg5Nnz69zIV1inT9vgWO4EuhMhN8ZGQkrVy5kjXWzePxyMnJiW7fvs0aMpG0ne/fv2cFhFJVVaUpU6bIpF0EAgF5e3vTkCFDWAShp6dHU6dOJX9/f4VaQq6ocnl5eXThwgXq27evSO7WuXPnin05SsvOLl26ML91dXVp1apVxOfzpaYvMTGR9uzZQ40aNWLVu3379nTkyBHWnIyiXj9x4Ai+FCobwcfHx9Px48dFPEGMjY1p3rx59OHDB6naGRMTQ5MnT2aWbPN4PBo1ahSFh4dLvV2ys7PpwIEDrFgoJWX//v1lTh5+r76fSe7Tp0+0dOlSVpvyeDzq378/3b9/X+ovzMzMTHJ3d2eFPzA1NaVt27ZJ1RtNIBCQh4cH/frrr6SiosLs19bWpnHjxpGnpyfL3VFRr18JOIIvhcpA8ImJiYxc6QVU3bp1ozNnzkg9lsnnz5/pzz//ZE2QlV4iLq12iY2NpSVLlrCGFLS0tMjFxaVSPHiVUa50B6Jx48Z06NAhqd9n4kJm1KhRgw4dOsSkm5RWu8THx9M///zDipoJgBXwr6yviu/RJ2k5Io7gRaCoBB8fH09Hjx6lQYMGiXgd1KtXj1avXv3NT2hJ2BkTE0MrVqxgTdp27tyZfH19paJPWC4kJITGjh3LhCoGvoy1b9myhdLS0iolcVYmubdv39KMGTNYC9SqVatGq1evZgXWkoadBQUFdODAAdaCrrp169KZM2dYuXil0S4l8xS///67SPYwMzMzmjZtGrm5uX119XlF9ElKjogjeBEoCsFnZ2fT3bt3afHixdSiRQvWTSVcHj58WK48mZKyU19fn/ndokULcnNzK1O/pD7Vvby8qE+fPqx6d+7cmS5fvixTtz5O7gvS0tJo8+bNVKNGDWa/lpYWzZw5kyIiIqRqZ05ODm3dupWVzk943Fza7ZKfn89KfSlcNDQ0yNHRkbZs2UIBAQEiQfk4glcAyIvgQ0JCyNXVlebOnUvt2rVj9VJLSqtWrWjlypX0+PFjmd0oWVlZtGbNGpYdDRs2pAsXLnzzxSKJdhF2tVRSUqJhw4aRv7+/1PRxcuWXKygooDNnzrDGyZWVlVmxYKRlJ5/Pp9WrV7M6HADo3LlzMu3wXLlyhaZMmcJ62ZUUQ0ND6tOnD61Zs4bu3r1LkZGRHMHLG9IkeD6fTyEhIXTjxg3aunUra8xYXLGysqKxY8fSsWPHWOEDZPGgZ2Zm0qZNm8jU1JRl06FDh6S6IKSwsJAOHTrE0qmurk5Tp05lTRhLSh8n9+NyAoGA7t27J5LoHQD5+PhI1c7U1FRauHAhS2eLFi3o2rVrMumAlMgJBAIKDQ2lTZs2Ud++fUXWnZQuM2fOpAMHDtD9+/cpLCxMKknMibhwwSL4nvCab9++RcOGDQEALi4uAMCEfs3IyEBSUhKSkpKQlZVV5jlUVVXRrFkztG3bFu3bt0f79u1Rp04dJkSwMKQZ/pXP52P37t3YsmULUlJSAADW1taIiIiQir4SFBQU4OTJk1i/fj3Cw8OZ7fPmzcPChQthZmYmUX3SkisqKkJSUhLi4+ORnJyMlJQUpKenIysrC9nZ2cjPz0dubi7+++8/AMCsWbOgpaUFTU1N6OjoQEdHB0ZGRjA2NoapqSksLCxgaGgIHo+nEPX7Fp4/f461a9fi2rVrzLZevXrhr7/+QqdOnaRup5aWFnJycgAAdnZ2WL58OQYPHgwlJSWp6CtLrrCwEMHBwXj8+DEePXqE58+fIyws7KvnNTIygpmZGUxMTKCvrw9dXV1oaWkBAA4fPlxhOwEuXLAIvueN5+fn99W3tXAxMjIie3t7+vXXX1k9j/KuKiWSTo8sKSmJli9fzvrktbW1paNHj0o152VeXh7t3buXatasyWojaemThFxeXh6FhITQ8ePHGbl27dqRhYWFiP+4JIq6ujrZ2tqyPFkuXbpEHz9+LFfyFXn2/IXbo2vXruTh4SHVOZvIyEhavHgxqwfdsGFDOn78uEiIYlm3i3AmqBkzZpCjoyM1aNBAbKiGsgrXg/9BfM8bLzw8HLa2tgCA5cuXQ0tLC7q6utDV1YWenh6qVasGMzMzmJmZQVdXl5FThB5ZREQEtm3bhsOHDzM9nwYNGmD58uUYMWIEVFRUpGJnXl4eDh8+jPXr1yM2NhYAYGZmhgULFmD06NEwNzeXqL4fsTMoKIhJ9hEUFIQ3b958NSGHsrIy0xMzNjaGgYEBk/BDXV0dAoEAO3bsAPClB6+kpIScnBxkZ2eDz+cjNTUVKSkpSEpKQmpq6ldt19XVRbNmzWBnZ4c2bdqgTZs2qFevHqvHKs/7LDQ0FDt37sTRo0dRWFgIAOjUqRNWrlyJHj16sL5QJWlnamoqtm/fjv/++w8ZGRkAgFq1amHevHmYOHEitLW1FeL5A8AkA0pMTERiYiKSk5ORmZkJPp+P3NxcZGdn459//qmwPoDrwYtAUbxopC3n4+NDI0eOZPWwWrVqRZcvX5bq7H9ubi7t3LmT5e5mYWFB//33H+NmJs92iY+Pp1u3btGiRYuoffv2Yie7gS/eRK1bt2b+Hz9+nJ4+fUrx8fHfnKOoiJ25ubn08eNH8vb2pr179zJyjRo1KjMtoKGhIfXr1482btxI/v7+CrEw59OnTzRjxgyWzR07dqR79+4xPXppXPeMjAzasGEDK0SxkZERLV++nBXmu7I8t9wk6w+iKhO88FCLcOnVqxfrQZOGncnJybRz506ysLBgtllZWdHu3bvlGie/uLiYfHx8GLnSSZSBLyso+/XrR6tWraLr16/Tp0+fpBa/vCJyBQUFFBoaSqdOnaK5c+dSx44dxX7uCw+7vX79WuZ2CiMmJoZmzZrFWqDXoUMHunv3rlRDaeTk5NC+fftYi5aEV6oq8nPLEbwEURUJPikpidatW8ciVxUVFRozZgwFBgbKxE7hROI1atSgPXv2UF5entT0fU0uOzubrly5QuPGjRPxEgJAderUoQkTJtCxY8coPDxcqi8+ScsVFBTQ06dPacuWLTRgwAARN8KS3v/ixYvpyZMnXx3Dl6adsbGxNHv2bNYLSTirmLTas6ioiC5evCiSD6Bt27Z09uzZr3qzfI8+ecoRcQQvgqpC8AKBgDw9PWnEiBFihxm+5XL4o3bm5eXR1q1bWTqtrKy+Suw/ou9bcnw+n86cOUODBg0SCR8sPCH38uVLiehTFLmioiLWF0rpSeDq1avTjBkzyNvbW2RoSRZ2xsXF0ezZs0VCbty8eVPq/uze3t4iz0W1atVo0aJFX30+KsN1LwFH8KVQ2Qk+KiqKVq9eTTY2Nqwbt3Xr1nTgwAGp21niFVN64ce2bdu+Sezfo+9rcrm5uXT58mX69ddfRYYurK2tae7cueTl5UVpaWkKc/2kLRcdHU1nz56lkSNHsjIqAV++smbPnk1Pnz6V+RBUbGwsTZs2jWVPly5dyNPTUyb+7EuXLqXq1auz9Ds4ONCxY8dEsntVlutOxBG8CCojwaemptKBAweoa9eurEw1urq6NHXqVAoICJC6neKIXfiBkXW7uLi4iCQzrlevHi1btowCAwNZpCHv6ycvufz8fHJzcyMXFxeRGCt169alFStWyM1O4cnYbxG9pNqloKCArly5Qn369GE9R9ra2jRq1Chyc3OjwsJChbl+5QFH8KVQ2Qi+V69eIkMw3bt3pxMnToicUxp25ubm0q5du1gx6C0sLGjnzp2UnJwss3ZJSEgQCakAfBkWWrBggQip/6i+qiaXn59PN2/eJGdnZ9LS0hJpx2PHjsn0C+z9+/f0xx9/sIi+c+fOYkMVS6NdPn36RGvXrhWJJGliYkLjxo1TuOtXFjiCLwVFJXiBQECvXr2ijRs3ik0Y3bRpU9qwYQNFRUXJxM6cnBz677//RNwdd+7cyXjFSLtdiouLyd3dnQYPHszyiABAzs7O5OHhofALgRRRLjMzk44dO8bK6AR8cS+cO3cuvX37VmZ2xsTEiBB9x44dyd3dXarulSUQCAT0+PFj+uOPP8ROyA8ePJhOnDhBiYmJEtEnSTkijuBFoEgEHxUVRSdPniQXFxcWkQqX5cuX06tXr2RmZ2JiIm3ZsoXlFWNpaUm7du2SmbtjcnIybdy4kerUqcNqC2G/dEUkzsosV3p8ulu3bnThwgWR1aHSsjMmJoZmzpzJmoxt27Yt3bx5U6rulcIoLCyk+/fv06RJk8Q+i3Z2drRgwQJyc3MTm9eVI3gFgLwIPi4ujnx9fWnr1q00YsQI1tL9kqKurk69evWizZs3y+1BNzY2Zn7XrFlTpu6OAQEB5OLiwpow1dfXp5kzZ1JoaGilJM7KIpeRkUE3b96k/v37szxxLCwsaPXq1TILhhcbG0tz5sxh3QNNmzaVW7ssWLCAmjdvLvKsKikpkb29PU2dOpWOHj1KoaGhMp/MJ+IIXgTSJPjc3Fz68OEDeXh40MGDB2nWrFliewIlRVlZmdq0aUPz58+nu3fvymWlZ2JiIs2fP59lV506dejgwYPf9BmWhJ3p6el04cIF6tSpE8sGe3t7OnToEOu8lZE4K6NcVFQULVu2jLU6VE1NjcaNG0cvXryQiZ0JCQk0f/58VvIRALRv3z6xXxU/qu9bcgkJCXTq1ClycXER8WArKcJzZUuXLqUzZ87Q48ePKSYm5qurnzmClyC+p0HevHnDXIAJEybQhAkTaPjw4dSnTx/q2LEj1atXT8RLQVyxtLSkgQMH0rp16+ju3btSTTL8LbmPHz/SH3/8IeJeePDgQSZVmiT1lSUn7JWjoqJCI0eOpEePHomdMFUUAvxZ5PLy8ujUqVOsBUoAWC9jaduZnJxMixYtYumvUaMGbd++XcS9URL6yisXHR1N58+fp/nz51Pnzp1JV1f3m505MzMzatq0KXXt2pX69+9Pv/32G02aNIkmTpzIEbykIO1oklpaWtSgQQNydHSk6dOnM9u/NjlaGtK8MV+8eCESo0Y4o5S0H9hPnz6JfNkYGxvTsmXLKCYmRuL6ODnJyD158oScnZ1FJru3b98u0+Tnwl8VhoaG9Ndff7GGjyStr7xyJU4SJXJjx46lzp07U61atcSGxyircAT/g/ieBhEOWrR8+XL6559/aMeOHXTkyBG6ePEieXt706tXryg5OVkh/a+Li4vp+vXr1LVrV9bN1KtXL7p//75MJrECAwNp1KhRIjf7zp07v5nr8nv0cXLSkYuOjqa5c+eKvKBXrlxJSUlJUrczOTmZ9u7dy3JvVFdXp4kTJ4qsUlaU9iwqKqKYmBgKDAwkd3d3Onv2LB04cIC2bNlCa9eupaVLl8qc4LlwwUJQlLCjFZUTCAQ4evQodu7cySQjUFFRwfDhw7FgwQLY2dlJ1U4igqenJzZu3Ii7d+8y2x0cHODj4yNxfdKUS0lJQVpaGuLi4hAfH4/ExESkpqYiLS0N6enpyM7ORk5ODvLz85Gfnw8/Pz8AQOfOnaGurg5NTU1oa2tDW1sbhoaGTNIPc3NzVK9eHZaWlkz46crULrVq1UJUVBQAQFNTEy4uLvjzzz9Rp04dqdpZXFyMq1evYtOmTfD392eO7dmzJ2bPno0+ffogNze3Uj63XLjgH4AiuUlKU27KlCmscUF9fX1asGABffr0Sep2FhUVkaurq0i+1ZEjR9Lz588Vtj2Li4spLCyMrly5QuvXr6fRo0eX+9NaEkV4km7KlCn033//kYeHh0x6xt8rl56eTufPnxd7rUsHupOGnQKBgPz8/Gjw4MGsYUdbW1v6559/FPI+k5Qc0ff34FXK/yrgoAjIz8+Hq6sr83///v0AgPr162PWrFkYO3Ys00uQpg0nTpzAxo0bmS8GTU1NTJw4EfPmzYO1tTWALz0WeYOI8O7dO/j7++P58+d48eIFQkJCvmqbpqYmLCwsUL16dZiZmcHY2BhGRkYwMDCAtrY2tLS0oK6ujqKiIowfPx4AcPToUaioqCA3Nxc5OTnIzMxEeno6UlNT8fnzZyQkJCA+Ph4JCQlMwgzg/69fCczMzNCiRQu0bNkSrVq1Qrt27cqV5lDaKPkiHDZsGLy9vbFx40bcuXMH586dw7lz59C7d28sXrwYDg4OUtHP4/HQsWNHdOzYEREREdi9ezcOHTqEsLAwLF26lDnO398f3bp1E5si86dEhV4HlQhVrQcfHBxMc+bMYfmvA6B+/frR3bt3ZbbSc+3atazFMkZGRrRixQqxvU95tufq1avJycmJlTZQuKirq5OdnR2NGjWKli9fzmyPiIiQavTDwsJCev36NSM3Z84cGjBggMhiL+FSp04dGjNmDO3evVuh7s/AwEBydnZm9ahLwvXKws6srCzav38/NWnShNVejRs3pq1btyr0FxE3yfqDqAoEn5CQQDt27GB5vwBgxYOXhZ0REREipGNlZUXbtm37qgubLNpTIBDQ27dvaceOHeTo6CiWIDU0NKhTp040d+5cOnXqFL1+/ZrlIqoo1z0zM5MeP35Mu3btIhcXF2rcuDErWJZwGT16NJ05c4aSk5NlbmdphIeH0/Tp08UmKZFFjmJh5wHhFbIqKio0aNAgunjxosjq7B/RxxG8AqCyEnxKSgodOXKEevXqxeoZqaqq0pAhQ+jGjRtSTZ4tjKioKJo5cybrwa1bty4dOXJErgkV8vPz6e7duzRz5swye75OTk60detWevr0qUwWcklLLj09ne7cuUPLli2j9u3bi9RTSUmJ2rdvT2vXrqWQkBC5ritISEigJUuWsOaErKys6L///iuXi6Uk7IyJiaHdu3dTq1atWO2kr69PEyZMoDt37jALqBT5upcGR/ClUNkIfvv27dS7d28R/+O2bdvSf//9R58/f5aZnS9fvqSxY8eK2CLP9szOzqYLFy6Qs7OzSPxzNTU16tGjBysKpSI/sJKQmzVrFmtpf0mpU6cOzZs3jx4+fMgM28naztjYWBG7TExMaM2aNZSamipxfWXJhYaG0sKFC1kRUoEvw4ouLi507ty5SnHdiTiCF4EiE3xRURE9evRIZOVeSWnWrBmtWbOmzGw00rLTz8+P+vfvz7KlR48edOPGDbk9CKdOnaKhQ4eKhL41MzOjSZMm0dWrV5lhospI1D8qFx0dTQcOHKB+/fqJZFOytLSk2bNnk6enp1w7LtbW1sx/HR0dmjdvHkVHR0tFnzi54uJi8vb2pmnTprEWUAmXLVu2UFhYmET0SVqOiCN4ESgSwRcWFlJAQABt3769zPyarVq1on/++eebIVwlbWdxcTHduHGDtSydx+PRr7/+Sk+fPpW4vm+hqKiIrl+/LvYhrF27Ns2fP58ePXokdlJZEQhXnnJZWVl06dIlGjVqVJlL6kuSxsjSzsLCQjpz5gw1a9aM2a6qqkrjx49nRVCVRXsWFRWRl5cXzZo1SyRbGfAlQ9iECRPo5MmTFBkZqRChNIgUiOCLiopo+fLlVLt2bdLQ0KA6derQ6tWrWQ0lEAjor7/+InNzc9LQ0KAePXrQ+/fvWedJSUmh3377jXR1dZnxs2/FpBCGvAiez+dTWFgYubq60qJFi6h79+6sXKElxcDAgIYMGSI3gigZ62/YsCGzTU1NjSZNmiTykpHFDf3mzRtauHAhawK5pBe6YMECev78uUxSvlUVudzcXLp+/Tr99ttvIl8/rVu3pl27dlFKSopM7RQIBOTm5kYODg4se/r160c+Pj4yCxdcAmF9nTt3FjskaWFhQb/++iutX7+e7t69S58/f/65CX7dunVkbGxMN2/epIiICLpw4QLp6OjQjh07mGM2bNhA+vr6dPXqVQoODqYBAwaQtbU1a6bb0dGRmjdvTk+ePCFfX1+ytbUlZ2fnctshTYIvWZL85MkTOnv2LP3111+MXOlE0CVFX1+fHB0d6d9//6Vnz55RUVGRXAlC+FNVT0+PFi5cSLGxsVLTJ06Oz+fTwYMHqV27diIvP+EXpqT0/axyiYmJjJzwxL2amhoNHz68TDdbadr5+PFjGjJkCMtLSJaxksTJ8fl8cnNzowULFlCbNm3EEn7pZ2f9+vV0/fp1Cg4OFglhIik7iRSI4J2cnGjChAmsbUOGDKFRo0YR0Ze3uLm5OW3atInZn56eTurq6nT27FkiIsZP+NmzZ8wxt2/fJh6PVyYJ5eXlUUZGBlOio6Mr3CDiokmOHDmS+vXrR126dKHGjRuTmZnZN4MKqampUcuWLWny5Ml04MABCg0NlfuQwvv372ny5MkiveONGzd+s40kaadAICB/f3+aOHEiK0SssrIy9e/fny5dukQpKSmVgjgro9zHjx9p+/btIrHPa9euTatXr2YFgpOFne/evaPJkyeLzB+sX7++3M+utOzMzs4mHx8f2rhxI40YMaLM8MHCRUNDg2rUqEH29vbUo0cPGjRoEI0ePbrqRJNct24d1apVi969e0dEREFBQVStWjU6deoUEX3xmQUgsry5S5cuNGvWLCIiOnz4MBkYGLD2FxYWkrKyMl2+fFms3pUrV4pt8Io0iK+v7zcvoDAh1axZkzp16kSjRo1itr948UKmYXi/JicQCOj+/fvUv39/EX/q8sSBl6Sd8fHxtG/fPrKzs2PZUb9+fdq4cSPFx8dLVB8n9225wMBA+uOPP1hfTMrKyjRo0CC6c+cO8fl8mdmZmJhIS5YsYd0burq6NHv27G9OfsqyPTMzM8nHx4eRGzx4MNnb24tNA/i1UmkJvri4mBYtWkQ8Ho9UVFSIx+PRP//8w+x/+PAhAV8yHwlj2LBhNHz4cCL68pKoV6+eyLlNTU1pz549YvVKogf/4cMH5gIsW7aM1q5dS9u2baNDhw7RuXPn6P79+xQUFERxcXGswP6K8sAK7xe3wq93795ys1N4HkJdXZ3GjBlDDx48UIhJrJ9dLicnh06ePCmSu1XY+0XWdtavX5/5zePxqH///nIZSqqIXG5uLn38+JGePn1Kbm5udOrUKdq3bx9t3ryZ1qxZI5dokhIn+LNnz5KVlRWdPXuWQkJC6MSJE2RkZETHjh0jIukRfGkokheNrOTevn1Lc+bMYXnpaGtr0/Tp0+nNmzcys7OwsJAuXbokQhj16tWjrVu3ynxyj5Mrv9yrV69o1qxZIp5eY8aMKbcHjiTs5PP5dPv2bZHVyfXq1aPt27ezVsgqcntKQo5IgQjeysqKdu3axdq2Zs0aql+/PhFJb4imNH4Wgk9JSaFz585Rt27dWA+CjY0NbdmyRaYPQnJyMm3YsEGs+9mNGzekGuOFk5OsXFZWFu3atUvkOnbs2JHOnz//1XR60ui4/PHHHyzXT01NTXJxcaEnT57I3PvmpyZ4IyMjkV72P//8Q3Xr1iWi/59k3bx5M7M/IyND7CTr8+fPmWPc3d2/OslaGj8LwQsH01JSUqJ+/frR7du3ZfopGxISQhMnTmSFNDAxMWHlgK0s7cnJiZcbNmwYy6vE0tKS1q1bx1phLW07+Xw+7dmzR2TosVGjRpWuPSstwY8bN44sLS0ZN8nLly+TiYkJLVy4kDlmw4YNZGBgQNeuXaOQkBAaOHCgWDdJe3t78vf3Jz8/P6pbt67CuEnKSy45OZl27txJ9vb2rBvcwsKCli9f/s10gZK0s6ioiK5duyby5dCiRQs6fvw45ebmKnx7ipO7du0aHT58mNatW0ezZ88mZ2dncnR0pHbt2lGjRo2odu3aVK1aNTIwMGB5Aeno6JChoSFVr16dbGxsqGnTptS5c2fq378/jR8/nhYuXEibN2+m06dPk7u7e6Vrl6ysLIqLi6OVK1eSmZkZs11DQ4MmTpxIISEhMrNTIBDQw4cPacyYMSIBzvr3709Xr16Va6wkScsRKRDB8/l8mj17NtWsWZNZ6LRs2TJWg5csdDIzMyN1dXXq0aMH43VTgpSUFHJ2diYdHR3S09MjFxeXSrHQSdJyWVlZdPbsWerXr59Yv9yLFy/K1GsnPj6eduzYwXIZU1ZWpmHDhpGfn59CpjIsgUAgoE+fPtGtW7do8+bNNGHCBOrUqVOZy9dlUaytral37940e/Zs2rdvHz148IDS09Nl2i4VlcvLy6MTJ06wkn8A/x/WQpbeN2lpabR161aRdjU2NqapU6fSgwcPygylrSjtWR5wKftKoTKn7MvKyoKbmxsuXLiAW7duITc3l5Gxt7fHyJEjsWjRIrnYqauri8zMTACAoaEhfv/9d8yYMQM1a9aUir7vlcvMzERKSgqePn2KZ8+e4cWLFwgKCkJqaupXz9GwYUPUrFmTSfZRrVo1JtmHnp4ek/BDTU0NBQUFaNasGQAgODgYampqyMvLQ05ODrKzs5Geno709HSkpKQgMTERiYmJiIuLQ1RUFCIjI79qR+3atWFvb49WrVqhdevWaN26NVRVVRXi/iwBEeHRo0fYvn07Ll++DIFAAACwtbVlEsHI2s5Zs2bh/PnzSExMZPZbWlri119/xbBhw9C+fXsoKytLTJ8s5AAuZZ8IKlsP/sOHD3Tw4EFycnISWfRhbW1Ny5YtY+J2yMrOkjRpgwYNYtlTv3592r179zfPIcv2LC4upkePHjFywsMIwkVFRYUaN25Mw4cPp5UrV9KZM2dYfs2yvu5ubm508OBBmjdvHvXp04dq1qwp1m4ej8cKK1H6i1fadn5LLjIykv78808R75s5c+aITR8pTTsLCwvp7t27NG7cOJGYPNWqVaNJkybR9evXWSt8q2oPniN4IcjywuXm5tKtW7fK/HS3sbGhRYsWiY3BIm078/Pz6dSpU9S6dWsRuy5dulSu7FHStlMgENCHDx9oz549NHjwYDI0NBRL5i1btqSpU6fSoUOHKCAggPLy8mRq5/fIpaamkpeXF23ZsoVGjhxZZsx7Gxsbmjx5Ml24cOGrrqeyrB+fz6fNmzez7FRWVqYRI0bQ48ePJa7vW3J5eXl0/fp1Gj16tMjLR01Njfn95MkThfXyIuIIXgSKRvBZWVnk4eFBf//9N/Xo0UNs9ps2bdrQ2rVrKTQ0VCoxLb4ll5SURGvXrmUF/FJXV6dx48YpBAHm5uaSm5sbzZw5U+yyceFJzzt37lBOTo5c7JSGXEJCAisVXumVyUpKStShQwdas2YNvXjxQmHmQrp06cKys23btnTmzBmxbpay6Ljcu3ePZsyYQbVq1RK5f8zMzGj48OG0c+dOCgoKYi1mlKWd4sARfCnIk+CzsrLo8ePHtHfvXvr999+pWbNmrCBPwjdUye+PHz/K3M4SBAUF0YQJE1hDQ9WrV6c1a9ZQUlKSXAni06dPdOzYMRoyZAiLwIEvIWcdHBxo7dq19OTJE5llulIEubi4OLpx4wbNnj2b5SZYUqysrGj69Onk7u5OaWlpcq1fUFAQubi4sHrMFhYWtHbtWlbeVFm2p0AgoOfPnzNy4jpc2tra5ODgQAsWLKAzZ84wqR45glcASJPgBQIBpaSkUEhICN28eZM2bdrEyNWsWbPMPJpWVlbk7OxMe/bsoVevXsl1gUZ6ejpdvHhRJHRrq1at6OTJkyyvJ1nf0B8/fmT1TIXts7S0pMmTJ9PVq1dFIk1WRqKWlNynT59o//79NHDgQJEXofDQxLdWEUvTzoSEBFq1ahWrY6Ourk7jx4+ngIAAubZnSkoK+fj40Jo1a6hXr15iQ3wDX4Z1hF+ou3fvJk9PT3r//v03dcuD4DkvGiG8ffsWDRs2BABMnDgRABiPiKysLKSkpCAlJQWfP39Gfn7+V89lbm4OOzs72NnZoU2bNmjTpg0sLS1Zx8hzFt/CwgJxcXEAAGVlZQwZMgSzZ89Ghw4dwOPxZG5nWloaLl26hPPnz8PDwwPCt2XTpk0xePBgDBgwAC1atBCxT5Z2Vga5vLw8eHh44Nq1a7h27RqSkpKYfbq6uhg8eDCcnZ3Ro0cPqKqqytzO/Px8uLq6YseOHXjx4gWzvW3btvD395e4vu+RKy4uxtu3b+Hv74/nz58jKCgIwcHByMnJ+eo59fT0YGxsDBMTExgaGkJbWxs6OjrQ0NAAEeHQoUMVthPgvGhE8D1vvIpEkwS+rNa0s7OjAQMGMNvu3LnD+uz8GmTVYylZGDJixAgR+5cuXSo2fZos7MzNzSVXV1caOHAgqaqqim3joKAgien7GeWKiorozp07YtvW1NSUZsyYQY8fP5ZL0DeBQECPHj2ikSNHiqzxWLhwocy9b76FoqIi+vjxI126dImR++WXX6hevXoiX03fKlwP/gfxPW+8sLAw1K1bFwCwbNkyaGpqQktLCzo6OtDR0YGRkRGMjIxgYmICCwsLqKurA1Dcnhyfz8fp06exf/9+BAcHs/YdPHgQo0ePhoaGhkztpP/5Th8/fhyurq7IyMhgjm/atClGjhyJ/v37M/7litSeVUHO3d0d165dg6urK5KTk5lj6tati9GjR2Ps2LGoXbu2zO2Mj4/H7t27sW7dOmabkpIS+vXrh6lTp6JXr16M/7ok9ElajoiQmZmJuLg4pKamIiUlBWlpacjOzkZ2djby8vKQm5uLf/75p8L6AK4HLwJF86KRlZxAIKAnT57QpEmTWL0KDQ0NGj16tNzsfPfuHa1du5ZsbW1ZPZkaNWrQ4sWLZbrUnZMjKigooNu3b9OoUaNEUvp169aNTpw4QUlJSXKzs3Qk0lq1atHq1atlmqxbUeSIuElWEfxsBJ+UlETbtm2jpk2bsh6MBg0a0LZt2yglJUXmdqampor9PNXW1qbx48eTp6enQsf3/lnkMjMz6cSJE9SjRw+Wg4DwIqGKhAmRlJ2vX7+m2bNnsxKSKCkpkZOTE128eJFxBFC09pS0HBFH8CL4WQj+zJkzNGjQINYYpoaGBo0ZM4Z8fHzk4g/95s0b+vPPP8nY2JhF7A4ODnTs2LFvkkVlvA5VRS4yMpJWr14tsriqcePGtGPHjnJ54UjazpycHDpx4oSIT72xsTHNmjWLHjx4oLDtKQk5Io7gRVBVCb64uJgVjVC4tG7dmnbv3s2KAS8rO3Nzc+nUqVMin9YlJTg4WKL6ODnp32dubm4i17Gk8+Dr61vmYjxp2vn27VtatGgRVa9eXex9JjzUJwl9iiBHxBG8CKoSwQsEAnr8+DHNmzePrKysWDe0ubk5LViwgEJDQ+Vi55s3b2ju3LkicekHDBhAFy5cUMj25OQqLrdlyxaRRN2NGjWiHTt2UGpqqsztLCwsJDc3Nxo5cqRI7KY2bdrQ5s2bKTIyUmL65ClHxBG8CCo7wRcWFpKnpyfNmjVLJEOS8NioPOqXn59P586do65du7LsqlGjBq1evZpiYmIkqk8R5AQCAWVlZdHnz5/p06dPFBYWRgEBAYxcYGAghYeHU0xMDKWkpFBubq5cerjSlBMIBOTv708TJkxgTcxqaGjQ+PHjyd/fn2knWdoZFxfHyJVeZNimTRtav349vX79WuYxnSQlR/T9BK8CDgqD5ORkuLu7w83NDbdv30ZaWhqzT0dHB/3798ewYcPQpUsXmJiYAECZrmPSwsqVK3Hy5Elm8YySkhKcnJwwZcoUODo6ytyeHwWfz8fr16+Z/ytWrEBycjKSkpLw+fNnpKSkID09HXw+nwmHKw729vYi21RVVWFgYAADAwOYmprC1NQUZmZmMDU1ZY4JDw9HgwYNoKamJtmKSQE8Ho9ZtLd161bGBTckJATHjh3DsWPHYG9vDxcXF5naJew2GBYWBjc3N1y8eBEPHjzA06dP8fTpUyxZsgR169aFk5MTnJyc0LlzZ5naKDdU6HVQiVAZevCfP39m5Ozt7UV6HyYmJuTi4kLXrl1jZbuSpZ1FRUXk6urKsgv4EqtmxYoVX12Moig9pJJEH25ubrRp0yZycXGhjh07kqmpqUi9ylPU1NRIR0eHFQJAT0+PtLW1SVlZucLnU1JSYhJ/zJw5k/bt20d+fn4icymK0p7CKFmsNGbMGJGhEuBLlEZ52RkfH0/79u2jPn36sOLgACAtLS3q2bMn87902AtZ2lkecD34SoDk5GQ8efIEjx8/xoMHD5hl2QAQGBgIAGjWrBn69u0LJycnVnICWSM+Ph6HDx/GgQMHEB0dzWzv3r07ZsyYgf79+391mbu8cfnyZYSGhiIgIACBgYFfTfRhZGTE7J8yZQpq167N9LRNTExgYGAAfX196OrqQlNTU2zCiLi4OGbhSmFhIXJycpCRkYGMjAykpaXh8+fP+Pz5MxISEhAZGYnjx48DADQ0NJCXl4eIiAhERETA3d2dZZu1tTXs7e3RsmVLNG3aVOLt9KPg8Xho37492rdvj23btuH48ePYs2cPwsPDAQDt2rVDx44dMXXqVAwdOrRcC+skBXNzc0yZMgVTpkwBn8/HvXv34ObmBjc3NyQkJODevXvMsbVq1YKDgwM6duyIDh06oEWLFjK1VVrgVrIKQVIr27S0tBAbG4uXL18iODgYL168wIsXL/Dx48cyz3HgwAE4OTnBwsJCZnaWlhMIBPD09MS+fftw7do1FBUVAfiSualkuEiS+iQhV1RUhMDAQPj6+sLHxwfXr18Xe5yKigrq1auHJk2aoHHjxqhfvz7q1asHGxsbKCsryzXzVFZWFj58+ID379/j7du3ePXqFV6+fMl6sZbGuHHj0LVrVzg4OKB27dplxueRlJ0VkcvMzGSeOSUlJWZoy9jYGOPHj8fkyZNRr149udkpEAgQGhqKW7duYdmyZWKPUVVVRdOmTdGyZUvm5dq4cWPo6+tzGZ0UAdIeosnOzqbw8HDy9vamAwcOMHKtWrViLcwoXRo0aEAuLi506NAhCg4OVohP7sTERNq4caNIjPWOHTvSiRMnKDk5WSHsJPrivhcUFESbN2+mvn37imTsKSl2dnY0depUOnjwID1//lxsog9p2ikJuZSUFPLw8KBNmzbRyJEjqXbt2mLrWqNGDRozZgwdP36cmeBWlPp9+PCBVq9eLeIo0L17dzp//rxco5YKy3l5edG///5LgwYN+mqOXisrK1YE1hMnTtDTp08pJibmm7mR5TFEw/XghVA6miSPx0Nubi4TTTItLQ1paWlITk4Gn8//6rmUlZVRr149NG3aFC1atEDLli3RokULGBkZMcfIM4YGn8/H06dPceDAAVy5cgWFhYUAvkxYjRkzBlOmTGGGBOQd6yMnJwfu7u64c+cO7t69i8+fP7OONzAwQKdOndCmTRusWLFCbnbKUm7OnDnw9/fHs2fPmC+tEjRs2BCOjo7o06cPOnfujOLiYrnXr7i4GLdv38a+ffvg5ubGRAs1NTWFi4sLJk2aBAsLC7nbCQBEhMjISObLOygoCC9fvkRMTMxXz8fj8WBiYgIjIyMYGhrCwMAA2tra0NbWhoaGBgQCARdNUlL4njeen59fhSbHNDU1ydbWluUueOrUKQoJCflqj7EE8uyxlO4NtmrVig4dOiT2fLK2UzhOfuvWrUUmn7W1talv3760ZcsWCggIYDLvKGpPXJpyWVlZdPfuXVq8eLHYttLS0iInJye52ymMyMhIWr58uchiJeFFcopgZ2mkpqbS48ePaf/+/Yxc27ZtycLCosKT61wP/gfxo9Ekly5dykST1NbWhpaWFhNN0sjICNWrV4euri54PJ7C9wALCgpw69YtHDhwAHfu3GG26+np4bfffsPkyZPFuvnJ0s7i4mL4+fnh6tWruHz5Mj59+sTab2dnB0dHR/Tu3RsdOnQQ61ao6NdBFnKpqanw8PDAnTt3cOfOHSbmfwlat26NX3/9FYMHDxY7Di4rO4Ev8yfC96WwG+rvv/+OqVOnwt7e/qvzC7KwszxyAoEAycnJSExMRGpqKtLS0pCeno7s7Gzk5OQw0STXr19fYX0A14MXQWVwk5S2XFBQEM2ZM0esO+D+/fspOztbrnYWFhbSvXv3aPLkyWWOe/73339ix5VlaWdllRMIBBQQEEDLly8X27ZNmzalv//+m169eiX3+n369ImWLVsmYmOzZs1o69atlJiYKFF9lUmOiFvJKoKfleDj4uJo8+bNIsvKzczMaM6cOXK3s6ioiDw9PWnKlClkYmLCstHQ0JDGjh3LSi4t7/asanLbt2+nXr16iSTYaNy4Ma1atYrev3+vEHYOHTqU5buuoqJC/fr1o/Pnz4skU6+M14Ej+B/Ez0Tw6enpdPToUerZsycrh6mamhoNHTqUbt68KZdkwcJyPj4+NGfOHJFxV2NjY/r999/J3d2dCgoKJNounFzZcikpKXTs2DFycnISyabVokUL2rRpE71//16udqakpNCePXuoTZs2LPv09PTIxcWF7t27R0VFRQrRntKUI+IIXgQ/C8H369dPZAVhhw4daO/evSKhXWVtp7AbqHAxMDCgCRMm0N27d8W6llXG61CZ5dLS0ujo0aPk6OhY5mRheYfJpGXnmzdvaOnSpVSzZk2WXWZmZvT7778rVHtKWo6II3gRVEWCT01NpePHj1Pfvn1FHsCGDRvS2rVrKSwsTK52pqSk0O7du6ldu3Ys+zQ0NGjkyJF0/fp1lu+zvOzk5MQjKSmJ9u7dS506dWJdPzU1NRo2bBhdv36d+dKSh53FxcX04MEDmjp1KiuCaUmZOHEi3bt375s2SttOScoRcQQvgqpC8OHh4bR9+3bq3r27yLgpAFqwYAEFBweXGblQFnYWFBTQtWvXaMiQIazPfWGXvfj4eInp4+RkI/f69WuxvXlTU1OaPXs2BQQEyCVZdwmE0w6WttHAwIB+++03OnfunFzyI0hSjogjeBFUVoLPzs6m27dv09y5c6l+/foiN27jxo1p8eLFcreTiCgwMJBmz54t4qVjZ2dHW7ZsobCwMIWwk5P7cbmHDx/S3LlzRbydmjZtSlu2bKGEhASFsHP8+PEi96OysjJ17tyZ1q9fT8+fP2fSRFaW60DEEbwIKhvBL1++nLp16yYS9U5FRYW6du1KW7duZYZf5GlnREQEbdu2TayXzrx581iZmyrLA8TJlV+usLCQbt26RcOHD2fN/SgrK1P//v3p0qVLrFy88rCzqKiIHj58SAsXLqSGDRuKdJKMjY1p2LBhtG3bNrm3Z3nBRZOsJIiLi8PTp0/x5MkTPHjwgNm+du1a5nfNmjXRs2dP9O3bF7/88kvFFjZIASVhDADA1tYWxcXFAAA1NTUMHDgQ48ePR69evaCiUrVup/z8fKSmpoLP54PP5yMrKwt5eXnIy8tDQUEBsrOzmWNdXV2hra0NdXV1aGhoQFNTE7q6utDT04O+vj4MDQ0rXax8cVBRUUHfvn3Rt29fpKWl4fz58zh+/DiePHmCGzdu4MaNG6xwHPKAsrIyOnTogA4dOuDff/9FZGQk3Nzc4O7uDi8vL6SkpODChQu4cOECIzN8+HB06dIF7dq1Q4sWLaCrqyvHGkgOVeuJVCAUFhYiLCwMr169QnBwMIKCghAQECCysrAEQ4YMQY8ePfDLL7+gbt2631y9JwuEhobi6NGjOHnyJLOtuLgYrVu3xrhx4+Ds7Cz3h/l7QERITk5GeHg4IiMjERYWxuzr1q0bPn/+jOTkZGRlZZX7nBMmTPjqfh6PB0NDQ5iamqJatWrM9r1796Ju3bqwtraGjY1NhVY3yhuGhoaYOnUqpk6dirdv3+LYsWM4efIk6x5v164dJk6ciFGjRrESncgStWvXxvTp0zF9+nQUFhbi6dOn8PLywv379+Hj4wMATBhh4Mu1atiwIezt7dG8eXM0b94cjRo1gqWlpUI8lxUBF6pACBUNU5ucnIy4uDh8+PABI0eOBAD06dMHERERCAsLEwkCBXwJn9qoUSO0adMGrVq1wvTp08ul73vtrKhccnIyzp49i2PHjiEgIEBkv7+/P9q0aSN3O8sjp6mpiYiICISGhuLVq1d48+YN3r59i/fv3yMzM7Nc51RSUoKenh50dXWho6MDTU1NaGpqMrHwvb29AQAODg4AvvT68/LykJOTg8zMTCYccHlhbm6OBg0aoEGDBmjYsCGaNGmCpk2bwtTUVO7tWR65oqIi3Lx5E4MHD2ZtV1FRgZOTE8aPH4++ffsqXKiJdevW4fnz53j27FmZQcV0dXVRv3591K5dGxcvXgQAXLt2DXXr1oW5uTkMDAykErYZ+P5QBRzBC0E4muSkSZPA4/GQl5eH7OxsZGdnIz09Henp6UhNTUVycjK+1XTa2tpo2LAh0wuws7ODvb09c5EV5YEtKCjA7du3cfz4cdy8eZMZklFVVUX//v3h7OyMYcOGyd3Or0EgECAgIACtW7cG8KXnGBoayhpGKQ0rKytYW1vD0tIS586dAwCcPn0a1tbWTLIPPT09KCkp/ZCdhYWFTBTSpKQkREREMD3+gQMHIjY2FuHh4awUjaVhbm6OZs2a4e7duwC+xE2ysbH5RqtUzE5pyG3btg1nzpzBs2fPmP0mJib47bffMG7cOFasGUV5HuLj4/HixQvmyzs0NBRhYWHM0GRZUFNTg6mpKRNJUl9fn4ljpaamBiLCwYMHK2wnwMWiEYEsokkqKSmRubk5tWjRgtm2bds2cnd3p6ioKGa2vizIc9IsMzOTnj17RjNnzhQJGdCiRQvauXMnJScny93OsuQyMjLozp07tGLFCurRo0eZceHV1dXJ3t6exowZQ+vXr6crV67Qq1ev5JYC8Wtyqamp5O/vTydOnKBly5bRoEGDyMbGRiRCZEmxsrKiYcOG0fbt2+np06dlxiNXhPq9fPmSFixYQObm5qw6NGnShDZu3EixsbEKYWdZyM/Pp5cvX9KVK1do3bp1jFyjRo2+mv+hrCKrSVauBy+E8PBw2NraAgCWLFnCRJMsKSUJlA0NDWFmZgYTExMoKysrTM+jInL16tXD+/fvmX3m5uYYPXo0xo0bhyZNmiiMnSVyfD4fDx48gJeXF3x8fBAYGCiSBFtTUxO5ubkAgEOHDqF9+/aoV6/eNyd/FaF+3zo+JCQEjx8/xp9//gngyzhx6UdXR0cHHTt2hIODA7p3746WLVtCRUVFoepXVFSEe/fu4fjx47h69Sry8/MBfBkK69q1Kzw9PRXCzorK5eXlISkpCUlJScyXfkZGBnJzc1nRJDds2FBhfQDXgxdBZXOTlKZccnIy7dmzp8zVpbdv3/5qNhp51m/RokXUtm1bsUvora2tafTo0bR3714KCgqi9PR0hb4OkpSLj48nLy8vWrduHTk5OYntRerq6lK/fv1o06ZNClm/tLQ0OnDgAHXs2FHE9qFDh5Zr1bMs7JS3HBHnBy+Cn53gMzIy6MSJE9S3b1+xK2D37t1L6enpcrdTGDExMXTw4EEaMGCA2M9aW1tb+v333+n06dMUHR0tNzsVUa4kleGOHTtoyJAhZGhoKLYNJ06cSNeuXSuXXlnWLzw8XGy4YCMjI/r999/Jw8ODSewiTzvlIUfEEbwIfkaC5/P5dObMGRo0aJBIADJ7e3vW2KEi1K+4uJiePn1Kf/31F9nb24slpKFDh9Lhw4cpMjJSbnZWRrmioiJ6/vw5bdiwgZVxrKSoq6uTo6Mj7dq1iz59+qRw9ZsxY4bIeL2ZmRlNnz6dvL29WWSvyNdBEnJEHMGL4Gch+KioKDp27Bj1799fhNTr169Pf//9N719+1budpbI5efnk7u7O02dOpUsLCxY9vJ4PGrbti2rJ1dZrkNlkZs8ebLY5N0tWrSgVatWUUhICBNfRt71KyoqIg8PD5o0aZLIF0m1atVo8uTJ5O7uLveVs9KWI+IIXgRVmeBDQkIYOeH47wCobt26tGzZMrEByORZvzNnztCoUaNIX1+fZa+2tjb9+uuvdOzYMSZrT2W5DpVVTiAQ0KtXr+jff/+ljh07injp2NjY0Pz588nT01Nh6pefn0+3b9+m8ePHi5C9sAeVuKE7WdopDTkijuBFUJUIPi8vj+7fv0/z58+nBg0aiPS+mjZtSitXrqTQ0NCvRpWUZf2ysrLo+PHjIrYCXz61J0+eTG5ubix3RXnYyckRJSYm0uHDh8V+BZaUe/fufdPtV1b1KygoIHd3d5o8eTKZmZmx7FRSUqKuXbvSxo0bWV8j8rBTUnJEHMGLoDITvEAgoNDQUNq2bRs5OTmRtrY26yYW9igJDQ1VmPplZ2eTq6srDR06lDQ1NVk216hRg+bOnUt+fn5lTpbJyk5OrmxkZmaSq6srjRw5UuS+s7S0pNmzZ9PDhw+/SvayrF9xcTF5eHiIfSmV2Dxu3Dg6deqUSMhqRb4OpcERfClUNoJ//Pgx7dy5k4YOHSo2Sba5uTmNHz+ezp07RzExMQpzY+bm5tKVK1doxIgRpKWlxbJZeKw3MzNTrnZychWXS05OZuRKLySrUaMGzZs3j54+fapQQ4EhISG0Y8cO6tOnD2loaIg8Rw0aNKCpU6fS2bNn6e3bt5XiOhBxBC8CRSb4uLg4un79Oi1cuLDMnoempib16tWLNm3aRIGBgawek7wJoqCggNzc3Gjs2LGkp6fHstva2poWLVpEL168oMzMzErxAHFy35ZLSUmhGzdu0JgxY0TIvk6dOrRkyRJm3kdR6peTk0Pu7u60cOFCsre3L3NFMAD6559/6MGDB+XqiPz0BB8TE0OjRo0iIyMj0tDQoCZNmtCzZ8+Y/QKBgP766y8yNzcnDQ0N6tGjByubO9GX1G+//fYb6erqkr6+Pk2YMKFCvUBFIPisrCwKCAigkydP0qJFi6hPnz4iY4YlRUdHh3r27Elr1qwhX19fysvLk5mdFZFzcXERSZVWo0YN+vPPP0V6c4ryoHNykpUr+WobOXKkyFdbw4YNFdYLKiUlha5evUqzZ8+mli1bijgoAF88uerVq0cjRoygtWvX0tWrV+nDhw+shYA/NcGnpqZSrVq1aPz48eTv708fP34kd3d3Vq7QDRs2kL6+Pl29epWCg4NpwIABZG1tzZpwc3R0pObNm9OTJ0/I19eXbG1tydnZudx2SJvgBQIBZWRk0Lt37+jWrVuM3NixY6l79+5kZWVVZm9BSUmJGjVqRKNHj2a2KeKXhkAgoMePH9P06dNF6mBmZkYzZ84kPz+/MsdjFYWQODnpyWVlZZGrqysNGTJE7ATt2rVrKSoqSu52ikNCQgIj169fPxG3XeGiqqpKDRo0oH79+tHUqVOZ7R4eHhQVFfXVDtmP2kmkQLFoFi9ejIcPH8LX11fsfiKChYUF/vzzT8yfPx8AkJGRATMzMxw7dgwjR47Emzdv0KhRIzx79gytWrUCANy5cwd9+/ZFTEwMLCwsRM6bn5/PxLUAvsRuqFGjhkSiSZbEk8jIyEBGRgYTGVBYX1kwNjZG48aN0aRJEzRp0gT29vZo1qwZtLS0FCKGRmkQEUJCQnDu3DmcO3cOkZGRrP3jxo3DmDFj0LVr128msFDE+n1LLjk5GdnZ2UhNTUVaWhrS0tKYsL/Z2dlMOODCwkLk5+dj586dAICZM2dCQ0MDampq0NDQgIaGBnR0dJikH4aGhjA0NISJiQk0NDRgYGBQqdqlPHJ8Ph9Xr17FqVOncO/ePda+jh07YuTIkRg2bBjMzMzkaufX5JKSkhAYGIjAwEC8evWKCTOdl5f3zfPp6urCxMSEiSSpp6fHhJeuMtEkGzZsSHPmzGEmC+3s7OjAgQPM/vDwcAJAgYGBLLkuXbrQrFmziIjo8OHDZGBgwNpfWFhIysrKdPnyZbF6V65cKfbNW5E3nq+vb5lv8LKKjo4O1a1bl/m/bNkyOn78OD1+/JiJxlgWFKlH9vr1a1q5cqWIG6a2tjYNHz5cYez8EbnCwkIKCwsjd3d32r9/Py1ZsoRGjRpFnTt3rvB1l1Tp2bMnTZo0idasWUMnT54kX19fio+Pl2sya0nKderUiTX2raSkRN27d6cDBw6IPB+KWr/i4mKKioqiu3fv0t69e2nOnDmMnJWVldhQIN8qsurBSzyj08ePH7F3717MmzcPS5cuxbNnzzBr1iyoqalh3LhxSEhIAACRt7iZmRmzLyEhgZX1BviSMMDIyIg5pjSWLFmCefPmMf9LevAVgbm5Oet8mpqaTPo1LS0t6OnpMRElTU1NYWpqKtITX7JkSaXJyvP+/Xu4urrC1dUVoaGhzHZ1dXU4OTlh5MiRcHJyAhHB1dVVjpZWHAEBAQgPD8fr16/x5s0bvHv3DhEREWKTsJSGqqoqjI2NYWRkBAMDA+jp6UFHRwfa2tpM71xVVRXFxcXYtm0bAGDOnDlQVlZGQUEB89WXlZWFrKws5quv5KuAhD6aS/d0S6Cjo4O6desyiT8aNWpU7vjvioQ7d+4gPT0dFy5cwLlz5+Dv7w9PT094enpi+vTp+OWXXzB8+HAMGjRIbBIQRYCSkhJq1qzJpNLMzs7G9u3bAXz56tfS0kJ6ejqTCazkS5/P5zP3Qn5+PiuapKwgcYIXCARo1aoV/vnnHwCAvb09Xr58iX379mHcuHGSVsdAXV0d6urqP3SO6tWrM7+XLVtWaYj6e9CuXTu8fPmS+a+qqopevXphxIgRGDhwIOsz8GtJM+SN9PR0PH/+HAEBAaykEl26dBF7vIaGBurUqQNra2vUrl0bNWvWhImJCSZOnAgAzBBgeVKzZWdnMwS/du3acmc8+vTpE0PWu3fvxufPnxEVFYXIyEh8/PgR0dHRyMrKYoYKxGHWrFlMVrCmTZsqLDkCgKWlJebMmYM5c+bg48ePcHV1xfnz5xEUFIQ7d+7gzp07mDx5Mrp16yZvU78LJekYDQ0NUa9evTKPy87OrvwEX716dTRq1Ii1rWHDhrh06RKA/+8lJyYmsgg1MTERdnZ2zDFJSUmscxQVFSE1NZXVy+bwbRARXr58iUuXLrGSDL98+RLKysro2bMn04MyNDSUo6XfRnFxMUJDQ/H48WM8fvwY/v7+rJj2wjA2NkazZs3QuHFjNGzYEA0aNEC9evVgYWEhkqEpOzubIfhvpV37UaioqLC+XseNGyfyYsjPz0dkZCTevXuHN2/e4M2bN3j16hVCQ0OZeZ8jR47gyJEjAL50bpo3b4527dqhffv26NChA2rWrCm1OvwI6tSpg8WLF2Px4sXMF+T58+fx8uVL1tfMgAEDmPuyrDF7DuVAhQZ0ygFnZ2fq1KkTa9ucOXOoffv2RPTFM8Pc3Jw2b97M7M/IyCB1dXU6e/YsEX0ZDwZAz58/Z45xd3cnHo9HsbGx5bJDEdwk5SVXVFREDx8+pPnz55ONjY3YMcDdu3d/c45AEern7u5Oa9asod69e5eZtcna2pqGDRtGq1atYrZVxYVVJfc0AJo7dy717NmzzLDANWrUIGdnZ9qzZw89f/5c4ev35s0bWr58uUg9eDwederUibZs2ULh4eFyt1MeckQK5Cb59OlTUlFRoXXr1tGHDx/o9OnTpKWlRadOnWKO2bBhAxkYGNC1a9coJCSEBg4cKNZN0t7envz9/cnPz4/q1q2rUG6SiiaXmZlJV65coQkTJlC1atVYD4m6ujr179+f9u/fL3c7v4bCwkJ69OgRrVixoszJKV1dXerZsyetWLGC3Nzc6PPnzzK3U5HkBAIBhYWF0enTp+mPP/6gli1bik2OUlJ27NhBHz58+GqMFkWo36pVq6hVq1Yi9jdu3JiWLl1Kjx8/ZkJeKMJ1kKYckQIRPBHRjRs3qEmTJqSurk4NGjRgedEQ/f9CJzMzM1JXV6cePXrQu3fvWMekpKSQs7Mz6ejokJ6eHrm4uFS6hU6ykNu4cSP17t2b1NTUWA+Cvr4+OTs704ULF5h2U8T6ffjwgXbv3k0DBw4UWRULgExNTWnYsGG0c+dOCgwM/GocG0WsnzzksrKyyMPDg/7++2/q3r27WP/0WrVq0aRJk8jV1ZVSUlIUtn6fPn2i//77j7p16yby4jI1NaWxY8fS0aNH5W6nNOWIFIzgFQFVkeDT09PpypUrNGnSJLG9szp16tCsWbPo/v37VFBQoJD1y8rKohs3btD06dPFDh8ZGhqyMjpVxaEWWculpKQwch07diRVVVVWmyspKVH79u3p77//pqdPnzIL1xStfqmpqXTq1CkaMWKESNjpkrJ48WLy8/MTe//Lyk5JyxEpkJskB8khKysLjx49gre3Nzw8PPD8+XORRNMODg7o168fnJyc0KBBA6lOEP4I9u7di/v378Pb25u1QExVVRUdO3ZEr1690LNnT9jb2yMvL49xO1XU+lQmCHuXubu7g4jw4MED3Lt3D3fv3sXr16+Zieu///4bpqamcHR0xC+//CJHq0VhaGiIUaNGYdSoUSgsLISfnx/c3Nxw69YtvHnzBgCwYcMGbNiwAbq6uujSpQu6d+8OBwcH2NnZfXNhXpVEhV4HlQiVsQcfFxdHFy9epHnz5lGbNm3EjqXWrVuXJk+erNA9j6KiIvLz82MtCBEutWrVomnTptG1a9eIz+fLzU5O7gs+ffpEBw8epF9//bXMiez169fThw8fFL5+Q4YMEYmVBID09PTI0dGR1qxZQ56enpSVlaVw1+Fr4IZoSkHRCT45OZmuX7/OyFlaWop9sGrXrk1jx46l48ePM7kzFfHGzMrKosuXL9P48ePJxMREpB6dO3emTZs20evXr785waeI9ftZ5PLz88nT05Pmz59P9erVE7mODRs2pMWLF9OjR48UNgZRcXExBQQE0ObNm8nJyUns3I6SkhI1adKE+e/j4yM2+Ywi1I+IG6JRWGRkZODdu3d49+4d48scEhKCmJgY1nGxsbHg8Xho2rQpOnbsiA4dOqBLly4K688MAElJSbhx4wauXbuGe/fuseJ1GBgYoFevXswK2Nu3b1fphWNVBWpqaujWrRu6deuGv//+mxkqc3BwwMOHDxm//A0bNsDc3Bz9+/fHoEGD0L17d2hoaMjZ+i9QUlKCvb097O3t8eeff6K4uBghISHw9fXFo0eP8PDhQ8TExLAW+jk4OEBZWRn169dHs2bN0LRpU2b9hI2NjUIvJPsaOIL/ARQVFeHz58/4+PEjs+3vv/9GfHw8wsPDER4ejs+fP5cpb21tjYiICACAm5sbOnXqBF1dXanb/SP4+PEj7t69i6tXr+Lhw4esZffW1tYYOHAgBgwYgE6dOqGgoKDShTjgIB63bt1CYWEhbt++jevXr8PNzQ0JCQk4ePAgDh48CB0dHfTp0weDBg2Cg4ODvM1lQVlZmSH8WbNmAfjSoXrw4AF+++03AICRkRFSU1Px+vVrvH79GufOnWPkS0IV2NjYoE6dOqzFlq9fv4aNjQ0MDQ0Vcr6II3ghREdHM7/nzJkDJSUlJnpgTk4OMjMzwefzkZ6ejpSUFGRkZIicY/PmzSLbqlevjgYNGqBBgwZo2rQpU1RUVJgeUpcuXRSyh0tECAoKYv43a9aMtb9FixYYNGgQBg0ahCZNmrBu8oKCAlmZyUEGMDAwgLOzM5ydnVFQUABvb29cu3YN165dQ2xsLC5cuIALFy6wJjPj4uJQt25dOVotHpaWlhgwYADzPyoqCmlpaQgNDUVoaChevnyJt2/f4u3bt8jKykJkZCQiIyPh4eHBOk+bNm0AfHmJGBkZwcjIiIkkqaury8SyUlVVFXGQkAU4ghdCcnIy8/vQoUPlklFSUoKpqSkSExMBAJMnT0adOnVQp04d2Nraok6dOtDX1xcrq6gxXoqKiuDr64urV6/i6tWr+PTpE7NPSUkJXbt2xeDBgzFgwACFHkLiID2oqamhV69e6NWrF3bu3IkXL17gypUruHbtGl6/fs0cV69ePbRt25bpBDRo0ECOVpcNHo+HGjVqoEaNGujbty+znYiQkJCA8PBwhIWFISoqCuHh4Th58iSALy+99PR0FBcX4/Pnz1/9YpcHOIIXgrhokurq6sxbuCS2t76+PoyNjWFiYgJDQ0OWW9/WrVsVsif+LWRnZ8Pd3R3Xrl3DzZs3kZqayuzT1NREbm4uACAyMrLCUTo5VG0oKSmhdevWaN26Nf755x8EBQXB3t6e2e/v7w9/f38sWbIE9evXx8CBAzFo0CC0bdtWJC6QooHH46F69eqoXr06OnXqBODLs1JC8DExMVBRUUFKSgqSk5ORmpoKPp8PPp+PzMxMZgSgoKCgakSTrMz4maJJAkB8fDxu3ryJ69ev4/79+6xJUmNjYwwYMAADBw5Ex44dYWpqCuDLWGVVg3C97969i6ysLKSnpyM9PR18Pp8J+5uTk4P8/HwUFBSgsLAQhYWFjFzv3r2hpqYGNTU1JrKptrY2tLW1oaOjw4SZNjQ0ZN1XxcXFMq2rLCA8JBMWFoZ79+7h2rVr8PDwwLt377Bx40Zs3LgRZmZm6NevHwYOHIgePXrI0eIfg7q6OiwsLMQmIhJGlYgmyUFxITwh2qVLFwQEBLD216lTBwMHDmRIXUXly+2hqENJ5QERITk5GWFhYYiIiEBERAQiIyMRExOD6OhoxMXFIS0tjTl+yJAh36Xn4cOH3yVnYGAAMzMzWFlZwcrKCjVr1kTt2rVhbW2NOnXqwMbGplJ3NMzNzTF16lRMnToVfD4ft2/fxrVr13Dr1i0kJibi8OHDOHz4MDQ1NdG1a1d5m1vlwBF8FUd2dja8vLxw69YtXL9+ndleQu6tW7dmPF9KT5JWJhQXFyM8PJz5P2nSJISFheHDhw9iJ8PLQtOmTWFmZgZDQ0Mm2Yeuri60tbWhpaXF9M5VVVVRWFiIMWPGAABOnDgBVVVVFBQUsCbms7KykJmZiYyMDKSnpyM1NRVJSUl4+/YtgP8f401ISMDz58/F2mRhYYF69erB1taW2ZaYmIg6dep8T1PJDXp6ehgxYgRGjBiBgoIC+Pj44Pr167h27Rqio6Nx+/Zt5thOnTph4MCBcHJyQsuWLRV+KEdRIfGcrIqC78lhqAg5IX9Ujojw7t07JpFC6dAAJdi5cyd+/fVX1rCULO38EbmcnBwEBwcjMDAQQUFBCAoKwsuXL5l5gtLg8XiwsrJiEn3UqlULNWvWhJWVFSwtLaGnp8dMFsu6fmFhYUhPT0dsbCyio6Px6dMnREZGIiIiAuHh4ay5kNIwNTVF8+bNYWdnBzs7O7Ro0QL16tUTWZKvaNevNOh/eYAvXbqENWvWiOwvCZ3Qp08f9OzZEyYmJnKxU15ywPfnZOV68FUAKSkp8PT0xN27d3Hv3j1ERUWx9teqVQt9+/ZFz549mSEIFxeXSvHpX1RUhMDAQDx9+hT+/v549uwZXr9+LdblTF1dnXmZrVy5Es2aNUP9+vVhY2Pz1UU48hyCMjc3h42NDVq2bCl2f2pqKj58+IB3794hJCQEW7ZsYfZ9/vwZ9+/fx/3795lt2trasLe3R5s2bdCmTRu0bdtWhBAVDTweD82bN4etrS1D8Hv37sW9e/dw7949fP78GSdPnsTJkyfB4/HQsmVLJnZRhw4d5Gy9gqNC614rERQ9VMGPyMXHxzNyzZo1YyU1BkBqamrUs2dP2rx5Mys0QGWoX1paGl2+fJmR09LSEhvCwdzcnPr27UvLli0jV1dXevfuHSshhqLWT1JySUlJ9OzZMzp06BD98ccf1LFjxzLbyszMjPnt5eVF+fn5Cl+/Ern8/Hzy8vKihQsXUvPmzUXqpqWlRd27d2f+p6eny8VOacoRcaEKqjRSUlLw8OFD+Pr64sGDB6yx2pCQEABAkyZN0LNnT/Ts2VNhF02JQ1JSEh48eIAHDx7Ax8cHoaGhrMngnJwc6OnpoW3btmjTpg1at26NVq1aic2bWpkngysKLS0ttGrVCq1atWK2FRcX4+3bt3j27BmePXsGf39/BAcHM2s0AKBbt27Q1NREu3bt4ODggC5duqBdu3bQ1NSURzW+CTU1NXTt2hVdu3bFv//+i7i4ONy/f5/p3ScmJsLT05M53srKCp07d0aXLl3QqVMntG7d+odzNVdqVOh1UIlQWXvwBQUFFBgYSPv376fx48dT/fr1xfbKSsrhw4cpPj6+0tQvJSWFLl26RDNmzKDGjRuLrVOdOnWY38LxyStD/RRNLjs7m9zd3Rk5cSn+1NTUqEuXLrRy5Ury8fFheviKXj+BQEChoaG0cePGMp8PNTU1at++Pc2dO5dcXV0pIiKiUn3RloDrwVdCCPtfz5s3D6GhoQgMDGRtL0HDhg3RqVMndO7cGW3atGFWBI4YMaJS9NaXL1+OBw8eIDAwkNVDB754rpT0Jjt37gxdXV1mMqpRo0acB8UPQEtLCx07dmT+R0VFITo6mvlq8vb2Rnx8PPN/1apV0NLSQqdOndClSxc5Wv5t8Hg8NGnSBNbW1li4cCEA4NGjR/D394efnx98fX2RlJTExLrftm0bgC+Ttq1atULjxo2Zc8kjjIAswHnRCEFas+Pp6ekICwvDu3fvmGh8r169wvv370XIDvjiTtaqVSu0a9cO7du3R7t27VgTZYo8+y8QCBASEoK7d+/i9u3b8Pb2FjmmUaNGTMRCBweHn84rQpHkiAgfPnyAl5cXvLy84OnpKXa5/dChQ9G3b1/06tULlpaWlaJ+RITw8HCG4P39/RESEoKioiKRc2hqaqJJkyZo1KgRGjZsiIYNG6Ju3bqoU6eOyBAP50Xzk4CIkJWVxUSEBIDdu3fj8+fPiIqKYtzdhGPclIVZs2ahTZs2aNWqFerWrVupeq1JSUm4e/cu3N3dcffuXSQlJYkcM3r0aDg6OqJ79+7lcs3kIBvweDzUq1cP9erVw5QpU0BEePnyJTw9PRlXWwC4ePEiLl68CABo3LgxevXqBUdHR3Tp0kVhwgSXBo/Hg62tLWxtbZn1Cnl5eQgODkZAQAD8/f1x/PhxAEBubi4zd1H6HDVq1IC1tTVq166NmjVrsjokMTExqF27tsKO83M9eCG8e/eOGfr4/fffoaSkhIKCAuTl5SEvLw+ZmZnIysoCn89Hamoq0tLSxPqYi4OZmRnq1q3L9A4aN24MGxsbZvGKvHtyFZFTV1fHkydPGAJ48eIF63htbW1mYmzBggWVrn6cnKjcwoUL4eXlhefPn7O+OktWoDo6OsLR0RF169ZFTk5OpatfQEAAwsPDmS/st2/f4sOHD8jKyirXuXR0dGBkZARDQ0NmiFFHR4eJZVUSTfLAgQMVthPgevASgXBP++DBg+WWEw7GNXjwYNSqVQu1atVC7dq1Ubt2bdjY2IiN814ZvT5GjRoFb29vkdWh9vb26N27N3r37o0OHTpATU0N2dnZDMFzqNxYsWIF/v33X6SkpMDDwwPu7u5wd3dHbGwsbt++zaxCtba2rpRxZerVq8cKkAZ8+UJPTExEeHg4oqKiEBERgZiYGERFRTH1VVZWRnFxMROvSDjyqiKAI3ghmJmZMb8XL14MTU1NqKmpQUNDAxoaGtDR0WEiShoaGsLQ0BDGxsbg8XhMT+DkyZOVYtLzW8jPz4efnx/u3LmDW7duMduvXbsG4EswshJC7927N6vtOFRdGBsbY/jw4Rg+fDiICK9evYK7uzvu3LmDBw8eICIighVq28nJCU5OTujTpw8aN25cqUJh8Hg8mJubw9zcnDVRLdzzT0tLQ2FhIfNFn5aWhszMTGRmZiI7O5sJW1FYWIjc3Fz8+++/sq1EhXxuKhEqq5ukPOU+fPhAO3fupH79+pW5aGbZsmXk7+9PRUVFla5+nJx05bKysujGjRuspPDCxdLSkiZMmECurq6Umppa6eonLzkizk2Sw3cgMzMTnp6ezOe2cOpB4Msy+t69e6Nbt24YP348gC9x8qvCFwoHyUNbWxv9+vVDt27dmLHmTZs2wdPTE97e3oiNjcWRI0dw5MgRKCkpoU2bNswXYOvWreVsfdUER/A/EYTdw3r16oWnT5+ytqmoqKBTp07o3bs3+vTpg2bNmoHH4yE7O5sheA4cKoJp06Zh/vz5yMvLg6+vL27fvg13d3e8fv0aT548wZMnT7Bq1SoYGBgovN99ZQRH8FUYRIQ3b97A09MTHh4erCXdjx49AgDY2tqid+/e6NWrF7p166bwSb8lhby8PMTHxyMhIYE1MbZ8+XJkZWUhIyODycqTk5ODnJwc5ObmoqCggEn4IZyso1q1alBWVmaSfqipqUFLS4spJZnA9PX1mfFbALh37x5q1qyJ6tWrM+eoitDQ0GBCaQBf8h+XuNbev38faWlprHDWJa6Y3bt3R/fu3VGtWjV5mV6pwRF8FQL9b2GHl5cXvL294eXlhfj4eLHH7tixA/369at0McXLi9TUVLx69YqV5CM6OhrR0dGIiYlhJfkQxvbt279LX05OznfJDR48mPmtpKQEMzMzJjdo6eQfVWkiu0aNGpg4cSImTpyI4uJivHjxAv/X3pnHR1Wd//8zk8yaZCb7TPZ9JWEnCyCgUKjFFW2tIlK1tqXQL4oLta7VIlTb2uoX0Vprv1URtS/ccEXAIJIFQhKyA9nXyT5bMsks9/dHfuf03mQCSViSmZz363VfmZl7z8w9k7nPfc45z/N5Dhw4QNUkGxoa8Prrr9NotrS0NJoct2zZMgQEBEzl6bsMzMC7OOXl5SgsLKSp5q2trYL9crkcS5cuxTXXXIMlS5Zg+fLlAIB7773X5efSbTYbampqUFFRgcrKSpSWltJ94ykGLpfLodFoEBgYSGP5f/Ob3yA4ONhpsQ+5XA6ZTAapVAoPDw8MDg4iLS0NAFBaWgq5XA6r1UqLfgwMDKC/v59GVej1euj1euh0Orz22msAhg1Xd3c3dDodHA4H2tra0NbWhoKCgvOe+/3334/09HSaUxESEuJSESp8PDw8kJGRgVmzZlEDv3//fnz33Xc4fPgwSkpKUFZWhrKyMrz88ssAhuUtli1bhmXLlmH+/PlTefrTGmbgXQiDwYCCggLk5OTQ1zIzMwXHSCQSZGVlUW8nKyuLZhq6Ytw9oaOjgxb3KC0txenTp1FVVYWhoaEx24SEhCAuLk6QhRgREYHw8HCEhobC19eXrjGQaZOdO3dOKFGGEBMTM6F2xMDn5eXBy8sLdrsdnZ2dtPBHU1MTzYaura1FTU0NDAYDfQ9+KCIwXPovLS0Ns2fPxuzZszF37lykp6dDqVSO65ymG6tXr6ajm66uLjoiPXLkCL2Zl5aWYvfu3YJ2r732GlasWIHZs2fTkpMzGfYNTFMGBgZw+vRpFBYW4uTJk8jPz0dlZeUo7RqlUons7GzqzWRmZk5b6dfxwpe3vfXWW3H69OlRIxOCUqmk+iGxsbH4/e9/T9/DleZtPTw8aMy1s+IfHMehsbER0dHRAIAHH3wQtbW1qKiooFWhjh07hmPHjtE2YrEYSUlJmDNnDn3NbDa73MgtMDAQt956K2699VYAwzd7Ip393Xffobi4mF4XDz74IIDh5MP58+cjMzMTCxYswIIFC1xOAuRSwAz8NOHQoUM4e/YsSkpKUFxcjIqKCsEiHiEqKgqLFi2iuiCtra1Qq9VX+nQvGWazGYWFhcjPz0deXh5OnDiBpqYmup9ooYhEIiQkJGDOnDmYM2cO0tPTkZ6ejqioKHrRms1mauBdzYhdCJFIJNBA+f3vf0/7ODg4iKqqKurVkpFOR0cHTb0naLVapKWl0WpPWVlZSE1NdanF3eDgYNxyyy245ZZbAABtbW0IDQ0FAKxcuRInT56EXq/H999/LyiG7u3tTUsczpkzB3FxcVNy/lcSZuCvEGazGXV1dTh79iwtwVZWVkb333jjjaPaBAUFUe+DFLzQaDQwm83UwLvaMLSxsRHff/89jh8/juPHj6OkpMTpjYzwwgsvIDs7G3PmzBFEnzD+i0wmozc+Pm1tbSgqKkJubi7+8Ic/ABgeCZAbwRtvvAEA8PHxQWZmJhYvXowlS5YgKytrQnonUw3/XD/++GMoFAqcPXsW+fn5KCgoQGFhIYqLi2EymUYZfcINN9yA9PR0Wtw8ISEBERERLnd9jcS1z34aYLfbBRo2H3zwAXp7e9Hc3EyLKNfV1TlVWOSTmJiI9PR0WkB5zpw5CA8Pd9mFM0CosX333XcjLy9P4J0TQkNDkZWVRW9iycnJVHFy06ZNbueNXylCQkIQEhKC5cuXUwN/5swZlJeXIz8/n9a4NRqNgtquYrEY6enpyMrKmsrTnzRkaiopKQl33XUXgOEF+aqqKlqsnazjtLe3AwAOHz4sCCMGhqfNiJIkWbsJDw+Hr68vPcZgMECpVE7b65QZeB7Nzc308QMPPEDVJAcHBzE4OAiz2Qyz2UwjIvr6+tDX1yeYF7/77rvHfH+1Wo2EhAQkJCQgMTERMTExNIHo1KlTLm/IbDYbiouLkZOTQ+dHCR988AGA4Ytm3rx5WLx4Md0iIiIE7+PKi8HTndDQUCQkJOCmm24CMOyglJWVITc3l3q3dXV1KCkpQUlJCW2Xnp6OFStWYNmyZVi+fDmio6OnrVFzhqenJ9LS0pCWlob169cDEGrK7N69G7W1tXSEXVNTg6GhIdTX16O+vn7M9w0NDYVEIoGfnx98fX2hVqvh5eVFI69kMhlkMhlVk7zSMAPPY7JqknyuuuoqhIWF0bs9X0vaz89PcKyrZ4harVacOnUK3377LXJycnDs2DEYjUanxz722GO45pprkJmZ6fI3MnfCw8ODTu/86le/AjA8tfP999/j8OHD2LNnDwDQfII333wTwHAc+/Lly6ksdGxsrEsZ/JFs3LhR8LskIat1dXVoaGigI/LW1lY0NzcLdOOtVis6OjouOEqfCpiB5zFSTVIul0MqldK7sLe3N7y8vODt7Q1fX1+6yeVyary/+OILtzZgpJjzt99+i2PHjo3Sy1ar1bTocUZGBlasWAGAadi4EiEhIbj11ltx7bXXUgO/f/9+5Ofn4+jRo3Qh/O2338bbb78NAAgLC6PGPiMjYypP/5IgFosRFhaGsLAwLF26VLCP7/l3dHTAYrHQ0bxer4fZbIbJZEJ/fz8d/VutVlgsliuuJskMPA9+paHHH398UvHQ7oTNZsOpU6fw9ddf09euvvpqwTF+fn5YtmwZVqxYgeXLl2P27Nk0IsNdv5eZCD8u3Ww2Izc3Fzk5OThy5AgKCgrQ0tKCd955B++8846g3f/93//hhz/8IWJiYlzawx8LpVKJoKCgUdOMzjCbzczAM6YOm82GoqIifPvtt/j222/x3XffjZpy8fX1xfLly3H11VdjxYoVSE9Pn3GxxTMdLy8vrFq1CqtWrQIwLNOQm5uLI0eOICcnB3l5eVTEbvPmzQCGp3RWrFhB6/C6q8GfbjADP4OxWq04efIkcnJykJOTg++//96pQV+8eDE+//xzAMNhjjNFkIwxPpRKJVauXEkrOXV2dtIks6ysLJw8eRJNTU1466238NZbbwEAwsPDsXz5crolJCRM2fm7M8zAzyD4gljXXXcdCgoKRolkEdlWMp86e/ZsWCwWOufIvHXGheDLI5DQy9zcXCo3cOLECTQ3NwumdLRaLRYvXkzbTUXEiTvCDLwb09HRQUPfjh07hpMnT9J93377LYDhEmwk9G358uVIT093qaxGxvTH2ZTO8ePHaThtXl4e2tvbsX//ftomPDwcS5cuxZIlS7BkyRJkZGS4vATHVMAMvJtgs9lQWlqKvLw85ObmIjc3F+fOnRvz+BdffBGrVq1Camoq88rPA8dxVBlycHBQoAXPjyCqrq6Gt7c3JBIJJBIJreWrUCggkUimsAfTD6VSKTD4FosFBQUFOHToEJ555hkAwwlEn3/+OZ0a9PT0xLx585CdnY3FixcjMzMTUVFRbB7/AjAD74LwE6seffRRFBcXo7Cw0KkmeVpaGvWCFixYgFmzZgEA7rvvvhkVtshxHPR6PVpbW9HW1kbjljs7O2k2IzCcx2AymWA0GmEymWA2m0cJvDnDmUAYwdPTE97e3rRoO38N46GHHqLFPsgWGhqKkJCQGeOxyuVyLFu2DAsWLKAG/rvvvkNhYSEdfba1teHEiRM4ceIEXnrpJQDDYc2ZmZmjJBoY/4UZ+GmOzWbDmTNnUFxcjKKiIpw6dYpqlwOg+tjAsCZHRkYGFi9ejOzsbGRmZgqSq9w5bNFut6OhoYE+f/bZZ2lSSlNTE1paWjAwMHDB9ykqKhpzn0gkglQqhUQigYeHB8RiMS0c4uvrC47jYLPZqJdPsNlsNE56JK+++uqYn+fn50cT5kjVJ0JnZ+e0TpG/WObNm4elS5di69at4DgO9fX1dGSal5eH4uJi6HQ6fPLJJ4JKUCkpKVi0aBHmzZuHuXPnYt68eQgNDXXb7+lCMAM/TXA4HKirq0NFRQXKy8tRXl6O06dPo7KyEoODg2O2u+++++iQNSkpya2nWziOg06nQ1VVFaqqqlBdXY2zZ8/izJkzqKurE9SXHSve2M/PD1qtFhqNBsHBwQgKCoKPjw927doFAHj//feh0WigUqmo161QKOhUC99Q8BNempubBSMijuNgsVho0Q8icWEwGKDT6XDHHXcAALZt2waj0YjOzk7odDrodDq0tbVhYGAAvb296O3tFRQyIcTExMDHx4cKYyUmJiIpKQnJyclISkpyq0gnkUiEmJgYxMTE0O9tYGAARUVFOHHiBI4fP473338fAKiWPn8+38/Pj6qPzpo1C7NmzUJqauqMGCGJuPGMPy+CXbt24dFHH8XWrVtpOTSLxYIHH3wQ+/btw+DgINasWYNXXnlFkEna2NiITZs24ciRI/D29sbGjRuxc+fOcau7GQwGqNVq6PX6cSvj8S9Yk8k0oUSn8bSz2+1obm5GfX09rUT05z//GcCwIuBYhpwvczp37lykpqZiyZIll+08p1O7559/HmfOnEFFRQUqKiqcesEET09PauTvuecexMfHC4p8jDXtMd2+FzKd1NLSIhCtO3fuHN59991xfUZERARSU1Mxa9YsJCQkYNOmTdOmf5ez3WeffYbKykoqmVxZWTmmWqmfnx8dgT355JNITU1FbGwsoqOjERgYOKbXf6X7B0zOngGX2YM/ceIEXnvtNcyePVvw+gMPPIDPPvsMH3zwAdRqNbZs2YJ169ZRGU+73Y61a9dCq9Xi+PHjaGtrw1133QWJRILnnnvucp7ypOBXFTpy5AiMRiMtvcav0NPS0iLwMvkMDg5CKpUiMTGRehnp6emYPXs2oqOjBZ65O0212O12nD17ll6QZCqK8MgjjwiOF4vFiI2NpWqBiYmJSEhIQHx8PBV7AoCXXnrJZdcYRCIRlcEgaybA8P+dGPiuri50dHRQcawzZ86guroa1dXVaG9vp7+5r776SvDeZOqCTF/MnTtXMPXj6ixfvhw/+tGP6HOLxYKqqiqcPn0aZWVldHTc0NAgqMtL5v4JXl5etDZuREQEQkJCEBoaCq1WKxgdnU/qejpw2Qy8yWTC+vXr8frrr1OpUgDQ6/V44403sHfvXlxzzTUAgDfffBMpKSnIy8tDVlYWvv76a1RUVOCbb76BRqPB3Llz8eyzz2L79u14+umnIZVKR30e0Xwg8MubjRe+muS2bdsgFoud1tg0mUwwGAwwGAzo6+sTGNzrr7/+vJ8hlUoRFRVFBcj+/ve/AwBKSkqQmprq8vrT58Nut6OqqopWqTp16hSKi4vPe8O67rrrMGfOHKSlpSE1NRWJiYm0BOFI3OnGdyHkcjlSUlKQkpIyal9vb69gqq+kpISWeSQ3BKLuCYBWkZo/fz4WLlyIhQsX0gIaro5cLqc3ND5msxmnT5+msffr16+nypGtra0wm810KvB8qNVqejMeWcNXoVBAKpVCKpXC09NzSm4Gl82abN68GWvXrsWqVasEBr6wsBBWq5WGSAFAcnIyIiMjkZubi6ysLOTm5iI9PV0wZbNmzRps2rQJ5eXlmDdv3qjP27lzJ63mM1k6OzvpY2J4J0pSUhI0Gg2NhAgNDUVERASdKggNDRVUICKfExcX51bGneM41NXV0eerV69GSUmJUyOsUCgEU1CJiYn05r9v3z6X9cSnCj8/Pxo5BQinBj7++GNUVVXR0RLx+D/77DN89tln9D20Wq3gOuvp6XGr/4OXl5dgZuG1114TVMhqaGigo6Cmpia0tbWhtbWVrpPwf9tjLaBPBy6LRdm3bx9OnTolkNQktLe3QyqVCkTzgeGQJxKu1t7eLjDuZD/Z54xHH30U27Zto88NBsO4BID4aLVa+pivJkk2pVJJN5VKBbVaDbVaDZlMRj+rsLDQrS6E8dLT04OCggJaSKKgoADd3d10//HjxwEMX1jz58+nlarmz5+PpKQkQXLVTPLErzQrV67EDTfcQJ8TT/bUqVM4efIkCgsLUVFRgfb2dnzxxRf0uMjISMTHx9NSf5mZmZg7dy5kMtlUdOOyIpPJkJiYiMTERKf7+TfM2tpaDA4OQq/X01E9Gen39/fTGQC3UZNsamrC1q1bcfDgwTGH0pcDIul7MTA1yfHBT6oi25kzZ0YdJ5FIaLjga6+9hqVLl44y5oypxcvLC9nZ2cjOzqav9ff3o7i4GMeOHcP27dvp6+fOncO5c+ewd+9eAMPTjfPmzUNWVhbdoqKirngfppLg4OAJ2QmXN/CFhYXo6OjA/Pnz6Wt2ux1Hjx7F//7v/+Krr77C0NAQ+vr6BF68TqejHrRWq0VBQYHgfXU6Hd3HuLKQ7x4YniorKipymlQVHx8vKL0XHx+PgIAAAMNznDNxZOOKKJVKLF68GHPmzKEGvqmpCRUVFXSElp+fj66uLvr4b3/7G4DhkfbChQvpe5nNZvZ/n0IuuYFfuXLlqLjdu+++G8nJydi+fTsiIiIgkUhw6NAhWhW9uroajY2N1IvIzs7Gjh070NHRQVXpDh48CJVKhdTU1Et9ygweg4ODKCoqEnjn/AQiEunk6+tLh+vZ2dnIyMigxpww00Y27oyfnx9Wr16N1atXAxheY6mtrUV+fj5yc3ORn59Pk4/4c/khISGYPXu2wMtPSEhw63yN6cQlN/A+Pj5IS0sTvObl5YWAgAD6+r333ott27bB398fKpUKv/nNb5CdnU2L/K5evRqpqanYsGEDnn/+ebS3t+Pxxx/H5s2b3XLOb6rgX6T5+fnIy8tDUVGRIAtzJHv27MHy5cvdPqmKcX5EIhHi4uIQFxdHk48sFgtOnTqFnJwc/O53vwMwnMBHFnRJ1q6fnx8yMjIEo72RzgHj0jAlYRsvvvgixGIxbrnlFkGiE8HDwwMHDhzApk2bkJ2dDS8vL2zcuHFUrCpjYvCjhNatW4dTp04J6tASgoKC6MWXlZWF1NRUGja3YcMGNuRmOEUul9OpHWLgq6urcfr0aepAnDx5Er29vfjqq68EMfrx8fGCad2BgQH2O7sEXBEDT6RpCXK5HLt378bu3bvHbBMVFUWV5BgTp6enRxAZceLECcFUCynDRxbKiDHPzMwcVW2HTbUwJktYWBgSExNx6623AhguMsM3+Pn5+Thz5gxdwCVoNBqkp6dj0aJFNOIqPT39igZuuAPuE3g9Q+E4Di0tLSgqKhIIktXX15+33Z///GcsXboUc+bMYdNejCuGRCKhBvvXv/41gGFn5OTJkzh27BieffZZAMNTOyUlJSgpKcE//vEPAMNSFLNmzcL8+fNpFu6cOXNYVNZ5YAbehTCZTCgvLxeoSUZFRaGnp8fp8XFxcVi4cCEWLFiAhQsXIjk5mU61/PKXv2RDYMa0wN/fH6tXr8aSJUuoga+urkZ5eTkdgZ48eRLd3d3U6L/55pu0PT80c//+/Vi4cCHi4+OZDj+YgZ92cByH9vZ2nD17liomVlZWory8HI2NjaOO7+npgYeHB5KTk6lXQzyckclkbKrlwhDVR7PZDLPZjP7+flgsFiqFYbVaYbPZYLfbBaGi+/btg0KhgKenJy36QXIzFAoFlEolvLy84O3tzRanxwGZ2rn55psBDF8XTU1NOHXqFJW4KCoqQnNzs2Dq8a677gIwPFJITExEamoqUlJSqNJmQkKCWyltXghm4KeA/v5+NDY2orq6mr62fv16NDQ04Ny5c4JKQSPRaDRITU3FkSNHAADHjh3DggUL2NykE0wmExV9a29vFxT56OrqQnd3N3p7ewUjoJEZ1OPl5z//+aTazZkzB/7+/vD390dAQAACAwMFxT9CQkKg1WpnfP6HSCRCZGQkIiMjcdNNN9HXu7u7kZ+fj7Vr1wIAFi5ciMrKSpjNZqrFMxKNRkOVRgnHjh1DSkoKQkND3UoyxH16Mk0oKyvDwMDAKH3v1tZWtLa2oqmpyemUyscff0wfi8ViREVFITk5mW7EEwkICBCkSs+dO3dGGner1Uqll+vr69HQ0IDa2lq6X6vVnvdGeT7EYrFAMEqhUFBvnHjnYrEYHMfh8OHDAIBrrrkGIpEINpsNVqsVVquVev18TfiRRUdqampQU1MzrvMKCgqij7dt20albckWHBw84wpbBAQEYPny5fT5t99+C4VCQROzKioqUF1dTUfDHR0d9LokOR0A8MMf/hDA8P8+JCQE4eHhCA0NpZpS5IYbFBTkUjryzMDzGKkm6eHhQSv0DA0NYWBggG6krBtRlCSQWP4L4e3tjcjISFRUVAAYLlCRkpKChIQExMTEsIXP/09lZSWam5tplEVNTQ1qa2vR0NBwXnU+Yty9vb2pB8wv8hEQEICAgAD4+/tDLpdTcTOdToegoKBxGUr+jfaTTz4Z15qG3W6HTqdDWFgYAOCrr76CxWJBd3c33To7O9HR0YH29na6Wa3WC4rhKZVKxMbGIjY2FvHx8bQYSHh4+AXPy50gDlJUVBSuvfZawT69Xo+zZ8+ipqYGlZWVVKAwJiYGzc3NsFqtaGlpQUtLy7g+S6PRwM/PDz4+PqMKxBAtK4lE4n5qkq7IpVCT9Pf3R2BgIDUm/BqbRFkyPDwcarUa/f391EBs3rx5xi569vT0oLKyEhUVFaiqqkJZWRndt2jRojHbyWQyREVFITo6mpa0I4t0hYWF455v5a9NeHl5XVYv2MPDg2rWA8CSJUsu+H93OBzo7u7GuXPnqLztQw89hLa2NjQ0NKC+vh4tLS3o7+9HWVmZ4PsbyV133YW0tDSkpKRcUH7ZHVGr1VQS2Ww2UwNfWloKhUIBnU6H5uZmNDc30/q9pIavTqdDV1cXurq6YDQaAYCu1UxXmIHnwZ/n3L59O+RyOR2SSyQSemdWKBT0ju3j4wOpVEoLMzQ2Ns5YQ30hjEYjNUD84gtjKYQCwwaXFPaIj4+n2ZNxcXHQarWjCqEQA5+UlOQ2/wexWIygoCAolUr62tNPPy3o3+DgIBobG1FbW0tHOkT7/dy5c9R73L9/v6CcnVgsRlxcHC0yk5aWhvT09DGVFN0ZMj0TEhJyXseCP3IrLi6G1WqlRdpNJhMd5VssFjpdZ7PZMDg46PpiY64MX03yiSeeYGqSk8Rut+PcuXPIz8+nr6WmpjqNAiKQEnPJycmIjY3F1q1bAQzLQ5OLiTE2MpkMCQkJSEhIwJo1awT79Ho9jajasWMHamtr6Yipr6+P3gg++ugj2kYikSApKYk+P3jwIDIzM6HVamfcPP/5iI+Pn1lqkoyZhcFgwOnTp1FSUoLi4mKUlJTQhWY+xLiHhobS4sdpaWmYNWsWUlJSBFMpZrOZGnhmTC4eflTI1q1bqUEiIbnl5eWoqKgQjK7IaItAwhUDAwNpghEp0pKcnMxizqcpzMAzJsQXX3whqAg0VgSIUqlEamoqTp48SdtlZGTA39//Sp4u4zyIRCI6JcGvsMZxHBoaGnDixAn85Cc/ATA85XX27Fl0dXXhm2++wTfffEOPl0qlSEtLoxW5+J4/Y2phBp4xCpvNhurqamrE+ZmzP/7xj0cdHx4eLvDq5syZg7i4OFgsFjq9ctVVV7nNnLi7IxKJEB0dLQjLLCwshFgspjVeyWituLgYRqORJiCN5I477sCiRYuo8Q8LC2OjsisIM/AzHL1ej9LSUnqxFhcXo6ysDBaLxenxqampmDdvnkALJDAw8AqfNWMqUCgUNAKF4HA4UFdXJzD6hYWFNMzwk08+wSeffEKPDwgIoMaeOAPJycmQSqVXvD8zAWbgZwh2ux1nz56lz2+77TaUl5ePKUrm7e1NL8DU1FRs2bIFAFBQUMA8cQaFROHExcVh3bp1AIRRJjt27EBFRQVKSkpQWVmJ7u5uHDp0CIcOHaLvIZFIaCIfQafTjVI1ZUwcZuDdDI7j0NzcPGrRrLy8XLDwya+6ExERIVg0I1MsJATRbDZTA89gTAT+oq7FYkFZWRkVDCMev8FgoK8R4uLiEBQURMM2yYL8rFmzBHkEjPPDDLyL8/nnn6O+vh6VlZU09M1gMDg9Vi6X06mXP/7xj1i0aBHVQmEwLjdyuXzUFA9Z0D19+jROnDiBP/zhDwCG1wE6Oztx5MgRqrtECAsLo4laKSkpM67Q90RgBn4aY7PZ0NzcjJqaGpqqf+bMGVRVVdFjSJQDH09PTyQkJGDWrFnU+0lLS4NWq6Xez0zOnGVMH8iCbnR0NFauXEkNfEdHBxoaGugItLS0FOXl5WhubqZSAvxIHsJVV11FJT+IXENcXBwCAwNn5HQPM/BTCH/KZO/evdDpdFQ8iwho2Wy2875HWloaUlNT6ZaSkoLExESni1YsIYvhKigUCloYhI9er0dFRYVA2qKiogJ1dXUAgKKiIhQVFY16P29vb8TExNCbSVRUFIKDg+n+C11nrgoz8JeYjo4ODA0NORWPIsqSRF2yt7eXtvvFL37h9P2kUiliYmKoN0JkTm+88UYAQF5eHvPEGTMGtVqN7OxsZGdn09f4i7p79+5FY2MjHfGeO3cOLS0tMJlMKC0tRWlpqdP39fPzg1arRWhoKLRa7SgFSb44nStF/DADz8OZmqTdbncq/0qKQZhMJuj1etouNjZ2Up999dVXC6Rfo6KiEBcXh9DQ0FEFIpgnfvFwHIf+/n7o9XrodDr6+hdffEGLeRA9EaImOjQ0RIt92O12DA4O0nbbt2+HVCqFp6cn3aRSKd2IhpFSqRSUmKutraVTZ65kOKYrN9xwwyiHx2KxUDnphoYG1NXVobGxEfX19cjLywMw/HsgztdEiI+Ph1qthre3N5WYlsvlAnlpT09PakuuNMzA8+jq6qKPJ6smCQAqlYre8QMCApwWcAgJCYGfnx+Vcv3000+ZJ34RWK1WtLa20udvvfUW9Ho9Ojs7aYGPnp4euvX19TkdljtL5BoP5ysgfz5mz55NHysUCvj6+o4qABIUFITg4GCoVCp6bHd3N5RK5YycV54ocrkcSUlJozJs+Z7/uXPn0Nvbi/b2dkGBGDL6JqPx3t5eQSUvIuc8XWEGnge/ms8jjzwCuVxOS7B5enrSO7NcLoeXlxfdPD096ZBRr9cLLsTzwTzx8TE4OIjm5mY0NjaisbERzc3NaGpqopKuLS0t6OzsBMdxtM2mTZvG9d4eHh7w9vamo7D58+dDpVIJNL1lMhnV9ZZIJPDw8IBYLIbNZsNf/vIXAMMjPqL5TUZ9xOu3WCx0M5vNVL8HGFbLJL8DokI4Hi8yKioKEokEISEhCAsLQ1hYGMLDw6kcNal+NNMrQY0XrVaLuLi4cR3b09ODgIAAAMOVoKxWKy3oYjab6UifX+KRqEk+//zzl7Mbo2AGngdfTfLJJ5+clJokq/A+cex2O1paWmgxD34pw/j4+HF7SGKxGA6HAwCwatUqhIaGIjg4GIGBgQgMDKRzqP7+/vDz84Ovry+USqVAl//o0aMT+r8TA//MM89MqB35PJ1OB7lcDqPRiL6+PvT09NAygkR7nIxCWltbcfToUfo+VquV3vTGQiqVCgp+vPDCC1SxMy4uDv7+/mwUMEH4xXjmzp07of87M/AMt8Rut6O2tpZK05KqOufOnUNdXR2GhoactiPGXS6XU680IiICERER1HMNCwtDaGgoFAoFHT199NFHLjPl5eHhAV9fX/j6+iI6OnrM4/g3hu7ubphMJjqCaWlpoSObxsZGNDU1oaWlBUNDQ4JShqTABUGlUtFQQlIBKiEhAYmJiQL9eYZrwgw845LBcRy6urpQVVWFM2fOCCIWAgMDYbVax2wrkUgQHR2N2NhYhIeH44033gAA5OTkIDk5eVxl9GbSlJdMJoO/v7+gcPRIbDYbWlpaUFlZSUvX3X777WhubkZtbS1aWlpgMBjGFArjTzXu3LkT6enptPgKM/6uATPwjAljtVpRW1uLqqoqupHCxvzQz5FtZDIZ4uLiqJdIklHi4uIQHh5Op7fMZjM18AsWLHAZT3y64enpiaioKIEY3Ouvv06/z4GBAdTV1dGRFH901djYKMiI3rFjh+C9IyIikJycjKSkJEFx+NDQ0CvTOca4YAaeMSZ6vR7V1dUCjZD58+ejtrZ2zMQQkUiEqKgoJCYmIjY2Fq+++ioAoKKiAomJiWyNYhqhUChogtxILBYLSktLkZGRAQDYsGEDampqUF1dje7ubjQ1NaGpqQkHDx4UtPP29kZCQgJ9/vHHH2Pu3LmIj49nYaBTADPwMxyHw4GmpibqgfM3Z9EcZ86cATBc0IN4cCkpKTQMLTExEQqFAsCwJ04MfGRkJDPuLoRcLhcY/j179lDPv7u7m47aqqurUVlZierqatTU1MBkMgkySdevXw9geJ0hNjZW4O2T3w+JSGFcepiBnyH09PTQ0Dzgvx7Z2bNnR5XX46PVapGYmEijN4hHFh4ePioBizEzCAgIwJIlS7BkyRLB60NDQ6ipqUFRURE17PPnz8fZs2dhNBrp9M+nn3466v2SkpIQExNDXysvL8fs2bMhl8svf4fcGGbg3QSO49Dd3Y2amhrBnCr5293dLTj+ww8/pI8lEgni4+MFXhXxytVqtSB6Y+XKlWxOnOEUqVSKlJQUwcLv0aNHoVQq0dbWhqqqKurtk1FiU1MTuru7cfz4cRw/fpy2y8zMhEgkQkREhGC9hqzZxMbGsoXeccAMvAthMpnQ0NAgUJO844470NTUhJqamjFlggkhISF02uW5556jURExMTGCwswMxqVEJBIhNDQUoaGhuOaaawT7zGYzzpw5Q6OuyGKuj48PjEYjjfPnFwghkOSkiIgI+lpOTg5SUlIQFhbG5vzBDPy0obe3Fw0NDWhpaaGxzSRbk8Q2O4tQ4ZdDA4DQ0FCBMBnf8xGJRNQT/5//+R/miTOmHC8vL1oC8rrrrqMGvrW1Ff39/YJRKF9ATK/XO5UJWLt2LYD/FhQneRPh4eEIDw8X5E2MN+PclWEG/hLjcDhgMBig1+vR19dHsxN7enqosmRXVxc6OjoE2il8L+R8+Pr6IjIyks6n8zMTY2Ji6AKnM2ZSnDjDtRGJRFS/aeRcPzC8plRTU4O6ujpUVVXhqaeeAgAkJCSgsbERg4ODaG1tRWtrKxUUOx8/+MEPEBoaiqCgIKeZzyQRTa1WCyQxpjvMwPPgq0k++OCDVAHObrdTLYmhoSGqKGmxWNDf3y+YGrkYr8DPz48OZUNDQ2nGZnh4OKKiohAREQGVSiWYE9+0aRPzxBkzDmJ4Fy1aBLPZTA18UVERlEolOjs70dDQMKZ2UVtbmyC4IDc3d9yfzQ8uWLBgAXx8fJxqFxF1UQ8PD3h4eEyJ5jwz8Dz4apKvvfbaRb2XRCKhd33yY/T390dQUBDd1Go1brvtNvrZLFyMwbh4+N7/okWLnB5D5IHDwsIAAP/+97+h1+sF2j9EE4ioj+r1enAcR/WOAAh0k6YjzMDz4KtJbt++HTKZDB4eHvQuTO7MMplMoO8tFouxevVqAEBNTQ20Wi0UCsWEUutZOBiDceUQiUSC4t3r1q274EjY4XDAZDJBp9MhMTERwHBNZIfDQZVABwYGBPUDyOif1A9gYmNTCF9N8oknnpiUmqRGo2HhW9MMq9UKvV5PN4PBAKPRCJPJBJPJhJ6eHnrso48+Sqfj+JKvZCNTdg6HQ6Ct84Mf/EAwHCdFPyQSCXUKiNQ0P+Frz5498Pf3h7e3N3x8fODj4wO1Wg2VSgVfX1/4+PiwfINpglgshkqlEvz/li1bxtQkGYxLhc1mQ2dnJ3Q6HTo6OmhRhq6uLkHmbVZWFvr6+tDb2zuhxeWXX355Uuc1kTlcPg8//PB59xNPk8gbEx588EGEhITQ6T4yJaHRaODn58ckgBkAmIFnTBOsViva29up0iHhvvvuQ1dXFw2J6+rqGlcUQ1lZ2ajXvLy8oFKpoFKpqLfs7e0NmUyG//znPwCArVu3Qq1Wjyq7Roq+eHp6QiwWQywWY2hoCHfeeSeA4QpSMpkMDoeDDsttNhst/EFGAxaLBQaDAS+99BIA4Oabb8bg4CAdURgMBhqFNTQ0BI7jaDQWn/OtEUkkEmg0Gmi1Wmi1WgQFBdF9X375JeLi4hAWFobAwEB2I3BzmIFnXBHa2trQ1dVFtcpHRje0t7c7NdzvvvvuqNfEYrHAayWhbSqVCs899xyAYUmF0NBQ6vmq1eoxk7nMZjM18Dt27JjU1NzNN988oXbEwL/11ltjthsYGIBer0dvby/6+vrQ2tqKW2+9FQDw0EMPwWAw0AVBMprp6+uD1WpFc3OzICqMQNoDw5LDY1WCioiIEKhQMlwTZuAZF43VakVTUxPq6+vR0NBA/9bV1dFj+AqDY+Hp6Umr2hcUFAAYrpQUFRWFkJAQaDQaaDQaBAYGOhUuM5vN1MC7g6QCWcgnZff4N5Snn37aaf8GBweh0+mg0+lobdGGhgb6vcyePZvWGx0cHERtba1gxDQW69atQ1xcHKKiohAVFUWLw2s0GjYKmMYwA8+4IPzFxH//+99oa2tDfX093VpaWgShY84QiUQICwtDVFSUoCoTqcwUERGBoKAgiMViQZz/tm3bXN5QX0lkMhn1wgn8G9/x48fh5eWFoaEhtLa2Uk+fyP82NTWhoaEBTU1NgrDhr7/+2unnyeVygcGPjo4W1IF1paQgd4QZeAYd0vONNn9ramqix/761792+h4ymYxe6MTL02g0uO+++wAMSzHww9IYU4tUKqUGeSw6OzsRHBwMYHjxua2tDQ0NDXSU1tLSAovFQmWDnREYGIiYmBjBDYBs5DfCRgCXD2bgZwAmkwmNjY2Ci/Cee+5Ba2sr6uvr0draekEPnLBy5UrEx8cLLtKYmBgEBwePCuczm83UwDMxM9eDH+579913jxpJDQ0Nobm5GXV1dYKpuZqaGnz//fcAhqeMiHKkM0it3aioKEE1qO+++w5JSUlMNOwiYVedi2M0GmmBZf6iJX/IPTICAwDef/99wXOZTDbKaPO9rLi4OADDi5dsyoQBDI8CYmNjERsbK3idP8VWWloKnU5HbwD8mwEZARA1ST6khqxIJIJWqxVM6RHhMCIeNhNEwybLJTfwO3fuxP79+1FVVQWFQoHFixfjj3/8I5KSkugxFosFDz74IPbt24fBwUGsWbMGr7zyiiCTtLGxEZs2bcKRI0fg7e2NjRs3YufOnTPCE7TZbOjq6qKx3jqdDu3t7Whra0NbW5sgOoKfnHU+fH19ER4eTsMHn332WSQkJFCjHhwcPOZQmYmUMSZLTEwM0tLSnO7jTw02NDTg7NmzdK0gLi4Ozc3NGBwcpL97svB+Pm666SZEREQgJCSEholqNBqaI+Dr6zujpoQuubXMycnB5s2bsWjRIthsNvzud7/D6tWrUVFRQT2/Bx54AJ999hk++OADqNVqbNmyBevWraPDOrvdjrVr10Kr1eL48eNoa2vDXXfdBYlEQn8A0x2S1mwymQRZlCT5pre3VyB1umrVKvT29qKzs1OQWTkeVCqVwKPhezpkQdPHx0fgWT3wwAPME2dMKRKJBDExMbSSE38xuKSkhIqGjQyr5Y9YW1paMDQ0RN/zm2++Oe9nenp60uQwfuLY008/TZPE+KG1KpUKarUa3t7e45IfmW5ccgP/5ZdfCp7/61//QnBwMAoLC7Fs2TLo9Xq88cYb2Lt3LxX/f/PNN5GSkoK8vDxkZWXh66+/RkVFBb755htoNBrMnTsXzz77LLZv346nn37a6ZwcSSQhXKj4hTNGqkl6enrS1HS73U7T1UniytDQECwWC0wmE20XHR2N/v5+9Pf3T+izR0qaisViBAYGUs9Dq9VSr8TPzw/33nsvAKC9vV0w8mEw3AW+aNiCBQucHsNxHBobG+li8Z49e9Dd3U0T49rb2+lIWK/Xw2az0REBnz/96U8XPB+xWEwNPWH58uXw9vaGXC6nkhQkMU4ikVDpCrFYDLvdPvkvY5Jc9vkOvV4PYFjeEwAKCwthtVqxatUqekxycjIiIyORm5uLrKws5ObmIj09XWC41qxZg02bNqG8vBzz5s0b9Tk7d+7E73//+4s6187OTvp4smqS/NAyYLjYMN8TIN6Bn58ffHx8aMLL22+/jbCwMJq44+/vP2aRarPZTA088cgZjJmISCQSJGRt2LBhzJHp4OAgTQzr6upCc3Mz7rnnHgDDstsGg4FmDff29tKMYqPRCOC/tR74zmNhYeFl7N3Fc1kNvMPhwP33348lS5bQebj29nZIpVLB8AgYFukiUxbOvFLyfGQFF8Kjjz6Kbdu20ecGg2HcRTQI/PjdRx55BDKZDGKxmN6FyV15pHiUSCSiGYJ5eXkICgqi4lFkvzP4GY033XQTmzJhMC4jMpmMTmUCw9cfMfAvvPDCmNefw+GA2WymchJdXV20CMl7770HjuPOK07ncDjgcDjcT01y8+bNKCsrw7Fjxy7nxwAANbgXA3/B8sknn5xUynpaWhoz1AyGGyEWi6l2EQCqIQ8MlwiczmqSl02HdMuWLThw4ACOHDlC75jAsJc8NDQ0KnRPp9NRD1qr1UKn043aT/YxGAwG48JccgPPcRy2bNmCDz/8EIcPH6Yr5IQFCxZAIpEIqqRXV1ejsbER2dnZAIDs7GyUlpaio6ODHnPw4EGoVCqkpqZe6lNmMBgMt+SST9Fs3rwZe/fuxccffwwfHx86Z65Wq6FQKKBWq3Hvvfdi27Zt8Pf3h0qlwm9+8xtkZ2cjKysLALB69WqkpqZiw4YNeP7559He3o7HH38cmzdvvuhpGIb7QeZA+aO+nJwc2Gw2QWEPs9kMs9lMo5z6+/sxMDAgiIJavHgxbDYbhoaG6DwqqcjDL/ZBNkJAQACVESZRE0Re2MPDA1KplK7f8HM51q1bRyMzlEol3by8vODt7U03Hx8fQbvu7m7IZLIZkRfCmDyX/NexZ88eAMCKFSsEr7/55pv42c9+BgB48cUXIRaLccsttwgSnQgeHh44cOAANm3ahOzsbHh5eWHjxo145plnLvXpMqYRHMfBaDSisbGRvvbuu+/CbDajp6cH3d3d6OnpoXkEREa3r69PEAsNDM+NTobTp09Pqh0/RHcijCXidSGioqIADGvck9q/JIabXwPY399fMEfc0tKCyMhIViJyhnDJDfx41OPkcjl2796N3bt3j3lMVFQUPv/880t5aowp5MSJEzAajTQzl1RiGlmVia9cCYBq2UyUpKQkqNVqQWEPLy8veHl5CTxluVwOsViMX/ziFwCADz/8ECqVinrcI+OZiXcuEokwMDCAWbNmAQDKy8uhUCjAcZzA2ydFP/jFP/R6PW655RYAwKuvvkprepJRBRllkJGH0WiE0WiEXq9HTU2NoJ9kVNLS0jLu7wUYvjHwC8CTeHP+xiQAXB82vmNMmKGhISqfMHIb+Trh6quvHvf7KxQKDAwM0HbBwcEICAiAv78/9VD5GYck65DUzASG45MnEt1ADPwPfvCDSUVPRUVFTardnXfeOaF2JO+hp6cHdrudZkfzM6R7enoEI56Ojg6aJe7h4QG73U5vDPX19eP67MjISKrJT9L/iRQAf2NFQqYXzMAzAAzH+o7MACQbP8M3IiICvb29E37/8PBwgS4IvxoTfwsMDATHcdSQffrpp5MynO6OVCqFl5fXuAwq/8bQ19dHtY5I0s/IkRQZYZHCIADoTaO8vPy8n+Xh4SE4p02bNiEiIsLpTcHHx8flUv9dDWbg3RibzYbu7m46LdLQ0ED3/fKXv0R3dzf1uDs6OsaVSk2Mu0QiGXXRajQaQeUllUqFuXPnAgCqqqqYoZ4GiEQiOuqJj48/77H8G0N+fj4MBoNghMYXwdPpdOjq6oLdbhcsdr/11ltjvj+pVkV+LwEBAXTfhx9+iKioKOoIzDSRsEsFM/AuAsdxMJlM6O7uFnjUr7zyCoxGo8AbIx5ZT0/PmGsi77zzjtPXAwMDqaEmF5+/vz8ee+wxAEBBQQFiY2Ph7+9/wQuOGWr3YdasWRe8QVutVnR2dqKurg5Lly4FADz11FMCR4LcDIxGIwYGBlBXVyco7UjYsGGD4LlEIhGsFwQGBtLnJAEJGC62HhERAX9/f7aQDGbgrwj8OU/+ohlf++bPf/4zLbI8ck6VzKvabLZR7/3II4+c97NFIhECAgLoRXH06FEAw+p5ZOjMnzqRSCSj3sNsNlMDn5qayjJ1GU6RSCQIDQ0VVO56+OGHnf5ezGazoHasTqdDU1MTdu7cCQDIzMyk00gGgwFWqxWtra1obW097zmQUGtgeITAX68ZuWbDvwEcPHiQ3ixIaCpZkHflkQMz8Dz4nvFDDz0ET09PGu9MIiLIXxInPTQ0JFCOzMjIwODgIAYGBmhkxHhC6J566qlxnaNcLoefnx9Vw1u3bh00Go1gDps/tx0YGEhjpflD7oceeogZasaU4eXlNapYiNlspgb+0KFD9Pc5MDAgGJnyR6pk3ejAgQMAhkegvb29sNvtGBgYQEtLy7gijG6++eYx9ymVSpqnoFAoBGq2119/PZRKpSDqip//QPIiRCKRUwftcsMMPA++R/3qq69O6j0qKirG3EfkRvlhe6dOnQIA3HHHHQgMDKQeBj+u2c/Pj0aRKBQKgaH+97//zQw1w61RKBSjConz4V8P9fX1UCqVMBgMdGF4ZN4EUYrs7u7Ge++9BwCYPXu2YITNd9pI+Gp3d/eozz5y5Mhl6PGlgxl4Hnydm4cffligJnm+zESO46gq3YEDB+Dr60vjrBUKBY2/lslkguEe/4f597//nRlqBuMSIBKJoFaroVarR0ml8DGbzdTAHz9+XHD9ORwOQV4CGY0PDAygt7cXN954IwDgH//4B0QikdPMZ5vNJsh6HhwcxAsvvHB5Oz8CZuB58NUkn3rqqQlFfRADv2LFCmaoGQwXh4y2ndVb4AcP/PSnP52QnbjSBv6yqUkyGAwGY2phBp7BYDDcFGbgGQwGw01hBp7BYDDcFLbIypjx8LN99Xo9LBbLqEiIkTrwHMcJQukqKyuhVCqpJjx/8/DwoNFXnp6eAmnj8aivMhiThRl4xrSmvb0dDofDaeGOkQU89Ho9bfeTn/wEVqsVFotFsA0ODsJisWBoaIhu/AQUfr3NibBo0aJJtfPx8YFEIoFMJoNUKoVUKoVcLqcF3eVyORQKBeRyuSDL+OGHH4ZarabFQcjfkYVCvL29IRazgfpMhRl4xiXHYrGgr6+PZtsCwP79+2GxWGAwGKDX6wV/nW2ECwlijcWlqCVAvG6SB0E2kUhE8xl6enoAAP7+/gCGPXKiCT9SG34sMTcSPz0RSGGdiRIeHg61Wg2VSgUfHx+oVCr6nP94ZCp/XV0dQkJCoFarWRUpF4L9pxgCOI6jBppsfF33P/3pT+jv76f7iHYOyRLU6/VOpRnuuuuuSZ8Tv2gHXydkZAEPiUSCXbt2AQBeeukl+Pr6Uu+X7xVLpVLIZDLIZDJIJBLYbDaaENPd3Q21Wg0PD48Lnhc/Ua2xsfGC8dDE4Ov1eiqpW1NTA09PT1itVgwODgo2/ohjYGAAfX19uP/++wEMe/BWq1WQjEMyMckoh4x6+FNJ5P82UdLT0+ljfhUpZ5tSqaTHHj58GCEhIQINGGd6R4zLAzPwbobVaoVerxd4yWTjFzHfsmULzGYzNdB8Qz2y/B2fp59+elznIRKJoFKp6LTJ4sWL4e/vL/AQR3qOxJB7enpSmWGj0eg02cQZZrOZGvh77rlnUvLEMplsXMZ9MohEInh6ego8Y41GM6HzJAZ+Iol4BoOBCoCdPHmS1qrlj5ic/WZ6enpw4sQJAMN6LORGMZEqUjfccMOo15zdINRqtaA///jHPxAcHOz09+Lj43PZ/kfuBjPwU4TVahVMRVRWVtKFu5EeGV8jw2QyCQpuZGdno7+/n16o460N+q9//eu8+4luOLmoSK3SO++8E4GBgVSZT61WC1T6yObt7Y2BgQFqnL/++utJGVxXVvKbLvCNYXJy8qQqSHV0dEAqlcJgMAhGb0TjhTzW6/Xo6urCvn37AAyrj5IbBiluPp4bBLmRjQXRdFKpVIIRw7333gs/P79R6xAjR3wjvwOTyQS5XO52Nw5m4Hk4U5Mkc6p8VUl+vU2bzQaLxULbrV27Fna7nS7gjRxyk23kfOxkF+lKS0udvu7l5TVqTtXb2xsffvghAOCJJ55AUFAQNdJ8Q028abI4x7/QX331VSbFMEORSCQICAgQFOZwhtlspga+oKCA/l74o8uRNwm9Xo/Ozk46ArvuuutgMplGjS7I6JJMRfHXeQBQbZmJQnSoJBIJndIbOa1HNv5N4I477oBCoRBESo1UkSQbU5OcYrq6uujjyapJ5uTkTKpdQECAIBKC/9jLy0swBy2VSrF9+3YAw5VvgoKCqFEmQ1hnC2F8Q719+3ZmqBlXFIlEgsDAwDHLDPKn2Pbt2+f09zk4OAi9Xk+LkJO6Cj/+8Y8BADt27MDQ0BC9AYwVdUX+jlyPIAveRqNxXH365JNPJvANXHmYgeeh0Wjo44cffhhSqVQQOcG/M/Pjmh0OB7Zu3QoA+Oc//wkfHx+nYW8ymQwKhYIu/DkcDvpjb2homNDQmRj4iRSJZjBcHZlMRsv4EfhTelu3bp3UFJROp4NYLKYj7IGBAcHImz8iNxqN+PnPfw4AePHFFyEWiwWjev5In4z+OY7D4OAg/vSnP13Cb+PCMAPP42LUJImB/8lPfsJqjzIYLgYZKY8Hs9lMDfx99903oXZX2sCzDAgGg8FwU5iBZzAYDDeFGXgGg8FwU5iBZzAYDDeFGXgGg8FwU5iBZzAYDDeFGXgGg8FwU1gcPMNlIeqMJPuQn5VYX18PqVQKm80Gq9VKZSVIMgpfcoKfj/Dpp59CKpWOKu7B38hn83V/3n33XchkMqqdw09R5yfLicVigTTwwYMH4eXlRVPcSfIcSaSTSCT0Ob9dT08PHA4HpFIpJBIJ03xnOIUZeMaEIGncIwtpOCuswTe4f/vb36hR5EvhOtsGBgZou4ULF8JmswkKdJDNarWOWREpLS1tUv27/fbbJ9Xuvvvum1S7m2++eVLtIiMjBc/JzYCvmUI2vmzFtddeC4VCQTOrycbPtibP+UJv7733Hnx9fZ3qtIwsTDKW7j3jysMMvAswUryMbzhPnz4NsVg8prHkG1O+euX9998Pu90u2D8wMODUUPMNrp+f36T68Nhjj02qXVVV1aTaKRQKSCQSgQfM94z5GwCUlJQAADIyMqhHzPe6+R45MXx2ux2HDh0CAKxcuZK+F9/bHzkKcDgcsFqtKCgoAADMnj2bvtfI0YXVaqWvWa1W+v93BmnDF75zxnfffTep7/Pee++dVLvo6GiBJv/IjX+T4It47dq1CyqVatTNhzzma/rzbyhtbW3w9fWl+2f66EbEuWlRSKKBrdfroVKpxtWmuroaycnJAIBNmzZRz2fkBcu/cB0OBwYHB7F3714AwC233AKRSCTQoyDTA/xpAlJOrqysDAAQFRUlmG4gF/TQ0NC0rdtJLiJyAY98LJFIcPjwYQDAbbfdBi8vL8GF7cxzlEql4DiOFgj57LPP6IVO3pN4puQxMeRDQ0NU99xkMk1Kk8RV2vX29kIqlQp+K/zfDP+GoNfrcf311wMYlokWiUR0n7ORFLm5m81mfPDBBwCAFStWCNRR+c4AeexwOMbVjyuNh4eH4HdCNg8PD9TX1wMYvtGS39dIZ4D8JTpUHMfhP//5DwBg/fr1kMlk43IIbDYbrcQ1kf87MDl7BjADL+D777/H0qVLL/OZXTyenp5UelSj0YwykmN5PR4eHnjjjTcAAL/97W/h4+MzpnHmP+Y4DgsXLgQANDU1wd/fH3K5/IKekSsaTtZu8u2IdHZPTw+ioqIADMsFi0Qip6NEIuhFnhuNRjz//PMAgLvvvlswwjzflN7g4CAtZiMWi6ftjYbPlTLwbIqGhzM1SWeLZkRZktyt7XY7nnjiCQDAH//4RyiVynEtmtntdtx4440Ahkub+fj4CDwNvqdKvFuJRIL+/n564dXU1EzogiUG/vHHH5+UKJqfn5+gwAKDQfD09IS3t7dg7j41NXVCvzNi4F9++eVJ3YgMBgPkcrlgBDNyZEM2g8GAVatWARiW3fbw8BCMop1Nm9ntdgwMDFA112eeeYZ69RdalB8aGsILL7wwvi/zUsG5KXq9ngPA6fX6cbcxmUwcAA4AZzKZWDvWjrVj7aa8HcdNzp5xHMfN3NUHBoPBcHOYgWcwGAw3hRl4BoPBcFOYgWcwGAw3hRl4BoPBcFOYgWcwGAw3hRl4BoPBcFOYgWcwGAw3ZVob+N27dyM6OhpyuRyZmZlUoInBYDAYF2baShW899572LZtG1599VVkZmbir3/9K9asWYPq6moEBwdfls/keLI8/PT8C8E/lrVj7Vg71u5C7bgrJQE2obzXK0hGRga3efNm+txut3OhoaHczp07nR5vsVg4vV5Pt6ampgmn9up0OppKzDa2sY1tl2vT6XQTsoduJVUwNDSEwsJCKgQEDKvErVq1Crm5uU7b7Ny5E2q1mm4RERFX6nQZDAZjWjItp2i6urpgt9sF6o7AsNrjWAUgHn30UWzbto0+NxgMEzbygYGB0Ol0AAClUilQxTsfHMehv7+ftWPtWDvWblztAgMDx9XmYpmWBn4yEO3zi0EsFk96fp/IlbJ2rB1rx9pd6naTZVpO0QQGBsLDw4N60wSdTgetVjtFZ8VgMBiuxbQ08FKpFAsWLKD1LgHA4XDg0KFDyM7OnsIzYzAYDNdh2k7RbNu2DRs3bsTChQuRkZGBv/71rzCbzbj77run+tQYDAbDJZi2Bv62225DZ2cnnnzySbS3t2Pu3Ln48ssvRy28MhgMBsM5rOg2g8FgTHMma8+m5Rw8g8FgMC4eZuAZDAbDTWEGnsFgMNwUZuAZDAbDTWEGnsFgMNwUZuAZDAbDTWEGnsFgMNwUZuAZDAbDTZm2mawXC8nfMhgMU3wmDAaDcXEQOzbRvFS3NfBGoxEAWOEPBoPhNhiNRqjV6nEf77ZSBQ6HA62trfDx8Rm3ID/w30IhTU1NbilxwPrn2rD+uTaT7R/HcTAajQgNDYVYPP6Zdbf14MViMcLDwyfdXqVSueUPjMD659qw/rk2k+nfRDx3AltkZTAYDDeFGXgGg8FwU5iBH4FMJsNTTz110fVdpyusf64N659rc6X757aLrAwGgzHTYR48g8FguCnMwDMYDIabwgw8g8FguCnMwDMYDIabwgw8g8FguCnMwPPYvXs3oqOjIZfLkZmZiYKCgqk+pXGxc+dOLFq0CD4+PggODsZNN92E6upqwTEWiwWbN29GQEAAvL29ccstt0Cn0wmOaWxsxNq1a6FUKhEcHIyHH34YNpvtSnblguzatQsikQj3338/fc0d+tbS0oI777wTAQEBUCgUSE9Px8mTJ+l+juPw5JNPIiQkBAqFAqtWrcLZs2cF79HT04P169dDpVLB19cX9957L0wm05XuyijsdjueeOIJxMTEQKFQIC4uDs8++6xAOMuV+nf06FFcf/31CA0NhUgkwkcffSTYf6n6cvr0aVx11VWQy+WIiIjA888/P/GT5Rgcx3Hcvn37OKlUyv3zn//kysvLufvuu4/z9fXldDrdVJ/aBVmzZg335ptvcmVlZVxxcTH3ox/9iIuMjORMJhM95le/+hUXERHBHTp0iDt58iSXlZXFLV68mO632WxcWloat2rVKq6oqIj7/PPPucDAQO7RRx+dii45paCggIuOjuZmz57Nbd26lb7u6n3r6enhoqKiuJ/97Gdcfn4+V1tby3311VfcuXPn6DG7du3i1Go199FHH3ElJSXcDTfcwMXExHADAwP0mB/+8IfcnDlzuLy8PO67777j4uPjudtvv30quiRgx44dXEBAAHfgwAGurq6O++CDDzhvb2/ub3/7Gz3Glfr3+eefc4899hi3f/9+DgD34YcfCvZfir7o9XpOo9Fw69ev58rKyrh3332XUygU3GuvvTahc2UG/v+TkZHBbd68mT632+1caGgot3Pnzik8q8nR0dHBAeBycnI4juO4vr4+TiKRcB988AE9prKykgPA5ebmchw3/KMVi8Vce3s7PWbPnj2cSqXiBgcHr2wHnGA0GrmEhATu4MGD3PLly6mBd4e+bd++nVu6dOmY+x0OB6fVarkXXniBvtbX18fJZDLu3Xff5TiO4yoqKjgA3IkTJ+gxX3zxBScSibiWlpbLd/LjYO3atdw999wjeG3dunXc+vXrOY5z7f6NNPCXqi+vvPIK5+fnJ/h9bt++nUtKSprQ+bEpGgBDQ0MoLCzEqlWr6GtisRirVq1Cbm7uFJ7Z5NDr9QAAf39/AEBhYSGsVqugf8nJyYiMjKT9y83NRXp6OjQaDT1mzZo1MBgMKC8vv4Jn75zNmzdj7dq1gj4A7tG3Tz75BAsXLsSPf/xjBAcHY968eXj99dfp/rq6OrS3twv6qFarkZmZKeijr68vFi5cSI9ZtWoVxGIx8vPzr1xnnLB48WIcOnQIZ86cAQCUlJTg2LFjuPbaawG4fv/4XKq+5ObmYtmyZZBKpfSYNWvWoLq6Gr29veM+H7dVk5wIXV1dsNvtAgMAABqNBlVVVVN0VpPD4XDg/vvvx5IlS5CWlgYAaG9vh1Qqha+vr+BYjUaD9vZ2eoyz/pN9U8m+fftw6tQpnDhxYtQ+V+8bANTW1mLPnj3Ytm0bfve73+HEiRP4n//5H0ilUmzcuJGeo7M+8PsYHBws2O/p6Ql/f/8p7+Nvf/tbGAwGJCcnw8PDA3a7HTt27MD69esBwOX7x+dS9aW9vR0xMTGj3oPs8/PzG9f5MAPvZmzevBllZWU4duzYVJ/KJaGpqQlbt27FwYMHIZfLp/p0LgsOhwMLFy7Ec889BwCYN28eysrK8Oqrr2Ljxo1TfHYXz/vvv4933nkHe/fuxaxZs1BcXIz7778foaGhbtG/6QybogEQGBgIDw+PUZEXOp0OWq12is5q4mzZsgUHDhzAkSNHBFr4Wq0WQ0ND6OvrExzP759Wq3Xaf7JvqigsLERHRwfmz58PT09PeHp6IicnBy+99BI8PT2h0Whctm+EkJAQpKamCl5LSUlBY2MjgP+e4/l+n1qtFh0dHYL9NpsNPT09U97Hhx9+GL/97W/x05/+FOnp6diwYQMeeOAB7Ny5E4Dr94/PperLpfrNMgMPQCqVYsGCBTh06BB9zeFw4NChQ8jOzp7CMxsfHMdhy5Yt+PDDD3H48OFRQ7sFCxZAIpEI+lddXY3Gxkbav+zsbJSWlgp+eAcPHoRKpRplfK4kK1euRGlpKYqLi+m2cOFCrF+/nj521b4RlixZMiqs9cyZM4iKigIAxMTEQKvVCvpoMBiQn58v6GNfXx8KCwvpMYcPH4bD4UBmZuYV6MXY9Pf3j6pC5OHhAYfDAcD1+8fnUvUlOzsbR48ehdVqpcccPHgQSUlJ456eAcDCJAn79u3jZDIZ969//YurqKjgfvGLX3C+vr6CyIvpyqZNmzi1Ws19++23XFtbG936+/vpMb/61a+4yMhI7vDhw9zJkye57OxsLjs7m+4noYSrV6/miouLuS+//JILCgqaNqGEfPhRNBzn+n0rKCjgPD09uR07dnBnz57l3nnnHU6pVHJvv/02PWbXrl2cr68v9/HHH3OnT5/mbrzxRqehd/PmzePy8/O5Y8eOcQkJCdMiTHLjxo1cWFgYDZPcv38/FxgYyD3yyCP0GFfqn9Fo5IqKiriioiIOAPeXv/yFKyoq4hoaGi5ZX/r6+jiNRsNt2LCBKysr4/bt28cplUoWJnkxvPzyy1xkZCQnlUq5jIwMLi8vb6pPaVwAcLq9+eab9JiBgQHu17/+Nefn58cplUru5ptv5tra2gTvU19fz1177bWcQqHgAgMDuQcffJCzWq1XuDcXZqSBd4e+ffrpp1xaWhonk8m45ORk7u9//7tgv8Ph4J544glOo9FwMpmMW7lyJVddXS04pru7m7v99ts5b29vTqVScXfffTdnNBqvZDecYjAYuK1bt3KRkZGcXC7nYmNjuccee0wQAuhK/Tty5IjT623jxo2XtC8lJSXc0qVLOZlMxoWFhXG7du2a8LkyPXgGg8FwU9gcPIPBYLgpzMAzGAyGm8IMPIPBYLgpzMAzGAyGm8IMPIPBYLgpzMAzGAyGm8IMPIPBYLgpzMAzGAyGm8IMPIPBYLgpzMAzGAyGm8IMPIPBYLgp/w/zF/XVmz+YhwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Make a plot showing zeta horizons in x-z space\n", + "cells = 20 # Sets number of cells\n", + "plt.figure()\n", + "plt.title(\"The Curvilinear Grid\")\n", + "ax = plt.gca()\n", + "ax.set_aspect('equal')\n", + "# Plot the x lines\n", + "plt.plot(x_msh[:, ::grid.shape[0]//cells], z_msh[:, ::grid.shape[1]//cells], 'k')\n", + "# Plot the zeta horizons\n", + "plt.plot(x_msh.T[:, ::grid.shape[0]//cells], z_msh.T[:, ::grid.shape[1]//cells], 'k')\n", + "# Pick out the free surface in red\n", + "plt.plot(x_vals, z_xzeta(x_vals, (zeta_M-zeta_m), x_M, x_m,\n", + " z_b, z_m, zeta_M, zeta_m, h), 'r')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The transformed equation\n", + "\n", + "Now we can write out our transformed equation. Both derivatives in the Laplacian will have modified expressions reflecting the new coordinate system.\n", + "\n", + "These are substituted into the acoustic wave equation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from devito import TimeFunction, Eq\n", + "\n", + "# Wavespeed\n", + "c = 2. # km/s\n", + "\n", + "# Set up the TimeFunction and equations\n", + "p = TimeFunction(name=\"p\", grid=grid, time_order=2, space_order=so)\n", + "# Transformed derivative expressions (note these are not the shortcuts)\n", + "pdx2 = p.dx2+p.dx.dzeta*zeta_dx+(p.dx.dzeta+p.dzeta2*zeta_dx)*zeta_dx+p.dzeta*zeta_dxx\n", + "pdz2 = p.dzeta2*zeta_dz**2\n", + "\n", + "# Superficially resembles the untransformed equation\n", + "eq = Eq(p.forward, 2*p - p.backward + c**2*(pdx2 + pdz2),\n", + " subdomain=grid.subdomains['main'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The free surface\n", + "\n", + "We now implement the free surface on a horizontal plane in the iteration space by antisymmetric mirroring the pressure field across it." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from devito import sign, norm\n", + "from devito.symbolics import retrieve_functions, INT\n", + "\n", + "def free_surface_top(eq, subdomain, function):\n", + " \"\"\"\n", + " Modify a stencil such that it is folded back on\n", + " itself rather than leaving the model domain. This is\n", + " achieved by replacing the symbolic indices for some\n", + " function of those indices.\n", + " \n", + " Parameters\n", + " ----------\n", + " eq : Eq\n", + " The update stencil to modify\n", + " subdomain : FreeSurface\n", + " The subdomain in which the modification is\n", + " applied\n", + " function : Function\n", + " The Function to which the folding should be\n", + " applied\n", + " \"\"\"\n", + " lhs, rhs = eq.evaluate.args\n", + " \n", + " # Get vertical subdimension and its parent\n", + " zetafs = subdomain.dimensions[-1]\n", + " zeta = zetafs.parent\n", + " \n", + " # Functions present in stencil\n", + " funcs = retrieve_functions(rhs)\n", + " mapper = {}\n", + " for f in funcs:\n", + " if f.function is function:\n", + " # Get the zeta index\n", + " zetaind = f.indices[-1]\n", + " if (zetaind - zeta).as_coeff_Mul()[0] > 0:\n", + " # Flip the sign on folded-back points\n", + " s = sign(zetafs.symbolic_max\n", + " - zetaind.subs({zeta: zetafs, zeta.spacing: 1}))\n", + " # Antisymmetric mirror\n", + " mapper.update({f:\n", + " s*f.subs({zetaind: INT(zeta.symbolic_max*zeta.spacing\n", + " - abs(zeta.symbolic_max*zeta.spacing\n", + " - zetaind))})})\n", + " return Eq(lhs, rhs.subs(mapper), subdomain=subdomain)\n", + " \n", + "fs = free_surface_top(eq, grid.subdomains['freesurface'], p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now solve this equation as any other in Devito:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from examples.seismic import TimeAxis, RickerSource\n", + "\n", + "t0 = 0. # Simulation starts a t=0\n", + "tn = 650. # Simulation lasts 650ms\n", + "dt = grid.extent[0]/(2*c*(grid.shape[0]-1)) # Time step from model grid spacing\n", + "\n", + "time_range = TimeAxis(start=t0, stop=tn, step=dt)\n", + "\n", + "f0 = 0.009 # Source peak frequency is 9Hz (0.009 kHz)\n", + "src = RickerSource(name='src', grid=grid, f0=f0,\n", + " npoint=1, time_range=time_range)\n", + "\n", + "# First, position source centrally in all dimensions, then set depth\n", + "src.coordinates.data[0, :] = np.array(grid.extent)/2 # Centre first\n", + "src.coordinates.data[0, -1] = 3*grid.extent[1]/4 # Set depth\n", + "\n", + "src_term = src.inject(field=p.forward, expr=src*dt**2/c)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "tags": [ + "nbval-ignore-output" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Operator `Kernel` ran in 0.02 s\n" + ] + }, + { + "data": { + "text/plain": [ + "PerformanceSummary([(PerfKey(name='section0', rank=None),\n", + " PerfEntry(time=1e-06, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n", + " (PerfKey(name='section1', rank=None),\n", + " PerfEntry(time=0.01499099999999999, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n", + " (PerfKey(name='section2', rank=None),\n", + " PerfEntry(time=2.5000000000000008e-05, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from devito import Operator\n", + "\n", + "op = Operator([eq, fs] + src_term)\n", + "op(time=time_range.num-1, dt=dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the wavefield\n", + "\n", + "We will first plot the wavefield in the transformed space. As we can see, the top of the wavefield is flattened, with this flattening being most pronounced at the apex of the cosine hill." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "tags": [ + "nbval-ignore-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vmax = np.amax(np.abs(p.data[-1]))\n", + "vmin = -vmax\n", + "\n", + "plt.figure()\n", + "ax = plt.gca()\n", + "ax.set_aspect('equal')\n", + "plt.imshow(p.data[-1].T, origin='lower', cmap='seismic',\n", + " vmin=vmin, vmax=vmax)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Transforming back to physical space, the wavefront becomes circular and the focusing effect of the surface curvature becomes apparent." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false, + "tags": [ + "nbval-ignore-output" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Bootleg curvilinear plotter\n", + "plt.figure()\n", + "ax = plt.gca()\n", + "ax.set_aspect('equal')\n", + "plt.scatter(x_msh, z_msh, c=p.data[-1], s=3., cmap='seismic',\n", + " vmin=vmin, vmax=vmax)\n", + "# Pick out the surface horizon\n", + "plt.plot(x_vals, z_xzeta(x_vals, (zeta_M-zeta_m), x_M, x_m,\n", + " z_b, z_m, zeta_M, zeta_m, h), 'k')\n", + "plt.xlabel(\"x (m)\")\n", + "plt.ylabel(\"y (m)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "assert(np.isclose(np.linalg.norm(p.data), 154.39851))" + ] + } + ], + "metadata": { + "celltoolbar": "Tags", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}