{ "cells": [ { "cell_type": "markdown", "id": "b61b67a1", "metadata": {}, "source": [ "# Eigen Decomposition\n", "\n", "[Eigen decomposition](https://en.wikipedia.org/wiki/Eigendecomposition_of_a_matrix), or spectral decomposition, factorizes a square symmetric matrix into its eigenvalues and eigenvectors, $X = Q \\Lambda Q^T$, where the columns of $Q$ are the eigenvectors and $\\Lambda$ is a diagonal matrix of corresponding eigenvalues. This tutorial looks at how to differentiate the eigenvectors $Q$ with respect to elements of the matrix $X$. We will make the technical assumption that all eigenvalues are simple otherwise well-defined derivatives do not exist.\n", "\n", "Given a real symmetric matrix $X = X^T \\in \\mathbb{R}^{m \\times m}$, it is well-known that a (unit) eigenvector associated with the largest eigenvalue of $X$ can be found by solving the following equality constrained optimization problem,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\begin{array}{ll}\n", "\t\t\\text{maximize (over $u \\in \\mathbb{R}^{m}$)} & u^T X u \\\\\n", "\t\t\\text{subject to} & u^T u = 1.\n", "\t\\end{array}\n", "\\end{align*}\n", "$$\n", "\n", "Since the objective function $f$ is a quadratic form we could equally write it as $f(X, u) = \\frac{1}{2} u^T (X + X^T) u$.\n", "\n", "The optimality conditions for a solution $y \\in \\mathbb{R}^m$ to the above optimization problem are:\n", "\n", "$$\n", "\\begin{align*}\n", "\tX y - \\lambda_{\\text{max}} y &= 0_{m} \\\\\n", "\ty^T y &= 1.\n", "\\end{align*}\n", "$$\n", "\n", "Indeed, any eigenvalue-eigenvector pair will also satisfy these conditions (replacing $\\lambda_{\\text{max}}$ with the appropriate eigenvalue). We can easily extend the above optimization problem to find all eigenvectors (and eigenvalues) of symmetric input matrix $X$ as,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\begin{array}{ll}\n", "\t\t\\text{maximize (over $U \\in \\mathbb{R}^{m \\times m}$)} & \\textbf{tr}(U^T X U) \\\\\n", "\t\t\\text{subject to} & U^T U = I_{m \\times m}.\n", "\t\\end{array}\n", "\\end{align*}\n", "$$\n", "\n", "Note also that the solution is not unique, even if all eigenvalues are simple (i.e., even if $X$ has $m$ distinct eigenvalues). Given a solution $Y$, negating and permuting columns is also a solution. We typically rely on the solver to sort eigenvectors in ascending or descending order corresponding to their eigenvalues. However, the sign ambiguity for each eigenvector is unavoidable." ] }, { "cell_type": "code", "execution_count": 1, "id": "75aafed8", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:30.909221Z", "start_time": "2023-10-31T22:22:29.414434Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.13.0\n", "No CUDA\n" ] } ], "source": [ "import torch\n", "print(torch.__version__)\n", "print(torch.cuda.get_device_name() if torch.cuda.is_available() else \"No CUDA\")\n", "\n", "torch.manual_seed(22)\n", "\n", "import sys\n", "sys.path.append(\"../\")" ] }, { "cell_type": "markdown", "id": "d344e9e7", "metadata": {}, "source": [ "### Forward Pass\n", "\n", "In the forward pass we can use PyTorch's ``torch.linalg.eigh`` function for computing all eigenvalues and eigenvectors of a symmetric matrix, which is equivalent to solving the optimisation problem above. This function can be directly back-propagated but we will develop a version that is as fast and empirically more stable using ideas from deep declarative networks. The following shows the forward pass code." ] }, { "cell_type": "code", "execution_count": 2, "id": "3b73abb4", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:30.940458Z", "start_time": "2023-10-31T22:22:30.916925Z" } }, "outputs": [], "source": [ "class EigenDecompositionFcn(torch.autograd.Function):\n", " \"\"\"PyTorch autograd function for eigen decomposition of real symmetric matrices.\n", " The input matrix is made symmetric within the forward evaluation function.\"\"\"\n", "\n", " eps = 1.0e-9 # tolerance to consider two eigenvalues equal\n", "\n", " @staticmethod\n", " def forward(ctx, X):\n", " B, M, N = X.shape\n", " assert N == M\n", "\n", " with torch.no_grad():\n", " lmd, Y = torch.linalg.eigh(0.5 * (X + X.transpose(1, 2)))\n", "\n", " ctx.save_for_backward(lmd, Y)\n", " return Y" ] }, { "cell_type": "markdown", "id": "0f933f11", "metadata": { "ExecuteTime": { "end_time": "2022-12-06T23:19:16.976852Z", "start_time": "2022-12-06T23:19:16.959158Z" } }, "source": [ "### Backward Pass\n", "\n", "Magnus (1985) gives the differentials as\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\text{d} \\lambda_{k} &= y_k^T (\\text{d} X) y_k \\\\\n", "\t\\text{d} y_k &= (\\lambda_{k} I - X)^{\\dagger} (\\text{d}{X}) y_k\n", "\\end{align*}\n", "$$\n", "\n", "for any simple eigenvalue $\\lambda_k$ and it's corresponding eigenvector $y_k$. Here $(\\lambda_{k} I - X)^{\\dagger}$ is the pseudo-inverse of $(\\lambda_{k} I - X)$, which will be singular since we are zeroing out one of the eigenvalues. So with respect to the $(i,j)$-th component of $X$ we have\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d} y_k}{\\text{d} X_{ij}} &= -\\frac{1}{2} (X - \\lambda_{k} I)^{\\dagger} (E_{ij} + E_{ji}) y_k\n", "\\end{align*}\n", "$$\n", "\n", "where we have used the fact that $X$ is symmetrical.\n", "\n", "To compute the gradient of the loss with respect to the $(i,j)$-th component of $X$ we need to sum over the contributions from all eigenvectors. Let $v_k^T = \\frac{\\text{d} L}{\\text{d} y_k} \\in \\mathbb{R}^{1 \\times m}$. Then,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d} L}{\\text{d} X_{ij}} &= \\sum_{k=1}^{m} v_k^T \\frac{\\text{d} y_k}{\\text{d} X_{ij}} \\\\\n", "\t&= -\\frac{1}{2} \\sum_{k=1}^{m} v_k^T (X - \\lambda_{k} I)^{\\dagger} (E_{ij} + E_{ji}) y_k\n", "\\end{align*}\n", "$$\n", "\n", "Naively implementing this expression by looping over the contribution from each eigenvector is painfully slow. We show an example of such code below." ] }, { "cell_type": "code", "execution_count": 3, "id": "f26d0fe7", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:30.971042Z", "start_time": "2023-10-31T22:22:30.948000Z" } }, "outputs": [], "source": [ "class EigenDecompositionFcn_v1(torch.autograd.Function):\n", " \"\"\"PyTorch autograd function for eigen decomposition of real symmetric matrices.\n", " The input matrix is made symmetric within the forward evaluation function.\"\"\"\n", "\n", " eps = 1.0e-9 # tolerance to consider two eigenvalues equal\n", " \n", " @staticmethod\n", " def backward(ctx, dJdY):\n", " X, lmd, Y = ctx.saved_tensors\n", " B, M, N = dJdY.shape\n", " assert M == N\n", " \n", " dJdX = torch.zeros_like(X)\n", "\n", " # loop over eigenvalues\n", " for i in range(K):\n", " L = torch.diag_embed(lmd[:, i].repeat(M, 1).transpose(0, 1))\n", " w = -0.5 * torch.bmm(torch.pinverse(X - L), dJdY[:, :, i].view(B, M, 1)).view(B, M)\n", " dJdX += torch.einsum(\"bi,bj->bij\", w, Y[:, :, i]) + torch.einsum(\"bj,bi->bij\", w, Y[:, :, i])\n", "\n", " return dJdX, None" ] }, { "cell_type": "markdown", "id": "029f60a1", "metadata": {}, "source": [ "### Faster Backwards Pass\n", "\n", "Recognising that $X$ can be decomposed as $Y \\Lambda Y^T$ for $Y = \\left[y_1 \\, y_2 \\, \\cdots\\, y_m\\right] \\in \\mathbb{R}^{m \\times m}$, which we obtain from the forward pass, we can write the gradient as\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d} L}{\\text{d} X_{ij}} &= \\sum_{k=1}^{m} v_k^T \\frac{\\text{d} y_k}{\\text{d} X_{ij}} \\\\\n", "\t&= -\\frac{1}{2} \\sum_{k=1}^{m} v_k^T Y (\\Lambda - \\lambda_{k} I)^{\\dagger} Y^T (E_{ij} + E_{ji}) y_k\n", "\\end{align*}\n", "$$\n", "\n", "and significantly speed up the various pseudo-inverse calculations in the backward pass." ] }, { "cell_type": "code", "execution_count": 4, "id": "90f4570a", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:31.001525Z", "start_time": "2023-10-31T22:22:30.977364Z" } }, "outputs": [], "source": [ "class EigenDecompositionFcn_v2(torch.autograd.Function):\n", " \"\"\"PyTorch autograd function for eigen decomposition of real symmetric matrices.\n", " The input matrix is made symmetric within the forward evaluation function.\"\"\"\n", "\n", " eps = 1.0e-9 # tolerance to consider two eigenvalues equal\n", "\n", " @staticmethod\n", " def backward(ctx, dJdY):\n", " lmd, Y = ctx.saved_tensors\n", " B, M, N = dJdY.shape\n", " assert M == N\n", "\n", " dJdX = torch.zeros_like(Y)\n", " zero = torch.zeros(1, dtype=lmd.dtype, device=lmd.device)\n", "\n", " # loop over eigenvalues\n", " for i in range(K):\n", " L = lmd - lmd[:, i].view(B, 1)\n", " L = torch.where(torch.abs(L) < EigenDecompositionFcn.eps, zero, 1.0 / L)\n", " w = -0.5 * torch.bmm(torch.bmm(Y, L.view(B, M, 1) * Y.transpose(1, 2)), dJdY[:, :, i].view(B, M, 1)).view(B, M)\n", " dJdX += torch.einsum(\"bi,bj->bij\", w, Y[:, :, i]) + torch.einsum(\"bj,bi->bij\", w, Y[:, :, i])\n", "\n", " return dJdX, None" ] }, { "cell_type": "markdown", "id": "607ae94d", "metadata": {}, "source": [ "### Even Faster Backwards Pass\n", "\n", "A even faster implementation is possible with some rearranging of terms to reuse and vectorize calculations. Considering only the term involving $E_{ij}$ and observing that $E_{ij} y_k = e_i e_j^T y_k = Y_{jk} e_i$, we have\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\sum_{k=1}^{m} v_k^T Y (\\Lambda - \\lambda_{k} I)^{\\dagger} Y^T E_{ij} y_k\n", "\t&= \\sum_{k=1}^{m} Y_{jk} v_k^T Y (\\Lambda - \\lambda_{k} I)^{\\dagger} Y^T e_i\n", "\t\\\\\n", "\t&= \\begin{bmatrix}\n", "\t\tY_{j1} & Y_{j2} & \\cdots & Y_{jm}\n", "\t\\end{bmatrix} \\begin{bmatrix} \n", "\t\tv_1^T Y (\\Lambda - \\lambda_{1} I)^{\\dagger} \\\\\n", "\t\tv_2^T Y (\\Lambda - \\lambda_{2} I)^{\\dagger} \\\\\n", "\t\t\\vdots \\\\\n", "\t\tv_m^T Y (\\Lambda - \\lambda_{m} I)^{\\dagger}\n", "\t\\end{bmatrix} Y^T e_i\n", "\t\\\\\n", "\t&= e_j^T Y \\begin{bmatrix} \n", "\t\tv_1^T Y (\\Lambda - \\lambda_{1} I)^{\\dagger} \\\\\n", "\t\tv_2^T Y (\\Lambda - \\lambda_{2} I)^{\\dagger} \\\\\n", "\t\t\\vdots \\\\\n", "\t\tv_m^T Y (\\Lambda - \\lambda_{m} I)^{\\dagger}\n", "\t\t\\end{bmatrix} Y^T e_i\n", "\t\\\\\n", "\t&= e_j^T Y \\left( \\begin{bmatrix}\n", "\t\t0 & \\frac{1}{\\lambda_2 - \\lambda_1} & \\cdots & \\frac{1}{\\lambda_m - \\lambda_1} \\\\\n", "\t\t\\frac{1}{\\lambda_1 - \\lambda_2} & 0 & \\cdots & \\frac{1}{\\lambda_m - \\lambda_2} \\\\\n", "\t\t\\vdots & \\vdots & \\ddots & \\vdots \\\\\n", "\t\t\\frac{1}{\\lambda_1 - \\lambda_m} & \\frac{1}{\\lambda_2 - \\lambda_m} & \\ldots & 0 \n", "\t \t\\end{bmatrix} \\odot \\begin{bmatrix} \n", "\t\tv_1^T Y \\\\\n", "\t\tv_2^T Y \\\\\n", "\t\t\\vdots \\\\\n", "\t\tv_m^T Y\n", "\t\\end{bmatrix} \\right) Y^T e_i\n", "\t\\\\\n", "\t&= e_j^T Y (\\tilde{\\Lambda} \\odot V^T Y) Y^T e_i\n", "\\end{align*}\n", "$$\n", "\n", "where $V = \\left[v_1 \\, v_2 \\, \\cdots \\, v_m \\right]$ and $\\tilde{\\Lambda}_{ij} = \\frac{1}{\\lambda_i - \\lambda_j}$ for $i \\neq j$ and zero otherwise. The second last line is because post-multiplying a row vector by a diagonal matrix results in scaling each element of the vector by the corresponding diagonal entry. Thus we can eliminate the explicit for-loop in our backward pass code." ] }, { "cell_type": "code", "execution_count": 5, "id": "13b46c83", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:31.017137Z", "start_time": "2023-10-31T22:22:31.005032Z" } }, "outputs": [], "source": [ "class EigenDecompositionFcn_v3(torch.autograd.Function):\n", " \"\"\"PyTorch autograd function for eigen decomposition of real symmetric matrices.\n", " The input matrix is made symmetric within the forward evaluation function.\"\"\"\n", "\n", " eps = 1.0e-9 # tolerance to consider two eigenvalues equal\n", "\n", " @staticmethod\n", " def backward(ctx, dJdY):\n", " lmd, Y = ctx.saved_tensors\n", " B, M, N = dJdY.shape\n", " assert M == N\n", " \n", " zero = torch.zeros(1, dtype=lmd.dtype, device=lmd.device)\n", "\n", " # do all eigenvalues in one go\n", " L = lmd.view(B, 1, M) - lmd.view(B, N, 1)\n", " L = torch.where(torch.abs(L) < EigenDecompositionFcn.eps, zero, 1.0 / L)\n", " w = torch.bmm(L * torch.bmm(dJdY.transpose(1, 2), Y), Y.transpose(1, 2))\n", "\n", " dJdX = torch.einsum(\"bik,bkj->bji\", Y, w)\n", " dJdX = -0.5 * (dJdX + dJdX.transpose(1, 2))\n", "\n", " return dJdX, None" ] }, { "cell_type": "markdown", "id": "33639454", "metadata": {}, "source": [ "### Yet Even Faster Backward Pass\n", "\n", "Continuing with some further algebraic manipulation we get\n", "\n", "$$\n", "\\begin{align*}\n", " e_j^T Y (\\tilde{\\Lambda} \\odot V^T Y) Y^T e_i\n", " &= e_i^T Y (\\tilde{\\Lambda}^T \\odot Y^T V) Y^T e_j \\\\\n", " &= \\left(Y (\\tilde{\\Lambda}^T \\odot Y^T V) Y^T \\right)_{ij} \\\\\n", " &= -\\left(Y (\\tilde{\\Lambda} \\odot Y^T V) Y^T \\right)_{ij}\n", "\\end{align*}\n", "$$\n", "\n", "Evident from this result is that we can efficiently compute derivatives with respect to all components of $X$ using a single expression, i.e.,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d} L}{\\text{d} X} &= \\frac{1}{2} \\left(Y (\\tilde{\\Lambda} \\odot Y^T V) Y^T \\right) + \\frac{1}{2} \\left(Y (\\tilde{\\Lambda} \\odot Y^T V) Y^T \\right)^T\n", "\\end{align*}\n", "$$\n", "\n", "The following code implements the full differentiable eigen decomposition PyTorch function with hand-coded backward pass. It is also available as ``EigenDecompositionFcn`` in the ``ddn.pytorch.eigen_decomposition`` module, which also allows for computing just the top-$k$ eigenvalues and corresponding eigenvectors." ] }, { "cell_type": "code", "execution_count": 6, "id": "055d12e5", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:31.047933Z", "start_time": "2023-10-31T22:22:31.020083Z" } }, "outputs": [], "source": [ "class EigenDecompositionFcn(torch.autograd.Function):\n", " \"\"\"PyTorch autograd function for eigen decomposition of real symmetric matrices.\n", " The input matrix is made symmetric within the forward evaluation function.\"\"\"\n", "\n", " eps = 1.0e-9 # tolerance to consider two eigenvalues equal\n", "\n", " @staticmethod\n", " def forward(ctx, X):\n", " B, M, N = X.shape\n", " assert N == M\n", "\n", " with torch.no_grad():\n", " lmd, Y = torch.linalg.eigh(0.5 * (X + X.transpose(1, 2)))\n", "\n", " ctx.save_for_backward(lmd, Y)\n", " return Y\n", "\n", " @staticmethod\n", " def backward(ctx, dJdY):\n", " lmd, Y = ctx.saved_tensors\n", " B, M, N = dJdY.shape\n", " assert N == M\n", " \n", " zero = torch.zeros(1, dtype=lmd.dtype, device=lmd.device)\n", " L = lmd.view(B, 1, N) - lmd.view(B, M, 1)\n", " L = torch.where(torch.abs(L) < EigenDecompositionFcn.eps, zero, 1.0 / L)\n", " dJdX = torch.bmm(torch.bmm(Y, L * torch.bmm(Y.transpose(1, 2), dJdY)), Y.transpose(1, 2))\n", "\n", " dJdX = 0.5 * (dJdX + dJdX.transpose(1, 2))\n", "\n", " return dJdX, None" ] }, { "cell_type": "markdown", "id": "36d1869b", "metadata": {}, "source": [ "### Profiling\n", "\n", "We profile the running time and memory required by the various implementations. All implementations use the same forward pass method, namely `torch.linalg.eigh`. We plot the speed of the backward pass code relative to the forward pass." ] }, { "cell_type": "code", "execution_count": 7, "id": "d45dbb3f", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:22:31.906390Z", "start_time": "2023-10-31T22:22:31.050932Z" } }, "outputs": [], "source": [ "import time, os, sys\n", "import numpy as np\n", "\n", "import matplotlib.pyplot as plt\n", "plt.rcParams.update({'font.size': 12})\n", "\n", "import torch\n", "\n", "torch.backends.cudnn.benchmark = False\n", "torch.backends.cudnn.deterministic = True\n", "torch.backends.cudnn.enabled = True\n", "\n", "import torch.autograd.profiler as profiler\n", "\n", "sys.path.append(\"..\")\n", "from ddn.pytorch.eigen_decomposition import EigenDecompositionFcn\n", "sys.path.append(\"../tests\")\n", "from testEigenDecomposition import EigenDecompositionFcn_eigh, EigenDecompositionFcn_v1, EigenDecompositionFcn_v2, EigenDecompositionFcn_v3, speed_memory_test\n", "\n", "\n", "def plot_profiling(device=torch.device(\"cpu\")):\n", " \"\"\"Speed and memory profiling.\"\"\"\n", " data = {}\n", " for f in [EigenDecompositionFcn,\n", " EigenDecompositionFcn_v1,\n", " EigenDecompositionFcn_v2,\n", " EigenDecompositionFcn_v3,\n", " EigenDecompositionFcn_eigh]:\n", "\n", " torch.cuda.empty_cache()\n", " time_fwd, time_bck, mem = speed_memory_test(lambda X: f.apply(X, None),\n", " (5 if device == torch.device('cpu') else 1000, 32),\n", " num_iter_speed=1000, num_iter_memory=5, device=device, dtype=torch.float32)\n", "\n", " print(f.__name__, time_fwd, time_bck, mem)\n", " data[f.__name__] = {'time_fwd': time_fwd, 'time_bck': time_bck, 'total_mem': mem}\n", "\n", " fig, ax = plt.subplots(1, 1)\n", " b = plt.bar(tuple(range(6)), [data['EigenDecompositionFcn']['time_fwd'],\n", " data['EigenDecompositionFcn_v1']['time_bck'],\n", " data['EigenDecompositionFcn_v2']['time_bck'],\n", " data['EigenDecompositionFcn_v3']['time_bck'],\n", " data['EigenDecompositionFcn']['time_bck'],\n", " data['EigenDecompositionFcn_eigh']['time_bck']],\n", " log=True, color=['r', 'b', 'b', 'b', 'b', 'g'])\n", " ax.set_xticks(range(6))\n", " ax.set_xticklabels(['fwd', 'bck (v1)', 'bck (v2)', 'bck (v3)', 'bck (final)', 'bck (eigh)'])\n", " \n", " # add counts above the two bar graphs\n", " for rect in b:\n", " height = rect.get_height()\n", " value = height / data['EigenDecompositionFcn']['time_fwd']\n", " plt.text(rect.get_x() + rect.get_width() / 2.0, height, f'{value:0.1f}x', ha='center', va='bottom')\n", "\n", " plt.ylabel('log time (ms)')\n", " plt.grid(True); plt.grid(True, which='minor', axis='y', ls='--')\n", " plt.tight_layout()\n", " plt.title(\"Differentiable eigen decomposition implementation comparison on {}\".format(device))" ] }, { "cell_type": "code", "execution_count": 8, "id": "514126b8", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:23:32.054801Z", "start_time": "2023-10-31T22:22:31.912127Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EigenDecompositionFcn 0.7057057046149675 0.30930931059954997 1.9325370788574219\n", "EigenDecompositionFcn_v1 0.6596596594116799 34.87687687658974 77.40751647949219\n", "EigenDecompositionFcn_v2 0.5005004998013094 10.463463463676018 24.186046600341797\n", "EigenDecompositionFcn_v3 0.5355355349855052 0.4224224226759957 2.2236547470092773\n", "EigenDecompositionFcn_eigh 0.595595595567628 0.32732732690967714 1.592463493347168\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuAAAAHnCAYAAAD5M+gsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACgGUlEQVR4nOzde3wTVf4//lcmSdOUXoBeFIQWAW1ZubR4BUQukqrtT1EUhYoKKCpyUREQXKVlxdVl3c+CtPvdZZEVRdoVr7vSYsNahV3Q4krFK6JAi+gi5dICTdNM5vz+wEySZgK9kRuv5+Pho/jOJDnvOTMn755O5uiEEAJERERERBQQUrAbQERERER0LmEBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAApoAT5y5EjodDqfuMPhwG9+8xtcfPHFMJlM0Ol0ePvtt9XHi4qKcMkllyAmJgY6nQ7Lli0LXKMDzN8+aq1evXqhV69eLd5+37590Ol0mDx5crvfu6MUFBRAp9Phgw8+CHZTzppzIcdQ9tJLL0Gn0+Gll15q1fN0Oh1Gjhx5VtrUFqF4/gLABx98AJ1Oh4KCgmA3JeJxLAl/PF/OLa0uwHU6ndd/JpMJycnJuPTSSzFt2jSUl5dDUZRWveYf//hH5Ofno1u3bpg7dy7y8/ORkZEBAHjttdcwc+ZMmEwmPPzww8jPz8dVV13V2maHjMmTJ0On02Hfvn3BbgoR+dHaX2CJmuvosb6tvywSUWgytPWJ+fn5AACn04ljx47hyy+/xMsvv4xVq1bhiiuuwKuvvoq+fft6Pefll19GQ0ODz2v94x//QGxsLKxWK6KionweA4B3330X3bt3b2tzw4a/fXQumjlzJiZMmIDU1NRgN4Ui1C233IKrrroK3bp1a9Xzvv76a8TExJylVrXeBRdcgK+//hoJCQnBbgoFCcfL8HfFFVfg66+/RlJSUrCbQgHQ5gJc608kBw8exKxZs7B+/XqMGTMGn3zyideB5G9g+PHHH5GYmOhTfLseA3BOFN+A/310LkpKSuJARGdVQkJCm4pW11/oQoXRaAy5NlFgcbwMfzExMTyPzyEdeg34eeedh5KSEowcORLV1dX47W9/6/V48+ubXX+i27t3L6qrq9XLWnr16qVez1ZRUQHA+9IXT9988w0mT56Mnj17wmQy4bzzzkNeXh527drl0z7X++3ZswfLli3DgAEDYDabva7lPHLkCBYuXIh+/frBbDYjISEB1157LcrLy31ez/NPghUVFRg5ciTi4uIQHx+PnJwcfPnll17b63Q6rFmzBgBw4YUXeuXrbx8BQFNTEwoLC5GTk4O0tDSYTCZ06dIF1157LTZs2HCaHgHq6uowc+ZMXHDBBYiOjsavfvUrvPDCCxBCnPZ5nhoaGvDss88iMzMTnTp1QmxsLIYMGYLi4uIWv4bLDz/8gJkzZ6J3794wmUxITEzETTfdhO3bt/tse7prGl999VUMHjwYZrMZKSkpuOuuu/Djjz+e9hr69957Dzk5OUhKSoLJZEKfPn0wb948HDt2zGdb1yUIDQ0NmDdvHlJTU2EymdC3b18899xzrdp/APDf//4X119/vXp8jBkzBlu3bj3tc1pzbAOn+ul3v/sdLrvsMsTFxSE2Nhb9+vXD7NmzcfDgQa9tf/zxRzz00EPo1asXoqKikJycjFtuuUWzHzyPc6vViuHDhyM2NhbJycmYMmWKuv8++eQT5OTkoEuXLoiNjcXYsWNRXV3t83quPrLb7XjyySdx4YUXqv2xePFiNDU1aeZntVpx3XXXoWvXroiOjsZFF12Exx9/XLP/vvvuO9x3333o06cPoqOj0aVLF/Tr1w8PPPAADh8+rJkb4L4Gs7q62mtMan59tb9rwI8dO4YFCxbg4osvVt83OzsbVqvVZ1vP6z2rqqqQm5uLzp07IyYmBtdccw3+85//aO4HLf6uAfccYwsLC3HJJZfAbDajV69e+O1vf6sexyUlJbj88ssRExODlJQUzJo1C42NjT7v48r7xx9/xF133YWUlBSYzWZceumlWLduXYvbC7R9rO2IY7A9799RY/1///tfPPzwwxg0aJDXMT1nzhwcOXLE6/VGjhyJKVOmAACmTJnidVy6LnE53XjZmnPHdX7Ksozf/va3uOiii2AymdCzZ0/MmzcPdrtdc3/6E8nj0ttvv41Jkybh4osvVj8bBw8ejGXLlsHpdPpsf6YaxN814C0dzwCgsbERzz77LAYMGICYmBjEx8dj+PDhKCkp8WmP57ixb98+TJgwAUlJSYiOjsall16qXoHQGuFwrHn2w//93/8hIyMD0dHR6NGjBx599FHU19f7vPbpvvfT5svNRCsBEGd62qZNmwQAkZKS4hUfMWKE13PfeustkZ+fLxISEkRCQoLIz88X+fn54o9//KOoqKgQ+fn5Ii0tTQBQH8vPz1efX1ZWJsxmszAajeKWW24R8+bNExMnThQmk0nEx8eL//73v17vf8899wgAIjc3VyQkJIi8vDwxf/58sXDhQiGEEPv27RO9evUSAMQ111wjHn30UTFt2jTRrVs3odPpxF/+8hev1/vb3/4mAIhbb71VGAwGceONN4q5c+eKnJwcAUAkJSWJn3/+Wd0+Pz9fDBo0SAAQDz/8sFe+/vaREEL89NNPQpIkcfXVV4t7771XLFiwQNxzzz2ic+fOAoBPu4QQIi0tTXTr1k1cdtllom/fvmLOnDli5syZolu3bgKAeOihh7y237t3rwAg7rnnHq/40aNHRVZWlgAgLr30UjFz5kzx0EMPiT59+ggA4te//rXPe/vz3//+VyQmJgqdTieuv/568dhjj4l77rlHJCQkiKioKLFhwwav7fPz8wUAUVFR4RVfunSpACC6dOkiHnjgATF//nyRlZUlevXqpe7f5hYvXiwAiMTERHH33XeLuXPniuzsbAFA/OpXvxLHjh3z2X/du3cXw4YNExdeeKG4//77xUMPPSS6d+8uAIhFixa1OO///Oc/wmw2C71eL8aPHy8WLlwobrjhBhEVFSWuv/56zRxbe2wfOXJEzT0jI0PMnj1bzJ07V9x8882iU6dOXq///fffq8fBtddeKxYsWCDuvPNOERUVJYxGo3j77be9Xtt1nN9yyy1qex577DExZMgQAUCMHDlSbNmyRURHR4vrrrtOPPbYY+K6665T963T6fR6PdcxftNNN4lu3bqJWbNmiTlz5qjH1P/3//1/QlEUr+cUFRUJnU4nYmNjxdSpU8Xjjz8urrjiCjXfI0eOqNseOHBAdOnSRRgMBnHTTTeJ+fPni9mzZ4sbb7xRxMTEiM8//9wnt7/97W9CiFPngdaYlJ+fL9566y31eQDEiBEjfPogIyNDABBXXHGFePzxx8W9994r4uLihE6nE0VFRV7bV1RUqOOR2WwWo0ePFo899pgYP368kCRJmEwm8dVXX/kcT1r8nb+uMW/cuHGia9eu4p577hEPP/ywuPDCCwUAUVBQIJ5//nlhNpvFxIkTxZw5c8TAgQMFAPHggw/6vA8AMXDgQPVcmz9/vrj//vvVsWjp0qWaOXqO20K0faztqGMwFMb6Bx54QKSkpIjx48eLOXPmiIcfflgMGzZMABDp6emivr7e6/3Hjh0rAIixY8d6HZdHjx5V31NrLGnNuSOE+/wcP368OP/888WUKVPEww8/LC666CIBQNx9990+x4U/kT4upaeni379+olJkyaJxx9/XDzwwAOib9++AoCYOHGiz/44Uw2idb60Zjyz2+1i+PDhao5z584VDz30kEhOThYAxPz5873a4xo3Ro4cKZKTk8WVV14pHnnkEXH33XcLk8kkdDqd2LRpU4v7O1yONVc/3HTTTaJz587i/vvvF/Pnz1eff+mllwqbzeb1+lpjfvPX27t3b4vbK4QQZ6UAb2xsFAaDwadBWsWlEKeKnbS0NM3X8vecI0eOiM6dO4ukpCTx9ddfez32xRdfiE6dOonMzEyvuGsnde/eXezZs0fzvXQ6nXjttde84kePHhWDBg0S0dHR4qefflLjrgFAr9f7HKQLFiwQAMRzzz2n2QZ/HaWVb2Njo9i/f7/mPujXr5/o0qWLaGho8HrM9YvLsGHDRGNjoxo/fPiw6N27twAgPvzwQzV+pg/w559/3itus9nEddddJ3Q6nfj00081c/HkcDhEnz59RHR0tNiyZYvXYwcOHBDdu3cX5513ntdBr/WB8v333wuDwSCSkpJETU2NGlcURUyYMEHz+Hz//ffVfdG80Hb14cMPP+wVd+2/G264wWvfHjx4UCQkJIj4+HjR1NR0xrwVRRHp6ekCgM8HyLJly9T2eubYlmN74sSJatHU/IOlvr5e/ZAWQgiLxaJ5bG7ZskVIkiS6dOni8+HvOs49jxmn0ynGjBkjAIiEhASxdu1ar9ebNm2aZt6uY/yiiy7yGpBtNpu46qqrBADx8ssvq/G9e/cKo9Eo4uPjxa5du7xe64EHHhAAxH333afGli9fLgB4FTsuJ06c8OrP5gW4y+nGJCG0B2NXvtOnT/eKf/PNNyIuLk4YjUavccf1YQtAvPTSS17P+fOf/+y3CNZypvM3LS1N/PDDD2r86NGjIjExUcTExIjExESvQt9ut4tLLrlEREVFiYMHD/rk7frA9DzO9uzZI7p06SKMRqP4/vvvfXJsXoC3Z6ztqGMw2GP9vn37hCzLPnFX3z/77LNecX/HqovWeNnac0cI9/k5ePBgcfjwYTV+4sQJ0adPHyFJkvjxxx8129BcJI9LQgjx3Xff+eTsdDrFnXfeKQCIbdu2eT12phpE63xpzXj2zDPPqL8sOBwONf6///1P9OzZUwDw+vx1jRuuX8Y9bdy4UQAQ119/vc/7agmnY83VD4mJiWLfvn1q3Ol0inHjxgkA4je/+Y3Xa4RNAS6EECkpKQKA+Pjjj9VYRxbgruKl+aySyyOPPCIAiC+++EKNuXaS1oFcVVWlfrBoefvttwUAUVhYqMZcA8CkSZN8tt+zZ486Y+KpLQX46Tz//PM+xbQQ7gJy8+bNPs9xtXvy5MlqTOsDvLa2Vuj1enH55Zdrvrdrn82dO/eM7XTtv3nz5mk+7urPd999V41pfaA8/fTTAoBYvHixz2vs27dP6PV6n/138803CwDiyy+/1HzvzMxMkZyc7BVz7T+tAfbuu+8WALxmHvz597//LYBTs2zNybKszq545tjaY/vgwYNCkiTRrVs3cfLkydO2Z//+/WpB5jlAu+Tl5QkAYs2aNWrMdbzcddddPtuvWbNGABDDhw/3eezDDz/UHNhdx3jzDzMh3B9AI0eOVGOuPtf6a8vhw4dFbGysiI6OVn/RfOGFFwSg/Zeh5jqqALfb7cJsNovY2FifWR4hhHjiiSd8jltXrldffbXP9k1NTcJgMIhLL730jDkIceYC/MUXX/R5zpQpUwQA8dRTT/k85vqL0QcffOAVdxU8WsWD63z17G+tgqI9Y21HHIOhMtb7oyiKiI+PF6NGjfKKt6UAb+25I4T7/NSa+Vy0aJEAIP75z3+eMY9IH5dO55NPPtH8nDpdDeL5Pp7nS2vGsz59+gidTudTAAshxMqVKwUAMWXKFDXmGjd69eql+ctgamqqSExMPOP7ChE+x5oQ7n5oXmQLcWqST5Ik0atXL6/42SjA2/wlzGDbtm0bAKCqqkrzC6HffvstgFPX0V5yySVej1155ZV+X+/YsWOar3fo0CH19Zq77LLLfGI9e/YEABw9evQ0WbTcl19+id///vfYvHkzfvrpJ5/rMw8cOODzHIPBgKFDh/rEXdcx7dix47TvuX37dvU6Nq194nA4AGjvk+Zc+3ffvn2ar7V79271tXJzc/2+jqvNV199tc9jaWlp6Nmzp891WNu2bYPRaMRrr72m+ZpNTU04dOgQDh8+jMTERDXeuXNn9OnTx2f71vTtp59+CgAYMWKEz2N6vR5XX301vv/+e5/2Ai0/trdv3w5FUXDNNdec8c4crv03fPhwGAy+p/+YMWOwbt06fPrpp7j77ru9Hrv00kt9tnd9Ofp0j/3www+abdHaJ652eR6brn+PGjXKZ/uuXbti8ODB2Lx5M77++mtkZmbipptuwhNPPIEZM2bAarXCYrFg2LBh+NWvftUh99jXsmvXLthsNlx99dXo0qWLz+NjxozBb3/7W/V48KQ1fhiNRpx33nkdNn50ZN+lpqbiwgsv9ImPHDkSixcvPuO40p6xtiPyCJWx3uFw4C9/+QtKSkrw1Vdfoa6uzusWvlpjemu19tzx1N5cI31cAoDDhw/j97//PUpLS7Fnzx6cPHnS63F/fahVg/jT0vHs+PHj+P7779GjRw9cfPHFPq8zZswYANAcgzIzM6HX633iPXv2VM+XMwmXY82TVl/37t1brSOOHTuGzp07t/j1WuusFOB2u139EklycvLZeAv1iwd//etfT7vdiRMnfGLnn3++39ezWq2aX5g63etp3UXBNYhofRGjtT766COMHj0asizj2muvxU033YT4+HhIkoSqqiq88847ml9WSEpK0jypXPnX1dWd9n1d+2T79u2aX4Jx0don/l5r/fr1p93uTK/lavN5552n+fh5553nU4AfPnwYsixj8eLFZ3xvzwLc390xWtO3Z2rv6Y7Flh7bri+3XHDBBS1uj9b7AlBvx6d1bJzuOD/dY65f1JrT2id6vR6JiYn4+eef29zmtLQ0VFZWoqCgABs3bsTrr78O4NSAPn/+fMycOVPzddqjo/crcGr/dcT44e892tp3ZzqWWzqudPRY29I8QmWsv+OOO/DWW2+hd+/eGDt2LM4//3yYTCYAwLJly1r9BTQtZ+t8b0mukT4uHTt2DJdffjn27t2LK664AnfffTe6du0Kg8GAY8eOYfny5X770F+eWlo6np2tMail67qEy7Hm6XRjWXV1Nerq6sKvAN+yZQtkWcZ5552nOVPSEVwd9tlnn2HgwIGteq7WLJjr9ZYvX47Zs2e3v4EdaMmSJbDZbOq37z09++yzeOeddzSfV1tbC6fT6VOE/+9//wPg/6RzcT3+6KOP4v/+7//a2Hrv13rnnXdw0003tfl14uPjAZy65WXzv2y44lrvrSiKz50FAsGVt1a7AHdfaD2npce2a4BoyYyZ67W13hcAfvrpJ6/tzqaDBw/63HbT6XTi8OHDaj97tuV///ufZp9rtblfv374+9//DlmW8dlnn2HTpk1YsWIFZs2ahU6dOql3lOgoobRfz7YzHcstHVeCNdYG+/2BU3fmeOutt3DttdeirKwMRqNRfUxRFCxdurRD3qct505HifRxadWqVdi7dy/y8/N9/pKybds2LF++3O97tPYvcS0Zz4K9D8PlWPN08OBBpKen+8S1xjLX3Vq0aN3hpSU6fCl6RVHwzDPPAADy8vI6+uVVrtUwt2zZEpKv54+rGG7NbMl3332Hrl27at4C58MPP/T7PFmWNW9157pNVVZW1mnf94orroAkSR2yTzpq/7ra/O9//9vnserqauzfv1/zvY8ePepzq7BAGDx4MADtfnI6nZp5tHZfefbTmRZx8tx/WoOJ67afrnafTVr7xPXLu+ex6fq31u3Vjh07hqqqKkRHR6Nfv34+jxsMBlx66aV4/PHH1dtmvvXWW2dsm16vb9U5mp6ejpiYGFRVVWn+yTSQ+/Vsq6mp0bzdVkvHlUCNtcF+/9ON9d999x0AYOzYsV7FNwBUVlbCZrO16vX8ac+5016RPi65+vDWW29t0Wt0hNONZ3FxcejTpw8OHDigXtLp6Wzvw3A51jxp9dOePXuwf/9+9OrVy2v2u0uXLpr1hdPpRFVVVVua3bEF+M8//4wJEybggw8+QGpqKp544omOfHkvU6ZMQefOnbF48WJUVlb6PK4oiuaB4M9ll12G4cOH480338Tq1as1t/n888+9/gTVFq5LHLQ60p9evXrhyJEj2Llzp1f8xRdfxHvvvXfa5y5cuNDrz2BHjhzBkiVLAOCMs4ApKSm488478cknn+Dpp5/WHBi///577N2794w5jB07Fn369EFRURFKS0s1t9m2bdsZT568vDwYDAasWLHCax8KIbBw4ULND6dHH30UADBt2jR1YSdPJ0+exEcffXTGHNpi6NChSE9Px+bNm33+UlFYWOhz/TfQ+mM7OTkZEyZMwI8//ojHH3/c5x7lJ06cUP/s16NHD1gsFuzbtw/Lli3z2u7jjz/GunXr0KVLF9xyyy1tzLjlnn76aa9itbGxEQsXLgTgfWxOmjQJRqMRK1asUD/0XJ566inU19dj0qRJ6p/vKysrNWdpXbHo6Ogzti0xMRGHDh3SvBe2lqioKNx55504ceIEFi1a5PXY999/jxdeeAFGoxF33XVXi14vlDmdTjz++ONef5reu3cvXnjhBRgMBkyaNOm0zw/UWBvs9z/dWO+6H3jzz6iff/4ZM2bMaPXr+dPac6cjRfq45OpDV2HrsmPHDjz77LMd1p7WjGdTp06FEALz5s3z+iysra3F008/rW5zNoTLseZp+fLlXveEVxQF8+bNg6IoPvXRlVdeiZqaGp91ApYsWeJ3rYEzafdKmIqiqEvR//vf/0ZTU5O6FP3ZXJUrMTERr7/+urqU9LXXXotLLrkEkiShpqYG27Ztw+HDh1v8AQoA69atw+jRo3HvvffihRdewJVXXonOnTvjhx9+wM6dO/HFF19g27ZtSElJaXO7r732Wvz+97/HtGnTcOuttyI2NhadO3c+7XWpjzzyCN577z1cffXVuP3225GQkIBPPvkE//73v3Hbbbep14Q1161bNzQ1NaF///646aab4HA48Prrr+Onn37CQw89hGuuueaM7S0sLMTu3buxaNEivPLKK7j66qtx3nnn4ccff8TXX3+N7du3o7i4+IyXGhmNRrz55pu47rrrkJubi6FDhyIzMxMxMTHYv38/tm/fjj179uCnn3467Zco+vTpg9/85jd44oknMGjQINxxxx1ISEiA1WrFkSNHMGjQIJ9fVK699lo899xzWLhwIS666CLk5OTgwgsvxIkTJ1BdXY0PP/wQV199NTZu3HjG/dFaOp0OL774IiwWC2699VaMGzcOffv2Vf+MeP311/u8b1uO7cLCQnzxxRcoLCzEv/71L2RnZyMqKgp79+7Fe++9h3/84x/qX1D+/Oc/Y9iwYZg3bx7Ky8tx2WWXYf/+/Vi/fj0kScLf/vY3xMXFdfi+aO5Xv/oVLrnkEtx2220wGo1455138P333yM3N9erUO3VqxeWLVuGGTNmYPDgwbj99tuRnJyMDz/8ENu2bUNGRgZ+97vfqduvW7cORUVFGDFiBPr27YsuXbrg+++/xz//+U+YTCY8/PDDZ2zbtddei+3bt+OGG27A8OHDERUVhUGDBuHGG2/0+5znnnsOW7ZsQWFhIbZv345Ro0ahtrYWr732Go4fP47CwsKzdkleIA0cOBCVlZW49NJLkZ2djbq6Ovz973/HsWPHsHTpUs0vLjcXiLE22O9/urH+8ssvx7Bhw/Dmm29i6NChuPrqq3Hw4EGUlZUhPT1dc+XnIUOGICYmBsuWLcPhw4fV61dnzZrl98/6rT13Olokj0t33303fv/73+PRRx/FBx98gIsuugi7d+/Gu+++i3HjxuHvf/97h7SnNePZ3LlzUVZWhnfeeQeDBg1CTk4OGhoasH79evz888+YP3++5g0MOkI4HWsuV199NTIzM9U64r333sNnn32GSy+9FPPnz/fadu7cuXjvvfcwduxY3HHHHejatSu2bt2KvXv3YuTIka2a8FW16p4pwn0bQtd/UVFRIjExUQwePFjcd999oqyszOcejC4deRtCl71794oZM2aIvn37CpPJJOLi4kR6erqYNGmS18IZQrTsVjH19fXimWeeEYMHDxadOnUS0dHRolevXiInJ0f85S9/ESdOnFC3PdNtoeDntjV/+MMfREZGhoiKilJvvXSmfP/5z3+KK6+8UsTGxoqEhARhsVjEhx9+eMbbqB07dkxdQCYqKkpkZGSI5cuX+ywo4O82ZkKcusXaihUrxJAhQ0R8fLyIiooSPXv2FKNHjxZ//OMfRW1trd/92dzBgwfF448/Li655BJhNptFp06dRN++fcWtt94qXnnlFa9bUPlbWEIIIV5++WWRmZkpTCaTSEpKEnfeeac4cOCAuOSSS0Tnzp0133vLli1i/Pjxolu3bsJoNIqkpCQxaNAg8eijj4rt27dr7j8tp2uXP5988om47rrrRGxsrIiNjRXXXnut2Lp162lfqzXHthCn7p26ZMkSMWDAAPWWeP369RMPP/ywz/2cf/jhB/Hggw+K1NRUYTQaRWJiohg7dqyorKz0ed3THef+7vPsar/WMeU6xhsbG8Wvf/1r0atXLxEVFSUuvPBCUVBQ4HWbKk/vvfeesFgsonPnziIqKkr06dNHzJs3z+v+rkII8dFHH4kHH3xQDBw4UHTp0kVER0eLPn36iMmTJ/vcOtJfbidOnBAPPviguOCCC9RbW3rm4e/cPnr0qJg/f77o27eviIqKEgkJCWLMmDHivffea9W+E+LMt0L0dKbbEGqNeac79vztF1feBw4cEHfeeadITk4WJpNJZGVliVdffbVVOXbUWNuWY7Aj399zvzR3urH+8OHDYvr06SItLU2YTCbRu3dvsXDhQnHy5Em/fV9WViauuuoq0alTJ/Uz2NW3p+vPlp47Qpz+M/dM+0FLJI9LX375pbjxxhtFcnKyiImJEYMHDxZ//etf23Q++mt3a8YzIU7dt/yZZ54Rl1xyiYiOjhaxsbFi2LBhYt26dS3eF833SWuEw7Hm6ofvv/9ePP/88yI9PV2YTCbRvXt38fDDD4u6ujrN1//HP/4hLr30UmEymUTXrl3FHXfcIfbt29fm2xDqhGg2V08Upurr63HeeechMzOzxbdOosAbOXIkPvzwQ58/E1Lo0+l0GDFiRNtme4hCGMelc8fkyZOxZs0a7N27V72UKBg6/EuYRGfboUOHfG4hJcsyHnvsMTQ2Nmp+KYaIiIgoVITtQjx07nrjjTewaNEijBkzBj179sSRI0ewefNmfPvttxg8ePBZuc8zERERUUdhAU5h58orr8SIESOwdetW/PzzzxBC4MILL8STTz6Jxx9/vEV3uSAiIiIKFl4DTkREREQUQLwGnIiIiIgogFiAExEREREFEK8BDyJFUfDjjz8iLi4OOp0u2M0hIiKic4AQAsePH0f37t0hSZyLDQYW4EH0448/omfPnsFuBhEREZ2D9u/fjx49egS7GeckFuBB5FpWd//+/YiPjw9ya84uh8OB8vJyZGdnw2g0Brs5EYH7tONxn54d3K8dj/u0451L+7S+vh49e/ZU6xAKPBbgQeS67CQ+Pv6cKMBjYmIQHx8f8QNboHCfdjzu07OD+7XjcZ92vHNxn/Ly1+DhhT9ERERERAHEApwoSFatWgWdTofY2FivuBACL7zwAjIyMmAymdCtWzdMnz4dR48ebfV72Gw2XHzxxdDpdHj++ec7qulERETUDizAiYLgwIEDmDt3Lrp37+7z2Ny5c/Hoo49i7NixePfdd7FgwQKsW7cOFosFDoejVe/z1FNP4eTJkx3VbCIiIuoALMCJguDBBx/ENddcA4vF4hU/cOAAli9fjhkzZuB3v/sdLBYLHn74Yfz5z3/Gf//7X7z00kstfo/KykqsWLECy5cv7+DWExERUXvwS5ghwOFwqDObkiRBr9fD6XRCURR1G1dclmUIIdS4Xq+HJEl+481nTA2GU10uy3KL4kajEYqiwOl0qjGdTgeDweA3rtV2z1wjJae29tPatWvx4Ycf4rPPPkNBQYHXfvn3v/8Np9OJG264AUIIte3XXXcdAOCNN97AfffdB1mW1ec4HA6fnJqamjB16lTMmDEDgwcPBgA4nU44HA7odDro9Xrk5OSgsrISlZWVSE1NhSRJsNvtuPzyy+F0OvHRRx+hU6dO51Q/ubZp3pZwzikU+sn1HrIsw2g0RkROzeOBzsm1TUtzDYecgt1PnmNqpOTkr59a+9dU6ngswIOgqKgIRUVF6olUXl6OmJgYAEBqaiqysrKwc+dO1NTUqM9JT09HRkYGKisrcejQITWemZmJtLQ0bN68GcePH1fjQ4YMQUpKCsrLy71O8FGjRsFsNqO0tNSrTTk5ObDZbKioqFBjBoMBubm5qK2txbZt29R4XFwcRo8ejf3796OqqkqNJycnY+jQodi9ezd27dqlxlNTU9G/f38AgNVqjZic2tJP77zzDmbPno2JEydi586dsNvtAKDmVFlZCeBUsSzLsppTU1MTdDoddu7ciePHj3vlVFFR4ZPTq6++isOHD+Ppp5/Gjh07AADffPMNSktL1ZwWLVqEG2+8ETk5Ofjtb3+L3r17Y/ny5dizZw+ee+45fPjhh+dcPw0YMAAAsHXrVpw4cSIicgqlfvr0008xbNiwiMopWP00fPhwAN5jarjnFCr9ZLVaIy4nwLufqqurQcGlE56/wlFA1dfXIyEhAbW1teptCCN1hkFRFJSWlsJisai3dwr3nNrST7feeit++uknfPDBB9DpdLjvvvvwxhtvqF+w/Oyzz3D55ZfjN7/5DZ588km17RUVFbjuuusQFRWFxsZGdQbDarXCYrEgJiZGbXtVVRWGDRuGt99+Gzk5OdizZw/69OmD5557DnPmzPHK6d///jfGjBmDhx56CAMHDsR9992HlStXYvLkyS3OKZL6SVEUbNy4EdnZ2Wq7wj2nUOgn17GanZ0Ns9kcETk1jwdjBrysrMxrTA33nILdT3a7XR1TTSZTROTkr5/q6uqQlJSEurq6iL8NcqjiDHgIMBqNPvcc1ev10Ov1Ptt6FgUtifu7l2lr4pIkaS5V6y+u1XbXIKCVa7jmdLq4VtvfeOMNvPvuu9ixYweioqIAuO/B6mrjZZddhmuuuQbPP/88MjIyYLFY8NVXX2HmzJnqAK/T6bxy8vyFRlEUPPDAA7jjjjuQk5Ojxl1t9XyeXq/HiBEj8Mwzz+Dxxx+HyWTCpEmTMG3aNJ+2+8vpdPFw7CfXh6fBYNBsTzjmdKZ4IHNytSGScnIJdE6uY1VrTNXa/nRtD5Wc2hLvyJxcr280GtVtwj0nf/10rtznPJTxS5hEAXDixAnMmDEDs2bNQvfu3XHs2DEcO3YMTU1NAIBjx46pdytZv349hg0bhttvvx1dunTBqFGjMG7cOGRmZuKCCy447fssW7YMe/bsQX5+vvoe9fX1AIDGxkYcO3bMawYFAO68805ERUXBbrdj3rx5ZyF7IiIi8sQCnCgAamtrcfDgQfzhD39Aly5d1P+Ki4tx8uRJdOnSBXfeeScAICUlBaWlpTh48CA+++wz/Pzzz/jNb36Db7/9Ftdcc81p3+eLL75AXV0dLrroIvU9Bg0aBODULQm7dOmCzz//XN3e6XTizjvvRJcuXZCamop7771X/aWAiIiIzg5egkIUAOeff77Xl21cXF92LCsrQ1JSktdjKSkpSElJAQC88MILOHnyJGbOnHna91mwYIHX9dsA8L///Q8TJ07Egw8+iDvuuAN9+/ZVH8vPz8eWLVtQXl6OTp064ZprrsG8efN460IiIqKziAU4UQBER0dj5MiRPvGXXnoJer3e67G//vWvAIA+ffrg2LFjKCsrw4svvojf/va36i0FXcaNG4cRI0bg/fffBwBkZGQgIyPDa5t9+/apr+f5PlarFc8++yyeeuopXHvttQCAZ599FnPnzsXIkSNxyy23tDNrIiIi0sICnCjECCGwbNkyVFdXQ5IkZGVl4a233sLYsWN9tm3+rfiW+umnnzBp0iSMHDkSixYtUuNz5szBhx9+iKlTpyIrKwu9evVqTypERESkgQU4URC99NJLPqtb3n///bj//vtb9HzXrQZPp1evXmh+t9Fu3brh4MGDPtvqdDr84x//aNF7ExERUdvwS5hERERERAHEApyIiIiIKIBYgBO1gU4X/P8SEk61JSEh+G0hIiKilmMBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCyBDsBhDgcDjgcDgAAJIkQa/Xw+l0QlEUdRtXXJZlCCHUuF6vhyRJfuOu13UxGE51uSzLLYobjUYoigKn06nGdDodDAaD37hW2z1zjYScoqIkNDXpERXlhF7vjjscEmRZD5NJhiQJj7gesiwhOlqGTueO2+16KIoEs9k7J7vdAEUBzGbvtttsBkgSYDLJ6nPMZgdsNiMkSYHJ5G67EDo0NhpgMCgwGt1xRdHBbjfAYHDCaHS33else04OR2j2U2vPJ9c2zdsSzjmFwvnkeg9ZlmE0GiMip+bxQOfk2qaluYZDTsHuJ1d7HA5HxOTkr5+at5MCjwV4EBQVFaGoqEg9kcrLyxETEwMASE1NRVZWFnbu3Imamhr1Oenp6cjIyEBlZSUOHTqkxjMzM5GWlobNmzfj+PHjanzIkCFISUlBeXm51wk+atQomM1mlJaWerUpJycHNpsNFRUVasxgMCA3Nxe1tbXYtm2bGo+Li8Po0aOxf/9+VFVVqfHk5GQMHToUu3fvxq5du9R4amoq+vfvDwCwWq0RkdO0aakoKsrCtGk7YbG4+6mkJB0lJRlYsKASWVnunAoLM7FpUxqWLt2M1FR3TgUFQ1BVlYIXXyxHTIw7p1mzRqG21oziYu+cJk7MQVKSDStWVHi8dgXy8nIxcGAtCgrcOdXUxGH27NEYOXI/Zs5057RjRzIWLx6K227bjQkT3DlZrW3PqbQ0NPuptefTgAEDAABbt27FiRMnIiKnUDqfPv30UwwbNiyicgpWPw0fPhyA95ga7jmFSj9ZrdaIywnw7qfq6mpQcOmE569wFFD19fVISEhAbW0t4uPjAUTuDIOiKCgtLYXFYoHRaAz7nGJjQ2MGfPVqK6ZOteDIkZigzoDX14dmP7VlBnzjxo3Izs5W2xXuOYXC+eRwOGC1WpGdnQ2z2RwROTWPB2MGvKyszGtMDfecgt1PdrsdVqsVFosFJpMpInLy1091dXVISkpCXV2dWn9QYHEGPAQYjUavARQ4dTLr9XqfbT2LgpbEm79uW+KSJHldRnKmuFbbXYOAVq7hmFNTk+unHoBvP9nt2m1vbNSO22zabdeKK4p33PVvRZFgs/m2XZYlyLJWXA9Z9m17W3LS2vWh0E9nijc/xlwfngaDQbM94ZjTmeKBzMnVhkjKySXQObmOVa0xVWv707U9VHJqS7wjc3K9vtFoVLcJ95z89ZO/9lDg8EuYREREREQBxAKciIiIiCiAWIATEREREQUQC3AiIiIiogBiAU5EREREFEAswImIiIiIAogFOBERERFRALEAJyIiIiIKIBbgREREREQBxAKciIiIiCiAWIATEREREQUQC3AiIiIiogBiAU5EREREFEAswImIiIiIAogFOBERERFRALEAJyIiIiIKIBbgREREREQBxAKciIiIiCiAWIATEREREQUQC3AiIiIiogBiAU5EREREFEAswImIiIiIAogFOBERERFRALEAJyIiIiIKIBbgREREREQBxAKciIiIiCiAWIATEREREQUQC3AiIiIiogBiAU5EREREFECGYDeAAIfDAYfDAQCQJAl6vR5OpxOKoqjbuOKyLEMIocb1ej0kSfIbd72ui8FwqstlWW5R3Gg0QlEUOJ1ONabT6WAwGPzGtdrumWsk5BQVJaGpSY+oKCf0enfc4ZAgy3qYTDIkSXjE9ZBlCdHRMnQ6d9xu10NRJJjN3jnZ7QYoCmA2e7fdZjNAkgCTSVafYzY7YLMZIUkKTCZ324XQobHRAINBgdHojiuKDna7AQaDE0aju+1OZ9tzcjhCs59aez65tmnelnDOKRTOJ9d7yLIMo9EYETk1jwc6J9c2Lc01HHIKdj+52uNwOCImJ3/91LydFHgswIOgqKgIRUVF6olUXl6OmJgYAEBqaiqysrKwc+dO1NTUqM9JT09HRkYGKisrcejQITWemZmJtLQ0bN68GcePH1fjQ4YMQUpKCsrLy71O8FGjRsFsNqO0tNSrTTk5ObDZbKioqFBjBoMBubm5qK2txbZt29R4XFwcRo8ejf3796OqqkqNJycnY+jQodi9ezd27dqlxlNTU9G/f38AgNVqjYicpk1LRVFRFqZN2wmLxd1PJSXpKCnJwIIFlcjKcudUWJiJTZvSsHTpZqSmunMqKBiCqqoUvPhiOWJi3DnNmjUKtbVmFBd75zRxYg6SkmxYsaLC47UrkJeXi4EDa1FQ4M6ppiYOs2ePxsiR+zFzpjunHTuSsXjxUNx2225MmODOyWpte06lpaHZT609nwYMGAAA2Lp1K06cOBEROYXS+fTpp59i2LBhEZVTsPpp+PDhALzH1HDPKVT6yWq1RlxOgHc/VVdXg4JLJzx/haOAqq+vR0JCAmpraxEfHw8gcmcYFEVBaWkpLBYLjEZj2OcUGxsaM+CrV1sxdaoFR47EBHUGvL4+NPupLTPgGzduRHZ2ttqucM8pFM4nh8MBq9WK7OxsmM3miMipeTwYM+BlZWVeY2q45xTsfrLb7bBarbBYLDCZTBGRk79+qqurQ1JSEurq6tT6gwKLM+AhwGg0eg2gwKmTWa/X+2zrWRS0JN78ddsSlyTJ6zKSM8W12u4aBLRyDcecmppcP/UAfPvJbtdue2Ojdtxm0267VlxRvOOufyuKBJvNt+2yLEGWteJ6yLJv29uSk9auD4V+OlO8+THm+vA0GAya7QnHnM4UD2ROrjZEUk4ugc7Jdaxqjala25+u7aGSU1viHZmT6/WNRqO6Tbjn5K+f/LWHAodfwiQiIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQCxACciIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQCxACciIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQCxACciIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQCxACciIiIiCiAW4EREREREAcQCnIiIiIgogFiAE1HYOn78OObPn4/s7GwkJydDp9OhoKDgtM8RQuCaa66BTqfDzJkzW/Q+drsdv//979G/f3906tQJ5513Hm644QZs3bq1A7IgIqJzDQtwIgpbhw8fxsqVK2G323HzzTe36DlFRUX47rvvWvU+06ZNw4IFC3DzzTfjn//8J4qKinDo0CGMGDEClZWVbWg5ERGdywzBbgARUVulpaXh6NGj0Ol0qK2txapVq067/b59+7Bw4UK8/PLLGDduXIvew263Y926dcjLy8OSJUvU+LBhw9C9e3e8+uqruOKKK9qVBxERnVs4A05EYUun00Gn07V4+/vvvx8WiwW33HJLi58jSRIkSUJCQoJXPD4+HpIkITo6GsCpS1tycnKQmJiImpoadbuGhgZccskl6NevH06ePNni9yUiosjFApyIzgmrVq1CZWUlCgsLW/U8o9GIhx56CGvWrMHbb7+N+vp67Nu3D9OmTUNCQgKmTZsG4NQvA6+88gpiYmJw++23w+FwAAAeeugh7N27F6+99ho6derU4XkREVH44SUoRBTxDhw4gLlz52Lp0qXo3r17q5//xz/+EQkJCbj11luhKAoAIDU1Fe+//z769u2rbpeYmIiSkhKMHDkS8+fPx8CBA7FmzRqsWrUKAwYM6LB8iIgovLEAJ6KI9+CDD2LQoEHqbHVrPfPMM3j++edRUFCA4cOHo76+HoWFhbBYLCgvL0dWVpa67bBhw/DMM8/g8ccfh8lkwqRJk3Dvvfd2VCpERBQBWIATUUR7/fXXsXHjRvz73/9GXV2d12NNTU04duwYOnXqBKPRqPn8r7/+GosWLcLSpUsxd+5cNX7DDTfgV7/6FebMmYOKigqv59x555146qmnYLfbMW/evI5PioiIwhqvASeiiPbFF19AlmVcddVV6NKli/ofAPz1r39Fly5dsGHDBr/P/+yzzyCEwOWXX+4VNxqNGDRoEL744guvuNPpxJ133okuXbogNTUV9957L5qamjo+MSIiClucASeiiDZ58mSMHDnSJz5q1CjcfPPNePjhh9G/f3+/z3ddM/7RRx9hxIgRatxut+PTTz9Fjx49vLbPz8/Hli1bUF5ejk6dOuGaa67BvHnzsHz58o5JiIiIwh4LcCIKa2VlZTh58iSOHz8OAPjqq6/w+uuvAwBycnLQq1cv9OrVS/O5F1xwgU9xPm7cOIwYMQLvv/8+AODqq6/G5ZdfjoKCAjQ0NOCaa65BXV0dVqxYgb179+KVV15Rn2u1WvHss8/iqaeewrXXXgsAePbZZzF37lyMHDmyVbc/JCKiyMVLUNrp//2//4fBgwfDaDSecQlsIup406dPx/jx4zF16lQAwPr16zF+/HiMHz8eP//8c6tfT1EUOJ1O9f8lSYLVasVjjz2G9evX46abbsL06dMBAKWlpZg0aRIA4KeffsKkSZMwcuRILFq0SH3+nDlzcOONN2Lq1KnYt29fOzIlIqJIwRnwdurWrRsWL16Ml19+OdhNITontbWoFUJoxt9++23k5OR4xRISErBkyRKvlTCb69atGw4ePOgT1+l0+Mc//tGmNhIRUWRiAd5ON998MwDgnXfeCW5DiIiIiCgsnFOXoBw/fhzz589HdnY2kpOTodPp/F42cuLECTzyyCPo3r07oqOjkZmZiZKSksA2mOgcotMF/z/XavMJCcFvCxERRa5zqgA/fPgwVq5cCbvdrs5c+zNu3DisWbMG+fn5KCsrw+WXX46JEydi3bp1gWksEREREUWkc+oSlLS0NBw9ehQ6nQ61tbVYtWqV5nalpaWwWq1Yt24dJk6cCODULcuqq6sxb9483HHHHdDr9YFsOhERERFFiHOqANe18O+6b731FmJjYzF+/Hiv+JQpU5CXl4ePP/4YQ4cObfX72+122O129f/r6+sBAA6HAw6Ho9WvF05c+UVKnmZzsFsAmM0Or5/B1BHdyn3qLUJOFQCRd/6HAu7Tjncu7dNzIcdQd04V4C31xRdfoF+/fjAYvHfPwIED1cddBbgsy5BlGU6nE7Iso7GxEUajUXOG/Nlnn8XixYt94uXl5YiJiTkLmYQeq9Ua7CZ0iOLiYLfAbfXq4O/T0tL2vwb3qbeO2KehJlLO/1DCfdrxzoV92tDQEOwmnPNYgGs4fPgwevfu7RPv2rWr+rjLkiVLvIrqZ555Bn/7298wefJkn+cvXLgQc+bMUf+/vr4ePXv2RHZ2NuLj4zswg9DjcDhgtVphsVhgNBqD3Zx2c31ZL5jMZgdWr7Zi6lQLbLbg7tO6uva/Bvept47Yp6Ei0s7/UMB92vHOpX3q+gs8BQ8LcD9Od7mK52MFBQUtXoDHZDLBZDL5xI1GY8Sf7C6RkqvNFuwWuNlsxqAXix3Rpdyn3iLgNPERKed/KOE+7Xjnwj6N9PzCwTl1F5SWSkxM9Jrldjly5AgA90w4EREREVFrsQDXMGDAAHz99deQZdkr/vnnnwMA+vfvH4xmEREREVEEYAGu4ZZbbsGJEyfwxhtveMXXrFmD7t2748orrwxSy4iIiIgo3J1z14CXlZXh5MmTOH78OADgq6++wuuvvw4AyMnJQUxMDG644QZYLBZMnz4d9fX16Nu3L4qLi7Fx40asXbuW9wAnIiIiojY75wrw6dOno7q6Wv3/9evXY/369QCAvXv3olevXgCAN998E7/+9a+xaNEiHDlyBBkZGSguLsaECRM6vE2e9wGXJAl6vR5OpxOKoqjbuOKyLEMIocb1ej0kSfIbb36vT9etFZtfXuMvbjQaoSgKnE6nGtPpdDAYDH7jWm33zDUScoqKktDUpEdUlBN6vTvucEiQZT1MJhmSJDziesiyhOhoGTqdO26366Eoks99p+12AxQFMJu9226zGSBJgMkke92z2mYzQpIUmEzutguhQ2OjAQaDAqPRHVcUHex2AwwGJ4xGd9udzrbn5HC0v598cw18Tq5tTCbvtrSnn9qakyz7P5/CbYxwvYcsyzAajRGRU/N4oHNybdPSXMMhp2D3k+d9wCMlJ3/9xPuAB59OeB5BFBBFRUUoKiqC0+nEt99+i3Xr1qn3AU9NTUVWVhZ27NiBmpoa9Tnp6enIyMjA1q1bcejQITWemZmJtLQ0vP/+++qsPgAMGTIEKSkp2LBhg9cJPmrUKJjNZpQ2u8lwTk4ObDYbKioq1JjBYEBubi5+/vlnbNu2TY3HxcVh9OjRqK6uRlVVlRpPTk7G0KFD8c0332DXrl1qPDU1Ff379/d5z3DOyWpNRVFRFmbM2AGLxd1PJSXpKCnJQH7+VmRluXMqLMzEpk1peOGF95Ga6s6poGAIqqpSsG7dBsTEuHOaNWsUamvNKC72zmnixBwkJdmwYoU7p4YGA/LycpGZ+TMKCtw51dTEYfbs0RgzphozZ7pz2rEjGYsXD8WECd9gwoSOz6kj+ilYOa1cOQD33/85fvghFj16nFDjwein051P4TpGJCUlYdiwYRGVU7D6afjw4diyZQuaC+ecIrGfQjWn6upq5OXloa6uLuJvgxyqWIAHUX19PRISElBbW6ueAJE6w6AoCkpLS73urxrOOcXGhsYMuOue1UeOxAR1Bry+vv391KlTaMyAr127EZMnZ8Nud/+BMBgz4PX1kTML6bq/cnZ2Nsxmc0Tk1DwejBnwsrIyn3tWh3NOwe4nu92u3gfcZDJFRE7++qmurg5JSUkswIPonLsEJRRp3XNUr9drXmvefHXOM8X93euzNXFJkrwuIzlTXKvtrkFAK9dwzKmpyfVTD8C3nzyLN0+Njdpxf/ec1oorinfc9W9FkWCz+bZdliXIslZcD1n2bXtbctLa9a3tJ+1cA5uTq8C22w2a7WlPP7njLcvJdfj7GwvCcYxwtSGScnIJdE6uQs/fPavDMae2xDsyJ9fre65mHe45+esn3gc8+HgXFCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHE2xCGAK6EGX45cSVMroR5Ks6VMLkSJlfCjJR+4kqYFEgswIPAcyVMACgvL/dZCXPnzp2aK1hVVlZqrsq1efNmzVW5ysvL270qV21treaqXPv379dclWv37t2aK2ECgNVqjYicpk07tcLitGk7NVdYXLCgUnPVyKVLN2uuhPnii+VtXmGxsLACeXm5GDiwVnOFxZEj92uuGnnbbbs1V41sS06lpe3vp+Ji31UjA53TypUDAABLlmzVXAmzPf3U2pwqK/2fT+E6Rnz66acYNmxYROV0unHvbOY0fPhwAN5jarjnFCr9ZLVaIy4nwLufqqurQcHFlTCDiCthhm9OXAmTK2GeinMlTK6EyZUwI6WfuBImBRJnwEMAV8IMv5y4EqYbV8LkSphcCZMrYZ6u7eHST1wJkwKJX8IkIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiPcBDwFcij78cuJS9FyK/lScS9FzKXouRR8p/cSl6CmQWIAHAZeiD/+cuBQ9l6IHuBQ9l6LnUvQdmVOo9BOXoqdA4FL0QcSl6MM3Jy5Fz6XoT8W5FD2XoudS9JHST1yKngKJM+AhgEvRh19OXIrejUvRcyl6LkXPpehP1/Zw6ScuRU+BxC9hEhEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAIo5L+EabPZ8L///Q82mw1JSUlISUkJdpOIiIiIiNosJAvwAwcO4K9//Ss2bNiAqqoqr9voJCYmYsSIEZg0aRJuvPFGzW8EExERERGFqpAqwH/66Sc88cQTePXVV9GpUycMHToUCxYsQEpKCqKjo3HkyBHs2bMHH330EW655RakpaXh2WefxYQJE4LddCIiIiKiFgmpAvziiy/GFVdcgZKSEtx4442nvU/lnj178Le//Q0zZszAgQMH8NhjjwWwpUREREREbRNSBfg777yD0aNHt2jb3r174+mnn8bcuXOxd+/es9yys8vhcKiLKkTqSmOeuUZCTlFRobESJnBq8ZhgrBrpmZPD0f5+8s01OCthAr4rWAZjJUxZjpzVCF3vIcsyjEZjROTUPB6MlTABtDjXcMgp2P3kao/D4YiYnPz1U/N2UuBxKfogKCoqQlFREZxOJ7799lusW7cOMTExAIDU1FRkZWVhx44dqKmpUZ+Tnp6OjIwMbN26FYcOHVLjmZmZSEtLw/vvv4/jx4+r8SFDhiAlJQUbNmzwOsFHjRoFs9mM0tJSrzbl5OTAZrOhoqJCjRkMBuTm5uLnn3/Gtm3b1HhcXBxGjx6N6upqVFVVqfHk5GQMHToU33zzDXbt2qXGU1NT0b9/f5/3DOecrNZUFBVlYcaMHbBY3P1UUpKOkpIM5OdvRVaWO6fCwkxs2pSGF154H6mp7pwKCoagqioF69ZtQEyMO6dZs0ahttaM4mLvnCZOzEFSkg0rVrhzamgwIC8vF5mZP6OgwJ1TTU0cZs8ejTFjqjFzpjunHTuSsXjxUEyY8A0mTOj4nDqin4KV08qVA3D//Z/jhx9i0aPHCTUejH463fkUrmNEUlIShg0bFlE5Baufhg8fji1btqC5cM4pEvspVHOqrq5GXl4el6IPorAqwPfv348vv/wSl19+ORITE4PdnHarr69HQkICamtr1RMgUmcYFEVBaWkpLBaLemlROOcUGxsaM+CrV1sxdaoFR47EBHUGvL6+/f3UqVNozICvXbsRkydney1TH4wZ8Pr6yJmFdDgcsFqtyM7OhtlsjoicmseDMQNeVlbmNaaGe07B7ie73Q6r1QqLxQKTyRQROfnrp7q6OiQlJbEAD6KQugTF05NPPomTJ0/ij3/8IwBg06ZNuPHGG9HU1ITOnTtj8+bNuOSSS4Lcyo5hNBp9rnfX6/XQ6/U+27pO2pbG/V1H35q4JEmad5vxF9dqu2sQ0Mo1HHNqanL91APw7SfP4s1TY6N23GbTbrtWXFG8465/K4oEm8237bIsQZa14nrIsm/b25KT1q5vbT9p5xrYnFwFtt1u0GxPe/rJHW9ZTq7D399YEI5jhKsNkZSTS6BzchV6WmOq1vana3uo5NSWeEfm5Hp9o9GobhPuOfnrp9N9x44CI2Tv4ffGG2/gV7/6lfr/Tz75JAYOHIi33noLaWlpWLJkSRBbR0RERETUNiE7A37gwAH07dsXAHD48GFs374dpaWluO6669DY2Mi7nhARERFRWArZGXAhhHrZwn/+8x/o9Xpcc801AIBu3bqhtrY2mM0jIiIiImqTkC3A+/Tpg3fffRcAUFJSgiuuuAJmsxnAqQV7unTpEszmERERERG1SchegvLAAw9gxowZePnll3Hs2DGsXr1afew///mP1/XhREREREThImQL8OnTp6NLly7YunUrrrjiCkyaNEl9zGazYfLkycFrHBERERFRG4VsAQ4AEyZMwIQJE3ziK1euDEJriIiIiIjaL2SvASciIiIiikQhOwPudDqxYsUKvPrqq6iurkZjY6PX4zqdDnV1dUFqHRERERFR24RsAb5gwQL84Q9/QGZmJiwWC6KiooLdJCIiIiKidgvZAvzVV1/FggUL8Nvf/jbYTSEiIiIi6jAhW4DbbDaMGTMm2M0ICIfDAYfDAQCQJAl6vR5Op1NdiMgzLssyhBBqXK/XQ5Ikv3HX67oYDKe6XJblFsWNRiMURYHT6VRjOp0OBoPBb1yr7Z65RkJOUVESmpr0iIpyQq93xx0OCbKsh8kkQ5KER1wPWZYQHS1Dp3PH7XY9FEWC2eydk91ugKIAZrN32202AyQJMJlk9TlmswM2mxGSpMBkcrddCB0aGw0wGBQYje64ouhgtxtgMDhhNLrb7nS2PSeHo/395Jtr4HNybWMyebelPf3U1pxk2f/5FG5jhOs9ZFmG0WiMiJyaxwOdk2ubluYaDjkFu59c7XE4HBGTk79+at5OCryQLcCzs7Px8ccfY/To0cFuSocrKipCUVGReiKVl5cjJiYGAJCamoqsrCzs3LkTNTU16nPS09ORkZGByspKHDp0SI1nZmYiLS0NmzdvxvHjx9X4kCFDkJKSgvLycq8TfNSoUTCbzSgtLfVqU05ODmw2GyoqKtSYwWBAbm4uamtrsW3bNjUeFxeH0aNHY//+/aiqqlLjycnJGDp0KHbv3o1du3ap8dTUVPTv3x8AYLVaIyKnadNSUVSUhWnTdsJicfdTSUk6SkoysGBBJbKy3DkVFmZi06Y0LF26Gamp7pwKCoagqioFL75YjpgYd06zZo1Cba0ZxcXeOU2cmIOkJBtWrKjweO0K5OXlYuDAWhQUuHOqqYnD7NmjMXLkfsyc6c5px45kLF48FLfdthsTJrhzslrbnlNpafv7qbjYnVNDgyEoOa1cOQAAsGTJVvTocUKNd0Q/tTanykr/51O4jhGffvophg0bFlE5nW7cO5s5DR8+HID3mBruOYVKP1mt1ojLCfDup+rqalBw6YTnr3Ah5ODBg8jNzcXdd9+NnJwcdO3a1WcbrVg4qa+vR0JCAmpraxEfHw8gcmcYFEVBaWkpLBYLjEZj2OcUGxsaM+CrV1sxdaoFR47EBHUGvL6+/f3UqVNozICvXbsRkydnw253z08EYwa8vj5yZiEdDgesViuys7NhNpsjIqfm8WDMgJeVlXmNqeGeU7D7yW63w2q1wmKxwGQyRURO/vqprq4OSUlJqKurU+sPCqyQnQGPj49Heno6Hn30UTz66KOa23geiOHMaDR6DaDAqZNZr9f7bOs6aVsab/66bYlLkuR1GcmZ4lptdw0CWrmGY05NTa6fegC+/eRZvHlqbNSO22zabdeKK4p33PVvRZFgs/m2XZYlyLJWXA9Z9m17W3LS2vWt7SftXAObk6vAttsNmu1pTz+54y3LyXX4+xsLwnGMcLUhknJyCXROrkJPa0zV2v50bQ+VnNoS78icXK9vNBrVbcI9J3/95K89FDghW4A/+OCDeO211zB27Fj069ePd0EhIiIioogQsgX422+/jWeffRZz584NdlOIiIiIiDpMyK6EaTQakZWVFexmEBERERF1qJAtwMeNG4f33nsv2M0gIiIiIupQIXsJysSJEzFt2jQ4HA7k5uZq3vFk8ODBQWgZEREREVHbhWwBfu211wIAli9fjhdeeMHrMSEEdDpdxNwFhYiIiIjOHSFbgP/tb38LdhOIiIiIiDpcyBbg99xzT7CbQERERETU4UL2S5hERERERJEopArwhx56CP/73/9a9Zw333wTr7766llqERERERFRxwqpAnzXrl3o3bs3Jk2ahPfeew8NDQ2a23333Xf4wx/+gP79++Pee+9Fly5dAtxSIiIiIqK2CalrwP/1r3/hnXfewbPPPosbbrgBBoMBF110EVJSUhAdHY0jR45gz549OHLkCDp16oTJkyfjySefREpKSrCbTkRERETUIiFVgAPA2LFjMXbsWOzYsQPvvvsuPvroI/z444+w2WxISkrC2LFjMXLkSIwdOxZxcXHBbi4RERERUauEXAHukpWVxaXoiYiIiCjihGwBfi5xOBxwOBwAAEmSoNfr4XQ6oSiKuo0rLssyhBBqXK/XQ5Ikv3HX67oYDKe6XJblFsWNRiMURfFa9Ein08FgMPiNa7XdM9dIyCkqSkJTkx5RUU7o9e64wyFBlvUwmWRIkvCI6yHLEqKjZeh07rjdroeiSDCbvXOy2w1QFMBs9m67zWaAJAEmk6w+x2x2wGYzQpIUmEzutguhQ2OjAQaDAqPRHVcUHex2AwwGJ4xGd9udzrbn5HC0v598cw18Tq5tTCbvtrSnn9qakyz7P5/CbYxwvYcsyzAajRGRU/N4oHNybdPSXMMhp2D3k6s9DocjYnLy10/N20mBxwI8CIqKilBUVKSeSOXl5YiJiQEApKamIisrCzt37kRNTY36nPT0dGRkZKCyshKHDh1S45mZmUhLS8PmzZtx/PhxNT5kyBCkpKSgvLzc6wQfNWoUzGYzSktLvdqUk5MDm82GiooKNWYwGJCbm4va2lps27ZNjcfFxWH06NHYv38/qqqq1HhycjKGDh2K3bt3Y9euXWo8NTUV/fv3BwBYrdaIyGnatFQUFWVh2rSdsFjc/VRSko6SkgwsWFCJrCx3ToWFmdi0KQ1Ll25Gaqo7p4KCIaiqSsGLL5YjJsad06xZo1Bba0ZxsXdOEyfmICnJhhUrKjxeuwJ5ebkYOLAWBQXunGpq4jB79miMHLkfM2e6c9qxIxmLFw/FbbftxoQJ7pys1rbnVFra/n4qLnbn1NBgCEpOK1cOAAAsWbIVPXqcUOMd0U+tzamy0v/5FK5jxKeffophw4ZFVE6nG/fOZk7Dhw8H4D2mhntOodJPVqs14nICvPupuroaFFw64fkrHAVUfX09EhISUFtbi/j4eACRO8OgKApKS0thsVhgNBrDPqfY2NCYAV+92oqpUy04ciQmqDPg9fXt76dOnUJjBnzt2o2YPDkbdrt7fiIYM+D19ZEzC+lwOGC1WpGdnQ2z2RwROTWPB2MGvKyszGtMDfecgt1PdrsdVqsVFosFJpMpInLy1091dXVISkpCXV2dWn9QYHEGPAQYjUavARQ4dTLr9XqfbV0nbUvjzV+3LXFJkrwuIzlTXKvtrkFAK9dwzKmpyfVTD8C3nzyLN0+Njdpxm0277VpxRfGOu/6tKBJsNt+2y7IEWdaK6yHLvm1vS05au761/aSda2BzchXYdrtBsz3t6Sd3vGU5uQ5/f2NBOI4RrjZEUk4ugc7JVehpjala25+u7aGSU1viHZmT6/WNRqO6Tbjn5K+f/LWHAiek7gNORERERBTpWIATEREREQVQyBfg7733HhYuXIhp06apXybYvn2715ciiIiIiIjCRcheA97Q0ICxY8fiX//6F3Q6HQBg+vTpSE1NxfPPP4+ePXvi+eefD3IriYiIiIhaJ2RnwH/961/jk08+wRtvvIG6ujqvbxtnZ2dj06ZNQWwdEREREVHbhOwM+Pr16/H000/jlltu8brtDnDqHpee97YkIiIiIgoXITsDfujQIVxyySWaj0mSBJvNFuAWERERERG1X8gW4BdccAE+//xzzcd27tyJCy+8MMAtIiIiIiJqv5AtwMeNG4dnnnkGO3bsUGM6nQ7V1dX44x//iPHjxwexdUREREREbROyBXh+fj66d++OK664Apdddhl0Oh2mTJmC/v37IyUlBQsWLAh2E4mIiIiIWi1kC/C4uDhs3boVTz/9NGJjY9GnTx/ExMRg4cKF2Lx5M8xmc7CbSERERETUaiF7FxQAMJvNWLBgAWe7iYiIiChihOwMOBERERFRJArpGfC3334br776Kqqrq9HY2Oj1mE6nw2effRaklhERERERtU3IFuC///3v8fjjjyM5ORl9+/ZFp06dgt0kIiIiIqJ2C9kC/E9/+hOmTp2Kv/zlL9Dr9cFuDhERERFRhwjZa8APHz6MvLw8Ft9EREREFFFCtgAfNmwYvv7662A3g4iIiIioQ4XsJSjLli3DLbfcgp49e+L6669HVFRUsJtERERERNRuIVuA9+3bF2PGjMEtt9wCnU6HmJgYr8d1Oh3q6uqC1LqO5XA44HA4AACSJEGv18PpdEJRFHUbV1yWZQgh1Lher4ckSX7jrtd1MRhOdbksyy2KG41GKIoCp9OpxnQ6HQwGg9+4Vts9c42EnKKiJDQ16REV5YRe7447HBJkWQ+TSYYkCY+4HrIsITpahk7njtvteiiKBLPZOye73QBFAcxm77bbbAZIEmAyyepzzGYHbDYjJEmByeRuuxA6NDYaYDAoMBrdcUXRwW43wGBwwmh0t93pbHtODkf7+8k318Dn5NrGZPJuS3v6qa05ybL/8yncxgjXe8iyDKPRGBE5NY8HOifXNi3NNRxyCnY/udrjcDgiJid//dS8nRR4IVuAz58/H4WFhcjMzES/fv0iaga8qKgIRUVF6olUXl6u/oKRmpqKrKws7Ny5EzU1Nepz0tPTkZGRgcrKShw6dEiNZ2ZmIi0tDZs3b8bx48fV+JAhQ5CSkoLy8nKvE3zUqFEwm80oLS31alNOTg5sNhsqKirUmMFgQG5uLmpra7Ft2zY1HhcXh9GjR2P//v2oqqpS48nJyRg6dCh2796NXbt2qfHU1FT0798fAGC1WiMip2nTUlFUlIVp03bCYnH3U0lJOkpKMrBgQSWystw5FRZmYtOmNCxduhmpqe6cCgqGoKoqBS++WI6YGHdOs2aNQm2tGcXF3jlNnJiDpCQbVqyo8HjtCuTl5WLgwFoUFLhzqqmJw+zZozFy5H7MnOnOaceOZCxePBS33bYbEya4c7Ja255TaWn7+6m42J1TQ4MhKDmtXDkAALBkyVb06HFCjXdEP7U2p8pK/+dTuI4Rn376KYYNGxZROZ1u3DubOQ0fPhyA95ga7jmFSj9ZrdaIywnw7qfq6mpQcOmE569wISQxMRH3338/nn322WA35aypr69HQkICamtrER8fDyByZxgURUFpaSksFguMRmPY5xQbGxoz4KtXWzF1qgVHjsQEdQa8vr79/dSpU2jMgK9duxGTJ2fDbnfPTwRjBry+PnJmIR0OB6xWK7Kzs2E2myMip+bxYMyAl5WVeY2p4Z5TsPvJbrfDarXCYrHAZDJFRE7++qmurg5JSUmoq6tT6w8KrJCdAXc6nbBYLMFuRkAYjUavARQ4dTJr3QHGddK2NN78ddsSlyTJ6zKSM8W12u4aBLRyDcecmppcP/UAfPvJs3jz1NioHbfZtNuuFVcU77jr34oiwWbzbbssS5Blrbgesuzb9rbkpLXrW9tP2rkGNidXgW23GzTb055+csdblpPr8Pc3FoTjGOFqQyTl5BLonFyFntaYqrX96doeKjm1Jd6ROble32g0qtuEe07++slfeyhwQvYuKNnZ2fjoo4+C3QwiIiIiog4VsjPgTz31FO644w506tQJubm56Nq1q882WjEiIiIiolAWsgX4oEGDAABz5szBnDlzNLfxvBaKiIiIiCgchGwBvmjRIuh0umA3g4iIiIioQ4VsAV5QUBDsJhARERERdbiQ/RImEREREVEkCqkZ8Jdffhm5ublITEzEyy+/fMbt77777gC0ioiIiIio44RUAT558mR89NFHSExMxOTJk0+7rU6nYwFORERERGEnpArwvXv3olu3buq/iYiIiIgiTUgV4GlpaZr/JiIiIiKKFCH7JczevXvjs88+03zsiy++QO/evQPcIiIiIiKi9gvZAnzfvn2w2+2ajzU2NqK6ujrALSIiIiIiar+QLcAB+F2IZ8+ePYiLiwtwa4iIiIiI2i+krgFfs2YN1qxZo/7/9OnTER8f77WNzWbDZ599hhEjRgS6eURERERE7RZSBXhDQwMOHToE4NTs97Fjx3wuQzGZTLjjjjuwePHiYDSRiIiIiKhdQqoAnz59OqZPnw4AuPDCC/HGG29g0KBBQW4VEREREVHHCakC3BPvA05EREREkSikv4RJRERERBRpWIATEREREQUQC3AiIiIiogBiAU5EREREFEAswImIiIiIAogFOBERERFRAIXsbQgvvPBCv0vRS5KEzp074/LLL8fs2bPRr1+/ALeOiIiIiKhtQnYGfMSIERBC4MCBA+jVqxeuvPJKpKWl4cCBA3A6nejZsyfefPNNXHbZZfjkk0+C3VwiIiIiohYJ2QL8uuuug8lkwnfffYf3338fxcXFqKiowO7du2EymXDzzTfj22+/xcUXX4z8/PxgN5eIiIiIqEVCtgB/5plnUFBQgJ49e3rFU1NTsWjRIjz33HNISEjAo48+im3btgWplURERERErROyBfh3332HhIQEzce6dOmCffv2AQB69eqFhoaGALaMiIiIiKjtQrYAT0tLw0svvaT52OrVq5GamgoAOHz4MLp27RrAlhERERERtV3I3gVl7ty5eOCBB/DDDz9g/PjxOO+883Dw4EG89tpr+Pjjj7Fy5UoAQEVFBS677LIgt7Z9HA4HHA4HgFN3eNHr9XA6nVAURd3GFZdlGUIINa7X6yFJkt+463VdDIZTXS7LcoviRqMRiqLA6XSqMZ1OB4PB4Deu1XbPXCMhp6goCU1NekRFOaHXu+MOhwRZ1sNkkiFJwiOuhyxLiI6WodO543a7HooiwWz2zsluN0BRALPZu+02mwGSBJhMsvocs9kBm80ISVJgMrnbLoQOjY0GGAwKjEZ3XFF0sNsNMBicMBrdbXc6256Tw9H+fvLNNfA5ubYxmbzb0p5+amtOsuz/fAq3McL1HrIsw2g0RkROzeOBzsm1TUtzDYecgt1PrvY4HI6IyclfPzVvJwWeTngeQSFm5cqVKCgowP/+9z81dv7552Px4sWYNm0aAODgwYMwmUzo3LlzkFrZekVFRSgqKoLT6cS3336LdevWISYmBsCpa9yzsrKwY8cO1NTUqM9JT09HRkYGtm7dikOHDqnxzMxMpKWl4f3338fx48fV+JAhQ5CSkoINGzZ4neCjRo2C2WxGaWmpV5tycnJgs9lQUVGhxgwGA3Jzc/Hzzz97XWcfFxeH0aNHo7q6GlVVVWo8OTkZQ4cOxTfffINdu3ap8dTUVPTv39/nPcM5J6s1FUVFWZgxYwcsFnc/lZSko6QkA/n5W5GV5c6psDATmzal4YUX3kdqqjungoIhqKpKwbp1GxAT485p1qxRqK01o7jYO6eJE3OQlGTDihXunBoaDMjLy0Vm5s8oKHDnVFMTh9mzR2PMmGrMnOnOaceOZCxePBQTJnyDCRM6PqeO6Kdg5bRy5QDcf//n+OGHWPTocUKNB6OfTnc+hesYkZSUhGHDhkVUTsHqp+HDh2PLli1oLpxzisR+CtWcqqurkZeXh7q6OsTHx4MCL6QLcODUb/m7du3C4cOHkZiYiPT0dL/3Bw839fX1SEhIQG1trXoCROoMg6IoKC0thcVigdFoDPucYmNDYwZ89Worpk614MiRmKDOgNfXt7+fOnUKjRnwtWs3YvLkbNjt7j8QBmMGvL4+cmYhHQ4HrFYrsrOzYTabIyKn5vFgzICXlZV5janhnlOw+8lut8NqtcJiscBkMkVETv76qa6uDklJSSzAgyhkL0Fx0el0yMjICHYzziqj0eg1gAKnTma9Xu+zreukbWm8+eu2JS5JktdlJGeKa7XdNQho5RqOOTU1uX7qAfj2k2fx5qmxUTtus2m3XSuuKN5x178VRYLN5tt2WZYgy1pxPWTZt+1tyUlr17e2n7RzDWxOrgLbbjdotqc9/eSOtywn1+HvbywIxzHC1YZIyskl0Dm5Cj2tMVVr+9O1PVRyaku8I3Nyvb7RaFS3Cfec/PWTv/ZQ4ITslzAB4Pvvv8ddd92F7t27w2Qy4YILLsA999yD77//PthNIyIiIiJqk5CdAf/mm28wZMgQNDY2YvTo0ejevTt+/PFHvPbaa3j33Xfxn//8J+JnxomIiIgo8oRsAf7EE08gMTERH3zwAXr06KHGf/jhB4wePRq//vWv8cYbbwSxhURERERErReyl6B8+OGHWLx4sVfxDQA9evTAokWLvL45TEREREQULkK2AG9oaEBiYqLmY0lJSbDZbAFuERERERFR+4VsAZ6eno5XX31V87Hi4mJe/01EREREYSlkrwGfPXs27rvvPtTV1eGee+5Bt27d8NNPP2Ht2rX4xz/+gVWrVgW7iURERERErRayBfjUqVNx8OBBLFmyBBs2bABwauEBs9mMZ555BlOmTAlyC4mIiIiIWi9kC3AAWLhwIR566CFs27ZNXQlzyJAhSEhICHbTiIiIiIjaJKQLcABISEjA9ddfH+xmEBERERF1iJAqwGtqalq1fWpq6llqCRERERHR2RFSBXivXr2g0+lavL3T6TyLrSEiIiIi6nghVYCvXr26VQU4EREREVG4CakCfPLkycFuAhERERHRWRWyC/EQEREREUUiFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQBvh0OHDiE3NxedOnXCxRdfDKvVGuwmEREREVGIMwS7AeFsxowZOP/883Ho0CFs2rQJt99+O7777jskJiYGu2lEREREFKI4A95GJ06cwNtvv42CggLExMTgpptuwqBBg/DOO+8Eu2lEREREFMLOmQL8+PHjmD9/PrKzs5GcnAydToeCggLNbU+cOIFHHnkE3bt3R3R0NDIzM1FSUuK1ze7duxEbG4uePXuqsQEDBuDLL788m2kQERERUZg7Zwrww4cPY+XKlbDb7bj55ptPu+24ceOwZs0a5Ofno6ysDJdffjkmTpyIdevWqducOHEC8fHxXs+Lj4/HiRMnzkbziYiIiChCnDPXgKelpeHo0aPQ6XSora3FqlWrNLcrLS2F1WrFunXrMHHiRADAqFGjUF1djXnz5uGOO+6AXq9HbGws6uvrvZ5bX1+P2NjYs54LEREREYWvc6YA1+l0LdrurbfeQmxsLMaPH+8VnzJlCvLy8vDxxx9j6NChuOiii3DixAn88MMP6NGjBwDgiy++wF133eX3te12O+x2u/r/rgLe4XDA4XC0NqWw4sovUvI0m4PdAsBsdnj9DKaO6FbuU28RcqoAiLzzPxRwn3a8c2mfngs5hjqdEEIEuxGBVltbi+TkZOTn5/tcBz5kyBA4nU5UVlZ6xb/88kv0798ff/nLX3D//fcDAMaPH4+EhASsWLEC//rXv3DXXXdh9+7dSEpK0nzfgoICLF682Ce+bt06xMTEdExyRERERKfR0NCAvLw81NXV+VxOS4FxzsyAt9Thw4fRu3dvn3jXrl3Vx13+9Kc/4Z577kFiYiIuuOAC/P3vf/dbfAPAwoULMWfOHPX/6+vr0bNnT2RnZ0f8CeBwOGC1WmGxWGA0GoPdnHZLSAh2C07N0q5ebcXUqRbYbMHdp3V17X8N7lNvHbFPQ0Wknf+hgPu0451L+7T5JbQUeCzANZzuchXPx5KTk1FaWtri1zWZTDCZTD5xo9EY8Se7S6TkarMFuwVuNpsx6MViR3Qp96m3CDhNfETK+R9KuE873rmwTyM9v3BwztwFpaUSExO9Zrldjhw5AsA9E05ERERE1BYswJsZMGAAvv76a8iy7BX//PPPAQD9+/cPRrOIiIiIKEKwAG/mlltuwYkTJ/DGG294xdesWYPu3bvjyiuvDFLLiIiIiCgSnFPXgJeVleHkyZM4fvw4AOCrr77C66+/DgDIyclBTEwMbrjhBlgsFkyfPh319fXo27cviouLsXHjRqxduxZ6vT6YKRARERFRmDunCvDp06ejurpa/f/169dj/fr1AIC9e/eiV69eAIA333wTv/71r7Fo0SIcOXIEGRkZKC4uxoQJE85KuzzvAy5JEvR6PZxOJxRFUbdxxWVZhuedI/V6PSRJ8htvfq9Pg+FUlze/xMZf3Gg0QlEUOJ1ONabT6WAwGPzGtdrumWsk5BQVJaGpSY+oKCf0enfc4ZAgy3qYTDIkSXjE9ZBlCdHRMnQ6d9xu10NRJJ/7TtvtBigKYDZ7t91mM0CSAJNJ9rpntc1mhCQpMJncbRdCh8ZGAwwGBUajO64oOtjtBhgMThiN7rY7nW3PyeFofz/55hr4nFzbmEzebWlPP7U1J1n2fz6F2xjheg9ZlmE0GiMip+bxQOfk2qaluYZDTsHuJ8/7gEdKTv76ifcBD75z8j7gwVZUVISioiI4nU58++23XvcBT01NRVZWFnbs2IGamhr1Oenp6cjIyMDWrVtx6NAhNZ6ZmYm0tDS8//776sw+cOp+5ikpKdiwYYPXCT5q1CiYzWafu7fk5OTAZrOhoqJCjRkMBuTm5uLnn3/Gtm3b1HhcXBxGjx6N6upqVFVVqfHk5GQMHToU33zzDXbt2qXGU1NT0b9/f5/3DOecrNZUFBVlYcaMHbBY3P1UUpKOkpIM5OdvRVaWO6fCwkxs2pSGF154H6mp7pwKCoagqioF69ZtQEyMO6dZs0ahttaM4mLvnCZOzEFSkg0rVrhzamgwIC8vF5mZP6OgwJ1TTU0cZs8ejTFjqjFzpjunHTuSsXjxUEyY8A0mTOj4nDqin4KV08qVA3D//Z/jhx9i0aPHCTUejH463fkUrmNEUlIShg0bFlE5Baufhg8fji1btqC5cM4pEvspVHOqrq7mfcCDjAV4ENXX1yMhIQG1tbXqCRCpMwyKoqC0tNTr/qrhnFNsbGjMgLvuWX3kSExQZ8Dr69vfT506hcYM+Nq1GzF5cjbsdvcfCIMxA15fHzmzkK77K2dnZ8NsNkdETs3jwZgBLysr87lndTjnFOx+stvt6n3ATSZTROTkr5/q6uqQlJTEAjyIzqlLUEKV1j1H9Xq95vXmrpO2pXF/9/psTVySJK/LSM4U12q7axDQyjUcc2pqcv3UA/DtJ8/izVNjo3bc3z2nteKK4h13/VtRJNhsvm2XZQmyrBXXQ5Z9296WnLR2fWv7STvXwObkKrDtdoNme9rTT+54y3JyHf7+xoJwHCNcbYiknFwCnZOr0PN3z+pwzKkt8Y7MyfX6RqNR3Sbcc/LXT7wPePDxLihERERERAHEApyIiIiIKIBYgFOLHT9+HPPnz0d2djaSk5Oh0+lQUFDQ4ucfO3YM9957L5KSkhATE4MhQ4bgX//619lrMBEREVEIYgFOLXb48GGsXLkSdrsdN998c6uea7fbsWjRIlRUVGD58uV45513cN555+H666/Hhx9+eHYaTERERBSC+CVMarG0tDQcPXoUOp0OtbW1WLVqVYuf+7e//Q01NTXYvHkzhg8fDuDU7ZkGDRqE+fPn4+OPPz5bzSYiIiIKKZwBpxbT6XTQ6XRteu4777yDCy64AFdddZUaMxgMmDRpEiorK3HgwAEAQElJCXQ6HQoLC72en5+fD71eD6vV2vYEiIiIiEIAZ8BDQDiuhOniuXrY6e5J+uWXX6J3794+K2EOHDgQAPDZZ58hJSUFt956Kx544AE89thjuOyyy3DppZeioqICS5YswcKFC2GxWELiPqtcCZMrYZ6KcyVMroTJlTAjpZ+4EiYFEgvwIPBcCRMAysvLfVbC3Llzp+YKVpWVlZqrcm3evFlzVa7y8vJ2r8pVW1vrsyqXq3DevXu3+lquVbl2797tsyrX4cOHMWjQIK8Z7PT0dHTt2hUA8K9//UsdEObMmYPKykqMGzcOTzzxBJ566in069cPM2bMUPfX2chp9OjR2L9/v+ZKY81zmjbt1AqL06bt1FxhccGCSs1VI5cu3ay5EuaLL5a3eYXFwsIK5OXlYuDAWs0VFkeO3K+5auRtt+3WXDWyLTmVlrb/2Csu9l01MtA5rVw5AACwZMlWzZUw29NPrc2pstL/+RQOY4TW+fTpp59i2LBhEZXT6ca9s5mT61K+5n8VDOecQqWfrFZrxOUEePdTdXU1KLi4EmYQhfNKmMeOHUNycjKefPJJLFq0SI37+23cbDbj2muvxRtvvOG1EmZlZSWGDh2KV155BXfccYfa9j179uDSSy9FU1MT4uPjsX37dvTo0SNkZhi4EiZXwjwV50qYXAmTK2FGSj9xJUwKJM6Ah4BwXQnT1c6WtD0xMRH19fU+uR45cgQAkJKS4hXv27cvhg8fjg0bNmD69OlITU0NSE5cCZMrYbriXAmTK2GG8qqRXAnzFK6EyZUwwxW/hEkB0b9/f68/hbl8/vnn6uOeVq1ahQ0bNuCKK65AYWEh75JCREREEYMFOAXE2LFj8cMPP6CyslKNybKMtWvX4sorr0T37t3V+Oeff47Zs2fj7rvvxpYtWzBw4EDccccdOHr0aDCaTkRERNShWIBTq5SVleH111/HP//5TwDAV199hddffx2vv/46GhoaAAD33nsvDAaD15c8Jk+ejNTUVEycOBHr1q3Dpk2bcPvtt2PXrl343e9+p2538uRJ3H777bjwwgvxpz/9CVFRUXjttddw7NgxTJkyJbDJEhEREZ0FvAacWmX69OlehfX69euxfv16AMDevXvRq1cvOJ1OOJ1Ory+omEwm/OY3v8GmTZswa9YsNDQ0IDMzE2VlZRgxYoS63YMPPoiamhps374dnTp1AgD07t0bq1atwvjx47Fs2TI88sgjgUmWiIiI6CxgAU6tsm/fvjNu89JLL+Gll17yiXfu3BmrV68+7Zc/XnnlFbzyyis+8dtuuw28YQ8RERFFAl6CQkREREQUQJwBDwHhuBJma+9J6plrJOTElTC5EuapOFfC5EqYXAkzUvqJK2FSILEAD4KgroQ5axbMtbUoLS72alPOxImwJSWhYsUKNWZoaEBuXh5qMzOxraBAjcfV1GD07NnYP2YMqmbOVOPJO3Zg6OLF2D1hAnZNmKDGU61W9F+9Gigu9l4Js6QEGSUlqMzPx6GsLHdOhYVI27QJm194Acc97v89pKAAKVVVKF+3DvIv+6tNOU2cyJUwuRImV8LkSphBX42QK2GGZj9xJUwKBK6EGUQBWwkzIUGNG+x2QFEgm81ebTHYbIAkQTaZvOJGmw2KJMHpEdcJAUNjIxSDAU6P67l1igKD3Q6nwQDFIy45nVD0epQWF8MydSqMNtupuMMBvSxDNpkgPGbJ9Q4HJFmGHB0NodO543Y7JEWBo3nbW5tTQwNXwuRKmFwJkythBn0WkithhlY/cSVMCiTOgIeAs74S5i8Fr1dcIwZF0YxLigJJKy7LkJoNHgCgl2Xom8WVX4pjo83m8x4Gu12z7YbGRs24Ztv9xf3lxJUwuRImuBImwJUw/cVDfdVIroR5ClfC5EqY4YpfwiQiIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQCxACciIiIiCiCuhBkCHA6HuqrZWVnq12OJ9mAtRa/m6vG+QVuKHmj3Ur9RUaGxFD1wavXGYCzb7pmTw9H+JZl9cw3OUvSA7xLywViKXpYjZzlw13vIsgyj0RgROTWPB2MpegAtzjUccgp2P7na43A4IiYnf/3UvJ0UeCzAg6CoqAhFRUXqiVReXo6YmBgAQGpqKrKysrBz507U1NSoz0lPT0dGRgYqKytx6NAhNZ6ZmYm0tDRs3rwZx48fV+NDhgxBSkoKysvLIRcXq/FRs2bBXFuLUo8YAORMnAhbUhIqVqxQY4aGBuTm5aF24EBsKyhQ43E1NRg9ezb2jxyJqpkz1Xjyjh0Yungxdt92G3ZNmKDGU61W9F+9GgBg/eUnAKSXlCCjpASVCxbgUFaWO6fCQqRt2oTNS5fieGqqO6eCAqRUVaH8xRch/7K/2pQTgNraWmzbts2dU1wcRo8ejf3796OqqsqdU3Iyhg4dit27d2PXrl1qfNq0VBQVZWHatJ2wWNz9VFKSjpKSDCxYUImsLHc/FRZmYtOmNCxduhmpqe5+KigYgqqqFLz4YjliYtwD8axZo1Bba0ZxcalXThMn5iApyYYVKyo8XrsCeXm5GDiwFgUF7pxqauIwe/ZojBy5HzNnunPasSMZixcPxW237caECe6crNa251Ra6ufY8/hwGTVqFMxmM0pLvXPKycmBzWZDcbE7p4YGQ1ByWrlyAABgyZKt6NHjhBrviH5qbU6VldrH3lkZI1rRTxUV7pwMBgNyc3NbfD59+umnGDZsWETl5G+MONs5DR8+HABgtVojJqdQ6Ser1RpxOQHe/VRdXQ0KLp3w/BWOAqq+vh4JCQmora1FfHw8gLM0w5CQoMaDNQOu6PUoLS6GZepUGG22U/FgzYA3NLR7hiE2NjRmwFevtmLqVAuOHIkJ6gx4fX37Z4I6dQqNGfC1azdi8uRs2O3u+YlgzIDX10fOLKTD4YDVakV2djbMZnNE5NQ8HowZ8LKyMlgsFhg9xttwzinY/WS322G1WmGxWGAymSIiJ3/9VFdXh6SkJNTV1an1BwUWZ8BDgNFo9BpAgVMns16v99nWddK2NG40GoFfCl6vuEYMiqIZlxQFklZcliE1GzwAQC/L0DeLK78Ux0abzec9DHa7ZtsNjY2acc22+4v7y0mSIEm+X4HwF2/eH01Nrp96AL795Fm8eWps1I7bbMYWxxXFO+76t6JIsNl82y7LEmRZK66HLPu2vS05GTWa3/yYPlNcO9fA5uQqsO12g2Z72tNP7njLcnKd0v7Ggg4dI9oZb+n55GpDJOXkEuicXIWe1ueH1vana3uo5NSWeEfm5Hp9o9GobhPuOfnrJ3/tocDhlzCJiIiIiAKIBTgRERERUQCxACciIiIiCiAW4EREREREAcQCnIiIiIgogFiAExEREREFEAtwIiIiIqIAYgFORERERBRALMCJiIiIiAKIBTgRERERUQBxKfoQ4HA41GWFJUmCXq+H0+mEoijqNq64LMsQQqhxvV4PSZL8xh0OB/DLMvDAL8u+KwpkjxgAGGw2QJIgm0xecaPNBkWS4PSI64SAobERisEAp8dytjpFgcFuh9NggOIRl5xOd64e7ys5HNDLMmSTCcJjeV29wwFJliFHR0PodO643Q5JUbxeo005AVAUBU6Pdul0OhgMBr/x5v0RFSWhqUmPqCgn9Hp33OGQIMt6mEwyJEl4xPWQZQnR0TJ0OnfcbtdDUSR1CXR33ABFAcxm2StusxkgSYDJJKvPMZsdsNmMkCQFJpO77ULo0NhogMGgwGh0xxVFB7vdAIPBCaPR3Xans+05ORx+jj0PrqWbZVnWjPvmGvicXNuYTN5taU8/tTUnWdY+9s7KGOHBXz81NjbiySefxPr163HkyBGkp6dj3rx5mDRp0hnPJ4fDgY8//hjPP/88PvvsMzidTqSlpWHWrFm47777gpaTv7jRaGz3GHG2c3Jt09JcwyGnYPeTqz0OhyNicvLXT83bSYHHAjwIioqKUFRUpJ5I5eXliImJAQCkpqYiKysLO3fuRE1Njfqc9PR0ZGRkoLKyEocOHVLjmZmZSEtLw+bNm3H8+HE1PmTIEKSkpKC8vBxycbEaHzVrFsy1tSj1iAFAzsSJsCUloWLFCjVmaGhAbl4eagcOxLaCAjUeV1OD0bNnY//IkaiaOVONJ+/YgaGLF2P3bbdh14QJajzVakX/1asBANZffgJAekkJMkpKULlgAQ5lZblzKixE2qZN2Lx0KY6nprpzKihASlUVyl98EfIv+6tNOQGora3Ftm3b3DnFxWH06NHYv38/qqqq3DklJ2Po0KHYvXs3du3apcanTUtFUVEWpk3bCYvF3U8lJekoKcnAggWVyMpy91NhYSY2bUrD0qWbkZrq7qeCgiGoqkrBiy+WIybGPRDPmjUKtbVmFBeXeuU0cWIOkpJsWLGiwuO1K5CXl4uBA2tRUODOqaYmDrNnj8bIkfsxc6Y7px07krF48VDcdttuTJjgzslqbXtOpaV+jj2PD5dRo0bBbDajtNQ7p5ycHNhsNhQXu3NqaDAEJaeVKwcAAJYs2YoePU6o8Y7op9bmVFmpfeydlTGiBf1UWFiI7du3Iy8vD927d8fmzZtx1113QZIkjBkz5rTn0xtvvIFXX30VY8eOxWuvvYaffvoJH330EXbs2IHS0tKg5eQ69ioq3P1kMBiQm5vb7jHibOc0fPhwAIDVao2YnEKln6xWa8TlBHj3U3V1NSi4dMLzVzgKqPr6eiQkJKC2thbx8fEAztIMQ0KCGg/WDLii16O0uBiWqVNhtNlOxYM1A97Q0O4ZhtjY0JgBX73aiqlTLThyJCaoM+D19e2fCerUKTRmwNeu3YjJk7Nht7vnJ4IxA15fHzqzkGVlZRg7dixeffVVjB8/Xo3n5OTgq6++wr59+7xew/N82r59O4YOHYpJkybhz3/+M8xmc0jkdLp4OMwWCyFQVlYGi8UCo8d4G845Bbuf7HY7rFYrLBYLTCZTROTkr5/q6uqQlJSEuro6tf6gwOIMeAgwGo1eAyhw6mTW6/U+27pO2pbGjUYj8EvB6xXXiEFRNOOSokDSissypGaDBwDoZRn6ZnHll+LYaLP5vIfBbtdsu6GxUTOu2XZ/cX85SRIkyfcrEP7izfujqcn1Uw/At588izdPjY3acZvN2OK4onjHXf9WFAk2m2/bZVmCLGvF9ZBl37a3JSejRvObH9NnimvnGticXAW23W7QbE97+skdb1lOrlPa31jQoWPEGeL//Oc/ERsbi9tvv93rdaZOnYq8vDy1yG5OkiT8+c9/hslkQm5urvpcrbaXlJRg4sSJWLFiBWZ6/GUtPz8fS5YswcaNG2GxWDospzPF2ztGnCne3n5yFXpanx9a25+u7aGSU1viHZmT6/WNRqO6Tbjn5K+f/LWHAodfwiQiotP64osv0K9fP5+iY+DAgerj/mzevBkZGRnYtm0bLrnkEuj1evTo0QMLFixAk+s3WQATJkzAgw8+iMceewyffPIJAOD999/HkiVL8MQTT/gU30RE4Ywz4EREdFqHDx9G7969feJdu3ZVH/fnwIEDOHToEHbv3o1nnnkGAwYMwL/+9S8899xz2L9/P1599VV122XLluHjjz/G7bffjg0bNiAvLw/Dhw9Hgcd3UIiIIgELcCIiOiOdx/cxWvOYoig4fvw4HnvsMUyfPh1GoxGjRo3CyZMnsWzZMixevBh9+/YFAJhMJrz22mu49NJLMXjwYMTHx6O4uFjzz+hEROGMl6AQEdFpJSYmas5yHzlyBIB7JtzfcwEgy+NORwBwww03AAA+/fRTr3jfvn0xfPhwNDY24s4770S3bt3a1XYiolDEApyIiE5rwIAB+Prrr33u2PD5558DAPr37+/3ua7rxJtz3UGi+ZfKVq1ahQ0bNuCKK65AYWEhPv744/Y0nYgoJLEAJyKi07rllltw4sQJvPHGG17xNWvWoHv37rjyyiv9PvfWW28FAPz3v//1ipeWlkKSJFx++eVq7PPPP8fs2bNx9913Y8uWLRg4cCDuuOMOHD16tAOzISIKPl4DTkREp3XDDTfAYrFg+vTpqK+vR9++fVFcXIyNGzdi7dq16jXa9957L9asWYPvv/8eaWlpAIApU6bgz3/+M/7yl7+gZ8+eGDBgADZt2oSioiI89NBD6nYnT57E7bffjgsvvBB/+tOfEBUVhddeew2DBw/GlClT8PbbbwcrfSKiDscCnIiIzujNN9/Er3/9ayxatAhHjhxBRkYGiouLMcFj1Vun0wmn0+m1QInRaERZWRnuuece/O53v8ORI0dw4YUX4rnnnsOcOXPU7R588EHU1NRg+/bt6NSpEwCgd+/eWLVqFcaPH49ly5bhkUceCVi+RERnEwtwIiI6o9jYWCxfvhzLly/3u81LL72El156ySfetWtXTJ8+HTk5OX4XAHnllVfwyiuv+MRvu+02cMFmIoo0vAaciIiIiCiAWIATEREREQUQC3Aiogim0wX/v4SEU21JSAh+W4iIQgELcCIiIiKiAGIBTkREREQUQLwLSghwOBxwOBwATq0Kp9fr4XQ6oSiKuo0rLsuy1x0B9Ho9JEnyG3c4HIDZrMYNdjugKJA9YgBgsNkASYJsMnnFjTYbFEmC0yOuEwKGxkYoBgOcHnc00CkKDHY7nAYDFI+45HS6c/V4X8nhgF6WIZtMEB6r4ekdDkiyDDk6GsLjb8Z6ux2Soni9RptyAqAoCpwe7dLpdDAYDH7jzfsjKkpCU5MeUVFO6PXuuMMhQZb1MJlkSJLwiOshyxKio2XodO643a6Hokgwmx1ebbTbDVAUwGz2XnnQZjNAkgCTSVafYzY7YLMZIUkKTCZ324XQobHRAINBgdHojiuKDna7AQaDE0aju+1OZ9tzcjj8HHseDIZTw03z1RRdcd9cA5+TaxuTybst7emntuYky9rHXmvHCIOh44+91ubkeg+TSYbNZuzQY6+1OXkelv6OSaPR2O4x4qyM5R5c27T0PAuHnM40RpztnFztcTgcEZOTv35q3k4KPBbgQVBUVISioiL1RCovL0dMTAwAIDU1FVlZWdi5cydqamrU56SnpyMjIwOVlZU4dOiQGs/MzERaWho2b96M48ePq/EhQ4YgJSUF5eXlkIuL1fioWbNgrq1FqUcMAHImToQtKQkVK1aoMUNDA3Lz8lA7cCC2FRSo8biaGoyePRv7R45E1cyZajx5xw4MXbwYu2+7Dbs87g2carWi/+rVAADrLz8BIL2kBBklJahcsACHsrLcORUWIm3TJmxeuhTHU1PdORUUIKWqCuUvvgj5l/3VppwA1NbWYtu2be6c4uIwevRo7N+/H1VVVe6ckpMxdOhQ7N69G7t27VLj06aloqgoC9Om7YTF4u6nkpJ0lJRkYMGCSmRlufupsDATmzalYenSzUhNdfdTQcEQVFWl4MUXyxET4x6IZ80ahdpaM4qLS71ymjgxB0lJNqxYUeHx2hXIy8vFwIG1KChw51RTE4fZs0dj5Mj9mDnTndOOHclYvHgobrttNyZMcOdktbY9p9JSP8eex4fLqFGjYDabUVrqnVNOTg5sNhuKi905NTQYgpLTypUDAABLlmxFjx4n1HhH9FNrc6qs1D72WjtGjBx59o691ub06KOfIj9/WIcee63NyfPwcx17FRXunAwGA3Jzc9s9RpyVsdzjfBo+fPgv+84KT+Gc05nGiEDlZLVaIy4nwLufqqurQcGlE7zBatDU19cjISEBtbW1iI+PB3CWZhhc34BC8GbAFb0epcXFsEydCqPNdioerBnwhoZ2zzDExobGDPjq1VZMnWrBkSMxQZ0Br69v/0xQp06hMQO+du1GTJ6cDbvdPT8RjBnw+vqOmYWMiQmNGfDVq62YPDkbx46ZgzoDXlfnjgd7FrK9M+BlZWWwWCxe91YP55yCPVtst9thtVphsVhgMpkiIid//VRXV4ekpCTU1dWp9QcFFmfAQ4DRaPRZnEKv16vLO3tynbQtjRuNRuCXgtcrrhGDomjGJUWBpBWXZUjNBg8A0Msy9M3iyi/FsdFm83kPg92u2XZDY6NmXLPt/uL+cpIkSJLvVyD8xZv3R1OT66cegG8/eRZvnhobteM2m/biJFpxRfGOu/6tKBJsNt+2y7IEWdaK6yHLvm1vS05aa6v4W3DFX1w718Dm5Crc7HaDZnva00/ueMtycp3S/saClo4RrlPxbBx77njLcnLt74489lradle8pcdqe8eIM8XbNJZ7cBV6Wp8fWtufru2hklNb4s3bfuLECTz55JN47bXX1BVbFyxYoK7Y6q/tr7zyCqZMmaL5vj/99BPOP//8oOV0pnhb+slfeyhwWIATERFRRBg3bhy2b9+O5557DhdffDHWrVuHiRMnQlEU5OXlnfH5s2bNwu233+5VYCcmJp7NJtM5igU4ERERhb3S0lJYrVa16AZOXYNdXV2NefPm4Y477tCcEfaUlpaGK6+8kjPEdNbxNoREREQU9t566y3ExsZi/PjxXvEpU6bgxx9/xMcff9zu9ygpKYFOp0NhYaFXPD8/H3q93udLsUT+sAAnIiKisPfFF1+gX79+PtdnDxw4UH38TJYsWYLo6Gh07doV48aN83nOhAkT8OCDD+Kxxx7DJ598AgB4//33sWTJEjzxxBOwWCwdlA1FOhbgREREQXDixAk88sgj6N69O6Kjo5GZmYmSkpJWv86TTz4JnU6H/v37n4VWho/Dhw+ja9euPnFX7PDhw36fe/7552PBggWYMWMGrFYrnn76aWzfvh1XXXUVPvvsM69tly1bhksuuQS33347vv76a+Tl5WH48OEo8LhdL9GZsAAnIiIKgnHjxmHNmjXIz89HWVkZLr/8ckycOBHr1q1r8WtUVVXh+eefx3nnnXcWWxo+dB63rm3NY9dffz1+85vf4PLLL8fw4cMxY8YMbNmyBTqdDosWLfLa1mQy4bXXXsPhw4cxePBgCCFQXFx8xuvLiTyxACciIgow1xcG//SnP+GBBx7AqFGj8Ne//hUWiwXz5s3zut+zP06nE9OmTcMDDzyAjIyMALQ6tCUmJmrOch85cgQANGfHT6dXr164+uqr8dFHH/k81rdvXwwfPhyNjY2488470a1bt7Y1ms5ZLMCJiIgCrCO+MPjGG2/g6NGjeOaZZzQfP9e+MDhgwAB8/fXXPovbfP755wDQpkt0hBCa995etWoVNmzYgCuuuAKFhYUd8gVPOrewACciIgqw9n5h8KuvvsL69euxYsUKxMbGam5zrn1h8JZbbsGJEyfwxhtveMXXrFmD7t2748orr2zV6+3duxf/+c9/cNVVV3nFP//8c8yePRt33303tmzZgoEDB+KOO+7A0aNH250DnTt4H3AiIqIAO3z4MHr37u0Tb8kXBhVFwf3334+rrroKN9xww2nfZ9myZfj4449x++23Y8OGDRH9hcEbbrgBFosF06dPR319Pfr27Yvi4mJs3LgRa9euVa/Rvvfee7FmzRp8//33SEtLAwCMGTMGw4YNQ1NTE8xmM77++mssXboUOp0OTz/9tPoeJ0+exO23344LL7wQf/rTnxAVFYXXXnsNgwcPxpQpU/D2228HI3UKQ5wBJyIiCoK2fmHw//7v//Ddd9/h3nvvPeN7nGtfGHzzzTdx1113YdGiRbj++uvx8ccfo7i4GHfeeae6jdPphNPphBBCjQ0YMADr16/H8uXLkZubi6VLl2L06NH45JNPvC5defDBB1FTU4P169ejU6dOAIDevXtj1apVeOedd7Bs2bKA5UrhjTPgREREAdbWLwzW1NRg0aJFeOaZZ2AwGHDs2DEYjUbIsgxFUXDs2DGYTCaYzWb1Oa4vDG7YsAHTp0+P6C8MxsbGYvny5Vi+fLnfbV566SW89NJLXrE//vGPcDgcKC0tRU5Ojt+VMF955RW88sorPvHbbrvNq6AnOhPOgBMREQVYW78wuGfPHthsNsyZMweTJk1CSkoKunTpgv/85z/4+uuv0aVLFyxcuNDrOfzCIFHoYQFOREQUYG39wmBmZiYqKirUxWKsVisqKiowaNAg9OrVCxUVFZg5c6a6Pb8wSBSaeAkKERFRgLX1C4OdO3fGyJEj4XA4cPLkSYwYMQJGoxGdO3eGLMsYOXKk+h7h9IVB3WL/17wHilkyo3hgMRKeS4BNsQW1LSKfl7NEOs6AExERBUFbvzDYUvzCIFHo4gw4ERFRELT1C4NaPvjgA58YvzBIFLo4A05EREREFEAswImIiFpBpwv+fwkJp9qSkBD8thBR67EAJyIiIiIKIF4DHgIcDgccDgcAQJIk6PV6OJ1OKIqibuOKy7Lsde2eXq+HJEl+4w6HA/BYkMFgtwOKAtkjBgAGmw2QJMgmk1fcaLNBkSQ4PeI6IWBobIRiMMDpsViBTlFgsNvhNBigeMQlp9Odq8f7Sg4H9LIM2WSCkNy/C+odDkiyDDk6GsJjekVvt0NSFK/XaFNOOLWUs9OjXTqdDgaDwW+8eX9ERUloatIjKsoJvd4ddzgkyLIeJpMMSRIecT1kWUJ0tAydzh232/VQFAlms8OrjXa7AYoCmM3e9wi22QyQJMBkktXnmM0O2GxGSJICk8nddiF0aGw0wGBQYDS644qig91ugMHghNHobrvT2facHA4/x54Hg+HUcNP8vseuuG+ugc/JtY3J5N2W9vRTW3OSZe1jr7VjhMHQ8cdea3NyvYfJJMNmM3bosdfanDwPS3/HpNFoPO0YYTaf3fOpJTm5tmke74hjr7U5OZ3t+Hz6hVkyw67YoUCBWfIey22KDRIkmCTTGeMCAo1KIww6A4w69+eQAgV2xe4TdwonmkQTonRR6vuaJTMcwgFZyDBJJkgec5WueLQUDR3cn0/+2t7WnDz3TWs/n1oyRjQfnynwdILfxAi4oqIiFBUVwel04ttvv8W6desQExMDAEhNTUVWVhZ27NiBmpoa9Tnp6enIyMjA1q1bcejQITWemZmJtLQ0vP/++zh+/LgaHzJkCFJSUrBhwwavD5dRs2bBXFuL0uJirzblTJwIW1ISKlasUGOGhgbk5uXh58xMbCsoUONxNTUYPXs2qseMQZXH/WaTd+zA0MWL8c2ECdg1YYIaT7Va0X/1ap/3TC8pQUZJCbbm5+NQVpY7p8JCpG3ahPdfeAHHU1PdORUUIKWqChvWrYP8y/5qU04TJ+Lnn3/Gtm3b3DnFxWH06NGorq5GVVWVO6fkZAwdOhTffPMNdu3apcat1lQUFWVhxowdsFjc/VRSko6Skgzk529FVpa7nwoLM7FpUxpeeOF9pKa6+6mgYAiqqlKwbt0GxMS4+2nWrFGorTWjuLjUK6eJE3OQlGTDihUVaqyhwYC8vFxkZv6MggJ3TjU1cZg9ezTGjKnGzJnunHbsSMbixUMxYcI3mDCh43Pye+yNGgWz2YzSUu+ccnJyYLPZUFER/JxWrhyA++//HD/8EIsePU6o8WD0k79jr7VjRCgde599loT8/GFn7dhrbU5ax57BYEBubm6Lx4izfT75y2nevOH4/e+3oLlgjBEd9fk065tZqG2qRfFA77F84s6JSIpKwooM91je4GxA3ud5yIzLREGfAndOthrM3jUbY7qOwcxU9+fTjvodWLxnMSacPwETznd/PlkPW1G0vwgzes6AJdGixkv+V4KS/5Ugv3c+suLdn0+FNYXYdGQTXkh/Aalm9+dTwfcFqDpehXUD1iFG7/586oicWvv51JIxorq6Gnl5eairq0N8fDwo8FiAB1F9fT0SEhJQW1urngBnZQbcdbEggjcDruj1KC0uhmXqVBhtp+6vGrQZ8IaGds+Ax8aGxgz46tVWTJ1qwZEjMUGdAa+vb/8MeKdOoTEDvnbtRkyenA273f0HwmDMgNfXd8wMeExMaMyAr15txeTJ2Th2zBzUGfC6One8rTPgsbGhMQO+bl0Zpk61wGZzj7fBmAE/frz9M+AJzyUEfQY8Vh+L1f1XY+oXU1HvrA/qDHjjE41q7GzMgNfV1SEpKYkFeBDxEpQQYDQaYfQoWIFTA5RrIQZPrg+MlsaNRiNg811QwKgRg6JoxiVFgaQVl2VIzT64AEAvy9A3iyu/FMdGm83nPQx2u2bbDY2NmnHNtvuL+8tJkiBJvl+B8Bdv3h9NTa6fegC+/eRZvHlqbNSOe36AnimuKGj2gWv8JS7BZvNtuyxLkGWtuB6y7Nv2tuRk1Gh+82P6THHtXAObk6vIsdsNmu1pTz+54y3LyXVK+xsLWjpGuE7Fs3HsueMty8m1vzvy2Gtp213xlh6rpxsjtHMNbE6uY9VmM/o81t5+csdblpPrMGzT59MvPBe+0VoER4HSqrgsZMjC9/PJX7xJNKmvY1Ns6jZ2RfvzqVHR/nzyt4BPa3NqzTHZljHC3zhMgcMvYRIRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCiAU4EREREVEAsQAnIiIiIgogFuBERERERAHEApyIiIiIKIBYgBMRERERBRALcCIiIiKiAGIBTkREREQUQCzAiYiIiIgCyBDsBpzLhBAAgPr6+iC35OxzCIGGhgbUCwFjsBsTIftbCAcaGhogRD0Q5L0aIbuU+/Qs4X7teBG3Txs74DXaSUinPqdEowCU4LblbNcFrtd31SEUeDrBvR80P/zwA3r27BnsZhAREdE5aP/+/ejRo0ewm3FOYgEeRIqi4Mcff0RcXBx0Ol2wm3NW1dfXo2fPnti/fz/i4+OD3ZyIwH3a8bhPzw7u147HfdrxzqV9KoTA8ePH0b17d0gSr0YOBl6CEkSSJJ1zv3nGx8dH/MAWaNynHY/79Ozgfu143Kcd71zZpwkJCcFuwjmNv/YQEREREQUQC3AiIiIiogBiAU4BYTKZkJ+fD5PJFOymRAzu047Hffr/t3enQU1dbRzA/xfCHkEEV/oKaHFBq6JI41KDskgFqjBKxwHcUHHBbVyYqmgUt3G3VqCuiKKjWFyoC0ZAnVZUXFtX2roM6uACatWKAj7vB4dMQxK2kAjp85vJh5x77jnn/sWcQ7g50Q3OtfZxprWPM2X6xB/CZIwxxhhjTI/4HXDGGGOMMcb0iBfgjDHGGGOM6REvwBljjDHGGNMjXoCzGtmzZw86dOgACwsLCIKAK1eu1FrbJ0+ehCAIOHnyZK21yRhj7NOSyWQQBAHPnj2rlfY8PT3RsWNHrdrw8vLCuHHjanSuIAiQyWQ1OtfJyQkBAQGV1svIyIBYLMbDhw9r1A+ru3gBzqrt6dOnCA8PR+vWrXHs2DFkZ2ejTZs2n3pYemdIk8mrV68wa9Ys+Pr6onHjxhVOLH369MHUqVO1GqcmhpRpZmYmRo0ahXbt2sHKygoODg4YOHAgLl68qFJXl5kChpXrlStX4O/vj5YtW8LCwgKNGjVCjx49sHPnTpW62uRaXzLLyMiAu7s7rKysIAgCDhw4gMTERAiCgHv37mnVX2WcnJwwYsQIxfPc3FyYmpri0qVLOu23thw8eBC//vorYmJianR+dnY2Ro8eXcujUubl5QUPDw/Mnj1bp/0w/eMFOKu23NxcFBcXIywsDFKpFBKJBJaWlp96WP952kwmBQUF2LhxI969e4dBgwZVWDc2NhZxcXG4fft2DUdaf2iTaXx8PO7du4cpU6bgyJEjWLduHZ48eQKJRILMzEyluv+lTAHtcn3x4gX+97//YcmSJThy5AiSkpLg5OSE8PBwLFq0SKmuIeWqLjMiQkhICExMTHDo0CFkZ2dDKpXC398f2dnZaN68uV7H2KZNG4SGhmLatGl67bemlixZgqCgIDg4ONTofIlEopdvs544cSKSk5ORl5en876Y/vACnFXLiBEj0Lt3bwDAt99+C0EQ0L17d9jY2KC0tFRRb9KkSRAEAStWrFCUFRQUwMjICOvXr1eU3bp1C35+frC0tIS9vT3GjRuHV69e6e+CDIg2k4mjoyOeP3+OU6dOYenSpRXWlUqlaNu2LVatWlXTodYb2mS6YcMGZGZmYvz48ZBKpRg8eDDkcjns7OywZMkSpbr/pUwB7XL19PREQkICwsLC0LdvXwQEBGD37t348ssvsXHjRqW6hpSruswePXqEwsJCBAUFwcvLCxKJBLa2tmjcuDEkEskn2c86KioKp0+fxpkzZzTWycvLQ3BwMKytrWFjY4OwsDA8ffpUpd6uXbvQo0cPiMViiMVidOnSBVu2bKmw//3798PS0hKjR49GSUmJxnqXL1/G+fPnER4ernIsPz8fkZGR+Oyzz2BqagpnZ2csWLBApT11fyn85Zdf0KNHD5ibm8PBwQExMTHYvHmzxr9IHDt2DF27doWFhQXatWuHrVu3qtQJDAyEWCzGpk2bKrx2Vr/wApxVS0xMDDZs2ADg44SQnZ2NsLAw/P333zh//ryi3okTJ2BhYQG5XK4oy8jIABHB29sbAPD48WNIpVJcu3YNcXFx2LFjB16/fo2oqCj9XpSW6upkcvXqVQiCoLaPo0ePQhAEHDp0CMDHiUQQhKpeMsLDw7Fr1y6d/bJkCJk2adJEpY5YLIarq6vad7J0nSlgGLlqYm9vD5FIpFKuba51NTOZTKZ49zU6OhqCIMDJyQkA1N6CUnYLTE5ODr766itYWlqiVatWWLZsGT58+KCoV1RUhOnTp6NLly6wsbFR3OJz8ODBqsSFbt26oX379khISNBYJygoCJ9//jn27dsHmUyGAwcOoH///iguLlbUmTdvHkJDQ9GiRQskJiZi//79GD58OO7fv6+x3TVr1mDIkCGYPXs2Nm/erPbnoczPP/8MY2Nj9OnTR6k8Pz8fHh4eSE9Px7x583D06FFERERg6dKlGDNmTIXX/ttvv8HHxwf//PMPtm/fjoSEBFy6dAmLFy9WW//q1auYPn06pk2bhoMHD6JTp06IiIjA6dOnleqZmpqiZ8+eOHz4cIX9s3qGGKumrKwsAkApKSlERPTmzRsyNTWlhQsXEhHRgwcPCABFR0eThYUFFRUVERHRmDFjqEWLFop2oqOjSRAEunLlilL7Pj4+BICysrL0c0E1NH/+fAJAjo6ONHPmTEpPT6fVq1eTlZUVubm50fv37xV1Y2JiCAAFBwdTSkoKHT9+nFavXk0xMTGKOlKplDp06KB4vnr1ajI2NqbY2NhKx7Jw4UIyNjamV69eKZW7ublRr169VOqHhIRQkyZNqLi4WOXY06dPCQDNnz9fY3/nzp0jAHTo0KFKx1YdhpppmRcvXpCNjQ0FBQWpHNNVpkSGmWtpaSkVFxfTkydPaMOGDSQSiSghIUHl/JrmWtczy8vLo9TUVAJAkyZNouzsbLp06RIREW3bto0A0N27d5X6t7OzIxcXF0pISCC5XE4TJkwgALR9+3ZFvRcvXtCIESNox44dlJmZSceOHaMZM2aQkZGRUj0iIkdHRxo+fLjKeMePH0/29vb04cMHtZlOmzZNqTw5OZkA0M6dO4mI6M6dO2RsbEyhoaEV5lKWaWlpKUVFRZGpqamijcp8/fXX1K5dO5XyyMhIEovFdP/+faXylStXEgC6fv26oqz86+SQIUPIysqKnj59qigrLS0lV1dXlX8PR0dHMjc3V+rn7du31KhRI4qMjFQZ15w5c8jIyIhev35dpetjdR8vwFm1lV+AE318IezTpw8RfXzxb9iwIT179oyMjY3pxIkTRETk7OxMw4YNU5zj4eFBHTt2VGm/bPKoLwvwujyZfP/99wSAbt++rSgrLCwkMzMzmj59utq2qrIAf//+PQmCQNHR0VUaX1UZaqZlQkNDSSQS0YULF1SO6SpTIsPMNTIykgAQADI1NaW4uDi1/dU01/qQ2d27dwkArVixQqlc0wIcAJ07d06prqurK/Xv319j3yUlJVRcXEwRERHk5uamdEzTAnzTpk0EgG7evKlUXpZp+Z//4uJiEolEFBERQUREP/74IwGgM2fOaBxX2TW1bt2aAgMDydbWlk6ePFlh/X/r3LmzYs76NwcHBwoMDKTi4mKlx/Xr1wmA0s9Z+dfJJk2aUGBgoEqbMplM7QJcIpGo1JVIJOTn56dSvm7dOgJAf/75Z5WvkdVtfAsKqxXe3t44e/Ys3rx5gxMnTqBfv36ws7NDt27dcOLECdy9exd3795V3H4CfLwnvFmzZiptqSury0JDQ5Weh4SEQCQSISsrCwAgl8tRWlqKiRMnVtpWUVERBg0ahOTkZBw/flylbU0ePXqk9paH0NBQmJmZITExUVG2e/duvHv3DiNHjqxS2+qYmJigYcOGOtsayxAzjYmJQXJyMtasWYNu3bqpHNd1poBh5Tp79mzk5OTg8OHDGDVqFKKiorBy5UqVetrmWpczq65mzZrBw8NDqaxTp04qt3WkpKSgV69eEIvFEIlEMDExwZYtW3Dz5s0q9VM2Vk2Zl3+NF4lEsLOzQ0FBAQAobvGpygccnzx5gvT0dPTo0QM9e/as0vgA4O3btzA3N1cpf/z4MdLS0mBiYqL06NChAwBUuCtOQUEBmjZtqlKurgwA7OzsVMrMzMzw9u1blfKysao7xuonXoCzWuHl5YX379/j9OnTyMjIgI+Pj6JcLpcr7gX38vJSnGNnZ4f8/HyVttSV1WV1eTJp1KgRvvnmGyQlJSk+JJuYmAgPDw/FhFJT5ubmOpsMDC3TBQsWYNGiRVi8eHGFn3HQZaaAYeXasmVLuLu7Y8CAAYiPj8fYsWPx3Xffqb0/W5tc63Jm1VWVBV9qaipCQkLg4OCAnTt3Ijs7Gzk5ORg1ahSKioqq1E9li8Xyr/ElJSUoKChQjK9x48YAgAcPHlTaV8uWLZGWloaTJ08iODi4ymO0t7dHYWGh2nJfX1/k5OSofURERGhs087ODo8fP1Ypr405rWys9vb2WrfF6gZegLNa4eHhAWtra6xduxb5+fmKBbi3tzcuX76MvXv3wtXVFS1atFCc07dvX1y/fh1Xr15VamvXrl16Hbu26vJkAgAjR47Ew4cPIZfLcePGDeTk5Gj17neZ58+f62wyMKRMFyxYAJlMBplMVulevrrMFDCsXMvz8PBASUkJ7ty5o3JMm1zrema1befOnXB2dsaePXswaNAgSCQSuLu74927d1Vuo7LFYnJystLzvXv3oqSkBJ6engAAX19fGBsbIz4+vkr9+fr6Ij09HadPn0ZAQADevHlT6Tnt2rVT+7MSEBCAa9euoXXr1nB3d1d5/HsOK08qlSIzM1PpXfIPHz4gJSWlStdRkTt37sDOzk7ju+ms/uEFOKsVxsbGkEqlOH78OJydndG6dWsAQK9evWBmZoaMjAyl208AYOrUqbC3t4e/vz8SExNx9OhRhIWF4datW5/iEmqsLk8mZe05ODhg27Zt2LZtG8zNzTF06NAqjUWTR48eoaioCK6urlq1o4mhZBobGwuZTIa5c+di/vz5Ffan60wBw8lVnaysLBgZGaFVq1ZK5drmWtczq22CIMDU1FRpV6T8/Pwq74ICfFwsGhkZoW3btmqPp6amYtasWZDL5Vi7di0iIyPRuXNnhISEAPj4BT+zZ8/Gjh07MGTIEKSmpiIjIwPr16/X+P+od+/eyMjIwJUrV+Dr64uXL19WOEZPT08UFhYiNzdXqXzhwoUwMTFBz549ER8fj8zMTBw5cgRxcXEICAio8BetOXPmoLS0FF5eXti7dy/S0tIQGBio+Dc2Mqr5kuvs2bOQSqXV2q2K1W2a9+hhrJq8vb2RlpamtNA2MzND7969IZfLVRbgzZo1w6lTpzBlyhSMHz8elpaWCAoKwg8//ICBAwfqe/g1lpqaCpFIBB8fH1y/fh0xMTFqJ5PY2Fi8ffsWQ4cOhY2NDW7cuIFnz55hwYIFKm2WTSZ+fn7w9fXFkSNHYGNjo3EMnp6e2Lp1K3Jzc1W+ldTY2BjDhg3D6tWrYW1tjeDgYLVtHT16FG/evFFs13bjxg3s27cPADBgwAClL1s6e/YsgI9/xdAFQ8h01apVmDdvHvz8/ODv76/IrIxEIlF6rutMAcPIdezYsbC2toaHhweaNm2KZ8+eISUlBXv27MHMmTMV70iX0TbXup5ZbQsICEBqaiomTJiAwYMHIy8vD7GxsWjevDn++OOPKrVx9uxZdOnSBba2tmqPp6amQiaTIT4+HoIgIDAwEGvXroWpqamizsKFC+Hi4oL169cjNDQUIpEILi4umDx5ssZ+3d3dcerUKXh7e6Nfv35IT0/X+C78wIEDIRaLcfDgQcycOVNR3rx5c1y4cAGxsbFYsWIFHjx4gAYNGsDZ2Rl+fn4arwkAOnfuDLlcjhkzZmDYsGGwtbVFeHg4pFIpoqOjK/w3rshff/2F33//vcZfe8/qqE/9KVDG6quyT/RfvHiRAgMDSSwWU4MGDWjo0KH0+PFjlfpJSUnUvXt3Mjc3J7FYTG5ubrRt2zbF8fLblBERXbt2jZo1a0Zdu3ZV2tqqvJcvX5JYLKbly5erPZ6bm6vYMUIul6ut4+joqKhT/vHvT+8TEYWHh9MXX3yhcTw1ZUiZlu06oelRnq4yJTKsXLdu3UpfffUV2dvbk0gkooYNG5JUKqUdO3aoba+mudaHzKq7C0r5/omIhg8fTo6Ojkply5YtIycnJzIzM6P27dvTpk2bFHn8m7pdUF69ekWWlpa0atUqjddTV0RFRVH79u1VtkusbT4+PuTi4lLj8+fOnUstW7ascItTVv/wApwxA6GvyeTly5dkZWVFGzdu1Gk/dQFnqhuca/XpKzNtbd68maysrKiwsPBTD6VS+fn5ZG1trbSlrramTZtGSUlJlJWVRT/99BMFBwcTANqyZUuN2nv+/DnZ2tpWectKVn/wApwxA6GLyUQdmUxG7du3/0+8G8OZ6gbnWn36ykwbxcXF5OLiQosWLfrUQ6mytLQ0SkpKqrX2Jk+eTE5OTmRubk4WFhbUrVs3jX+dqYpLly7R8uXL6/wvXqz6+B5wxgxE06ZNkZycjOfPn+u0H2trayQmJlb4Nc+GgjPVDc61+vSVmTby8vIQFhaG6dOnf+qhVFlAQECttrdu3TqsW7eu1tpzc3ODm5tbrbXH6g6BiOhTD4IxxhhjjLH/Ct6GkDHGGGOMMT3iBThjjDHGGGN6xAtwxhhjjDHG9IgX4IwxxhhjjOkRL8AZY4wxxhjTI16AM8YYY4wxpke8AGeMMcYYY0yPeAHOGGOMMcaYHv0feHG0MvrsOKcAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# profile on cpu\n", "plot_profiling(torch.device(\"cpu\"))\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 9, "id": "3514dbcc", "metadata": { "ExecuteTime": { "end_time": "2023-10-31T22:23:32.070911Z", "start_time": "2023-10-31T22:23:32.055923Z" } }, "outputs": [], "source": [ "# profile on gpu\n", "if torch.cuda.is_available():\n", " plot_profiling(torch.device(\"cuda\"))\n", " plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.13" } }, "nbformat": 4, "nbformat_minor": 5 }