{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Optimal complexity finite element assembly" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sum factorisation\n", "Suppose we are assemblying the 2-form of the Laplace operator on a hexahedral element, e.g. the Q3 element:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\"Q3\"
\n", "
$Q_3$ element on hexahedron. Image from the periodic table.
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since each quadrature point $X$ can be represented as a 3-tuple $q=\\{q_1,q_2,q_3\\}$, and each basis function by a 3-tuple $i = \\{i_1,i_2,i_3\\}$, the naive local assembly kernel for the local tensor $A_{ij}$ contains the loop structure:\n", "```\n", "for q1, q2, q3\n", " for i1, i2, i3\n", " for j1, j2, j3\n", " A[i1,i2,i3,j1,j2,j3] += ...\n", "```\n", "This requires $O(N_{q}^3N_{i}^6)$ FLOPs. For polynomial degree $p$, both $N_q$ and $N_i$ are $O(p)$, so this local assembly requires $O(p^9)$ FLOPs." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For *tensor product elements* like this, we can rearrange the contraction over quadrature points and hoist invariant sub-expressions out of the innermost loop into temporary variables. This is known as *sum factorisation*:\n", "```\n", "for q1, i1, j1\n", " t1[i1,j1] += ...\n", "for q2, i2, j2\n", " t2[i2,j2] += ...\n", "for q3\n", " for i1, i2, i3\n", " for j1, j2, j3\n", " A[i1,i2,i3,j1,j2,j3] += t1*t2*...\n", "```\n", "This reduces the complexity to $O(p^7)$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC \\[1\\], the form compiler of Firedrake, is capable of exploiting this intrinsic structure of the finite element, provided by FInAT \\[2\\], and apply sum factorisation automatically to generate assembly kernels with optimal algorithmic complexity." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib widget\n", "%config InlineBackend.figure_format = 'svg'\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams['figure.figsize'] = (11, 6)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from firedrake import *\n", "set_log_level(ERROR)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can create a hexahedral mesh by extruding a quadrilateral mesh." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "mesh = ExtrudedMesh(UnitSquareMesh(10, 10, quadrilateral=True), 10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's choose the continuous Lagrange element of degree 5 as our function space." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "p = 5\n", "V = FunctionSpace(mesh, \"CG\", p)\n", "u = TrialFunction(V)\n", "v = TestFunction(V)\n", "a = dot(grad(u), grad(v)) *dx # Laplace operator" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Firedrake internalises the process of local assembly. In order to look at the kernel, we need to import the compilation interface from TSFC." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from tsfc import compile_form" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC organises the optimisation passes into *modes*. Let's first try the *vanilla* mode, which does as little optimisation as possible:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "kernel_vanilla, = compile_form(a, parameters={\"mode\": \"vanilla\"})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "TSFC also lets us estimate the number of FLOPs performed by the kernel:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with vanilla mode is 4.45e+08\n" ] } ], "source": [ "print(\"Local assembly FLOPs with vanilla mode is {0:.3g}\".format(kernel_vanilla.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The default optimisation mode in TSFC is *spectral*, which applies sum factorisation to determine the tensor contraction order, and at each level, apply *argument factorisation* \\[3\\] to rearrange the expression using associative and distributive laws. Since *spectral* is the default mode, we do not need to specify it in the parameters." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with spectral mode is 5.45e+06\n" ] } ], "source": [ "kernel_spectral, = compile_form(a)\n", "print(\"Local assembly FLOPs with spectral mode is {0:.3g}\".format(kernel_spectral.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is a 43x reduction in FLOPs. Not bad, but there's opportunity to do better. For spectral elements, if we use the Gauss–Lobatto–Legendre (GLL) quadrature scheme, which has quadrature points collated with the Lagrange basis function nodes, then we know that the basis function tabulation is an indentity matrix. TSFC and FInAT can further simplify the loop structure of the local assembly kernels. This reduces the complexity to $O(p^5)$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to specify the GLL quadrature scheme for hexahedra. We can do this with FIAT, which defines GLL on intervals, and FInAT, which makes the tensor product scheme from the interval scheme." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "import FIAT, finat\n", "\n", "def gauss_lobatto_legendre_line_rule(degree):\n", " fiat_make_rule = FIAT.quadrature.GaussLobattoLegendreQuadratureLineRule\n", " fiat_rule = fiat_make_rule(FIAT.ufc_simplex(1), degree + 1)\n", " finat_ps = finat.point_set.GaussLobattoLegendrePointSet\n", " points = finat_ps(fiat_rule.get_points())\n", " weights = fiat_rule.get_weights()\n", " return finat.quadrature.QuadratureRule(points, weights)\n", "\n", "def gauss_lobatto_legendre_cube_rule(dimension, degree):\n", " make_tensor_rule = finat.quadrature.TensorProductQuadratureRule\n", " result = gauss_lobatto_legendre_line_rule(degree)\n", " for _ in range(1, dimension):\n", " line_rule = gauss_lobatto_legendre_line_rule(degree)\n", " result = make_tensor_rule([result, line_rule])\n", " return result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start by creating the spectral finite element function space of the same polynomial degree." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "element = FiniteElement('CG', mesh.ufl_cell(), degree=p, variant='spectral')\n", "V = FunctionSpace(mesh, element)\n", "u = TrialFunction(V)\n", "v = TestFunction(V)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to tell Firedrake to use the GLL quadratures for numerical integration." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "gll_quadrature_rule = gauss_lobatto_legendre_cube_rule(dimension=3, degree=p)\n", "a_gll = dot(grad(u), grad(v)) *dx(scheme=gll_quadrature_rule)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Local assembly FLOPs with GLL quadrature is 2.14e+05\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n" ] } ], "source": [ "kernel_gll, = compile_form(a_gll)\n", "print(\"Local assembly FLOPs with GLL quadrature is {0:.3g}\".format(kernel_gll.flop_count))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is a further 10x reduction in FLOPs.\n", "\n", "Now, let's verify that we achieve the expected asymptotic algorithmic complexity with respect to polynomial degrees." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "from collections import defaultdict\n", "import matplotlib.pyplot as plt\n", "import numpy" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n" ] } ], "source": [ "flops = defaultdict(list)\n", "ps = range(1, 33) # polynomial degrees\n", "modes = {\n", " 'gll': {'mode': 'spectral', 'variant': 'spectral', 'rule': gauss_lobatto_legendre_cube_rule},\n", " 'spectral': {'mode': 'spectral', 'variant': None, 'rule': lambda *args: None},\n", " 'vanilla': {'mode': 'vanilla', 'variant': None, 'rule': lambda *args: None}\n", "}\n", "\n", "for p in ps:\n", " for mode in modes:\n", " element = FiniteElement('CG', mesh.ufl_cell(), degree=p, variant=modes[mode]['variant'])\n", " V = FunctionSpace(mesh, element)\n", " u = TrialFunction(V)\n", " v = TestFunction(V)\n", " a = dot(grad(u), grad(v))*dx(scheme=modes[mode]['rule'](3, p))\n", " kernel, = compile_form(a, parameters={\"mode\": modes[mode]['mode']})\n", " flops[mode].append(kernel.flop_count)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b643618da54d41f791bdda429df36129", "version_major": 2, "version_minor": 0 }, "image/png": "iVBORw0KGgoAAAANSUhEUgAABEwAAAJYCAYAAAB4lnMNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD18ElEQVR4nOzdeXjUZZrv/3dVZd83AiQkZE8ICUnYERUEBFGQVVEEQdSenhm77fb09LSn59jTM3PG6zrd02O3p3/HGRVcUVRwRXFBBEUUgSQkZCFkYc1CAknIXqn6/v4oqBgUBQW+WT6v6+qrredbqboDSUh96nnu22IYhoGIiIiIiIiIiLhZzS5ARERERERERKSvUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4FJiIiIiIiIiIi51FgIiIiIiIiIiJyHgUmIiIiIiIiIiLnUWAiIiIiIiIiInIeBSYiIiIiIiIiIudRYCIiIiIiIiIich4PswuQvs/pdHLixAkCAwOxWCxmlyMiIiIiItJvGIbBmTNniIqKwmrVnoX+RIGJfK8TJ04QExNjdhkiIiIiIiL91tGjRxkxYoTZZcglUGAi3yswMBBwfYMHBQWZXI2IiIiIiEj/0dzcTExMjPt1lfQfCkzke507hhMUFKTARERERERE5AdQe4P+RweoRERERERERETOo8BEREREREREROQ8CkxERERERERERM6jHiZyWTgcDux2u9llyLfw8vLS+DIREREREZFLpMBEfhTDMKipqaGxsdHsUuQCrFYr8fHxeHl5mV2KiIiIiIhIv6HARH6Uc2FJZGQkfn5+6vzcxzidTk6cOEF1dTWxsbH6+xEREREREblICkzkB3M4HO6wJDw83Oxy5AKGDBnCiRMn6O7uxtPT0+xyRERERERE+gU1NpAf7FzPEj8/P5Mrke9y7iiOw+EwuRIREREREZH+Q4GJ/Gg65tG36e9HRERERETk0ikwEbmAuLg4HnvsMfdti8XCG2+8YVo9IiIiIiIicvUoMBEREREREREROY8CExERERERERGR8ygwkUHrzJkz3HXXXfj7+zN8+HD+8z//k+nTp/OLX/zC7NJERERERETEZApMZNB66KGH2LlzJ2+99RYffvghn376Kfv27TO7LBEREREREekDPMwuQAYWwzBot5szvtbX03bRE2HOnDnDs88+y/r165k5cyYA69atIyoq6kqWKCIiIiIiIv2EAhO5rNrtDtIfed+U5y76lzn4eV3cl3RFRQV2u52JEye614KDg0lNTb1S5YmIiIiIiEg/oiM5IiIiIiIi0q8ZhkFRQ5HZZcgAox0mcln5etoo+pc5pj33xUpISMDT05OvvvqK2NhYAJqamjh48CDXX3/9lSpRREREREQuI6fh5OMjH/NkwZMUNRSx6dZNJIcmm12WDBAKTOSyslgsF30sxkyBgYGsWrWKf/iHfyAsLIzIyEh+97vfYbVaL7oPioiIiIiImKPb2c17le/xVMFTVDRVAODr4Uvp6VIFJnLZ9P1XtiJXyJ/+9Cd++tOfMm/ePIKCgvj1r3/N0aNH8fHxMbs0ERERERH5Fl2OLt449AZrC9dyvOU4AIGegdyRdgcr01cS6hNqcoUykCgwkUErMDCQF1980X27tbWV3//+9/zkJz8BoKqqqtf9DcO4muWJiIiIiMhZbfY2Xjv4Gs8eeJa69joAwnzCWJm+kmWpywj0CjS5QhmIFJjIoJWbm0tJSQkTJ06kqamJf/mXfwFgwYIFJlcmIiIiIiIAzV3NrC9ez4vFL9LY2QhApF8k94y+hyUpS/D18DW3QBnQFJjIoPbHP/6R0tJSvLy8GDduHJ9++ikRERFmlyUiIiIiMqjVt9fzQtELvFz6Mq32VgBiAmO4N+Ne5ifOx8vmZXKFMhgoMBlAFi1axCeffMLMmTN57bXX3OtxcXEEBQVhtVoJDQ1l27ZtJlbZd+Tk5LB3716zyxARERERkbNqWmtYV7iOjWUb6XR0ApAUksT9mfczO242Hla9hJWrR19tA8iDDz7ImjVrePbZZ79x7fPPPycgIMCEqkRERERERL7b4ebDPF3wNG9XvE23sxuAzIhM7s+8n2kx07BarCZXKIORApMBZPr06XzyySdmlyEiIiIiInJRSk+V8lTBU3xw+AOchhOACcMmcH/m/UwePhmLxWJyhTKYKabrI3bs2MH8+fOJiorCYrHwxhtvfOM+f/3rX4mLi8PHx4dJkyaxe/fui3psi8XCtGnTmDBhQq+pMCIiIiIiImbIP5nPz7b+jKVvL2VL1RachpNpI6bx/NznWTtnLVOipigsEdNph0kf0draSlZWFmvWrGHx4sXfuL5hwwYeeughnnjiCSZNmsRjjz3GnDlzKC0tJTIy8jsf+7PPPiM6Oprq6mpmzZpFZmYmY8aMuVKfioiIiIiIyDcYhsHumt08uf9Jvqz5EgALFubEzeG+zPtIDUs1uUKR3hSY9BFz585l7ty5F7z+pz/9ifvvv5977rkHgCeeeILNmzezdu1afvOb33znY0dHRwMwfPhwbr75Zvbt2/edgUlnZyednZ3u283NzZfyqYiIiIiIiLg5DSfbj27nqYKn2F+/HwAPiwfzEudxb8a9xAXHmVugyAUoMOkHurq62Lt3Lw8//LB7zWq1MmvWLHbt2vWdH9va2orT6SQwMJCWlhY+/vhjbr/99u/8mEcffZTf//73l6V2EREREREZnLqd3XxQ9QFPFjzJocZDAHjbvFmcvJh7Rt/D8IDhJlco8t0UmPQD9fX1OBwOhg4d2mt96NChlJSUuG/PmjWL/Px8WltbGTFiBK+++ipDhw5l0aJFADgcDu6//34mTJjwnc/38MMP89BDD7lvNzc3ExMTcxk/I7ncpk+fTnZ2No899pjZpYiIiIjIINfl6OLt8rd5uvBpjp45CoC/pz93pN7BivQVRPhGmFyhyMVRYDKAfPTRR9+6np+ff0mP4+3tjbe39+UoSS5g9erVNDY2fmtzXxERERGR/qjN3sbGso08c+AZ6trqAAjxDmHFqBXckXYHwd7BJlcocmkUmPQDERER2Gw2amtre63X1tYybNgwk6qSq8Fut+Pp6Wl2GSIiIiIiF9Tc1czLJS/zQtELnO48DUCkbySrM1azJHkJfp5+Jlco8sNorHA/4OXlxbhx49i6dat7zel0snXrVqZMmWJiZf3ba6+9RmZmJr6+voSHhzNr1ixaW1tZvXo1Cxcu5Pe//z1DhgwhKCiIn/70p3R1dbk/1ul08uijjxIfH4+vry9ZWVm89tprvR7/wIEDzJs3j6CgIAIDA7nuuusoLy/nn//5n3n22Wd58803sVgsWCwWPvnkE6qqqrBYLGzYsIFp06bh4+PDiy++SENDA3feeSfR0dH4+fmRmZnJSy+9dLX/uEREREREemlob+DP+/7MnNfm8Hju45zuPM2IgBE8MuUR3lvyHivTVyoskX5NO0z6iJaWFg4dOuS+XVlZSV5eHmFhYcTGxvLQQw+xatUqxo8fz8SJE3nsscdobW11T82RS1NdXc2dd97J//k//4dFixZx5swZPv30UwzDAGDr1q34+Pi4g4x77rmH8PBw/vf//t+AqzHuCy+8wBNPPEFycjI7duxgxYoVDBkyhGnTpnH8+HGuv/56pk+fzscff0xQUBA7d+6ku7ubX/3qVxQXF9Pc3My6desACAsL48SJEwD85je/4T/+4z/IycnBx8eHjo4Oxo0bxz/+4z8SFBTE5s2bWblyJYmJiUycONGcP0ARERERGbSqW6p55sAzbCzbSKfDNV0zKSSJ+zLvY07cHDysepkpA4O+kvuIPXv2cMMNN7hvn2u6umrVKp555hmWLVvGyZMneeSRR6ipqSE7O5stW7Z8oxGs6QwD7G3mPLenH1gsF3XX6upquru7Wbx4MSNHjgQgMzPTfd3Ly4u1a9fi5+fH6NGj+Zd/+Rf+4R/+gX/913/Fbrfz7//+73z00UfuHT4JCQl89tln/Nd//RfTpk3jr3/9K8HBwbz88svuIzUpKSnux/f19aWzs/Nbj1T94he/YPHixb3WfvWrX7n/+2c/+xnvv/8+r7zyigITEREREblqqpqqWFu4lrfL36bb6AYgMyKT+zPvZ1rMNKwWHWCQgUWBSR8xffp09+6GC3nggQd44IEHrlJFP5C9Df49ypzn/p8nwMv/ou6alZXFzJkzyczMZM6cOcyePZulS5cSGhrqvu7n17N9cMqUKbS0tHD06FFaWlpoa2vjxhtv7PWYXV1d5OTkAJCXl8d11133g/qPjB8/vtdth8PBv//7v/PKK69w/Phxurq66Ozs7FWfiIiIiMiVUnKqhKcKnuKDqg8wcL1mmTRsEveNuY9JwyZhucg3LUX6GwUmMijZbDY+/PBDPv/8cz744AMef/xxfvvb3/Lll19+78e2tLQAsHnzZqKjo3tdOzddyNfX9wfX5u/fO/T5wx/+wJ///Gcee+wxMjMz8ff35xe/+EWvnioiIiIiIpdbbl0uT+5/kk+Pf+pemz5iOvdm3kt2ZLZ5hYlcJQpM5PLy9HPt9DDruS+BxWJh6tSpTJ06lUceeYSRI0fy+uuvA65RzO3t7e7g44svviAgIICYmBjCwsLw9vbmyJEjTJs27Vsfe8yYMTz77LMXnHLj5eWFw+G4qDp37tzJggULWLFiBeBqOHvw4EHS09Mv6fMVEREREfk+hmHw+YnPebLgSfbW7gXAarEyJ24O92bcS2pYqskVilw9Ckzk8rJYLvpYjJm+/PJLtm7dyuzZs4mMjOTLL7/k5MmTjBo1iv3799PV1cW9997LP/3TP1FVVcXvfvc7HnjgAaxWK4GBgfzqV7/il7/8JU6nk2uvvZampiZ27txJUFAQq1at4oEHHuDxxx/njjvu4OGHHyY4OJgvvviCiRMnkpqaSlxcHO+//z6lpaWEh4cTHHzhmfTJycm89tprfP7554SGhvKnP/2J2tpaBSYiIiIictk4DScfH/mYJwuepKihCAAPqwcLEhewJmMNsUGxJlcocvUpMJFBKSgoiB07dvDYY4/R3NzMyJEj+Y//+A/mzp3Lhg0bmDlzJsnJyVx//fV0dnZy55138s///M/uj//Xf/1XhgwZwqOPPkpFRQUhISGMHTuW//k//ycA4eHhfPzxx/zDP/wD06ZNw2azkZ2dzdSpUwG4//77+eSTTxg/fjwtLS1s27aNuLi4b631n/7pn6ioqGDOnDn4+fnxk5/8hIULF9LU1HSl/5hEREREZICzO+28V/keTxU8RWVTJQC+Hr4sSV7CqtGrGOb/zSEFIoOFxfi+TqMy6DU3NxMcHExTUxNBQUHu9Y6ODiorK4mPj8fHx8fECi+v1atX09jYyBtvvGF2KZfFQP17EhEREZEfrqO7gzcOvcG6wnWcaHUdqQ/0DOTOUXdy16i7CPMJM7nCgeNCr6ek79MOExERERERkUGipauFVw6+wnMHnqOhowGAMJ8w7k6/m2WpywjwCjC5QpG+Q4GJiIiIiIjIAHe64zQvFr/I+pL1nOk6A8Bw/+Hck3EPi5IW4eOhncgi51NgInKeZ555xuwSREREREQui5rWGp498CwbyzbS3t0OQFxQHPdl3sfNCTfjaf3mREcRcVFgIiIiIiIiMsAcbj7MusJ1vFn+Jt3ObgBGhY3ivsz7mBk7E5vVZnKFIn2fAhMREREREZEBovRUKU8VPMUHhz/AaTgBGD90PPdn3s+UqClYLBaTKxTpPxSYiIiIiIiI9HN5dXk8WfAkO47tcK9dP+J67su8j5zIHBMrE+m/FJiIiIiIiIj0Q4Zh8PmJz3my4En21u4FwGqxMnvkbO7NvJe0sDSTKxTp3xSYiIiIiIiI9CNOw8nWI1t5cv+TFJ8qBsDD6sGtibeyJmMNI4NGmlzh1WW322lubiY8PNzsUmSAUWAiIiIiIiLSD9iddjZXbObpgqepaq4CwNfDlyXJS1g1ehXD/IeZW6AJjh07xoYNG/D19eVv//Zv1aNFLiur2QWIDERVVVVYLBby8vIA+OSTT7BYLDQ2NgKu0cUhISGm1SciIiIi/Ud7dzsvFr/ILZtu4X/t/F9UNVcR6BXI34z5G95f8j7/OPEfB2VYAhAREYHdbqerq8v9u7bI5aIdJiJXQExMDNXV1URERJhdioiIiIj0U81dzWwo2cALxS9wquMUAOE+4awavYrbUm4jwCvA5Aqvrs7OTnbv3k1TUxPz5s0DwMfHh1WrVhEZGYnNplHJcnkpMBG5Amw2G8OGDc6UX0RERER+nPr2el4oeoENpRtosbcAEB0QzZqMNSxIWoC3zdvkCs3R1NTExx9/DMCkSZMYMmQIAMOHDzezLBnAdCRHBp3//u//JioqCqfT2Wt9wYIFrFmzhvLychYsWMDQoUMJCAhgwoQJfPTRR73uGxcXx7//+7+zZs0aAgMDiY2N5b//+7/d188/kvN9LuY5RURERGRgO9Fygv/9xf/mpo038XTh07TYW0gKSeLfr/133ln0Dren3j6owpL29nYqKyvdtyMjI7nmmmtYtGiRGrzKVaHARAad2267jYaGBrZt2+ZeO3XqFFu2bOGuu+6ipaWFm2++ma1bt5Kbm8tNN93E/PnzOXLkSK/H+Y//+A/Gjx9Pbm4uf/d3f8ff/u3fUlpa+oNqutjnFBEREZGBp7yxnN9+9ltu2XQLL5e+TKejkzERY/jzDX9m460bmZ84Hw/r4DocUFdXx2OPPcaGDRvo6Ohwr994442MGTMGq1UvZeXKG1zfdXLFGYZBe3e7Kc/t6+F7UV2xQ0NDmTt3LuvXr2fmzJkAvPbaa0RERHDDDTdgtVrJyspy3/9f//Vfef3113nrrbd44IEH3Os333wzf/d3fwfAP/7jP/Kf//mfbNu2jdTU1EuuPSsr66KeU0REREQGjsL6Qp4qeIqtR7a61yYPn8z9mfczYdiEQTfxxTAM9+c8ZMgQgoODsVqtNDc34+PjY3J1MhgpMJHLqr27nUnrJ5ny3F8u/xI/T7+Luu9dd93F/fffz//3//1/eHt78+KLL3LHHXdgtVppaWnhn//5n9m8eTPV1dV0d3fT3t7+jd0eY8aMcf+3xWJh2LBh1NXV/aDaL/Y5RURERKR/MwyD3TW7eargKb6o/sK9PjN2Jvdl3kdGRIaJ1Zmjvb2dHTt2cPToUe69914sFgsWi4WVK1cSEBAw6IIj6TsUmMigNH/+fAzDYPPmzUyYMIFPP/2U//zP/wTgV7/6FR9++CF//OMfSUpKwtfXl6VLl9LV1dXrMTw9PXvdtlgs3+iLcrEu9jlFREREpH9yGk62Hd3G0wVPU1BfAIDNYuOWhFtYk7GGxJBEkys0V25uLp2dnVRUVJCY6PqzCAwMNLkqGewUmMhl5evhy5fLvzTtuS+Wj48Pixcv5sUXX+TQoUOkpqYyduxYAHbu3Mnq1atZtGgR4Nr9UVVVdSVKdjPjOUVERETkyrM77Wyp3MLTBU9T3lQOgLfNm8XJi1k9ejVRAVEmV3j1NTU1UV5e7v7929fXlzlz5hAYGEhCQoLJ1Yn0UGAil5XFYrnoYzFmu+uuu5g3bx4HDhxgxYoV7vXk5GQ2bdrE/PnzsVgs/K//9b9+8M6Ri2XGc4qIiIjIldPR3cEbh97gmQPPcLzlOAABngHckXYHd426iwjfCJMrNMeZM2d4/PHHcTgcxMbGEhHh+nPIyckxuTKRb1JgIoPWjBkzCAsLo7S0lOXLl7vX//SnP7FmzRquueYaIiIi+Md//Eeam5uvaC1mPKeIiIiIXH5nus6woXQDzxc9z6mOUwCE+YSxMn0ly1KXEeg1+I6ZdHV14eXlBbiO2SQnJ9PZ2YnD4TC5MpHvZjEMwzC7COnbmpubCQ4OpqmpiaCgIPd6R0cHlZWVxMfHq2t1H6a/JxEREZErr6G9gReLX+Tlkpc5Yz8DQJR/FKszVrMoaRE+HoPv97COjg7ee+89Dh06xM9//nO8vb0BsNvt3+gHOJBd6PWU9H3aYSIiIiIiIvIDnWg5wTMHnmFT2SY6HZ0AJAQncG/mvcyNn4undfAEA+fz8vLi+PHjtLW1UVZWRkaGawLQYApLpH9TYCIiIiIiInKJyhvLWVu4lncr3qXb6AYgIzyD+8bcxw0xN2C1WE2u8Oqrra1l//79zJo1C4vFgtVqZd68eXh5eREVNfia20r/p8BERERERETkIhWcLOCpgqf4+OjH7rXJwydzb+a9TBo2CYvFYmJ15unq6mLt2rV0dXURGxtLamoqAHFxceYWJvIjKDARERERERH5DoZh8EX1Fzxd8DRf1nzpXp8ZO5P7Mu8jIyLDxOrMc/r0aUJDQwHX8ZuJEydy+vRpwsLCTK5M5PJQYCIiIiIiIvItnIaTj498zNMFT1PYUAiAh8WDmxNu5t6Me0kISTC5QnN0d3ezYcMGysvL+fu//3vCw8MB1xTKwbrDRgYmBSYiIiIiIiJfY3fY2Vy5mbWFa6lsqgTAx+bD4uTFrBq9iqiAwd2Pw8PDA6vV1aOlqqrKHZgoLJGBRoGJiIiIiIgI0GZvY1PZJp4tepaa1hoAAj0DuSPtDu4adRfhvuEmV3j1GYbB4cOH+fLLL1m0aBFeXl4AzJ49mzlz5uj4jQxoCkxERERERGRQa+ps4qWSl3ix+EUaOxsBiPCNYGX6Sm5PuZ0ArwBzCzSRYRi8/fbbnDp1iq+++oqpU6cCuHeViAxkCkxERERERGRQqmur47kDz/HqwVdp624DYETACO7JuIcFSQvwtnmbXOHVd25HyciRI92jgadNm8axY8fIyBiczW1l8FJgIiIiIiIig8qR5iOsLVzLW+VvYXfaAUgJTeHejHuZHTcbD+vgfJlkGAbPPfccVVVVLF++nOTkZADGjBnDmDFjTK5O5OobnD8JRERERERk0CluKObpwqf58PCHOA0nAGMjx3Jv5r1cF33doG9aarFYGD58OMePH6exsdHsckRMp8BE5DvExcURFBSE1WolNDSUbdu2mV2SiIiIiFwCwzDYU7uHpwueZueJne7160dcz5qMNYwbOs7E6sxVVFTEZ599xtKlS93NW6+99lqmTp2Kv7+/ydWJmE+Bicj3+PzzzwkIGLyNvkRERET6I6fhZPvR7TxV+BT7T+4HwGqxclPcTazJWENqWKrJFZovNzeX6upqPv/8c+bNmweAn5+fyVWJ9B0KTEREREREZMCwO+1sqdzC2sK1HGo8BICX1YtFyYtYNXoVMYExJldoDqfTyYEDB0hLS8PT0xOAadOmERUVxeTJk02uTqRvUmAi8h0sFgvTpk3DarXyi1/8grvuusvskkRERETkW7R3t/N62es8e+BZTrSeACDAM4BlqctYkb6CCN8Ikys01/r16ykvL2f27NlMmTIFgBEjRjBixAiTKxPpuxSYiHyHzz77jOjoaKqrq5k1axaZmZnqEC4iIiLShzR1NrGhdAMvFr/IqY5TAIT5hLEyfSXLUpcR6BVocoXmcDgcWK1WdyPb9PR0Tpw44d5dIiLfz2p2AXL5LFq0iNDQUJYuXepea2xsZPz48WRnZ5ORkcGTTz5pYoV9S01NDRaLhT//+c/k5OTg4+PD6NGj+eyzz9z3iY6OBmD48OHcfPPN7Nu3z6xyRURERORr6trq+I89/8Hs12bzeO7jnOo4RXRANL+d9FveX/I+92XeN2jDktzcXB5//HEqKirca1lZWfziF79g/PjxJlYm0r9oh8kA8uCDD7JmzRqeffZZ91pgYCA7duzAz8+P1tZWMjIyWLx4MeHh4SZW2jfk5eUBsHbtWv7yl78wdOhQfvnLX3LXXXdRWVlJe3s7TqeTwMBAWlpa+Pjjj7n99tvNLVpERERkkDvcfJh1het4q/wt7E47AMmhydybcS9z4ubgYdVLnNraWpqamtizZw+JiYkA2Gw2bDabyZWJ9C/6aTKATJ8+nU8++aTXms1mc3e67uzsxDAMDMO44rV0dXVd8sd4eHhgtbo2PTmdTrq7u7FYLL22DV7ocb28vC75+fLz8/H09OTNN98kLi4OgH/7t39j/PjxHD9+HLvdzqJFiwDXlsb777+fCRMmXPLziIiIiMiPV9RQxNMFT/Ph4Q8xcP0+OzZyLPdm3st10de5j54MNna7nb1795KWlkZISAgAU6dOJTQ0lLFjx5pbnEg/p8Ckj9ixYwd/+MMf2Lt3L9XV1bz++ussXLiw133++te/8oc//IGamhqysrJ4/PHHmThx4vc+dmNjI9OmTaOsrIw//OEPRERc+YZXjz766CV/zNKlSxk9ejQAxcXFvPbaa4wcOZLVq1e77/PnP/+Ztra2b3zs7373u0t+vry8PBYvXuwOSwCCgoLc/52QkEB+fv4lP66IiIiIXB6GYfBVzVc8Xfg0n5/43L1+/YjruTfjXsYOVSDw5ptvcuDAAU6ePMn8+fMB1y7zSZMmmVyZSP+nHiZ9RGtrK1lZWfz1r3/91usbNmzgoYce4ne/+x379u0jKyuLOXPmUFdX972PHRISQn5+PpWVlaxfv57a2trLXX6/lJeXR3Z2dq+1Xbt2ERER4e5dIiIiIiJXn9NwsvXIVu569y7u/eBePj/xOTaLjVsSbuG1+a/x15l/HbRhSWdnJ93d3e7bEydOJCQkhJiYwTkuWeRK0g6TPmLu3LnMnTv3gtf/9Kc/cf/993PPPfcA8MQTT7B582bWrl3Lb37zm4t6jqFDh5KVlcWnn37aqzHs+To7O+ns7HTfbm5uvsjPosfDDz98yR/j4dHz5Thq1Cgefvjhb2ytfPDBBy/5cb9Ne3s7ZWVlOBwO95rT6eSxxx5j1apV7qNBIiIiInL12B12NlduZm3hWiqbKgHwtnmzMGkhq0evZkTg4B6B+9VXX/Hxxx8zffp09w6S2NhYfvazn+n3V5ErQIFJP9DV1cXevXt7hRBWq5VZs2axa9eu7/zY2tpa/Pz8CAwMpKmpiR07dvC3f/u33/kxjz76KL///e9/VM0/pKfI11mt1m99jB/7uOcUFBRgsVh44YUXmDFjBiEhITzyyCM0NjbyT//0T5flOURERETk4rTZ29hYtpFnDzxLbZtrN3SgZyB3pN3B8lHLifC98kfK+wOLxUJHRwelpaW9jtwoLBG5MhSY9AP19fU4HA6GDh3aa33o0KGUlJS4b8+aNYv8/HxaW1sZMWIEr776KjabjZ/85CfuZq8/+9nPyMzM/M7ne/jhh3nooYfct5ubmwfcFr+8vDzS0tL49a9/zZIlS2hqamLOnDls377d3SxLRERERK6s0x2nWV+ynvXF62nucu1qjvCN4O70u7kt5TYCvAJMrtA8bW1t7Nq1i8TERHfPvezsbHx9fRk1apS5xYkMEgpMBpCPPvroW9fPjc+9WN7e3nh7e1+Givqu/Px8MjMzWblyJStXrjS7HBEREZFBpbqlmueKnmNj2Ubau9sBiA2M5Z6Me5ifOB9v28D+XfRi7Nixgy+//JKjR4+6hyB4eHi4hySIyJWnwKQfiIiIwGazfaNZa21tLcOGDTOpqv4tLy/P3UVcRERERK6O8sZy1hau5d2Kd+k2XI1LR4WN4t7Me5kVOwub1WZyheZpaWnBYrHg7+8PwDXXXMPx48eZPHkyhmEM2rHJImZSYNIPeHl5MW7cOLZu3eoeNex0Otm6dSsPPPCAucX1Q4ZhUFBQwG9/+1uzSxEREREZFPLq8ni68Gk+OfqJe23SsEmsyVzDlOFTBn0YsGfPHt5//32ys7O55ZZbAAgKCuLee+81uTKRwU2BSR/R0tLCoUOH3LcrKyvJy8sjLCyM2NhYHnroIVatWsX48eOZOHEijz32GK2tre6pOXLxLBbLD5r8IyIiIiIXzzAMPjv+GU8XPs3e2r0AWLAwM3Ym92beS0ZEhskV9h0RERF0d3dTX1+v3SQifYgCkz5iz5493HDDDe7b55qurlq1imeeeYZly5Zx8uRJHnnkEWpqasjOzmbLli3faAQrIiIiImKmbmc371e9z9rCtRw8fRAAD6sHtybeyurRq4kPjje5QnM1Njby6aefEhUVxbhx4wAYOXIk9957L9HR0QpLRPoQBSZ9xPTp0zEM4zvv88ADD+gIjoiIiIj0Se3d7bxx6A2ePfAsx1uOA+Dn4cfSlKXcnX43Q/31Rh/AwYMH2bdvH4cOHSI7OxubzYbFYmHEiBFmlyYi51FgIiIiIiIiP1hTZxMvl7zMi8UvcrrzNABhPmEsT1vOHWl3EOwdbHKF5mpoaMDhcBAZGQnA2LFjOXr0KBMmTMBmG7xNbkX6AwUmIiIiIiJyyWpaa3i+6HlePfiqezRwdEA0q0avYmHSQnw9fE2u0Hy5ubm8/fbbxMXFcffddwOu0cBLliwxuTIRuRgKTERERERE5KJVNFaw7sA63ql4h26nazRwSmgK92bcy+y42XhYB/dLjK83bU1ISMBqteLp6YndbsfT09Pk6kTkUgzun2YiIiIiInJR8k/ms7ZgLR8f/di9Nn7oeNZkrOHa6GsHfbPSkydPsm3bNoKCgrjpppsACA4O5uc//zlBQUEmVyciP4QCExERERER+VbnRgOvLVzLnto97vUZMTNYk7mGrCFZJlbXt5w5c4bi4mI8PT2ZPn06Pj4+AApLRPoxBSYiIiIiItJLt7ObLVVbWFe4rtdo4HkJ87hn9D0khCSYXKH5jh07RkdHB0lJSQDEx8dz/fXXk5GR4Q5LRKR/U2AiIiIiIiKAazTwprJNPHfgOU60ngB6RgOvTF/JMP9hJlfYNxQVFfHqq68SEhLCAw884B4NfMMNN5hdmohcRgpMREREREQGucaORl4qeYn1Jetp7GwEXKOB7xp1F8tSlw360cAAXV1deHl5AZCcnExQUBBxcXF0dXXh66uJQCIDkQITEREREZFBqrqlmueKnmNj2cZeo4FXj17NwqSF+HjoaEldXR3vvvsuHh4erFixAgBPT08eeOABTb0RGeAUmIhcQGlpKcuWLet1+6WXXmLhwoXmFSUiIiJyGZSdLmNd4Treq3yPbsM1GjgtLI01GWu4ceSNg3408Nd5enpy5MgRrFYrTU1NBAcHu9dFZGDTT0KRC0hNTSUvLw+AlpYW4uLiuPHGG80tSkRERORH2Fe7j6cLn2bHsR3utUnDJrEmYw1ToqYM+tHAhmFQVlZGY2MjEydOBCA0NJRFixYxcuRITbwRGWQUmIhchLfeeouZM2fi7+9vdikiIiIil8RpONl+dDtrC9eSdzIPAAsWZo2cxZqMNWREZJhbYB9hGAaHDx/mpZdewsPDg9GjR7t/98vMzDS5OhExgwITkYvwyiuvcPfdd5tdhoiIiMhFszvsvFPxDs8ceIaKpgoAPK2e3Jp4K6tHryYuOM7cAvsAwzBoamoiJCQEi8XCyJEjiY+PZ/jw4VitVrPLExGTKTAR+R7Nzc18/vnnvPzyy2aXIiIiIvK9WrpaeO3gazxf9Dx17XUABHgGcHvq7awYtYIhfkNMrrBvqK+v55VXXqG7u5sHHngAq9WKxWJh5cqVg/5okoi4KDCRQaumpobhw4fz2GOP8cwzz1BcXExiYiL/9V//xbXXXuu+35tvvsns2bPx8VGXeBEREem76tvreaHoBV4pfYUz9jMARPpGsjJ9JUtTlhLgFWByhX1LUFAQra2tOBwO6urqGDZsGIDCEhFxU2Aig9a5hq5r167lL3/5C0OHDuWXv/wld911F5WVle5tmK+88go/+clPTKxURERE5MKqmqp45sAzvFX+FnanHYD44HjuGX0PtyTcgpfNy+QKzedwOCgoKODEiRPcfPPNAHh5eXHHHXcwZMgQvTEmIt9KgYkMWvn5+Xh6evLmm28SFxcHwL/9278xfvx4jh8/TkxMDE1NTezevZuNGzeaW6yIiIjIeQpOFrC2cC1bj2zFwAAga0gWazLWMD1mOlaLenCc09TUxFtvvYVhGGRnZxMVFQVATEyMyZWJSF+mwESuiK6urgtes1qteHh4XNR9LRZLrxn3F7qvl9elv3OSl5fH4sWL3WEJ8I1RccHBwdTW1l7yY4uIiIhcCYZh8Nnxz1h3YB1f1XzlXp8+Yjr3ZNzD2KFjTayu7+ju7qampoYRI0YAEBYWxqRJkwgICCAiIsLk6kSkv1BgIlfEo48+esFrycnJLF++3H37j3/8I3a7/VvvO3LkSFavXu2+/ec//5m2trZv3O93v/vdJdeYl5fHqlWreq3t2rWLiIgIoqOjL/nxRERERK4Uu9PO+1Xvs65wHQdPHwTAw+LBLQm3sHr0apJCk0yusO9oamri6aefpqOjg1/84hf4+fkBMGfOHJMrE5H+RoGJDErt7e2UlZXhcDjca06nk8cee4xVq1ZpjJyIiIj0CW32NjaVbeL5ouc50XoCAD8PP5amLGVl+kqG+Q8zucK+JygoiIAAV4PbhoYGd2AiInKpLIZhGGYXIX1bc3MzwcHBNDU19Tqy0tHRQWVlJfHx8d9olNXXj+Ts3r2bqVOnkpSUxNq1awkJCeGRRx5h79697Nu3j5CQkEt6vL7su/6eREREpG9qaG9gfcl6Xi55meauZgDCfMJYMWoFt6feTrB3sMkV9g12u52vvvqK0tLSXm96nT59msDAwF6/c4qY5UKvp6Tv008QuSIuJcC4Uvf9Lnl5eaSlpfHrX/+aJUuW0NTUxJw5c9i+ffuACktERESkfznSfITnip7jjUNv0OnoBCA2MJbVGauZnzAfHw+9+fF1TqeTzz77jPb2doqLixk9ejQAoaGhJlcmIgOBAhMZlPLz88nMzGTlypWsXLnS7HJERERkkCusL2Rd4To+OvIRTsMJQEZ4Bmsy1zAjZgY2q83kCvuGjo4ODh06REZGBgDe3t7MmjULi8VCWlqaydWJyECjwEQGpby8PObPn292GSIiIjKIGYbBzhM7WVe4jt01u93r10Vfxz0Z9zB+6HgsFouJFfYtnZ2d/OUvf6G9vZ3w8HCGDx8OwNixmgwkIleGAhMZdAzDoKCggN/+9rdmlyIiIiKDkN1pZ0vlFtYdWEfZ6TLANfHm5oSbWTV6FSmhKSZX2Hc4HA5sNtfuGm9vbxITE6mtrf3OHngiIpeLAhMZdCwWC83NzWaXISIiIoNMm72NjWUbea7oOWpaawDw9fBlacpS7k6/WxNvvqa7u5tPPvmE/Px8/u7v/g5fX18AbrnlFry9vbXzRkSuCgUmIiIiIiJXUEN7Ay8Wv8iG0g2aeHORbDYbhw4doqWlhf379zNp0iQATfwTkatKgYmIiIiIyBVwuPkwzx54ljcPvUmX03WEZGTQSFaNXsWtibfibfM2ucK+48yZM+zbt4/rrrsOq9WKxWJhzpw52O12kpOTzS5PRAYpBSYiIiIiIpdR/sl8nil8hq1HtmJgAJAZkcmajDXcEHODJt6cx+Fw8N///d+0tLQQERHhHg0cHx9vcmUiMtgpMBERERER+ZGchpMdx3awrnAd++r2udevH3E9q0ev1sSb87S2tuLv7w+4jt+MHz+eiooKgoKCTK5MRKSHAhMRERERkR+oy9HF5orNPHPgGSqaKgDwsHpwS/wtrB69mqTQJJMr7FsMw+Cdd94hLy+Pn/zkJwwdOhSA6667juuvv16hkvww3V1w6EM48DrM/wt4+ZldkQwQCkxERERERC5Rc1czr5a+yovFL3Ky/SQAAZ4B3JZ6G3el3cVQ/6EmV9g3WSwWOjs7cTqdlJaWugMTq9VqcmXS7xgGHPsK8l+GA5ug/bRrPeUmyFxqbm0yYCgwERERERG5SDWtNTxf9DyvHXyNtu42ACL9Ilk5aiVLUpYQ6BVocoV9y8mTJ9m1axezZ892T7i54YYbmDRpEjExMSZXJ/1SQznsfwX2b4DTlT3rAUMh8zYYnmVebTLgKDAREREREfkeB08f5JnCZ3iv8j26jW4AkkKSWD16NTfH34ynzdPkCvsewzDYuHEjtbW1BAcHM23aNADCw8MJDw83uTrpV1obXLtI9m9w7So5x9MfRs2HMbdDwnRQQ2W5zBSYiIiIiIh8C8Mw+KrmK9YeWMvO4zvd6xOGTWD16NVcF32dem6cp66ujiFDhmCxWLBYLFx33XUUFhaSkpJidmnS39jbofQ9126SQx+C0xVUYrFCwg2QdQek3QJe/ubWKQOaAhMRERERka/pdnbz0eGPWHdgHUUNRQBYLVZmxc7inox7yIjIMLnCvumNN94gPz+f2267jfT0dABGjx7tHhMs8r2cTji8E/a/DEVvQWdzz7Xh2TBmGWQsgUD1CJKrQ4GJiIiIiAjQZm/jjUNv8FzRcxxvOQ6Aj82HhUkLuTv9bmKC1HPjuwQHBwNQW1vrDkxELkptkeu4TcFr0HysZz04xnXcJvN2iEwzrz4ZtBSYiIiIiMigVt9ez0slL7GhdANNnU0AhHqHcmfandyRdgehPqEmV9j3HD16lB07dnDjjTcSGRkJwOTJk8nMzCQiIsLk6qRfaD7hCkj2vwK1BT3r3sEwegGMuQNip4AmKImJFJiIfIc//vGPrFu3DovFwm9+8xtWrFhhdkkiIiJymVQ2VfLsgWd5u/xtupxdAMQExnB3+t0sSFqAr4evyRX2Xbt27eLQoUP4+vqyePFiAHx9ffH11Z+ZfIeOZih5x7WbpGI7YLjWrZ6QMsd15CZ5Nnj6mFqmyDkKTEQuoKCggPXr17N3714Mw+CGG25g3rx5hISEmF2aiIiI/ECGYZBbl8u6A+v45Ogn7vUxEWNYnbGaGTEzsGnSRi+GYVBVVUVUVBTe3t4AXH/99fj4+HDdddeZXJ30eQ47lH/sCklK3oXu9p5rsVNcR27SF4JfmGklilyIAhORCyguLmbKlCn4+LgS7qysLLZs2cIdd9xhcmUiIiJyqRxOBx8f/ZhnDjzD/pP73evTY6Zzz+h7yInM0cSbC3jrrbfIy8tjxowZ7oBk2LBh3HrrrSZXJn2WYcDxva6QpHAjtDX0XAtPPtuX5DYIizevRpGLoMBE5AIyMjL4/e9/T2NjI4Zh8Mknn2gknoiISD/T3t3OW4fe4rmi5zhy5ggAXlYv5ifOZ9XoVcQH6wXb+QzDdUziXIAUHx9PQUEB3d3dZpYl/UFDORS86gpKTlX0rPsPgYylrqAkKgcUTko/ocBE5ALS09P5+c9/zowZMwgODmby5MnYbNqiKyIi0h+c6jjFyyUv83LJy5zuPA1AsHcwy1KXcWfanUT4qjHptykrK2Pbtm1cf/31pKW5ppJkZGQQHx9PYGCgydVJn9RaD4WbXCHJ8T09655+kDbP1ZckYTrY9NJT+h+1HB5gFi1aRGhoKEuXLr2o9cGspqYGi8XCn//8Z3JycvDx8WH06NF89tln7vv8zd/8Dfv27WPbtm14enqSnJxsYsUiIiLyfY40H+Ffd/0rs1+bzf/L/3+c7jxNdEA0v5n4Gz5Y8gE/y/mZwpLvcOTIEaqrq9m1a5d7zWq1KiyR3rraXBNuXrwN/pgC7/2DKyyxWCFxJiz6L/hVGSx5EpJnKSyRfktfuQPMgw8+yJo1a3j22Wcvan0wy8vLA2Dt2rX85S9/YejQofzyl7/krrvuorKyEqvVSl1dHZGRkZSWlrJ7926eeOIJc4sWERGRb5V/Mp9nCp9h65GtGGcnb4wOH83qjNXMip2Fh1W/9p7P6XRSVFTE8OHDCQ8PB2DKlCm9/l/EzdENldtdY4BL3oGulp5rUTmunSSjF0PgUPNqFLnM9C/HADN9+nQ++eSTi16/Urq6XKP5PD093edfHQ4HDocDq9WKh4fHZb3vDzkqk5+fj6enJ2+++SZxcXEA/Nu//Rvjx4/n+PHjxMTEsGDBApqamvD392fdunW9ahERERFzOQ0nnxz9hGcOPENuXa57/foR17N69GrGDx2vRq7f4b333mPPnj2MGTOGRYsWAeDn58fMmTNNrkz6DMOA6jxXSFK4EVpqe66FxLpCkszbYYj6/MnApFd/fciOHTv4wx/+wN69e6murub1119n4cKFve7z17/+lT/84Q/U1NSQlZXF448/zsSJE80p+Ds8+uijAPzqV7/C398fgJ07d7Jt2zZycnJ6dVX/4x//iN1u58EHH3SP7P3qq694//33yczMZPHixe77/vnPf6atrY2//du/JTIyEnDtFBk3btwl15iXl8fixYvdYQlAUFBQr/t8fTuqiIiI9A0d3R28Vf4Wzxc9T1VzFQCeVk/mJcxj1ehVJIYkmltgH+V0OnE6ne43gHJycigsLHTvLhFxO10F+1+Fgleg/mDPum+oaxfJmNshZpKat8qAp8CkD2ltbSUrK4s1a9b0CgnO2bBhAw899BBPPPEEkyZN4rHHHmPOnDmUlpa6wwO5eHl5eaxatarX2q5du4iIiCA6OtqkqkRERORCvq2Ra6BXIMtSl7E8bTlD/IaYXGHfVVxczIcffsjYsWO59tprAYiKiuKhhx7C09PT5OqkT2htgKLXXbtJjn7Zs+7hA6k3u0KSxJng4WVejRdw5swZCgsLmThxooY0yGWlwKQPmTt3LnPnzr3g9T/96U/cf//93HPPPQA88cQTbN68mbVr1/Kb3/zmstXR2dlJZ2en+3Zzc/MlP8bDDz8M0Osf4KlTpzJ58mSs1t69hn/1q199474TJkxg7Nix37jvgw8++I37ZmdnX3J97e3tlJWV4XA43GtOp5PHHnuMVatWfeN5RURExDyVTZU8X/Q8b5W/RafD9TtKdEA0K9NXsihpEX6efiZX2Pd1dXVx+vRp9u/fz9SpU91HlRSWDHJdbVD6rmsU8KGPwHl2dLTFCvHXu47cpM0Dn6DvfhyTffnll+zcuZOwsDBSU1PNLkcGEAUm/URXVxd79+51BxHg6lg+a9asy35s5NFHH+X3v//9j3oML69vJs82m+1bE9/Lcd9LVVBQgMVi4YUXXmDGjBmEhITwyCOP0NjYyD/90z9d8uOJiIjI5WUYBvvq9vHMgWfYfnS7u5FrRngGqzJWqZHrd+ju7mbfvn1ERESQkJAAQGZmJna7nTFjxqivy2DndPQ0by1+u3fz1uFZrp4kGUsgaLh5NX6Huro6cnNzSUlJIT4+HnAdLzty5IgCQLns9K9MP1FfX4/D4WDo0N5dp4cOHUpJSYn79qxZs8jPz6e1tZURI0bw6quvMmXKlAuuf5uHH36Yhx56yH27ubmZmJiYK/OJmSQvL4+0tDR+/etfs2TJEpqampgzZw7bt29391ERERGRq6/b2c1HRz7i2cJnKWwoBMCChekx01k9ejVjI8fqBf/3+Oyzz9i+fTvR0dHEx8djsViwWq2MHz/e7NLELIYBJ3JdO0m+rXlr5u2uIzdD+ubujI6ODgoLC8nLy+P48eMANDU1uQOT8PBw1qxZY2aJMkApMBlgPvroo0ta/zbe3t54e3tfrpL6pPz8fDIzM1m5ciUrV640uxwREZFBr83exqayTbxQ/ALHW1wviLxt3tyaeCsr01cSHxxvcoV9V1dXF3a73d1of8KECRQWFpKVlYVhGAqYBrNTFWebt74KDWU9675hMHqR68hNzMQ+2bzVMAyqqqrIy8ujqKiI7m7XcSGr1UpKSgo5OTkmVyiDgQKTfiIiIgKbzUZtbW2v9draWoYNG2ZSVf1XXl4e8+fPN7sMERGRQa+urY71xet55eArnOk6A0Codyh3pt3JsrRlhPmEmVxh31ZcXMw777xDSkoKCxYsAMDf35+///u/V1AyWLWchAObXEduju/pWffwhdS5fbp56/m2bNlCXV0dAEOGDCE7O5usrCx3OChypSkw6Se8vLwYN24cW7dudY8adjqdbN26lQceeMDc4voZwzAoKCjgt7/9rdmliIiIDFoHTx/k2QPP8m7lu3SfbTQ5Mmgkd6ffza2Jt+Lj4WNyhf1DYGAgbW1tHDt2jO7ubvfIYIUlg0xnC5Rsdo0BLt8GxtnBBhYrJEx3HbkZNQ+8A00t80K6u7spKSmhoKCAJUuW4OXlhcViYdKkSRw/fpyxY8cSFRWlr2u56hSY9CEtLS0cOnTIfbuyspK8vDzCwsKIjY3loYceYtWqVYwfP56JEyfy2GOP0dra6p6aIxfHYrH8oMk/IiIi8uMYhsGu6l08d+A5dp7Y6V4fGzmW1aNXMy1mGlaLJtVdSHt7O19++SUBAQHufiQjRozgrrvuIiEhQVP+BhuHHco/du0kKX0X7G0916JyXMdtRi+GwKEXfgyTVVdXk5ubS0FBAR0dHQAcOHDAfdxm7NixjB071swSZZBTYNKH7NmzhxtuuMF9+1zj1VWrVvHMM8+wbNkyTp48ySOPPEJNTQ3Z2dls2bLlG41gRURERPoSu8POe1Xv8eyBZzl4+iAAVouVG0feyKr0VWQOyTS5wv6hpKSE7du34+/vT1ZWlnsiSFJSksmVyVVjGHB0t2snyYHXoa2h51povOu4TebtENF3vyY6OjrIz88nLy+Pmpoa93pQUBBZWVnuRq4ifYECkz5k+vTpGIbxnfd54IEHdARHRERE+oXmrmZeO/gaLxa9SF27qw+Br4cvi5MXs2LUCkYEjjC5wr6ttbWVtrY2hgwZAsCYMWMoLi4mKyvLffRGBom6EldIUvAqNB7pWfcf4hoBnHk7RI/tk81bz9fR0cGWLVsAsNlspKWlkZ2drV1S0ifpJ62IiIiIXFbHzhzjheIX2FS2ifbudgCG+A5h+ajl3JZyG8HewSZX2PeVlpayceNGhg4dypo1a7BYLNhsNpYvX252aXK1NB13jQAueAVqCnrWvQJg1HzIvA3ip4Gt776kO3XqFHl5ebS2troHLoSEhDBx4kTCw8PJyMjAz8/P5CpFLqzvfneJiIiISL+SV5fHc0XPsfXIVpyGE4Dk0GTuTr+bm+NvxsvW96dy9BVRUVEYhoHT6aSjowNfX1+zS5Kroe0UFL8FBa9B1WfA2d3nVg9IuhHG3AYpc8Gr74YMdrudoqIi8vLyqKqqAlw9BKdPn05goKvp7Ny5c02sUOTiKTARERERkR/M4XSw9chWni16lv0n97vXp0ZN5e7RdzNl+BRNtvgeZ86c4dNPP8VisbhfSAYGBvKTn/yEiIgI/fkNdPZ2KH3PFZKUfQBOe8+1kVMhcymkLwS/vj1iu7a2lt27d1NYWEhXV5d7PTExkezsbIV+0i8pMBERERGRS9Zqb+X1std5ofgFjrccB8DT6sm8hHmsTF9JcmiyyRX2H42NjXz11VdYrVauvfZa97vw53qXyADk6IbK7a6eJMVvQ1dLz7WhGa7jNhlLICTGvBov0dGjR9m3bx8AoaGhZGdnk5WVRXCwjuBJ/6XARH6072tUK+bS34+IiFxONa01rC9ez2sHX+OM/QwAId4hLEtdxh1pdxDhG2FyhX3f6dOnOX36NAkJCQDExMRwzTXXkJSUREBAgMnVyRVjGHBsjyskObAJWk/2XAuOde0kybwNhqabV+NFcDqdlJWVkZeXR1JSEuPGjQMgIyOD48ePk5WVxciRI7UzSgYEBSbyg50bZdfW1qYtdn3YuS2RNpvN5EpERKQ/K2oo4tkDz/JB1Qd0G90AxAXFsTJ9JfMT5+Prod8FLkZVVRXPPfcc/v7+PPjgg+5pNzfeeKPJlckVc7LUFZIUvAqnq3rW/cJdR23G3A4xk/r8hJuTJ0+Sl5fH/v37aWlx7YhpampyByY+Pj4sWLDAzBJFLjsFJvKD2Ww2QkJCqKtzjQn08/NTktzHOJ1OTp48iZ+fn8YPiojIJXMaTnYc28FzRc/xVc1X7vUJwyawKn0V1424DqtFY0C/j8PhcL9xERMTQ2BgIJGRkbS1tREUFGRydXJFuCfcvAo1Pb198PSHtFtcO0kSbwCbp3k1XqS8vDz27t3LsWPH3Gt+fn5kZWWRnZ1tXmEiV4FeQcmPMmzYMAB3aCJ9j9VqJTY2VmGWiIhctPbudt4uf5vni56nqrkKAA+LB3Pi53B3+t2kh/ftIwN9RWNjIx999BGtra2sWrUKcL3h9NOf/lS7cweitlNQ9KYrKPnGhJtZrpAkdS54+Zta5vcxDKPX740lJSUcO3YMi8VCcnIyOTk5JCcna/eyDAoKTORHsVgsDB8+nMjISOx2+/d/gFx1Xl5eWK16909ERL5ffXs9L5W8xCulr9DY2QhAoGcgS1OXsjxtOcP8h5lbYD9jtVopKSnB4XBQW1vL0KFDARSWDCRdrT0Tbg591HvCTew1rjHA/WDCDUBzczP5+fnk5eWxYsUKQkNDAZg0aRIxMTFkZWWpx44MOgpM5LKw2WxKmUVERPqpstNlPF/0PO9UvIP97Au+6IBoVqavZGHSQvw9+/Y74n3FiRMnqK6udvd0CAoK4pZbbmH48OHusEQGAIcdyj92HbcpeRfsrT3Xhma6mrf2kwk33d3dHDx4kNzcXMrLy93DAvLz85k+fTqGYRAfH098fLzJlYqYQ4GJiIiIyCBkGAa7TuziuaLn2Hlip3s9a0gWq0avYkbMDGxWvRlysWpra3nyySex2WwkJye7e5Pk5OSYXJlcFk4nHP3i7ISbN6D9VM+10LizY4CXQmSaWRVekra2Nnbs2MH+/ftpb293r8fGxpKTk0N6uuvYnY50y2CnwERERERkEOl0dPJuxbs8X/w8ZafLALBarMyMncnd6XeTHZltboH9SFtbG35+fgAMHTqU+Ph4AgMD3e/SSz9nGK6GrQWvQeEmaO5peop/pGsXSeZSiB7X5yfcQO/eJB4eHuTm5tLV1UVgYKC7gWt4eLjJVYr0LQpMRERERAaBhvYGXil9hZdLX+ZUh+vdcT8PPxYnL2b5qOXEBPb94wN9RXNzM2+88QYNDQ387Gc/c0+iW7FihfqGDQQN5T0TbuoP9qx7B8GoW10hSdx1YOv7L6UMw6CyspLc3FwaGhq4//77sVgseHl5MXv2bIKCgkhMTNTXrcgF9P3vchERERH5wc71J9lcsZkuZxcAw/yHsTxtOUtSlhDkpbG2l8rPz4/6+npaW1s5duwYcXFxAHrR2Z81V8OBTa7dJCf29azbvCH1JteRm6QbwdPHvBovQWNjI3l5eeTl5dHU1ORer62tdU+5PNdrR0QuTIGJiIiIyADjNJzsPL6T54ueZ1f1Lvd6ZkQmd6ffzcyRM/G0eppYYf9hGAYVFRUcOnSIOXPmAK7jDIsWLSI0NJSQkBBzC5Qfrv00FL3l2kny9THAFhskTHeFJGm3gE//CRWPHDnCJ598QmVlpXvN29ubzMxMcnJy1HxY5BIpMBEREREZINq723m7/G1eKH6ByibXC6av9yfJGpKlJo6XqKWlhfXr1+N0OklLS2PkyJEAmhrSX33XGOCYya7jNukLIWCIaSVeCsMwcDgc7mNhXV1d7rAkISGB7Oxs0tLS8PRUQCryQygwEREREenn6trqeLnkZV49+CqNnY0ABHgGuPuTRAdEm1tgP2IYBidPniQyMhKAwMBAJkyYAEBYWJiZpckP1d0F5VtdIUnpu2Bv67kWORrG3HZ2DHCseTVeotbWVgoKCsjNzSUpKYkbb7wRcIUkM2fOJCMjQ7ufRC4DBSYiIiIi/VRRQxHPFz3PlqotdDu7AYgOiGbFqBUsTFpIgFeAyRX2L+3t7Tz33HOcPHmSBx98kMDAQABuuukmkyuTS+Z0uI7ZFL7mOnbT0dhzrR+OAQZwOp2Ul5eTm5tLaWkpTqcTgM7OTmbNmoXFYsFqtXLttdeaXKnIwKHARERERKQfcTgdbD+2neeLnmdP7R73+tjIsaxMX8kNMTdgs9pMrLD/8vHxwdPTE5vNRnV1tTswkX7CMOD4XtdOkgOvQ0tNz7WAYZCx2BWSRI/tF2OAv27nzp18+eWXnDlzxr0WFRVFdnY2GRkZOmoncoUoMBERERHpB9rsbbx+6HVeLH6Ro2eOAuBh8WB23GzuTr+b0RGjTa6wf3E6nRw4cID8/HzuvPNObDYbFouFW2+9FT8/P/z8/MwuUS5WbZFrJ0nhRjhd1bPuEwLpC1x9SUZOhX4UJHZ1deHp6ekOQpqbmzlz5gy+vr6MGTNGDVxFrhIFJiIiIiJ9WHVLNetL1rPx4EbO2F3vLgd5BbE0ZSl3pt3JMP9hJlfYPzkcDj744ANaWlrIz89n7NixAERERJhcmVyUUxWugKRgI5ws7ln39Ie0m107SRJngIeXeTVeIsMwOHbsGLm5uRw4cIA777zTPbJ64sSJjBw5kpSUFHeDVxG58vTdJiIiItIH7T+5n+eLnufDwx/iMBwAjAwayYpRK7g18Vb8PLUD4lI4HA7Ky8tJSUkBwNPTk+nTp9Pa2kp6errJ1clFaT4BhZtcQcmJfT3rNi9IuhEyl0DKTeDlb16NP8CZM2fYv38/ubm5NDQ0uNdLS0vdgUl4eDjh4eEmVSgyeCkwEREREekjup3dbD2yleeLnif/ZL57fdKwSaxMX8l1I67DarGaWGH/1N3dzf/7f/+PU6dOsWbNGmJiYgAYN26cyZXJ92ptgKI3XEHJ4Z2A4Vq32CBhmmu6Tdo88A0xscgfpr29nTfeeIOysjIMw/V5eXp6Mnr0aLKzs4mN7T9Te0QGKgUmIiIiIiY703WGTWWbWF+8nhOtJwDwtHoyN34ud6ffTWpYqskV9j+GYbj7P3h4eDBy5Eg6OztpaWkxuTL5Xh3NULLZ1ZekfBuc3WEFQOwUV0iSvhAChphW4g/V2tqKv79rB4yPjw/19fUYhkFMTAzZ2dmMHj0ab29vk6sUkXMsxrk4U+QCmpubCQ4OpqmpiaCgILPLERERGTCONh/lxZIXeb3sddq62wAI9Q7l9tTbuSPtDiJ81U/jUjmdTr766it2797NPffcQ0CAa7RyW1sbnp6eeHp6mlyhfKuuNih73zXhpuxDcHT2XBue5QpJRi+GkBjzavyBOjo6OHDgALm5uZw6dYqHHnrI3YeksrKSwMBA9c4Z4PR6qv/SDhMRERGRq8gwDHbX7OaF4hfYfnQ7xtkjBonBiaxMX8ktCbfg4+FjcpX9l8ViobCwkFOnTrFnzx6mT58OoKk3fVF3J5R/7OpJUvIu2Ft7rkWkuEKSjCUQkWxejT+QYRgcPnyY3NxcioqK6O7uBsBqtXL8+HFGjhwJQHx8vJllisj3UGAiIiIichV0dHfwbuW7vFD8AmWny9zrU6OnsnLUSq6JusZ9hEQuXldXF3l5eYwbN849GnjmzJk0NDSQlZVldnlyPkc3VH3qOm5T/DZ0NPVcC4ntCUmGZkA//X6oqKjgnXfe4fTp0+61IUOGkJ2dTVZWlvtIjoj0fQpMRERERK6g2tZaNpRu4NWDr9LY2QiAr4cvtybeyvJRy0kITjC3wH7MMAyeeuopTp48iZeXF9nZ2QDExcW5p4tIH+B0wtEvXTtJit6A1pM91wKGwehFkLkUosf1y5Cku7ubjo4O9/GvoKAgTp8+jZeXFxkZGeTk5BAdHa1AVKQfUmAiIiIicgXsP7mfF4pf4MOqD+k2XNvxh/sPZ3nachYlLyLYO9jkCvunrq4uvLy8ANfxm6ysLPbt24ePj44x9SmGASdyXSHJgTeg+VjPNd8wSF/g2kky8hqw2kwr88eoqakhNzeXgoICEhISWLp0KQARERHceeedxMfHq2eOSD+nwERERETkMrE77Xx0+CNeKH6B/Sf3u9fHRo5lRfoKboi5AQ+rfv36obZv386uXbtYuXIl0dHRAEyaNIkpU6ZgtWrcsukMA2oPwIFNrqDkdFXPNa9AGDXPFZIkTAdb/wwS2tvbKSgoIDc3l5qaGvf6iRMncDgc2Gyu8CclJcWsEkXkMtK/2CIiIiI/0umO07x28DVeLn2ZurY6oGcs8F2j7iI9PN3kCgeG06dP09nZSX5+vjswOTdtRExUXwaFZ0OS+tKedQ9fSL3JNd0meTZ49u9dQFu3bmXXrl04HK4xxzabjbS0NLKzs0lISFBoJzIA6V8YERERkR+o7HQZLxa/yDsV79B5dgxquE84y1KXcVvqbRoL/CO0tLTwxRdfMGXKFHeTzOuvv56UlBRGjRplcnXC6So48LorJKkp6Fm3eUHSjZCxGFJuAu8A00r8sU6fPk1AQID7WI2fnx8Oh4OhQ4eSk5NDZmampi+JDHAKTEREREQugdNwsuPYDl4ofoEvq790r48KG8WK9BXcFHcTXjYvEyscGF599VWOHDkCwKxZswAICwsjLCzMzLIGt+YTZ0OSTXB8T8+61QMSbnCFJGm3gE//7c9jt9spKioiLy+PqqoqFixY4G4mnJ2dTVxcHMOHDze3SBG5ahSYiIiIiFyElq4W3ix/kxeLX+TomaMAWC1WZsbOZMWoFeRE5mgKxo/Q3NxMQECA+1jDNddcg8PhID4+3uTKBrmWOih60xWSHNkFGK51ixXirnX1JBl1K/j13yDLMAyOHz9Obm4uBw4coLOz033t5MmeiT6+vr74+vqaUaKImESBiYiIiMh3ONp8lPUl63n90Ou02lsBCPQKZGnyUu5Iu4OogCiTK+z/zvWGuPXWWxkzZgzgapqZkpKiEMoMrQ1Q/JareWvVZ2A4e67FTHaFJOkLIHCoeTVeJna7naeeeoq6ujr3WkhICDk5OWRlZREc3H93y4jIj6fAREREROQ8hmGwu2Y3LxS/wPaj2zHOvqseHxzPXWl3MT9xPn6e6l1wuXh5eeFwOKisrHQHJgpKrrL2Rih5x7WTpOITMBw916LGuo7bjF4EwSPMqvCycDqdnDhxghEjXJ+Hp6cn/v7+eHh4kJ6eTk5ODiNHjtTXn4gACkxERERE3Dq6O3i38l1eKH6BstNl7vWp0VNZMWoF10Rdg9WiSRg/RkNDA5999hkTJ05094KYOHEiMTExxMXFmVvcYNPRDKXvuXaSHNoKTnvPtWFjXCFJ+kII6//Hourr68nNzWX//v20trbyy1/+ksDAQABuueUW/P398fHp31N8ROTyU2AiIiIig15tay0bSjfw6sFXaexsBMDXw5dbE29l+ajlJAQnmFvgALJjxw72799PR0cHy5YtA8Db21thydXS1QoHt7h2kpR9CI6efh1EprtGAI9eBBFJ5tV4mXR2dnLgwAHy8vI4evSoe93Pz4/6+np3YBIeHm5WiSLSxykwERERkUFr/8n9vFD8Ah9WfUi30Q1AlH8Ud6bdyaLkRQR7q3/Bj1VXV0dgYKC7Wea1115Le3s7U6dONbmyQcTe7gpHDmyCg++Dva3nWnhyz3GbyIEzrrmyspKXXnoJu921a8ZisZCcnEx2djYpKSnYbDaTKxSR/kCBiYiIiAwqdoedj458xAvFL7D/5H73+tjIsaxMX8n0mOl4WPUr0uXw8ccf8+mnn3LdddcxY8YMAIYMGcLy5ctNrmwQsHdA+VbXGODS96CrpedaaJxrJ0nGYhiaAQOgX0dzczOtra3uY17Dhw/HMAzCw8PJzs4mKyvLvaNERORi6bcBERERGRTq2+t5tfRVXj34KifbXaNCPa2ezI2fy4pRKxgVPnDeXe8rzr14PXPmjMmVDBLdnVC+zbWTpORd6Pran3twDIxe6ApKonIGREjicDgoLS0lLy+PQ4cOERUVxX333QeAj48PP/3pTwkLC1MDVxH5wRSYiIiIyIBlGAb76/ezvng9Hxz+gG6n69hNhG8Et6fczm2ptxHhG2FylQPDiRMn2L59O5mZmWRkZACQlpbG3/3d3zFkyBCTqxvAurtcU20OvA4lm6GzqedaULTrqM3oRRA9bkCEJAC1tbXk5uZSUFBAW1vP8SKbzUZXVxdeXl6AepOIyI+nwGQQ+OMf/8i6deuwWCz85je/YcWKFWaXJCIickV1OjrZUrmFl0pe4kDDAfd61pAslqct58aRN+Jp8zSxwoHn0KFDHDx4kMbGRndgYrFYFJZcCQ47VG53hSTF70BHY8+1wOGuyTajF8GICWAdWFOd3n//fb744gv37YCAALKyssjJyVFAIiKXnQKTAa6goID169ezd+9eDMPghhtuYN68eYSEhJhdmoiIyGVX01rDK6Wv8NrB1zjdeRoAL6sXc+PncueoOxkdPtrkCgeOw4cP4+/vT0SEa4fOxIkTaWpq4pprrjG5sgHK0Q1Vn54NSd6G9lM91wKGQvoCV0gSM3nAhCSGYVBZWUlERARBQUEAxMbGsnv3blJTU8nJySExMRHrAPl8RaTvUWAywBUXFzNlyhT3XPmsrCy2bNnCHXfcYXJlIiIil4dhGOyp3cNLJS/x8ZGPcRgOAIb6DeWOtDtYnLyYMJ8wk6scWLZv384nn3xCeno6t912G+DqGTF//nyTKxtgHN1w+DM48IYrJGmr77nmF9ETkoy8BqwDZ+pLY2MjeXl55OXl0dTUxLRp05g+fToAKSkpPPTQQ/j7+5tbpIgMCgpM+rgdO3bwhz/8gb1791JdXc3rr7/OwoULe93nr3/9K3/4wx+oqakhKyuLxx9/nIkTJwKQkZHB73//exobGzEMg08++YSUlBQTPhMREZHLq727nc0Vm3mp5CUOnj7oXp8wbAJ3pt3JDTE3aNrNZWIYBk6n0z2KddSoUXz66af4+flhGIaaal5O3xWS+IZB+q1nQ5JrwTZwvr7tdjslJSXk5eVRUVHhXvf29u719WWz2RSWiMhVM3B+yg5Qra2tZGVlsWbNGhYvXvyN6xs2bOChhx7iiSeeYNKkSTz22GPMmTOH0tJSIiMjSU9P5+c//zkzZswgODiYyZMna+68iIj0a8fOHOPlkpfZdGgTZ85OAfGx+TAvcR53pt1JSqjeGLicDh8+zEcffURiYqL7Xf7IyEj+x//4H/j6+ppb3EDh6IbDO3uO25wfkoya5wpJ4q6DAdh7x+l08n//7/+lubnZvRYfH09OTg5paWl4eg68z1lE+geLYRiG2UXIxbFYLN/YYTJp0iQmTJjA//2//xdw/YMTExPDz372M37zm9984zHuu+8+Fi1axC233HLB5+ns7KSzs9N9u7m5mZiYGJqamtznR0VERK4mwzDYVb2Ll4pfYvux7Ri4fn2JDojmzrQ7WZi0kGDvYJOrHJgOHDjAa6+9RkBAAL/4xS/0xsvl4nRA1WdQ9AYUvfXtIUn6Qoi/fsCFJG1tbRw8eJCsrCz37pE333yTyspKsrOzycrKIjQ01OQqRS6f5uZmgoOD9XqqH9IOk36sq6uLvXv38vDDD7vXrFYrs2bNYteuXe61uro6IiMjKS0tZffu3TzxxBPf+biPPvoov//9769Y3SIiIher1d7KW+Vv8VLJS1Q2VbrXr4m6huVpy7k2+lpsA6h3g9kMw6CkpARvb28SEhIASE9PZ8aMGeTk5Cgs+bGcjt47SVpP9lzzDYVR8wdsSOJ0OikvLycvL4+SkhKcTieRkZFERUUBMGfOnG8cvxERMZsCk36svr4eh8PB0KFDe60PHTqUkpIS9+0FCxbQ1NSEv78/69atw8Pju//aH374YR566CH37XM7TERERK6WqqYqXip5iTfL36TV3gqAn4cfC5IWcGfancQHx5tc4cC0e/dutmzZQmRkJD/96U+xWCxYLBauu+46s0vrv9whyRtQ/NY3Q5K0s8dtBmBIAnDq1Clyc3PJz8/nzJkz7vXhw4fT1dXlvn1uQIGISF+iwGQQ+Ppuk4vh7e2Nt7f3FapGRETk2zkNJ58d/4z1xevZeWKnez0uKI470+7k1sRbCfAKMLHCgcfpdNLZ2enuRTJmzBg+//xzUlNTcTgc3/smi1zAuZ4kRW98+06StHkweiHETxuQIck5R48eZe3ate7bvr6+jBkzhuzsbIYNG2ZiZTJQHW9sZ3iQD1ardirJ5aF/BfuxiIgIbDYbtbW1vdZra2v1j5CIiPQbzV3NvF72Oi+XvMyxlmMAWLBw/YjrWZ62nMlRk7FarCZXOfBUVVXxzjvvMGzYMJYuXQq4XtA++OCDWK36875kjm6o+vRsSPJO754kPiGu4zYDOCQxDINjx47R0tLCqFGjAIiOjiY4OJghQ4aQk5NDSkqKQji5rE63drGrooGdh+r5vLyByvpWNv/8WkZHqaeVXB76idWPeXl5MW7cOLZu3epuBOt0Otm6dSsPPPCAucWJiIh8j7LTZbxU8hLvVLxDe3c7AIFegSxOWsyytGXEBOo46JXk4+NDQ0MD7e3tdHR0uI9EKCy5BA47VO7oCUnaT/VcczduXTBgQxKAlpYW8vPzycvLo76+noCAAFJTU7FarVitVv7+7/9eU27ksmnvcvBV1Sl2HqpnZ3k9B0408/URJlYLlNacUWAil40Ckz6upaWFQ4cOuW9XVlaSl5dHWFgYsbGxPPTQQ6xatYrx48czceJEHnvsMVpbW7nnnntMrFpEROTbdTu7+eToJ6wvWc9XNV+515NCklg+ajm3xN+Cn6efeQUOUA6Hg7y8PAzDYPz48QAMGzaM2267jcTERB3FvRTdXVC53RWSlGyG9tM91/zCzzZuXTBgRwCD6+uprKyMvLw8Dh48yLmhm56eniQlJfU65qWwRH6MboeT/GNNroDkUD25Rxrpcjh73Sc5MoCpSRFMTYpgUkIYQT76mpPLR4FJH7dnzx5uuOEG9+1zzVhXrVrFM888w7Jlyzh58iSPPPIINTU1ZGdns2XLlm80ghURETHT6Y7TbCzbyCulr1DdWg2AzWJjRuwM7ky7k/FDx2s6xhVUWlrKO++8g4+PD5mZme6AJD093eTK+onuLqjYBkVvQsk70NHUc81/SE9IMvJasA38X6+3bt3aq0feiBEjyMnJYfTo0Qrf5EcxDIODtS3ugOTLylO0dHb3uk9UsA/XJEVwbVIE1ySGExmkhsFy5VgM4+ubmES+SXPDRUTkhypqKGJ98Xreq3yPLqdrIkaodyhLUpawLHUZw/zVc+tKsNvtnDlzhrCwMMB1ZPf5558nNTWV8ePHq4/ExejuhPKPXdNtSt+Dzq+HJJGQfuvZkGQqDODR1p2dnRQWFhIVFcXw4cMBqK6u5sUXXyQrK4ucnBwiIiJMrlL6s6On2vi8vJ6dhxr4vLyB+pbOXtdD/DyZkhDu3kUSF+7X7wJ2vZ7qvxSYyPfSN7iIiFwKu9POR4c/Yn3xevJO5rnX08PTWZ62nJvib8Lbpnehr5QjR47w6quvEhAQwE9+8pN+98LCVPZ2OLTVtZPk4BbobO65FjDsbEiyEGInD+iQxDAMDh8+TG5uLkVFRXR3d5Odnc2CBQvc1w3DUL8b+UEaWjr5vLzBHZIcOdXW67qPp5UJcWFcezYgSR8e1O+n3uj1VP+ltxdERETksqhpreHVg6+yqWwT9e2uCSEeFg9ujLuR5WnLyRqSpRfvV0FERASdnZ3YbDb3L+nyHTpb4NCHZ0OSD8De2nMtMKonJImZBAM8IGhqanI3cD19uqc3S0REhHt3CYDFYtH3sly0ls5udlc2sPOQa5pNSc2ZXtdtVgvZMSFMTQznmqQIcmJD8PYYuIGk9C8KTEREROQHcxpOdp3YxYbSDWw/th2n4WrGF+EbwW0pt3Fbym0M8RticpUDV2dnJ7t376alpYW5c+cC4Ofnx6pVqxg2bBg2m150fKuOZjj4vqtx66GPoLuj51rQiJ6QZMSEAR+SnGMYBs899xynTrkm/Xh5eTF69GjGjh1LdHS0AhK5aJ3dDnKPNPL5oXp2ljeQf7SRbmfvQw1pwwLPHrEJZ2J8OAHeelkqfZO+MkVEROSSNXY08sahN3jl4CscPXPUvT5h2ASWpS5jRuwMPK2aVHClNTQ08PHHH2OxWJg0aZK7Z0l0dLTJlfVBbadcvUiK33L1JnF09VwLjXP1Ixm1AKLHwiAIB2pqati/fz8zZszAw8MDi8VCVlYWFRUV5OTkMGrUKLy8vMwuU/oBh9Og6EQzO8tdjVq/qjpFh733JJvYMD+mJoVzTWIEUxLDiQjQsUzpHxSYiIiIyEUxDIP99fvZULKB96vedzdxDfQM5NakW7k95XYSQhJMrnJga29vp66ujpEjRwIQFRXFpEmTiIqKIiQkxNzi+qLWetdUm6I3oXIHOL82bSM82RWSpC+AYZmDIiRpb2+noKCA3NxcampqANeEm3PTkq677jquv/56M0uUfsAwDMpPtp7tQVLPFxWnaGq397pPRIAX1yRGuEOSmLArNy7e6XRSXV1NeXk5U6ZM0ShruawUmIiIiMh3arO3sblyM6+UvkLJqRL3+qiwUSxLXcbc+Ln4eV65X4bFpaamhnXr1uHh4cGDDz7ofvf/pptuMrmyPqa5uickObwTjK+90x05+mxIcisMSRsUIYnT6aSyspLc3FxKSkpwOBwA2Gw2UlNTe/W40bEbuZATje2uRq2H6tlZXk9tc+9JNoHeHkxKCDsbkkSQMjTgin49NTU1UV5eTkVFBRUVFbS3twOuEDkpKemKPa8MPgpMRERE5FuVN5azoXQDb5e/TYu9BQBvmzdz4uawLHUZmRGZeoF1hRmG4f4zjoyMJCAgAE9PT5qbmzXK9esaj0Lx266Q5OiXwNf6JQzP6jluEzH4Xkg1NDTwwgsvuG8PHTqU7OxsxowZg5+fgk75dqdau9h1dpLN5+UNVNa39rru5WFl/MhQpiZFcE1iOJnRwXjYrmy/n87OTj7++GMqKiqor6/vdc3b25v4+Hi8vXXURy4vBSYiIiLiZnfY2XpkKy+Xvsze2r3u9djAWG5PvZ2FSQsJ9tbUlSutra2NTz/9lOrqalatWoXFYsFqtbJq1SoCAwMVVAE0lLtCkuK34Pje3tdGTIBRt7p2koTGmVKeGex2O8XFxTQ1NXHdddcBMGTIEJKSkggNDSUnJ4dhw4bp60e+oaWzm68qT7HzkCsgKapu7nXdaoExI0LcR2zGjQzFx/PKNZU2DIPq6mpaWlpISUkBwNPTk4KCAtrb27FYLERHR5OQkEBSUhLR0dEacy1XhAITERERobql2j0SuKGjAQCrxcoNMTdwe+rtTB4+GatFv4xeLYZhsHfvXux2O4cPHyYuLg6AoKAgcwszk2FAXbErICl+G2oLv3bRArFTzu4kmQfBI0wr82ozDIMTJ06Qm5tLYWGhe6T0+PHj8fX1BeCuu+4yuUrpazq7Hew73Miu8gtPskkdGsg1ZwOSSQlhBPlc2d4gTqfTHXpUVlby/PPPExgYyC9/+Ut3aDxr1ix8fX2Jj4/Hx8fnitYjAgpMREREBi2n4WTn8Z28UvoKO47vcI8EHuI7hCUpS1iSvIRh/sNMrnJwaGpqoqqqiqysLAD8/f2ZPXs2ISEh7gavg5JhwIl9UHQ2JDlV3nPNYoP462DUfEibD4FDzavTBK2trezfv5/c3FxOnjzpXg8JCSE7O9u8wqRPcjgNCo83sbO8ns8PNfBV1Sk6u785yeaaxHCuSYpgSkI4QwKv7PGWrq4uDh8+7O5FkpSUxOzZswGIiYnB39+fqKgourq63Edtxo4de0VrEjmfAhMREZFB5nTHaV4/9Dqvlr7KsZZj7vVJwyaxLG0Z02OmayTwVdTU1MRf/vIXDMMgJibGPRp4/PjxJldmEqcDjnxxdifJO9Dc8zWKzRsSZ7hCktS54BdmXp0my8/P58MPPwTAw8OD9PR0srOziYuL05EbwTAMDta2nJ1k08CXlQ2c6ejudZ+IAO+zR2yu/CSbczXV1NS4A5IjR464mxADvY7UeHp68j/+x//Q17KYToGJiIjIIGAYBvkn89lQ6hoJbHe6RkAGegWyIHEBt6feTnxwvMlVDh5dXV3uKTfBwcEkJCTgcDjo7u7+no8coLq7oGqHaxdJyWZo7dkxgac/pMx2hSTJs8E70Lw6TVJfX09eXh4jRowgLS0NgDFjxlBcXExWVhYZGRk6njDIGYbB0VPtrh0k5Q3sKq+nvqWr132CfDyYnOAKSKYmRZAUeWUn2QCcOXPGHZCUl5fT1tbW63pwcDCJiYkkJCSQkNB7LL3CEukLLIZhGN9/NxnMmpubCQ4OpqmpaXCfnRYR6Yda7a1srtjMhtINHDx90L0+Onw0y1KXcVP8Tfh6+JpY4eDS3t7Oli1bqKys5Gc/+xmenq6dPHa73f3fg0ZXG5R/7ApJDr4HHU0913xCIPVmV0iSeAN4Dr6v0c7OToqKisjNzeXo0aMAxMXFsWrVKpMrk76itrmDXeUN7katxxvbe1338bQyIS7MPclmdFQwNuvVCSGqqqp47733qKur67Xu5eVFXFycOyQJDw8fFMGIXk/1X9phIiIiMgCVnS5jQ+kG3ql4h1a7axykt82bufFzWZa6jIyIDJMrHJy8vLw4cuQIZ86c4dChQ4waNQpg8IQlHc1Q9oHruE3Zh2D/2rvN/pGuhq2j5kPcdWAbJH8m5zly5Ai5ubkcOHAAu921E8xisZCcnKzeJINcY1sXX1Q0sPOQa9xv+cneo349bRayY0K4JtEVkGTHhuDtceUm2ZxTX19PaWkpw4cPd+8S8fX1dYclUVFR7oAkJiYGm+3K1yRyuSgwERERGSC6HF18dPgjNpRuYF/dPvd6XFAct6fezq2Jt2ok8FVWW1tLYWEhM2bMwGKxYLPZmDdvHr6+vkRFRZld3tXR2gCl77p2klRsA8fXjgkEx7oCklHzIWYiWPVCatu2bVRVVQEQFhZGTk4OWVlZBAYOvqNIg11LZzdfVZ1y7yIpqm7m62cDLBbIiAp2T7KZEBeKn9eVf3nX0tKCj48PHh6u58rPz+ezzz5jzJgx7sAkMjKS2267jbi4OPz8rmxvFJErSYGJiIhIP3e85TivHXyNTWWbONVxCgCbxcaM2Bncnno7k4ZNGhRbnvuazs5Onn76aex2u3sLOuD+/wGt8airF0nJO3D4czB6GjsSngzpt7pCkuHZrld9g5DD4aC0tJT8/Hzmz59PQEAA4Gr2GxISQk5ODjExMfreHUQ67A72HTnNrvIGPr/AqN/kyACmJkUwJTGcyfHhBPtd+Z1YdrudI0eOuHuR1NbWcuedd5KSkuKqKTmZ2tpa4uN7+mBZLBbS09OveG0iV5oCExERkX7I4XSw88RONpRu4NNjn2Lg+qU60jeSpSlLWZy8mKH+g2vMal/Q1NREcLBrF4+3tzfjxo3jzJkz7rUByzDgZCmUvO2abFOd1/v6sEwYtcAVkkSmmVJiX1FXV0dubi779+93N8Dcv38/11xzDQCjR49m9OjRZpYoV4nd4WT/sSZ2nW3UuufwabouMOp3ytn/RQZe+ea+hmFQV1fnDkgOHz78jYbUdXV17sAkNjaW5cuXX/G6RMygwERERKQfaWhv4PVDr/Pawdc43nLcvT55+GSWpS5jWsw0jQQ2gd1u55VXXqGiooKf/exnhISEADB79uyBu0PA6YTje127SEregYZDX7togdgpkHaL639hg3sCU1dXF/v37yc3N5cTJ0641wMCAsjKynJPvpGBzek0KKpuPruDpJ7dlado7XL0uk9koLd7zO+UxPArPur3nJaWFioqKtzTbFpaWnpdDwwMJDExkcTEROLj4/H3978qdYmYTYGJiIhIH2cYBrl1uWwo3cCHhz90jwQO8gpiYdJCbku5jbjgOHOLHOQ8PT1xOp0YhkFVVZW7OeeAC0scdqj61LWLpPRdOFPdc83mBQnTIW2ea8JNwBDTyuxrHA4HW7ZsweFwYLVaSU1NJTs7m6SkJKxWq9nlyRViGAaH6lr4/GxA8kXFKZra7b3uE+LnyZSzo36nJEaQOMT/qv/cePfdd/nqq696rXl6ehIXF0dCQgKJiYlEREQMvJ9nIhdBgYmIiEgf1Wpv5Z3yd3i59GUONfa8e58ZkcntqbdzU9xN+Hhc+e3Z0pthGBw+fJivvvqKhQsXuifc3HTTTdhsNsLCwkyu8DLraoVDW127SA5u6T3+1ysQkm90TbdJuhF8NC6zsbGR/Px8Tp48ydKlSwHXxJApU6bg5+fHmDFj9O78AGUYBkdOtbl7kHxe3kB9S2ev+wR4ezAxPsx9zGbUsCCsV2nUL8CXX35JWVkZ8+fPdx8VPPcz69yUm8TERGJiYtxNXUUGM30XiIiI9DGlp0p5pfQV3ql4h7ZuV48DH5sPNyfczO2ptzM6XP0NzOR0OnnjjTdoamoiNjaWSZMmATBkyADaUdF2CkrfczVuLd8K3R091/wiIO1mSJsPCdPAw9u8OvuI7u5uSkpKyM3NpaKiwr0+bdo099fFzJkzzSpPrqDqpnY+P9TArooGdpU3cLyxvdd1bw8rE+LCmJLo2kWSGR2Mh+3q7CpqbW2lurqapKQk91phYSHHjh2joqKCnJwcALKyssjMzFSQJ/ItFJiIiIj0AR3dHXx4+ENePfgquXW57vW4oDiWpS7j1qRbCfLSu/dmMAyDo0ePuieW2Gw2pk2bRnV19cDqPdF0zBWQFL/9zck2ISNdDVvT5mn879ecPHmS3bt3U1hYSEdHT6gUHx9Pdna2u5eNDBwnz3TyRYVr98gXFQ1U1rf2uu5ps5ATE8rkswFJTmwI3h5X5/ulu7ubo0ePUl5eTnl5OTU1NVgsFn7961/j4+PajThhwgTS09OJi4tzf5yvr+9VqU+kP1JgIiIiYqLihmI2lW1ic8VmztjPAOBh8WBG7AyWpS5jwrAJOjduIsMweOaZZzhy5Ah33323e2xmTk6O+93Zfu1kqSsgKXkHTuT2vjY0wxWQjJrn+m99HX7DyZMn2bNnDwBBQUFkZ2eTnZ1NaGioyZXJ5dLY1sUXFafOhiT1HKzt3QzVaoHMESFnG7WGM25kKH5eV+cllmEY1NfXuwOSw4cPY7f37pESGRlJc3OzOzAZM2bMValNZKBQYCIiInKVnek6w7sV77KxbCPFp4rd69EB0SxKWsTi5MUM8RtAxzv6MYvFwtChQzlx4gQNDQ3uwKTfcjrh+B7XTpKSzdBQ9rWLFoid7ApJNNmmF6fTSUVFBbm5uURFRTF16lQAUlJSyM7OJiMjg/j4eDVwHQDOdNj5quqU+5hNUXUzhtH7PunDg9xHbCbEhxHkc/Umk7W1tbkn2ZSXl3PmzJle1/39/d3TbBISEggICLhqtYkMRBbDOP9HgEhvzc3NBAcH09TURFCQtoOLiPwQhmGwr24fm8o28UHVB3Q4XNv3Pa2ezIydyeLkxUwaPgmrRS+4zGIYBkVFRezcuZNly5a5GyK2trq23Pfb8/32dqjYDqWboXQLtNb1XLN5Qfw01y6S1JshINK8OvugU6dOkZubS35+vvuFaUhICD//+c+182uAaOvqZk/VaXadPWZTeLwJh7P3y6OkyABXk9aEcCYlhBPm73XV6jMMw/215nQ6+T//5//Q2dnTSNbDw4ORI0e6m7VGRkbqa7MP0uup/ks7TERERK6g+vZ63i5/m01lm6hqrnKvJ4UksTh5MfMS5hHqo+37fYHFYmHPnj1UV1eza9cubrrpJqCfBiVtp+Dg+66Q5NBWsLf1XPMOck22Sb0Zkmdrss23KCwsZM+ePRw+fNi95uvrS2ZmJjk5OXpB2o912B3sO3KaL8pdO0jyjjZid/QOSOLC/ZiSGM7kBNckm8jAqz+NrLGxkXfffZczZ87wN3/zNwBYrVbi4uJobGwkISGBhIQERo4c6Z7UJSKXnwITERGRy8zhdPD5ic/ZVLaJT45+QrfRDYCvhy9z4+eyOHkxYyLG6EWXyZxOJwcOHGDUqFHu8ZnTp0+noqKCyZMnm1zdD3CqEkrfhZJ34ciu3k1bg6JdAUnazTDyWvC4eu+Q9wfnNlyf+5481w/CYrGQmJhITk4OKSkpGrPaD3V1O8k72siu8gZ2VdSz70gjXd3OXveJCvZhSmKEe9RvVMjVbYLa1tZGZWUlNpvN3Uja19eX8vJynE4np0+fdvfFue2227DZ1HRZ5GrRT30REZHL5HjLcd449Aavl71ObVute31MxBgWJy/mpvib8Pfsh7sVBqjnn3+eqqoqbr75ZiZMmADAyJEjGTlypMmVXSTDcDVqPReS1B3ofX1oRk9IMjxbTVu/RUtLC/v37yc3N5fFixczfPhwAMaPH09oaCjZ2dnaPt/PdDuc7D/exK6zU2y+qjpFh713QDIk0Nt9xGZKYjixYX5XNcB2OBwcO3bM3YfkxIkTAERHR7sDE29vbxYsWEBkZGSvaUsKS0SuLgUmIiIiP0KXo4ttR7exqWwTu07swsD1TnWwdzDzE+azKHkRKaEpJlcp4HqR8vUXG6NGjaK2trZ/Ners7oKqT10hSel70Hy855rFBiOv6QlJQuNMK7MvczgclJWVkZeXx8GDB927S/Ly8tyBSXR0NNHR0WaWKRfJ4TQ4cKLp7A6SBr6qPEVrl6PXfcL9vZicEM7ksyFJ4hD/qxqQGIbBqVOnKC8vp6KigsrKSrq6unrdJzIyktjY2F49SzTRRsR8CkxERER+gPLGcjaVbeLt8rc53XnavT55+GSWJC/hhtgb8LZ5m1ihfN2+ffvYsWMHCxcuJC4uDoCxY8eSnZ2Nl1cfP57S0QRlH7qm2hz6CDqbe655+kPSTNdUm+TZ4BdmXp19XGdnJ9u3b2f//v3uRr4AI0aMcE+6kb7P6TQoqm7mi4oGdpU3sLvyFGc6u3vdJ8TPk0nxYWd3kESQMjTgqh+B7OzsdO8gqaiooLGxsdd1Pz8/dx+SxMRE7WQS6aMUmIiIiFykNnsb71e9z8ayjeSfzHevR/pGsjB5IQuTFhITGGNihXIhJ06coKmpiT179rgDkz7dj6LpmGsHSclmqPoMnPaea/6RkDrXFZLETwPPq9+Qsr9wOp3uHUSenp4UFBTQ2tqKv78/Y8aMIScnhyFDNMK7L3M6DUprz7h3kOyuPEVTu73XfQJ9PJgUH+Zu0jpqWBBW69UNSBwOB11dXfj6uvqfnDx5kldffdV93WazERsb6w5Ihg0bpj5WIv1AH/5NQURExHyGYVBYX8jGso1sqdpCq931zrTNYmPaiGksSVnCNVHX4GHVP6l9hd1uZ8+ePYwePdr9ru21117LkCFDGDt2rMnVXYBhQO0BV0BSuhmq83tfj0h1HbNJvQWix0F/OkZ0lRmGweHDh8nLy+Po0aP8/d//PVarFavVyo033oi3tzdJSUnqBdFHGYZBWV2LKyApb+DLygZOt/UOSAK8PZgQF8qUxHCmJESQHhWE7SoHJF+3b98+3n//fTIyMpg/fz4AUVFRjBgxgujoaBITExk5cmTf380mIt+g3+5ERES+RVNnE+9UvMPGso2UnS5zr8cGxrI4eTELkhYQ4RthYoVyIZs2baKkpITGxkbmzp0LQEhICJMmTTK5svM47HD4c9dOktLN0HjkaxctEDOpJySJSDKtzP6iubmZvLw88vLyOH2655hcVVUVCQkJgHpC9EWGYVB+suVsk9ZTfFHRQENr7/4efl42xse5jthMTggjMzoYD9vVDw07OjqorKykvLycrKwsYmJcOwoDAwPp6uqiurrafV+r1cq999571WsUkctLgYmIiMhZTsPJVzVfsbFsI1sPb6XL6fql3dvmzY0jb2Rx8mLGDx2vbdR9TGdnJx4eHu4dAxMmTKCmpoaoqCiTK/sWbadcfUhK34NDW6Gzqeeahw8k3OAKSVJugoBI8+rsR06cOMG2bdsoLy93N3D18vIiIyODnJwcNW/tY1wBSaurB0lFA19WNFDf0jsg8fG0Mn5kGJMTwpiSGM6YESF4mhCQOJ1Ojh8/7u5Fcvz4cffXmLe3tzswiYuL4/7773c3DRaRgUOBiYiIDHp1bXW8eehNNpVt4ljLMfd6amgqS1KWcHP8zQR7B5tYoVzI7t272bZtG7NmzWLcuHEAxMfH88ADD/SdIxf1Za6A5OAWOPIFGF+b4OEXASlzXJNtEm8AL42dvhjd3d29etAcOnQIcI2FzsnJYdSoUTr+0EcYhkFlfSu7Knp2kJw809nrPt4eVsaNDHXtIEkMJ2tECF4e5hw7O336tDsgqayspLOzd63h4eEkJiaSktIz/czT07NvBrQi8qMpMBERkUGp29nNp8c+ZVPZJnYc34HTcAIQ4BnAzfE3szhlMelh6dpN0sc5nU46OjooLi52ByYWi8XcsMTRDUd2uQKS0vfgVHnv65Hprh0kqXPP9iPpI8FOH9fe3k5BQQF5eXkMGzaMW2+9FYDhw4cze/ZsUlNTCQvTlCCznQtIzoUjX1Q0UHdeQOLlYWVsbAhTEiKYnBBGdmwI3h7mfR8cOXKEgoICysvLex3nAvD19SU+Pp7ExEQSExMJDlZ4LjKYKDAREZFB5UjzEV4/9DpvHnqTk+0n3etjI8eyOHkxN468ET9PPxMrlAtpa2tj165dpKSkuLfCjxs3joCAANLT080trv2064hN6Xtw6EPXKOBzrJ4Qd60rIEm5CUJHmldnP2MYBhUVFeTl5VFcXIzD4dqd09jYyC233ILNZsNisTBlyhSTKx28LiogsVnJiQ1xT7HJjgnBx9OcgMTpdHLixAkiIiLw8XFNmDpy5Ah79uwBXL1HRowY4Q5Ihg8f7p60JCKDjwITEREZ8DodnXx0+CM2lW1id81u93qYTxgLEhewMHkhCcEJJlYoF2Pbtm3s2bOH6upqVqxYAbi2wmdkZJhTUEN5z1Gbw5/3PmrjG+Y6apNyEyTOAJ8gc2rsx3bv3s3nn39OU1NP+DR06FCys7MZM2ZM3zlyNcgYhkFVQ5s7HPmiooHa5m8GJNlnA5LJCWGMjQ01LSA537PPPsuRI0dYvHgxmZmZAKSkpNDc3ExiYiJxcXF4e3ubXKWI9BUKTEREZMAqPVXKprJNvFPxDs1dzQBYsDA1eipLkpcwbcQ0PG2eJlcpF3LmzBlsNht+fq4dP9dccw3V1dWMHz/enIIc3XD0Szj4HpRugYay3teHpPUctRkxQUdtLpHdbsdqtbqDkLa2NpqamvDx8SEzM5OcnByGDRumY3JX2dd3kHxZ2T8Cks7OTqqqqigvL+fw4cPcd999eHq6ftaPGDGCuro62tvb3fePjIzk5ptvNqtcEenDLMa5Vs8iF9Dc3ExwcDBNTU0EBekdMhHp21q6Wniv6j02HdxEYUOhe324/3AWJS9iYeJChgdokkFft3v3bj788EPGjx/PnDlzzCuko+nsVJstrqM27V/rb2D1gJFTzx61mQNh2qV0qQzD4MSJE+Tm5lJYWMiCBQsYNWoUAE1NTRw9epS0tLReDV7lyjo3xcYVjpziywscselLAYnT6aS6utrdrPXYsWM4nU739bvuuoukJNdo7s7OTjw9PXXMRq4qvZ7qv/Svj4iI9HuGYZB3Mo+NBzfyweEPaO92vXPoYfVgRswMliQvYdLwSdj0jn+/ERYWRnd3N3V1dRiGcXV3FZyqcAUkB99zHbVxdvdc8wnpOWqTNBN81ADyh2htbWX//v3k5eVRV1fnXj948KA7MAkODlaDzavAFZC0sOtsOPJFxSnqWy4QkMSHMTkx3PSABFyB2rmApKKigo6Ojl7XQ0ND3X1IzvU8AnTcRkQuiQITERHpt051nOLt8rfZWLaRyqZK93pCcAKLkxczP3E+YT6amtHXNTY28umnnxIbG0tWVhYAiYmJrFmzhhEjRlz5sMTpgKO7e47a1Jf2vh6eDKk3QcpciJkENv369EN1d3ezadMmSktL3TsAPDw8GDVqFDk5OcTFxZlb4CBgGAZldS3ucOTLygbqW7p63efcFJtJ8eFMTggnJ9a8Jq3n+/DDDyktLaWhoaHXure3NwkJCSQkJJCYmEhoaKhJFYrIQKJ/8QeB0tJSli1b1uv2Sy+9xMKFC80rSkTkB3I4HXxR/QUbyzay7eg2us++++/r4cucuDksSV5C1pAs9TnoR4qKiti3bx+VlZVkZmZitVqxWCy93hW+7DqaofxjV8PWg+9D+6meaxYbjLympx9JeOKVq2MQaG1txd/fH3CFI83NzTidTqKiosjJySEjI8M9rUT+//b+NLrN87wT/7/YuQIkuBNcwU0iRREQJVK2JdmyZMuy4sR2k9pOplXsxlmdOlX/6cRv0pPfmXPywjOp2yQznraTrdNJnaV22sh2HMuWtVi7AIoStZHgvi/YCWJ9/i9A3iRIydpIgiC/n3N0JDzPQ/AGRVHAF9d9XYsvEpFwddiNU7ZxnOqcwOnOCYx7YwMSjVKOxtLM6YBEj4Y4TrGZMbPNZn7fouHhYYyPj0Mmk8VMsyksLOQ2GyJadAxM1oCamhpYrVYAgMfjQVlZGR555JH4LoqI6A4NegbxVvtbeLP9TQx6B8XxDVkb8HT109hbthdp6rQ4rpBu19jYGAAgOzsbALB582b09/ejubl56V7wSBIwdg24/l70V/cJIBKcPZ+kAyofiQYklbuAZL47fS8CgQAuXboEi8WCwcFBHDhwAMnJyQCAPXv2QK1WIy8vL86rXJ3CEQmXB104OR2QnOmagGMyGHNNkioakGwtz0KzMQsNxTpolPGvIAkGg6I569TUFP75n/8ZQPS5bHp6OoBo8+fGxkaUl5czaCOiJcfAZI35j//4D+zatUu800NEtJIFw0Ec7juM317/LT7u/xgSon3K09XpeML4BJ6ueho1+po4r5LuxLlz53Dw4EFUVlbi85//PABArVbjc5/73OJ/sqAP6Dw6G5I4umPP6yumG7Y+BpRsBTgx6Z5IkoTe3l5YLBZcunQJwWD0RbpMJkNPTw9qaqL/Vpe0cmgNCoUjuDjgEhUkZ7om4J4KxVyTolZMV5DosdWYhY1FGVAr41+NEQgExDQbm82G1NRUfPGLXwQApKSkoLy8HBqNBoHAbEWM0cjmykS0fBiYJIAjR47g1Vdfxblz5zA4OIg333xzwXaaH//4x3j11VcxNDSEhoYG/PCHP0RTU9OC+/rVr36FP//zP1+mlRMR3R2b04Y3r7+J/+j4D0xMzW6VaMpvwtNVT2NXyS4kKfnOYqKY27S1vLwcACCXyxEKhRZ/+om9ezYg6TwChOY0glSogbJtQNWj0V/carNo+vr68NZbb8X0ldDr9TCZTDCZTKI6gO5dIBRBa79juv/IBM51TcAbCMdck6ZRYnNZdItNs1GPeoMOKkX8AxJJksQ0G5vNhp6enphpNna7PabKhM9ZiSjeGJgkAK/Xi4aGBrzwwgt4+umnF5x/4403cODAAbz++utobm7Ga6+9hj179uDq1avIzc0V17lcLnz88cf4t3/7t+VcPhHRbfEEPPhj9x/xVvtbOD9yXhzPTs7Gk5VP4qnKp1CiLYnjCulOjYyM4PDhw9Dr9di9ezeA6Ivol19+efGmn4QCQO/JaB+S639c2LBVa5gNSMp3ABpu21oM4XAYHo9HjMfU6XSYmJiASqVCXV0dzGYziouL2UtoEUwFw2jpdeBUZ7RB6/luB3zB2IBEm6REU7leBCS1BVooV0BAAkSff84EJDabDZOTkzHndTqd6ENSXl4uwhIiopWAgUkC2Lt3L/bu3XvT8z/4wQ/w4osv4vnnnwcAvP766zh48CB+8pOf4Dvf+Y647ne/+x0effTRW+739Pv98Ptnx8m5XK57fARERDcWCAdwtP8o3ra9jY/6PoI/HP3Zo5ApsN2wHU9XPY3tRduhlPO/q0TkcDhw+fJlqNVq7NixA2q1GgDuPSxxD0XDket/ADoOAwH37DmZIjrJpno6JMmtBfiifdGMjIzAYrHgwoULyMvLExUA6enp+PznP4/i4mKObb1Hk4EQznc7cKozusXG2utAIBSJuSYzRRUTkKzL10IhX1nf53a7Hb/85S8xOjoac1ytVqO8vFxMs9Hr9QzWiGjF4jPQBBcIBHDu3Dm88sor4phcLsfu3btx4sSJmGt/9atf4ctf/vIt7/P73/8+vve97y36WomIACAiRXBu+BwO2g7ij91/hCswG8qW68rxhPEJfKbyM8hNyf2Ee6GVqK+vD4FAQPQYqKqqwrZt27Bx40YRltyVSBjoPzddRfIeMHQh9nxqTrRha9UjQMVONmxdZFNTU7h48SIsFgsGBgbE8bGxMfj9fhGQVFZWxmuJCc01FcTZrgkxwaa1z4lQRIq5JjtNg2ajHs3TIUlVbhrkKyggsdvtuHTpEjQaDbZs2QIgGqI5HA4AQGFhoagiKSoqgkIR/wazRES3g4FJghsbG0M4HF7QaT4vLw9XrlwRt51OJ06fPo3f/va3t7zPV155BQcOHBC3XS4XG7QR0T2RJAnX7Ndw0HYQb3e+jeHJYXEuNzkXe8v34nHj41ivX893GhNUa2sr/v3f/x16vR7f+MY3xGjgXbt23d0dTk4A7YeiVSTt7wM+e+z5wk3RCpLqR4ECM8Bxokvi6NGjOHLkCEKhaBNRuVyO6upqmM1mVFZWcozrXZjwBnB6Ohw51TmOy4MuzMtHUKhLQrMxC83lejSV61Genbqifja63W7IZDKkpUW3uA0NDeHQoUPIysoSgYlSqcQXvvAF5ObmiglJRESJhoHJGqHT6TA8PHzrCwFoNBqW0xLRouj39OOdzndw0HYQ7Y52cTxdlY7dpbuxz7gPm/M2QyHnu42JKBAIiMqR6upqpKamoqSkBIFA4M7HfUpStHLk+nvAtfeA/rOANGcbgkYHVD4cDUkqdwNprEBaCk6nExqNRvz9paenIxQKIScnB2azGRs3buSkvTs04poS/UdOd07g2rBnwTXl2aloKouGI81GPYoyU+Kw0psLBoPo7u4WvUhGRkbw4IMP4qGHHgIQbeZcXV0No9EY0+S5tLQ0jqsmIrp3DEwSXHZ2NhQKxYIwZHh4GPn5+XFaFRGtZfYpO97reg8HOw/CMmIRx1VyFR4sehD7jPuwvWg7NAoGs4lqaGgI77zzDpKTk/Hss88CiIbtf/mXf3lnW2+mXIDtcLSK5Pr7gGco9nxuXXSbTfUeoKgJUPBpy1IIhUK4cuUKrFYrOjo68Oijj+K+++4DANTW1iInJweFhYUrqsJhpZIkCb0TPhGOnOmaQNf45ILrqvPSRA+SpnI98rQra+qXJEkYGRlBR0cHOjo60N3djXA4ttGs0+kUf05KSsJzzz233MskIlpyfOaR4NRqNRobG3Ho0CExajgSieDQoUN46aWX4rs4IlozfCEfDvcexkHbQRzvP46QFC3fl0GGLflbsM+4D7tLd0Or1sZ3obQolEolenp6oFAo4Ha7xcjYW4YlkgSMXZuuIvkD0HMCiIRmz6tSAOND0ZCk6lFAV7R0D4IwODgIi8WC1tZWTE3Njl+eOxpYrVbDYDDEY3kJIRKRcH3Eg9Od4zjdZcfpznEMu/wx18hkQG2BVoQjTeV66FPvoafPEvF4PLDZbKKKxOOJrYTRarWiUavRaERKysqqgiEiWgoMTBKAx+NBe/tsKXtnZyesViv0ej1KSkpw4MAB7N+/H5s3b0ZTUxNee+01eL1eMTWHiGgphCIhnBw8iYO2gzjUcwi+kE+cW69fj33GfXis7DHkpeZ9wr3QSidJEq5fvw63243GxkYA0erGz3zmMzAajSIsuanAJNB1LBqSXP8D4OiJPa+vmB77+whQ+gCgWlnvtK9GkUgEP/nJT9Df3y+OabVamEwmmEwmZGayae7NhMIRXBpwTfcfmcDZ7gk4JoMx16gUMjQUZWDLdDjSWJoJbdLKHpV7+vRpvPPOOzHHVCoVysrKRLPWrKwsVhkR0ZrDwCQBnD17Fjt37hS3Zxqy7t+/Hz/72c/wzDPPYHR0FN/97ncxNDQEk8mEd999d0EjWCKieyVJEi6MXcBB20H8oesPmJiaEOcMaQbsM+7DvvJ9MGYY47hKWkw2mw2//OUvoVarUVtbK5o3mkymm3/QRGe0Uev194DOI0BotnoBCjVQtm06JHkUyKpY2gdAiEQi6O/vFw3c5XI5dDodhoaGsG7dOpjNZpSXl7OB6w1MBcOw9jrE9ppz3XZMBmK3piSrFGgszURTuR5byvQwl2QgSbVy+zK1tLSgtbUVTU1NqK6uBgCxjbugoCBmmo1SyZcKRLS2ySRJkm59Ga1lLpcLOp0OTqcTWi3L6YnWIpvThrdtb+PtzrfR6+4VxzM1mdhTtgf7jPvQkNPAdx9XAUmS4Ha7xc97SZLw05/+FMXFxdi2bduNp1343UDnUaDjUHSyjb0z9rzWMBuQlO8ANGnL8EhoYmICVqsVLS0tcLlc+MY3voHs7GwAgMPhgEaj4fSSeVxTQZzrtuPM9BSbC31OBMKRmGt0ySpsKcuc3l6ThbpCLVSKlRk2zWyzqaurE6N833nnHZw+fRqNjY341Kc+BSAaqvl8Pjb0JVoifD2VuBgbExHRDY1MjogJN5cnLovjycpkPFzyMPaV78PWwq1QyVd2qTndvpGREfzmN7+BJEn42te+JkYDP//887FhWCQCDLVEw5GOD4Hek7G9SOTKaJPW6umQJLc22siBllwgEMDly5dhsVjQ3d0tjiclJWFsbEwEJhkZGXFa4coy4prC6a6JaEDSZceVIRfmv5WYm64RvUeayvWozk2HXL4yv59DoRB6enpEH5KhoWgjZa1Wi7KyMgBAfX09MjIyUFVVJT5OLpczLCEiugEGJkREJLgDbrzf/T4Odh7E6cHTkBB95aCQKXB/4f3YZ9yHncU7kaJis7/VSKvVwu12Q5IkjI2NITc3OrpXJpMB7iGg44PpXx8Ck2OxH5xZBlTsAioejlaRJPEdtOU2MDCAn//85wgEAuJYRUUFzGYzampq1vz2CkmS0DnmxZmuCZzutONM1wR6JhZOsCnNSsGW6RG/TWV6lGalrNjqOUmSMDo6KgKSrq4uhEKhmGvy8/NjjhUVFaGoiA2ViYhux9r+n5OIiBAIB3C07ygOdh7ER70fIRCZfbFlyjFhn3EfHi17FPokfRxXSYstHA6jtbUVw8PD2LNnD4BoFcKzzz6LvLw8JCkQDUZmQpLhi7F3oE6LBiMVD0d/sRfJsvN4PHA4HOLFb25uLuRyOTIzM2EymdDQ0ACdThfnVcZPKBzB5UG3qCA52z2BMU8g5hqZDFifrxX9R7aUZSJ3hY34nc/r9cJms4mJNm63O+Z8Wlqa6ENiNBpZOUJEdA8YmBARrUERKYKzQ2fxdufbeK/7PbgDs0+4jToj9hn34fHyx1GUznchV6uJiQn87ne/AxBt4JqXmwuMXUfp4CHg6KHoZJs5k48AAAUmoHK6iqSoCVCuvNGoq104HEZ7ezssFguuXbuGjIwMfPOb34RMJoNSqcSLL76IzMzMFVsRsZSmgmFYehw40xVt0Hq+2w7vvAataqUcpqIMbCnPxJYyPTYlwASbSCQS05D3V7/6FXp6ZqdNKZVKlJaWioAkNzd3Tf79ExEtBQYmRERrhCRJuGq/ioO2g3i7822MTI6Ic7kpuXi8/HHsM+5DTWYNn2yvQqFQCCMjIygsLAQA5OTkYLO5HhmhMWR+/N+Arg8BZ2/sB6XlTVeQ7AIqdgKp2XFYOQHA6OgoLBYLLly4AK/XK46npqZicnJSVBHo9WunEszuDUQbtHZN4HTXBC72OxEMxzYgSU9SYnNpZnTEb5ke9UU6aJQrd4LNXOFwGG+88Qa6u7vx8ssvIyUluhWyoqICfr8fRqMRlZWVKCkpWfPbrYiIlgp/uhIRrXJ97j683fk2DtoOwua0iePpqnQ8UvYI9pXvQ2NeIxTyxHgRQXfObrfjpz/9KQKBAL712e1I6j0CdBzCvv5zgDRnAohCDZTePxuS5NWxWesKcPjwYXz00UfidmpqKjZu3Aiz2YycnJw4rmz5SJKEnolJnOmy41z3BM502dE+4llwXZ5WI/qPbCnTozovHYoV2qB1rsnJSdhsNrjdbtx3330AAIVCAafTiUAggK6uLtTW1gIAtm/fjh07dsRzuUREawYDEyKiVcg+Zccfuv6Ag7aDsI5axXG1XI0Hix/EvvJ92F60HWoFt1Sseo5eZHS8jyT/GBAIYfz/vgADhmbPZ9dEA5LKXUDpA4CaDX3jSZIkdHd3Q6vVimqRsrIyHDlyBNXV1TCZTKiqqhIjYlerYDiCy4MunOmy42zXBM522zHq9i+4riIndbr3SDQkKcpMTogKuXA4jN7eXtGsdWBgAEB0e82WLVtExchjjz2GlJQU0YAZQEI8PiKi1UImSfOHpxHF4txwosQwGZzEh70f4qDtIE4MnEBIik5FkEGGpoIm7Cvfh92lu5GuTo/zSmkpBb0OnHn/LbTbbPgz5TuQjV8DAEwgA1q4oUxKA4wPzU60ySiO74IJQPT/2paWFlgsFtjtdjQ1NWHv3r0AoiGK1+tFWlpanFe5dNxTQVh6HDjbHQ1ILD0O+IKx/UdUChk2FmVgc1kmNpfq0ViaCX1qYoS+kiRhfHxcBCSdnZ0IBoMx1+Tm5sJoNGLHjh1ITk6O00qJaCnw9VTiYoUJEVECC0aCODFwAm93vo0Pej6Ab06TzvX69dhn3Ie95XuRm5L7CfdCCU2SohNs2g8BHR8g3H0ORyL74ZdpcE0KoUYmBwyboa/cFQ1JDJsAbr9aEUKhEK5duwaLxYKOjg7MvIelVqtjKkhkMtmqC0sGnT6cna4eOdNlx5UhFyLz3sLTJimxuUwvApKNRTokqRLnezcUCuHq1asiJHE6nTHnU1NTYTQaRbPW9HSG2UREKw0DEyKiBCNJElpGW3DQdhDvdb+HiakJca4orSg64cb4OIw6YxxXSUvKMwrYDgMdhzDVfhQ2bzJqcR0AkARgV/IlqHKrUbnlb4GKh4DkjDgulm5EkiT80z/9E0ZGZpsvl5SUwGw2o7a2Fmp1YlRO3I5IRMK1EXe0/8h0QNLv8C24rlifjM2l0YBkS5kelTlpkCdA/5EZ4XAYbrcbGRkZAKJ/x2+++SbC4WiljEKhQElJiRj5m5eXx+01REQrHAMTIqIEYXPY8Hvb7/F259vo9/SL4/okPfaU7cE+4z5szN7IJ+CrUSgA9J2eriI5BAy2AAB8SMI/4AVMyTT4ekk7ctZvAyp3YUtWJZu1rjA+nw+XL1+GyWSCXC6HTCZDZWUlfD4fGhoaYDKZkJWVFe9lLgqvP4SWXgfOddtxttuO8z12uKdCMdfIZUBtoRabS6P9RzaXZSJPmxSnFd+7rq4u/PKXv4Rer8dXvvIVAIBKpUJDQwNUKhUqKytRWloKlWpljzAmIqJYDEyIiFawYe8w3u16FwdtB3F54rI4nqxMxq6SXdhn3IetBVuhlPPH+aoz3gF0fBANSbqOAoHoRJAw5FAAQF49kisfRnlfHsYmAd+uF4CSkrgumWJJkoTOzk5YLBZcvnwZ4XAYWq0WlZWVAIAdO3Zg165dkMvlcV7p3ZMkCQPOKZztmsD5bjvO9dhxedCN8Lz9NSlqBcwlGSIgMZVkIE2TeD+3fD4fOjs70dHRAYPBgE2bNgGIjukOBAJwu90IBAKiQuiJJ56I53KJiOgeJd7/VEREq5wr4ML73e/joO0gzgydgYToCw+lTIn7DfdjX/k+PFT8EFJUnGayqkxOAF3HANuH0aDE3hVzOpich4/SnkCrV4+vv/Dn0GRHm7U+4fMhKSmJlUUriMPhgNVqhdVqjelbkZubi7m99jUaTTyWd0+C4QjaBlw4120Xv4ZcUwuuM2QkY1NpJhpLMtBYqsf6gnQoFYkXDIXDYfT394s+JP39/eLv0G63i8AkNTUVX//615Gdnc1/i0REqwgDEyKiFcAf9uNo31EctB3Ekb4jCEQC4pw514x95fvwaNmjyEzKjOMqaVFNuYCeE0DnEaDzI2DoIoA578rLVUDJVjHyV5FTh6v/+3/D5RtDa9cwNk8HJpymsbKMjo7if/7P/yluJyUlYcOGDTCbzSgoKEi4F9OOyQDO99hxtisajrT0OTAVjMRco5DLUFeoRWNppvhVoEvM70tJkmC329HR0YGOjg50dnYiEAjEXJOdnY2KigpUVVXFHM/JyVnOpRIR0TJgYEJEFCfhSBhnh8/ioO0g3u9+H+6gW5yr0FWI5q2GNEMcV0mLJjAJ9J6aDkiOAAMWQIodm4qcdUD5DqBiF9xZJlgvX8e2bdsgk8kgB7Bnzx5EIpEFL9QoPiRJwsDAAMbHx7Fx40YA0RfTubm5SEtLg8lkwrp16xKmb4UkSbCNeXFuOhw52z2BjlHvgut0ySoRjGwqyURDsQ4p6sR+Sjk8PIwzZ86go6MDDocj5lxycrKYZlNRUcGRoEREa0hi/+9GRJRgJEnC5YnLeNv2Nt7pfAcjvtkJGXkpeXi8/HHsM+5DdWZ1wr0TTfOEAkD/2emA5Gi0aWs49p1qZJZHA5LyHUDZdiA9L/qhoRBe/7u/w+TkJHJycrBu3ToAEL0vKL68Xi9aW1thsVgwMjICtVqNdevWQa1WQyaT4Utf+lJChCS+QBgX+hw412PHua5oc1b7ZHDBdcacVGyeUz1izE6s6TXzRSIR9Pf3IyUlRTTa9Xq9OHfuHABALpejuLgYRqMRlZWVyM/PT+g+M0REdPcYmBARLYNedy/etr2Ng50H0ensFMfT1el4tPRR7DPuQ2NeI+QyPilPWOFQdHpN13QFSc9JIDgZe43WEBuQZBSLU5OTk5jpSqNUKrFp0yb09PQgNTV1+R4D3VQkEkFHRwcsFguuXr2KSCS6LUWpVKKmpgZ+v180+lyJYYkkSeiz+3C+xw5LjwOWHjsuDbgQmtecVaOUo6E4IxqOlGRiU2km9KmJP+JYkiQRQr/zzjs4e/Ystm7dij179gCIjnRuampCRUUFSktLE7K/DBERLT4GJkRES2RiagLvdr6LtzvfRstoiziulqvxYPGD2Gfch+2G7VArEv/FyJoUiQAjl6LVI51HgO7jgN8Ve01K9mxAUr4D0BsXjPuNRCL4/e9/jwsXLuCrX/0qsrOzAQAPPfSQGD9L8Xf8+HF88MEH4nZhYSHMZjM2bNiApKSVNw53pnrE0uvA+W47LL0OjLr9C67L02qwuVQfbdBamonaAi3UysQPbv1+v5hmY7PZ8NRTT6GoqAgAUFZWhosXL8ZUjSiVSuzduzdeyyUiohWKgQkR0SKaDE7ig94PcNB2ECcGTiA83aNCLpOjKb8J+4z7sKtkF9LV6XFeKd0xSQLG26MNWme22fgmYq9J0kUrR8q2RwOS3PULApL55HI5vF4vwuEwrl69KgIThUKxVI+EbiEQCKCtrQ2ZmZkoLS0FAGzYsAEnT55EfX09zGYz8vLy4rzKWZIkoXciWj0yU0FyeXBh9YhyujmrebpyxFycgaLM5FURykUiEQwMDIhmrX19fTETiTo6OkRgsm7dOqxfv57bbIiI6JZk0tz/TYhuwOVyQafTwel0stEZ0Q0EI0GcGDiB39t+j8O9h+EL+cS5uqw6PF7+OPaW70VOCicoJBx792yT1s4jgGco9rwqFSi9b7aCJH8jIP/koGN0dBQnTpzAnj17RNn/6OgopqamUFxc/IkfS0tHkiT09vbCarXi0qVLCAQCqKmpwbPPPiuuiUQiK+JF9mQghJZeJyy9dpzvdsDaa8eYJ7DgujytBptKMmEuycCmkkxsMOiQpFo9QZzD4RAVJDabDVNTseON9Xq9aNRaVlbGbTZEFDd8PZW4WGFCRHQXJElCy2gLfm/7Pd7reg92v12cK04vjk64KX8c5bryOK6S7phrEOg6Ol1FchRwdMeeV2iA4iag/MFoQGLYBChuv1+FJEn41a9+hbGxMWRlZeGBBx4AwHGk8eR2u9HS0gKr1Yrx8XFxXK/XLwiw4hGWSJKE7vHJmOqRK0NuhOdVj6gUMtQV6mYDktJMFOqSVkX1yHwnTpzAuXPnYv6+gOgIZ6PRKCbaZGRkxGeBRES0ajAwISK6Ax2ODhy0HcTbnW+j39MvjuuT9His7DHsM+5DfXb9qnyRsip5x6cDkiPR38euxZ6XKwFD42wFSVEToLqzfhWjo6PIzs6GTCaDTCbDtm3bcOXKFVRUVCziA6G79cYbb6C/P/pvWaVSoa6uDmazGcXFxXH5d+z1h9DSG9t7ZMK7sHokX5uETaUZ0wFJJuoKtauqegSYHdvc0dGB5uZmUSHi8/kwPj4OmUwmptlUVFSgsLBwRVQAERHR6sHAhIjoFvrcfXi/+30c7DyIKxNXxPEUZQp2lezCPuM+NBc0Qynnj9QVb8oJdH8826h1uHXeBTKgoGE2ICnZCmjuvt/Mv//7v6O1tRXPPfccqqurAQANDQ1oaGi4hwdBd2tkZARWqxU7duwQjVobGhogl8thNptRW1u7rNs2IhEJneNeMbXmfI8DV4dcmFc8ArVCjg2G6d4jJZnYVJqBAl3ysq1zOfl8PiQnRx+bTCbDb3/7W9jtduTl5aGmpgYAsHHjRhQWFqK8vJzbbIiIaEnx2T0R0Tz+sB9nh87iWP8xHOs/hi5XlzinlCmxzbAN+4z78GDxg0hWrs4XLatGYBLoPTnbg2TAAkiR2Gtya2fH/JY9ACRnLtqnT0+Phi2Dg4MiMKHlNTU1hYsXL8JqtYpKkqysLDQ2NgIANm/ejC1btizLWkbdfrT0OmDtdaClz4GWXgdcU6EF1xXqkmCebsq6qTRaPaJRrq7qkRmBQABdXV2iF4nL5cLf/M3fiKbHtbW1GB8fj5lElJ2dLZojExERLSUGJkREAHpcPSIgOTN0BlPh2eaBCpkC5lwz9pbvxaOljyIjKSN+C6VPFvIDfWdmK0j6zgCRYOw1+gqgfPtsSJKWuyifuqenB0ePHsXevXuh1+sBAPfffz/MZjNf3C0zSZLQ1dUFq9WKtrY2hELRUEIul6O6ujqmZ8xSbbvxBcK4OOCEtccBa58D1h4H+h2+BddplHJsMOiwqSRDVJDk61bemOLFIkkSBgcHRUDS09ODSGQ2xJTJZBgdHUV+fj4AYPfu3fFaKhEREQMTIlqbpkJTODN0RoQkPe6emPO5ybnYVrQN2wzbsLVgK8cAr1ThEDBonR3123MKCM17Uaotmt1iU74d0BUtyVKOHTuG9vZ2HD16FJ/5zGcAAKmpqUhNTV2Sz0c35/F48C//8i9irGxOTg5MJhMaGhqW5O8jHJHQMeqJCUeuDi9szCqTARU5aTAVZ4hfNfnpUClWd98Np9MJm80mQhKfL/bfaEZGhphmU15eHlNNQkREFE8MTIhoTZAkCd2ubhwfOI6j/Udxdugs/GG/OK+UKWHKNWGbIRqSVGdWs3HrShSJAMMXZ7fYdH8MBNyx16TmzAlIdgCZ5dFXqotopoLBYDBArVYDAHbs2IG0tDRs3759UT8XfbJQKIQrV65geHgYu3btAhDdClVXVwe1Wg2z2QyDwbCo/56HXVOw9ES31Vh7HGjtd8LjX7i1JiddExOO1BfpoE26/alKiS4cDuMf//EfMTIyEnNco9GgvLxcNGudqcgiIiJaaRiYENGq5Qv5cGboDI72HcWx/mPo8/TFnM9LycM2wzZsN2xHc0Ez0tRpcVop3ZQkRSfXdB6JVpF0HQN89thrkjKAsm3To363AznrFj0gme+tt97ChQsX8Oijj+K+++4DABQVFaGoaGmqV2ihwcFBWCwWtLa2YmoquoWusbFRjJL9kz/5k0X5PB5/CK19zmjfken+I0OuqQXXJasUqC/SwVycgYbpgKRglY71vRGv1wuLxQKXy4XHH38cAKBQKKDRaCCTyWAwGERAYjAYRI8SIiKilYyBCRGtGpIkodPViWN9x3B84DjODp1FIDI7jlMpV6IxtxEPGB7ANsM2VGZUrpkXMwlDkgB71+yY384jgGc49hp1GlB6f7T/SPkOIL8ekC/ti6+ZrR0z3y9lZWW4dOkS/H7/J30YLbLJyUm0trbCarViaGhIHNdqtWhoaIBSeW9Pa0LhCK4Ne2LCkesj7gVTa+QyoDovHaY54UhVbhqUq3xrzVwulwt+v1/0gwmFQjh06BBkMhkefvhhsa3miSeeQFpamph8Q0RElEgYmBBRQpsMTuL00GnRi6Tf0x9zviC1QGyzaS5oRqqK/SRWlHAoOtq39zTQeyrag8QVWwkEZRJQ3DS9xeZBoNAMKJZvW8O1a9dw+PBhPPzww6isrAQQHWtaWVkppuDQ8rh69SreffddANHqhXXr1sFkMsFoNEIuv7OwQpIkDDinYJ23tcYXDC+4tkCXFBOO1Bt0SNWsradQwWAQ3d3d6OjoQEdHB0ZHR1FVVYXPf/7zAACdTofGxkbk5ubGBNFzG+wSERElmrX1vz0RJTxJkmBz2kRAcm74HIJzpqCo5Co05jWKkMSoM7KKZCXx2YG+s0DPyWhA0n8OCE7GXiNXAobNsz1IirYAqvg1gezs7MTg4CBOnDghAhOFQsGwZInZ7XZYLBZkZWWhoaEBAFBXVweLxYINGzagvr7+jqoWRlxTaO134kKfU/w+5llYIZSmUWJjkS4mIMnTrr0mpJIkYXh4WAQkPT09CIdjw6RgMAhJksTP2E996lPxWCoREdGSYWBCRCueN+jFqcFTONZ/DMf7j2PAOxBz3pBmEAFJU34TUlQpcVopxZAkYLwjGozM/Bq9svA6jQ4o3gIUN0d/GRoBTXz6yUQiEbS1taGoqEj0wrj//vuhVCpFrxJaOsFgEG1tbbBarejq6gIA5ObmYuPGjZDJZFCr1XjhhRdueT9jHj9a+51o7ZsJSBwYdi0MRxRyGdblz26tMRdnwJiTBoV8bYasbrc7ZpqN1+uNOa/VasU0G6PRyG02RES06jEwIaIVR5IktDvaRUBybuQcQpHZCRRquRqb8zeLkKRMW8YqkpUg6AMGLNPhyPQWm8nxhdfpK6bDkSagZCuQXQPc4XaKpXLw4EGcP38emzZtwhNPPAEgOnFlZvoKLY3+/n6cP38eFy9eRCAw23eooqICZrP5Ez/W7g1Ew5F+Jy70OdDa58SAc2FTVpkMqMxJQ32RDhsNOtQXZaC2QItkNZuPAtFKql/84hcxx1QqVcw0m6ysLP6sJSKiNYWBCRGtCJ6AB6cGT+Fo/1EcHziOIe9QzPmitKLoRJui7dict5lVJCuBe2i270jvKWCwBZizPQoAoNBEe46UTFePFDUBaSunp0EkEoEkSWJiR0NDA9ra2kR1CS2P48eP4/LlywCAjIwMmM1mNDQ0QKfTxVzn9AVxcXo7zcV+Jy70O9A74bvhfRpzUkUwUm/Qoa5Qu+b6jtzM9evXcfLkSZSUlODBBx8EADG5Ji8vTwQkxcXFnGZDRERrGp85EFFcSJKEa/Zr0SqSgeOwDFsQkmarSDQKDTbnb8Z2w3ZsM2xDSXoJ39mMp0gYGL40p3rkJODoWXhdau50OLI1GpAUbASUmuVf721oa2vD+++/j6amJmzduhUAUFJSgr/6q7+CWq2O8+pWp0gkguvXr8NqtWL37t3IysoCEB0HrFKpYDKZUFYWrRhzTwVxomN8OhhxorXPga7xyRveb1lWCuqLMrDRoMMGgw4bDFqkJy1fY+CVzOPxwGazobi4GJmZmQCi04ZsNht8Pp8ITNRqNb797W9Do1mZ/16JiIjigYEJES0bd8CNk4MnRcPWkcmRmPOl2lI8UBgd+bslfwuSlGuv0eKKMeUE+s7Mbq3pOwsEPPMukgF5G6Jba4qbo0FJRml070MC8Pl8sNvtaGlpQXNzswjkGJYsvrGxMVgsFly4cAEeT/T7KDs7W2x1yi8qxYQiEx/0OdF6yooL/U7YRr03vK9ifTI2GjKwwaDDxiIdNhTqoEthODIjFAqhp6dHNGsdHo6O5X7kkUdw//33A4huddqzZw8qKipiPpZhCRERUSwGJkS0ZCRJwlX7VRzrP4ajfUfRMtqCsDQ7ZSFJkYQt+VuiW20M21GsLY7jatcwSQLsndFwpOdk9PeRNgBS7HXqdKBoc7TvSHFTdJJNkjYuS75ToVAI58+fR15eHkpLSwFEt9+Ew2GYTCZWLy2BUCiECxcuwGq1ore3VxxPSUlBfnkNOkJ6HPyVFa19TnSMehCRFt6HISMZGwxabJzeVlNv0CEzlYHWXJIkYXR0VAQk3d3dCIVCMdcUFBTENGhNS0sTVVVERER0cwxMiGhROf1OUUVyvP84Rn2jMefLtGWiWWtjXiOrSOIhOBXtNzJ3eo13dOF1mWWzk2uKm4Hc9YA8MfsZfPTRRzh27BhKSkrwxS9+ETKZDEqlEk1NTfFe2qolSRLe++Mf4Z+aAmQyhFLz0B7Jxlm7BsFxGYDYaVd5Wg3qDRnYWKRDfVE0HMlOY8XDjXi9XjHNpqOjQ1TtzEhPTxeTbIxGI1JTU+O0UiIiosTGwISI7klEiuDKxBWxzebC6IWYKpJkZTKa8puwzbANDxgeQHE6q0iWnWdkTjhyOjrJJhyIvUahBgpMs9tripuB9Ly4LHcxBAIBhMNh8a76li1b0NbWhg0bNsR5ZauTy+XCmfMWXG3vRMr6B3F50I2LA04oPdkISxI6QlnwTc5WhmSnaaLByPS2mnqDDrlahqc3EwqFIJfLIZ+eJnXs2DGcPHlSnFcqlSgrK4PRaERlZSWys7NZNUVERLQIGJgQ0R1z+p04MXAiOtGm/zjGp2JHxxp1RhGQNOY1QqPgu8TLJhIGRq/Mbq3pPRXdbjNfSvbs1pri5mhYolodL1gvXbqEt99+G7W1tdi3bx8AQKvV4qWXXuKLyEUgSRJG3H609k6g5eJljPdchXpyFDNf2YO2UxiJpE/fyoc+VY0m42wwUl+kQ742iX8Xt+l3v/sdLl26hGeeeUb0HKmsrERXV5cISIqLi6FU8ikdERHRYuP/rkR0SxEpgsvjl3G0/yiO9R9D61grIlJEnE9WJqO5oBnbDdvxgOEBGNIMcVztGuN3Rxuyzkyu6TsL+F3zLpJFt9MUN01Pr2kC9MaEac56p9LS0jA5OYnu7m6Ew2ExFpUv0O9cOCKhc8yDSwMutA240DboQlf/CAqCfahQTCBJFsJMHDoUTsOIugD1laWoLdKjtkCL+iIdDBnJ/NrfhpltNj09PXj88cdjvmbBYBA9PT0iMKmoqFjQsJWIiIgWHwMTIrohx5QDxweO43j/cRwfOI6JqYmY85UZlaIXiTnXDLWCjRiXnCQBju7ZypHeU9FRv3PCKwCAKjXanHVma03RZiA5Iy5LXmo+nw+nTp2CTqeD2WwGAJSWluK5555DZWWl2MJAtzYZCOHKkBttA65oQDLowtUhF6aCsd9fBXIP6jTRCVcRZRLSDZXYWN+AxppiZLHnyG0LhULo7e1FR0cHbDYbBgcHxTmz2YzCwkIAwP3334+tW7ciNzc3XkslIiJasxiYrBFlZWXQarWQy+XIzMzEhx9+GO8l0QoTkSK4NHZJ9CJpHWuFNGdKSooyBVsLtmJb0TZsK9yGgrSCOK52jQgFgKEL09trpvuPeIYWXqcriY70LW6OVo/k1gGKtfHj/eLFi/joo4+g1WpRX18vtiVUV1fHeWUr26jbj7ZB13Q44kTboAudY15IMZNqJBTI3VivGUdSajr01ZtQV6jD+vx0dFvTULt+HSoqKhhK3SZJkjA2NiYCkq6uLgSDwZhr8vLyYDQakZQ0uz0uJydnuZdKRERE09bGM2oCAHz88cdIS0uL9zJoBZmYmhAVJB/3fwy73x5zviqzSoz8NeWYoFKo4rTSNcI7Fls9MmABQlOx18iVQEHDnOk1TYC2MD7rjQOv14upqSlkZWUBiL4Tf/XqVZjNZrH1hmZFIhK6xr1zwpFo5cio23/D63PSNdiYo0S5fAwKezcCk9HpK8mYxF8/USu+xqaSJ5btMSS6S5cuiWk2LlfsdrnU1FQYjUYx0SY9Pf0m90JERETxwMCEaA0JR8K4OH4xWkXSdwyXxi/FVJGkqdKiVSTTDVvzU/PjuNpVLhIBxq7OVo70ngLG2xdel6yfDUaKmwHDJkCVvPzrXQEuX76MN998EwaDAfv37wcQnQ7yX/7Lf4nzylaGqWAYV4fcIhxpG3Th8qALk4HwgmtlMqA8OxW1BVrUFmpRV6hDkncIV1st6OzsRBhAGIBGo0F9fT3MZjMrSW5DOBzG6Ogo8vNnf3YeO3YMQ0PRyjCFQoHS0lIRkOTl5bG/CxER0QrGwCQBHDlyBK+++irOnTuHwcFBvPnmm3jyySdjrvnxj3+MV199FUNDQ2hoaMAPf/hDNDU1ifMymQwPPvgg5HI5vvWtb+ELX/jCMj8Kipcx3xg+HvgYx/qP4cTACTj8jpjzNZk1ohdJQ24DVHJWkSyJgBfoPwf0TFeP9J0GppwLr8uumbO9phnIqly1zVnvVGFhIcLhMAKBAPx+PzSatdsvY8IbmA5FnCIc6Rj1IhyRFlyrUcqxrkA7JxzRYl1+OpJVsc1w//CH8+jsjE5UMhqNMJlMWLduHVQq/ky4HW63Gz/84Q8RDofxX//rf4VaHe3rZDKZ4HQ6UVFRgZKSEn49iYiIEggDkwTg9XrR0NCAF154AU8//fSC82+88QYOHDiA119/Hc3NzXjttdewZ88eXL16VTSJO3bsGAwGAwYHB7F7927U19dj48aNy/1QaBmEI2G0jrWKiTZt420x59NV6dhauFVMtMlNYSPBJeHonVM9chIYughI897pVyZPN2ednl5TtBlI0cdnvSuMy+XCsWPHoFQq8eijjwIAdDodvvKVryAnJ2fNvCsfiUjos/tEn5GZcGTQOXXD6/WpatQVxoYjZVmpUCpmq0O8Xi8unD8Li8WCPXv2wGg0AgAaGxuh0WhgMpmQkZGxHA8vIfl8PthsNnR0dECpVOLxxx8HEJ3OlJqaikAggImJCVFl0tzcHM/lEhER0T2QSZK08O0oWrFkMtmCCpPm5mZs2bIFP/rRjwAAkUgExcXF+OY3v4nvfOc7C+7j29/+Nurq6vDFL37xtj6ny+WCTqeD0+mEVqtdjIdBi2zMN4Zj/cdwvP84Ph74GK5A7D759fr1oopkY85GKOXMShdVOBhtzir6j5wGXP0Lr9MaYnuP5NcD7AtzQ52dnfjFL34BhUKBv/qrv0Jqamq8l7TkJgMhtI94cGVwdlvN5UEX3P7QDa8vy0pB7ZxwpLZAhzyt5oZhUiQSQUdHBywWC65evYpIJDr5pr6+/oZBPM0Kh8Po6+sTzVr7+2f/bSclJeHb3/622K7kcrmQnp6+ZgI9IiK6PXw9lbj4qinBBQIBnDt3Dq+88oo4JpfLsXv3bpw4cQJA9N3ESCSC9PR0eDwefPDBB/jTP/3Tm96n3++H3z/bEHB+kzqKv1AkhAujF8REm8sTl2POa9Va3F94v+hFkp2cHaeVrlKTE0DfmenpNaejW21CvthrZIpoIFKydbb/iK4oPutNAHa7HU6nE2VlZQCik72am5tRU1ODlJSU+C5ukU0Fw2gf8eD6iBvXhj24NuTGtRE3+uw+3OgtDLVCjpr89NlgZHpLTXrSrcO2UCiEjz76CC0tLXC73eJ4YWEhTCYTNmzYsJgPbVWQJAkTExMiIOns7EQgEIi5JicnRzRrnYtPgomIiFYXBiYJbmxsDOFwGHl5eTHH8/LycOXKFQDA8PAwnnrqKQDRd8pefPFFbNmy5ab3+f3vfx/f+973lm7RdFdGJkdwvP84jvYfxcmBk3AH3THna7NqxUSbDdkbWEWyWMIhYOxaNBSZmV4zdm3hdUm6Oc1Zt0abs6pXf1XEYujo6MC//uu/QqvV4pvf/CYUCgVkMhkee+yxeC/tnvhDYXSOeXF1yI3rwx5cG3bj+ogH3eNe3KDVCAAgO02N6rzYcKQiJw0qxe03XI1EIqLiQaFQ4MqVK3C73UhOTsbGjRthNpsX/J9B0TcHPvroI9hsNjgcjphzKSkpMdNsGIwQERGtDXxFtQYYjUa0tLTc9vWvvPIKDhw4IG67XC4UFxcvxdLoEwQjQbSMtIgqkqv2qzHndRod7i+8H9sN23Ff4X2sIlkM4RAwegUYtAIDVmCwBRhqXVg9AgBZVbHTa7KrAU4RuW1zX9SXlJQgNTUVOTk58Pl8CTf+PBiOoGvMG60WGXaLX13jkzdswgoAGSkqVOemozo/DdV56ajKTUd1Xhqy0u6uka0kSejr64PFYkF7ezu++c1vQqVSQSaT4eGHH4YkSaiuroZSyf/2geibB/39/YhEIqKqSaVS4fz58wCilZolJSWoqKhARUUF8vPzuc2GiIhoDeIzpwSXnZ0NhUKB4eHhmOPDw8MxYw3vhEajWdPTJ+JpyDuE4/3Hcaz/GE4OnoQn6BHnZJChLqsO24qivUg2ZG2AQq6I42oTXDgIjFyeE45YgeFLQOgGzTTVaUD+xmg4UrIVKGoCUrOWecGrg8PhwKFDh+Dz+cQ4YJVKha997WsrfutNOCKhezw2GLk+7IFtzINg+MbBSHqSEtV50TCkKjcdNfnpqMpLQ07ajXuN3CmPx4OWlhZYrVaMjY2J49euXUNdXR0AYP369ff8eVaDuSGd1WrF73//e5SUlOD5558HACQnJ+ORRx5BTk4OSktLxZQbIiIiWrsYmCQ4tVqNxsZGHDp0SDSCjUQiOHToEF566aX4Lo5uKRgOwjpqFRNtrtuvx5zP1GTifkO0F8n9hfdDn8QJKnclFABG2haGI+HAwmvV6UBBA1Boiv5eYIqO9mX1yKJpa2tDJBLB2NgYsrOjlVErKSyJRCT02idFMHJ92I2rwx50jHoQCEVu+DGpagUq89JRkzddMTIdkuRrk5akMmF0dBSHDh3CtWvXMNO7XaVSoa6uDiaTCSUlJYv+ORPN1NQUOjs7RS+SrVu3oqmpCUC08jI5ORk6nQ6SJIm/o/vvvz+eSyYiIqIVhoFJAvB4PGhvbxe3Ozs7YbVaodfrUVJSggMHDmD//v3YvHkzmpqa8Nprr8Hr9Yp3zWhlGfIORQOSvmM4NXQK3qBXnJNBhvrsejHRpjarllUkdyrkj4YhMeFIGxAJLrxWowMKNk6HI9O/9EaGI4toYGAAIyMjMJlMAICMjAzs3bsXRUVFIiyJF0mS0O/w4fqwB1fnVIy0j3jgC4Zv+DFJKjmqcqNVItV56ajJi/65UJcMuXxpt2yEQiGxpUahUODq1eg2veLiYphMJtTV1a3p6sBIJIL+/n4RkPT19WHuIECbzSYCk8zMTHz729/mNhsiIiL6RAxMEsDZs2exc+dOcXumv8j+/fvxs5/9DM888wxGR0fx3e9+F0NDQzCZTHj33XfZ1G+FCIaDOD9yXvQiaXe0x5zXJ+nxQOEDoookIykjPgtNREFfNAwZtMyGIyOXgcgNxrAmZcypHDFF/5xZznBkCQ0MDOCf/umfoFQqUVlZKXqTbN68eVnXIUkShlxTuDbswfXpYOTqsAftw254AzcORtRKOSpy0lCTlzZdLRKtGCnOTFnyYGSuqakpXLp0CRaLBenp6XjmmWcAAHq9Ho8//jjKy8vjHjzFk91uFwGJzWaLmfAGAFlZWaJR60yvkhkMS4iIiOhWGJgkgIceeijmXbIbeemll7gFZwUZ8AzgWP8xHO0/ilODp+Cb0zRULpOLKpLthu1Yn7UechlftN9SYBIYvhhtxDo3HJFu8II3OTMaisyEI4UmIKMU4AukJefz+ZCcnAwAKCgoQHFxMTIzMxGJ3Hgry2KSJAmjHn+0YmTIPTu2d9gN99QNQjQAKoUMxuw0UTEyE4yU6FOgvIPJNItJkiR0d3fDYrGgra0NoVB07UqlEn6/X1SRfNK0s9Xu4sWL+PDDDzExMRFzPCkpKWaaTUZGRnwWSERERKsCAxOiRRAIB3B2+Kxo2Gpz2mLOZyVl4QHDA2KijU6ji9NKE0TAG51OMzccGb1643AkJWthOKIrZjiyzJxOJ373u9/BbrfjpZdeEqOB9+/fD4Vi8beVjXv80YqRkempNEMeXBtxwzF5g61XABRyGcqyUuaEItFgpCw79Y5G9i41q9WKI0eOwG63i2PZ2dkwm83YuHHjmtxyMzg4iGvXrqGmpkY0M1cqlZiYmIBcLkdRUZGYZlNQUCAauxIRERHdKwYmRHepz90nttmcHjodU0WikCnQkNOABwzRrTbr9OtYRXIzfg8wdGF2jO+gFRi7Bkg3qEhIzVkYjmgNDEdWgJSUFIyMjMDn86G/v180Hb3XsMQ5GcQ1EYq4RUgy5rlBw15EvxXKslJRlTvTfDUNNfnpKM9OhUa58voBza0eAYBAIAC73Q61Wo0NGzbAbDbDYDCsqe0jDocDOp1OPOaPP/4YFy9eRCQSEYFJeXk5nn32WZSVla3JEImIiIiWBwMTotvkD/txduisCEm6XF0x53OSc0RAsrVgK6tIbmTKdYNw5DqAG2w5S8uPnVRTaALSCxiOrACSJMFms6GzsxO7d+8GEJ3Q8tRTTyErK+uOt0FEIhKG3VPoHPOia2wS7SPRUOTqkBsjbv9NP65Yn4zq3HRU58+O7a3MTUOSauUFI/MNDQ3BYrGgtbUVu3fvxqZNmwAA9fX10Gg0qK2thUqlivMql4ff70dXV5foRTI+Po6vfe1ryM3NBQDU1NQgHA6joKBAfIxGo0FNTU28lkxERERrBAMTok/Q6+oVI3/PDJ3BVHhKnFPIFDDlmsREm5rMmjX1LvAtTTnnbKmZDkfG2298bXphbDPWQhOQnr9sS6U743K58K//+q+QJAnr16+HwWAAAFRUVNz0YyKRaOPVrjEvusYn0TXunf6zF93jk/DfZFwvABgykkWPkarcaMVIZW4aUtSJ9V+Yz+dDa2srLBYLhoaGxPHr16+LwCQ5ORkNDQ3xWuKyiEQiGBwcFAFJb29vTI8bmUyG4eFhEZhs2LABGzZsiNdyiYiIaA1LrGebREtsKjSFM0NnRBVJj7sn5nxuSq4ISLYWbEW6Oj1OK11hfPbYfiODLcCE7cbXaosWhiNpucu2VLpzkiRhbGwMOTk5AACdTofGxkYoFArodLOVVJGIhEERinhnw5ExL7onJhH4hFBEKZehWJ+C0qwUGLPTUJMfnU5TlZuG9KTErrSQJAlvvvkm2traEA5H+/AoFAqsW7cOJpMJRqMxzitcek6nM2aajc/nizmv1+tFs9aysjIkJSXFaaVEREREsxiY0JrX7eoWE23ODp2FPzy7BUApU8KcZxYhSVVGFatIJieiochMODJgBRzdN75WVwIUNsT2HUlduyNQE5HX68W//Mu/YGJiAi+//DKSklMw6PRBV92MrnEvXjvcg67xSXSP314oUjIdipRlp6IsK3X69xQYMpLjNpVmKXg8HjFGWSaTwefzIRwOIy8vD2azGfX19UhJSYnzKpfHL3/5S1y7di3mmEajgdFoFCFJZmZmnFZHREREdHMMTGjN8YV8ODN0Bkf7juL4wHH0untjzuel5ImRv80FzUhTp8VppSuAd2xeONICOHtufG1GaWwz1vwGIDVruVZKiygckTDg8KFr3IvOMS+G3QFEQhF88cd/QIszGYHwzUMRlSJaKVKWNROIzP65MCNpVYUi8wWDQVy+fBkWiwXd3d14+eWXRQXOzp078fDDD8f04VhtQqEQTpw4ge7ubjz77LOikW1mZiZkMhkMBoOYZmMwGDjNhoiIiFY8Bia06kmShC5Xl9hmc3boLAKR2QkbSrkSjbmNooqkIqNibVaReEZit9UMWAFX342vzSyPDUcKGoBkvkOcSGZCkc4xL7rHp7fOjHrgHe5Eum8I7/srICH670AnK8SUVAr/pBJABGqFHMX65JgKkZmKkQLd6g5F5pMkCQMDA7BYLLh48SL8/tkKte7ubmzcuBEAUFhYGK8lLhmXy4WJiQmUlZUBiG4zOnXqFLxeL3p7e1FeXg4A2LZtGx566CFusyEiIqKEw8CEVqXJ4CROD50WIUm/pz/mfEFqgQhImguakapKjdNK48Q9tDAccQ/c+NqsythJNfkbgeSM5Vop3YNQOIIBx1S0n8h4dALNzJ97JyYRDMdOJ1IijM8ltSNJHkKVyo5IZkk0DMlKRWl2KsqzUlGalYLCjGQo5GswVJxnZGQEv/nNbzA6OiqOZWRkwGQywWQyxfR3WQ0CgQC6u7tFL5LR0VGkpqbir//6ryGTySCTybBt2zYoFArR7waA2JpERERElGgYmNCqIEkSOp2dYqLNueFzCEaC4rxKrkJjXqPYalOuK18bVSSSBLgHYyfVDFgBz9ANLpYB2VWxzVjzNwJJ2uVcMd2hUDiCfodPNFedabbaPT6JXvvCUGQujRLYqA1Al1eM8uwUlGalQjmejjSVhP/ftvuQmpK8jI9k5YtEInC5XGJssk6ng8PhgFKpRG1tLUwmE8rKylbNzxZJkjA0NCQCkp6eHtG0Foj2ZsnMzMTk5CRSU6Oh89atW+O1XCIiIqJFx8CEEtZkcBInB0/iWP8xHO8/jgFvbIWEIc0gqkia8puQolrlDRYlCXD1LwxHvCMLr5XJgezqeeFIPaDh1J+VKBSOoM/ui508Mz2Ot3diEqHIzUMRtVKOsqxoGFKeHa0QKctKRVGGGr/7fz+D3W7Hlx/dOqe3RunyPKgEMjY2BqvVipaWFqSlpeErX/kKgGjj0ueeew4FBQWrZruJy+WCzWYTIcnk5GTMeZ1OJ/qQlJeXIzmZoRoRERGtXgxMKCFJkoRPvfkpjPpmS+HVcjU2528WIUmZdvW807uAJAHO3tgxvgNWYHJs4bUyOZCzbmE4ol5j25BWuOC8UKR7fFL0F+mz+z4xFNEo5dFtM1kp06HIbF+RfG0S5NPbZyRJivk3UVRUhEAgAJfLtaqbkd4Nv9+PtrY2WCwW9PbONoaORCIxE3Bm+nQkqrnfE16vF3/3d38Xc16tVqO8vFxMs9Hr9av35yoRERHRPAxMKCHJZDJsztuMi+MXRUCyJX8LkpWr8N1OSYqO7Z0fjvgmFl4rUwC562ObseZtANSrvLomQQTDEfROTMaEIZ3TI3n77D6EPyEUSVLNhiIzDVZnApK89NlQ5EYikQhOnz6Ns2fP4oUXXhDjbPfs2QO1Wg2VSrXojzWRnT59Gu+//z6Cwei2PplMhqqqKphMJlRXV0OhUMR5hfduYGAA77//PlQqFZ577jkAQGpqKvLz8yGXy0UVSVFR0ap4vERERER3g4EJJaz/74H/D0nK1VEGL0gSYO+MDUcGWwCffeG1cuW8cMQM5NUCqlUYGiWQQCiCXns0BOkcm5ydQDPmRb/jk0ORZJVCbJmZmT4zs5UmN13ziaHIJ5HJZGhpacH4+DjOnTuH7du3A4DoO7HWuVwuKBQK8fXIyMhAMBhEVlYWTCYTGhoakJ6euNvV3G43bDYbdDqdmGijUqnQ2dkJhUKBYDAoQrMvfelLDEiIiIiIpskkSbr5s3ciRF9M6HQ6OJ1OaLVsALpoIpHpcMQy229k8ALgdy68Vq6KhiEiHDEBeXWAUrOsS6aoQCiCnonYMGRm+ky/3YdPyESQolbEbJmZH4osxnYHv9+PCxcuoLGxEXJ5dMRvR0cHHA4HGhoaoFQyKw+Hw7h69SqsViva29uxbds2PPzwwwCiFTn9/f0oKipKyO0nwWAQPT096OjoQEdHB0ZGon2M6urq8NnPfhZAdCvO+fPnUVpaiqysrIR8nERERImCr6cSF581Ey2HSASY6Igd4zt0AfC7Fl6rUEfDkLnhSG4toFQv54rXNEmSMOENoM/uQ5/dh37H5HRAEt1KM+C4dSgSrRKZrhaZs30mZ5FCkU9a+z/+4z9iYmICycnJ2LBhAwCgoqJiyT5nIhkeHobFYkFra2tMQ9OJidktbnK5HMXFxfFY3l2RJAkjIyMiIOnu7o6ZZgMAhYWFyM/PF7dlMhkaGxuXe6lERERECYWBCdFii4SB8faF4UjAs/BaZVK0x8hMM9YCU3SbjYI9JZaSJEkY9fijYch0KNJnn0S/wyeO+YLhT7yPVLVC9BIpmx7JO/PnnLSlDUXmm7ulQiaTYePGjbhw4QJ7k8whSRL+7//9v7DZbOJYWloaTCYTTCYTsrKy4ri6Ozc5OYn29nYxzcbjif35otVqRaNWo9Eo+tYQERER0e1jYEJ0L8IhYOxa7BjfoVYg6F14rTI5Op1mbjiSU8NwZAlEIhJG3H70OyZFlYgIRew+9Dt88Icin3gfMhmQl56EosxkGDKTUZSZPKe3SCqy09Rx38YgSRI++ugjnDx5El/84hdFBcEDDzyA7du3i+04a5EkSejp6UFJSQlkMhlkMhkyMzMhl8tRU1MDk8mEysrKhPkahUIhhMNhaDTRbXg2mw1vvvmmOK9SqVBWViZCkuzs7Lh/fxIRERElOgYmRLcrHAJGrywMR0K+hdeqUoD8jbOTagpMQHY1oOA/ucUQjkgYdk2J7TJ9EzNbZ6KhyIBjCoHwJwcichmQr01CUWZKTCgyc7tAlwy1cmW/mJbJZBgbG4Pf70dLS4sITNZyjxKHwwGr1Qqr1Qqn04kXXnhBbK/ZsWMHdu7cmXDNbj/66CMcO3YMO3bsEA17jUYjCgoKREBSXFy8pv/eiYiIiJYCn10R3Ug4CIxcjh3jO3wRCE0tvFadNiccMUUDkuwqQM5JE3crFI5g0DkltsjMVIb02X3oc0xi0DGF0Cc1EQGgkMtQoJuuEMlImQ5DosFIcWYK8nVJUClWdiAyn8fjwcmTJ/HAAw8gOTk6Demhhx5CXV0d1q1bF+fVxU8wGMSVK1dgtVpjttxoNBrY7XYRmKz0Jmterxc2mw02mw07duxAZmYmACAlJQWhUAiDg4Pi2pSUFHz5y1+O11KJiIiI1gQGJkShADDSNi8cuQSE/QuvVafHbqkpaACyKoEEKetfKQKhCIacU+izT2+Zma4MmekfMuSa+sTxuwCgUshQmJEMQ8ZsZYj4sz4FeekaKBMsELmVf/u3f0N/fz+USiUeeughAEB2djays7Pju7A4Gh8fxz//8z9jamo2zCwvL4fZbMa6detWdB+XUCiE3t5e0ax1aGhInDMYDNi8eTOA6HSb0tJS5OTkxGupRERERGsSAxNaW0L+aBgixvi2RMOScGDhtRodUDC3csQE6I0MR26DPxTGgGMqtjJkTlPVIdcUbjXQXK2Qi20yMaHI9LHc9CQo5Ku7R4PL5UJ6erroRXHffffhxIkTCTXBZbFNTk5idHQUpaWlAAC9Xg+NRgONRoOGhgaYzWZkZGTEd5E3IUkSxsbGYqbZBIPBmGvy8/NhNBpRVFQkjqWkpLBpKxEREVEcyCTpVi9baK1L2LnhwanpcMQyJxy5DESCC69NyoitHCk0AZnl0c6ftMBUMBzTM2R22kz0zyPuG1TnzKNRyqe3yMzZLpMRDUWKM5ORnaaBfJUHIp/k/fffx8mTJ/H000+jtrYWQPQFN4A118wzEomgo6MDVqsVV65cQVJSEg4cOACFIrrtzeFwQKfTrdivy/Xr19HW1gabzQaXK3aUeFpamphkYzQakZaWFqdVEhER0VJJ2NdTxAoTWiWCPmDoYmzlyOhlIBJaeG1y5mwoMvN7RinDkTkmA6E5PUPmhyI+jHluHYgkqxQxfUOKRDAS3TqzEqbMrGQKhQLhcBg2m00EJmvt6zUxMQGLxYKWlha43W5xXKfTweVyiR4fK6miJBwOo7e3FyUlJWICz0x/FSDakLe0tFQ0a83NzV1zf69EREREiYKBCSWuM/8H6Ds7HY5cAaTwwmtSshaGI7riNR+OePyhm26X6bP7MOG9wRaleVLVChTrU264XaYoMwWZKSq+ELxN4+PjOHbsGO677z7k5uYCALZu3Yry8nKUlZXFd3FxcurUKbz77rvidnJyMjZu3AiTySSmAa00kiThhz/8IZxOJ/7iL/5CbKupq6uDRqNBRUUFSkpKVnRfFSIiIiKaxcCEEtfZnwLDrbO3U3Njx/gWmgCtYU2GI05fMGaLTMzWGYcPjskbbEuaR5ukvOF2mZnbumQGIovlgw8+QFtbG0KhEP7kT/4EQDQgWCthiSRJ6Ovrg0ajEYFRWVkZZDIZKioqYDabUV1dvWLG5k5OTqKzsxMdHR0YGxvD888/D5lMBplMBoPBgFAoFFMRM7PdhoiIiIgSy8p49kl0N8z/BfBNzIYj6QVrIhyRJAlOX1BUhvTZZytDZoIR99QNtiLNk5GiWhCEzPzZMB2I0NIYGRmBVqtFUlISAGD79u0IBoNobm6O88qWl8fjQUtLC6xWK8bGxlBfX4+nn34aAJCXl4cDBw6siJ4e4XAYfX19olnrwMBAzPnx8XExqeiJJ56ARqNhmEhERES0CjAwocS19avxXsGSkCQJE97ATZqqRm97AzfYfjRPVqo6ZovM/K0zaRr+84+H999/H8ePH8fOnTuxY8cOANHJKJ///OfjvLLlEQ6Hcf36dVitVly7dk00slWpVFCr1THXxisskSQJExMTIiDp6upCIBC7TS03N1f0IZnbQ2UmBCMiIiKixMdXTETLTJIkjHkCN94uMx2K+IK3DkSy0zRzGqrO2S6TET2WouY/75UoLy8PAOB0OuO8kvj4xS9+gZ6eHnG7qKgIZrNZ9PmIp3A4jLfffhsdHR0L/n5SUlLENJuKigqkp6fHaZVEREREtFz4iopokUUiEkY9/ptul+m3++APRW55P3laTex2mczYrTNJKsUyPBq6FwMDA/joo49gNpuxbt06ANEGoPn5+cjJyYnz6pae3+/HpUuXUF9fLxqdVlVVYXx8HA0NDTCZTHH7OoTDYfT398PhcGDjxo0AopOJurq64HQ6oVAoUFxcjIqKClRUVCA/P5/bbIiIiIjWGAYmRHcoHJEw7JqarQyZ8M2ZMDOJAccUAuFPDkRkMiBfm3TT7TIFuiQGIqvAlStXcO3aNXg8HhGYyOXyVR2WSJKE7u5uWCwW0chWpVKhvr4eANDc3Iz77rsPCsXyfn9LkiTWAkT7yPz0pz+FWq1GXV2dWM+uXbugUqlQWlq6YIsQEREREa0tDEyI5gmFIxhyTc1WhsybNjPg8CEUkT7xPuQyoEA3b7vMnFAkX5cEtVK+TI+Ilkt3dzfS09Oh1+sBREcDezwePPDAA3Fe2dJzOp2igavdbhfHs7OzY8KR5Ryp6/P5xDQbm82G0tJSPPnkkwCifWOys7ORn5+PqakppKamAgBqa2uXbX1EREREtLIxMKE1JxiOYNAxhT7H3C0zk6J/yJBrCuFbBCJKuQwFGUkoyrjxdpl8XRJUCgYia8mHH36II0eOxEx6SUlJwac//ek4r2zpud1u/P3f/71o4KpWq7FhwwaYzWYYDIZl28oSiUTENBubzYb+/n6xJiBaZSJJkhgB/PWvf53bbIiIiIjophiY0KrjD4WjgchMEOKIDUWGXFO4RR4ClUIGw3Tz1JlQpEifDMP0n/O0SVDI+UJrLZt58S2XR4OxdevW4fjx40hKShIvyleroaEhDAwMYNOmTQCA9PR0lJSUAADMZjPWr1+/bNtZZqbZ2Gw2dHZ2wu/3x5zPzs4WjVrLyspi/l5W898REREREd07mTT37TeiG3C5XNDpdHA6ndBqtfFejvBxxxi6xiYXTJsZcftxq+9qtVIupsmI6TLTvwwZKchN10DOQIRuoqurC++//z7WrVuHbdu2ieOTk5NISUmJ48qWjs/nQ2trK6xWKwYHByGXy3HgwAGxlSUUCkGpXL4Mvre3F2+++WbM9h8ASE5OhtFoFCGJTqdbtjURERER3chKfT1Ft8YKE0pY3/uPNlwddt/wXJJKHrNFJnbSTDKyUxmI0N1zOp3o7++H2+3G/fffL6pMVltYIkkSbDYbrFYrLl++jHA4Ou5aLpdj3bp1CAQCIjBZyrBkZGQEly9fRnZ2Nurq6gAAOp0OdrsdcrkcxcXFIiApKCgQfx9ERERERPeCgQklrK1GvQhA5ociWalqltvTopAkCVeuXEFycjLKysoAAPX19XA6ndi0adOqfnF+7tw5HDx4UNzOy8uD2WxGfX39koZDdrsdycnJSEpKAgB0dHTg8OHDqKysFIGJVqvFn/3Zn8FgMECj0SzZWoiIiIho7WJgQgnre5/ZEO8l0Bpw4sQJ/PGPf0RhYSG+9KUvQSaTQS6XY8eOHfFe2qIKBoO4fPkyUlJSUFlZCSA6Mebw4cOora2F2WxGfn7+kgSRfr8/ZprNxMQEPvOZz8BkMgEAKisr0dfXh+rq6piPMxqNi74WIiIiIqIZDEyIiOaIRCIIBAKiuqGhoQEnTpxARUUFIpFIzIjcRCdJEgYGBmCxWHDx4kX4/X4UFxeLwCQlJQUHDhxY9CqaSCSCgYEBEZD09vbGTLORyWRwOBzidk5ODj73uc8t6hqIiIiIiG6FgQkR0bTOzk4cPHgQRUVFePLJJwEAqamp+Na3vrWqghKv14sLFy7AYrFgdHRUHM/IyEBFRUXMlJ/FCkscDocISGw2G6ampmLO6/V60YekvLyc22yIiIiIKO4YmBARTVOr1RgfH8fU1BQCgYAYjbuawhIAeOutt9De3g4g2qy1trYWJpNpwdjdxfLee+/hxIkTMcc0Gk3MNJvMzMxF/7xERERERPeCgQkRrUnhcBhWqxVyuRxmsxkAYDAY8Cd/8ieoqqoSYUmiGxsbg9VqRVNTkxhj19DQAJ/PB5PJhA0bNojtR4vh5MmTuHLlCh577DHk5+cDgOh9UlRUBKPRiMrKShQWFq7qhrlERERElPgYmBDRmnTp0iX8/ve/R2pqKjZs2ACVSgUA2LAh8ZsJ+/1+tLW1wWKxoLe3F0C0omP79u0AgLq6ukV5nE6nE729vTH31dnZie7ubnR0dIjAZP369aiurl7UYIaIiIiIaKkxMFkDHA4Hdu/ejVAohFAohJdffhkvvvhivJdFtKyCwSA8Ho/Y+lFXV4dz585h/fr1q2IEtSRJ6O3thcViwaVLlxAMBgFEG6hWVVXBYDCIa+/28QYCAXR1dYleJGNjYwCAoqIiZGRkAAA2b96MysrKmIk2KpVKBFJERERERIlCJs0dTUCrUjgcht/vR0pKCrxeLzZs2ICzZ88iKyvrtj7e5XJBp9PB6XSKkn6iRNLd3Y1f//rXyMjIwF/8xV+sioBkPr/fj//+3/87QqEQACArKwsmkwkNDQ1IT0+/q/uUJAmDg4MiIOnp6UEkEhHnZTIZDAYD9u7di8LCwkV5HERERESrDV9PJS5WmKwBCoUCKSkpAKIvqiRJAnMyWkuysrLg9/vh8Xjg8XjuOkBYKcLhMK5du4bu7m489thjAKJbbkwmE0KhEMxmM4qLi+8qGHK5XCIg6ejogM/nizk/M0mnoqICZWVlSE5OXpTHRERERES00jAwSQBHjhzBq6++inPnzmFwcBBvvvmmGHk648c//jFeffVVDA0NoaGhAT/84Q/R1NQkzjscDjz44IO4fv06Xn31VWRnZy/zoyBaHn6/H6dPn8bU1BQeeeQRAEBaWhr279+PgoKChJ54MzIyAovFggsXLmBychIAYDKZRK+Qffv23fF9RiIR0XxVkiT8n//zf+ByucR5tVqN8vJyEZJkZmauygodIiIiIqL5GJgkAK/Xi4aGBrzwwgt4+umnF5x/4403cODAAbz++utobm7Ga6+9hj179uDq1avIzc0FEH1XuKWlBcPDw3j66afx2c9+Fnl5ecv9UIiW3MjICD744API5XJs2bJF9NYoKiqK78Lu0tTUFC5evAiLxYKBgQFxPC0tDQ0NDaJ67E653W68+eabGB0dxV/91V9BLpdDJpOhsrISw8PDIiAxGAwJHTIREREREd0tBiYJYO/evdi7d+9Nz//gBz/Aiy++iOeffx4A8Prrr+PgwYP4yU9+gu985zsx1+bl5aGhoQFHjx7FZz/72Rven9/vh9/vF7fnvttMtNL4fD6MjY2huLgYAFBcXIzGxkaUlJSsij2iXV1dOHjwIABALpejpqYGJpMJlZWVtz2W1+12o6OjA5IkiRHKqampGBgYgN/vx9DQkOhB8qlPfYoVJEREREREYGCS8AKBAM6dO4dXXnlFHJPL5di9ezdOnDgBABgeHkZKSgrS09PhdDpx5MgRfO1rX7vpfX7/+9/H9773vSVfO9G9GhgYwM9//nOo1Wr85V/+pZjE8qlPfSrOK7s7TqcTVqsVycnJYktdVVUVysvLUVVVhY0bNyI1NfWW9xMMBsVoX5vNhpGREQDRSjOTyQSZTAa5XI6nn34aWVlZ0Ov14mMZlhARERERRTEwSXBjY2MIh8MLttfk5eXhypUrAKITQr785S+LZq/f/OY3UV9ff9P7fOWVV3DgwAFx2+VyiXfvieJNkiTxoj4vLw/JyclISkqC2+2OeeGfKEKhEK5cuQKLxQKbzQYA0Gq12Lx5M+RyORQKBf78z//8E+9DkiQMDw+LgKS7uxvhcDjmmsLCQhiNRkQiEbHFZu7oXyIiIiIiisXAZA1oamqC1Wq97es1Gg00Gs3SLYjoLkxOTuLo0aMYHR3FF77wBchkMigUCjz//PPQarUJVxkxNDSE8+fPo7W1FVNTU+J4eXk5TCbTLT/e7/fjypUrYpqN1+uNOa/VakUfkvLy8rvudUJEREREtFYxMElw2dnZUCgUGB4ejjk+PDwsJmcQrQbhcBhnzpxBOBxGf3+/aOKq0+nivLK7c+bMGZw/fx5ANNwwmUwwmUzIzMy84fXBYBA+n0/0ZfF6vXjrrbfEeZVKhbKyMhGSZGVlJVyIRERERES0kjAwSXBqtRqNjY04dOiQGDUciURw6NAhvPTSS/FdHNE9cDqd6OnpEdvH0tPT8cgjjyArKwsGgyHOq7t9kUgENpsNFosF999/v1j7pk2b4Pf7YTabUV5e/okNXC9cuID//M//RGVlJZ555hkAgF6vR01NDXJyclBRUYGioiIolfyRTkRERES0WPjsOgF4PB60t7eL252dnbBardDr9SgpKcGBAwewf/9+bN68GU1NTXjttdfg9XrF1ByiRGO32/GjH/0IAFBSUiKqSJqbm+O5rDsyMTEBq9UKq9UKt9sNAEhKShKBicFgWDCpyuPxwGazwWazoba2VvQYycrKQigUwvj4eEwPl2effXYZHxERERER0drCwCQBnD17Fjt37hS3Zxqy7t+/Hz/72c/wzDPPYHR0FN/97ncxNDQEk8mEd999d0EjWKKVLBgMiik3mZmZKCkpgUwmQyAQiPPKbl84HMbFixdhsVjQ3d0tjicnJ6O+vh6bNm2KuT4UCqGnp0c0ax0aGhLnZDKZCEwKCgrw9a9/HdnZ2dxmQ0RERES0TGSSJEnxXgStbC6XCzqdDk6nU/RPIFosk5OT+MMf/oDu7m689NJLYltJIBCAWq2O8+ruTCQSwd///d/D5XIBACorK2EymVBTUwOlUglJkjA6OioCkq6uLoRCoZj7KCgogNFoRE1NDadTEREREa0CfD2VuFhhQkRxpVar0dnZCbfbjY6ODtTU1IjjK5nH48GFCxdw7do1/Nmf/RkUCgXkcjkeeOABTE1NoaGhQWwl6unpgcViQUdHh9ieMyMtLU00ajUajUhNTY3HwyEiIiIionkYmBDRshoeHsbly5fx0EMPAQCUSiWeeOIJpKamorCwML6Lu4VwOIzr16/DarXi2rVrmCnQa29vF0HPpk2b0NvbG9PEdWxsTIz2ViqVKC0tFSFJTk4Ot9kQEREREa1ADEyIaNn4fD780z/9E8LhMMrLy1FaWgoAqKqqivPKPpnT6cSpU6dw4cIFeL1ecbyoqAgmkwllZWXi2BtvvIH29nY89thjokltRUUF7r//flRUVKCkpITTbIiIiIiIEgCftRPRknK5XGKvZnJyMsxmM3w+H9LS0uK8stvn8/lw4sQJAEBqaipqa2uRkZGB0dFRHDlyBDU1NdBoNACAsrIyDA4OIhKJiI/X6XR45JFH4rJ2IiIiIiK6O2z6SrfEJkV0NwKBAH7961+js7MTf/mXfym+d+aOxV1pJEkS/UZUKhX27dsHILoV57e//S0AwOFwYHBwMObjnnrqKWzcuBFAdPKNQqFYsY+RiIiIiJYXX08lLlaYENGSUKlUCAQCiEQi6OrqEoHCSgwSXC4XWlpaYLVaMTExASDaayQjIwM9PT3o7OxEMBiM+Zi8vDwYjUaxzWYGt9sQEREREa0OrDChW2IiSrciSRK6u7tx7tw5PPnkk1AoFACiDV5VKhX0en2cV3hjHR0dOHnyJDo6OkQDV7lcDoVCsSAgSU1NFZNsjEYj0tPT47FkIiIiIkowfD2VuPhWKBHds5ktKx6PB2VlZWhsbAQQrcJYaWa2BEUiEbS1taG9vR0AUFpaCpPJhPb2dly6dAkKhQKlpaWiiiQvL29FVscQEREREdHSYGBCRHdMkiT09fWhuLgYQHQbyo4dOzA6OorKyso4r24hn8+H1tZWnD9/Htu2bcOGDRsQiUTQ0tICAHjuuedQXV0NAMjJyYHJZEJpaSlUKlU8l01ERERERHHEwISI7kgkEsHPfvYz9Pb24vnnnxf9O7Zs2RLnlcWSJAlXrlzBiRMn0NfXJ7bctLS0YMOGDVAqlairq4MkScjIyBAfZzAY4rRiIiIiIiJaSRiYENEdkcvlyM7OxtDQEMbHx2MansZbOBxGX18fPvjgA/T39yMcDsecl8lk2LNnj7j91FNPLfcSiYiIiIgoQbDpK90SmxStXZIkoa2tDSdOnMAzzzwjGp16PB7IZDKkpqbGfX12ux3Xr19HZ2cnOjs7EQgEYq5JSkpCZWUl6uvrUVZWBrVaHafVEhEREdFaxNdTiYsVJkT0iU6ePIn+/n6cPHkSjzzyCAAgLS0tzqsC3G43/vEf/xEejyfmeHJyMnJzc5GdnY37779/xU7oISIiIiKilY2BCREJM5Nj1q9fD4VCAZlMhp07d6KnpwfNzc1xW5fD4YDVaoVMJsPmzZtx4cIFWK3WmLCkpqYGO3bsQEFBAafZEBERERHRPWNgQkTCz3/+c/T09ODTn/40zGYzAMBoNMJoNC7rOux2O2QymWjG6nQ68dFHH0GhUODIkSOIRCIAAIVCgXXr1qGxsRFlZWUMSoiIiIiIaNEwMCFawyKRCORyubhdU1ODsbExLHdro6mpKXR1daGjowMdHR2w2+3YsmULHnnkEahUKhQVFWH9+vW4cuUKJElCYWEhzGYzNmzYgKSkpGVdKxERERERrQ1s+kq3xCZFq9P58+dx5MgRfO5znxOjdIPBICRJWvLGqJFIBAMDAyIgmTv2F4hOs0lOTkZOTg6++MUviuMWiwWFhYXIy8tb0vURERERES0Wvp5KXKwwIVqjent74XQ6cfr0aTFeV6VSLdnnczgcIiDp7OzE1NRUzHmtVgu1Wg2Hw4FQKITJyUn09PTA7XaL6Twz24SIiIiIiIiWGgMTojUgGAzi3LlzqK+vF6OAt23bhoKCgmUJISwWC/7jP/4j5lhSUhKMRiOSkpJgs9ngcDjEOb1eD7PZjIaGBhGWEBERERERLScGJkRrwK9//Wtcv34dbrdbjAbOyspCVlbWon+ulpYWnD9/HiaTSYQxxcXFkMlkKC4uRllZGcrKylBaWgq5XI7W1lacP38eKpUKdXV1MJvN4noiIiIiIqJ4YWBCtAr5/X6oVCrR0HXz5s0YHR1Fbm7uon6emW02dXV1ovmqw+FAT08P0tLSRGCSlZWFF154AZcuXcLZs2ehUqlQXl4OAFi3bh0+/elPo7a2FhqNZlHXR0REREREdLcYmBCtMqdOncLhw4fx2GOPoaGhAQBQVVWFiooKKBSKe7pvv98vptnYbDaMj48DAJKTk1FbWwsAqK2tRWpqKioqKjA1NYWLFy/CarWiv79f3E97ezu2bdsGINo3hb1JiIiIiIhopWFgQrTKBINBTE1Noa2tTQQmMpnsrsKSSCSCoaEh0ay1t7cXkUhEnJfJZCgqKoJSOfujJCcnBzk5OfjP//xPXLhwAaFQCAAgl8tRXV0Nk8mEqqqqe3yURERERERES4uBCVECm5ycxIkTJ1BbW4uCggIAwJYtW5CRkSEqPu6Uy+USAYnNZoPP54s5n5GRgYqKClRUVKC8vFxsxfF4PEhLSxPXBYNBhEIh5OTkwGw2Y+PGjaLhLBERERER0UrHwIQogf3xj3+E1WrF6Ogonn32WQCARqPBhg0bbvs+gsFgzDjhd955B1euXBG3NRoNysvLYTQaUVFRAb1eL86FQiGx5aajowNf/epXkZeXByA6hae5uRmFhYVs4EpERERERAmHgQlRAnG73VAqlUhOTgYAPPDAAxgZGYHJZLrj+5IkCf/6r/+Kzs5OfOMb3xBBSGVlJTwejwhIDAbDgu08g4ODsFgsaG1txdTUlDje3d0tApPFbjBLRERERES0nBiYECWIkydP4tChQ9i6dSt27doFAMjOzsaLL754y4+d2WYzPj6O3bt3A4j2HwmHw4hEIuju7haBSWNjIxobG294P3a7Hb/61a8wNDQkjmm1WphMJphMJmRmZt7rwyQiIiIiIloRGJgQJYiMjAyEQiEMDg5CkqRP3OYSDAbR3d0tepGMjo6Kc/fdd5/oJfLII49Ao9HEbLOZKxKJwOl0iiBEq9XC5XJBoVBg3bp1MJvNKC8vF+OLiYiIiIiIVguZJElSvBdBK5vL5YJOp4PT6YRWq433ctYEu92OY8eOwWg0oq6uDkB0C01PTw9KSkoWhCWSJGF4eFgEJD09PQiHwzHXGAwGGI1GNDc337L56sTEBKxWK1paWiCTyfDyyy+Lz9nT04OcnByxLYiIiIiIiG6Or6cSFytMiFag1tZWnD9/Hj09PaitrYVMJoNMJkNpaam4JhwO4+LFi2KajdfrjbkPnU4n+pAYjcZbBhzBYBBtbW2wWq3o6uoSx5OTkzExMYGsrCwAQElJyeI9UCIiIiIiohWKgQnRCjA2Nga5XC62xjQ1NWFoaAhbt24VlR3BYBAOhwM5OTkAoj1I/vCHP4ixvyqVKmaaTVZW1m1Pp2lpacHbb7+NQCAgjlVUVMBsNqOmpgZKJX9UEBERERHR2sJXQURxdubMGbzzzjtYt24d/vRP/xQAkJSUJP4MAAMDA/jJT36C1NRUfOtb34JMJoNcLsfmzZshSRIqKytRVFS0YJrNzXg8HkQiEVESqNfrEQgEkJGRAbPZjIaGBuh0usV/sERERERERAmCgQlRHMxt2jqzzWamwWpXVxdsNhuys7Oxfft2ABBVJQDg9XqRlpYGAHj44Ydv+3NGIhFcv34dVqsV165dg9lsxqc+9SkAQFFREZ5//nkUFxffdlUKERERERHRasbAhGgZjYyM4MMPP0ReXh4eeughBINBuN1umEwmDAwM4LXXXhPX5uXlicBEpVLhm9/8JrRa7R0HGmNjY7BYLLhw4QI8Ho847nA4RHAjk8nYm4SIiIiIiGgOBiZEy2hsbAxXrlxBe3s7enp60Nvbi1AoFHNNQUGB6EMy191skfn1r3+NtrY2cTslJQUNDQ0wmUzIzc29uwdBRERERES0BjAwIVpCfX19CIfDSElJwfHjx9He3g4ACIVC6OzsBACkp6eLSTZGo/GWI39vZmbscHFxMeRyOQCIxq9VVVUwm82oqqq67T4nREREREREaxkDE6JFFgqF0NPTg56eHnz00UfIzc3Fk08+iZaWFgCAUqlEWVkZKioqUFFRgezs7HvqG+JyudDS0gKr1YqJiQk899xzqK6uBgA0Nzdjy5YtSE9PX5THRkREREREtFYwMCG6R5IkiT+HQiEcOXIEx44dQ11dHZKTk1FYWIjMzEzs2LEDpaWlKCkpuecxvaFQCNeuXYPFYkFHR4dYg1qthtPpFNfdbbUKERERERHRWsfAhOgueL1e2Gw22Gw2dHR04IEHHkBbWxvS09PR2NgIq9WK9PR0fOtb34JarQYA7Ny5c1E+t9vtxv/6X/8LPp9PHCstLYXJZEJtba34fERERERERHT3GJgQ3YZQKITe3l50dHTAZrNhcHAw5nx/fz96enqgVCrx2GOP4cCBA4s2ntfn82FwcBBGoxFAtOeJTqeDUqkUDVyzsrIW5XMRERERERFRFAMTohuQJAljY2MiIOnq6kIwGIy5RqvVYsOGDaioqEBJSQnKyspQWVmJtLS0Rfn8nZ2dsFgsuHz5MuRyOf76r/8aGo0GAPDss88iPT1dNHclIiIiIiKixcXAhGieU6dO4eOPP4bL5Yo5npqaioqKCqSkpODkyZMIBALYsWOHCDE2bdp0z5/b4XDAarXCarXG9CLJysqC0+kUo4DvZsQwERERERER3T4GJmvEU089hcOHD2PXrl34zW9+E+/lrBjd3d1ob2/Hli1boNVqAUSrO1wuFxQKBUpLS2E0GpGfnw+j0QiZTIZIJIKenh6UlZXFNHy9Vy0tLXjrrbfEbY1Gg/r6epjNZhQUFCzaFh8iIiIiIiK6NQYma8TLL7+MF154AT//+c/jvZS4mQlC5lZn/PGPf0R/fz/0ej3MZjMAoLa2Fjk5OSgpKcHExAR++9vforW1FV/5ylcAAHK5HF/60pfuKcCQJEn0QSksLAQAlJWVQSaToby8HCaTCevWrYNKpbrrz0FERERERER3j4HJGvHQQw/h8OHD8V7GsvP5fGKSjc1mg8vlwt/8zd8gKSkJAFBXVwe9Xg+9Xi8+RqvVimoTrVYLp9MJmUyGiYkJ0Vz1bsMSr9eL1tZWWCwWjIyMoLKyEl/4whcARLfZ/PVf/zVHARMREREREa0ADEwSwJEjR/Dqq6/i3LlzGBwcxJtvvoknn3wy5pof//jHePXVVzE0NISGhgb88Ic/RFNTU3wWHEfhcBh9fX0iIOnv7485r1AoMDw8jNLSUgDAfffdF/Oxra2tGBsbw+7duwEAycnJePbZZ1FQUCBCljsViUTQ0dEBi8WCq1evIhKJiLWkpKRAkiQRwDAsISIiIiIiWhkYmCQAr9eLhoYGvPDCC3j66acXnH/jjTdw4MABvP7662hubsZrr72GPXv24OrVq6JJ6GolSRImJiZEQNLZ2YlAIBBzTU5ODioqKlBRUYHS0tKbbnMZHR3F7373O8hkMphMJmRnZwMAysvL72mNv/rVr3D16lVxu7CwECaTCRs2bEBycvI93TcREREREREtDQYmCWDv3r3Yu3fvTc//4Ac/wIsvvojnn38eAPD666/j4MGD+MlPfoLvfOc7d/z5/H4//H6/uD1/WsxKIUkS/vf//t8YHh6OOZ6SkgKj0YiKigoYjUaxvWa+UCiE0dFRFBQUAADy8/NhNpuRlZV104+5lUAggEuXLmHdunUiDKmqqkJPTw82btwIs9mMvLy8u7pvIiIiIiIiWj4MTBJcIBDAuXPn8Morr4hjcrkcu3fvxokTJ+7qPr///e/je9/73mItccnIZDJkZGRgdHQUJSUloookPz//lj1GxsfH8Ytf/ALBYBAvv/yyGA386U9/+o7XIUkS+vr6cP78eVy6dAnBYBDBYFBsiWpoaIDJZIJCobjzB0lERERERERxwcAkwY2NjSEcDi+oWsjLy8OVK1fE7d27d6OlpQVerxdFRUX49a9/HdO/Y65XXnkFBw4cELddLheKi4uX5gHco7179+Lpp5+GWq2+o4/LzMyEUqmEJEkYHx8Xk2ruhNvtxoULF2CxWDA+Pi6O6/V6EcAAgFLJf2ZERERERESJhq/k1oj333//tq/VaDQxL/hXsrkjgm8mEAjg7Nmz6OrqwnPPPQeZTAa5XI7nnnsOGRkZdxVo+P1+/MM//ANCoRAAQKVSoa6uDiaTCSUlJfc0cpiIiIiIiIjij4FJgsvOzhaTX+YaHh5Gfn5+nFa1sgSDQRw+fBjBYBAdHR2orKwEANHU9XaMjIygq6tLbLPRaDSoqKjA5OQkTCYT6urqEiZkIiIiIiIioltjYJLg1Go1GhsbcejQITFqOBKJ4NChQ3jppZfiu7g4mZqaQldXF9atWwcgOqp3586dSE5OvqOJN1NTU7h06RIsFosYT1xZWQm9Xg8A+OxnP8vtNkRERERERKsUX+0lAI/Hg/b2dnG7s7MTVqsVer0eJSUlOHDgAPbv34/NmzejqakJr732Grxer5ias5Z4vV786Ec/gt/vx0svvSTCjZv1a5lPkiR0dXXBarWira1NbLmRy+Worq5GOBwW1zIsISIiIiIiWr34ii8BnD17Fjt37hS3Zxqy7t+/Hz/72c/wzDPPYHR0FN/97ncxNDQEk8mEd999d82Mr41EIpDL5QCi1STFxcVwOByYnJwUgcntamtrw29+8xtxOycnByaTCRs3bkRaWtqirpuIiIiIiIhWLpkkSVK8F0Erm8vlgk6ng9PphFarjfdyhEAggCNHjqCtrQ1f/epXxaScyclJJCcn37LxaigUwtWrVyGTyVBbWwsg2u/kRz/6ESorK2E2m2EwGNjAlYiIiIiI7tpKfT1Ft8YKE0pYSqUSbW1tsNvtuHTpEsxmMwAgJSXlEz9uaGgIFosFra2t8Pl8yM7Oxvr16yGTyaBSqfDyyy+LihUiIiIiIiJamxiYUMKSy+V47LHHAABVVVWfeK3P50NrayssFguGhobEca1Wi/Xr1yMcDoueJAxLiIiIiIiIiIEJJbTq6urbuu6dd95Ba2srAEChUGDdunUwm80oLy9nQEJEREREREQLMDChVcdut8NqtaK+vh7Z2dkAgIaGBoyMjMBsNqO+vv6W23aIiIiIiIhobWNgQqtCMBjE5cuXYbFY0NXVJY49+uijAACj0YivfvWrcVwhERERERERJRIGJpSwJEnCwMAALBYLLl68CL/fL85VVFSgtLRU3OakGyIiIiIiIroTDEwoYUUiEfy///f/MDk5CQDIyMiAyWSCyWSCTqeL8+qIiIiIiIgokTEwoYSlUCiwadMmuFwumM1mlJaWspKEiIiIiIiIFgUDE0pou3btivcSiIiIiIiIaBXiPFUiIiIiIiIionkYmBARERERERERzcPAhIiIiIiIiIhoHgYmRERERERERETzMDAhIiIiIiIiIpqHgQkRERERERER0TwMTIiIiIiIiIiI5mFgQkREREREREQ0DwMTIiIiIiIiIqJ5GJgQEREREREREc3DwISIiIiIiIiIaB4GJkRERERERERE8zAwISIiIiIiIiKah4EJEREREREREdE8DEyIiIiIiIiIiOZhYEJERERERERENA8DEyIiIiIiIiKieRiYEBERERERERHNo4z3AmjlkyQJAOByueK8EiIiIiIiosQy8zpq5nUVJQ4GJnRLbrcbAFBcXBznlRARERERESUmt9sNnU4X72XQHZBJjLnoFiKRCAYGBpCeng6ZTHbHH79lyxacOXNm0dflcrlQXFyM3t5eaLXaRb9/ormW6vuYFlrrX+vV8vgT4XGslDXGax3L+Xn5XIBWg5XyM2MtWG1fa0mS4Ha7UVhYCLmcXTESCStM6JbkcjmKioru+uMVCsWSPonRarV8kkRLbqm/j2nWWv9ar5bHnwiPY6WsMV7rWM7Py+cCtBqslJ8Za8Fq/FqzsiQxMd6iJfeNb3wj3ksgumf8Pl4+a/1rvVoefyI8jpWyxnitYzk/70r5WhPdC34fLx9+rWml4JYcSlgulws6nQ5Op3PVJdBERER0a3wuQERES4kVJpSwNBoN/vZv/xYajSbeSyEiIqI44HMBIiJaSqwwISIiIiIiIiKahxUmRERERERERETzMDAhIiIiIiIiIpqHgQkRERERERER0TwMTIiIiIiIiIiI5mFgQqvW73//e9TU1KCqqgr//M//HO/lEBER0TJ76qmnkJmZic9+9rPxXgoRESUgTsmhVSkUCqG2thYffvghdDodGhsb8fHHHyMrKyveSyMiIqJlcvjwYbjdbvz85z/Hb37zm3gvh4iIEgwrTGhVOn36NOrq6mAwGJCWloa9e/fivffei/eyiIiIaBk99NBDSE9Pj/cyiIgoQTEwoRXpyJEjeOKJJ1BYWAiZTIa33nprwTU//vGPUVZWhqSkJDQ3N+P06dPi3MDAAAwGg7htMBjQ39+/HEsnIiKiRXCvzwWIiIjuFQMTWpG8Xi8aGhrw4x//+Ibn33jjDRw4cAB/+7d/i/Pnz6OhoQF79uzByMjIMq+UiIiIlgKfCxARUbwxMKEVae/evfhv/+2/4amnnrrh+R/84Ad48cUX8fzzz6O2thavv/46UlJS8JOf/AQAUFhYGFNR0t/fj8LCwmVZOxEREd27e30uQEREdK8YmFDCCQQCOHfuHHbv3i2OyeVy7N69GydOnAAANDU14eLFi+jv74fH48E777yDPXv2xGvJREREtIhu57kAERHRvVLGewFEd2psbAzhcBh5eXkxx/Py8nDlyhUAgFKpxP/4H/8DO3fuRCQSwd/8zd9wQg4REdEqcTvPBQBg9+7daGlpgdfrRVFREX7961/jvvvuW+7lEhFRgmJgQqvWpz/9aXz605+O9zKIiIgoTt5///14L4GIiBIYt+RQwsnOzoZCocDw8HDM8eHhYeTn58dpVURERLRc+FyAiIiWAwMTSjhqtRqNjY04dOiQOBaJRHDo0CGW2RIREa0BfC5ARETLgVtyaEXyeDxob28Xtzs7O2G1WqHX61FSUoIDBw5g//792Lx5M5qamvDaa6/B6/Xi+eefj+OqiYiIaLHwuQAREcWbTJIkKd6LIJrv8OHD2Llz54Lj+/fvx89+9jMAwI9+9CO8+uqrGBoagslkwj/8wz+gubl5mVdKRERES4HPBYiIKN4YmBARERERERERzcMeJkRERERERERE8zAwISIiIiIiIiKah4EJEREREREREdE8DEyIiIiIiIiIiOZhYEJERERERERENA8DEyIiIiIiIiKieRiYEBERERERERHNw8CEiIiIiIiIiGgeBiZERERERERERPMwMCEiIiIiIiIimoeBCRERERERERHRPAxMiIiIiIiIiIjmYWBCRERERERERDQPAxMiIiIiIiIionkYmBARERERERERzcPAhIiIiIiIiIhoHgYmRERERERERETzMDAhIiIiIiIiIpqHgQkRERERERER0TwMTIiIiIiIiIiI5mFgQkREREREREQ0DwMTIiIiIiIiIqJ5GJgQEREREREREc3DwISIiIiIiIiIaB4GJkRERERERERE8zAwISIiIiIiIiKah4EJEREREREREdE8DEyIiIiIiIiIiOZhYEJERERERERENA8DEyIiIiIiIiKieRiYEBERERERERHNw8CEiIiIiIiIiGgeBiZERERERERERPMwMCEiIiIiIiIimoeBCRERERERERHRPAxMiIiIiIiIiIjmYWBCRERERERERDQPAxMiIiIiIiIionkYmBARERERERERzcPAhIiIiIiIiIhoHgYmRERERERERETz/P8BXFYBTrXGEq8AAAAASUVORK5CYII=", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1, 1)\n", "ax.set_xscale('log')\n", "ax.set_yscale('log')\n", "for mode in modes:\n", " ax.plot(ps, flops[mode], label=mode)\n", "x = numpy.linspace(1, 32, 100)\n", "for p, style, offset in zip([5,7,9], ['-.','--',':'], [10, 3, 5]):\n", " ax.plot(x, numpy.power(x, p)*offset, label=r\"$p^{0}$\".format(p), color='grey', linestyle=style)\n", "ax.legend(loc='upper left');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, let's do the same analysis on a different problem: $a (u,v) = \\int_\\Omega\\left( \\nabla\\times u \\right) \\cdot \\left( \\nabla\\times v \\right)\\,\\text{d}x$, on the H(curl) conforming NCE element." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n", "/home/jack/Documents/firedrake/firedrake/src/ufl/ufl/utils/sorting.py:84: UserWarning: Applying str() to a metadata value of type TensorProductQuadratureRule, don't know if this is safe.\n", " warnings.warn(f\"Applying str() to a metadata value of type {type(value).__name__}, \"\n" ] } ], "source": [ "# This might take some time to run\n", "flops_curl = defaultdict(list)\n", "ps_curl = range(1, 17)\n", "for p in ps_curl:\n", " for mode in modes:\n", " element = FiniteElement('NCE', mesh.ufl_cell(), degree=p, variant=modes[mode]['variant'])\n", " V = FunctionSpace(mesh, element)\n", " u = TrialFunction(V)\n", " v = TestFunction(V)\n", " a = dot(curl(u), curl(v))*dx(scheme=modes[mode]['rule'](3, p))\n", " kernel, = compile_form(a, parameters={\"mode\": modes[mode]['mode']})\n", " flops_curl[mode].append(kernel.flop_count)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bc75081f970a4bff979f84c99f4c59ee", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(1, 1)\n", "ax.set_xscale('log')\n", "ax.set_yscale('log')\n", "for mode in modes:\n", " ax.plot(ps_curl, flops_curl[mode], label=mode)\n", "x = numpy.linspace(1, 16, 100)\n", "for p, style, offset in zip([5,7,9], ['-.','--',':'], [800,40,60]):\n", " ax.plot(x, numpy.power(x, p)*offset, label=r\"$p^{0}$\".format(p), color='grey', linestyle=style)\n", "ax.legend(loc='upper left');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\\[1\\] Homolya, M., Mitchell, L., Luporini, F. and Ham, D.A., 2018. TSFC: a structure-preserving form compiler. SIAM Journal on Scientific Computing, 40(3), pp.C401-C428.\n", "\n", "\\[2\\] Homolya, M., Kirby, R.C. and Ham, D.A., 2017. Exposing and exploiting structure: optimal code generation for high-order finite element methods. arXiv preprint arXiv:1711.02473.\n", "\n", "\\[3\\] Luporini, F., Ham, D.A. and Kelly, P.H., 2017. An algorithm for the optimization of finite element integration loops. ACM Transactions on Mathematical Software (TOMS), 44(1), p.3." ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 4 }