{ "cells": [ { "cell_type": "markdown", "id": "b61b67a1", "metadata": {}, "source": [ "# Basic Differentiable Least Squares\n", "\n", "In this tutorial we develop a declarative node in PyTorch for solving the ordinary least squares problem,\n", "\n", "$$\n", " \\text{minimize} \\quad \\|Ax - b\\|_2^2\n", "$$\n", "\n", "parameterized by $m$-by-$n$ matrix $A$ and $m$-vector $b$. The output has closed-form solution\n", "\n", "$$\n", "\\begin{align*}\n", " x^\\star &= \\left(A^T \\! A\\right)^{-1} \\! A^T b \\\\\n", " &= R^{-1} Q^{T} b\n", "\\end{align*}\n", "$$\n", "\n", "where $A = QR$ is the QR decomposition of $A$." ] }, { "cell_type": "code", "execution_count": 1, "id": "75aafed8", "metadata": { "ExecuteTime": { "end_time": "2022-12-07T00:01:17.291352Z", "start_time": "2022-12-07T00:01:16.004171Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.2.0\n", "NVIDIA GeForce RTX 4090\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": [ "### Automatic Differentiation\n", "\n", "Since QR decomposition is differentiable we can simply produce a PyTorch function for solving the least-squares problem in the forward pass and allow `autograd` to automatically compute gradients in the backward pass." ] }, { "cell_type": "code", "execution_count": 2, "id": "74030c32", "metadata": { "ExecuteTime": { "end_time": "2022-12-07T00:01:17.306567Z", "start_time": "2022-12-07T00:01:17.293347Z" } }, "outputs": [], "source": [ "def solve_by_qr(A, b):\n", " \"\"\"Auto-differentiable solver for least squares by QR.\"\"\"\n", " B, M, N = A.shape\n", " assert b.shape == (B, M, 1)\n", "\n", " Q, R = torch.linalg.qr(A, mode='reduced')\n", " return torch.linalg.solve_triangular(R, torch.bmm(b.view(B, 1, M), Q).view(B, N, 1), upper=True)" ] }, { "cell_type": "markdown", "id": "9187cfd3", "metadata": {}, "source": [ "Indeed the PyTorch `torch.linalg.lstsq` function is itself auto differentiable." ] }, { "cell_type": "markdown", "id": "0f933f11", "metadata": { "ExecuteTime": { "end_time": "2022-12-06T23:19:16.976852Z", "start_time": "2022-12-06T23:19:16.959158Z" } }, "source": [ "### Custom Backward Pass\n", "\n", "We can develop a more efficient backward pass code by hand deriving the gradients.\n", "\n", "Consider differentiating $x^\\star$ with respect to single element $A_{ij}$, we have\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d}}{\\text{d} A_{ij}} x^\\star \n", "\t&= \\frac{\\text{d}}{\\text{d} A_{ij}} \\left(A^T \\! A\\right)^{-1} \\! A^T b \\\\\n", "\t&= \\left(\\frac{\\text{d}}{\\text{d} A_{ij}} \\left(A^T \\! A\\right)^{-1} \\right) A^T b + \\left(A^T \\! A\\right)^{-1} \\! \\left(\\frac{\\text{d}}{\\text{d} A_{ij}} A^T b\\right)\n", "\\end{align*}\n", "$$\n", "\n", "Now using the identity $\\frac{\\text{d}}{\\text{d} z} Z^{-1} = -Z^{-1} \\left(\\frac{\\text{d}}{\\text{d} z} Z\\right) Z^{-1}$ we get, for the first term,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d}}{\\text{d} A_{ij}} \\left(A^T \\! A\\right)^{-1} \n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\!\\left(\\frac{\\text{d}}{\\text{d} A_{ij}} \\left(A^T \\! A\\right) \\right) \\left(A^T \\! A\\right)^{-1} \\\\\n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\!\\left(E_{ij}^T A + A^T E_{ij}\\right) \\left(A^T \\! A\\right)^{-1}\n", "\\end{align*}\n", "$$\n", "\n", "where $E_{ij}$ is a matrix with one in the $(i,j)$-th element and zeros elsewhere. Furthermore, for the second term,\n", "\n", "$$\n", "\\begin{align}\n", "\t\\frac{\\text{d}}{\\text{d} A_{ij}} A^T b &= E_{ij}^T b\n", "\\end{align}\n", "$$\n", "\n", "\n", "Plugging these back into parent equation we have\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d}}{\\text{d} A_{ij}} x^\\star \n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\!\\left(E_{ij}^T A + A^T E_{ij}\\right) \\left(A^T \\! A\\right)^{-1} \\! A^T b + \\left(A^T \\! A\\right)^{-1} E_{ij}^T b\n", "\t\\\\\n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\!\\left(E_{ij}^T A + A^T E_{ij}\\right) x^\\star + \\left(A^T \\! A\\right)^{-1} E_{ij}^T b\n", "\t\\\\\n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\left( E_{ij}^T (Ax^\\star - b) + A^T E_{ij} x^\\star \\right)\n", "\t\\\\\n", "\t&= -\\left(A^T \\! A\\right)^{-1} \\left( (a_i^T x^\\star - b_i) e_j + x_j^\\star a_i \\right)\n", "\\end{align*}\n", "$$\n", "\n", "where $e_j = (0, 0, \\ldots, 1, 0, \\ldots) \\in \\mathbb{R}^n$ is the $j$-th canonical vector, i.e., vector with a one in the $j$-th component and zeros everywhere else, and $a_i^T \\in \\mathbb{R}^{1 \\times n}$ is the $i$-th row of matrix $A$.\n", "\n", "Observe that the term $(A^TA)^{-1}$ appears both in the solution for $x$ and the derivatives with respect to each $A_{ij}$. Thus, we only need to factor $A$ once in the forward pass and cache $R$ for use during the backward pass. This saves significant compute. Moreover, we can reuse terms for different $\\frac{\\text{d}}{\\text{d} A_{ij}}$ and efficiently combine with the incoming gradient of the loss with respect to $x^\\star$ as we now show.\n", "\n", "Let $r = b - Ax^\\star$ and let $v^T$ denote the backward coming gradient $\\frac{\\text{d}}{\\text{d} x^\\star} L$. Then\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\frac{\\text{d} L}{\\text{d} A_{ij}} &= v^T \\frac{\\text{d} x^\\star}{\\text{d} A_{ij}} \\\\\n", "\t&= v^T \\left(A^T \\! A\\right)^{-1} \\left( r_i e_j - x_j^\\star a_i \\right) \\\\\n", "\t&= w^T \\! \\left( r_i e_j - x_j^\\star a_i \\right) \\\\\n", "\t&= r_i w_j - w^T \\! a_i x_j^\\star\n", "\\end{align*}\n", "$$\n", "\n", "where $w = \\left(A^T \\! A\\right)^{-1}v$ does not depend on which $A_{ij}$ we are differentiating with respect to. We can therefore compute the entire matrix of $m \\times n$ derivatives efficiently as the sum of outer products\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\left(\\frac{\\text{d} L}{\\text{d} A}\\right)^{\\! T} = \\begin{bmatrix}\n", "\t\t\\displaystyle \\frac{\\text{d} L}{\\text{d} A_{ij}}\n", "\t\\end{bmatrix}_{\\substack{i=1, \\ldots, m \\\\ j=1, \\ldots, n}} &= rw^T - (Aw)(x^\\star)^T\n", "\\end{align*}\n", "$$\n", "\n", "We can also differentiate with respect to $b$, which is much simpler,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\left(\\frac{\\text{d} L}{\\text{d} b}\\right)^{\\! T} = Aw\n", "\\end{align*}\n", "$$\n", "\n", "The following code implement a PyTorch function with hand-coded backward pass. It is also available as ``BasicLeastSquaresFcn`` in the ``ddn.pytorch.leastsquares`` module." ] }, { "cell_type": "code", "execution_count": 3, "id": "f26d0fe7", "metadata": { "ExecuteTime": { "end_time": "2022-12-07T00:01:17.321277Z", "start_time": "2022-12-07T00:01:17.310472Z" } }, "outputs": [], "source": [ "class BasicLeastSquaresFcn(torch.autograd.Function):\n", " \"\"\"\n", " PyTorch autograd function for basic least squares problems,\n", "\n", " y = argmin_u \\|Au - b\\|^2\n", "\n", " solved via QR decomposition.\n", " \"\"\"\n", "\n", " @staticmethod\n", " def forward(ctx, A, b, cache_decomposition=True):\n", " B, M, N = A.shape\n", " assert b.shape == (B, M, 1)\n", "\n", " with torch.no_grad():\n", " Q, R = torch.linalg.qr(A, mode='reduced')\n", " x = torch.linalg.solve_triangular(R, torch.bmm(b.view(B, 1, M), Q).view(B, N, 1), upper=True)\n", "\n", " # save state for backward pass\n", " ctx.save_for_backward(A, b, x, R if cache_decomposition else None)\n", "\n", " # return solution\n", " return x\n", "\n", " @staticmethod\n", " def backward(ctx, dx):\n", " # check for None tensors\n", " if dx is None:\n", " return None, None\n", "\n", " # unpack cached tensors\n", " A, b, x, R = ctx.saved_tensors\n", " B, M, N = A.shape\n", "\n", " if R is None:\n", " Q, R = torch.linalg.qr(A, mode='r')\n", "\n", " dA, db = None, None\n", "\n", " w = torch.linalg.solve_triangular(R, torch.linalg.solve_triangular(torch.transpose(R, 2, 1), dx, upper=False), upper=True)\n", " Aw = torch.bmm(A, w)\n", "\n", " if ctx.needs_input_grad[0]:\n", " r = b - torch.bmm(A, x)\n", " dA = torch.bmm(r.view(B, M, 1), w.view(B, 1, N)) - torch.bmm(Aw.view(B, M, 1), x.view(B, 1, N))\n", " if ctx.needs_input_grad[1]:\n", " db = Aw\n", "\n", " # return gradients (None for non-tensor inputs)\n", " return dA, db, None" ] }, { "cell_type": "markdown", "id": "67ec8c1c-c573-4740-b34c-1ea88bc2f3ec", "metadata": {}, "source": [ "We also demonstrate how to use automatic differentiation to compute some terms in the derivative expression (although not really necessary for this problem)." ] }, { "cell_type": "code", "execution_count": 4, "id": "68dd6122-db74-49bf-89ca-c6301565e69e", "metadata": {}, "outputs": [], "source": [ "class BasicAutoDiffLeastSquaresFcn(BasicLeastSquaresFcn):\n", " \"\"\"PyTorch autograd function for basic least squares problems using automatic differentiation.\"\"\"\n", "\n", " @staticmethod\n", " def backward(ctx, dx):\n", " # check for None tensors\n", " if dx is None:\n", " return None, None\n", "\n", " # unpack cached tensors\n", " A, b, x, R = ctx.saved_tensors\n", " B, M, N = A.shape\n", " \n", " if R is None:\n", " Q, R = torch.linalg.qr(A, mode='r')\n", "\n", " # explicitly compute dLdg = v^T H^{-1}\n", " w = torch.linalg.solve_triangular(R, torch.linalg.solve_triangular(torch.transpose(R, 2, 1), dx, upper=False), upper=True)\n", " \n", " # implicitly compute dLdA and dLdb from dLdg and g = (d/dx)(objective)\n", " A_var = A.detach().requires_grad_(True)\n", " b_var = b.detach().requires_grad_(True)\n", " x_const = x.detach().requires_grad_(False)\n", "\n", " with torch.enable_grad():\n", " g = torch.bmm(A_var.transpose(1, 2), b_var - torch.bmm(A_var, x_const))\n", " dA, db = torch.autograd.grad(outputs=g, inputs=(A_var, b_var), grad_outputs=w, retain_graph=False)\n", "\t\t \n", " # return gradients (None for non-tensor inputs)\n", " return dA, db, None" ] }, { "cell_type": "markdown", "id": "36d1869b", "metadata": {}, "source": [ "### Profiling\n", "\n", "We profile the running time and memory required by the various implementations. Our test is to solve the bi-level optimisation problem,\n", "\n", "$$\n", "\\begin{align*}\n", "\t\\begin{array}{ll}\n", "\t\t\\text{minimize} & \\frac{1}{2} \\|x^\\star - x^{\\text{target}}\\|_2^2 \\\\\n", "\t\t\\text{subject to} & x^\\star = \\textrm{argmin}_{x} \\; \\|Ax - b\\|_2^2\n", "\t\\end{array}\n", "\\end{align*}\n", "$$\n", "\n", "by gradient descent for a fixed number of iterations." ] }, { "cell_type": "code", "execution_count": 5, "id": "d45dbb3f", "metadata": { "ExecuteTime": { "end_time": "2022-12-07T00:01:17.337230Z", "start_time": "2022-12-07T00:01:17.324267Z" } }, "outputs": [], "source": [ "import time\n", "import torch.profiler as profiler\n", "\n", "def do_profile(fcn, B, M, N, device=torch.device(\"cpu\"), seed=0, iters=1000, mem_iters=10):\n", " \"\"\"\n", " Profile implementation. Uses different number of itertions for memory profile\n", " and speed profiling since memory profiling is slow.\n", " \"\"\"\n", "\n", " torch.manual_seed(seed)\n", "\n", " A_true = torch.randn((B, M, N), device=device, requires_grad=False)\n", " b_true = torch.randn((B, M, 1), device=device, requires_grad=False)\n", " x_true = torch.linalg.lstsq(A_true, b_true, driver='gels').solution\n", " A_init = torch.randn((B, M, N), device=device, requires_grad=True)\n", "\n", " # profile time\n", " model = [torch.nn.Parameter(A_init.clone())]\n", " optimizer = torch.optim.AdamW(model, lr=1.0e-3)\n", " loss_trace = [None for i in range(iters)]\n", "\n", " time_start = time.monotonic()\n", " for i in range(len(loss_trace)):\n", " x = fcn(model[0], b_true)\n", "\n", " optimizer.zero_grad()\n", " loss = torch.nn.functional.mse_loss(x, x_true)\n", " loss_trace[i] = loss.item()\n", " loss.backward()\n", " optimizer.step()\n", "\n", " duration = time.monotonic() - time_start\n", "\n", " # profile memory\n", " model = [torch.nn.Parameter(A_init.clone())]\n", " optimizer = torch.optim.AdamW(model, lr=1.0e-3)\n", "\n", " with profiler.profile(profile_memory=True) as prof:\n", " for i in range(mem_iters):\n", " x = fcn(model[0], b_true)\n", "\n", " optimizer.zero_grad()\n", " loss = torch.nn.functional.mse_loss(x, x_true)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " if device == torch.device(\"cpu\"):\n", " memory = prof.key_averages().total_average().cpu_memory_usage\n", " else:\n", " memory = prof.key_averages().total_average().cuda_memory_usage\n", " prof.enabled = False\n", " \n", " return duration, memory, loss_trace" ] }, { "cell_type": "code", "execution_count": 6, "id": "90960f8e", "metadata": { "ExecuteTime": { "end_time": "2022-12-07T00:02:45.600798Z", "start_time": "2022-12-07T00:01:17.339227Z" } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", "def plot_profiling(device=torch.device(\"cpu\")):\n", "\n", " # implementations to profile\n", " if device == torch.device(\"cpu\"):\n", " f_array = [\n", " lambda A, b: torch.linalg.lstsq(A, b, driver='gels').solution, # auto-diff torch least-squares solver\n", " solve_by_qr, # auto-diff solve by QR decomposition\n", " BasicLeastSquaresFcn.apply, # custom diff cache QR decomposition\n", " lambda A, b: BasicLeastSquaresFcn.apply(A, b, False), # custom diff recompute QR decomposition\n", " BasicAutoDiffLeastSquaresFcn.apply # custom diff using AD\n", " ]\n", " f_legend = ['torch.lstsq', 'autograd QR', 'custom QR', 'custom QR (no cache)', 'custom via AD']\n", " styles = ['--', ':', '-', '-.', (0, (3, 5, 1, 5, 1, 5))]\n", " colours = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#800080']\n", " batch_size = 1\n", " iters = 1000\n", " \n", " else:\n", " f_array = [\n", " solve_by_qr, # auto-diff solve by QR decomposition\n", " BasicLeastSquaresFcn.apply, # custom diff cache QR decomposition\n", " lambda A, b: BasicLeastSquaresFcn.apply(A, b, False), # custom diff recompute QR decomposition\n", " BasicAutoDiffLeastSquaresFcn.apply # custom diff using AD \n", " ]\n", " f_legend = ['autograd QR', 'custom QR', 'custom QR (no cache)', 'custom via AD']\n", " styles = [':', '-', '-.', (0, (3, 5, 1, 5, 1, 5))]\n", " colours = ['#ff7f0e', '#2ca02c', '#d62728', '#800080']\n", " batch_size = 128\n", " iters = 100\n", " \n", " runtime = [[] for i in range(len(f_array))]\n", " memused = [[] for i in range(len(f_array))]\n", " endloss = [[] for i in range(len(f_array))]\n", "\n", " N_array = [100, 200, 300, 400, 500]\n", " \n", " for N in N_array:\n", " print(\"...running on size {}-by-{}\".format(2*N, N))\n", " for i in range(len(f_array)):\n", " t, m, loss = do_profile(f_array[i], batch_size, 2 * N, N, device=device, iters=iters)\n", " runtime[i].append(t)\n", " memused[i].append(m)\n", " endloss[i].append(loss[-1])\n", "\n", " for i in range(len(f_array)):\n", " print(\"time: {}\\n mem: {}\\nloss: {}\".format(runtime[i], memused[i], endloss[i]))\n", "\n", " plt.figure()\n", " for i in range(len(f_array)):\n", " plt.plot(N_array, runtime[i], linestyle=styles[i], color=colours[i])\n", " plt.xlabel('problem size (2n-by-n)', fontsize=12)\n", " plt.ylabel('running time (seconds)', fontsize=12)\n", " plt.title('Running time on {} with batch size {}'.format(device, batch_size))\n", " plt.legend(f_legend, fontsize=12)\n", " #plt.savefig(\"ls_runtime_{}.png\".format(device), dpi=300, bbox_inches='tight')\n", "\n", " plt.figure()\n", " for i in range(len(f_array)):\n", " plt.plot(N_array, [m / (1024 * 1024) for m in memused[i]], linestyle=styles[i], color=colours[i])\n", " plt.xlabel('problem size (2n-by-n)', fontsize=12)\n", " plt.ylabel('memory used (MB)', fontsize=12)\n", " plt.title('Memory usage on {} with batch size {}'.format(device, batch_size))\n", " #plt.savefig(\"ls_memory_{}.png\".format(device), dpi=300, bbox_inches='tight')\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "514126b8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "...running on size 200-by-100\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 400-by-200\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 600-by-300\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 800-by-400\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 1000-by-500\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "time: [1.7260210189999725, 4.557886900999961, 10.210909276000052, 18.88681051100002, 32.31588743400005]\n", " mem: [36146294, 142050679, 310347352, 555262681, 874397943]\n", "loss: [1.1333455007811466e-10, 3.4009645794030874e-11, 1.6922433940247394e-11, 1.1042094322233353e-11, 9.083799684672655e-12]\n", "time: [0.8434276509999563, 1.552925862000052, 2.550825646000021, 4.8124364359999845, 8.678068538999923]\n", " mem: [16387452, 64381972, 146961488, 273747916, 418311848]\n", "loss: [1.132792054603371e-10, 3.398326411940822e-11, 1.69390057536134e-11, 1.1052428069979747e-11, 9.079023990943291e-12]\n", "time: [0.7377762180000218, 1.1948615499999278, 1.750510011000074, 3.3644949770000494, 5.283107986999994]\n", " mem: [8923772, 34856216, 78456104, 136956956, 215223008]\n", "loss: [1.1320665932457175e-10, 3.399408185500441e-11, 1.6918312237268474e-11, 1.1039472287699414e-11, 9.070240218622683e-12]\n", "time: [0.8947231700000202, 1.5831238719999874, 2.4946875680000176, 4.737828183999909, 8.076741408999965]\n", " mem: [13464716, 52415980, 114164556, 210186780, 327092608]\n", "loss: [1.1320665932457175e-10, 3.399408185500441e-11, 1.6918312237268474e-11, 1.1039472287699414e-11, 9.070240218622683e-12]\n", "time: [0.816548752000017, 1.3190117049999799, 1.8435166710000885, 3.3968830659999867, 5.300165514000014]\n", " mem: [10563540, 43187400, 92636296, 169259788, 258905088]\n", "loss: [1.1320665932457175e-10, 3.399408185500441e-11, 1.6918312237268474e-11, 1.1039472287699414e-11, 9.070240218622683e-12]\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAHGCAYAAABjORGMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuYdJREFUeJzs3Xd8zdf/wPHXzbrZmwwkMWKLvWeEGqFVVFGrdCj6raJVWhXaUqo61OiwWooObbWKGkHV3q2tEjMJksheN/f8/sgvt64MuSRuwvv5eNxHe8/nfD6f971yc985U6OUUgghhBBClGEW5g5ACCGEEOJ+SUIjhBBCiDJPEhohhBBClHmS0AghhBCizJOERgghhBBlniQ0QgghhCjzJKERQgghRJknCY0QQgghyjxJaIQQQghR5klCI4rNsmXL0Gg0hoeVlRU+Pj7079+fc+fOmTs8IxqNhrCwsAd+39TUVMLCwti+fXueY7nvX2Rk5AOPS9y/gIAAhg0bZnh+7do1wsLCOHr0aJ66w4YNw9HR8b7u1aNHj3s+Pz8zZszg559/vqdzt2/fjkaj4YcffijWmG43bNgwAgICSuz6+bly5Qpjx46lffv2uLq6otFoWLZs2QONQRSdJDSi2C1dupQ9e/awZcsWxowZw7p162jTpg3x8fHmDs1gz549PPfccw/8vqmpqUybNi3fhCY0NJQ9e/bg4+PzwOMS9++nn35iypQphufXrl1j2rRp+SY0pdH9JDQPwpQpU/jpp58e6D3Pnz/PypUrsbGxoXv37g/03sJ0VuYOQDx86tatS5MmTQDo0KED2dnZTJ06lZ9//plnn33WzNHlaNGihblDyKNcuXKUK1fO3GGIe9SwYUNzh/BQq1q16gO/Z7t27bhx4wYABw8eZNWqVQ88BlF00kIjSlxuchMTE2Mo69ChAx06dMhT985m5cjISDQaDXPmzGHu3LlUrlwZR0dHWrZsyd69e/Oc6+joyPnz5+nevTuOjo5UqlSJ8ePHk5GRYVT3zi6n3O6e8PBwXnrpJTw9PfHw8KB3795cu3bN6NyMjAzGjx+Pt7c39vb2tGvXjkOHDuXpcrhTZGSkIWGZNm2aoWsu95z8upw6dOhA3bp12bNnD61atcLOzo6AgACWLl0KwPr162nUqBH29vbUq1ePjRs35rnvuXPnGDhwIOXLl0er1VKrVi3mz59fYJy3S09PZ9KkSVSuXBkbGxsqVKjA6NGjuXXrllG93C6QjRs30qhRI+zs7KhZsyZLliwp0n0yMjKYPn06tWrVwtbWFg8PD4KDg9m9e7ehjkajYcyYMXz++edUr14drVZL7dq1Wb16tdG1wsLC0Gg0ee5RlC699evXo9FoOHDggKHsxx9/RKPREBoaalQ3KCiIPn36GL0Huf+W27dvp2nTpgA8++yzhn/rO7s5i/KzWpiffvqJoKAgbG1tqVKlCp9++qnR8fT0dMaPH0+DBg1wcXHB3d2dli1b8ssvvxjV02g0pKSksHz5ckOst38+r169ygsvvEClSpWwsbHB19eXvn37Gn2mAbKysnjzzTfx9fXF2dmZTp06cebMmbu+jhs3bhiur9VqKVeuHK1bt2bLli2GOnf+bsj9d87vcfvnMDMzk3fffZeaNWsarv3ss88aEpXCWFjIV2RZIi00osRFREQAUL169Xu+xvz586lZsyYff/wxkNP83L17dyIiInBxcTHUy8rK4vHHH2fEiBGMHz+enTt38s477+Di4sLbb7991/s899xzhIaG8u2333L58mVee+01Bg0axLZt2wx1nn32WdasWcPrr79Ox44dOXnyJE8++SSJiYmFXtvHx4eNGzfStWtXRowYYejyulurTHR0NM8++yyvv/46FStWZN68eQwfPpzLly/zww8/MHnyZFxcXJg+fTq9evXiwoUL+Pr6AnDy5ElatWqFn58fH374Id7e3mzatIn//e9/3Lx5k6lTpxZ4X6UUvXr1YuvWrUyaNIm2bdty/Phxpk6dyp49e9izZw9ardZQ/9ixY4wfP5433ngDLy8vvvrqK0aMGEG1atVo165dgffR6XR069aNP//8k7Fjx9KxY0d0Oh179+7l0qVLtGrVylB33bp1hIeHM336dBwcHFiwYAEDBgzAysqKvn37Fvo+FkX79u2xtrZmy5YthoRky5Yt2NnZsWPHDrKysrC2tub69ev8888/vPTSS/lep1GjRixdupRnn32Wt956y5AMVaxY0VDnfn9Wjx49ytixYwkLC8Pb25uVK1fyyiuvkJmZyYQJE4CcRDEuLo4JEyZQoUIFMjMz2bJlC71792bp0qUMGTIEyOmC7dixI8HBwYZuM2dnZyAnmWnatClZWVlMnjyZoKAgYmNj2bRpE/Hx8Xh5eRlimjx5Mq1bt+arr74iMTGRiRMn0rNnT06dOoWlpWWBr2Xw4MEcPnyY9957j+rVq3Pr1i0OHz5MbGxsgec899xzdO3a1ahs7dq1fPDBB9SpUwcAvV7PE088wZ9//snrr79Oq1atuHjxIlOnTqVDhw4cPHgQOzu7u77XooxQQhSTpUuXKkDt3btXZWVlqaSkJLVx40bl7e2t2rVrp7Kysgx127dvr9q3b5/nGkOHDlX+/v6G5xEREQpQ9erVUzqdzlC+f/9+BahVq1YZnQuo7777zuia3bt3VzVq1DAqA9TUqVPzxD5q1CijerNnz1aAioqKUkopdeLECQWoiRMnGtVbtWqVAtTQoUMLfY9u3LiR5953xhAREWEoa9++vQLUwYMHDWWxsbHK0tJS2dnZqatXrxrKjx49qgD16aefGsq6dOmiKlasqBISEozuNWbMGGVra6vi4uIKjHXjxo0KULNnzzYqX7NmjQLUF198YSjz9/dXtra26uLFi4aytLQ05e7url588cWC3xCl1Ndff60A9eWXXxZaD1B2dnYqOjraUKbT6VTNmjVVtWrVDGVTp05V+f1qy+/9zU+bNm1Ux44dDc+rVaumXnvtNWVhYaF27NihlFJq5cqVClBnz5411PP39zf69z9w4IAC1NKlS/Pcw5Sf1fz4+/srjUajjh49alTeuXNn5ezsrFJSUvI9T6fTqaysLDVixAjVsGFDo2MODg75/vwOHz5cWVtbq5MnTxYYT3h4uAJU9+7djcq/++47Bag9e/YU+nocHR3V2LFjC61z5++GO/3555/K1tZWPfPMM0qv1yul/vtc/vjjj0Z1c/9tFixYUOg98zsnv39PUTpIe5oodi1atMDa2honJye6du2Km5sbv/zyC1ZW994gGBoaavQXXlBQEAAXL140qqfRaOjZs6dRWVBQUJ56BXn88cfznHv7fXbs2AFAv379jOr17dv3vl5fYXx8fGjcuLHhubu7O+XLl6dBgwaGlhiAWrVqGcWanp7O1q1befLJJ7G3t0en0xke3bt3Jz09PU+33e1yW6Xu7EZ76qmncHBwYOvWrUblDRo0wM/Pz/Dc1taW6tWr3/W937BhA7a2tgwfPrzQegAhISFGLQKWlpY8/fTTnD9/nitXrtz1/KIICQnhr7/+Ii0tjYsXL3L+/Hn69+9PgwYN2Lx5M5DTauPn50dgYOA93+d+f1br1KlD/fr1jcoGDhxIYmIihw8fNpR9//33tG7dGkdHR6ysrLC2tmbx4sWcOnWqSPfZsGEDwcHBhp+vwtzt81OQZs2asWzZMt5991327t1LVlZWkWLLderUKR5//HFatWrFkiVLDF2Ov/32G66urvTs2dPo579BgwZ4e3vnOzhflF2S0Ihi9/XXX3PgwAG2bdvGiy++yKlTpxgwYMB9XdPDw8PoeW5XR1pamlG5vb09tra2eeqmp6cXy31ym8Bv/1IFsLKyynNucXF3d89TZmNjk6fcxsYGwPBaY2Nj0el0zJs3D2tra6NH7oyNmzdvFnjf2NhYrKys8nSJaTQavL2983QH5Pf6tVptnn+jO924cQNfX98ijVfw9vYusKyw7glTdOrUiYyMDHbt2sXmzZvx9PSkYcOGdOrUyTCmY+vWrXTq1Om+7nO/P6tFeS/Wrl1Lv379qFChAitWrGDPnj0cOHCA4cOHF/k+N27cMOoqK0xRP6d3WrNmDUOHDuWrr76iZcuWuLu7M2TIEKKjo+96z2vXrtG1a1cqVqzI2rVrDZ8DyBm3d+vWLWxsbPJ8BqKjowv9+Rdlj4yhEcWuVq1ahoHAwcHBZGdn89VXX/HDDz8YxjnY2tqSkJCQ59zS/gsm9xd2TEwMFSpUMJTrdLpi+0ItLm5ublhaWjJ48GBGjx6db53KlSsXeL6Hhwc6nY4bN24YJTVKKaKjow1jTO5XuXLl2LVrF3q9/q5JTX5fcLlluf82uUlCRkaG0Rifov5sNW/eHEdHR7Zs2UJkZCQhISFoNBpCQkL48MMPOXDgAJcuXbrvhOZ+FeW9WLFiBZUrV2bNmjVGA6VNGXhcrly5Ymv9Koinpycff/wxH3/8MZcuXWLdunW88cYbXL9+Pd+B7rkSExPp3r07er2e33//3Wg8Xe51PTw8CryGk5NTsb4OYV7SQiNK3OzZs3Fzc+Ptt99Gr9cDOTNCzp49a/SLNTY21mhWS2mUO7h1zZo1RuU//PADOp3urucX9S/W4mBvb09wcDBHjhwhKCiIJk2a5HkU1qoUEhIC5Hwp3u7HH38kJSXFcPx+devWjfT09CItWLZ161ajmTXZ2dmsWbOGqlWrGloRcmfCHD9+3OjcX3/9tUjxWFtb065dOzZv3sy2bdvo3LkzAG3btsXKyoq33nrLkOAUpqT/rU+cOMGxY8eMyr799lucnJxo1KgRkNOaZmNjY5TMREdH55nllBtvfrF269aN8PDwIs1WKg5+fn6MGTOGzp07G3Wd3SkzM5Mnn3ySyMhINmzYkG8rUo8ePYiNjSU7Ozvfn/8aNWqU5EsRD5i00IgS5+bmxqRJk3j99df59ttvGTRoEIMHD+bzzz9n0KBBPP/888TGxjJ79mzDzIrSqk6dOgwYMIAPP/wQS0tLOnbsyIkTJ/jwww9xcXG5awuDk5MT/v7+/PLLL4SEhODu7o6np2eJrYD6ySef0KZNG9q2bctLL71EQEAASUlJnD9/nl9//dVo9tadOnfuTJcuXZg4cSKJiYm0bt3aMMupYcOGDB48uFhiHDBgAEuXLmXkyJGcOXOG4OBg9Ho9+/bto1atWvTv399Q19PTk44dOzJlyhTDLKfTp08bTd3u3r077u7ujBgxgunTp2NlZcWyZcu4fPlykWMKCQlh/PjxAIaWGDs7O1q1asUff/xBUFAQ5cuXL/QaVatWxc7OjpUrV1KrVi0cHR3x9fU1Gvd0P3x9fXn88ccJCwvDx8eHFStWsHnzZmbNmoW9vT2Q84W+du1aRo0aRd++fbl8+TLvvPMOPj4+eVbvrlevHtu3b+fXX3/Fx8cHJycnatSowfTp09mwYQPt2rVj8uTJ1KtXj1u3brFx40bGjRtHzZo17+t1JCQkEBwczMCBA6lZsyZOTk4cOHCAjRs30rt37wLPe/XVV9m2bRszZswgOTnZaDxYuXLlqFq1Kv3792flypV0796dV155hWbNmmFtbc2VK1cIDw/niSee4Mknnyw0vtzVjy9cuADkrEeTu8pzccysE8XI3KOSxcMjdxbJgQMH8hxLS0tTfn5+KjAw0DBbafny5apWrVrK1tZW1a5dW61Zs6bAWU4ffPBBnmtyx2yhoUOHKgcHhzz18pv1cue5BcWeO3sjPDzcUJaenq7GjRunypcvr2xtbVWLFi3Unj17lIuLi3r11VcLe4uUUkpt2bJFNWzYUGm1WqOZUQXNcqpTp06ea/j7+6vQ0NA85YAaPXq0UVlERIQaPny4qlChgrK2tlblypVTrVq1Uu++++5dY01LS1MTJ05U/v7+ytraWvn4+KiXXnpJxcfHFymegmaz5Xeft99+WwUGBiobGxvl4eGhOnbsqHbv3p3ntS1YsEBVrVpVWVtbq5o1a6qVK1fmud7+/ftVq1atlIODg6pQoYKaOnWq+uqrr4o0y0kppY4dO6YAFRgYaFT+3nvvKUCNGzcuzzl3znJSKmeWTc2aNZW1tbXRz5wpP6v5yX2/f/jhB1WnTh1lY2OjAgIC1Ny5c/PUff/991VAQIDSarWqVq1a6ssvv8z3PkePHlWtW7dW9vb2CjD6d7t8+bIaPny48vb2VtbW1srX11f169dPxcTEKKX++5x8//33RtfM/fwWNjMoPT1djRw5UgUFBSlnZ2dlZ2enatSooaZOnWo0W+vO3w25MwDze9z+75CVlaXmzJmj6tevr2xtbZWjo6OqWbOmevHFF9W5c+fu+l4XdA/5+ix9NEopVeJZkxAPud27d9O6dWtWrlzJwIEDzR3OQ0mj0TB69Gg+++wzc4cihCiFpMtJCBNt3ryZPXv20LhxY+zs7Dh27Bjvv/8+gYGBhTaRCyGEKDmS0AhhImdnZ/744w8+/vhjkpKS8PT0pFu3bsycOTPPNFwhhBAPhnQ5CSGEEKLMk2nbQgghhCjzJKERQgghRJknCY0QQgghyrxHYlCwXq/n2rVrODk5Ga2YKYQQQojSSylFUlJSkfZ7eyQSmmvXrlGpUiVzhyGEEEKIe3D58uW7bpL6SCQ0uRuQXb58udQvrS+EEEKIHImJiVSqVKlIG4k+EglNbjeTs7OzJDRCCCFEGVOU4SIyKFgIIYQQZZ4kNEIIIYQo8yShEUIIIUSZJwmNEEIIIcq8R2JQsKmysrLIzs42dxhCiHtgbW2NpaWlucMQQjxgktDcJjExkZs3b5KRkWHuUIQQ90ij0eDi4oK3t7cspCnEI0QSmv+XmJjI1atXcXR0xNPTE2tra/llKEQZo5QiJSWFGzduYGdnh6urq7lDEkI8IJLQ/L+bN2/i6OhIxYoVJZERogyzs7MjIyOD69ev4+LiIp9nIR4RMiiYnDEzGRkZ8stPiIeEs7Mz2dnZMhZOiEeIJDRg+KVnbW1t5kiEEMXByiqn8Vmn05k5EiHEgyIJzW2kdUaIh4N8loV49EhCI4QQQogyTxKaR8Du3bsJCwvj1q1bD/zekZGRaDQa5syZc0/nb9++HY1Gw/bt2006b8GCBSxbtuye7imEEKLskYTmEbB7926mTZtmloTGXCShEUKIR4skNOKepKammjsEIYQQZrb9zHX+vpJg7jAASWgeemFhYbz22msAVK5cGY1GY+jC0ev1zJ49m5o1a6LVailfvjxDhgzhypUrRtfo0KEDdevWZefOnbRq1Qp7e3uGDx8OwK1btxg/fjxVqlQxXKN79+6cPn06Tyxz586lcuXKODo60rJlS/bu3XtPr+nChQv0798fX19ftFotXl5ehISEcPToUQACAgI4ceIEO3bsMLzegIAAAPR6Pe+++y41atQwLLwWFBTEJ598YnSP9evX06BBA7RaLZUrV2bOnDmEhYXJYFMhhPh//95IZsy3R+izaDeHL8WbOxxZWK8oUjMLnvppodFga21Z4nXv1XPPPUdcXBzz5s1j7dq1+Pj4AFC7dm1eeuklvvjiC8aMGUOPHj2IjIxkypQpbN++ncOHD+Pp6Wm4TlRUFIMGDeL1119nxowZWFhYkJSURJs2bYiMjGTixIk0b96c5ORkdu7cSVRUFDVr1jScP3/+fGrWrMnHH38MwJQpU+jevTsRERG4uLiY9Jq6d+9OdnY2s2fPxs/Pj5s3b7J7925Dl9pPP/1E3759cXFxYcGCBQBotVoAZs+eTVhYGG+99Rbt2rUjKyuL06dPG3XHbd26lSeeeIKWLVuyevVqw71iYmJMffuFEOKhlJyhY+Q3h0jO0NEswJ16FUz7PV4SJKEpgtpvbyrwWHCNcix9tpnheeN3tpCWlf9iXs0ru7PmxZaG521mhROXkplv3aCKLqwb0+YeI/5PxYoV8fPzA6Bhw4aGlorTp0/zxRdfMGrUKObNm2eo37BhQ5o3b85HH33Ee++9ZyiPi4vj+++/p2PHjoayd955hxMnTrB582Y6depkKO/du3eeOJycnPjtt98Mmwb6+vrSrFkzNmzYQP/+/Yv8emJjYzlz5gwff/wxgwYNyveeDRs2xM7ODmdnZ1q0aGF0/l9//UW9evUICwszlHXp0sWozptvvomXlxebN2/G1tbWUCf3vRNCiEeZUorXfzjGuevJeDlr+eyZhlhbmr/Dx/wRCLMIDw8HYNiwYUblzZo1o1atWmzdutWo3M3NzSiZAdiwYQPVq1c3SmYKEhoaarQDclBQEAAXL140KW53d3eqVq3KBx98wNy5czly5Ah6vb7I5zdr1oxjx44xatQoNm3aRGJiotHxlJQUDhw4QO/evQ3JDOQkZD179jQpViGEeBh9sfMCv/8djbWlhgXPNKa8k+3dT3oApIWmCE5O71LgMYs7xlQcmlLwl/uddXdNDC5y3eIWGxsLYOiCup2vr2+eRCO/ejdu3DC0/tyNh4eH0fPcLqC0tLQinZ9Lo9GwdetWpk+fzuzZsxk/fjzu7u4888wzvPfeezg5ORV6/qRJk3BwcGDFihUsWrQIS0tL2rVrx6xZs2jSpAnx8fHo9Xq8vb3znJtfmRBCPEr+On+TWRtzxkhO7VmHxv5uZo7oP9JCUwT2NlYFPu4c51JSdYtbboIRFRWV59i1a9eMxs9A/iuvlitXLs8A4gfB39+fxYsXEx0dzZkzZ3j11VdZsGCBYfBzYaysrBg3bhyHDx8mLi6OVatWcfnyZbp06UJqaipubm5oNBqio6PznJtfmRBCPEp+PHwFvYKnGlfkmeZF+4P2QZGE5hGQX2tIbvfRihUrjOoeOHCAU6dOERISctfrduvWjbNnz7Jt27ZijNY01atX56233qJevXocPnzYUK7Vau/a+uPq6krfvn0ZPXo0cXFxREZG4uDgQLNmzVi7di3p6emGuklJSfz6668l9jqEEKIsmNO3Pu/0qss7veqWulmf0uX0CKhXrx4An3zyCUOHDsXa2poaNWrwwgsvMG/ePCwsLOjWrZthllOlSpV49dVX73rdsWPHsmbNGp544gneeOMNmjVrRlpaGjt27KBHjx4EBxfcpZafr7/+muHDh7NkyRKGDBmSb53jx48zZswYnnrqKQIDA7GxsWHbtm0cP36cN954w+g1r169mjVr1lClShVsbW2pV68ePXv2pG7dujRp0oRy5cpx8eJFPv74Y/z9/QkMDARyBjt37dqVzp07M378eLKzs5k1axYODg7ExcWZ9JqEEKKsU0oBOS31FhYaBrfwN3NE+ZOE5hHQoUMHJk2axPLly/nyyy/R6/WEh4ezcOFCqlatyuLFi5k/fz4uLi507dqVmTNn5hnzkh8nJyd27dpFWFgYX3zxBdOmTcPNzY2mTZvywgsvmBynXq8nOzu70EG+3t7eVK1alQULFnD58mU0Gg1VqlThww8/5OWXXzbUmzZtGlFRUTz//PMkJSXh7+9PZGQkwcHB/Pjjj3z11VckJibi7e1N586dmTJlimG39c6dO/Pzzz/z1ltv8fTTT+Pt7c2oUaNIS0tj2rRpJr8uIYQoy77df4kjl27xbq+6JT4c4n5oVG7q9RBLTEzExcWFhIQEnJ2d8xxPT08nIiKCypUrG81sEeJ2YWFhTJs2jUfgI1PmyWdaiOJx+FI8T3++h6xsxaw+9Xi66YMdN3O37+/byRgaIYQQQuRxIymDl1YcIitb0a2uN/2aVDJ3SIWShEYIIYQQRrKy9Yz+9jAxiRlULefAB0/VL3WDgO8kCY0QRRQWFibdTUKIR8LM30+zPyIOR60Vnw9ugqO29A+5lYRGCCGEEAa/HL3Kkr8iAJjzVH2qlXc0c0RFU/pTLiGEEEI8MB4OWlztrXmmuR9d65adFdIloRFCCCGEQZtATza+0o5yTlpzh2IS6XISQgghHnF6veLqrf9WV/d2scXSonQPAr6TJDRCCCHEI+7jrefo+vFOtp6KMXco90y6nIQQQohH2JaTMXy69RwACWlZZo7m3pm9hWbhwoUEBQXh7OyMs7MzLVu2ZMOGDYbjSinCwsLw9fXFzs6ODh06cOLECTNGLIQQQjwcIm6m8OqaowAMbelP70YVzRvQfTB7QlOxYkXef/99Dh48yMGDB+nYsSNPPPGEIWmZPXs2c+fO5bPPPuPAgQOGvXeSkpLMHLkQQghRdqVk6Hjxm4MkZeho4u/Gm6G1zR3SfTF7QtOzZ0+6d+9O9erVqV69Ou+99x6Ojo7s3bsXpRQff/wxb775Jr1796Zu3bosX76c1NRUvv32W3OH/kj79ttv+fjjj80dxn1btmwZGo2GyMjIItXfuHEjoaGhlCtXDq1Wi5+fH88++yxnzpzJUzcsLAyNRmN4WFtb4+fnx/PPP090dHQxvxIhhCg6pRSv/3icszHJlHPSsuCZRthYmT0luC+lKvrs7GxWr15NSkoKLVu2JCIigujoaB577DFDHa1WS/v27dm9e7cZIxUPS0Jjitdff51u3bqh1+tZsGABmzdv5u2332bfvn00bNiQ3377Ld/zNm7cyJ49e9iwYQP9+/dnyZIlhISEkJVVdvuqhRBl209HrrL+eBRWFhoWPtOI8s5lfxPXUjEo+O+//6Zly5akp6fj6OjITz/9RO3atQ1Ji5eXl1F9Ly8vLl68WOD1MjIyyMjIMDxPTEwsmcCF2aSmpmJvb//A7rdq1So++OADXnrpJRYsWGAob9euHQMGDKB9+/YMHDiQf/75Bz8/491oGzdujKenJwCdOnXi5s2bLF26lF27dhEcHPzAXoMQQuTqEeTLkUu3qFbekSYB7uYOp1iUihaaGjVqcPToUfbu3ctLL73E0KFDOXnypOH4nRtiKaUK3SRr5syZuLi4GB6VKpXuHUJL2vnz53n22WcJDAzE3t6eChUq0LNnT/7++2+jegV1v2zfvh2NRsP27dsB6NChA+vXr+fixYtGXSq54uLiGDVqFBUqVMDGxoYqVarw5ptvGiWZALdu3WLEiBG4u7vj6OhIaGgoFy5cQKPREBYWZqiX23Vz+PBh+vbti5ubG1WrVgXg4MGD9O/fn4CAAOzs7AgICGDAgAH5Jrx79+6ldevW2Nra4uvry6RJk4rcSvLee+/h5ubGnDlz8hxzcHBg3rx5JCUlFanVqkmTJgDExJTd6ZFCiLLNxsqCd3rVZWirAHOHUmxKRQuNjY0N1apVA3J+2R84cIBPPvmEiRMnAhAdHY2Pj4+h/vXr1/O02txu0qRJjBs3zvA8MTHx/pKazJSc/1rbQ+4Xty4T9FlgYQVW2rx1rezA4v/zxewsyM4EjSVY295b3ftw7do1PDw8eP/99ylXrhxxcXEsX76c5s2bc+TIEWrUqGHS9RYsWMALL7zAv//+y08//WR0LD09neDgYP7991+mTZtGUFAQf/75JzNnzuTo0aOsX78eAL1eT8+ePTl48CBhYWE0atSIPXv20LVr1wLv27t3b/r378/IkSNJScl57yIjI6lRowb9+/fH3d2dqKgoFi5cSNOmTTl58qShZeTkyZOEhIQQEBDAsmXLsLe3Z8GCBUUaixUVFcWJEyd4+umnC2wVatmyJeXLl2fTpk13vV5ERM4eKdWrV79rXSGEKC7pWdms2n+JwS38sbIsFe0ZxUuVQh07dlRDhw5Ver1eeXt7q1mzZhmOZWRkKBcXF7Vo0aIiXy8hIUEBKiEhId/jaWlp6uTJkyotLS3/C0x1znkk3/ivbMfsnLJfxhjXfdc7pzwu8r+y3fNzyn4YYVx3VuWc8piT/5UdXJpT9u2AIr8+U+l0OpWZmakCAwPVq6++aihfunSpAlRERIRR/fDwcAWo8PBwQ1loaKjy9/fPc+1FixYpQH333XdG5bNmzVKA+uOPP5RSSq1fv14BauHChUb1Zs6cqQA1depUQ9nUqVMVoN5+++0ivbbk5GTl4OCgPvnkE0P5008/rezs7FR0dLRR3Zo1a+b7mm+3d+9eBag33nij0Hs3b95cOTg45Ik7OjpaZWVlqfj4ePXdd98pBwcHNWBAyf37iiJ8poV4BE384Zjyn/ibGrXikLlDKbK7fX/fzuwp2uTJk/nzzz+JjIzk77//5s0332T79u0888wzaDQaxo4dy4wZM/jpp5/4559/GDZsGPb29gwcONDcoZcZOp2OGTNmULt2bWxsbLCyssLGxoZz585x6tSpYr3Xtm3bcHBwoG/fvkblw4YNA2Dr1q0A7NixA4B+/foZ1RswYECB1+7Tp0+esuTkZCZOnEi1atWwsrLCysoKR0dHUlJSjF5beHg4ISEhRi17lpaWPP3006a9wEKoArpCvb29sba2xs3NjX79+tG4cWOWL19ebPcVQoi7WbX/EqsPXEajgaebPpzDMMze5RQTE8PgwYOJiorCxcWFoKAgNm7cSOfOnYGcmSVpaWmMGjWK+Ph4mjdvzh9//IGTk9ODC3LytZz/Wt/W3dDqFWgxKqfL6Xavnc/5r5Xdf2XNnofGQ3O6kW439u+8dRs8A/Weylv3PowbN4758+czceJE2rdvj5ubGxYWFjz33HOkpaXd/QImiI2NxdvbO88Xe/ny5bGysiI2NtZQz8rKCnd348FohXUl3t7tmGvgwIFs3bqVKVOm0LRpU5ydndFoNHTv3t3oteXGdaf8yu6UO8g3t6uoIBcvXsy3a3PLli24uLgQFxfHF198wY8//sjLL7/MokWL7npvIYS4X0cv32LqLzlru014rAbtqpczc0Qlw+wJzeLFiws9njtA9PZBog+cjUPeMisbwKZodS2tcx73U/c+rFixgiFDhjBjxgyj8ps3b+Lq6mp4bmubM2bnzsG7N2/eLPK9PDw82LdvX57WiuvXr6PT6QxjWjw8PNDpdMTFxRklNYWtz3JnkpSQkMBvv/3G1KlTeeONNwzlGRkZxMXF5Ykrv2sXZT0YHx8f6tatyx9//FHg7Ko9e/YQExOTp2UKoH79+obX3blzZ7p06cIXX3zBiBEjaNq06V3vL4QQ9+pmcgYvrThEZraeLnW8GNWhqrlDKjFm73ISJU+j0aDVGm8Dv379eq5evWpUFhAQAMDx48eNytetW5fnmlqtNt/WnZCQEJKTk/n555+Nyr/++mvDcYD27dsDsGbNGqN6q1evvsur+Y9Go0Eplee1ffXVV2RnZxuVBQcHs3XrVqOZRdnZ2XnuX5A333yT+Ph4JkyYkOdYSkoK//vf/7CxsWHUqFF3jXn+/PlYWlry1ltvFeneQghxL3TZesZ8e5iohHSqlHNgzlP1C50hXNaZvYVGlLwePXqwbNkyatasSVBQEIcOHeKDDz6gYkXjPTuaNm1KjRo1mDBhAjqdDjc3N3766Sd27dqV55r16tVj7dq1LFy4kMaNG2NhYUGTJk0YMmQI8+fPZ+jQoURGRlKvXj127drFjBkz6N69O506dQKga9eutG7dmvHjx5OYmEjjxo3Zs2ePIfGxsLh7ru3s7Ey7du344IMP8PT0JCAggB07drB48WKjlieAt956i3Xr1tGxY0fefvtt7O3tmT9/vmG21N3079+fQ4cOMWfOHCIjIxk+fDheXl6cOXOGjz76iNOnT7N48WJq17770uGBgYG88MILLFiwgF27dtGmTZsixSCEEKY4HZ3EscsJONhY8sXgxjjZFm/rf6lT0iOUS4P7nuVUxsXHx6sRI0ao8uXLK3t7e9WmTRv1559/qvbt26v27dsb1T179qx67LHHlLOzsypXrpx6+eWXDTOSbp/lFBcXp/r27atcXV2VRqNRt/8oxcbGqpEjRyofHx9lZWWl/P391aRJk1R6errRveLi4tSzzz6rXF1dlb29vercubNhRtHtM5RyZwvduHFD3enKlSuqT58+ys3NTTk5OamuXbuqf/75R/n7+6uhQ4ca1f3rr79UixYtlFarVd7e3uq1115TX3zxxV1nOd1u/fr1qlu3bsrd3d3wusuXL6/27t2bp25hccfExChHR0cVHBxcpPsK0zzsn2khiupUVILadirG3GHcM1NmOWmUUsps2dQDkpiYiIuLCwkJCTg7O+c5np6eTkREBJUrVzaMIxHm8e233/LMM8/w119/0apVK3OHc1fTp09n6tSpzJ8//67dTeLBkc+0eJSpuyw+W5bc7fv7dtLlJMxm1apVXL16lXr16mFhYcHevXv54IMPaNeuXZlIZgDefvttoqKiGDNmDA4ODgwdOtTcIQkhHmEJaVk8//VBXu9S46HZ0qCoZFCwMBsnJydWr17N008/Tffu3fnyyy8ZNmwYv/76q7lDM8nChQvR6/WSzAghzEqvV4xbc5T9EXFM+P4Yumy9uUN6oKSFRphNjx496NGjh7nDEEKIh8K8befZevo6WisLPhvY6OHc3qAQj9arFUIIIR5C207H8PHWswC892Q96lZwMXNED54kNEIIIUQZFnkzhbGrj6IUDG7hT9/GFe9+0kNIEhohhBCijErN1DFyxSES03U08nNlSo+7r4X1sJIxNEIIIUQZpRRUKefAzeRMFg5qjI3Vo9tOIQmNEEIIUUY5aK2YP7ARUQnpeDk/2msuPbqpnBBCCFFGXb2VRu66uBqNBl9XOzNHZH6S0AghhBBlSHRCOk98tosx3x4hJUNn7nBKDUloRLFLTU0lLCyM7du3mzuUfGVlZbFw4UJatmyJi4sLdnZ21K5dm8mTJxMfH5+nfocOHdBoNIaHra0ttWvX5t133yUzM9MMr0AI8ajK0GXz0spD3EzO5MLNFCweki0OioMkNKLYpaamMm3atFKZ0KSmptK5c2defvllGjZsyKpVq/j9998ZNGgQixYtolGjRvz77795zqtSpQp79uxhz549fP/99wQGBjJlyhTGjBljhlchhHhUTf/1JEcu3cLZ1orPBzXGzsbS3CGVGjIoWDxSXn31VXbs2GHYciFXcHAwffv2pVmzZvTt25dDhw5hYfFfvm9nZ0eLFi0Mz7t160bt2rVZvnw5n376qWyAKIQocd8duMzKfZfQaOCTAQ3x87A3d0ilirTQPCJOnz7NgAED8PLyQqvV4ufnx5AhQ8jIyAAgLCws391Zly1bhkajITIy0lC2bds2OnTogIeHB3Z2dvj5+dGnTx9SU1OJjIykXLlyAEybNs3QTTNs2DDD+bt27SIkJAQnJyfs7e1p1aoV69evz/e+27Zt4/nnn8fDwwNnZ2eGDBlCSkoK0dHR9OvXD1dXV3x8fJgwYQJZWVmFvgfR0dEsWbKELl26GCUzuapXr87EiRM5evQov/32W6HXsrKyokGDBmRmZnLr1q1C6wohxP06fuUWb/3yDwDjOlUnuEZ5M0dU+kgLTSGUUqTp0swdhoGdld09bQl/7Ngx2rRpg6enJ9OnTycwMJCoqCjWrVtHZmYmWq22yNeKjIwkNDSUtm3bsmTJElxdXbl69SobN24kMzMTHx8fNm7cSNeuXRkxYgTPPfccgCHJ2bFjB507dyYoKIjFixej1WpZsGABPXv2ZNWqVXkSjeeee47evXuzevVqjhw5wuTJk9HpdJw5c4bevXvzwgsvsGXLFmbNmoWvry/jxo0rMPbw8HB0Oh29evUqsE6vXr2YPHkymzZt4vHHHy/0vYiIiMDV1dXw2oQQoiRkZet5edURMnV6OtXyYnRwNXOHVCpJQlOINF0azb9tbu4wDPYN3Ie9telNjOPGjcPKyor9+/cbffk+88wzJl/r0KFDpKen88EHH1C/fn1D+cCBAw3/37hxYwAqVqxo1E0D8MYbb+Dm5sb27dtxdHQEcjapbNCgARMmTKBfv35GSVuPHj2YM2cOAJ07d2bPnj2sWrWKuXPn8uqrrwLQqVMnNm3axMqVKwtNaC5dugRA5cqVC6yTe+zixYt5jul0ObMJbt68ycKFCzl48CCLFi3C0lL6sIUQJcfa0oIPn6rPB5vOMPfp+lhYyEDg/EiX00MuNTWVHTt20K9fv2JpSWjQoAE2Nja88MILLF++nAsXLhT53JSUFPbt20ffvn0NyQyApaUlgwcP5sqVK5w5c8bonDt3465VqxYAoaGhecrzS0Lu1Z0tYSdOnMDa2hpra2t8fHyYPn06kyZN4sUXXyy2ewohREGaBLiz+oUWONtamzuUUktaaAphZ2XHvoH7zB2GgZ2V6QsnxcfHk52dTcWKxbNZWdWqVdmyZQuzZ89m9OjRpKSkUKVKFf73v//xyiuv3DUWpRQ+Pj55jvn6+gIQGxtrVO7u7m703MbGpsDy9PT0Qu/v5+cH5HQVFST3WKVKlYzKq1atyurVq1FKcfHiRd59911mzpxJUFAQ/fv3L/S+QghxL7adjqGCqz01vJ2AvH9oCWOS0BRCo9HcUxdPaeLu7o6lpSVXrlwptF7uLJ2MjAyjMTU3b97MU7dt27a0bduW7OxsDh48yLx58xg7dixeXl6Ffrm7ublhYWFBVFRUnmPXrl0DwNPTs0iv614EBwdjZWXFzz//zMiRI/Ot8/PPPwPQsWNHo3JbW1uaNGkCQNOmTQkODqZOnTqMHTuWHj16GLU4CSHE/ToXk8SYb4+gFHw/siV1K7iYO6RST7qcHnJ2dna0b9+e77//Pt/kJFdAQAAAx48fNyr/9ddfCzzH0tKS5s2bM3/+fAAOHz4MYEiI0tKMB1Q7ODjQvHlz1q5da3RMr9ezYsUKKlasSPXq1Yv+4kzk7e3NiBEj2LRpE2vWrMlz/OzZs8yaNYvKlSvzxBNPFHotDw8P3n//fWJiYpg3b15JhSyEeAQlpmfx4jeHSM3MpqGfKzX/v4VGFE5aaB4Bc+fOpU2bNjRv3pw33niDatWqERMTw7p16/j8889xcnKie/fuuLu7M2LECKZPn46VlRXLli3j8uXLRtdatGgR27ZtIzQ0FD8/P9LT01myZAmQMzgXwMnJCX9/f3755RdCQkJwd3fH09OTgIAAZs6cSefOnQkODmbChAnY2NiwYMEC/vnnH1atWlXiTapz587l9OnTDBo0iJ07d9KzZ0+0Wi179+41DD7++eefsba+ez/1kCFDmDt3LnPmzGH06NE4OzuXaOxCiIefXq8Y/90xLtxMwdfFlnkDGmJlKW0PRSHv0iOgfv367N+/n8aNGzNp0iS6du3KxIkT0Wq1hjEpzs7ObNy4EScnJwYNGsTIkSOpW7cub775ptG1GjRogE6nY+rUqXTr1o3Bgwdz48YN1q1bx2OPPWaot3jxYuzt7Xn88cdp2rQpYWFhALRv355t27bh4ODAsGHD6N+/PwkJCaxbty7ftWGKm729PZs3b+ajjz7i0KFDPPXUU3Ts2JHJkydTs2ZNTpw4QVBQUJGuZWFhwfvvv09cXBwff/xxyQYuhHgkLNh+ns0nY7CxtGDhoMZ4OBZ9WY1HnUblbtf5EEtMTMTFxYWEhIR8/4pOT08nIiKCypUry4qvj6CsrCx69uzJ7t272bx5M82bl56p+uLeyGdalEXbz1zn2WUHUApm9anH0039zB2S2d3t+/t20kIjHnnW1tb88MMP1KhRg27dunHs2DFzhySEeAR9d/AySsGAZn6SzNwDGUMjBODo6MiBAwfMHYYQ4hH2af+GNA24yMDmkszcC0lohBBCiFLAytKCZ1sXvJK5KJx0OQkhhBBmsuyvCN76+W8ydXpzh1LmSQuNEEIIYQb7I+J4d/0pdHpFE393ejWsYO6QyjRpoRFCCCEesJjEdEatPIxOr3i8vi9PNPA1d0hlniQ0QgghxAOUqdPz0opD3EzOoKa3E+/3qSf7NBUDSWiEEEKIB+id305y+NItnGytWDSoMfY2MvqjOEhCI4QQQjwg3x+8zDd7LwLwSf8GBHg6mDmih4ekhUIIIcQD4u5gg5PWihFtK9Oxppe5w3moSEIjhBBCPCAhtbzY+Go7fJxlS47iJl1OotilpqYSFhbG9u3bzR1KvrKysli4cCEtW7bExcUFOzs7ateuzeTJk4mPj89Tv0OHDmg0GsPD1taW2rVr8+6775KZmVnk+966dQtPT09Wr15dnC+nVNq+fTsajYYffvih2K65ePFiKlSoQEpKSrFdU4gHIVuviE5INzyv4GqHhYUMAi5uktCIYpeamsq0adNKZUKTmppK586defnll2nYsCGrVq3i999/Z9CgQSxatIhGjRrx77//5jmvSpUq7Nmzhz179vD9998TGBjIlClTGDNmTJHvPW3aNHx9fR/IruIPo6FDh+Lg4MDs2bPNHYoQJpnzxxm6fbKTXedumjuUh5p0OYlHyquvvsqOHTtYvXq1UWIRHBxM3759adasGX379uXQoUNYWPyX79vZ2dGiRQvD827dulG7dm2WL1/Op59+etcdnePi4vj888/56KOPZHrmPbKysuLFF1/knXfeYeLEidjb25s7JCHuasPfUSzcnvNHUlxq0Vt0hemkhaYI9KmpJj+UTmc4X+l0OeXp6fd83ft1+vRpBgwYgJeXF1qtFj8/P4YMGUJGRgYAYWFh+X7RLlu2DI1GQ2RkpKFs27ZtdOjQAQ8PD+zs7PDz86NPnz6kpqYSGRlJuXLlgJwWidxummHDhhnO37VrFyEhITg5OWFvb0+rVq1Yv359vvfdtm0bzz//PB4eHjg7OzNkyBBSUlKIjo6mX79+uLq64uPjw4QJE8jKyir0PYiOjmbJkiV06dIl31aS6tWrM3HiRI4ePcpvv/1W6LWsrKxo0KABmZmZ3Lp1q9C6ua9Hp9Plue+wYcNwdHTk/PnzdO/eHUdHRypVqsT48eMN/za54uLiGDVqFBUqVMDGxoYqVarw5ptv5qlXkI0bNxISEoKLiwv29vbUqlWLmTNnGo4fPHiQ/v37ExAQgJ2dHQEBAQwYMICLFy/mudbVq1d54YUXqFSpEjY2Nvj6+tK3b19iYmKM6mVlZfHmm2/i6+uLs7MznTp14syZM3mut2XLFkJCQnB2dsbe3p7WrVuzdevWPPWeeeYZEhMTH4luO1H2nb+exITvjwHwXJvKPF5fFs8rSWZvoZk5cyZr167l9OnT2NnZ0apVK2bNmkWNGjUMdYYNG8by5cuNzmvevDl79+59IDGeadTY5HMqfPwRzl27ApC0ZQtXx76KfdOm+H/ztaHO+ZBOZOczZiM/tU6fMjmGXMeOHaNNmzZ4enoyffp0AgMDiYqKYt26dWRmZqLVaot8rcjISEJDQ2nbti1LlizB1dWVq1evsnHjRjIzM/Hx8WHjxo107dqVESNG8NxzzwEYkpwdO3bQuXNngoKCWLx4MVqtlgULFtCzZ09WrVqV5wv/ueeeo3fv3qxevZojR44wefJkdDodZ86coXfv3rzwwgts2bKFWbNm4evry7hx4wqMPTw8HJ1OR69evQqs06tXLyZPnsymTZt4/PHHC30vIiIicHV1Nby2wqxfv56GDRvi6uqa51hWVhaPP/44I0aMYPz48ezcuZN33nkHFxcX3n77bQDS09MJDg7m33//Zdq0aQQFBfHnn38yc+ZMjh49michvNPixYt5/vnnad++PYsWLaJ8+fKcPXuWf/75x1AnMjKSGjVq0L9/f9zd3YmKimLhwoU0bdqUkydP4unpCeQkM02bNiUrK4vJkycTFBREbGwsmzZtIj4+Hi+v/2ZuTJ48mdatW/PVV1+RmJjIxIkT6dmzJ6dOncLS0hKAFStWMGTIEJ544gmWL1+OtbU1n3/+OV26dGHTpk2EhIQYruft7U3NmjVZv349w4cPv+v7LoS5JKVn8cI3h0jJzKZFFXfe6FbT3CE9/JSJwsPD1YQJE1TLli2Vn5+fKleunKpVq5bq06ePmj9/vrp+/bpJ1+vSpYtaunSp+ueff9TRo0dVaGio8vPzU8nJyYY6Q4cOVV27dlVRUVGGR2xsbJHvkZCQoACVkJCQ7/G0tDR18uRJlZaWlu/xkzVqmvxI2LDhv/tv2KBO1qipIgcNNrrumRYti3y9+9GxY0fl6upa6L/N1KlTVX4/DkuXLlWAioiIUEop9cMPPyhAHT16tMBr3bhxQwFq6tSpeY61aNFClS9fXiUlJRnKdDqdqlu3rqpYsaLS6/VG93355ZeNzu/Vq5cC1Ny5c43KGzRooBo1alRgTEop9f777ytAbdy4scA6aWlpClChoaGGsvbt26s6deqorKwslZWVpaKiotTbb7+tALVo0aJC75nL3t5ejRw5Mk/50KFDFaC+++47o/Lu3burGjVqGJ4vWrQo33qzZs1SgPrjjz8KvHdSUpJydnZWbdq0Mby/RaHT6VRycrJycHBQn3zyiaF8+PDhytraWp08ebLAc8PDwxWgunfvblT+3XffKUDt2bNHKaVUSkqKcnd3Vz179jSql52drerXr6+aNWuW59rPPPOM8vLyKjT2u32mhShJ2dl69fzyA8p/4m+q+Xtb1I2kdHOHVGbd7fv7dkVuoVm+fDnvv/8+Z86cwdHRkfr169OkSRNsbW2Ji4vj77//Zu3atYwbN45+/frxzjvv4O/vf9frbty40ej50qVLKV++PIcOHaJdu3aGcq1Wi7e3d1HDLVY1Dh8y+RyNjY3h/506dcq5hoVxD1+1rVvuO7a7SU1NZceOHYwYMaJILQl306BBA2xsbHjhhRcYNWoUbdu2pUqVKkU6NyUlhX379vHSSy/h6OhoKLe0tGTw4MFMnDiRM2fOULPmf3/J9OjRw+gatWrV4ueffyY0NDRP+R9//HEfr8zYnd1vJ06cwNra2qhs0qRJvPjii3e91q1bt0hNTaV8+fIF3qtnz55GZUFBQWzbts3wfNu2bTg4ONC3b1+jesOGDWPixIls3bqVzp0753v93bt3k5iYyKhRowodv5OcnMw777zDjz/+SGRkJNnZ2YZjp07910K4YcMGgoODqVWrVsEv+v/d2coVFBQEwMWLF2nRogW7d+8mLi6OoUOHorutmxaga9euzJ49m5SUFBwc/lt8rHz58ly/fh2dToeVldkbmYXIY83By/xxMgYbSwsWDmqEp2PRW8HFvSvSb4PGjRsTERHBoEGD+Prrr2ncuLHRgMlccXFx/PzzzyxbtoxatWrx9ddf5/kFfDcJCQkAuLu7G5Vv376d8uXL4+rqSvv27XnvvfcK/IIobhb3OfhQY2WFJp9fvPd73aKIj48nOzubihUrFsv1qlatypYtW5g9ezajR48mJSWFKlWq8L///Y9XXnnlrrEopfDx8clzzNc3p285NjbWqPzOnwOb/08U8ytPv2OM0p38/PyAnK6iguQeq1SpklF51apVWb16NUopLl68yLvvvsvMmTMJCgqif//+hd43LS0NoMCBw/b29nmOabVao9cTGxuLt7d3noSkfPnyWFlZ5Xnfbnfjxg2Au/4MDBw4kK1btzJlyhSaNm2Ks7MzGo2G7t27G15D7vWK+vPk4eGR53XBf+9J7pibwn5PxMXFGSU0tra2KKVIT083SoyFKC2ebFiBg5HxNAlwo6Gfm7nDeWQUKaEJDQ1lwoQJODs7F1rP3d2d4cOHM3z4cHbu3ElcXJxJwSilGDduHG3atKFu3bqG8m7duvHUU0/h7+9PREQEU6ZMoWPHjhw6dCjf8R8ZGRlGAyUTExNNiuNh4u7ujqWlJVeuXCm0Xu4XakZGhtF7evNm3mmGbdu2pW3btmRnZ3Pw4EHmzZvH2LFj8fLyKvTL3c3NDQsLC6KiovIcu3btGoBhnEZJCA4OxsrKip9//pmRI0fmW+fnn38GoGPHjkbltra2NGnSBICmTZsSHBxMnTp1GDt2LD169Cj0izX3S93Uz8Od19i3bx9KKaOkJrelorD3LbdlrrCfgYSEBH777TemTp3KG2+8YSjPyMjIE3e5cuXu+vNUVLlxz5s3z2gW2e1uH5MDOe+jVquVZEaUWrbWlsx5KkhmND5gRZrlNH369LsmM3dq165doYMv8zNmzBiOHz/OqlWrjMqffvppQkNDqVu3Lj179mTDhg2cPXu2wIGQM2fOxMXFxfC486/tR4mdnR3t27fn+++/zzc5yRUQEADA8ePHjcp//fXXAs+xtLSkefPmzJ8/H4DDhw8Def8Kz+Xg4EDz5s1Zu3at0TG9Xs+KFSuoWLEi1atXL/qLM5G3tzcjRoxg06ZNrFmzJs/xs2fPMmvWLCpXrswTTzxR6LU8PDx4//33iYmJYd68eYXWzZ2RlN/6NkUVEhJCcnKyIeHK9fXXXxuOF6RVq1a4uLiwaNEilFL51tFoNCil8vyB8NVXXxl1PUHOHxjh4eH5zlYyVevWrXF1deXkyZM0adIk34fNbd23ABcuXKB27dr3fW8hilN6Vjbf7IlEr8/5jEky8+AVWwd0enr6XdfiKMzLL7/MunXr2Llz512bs318fPD39+fcuXP5Hp80aZLRbJfExMRHOqmZO3cubdq0oXnz5rzxxhtUq1aNmJgY1q1bx+eff46TkxPdu3fH3d2dESNGMH36dKysrFi2bBmXL182utaiRYvYtm0boaGh+Pn5kZ6ezpIlSwDo1KkTAE5OTvj7+/PLL78QEhKCu7s7np6eBAQEMHPmTDp37kxwcDATJkzAxsaGBQsW8M8//7Bq1aoS/yUwd+5cTp8+zaBBg9i5cyc9e/ZEq9Wyd+9e5syZA+S00tw5XiY/Q4YMYe7cucyZM4fRo0cXmvR36NCBDRs23HPcQ4YMYf78+QwdOpTIyEjq1avHrl27mDFjBt27dze89/lxdHTkww8/5LnnnqNTp048//zzeHl5cf78eY4dO8Znn32Gs7Mz7dq144MPPjD8W+3YsYPFixfnmZk1ffp0NmzYQLt27Zg8eTL16tXj1q1bbNy4kXHjxhmNgbobR0dH5s2bx9ChQ4mLi6Nv376UL1+eGzducOzYMW7cuMHChQsN9fV6Pfv372fEiBEmv4dClBSlFJN/+pu1h69y7EoCc56qb+6QHk2mjjhevXq1mj9/vuH5uXPnVK1atZSFhYVq06aNiouLM+l6er1ejR49Wvn6+qqzZ88W6ZybN28qrVarli9fXqT69zvL6WFw8uRJ9dRTTykPDw9lY2Oj/Pz81LBhw1R6+n+j7/fv369atWqlHBwcVIUKFdTUqVPVV199ZTTLac+ePerJJ59U/v7+SqvVKg8PD9W+fXu1bt06o/tt2bJFNWzYUGm1WgWooUOHGo79+eefqmPHjsrBwUHZ2dmpFi1aqF9//dXo/NxZTgcOHDAqz52NdePGDaPyoUOHKgcHhyK9F5mZmWrevHmqefPmytHRUQEKUK1atVJXrlzJUz93llN+1q9frwA1bdq0Qu+5detWBaj9+/cXKe78Zp3FxsaqkSNHKh8fH2VlZaX8/f3VpEmTjP4NC/P777+r9u3bKwcHB2Vvb69q166tZs2aZTh+5coV1adPH+Xm5qacnJxU165d1T///KP8/f2N/v2UUury5ctq+PDhytvbW1lbWytfX1/Vr18/FRMTo5T6b5bT999/b3ReRESEAtTSpUuNynfs2KFCQ0OVu7u7sra2VhUqVFChoaF5zs99Hw8dOlToa30UPtOi9Ph6d4Tyn/ibqvzGb+qv8zfufoIoMlNmOZmc0DRp0kTNnj3b8LxXr17K29tbvfrqq8rT01NNmDDBpOu99NJLysXFRW3fvt1oWnZqaqpSKmfK6fjx49Xu3btVRESECg8PVy1btlQVKlRQiYmJRbqHJDSiMJmZmapLly7KyclJ7d27t8TuU69evXynbouiGzRokGrVqtVd68lnWjwoByNjVdVJ65X/xN/UFzv+NXc4D50STWjc3d3V77//rpTK+aVhZ2dnaClZtGiRqlatmknXy/3r+M5H7l9wqamp6rHHHlPlypVT1tbWys/PTw0dOlRdunSpyPeQhEbcTVJSkmrSpIlyc3MrdI2d+7FhwwZla2urLl++XCLXf9idP39eWVtbqz///POudeUzLR6EmIQ01fTdzcp/4m9q1MpDJq3zJIqmRNahyZWammqYQrlv3z4yMjLo1q0bALVr1+bq1aumdnkVetzOzo5NmzaZGqYQJnF0dOTAgQMleo+uXbvywQcfEBERUWzT6B8lly5d4rPPPqNNmzbmDkUIMnV6Rq08zPWkDKp7OTK7j8xqMjeTExofHx+OHj1Ku3bt2LhxIzVq1DBMC42Pj5cN44QohCm7cwtjwcHBBAcHmzsMIQD4+2oCx68m4KS14vPBTXDQyiKP5mbyv0Dv3r1588032bFjBxs2bGDixImGY8ePH6dq1arFGqAQQghR2jT2d+PHka2IS82ksqfD3U8QJc7khOadd94hOTmZ3bt3M3DgQF5//XXDsd9++63Q6aNCCCHEw6JeRRdzhyBuY3JCY2dnx6JFi/I99qB2vxZCCCEetFupmYxccYjJ3WsRVNHV3OGIOxRppWAhhBDiUZatV/xv9VH2Xohj/HfHyNYXPqFFPHhFaqEZPnx4kS+o0WhYvHjxPQckhBBClDYfbT7LzrM3sLW24NMBDbG0kBlNpU2REppt27YZTUe7desWCQkJWFlZ4eHhQWxsLDqdDhcXF9zcZGdRIYQQD49NJ6L5LPw8ALP6BFHLx7S9DcWDUaQup8jISCIiIoiIiOC7777D0dGRlStXkpaWRlRUFGlpaaxYsQIHBwdWr15d0jELIYQQD8S/N5IZ/90xAIa3rswTDSqYOSJREJPH0IwfP54JEyYwYMAALC0tgZxdlwcOHMj48eN59dVXiz1IUbakpqYSFhbG9u3bzR3KPQsICGDYsGElcu3evXuj0WgKXJNm+/btaDQaw8PGxoZy5crRunVr3nzzTS5evFgicQkhjCVn6Hjxm0MkZ+hoVtmdSd2LvvGqePBMTmgOHTpE3bp18z1Wr149jh49er8xiTIuNTWVadOmlemE5qeffmLKlCnFft3r16/z22+/AbBy5UrS09MLrDtjxgz27NlDeHg4ixcvpkOHDixZsoRatWqxcuXKYo9NCGFMrxT+7vZ4OWuZP7AR1pYyj6Y0M/lfx9nZmS1btuR7bMuWLTg7S9+iKPsaNmxYIotEfv3112RlZREaGsqtW7dYu3ZtgXUDAwNp0aIFrVu35vHHH+e9997jxIkT1KxZk2HDhvH3338Xe3xCiP8421rz5ZAmrB3VmnJOWnOHI+7C5IRm8ODBfPDBB7z22mscOXKEqKgojhw5woQJE5gzZw6DBw8uiTjFfTp9+jQDBgzAy8sLrVaLn58fQ4YMISMjA4CwsLB89yFZtmwZGo2GyMhIQ9m2bdvo0KEDHh4e2NnZ4efnR58+fUhNTSUyMtKwFca0adMM3Sa3d9/s2rWLkJAQnJycsLe3p1WrVqxfvz7f+27bto3nn38eDw8PnJ2dGTJkCCkpKURHR9OvXz9cXV3x8fFhwoQJZGVlFfoe9OrVC39/f/R6fZ5jzZs3p1GjRobnd3Y5paenM378eBo0aICLiwvu7u60bNmSX375pdB73mnJkiV4eXmxfPly7OzsWLJkiUnnu7u78/nnn6PT6fjoo49MOlcIUTRRCWmGfQYtLDRUcLUzc0SiKExeWG/GjBlcv36dDz/8kLlz5xrKlVIMGjSIGTNmFGuApUFmSma+5Va2VlgUoQlSr9Ojy9ChsdBgbWddpHtmpWahlCryPQpz7Ngx2rRpg6enJ9OnTycwMJCoqCjWrVtHZmYmWm3R//KIjIwkNDSUtm3bsmTJElxdXbl69SobN24kMzMTHx8fNm7cSNeuXRkxYgTPPfccgCHJ2bFjB507dyYoKIjFixej1WpZsGABPXv2ZNWqVTz99NNG93vuuefo3bs3q1ev5siRI0yePBmdTseZM2fo3bs3L7zwAlu2bGHWrFn4+voybty4AmMfPnw4TzzxBNu2bTNa0fr06dPs37+fTz/9tMBzMzIyiIuLY8KECVSoUIHMzEy2bNlC7969Wbp0KUOGDLnre7d7925OnTrFa6+9hoeHB3369GHlypVERERQuXLlu56fq2nTpvj4+LBz584inyOEKJor8an0nLeL4JrlmfFkPWytLc0dkiiqe93S+/Tp02rhwoXq3XffVQsXLlSnTp2610uVuLttP56WlqZOnjyp0tLS8j0eRli+j4jwiCLd/5/v/lFhhKml7ZcWOeb5teebdI/CdOzYUbm6uqrr168XWGfq1Kkqvx+HpUuXKkBFROTE8cMPPyhAHT16tMBr3bhxQwFq6tSpeY61aNFClS9fXiUlJRnKdDqdqlu3rqpYsaLS6/VG93355ZeNzu/Vq5cC1Ny5c43KGzRooBo1alRgTEoplZWVpby8vNTAgQONyl9//XVlY2Ojbt68aSjz9/dXQ4cOLfBaOp1OZWVlqREjRqiGDRsWet9cw4cPV4DhsxIeHq4ANWXKFKN6ueXff/99gddq3ry5srOzK9J9H0V3+0wLkZ+0TJ0K/XSn8p/4m+rx6Z8qLVNn7pAeeXf7/r7dPf/pX6NGDUaOHMmbb77JyJEjqVlTRn+XRqmpqezYsYN+/foZWknuR4MGDbCxseGFF15g+fLlXLhwocjnpqSksG/fPvr27Yujo6Oh3NLSksGDB3PlyhXOnDljdE6PHj2MnteqVQuA0NDQPOV3m/1jZWXFoEGDWLt2LQkJCQBkZ2fzzTff8MQTT+Dh4VHo+d9//z2tW7fG0dERKysrrK2tWbx4MadOnSr8hQPJycl89913tGrVyvBZad++PVWrVmXZsmX5doMVRilZpVSI4qSU4q2f/+Gfq4m42VuzcFAjaZ0pY+55v/Pr169z8eJF0tLS8hxr167dfQVV2kxKnpRvuZVt0d6+Wk/WYlLyJDQmrCz5/IHnDV1O9yM+Pp7s7GwqVqx4X9fJVbVqVbZs2cLs2bMZPXo0KSkpVKlShf/973+88sord41FKYWPj0+eY76+vgDExsYalbu7uxs9t7GxKbC8sBlDuYYPH86HH37I6tWrefHFF9m0aRNRUVE8++yzhZ63du1a+vXrx1NPPcVrr72Gt7c3VlZWLFy4sEjjYNasWUNycjL9+vXj1q1bhvJ+/foxc+ZMNm/eTJcuXe56nVyXLl0yvGdCiPu3ct8lfjh0BQsNzBvQiIpu9uYOSZjI5G/LqKgoBg8eTHh4OPDfX4oajQalFBqNhuzs7OKN0sxsHGzu63wLKwtsrEy7hrV90cba3I27uzuWlpZcuXKl0Hq2trZAzliR28fU3Lx5M0/dtm3b0rZtW7Kzszl48CDz5s1j7NixeHl50b9//wLv4ebmhoWFBVFRUXmOXbt2DQBPT88iva57Vbt2bZo1a8bSpUt58cUXWbp0Kb6+vjz22GOFnrdixQoqV67MmjVrjAZP5w6qvpvc7UDGjh3L2LFj8z1e1IRm//79REdHM2LEiCLVF0IU7tDFeKb9egKA17vWpE1gyf4eEiXD5IRmzJgxHDlyhFmzZhEUFGTSgFLx4NnZ2dG+fXu+//573nvvvQIThoCAAACOHz9O06ZNDeW//vprgde2tLSkefPm1KxZk5UrV3L48GH69+9v+Jm4s/XOwcGB5s2bs3btWubMmYOdXc7MAb1ez4oVK6hYsSLVq1e/n5dbJM8++ywvvfQSu3bt4tdff2XcuHGGRSILkrvA3e3JTHR0dJFmOZ06dYo9e/bQp0+ffBfTe/fdd/nll1+IjY29a7dXXFwcI0eOxNraWhaxFKIYZOiyefnbw2RlK7rV9ebFdlXMHZK4RyYnNDt27GDOnDl3baIXpcfcuXNp06YNzZs354033qBatWrExMSwbt06Pv/8c5ycnOjevTvu7u6MGDGC6dOnY2VlxbJly7h8+bLRtRYtWsS2bdsIDQ3Fz8+P9PR0Q5dL7swhJycn/P39+eWXXwgJCcHd3R1PT08CAgKYOXMmnTt3Jjg4mAkTJmBjY8OCBQv4559/WLVqVb5Tx4vbgAEDGDduHAMGDCAjI6NIKwL36NGDtWvXMmrUKPr27cvly5d555138PHx4dy5c4Wem9s68/rrr9OsWbM8x5OSkti6dSsrVqww6rY7d+4ce/fuRa/XExsby759+1i8eDGJiYl8/fXX1KlTx7QXLoTIQ2tlyey+9fl02zk+eKr+A/kdJEqIqSOOPT091ebNm009zazud5bTw+DkyZPqqaeeUh4eHsrGxkb5+fmpYcOGqfT0dEOd/fv3q1atWikHBwdVoUIFNXXqVPXVV18ZzXLas2ePevLJJ5W/v7/SarXKw8NDtW/fXq1bt87oflu2bFENGzZUWq1WAUYzhv7880/VsWNH5eDgoOzs7FSLFi3Ur7/+anR+7iynAwcOGJXnzsa6ceOGUfnQoUOVg4NDkd+PgQMHKkC1bt063+P5zXJ6//33VUBAgNJqtapWrVrqyy+/LHB2WK7MzExVvnx51aBBgwLr6HQ6VbFiRVWvXj2l1H+znHIfVlZWysPDQ7Vs2VJNnjxZRUZGFvl1Pqoehc+0KF65MyxF6WLKLCeNUqZNlxg1ahQ2NjZ8/PHHxZlXlajExERcXFxISEjIdyXj9PR0w1oguWNJhBBll3ymxd1sORlD1fKOVPZ0MHcoohB3+/6+ncldTv369eP5559Hr9fTs2fPfPv8b19xVQghhChNTl5LZMyqw1hbWLB2VCsCvZzMHZIoBiYnNB07dgTgs88+Y/78+UbH1EM6y0kIIcTD4VZqJi+uOEh6lp5m1T2oUs7x7ieJMsHkhGbp0qUlEYcQQghRorL1ildWH+VyXBqV3O34tH8DLE1YH0yUbiYnNEOHDi2JOIQQQogS9cmWs+w4ewOtlQWLBjXG1f7+1hgTpct9LUN79uxZYmNj8fT0JDAwsLhiEkIIIYrV5pMxfLrtPADv96lHHV8XM0ckits97eX0/fff4+/vT61atWjTpg01a9bE39+fH374objje6BMnPAlhCil5LMs7rRyX85eb8NaBfBkw+LZCkaULia30Pz+++/079+fOnXqMGbMGHx9fbl69SorVqygf//+/Prrr3Tr1q0kYi0x1tbWaDQaUlJSDKvXCiHKrtTUVCDnsy0EwBeDm/D1nkiGtAwwdyiihJi8Dk3r1q1xdnZm/fr1WFj818CjlKJbt24kJSXx119/FXug96Mo89ijoqK4desWzs7OODs7Y2VlJStGClHGKKVITU3l+vXruLq65rsRqhCi7CjRdWiOHj3K6tWrjZIZyNnrZtSoUQwcONDUS5YK3t7e2NnZcf36dRITE80djhDiPri6uuLt7W3uMISZfbnzAteT0pnYtSZWlvc0wkKUISYnNJaWlmRmZuZ7LCsrK0+iU1ZoNBpcXV1xcXEhOzsbnU5n7pCEEPfA2tr6rpuNioff7vM3mbnhFHoFjf3d6FpXWusediYnNE2bNmX27Nl0797daLxJRkYGc+bMoXnz5sUa4IOm0WiwsrLCyuq+JoAJIYQwk2u30hiz6gh6BX0aVaRLHWmtexSY/K09bdo0QkJCqFKlCk899RTe3t5ERUWxdu1aYmNj2bZtW0nEKYQQQtxVelY2L604RFxKJnV8nXnvyboyHvIRYXJC06ZNG/744w/eeOMN5s+fj1IKCwsLmjdvzqpVq2jVqlVJxCmEEELcVdi6Exy7koCrvTWLBjXG1lq6Hx8V99Sv0r59e/bs2UNqairx8fG4ublhb29f3LEJIYQQRbZq/yVWH7iMhQbmDWhIJXf5XnqU3NdAEXt7e0lkhBBClArOttbY21gypmM12gaWM3c44gEzOaEZN24cMTExrFy5Ms+xQYMG4ePjwwcffFAswQkhhBBFFRrkQ1BFFyq6yQKpjyKT51ivW7eOxx57LN9jjz32GL/88st9ByWEEEIUhS5bz42kDMPzSu72Mgj4EWVyQnP16lUCAgLyPebv78+VK1fuNyYhhBCiSGZtPE33T//kQGScuUMRZmZyl5ODgwOXL1/O99ilS5ewtbW976CEEEKIu/n12DW+/DMCgNjkjLvUFg87k1toWrZsyYcffkhWVpZReVZWFh999JFM2xZCCFHizkQn8foPxwF4qUNVWQlYmN5C89Zbb9GuXTvq1q3LiBEjqFChAleuXGHJkiVcvHiRRYsWlUScQgghBAAJaVm8+M1B0rKyaVPNkwmP1TB3SKIUMDmhad68OevWrWP06NG88cYbhvKqVauybt06mjVrVqwBCiGEELn0esW4NUeJjE2lgqsd8wY0xNJCBgGLe+hyAujSpQvnz5/nzJkz7Nq1izNnznDu3LkCZz8VZubMmTRt2hQnJyfKly9Pr169OHPmjFEdpRRhYWH4+vpiZ2dHhw4dOHHixL2ELoQQogz7Zu9Ftp6+jtbKgs8HN8bNwcbcIYlS4r62xg4MDKRVq1YEBgbe8zV27NjB6NGj2bt3L5s3b0an0/HYY4+RkpJiqDN79mzmzp3LZ599xoEDB/D29qZz584kJSXdT/hCCCHKmL6NKxIa5MN7T9ajbgUXc4cjShGNUkqZetLp06eZNm0a27dvJzY2lr1799KoUSOmTZtGu3btCA4OvueAbty4Qfny5dmxYwft2rVDKYWvry9jx45l4sSJQM7O3l5eXsyaNYsXX3zxrtdMTEzExcWFhIQEnJ2d7zk2IYQQ5qeUkrVmHhGmfH+b3EJz9OhRmjZtyo4dO+jQoQPZ2dmGY8nJyfc9KDghIQEAd3d3ACIiIoiOjjbqztJqtbRv357du3fne42MjAwSExONHkIIIcqm1Ewdq/dfIvfvb0lmRH5MTmjeeOMNgoKCOH/+PN988w23N/A0a9aMAwcO3HMwSinGjRtHmzZtqFu3LgDR0dEAeHl5GdX18vIyHLvTzJkzcXFxMTwqVap0zzEJIYQwH6UUb/z4N2+s/Zu3f5Gxk6JgJic0f/31F6+//jr29nmXly4sySiKMWPGcPz4cVatWpXn2J33KqzJcdKkSSQkJBgeBS0EKIQQonRb8lck645dw8pCQ8/6vuYOR5RiJk/bVkphY5P/qPL4+Hi0Wu09BfLyyy+zbt06du7cScWKFQ3l3t7eQE5LjY/PfwsnXb9+PU+rTS6tVnvPcQghhCgd9l6IZcbvpwB4K7QWzSq7mzkiUZqZ3EITFBTETz/9lO+xjRs30rhxY5Oup5RizJgxrF27lm3btlG5cmWj45UrV8bb25vNmzcbyjIzM9mxY4esSiyEEA+pqIQ0xnx7mGy94smGFRjaKsDcIYlSzuQWmldeeYWBAwfi4ODA4MGDgZw9nLZt28aSJUv44YcfTLre6NGj+fbbb/nll19wcnIydFm5uLhgZ2eHRqNh7NixzJgxg8DAQAIDA5kxYwb29vYMHDjQ1PCFEEKUchm6bF5acZibyZnU8nFmxpP1ZCCwuKt7mrY9Y8YMwsLCyM7ONoxlsbKyYtq0aUarBxcpgAJ+SJcuXcqwYcOAnFacadOm8fnnnxMfH0/z5s2ZP3++YeDw3ci0bSGEKDv2/BvL4MX7cNBa8euYNvh52Js7JGEmpnx/31NCA3DlyhU2bdpETEwMnp6edOnSBX9//3sKuKRJQiOEEGXLoYtxpGXqaRPoae5QhBk9kISmLJGERgghhCh7SnRhvePHj7Nz507D85SUFEaNGkWLFi14++23eQTyIyGEEMUsNjmDgV/u5XS0LIQq7o3JCc24ceP47bffDM8nT57Ml19+SWZmJjNnzuSzzz4r1gCFEEI83HTZel5edYTd/8Yy/rtj8oexuCcmJzT//POPYbq0UoqVK1cybdo0Dh8+zMSJE1myZEmxBymEEOLh9cGmM+z+NxZ7G0s+frqBzGgS98TkhObWrVt4euYM0jp27Bjx8fH069cPgJCQEC5cuFC8EQohhHgo6fWKD/84w+c7c743Puhbn0AvJzNHJcoqk9eh8fDwMGwlEB4ejpeXF9WqVQNyFryTpkIhhBB3k5yh49U1R9l8MgaAsZ0CCQ3yuctZQhTM5ISmbdu2hIWFcfPmTT766CNCQ0MNx86dOycbQQohhLirBeHn2XwyBhsrC2Y+WY8+jSve/SQhCmFyl9PMmTPRaDS88soraLVa3n77bcOx77//nhYtWhRrgEIIIR4+/wsJpFOt8qx5oYUkM6JY3PM6NHFxcbi7G28U9vfff+Pt7U25cuWKJbjiIuvQCCGEeSmlCD9znQ7Vy2NhIYN+RdGU6Do0ue5MZgDq1atX6pIZIYQQ5pWp0zP5p38Yvuwgn2w9Z+5wxEOqSAnNd999Z/KFr127xl9//WXyeUIIIR4eN5MzGPTVPlbtv4RGA/Y2luYOSTykipTQjB49mgYNGvDVV1+RmFj4Ko6HDh1i9OjRBAYGcuzYsWIJUgghRNlz4loCT3z2F/sj43DSWrFkaFNebF/V3GGJh1SRZjmdP3+esLAwXnnlFcaMGUPDhg1p1KgR5cuXx9bWlri4OP7991/27t1LVFQUdevWZe3atXTp0qWk4xdCCFEK/f53FOO/O0ZaVjaVPR34ckgTqpV3NHdY4iFm0qDg+Ph4li5dyu+//87evXtJTU01HKtSpQodOnTgmWeeITg4uESCvVcyKFgIIR6cmMR02s0OJ0Onp22gJ58NaISLvbW5wxJl0APbbTshIYG0tDQ8PDywti69P6yS0AghxIP1w6ErnIpKZFK3mlhZ3vP8E/GIM+X72+SF9W7n4uKCi4vL/VxCCCHEQ+ByXCopmTpqeud86fSVtWXEAyZpsxBCiPuy599YHv9sFyOWHeRmcoa5wxGPqPtqoRFCCPFo+2bvRaatO4FOr6joZo8uW/bzE+YhCY0QQgiTZer0TPv1BCv3XQLg8fq+zO4bhK21rDMjzEMSGiGEECaJTc5g1MrD7IuIQ6OB17vUZGT7Kmg0sqWBMB9JaIQQQpjkg01n2BcRh6PWik/6NyCklpe5QxLi3hOahIQE9u7dy82bN+nevTtubm7FGZcQQohSalL3WlxPymBSt5oEejmZOxwhgHuc5fTOO+/g6+tLt27dGDJkCBEREQCEhITw/vvvF2uAQgghzEuvV2w+GUPusmUudtYsGdZUkhlRqpic0CxYsIBp06YxYsQI1q9fz+3r8vXo0YP169cXa4BCCCHMJyVDx+hvD/P81wf5es9Fc4cjRIFM7nL67LPPGDduHLNnzyY7O9voWGBgIOfOydbwQgjxMLgcl8rzXx/kdHQS1pYa7GSnbFGKmZzQXLhwocBNJ52cnLh169b9xiSEEMLM9l2I5aWVh4lLycTT0YZFgxrTJMDd3GEJUSCTExoXFxdiYmLyPRYZGUn58uXvOyghhBDms3LfRab+krNYXt0KznwxuAm+rnbmDkuIQpk8hiYkJITZs2eTkpJiKNNoNOh0OhYuXFhg640QQojS7/z1JKb8/A86vaJHkA/fv9hKkhlRJpjcQjN9+nSaNm1K7dq1efLJJ9FoNHz22WccOXKES5cu8d1335VEnEIIIR6AauWdeDO0NulZ2YzqUFUWyxNlhkbdPk2piE6ePMm4cePYtm0bOp0OS0tLgoOD+eSTT6hVq1ZJxHlfTNl+XAghHjWnoxOxs7bE38PB3KEIYcSU7+97Wlivdu3abNy4kYyMDGJjY3Fzc8POTpokhRCirNl0IppX1xylgqsda0e1wsnW2twhCXFP7mvrA61Wi6+vb3HFIoQQ4gFRSjFv23nmbj4LQDknLdl62SlblF33lNBER0fz448/cvHiRdLT042OaTQaPvnkk2IJTgghRPFLzdTx2vfHWf93FADDWgXwZmgtrC3vafF4IUoFkxOaTZs28eSTT+ZJZHJJQiOEEKXXlfhUXvj6ECejErG21PDOE3Xp38zP3GEJcd9MTsdfe+01GjRowNGjR8nIyECv1xs97lw9WAghROkRtu4kJ6MS8XCw4dvnW0gyIx4aJrfQ/Pvvv6xdu5agoKCSiEcIIUQJmvFkXZRSTO9Vlwqyvox4iJjcQlOzZk0SExNLIhYhhBDFLCtbz5aT/63uXt7ZlsXDmkoyIx46Jic006dP57333itw+wMhhBClQ3xKJkOX7Oe5rw/yy9Gr5g5HiBJlcpdTaGgohw8fpmrVqjRo0AB3d+PNyjQaDb/88kuxBSiEEMJ0Z6KTeP7rg1yKS8XBxhI7a9kpWzzcTE5oli1bxtSpU7G0tCQiIoKrV42zflkmWwghzGvzyRjGrj5CSmY2ldzt+HJIE2p6yyrp4uFm8tYHlStXJigoiGXLluHm5lZScRUr2fpACPEoUEoxP/w8H24+i1LQsooH859phLuDjblDE+KelOjWBzExMbz88stlJpkRQohHxcGL8cz5I2fl3yEt/ZnSo7YsliceGSb/pDds2JArV64UWwA7d+6kZ8+e+Pr6otFo+Pnnn42ODxs2DI1GY/Ro0aJFsd1fCCEeFk0D3Plfx2q892Rdpj9RV5IZ8Ugx+af9ww8/ZPbs2Rw9erRYAkhJSaF+/fp89tlnBdbp2rUrUVFRhsfvv/9eLPcWQoiy7tDFeK4n/rdy+7jHavBMc38zRiSEeZjc5fT8889z48YNGjdujI+PT76znI4dO1bk63Xr1o1u3boVWker1eLt7W1qqEII8VD77sBl3vz5b+r4urD6hRbYykwm8QgzOaHx8PDA09OzJGIp0Pbt2ylfvjyurq60b9+e9957j/LlyxdYPyMjg4yMDMNzWQhQCPEw0WXreXf9KZbtjgTA19UWvWnzO4R46Jic0Gzfvr0EwihYt27deOqpp/D39yciIoIpU6bQsWNHDh06hFarzfecmTNnMm3atAcapxBCPAi3UjMZ8+0Rdp2/CcC4ztV5uWM1WTJDPPJMnrZdkjQaDT/99BO9evUqsE5UVBT+/v6sXr2a3r1751snvxaaSpUqybRtIUSZdi4miee+PsjF2FTsbSyZ268BXetKd7x4eBX7tO1Lly7h4+ODtbU1ly5dumt9P7+S273Vx8cHf39/zp07V2AdrVZbYOuNEEKURUopJv54nIuxqVR0y1ksr5aP/IEmRK4iJTSVK1dmz549NGvWjICAgLs2bWZnZxdLcPmJjY3l8uXL+Pj4lNg9hBCitNFoNHz0dAPeW3+Kmb3r4eEof7QJcbsiJTRLliyhatWqhv8vzr7a5ORkzp8/b3geERHB0aNHcXd3x93dnbCwMPr06YOPjw+RkZFMnjwZT09PnnzyyWKLQQghSqP0rGx2/3uTjjW9APD3cOCLIU3MHJUQpZPZx9Bs376d4ODgPOVDhw5l4cKF9OrViyNHjnDr1i18fHwIDg7mnXfeoVKlSkW+h2x9IIQoa6IS0njh60OcuJbA4mFNCa5R8MxOIR5WJbr1wfDhw5kyZQqVK1fOc+zixYtMmzaNJUuWFPl6HTp0oLCcatOmTaaGKIQQZdqhi/G8+M0hbiZn4GZvLTtlC1EEJq8UvGzZMm7cuJHvsZs3b7J8+fL7DkoIIR5V3x28zIAv9nIzOYOa3k6sG9OGFlU8zB2WEKWeyS00hYmLi5PZRUIIcQ902XpmbjjN4l0RAHSp48Xcfg1w0Bbrr2khHlpF+qTs3LnTaEG9r776io0bNxrVSUtL45dffqF27drFGqAQQjwKtpy6bkhmXgkJ5JWQQCwsZLE8IYqqSAlNeHi4YeVdjUbDV199lW89f39/5s+fX3zRCSHEI6JLHS+ebR1A0wB3uteTZSmEMFWRZjmlpaWRmpqKUory5cuzadMmGjVqZFRHq9Xi6OhYYoHeD5nlJIQojf48d4Ogiq642FmbOxQhSqVin+VkZ2eHnZ0dkLNOjK+vL9bW8gEUQoh7oZTi850XmLXxNG0Dy7F0WFMspXtJiPti8mgzf3//kohDCCEeCelZ2bzx43F+PnoNgIpuduiVwhJJaIS4HzJ8XgghHpDohHRe+OYgx68kYGmhIezxOgxuIX8kClEcJKERQogH4PClnMXybiTlLJY3/5lGtKrqae6whHhoSEIjhBAlTJetZ8J3x7iRlEENLye+HNIEPw97c4clxEPF5JWChRBCmMbK0oJ5AxvyeH1ffhzVSpIZIUqAJDRCCFECEtKy2Hn2v21i6vi68OmAhjjKyr9ClIh72pyyIBYWFri6utK0aVOefPJJbGxs7is4IYQoi/69kczzyw9yJT6N1S+2oJGfm7lDEuKhZ3JCEx4eTkJCArdu3cLKygoPDw9iY2PR6XS4urqilGLu3LnUqFGD7du34+XlVRJxCyFEqRR+5jr/W3WEpHQdvi62aK2kIVyIB8HkT9qPP/6Ik5MTq1atIi0tjaioKNLS0vj2229xcnJi06ZN7Nq1i/j4eCZPnlwSMQshRKmjlOKLnf8yYtkBktJ1NA1wY93Lbajj62Lu0IR4JJjcQjNu3DgmTJjA008/bSiztLSkf//+xMTEMG7cOHbt2sXEiROZM2dOsQYrhBClUXpWNpPW/s1PR64C0L9pJaY/URcbaZ0R4oEx+dN24MCBAnfUrlu3LkeOHAGgQYMG3Lx58/6iE0KIMuDHw1f46chVLC00THu8DjN715NkRogHzOQWGmdnZ8LDwwkJCclzbNu2bYbNo9LS0nBycrr/CIUQopQb0NSPv68k8Hh9X1pVk8XyhDAHkxOagQMHMmvWLJRSPPXUU3h5eRETE8OaNWv48MMPeeWVVwA4dOgQtWrVKvaAhRCiNPjjRDRtA8thZ2OJhYWG9/sEmTskIR5pGqWUMuWEzMxMhg0bxurVq9Fo/ttMTSnFgAEDWLZsGdbW1mzZsgVnZ2eaNWtW7EGbypTtx4UQojDZesWsjaf5YucFetb35dP+DYx+Fwohio8p398mJzS5Tp06xY4dO4iNjcXDw4N27doVOLbG3CShEUIUh4S0LP636gg7/n/BvDHB1RjXuToWFpLQCFESTPn+vuclK2vVqiVdSkKIR8aFG8k89/VBLtxIwdbagg/61qdnfV9zhyWE+H/3nNBcv36dixcvkpaWludYu3bt7isoIYQoTXacvcGYbw8bFsv7YkgT6laQ9WWEKE1MTmiioqIYPHgw4eHhQM7YGQCNRoNSCo1GQ3Z2dvFGKYQQZpKaqWP8d8dIStfR2N+NRYMaU85Ja+6whBB3MDmhGTNmDEeOHGHWrFkEBQWh1coHWwjx8LK3sWL+wIb8fPQaYY/XRmtlae6QhBD5MDmh2bFjB3PmzOHZZ58tiXiEEMLsriem8++NFFpW9QCgeRUPmlfxMHNUQojCmLyUpUajoVKlSiURixBCmN2xy7fo+dkunlt+gLMxSeYORwhRRCYnNE899RS//fZbScQihBBm9fORqzz1+R5iEjPwcbXDxlK2LxCirDC5y6lfv348//zz6PV6evbsiYdH3mbYRo0aFUtwQgjxIGTrFbM3nebzHRcACKlZno/7N8DJ1trMkQkhisrkhfUsLP77i+XO1TFL6ywnWVhPCFGQxPQsXll1hPAzOYvljepQlfGP1cBSFssTwuxKdGG9pUuX3nNgQghR2iz/K5LwMzfQWlkwu28QTzSoYO6QhBD3wOSEZujQoSURhxBCmMXIDlW5cDOF4a0rU6+iLJYnRFklI96EEI8UpRS/Hb9GVrYeAGtLCz56uoEkM0KUcUVqoZk+fTrPPfccvr6+TJ8+vdC6Go2GKVOmFEtwQghRnDJ02bz50z/8cOgKw1oFEPZ4HXOHJIQoJkUaFGxhYcHevXtp1qyZ0aDgfC8og4KFEKXQ9aR0Rn5ziMOXbmGhgTdDazO8dUCeyQ1CiNKj2AcF6/X6fP9fCCHKguNXbvHC14eITkzH2daKzwY2ol31cuYOSwhRjO55t20hhCgLfjl6ldd/OE6GTk/Vcg58NbQplT0dzB2WEKKYSUIjhHhoxSZnMHnt32To9HT8/8XynGWxPCEeSibPcsrKyuLdd9+ldu3aODg4YGlpafSwspIcSQhROng4avno6QaMbF+VL4c0kWRGiIeYydnHpEmT+Oijj+jWrRu9evVCq9WWRFxCCHFPIm+mEJeaSSM/NwAeq+PNY3W8zRyVEKKkmZzQfPfdd7z99ttMnTq1JOIRQoh7tuvcTUZ/exgrCw2/jGlNRTd7c4ckhHhATO5yio+Pp127diURixBC3BOlFEv/imDo0v0kpGVRyd1edsoW4hFj8ie+Xbt2HD16tNgC2LlzJz179sTX1xeNRsPPP/9sdFwpRVhYGL6+vtjZ2dGhQwdOnDhRbPcXQpRtGbpsJv54nGm/niRbr+jTqCKrX2hBeWdbc4cmhHiATE5oPv30UxYvXszatWvJzMy87wBSUlKoX78+n332Wb7HZ8+ezdy5c/nss884cOAA3t7edO7cmaSkpPu+txCibNsfEUffhXv47uAVLDTwVmgt5jwVhK21pblDE0I8YEVaKfh2Tk5OZGVlkZWVhUajwd7euI9ao9GQkJBwb8FoNPz000/06tULyGmd8fX1ZezYsUycOBGAjIwMvLy8mDVrFi+++GKRrisrBQvxcPpg02nmh/+L0/8vltdeFssT4qFS7CsF365Pnz4PbKnwiIgIoqOjeeyxxwxlWq2W9u3bs3v37gITmoyMDDIyMgzPExMTSzxWIUTJuxSbSlpWNjW8nQB4sX1V0jL1jGxfRbqYhHjEmZzQLFu2rATCyF90dDQAXl5eRuVeXl5cvHixwPNmzpzJtGnTSjQ2IcSDcyMpg8+2nePb/ZcIqujKDyNbotFocLa15u2etc0dnhCiFCgT0wDubBFSShXaSjRp0iQSEhIMj8uXL5d0iEKIEpCUnsXcP87Q/oNwlu+5SFa2wt7GkqQMnblDE0KUMve0rG9SUhIbNmzg4sWLpKWlGR3TaDRMmTKlWILz9s5ZDCs6OhofHx9D+fXr1/O02txOq9XKgn9ClGHpWdms2HuR+eHniU/NAqB+JVcmdqlBq2qeZo5OCFEamZzQ7Nu3j9DQUOLi4vI9XpwJTeXKlfH29mbz5s00bNgQgMzMTHbs2MGsWbOK5R5CiNJn04lo3l1/CoAq5Rx4vUsNutTxfmDj94QQZY/JCc2rr75KhQoV2LhxI0FBQdjY2NxXAMnJyZw/f97wPCIigqNHj+Lu7o6fnx9jx45lxowZBAYGEhgYyIwZM7C3t2fgwIH3dV8hROmhlCI6MR0fFzsAegT5svbwVbrV9aZv44pYySJ5Qoi7uKdp299++y09e/YslgC2b99OcHBwnvKhQ4eybNkylFJMmzaNzz//nPj4eJo3b878+fOpW7duke8h07aFKL32XYhl1sbTXLuVzvbXOsgaMkIIgxKdtl2uXPGu89ChQwcKy6k0Gg1hYWGEhYUV632FEOZ1KiqR2RtPE37mBgC21hYcv5JAs8ruZo5MCFEWmZzQvPzyyyxatIgePXpIf7YQwmSX41KZu/ksPx+9ilJgaaGhf9NKvBISKGvJCCHumckJjV6v5/Tp0zRs2JDQ0FA8PDyMjms0Gl599dViC1AI8fC4diuNkA93kJmtB6BHkA/jH6tBZU8HM0cmhCjrTB5DY2FR+OA8jUZDdnb2fQVV3GQMjRDmo8vWGw3qfeHrg6RlZTOxa03qVnAxY2RCiNKuRMfQRERE3HNgQohHR+5aMot3RbB2VCvDDKZPBzSUgb9CiGJnckLj7+9fEnEIIR4S2XrF2sNX+HjLOa7eyll485s9F3m9a00ASWaEECXinlYKFkKIOyml2HLqOh9sOs3ZmGQAvJ1tGdspkL6NK5o5OiHEw87khKZy5cqFzm7SaDT8+++/9xWUEKJsUUoxePF+dp2/CYCLnTWjOlRlaKsAaZER4mGmywALK7Aw/+fc5ISmffv2eRKamzdvsnv3bpydnWnfvn2xBSeEKBs0Gg31Krpw8GIcz7auzMh2VXGxtzZ3WEKIkrRlGhxcAn2XQLUQc0djekKzbNmyfMtjY2Pp3LkzoaGh9xuTEKKUy11L5pnmfjQJyFkI76UOVRnWKgAvWUtGiIdTYhQ4/7dRNBmJkH4LTq8vFQmNydO2C7Nq1SpmzJjB33//XVyXLBYybVuI4nEzOYPPtp1n5b6LZGUrmga48f3IVuYOSwhRkrKz4Osn4OJu+N8RcK+cU37zHCRcgcrtSqzLqUSnbRfG09OTCxcuFOclhRClQFJ6Fl/+GcFXf14gNTNnnak21Tx5vWsNM0cmhCh2uky4cRp8gnKeW1rnPDQauLT3v4TGMzDnUUoUW0KTlZXFl19+SeXKlYvrkkKIUuDHQ1d47/dTxKVkAlCvggsTu9akTaCnmSMTQhS7uAj4smNOq8xr58A6Z/0our4Pti7g7Gve+AphckLTsWPHPGUZGRmcPXuWuLg4li9fXiyBCSFKB71SxKVkUtnTgQmP1aB7PW/Zx02Ih8WtSzljY/ya5zx39QetY87spZvn/mulKV+rwEuorCyUUljY2DyAgAt2T3s53fnLzNnZmb59+zJ48GBatZL+dCHKKqUU205fJ1uveKyONwC9G1XE2tKC0CAfrC0L3/pECFGGnNkAq/pDuZowam9Ol5KFBQz5BVz8wLJoKUJEv6dxHzwY195PlnDAhTM5odm+fXsJhCGEMLeDkXG8v+E0By/G4+NiS7vq5bC1tsTSQkOvhhXMHZ4Q4n5kZ8G/28DOHSo1zSnzbwXW9uBYPmfGku3/763mXiXfS+ji40neFk7KX7vwnTULjXXO0gz2TZuQsmdP2Upo0tLSqFatGosWLaJnz54lFZMQ4gE6HZ3InE1n2HLqOgBaKwueaFCBbH2xTYAUQpjbzg9gxyyoEQoDvs0ps3WBcSfBzq3A07KuXiVp61aSNm8h9dAh0OsBcO3XD4cWLQAo97//YWFnV+Iv4W5MSmjs7OxIS0vDwcGhpOIRQjwgV2+l8eEfZ/jpyFWUAksLDf2aVOKVkEC8XWQtGSHKrISr8Pd3OclLueo5ZbV7wYHF4FEVlMrpXoI8yYxSioxz50jasoXkLVtJP3nS6Li2Vi2cQkKwqVTJUGbp6FiSr6bITO5yCgkJYcuWLfkODhZClB3RCemsPXwVgNB6Pox/rDpVypWOX0xCiPuw4XU4/RukxUPn6TllXrVh/Jl8x8UovZ60o8dI2rKFpC1byLp06b+DFhbYN2qEY6cQnDp1wqZi6d2XzeSEZvLkyfTp0wdbW1t69+6Nj49PnkHC7u7uxRagEKJ4JGfoOHIpnraB5QBo7O/GuM7V6VCjHEEVXc0bnBDCdErBv1vh+PfQbRbYueaU1x+Qk8z4NDCuX8Ag3ysvjSJ5xw7Dc42NDQ6tWuHUKQTHjh2xKiPf6SavFGxh8d8sh4KmbmZnZ99fVMVMVgoWj7IMXTYr917is/DzpGTo2P5aB3xczN/fLYS4T0rBghY5i+D1/BQaD71LdUXSxo0kbd2G95S3sHTJGQQc+9VX3Fz0OY4dOuDUKQSHNm2xdCwdQ0tKdKXgt99+W9agEKIMyNYrfj5ylbmbz3L1VhoAlT0diEnMkIRGiLImIzlnI8jIP2HAmpzp1RoNNHserp+Gik3zPU2fkoLF/4971Wg03FywkIxz53Bs1xaXxx8HwG3AANyHDEFj5nVk7pfJCU1YWFgJhCGEKC65a8nM3niGMzFJAJR30jK2U3WealJR1pIRoqy4ffCuhWXOTKWMRLi0GwLa5JQ3fS7PaZlXrhjGw2ScPEXgX7sMs5Bc+z9N1rVr2Naubahv8ZBM9CnWvZyEEOZ3MzmTUSsPk6HT42RrxUsdqvJsq8rY2ZTM5nFCiGIWdwF2zIaMJOi/MqfM2g7avZaziq9XXaPqSikyzpwhacvWnCTm9Gmj42lHj+LQsiUA7s8880BegjlIQiPEQ+DqrTQquOb8BVbOScvI9lVJ12XzUvuquNqX7WZkIR4Jukyw+v/PqsYCjq0CNJB47b/9k1r/z1BdZWeTduRIThKzdStZly//dy1LS+ybNMGpUyecQjpi7Vt6918qTpLQCFGGXYlPZe7ms/x85Crfj2xJY/+c2Qivdq5u5siEEEVyfgtsmQaVmkHohzllbgE5060rtQAnH6PqyX/uIumPTSRtCyc7NtZQrtFqcWjTBqdOnXDs0B4rt4IXy3tYSUIjRBkUm5zBZ+HnWbn3EpnZOSt37joXa0hohBClVFYaKD3Y/P+4FY0FRB+H5BjoNjtnrAxA61cA0KemYmFvbzg9bulSUnbvBsDC2Rmn4A44duqEY+vWRvUeRZLQCFGGJGfo+OrPC3y58wIpmTnLI7Sq6sHErjWpX8nVvMEJIQq36yPY+SEET4aWo3LKKreHnp9Arcf/S2YApdNxefRoUvfspermP7D28gLApXdvbAICcOrcCfsmTQz7KQlJaIQoM5RSDPhiL39fTQCgbgVnJnatSZtqnrKUghCl0Y2z4F4ZLP8/6bBxhMyknKnXuQmNhSU0HkbmxYuk/bMHl9BQADRWVugTElGZmTkbP/bqBYBLj1BceoSa4cWUfpLQCFGK6fUKRc4+SxqNhsEt/Fmw/TwTutSge10fLCwkkRGiVFrZD85tgoHfQfUuOWV1+4BXHajUAqUU6SdPGvZMyjh3DiwtcWzTxrDgndcbE7FwdkZbJf/dr4UxSWiEKIWUUoSfyVlLZkSbyjzVJGcjuD6NK/JkowqylowQpUlWes7aMFVv2+PQvQpYWOWs4vv/CY2ycSY12oqkFe+TtHULumtR/9W3ssKhWVN0cXGGhMauQYMH+CLKPpO3PiiLZOsDUZYcuhjHrA1n2B8ZB0BNbyc2vNJWupWEKI0yU+GjOpAWBy8fztnNGiApGjSW6K2cSNm9m6TNW0gODyf71i3DqRpbWxzb5s5M6mBIZMR/SnTrAyFEyTgbk8TsjWfYcioGAK2VBcNaB/BS+6qSzAhRWsT+CzH/QO0ncp7b2EOFxnD9FNy6+F9C4+TNtYlvkPjHH6i0NMPpli4uOAYH49S5Ew6tWhlW8BX3TxIaIUqBz3f8y/sbT6NUzniZfk0q8r+QQNlzSYjSJPpvWNQGrB2gWqf/pl4/+TlZSVmk7tuHS9X/qutTU1FpaVj5+OAUEoJTp07YN2mMxkq+ekuCvKtClAKN/N1QCrrV9Wb8YzWoVt7R3CEJ8WjTZcC5P0CfDXV65ZR51QWPwJyF71JuGhIavcaOfzsHo7KysK0XhLZKZQA8R72Ex4svYluntrSyPgCS0AjxgKVk6Fi8KwJLCw2jg6sB0DTAna3j21O1nCQyQpQKJ36Cn14E96o53UsaDQpIb/M5SeE7yXrvMyrM+QAAC3t77Js3R5+cjD4p0XAJ21q1zBT8o0kSGiEekEydnlX7LzFv2zluJmdia23BU00qUt7JFkCSGSHMJT4Sjq3JGQsT2CmnrGYouFdFBXYjdddOksJ3krR1K7qYGMNp5V+bYFjwrtLCBbLInZlJQiNECdPrFeuOXePDzWe4HJczODDAw57xj9XA00Fr5uiEEBz+Gv78EAK7QGAn9KmpJP+1l+QrnUlauRV9wlpDVY29PY7t2uHUqROWTk7/lUsyY3aS0AhRgk5cS2DC98c5FZXTDF3OScsrIYE83bSSrCUjhDmc2wxHvoG2E8AnKKcsqD+6cwdIjgskafQYUv76C5WebjjF0t0dx47BOIWE5MxM0sofIqWRJDRClCA3exv+vZGMk60VI9tX5dnWAdjbyMdOCLM58g2c/AWcKxoSGuVRjQsrbpF987+WGOsKFXDq1AmnTiHYNWqExtKyoCuKUkJ+swpRjM7GJLHt9HVGts+Zu+nrasfCZxrRyM8NNwcbM0cnxCMkWwd/fQQnfoahv4J9zk702bX6E78vhbQ1l6jYRaHRaNBYWODYti3pJ0/mJDGdO6GtUUNmJpUxktAIUQyuxKfy8ZZzrD18Bb2C5pXdaejnBkBILS8zRyfEI0Kf/d+O1ZZWcOIXVPQ/6HZ9g/VjrwCgCezIzfApqNRU0k+cxK5uHQB8poWhsZE/OsoySWiEuA9xKZnMDz/PN3sukpmtB6BrHW/c7OUXoxAPTFIMbHwDoo7BmAMoXTYp+w+QdDqQ5P2ZWBzYRNX/T2gsbG3xfPFFLN1csalU0XAJSWbKvlKf0ISFhTFt2jSjMi8vL6Kjo80UkRCQnpXNFzsv8MXOCyRn6ABoUcWdiV1rGlpmhBAlRCnISATb/9/7yM4V/emtJEdmkDTmOZIPnECflGSobpGpR3fzJlaengB4vviCOaJ+6OiVnstJlzkbf5YzcWdo4dOCJt5NzBZPqU9oAOrUqcOWLVsMzy1lcJYoBVbuu0hyho46vs683rUm7QI9pc9diJJ2+QCsGwMO5dA98Q3J27aRtGUrKbtcUFk6YC8Alp6eOHXsiFPnTtg3b46FtMDcl1Phpzix+wSpbVO5YHWBc/HnOHfrHGm6//ap0ul1ktDcjZWVFd7e3uYOQzzC9HrF5lMxdKrlhaWFBltrS6b2rINOr+hRzwcLC0lkhCgRGUk5O1o75YxFU7YexO+6TNLVWFJntwG93lDV2s/v/2cmdcKuQX00FrI0gqmy9dlcSrpkaHU5F3+Os/FnqTWhFm4X3dj98m6uNb5mqK+11FLNtRrV3apTv1x9M0ZeRhKac+fO4evri1arpXnz5syYMYMqVaqYOyzxCFBKsf3sDWZvPMOpqEQ+fKo+fRrn9Lt3r+dj5uiEeMgdXIraMAldwONYD/4ip8yzMrGX/dHdvAXosa1dG8dOORs/agMDpZW0CJRSpMSkcPnMZZJrJHM2/mzOI+4s52+dJz07Pc857nXd0ZfXU9u/NqH1QqnuXp3qbtXxc/LDyqJ0pBKlI4pCNG/enK+//prq1asTExPDu+++S6tWrThx4gQeHh75npORkUFGRobheWJiYr71hCjM4UvxzNpwmn0RcQA4aa1I12WbOSohHmLR/4CTDzjk/G7PzHLh0i9O6HW7COyfhcbaGo1Gg8dLYyA7G6eQEKwrVDBz0KWfTq/jUuL/t7rEn+HfE//iMcSDbOtsfvr8J7ijIcvW0pZAt0Cqu1U3PAL7B+KidTHPCygijVJKmTsIU6SkpFC1alVef/11xo0bl2+d/AYSAyQkJODs7FzSIYoy7vz1JGZvPMMfJ3P2bLGxsmBoS39Gdagma8kIUUL0P7xE6h8/kl3zaVzGzQNAZWZyrk1r9OmZBHz/HbY1apg5ytJLKUVWahaplqmGxCW35eXfW/+Skf3fH/no4YlRT5DmmsbZd84SUCWA6m7VqeFWg+pu1ankVAlLi9IxVjUxMREXF5cifX+XuYQGoHPnzlSrVo2FCxfmezy/FppKlSpJQiOKpN+iPeyPjMNCA30bV2Rsp+r4utqZOywhHg76bPh9AvqIA6Q3fpe0s5GkHTlKyo5w9OmZWLnaUW3PIUPXUdrf/6CtUhkLBwczB156ZCZncu34NU7tO0XkkUhi/4kl62wWNxrd4M8Rf+Z7jp2VnaHVpYZbDao5VKOGVw2cbJzyrV9amJLQlPoupztlZGRw6tQp2rZtW2AdrVaLVvbaEEUUn5KJlaUGJ9uczeUmdKnB4l0XeK1LDaqVL90fdiFKtRtn4NgqlI0TGd49Sf/7b9KO/03a1k1kxOpBvWRU3crTA8dOnVCpqWj+P4Gxq1fXHJGXKnHpcYZBumfjz5I4NxHPnzyN6lhggc2lnBbkio4Vc7qK3P9rdanoVBELzcM9SLrUJzQTJkygZ8+e+Pn5cf36dd59910SExMZOnSouUMTZdit1Ez2/BvLn+dv8uvRawxp5c9rXWoC0KyyO80qu5s5QiHKmMv74eJuqNUTPHK2/sg4tpfoaV+TFq9F6b664wQNlp4e2NVvgF29uji0aIFtUNAjOzMpLT4Nja2GS+mXjGYXnYk/w820m0Z1K5WrhIOrA8mVkrGqboV7XXcCGgXQs1FP3i3/Lo42jmZ6FeZV6hOaK1euMGDAAG7evEm5cuVo0aIFe/fuxd/f39yhiTJEKcWef2PZdf4mf52/yfGrCdze2brvQhz/196dx0dV3Y0f/8w+k2Um+0YgCYR9CbuyWFB2FTesuBa08qgV9/prxVrQaqHUx8etan2wVqsVfRTQuqCogLIpAgqiQoCEQBISsk+S2ef8/hhyYbIAikAmfN+v17zC3HvuvefkJJkvZw0GlUy/FuJYggEo/x5q9kKvC7TDzufnULNuF9Hn7iThD88AoM89m8aDodZyXZQNW7/+2Ab0x9p/ALYB/TGmpZ2xs5IqXBXazKKCKwvQb9fz+f2fU9a9rEVaHTo6x3bWWl26j+1Oz0d70immU4dvdfkx2n1As3jx4tOdBRGBgkFFcY2LzglRAOh0On6/ZBtFVY1amu4pMYzKTWJMz2TGdE+WYEaI5pSCumJAB45OBL1ePF98jOu5X+OutpH0dE/MXXMB8JlzqS8uhh/KaGrfNGX3JGPhX7D06oWlW7czcsdqb8BLQW1BaJBu1U6t1aXKXaWlGWkcSQYZ2EptxPSJCc0qiu9Oz4RQd1H3uO5EmaJOYykiQ7sPaIQ4XsU1LtbmV/D5rgrW7arA6w+y5Y8TMBpC/4O5KC+DkhoXo3KTGJWbRJrDeppzLEQ743GCOQZ0OlQwiPe1e3CveA2XeSiummg833+P8vmAOACiNqzRAproa39HSueziRoyJOyWjosuOsWFOD2UUlS4Kti6fSsb79iIq8LFtke3UVBTgF/5W6TXoSPLnkX3+O7kLsile2Z3bsy+kYzojDO21epESUAjItqXBVX855sS1uyqoKCiIexclNlAYWUjuSmh/uTfTpIpn0K0KhjA/9g5uHbsxpU7G/eOQlzffkuwrg6IB3ZrSQ1xcVj798c2YADWISO145acHCw5Oac+76eBJ+BhT82esKnRO6t2Uu2pxuA2cOn6S9GjZ2/RXvyxfmLNsdp6Lk2DdLvFdZNWl5+ZBDQiYnj8AbYU1dAnw4790Iyk9bsr+deGvQAY9DryMh2M7p7M6NwkBnaOw2yU/mUhwhSuIbj8Iby+BKy3HerS1xsoWlqHpzIBPv+3llRnsWDt3QtbXp427sXUufMZ0YLgbfBStq2MXV/tYs+mPTgznJRMKiG/Op+C2gICquUim3qdni6pXXA94KJzz848OuJReqX0Ii36zB0rdCpJQCPaLaUUPxxwsnZXBZ/nV/BlQRUuX4BnrhmsbTswvk8KVQ0eRuUmcXa3RC3QEUIAG19A7fiI4MD/wtBvHADesip2P1GETl9Ez5u86A5t2mg9eyx8vwfrwEGHBu72x9qjBzrTmfE75fa72V27m3VPraP0hVKCxUF06nAQUt67nM96fKa9t5vt2hiXI1tdrEYrXHIaCiAkoBHtT0FFA49/vJO1uyqpqPeEnUuKMeN0+7T3fTMcPHhx+16OW4iTzlUN295E1ZXg63Uj7m1bcX2zFdenb+IuriN28P/Q6V+hgMY0cBx6mxV9TAy+8nLMmaG9ydL/+uQZMWVaKUVZY1nYui47q3dSWFdIUAXJzc9l4P6B6NDhcrio61wH3cAx2MEdg+/Quo5So1Kl1aWdkYBGnFZ1bh8bdlcSazUxolto/xazUc/bX4d2c7WZDAzPSeCc7qGBvD1TY2U2kjiz1RZD0XqIyyIQ2x3Xtm9xbVyL+93ncFWaCHiazwzV46k63D2is0ST++kqDHFxYak6YjDj8rt4b+57FK0vwn2Lm/zY0Noudd7W9/eLs8SRMjkF80gzuUNz6Zvbl25x3bAYZKHWSCABjTilfIEgW4pqWLOrgjX5B/lmfy2BoOK8XilaQNMpzsac83sxIDOOQV3isBjPvKmeQgDQWAUlm6HruXBob53G1x6heul7uOoT8VW6jkh8aNae0Yi1V6+w9V7MzQbrNg9mIp1SitKG0hatLkXOIsa8PobE3Yls6LWB/WftB8CoM5LtOLR/0aFuox7xPUi2JUurSwSTgEacEkopbnllM5/nH6TBGz6YLicpWpuJ1OS/ftHtVGZPiNPP74HGSrBnhN4Hg9TdNYiGYkXcvU9jGxOa/uwzZFK3NwoIBTPmrCysAwZg6x9atM7Suzf6Drr1i7vWzbYl2yjaW0Tw6qC2rkt+dT5On7PVaw5MPoAePeeOP5de/XvRI74HXR1dMRtko9mORgIa8bMrq3OzJr+CPRX12nYCOp2OGpeXBm+AhGgzo3KTGJ2byKjcJDLjZeqiOMMoBSqotbr41r6C66Xf4QlkkbRobaiVQK+n7kAyzl0NmL/4Qgtooi76NUm+OGz9B2Dr36/DtbY0UUpRXF+sTY3Or86nYGcBA28aSNAQZGnnpSjj4eW+jXojXR1dwwbp9kjoQdKMpKM8RXQkEtCIE1bv8fPFnspD3UgV5JfXa+duGJVDYkzof4v/b3IvLEY9vdPsMg5GnLECb92O+7P/4Eq5DPcBL66t2/CXlQF2oBpHURHmQ1u72G/8I6bvfsA2frx2vSk1leTf/Ob0ZP5npJSioayByp2V+C1+nDnOw2u6HHo1+MLXlsIMqQNSCaYHGRk/kh5demg7SHd1dMVkODNmZInWSUAjTsiTn+Tz5Cf5+IOH/6ek00H/Tg5G5SYROGLDpMFd4k9HFoU4PepKUB/Mwb1nP+7sX4d2md62Fe/u3aCswPuH0+r1WLpmYRs4JPQLdIh96kXYp3aMlXYDwQBrX1nL9je3U7O7Bm+hFw7tRLJv2D6+uPWLFteY9Ca6xXXTxrj0iO9Bj+k9SLQlnuLci0ggAY04JqUUuw/Wsya/gjW7Krh3Ui96psUCkBFnwx9UZCVGHepGSmJkt0TioqR/WpxBCj5DbV9GMGkwhrOvBSDg05H/0AZUQAc8FJbclJqEdeBgbAPysOUNwNqnD/qojtH1WuuppbCukMLawrCvRXVF5C7Jpc9/+mhplU7RkNSAx+4hxZZC94Tuh7uL4nuQ7cjGpJdWF3F8JKARrSp3ulm3q5LP80O7Ux+oc2vnzu6aqAU0E/um8nnOudomkEJ0aMEg7FwOxZtQ59yDzhz6ua//YAklz32AJXMtWe+HAhpDYjrGpHgC9R5seQOx5uVhOzR415gU2eM6fEEf++r28Z+L/oNzhxPfsz4KbaHA5chNF5urGFhBcXwxjm4O0nunk9Mrh64pXcm2Z+OwyHpS4sRIQCNa+KqwisufWx92zGzUMyw7nlG5SZzbK0U7breaZHVe0TH5XFDyNQQ8BNPPwv3dd7i2bsX9xgJc5UESbzASf+t9ABj7jSXg/RBPZRCllDb1N3vJuxgSEiJmKnDQH8Rd4yYqKQqlFFXuqlZbW/Y79+NXfiblTyK2PJY1X6yhvE+5dp8UWwrZjmyy7dlhXzOiMzDoZRkGcXJIQHOG8geCbC2u1XanHpIVz+8mh2Yk9evkwGrSk5sSo3UjDctOwGqSP0SigwoGoWIHxKSiLA48u3bjXv4iro9exVXnwFOlINC03IAe0OPKL6JpVJhl5IVk/18u1p49woIXY2L7H+vhCXgoqitiy9tb+H7W9wR7Bdm1YBcFdQU4va1PhQawGW1UzK7AkGjg0rxLyUnN0YKXaFP0KSyBECES0JwhlFIUVDRo+yKt31OJ0314S/s6l08LaKwmA1/9YQIxFvnxEB2UqwZscdrbhj9NpH7LDtz6vrgKD6IaD41WJRoI/Z4YkpNCY14GhBars/brp12vMxqx9T/8/nRTStF4sJHK/EocXRzYM+2UN5aHtbIU1BVQWFtIaUMpQRXEUeRggn8C7hI3Wyu2AqBDR3p0eovWlhxHjiz9L9od+cTqwBq9fqLMh6v4qv/dQFnd4b2RHDYTI7uF1oI5p3t4n74EM6LDUEqbOaQqdtPw5wtxH/CR8MI29DYbAHVFZmp+iAFCO7fro6Kw9uuHbcAArAP6YxswAGNq+/4A/+LJL9i7fi8HfjhA3e46As5Qi1LpjaVsGbuFRn9jm9fGmGLoPKAz7v9zk9Mth0fjHyXbnk2WPSu02aIQEUA+tToQlzfAl4VVrMk/yJpdlZTXudl4/3j0eh06nY7zeqVQWNHI6O6hbqR+nRwYZD0Y0UEFv/wnnnefwZ9yFrGznwoddGRS8mmQgNtE1FeriTpnMgAxV94GndZjyxsY2iqga1d0hvbZxRpUQUobSg+3tNQWUFhXSOz/xhL3bZyWTukUjQmNHHAdoNHfiEFnoFNMp1ZbWxKtie06WBPieEhAE+F2HHDy8fdlrMmvYNPearyBYNj5PRX15KaEZiT9+dL+8kdLRL5gEHyNYInR3qsVc/FuW4+7yw24duwJDd79bjsEghhjVxE7O5RUZ7IQO2EiQb8BfWIX7ZaxE6YQO2HKaShM66oLqll6w1IanA1kv56tBS1N0589AU+La7qM7IKtt41g5yDxufFk9MygZ3JPJjkmkWPPoXNsZ1l4TnRoEtBEEKUUeysbSbVbsZlD/3t8++tinlm1W0uT4bCGWmC6JzOyWyJJMYf3dJFgRrRrfi8Yj1i/aPPLqMo9MGgmuqRsAHyfLsK5aC5+W1cCGefir6oiUFGB54dvCHoA/hR2S0NsFJYB/Qm6XFr3Uvpfnzo15WkmGAgS8AQwRR0OKvxBP8X1xS1aW4r3FTN61WgAFn26iKA5/D8qRr2RLrFdwltapuSQbc8mzhp3KoslRLshAU07V9XgZd3uCm1Ru/3VLl6YMZRxvVMBOK9XCrvK6zmnexKjcpPISYqWwEW0H8Eg6PXaW/XNGwQP7CLQeSJ+j4FAVRX+bZ8Q2PAaAXMGKS+t0X5+Sx56lNofvKTdqiP+trkAeGu8lG22AxXA/4U9SmcyYu3TC9vAIdq4F1NmZrv4ffjooY/44pEvSLguAc8tHi2A2efchz/ob3mBCb74ry8wdTYxOH0w2YmHu4ey7dlkxGRg1MufbyGOJL8R7VBxjYuX1xeydlcF20vqOGL3AEwGHXsrDw/uG5qdwNDshNOQSyFC1DdL8O/biX7QNAydugPg+fgf1Px9PgFdEv64/gQqq/BXVxEoK0UFAP7V7C5WoIqk+noMsaEuUl1yDvywE3/j4V8A06CJxI7fhjElHUNSEsaERAyJCZg7dcLSvTs606npUmmsbKRyZyVpA9Mw2ULP9AV8FDmLKKw9PIOoqZsoKT+JQd5BfPP1N6z/NnyNJ6vBShd7lxbjWrKvzibGHNPa44UQrZCA5jQLBhXbS+rQ66FvRmilTLcvwN9X79HS9EqLDa0H0z2J4dkJRMsMJHESqWCQwJZ3COzbgT9uIAG3wl9ZSWDnl/i3fkQAB52WrNdaPornzMW520/qLW4S7pgHQKDeS9U2I1ADfN7iGTqrBWNSMobEBIxxDgx2G8aUjLA0yfNfIFkpDPGH9wAz5+SS+fSzJ6nkrfO7/ax7dB2VOyup3FlJRX4FnqrQGBbLPy0UdSoKdRPVFxNUwVbv4Trbhf9sP+ld07ky/kqyHdnk2EPrtqRFp6HX6Vu9Tghx/OST8TTYV9WobSmwdncFNY0+zu+fxjPXDAGga1I014/KJi8zjpG5iaTEyrRJceJ8X72Dv+AHjEMvxJQT2k/HveJlKp9cSCAQhd+Ugb+qkkBV9RGLyLWmlqDTicFuB8CQ1hkKClCBwx/KpkHjSfjlbgxpmRjTMjEkJGBMTMSQkIgxIf649i06ndsDuPwuiuqKKKgroKC6gLI/laHzhnddNSY08tl3n1HO4RVyo4xRYbOImoKWLrFdiDLJ9iBCnEwS0JwiSinmvrOdVTsOUlQVvh5EjMWIzXS4KnQ6HXOn9j3VWRQRRPl8+KurCXz3Of7iXQQsnQk0+PBXVuEv/JZA/kYCfgtZH36B7tAYlrJ5f8C5y0fqTfUk3BXaLDHoclOXHwCcwI6wZ+itBozJKRhSMzDGJ2CIi8FoBUNaZtiU5tRnlpJmMmnPATBl5ZL6p7+e9O/DT7Hn4z2sXbiW5D7J5D2cF949dOhraUNp2DV9J/XFb/FTn1pPQ1oD9q52uqR0YaJ9ojauJduRTbItuV2M2RHiTCQBzUng9gXYvLea3QfruW5ENhAKUrYV11JU1YhRr2NQlzhG5yYzunsieZlxGA3S5CxC3GvfxbvzW6wjpmDulQeAa/m/KH/00dBAWq+ZQG3tcdzJR6C2FuOhLhtTRgbG8mJ05sMtfuYh40iZtR9jehcMXXpjTEwItaLEx6EzH9+O6XqL5diJTjIVVKigQm9s+XvU4GsIG9eyf8N+bCtsbN61mXsH3dvmPe1m++ExLY8cClrs2XSxd8FskN3khWhvJKD5GQSDiu8P1GkzkTYWVuH2BTHodVw8qJO2eePt53UnqBRndU2UlXjPAEGPh0BlJf7KKgIFW/GXFBAI2vE7XQSqKvEX78G/L5+AG3LXb9ZaOCoW3I8z30vqf9WTcCigUX4vjfu9h+7sCn3R6zFEGUKtJp26YezUFUNiIsZYGwZ9Hcb0LG2qMkDq88tJbZZHY6duJN7z0En+TrQt6A/iqfPgcXrw1nvxOr14nB5Q0G1it+O6x7IZy9j+xnbG/GMMwXOCYYNxC2sLOeg6GJbeEmsh7ddpODOcGHVGMmMzw7qHmlpb4i3x0toiRASRT9UT9MKaAp5ZuYvKBm/Y8ZRYC6Nzk2jw+LWA5shdqkXkUcFgWLdKw8fv4Nn+DVFjJmEdOByAxg9epeShhQQaAwQ9RxuHEu7IlhRLVjr+hhIM9ljtvGXIeXS6pwRDejbGnmdjSEzE4HC0u9Vsv37pa5zFTgZcNwBHZ8cx02/79zaWzVjW4rg51Uzeujwa/A00eBto8DdQ762n0d9Ig6+Bel89jb5G6n31ZP6QSaI7kf9Z9j/s9O5s9TkJ1oSwac/Zl4UCl06xnTDpZbE5IToCCWhOkMWop7LBS5TZwNldExl9aDZS95QY+d9dO6eCQYJOJ4Ha2tAsnqoq/MWFBA4U4XdBoLY+tHBbWTH+8lIC7gC9tm7TgoiaJx+gbqeXVK9LC2h0yoOv+nBwqzOZQq0meicGkwdjt8EYsvuFunaizRg9RRgycjBEH96dOPnp5SQ3y6shPQf7rAd+XPmUwtfow+v04q33aq0gKf1SsMXbjnn97o928+FdH5I6IJVpr00Lu68n4NGCiiMDjA2PbMCd7+bb1G8JDA7Q4Gto8dKu8zdg/8rOWZxFwBjAb/Pjs/rwW/y449z8+/N/H1c5S6aVwDTwp/jJjcsNG9PS9NVutv+o750QIvJIQHOCJvdLo0dqLAM7x2Fupf9enFxBr5dgbS2BQ4FJsK6OYH0D9gvO19JUPf4QjVu+Ie7qGcRMugiA+ndeZt//m/+jnxeortZm39hy01CB/ZhSD08rtgwdR9YfS0PdP4MvRB/z8wS25d+Ws2/dPuK7xtN1fNdjpldK8Yj1EQLelq1EE5ZMIO4XcS0DjGYtH55NHqK/i2affx+vvP1KWFASUK23PvXt2RdrmpWPDnxE3da6Y+azbmAd+xftRxkVUcYook3R2mu4aXjY++avGFMMUabQNYnWRNKj0zHo21eLlRDi1JGA5gQlxVjCthcQP523sBBfeTnm7GxMKaHuOfe2TdS8+jKBBhdBr55AXR0BZx3Bg6UEGtwof+vrfsROnKAtsuZauRTnDje2vmu1gMZgPHydLioKY0JCaE0UVyEGajH2Pw9jj7NCA2Sj9BiqNmHMzMWQcHgRw7i/fkDUoXEfB78/iMlmIi47i6ir7z9mWV+Z/AoN5Q1c9Z+rsHdqvfVAKYXL76LR38jGZRv56oGvyLgsg7099rbaFdO8S6arqStGb+hX3Gf14bf68Vv9PLDhAcrrylt95pHMsWYcv3PgifFQV9N6cBJtiibaGE2UKYoYUwzRs0PBxhjTmMPH2ghCmv4dY4rBZrRJMCKEOCES0IifRdDlwl9WdqilpI5gXS2BOieByjKCVQcJeIIE6htDx6sOEqgsRynovuYL7R4HZk+nYVcd6ffcSNysewDwf/MJ1cs+OvrDdTr0djsGmwmDpwR9tI2gx4vhUEDjOKcftqxCoobmaZdYzx5P96dqUPFZ7NrXi8YGHwOuHQBKQastKodbfD6850O+evYr/K7wJev7Tu/LtNem4fK7Wm35OLKFo/jLYlS1YuEnC2no3HaXTNNCbemV6eQMyuEbyzfkr8w/rjrZMX8HfrOfgDkAhxoPdeiINkWTYkppEVREm6KJMkYRY45pvVXEGE20OfQ1xhwKQmRBOCFEeyEBjUAphXK7CdTVEayrC7WC1NYRdNYRqKlF+T0k/nqWlv7AXTfS+O1OUn73O2LGXwCA87W/UbLwhR//bL8fnTH0Y2iO9uOz+yDYiM/lw1vvpTE6G3IcJHeLxjj2llDgYrdj2L8Kva4Rw6BL0GcPDA3W9Taw8YnVbH+nmH6vfs/Qm4YCEPPb5svsgy4hE+OEO3FVu3hj2EIAkqcm48bdIrBoCkaa/u3e78bgOtyaEDQGCVgDfFTyEX/615/aXC32SGkz0kAPFY0V+Ita2cvnyLyio35YPbtH7ibaFM0A0wAtCGmtteNoXTRWo1WCECFEhyQBTQehgkGUy4X+iMGl9WvX4i8tJXrkSEwZoWXl6z9+j6oXXyTQ6CboDmpBjPL52ry33qwPC2i829fj2RfEv2c7EApoDGaF3hhEbzNhyMjFEBtLeUMSDfv2kB5XSMKY8RiyB2Gwx6IP1mDY+yGG9G5hGxcGZyzk/67cgPc3AdTNfz4iB1P4ff3vCZgDNPobcflduHpeFvrqd+Hav1r79/4f9lOzpoYDWZV8MugTrctGS+sLf+92uxmeOxy/1c+U16cQsBx7ZpJltAXDMAN+mx+/xU/QdEQAc2jbIb1O32bLRpQxiuheLbth2gpGbEabDDAXQohjkICmHVFKaR9cvgMH8OzcGeq2qas91HLiJHCwhGBtNQGPIuB0EqxzEqipItjQiDE+lu7rvtTuV/GHW3CV+sh85HeYps1EKYX768+o/GIXvqAJf9CIzejCajwUzOgUhthY9PEJGGLtGAwe9FVbMSQkUZlfyTu/fgdztJnLpg4hoaYSy8jh2rNipl5Nbr9MXDHJuDLycPldfHPlRxRviqP3X64h8crEI4IKHa6uY0L/3vgX7binxEOiMzHse+K3hMZ9jPznSLwx4VPjW+PIchB7SyzODCe13x/P4nOw6g+rADDoDNhN9qMORG0rCGkekFgNVglChBDiFJKA5meklCLYcGicyBGzbsKCkuoq9DYLKf/vPu26vZdOwrW7hM5/e4Loc84DwPnq45T979utPqfBF0VZYypmvZfM2GLteMDZEJbOlqow6NwYLIrnhz5P6eZSUFHApVqaQfd0ofOvOtFYshqX3oMrvT8usy3UsuGpxeUZjosgjRsfw/y5mWBMkFvu0OPyx+Da9RiuHx7RWj68wfCAo7e1N4n9E1lbspbSleFLybdGj56oBVH4raHpu0eO/Qgrl9EW9ooyRh1+n23DZrK1SNPiGlNU2PsYUwwWg0WCECGEiFAS0Jygmpf/Tvk/XsHn9ONx+vD79fiDRnQo4qw1rV5jdJjDAprP16VRWdubSat30nP0ufiCPnwxCkO8j6DdTjB7AP5oK75oM97i1RQXO9j+0VlEdVOUPRTAGajA2biHujg7DSvvOtwSckU2rqCHxsZXyKvOw6EOL3TWtN7HooqlFGwpOJy50g9bzbPBYyDt1jT8Nj9lZWVH/Z7odXpsRhsHrzxIvbGeWGMsKcaU4w4ujnZeWj6EEEK0RqeUUqc7EydbXV0dDoeD2tpa7Pafb4GtRl8jK6f+nq8+TGxxLs5WxS/6f4AvMRVPbBTuKCNunDT6SqmLj2Xj1KFa4NH9jk5YCxP45rav2DN0X5trfGj3Loyj75K+ODOcbL1y63Hl1VptRekVfqufgCmAwWA43LJxHC0aYS9Ts1aRZsGHWW+WoEMIIcQJ+zGf39JCcwJe+u4lPnMU0otQQKN0Cr/Vh8/q50AnL4t+YwFqDr2aWAEflK7XjlReVYnBZ6CmS01YMGPUG1vvVulkI2pMFInGRHobex9XANL8Hia9SYIOIYQQHYYENCcgyhjF7vEHODBuFeZoM5YoS1jwMNE48ahBhfaa3HoAInvMCCGEEMdHupxOwJGzkoQQQgjx8/oxn9+ywtYJkGBGCCGEaB8iJqB55plnyMnJwWq1MmTIED7//PPTnSUhhBBCtBMREdC8/vrr3Hnnndx///1s2bKFc845hylTplBUVHS6syaEEEKIdiAixtCcddZZDB48mGeffVY71rt3by655BLmz59/zOtP1hgaIYQQQpw8HWoMjdfrZdOmTUycODHs+MSJE1m3bt1pypUQQggh2pN2P227oqKCQCBAampq2PHU1FQOHDjQ6jUejwePx6O9r6urO6l5FEIIIcTp1e5baJo0n1F0tCnT8+fPx+FwaK/OnTufiiwKIYQQ4jRp9wFNUlISBoOhRWtMeXl5i1abJvfddx+1tbXaa9++faciq0IIIYQ4Tdp9QGM2mxkyZAgrVqwIO75ixQpGjhzZ6jUWiwW73R72EkIIIUTH1e7H0ADcfffdXHfddQwdOpQRI0bw/PPPU1RUxM0333y6syaEEEKIdiAiAprp06dTWVnJQw89RGlpKf369eP9998nKyvrdGdNCCGEEO1ARKxDc6JkHRohhBAi8nSodWiEEEIIIY5FAhohhBBCRLyIGENzopp61WSBPSGEECJyNH1uH8/omDMioHE6nQCywJ4QQggRgZxOJw6H46hpzohBwcFgkJKSEmJjY9tcXfinqquro3Pnzuzbt69DDjiW8kW+jl5GKV/k6+hllPL9dEopnE4nGRkZ6PVHHyVzRrTQ6PV6MjMzT+ozOvoCflK+yNfRyyjli3wdvYxSvp/mWC0zTWRQsBBCCCEingQ0QgghhIh4EtCcIIvFwty5c7FYLKc7KyeFlC/ydfQySvkiX0cvo5Tv1DgjBgULIYQQomOTFhohhBBCRDwJaIQQQggR8SSgEUIIIUTEk4BGCCGEEBFPAppWfPbZZ0ydOpWMjAx0Oh3Lli0LO6+UYt68eWRkZGCz2Rg7dizbt28PS+PxeLjttttISkoiOjqaiy66iP3795/CUrTtWOWbOXMmOp0u7HX22WeHpWnP5Zs/fz7Dhg0jNjaWlJQULrnkEnbs2BGWJpLr8HjKF+l1+OyzzzJgwABtoa4RI0bwwQcfaOcjuf7g2OWL9Pprbv78+eh0Ou68807tWKTX4ZFaK1+k1+G8efNa5D8tLU073x7rTwKaVjQ0NJCXl8fTTz/d6vmFCxfy2GOP8fTTT7Nx40bS0tKYMGGCtmcUwJ133snSpUtZvHgxa9asob6+ngsvvJBAIHCqitGmY5UPYPLkyZSWlmqv999/P+x8ey7f6tWrufXWW9mwYQMrVqzA7/czceJEGhoatDSRXIfHUz6I7DrMzMxkwYIFfPXVV3z11Vecd955XHzxxdofzEiuPzh2+SCy6+9IGzdu5Pnnn2fAgAFhxyO9Dpu0VT6I/Drs27dvWP63bdumnWuX9afEUQFq6dKl2vtgMKjS0tLUggULtGNut1s5HA713HPPKaWUqqmpUSaTSS1evFhLU1xcrPR6vVq+fPkpy/vxaF4+pZSaMWOGuvjii9u8JpLKp5RS5eXlClCrV69WSnW8OmxePqU6Xh0qpVR8fLxatGhRh6u/Jk3lU6rj1J/T6VTdu3dXK1asUGPGjFF33HGHUqrj/A62VT6lIr8O586dq/Ly8lo9117rT1pofqSCggIOHDjAxIkTtWMWi4UxY8awbt06ADZt2oTP5wtLk5GRQb9+/bQ07d2qVatISUmhR48ezJo1i/Lycu1cpJWvtrYWgISEBKDj1WHz8jXpKHUYCARYvHgxDQ0NjBgxosPVX/PyNekI9XfrrbdywQUXMH78+LDjHaUO2ypfk0ivw/z8fDIyMsjJyeHKK69kz549QPutvzNic8qf04EDBwBITU0NO56amsrevXu1NGazmfj4+BZpmq5vz6ZMmcIvf/lLsrKyKCgo4IEHHuC8885j06ZNWCyWiCqfUoq7776b0aNH069fP6Bj1WFr5YOOUYfbtm1jxIgRuN1uYmJiWLp0KX369NH+GEZ6/bVVPugY9bd48WI2b97Mxo0bW5zrCL+DRysfRH4dnnXWWbz88sv06NGDsrIyHn74YUaOHMn27dvbbf1JQPMT6XS6sPdKqRbHmjueNO3B9OnTtX/369ePoUOHkpWVxXvvvcdll13W5nXtsXyzZ89m69atrFmzpsW5jlCHbZWvI9Rhz549+frrr6mpqeGtt95ixowZrF69Wjsf6fXXVvn69OkT8fW3b98+7rjjDj766COsVmub6SK1Do+nfJFeh1OmTNH+3b9/f0aMGEG3bt146aWXtMHN7a3+pMvpR2oa5d08wiwvL9ei1bS0NLxeL9XV1W2miSTp6elkZWWRn58PRE75brvtNt555x1WrlxJZmamdryj1GFb5WtNJNah2WwmNzeXoUOHMn/+fPLy8njiiSc6TP21Vb7WRFr9bdq0ifLycoYMGYLRaMRoNLJ69WqefPJJjEajlsdIrcNjla+1Qa+RVofNRUdH079/f/Lz89vt76AEND9STk4OaWlprFixQjvm9XpZvXo1I0eOBGDIkCGYTKawNKWlpXz77bdamkhSWVnJvn37SE9PB9p/+ZRSzJ49myVLlvDpp5+Sk5MTdj7S6/BY5WtNpNVha5RSeDyeiK+/tjSVrzWRVn/jxo1j27ZtfP3119pr6NChXHPNNXz99dd07do1ouvwWOUzGAwtrom0OmzO4/Hw/fffk56e3n5/B0/KUOMI53Q61ZYtW9SWLVsUoB577DG1ZcsWtXfvXqWUUgsWLFAOh0MtWbJEbdu2TV111VUqPT1d1dXVafe4+eabVWZmpvr444/V5s2b1Xnnnafy8vKU3+8/XcXSHK18TqdT3XPPPWrdunWqoKBArVy5Uo0YMUJ16tQpYsp3yy23KIfDoVatWqVKS0u1V2Njo5YmkuvwWOXrCHV43333qc8++0wVFBSorVu3qjlz5ii9Xq8++ugjpVRk159SRy9fR6i/1jSfBRTpddjckeXrCHV4zz33qFWrVqk9e/aoDRs2qAsvvFDFxsaqwsJCpVT7rD8JaFqxcuVKBbR4zZgxQykVmrI2d+5clZaWpiwWi/rFL36htm3bFnYPl8ulZs+erRISEpTNZlMXXnihKioqOg2laelo5WtsbFQTJ05UycnJymQyqS5duqgZM2a0yHt7Ll9rZQPUiy++qKWJ5Do8Vvk6Qh3ecMMNKisrS5nNZpWcnKzGjRunBTNKRXb9KXX08nWE+mtN84Am0uuwuSPL1xHqcPr06So9PV2ZTCaVkZGhLrvsMrV9+3btfHusP51SSp2cth8hhBBCiFNDxtAIIYQQIuJJQCOEEEKIiCcBjRBCCCEingQ0QgghhIh4EtAIIYQQIuJJQCOEEEKIiCcBjRBCCCEingQ0QkSoVatWodPpePPNN4+Zdt68ee1iw7sfo6l8q1atOuXP/vzzz7FYLNrOwYFAgMcee4zJkyeTmZlJVFQUvXv35ve//z01NTU/+/NnzpxJTEzMz37fE3HddddxySWXnO5sCNEmCWiEEO3S4MGDWb9+PYMHDz6lz1VKceeddzJr1iyysrIAcLlczJs3j6ysLB5//HHef/99Zs2axfPPP8+oUaNwuVynNI+nw7x583jvvff49NNPT3dWhGiV8XRnQAhxmMvlwmazne5stAt2u52zzz77lD93+fLlbN68mX//+9/aMZvNRkFBAYmJidqxsWPH0qVLF375y1/y1ltvce21157yvJ5K3bp1Y/LkySxYsIDzzjvvdGdHiBakhUaIn1FT186WLVu47LLLsNvtOBwOrr32Wg4ePBiWNjs7mwsvvJAlS5YwaNAgrFYrDz74IADffvstF198MfHx8VitVgYOHMhLL73U6jPdbjd33303aWlp2Gw2xowZw5YtW44rv6+//jojRowgOjqamJgYJk2a1OLapu6PH374gUmTJhEdHU16ejoLFiwAYMOGDYwePZro6Gh69OjRZj6be/bZZ8nLyyMmJobY2Fh69erFnDlztPPNu5wKCwvR6XRtvo708ccfM27cOOx2O1FRUYwaNYpPPvnkuPM1bNgwevbsqR0zGAxhwUyT4cOHA7Bv374W+X7ttde4//77ycjIwG63M378eHbs2HFceWiyfft2xo0bR3R0NMnJycyePZvGxkbt/Lhx4+jVqxfNd7BRSpGbm8sFF1xw1Pv/2Lxed911fPzxx+zevftHlUOIU0ECGiFOgksvvZTc3FzefPNN5s2bx7Jly5g0aRI+ny8s3ebNm7n33nu5/fbbWb58OdOmTWPHjh2MHDmS7du38+STT7JkyRL69OnDzJkzWbhwYYtnzZkzhz179rBo0SIWLVpESUkJY8eOZc+ePUfN45///Geuuuoq+vTpwxtvvMG//vUvnE4n55xzDt99911YWp/Px2WXXcYFF1zA22+/zZQpU7jvvvuYM2cOM2bM4IYbbmDp0qX07NmTmTNnsmnTpqM+e/HixfzmN79hzJgxLF26lGXLlnHXXXfR0NDQ5jXp6emsX78+7PXOO+9gt9vp3bu3lu6VV15h4sSJ2O12XnrpJd544w0SEhKYNGnSMYMar9fLxx9/zLnnnnvUdE2aul/69u3b4tycOXPYu3cvixYt4vnnnyc/P5+pU6cSCASO694+n4/zzz+fcePGsWzZMmbPns3f//53pk+frqW544472LFjR4tyffDBB+zevZtbb731uJ51vHkdO3YsSinef//947qvEKfUSdv2Uogz0Ny5cxWg7rrrrrDjr776qgLUK6+8oh3LyspSBoNB7dixIyztlVdeqSwWS4tdaadMmaKioqJUTU2NUurwrumDBw9WwWBQS1dYWKhMJpO68cYbW+SrSVFRkTIajeq2224Le4bT6VRpaWnqiiuu0I7NmDFDAeqtt97Sjvl8PpWcnKwAtXnzZu14ZWWlMhgM6u677z7q92n27NkqLi7uqGmayrdy5cpWzzc0NKjhw4er9PR0VVhYqB1LSEhQU6dODUsbCARUXl6eGj58+FGf+cUXXyhALV68+KjplFJq//79KjU1VQ0dOlQFAoEW+T7//PPD0r/xxhsKUOvXrz/mvZu+50888UTY8UceeUQBas2aNVq5unbtqi6++OKwdFOmTFHdunUL+7lozU/Ja6dOndT06dOPWQYhTjVpoRHiJLjmmmvC3l9xxRUYjUZWrlwZdnzAgAH06NEj7Ninn37KuHHj6Ny5c9jxmTNn0tjYyPr168OOX3311WFdLllZWYwcObLFs4704Ycf4vf7+dWvfoXf79deVquVMWPGtJhZpNPpOP/887X3RqOR3Nxc0tPTGTRokHY8ISGBlJQUbXZQW4YPH05NTQ1XXXUVb7/9NhUVFUdN31wgEGD69Ol8//33vP/++9rg3XXr1lFVVcWMGTPCyhUMBpk8eTIbN248aitQSUkJACkpKUd9flVVFeeffz5KKV5//XX0+pZ/Si+66KKw9wMGDADQvjdKqbA8+v3+Fvdo/nN09dVXA2h1q9frmT17Nu+++y5FRUUA7N69m+XLl/Ob3/xG+7lo/hzVrIvqWHk9UkpKCsXFxa19W4Q4rSSgEeIkSEtLC3tvNBpJTEyksrIy7Hh6enqLaysrK1s9npGRoZ0/2rOajjVPd6SysjIAhg0bhslkCnu9/vrrLQKMqKgorFZr2DGz2UxCQkKLe5vNZtxud5vPhtBYjH/84x/s3buXadOmkZKSwllnncWKFSuOel2Tm2++meXLl/Pmm28ycODAFuW6/PLLW5TrL3/5C0opqqqq2rxv02yl5mU9UnV1NRMmTKC4uJgVK1bQtWvXVtM1H3NjsVjCnvHSSy+1yOORmn5mjtRU10fW7Q033IDNZuO5554D4G9/+xs2m40bbrhBS9P8Oc3HOR0rr0eyWq1nxKwuEXlklpMQJ8GBAwfo1KmT9t7v91NZWdnig6O1tWESExMpLS1tcbyp9SApKanFs1p7fmuDWJs03ePNN9/UWjdOteuvv57rr7+ehoYGPvvsM+bOncuFF17Izp07j5qnefPmsWjRIl588UUmTpwYdq6pXE899VSbM6RSU1PbvHfT9W0FPdXV1YwfP56CggI++eQTrSXjp5g6dSobN25s83xrPzNNdX3kMYfDwYwZM1i0aBG//e1vefHFF7n66quJi4vT0jR/Tk5Ozk/Od1VVFdnZ2T/5eiFOFglohDgJXn31VYYMGaK9f+ONN/D7/YwdO/aY144bN46lS5dSUlKitcoAvPzyy0RFRbX4oH7ttde4++67teBo7969rFu3jl/96ldtPmPSpEkYjUZ2797NtGnTfmTpfl7R0dFMmTIFr9fLJZdcwvbt29sMaF544QUefPBBHnroIWbOnNni/KhRo4iLi+O7775j9uzZPzovTYOLW5vF0xTM7NmzhxUrVoR1tf0UiYmJRw06IfRzdPvtt2vvm6aSN/85uv3223nmmWe4/PLLqampaVH2oUOHnlBem/j9fvbt2xfW/ShEeyEBjRAnwZIlSzAajUyYMIHt27fzwAMPkJeXxxVXXHHMa+fOncu7777Lueeeyx//+EcSEhJ49dVXee+991i4cCEOhyMsfXl5OZdeeimzZs2itraWuXPnYrVaue+++9p8RnZ2Ng899BD3338/e/bsYfLkycTHx1NWVsaXX35JdHS0NoX8ZJg1axY2m41Ro0aRnp7OgQMHmD9/Pg6Hg2HDhrV6zfr167n55psZNWoUEyZMYMOGDWHnzz77bGJiYnjqqaeYMWMGVVVVXH755aSkpHDw4EG++eYbDh48yLPPPttmvjIzM+natSsbNmwICyRcLpc2pf3xxx/H7/eHPT85OZlu3bqd4HclnNls5r//+7+pr69n2LBhrFu3jocffpgpU6YwevTosLQ9evRg8uTJfPDBB4wePZq8vLyfNS9Ntm7dSmNj43HPAhPiVJKARoiTYMmSJcybN49nn30WnU7H1KlTefzxxzGbzce8tmfPnqxbt445c+Zw66234nK56N27Ny+++GKrrRJ//vOf2bhxI9dffz11dXUMHz6cxYsXH/MD9r777qNPnz488cQTvPbaa3g8HtLS0hg2bBg333zzTy36cTnnnHP45z//yRtvvEF1dTVJSUmMHj2al19+meTk5Fav2bFjB36/n7Vr1zJixIgW55sGul577bV06dKFhQsXctNNN+F0OklJSWHgwIGtfv+au+aaa3j66afxeDzaWJKysjKt2+aOO+5occ2MGTP45z//eZylPz4mk4l3332X22+/nYcffhibzcasWbP461//2mr66dOn88EHH/yklqnjtWzZMpKSklp09QnRHuhU8+HuQoifbN68eTz44IMcPHiwxVgXERlKSkrIycnh5ZdfDlvzpb2bNm0aGzZsoLCwsMUA459DIBAgNzeXq6++mkceeeRnv78QJ0pmOQkhxBEyMjK48847eeSRRwgGg6c7O0fl8XhYv349TzzxBEuXLuXee+89KcEMhBYsrK+v59577z0p9xfiREmXkxBCNPOHP/yBqKgoiouLW6wH1J6UlpYycuRI7HY7N910E7fddttJe1YwGOTVV18Nmz0lRHsiXU5CCCGEiHjS5SSEEEKIiCcBjRBCCCEingQ0QgghhIh4EtAIIYQQIuJJQCOEEEKIiCcBjRBCCCEingQ0QgghhIh4EtAIIYQQIuJJQCOEEEKIiPf/AXhOoNWP9ILoAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "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": 8, "id": "3514dbcc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "...running on size 200-by-100\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 400-by-200\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 600-by-300\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 800-by-400\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...running on size 1000-by-500\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "time: [1.1992647359999182, 7.299320128999966, 12.82854260299996, 18.24462229400001, 24.849700052000117]\n", " mem: [2201193984, 8741443072, 18340635648, 32244944896, 50672862208]\n", "loss: [0.004932546988129616, 0.002398667624220252, 0.0018031231593340635, 0.0016320128925144672, 0.0015017074765637517]\n", "time: [1.0918115539999462, 7.192320589999895, 12.530058725000004, 17.595300721000058, 23.84322840599998]\n", " mem: [1022671360, 4736347136, 8919271936, 15629771776, 23909054464]\n", "loss: [0.004932546988129616, 0.0023986678570508957, 0.0018031231593340635, 0.0016320128925144672, 0.0015017074765637517]\n", "time: [1.5313050020000674, 12.998051976000056, 22.683731706999993, 32.07461897500002, 43.82458247700015]\n", " mem: [1376428032, 6968102400, 12693858816, 22039259136, 34300435456]\n", "loss: [0.004932546988129616, 0.0023986678570508957, 0.0018031231593340635, 0.0016320128925144672, 0.0015017074765637517]\n", "time: [1.1050931310001033, 7.212295573000006, 12.514222188999952, 17.61808622600006, 23.88114080499986]\n", " mem: [1295177216, 5857880576, 10680740352, 18955632640, 29061838848]\n", "loss: [0.004932546988129616, 0.0023986678570508957, 0.0018031231593340635, 0.0016320128925144672, 0.0015017074765637517]\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "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.11.13" } }, "nbformat": 4, "nbformat_minor": 5 }