From c5dddcf44770b85e80bd75ba4b1d88fde1c251fc Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Thu, 28 Sep 2023 08:40:48 -0700 Subject: [PATCH 01/16] perf: exploration of better matmul algorithms --- .gitignore | 2 + ...rformance_test_large_matrix_multiply.ipynb | 1401 +++++++++++++++++ 2 files changed, 1403 insertions(+) create mode 100644 devel/performance_test_large_matrix_multiply.ipynb diff --git a/.gitignore b/.gitignore index bbe5206..e6f9724 100644 --- a/.gitignore +++ b/.gitignore @@ -54,3 +54,5 @@ full-stats-*.txt stats-*.pkl summary-stats-*.pkl .hypothesis/* + +devel/*.yaml \ No newline at end of file diff --git a/devel/performance_test_large_matrix_multiply.ipynb b/devel/performance_test_large_matrix_multiply.ipynb new file mode 100644 index 0000000..ae7ca38 --- /dev/null +++ b/devel/performance_test_large_matrix_multiply.ipynb @@ -0,0 +1,1401 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d80c2710", + "metadata": {}, + "source": [ + "# Performance Tests of Matrix Multiply Algorithms" + ] + }, + { + "cell_type": "markdown", + "id": "1100dba8", + "metadata": {}, + "source": [ + "The point of this notebook is to test different matrix-multiply algorithms for doing the vis-cpu algorithm's $V = ZZ^\\dagger$. In this notebook, we don't care about _how_ we got $Z$, only that it is complex-valued, and its shape is supposed to be $N_{\\rm feed} N_{\\rm ant} \\times N_{\\rm ax} N_{\\rm src}$, which is generally _very_ non-square. \n", + "\n", + "We define a number of methods that compute $V$, and test their performance on different shapes of $Z$." + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "31f6b315", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T23:58:52.927596Z", + "start_time": "2023-03-11T23:58:52.814891Z" + } + }, + "outputs": [], + "source": [ + "from scipy.linalg import blas\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pycuda.autoinit\n", + "from pycuda import cumath as cm\n", + "from pycuda import driver, gpuarray\n", + "from skcuda.cublas import (\n", + " cublasCreate,\n", + " cublasDestroy,\n", + " cublasZgemm,\n", + " cublasZherk,\n", + " cublasZdotc\n", + ")\n", + "import jax.numpy as jnp\n", + "import arrayfire\n", + "import time\n", + "from dataclasses import dataclass, asdict\n", + "import yaml\n", + "from pathlib import Path\n", + "import numba" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "58e47f8c", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T23:56:53.165486Z", + "start_time": "2023-03-11T23:56:53.161005Z" + } + }, + "outputs": [], + "source": [ + "h = cublasCreate()" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "c9ca126a-64fc-4f46-b84f-20c52e1a90da", + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "repeats: int = 1\n", + "rerun: bool = False\n", + "precision: int = 2\n", + "nants_redundant: int = 350" + ] + }, + { + "cell_type": "markdown", + "id": "6d508e80-aeb0-4f03-92c2-a580f3921ed0", + "metadata": {}, + "source": [ + "## Plotting Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_timings(timings: dict[str, dict[tuple[int, int], \"TimeResult\"]]):\n", + " fig, ax = plt.subplots(2, max(len(nants), len(nsrcs)), figsize=(15, 8), constrained_layout=True)\n", + "\n", + " for i, (nside, nsrc) in enumerate(zip(nsides, nsrcs)):\n", + " for j, (method, results) in enumerate(timings.items()):\n", + " ax[0, i].plot(nants, [results[(n, nside)].best for n in nants], color=f'C{j}', label=method)\n", + " \n", + " ax[0, i].set_title(f\"Nside={nside}\")\n", + " ax[0, i].set_xlabel(\"Nants x Nfeeds\")\n", + " ax[0, 0].set_ylabel(\"Time [sec]\")\n", + " ax[0, i].plot(nants, np.array(nants) * (results[(np.max(nants), nside)].best/np.max(nants)), ls='--', color='k')\n", + " \n", + " ax[0, i].set_xscale('log')\n", + " ax[0, i].set_yscale('log')\n", + " \n", + " for j in range(i+1, ax.shape[1]):\n", + " ax[0, j].axis('off')\n", + " \n", + " \n", + " for i, nant in enumerate(nants):\n", + " for j, (method, results) in enumerate(timings.items()):\n", + " ax[1, i].plot(nsrcs, [results[(nant, n)].best for n in nsides], color=f'C{j}')\n", + "\n", + " ax[1,i].set_title(f\"Nant x Nfeed={nant}\")\n", + " ax[1,i].set_xlabel(\"nsrc\")\n", + " ax[1, i].set_xscale('log')\n", + " ax[1, i].set_yscale('log')\n", + " ax[1, i].plot(nsrcs, np.array(nsrcs) * (results[(nant, np.max(nsides))].best/np.max(nsrcs)), ls='--', color='k')\n", + " \n", + " ax[0,0].legend(frameon=False, ncols=2)\n", + " return fig, ax" + ] + }, + { + "cell_type": "markdown", + "id": "3ae38109", + "metadata": {}, + "source": [ + "## Make Test Arrays" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "91f49fdf", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T23:59:25.853724Z", + "start_time": "2023-03-11T23:59:13.956196Z" + } + }, + "outputs": [], + "source": [ + "def getz(shape):\n", + " return (\n", + " np.random.random(shape, dtype=np.float32 if precision==1 else float) + \n", + " np.random.random(shape, dtype=np.float32 if precision==1 else float)*1j\n", + " )\n", + "\n", + "# Note that \"nants\" here represents Nants * Nfeed, which is why we \n", + "# go to double the number of ants that HERA has.\n", + "nants = (100, 200, 400, 700)\n", + "\n", + "nsides = [32, 64, 128, 256]\n", + "nsrcs = [2 * 12 * nside**2 for nside in nsides]\n", + "\n", + "z = {}\n", + "for nant in nants:\n", + " for nsrc, nside in zip(nsrcs, nsides):\n", + " z[(nant, nside)] = getz((nant, nsrc))" + ] + }, + { + "cell_type": "markdown", + "id": "89f69d4d-6dcb-4b2b-afb1-db57174b5fab", + "metadata": {}, + "source": [ + "Use the smallest array as a test" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "47990a53", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T23:59:26.744576Z", + "start_time": "2023-03-11T23:59:26.722326Z" + } + }, + "outputs": [], + "source": [ + "z0 = z[(nants[0], nsides[0])]\n", + "v0 = np.dot(z0, z0.conj().T)" + ] + }, + { + "cell_type": "markdown", + "id": "3011052a-34ea-4d6a-b7ec-dbb81109ebac", + "metadata": {}, + "source": [ + "## Scaffolding for methods" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "81e2e7b8-3a06-45c6-8cd6-973e56b6284f", + "metadata": {}, + "outputs": [], + "source": [ + "class Solver:\n", + " def __init__(self, z: np.ndarray):\n", + " self.z = z\n", + " \n", + " def setup(self):\n", + " pass\n", + " \n", + " def compute(self):\n", + " pass\n", + " \n", + " def __call__(self):\n", + " self.setup()\n", + " return self.compute()\n", + " \n", + " @classmethod\n", + " def test(cls, rtol=1e-5, atol=1e-5):\n", + " obj = cls(z0)\n", + " result = obj()\n", + " np.testing.assert_allclose(result, v0, rtol=rtol, atol=atol)\n", + " \n", + "class RedundantSolver:\n", + " def __init__(self, z: np.ndarray, pairs: np.ndarray):\n", + " self.z = z\n", + " self.pairs = pairs\n", + " \n", + " def setup(self):\n", + " pass\n", + " \n", + " def compute(self):\n", + " pass\n", + " \n", + " def __call__(self):\n", + " self.setup()\n", + " return self.compute()\n", + " \n", + " @classmethod\n", + " def test(cls, rtol=1e-5, atol=1e-5):\n", + " # All the pairs.\n", + " nant = z0.shape[0]\n", + " pairs = np.array([(a, b) for a in range(nant) for b in range(nant)])\n", + " obj = cls(z0, pairs)\n", + " result = obj()\n", + " np.testing.assert_allclose(result.reshape((nant, nant)), v0, rtol=rtol, atol=atol)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "e18d0954-6520-4d7a-971d-9370d4b89989", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclass\n", + "class TimeResult:\n", + " times: list[float]\n", + " n: int\n", + " \n", + " @property\n", + " def best(self):\n", + " return np.min(self.times)\n", + " \n", + " @property\n", + " def mean(self):\n", + " return np.mean(self.times)\n", + " \n", + " @property\n", + " def repeats(self):\n", + " return len(self.times)\n", + " \n", + " @property\n", + " def std(self):\n", + " return np.std(self.times)\n", + " \n", + "def get_timing(sln, repeats: int = repeats) -> float:\n", + " sln.setup()\n", + " \n", + " # this timing is not even used because it could contain\n", + " # caching and other overhead.\n", + " t0 = time.time()\n", + " sln.compute()\n", + " t1 = time.time() - t0\n", + "\n", + "\n", + " # Need to do it at least twice to check if the time comes down.\n", + " t0 = time.time()\n", + " sln.compute()\n", + " t2 = time.time() - t0\n", + "\n", + " n = int(2 / t2) + 1\n", + " \n", + " if n == 1:\n", + " times = [t2]\n", + " \n", + " for _ in range(repeats - 1):\n", + " t0 = time.time()\n", + " sln.compute()\n", + " times.append(time.time() - t0)\n", + " \n", + " else:\n", + " times = []\n", + " for _ in range(repeats):\n", + " t0 = time.time()\n", + " for _ in range(n):\n", + " sln.compute()\n", + " times.append((time.time() - t0)/n)\n", + "\n", + " return TimeResult(times, n)\n", + "\n", + "def get_timings(solver, repeats: int=repeats, rerun: bool = rerun) -> dict[tuple[int, int], float]:\n", + " out = {}\n", + " \n", + " # First, test the solver.\n", + " solver.test()\n", + " \n", + " for size, zz in z.items():\n", + " print(size, end=': ')\n", + " \n", + " pth = Path(f\"{solver.__name__}_{size[0]}x{size[1]}.yaml\")\n", + " if not rerun and pth.exists():\n", + " with open(pth, 'r') as fl:\n", + " o = out[size] = TimeResult(**yaml.safe_load(fl))\n", + " else:\n", + " sln = solver(zz)\n", + " \n", + " o = out[size] = get_timing(sln)\n", + " del sln # Ensure memory is freed.\n", + " \n", + " print(f\"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]\")\n", + " \n", + " # Cache it\n", + " with open(pth, 'w') as fl:\n", + " yaml.dump(asdict(o), fl)\n", + " \n", + " return out\n", + "\n", + "def get_timings_red(solver, repeats: int=repeats, rerun: bool = rerun) -> dict[tuple[int, int], float]:\n", + " out = {}\n", + " \n", + " # First, test the solver.\n", + " solver.test()\n", + " \n", + " for redfrac, p in pairs.items():\n", + " for (nside, nsrc) in zip(nsides, nsrcs):\n", + " size = (redfrac, nside)\n", + " print(size, end=': ')\n", + " \n", + " pth = Path(f\"{solver.__name__}_{size[0]}x{size[1]}.yaml\")\n", + " if not rerun and pth.exists():\n", + " with open(pth, 'r') as fl:\n", + " o = out[size] = TimeResult(**yaml.safe_load(fl))\n", + " else:\n", + " sln = solver(z[(nants_redundant*2, nside)], p)\n", + "\n", + " o = out[size] = get_timing(sln)\n", + " del sln # Ensure memory is freed.\n", + "\n", + " print(f\"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]\")\n", + "\n", + " # Cache it\n", + " with open(pth, 'w') as fl:\n", + " yaml.dump(asdict(o), fl)\n", + " \n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "65f02230-958d-4d75-9abb-76c5978cb93a", + "metadata": {}, + "outputs": [], + "source": [ + "timings = {}" + ] + }, + { + "cell_type": "markdown", + "id": "a981c9bd-fa7e-4260-b4a2-4c509dd03bf9", + "metadata": {}, + "source": [ + "## Full Dot-Product Methods" + ] + }, + { + "cell_type": "markdown", + "id": "76cffc27", + "metadata": {}, + "source": [ + "### CPU" + ] + }, + { + "cell_type": "markdown", + "id": "600df1cd", + "metadata": {}, + "source": [ + "#### np.dot" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "b859bdb0-9d6e-486b-a247-049c25e3f2c9", + "metadata": {}, + "outputs": [], + "source": [ + "class NpDot(Solver):\n", + " def compute(self):\n", + " return np.dot(self.z, self.z.conj().T)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "a75dfb83-f390-47f4-a04a-3faa27f0db24", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 32): 4.537e-02s ± 0.000e+00s [1 loops of 38]\n", + "(100, 64): 1.921e-01s ± 0.000e+00s [1 loops of 7]\n", + "(100, 128): 5.643e-01s ± 0.000e+00s [1 loops of 3]\n", + "(100, 256): 2.189e+00s ± 0.000e+00s [1 loops of 1]\n", + "(200, 32): 9.882e-02s ± 0.000e+00s [1 loops of 22]\n", + "(200, 64): 3.205e-01s ± 0.000e+00s [1 loops of 6]\n", + "(200, 128): 1.062e+00s ± 0.000e+00s [1 loops of 2]\n", + "(200, 256): 4.268e+00s ± 0.000e+00s [1 loops of 1]\n", + "(400, 32): 1.990e-01s ± 0.000e+00s [1 loops of 10]\n", + "(400, 64): 7.316e-01s ± 0.000e+00s [1 loops of 3]\n", + "(400, 128): 2.385e+00s ± 0.000e+00s [1 loops of 1]\n", + "(400, 256): 1.016e+01s ± 0.000e+00s [1 loops of 1]\n", + "(700, 32): 4.552e-01s ± 0.000e+00s [1 loops of 5]\n", + "(700, 64): 1.916e+00s ± 0.000e+00s [1 loops of 2]\n", + "(700, 128): 5.792e+00s ± 0.000e+00s [1 loops of 1]\n", + "(700, 256): 2.275e+01s ± 0.000e+00s [1 loops of 1]\n" + ] + } + ], + "source": [ + "timings['np.dot'] = get_timings(NpDot)" + ] + }, + { + "cell_type": "markdown", + "id": "ece92a57", + "metadata": {}, + "source": [ + "#### zgemm" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "600b4875-b401-4a4e-8143-a7d7a3767359", + "metadata": {}, + "outputs": [], + "source": [ + "class NpZgemm(Solver):\n", + " def compute(self):\n", + " return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "a24fd6ff-6a74-4755-b5a8-52703452a73d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 32): 1.316e-01s ± 0.000e+00s [1 loops of 17]\n", + "(100, 64): 3.535e-01s ± 0.000e+00s [1 loops of 6]\n", + "(100, 128): 1.255e+00s ± 0.000e+00s [1 loops of 2]\n", + "(100, 256): 4.666e+00s ± 0.000e+00s [1 loops of 1]\n", + "(200, 32): 2.316e-01s ± 0.000e+00s [1 loops of 10]\n", + "(200, 64): 7.361e-01s ± 0.000e+00s [1 loops of 3]\n", + "(200, 128): 2.506e+00s ± 0.000e+00s [1 loops of 1]\n", + "(200, 256): 1.010e+01s ± 0.000e+00s [1 loops of 1]\n", + "(400, 32): 4.873e-01s ± 0.000e+00s [1 loops of 5]\n", + "(400, 64): 1.897e+00s ± 0.000e+00s [1 loops of 2]\n", + "(400, 128): 7.242e+00s ± 0.000e+00s [1 loops of 1]\n", + "(400, 256): 3.057e+01s ± 0.000e+00s [1 loops of 1]\n", + "(700, 32): 9.058e-01s ± 0.000e+00s [1 loops of 3]\n", + "(700, 64): 3.519e+00s ± 0.000e+00s [1 loops of 1]\n", + "(700, 128): 1.344e+01s ± 0.000e+00s [1 loops of 1]\n", + "(700, 256): 5.758e+01s ± 0.000e+00s [1 loops of 1]\n" + ] + } + ], + "source": [ + "timings['np.zgemm'] = get_timings(NpZgemm)" + ] + }, + { + "cell_type": "markdown", + "id": "160dc508", + "metadata": {}, + "source": [ + "#### zherk" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fed2f857-4570-40e3-a8b3-3b1250a73d3a", + "metadata": {}, + "outputs": [], + "source": [ + "class NpZherk(Solver):\n", + " def compute(self):\n", + " return blas.zherk(alpha=1, a=self.z)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3e78c7d-2b07-425d-a829-d69e59fbbc2d", + "metadata": {}, + "outputs": [], + "source": [ + "timings['np.zherk'] = get_timings(NpZherk)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "b0090363-f235-4890-a2da-181be2852031", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_timings(timings)\n", + "fig.suptitle(\"CPU Timings\");" + ] + }, + { + "cell_type": "markdown", + "id": "3bc7799e", + "metadata": {}, + "source": [ + "### CuBLAS" + ] + }, + { + "cell_type": "markdown", + "id": "51b8caf5", + "metadata": {}, + "source": [ + "#### cublas.zgemm" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "5ad23c8f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T20:45:55.353128Z", + "start_time": "2023-03-11T20:45:55.345190Z" + } + }, + "outputs": [], + "source": [ + "class CuBLASZgemm(Solver):\n", + " def setup(self):\n", + " self.z = gpuarray.to_gpu(self.z)\n", + " nant = self.z.shape[0]\n", + " self.out = gpuarray.empty(shape=(nant, nant), dtype=complex)\n", + "\n", + " def compute(self):\n", + " nant, nsrc = self.z.shape\n", + "\n", + " cublasZgemm(\n", + " h,\n", + " \"c\", # conjugate transpose for first (remember fortran order)\n", + " \"n\", # no transpose for second.\n", + " nant,\n", + " nant,\n", + " nsrc,\n", + " 1.0,\n", + " self.z.gpudata,\n", + " nsrc,\n", + " self.z.gpudata,\n", + " nsrc,\n", + " 0.0,\n", + " self.out.gpudata,\n", + " nant,\n", + " )\n", + " return self.out.get()" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "6d949ca9-03cc-4834-9099-fd0ba78e30ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(100, 32): 1.597e-02s ± 0.000e+00s [1 loops of 107]\n", + "(100, 64): 6.254e-02s ± 0.000e+00s [1 loops of 32]\n", + "(100, 128): 2.486e-01s ± 0.000e+00s [1 loops of 9]\n", + "(100, 256): 9.924e-01s ± 0.000e+00s [1 loops of 3]\n", + "(200, 32): 4.867e-02s ± 0.000e+00s [1 loops of 40]\n", + "(200, 64): 1.912e-01s ± 0.000e+00s [1 loops of 11]\n", + "(200, 128): 7.617e-01s ± 0.000e+00s [1 loops of 3]\n", + "(200, 256): 3.045e+00s ± 0.000e+00s [1 loops of 1]\n", + "(400, 32): 1.869e-01s ± 0.000e+00s [1 loops of 11]\n", + "(400, 64): 7.467e-01s ± 0.000e+00s [1 loops of 3]\n", + "(400, 128): 2.987e+00s ± 0.000e+00s [1 loops of 1]\n", + "(400, 256): 1.199e+01s ± 0.000e+00s [1 loops of 1]\n", + "(700, 32): 5.496e-01s ± 0.000e+00s [1 loops of 4]\n", + "(700, 64): 2.196e+00s ± 0.000e+00s [1 loops of 1]\n", + "(700, 128): 8.790e+00s ± 0.000e+00s [1 loops of 1]\n", + "(700, 256): " + ] + }, + { + "ename": "MemoryError", + "evalue": "cuMemAlloc failed: out of memory", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mMemoryError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [87], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m timings[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcublas.zgemm\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timings\u001b[49m\u001b[43m(\u001b[49m\u001b[43mCuBLASZgemm\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn [79], line 72\u001b[0m, in \u001b[0;36mget_timings\u001b[0;34m(solver, repeats, rerun)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 71\u001b[0m sln \u001b[38;5;241m=\u001b[39m solver(zz)\n\u001b[0;32m---> 72\u001b[0m o \u001b[38;5;241m=\u001b[39m out[size] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timing\u001b[49m\u001b[43m(\u001b[49m\u001b[43msln\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m sln \u001b[38;5;66;03m# Ensure memory is freed.\u001b[39;00m\n\u001b[1;32m 75\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mmean\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mstd\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mrepeats\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m loops of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn [79], line 23\u001b[0m, in \u001b[0;36mget_timing\u001b[0;34m(sln, repeats)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_timing\u001b[39m(sln, repeats: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m repeats) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mfloat\u001b[39m:\n\u001b[0;32m---> 23\u001b[0m \u001b[43msln\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# this timing is not even used because it could contain\u001b[39;00m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# caching and other overhead.\u001b[39;00m\n\u001b[1;32m 27\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n", + "Cell \u001b[0;32mIn [86], line 3\u001b[0m, in \u001b[0;36mCuBLASZgemm.setup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz \u001b[38;5;241m=\u001b[39m \u001b[43mgpuarray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_gpu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m nant \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mout \u001b[38;5;241m=\u001b[39m gpuarray\u001b[38;5;241m.\u001b[39mempty(shape\u001b[38;5;241m=\u001b[39m(nant, nant), dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcomplex\u001b[39m)\n", + "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:1294\u001b[0m, in \u001b[0;36mto_gpu\u001b[0;34m(ary, allocator)\u001b[0m\n\u001b[1;32m 1292\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_gpu\u001b[39m(ary, allocator\u001b[38;5;241m=\u001b[39mdrv\u001b[38;5;241m.\u001b[39mmem_alloc):\n\u001b[1;32m 1293\u001b[0m \u001b[38;5;124;03m\"\"\"converts a numpy array to a GPUArray\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1294\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mGPUArray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallocator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_compact_strides\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1295\u001b[0m result\u001b[38;5;241m.\u001b[39mset(ary)\n\u001b[1;32m 1296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:268\u001b[0m, in \u001b[0;36mGPUArray.__init__\u001b[0;34m(self, shape, dtype, allocator, base, gpudata, strides, order)\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gpudata \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 267\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize:\n\u001b[0;32m--> 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mallocator\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 270\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mMemoryError\u001b[0m: cuMemAlloc failed: out of memory" + ] + } + ], + "source": [ + "timings['cublas.zgemm'] = get_timings(CuBLASZgemm)" + ] + }, + { + "cell_type": "markdown", + "id": "eca36052", + "metadata": {}, + "source": [ + "#### cublas.zherk" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5653094-e1b5-4391-baa2-b66cea7bc0de", + "metadata": {}, + "outputs": [], + "source": [ + "class CuBLASZherk(CuBLASZgemm):\n", + " def compute(self):\n", + " nant, nsrc = self.z.shape\n", + "\n", + " cublasZherk(\n", + " h,\n", + " uplo=\"L\",\n", + " trans=trans,\n", + " n=nant,\n", + " k=nsrc,\n", + " alpha=1.0,\n", + " A=self.z.gpudata,\n", + " lda=nsrc,\n", + " beta=0.0,\n", + " C=self.out.gpudata,\n", + " ldc=nant\n", + " )\n", + " return out.get()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4767df58-a497-4be7-8eba-7f1e421d64e5", + "metadata": {}, + "outputs": [], + "source": [ + "timings['cublas.zherk'] = get_timings(CuBLASZherk)" + ] + }, + { + "cell_type": "markdown", + "id": "1713c876-b220-4ea0-a6f6-eba42fe1aa14", + "metadata": {}, + "source": [ + "### JAX" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "664c1c20-87da-491f-9391-6b56bdb39aae", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "from jax import config\n", + "\n", + "if precision==2:\n", + " config.update('jax_enable_x64',True)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "2a21ab0e-21f4-4c83-a6c8-cb6f40bb9b11", + "metadata": {}, + "outputs": [], + "source": [ + "class JAXdot(Solver):\n", + " def setup(self):\n", + " self.z = jax.device_put(self.z)\n", + " \n", + " def compute(self): \n", + " out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST)\n", + " return jax.device_get(out)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52c8626a-4375-4b87-adc8-a01987c03237", + "metadata": {}, + "outputs": [], + "source": [ + "timings['jax.dot'] = get_timings(JAXdot)" + ] + }, + { + "cell_type": "markdown", + "id": "9f266948-9ca7-418f-a9a7-382defd5c8ab", + "metadata": {}, + "source": [ + "### ArrayFire" + ] + }, + { + "cell_type": "markdown", + "id": "497b60e1-0b51-4419-8918-1a48cb8be7e2", + "metadata": {}, + "source": [ + "There's something weird about how arrayfire stores arrays in memory so that you NEED to use the transpose shape for the array to make sense, but then of course if you go BACK to numpy arrays on cpu, they're the transpose of the original. I've tested passing in pre-transposed data and computing the GEMM and it takes essentially the same amount of time." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "e2b39e53-89ba-446b-85f8-6f90042c0424", + "metadata": {}, + "outputs": [], + "source": [ + "class ArrayFireGemm(Solver):\n", + " def setup(self):\n", + " self.out = arrayfire.Array(dtype=self.z.dtype.char, dims=(self.z.shape[0], self.z.shape[0]))\n", + " self.z = arrayfire.from_ndarray(self.z)\n", + " \n", + " def compute(self):\n", + " return arrayfire.blas.gemm(\n", + " self.z, self.z, lhs_opts=arrayfire.MATPROP.NONE, rhs_opts=arrayfire.MATPROP.CTRANS, C=self.out\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3eb9f38b-0bbc-4ce0-8a14-cec38c271789", + "metadata": {}, + "outputs": [], + "source": [ + "timings['af.gemm'] = get_timings(ArrayFireGemm)" + ] + }, + { + "cell_type": "markdown", + "id": "1d304566", + "metadata": {}, + "source": [ + "## Redundant Baseline Methods" + ] + }, + { + "cell_type": "markdown", + "id": "5407c1ff", + "metadata": {}, + "source": [ + "Say that we have different subsets of baselines that should actually be \"used\". Let's see how long different methods take there..." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "d45ab3dc", + "metadata": { + "ExecuteTime": { + "end_time": "2023-03-11T23:59:49.510072Z", + "start_time": "2023-03-11T23:59:49.476499Z" + } + }, + "outputs": [], + "source": [ + "allpairs = np.array([(0,0)] + [(a, b) for a in range(nants_redundant*2) for b in range(a+1, nants_redundant*2)])\n", + "\n", + "pairs = {}\n", + "pairfracs = [3, 10, 25, 50]\n", + "\n", + "for pc in pairfracs:\n", + " pairs[pc] = allpairs[np.sort(np.random.choice(np.arange(len(allpairs)), size=int(len(allpairs)*pc/100), replace=False))]" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "2df81e33-8c05-443b-bd40-133d5d3e35f9", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_timings_reds(red_timings: dict[str, dict[tuple[int, int], TimeResult]], \n", + " timings: dict[str, dict[tuple[int, int], TimeResult]]):\n", + " fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n", + " \n", + " for j, (method, results) in enumerate(timings.items()):\n", + " ax.plot(nsrcs, [results[(nants_redundant*2, n)].best for n in nsides], color=f'C{j}', label=method)\n", + " \n", + " for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n", + " for k, frac in enumerate(pairfracs):\n", + " ax.plot(\n", + " nsrcs, [results[(frac, n)].best for n in nsides], \n", + " color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5))][k], \n", + " label=f\"{method} ({frac}% red.)\"\n", + " )\n", + " \n", + " ax.set_title(f\"Nant x Nfeed={nant}\")\n", + " ax.set_xlabel(\"nsrc\")\n", + " ax.set_xscale('log')\n", + " ax.set_yscale('log')\n", + " #ax.plot(nsrcs, np.array(nsrcs) * (results[(350, np.max(nsrcs))].best/np.max(nsrcs)), ls='--', color='k')\n", + "\n", + " ax.legend(frameon=False, ncols=3)\n", + " return fig, ax" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "76b2a1d1-10a7-4c52-b020-f790dfddfed4", + "metadata": {}, + "outputs": [], + "source": [ + "timings_reds = {}" + ] + }, + { + "cell_type": "markdown", + "id": "353c44f6-9836-4a62-989a-40bc8a0ac473", + "metadata": {}, + "source": [ + "### Custom Kernel" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "b47cfbc4-ca67-41bd-ba88-1f610c235db6", + "metadata": {}, + "outputs": [], + "source": [ + "multiply_and_sum_kernel = \"\"\"\n", + "// CUDA code for computing V_ij = Z_i Z_j^*\n", + "\n", + "// ========== Template Parameters =========\n", + "// This code is actually a Jinja template, which can use the following parameters. They\n", + "// appear in double curly braces, eg. {{ DTYPE }}. They get substituted before compilation.\n", + "//\n", + "// DTYPE : float or double\n", + "// CDTYPE : cuFloatComplex or cuDoubleComplex\n", + "// BLOCK_PX : # of sky pixels handled by one GPU block, used to size shared memory\n", + "// NANT : # of antennas to pair into visibilities\n", + "// NPIX : # of sky pixels to sum over.\n", + "// NAX : # of E-field axes in the beam\n", + "// NFEED : # of feeds in the beam\n", + "// -------------------------------------------------------------------------------------\n", + "\n", + "#include \n", + "#include \n", + "#include \n", + "\n", + "__global__ void MultiplyAndSum(\n", + " {{ CDTYPE }} *Z,\n", + " int *ant1_array,\n", + " int *ant2_array,\n", + " uint nsrc,\n", + " {{ CDTYPE }} *v\n", + "){\n", + " const uint nax = {{ NAX }};\n", + " const uint nfeed= {{ NFEED }};\n", + " const uint nant = {{ NANT }};\n", + " const uint nbl = {{ NBL }};\n", + " \n", + " // Z should have shape (NFEED x NANT x NSRC x NAX)\n", + " // with NFEED = NAX = 2,\n", + " // NANT ~300\n", + " // NSRC ~5e6.\n", + " // Output V is (NFEED x NFEED x NBL) and is gotten by taking FEED and ANT1 and ANT2, \n", + " // multiplying Z[FEED, ANT1] * Z[FEED, ANT2].conj() then summing over all SRC and AX. \n", + " // ANT1 and ANT2 are length NBL, where NBL < NANT*(NANT + 1) / 2. \n", + " \n", + " // We expect a GPU to have ~2048 threads available (eg. the V100). In this naive implementation,\n", + " // each thread will correspond to a FEED/BL. This will mean that it will have about the same\n", + " // speed as NBL grows, up to 2048, then it will halve in speed, etc.\n", + " \n", + " const uint bl = blockIdx.x * blockDim.x + threadIdx.x; \n", + " const uint feed1 = blockIdx.y * blockDim.y + threadIdx.y; // goes up to 2\n", + " const uint feed2 = blockIdx.z * blockDim.z + threadIdx.z; // goes up to 2\n", + " \n", + " // later, think of some work these guys could do.\n", + " if (bl >= nbl || feed1 >= nfeed || feed2 >= nfeed) return;\n", + "\n", + " uint ant1 = ant1_array[bl];\n", + " uint ant2 = ant2_array[bl];\n", + "\n", + " {{ CDTYPE }} temp = make_{{ CDTYPE }}(0, 0);\n", + " \n", + " for (int i = 0; i < nsrc*nax; i += 1){\n", + " int idx1 = i + ant1*nsrc*nax + feed1*nsrc*nax*nant;\n", + " int idx2 = i + ant2*nsrc*nax + feed2*nsrc*nax*nant;\n", + " \n", + " temp = cuCadd(temp, cuCmul(Z[idx1], cuConj(Z[idx2])));\n", + " }\n", + " \n", + " v[bl*nfeed*nfeed + feed1*nfeed + feed2] = temp;\n", + " \n", + " __syncthreads(); // make sure everyone used mem before kicking out\n", + "}\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "5de673ca-b70c-4dcd-8eec-fedf556ac1e9", + "metadata": {}, + "outputs": [], + "source": [ + "from jinja2 import Template\n", + "from pycuda import compiler" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "a1189839-04f7-46c3-b85c-62a59b7caba2", + "metadata": {}, + "outputs": [], + "source": [ + "VisProduct = Template(multiply_and_sum_kernel)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "9088ee12-1893-4c48-b5b6-6ba4846f618c", + "metadata": {}, + "outputs": [], + "source": [ + "cuda_params = {\n", + " \"NANT\": 50,\n", + " \"NAX\": 1,\n", + " \"NFEED\": 1,\n", + " \"NBEAM\": 1,\n", + " \"DTYPE\": \"double\",\n", + " \"CDTYPE\": \"cuDoubleComplex\",\n", + " \"NBL\": 2500,\n", + " # \"f\": \"f\" if precision == 1 else \"\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "d0d411bd-925f-4b27-b5c2-1d65b8b3221d", + "metadata": {}, + "outputs": [], + "source": [ + "vis_product = VisProduct.render(**cuda_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "fdc08e68-88d7-4100-8f3b-a9e8d610b29e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "vis_product_module = compiler.SourceModule(vis_product)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "5b85807e-9850-4bd0-87c3-9877889616de", + "metadata": {}, + "outputs": [], + "source": [ + "mult_and_sum = vis_product_module.get_function(\"MultiplyAndSum\")" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "6f2ffb4b-19cc-499f-8953-8dad6b6ac4d9", + "metadata": {}, + "outputs": [], + "source": [ + "# ant1 = gpuarray.to_gpu(np.tile(np.arange(50), 50))\n", + "# ant2 = gpuarray.to_gpu(np.repeat(np.arange(50), 50))" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "id": "df62ccfc-40b7-4a5b-b1c9-c41f450db84d", + "metadata": {}, + "outputs": [], + "source": [ + "# del ant1, ant2" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "05e10efd-a653-4a6b-a8fb-c61738b6da6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('int64')" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ant1.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "71e39821-176f-4b6b-a97e-71cf286ed1d0", + "metadata": {}, + "outputs": [], + "source": [ + "# out = gpuarray.empty(2500, dtype=np.complex128)\n", + "# zz = gpuarray.to_gpu(z0)\n", + "\n", + "# mult_and_sum(\n", + "# zz.gpudata,\n", + "# ant1.gpudata,\n", + "# ant2.gpudata,\n", + "# np.uint(10000),\n", + "# out.gpudata,\n", + "# block=(512, 1, 1),\n", + "# grid=(20, 1, 1)\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "06664df4-6751-499d-8663-d414f6fc001a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1727.2704914626827" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# np.max(np.abs(out.get().reshape((50,50))-v0))" + ] + }, + { + "cell_type": "markdown", + "id": "c4564350-a052-45ab-ad5a-aa34855e11a9", + "metadata": {}, + "source": [ + "### Dumb Loop CuBLAS" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "1c0bb3a2-1956-4b31-86bd-5a63061c391f", + "metadata": {}, + "outputs": [], + "source": [ + "class SingleLoopCuBLAS(RedundantSolver):\n", + " def setup(self):\n", + " self.z = gpuarray.to_gpu(self.z)\n", + " self.out = gpuarray.empty(\n", + " self.pairs.shape[0], dtype=complex if precision==2 else np.complex64\n", + " )\n", + " \n", + " def compute(self): \n", + " size = self.z.shape[1]\n", + "\n", + " for i, (a, b) in enumerate(self.pairs):\n", + " self.out[i] = cublasZdotc(h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1)\n", + "\n", + " return self.out.get()" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "80b93732-b374-4db9-b933-a77eda975ad7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 32): 7.604e-01s ± 0.000e+00s [1 loops of 3]\n", + "(3, 64): 7.962e-01s ± 0.000e+00s [1 loops of 3]\n", + "(3, 128): 1.098e+00s ± 0.000e+00s [1 loops of 2]\n", + "(3, 256): " + ] + }, + { + "ename": "MemoryError", + "evalue": "cuMemAlloc failed: out of memory", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mMemoryError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [132], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m timings_reds \u001b[38;5;241m=\u001b[39m \u001b[43mget_timings_red\u001b[49m\u001b[43m(\u001b[49m\u001b[43mSingleLoopCuBLAS\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn [131], line 102\u001b[0m, in \u001b[0;36mget_timings_red\u001b[0;34m(solver, repeats, rerun)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 100\u001b[0m sln \u001b[38;5;241m=\u001b[39m solver(z[(nants_redundant\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m, nside)], p)\n\u001b[0;32m--> 102\u001b[0m o \u001b[38;5;241m=\u001b[39m out[size] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timing\u001b[49m\u001b[43m(\u001b[49m\u001b[43msln\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m sln \u001b[38;5;66;03m# Ensure memory is freed.\u001b[39;00m\n\u001b[1;32m 105\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mmean\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mstd\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mrepeats\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m loops of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "Cell \u001b[0;32mIn [131], line 23\u001b[0m, in \u001b[0;36mget_timing\u001b[0;34m(sln, repeats)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_timing\u001b[39m(sln, repeats: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m repeats) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mfloat\u001b[39m:\n\u001b[0;32m---> 23\u001b[0m \u001b[43msln\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# this timing is not even used because it could contain\u001b[39;00m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# caching and other overhead.\u001b[39;00m\n\u001b[1;32m 27\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n", + "Cell \u001b[0;32mIn [127], line 3\u001b[0m, in \u001b[0;36mSingleLoopCuBLAS.setup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz \u001b[38;5;241m=\u001b[39m \u001b[43mgpuarray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_gpu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mout \u001b[38;5;241m=\u001b[39m gpuarray\u001b[38;5;241m.\u001b[39mempty(\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpairs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcomplex\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m precision\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m np\u001b[38;5;241m.\u001b[39mcomplex64\n\u001b[1;32m 6\u001b[0m )\n", + "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:1294\u001b[0m, in \u001b[0;36mto_gpu\u001b[0;34m(ary, allocator)\u001b[0m\n\u001b[1;32m 1292\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_gpu\u001b[39m(ary, allocator\u001b[38;5;241m=\u001b[39mdrv\u001b[38;5;241m.\u001b[39mmem_alloc):\n\u001b[1;32m 1293\u001b[0m \u001b[38;5;124;03m\"\"\"converts a numpy array to a GPUArray\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1294\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mGPUArray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallocator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_compact_strides\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1295\u001b[0m result\u001b[38;5;241m.\u001b[39mset(ary)\n\u001b[1;32m 1296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:268\u001b[0m, in \u001b[0;36mGPUArray.__init__\u001b[0;34m(self, shape, dtype, allocator, base, gpudata, strides, order)\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gpudata \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 267\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize:\n\u001b[0;32m--> 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mallocator\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 270\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mMemoryError\u001b[0m: cuMemAlloc failed: out of memory" + ] + } + ], + "source": [ + "timings_reds['cublas.singleloop'] = get_timings_red(SingleLoopCuBLAS)" + ] + }, + { + "cell_type": "markdown", + "id": "7659d02d-78f5-43bf-92d8-9847e8950d89", + "metadata": {}, + "source": [ + "### Dumb Loop njit" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "id": "4108942c-7fcd-400d-abd3-878e688a3ed8", + "metadata": {}, + "outputs": [], + "source": [ + "@numba.njit\n", + "def _dumbloopjit(z, pairs, out):\n", + " zc = z.conj()\n", + " for i, (a, b) in enumerate(pairs):\n", + " out[i] = np.dot(z[a], zc[b])\n", + "\n", + "class SingleLoopNumba(RedundantSolver):\n", + " def setup(self):\n", + " self.out = np.empty(len(self.pairs), dtype=np.complex128 if precision==2 else np.complex64)\n", + " \n", + " def compute(self):\n", + " _dumbloopjit(self.z, self.pairs, self.out)\n", + " return self.out\n" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "c8a4ba4f-d586-4a63-ae90-7e8bc3f82925", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 32): 3.938e-01s ± 0.000e+00s [1 loops of 6]\n", + "(3, 64): 1.392e+00s ± 0.000e+00s [1 loops of 2]\n", + "(3, 128): 4.803e+00s ± 0.000e+00s [1 loops of 1]\n", + "(3, 256): 1.955e+01s ± 0.000e+00s [1 loops of 1]\n", + "(10, 32): 8.373e-01s ± 0.000e+00s [1 loops of 2]\n", + "(10, 64): 2.564e+00s ± 0.000e+00s [1 loops of 1]\n", + "(10, 128): 1.023e+01s ± 0.000e+00s [1 loops of 1]\n", + "(10, 256): 4.024e+01s ± 0.000e+00s [1 loops of 1]\n", + "(25, 32): 1.771e+00s ± 0.000e+00s [1 loops of 2]\n", + "(25, 64): 5.495e+00s ± 0.000e+00s [1 loops of 1]\n", + "(25, 128): 2.222e+01s ± 0.000e+00s [1 loops of 1]\n", + "(25, 256): 7.531e+01s ± 0.000e+00s [1 loops of 1]\n", + "(50, 32): 3.842e+00s ± 0.000e+00s [1 loops of 1]\n", + "(50, 64): 1.053e+01s ± 0.000e+00s [1 loops of 1]\n", + "(50, 128): 4.178e+01s ± 0.000e+00s [1 loops of 1]\n", + "(50, 256): 1.603e+02s ± 0.000e+00s [1 loops of 1]\n" + ] + } + ], + "source": [ + "timings_reds['numba.singleloop'] = get_timings_red(SingleLoopNumba)" + ] + }, + { + "cell_type": "markdown", + "id": "b98ffb9e-d159-43f0-8b0b-9a3933217f7c", + "metadata": {}, + "source": [ + "### Chunked Loop (JAX)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "50447a2d-7b7d-4d61-8c1e-c593765849ef", + "metadata": {}, + "outputs": [], + "source": [ + "class ChunkedLoopJAX(RedundantSolver):\n", + " chunksize = 350\n", + " \n", + " def setup(self):\n", + " self.z = jax.device_put(self.z)\n", + " self.ant1 = jax.device_put(self.pairs[:, 0])\n", + " self.ant2 = jax.device_put(self.pairs[:, 1])\n", + " self.out = jnp.empty(len(self.ant1), dtype=complex if precision==2 else np.complex64)\n", + " \n", + " def compute(self):\n", + " nchunks = len(self.ant1) // self.chunksize\n", + "\n", + " def doslc(slc):\n", + " s1 = self.z[self.ant1[slc]]\n", + " s2 = self.z[self.ant2[slc]]\n", + " s1 *= s2.conj()\n", + " sm = jnp.sum(s1, axis=1)\n", + " self.out = self.out.at[slc].set(sm)\n", + "\n", + " for chunk in range(nchunks):\n", + " slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize)\n", + " doslc(slc)\n", + "\n", + " if len(self.ant1) % self.chunksize:\n", + " slc = slice((chunk+1)*self.chunksize, None)\n", + " doslc(slc)\n", + "\n", + " return jax.device_get(self.out)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "e86bfe3c-e4f3-4abd-b23d-b3be5a4c517f", + "metadata": {}, + "outputs": [], + "source": [ + "timings_reds['jax.chunkedloop'] = get_timings_red(ChunkedLoopJAX)" + ] + }, + { + "cell_type": "markdown", + "id": "b0386649-67b2-42fa-b78f-c609985e4351", + "metadata": {}, + "source": [ + "### Redundant Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "80bf6e17-b7aa-4d14-b180-632be242b676", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_timings_reds(timings_reds, timings);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "433cdfe8-581a-4706-a605-dbe735f05803", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:gputest]", + "language": "python", + "name": "conda-env-gputest-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": true, + "autocomplete": false, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0a56d781e2e954e65c16297a41e34ed75c7e9340 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 29 Sep 2023 10:37:12 +0000 Subject: [PATCH 02/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index e6f9724..6d1b0db 100644 --- a/.gitignore +++ b/.gitignore @@ -55,4 +55,4 @@ stats-*.pkl summary-stats-*.pkl .hypothesis/* -devel/*.yaml \ No newline at end of file +devel/*.yaml From ff80590749f113ea9c5f31ff5560129a4d42384f Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Mon, 2 Oct 2023 08:50:37 -0400 Subject: [PATCH 03/16] docs: fix some perf stuff --- ...rformance_test_large_matrix_multiply.ipynb | 375 ++++++++---------- 1 file changed, 166 insertions(+), 209 deletions(-) diff --git a/devel/performance_test_large_matrix_multiply.ipynb b/devel/performance_test_large_matrix_multiply.ipynb index ae7ca38..b9abf35 100644 --- a/devel/performance_test_large_matrix_multiply.ipynb +++ b/devel/performance_test_large_matrix_multiply.ipynb @@ -33,23 +33,53 @@ "from scipy.linalg import blas\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "import pycuda.autoinit\n", - "from pycuda import cumath as cm\n", - "from pycuda import driver, gpuarray\n", - "from skcuda.cublas import (\n", - " cublasCreate,\n", - " cublasDestroy,\n", - " cublasZgemm,\n", - " cublasZherk,\n", - " cublasZdotc\n", - ")\n", - "import jax.numpy as jnp\n", - "import arrayfire\n", "import time\n", "from dataclasses import dataclass, asdict\n", "import yaml\n", "from pathlib import Path\n", - "import numba" + "\n", + "try:\n", + " import pycuda.autoinit\n", + " from pycuda import cumath as cm\n", + " from pycuda import driver, gpuarray\n", + " from skcuda.cublas import (\n", + " cublasCreate,\n", + " cublasDestroy,\n", + " cublasZgemm,\n", + " cublasZherk,\n", + " cublasZdotc,\n", + " cublasCgemm,\n", + " cublasCherk,\n", + " cublasCdotc,\n", + " )\n", + " HAVE_PYCUDA = True \n", + "except:\n", + " HAVE_PYCUDA = False\n", + "\n", + "try:\n", + " import jax.numpy as jnp\n", + " HAVE_JAX = True\n", + "except ImportError:\n", + " HAVE_JAX = False\n", + "\n", + "try:\n", + " import arrayfire\n", + " HAVE_AF = True\n", + "except:\n", + " HAVE_AF = False\n", + "\n", + "try:\n", + " import numba\n", + " HAVE_NUMBA = True\n", + "except:\n", + " HAVE_NUMBA = False\n", + "\n", + "\n", + "print(\"Running Performanc Tests with the following libraries:\")\n", + "print(\"pycuda/cublas: \", HAVE_PYCUDA)\n", + "print(\" jax: \", HAVE_JAX)\n", + "print(\" arrayfire: \", HAVE_AF)\n", + "print(\" numba: \", HAVE_NUMBA)\n" ] }, { @@ -64,7 +94,8 @@ }, "outputs": [], "source": [ - "h = cublasCreate()" + "if HAVE_PYCUDA:\n", + " h = cublasCreate()" ] }, { @@ -84,6 +115,23 @@ "nants_redundant: int = 350" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "474ceb24", + "metadata": {}, + "outputs": [], + "source": [ + "if precision==1:\n", + " cublas_gemm = cublasCgemm\n", + " cublas_herk = cublasCherk\n", + " cublas_dotc = cublasCdotc\n", + "else:\n", + " cublas_gemm = cublasZgemm\n", + " cublas_herk = cublasZherk\n", + " cublas_dotc = cublasZdotc" + ] + }, { "cell_type": "markdown", "id": "6d508e80-aeb0-4f03-92c2-a580f3921ed0", @@ -132,6 +180,17 @@ " return fig, ax" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "7970934d", + "metadata": {}, + "outputs": [], + "source": [ + "rtype = np.float32 if precision==1 else float\n", + "ctype = np.complex64 if precision==2 else complex" + ] + }, { "cell_type": "markdown", "id": "3ae38109", @@ -154,9 +213,9 @@ "source": [ "def getz(shape):\n", " return (\n", - " np.random.random(shape, dtype=np.float32 if precision==1 else float) + \n", - " np.random.random(shape, dtype=np.float32 if precision==1 else float)*1j\n", - " )\n", + " np.random.random(shape) + \n", + " np.random.random(shape)*1j\n", + " ).astype(ctype)\n", "\n", "# Note that \"nants\" here represents Nants * Nfeed, which is why we \n", "# go to double the number of ants that HERA has.\n", @@ -212,10 +271,10 @@ "source": [ "class Solver:\n", " def __init__(self, z: np.ndarray):\n", - " self.z = z\n", + " self._z = z.copy()\n", " \n", " def setup(self):\n", - " pass\n", + " self.z = self._z\n", " \n", " def compute(self):\n", " pass\n", @@ -228,15 +287,15 @@ " def test(cls, rtol=1e-5, atol=1e-5):\n", " obj = cls(z0)\n", " result = obj()\n", - " np.testing.assert_allclose(result, v0, rtol=rtol, atol=atol)\n", + " np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol)\n", " \n", "class RedundantSolver:\n", " def __init__(self, z: np.ndarray, pairs: np.ndarray):\n", - " self.z = z\n", + " self._z = z.copy()\n", " self.pairs = pairs\n", " \n", " def setup(self):\n", - " pass\n", + " self.z = self._z\n", " \n", " def compute(self):\n", " pass\n", @@ -252,7 +311,7 @@ " pairs = np.array([(a, b) for a in range(nant) for b in range(nant)])\n", " obj = cls(z0, pairs)\n", " result = obj()\n", - " np.testing.assert_allclose(result.reshape((nant, nant)), v0, rtol=rtol, atol=atol)\n", + " np.testing.assert_allclose(np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol)\n", " " ] }, @@ -546,7 +605,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -590,14 +649,14 @@ "source": [ "class CuBLASZgemm(Solver):\n", " def setup(self):\n", - " self.z = gpuarray.to_gpu(self.z)\n", + " self.z = gpuarray.to_gpu(self._z)\n", " nant = self.z.shape[0]\n", - " self.out = gpuarray.empty(shape=(nant, nant), dtype=complex)\n", + " self.out = gpuarray.empty(shape=(nant, nant), dtype=ctype)\n", "\n", " def compute(self):\n", " nant, nsrc = self.z.shape\n", "\n", - " cublasZgemm(\n", + " cublas_gemm(\n", " h,\n", " \"c\", # conjugate transpose for first (remember fortran order)\n", " \"n\", # no transpose for second.\n", @@ -662,7 +721,8 @@ } ], "source": [ - "timings['cublas.zgemm'] = get_timings(CuBLASZgemm)" + "if HAVE_PYCUDA:\n", + " timings['cublas.zgemm'] = get_timings(CuBLASZgemm)" ] }, { @@ -684,10 +744,10 @@ " def compute(self):\n", " nant, nsrc = self.z.shape\n", "\n", - " cublasZherk(\n", + " cublas_herk(\n", " h,\n", " uplo=\"L\",\n", - " trans=trans,\n", + " trans='n',\n", " n=nant,\n", " k=nsrc,\n", " alpha=1.0,\n", @@ -697,7 +757,7 @@ " C=self.out.gpudata,\n", " ldc=nant\n", " )\n", - " return out.get()" + " return self.out.get()" ] }, { @@ -707,7 +767,8 @@ "metadata": {}, "outputs": [], "source": [ - "timings['cublas.zherk'] = get_timings(CuBLASZherk)" + "if HAVE_PYCUDA:\n", + " timings['cublas.zherk'] = get_timings(CuBLASZherk)" ] }, { @@ -725,11 +786,12 @@ "metadata": {}, "outputs": [], "source": [ - "import jax\n", - "from jax import config\n", + "if HAVE_JAX:\n", + " import jax\n", + " from jax import config\n", "\n", - "if precision==2:\n", - " config.update('jax_enable_x64',True)" + " if precision==2:\n", + " config.update('jax_enable_x64',True)" ] }, { @@ -741,7 +803,7 @@ "source": [ "class JAXdot(Solver):\n", " def setup(self):\n", - " self.z = jax.device_put(self.z)\n", + " self.z = jax.device_put(self._z)\n", " \n", " def compute(self): \n", " out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST)\n", @@ -755,7 +817,8 @@ "metadata": {}, "outputs": [], "source": [ - "timings['jax.dot'] = get_timings(JAXdot)" + "if HAVE_JAX:\n", + " timings['jax.dot'] = get_timings(JAXdot)" ] }, { @@ -783,8 +846,8 @@ "source": [ "class ArrayFireGemm(Solver):\n", " def setup(self):\n", - " self.out = arrayfire.Array(dtype=self.z.dtype.char, dims=(self.z.shape[0], self.z.shape[0]))\n", - " self.z = arrayfire.from_ndarray(self.z)\n", + " self.out = arrayfire.Array(dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0]))\n", + " self.z = arrayfire.from_ndarray(self._z)\n", " \n", " def compute(self):\n", " return arrayfire.blas.gemm(\n", @@ -799,7 +862,8 @@ "metadata": {}, "outputs": [], "source": [ - "timings['af.gemm'] = get_timings(ArrayFireGemm)" + "if HAVE_AF:\n", + " timings['af.gemm'] = get_timings(ArrayFireGemm)" ] }, { @@ -973,153 +1037,44 @@ "metadata": {}, "outputs": [], "source": [ - "from jinja2 import Template\n", - "from pycuda import compiler" - ] - }, - { - "cell_type": "code", - "execution_count": 130, - "id": "a1189839-04f7-46c3-b85c-62a59b7caba2", - "metadata": {}, - "outputs": [], - "source": [ - "VisProduct = Template(multiply_and_sum_kernel)" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "id": "9088ee12-1893-4c48-b5b6-6ba4846f618c", - "metadata": {}, - "outputs": [], - "source": [ - "cuda_params = {\n", - " \"NANT\": 50,\n", - " \"NAX\": 1,\n", - " \"NFEED\": 1,\n", - " \"NBEAM\": 1,\n", - " \"DTYPE\": \"double\",\n", - " \"CDTYPE\": \"cuDoubleComplex\",\n", - " \"NBL\": 2500,\n", - " # \"f\": \"f\" if precision == 1 else \"\",\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 132, - "id": "d0d411bd-925f-4b27-b5c2-1d65b8b3221d", - "metadata": {}, - "outputs": [], - "source": [ - "vis_product = VisProduct.render(**cuda_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 133, - "id": "fdc08e68-88d7-4100-8f3b-a9e8d610b29e", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "vis_product_module = compiler.SourceModule(vis_product)" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "id": "5b85807e-9850-4bd0-87c3-9877889616de", - "metadata": {}, - "outputs": [], - "source": [ - "mult_and_sum = vis_product_module.get_function(\"MultiplyAndSum\")" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "id": "6f2ffb4b-19cc-499f-8953-8dad6b6ac4d9", - "metadata": {}, - "outputs": [], - "source": [ - "# ant1 = gpuarray.to_gpu(np.tile(np.arange(50), 50))\n", - "# ant2 = gpuarray.to_gpu(np.repeat(np.arange(50), 50))" - ] - }, - { - "cell_type": "code", - "execution_count": 187, - "id": "df62ccfc-40b7-4a5b-b1c9-c41f450db84d", - "metadata": {}, - "outputs": [], - "source": [ - "# del ant1, ant2" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "id": "05e10efd-a653-4a6b-a8fb-c61738b6da6b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dtype('int64')" - ] - }, - "execution_count": 126, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# ant1.dtype" - ] - }, - { - "cell_type": "code", - "execution_count": 136, - "id": "71e39821-176f-4b6b-a97e-71cf286ed1d0", - "metadata": {}, - "outputs": [], - "source": [ - "# out = gpuarray.empty(2500, dtype=np.complex128)\n", - "# zz = gpuarray.to_gpu(z0)\n", + "# if HAVE_PYCUDA:\n", + "# from jinja2 import Template\n", + "# from pycuda import compiler\n", "\n", - "# mult_and_sum(\n", - "# zz.gpudata,\n", - "# ant1.gpudata,\n", - "# ant2.gpudata,\n", - "# np.uint(10000),\n", - "# out.gpudata,\n", - "# block=(512, 1, 1),\n", - "# grid=(20, 1, 1)\n", - "# )" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "id": "06664df4-6751-499d-8663-d414f6fc001a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1727.2704914626827" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# np.max(np.abs(out.get().reshape((50,50))-v0))" + "# VisProduct = Template(multiply_and_sum_kernel)\n", + "\n", + "# cuda_params = {\n", + "# \"NANT\": 50,\n", + "# \"NAX\": 1,\n", + "# \"NFEED\": 1,\n", + "# \"NBEAM\": 1,\n", + "# \"DTYPE\": \"double\",\n", + "# \"CDTYPE\": \"cuDoubleComplex\",\n", + "# \"NBL\": 2500,\n", + "# # \"f\": \"f\" if precision == 1 else \"\",\n", + "# }\n", + "\n", + "# vis_product = VisProduct.render(**cuda_params)\n", + "# vis_product_module = compiler.SourceModule(vis_product)\n", + "# mult_and_sum = vis_product_module.get_function(\"MultiplyAndSum\")\n", + "\n", + " # ant1 = gpuarray.to_gpu(np.tile(np.arange(50), 50))\n", + " # ant2 = gpuarray.to_gpu(np.repeat(np.arange(50), 50))\n", + "\n", + " # out = gpuarray.empty(2500, dtype=np.complex128)\n", + " # zz = gpuarray.to_gpu(z0)\n", + "\n", + " # mult_and_sum(\n", + " # zz.gpudata,\n", + " # ant1.gpudata,\n", + " # ant2.gpudata,\n", + " # np.uint(10000),\n", + " # out.gpudata,\n", + " # block=(512, 1, 1),\n", + " # grid=(20, 1, 1)\n", + " # )\n", + "\n", + " # np.max(np.abs(out.get().reshape((50,50))-v0))" ] }, { @@ -1139,16 +1094,14 @@ "source": [ "class SingleLoopCuBLAS(RedundantSolver):\n", " def setup(self):\n", - " self.z = gpuarray.to_gpu(self.z)\n", - " self.out = gpuarray.empty(\n", - " self.pairs.shape[0], dtype=complex if precision==2 else np.complex64\n", - " )\n", + " self.z = gpuarray.to_gpu(self._z)\n", + " self.out = gpuarray.empty(self.pairs.shape[0], dtype=ctype)\n", " \n", " def compute(self): \n", " size = self.z.shape[1]\n", "\n", " for i, (a, b) in enumerate(self.pairs):\n", - " self.out[i] = cublasZdotc(h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1)\n", + " self.out[i] = cublas_dotc(h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1)\n", "\n", " return self.out.get()" ] @@ -1187,7 +1140,8 @@ } ], "source": [ - "timings_reds['cublas.singleloop'] = get_timings_red(SingleLoopCuBLAS)" + "if HAVE_PYCUDA:\n", + " timings_reds['cublas.singleloop'] = get_timings_red(SingleLoopCuBLAS)" ] }, { @@ -1205,19 +1159,20 @@ "metadata": {}, "outputs": [], "source": [ - "@numba.njit\n", - "def _dumbloopjit(z, pairs, out):\n", - " zc = z.conj()\n", - " for i, (a, b) in enumerate(pairs):\n", - " out[i] = np.dot(z[a], zc[b])\n", + "if HAVE_NUMBA:\n", + " @numba.njit\n", + " def _dumbloopjit(z, pairs, out):\n", + " zc = z.conj()\n", + " for i, (a, b) in enumerate(pairs):\n", + " out[i] = np.dot(z[a], zc[b])\n", "\n", - "class SingleLoopNumba(RedundantSolver):\n", - " def setup(self):\n", - " self.out = np.empty(len(self.pairs), dtype=np.complex128 if precision==2 else np.complex64)\n", - " \n", - " def compute(self):\n", - " _dumbloopjit(self.z, self.pairs, self.out)\n", - " return self.out\n" + " class SingleLoopNumba(RedundantSolver):\n", + " def setup(self):\n", + " self.out = np.empty(len(self.pairs), dtype=ctype)\n", + " \n", + " def compute(self):\n", + " _dumbloopjit(self.z, self.pairs, self.out)\n", + " return self.out\n" ] }, { @@ -1250,7 +1205,8 @@ } ], "source": [ - "timings_reds['numba.singleloop'] = get_timings_red(SingleLoopNumba)" + "if HAVE_NUMBA:\n", + " timings_reds['numba.singleloop'] = get_timings_red(SingleLoopNumba)" ] }, { @@ -1275,7 +1231,7 @@ " self.z = jax.device_put(self.z)\n", " self.ant1 = jax.device_put(self.pairs[:, 0])\n", " self.ant2 = jax.device_put(self.pairs[:, 1])\n", - " self.out = jnp.empty(len(self.ant1), dtype=complex if precision==2 else np.complex64)\n", + " self.out = jnp.empty(len(self.ant1), dtype=ctype)\n", " \n", " def compute(self):\n", " nchunks = len(self.ant1) // self.chunksize\n", @@ -1305,7 +1261,8 @@ "metadata": {}, "outputs": [], "source": [ - "timings_reds['jax.chunkedloop'] = get_timings_red(ChunkedLoopJAX)" + "if HAVE_JAX:\n", + " timings_reds['jax.chunkedloop'] = get_timings_red(ChunkedLoopJAX)" ] }, { @@ -1324,7 +1281,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] From 84e307a6599d35f23e7cf3c9fe490942acc8e9b0 Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Mon, 2 Oct 2023 06:16:24 -0700 Subject: [PATCH 04/16] docs: fix ctype in perf notebook --- ...rformance_test_large_matrix_multiply.ipynb | 330 ++++++------------ 1 file changed, 101 insertions(+), 229 deletions(-) diff --git a/devel/performance_test_large_matrix_multiply.ipynb b/devel/performance_test_large_matrix_multiply.ipynb index b9abf35..55e16cc 100644 --- a/devel/performance_test_large_matrix_multiply.ipynb +++ b/devel/performance_test_large_matrix_multiply.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": null, "id": "31f6b315", "metadata": { "ExecuteTime": { @@ -75,7 +75,7 @@ " HAVE_NUMBA = False\n", "\n", "\n", - "print(\"Running Performanc Tests with the following libraries:\")\n", + "print(\"Running Performance Tests with the following libraries:\")\n", "print(\"pycuda/cublas: \", HAVE_PYCUDA)\n", "print(\" jax: \", HAVE_JAX)\n", "print(\" arrayfire: \", HAVE_AF)\n", @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "58e47f8c", "metadata": { "ExecuteTime": { @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": null, "id": "c9ca126a-64fc-4f46-b84f-20c52e1a90da", "metadata": { "tags": [ @@ -111,7 +111,7 @@ "source": [ "repeats: int = 1\n", "rerun: bool = False\n", - "precision: int = 2\n", + "precision: int = 1\n", "nants_redundant: int = 350" ] }, @@ -126,10 +126,14 @@ " cublas_gemm = cublasCgemm\n", " cublas_herk = cublasCherk\n", " cublas_dotc = cublasCdotc\n", + " rtype = np.float32\n", + " ctype = np.complex64\n", "else:\n", " cublas_gemm = cublasZgemm\n", " cublas_herk = cublasZherk\n", - " cublas_dotc = cublasZdotc" + " cublas_dotc = cublasZdotc\n", + " rtype = float\n", + " ctype = complex" ] }, { @@ -142,7 +146,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": null, "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1", "metadata": {}, "outputs": [], @@ -180,17 +184,6 @@ " return fig, ax" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "7970934d", - "metadata": {}, - "outputs": [], - "source": [ - "rtype = np.float32 if precision==1 else float\n", - "ctype = np.complex64 if precision==2 else complex" - ] - }, { "cell_type": "markdown", "id": "3ae38109", @@ -201,7 +194,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "91f49fdf", "metadata": { "ExecuteTime": { @@ -240,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "47990a53", "metadata": { "ExecuteTime": { @@ -264,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 124, + "execution_count": null, "id": "81e2e7b8-3a06-45c6-8cd6-973e56b6284f", "metadata": {}, "outputs": [], @@ -317,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": null, "id": "e18d0954-6520-4d7a-971d-9370d4b89989", "metadata": {}, "outputs": [], @@ -346,35 +339,41 @@ "def get_timing(sln, repeats: int = repeats) -> float:\n", " sln.setup()\n", " \n", - " # this timing is not even used because it could contain\n", - " # caching and other overhead.\n", " t0 = time.time()\n", " sln.compute()\n", " t1 = time.time() - t0\n", "\n", - "\n", - " # Need to do it at least twice to check if the time comes down.\n", - " t0 = time.time()\n", - " sln.compute()\n", - " t2 = time.time() - t0\n", - "\n", - " n = int(2 / t2) + 1\n", + " times = []\n", " \n", - " if n == 1:\n", - " times = [t2]\n", + " if t1 > 2: # assume overhead from compilation etc. is negligible compared to 5sec\n", + " times.append(t1)\n", + " n = 1\n", " \n", - " for _ in range(repeats - 1):\n", + " if repeats > len(times):\n", + " # Need to do it at least twice to check if the time comes down.\n", + " \n", + " if t1 < 2:\n", " t0 = time.time()\n", " sln.compute()\n", - " times.append(time.time() - t0)\n", + " t2 = time.time() - t0\n", + "\n", + " n = int(2 / t2) + 1\n", + " \n", + " if t2 > 2:\n", + " times.append(t2)\n", " \n", - " else:\n", - " times = []\n", - " for _ in range(repeats):\n", - " t0 = time.time()\n", - " for _ in range(n):\n", + " if n == 1:\n", + " for _ in range(max(0, repeats - len(times))):\n", + " t0 = time.time()\n", " sln.compute()\n", - " times.append((time.time() - t0)/n)\n", + " times.append(time.time() - t0)\n", + "\n", + " else:\n", + " for _ in range(repeats):\n", + " t0 = time.time()\n", + " for _ in range(n):\n", + " sln.compute()\n", + " times.append((time.time() - t0)/n)\n", "\n", " return TimeResult(times, n)\n", "\n", @@ -437,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "id": "65f02230-958d-4d75-9abb-76c5978cb93a", "metadata": {}, "outputs": [], @@ -471,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "id": "b859bdb0-9d6e-486b-a247-049c25e3f2c9", "metadata": {}, "outputs": [], @@ -483,35 +482,12 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": null, "id": "a75dfb83-f390-47f4-a04a-3faa27f0db24", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(100, 32): 4.537e-02s ± 0.000e+00s [1 loops of 38]\n", - "(100, 64): 1.921e-01s ± 0.000e+00s [1 loops of 7]\n", - "(100, 128): 5.643e-01s ± 0.000e+00s [1 loops of 3]\n", - "(100, 256): 2.189e+00s ± 0.000e+00s [1 loops of 1]\n", - "(200, 32): 9.882e-02s ± 0.000e+00s [1 loops of 22]\n", - "(200, 64): 3.205e-01s ± 0.000e+00s [1 loops of 6]\n", - "(200, 128): 1.062e+00s ± 0.000e+00s [1 loops of 2]\n", - "(200, 256): 4.268e+00s ± 0.000e+00s [1 loops of 1]\n", - "(400, 32): 1.990e-01s ± 0.000e+00s [1 loops of 10]\n", - "(400, 64): 7.316e-01s ± 0.000e+00s [1 loops of 3]\n", - "(400, 128): 2.385e+00s ± 0.000e+00s [1 loops of 1]\n", - "(400, 256): 1.016e+01s ± 0.000e+00s [1 loops of 1]\n", - "(700, 32): 4.552e-01s ± 0.000e+00s [1 loops of 5]\n", - "(700, 64): 1.916e+00s ± 0.000e+00s [1 loops of 2]\n", - "(700, 128): 5.792e+00s ± 0.000e+00s [1 loops of 1]\n", - "(700, 256): 2.275e+01s ± 0.000e+00s [1 loops of 1]\n" - ] - } - ], + "outputs": [], "source": [ - "timings['np.dot'] = get_timings(NpDot)" + "timings['np.dot'] = get_timings(NpDot, rerun=True)" ] }, { @@ -524,7 +500,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": null, "id": "600b4875-b401-4a4e-8143-a7d7a3767359", "metadata": {}, "outputs": [], @@ -536,33 +512,10 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": null, "id": "a24fd6ff-6a74-4755-b5a8-52703452a73d", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(100, 32): 1.316e-01s ± 0.000e+00s [1 loops of 17]\n", - "(100, 64): 3.535e-01s ± 0.000e+00s [1 loops of 6]\n", - "(100, 128): 1.255e+00s ± 0.000e+00s [1 loops of 2]\n", - "(100, 256): 4.666e+00s ± 0.000e+00s [1 loops of 1]\n", - "(200, 32): 2.316e-01s ± 0.000e+00s [1 loops of 10]\n", - "(200, 64): 7.361e-01s ± 0.000e+00s [1 loops of 3]\n", - "(200, 128): 2.506e+00s ± 0.000e+00s [1 loops of 1]\n", - "(200, 256): 1.010e+01s ± 0.000e+00s [1 loops of 1]\n", - "(400, 32): 4.873e-01s ± 0.000e+00s [1 loops of 5]\n", - "(400, 64): 1.897e+00s ± 0.000e+00s [1 loops of 2]\n", - "(400, 128): 7.242e+00s ± 0.000e+00s [1 loops of 1]\n", - "(400, 256): 3.057e+01s ± 0.000e+00s [1 loops of 1]\n", - "(700, 32): 9.058e-01s ± 0.000e+00s [1 loops of 3]\n", - "(700, 64): 3.519e+00s ± 0.000e+00s [1 loops of 1]\n", - "(700, 128): 1.344e+01s ± 0.000e+00s [1 loops of 1]\n", - "(700, 256): 5.758e+01s ± 0.000e+00s [1 loops of 1]\n" - ] - } - ], + "outputs": [], "source": [ "timings['np.zgemm'] = get_timings(NpZgemm)" ] @@ -599,21 +552,10 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": null, "id": "b0090363-f235-4890-a2da-181be2852031", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, ax = plot_timings(timings)\n", "fig.suptitle(\"CPU Timings\");" @@ -637,7 +579,37 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": null, + "id": "15f625c1-4878-4d72-b445-693319330278", + "metadata": {}, + "outputs": [], + "source": [ + "cc = CuBLASZgemm(z0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09893bc3-e4dc-4dec-a37c-2de638e21e7e", + "metadata": {}, + "outputs": [], + "source": [ + "cc.setup()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34266b0a-cdbf-489d-af80-0286856f23a8", + "metadata": {}, + "outputs": [], + "source": [ + "cc.z.dtype" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "5ad23c8f", "metadata": { "ExecuteTime": { @@ -677,49 +649,10 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": null, "id": "6d949ca9-03cc-4834-9099-fd0ba78e30ed", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(100, 32): 1.597e-02s ± 0.000e+00s [1 loops of 107]\n", - "(100, 64): 6.254e-02s ± 0.000e+00s [1 loops of 32]\n", - "(100, 128): 2.486e-01s ± 0.000e+00s [1 loops of 9]\n", - "(100, 256): 9.924e-01s ± 0.000e+00s [1 loops of 3]\n", - "(200, 32): 4.867e-02s ± 0.000e+00s [1 loops of 40]\n", - "(200, 64): 1.912e-01s ± 0.000e+00s [1 loops of 11]\n", - "(200, 128): 7.617e-01s ± 0.000e+00s [1 loops of 3]\n", - "(200, 256): 3.045e+00s ± 0.000e+00s [1 loops of 1]\n", - "(400, 32): 1.869e-01s ± 0.000e+00s [1 loops of 11]\n", - "(400, 64): 7.467e-01s ± 0.000e+00s [1 loops of 3]\n", - "(400, 128): 2.987e+00s ± 0.000e+00s [1 loops of 1]\n", - "(400, 256): 1.199e+01s ± 0.000e+00s [1 loops of 1]\n", - "(700, 32): 5.496e-01s ± 0.000e+00s [1 loops of 4]\n", - "(700, 64): 2.196e+00s ± 0.000e+00s [1 loops of 1]\n", - "(700, 128): 8.790e+00s ± 0.000e+00s [1 loops of 1]\n", - "(700, 256): " - ] - }, - { - "ename": "MemoryError", - "evalue": "cuMemAlloc failed: out of memory", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mMemoryError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [87], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m timings[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcublas.zgemm\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timings\u001b[49m\u001b[43m(\u001b[49m\u001b[43mCuBLASZgemm\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn [79], line 72\u001b[0m, in \u001b[0;36mget_timings\u001b[0;34m(solver, repeats, rerun)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 71\u001b[0m sln \u001b[38;5;241m=\u001b[39m solver(zz)\n\u001b[0;32m---> 72\u001b[0m o \u001b[38;5;241m=\u001b[39m out[size] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timing\u001b[49m\u001b[43m(\u001b[49m\u001b[43msln\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m sln \u001b[38;5;66;03m# Ensure memory is freed.\u001b[39;00m\n\u001b[1;32m 75\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mmean\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mstd\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mrepeats\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m loops of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "Cell \u001b[0;32mIn [79], line 23\u001b[0m, in \u001b[0;36mget_timing\u001b[0;34m(sln, repeats)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_timing\u001b[39m(sln, repeats: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m repeats) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mfloat\u001b[39m:\n\u001b[0;32m---> 23\u001b[0m \u001b[43msln\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# this timing is not even used because it could contain\u001b[39;00m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# caching and other overhead.\u001b[39;00m\n\u001b[1;32m 27\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n", - "Cell \u001b[0;32mIn [86], line 3\u001b[0m, in \u001b[0;36mCuBLASZgemm.setup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz \u001b[38;5;241m=\u001b[39m \u001b[43mgpuarray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_gpu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m nant \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mout \u001b[38;5;241m=\u001b[39m gpuarray\u001b[38;5;241m.\u001b[39mempty(shape\u001b[38;5;241m=\u001b[39m(nant, nant), dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcomplex\u001b[39m)\n", - "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:1294\u001b[0m, in \u001b[0;36mto_gpu\u001b[0;34m(ary, allocator)\u001b[0m\n\u001b[1;32m 1292\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_gpu\u001b[39m(ary, allocator\u001b[38;5;241m=\u001b[39mdrv\u001b[38;5;241m.\u001b[39mmem_alloc):\n\u001b[1;32m 1293\u001b[0m \u001b[38;5;124;03m\"\"\"converts a numpy array to a GPUArray\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1294\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mGPUArray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallocator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_compact_strides\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1295\u001b[0m result\u001b[38;5;241m.\u001b[39mset(ary)\n\u001b[1;32m 1296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:268\u001b[0m, in \u001b[0;36mGPUArray.__init__\u001b[0;34m(self, shape, dtype, allocator, base, gpudata, strides, order)\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gpudata \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 267\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize:\n\u001b[0;32m--> 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mallocator\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 270\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "\u001b[0;31mMemoryError\u001b[0m: cuMemAlloc failed: out of memory" - ] - } - ], + "outputs": [], "source": [ "if HAVE_PYCUDA:\n", " timings['cublas.zgemm'] = get_timings(CuBLASZgemm)" @@ -781,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": 138, + "execution_count": null, "id": "664c1c20-87da-491f-9391-6b56bdb39aae", "metadata": {}, "outputs": [], @@ -796,7 +729,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": null, "id": "2a21ab0e-21f4-4c83-a6c8-cb6f40bb9b11", "metadata": {}, "outputs": [], @@ -839,7 +772,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": null, "id": "e2b39e53-89ba-446b-85f8-6f90042c0424", "metadata": {}, "outputs": [], @@ -884,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": null, "id": "d45ab3dc", "metadata": { "ExecuteTime": { @@ -905,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": null, "id": "2df81e33-8c05-443b-bd40-133d5d3e35f9", "metadata": {}, "outputs": [], @@ -937,7 +870,7 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": null, "id": "76b2a1d1-10a7-4c52-b020-f790dfddfed4", "metadata": {}, "outputs": [], @@ -955,7 +888,7 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": null, "id": "b47cfbc4-ca67-41bd-ba88-1f610c235db6", "metadata": {}, "outputs": [], @@ -1032,7 +965,7 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": null, "id": "5de673ca-b70c-4dcd-8eec-fedf556ac1e9", "metadata": {}, "outputs": [], @@ -1087,7 +1020,7 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": null, "id": "1c0bb3a2-1956-4b31-86bd-5a63061c391f", "metadata": {}, "outputs": [], @@ -1108,37 +1041,10 @@ }, { "cell_type": "code", - "execution_count": 132, + "execution_count": null, "id": "80b93732-b374-4db9-b933-a77eda975ad7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(3, 32): 7.604e-01s ± 0.000e+00s [1 loops of 3]\n", - "(3, 64): 7.962e-01s ± 0.000e+00s [1 loops of 3]\n", - "(3, 128): 1.098e+00s ± 0.000e+00s [1 loops of 2]\n", - "(3, 256): " - ] - }, - { - "ename": "MemoryError", - "evalue": "cuMemAlloc failed: out of memory", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mMemoryError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [132], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m timings_reds \u001b[38;5;241m=\u001b[39m \u001b[43mget_timings_red\u001b[49m\u001b[43m(\u001b[49m\u001b[43mSingleLoopCuBLAS\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn [131], line 102\u001b[0m, in \u001b[0;36mget_timings_red\u001b[0;34m(solver, repeats, rerun)\u001b[0m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 100\u001b[0m sln \u001b[38;5;241m=\u001b[39m solver(z[(nants_redundant\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m, nside)], p)\n\u001b[0;32m--> 102\u001b[0m o \u001b[38;5;241m=\u001b[39m out[size] \u001b[38;5;241m=\u001b[39m \u001b[43mget_timing\u001b[49m\u001b[43m(\u001b[49m\u001b[43msln\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m sln \u001b[38;5;66;03m# Ensure memory is freed.\u001b[39;00m\n\u001b[1;32m 105\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mmean\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms ± \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mstd\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m1.3e\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124ms [\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mrepeats\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m loops of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mo\u001b[38;5;241m.\u001b[39mn\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m]\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "Cell \u001b[0;32mIn [131], line 23\u001b[0m, in \u001b[0;36mget_timing\u001b[0;34m(sln, repeats)\u001b[0m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_timing\u001b[39m(sln, repeats: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m repeats) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mfloat\u001b[39m:\n\u001b[0;32m---> 23\u001b[0m \u001b[43msln\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# this timing is not even used because it could contain\u001b[39;00m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;66;03m# caching and other overhead.\u001b[39;00m\n\u001b[1;32m 27\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mtime()\n", - "Cell \u001b[0;32mIn [127], line 3\u001b[0m, in \u001b[0;36mSingleLoopCuBLAS.setup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mz \u001b[38;5;241m=\u001b[39m \u001b[43mgpuarray\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_gpu\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mz\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mout \u001b[38;5;241m=\u001b[39m gpuarray\u001b[38;5;241m.\u001b[39mempty(\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpairs\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mcomplex\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m precision\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m2\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m np\u001b[38;5;241m.\u001b[39mcomplex64\n\u001b[1;32m 6\u001b[0m )\n", - "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:1294\u001b[0m, in \u001b[0;36mto_gpu\u001b[0;34m(ary, allocator)\u001b[0m\n\u001b[1;32m 1292\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mto_gpu\u001b[39m(ary, allocator\u001b[38;5;241m=\u001b[39mdrv\u001b[38;5;241m.\u001b[39mmem_alloc):\n\u001b[1;32m 1293\u001b[0m \u001b[38;5;124;03m\"\"\"converts a numpy array to a GPUArray\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1294\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mGPUArray\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallocator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstrides\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_compact_strides\u001b[49m\u001b[43m(\u001b[49m\u001b[43mary\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1295\u001b[0m result\u001b[38;5;241m.\u001b[39mset(ary)\n\u001b[1;32m 1296\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "File \u001b[0;32m~/miniconda3/envs/gputest/lib/python3.10/site-packages/pycuda/gpuarray.py:268\u001b[0m, in \u001b[0;36mGPUArray.__init__\u001b[0;34m(self, shape, dtype, allocator, base, gpudata, strides, order)\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m gpudata \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 267\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msize:\n\u001b[0;32m--> 268\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mallocator\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msize\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitemsize\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 270\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgpudata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "\u001b[0;31mMemoryError\u001b[0m: cuMemAlloc failed: out of memory" - ] - } - ], + "outputs": [], "source": [ "if HAVE_PYCUDA:\n", " timings_reds['cublas.singleloop'] = get_timings_red(SingleLoopCuBLAS)" @@ -1154,7 +1060,7 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": null, "id": "4108942c-7fcd-400d-abd3-878e688a3ed8", "metadata": {}, "outputs": [], @@ -1177,33 +1083,10 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": null, "id": "c8a4ba4f-d586-4a63-ae90-7e8bc3f82925", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(3, 32): 3.938e-01s ± 0.000e+00s [1 loops of 6]\n", - "(3, 64): 1.392e+00s ± 0.000e+00s [1 loops of 2]\n", - "(3, 128): 4.803e+00s ± 0.000e+00s [1 loops of 1]\n", - "(3, 256): 1.955e+01s ± 0.000e+00s [1 loops of 1]\n", - "(10, 32): 8.373e-01s ± 0.000e+00s [1 loops of 2]\n", - "(10, 64): 2.564e+00s ± 0.000e+00s [1 loops of 1]\n", - "(10, 128): 1.023e+01s ± 0.000e+00s [1 loops of 1]\n", - "(10, 256): 4.024e+01s ± 0.000e+00s [1 loops of 1]\n", - "(25, 32): 1.771e+00s ± 0.000e+00s [1 loops of 2]\n", - "(25, 64): 5.495e+00s ± 0.000e+00s [1 loops of 1]\n", - "(25, 128): 2.222e+01s ± 0.000e+00s [1 loops of 1]\n", - "(25, 256): 7.531e+01s ± 0.000e+00s [1 loops of 1]\n", - "(50, 32): 3.842e+00s ± 0.000e+00s [1 loops of 1]\n", - "(50, 64): 1.053e+01s ± 0.000e+00s [1 loops of 1]\n", - "(50, 128): 4.178e+01s ± 0.000e+00s [1 loops of 1]\n", - "(50, 256): 1.603e+02s ± 0.000e+00s [1 loops of 1]\n" - ] - } - ], + "outputs": [], "source": [ "if HAVE_NUMBA:\n", " timings_reds['numba.singleloop'] = get_timings_red(SingleLoopNumba)" @@ -1219,7 +1102,7 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": null, "id": "50447a2d-7b7d-4d61-8c1e-c593765849ef", "metadata": {}, "outputs": [], @@ -1256,7 +1139,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": null, "id": "e86bfe3c-e4f3-4abd-b23d-b3be5a4c517f", "metadata": {}, "outputs": [], @@ -1275,21 +1158,10 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": null, "id": "80bf6e17-b7aa-4d14-b180-632be242b676", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_timings_reds(timings_reds, timings);" ] From a2a78f1cebb93c679ee397b7a3f58b3ca4cac97b Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Tue, 3 Oct 2023 06:39:23 -0400 Subject: [PATCH 05/16] fix: tolerances --- ...rformance_test_large_matrix_multiply.ipynb | 48 +++++-------------- 1 file changed, 11 insertions(+), 37 deletions(-) diff --git a/devel/performance_test_large_matrix_multiply.ipynb b/devel/performance_test_large_matrix_multiply.ipynb index 55e16cc..144fee2 100644 --- a/devel/performance_test_large_matrix_multiply.ipynb +++ b/devel/performance_test_large_matrix_multiply.ipynb @@ -112,7 +112,9 @@ "repeats: int = 1\n", "rerun: bool = False\n", "precision: int = 1\n", - "nants_redundant: int = 350" + "nants_redundant: int = 350\n", + "max_nants: int = np.inf\n", + "max_nsrcs: int = np.inf" ] }, { @@ -213,8 +215,10 @@ "# Note that \"nants\" here represents Nants * Nfeed, which is why we \n", "# go to double the number of ants that HERA has.\n", "nants = (100, 200, 400, 700)\n", + "nants = [nant for nant in nants if nant <= max_nants]\n", "\n", "nsides = [32, 64, 128, 256]\n", + "nsides = [nside for nside in nsides if nside <= max_nsrcs]\n", "nsrcs = [2 * 12 * nside**2 for nside in nsides]\n", "\n", "z = {}\n", @@ -277,7 +281,7 @@ " return self.compute()\n", " \n", " @classmethod\n", - " def test(cls, rtol=1e-5, atol=1e-5):\n", + " def test(cls, rtol=1e-5 if precision==2 else 1e-3, atol=1e-5 if precision==2 else 1e-3):\n", " obj = cls(z0)\n", " result = obj()\n", " np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol)\n", @@ -298,7 +302,7 @@ " return self.compute()\n", " \n", " @classmethod\n", - " def test(cls, rtol=1e-5, atol=1e-5):\n", + " def test(cls, rtol=1e-5 if precision==2 else 1e-3, atol=1e-5 if precision==2 else 1e-3):\n", " # All the pairs.\n", " nant = z0.shape[0]\n", " pairs = np.array([(a, b) for a in range(nant) for b in range(nant)])\n", @@ -577,36 +581,6 @@ "#### cublas.zgemm" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "15f625c1-4878-4d72-b445-693319330278", - "metadata": {}, - "outputs": [], - "source": [ - "cc = CuBLASZgemm(z0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "09893bc3-e4dc-4dec-a37c-2de638e21e7e", - "metadata": {}, - "outputs": [], - "source": [ - "cc.setup()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "34266b0a-cdbf-489d-af80-0286856f23a8", - "metadata": {}, - "outputs": [], - "source": [ - "cc.z.dtype" - ] - }, { "cell_type": "code", "execution_count": null, @@ -680,7 +654,7 @@ " cublas_herk(\n", " h,\n", " uplo=\"L\",\n", - " trans='n',\n", + " trans='c',\n", " n=nant,\n", " k=nsrc,\n", " alpha=1.0,\n", @@ -1177,9 +1151,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:gputest]", + "display_name": "hera-gpu", "language": "python", - "name": "conda-env-gputest-py" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1191,7 +1165,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.4" }, "latex_envs": { "LaTeX_envs_menu_present": true, From 246ce821496523300f54149a3dd7678db05b1881 Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Tue, 3 Oct 2023 09:40:37 -0400 Subject: [PATCH 06/16] feat: add small package that tests performance --- devel/viscalc-performance/getperf.py | 201 ++++++++++++++++++ devel/viscalc-performance/methods/__init__.py | 0 devel/viscalc-performance/methods/_cublas.py | 45 ++++ devel/viscalc-performance/methods/_jax.py | 49 +++++ devel/viscalc-performance/methods/_lib.py | 54 +++++ .../methods/arrayfire_gemm.py | 18 ++ .../methods/cublas_vectorloop.py | 10 + .../methods/cublas_zgemm.py | 23 ++ .../methods/cublas_zherk.py | 20 ++ .../methods/jax_chunkedloop.py | 26 +++ devel/viscalc-performance/methods/jax_dot.py | 9 + .../methods/jax_vectorloop.py | 12 ++ devel/viscalc-performance/methods/np_dot.py | 6 + devel/viscalc-performance/methods/np_zgemm.py | 6 + devel/viscalc-performance/methods/np_zherk.py | 6 + .../methods/numba_vectorloop.py | 18 ++ ...rformance_test_large_matrix_multiply.ipynb | 0 17 files changed, 503 insertions(+) create mode 100644 devel/viscalc-performance/getperf.py create mode 100644 devel/viscalc-performance/methods/__init__.py create mode 100644 devel/viscalc-performance/methods/_cublas.py create mode 100644 devel/viscalc-performance/methods/_jax.py create mode 100644 devel/viscalc-performance/methods/_lib.py create mode 100644 devel/viscalc-performance/methods/arrayfire_gemm.py create mode 100644 devel/viscalc-performance/methods/cublas_vectorloop.py create mode 100644 devel/viscalc-performance/methods/cublas_zgemm.py create mode 100644 devel/viscalc-performance/methods/cublas_zherk.py create mode 100644 devel/viscalc-performance/methods/jax_chunkedloop.py create mode 100644 devel/viscalc-performance/methods/jax_dot.py create mode 100644 devel/viscalc-performance/methods/jax_vectorloop.py create mode 100644 devel/viscalc-performance/methods/np_dot.py create mode 100644 devel/viscalc-performance/methods/np_zgemm.py create mode 100644 devel/viscalc-performance/methods/np_zherk.py create mode 100644 devel/viscalc-performance/methods/numba_vectorloop.py rename devel/{ => viscalc-performance}/performance_test_large_matrix_multiply.ipynb (100%) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py new file mode 100644 index 0000000..7980fa1 --- /dev/null +++ b/devel/viscalc-performance/getperf.py @@ -0,0 +1,201 @@ +"""Script to get the performance metric of a particular solver.""" +from __future__ import annotations + +import click +from dataclasses import dataclass, asdict +import numpy as np +import time +from pathlib import Path +import yaml +import importlib +from methods._lib import Solver, RedundantSolver + +@dataclass +class TimeResult: + times: list[float] + n: int + + @property + def best(self): + return np.min(self.times) + + @property + def mean(self): + return np.mean(self.times) + + @property + def repeats(self): + return len(self.times) + + @property + def std(self): + return np.std(self.times) + +def get_timing(sln, repeats: int = 3) -> float: + sln.setup() + + t0 = time.time() + sln.compute() + t1 = time.time() - t0 + + times = [] + + if t1 > 2: # assume overhead from compilation etc. is negligible compared to 5sec + times.append(t1) + n = 1 + + if repeats > len(times): + # Need to do it at least twice to check if the time comes down. + + if t1 < 2: + t0 = time.time() + sln.compute() + t2 = time.time() - t0 + + n = int(2 / t2) + 1 + + if t2 > 2: + times.append(t2) + + if n == 1: + for _ in range(max(0, repeats - len(times))): + t0 = time.time() + sln.compute() + times.append(time.time() - t0) + + else: + for _ in range(repeats): + t0 = time.time() + for _ in range(n): + sln.compute() + times.append((time.time() - t0)/n) + + return TimeResult(times, n) + +def test_solver(solver, nants, nsrcs, ctype=complex): + z0 = getz((nants, nsrcs), ctype) + solver.test(z0, np.dot(z0, z0.T.conj())) + +def get_timings( + solver, nants, nsides, nsrcs, + repeats: int=3, rerun: bool = False, cache=Path('.'), + ctype=complex, + nants_redundant: int | None = None, + pairs: dict | None = None, +) -> dict[tuple[int, int], float]: + out = {} + + # First, test the solver. + test_solver(solver, nants[0], nsrcs[0], ctype) + + # Get the outer iterator. + if nants_redundant: + outer = pairs + else: + outer = nants + + for outer_thing in outer: + if nants_redundant: + label_outer = outer_thing[0] # pairfrac + use_nants = nants_redundant + else: + label_outer = outer_thing # nant + use_nants = outer_thing + + for nside, nsrc in zip(nsides, nsrcs): + size = (use_nants, nsrc) + z = getz(size, ctype) + + print(size, end=': ') + prec = 'double' if ctype is complex else 'single' + pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}.yaml" + if not rerun and pth.exists(): + with open(pth, 'r') as fl: + o = out[(label_outer, nside)] = TimeResult(**yaml.safe_load(fl)) + else: + if issubclass(solver, RedundantSolver): + sln = solver(z, outer_thing[1]) + else: + sln = solver(z) + + o = out[(label_outer, nside)] = get_timing(sln, repeats=repeats) + del sln # Ensure memory is freed. + + print(f"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]") + + # Cache it + with open(pth, 'w') as fl: + yaml.dump(asdict(o), fl) + + return out + +def getz(shape, ctype): + return ( + np.random.random(shape) + + np.random.random(shape)*1j + ).astype(ctype) + +def get_sizes(max_nants: int, max_nside: int, n_nants: int, n_nsides: int,): + # Note that "nants" here represents Nants * Nfeed, which is why we + # go to double the number of ants that HERA has. + nants = sorted([max_nants*2 // 2**i for i in range(n_nants)]) + nsides = sorted(max_nside // 2**i for i in range(n_nsides)) + nsrcs = [2 * 12 * nside**2 for nside in nsides] + + return nants, nsides, nsrcs + +@click.command +@click.argument('solver', type=str, required=True) +@click.option('--max-nants', type=int, default=350) +@click.option('--n-nants', type=int, default=4) +@click.option('--max-nside', type=int, default=256) +@click.option('--n-nsides', type=int, default=4) +@click.option("--redundant-nants", type=int, default=None) +@click.option("--double/--single", default=True) +@click.option("--repeats", type=int, default=3) +@click.option("--rerun/--use-cache", default=False) +@click.option("--cache", type=click.Path(exists=True, file_okay=False), default=Path('.')) +def main(solver, max_nants: int, n_nants: int, max_nside: int, n_nsides: int, redundant_nants: int | None, double: bool, repeats: int, rerun: bool, cache): + """Get the performance metric of a particular solver.""" + + nants, nsides, nsrcs = get_sizes(max_nants=max_nants, max_nside=max_nside, n_nants=n_nants, n_nsides=n_nsides) + + # Note that "nants" here represents Nants * Nfeed, which is why we + # go to double the number of ants that HERA has. + nants = sorted([max_nants*2 // 2**i for i in range(n_nants)]) + nsides = sorted(max_nside // 2**i for i in range(n_nsides)) + nsrcs = [2 * 12 * nside**2 for nside in nsides] + + if redundant_nants is None: + redundant_nants = nants[-1] // 2 + + mdl = importlib.import_module(solver, package='methods') + + for k, v in mdl.__dict__: + if issubclass(v, (Solver, RedundantSolver)) and v is not Solver and v is not RedundantSolver and not k.startswith("_"): + solver = v + break + else: + raise ValueError(f"Cannot find a solver in '{solver}'") + + if issubclass(solver, RedundantSolver): + allpairs = np.array([(0,0)] + [(a, b) for a in range(redundant_nants*2) for b in range(a+1, redundant_nants*2)]) + + pairs = {} + pairfracs = [3, 10, 25, 50, 100] + + for pc in pairfracs: + pairs[pc] = allpairs[np.sort(np.random.choice(np.arange(len(allpairs)), size=int(len(allpairs)*pc/100), replace=False))] + else: + pairs = None + + get_timings( + solver, nants=nants, nsides=nsides, nsrcs=nsrcs, + repeats=repeats, rerun=rerun, cache=cache, ctype=complex if double else np.complex64, + nants_redundant=redundant_nants*2 if issubclass(v, RedundantSolver) else None, + pairs=pairs + ) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py new file mode 100644 index 0000000..2bd1e9f --- /dev/null +++ b/devel/viscalc-performance/methods/_cublas.py @@ -0,0 +1,45 @@ +from ._lib import Solver, RedundantSolver + +try: + import pycuda.autoinit + from pycuda import cumath as cm + from pycuda import driver, gpuarray + from skcuda.cublas import ( + cublasCreate, + cublasDestroy, + cublasZgemm, + cublasZherk, + cublasZdotc, + cublasCgemm, + cublasCherk, + cublasCdotc, + ) + HAVE_PYCUDA = True +except: + HAVE_PYCUDA = False + +class _CuBLASCommon: + def setup(self): + self.z = gpuarray.to_gpu(self._z) + self.h = cublasCreate() + + if self._z.dtype is complex: + self.gemm = cublasZgemm + self.herk = cublasZherk + self.dotc = cublasZdotc + else: + self.gemm = cublasCgemm + self.herk = cublasCherk + self.dotc = cublasCdotc + +class _CuBLAS(Solver, _CuBLASCommon): + + def setup(self): + super().setup() + nant = self.z.shape[0] + self.out = gpuarray.empty(shape=(nant, nant), dtype=self._z.dtype) + +class _CuBLASRed(RedundantSolver, _CuBLASCommon): + def setup(self): + super().setup() + self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype) \ No newline at end of file diff --git a/devel/viscalc-performance/methods/_jax.py b/devel/viscalc-performance/methods/_jax.py new file mode 100644 index 0000000..9b4bac2 --- /dev/null +++ b/devel/viscalc-performance/methods/_jax.py @@ -0,0 +1,49 @@ +from ._lib import Solver, RedundantSolver + +try: + import jax.numpy as jnp + from jax import config + import jax + HAVE_JAX = True +except ImportError: + HAVE_JAX = False + + +class JAXSolver(Solver): + def setup(self): + if self._z.dtype is complex: + config.update('jax_enable_x64',True) + + self.z = jax.device_put(self._z) + + + +class JAXRed(RedundantSolver): + def setup(self): + if self._z.dtype is complex: + config.update('jax_enable_x64',True) + + self.z = jax.device_put(self._z) + self.ant1 = jax.device_put(self.pairs[:, 0]) + self.ant2 = jax.device_put(self.pairs[:, 1]) + self.out = jnp.empty(len(self.ant1), dtype=self._z.dtype) + + def compute(self): + nchunks = len(self.ant1) // self.chunksize + + def doslc(slc): + s1 = self.z[self.ant1[slc]] + s2 = self.z[self.ant2[slc]] + s1 *= s2.conj() + sm = jnp.sum(s1, axis=1) + self.out = self.out.at[slc].set(sm) + + for chunk in range(nchunks): + slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize) + doslc(slc) + + if len(self.ant1) % self.chunksize: + slc = slice((chunk+1)*self.chunksize, None) + doslc(slc) + + return jax.device_get(self.out) diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py new file mode 100644 index 0000000..4e06fc3 --- /dev/null +++ b/devel/viscalc-performance/methods/_lib.py @@ -0,0 +1,54 @@ +"""Some small library code to help with implementing different solvers.""" + +import numpy as np + + +class Solver: + def __init__(self, z: np.ndarray): + self._z = z + + def setup(self): + self.z = self._z + + def compute(self) -> np.ndarray: + pass + + def teardown(self): + pass + + def __call__(self) -> np.ndarray: + self.setup() + out = self.compute() + self.teardown() + return out + + @classmethod + def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): + if rtol is None: + rtol = 1e-5 if z0.dtype is complex else 1e-3 + if atol is None: + atol = 1e-5 if z0.dtype is complex else 1e-3 + + obj = cls(z0) + result = obj() + np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol) + +class RedundantSolver(Solver): + def __init__(self, z: np.ndarray, pairs: np.ndarray): + self._z = z + self.pairs = pairs + + @classmethod + def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): + if rtol is None: + rtol = 1e-5 if z0.dtype is complex else 1e-3 + if atol is None: + atol = 1e-5 if z0.dtype is complex else 1e-3 + + # All the pairs. + nant = z0.shape[0] + pairs = np.array([(a, b) for a in range(nant) for b in range(nant)]) + obj = cls(z0, pairs) + result = obj() + np.testing.assert_allclose(np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol) + \ No newline at end of file diff --git a/devel/viscalc-performance/methods/arrayfire_gemm.py b/devel/viscalc-performance/methods/arrayfire_gemm.py new file mode 100644 index 0000000..becb244 --- /dev/null +++ b/devel/viscalc-performance/methods/arrayfire_gemm.py @@ -0,0 +1,18 @@ +from ._lib import Solver + +try: + import arrayfire + HAVE_AF = True +except: + HAVE_AF = False + + +class ArrayFireGemm(Solver): + def setup(self): + self.out = arrayfire.Array(dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0])) + self.z = arrayfire.from_ndarray(self._z) + + def compute(self): + return arrayfire.blas.gemm( + self.z, self.z, lhs_opts=arrayfire.MATPROP.NONE, rhs_opts=arrayfire.MATPROP.CTRANS, C=self.out + ) \ No newline at end of file diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py new file mode 100644 index 0000000..7f97d65 --- /dev/null +++ b/devel/viscalc-performance/methods/cublas_vectorloop.py @@ -0,0 +1,10 @@ +from ._cublas import _CuBLASRed + +class CuBLASVectorLoop(_CuBLASRed): + def compute(self): + size = self.z.shape[1] + + for i, (a, b) in enumerate(self.pairs): + self.out[i] = self.dotc(self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1) + + return self.out.get() \ No newline at end of file diff --git a/devel/viscalc-performance/methods/cublas_zgemm.py b/devel/viscalc-performance/methods/cublas_zgemm.py new file mode 100644 index 0000000..74e9102 --- /dev/null +++ b/devel/viscalc-performance/methods/cublas_zgemm.py @@ -0,0 +1,23 @@ +from ._cublas import CuBLAS as _CB + +class CuBLASZgemm(_CB): + def compute(self): + nant, nsrc = self.z.shape + + self.gemm( + self.h, + "c", # conjugate transpose for first (remember fortran order) + "n", # no transpose for second. + nant, + nant, + nsrc, + 1.0, + self.z.gpudata, + nsrc, + self.z.gpudata, + nsrc, + 0.0, + self.out.gpudata, + nant, + ) + return self.out.get() \ No newline at end of file diff --git a/devel/viscalc-performance/methods/cublas_zherk.py b/devel/viscalc-performance/methods/cublas_zherk.py new file mode 100644 index 0000000..61c0d17 --- /dev/null +++ b/devel/viscalc-performance/methods/cublas_zherk.py @@ -0,0 +1,20 @@ +from ._cublas import CuBLAS as _CB + +class CuBLASZherk(_CB): + def compute(self): + nant, nsrc = self.z.shape + + self.herk( + self.h, + uplo="L", + trans='c', + n=nant, + k=nsrc, + alpha=1.0, + A=self.z.gpudata, + lda=nsrc, + beta=0.0, + C=self.out.gpudata, + ldc=nant + ) + return self.out.get() \ No newline at end of file diff --git a/devel/viscalc-performance/methods/jax_chunkedloop.py b/devel/viscalc-performance/methods/jax_chunkedloop.py new file mode 100644 index 0000000..e96919d --- /dev/null +++ b/devel/viscalc-performance/methods/jax_chunkedloop.py @@ -0,0 +1,26 @@ +from ._jax import JAXRed as _JR +import jax.numpy as jnp +import jax + +class JAXChunkedLoop(_JR): + chunksize = 350 + + def compute(self): + nchunks = len(self.ant1) // self.chunksize + + def doslc(slc): + s1 = self.z[self.ant1[slc]] + s2 = self.z[self.ant2[slc]] + s1 *= s2.conj() + sm = jnp.sum(s1, axis=1) + self.out = self.out.at[slc].set(sm) + + for chunk in range(nchunks): + slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize) + doslc(slc) + + if len(self.ant1) % self.chunksize: + slc = slice((chunk+1)*self.chunksize, None) + doslc(slc) + + return jax.device_get(self.out) diff --git a/devel/viscalc-performance/methods/jax_dot.py b/devel/viscalc-performance/methods/jax_dot.py new file mode 100644 index 0000000..7e27395 --- /dev/null +++ b/devel/viscalc-performance/methods/jax_dot.py @@ -0,0 +1,9 @@ +from ._jax import JAXSolver as _JXS +import jax.numpy as jnp +import jax + +class JAXDot(_JXS): + def compute(self): + out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST) + return jax.device_get(out) + \ No newline at end of file diff --git a/devel/viscalc-performance/methods/jax_vectorloop.py b/devel/viscalc-performance/methods/jax_vectorloop.py new file mode 100644 index 0000000..9d326c4 --- /dev/null +++ b/devel/viscalc-performance/methods/jax_vectorloop.py @@ -0,0 +1,12 @@ +from ._jax import JAXRed as _JR +import jax.numpy as jnp +import jax + +class JAXVectorLoop(_JR): + def compute(self): + zc = self.z.conj() + + for i, (a, b) in enumerate(self.pairs): + self.out[i] = jnp.dot(self.z[a], zc[b]) + + return jax.device_get(self.out) diff --git a/devel/viscalc-performance/methods/np_dot.py b/devel/viscalc-performance/methods/np_dot.py new file mode 100644 index 0000000..15621b2 --- /dev/null +++ b/devel/viscalc-performance/methods/np_dot.py @@ -0,0 +1,6 @@ +from ._lib import Solver +import numpy as np + +class NpDot(Solver): + def compute(self): + return np.dot(self.z, self.z.conj().T) \ No newline at end of file diff --git a/devel/viscalc-performance/methods/np_zgemm.py b/devel/viscalc-performance/methods/np_zgemm.py new file mode 100644 index 0000000..c83765d --- /dev/null +++ b/devel/viscalc-performance/methods/np_zgemm.py @@ -0,0 +1,6 @@ +from ._lib import Solver +from scipy.linalg import blas + +class NpZgemm(Solver): + def compute(self): + return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True) \ No newline at end of file diff --git a/devel/viscalc-performance/methods/np_zherk.py b/devel/viscalc-performance/methods/np_zherk.py new file mode 100644 index 0000000..0bb4eb0 --- /dev/null +++ b/devel/viscalc-performance/methods/np_zherk.py @@ -0,0 +1,6 @@ +from ._lib import Solver +from scipy.linalg import blas + +class NpZherk(Solver): + def compute(self): + return blas.zherk(alpha=1, a=self.z) \ No newline at end of file diff --git a/devel/viscalc-performance/methods/numba_vectorloop.py b/devel/viscalc-performance/methods/numba_vectorloop.py new file mode 100644 index 0000000..4027e58 --- /dev/null +++ b/devel/viscalc-performance/methods/numba_vectorloop.py @@ -0,0 +1,18 @@ +from ._lib import RedundantSolver +import numba +import numpy as np + +@numba.njit +def _dumbloopjit(z, pairs, out): + zc = z.conj() + for i, (a, b) in enumerate(pairs): + out[i] = np.dot(z[a], zc[b]) + +class SingleLoopNumba(RedundantSolver): + def setup(self): + self.z = self._z + self.out = np.empty(len(self.pairs), dtype=self._z.dtype) + + def compute(self): + _dumbloopjit(self.z, self.pairs, self.out) + return self.out diff --git a/devel/performance_test_large_matrix_multiply.ipynb b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb similarity index 100% rename from devel/performance_test_large_matrix_multiply.ipynb rename to devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb From 02831d1e72310499a1b0aa523a3bdf6ea2ed433a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 13:40:50 +0000 Subject: [PATCH 07/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- devel/viscalc-performance/getperf.py | 177 ++++++++++++------ devel/viscalc-performance/methods/_cublas.py | 21 ++- devel/viscalc-performance/methods/_jax.py | 22 +-- devel/viscalc-performance/methods/_lib.py | 18 +- .../methods/arrayfire_gemm.py | 15 +- .../methods/cublas_vectorloop.py | 7 +- .../methods/cublas_zgemm.py | 3 +- .../methods/cublas_zherk.py | 7 +- .../methods/jax_chunkedloop.py | 12 +- devel/viscalc-performance/methods/jax_dot.py | 7 +- .../methods/jax_vectorloop.py | 8 +- devel/viscalc-performance/methods/np_dot.py | 6 +- devel/viscalc-performance/methods/np_zgemm.py | 6 +- devel/viscalc-performance/methods/np_zherk.py | 6 +- .../methods/numba_vectorloop.py | 7 +- 15 files changed, 204 insertions(+), 118 deletions(-) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 7980fa1..793f1ea 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -2,61 +2,63 @@ from __future__ import annotations import click -from dataclasses import dataclass, asdict +import importlib import numpy as np import time -from pathlib import Path import yaml -import importlib -from methods._lib import Solver, RedundantSolver +from dataclasses import asdict, dataclass +from methods._lib import RedundantSolver, Solver +from pathlib import Path + @dataclass class TimeResult: times: list[float] n: int - + @property def best(self): return np.min(self.times) - + @property def mean(self): return np.mean(self.times) - + @property def repeats(self): return len(self.times) - + @property def std(self): return np.std(self.times) - + + def get_timing(sln, repeats: int = 3) -> float: sln.setup() - + t0 = time.time() sln.compute() t1 = time.time() - t0 times = [] - - if t1 > 2: # assume overhead from compilation etc. is negligible compared to 5sec + + if t1 > 2: # assume overhead from compilation etc. is negligible compared to 5sec times.append(t1) n = 1 - + if repeats > len(times): # Need to do it at least twice to check if the time comes down. - + if t1 < 2: t0 = time.time() sln.compute() t2 = time.time() - t0 n = int(2 / t2) + 1 - + if t2 > 2: times.append(t2) - + if n == 1: for _ in range(max(0, repeats - len(times))): t0 = time.time() @@ -68,27 +70,34 @@ def get_timing(sln, repeats: int = 3) -> float: t0 = time.time() for _ in range(n): sln.compute() - times.append((time.time() - t0)/n) + times.append((time.time() - t0) / n) return TimeResult(times, n) + def test_solver(solver, nants, nsrcs, ctype=complex): z0 = getz((nants, nsrcs), ctype) solver.test(z0, np.dot(z0, z0.T.conj())) + def get_timings( - solver, nants, nsides, nsrcs, - repeats: int=3, rerun: bool = False, cache=Path('.'), + solver, + nants, + nsides, + nsrcs, + repeats: int = 3, + rerun: bool = False, + cache=Path("."), ctype=complex, nants_redundant: int | None = None, pairs: dict | None = None, ) -> dict[tuple[int, int], float]: out = {} - + # First, test the solver. test_solver(solver, nants[0], nsrcs[0], ctype) - - # Get the outer iterator. + + # Get the outer iterator. if nants_redundant: outer = pairs else: @@ -99,103 +108,149 @@ def get_timings( label_outer = outer_thing[0] # pairfrac use_nants = nants_redundant else: - label_outer = outer_thing # nant + label_outer = outer_thing # nant use_nants = outer_thing for nside, nsrc in zip(nsides, nsrcs): size = (use_nants, nsrc) z = getz(size, ctype) - print(size, end=': ') - prec = 'double' if ctype is complex else 'single' + print(size, end=": ") + prec = "double" if ctype is complex else "single" pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}.yaml" if not rerun and pth.exists(): - with open(pth, 'r') as fl: + with open(pth) as fl: o = out[(label_outer, nside)] = TimeResult(**yaml.safe_load(fl)) else: if issubclass(solver, RedundantSolver): sln = solver(z, outer_thing[1]) else: sln = solver(z) - + o = out[(label_outer, nside)] = get_timing(sln, repeats=repeats) del sln # Ensure memory is freed. - + print(f"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]") - + # Cache it - with open(pth, 'w') as fl: + with open(pth, "w") as fl: yaml.dump(asdict(o), fl) - + return out + def getz(shape, ctype): - return ( - np.random.random(shape) + - np.random.random(shape)*1j - ).astype(ctype) + return (np.random.random(shape) + np.random.random(shape) * 1j).astype(ctype) -def get_sizes(max_nants: int, max_nside: int, n_nants: int, n_nsides: int,): - # Note that "nants" here represents Nants * Nfeed, which is why we + +def get_sizes( + max_nants: int, + max_nside: int, + n_nants: int, + n_nsides: int, +): + # Note that "nants" here represents Nants * Nfeed, which is why we # go to double the number of ants that HERA has. - nants = sorted([max_nants*2 // 2**i for i in range(n_nants)]) + nants = sorted([max_nants * 2 // 2**i for i in range(n_nants)]) nsides = sorted(max_nside // 2**i for i in range(n_nsides)) nsrcs = [2 * 12 * nside**2 for nside in nsides] return nants, nsides, nsrcs + @click.command -@click.argument('solver', type=str, required=True) -@click.option('--max-nants', type=int, default=350) -@click.option('--n-nants', type=int, default=4) -@click.option('--max-nside', type=int, default=256) -@click.option('--n-nsides', type=int, default=4) +@click.argument("solver", type=str, required=True) +@click.option("--max-nants", type=int, default=350) +@click.option("--n-nants", type=int, default=4) +@click.option("--max-nside", type=int, default=256) +@click.option("--n-nsides", type=int, default=4) @click.option("--redundant-nants", type=int, default=None) @click.option("--double/--single", default=True) @click.option("--repeats", type=int, default=3) @click.option("--rerun/--use-cache", default=False) -@click.option("--cache", type=click.Path(exists=True, file_okay=False), default=Path('.')) -def main(solver, max_nants: int, n_nants: int, max_nside: int, n_nsides: int, redundant_nants: int | None, double: bool, repeats: int, rerun: bool, cache): +@click.option( + "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".") +) +def main( + solver, + max_nants: int, + n_nants: int, + max_nside: int, + n_nsides: int, + redundant_nants: int | None, + double: bool, + repeats: int, + rerun: bool, + cache, +): """Get the performance metric of a particular solver.""" - nants, nsides, nsrcs = get_sizes(max_nants=max_nants, max_nside=max_nside, n_nants=n_nants, n_nsides=n_nsides) + nants, nsides, nsrcs = get_sizes( + max_nants=max_nants, max_nside=max_nside, n_nants=n_nants, n_nsides=n_nsides + ) - # Note that "nants" here represents Nants * Nfeed, which is why we + # Note that "nants" here represents Nants * Nfeed, which is why we # go to double the number of ants that HERA has. - nants = sorted([max_nants*2 // 2**i for i in range(n_nants)]) + nants = sorted([max_nants * 2 // 2**i for i in range(n_nants)]) nsides = sorted(max_nside // 2**i for i in range(n_nsides)) nsrcs = [2 * 12 * nside**2 for nside in nsides] if redundant_nants is None: redundant_nants = nants[-1] // 2 - mdl = importlib.import_module(solver, package='methods') - + mdl = importlib.import_module(solver, package="methods") + for k, v in mdl.__dict__: - if issubclass(v, (Solver, RedundantSolver)) and v is not Solver and v is not RedundantSolver and not k.startswith("_"): + if ( + issubclass(v, (Solver, RedundantSolver)) + and v is not Solver + and v is not RedundantSolver + and not k.startswith("_") + ): solver = v break else: raise ValueError(f"Cannot find a solver in '{solver}'") - + if issubclass(solver, RedundantSolver): - allpairs = np.array([(0,0)] + [(a, b) for a in range(redundant_nants*2) for b in range(a+1, redundant_nants*2)]) + allpairs = np.array( + [(0, 0)] + + [ + (a, b) + for a in range(redundant_nants * 2) + for b in range(a + 1, redundant_nants * 2) + ] + ) pairs = {} pairfracs = [3, 10, 25, 50, 100] for pc in pairfracs: - pairs[pc] = allpairs[np.sort(np.random.choice(np.arange(len(allpairs)), size=int(len(allpairs)*pc/100), replace=False))] + pairs[pc] = allpairs[ + np.sort( + np.random.choice( + np.arange(len(allpairs)), + size=int(len(allpairs) * pc / 100), + replace=False, + ) + ) + ] else: pairs = None get_timings( - solver, nants=nants, nsides=nsides, nsrcs=nsrcs, - repeats=repeats, rerun=rerun, cache=cache, ctype=complex if double else np.complex64, - nants_redundant=redundant_nants*2 if issubclass(v, RedundantSolver) else None, - pairs=pairs + solver, + nants=nants, + nsides=nsides, + nsrcs=nsrcs, + repeats=repeats, + rerun=rerun, + cache=cache, + ctype=complex if double else np.complex64, + nants_redundant=redundant_nants * 2 if issubclass(v, RedundantSolver) else None, + pairs=pairs, ) - -if __name__ == '__main__': - main() \ No newline at end of file + +if __name__ == "__main__": + main() diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index 2bd1e9f..8165f21 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -1,23 +1,25 @@ -from ._lib import Solver, RedundantSolver +from ._lib import RedundantSolver, Solver try: import pycuda.autoinit from pycuda import cumath as cm from pycuda import driver, gpuarray from skcuda.cublas import ( + cublasCdotc, + cublasCgemm, + cublasCherk, cublasCreate, cublasDestroy, + cublasZdotc, cublasZgemm, cublasZherk, - cublasZdotc, - cublasCgemm, - cublasCherk, - cublasCdotc, ) - HAVE_PYCUDA = True + + HAVE_PYCUDA = True except: HAVE_PYCUDA = False + class _CuBLASCommon: def setup(self): self.z = gpuarray.to_gpu(self._z) @@ -32,14 +34,15 @@ def setup(self): self.herk = cublasCherk self.dotc = cublasCdotc -class _CuBLAS(Solver, _CuBLASCommon): +class _CuBLAS(Solver, _CuBLASCommon): def setup(self): super().setup() nant = self.z.shape[0] self.out = gpuarray.empty(shape=(nant, nant), dtype=self._z.dtype) - + + class _CuBLASRed(RedundantSolver, _CuBLASCommon): def setup(self): super().setup() - self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype) \ No newline at end of file + self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype) diff --git a/devel/viscalc-performance/methods/_jax.py b/devel/viscalc-performance/methods/_jax.py index 9b4bac2..e9cfe49 100644 --- a/devel/viscalc-performance/methods/_jax.py +++ b/devel/viscalc-performance/methods/_jax.py @@ -1,33 +1,33 @@ -from ._lib import Solver, RedundantSolver +from ._lib import RedundantSolver, Solver try: + import jax import jax.numpy as jnp from jax import config - import jax + HAVE_JAX = True except ImportError: HAVE_JAX = False class JAXSolver(Solver): - def setup(self): + def setup(self): if self._z.dtype is complex: - config.update('jax_enable_x64',True) + config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) - - -class JAXRed(RedundantSolver): + +class JAXRed(RedundantSolver): def setup(self): if self._z.dtype is complex: - config.update('jax_enable_x64',True) + config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) self.ant1 = jax.device_put(self.pairs[:, 0]) self.ant2 = jax.device_put(self.pairs[:, 1]) self.out = jnp.empty(len(self.ant1), dtype=self._z.dtype) - + def compute(self): nchunks = len(self.ant1) // self.chunksize @@ -39,11 +39,11 @@ def doslc(slc): self.out = self.out.at[slc].set(sm) for chunk in range(nchunks): - slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize) + slc = slice(chunk * self.chunksize, (chunk + 1) * self.chunksize) doslc(slc) if len(self.ant1) % self.chunksize: - slc = slice((chunk+1)*self.chunksize, None) + slc = slice((chunk + 1) * self.chunksize, None) doslc(slc) return jax.device_get(self.out) diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py index 4e06fc3..07fb677 100644 --- a/devel/viscalc-performance/methods/_lib.py +++ b/devel/viscalc-performance/methods/_lib.py @@ -6,13 +6,13 @@ class Solver: def __init__(self, z: np.ndarray): self._z = z - + def setup(self): self.z = self._z - + def compute(self) -> np.ndarray: pass - + def teardown(self): pass @@ -21,7 +21,7 @@ def __call__(self) -> np.ndarray: out = self.compute() self.teardown() return out - + @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: @@ -32,12 +32,13 @@ def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): obj = cls(z0) result = obj() np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol) - + + class RedundantSolver(Solver): def __init__(self, z: np.ndarray, pairs: np.ndarray): self._z = z self.pairs = pairs - + @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: @@ -50,5 +51,6 @@ def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): pairs = np.array([(a, b) for a in range(nant) for b in range(nant)]) obj = cls(z0, pairs) result = obj() - np.testing.assert_allclose(np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol) - \ No newline at end of file + np.testing.assert_allclose( + np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol + ) diff --git a/devel/viscalc-performance/methods/arrayfire_gemm.py b/devel/viscalc-performance/methods/arrayfire_gemm.py index becb244..0491ec9 100644 --- a/devel/viscalc-performance/methods/arrayfire_gemm.py +++ b/devel/viscalc-performance/methods/arrayfire_gemm.py @@ -2,6 +2,7 @@ try: import arrayfire + HAVE_AF = True except: HAVE_AF = False @@ -9,10 +10,16 @@ class ArrayFireGemm(Solver): def setup(self): - self.out = arrayfire.Array(dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0])) + self.out = arrayfire.Array( + dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0]) + ) self.z = arrayfire.from_ndarray(self._z) - + def compute(self): return arrayfire.blas.gemm( - self.z, self.z, lhs_opts=arrayfire.MATPROP.NONE, rhs_opts=arrayfire.MATPROP.CTRANS, C=self.out - ) \ No newline at end of file + self.z, + self.z, + lhs_opts=arrayfire.MATPROP.NONE, + rhs_opts=arrayfire.MATPROP.CTRANS, + C=self.out, + ) diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py index 7f97d65..1634ef2 100644 --- a/devel/viscalc-performance/methods/cublas_vectorloop.py +++ b/devel/viscalc-performance/methods/cublas_vectorloop.py @@ -1,10 +1,13 @@ from ._cublas import _CuBLASRed + class CuBLASVectorLoop(_CuBLASRed): def compute(self): size = self.z.shape[1] for i, (a, b) in enumerate(self.pairs): - self.out[i] = self.dotc(self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1) + self.out[i] = self.dotc( + self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1 + ) - return self.out.get() \ No newline at end of file + return self.out.get() diff --git a/devel/viscalc-performance/methods/cublas_zgemm.py b/devel/viscalc-performance/methods/cublas_zgemm.py index 74e9102..03cdac6 100644 --- a/devel/viscalc-performance/methods/cublas_zgemm.py +++ b/devel/viscalc-performance/methods/cublas_zgemm.py @@ -1,5 +1,6 @@ from ._cublas import CuBLAS as _CB + class CuBLASZgemm(_CB): def compute(self): nant, nsrc = self.z.shape @@ -20,4 +21,4 @@ def compute(self): self.out.gpudata, nant, ) - return self.out.get() \ No newline at end of file + return self.out.get() diff --git a/devel/viscalc-performance/methods/cublas_zherk.py b/devel/viscalc-performance/methods/cublas_zherk.py index 61c0d17..022124b 100644 --- a/devel/viscalc-performance/methods/cublas_zherk.py +++ b/devel/viscalc-performance/methods/cublas_zherk.py @@ -1,5 +1,6 @@ from ._cublas import CuBLAS as _CB + class CuBLASZherk(_CB): def compute(self): nant, nsrc = self.z.shape @@ -7,7 +8,7 @@ def compute(self): self.herk( self.h, uplo="L", - trans='c', + trans="c", n=nant, k=nsrc, alpha=1.0, @@ -15,6 +16,6 @@ def compute(self): lda=nsrc, beta=0.0, C=self.out.gpudata, - ldc=nant + ldc=nant, ) - return self.out.get() \ No newline at end of file + return self.out.get() diff --git a/devel/viscalc-performance/methods/jax_chunkedloop.py b/devel/viscalc-performance/methods/jax_chunkedloop.py index e96919d..9676800 100644 --- a/devel/viscalc-performance/methods/jax_chunkedloop.py +++ b/devel/viscalc-performance/methods/jax_chunkedloop.py @@ -1,10 +1,12 @@ -from ._jax import JAXRed as _JR -import jax.numpy as jnp import jax +import jax.numpy as jnp + +from ._jax import JAXRed as _JR + class JAXChunkedLoop(_JR): chunksize = 350 - + def compute(self): nchunks = len(self.ant1) // self.chunksize @@ -16,11 +18,11 @@ def doslc(slc): self.out = self.out.at[slc].set(sm) for chunk in range(nchunks): - slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize) + slc = slice(chunk * self.chunksize, (chunk + 1) * self.chunksize) doslc(slc) if len(self.ant1) % self.chunksize: - slc = slice((chunk+1)*self.chunksize, None) + slc = slice((chunk + 1) * self.chunksize, None) doslc(slc) return jax.device_get(self.out) diff --git a/devel/viscalc-performance/methods/jax_dot.py b/devel/viscalc-performance/methods/jax_dot.py index 7e27395..1e84ab5 100644 --- a/devel/viscalc-performance/methods/jax_dot.py +++ b/devel/viscalc-performance/methods/jax_dot.py @@ -1,9 +1,10 @@ -from ._jax import JAXSolver as _JXS -import jax.numpy as jnp import jax +import jax.numpy as jnp + +from ._jax import JAXSolver as _JXS + class JAXDot(_JXS): def compute(self): out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST) return jax.device_get(out) - \ No newline at end of file diff --git a/devel/viscalc-performance/methods/jax_vectorloop.py b/devel/viscalc-performance/methods/jax_vectorloop.py index 9d326c4..1121623 100644 --- a/devel/viscalc-performance/methods/jax_vectorloop.py +++ b/devel/viscalc-performance/methods/jax_vectorloop.py @@ -1,8 +1,10 @@ -from ._jax import JAXRed as _JR -import jax.numpy as jnp import jax +import jax.numpy as jnp + +from ._jax import JAXRed as _JR + -class JAXVectorLoop(_JR): +class JAXVectorLoop(_JR): def compute(self): zc = self.z.conj() diff --git a/devel/viscalc-performance/methods/np_dot.py b/devel/viscalc-performance/methods/np_dot.py index 15621b2..e296825 100644 --- a/devel/viscalc-performance/methods/np_dot.py +++ b/devel/viscalc-performance/methods/np_dot.py @@ -1,6 +1,8 @@ -from ._lib import Solver import numpy as np +from ._lib import Solver + + class NpDot(Solver): def compute(self): - return np.dot(self.z, self.z.conj().T) \ No newline at end of file + return np.dot(self.z, self.z.conj().T) diff --git a/devel/viscalc-performance/methods/np_zgemm.py b/devel/viscalc-performance/methods/np_zgemm.py index c83765d..35afd7a 100644 --- a/devel/viscalc-performance/methods/np_zgemm.py +++ b/devel/viscalc-performance/methods/np_zgemm.py @@ -1,6 +1,8 @@ -from ._lib import Solver from scipy.linalg import blas +from ._lib import Solver + + class NpZgemm(Solver): def compute(self): - return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True) \ No newline at end of file + return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True) diff --git a/devel/viscalc-performance/methods/np_zherk.py b/devel/viscalc-performance/methods/np_zherk.py index 0bb4eb0..bacb996 100644 --- a/devel/viscalc-performance/methods/np_zherk.py +++ b/devel/viscalc-performance/methods/np_zherk.py @@ -1,6 +1,8 @@ -from ._lib import Solver from scipy.linalg import blas +from ._lib import Solver + + class NpZherk(Solver): def compute(self): - return blas.zherk(alpha=1, a=self.z) \ No newline at end of file + return blas.zherk(alpha=1, a=self.z) diff --git a/devel/viscalc-performance/methods/numba_vectorloop.py b/devel/viscalc-performance/methods/numba_vectorloop.py index 4027e58..d868bb3 100644 --- a/devel/viscalc-performance/methods/numba_vectorloop.py +++ b/devel/viscalc-performance/methods/numba_vectorloop.py @@ -1,18 +1,21 @@ -from ._lib import RedundantSolver import numba import numpy as np +from ._lib import RedundantSolver + + @numba.njit def _dumbloopjit(z, pairs, out): zc = z.conj() for i, (a, b) in enumerate(pairs): out[i] = np.dot(z[a], zc[b]) + class SingleLoopNumba(RedundantSolver): def setup(self): self.z = self._z self.out = np.empty(len(self.pairs), dtype=self._z.dtype) - + def compute(self): _dumbloopjit(self.z, self.pairs, self.out) return self.out From 6c88fbaee04f45db6e6fb9201a229c8ec436c8ac Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Tue, 3 Oct 2023 09:48:49 -0400 Subject: [PATCH 08/16] fix: try importing modules at top level --- devel/viscalc-performance/methods/__init__.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index e69de29..e360070 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -0,0 +1,3 @@ +from . import np_dot +from . import np_zgemm +from . import np_zherk \ No newline at end of file From e93f2165382a6e1c1cdf3b7d50fcd791e23a4b3b Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 3 Oct 2023 13:49:16 +0000 Subject: [PATCH 09/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- devel/viscalc-performance/methods/__init__.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index e360070..3fd9363 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -1,3 +1 @@ -from . import np_dot -from . import np_zgemm -from . import np_zherk \ No newline at end of file +from . import np_dot, np_zgemm, np_zherk From e07d26ae644c51707a9ec11eecf99ab46b62825b Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Fri, 6 Oct 2023 04:39:22 -0400 Subject: [PATCH 10/16] refactor: the whole viscalc-performance subpackage --- devel/viscalc-performance/getperf.py | 72 +- devel/viscalc-performance/methods/__init__.py | 19 +- devel/viscalc-performance/methods/_cublas.py | 170 ++- devel/viscalc-performance/methods/_jax.py | 4 +- devel/viscalc-performance/methods/_lib.py | 23 +- .../methods/cublas_chunkedloop.py | 93 ++ .../methods/cublas_vectorloop.py | 19 +- .../methods/cublas_zgemm.py | 55 +- .../methods/cublas_zherk.py | 46 +- .../methods/jax_vectorloop.py | 17 +- devel/viscalc-performance/methods/np_dot.py | 5 +- devel/viscalc-performance/methods/np_zgemm.py | 6 +- devel/viscalc-performance/methods/np_zherk.py | 5 +- ...rformance_test_large_matrix_multiply.ipynb | 1198 +++-------------- 14 files changed, 639 insertions(+), 1093 deletions(-) create mode 100644 devel/viscalc-performance/methods/cublas_chunkedloop.py diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 793f1ea..1ca68ed 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -91,20 +91,19 @@ def get_timings( ctype=complex, nants_redundant: int | None = None, pairs: dict | None = None, + transpose: bool = False, ) -> dict[tuple[int, int], float]: out = {} + cache=Path(cache) # First, test the solver. test_solver(solver, nants[0], nsrcs[0], ctype) # Get the outer iterator. - if nants_redundant: - outer = pairs - else: - outer = nants + outer = pairs.items() if solver.is_redundant else nants for outer_thing in outer: - if nants_redundant: + if solver.is_redundant: label_outer = outer_thing[0] # pairfrac use_nants = nants_redundant else: @@ -113,19 +112,17 @@ def get_timings( for nside, nsrc in zip(nsides, nsrcs): size = (use_nants, nsrc) - z = getz(size, ctype) + z = getz(size, ctype, transpose=transpose) - print(size, end=": ") + print((label_outer, nside), end=": ") prec = "double" if ctype is complex else "single" - pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}.yaml" + trns = 'col' if transpose else 'row' + pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}_{trns}.yaml" if not rerun and pth.exists(): with open(pth) as fl: o = out[(label_outer, nside)] = TimeResult(**yaml.safe_load(fl)) else: - if issubclass(solver, RedundantSolver): - sln = solver(z, outer_thing[1]) - else: - sln = solver(z) + sln = solver(z, outer_thing[1]) if solver.is_redundant else solver(z) o = out[(label_outer, nside)] = get_timing(sln, repeats=repeats) del sln # Ensure memory is freed. @@ -139,9 +136,12 @@ def get_timings( return out -def getz(shape, ctype): - return (np.random.random(shape) + np.random.random(shape) * 1j).astype(ctype) - +def getz(shape, ctype, transpose=False): + if transpose: + return (np.random.random(shape[::-1]) + np.random.random(shape[::-1]) * 1j).astype(ctype) + else: + return (np.random.random(shape) + np.random.random(shape) * 1j).astype(ctype) + def get_sizes( max_nants: int, @@ -157,6 +157,22 @@ def get_sizes( return nants, nsides, nsrcs +def get_solver(solver): + mdl = importlib.import_module(f"methods.{solver}") + + for k, v in mdl.__dict__.items(): + if ( + np.issubclass_(v, (Solver, RedundantSolver)) + and v is not Solver + and v is not RedundantSolver + and not k.startswith("_") + ): + solver = v + break + else: + raise ValueError(f"Cannot find a solver in '{solver}'") + + return solver @click.command @click.argument("solver", type=str, required=True) @@ -164,10 +180,10 @@ def get_sizes( @click.option("--n-nants", type=int, default=4) @click.option("--max-nside", type=int, default=256) @click.option("--n-nsides", type=int, default=4) -@click.option("--redundant-nants", type=int, default=None) @click.option("--double/--single", default=True) @click.option("--repeats", type=int, default=3) @click.option("--rerun/--use-cache", default=False) +@click.option("--transpose/--no-transpose", default=False) @click.option( "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".") ) @@ -177,11 +193,11 @@ def main( n_nants: int, max_nside: int, n_nsides: int, - redundant_nants: int | None, double: bool, repeats: int, rerun: bool, cache, + transpose: bool ): """Get the performance metric of a particular solver.""" @@ -195,24 +211,11 @@ def main( nsides = sorted(max_nside // 2**i for i in range(n_nsides)) nsrcs = [2 * 12 * nside**2 for nside in nsides] - if redundant_nants is None: - redundant_nants = nants[-1] // 2 - - mdl = importlib.import_module(solver, package="methods") + redundant_nants = nants[-1] // 2 - for k, v in mdl.__dict__: - if ( - issubclass(v, (Solver, RedundantSolver)) - and v is not Solver - and v is not RedundantSolver - and not k.startswith("_") - ): - solver = v - break - else: - raise ValueError(f"Cannot find a solver in '{solver}'") + solver = get_solver(solver) - if issubclass(solver, RedundantSolver): + if solver.is_redundant: allpairs = np.array( [(0, 0)] + [ @@ -247,8 +250,9 @@ def main( rerun=rerun, cache=cache, ctype=complex if double else np.complex64, - nants_redundant=redundant_nants * 2 if issubclass(v, RedundantSolver) else None, + nants_redundant=redundant_nants * 2, pairs=pairs, + transpose=transpose ) diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index e360070..7c5009f 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -1,3 +1,16 @@ -from . import np_dot -from . import np_zgemm -from . import np_zherk \ No newline at end of file +from .np_dot import NpDot +from .np_zgemm import NpZgemm +from .np_zherk import NpZherk + +from .numba_vectorloop import SingleLoopNumba + +from .jax_chunkedloop import JAXChunkedLoop +from .jax_vectorloop import JAXVectorLoop +from .jax_dot import JAXDot + +from .cublas_zgemm import CuBLASZgemm +from .cublas_zherk import CuBLASZherk +from .cublas_vectorloop import CuBLASVectorLoop +from .cublas_chunkedloop import CuBLASChunkedLoop + +from .arrayfire_gemm import ArrayFireGemm diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index 8165f21..ae9942f 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -1,48 +1,178 @@ from ._lib import RedundantSolver, Solver +import ctypes +import numpy as np +from functools import cache +from jinja2 import Template +import os +import warnings try: - import pycuda.autoinit - from pycuda import cumath as cm - from pycuda import driver, gpuarray - from skcuda.cublas import ( - cublasCdotc, - cublasCgemm, - cublasCherk, - cublasCreate, - cublasDestroy, - cublasZdotc, - cublasZgemm, - cublasZherk, - ) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + + import pycuda.autoinit + from pycuda import cumath as cm + + from pycuda import driver, gpuarray, compiler + from skcuda.cublas import ( + cublasCgemm, + cublasCherk, + cublasCreate, + cublasDestroy, + cublasZgemm, + cublasZherk, + cublasZgemv, + cublasCgemv, + _libcublas, + cuda, + ) HAVE_PYCUDA = True except: HAVE_PYCUDA = False +def cublasZdotc_inplace(handle, n, x, incx, y, incy, result): + _libcublas.cublasZdotc_v2( + handle, n, int(x), incx, int(y), incy, int(result) + ) + +def cublasCdotc_inplace(handle, n, x, incx, y, incy, result): + _libcublas.cublasCdotc_v2( + handle, n, int(x), incx, int(y), incy, + int(result) + ) + class _CuBLASCommon: def setup(self): self.z = gpuarray.to_gpu(self._z) self.h = cublasCreate() - if self._z.dtype is complex: + if self._z.dtype.name == 'complex128': self.gemm = cublasZgemm self.herk = cublasZherk - self.dotc = cublasZdotc + self.dotc = cublasZdotc_inplace + self.gemv = cublasZgemv else: self.gemm = cublasCgemm self.herk = cublasCherk - self.dotc = cublasCdotc - + self.dotc = cublasCdotc_inplace + self.gemv = cublasCgemv -class _CuBLAS(Solver, _CuBLASCommon): +class _CuBLAS(_CuBLASCommon, Solver): def setup(self): super().setup() - nant = self.z.shape[0] + if self.transposed: + nant = self.z.shape[1] + else: + nant = self.z.shape[0] self.out = gpuarray.empty(shape=(nant, nant), dtype=self._z.dtype) -class _CuBLASRed(RedundantSolver, _CuBLASCommon): +class _CuBLASRed(_CuBLASCommon, RedundantSolver): def setup(self): super().setup() self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype) + + +take_along_axis_kernel_code = r""" +// CUDA code for copying values from a 2D array into another 2D array along an axis. + +#include +#include +#include + +__global__ void TakeAlongFirstAxis2D( + {{ TYPE }} *in_matrix, + int m, + int n, + int *indices, + int k, + {{ TYPE }} *out_matrix +){ + const uint i = blockIdx.x * blockDim.x + threadIdx.x; + const uint j = blockIdx.y * blockDim.y + threadIdx.y; + + const uint outel = j*n + i; + + // exit if we're out of scope + if (j >= k || i >= n) return; + + int idx = indices[j]; + out_matrix[outel] = in_matrix[idx*n+i]; +} + + +__global__ void TakeAlongSecondAxis2D( + {{ TYPE }} *in_matrix, + int m, + int n, + int *indices, + int k, + {{ TYPE }} *out_matrix +){ + const uint i = blockIdx.x * blockDim.x + threadIdx.x; + const uint j = blockIdx.y * blockDim.y + threadIdx.y; + + + // exit if we're out of scope + if (i >= k || j >= m) return; + + int idx = indices[i]; + const uint outel = j*k + i; + + out_matrix[j*k+i] = in_matrix[j*n+idx]; +} +""" + +if HAVE_PYCUDA: + def compile_take(dtype): + take_along_axis_template = Template(take_along_axis_kernel_code) + take_along_axis_code = take_along_axis_template.render(TYPE=dtype) + return ( + compiler.SourceModule(take_along_axis_code).get_function(f"TakeAlongFirstAxis2D"), + compiler.SourceModule(take_along_axis_code).get_function(f"TakeAlongSecondAxis2D"), + ) + + + take_along_first_axis_z, take_along_second_axis_z = compile_take('cuDoubleComplex') + take_along_first_axis_c, take_along_second_axis_c = compile_take('cuFloatComplex') + + @cache + def _cudatake_blocksize(n: int,k: int): + nthreads_max = 1024 + threadsx = min(nthreads_max, n) + threadsy = min(k, nthreads_max // threadsx) + block = (threadsx, threadsy, 1) + grid = (int(np.ceil(n / threadsx)), int(np.ceil(k / threadsy)), 1) + return block, grid + + def cuda_take_along_axis(x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0) -> gpuarray.GPUArray: + m, n = x.shape + if axis==0: + out = gpuarray.empty((idx.shape[0], n), dtype=x.dtype) + else: + out = gpuarray.empty((m, idx.shape[0]), dtype=x.dtype) + + if idx.dtype.name == "int64": + idx = idx.astype(np.int32) + + block, grid = _cudatake_blocksize(n, idx.shape[0]) + if axis==0: + fnc = take_along_first_axis_z if x.dtype.name == 'complex128' else take_along_first_axis_c + else: + fnc = take_along_second_axis_z if x.dtype.name == 'complex128' else take_along_second_axis_c + + fnc( + x.gpudata, + np.int32(m), + np.int32(n), + idx.gpudata, + np.int32(idx.shape[0]), + out.gpudata, + block=block, + grid=grid, + ) + return out +else: + cuda_take_along_axis = None \ No newline at end of file diff --git a/devel/viscalc-performance/methods/_jax.py b/devel/viscalc-performance/methods/_jax.py index e9cfe49..1a21e07 100644 --- a/devel/viscalc-performance/methods/_jax.py +++ b/devel/viscalc-performance/methods/_jax.py @@ -12,7 +12,7 @@ class JAXSolver(Solver): def setup(self): - if self._z.dtype is complex: + if self._z.dtype.name == 'complex128': config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) @@ -20,7 +20,7 @@ def setup(self): class JAXRed(RedundantSolver): def setup(self): - if self._z.dtype is complex: + if self._z.dtype.name == 'complex128': config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py index 07fb677..fc815c4 100644 --- a/devel/viscalc-performance/methods/_lib.py +++ b/devel/viscalc-performance/methods/_lib.py @@ -4,8 +4,14 @@ class Solver: + is_redundant: bool = False + def __init__(self, z: np.ndarray): self._z = z + if self._z.shape[0] > self._z.shape[1]: + self.transposed = True + else: + self.transposed = False def setup(self): self.z = self._z @@ -25,9 +31,9 @@ def __call__(self) -> np.ndarray: @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: - rtol = 1e-5 if z0.dtype is complex else 1e-3 + rtol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 if atol is None: - atol = 1e-5 if z0.dtype is complex else 1e-3 + atol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 obj = cls(z0) result = obj() @@ -35,19 +41,26 @@ def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): class RedundantSolver(Solver): + is_redundant: bool = True + def __init__(self, z: np.ndarray, pairs: np.ndarray): self._z = z + if self._z.shape[0] > self._z.shape[1]: + self.transposed = True + else: + self.transposed = False + self.pairs = pairs @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: - rtol = 1e-5 if z0.dtype is complex else 1e-3 + rtol = 1e-5 if z0.dtype.name=='complex128' else 1e-3 if atol is None: - atol = 1e-5 if z0.dtype is complex else 1e-3 + atol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 # All the pairs. - nant = z0.shape[0] + nant = min(z0.shape) pairs = np.array([(a, b) for a in range(nant) for b in range(nant)]) obj = cls(z0, pairs) result = obj() diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py new file mode 100644 index 0000000..2386900 --- /dev/null +++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py @@ -0,0 +1,93 @@ +from ._cublas import _CuBLASRed, cuda_take_along_axis +from . import _cublas as _cu +import numpy as np + +class CuBLASChunkedLoop(_CuBLASRed): + def setup(self): + super().setup() + + # Now, chunk the pairs into lists of pairs, where each list has the same + # first antenna. + ants = {} + + if self.transposed: + for (a, b) in self.pairs: + if b not in ants: + ants[b] = [a] + else: + ants[b].append(a) + else: + for (a, b) in self.pairs: + if a not in ants: + ants[a] = [b] + else: + ants[a].append(b) + + # Put them on the GPU + self.ants = {k: _cu.gpuarray.to_gpu(np.sort(v).astype(np.int32)) for k, v in ants.items()} + # most_pairs = max(len(v) for v in ants.values()) + + def compute(self): + if self.transposed: + nsrc, nant = self.z.shape + + out = np.zeros(len(self.pairs), dtype=self.z.dtype) + + n = 0 + for a, b in self.ants.items(): + # Make new contiguous array for these antennas. + m = cuda_take_along_axis(self.z, b, axis=1) + print('m shape', m.shape, b.shape, b) + thisn = len(b) + print('thisn', thisn) + this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) + + self.gemv( + self.h, + "n", # conjugate transpose for first (remember fortran order) + thisn, + nsrc, + 1.0, + m.gpudata, + nsrc, + self.z[a].gpudata, + 1, + 0.0, + this.gpudata, + 1 + ) + out[n: n+thisn] = this.get() + n += thisn + + return out + + else: + nant, nsrc = self.z.shape + + out = np.zeros(len(self.pairs), dtype=self.z.dtype) + + n = 0 + for a, b in self.ants.items(): + # Make new contiguous array for these antennas. + m = cuda_take_along_axis(self.z, b) + thisn = len(b) + this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) + + self.gemv( + self.h, + "c", # conjugate transpose for first (remember fortran order) + nsrc, + thisn, + 1.0, + m.gpudata, + nsrc, + self.z[a].gpudata, + 1, + 0.0, + this.gpudata, + 1 + ) + out[n: n+thisn] = this.get() + n += thisn + + return out diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py index 1634ef2..ad91f38 100644 --- a/devel/viscalc-performance/methods/cublas_vectorloop.py +++ b/devel/viscalc-performance/methods/cublas_vectorloop.py @@ -1,13 +1,20 @@ from ._cublas import _CuBLASRed - class CuBLASVectorLoop(_CuBLASRed): def compute(self): - size = self.z.shape[1] + if self.transposed: + size = self.z.shape[0] + + for i, (a, b) in enumerate(self.pairs): + self.dotc( + self.h, size, self.z[:, b].gpudata, 1, self.z[:, a].gpudata, 1, self.out[i].gpudata + ) + else: + size = self.z.shape[1] - for i, (a, b) in enumerate(self.pairs): - self.out[i] = self.dotc( - self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1 - ) + for i, (a, b) in enumerate(self.pairs): + self.dotc( + self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1, self.out[i].gpudata + ) return self.out.get() diff --git a/devel/viscalc-performance/methods/cublas_zgemm.py b/devel/viscalc-performance/methods/cublas_zgemm.py index 03cdac6..a4029dc 100644 --- a/devel/viscalc-performance/methods/cublas_zgemm.py +++ b/devel/viscalc-performance/methods/cublas_zgemm.py @@ -1,24 +1,43 @@ -from ._cublas import CuBLAS as _CB +from ._cublas import _CuBLAS as _CB class CuBLASZgemm(_CB): def compute(self): - nant, nsrc = self.z.shape + if self.transposed: + nsrc, nant = self.z.shape + self.gemm( + self.h, + "n", # conjugate transpose for first (remember fortran order) + "c", # no transpose for second. + nant, + nant, + nsrc, + 1.0, + self.z.gpudata, + nant, + self.z.gpudata, + nant, + 0.0, + self.out.gpudata, + nant, + ) + else: + nant, nsrc = self.z.shape - self.gemm( - self.h, - "c", # conjugate transpose for first (remember fortran order) - "n", # no transpose for second. - nant, - nant, - nsrc, - 1.0, - self.z.gpudata, - nsrc, - self.z.gpudata, - nsrc, - 0.0, - self.out.gpudata, - nant, - ) + self.gemm( + self.h, + "c", # conjugate transpose for first (remember fortran order) + "n", # no transpose for second. + nant, + nant, + nsrc, + 1.0, + self.z.gpudata, + nsrc, + self.z.gpudata, + nsrc, + 0.0, + self.out.gpudata, + nant, + ) return self.out.get() diff --git a/devel/viscalc-performance/methods/cublas_zherk.py b/devel/viscalc-performance/methods/cublas_zherk.py index 022124b..cd399c3 100644 --- a/devel/viscalc-performance/methods/cublas_zherk.py +++ b/devel/viscalc-performance/methods/cublas_zherk.py @@ -1,21 +1,37 @@ -from ._cublas import CuBLAS as _CB +from ._cublas import _CuBLAS as _CB class CuBLASZherk(_CB): def compute(self): - nant, nsrc = self.z.shape + if self.transposed: + nsrc, nant = self.z.shape + self.herk( + self.h, + uplo="L", + trans="n", + n=nant, + k=nsrc, + alpha=1.0, + A=self.z.gpudata, + lda=nant, + beta=0.0, + C=self.out.gpudata, + ldc=nant, + ) + else: + nant, nsrc = self.z.shape - self.herk( - self.h, - uplo="L", - trans="c", - n=nant, - k=nsrc, - alpha=1.0, - A=self.z.gpudata, - lda=nsrc, - beta=0.0, - C=self.out.gpudata, - ldc=nant, - ) + self.herk( + self.h, + uplo="L", + trans="c", + n=nant, + k=nsrc, + alpha=1.0, + A=self.z.gpudata, + lda=nsrc, + beta=0.0, + C=self.out.gpudata, + ldc=nant, + ) return self.out.get() diff --git a/devel/viscalc-performance/methods/jax_vectorloop.py b/devel/viscalc-performance/methods/jax_vectorloop.py index 1121623..3655015 100644 --- a/devel/viscalc-performance/methods/jax_vectorloop.py +++ b/devel/viscalc-performance/methods/jax_vectorloop.py @@ -3,12 +3,17 @@ from ._jax import JAXRed as _JR +@jax.jit +def _go_at_it(z: jnp.array, out: jnp.array, pairs: jnp.array): + zc = z.conj() -class JAXVectorLoop(_JR): - def compute(self): - zc = self.z.conj() + for i, (a, b) in enumerate(pairs): + out = out.at[i].set(jnp.dot(z[a], zc[b])) + + return jax.device_get(out) - for i, (a, b) in enumerate(self.pairs): - self.out[i] = jnp.dot(self.z[a], zc[b]) - return jax.device_get(self.out) +class JAXVectorLoop(_JR): + def compute(self): + return _go_at_it(self.z, self.out, self.pairs) + \ No newline at end of file diff --git a/devel/viscalc-performance/methods/np_dot.py b/devel/viscalc-performance/methods/np_dot.py index e296825..da62003 100644 --- a/devel/viscalc-performance/methods/np_dot.py +++ b/devel/viscalc-performance/methods/np_dot.py @@ -5,4 +5,7 @@ class NpDot(Solver): def compute(self): - return np.dot(self.z, self.z.conj().T) + if self.transposed: + return np.dot(self.z.T, self.z.conj()) + else: + return np.dot(self.z, self.z.conj().T) diff --git a/devel/viscalc-performance/methods/np_zgemm.py b/devel/viscalc-performance/methods/np_zgemm.py index 35afd7a..8aa9757 100644 --- a/devel/viscalc-performance/methods/np_zgemm.py +++ b/devel/viscalc-performance/methods/np_zgemm.py @@ -2,7 +2,9 @@ from ._lib import Solver - class NpZgemm(Solver): def compute(self): - return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True) + if self.transposed: + return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_a=True) + else: + return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True) diff --git a/devel/viscalc-performance/methods/np_zherk.py b/devel/viscalc-performance/methods/np_zherk.py index bacb996..a3c3c1a 100644 --- a/devel/viscalc-performance/methods/np_zherk.py +++ b/devel/viscalc-performance/methods/np_zherk.py @@ -5,4 +5,7 @@ class NpZherk(Solver): def compute(self): - return blas.zherk(alpha=1, a=self.z) + if self.transposed: + return blas.zherk(alpha=1, a=self.z.T) + else: + return blas.zherk(alpha=1, a=self.z) diff --git a/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb index 144fee2..581e61a 100644 --- a/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb +++ b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "31f6b315", "metadata": { "ExecuteTime": { @@ -30,77 +30,17 @@ }, "outputs": [], "source": [ - "from scipy.linalg import blas\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "import time\n", - "from dataclasses import dataclass, asdict\n", - "import yaml\n", "from pathlib import Path\n", - "\n", - "try:\n", - " import pycuda.autoinit\n", - " from pycuda import cumath as cm\n", - " from pycuda import driver, gpuarray\n", - " from skcuda.cublas import (\n", - " cublasCreate,\n", - " cublasDestroy,\n", - " cublasZgemm,\n", - " cublasZherk,\n", - " cublasZdotc,\n", - " cublasCgemm,\n", - " cublasCherk,\n", - " cublasCdotc,\n", - " )\n", - " HAVE_PYCUDA = True \n", - "except:\n", - " HAVE_PYCUDA = False\n", - "\n", - "try:\n", - " import jax.numpy as jnp\n", - " HAVE_JAX = True\n", - "except ImportError:\n", - " HAVE_JAX = False\n", - "\n", - "try:\n", - " import arrayfire\n", - " HAVE_AF = True\n", - "except:\n", - " HAVE_AF = False\n", - "\n", - "try:\n", - " import numba\n", - " HAVE_NUMBA = True\n", - "except:\n", - " HAVE_NUMBA = False\n", - "\n", - "\n", - "print(\"Running Performance Tests with the following libraries:\")\n", - "print(\"pycuda/cublas: \", HAVE_PYCUDA)\n", - "print(\" jax: \", HAVE_JAX)\n", - "print(\" arrayfire: \", HAVE_AF)\n", - "print(\" numba: \", HAVE_NUMBA)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58e47f8c", - "metadata": { - "ExecuteTime": { - "end_time": "2023-03-11T23:56:53.165486Z", - "start_time": "2023-03-11T23:56:53.161005Z" - } - }, - "outputs": [], - "source": [ - "if HAVE_PYCUDA:\n", - " h = cublasCreate()" + "import methods\n", + "import yaml\n", + "from getperf import TimeResult" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "c9ca126a-64fc-4f46-b84f-20c52e1a90da", "metadata": { "tags": [ @@ -109,730 +49,239 @@ }, "outputs": [], "source": [ - "repeats: int = 1\n", - "rerun: bool = False\n", - "precision: int = 1\n", - "nants_redundant: int = 350\n", - "max_nants: int = np.inf\n", - "max_nsrcs: int = np.inf" + "cache: str = \"/ocean/projects/phy210034p/sgm/visgpu-mm-profiling/cache\"" ] }, { "cell_type": "code", - "execution_count": null, - "id": "474ceb24", + "execution_count": 6, + "id": "eb8b550d", "metadata": {}, "outputs": [], "source": [ - "if precision==1:\n", - " cublas_gemm = cublasCgemm\n", - " cublas_herk = cublasCherk\n", - " cublas_dotc = cublasCdotc\n", - " rtype = np.float32\n", - " ctype = np.complex64\n", - "else:\n", - " cublas_gemm = cublasZgemm\n", - " cublas_herk = cublasZherk\n", - " cublas_dotc = cublasZdotc\n", - " rtype = float\n", - " ctype = complex" - ] - }, - { - "cell_type": "markdown", - "id": "6d508e80-aeb0-4f03-92c2-a580f3921ed0", - "metadata": {}, - "source": [ - "## Plotting Functions" + "cache = Path(cache)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1", + "execution_count": 7, + "id": "66b2c880", "metadata": {}, "outputs": [], "source": [ - "def plot_timings(timings: dict[str, dict[tuple[int, int], \"TimeResult\"]]):\n", - " fig, ax = plt.subplots(2, max(len(nants), len(nsrcs)), figsize=(15, 8), constrained_layout=True)\n", + "def get_all_timings(cache: Path, precision: str, kind: str):\n", + " timings = sorted(cache.glob(f\"*_{precision}_{kind}.yaml\"))\n", "\n", - " for i, (nside, nsrc) in enumerate(zip(nsides, nsrcs)):\n", - " for j, (method, results) in enumerate(timings.items()):\n", - " ax[0, i].plot(nants, [results[(n, nside)].best for n in nants], color=f'C{j}', label=method)\n", - " \n", - " ax[0, i].set_title(f\"Nside={nside}\")\n", - " ax[0, i].set_xlabel(\"Nants x Nfeeds\")\n", - " ax[0, 0].set_ylabel(\"Time [sec]\")\n", - " ax[0, i].plot(nants, np.array(nants) * (results[(np.max(nants), nside)].best/np.max(nants)), ls='--', color='k')\n", - " \n", - " ax[0, i].set_xscale('log')\n", - " ax[0, i].set_yscale('log')\n", - " \n", - " for j in range(i+1, ax.shape[1]):\n", - " ax[0, j].axis('off')\n", - " \n", - " \n", - " for i, nant in enumerate(nants):\n", - " for j, (method, results) in enumerate(timings.items()):\n", - " ax[1, i].plot(nsrcs, [results[(nant, n)].best for n in nsides], color=f'C{j}')\n", + " nsides = set()\n", + " nants = set()\n", + " redfracs = set()\n", "\n", - " ax[1,i].set_title(f\"Nant x Nfeed={nant}\")\n", - " ax[1,i].set_xlabel(\"nsrc\")\n", - " ax[1, i].set_xscale('log')\n", - " ax[1, i].set_yscale('log')\n", - " ax[1, i].plot(nsrcs, np.array(nsrcs) * (results[(nant, np.max(nsides))].best/np.max(nsrcs)), ls='--', color='k')\n", - " \n", - " ax[0,0].legend(frameon=False, ncols=2)\n", - " return fig, ax" - ] - }, - { - "cell_type": "markdown", - "id": "3ae38109", - "metadata": {}, - "source": [ - "## Make Test Arrays" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "91f49fdf", - "metadata": { - "ExecuteTime": { - "end_time": "2023-03-11T23:59:25.853724Z", - "start_time": "2023-03-11T23:59:13.956196Z" - } - }, - "outputs": [], - "source": [ - "def getz(shape):\n", - " return (\n", - " np.random.random(shape) + \n", - " np.random.random(shape)*1j\n", - " ).astype(ctype)\n", - "\n", - "# Note that \"nants\" here represents Nants * Nfeed, which is why we \n", - "# go to double the number of ants that HERA has.\n", - "nants = (100, 200, 400, 700)\n", - "nants = [nant for nant in nants if nant <= max_nants]\n", + " normal = {}\n", + " redund = {}\n", "\n", - "nsides = [32, 64, 128, 256]\n", - "nsides = [nside for nside in nsides if nside <= max_nsrcs]\n", - "nsrcs = [2 * 12 * nside**2 for nside in nsides]\n", - "\n", - "z = {}\n", - "for nant in nants:\n", - " for nsrc, nside in zip(nsrcs, nsides):\n", - " z[(nant, nside)] = getz((nant, nsrc))" - ] - }, - { - "cell_type": "markdown", - "id": "89f69d4d-6dcb-4b2b-afb1-db57174b5fab", - "metadata": {}, - "source": [ - "Use the smallest array as a test" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "47990a53", - "metadata": { - "ExecuteTime": { - "end_time": "2023-03-11T23:59:26.744576Z", - "start_time": "2023-03-11T23:59:26.722326Z" - } - }, - "outputs": [], - "source": [ - "z0 = z[(nants[0], nsides[0])]\n", - "v0 = np.dot(z0, z0.conj().T)" - ] - }, - { - "cell_type": "markdown", - "id": "3011052a-34ea-4d6a-b7ec-dbb81109ebac", - "metadata": {}, - "source": [ - "## Scaffolding for methods" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "81e2e7b8-3a06-45c6-8cd6-973e56b6284f", - "metadata": {}, - "outputs": [], - "source": [ - "class Solver:\n", - " def __init__(self, z: np.ndarray):\n", - " self._z = z.copy()\n", - " \n", - " def setup(self):\n", - " self.z = self._z\n", - " \n", - " def compute(self):\n", - " pass\n", - " \n", - " def __call__(self):\n", - " self.setup()\n", - " return self.compute()\n", - " \n", - " @classmethod\n", - " def test(cls, rtol=1e-5 if precision==2 else 1e-3, atol=1e-5 if precision==2 else 1e-3):\n", - " obj = cls(z0)\n", - " result = obj()\n", - " np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol)\n", - " \n", - "class RedundantSolver:\n", - " def __init__(self, z: np.ndarray, pairs: np.ndarray):\n", - " self._z = z.copy()\n", - " self.pairs = pairs\n", + " for fl in timings:\n", + " method, size, _, _ = fl.stem.split(\"_\")\n", + " n1, nside = size.split('x')\n", " \n", - " def setup(self):\n", - " self.z = self._z\n", - " \n", - " def compute(self):\n", - " pass\n", - " \n", - " def __call__(self):\n", - " self.setup()\n", - " return self.compute()\n", - " \n", - " @classmethod\n", - " def test(cls, rtol=1e-5 if precision==2 else 1e-3, atol=1e-5 if precision==2 else 1e-3):\n", - " # All the pairs.\n", - " nant = z0.shape[0]\n", - " pairs = np.array([(a, b) for a in range(nant) for b in range(nant)])\n", - " obj = cls(z0, pairs)\n", - " result = obj()\n", - " np.testing.assert_allclose(np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e18d0954-6520-4d7a-971d-9370d4b89989", - "metadata": {}, - "outputs": [], - "source": [ - "@dataclass\n", - "class TimeResult:\n", - " times: list[float]\n", - " n: int\n", - " \n", - " @property\n", - " def best(self):\n", - " return np.min(self.times)\n", - " \n", - " @property\n", - " def mean(self):\n", - " return np.mean(self.times)\n", - " \n", - " @property\n", - " def repeats(self):\n", - " return len(self.times)\n", - " \n", - " @property\n", - " def std(self):\n", - " return np.std(self.times)\n", - " \n", - "def get_timing(sln, repeats: int = repeats) -> float:\n", - " sln.setup()\n", - " \n", - " t0 = time.time()\n", - " sln.compute()\n", - " t1 = time.time() - t0\n", - "\n", - " times = []\n", - " \n", - " if t1 > 2: # assume overhead from compilation etc. is negligible compared to 5sec\n", - " times.append(t1)\n", - " n = 1\n", - " \n", - " if repeats > len(times):\n", - " # Need to do it at least twice to check if the time comes down.\n", - " \n", - " if t1 < 2:\n", - " t0 = time.time()\n", - " sln.compute()\n", - " t2 = time.time() - t0\n", + " nside = int(nside)\n", + " nsides.add(nside)\n", + " cls = getattr(methods, method)\n", "\n", - " n = int(2 / t2) + 1\n", " \n", - " if t2 > 2:\n", - " times.append(t2)\n", - " \n", - " if n == 1:\n", - " for _ in range(max(0, repeats - len(times))):\n", - " t0 = time.time()\n", - " sln.compute()\n", - " times.append(time.time() - t0)\n", + " with open(fl, 'r') as yml:\n", + " d = yaml.safe_load(yml)\n", "\n", - " else:\n", - " for _ in range(repeats):\n", - " t0 = time.time()\n", - " for _ in range(n):\n", - " sln.compute()\n", - " times.append((time.time() - t0)/n)\n", "\n", - " return TimeResult(times, n)\n", + " if not cls.is_redundant:\n", + " nant = int(n1)\n", + " nants.add(nant)\n", + " if method not in normal:\n", + " normal[method] = {}\n", "\n", - "def get_timings(solver, repeats: int=repeats, rerun: bool = rerun) -> dict[tuple[int, int], float]:\n", - " out = {}\n", - " \n", - " # First, test the solver.\n", - " solver.test()\n", - " \n", - " for size, zz in z.items():\n", - " print(size, end=': ')\n", - " \n", - " pth = Path(f\"{solver.__name__}_{size[0]}x{size[1]}.yaml\")\n", - " if not rerun and pth.exists():\n", - " with open(pth, 'r') as fl:\n", - " o = out[size] = TimeResult(**yaml.safe_load(fl))\n", + " normal[method][(nant, nside)] = TimeResult(**d)\n", " else:\n", - " sln = solver(zz)\n", - " \n", - " o = out[size] = get_timing(sln)\n", - " del sln # Ensure memory is freed.\n", - " \n", - " print(f\"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]\")\n", - " \n", - " # Cache it\n", - " with open(pth, 'w') as fl:\n", - " yaml.dump(asdict(o), fl)\n", - " \n", - " return out\n", - "\n", - "def get_timings_red(solver, repeats: int=repeats, rerun: bool = rerun) -> dict[tuple[int, int], float]:\n", - " out = {}\n", + " redfrac = int(n1)\n", + " redfracs.add(redfrac)\n", + " if method not in redund:\n", + " redund[method] = {}\n", + " redund[method][(redfrac, nside)] = TimeResult(**d)\n", " \n", - " # First, test the solver.\n", - " solver.test()\n", - " \n", - " for redfrac, p in pairs.items():\n", - " for (nside, nsrc) in zip(nsides, nsrcs):\n", - " size = (redfrac, nside)\n", - " print(size, end=': ')\n", - " \n", - " pth = Path(f\"{solver.__name__}_{size[0]}x{size[1]}.yaml\")\n", - " if not rerun and pth.exists():\n", - " with open(pth, 'r') as fl:\n", - " o = out[size] = TimeResult(**yaml.safe_load(fl))\n", - " else:\n", - " sln = solver(z[(nants_redundant*2, nside)], p)\n", - "\n", - " o = out[size] = get_timing(sln)\n", - " del sln # Ensure memory is freed.\n", - "\n", - " print(f\"{o.mean:1.3e}s ± {o.std:1.3e}s [{o.repeats} loops of {o.n}]\")\n", - "\n", - " # Cache it\n", - " with open(pth, 'w') as fl:\n", - " yaml.dump(asdict(o), fl)\n", - " \n", - " return out" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "65f02230-958d-4d75-9abb-76c5978cb93a", - "metadata": {}, - "outputs": [], - "source": [ - "timings = {}" - ] - }, - { - "cell_type": "markdown", - "id": "a981c9bd-fa7e-4260-b4a2-4c509dd03bf9", - "metadata": {}, - "source": [ - "## Full Dot-Product Methods" - ] - }, - { - "cell_type": "markdown", - "id": "76cffc27", - "metadata": {}, - "source": [ - "### CPU" - ] - }, - { - "cell_type": "markdown", - "id": "600df1cd", - "metadata": {}, - "source": [ - "#### np.dot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b859bdb0-9d6e-486b-a247-049c25e3f2c9", - "metadata": {}, - "outputs": [], - "source": [ - "class NpDot(Solver):\n", - " def compute(self):\n", - " return np.dot(self.z, self.z.conj().T)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a75dfb83-f390-47f4-a04a-3faa27f0db24", - "metadata": {}, - "outputs": [], - "source": [ - "timings['np.dot'] = get_timings(NpDot, rerun=True)" - ] - }, - { - "cell_type": "markdown", - "id": "ece92a57", - "metadata": {}, - "source": [ - "#### zgemm" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "600b4875-b401-4a4e-8143-a7d7a3767359", - "metadata": {}, - "outputs": [], - "source": [ - "class NpZgemm(Solver):\n", - " def compute(self):\n", - " return blas.zgemm(alpha=1, a=self.z, b=self.z.conj(), trans_b=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a24fd6ff-6a74-4755-b5a8-52703452a73d", - "metadata": {}, - "outputs": [], - "source": [ - "timings['np.zgemm'] = get_timings(NpZgemm)" - ] - }, - { - "cell_type": "markdown", - "id": "160dc508", - "metadata": {}, - "source": [ - "#### zherk" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fed2f857-4570-40e3-a8b3-3b1250a73d3a", - "metadata": {}, - "outputs": [], - "source": [ - "class NpZherk(Solver):\n", - " def compute(self):\n", - " return blas.zherk(alpha=1, a=self.z)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d3e78c7d-2b07-425d-a829-d69e59fbbc2d", - "metadata": {}, - "outputs": [], - "source": [ - "timings['np.zherk'] = get_timings(NpZherk)" + " return normal, redund, sorted(nsides), sorted(nants), sorted(redfracs)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b0090363-f235-4890-a2da-181be2852031", + "execution_count": 13, + "id": "a8c7ea1b", "metadata": {}, - "outputs": [], - "source": [ - "fig, ax = plot_timings(timings)\n", - "fig.suptitle(\"CPU Timings\");" - ] - }, - { - "cell_type": "markdown", - "id": "3bc7799e", - "metadata": {}, - "source": [ - "### CuBLAS" - ] - }, - { - "cell_type": "markdown", - "id": "51b8caf5", - "metadata": {}, - "source": [ - "#### cublas.zgemm" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5ad23c8f", - "metadata": { - "ExecuteTime": { - "end_time": "2023-03-11T20:45:55.353128Z", - "start_time": "2023-03-11T20:45:55.345190Z" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full Dot Product (single row): 5\n", + "Full Dot Product (double row): 5\n", + "Full Dot Product (single col): 0\n", + "Full Dot Product (double col): 0\n", + "Redundant (single row): 3\n", + "Redundant (double row): 3\n", + "Redundant (single col): 0\n", + "Redundant (double col): 0\n" + ] } - }, - "outputs": [], + ], "source": [ - "class CuBLASZgemm(Solver):\n", - " def setup(self):\n", - " self.z = gpuarray.to_gpu(self._z)\n", - " nant = self.z.shape[0]\n", - " self.out = gpuarray.empty(shape=(nant, nant), dtype=ctype)\n", + "normal_single_row, redundant_single_row, nsides, nants, redfracs = get_all_timings(cache, 'single', 'row')\n", + "normal_double_row, redundant_double_row, _, _, _ = get_all_timings(cache, 'double', 'row')\n", + "normal_single_col, redundant_single_col, _, _, _ = get_all_timings(cache, 'single', 'col')\n", + "normal_double_col, redundant_double_col, _, _, _ = get_all_timings(cache, 'double', 'col')\n", "\n", - " def compute(self):\n", - " nant, nsrc = self.z.shape\n", + "print(\"Full Dot Product (single row): \", len(normal_single_row))\n", + "print(\"Full Dot Product (double row): \", len(normal_double_row))\n", + "print(\"Full Dot Product (single col): \", len(normal_single_col))\n", + "print(\"Full Dot Product (double col): \", len(normal_double_col))\n", "\n", - " cublas_gemm(\n", - " h,\n", - " \"c\", # conjugate transpose for first (remember fortran order)\n", - " \"n\", # no transpose for second.\n", - " nant,\n", - " nant,\n", - " nsrc,\n", - " 1.0,\n", - " self.z.gpudata,\n", - " nsrc,\n", - " self.z.gpudata,\n", - " nsrc,\n", - " 0.0,\n", - " self.out.gpudata,\n", - " nant,\n", - " )\n", - " return self.out.get()" + "print(\"Redundant (single row): \", len(redundant_single_row))\n", + "print(\"Redundant (double row): \", len(redundant_double_row))\n", + "print(\"Redundant (single col): \", len(redundant_single_col))\n", + "print(\"Redundant (double col): \", len(redundant_double_col))\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "6d949ca9-03cc-4834-9099-fd0ba78e30ed", + "execution_count": 14, + "id": "ee8f43c2", "metadata": {}, "outputs": [], "source": [ - "if HAVE_PYCUDA:\n", - " timings['cublas.zgemm'] = get_timings(CuBLASZgemm)" + "nsrcs = [2 * 12*nside**2 for nside in nsides]" ] }, { "cell_type": "markdown", - "id": "eca36052", + "id": "6d508e80-aeb0-4f03-92c2-a580f3921ed0", "metadata": {}, "source": [ - "#### cublas.zherk" + "## Plotting Functions" ] }, { "cell_type": "code", - "execution_count": null, - "id": "c5653094-e1b5-4391-baa2-b66cea7bc0de", + "execution_count": 10, + "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1", "metadata": {}, "outputs": [], "source": [ - "class CuBLASZherk(CuBLASZgemm):\n", - " def compute(self):\n", - " nant, nsrc = self.z.shape\n", + "def plot_timings(timings: dict[str, dict[tuple[int, int], \"TimeResult\"]]):\n", + " fig, ax = plt.subplots(2, max(len(nants), len(nsrcs)), figsize=(15, 8), constrained_layout=True, sharex='row', sharey='row')\n", "\n", - " cublas_herk(\n", - " h,\n", - " uplo=\"L\",\n", - " trans='c',\n", - " n=nant,\n", - " k=nsrc,\n", - " alpha=1.0,\n", - " A=self.z.gpudata,\n", - " lda=nsrc,\n", - " beta=0.0,\n", - " C=self.out.gpudata,\n", - " ldc=nant\n", - " )\n", - " return self.out.get()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4767df58-a497-4be7-8eba-7f1e421d64e5", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_PYCUDA:\n", - " timings['cublas.zherk'] = get_timings(CuBLASZherk)" - ] - }, - { - "cell_type": "markdown", - "id": "1713c876-b220-4ea0-a6f6-eba42fe1aa14", - "metadata": {}, - "source": [ - "### JAX" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "664c1c20-87da-491f-9391-6b56bdb39aae", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_JAX:\n", - " import jax\n", - " from jax import config\n", + " for i, (nside, nsrc) in enumerate(zip(nsides, nsrcs)):\n", + " for j, (method, results) in enumerate(timings.items()):\n", "\n", - " if precision==2:\n", - " config.update('jax_enable_x64',True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a21ab0e-21f4-4c83-a6c8-cb6f40bb9b11", - "metadata": {}, - "outputs": [], - "source": [ - "class JAXdot(Solver):\n", - " def setup(self):\n", - " self.z = jax.device_put(self._z)\n", + " res = [results.get((n, nside), None) for n in nants]\n", + " ax[0, i].plot(nants, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n", + "\n", + " ax[0, i].set_title(f\"Nside={nside}\")\n", + " ax[0, i].set_xlabel(\"Nants x Nfeeds\")\n", + " ax[0, 0].set_ylabel(\"Time [sec]\")\n", + "# ax[0, i].plot(nants, np.array(nants) * (results[(np.max(nants), nside)].best/np.max(nants)), ls='--', color='k')\n", + " \n", + " ax[0, i].set_xscale('log')\n", + " ax[0, i].set_yscale('log')\n", " \n", - " def compute(self): \n", - " out = jnp.dot(self.z, self.z.T.conj(), precision=jax.lax.Precision.HIGHEST)\n", - " return jax.device_get(out)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "52c8626a-4375-4b87-adc8-a01987c03237", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_JAX:\n", - " timings['jax.dot'] = get_timings(JAXdot)" - ] - }, - { - "cell_type": "markdown", - "id": "9f266948-9ca7-418f-a9a7-382defd5c8ab", - "metadata": {}, - "source": [ - "### ArrayFire" - ] - }, - { - "cell_type": "markdown", - "id": "497b60e1-0b51-4419-8918-1a48cb8be7e2", - "metadata": {}, - "source": [ - "There's something weird about how arrayfire stores arrays in memory so that you NEED to use the transpose shape for the array to make sense, but then of course if you go BACK to numpy arrays on cpu, they're the transpose of the original. I've tested passing in pre-transposed data and computing the GEMM and it takes essentially the same amount of time." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e2b39e53-89ba-446b-85f8-6f90042c0424", - "metadata": {}, - "outputs": [], - "source": [ - "class ArrayFireGemm(Solver):\n", - " def setup(self):\n", - " self.out = arrayfire.Array(dtype=self._z.dtype.char, dims=(self._z.shape[0], self._z.shape[0]))\n", - " self.z = arrayfire.from_ndarray(self._z)\n", + " for j in range(i+1, ax.shape[1]):\n", + " ax[0, j].axis('off')\n", " \n", - " def compute(self):\n", - " return arrayfire.blas.gemm(\n", - " self.z, self.z, lhs_opts=arrayfire.MATPROP.NONE, rhs_opts=arrayfire.MATPROP.CTRANS, C=self.out\n", - " )" + " \n", + " for i, nant in enumerate(nants):\n", + " for j, (method, results) in enumerate(timings.items()):\n", + " res = [results.get((nant, n), None) for n in nsides]\n", + "\n", + " ax[1, i].plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}')\n", + "\n", + " ax[1,i].set_title(f\"Nant x Nfeed={nant}\")\n", + " ax[1,i].set_xlabel(\"nsrc\")\n", + " ax[1, i].set_xscale('log')\n", + " ax[1, i].set_yscale('log')\n", + " # ax[1, i].plot(nsrcs, np.array(nsrcs) * (results[(nant, np.max(nsides))].best/np.max(nsrcs)), ls='--', color='k')\n", + " \n", + " ax[0,0].legend(frameon=False, ncols=2)\n", + " return fig, ax" ] }, { "cell_type": "code", - "execution_count": null, - "id": "3eb9f38b-0bbc-4ce0-8a14-cec38c271789", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_AF:\n", - " timings['af.gemm'] = get_timings(ArrayFireGemm)" - ] - }, - { - "cell_type": "markdown", - "id": "1d304566", - "metadata": {}, - "source": [ - "## Redundant Baseline Methods" - ] - }, - { - "cell_type": "markdown", - "id": "5407c1ff", + "execution_count": 16, + "id": "52c3f3e4", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "Say that we have different subsets of baselines that should actually be \"used\". Let's see how long different methods take there..." + "plot_timings(normal_single_row);" ] }, { "cell_type": "code", - "execution_count": null, - "id": "d45ab3dc", - "metadata": { - "ExecuteTime": { - "end_time": "2023-03-11T23:59:49.510072Z", - "start_time": "2023-03-11T23:59:49.476499Z" + "execution_count": 17, + "id": "459f718b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ - "allpairs = np.array([(0,0)] + [(a, b) for a in range(nants_redundant*2) for b in range(a+1, nants_redundant*2)])\n", - "\n", - "pairs = {}\n", - "pairfracs = [3, 10, 25, 50]\n", - "\n", - "for pc in pairfracs:\n", - " pairs[pc] = allpairs[np.sort(np.random.choice(np.arange(len(allpairs)), size=int(len(allpairs)*pc/100), replace=False))]" + "plot_timings(normal_double_row);" ] }, { "cell_type": "code", - "execution_count": null, - "id": "2df81e33-8c05-443b-bd40-133d5d3e35f9", + "execution_count": 18, + "id": "3db2308c", "metadata": {}, "outputs": [], "source": [ "def plot_timings_reds(red_timings: dict[str, dict[tuple[int, int], TimeResult]], \n", " timings: dict[str, dict[tuple[int, int], TimeResult]]):\n", " fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n", - " \n", + "\n", + " nants_redundant = np.max(nants)\n", + "\n", " for j, (method, results) in enumerate(timings.items()):\n", - " ax.plot(nsrcs, [results[(nants_redundant*2, n)].best for n in nsides], color=f'C{j}', label=method)\n", + " res = [results.get((nants_redundant, n), None) for n in nsides]\n", + " ax.plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n", " \n", " for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n", - " for k, frac in enumerate(pairfracs):\n", + " for k, frac in enumerate(redfracs):\n", + " res = [results.get((frac, n), None) for n in nsides]\n", " ax.plot(\n", - " nsrcs, [results[(frac, n)].best for n in nsides], \n", - " color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5))][k], \n", + " nsrcs, [r.best if r is not None else np.nan for r in res], \n", + " color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5)), (0, (3, 1, 1, 1, 1, 1))][k], \n", " label=f\"{method} ({frac}% red.)\"\n", " )\n", " \n", - " ax.set_title(f\"Nant x Nfeed={nant}\")\n", + " ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n", " ax.set_xlabel(\"nsrc\")\n", " ax.set_xscale('log')\n", " ax.set_yscale('log')\n", @@ -844,309 +293,98 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "76b2a1d1-10a7-4c52-b020-f790dfddfed4", - "metadata": {}, - "outputs": [], - "source": [ - "timings_reds = {}" - ] - }, - { - "cell_type": "markdown", - "id": "353c44f6-9836-4a62-989a-40bc8a0ac473", + "execution_count": 19, + "id": "3f3e5f7d", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "### Custom Kernel" + "plot_timings_reds(redundant_single_row, normal_single_row);" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b47cfbc4-ca67-41bd-ba88-1f610c235db6", + "execution_count": 20, + "id": "a52739ce", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "multiply_and_sum_kernel = \"\"\"\n", - "// CUDA code for computing V_ij = Z_i Z_j^*\n", - "\n", - "// ========== Template Parameters =========\n", - "// This code is actually a Jinja template, which can use the following parameters. They\n", - "// appear in double curly braces, eg. {{ DTYPE }}. They get substituted before compilation.\n", - "//\n", - "// DTYPE : float or double\n", - "// CDTYPE : cuFloatComplex or cuDoubleComplex\n", - "// BLOCK_PX : # of sky pixels handled by one GPU block, used to size shared memory\n", - "// NANT : # of antennas to pair into visibilities\n", - "// NPIX : # of sky pixels to sum over.\n", - "// NAX : # of E-field axes in the beam\n", - "// NFEED : # of feeds in the beam\n", - "// -------------------------------------------------------------------------------------\n", - "\n", - "#include \n", - "#include \n", - "#include \n", - "\n", - "__global__ void MultiplyAndSum(\n", - " {{ CDTYPE }} *Z,\n", - " int *ant1_array,\n", - " int *ant2_array,\n", - " uint nsrc,\n", - " {{ CDTYPE }} *v\n", - "){\n", - " const uint nax = {{ NAX }};\n", - " const uint nfeed= {{ NFEED }};\n", - " const uint nant = {{ NANT }};\n", - " const uint nbl = {{ NBL }};\n", - " \n", - " // Z should have shape (NFEED x NANT x NSRC x NAX)\n", - " // with NFEED = NAX = 2,\n", - " // NANT ~300\n", - " // NSRC ~5e6.\n", - " // Output V is (NFEED x NFEED x NBL) and is gotten by taking FEED and ANT1 and ANT2, \n", - " // multiplying Z[FEED, ANT1] * Z[FEED, ANT2].conj() then summing over all SRC and AX. \n", - " // ANT1 and ANT2 are length NBL, where NBL < NANT*(NANT + 1) / 2. \n", - " \n", - " // We expect a GPU to have ~2048 threads available (eg. the V100). In this naive implementation,\n", - " // each thread will correspond to a FEED/BL. This will mean that it will have about the same\n", - " // speed as NBL grows, up to 2048, then it will halve in speed, etc.\n", - " \n", - " const uint bl = blockIdx.x * blockDim.x + threadIdx.x; \n", - " const uint feed1 = blockIdx.y * blockDim.y + threadIdx.y; // goes up to 2\n", - " const uint feed2 = blockIdx.z * blockDim.z + threadIdx.z; // goes up to 2\n", - " \n", - " // later, think of some work these guys could do.\n", - " if (bl >= nbl || feed1 >= nfeed || feed2 >= nfeed) return;\n", - "\n", - " uint ant1 = ant1_array[bl];\n", - " uint ant2 = ant2_array[bl];\n", - "\n", - " {{ CDTYPE }} temp = make_{{ CDTYPE }}(0, 0);\n", - " \n", - " for (int i = 0; i < nsrc*nax; i += 1){\n", - " int idx1 = i + ant1*nsrc*nax + feed1*nsrc*nax*nant;\n", - " int idx2 = i + ant2*nsrc*nax + feed2*nsrc*nax*nant;\n", - " \n", - " temp = cuCadd(temp, cuCmul(Z[idx1], cuConj(Z[idx2])));\n", - " }\n", - " \n", - " v[bl*nfeed*nfeed + feed1*nfeed + feed2] = temp;\n", - " \n", - " __syncthreads(); // make sure everyone used mem before kicking out\n", - "}\n", - "\"\"\"" + "plot_timings_reds(redundant_double_row, normal_double_row);" ] }, { "cell_type": "code", "execution_count": null, - "id": "5de673ca-b70c-4dcd-8eec-fedf556ac1e9", + "id": "3bd95843", "metadata": {}, "outputs": [], "source": [ - "# if HAVE_PYCUDA:\n", - "# from jinja2 import Template\n", - "# from pycuda import compiler\n", - "\n", - "# VisProduct = Template(multiply_and_sum_kernel)\n", - "\n", - "# cuda_params = {\n", - "# \"NANT\": 50,\n", - "# \"NAX\": 1,\n", - "# \"NFEED\": 1,\n", - "# \"NBEAM\": 1,\n", - "# \"DTYPE\": \"double\",\n", - "# \"CDTYPE\": \"cuDoubleComplex\",\n", - "# \"NBL\": 2500,\n", - "# # \"f\": \"f\" if precision == 1 else \"\",\n", - "# }\n", - "\n", - "# vis_product = VisProduct.render(**cuda_params)\n", - "# vis_product_module = compiler.SourceModule(vis_product)\n", - "# mult_and_sum = vis_product_module.get_function(\"MultiplyAndSum\")\n", - "\n", - " # ant1 = gpuarray.to_gpu(np.tile(np.arange(50), 50))\n", - " # ant2 = gpuarray.to_gpu(np.repeat(np.arange(50), 50))\n", + "def plot_comparison(\n", + " t1: dict[str, dict[tuple[int, int], TimeResult]], \n", + " t2: dict[str, dict[tuple[int, int], TimeResult]],\n", + " nant: int\n", + "):\n", + " fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n", "\n", - " # out = gpuarray.empty(2500, dtype=np.complex128)\n", - " # zz = gpuarray.to_gpu(z0)\n", + " nants_redundant = np.max(nants)\n", "\n", - " # mult_and_sum(\n", - " # zz.gpudata,\n", - " # ant1.gpudata,\n", - " # ant2.gpudata,\n", - " # np.uint(10000),\n", - " # out.gpudata,\n", - " # block=(512, 1, 1),\n", - " # grid=(20, 1, 1)\n", - " # )\n", + " # def get_res(t, method):\n", + " # res = [t[method].get((nants_redundant, n), None) for n in nsides]\n", + " # return np.array([r.best if r is not None else np.nan for r in res])\n", "\n", - " # np.max(np.abs(out.get().reshape((50,50))-v0))" - ] - }, - { - "cell_type": "markdown", - "id": "c4564350-a052-45ab-ad5a-aa34855e11a9", - "metadata": {}, - "source": [ - "### Dumb Loop CuBLAS" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1c0bb3a2-1956-4b31-86bd-5a63061c391f", - "metadata": {}, - "outputs": [], - "source": [ - "class SingleLoopCuBLAS(RedundantSolver):\n", - " def setup(self):\n", - " self.z = gpuarray.to_gpu(self._z)\n", - " self.out = gpuarray.empty(self.pairs.shape[0], dtype=ctype)\n", + " # for j, method in enumerate(t1):\n", + " # r1 = get_res(t1, method)\n", + " # r2 = get_res(t2, method)\n", " \n", - " def compute(self): \n", - " size = self.z.shape[1]\n", + " # ax.plot(nsrcs, r1 / r2, color=f'C{j}', label=method)\n", "\n", - " for i, (a, b) in enumerate(self.pairs):\n", - " self.out[i] = cublas_dotc(h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1)\n", + " def get_res_redt, method):\n", + " res = [t[method].get((nants_redundant, n), None) for n in nsides]\n", + " return np.array([r.best if r is not None else np.nan for r in res])\n", "\n", - " return self.out.get()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "80b93732-b374-4db9-b933-a77eda975ad7", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_PYCUDA:\n", - " timings_reds['cublas.singleloop'] = get_timings_red(SingleLoopCuBLAS)" - ] - }, - { - "cell_type": "markdown", - "id": "7659d02d-78f5-43bf-92d8-9847e8950d89", - "metadata": {}, - "source": [ - "### Dumb Loop njit" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4108942c-7fcd-400d-abd3-878e688a3ed8", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_NUMBA:\n", - " @numba.njit\n", - " def _dumbloopjit(z, pairs, out):\n", - " zc = z.conj()\n", - " for i, (a, b) in enumerate(pairs):\n", - " out[i] = np.dot(z[a], zc[b])\n", - "\n", - " class SingleLoopNumba(RedundantSolver):\n", - " def setup(self):\n", - " self.out = np.empty(len(self.pairs), dtype=ctype)\n", - " \n", - " def compute(self):\n", - " _dumbloopjit(self.z, self.pairs, self.out)\n", - " return self.out\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c8a4ba4f-d586-4a63-ae90-7e8bc3f82925", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_NUMBA:\n", - " timings_reds['numba.singleloop'] = get_timings_red(SingleLoopNumba)" - ] - }, - { - "cell_type": "markdown", - "id": "b98ffb9e-d159-43f0-8b0b-9a3933217f7c", - "metadata": {}, - "source": [ - "### Chunked Loop (JAX)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "50447a2d-7b7d-4d61-8c1e-c593765849ef", - "metadata": {}, - "outputs": [], - "source": [ - "class ChunkedLoopJAX(RedundantSolver):\n", - " chunksize = 350\n", - " \n", - " def setup(self):\n", - " self.z = jax.device_put(self.z)\n", - " self.ant1 = jax.device_put(self.pairs[:, 0])\n", - " self.ant2 = jax.device_put(self.pairs[:, 1])\n", - " self.out = jnp.empty(len(self.ant1), dtype=ctype)\n", + " for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n", + " for k, frac in enumerate(redfracs):\n", + " res = [results.get((frac, n), None) for n in nsides]\n", + " ax.plot(\n", + " nsrcs, [r.best if r is not None else np.nan for r in res], \n", + " color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5)), (0, (3, 1, 1, 1, 1, 1))][k], \n", + " label=f\"{method} ({frac}% red.)\"\n", + " )\n", " \n", - " def compute(self):\n", - " nchunks = len(self.ant1) // self.chunksize\n", - "\n", - " def doslc(slc):\n", - " s1 = self.z[self.ant1[slc]]\n", - " s2 = self.z[self.ant2[slc]]\n", - " s1 *= s2.conj()\n", - " sm = jnp.sum(s1, axis=1)\n", - " self.out = self.out.at[slc].set(sm)\n", - "\n", - " for chunk in range(nchunks):\n", - " slc = slice(chunk*self.chunksize, (chunk+1)*self.chunksize)\n", - " doslc(slc)\n", - "\n", - " if len(self.ant1) % self.chunksize:\n", - " slc = slice((chunk+1)*self.chunksize, None)\n", - " doslc(slc)\n", + " ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n", + " ax.set_xlabel(\"nsrc\")\n", + " ax.set_xscale('log')\n", + " ax.set_yscale('log')\n", + " #ax.plot(nsrcs, np.array(nsrcs) * (results[(350, np.max(nsrcs))].best/np.max(nsrcs)), ls='--', color='k')\n", "\n", - " return jax.device_get(self.out)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e86bfe3c-e4f3-4abd-b23d-b3be5a4c517f", - "metadata": {}, - "outputs": [], - "source": [ - "if HAVE_JAX:\n", - " timings_reds['jax.chunkedloop'] = get_timings_red(ChunkedLoopJAX)" - ] - }, - { - "cell_type": "markdown", - "id": "b0386649-67b2-42fa-b78f-c609985e4351", - "metadata": {}, - "source": [ - "### Redundant Plot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "80bf6e17-b7aa-4d14-b180-632be242b676", - "metadata": {}, - "outputs": [], - "source": [ - "plot_timings_reds(timings_reds, timings);" + " ax.legend(frameon=False, ncols=3)\n", + " return fig, ax" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "433cdfe8-581a-4706-a605-dbe735f05803", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From db9b7c05e57a8844f9a646dadcccf382e61ea8f8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 6 Oct 2023 08:40:26 +0000 Subject: [PATCH 11/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- devel/viscalc-performance/getperf.py | 16 ++-- devel/viscalc-performance/methods/__init__.py | 21 ++--- devel/viscalc-performance/methods/_cublas.py | 90 +++++++++++-------- devel/viscalc-performance/methods/_jax.py | 4 +- devel/viscalc-performance/methods/_lib.py | 8 +- .../methods/cublas_chunkedloop.py | 32 ++++--- .../methods/cublas_vectorloop.py | 17 +++- .../methods/jax_vectorloop.py | 2 +- devel/viscalc-performance/methods/np_zgemm.py | 1 + 9 files changed, 111 insertions(+), 80 deletions(-) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 1ca68ed..5a0a853 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -94,7 +94,7 @@ def get_timings( transpose: bool = False, ) -> dict[tuple[int, int], float]: out = {} - cache=Path(cache) + cache = Path(cache) # First, test the solver. test_solver(solver, nants[0], nsrcs[0], ctype) @@ -116,7 +116,7 @@ def get_timings( print((label_outer, nside), end=": ") prec = "double" if ctype is complex else "single" - trns = 'col' if transpose else 'row' + trns = "col" if transpose else "row" pth = cache / f"{solver.__name__}_{label_outer}x{nside}_{prec}_{trns}.yaml" if not rerun and pth.exists(): with open(pth) as fl: @@ -138,10 +138,12 @@ def get_timings( def getz(shape, ctype, transpose=False): if transpose: - return (np.random.random(shape[::-1]) + np.random.random(shape[::-1]) * 1j).astype(ctype) + return ( + np.random.random(shape[::-1]) + np.random.random(shape[::-1]) * 1j + ).astype(ctype) else: return (np.random.random(shape) + np.random.random(shape) * 1j).astype(ctype) - + def get_sizes( max_nants: int, @@ -157,6 +159,7 @@ def get_sizes( return nants, nsides, nsrcs + def get_solver(solver): mdl = importlib.import_module(f"methods.{solver}") @@ -174,6 +177,7 @@ def get_solver(solver): return solver + @click.command @click.argument("solver", type=str, required=True) @click.option("--max-nants", type=int, default=350) @@ -197,7 +201,7 @@ def main( repeats: int, rerun: bool, cache, - transpose: bool + transpose: bool, ): """Get the performance metric of a particular solver.""" @@ -252,7 +256,7 @@ def main( ctype=complex if double else np.complex64, nants_redundant=redundant_nants * 2, pairs=pairs, - transpose=transpose + transpose=transpose, ) diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index be6ce9c..d24eff5 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -1,17 +1,12 @@ +from .arrayfire_gemm import ArrayFireGemm +from .cublas_chunkedloop import CuBLASChunkedLoop +from .cublas_vectorloop import CuBLASVectorLoop +from .cublas_zgemm import CuBLASZgemm +from .cublas_zherk import CuBLASZherk +from .jax_chunkedloop import JAXChunkedLoop +from .jax_dot import JAXDot +from .jax_vectorloop import JAXVectorLoop from .np_dot import NpDot from .np_zgemm import NpZgemm from .np_zherk import NpZherk - from .numba_vectorloop import SingleLoopNumba - -from .jax_chunkedloop import JAXChunkedLoop -from .jax_vectorloop import JAXVectorLoop -from .jax_dot import JAXDot - -from .cublas_zgemm import CuBLASZgemm -from .cublas_zherk import CuBLASZherk -from .cublas_vectorloop import CuBLASVectorLoop -from .cublas_chunkedloop import CuBLASChunkedLoop - -from .arrayfire_gemm import ArrayFireGemm - diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index ae9942f..6022e61 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -1,29 +1,30 @@ -from ._lib import RedundantSolver, Solver import ctypes import numpy as np -from functools import cache -from jinja2 import Template import os import warnings +from functools import cache +from jinja2 import Template + +from ._lib import RedundantSolver, Solver try: with warnings.catch_warnings(): warnings.simplefilter("ignore") - + import pycuda.autoinit + from pycuda import compiler from pycuda import cumath as cm - - from pycuda import driver, gpuarray, compiler + from pycuda import driver, gpuarray from skcuda.cublas import ( + _libcublas, cublasCgemm, + cublasCgemv, cublasCherk, cublasCreate, cublasDestroy, cublasZgemm, - cublasZherk, cublasZgemv, - cublasCgemv, - _libcublas, + cublasZherk, cuda, ) @@ -31,16 +32,13 @@ except: HAVE_PYCUDA = False + def cublasZdotc_inplace(handle, n, x, incx, y, incy, result): - _libcublas.cublasZdotc_v2( - handle, n, int(x), incx, int(y), incy, int(result) - ) + _libcublas.cublasZdotc_v2(handle, n, int(x), incx, int(y), incy, int(result)) + def cublasCdotc_inplace(handle, n, x, incx, y, incy, result): - _libcublas.cublasCdotc_v2( - handle, n, int(x), incx, int(y), incy, - int(result) - ) + _libcublas.cublasCdotc_v2(handle, n, int(x), incx, int(y), incy, int(result)) class _CuBLASCommon: @@ -48,7 +46,7 @@ def setup(self): self.z = gpuarray.to_gpu(self._z) self.h = cublasCreate() - if self._z.dtype.name == 'complex128': + if self._z.dtype.name == "complex128": self.gemm = cublasZgemm self.herk = cublasZherk self.dotc = cublasZdotc_inplace @@ -59,6 +57,7 @@ def setup(self): self.dotc = cublasCdotc_inplace self.gemv = cublasCgemv + class _CuBLAS(_CuBLASCommon, Solver): def setup(self): super().setup() @@ -90,14 +89,14 @@ def setup(self): int k, {{ TYPE }} *out_matrix ){ - const uint i = blockIdx.x * blockDim.x + threadIdx.x; + const uint i = blockIdx.x * blockDim.x + threadIdx.x; const uint j = blockIdx.y * blockDim.y + threadIdx.y; - + const uint outel = j*n + i; - + // exit if we're out of scope if (j >= k || i >= n) return; - + int idx = indices[j]; out_matrix[outel] = in_matrix[idx*n+i]; } @@ -111,13 +110,13 @@ def setup(self): int k, {{ TYPE }} *out_matrix ){ - const uint i = blockIdx.x * blockDim.x + threadIdx.x; + const uint i = blockIdx.x * blockDim.x + threadIdx.x; const uint j = blockIdx.y * blockDim.y + threadIdx.y; - - + + // exit if we're out of scope if (i >= k || j >= m) return; - + int idx = indices[i]; const uint outel = j*k + i; @@ -126,30 +125,36 @@ def setup(self): """ if HAVE_PYCUDA: + def compile_take(dtype): take_along_axis_template = Template(take_along_axis_kernel_code) take_along_axis_code = take_along_axis_template.render(TYPE=dtype) return ( - compiler.SourceModule(take_along_axis_code).get_function(f"TakeAlongFirstAxis2D"), - compiler.SourceModule(take_along_axis_code).get_function(f"TakeAlongSecondAxis2D"), + compiler.SourceModule(take_along_axis_code).get_function( + f"TakeAlongFirstAxis2D" + ), + compiler.SourceModule(take_along_axis_code).get_function( + f"TakeAlongSecondAxis2D" + ), ) - - take_along_first_axis_z, take_along_second_axis_z = compile_take('cuDoubleComplex') - take_along_first_axis_c, take_along_second_axis_c = compile_take('cuFloatComplex') + take_along_first_axis_z, take_along_second_axis_z = compile_take("cuDoubleComplex") + take_along_first_axis_c, take_along_second_axis_c = compile_take("cuFloatComplex") @cache - def _cudatake_blocksize(n: int,k: int): + def _cudatake_blocksize(n: int, k: int): nthreads_max = 1024 - threadsx = min(nthreads_max, n) + threadsx = min(nthreads_max, n) threadsy = min(k, nthreads_max // threadsx) block = (threadsx, threadsy, 1) grid = (int(np.ceil(n / threadsx)), int(np.ceil(k / threadsy)), 1) return block, grid - def cuda_take_along_axis(x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0) -> gpuarray.GPUArray: + def cuda_take_along_axis( + x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0 + ) -> gpuarray.GPUArray: m, n = x.shape - if axis==0: + if axis == 0: out = gpuarray.empty((idx.shape[0], n), dtype=x.dtype) else: out = gpuarray.empty((m, idx.shape[0]), dtype=x.dtype) @@ -158,10 +163,18 @@ def cuda_take_along_axis(x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0) - idx = idx.astype(np.int32) block, grid = _cudatake_blocksize(n, idx.shape[0]) - if axis==0: - fnc = take_along_first_axis_z if x.dtype.name == 'complex128' else take_along_first_axis_c + if axis == 0: + fnc = ( + take_along_first_axis_z + if x.dtype.name == "complex128" + else take_along_first_axis_c + ) else: - fnc = take_along_second_axis_z if x.dtype.name == 'complex128' else take_along_second_axis_c + fnc = ( + take_along_second_axis_z + if x.dtype.name == "complex128" + else take_along_second_axis_c + ) fnc( x.gpudata, @@ -174,5 +187,6 @@ def cuda_take_along_axis(x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0) - grid=grid, ) return out + else: - cuda_take_along_axis = None \ No newline at end of file + cuda_take_along_axis = None diff --git a/devel/viscalc-performance/methods/_jax.py b/devel/viscalc-performance/methods/_jax.py index 1a21e07..639e000 100644 --- a/devel/viscalc-performance/methods/_jax.py +++ b/devel/viscalc-performance/methods/_jax.py @@ -12,7 +12,7 @@ class JAXSolver(Solver): def setup(self): - if self._z.dtype.name == 'complex128': + if self._z.dtype.name == "complex128": config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) @@ -20,7 +20,7 @@ def setup(self): class JAXRed(RedundantSolver): def setup(self): - if self._z.dtype.name == 'complex128': + if self._z.dtype.name == "complex128": config.update("jax_enable_x64", True) self.z = jax.device_put(self._z) diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py index fc815c4..f6750dd 100644 --- a/devel/viscalc-performance/methods/_lib.py +++ b/devel/viscalc-performance/methods/_lib.py @@ -31,9 +31,9 @@ def __call__(self) -> np.ndarray: @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: - rtol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 + rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 if atol is None: - atol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 + atol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 obj = cls(z0) result = obj() @@ -55,9 +55,9 @@ def __init__(self, z: np.ndarray, pairs: np.ndarray): @classmethod def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): if rtol is None: - rtol = 1e-5 if z0.dtype.name=='complex128' else 1e-3 + rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 if atol is None: - atol = 1e-5 if z0.dtype.name == 'complex128' else 1e-3 + atol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 # All the pairs. nant = min(z0.shape) diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py index 2386900..24e1bc2 100644 --- a/devel/viscalc-performance/methods/cublas_chunkedloop.py +++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py @@ -1,30 +1,34 @@ -from ._cublas import _CuBLASRed, cuda_take_along_axis -from . import _cublas as _cu import numpy as np +from . import _cublas as _cu +from ._cublas import _CuBLASRed, cuda_take_along_axis + + class CuBLASChunkedLoop(_CuBLASRed): def setup(self): super().setup() - + # Now, chunk the pairs into lists of pairs, where each list has the same # first antenna. ants = {} if self.transposed: - for (a, b) in self.pairs: + for a, b in self.pairs: if b not in ants: ants[b] = [a] else: ants[b].append(a) else: - for (a, b) in self.pairs: + for a, b in self.pairs: if a not in ants: ants[a] = [b] else: ants[a].append(b) # Put them on the GPU - self.ants = {k: _cu.gpuarray.to_gpu(np.sort(v).astype(np.int32)) for k, v in ants.items()} + self.ants = { + k: _cu.gpuarray.to_gpu(np.sort(v).astype(np.int32)) for k, v in ants.items() + } # most_pairs = max(len(v) for v in ants.values()) def compute(self): @@ -37,9 +41,9 @@ def compute(self): for a, b in self.ants.items(): # Make new contiguous array for these antennas. m = cuda_take_along_axis(self.z, b, axis=1) - print('m shape', m.shape, b.shape, b) + print("m shape", m.shape, b.shape, b) thisn = len(b) - print('thisn', thisn) + print("thisn", thisn) this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) self.gemv( @@ -54,11 +58,11 @@ def compute(self): 1, 0.0, this.gpudata, - 1 + 1, ) - out[n: n+thisn] = this.get() + out[n : n + thisn] = this.get() n += thisn - + return out else: @@ -85,9 +89,9 @@ def compute(self): 1, 0.0, this.gpudata, - 1 + 1, ) - out[n: n+thisn] = this.get() + out[n : n + thisn] = this.get() n += thisn - + return out diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py index ad91f38..68788ee 100644 --- a/devel/viscalc-performance/methods/cublas_vectorloop.py +++ b/devel/viscalc-performance/methods/cublas_vectorloop.py @@ -1,5 +1,6 @@ from ._cublas import _CuBLASRed + class CuBLASVectorLoop(_CuBLASRed): def compute(self): if self.transposed: @@ -7,14 +8,26 @@ def compute(self): for i, (a, b) in enumerate(self.pairs): self.dotc( - self.h, size, self.z[:, b].gpudata, 1, self.z[:, a].gpudata, 1, self.out[i].gpudata + self.h, + size, + self.z[:, b].gpudata, + 1, + self.z[:, a].gpudata, + 1, + self.out[i].gpudata, ) else: size = self.z.shape[1] for i, (a, b) in enumerate(self.pairs): self.dotc( - self.h, size, self.z[b].gpudata, 1, self.z[a].gpudata, 1, self.out[i].gpudata + self.h, + size, + self.z[b].gpudata, + 1, + self.z[a].gpudata, + 1, + self.out[i].gpudata, ) return self.out.get() diff --git a/devel/viscalc-performance/methods/jax_vectorloop.py b/devel/viscalc-performance/methods/jax_vectorloop.py index 3655015..456db3c 100644 --- a/devel/viscalc-performance/methods/jax_vectorloop.py +++ b/devel/viscalc-performance/methods/jax_vectorloop.py @@ -3,6 +3,7 @@ from ._jax import JAXRed as _JR + @jax.jit def _go_at_it(z: jnp.array, out: jnp.array, pairs: jnp.array): zc = z.conj() @@ -16,4 +17,3 @@ def _go_at_it(z: jnp.array, out: jnp.array, pairs: jnp.array): class JAXVectorLoop(_JR): def compute(self): return _go_at_it(self.z, self.out, self.pairs) - \ No newline at end of file diff --git a/devel/viscalc-performance/methods/np_zgemm.py b/devel/viscalc-performance/methods/np_zgemm.py index 8aa9757..b9f0740 100644 --- a/devel/viscalc-performance/methods/np_zgemm.py +++ b/devel/viscalc-performance/methods/np_zgemm.py @@ -2,6 +2,7 @@ from ._lib import Solver + class NpZgemm(Solver): def compute(self): if self.transposed: From 3583a574c9604f4b30666c7f4374672e9728421b Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Fri, 6 Oct 2023 12:25:50 +0200 Subject: [PATCH 12/16] fix: cublas_chunkedloop method --- devel/viscalc-performance/methods/_cublas.py | 32 ++++++++++------ .../methods/cublas_chunkedloop.py | 38 ++++++++----------- 2 files changed, 37 insertions(+), 33 deletions(-) diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index 6022e61..03c5ddd 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -29,15 +29,17 @@ ) HAVE_PYCUDA = True -except: +except Exception: HAVE_PYCUDA = False def cublasZdotc_inplace(handle, n, x, incx, y, incy, result): + """In-place Zdotc that doesn't transfer data to the host.""" _libcublas.cublasZdotc_v2(handle, n, int(x), incx, int(y), incy, int(result)) def cublasCdotc_inplace(handle, n, x, incx, y, incy, result): + """In-place Cdotc that doesn't transfer data to the host.""" _libcublas.cublasCdotc_v2(handle, n, int(x), incx, int(y), incy, int(result)) @@ -126,33 +128,41 @@ def setup(self): if HAVE_PYCUDA: - def compile_take(dtype): + def _compile_take(dtype): take_along_axis_template = Template(take_along_axis_kernel_code) take_along_axis_code = take_along_axis_template.render(TYPE=dtype) return ( compiler.SourceModule(take_along_axis_code).get_function( - f"TakeAlongFirstAxis2D" + "TakeAlongFirstAxis2D" ), compiler.SourceModule(take_along_axis_code).get_function( - f"TakeAlongSecondAxis2D" + "TakeAlongSecondAxis2D" ), ) - take_along_first_axis_z, take_along_second_axis_z = compile_take("cuDoubleComplex") - take_along_first_axis_c, take_along_second_axis_c = compile_take("cuFloatComplex") + take_along_first_axis_z, take_along_second_axis_z = _compile_take("cuDoubleComplex") + take_along_first_axis_c, take_along_second_axis_c = _compile_take("cuFloatComplex") @cache - def _cudatake_blocksize(n: int, k: int): + def _cudatake_blocksize(m: int, n: int, k: int, axis=0): nthreads_max = 1024 - threadsx = min(nthreads_max, n) - threadsy = min(k, nthreads_max // threadsx) + if axis == 0: + threadsx = min(nthreads_max, n) + threadsy = min(k, nthreads_max // threadsx) + grid = (int(np.ceil(n / threadsx)), int(np.ceil(k / threadsy)), 1) + + else: + threadsx = min(nthreads_max, k) + threadsy = min(m, nthreads_max // threadsx) + grid = (int(np.ceil(k / threadsx)), int(np.ceil(m / threadsy)), 1) + block = (threadsx, threadsy, 1) - grid = (int(np.ceil(n / threadsx)), int(np.ceil(k / threadsy)), 1) return block, grid def cuda_take_along_axis( x: gpuarray.GPUArray, idx: gpuarray.GPUArray, axis=0 ) -> gpuarray.GPUArray: + """Create a new GPUArray by taking indices along a given axis.""" m, n = x.shape if axis == 0: out = gpuarray.empty((idx.shape[0], n), dtype=x.dtype) @@ -162,7 +172,7 @@ def cuda_take_along_axis( if idx.dtype.name == "int64": idx = idx.astype(np.int32) - block, grid = _cudatake_blocksize(n, idx.shape[0]) + block, grid = _cudatake_blocksize(m, n, idx.shape[0], axis=axis) if axis == 0: fnc = ( take_along_first_axis_z diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py index 24e1bc2..8e037ec 100644 --- a/devel/viscalc-performance/methods/cublas_chunkedloop.py +++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py @@ -1,3 +1,4 @@ +"""Chunked-loop implementation in CuBLAS.""" import numpy as np from . import _cublas as _cu @@ -5,25 +6,21 @@ class CuBLASChunkedLoop(_CuBLASRed): + """Chunked-loop implementation in CuBLAS.""" + def setup(self): + """Set it up.""" super().setup() # Now, chunk the pairs into lists of pairs, where each list has the same # first antenna. ants = {} - if self.transposed: - for a, b in self.pairs: - if b not in ants: - ants[b] = [a] - else: - ants[b].append(a) - else: - for a, b in self.pairs: - if a not in ants: - ants[a] = [b] - else: - ants[a].append(b) + for a, b in self.pairs: + if a not in ants: + ants[a] = [b] + else: + ants[a].append(b) # Put them on the GPU self.ants = { @@ -32,18 +29,18 @@ def setup(self): # most_pairs = max(len(v) for v in ants.values()) def compute(self): + """Compute it.""" if self.transposed: nsrc, nant = self.z.shape out = np.zeros(len(self.pairs), dtype=self.z.dtype) + zc = self.z.conj() n = 0 for a, b in self.ants.items(): # Make new contiguous array for these antennas. - m = cuda_take_along_axis(self.z, b, axis=1) - print("m shape", m.shape, b.shape, b) + m = cuda_take_along_axis(zc, b, axis=1) thisn = len(b) - print("thisn", thisn) this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) self.gemv( @@ -53,18 +50,15 @@ def compute(self): nsrc, 1.0, m.gpudata, - nsrc, - self.z[a].gpudata, - 1, + thisn, + self.z[:, a].gpudata, + thisn, 0.0, this.gpudata, 1, ) out[n : n + thisn] = this.get() n += thisn - - return out - else: nant, nsrc = self.z.shape @@ -94,4 +88,4 @@ def compute(self): out[n : n + thisn] = this.get() n += thisn - return out + return out From 9c20f1f02ffdf1f568155c5774fab4fa9bd9650c Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Mon, 23 Oct 2023 11:37:29 -0400 Subject: [PATCH 13/16] update getperg --- devel/viscalc-performance/getperf.py | 63 ++- devel/viscalc-performance/methods/__init__.py | 8 +- devel/viscalc-performance/methods/_cublas.py | 1 + .../methods/cublas_chunkedloop.py | 21 +- ...rformance_test_large_matrix_multiply.ipynb | 362 ++++++++++++++---- 5 files changed, 362 insertions(+), 93 deletions(-) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 5a0a853..0c80661 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -10,7 +10,6 @@ from methods._lib import RedundantSolver, Solver from pathlib import Path - @dataclass class TimeResult: times: list[float] @@ -178,7 +177,9 @@ def get_solver(solver): return solver -@click.command +cli = click.Group() + +@cli.command() @click.argument("solver", type=str, required=True) @click.option("--max-nants", type=int, default=350) @click.option("--n-nants", type=int, default=4) @@ -259,6 +260,62 @@ def main( transpose=transpose, ) +def get_redundancies(bls, ndecimals: int=2): + uvbins = set() + pairs = [] + + # Everything here is in wavelengths + bls = np.round(bls, decimals=ndecimals) + nant = bls.shape[0] + + # group redundant baselines + for i in range(nant): + for j in range(i + 1, nant): + u, v = bls[i, j] + if (u, v) not in uvbins and (-u, -v) not in uvbins: + uvbins.add((u, v)) + pairs.append([i,j]) + + return pairs + +@cli.command() +@click.argument("solver", type=str, required=True) +@click.option("--double/--single", default=True) +@click.option("--transpose/--no-transpose", default=False) +@click.option("--outriggers/--core", default=False) +@click.option("--nside", type=int, default=256) +@click.option("--ax-moves-first/--ant-moves-first", default=True) +def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): + from py21cmsense.antpos import hera + + antpos = hera(hex_num=11, split_core=True, outriggers=2 if outriggers else 0) + bls = antpos[np.newaxis, :, :2] - antpos[:, np.newaxis, :2] + pairs = np.array(get_redundancies(bls.value)) + + # We also need the pairs for the pol axis + if ax_moves_first: + pairs *= 2 + pairs = np.array([[p, p + 1] for p in pairs]).reshape((2*len(pairs), 2)) + else: + pairs = np.concatenate((pairs, pairs + len(pairs)), axis=0) + + solver = get_solver(solver) + + ctype = complex if double else np.complex64 + test_solver(solver, 50, 1000, ctype) + + nant = len(antpos) + nsrc = 12*nside**2 + + # now run the actual computation + z = getz((2*nant, 2*nsrc), transpose=transpose, ctype=ctype) + + if solver.is_redundant: + sln = solver(z, pairs=pairs) + else: + sln = solver(z) + + sln() if __name__ == "__main__": - main() + cli() diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index d24eff5..b1634d1 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -1,11 +1,11 @@ -from .arrayfire_gemm import ArrayFireGemm +# from .arrayfire_gemm import ArrayFireGemm from .cublas_chunkedloop import CuBLASChunkedLoop from .cublas_vectorloop import CuBLASVectorLoop from .cublas_zgemm import CuBLASZgemm from .cublas_zherk import CuBLASZherk -from .jax_chunkedloop import JAXChunkedLoop -from .jax_dot import JAXDot -from .jax_vectorloop import JAXVectorLoop +# from .jax_chunkedloop import JAXChunkedLoop +# from .jax_dot import JAXDot +# from .jax_vectorloop import JAXVectorLoop from .np_dot import NpDot from .np_zgemm import NpZgemm from .np_zherk import NpZherk diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index 03c5ddd..03f5a88 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -173,6 +173,7 @@ def cuda_take_along_axis( idx = idx.astype(np.int32) block, grid = _cudatake_blocksize(m, n, idx.shape[0], axis=axis) + print(m, n, idx.shape[0], block, grid) if axis == 0: fnc = ( take_along_first_axis_z diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py index 8e037ec..16f816f 100644 --- a/devel/viscalc-performance/methods/cublas_chunkedloop.py +++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py @@ -26,23 +26,23 @@ def setup(self): self.ants = { k: _cu.gpuarray.to_gpu(np.sort(v).astype(np.int32)) for k, v in ants.items() } - # most_pairs = max(len(v) for v in ants.values()) + most_pairs = max(len(v) for v in ants.values()) + self.out_chunk = _cu.gpuarray.empty((most_pairs,), dtype=self.z.dtype) def compute(self): """Compute it.""" + out = np.zeros(len(self.pairs), dtype=self.z.dtype) + n = 0 + if self.transposed: nsrc, nant = self.z.shape - - out = np.zeros(len(self.pairs), dtype=self.z.dtype) zc = self.z.conj() - n = 0 for a, b in self.ants.items(): # Make new contiguous array for these antennas. m = cuda_take_along_axis(zc, b, axis=1) thisn = len(b) - this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) - + self.gemv( self.h, "n", # conjugate transpose for first (remember fortran order) @@ -54,10 +54,10 @@ def compute(self): self.z[:, a].gpudata, thisn, 0.0, - this.gpudata, + self.out_chunk.gpudata, 1, ) - out[n : n + thisn] = this.get() + out[n : n + thisn] = self.out_chunk[:thisn].get() n += thisn else: nant, nsrc = self.z.shape @@ -69,7 +69,6 @@ def compute(self): # Make new contiguous array for these antennas. m = cuda_take_along_axis(self.z, b) thisn = len(b) - this = _cu.gpuarray.empty((thisn,), dtype=self.z.dtype) self.gemv( self.h, @@ -82,10 +81,10 @@ def compute(self): self.z[a].gpudata, 1, 0.0, - this.gpudata, + self.out_chunk.gpudata, 1, ) - out[n : n + thisn] = this.get() + out[n : n + thisn] = self.out_chunk[:thisn].get() n += thisn return out diff --git a/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb index 581e61a..c0c8c68 100644 --- a/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb +++ b/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "31f6b315", "metadata": { "ExecuteTime": { @@ -33,9 +33,39 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from pathlib import Path\n", - "import methods\n", + "#import methods\n", "import yaml\n", - "from getperf import TimeResult" + "#from getperf import TimeResult\n", + "from dataclasses import dataclass" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bb4a2e45", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclass\n", + "class TimeResult:\n", + " times: list[float]\n", + " n: int\n", + "\n", + " @property\n", + " def best(self):\n", + " return np.min(self.times)\n", + "\n", + " @property\n", + " def mean(self):\n", + " return np.mean(self.times)\n", + "\n", + " @property\n", + " def repeats(self):\n", + " return len(self.times)\n", + "\n", + " @property\n", + " def std(self):\n", + " return np.std(self.times)\n" ] }, { @@ -64,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "id": "66b2c880", "metadata": {}, "outputs": [], @@ -79,20 +109,23 @@ " normal = {}\n", " redund = {}\n", "\n", + " normal['redundant'] = False\n", + " redund['redundant'] = True\n", + "\n", " for fl in timings:\n", " method, size, _, _ = fl.stem.split(\"_\")\n", " n1, nside = size.split('x')\n", " \n", " nside = int(nside)\n", " nsides.add(nside)\n", - " cls = getattr(methods, method)\n", - "\n", + " #cls = getattr(methods, method)\n", + " is_redundant = (int(size.split('x')[0]) in (3, 10, 25, 50, 100))\n", " \n", " with open(fl, 'r') as yml:\n", " d = yaml.safe_load(yml)\n", "\n", "\n", - " if not cls.is_redundant:\n", + " if not is_redundant:\n", " nant = int(n1)\n", " nants.add(nant)\n", " if method not in normal:\n", @@ -111,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "a8c7ea1b", "metadata": {}, "outputs": [ @@ -119,14 +152,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Full Dot Product (single row): 5\n", - "Full Dot Product (double row): 5\n", - "Full Dot Product (single col): 0\n", - "Full Dot Product (double col): 0\n", - "Redundant (single row): 3\n", - "Redundant (double row): 3\n", - "Redundant (single col): 0\n", - "Redundant (double col): 0\n" + "Full Dot Product (single row): 6\n", + "Full Dot Product (double row): 6\n", + "Full Dot Product (single col): 6\n", + "Full Dot Product (double col): 6\n", + "Redundant (single row): 4\n", + "Redundant (double row): 4\n", + "Redundant (single col): 4\n", + "Redundant (double col): 4\n" ] } ], @@ -149,7 +182,28 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, + "id": "6cb07ac8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['redundant', 'CuBLASZgemm', 'CuBLASZherk', 'NpDot', 'NpZgemm', 'NpZherk'])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "normal_single_row.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "id": "ee8f43c2", "metadata": {}, "outputs": [], @@ -167,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 21, "id": "e1459e2b-6f80-435f-b7d6-ab415f7743f1", "metadata": {}, "outputs": [], @@ -177,7 +231,8 @@ "\n", " for i, (nside, nsrc) in enumerate(zip(nsides, nsrcs)):\n", " for j, (method, results) in enumerate(timings.items()):\n", - "\n", + " if method == 'redundant':\n", + " continue\n", " res = [results.get((n, nside), None) for n in nants]\n", " ax[0, i].plot(nants, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n", "\n", @@ -195,6 +250,8 @@ " \n", " for i, nant in enumerate(nants):\n", " for j, (method, results) in enumerate(timings.items()):\n", + " if method=='redundant':\n", + " continue\n", " res = [results.get((nant, n), None) for n in nsides]\n", "\n", " ax[1, i].plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}')\n", @@ -211,13 +268,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "id": "52c3f3e4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -234,30 +291,7 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "459f718b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_timings(normal_double_row);" - ] - }, - { - "cell_type": "code", - "execution_count": 18, + "execution_count": 25, "id": "3db2308c", "metadata": {}, "outputs": [], @@ -269,10 +303,14 @@ " nants_redundant = np.max(nants)\n", "\n", " for j, (method, results) in enumerate(timings.items()):\n", + " if method=='redundant':\n", + " continue\n", " res = [results.get((nants_redundant, n), None) for n in nsides]\n", " ax.plot(nsrcs, [r.best if r is not None else np.nan for r in res], color=f'C{j}', label=method)\n", " \n", " for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n", + " if method=='redundant':\n", + " continue\n", " for k, frac in enumerate(redfracs):\n", " res = [results.get((frac, n), None) for n in nsides]\n", " ax.plot(\n", @@ -293,13 +331,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 26, "id": "3f3e5f7d", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABEAAAAJICAYAAABhfJEYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd1gVx97A8e8eQKQoaFBUlCICIu1QRRHFghp7F8UWrhox1hhLYjRq8FpuEktioknsUeBq7NHotUUlRgFFVCIoBis2rFQp+/6B7AvCAQv2+TwPj57Z3dnZZWc5O/ubGUmWZQRBEARBEARBEARBEN5mqlddAEEQBEEQBEEQBEEQhBdNNIAIgiAIgiAIgiAIgvDWEw0ggiAIgiAIgiAIgiC89UQDiCAIgiAIgiAIgiAIbz3RACIIgiAIgiAIgiAIwltPNIAIgiAIgiAIgiAIgvDWEw0ggiAIgiC8MSRJCpEk6ZYkSdfKOV9LSZJkSZK0yzNfQRAEQRBeH6IBRBAEQRDeUpIkJUmSdEOSJINCaYMlSdpfjvm3Kqe8/B41QHz/WPohSZIGPfq/OTAOaCDLco3y2O/zkiTptCRJqYV+ciRJ2lpouVqSpGhJktIf/asutEySJGmOJEkpj37mSJIkvZIDEQRBEIR3gGgAEQRBEIS3mxYw+lUX4gmlAf0lSbLUsNwcSJFl+cbLK1LpZFl2kGXZUJZlQ6AScAlYByBJUgVgM/ALUAVYCWx+lA4wFOgCuADOQEfgw5d6AIIgCILwDhENIIIgCILwdvsP8IkkScYlLZQkaYEkSZckSbr/KELBt9CyaZIk/VeSpFWSJD14FO3g8WjZavIbJLY+inyYUELeEyVJOlLQrUSSpOBHeVTUUNa7wArgixLyagX8D6j1aH8rHqV7S5L0pyRJdyVJOiFJkl+hbYwkSVoqSVKyJElXHnWf0Xq0TEuSpK8edac5D7Qv9Sw+maaACfDro89+gDYwX5blLFmWFwIS0OLR8oHA17IsX5Zl+QrwNTCoHMohCIIgCEIJRAOIIAiCILzdooD9wCcalkcCaqAqsBZY91gDRScgDDAGtgDfAciy3B+4CHR8FAExt4S8/wNkAZ9LkmQD/BvoJ8tyZinlnQl0lyTJrnCiLMu7gfeBq4/2N0iSJDPgNyDkUfk/AX6VJKnao81WADlAPcAVaA0MfrRsCNDhUboH0KPw/iRJ+v5Ro0pJP7Eayj4Q+FWW5bRHnx2AWFmW5ULrxD5KL1h+otCyE4WWCYIgCIJQzkQDiCAIgiC8/aYCIws1DChkWf5FluUUWZZzZFn+GtAFCjc+HJJlebssy7nAavK7azwRWZbzgAHAKPIbT+bKsny8jG2uAYuBGU+wi37A9kfly5Nl+X/kN/i0kyTJFGgHjJFlOe1Rt5l5QMCjbXuRH5lxSZbl28Csx8oxXJZlYw0/zo8XRJIkffIbUVYUSjYE7j226j3yu8qUtPweYCjGAREEQRCEF0OMdC4IgiAIbzlZlk9JkrQNmAT8XXiZJEmfAP8CagEyUJn8bhwFCs+2kg5UlCRJW5blnCfcd5IkSfvIb4xY9IRFngMkSpJUVmOLBdBTkqSOhdJ0gH2PlukAyYXaE1Tkj9EB+cd7qdB2F56wbJp0A24DfxRKSyX/fBZWGXigYXllIPWxiBFBEARBEMqJiAARBEEQhHfDF+R3+zArSHg03scE8qMhqsiybEx+FMKTRiCU+aAuSVJ7oBGwh/wuMWVnKsspwHzgyzJWvQSsfiw6w0CW5dmPlmUBJoWWVZZluaCLSTJQp1Be5o+Ve/Fjs7sU/jldQlkGAqsea7w4DTg/FtHh/Ci9YHnhRh6XQssEQRAEQShnogFEEARBEN4BsiyfA8LJ745SoBL5Y2TcBLQlSZpK8YiF0lwH6mpaKEmSCfAz+eNuDAQ6SpLU7gnz/gZoDNiXss4vj/Js82hQ04qPptOtLctyMrAL+FqSpMqSJKkkSbKWJKnZo23/C4ySJKm2JElVyI+OUciyPKxgdpcSfoqM0yFJUm2gOfmzvBS2H8h9tB9dSZJGPErf++jfVcDHkiSZSZJUi/wpflc84fkRBEEQBOEpiQYQQRAEQXh3zAAMCn3eCfwOJJDfBSSTot1CyjKL/AFO7z7qSvO4H4HNj8boSCG/q83PkiS9V1bGsizfB+aSP7ippnUuAZ2Bz8hvxLkEjOf/v98MACoAccAdYD1Q89Gyn8g//hPAMWBDWWUqRX/gsCzLiY+V7yH509wOIH+GmyCgy6N0gCXAVuAkcIr8AV2XPEc5BEEQBEEohSS6mQqCIAiCIAiCIAiC8LYTESCCIAiCIAiCIAiCILz1RAOIIAiCIAiCIAiCIAhvPdEAIgiCIAiCIAiCIAjCW080gAiCIAiCIAiCIAiC8NYTDSCCIAiCIAiCIAiCILz1tF91AUpjYmIiW1pavupiCIIgCIIgCIIgCILwBoiOjr4ly3K1kpa91g0glpaWREVFvepiCIIgCIIgCIIgCILwBpAk6YKmZaILjCAIgiAIgiAIgiAIbz3RACIIgiAIgiAIgiAIwltPNIAIgiAIgiAIgiAIgvDWEw0ggiAIgiAIgiAIgiC89UQDiCAIgiAIgiAIgiAIbz3RACIIgiAIgiAIgiAIwltPNIAIgiAIgiAIgiAIgvDWEw0gz+DatWsEBARgbW2Nu7s77dq1IyEhQeP6fn5+2NnZoVarsbe358cff1SWWVpacuvWrRK3mz9/PhUrVuTevXtKWnp6OoGBgTg5OeHo6EiTJk1ITU1l48aNqNXqIj8qlYodO3aU34ELQjl62noEL6culVa2/fv306FDh3I4ekhKSsLR0fGZtzc0NCyXfJ7Wpk2bmDFjBgDffPMNDRo0wNnZmZYtW3Lhwv9Pua6lpaXcizp16qSkBwYG4uzszGeffaakhYSEsGnTpnItp5+fH1FRUcXSP/nkE/bu3Vuu+3odva71q3nz5uzcubPY9sHBwU91fDExMWzfvv2ptgHKtQ4/ifnz57Nq1SoA1q1bh4ODAyqVqti1OWvWLOrVq4ednV2R8/P7779jZ2dHvXr1mD17tpIu6pEgCIIgPCNZll/bH3d3d/l1k5eXJ3t7e8s//PCDkhYTEyMfOHBA4zbNmjWTIyMjZVmW5ZSUFNnY2FjOysqSZVmWLSws5Js3b5a4nZeXl9ykSRN52bJlStq///1veezYscrnM2fOyJmZmcW2XbJkidy0aVM5Nzf36Q5QEF6CZ6lHsvxy6lJpZdu3b5/cvn37pz/gEvzzzz+yg4PDM29vYGBQLvk8rUaNGinnee/evXJaWposy7L8/fffy7169SpWvsJOnDgh/+tf/5JlWZZbtWol3717V7569arcoUOHJ9p3dnb2E5ez8LVSWFJSkuzv7//E+byJXuf6tWTJEnnQoEFFtm/YsKH8xx9/PNUxLl++XP7oo4+eapvs7OxyrcNPsj8nJyfluo2Li5PPnDlT7No8ffq07OzsLGdmZsrnz5+X69atK+fk5Mg5OTly3bp15cTERDkrK0t2dnaWT58+LeqRIAiCIJQBiJI1tDGICJCntG/fPnR0dBg2bJiS5uLiQm5ubpG3SiNGjGDFihXFtk9NTcXAwAAtLa1S95OYmEhqaiohISGEhoYq6cnJyZiZmSmf7ezs0NXVLbJtQkICM2bMYPXq1ahUKvLy8hg+fDj169fH39+fdu3asX79egCio6Np1qwZ7u7utGnThuTkZCD/rc/YsWPx8PDA3t6eyMhIunXrho2NDZ9//jmQ/+a5fv36DBo0CFtbWwIDA9m9ezc+Pj7Y2Nhw9OjRJzyrwrtGUz3y9fUt9ob2Zdel0spWsN8ePXpQv359AgMDyb/HFn1DHhUVhZ+fHwDTpk0jKCgIPz8/6taty8KFC4uV8fz587i6uhIZGUliYiJt27bF3d0dX19fzpw5A8A///xDo0aNcHJyUupgafbs2YOrqytOTk4EBQWRlZVVarqlpSUTJkzAyckJLy8vzp07VyzPhIQEdHV1MTExAaB58+bo6+sD4O3tzeXLl0stk46ODhkZGeTl5ZGdnY2WlhZTp05l+vTpGrdZsWIFnTp1okWLFrRs2ZK0tDSCgoLw8vLC1dWVzZs3A5CRkUFAQAD29vZ07dqVjIyMEvOzsLAgJSWFa9eulXEG31yvc/3q0aMHv/32Gw8fPgTy/45cvXoVX19fdu3aRaNGjXBzc6Nnz55KRFZkZCSNGzfGxcUFLy8v7t27x9SpUwkPD0etVhMeHs7t27fp0qULzs7OeHt7ExsbC+TXv/79++Pj40P//v01HkdoaKgSrTJx4sQy0w0NDRk7diwODg60bNmSmzdvFstz7969uLm5oa2tDYC9vT12dnbF1tu8eTMBAQHo6upiZWVFvXr1OHr0KEePHqVevXrUrVuXChUqEBAQwObNm0U9EgRBEITnoP2qC/A8pm89TdzV++WaZ4Nalfmio4PG5adOncLd3f2p8w0MDERXV5ezZ88yf/78Mr9UhoWFERAQgK+vL/Hx8Vy/fh1TU1OCgoJo3bo169evp2XLlgwcOBAbGxtlu+zsbPr27cvXX3+Nubk5ABs2bCApKYm4uDhu3LiBvb09QUFBZGdnM3LkSDZv3ky1atUIDw9n8uTJLFu2DIAKFSoQFRXFggUL6Ny5M9HR0VStWhVra2vGjh0LwLlz51i3bh3Lli3D09OTtWvXcujQIbZs2cK///3vcg/HFV6M8OmTylynrpsXnh27Kes7NGuFo18r0u/fY+u8WUXW7f3F7JKyUDxrPYIXX5fKKtvx48c5ffo0tWrVwsfHh4iICJo0aVJqGc6cOcO+fft48OABdnZ2RcL94+PjCQgIYMWKFbi4uNCyZUsWL16MjY0NR44cYfjw4ezdu5fRo0cTHBzMgAEDWLRoUan7y8zMZNCgQezZswdbW1sGDBjADz/8wLBhw0pMHzNmDABGRkacPHmSVatWMWbMGLZt21Yk34iICNzc3Erc59KlS3n//feLlMHDwwNtbW0mTZpEly5dsLe3p1q1ari5udG/f3/OnTtHXl6exjwLHDt2jNjYWKpWrcpnn31GixYtWLZsGXfv3sXLy4tWrVqxZMkS9PX1+fvvv4mNjS01Tzc3NyIiIujevXup+y0vN5bEFvls4G6KgYcpN5bEavx/WeuX5nWuX1WrVsXLy4sdO3bQuXNnwsLC6NWrFykpKYSEhLB7924MDAyYM2cO33zzDZMmTaJ3796Eh4fj6enJ/fv30dfXZ8aMGURFRfHdd98BMHLkSFxdXdm0aRN79+5lwIABxMTEABAXF8ehQ4fQ09Nj//79xY7h6tWrTJw4kejoaKpUqULr1q3ZtGkTXl5eJaZ36dKFtLQ0PDw8mDdvHjNmzGD69OlKWQpEREQ80e/hypUreHt7K59r167NlStXAKhTp06R9CNHjryz9UgQBEEQyoOIAHlJ1qxZQ2xsLBcvXuSrr74q0le+JKGhoQQEBKBSqejevTvr1q0DQK1Wc/78ecaPH8/t27fx9PTk77//VrabMmUKDg4O9O7dW0k7dOgQPXv2RKVSUaNGDZo3bw7kP3idOnUKf39/1Go1ISEhRd7gFvTbd3JywsHBgZo1a6Krq0vdunW5dOkSAFZWVjg5OaFSqZQ3YZIk4eTkRFJSUrmcO0Eo7GXVJU28vLyoXbs2KpUKtVr9RNd5+/btlciJ6tWrc/36dQBu3rxJ586dWbNmDS4uLqSmpvLnn3/Ss2dP1Go1H374oRKVFRERQZ8+fQBKfZMN+XXbysoKW1tbAAYOHMiBAwc0phcoyL9Pnz4cPny4WL7JyclUq1atWPovv/xCVFQU48ePV9IuXLhAVFQUa9euZcyYMSQmJgL5YyLExMQwbtw4pkyZwpdffsnMmTPp1asXP/30U4nH4+/vT9WqVQHYtWsXs2fPRq1W4+fnR2ZmJhcvXuTAgQP069cPAGdnZ5ydnTWen+rVq3P16lXNJ/Ad9jLqV58+fQgLCwPyG1D69OnDX3/9RVxcHD4+PqjValauXMmFCxeIj4+nZs2aeHp6AlC5cmUloqKwQ4cOKfWiRYsWpKSkcP9+/guSTp06oaenp/EYIiMj8fPzo1q1amhraxMYGMiBAwc0pgOoVCrl72y/fv04dOhQsXw11ZfyIOqRIAiCIDybNzoCpLRIjRfFwcFB6T5SmLa2Nnl5ecrnzMzMErcveGtz5MgRLCwsSlzn5MmTnD17Fn9/fwAePnyIlZUVI0aMAPJDb7t160a3bt1QqVRs374de3t79u/fz6+//sqxY8ee6FhkWcbBwaHEBx1A6VqjUqmKdLNRqVTk5OQUWefx9QqvI7z+yorYKG19/cpGT729pnoEr74uqdVqjWWDote8lpaWcp0XLvfjZda0jZGREebm5hw6dIgGDRqQl5eHsbGx8ub6cZIkaSxXeSicf0n70tPTKzLQJcDu3buZOXMmf/zxR5HjLOj+ULduXfz8/Dh+/DjW1tbK8s2bN+Pu7k5qaiqJiYn897//pU2bNgQGBirdagoYGBgo/5dlmV9//bXErgRPKjMzs9QH4vJW/cOSHyILp2v6/5Pk87jXuX7Z29vTuXNnxo4dy7Fjx0hPT8fd3Z2tW7fi7+9fpBtNwT6eV+Hr50XRVF80nd/CzMzMlJcKAJcvX1bqj6b0Au9SPRIEQRCE8iAiQJ5SixYtyMrKKjI6fmxsLLIsExcXR1ZWFnfv3mXPnj0lbp+enl7sQeBxoaGhTJs2jaSkJKV/9NWrV7lw4QIRERHcuXMHyP+yGRcXh4WFBXfu3OGDDz5g1apVVKpUqUh+Pj4+/Prrr+Tl5XH9+nUlBNjOzo6bN28qDSDZ2dmcPn36eU6PIDwRTfXo4MGDWFhYvNK6VFrZSmNpaUl0dDQAv/766xOdhwoVKrBx40ZWrVrF2rVrqVy5MlZWVspbdFmWOXHiBJBfjwvemq9Zs6bUfO3s7EhKSlLG8Vi9ejXNmjXTmF4gPDxc+bdRo0bF8rW3ty8yNsjx48f58MMP2bJlC9WrV1fS79y5o4wtcuvWLSIiImjQoIGyPDs7m/nz5zNhwgQyMjKUh8fc3FxlbAhN2rRpw7fffquMvXL8+HEAmjZtytq1a4H8LiAFY0CUJCEh4aXOnPOyvc71C/IbRpo3b05QUJASdeTt7U1ERIRyfaWlpZGQkICdnR3JyclERkYC8ODBA3JycqhUqRIPHjxQyuLr66vUi/3792NiYkLlypWf6Hx5eXnxxx9/cOvWLXJzcwkNDaVZs2Ya0wHy8vKURqa1a9eW2A3u8fqiSadOnQgLCyMrK4t//vmHs2fP4uXlhaenJ2fPnuWff/7h4cOHhIWFFZlRSdQjQRAEQXh6r2UEiCRJHYGO9erVe9VFKUaSJDZu3MiYMWOYM2cOFStWxNLSkvnz59OrVy8cHR2xsrLC1dW1yHaBgYHo6emRlZXFoEGDivQLdnZ2RqXKb4vq1asXmzZtKja9X9euXQkLC6NmzZoEBwcjyzJ5eXm0b9+e7t27M3v2bG7cuFFsKsFPP/2Unj17smfPHho0aECdOnVwc3PDyMiIChUqsH79ekaNGsW9e/fIyclhzJgxODi8/Mga4d1SWj2qU6fOK61LpZWtoF9+Sb744gv+9a9/MWXKFGUA1CdhYGDAtm3b8Pf3x9DQkDVr1hAcHExISAjZ2dkEBATg4uLCggUL6Nu3L3PmzKFz585F8oiPj6d27drK53nz5rF8+XJ69uxJTk4Onp6eDBs2DF1d3RLTC9y5cwdnZ2d0dXWLvYmH/IejcePGIcsykiQxfvx4UlNT6dmzJwDm5uZs2bKFv//+mw8//FAZhHnSpElFGkAWLVrEwIED0dfXx9nZmfT0dJycnGjXrh3Gxsalnq8pU6YwZswYnJ2dycvLw8rKim3bthEcHMwHH3yAvb099vb2Ra6LwYMHM2zYMDw8PMjOzubcuXN4eHg88e/oTfM6168Cffr0UdaF/IiTFStW0KdPH6XxLCQkBFtbW8LDwxk5ciQZGRno6emxe/dumjdvrnTh+PTTT5XBhp2dndHX12flypUaz8+ePXuK1Jd169Yxe/ZsmjdvjizLtG/fXqljmtINDAw4evQoISEhVK9eXWk8LOz9998v0l1t48aNjBw5kps3b9K+fXvUajU7d+7EwcGBXr160aBBA7S1tVm0aJEy9sp3331HmzZtyM3NJSgoqMjfZ1GPBEEQBOHpSQWt/68jDw8PuaT554Wnl5qaiqGhISkpKXh5eREREUGNGjVedbEEQXhNWFpaEhUVpczwosno0aPp2LEjrVq1ekklK18bN27k2LFjfPnll6+6KMIbzNDQUJmlpjRdu3Zl7ty5RQYrfxuIeiQIgiC8ziRJipZlucRW+tcyAkQofx06dODu3bs8fPiQKVOmiMYPQRCeyWeffcaRI0dedTGeWU5ODuPGjXvVxRDeEbNnzyY5OfmtawAR9UgQBEF4U4kIEEEQBEEQBEEQBEEQ3gqlRYCIQVAFQRAEQRAEQRAEQXjriQYQQRAEQRAEQRAEQRDeeqIBRBAEQRAEQRAEQRCEt55oABEEQRAEQRAEQRAE4a0nGkCewbVr1wgICMDa2hp3d3fatWtHQkKCxvX9/Pyws7NDrVZjb2/Pjz/+qCyztLTk1q1bJW43f/58KlasyL1795S09PR0AgMDcXJywtHRkSZNmpCamsrGjRtRq9VFflQqFTt27GD//v106NDhuY550KBBrF+//rnyEITCnrYewcupS6WVrTzqUoGkpCQcHR2feXtDQ8Nyyedpbdq0iRkzZgCwYsUKqlWrptxzfv75Z2W9lStXYmNjg42NDStXrgQgKyuLtm3b4ujoyPfff6+sO3ToUI4dO1au5dR0PQQEBHD27Nly3dfraObMmTg4OODs7IxarVZm7hk8eDBxcXHPlOeTXGsv+nqcNm0a+vr63LhxQ0krqAvPqzzKPn/+fFatWgXAlClTlPPfunVrrl69CsCvv/6Kg4MDvr6+pKSkAJCYmEjv3r2f7wAes2LFCkaMGFEs/eTJkwwaNKhc9yUIgiC8/jIyMjh//jyHDh3iv//97zv7bCcaQJ6SLMt07doVPz8/EhMTiY6OZtasWVy/fr3U7dasWUNMTAwRERFMnDiRhw8flrmv0NBQPD092bBhg5K2YMECTE1NOXnyJKdOnWLp0qXo6OjQtWtXYmJilJ/hw4fj6+tLmzZtnvuYc3JynjsPQSjsWesRvPi69DxlexfMnTuX4cOHK5979+6t3HcGDx4MwO3bt5k+fTpHjhzh6NGjTJ8+nTt37rBz506aNGlCbGwsq1evBuDEiRPk5ubi5uZW5r7L414UHBzM3Llznzuf19nhw4fZtm0bx44dIzY2lt27d1OnTh0Afv75Zxo0aPCKS/h8TExM+Prrr191MYrJyclh2bJl9O3bF4Dx48cTGxtLTEwMHTp0UBoOv/32WyIjI/nwww9Zu3YtAJ9//jkhISFPtJ/c3NznKqeTkxOXL1/m4sWLz5WPIAiC8GbZsWMHq1atYvfu3SQnJ6Ojo/Oqi/RKiAaQp7Rv3z50dHQYNmyYkubi4kJubm6RN8MjRoxgxYoVxbZPTU3FwMAALS2tUveTmJhIamoqISEhhIaGKunJycmYmZkpn+3s7NDV1S2ybUJCAjNmzGD16tWoVCplvz169KB+/foEBgZSMP1xdHQ0zZo1w93dnTZt2pCcnAzkv2kfM2YMHh4eLFiwoEj+U6ZMYdCgQc/9JUx4d2mqR76+vsWiLF52XSqtbAX7LakuFY44iIqKws/PD8h/Yx0UFISfnx9169Zl4cKFxcp4/vx5XF1diYyMJDExkbZt2+Lu7o6vry9nzpwB4J9//qFRo0Y4OTnx+eefl3rMAHv27MHV1RUnJyeCgoLIysoqNd3S0pIJEybg5OSEl5cX586dK5ZnQkICurq6mJiYlLrvnTt34u/vT9WqValSpQr+/v78/vvv6OjokJ6eTnZ2tnLepkyZwpdffqkxr2nTptG/f398fHzo378/N2/epHv37nh6euLp6UlERAQAKSkptG7dGgcHBwYPHoymKd59fX3ZvXv3W92wm5ycjImJifK3wcTEhFq1agH59/aC6eUNDQ2ZPHkyLi4ueHt7K418iYmJeHt7K9daSREWubm5jB8/Hk9PT5ydnVmyZEmpZSrP6zEoKIjw8HBu375dZB+PR3B89dVXTJs2TTnusWPH4uHhgb29PZGRkXTr1g0bG5si9SknJ4fAwEDs7e3p0aMH6enpAMyYMQNPT08cHR0ZOnRoidfX3r17cXNzQ1tbG4DKlSsry9LS0pAkCQCVSkVWVhbp6eno6Ohw8OBBatSogY2NjcbzZ2hoyLhx43BxceHw4cP88ssveHl5oVar+fDDD5W/x8uXL8fW1hYvLy+lbpSkY8eOhIWFaVwuCIIgvFlSUlKIjIzU+P0HoGHDhvTv358JEyYwevRoOnfu/BJL+Pp4sxtAdkyC5e3L92fHpFJ3eerUKdzd3Z+6qIGBgTg7O2NnZ8eUKVPKfGgLCwsjICAAX19f4uPjlS+mQUFBzJkzh0aNGvH5558XC+XOzs6mb9++fP3115ibmyvpx48fZ/78+cTFxXH+/HkiIiLIzs5m5MiRrF+/nujoaIKCgpg8ebKyzcOHD4mKimLcuHFK2vjx47l58ybLly8v8xiEN0f49ElFfk7t313m+mWtU5pnrUfw4utSWWUrqS6V5cyZM+zcuVOJhsjOzlaWxcfH0717d1asWIGnpydDhw7l22+/JTo6mq+++kqJthg9ejTBwcGcPHmSmjVrlrq/zMxMBg0aRHh4OCdPniQnJ4cffvhBY3oBIyMjTp48yYgRIxgzZkyxfCMiIopFavz66684OzvTo0cPLl26BMCVK1eUiAOA2rVrc+XKFfz9/UlKSsLb25tRo0axZcsW3NzclIdzTeLi4ti9ezehoaGMHj2asWPHEhkZya+//qpEnUyfPp0mTZpw+vRpunbtqvHttkqlol69epw4caLUfZan5cuXc/z4cSC/4WD58uXK/h8+fMjy5cs5deoUkP+7W758udJNJS0tjeXLlxMfHw/AgwcPytxf69atuXTpEra2tgwfPpw//vijxPXS0tLw9vbmxIkTNG3alJ9++gnIv9ZGjx7NyZMnqV27donbLl26FCMjIyIjI4mMjOSnn37in3/+KXHd8r4eDQ0NCQoKKtY4X5YKFSoQFRXFsGHD6Ny5M4sWLeLUqVOsWLFC6YoSHx/P8OHD+fvvv6lcubLSVWvEiBFERkZy6tQpMjIy2LZtW7H8IyIiit07Jk+eTJ06dVizZo0SAfLpp5/SqlUrtm7dSp8+ffjyyy+ZMmVKqWVPS0ujYcOGnDhxgvfee4/w8HAiIiKIiYlBS0uLNWvWkJyczBdffEFERASHDh0qtauTh4cHBw8efKrzJwiCILy+EhMT+e2334p0936cmZkZ1tbW6Ovrv8SSvX7e7AaQN8iaNWuIjY3l4sWLfPXVV1y4cKHU9UNDQwkICEClUtG9e3fWrVsHgFqt5vz584wfP57bt2/j6enJ33//rWw3ZcoUHBwcivUl9vLyonbt2qhUKtRqNUlJScTHx3Pq1Cn8/f1Rq9WEhIRw+fJlZZvH8/jyyy+5d+8eixcvVt5kCcLL9rLqkiYl1aWytG/fXomcqF69utIIc/PmTTp37syaNWtwcXEhNTWVP//8k549eypvdguisiIiIujTpw8A/fv3L3V/8fHxWFlZYWtrC8DAgQM5cOCAxvQCBfn36dOHw4cPF8s3OTmZatWqKZ87duxIUlISsbGx+Pv7M3DgwFLLpa2tzdq1azl+/Dg9e/Zk/vz5jBs3jo8//pgePXqwZcuWErfr1KkTenp6AOzevZsRI0agVqvp1KkT9+/fJzU1lQMHDtCvXz/lfFepUkVjOapXr66Mx/A2MjQ0JDo6mh9//JFq1arRu3fvEqOoKlSooERbubu7K9fy4cOH6dmzJ4DSneNxu3btYtWqVajVaho2bEhKSorGsVVexPU4atQoVq5c+UQNQgU6deoE5HcBcXBwoGbNmujq6lK3bl2l8a5OnTr4+PgA0K9fPw4dOgTkR601bNgQJycn9u7dy+nTp4vl/3j9gPyxWC5dukRgYCDfffcdAP7+/kRHR7N161Y2b96sjDHUo0cPhgwZokSdFKalpUX37t2B/KiZ6OhoPD09UavV7Nmzh/Pnz3PkyBH8/PyoVq0aFSpUKHVMkbe9DgiCILxNbt26xbZt27h7967GdRwdHfn4448xMjJ6eQV7Q2m/6gI8l/dnv/RdOjg4lDhgjLa2Nnl5ecrnzMzMErevVq0abm5uHDlyBAsLixLXOXnyJGfPnsXf3x/If0NoZWWlDGZmaGhIt27d6NatGyqViu3bt2Nvb8/+/fv59ddfSxxMsHA3GS0tLXJycpBlGQcHhxIfdAAMDAyKfPb09CQ6Oprbt29TtWrVErcR3ky9v3i6uvS06z9OUz2CV1+X1Gp1qYNClVSXHi/342XWtI2RkRHm5uYcOnSIBg0akJeXh7GxMTExMSXu+0U3PBbOv6R96enpFXmz8N577yn/Hzx4MBMmTADy3zDs379fWXb58mWlS1CB77//ngEDBvDXX39hZGREeHg4LVq0UB5SCyt8L8rLy+Ovv/6iYsWKT318BTIzM5UGlZfhgw8+UP6vpaVV5HOFChWKfK5YsWKRzwYGBkU+V6pU6Yn2qaWlhZ+fH35+fjg5ObFy5cpiA1/q6Ogov+fC1+WTkGWZb7/9ttg4U0/SIPikSrsejY2N6du3L4sWLVLSyrp3FNRDlUpVpE6qVCrl2B/fjyRJZGZmMnz4cKKioqhTpw7Tpk0r8b6kp6en8X4VGBhIu3btmD59upKWnp7OihUr2LlzJx06dGDDhg2sX7+eNWvWMGTIkCLbV6xYUYl2k2WZgQMHMmvWrCLrbNq0qcR9l+Rl1wFBEATh2WVnZ3Py5EkaNGiAsbFxieu861EdT0NEgDylFi1akJWVVWT2idjYWGRZJi4ujqysLO7evcuePXtK3D49PZ3jx49jbW2tcR+hoaFMmzaNpKQkkpKSuHr1KlevXuXChQtERERw584dIP9hLi4uDgsLC+7cucMHH3zAqlWrnvgLsp2dHTdv3lQaQLKzs0t8q1Wgbdu2TJo0ifbt2z/VWzdBeJymenTw4EEsLCxeaV0qrWylsbS0JDo6GsjvFvIkKlSowMaNG1m1ahVr166lcuXKWFlZKVEqsiwrXSV8fHyUPvtr1qwpNV87OzuSkpKUcRNWr15Ns2bNNKYXCA8PV/5t1KhRsXzt7e2LjMVQEJ0CsGXLFuzt7QFo06YNu3bt4s6dO9y5c4ddu3YVeVC+c+cO27ZtY8CAAaSnp6NSqZAkiYyMjDLPWevWrfn222+VzwWNRU2bNlUGlNyxY4fyuy1JQkLCS50552WLj48vEo0RExOjsZGwJN7e3so1rGmciDZt2vDDDz8o3bkSEhJIS0srcd0XdT1+/PHHLFmyRGm8MDU15caNG6SkpJCVlVViN5WyXLx4UfmbuHbtWpo0aaI0apiYmJCamqqxgfTx+lH4d7B582bq169fZP3//Oc/jBo1Ch0dHTIyMpAkCZVKVWIESGEtW7Zk/fr1ykw4t2/f5sKFCzRs2JA//viDlJQUsrOzlftISd72OiAIgvA6k2WZlJQUTp48yc6dO1m+fHmpz2CmpqZMnDiRunXrvsRSvr3e7AiQV0CSJDZu3MiYMWOYM2cOFStWxNLSkvnz59OrVy8cHR2xsrLC1dW1yHaBgYHo6emRlZXFoEGDivQTdnZ2VgYr7dWrF5s2bWL79u1Ftu/atSthYWHUrFmT4OBgZFkmLy+P9u3b0717d2bPns2NGzcIDg4ust2nn36KqalpicdSoUIF1q9fz6hRo7h37x45OTmMGTMGBwcHjcffs2dPHjx4QKdOndi+fbt4gyQ8k9LqUZ06dV5pXSqtbFeuXNF4TF988QX/+te/mDJlSrFoh9IYGBiwbds2/P39MTQ0ZM2aNQQHBxMSEkJ2djYBAQG4uLiwYMEC+vbty5w5c4oNWhUfH19krIZ58+axfPlyevbsSU5ODp6engwbNgxdXd0S0wvcuXMHZ2dndHV1iwwYW6Bp06aMGzcOWZaRJImFCxeyZcsWtLW1qVq1qtLNomrVqkyZMgVPT08Apk6dWiRqbMaMGUyePBmVSkWbNm1YtGgRTk5ORcqiycKFC/noo49wdnYmJyeHpk2bsnjxYr744gv69OmDg4MDjRs3LjIGUrt27fj555+pVasW169fR09Pjxo1ajzZL+gNlJqaysiRI7l79y7a2trUq1evSINeWebPn0+/fv2YOXMmbdu2LTGcdvDgwSQlJeHm5oYsy1SrVk2JQHhZ16OJiQldu3Zl3rx5QH5Ey9SpU/Hy8sLMzKxYg8OTsLOzY9GiRQQFBdGgQQOCg4PR19dnyJAhODo6UqNGDeW6ftz7779fpHvapEmTiI+PR6VSYWFhweLFi5VlV69e5ejRo3zxxRcAjBw5Ek9PT4yNjcuM5GjQoAEhISG0bt2avLw8dHR0WLRoEd7e3kybNo1GjRphbGyMWq1WttmyZQtRUVHKOCT79u2jffv2T31+BEEQhOf38OFDvvvuO2RZRltbmxo1apQa5Vvw3VYoH1JpI8W+ah4eHnLBaPWCIAjCi2NpaUlUVFSZM7yMHj2ajh070qpVq5dUsvI1b948KleuzL/+9a9XXZTXVnp6Onp6ekiSRFhYGKGhoWzevPmlluFJr8fXTdeuXZk7d26pM7q8allZWTRr1oxDhw4pM9YIgiAI5SchIQEtLa1So5RPnTrFe++9R/Xq1cXEEi+AJEnRsix7lLRM/OUTBEEQnthnn33GkSNHXnUxnpmxsXGZg8i+66KjoxkxYgSyLGNsbMyyZctedZHeGLNnzyY5Ofm1bgC5ePEis2fPFo0fgiAIL8jevXsxMDAotQFEdEN8dUQEiCAIgiAIgiAIgiCU4cSJE9y+fZvmzZtrXOf27dsYGhpSoUKFl1gyobDSIkBEhyJBEARBEARBEARBKMOlS5dISEgodZ2qVauKxo/XmIh/FARBEARBEARBEN452dnZXLt2TZkp8MaNGwwZMkTjwKPt2rUTg5K+4UQDiCAIgiAIgiAIgvDOOXbsGDt27ADA0NCQWrVqkZmZib6+fonri8aPN59oABEEQRAEQRAEQRDeKmlpacTHx2Nra4uhoWGJ69jZ2WFkZEStWrWoXLnySy6h8CqIJqxnIEkS48aNUz5/9dVXTJs2rdRt9u/fj5GREa6urtjZ2dG0aVO2bdtW5r42bdpEXFzc8xZZEF47165dIyAgAGtra9zd3WnXrl2ZfSr9/Pyws7NDrVZjb2/Pjz/+qCyztLTk1q1bJW43f/58KlasyL1795S09PR0AgMDcXJywtHRkSZNmpCamlpq2fbv30+HDh3K4eghKSnpuUYAL/hD/rz5PK1NmzYxY8YMAA4cOICbmxva2tqsX7++yHorV67ExsYGGxsbVq5cqaRHR0fj5OREvXr1GDVqFAUDcU+cOBFnZ2cGDBigrPvLL78wf/78ci3/oEGDipUV4LvvvnurZjuZOXMmDg4OODs7o1arlZl7Bg8e/Mx/U57kWnvR1+O0adPQ19fnxo0bSpqmL7VPqzzKPn/+fFatWgXAunXrcHBwQKVS8fiA7rNmzaJevXrY2dmxc+dOAG7evEmTJk1wdHRk06ZNyrqdO3fm6tWrz1Wux2k6Z61ateLOnTvlui9BEIRX5d69e2zZsoULFy5oXMfY2Jj69euLxo9HZFnm1q1bJCUlveqivDCiAeQZ6OrqsmHDBo0PW5r4+vpy/Phx4uPjWbhwISNGjGDPnj2lbiMaQIS3kSzLdO3aFT8/PxITE4mOjmbWrFlcv369zG3XrFlDTEwMERERTJw4kYcPH5a5TWhoKJ6enmzYsEFJW7BgAaamppw8eZJTp06xdOlSdHR0nqts74K5c+cyfPhwAMzNzVmxYgV9+/Ytss7t27eZPn06R44c4ejRo0yfPl15qAoODuann37i7NmznD17lt9//5179+5x7NgxYmNjqVChAidPniQjI4Ply5fz0UcflVmmnJyc5z6uoKAgvv322+fO53Vw+PBhtm3bppzT3bt3U6dOHQB+/vlnGjRo8IpL+HxMTEz4+uuvX3UxisnJyWHZsmVKfXB0dGTDhg00bdq0yHpxcXGEhYVx+vRpfv/9d4YPH05ubi6hoaEMGzaMo0ePKg1/W7duxdXVlVq1aj3R/p9X//79+f777587H0EQhBctMzOTnTt3cv78eY3rmJqaMnLkSOzt7V9iyd5M0dHRhIeH85///IfvvvuOzZs3v+oivTCiAeQZaGtrM3ToUObNm1ds2aBBgxg2bBgeHh7Y2tpqjPJQq9VMnTqV7777Dsh/89SiRQucnZ1p2bIlFy9e5M8//2TLli2MHz8etVpNYmLiCz0uQXhZ9u3bh46ODsOGDVPSXFxc8PX1LRZlMWLECFasWFEsj9TUVAwMDNDS0ip1X4mJiaSmphISEkJoaKiSnpycjJmZmfLZzs4OXV3dUstWsN8ePXpQv359AgMDlQiGwhEoUVFR+Pn5AflvrIOCgvDz86Nu3bosXLiwWBnPnz+Pq6srkZGRJCYm0rZtW9zd3fH19eXMmTMA/PPPPzRq1AgnJyc+//zzUo8ZYM+ePbi6uuLk5ERQUBBZWVmlpltaWjJhwgScnJzw8vLi3LlzxfJMSEhAV1cXExMTZRtnZ+di/WF37tyJv78/VatWpUqVKvj7+/P777+TnJzM/fv38fb2RpIkBgwYwKZNm1CpVGRnZyPLMunp6ejo6PDVV18xcuRIdHR0Sjy+/fv34+vrS6dOnWjQoAG5ubmMHz8eT09PnJ2dWbJkCZDf2DZixAjs7Oxo1apVkciBwvT19bG0tOTo0aNlntvXXXJyMiYmJujq6gL5DQYFD9B+fn5KNIKhoSGTJ0/GxcUFb29vpZEvMTERb29v5VorKVpA0/nWpDyvx6CgIMLDw7l9+3aRfTwewVE4OtPPz4+xY8fi4eGBvb09kZGRdOvWDRsbmyL1KScnh8DAQOzt7enRowfp6ekAzJgxA09PTxwdHRk6dKhS7wvbu3evEhEFYG9vj52dXbH1Nm/eTEBAALq6ulhZWVGvXj2OHj2Kjo4O6enpZGVloaWlRU5ODvPnz2fChAkaz2vBd46GDRsyYcKE575/dOrUqch9UhAE4XWlo6PD8ePHS31BpaWlxXvvvSfG7SjBqVOn2LJli/L5zJkzJCcnU69ePTp27Fjs5dbb5I0eA2TO0TmcuX2mXPOsX7U+E70mlrneRx99hLOzc4lfTJKSkjh69CiJiYk0b968xAcJADc3N/7zn/8AMHLkSAYOHMjAgQNZtmwZo0aNYtOmTXTq1IkOHTrQo0eP5zswQShF+PRJRT47NGuFo18rwqdP0vj/stYvzalTp3B3d3+msgYGBqKrq8vZs2eZP39+mQ0gYWFhBAQE4OvrS3x8PNevX8fU1JSgoCBat27N+vXradmyJQMHDsTGxqbMsh0/fpzTp09Tq1YtfHx8iIiIoEmTJqWW4cyZM+zbt48HDx5gZ2dHcHCwsiw+Pp6AgABWrFiBi4sLLVu2ZPHixdjY2HDkyBGGDx/O3r17GT16NMHBwQwYMIBFixaVur/MzEwGDRrEnj17sLW1ZcCAAfzwww8MGzasxPQxY8YAYGRkxMmTJ1m1ahVjxowp1oAbERGBm5tbqfsGuHLlihJxAFC7dm2uXLnClStXqF27drH0SpUq0a5dO1xdXWnZsiVGRkYcOXKEKVOmlLqfY8eOcerUKaysrPjxxx8xMjIiMjKSrKwsfHx8aN26tRJ1FxcXx/Xr12nQoAFBQUEl5ufh4cHBgwfx8vIq8xifxvLly4ulOTg44OXlxcOHD1mzZk2x5Wq1GldXV9LS0vjvf/9bZNkHH3xQ6v5at27NjBkzsLW1pVWrVvTu3ZtmzZoVWy8tLQ1vb29mzpzJhAkT+Omnn/j8888ZPXo0o0ePpk+fPixevLjEfSxdurTE8y1JUrF1y/t6NDQ0JCgoiAULFjB9+vRSz0VhFSpUICoqigULFtC5c2eio6OpWrUq1tbWjB07Fsivj0uXLsXHx4egoCC+//57PvnkE0aMGMHUqVOB/CiJbdu20bFjxyL5R0REPNF97cqVK3h7eyufC+pB37596du3Lz/++CNz5szh+++/p3///hoH4itw+fJl/vzzT7S0tJ77/lGlShWysrJISUnhvffeK/NYBEEQytP9+/eV2ViuXr1KrVq1aNGiRYnramlpMWHCBNG4UYaMjAwuXbrEhQsXuHjxIn369EFfX5+7d+9y5coVsrOz0dHRoVevXhpfOr1txBXzjCpXrsyAAQNKfJvbq1cvVCoVNjY21K1bV3kD87jCb5AOHz6stLT179+fQ4cOvZiCC8Ibbs2aNcTGxnLx4kW++uqrUvt1Qn73l4CAAFQqFd27d2fdunVA/gPm+fPnGT9+PLdv38bT05O///67zP17eXlRu3ZtVCoVarX6ifpItm/fXomcqF69uvK24ubNm3Tu3Jk1a9bg4uJCamoqf/75Jz179kStVvPhhx+SnJwM5D9c9enTB8i/R5QmPj4eKysrbG1tARg4cCAHDhzQmF6gIP8+ffpw+PDhYvkmJydTrVq1Mo/3WUyYMIGYmBi+/vprpkyZwowZM/j555/p1asXISEhJW7j5eWFlZUVALt27WLVqlWo1WoaNmxISkoKZ8+e5cCBA/Tp0wctLa1Sv0gBVK9evdzHWngVDA0NiY6O5scff6RatWr07t27xCiqChUqKNFW7u7uyrV8+PBhevbsCaDxDZCm812SF3E9jho1ipUrV/LgwYMnPCv50Q0ATk5OODg4ULNmTXR1dalbty6XLl0CoE6dOvj4+ADQr18/5W/xvn37aNiwIU5OTuzdu5fTp08Xy/9564eRkRG//fYbUVFRuLm5sXXrVnr06MGQIUPo0aNHiXUSoGfPnmhpaZXb/eNtqQeCILx5fvnlF8LCwjh48CD3798v84FcNH4U9+DBA06dOsX27dv54YcfmDNnDmvXruXw4cPIskxaWhoAPj4+BAcHK+f4XWn8gDc8AuRJIjVepDFjxuDm5lbsbdzjb8BKeiMG+W+SRZ804XXQ+4vZZaZr+v+T5PM4BweHEgeihPwuZnl5ecrnzMzMEterVq0abm5uHDlyBAsLixLXOXnyJGfPnsXf3x+Ahw8fYmVlxYgRI4D8B8Vu3brRrVs3VCoV27dvR61WaywboHQrAJQw9cfL/XiZNW1jZGSEubk5hw4dokGDBuTl5WFsbExMTEyJ+9Z0LykvhfMvaV96enpFBpLVxMzMjP379yufL1++jJ+fH2ZmZly+fLlIeuFuSJB/X5RlGTs7Oz799FN27tzJBx98wNmzZ7GxsSmyroGBgfJ/WZb59ttvadOmTZF1tm/fXmZ5C2RmZqKnp/fE6z+p0iI2KlSoUOpyAwODMiM+SqKlpYWfnx9+fn44OTmxcuVKBg0aVGQdHR0d5fdc+Lp8EprOd3kOmlba9WhsbEzfvn2LRDOUde8oqIcqlapInVSpVMqxl/T3OzMzk+HDhxMVFUWdOnWYNm1aifclPT09jferwszMzJQGFyi5Hnz55ZdMnjyZ0NBQmjRpQo8ePejWrZsyYGphBfWgvO4fL6oeCILwbrt8+TJ37tzByclJ4zpt2rRBR0eHGjVqUKFChZdYujeTLMvk5eWhpaXFlStXWL9+vTLmmo6ODnXq1MHPzw8LCwvMzMyKnNMX/Z3ydfbSms0kSeoiSdJPkiSFS5LU+mXt90WqWrUqvXr1YunSpUXS161bR15eHomJiZw/f77EPsCxsbF8+eWXygB/jRs3JiwsDMh/w10w3kClSpWe6g2XILwJWrRoQVZWVpFZXGJjYzl48CAWFhbExcWRlZXF3bt3NQ4UnJ6ezvHjx7G2tta4n9DQUKZNm0ZSUhJJSUlKSOWFCxeIiIhQ/kg8fPiQuLg4LCwsSi1baSwtLYmOjgbg119/faLzUKFCBTZu3MiqVatYu3YtlStXxsrKSolSkWWZEydOAPkt9YXvEaWxs7MjKSlJ6X63evVqmjVrpjG9QHh4uPJvo0aNiuVrb2+vsUtfYW3atGHXrl3cuXOHO3fusGvXLtq0aUPNmjWpXLkyf/31F7Iss2rVKjp37lxk2ylTpvDll1+SnZ1Nbm4ukP+AWjAWQ2n7/OGHH8jOzgbyxytJS0ujadOmhIeHk5ubS3JyMvv27dOYR0JCwkudUedFiY+PLxKNERMTo7GRsCTe3t7KNVxwzT1O0/kuyYu6Hj/++GOWLFmiNF6Ymppy48YNUlJSyMrKeqKZ1h538eJFJdJi7dq1NGnSRGnUMDExITU1VWMD6ZPWj06dOhEWFkZWVhb//PMPZ8+eLdLt6uzZs0qjYXp6OiqVCkmSyMjIKDXf8rh/yLLMtWvXsLS0LPM4BEEQnsbx48f57bffShxDqYC1tTXm5uai8UODvLw85ftQZmYmX3/9tTJ2WeXKlTE1NaV169YMGTKESZMmMWDAAPz8/LCyshLntJDnagCRJGmZJEk3JEk69Vh6W0mS4iVJOidJ0iQAWZY3ybI8BBgG9H6e/b5Oxo0bV2w2GHNzc7y8vHj//fdZvHgxFStWBODgwYPKNLgfffQRCxcupGXLlgB8++23LF++HGdnZ1avXs2CBQsACAgI4D//+Q+urq5iEFThrSFJEhs3bmT37t1YW1vj4ODAp59+So0aNahTpw69evXC0dGRXr164erqWmTbwMBA1Go17u7uDBo0qEife2dnZ2rXrk3t2rX5+OOPCQsLo2vXrkW279q1K2FhYSQmJtKsWTOcnJxwdXXFw8OD7t27l1q20nzxxReMHj0aDw+PMsclKczAwIBt27Yxb948tmzZwpo1a1i6dCkuLi44ODgoo3AvWLCARYsW4eTkxJUrV4rkER8frxx37dq12bp1K8uXL6dnz544OTmhUqkYNmwYFStWLDG9wJ07d3B2dmbBggUlDvLctGlTJUIDIDIyktq1a7Nu3To+/PBDHBwcgPzG4SlTpuDp6YmnpydTp06latWqAHz//fcMHjyYevXqYW1tzfvvv6/kv2nTJjw8PKhVqxbGxsao1WqcnJzIzMzExcWl1PM4ePBgGjRogJubG46Ojnz44Yfk5OTQtWtXbGxsaNCgAQMGDCjyID116tQiA4BFREQo0UJvstTUVAYOHEiDBg1wdnYmLi6uzKnaC5s/fz7ffPMNzs7OnDt3DiMjo2LraDrf8PKuRxMTE7p27aoMnKqjo8PUqVPx8vLC39+f+vXrP+WZy2+sWbRoEfb29ty5c4fg4GCMjY0ZMmQIjo6OtGnTBk9PzxK3ff/994t04dm4cSO1a9fm8OHDtG/fXomWcXBwoFevXjRo0IC2bduyaNGiIveMyZMnM3PmTCC/+88PP/yAp6cno0ePLrP8z3L/UKvVyv+jo6Px9vZWBnIVBEF4EklJSWzevLlIFN7jmjVrxqhRo97pyIOnlZ2dzYULFzhw4AC//PILc+bMYevWrQBUrFgRBwcHpetlpUqVCAgIoHHjxpiZmT3Vd9F3jVRaK1yZG0tSUyAVWCXLsuOjNC0gAfAHLgORQB9ZluMeLf8aWCPL8rGy8vfw8JALRqt/UwwaNEgMWioIwhvH0tKSqKgoZYYXTUaPHk3Hjh1p1ar0gW7fNMePH+ebb75h9erVr7oor1x6ejp6enpIkkRYWBihoaEvfTq8J70eXzddu3Zl7ty5xbprvSlGjx5Np06dlJczgiAITyImJobdu3czZMiQEhvNhSeTmZlZZMDSK1euKNGw1apVw9zcHBsbm2dq4H/XSJIULcuyR0nLnquJX5blA5IkWT6W7AWck2X5/KOdhwGdJUn6G5gN7HiSxg9BEATh9fPZZ59x5MiRV12Mcnfr1i2+/PLLV12M10J0dDQjRoxAlmWMjY1ZtmzZqy7SG2P27NkkJye/sQ0gjo6OovFDEARyc3O5efOm0nX4ypUrdOnSBVNT0xLXd3Z2LhJNJjyZtLQ0ZepZyB9GITExEUmSqFWrFl5eXlhYWFCnTp0i454Jz+e5IkAAHjWAbCsUAdIDaCvL8uBHn/sDDcmPChlIfkRIjCzLJc6tJ0nSUGAogLm5uXtZMzwIgiAIgiAIgiAI5ePy5cv8/PPPQP4A0rVq1aJVq1bFBmwWnpwsy9y5c4cLFy7QoEEDdHV12b9/P/v372fixIno6emRlJREbm4utWvXLjJYt/D0XlgEyNOQZXkhUHzO2OLr/Qj8CPldYF50uQRBEARBEARBEN4FOTk5/P3335iYmFCzZs0S1zE1NaVbt26YmZlRpUoVMd3sM8jLy+PGjRtcvHhR6dJSMLFFpUqVqFevHi4uLlhbWysDlIoBqF+OF9EAcgWoU+hz7UdpgiAIgiAIgiAIwiu0adMmGjZsqLEBREdHB2dn55dcqjdfamoqMTExXLhwgUuXLimziFWuXBkLCwssLCwwNzdXBi6tUqUKVapUeZVFfie9iAaQSMBGkiQr8hs+AoC+L2A/giAIgiAIgiAIwiMHDx5ET08PD48So//R1tYmODhYPHiXg9zcXP744w9q1apF/fr1ycnJYffu3ZiYmNCgQQOlwcPY2FjMfvMaea4GEEmSQgE/wESSpMvAF7IsL5UkaQSwE9AClsmyfPq5SyoIgiAIgiAIgiBodO7cOYyNjTU2gABv3Axbr4O0tDSlO4uuri7NmzdHpVIRGxtLXl4e9evXx9jYmPHjx4sBS19zz9WhS5blPrIs15RlWUeW5dqyLC99lL5dlmVbWZatZVme+bT5SpLUUZKkH+/du/c8xXthJEli3LhxyuevvvqKadOmlbrN5MmTUavVyo+trS1aWlqkpqa+4NIKwuvp2rVrBAQEYG1tjbu7O+3atSMhIaHUbfz8/LCzs0OtVmNvb8+PP/6oLLO0tOTWrVslbjd//nwqVqxI4XtKeno6gYGBODk54ejoSJMmTUhNTaV58+bs3Lmz2PbBwcFPdXwxMTFs3779qbYB2L9/Px06dHjq7Z7V/PnzWbVqFQBTpkxRRnJv3bo1V69eBeDXX3/FwcEBX19fUlJSAEhMTKR3797lWpYVK1YwYsSIYuknT55k0KBB5bqvt93MmTNxcHBQfp8FM/cMHjyYuLi4Z8ozKSkJR0fH517neUybNg19fX1u3LihpBkaGpZL3uVR9sL1afz48dSvXx9nZ2e6du3K3bt3lf3o6ekp3weGDRsGQFZWFm3btsXR0ZHvv/9eyXPo0KEcO1a+k+dpul8GBARw9uzZct2XIAjPJyMjg8TERA4ePEh4eDhhYWGlrj9w4EC6du36kkr3dioYsPTEiRNs2bKF7777jv/85z+Eh4cTFRWlfBeSJImRI0fSqlUrZVvR+PH6ey1HtJFleassy0Nf13mkdXV12bBhg8aHrZLMnDmTmJgY5cfT05NPP/203L64CcKbRJZlunbtip+fH4mJiURHRzNr1iyuX79e5rZr1qwhJiaGiIgIJk6cyMOHD8vcJjQ0FE9PTzZs2KCkLViwAFNTU06ePMmpU6dYunQpOjo69OnTp9iXi7CwMPr06fNUx/gsDSA5OTlPtf7zysnJYdmyZfTtm99Lcfz48cTGxhITE0OHDh2YMWMGAN9++y2RkZF8+OGHrF27FoDPP/+ckJCQJ9pPwRz2z8rJyYnLly9z8eLF58rnXXH48GG2bdvGsWPHiI2NZffu3dSpkz80188//0yDBg1ecQmfj4mJCV9//fWrLkYxj9cnf39/Tp06RWxsLLa2tsyaNUtZ19raWvk+sHhx/qR4O3fupEmTJsTGxrJ69WoATpw4QW5uLm5ubk+0/+cVHBzM3LlznzsfQRDKz//+9z9Wr17Nnj17uHbtWpmzg4gBS59e4VlRDxw4wLx581iwYAEbN27k9OnTVKlShVatWhEUFMSkSZPo0aOHsr6WltarKLLwHEQNeQba2toMHTqUefPmFVs2aNAghg0bhoeHB7a2tmzbtq3YOr/88gvnzp1TokZu3ryJv78/Dg4ODB48GAsLC6Vx5ZdffsHLywu1Ws2HH36oPEgYGhoyfvx4HBwcaNWqFUePHsXPz4+6deuyZcsWIP9tapcuXfD398fS0pLvvvuOb775BldXV7y9vbl9+/YLOkOCULp9+/aho6OjvPkEcHFxwdfXt1gExIgRI1ixYkWxPFJTUzEwMCjzD09iYiKpqamEhIQQGhqqpCcnJxeZzs3Ozg5dXV169OjBb7/9pjSsJCUlcfXqVXx9fdm1axeNGjXCzc2Nnj17KhFckZGRNG7cGBcXF7y8vLh37x5Tp04lPDwctVpNeHg4t2/fpkuXLjg7O+Pt7U1sbCyQ/0a7f//++Pj40L9/f43HERoaqkSrTJw4scx0Q0NDxo4di4ODAy1btuTmzZvF8ty7dy9ubm5oa+f3hqxcubKyLC0tTemvqlKpyMrKIj09HR0dHQ4ePEiNGjWwsbHRWF5DQ0PGjRuHi4sLhw8f1ngvW758Oba2tnh5eREREaExv44dO5b51kvIl5ycjImJifIl2cTEhFq1agH5UVRRUVFA/u9o8uTJuLi44O3trTRAJiYm4u3tjZOTE59//nmJDfW5ubmMHz8eT09PnJ2dWbJkSall2rNnD66urjg5OREUFERWVlap6ZaWlkyYMAEnJye8vLw4d+6ckldQUJBSpwp7PIKjcHSmn58fY8eOxcPDA3t7eyIjI+nWrRs2NjZ8/vnnyjY5OTkEBgZib29Pjx49SE9PB2DGjBl4enri6OjI0KFDi3xZLvB4fWrdurXyf29vby5fvlzqOdLR0SE9PZ3s7Gwl/ylTpvDll19q3Obx+8fNmzfp3r07np6eeHp6KnUqJSWF1q1bK98zSio/gK+vL7t3737pjbGvs+vXr/PPP/8A8Pvvv7/i0ghvm5SUFI4ePUpeXp7GdTw9Penfvz8TJkxg9OjRIrqjHOTm5irfQ06cOMFXX32l/P3R0dGhTp06vP/++wwbNoyJEycSGBhIkyZNMDc3V+7rwpvrjW4Aufbvf3Oh/4By/bn2738/0b4/+ugj1qxZQ0nddJKSkjh69Ci//fYbw4YNU0YALlg2adIk1qxZo1Sg6dOn06JFC06fPk2PHj2Ut5x///034eHhREREEBMTg5aWFmvWrAHyH04KtqlUqRKff/45//vf/9i4cSNTp05V9nfq1Ck2bNhAZGQkkydPRl9fn+PHj9OoUSMlTFcQbiyJJS0q/+FHzs3L/3w8P8Q872EuN5bEkn4i/wE6LzOHG0tiyTiV30iXm5ad/zkuPxww90HZERmnTp3C3d39mcoaGBiIs7MzdnZ2TJkypcwGkLCwMAICAvD19SU+Pl55yAsKCmLOnDk0atSIzz//XAn7rlq1Kl5eXuzYsUPZvlevXqSkpBASEsLu3bs5duwYHh4efPPNNzx8+JDevXuzYMECTpw4we7duzEwMGDGjBn07t2bmJgYevfuzRdffIGrqyuxsbH8+9//ZsCAAUoZ4+Li2L17d5EGmsKuXr3KxIkT2bt3LzExMURGRrJp0yaN6ZB/j/Dw8OD06dM0a9aM6dOnF8s3IiKi2O9h8uTJ1KlThzVr1igRIJ9++imtWrVi69at9OnThy+//JIpU6aUet7T0tJo2LAhJ06c4L333ivxXpacnMwXX3xBREQEhw4dKrVrhoeHBwcPHix1n6+r5cuXl/lTuPFn+fLlHD9+HMg/j4+vW5bWrVtz6dIlbG1tGT58OH/88UeJ66WlpeHt7c2JEydo2rQpP/30EwCjR49m9OjRnDx5ktq1a5e47dKlSzEyMiIyMpLIyEh++ukn5SHxcZmZmQwaNIjw8HBOnjxJTk4OP/zwg8b0AkZGRpw8eZIRI0YwZswYJd3Q0JCgoCAWLFhQ5rkorEKFCkRFRTFs2DA6d+7MokWLOHXqFCtWrFDCmePj4xk+fDh///03lStXVrqijBgxgsjISE6dOkVGRkaJLzdKqk8Fli1bxvvvv698/ueff3B1daVZs2bKde3v709SUhLe3t6MGjWKLVu24ObmpjReaVL4/jF69GjGjh1LZGQkv/76K4MHDwbyv2c0adKE06dP07VrV43RVCqVinr16nHixIkyzubbR5ZlpVH7yJEj/Pbbb0D+2/eCvweVK1cu9UFVEJ7WhQsX2L59O3fu3NG4Ts2aNbG2tkZfX/8lluzt8vDhQ86fP8++fftYsWIFs2bN4sKFC0D+TCy2trbKi69GjRrRs2dPGjZsSI0aNUREzVtINGE9o8qVKzNgwAAWLlyInp5ekWW9evVCpVJhY2ND3bp1OXPmDGq1mtzcXPr168eXX35JvXr1lPUPHTrExo0bAWjbtq0yKvOePXuIjo7G09MTyO8DWL16dSD/i1zbtm2B/PBwXV1ddHR0cHJyIikpScm7efPmVKpUiUqVKmFkZETHjh2VbQreQAvCm2TNmjV4eHhw8+ZNGjduTNu2bbGwsNC4fmhoKBs3bkSlUtG9e3fWrVvHiBEjUKvVnD9/nl27drF79248PT05fPgw9vb2SjeYzp07ExYWxtKlS/nrr7+Ii4vDx8cHyP9j2qhRI+Lj46lZs6ZSTwtHURR26NAhfv31VwBatGhBSkoK9+/fB6BTp07F7iOFRUZG4ufnp0ybFhgYyIEDB5AkqcT0Ll26oFKplDE6+vXrR7du3Yrlm5ycjL29fZG0mTNnMnPmTGbNmsV3333H9OnT8ff3x9/fH4BVq1Yp47V89dVXVKlShQULFhT7YqalpUX37t0BzfeyI0eOFCl/7969NY4DU716dWVMEqF0hoaGREdHc/DgQfbt20fv3r2ZPXt2sXFUKlSooERbubu787///Q/I70JT0JDWt29fPvnkk2L72LVrF7Gxsaxfvx6Ae/fucfbsWWxtbYutGx8fj5WVlbJs4MCBLFq0iObNm5eYXtDYUdDtrE+fPowdO7ZInqNGjUKtVpdYNk06deoE5P/9c3BwUKZ/rFu3LpcuXcLY2Jg6deoodbxfv34sXLiQTz75hH379jF37lzS09O5ffs2Dg4Oyt/TAiXVJ8ivU9ra2gQGBgL5DzMXL17kvffeIzo6mi5dunD69GkqV66sdDHLzs6mTZs2bN68mY8//piLFy8yYMAA5RgeP66C+8fu3buLNCTev3+f1NRUDhw4oHQBbN++famzPxTUtWdtpH6TXLlyhbNnz3LlyhWuXLmCSqVi3Lhx3L9/X4kwat26NTo6OgA0btz4VRZXeMOkpKTw559/0rhxY957770S17G3t6devXoavzsIzyY9PV0ZsPTixYskJyeTl5eHJEmYmpri7u6uRDeam5tjbm7+ikssvEyvZQOIJEkdgY6FGwlKUuOzz15OgTQYM2YMbm5ufPDBB0XSH5/mqOBzSEgINWvWLLa+JrIsM3DgwCL9hgvo6OgUCU8vCHVWqVRFQlcL9xMsbT3h3Vb9w/+f613SUhX5rKqgVfRzRe0in7UMdIp+rlShzP05ODgoD06P09bWLvKGrXAEVWHVqlXDzc2NI0eOaGwAOXnyJGfPnlUe3h8+fIiVlZUy0KahoSHdunWjW7duqFQqtm/fjr29PZ07d2bs2LEcO3aM9PR03N3d2bp1K/7+/sWiNE6ePFnm8ZblZQyYVdL0a3p6ehrPb2BgIO3atSsSOZKens6KFSvYuXMnHTp0YMOGDaxfv541a9YwZMiQIttXrFhRic7RdC8reMh+EpmZmaU2Er3OnvSeX9L6BgYGT7095DdA+fn54efnh5OTEytXrizWAFL474iWltZT/U2QZZlvv/2WNm3aFEkv3AD/vApfs49fv8bGxvTt25dFixYpaWXdOwr//Xv8b2PBsZf09zszM5Phw4cTFRVFnTp1mDZtWon1pqT6tGLFCrZt28aePXuUvHV1dZX9u7u7Y21tTUJCQpEZG77//nsGDBjAX3/9hZGREeHh4bRo0aLEBpDC94+8vDz++usvKlasWGy9J/Um1zVNsrOzuXbtGrVr1yY2NpZDhw4xbNgwzp49y/79+6levTp2dnaYmZkhy7LyNwNQXjwJwtPKy8vj1KlT1K9fX2MDiJ6e3ltX316Fu3fvkpuby3vvvcfdu3eZP38+kP+3zczMDB8fH8zNzalTp85z3R/fZlnp6ejo6nItMYEjG/5LU5/mGJjWoGIJLzbedK9lTM/rPghqgapVq9KrVy+WLl1aJH3dunXk5eWRmJjI+fPnsbOz46+//mLFihVFZq0o4OPjw3//+18g/61aQRhcy5YtWb9+vTLa/e3bt5VwLUF4k7Vo0YKsrKwi9SE2NpaDBw9iYWFBXFwcWVlZ3L17lz179pSYR3p6OsePH8fa2lrjfkJDQ5k2bRpJSUnKWB5Xr17lwoULREREKHXt4cOHxMXFKQ0phoaGNG/enKCgIOUttLe3NxEREcpYBGlpaSQkJGBnZ0dycjKRkZEAPHjwgJycHCpVqsSDBw+Usvj6+ipd2Pbv34+JickTv/Hx8vLijz/+4NatW+Tm5hIaGkqzZs00pkP+F6+CRqa1a9fSpEmTYvna29sXGVuh8OwPmzdvpn79+kXW/89//sOoUaPQ0dEhIyMDSZJQqVTKOAmaaLqXNWzYkD/++IOUlBSys7NZt26dxjwSEhJe6Owib5P4+Pgiv8uYmJhSo6Qe5+3trUQraRp3pU2bNvzwww9kZ2cD+b+ftLS0Ete1s7MjKSlJudZWr15Ns2bNNKYXCA8PV/5t1KhRsXw//vhjlixZojRemJqacuPGDVJSUsjKyiqxm0pZLl68yOHDh4H/rzcFjRomJiakpqZqbLx9vD79/vvvzJ07ly1bthSJkLp586bS9/z8+fOcPXuWunXrKsvv3LnDtm3bGDBgAOnp6ahUKiRJIiMjo8zyt27dmm+//Vb5HBMTA0DTpk2V6JIdO3aUGm7/pte1vLw8bty4wfHjx9m2bRsZGRnExMSwdOlS7t27h56eHiYmJmRmZtKwYUM+/fRThg8fTufOnfHw8BDh7oJGsiyTkpLCyZMn2blzJ8uWLSu1u5iJiQkTJ04sdbws4enJsszNmzeVbpeyLPPTTz8p3T2NjIxo3bo1H3zwAZMmTSIoKIiWLVtiY2MjGj8KSb9/j9g9v7Nz8QJWjBvOd0G9Obv4e6599TU3jhzm3MiR3Fn9y6su5gvxWkaAvEnGjRvHd999VyTN3NwcLy8v7t+/z+LFi6lYsSJffPEF6enpNG/evMi6v/76K1988QV9+vRh9erVNGrUiBo1alCpUiVMTEwICQmhdevW5OXloaOjw6JFi57qi6wgvI4kSWLjxo2MGTOGOXPmULFiRSwtLZk/fz516tShV69eODo6YmVlhaura5FtAwMD0dPTIysri0GDBhUJ03Z2dla+vPbq1YtNmzYVm4mla9euhIWFUbNmTYKDg5Flmby8PNq3b6902YD8sPuCdSE/4mTFihX06dNHGSgrJCQEW1tbwsPDGTlyJBkZGejp6bF7926aN2/O7NmzUavVfPrpp0ybNo2goCCcnZ3R19dn5cqVGs/Pnj17ioy9sG7dOmbPnk3z5s2RZZn27dvTuXNnAI3pBgYGHD16lJCQEKpXr648TBb2/vvvFxl4ddKkScTHx6NSqbCwsFBmp4D8cUiOHj3KF198AcDIkSPx9PTE2Ni4zEiOBg0alHgv8/b2Ztq0aTRq1AhjY2PUarWyzZYtW4iKilLGIdm3bx/t27cvdT9CvtTUVEaOHMndu3fR1tamXr16JTa+azJ//nz69evHzJkzadu2LSW9jBg8eDBJSUm4ubkhyzLVqlVTroP4+Pgi1++8efNYvnw5PXv2JCcnB09PT4YNG4aurm6J6QXu3LmDs7Mzurq6JY6PY2JiQteuXZUByXV0dJg6dSpeXl6YmZkVa8B7EnZ2dixatIigoCAaNGhAcHAw+vr6DBkyBEdHR2rUqKF05Xrc4/VpxIgRZGVlKdEE3t7eLF68mAMHDjB16lR0dHRQqVQsXryYqlWrKtvNmDGDyZMno1KpaNOmDYsWLcLJyanIudFk4cKFfPTRRzg7O5OTk0PTpk1ZvHix8j3DwcGBxo0bFwn3bteuHT///DO1atXi+vXr6OnpUaNGjac+d69KZmYm58+fx9zcnJs3bxIaGqr05dfV1cXNzQ1bW1sqVaqEnp4etra2JXbVEoSy5ObmsmjRIvLy8tDW1qZGjRqljkMmSVKJ0ZfC08nNzeXatWtKd5aLFy+Snp6OsbExY8aMQZIkOnfurPytkiRJdFd7TOqd22hpa5Odmcnv38/Dq0tP9HQr8r8fv0NXSxvjjIfY3L5L6uIfMapWnU5NmmAwzAcD74avuugvhKRpJPDXgYeHh1wwWv2bYtCgQXTo0KHI9EhlycrKQktLC21tbQ4fPkxwcLDy1kYQBOFZGBoaKgP6laZr167MnTv3tX5DlZWVRbNmzTh06JAYff0lSE9PR09PD0mSCAsLIzQ0lM2bN7/UMlhaWhIVFYWJiclL3e/zehPqU2nmzZtH5cqV+de//vWqi1KigmicrKwsduzYgbe3N7q6uixZsoTu3btjYWHBwYMHMTMzw8zMjPfee09EdAhPLCEhAUmSSq2/cXFxVK1alWrVqonpT1+gq1evkpCQwMWLF7l06ZISbVilShUsLCwwNzfHwsJCY9eid1n2wyxunE8k+Vw8pnXr8Z5ZHX4Y2o9m/YKwNa3Nxh8XYJv6EKOTf5OuJWGoXQGDhg0xaOKDoY8POhYWb0XDnSRJ0bIse5S0THyTfA1cvHiRXr16kZeXR4UKFZSR+AVBEF602bNnk5yc/Fo/sF28eJHZs2eLxo+XJDo6mhEjRiDLMsbGxixbtuxVF+mN8SbUp9IYGxuXOh33y5adnU1MTIwySOnNmzd5//33cXFx4ebNm6Snp1OnTh0GDx6MqakpOjo6IlJMeGYHDhxAS0ur1PrboEGDl1iid8eNGzc4ceIEfn5+6OjocPr0aSIiIjA1NUWtViuNHmKw2OLuJF8hLzePqrXMCJ06nuvnz5H3qJule4u2GBpXx72SCdLsr7iScgcvSaKioyMGQwZj6OODnosLUoWyx+97m4gIEEEQBEEQBOGVSklJQZZlqlatyooVK7CxscHHx4dZs2aho6ND7dq1MTMzw87O7o3qoiO8HmJjY7lx4watWrXSuM6dO3cwMDCgwjv2MPiy3bt3T5mhpWCq7/j4eMLDwxkyZAg1a9YkNTUVLS0tMUDsY3JzctDS1iZq20a0tLVxbduRn0b8ixrWNnQcO4ld389H6959KqfcQf/U36iS8seO1K5RQ4nw0Pf2RruUmcDeFm9cBMiTzgIjCIIgCIIgvFnS0tKUqA4DAwO8vLxYuXIl5ubm9OjRg6pVq6Kvr49KpWL06NEYGBi8FSHZwquTnJxMYmIiLVu21HgtlTY9tPBsCgaOLRi/48KFC9y9exfIn4rdwsKCWrVqYW1tzaeffqpMOV0wRe277tbFJC7/fZrkc/Ekn42n0nvv0XPKv7l4MgYd3Yqo/dvh17ojqrPnSOrXjzoxJyAnB0lPD30vTwz79sXAx4cKdeuKe2ghIgJEEARBEARBeGGuXr3KgwcPsLOzY82aNcosRZIk4eDgQI8ePUhMTKRy5cpUq1btFZdWeBNkZ2eTnJyszO52/fp1hgwZorGrZF5enhgP5iXKzMxk8+bNXLx4UZkhTF9fXxm7w8LCAlNTUzGOyiOyLJPx4D76lY04uXcXl/8+xfsffcxvC//DmYg/0DcypqZNfcwdnHBy9eLBoYOk/3mY9D8Pk3vvHgAVGzTAwMcHAx8f9NxcUb3jkUxvXASIIAiCIAiC8GbJy8vj3r17VKlShSNHjnDp0iV69OjBoUOHuHLlCnZ2dtSvXx9LS0vMzMyoWbMmurq6AKVOaS4Ij4uNjWXr1q1AfrRArVq1yMzM1Bg5IBo/XozCDUvr16/HwMCA999/H11dXe7du4e1tbUyfoeJiYmIQnjkYWYG1xPPciPpH9zadeJQ2CqO7djCyOX/Jf3+Pe7duEZebi6Ne/bFp0svtM7/Q9qff5L23Y+cOz8JAO1q1TBs3jy/0aNxI7TFgLBPTDSACIIgCIIgCM/k8uXLxMXFceXKFa5evYokSUyaNIns7GwyMzPJy8ujVatWSmh74anLBaEkaWlpxMfHU69ePY2DXtrY2BAQEECtWrXEwJgvUUZGBpcuXVK6szx8+JDg4GAgvyGqYMwOSZIYOnToqyzqa0POy+P21csY16hF0oljRISt4tali8hyHgC2jXyo6+aFYZWq5Obm4NWpO842Dbi9dBlpERGkHzsG2dlIurroe3pi3LMnBj6N0bWxEQ1Kz0g0hz4DSZIYN26c8vmrr75i2rRppW4zefJk1Gq18mNra4uWlhapqalMmzaNr7766rnKZGlpya1bt54rD0F4ma5du0ZAQADW1ta4u7vTrl07EhISSt3Gz88POzs71Go19vb2/Pjjj8qy0urA/PnzqVixIvcehQlC/lSfgYGBODk54ejoSJMmTUhNTaV58+bs3Lmz2PYFf+CfVExMDNu3b3+qbQD2799Phw4dnnq7ZzV//nxWrVoFwLp163BwcEClUvF498NZs2ZRr1497OzslPNz8+ZNmjRpgqOjI5s2bVLW7dy5M1evXi3Xcmp6q9eqVSvu3LlTrvt6G8ycORMHBwecnZ1Rq9UcOXIEgMGDBxMXF/dMeSYlJeHo6Pjc6zyPadOmoa+vz40bN5S08uorXh5lL1yfpk2bhpmZmfJ3v/D94E2sT1lZWSQmJpKXl0dsbCzffPMNWVlZXLp0iSNHjpCTk4Orqyvt27cnLy+PJk2a0K9fP1QqFVWrVqVSpUrlegzC2ys1NZUtW7aQlJSkcZ3KlStTv3590fjxgj148IBTp06xfft2fvjhB+bMmcPatWv5888/kWWZevXqkZeX/yDftm1bmjVr9opL/OrJssy9G9c5FLaaB7dvEf/XIVaMG86ti0lU0NPDoEpVGnbrTbdJ0xj+81oqVTWhuvF7WKXncOPTyZz1aUJS9x7c/OYbcu/epWr//pgvW4rt0SOY//wT730wiIq2tqLx4zmICJBnoKury4YNG/j0008xMTF5om1mzpzJzJkzlc+BgYH06tWrXL645T6a6kgQ3hSyLNO1a1cGDhxIWFgYACdOnOD69evY2tqWuu2aNWvw8PDg9u3bWFtbM2jQoDJHbA8NDcXT05MNGzbwwQcfALBgwQJMTU05efIkAPHx8ejo6NCnTx/CwsJo06aNsn1YWBhz5859qmOMiYkhKiqKdu3aPfE2OTk5T7WP55WTk8OyZcs4duwYAI6OjmzYsIEPP/ywyHpxcXGEhYVx+vRprl69SqtWrUhISCA0NJRhw4bRrVs32rVrR5cuXdi6dSuurq7UqlXrifb/vFPb9u/fn++//57Jkyc/Vz5vk8OHD7Nt2zaOHTuGrq4ut27d4uHDhwD8/PPPr7h0z8/ExISvv/6aOXPmvOqiFPF4fQIYO3Ysn3zySZH13oT6NHHiRK5fv64MVNqyZUv++ecfNm7cSHBwMJUrV8bS0pKHDx/i5uaGp6enmKZaeCIPHz5k37591K1bV+N0s9WqVWPkyJFiUNKXTJZlbt++jbGxMVpaWvzxxx/s27cPQJmJyc/PDwsLC8zMzMRsOeTPynL9/DmunYvn6tl4rp2Lp9WQEegZVuLo5nWY2dlTp4ETbYLHUMmkGvqVjajTwIm8jAzSo6K5v+gHkiMiyHo0LpLWe+9h4Nskf7aWRo3QqV79FR/h20lEgDwDbW1thg4dyrx584otGzRoEMOGDcPDwwNbW1u2bdtWbJ1ffvmFc+fOFYkaiYuLw8/Pj7p167Jw4cIi63p5eaFWq/nwww+Vxg5DQ0PGjRuHi4sLhw8fVtbPyMjg/fff56effirHIxaE8rVv3z50dHQYNmyYkubi4oKvr2+xCIgRI0awYsWKYnmkpqZiYGBQ5gBaiYmJpKamEhISQmhoqJKenJyMmZmZ8tnOzg5dXV169OjBb7/9pjwwJiUlcfXqVXx9fdm1axeNGjXCzc2Nnj17kpqaCkBkZCSNGzfGxcUFLy8v7t27x9SpUwkPD0etVhMeHs7t27fp0qULzs7OeHt7ExsbC+S/Je7fvz8+Pj70799f43GEhoYq0SoTJ04sM93Q0JCxY8fi4OBAy5YtuXnzZrE89+7di5ubm/LgYm9vj52dXbH1Nm/eTEBAALq6ulhZWVGvXj2OHj2Kjo4O6enpZGVloaWlRU5ODvPnz2fChAkaj6PgHtmwYUMmTJhAYmIibdu2xd3dHV9fX86cOQPAP//8Q6NGjXBycuLzzz/XmF+nTp2K/F6F/GvbxMREGVvBxMREeYD28/NTonsMDQ2ZPHkyLi4ueHt7c/36dSC/znh7eyvnvqSG+tzcXMaPH4+npyfOzs4sWbKk1DLt2bMHV1dXnJycCAoKIisrq9R0S0tLJkyYgJOTE15eXpw7d07JKygoSKlThT0ewVE4OtPPz4+xY8fi4eGBvb09kZGRdOvWDRsbmyLXV05ODoGBgdjb29OjRw/S09MBmDFjBp6enjg6OjJ06FBKGkD+8fqkyetYnzIzM4mNjaVZs2asWrWKWbNm8dNPP7F9+3bOnTvH3bt3sba2pn///lSpUgVLS0u6detGpUqV0NXVFY0fwhPT1tYmNjZWud+URKVS8d5774lxO16wvLw8kpOTuX//PpD/Iujbb79VIs7q1q1L69atGTx4MJMmTWLgwIH4+flhZWX1TjZ+yLJMTnY2Welp7F2xhKTY46TdvU3olE/Yt/Inrpw5TXUraypUrEg1SytGrvgvVq4eGBhXwaFZS1RXk0lZupSLQUEkNPTm0pAh3Fm7Fu1qJlQf/wlWmzZic/AAZnPnYtS5s2j8eIHe6L9YB/+bwK1LqeWap0kdQ3x7lf4GGuCjjz7C2dm5xC8mSUlJHD16lMTERJo3b865c+eoWLGismzSpEns37+/yBeGM2fOsG/fPmWU9ODgYM6dO0d4eDgRERHo6OgwfPhw1qxZw4ABA0hLS6Nhw4Z8/fXXSh6pqakEBAQwYMAABgwYUA5nQ3hX3FgSWyxN39kEw0a1yHuYy63lp4stN3A3xcDDlNy0bFJ++bvIsuofOpe6v1OnTj1zP/DAwEB0dXU5e/Ys8+fPL7MBJCwsjICAAHx9fYmPj+f69euYmpoSFBRE69atWb9+PS1btmTgwIHY2NhQtWpVvLy82LFjB507dyYsLIxevXqRkpJCSEgIu3fvxsDAgDlz5vDNN98wadIkevfuTXh4OJ6enty/fx99fX1mzJhBVFQU3333HQAjR47E1dWVTZs2sXfvXgYMGEBMTAyQ3wB66NAh9PT02L9/f7FjuHr1KhMnTiQ6OpoqVarQunVrNm3ahJeXV4npXbp0IS0tDQ8PD+bNm8eMGTOYPn26UpYCERERT/R7uHLlCt7e3srn2rVrc+XKFfr27Uvfvn358ccfmTNnDt9//z39+/dHX1+/1PwuX77Mn3/+iZaWFi1btmTx4sXY2Nhw5MgRhg8fzt69exk9ejTBwcEMGDCARYsWacyrSpUqZGVlkZKSwnuv6QBgy5cvL/JZrVbj6upa6vplrVOa1q1bM2PGDGxtbWnVqhW9e/cuMSw5LS0Nb29vZs6cyYQJE/jpp5/4/PPPGT16NKNHj6ZPnz4sXry4xH0sXboUIyMjIiMjycrKwsfHh9atW5cYkpuZmcmgQYPYs2cPtra2DBgwgB9++IFhw4aVmD5mzBgAjIyMOHnyJKtWrWLMmDHKCwVDQ0OCgoJYsGAB06dPf+LzUqFCBaKioliwYAGdO3cmOjqaqlWrYm1tzdixY4H8B4ClS5fi4+NDUFAQ33//PZ988gkjRoxg6tSpQH6UxLZt2+jYsWOR/EuqT9999x2rVq3Cw8ODr7/+mipVqrzy+vTNN98A+aHtBfeRatWqsWHDBjp06EBubi729vbY29tjZmaGkZGR8nsVU1MKJbl//74yG8vVq1epXr06rVu3LnFdlUrFuHHjROPGK5CTk8OVK1eU8TsuXbpEVlYW/v7++Pj4YG5uTocOHZTImzp16lCnTp1XXOpXJys9jWvnzqKrr4+JhRU/ffQBLv7t8O7WmzMRBzCuXgMLJzWdP/kc07r1qPRe0V4Befdvc+/wLtIiIkiN+JPcR920dW3qUaVPHwya+KDv4YHq0bgpwsvzWjaASJLUEehYr169V10UjSpXrsyAAQNYuHChMuBPgV69eqFSqbCxsaFu3bqcOXMGtVpNbm4u/fr148svv+TxY2vfvj26urro6upSvXp1rl+/zp49e4iOjsbT0xPIj+6o/qg1UEtLi+7duxfJo3PnzkyYMIHAwMAXeOSC8GoVdIG5efMmjRs3pm3btlhYWGhcPzQ0lI0bN6JSqejevTvr1q1jxIgRqNVqzp8/z65du9i9ezeenp4cPnwYe3t7pRtMQQPI0qVL+euvv4iLi8PHxwfID+Nt1KgR8fHx1KxZU6mnmvojHzp0iF9//RWAFi1akJKSorx16dSpU7H7SGGRkZH4+fkp00MGBgZy4MABJEkqMb1Lly6oVCp69+4NQL9+/ejWrVuxfJOTk7G3ty/1fJfGyMiI3377DYA7d+4we/ZsNm7cyJAhQ7hz5w7jxo2jUaNGxbbr2bOnMgbSn3/+Sc+ePZVlBREAERERyvnq379/keiWx1WvXp2rV6++tg0gL5uhoSHR0dEcPHiQffv20bt3b2bPns2gQYOKrFehQgUl2srd3Z3//e9/QH4XmoIxKPr27VusCwfArl27iI2NZf369QDcu3ePs2fPltiFLT4+HisrK2XZwIEDWbRoEc2bNy8xvaABpE+fPsq/BQ0UBUaNGoVarS6xbJp06tQJACcnJxwcHKhZsyaQ/5bz0qVLGBsbU6dOHaWO9+vXj4ULF/LJJ5+wb98+5s6dS3p6Ordv38bBwaFYA8jj9Sk4OJgpU6YgSRJTpkxh3LhxLFu2TGP5XlR9ys3N5Y8//iAgIIB58+Zx8+ZN8vLy0NPTIyMjg5ycHKpUqUJwcDDVqlXD1NQUOzs7HBwcnvjcCu+28PBwrly5giRJVK9evcyHZtH48XLk5eVx/vx5Lly4wIULF7hy5YoSSW5iYoKjoyPm5uZYWVkB+dPUeniUOGvoWy8vN5fMtFT0Kxuxd/kSLp46QcqVSyDL2Dfxo93IT3Bq0Zoa9WxQaWkRvGQ10qPruJ5nfoN2XlYWGdHRpEZEkBbxJ1mPIvC0qlTBoHHjR1PUNkbH1PSVHaeQ77VsAJFleSuw1cPDY0hp6z1JpMaLNGbMGNzc3JQxBQo8/gas4HNISAg1a9Ystj6ghCoDSuirLMsMHDiQWbNmFVu/YsWKxd58+/j48Pvvv9O3b18xMI7wVEqL2FBV0Cp1uZaBTpkRH49zcHBQHpwep62trQyoBflvj0tSrVo13NzcOHLkiMYGkJMnT3L27Fn8/f2B/EYLKysrRowYAeQ/KHbr1o1u3bqhUqnYvn079vb2dO7cmbFjx3Ls2DHS09Nxd3dn69at+Pv7F+tuUTCGyPMwMDB47jzKUtI9QU9PT+P5LczMzIxLly4pny9fvlyk+xDAl19+yeTJkwkNDaVJkyb06NGDbt26FRtQFv7/ePPy8jA2NlYiYZ6kzCXJzMwstQHpVSvpnl+e65dES0sLPz8//Pz8cHJyYuXKlcUaQHR0dJRzXPB350nJssy3335bZKwcoNRBC59W4d//49eCsbExffv2LRIdVNa9o+DvrEqlKvI3V6VSKcde0t/vzMxMhg8fTlRUFHXq1GHatGkl1pvH65NpoS+5Q4YMURqbXmR9qly5Mjt27KBGjRosXboUc3Nz5fiSk5MxNzfH0dGRhQsXKt15Hy/v616fhJfrypUr3Lx5E7VarXGdVq1aoaWlRY0aNd7JrhGvk/j4eLKzs5XugOvWrePhw4fUrFkTLy8vzM3NMTc3fynfO153SbHHyXhwH3ufZoRNnYCugQHdP5tB6p0UjKqbYtfYl5o29alhnT9WTZOA/4+ul1QqZFnm4blzSoNHemQkcmYm6Oig7+pKtbFjMWjiQ0V7e6WxRHg9iN/Gc6hatSq9evVi6dKlRdLXrVtHXl4eiYmJnD9/Hjs7O/766y9WrFhRZNaKsrRs2ZL169cro93fvn2bCxcuaFx/xowZVKlShY8++ujZDkgQXpIWLVqQlZVVpD7ExsZy8OBBLCwsiIuLIysri7t377Jnz54S80hPT+f48eNYW1tr3E9oaCjTpk0jKSlJGcvj6tWrXLhwgYiICGW2g4cPHxIXF6c0pBgaGtK8eXOCgoKUt9De3t5EREQoYxGkpaWRkJCAnZ0dycnJREZGAvlh5Tk5OVSqVIkHDx4oZfH19WXNmjVA/kwvJiYmTzx6vZeXF3/88Qe3bt0iNzeX0NBQmjVrpjEd8h+GChqZ1q5dS5MmTYrla29vX2RsBU06depEWFgYWVlZ/PPPP5w9exYvLy9l+dmzZ7l8+TJ+fn6kp6ejUqmQJImMjIxS861cuTJWVlasW7cOyH+oPnHiBJDfoFswQG7BeSuJLMtcu3YNS0vLMo/jXREfH8/ZRwOqQf6AvKVFST3O29tbib4p+B08rk2bNvzwww9kZ2cDkJCQQFpaWonr2tnZkZSUpFxrq1evplmzZhrTC4SHhyv/lhT58PHHH7NkyRKl8cLU1JQbN26QkpJCVlZWiWNwleXixYvKuFoF9aagUcPExITU1FSNjbeP16fk5GTl/xs3blQeSMqjPsmyzN27d7l79y4nTpzg4MGDVK5cGQMDA2bNmoUkSdSuXZvbt28jSRLNmzfH1NSUnj17cu7cOY2Ni6I+CY+LjY3lt99+K9K4+DgrKyvMzc1F48dLVDBgaUxMDHv37lXSIyMjiYiIAPIbdwcNGsSkSZMYOnQobdq0wd7e/p1r/MjOyuTymdNEbd3A1m9msXHuDABid+/g8Lq1ALi164Rzq7YAdPr4M7pO/IJG3ftg6exKRYP/7/qXc/s297b9xtVPP+NcMz/Od+zEjdlzyL5yBeOePam9+Afs/jqMxaqVmHw4FD0HB9H48Rp6LSNA3iTjxo0r1q/e3NwcLy8v7t+/z+LFi6lYsSJffPEF6enpNG/evMi6BV8yS9KgQQNCQkJo3bo1eXl56OjosGjRolK/yC5YsICgoCAmTJjw1LNWCMLLIkkSGzduZMyYMcyZM4eKFStiaWnJ/PnzqVOnDr169cLR0RErK6ti4yAEBgaip6dHVlYWgwYNKtLn3tnZWQmt7dWrF5s2bSo2FW3Xrl0JCwujZs2aBAcHI8syeXl5tG/fvki3sj59+ijrQn7EyYoVK+jTp4/STSMkJARbW1vCw8MZOXIkGRkZ6OnpsXv3bpo3b87s2bNRq9V8+umnTJs2jaCgIJydndHX12flypUaz8+ePXuoXbu28nndunXMnj2b5s2bI8sy7du3p3PnzgAa0w0MDDh69CghISFUr15deZgs7P333y8y8OrGjRsZOXIkN2/epH379qjVanbu3ImDgwO9evWiQYMGaGtrs2jRoiIRaJMnT1ZmuerTpw9dunRh9uzZzJgxQ+MxFlizZg3BwcGEhISQnZ1NQEAALi4uLFiwgL59+zJnzhzlmAqo1WolaiQ6Ohpvb28xCGMhqampjBw5krt376KtrU29evWeqvF9/vz59OvXj5kzZ9K2bVuMjIyKrTN48GCSkpJwc3NDlmWqVaumdJuJj48vcv3OmzeP5cuX07NnT3JycvD09GTYsGHo6uqWmF7gzp07ODs7o6urW+JAtyYmJnTt2lUZkFxHR4epU6fi5eWFmZkZ9evXf+JjLmBnZ8eiRYsICgqiQYMGBAcHo6+vz5AhQ3B0dKRGjRpKd7fHPV6fJkyYQExMDJIkYWlpqQwU+6z1adSoUcTGxuLs7ExYWBjx8fEkJSVRsWJFnJ3zo/BWr17N1KlTcXFxUeoTwLfffivqk1DMhQsXOHbsGJ06ddI4npavry9+fn6i28orlpeXx40bN5TxOy5evKi8ZNHT08PX1xcdHR06d+5cJIKroKvfu0KWZSRJ4nLcKf45EY1vn4H8sXopJ/63AwCj6qaY2TVAlmVaBgWjq5/fGFTfp+Tpe+WHD0k/HkPaoUOkRUSQ+WgaeZWREQaNGmHYxAeDxo3ReYKZuoTXh1TSSOavCw8PD7lgtPo3xaBBg+jQoQM9evR41UURBOEdZmhoqMxSU5quXbsyd+5cjdMRvu5Gjx5Np06daNmy5asuylsjPT0dPT09JEkiLCyM0NBQNm/e/FLLYGlpSVRU1BNPNf+6KI/6lJOTQ0pKCqamphw5coSEhAT69+/P5s2biY+PZ/z48Zw+fZr09HTMzMwwNTUttwYLUZ/eLadOneL333/nX//6l5hy9jWVmJjIX3/9xaVLl5RotEqVKmFhYYGFhQXm5uZUq1btnW2gynhwn2vnErBwcSXuwD4OrFnOkO/yGzwOr1/LkEXLuXf9Gql3UqhZzw59I+NS85NlmYf//EPaoQjSIiJIi4xETk8HbW301C4Y+vhg4ONDRQcHpDIG4RdeLUmSomVZLnFQG9HELwiC8A6bPXs2ycnJb2wDiKOjo3hYK2fR0dGMGDECWZYxNjYudeBOoainrU8FbysvXbrEyZMnuXz5MteuXQPg008/RUtLC21tbXJzc2nevDlt2rRBkqQi0/2WJ1Gf3my5ubncuHGjyIwsHTt2VKbBflyDBg1e2LUkPJvr16+zY8cO2rRpQ82aNcnMzOT27ds0aNAAc3NzLCwsMDY2fifH+svNyUGSJG5dukDUto1cOxfPneT8KXsHfrUI4+o1qOfpTXZmJurW7XFr1wmVSouKdethiuaJNXLu3CH9r7+UsTxyHnVf1LEwx7hLl/zZWry80BKzYL01RASIIAiCIAjCS5CRkcGFCxewtrYmISGBrVu3MmLECBISEtixYwe1atWidu3amJmZYWtrK7qiCE/l2rVrytTVurq61KpVixYtWrzTU5m+rtLS0op0Z3F1dcXT05N79+4RFhZGmzZtsLS0VBpJ30VZ6ekknYimlq0992/dZP2Xk+n22XS0tHXY/FUINW3qU9PGjpr17Khpa4dOBd2yMwXk7GwyTpxQGjwyT54EWUZVqRIG3t7KbC0VRL15o5UWASIaQARBEARBEMpZVlYWycnJXLlyhStXrtCiRQtu3bpFWFgYQUFBaGtrEx0dTdOmTTEwMEClUr2zYexC2XJycvj777+pWrVqsVmDCuTm5hIXF0etWrWoWrXqO/vg/Dq6e/euMh3txYsXuXXrFpA/A1ft2rXx9PR8p6NxHmZmcD3xLFfPxnPtXDzOrd7H2LQGy8Z8iP/QEdh4NebIxv/i1KINVc3yx5h60utblmWyL1z4/9lajhwhLy0NVCr0XFyUBg89Jyck0ej81njjusBIktQR6FivnuZwJUEQBEEQhNdFZmYmp0+fxsLCguzsbH788UcKXjIZGxvz4MEDLC0tCQoKombNmujo6GjsmiAIj1OpVGzZsgVXV1eNDSBaWlo4OTm95JIJj8vLyyM9PR1DQ0NkWeb777/n5s2bQH5kjrm5OS4uLlhYWFCrVq13MtIrLzeX03/soUqNWlSzrMuifwUgP5ppqErNWmSlpWJcoxb9Zs3HxNwSLW1t/AYMfuL8c+/fJ+2vv0iL+JO0Q4fIvnIFAB0zMyp36ICBT2MMvL3ResLZ+IS3i4gAEQRBEARBeEIFU9CqVCp0dHQICwvD3d0da2trvvrqK9q0aYOHhwcHDx5UurO8a9NOCk/v0KFDVKhQociUyI+7ffs2RkZGGmdsEV6N3Nxcbt26hampKQChoaHcu3dPmdXqwIED6OrqYmFhQfXq1d+5SK/0e3fJykjH2LQmm+bOwLRuPRr16MsPQwKx9fah1eCPiP5tM1VrmVGjni16lZ6+UULOySEj9mT+wKUREWTExkJeHioDA/S9vTHwaYyhjw865uYiMuod8cZFgAiCIAiCILwO8h69lTx48KDSnSUtLQ0fHx9atmyJtrY2WlpaGBoaMnr0aGWAwhYtWrzikgtvkn/++Qc9Pb1SG0CqVq36EkskaPLw4UMuX76sdGe5fPkyOTk5TJo0CV1dXVxdXZUZWwCaNm36Ckv7chWMWXJq3/9Iij1O8tl47t+8Tl13L7pOmIq+kTG6+gZIksSAud9iUCX/mnZv37mMnIt7ePnyo9laDpH21xHyHjwASaKikxPvfTgUwyZN0HN2RtLRKe/DFN5w71YTZDm5du0aAQEBWFtb4+7uTrt27UhISCh1Gz8/P+zs7FCr1djb2/Pjjz8qyywtLZW+gI+bP38+FStW5N69e0paeno6gYGBODk54ejoSJMmTZTpLjWVbf/+/XTo0KEcjh6SkpKeq5+i4aNRlJ83n6e1adMmZsyYAcDixYtxcnJCrVbTpEkT4h7N6x0REYGzszMeHh6cPXsWyO+32bp1a+VLcHnQ9Pu4efMmbdu2Lbf9vM5e13rUvHlzdu7cWWz74ODgpzq+mJgYtm/f/lTbgOZr40WZP38+q1atAmD8+PHUr18fZ2dnunbtyt27d4H8uqqnp4darUatVitvtbKysmjbti2Ojo58//33Sp5Dhw7l2LFj5VpOTb/fgIAApa4K/2/mzJk4ODjg7OyMWq3myJEjAAwePFi53z2tJ7lnv+j7+rRp09DX1+fGjRtKmmE5jcxfUPYrV65w4cIFAH7++We2bduGSqXixIkT3L59GxsbG9q3b49arUalUjFgwADlmFeuXMnq1asBWLduHQ4ODqhUKh6PZp01axb16tXDzs6uyP3m999/x87Ojnr16jF79mwlPTAwEGdnZz777DMlLSQkhE2bNpXLsRfw8/MrVlaATz75hL1795brvt52GRkZJCYmcvDgQcLDw/nll19KXT8wMJAePXq8pNIJTyMjI4MzZ86wc+dOfvrpJ2bPns2qVav4448/yMjIwNXVlR49eiiRHfXr10etVr/aQr8k92/e4NLpWAD+9+N3rJuRf486G3mYq/F/U8Pahmb9gvDu1huANsNG496+CwCGVd97qmiM3NRUHuzZw7UZMzjXpg2Jrfy5Nm0aGadOU7ltG8zmz8P28J9Y/Tec6qNHo+/uLho/hBKJCJCnJMsyXbt2ZeDAgYSFhQFw4sQJrl+/jq2tbanbrlmzBg8PD27fvo21tTWDBg2iQoUKpW4TGhqKp6cnGzZs4IMPPgBgwYIFmJqacvLkSQDi4+PR0dEptWwCzJ07ly1btgDQt29f5SFuy5YtfPzxx/z+++98/fXXbN++naSkJBYvXszXX39NSEgIn3322ROFLObm5j5XaGq1atWoWbMmERER+Pj4PHM+r7vXuR716dNHGYG9QFhYGHPnzn2qY4yJiSEqKop27do98TY5OTlPtY/nlZOTw7Jly5TGCn9/f2bNmoW2tjYTJ05k1qxZzJkzBwBra2tiYmKKbL9z506aNGnCZ599ho+PD8OHD+fEiRPk5ubi5ub2RPt/3r7PwcHBzJ07l59++um58nmbHD58mG3btnHs2DF0dXW5desWDx8+BPIf6N90JiYmfP3118q1+azy8vJISUlRojpSUlIA2LFjB1paWnzwwQfY2NhQ+VEf8eHDh5d6vT5enxwdHdmwYQMffvhhkfXi4uIICwvj9OnTXL16lVatWimNvx999BH/+9//lEERO3XqRE5ODnp6esTGxuLv78+9e/dIT0/nyJEjfP7552UeZ3nUs5EjRzJkyBAR1fIU9u3bx9GjR4H8yI3atWuXOqPHu9Yt4nWWmZlJQkIC5ubmGBsbk5CQwMaNG9HS0sLMzIzGjRtjYWFBnTp1qFix4qsu7kuTmZbKtXMJJJ+L58Gtm7T+cBR/rl9LYvRRhv+0hupWddE3rgJAxzGT0C7ju1lZ5NxcMk+fJvXQIdIi/iQjJgZyc5H09THw8qJqv/4Y+PhQwcpSdGsRnoq42z6lffv2oaOjozw8A7i4uODr61vsze2IESNYsWJFsTxSU1MxMDAo80E5MTGR1NRUQkJCCA0NVdKTk5OLDIBlZ2eHrq5uqWUr2G+PHj2oX78+gYGByuBshd+sRkVF4efnB+S/aQsKCsLPz4+6deuycOHCYmU8f/48rq6uREZGkpiYSNu2bXF3d8fX15czZ84A+WGdjRo1wsnJ6Ym+rO3ZswdXV1ecnJwICgoiKyur1HRLS0smTJiAk5MTXl5enDt3rlieCQkJ6OrqYmJiAqB8oYX8qcgKbpw6Ojqkp6eTnp6Ojo4OiYmJXLp0STknJbG0tGTixIm4ubmxbt06du3aRaNGjXBzc6Nnz55KdM7vv/9O/fr1cXNzY8OGDRrz69KlC2vWrCnzPL3JXud61KNHD3777TflgTEpKYmrV6/i6+ur8XcbGRlJ48aNcXFxwcvLi3v37jF16lTCw8NRq9WEh4dz+/ZtunTpgrOzM97e3sTG5r8xmTZtGv3798fHx4f+/ftrPI7Q0FAlWmXixIllphsaGjJ27FgcHBxo2bKlMgBbYXv37sXNzU15OGrdurXyf29vby5fvlzquS2oL9nZ2cr9ZMqUKXz55Zcat3n8eG/evEn37t3x9PTE09OTiIgIAFJSUmjdujUODg4MHjwYTeNV+fr6snv37pfeePQ6S05OxsTEBF3d/CkBTUxMlME2C7/hNzQ0ZPLkybi4uODt7a00licmJuLt7a3cs0uKsMjNzWX8+PF4enri7OzMkiVLSi1Ted7Xg4KClDpV2OPRJ1999RXTpk1Tjnvs2LE4OztjZWVFZGQk3t7e1K9fn1GjRnHixAkePHhATk4O27dvZ/bs2fTo0QNPT09cXV2ZMWMGjRo1wtHRkaFDh5Z4PT5en+zt7bGzsyu23ubNmwkICEBXVxcrKyvq1avH0aNHOXr0KPXq1aNu3bpUqFCBgIAANm/ejI6ODhkZGeTl5ZGdnY2WlhZTp05l+vTpGs/3ihUr6NSpEy1atKBly5akpaURFBSEl5cXrq6ubN68Gch/sx0QEIC9vT1du3YlIyPj/9g77/CoyrQP39MymZbeJpPeQyCEEggEEBFEQLpSLMjioqLYddV1Xcuna9kiuvauuwquBXtBQKT33pIAKWQmvSeT6ef7Y5IjEQI2SOHc15Urycw5Z54p75nz/t7neX6nPF5sbCw1NTWUl5d3+pjnE7W1tWzevBm3293pNoMGDeLqq6/mnnvu4ZZbbmHGjBnSJK0bIggCVVVVbN++nWPHjgHeDNGPP/5YFCaTk5P5wx/+wL333suCBQsYO3YsycnJvV78aKisYO+qbxEEga2ffsjzC+bw0d/+ysb/vYsl/zAuh4PsyTO5/C+PAtB/3ERyZ10J8KvFD6fFQt0HH1B62+3kD8+laNZsqp/9N4LNRvC11xLz9tukbN5E9EsvEnT1VagT4qVxJfGL6fECyPsP38v+NSsBcLtcvP/wvRxc9z0ATruN9x++l8Mb1wJgt7bw/sP3UrBlIwDWxgbef/heju7wpga31Ned8fH279/PoEGDflWs7SmsqampPPDAA2ecuC1btow5c+YwcuRI8vLyxIvTBQsW8OSTTzJs2DD+8pe/iOnfZ4pt165dLFmyhIMHD3Ls2DFxonE62lP+tm7dysMPP4zT6RTvy8vLY+bMmbz11ltkZ2dz3XXX8e9//5sdO3bwj3/8gxtvvBGAW2+9lUWLFrFv3z6MRuNpH89mszF//nzef/999u3bh8vl4sUXX+z09nb8/f3Zt28fixcv5rbbbjvpuBs2bDhpRfr5558nMTGRP/3pT6K4c9999zFv3jwef/xxFi9ezP3338+jjz56xtcpODiYnTt3MnbsWB599FFWrlzJzp07GTx4MP/617+w2WwsXLiQzz//nB07dpz2IrK9ed65pPLlvWf8aVpb2mH7lu3ez6O7xXnStmeiO4+joKAghgwZwtdffy3uP2vWLGpqak753jocDmbPns0zzzzDnj17WLlyJTqdjkceeYTZs2eze/duZs+ezYMPPsiAAQPYu3cvf/vb35g3b54Y48GDB1m5cmUHgeZELBYL99xzD6tXr2b37t1s27aNTz75pNPbwSvsDR48mAMHDnDBBReccrK0YcOGTt+HN954gwkTJoj/FxYWMmDAAC644ALx8zlu3DiKiorIycnhlltu4bPPPmPgwIFndLY48fneeuut3H777Wzbto2PPvqIP/7R2+X94YcfZsSIERw4cIDp06dTUlJyymPJ5XKSkpLYs2fPaR+zK3nzzTc7/OzatUu8vbO/z7T96bj44os5fvw4KSkp3Hjjjfzwww+n3K6lpYWcnBz27NnDqFGjxCyaW2+9lVtvvZV9+/YRFRV1yn1ff/11/P392bZtG9u2bePVV1+lsLDwlNv+3ud1vV7PggULeOaZZzp9Dex2u1jCtXXrViwWCyqViqeeeoqMjAymTp3Kv/71L7766iuOHDnCwoULmTRpEnl5edx5553k5eXh5+cnlnYtXryYbdu2sX//flpbW/niiy9OeszTjacTMZvNREdHi/9HRUWJWSinuj09PZ3Q0FAGDhzI5MmTOXLkCB6P54xZVjt37uTDDz/khx9+4LHHHmPMmDFs3bqV77//nrvvvpuWlhZefPFFtFothw4d4uGHH2bHjh2dHm/gwIE/67rhfKC0tJRvvvmm07JLgPDwcBITE9FoNOcwMokz4Xa7MZvNbNy4kWXLlvH3v/+d559/ni+++IL9+/cDEBgYyA033MDgwd7+iVqtltjYWFS9uJyiqbYat8vJ8QN7ef+he7E2NlC8bzffvfJv6sstmNIyyJ11FTPv/z9uemMZ8//5AkofH4KjogmLS/jVIoSnpYWm77+n/NHHODphIkfGXET5A3+ldedODBddROQ//0Hyxg3Ef/QhYXfcjm7oEOS/MbNEQkIqgTmHtKfuV1VVMXz4cC655BJiY2M73X7p0qUsX74cuVzOzJkz+eCDD1i8eDFZWVkcO3aMFStWsHLlSrKzs9m0adMZH3/IkCHixWxWVhZFRUWMGDHitPtMmjQJtVqNWq0mLCxMnDxWVVUxdepUPv74Y/r06UNzczMbN27k8ssvF/dtX8nbsGEDH330EYC4GtIZeXl5xMfHi2UQ11xzDc8//zwXXnjhKW9vvyieO3eu+Pv2228/6bhlZWWEhoZ2uO2mm27ipptu4r333uPRRx/l7bffJisri82bNwPert1GoxFBEJg9ezYqlYp//vOfYpfvE5k921vbuHnzZg4ePCiWrzgcDoYNG8bhw4eJj48nOTkZgKuuuqpD/4oTCQsLw2KxdPoane+c7XGUnp4ulsFMnTqVZcuW8frrr3f63ubl5WE0GsnOzgY6ZhedyPr168VxMGbMGGpqamhsbARgypQpp71I3rZtG6NHjxY/w1deeSVr165FJpOd8vZp06Yhl8vFz+VVV13FjBkzTjpuWVkZ6enpJ93+2GOPoVQqufJK70qO0WikpKSE4OBgduzYwbRp0zhw4AB+fn689957ADidTsaPH8+nn37KHXfcQUlJCfPmzWPKlCknHf/E57ty5coOPSkaGxtpbm5m7dq1YqbUpEmTCAwM7PT1aR8zv1ZU623o9Xp27NjBunXr+P7775k9ezZPPPEE8+fP77Cdj4+PmG01aNAgvvvuO8BbQtMupF1xxRXcddddJz3GihUr2Lt3Lx9++CEADQ0NFBQUnLKE7Wyc12+55RaysrLE2ARBwGKx0NTUxAsvvEBlZSVbt24lOzsbjUaDSqVi4sSJDBkyBLlczt///nfx+y8pKQmz2UxAQADR0dHiGL/qqqt49tlnueuuu/j+++956qmnsFqt1NbWkpGRweTJkzvE1Nl4+j1YsmSJ+PfkyZN5+eWXeeyxx9izZw/jxo1j4cKFJ+0zbtw4sWnmihUr+Oyzz/jHP/4BeEWpkpIS1q5dyy233AJAZmYmmZmZncZwvnw31dbW8sMPPzB8+PBTft8DpKSkcMcdd3R6vpfofmzYsIGjR49SWloqZngGBgaSnJxMbGwsMTExBAcHAyCTyYiIiOjKcM86zXW1HFq/hvKCPCxH8miuqWbu//0dmUKB2+mktbGB5KHDienbH/+wcAKNJkypv/38Jng82A4eEt1arLt2gdOJzNcXbXY2AbNnoc/NxScpScrskDhr9HgBZPaDPzYJUyiVHf5XqX07/K/W6jr8r/Xz7/C/LqDzC+x2MjIyxAu+n6JUKjs0yjyxA/SJtK/kbNmypdOJ2759+ygoKGDcuHGAd7IVHx/P4sWLAe8F7owZM5gxYwZyuZyvvvqKrKysTmMDxHRo8HrFt6eMnxj3T2PubB9/f39iYmJYv349ffr0wePxEBAQcFKPgHbO9knsxOOf6rE0Gk2HBpgnMmfOnJMaXAqCwKOPPsqyZcu4+eabeeqppygqKuLZZ5/lscceO+kY7RaHgiAwbty4k1byO3tdToXNZjvnK0Zh13d+0Xum7RU61S/evzuPo/T0dKZOncrtt9/Ozp07sVqtDBo0iM8///yU7217D5HfwrmwyOxsXPz09X3rrbf44osvWLVqlbhPuwgKiHaf+fn54uoYwAsvvMC8efPYvHkz/v7+vP/++4wZM+aUAsiJz9fj8bB58+bflErcFWPml9Ded+Z0t3f29885zqlQKBSMHj2a0aNH069fP95+++2TBBCVSiW+xyee338OgiDw73//u0OvHPCWofxedHZeb3dgmDVrFg8++CBOp5O6ujpaW1ux2Wz4+/vTp08fGhoakMvl9OvXj9DQUPR6PVqtFh8fnw7fbXK5XHzuPx0nMpkMm83GjTfeyPbt24mOjuahhx465XnpVOPpVJhMJo4fPy7+X1paKpbjdXZ7O59++imDBg2iubmZo0eP8r///Y/x48dz5ZVXotVqO2x74jgTBIGPPvrolCU5P5fuPs5+T44cOUJGRkanAoivr2+vL3/o6Wzfvh2LxSJ+BxUUFNDa2kr//v1FweN8ELAEj4e6cgtqrQ6nzcbnTz9B7pyr8AsJY+1/38A/LJyotAyMSSkYQkIxBIVwxWP/FPfX6A2/OQZneTktGzZ6RY+NG3G3Zeep09MJvmYeutxcNAMHIj/hvCwhcTbp8SUw55oxY8Zgt9s7rN7v3buXdevWERsby8GDB8XU21WrVp3yGFarlV27dpGYmNjp4yxdupSHHnqIoqIisQeBxWKhuLiYDRs2UFfnLddxOBwcPHiQ2NjY08Z2OuLi4sS01/YV6jPh4+PD8uXLeeedd3jvvffw8/MjPj6eDz74APBebLWnpOfm5oqNLs/U2yI1NZWioiKx3vs///kPF1xwQae3t/P++++Lv4cNG3bScdPT0zvUkJ/oGvHll1+KmRntvPPOO0ycOJGgoCCsVityuRy5XI7Vaj1t/Dk5OWzYsEF8rJaWFvLz80lLS6OoqIijR48CdFrqAN5+JefSHacr6M7jCLzCyIUXXsiCBQvEVejO3tvU1FTKysrYtm0bgNhHwGAw0NTUJMYycuRI8fO/Zs0aQkJCfvbF15AhQ/jhhx+orq7G7XazdOlSLrjggk5vB6+w0C4yvffee6fM9vrpuPjmm2/EZsEnTqaqqqrEWvdjx45RUFBAQkKCeH9dXR1ffPEF8+bNE8eLTCbrtJ/AiVx88cX8+9//Fv9vFwtHjRolZpd8/fXX4nt1Ks6HMfNLyMvL63CO271792mzpH5KTk6O+F3Qfu7+KePHj+fFF18UyyLz8/NpaWk55ba/5bxutVp55plnSElJ4d1336WpqYnm5mY+/PBDZs6cyUcffYQgCMjlckaMGIHb7eaSSy5h2LBhbNq06Rc3pS4pKREzKtvHTbuoERISIj72qfjpeOqMKVOmsGzZMux2O4WFhRQUFDBkyBCys7MpKCigsLAQh8PBsmXLOgiITqeTJUuW8Kc//YnW1lZRrHG73eKKdmeMHz+ef//732LvkvZSqhPH2f79+8XeRKeip44zj8dDcXExmzdv5uOPP+b5558Xz9enIjAwkLvuuuuMDbklugeNjY3s27ePL7/8kpdfflkcC83NzdTU1IgLKldffTWLFi1i0qRJ9O3bt9eKH61NjRzbtY0N/3uXor27sDY28ObtN3Bo/Rp0gYFo/PxQKFQEm6JZ9Mp/+eO/X2fSLXczcOJUDEEhv0sMntZWmteto+Lxxzl66aUcGX0hZfffT8vWregvGEXkU0+SvH4dCcs/Juyuu9ANGyaJHxLnlB6fAXKukclkLF++nNtuu40nn3wSX19f4uLiWLJkCdHR0cyaNYu+ffsSHx/PgAEDOux75ZVXotFosNvtzJ8/v0O6dmZmptgBfNasWXzyyScnWWhOnz6dZcuWYTQaWbRoEYIg4PF4mDRpEjNnzjxtbGazudPn9OCDD3LttdfywAMPnLbZ50/R6XR88cUXjBs3Dr1ez7vvvsuiRYt49NFHcTqdzJkzh/79+/PMM89wxRVX8OSTTzJ1akef77y8vA415k8//TRvvvkml19+OS6Xi+zsbG644QbUavUpb2+nrq6OzMxM1Gr1KcWFUaNGceedd4od2J977jlWrlyJSqUiMDCQt99+W9zWarXy1ltvsWLFCgDuuOMOJk6ciI+Pj3ih2BmhoaG89dZbzJ07VywBevTRR0lJSeGVV15h0qRJaLVaRo4cKU6Ot2/fzksvvSS6M3z//fdMmjTpZ78PPZHuPI7amTt3rrgtnP69ff/997n55ptpbW1Fo9GwcuVKLrzwQp544gmysrK47777xKbCmZmZaLXaDp+5n7Jq1aoO4+KDDz7giSee4MILL0QQBCZNmiSOpc5u1+l0bN26lUcffZSwsDBRJDyRCRMmdGi8unjxYux2u5gxk5OTw0svvcTatWv561//ikqlQi6X89JLL4mp9QCPPPII999/P3K5nPHjx/P888/Tr1+/DmO0M5599lluuukmMjMzcblcjBo1ipdeeokHH3yQuXPnkpGRwfDhw4mJiRH3mThxIq+99hqRkZFUVFSg0Wh6fbryL6G5uZmbb76Z+vp6lEolSUlJnZbcnYolS5Zw1VVX8dhjj3HJJZfg7+9/0jZ//OMfKSoqYuDAgQiCQGhoqFg281vO63/4wx/YtGmTWKcfHx+PUqlk5syZ1NfX43Q6CQsLY968eYSFhTFz5kyefvppAgICAPjrX//KkCFDMJlMpKWl/eLXLjU1leeff54FCxbQp08fFi1ahFarZeHChfTt25eIiAix3O2n/HQ8LV++nJtvvpmqqirRNvfbb78lIyODWbNm0adPH5RKJc8//7wo1Dz33HOMHz8et9vNggULyMjIEI/3/PPPc80116DVasnMzMRqtdKvXz8mTpwoPv/OeOCBB7jtttvIzMzE4/EQHx/PF198waJFi/jDH/5Aeno66enpHc6nf/zjH8U+CE6nkyNHjnTI+uopCILAf//7X5xOJ3q9nsjISAyGzle1pbT77osgCNTU1FBSUkJxcTHFxcVirx8fHx+io6OxWq34+PiIGXDt/BaHvu5M+dECZHI5obFxvHP3zdSUevtlyWRyhl02l7jMAUy8+S5MqX1QqX257P4fm5Rr/QN+lxgEjwd7Xh4tGzbQvGEDrdt3IDidyHx80A4eTMD0GehG5KJOSZHGVw/C4/H0WncqWWed9bsSmUw2GZiclJS08MRVLAmJUxEXF8f27dtFh5fOuPXWW5k8eTJjx449R5H9OkaNGsWnn3562p4HEhJnQq/Xiy41p2P69Ok89dRTJ2VB9RSefvpp/Pz8uPbaa7s6lF6D1WpFo9Egk8lYtmwZS5cuFV1Dfi/aLWjlcjkGg4E333yTrKwsBgwYwOOPP85LL73Enj17KCgoIDIyksjIyA5lK92Vnj6eOmP58uXs3LnztA5PXcX27dtRKBQnieUnUlxcTFBQ0GmFD4nuh8fjwePxoFQqOXbsGB999JGYaabVaomJiRHLWSIiInqtyAFe8cdpa8VHo2XjB++iUvuSPWUmr918LWHxiUy548/88N830Bj8MCanEp6QhI/v2StZc1ZW0rJxo7e0ZeNG3G024urkZHQjRqDLzUU7eBByqVSsR3Ci2LFp0yb27NmDWq3+RaW33Q2ZTLZDEIRTqvbdMgNEEITPgc8HDx58clcvCYlfyZ///Ge2bNnS1WGclqqqKu644w5J/JA4ZzzxxBOUlZX12AlbQEDAae2DJX45O3bsYPHixQiCQEBAAG+88cZvPqbT6USlUrF69WqOHz+O2WzG4XCQnZ3NpEmTCAoKQqfT4ePjw5133smbb76JXC4XG5L2FHr6eOoMl8vFnXfe2dVhnJL9+/ejUqlOK4D8khIwia7D6XRit9vR6/U0NjaKGVGDBg0iICCAxMREUfQICQnp9dkElvzDHD+wl7IjeZQV5BFsimbWg49TVVyIWuu1J594890Ygr0LgBdcteCsxeKx2bDu2CH28rDn5QGgCApCN3w4utxcdMOHowoPO2sxSPw+CIJAfX09ZrMZi8WC2WymoqKCu+66C6VSid1uF52PeivdMgOkncGDBwvbt2/v6jAkJCQkJCQkfgElJSXY7XaSk5N57bXX8PPzY9asWbz66qsIgoDJZMJkMhETE9OhnEpC4kTWr19PaWkpc+bM6XQbh8OBj2SL2SNpdyNqL2mxWCz069ePadOmIQgCK1asoE+fPh3soXsjHo+bxqoqAsIj2Pn155Qe3MeUO//Ml8/+ncMbfiDQaMKYlEJURj/6XXixWM59NhEEAXt+wY9uLdu3I9jtoFKhHTgQ3Yhc9Lm5qNPSkPXSMonegtVqxWw2ExUVhUajYdOmTXz77beAtzQsIiKCID8Dsf56EjKzCIqMOsMRewY9LgNEQkJCQkJCovvjdrupqKjAbDZjNpuRyWRMnTqVNWvWYLVaSU5Opl+/fmL5yrXXXttra4olfjl2u/20pU0ymQy5XH7aCZ8kfvQcmpqaRLGjpKSE8vJywOvEZDQaGTp0KElJSYD3vf+py1RvoaW+jrKCPKpKCsmZMYe1/32TPd99zc1v/Q/B48btcuLxuBl5xXzGLLjhJCeWsyV+uGpqaNm4SRQ9XFVVAPgkJor2tNrsbOQ/cZyS6F40NTWxf/9+8Xu5vYn83LlzSU1NJTExkUmTJhESGMCmt1+hau1uGh12igD5NQt7jQByOqQMEAkJCQkJCYmfTWFhIaWlpYwcOZKPP/5YdA7RarUkJCRw2WWXUVNTg0ajOcmaVeL8prq6mry8PCwWC2VlZdTV1XHfffdJIkYvpb6+noqKCtF++bXXXqO0tBSVSkVUVJTYvyMqKqrXfgZcDgeVRUcJT0jm6I4t/PCf12msqgRArlCw8Pk3aa6pptZSSsqwkShVqnMWm8fhoHXnTrF5qf3gIQAU/v7ock8oazEaz1lMEj8ft9tNVVWVWMaSnJxMWloalZWVvPDCC/j5+REZGUlUVBQmk+mkXlqCx8NHjz9ISHQM4YkpGBNT8A+P6DWlZVIGiISEhISEhMQvoqWlhbKyMhITE9m+fTvr16/nlltuoaioiE2bNpGTk8OgQYNISUnBZDIREBAgXjgFBwd3cfQS3RGz2cx3332Hv78/kZGRZGVliTalEj0bj8dDZWUlxcXFDBo0CKVSyZYtW9i6dSv33nsvKpWKsWPHolQqMRqNvbJhqSAIIAjUlZex65vPyZ4yE0v+Ib585imuenwJWv8AIhJTGHDJZIxJqYQlJKLyUaMPDCIi6ezbLguCgOPYMa/gsX491m3bEVpbQalEm5VF6G23ossdgW+fdGS98P3pyQiCgMPhQK1W43K5eOeddygrKxOt6H19fQkNDQW8lu133nkny//vzwTplIzopIRQJpd3cAU6n5AEEAkJCQkJifMcp9OJQqHAYrGwefPmDmmzt99+O/7+/iQkJOBwOBg+fDijRo1CoVD06iZpEr+Mqqoqvv/+e0aPHk1Y2KkbIaalpXH33Xej0+nOcXQSvzculwuLxSKWs7T3/QGIjIwkOjqaIUOGMGDAAFHsiIuL68KIf3+cDjvmQwcoK8jzNio9ks+km+9C4+fPgTUrSRqcQ0zf/ky5634CIiJRa7VEpWWc+cC/I666OqybNtG8YQMtGzbiais78omLI2DGDK9by5AhKPTSmOxOtLS0iJkd7T8xMTHMmTMHpVKJVqMhIy2VhGTvAkRQUJC4ANHurpY6fBR+IaFd/Ey6J1Ih7q+gvLycOXPmkJiYyKBBg5g4cSL5+fmn3Wf06NGkpqaSlZVFeno6r7zyinhfXFwc1dXVp9xvyZIl+Pr60tDQIN5mtVq58sor6devH3379mXEiBGi3WVnsa1Zs4ZLL730d3j2UFRURN++fX/1/nq9/nc5zi/lk08+4ZFHHgFg7dq1DBw4EKVSyYcffthhu7fffpvk5GSSk5N5++23AW+d8iWXXELfvn154YUXxG2vu+46du7c+bvG2dnnYc6cOfQmW+juOo4uvPBCsTnUifsvWrToFz2/3bt389VXX/2ifYDfdaz+HJYsWcI777wDwEMPPYTJZCIrK4usrKwO8T/++OMkJSWRmpoqvj5VVVWMGDGCvn378sknn4jbTp06FYvF8rvG2X7e+Cljx44VJ+oSP5+WlhZ27txJc3MzBQUF/O1vf6OiokJsSmg0Ghk3bhzz589Hp9ORkpLC1KlT0Wg0qNXqXrl6K3FmTlc2LZfLsVgsNDU1dbqNWq2WxI8eTH19PatWreLNN9/k8ccf54033mDVqlXU1dXRt29fpk+fzm233SY2LQ0MDCQsLKxX9P3xuN04bK3Ympv55oWnObZrG62NjXz0t7+y8cP3aKyqJGnwUDQGP8Ji41n81vvEZmah9fMnOXsY6nNUDig4HFi3baPy6SUUXnY5BcNzMd9xJ03frUTTvz8RjzxM4sqVJH7zNREP/AXDmAsl8aOLcTgcFBcXi+WkAO+99x7vvvsua9asob6+npSUFPr06SPerz5eQP3G1WRmZhIcHHzKspWh0y4nfcToc/EUehxSBsgvRBAEpk+fzjXXXMOyZcsA2LNnDxUVFaSknD597d1332Xw4MHU1taSmJjI/Pnzz1jzuHTpUrKzs/n4449FL+ZnnnmG8PBw9u3bB0BeXh4qleq0sUnAU089xWeffQZATEwMb731Fv/4xz86bFNbW8vDDz/M9u3bkclkDBo0iClTprBu3TpGjBjBn//8Z3Jzc7nxxhvZs2cPbrebgQMHnvGxXS4XSuVvG26LFi3iqaee4tVXX/1Nx+kOdOdxNHfuXJYtW9ah+dqyZct46qmnftFz3L17N9u3b2fixIk/ex+Xy/WLHuO34nK5eOONNzqIeLfffjt33XVXh+0OHjzIsmXLOHDgABaLhbFjx5Kfn8/SpUu54YYbmDFjBhMnTmTatGl8/vnnDBgwgMjIyJ/1+L91XFx99dW88MIL3H///b/pOL2ZhoaGDqtIo0ePxsfHh88++4zLL7+cqKgoRowYga+vLxEREdxxxx1dHbJEN8NqtfLKK6+Qm5tLdnb2KbcJDg7mtttuO7eBSZxV7HY7q1evJjExkZSUFBwOB+vXr8doNJKdnS328OiNolZTTTVlR/K8ZSsJybyw8EoGXzqNnBlzKD20n8iUdOKzBjPrr38jLD7pJIHjXHVREAQBR1GRaE9r3bIFj9UKCgWa/v0JWXwT+txcfPv2RfYbv28lfj+OHDnCwYMHMZvNVFZWIggCSqWSjIwMmmuqSY+JYty4cRiNxlM2ih44YQoOW2sXRN47kEbCL+T7779HpVJxww03iLf1798f8K7c/uMf/+CLL74AYPHixQwePJj58+d3OEZzczM6ne6MK2hHjx6lubmZF154gccee0ycuJWVlXVIO25vLrV69erTxtbc3Mxll13G/v37GTRoEP/973+RyWTExcWxfft2QkJC2L59O3fddRdr1qzhoYceoqSkhGPHjlFSUsJtt93GLbfc0iHGY8eOMXPmTF555RWCgoK46aabqKqqQqvV8uqrr5KWlkZhYSFXXHEFzc3NTJ069Yyv8apVq7jrrrtwuVxkZ2fz4osvolarO709Li6OWbNm8fXXX6PRaHjvvffELuLt5Ofno1arCQnxeqW3p2H+dFXi22+/Zdy4caIt47hx4/jmm28ICAjAarXidDrFFbAHHniAl156qdPn8dBDD3H06FGOHTtGTEwMzz77LDfccAMlJSWAd+U9NzeXmpoa5s6di9lsZtiwYZ2usI0cOZL58+f/LpPGrqY7j6PLLruMv/zlL6K1YlFRERaLhZEjR7JixQoefPBB7HY7iYmJvPnmm+j1erZt28att95KS0sLarWa7777jr/+9a+0trayfv167rvvPsaNG8eCBQs4duwYWq2WV155hczMzJM+J9dff/0pn8fSpUv529/+hiAITJo0iSeffPK0t+v1ehYuXMiKFSuIiIhg2bJlYn1oO6tXrxYzoU7Hp59+ypw5c1Cr1cTHx5OUlMTWrVtRqVRYrVbsdjsKhQKXy8WSJUv4/PPPOz3W/Pnz8fX1ZdeuXeTm5nLTTTf9pvPGlClTGDlypCSAtCEIAk6nky1bthATE0NAQABPP/004D3fRURE4HQ6iY6O5qabbiI4OBi5XM5FF13UxZFLdCUtLS04nU4CAgJOeb9GoyEuLq7T+yV6NoIgUFdXJzq0+Pv7M3r0aFQqFQcPHsRgMJCSkkJISAj33nvvaZ17eiJOm43W5kb8QsL45oWnKd67i+a6WgDSR4wm6uYMhk6fRWRyKnKFgj/++3Vx3+iMzHMer7uhgZZNm0W3FmdbxqUqOhq/qVO8bi1Dh6IwGM5wJImzSfu4al98sFgszJkzB61Wi9ls5uDBg5hMJlJTU1E57ZTt2sLLN8yjtdGbrZz95vudjrXYflnn8Jn0Pnr2LAp4/+F7T7otNWckWeMn4bTb+PiJh066P+OCsfQdPRZrYwOfP/14h/tmP/jEaR+vXTz4NVx55ZWo1WoKCgpYsmTJGSduy5YtY86cOYwcOZK8vDwqKioIDw9nwYIFXHzxxXz44YdcdNFFXHPNNSQnJ58xtl27dnHgwAEiIyPJzc1lw4YNjBgx4rQxHD58mO+//56mpiZSU1M7lAHk5eUxZ84c3nrrLfr3789FF13ESy+9RHJyMlu2bOHGG29k9erV3HrrrSxatIh58+bx/PPPn/bxbDYb8+fPZ9WqVaSkpDBv3jxefPFFbrjhhlPe3r7a5O/vz759+3jnnXe47bbbxMlzOxs2bPhZmRpms7mD33xUVBRms5nLL7+c//znP+Tk5HD33Xfz2WefMXDgwDOuch88eJD169ej0Wi44ooruP322xkxYgQlJSWMHz+eQ4cO8fDDDzNixAj++te/8uWXX/L666+f8lhyuZykpCT27Nnzqz+DnVH58t4O/+sGhaMbHH7a7c+0zenozuMoKCiIIUOG8PXXXzN16lSWLVvGrFmzqKmp4dFHH2XlypXodDqefPJJ/vWvf3Hvvfcye/Zs3n//fbKzs2lsbESr1fLII4+wfft2nnvuOQBuvvlmBgwYwCeffMLq1auZN28eu3fvBjp+TtasWXPSc7BYLNxzzz3s2LGDwMBALr74Yj755BOGDBlyytunTZtGS0sLgwcP5umnn+aRRx7h4YcfFmNpZ8OGDSe9D8899xzvvPMOgwcP5p///CeBgYGYzWZycnLEbdrHxRVXXMEVV1zBK6+8wpNPPskLL7zA1VdffUbnj9LSUjZu3IhCofjN543AwEDsdjs1NTXnXeNNl8tFZWUlCoWCkJAQXnrpJbGca+3atYwYMYJRo0Zx6aWXEhERQURERAex66eCmMT5xaZNmyguLqasrIyGhgYyMzOZMWPGKbeVyWRMmzbt3AYocdbweDxUVVWJ/TuKi4vF0iVfX18yM72Terlczu233y4uFsnl8l4jfhRs2UhrcxOZF41n2YP3oPHz47L7/w9BEIjq0w9jcirG5FRCYxMAbzlBVyE4nbTu20fLeq/g0bpvH3g8yPV6tDlDCV74R3S5ufjExHRZjBJeIVmpVKJWq8nPz2f58uW0tnqzNNqb/1qtVrRaLbm5uYwaNUosXcnfvJ6jVZUkDMwmIjGFiMRkVGrfrnw6vZoeL4D0JNpT96uqqhg+fDiXXHLJaRvILV26lOXLlyOXy5k5cyYffPABixcvJisri2PHjrFixQpWrlxJdnY2mzZtOuPjDxkyhKgor7dzVlYWRUVFZxRAJk2ahFqtRq1WExYWJpbTVFVVMXXqVD7++GP69OlDc3MzGzdu5PLLf/yCaG+GtWHDBj766CPAm65+zz33dPp4eXl5xMfHi2UQ11xzDc8//zwXXnjhKW9vF0Dmzp0r/r799ttPOm5ZWdlvuthXKpW89957gLdZ4Pjx4/n000+54447KCkpYd68eUyZMuWk/aZMmYJGowFg5cqVHDx4ULyvsbGR5uZm1q5dy8cffwx4X+/AwMBO4wgLC8NisfzuAkhP4myPo/T0dLEMpl0Aef3119m8eTMHDx4kNzcX8NZsDhs2jLy8PDEdGMDPz++Ucaxfv14cB2PGjKGmpobGxkag4+fkVGzbto3Ro0eLn+Err7yStWvXIpPJTnn7tGnTkMvlzJ49G4CrrrrqlBObsrIy0tPTxf8XLVrEAw88gEwm44EHHuDOO+/kjTfe6DQuf39/vvzySwDq6up44oknWL58OQsXLqSuro4777yTYcOGnbTf5ZdfjkKh+N3OG+3jojcLIIIgYLfb8fX1ZeXKlRQVFVFWVobb7RYnrrGxsQQHB6NQKLjrrrvEicrgwad0gZM4zzl8+DBNTU1ERUUxZMgQqaFtL8bj8YgixrfffsuuXbuw2WwAGAwGsZQlNjaW0NDQDtmxPb1/h7WxgfIj+d4mpQV5CB43lz/wNw5v+IG6MjOZF41n2OVXoGwrpZ1wU/coAXSUlIj2tNbNW/A0N4NcjqZfP0JuuAHdiFw0/fohO4e2uRI/4nK5OpSWms1m6uvrmT59Ov379ycwMJC0tDRMJhO+goft77/NJXNmiZnoP828TckZQUrO6edk5xJbi5Oq401o9D6ERJ26B1tPpscLIKfL2FCpfU97v9bP/4wZHz8lIyPjpKaZ7SiVyg52bu1fLj8lNDSUgQMHsmXLlk4vOPbt20dBQQHjxo0DvJOt+Ph4Fi9eDHjT22fMmMGMGTOQy+V89dVXZGVldRob0EG1b09X/2ncP425s338/f2JiYlh/fr19OnTB4/HQ0BAgLii/VPOtqf0icc/1WNpNJoODTA7w2QydViBLy0tZfTo0R22eeGFF5g3bx6bN2/G39+f999/nzFjxpxSADmxLtbj8bB582Z8fX+9omuz2U47Uf61hF3/y1I4f+n2P6U7j6P09HSmTp3K7bffzs6dO7FarQwaNIjPP/+ccePGsXTp0pMe47dyLuqnOxsXJ76+4eE/ZvQsXLhQbMZqMpk4fvy4eF9paSkmk6nDsf7v//6P+++/n6VLlzJixAguu+wyZsyYcVJDWfjx+f5e542zNS66msLCQqxWKxkZGbz55pv4+Phw1VVXUVFRgVwuZ+jQoZhMJlHYPrF5bm9ZpZX4daxZswaLxcIVV1zR6Tbz5s2Tmtn2Uux2OyqVCrlczpYtW/jhhx+48847USgU6PV60tPTiY2NJTY2toN9dU/H43YjVygo2r2Dozu3cdGCG9j4v/+y57uvkcnkhMTEYkrrgyAIjLv+ZtQab7Zi0uChXRw5uJuasG7ZQvP69bRs2Iiz7TtXGWnEb8IEdLm56HKGopDK0M45brebyspKzGYzAQEBJCUlYbVaefPNNwFEW+/s7Gzx2ig0NFQs322qqSY/JBSBzptIdyW2ZieVJY1UlTSJP43V3mvDjFEmRl+R2sUR/v50S1lXJpNNlslkr/ycCeu5ZsyYMdjt9g7uE3v37mXdunXExsZy8OBB7Ha72Cn7VFitVnbt2kViYmKnj7N06VIeeughioqKxB4E7XZjGzZsEF0PHA4HBw8eJDY29rSxnY64uDh27NgBIK64ngkfHx+WL1/OO++8w3vvvYefnx/x8fF88MEHgHe1cs+ePQDk5uaKjS7ffffd0x43NTWVoqIijhw5AsB//vMfLrjggk5vb+f9998Xf59qxTk9PV3c93SMHz+eFStWUFdXR11dHStWrOjQDLOuro4vvviCefPmYbVakcvlyGQyMcXtdFx88cX8+9//Fv9vn/SNGjVKzC75+uuvT+tokZ+ff06dc84W3XkcgVcYufDCC1mwYIGYXZSTk8OGDRvEz1FLSwv5+fmkpqZSVlbGtm3bAGhqasLlcmEwGDq4IYwcOVL8/K9Zs4aQkJBOs0V+ypAhQ/jhhx+orq7G7XazdOlSLrjggk5vB6+40C4yvffee6fM9vrpuCgrKxP/Xr58ufhZmzJlCsuWLcNut1NYWEhBQQFDhgwRty0oKBDFwl8yLn6P84YgCJSXl/doe8X2DvAbN27kgw8+EJ/31q1bxc//wIEDxbT0K6+8UizhysjIwN/fv8til+garFbrae9Xq9VotdrTurZI4kfvoaWlhUOHDvHtt9/yyiuv8MQTT4jn89DQUPr164fD4QC859apU6eSlZVFYGBgjxU/BEGgobKCwxvX4vG42fPdVzz3h9k4bTZqzMc5snUjdmsL/S+exKwHH2fxW+8z76l/c9GCRchkMnx1emRdmN0iuFy07t5N1fPPU3TFleTnDKN08c00fvY56qQkwv/yFxK+/oqkVasw/t8j+F0yXhI/ziGCILBixQpef/11Hn/8cV5++WW++OIL9u/fD3ivX6666ipuXrQI1d7NJBt8yc3NFTM8TsQQHMKMex/CmNT1QoK10UHxgRq2f1XE1y/t450/b+T1u9bx+bN72PzJMapKmgiNMZAzLYEpt2SRMyWhq0M+K3TLDBBBED4HPh88ePDCro7lp8hkMpYvX85tt93Gk08+ia+vL3FxcSxZsoTo6GhmzZpF3759iY+PZ8CAAR32vfLKK9FoNNjtdubPn9+hjCEzM1NMM5w1axaffPLJSRaa06dPZ9myZRiNRhYtWoQgCHg8HiZNmsTMmTNPG5vZbO70OT344INce+21PPDAAydlO5wOnU7HF198wbhx49Dr9bz77rssWrSIRx99FKfTyZw5c+jfvz/PPPMMV1xxBU8++eRJzQzz8vLE1UuAp59+mjfffJPLL79cbHZ6ww03oFarT3l7O3V1dWRmZqJWq09aoQevyHDnnXciCAIymYxt27Yxffp06urq+Pzzz3nwwQc5cOAAQUFBPPDAA2I5w1//+lexISrAI488wv33349cLmf8+PE8//zz9OvXr0MsnfHss89y0003kZmZicvlYtSoUbz00ks8+OCDzJ07l4yMDIYPH07MCTWcEydO5LXXXiMyMpKKigo0Gg0RERE/+z3qrnTncdTO3LlzxW3BexH51ltvMXfuXLFM49FHHyUlJYX333+fm2++mdbWVjQaDStXruTCCy/kiSeeICsri/vuu4+HHnqIBQsWkJmZiVarFS2WT8WqVas6jIsPPviAJ554ggsvvFBsdto+ljq7XafTsXXrVh599FHCwsJEkfBEJkyYwNVXXy3+/6c//Yndu3eLzZFffvllwJuxM2vWLPr06YNSqeT555/vMHm6//77eeyxx8TXbdq0aTzxxBOi7fTp+DXnjaysLFFA3LFjBzk5OT2mMXB7KnphYSFHjhxh3LhxfPvtt6II3Z5dJwgCEyZMEDM5srKyujBqie7EunXrWL16NX/+859RdZL+fqqFAIneQ319fYf+He0W8AqFQnR1au/FlJCQQEJCz5/E2K1WlD4qqooK2bz8fcoK8rA21AMQEvUcobHxZI6bgMvpYMCEyQyaNA2A0Jju41DjNJtp3rDB28tj82Y8jY0gk+GbkUHwH/+IfkQumv79kZ3B2U7i96O5ublDGYuPjw+zZ89GJpNx/PhxBI+HzIwM4pOSMJlMHcrU2w0X+l00ntDY+K56Cp3S0mDvkNVRVdJEc51dvN8/VEN4gh99R5sIjTEQGm3AV3d+lFTJTrc60NUMHjxY2L59e1eHIdHNOdHF5nTceuutTJ48mbFjx56jyH5fnn76afz8/Lj22mu7OhSJHoBer6e5ufmM202fPp2nnnqK5OTkcxDV78+tt97KlClTuqWLiSAIogVteno6u3bt4rvvvuOOO+5g+/btrF27lttuu43a2lqampowmUzo9b2v1lbi59PY2EhZWRnx8fGd2nubzWZKSkoYOHCgVOp0HiAIAlVVVSgUCoKDg6moqODFF18EvJk+0dHRYjlLZGRkjxGDz0RrcxMFWzYQlzmQhqoK/vfIn5n1wGMo1Wq+fv5pIpNTiUhqa1QaE4e8G2Y0uZtbsG7dKrq1OIqKAFBGRKDLHe51axk2DOVper9J/H7Y7XaqqqrEBaaPP/6YvXu9JgAymYywsDDi4+OJVMk4fmAvZUfzaSgvI2XYSCbf1nkfsq5GEARa6h1UHW+iqvjHUpaWBm/WFzIICNN6RY4YA2ExBkKi9ai1vVvskMlkOwRBOGUTtN5xlpSQ+Bn8+c9/ZsuWLV0dxq8mICCgw2q9hMTvQXuqdE8VQPr27dttxI/W1lZUKhXl5eWsW7eO0tJSWlpaALjxxhsJCQkhMzMTp9PJkCFDyMnJQS6Xn9FNSqJ3U1FRwapVq7BYLKJo+Yc//KHT3kYmk+mkHjwSvQe3201ZWRkOh4OEhAQ8Hg+vvfYamZmZXHrppYSGhjJx4kSio6MJDw/v8U1KAZrraik7kkd5gbdR6aBLpxFkiua7V57j4utvIWnIMIZfdgWG4FACIowsePqlrg75lAhuN7aDB72Cx/oNWHfvBpcLma8v2iHZBF4x1+vWkpDQY0uPehK1tbUcO3ZMzO6oqqpCEATuvfdefH19SUlJISIiApPJhNFoFEXnDx79C7Xm40QkptBv9Dii+vTr4mfyI4Ig0FzXMbOjsqSJ1sYfxY7AcC2mtEDCYvwIjdETEmXARyNN+U9EygCRkJCQkJD4FbS0tLB//35SUlKor6/n7bffZv78+SgUCj755BOxQanJZCI8PLzXrMxK/DIEQUAQhE4nqtXV1SxbtozIyEiMRqP4u7MMEInehcPhoLS0VCxnKS0txel0Eh4ezqJFiwA4cuQIwcHBp3WJ60m4XS52ffM5ITFxRCQm8/yCOQDIFQrC4hIYMn0WSYNzqC+3EBAR2a3FAmdZGS0bN3pFj42bcNfXA6Duk44+Nxddbi6agQORS+P5rCEIArW1taLQMXz4cPz9/dmyZQtff/01Wq2WyMhITCYTzuoKXJUWJp7G7cdpt3ULC1pBEGiqsbVldrQJHsebaG1yAiCTQaBR1yGzIzhKj4+vdK0BUgaIhISEhITEr8bj8XS4uDKbzYwcOZLQ0FC+/vpr1Go1KSkpjBkzBn9/fwIDA7n55pu7OmyJbkBzczMvvvgio0ePFntL/ZSQkBDRmUri/KCoqIj8/HyKi4spKysTnc8iIiIYMGCAaEvbTnuvgZ6GIAjUl1twO50ER8fy/kP3EJnah5Fzr2Hrpx+SPmI0cZkDuPj6WwiOiiYsLlG0owUINHa/TCeP1Yp12zZvL48NG3EcPQqAMjQU/ejRXreW4cNQ9mJb9q6mvZdWZWUl3377LWazWXS0UyqVpKSk4O/vT9++fUlJSengdLRl+f8orKzA43Ejl5+6bKorxA9BEGistp2Q2dFIVUkztpY2sUMuI8ioI7ZfCGFtgkdwlB6VT/cr/eoJSAKIhISEhITECbjdbgRBYO3atURHR2MymXjuuecAUKlUREZGIpfLCQoK4rbbbsPf3x+ZTMaoUaO6OHKJc4kgCDQ2NuLxeDpdmdfpdKSlpREsTYbOa8xmM3v27OGSSy5BLpdz4MABdu7ciclkYvjw4cTGxhIdHY2vb9evOv8W3C4nCqWKnV9/RtHuHZQdycfW3ETCwGym3/MgYXGJBIRFIJPJuPaZV1BrvQ1K+425uIsj7xzB48F++LAoeLTu2IHgdCJTq9EOHkzAzJnocnNRpyR360yVnordbsdisWA2m8Xfw4cPZ+jQofj4+NDc3EyfPn3asjsq2fv5B0QZjYD3/KvTdWyCO3T6LIZOn9UVT0VE8Ag0VLWKmR2VJU1UH2/CbnUBIJfLCDLpiM9qFzv8CI7SoVRJYsfvhSSASEhISEict9jtdsrKylAoFJhMJp5//nlSUlK4+OKLRWeW5ORkZs6cSVhYGKGhoR1KGQIkW8LzmldeeYWkpCSmT59+yvtlMhmTJ08+x1FJdBWCIFBdXS2Ws4wYMYKwsDBqamrYvXs3Q4cOJTg4mNGjR3PxxRd36uLTU6gpLaG+opzEQUP48tm/01BVwRX/9w+OH9hHY3UVSdnDMCanYErtA8CYP1wv7tsufnRHnBWVJ5S1bMRdWwuAOjWVwKuvRpc7HO2gQch7uGDV3XC73VRUVCAIAiaTCYfDwZNPPilmSAUEBGAymUR3xoCAALFMDKD04H6qk9Nw2Kyo21yQuhrBI1BfaRV7dVS3ZXg4bG4A5EoZwZF6EgeF/ZjZEalHoer5vX26M1IPEAkJCQmJ8wK3243VasVgMPDdd99x5MgRKisrEQSB1NRU5s6dy6pVqwgPD6dv37643e4Odr8S5wft7j0WiwWPx0Pfvn073TYvLw9/f/9eYU8u8ctxu92Ul5eLgkdJSQlWqxXwrj5PnTqVlJQUXC4XMpmsx55PvL0Iqik/koelII/m2houvfVPfPvSMxzZvoUbX32Xg2tX09rYwODJM05bXtAd8dhsWLfvaGteuh57QQEAiuBgdMOHox/hdWtRhYV1caS9j4MHD1JcXIzZbKasrAy3201iYiJXX301tpZmvln+MY76WlrNJdQWH2PGfQ8R2y+rq8M+JR6PQH259YTMjkaqjzfjtHvFDoVSTnCUXuzXERpjIChSh0IpiR1nA6kHiISEhITEecnRo0dpaGhg4MCB/Pe//8XlcnHttdfS1NSEXq8nNTWVqKgo0YnlREeZnjpZkfj1fPfdd+zcuZPW1lbA25/jdAJIamrquQpNohsgCAIymYympiaWL19OaWkpDofXfSEwMJDk5GSxf0dwcLBYEtETGyDXmI9TuHMbgy6dzqYPl7Lpw/cAUKhUhMUn4nI6GTptFjkzvA1MMy748dzZ3cUPQRCw5+fTst5rT2vdvh3B4UCmUqEZPIiwqVO8ZS2pqch6gctOd6CpqUnsodXa2sqll14KwNatWzGbzRiNRoYMGSI2Dwewt7Rw9PP/4aPREJ6QzKBJU9EHdo9yQo/bQ135TzI7SptxtYkdSpVX7EjLiSA01it2BBp1KBTS56k70PPOyBISEhISEj+htbW1Q5NSm83GggUL2LdvH8eOHWPgwIEMGTJETKWdMWNGF0csca4RBIGmpib8/Pw63cZgMJCWliY6sYSHh5/DCCW6Ex6PB6vVil6vRxAE3nzzTUwmE+PHj0er1WK32+nfvz8xMTHExsae9nPVnRE8HmotpfiHGyk9uI+1777JZX95FEveIX747xskDRlO/IBB+OoNRCanEhoXj0LpLd0JiDB2cfQ/H1d1tVjW0rxxI+6qagB8khIJnDsX3YhctIMHI9doujjSno/dbketVgOwadMmNm3aRGNjI+AtCzQajTgdDrZ/9hGDU7zZHqdacPALDWP+P18kKNLUpUKU2+2hrqzF25y0rWdHTWkzLqf3ekLpIyc02kCf4UbRkSUwQotcEju6LZIAIiEhISHRo3C5XCiVSo4dO8b+/fuZPHky69atY+PGjYB31T4qKgqPx8PFF18s2ommp6d3ZdgSXcyaNWtYt24d9913X6e9F3Jycs5xVBLdhYaGhg4iqsViISQkhOuuuw6ZTIbJZBKb2SoUChYuXNjFEf862stZ9q36BktBHuVH8nG0WpnzyN/x0WjR+gdga24mJWcEiYOHovXzJyA8AmNSz8p28tjttO7c6RU8NmzEfugQAIqAAHTDh3vdWnKHo5LK134TLpeLiooKsUGp2WymqqqKO+64Az8/PzQaDTExMZhMJkwmExEREfj4+CAIAntXfk36yAtRDB95ymPLZDKCo6LP6fNxuzzUWlrEzI6qNrHD7fKKHSq1gpBoPRkjTWJmR0C4FrlcaoDbk5B6gEhISEhIdFs8Hg81NTWYzWYyMjLYv38/X3zxBXfccQeHDx/m+++/5/rrr8dms9HU1ERkZGSPd1KQ+OW0tLRQWFhISkqKKHj9lPYL9P79+3e6jcT5Q2lpKYWFheKkrampCQC5XE5ERAQmk4mYmBj69evXxZH+etwuF5WFR9EHBeO02/n4iQe58JqFBIQbefvuxYTGxGNMTsGYnEb8gMFo/fy7OuRfjSAIOI4cEd1arNu2IdhsoFKhHTCgTfDIxbdPulTW8is50RI+NjaWgIAA9uzZw/LlywFv35t2ocNZfARfHxUj5szr9HgupxNlFzYCdjs91FiaqSxuEvt21Fia8bi8c2MfX4WY0dH+ExCmRSaJHT0CqQeIhISEhESPoKmpCbVaTXV1NStXrsRsNmO32wEIDg4mIiKCnJwcBEFgwIABDBw4EJlMhsFgIDQ0tIujl+gqSktL+fDDD1mwYAExMTGn3CYyMlLs9SJx/lFUVMTevXu59NJLkcvl7Nq1ix07dhAcHEx8fHyHFeqe2LNDEAQaKisoO5JHWcFh4jIHEpGYzHt/uZMLrlpA/4snEhaXgFqjIygyipvf+h8qdc8Wi111dW1lLd7SFldFBQA+8fEEXHaZ160lewgKffd1nOnutLS0sGnTJlFAbv8+vvTSSxk8eDAJCQlcfvnlmEwm0RIeYMXLe7DaTi8UnEvxw+VwU2NuoaqkUczsqLW04HF7xQ61VklItIH+F0aLmR3+IRpJ7OilSBkgEhISEhJdRktLC7t37yYlJQWbzcbrr7/O3LlzCQwM5OOPPxYnJVFRUYSEhHSwoJXo3QiCQG1tLWVlZVgsFvr164fReOqeAzabjdraWsLCwnrk5FXi96H9M3NiKcvkyZMJDw9n9+7dfPfdd1x33XX4+/vT2NiIUqlE203sMn8Nxft2o1L7EpGYzKuLF9BcWwOA0kfNsMvmMmTqZRzbuY3whCR0AYFdHO1vR3A4sO7a7XVr2bAB28GDIAjI/f3RDRuGLnc4+uHDUZlMXR1qj8Nms3UoY0lISGDIkCFYrVb+8Y9/EBoSgsHXB5XDhqOqHKG5iXlPPtPVYZ8Sp8NNTWnHzI7ashYET5vYoVO2ubD4iZkdfiG+ongj0TuQMkAkJCQkJLoUj8dDRUVFh4nJ8OHDSUxM5LvvvkOtVpOZmcn48eMJCwsjMDCQG264oavDlugimpqaeO6558TVRoVCQVhYWKcCiK+vr5TdcR7S0tIink9KS0uxWCyig49KpfI2W3Q6AcjMzKR///7iJKcnNS31eNzYmprQ+gew5p3XUGt1DLtsLt+9+hxhsQlMufPP9BtzMbqAQCKSUgmJjkXRJgQmDMzu4uh/PYIg4CgsEu1pW7ZtQ7BaQaFAk5VFyM2L0Y8YgW9GBjLJtetn43K5aGlpwd/fH0EQeOWVVygrKxPvDwoKEjPptFot9913H1s+WsqW5f9DJpd7S6eSkvG43ci7+HV32FxesaMtq6OqpIm6shba1/d99SrCYgzE9QsWMzsMQZLYcb4jCSASEhISEr8rgiDgcrlQKBR89913mEwmUlNTefXVV/F4PGg0GkwmExqNBoPBwJ/+9CdxFXbYsGFdHL3E2UYQBGpqarwN7oJPbWmo1+vJysoiPDwco9FIWFiYZEt8nuN2uyktLUWn0xESEoLFYuGVV14BvM0Sw8LCSE9PF7PGQkNDO3xmelr2WPG+3RTv2015QR7lRwsIT0hi9kNPYG2ox+1yATD1rr9gCA4BYPjlV3ZluL8b7vp6WjZvbmteugGXxTsxV8XGEDBtKrrcXLRDh6LQ67s40p5DTU0Nx48fFzM8ysvLiYiIYOHChd4GvxER+Csga/hIYuLiTsqKUqlU9B09joSB2YTGJaDyUXfJ83DYXFQfb+qQ2VFXYYU2sUPj50NYjIGErFAxs0MfqJbEDomTkAQQCQkJCYnfhNVqxWw2o1AoSEhI4LnnniMuLo7JkydTUFCAUqmkb9++zJkzh5CQEAIDAztckPTkFHSJX8cbb7xBSkoK06ZNO+X9MpmMCRMmnNugJLoNHo+HqqoqzGYzarWajIwMBEHgnXfeYciQIYwfP57Q0FDGjRuHyWTCaDSKtps9DafDTn2ZhdDYeLZ88gHHD+zlsvv/jwNrVpK3aT1hcfH0vXAcUekZAEy8+S5x39CYuC6K+vdDcDpp3bNHbF5q27fPW9ZiMKDLyUF33fXocofjE31u3UB6Ko2NjZjNZqqrqxk50uuu8t1333H48GF8fHyIjIwkJyeH6BNez/QoI5+89yojR47q9Ps4IMJ4Tm2P7a0uqk9wYqkqaaK+8kexQ+fvQ2isH0mDwgiN9SMsxoDW30cSOyR+FlIPEAkJCQmJX4TT6USlUvH999+zf/9+amq8dedxcXHMnz+fDRs2EBAQIE5apAuS84vDhw/jcDjIzMzsdJsjR44QEBBASEjIOYxMojsiCII4aSstLRUtaNtLVxISEpg3z+skUVRUREhICPoeuvovCAJ1ZRbKj+RRVVLEqCv/wJp3XmPvym9Y/Ob77Fv1Lea8g0xcfCetTY34aLQoe5ljkSAIOEtKfnRr2bwZT0sLyOVoMjNFtxZNZj9kUj+fn0VBQQE7duw4yc3o7rvvxmO38f2Hy0gcmE1q1sBTZkI57TZsLc0YgrrmfGxrcYoZHe2/G6paxfv1geqT3Fh0/j1T8JQ4d/S4HiAymWwyMDkpKamrQ5GQkJA472lubqa6upq4uDg+/fRTzGYzN954I1arlaCgILKysjCZTGIPhtzcXHFfSfw4/9i5cyeNjY2nFUCk7/fzl3YBFeDrr7/mwIEDNDc3A95eLxEREQwYMEAsZQkKChL3jYuL64qQfzV2awuW/MPE9O1P/pYNrH79RWwt3ufqo9Ew+NLpZFxwEdEZ3rGSNX4SWeMnAaD1D+iqsH933I2NbWUtXrcWZ2kpACqTCb9LL0WXOxxdTg6KHtSX5VzjdDpP6qM1e/ZswsLCaG5upqqqSnQzioyMJCIiApVKhdXp4Oia74hPTum0DEyl9j1njkC2ZidVJU1UljSKmR2N1TbxfkOQL6GxBtKGGb09O6INaP16lwjYHREEgYaKciwFhykrOExKzgii+/RcC/AzIWWASEhISEh0oKWlhaKiIiwWC2PHjuWbb75h586d3HPPPeTl5VFfX8/w4cMlceM8wePxUF1djcVioaysjObmZi6//PJOt29pacHX11fq2SGBy+WioqICo9GIXC5n1apVbN++nT/96U/IZDJWr15NfX296PQUHh7eY1183C4nIKOuzMy2Tz8kd/bVlB3J44slT3LV40vwuN3sW/0txuQ0jEkpBEVFI5f3zjEiuFy07tsnCh6te/eC241cq0Wbk+N1a8nNRRUbK32PnAKPx0NNTQ2+vr4YDAaKiop455138Hg8AOh0OoL9/Yjx09FqOU5030yyLp7U+fG6qFlpa5PDW8JyQmZHU+2PYodfiK+Y0REW40dIjB6NXhI7zgUOWyvlRwooKzjcJnrk0drYAIDKV8Poq68lc+wlXRzlb6PHZYBISEhISJw7Wlpa0Gg0HDlyhJUrV1JZWQl4G5/l5OSQnZ1Nv379kMvlZGRkdHG0Euea1atXs379esD7mYiIiMDlcnU6UdXpdOcyPIluQrsFbXsZS3uzRbfbzU033URoaCixsbGoVCrcbjdKpZIxY8Z0ddi/GkerlcLdOygryKOsII/KwqNMvet+tAGBFO/bTb8x44npl8XlDzxGkCkKldoXY3JqV4d91nCUltKy3mtP27J5M56mJpDJ8O3Xj+DrFqLPzUXTvz+ytuwfiR9xuVzk5+eL48ZiseBwOBg7diwjRowgNDSUYcOGiVlR7/1pMXX1ddQB/mHhRJzhc3UuxI+WBruY0dH+01xnF+/3D9UQnuBH3wtMYmaHr076LJwLBEHA0WpFrdXhdNhZ+pe7qC4pRhC8glpgZBQJA7IxJqcSmZJGcHRMrxVn25EyQCQkJCTOM+x2O8eOHSMmJobS0lKWLl3KwoULcblcrF27lri4OOLi4oiMjJRW8Xs5TU1NHD16lIyMDLEs4aeUlZVRUVFBZGQkISEhPc5NQ+LsUVtby+7du8WJm83mXd1VqVRERkaKE7bExER8fc9Niv3ZwOmw43Y6ETweVrz8LBkXjCU8IYlXbpyPQqUiLD6RyORU+o4eR3B0LND7y//czc1Yt24VRQ9HcTEASqNRzPDQ5uSgDAzs4ki7F62traIbi8FgYMCAAbhcLv72t78BEBIcRLC/PykZfYmLiyPwFK/fofVr8NXpCU9MRuvnf66fAi319rbMjkaqjjdTVdxIS4PDe6cMAsK0J2R2GAiJ1qPWSmLHucJutdJQWU5YXAIA/73vdgzBIUy9634Avn7un/iFRRCZnEpEcioavaErwz1rSBkgEhISEucxVquV4uJiioqK6Nu3L0qlkvfff5/p06eTmJjImDFj0Ov1+Pv7c/XVV3d1uBLnkNLSUj755BOCg4M7uAKciNFoxGg8d93/Jbof7c2Mm5qa+Oabbxg4cCCJiYk0NTWxbt06wsLCyMjIEAWPkJCQHi2eNtfWYMk/hNY/gPDEZF5YMJfsqTPJmTmHhsoK7NYWDMEhXPX4EkJiYlEoe//kTnC7sR04INrTtu7eAy4XMo0G3ZAhBF55JboRufjEx/d68efn4vF4RMH466+/5siRI2LTcIB+/foxYMAAlEol119/PUFBQXy55Alqj+xnwFWdfxenjxh9tkMHvOO+ue7kzA5r449iR2C4FlNaIGExfoTG6AmJMuCjkaaX5wrB46HWYsZScMibjZZ/mOrSErR+/tzw8n+QyWT0HzcBH41G3GfC4ju7MOLugZQBIiEhIdHLaG1txel04uPjw1tvvUV5eTkASqWSiRMnkpWVRWlpKZGRkT223l7izDQ2NrJu3ToGDhzYqYBht9tpbGwkODhYyuyQALyTtsrKyg7NFpOTkxk7dixOp5MXX3yR0aNHk5mZidvtxu1249ODnUo8bje25ia0/gF898pzFO3dRWNVBQBpuRcw6Za72fHlJ0QkpWJKTe/iaM8tTotFdGtp2bQJT4O3R4Bvnz5et5YRI9AMyELeg9//34v2Xkknjhu3282NN94IwCeffEJDTQ1qwUX2hWOJjIxEc8KktJ2q4kLkCgXBUTHnNH5BEGiqtXlFjvaeHSVNtDZ53ZhkMgg06jpkdgRH6fHxla4hzjUVx45wdMcWr+BxJA97SwsAap0OY3IakclpGJNTie2Xhew8/l6XMkAkJCQkejn5+fkoFAri4+NZsmQJmZmZTJo0iZCQENLT04mLi8NkMomCR0zMub24kjj3yOVy9uzZQ2xsbKcCiFqtJjQ09BxHJtGdqK+v7zBpO9GC1tfXF5PJRHBwMOAtbbnlllvEfRUKRY/M9Cg9uJ+WhjpSh41k2UP3oFL7cvlfHsVptxGRmMzACVOITE0TU8gHTZrWtQGfIzwtLbRs2yY2L3UcOwaAMiwMw5gxXtFj+DCUJzjznI+caN2cnp6OTCbjyy+/ZMeOHYD3vNpeAtaePTVt2jS2fvoh65a+zbS5V+J7CvEDIDQ2/tzEX207IaujkaqSZmwtbWKHXEaQUUdsvxBCow2ExXrFDpVPzxvrvYGKwqPs+uZzRl/9R3z1egp3bWfTR8sIiY4lNWckxuRUjClpBBlN57Xg8UuQMkAkJCQkehg2m42SkhIKCwtRqVSMGTOGl156Ca1Wy7x589izZw8hISGYTKauDlXid0QQBMrLyykrKxMdWfr27cuwYcM63efEFGwJCYCSkhIaGxvp27cvAM8++yy1tbUoFAqMRqNYxtJuQduTyxkEQaCuzIIl/xCW/EPYrVYm33YPny95koqj+fzx36+Tt2kdcrmC5KHDuzrcc47g8WA7eMjbuHTDBqy7doHTiczXF212ttjLwycpqUd/Dn4PqqurOXjwoCgUtls333jjjQgtTRzYuQNLSTEXTL8MU0zsKc+7tuZmZHIZau25axQteAQaqlvFzI7Kkiaqjzdht7oAkMtlBJl0YlZHaIwfwSYdSknsOOe0NjVSdsRbxmIpyGPI1MuI7ZdFyf49fL7kSS778yOEJyRha25GrpDjo9F2dcjdGikDREJCQqIHY7PZqK6uJioqii+++IIdO3YgCAIKhYK0tDQAZs2ahcHgbWTVv3//rgxX4izy9ttvY7PZUKvVGI1GtNrTXwBJ4sf5i8vlory8HLPZTGVlJZdeeikymYwdO3Zw9OhRUQCZNGkSvr6+PdqC9kSqjxdTsn8vAydM5of/vMaOLz8FvOnhprQMBI+H0fOuFSehqcNGdmW45xxnRYWY4dGycSPuujoA1GlpBM272uvWMmgQcrW6iyPtGpxOpzhuzGYzw4YNIzIyksrKSlavXk1ISAiJiYnejEq7jffuWITb6XU78dXpUU6e0ul511evP6uxCx6B+kprx54dx5txtLaJHUoZwZF6EgeFtYkdBoIj9ShU0vfEucbjdlN9vJiyNgtaS/5h6srMAMhkckJi43A5vJ+r6D79uPHVd0UR8mx/js4HpAwQCQkJiW6IxWKhoKCACy64gC+//JI9e/Zwzz33sH//fmpra4mLiyMqKqpT5w6Jnse+fftwuVwMGDCg020KCwvx8/MjMDBQEjckRDweD7W1teKkrbS0lPLycjwer82hXq/nhhtuQK/X09jYiI+PT492ZWmnqbYaXUAgxXt2semjpVz2l0fZt2oFa955lRte/g/1FeXUlBZjSu1DUGTUeZke7mltxbp9u9etZeMG7AVHAFCEhKDPHe4taxk2DOV5WArn8XhwOp2o1Wpqa2v53//+R2Vl5QnjRse4iy6i/4CBOJ1O3G53h3HTUl/Hts8+JCIxhYjEFPzDI85ZpozHI1BfYe3Ys+N4E06bGwCFUk5wlP6EzA4DQZE6FMrzbwx0B6wN9TjtNvzDImhtbuLVG/+A0+51zdL4+ROZktbWvyOV8MRkfHxPXSIl8fORMkAkJCQkujF2u53jx49TVFREcXExV111FcePH+eHH35g4MCBDB48mPR0b/M9Kbuj97J3715aW1tPK4DEx5/9+nCJ7k9TUxO+vr6oVCr27dvHl19+KVrQ+vj4EBkZybBhw8RSFj8/P3Fi5ufn15Wh/yZa6uvI37weS/5hLPmHaKyqZN7fn0OuUCJXKGltbCDjgotIHzkarZ8/uoDA865xqSAI2PPyvG4t69fTun0HgtOJzMcH7eBB+E+bhm7ECNQpKedVWYsgCDQ0NJzU72bo0KGMHTsWvV6PVqtl+PDh3vIvPz/+e8f1OFMTYcBAVCrVSQsOuoBARs9beNZj97g91JX/JLOjtBmX3St2KFVesSNtaAShsV6xI9CoQ6GQxI6uwO1yUV1ShLWxgfisQQC8e/8dRCSlMvm2e9DoDQyYMJmQqBiMKen4h4WfV2OxOyBlgEhISEicY5xOJ8XFxURGRlJaWsqyZcvEXg0mk4lp06ah1+uRyWQ92l1B4ke2bdvGsWPHmD17dqfbtJe2SBdCEidit9spKyvDYDAQHBxMSUkJb7zxBldccQUpKSmYzWZ27twpih2hoaG9IjvI2y9BjrWxnpWvPsewy69EoVTy3v13og8MIjK1D5Ep6aTljkIXENjV4XYprqoqWjZu9Dq2bNyEu7oaAHVysjfDIzcX7eBByDtpvNkbsVqtWCwW3G43qampCILAk08+ic1mQ6FQEBwQQFhICAOGDCExMfGUx9i78htMaRkER53aIvxs4HZ7qCuzehuTtvXsqCltxuX0ZqUofeSERhsIOSGzIzBCi1wSO7qMlvo6LAWHKcv3lrOUHy3A5bCjDw7h+hfeAuDI9i3oAwKJSErp2mDPI6QMEAkJCYkupqWlhc2bN5Oeno4gCPz3v/9l5syZxMbGkpubS1xcHNHR0ZLg0UNxuVyn7Z/gdrtxOBy43e5OXTN6Q0mCxG/D7XZTVVUllrGYzWaqqqoQBIGRI0dy0UUXER4ezvjx40X3nnbhoydzYrPS0Jg4NH5+vHrTAsb+8SZSh43EbrXistkw9u3PwuffwBAcel4LhR67ndYdO2he721eas/LA0ARGCgKHrrhw1CFh3dxpOeWPXv2UFBQgMVioba2FoCwsDBSU1NFJxaDwUB4eDhv37EIH2c8iYlzOz1e5thLzmq8bpeHWkuLmNVRWdJEjbkZd5vYoVIrCInWkzHS5M3siDYQEKFFLj9/P/vdhSPbNnN441rKCvJE22y5QklYfAKZF43HmJxKZMqP2WdJg4d2VaiiE5G7wY67yYGn1YWn1YVMJUeTHkzzJguC04NhVBR1nx5BcHoIuiyFhm+K8L8krsviPptIGSASEhISvzNOp1MsaSksLCQrK4uMjAz+/ve/M2HCBAYMGEBhYSHR0dGoz9NGcz2d+vp68UK7rKyMyspK7rrrrjM2JZWQ+Clut5uVK1eKKfkul7dhoUaj6eDIEhUV1Ws+X067DUdrKxqDH5/962+Y8w5ha2oEIHvqZYycew3bP/+Y+AGDCYmO7eJoux5BELAXFIjNS63btiHY7aBSoR04sE30GI5venqv73Pi8XhEkdBsNlNbW8u8efOQyWR89NFHFB47RoBOS4BOy6BRozEajacUl8uP5KMLCsIQFHJO4nY7PdRYmkWho6q4iRpLMx6Xdx7m46sgtC2jo/0nIEyLTBI7upR28aBoz042fbSMmfc9hI9Gy4b//Zf9a1YSmeS1oDUmpxEen4jyLC9ieaxOPA43ygBf7CWNuKpb8Vi9gobcV4FhZBQN3xbhaXYSODOZmncP4W50ELaoP1Vv7MeeXyceS2XSE37zAGrePYTH5iL02n40fFOE4PIQcGkCrYdq0KQHn9XnczaRMkAkJCQkzjKFhYXIZDJiYmL45z//ic1mQyaTERkZiUqlwtfXl3vvvVesIU5KSuriiCV+CxaLhS+//BKNRkNkZCTDhw8XG+dJSJwKp9Mpjv/PP/8cgMmTJ6NQKMjPz0ej0TBo0CBR7AgMDOxVWQ5Htm0GICk7hzduv4GYjEwm3HQHgsdD4qAhRKaktzUrNSGTycieMrOLI+5aXLW1P7q1bNiAq6oKAJ/ERAJmz0Kfm4t28GDkunNnqXquEQSB+vp6/Pz8UCgUbNmyhZUrV+J0OgFQq9WYTCYcDgc7PvuI8m+/RNbUQAMghIYTf80fOj322SxFcDnd1JS2eMtY2gSPWksLHrdX7FBrlYREG+h/YbSY2eEfqpHEji7G5XBQWXQUS763nMVyJI9LbriN2Mwsr7AoCFgbGvDRaMmZMYfcWVf9qsfxONwIdjcKgw8OSzMeqxPfpECs+6pxlDYhtLrwWJ3ItSoCZyRT+2E+rkorYTdmUftRAa7qViJuH0Tz2lJa99d4DyoDVZQBw8gowDt2AHxTAvG09YrxGx2FZ6gRuVbZ9uP9Pgq+8sdMlRMzPnqy+HEmJAFEQkJC4hfSviKwadMmXC4XI0eO5Ouvv8ZgMHD11VczduxY/P39iY6O7rDyJDm29Azq6+tZs2YNQ4cOxWg0nnKbxMREbrvtNvz9/XvVJFXi98HpdFJRUSGWsZjNZpxOJ3fccQcymeykFembbrqpV/TtAK+9Y1VxIZb8Q1jyD6Py9eXi625m+xcfAzKSsnMYMftqDMHeEp7p9zzYtQF3EzwOB607d4mCh+3gQQAU/v5ohw9Dn5uLbvhwVJGRXRzp2cNut1NSUtKhUanVamXhwoWEhQQTEhLCgAEDxKyooKAgcdzoA4NIHJRNRGIKxqQUQmLOTeaQ0+GmprRjZkdtWQuCp03s0CkJizGQNTZGzOzwC/GVvje6GEEQaKqp8oodBXmU5R+msugo7rYMPL/QcEypffDRevvmxPbLIrZflri/XKbwZl1olDirrHianKgT/LHl1eKqtaEfFknzJgu2vDpv1karC7lWRdii/tR9VICztImIu7NpXluKvaQJ45+ysR2swbq3yitOaFSowr2fEXWsH8oAb7awfngkQpvTj//EBPwviUeuVSLzVYoCmv/4ODFOXXaE+Lc6IeBsvZw9DqkERkJCQuIMOJ1OzGYzRUVFFBUV4fF4WLBgAR9++CFOp5O5c+dSWVmJn5+f1MehF9DY2MhLL73E5MmTRfcdCYnTUV9fT1FRkThpO9GC1mAwiBO24cOHd9oDpidjyT9MVfEx+o+byOf/epz8LRsA0AcFkzAgm3HXLaapthqtnz8KpSQEg3cC5jh2zOvWsmED1q3bEFpbQalEm5WFboS3l4dvnz7IeuFnxuFwUF5ejtlsJjY2lsjISI4dO8Y777wDQGhoqDhuPJVmNvz3DW587T18dfoui9lpd1N93Ct0VLcJHnXlVlHs8NWrxMak7ZkdhmBJ7OgOCIKAOe8gKrUv4fGJNFZX8upNC1DIlGjV/hhjUwiLjicoK55QnyiUNiX6oUZatlfgKG0icFoSDd8VY91Zgcfq8mZw+Plg/PNQaj/Mx5ZXR+T9Q6n7uIDWQzVE3p9Dw4oibIdrkWtVyDVKFIFqAiYmYCuow9PsRDsgDFd1K4Lbgypch+AWQE63+Lzk5eVRXV1Nbm5uV4fyq5FKYCQkJCR+IRUVFRQWFpKTk8M333zDjh07ADAajSQkJCAIAjNmzBBXn8LCwroyXImfidPp5NVXX2XAgAEMGzbslNv4+flx9913d4uLEInuSXV1NXv27GH48OFoNBp2797NmjVrOljQRkVFiRa0vQVBEGioKCcgwsiBH1axd+U3zHnkKY5s28Sub7+g74XjyBw7geShw4lMTccv5Mfz4rnqtdCdcdXVYd282evWsmEjrrIyAHxiYwmYPh3diFy0Q4ai0PfOshabzcaKFSswm81UVlaKafq5Q7IJDQoiKiqKa665hsjIyA79sSqOBeKeMRvhHJYZOmwuqo83UVXSTGWbI0tdhRXa1o01fj6ExRhIyAoVMzv0gZKLV1cgeARkchnuJgfuejtuq5Pm8hrqLRYckS7iAzOxFzbwxddPMjDmYmSBzYTekMnUUXfge7xNkHWAzKLEtHAY9Z8dpWHncfRDjbjqbDhKmwBQBqhRx/m3ZWgokRu8/T4Mo6LQD/Vmi/pfmkDAVG+Js//FcfhfHHdSvL7JP7pWKUN+dGaSKc7dZ8fj8VBXV0dgYCByuZw9e/awevVqFi9ejEqloqqqikOHDvVoAeR0SAKIhITEeY/L5UKhUFBYWMj69euZM2cOx44d49tvv6Vv374MGjSIlJQUYmJi0JxgIyhd6HQ/HA4HNput00mnSqXCaDSecVIqvbcS4E3Jt1gsYmbH0KFDiYuLo6GhgQ0bNpCSkkJ0dDQDBgygT58+hISE9JpSlnbqy8vI27weS95BLAV52JoaWfTquyiUStQ6HXZrC9lTZjJs5lwUShWxmVldHXK3QXA4aN2zRxQ8bPv3gyAgNxjQDRuG7oYb0OUOxycqqqtD/d1o79txYhmLyWRi/Pjx+Pj4cOTIEUJDQ0lNTcVkMiE0NfDl3x8hOTKCuKxBxMfHn3TM8IQkwhPOXt8se6tLzOhod2Spr/xR7ND5+xAaYyBpUBihsX6ExRjQ+vtI3xNnAU+rC3eTA1WYFmd5C47SZjytTm/WhcNNwOREmreUYd1VSdgN/Wn4tojmDWY8sw00rzRjKPsxQ8hH8LBh+0dET0jCll/H1Dvvx7dMhafUjkwmI2rcAByW5h8FjbaeGH4Xx+I33ltC5T8uFv9x3r912REdSkraUYX92Jxa7tM9s7Wam5vJy8sjNTUVvV7Pvn37WL58OTfddBOhoaEYDAZiY2Ox2+2oVCqGDx/OiBEjujrss4ZUAiMhIXHe4XK5sFgsYklLSUkJCxcupKmpiZUrV3L55ZeLbgsnCh4S3ZNdu3ZRWFhIWVkZ1dXVpKWlMXv27K4OS6KH4Xa7qays7DBxa7egBQgMDGTcuHH06dMHl8uFIAi9rq9PU201vjo91SXFrH7zJSYsvota83E+/cejBEZGEZmSRmRKOqnDRqDW9s4shd+CIAg4i4u9gsf6DVi3bMFjtYJCgSYzE11uLvoRufj27YvsNLbZPYmWlhYaGxvFfkkvv/wyZW2ZLQqFgiA/P1JTUxh7yQTgxx5a7ThsreRvWk/8gMHoAgJPfoDfGVuLk6rjPwodVcVNNFS1ivfrA9UnubHo/CW3tl+Cx+HG0+xEGeSLs7oVp6UZTb8Q7McasB2u9dqwWl0INhchC/vRvLaUxtXHiXxwGI0ri2n6/jimx0bQuKqEplUl3oPKQK5VEvHnobTuqqR1XzUl4cew/LAPVYOS/XXr8FeFEBaWgH9UBMEJMYSmJBKSEo+il4y1n4PH40Eul1NfX8+qVasYMmQI0dHRHD9+nNdff505c+aQlpZGQ0MDR48eJS0trde4i/0UqQRGQkLivMdqtbJ9+3ZSUlJwOp288cYbAISHhzNo0CBUKhVJSUmSO0sP5MCBA5SXlxMZGUmfPn2IjZVsMyXOTF1dHW63m5CQEFpaWnj66ac7WNBGRUXRp08fTCYTkZGR6E5w21D2ggvqE5uVxvTLwt7SwtIH7mLanx4g0GhCqVbjtLUS238Ai159F62ff1eH3C1xNzTQsnmL2LzUaTYDoIqKwm/KZK9F7dChKHpJKVRZWRmFhYWiSNju0nLHHXcAkNW/Pz4NNdjKS2kxH8eGgMb4Y/nTT7MmfHw19L1w3FmJ1dbsbGtO2igKHo3VNvF+Q5AvobEG0oYZxZ4dWr+za2PaUxBcHm/jTr0Kd4MdZ1kLvqlBOEqbsOXV4TcmBtuhGlq2lYs2rB6rE+Ofh9K8wULjt0WY/i+X1v3VNH5TROQjw3GWNtGyuawt20KJTKMEl4DKqEc3JAI8App+oagidCCAfpgRnww/lH4alFo1B9et5rOb5nPtM6+gGxzBkY8P0GpoJXBgKtNTHsSYlIrG0DvG2ZkQBIHa2loUCgUBAQG0tLTw0ksvMWrUKLKzs1GpVBQXF4t9zIxGI7fccgsBAQEA+Pv7M3DgwC58Bl2LlAEiISHR63C73aJN3gcffEBmZibJycn8/e9/Z8KECQwaNIi8vDzi4uJ6rfLdW9i0aROFhYVcccUVnW7jcDjw8ZEuWiU6x2q1YjabcTgcZGRkAPCvf/2LmJgYLrvsMgRBYPXq1YSFhWEymXqdBS1Aa3MTgtuNTKHg8389TtmRPFx2OwBjFtxA3wvHsfe7b0geMgy/UKmnUWcILhete/fSst4reLTu2wceD3KdDm1ODvq25qU+MTFdHepvwu12U1VVhdlsxmKxMHHiRBQKBV9++SXbtm3D399fbFJqMpmIjY0Vx8x799+JLjCIiCSvI0t4QtJZzxhqbXJ0KGGpKm6iqfZHscMvxPekzA6Nvnd/bwiCgOBwnyBQuFDH++GssGLLr8OQa8Je2EDLljICZ6fSuq+axhXFeFqdCA5vv5XIv+bQsrOShi+Oef/e5f3b+JccbPl1NG8wi+Ujco0S/4nxuKpbcVpa0GaFisKIMtR7rXU6q1/B46G2zCy6slgKDlNzvITL//oY0X36cfzgPg78sIqRc685J9lC3Y2dO3ei1+tJSUnB7Xbzt7/9jSFDhjB+/HgEQeDzzz8nIyODxMTErg61WyBlgEhISPR6SktLKSoqorCwkJKSEgYPHszFF1+M2+1GEAS0Wi1/+tOfxJKWPn36dHHEEuDtsXBis7ufIpfLkcvlYlrnqZDED4kTcTqdoruE2WymtLSUuro6AAICAkQBZMqUKWIvGJlMxkUXXdRlMZ8NBEHgwJqV6AODiMrI5OXrr2bQpGmMmDMPgH5jLiYyJZ3IlHT8QryWtIMmTe3KkLsdgseDs6QE2+HD3p9Dh2jdsRNPczPI5fj260vIDdejy81Fk5mJrIeWRAmCgCAIyOVyjhw5wg8//EBZWZmYEeXr60tubi5BQUHY8/YxMMSPKYtv7/R4Vzz2z7Mar7XRQWXxj1kdVSVNNNfZxfv9QzWEJ/jR9wKTmNnhq+uZ7w3gdQeRgWBz4axu9ZaPtAkL2sEROC3NtGwtJ2ByArajDTSuKCL0+kxa99dQ/8mRDscy3jcEZ2kzjd8UtQkUTpxVrV5XE38f1EkBXkGjLUsDpRxtZgjqWD9kagX6HCP6YZHI5DJ0A8LQDThZLPWJ1OMT6e3FoTD4oDCc+jva6bBjPnSAsoI8LAWHKS/Iw9bSDIBaq8OYnErykGFiA+XoPv2I7tPv93xpux0nLuh88803KJVKxo4dC8DGjRsJCwsjJSUFhULBZZddRmio99wtk8mYMmVKl8Xd05AEEAkJiR7Ltm3bcLvd5OTk8Mknn1BdXU1oaChZWVkkJycjk8mYP3++uL3Uz6N7sW3bNr766qsOwtRPGTp0KEOHDj3HkUn0FE7sJ7BlyxZ2795NRUWFaEHr5+eHyWRi0KBBYilLO72p3M1pt1Fx9AjmvINY8g8RZIrmgqsWsHn5+xiTUonLGsRF195IWFwCMrmcWX/9W1eH3O3wWK3Y8/OxHc7DdvgQ9sN52PLzEaxW7wYKBeqEePwmXIIudwS6nKEo2tLJexotLS0det2YzWYuu+wyEhMTcbdlTw4ePFjM7jgxIyo8KhrlORR6WurtP8nsaKSlwSHeHxCuxZgUQGiMgbAYAyHRetTa7id2tGfcCw43rlo7qlAN7kYH9qP1bRka3kaffhfH4jQ30/BtEcHXZGA/1kDd+3lE/Ckbe2EDdR/kdziuOjUId7MDe1EDHpsbuVYplpD4xPrhPzG+g6Ah16rQDghDkxWKTCVH2z8MbX+viKEw+OCbdIrMCh8FCr/f3gfF43Zz4IdVBEZEEtWnL8011Xz0t7+CTEZIVAzJObkYk1OJTE4nKNKErJc1lP4p9fX11NXViY1///e//1FfX891110HeMUQzwnOR3/4wx86XCu1l7dI/HIkAURCQqLb43a7aWhoICgoiBUrVlBRUcHVV1/N0aNHcTqd5OTkMGPGDPz8/NDr9Wc+oMRZx2azUVZWhtFoxNfX95TbREVFMXr0aLpzKaZE96KxsRGtVotSqWTXrl18++233H777ajVahwOB76+vgwfPlycuPUmC9qfUrh7B811NfS78GI++L/7KSvIAyAoMkp0zJjz8FPo/AMAb8aHhHci6qqswn74UAexw1FUBG3nIrlej29aGgEzZuCbnoY6NQ11chLy02SrdVfsdjtlZWVotVrCwsKoqKjgxRdfBLyrxqGhoaSlpaHRaFj5+osc27GV6154s9Pj5c668qzEKQgCzXX2DlkdVSVNWBvbxA4ZBIZrMaUFEhptICzWQEiUAR/NuZ/KCE4P7gY7Cn81nlYn9mMN+KYE4m50eHtitLrEn6DLU3CWt1Dz3mHCbxmAs8JK7XuHCb99IM5KK3UfFXgPqpAh1yjRjzAhU7UJDh4BH6MOv7ExyHzkqJMCCP5DxgmChrfsRBWiQdvPmwmgDPLFNzHAe0iDDz7GU5cene0CP1tzM2UFh7EU5KHWaBg8eQYyuZx1771FSk4uUX36EhARyWV/eZSIxOTzoqlyYWEhR44cYdw4b8+bdevWceDAAe655x5kMhnp6em0tv7YkPenGR0n9qGS+G1IPUAkJCS6JdXV1eTn51NUVERxcTFyuZy7776bbdu2UV1dzcSJE3G73b2iGWFvoba2llWrVlFWVkZtbS0AV155JcnJyV0cmURPpF1Eay9jMZvNNDU1cc011xAfH09JSQl79+5l9OjRvVr4dLtcNFSWExQZxdZPP+T4gb3M/PMjfPXcP7HkH+KPz77GsZ3bADAmnz9NAH8OgtOJ/Vgh9rzD2A4dFn+720qiAFQmE+r0NHzT0vFNS0Wdlo7KFNlje8B4PB527tx5kpPRkOxsBqalEBIbz9atW4mMjMRoNHYoQSzctZ1aSykDJkxGLj97dp6CINBUaztJ7Ght8mafyGQQaNSJvTrCYgwER+nx8f39vu8Fp9vb5FOjwmN34ShuQh3vh9vqwrqjAt1QI54mBw0risT+GR6ri9CF/XA32Kl55yBhN2XhbnFS89YB799WJ7XvHv7RVlWjJGB6EngEWnZWoh8eiQywlzThmxQAchmeVidyjQqZj7wHf+bc1Bwv8Zay5B+mrOAwtZZSAGQyOYmDhzD1rr8A0Fxbgy4wqMc+1zPR0tKCRqNBLpdz8OBBvv/+exYuXIiPjw8bNmxg7dq13H777fj6+lJVVYXT6cRoNPba16MrOV0PEEkAkZCQ6HI8Hg8ymYzi4mI2b97MzJkz2bp1K9999x3BwcHExcURFxdHnz59UCi6p8e6BDQ0NPDGG29gNBrFi+vo6OhOM0AkJE7EarVy4MCBDhO3doKCgsSsjvT0dPz9e7cjSUXhUQq2bMCSd4iyo/kgwOI332ffqm8pPXyAiTffib2lBR+N9ryyeDwd7sZGbIcPYz98WMzscBQcQWgr6ZD5+KBOTkadlvqj2JGa2mPdWQRBoK6uThwvvr6+jB49GoB//OMfuN1uQoMCEZoacNVU0lxyDBx2rnvhLQzBIac/+O8cZ2P1iWJHI1Ulzdha2t4XuYwgo07s1REW6xU7VD5n/q4XPAKC3Y3H6hQzLlSRegSnG+uuSrRZYQh2Nw0rivG/OBaPzUXNe4fxWF3g8pYWhF6fieD2UP3afkKv64cgQPVr+wi9LhOZUk79Z0d/FDS0KvS5kciUcmxH6/FNCUSmkuNucKAM9EWm6t0lG+3YrVbUbQ3kv3/7VfatXoHT5s1c0Bj8MKakEZmchjE5jYjEJHw0vbPZvNVq5dixY8THx6PT6Thw4AAffPABixYtIjw8nKNHj7JlyxYuvfRS/Pz8cLlcKBQKSew4R0gCiISERLfC4/FQUVFBUFAQx48f58MPP+Taa6+ltraWb7/9liuuuAKNRoPb7e7VKew9Cbfbzbp16wgPD5fqTiV+F1wuFytXriQ2Npb09HRqa2t59tln0Wq1otgRFRVFZGRkr3VrEgSBWkspgRGRFO7ewbr33mLOI09xeMNaVr/5EmFxiUSmphGZkk5S9rBz2nuhuyIIAs7SUq/YceiwKHo4LRZxG0VQEL5paW2ZHd4fn/h4ZD1YLLLZbKKY/NVXX7Fv3z4xXV6pVJKWlsZll10GQHNzMzqdjqI9O/liyRNEJCYTnphCRGIycf0H4uN7dvphCYJAQ1XrSZkddqu3mapcLiPIpBOzOkJj/Ag26VDIZd4mny4BZ1nzj64lrS40fYLBI9CwshjDqCgQoHbpYQJnJIMcql7a2yGGkAV9kfkqqHphDyF/yEBu8KHuf3kETE9GoVPRuOZ4m6DhLR/RpAchUytw1dhQhmqQKb0ixuncSs4nPG43VSVFBEfFoFSp2LL8f2z6aCmL3/wfSpWKnV9/Rq3FTGSb6OEfHtFrJ/hNTU388MMPZGVlERUVRWlpKa+99hqzZ88mPT2dhoYGDh48SN++fTEYDF0d7q/G4XZwpP4Ih2sPE2OIYXDEKTWEbo/kAiMhIdHltLa2smfPHoqKiigqKsJmszF79mwiIiJIT09HJpORkpJCampqV4cqcQoUCgV79uwhLS1NEkAkfhE/bbgYFBQkWmoePnwYjUZDeno6gYGB3HrrrQQEBPTaC2in3Ub50QIseYfoc8EYyvIP8/nTT3DV40tQ63T4h4Vjb2mmz6gLyRg1BtV5nj3lsdmwFxz5sSnp4cPY8/K8LiwAcjk+cXFosrIImDOnrV9HKsrQ0B79GWrv23HiuLHZbNxzzz3I5XL0ej2JcbHUHzlM9oVj6Tt0WIfsyPaSsNjMLBa/8f5ZaSYpeATqK61UHfdazlYVN1JV2oKr1YVBATaZN7NjQLwBP70POo0CtUKOYZgRmY+C2vcO42/S4alqpfzfuwie1weFv/okQUMZoEYZqsFxvMlrpxqkQWXSI1MrUPj54D8p3itmaL1NPlXhOmQ+CkyP5opiRvhtg8TjBV2Wcsrn42PqvWV0vwRrQ71YxmIpOEz50QJcdjtzHvk7ptR0ojP6IZPL8bicoFIxcELvch5pbm5GEAQMBgOtra28/vrrDB06lOzsbJRKJfv27SMmJoaoqCgiIiK4/vrrRScWf39/hg0b1sXP4JfR5GjicO3hDj/H6o/hEryi5eUpl/dYAeR0nLMMEJlMlgDcD/gLgnDZz9lHygCRkOiZeDweXC4XHo+HTz/9lIyMDOLj4/n73/9OQEAA8fHxxMXFkZiY2Ktr93sSzc3N1NXVER0d3ek2TqcTlbQCLXEanE7nSRO3dgvaExsujhkzBujo4tIbaaqpRunjg625iS+f/QdVxcfwuN0ATL3rL0SmpHF0x1YSBw9F69e7y3rOhKu6ukOfDlveYRzHCqHNBUGu1aJOTfWKHG1ZHerkZOQ93N3L7XZTUVGB2WwmMzMTtVrN6tWrWbt2LeC1bm7PiMrOzhbPwbbmZpY9+CdGXnENiYN+X6cswe3BVWtDoVOBXIb1QA02rZKaylbc2ytwNNrxWF0oBYHDNg92mYwLdAoqY/zQx/uj/+E4AbNSUEcbqPjnDu9BlTLkGhWB05NQmfTUf3IEwwVRKEO1tGwpQ9M3BIW/GkdxY4ceGjJfpZSNcRaxNtRzeOM6ygq8okdDZQUAcoWCsLgEjCneUpa4/gPR6HtuVkNnHDx4ELVaTWJiIh6Ph8cff5yBAwcyYcIEBEHgo48+om/fvqSlpQE99ztLEAQqrBXk1eZxqPaQ+NvcbBa3CdGEkBaU1uEn2hCNXNYzS7vOWgmMTCZ7A7gUqBQEoe8Jt18CPAMogNcEQXjihPs+lAQQCYnehSAIVFZW4vF4CAsLY8mSJWRmZjJ27FheffVVBg0axKBBg2hsbJRKWropH374IUVFRdx555098stdomuora2loqJCzAp66623KCoqAn60oI2KisJkMp3UcLE34nTY2bdqBWHxCfiHhfPKovlcOP86+o4eyydP/R+RqelEpqSf181KBZcLR1ERtsN5JzixHMZdXS1uozQavQLHCf06VNHRvcYWs7q6mm3btmE2mykvL8fl8q62zp8/n7i4OCrKy1m+5En6DBzMqF/huiIIAoLT423yqVaAXIY9vw6VUYdco6RpbSm+fYJRBvpS+36et4dGW9mJ/6UJtOpV2N8+SFWMH+ZGB1n1NnZZXVQ6Bcb4KXEr5N4MDJ0KTW4kQf1CsK63oMkMQRmiwV5Qh0+UAblehafZiVyrRKaS+nd1B5w2Gxs/fI+Yvv2JzxpE9fFi3r7rJvSBQaLYEZmcRlhCIiqf3nG+9ng8yNvOHWvWrMHj8Ygi/AsvvEBAQABXXHEFAHv37iUkJKSDZXpPw+1xU9xUzOGajpkddfYfmz/H+sWeJHaEaM5db6BzwdkUQEYBzcA77QKITCZTAPnAOKAU2AbMFQThYNv9kgAiIdFL2L17t+jUYrVaSU1NZe7cuaxdu5aIiAhSUk6daipx7jnxAuBUtF+Em0wmSQCROCWNjY2iG8sFF1yAj48PK1euZOPGjdx3332oVCoKCgpwu92YTKYeXQP9c2htamxzPTiEJe8Qsf0Hkj15Bs8tmMOA8ZMYecV89q78huiMfgQaTV0dbpfgbm7Gnpf3Y3PSQ4exFxQg2O3eDVQq1ElJ+LZndqSm4ZuWiiIgoEvj/r1oamrCbDZjsVgwm80MGTKE1NRUjpeU8M4772CMjBSzO0wmU4fyr+9eeY6oPv1IHTj8x54YVifKEA1ygw/N68yokwNQhWio/V8+uiER+MQYqFiyE0+rC9ze6/uAaYlo+oZQ9ugWAqYmoskMpexv3r99+wRT8dp+nIJAq8NDs9XJsXoHtXYPRpWMRrkMvUlPRLiWoAR/QhP8CYzQIlf0DiGqN+NyOqkqOiaWswQaI8mdfTWCx8NLN8xj4IQpDJ0+C8Hjoam2BkNwSK/47m9paaGuro6oqCgAPvvsM8rLy7nuuusAWL58OYIgMGPGDADq6+vR6/U91lHQ5rJRUFfA4brDXsGj7jAFdQW0urz9gVRyFUkBSaQHp5MamEp6cDopgSnoVL3fUves9QARBGGtTCaL+8nNQ4AjgiAca3vwZcBU4OBveSwJCYmuQxAEmpubMRgMrF69mqqqKmbPns3BgwcpLy8nKSlJLGsBGDVqVNcGLAFAXV0dx44d4+jRoxQWFnLdddcRGBh4ym0jIiLOcXQS3RmbzSZO2tp/mpqaAJDL5fTt2xej0cjgwYPp37+/2H+gt1seH1r3PQDpIy/kP/fcSlNNFTK5nLC4RNRaHXKFgj/++zWxnCVz7CVdGe45QxAEXBYLtrw8bId+7NfhPH5c3EYREIA6LY3AuXO9mR3p6ajj45H5+HRh5L8fdrsdh8OBwWCgpaWFl19+mcbGRsBb/hVgMLBvzSoKl31BU1kVwyNiGZx0MT6xfqiMOuo+zMfW3406KYCKZ3YxbNRMtP1DsTy8qcPj+E+MR5djpPG7Yvx95KgidLgb7AgON3JfJZo+wW2OJUpkGiXqOH/kWhUhN/WnsdVNya5KqvqEULnaTM1/8nA7vSVGKrWCkGg9poxQstocWQIitMil8pMeQVNNdYfeHZWFR3G3OSAZgkPxCw0DQCaXc/1Lb4s2xzK5HL+Q0C6L+7dSWlrK0aNHueCCCwBvhseePXu49957kcvlxMTEEHCCoDp9+vQO+wf0ILG1wd7QoXwlrzaPwoZC3IK3rNKgMpAalMrM5JliVkdCQAIquVS6/FPOhtxlAo6f8H8pMFQmkwUDjwEDZDLZfYIgPH6qnWUy2XXAdQAxMTFnITwJCYkzIQgCNTU1lJWV0a9fP7766isOHDjA3XffjY+PD76+vgiCwMyZM/Hx8ekVqwa9jaKiIt566y0ADAYDKSkpeNpq6SUkTsTlciEIAiqVipKSEj777DOqTyhHCA4OJj4+XlyljoiIEFfLetLF4y/BabfRWFVFcFQ037/9Ks11tUy+7R72r/kOj8dD+sgLuXD+Qnz1BiISkjs0K+3tvTw8DgeOI0fEPh32Q4ex5eXhaZvsI5PhExODb0YGATNniP06lOHhPeq7QhAEEAABZAqZN6tCIUOmlOO0NFPRUkNZQyXFe45QXldJjbWeNP94po6bhCYtkMhWfwam9iE+Jw3h5SIqZMfZtP1jLou5AwIAGzR8VYjf2Bh8og04LS24kwKQqRSoYwwoAtTIv5SjXAABAABJREFU1Ar8L01oa/DpdS1RBnvtVk2P5SJry8QIv3WgGHfgjGTcTg81lmaqSpqo/K6E6pImqs3NeFzerBAfXwWhMQb6XmBqc2MxEBCmlXpt9BBcDgd15RZCY+IAWP7kwxzbuQ0AhUpFeEIyAy6ZjDE5FWNyKoagjqUN7eJHT8HhcKBUKpHL5RQUFPDDDz9w9dVXo1arOX78OD/88APZ2dlotVoGDx5Mnz59xH2zsrK6LvBfiSAIlLWUnSR2lLWUiduEacNID0rnopiLRLHDpJcyeH8u5yzfRxCEGuCGn7HdK8Ar4C2BOdtxSUhItF3oAcePH2fr1q0UFRXR3NZlPyEhgYyMDCIiIvB4PIwYMULcr7fX8/dkTCYTl1xyCYmJiYSE9I7UVonfjiAI1NbWAl5ho6GhgWeffZaJEycyaNAgdDodQUFB9OvXD5PJ1KstaH/K8YP7KNi6EUveYaqKj6ELDOK659/0Chpt58hLb78PX603dTh5yPCuDPec4Kqrw36ovU+HN7PDfuwYuFwgUyDT+OKbnIThksn4pibj2ycFZVgscrUGwSOAR0CuVaHw88Fe3IjC4IMyyBdbfh2KADWqMC3WfVXgFhDc3u1VETp8og00bTDjY9KjjvOncVUJPjEGfJMDafi6EMHlEY/vmxyIpm8Ite/n4ZsaiDYrjOp3DqLJCEY3KJyqV/ciuAQEtwc8ArpB4ehzTZT/azu6wREYRkVR9rct6HKM+I2JwfzgRgSXRywh0Y+Owp3tx76nVyNPMjDymvFUvrCb5f47qG2tx1dQEerxI0aII9oahqvOjkapYFz8cDQZIWjjQ2maoCAgOImBKbNwl7SKDT7lWiUytQKZTEbEXT9magfNSRP/NozopHxK4T2nu5xuakpb2txYGqksaaLW0oKnLX61VklItIH+F0YT2pbZ4R+qkcSOHoIgCDRVV2HJP0Ty0OEolCrWLX2bvSu/YfGb76NQKknJGUFs5gAik9MIjYtHoey5K/52u53jx49jNBrR6XTk5+ezdOlSrrvuOoxGI3K5HIVCgdVqRa1WM2jQINGhBSA8PLyLn8Evw+VxUdhQeJITS6OjLXsMGXH+cWSFZTE3aC6pQamkBaUR5BvUxZH3bM6GAGIGTrQRiGq7TUJCopvQPgkyGAwcP36cTz75hD/84Q+0tLRQVFQklrPExcWh1WrFvyW6Bx6Ph2XLlhETE9NBkDoRlUpFTk7OOY5MorvxUwtas9lMa2srWVlZTJs2DT8/P4YNGyaWQAUHB4vN4HorbpeL6uPFhMcnsm/1CnZ8+Qnz/v5vSvbvYd/qFRgTU8ieMpPI1HQEQWDo9Fnivj/XBUFwebOtZEo57hand4Lv8U6qZb5KFDoVDkszCp0Khb8ae1GDVxwI1tCaVwuutu09AsoQLT4mPS3bylGGa1HH+NG03oxPpB51glccEAUBt4A60R9NejB1nxxBnRiAtl+bOJASiHaAVxwQnO62mAS0WaHossOpWLINhV8zQvN+7JYkXKWbse36CN34J5EpjKCIRpU+Ed/BleizDTSu06MfYSJgYgKl969HEWRCOyCe0vvXi+IBgOGCKPwnxFP16l4MuSb8J8RT/c4B9LkmAibEU/t+Hrg6bu8TbaDh60IMuSavAPJ9CfpcE77JgTRvLQePgEwhA7kMhb8aDeCwNKMyesUpT7MDweZtLIpchkwl8woNChkyX++lr0+UAYW/V8T3zQhGFe4V+vTDvM0PD1QfIb+mkPKdG7BttoES/KoMjGQ8IddkMNUViV9kEAaFll3ff8nOrz9hwpKX8fH1utIEX5F+wnP68bJYlfTrFw6cDjc1pW2ZHSVNVJU0UWdpweNpEzt0SsJiDGSNjeH/2Tvv8LjKM33fZ3oflSkqI2k0KjNyb9jgAjbNNFNCCS0EEhJCQtpmU8hufrvZ3SSbbLIJhJAEEsgGQoCQ0FuAmGZMc8EU9V5HbaSRNH3O+f1xRkcWWALjIsue+7p0aWx9OvNp2jnf873v8zgzlR02hyErgM8jkvEYwZamTDtLPb2NdUyMyOaVV/zgfymorGbhSafgWbAIuUQJFp50yhzO+MCYmJhg+/btBAIBPB4PQ0ND3H333Vx88cUsXLgQt9vNiSeeiDGT9lRRUUFFRYXy+7p51EIXSUZoCDVMEzoaQ40kxAQAerWeqpwqTveeTk1eDf48P1U5VZi0x8YmxOHkgGNwMx4gj+1lgqpBNkE9BVn4eAO4XJKkd/f32FkT1CxZDg6SJBEKhWhra6OsrIzx8XHuvPNOLrvsMhwOB1u3buWkk04iPz8fQRCyF0vzgAceeIDi4uJ5lzmf5dDz+uuv097eTnd3NyMjI4DsQeByuZQ2ltLSUpzOuen7FhNpEKd2/AWtCpVBQ2ooKidLWHQkesZRmbRocvTEW0fl3fvMgl2TZ0DrNhN5awCNwyiLA69nxIEyWRyQkiKkM6KAS8Nguofo80HKTllFY8/rhB9rZ/EV5xDSDxB5vJuC0kq51UESMC12Yl5dwMBtezAucmBZW0Twll2Yljixnuih72dvIsXTSgWC+fhC7Kd76f63V7AcX4j9zHK6v7cN8wlF5Jwl35aSU+1nlhM95JxVTte/bsOydmrMzONlkUEeU7jX7b3Gp0V5oa9SYVlfhP10L70/eQPzKje2k0sJ3rQT03IX1hM99N+6C3EighiLIkYmSA+8RXTHQ+gXXkkq+Dap3jcxrbsetT2BMWBHTFWhzs1FZTQiqAX0PjsGfx5jL3Si9VgxVOQwvr0HbZEFfZmNiZ1BEAQEFaBSoXUa0RaYiTWF0OQY5JSQjjBqmx5Njp5kfwQE5IoEtQqVQY3KoEGMphA0KgStCkmUDknFwvtjm3t7e/nCF76AVqvl2WefpbGxkVyLmXBbE6ddeiWlvgrF72baa1pMH/S2gmQ8zWDnWKayQxY8Qn0R+XUHGCxapX1lsrLDmp8VO+Yjod5udj75KL2NdQy0typR2Tnuwkwyi5+iqgCOUi/qeWjWmUgkSCaTmM1m4vE4d911F8uWLWPVqlXEYjF+8pOfcNZZZ7Fq1SpSqRSdnZ0UFRXN6yrj4dgwdUN109pY2sPtSBnRyqazUZNXI7ev5AcI5Abw2r1oVPPv+T1SOWQmqIIg/BnYCDgEQegC/k2SpN8LgnAD8DRyDO4dH0f8yJIly8dHkiREUSSZTPLEE0/Q1tammLGdccYZrFy5krPPPpvCwkJsNhsXXfSRgpmyHCba2tro7+9n9erVM47JPmdHD4rXQGaBL6hA0KpJjyUQNCpURg3JwSgqvRq1VUeiexwxlUYQQRIl3mjezVBkhM2BE9Hk6NmzZw/hoRGKCoo47rjjyBsz4Dblo0WDJEro7BYMzlzCz7aj9VgxBvIYeaIFfakN4yIHoQcbkRKi0jJgCORjXuVm8P/exeDPw3J8IQO37cGwIB/r+mKCt+xCiqWVCgTzcW5sp5bR+8PXMK10Y98siwPm1QXknO2j979eRUrstcDfUEzO2T6CN+3EvKaQnLN9DPzmLeX24J3vTB+/vpicc3yE/tqAeXUhumILI481y7dLLIw+3QrJqc2dupHXeCv0PFtKvki4rpeKk9cwujMP1bhE5bo1BLfvQhpNgkpAUqsQk/LiQ9CrlTYDTb4RlVkuK9eX2+XnKVOBoCu2KPPSl8oVIrbTytBm/t9+jk8+nkoeP1lpkH95AE2+7B2Sf/VCNJlqBOd1S2QBIXN8lUm+VCv451XynIDCf1mDoJH9H4q+v3af4kDBN1eRCgYZe/551Po6Rv9WT/8Pakl0dCgtPSqbDYPfT87FF2HwezHUnIGushLVR9hV3buqYbJqAsC8Yt8l6IbKKQNmfelUBLDWte/dTZVx6hL1YIgfoigyNDSEzWZDr9eze/duHnnkEcUbyWaz4fF4iMViaLVaTjnlFE499VR6Gup4ds/rmLWafYofcOCeColYisHOycqOMAMd44z0TUw+TRhtOlylVnzLnEplhyVXnxU75hmSJCEIAtGxME/9+hcs2nQaVcedQDIe593nn6WgUq4+k707AvPWT6i5uRm1Wo3X60WSJH72s5+xdOlSzjrrLHQ6HWazWRE3DAYD3/3ud5UWFo1GQ3l5+VxOf7+QJImu8S7qhuuoHaqlPlRP3VAd/dF+ZUyRuQh/np+zys9S/DoKzAXZ9+8ccqApMJfN8P9PAE983OMKgrAF2FJZWflxD5ElyzFHKBQilUqRl5fHLbfcwqJFi9i0aRM9PT14PB6lrWXSD+K4446b6ylnmYHa2lr27NnDypUrZ7zgPlaYFAcElYAYT4EgoNKpSYfjsjhg0pIciEzzEFCZtbLPQPMIapsOrdNEtHYItV2PrshCZHc/UlKc5jmg99kZe6kLbYEZQ1VGHCi2YKzJZ+TxFqREWhmvr8rFvNzF0L11GCpyMB9XIIsD1blYTihi4LY9iPG0UoFgWu7GtqmEvp+9iXGJE/tpGXFguQv7meX0/Pt2pHha+ZsnF/h9P30T8yo39nN8tPxyO+FKgZGCFC0vv8cwY1we34AaFRPlw0RtcYb+XItlVQFXXXUVAz94E3Oem5x1FXT/2ytE4lPe5JZ1RRgqcxnb1oN5lRtjII/onkEEtQrjIgfxtjBSUszsyAvoSuQkgcmqCgDBoEHQygtwrdM0tUOvEtA45QWtcbkLnUcWAawnetBmbttO98oLcJW8yNcWyv+fe2E1Godc5px3eQ2aXPkC2XH1IhCQDShVAmqrvDh3fWUFKqOG6FiYnoW9lFa76Wtp5IHGn3HWl/8JV0UlW//vNorW1HCJ/0cUVFSh1cuCg/1fp1KP3F9evs/XnuPTC5Xb+ZdNeTLkfmLfSTf208qU29YTPVOP95rCfY43LshXbhsqcpTbOs++22wm2zUAVIbp4oCUTBJvaZmWwBKvqyOdqQAC0JaUYAgEsJ27BUNNDQa/H01R0VF7ER6Px2lpaVGqO3p6eojH41x66aVU+MoRouOUO/MQR4Y5btMpLDh+3bTfn3xciqoDXPU/txy8eUVTDHbIlR397XIby0h/ZLKbAbNdh7PUSuUKJ84yG84SK+acrNn4fEOSJEb6evZKZqnHE1jIyddch95sZnxoiGRUjip1lnq54Q/3zStz0kkxB2D79u0kk0klAfCZZ57BYrHg9XoRBIHTTz8dh0M2YhUEgcsum758nC8RtMl0kpbRFmqHa5UWlvrhesaTsmeeWlBTbi9ndeFqAnkBpY3Frp+fQtbRzAG3wBxKsi0wWbLMzMjICG1tbQiCwNKlS/nFL35BQUEBl156Kc8++yzFxcXU1NR8+IHmIVPu/Jnvmd1SMZFGUMku/WIsJe+e6tSIkaS8O535uJssuU+PxuXbJi2pUAxBp0Zt1pIaik6NlyRURtnELxmcQDBo0Nj1mRJ9DZocA4nOscx4+Q4me/njraOoLFq0TpO8GLfq0DiN9O5sxW6wohJUIIE6z4Cu0Ez0vSHUOXpSOSrSjWH0+WZ0HiuRPQPy4lMCkNC4ZB+AiR1BNPkG9F677A/gMKIvtzP+Wm9mvPw3aIvM8oL35W60bhOGqlzGXuySb/vzCD/fiZRIK4+PrsSKcUE+o8+0oyuyYFyYz+jTbeiKLRgXORh9slVuY8g8PnpfDqalTkJ/a0RXZsO80s3Qn+vQ++xY1hQy+H/vygkKYsZzYLET60kegrfswliTj+2UUlkcWOTAvtlL7w9fIx2RfROQ5AV7zpYKuv/9Fcwr3VO3V7jJOVe+LcX2EhDWFmX+fzvmFa593lb8AWYY3/Nfr2Ja5iLnHB+9P3kDKfPaQiXIbQWnltH/67cw1ORh21jCwB3vYPDnYl1XzNCfauXHP7PANwTyMK90M/JIM7oyG6alTkafakNXYsG40EF4ayeIU4KA6NQyqBun7fV6+iJD9IaCiimxWq3GleOgKL+A9UuOx2Qyorbr0eQbp3lKpIaiitdEejyhzF2uKlDJ3+ch4YwZYE9DLT31dSw97UwqV5/ArddezsnXXMeSUzbz3ktbKV+6Ekte/ocfcB6SHh0lVldPvG7SnLSOeFMTZCIvBb0efVUVhpoAen8g892P2mKZ45kfOuLxOL29vXR1dVFYWEhFRQUDAwP86le/QqVS4Xa7p9q/iov449euQ0zLnwG5hcWsveQKAmsPfnx7bCLJYOeUX8dAxxij/VHl55ZcvVLRMfllts/fsv9jmXgkQl9zA70NdfQ21dPTWE9sTK681RmNFFT6qV6zjqWnnTnHM91/EokEoVBIMRh96qmn6Orq4tprrwXgr3/9K/F4XPGPGhwcxGw2K74d85HxxDgNoQZF7KgfrqdppImkKH/OGjVGqnOrlYqOmrwaKnIqMGgMH3LkLIeLQ9YCk+XoRVnMZSLgEGQzNzGeWWBqVUoknEqnlk3eMn2pSBKCVo3KqCE1Gkc1ucAcjiHoVKgtOpKDUXl85j5UJg1qm55kX2aBmaMn0T0uR77lZRaYmZ1HRFDZdGgdRuIto6ismQVm0whqqxat20ysISSb0GUWjOpcA7oiC9F3B1HnGNAVW4i8PYgmVy8vMN/qR0pOLWA1LrmXfOLNIBpHZoH5emaB6bMz/mrP1IJ0coFZlcvYS5kFZnUuYy90oSkwYfTnEd669wJTQldqm1pgFprlReVTbWiLLZgWOxh5ojUzXn589D47gt9K/Jke3ozU805fg9LbX1JSQmmTiZPMS7FETQz9qZYTqhdhrilg+L56dOU2LKsLGbqnFr0vB8vxhQzd/Z68Q51ZwBoX5GNZV8zgH95FX5mDdX2xvKCrysG6wcPA7XsQY1PzMS51YttYIi8AA7nYNpUS/NVujIE8bKeUErx5p/z6yDw+ppUu7Kd76fvfNzEulBe5fT99E+OifOxnlNP7kzcQJ5LK42NeXUjOOT56fvAqpiVOcrZU0POf2zEtzSxO/+NVpOjUAtZ8QiG551XS+6PXMS1zyrd//MbU7f95c5/j+36xUxkTvHnX1O1bdu9zfP9v9ihjBm5/e+r2He/sc/zgH9/DtMyJcbOH1+/6B8H8CbpSg4yOjnJufBUuya6M151XyfBfGpRjdj/0FqZlTnQeK6EHmz5wfH2pjZHHWjAtc6L32hl5olW+XW5n9Km2D4w3VOYSfq4D0zKnXOGwtVO+7c9j7IUuebwACAKWEwoxLshn4o0+pCVOjAvziezqR0qLGBc5iLw9KAsIAoCAyqiFpU4S3eOobfLufDq8lwlhpoIDrQqVSkAwyLtcukIL6pxMGWx1LtoCuXLAtMotix+ZRftkW4F9sxdNplw+Z0vFVLXARdVIk/ehFqYqBz6zELUlUy3whSVKK4H7q8szHgUCqEDQyfMp+tc18n0CRf86ZSBb+K19V0u5rl+q3HZ+ZpFyO/+KfQuPOedOGbfZz/Aqt1XH5fLuu+8SCASw2e3s2LGDR+97VD5Wfj4+n4/i4mI8Hg9ut3vG3TJd0dQCV5M/deE5+RjMRyRJYtdTj2J1OPEtX8UdX/s86WQSjV5PYaUfvdmM0WLlhjvuRZ9JZ1m86fQ5nvXBQRJFkl1dxGrriNfXKbGzqZ6pKES1w4EhEMCybi36QA2GgB+d14swT3ZUDwRRFHnsscfo6upiYGBASTM74YQTKHTkk5+fz2c+8xkKCwvRaqenYqz75JXke0oOaptBbDw5rYVloCNMeDCm/NyaZ8BZZiVwfKHi2WGyzd/35rHOSF8vw71d+JbL54f7/+NG+lubAcj3lFK5ag2FVQGKqvzkeUrmVXVHMBikubmZE044AUEQePbZZ9m1axc33ngjKpUKl8uFSqVSxn/iE5+YVqE0We0xXxiIDCgVHZOeHR1jHcrP8wx5BPICXLngSsW3o9RainoePadZpnP0nyHniKG7JheY8oJxsld68M535AXmBg8Dv38bQ1Uu1hM9csl0dGqxYFzqxLaphP5bd2PwZxaVt+ySF5inlhG8aa8FJhKmFXKfdd/P3sS4UF5U9v3PGxgWOcg5s5zeH7+OOJGSDy4h92JvqZAXmIud8qLyP7djXJJZMP7Xq4iRfSwYf/w6xqXymL7/eUO5HfzZm/sc33/TTmVM/y27lNsDt+7e5/iB2/YoYwZ///bU7Tvf2ef4obvfU8YM31M7dfveug+M151XSeivjRiXOtEVVzLyYOa2x8rIw80fGK8vszH6RAvGpfICc/SpVvm2z0747+0fGG+oymVsawfGpc6MANKJcakToz+P8Ze75PGCAAJYjhcxLsgn8mYQabFDXlTuGcAoipgWO4i9N8R4ZJx+wnjVLl7o30nTs51cqd5I2pagoKCARYkSyqt9lJ+7lIFf76EwagUBkkIEbZG8EEiFYmgy/ebiRFIpsxfjafl2Zj5KIZhKYPIcptKplB5zlVmLoM180AtTvdkah1FZXGndJqVEW1dilXv2MwtqbaYk3lCVq/S/Gxbkoc0s2ExLnHIqQWY++jK5P9yyplAZY1lfrJTK2zZ6ZAFKkBewuuJM3/2ppUo/uX1zmVKKbz/TK6cMTM6nYHIR7VMWirnnV6DOlZX73AsqZYEuM35yTN4l1crfmH+pf+r2FQGYtCgQUBb1jk8vQG3RMTgywj/Yg2FcT7nPx/GLjqO8rAqzySS3dFjki3PXF5Yoj63ri0uVMnf3Dcsyx5YfH1XGB6Dg6ysRdPJzVPCNlUpLQuE3VynPJwII6oxXwHdXT1/gZ57rov93/D7Lq4u+u0a5XfidKT+SmQSBvVsJXNctUW47rl64r+HkXjjVSpCzZS9x4HTvPsdP8xlYOeUzYFy074utaT4DBWbltiZ33zs0k6/3Q4UoigwPDysl+RUVFfj9fiKRCE8++SRGo5ElS5ZQXV3Npz71KYqKiub1Dtr+Eh0LExkdJd9TwqP/+yOMNhunXvsl3nrmSQp8lVQddwJnfukb5LgLcJaVo9qrPWxS/JiviNEo8cZGpXVFrvCoQ4xE5AEqFTpfOablKzBcnqnsCPjRzJGR7eFCkiRGR0enpRhZrVYuuugiVCoVwWAQq9VKTU2NUuHx13//Nn/f8zrnf/N7lJaW7vO4q887MA+l6FhiWhLLQMcYY0NTYofNYcBZamXB+iKlssM4j4XIY53YxDh9TQ30NtWz5vxLUKnV7HjiId594R/ccOe9qFRq1l1yJSqVioIqPwbzkV9tNel9o1KpaG1tZdu2bVx44YUYjUba2tr4+9//zuLFi7FarSxfvhyfz6eIjCtWrJh2rPnSniVKIh3hDupCddQNTSWxDMWGlDEei4ea/BrOrTiXmnxZ7HAanfPmb8zy0ci2wBwiBu54J7PABAQwLnTIAshd72Hw2bFkyqT1PjuWE4oYurduqgdcEDAEcrGsLmT4gQb0ZTbMxxXI5eWlNsyr3IQeapIrBDILIkNFDqblLkYeb0HnsWBa6mLkyVZ0xRZMS5yMPt2WWTDKx9eXWeXS6+c60BaaMS7IJ/x8J9oCM8ZAHmMvdmVKuOXxuiILhupcxrf3oHEaMVTmMv5aLxqHEUNFjrxTnBKV+WjdJvReO5Fd/ajzDOjLbET2DKDJNaArsRJ9Z1Cu6MiM1+TJTv7RumG5T7/QTKwxJPfvu83EmkamLUjVdrmvP94eRm3RyuXfnWNK73+iZzwzPrNgNGvR2GW3eZVBg9qmIzWYSRyw6kgNZy5cMsdX6eSqlfRYYqpdYiIpew7o1XJ7xV7jJ9suJh8DQS3IVTTCRz8xhMNh2tra6Ojo4Mwzz+Tll19m69atfOtb36Knp4eBgQFWr159zHtCHIlMGs7O5FguiiI9PT0UFRVN2zXJcnQzPj7+gQjaWEz+rNFqtWzcuJF169YhiiLhcBi73X7MXWQ1vv4KLTvfoLu+llBPF4VVfi7/r5/x4j1/QG8ys+b8i4lHIuhNR08MYGpggFidXNEhix11JNraYHJBYjajDwQwBALoA34MgRr0VZWoDEd/aXUsFmNwcBCPR/ZQueeee2hoaADk9q+CggJKigo54+xzZjxG7bYX0BmMVKyc2UR6f0hEU/S3hwm2helvG6O/Pcx4KK783O40TrWwZCo7DGbtLEfMciQjiSJDXR30ZCJoexvrGerulHeKBIGrf3or+Z4SRvp6SadT5BV5jvjP7WQySV9fH/n5+ZhMJlpaWrjnnnv4zGc+Q1FREc3NzTzzzDNcdNFFOBwOYrEYkiTNawE+kU7QONIoJ7AMZdpYQvVEU3ILmkbQUJFTobSwBPIC+PP8WHUfLeo8y5HPbC0wWQEkS5Y5IhwOYzQa6erq4tFHH2V4eBiQHbGvvfZatFotkUgEt9udXTQfwUiSxM0330xFRQXnnDPzRXmWo5tEIsHExAS5ubmIosgtt9yivKcnI2g9Ho+yS+10Oo+p93UyFmO4pwu3r5JX/3ovLTvf4PIf/Iynf3MzTW++SlF1gKLqGooDC/AE9l0xNN+QUikSra0Zn44pc9L00NRuo7aoCH3GkFRfI4se2uJihGPktTE0NERzc7MiEA4ODqJWq7nxxhvRaDTs2bOHaDSqtH/9445f0/TGq1x/292HZNGZTosMd08QbB0l2BYm2DZGqG9C8Ueyu4y4ymxTgkeJBb0pK3bMZybNPHsb69l2/930NtaTiMqVVwaLVYmgLawKUFBZPS/E2Gg0yptvvqm0T/b19fGb3/yGCy+8kMWLFzM6Osr27dtZtWrVvGtX2RfhRJj64fppbSytI62kJHmz0qw148/1TxM7KnIq0KmzVVlHM/POAySbApPlaCQej9PQ0IDH4yEcDnPnnXdyxRVXkJOTg8PhYNWqVZSXl08TPOz2rHP0kY4gCKxevZq8vLy5nkqWw0Q6nWZgYICRkRECATkd5I9//CNqtZprrrkGlUpFTU0NZrOZ4uJiCgsL0X2EWNGjifBgPz31tQRbmznximvY/tc/s/OJh7nhzvux5DtwlJYhptNsuvpznH7dl4/4HdQPIz02Rry+XvHpiNfWEW9sREokABC0WnRVlVhOOglDwC9XePj9qI+Rz3hJkgiFQorQceKJJ2IymXjvvfd47rnnMJlMeDweqsq9VPgDyuthyZIl046zYMMmPIGFSKKIcIDVkJIkER6MypUdrWME20YZ6BwnnZQrcYxWLS6vjapVLtxeGy6vLVvZMc8RxTTJWBy9yUR4oJ8HfvA91n3yU/hPWI9KrSYyOkLN+pMozAgeuYVHbkqSKIokEgkMBgPJZJJ7772XBQsWsHLlSlQqFc899xwajYbi4mIcDgeXXnopJSVydLXdbueMM86Y479g/5EkiWAkqAgdk1/d493KGKfRiT/Pz0bPRkXs8Fg9sul8ln2S7I/IEe2O+Vvxs79kK0CyZDlEjI+P09bWRltbG36/H5fLxc9//nPOOOMMVqxYwRtvvMHChQvJycmZ66lmmYVdu3bR1tbGBRdcMNdTyTIHvN+DoKuri97eXpLJJBqNhhtvvBG1Wk1DQwMqlYpjUbhPp1IMtLXgKCunbfcOnrvzN4wPDQKg1Ru4+n9/TTIWJTzQT+nipag183cRKUkSye6evRJY5MqOZFeXMkadm/u+BJYAel85gnb+/t37i7Kr3tvLP/7xD7q7u4lk/Ew0Gg1XXXUVpaWl9La3Uf/aK4TamuhtrCcaHuUzN91GbkHRh9zD/hMdS2TaWOTKjv62MLEJOdFBo1XhLLPi8tpwZ76s+YYjdvGb5aMRCY/Sq7Sy1NHb1MjiTaex6erPk06lePymn7D0tLMoW7Jsrqf6oXR1dSFJEiUlJUiSxP/+7//i9/uVytM//vGPLFy4kJUrVwJyO5lhHrfNpcU07eF2xZR08nsoHgJAQKDMVoY/zz8tctZhnP8VLQdKvGWUdDiOOJEkHUmhyTdgXuGecXzfT99EW2yZFvd+NDDvKkCyZJmPjI+Pk0gksNvt/Pa3v6W/vx8AnU6Hw+GgqqqK6667DpfLhVqtZt26dXM84ywfhYmJCYaHh0mlUvMmqz7LgVNfX8+OHTvo7u5mYmICkD0ICgsLWbFihdLKMlmtVV1dPZfTPeyEB/p565knWHLqGfS3t/LIT3/Apd//CZa8fIr9C+R2Fn/NNLPSfM++DSmPVMR4nHhTk+zTMenXUV+PODYmDxAEdF4vhsWLyLn44kxlRw0a17FlmDfpL7C3182JJ57IsmXLUKlUjI6O4vf7lffM5DkQIDUeZsdf7yG3sBjf8uMo8gcwWA68Bz+VSDPQMbaX4DGVyCIIkFdkpnyZQxY7ym3kFZpRqbM7xPOdYGszvQ119GQEj5E+OTFJUKlweX0sPOlkypfJAoFao+Hcb3x3Lqc7Kzt37iQWi7F27VoAHn/8cYxGI1dddRWCILB+/fppladXXXXVtN+fT+JHNBWlKdSkiBx1w3U0hBqIpTOeWSotVblVbCrdpIgdVblVmLXz2/x6X0yKxzMx+kw7Kr0a64meGceMPNpMsndC+bdxiWNWAcR+ro+J6Ai1214g2NxIsKWJjVddi9t39G7oZK/ms2Q5AOrr60mlUixcuJDbb7+d4uJiLrnkEsrLy1myZAler5fCwkLlYq+wsHCOZ5xlb8LhMC0tLdTU1MxoYLpu3TrWr19/mGeW5XCQSqWQJAmtVktLSwuPP/44V1xxBXl5eYTDYYaHh6msrFQWbrNF0B6tSKLIcE83PQ218ld9LSdeeQ057iLefOxBCqr8eGoWcc7XvkO+pxSDxcI5X/3WXE97v0kNDWUSWOqVJJZ4SwukZXNywWTCUF2N7ZyzMUxWdlRVoZoHfgAHk8kkI1EUcblcRCIRfvrTnyqJElarFY/Hg8ViIRGN0L3jVS484/QZL6SL/DVcf/ufDiiKVhQlQn0TBFunxI6h7gnZiByw5Opxl9tYeGIxbq/s36EzHFvv46OVjnf2MNrfx+KT5ejrJ2/5GUNdHZhzcimsCrD45M0UVQdw+yrR6o8sQUAURUZHR8nNzQVg69attLe3c/XVVwPQ0tLC2NiYIoCce+6500xJ16xZ84FjzgdGYiNKCsuk4NEabkWUMp8hWiuB/AAXVV+kpLCU28vRquZfBZ2UEhEjSdITKcSIHKQwmXK4LwZ+9zaCWsBxzaIZxyR7J5S0wJnI+6QfVAIqkwaVUYugnhJUJElitD+IRqvFkpdPf1sL9//oRuIRWTDRaHU4y30k47GZDn9UkD0DZMnyEZmYmKC9vZ22tjZEUeScc87htddeIx6Ps3DhQs466yysVnnn6swzz5zj2WaZiUnzr+bmZgYGBgAwmUwz7uAfSzu5RzOTC7euri5ll7qvr4/zzjuPpUuXYrFYcDgcpFKyadqqVas47rh9x/0ezUiSRCqZYMdjD1FY6cdRWsYfvnE9AAarjaLqADqDkbyiYm648z5lUeE/YX6IhFI6TaK9XanqmPTrSGU+CwA0BQUY/H4sp5yMIZPGoi0tPWaMSd9PY2MjnZ2ddHV10dPTQywWY8GCBVxyySWYTCY2btyI0+mkuLgYm23q4j4Zi/H8Xb9n3SVXziiAqDXa/RI/JEliYiQ+VdnRGqa/fYxkJkVPZ9TgKrOyYnOp4tthtu9b3M4yf0inkgy0tdLTWE9/WzObr/sKgkpF3Ssv0PzmayzadBqCILD5+q9isuVgc7qOuHP30NAQra2trFy5EkEQeOaZZ3jjjTf47ne/i0qlwmq1kpeXp1QAXHDBBdNS/+bbBpokSfRM9Ex5dQzVUReqo2+iTxnjNrmpyavh1LJTqcmrIZAfoMh85Pqu7E2sMYQUT2NcNHPLzeAd7xBvGVX+rSuz4bp+6YzjjQvzQTX73+64asGHzk1bMFUZI6bTNL3+GsGWJvqaGwk2NxKbGOf4Cy9l3SVXYncVEFh3Eu6KSgp8VeR7SqdFzB+tZD1AsmSZgUgkQl9fHz6fj6effprt27cDcnxlRUUFn/zkJxkfH8dkMmWjaecR4XCYm2++mdLSUioqKvD5fNmknaOQZDI5LV2iu7ubeFyOrtTpdBQVFVFcXMyiRYvm3YXlwUKSJMaGBkglEuQWFPHn//dNyhYvY+3FV3Dr565g2elnse6Tn6LulRdxeSuOaEPAfZEenyDe0DAtgSXe0ICUiSJGo0FfUZGJm5306/CjyezIHmskEgl6e3uV98qmTZsAuO222+jt7cXtdlNcXIzH46GkpITet3diMFmoWrN2xmNGRkcw2XM+9pzimQjaSbEj2BYmMioby6rUAg6PRWljcXlt5LhMCB+ygMhy5DM+PERvYz09jXX0NNTR39JEKik/75Z8B5f/10+x5jmIhEfRGYxojhCT6ck1lSAIdHV1sX37ds4++2xMJhNvvPEGjz/+OF/72tfIycmhu7ubgYEBFi1aNO8rC5NiktbRVsWrY1L0GEvI7YIqQYXX5p2WwhLIC5BrOPyftZIoISXSqGapAgs/10E6HCf3gqoZxwz+37ukR+K4v7pixjGRtwcRJ5KozBpUJi1qmw6t89BVDY6Hhgm2NNLX3ITJbmf55nOQRJFfXvNJ0skEjhKvInR4Fiwmr6j4kM3lSGDexeDulQLzucbGxrmeTpZjiN7eXt5++21OPfVUXnjhBV588UW+/e1v097eTjAYxOv1UlRUNO9PVkcrkiQxPDxMOp3G5XLNOC7r53F0sn37diwWC4sXLyYej/Pf//3fAMrC7ViNoJ1kcmdxz3NP075nFz0NtYwPD1G1ei3nfuO7PHfHr3GVV7B40+kk47EjrmR8JiRJItXXp7SuTFZ2JNs7lDEquz1TzSH7dBgCfnQVFaiOkIXT4UYUReU98Nprr7Fz5076+/uVBZzT6eSLX/wigiAwPDyMxWL5QJLRXd/5KtZ8J+d/818PypzSKZGh7vFprSyhYESJoM1xm3B5rRmTUjsOjwW19th7Hx9tpJKTRrRamne8znN3/JqxQbkiS63R4PJVKjG0RdUBrPlHhsmlKIoMDQ1hsVgwGo10dHRw3333cdlll+HxeGhpaeGRRx7hsssuw+12E4lEFJ+4+SQkv59IMkJDqGFa5GxTqImEKAtUerWe6tzqaUJHVW4VRs2hSRhJTyQRo6lZE0xGn2wl+s4g6UgKKZZC4zRR8E8rZx2fGonPagqaHkuASkA9R8lQiVgUnUH+m5/93a00v/kq46FhAARBRdXx69jytW8DMNTVgd1VcMQIhYeLeSeATJKtAMlyKIlGo0pLS1tbG5dddhkdHR08/PDDfOELX0CtVjM2NkZxcXG2wmOeIEkSv/jFLygqKuKTn/zkXE8nyyEgnU7T39+vVHUIgsC5554LwG9+8xtcLhef+MQnAOjp6cHhcBxzEbSTRMfCjPYHKaio4tnf/YrRgX4uvPH7/O1H/8ZQdydF1TUUVQfw1CzCWVY+19P9SEiJBPGWlilT0ozokR6dKjPWlpbKYsdeSSyagoJ5veg4UPaVZPRP//RPGAwGXnnlFZqbmxWB0KxRMdrVQXQszKpzZk6/io2PozebP9bjKkkSowPRaZUdg53jpFNTEbTucjtur5zM4irLRtAeDUxWnQmCCmu+g4GONv5049c4+6vfomr1WoItTbz+yF8pyogdTq8PzRGSnhSPx9mzZw8ej4fCwkL6+/u59dZbueCCC1i6dCmjo6Ns3bqVE044Abd7ZsPJ+cRQdOgDkbPt4XakjCpp19unJbDU5NVQZitDozo4G0yx+mGSA1Gs62euVBi+v554yyiF31k945ixl7tJdI7JnhgmLZocPebjCg7KHA8HsfFx+loaFYPSvpZGJFHkul//HwDP3/V7IqMjFPgqcfuqcHl9aOeRCe6hIiuAZMmCXN7b2tpKQUEBIyMj3HnnnYCc7FBSUsKZZ55JXl4egiBkqwOOYPbeudwXra2t2Gw28vPzD+OsshwKJEliZGRkWhtLT0+P4tNhNBopLy/nkksuAeS2F+0RcrF8uJHNSrvorq8lPBBk/aVX8cQtP6Pj7d1c95s/suupR5kYCbHhsk+TTMTR6o58X4RUKES8PtO6UisnsMSbmyGzYywYDOirqzH4/ehrZK8OfbUfteXoSwbYH2KxGD09PbjdbsxmMzt37uSRRx4BQKVSUVBQgMfjYcOGDYpvFcCbj/6N1x9+gOhYGABLXj6fv/UPB0U4moygDbaF6c8IHvGI/D7W6FQ4S60ZwcOGy2vFmpeNoD0aSCbiBFvkiOPeBjmZZTw0zKotn+CkKz9DKplk2313seDEk3GWeud6ukiSRDqdRqPRkE6n+dvf/kZlZSXLly8nkUjwox/9iE2bNnHiiSeSTqd5++23KS8vx27/+Ca+RwKiJNI91j2tfaVuuI6B6JQ3UrGlGH+un0B+gEBugJr8Gtwm9369TyNvDxJvCJGOJBEnkiAIuK5bMuP40ENNRPcMUPT/TphxTLw9jDiRxLjg6Ljmi0ci9Lc20dfSxIozz0Wt0fCPO3/LrqceBSCnoBC3r4oCXyUrzj4PlSq7QTsTWQEkyzGJJEnE43FeeOEFqqqqyM3N5aabbuLMM89k2bJlbN++Ha/XS3Fx8TG7aJpvvPjii+zatYuvfOUr2Yvjo5BoNEpPTw8+nw9BEHjkkUfYuXMnMBVBO+lBUFxcTG5u7jH7OkjGYvS1NOKpWcSeZ5/ipT//gXgmrtdos/O5X93BcHcXyViU4sDCI/pxkkSRZEcHsbr6aX4dqb4pszyN0yn7dAQC6AN+DDU16MrKELLVeUQiEd59911FJJw0d77wwgtZvHgxw8PDNDQ04PF4KCgomFHgr932Au1v7aKoWt59z/d8POPXZCaCdrKNJdgaZmxo7whaC26vLHi4vDbyCk3ZCNqjBEmSqHvlRTmKtqGOgfYWxEySkt1dQGGln6LqAKWLlh4RsdiDg4MkEgmKiooAuOWWWygrK2PLli0A3HHHHdTU1HDCCfICPBwOY7Vaj+jP0w8jmU7SPNpM7VAt9aF6aodqaQg1MJ4cB0AtqPHl+Ajk7tXCoi7HNKFDXz6z0BN+roOJN/pmrcQYfbqNiTf7UJm0iifGbG0mUlIEtXDU+/r0NtWz68lH6WtpItTTpfz/p//nFhylXgY72pgYHcFdXonBYpnDmc4vsgJIlmOCeDxOR0cHra2ttLW1EQgEWLduHT/96U/ZsGEDa9eupb29naKioqzgMU+pra2lvb2dU045JfscznOSySR9fX10d3ezcOFCrFYrr732Gk8++SRf//rXsdvtNDU1EQqFKC4uxuVyHbOVWZPn6aHOdt569inWffJK6ra9yHO/v5Vrf/k7Qr09NLy2LdPSUnNEm5WK0WjGmDQjdtTKxqRiJCIPUKvR+8oVn45J0UOTreiaVhHV1dVFSUkJCxcuZGRkhF/84heYTKZpXjclJSUYMmXQrbt38Mxtt3Dpf/wYm2Nmf6T9RRQlQr0TU9Ud74ugteYZcHltGaNSK85SG1p9VrQ6mnhn6zNMjIRYc4FciXfH165jbHiQwopqCqv8FFbXUFhZjTln7s2F3333XcbHx5UI2dtvvx2tVqtEz27bto2cnBwWLlw4h7M8eIwnxqkP1U+r6mgaaaIgmk9VrIx8KQevtoRCjZuxjToCeQEqcyvRq6dXCI4+3cbY850U/2D9jGJE9J1B4i2j2Lf4jtjzz1ySTMQZaGsl2NKoJLJs/PTn8C5ZTtvuHTz925uVyg53RRVuX+UBxYNnmV0AOTavJrMcNbS0tJBMJvH7/fzqV78iHA6jUqnweDzYbDbUajX//M//rHh4lJWVzfGMs+yLWCxGa2srLS0trF+/fsZy0pqaGmpqag7z7LIcKJNmcXt7EASDQURR7ve32WwsWLCAQCCA0+nEZJJd0isr9x2debSTTqXob2ump76Onvr36Gmo5bxvfo94ZIJ3n3+WBSduomLVauwuNyZ7DnZXAd6lMzvRzwWSJJHqHyBeL5uSTn5PtLdD5nlXWSwYAgHsn/iE4tehr6pEpT/y23MOB+l0GrVajSiK3HfffXR2dhLJCEUajQa9Xs/ChQux2+189atfxW63z9geaMnLp6g6QDrTPvRxkCSJ8VB8mm9Hf8cYqUwErd6kweW1sfIMR8a3w5qNoD1KkCSJkWCvnMzSUMdwdycXf+8HctpJ7buEersVAeSif/0vLLl5cxKlKUkSkUgEs1lug9u2bRutra1ceeWVANTV1REMBhUB5IwzzkC/1+fNunXrDvuc9xcpLYGKaSKDJEkMRAeoG65jeE8XOXVqflr2R9rHp4yg8wx51OTVsHbBWja0L6Hg9Yw3lgAqo4bC8jUIM5gKm1e60VfmzDov4yLHrJGwxxKpZJLBjjZ0RiN5RR6Gujv5v3/+ElLm3Gey51BQUaX425QtXaH4eWQ5PGQFkCzzhsmLwVdffZXR0VE2b97Miy++SCKRwO/3c/rpp2MymfB4PNNMD7MGpkcuw8PD/O1vf6O7uxtJktBqtfj9/nnfT3usM/leHR4e5tFHH6Wnp+cDEbRr165VdqptNhsAdrv9mHzuJUkiOhZmx2MPUrn6BNQaLff8yzcAsDldeBYsRqVWU7JgMTfceZ+ysLDmHRkXm1IySby1NWNKWk+8rpZYXT3p4WFljLa4GH1NANvZZytJLNriI7dS5XCTSqWUiqjJL7vdzlVXXYVKpUKlUlFVVaW0f7ndbuXcNjY4wIM/+FfWXnIlgbUn7vP4zlIv52QSAT4q8UiS/vYxpY2lvy1MJJyJoNUIODxWatYWZlJZbNidxqO+VP1YIRGL0tfUkBE8aultrFe8YbQGI4WV1cQjExjMFk6/7svTxA6bw3nY5hkOh2lvb2fRokUIgsDWrVvZtm0b3/3ud1Gr1Wg0GnQ6neIdtmXLlmnVoyUlJYdtrvtCSolyislEEjGSQozIXhaCZt9CxPi2bkYebSH5T0XUTzRSO1yrRM8Ox+TP21NHjufSsTNYZFvIuVXnKW0sTqNT+bxNVycQN6TkVhSj5kPftxqHEc0sKSvHOpIo8s7zz2YiaBsZaG9DTKdYfsYWTr7mOnLchaw5/2JcPjmC1pKXP+3clz0PHn6OSAFkrxjcuZ5KljkkHo/T2dmppLREIhG+8pWvEAqFGBwcBOC8885TlP5FixbN5XSzfAwsFguCILBhwwZ8Ph8ej+eYbXOYryQSCSKRCDk5OaRSKX75y1+yfPlyNm7ciNFoJBaLsXjxYkXscDgcx2QE7SSTZqUqjQaTLYc/fffrLNt8Dos2nsLOJx7B5nSx+OTNbPn6dyisDhwxIsck6XA4k7xSrySwxBsbkSaNSXU69FVVWDZtxDDZxuL3o86IXFmm4roHBwfx+/0A/PnPf6a5uRmQPxeLi4spL59K5rnkkktmvEg25+bhKPVitH78xzidEhnsGp/m2zESjCg/z3GbKKnJw11uw+W14SjORtAeLUiSRKi3B2tePlqDgT3PPc2zt/8KSZJ3q/OKPPhWrpajaKsD5HtKphkvHs5Kj76+Pl5//XVOOeUUzGYzDQ0NPPbYY3g8HnJzc6mqqsJsNiOKImq1mjVr1ijVHsBhTQRL9keINYQwH1eAaoa2r4k3g4w81DTt/wpvXI06UzkVT8dpCjUpcbMTncPku0zc/9hTRNVxNCoNlTmVnOg5URE6qnOrseqsrOHCGeemtupQW4/NdLQDQRTTDHd3KS0sBouFdZdciaBS8cr9d5OMx3H7Kll5zvkU+CoprJL9TdQaDes++ak5nn2Wvcl6gGQ5oujv7+fdd9/lpJNOYuvWrbz00kuoVCqKiorwer1s2rQJlUqVVUvnCW+//TZarZZAYGaTqyzzi3Q6TU9PDy0tLbS0tNDZ2Ul5eTmf+pR8cn/66acpKyvLPucZJs+xrz/0F7rr3qWnsY74xATLNp/NKZ+5nqdu/QWVq0+gctUaUsnkERP5KEkSye5uYrVTpqTx2lqSPT3KGHVenmxKmklgMQQC6MrLEbIi5gfo6emhrq5Oqe6IxWIIgsCNN96ITqejsbGRZDKpVESNBHvpqa+lp6GWnoY6yhYvZeNVnzsoc5EkidH+6DTfjoHOMcSU/Fo12nRKVcdkKovedGS8LrMcOPHIBL1NDdgcTvKKPHTVvsN9//4dLvj2v+FbcRz9bS00vr6douoAhZX+w2q6KEkSY2Nj6HQ6DAYDPT09PPDAA1xwwQWUlJTQ2trK/fffz5VXXklxcTETExOMj4/jcDgOWrWvlJYQo0m5MmIGc95YU4jwsx3kXxZQxIr3M7Grn9B99bi/sRKt07TPMcn+CPHWUVQmLVFtnPZkJ+/SQO1IHXWhOlpGWkhLcouZWWvGn+unJr9G+V5hr0Crzr43DwWSKDI2PKRUNP39tzdTu+0FUplqVq3BSOWqNZz15X8GYGIkhMlm/1jG0VkODVkPkCxHJMlkEpVKRVdXF88++yyXXHIJvb29vPjiiyxevJilS5dSVlZGSUnJtB7NLPOH7du3Yzabs4vheYwkSQwMDNDS0kJrayutra0kEnIZfGFhISeccAIVFRXK+M2bN8/VVI8IwoP9RMNh3L5KHvzx99GbzJz15X+m4bVtiKkU/uM3UOSvwVMjm+yd8cWvKb87V+KHGIsRb2xSfDpi9XKFhzgupwKgUqHzejEuW0bOpZdm/Dr8aJzOrBj9PpLJJL29vYrXzebNm7HZbLS3t/PSSy/hcrlYsGCB0soyWfFWVVU17TiP/PQHDHa2ozOa5ESWko/vXxUJJ6YqOzKChxJBq1fjKrWydFOJbFZabsOSq88+r0cJkxVnPZkI2p6GOoa6O0GSWH3+xWy47NO4fZWcft1XcHl9ALi8PuX2oSaZTFJbW4vL5aKgoIChoSFuueUWzj//fJYtW4bFYsHtditVg2VlZXzrW99SXp9ms1mpAp4JMZ4mNRRF4zCi0u1bJIk1hAg93IQ4kUSKyYKD+2sr0BbMcGxBTiaRUuKM92tcmI/x/x2PYJi+1JIkiWAkSO1QLXWhOuom6qjrrKNnYkpcdhqdBPICbPRsJJAXoCavhmJrMSohu7g+VIwNDdJd/x7BliaCzY0EW5uQJPjynfchqFTkFnlYcvJmxaA0r7B4mthxJJj8ZvnoZCtAshw2UqkUHR0dSktLd3c3V155JXq9nscff5wtW7aQl5eHJElZwWMeIIoiw8PDOBwzl+iPjY1hNpuP6ZaH+cj4+DiWzK7fQw89xO7duwHIzc3F5/Ph8/koLy9XzEqPVdKpJP1tLfTU15KIRTnhwsv4y3/+C7GJcT713zfx6l/vRWswsvLs80inkqg1c79TlxocnObTEaurJdHaBpmoSpXJhN7vl0WOydjZqipUxmz/9/sRRRFRFNFoNHR3d/PYY49NM/e12+1cdNFFlJSUEIvFUKlU6HQ6xoeHCPX1ULJg8YzH7qp9B4PFSn5xyX7tKCbjcgTt3r4dY8OZCFqVQF6RGXf5VHVHbkE2gvZoQxTTvPrXe+lpqKOvqYF4RI7HNpgtcipLppWlsLIavWl28eDgzUn24BBFkccee4yysjKWLl1KMpnkhz/8IRs2bODkk09GFEXeeOMNKisryf8IyU+pwSgTO4KY1xSiydn3dWO0bpihP7yL84tL0Zfuu00s0T3O2ItdqM1aVCYNKpMW4xIHasuBtYmkxBTt4fZpXh31w/WMxEcAEBAos5Up7SuBvAD+PD8O45HV+ng0IUkSY0MDBJub6GtpZPV5F6M3mdh2/928+td7UWs0OL0+JZGlZsPGI+LcnWX/ycbgZpkzYrEY27dvx+fzYbFY+OUvf4kgCBQWFuL1elmxYsWsC+gsRy5PPfUUO3bs4Nvf/nbWt2OeE4vFUKvVaLVaduzYwaOPPso//dM/YbPZaGpqYnR0FJ/PR27usb3DER0LM9jRRsnCJWy7/0+8+chfSSXlahhnqZdP/eSX9DU1oNZqD9sO6kxI6TSJtrZpCSyx+jrSA4PKGE1hoSxwBPyKX4e2ZP8W3McS4XB4mklpd3c3p512GscddxyhUIhHH310Wgyt1Wrd53Geue0W6re/xJd+/+cDeqzFtMhwb2Sab8dwzziTl3XWfEMmflb27XCWWLMRtEcRkiQplRAv33sXqURMaZP6/Vc/h1anl4WOqgBF1QFyC4oOy3s7HA4Ti8VwueS45d/97nc4nU7OO+88AH77298SCAQ46aSTABgcHCQ3Nxe1Wk1yIMLYC12KIagYSZJ7UfWMwkW8ZZSB2/fg/Nxi9L6cfY5JjyVItIfRldtRmw/dQjaaitIYapwWOdsYaiSWlgVInUpHZW4lNXk10/w6TNpjeyPhUCJJEkgSgkpFb1M92/9yD30tTUTDo4DsX3PZf/wPBZXVjPYHiU2M4ygpzQoeRwnZFpgsh4VUKkUsFsNgMHD33XdTXV3N6tWr2b59O1qtlnXr1nHFFVdQUlKCwWCY6+lmOUCWLl1KcXHxXE8jy8cglUrR1dWl+Hh0d3dz0UUXsXDhQrxeL6eddprST32smlFLooigUtFV9y7vvfgPTr32i+x84mFee+gv3HDnfThKylh6+pkUVddQVF2DJU/erSys8h/2uabHJ4g31E/362hsRIrJF95otegrK7GsW6/EzRoCftQ5OYd9rvOFeDxOT08ParWa0tJSYrEY//u//wuASqXC7XazdOlSZZGXm5vLVVddRWx8nO76d7GYq2c89oqzzmXxKfvXKiZJEmPDMfrbxpQ2lvdH0Lq9NsqXejO+HTZMtqzJ4dFEdCysxND2NtYxNjTINT//DYIgEI9MkIzHlLFX/+zXqA/TxkRjYyOjwyMsyqtEW2DmL3/5C4Ig8JnPfAaQzyE2m41E1xgDv3ubT19+CYbqKTF9700wKSESawihzlRhaN3mGRNRAHReG8U/WD9rionaqjvo8ayhWGia0FE3XEdbuA0xYxxr1VkJ5AW42H8xNXk1+PP8lNvL0aqyC+tDycRISDEoDbY0EmxpYuOnP0dg7YkICIwPD1GxcrVS3eEo9aLJGOPaXW7suOf4L8hyuMhWgGQ5IDo6OhRfgK6uLhYsWMAnPvEJ/vKXv+Dz+Vi5ciXJZHJa7FiWI5dkMklnZyctLS00NzezZcsWioqK5npaWQ4QSZIIBoOK4NHe3k4ymUQQBIqKivD5fCxZsgSn8/DFFx5pJGMxepvq6amvpbuhlt7GOj7901/R+e7bPP/H33HlD3+OmE4zPjJMYaX/sC0u9kaSJFK9vcTq6jKmpHXE6utJdnQoY9R2O/qamqnKjpoa9OXlCIcx/WC+8tZbbyntmQMDA0iSRFVVFVdccQUAu3btwuFwUFBQMOM57Z3nn+XpX/+Cq392K/me0o89l9hEkoH2MYJtowQzokc0E0Gr1qhwlFgUocPttWF3GbO+HUcRYjrNYGe7Inb0NtYR6pU9IgSVCmdpOYXVATZ+6rPKAu6g3n80RfS9IaUSIz4eJWeNB53HyptvvklTUxOXXnopAA8++CBtza1cPHgceVcECFrG0Wq1eDyeacdMh+OMPd+FeXXBzN4aRxiSJNE93j2tfaV2uJZgJKiMKTAXEMgNEMifamMpMmcjvg810bEwwZYmDGYLBZXVhAf7uf1LsuiGIJBX5KHAV8niU8/AE1g4t5PNMidkK0CyHBQmyy3ffPNNwuEwJ598Ms8++ywdHR0UFBSwatUqqqvlXa+LL75Y+b2s+DE/GBoa4te//jWpVAqVSoXH4yGVSs31tLJ8TCaFx0Qiwc0338x4xtAyPz+fZcuW4fP58Hq9GI9Bb4fJstjwYD9vPvYgy8/Ywkiwlwf/+/sgCDg8pfiP34CUFgmsPZGa9RuVi9mcgsLDMkcxkSDR1KT4dMTr6onV1yOOyqW7CAK60lIMNTXkfOICxa9D43ZnL7xnQZIkRkdHFZPSeDzOueeeC8DOnTvp7++nuLiYmpoapZVlkgV+P71N9SSsFrQzGN75VhzHJ7//Y+zuj/46SSflCFrZpHSU/raxaRG0uQUmyhbkKSal+cUW1LPsimeZf8QjE3S+9w6lCxejM5p4/aG/sO3+uwEw2XMorAqwaNPpFFb5KfBVoZ2lilZKiyAxY+VEeixB6G+NWNYWYaj64Ot4YmKCjtpWLA8MIyDwlqaNHZoWvl75BXQeK6lUikQiQTqdRq1Ws3nzZrSCBrE3isZtoty8byFdbdOTc27FPn92JJAUk7SMtFAfqqd2qJb6UD11w3WMJcYAUAkqym3lrHSvlNtY8gP4c/3kGo7t1tDDyZuP/o3epgaCLY2M9ssi1IINmzjzhm9gzXey6erP4yrz4Sr3oTNmW4uyzExWAMkyI6lUisHBQQoKCti6dSt1dXVcf/319Pb2Mjgo95Fv2bIFs9l8zJshHg3k5uayevVqysrK8Hq9WSPaecbelVZ/+tOfkCSJK6+8Ep1Ox7Jly8jPz8fn82G32+d4poefSbNSc04uYirNvf/+bU6++vO4vBW8+/xzlC1ZQcmCxXzixu9TWOXHYD58sY8AqVCIeF3dNL+OeEsLZARIwWhEX12F7YwzMAT8sthRXY3qQ9IPsqC0ZQK8/PLLbN++nYkJ2RRSrVbj8XgUg8ZLL70Ug8EwTUCKjoV55vZb6GmoY7CzHSSJ0z7/ZZbM0MJistkx2WZ+j0mixEj/pG/HGMHWUQa7xhHTUub3dbjLbfiPL5C9O8ps6I3ZS7WjiXQqxWBHGz2NdRT7F+Dy+uhrauTh//lPLvzuf+BduoKqNeuwuwsorPRj1uUgRdOKJwZhEWbQP1Kjcfp+9Do5n6jEsnoGEU4lkA7FkTLtUwMDA+zatYu1a9disVior6/nkcce4YvXfh5HkZN0fymW9lJ0gRwAjj/+eI4//njlcMr1n2/+VJlFkhFF4Jj8ago1kRDlKiuD2kB1bjVnes/En+enJq+GytxKjJpjb8PgcJOIRuhvbaEv08Ki1es5/bqvAHKFXSoRx+2rYsmpZ1JQUYWrXBbVBEFgxZnnzuXUs8wjjsgWGEEQtgBbKisrP9fY2DjX0zmmGBwcpLa2ltbWVjo7O0mn03znO9+hrq6O7u5uTj/9dARByKZ6zEOeeeYZDAYDGzZsmOupZDkI7N2u1NLSQigU4pvf/CYqlYo333wTSZI47rjj5nqac4IophFTaV554B566msJNjeSSiZYf+lVrNpyAX//zc0sPvUMiv0LkEQRlfrwGENKokiivZ14fb0scmRaWVLBqXJqjcuFviaAwR9Q/Dp0ZaUIh2mO85lUKkUwGFQMSru6uhgaGuIb3/gGVquVXbt20dbWplR2uN3uDzVwTiWT3P6la3B5fYrfS2FV9UfeXZwYjSsmpf1tYfrbx5QIWq1ejavMqrSxuMttmHOyEbRHGxMjIXoaahX/jmBLE6lEHJWg5rSTPk/V2RtQuXQE25px+yrR6qY2H8RIkp7/eHXa8exnl2Pd4Hn/3QAgJUXGXujEUJOPrnhKyI3H4wDo9XqCwSAPP/wwZ5xxBqWlpbS1tXHXXXdx1VVXUVZWxvj4OENDQxQVFR0VFbyD0cFpQkf9cD3t4XYk5PVPjj5HiZqdFDvKbGWoVdnP3ENNMh4j1NujmIY/9etf8O4LzzHp5GzJd1C2eBlnXP81eXwiPu39kSXLbGRTYLLsk3Q6jSAIdHd38/zzz3PBBRfQ2NjIww8/jMvlwuv14vV6qaqqOipOgsc6999/PyaTiXPOOWeup5LlYyCKIn19fYrg0dHRobQrFRcX4/P5WLduHbpj0OthsLMdMZ3GWVbOXd/6MqWLl3HSpz7LbV+6Bmtevrxw9ddQ7F+AeYbWhYONGIkQb2iY7tfR2IgUybQ2aDTofb5pCSz6QABNXt5hmd98R5IkQqEQXV1dlJWVYbfb2b17Nw899BAAZrNZETpWrVqFeYZqmRf/dCdWh5Plm2f+XNw7bWM2ErEUg51j9GXiZ4NtYcaH5YWnoBLILzZP8+3ILTSjmsW8McuRiZQSEaMpBLWAyrTva6NkJEbzj56jdWwP7/VuA0Cl1uAur8gks/gprPAz9vMGbKeVYTtl334xkigReTOIyiybgqpMGtR2PSrDzMJdKpWiubmZ3NxcXC4XoVCIm266iXPPPZcVK1YwNjbG3/72NzZu3EhZWRnpTAS2ep6LrKIk0jXW9YHI2YHogDKm2FI8LXI2kBfAbcq2DR4uQr3dtL/9lmxQ2tzIYJfsX/Xl//sLWp2ed194jtH+IAUVVbh9lYftfJ3l6CTrAZIFkAWP3t5ecnNzGRoa4u677+aKK65ApVIRDocZGxtjwYIFVFdXz3ixmOXIZHh4mK6uLpYsWTLjmEsuueQwzijLwWCyNL+uro6HH36YaDQKgMvlYtWqVfh8PsrKyo6pdqVENEJvUwM9DbVo9QZWnXMBj/78v8lxF3DBt/+N8hXH4SgpQxAEPnfL71Ed4l08SZJI9fdPT2CpqyPR3q7sYqlsNgx+PzkXXahUdugqK1Edg2LVgTAxMcHrr7+uVHhMvh+2bNnCypUr8fl8XHTRRXg8Hux2+0da1ARbmkhmdsdnYl/HkSNoJwi2TlV3DPdMKBG0NoeBQp8d18my2OEotaLVze8F5oGSDscRtGpUs7T0xJpH0Nj1aBwztxqMv9qDlJJAlJBECV2JFUNFzozjh//SgMGfi2nJzCbP/bfuxrTcheWEmU2/u7+/HSkpQiqT9HFyCYb1TvQm+Xrp0Z//N1q9njO++HU0Rj2JVBSry8XG066lsMqPy1vxAcNS67/lI8wSTSyoBMyrC2b8OcifQc888wyFhYUsXrwYgPvuu4+1a9dy6qmnYrfbOfnkkxU/G6vVyqc//Wnl9+ej8JFMJ2kaaZpe2RGqZyKZaW8T1PhyfJxQdIIidPjz/Nh0+47TzXJwSadSDHa2Z4SOJk646DIsefk073idF+76PUarDXdFFRWr1uD2VSEIclX5wpNOmeOZZzlWyAogRznxeJw333yT1tZWOjo6SCQSbNmyhZqaGpYuXYrRaMTlcvGlL31J+Z1jaTF1tPD222+zdetWKisrs34s85hJwWN4eJg//vGPnH766SxYsIDc3Fyqq6upqKigvLwcq9U611M9bIQH+xnp66N00RKe/s1NvPv8c0iSCIKAb/kqVp1zAadf9xVlp2jDZVMX9gdb/JCSSeItrcTraonV1hGrlys70iMjyhhtSQmGQADblnMw1NRg8PvRFGUTAfaHZDJJX1+f0sZSXl7OypUrAXjxxRdxOp0EAgGKi4vxeDxKepHNZmPRokXKcd565kkGO9s55TNfmPG+LvrX//rQ50aSJMaGYorQEWwLM9A+RiopL4T15kwE7TKn3MritWG0fri4JSbSCCph1pjPRPc4KrMWTc7M5+XI7n6klIQkiiBKaAst6MtmXuiNPNaCvtyOcWH+jGMG73wHw8L8mX0kgN6fvIGUSMtCRFrCsr4Y+2llM4//8RtY1xdjP7N85vu9450PHTPyaAukp6qXrSd5ZhVAEu1htK7Zz4sqsxZBO/vnhXGFg8joKONjQ4SGe2l75CHGHhrm87feCUC+pwS1Vn7eBUFgyY8umvV4wKxi0N7EYjEikQh5mQqxP/3pT9hsNrZs2YIgCDQ1NSEIAosXL0aj0XDttdcqY1UqFSeeeOJHup8jkbHEGPXD0/06mkebSYlyK5lRY8Sf62eLbws1+XIbS2VOJXp19lr2cCCm04jpNBqdjr7mRp6749cMtLeSTiYB0JvM1Jy4CUtePgtOPJnqNeuwOpzZc2KWOSUrgBxFiKJIPB5Hq9Vy3333UVVVxfLly9m6dSs5OTksWbIEr9dLeXk5JpOJs88+e66nnOUjkkgkUKlUM/arr1ixgiVLlmTFj3lGIpGgo6NDaWspLy9n8+bN2O12iouLlYQWt9vNBRdcMMezPfSIYhqVSk3zjtdoe2snp3zmerY/cC9Nb2zni7f/iaLqGix5+RRX11Cwl1lpsb/moM8lPTpKrK5eMSWN1deRaGxCylzUCXo9+qoqrKedil7x6/CjthxeA9X5jiiKxGIxTCYTkiRxxx130N3djSjK4oLNZqOgQN4BN5vNfPO6r6G3GFFbZhYYonXDkBJJN01AT4J41xh6z75FQ0EQCD/bjrbEitEvLxhjE8lpvh3BtjA1aZGBpEiPJOAstbBgQ5Hi22FzyBG0wV/uQqofZkSUGElLmFcXzNjaANDzH69iWVdEziyL/f5fv4VlbRE5Z808JvTXRrkyIYPlRM+sAkhkzwCCXj2rACIlxWkiw74wVOXIN1QCgkpA55n9tZ97fuWHxp86r12M2j77wrXwxtUIKgHUAoJKBerZF1IF/7zPCuhpOD79wZjMgfZWOt55i2BrM8GWJkI93bL4Cticbgqr/PirT1I+t9ZefMWH3s9Hpb29nZGREZYuXQrAPffcgyRJfPazn5X/poKCaef766+/ftqCcj7G10uSxEB0gLrhOiWFpXaolq7xLmVMniGPmrwa1hevl2NncwOU2kpRCVlfusOBJIoM93YTbGki2NxIX0sT/W3NbPzUtSw97Uz0ZjManY5lm8+hwFeJu6KKHHeh8tqczSA6S5bDSdYDZB4z6QmQTCYpLS3l5ptvpqysjPPPP58//elPVFVVsXr1aqLR6DEZdTmfEUWRnp4eZWHc2dnJpZdeSlVV1VxPLcsBMNmGtvfzOhklWFJSwpIlS1ixYsVcT/OwER0fo7v2XXoaaulpqGWgvY3rb7ubnU8+wp5nn+TT//MrwoMDpFNJnGXlh2THSBJFkl1dSuvKZOxsqqdXGaN2ODAEAhmfDtmvQ+f1InyIgebhID2RlL0IZvEEiLeNTmsZ0OTq0bpnXoiOvdyNtsCMoTJnxjGhh5rQl9sxLZ25rWDgd28jxlJKhYB5hRthZQ5dXV1KG0t3dzcul4vPfvazdP/7dl53tWGtdir+HTbb9IV81/e2IVao6DK30NfcyHn//C+oNdN9GLr/3zakxF6CwPpics7x7XOOqWSavv98lWiRhTadhmBbmNF+ubUGAXILzLi9Vip6xtAvyMd1tm/GCNrhe+uQRAlBrQKV8KFtF2MvdaMtMs9avRCtG0aTZ5i1giE1FAVhUhAQEPRqVMd4u83Hoaehlp1PPMJpn/8yepOJbfffzat/vRdLXj6u8grc5ZW4fRUUVFQfFG+CyYo/gLfeeoumpiYuvPBCAB566CEaGxv55je/CUBTUxMAlZWVB3y/RwJpMU37WPs0r4664TqGY8PKmFJrqWJKOtnG4jTN/H7KcnCRJImRYC/B5kYMVhveJcuJjY/zq89eCoBGr8ddXoHbV4X/hA0UVQfmeMZZskwn6wFylLF7925qa2tpb28nFovh8Xi49tprWbt2rRJxecUVUzsRWfFj/jE2Nsbvfvc7QN7pWbNmDTk5OXM7qSwHxJNPPsnu3bsVN/7J59Xn81FaWnrUm5dKmR39gY42dj7xMCde+Rma33yNv//2Ztkc0FfB4pNPJ5mIs2rLBaw+Ty4fz/eU7N/9pEQQkBeh70OMxYg3NhLZ2UiitZ14WwfJzi7SI0GkiQFQqdD5yjEtX4HhcjmBxRDwE28X0TiNs+6qjz7dhs5jwbjQMeOYobvfQ4ynIS0LEcbFDqzrimcc3/vj1zEtc2Hf7J1xTN9P3sC8yk3OlooZxwze+a4SeQnIVQezjA8/0455lXtWASTePILaMrs5dkot0q8aISSNs8hRgcqi5ZFHH6W+vh5BEHC73SxevJjSUrlKwrqhmDM8fqUS4/3UvfIie3oeZbxtmFCyH2dJGROhEDana9o453VLM68BAVRTRpWTEbTBtjDBjFGpEkHbH8dk1+H22qhZW4jba8O5nxG0eZfu3wLAumHm534SY+DDTXE1+dlz/EclMjpCsLWZ/kxVR7C1mdM+fwPeJcuJT0zQ29TA+PAgelMpyzefw7LTzz4oYkc8Hqevr4+SkhJUKhWvv/46zz77LN/85jfRarVMTEwwNDREKpVCo9FwyimncMYZZyi/P5+Fj3g6TlOoidrhWqWFpSHUQDQlC40alYaqnCpO9JyopLFU51Zj0WWr6eaC7Q/8ma7adwi2NhHPRIZXrDoe75LlGCwWzvnat8kvLiHPU3LIPbayZDlUZCtAjmBEUWRkZIS8vDxeeOEFmpqa+OxnP8tDDz1Ee3s75eXleL1exQE/y/xi792ffVFXV4fH48GSLak/7EiSBJMfjRLyYmqWtAYxlpIXWnvtuu7cuZPXXnuN6667DpVKxdannyM8MUZFdSXl5eX7NBpODkRAlJT7VZk0qG0zl4MnOsdkf4A8w4xjYs0jqK26WXeQJ1sG5NOBhCbPOC1C8f1EdvejzjOgL51ZEAg920I4NYzj+ApGgn08+N//zgXf+XckSeSRn/2QC779/1C/niQxOoHeaEZAwBDIw3L8zJ4DwZt2YlyYj+3UmX0Guv/9Fcwr3ViOtynVHPHaOmL19SRaW0EUsZz9CwTt1OOhcU1gP82DvqoSleGDj2X3v7+CeYWbnHNnFg16f/QaxmWuWdsZBm7bIws0KgFBLWBc5JjVdHHkiRZ0JTZMi2cWVcZf70XrMqH3znwOiLeMAFMVAiqrblZPCTGeRlDP7k0xE+3t7bz11lt0d3fT39/P5DXGt7/9bYxGI11dXYiiSEFBwQdEv2RCFgdnijkc6eul9uXnKaquoaCyGv2HtPxNjMYVoWOynSURk4UgrV6Ny2vNeHbYcXltWHKzngFHE8lYjI539xDMlOkHW5sZHxpUfp5TUIirvJKVZ51HUXXgI6f9fBRCoRB79uxh5cqVWCwWJaHohhtuwOFw0N7eTn19PRs2bDiqNqlG46PTvDrqhutoHW0lLcnvO4vWgj/Pr1R01OTV4LP70KqzSYOHC0mSGA8NEWxuItgit7EIwCdu/D4A9//Hd0lEI7h9lbh9VRRUVJHvKUV9BFQ8ZsmyP2QrQOYJoijS399PZ2cnq1at4h//+Afbt2/nO9/5DjabDYfDQTqd5pxzzpnRC+JQIGUWZB+6AMyMkyQQNCpUszibp0biCFoVavPMJ71kfwSVQT37ArBrDGmyT1mSUFt1s+6GxZpGUFu1s5Z/R98bQm3Xz74AfKtf7pHO3LXGZZp1d3j8tV40DqNS6vznP/8ZrVbLRRdNmaSNvdSF1mXCkNn9DAQ+uJsYfq4DMZHO3K+EvtSGcdHMi6ORx1rQlVgwLXXNOCb0t0Z0ZTbMK90zjhm+t07euc78vR+2UB38w7voK3Owrp95h3Pgtj0Y/LlYT5p5hz/4q91I0RRIEhJgXu6adfHb97M3MS50YD/DO+OY3h+9hnGxc8aSeJB786VoSvm3+YRCcs/b9w5cPB5n538/TdAZoUcY5qKLLsLlcmE0GsnPz1f8DapfNWFaVkbuopl38vpvfesj3y/AwB3vYFrmnHXM0N21Hzpm+L76D9yvrnjm8aGHmzEtcyoCiCRJiOk08cgEr/zlHnoaalknnkPHxHuM6UP4Vq7Gf8IG9EYj+Z5Srr/tbtkz4endaOIaxHgC1MK0KoV9oSu1on6f2COlUiTa2ojV1hGvryM9qGLwt2/T+81XlTHaoiL0gQC2zZvRB/wIxjLUefkIGhWCSkCdo0frnHkxXfBPKxE+pKWg8MY1s/4cwPn5mVOa9kXOWTO/RieZzaRyEr0vZ7/ud7bPbpCf73A4rJiUdnd3c+6555Kfn8/g4CDvvfcexcXF+P1+PB4PRUVFyiLP4/Hs85ihvh7+8E/Xs/kLX2XBiSfvc0xOQSEnXHTZPn+WiKUYaB+b5tsxHpIFFZVKIN9joWp1AW6vFbfXTk6BKRtBe5QhptNsf+Ae3BXVVK5aQ3QszEM/+Q8QBPIKi/EEFsqLuvIKnF6f4iE0yf6KH+l0GlEU0Wq1DA4O8vjjj7Np0yZKS0sZGxtj69atyiZGRUUFl19+uWJgXVZWRlnZzOeyIx1Jkuib6PtA5GzPRI8yxmV0EcgPsKlkEzX5chtLsaU469dxmJkYCTHQ3op3qdxeK5uJPwuAoFLhKCmjyL9AGX/x936QNSjNctSTFUAOEYP/964sCmQWjMaFjg+Uu0qShCRJ9Pb28txdj9OTGiKWki/YfD4fCxcuVNztly9fTtE2mNjaNfsC8H/fRIyklAWyeVXBrG7qPT98DdNix6zl0L3/9SrGpbMvoPp+8oZ8vxk+bOHWf/PODz3mwG/e+tAxg3e8s1/3O3xP7YceM/RAA8alzlkXgCMPN3/gfmcTQMJPt2Fc6lQEEI/H8wERa2xrpzxmhvJvgPFXexGjSUBAEACRWQWQWMOwvIu7dMYhJLrHUdtmb79IjcaRYmkQAOHDF6p8hHOnyqpD0M/+EaR1mxRzP0EAde7MlQ4ABn8e2sLZd4VNK93oimavqrGe5FGiDhEEdCVTBorpdJru7m7Fx6OrqwsREc2wmtKyMpIZk8yamhpqaqbMOXO2+D60VD3vwipZ0BMA4cNL2/OvCMwqEAI4rlk4q9AI4LpuiSx0CvLrarJlYCacX15K2zs7iDWmyS8p5Y6vXceqs89n6eazqX/lRVzlFfRVDVDu30BhdQ16k4nTPn/DB47j/tKyWe/n/dhOLSBeX8/w3c/KlR119cQbG5EybUWCVouuqhLTkhoMl9yIPhDA4PejPsAKuQ97jI92YrEYkiQpFRz33nsv4+PjgByhWVBQoETSLlu2jBUrVnzgAjqdSpGMxTDMUNFmd7lZfd5FOEq9HzofMS0y1DMxrboj1Pu+CNrKHNxeGy6vDWeJBU3WE+OoQJIkRoN9mTYWuYUlx13Iqdd+EZVazbsv/AMxnaZy1RqsDieXfv8nOL3l6AwHVmUxuUGl0+nIy8sjHA5z0003ceaZZ7Jq1SoMBgPxeFz5/C8uLubGG29UUvWsVuu8Te9KiSnaRtumeXXUheoYjY8CICBQZitjqXMpl/gvoSZPTmLJN85sspvl0DHY2U7TG6/S19xIsKWR8eEhAK6//U+YbHaq16xTvDuc3vIPVNxlxY8sxwJHZAuMIAhbgC2VlZWfa2xsnOvpfCxkASQtL1IFMCzIx7K2iIGBAaxWK4ODg/z5z3/msssuQxRFHrj7fkpdxVQdtwCv17tPv4fQg43oSmyYV828Uz/yWAtSMrM4FQT0PvusJmzhZ9vRFlpmdYMfe7ELrdv0oQtzKTW1UNUWmmfddfwoJfTRd4dQ58xeiRFrDMmVJ4IgV3jb9bOW+n+UloFkcAKVcfbWg1QoprRGIAiodCpl0dja2sp7773HWWedpZxIxGgK1MKsxnRSWo72nK3SJsvcMTY2xqOPPkpbWxuJRAKQnfZ9Ph8+n4+SkhK02qOvjLfrvXfob29hoL2NwQ55F2ntJVfyq89eiv+EDZz2uRvY+n+3U750Bd5lK5FEUU5mOAAkSSLZ3aMksEx+T3ZNpQGoc3MzySsB5bveV45wFD4Hh5NJc+1Jg9Kuri4GBwc57bTTWLduHWNjYzzzzDOKSWlBQcGHViRKksRvv3AVlccdz6nXfmnWsfv63ckI2knBY6BjKoLWYNbiyqSxyIKHFeMsCTFZ5hehvh76mhoU347+1mbiEdmXQKXW4Cgpw7fyONZdciUgV4Go1AdH7Gpra0OlUlFaWkoqleJHP/oRq1evZvPmzUiSxHPPPUcgEJixqmk+Ek1FaQg1UDckixx1Q3U0jjQST8sis06loyq3SmlhCeQFqM6txqTNJtAdbmIT47KPTSaRZd2lnyKvyMM7W5/h6d/cRG5hMW5fJQUVVbh9lRRW+T9gGJ0ly9HMbC0wR6QAMsl89wCRJInBwUFaW1uVHf9bb72V8847j+rqav7+979zwgkn4Ha7s4rrUcQbb7zB888/z/XXX5/175jHSJLEI488Qm5uLieeeCKpVIrbb7+dkpISfD4fXq/3qIodHurqIBmLUVBZzZO/+l+MVhsbr7qWO752HaHeboxWG86ycqqPX8/S085kuKcbm8OJ5gDNW8V4nHhTk5LAEq+tJVZfjzg2Jg8QBHRlZehrAhgmxY5ADRqXM/u5eYBIkkQoFKK7uxudToff7yeZTPKjH/0IURQxmUwUFxfj8Xiorq6msHDf7TaimCYaDs9qFvnWM0+Q4y6ibMmyWecUG08SbM9UdrTK1R2xcXlXXa1V4SyxKvGzLq8Nm8OQfR0cRbS/vZu+pgbWXHAJAH/5z3+h4523UGu1OEu9uH2VSiJLfkkZmoMoeDY1NRGLxVi0aBEAv/zlL8nPz+fyyy8HoLGxEZfLddR4roVioWnGpHXDdbSH2xEno351tmlCRyAvQLm9HI0qWzx+uElEI4iiiMFsob+thcd+8d+EeqfajezuAk7//FcoXbSERCyKJIroTbNHTmc5dkmPxkmNxhGjKaRICjGSRIym5K+I/F1Kizg/u3iup3pAZD1ADjOpVIoHH3yQtrY2JjIOyhs3buSkk07i/PPPx+fzYTabueCCC+Z4pln2l8n2B4fDMePid/ny5axatSp7UT6PiMVitLW10dLSQjQa5cILL0QQBBKJhFLSrNFouP766+d4pgfOxEiIgbYWBjraGOhoQ28yc8pnvsDfb7sFQYBLv/8TdEYT2kzJ+Dlf+zbmnFxM9pxpr+m8og9PsHg/qeFhWeiorVNiZ+MtLZCWq9YEkwlDdTW2s8/CkImb1VdXozqKhKYjge3bt9PS0kJ3dzeRSASQ2y79fj9arZbLLrsMh8NBTk7OjJ9jPQ11tL21g56GOnob67E7XVz1P7fMeJ9LTzvrA/+XSqYZ7BxXhI7+tjCjA1MRtHmFZrxLHBmjUht5xWbU+0j3yTK/SKeSDHV1EmxtItgit7Jc9C//ic5oovPdt9n11KOs2vIJ1BoNGy6/GrVGQ15xyUE3YWxoaKCvr48TTzwRkDcvQqGQIoBcfPHF02KY52sMvSRJdI93UzdcN82zoz/Sr4wpNBfiz/NzhvcMJXq20FyYvY6ZA8R0mt7GesWgNNjcyHBvNxsu+zSrz7sIS24ejhIvC086FXemusNomWqvOtB2ryxHPlJSJB1JIkZSSNGkIloo3zP/l3thFSqDhvDznYy/1EXhvx6PIAiM/r2dyI7gB44r6NWoTBpURg0qs/agGkMfaWQFkEOARqNhfHyciooKvF4vXq+X3NxcBEFg2bJlcz29LPtJPB5n9+7dNDc3K+0P559//ozP5eE0qM3y8UilUnR1dSk+Ht3d3UiShFarxev1Kgk9F1988VxP9WOTTMQZGxwkr6iYt555koH2Fk699ks8+7tbaXpjOwCWvHzKFi8DYNNV1yqixymf+YJyHJf3w40434+UTpNo7yBeVzuVxFJXT6p/6oJbU1CAwe/HcsrJGAIBDIEA2tLSA26fySKTSqWUVpauri5isZgSj97S0sLIyAjV1dVKK4vbPdVa+VEWerUvP89bf38CR2kZNetPongvE719IYkSoWBkmm/HUNc4YsY825yjx11uY8H6IlxeG65SK7r9iKDNcmSSSiYZ7GiTk1hamwm2NjHY0UY6JXto6YxGXN4KomNhdEYTa86/mLWXXK7EaxZUHDzRoampiT179nDBBRcgCAJtbW3s2bOH9evXo1KpOOecc6YlshQUFBy0+z5cJMUkLSMt06o66ofrGUvKFXUqQYXP7uO4guMUr45AboAcQ87cTvwYJZVIMNDRSrC5CYPFQmDdSYiiyF/+87ukUynMuXkUVFQRWH+Scq422XM49xvfnduJZzlgJFFCiu0tWuxViZH5P8vaIjR5BqLvDjH6dBvOzy1GbdUx9kIn4Wc79n1glaCIGFI8DQYN2gIzpmUuEAE1WE4oxLjYMSV2ZL6EY2iDIdsCkyXLhxCPx/nxj3+M3W7H5/NRUVFBeXn5URVdd6zQ2NjIa6+9Rnt7O8lkEkEQKC4uVnw89mVOe6QjSRJjgwMMdLQy0N7G+PAgp177JZ657RYaXtvGF393D6/cfzddde9yyf/7EX1NDaSSCRyl3mm7Rh8XcWKCWH2D4tMRq68j3tCIlDHFRKNBX1GBIRCQTUlrAuj9fjS5M7dLZNk/RFFkeHiY/Px8BEFg69atvPTSS4iiXMpusVgoKSnh4osvRqVSfWgEd6i3m8bXt7PqnAtm9FOYGAmh0elnjKKdGIkrvh3BtjAD7XtF0BrUuMr28u0oy0bQHi1EwqPUv/Ii5ctWkVNQSO3Lz/PEL38KgN5sxl0+2cJSgdtXSY678JCJnm1tbTz//PNcfPHFmM1mduzYwcsvv8xnP/tZLBYLiUQCjUYz63vhSGYiOUFDqIHaoak2lqaRJpKiXLVoUBuozqsmkBsgkB8gkBugKrcKg2Z2M/Esh4a9/bFeuucPtL21i8HONsRMBaRvxXFc8O1/A6Dz3T3kFhZjycsayR7pSMn0lGjxvgoMQ3Uu2gIzyb4JRh5vwX5GObpiC5G3Bhi+t04JytgXgk6N45qF6MvtxFtGGH+lh5xzK1Db9CS6xkj0jKMyamXxwpT5MmoRdKqjtmpjf8m2wGTJMguJRIKJiQlyZ1iQ6fV6vv71r89bB/djmcHBQZ5//nk2btyIw+EgEokwMjLC8uXLFR8Pg2H+XAwmohG0BiM9DXXUv/Iimz79Obb/9V62P3CPMsbuLiCZiLNo02mULV2OJIms++SnlJ8XVvk/9v2nBgaI1dZmWlhqidfWkWhvZzJ+Q2W3YwgEyL3kYvSZFhZdRQWqA/QJyTKdaDRKR0eHYlTa3d1NLBbjK1/5Cnl5eRQWFnLCCSco1R02m23aBdGHLfj6Wpp46Z4/4Fu+asZUlr39PhKxFP3tY9N8OyZGpkfQVq8uUMxKc92mrNnzPCcRjdDf1qK0sJQvX0Vg3UkkY1H+cedvOf06PTkFhZQuWsqWf7oRd3kFNueh8TubFPT6+vp48MEHOeeccygpKUGlUinnd7PZzIoVK1i5cqXye7p59Lk0GB1URI7aoVrqQ/V0hDuQMiuoXH0ugbwAV9Zcqfh1lNnKUKuy6UdzgZhOM9TVQV9LI8HmJoItjaSSST6daRMcGx7CaLOxassnKPBV4a6oxJo/FVhQsnD/ItOzHBhKNcY0H4wkGqcJXZEFMZJk5PFWTCtcGCpySHSPy2EXkdRUYuA+EAxqtAWyF4sUT8thB4C2wIT15NK9xAvtVCWGSYPKoJETHDPofTnTgiV0His6T3ZNciBkK0CyHPPcfvvtaLVarr766rmeSpYDIBKJ0NraSktLCxUVFSxYsIDh4WHuuOMOzj//fCorK+dNP6Mophnp62Ows42B9jaO23IB9a++zN9/czNf+O1dtOx6g+f/73dc/bNbiYyO0NfciLPMi6OkDJ3xwP0yprWwKIJHHenBQWWM1uPBUFMjm5MGAhhqatAUFMyLx3c+kUgk6Ovro6uri+rqahwOB++88w4PPPAAgiDgdrsVoaOmpuZDK9Mi4VHqXn4e34rV5BTs29Q0EYuSSiQw2T5o9phOiwx3T8jVHRnfjuHeCWUny+40ykJHRuxwlFjQaLOLsPlMbGI8074ip7AEW5oI9fUowqc5N4/jtlzIyrPPy6T2DGLNdxwysSOVSqHT6QiHw/z+979n48aNLF++nPHxcf72t7+xceNGSktLD/p9Hw5ESaRzrHNK7Mh4dgxGpz57iy3FSvvK5He3KWumP1eIYppQTw/B1iZq1m9EEASeue0W9jz3FAA6o0lJY9lw+dXZ5+kQIqVERbwQoykEvQZdoRlJkgg/046u1IYxkIcYSTJwxztI0SnRY1/VGNaNHuxnlCNGkgRv2oltsxfzCjepkTjhZ9unhAvTXuLFXlUZgl6dfb7nkGwFSJYss3DSSSehPkixeVkOH8lkko6ODsXHo7e3F5B39fLy5MjmvLw8vvGNbygnoCPxRCRJEhOhYRpe24b/hA0MtLXw8M9+SCoh76ALgorKVWsorKhm3Sc/haBSsWDDySzaeBqCIGDNd+D2VX7s+xdjMeINDdOqOmINDUgZc0y0WvSVlVg2bMBQU6O0sKhtM0dYZzkwxsfH2bp1K93d3QSDQSY3KvR6PQ6HA5/PxzXXXENhYeF+72InYzG2/t/taI3GGQUQncGIzmCULxoHYwTbRulvHZNbWTrHSE9G0Fq0uMttVK50yaJHmQ2DJRuzON/pfHcPqWSS8kys9W3XX00yHgPA6nDiLq+gZsNGOZHFW4ElN0/5XUEQsDmcMx16v0kkEsRiMWw2G+l0mp/97GesWLGCU089FYvFgtfrVVJZLBYLV1111UG770NNIp2gaaTpA34dkZT82asRNPhyfKwtWqtUdfjz/Nh02c/euaa/rYX3XvyHHEHb2kwyJrd8FlZWk1tYzIKTTsGzYBFuXxW5BYeuzetoRJIkpHharq4QJTQOWdSP7O5H0KkxLpDbgob+XEc6nJBNQDNVG1JyejWGcYmD/MtrEASBiVd7IS1hDOQh6NSyeJFv3MsHQ/s+IUOD2ia3ZqpMWgpvXKMcV5OjJ++i6sP0iGQ5FGQrQLIc1bz99tu8/PLLfP7zn8+KHEcJ27dvp7GxkY6ODlKpFCqVCo/Ho/h4FBcXH5HPdTqVItTTxUBHG8X+BcQmxnnwx9/njC9+HZ3ByD3/+g3O/9b3cJSUsfPJR3GWenGWlZPnKUGrOzj+CKlQSI6Zra2TKzvqakm0tELGK0JltcpeHTUBOYWlJoC+ogJhHpWKzyfC4bDSwtLV1UVFRQUbNmwgHo/zi1/8gsLCQiWGtri4eNZYbVFMM9TVSU99LTkFhYph3vuRJInx0BDWPMcHfhYdT9DfNqZ4d/S3hYlNTEXQukqtShuL22vDmp+NoJ3PTIyEMgu4JmLj42z69OcAuP8/vksyFuWKH/4cgHdfeA5zTi6u8op9VgUd1DlNTBAOh5XI5V/+8pc4nU4uvfRSAF566SUKCwuprPz4ou9cMJYYmyZ01A3X0TLSQkqSzWBNGpNsSLpX5GxlTiU6dfazd66QJInwQJC+TAtLsKWR9Zd+msIqP42vv8ITN/8Up7cct6+KgkwaS16xRzHwPdaRUiJiPI3aLIvi8Y4wUjSFwS8LpuGtnaSCEx9ML4mmZLNOQOux4L5hOQDBm3aitutxXL0QgIHb9iBJ0j58MKbEDHWOHq1TroqVRCnbenmMka0AyXLMotfrsdvtRCKRrIfHPKWuro7u7m5OOeUUAOrr64lEIqxatQqfz0dZWRl6/ZFloJhKJul6723s7gI0Wh0P/vj7DHV1Iqbli93TPn8DlcedQMnCJehNZpxlXq77zR8x58hpUZMLkY+LJEkku7qIvVc7VdVRW0sqOBV7piksxBAIYDt9syx41NSgLS7OLmgPEfF4nLGxMRwOB5IkceuttzIwMADInhwFBQXK61iv1/Otb33rIz8XD//0B3S88xaJqLxzvOSUM2YUQARBwJrnIJVIM9A5riSyBFtHCQ/GMoPkCNrypQ5F8MgrykbQzlcm21Km2ljkXeuJ0LAyxlFSppg0nv75L2PYyyB54UmnHLK5hUIhBgYGqK6Wd1MffPBBRkdH+dKXvgTApk2bpkXOb9iw4ZDN5WAgSRL9kf4PRM52j3crY/IN+QTyA5zoOVFpYymxlqASsu+vuUKSJMaHhxAEAUtePkNdHdz7b98mNi6n56g1Gpxl5SQylR6+Fcdxwx/uP+jRzEcak5vkgiCQCsVIj8bRe2URNPL2AImucaTIlOnn3mKGlEijMmko+n8nADD+YhfJgSgFGQEk0TZKciCqiBbaXP37Wkq0qHOmBEDHtYtR6abEJefn988nJSt+ZNmbbAVIlnmJJEkEg0FaWlrw+/3k52edso8GxsfHaW1tpbW1lTPPPBOtVstzzz3HO++8ww033IBarSaVSh0xSS2pRIKhrg50RiOW3Hwe+p//pGb9RqrWrOOWay5h/aVXsWrLBTz80x/gKPXiLCnDUVZOXlExas3BaRUQEwkSTU3TqjridfWI4+PyALUava8cfU3NVFVHIJBNYTnE9Pf3K0alXV1dDAwMUFBQwBe+IEcMv/jii+h0OoqLiykoKECr/fivh7/f9ktUKhVF1TUUVddgd0/3YhFFiVDfREbskM1K946gteTq5TSWjHeHs8yKznBkvMey7D+R0RG6at+h8rgTUKnVvHD3Hbz56N8AuaUur9iDu7wCV3klbl8FzjLfjGk+B5vBwUFaWlo47rjjEASBJ598kh07dvCd73wHjUZDZ2cnkiTNCw+PtJimfayduqHplR2heEgZU2Yrw5/rpya/RvnuMH6w+irL4UUU07Tu2pGp7Giir7mRyOgIq8+7iA2Xyy1fW/9wm1Ld4SgtO2jn7LlCjKdJh+No8o0IKoFE5xiJjvD7KjA+GMVa9G/Ho9JrGHmihYntvRT/5zoAhu+rJ7JnYB8+GHsZepq1WI6Xq7lSw7LArsmbP8bzWeY3s1WAZAWQLPOKaDTKE088QUtLCxMTEwCcc845rFq1z9d3liOcRCJBe3u74uMRzFQo6PV6rrnmGgoKCkilUqjVc28kFR7sR0ylsbsLePKWnxFsbSbU240kiqw46zw2XnUtD/zgeyzYsImFJ51Cd9175HtKMczStrC/pMNhYrV1GXNSWfCINzdDSq4sEUwmDH6/LHJkBA99VSWqeZR0M9+QJImRkRG6u7vp7+9n06ZNCILAAw88wDvvvIPRaFTaWDwez36X7m+77y6CLU184sbvf+TfGQ/FZd+OSaPS9jGSmQhanUGtCB2T1R1m+5FVQZXloyGJIqG+XqWiY/HJp5NX5OG9l7by5C0/49P/cwuOUi9dte8w0NGGu7wCZ2k52sP4eTA0NMTu3btZu3YtRqORN954g8cff5yvfvWr5ObmMjw8TDqdxuE4NKapBwtJkmgdbWX3wG7eG3qP2uFaGkONRFNyRYBWpaUyp3JaC4s/z49Za57jmWeJhEflVq/mRnQmMyvO3IIkSfzqs5eSiETJ95TgziSxlC5cQr7nyBTfJElCSooIahWCWiA1EifZNfaB6FUxOl3McHx6IdoCM+Pbexh5uJnCf1mD2qpj9Jl2xp7rAOS0kg+IFxlBw7qpBJVeQ3IgQjqcQO+zIwgCUloC1ZHprZYlC2QFkCxHEaIocuutt1JYWKh4PkwaoGWZH4yNjbFr1y5aWlro7OwknU6jVqspLS1VntPCwsIPjeo8VCRiUWLj49gcTl6+948YzBZWbfkEt33pGor9Czj7K9/krz/8f6i1OpxlXpylXgoqqrE5XQdtDpIkkertJVZXN62NJdk9VUatdjpkU9JMVYehpgZtaWnWbO0w0dTUxOuvv053d7cixqrVar7+9a9jsVgYHBxEpVKRm5t7QBeIO598hMHOdk773A37PE4imqK/PTzNt2NiNAGASi3g8Fim+XbkuLIRtPMROWmim2AmhaW/tZn+tmYSUXkBrtZoOPsr36JqzVqiY2FG+4M4y7yHfdd6ZGSEbdu2sWrVKtxuNy0tLdx1111cffXVlJWVEY1GSaVSR3xLaiwV453Bd9g9sJvd/bvZPbCb0fgoAFat9QN+HT67D616flcIHA0k4zG0elnge/6Pt9P4+nbCA/3yDwWBipWrOf+b3wNgsKMNu6vgsAqCeyPGUySDkWlJJGJkrwqMzL9tp5ViqMwlVj/M4J3v4rx+KfoyGxNvBgk90DB1QLWwl3gxJWTYTilF4zCSHIiQ7BrHsCAflV4tt6mIkhy5qs6eE7IcfWQFkCzzhq6uLqLRKFVVVXM9lSwHiVQqxY4dO3A6nfh8PoaHh7n55pspKCigoqICn89HSUnJfqdZHCiimCY2NobJnsPupx+n/e1dDHS0MRrso2zJci76l//kof/5T8w5uZz2uRto2fUG5pw83OUVB3UeUjJJvKV1qqqjro54bS3pUfliG0FA5/VOq+owBPxonAcvaSHLvkmlUgSDQaWNpbu7m4suuojCwkLefvttXnjhBSWCtri4GLfbvV/tWbXbXmDbvX/k0z/9lXLRPhvplMhQ996+HWFCwchUBK3LOK2yw+HJRtDORyRRZKCjDZ1BTuoZ7unmru98hVRcTobS6PQ4y7xKC4u7vJJ8T8mclOhHo1Eef/xxFi9ejN/vZ3R0lF/96lecd955LFy4kHQ6TSqVOuJ8mt7PYHSQ3f272dW/i939u3lv+D1SolxZ57V5We5aznLXcpa6llJuK8/ueh8BJKIRWRBsbqQvU+GRiEX5wm/vQhAEXrj7DsaGBinwVeKuqMLlrTiorV6SKCGOJfZqF0nus5XEtMSJcZGD1FCU4C93kXt+JaZlLuItowzctucDxxX06ikhw6jBenIJhspcUiMxIrsHMC1zoskxkJ5Ikh6NK34Zgk6VfV1mybIX884EVRCELcCW+ebyneXA2bp1K+FwOCuAzGPGxsZoaWkhnU6zYsUK1Go1L774IgsXLsTn85Gbm8u3vvWtacZ2h5pkLIbWYKDx9VcI9faw+ryLeORnPyQ80M9VP/klXXXvMtTdhbu8kkUnnUpBlR9A2SkC8C0/7oDnkR6fIN5QL3t11MpVHfHGRqSEvGMv6PXo/X6smzcrXh0Gvx/VYXysjlUkSWJ4eBitVovNZqOrq4s777yTdFpuHTGbzXg8HsUUbvHixSxevPiA7tNsz6Wgopp4JPIBAUSSJEYHolNtLG1hBjrGSadke3yjVYvba6PqOLciehjM2R3o+UYqmWSos51gaxM6g5HAupOQJIk/f++bLDn1DDZ9+nPYXS6WnLwZV3kF7vIK8opLUB3mpCtJkhAEAVEUuffeeykrK2PdunXo9Xr6+vooLy8HwG63853vfEep4FOr1UdcKpcoiTSPNCtix67+XXSNdwGgU+lY5FjEVQuuYplzGctcy8g1ZP2S5ppkLEawrZlgcxNLTzsTjU7HKw/8mR2PPQiAzenC7avE7atCTKdRazScdOVnPvS4kighxVIfTCLZy9BTV2zBtNyFJEoEb9qJeXUB1nXFpMcS9P3o9X0fWIWSRpL25cj/ZdZiXuFGnfHA0BaYyL964XT/DKMGYQazaU2OAdvGEuXfarNWSVjJkiXL/pGtAMlyWIlGoxiNxhl/Pjg4iMlkOqyL4ywHRjwep62tTfHxmEy22NvwMRKJHJbnVBTTqFRqumrfoXXXmwx0tDHQ0QaiyHW/+SPP/v7XtL21g8/edDstO18nPjHBghNPVi7uDxaSJJHqH5hW1RGrfY9ke4cyRp2Tg2FBzTRzUp3Xi3CEGLwe7aTTaZqbm5UY2u7ubqLRKBs3bmTjxo1Eo1FeeuklpbrDbrd/6GtEEkWGujroaaijp6GWnoZaTr/uK3hqFn3ofKJjCbmqIyN2BNvCxCfkHWiNVoWzzDrNqDQbQTv/SCbiDLa3ZaJnm+lvbWaws11JhypdtISLv/dDANp27yC3yIPd5Z6buSaTijHvvffei06n4xOf+AQAf/nLXygpKeH444+fk7ntL5FkhHcG35EFj4HdvDXwFmMJOd0jz5DHctdyRexYkL8gGz17hBBsbWbXk4/Q19zIcHcXkiSLv1f+6Be4fZUMdrQxNjyE21eJ0WTdp4GnGEmhMmswr5DfR8P31aNxGLGdUookSXR/bxukZl4HCToVppVucs+TN2SH/lyHcUE+pqVOpJTIxI7gB6JXVUYNgn7ufcuyZDnWmXcVIFmOTl577TWeeuopvvWtb80ogjgcWXf0+UBvby91dXW0tLTQ3d2NKIpoNBrKyspYtmwZPp8Pt3vqwv1QiR+Dne10vL2b5Weey47HHuTVv93HF393Dx3vvMWbjz1EfrGHkgWLcZZ6kUSRjVddi1rzBQRBoGLlGuU4B3KhIqXTJNrbMxUdU4JHemhIGaMtKcFQU0PO+efLVR0LFqBxubIXSIeJZDJJX18fXV1dGI1Gli1bBsD9999POp3G6XQSCATweDx4vV4AjEYjp59++n7dT6ivl//75g0AmOw5FFUH9tmWkEykGewYmyZ4TEbQCgLkFZnxLXPinoygLTSjykbQzisSsajsw1HqBeDRn/83ja+/giTKiziD1Ya7vIJV55wvt7KUV2B3Fyi/71228rDNVZIkxsbGsNlsgBxFGwwGFQG7sLBwWmvXxRdffNjm9nEITgTZNbCLt/rfYlf/LuqG60hLciVXZU4lp5edrrS0lFhLsp/Dc0g6lWSwo52+5kaCzY0MtLSxdsulFPsWEG8aJfZeiHL3YqqPX4fbV4W93462SQM+cJR6EZ8cJfTXdxhOijPeh67UqgggkiTBXtGutlPKEDSqvRJMpntoCJrpn7v5lwWU24JGhWVN4SF4VLJkyXKoyVaAZDls9PX10dDQwKpVq7IVHvOM0dFR3nvvPVatWoVWq+XZZ59l27ZtFBUVKcalHo/ngKI8Z2NseJCOt99ioL1V/upo4zM//y21257nH3f8hs//+g8Md3fRvmcXx194KUgSaq32oPfEi9Eo8YaGjMiRaWOpb0CKyYtXtFr0VZWZio5M5Kzfj/oIN/w7Wtm6dSsNDQ0Eg0HEzMKzurqayy+/HICenh7y8/M/kj+BJEmM9PUAkFtYPOOYupefp7AqoETRiqJEqHdiWmXHUPcE0mQEbd5UBG1BuQ1HSTaCdr4Rj0xkTElbWH7mFlQqNc/+7lfUvvwCN9xxL4JKxc4nHyEaHpXbWHyVWPOdc7bwnvS2KS6WX8dPP/00O3bs4Nvf/jZqtZq3336bcDjM2rVrj3hxIC2maRxpnObf0TMhv08NagOLHIvkCg/XMpY6l2LXZ03TDzVSSvxAEokhkIeYTjPwUj0MixRcuJiRYB+7/uNe3HovOrURncqASvig0KuyaCn6V7naaPiBBqRoivxPLQAg/FwHYiy1zyqMSSFD0Kuzxs9ZshyDZE1QsxxSQqEQLS0tNDc3s3r1amUHNcv8ZXR0lJaWFjweD06nk/r6ev785z9zzTXXUFZWxvj4OGq1etZ2po9DbGKc7rr3KA4sYKCthefu+A3n/fO/MNDeyqM//280Wh35JWU4y7ysu+RKNHo9YjqNyXbwL2pTw8MfqOpItLZCZiGtstkwBAIZr46M2OHzIRxmM9djnbGxMaWFpauri0gkwvXXXw/AQw89xOjoqBJDW1xc/LHTJyRJ4tbPXUHFytWccf3XZhwzHopP8+3obx8jGc9E0Bo1uL3WaTG02Qja+UV0LKy0rwRbm+lvaWIk2Kv8/Jqf/4a8Ig/BlibGQ8OUL1+JSjW3HhjxeJyOjg7KysrQ6XS8+uqrPPXUU3z961/HbrfT2dlJf38/S5YsOWQi9sFiIjnBnoE9iuCxZ3APE0k5hclpdLLMtUyp7vDn+dGqjuy/50hFkiSkRDqTSpJC6zIhaFUkuseJNYawbvAgqAXGX+8luntgWtuJlEh/4Hgvqx8l2N7EIus6fPnLKP+vUxDFNO/c/Cg2dT5Ghx1Dnu2DQkbG4FNty55Xs2TJsn9kBZAsh4RYLMZvf/tbQqEQAFarlc2bN7No0Yf3u2c5sohGo9N8PIYy7Runnnoq69evJ5lMMjExQU5OzkG5v1QyKfe/d7Qx0NHKQHsbJ33qM6QSCe7//o1ceOP3seTl8/J9d7H+0quw5juYGAmRU1B40BcTkiiS7OxUqjritXXEamtJ9fcrYzRFhdOrOgI1aIuLjvjd0aONRCJBT08PpaWlqFQqnnnmGbZt2waASqXC7XZTXFzMmWeeud/Gi2NDg0yEhimorJ5xTOvuHdhdBeQVyTvn8ckI2tap6o7I+yJo3eV2RfTIRtDOLyZGQmgNBnQGIy273uC53/96KlITsDndSgrLpEGpyZ4zdxPOEIvFaGxspKSkhJycHJqamrj77ru56qqr8Pl8jIyM0N3dTWVl5RGfztI73suu/l2Kf0dDqAFREhEQqMqtUqo7ljmXUWwpzn4mvw8pLSFGk6j0agStmvRonFjLKEZ/LiqTlljTCJEdwX36ZyBOrQ/cX1uBtsDM+LZuRh5tofBf16C26Bjf1k1kzyBpVYpYcpzxyAjoBMrXrEJl1PD0nb9kfGIYXbENd0UFbl8VRdWBOfO2yZIly7FDVgDJcsh45JFHcLlcVFRU4HA4shcf8wRRFGlvb1cEj56eHiRJQqvV4vV6lbYW1wH6VEiiyEh/H3qjCVEUee73v2bZ6WdjycvjD9/4IgA6oxFHaTkbLr0Kt6+S/rYWXF4fWsOHx4LuL2IiQbyxkXhdHbH3auXI2bo6xAl5BxG1Gr3PJ5uTZqo6DIEA6oMk/GTZP8LhMI2NjUqFR39/P5Ikcf311+N2u2lra6O3t5fi4mIKCwsPaPf6wR9/n5G+Xq75+W/2+fPJCNpg61R1R6gvovw8x23C5bXi9tpxe+UIWrU269sxH5Ard4bob23G5nDhLCsn2NrM3d/5Klu+/h2qj19PsLWZNx5+QGlhcZVXYLQcGa1tyWSSXbt2UVhYSElJCaFQiJtuuomzzjqL1atXE4/H6e7uxuPxHPa48f0hJaaoD9Wzu3+3UuERjAQBMGqMLHEuYZlTrvBY4lyCVXdkPP6HGtm3AgSVgJhIk+gcQ+syobbqSA5EZAHj/fGrk9UYmeqz/KsWYFyQT7RumKE/vIvrS8vQlViJ7Opn9O9tiufFPltJTBr0FTmoDBrERIqJUAirW45hf+6O3/Dei8+RiEYB0Gh1lC9fxbnf+C4A48NDmHJy5rwKKkuWLMceWQEky8di586dRCIR1q9fP9dTyXIQCAaDjI2NUVlZiSiK/PSnPyUajeLxeBTBo7i4eJrZ3f4QGx+fqujoaMO3YjVF1QF+/bkrOOlTn2XpqWdy141fY90lV1L1/9k77/C2yrv9f87RnpaHJG9Z3s60E7JIGGFT9qbM0sVoael429Jf+3a83bule9GWMlooo5RdSguEFbJ3vLcteUqyts75/XHkY5skUCCJneR8riuXY5+hR7J8dJ77+X7ve/kq2jaux+3z43QfGjPQzPj4PlUdibY2SCuJC6LVqhiS1tergoepphpxjq+IHo3Issz4+LgqdCxYsIDi4mL27t3LPffcg9lsntHG4vP53tbKdTQ0TqCjjYpFTQfcZ6C1GUEQ8FZWK+MJxGb4dgS7w0jZtACLw6BWdngrcnD7HFoE7RGCLMuEggG1hWWwvYVAeyvR8TEAlp57ESdf+wHSySRbnnmcqqUrcBXOLaNDWZZ54YUXyM3NZeHChWQyGb71rW+xYsUKTjvtNGRZZmBgAI/HM+ciaKcTTobZElSMSrcEtrB1aCuxtDKR9lq9anVHk6eJ2txa9OKR740jSzLpkTiiWYfObkSKpoiqLSSpA8ax5pztx7GmhNTgBIM/3Ejee+uwLvYQbx1j6Pfbp4kXbxQyFB8Mc10u+nwLUiJNJpxC7zLtY/C5PybGRunbs4uBtmYlvai1mXQyya1/vB9Rp+P1fzzE2EA/3qpqCitryC8tP+wRzRoaGhr7QxNANN4RDz74IGNjY7z//W+dpa4x9xgdHaWnp4eFCxcCSpThwMAAt912G6AYQObl5WF+m5UWUiZDMh7DZLWx7i934fb5qV62ip9cd6ka52i2O1h1yZUsec8F7Hz+XxTXNhyySYQsy6T7+pSo2cmqjl27SPX1qfvo3W5M86biZs0NDRjKyhBEbYV+NpiMHY5EIjz66KP09vYSiUQA0Ol0nHvuuTQ1NZFMJgmHw+Tl5b1tkaxv7y62PPMEfXt3MTageDTc8rt797tqHw0lZ/h2DHaESESzEbRGEY/POc23w4EjT4ugPRKQJYlELIrZZkeSMjz0ra8w0NpMPKJEoAqiSEFpOZ7JFpbKaty+Cozmg+ttdDB4/vnnkSSJk08+GYBf/OIXlJaWct555wEQiUSw2Wxz9n0pyzI9kZ6p6o7gJlpGW5CREQWRuty6Gf4dhbbCtz7pLCGnMsiSjGjSI0sy8V3DM2JXpdgbhYw01kVucs6qQE5l6P3iSzjPrMC5toz0SJyB76wHQDDp9ptEIlr1mOvzMFXkIKcyJLrCGLxWdHajYqYsvLsks0kiI8MMtLUw2NbM0vdciNlu55W/3ce6v/4ZUaejoKyCwqoavFXVzDvhFPRzuJpIQ0NDQ4vB1diHRCJBd3c3VVVVB/zgPP/8899xNYDG4ScajdLe3q62tUx6s/h8PpxOJ6eddtqM8ufi4uK3Puf4GMHODoKdbdhcuTScsJbf3vpBfIsaOfOmj7P3lXWkUynqVp3AaR+8BXtePu7yCmy5UxPWeSeectCeo5xKkWhry5qTKsak8d27kcbHlR0EAaPfj6Wxkdyr3qu0sdTXodfilWeNdDpNIBCgp6dHrfCoqanhzDPPxGw2Mzo6qlYflZaW4vV61euO0WgkPz//HT1uZHSE9s0bKK5tYOEpZ1Jc14DRbCGVzBDsCs/w7QgPT4+gtVO1xKOalOYVWbUI2iMAScow2t9HZHgY36JGAO770mcxWq1ccvtXEEUdBrOZmuWr1BaWgvIKDMa5WfG1bt06+vr61MjZYDDI9AWrD33oQzM+n+12+2Ef4xuRZRkkQJJJppM0D+1hW2AbO4M72TW0kz3pVhCgjCKWOBs5vfF0mjxNzMtUY4zrQZKREzJ0SESloPJ9Rla8KERBjTKN7RhGiqWwHaeIJJFX+kiPJiC7ryzJkJn8KiFLMrocE65zKgEYfaQF0agj52w/AEN/2EFmPPGG47JfJQk5A6aqHAqyySP933kdS30euZfUADD8510w+asRmdE+orMbMHis6L1K8p1g0JF3RR2GEuX3pXOZKPrCCiVy9b+4zggGHeYq19T379BTaFKEHmxr4aUH7mGwrYWJ0RHlnIJIxaIllNTPY96Jp+Bb3IS73K8JHhoaGkcN2uz2GGXLli08/vjjfOxjHyMvL2+/+2jix9wmlUrR1dWlCh79/coqt9FoxO/3s3LlSiorK9XUi4I3EQFkSUIQRZrXv0wqHmfeCWv5y5c/R8+u7eo+NSuOp+GEtay8+AocBUr/7w0/+IVaRbHwlDMO6vPLRCIk9uzJVnUogkeiuRk5lQJAMJsx1dXiPOss1avDVFuLqEUszxqyLDM6OsrExARlZWUA3HHHHYxnBSqr1aqKHKBcY2655Za3/TihoQCvPvRXGs84B7fPv999qpetpOq4VYwNRBnsCNH8eogXH9jISN9UBK0jz4ynwsnCk0vxVjhxlzswmLTy7bmOlMkw3NudbWNpYbCtlWBHG6lEHJPNxkd+dx+CILD49LNnlOOf/8nPz9qYJ99zgiggS7Liz6ADvdmAlMzw2rpXeW3zem684gMIkkx6NE46kiDWMoogw9nzT8ZUrFzLM6EkydYxhBoXOruRVCBKonkUWUKZsO9vIp+Rsa8pQZ9nJtExzsSrA+ScW4nOZiC6NUh0Y2CGYIAEckaaIUK4P7gQXY6J8Lpews91U/S55Qh6kbFHW4m83KeIH9NwASfg4wR8wNmsu7aXxqIm3M+LxLcOUXzRKgCG79pJaMfwm75+olWvCiDRjYOkhmKqABLdHCTZE1HEAJ2gfBUFBF32qyggp6dVO2eyz2ny3DaDUkUxub9O3Od4vWfqc8V5ejn6XLP6+/Tc2qRWaghG3VtWY1ibPOr/BVFAZz+0wkIsElbbVwbbWhhoa2bNFdcy78RTEESRsf4+yhcsprCyGm9VLR6fX/Xgcro9ON2et3gEDQ0NjSMLrQXmKEWWZWRZRjxAiX84HCYYDFJeXq4JHUcIkiTR39+P3W4nJyeH3bt3c9999yGKImVlZaqPR3Fx8QH7vmVZJjw8xFBXB4noBA1rTubJn/+I0YE+3vvV7/DQd75KZHiYa7/9Y7Y88wTpZBK3r4KC8opDEjU7OaZ0IKBUdezerfh27NpFqqtL3UeXm4u5oQFTQz3mhnmYG+ox+nwI2nt31pkU4SarO6LRKHl5eXzsYx8DYMOGDZhMJkpKSnC5XAetVPsPn7qFM276GLUrVgNTEbTTKzsCXWHSWRNAk1U/I37WW+HEqkUrzhnklDQ14Z42cc8kU4iCDiSZ5g0vs/mlJwh2tuMU80lLSaJiBE9FFZXuxbjcReS4vThcBVPnmTaB17stWBqUiqLxZzoxljuw1OUhJTOMP9am7vfG4ya/WhYVYF9ehBRPE/zNNhwnlGBt9JAKRhn6/fb9VB9MnQsZzGeVkntCOdJQnJd+/DgvWPbw8ds+jmEgzYY7n6NDF2BVqg7jAdam8q6qx7rITbx5lKHfbcd90yJMFTlMbBhk9P69+x4goE7g0QkU3LAAk89JdNsQ44+34b5xEXqXmYnXB4i83L+PcDBDBNAJuM6rQucwEts9QnBLJ5saO9k0vJnM7jA5w2YkQUISZPKs+RQ6CilyFlOaU4rD7EQQBaxLvAg6gWRfhMx4Qv1dpAYmkKIp0In7FS/QKd/rnKbseyUDCAiayfA+JKITDLa1YjCbKKquY2JslF/eeK26PbeoGG9lDQtPOZPyBYtmcaQaGhoahxbNA+QYYWJiQq0GaG1t5bTTTmPRIu0D7khFlmVGRkZIpVIUFhYyMTHBd7/7XU455RROPPFEEokEXV1dlJeXH9AQcrinm6HuTupWrWHdX+9m05N/J5FNPLHmuLj5139m67NPEQuNs+Kiy4mFQ5istkNmYiZnMiQ7OmZUdcR37yYzMqLuYygvnxY3qwgeeo97zva2H0tkMhn6+vro6uri+OOPRxAEHnnkETZt2oTb7VZNSidTWd7RY6TTPP/n31NUW0/98ScecL94JEGwa4LBad4d0VA2glYv4C5zqEKHt8JJjsdyxL2H9p2IS4gWA4JOQIqmyEyk0OdbEESB9FicTCi535V/tZRfAusiN4JOINExTmowin2F8nuKbR8i2T8xYxL/RjFA0AvkXqSU/Yf/00N6JKZ+P/pIC6neyD4T/+kigj7PjOfmxQAEf7MVRAH3BxSPov7vrieTbUU6EElXmvWJp/D6q6nsqMVQasf7vsWIoo7eL65DTklvery10U3elfUA9H75Jewri8g5y48UTzPwvddnTrj3EQBErI1u7KuKkZIZRu7ZjW1ZIZb5+WRCCcaf6NjnuFBqApPBiNlkpjs0wAPbn+R973sf5Z4SOp/fza5YJ2tOPRGbYCbRMjZTfNjPGPT5FnQ2pWIkE0qizzEiGHTIqQxSUpopGkx+PQgkM0l2Du9UomgDm9kc3MxIXLlmO4wOFrsXq94d8/PnYzVoVXiHk01PPkrf3t0MtrUw2t8LQN2qEzj3ts8CsPHxRygor8Djr8Jsm/1WKQ0NDY3DgeYBcgyQTCb5/ve/jyRJmM1m/H6/2vqgceQQiURm+HiMj49TU1PD1Vdfjc1m46qrrqKkpAQAk8lETU2NEjU70M9wbzdVS5ez9dkn2fz041z7rR+z4/ln2fCPh6lethKXt5C6VSfg9lXiLq+goNwHwKJTz1Qf3+JwHrTnIsViSgvLtKqOxN69yPGs34LBgKmmBvvak9WqDlNdHbo50MuuMcX4+Di7du2ira2Nzs5OEokEAPX19eTn53PKKaeofh4HA51eT8fWTRitNvVnmZTEUDaCdrK6Y2wwig6l6j7Ha6WsIZfCIhsFxXZyPRZEUZiafCfSJDtDyiQ834zeZUZKZEg0j2IotaN3mcmEksT3jOyz6i9L0owJvWWRG2OxnVQwSuTFXuxrSjC4rSQ6xoms6ztwFUH2+9yLqjGWOojtHGbs7624P7QQfb6FyEt9jD/VMWNf9rM+4f3UUgxuKxOvDzL+eDvFX1mFYNITebGPyIu9b/n6WublIej0xLYPM/FavyqARLcNEdsSBJFpk2gRQYfyVRQQzFPCqBRLkYmk1O8FnaiYOIrCvkJCdmVfnFZxY2xwER4ZZtOTjzLY1oo+KBEfiyDJGRaccjqeqioio8P0teymonEpZqcDncNAZcVaABJdIUSzXo3X9HykcZ+KB+GNY5nmsVDy5ePV/4tmPcVfWPmWr526v1FHwfvmq9/rnCZcl9UQCAQwGo3k5eUxPDzM7++4i/POO4+lS+sxxrycXBDH6XQiWg34z1qIn4XqOaa3Rfw3jy8WTBm1CgYdOsPBE61H4iNsCWxhU1ARPHYM7SApKeJimaOMNSVrFMNSdxOVrkpEQavEONSkkgmCHW0MtCompaJOx5k3fRyAbc89QywcorCymnknnkJhZTWeymr12CXvuWC2hq2hoaExJ9EqQI4iJldhi4uLD9j6ojG3mKzimBQ8BgcHAVQRa7KtZdIIMhmLEuhoo7i2gfbNG3j1ob8w1NVJKqGICjf/5m66d2xj78svcObNHycRjZJJp8nxeA/p6nd6eDgrcuxUqzqSHR0gKSuyotOpVHXU16ttLKZKP4Lh6I0OleXsBDY7kVW/l2UEk9InLiUyyMkMOocyMcxMpJATGZD3PQZ5ykfAWKyIROmhGFI8jbFUETuTfRGllDz7uPK0Y5FlZAkEo4ilTvH9iTePgiRjzn4f3RZkdGiUruEeSlyF5FlyaB7s4JGtz+CyOCnPLaaiuJy6tYux2WxEXu5DtBmwLlI8Ycaf7EBOZrKtDMxoaUgnksRDYcbkISZKohx/2VUEf78dc20ujjUlSMkMgZ9uBkkmk8yQSUlI2bYIWZIRUea33QiM+3IoLLPjXdeL7bRyck/zkRqKMfi9t/68yDnbj+OkUtJDMQa+9zq5V9Rha/KQaBsn+Outb36wTiDvslqsjR4SnSGG79pJ/jUNmCpyiO0eYfzxNnXCP2MlftrKvPMMH8ZiO4muEBOv9JNzVgU6p4l46xjxncP7mbiLMyb01kY3otVAKhAl1RfBsqAAQS+SCkTJjMb3qVp44+Pr8swIooCUSCOnZXTZ+N7pHhUHm0nDxdBQkBfv+xOB9lZGenuQZeX6YHHm4K2sxuuvxuuvoqRh/iFruTuYdHR0IIoi5eXlpNNpvvnNb7J8+XLOPPNMZFnm9ddfp6qq6oA+W3MBWZZpD7UrySzZCo+OUAcAelHPvPx5NLmV6o7FnsUUWDRD6UNNOpVitK9H9Tf6529/ztZnn1TEWJTqzfIFiznnY/8DQCoeVz07NDQ0NA4GqUSc3S89z8K1B9ff73CiVYAcBfzzn/9kdHRUdYTfH01NTYdxRBrvhEwmw+DgoJrA8uCDD7Jnzx50Oh3l5eWceuqpVFb48eS7GR8cwFHgZrirk7//+pecdO0H6du1g2d//0uu/Op3EEURvcFI4wlnk1daRkFNBSarjcrqJVRWNsG4jEkygwyp3siMCbVo0WPImrol2sYQHUYMbqsS6bdnZN9JtzqBlkgPDSON9ZLq3Ul81y7SI3ZS3duQxrtBb8G88CyMtWdiXePF4PWgL/AgOhxT55BBMLoQDAYyEynC/+nBuqgAY6mD9HCM8Iu9B3z8yedgX1GEyZ9DKhAl9FQHjlPLlUll+zjhf3fv9xikqe9d51dhLHMQbx5l/PF28q9pQJ9vYWLDIOHnug8gXkyd033jYgweK5GX+xh/op2i2xUX//En2wn/p2e/K/fTKf7flQhWA6F/dRFZ10fp1xQfi/F/tBHdFHjzg/Wiun/o2S4SnSGKPrNMOf7xdqWU/k3Q5ZmxfEaZkIX/00MqmWIk1UdbWxstm3YTkqMALE9VsyjjI5cMV3A8jrgFRsGYsWGzKdUZkZf7MHhtqgAS3RRASmbesPovEB0fIx4NI8kSwUQnkVQMUEwHU8kM7VuHCLSNYw0liE+kSWdkJFnZbrYbsDiNWFwmrLkmltTlYZ2Xj5yRiTgNGP3KRFlnN+C6uFox5d3f6n/2qz5fmSjoXCY8H2tC71Lax4xlDgo/tzx7HPsVD6Zj8jlnVA1Y6vOw1P/3E11TuRNT+VTFlbnKNSPd4a0weKzq3/D+vn8rRJMepnXOHSzhIxYJk4xOkOMpJJNO8cf/uZV5WfNkg8lE9/YtePxV1K5cjcdfjbeyCntu/hHRntTc3EwikWDBggUAPProo+Tn53PVVVeh1+u58sor8XiUSg5BEFi2bNlsDne/xNNxdgzvmNHOMp5QTIpdJheN7kYuqL5AbWcx67WJ9aFmPDBA57YtDLY2M9DWzFBXJ5KU4dY7/4LRYqW4th6Lw4G3UomgfePfiyZ+aGhovBNkWSYVj2G0WJFlmQe/9WWKa+tZdcl70RuMbH3miSNaAHkzNAHkCMFkMmE2m9WVtOnIsgxpWb1plyVZXUWWp03i1O8nJ8FmHaLVgJyWSA/H0DmMiFYDUiJDOhjddwV6+oqyhJJDn2NCiqZIdIQwljvQ2Y2kxxIkO0MHePyp/5vr89G7TKSGYsR3jWBd4kFnM5DsCRPfO7rvmKWZ3ztOLEXnMJJoGyO6bYics/2IRh3RbUPEd4/MXPmevhKefR55V9QimvRMvD5AbPuwWtIceq6b+N5JEWBy/5kTakQB762K4DT2RDup7jDuDyt+K8P37ibZPq7sKkmMyRHsshm9rGeL3MZrQjPX2U+j8tNrWL16NTXBPIrEfKxnFPHqQ/cTfmwcGWVSF0cxAl3CiYR/uhcHBi703Urm6RH8HzkOf9NxDPxwA4ZhC/ln1wIw8PP1yLH0m76fLAvyyb9GifQbumsXtiYPrvOrICMz/Medb/l+TLa+RGLnA5iqazE2XIN11Qk4VhehL6ok+IvdAGRCyj+aR4CRGccLBhGTPwc5kWHi5T4MRTaMpQ4yEymlDF9AySQVBAT1/8rrjgDSAmUVUk5JpIZiau+/nJHITKSUv5HsvgjKZAQ9IIpT58qOQ5drVvYFRLsBQ4l95mNmvwri1PdithXA4LVhW1EEOuV4U6Ur+7j7jnv695PmfZZ5+ejzpm5ebcsKMVW59nuMes5pE1X7iaXYpv2uc86pRI6np/YXZz4HBIGklGTv3r0IgkDlZbWk0il+9/Mfotfr8VWWs6rMR4XPj7ugAEEUpx5z+jmzeD+xFEEQ1BXIotuX7/f9svul54kOhfBU1JGjP4HhngRP/no7gY4Q4ZeVqidBFMgrtuFtzFN9O3KLbEpLxX4QdAKOk8rU70WzHvvy/953RNCLaiUNKL+TSTFE478jGhon0NbCYDaNJdDeynhgEH/TcVz8uS+j0xsoX7CYvGKlbc/icHLjL/80y6P+79m7dy8DAwOceKLiRfP6668zOjqqCiCXXXYZTueUiFVTUzMr43wzhmJDU9Udwc3sHN5JWlKuGRXOCtaWraXJ00SjpxG/039ECFFHKpKUYaSnm4E2pY1l2fmX4ixw07ZxPf+681eYrDa8ldUsPfdCCiurEbJeXAczSl5DQ+PYJTw8RHR8DG+2Re6eL3wKe24eF3z6CwiCgC3HhSnbfiyIIld97fuzOdxDitYCc4gI/nYbUiy97yR8mhhgqskl98JqgsEgr/z2GdY0rST3rErktET/N15VIu3k/YsHyGBbWUTuBdXIaYneL6zDeaYP59py0iNxBr6z/i3H+Mb9cy+txXacl0RniOAvtrzl8W/cv+D9CzDX5hLdFmTk7t1vefzU/kOM3L0L721LMBTaiKzrZezRtpk7T07ixOxkVlB6vg1eG5HX+gk92YH3U8ehsxkI/bubiZf7Z0yYhTdOZgUB942LEC16Ii/3Ed0cVM35Qs91k2ge3c/kd9okUCeQf3UDAJFX+kgHYoqAAPQ/s4e2jg56ogN0hQeYSMc4x38iVTlljCfCDE4MYRgNUXLBIkS9nhf+79c0nn4OuSdW8tevfI55havJcXmxuXLJLS7BaLXMGDci6OxGLFkRILZjGMGsU1ePY9uHlAqIN5mEi3aDOvlLdIZAipEebCe2czfx3b2k2ttJ9vRAJg2yhGAxY/T7MVX6MVVXYWqoxjK/FsFoRAqnlN5/k04R3+LpmRPmN4gX2g324ae7u5uWlhY1rUWSJMrLy3n/+98PQDAYJC8v74DpQW/G5qcf57k//IpbfnsvpmkRxFJGYqQ/ymD7eNa3I8xIX4TJjxxHvlkROvxKKou7TIugPRLY9NQ/6Ny6mcH2FiLDQ+rPXd4iPP4qvJXVFNfWU9qwYBZH+c5oaWlhy5YtXHzxxQiCwNNPP822bdv4xCc+gSiKhMNhLBbLnE1Ok2SJ1rFWNgc3q6JHd7gbAKNoZH7BfNW7o9HTSK45d5ZHfPQiSxKZTAa9wUCgo41nf/9LAh2tpLMeSgazhQv/5wuUL1hMNDROIjqBy1ukfT5qaGgcNHp372Sou5PFp58NwEPf/grjgUHe9/2fA7D12acwms3Urz5pNod5yNBSYGaB4Xt2KVUY0ybO6mQ0OxE0ljpwrClhx44dPHD/A1y/9jIqTpqHLMmMPdo6c9IuMnMyKYCx3ImlPg9Zkgk/34PJn4PJ50SKp5l4fXDmxH8/QoCh2I6xyIaUzBDfPYKx1IE+z6xWdOx3BVqc+l5fYEFnNyoVI0Mx9PlmRLMeKZ5W0gjeKDy84TmIFj2CXkROS8hpCcGoQ5g0LpTlI2bCHI/H6ejooK2tjfb2doLBIABWi4UckwFTMk460Eeot4tTbriJ+uNP5Fc3XcepH7iZ+tUnseWZJ6hcuuyw3PzIskyqt4/E7l3ZJJbdxHfvIt3Xr+6j93imImfrGzDPa8BQWqq0FmjMeSRJYmBggP7+fpYuXQrAPffcQ3NzM8XFxaq3TFlZGYa38GCJhsbp3rGVisVL1FWBNzLQspe2za9Tvfw0QkEYbB9nsCNEsCtMOqlU5pis+qn4Wb8Tj0+LoJ2rTEZlOwuUtqZXH76f1vWvcNXXlZWgv3//Gwz1dOH1V+H1V+HxV+PxVx6R6RIdHR0899xzXH755dhsNjZs2MCLL77IBz7wAex2O8lkEoPBMGc/g6KpqNrOsimwiS3BLYSTYQDyzHk0uhvV6o55+fMw6rS/uUOBLMuMDfZnW1iU6o5Aeyurr7iOJWefx3hgkMd/+n0KK6vxVtXgrawmr6hE+0zV0NA4qLRueI3d6/7De279NIIg8O8//Yatzz7NR++8D1HU0d+yB4Ci6rpZHunh4YgTQARBOA84r7q6+kPNzc2zPZx3TSgUQq/XY7Xuvz87lUqRyWQOWoqCxqElnU4Ti8VwOBzEYjG++93vIkkSOp2OCp+PgY2vsnDJUk6/6jp++r7LsbpcFJRX4C73U71sJYVVNUhSRk0vOFTIySSJtjbiu3bPEDyksHKDjChi9Psx19crCSxZk1J91nBV48hhfHycPXv20N7eTnt7O/Fs0s7//M//YLPZGB0dxWw2Y7FY3uJMM+nctpkHvvYFLv3C1/AtbFR/Hg0lCXSGCHSGCXaGGOwME8tG0Or0IgVl9hmCR477yIugPRaQZZnxwCCDbS0E2pVWlkB7K7FwiJt+dRc2Vy7b//1PenZu44wbP4ao0x2Wa9fBRpIkRFFkYGCAhx56iHPPPZeysjK6urp48sknufDCC/F4PPttMZ1LBKIB1btjU2ATe0b2kJaVdpaqnCqluiMreJQ7yuf0czlSkWWZUDDAYHsLRrOFisVLSMZj3PG+y0GW0RkMuH1+vJU11K86gdJ5R14llIaGxtwlFgljNFvQ6fU0v/YSz/3xN1z7rR9jcTjZ8swTbHzi71z51e9gsTuIhUPoDcZj1ifoiBNAJjlSK0AymQytra20trbS1tZGMBjkzDPPZNWqVbM9NI13gCzLhEIhcnJyaN3wGg8/8yxCOolrqJeKxUuxNizm1Xt+T23DfM6++eO8eN9dlNTPw9+4lGQ8htH89iad74RMOKxEzk6r6kg2tyCnlJhKwWzGXFc3VdXRUI+pthbxbU6INeYGoVCI9vZ2/H4/TqeTDRs28Oijj+J0OtXkoANFYU+MjRLsaCPQ2U6go43Fp59N2byF+3kUJV1gsL2TdCaX4Z4owc4wg50hIiNKGTcC5HqtitCRFTvyS+zo9NrK5lwl2NXBzuf/pYgeHa0kJiYAEHU68st8ahJL/eqTMB+BkdSSJJFKpTCZTIRCIX7729+ydu1ampqaiEQiPPjgg5x88smUl5fP9lDflIyUoWWsRa3u2BzYTN9EHwBmnZkFBQtUsWOxezE5prmfmnMk89ojD9C9cxuDrc3EwiEA/I1Lufj2rwCwe91/yC0upaCsHJ3+6E0309DQOHykkgn69+6hoKwca46Ltk3reehbX+Gqr32fopo6+vbuYuMTj3Li1e/DWTD3RfzDjZYCMwv87W9/I5PJUF5eTmNj45w0R9M4MHu3bKSrq5vxZJpd27cBAp//4hdZd9+fSI2FcOTkUFBegbeymvkrV7Kwvk6NbVxz5bXqeQ62+CHLMunBQeK7dpHYvVsVPFLd3eo+urw8zA0N2K+/TqnqaGjA6POphmoaRx7JZFIVVNvb2xkaUrwXzj//fJYsWcK8efOoqKggLy/vTT/8JsZG+eWNU+9Pp9tDzfIpYTaVyBDsCqvVHYHOEOOBGNCb3d9CYWUOnrVOPD4H7nIHRrP2MTLXkDIZMukUBpOZkb4envn1T1l95bWU1s8nFBxk05OP4i6voG7VCYrgUVlNfpkP/REYS51MJonH4zidTjKZDN///vdZsmQJp512Gna7Hb/fT06Ocm222+1cd911szzi/TORmmBrcKuazLI1uJVIKgJAgaWAJk8TVzdcTZOnifq8egy6I+93NdeJT0QYbGthoLWZwdZmMukUF332S4BSDRcdG6Vy6XIKK2sorKqhoLxCPfZo7aHX0NA4fCRjUbb962lKGxbgraxmfKCf+//v85z90U8x74S1eP3VnHDV+7DlKv5NxbUNFNc2qMdr4sd/j1YBcogYGBggPz//LXvsNWaXsYF+Btqa6W9vpaOzk5igJ2PPYXh4GACbzYZDL+B2Orng+vcTGR7CluM6LOVkcjpNsqOD+K5dU20su3aTGR1V9zH4yjE3zJvRxqJ3u7WL4BFOMpmku7tbSWbx+YhEInzve9/DYDDg8/nUCg+v14uY7SOXZZmt/3ySHI+XisVL9nteWZbZ/PRjFJSWk1dSQWSUrNihCB6j/ROqSak914TH58Ttc+DNfjXbtOvZXCOTTjPc06WmsAy2tRDs7GDlxVew4qLLiYbGeeS7X+P4y6/Gt7CRTDoFCOjmqJHnWxGJRAiHwxQVKYk/d9xxBx6PhyuuuAKAF154geLiYqqqqmZzmG9Jf6RfTWbZHNjMntE9SLKEgEB1brVqVNrkaaLEXqJd0w8yqUScYGcHxbX1ADz3h1+z8Ym/q9td3iKKa+s56yOfRBAEZEnSPDs0NDQOCpOVGpl0mqd/9RPKFyxm/kmnkkrEueP6y1l95bWsuPAyJClD59bNFNXUHZE+W7ON1gKjccwTC4cYG+ynqLqOjU/8ne6d2znn45/hqZ//kG3btxMvqlDSUQSBqupqCvPzqKyspKKm9rDceErRKPE9e5Sqjl27lQqPvXuRs47xgsGAqbZWaWHJVnWYauvQ2fdvTKlx5NHT00Nrayvt7e10d3eTyWSoq6vjve99LwC9vb14vd43TaD49S03UL5wMWfdfNuMn2cyEqP9EwQ6pqo7hnsjSBnl+m9xGPYRO2w5WiTsXESSMmz/1zMMZuNnh7rayaQVHwijxYKnogqPv4rqZSsP2Np0JDE6OkowGKS2Von5/vOf/8z4+Dgf+chHANi+fTtWq5XKysrZHOabkpbS7Bndo1R3ZP07BqNK/LNFb2FRwSJV7FjoXojT6HyLM2q8XULBAO2bN2SrO/Yy1NOFLEnc+Is/Ys/Lp+X1Vxnq6qCwqgZvVQ0W+77tgxoaGhpvl3QqRSw8jiNPSW7861duJ6+0nNM+cDMAd/+/T1Kz/HiWX3ApoJjPT1aUa7w7NAFE45ghnUox0tvNUFcHwa4OQoFBzv3E53juD79m67//ycfv/Av/uv9eXtzVzOVXXIHbbmVoaJjekVGqq6spKSk55BGH6aGhfao6kh0dTC69izk5isgxWdVR34Cp0o+gVRMdNciyTCAQYGhoiPnz5wPw29/+lp6eHgoLC9WklvLyckwmRYh4+lc/AUHgjA/fesDzRkPjmG0OxoMxJXo2a1Ia7I6QSSmJLEaLHo/PgcentLF4KpzYc03aCvMcQ8pkELNtay/c8wdEvZ7Vl1+DLMv84sPXIGXSagrL5NfcwqIjfpV6aGiI1tZWli9fjiAIPPHEE2zYsIHbb78dnU5Hd7bdr6ysbJZHemDCyTBbg1tV746tQ1uJpWMAeK1e1buj0dNIXW4devHIrMaZi8iSxEh/r5LI0trM4jPeQ35JGTtfeI4nfvp9zDY73qoaCqtqKayqwbew8Zg1CNTQ0Dj4DPd0Ex4OqpW493zx0+j1Bi7/0jcBeOHeP+IscLP49PfM5jCPCTQPEI2jDlmWiYwOY8/Np2fXdrY9+xRn3vxxXn/0Qdb95S5lJ4sNc0k5f7nvPjoGRqg+8wJkZE665ArSzz5Lbm4uBYWFFJT5qD8UY5Qkkp2dM6o64rt3kQkOqfsYSkowNdTjPOcczPOyKSxFhz4OV+PwMz4+PsPHY2JiAp1OR21tLXImzYkrllPy3vdis+2/qsfi2HdVWJZlQkPxGYksga4wqXgGAL1RxF3uYMGJJarokeO2IIja+2sukYxFCXS0qS0sg+2tSJkM7//RrwCYGBtDZ1A+rgVB4Prv/hRrjuuouE4MDw+zefNmVq9ejdlspr29nSeeeIK6ujpcLhcrVqzguOOOU1u95prwIcsyvZHeqXSW4CZaRluQkREFkbrcOi6svlCNpC2yF832kI8aZFlGyqTR6Q2MDvTxzK/uYLC9hWRMEZsMJjNlCxaRX1JG5ZJlfODHvyHHW3hU/N1oaGjMDTq3baZ3906Ov+wqAF596C9079zGjb/4IwDLzr9E/fwCOOG918/KODVmolWAaMx5UvE4Qz2dDHV1EuxqZ9Ul76Xl9Vd4+pc/4YN3/Ja+5j28cM8fuOCzX6a9o4O9e/YwFAoTysa9OhwOKisrWbBgwSEzo5XicRLNLcR37ZwSPPbsQY5GlR30ekxVVdn2FaWqw1xfhy5HK3M7WolEIrS3t1NTU4PZbOaFF17g2WefVY0ZrWSIdrQy3t3O6EA/dlcuN/7yT29+ztHEDM+OQGeIxITS/iDqBQpK7HgqnGp1R26RDVETO+YcgY42urZtZrC9lcH2Vkb7e9UKMJsrF29lNR5/FcdfetURX9HxRsbGxli3bh3Lli3D4/HQ1tbGXXfdxQ033EB5eTmxWIx0Or3fBKO5QEpKsXt49wz/jmAsCIDNYGNRwSK1wmORexE2g9ameLCIjo8x0NrMQOve7Ndmms46l1WXvJdYJMzfvv6/FFbVqP/ySsuOuMhmDQ2NuYcsSSAICIJAy/pX2Pj4I1zy//4PnV7Pyw/cy4bHHuamX92F3mhkpK8XQRRwebXFzNlGqwDROCKQJSlb2THCjn//k/knncpIbzd/+9aX1cmBwWRm3pq1lDYs4OQbbsRgtlB//Ils6e7nF7+/EwCTyYTf72dNNg40Pz//oF6E0qOjM706du8i0dYOGWXVXbTZMDXU47r4YlXwMFZXIxqNB20MGnOPZDJJe3s77e3ttLW1EQgEALjyyiupr69n8eLF1NXV4c6a1L78wL30drTg9lXSsGYt7orKGRFmsUhyhmdHoDNEdDwJgCAK5BXbqGx0q2KHFj8795j8ffbs3sGmJ//BWTd/HIPJzO6Xnmf9Iw/gyHfj8VfRsOYkvH5F9LDn5s32sA8qsViMxx57jIULF1JXV4cgCGzZsgW/34/H48Hn83H77bdjzF4fLXMsmns8Mc6W4Ba1wmP70HbimTgAxbZilhUuo8nTRJOniWpXNTptwn1QSEQnGGhtRpZlKhY1IWUy/OajHyCdTIAgKFUdTcsorFQWNSx2B9d884ezPGoNDY0jHVmWGRvsx56bh8FkpmX9Kzzxs+9z3XfuIMdTiCxJZDIZYuEQ9tw8jjv/YlZefIW6WJFXXDLLz0Djv0ETQDRmhUR0gmBXB0OdHZQtWISUTnPflz7De279H5wFbl564B7cPj+FVTUcf+lVFJT7yC/14fIWIup0vPDCC6zf2UzTGecgCAI+n4/i4mIqKyspKipCdxAiX2VZJtXbS3zntKqO3btJ9/er++i9XiVy9rTTMNcrYoehtPSoW7XV2Jd0Ok1PTw9ms5nCwkLGxsa499570el05DvsmIcHuPxjn8KXNWd0Op04nVNtLCsvuZJVlyoGp4lYmmBniE1PdymCR0eY8IgyyUKAXK+Vsvo8xaS0wkl+qR2DUZtozSUmxkaVJJa2VgbblTaWs2/5BGXzFxEPhxlsayY8PExecQlL33MBx5170VFldDYp9kiSxL333ktFRQWrV6/GZDIxMDCA3+8HICcnh8997nNqSbBOpzso1+uDgSzLdIW7VKPSzYHNtI63AqATdNTn1XNp7aWKf4e7Ea/NO8sjPrrY8Z9n6dy6iYHWZqUqCiisrqViUROiTscZN96KI68AT2XVQY+Y19DQODZJxmN0bN6At7KGHI+X7h3buP//Ps8lt3+Fisal5BaVMO/EUwBlcapmxfHUrDhePd5g1Azjj0S0FhiNQ046maR1w6vklZRhcTi594ufJhQMqNtPef9NzDvhFF68708sWHs6bl8F6WQSg8nM8PAwbW1tqm/Chz70IQoKCti7dy8dHR2cfPLJ6srhu0FOJkm0tmZFjl0kdu4ivmcPUraNBlHEWOlXRQ5zQwOm+nr0eUfXaq3GgZFlmf7+fpr37Gb3zp0ER8dIp9M0NjZy4YUXIssyHR0dlJaWMtzZzu6Xnmf5BZdizXHNOE8qkWGoO6xWdQQ6w4wNRtXtzgLzzESWcgdGi6ZVzyWS8Rhd27cy2NZCIBs/GxkdUbfnFpXg8Vdx3DkXUlhdO6Oy52ghlUqpMe/33XcfRqORiy++GID777+fsrIyVq5cOZtDfEuSmSQ7h3dOCR7BzYzEld+jw+BgsWex0s7ibmRBwQKsBussj/jIZzK2ebKNJTIyzMWf+zIAj3zvawy07MWbNSjVElk0NDQONql4nFcfvp+y+QvxLWwkPDzEr295H2vfdyNLzj6PZCzK7pdeoLLpOOx5+bM9XI13gZYCo3FYiIbGGerqwGx3kFdSxn3/+z/MO2Eti047m59cfynLL7iM4y+/iqd+/iPySstxl1dQUF6BI79AnRyEw2G1haCtrY1QKAQoq4ZVVVWsXr2a/Px3d0HKhMPZ1pWpqo5ESwukUgAIFgvm2lpM8xpUwcNUU4M4x0qzNQ4tsiwzPDzM2NgY1dXVAPz4xz9mdHQUMR6jbt48Fi9fQUVFBeYDpAhkUhLDfRECHVNtLCN9E5MdXdhcppmJLD4nZruW9jPXSKdSvPK3eymubaByyTJG+3v5/W03IggieSWlM9JY3BWVmKxH10RZlmXC4bBawfTQQw8xODjITTfdBMB//vMfDAYDxx9//JudZtYZjY+qRqWbA5vZMbSDpKS0lZU5ymjyNLHYrYgeVa4qREGr5Hs3TCay5BYVI4o6XnvkAV6+/x7SKeU1n0xkufAz/4veYCCVTGirqRoaGgeFdCqF3mBAlmX+/v2vU1I3j+POuxhJyvDzD17FsvMuYcVFlyupfO2t5Jf50B8jaYtSLE0mkkSKpZGiaaRYGkEAa6MHgPFnOkl2h9E5jeRdWjvLo33naB4gGgedYFcHyDJun5+Hv/s1Blr3MpFdAV102lmc/qGPkltUgsWZg95o5Prv/pQcbxGiqOPsj35qn/ONjIxw3333qb4JFotFjQKtrKwkNzf3ba+gyrJMemBgqqojGz2b6ulR99Hl5ystLGtWZ6s6GjD6yhHmSEm2xuEhGYsS7Oygs3k3bS2t4MpncGSUcDiM1Wrl05/+NKIocskll2Azm5kYGsRbUTUjPlHKSIz0R2cksgz1RpDSitphthnwVDjwL3arYofNpd3szxVkSWJssF8xJm1TqjrySso49f03odPr2f7cMwiijsoly3B5i7jyq9/F4/MflRGa6XSawcFBSkqUXuann36aDRs28NnPfhadTkd1dTVer1etbDnppJNmecT7Issy7aH2Ge0sHaEOAPSinnl587iy/krVsLTAUjC7Az4KiIVDdO/YqhqUDra1kIxFuf57P6OgzEdBuY/FZ5ytVni80SRQEz80NDTeCdHQOLHQOPml5QDc+8X/wZ6Xz3mf+ByCIMxoSxdFHTf/+m50+qlkNW9l9ayM+90gZ6QZAoYUT2OpU6rSo1uDJNrGs9tTSDHFLN/70SYARu7fS3zn8Izz6VwmVQDJjCeQoil0zqPXu1CrANE4ILIsMzE6QiI6QX5pOc/98TcYLRZWX34Nv7/tRgrKfJz/qc/z+B3fQ9TpKCivwF3ux13hf8vedkmSuOuuuygtLeXUU08lnU5z3333UVFRQWVlJYWFhTNio95yrOk0yfZ2JWpWFTx2kxkbU/cx+nwzqzrq6zF4PO/05dE4CojFYuzdvYtnvvUlBGTinjJS+V6MBj3VNbVUVlbi9/vJy8ubcaMuSzJjgaha1RHsDBPsDpNOSgAYzTrc06o6PD4HjnzzUdcGcSQz0tfDQGszgaxfR6C9jWRMaUXS6fUUlFdQtXSF6tMiZTKIR6kwmkgk6OrqwufzYTQaeeWVV3jyySf5xCc+QU5ODt3d3QQCARYvXoxePzfXTRKZBNuHtrM5oCSzbA5uZiwxBkCOKYdGdyONHiWKdn7+fMz6o0+4OpxEQ+NKG0tLM9XLVuKpqKR1w2s8/J2vIur0qodXYVUNVcet2G+Mt4aGhsY7YaBlLyP9vcw7YS0AD3z9i0RD41z37Z8AsPGJv2Oy2ph/0qmzOcz/CjktZUWMFPp8C4JeJNkT3kfAkKJp8q+bh2jUMf5EO+H/9OxzrpKvr0HQCYw+0kJsSxDRakC06BGtekS7kbzLlGqOePMoUiSFYNVntyv76WxHVwWMVgGi8ZakEnEmRkdxFRbx+qMP0rZxPcHuTuLhECX187jyK98hMTGBLCsTvDNu+hi2rLfBe2799AHPK8sywWBQbWmRJIlrrrkGURTJz89Xow71ej3XXHPNfzVWaWKC+J69M6o6Env3IiezCRlGI6baWhynn4apvh5zwzxMtbXo7Foc4bGGLMvsfvHfWF25+BY2kkql6OzsVNus+rOGtsdfdAXVtXUYXHnoLVa8Xq8qwMmyTHg4Ps2zQxE8knEl9UdvEHGXO5i3plgVO1weK4IWPzun6NiykUBHG8svuBSAp391B727d6A3GHFX+Gk4YW22laWKgrJydPqZNwJHk/gRj8fZu3cv5eXluFwuurq6uPvuu7nuuuuorKykrq4Op9OptnaVlZVRVlY2y6OeyVBsiC0BJZ1lU3ATO4d3kpaUVa4KZwUnl52s+ndU5FRo7SzvgslKn+j4GM/+7hcMtDVP+XgJAvbcPDwVlZQ2LODqr/+AAp//mCkl19DQOPS0b95Ay2svc/qHPwrAjuefZefz/6Jh9UkIosjKi69g+oL+krPPP+xjlFMSiCDoRDKhBMmu8FSFRlbEcKwtQ59rJro5wPgTHUixFHJ24Qyg8NPHoS+wkGgbZ/zxdhBBtBgUAcOiVx7DqMNU5UIw6tSfTwoYWZ9Wci+oJveCA1e1mGtyD/XLMefRBJBjDFmWiY6PYXPlsmvdfwh2tHHi1Tfw+B3fZ7ini/f/6FeMDQ6QTiapWb4Kd3mFWhp21i23qecprZ9/wMcIhUKq4NHW1kYkEgEgLy+P6upq9Wbq3HPPfcvxpoPBfao6kp2daiyuLicH07wGcq++Wq3qMFVWIszRVUqNw4skSfzrofvxlpbjW9hIT08Pf/7znxFFkdLSUk4++WT8fj8lJSXqyvbEeILObcMzTErjEcUfRtQJFJTaqV1eqCay5BZaEXXa5GoukE6lGO7uzFZ0tBDoaOOyL34dg8lM57bNbP/3PznuvIsQRR0nX/sB9EYjeSVlR5W4sT+SySSbN2+mqKiIsrIyYrEYDz74IOeccw7Lli2jvLyc6667jtLSUgByc3PJzZ07N0iSLNE21qZ6d2wKbKI73A2AQTSwoGAB1867Vq3yyDNr5tTvlFQyQbCjTW1jGWhtpmrpck665v0YrTaC3Z0UVdfRdOa5eKtq8PqrMFoUzxuT1Uph9ZHbL66hoTF7pOJxdEYDoqijZf0rvHDvH7nqa9/DZLUx2t9L+5YNxCcimG12Vlx0Bcdffo3a2lLasOCgjkVOZUgFY1MVGNk2E0tDHgavjWRPmLHH2pFjU9vklETBBxZgrskl0Rlm5O5dUyfUCYhWPbZlhZBrRuc0Yqp2TVVnWLMiRtYDzraiCNvyQgSTbr+Vw+baXMy1c+cz+khEa4E5iknF4xjMZjq3bqb5tXUEOzsY6u5AFHXc8rt7ef7uO2nf9DrXf+9n9OzcRjw6Qc2yVe/48bZs2cILL7zA0NAQAFarVfXw8Pv9b3pDLWcyJDu7SOzeNU3w2E0mey4AQ2mpKnKYG+ZhbqhHX1iotRUcw/z7T78lnUxy2gdvARSBb3BwUK3w6OzsJJlMcvzxx3PGGWeQTqdpb29XS/3jkZRa1RHoDBPoCDExnq0kEiCv2DZlUFrhJL/Yjs6giR1zgVQywVBnhyp2DLa1MtTdiZRRqgCMFitefxVnfeSTOAvcpOJx9EbjMRFRLcsyL7zwAnl5eSxYsIBMJsM3v/lNVq1axamnnqr+nXg8nrfVani4iKVjbB/arlR3BDaxJbiFcFJJ5Moz581oZ5mXPw+j7ujtUz6UTCayxCMRyhcsAuBXN19PZETpDbfl5lFYVUPtitXZGEgNDQ2Nd08mnSLQ3oarqBiL3UHbpvU8/O3/4+pv/ABvZTXdO7ex4bGHOeWGG3EWeJAl6W19dsuyjJzMZKsvlPYSKZrG4LFiKLSRiSSVCoxp7SVSLEXOGRXYlhWS7I0QuGPTPufNvawW21Ivyb4IY4+2TlVnWPWIFgPWRQXo8y1I0RTpsYT6c8EoanOVWUBLgTnKkaQMgiAS6GijZf0rrLr0Sjb842FevO9P3PqH+9n4xN957ZH7cZf7FZ8OXwULTj4dQXx3f5C9vb088cQTXHTRReTn57Nt2za2bNmiih4HurmW4nESe/fOqOqI792LHM1Gger1mKqrMTdMeXWY6+vRObUe4mOJTDpNZGSYHI/3gPv858+/JxKNsujsCygrK0OSJL7zne8Qj8fJy8tTxTe/349eMBLsCjPYGSLQESbYFSI0FFfP5fJaZ3h2FJQ7MBiP7sqAI4no+Bi7X3qBqqXLyfF42f7vf/LUL34EgNnuwFtZjcdfhddfhddfTY7He0yIHZM8//zzyLKsGpL+/Oc/p6ysjPPOOw+ASCSCzWabkzdhgWhANSrdHNjM7pHdpGVFyKrMqVSNSps8TZQ7yufkczhSaNu0no4tGxlobSbY3kY6lSS3qIT3/+hXAOz4z7MYrVYKq2pw5GnGsBoaGu+eZCzKrhf/Q3FdA+7yCgbbW/nz5z7OOR//DPXHn0h4eIitzz7FgpNPm3HPJ0syciKjChWCUYfBY0WWZMLPde9boTE/H8eJpUjxNH1ffnmfcThOLSfndB+ZSJLAHZuntZAoFRiWxW7MVS6keJpEyxhCtr1ElxU5BIN2T3gkoQkgRxnjgQFa1r9KsKudoa4Ohru7+OBPf0fbpvU88+uf8oEf/4aJsVG6d2yl6axz0RkMiDr9O75plCSJQCCgtrQsXryYhQsXMjw8zEMPPcRZZ52llk6/kfToqOrTEd+1i/juXSTb2kFSet5Eux1zfT2mhgZV8DBWVSEatRW9Y5H2Ta+z99V1BDraGO7uxGi1cfOv/zzjvRuJRGhvb1erPMbGxigoKOCjH1V6Q9va2nA6XKRCuhmeHaODUche7hz55hlih9vnxGTR2qbmAonoBIGONjWJpeq4ldStWsNIXw93fuImzv7op5h3wloiI8P0t+zB66/GUeA+5ibFL774Iv39/Vx22WUA/O1vfwPgkksuAZQkl7loWJqRMrSMtSiCR1ARPHojvQCYdCYWFCygydOkRtLmmN7cUFtjXxTfoiEGW5sZaN3LcG83F3z6CwiCwJO/+BF7Xn4Br7+KwqoaNZElt7B4toetoaFxlJBJp3juD7+mbP4i6ladQHxigl9/8DpWXfhell1xKZl0mo5HXyXXWYhe1qsCht5jxblW8Zsa+O560iNx9b4NwNrkIe+KOgB6v7gOBGFGC4llQQH2lUXIskzkhd4pccNiQLTp0TmMiFbNn+hYQRNAjlCioXE6t2zEt6iJ4Z4uHr/je1x8+1cIDQV5+DtfxeLMwe3z4y6v4LhzL8JksyEIIvqDIB6MjY3N8PGIZqszCgoKWLNmDY2NjTP2l2WZVE8P8Z27pqo6du0iPTio7qMvLJxZ1dHQgKG09JibuBzLTPq/HIhXHvwLG5/4O56KSjwVlbgrKqlYsoyenl6qq6sRBIG//e1vbNu2DZPJhN/vp8JXgcvqJT1uVASPjjAj/RPIknJts+YYZ7SxeModWByawDYXiEXCBNpaGVSTWFoYG+hXt9vz8ll+waU0nXUesiQxMTaKPS9/Fkd8eMlkMuiy/iSvvfYar776Kh/5yEcQRZEXX3yR3t5eLr/8cgRBeMu/rdliIjXB1uBWVezYGtxKJKX4QhVYClSj0kZPIw15DRh02s3p2yUaGsdktaLTG9jxn2d5/u47iY6PAagJbZf+v//D4nASn4hgNFuOet8bDQ2Ng48syarBe6I/TKx/DANGpGiaHU8/gyU3h8WfuAiA1/7nj3is5Rh1ZiWGVQajz4nn5sUADPxgA+mAMrcQzDpEqwFzjYvci2oAGH+6A5hpAqrPN2PwKoEGckZC0PzXNN4ETQCZ46QScXp27SDYqVR0BLs6WHv9hzGYTNzzhU9x/qf/HwVlPl75230sv+AynG43yVgMm+vgGuDIsswTTzxBS0sLIyMjANjt9hk+Hjk5OUjJJMmWlhlVHYnde5CyZqfodJgq/ZjqGzDX12Oe14Cpvh79HDLV0zj87H7peZ797c+54Ue/OmBMspTJkJEkenp6aGtro729nd7eXmRZ5tZbbyU3N4/m7R0Ee8dJj5oIdkYY6o0gpZXrmMmmx+tz4s5Wd3grnNhcpsP5NDXehK7tW5AyGSoWL0HKZPjJ9ZeSSSkGs063V01h8VZW46moPOjXuLlOLBbDaDSi0+nYtm0bjzzyCLfddht2u53du3eze/duzjrrLDWdZS4yMDGgendsDmxmz+geJFlCQKA6t5omt9LO0uhppNSuCeBvl1QiTn/zXgZa9yoVHtlEliu/8h1K6ufRuW0zO5//VzaCtha3z39QFkU0NDSOLqRYmkw4OaOFRE5msK9SqsHCL/YS3zOibstMJEEnU/q/awDYcvv95MuF6vlkZNI2Cf8XTwZg7Il2MqoPhlKhoc8zY5mnLGKkxxIIBhHRrEfQaZ8DGgcfLQZ3jiBlMgQ62rDm5KDTG3jsJ9+l6ezz8Pj8PPjNLwHgyHfj9lUg6nW4Kyq5/ns/I7eoBJ1ez9kf+aR6LoPp4NwAr1+/noGBAc477zwEQWB0dJSCggKWL19OZWUleSYTid17SGzZwsR9f2F41y4Sra2QVvqzBYsFc10dOeefp1Z1mGpqEOfwDbrGwScVjzPQ1ozb58dss+93H5enkNqVa8ikUzN+LkkS/f39OJ1OHA4HO3ft4oEHHkAQBLzuQuZVNmJK5/Hc71sZ7t5GOhsZZjDr8JQ7WLy2TE1kceSbtQnVLCPLMhOjI0pVR1sryViUk6/7IADr/no3ABWLlyDqdJz2wY/gyCvA46/E4jj2PH7GxsYwmUxYLBba2tr405/+xA033IDP58PtdnPcccchZdsF6+vrqa+vn+URzyQtpdk7ulcVOzYFNjEYVar+LHoLCwsW8sGFH6TJ08Qi9yKcxmPvd/xuSCeTBLKJLMW19RRW1RBob+P+//s8ADkeL4XVdTSeeS6OAjcAvoWN+BY2zuKoNTQ0DhdyWpph8ilF05hrcxEMIvG9o8R2DKkCxqTQUfip4xAMIqFnOom81DfzhIKSQCKIAuPdfSQHwjiLPRg8Vjr2bGZ0tJ9SFAHEfKKHuAy+5cehs+oRzHq1OgTAdbb/Tceu1xanNGYRTQA5BMiyTCgYINjVwVBnO8GuDqqPW0HVcSu4+/OfYPUV17Ls/ItJp5LIkoSzwMPlX/om7nI/ZvvMyWNBme+gjEmSJAYGBmhra6Ojo4MrrrgCg8FAOBxmZGQESZLIDAxwflGR0sby0p8J7drNcG+veg6duwBzfQP2E09UqzqM5eUIWintMU+go42/fuV2LvzM/1K1dPl+9ymsrqWwuhZZlgkGg6qHR0dHB/F4nBNXr8WX38BIq0ClbTmxPjPpfggAOkMGd5nIvNXFaiuLy2Od8WGrcfiRpAyhQIBgVzuB9lYG25RWlsnyewQBt8+vtmecfcsnsEwzM15w8mmzM/BZQJIkBgcHMZlM5OXlMTw8zB133MF5553H0qVLKSws5OSTT8aZfX0KCws566yzZnnUMwknw2wNblX9O7YGtxJLxwDwWD2qd0ejp5G63Dr0onaL8XZJxeP8+0+/ZaC1maHuDqRMBoDjL7uawqoaPJVVXHz7V/BWVh+wkk5DQ+PIQk4piSWZaBp9ngnRpCcViBLfNbyPgJF7SQ36fAuRl/oY+3vrPucq/Mwy9HlmUgMTxLYPq/4YOqcJQ6FNSVRBxNrkwVDuQLTo0dkMdLfuZMdL/6RIXoUOPZ3ibl7f8zAf+cx96A0GMl0myqZ1DdSdfdLhfIk0NA4qWgvMIUCWJH7yvstIJxIAuLxFLDnnAprOPJe2Tetx+/yH3F1dlmVGRkZUD4/29nbicSXxwuPxcNHyFVh7e9S42cSuXWTGx5WDBQGjz5cVORTPDnN9PXq3+5COWWNukUmnGO7pJtDRRrCjjerlqyibt3C/+062cRXV1O23AmR8fJxYLEZhYSGJRIJvf/vbSJKExWjDJhQgj9sh5ECUjIg6gfwS+5Rnh89BXpENUev1nDUmBYyB1maaX3uJ1Zdfg6jT8c/f/YItTz8GgCCK5JeW4/VPpbG4K/wYzZZZHv3s0d7ejk6no7y8nFQqxbe+9S1WrFjBGWecgSzLvP7661RVVZGXlzfbQ90HWZbpjfROpbMEN9M82oyMjCiI1ObW0uhuVEWPQpsWSf7fIksSowP9DLbuZaC1mYHWZjz+Kk59/03IsszvPvZBcrxFFFZWU1hVi7eqBkd+gfb6amjMYWRZRk5JCAIIBh2ZiRSJtrFpAoYiYthXFmEsdRBvHWPkL3uQomlIS+p5Cj64AHN1LtGtQUbu2Q06YcrI06on9+IaDB4ryZ4w8ebRGR4ZotWAwWtF0O//fikyMozZ7kBvNNLy+qs88+s7uOabP8KRX8Cudf/h9b8/yMW3fxmbK5dENIreaECn13yZNI5MNA+QWaD51Zew5eZRUO47rBOA4eFh1q1bR2trK+NZQcNhsVBmMFA4OkrB3mbEXbuQk0kABJMJU21tNolFaWEx19Yi2myHbcwac49kLMrPPnAVUkZpddKbTJx0zQdoPOM9/9Xx0WiUjo4ORYBrbWNkdIQ8h5dq62qCXWGGo73o0zZ0kpm8Ivu0RBYn+aU29FrU2GEnk04xNjDASH8Po329jPb3MtLXy2hfD5d8/qt4K6vZ9tzT/PM3P+MDP/4NTreHnt07GO3vpaDUR4GvAoPx2C5pbW5uJpFIsGDBAgDuuOMO8vPzueqqq9TtHo+HnJy5t3KfklLsHt7N5uBmVfQIxoIA2Aw2FhUsUqs7FrkXYTNonxH/DZOJLOHhIUrqGgD48+2fYLCtGQC90YTHX0XNspUcd97F6jGa2KGhMbvIGYnUQFSNYJ2swDBV5mCqyCE9GlcFjMkWFDIyuRfXYFteSLI7TOBnm6dOqBcQrQZyL6zGMi+f1OAE4Rd6Ea2GGXGsJn8OOrsROS0ppqMG8R1dD1LxON27tuEu9+PIL6Bz22Ye+NoXuOyL36B8wSICHW1sfOLvrLrkSnI8hW99Qg2NIwxNADmKSSaTPPfcc1RUVFDpyqV/4wb+/NprFCWSeHq6ce/ahT0cQQB0LldW5JinVnUY/X6EORiVqHFoaVn/CiarlbL5iw64z6sP/RVXYRFuXyWuwkJE8cCiRDKZZGBggEJPMcGuMA8//gDBsV4EWYchkYMh6cKYdJGf556RyFJQasdo1t5/hwtZlomOj2EwmTBarAy2tfDS/Xcz0tfDeGAQWZpahbLmuMgrLiW3uISl51xIfkkZ6VQKURS1BIkse/fuZWBggBNPPBGAe+65h7GxMW655RYABgcHcTqdWCxzrwpmPDHOluAW1btj+9B24hmlSrDYVqwalTZ5mqhx1aB7k79/jZn0N++hY8tGBrIVHtHxMaw5Lm761V0IgsD2555BlmUKq2rILy3X/p40NA4RqnAxWYERS6HLMWGqyEHOSIz+rVmtzJjcx7ayiJzTfWQmUvT/3yv7nNN5pg/n2nIy4SQj9+5WW0xUAaMmF2OxHSmZITMSV38uHOKFnVQ8zsYn/k5J/TxKGxYwHhjgt7d+kNM++BEWn3428UiEnc8/S/Xy43EWaBXdGkc/mgnqUUImk6G/v5/WlhbESIRFgkB85062jo8T/dNdSBs2IAMXCAKm0lKlquOGG7LRsw3ovV5tVUkDgOfvvpP80vI3FUBWXHT5AbdlMhm6OrrZsXUPHR3tDI8HkJHID6xClAykDAUUOYspKyvFW5GDp8KJu8yB2aaVUh4OUskEY/19agVHUU09vkWNjPT18IdP3szZH/0U805YC0BoKIjHV0ndqhPJKy4ht7iEvOJSTNZ9V/j1hmP799fc3My2bdu46KKLEASBjo4Otm3bxpo1axBFkfPOO2+G2OH1emdxtFPIskx3uHtGOkvruNI7rhN01OXVcUntJYrg4W7Ca5sb457rJKJRAu0tDLQ2M9jWwlkf+SR6g4E9Lz/Phsf/Tl5xKRWLl6iJLJMsWHv6LI5aQ+PIQpZk5LjijyFFUwg6EWOJ0mobfqGHzGhihtBhLHfiOrcSgP5vvYacyMw4n3WpF1NFDogCya4wgkmHaNFjcJkQLXqMxcq5RYue/GvnZQWOqRaUyfYSncOI+8MHvocSjTrEwoNfKSdLEoIoIksSj93xPUrr59N45jmIej2vPPgXVlx4GaUNC3C6vVzxpW/hqawCwGy3s+Q9Fxz08WhoHIloFSBzGFmWCfb20rx+PW2trXRHIiSz20p6eljz4jowGDBUV2NtyEbONtRjqq9H53DM6tg1Zo91f72beCTMqe+/6YD7jA30Y8vN/a/ThNLpDM3bOoiPCoz1Jtjdvp1BaQfIoE/bsZBPUUEJldWVFFa48PicWJ1a9OKhRspk6N6xTW1bGenrYbS/l9BQEKZd21dcdAVrrryWTDrFlmeexN+4hNyiklkc+ZFBR0cHzz33HFdccQVWq5UNGzawbt063v/+92O320kmkxgMhjknLCczSXYO71SrOzYHNzMSV6LNHQYHizyLaHIr3h0LChZgNVhnecRzn3QyiSAK6PQG2jau5z9//j0jfT3q35nT7eWyL34dl7eQaGgcnd6Ayaq9rhoak8gZGSmuRK3qc5V7j9ieEdLB2IwWE53NgOt8ZdIe+NUWkh0hmDZVMfqdeG5cDMDAD14nE0rOrMCozMG5thyAidcGFA+N7DbRakBnNyBajwwxPxmPER0fx+VVWlT++pXbsecX8J6PfgqAv33jfymbv4jlF1wKKFUgBi2FUUMD0CpAjhjSIyPEd+1i76ZN7O7vp0eWiRqVSaQtEqFsZIQyowlfWSm555yL+dOfxlRZiWDUJprHCrIkMTE+hj33wKaJqXiMZCz6pudxFRYdcJskyYwOTNC+q5fmvS30D/UQSQ0hiSkcY3XkiCW4y0ooys2ndl4N5TVubC7TnJsEHi0kY1Fi4TA5HmVV/ulf34HLW8TyCy5FlmUe/NaXkDIZDGYLecUlFNc2sODk08ktLiG3qIS8ohL1hkinN7Dk7PNm8+nMOWRZRpZlRFGkv7+fhx56iPPPP5/S0lJEUSSVShGJRLBarSxZsoSlS5eqxxrnyLV3ND6qGpVuDmxm+9B2kpIil5faS1ldvFptZ6lyVSEKmqHwmyFlMgz3dGUNSpU2lqGuTi749P+jcskyTDY7Lm8h9cefSGFVDd6qmhmJLFo6i8bRjJyRELKm5KlgdB8BQ85IuN6jVGCMPd5GbPswUjSFHFcqMXQ5RopuXwHAxEt9xPeMgqBUXIgWPRRNVU1YFhRgqnTNFDCmLa54b1v6pmlwtuVHlrdFsLOdscF+apYfD8DD3/k/UvEYV3/jhwD4Fi/BYp9a4Lzk81+dcbwmfmho/HccNgFEEAQb8HMgCfxbluW7D9djzzVkSSLV3Z1NYNlFf3MLu2IxFrzyCjpJYu/iRXRUV1MiSfisNiob6ilsasJQUqJNMo9Bundspfm1l5U0ls52RFHklt/de8D3wsnXffC/Prcsy4wHYwQ7w3S1DhLoGiPUK5NIRRnxvAqAXjDhzS3BV+Fn0ZJ5FJVraQQHm8k42RmVHH29jPT3MjE6QmFVjXoDFI+ESWYnWDq9niu+/G2cBW5suXna7+W/QJIkUqkUJpOJUCjEb3/7W0455RQaGxux2+04HA4mKyPLy8v58Ic/rB47F15fWZZpD7WzJbBFbWnpCHUAoBf1zMubx5X1V6qGpQWWQ5s4dqQjyzJjA30MtDbj8hZRVFPHSG83f/rMrQCYrDa8ldUcd+6FqghZUtfARZ/90mwOW0PjoCDF02TGE1M+GNnEEvuqYgSDyMSGQaIbB2ckmcjJDCVfX42gE4ms62Pilf6pEwog2g3knO1HEAR0ThMmn3NKwLDoER1TAkbupbUIOgHBrN+vkOFY/eaVim8mfhwJdG7dTPvm19X7ts1PPcaeV16getkqBEFg+YWXwTRvrhUXXjZbQ9XQOKp4Vy0wgiD8HjgXCMiyvGDaz88CfgzogN/KsvwtQRCuBcZkWX5UEIS/yLJ8xVud/2hogZGSSRLNzSR27ya+cxfR3bvpCwzSn5NDWVc3ORMTDDY18UJVJZcVFVPWuBjB78fsdiOK2iqdBrz2yAO88rf7cPv8uCsq8VT4WXDy6W/bOE+WZSKjCQKdIQKdYfrbh+nt7yEqD5M0jpIxRHGKhRxXewqeCgdD8S5qGvx4PO45MfE7Whju6WK0v4/qZSsBePyO77H3lRfJpNPqPmabXfXiyC0qwe3zU7lk2WwN+YgmmUwSj8dxOp1kMhm+973vsXTpUk477TQkSeKRRx5h8eLFVFZWzvZQ90sik2DH0I4ZcbRjiTEAckw5NLoVs9JGdyMLChZg1msrgG+FJGVY95c/Z707mklMTACw+IxzOO0DNyNJGfasex5vVS25hUUI2mexxhxlMnp1esyqHEtj9OegsxlIdIaIbhhEmphpBOr+0CL0BRbCz/cw/nj7Puct/Nxy9C4TkVf7iW4MzIhZFS16HCeWIhhE0kMxpHha2WYzIBh1R7wocbDJpNOIooggirS8/iqv/O0+rvjSNzGYzbz+6IO89sgDfOAnv8VktRIKBhBEEXtevnbfpaHxLjmULTB/AH4K/Gnag+mAnwGnAz3AekEQ/g6UAtuyu810JDrKGH/0USZeXEd81y7ibW2M22wMer0EiosJVFWSrqkGoOy666k78wxqdDpWyzKGY9xg8FikZf0rPHvnL7n66z84YFvLkrPPZ9l5F7/tm/BoKKmKHYHOEIOdY0Si4+jTdkRRYNy7ibg1hCjqKCkspaa+mpqaaoqKJttjDtwmo3FgMukUY4MDMzw5Rvv7uOyLX0OnN7Dln0+w/V/PcOsf70cQBAqr67Dl5qmJK3nFpVgcTu3m5x0SiUQIh8Pq+/iXv/wlXq+XK664Ap1Ox/HHH09xcTEAoihy0UUXzeZw92EoNjRV3RHcxM7hnaQlRRzzOX2cVHoSTR7Fv6Mip0JrZ3kTYuHQjDYWuyuP0z/8UURRx95XXsRotlK38gS8VTUUVtVQUOYDQBR1NGRNgjU0DgeyLCMnJSVOdSKNLseIzm4kPZYguimgxqxOChg5Z1ZgqsghvnOY4bt27XM+94cXoqt0kRlPENs1rBp46vLMGCx20CufL+b6PHRZ8081jtWqRzAqCyz2FUXYVxz4XkBfMPcSrmYTScow0tONo8CDyWqlbdN6/v79b3D1N36Iu7wCvUHxBopFQhjMZprOPp+l516kft473Z5ZfgYaGscG70oAkWX5eUEQKt7w4+VAiyzLbQCCINwHXIAihpQCm4Gj+o4t9OKL7GhvJ1hfR9/SJcSyVTb5+fk0+v1UVlZSUVGBNWuQdlS/GMcw6VSKoa4OXIVFmG32/e5jz8unrGEBmVTqgOfR/xc+A/GJFMGu8JTg0REiPBonrY+QMo0iO8LEbWMIdoH3X3ULXl8O7R2l6PV6ysrK0GtRyG+Lyco5QRDo27ubva+uYzQrdowNDuwTJ5tbVEI8EsHmyuW4cy6i6cxz1e2aJ8e7Y2RkhGAwSF1dHQAPP/wwoVBIjaI95ZRTsNmmespPOOGEWRnn/pBkibaxNjYFs9Udgc10hbsAMIgG5ufP59qGa9VI2jzzgb1/jnWS8Rij/X14/Yp54iPf+zot619WNgoCeUUlM4x/b/jhL9802ltD450gy7KSOiKAaNIjJTPEd428QcBIY1lUgKUuj1QgSvDXW5FiachMVWTnXlqD7bhCMqEEoac6EAziVJyqxaCaghoKbTjPqpiRUiJa9KowYV3kxrrowJGnBo8Vg0cz632nJOMxWta/greymvySMgbbWrjn/32K8z/5eWpWHE9+STmNZ56rGs5XLF5CxeIl6vE67d5LQ2NWeNcpMFkB5B+TLTCCIFwKnCXL8gez318LrAA+i1ItEgdePJAHiCAIHwY+DFBeXr60s7PzXY1vNsgkEnzvRz9CFEUqKyuprKzE7/fjcrlme2gah5H+5j3c84VPcf6n/x81y1YdtPMm42mGuiMzxI7xYAwZmYwuRm6ei0Kfi1GxjV1dGwHweDz4s+JbdXU1urfZPnOsMj1OtqimFmeBh44tG/nHj77NFV/5Nu7yCrb+80me+8OvcRUVK5Os4lI1Tja3qOSA4pfGO2NoaIjW1laWL1+OIAg88cQTbNiwgdtvvx2dTkd3dzcAZWVlszzSfYmlY2wf2q6ms2wJbiGUDAGQa8pVjUqbPE005Ddg0plmecRzl5G+Hjq3bWawtZmB1maGe7vRG4zc+oe/Iup0bHvuaWKhEIVVtXgrq7VElmMYOSODJCFnZOS0BJIMooDOriwuJPsnkFMZyMjKvhkJ0W5Uo1YnNgUgJSFnsudIZDAU2bDMy0dOZQj+ZtuM9hIkcJxSRs4ZFWQiSfq/9qo6FsEoIloMOE4tw768iEwkSejpzn0EDEOpA73LpI5dMGif2XOBdCrFi/f9idKGBVQft4JYJMzPP/BeTrjqfSy/4FLSySR7X12Hb2EjNlfubA9XQ+OY5s1aYA6bACLL8kff7rmPZA+Q8fFxnE6tjP1oQ5Ykxgb7CXS0E+xsx7eokbJ5C/e7byqZoH3jekobFmDNcb2jx0unMgz1RAhmhY5AV5jR/gk14dScK2PwxEgaRhmZGCAam+Dqq6+mpqaGYDDIwMAAfr8fu12bhB8IWZIIjwxnTUcPHCd7xk0fY+HaMxjt72XD439n6TkXkFtYTCadQhR1mk/AIWJoaIgtW7awevVqzGYzr732Go8//ji33XYbLpeL0dFRMpkM+flzr2c6EA1MRdEGNrN7ZDdpWWlnqcypVI1KG92N+Jy+OTf+uYCUyTDc281A614GW5tZc+X1mO12Xn7gXl66/26sOS4liaWyhsLqGnwLm7RV1UOELMsgoYoJoll5nTORpFLBIMnIaRk5I4EMJp8TgGRPmPRoAiYFhGyKiG2pYiob3RIgFYhlBQgJMjKCRU/O6UpL0vgznaQGJmZs1+WZybu0FoChu3Yq29OyUn2XkTGWOyl433wA+r+7nsxwfMZzMTfkUXC9sr3va68gRWZWYVoa3eRfWQ9A7/+uQ05KM7bbVhaRe2E1siwz9PvtaoLJpEeG0efE5HMiSzLpYFT9uaDXPifmOrIsk4rHMFoU0fSh73wVT0Ulqy+/BlmW+fVHbmDRqWey6pL3AjDc001uUfHb9mXT0NA4tBzuGNxeYPrSW2n2Z8cUOTlaDN7RRiqZ4JcfvoZkLAaAIIqYbbYDCiAGo4nalWv+6/NnMhIjfRMEO8MMdoYIdoYZ7okgScoE3OIwkFduomS+h/LaQgRrnDvv+i2Mg9VqxV+pVHhMeh+43W7c7gOXvh5ryJKEIIqkkglee/gBShvm41vYyFB3p5r4AGAwW8gtKqa4toH5J52WreZQqjoAcotKOO0DN6v76/Sad8/BZGxsjBdffJHly5fj8XgIhUK8+OKL1NTUUF5ezsKFC5k3b54q6uXmzo1VtoyUoWWsRRE8si0tvRHlo8+kM7GgYAHXz7+eJk8Ti92LcZldszvgOYgsKxNYUaejb+8unr/7TgbbW0knEgAYLVYWrD2DQnsNi047i/knn4oj/8g0aZ7eRidnJKR4RhEIJgUESUbnMiOadGQiSVID0WkCglKlYKrJRWczkBqcIN48pgoEynYZ+5pidHYj8eZRoluC+2zPvawWnc3AxPoBIq/277Pd+4kliCY94091EH6+R6mcmLZmVvKNNQiiQOjpTiZeG5jx/ASDSMn/rQYg/GIvsc3BGdtFu2FKANkcJL5rBHQCgk4AUUTvtqgCSGY0TmY4BjpR2a4TZhhtGtwWBIOIMG27YZo3heOEEqR4RtmuF0AU0OdNmQXnXV6HLMlKGolOBL2AzjZ1XffetlQdmyAKCCadGgMrCALuD+z/HgCUlBKD13bA7RqzT2RkmEg2bQ3gL1/+LEaLlYs/92VAibU2ZcUQQRD48E9/P2PBI7907lUbamhovDmHQgBZD9QIguBHET6uBK46BI+joXFQ6dq+BVGvp7R+/n63G4wmlrznQpwFbjwVleSXlv9X/hz7Q5JkxgajM9pYhnoiZFLKKpPJqsdd7mDBKUXI9gihZICevr1sHhjgOP9xVCxcgCRJnHXWWVRUVODxeLTUILJxssEgo309jPT1Mtqf/drXg3/JMs748K3o9QY2PPYwOp0O38JGcotKOPUDt6htK/bcuVdJcDQTjUZ57LHHWLRoEXV1dQiCwNatW6mqqsLj8eDz+bj99tsxZv/WLJa5YboXTUXZOrRVre7YGtxKJBUBIN+cT5OniffWv1dpZ8lrwKDThLI3Eh4ZUpJYsm0sg63NrL3hRuadsBa90YQkSSw85QwKq2oprKoht7BYnXi8sbxcluQpgSDb5iDoRUSrAVmSSfVPKBUKWZGBjIQu14zBY0VOSUS37isQGCuUVfzMRIrwv7v32W5d4sFck0t6OMbowy1qC8VklYLzdB+Wefkku8MM/WnHPtvzr27AsqCAeMsYw3fu2Of1KfjAAsw1uSTaxhm5Z/c+2923LEZnM5DsCjP+j7aZG0UBa5Mbnd1IZjRBonlUFRAUkUBUBA0UsUJnM8wUGHQiZK+DRp8Tx5qSqZ9PniOL9TgvJn/O1M8nhYYsOWdU4Dy5bEq40Iszjs+/Zh6IB46Zzru87s3eRuSc5X/T7faVxW+63Vz75iLqdLFE48inb+9ugp1tLD79PQA8+/tfMtzTyft/9GsA5p982oyFjTNv+viM47VqTw2NI593G4N7L3AyUAAMAl+SZfl3giC8B/gRSgzu72VZ/vo7Of+R3AKjceTxh0/dQo7Hy0Wf/dJBPa8sy4SG4orY0aEIHsGuMKmEEoakN+lwl9nxVDgpKLNizgNfdTGCIPDjH/+Y0dFRRFGkrKwMv99PbW2tmmJxrBKPRIhPRHB5CwF44mc/YLCthbHB/hmGstPjZH0LG9Vkh0w6rZXJH2ZkWUYQBCRJ4t5776WiooLVq1cjSRI///nPOf7441myRDGHkyRpzgl6AxMDSjJLVvDYO7qXjJxBQKDKVaV6dzR6Gim1lx7RIpoqJkgyoinb5hBOIsWn2hwmfRQmfRIS7eNkIilVhCAjI1r1WBYUADD6fDuhzgF0OgP2nDySEzFeeeYvNIc2Iogiq8ovJMfmxpnvxmS2KQKEz0nOmRUABH6+mcxEakYbhGVhAbkXKau2Pf/vxRkmkgC2VUXkXlCNnJbo/cK6fZ6n4+RScs7yI0VT9H31lX22O8/w4TylnPRYnMEfbABRmdhPTuKdp5ZjW+olPRxj5C97VIFgUgSwH1+MudpFejhG+D89b9guYF3sxuC1kR6LE985VQExKTKY/DnoHEYykSTpQGxqu15UqhhyTQgGHXJKUjws9KIyNp1wRL//NDQOJu2bXmfH8//inFs/jSCKPH/3nWx64lE++oe/otPrGWhtRspkKK6tn+2hamhoHEQOqQfIoUAQhPOA86qrqz/U3Nw828PROAp47ZEHmBgbZe31HzrgPsM9XVhzXFgcznf8OLIsMzGWUKs6AtlklsSE0vcv6gUKSh14fQ5F8Ci3kxQidHS0097eTmdnJyaTiU9+8pMIgsD27dsxm82Ul5erK+DHCm+Mk03FY6y+4loA/vKVzyGlM7z3/74LwN9/8A2kTIbcohItTnaOkEql1Gjv++67D6PRyMUXXwzA/fffT3l5OStWrJjNIR6QtJRm7+hexag0sIVNwU0MTCgl/ha9hYUFC1XD0kXuRTiNB75mTAo/clpCSmT2aWPQ51sQ9CLpsQTpodjM7ZKEZV4BgkEk0RUi2RXepwrBeVo5gl4kujVIfO/ozO2SrPochJ7rJrZjaIaAgF6k8BNLARj56x61CmKyzUGXY6ToduV3FPz9dhJ7R2c8N73bQuGnlHuLwC+3kOwIzdiesqfZbn+Nwda9rNCfTa7Ji4SEzqAHnUDckcByXiHuikrG7tqLFE7OqEIw+XPIOaMCgNG/NSOlMjMEBGOZA9sSpY0i9G/F/HZGG0ShTfFhkGXiO4enVUAoAoMux6QYTUoymdH4zAoJ/bSWCg0NjTlNPBLBYDah0xto3fAq/7rz11z1te9hc+Wy7bmnWf/I37jyK9/GmuMiFg6hMxgwmudGNaGGhsah4XB7gLxrZFl+FHj0uOOOO/BsVUNjGonoBCbrgftsJ8ZGCQUDb3qO/NLyt/24sXBSETumVXdEQ0lA6f3NL7FR1ejGU+HE43OSW2QlFB7H5XIhiiJPPfUUL7+sRDXm5+ezePFi/H6/OmlasGDB2x7TkUiws53+lj1qu8r+4mQdBW6Ov/waBEFgxUVXzDj+/E9+/nAPWWMasiwTCoVU76MHH3yQQCDATTfdBEBRUZEqhgBcdtll7+xxprc5ZAUEwahDNOuR0xKpQHRKAMhWKeg9FvQuM5mJFPHdI29og5Ax1+cSz5XY2bKF2KsBhieGGIuOQgZ06Bgq7mNxxWJu9XyYhTtLsQpWhBDIzYqIYL5EgFKI7RjabxuE5yONGEsdTGwYZOyhln2ek/dTSzG4rcS2Bhl/vH2f7UWfz0FnMBHfM0r42a6ZG3UCjpNLFQElEFUECv3MNofJa4na5iBmKwh0AqJxyrTPVJOLzmGc0eYwaXIJ4DixBFuTZ0abg2jWKXHfne0EvH0MxzsRdAJrrroO9CJ//frnmRgYpbCyhpgfcqodeKtq9nutfjMfBYDcS2redLvz5AP34QuCgGV+wYG3iwL6fG0ypKFxJJBOJulv2UNecSk2Vy6d2zbzwNe+wBVf+Tal9fOxufIorK4llfUOWnDy6Sxce4Z6/LtZ5NLQ0Dg6mJMVIJNoLTAaB6K/eQ8tr79CsKONQGc7qXicj/7+vkPam5mIpgh0hacSWTrDhEeyzvIC5HqteHxOPBUOPD4nBaV29EYd4XCY9nalwqOtrY3x8XE+/OEPU1xcTG9vL8FgEL/ff1Qb56aTSUYH+sgtKkFvMLDn5RfY8PgjXPnlbyPqdPzzd79gy9OPoTcY942TLVK8OeZqnOwMM0Mp2xogy0p4jKyspgsmndL+kcgopeoy2VV2ZbsuR4k7zUSSyAll+/Rrs8GtGLClR+JKG8LkuUFpQyhWXpvUwISSxjB5vKzELprKlRu+RGcou11WxyBa9JgqlfdefM/ItPMr59A5jJhrlB756JYAUiKDJEkMh0dx2/PQ55n5d/trbNy4kY8cfw2kZPYMthJJRGkqqMdU7sTa5AFg+N7dkJZmCASW+fnYV5cgJTMEfrppHwHBvqYE5ynlZMJJ+r8+FSc5Sc7ZFThOKiM9FGPge/t+XrgurMK+sphkX4TATzbts/2u6ie51/AoDVE/X++6FUlUvCN0ej1Gg5H8i+uw1OaR6BhXBIo3tDk4T/dhLLKR7A4zsX5gH58E24oi9DkmUgMTJFrHpgkUyj7m2lxEs570WJzMSGKmj4JOQJ9vRtCJSMkMpKUp/wTx8Lc5SFKG8cEBcosUQ+B/3fkrtjzzBFJGqXCzOHMoX7CYcz/+GQBSiTgGk+afoKGh8c5JxeNs+9dTFNXWU1Rdx0hfL3d+4kY1mS0aGmfbs09Rv/okcjze2R6uhobGHOGIa4GZRBNANA7E6/94iBfu+QP5peV4Kipx+ypZfMZ70GdXmeVpE7zJSeZkX7ScltSYvkkTOFlGdX2XYmmSkSTDfROMdEcY6gkz1BshEFTEDrMArjwTeSV28gtt5JXYyCu2Yy1zABDuGSUTS2Exmeke6OHPj/9VOc5spqKigvK8YuqKq7CZrOpEVrDo1UlqvHUMOT45iVW26+xGdZIa2zGklNJPPj9ZRpdrwlytTFInXh9ATknqNlkGg8eqGr2Fn+9RJurTJujGUjvmujzkjEzon52oL0p2DKaqHCx1eUiJDKGnOt7wGstY5uVjqs0l1DPI+BPtJKNREtEoqViURDRG8/AGBmPtXP3572HYLhMeHmJ8cIDCqlp0Oj3iAiu6MiuWjI3xJzqmTdCVr87TfJgqc0h0hRh/rH0fgcF1QRWmcifxvaOMPdY28/cuQ9576zGW2IlOrrJnt0+ew/2hRRg8ViKv9RN6sgNZmn68jPeTS9G7zIT+3U3omc4ZAgJA8f+uRLQaGH+iXen1fwMlX1uNoBcZfaSFiZf7Z27UCZR+XUkLGvnrHqIbZ1YqiVY9xf+7ClDiHuM7hmcenmui6LPLAQj+dhuJlrEZ2w2FViXFAAj8bDPJ7vCM7UafE8/NiwEY+MEG0oHojO2mGhf5N8xnYGCAzB86EUJpdui6edmwlyvjq3EvKCF6koNgMIj70RhCTFIm59lJvLXJTe4F1cr5f7gBAGHaJN6ysADH6hLkjMTIfXtUo8TJKgVzbS6WhnykZIbIC737+CQYyxwYi+1Iycx+jR5ll46WVDub+zfR2r2HbSM7GEwMkhbSGPUm6rwNNHobafQ0sqhgEXbj3BTaZoPI6Ag9O7cxkDUpDbS3kkomuPXOv2C0WNn+738y0ttNYVUNhVW1OAqOzEQWDQ2N2UdtF5QknvrVTyipn8fCtWeQTqW44/rLWHnxFay69L3IkkTHlo0U1dRjtmvXaw0Njf1zxLXAHA1ENwfUSejkRFFfYMFc7QIg8lJfdhI6NZEyFNsw1+QiZ2TFcR5mTPRM/hzMNblIyQyhZ7tmTBCRZcz1eZhrcslMpPaZpMmyjLXRjbk6l/RYgtBTHTMmsMhKrr25ykUqEGX8iWwp9rRJtPOUMkwVOSS7w4w/0Z5dgJ56jJxz/MoktGWM8Sfb9xlf7uV1GIvtxLYPMf5Ux4xzI8sUvH8BBreVzgdfJfXqGBa7A0EQ1f08H2tC7zITfr6Hotc8XF79GeXh+2ToBeFkwADjT3ZMvX7TKPnaatALjD3Wtu8kVBQYPaOCQFcY154RvBml9SI3+88vCgydX4mnwoH5tQGSu0egKwRdIdJk2OmIMr7SRFtbG329fTSmK1iarkRHhmW6KspcxSz41FpEUSTw883E/tVGbNrDG8sdeG5pBGDs762kB/edhLorlRLxsUfbyIwlZmy3zM9XBZCxx9qRY+kZ261LPKoAMv5Ux37NAs11eSBn33uCAAIgKJUNgl7AUpcHGYmJjYMASJk0ol6PoBMZTwT5+9d/gD5t4LTia5CR0SNg1DtxmPMwr3Rx3MJc7Dn5RAY7MQtWLO5KCGXICBlslkIsnnyS/UoFgyCgJhAgTL4RlVJ1wSBOjSu7nxpJaNIp8YeTx09uNyrbdY6skJTdJmS/iialFcBQYMGy2K3+fHIMk60CxjIHjhNK1ddGHaNeOb+pNhfBrJ9xbgTl/QVgXViAwWPNPqfsGKbFOdqWF2KqcikCwuQu+qmqJsdJpUobwvTfj2GqjSHnbMXQcer5gTCtzSH3khrlujT5ugpKpOMkBdfPQ87ISLJE/9AgLkcODpeT1tZW7r77bq6+5Eoqy/2YQ7V4+uopr6rBbLeQb9ZTVlaGvEh6UwPGSb+J/SHoRPKvbjjgdtGow3nqgdvURKMOy/wCxhPjbAluYXNgM5uDm9k+tJ1YWvlrK7IV0VjeyCWey2nyNFHtqkYvah+DoERBTgodi884G0deAXtfWcdzf/gVOoMBT0UlC9aeTmFVjXJdBhacfNosj1pDQ+NIJJNOEQ2N48hTWtMe+PoXcbo9nPHhWxFEkdG+XlzeIgD0BgM3/vKPWJ3KIpAgivib9jun0dDQ0PivmJN3ftNMUGd7KO+Ysb+3IkX3MwnNCiBjj7XtfxJakwuyrAgY0xEACWV7WiKyrndqkpGd7OhyTIqAkpKIbQtOTZJQJoomn1JhIKcyJDpD+0zSJifNclpSJthvmETK6anxypI88/hp5diCXlCqKd4wiRT0IpKUIRwdRecxI+qnTRSZmsgZ3XZGzJ3YKryY7bap47PbDUU2bMuLpiZw6kQwOwmtyslOwqaPX/m/lJFIemzE5+UTHk0QGYkzMZ5AkqD9vr2Y7QYqC60Yc4w48s04CyyYrHoEvUhFo1LGHzOJhOosOKwOZGR+9vidRBMxhBcFSkpKWLV4OTVeP/l5HgQBioTFCCadmmrhuqBaaXMQp14bcdokNP+qeuW1njY5nj5JdX940VT7w+REd9okt/CTS7O/92mvz7RJdPGXVs18bRDU/QW9SOk3T9g3TrZrMyNf7WX+Sacy/8unMtLXw52fuImzP/JJ5p14CiN9PSxMnElecQnmojePk7V/0r3PzyYxFtnwfqTxwNtLHbg/eGCvAJPPienaeQfe7s9R4hoPtL3ShanSdcDt5ioX5qp3vv2tzm+qyMFU8SbjK3/z3uXJRI4DYSjcv0+OJEn09vZiNptxe9yMjIzwh/vv4j3veQ/Ly5dTbirnkksuoaSqHJ3VREGOl4KyfUuNp4s1hwNZlukOd6vpLFuCW2gZU3w2dIKOurw6Lq65mEZPI43uRgpthYd1fHOVyZXW4Z5uXrj3jwy27iUyOgIok4uS+nk48gqoW7WGkvp5FJT5tNQkDQ2Nd8xIXw+hwCAVjYoI/sDXv4iUkXjvV78DQFF1LdYcl7r/pMH5JJPih4aGhsbBQGuBOUSkxya9IbITUJRV6ElTuemrtOpEPlv2LctZH4FpK+BHS1nxYFsLf779Ns77xOeoXbnmkD6WLMmMBaJTiSydYYa6w6SzK+BGsw63z4m3woG7XPHucOSZ93mtZVkmGAyqHh4dHR24XC5uvvlmAF5//XUcDgc+nw+z+cjqd5cyGUSdjlQ8zisP/UVNXDlQnGzjmecy74S1SJkMI73duLKeHhpHHl1diqFmeXk56XSab33rWyxdupSzzz4bWZbZvXs35eXl2GwHNhc+3CQzSXYO72RLcIsaRzscV1qCHAYHizyLaHIrUbQLCxZiNVhnecSzTyoeZ7C9Ra3uGGxtZsk5F9B05rmMBwb42ze+lG1hqcFbVYunwq/5dmhoaLwrundspXvnNo6/7GoAnvzFj2jbuJ6bf/1nBEGgdcOryJJM9bKVszxSDQ2NoxXNA0TjkKJEv46qhqQldQ2UNuw/vSSdSrHnpecpX7hYLX08WGMID8enxc+GCHaGScYzAOiNIu5yB57yKZPSHLdlRvvBdEKhEE6nstr+yCOPsGmTYp7ocrnw+/1UVVUdMQktmXSa8cAAI329iKJI5ZJlAPz+EzdRPn8Rp33wFqRMhp/ecAX2/ALVeFSLkz266O7uZmJigvr6egB+9rOf4XQ6ufZaJVq4o6MDt9s9pwSP0fjoDLFj+9B2kpKSslRqL1WjaBs9jVS7qhGFw1uBMteYTGSRkSmqriOViPPTG65AyijXQUe+m8KqGhasPV29DmhoaGi8E2RJyi7yCbRtXM/rjz7Ixbd/Bb3RyKsP38+rD/2Vm391FwazmdH+XmQZcouKtXsJDQ2Nw4LmAaJxyMikU/zmox9gIls+DXD85VcfUADRGwzMP+nUd/24E2MJBjtCBLumqjviE0rFgqgXKCixU7u8UBU7cgutiLoDT46i0eiMpJaRkRFuu+02XC4XCxYsoLS0FL/fT15e3rse+6EiGhpnpLdbaVnpVyo5Rvt6GQ8MqBMgb2WNOvGZf+IpuAqLARB1Oj76h78giroDnl/jyKKvr4++vj6OO0659r/00ksMDAyoAsgll1yiinwAFRUVszFMFVmW6Qh1sDmwWW1p6Qh1AKAX9DTkN3BF/RWK4OFuxG09cCvVscTudf+hZ9cOBlqbGepqJ5NOU9G4lEtu/woGk5mTrnk/Od4iCqtqsLlyZ3u4GhoaRyCyLDMeGMSW48JgNtO2aT2P/fi7XP2NH5BXXIosS6Szvh7OAjdL3nM+y86/WL2nmEyO0tDQ0JgLaAKIxpvS37IHWZIprq3f73ad3sC8E0/BnpuHx1dJga/ioMeVxiLJGW0sgc4Q0XFlFVgQBfKKbPgbC5QIWp+D/BI7urfwIkhk8+FNJhN79uzh3nvvBcBoNFJRUcGyZcswZFs7qqqqDurzeTekUym15WTPyy8Q7OxgzZXKCv4j3/s6fXt2Aqhxsu7yCmpXrlGqOrKVHZOsuOjyGefWxI8jm8HBQXbt2sWJJ56IKIrs3LmTl19+mcWLF2MwGDjjjDNmtGgVFs6uH0Yik2DH0A61umNzcDNjiTEAnEYnjZ5GLqi+gEZ3I/ML5mPRW2Z1vLPJ5ORjoHUvA63NJKMTnHHjxwDY+s8nGWxvweuvpuns8ymsqqWoplY9dsl7LpitYWtoaByhpOJxOrZsxO3z4yosom/PLu770me48DNfpGrpCnILi2lYc7J631C1dAVVS1eoxxuMptkauoaGhsZborXAaLwpf/rMrdhy87jk9q8clsdLxNIzqjoCnSHCw3F1u8trVas6PD4nBWV2DMa3nrin02l6e3tpa2ujvb2dnp4ezjzzTFasWEE4HGbjxo1UVlZSXFyMTje7QoDSzjOk+HH096i+HKP9fURGhrj1jw+gNxj4959+Q9umDdzwg18gCAKdWzcjSxlyi0txFrgRxGO7HeBoZ2RkhI0bN7Jy5UrsdjubN2/mkUce4aMf/Sj5+flMTEyg0+nmjC/NcGxYFTo2BTaxc3gnKUmp2vI5fTS6p9pZ/Dn+Y7qdZWJsVK3WePWhv/L6Yw8TD4cA0BkMFFbVcMWXvoUgisTCIcw2u/b3rqGh8Y5JJ5O8+vBfKaltoKJxKRNjo1i7JN0AAJRASURBVPzyxms56Zr3c9x5F5NKxNn1wr/xNx2HI//gtS9raGhoHCo0DxCN/bL5qccYDw5y0jXvP+A+gY42LA7nIfnASyUzDHVHsmKHIniMTYt/dRaYVXNSj8+Jp9yB0fLfFS1JkkQ8HsdqtZJMJvn+97+vVn0UFRVRWVnJggULKCoqOujP678llYgz0ttDQbkPnd7Arhee4/V/PMxIfw/pxFTMrcFkVr04cotKOO7cCzFarMiSpE16jiEikQgvv/yy+r7t7u7mzjvv5Oqrr6aqqopkMoksy5hMs7/yJskSbWNtqtixObCZrrBiumoQDczPn0+Tp4nFnsU0uhvJt+TP8ohnj0R0gv7mPdNMSpVElht/8UfsefnsfOE5undsU41KJ68XGhoaGm+XTDqFTm9AlmX+8aNv4/FXseLCy5BlmZ9/6GqazjyX4y+7ClBM6/NLy9EbjbM8ag0NDY23zxHnAXI0xODOBdLJ5Jt+cI309zDc3XnA7QCeisqDMpZMWmK4NzKjlWWkf0KJ0wVsOUbcPid1K7x4fE7cPgcW+3//oSvLMiMjIzOSWgoLC7nuuuswGo2sWbOG/Px8KioqsFoPXzKEJGUIDwUVX45spOzi08/G7fPTtnE9//jRt7nuO3fg9vkR9QasLhelDfPJLS5V21YOFCeriR9HN6lUin/9619UVFRQV1eHKIq88sorFBQUUFRURElJCZ/97GdVwcM4izepsXSM7UPbVf+OLcEthJJKxUKuKZfFnsVcUnsJTZ4m5uXPw6SbfZFmNkjF4wx2tDLY2kzVcStxeQtpff1VnvjZDwClT75s/iIKq2rQZVvd5p2wlnknrJ3NYWtoaByBxCJhJkZHKCjzAfDXr34ek9XKBZ/+AkLWvHTy3kIQBG765R9niKveSu0eXEND4+hEqwA5igh0tNG2cX02jaWNibExPnrnfYfd20HKSIwORJWqjg6ljWWoN4KUVt5rZpthWhuL8tXmevsTomg0qooZ999/Pzt27ADA4XBQWVlJTU3NYU1qiYVDtG1cP8OAdHSgb5842TNvvo3qZSuJjI7Qt3cX5QsWH3TfFI0jk3/+8584HA5WrFiBLMv88Ic/ZOnSpZx00kmAIooYZjl2OCNlaBtvY/vQduXf8Hb2juwlLacB8Of4VaPSJk8TPqfvmHb9D48M8dJf72agtZnh7i5kWYnhPuuWTzD/pFOJjo8R7OrAW1mtXQc0NDTeMYNtLQz3dDHvxFMAeOjbX2E8MMj7vv9zADY9+Sh6o4mFp5wxm8PU0NCYq8gyDLdC74apfw3nwZrbZntk74gjrgJE453Rs2s76/5yF67CItw+P/NPrCSTSiGaDp0AIksy48GYksiS9ewIdodJJ5WbfKNZh9vnYPHaMjwViuDhyDe/owlRPB6no6ND9fEYHh7mM5/5DGazmfnz5+Pz+aisrCQ/f/8VE++WyThZUdThKiwiPhHh4e98lcWnnU3DCWuZGB3hyZ//EFGnI8dbRF5xCRWNSw8YJ2vPzaN2xeqDPk6NI4cXXniBiYkJzjrrLEBJbsnPV9pBBEHgtttuQ5xW6XO4xQ9ZlukJ97B9eLsqeOwa2UUsHQPAZrAxP38+18+/XmlpcS/GZXYd1jHOBSQpw0hvz4w2ltqVa1h2/iXojSZaX38Vb1UN1ctWZltZalWPD2uOC9/Cxtl9AhoaGkccHVs3sfflFzj9w7ciCAK7XnyOLc88Sf3qkxB1OpZfcBmZdFrdv+ms82ZxtBoaGnOOSDArdLye/boR4mPKNoMVipvAdnR6/mgCyBFCz87t/Puu33LeJ24nx+Pd7z7zTzqN+SedhukQtXjIskx4JE6gI0ywK8RgR5hgV5hkTPmA1RtECsoczFtTrFZ3uDxWBPGdiRGpbOWEwWBg69atPPTQQ8iyjF6vx+fzsXjxYiYrmObNm3fQnmN0fEw1IJ1sXRnt72VscABZkliw9gzOvOljmCxWdHoDQtY0Nbe4lBt++CtyPF50eu1PS2NfXn/9dZqbm3nve98LKL4e4XBY3X7ttdfOEO/Ew9zmFIgGVKFjx/AOdgzvYDwxDoBRNFKfV8+F1ReysGAh8wvmU+GsOObMSicTWRLRCbz+KmRJ4pc3XkcspLxOBrMFb2UV1hwXABa7g5t/c/cxXQWjoaHxzkgl4uj0BkSdjraN63n+7ju54svfwuJwMj7YT/uWjcTCIazOHJadfynLL7wcMXtPUlJ/cO6LNDQ0jgKS/5+9+w6Pq77yP/6+0zVdXRppZFnNtiRbsi3buNE7mN4hIQFCEtIL2SS72fLbZGt2s8mmhyRsEhICaZAOJEBCCeAi25J7Ve/SjEaaPvf3xx3d0VAdsK12Xs/DY66vLH8lkDRz5pzzmYDenZnOjq5tENB2s6EYoKgB6q+EstVQ3gIFS8A4f5/LzN+PbA5RVZXQyDCWHPtrFi/MOTlYHU7ikfBrvp+TXfiYCESzdnYMdgQJj2tFCYNRIb/MSe2aYn2MJa/UjsH45p8MpVIpenp69D0eHR0dXH311TQ2NuLz+di8eTNVVVWUl5djOkkFhqM7tpJKJfX4tm+9/w7Ghwb1+0azmdwSHwXpONnc0jJ9LlYxGLj+M5/LvK3JRJ5Psu5Fxp49e3j66ae56667MJvNpFIpEokEiUQCk8nEJZdckvX2p/NJciAa0IocQ+3sHtpN+1A7A+EBAIyKkWpvNedVnEdDfgONBY3UemsxGxfm8s3ju1vp2rNb6/A4cojIeJDS2iXc8tn/QjEYWHPFtdjdHkqqa8n1lb1i7FCKH0KIN5JMxBk8dhR3UTF2t4fju1r56b/+PTf/v/+ktHYJVrsDT1Ex0clJclxuVpx3MU0XXKr/+amuMiHEApdKwuA+6JrW2TGwB9Skdt9TAWWrYN3dWsGjtAksjpk982kmO0BmgcGOY3zv3vdz6QfvZdnGs2bkDJFQnIGOzM6OgePjTIxpSSSKAnk+B4WL3BQvclG4yE1BmROj+a298quqKrFYDKvVSigU4n//93/1pJbi4mIWL15Mc3MzJSUlb/r9h0aG9X0cU5GyANd++v8B2lKwRCzKLZ/9L0CLnDRbrfoSUldB4WnfoSLmHlVVtSji48d59NFHufnmmykoKODQoUP85S9/YcuWLXg8nhk732R8kn0j+/SdHe1D7XoqC2gxtFOFjsaCRpbmLSXHlDNj550pkYkQ/YcP0Xf4AMHBAS64+/0APPL5z3J464sU+Csorq6jpLqW0tolJ21JtBBi4YlHIux99mlKqmspqqxiqPM4//fx93HJ+z5K/ZnnMjE2Suvvf0XD2RfgLX5zj4OEEPOcqkKga9ooy3boaYX4hHbf5tGKHGWroaxFK3w4i2b0yKeLxODOkOjkBIPHjzJw7ChFi6soX9rwqm+XTCTY9Yffsbi55bT8kItFEul9HVPFjiDBoYh+31ts17s6iha5KPC7MJ+kPSJjY2P6Do+jR4+yePFirr32WlRV5fHHH8fn81FZWYnTeeLLAOOxKGaLtkR1z5+f1BaR9nQz2ttNPJr5uKbiZAsrFnPxPR8GYHx4CKvDgcW28J7siTcvlUphMBgYHh7mgQce4MILL2Tp0qUMDw/z+9//nnPPPfdNF+7eqngyzoGxA7QPtesFj8Njh0mll28W2YtozNcKHQ0FDTTkN+CxzlxxZqbEIxFMFguKwcDuJx/jpUd+wmhvj34/t9TH2/79S5itNsZHhrA5nJitthk8sRBiLkslkzz5f9/EV7eMZZvOJh6N8L+338AZ197EhutvIZVKcujF5ylf1qiP0AkhRJbwGPRsz3R2dG2FCa17F6MFSpanCx3pokd+tfZK9gI055agzvUY3FQqyf0fvYfR3m7999Zcce1rFkCMJhMrL7r8lJwlEUsy1BXKSmQZ7Z+EdN3LlWejqNJFw+Yyiha5KKxwYbWfvDb3WCymx3M+8MADHDx4EACHw8HixYtZsmQJoLWIX3jha28mT6WSBAcH9SjZ5eddiMWWwws/f4jnHv4hH/zeTzCaTPQdPkDfof3k+spPKE7WlT8/l/uIk0dVVRKJBGazmWg0yte+9jXWrFnDxo0bcbvdFBcXY7NpT4zz8/O55ZZbTtvZUmqKY4Fj+pLS9qF29o3sI5aKAeCxemjMb+Qc/zl60aPQXnjazjdbJBNxhjqOa98f0otKhzs7uP3zXya/vAKLLYf88goazjqf4upaSqpqsU0rwrry5PuEEOKNqakUkYkQOS43oCWxeItLOecdd2MwGuna00aOSys4m6027vryfbjyte/JBoORujM2zdjZhRCzTCIK/W3avo6p3R3DBzP382uh+lxtZ0fZKihuBNNfn6q5EEkHyCny5P99C7vbQ2HlYooWVeHIzTvlc+DJRIqRnol0IkuQ/uPjjPRMoKa0/8Z2t0VPYpnq7shxWU7qGaLRKB0dHXqXx9jYGPfeey9Go5Ft27YRi8WoqqqiqKjoVT8fsUiYoY7jWVGyIz1djPX3ZsXJ3vovX6Ckupaufe10721n1SVXYLbZ9FEEId4sVVWJRqN6UePrX/86paWlXHnllQD8+te/pqamRi/enc5z9Uz06IWOtuE29gzvYSLd5phjymFZ3jIaCxr1JaXlzvIF9/WgplKM9GiJLKW1S8jzlXN42wv84j/+GQCby51OYqll+bkX4S5YeAUhIcTJERjoZ3xokPL6RgAe+qdPAXDDP/wrAE9971s48wpoufxqAHmMIoR4da+IoN0Kfbshqb2ghaMoU+goWw2+VZDjndEjz3YyAjMPpVIqo30TWTs7hrtCJBNam7vVYdKLHNqvbhxey0n/wZtIJFAUBaPRyEsvvcRvf/tbUqkURqMRv99PVVUVZ5xxht4FAtrITyqVxGyxMtbXywu/eJjVl15BQUUle/78JL/9sraPQzEY8BaX6hGyuaVl5E3Fybo98iBCnBSqqjIxMaGPXf3whz8kEolwxx13APDMM8/g8XhYvnz5aT3XcHiY9mFtjGX30G72DO9hJDICgMlgYknuEm2MJb27o8pThXGB7quJTIR44ecP0Z9eUjq1LPrM2+5gzZZriIRCHN+9g5LqWtyFxfK9QwjxqlRVJRmPYzSbURSF0OgIgYF+ypYsA6D30H669rSx5oprAfjNl/+LzradvPvr3wNg//N/Rk2lWDpD+9yEEHNEaGBasSP9T0RLk9MjaPXdHavBU75gR1neLCmAzHFa7GI4a0npYGeIRFTb5mu2GimscGV1d7gLbKfkQX4qlaK/v1/v8Dh+/Dg333wzVVVVdHV1sW/fPhYvXozf7ycRnmQkPbIyvaMjMNDHWW+7i1WXbGGkp5sH/+ETXHzPh6lauYbQyDB9Rw6R5yvDU1QicbLipFNVldHRUfLy8gCto6O9vZ17770XRVHYtWsXiUSCVatWnbYzjcfG2TO8R4+fbRtqo3eiFwAFhWpvddaS0rrcOizGk9u9NRdMjI1mjbH46pay/tqbScRifPVdt5JfVq4vKS2priWvrFyWGAsxj6mpFPFYFJPZgsFoZDIYYLirg5LqWsxWG8NdnRzbuY3Gcy7EarfT2b6L3X98jPPufC9Wu4O9zzzFX372Y2757H9htdt58ZGf8Ocf3s8Hv/cTzFYbf/npgzz70A/48AM/x2gy8+xDD/DSoz/hfd95ELPFylDHMVKpFIWLFkthVQjx6qZH0HalF5W+PIJ2qrNjAUTQni5zbgfIQqaqKqHRaNbOjsGOcaKTCQCMZgOFfifLNpTqiSy5xXYUw6n5wauqKslkEpPJxPDwMPfddx/hsPbqakFBAc3NzcTHA4z29VBeXk6e28XP//2f+G1vN9GJCf39ZOJkF1F3xkZKa+oAyPOVcc+3HtDfzpmXT01e/in5WMTClEqlGBwcpKCgAKPRyHPPPcfjjz/OJz7xCex2O/X19RQXF+udSytWrDil54kkIuwb2acXOtqG2jgWPKbfL3OWsaJwBbcuu5WG/Abq8+uxm09uxPVcEJkIMTE6Qn55BQDf/+SHGDh6GABFMZDvr8Bk1opAJouF93/nQQxGKXYIMZupqRTRyUlMFgsmi4VYeJLeQwcorKjE7vESGhlm7zNPUXfGRjxFJQx3dfD8T37E+utuJr+8gq69bTz2jS9x+Yc/SVFlFYe2vcCjn/8cb/v3L1FUWUVn+y5+9T//zu3/+WUKKioZOHqIp753H4tXrsFqtzMRGKPnwF5ikTBWuwObw0l+uR81pXXPli9rZNNNb9dfaV2yYTMl1bUoipZ613L5Vay7+gZMZm1XWkFF5Yx8HoUQs1QqCQN7szs7BvZAehE9ngooX72gI2hnAymAzLDJYIyBY0F9jGXgeJDwuLbrwmBQyC93Ur26iOJFbooqXeSWOjAa31r87BsZHx/PSmpZunQpm9auIdjVQZHLgc1hoay4hDOvvxlVVfnqnTdTt34TF7zr/dicTqx2B0s3nJVePipxsuL0SqVSDAwM4Ha7sdvt7Nu3j4ceeog777wTv99PXV0dNpsNg0H7Olq8eDGLFy8+JWdJpBIcHjucFT97cPQgCVUraBbkFNCY38hlVZfp4yy5ttxTcpbZrv/oYbr2tNF3+AD9Rw4y2ttDnq+cd37h6wAsWb+Z+s3nUFxdS3FlNWZbdiKLFD+EOPlUVSU8HsRoMmO120klk3TsbsVb4sNbUko8EmH7bx+lYnkTpTVLCI8HefxbX2bFeRdT2bSK4NAAD/3Tpzjz1ndSd8YmRnq6uP9j93DZhz7B0g1nMtbfx08++3dc8dFPU7tuA6HREf70wHfJK/PjKSohHo0ycOwwkfQLKlaHk6LKaozpAkShv5Izb32nnppSvqyR6/7us7iLigGoXbeR961agzVHKyIv3XAmSzecqX98i1e2sHhl5gVCX91SfHVL9evc0jJyS8v0a6tdnqgIIdJONIJ2yaXpUZaFE0E728kIzGkUmYhr8bPTRllCo1FAe7Eht9SRtbMjv9yByXzqH9QnEglM6VGT+++/n2PHjgFgVMCWiKEM9aGMDOhvb7baqG5Zx2UfvBeAYzu34y4sIs9XfsrPKsTLTY1l2Ww2cnNz6e/v52tf+xpXXXUVzc3NTE5Osn//furq6nA4Tt2D15SaoiPYoRc62oba2Deyj0hSi2J2WVyZMZZ8LYK22L7w9lEkEwmGOo7Rd/gggx3HOO+O96AoCr/76v/Q/vQTOPPy0yMsdZRU17FoRfNMH1mIOWVibBRFUfSiwLFdO8hxuiiu0pL1XnzkJ+SXV1C9ei0Av/zCv7FoxUpWnHcRqqpy3wfuZMX5l7DuqutJJZN84ZYr2XD9ray/7mbisShfetu1bLr5dtZddT3RyUm+/M4bOOttd9Jy+dVEQiF+9Pf3sv7am1i68SwioRB/vP8brDj3IsrrG4lMhGh/6gkWr2whz1dOPBKh78hBCvyLyHG5SSWTJOIxzBYriuHUvtgjhBB/lekRtFPJLFkRtCsyYyxlqyGvSvZ2zCDZATIDYpEEQ53j9B8b1xNZgoNh/b6nKCdrSWmB34nFduobclKpJKN9vRzct49QCo4cOcLo4AA1SoxrP/3/eOaZZ9j5+G+YOHYIr8tFfjpCNq+0XF9G6sx7ZZysEKeLqqr09PSgKAo+n49oNMq//du/sXHjRs4//3xSqRS7d++mqqoKl8t1ys7QP9lP+1A7u4d2a4ksQ3sYj48DYDPaWJq3VOvqKGhgecFy/C4/BmVhPaCfaitXDAYObX2BF3/+EAPHj+iJTjani9s//xWcuXkEBvoxmkw4ZQROLDATY6Mk43Hchdorg1172kilklQ0NgGw8/HfoBiMrDjvIgD+8J2vY3M42Hjj2wB48B/+Bm9xKRff82EA7vvAnfjqlnHpBz4OwDfveScVjU36/a/dfRu1azdw/l33pP/8J6hpOYOWLdcA8Pi3vkzlilXUrtsAwI7f/4rS6jpKauq077/79+IpLsGZm/eKpaFCCDEvnEgE7VSho2wVFC8H08LbzTabzbkdIIqibAG21NTUzPRR3pQn7t/D/hf6IF1bcuZZKVrkpn5jKUWL3BRWuLA5zKf0DJFQSFs62tvNcE8Xoz1djPX20BuJE8krAYMBg8FAWVkZ/qICnCntCcmmTZtorl+G1enEbJEsaTE79PT0EA6Hqa6uRlEUHn74YUpLS7nxxhuxWq3cfPPNlJSUAGAwGGhqajqpf/9YZIy24basCNqh8BAAJsVEbW4tFy2+iMZ8bUlptbcak2FWfns9ZVRVJTg4kF5QeoD+wwfpP3qIaz71/yhbskxLizKbab7ocr3Dw1OU6YDxpFvWhZjtJoMBwsEg+eV+APoOHSA4NEDdGZsA2Pfcnxjt7Wb9tTcD8JefPshIbzeXvv9jgJYcMtbbwy2f0xLPfve1/yEyHuTWf/kCAM//9EckYjG9ALLvuT9hMlv0Akg8EslaEF65YiV2r1e/3nzLO7C7Pfr11X/z91gdTv363V/7v6yRsZv+6T+yPr4L3vX+rOuVF12u/7uiKJQtrc+6NlnkQb8QYg7LiqDdqv36ahG0TTelI2hXLogI2oFghJQKJR7bG7/xHCMdIKfAnmd7CI1G9e4Ou/vUPjgY6enm8LYXaL7wUsxWG8/8+Ac896tfkHS4STpcJOxuSiZGKC4pRvXkM2kwUVVVRfMZG7CfwpEAId6svr4+BgYG9IWk3//+9wkGg7zvfe8DoKurC4/Hc0o6PCbjk7QPt+uFjrahNrpD3fr9SnclywuW01CgjbMsyV2CzTT3fzioqspkYIxELEoiFiMejZKIRXHmFeAtLiEejbDv2T+RiEXT92IkYlEWN6/G37CC7n17ePAfPgGA0WSicNFiiqvraL7wUgr8i2b4oxMLzdRjG0VRCIfGCQ70U7hoMQajkeGuDrr376Xx7PMxGI0c27WDQy8+r41jGQzsfvIx2v74ODf9v/9AURSe/fH32f7bX/KB+x8C4Mn7v0nbU0/o1098+2sceP7P3HPfD7Xr+75CR/tu7kjvr3n+pz9ipLtLHxtte/JxJoMB1l55HQDHd7eSSiT0XRRj/X0YDAa9I0RVVemuEEKIk+V1I2gd6Qjaaaks7rJ5P8oyGUuwuytAa+cYO7vGaO0YoycQ4Y6Ni/n7LfVv/A5moTnXATLX1W/0nbT3paoq4WDgVeNkL3zPBylf2sDg8aM8/YPvULliJXGzlWePdhGubgTA43ZTXV3Nho0bKSgoOGnnEuJkGhgY4NChQ6xfvx5FUdixYwfbt2+noaEBo9HIJZdcgm3a0svy8pOzbyaWjHFg9ICextI21MaRwBHUdPtWqaOUxoJGrq+7nsaCRurz63FZTs1YzXSqqpJKJkjEYqgpFZtTe/V24NgRopMTWvEhXaBw5ObprxS/8POHiEyE9CJGIhbDt2SZ/gruA5/+CLFIRC9eJGJRlp97EWe//S4SsShff/fbXnGWdVffwKab3k48GuWxb3wp657RbMbu9uBvWEFRZRXn3XkPJdW1FFRU6ikJQpyIVDIJChgMRqKTk4z0dJJf5seSYyc4OMDR1q3UrtuI3e2h/8ghdj7+GzZcfyvOvHyOtm7jmQe/x5Uf/zvcBYW0Pfk4v//Gl7j7K9/FlV/A/mf/xB++8zXe843v4/DmcnzXDp78v29Ru24DOU4XI10dHHjhWc667Q7MNhtGowlLTg5qKoViNOKrW0YqldILEfVnnUf5skb97OuvvYk16fERgPPvel/WxzbVCTKl8ZwLsq4XLW/OuvYWl2RdS/FDCCHepNeNoDVCUT00XJ0eZVkNhUthnoc2JFMqhwdDtHaMsaNzjNbOMQ70j5NMaY99y3NzWLUolzv8XjbWzM/njlIAmSUSsRiqmsJstTHS080LP/8xoz3djPR2ZcfJmkx4S3x4yio41t3DjoNHOHz4MKve9WEKFy0mEolQXVNDVVUVVVVVeKe1xQoxW4yMjLBr1y7OOOMMbDYbx44d47HHHqOhoQGPx8PGjRs588wzMabbtE9G8S6ZSnIkcEQbY0lH0O4f3U8ipSWy5NnyaMhv4MLKC/VElvyc7H0UyUScSEgrMMRjURLRKKqqUlRZBUDX3jaCQ4N6cSIei2HJydELEH/52Y8Z6jhGIh7TuyhyS0q5+J6PAPDjf/ok/UcOp9+vtj+jorGJ6z/zOQAe/e9/IdDfl3Wm6pZ1egFk+28fJTY5iclq1WMmXQWF+tu68gv1lnWTxYrJatXb2U1mC+fdeQ8miwXz1J83W/GmR4tsTifv+sp3MFmsmC1WjBZzVrKT2Waj+cJL3/J/JzH7Te19QFEwmc0kYjH6jx7GW1yCw5tLJBRi7zNPsmjFSvJ85QSHBnnuoQdovugySqprGeo4xm/+9/Oc+873UF7fSNfeNn78j5/kur/7LIuWN9N3+AA/+ezfceM//hvlyxoZ7urgifu+SuGixdjdHiaDAY7s2MrKS67AmZeP2WLFmZvH1NxpYWUVZ1xzEyarNsZZ2byaKz/+d1jsWhJI/VnnUbN2A9b09apLr2TVpVfqH1/9medSf+a5+vXLk0KKF1dTvLhav3Z4F2ZykxBCzCpvFEHrnR5B2wKlKxZEBO1AMMKOjlFauwK0Hx8l0hXiYDzOKCoVVhN3OJzE1yyiamkBy20W+O1xPBursC5yz/TRTxkpgJxGqqoSGh3WChs93eSW+li0vJnQ6AjfeO/tnHfHe2m+8FLUlBYzl+srZ+mGM8ktLSe31EdemR9XQQHf/e797O7qYvefn8VisVBZWUlpmRbTZrPZuO6662b4IxUi2/j4OC+99BIrVqygoKCAsbExnnrqKSorK6msrGTFihU0NjZiTz8hcbtP7Juuqqok4jFMJjOKwcBkMEBoZJh4NErvWBdHRg5xfPgobbl97B3bh7s/RfGoFRtWFpvzWWNei9fo5uL3fhif08f23zzCgZ8+y7HYPg7FfkgiGgUF7v7KdwH43Vf/h33PPp11BrvHy3u/+QMAXvrlzziy7cWs+96SUr0AMtR5nIFjR/QChdlixZKOZwRY3NxC8eJqTBabXsCYvhvjovd8CDWVyhQwLFZs08bY3vON77/uq8VXfOzTr3lPMRhet4BhMBhxF0h821wVi2hLuC22HEBbtOnIzSW3tAw1lWL7b39JSXUtZUvrScTjPPaNL1G7bgO1a9YTnZzkR5/5OC2XX03jORcwGRjj6+9+G+fdeQ/NF17KZDDAg39/Lxfc/QFWnHcRkdA4f/zuN7j4no+Q5ysnmYjT0bZTX6ppttlwF5XoUaaeohI23HArnkLt//Wiyiqu/pt/IL+8AoDyhuW8++vfI8elfV9Y3Lya93z9e/rHVl7fSHl9piPj5QUKb3FJVleFzeHENm0nhhBCiDnmDSNovS+LoF0NzsLXe49zgppSSY5EUKxGjC4LaiLFxEt9WPwuLOUuJgJRen60l/Z8M4/FInQcG+ML42YeJcLvDQk2F7r477iNQ2vKKd/sp0JVGPjCdvKqi7AvKyQxHGbUMr87YEB2gJwSqqoycPQwI73djPZ0Mdrbk15I2kM8kkmCWX7eRVx49wdQUyme/+mDVK9eq8fUJRIJurq6OHr0KEeOHEFRFO644w4AHnvsMWw2G4sXL8bn8+mvkgsxG6ipFJOhEM88+wxlpSX4iopIGc185etf55ILLyTfYiAaiRANh1FSKRKxKEs2bMaVV0DPgX20P/1EuoMipndKXPjuD+ItLqHtqSd49sff18c7EjEtRvqa//xPjtHHzl8+QvJPh15xpp03uFhavpySbZOMPt2Kohi0IkK6EHHH/3wTk9nM9t88wuHtL+nFCZPFitlm47w73gPAkR0vMdbbky4+aH/ekmOncsVKAIJDAyTjcUxWK+Z0EUPSEcSbEZ2cJJVKkuPURq56DuzFaDLrPyN2PfE7ctxuatdqRYUn7vsq+eV+Vl68BYAf/u3HqFjexKab3g7A/77jBhrPuYBzbn8XAF+87RqaL76cs267A1VV+cItV7L2yuvYdNPbUVMpvv2hd9Fy+TU0X3QZyUSc33zp89SfdS7Vq9eRiMfZ9qufU9m0iuKqGhLxOF3tu8ivWIQrr4BUKkkkFMJqd2Qt6xRCCCHelHkUQZuKJiCpYrBrLwKE9wxjcJqxVmhF/tFHDmFd5MbeXKSlDn5+K/bVxbjPrUBNqXR/+hlc51XgOq+CQ31B7F/axV/KbHw7FeFY3zhfU+08QJS9uWZayjxcO2HA01xI3apSrChEjwYwlzgwui2o6bEXxTA7P1dvhcTgnmaqqvLld95ALBwGRcFdUETeG8TJplIpDOnM+6eeeopnn32WeDyOoiiUlpZSXV3NueeeK0+kxJsyNbueSiUZHxrSiwfxWGYMw1NUQiQUYt+zT6d/P6oXIurO2ETZ0npGerp56v++qS3JnNozEY1y1tvv5HhgAsITtH7/m6hAqLYZy0gf1uE+rv6bf6CsYQWdu3bwyOc/+4rz3fAP/4q/fjn7n3+GP37363qBYWoU48J3f4g8XxnHd7ey60+PE0iFGE0EGIwN0xsbYHtpHzFzityQhSWqn4q8ShblVVFTWEdVfg1Ffm35YSIeR1HAYDTJ15I4qaKTE8QjET3Gt//IIaKTE5kkj2efJjo5SdMFlwDw3MMPEI9GOes2rbD9y//+V1AUtnzkkwD84FMfwe52c82n/gmA733iA7gLi7jq3s8AcP/H7iGvrJwrPqp19fzkc5+heHE1m295B6BFpRYtrmL5ORcC0Pr7X5Nf7sffoC0W7trThqugAE+R1hkRmQhhseVkpYMIIYQQp90bRdAW1GW6OspWQ3HjaY+gVZMqilF7HBnrDoGqYinXXrAIPdeDYjbgWKP9fB1+YC9GrxXvZdq4dO+/vYh1sYe8G5do1//yAta6XPKuqwOg7wvbyGnIx3NhJQCjPz+ItdpLqNJFa+cYo1v7+Mt4mMcHg4SiCfJQUK1GGiu8NJV7afZ7afJ7KXQt7DRPWYJ6mimKwhUf/VvsXi/ektJXjZNVVZXh4WG9w+PYsWPcc889uFwu8vLyWLlyJYsXL6ayspKcnJwZ+CjEqZZKJvWkDcVg0GMLew7sJRYOZwoMsSiewhIqGrUnLn/+4f36n5vaI7F45WpWnHcx8ViUBz71ERLxmF68iEejrL3qOjbecBvhYJD7PnDnK86y+ZZ3sPbK6wiHgvzhO1/Tf99gNGGyWChYVJneFaEyGQxitloZtznBbsLvyiHH6ebIjt0U5uWy/rqbMVmsKCYztpwcTBYLhZWLsVqtlC9r5NZ/+cK04sZUl4X2NbJk/SaWrN+k//3hRJh9I/v49dAf2X1oN+1D7XQ4O/T7Fa4KGgqa+FD+rSwvXM7SvKXkmF7760UWc4op0clJJoNj5JZoS6uHuzoY7u6kbt1GAI62bqP34D42XH8roBUQOvfs1gsUT33vPo7vbuX2//wyoHVg9B7az11fug+AFx/9KUPHj/LOdBLI/uf/TGCgXy+ATAYCWR2BxdW1Wedbc8W1mCyZ/18vvucjmKb9LLn1X7+AyZS5f93f/nPWn5/qWprSfNFlWdfTR0YAGQkRQghx+qVSMHJkRiNok4EoqXACc4k2UhzeO0xqPI5jrVbACDx+nFQoRu7V2s/pwe+0ocaSFL1He4Fj7JeHUQwKhXdrj9Mndw5icJj1AojBada7PQDcFyzC6MoUbAretRxDTuYpeclHVhOOJXnx6AitnaO0TgZp/XUHPYEIACaDwtJSF1et9NHsz6XZ76WqwIFhHnZxnCpSADlFFq1ofsXvTb0Kf+zYMX72s58RDAYBbd/BkiVLSCS0ZYwrVqzQ4z/F6ReLhImFw/oiy0QshmIw6K3nx1q3ERweyooLdXi8+hOMp3/wHcb6evQiRSIWo2hxNRfe/QFAe+V2tLdbSz1Iq1mznis//rcA/Pw//pnIeDDrTPWbz9ELIDsf/y0oZLokLFbC41rV2GgykecrzxrvMFmslC1tAMDqcHLhez6oj3dMvY03/Sqwp7CY937zB/qfm/5q8NatW+no6OC2f/2Cds6f/5xYLMZlN94IwJ11S/Uuptdiczopcda+6r14Ks7B0YNZS0oPjx0mqWqfpyJ7EY35jVxVcxUNBQ005DfgsXpe9+8T80csEmZ8aAhPcQkms5nAQB89+/dSs2Y9ZpuNngP7OPCXP7Ph+lux5Ng5+OJzbP/to1z9N/+AxZbD9t/+kmd//D3e+80HMFksbP/NIzz38AN85IePYDAa2ffs07zw84f5yI8eQVEUOvfsZtfjv9ULIPFYlMhESD9P8eLqrPGO5edeRPXqtfr1ppveRiqR+Rrf8pFPoUz7+jj/rnuyPr6pSNQp0wuBgL5od8qrFdaFEEKIWe1EImjXvSczynICEbSpWJJUKI4pT0sLjHWHiPdO4GjR9kpN7BggemiMvOu1x8pjvz1KZM8wJR/TmgMCvz9G9EiA0k9qP8Mndw4S6xzXCyBqIoUaS+l/n72pEDWZufZeUa13gwAUvmdFVpdx7pU1Wed1rC7Oujbm53BoMETrvn5aO7UI2v2vkcrS7PfSWObBZpZuzbdCCiCnUDgc5tixY3qXx/r161m9ejVer5eysjI2b95MVVUVeXl50o7/GlRVJZlIkIhGsTocKIrC+MgQoeHhTAEiFiUZi7Fs8zmAtqeh9+B+vTtiak/Exe/9MADPPvQDjmx7KWsExOZwcsf/fAOAX/3Pv3N0R/boVW5pmX7/hV88TNfetqz7pbVL9ALIWF8vgf6+dHHBit1jz0oJWLbpbGKRcLoIYcFkteEtKdXvX/mxT6MYjFkjIFZ7ZtHl+7/749f8fBkMxtdddGkym/WW+Ff980Yjdo8XgPb2dl544QVuv/12jEYj4XCYYDBIMpnEaDRy1VVXZf1/+0bFj+lSaopjgWO0DWvRs+1D7ewb2UcspVX8PVYPjfmNnO0/m8b8RhoLGim0z/3lVfPd1EiloigkYjFG+3pwFxRitTuYDIxxtHUbFcubcOUVMNrbzY7f/YqVl2wht8RH78H9PPX9b3PBu95HgX8Rh7e9yK/+59+55bOfp3DRYo5se5Fff+k/ecd/fZX88gq69+3ht1/5b+744jfJLfEx0tPFrj88xqpLr9IWy6qACsl0YbnAv4jl516op+tUt6zDM20xZtOFl7F049n69eabb+fM9DgJwJot12RFnU59v5kyVaCcMtVZMkVGS4QQQiwoUxG0XenOjteIoFV9q1GLV6GULEUxmUiMRYl3j2NzaM+PokcCTO4axHvZYhSzkYmtfYw/2UnxR1ajmAyE/tRF8IkOyj63CcWoEG4fYvzJTuyrilAMCslAlHhP5gUMiy+749G5wYe9ObPkPffq2qyChveSxVlv//ICxsvf3xs9pxsYj9DaocXPtnaOsasrQCiqPVZxWU00+b2896xqGWU5haQAcgokEgm++93v0tPTg6qqmM1mFi1ahNOpfYF4vV5uTL9qPhdNJW9M7X+YGsXwlpRiseUQHBqg79CBrAJEIhZj+XkXYXd7OL6rlb3PPEl86l767a742KdxeHPZ9utHeOHnP9aLE6SfVL3vOw9iczjZ/ptH2frLn73iXHXrN2M0mTiyfSs7H/u1XoAwWSxYpyVtmK02nHl5WXsmptIFAJouuJTq1Wv18QyTxZLVHn7pBz8OKnpKh8lsyXpld6qT47Wsu/qG171fvqzxde+fKkePHuV3v/sdt9xyCx6PB0VR9MKH0+lk8+bNbN68WX/7Ey3aqapK70QvbUNttA1rxY49w3sIxbUfRjmmHJblLeOmpTfRWNBIY34j5a5yKQqeZFNftwpaDK6aSjHYcQy724MzL59kIs7BF5+nsGIx+eV+4pEIW9OLLktrlxAeD/LH736DxnMuYNHyZsaHh3jk859l/XW3UL16LcNdHXzvEx/g0g/cy5L1mxju7uQHn/wQV3z8b6lds57AYD+/++oXuPqT/4Arr4DJYJA9f/4jtes2kFviw2A0YjKb9CKKt7iE5osuw5r+2vMtWcZlH7wXR24eAFWr13LH/3wDdzrmt/Hs82k8+3z9461dt0FPHQGtQDG9SFFUWZXVVeHMzUtHqWrk/z8hhBDiBCUTMLgPureROr6TeEcv5rE/YSBEIlXKpOUKHIs3Y1xXT1RZRWCHjbwblmHKz2FyxwCjX95PycfjmApMRA+OMvrTg5R8Yg2mPBuJ4TDhXYO4z6vAaDZicJgxl7tQkykUkwHbsnyMXivaKx8Kzo1lONeVQvrHuPtsP+6z/fpR7U2F2JsyL6pN7e6YYrCevBcswrEku7sD7OzMFDy6x7TxVxllmTmzsgCiKMoWYEtNTc0bvu1sZDKZyDW6WNx8BrXNSykrK4NgAoP91H261VQKVVUxGI0kE3ECA/36eEYivdCywF+Jp6iYibFR9v75yayUjUQsyvJzLqSkpo7+I4d4+gffyYyApN/mkvd9lIrGJg69+DyP/ve/vOIMN/7Tv1O+tIGuPW389iv//Yr7lc2rsbs9jI8M0dG+S9v9MC1NQ01pr8zm+cqoO2NTOklDG8UwW616u3nj2efjb1iOyZy9KHOqA+Hcd9zNeXe85zWfwKy98jp4Wbv5dNPb2F+NK6/gde/PdlOjWAMDAzz88MNccsklVFVVkZOTg8PhIBKJ4PF4qK+vp76+/q9+/8PhYX2EZWqcZSQyAoDJYGJJ7hIuq7qMhvwGGgsaqfJUYTQs3FfHp/57AIRGhkFR9CfiXXvbMNty9EjP3U8+his3n8rm1QD86Yf3U1hRybJNZwPwi//8ZxatWKnH7n77Q++i4czzOOPamwD40tuu5Yxrb2bjDbeSSqX4/t98kI033MYZ195EKpnk11/8Dzbf8g7yy/0kkwmee/gBrA4HpbVLUFWVvkMHqEp/fRjNZhzeXExmbY7V7vHSsuUacku1zgdvcQlbPvJJSqu1ltPCisXc9b/34fBqH1vZkmW8/zuZbqbiqhqu/0zm+0p+eYW+IBTAXVCUFcMrUaZCCCHEyacmVZJjEQx2M4YcE6nJOJO7hrDWeDEX5JAYDhN4ZA/Oqh6ssReIHeplsONG8s2fw2ZsJWZcz9DE31LQshHb8hoS0aUEf9iJdeMKjJUeOB5E2X1MTyCxlDlxX1yJYtMeC9qW5VH0gZUY3drjC8eaEn2fBkDOsnxyluXr15YyJ5ayzOMBo2Nm9r2lUiqHB0PsmCp2vGyUpcybQ3OFl3durJRRlhkmKTCnSPc/Po99ZQGOi8pJRKOMfL4Na3MehdfWo6oqXf/8LIlqA9HFCRKRKDk7jFjrvZRfsop4NEbbVx5h3BwkpIyRiEaxhC1UrFtJ/QXnMRkY40efuTd7BCQe56zb7qBlyzWM9HTx3Y+85xVnOv+ue2i64FL6jxziB5/6MACKwaAvozz/rnuoXbuB/qOHefL+b2R1QJgsFlZdcgVFlVWM9nZz8MXn9d+f2idRtqwBu9tDJBQiNDKUtWPCbLVK8sYMmRpZmZyc5Dvf+Q7r1q1jzZo1RCIRfvKTn7Bp0yYqKyvf1PsOxULsGd6jj7K0DbXRO9ELgIJClaeKhgKt0LG8YDl1uXVYjKd3U/dbEY9GSMRieofQaG83sXBY3wfT0baLaHiC2jXrAWh76gnikbAeRfrcww+QSib1KNLffPm/MJpMXPSeDwFaVGmO283Vf/MPAPzfx99HbmmZPsb0nQ+/m6LF1Vz+oU8AcN8H7qRsST2XvP9jgLZPprJ5NWe/TVts+7N/+0cqV6xk1aVXAtpiTn/DCn2fxEu//BmlNXV6l9HBF58jv3wReb4yVFVlpLsLhzcXm9OJqqqoagrDAi5OCSGEEHONqqr6zgqD1YiaVInsHcZUmIO52EEqliTw6yPkNBRgq8slORFn4CutuM+rwLG6mMRohL5/f4nca2txrCkh0TNA35f2k7viEA5+T6Kjg6HAPXhN92GztJMo2EQocRWOJhfmhiZSORVEO8exlLswOsyoSW0mVTGe+Kj0XDB9lGVn1xi7OgOMv2yUpdkvqSwzRVJgZsDjff/HxI9HifxwAoBFjnoK82o4i3pQ4Uh/K71HD9M9eRCjYuIC3+2MKYOUX7IKYkkKB0oYmDxCj3qAHIubs8zXMNGpbf9VonCB41Z6KrqYyAthM9gp6i4hx6nNpNmtbq666F7URSZM+TZMigVDQMG9RNszUeCv5H3ffhCzzZa1xG9K8eJqbvqn/3jNjy23tOwVC/umszmd2JzyyuxMicfjmM1mVFXlG9/4BosWLeKSSy4hJycHn8+H2609mbfZbNx2220n/H6jySj7RvbpOzvahts4FjiGSrqy7SxjReEKbll6Cw0FDdTn1+MwO97gvf71kokEBqMRRVEIh8aZGBkm378IRVEY6eliqPO4nuTRtaeNnoP79P9f9z//ZzradnLBu94PwLZf/4Jju3ZwbTpq9KnvfYujrdt5539rSThPfOsrdO3bw7u+/G0Anv3xDxg4dkTfB9P6+18x2tutF0AOvvgc4fGgXgAJjQzrOygAPIVFGIyZr7n6M8/FbLPp1xtvejvWaalPl3/4b7DYMte3/esXMVkyBaR3/NdXsz4313zyH7OuX75oc/oOC4DatZkREUVRyC/3Z10rihQ/hBBCiJmgplSU9DhErHMcxWLAXKw9rgo+2Ym5KIecBq0refCbu7Aty8O1uRyAnn96DtdZfjwXVYKiRbG6zq3Ac4FD25PRNpxOPcnFYDFiqXBpySSJKMZAG7mrerAe/AX85SmMQ0cotXox7A9CYRWmJaspKQtD2X9DcSMmkwXvtHMbgJwl00ZKjQr6PMocFY4laesJZO3uePkoyxXNPpr9XlZWeKkqcMooyywmBZBTZNlF55JKJqclcVjIK9W+KSkGhZoPnsdS88VZeyjM6Sc+JqcN39+fgc+4QavcxpNEDo5RUqztsbA4HLg3V1CyfDUWv4vESISRB/fhLqsAwBAxYD1gIH/dUnIa8ol2BBn80U6MRT4ohkT3BENf30XBnY0Ya3OJdY4z9uhhvFfXYPE5ifdPMLGtH+eGMkxeK8lAlFhXCGu1B4PNRCqWhEQKxWbSvzGLmRMOh/Wo5AceeABVVbnttttQFIW6ujry87U2QUVRuOaaa17vXekSqQSHxw5n7e04OHqQhJpeKJlTQGN+I5cuvpTGgkYa8hvIteWSTMQJB4PYXG5MZjPh8SCDx49SXFWL1W5nrL+PYzu3s2TDZnKcLvqPHGLPn/7IumtuxO72cGzXDrb9+hdc8r6PYnd72Pvs0zz74Pe45XP/jd3tYduvH+Gp731L3wez+w+/588/vJ8Pfu8nmK02Djz/DM8+9AM+/MAvMJpMHG9r5S8/+zFrrrgWRVEY7e2hs32X/nEaTKasaNzi6jqM06JFl515Lv7GJv167VXXE49E9Ovz7nwv07vorrr3M1ldThe++4NZn9eNN74t6/rl0aQ1Leuyrl+e/CGFRSGEEGLuSYxFURMpzAXa47XJXYOggH25toti7NHDKDkmPBcsAqD/f7ZjKraTf/NSAIZ/uBdrpYe8G5cAMPFCL7aleXoBxOAwo1i0Fy0URcFzWZU+FqIYFIo+uEofKVGMBnyfOUOLoB06hNK9jXz3Vnh6G/x4N0oyhgPAWQxlLShNN2M8RRG0s5GMssx/MgIzT2nxTAqKUSEVSRDrDmEucWB0mEmMRJjcMYB9VRGmXBuxrnECvz+Gd0s15iI74b3DjPxwH4X3NGMpdTDZOsDIg/sp/uhqzEV2Jrb3M/rQAUo+3oKpIIfJXYMEnzhO4btWYHRZiBwaJbxrCM+lizHYTMT7Joj1hLCvKEQxGUhOxFGjSYxeqxRQ/kqqqhIKhXC5tIVNv/zlLzl8+DAf/vCHAdi2bRuqqtLS0qK/fSIeQ1EMmMxmkok4w12dOPPysbs9xCJhjmx7iWSJg2NKH20d2xl6fhc7PJ30OyZwThpZe7CQ5GofNUtXUpMoZfCnT3PBO++hfFkj3fv28NN/+Xuu/pu/x9+wgmO7dvDTz31G3wdzZMdL/Pzf/olbPvdflNYs4eCLz/Hof/0Lb/v3L1FUWcWBvzzDY9/4X2753H+R5yvn8LYX+ctPf8QVH/tbXPkFdLTtpO2pJzjn9neR43LTe2g/x3fuYPVlV2G22Rju7mS48zjVLeswmsyERkcIjwcpKK9AMRhIxOOAFg8s41dCCCGEeDNSsSRqJKkXEaLHg6TGY+Q0agWI0PM9JMeieNKJISMP7Sc5HqPwzuWA1qGhJlWK3qu9qDLwjZ2AQtG7teXcIz/ej8Fhxnu59sLH+DPdGF1m7E1F+t9nsJswF2ovhk7vDjlh0yNou7ZCz/ZXRtCWrfqrImjng8HxaLqrY1RLZXmNUZapX2WUZW54vREYKYCIN5QKJ0gMhzEXO1DMBuIDk0QOjOJYU4LBaiRycJSJF3rJvb4Og9VE6MVego8dp+TeNRisRoJPdhD8/XHK/nkjitlA8InjWXFVwT92MPFiHyV/swZFUZjY2k/0yBh5N2hV7sihMZIjET2POzEc1qro6TbA6Usk54rpZw4ODWIym/X42Y62nTi8ueSXV6CqKs8+8jMW1dXhr1/O008/zVNPPsmNF1/A0jM2sm/fPp566AE2nXU2jWedRywS5v6P3sPaK6+j+aLLCI8H+epdt3DOO97Nqku2MD4yzDffezvlV59LX52RfUdbqXlokGeWD3HIP0FB2MHlTxaQvHQJ9ZvPYVGikBe/ch/nvfM9VDavZrSvh6f+71ucce1NlNYsITDQz47f/ZIV519Mnq+c0MgwR7a/RNXqtThz8wiPBxnqPE5RZTVWu514LEpscpIcl1tiQYUQQghx2qjxFIpZ20ORGA4THwyTs1Qb1QjvGyF6JID3Uq2AEXyqk8ieYYruaQZg5CcHiOwfxfe3WqfmyEP7iR4OUPopbTH46COHSAyF9YJH6LkeUpEE7nO17uzI4TEAbNVeQHtsrZgNKKZTtBcjNgE9rZmCx8sjaIvrtSJH2Wooa4HCJbAAdn693iiL0aCwtMSl7+2QUZa5TXaAiLfEkGPKiogyF9kxF2ViZW21udhqc/Vr59pSnGtLM9cbfOQsL9R/6NgaCjDm2vSMbXORHdvSPL0gkByPER8M639+snVAK7ikCyDBP3QQPRKg9JPpHzoPHSDeN0Hxh1YBEHj8OKlQjNyrawGY2DEAiZS+QTrWNQ4GRc/tVuNJMBr0Sno8EiGZSOjjBsNdnaRSSQorKgE42roNBfQkjtbfa5G7UxGcT33vW9g9ufreiZ//+z+RV+bXEy2+/aF3Uba0gYvf+2EAHvj0R6hpOYML7n4/qqry8y/9F0vXnsFFd93D7t27eaJ1Ny1DA/jrl1NXV8fWXzzEcFcHsJElS5awIx7R2hgBk9lCxfImPEXaPphJJYb/srN5Xmnnu394jD0DbdhWTTAy+j0ibQp1nhom3t7ILf4mVpSv0hJZ7jZkLb5c/sXMWEZuiU9f2AngKSrm7LfflflvnZfPivMv1q9zXG789cv1a3M6+UcIIYQQ4s1KTcaJD4Wx+JwoJgOxnhCRvSM4N5dhsBgJtw0x/kw3BXc0YrAYCT7VSfB3x/QX4yZ3DKRfjNuIYjQQ6xxnclsfnosrUQwKRqcZU15mR5djVRHWxR792nNxJdNfQ869Mju50rnBl3U9VfiYYsg5iU/BpkXQ0r1VK3YM7AFVe2yIt0Lr6lj3bq3gUboCLCd/R9tsk0qpHBkKsWNasWNf36uPsjT5vTT6PORY5n8RSEgBRJwGBqsJgzXzv5ql1IGlNPONN6exQG8hBHCf48d9TmYZY+5VNSQmo/q1aaWHRHmmGhvPTxBOZvYyBLp7iI5OkotWABl4fA+JSIzadAGk4/6/EI9FWfb/tKjQg//8GNF4mOX/qu3HaP/cLwnHg6z/Ny1ZY983HiOSmuC8z2n7HA785CkSxpheADn45+ewuHL0AkhwaJBUuiAB4Cku0WNNAVacd7FeoFBVldXX30ZuoXbd3d3NqK+K/IaVAFRWVnLh+efR0KCldpSWlvKxL3xFf1+KonDzP/8nAJPxSfYM76H/zFz+MPRj2n76GbpCXdob9kOlu5K15WfQ2Kzt7FiatxSbKfPDXQghhBDidFATKZLBGAanGYPFSDIQJbxvhJz6fIwuC7Guccaf7sJzcSWm/BzC7cOMPLSfovc1a+Pa+0YYfegAxR9vwVyQQ7wnRPDx49hXFmHIS+/CMCio8RRYjFgXe3BfVAnpxe32lhJsS/P0EQ/PBYv0/RsAjpYSHC2Z6FVrlZfpL98Y3TP0Yo6qQqAzu7OjZwfEJ7X7Nq9W5Fh6mfarbxU4C2fmrKfZG42yrPB7eM9ZVTT7c2nyeyhyyWPghUoKIOItS8RihENB7G4vRpOJibFRhrs68NUtw2SxMNzVSeee3TScdS5mq42uvW0cfOE5Nt1yO2aLlQMvPMvuPz7GVff+HUaTmdbf/5qtv/oZd37xWygGA8/+5AFefORhPvqjRwHY8cJvaH3s13xow08BaO96hj1P/5H336IlWhxI7ODAnmep5TwAjhcfonf/Pmq5EIDA4nHGBwdYlj5/qtZMKhLTPx6v34fLXKRfL3LXo+RnvlQabRswV2U6YjbatpBTm8kjX2e8mJxFmYLOSte5WCu0DhlVVSl0LMPs0jpoJicn+c2zf+GczWdTi1bg2LJlC7W1WvHG7XazYdPmV3zOY8kYB0YP6NGz7cPtHAkcIZWu9pc6SmksaOS6uutoLGikPr8el8X1ivcjhBBCCPHXUlVVGylRFBSzgVQsSfTgGOZSB6Y8G8lglOAfO3G0FGMpdxHvm2D4+3vwXlWDrTaXWNc4g1/fRcEdjdjqckkMhxn7+SFM+TkYXRbURIp4/wSpaBIAY54NR0uxvujTWu0l/x0NWnIJYG8uwt5cpI+UvPzFNesiN9ZFbv3a5LWCdw50pIZHtQJH17ZM0WNiQLtntGrdHKvenhlnyataEHs7pkZZdnaOactKO145yiKpLOK1SAFkHppafGkwGDCazMRjUUa6u/AUFmNzOgmPBzm+awflyxpx5uUTHByg7aknqD/zXLzFJQx1HOOFXzzM+utuJs9XTte+dp68/5tc8r6PUuBfxOFtL/DrL/4nN3/28xRWVHLwxef4zf9+nnd+4evk+co5tnM7v/vqF7jrf+/DU1RC9/52/vDtr1K9ei1mq43hrk7annqCddfciNliJRGLEQmNk0wkMJrMOPPyKVtSTyqVxGgwsGh5EyazGTWVQjEYWLbpbEpr6vSPt+Xya1hx7kX69dlvv4uzb39X5vr2u7I+P6tvzU5CWfq287OuK+/emHVdfu/6rOuidzdlzWx6Ll6MKS/zQ9Rc5sToten/LboPdWAyBVi6vAA1meLBP/2cxcUV3NhQSY7ZxnmxRqriWgeIElcp+VUMwyUTsNZNKpxg+KF9jC9X2OU+yP7evXjaDfzW+BRHLF1YUmaaUsuo9Pm5YMUFNOY3six/GYX2hVHtF0IIIcSbN7WTTE2pxDrHMbosmPJsqIkU4091Yq3yYK3ykookGPpuO871pdibi0iNx+n9lxfwXlWD84xSUpNxhr+/h9xrajGtLUFNqIR3DWKt9mIpd6HkmDCXuzDYtKcepkI7udfVYppKOPS7KfnUWoxOLYnNWumh5KOZ8X1LqQPLlmr92uSxYvJkHnudsl0ap1MiCn1t07o7tsLwocz9gjqoOV9bVFq2GoobwWSZufOeJic0yuL38o4NlTRXyCiLeGNSADmN9B8yqsr40CBmm40cl5tUKknH7p14iorJLS0jmYiz8/Hf4atbSkl1LbFImD//8H5q126konEF4fEgv/rif7Dqki1Ur15HcGiQB//+E5z1tjtYsn4zIz1d3P/R93LZB+9l6cazGOvt4Qef/BBbPvop6tZtJDg4wK+/9J9c9YnP4MzLJzQ6zPM/+SG+2iV4i0uIR6P0HT5AdGIC0PY2OHPzUAzaDxdPYTErzr8Ym0PbkVFas4QL7n4/OW5tNrKyaRU3/MO/YvdqXQ9LN55F9ep15Li1ynvTBZfQdMEl+uelfvM51G8+R7+uWXMGNWvO0K/9DSvwN6zQr4sqq7LiQd0FhUDmCb/Jcmp/GExt4J7iaCnOuo5v9tA/MswyilAUhRcLj5McSLKUFhSjgeuvv57cfG0kRjEorL7xLMwl6a3eqkqqPocd8d288NIDHO85wg1Hz+QHwV/znLuV2mQlXzr2CQrWFuNaVUqDWgff6CJvzVLsKwqJ9YQY+OwOwm8zkLMsn3j/BGOPHMZzyWI9Mnliax+OlhLtFZpQjHjPBJYK7UGJmkhp7ZUmw5xbLCuEEEIsZInRCCiK1t0ATGzrx+i26HvaRh7ch6XSjfMMbT9Fzz8/j72lBO8li0GBwW/sxHWWH89FlWBQCP6hA7eyCGuVV1vYaVQg/Sq6wW7CfXElFr/WXWp0WSj6wEpMudrfbcqz4fv7zAtIJo9Vj3QFMDrMWSMmitmQVdCY91IpGDmS3tmRLnj07YZkuiM5HUFL083a/g7fSrB5Xv99zhPTR1l2dgbY2TXGeERGWcTJIykwp8iP/v4TVK1sYd3VNwDwlTtuovHcCznrtjtQVZUv3Hwla6+6nk03vY1UKskXbr6S9dfdwobrbyERj/PF265m001vZ93VNxALT/KtD9zFphvfRtMFlxCZCPGzf/tH1my5htq1G4iEQjz1/ftoPPt8ypc1EpkIseuJ31G9ei355RVEJyfpaN9JaXUdzrx84rEowYEBXAUFWGw5qKkUKmrW4ktx4oaGhjh27JgePfvII4+wd+9ePvGJT2AwGOjt7SUnJwev1/uKPzs4OaiNsQy30T7UTvtwO2PRMQAsBgtL85bSUNBAY0EjjfmNLHIvQomrKAaD1nIaSRA9HsRS6sTotpAYizLxl17sq4swF9qJ9YQYe/Qw3sursJS7iBwcZeg7bRS+pwnrIjfhPcMMf28PRe9vxlLuItw2xPAP9lL0wZVYfE7C+0cIPnac/FuXYcqzET0eJLxrENe5FRgdZuJDYeK9IXKW5qGYjaQiCdR4Ssujl1ZDIYQQ4oSlYknUeAqjQ+uCiBweg5SqFzCCf+xAMRlwnVkOwOB32jC6LORdr3XF9n1+K+Yyp15o6P33F7FWesi7UUvVG7xvN9ZqD+5ztGSSwOPHsZQ7yVmmjfFGDo5iys/Rl3+qSVVfWC/eoqkI2q50wePlEbRlqzKdHWUt4PYtiFGWSDxJW3eA1tcZZZmKn13p91JdKKMs4sRIDO4M+N1Xv4BvST0rztNGM557+AFKauqoWrkGgPan/0CBfxHFVdrW6O79e3EXFuLKK0BVVSKhcSw5ORhN5hn7GMSrGx0dpb29nXXr1mE2m3n22Wd5/PHHuffee3E4HIyOjmI0GnG73Vl/LhgL6kWOqd0d/ZP9ABgUA9XeahrzG2ksaKShoIE6bx1m48n/76+mWwYVg6JtUR+YxFzqxGA1Eh+YJLxnGOfaEgx2M5FDY4T+3EXu9XUYnRYmtvUz9uhhSj7egtFlYfyZbgK/OkLpZ87A6DAz/qcuAr85iu8f12OwmQg910PouR6KP7wKxWRgcvcgkX2j5F5bi2JQiB4PkhgM6100yUAUNZHClJ9z0j9uIYQQ4lRTkykUo9YxGx+YJDke0xNAJncOkBiN4j5bW/Q+9psjJEci5N9WD8Dgt3eTiiQpfl+zdv2tXagJlaL3NgEw9L09GCwG8m7SChzBJ45jyDHh3FgGQHjvMAa7Wd91kQzFMFhNegqfOE1eEUG7TVtcCi+LoG3Rfl0gEbQvH2XZ2TXGvt5xEi8bZWn2e2WURbxlc64AoijKFmBLTU3Nuw4ePDjTxxEL3Pj4ODt27GDFihV4vV727dvHgw8+yF133UV5eTkTExOkUilcrsyS0XAizL6RfVlLSo8Hj+v3K1wVWmdHuuCxNG8pdrP91f76WS0VTpAYi2IutqMYFGI9IWLHgzjWlaIYFMLtQ0zuHiLvxiUoisL4n7qYeLGPko9r34/GfnmYia39lP2TtsB29BeHCO8a1NtmRx85ROxogOIPa4k743/qIjEc1iOOw21DpCJJvYAS70+PbRVrKUNqSpVOFCGEWCBUVYUUYNBS0tREilQkgcGudSWmwgmS4zFM+TkoRoVkMEZiJIzF70YxKiSGw8T7J7EtyUMxKsT7Joh1hbCvKtKL9rFjAVxnaQWM0Iu9RNqHKXinltQ29uhhJncO4vuMNsY7+tODhPeN4PtbLU5+5OEDxDrHKfmo9jMt+FQnyUBUj1AN7xlGTaSwr9DGehMjERSjgnEhjYbMNXoE7dZMKktWBO2izILS8hYoWQGWufd4780YCkVpnba349VGWbSCh4yyiJPv9Qogs3IHiKqqvwR+2dLS8q43fGMhTrJIJMILL7xAVVUVfr+faDTKH//4R/Ly8vB6vVRXV/Pxj38cp1PbgWLJsXBo9BC79+/WuzsOjx0mqWqby4vsRTTmN3Jl9ZU0FDTQkN+Axzo/5jgNOSYs07LsLT4nFp9Tv85pKCCnIbOF3XVmud66C+C+sBLn5sy1Y00Jthqvfm2tcGOY9v5Tk3GSwUxiz8S2fpJjUb0AMvbro6Qm4xS/X4sRHvpOG2pSpejd2g6Z0V8cQjEZ8F6u7ZAJPduNYjfjWKml/kSPjKHYTPrHkIok0nPP8uqZEGJ+UFUV1HREqKqSmtS+zxksRtSUSmIkgtFuwmA3oyZTxLpCmHKtGN1W1HiKyOExzEV2THk2UtEk4fYhrBVuTAU5pCbjTGwfwFaXi7nITnI8Ruj5HuxNhZiLHSTGIow/1YXzjFLMJQ7ig5MEn+jAdVY5Fp+TWO8Egd8c0fZW+ZxEO4KMPXKY3GtrsficRA6NMvrTgxTc3oC5xEF4zzAjP95P0T1NmIsdhHcOMvLgfoo/thpzoZ3J1gFGf3KQkk+swZRnY3LXIGM/P0Tpp9didFuZ3D1I4JeZLsZw+7DexagYTYT3DhP8/XHszYVgUIgcGGX8Dx04N5VroyEpLQllasebtS4Xgzuzh8x5ZhmOdZk9F7nX1Wbt15rqBJmSU5+fdT01iiJmiZdH0HZtg95WiaDllaMsOzvH6BrNjLIsKXaxpcknoyxiVpiVBRAhTqdUKsWf/vQnCgsLaWhowGg08uc//xmTyYTf7yc/P18fb0mpKTonO2kfaqetXdvdsX9kP9FkFAC3xU1jQSNnlZ+l7e0oaKTIXvQGJ1i4DFYjBmumvdFS5oSyTAHFvjL7c+e5eHHWdf5t9aiJZOb+RZXaItepP99cqL0amPWXZv51YscARo9VL4CM/uwQZp+D/Fu0kOT+L+3AWuHS240Hv7ULa5UX93na/PTYb45g8buwL9ce4EzuHMRUmKMXUBKjEQx2c9bHKISY/aae0AJaDGcyhcGujSQmgzFtVC/95DQ+OAlJFXOJ1nkW6xxHTan6GELkwCgo6HscJncOopgUvTgc+ksvBpsRe7P2fSj4xw6MLguONdoT57FfHsZUkINzvba4cuTH+zH7nLg2a2MPg9/ejbXaqz+Z7v/idnIaC/TvUz2fewHH2hI8FywCoPvTz+A6x4/nwkpIqfT+819wX7AI93kVqIkU/Z/fiueSSlxn+VGjSQa/thPP5VW4NpWRiiQYvr8d75XVONf7SIXjjD50gNxra9MFkASBXx3BcOMSzEV2UpNxxv/YibnEgbnYQSqcJLxrENuyPMwlDtR4inh3CDX9qjApFTWahKlRTZMBo8ui76Ew2M1YKz36SIcxV4tGnSqUm0scuC9YpP+3slS48V5ZjcGu3bdVe8m7eQlKOokkpz4fc6Fd/x5tX1mEtcqDYtaunetKsTcV6Ys/3WeX4z7Hr5/HeYZPXygKkLM0j5ylefr1y5emy3LxOSY8qnV0dG9/gwjaFm1/xwKJoNVGWSb0RaWtna8+ynL7ekllEbPTrByBmTKXd4CI2e3ZZ59FURQ2bNBGL7785S9TXV3NJZdo6TTRaBSLxULvRG/WktI9w3sIxUMA5JhyWJa3TC90NOY3Uu4qlwc4c8z0MZl43wQYFf1Ba+jFXoxuq/6AduThA1j8Tv0Bb+9/vIS9qVArvKgq3X/3LK5NZXguWYyaUun+28wTDTWp0vfvL+I6x49zvQ81kWLkof3YVxeTsyQPNZFi4qU+rFUezMUO1GSKeP8kpjybHhsoxGwx9dhBURTUZAo1mkSxmlCMCqlYkmQwhslrRTEZSE7ESQyHsZQ6UMxGkoEosb4JbOknmomhMNHOceyN+ShmI7GeENGjAZxrS1HMBqLHg0QOjGpPPE0GIgdGCe8dxrulGsWgMLl7iHD7EPnpQuXE1j7C7cMU3N4AwPgz3UT2DFN4t9YJFnj8OJH9I3qn2NgvDxM5OKaPJYw8tJ/osSCln9B2dg3/cC/x3glKPqZ10g59bw/JkbA+mjf03TaSE5nOs8H7dqPGkhTd0wzAwNd3ohgU/e8f+EorSo6Jwju0sYn+L23H6LHq5x34aiumQru+2HLwvt2YSxx659rQ/7Vj8btwn6sVOIYf3Id1kVsvkIz+7CCWSjeOVVOdcUewLvbo3QXBP3RgqXRjq/aiqiqh53qwVrix+F2oKZXwzkHMPof+fSh6aAxTkR1Trk37vtQzgTHXitFpQU2qJMciGJxmDFYTakpFjSRQrEYUoyHr/xMhZrWsCNr0OMvLI2inCh0LKIIWXn+UxWk1saLck7W7Q0ZZxGww50ZghDjZtm7dSn9/P5dddhkAnZ2dGAyZVoD3vOc9BBNB/tT1J627Y1jb3TESGQHAZDBRl1vHZVWX0ZCvpbJUeaowLoClVfPd9B0hU6/gTnGuLc26nnpCMmXqCdKUko+sRpnW7ZF7bZ0ecUwqhbUuF2Nuert+LEm8Z4LUkrh2eyLO2COH8V5dg7nYQTIQY+BLO8i9rhZHSwmJoTD9/6td25cXkhiJMPbIIVznVmBd5CYZjDGxrR/7igJM+TmkwgnifROYSx1axPG05bfi9MjqIogkwKBgSL8KlhiJoFiNetpDrGscg8uCyWNFTanak858G6b8HNRkivDuIcyl6Selca1YZql0Y/E5SUWThP7chW1pHpZyF6nJOMEnOshpLsRa4SY5HiPwm6M41pVgrfSQGI0w9otDuM7xY630EB+cZPShA3guXYx1sYdYd4iRH+0j95parFUeoscCDH9vD/lvr8da6dHSpL7dRuF7tTSpyP7RrDSpyP5RRh7YS9GHVmEpdRA9OJo1lhA5NMbowwfSYwlGIofHGPv5IWxVazF6jMSOBgj88gj25iKMZgOxjiDjf+jAtbkMxWQg3j9BeOcg3suqwKCQDEaJp7suFIOCGk+Rmkzo/x0UiwFl2iidKc+mdZulWfwulGmvTubU52OeNspnX11MaiKuX7s2+UjFMq1l7gsWoSYzLyZ5r6jWWuXT8m5amvWicMGdjVmvEhd9YGVWgWCqcDKl8K7lWddThZIpU4WfKbnX1GZdey+ryrqe6gwBrTDhSi/QBO37w/TOO8VowLYkL+t6KvZUu1ayllYrBgXFnlneLYUPMSulUjByeNooy1YtgjaV/jqfiqBtviU9yrJwIminj7JM/SOjLGK+kQKImJfa2tpobW3l1ltvRVEUxsbGGBgYIJVKYTAYuOzqy9g7spfvtH1HW1I61E7PRA8ACgpVnio2lW3SOzuW5C3BYlwYlX7x5iiKgqkg+4nA1G4SAMVsJO+6TAHFYDfry2ABDC4LpX+3Tm+9NjjM5N+2TH8ipliMOFqK9ScbajxJciIO6SdeieEwwd8fw1LuxJSfQ6w7xNB9uym8eznWKi/RQ2MMfTcTgRw9GiDwu2PkXlerRyaHdw3i3FiG0WUhMRYh3jeJtcqDwWIkFdPa0hWr8ZQ8qVHjKdRkSu92SU7EUWNJTOmCUWIkghpLZsYMeidQowmsldqD0uixAKlokpz0k7Xw3mHUeGaZ4OSOAdRkCkeLNlYQeq4HFPRXzYNPHEcxG3Gdpe2kGXv0MAaHWX+yOPyjfZjybHguqgTSr8qXOvQnl/1f3I51sUd78gv0fO4v5DQUkHuVttyw919fxNFSjHeLdr/vv7fh3OjDe4k21jXwldbMWIKq7a/RxxKSKiMP7sd9cWW6AJJk7NHDeC6vwuJzosaTBJ/owOAwawWQeIqJ7f2Y/S6sFW7URIro8SA5Den9Amr68xvXnsQrBgXFZtTb/A1WI+Yyp/Z7gNFpIaepEEO6WGPKs+E6rwJjeteBucSB5/IqfVGjxe8k98YlmDzafWuVh/x3NGB0a/dtS3IpvKcJo0u7b19RiLXai8GZvl5TQk5zkT7W4NxYhnNTmf7/nWtzOa5pu4NcG8uynsQ71/v0/66gFTKnFzMdq4txrM58bU6NnkzJaSzIvp5WANA+Hm/WtaXclXVtLsoeezB5sxdYvryjS4oEQpxirxdBa3FqBY719yy4CNoTHWV5+/pFNPtzWV4moyxifpARGDEvHDlyhD/84Q/ceuut2O12Wltb2bZtGzfffDNGq5F9w/v0MZa24TaOBY6hkv4G7yzTCx0NBQ3U59fjMDve4G8UYvZR4ykt/cBoIDUZJ9YdwlLuwpBjIj44yWTrIM51JRjdVqJHAgT/cJzca+u05YA7Bxh56AAlH12NKT+HiRf7GP3ZQUo+uQaT10boL72M/eIQpZ9eh9GtRSKH/txF4XuaMNhMTGzrZ+KFXgrf3YRiVAg9203oL7362EDwjx1M/KWX0k9raQhjvznCxIt9lP3jtASg3YP4PpNOAPrpQcL7R/Cl337kx/uJHgtQ+jdrgVcZS/j+HhJDYUo+Mm0sIRSn+APpsYRv70aNZsYSBr/ThmJQKHhHg/7nDVYjeTcs0d7/g/swOi362MHoTw9i9Foz+19+eRhTfg7ODdoT7cDvj2Eqsuv7ZIJPdWIusutjB6HnezAV2TNxmDsGtH0x6SfP4X0jmPJtmAvtqKpK7HgQY65N7whJDIcxOszaYsqUSmoyjsFqRDEbs5ZaCiHEghYNQe/OaaMs218lgrYlk8yyQCJoIXuUZWeX9utrjrL4vRS5ZZRFzF1zLgZ3ihRAxGvp6+vjkUce4bLLLqO8vJyOjg6eeOIJLr38UgKmgJ7G0jbUxsHRgyRU7Rt8vi2fxoLGrAjaXFvuDH80QswO0+f1kxNxkiMRzD4HitGg7WU4NIZzgw/FZCC8Z5iJrf3k37oUxWhgsnWAiW39FNzegGIyMLl7kHDbsBaBbFAItw8TOTSaiXvcP0K8cxz3+dpixsihMRJDk/p+lejxIMlAVO/giHWHSIXj2Gq0r9f44CRqLKWPMiQCUUiq+mLKVFj7mp/qIlCTKihSJBBCiHlDImhfUySepL0nwI6O1x5laa7IFDuqC50Y5eejmEekACLmrKkZ+lAoxPe//302bNhAU1MToVCIhx9+mIYzGhi0DmpjLMPt7BvZRzihfYN3mV3UF9TrhY7GgkaK7cXSbiyEEEIIMZdMj6DtSnd2TI+gzcnNFDum/nEUvO67nC9ePsqyszPA3t6gPsri89imFTtyaSxzY7fIFgQxv8kSVDFnJJNJjEYjqVSKb33rW9TU1HDeeedht9vJceWwf3w/T29/WuvusLUx/uI4AFajlWV5y7i29lq9u6PCXYFBMbzB3yiEEEIIIWYViaB9TcOhaNaS0p2dYwRfNspy95lVMsoixGuQAoiYUbFYDItFW3z3gx/8ALPZzI033kgwFsSUZ2LX5C5+8cdf0D7UzmByEA6DUTFSm1vLhYsu1Ds7qr3VmA3mN/jbhBBCCCHErKJH0G7NFDuyImiXQM35WqGjvAWKGhZMBO3LR1l2do3ROZI9ynLZCh8r0xG0MsoixBuTAog4rSYnJ7HbtfnLRx55hO7ubt7xrnewZ3gPI44ResO93P/T++kKdaX/AFQmKllXuk7b3ZHfwNK8pdhMUs0WQgghhJhT3jCCtkQrcizACNpUSuXo8IS+qLS1c+xVR1nedsYiGWUR4i2QrxpxSgUCAdxuN4qi8OSTT/Lcc89xxV1XsGd0D23JNvpN/az/4XpSaAurSh2lNOY3cl3ddTQWNFKfX4/L4nqDv0UIIYQQQsw6oYFM/OzrRtCmk1kWSAQtnNgoy7vSoywrZZRFiJNGCiDipBobG8PhcGA2m9m+fTuPPvooy65cxsHoQQ73H2bcPc7Dv3mYpCFJrjWXhqoG7i64W4+gLchZGAurhBBCCCHmlTeMoG2AhmsyqSwFdQsmgnZqlKW1M6AvK50aZTEosKTELaMsQpwmkgIj3jRVVRkdHcVqtWK329m6byu//vGvsa2xsc+4j2N9x8gN5tLh7MBsM1OfX68XOhoLGvE5fJLIIoQQQggx1yQTMLh32ijLNu16egRteUsmkWUBRdCe6ChLs99LU7mX5eUeGWUR4iSTFBhxUqiqysjICIqikMpJse34Np5/8HmCi4O8ZH2J8fA4lXmVDAwMUFlUyQVLL2B54XIa8xup9FRKIosQQgghxFxzohG0yy7PpLIskAhayIyy7OwcY8fLRlkcFiMryr0yyiLELCIFEPG6hoaGGJ0YZcg8RNtgG12PdtHn7uM573MAVBZWYrfbOcd3jraktKCBOm8dZqMksgghhBBCzDlZEbTp/R0Tg9o9oxVKm2DV7elRltWQu3jB7O3QRlmC03Z3yCiLEHONFEBElu7+btq72hnIGaBtuI3UsylChPhz6Z8BWO5fjr/Ez73+e2ksaGRp3lLs5oXR0iiEEEIIMa8koloKy9QoS1YEraLt6ai5QCt0lK1eUBG000dZdnZlRlniSW2UpdRjo9nv5bZ1i2j2yyiLEHOFfJUuYPFUnB1Hd7Dz8E66nd20DbXh3e8lP5LPb/y/ocheRNPSJhqLGrlt0W00FDTgsS6MKDIhhBBCiHllegTtVDLLa0bQtoCvecFE0II2yrKza4zWjtceZblrszbK0uz3UiyjLELMSVIAWSBSaopjwWNsP7adffv2sde5l/2j+6kaqmLZ2DKeqnmKpcVLWbp2KXX5dXx08UcpdhTP9LGFEEIIIcSbMd6f3dnxqhG078ssKvWUzex5T6MTG2UpTRc7cqkpklEWIeaLWZkCoyjKFmBLTU3Nuw4ePDjTx5lzVFWlb6KPtuE2dnXtovNAJzuMOxhRRygPlbNucB3djd3ULaqjzl5HrbuWZeXLJJFFCCGEEGIu0iNo050drxZBOxU/W7Z6QUXQplIqx4YnphU7Xn2UZeofGWURYu57vRSYWVkAmSIxuCdmJDJC21Ab7UPttPe3M3Z4jGOmYwSsAfLj+ZzddTaGZgPLG5ZT566jxFJCfm7+TB9bCCGEEEL8tSSC9nWNTMRo7Rx93VGW5gotgnZlhYyyCDEfSQzuPDIRn2DP8B7ahtrYPbSbPYN7cPQ4CFqC9Nv7qXHWsHxwOeub13PmhjOp8dYQD8dxu90zfXQhhBBCCPHXmIqg7ZrW2fGqEbRb0gWPhRVBG4kn2dMbpLUj093RMaJ9bgwK1BW7ZJRFCJFFCiCzWDQZZf/Ifq27Y7idtqE2jgaOUhOoIaEkiPliNBQ04D3ipcJfwXVbrsNhdjB5ySR2e6bSn2POmcGPQgghhBBCnBA9gnba7g6JoAW0Ee+jQ288ynLrugqa/F6Wl3lwWOWpjhAim3xXmCUSqQSHxw7rhY62oTYOjh0kkUpQGaykgAL89X4uXnwx8Rfi5LvzufXaWwGIbYxhsWQiyaYXP4QQQgghxCz08gjarq1aSgugR9DWXqh1dSywCFrQRll2dmpjLK3pUZZAWEuscViMLC/3cOcmLZVFRlmEECdKCiAzQFVVOsc7tULHsLa7Y+/IXsIJbft0TaSG2ngtG9ZvoLGgkdHWUcaHx3nnue9EURSSjUmMxsziqunFDyGEEEIIMctMRdDqoyyvEUG78tYFGUF7IqMsly4vkVEWIcRbJgWQ06B/ol8vdEyNswRjQQCsRisrjSu5bPgymi5soqm0iYF9A7S2tvKOxndgtVpJ+VMYDAb9/U0vfgghhBBCiFkmK4J2K3TvgOhrRNCWt4DbN7PnPY2mj7LsTBc79rxslKWp3Mst6yq0VBYZZRFCnETy3eQU2N6/na39W9k9tJv2oXYGw9rsplExUptbywW5F2A/ZOesi85iVfUqOo528Ic//IHNhZvJ9+SzeN1i1q1bp7+/6cUPIYQQQggxi5xIBG3jNQsyghZef5TFbjGyQkZZhBCnkRRAToEH9j7AY8cfo9JdybrSdSyxLyHwYoBzzjyHFQ0rGB0d5addP8Vn82E2mKmurqa6unqmjy2EEEIIIV7PG0XQ5laCfy2c8V5tlKVk+YKKoI0mkrT3ZEZZdnaNcXw4e5Tlksb0KEuFl9oil4yyCCFOKymAnAIfXfVRag/U0ljYyKZNm0gmk3x/9/exmqwA5Obmctddd83wKYUQQgghxGtSVQh0aZ0dXVtfI4K2ZcFG0KqqyrHhSVo7R/WCx/RRlhK3lspy81oZZRFCzB7yXegUKHOXUVJUgtPpBLSdHe94xztm9lBCCCGEEOK1RcfTEbRbtc6O7q0Q6tfuGa1QukKLoC1v0YodCyiCFv66UZZmv5cSj4yyCCFmHymAnCJXXXXVTB9BCCGEEEK8mqlRlq6tmYLH4D5A614gvwaqzsns7ShuXFARtNFEkj09QT2RpbVTRlmEEPODFECEEEIIIcT8paoQ7M4UO7q3Q8+OaaMseVqho+FqKF8NvlVgz5vZM59GMsoihFhI5LuXEEIIIYSYP6LjWoGjK53K0rUVQn3aPaMFSlbAqrdr+zvKVy+4UZbRiVhWZ8fOrjHGJjOjLMvLPNyxaTEr/V6a/bkyyiKEmFekACKEEEIIIeamZEIbXdEXlW6Dgb3ooyx51VB1VqbYUbxcRlleNspycYOMsgghFg4pgAghhBBCiLkh0J1d7OhphfiEdm8qlaX+Su3XsgU+ytIVYG9PkFhSi+idGmW5aY02yrKiXEZZhBALj3zXE0IIIYQQs080pI2yTC94jPdq94wWKFkOK2/LLCrNq1p4oyxdY/rejlcbZXnnpkoZZRFCiGmkACKEEEIIIWZWKqmNsmSlsuwFVeteIK8KKjenix0tUNIIJuvMnvk0evkoy87OMY69yihLUzqCtq5YRlmEEOLVSAFECCGEEEKcXsGe7GJHz46XjbKshmVbMt0dC2yU5fjwpF7s2NE5ljXKUuy20uz3cmN6lGV5uQenjLIIIcQJke+WQgghhBDi1ImGoLc1u+Ax3qPdM5jToyy3pheVtsgoy+uMsjT5vZR6cmb4xEIIMXdJAUQIIYQQQpwcqSQM7n9ZKsuezChL7mKo3JgpdhQ3gnnh7KaIJpLs7R2ntWNU7/B4+SjLRfUlNFdooyy1RU5MRsMMn1oIIeYPKYAIIYQQQog3J9j7slSWHRALafdsXm18Zell6VSW1eDIn9Hjnk4yyiKEELOPfJcVQgghhBBvLDahxc5OL3gEu7V7BrO2mLTp5syi0vzqBTnKsnPaotLRl4+ybKyk2e+luUJGWYQQYiZIAUQIIYQQQmRLJWHoQPbejoE9oCa1+7mVULF+WirLchllSY+yKArUFbm4UEZZhBBi1pECiBBCCCHEQjfeN63YsVXr9IiNa/dsHm18ZcnHMqksjoIZPe7pNDXKsrNrjB3pRaV7XmOUpcnvYUW5V0ZZhBBilpLvzkIIIYQQC0ls8pWpLMEu7Z7BpC0mbbpxWipLNRgWTvfCcCjKrq4AO9JjLNNTWXLMRpaXyyiLEELMVVIAEUIIIYSYr1IpbZRF39uxFfqnjbJ4F0HFOih7n1bsKFkO5oXzhD4ST9LeE2BHxxg7uwLs7ByjYyQ7leXihhKa0xG0MsoihBBzmxRAhBBCCCHmi/H+7GJH947MKIvVA2WrYPNHM6kszsKZPe9plEqpHB4MZXV27OsdJ5FSASjz5tDk93DbGRU0lXtpLPPgkFEWIYSYV+S7uhBCCCHEXBSbhN6d2aksgU7tnsEExQ2w4oZpqSw1C2qUpT8YSXd2aAWPXV0BQtEEAC6riSa/l3efVUWzP5emcg9F7oWzxFUIIRaq01YAURSlCvhbwKOq6nWn6+8VQgghhJjzUikYPpi9qLS/fdooSwWUr4Ez3qt1dpQ2LahRllA0wa6uMXZ2BvQY2r5gBACzUWFZqZurV5bpoyxVBQ4MhoUT0SuEEEJzQgUQRVG+A1wODKiq2jjt9y8GvggYgftUVf2313ofqqoeAe5UFOUnb+3IQgghhBDzXGhg2hjLNm2UJRrQ7lnd2ijLpo9kUlmcRTN73tMokUyxv3+c1vQoS2vnGAcHQqjaJAuV+XbWVeXpxY76Ujc2s3FmDy2EEGJWONEOkPuBLwPfm/oNRVGMwFeAC4Au4CVFUR5FK4b868v+/B2qqg685dMKIYQQQsw38bA2yjI9lSXQod1TjNooy/JrM6ks+bULZpRFVVW6RsNZxY62ngCRuBZBm+ew0FTu4bLlPpr8HprKveQ6LDN8aiGEELPVCRVAVFX9k6IolS/77bXAoXRnB4qiPAhcqarqv6J1i7wpiqLcDdwNUFFR8WbfjRBCCCHE7JNKwfChl6WytENK202BpwLKV8O6d6dTWVaAxT6zZz6NApNxWrsyxY6dnWMMT8QAsJoMNJZ5uHXdIpr8XprLvfjzclAUGWURQghxYt7KDpAyoHPadRew7rXeWFGUfOBzwEpFUT6VLpS8gqqq3wS+CdDS0qK+hfMJIYQQQsys0GBmjKVrK3Rvzx5l8a2EjR/KpLK4imf2vKdRNJFkT08wncgSoLVzjKNDEwAoCtQUOjlnaRHNfi/Nfi9LSlyYJYJWCCHEW3DalqCqqjoMvOd0/X1CCCGEEKdVPAy9u7K7O8amj7LUQ+M1mVSWgroFM8qSSqkcHZ7Qih3p7o49vUHiSe21riKXlWa/l+tbymku97K83IPLZp7hUwshhJhv3koBpBvwT7suT/+eEEIIIcT8lkrByOGXpbK0TRtl8WsdHWvv1oodpU0LapRlcDya7uzIjLIEI9rnxmExsrzcw52bqmj2e2jyeyn1LJzEGiGEEDPnrRRAXgJqFUVZjFb4uAm45aScSgghhBBiNpkYyi529GyHSHqUxeKCspWw4YOZVBZXycye9zQKx5Ls7s7Ez7Z2jtE9FgbAaFBYUuzi8iYfzeVaKktNkROjRNAKIYSYAScag/sj4GygQFGULuAfVFX9tqIo7wd+j5b88h1VVdtPxqEURdkCbKmpqTkZ704IIYQQ4sTFI9C3K7vgMXZcu6cYoKgBGq7OpLIU1IFhYcSsJlMqBwfGpxU7AhzoHyeZ0kZZynNzaK7w8s6NlTT5vTT6PORYFsbnRgghxOynqOrs3TPa0tKibt26daaPIYQQQoj5SlVh+HD23o6+NkjFtfvuci2VZWpJqa8ZLI4ZPfLpoqoqvYGIVuzoGqO1Y4zd3QEmY0kA3DYTTX4vK/1aZ0eT30uB0zrDpxZCCLHQKYqyTVXVlle7d9qWoAohhBBCzLiJ4WnFjm3aP5Ex7Z7FqaWybHh/prtjAY2yBCNxdqfTWKb2dgyMRwGwGA0s87m5ocVPk99Dsz+Xyny7RNAKIYSYU6QAIoQQQoj5KRF9ZSrL6DHtnmKAonqovzKTylK4ZMGMssSTKfb1juudHTu7xjg8GGKqMbiqwMGmmgK9s2NZqQuraWF8boQQQsxfUgARQgghxNynqjByJHtvR9/uaaMsZdoIS8sd2q+lzWB1zuiRTxdVVekYmczq7GjrCRJLpAAocFpo9nu5ssmnFTzKvXjsEkErhBBi/pECiBBCCCHmnskRbXxlquDRvQ3Co9o9swPKVsH692W6O9ylM3ve02hkIqbFz6Y7O3Z2jjE6qRWCbGYDK8q83L5+EU1+L81+L2XeHBllEUIIsSDMygKIpMAIIYQQQpeIat0c07s7Ro9q9xQDFC6DZVsyezsKly6YUZZIPEl7T1BPZdnZNcbx4UkADArUFbu4sL5EL3bUFTsxGQ0zfGohhBBiZkgKjBBCCCFmj6lRlundHX27IRnT7rt8mVSW8pYFNcqSSqkcGQrR2hmgtXOUnZ0B9vYGSaQjaEs9NprTOzua/V4ayzw4rbPytS4hhBDilJEUGCGEEELMTlOjLHrBYxuER7R7ZoeWynLGezMFD7dvZs97Gg0EI5m9HV1j7OoMMB5NAOCymljh93D3mVV60aPYbZvhEwshhBCzmxRAhBBCCHF6JKLQ15adyjJyJH1TgaJlsPSyaaksS8G4MB6qTEQT7O4O6EtKWzvH6A1EADAZFJaVurlypY+mci8rK7xUFTgxGGRvhxBCCPHXWBiPKoQQQghxeqmqtqeja9u0VJZd00ZZSrU0llVv1371rQSra2bPfJokkikO9If0YsfOrjEO9I+TnmRhUb6dNZV5+ihLg8+NzbwwdpoIIYQQp5IUQIQQQgjx1k2OQPf29DhLepRlcli7Z7ZrBY5178l0d3jKZva8p4mqqnSPhTPFjs4Au7sDhONJAHLtZpr8Xi5qKKG5QougzXNYZvjUQgghxPw0KwsgkgIjhBBCzGKJGPTvzu7uGDmcvqlooytLLpmWyrJswYyyBMJxdk2LoG3tDDAUigJgMRlo9Lm5aa2f5nR3R0WeXSJohRBCiNNEUmCEEEII8dpUFUaPZaey9O6CpPakHmdJuqtjlVbw8K0Em3tGj3y6RBNJ9vWOZ+3tODI0od+vKXLSVO6lucJLc7mXJSUuLCaJoBVCCCFOJUmBEUIIIcSJCY9mRlmmCh5ToyymnPQoy93TUlnKYAF0MKiqyrHhST1+dkfnGHt7gsSSKQAKXVaa/V6uXV1Os9/L8nIPbpt5hk8thBBCiOmkACKEEEIsVIkY9LdlFzuGD6VvKlC4BOougfLVWsGjqH7BjLIMhaLpnR1jtHYF2Nk5RiAcB8BuMbK8zMM7N1bqEbSlHpuMsgghhBCz3MJ4FCOEEEIsdKoKY8fThY50waN357RRlmKtyNF8y4IbZQnHkrT1BPQxltbOMbpGwwAYFFhS4ubS5SV6saO2yIVRImiFEEKIOUcKIEIIIcR8FB6Dnu3Zi0onh7R7phzwNcPad01LZSlfEKMsyZTK4cEQrR1jtKaXle7vHyeZzqAt8+bQ7Pdy+/pKmvxeGsvc2C3ycEkIIYSYD+QnuhBCCDHXJePaKMv07o7hg+mbChTUQd1FULZaK3gU1YNxYeyn6AtEaO0cpbUzQGvnKLu7AkzEtAhal81Es9/LPcuqaSr3ssLvochlm+ETCyGEEOJUmZUFEInBFUIIIV6DqsJYR7qrI93d0bsTEhHtvqNIK3I03aQVPMpWgc0zs2c+TcYjcXZ3BfTOjp1dY/QHtREfs1GhvtTNdavLaUqPsizOd2CQURYhhBBiwZAYXCGEEGI2iwS0ro7ubZmCx8Sgds9kg9Lm9BhLurvD418QoyzxZIr9fdkRtIcGQ0w9rFlc4KCp3KPv7aj3ubGajDN7aCGEEEKcchKDK4QQQswFyTj0t2d3dwwdyNwvqIOaCzKpLMUNC2KURVVVOkfCtHZlih1t3QGiCS2CNt9hocnvZUuTT+vuKPfgtVtm+NRCCCGEmG2kACKEEELMBFWFQOcrU1kSWvoI9gKto2P5DVrBw7cKcrwzeuTTZXQixs6uMXam93bs7AowMhEDwGoysLzMw9vOWEST30uz30t5bo5E0AohhBDiDUkBRAghhDgdIgHo2ZFd8JgY0O6ZbFDaBC13ZLo7vBULYpQlEk+ypzeod3bs7Bzj2PAkoH34tUVOzl9WlO7s8LKkxIXZaJjhUwshhBBiLpICiBBCCHGyJRMw0J5d7Bg6AKQXVOTXQs15mb0dxY0LYpQllVI5MjSRKXZ0jbG3N0g8qX1eStw2mv1eblxTQZPfw4pyL06rPFQRQgghxMkhjyqEEEKIt0JVIdCV3tuRLnj0tE4bZcnXOjqWX5dJZcnJndEjny4D45HMGEtngJ1dY4xHEgA4LEZWlHu5a3MVTeXaKEuJRyJohRBCCHHqSAFECCGE+GtEgtooy/RFpaF+7Z7Rmh5leWemu8O7aEGMskxEE7R1a0UObZQlQPeYVgQyGhSWlri4Ir2kdKXfS1WhE6NE0AohhBDiNJICiBBCCPFakgkY2JNd7BjcT2aUpQaqzsnE0BY3gmn+p48kkikODoT0UZbWzjEO9I+TSn9a/Hk5rFqUyzs3VrKywkuDz4PNLBG0QgghhJhZs7IAoijKFmBLTU3NTB9FCCHEQqGqEOxOj7GkCx69rRDXFnLqoyyN12pjLGWrF8Qoi6qq9AQiWcWOtu4Ak7EkAF67maZyLxc2lNDs99BU7iXfaZ3hUwshhBBCvJKiqupMn+E1tbS0qFu3bp3pYwghhJiPouOvTGUJ9Wn3jFYoXaEVPKa6O3IrF8QoSyAcZ3eXtrejtTNAa+cYQ6EoABaTgQafW9/Z0ez3sijfLhG0QgghhJg1FEXZpqpqy6vdm5UdIEIIIcRJlUzA4N7s7o7BfeijLHnVUHVWuuCxGoqXL4hRllgixb6+oN7ZsbNzjMODE/r9qkIHZ9YV6MWOpSVuLCaJoBVCCCHE3CQFECGEEPNPoPtlqSw7MqMsOXlaR0fDVVrBo2wV2PNm9Ling6qqHB+ezBQ7usZo7wkSS6QAKHBaafZ7uXplGc3+XJaXe/DkzP9oXiGEEEIsHFIAEUIIMbdFx7XY2ekFj/Fe7Z7RAiUrYNXbM90duYsXxCjLcCjKrq4AO9KdHTu7xhibjAOQYzayvNzDOzZU0uz30uT34vPYZJRFCCGEEPOaFECEEELMHakkDOzNLnYM7gNV62IgrwoqN6f3drRASSOY5v9Czkg8SXtPgB0dY+xM7+/oHNEiaA0K1BW7uLihhKb0KEttkROTUUZZhBBCCLGwSAFECCHE7BXsyd7b0bMD4ukdFTm52ijLsisyi0oXwChLKqVyeDCU1dmxr3ecRDqD1uex0Vzh5bZ1i2j2e2ks8+Cwyo97IYQQQgh5RCSEEGJ2iIa02NnpBY/xHu2ewaylsqy8LVPsyKtaEKMs/cFIurNjjNaOMXZ3BwhFEwC4rCaa/F7efVYVzf5cmso9FLltM3xiIYQQQojZSQogQgghTr9UUhtdyUpl2ZsZZcldDJUbMzG0JcsXxChLKJpgV9cYOzsD7EwvK+0LRgAwGxWWlbrTS0q1vR1VBQ4MhvlfBBJCCCGEOBmkACKEEOLUC/a+MpUlFtLu2bxakWPZ5elUltXgyJ/R454OiWSKfX3j7Owa04sdBwdCqOlk3sp8O+uq8vRiR32pG5vZOLOHFkIIIYSYw2ZlAURRlC3Alpqampk+ihBCiL9WbOKVqSzBbu2ewax1czTfkunuWACjLKqq0jUa1uJn08WOtp4AkbjW8ZLnsNBU7uHS5aVawaPcS67DMsOnFkIIIYSYXxR16qWmWailpUXdunXrTB9DCCHEa0klYXD/tGLHdhjYA2pSu59bmSl0lKVHWczzf0dFYDJO67TOjp2dYwxPxACwmgw0lnloKvfSXOGludyLPy9HImiFEEIIIU4CRVG2qara8mr3ZmUHiBBCiFlIVbVOju5t6X+2v2yUxaONryz5WGZRqaNgZs98GkQTSfb0BDPFjq4AR4e0pBpFgZpCJ+csLaI5HUG7pMSFWSJohRBCCCFOOymACCGEeHXh0XSRY7v2a/c2CPVr94yWaaMsq7XujvzqeT/KkkqpHB2e0OJn0wWPPb1B4kmtm7LIZaXZ7+X6lnKay700lntw28wzfGohhBBCCAFSABFCCAEQj0Df7mndHdtg5HDmfkEdVJ+bLnasguLGBZHKMjge1YodXZlRlmBEi6B1WIwsL/dw56Yqmv0emvxeSj05M3xiIYQQQgjxWqQAIoQQC00qCUMHs4sd/W2Q0p7Y4/JpRY6Vt2m/+lZq4y3zXDiWZHd3Jn62tXOM7rEwAEaDwpJiF5c3+Wgu11JZaoqcGCWCVgghhBBizpACiBBCzGdvtLfD6tYKHBs+mOnucPtm9synQTKlcnBgfFqxI8CB/nGSKW2UpTw3h+YKL+/cWEmT30ujz0OORSJohRBCCCHmMimACCHEfBIe1QocU8WO19vb4VsF+TVgmN8LOVVVpTcQyers2N0dYDKmJdW4bSaa/F4uWFZNk1/r7ihwzv/xHiGEEEKIhUYKIEIIMVfJ3o5XFYzE2d0V0IsdOzvHGBiPAmAxGljmc3NDi58mvxZFu7jAIRG0QgghhBALgBRAhBBiLjjhvR23prs7Fsbejlgixf6+cVq7xmjt0JaVHh4MoWqTLFQVONhUU6B3diwrdWE1ySiLEEIIIcRCJAUQIYSYbV51b0crxMa1+wt0b4eqqnSMTGZ1drT1BIklUgDkOyw0+71c2eTTCh7lXjx2iaAVQgghhBAaKYAIIcRMO5G9HU03pYsdqxfE3g6AkYmYFj+b7uzY2TnG6GQcAJvZwPIyD7evX0ST30uz30uZN0dGWYQQQgghxGuSAogQQpxO0/d29KSLHcOHMvcX6N6OSDxJe09Q7+zY2TXG8eFJABQF6opcXFhfohc76oqdmIzzvwgkhBBCCCFOHimACCHEqfKGeztKtUKHnsqyMPZ2pFIqR4ZC7NA7OwLs7Q2SSEfQlnpsNPu93Ly2gqZyL8vLPTit8uNKCCGEEEK8NbPyEaWiKFuALTU1NTN9FCGEODH63o7tmWKH7O0AYCAYYce0zo5dnQHGo1oRyGU1scLv4e4zq/TujmK3bYZPLIQQQggh5iNFnVqVPwu1tLSoW7duneljCCHEK73e3g6DWdvbMbWzYwHt7ZiIJtjdHdBHWVo7x+gNRAAwGRSWlbr1+NmVFV6qCpwYDLK3QwghhBBCnByKomxTVbXl1e7Nyg4QIYSYVeIRbXRl+iiL7O0glkhxoH+cXV0BvdhxcGCc9CQLFXl21lTm6Z0dDT43NrNE0AohhBBCiJkhBRAhhJjuVfd2tENKSx/BWQLlLZm9HaXNkOOdyROfFpOxBHt7g7R1B2nvCdDeE+RA/zjxpFbtyLWbafJ7ubixhOYKLYI2z2GZ4VMLIYQQQgiRIQUQIcTCdcJ7O96fGWVZAHs7RiditPdkCh1tPQGODk0wNTGZ57DQ4HNz56YqGsvcNPo8LMq3SwStEEIIIYSY1aQAIoRYOE5kb0fTTQtmb4eqqvQHo7R1B7IKHt1jYf1tyrw51PvcXNHko9HnoaHMTYnbJsUOIYQQQggx50gBRAgxP53I3o6qczLFjpL5vbcjlVLpGJmkbaqrozvAnp4gwxMxABQFFhc4WLUol7evX0SDz0ODz02ujLEIIYQQQoh5QgogQoi5L5WCoQPTxli2Q1/bgt3bEU+mODQQynR1dAfZ0xsklI6eNRsVaotcnLu0iMYyrdCxrNSNwyo/EoQQQgghxPwlj3aFEHOLqkKwJ7uzY/reDosLyhbO3o5IPMne3mC62KEVPPb1jRNLpADIMRtZVurimlVlNPjcNPg81BY7sZokjUUIIYQQQiwsUgARQsxur9jbsR1Cfdq9Bba3IxCOs2faro72ngCHBydIpnNnPTlmGnxu3rGhMl3scLO4wInRIPs6hBBCCCGEkAKIEGL2eKO9Hfm1UHX2gtjbMTAe0Yoc+oLSIB0jk/r9YreVRp+HixtKqPd5aCxzU+bNkeWkQgghhBBCvAYpgAghZsb0vR096USW19rb4VulxdHOw70dqqrSNRqmvSdAW3emu2NgPKq/zaJ8O8vLPNy4xq+PsRS65mfhRwghhBBCiFNFCiBCiFNP9nYAkEypHBkM6SksU2MswYi2nNRoUKgtcrKptoAGn4dGn5tlPjdum3mGTy6EEEIIIcTcJwUQIcTJFx5Ld3VM/bPtNfZ2rErv7aidd3s7ookkB/pC6dhZrdixtzdIJK4tJ7WaDCwtdXN5k48Gn5tGn4clJS5sZllOKoQQQgghxKkgBRAhxFsjezsIRRNZy0nbugMcGgiRSC8ndVlN1Pvc3LJ2EY1l2ghLdaEDk3F+FX2EEEIIIYSYzaQAIoQ4cVN7O6Z2drza3o6y1dB0s/brPNzbMRyKZkXOtvcEOTY8garVOihwWmjweTh3aRGNZR4afG78uXYMksQihBBCCCHEjJICiBDi1S3wvR2qqtITiExLYdF+7Q1E9Lcpz82hwefmmpVlNKQ7O4pcVkliEUIIIYQQYhaSAogQQhMeg54d6WLHq+3taISmGzPFjnm0tyOVUjk6PJEpdKTTWEYntc4WgwJVhU7WLs6j0ad1ddT73Hjtlhk+uRBCCCGEEOJESQFEiIVoAe/tiCVSHBwY14od3ZnlpBOxJAAWo4G6EicXNZSkCx0elpW6sFvk26UQQgghhBBz2ax8RK8oyhZgS01NzUwfRYi5L5WC4YPZxY6svR3FUNYyL/d2TMYS7O0dZ09PgLbuIO29AQ70hYgltSQWu8VIfamb61v81KeTWGqKnFhM86OzRQghhBBCCJGhqFOb+2ahlpYWdevWrTN9DCHmjhPd2zHV2eFbpe3tmAc7KwKTcdp7AunYWW1J6ZHBEOkgFnLtZhrLPNT7tF0djT43lfkOWU4qhBBCCCHEPKIoyjZVVVte7d6s7AARQpygBbi3Q1VVBsajWrGjO7OctGs0rL9NqcdGg8/DZctLafC5aSzzUOqxyXJSIYQQQgghFjApgAgxV2Tt7UgXO4YPZu5n7e1YBcWNYLbN2HFPBlVV6RiZzCp0tPcEGArF9LepKnDQ7Pdy67pFNJa5qS91k++cH/tKhBBCCCGEECePFECEmI1OeG/HTfNmb0cimeLw4ARt02Jn9/QEGY8mADAZFGqLXZy9pEjv6lhW6sZplW9jQgghhBBCiDcmzxyEmGnT93b0pDs7une8cm/H+vdlRlnm+N6OSDzJ/r7xzL6O7gD7+saJJrTlpDazgWWlbq5c6UvHznqoLXZiMxtn+ORCCCGEEEKIuUoKIEKcbgtsb0cwEmdPeilpe0+A9u4ghwZDJNPbSd02Ew0+D287YxGNZR4afG6qCp0YZTmpEEIIIYQQ4iSSAogQp1Iiqo2uTB9lydrbUQNVZ2WKHXN8b8dgejmpXuzoCXJ8eFK/X+Sy0uBzc2FDMQ3pNJby3BxZTiqEEEIIIYQ45aQAIsTJsoD2dqiqStdomPaeIHt6ArSlCx79waj+NhV5dhp8bm5o8aejZ90UueZucUcIIYQQQggxt0kBRIg3a2pvx9Q/Pa0QDWr3LC7wNc+LvR3JlMrRoRDtPcFpC0qDBMJaYcegQE2Rk43VBelCh4d6nxtPjnmGTy6EEEIIIYQQGVIAEeJEnMjejhU3zPm9HdFEkoP9Idp7Anr07N7eccLxJAAWk4GlJS4uXV6aHmFxs7TETY5FlpMKIYQQQgghZjcpgAjxcgtkb8dENMHe3uyujoMD48ST2nJSp9VEvc/NTWv9NPg8NJa5qS50YjbOvcKOEEIIIYQQQkgBRCxsJ7y348ZpeztyZ/bMb8LoREwbYZm2oPTo0ASqVusg32GhoczDWUsKafC5afR5qMizY5AkFiGEEEIIIcQ8IQUQsbDM870dqqrSF4zo4yvtPUHauwP0BCL625R5c2jwubmyqYzGMm1nR7HbKkksQgghhBBCiHlNCiBi/pq+t2Pq1/Fe7d70vR2+VVqxo6AWDHNnl0UqpXJ8ZHLaCIv268hEDNDqNlUFDloq87SujjIP9aVuch2WGT65EEIIIYQQQpx+UgAR88OJ7O1YfOac3dsRT6b05aRTxY69veOEogkAzEaFumIX5y8rorHMoy8ndVjlS1wIIYQQQgghQAogYi56xd6O7dC3+2V7O1bP2b0d4ViSvX3aUtI96TSW/f3jxBIpAOwWI8tK3VyzqozGdORsXbELi0mWkwohhBBCCCHEa5ECiJj9Xndvh1MrcMzRvR2BcJz2ngB7ejJpLIcHQ6TSy0m9djMNPjfv3FBJvU/b17G4wIFRlpMKIYQQQgghxF9FCiBidokEMvs6ure/cm9HcQMsvz5T7JhDezsGghF9fKWtO0h7b4DOkbB+v8Rto8Hn5pLlpfrODp/HJstJhRBCCCGEEOIkkAKImDnzdG+Hqqp0joS1Qoe+syPI4HhUf5vKfDsryr3cvLaCBp+2s6PAaZ3BUwshhBBCCCHE/CYFEHF66Hs7tmeKHdP3djiKoLxlzu3tSCRTHBmayHR1pMdZghFtOanRoFBb5OTM2kIafG4afG7qfW5cNvMMn1wIIYQQQgghFhYpgIhT44T3dqQjaN1ls35vRySe5ED/uF7oaO8Jsrc3SDS9nNRqMrC01M2WJh8NPg+NZdpyUpt5bozoCCGEEEIIIcR8JgUQ8da97t6O/9/evcfWedZ3AP8+ce6Xc9o0bZPjhl5oKY0NU7uswAQTbGMwdV1hIAYbE9IQlTax7c8xadImTRP8MU3jprEO0ASbKAgxBNIm2E0DTfujFzaIk64JLYLU6T21c2lu9rM/zonjVKEkje3z+s3nI0U55z2vfX7va8t6/PXz/J6V/aUry6xvx6FjJ7PnwKG5xqQTk1PZ9+ThnBp0J920dmXGep2897XXzvXruGHLhqwcsRMLAABAEwlAuDAv7Nsx+WDy9MNnXj/dt6M3mNmx9VWN79vx9OHjcyHHxOR0Jh6byg+eOTr3+paNazI+2skv3HJVxnvdjPW62b55neakAAAAy4gAhB9vdjZ5Zt/ZS1nO1bfj1e9aFn07aq2ZnDo2N6tj96Bvx+PTx+bO2b55Xca2dfOO267J+Gi/OelVnWYHOAAAAPxkAhDOOK++Hb97ZilLg/t2zMzWPDpoTrp7cnpuN5bnjvbDmxUlefmVG/PaGzZnfLSbHb1OxrZ1012vOSkAAEAbCUAuVS3q23Hi1GwefuJQdg+WsewaNCc9emImSbJ6ZEVu3ropbx3bmrHBrI5btnaybnUzrwcAAICFJwC5FPykvh2bX55c94YzYUeD+3YcPXEqew5MZ2Jyem4py8NPHMrJmX5z0g2rR7Kj18m7dm4fbDvbzU1Xb8wqzUkBAAAuaQKQtmlR347njp6Ya056euvZR54+ktrPOrJ5w+qM9Tp5/+tvGIQdnVx3xYasWNHMZTkAAAAMz5IFIKWUtyW5I0knyWdqrd9cqvdutbm+HYNlLJPfWXZ9O2qteWL6+FlBx8TkdB577vm5c3rdtdnR6+bOn+plrNfN+GgnWztr7cQCAADAeTmvAKSU8tkkv5LkyVrr+Lzjb03y0SQjST5da/3Ij/sctdavJvlqKeXyJH+RRAByoS6ob8dtyZZXNK5vx+xszQ+fPdpfwjJ5ZjeWpw+fSNLPZq6/YkNuu/by/Nbrrp1bxrJ5w+ohVw4AAMBydr4zQP4uySeSfO70gVLKSJJPJnlzkv1J7iulfC39MOTDL/j43661Pjl4/MeDj+PFnO7bMfngmaUsy6xvx6mZ2ex76vBZszp2T07n8PFTSZKVK0pecfWmvOnmqzLW62R8tJtXbutk4xorswAAAFhY5/WbZq31W6WU615w+PYk+2qtjyRJKeXeJHfVWj+c/myRs5T+WoWPJPnnWuuDF1V125xv345Xvas/s6N3a7J+83BrfoFjJ2fy0OOH5hqT7p6cyp7HD+XEqdkkydpVK7JjWydvv3V0Luy46eqNWbOyWTNUAAAAaKeL+VP7aJIfzXu+P8lrXuT830vyi0m6pZQba62fOtdJpZS7k9ydJC972csuorwGmz5wdtixzPp2TD1/cm7L2d2DpSzff+pIZmb73Um761ZlrNfJ+153bcYH285ev2VjRjQnBQAAYEiWbK1BrfVjST52Hufdk+SeJNm5c2dd7LoW3Xn17XjnmbCjYX07njp0PLsGQcfpJqU/fPbo3OtXd9ZkrNfNW8a2ZqzXDzuuuXyd5qQAAAA0ysUEII8l2T7v+TWDY3zvy8m+f11WfTtqrdl/8Pm5Xh2nl7I8eej43DnXXrE+46Od/PrPbJ9rTnrlpjVDrBoAAADOz8UEIPcluamUcn36wce7k/zGglS13O39l+T7/94PORrYt2NmtuaRpw5nYt6sjonJqUwf6zcnHVlRcuOVG/P6G7dkbLCEZUevk87aVUOuHAAAAF6a890G9wtJ3phkSyllf5I/qbV+ppTywSTfSH/nl8/WWicWrdLl5M6/SlaubUTfjuOnZvLw44f7QcdgdsdDBw7l+ZMzSZLVK1fklq2bcserexkf7c/qeOXWTVm7qjnLcAAAAOBilVqb12ajlHJnkjtvvPHGD+zdu3fY5Swbh4+fyp4D05l4bCq7JqczMTmdvU8cyqlBc9JNa1bmll4n44NeHWOjnbz8yo1ZNbJiyJUDAADAxSulPFBr3XnO15oYgJy2c+fOev/99w+7jEZ69siJs5av7J6czqPPHMnpL+eWjauzo9fN+KBXx/hoJ9svX58VdmIBAACgpV4sAFmyXWB4aWqtOTB17KzGpBOTUzkwdWzunNHL1mV8tJO33TqasV4n46PdXLVpjZ1YAAAAYEAA0iCzszU/eObIYPlKf1bHrsemcvDoyST9liI3bNmQ26/f3A86et3s6HVy2frVQ64cAAAAmk0AMiQnZ2az94nD2TUv6NhzYDpHTvSbk64aKbl566b80o6tGRs0J71l26asX+1LBgAAABeqkb9Nz2uCOuxSFsTRE6ey58Ch7B7swrJrcioPP344J2ZmkyTrV49kx7ZO3vnT18xtO3vTVZuyeqXmpAAAALAQNEFdBA/+8GAe+MHBwdaz03nkqcMZbMSSy9evytjcLiz9/6+7YkNGNCcFAACAi6IJ6hL79LcfyT997/Fs667NWK+TO161bS7w6HXXak4KAAAAS0wAsgj+6JdvyZ/dNZ4rNq4ZdikAAABABCCLYvvm9cMuAQAAAJhHl00AAACg9QQgAAAAQOs1MgAppdxZSrlnampq2KUAAAAALdDIAKTW+vVa693dbnfYpQAAAAAt0MgABAAAAGAhCUAAAACA1hOAAAAAAK0nAAEAAABaTwACAAAAtF4jAxDb4AIAAAALqZEBiG1wAQAAgIXUyAAEAAAAYCEJQAAAAIDWE4AAAAAArScAAQAAAFpPAAIAAAC0ngAEAAAAaD0BCAAAANB6jQxASil3llLumZqaGnYpAAAAQAs0MgCptX691np3t9sddikAAABACzQyAAEAAABYSKXWOuwafqxSylSSvcOu4xLTTXKprz1q0z1YDtfStBqHVc9Svu9iv9eWJE8v4ueHc2naz5K2c7/72nQflsO1NKnGYdZizAAv7tpa65XnemHlUldygb5Ya7172EVcSkop91zq97xN92A5XEvTahxWPUv5vov9XqWU+2utOxfr88O5NO1nSdu5331tug/L4VqaVOMwazFmgJeu6Utgvj7sAi5B7nm77sFyuJam1TisepbyfZt2z2Eh+L5eWu53X5vuw3K4libVOMxajBngJWr0EhgAlh9/zQEAzocxA0ut6TNAAFh+7hl2AQDAsmDMwJIyAwQAAABoPTNAAAAAgNYTgAAAAACtJwABAAAAWk8AAsCiKqW8sZTy7VLKp0opbxx2PQBA85RSVpRS/ryU8vFSyvuGXQ/tJAAB4IKVUj5bSnmylLLrBcffWkr5v1LKvlLKhwaHa5LDSdYm2b/UtQIAw3GB44W7klyT5GSMF1gkdoEB4IKVUn4u/VDjc7XW8cGxkSQPJ3lz+gOX+5K8J8lDtdbZUsrVSf6y1vqbQyobAFhCFzhe+NUkB2utf1NK+XKt9Z1DKpsWMwMEgAtWa/1WkmdfcPj2JPtqrY/UWk8kuTfJXbXW2cHrB5OsWcIyAYAhupDxQvphyMHBOTNLVyWXkpXDLgCA1hhN8qN5z/cneU0p5deSvCXJZUk+MYS6AIDmOOd4IclHk3y8lPKGJN8aRmG0nwAEgEVVa/1Kkq8Muw4AoLlqrUeTvH/YddBulsAAsFAeS7J93vNrBscAAE4zXmBoBCAALJT7ktxUSrm+lLI6ybuTfG3INQEAzWK8wNAIQAC4YKWULyT57yQ3l1L2l1LeX2s9leSDSb6RZE+SL9VaJ4ZZJwAwPMYLNI1tcAEAAIDWMwMEAAAAaD0BCAAAANB6AhAAAACg9QQgAAAAQOsJQAAAAIDWE4AAAAAArScAAQAAAFpPAAIALHullJXDrgEAaDYBCADQGKWU60ope0opf1tKmSilfLOUsq6U8vullN2llO+WUu4dnPunpZTPl1L+K8nnSylXl1L+sZTyv4N/PzvkywEAGsRfSwCAprkpyXtqrR8opXwpyTuSfCjJ9bXW46WUy+aduyPJ62utz5dSvpjkP2utby+ljCTZuOSVAwCNZQYIANA0j9Za/2fw+IEk1yX5bpJ/KKW8N8mpeed+rdb6/ODxzyf56ySptc7UWqeWplwAYDkQgAAATXN83uOZ9Ges3pHkk0luS3LfvJ4fR5a4NgBgmRKAAABNtyLJ9lrrfyT5wyTdnHt5y78l+Z0kKaWMlFK6S1ciANB0AhAAoOlGkvx9KeV7Sb6T5GO11ufOcd4fJHnT4LwH0u8PAgCQJCm11mHXAAAAALCozAABAAAAWk8AAgAAALSeAAQAAABoPQEIAAAA0HoCEAAAAKD1BCAAAABA6wlAAAAAgNYTgAAAAACt9/8Lx+qGNsGYQwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -316,13 +354,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 27, "id": "a52739ce", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -339,7 +377,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "3bd95843", "metadata": {}, "outputs": [], @@ -347,44 +385,218 @@ "def plot_comparison(\n", " t1: dict[str, dict[tuple[int, int], TimeResult]], \n", " t2: dict[str, dict[tuple[int, int], TimeResult]],\n", - " nant: int\n", + " outer_label: int\n", "):\n", " fig, ax = plt.subplots(1, 1, figsize=(15, 8), constrained_layout=True)\n", "\n", - " nants_redundant = np.max(nants)\n", - "\n", - " # def get_res(t, method):\n", - " # res = [t[method].get((nants_redundant, n), None) for n in nsides]\n", - " # return np.array([r.best if r is not None else np.nan for r in res])\n", - "\n", - " # for j, method in enumerate(t1):\n", - " # r1 = get_res(t1, method)\n", - " # r2 = get_res(t2, method)\n", - " \n", - " # ax.plot(nsrcs, r1 / r2, color=f'C{j}', label=method)\n", - "\n", - " def get_res_redt, method):\n", - " res = [t[method].get((nants_redundant, n), None) for n in nsides]\n", + " def get_res(t, method):\n", + " res = [t[method].get((outer_label, n), None) for n in nsides] \n", " return np.array([r.best if r is not None else np.nan for r in res])\n", "\n", - " for j, (method, results) in enumerate(red_timings.items(), start=len(timings)):\n", - " for k, frac in enumerate(redfracs):\n", - " res = [results.get((frac, n), None) for n in nsides]\n", - " ax.plot(\n", - " nsrcs, [r.best if r is not None else np.nan for r in res], \n", - " color=f'C{j%10}', ls=[':', '--', '-.', (0, (3, 5, 1, 5, 1, 5)), (0, (3, 1, 1, 1, 1, 1))][k], \n", - " label=f\"{method} ({frac}% red.)\"\n", - " )\n", + " for j, method in enumerate(t1):\n", + " if method == 'redundant':\n", + " continue\n", + " r1 = get_res(t1, method)\n", + " r2 = get_res(t2, method)\n", + "\n", + " ax.plot(nsrcs, r1 / r2, color=f'C{j}', label=method)\n", " \n", - " ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n", + "# ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\n", " ax.set_xlabel(\"nsrc\")\n", " ax.set_xscale('log')\n", - " ax.set_yscale('log')\n", + " #ax.set_yscale('log')\n", " #ax.plot(nsrcs, np.array(nsrcs) * (results[(350, np.max(nsrcs))].best/np.max(nsrcs)), ls='--', color='k')\n", "\n", " ax.legend(frameon=False, ncols=3)\n", " return fig, ax" ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c1ad42fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_comparison(normal_single_row, normal_double_row, 700)\n", + "plt.title(\"Single / Double Precision Dot-Product\")\n", + "plt.axhline(0.5, linestyle='--', color='k')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "4d393558", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_comparison(redundant_single_row, redundant_double_row, 3)\n", + "plt.title(\"Single / Double Precision VectorLoop\")\n", + "plt.axhline(0.5, linestyle='--', color='k')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d1d2d8de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_comparison(normal_single_row, normal_single_col, 700)\n", + "plt.title(\"Row / Column Major Ordering, Full Dot Product\")\n", + "plt.axhline(1.0, linestyle='--', color='k')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "45628dd4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEAAAAJICAYAAABhfJEYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAAsTAAALEwEAmpwYAACeoUlEQVR4nOzdZ3hc1bn28XuNZtSLi4qrJPduZMmGUAw2xvRmiiEYjCFAIJC85HBSSDmQhPTkpEGSY3o1BFNCCCTYdByqZOOGuyV3FUtWbzOz3g97PJZkSW6St8r/d12+LM3sveeZkQSeW896lrHWCgAAAAAAoCfzuF0AAAAAAABAZyMAAQAAAAAAPR4BCAAAAAAA6PEIQAAAAAAAQI9HAAIAAAAAAHo8AhAAAAAAANDjEYAAANBBjDGPGWPuc7uOjmKM+asx5odu19GSMeYdY8xNx3B+lTFmeEfW1JGMMdYYMzL0cY/6nmrKGJMZeq5et2sBAPQOBCAAANcYY/KNMbWhN6R7Qm/24o/D437ZGPNMG/clGmN+b4zZFqprc+jz5M6uq6MYYxaE3lj+rsXtl4Ruf+xwrmOtvdVa+5MOrCvKGPPz0Gtba4zZaIz5ljHGdNRjHA5rbby1dktnP04oqKkLfR/t/3NyB15/gTEm0OTaW40xjxpjRh/BNfKNMWe1c/8MY0wwdP1KY8x6Y8wNHfMMOkZPDokAAB2LAAQA4LaLrLXxkrIkTZF093F4zAskvdbyRmNMpKQ3JU2QdK6kREknS9or6cTjUFdH2ixpbovfrl8vaUNnP3A7v9F/XtIsSedLSpB0naRbJP2hjesYY0yH/VvFpU6DO0KBy/4/H3bw9T8M/fwkSTpLUq2kXGPMxA58jF2hx0iU9B1JDxpjxrc8iE4OAEBXRwACAOgSrLV7JP1bThAiSTLGXGyMWWOM2Rf6bfq40O03GGP+0eS4jcaY55t8vt0Yk6VWhN5Qz5b0r1buni8pXdIca+1aa23QWltkrf2Jtfa10PnjQrXsC9V2cRuPs8AY80GL21oubfizMeb10G/XlxljBoS6TcqMMeuMMVOanJtvjPlvY8xKY0y5MeY5Y0x0Oy/pHkmrJJ0TOr+fpFMkvdKipudD3Tflxpj3jDETmtzX7DfrxpibjTGbjDGlxphXjDGDWjy3240xGyVtbOX1mCXpbEmXW2tXW2v91tqPJF0r6fYmr8s7xpifGmOWSaqRNNwYMzv0epQbY+6XZFpc+0ZjzBeh1+3fxpiM9upq5evwgDHmn6EOh4+NMSOanH92qOuhPPT1etccw/KbJs/xpiafH/S9cqSstQFr7WZr7dckvSvp3ibXb+vn6Ek53+//CH0PfvsQj2GttS9LKpM0PlT3MmPM74wxeyXda4xJMsY8YYwpNsYUGGN+sD/EMsZEGGN+Y4wpMcZskRNENn1dmnWjGGPuNcY81eTz04wx/wk9j+2hx79F0jxJ3w49h38IAIA2EIAAALoEY8wQSedJ2hT6fLSkRZLulJQip2PjH8bp0nhX0nRjjCf0JjxSTqeGjDPbIV7SyjYe6kRJW6y1Ja3cd5akf1lrq9qo0SfpH5LekJQq6euSnjbGjDniJ+yYK+kHkpIl1Uv6UFJe6PPFkv63lePPlTRM0mRJCw5x/SfkhDqSdLWkv4cep6nXJY2S83zyJD3d2oWMMWdK+nmohoGSCiQ92+KwSyWdJOmg7gA5odPH1trtTW+01n4saYeczpD99neGJEgql/SiDrxOmyWd2qSuSyR9T9Jlcr5P3pfzfXO4dUnOa/MjSX3lfP/9NHTt/V+HuyX1l7ReTojU1b0oabrU/s+RtfY6SdsU6sKy1v6qvYuGft7mSOojJ1yTnNd1i6Q0Oa/bn+R0owyXdIac77/9S2ZulnShnE6vqZKuONwnFAq1Xg9dP0VOULrCWrtQzvfsr0LP4aLDvSYAoPchAAEAuO1lY0ylpO2SiiTdE7r9Kkn/tNYusdY2SvqNpBhJp4TmN1TKeRN0upzOkV3GmLFy3nS9b60NtvF4rS5/CekvaXc7tX5JTrjyC2ttg7X2LUmvSvryYT3Tg71krc211tZJeklSnbX2CWttQNJzct4oNvVHa+0ua22pnCAm61DXlzTDGJMk543oEy0PsNY+Yq2ttNbWy+kaOCF0fEvzJD1irc0LHXu3pJONMZlNjvm5tbbUWlvbyvnJavu13R26f7/HrLVrrLV+OaHYGmvt4tD3we/ldLfsd2vocb8IHf8zSVlNu0AOUZfkfB0+CZ3/tA68rueHHvvF0H1/bPHYh+OPoY6FfcaYvCM892jtktQv9HGbP0dHcL1Bxph9kkrk/HxeZ61dv/+xrLV/Cr0+DXLCpLtD31P5kn4rJ9CSnPDs99ba7aHv4Z8fQQ3XSFpqrV1krW201u611q44gvMBACAAAQC47lJrbYKkGZLG6sAb4UFyugwkSaFAY7ukwaGb3g2dc3ro43fkhB9nhD5vy/lqOwDZK6e7oS2DJG1vEa4UNKnpSBU2+bi2lc9bDoRt+ua7ppX7mwm94f+nnO6J/tbaZU3vDy1J+IVxBr1WSMoP3dXawNeWX48qOa9X0+e+veVJTZSo7dd2YOj+1q4zqOnn1lrb4v4MSX/YHzJIKpWzROZw65Lafl1be+wdh7hWS9+w1vYJ/ck+wnOP1mA5r4N06J+jw7ErVH8/a22WtbZp50/T1zZZkq/p46n5z8egFsc3Pe5Qhsrp/gEA4KgRgAAAugRr7buSHpPzG2rJ+S1201kORs6boJ2hm/YHINNDH7+rQwQgxpgBct5st/Wb+KWSzjHGxLVx/y5JQ03zwZzpTWpqqlpSbIvHdsMTku6S9FQr910j6RI5S3+SJGWGbm9tV5aWX484OR0zTZ+7baeOpZJOMsYMbXqjMeYkOV/Xt9q4zu7Q/fuPN00/l/OG+qtNQoY+1toYa+1/DrOu9uyWNKTFYw9p+/DD1ux7Q1JHf2/MkbMUSDr0z9HRvjb7NT2/RFJj08dT85+PZl/L0H1Ntfe6bJc0Qq071ucAAOglCEAAAF3J7yXNNsacIOlvki4wxswKzd64S878iv1vbN+VNFNSjLV2h5w3fOfKeVO+vI3rnydnxkdbb5ielPNG6wVjzNjQzIP+xpjvGWPOl/SxnA6BbxtjfMaYGZIu0sGzMCTpc0kTjDFZxhlWeu/hvggd7F058zf+1Mp9CXJe071y3nj+rJ3rLJJ0Q+j5RIWO/Ti0zOGQrLVL5eyw84IxZkKo++RLcoKZv1hrDxqcGvJPOa/jZcbZZeQbav7G+K+S7jah4a2hIZxXHk5Nh+GfkiYZYy4NPfbtTR/bGJNpnIGqmUd43RWSLjPGxBpnGOtXjrXQ0Os5zBjzJznB4I9Cdx3q56hQzryOYxZauvU3ST81xiSEliH9lw6Eb3+T9A1jzBBjTF9J321xiRWSrg79bLWcEfK0pLOMMXONMd7Qz2VWRz8HAEDPRgACAOgyrLXFcjoW/ic0Y+BaOW/cS+QEDRdZaxtCx26QVKXQb7qttRVyhjEuC70Ra0178z8Umm1xlqR1kpZIqpD0iZzW/o9Dj32RnCClRNKfJc231q5r5VobJP1YTufDRknHtMvH0Qrt3PFmaOZCS0/IWYawU9JaSR+1c52lkn4o6QU5v8kfIWfew5G4XNLbcnbgqZLzxvhhOcNk23rcEklXSvqFnKBmlKRlTe5/SdIvJT0bWsazWs7X55g1eexfhR57vKTPdGCQ7FAdeP2OxO/kzMsolPS42hg8e5hONsZUyflefUfOVrXTrLWrQs+h3Z8jOXM4fhBaQvTfx1DHfl+X08mxRc73/DOSHgnd96CceT2fy+nCerHFuT+U831VJifAeWb/HdbabXKWr90lZ3nPCkknhO5+WM6uNPuMMS93wHMAAPRQpu1fggEA0HOEfoO/R9LwUFiCQzDGPCFpk7X2x27X0hWElj7tkDTPWvu2MeYHkoqttf/ncmkAAOAweN0uAACA46SfpB8SfhyeUGA0Rk4nTK9ljDlHztKnWknfkjMf5SNJstbe52JpAADgCLEEBgDQK1hri6y1f3G7jm5kj6R9cpa89GYny9l9ZP/ykUvb2U4XAAB0YSyBAQAAAAAAPR4dIAAAAAAAoMcjAAEAAAAAAD2ea0NQk5OTbWZmplsPDwAAAAAAepjc3NwSa21Ka/e5FoBkZmbqs88+c+vhAQAAAABAD2OMKWjrPpbAAAAAAACAHo8ABAAAAAAA9HgEIAAAAAAAoMcjAAEAAAAAAD0eAQgAAAAAAOjxCEAAAAAAAECPRwACAAAAAAB6PAKQVuzZs0dXX321RowYoZycHJ1//vnasGFDm8fPmDFDY8aMUVZWlsaNG6eFCxeG78vMzFRJSUmr5/3+979XdHS0ysvLw7fV1NRo3rx5mjRpkiZOnKjTTjtNVVVVeumll5SVldXsj8fj0euvv95xT7wXM8borrvuCn/+m9/8Rvfee2+757zzzjtKSkrSlClTNGbMGJ1++ul69dVXD/lYL7/8stauXXusJfdoR/P1+P73v9/s52P06NGKiIhQVVWV7r33Xv3mN785ppra+1kGAAAA0PURgLRgrdWcOXM0Y8YMbd68Wbm5ufr5z3+uwsLCds97+umntWLFCi1btkzf+c531NDQcMjHWrRokaZNm6YXX3wxfNsf/vAHpaWladWqVVq9erUefvhh+Xw+zZkzRytWrAj/+drXvqbp06frnHPOOebnDCkqKkovvvjiEb/BnT59upYvX67169frj3/8o+644w69+eab7Z5DAHJoR/P1+OlPf9rsZ2TatGm6++67FR8ff8z1BAKBY74GAAAAAHcRgLTw9ttvy+fz6dZbbw3fdsIJJygQCOjCCy8M33bHHXfoscceO+j8qqoqxcXFKSIiot3H2bx5s6qqqnTfffdp0aJF4dt3796twYMHhz8fM2aMoqKimp27YcMG/fjHP9aTTz4pj8ejYDCor33taxo7dqxmz56t888/X4sXL5Yk5ebm6owzzlBOTo7OOecc7d69W5LTtfLNb35TU6dO1bhx4/Tpp5/qsssu06hRo/SDH/xAkpSfn6+xY8dqwYIFGj16tObNm6elS5fq1FNP1ahRo/TJJ58c5qva9Xm9Xt1yyy363e9+d9B9CxYs0K233qqpU6dq9OjRbXZ5ZGVl6X/+5390//33S3JevzPPPFOTJ0/WrFmztG3bNv3nP//RK6+8om9961vKysrS5s2bO/V5dVfH+vV46qmntGnTpmZdI2vXrtWMGTM0fPhw/fGPf2x27IknnqisrCx99atfDYcd8fHxuuuuu3TCCSfoww8/DB9fW1ur8847Tw8++GAHPmMAAAAAnc3rdgFtev270p5VHXvNAZOk837R7iGrV69WTk7OEV963rx5ioqK0saNG/X73//+kAHIs88+q6uvvlrTp0/X+vXrVVhYqLS0NN144406++yztXjxYs2aNUvXX3+9Ro0aFT6vsbFR11xzjX77298qPT1dkvTiiy8qPz9fa9euVVFRkcaNG6cbb7xRjY2N+vrXv66///3vSklJ0XPPPafvf//7euSRRyRJkZGR+uyzz/SHP/xBl1xyiXJzc9WvXz+NGDFC3/zmNyVJmzZt0vPPP69HHnlE06ZN0zPPPKMPPvhAr7zyin72s5/p5ZdfPuLXqj17fvYz1X+xrkOvGTVurAZ873uHPO7222/X5MmT9e1vf/ug+/Lz8/XJJ59o8+bNmjlzpjZt2tTqNbKzs/XrX/9akvT1r39d119/va6//no98sgj+sY3vqGXX35ZF198sS688EJdccUVx/bEjoO3H1uoooItHXrN1IzhmrnglkMed6Rfj+jo6PB93/3ud/XOO+/I6z3wn7h169bp7bffVmVlpcaMGaPbbrtNmzZt0nPPPadly5bJ5/Ppa1/7mp5++mnNnz9f1dXVOumkk/Tb3/42fI2qqipdffXVmj9/vubPn98BrwYAAACA4+WQHSDGmGhjzCfGmM+NMWuMMT9q5ZgFxphiY8yK0J+bOqfcruvpp5/WypUrtW3bNv3mN79RQUFBu8cvWrRIV199tTwejy6//HI9//zzkpwugi1btuhb3/qWSktLNW3aNH3xxRfh8374wx9qwoQJuuqqq8K3ffDBB7ryyivl8Xg0YMAAzZw5U5K0fv16rV69WrNnz1ZWVpbuu+8+7dixI3zexRdfLEmaNGmSJkyYoIEDByoqKkrDhw/X9u3bJUnDhg3TpEmT5PF4NGHCBM2aNUvGGE2aNEn5+fkd8tp1FYmJiZo/f36z7oD95s6dK4/Ho1GjRmn48OFat671kMZaG/74ww8/1DXXXCNJuu666/TBBx90TuE91NF8PQKBgK699lr95Cc/0ciRI5udc8EFFygqKkrJyclKTU1VYWGh3nzzTeXm5mratGnKysrSm2++qS1bnMAnIiJCl19+ebNrXHLJJbrhhhsIPwAAAIBu6HA6QOolnWmtrTLG+CR9YIx53Vr7UYvjnrPW3tFhlR2iU6OzTJgwIbx8pCmv16tgMBj+vK6urtXzU1JSlJ2drY8//lgZGRmtHrNq1Spt3LhRs2fPliQ1NDRo2LBhuuMO5+WLj4/XZZddpssuu0wej0evvfaaxo0bp3feeUcvvPCC8vLyDuu5WGs1YcKEZu37Te1fWuPxeJots/F4PPL7/c2OaXlc02M60uF0anSmO++8U9nZ2brhhhua3W6Maffz/ZYvX65x48Z1Wn3H2+F0anSmI/163HfffRo4cOBBx0vNv5cjIiLk9/tlrdX111+vn//85wcdHx0dfVAn16mnnqp//etfuuaaa9r8HgAAAADQNR2yA8Q6qkKf+kJ/bDundGtnnnmm6uvrm+3ksnLlSllrtXbtWtXX12vfvn1tDrqsqanR8uXLNWLEiDYfY9GiRbr33nuVn5+v/Px87dq1S7t27VJBQYGWLVumsrIySU4wsnbtWmVkZKisrEw33HCDnnjiCSUkJDS73qmnnqoXXnhBwWBQhYWFeueddyQ580OKi4vDAUhjY6PWrFlzLC9Pj9evXz/NnTtXDz/8cLPbn3/+eQWDQW3evFlbtmzRmDFjDjp35cqV+slPfqLbb79dknTKKafo2WefleR0CE2fPl2SlJCQoMrKyk5+Jj3DkXw9PvroIz322GPNfnYPZdasWVq8eLGKiookSaWlpe12b/34xz9W3759w19jAAAAAN3HYc0AMcZESMqVNFLSA9baj1s57HJjzOmSNkj6prV2e8eVefwYY/TSSy/pzjvv1C9/+UtFR0crMzNTv//97zV37lxNnDhRw4YN05QpU5qdN2/ePMXExKi+vl4LFixoNkdk8uTJ8nicrGnu3Ll6+eWX9dprrzU7f86cOXr22Wc1cOBA3XbbbbLWKhgM6oILLtDll1+uX/ziFyoqKtJtt93W7Ly7775bV155pd58802NHz9eQ4cOVXZ2tpKSkhQZGanFixfrG9/4hsrLy+X3+3XnnXdqwoQJnfTq9Qx33XVXeJDpfunp6TrxxBNVUVGhv/71r+F5E++//76mTJmimpoapaam6o9//KNmzZolSfrTn/6kG264Qb/+9a+VkpKiRx99VJJ09dVX6+abb9Yf//hHLV68uN2wDIf/9bjnnntUU1MTXgK23wsvvNDmtcePH6/77rtPZ599toLBoHw+nx544IE2u7ckZ6emG2+8Ud/+9rf1q1/96tieHAAAAIDjxjSdWXDIg43pI+klSV+31q5ucnt/SVXW2npjzFclXWWtPbOV82+RdIskpaen5xxqTgYOX1VVleLj47V3716deOKJWrZsmQYMGOB2WT3CggULus3Q0t6ArwcAAACAthhjcq21U1u774h2gbHW7jPGvC3pXEmrm9y+t8lhD0lq9dei1tqFkhZK0tSpU3vsMho3XHjhhdq3b58aGhr0wx/+kPADAAAAAIAmDtkBYoxJkdQYCj9iJL0h6ZfW2lebHDPQWrs79PEcSd+x1n6pvetOnTrVfvbZZ8f8BAAAAAAAAKRj7wAZKOnx0BwQj6S/WWtfNcb8WNJn1tpXJH3DGHOxJL+kUkkLOqZ0AAAAAACAY3dEM0A6Eh0gAAAAAACgI7XXAXLIbXABAAAAAEDP11hfp8+XvCa3GiU62xENQQUAAAAAAD3P1hW5WvrQn1VRXKj+QzM0ZOwEt0vqcHSAtGLPnj26+uqrNWLECOXk5Oj888/Xhg0b2jx+xowZGjNmjLKysjRu3DgtXLgwfF9mZqZKSkpaPe/3v/+9oqOjVV5eHr6tpqZG8+bN06RJkzRx4kSddtppqqqq0ksvvaSsrKxmfzwej15//XW98847uvDCC4/pOS9YsECLFy8+pmt0Z8YY3XXXXeHPf/Ob3+jee+9t95zvf//7zb4eo0ePVkREhKqqqjq5WgAAAADoGNX7yvTqH36lF39+j7w+n6665xc9MvyQ6AA5iLVWc+bM0fXXX69nn31WkvT555+rsLBQo0ePbvO8p59+WlOnTlVpaalGjBihBQsWKDIyst3HWrRokaZNm6YXX3xRN9xwgyTpD3/4g9LS0rRq1SpJ0vr16+Xz+TRnzhzNmTMnfO7ChQv19NNP65xzztF77713TM/Z7/cf0/k9QVRUlF588UXdfffdSk5OPqxzfvrTn+qnP/1p+PN58+Zp7ty5io+P76wyAQAAAKBD2GBQq956Q+8986j89fU65cp5mnbJFfL6fG6X1mnoAGnh7bffls/n06233hq+7YQTTlAgEGjWZXHHHXfoscceO+j8qqoqxcXFKSIiot3H2bx5s6qqqnTfffdp0aJF4dt3796twYMHhz8fM2aMoqKimp27YcMG/fjHP9aTTz4pj8cTftwrrrhCY8eO1bx588JrtnJzc3XGGWcoJydH55xzjnbv3i3J6Vq58847NXXqVP3hD39odv0f/vCHWrBggQKBQLvPoSfxer265ZZb9Lvf/e6g+xYsWKBbb71VU6dO1ejRo/Xqq68edMxTTz2lTZs2hbtGiouLNXv2bE2YMEE33XSTMjIywp1ATz31lE488URlZWXpq1/9avh1jo+P17e+9S1NmDBBZ511lj755BPNmDFDw4cP1yuvvCJJeuyxx3TppZdq9uzZyszM1P3336///d//1ZQpU/SlL31JpaWlnfQKAQAAAOgp9u7Ypud+9F0tefB+pWYM1/xf36+Tr/hyjw4/pC7cAfLLT36pdaXrOvSaY/uN1XdO/E67x6xevVo5OTlHfO158+YpKipKGzdu1O9///tDBiDPPvusrr76ak2fPl3r169XYWGh0tLSdOONN+rss8/W4sWLNWvWLF1//fUaNWpU+LzGxkZdc801+u1vf6v09PTw7cuXL9eaNWs0aNAgnXrqqVq2bJlOOukkff3rX9ff//53paSk6LnnntP3v/99PfLII5KkhoYG7d+JZ8GCBZKkb33rW6qsrNSjjz4qY8wRvw7H6v2/bVDJ9o5dQpI8NF7T57bdvbPf7bffrsmTJ+vb3/72Qffl5+frk08+0ebNmzVz5kxt2rRJ0dHR4fu++93v6p133pHX6/xI/ehHP9KZZ56pu+++W//617/08MMPS5K++OILPffcc1q2bJl8Pp++9rWv6emnn9b8+fNVXV2tM888U7/+9a81Z84c/eAHP9CSJUu0du1aXX/99br44oslOd+jy5cvV11dnUaOHKlf/vKXWr58ub75zW/qiSee0J133tlBrxwAAACAnsTf0KCPX3pOn/z9BUXGxOic2+7UhDNmufLezw1dNgDpbvYvgSkuLtYpp5yic889VxkZGW0ev2jRIr300kvyeDy6/PLL9fzzz+uOO+5QVlaWtmzZojfeeENLly7VtGnT9OGHH2rcuHGSnO6MCRMm6Kqrrmp2vRNPPFFDhgyRJGVlZSk/P199+vTR6tWrNXv2bElSIBDQwIEDw+e0vMZPfvITnXTSSc1mmPQmiYmJmj9/vv74xz8qJiam2X1z586Vx+PRqFGjNHz4cK1bt05ZWVkKBAK69tpr9ZOf/EQjR44MH//BBx/opZdekiSde+656tu3ryTpzTffVG5urqZNmyZJqq2tVWpqqiQpMjJS5557riRp0qRJioqKks/n06RJk5Sfnx++9syZM5WQkKCEhAQlJSXpoosuCp+zcuXKznlxAAAAAHRrBatWaOlDD2jfnt0aP32mzph/k2ITk9wu67jqsgHIoTo1OsuECRNaHQbq9XoVDAbDn9fV1bV6fkpKirKzs/Xxxx+3GYCsWrVKGzduDAcTDQ0NGjZsmO644w5JzlKIyy67TJdddpk8Ho9ee+01jRs3Tu+8845eeOEF5eXlHXTNpstkIiIi5Pf7Za3VhAkT9OGHH7ZaR1xcXLPPp02bptzcXJWWlqpfv36tntPZDqdTozPdeeedys7ODs9k2a9lIrr/8/vuu08DBw486Pi2WGt1/fXX6+c///lB9/l8vvB1PR5P+Gvq8XiazWlp+rVu7zgAAAAAqKko17tPPqy1772lPgMG6oof3KeMSVlul+UKZoC0cOaZZ6q+vr5ZF8TKlStlrdXatWtVX1+vffv26c0332z1/JqaGi1fvlwjRoxo8zEWLVqke++9V/n5+crPz9euXbu0a9cuFRQUaNmyZSorK5PkBCNr165VRkaGysrKdMMNN+iJJ55QQkLCYT2XMWPGqLi4OByANDY2as2aNW0ef+655+q73/2uLrjgAlVWVh7WY/Q0/fr109y5c8NLVvZ7/vnnFQwGtXnzZm3ZskVjxozRRx99pMcee6zVjplTTz1Vf/vb3yRJb7zxRvhrOmvWLC1evFhFRUWSpNLSUhUUFHTyswIAAADQ21hrtfqdpXr0v27TumXv6aQ5V2n+r+/vteGH1IU7QNxijNFLL72kO++8U7/85S8VHR2tzMxM/f73v9fcuXM1ceJEDRs2TFOmTGl23rx58xQTE6P6+notWLCg2RyRyZMnh4eVzp07Vy+//LJee+21ZufPmTNHzz77rAYOHKjbbrtN1loFg0FdcMEFuvzyy/WLX/xCRUVFuu2225qdd/fddystLa3V5xIZGanFixfrG9/4hsrLy+X3+3XnnXdqwoS2tzS68sorVVlZqYsvvlivvfbaQUtBeoO77rpL999/f7Pb0tPTdeKJJ6qiokJ//etfFR0drXvuuUc1NTWaOXNms2NfeOEF3XPPPfryl7+sJ598UieffLIGDBighIQEJScn67777tPZZ5+tYDAon8+nBx54oN3lUgAAAABwJEp37dDSBx/Q9rWrNGjMeM2++XYlD+U9h9m/W8jxNnXqVLt/ACfQlS1YsEAXXnihrrjiisM+p76+XhEREfJ6vfrwww912223acWKFZ1XJAAAAIBez9/YqE//vlgfv/ScvFFROn3eDZo082wZT+9Z/GGMybXWTm3tPjpAgE6wbds2zZ07V8FgUJGRkXrwwQfdLgkAAABAD7Zj7WotefB+le7aoTGnnK6Z19+suD593S6rS6EDBAAAAACAbqq2qlLvPfWoVr/9hpJS0zTrK1/TsKycQ5/YQ9EBAgAAAABAD2Kt1boP3tHbTzykuqpKTbv4cp18xZfli4p2u7QuiwAEAAAAAIBuZN+e3Vr68J9VsHK5Bo4co9k/uE8pGcPcLqvLIwABAAAAAKAbCPgb9dk/XtJHLzwrj9erWTfepsmzz5XHE+F2ad0CAQgAAAAAAF3czvVfaOmD96tke4FGnXSKzlzwVcX36+92Wd0KAQgAAAAAAF1UXXWVPlj0uD5f8roS+qfo0m//UCNyTnK7rG6JAAQAAAAAgC7GWqsNH32gtx9bqJrycuVccIlOmXutIqNj3C6t2yIAAQAAAACgCykvKtSbj/xFW5d/prThIzXnO/cobfhIt8vq9ghAAAAAAADoAoKBgHJf+7v+8/zTMjKaMf9mTTn3QnkiGHLaEQhAAAAAAABw2Z5NG/TGg/erOH+LRkw9SWfecKsSk1PcLqtHIQABAAAAAMAl9TU1Wvbck1r+71cV36evLv6v72nkiSfLGON2aT0OAQgAAAAAAC7Y+OmHeuuRv6qqrFRZZ1+g066+TlGxcW6X1WMRgAAAAAAAcBxVlBTrrUf/T5s/+0gp6Zm6+L++p4GjxrhdVo9HAAIAAAAAwHEQDAa04l+v6oPnnpINBnX6vBuUff4livDy1vx44FUGAAAAAKCTFW7drCUL71fhlo3KzMrRWV+5TUmpA9wuq1chAAEAAAAAoJM01NXqP397WnmvvaKYxERd8P++rTEnT2fIqQsIQAAAAAAA6ARb8j7V0of/rMqSYk0+61xN//ICRcfHu11Wr0UAAgAAAABAB6oq3au3H1uoDR8vU/8h6br6R7/S4LHj3S6r1yMAAQAAAACgA9hgUJ8veV3vL3pcAX+jTrt6vqZeNEcRXp/bpUEEIAAAAAAAHLPibflasvBP2r1xvdInnqCzbr5dfQcMcrssNEEAAgAAAADAUWqsr9OHLzyr3FdfUlRsnM674y6NO20GQ067IAIQAAAAAACOQv6KXC19+M8qLyrUxJmzdfq8GxSTkOh2WWgDAQgAAAAAAEegel+Z3nniIa1b9q76Dhqiuff8XEPHT3K7LBwCAQgAAAAAAIfBBoNa9fYSvff0I/LX1+vkK67RiZdeKa+PIafdAQEIAAAAAACHsHfHdi158H7tXLdGQ8ZP1Fk33a7+g4e6XRaOAAEIAAAAAABt8Dc06OOX/6ZPXl6syJgYnXPr/9OEGWcx5LQbIgABAAAAAKAV21Z/rqUPPaCy3bs0fvpMnTH/JsUmJrldFo4SAQgAAAAAAE3UVJTrvace0Zp331SftIG64vv3KWNylttl4RgRgAAAAAAAIMlaq7XvvaV3nnxYDTXVOmnOXJ102VXyRUa5XRo6AAEIAAAAAKDXK921U0sfekDb16zUoNHjNPuWO5Q8NMPtstCBCEAAAAAAAL2Wv7FRn76yWB+/9Dd5fZE666bbNXnWOTIej9uloYMRgAAAAAAAeqUdX6zWkgcfUOnO7Rpz8nTNXHCL4vr0dbssdBICEAAAAABAr1JbVan3n35Uq956Q4kpqbrsu/dq2JSpbpeFTkYAAgAAAADoFay1WrfsXb3zxEOqrazQ1Isu0ylXXCNfdLTbpeE4IAABAAAAAPR4+/bs1tKH/6yClcs1YORoXf69Hys1c7jbZeE4IgABAAAAAPRYAb9fn736kj5avEgeb4TOvOGrOuHs8+XxRLhdGo4zAhAAAAAAQI+0a8MXWrLwfpVsL9CoE0/RzBtuUUK/ZLfLgksIQAAAAAAAPUpddZU+WPSEPl/6uuL79dcl3/qhRk49ye2y4DICEAAAAABAj2Ct1YaPluntx/5PNeXlyj7vYp06d54iY2LdLg1dAAEIAAAAAKDbqygu0puP/EVb8j5V6rARmvOde5Q2fKTbZaELIQABAAAAAHRbwUBAea+/omV/e0pGRjPm36Qp514kTwRDTtEcAQgAAAAAoFvas3mjliy8X0X5mzU850TNuvFWJSanul0WuigCEAAAAABAt9JQW6Nlzz2l5f96VbF9+uii/7pbo048RcYYt0tDF0YAAgAAAADoNjZ9+pHefPSvqirdq6yzz9dpV89XVGyc22WhGyAAAQAAAAB0eZV7S/TWo3/Vpk8/UnJ6pi6687saNHqs22WhGyEAAQAAAAB0WcFgQCv+/ZqWPfeEgoGgpl+zQDkXXKoIL29ncWT4jgEAAAAAdElF+Vu0ZOGftGfzRmWekK1ZX/ma+qQNcLssdFMEIAAAAACALqWxrk7/WfyMcv/5smISEnXBN76lMaeczpBTHBMCEAAAAABAl7Fl+ad68+G/qKK4SJNmnaPTr7lB0fHxbpeFHoAABAAAAADguqqyUr392EJt+OgD9R+Srqt+9EsNGTvB7bLQgxCAAAAAAABcY4NBrXzzX3r/mcflb2zQqVddp2kXX6YIr8/t0tDDEIAAAAAAAFxRsi1fbzx4v3ZvWKf0iZN11k23q+/AwW6XhR6KAAQAAAAAcFw1NtTroxee1Wf/eFFRsXE67/b/0rjpMxlyik5FAAIAAAAAOG7yVy7X0oceUHnhHk044yydfu0Nik1Mcrss9AIEIAAAAACATldTvk9vP/6g1i17V30HDtbc//mZhk6Y7HZZ6EUIQAAAAAAAncZaq9VvL9F7Tz2ixvo6nXzFl3XiJVfKGxnpdmnoZQhAAAAAAACdYu/O7Vr64APa8cVqDRk3UWfdfLv6Dx7qdlnopQhAAAAAAAAdyt/QoI9ffl6fvPy8IqOjdfat39DEM86S8XjcLg29GAEIAAAAAKDDbFu9UksfekBlu3dq3GkzNGP+TYpN6uN2WQABCAAAAADg2NVWVujdJx/RmneXqk/aQF3+/Z8oc/IUt8sCwghAAAAAAABHzVqrte+9pXeffFj1NdU6ac5cnXTZVfJFRrldGtAMAQgAAAAA4KiU7d6ppQ/9WdtWf66Bo8fq7JvvUHJ6pttlAa0iAAEAAAAAHJGAv1Gf/v0FffTSc/L6InXWTV/T5FnnMuQUXRoBCAAAAADgsO1Yt0ZLFt6v0p3bNfrk6Zp5/c2K79vP7bKAQyIAAQAAAAAcUl1Vld575lGtevPfSkxJ1Zzv3qPhU6a5XRZw2AhAAAAAAABtstZq3X/e0zuPP6jaygpNvegynXLFNfJFR7tdGnBEDhmAGGOiJb0nKSp0/GJr7T0tjomS9ISkHEl7JV1lrc3v8GoBAAAAAMdNedEeLX3oz8r/PE8DRozS5d/7sVIzh7tdFnBUDqcDpF7SmdbaKmOMT9IHxpjXrbUfNTnmK5LKrLUjjTFXS/qlpKs6oV4AAAAAQCcL+P3K/efL+nDxIhmPRzMXfFVZ55wvjyfC7dKAo3bIAMRaayVVhT71hf7YFoddIune0MeLJd1vjDGhcwEAAAAA3cSuDeu05MH7VbItXyOnnawzb/iqEvonu10WcMwOawaIMSZCUq6kkZIesNZ+3OKQwZK2S5K11m+MKZfUX1JJB9YKAAAAAOgk9TXVen/RE/p8yWuK79dfl/z3DzRy2pfcLgvoMIcVgFhrA5KyjDF9JL1kjJlorV19pA9mjLlF0i2SlJ6efqSnAwAAAAA6mLVWGz9eprceW6iaffuUfe5FOvWqaxUZE+t2aUCHOqJdYKy1+4wxb0s6V1LTAGSnpKGSdhhjvJKS5AxDbXn+QkkLJWnq1KksjwEAAAAAF1WUFOnNh/+iLXmfKjVzhC791g81YMQot8sCOsXh7AKTIqkxFH7ESJotZ8hpU69Iul7Sh5KukPQW8z8AAAAAoGsKBgJa/q9/aNlzT8nK6ozrvqLs8y6WJ4Ihp+i5DqcDZKCkx0NzQDyS/matfdUY82NJn1lrX5H0sKQnjTGbJJVKurrTKgYAAAAAHLXCLZv0xsI/qWjrZg3PnqZZN96mxJRUt8sCOt3h7AKzUtKUVm7/nyYf10m6smNLAwAAAAB0lIbaGi3729Na/vo/FNunjy765nc16qRTZYxxuzTguDiiGSAAAAAAgO5n02cf661H/qrK0hKdMPt8Tf/yfEXFxrldFnBcEYAAAAAAQA9VWVqitx9dqI2f/EfJ6Zm68M5va9DocW6XBbiCAAQAAAAAephgMKDP33hNHzz7hIKBoKZfs0A5F1yqCC9vAdF78d0PAAAAAD1IUf4WLXnwfu3ZtEEZk6forJtuV5+0AW6XBbiOAAQAAAAAeoDGujr9Z/Ezyv3ny4pJSNT5X/9vjT31DIacAiEEIAAAAADQzW1d/pmWPvwXVRQXatKZZ2v6vBsUE5/gdllAl0IAAgAAAADdVPW+Mr392EKt//B99Rs8VFfd+wsNGTfR7bKALokABAAAAAC6GRsMauWb/9b7zzwmf2ODTpk7T9MuvkJen8/t0oAuiwAEAAAAALqRkm35WvLgA9q14QsNnTBZZ910u/oNGux2WUCXRwACAAAAAN1AY0O9Pn7xOX36yguKjI3TuV/7psaffiZDToHDRAACAAAAAF1cwcoVWvrQA9pXuFsTzpil06+9UbGJSW6XBXQrBCAAAAAA0EXVlO/TO08+rC/ef1t9Bw7SlT/8mdInTna7LKBbIgABAAAAgC7GWqvV7yzRe089qobaWn3p8qt10qVz5Y2MdLs0oNsiAAEAAACALqR01w4tefB+7Vi7WoPHTtDsm+9Q/yFD3S4L6PYIQAAAAACgC/A3NuqTl/+mT15+Xt6oKM2+5euaNHO2jMfjdmlAj0AAAgAAAAAu2752lZY8+IDKdu3Q2FPP0Iz5NymuT1+3ywJ6FAIQAAAAAHBJbWWF3n3qEa15Z6mS0gbo8u/9WJknZLtdFtAjEYAAAAAAwHFmrdUXH7yjdx5/UPU11Trxkiv0pcuvli8q2u3SgB6LAAQAAAAAjqOyPbu09KE/a9uqFRo4eqxm33yHUtIz3S4L6PEIQAAAAADgOAj4G/XpKy/qoxefVYTXp1lf+ZpOOOtchpwCxwkBCAAAAAB0sp3r1mrJg/dr745tGv2l0zRzwS2K79vP7bKAXoUABAAAAAA6SV1Vld5/5jGtfPNfSkhO0aXf/h+NyDnR7bKAXokABAAAAAA6mLVW6z98X28/tlC1FRXKuXCOTrnyGkVGx7hdGtBrEYAAAAAAQAcqL9qjpQ//RfkrcpU2fJQuu/tHShs2wu2ygF6PAAQAAAAAOkDA71fuP1/Wh4sXyXg8mrngFmWdc4E8ngi3SwMgAhAAAAAAOGa7N67XkoV/UvG2fI2Y+iWdecNXlZic4nZZAJogAAEAAACAo1RfU6MPnn1cK954TfF9++ni//6+Rk072e2yALSCAAQAAAAAjpC1Vps++VBvPfpXVe0r05RzL9Spc69TVGys26UBaAMBCAAAAAAcgYqSYr35yF+0JfcTpWQO1yX//QMNGDna7bIAHAIBCAAAAAAchmAwoOWvv6plzz0pK6szrr1R2edfIk8EQ06B7oAABAAAAAAOoXDLJi158H4VbtmkYVOmataNtykpNc3tsgAcAQIQAAAAAGhDQ12t/vO3p5T32j8Um5SkC+/8rkZ/6VQZY9wuDcARIgABAAAAgFZszv1Ybz78V1WWluiEs87TaV+er+i4eLfLAnCUCEAAAAAAoImq0r1667H/08aP/6PkoRm68M5fadDocW6XBeAYEYAAAAAAgJwhp58veV0fLHpcQX9Ap335ek29cI4ivLxtAnoCfpIBAAAA9HrFBVu1ZOH92r1pvTImT9FZX/ma+gwY6HZZADoQAQgAAACAXquxvk4fLl6kz159SdHxCTr/6/+tsaeewZBToAciAAEAAADQK21dkaulD/1ZFcWFmjjzbJ1+7Q2KiU9wuywAnYQABAAAAECvUr2vTG8//qDW/+c99Rs0RFfd8wsNGT/R7bIAdDICEAAAAAC9gg0GteqtN/TeM4/KX1+vU66cp2mXXCGvz+d2aQCOAwIQAAAAAD1eyfYCLXnwAe1av1ZDx0/SWTffrn6DhrhdFoDjiAAEAAAAQI/V2FCvj1/8mz595QVFxsTonNvu1IQzZjHkFOiFCEAAAAAA9EgFq1Zo6UMPaN+e3Rp/+pk647qvKDYxye2yALiEAAQAAABAj1JTUa53n3hIa99/W30GDNQVP7hPGZOy3C4LgMsIQAAAAAD0CNZarXlnqd596hE11NbqS5ddpZPmXCVvZKTbpQHoAghAAAAAAHR7pbt2aOmDD2j72lUaNGa8zr7lDvUfku52WQC6EAIQAAAAAN2Wv7FRn/59sT5+6Tl5o6I0+5Y7NGnm2TIej9ulAehiCEAAAAAAdEs71q7WkgfvV+muHRp76hmaMf8mxfXp63ZZALooAhAAAAAA3UptVaXee+pRrX77DSWlpumyu3+kYVk5bpcFoIsjAAEAAADQLVhrte6Dd/T2Ew+prqpS0y65QidffrV8UdFulwagGyAAAQAAANDl7duzW0sf/rMKVi7XwJFjNPsH9yklY5jbZQHoRghAAAAAAHRZAX+jPvvHS/rohWfl8Xo168bbNHn2ufJ4ItwuDUA3QwACAAAAoEvauf4LLX3wfpVsL9Dok07VzAW3KL5ff7fLAtBNEYAAAAAA6FLqqqv0waLH9fmS15WQnKJLv/0/GpFzottlAejmCEAAAAAAdAnWWm346AO9/dhC1ZSXK+eCS3TK3GsVGR3jdmkAegACEAAAAACuKy8q1JuP/EVbl3+mtOEjNec79yht+Ei3ywLQgxCAAAAAAHBNMBBQ7mt/13+ef1pGRjPm36wp514oTwRDTgF0LAIQAAAAAK7YvWm9liy8X8UFWzVi6kk684ZblZic4nZZAHooAhAAAAAAx1V9TY2WPfeklv/7VcX36auL7/qeRk47WcYYt0sD0IMRgAAAAAA4bjZ+8h+99ej/qaqsVFlnX6DTrp6vqNhYt8sC0AsQgAAAAADodBUlxXrr0f/T5s8+UkrGMF181/c0cOQYt8sC0IsQgAAAAADoNMFgQCv+9ao+eO4p2WBQp8+7QdnnX6IIL29FABxf/FcHAAAAQKco3LpZSxber8ItGzUsK0ezvvI1JaWmuV0WgF6KAAQAAABAh2qoq9V//va08l57RTGJibrwzu9o9JdOY8gpAFcRgAAAAADoMFvyPtXSh/+sypJiTT7rXE2/ZoGi4+LdLgsACEAAAAAAHLuq0r16+7GF2vDxMvUfkq6rf/xrDR4zzu2yACCMAAQAAADAUbPBoD5f8rreX/S4gn6/Trt6vqZeNEcRXp/bpQFAMwQgAAAAAI5K8bZ8LVn4J+3euF7pk7J01k1fU98Bg9wuCwBaRQACAAAA4Ig01tfpwxeeVe6rLykqLl7n33GXxp42gyGnALo0AhAAAAAAhy1/Ra6WPvxnlRcVauLM2Tp93g2KSUh0uywAOCQCEAAAAACHVL2vTO888ZDWLXtXfQcN0dx7fq6h4ye5XRYAHDYCEAAAAABtssGgVr39ht57+lH56+t18hXX6MRLr5TXx5BTAN0LAQgAAACAVu3dsU1LHrxfO9et1ZDxE3XWTber/+ChbpcFAEeFAAQAAABAM/6GBn380nP65O8vKDImRufc+v80YcZZDDkF0K0RgAAAAAAI27b6cy196AGV7d6l8dNn6oz5Nyk2McntsgDgmBGAAAAAAFBNRbneffJhrX3vLfVJG6grvn+fMiZnuV0WAHQYAhAAAACgF7PWau17b+mdJx9WQ021TppzlU66bK58kVFulwYAHYoABAAAAOilSnft1NKHHtD2NSs1aPQ4zb7lDiUPzXC7LADoFIcMQIwxQyU9ISlNkpW00Fr7hxbHzJD0d0lbQze9aK39cYdWCgAAAKBD+Bsb9ekri/XxS3+T1xep2TffoUlnni3j8bhdGgB0msPpAPFLustam2eMSZCUa4xZYq1d2+K49621F3Z8iQAAAAA6yo4vVmvJgw+odOd2jTnldM28/mbF9enrdlkA0OkOGYBYa3dL2h36uNIY84WkwZJaBiAAAAAAuqjaqkq9//SjWvXWG0pMSdNl371Xw6ZMdbssADhujmgGiDEmU9IUSR+3cvfJxpjPJe2S9N/W2jXHXh4AAACAY2Gt1bpl7+qdJx5SbWWFpl18uU6+/MvyRUe7XRoAHFeHHYAYY+IlvSDpTmttRYu78yRlWGurjDHnS3pZ0qhWrnGLpFskKT09/WhrBgAAAHAY9u3ZraUP/1kFK5drwMjRuvx7P1Zq5nC3ywIAVxhr7aEPMsYn6VVJ/7bW/u9hHJ8vaaq1tqStY6ZOnWo/++yzIygVAAAAwOEI+P367NWX9NHiRfJ4I3Tal6/XCbPPk8cT4XZpANCpjDG51tpW1/cdzi4wRtLDkr5oK/wwxgyQVGittcaYEyV5JO09hpoBAAAAHIVdG77QkoX3q2R7gUaddIpmLrhFCf2S3S4LAFx3OEtgTpV0naRVxpgVodu+Jyldkqy1f5V0haTbjDF+SbWSrraH01oCAAAAoEPUVVfpg0VP6POlryuhX7Iu/fYPNSLnJLfLAoAu43B2gflAkjnEMfdLur+jigIAAABweKy12vDRMr392P+pprxcOedfrFPmXqvI6Bi3SwOALuWIdoEBAAAA0HVUFBfpzUf+oi15nyp12AjN+c49Shs+0u2yAKBLIgABAAAAuplgIKC81/6uZc8/LSOjGfNv0pRzL5IngiGnANAWAhAAAACgG9mzaYPeePB+Fedv0fCcEzXrxluVmJzqdlkA0OURgAAAAADdQENtjT547kmt+Nc/Fdunjy76r7s16sRT5GzaCAA4FAIQAAAAoIvb+OmHeuuRv6qqrFRZZ5+v066er6jYOLfLAoBuhQAEAAAA6KIq95borUf/qk2ffqSU9Exd9M27NWj0WLfLAoBuiQAEAAAA6GKCwYBW/Ps1LXvuCQUDQU2/ZoFyLrhUEV7++Q4AR4v/ggIAAABdSFH+Fi1Z+Cft2bxRmVk5OusrtykpdYDbZQFAt0cAAgAAAHQBjXV1+s/iZ5T7z5cVk5CoC77xLY055XSGnAJAByEAAQAAAFy2ZfmnevPhv6iiuEiTZ52r6dcsUHR8vNtlAUCPQgACAAAAuKSqrFRvP7ZQGz76QP2HpOuqH/1SQ8ZOcLssAOiRCEAAAACA48wGg1r55r/0/jOPy9/YoFOvuk7TLr5MEV6f26UBQI9FAAIAAAAcRyXb8vXGg/dr94Z1Sp94gs66+Xb1HTDI7bIAoMcjAAEAAACOg8aGen30wrP67B8vKio2Tufd/l8aN30mQ04B4DghAAEAAAA6Wf7K5Vr60AMqL9yjCTPO0hnX3qiYhES3ywKAXoUABAAAAOgkNeX79PbjD2rdsnfVd+Bgzf2fn2nohMlulwUAvRIBCAAAANDBbDCo1e8s1XtPPaLG+jqdfMWXdeKlc+X1MeQUANxCAAIAAAB0oL07tmvJg/dr57o1GjJ+os666Xb1HzzU7bIAoNcjAAEAAAA6gL+hQR+//Lw+efl5RUZH6+xbv6GJM2Yz5BQAuggCEAAAAOAYbVu9UksfekBlu3dq3GkzNGP+TYpN6uN2WQCAJghAAAAAgKNUU1Gu9556RGvefVN90gbq8u//RJmTp7hdFgCgFQQgAAAAwBGy1mrte2/pnScfVkNNtU6aM1cnXXaVfJFRbpcGAGgDAQgAAABwBMp279TSh/6sbas/16DR4zT75tuVnJ7pdlkAgEMgAAEAAAAOQ8DfqE///oI+euk5eX2ROuum2zV51jkyHo/bpQEADgMBCAAAAHAIO9at0ZKF96t053aNPnm6Zl5/s+L79nO7LADAESAAAQAAANpQV1Wl9555VKve/LcSU1I157v3aPiUaW6XBQA4CgQgAAAAQBMNdbUqLsjXnk3r9cnfF6u2skJTL7pMp1xxjXzR0W6XBwA4SgQgAAAA6LVqKspVtHWzivK3hP8u27NLslaSNGDkaF3+vR8rNXO4y5UCAI4VAQgAAAB6PGutyosKVZy/RUX5BwKPqrLS8DGJKWlKzRymcafNUOqw4UrNHKH4fv1ljHGxcgBARyEAAQAAQI8S8PtVunO7E3KEAo/i/K2qr6mWJBmPR/0HD1X6xBOUkukEHamZwxUdH+9y5QCAzkQAAgAAgG5r/7wOJ+RwAo+S7QUKNDZKkryRUUrJyNTYU89wujoyhqt/eoZ8kVEuVw4AON4IQAAAANAtHDSvo2CrynbvDM/riE5IVGrmcE059yKlDhuh1Izh6jtokDyeCJcrBwB0BQQgAAAA6FKstaooLlTR1ibzOvK3qKp0b/iYxJRUpWYO17j9nR3M6wAAHAIBCAAAAFxzuPM6hk6YrFTmdQAAjgEBCAAAAI6Lxro6FRVsbbYTS+vzOk4PBx3M6wAAdBQCEAAAAHS4ZvM6Qn/anNcR6uxgXgcAoDMRgAAAAOCoHc28jpSM4Uron8y8DgDAcUUAAgAAgMMS8PtVumtHk86Og+d19Bs0pNm8jpTMYYqJT3C5cgAACEAAAADQisa6OhVv29qss+OgeR3pzOsAAHQfBCAAAAC9XE1FudPR0WRmB/M6AAA9DQEIAABAL9FsXkfBgcCjtXkdY085XanDnM4O5nUAAHoCAhAAAIAeqOW8juJ8J/Sor25rXsdwpWQOZ14HAKDHIgABAADo5g6e17FVJdvzD57XcQrzOgAAvRcBCAAAQDdyyHkd8QnM6wAAoBUEIAAAAF2QM6+jKLwDS1vzOlIymNcBAMDhIAABAABwWTAQ0N6d2505Hfmbw0NKw/M6jEf9Bg/R0PGTnK6OYSOY1wEAwBEiAAEAADiOms3rKNiioq1b2pzXkZIxXKnDhis5PZN5HQAAHCMCEAAAgE7SdF5HccFWFW3drLLdu2RtUFJr8zqGq+/AwfJEMK8DAICORgACAABwjFqd11GwVVV7S8LHJCSnKDVzhMaE53UMU0L/FOZ1AABwnBCAAAAAHIFgIKDSndtDO7C0M69j3ETmdQAA0IUQgAAAALTBmdeR3yzsaG1ex5iTpys1cwTzOgAA6MIIQAAAAHRgXoezE8uWNud1ZJ1zodJCnR3M6wAAoPsgAAEAAL1K83kdW8NzO9qc15Hp7MTCvA4AALo3AhAAANBjHTSvI3+rivO3qK66SlIb8zoyhikmIdHlygEAQEcjAAEAAD1CY32digvamdfhi1RyRqZGn3zagXkdQzPki4p2uXIAAHA8EIAAAIBup6aiXMVNlq8wrwMAABwKAQgAAOiywvM6CrY42822O6/jwE4szOsAAAAtEYAAAIAuofm8ji3hHVlam9eRkjncmdmROZx5HQAA4LAQgAAAgOOu6byO4tDMjpJtBfI3NkhqZV5H5nAlpzOvAwAAHD0CEAAA0KlqKyuaLV8pyt+isl07D8zriItX6rDhOuGcC5jXAQAAOg0BCAAA6BDWWlWWFKswtANLUf5mFedvVeXe4vAxzryO4RrTZCcW5nUAAIDjgQAEAAAcsfC8joKtKtq6uc15HYPHjlfqsBHM6wAAAK4jAAEAAO3aP6+juMlOLG3P6xiu1MwRzOsAAABdDgEIAAAIC8/rKNgS7uxoa17H/q6OfoOGMK8DAAB0eQQgAAD0Qi3ndezv7mg2r6N/ilKHNZnXkTlcCcnM6wAAAN0TAchRKNleIMn5LVh0fIK8kZEuVwQAQNuCgYBKd+1wdmBpY15H30GDmdcBAAB6NAKQo/DG//1RuzeuD3/u9UUqKj5e0XHxioqLV3To42afxycc+Dx0W1RcvLw+n4vPBADQ0zTW16lkW4Gz5Wx78zq+dJpShzGvAwAA9B4EIEfhjGu/osrSEtVXV6muqkp11VXNPq7cW6KSbfmqq6pSQ21Nu9fyRkW1CEsSQgFJXJOwJOGgcCUqLl4RXr58ANCb1VZWOF0d+YeY13H2+eHODuZ1AACA3op30Edh8Njxh31sMBA4EJBUV6m+qkq1ob/rqpuGJ5Wqq65SRdEeFVVXq666So11te1e2xcdEwpP4kIdKAnhzpLoJp0m0XHxzTtU4uL5xy8AdCNN53UUhwOPtud1pGQOV1rmCOZ1AAAANEEA0sk8ERGKTUxSbGLSEZ8b8DeqPhSG1FU1D0oOBCfVqquuVF1Vlfbt2RW+z19f3+61I2NiWw1LWi7RCXekhEKUqNhYeTyEJwDQWZrN68jfouL8zSrK36q6qkpJrczryBiulMxhR/X/GQAAgN6EAKQLi/D6FJvUR7FJfY74XH9j48FLdPYHKFVNPg8dU7prR7hDZf868VYZo6jY2ObzTEJBSVRrs0+ahClRMbEyHs/RvyAA0MMcNK+jYItKCvKbz+tIz9Dok05lXgcAAMAxIgDpobw+n7x9+iquT98jPrexob6VJToHhyn11VWqrapUVene8OcBv7/N6xrjUVRcXLOAJCq0hKe1OSdNb4uMiaGNG0C31nJeR3HBVpXu3NFsXkdKJvM6AAAAOgsBCA7ii4ySr1+U4vv1P6LzrLXyN9QfCEramHPStAOlorgofH8wEGjz2sbjUVRcvGKaLNNpPiQ2rlkHSnR8QjhM8UVFE54AOG72z+twwo7N7c7rGBXq7GBeBwAAQOcjAEGHMcbIFxUtX1S0EvonH9G51lo11teFOk0qmy3RCQcpLTpQ9hXuVl11teqrq2SDwTav7YmIaDLPpHkHykHbE+/vTAmFKd7IKN6QAGjT/nkdxflbVHioeR2ZzhIW5nUAAAC4gwAEXYIxRpHRMYqMjlFicsoRnWutVUNtbXhJTn2T2SbNB8c6YUlNRYVKd+90gpWaasnaNq8d4fW22J64+aDYlst5YvZ3nsTFyxsZeawvC4AupNm8jtBSlvbmdaRkDFdKRibzOgAAALoIAhB0eyY0mDUqNlaJKalHdK4NBlVfW9PmnJP9g2P3d6FUlZVq745tTrhSU93utb2+yAPLclrsuBMOVeJbLudx/kR4fcfykgA4RrVVlSraujm0C4sTdjSd1xEVF6fUzBEH5nVkDFO/wUOZ1wEAANCFEYCgVzMeTziUSDqy7ETBYED1NTVNluhUNh8a22LeSeXeEpVsy1ddVaUaamvbvbY3KurgeSZx8YqOjzt4e+Imy3miYuMU4eXHGjhc1lpV7i12dmAJLV8pyt+sypID8zri+ycrNfPAvI7UjOFKTElleRwAAEA3wzsl4Ch5PBGKiU9QTHzCEZ8bDASa76hTVaXadgbHVhTtUVF1teqqq9RY13544ouOCYUjcc2GwbYcGhsdF9+kQyVBUXFx8nj47TV6rmAgoLLdO1W0dXP78zrGjFfqOczrAAAA6GkOGYAYY4ZKekJSmiQraaG19g8tjjGS/iDpfEk1khZYa/M6vlygZ/BERCg2Memo3lgF/I2qD4UhB8852f95teqqK1VXVaV9e3aF7/PX17d77ciY2CbzTNrYcSe+5dDYBEXFxsp4PEf7cgAdrrGhXiXb8pt0dmxRybYC+Rucn4EIn08p6ZkaddIpSs10tpxNSc+UL5p5HQAAAD3V4XSA+CXdZa3NM8YkSMo1xiyx1q5tcsx5kkaF/pwk6S+hvwF0sAivT7FJfRSb1OeIz/U3NjZbotPW9sT7P6/euSPcobJ/0GOrQnNYDt6eOL7F9sTN551ExcUrKobwBMdm/7yO/bM62pzXMfu80E4sw5nXAQAA0AsdMgCx1u6WtDv0caUx5gtJgyU1DUAukfSEtdZK+sgY08cYMzB0LoAuwuvzydunr+L69D3icxsb6ltZonPw4Nj9u/FUbdsb/jzg97d5XWM8imq5PXGLsKTZDjtNBsdGxsQwh6EXYV4HAAAAjsURzQAxxmRKmiLp4xZ3DZa0vcnnO0K3NQtAjDG3SLpFktLT04+wVABu8kVGydcvSvH9+h/RedZa+RvqDwQlVVXNd9g5aNviKlUUF4XDk2Ag0Oa1w0NsW8w4ObBEJ87pQGllaKwvKpo3xV1YMBhQ2a6m8zqczo798zpkjPoNZF4HAAAADt9hByDGmHhJL0i601pbcTQPZq1dKGmhJE2dOtUezTUAdC/GGPmiouWLilZC/+QjOtdaq8b6OmeZToslOvVNdtpp2oGyr3C36qqrVV9dJRsMtnltT4S3SXAS1zw8abo9cStDY72RUYQnHajlvI7i/K0q3pbfbF5H8lDmdQAAAODYHFYAYozxyQk/nrbWvtjKITslDW3y+ZDQbQBw1IwxioyOUWR0jBKTj2yfYmutGmprw0tyDu402T841glLaioqVLp7pxOs1FRLtu2MNsLrbbE9cYvlO82W8zQfHOuNjDzWl6Vbq62qdLo5tm4+xLyOc8NhB/M6AAAA0BEOZxcYI+lhSV9Ya/+3jcNekXSHMeZZOcNPy5n/AcBNJjSYNSo2VokpRxieBIOqr61pc87J/vBkfxdKVVmp9u7Y5oQrNdXtXtvri2wWmBw0NLaNOSjR8fGK8PqO5SU5rsLzOvK3Ngk72prXcUpoOOkI5nUAAACg0xxOB8ipkq6TtMoYsyJ02/ckpUuStfavkl6TswXuJjnb4N7Q4ZUCwHESni0SF6+kI8tOFAwGVF9T02SJTmXzobEtdtyp3Fuikm35qquqVENtbbvX9kZFHTzPpOmSnWY77hxYzhMVG6cI7xGNfDri57x/XkdRwdbw33WVodWSLeZ1pIR2YmFeBwAAAI6nw9kF5gNJ7f46LrT7y+0dVRQAdFceT4Ri4hMUE59wxOcGA4EWnSbtD46tKNqjoupq1VVXqbGu/fDEFx3T+hKdpp0nTWehhOegxMnjObD8pOm8juKCLc7frc3rOPFk5nUAAACgS+m8XwkCAI6IJyJCsYlJR9UZEfA3qj4Uhhw852T/59Wqq3YGyu7bsyt8n7++vt1rR8bEhpbgeLWvcE94uGxUXJxSM4Y3m9fRd9CQTu02AQAAAI4W/0oFgB4gwutTbFIfxSb1OeJz/Y2NzZboNAtPmizX8dfXa8wppzOvAwAAAN0SAQgA9HJen0/ePn0V16ev26UAAAAAncbjdgEAAAAAAACdjQAEAAAAAAD0eAQgAAAAAACgxyMAAQAAAAAAPR4BCAAAAAAA6PEIQAAAAAAAQI9HAAIAAAAAAHo8AhAAAAAAANDjEYAAAAAAAIAejwAEAAAAAAD0eAQgAAAAAACgxyMAAQAAAAAAPR4BCAAAAAAA6PEIQAAAAAAAQI9HAAIAAAAAAHo8AhAAAAAAANDjEYAAAAAAAIAejwAEAAAAAAD0eAQgAAAAAACgxyMAAQAAAAAAPR4BCAAAAAAA6PEIQAAAAAAAQI9HAAIAAAAAAHo8AhAAAAAAANDjEYAAAAAAAIAejwAEAAAAAAD0eAQgAAAAAACgxyMAAQAAAAAAPR4BCAAAAAAA6PEIQAAAAAAAQI9HAAIAAAAAAKRdK6R/3S35G9yupFN43S4AAAAAAAC4pL5SWrVYyn1M2r1C8kZLE6+QhuS4XVmHIwABAAAAAKA3sVbaleeEHqtekBqrpdQJ0nm/liZfKcX0dbvCTkEAAgAAAABAb1BXLq38m5T3uLRnleSLlSZeJuXcIA3OkYxxu8JORQACAAAAAEBPZa204zOn22PNi1JjjTRgknTBb6VJV0rRSW5XeNwQgAAAAAAA0NPUljndHrmPSUVrJV+cE3jkLJAGTenx3R6tIQABAAAAAKAnsFba9pETeqx9WfLXOWHHRX+QJl4uRSW4XaGrCEAAAAAAAOjOakqlz591go+S9VJkgpR1jZR9vTQoy+3qugwCEAAAAAAAuhtrpYJloW6PV6RAvTR4qnTx/c5g08g4tyvscghAAAAAAADoLqpLpM8XOcHH3k1SVJKUc73T7TFgotvVdWkEIAAAAAAAdGXBoJT/npT7uPTFP6RgozT0S9L0u6Txl0qRsW5X2C0QgAAAAAAA0BVVFUkrnnaCj7KtUnQfadpNTsdH6ji3q+t2CEAAAAAAAOgqgkFpy9vOEpf1r0lBv5RxqjTze9K4iyRfjNsVdlsEIAAAAAAAuK1yj7T8KSnvCWlfgRTTTzrpVme2R8pot6vrEQhAAAAAAABwQzAgbX4r1O3xumQDUuZ0adb/ON0e3ii3K+xRCEAAAAAAADieKnYd6PYo3y7FJkun3OF0e/Qf4XZ1PRYBCAAAAAAAnS3glzYtcQaabvy3ZIPS8JnS2T+RxlwgeSPdrrDHIwABAAAAAKCz7NsuLX9SyntSqtwlxaVKp94pZV8n9RvudnW9CgEIAAAAAAAdKdAobfi3lPe4tHGJc9vIWdL5v5JGnytF+Nytr5ciAAEAAAAAoCOU5TudHsufkqr2SAkDpdO/JU25Vuqb4XZ1vR4BCAAAAAAARyvQKK1/zdnJZfPbkjHSyNlSzu+kUWdLEbzt7ir4SgAAAAAAcKT2bnZ2cVnxjFRdJCUOlmZ81+n2SBridnVoBQEIAAAAAACHw18vrfun0+2x9V3JREijz5FyFkgjz5I8EW5XiHYQgAAAAAAA0J6STVLeY063R81eKSldmvkDaco8KXGQ29XhMBGAAAAAAADQUmOd9MU/nJ1c8t+XPF5pzHlS9gJpxEy6PbohAhAAAAAAAPYrXi/lPi59/oxUWyb1zZRm3SNlzZMS0tyuDseAAAQAAAAA0Ls11kpr/+7M9tj2oeTxSWMvcGZ7DDtD8njcrhAdgAAEAAAAANA7Fa51Qo+Vz0p15VK/4dLsH0snXCPFp7hdHToYAQgAAAAAoPdoqJHWvOQEHzs+kSIipXEXOd0emdMlY9yuEJ2EAAQAAAAA0PPtWRXq9vibVF8h9R8lnf1T6YQvS3H93a4OxwEBCAAAAACgZ6qvkla/4OzksjNXioiSJlzqdHukn0y3Ry9DAAIAAAAA6Fl2LXd2cln1vNRQJaWMlc79hTT5Kim2n9vVwSUEIAAAAACA7q+uQlq92FnmsvtzyRstTbjM6fYYeiLdHiAAAQAAAAB0U9ZKO/Ok3Eel1S9KjdVS6gTp/N9Ik66UYvq4XSG6EAIQAAAAAED3UlfuDDPNfVwqXCX5YqWJlzvdHoNz6PZAqwhAAAAAAABdn7XSjk+dJS6rX5T8tdKAydIF/+t0e0Qnul0hujgCEAAAAABA11VbJn3+nLOTS9FaKTJeOuEqp9tj0BS3q0M3QgACAAAAAOharJW2fegscVn7suSvkwZlSxf9wVnqEpXgdoXohghAAAAAAABdQ02p9PkiZ5lLyQYpMkHKmiflXC8NPMHt6tDNEYAAAAAAANxjrZT/gRN6fPGKFGiQhkyTLnlAmjBHioxzu0L0EAQgAAAAAIDjr7pEWvGMM9tj7yYpKsmZ65F9vTRgotvVoQciAAEAAAAAHB/BoJT/Xqjb41Up2CgN/ZI0/b+l8ZdIkbFuV4gejAAEAAAAANC5KgulFU873R5l+VJ0H+nEm51uj9SxblcHSdZaVZXVq7igUhmT+ivC63G7pA5HAAIAAAAA6HjBoLTlLWcnl/WvSUG/lHGaNPP70riLJV+02xX2atXl9SoqqFRRQYWKQ3/XVjZKkq68e6pSMxJdrrDjEYAAAAAAADpOxW5pxVNS3hPSvm1STD/ppFudbo+U0W5X1yvVVjaEw46igkoVF1SourxBkmSM1HdgnDIm9FdKRqJSMxLUf1C8yxV3jkMGIMaYRyRdKKnIWnvQJBpjzAxJf5e0NXTTi9baH3dgjQAAAACAriwYkDa96cz22PAvyQakYadLZ90rjb1Q8ka5XWGvUVfd6HR0bKsIhx5VpfXh+/ukxWrwmL5KzUhUSkaCkofEKzK6d/RGHM6zfEzS/ZKeaOeY9621F3ZIRQAAAACA7qF8h7T8KSnvSalihxSXIp3ydSl7vtR/hNvV9Xj1tX4Vb2u+jKWipC58f2JKjAYMT1LqDKezIyU9QZExvSPsaM0hn7m19j1jTOZxqAUAAAAA0NUF/NKmJU63x8Y3JBuUhs+UzvmpNOZ8yRvpdoU9UkOdXyXbqw4sY9lWqX2FNeH7E/pFKzUjQeNPG+R0d6QnKDrO52LFXU9HRT8nG2M+l7RL0n9ba9e0dpAx5hZJt0hSenp6Bz00AAAAAKDT7dvmdHosf1Kq3C3Fp0mnfVOacp3Ub5jb1fUo/oaASnYcCDuKCipVtqdass79cX2ilJqRoDEnpTlzO9ITFJNA8HQoHRGA5EnKsNZWGWPOl/SypFGtHWitXShpoSRNnTrVdsBjAwAAAAA6S6DRmemR+7i0aalz28izpPN/LY0+V4qgw+BYBRqDKtlZpeImYUfp7mrZoPOWOSbBp9TMRI3MTgnP7YhLYqbK0TjmAMRaW9Hk49eMMX82xiRba0uO9doAAAAAABeU5Tu7uCx/SqoqlBIGSad/S8q+TupDN//RCgSCKt1VHZ7XUVRQqb07qxQMOGFHdJxPqRkJypzcX6mhHVni+kTJGONy5T3DMQcgxpgBkgqttdYYc6Ikj6S9x1wZAAAAAOD48TdI619zZntseVsyHmnU2VLOAmnkbCmi9w7PPBrBQFBle2rC284WbatUyfYqBfxBSVJkjFepGQnKOmuoUtKdsCOhfzRhRyc6nG1wF0maISnZGLND0j2SfJJkrf2rpCsk3WaM8UuqlXS1tZblLQAAAADQHezdLOU9Lq14RqoulhKHSDO+J025Vkoa7HZ13YINWu0rqglvO1tcUKni7ZXyNzhhhy8qQinpCZo0Y3B4GUtScoyMh7DjeDqcXWC+fIj775ezTS4AAAAAoDvw10vrXnW6Pba+J5kIZ6ZHzgJp5CzJE+F2hV2WtVblxbXNlrEUb69UY11AkuT1eZSSfmA3ltSMBPVJjSXs6ALoYQIAAACA3qJkoxN6fL5IqtkrJaVLZ/5AyrpWShzodnVdjrVWlXvrQtvOHth+tr7GL0mK8HqUPDReY08a4OzGkpGgvgNi5YnwuFw5WkMAAgAAAAA9WWOd9MU/nOCj4APJ45XGnOd0eww/U/LwZl1ywo7qffXNlrEUFVSqrrpRkuSJMOo/OF4jc1LDy1j6DYpTBGFHt0EAAgAAAAA9UdE6Z7bH54uk2jKpb6Y06x4pa56UkOZ2da6rLq8/sIxlmxN21FY0SJKMx6jfwDgNOyFZqRkJSslIVP/BcfL6WBrUnRGAAAAAAEBP0VgrrXnZ6fbY/pHk8UnjLnS6PTJP77XdHrWVDSraFtqNJdTZUb2v3rnTSH0HxCl9fD+lZiQoNSNR/YfEyxdJ2NHTEIAAAAAAQHdXuMYJPVY+J9WVS/1GSLN/Ip3wZSk+xe3qjqu66kYVb2u+jKWytC58f5+0WA0a1SccdiQPjVdkNG+NewO+ygAAAADQHTVUS2tecoKPHZ9KEZHSuItD3R6nSabn7zrSUOsPhR2VKgoNKa0org3fn5gcrbRhiZq4f/vZ9ARFxfA2uLfiKw8AAAAA3cnulU7osep5qb5CSh4tnfMzafLVUlx/t6vrNI31ARVvr2y2/ey+wprw/fH9opSakajxpw5UarozpDQ6zudixehqCEAAAAAAoKurr5RWvyDlPi7typMioqQJc6Sc66X0k3tct4e/IaCSHVXOtrOhIaVlu6tlrXN/XFKkUjISNfrEtHBnR2xipLtFd3O1/lqtLF6pvMI83TDxBkV7o90uqcMRgAAAAABAV7VreajbY7HUUCWljJPO/aU0ea4U28/t6jpEoDGovbuqwtvPFhVUqnRXtWzQSTtiEnxKzUjU8CkpSs1IVGp6guL6RLlcdfdXXl+u5UXLlVeYp9zCXK3du1Z+65eR0fQh0zUxeaLbJXY4AhAAAAAA6ErqKpzlLbmPSXtWSt4YaeJlzmyPIdO6dbdHIBBU2e7q8E4sxQUVKtlZpaDfCTui4rxKzUhU5sT+TmdHRoLi+0bJdOPn3FUUVhcqr8gJO3ILc7Vp3yZJks/j08TkiVowcYGyU7OVlZqlhMgEl6vtHAQgAAAAAOA2a6WduU7osfoFqbFGSpsonf8badKVUkwftys8YsGgVdme6vBOLEUFFSrZUaVAY1CSFBkdoZSMRJ1w5lCnsyMjQQn9owk7OoC1VgUVBeHAI68wTzuqdkiSYr2xykrN0nnDzlN2arYmpUxSVETv6KghAAEAAAAAt9TuO9DtUbha8sVKEy+Xcm6QBmd3m24PG7TaV1QT6upwdmQp3lYpf4MTdnijIpSanqCJZwx2tp9NT1RSSoyMp3s8v64uEAxoQ9mGZoHH3rq9kqS+UX2VnZata8Zdo+y0bI3pO0ZeT++MAnrnswYAAAAAt1grbf/ECT3WvCT5a6UBk6ULfydNvEKKTnS7wnZZa1VRUttsGUvRtko11gUkSV6fR8lDEzT+1EFKzUhQSkai+qTFykPY0WEaAg1as3dNeDnLiqIVqmqskiQNihukkwedrOy0bOWk5WhY4jC6akIIQI7Czg1lskGr2KQoxSVFKjLGyzcUAAAAgPbVlEorn3N2cin+QoqMl064ypntMWiK29W1ylqrytK6ZstYirdVqr7GL0nyeI2ShyRozEkDnM6OjET1HRArT4TH5cp7lurGan1e9Lk+K/xMeUV5WlW8Sg3BBknSiKQRznKWtGzlpOZoYPxAl6vtughAjsJ/XtikooLK8OcRPo9iEyMVlxTphCKJzt+xSZGKS4pSbGKkYpMiFZMQSeoJAAAA9CbWSts+DHV7vCwF6qVB2dJFf3SWukTFu11hmLVW1fsawiHH/h1Z6qoaJUkej1H/IfEakZOq1HQn7Og3KE4RXsKOjlZaV6rlhcvDgce60nUK2qAiTITG9Runq8derey0bGWnZqtvdF+3y+02CECOwtk3TVBVab2qK+pVU96g6vIG1ZTXq7q8QWW7q7VzfVk4EW3KeIxiEnxOKJIUeSAoSYwM3+bcHqUIH/8RAQAAALqt6r3S54ukvMelkg1SVKKUfZ2Ufb00cLLb1UmSaioawiFHcejvmgqnq8B4jPoNjNOwycnhZSz9B8fJ64twueqeaVfVrvBylryiPG0t3ypJioqI0uSUybp50s3KTstWVkqWYn2xLlfbfRGAHIWklFglpbT/TedvDKimvEE1FQ2qLt8flNQfuG1fvYoLKlVb2SBrDz4/Ks7brHskLrFJR0mTzhJfdATLbwAAAICuwFop/31nicsXr0iBBmnIidIlD0gT5kiRca6VVlvVcNAylqqyeudOI/UdEKeh4/uFl7H0HxIvXyRhR2ew1mpL+ZZw2JFbmKs91XskSQm+BGWlZumSEZcoJy1H4/uPV2REpMsV9xwEIJ3E64tQYnKMEpNj2j0uGLSqrWw4EJBUHOgm2X/b7o3lqq6oD++N3exxIj3hWSSxiaG/m33s/B0d52PCMgAAANAZqoqlz59xgo/SzVJ0krOLS871UtqE415OfU2jiraFdmMJdXZU7q0L35+UGqOBI/uEw47kofGKjOatYWfxB/1aV7ouvDtLXlGe9tXvkyQlxyQrOzVbN0y4QTlpORrZZ6QiPARPnYXvcpd5PEZxSVGKS4pSihLaPM5aq/oavxOKVLToKAkFJ3t3Vmn72no1hKYvt3wcJxhpMp8k8UBAsv/vmMRIRTCwCAAAAGhfMChtfdeZ7bHun1KwUUo/WTrj29L4SyRf+78I7SgNdf7QvI4Dy1jKi2vD9ycmRys1I1ETT3e2n01JT1BUrO+41NZb1fnrtKpkVTjwWFG8QrV+52syNGGozhhyhnLScpSTlqOhCUPp6D+OCEC6CWOMouN8io7zqd+g9lvnGhsCzbpIairqw3NKasobVLm3ToVby1Vb2djq+dHxvkMOdI1LipIvimQSAAAAvUxlobTiKSnvCaksX4rpK514i5Q9X0od26kP3VgfUMn20DKWbRUqLqhUWWGNFGoUj+8bpdSMRI09ZaDT3ZGeqOh4wo7OVtFQoRVFK8KBx+q9q+UP+mVkNKrvqPByluy0bKXGprpdbq9GANID+SIjDmtOSSAQVG3F/jklTZfeHPi7bHe1aioaFAwcvPzGFx0RDkX2L8FxwpHmoUlULNsEAwAAoBsLBqUtbzndHutfl4J+KeM0aeYPpHEXSb7oDn9If2NAJTuqmi1jKdtdHZ4fGJsYqdTMRI2alqaU0I4ssYnMijgeSmpLDgwsLczThrINsrLyerya0H+Crht/nXJSc5SVmqWkqCS3y0UTBCC9WESER/F9oxXft/3/YNugVV1NY7NlNwfmlTgfFxVUqrpir/z1By+/ifB6wp0jTXe8aTnQNSbBx37hAAAA6DoqdkvLQ90e5duk2P7Sl25zdnJJHtVhDxPwB1W6qzocdBQVVKh0Z7WCQSftiEnwKSU9UcOzUsJzO+L6RHXY46Nt1lrtqNyh3KIDgce2ym2SpBhvjE5IOUG3Zd2mnNQcTUqZpBjv8Vn6hKNDAIJDMh6jmPhIxcRHqv/g9vcpb6jzt1h20zw0KS+u1a5N+1Rf3co2wUaKTog85EDX2KRItt8CAABA5wgGpE1LnYGmG/4l2YA07Axp9r3S2Asl77EFD8FAUKW7a5ydWEJhR8nOqvCGB1GxXqVmJCjr7PRw2BHfN4qO6uMkaIPaWLZReUV5yit0dmgpri2WJCVFJSk7NVtzx8xVdmq2xvYfK5+HJUbdCQEIOlRktFeR0V71STvE8pvGoGoqmw9yrW4y0LW6vEF7d1SqprJRNnjw8puoWG+TrpKWAcmBvyPZJhgAAACHo3xHqNvjSalihxSXIp3ydWe2R/8RR3XJYNBq354aFW2rCA8pLd5epUBjUJIUGR2hlIwEnTBzqFJCYUdicjT/fj2OGgONWrN3TTjwyCvKU2VDpSQpLTZNUwdM1dS0qcpOzdbwPsPlMXSsd2cEIHBFhM+jhH7RSujX/vKbYNCqrqrxQFDSpLNkf2hSuLVc1eUN4f+RNOX1eQ4KScJzShIPLMGJiWebYAAAgF4n4Jc2vuHM9ti0RLJBacSZ0rk/k0afJ3kPf6aGDVqVF9c2W8ZSvL0qvETcGxWhlKHx4d1YUjMSlZQSw79Bj7Oaxhp9Xvx5OPBYWbxSdQFni+DMxEydnXF2eGDpoLhBhFE9DAEIujSPxzidHomR0tC2j7PWqqEu0Oog1+pyZ9Br6e5q7VhfpvqaVpbfeIxiE3wHukdabBHcdFZJhJfUFwAAoFsrK5CWP+l0fFTuluLTpNP+S8q+TuqbecjTrbWqKKk7sIwltCNLQ50TdkT4PEoZGq9xTXZj6TMgVh7CjuNuX92+Zt0da/euVcAG5DEejek7RleMvkI5aTmakjpF/WP6u10uOhkBCHoEY4yiYryKivGq74D2twn2NwSa7XzjfLx/TkmDqvbVq7CgUrWVDeEtxZqKivM22f2m+UDXprdFRvPjBQAA0GUEGp2ZHrmPSZvedG4beZZ0/m+k0edIEa3PcrDWqqqsPtzZURz6e/8v1Txeo+TB8Rp94oDwMpZ+A2MZ7u+SPdV7wsNK84rytGnfJklSpCdSE5Mn6saJNyo7LVtZKVmKj2x/viF6Ht6hodfxRkYoMTlGicntT2gOBoKqrWpl95smu+Ds2rhP1RX14aFVzR4nKkJxoTklrQUk+/+OjvPRWgcAANBZSrc6u7iseFqqKpQSBklnfFuacq3UJ/2gw6v31TdZxlKp4m0Vqq1slOR0J/cbHKcR2anhZSz9BsXRIewSa63yK/LDw0rzivK0s2qnJCnOF6es1CydP+x8Zadla2LyREVFsHNOb0cAArTBE+FRXFKU4pKilKKENo+z1qq+xn/wQNeKAx+X7KhS9Zp6NdYdvE2wJ+LAMp/WBrnuX5ITkxipCH6TAAAAcGj+Bmn9P52dXLa8LRmPNOpsKWeBNHK2FOG8DaqpaHCWsWyrDM/tqClvkOTsUNhvUJwyJiUrNd0JO/oPiWM3QhcFggGtL1vfLPAorSuVJPWL7qectBxdO+5aZadla0zfMYrw8LVCcwQgwDEyxig6zqfoOJ/6D2r/2Mb6QLh7pGlHSU15vaorGlS5t1aFW8vDv2Vo/kBSTLyv+RbBBy3FcW7zRfIfewAA0Avt3SzlPS4tf1qqKZESh0gzvidNuVZ1EanObixv7AhvP1tVVu+cZ6S+abEaOrZfeBlL8pB4+aL4N5Wb6gP1Wl2yOhx4rCheoerGaknS4PjBOm3wacpOzVZ2WrYyEzPpqsYhEYAAx5EvKkJ9UmPVJ/UQ2wQHgqptMqekuklIsj8wKd1drZryBgVb2SY4MjrioIGuTZfdxIV2wImK9fI/CgAA0L3566Uv/uHM9sh/XzIRqh9+iYoHXaOixpEq2lCt4qUFqihZHz4lKSVGA0ckKSUjUWmZCUoemsD8ti6gqqFKK4pXhAOP1SWr1RB0OnJG9hmpC4dfGA48BsQNcLladEf8lANdUESER/F9oxXft/1tgm3Qqq66sc2BrjUVzkDXmvIS+RsO3iY4wusJBSQHd5E07SyJSYhkajkAAOhaijdIeY+rIe9FlVT2UZF3qopiFqioeoDKlzWEDtqqhP7RSs1I0ITpg5WSkaCUoQmKjmt94CmOr721e8M7tOQW5mp92XoFbVARJkLj+4/Xl8d+ObxDS5/oPm6Xix6AAAToxozHKCbBCSg0pO0p1tZaNdYHWh/oWuH8va+oRjs3lqm+upVtgo0UkxDZbDvg5qHJgdtYFwsAADpLY3W1Sj74t4ryclVc6FGRf4zK/PdLcn5RE983SinpCRp7SqJSMxKUkpGgmPhId4uGJOffo7uqd4V3aMktzFV+Rb4kKToiWpNTJuuWybcoJy1Hk5MnK9bXfsc0cDQIQIBewBijyGivIqO96pN2iOU3jcFwKFIT6iJpuQSneHulaisaZFvbJjjW28ZA1wNLb2KTohQZHcHyGwAA0CZ/Y0B7d1Q7O7Ks367izUUqrYiVVR9JsxQT3ai0Uf00ckSyE3akJyguiV0+uoqgDWrLvi3KLcxVbpETehTWFEqSEiITlJ2arTmj5ig7NVsT+k+Qr41tiIGORAACoJkIn0eJ/WOU2P8Q2wQHreqqGg/qKGkalOzZUq7q8gYFGg9efuP1eZpvERxedtN095soxcT7ZFh+AwBAjxbwB1W6KxR2bKtUcUGl9u6sUjDg/LYl2pQrNXKLhmVGKGXKCUqd9iXF9Y3mlyldSGOwUev2rlNeUZ4+K/xMy4uWq7y+XJKUEpOinLQcZadlKzs1W6P6jpLHsLshjj8CEABHxeM5sH2vhrZ9nLVWDbX+FgNdm3SWVNSrdFe1tn9Rpobag5ffeDxGMaHHCc8nabLsJhygJEYqwsv/SAEA6OqCgaDK9tQ4YUeBs/3s3h1VCvidX5hERRulxBcrK+4jpXrWKCXFr4STLpGZcr0Ul+xy9div1l+rVcWrlFuUq9zCXK0sXqlaf60kKT0hXWcOPVPZadnKSc3RkIQhhFXoEghAAHQqY4yiYn2KivWp38C4do/1NwRCoUhru9/Uq7LMGepaW9kgtbL8JjrO12yQ6/4ukvBtoY+Z8g4AwPERDFrtK6xRcZOwo2R7pfyh7lBfdIRS0xM06fQ0pZo1Si1cpMTipTLeSGnKJVLOD6WMU52BZHBVeX25VhStCAcea/eulT/ol5HR6L6jNWfknHCHR0psitvlAq3iXQCALsMbGaGklBglpRxi+U0gqNrKFstvQstu9n9cVlimmooGBf0HJyW+qIi2B7omHugwiYpjm2AAAA6XDVqVF9eqaJsTdhQXVKp4W6Ua6wOSJG+kRynpB3ZjSc1IUJ/gRpm8J6SVf5MaKqXkMdK5P5NO+LIU28/lZ9S7FdUUhYeV5hblalPZJllZeT1eTew/UfPHz1dOWo6yUrOUGJnodrnAYSEAAdDteCI8iusTpbg+7Q86s9aqvtrfJCA5sARn/6DX4u2VqlndEP7HWfPHMa0PdE1s0WGS6JMnguU3AIDew1qryr11oa6OUOCxrTK8nDXC51HykHiNPXlgeDeWvgPi5PEYqb5SWrVYeuVxaddyyRstjb9UylkgpX+Jbg8XWGu1rXJbOPDIK8rT9srtkqQYb4yyUrJ0dtbZyknL0aTkSYr2RrtcMXB0CEAA9FjGGEXH+xQd71P/we0f21Dnb95F0mxOSYMqSmq1e3O56qoaW3kgKSbe12ZA0jQ88UayTTAAoHux1qqqrF7F+8OObc7f9dVO2OGJMEoeEq9R09KUGurs6DswThFNfzlgrRN25D7mhB+N1VLqeOm8X0mT50oxfd15cr1UIBjQxn0bw1vS5hXlqaS2RJLUJ6qPslOzddWYq5STlqOx/cbK6+FtI3oGvpMBQDqwTXDqIbYJ9gcPWm7TdOebmvJ67d1ZrdqKBgWDBy+/iYyOaNZR0nzZzYE5JVGxLL8BALijurw+3NmxP/SorXR+AWA8Rv0Hx2lEVopSMhKVmpGg/oPiFeFroxOyrlxa9bwTfOxZJXljpImXO90eQ6bS7XGcNAYatWbvGn1W+JnyCvO0omiFKhsrJUkD4gbopIEnKTs1WzlpORqeNJx/g6DHIgABgCMQ4fUooV+0Evq13/ppg1Z11Y3Nd7+pODDYtaaiQYX5Faopr5e/4eBtgiN8nubbAodmlcS22P0mJiHSaScGAOAo1FY2NF/GUlCh6vIGSU420XdgnDIm9ldqRqJSMhKUPDj+0N2M1ko7c6XcR6XVL0qNNVLaJOn83zjdHtFJx+GZ9W41jTVaUbwi3OGxqmSV6gP1kqThScN1zrBzwoHHoPhBLlcLHD8EIADQCYzHKCbBCSg0JL7N46y1aqwLHBjoGppN0vTjsj012rm+TPU1B28TbIyabBPc9hbBcUlRbf92DgDQK9RVNzodHdsqwqFHVanzplhG6psWq8Fj+yo13ensSB6aIF/UESzdrN3nDDPNfUwqWiP54qRJVzjdHoOy6fboRGV1ZcorygvP8FhXuk4BG5DHeDSu3zjNHTNXOak5mpI2Rf2iGS6L3osABABcZIxRZIxXkTFe9R1wiG2CGwPh5TdNl+A03Q2neHulaisaZFvZJjgq1ttk+c2BpTctd7/xRUfQ+goA3Vx9rV/F25ovY6koqQvfn5QSo4HDk5Qy0wk7UoYmKDLmKN4aWCtt/9gJPda8LPlrpYFZ0oW/kyZeIUWzO0hn2F21W7lFueHAY0v5FklSpCdSk1Im6SuTvqKc1BydkHqC4nzt//sC6E0IQACgm/D6IpTYP0aJ/Q+xTXDQqrby4DklTleJ8/HuTeWqKW9QwH/w8htvpKfVga4xCZHyRnoU4W3lj8+jCK9p8vH+P4YdcgCgkzXU+VWyvarZbiz7CmvC9yf0j1ZqxoHtZ1OGJig6zndsD1pTKn3+rJT3uFS8ToqMl064Wsq5Xho05RifEZqy1mpr+dZmgcfu6t2SpHhfvLJSs3TRiIuUk5ajCf0nKDIi0uWKga6LAAQAehiPxyguKUpxSVFKUUKbx1lrVV/jb77jTbNlOM5A1+1flIW3NTwaxigcjHi8TYISr0feUFjiaRKYNA9Q2ghWfM2vc+B20+RazW8P1+AxdLgA6Lb8DQGV7DgQdhQVVKpsT7UU6vyL7xullPQEjTlpQHj72Zj4DnpDbK1U8B+n22Pt36VAvTQ4R7r4T9KEy6Sotpd84vD5g36tL10f3o52edFyldaVSpL6R/dXdlq2rp9wvXLScjSqzyhFeNhhDjhcBCAA0EsZYxQd51N0nE/9BrXfHtvYEFBtZYMCjUEF/EEFGq3zd8s/LW/ff7z/wO3BVm4L+INqrPMfuK2x5bWtbCu76hzdE9fB4UqzgOXAbZ4mIc3+2z2+VsKZIwhoWt7m8RLIAGhdoDGokp1VKm4SdpTurg7/9zAmMVKpGQkamZ2i1MxEpaQnKC4pquMLqd4rff6MlPu4tHejFJUoZc93uj0GTOr4x+tl6vx1WlWyKrwd7YqiFarxOx08Q+KH6LTBpyknLUc5aTlKT0jn/xnAMSAAAQAcki8yQr5DLL3pbMHgweFIsEmI4m88ELoE/a0ENK2FNq2FMaHbGmv8ocdoevuBGlrb5vhoeUJhSasdMe0ENAfd3kr3jKe1gKa1Y/eHNhEeGXYWAo67QCCo0l3V4XkdRQWV2ruzSsGA89+a6DifUjMSlDnZ2ZElNSNBcX2iOu/NsLVS/vtOt8cX/5ACDdKQE6VL/ixNuFSKZK7E0apsqNSKohXhDo/VJavVGHS2GR7Vd1R4OUt2arbS4tJcrhboWQhAAADdgsdj5ImMkO9Q2y8eJzZom3WoHNy5cnCoclCQEg5y2uqqsQo0BhTwWzXU+tsObUJhUEfxRJhWw5LWOmLCgU1bAU3TcOUwljd5WlkiRSCDniYYCKpsT01429mibZUq2V4VnssUGeNVakaCss4aqpTQjiwJ/aOPz2/+q4qlFU87sz1Ktzhb1k69Ucq+Xkob3/mP3wOV1JaEZ3fkFeVpQ9kGBW1QXuPV+OTxunbctcpOy9aU1ClKimKLYKAzEYAAAHAUjMfIGxkhb1cJZKxtvSOmaafMUQY0TTto9nfENNYHVFftDz9Wa50yHcXjMaGlR62EKy2DlXY7ZVqZEeNrYxlTW/NnGOyLI2SDVvuKasLbzhYXVKp4e6X8Dc7PiC8qQinpCZo0Y7BSMxKVkpGgpJSY47vMIRiUtr7jdHus+6cU9Evpp0hnfEcaf4nkc7cDsDux1mpH1Y5mgUdBRYEkKcYbo8nJk3Xr5FuVnZatScmTFOuLdblioHchAAEAoAcwxjhv5n1d4825tVbBgD0oQGk1dPHbFkub2gpoDnTEtAxo/A1B1YeWLTW9bjB0vt8fDA+JPFZNB/u2Nfel3cG+rYU5hzHY19viOp7QtRns23VYa1VeXNtsGUvx9ko11gUkObtspQxN0PjTBoWXsfRJjXWvy6lyj9Ptkfu4tK9AiukrnfhVZ7ZHyhh3aupmgjaoTfs2OfM7QqFHUW2RJCkxMlHZqdm6YtQVyk7L1rj+4+TzHOPuOwCOCQEIAADocMaY8Bv6rsBa68yROdoZMa0M5m1rsO/+jhhnsG/b5x+/wb6tD+Btb7Cv1+dp3i1zuIN9fR55InpHIGOtVeXeutC2swe2n62vcXbNivB6lDw0XmNPGqCUUNjRd0Cs+x1EwYC0+W0p91Fp/euSDUiZ06VZ/yONvVDyRbtbXxfXGGzU2r1rw4FHXlGeKhoqJEmpsanhYaXZadka0WeEPKZr/DcQgIMABAAA9HjGGEVEOENeu4qDBvu2Md+l/dAmcMiAJjzYt/7AYF9/iw6cYAcP9m1tfsxRBTTtDPYNd8SEH6PtrppjDWSstareV99sGUtRQaXqqp3BlZ4Io/6D4zUyJzW8jKXfoLgu9f2mil3S8qekvCel8m1SbH/p5Nud2R7JI92ursuqaazRypKV4cBjZclK1fprJUmZiZk6K+MsZadmKyctR4PjB/eK8A/ozghAAAAAXNDtBvu2E9C0N9jXHw5xmocurg32bdrN0sa21k0H+1aVOV0etRUNkpz5P/0GxWlYVnJ4GUv/QfFdZvlZM8GAtHGJM9B0w78kG5SGnSHN/pE09gLJ2wlb5nZz5fXlWl603JnfUZintXvXym/9MjIa22+sLht1mbJTs5Wdlq3kmGS3ywVwhAhAAAAA0PUG+watAoHWlxC1Odi3tRkxhzHY198YVENdQAF/Y/jY/YFNdHykMsb3Cy9jSR4S32Veozbt2+50eyx/UqrYKcWlSKf+Pyl7vtRvuNvVdSmF1YXKK3Jmd+QW5mrTvk2SJJ/Hp0nJk7Rg4gJlp2YrKzVLCZEJLlcL4FgRgAAAAKDLMR4jrydCXp8kNiE5tIBf2vhvZyeXTUsla6URZ0rn/lwafZ7kjXS7QtdZa1VQUdAs8NhZtVOSFOuN1ZTUKTpv2HnKTs3WpJRJioqgQwboaQhAAAAAgO6qrMDp9Fj+lFS5W4ofIJ32X1L2dVLfTLerc1UgGNCGsg3hwCOvME976/ZKkvpG9VV2WrbmjZun7LRsjek7Rl4Pb42Ano6fcgAAAKA7CTQ6O7jkPiZtfsu5bdRs6YLfSqPOkSJ65z/xGwINWl2yOhx4rChaoarGKknSoLhBOnnQyeEdWoYlDmNgKdAL9c7/OgIAAADdTekWKe8JafnTUnWRlDBIOuM70pRrpT5D3a7uuKturNaKohVOd0dRnlYVr1JD0BlWOyJphM4bdl54W9oBcQNcrhZAV0AAAgAAAHRV/gZp3avOTi5b3pGMx+nyyFkgjTyrV3V7lNaVKq8wLxx4rCtdp6ANKsJEaFy/cbp67NXKTstWdmq2+kb3dbtcAF1Q7/kvJgAAANBdlGxyQo8Vz0g1JVLSUGnm96WseVLSYLerOy52Ve0KDyvNK8rT1vKtkqSoiChNTpmsmyfdrOy0bGWlZCnWF+tytQC6AwIQAAAAoCvw10tf/MOZ7ZH/vmQipDHnOd0eI86UPF18+91jYK3VlvItzQKPPdV7JEkJvgRNSZuiS0Zcopy0HI3vP16REexqA+DIEYAAAAAAbirecKDbo7ZU6pMhnflDZ7ZHQs+cXeEP+rWudF048FhetFz76vdJkpJjkpWTlqMbJtygnLQcjewzUhE9OPwBcPwQgAAAAADHW2OttPYVp9tj238kj1cae4HT7TFshuTxuFtfB6vz12lVyapw4PF58eeq9ddKkoYmDNUZQ84IDywdmjCUHVoAdAoCEAAAAOB4KVzrdHt8/qxUt0/qO0w660dS1jVSfKrb1XWYioaKAzu0FOZp9d7V8gf9MjIa1XeUs5xlQI6yU7OVGttznjeAro0ABAAAAOhMDTXSmpec4GP7x5LHJ427yOn2yJzeI7o9imuKlVvkhB15hXnaULZBVlZej1cT+k/QdeOv09S0qToh5QQlRSW5XS6AXooABAAAAOgMe1ZJuY9LK/8m1ZdL/UdKZ98nnfBlKS7Z7eqOmrVW2yu3h4eV5hXmaVvlNklSjDdGJ6ScoNuyblNOao4mpUxSjDfG5YoBwEEAAgAAAHSU+ippzYvObI+duVJElDT+EqfbI+MUqRvOtgjaoDaWbWwWeBTXFkuS+kT10ZTUKZo7Zq6yU7M1tv9Y+Tw+lysGgNYRgAAAAADHatcKZ4nLyuelhkopeYx0zs+lE66WYvu5Xd0RaQw0as3eNeHAY3nRclU2VEqS0mLTNG3ANOWkOfM7hvcZLo/p/kt4APQOBCAAAOD/t3fvUXLWdZ7HP7/neaq6+pa+pjt3coMIcglJFEVmD15WBsV1UUQ94Fl2OItH1zPLLh4ZPejsruy4OjiL4wwgzriMMAdF1BlwvKzibQQiuZAbhI4JCYTcOl3V6aRv1XX57R9VXV1P1VNV3aG7q7vyfp3Tp6qf36+e5/dUVzpVn/7+fg+AsxE/I+1+PFPtcWyH5EWkN16fqfZYfsW8qfYYTgxr58md2t67XdtObNPuk7s1mhqVJK1csFLvPu/dmcCje4OWNC7hCi0A5i0CEAAAAGCyrJWObs+EHru/LyWGpK6LpGu/Il16o1TfVu0RVnRq9FRuKsu2E9u0N7ZXKZuSYxyta1unGy64QRu7N+ryrsvVUd9R7eECwLQhAAEAAAAqGR3ILGa6/R8yi5t69dLFH8xUeyzbNKerPY4PHc9djnbbiW06MHBAkhR2wrq482L9ycV/oo3dG3XZwsvUFG6q8mgBYOYQgAAAAABBrJVe25qp9njhB1JiWFp0ifTer0qXfEiKzL3LuVprdfD0wdzlaLf3bteRwSOSpMZQo9Z3rdd7V79XG7s36o2db1SdW1flEQPA7CEAAQCgFlib+VKJW5su3ZbrM4OPV3YfJds0iWO83seXOg9N8hjT8PiiPjqL5zodcNypPj7guJN+rl/Pz3r8tXo2P6vCMU/2Z1XqXCfxs0qnMwuahhozgcfGW6Qll8+pao9UOqWe/p5chcf23u2KjcYkSe2Rdm3s3qibL7xZG7s36oK2C+Q6bpVHDADVQwACALUonZZScSk1JiXHMrepeN797FcyLqUS2ba8+6lE9vu8fulE8QefKX1gVXGf1/tBb0Y/qGXHPF8+qKHGmOyH7KBbp0ybMu1lH28C+hQes9wx8h9faqyTeLyZ6hjzbzWFMQY8R5M6Rva268LMVJe65mn/KZ+NeCquPX17coHHjpM7NJQYkiQtbVqqq5ZepQ1dG7She4NWLljJgqUAkIcABADOVjo9ESzkAoP8+4mCEKIwkMgPIQICiUnvMyCssKnpPVfHk5xQwQcOp8yHn0l+sCjXVvJDlKZwjLzHO9nLNE55jAGPm9IHvUrnOBsf9Co8PrDPVJ+r1/v4/D6lXlcz/KF8Mj+z1/u6nvTjgYzBsUHtOLkjF3js7tutRDohSVrbulbXrb4uF3gsalxU5dECwNxGAAJgbsuFDAFhQcnqhhKhQFF4MJV9BvRNJ6f3XI0reXWSG858eXWSG5Lc7K1Xl7kfbipoC0teuKBf/j7Ced+P36/z3889LrvPwv2PhwcAgBkVHYn6rtDS09+jtE3LM54u7LhQN114kzZ0bdDlXZerNdJa7eECwLxCAAIgEzKkJxMYBAQLRRUMkw0hylQ35N+fsZChMDwoCAzCjZLbViIwCAgoSoUVhYGEL6woODbzsgHgnGKt1ZHBI77A49DpQ5KkiBvRpQsv1ccv/bg2dG/QpZ2XqiHUUN0BA8A8VzEAMcZ8S9J1knqttRcHtBtJX5P0HknDkm6x1m6f7oEC8561FSoRXuf6DFOqbijoly2lnTbGLa42CKpMCDdkQoazDQyK+uUHEiWOTcgAAKiStE3rwKkDmbCjd5u2ndim3uFeSVJzuFkbujbo+vOv18bujbqo/SKF3FCVRwwAtWUyFSAPSfobSd8u0X6tpPOzX1dIuj97C8y+8ZChZCXC612fYZLVDUH9pj1kcMqEAnnVDeEGyW09+8AgaJ+lpluM9yVkAABAiXRCe6N7c4HH873PayA+IEnqqu/Shu7M2h0buzdqbetaOYbphgAwkyoGINba3xpjVpbp8n5J37bWWkmbjTGtxpjF1tpj5fbb09Ojq6++2rftxhtv1Cc/+UkNDw/rPe95T9FjbrnlFt1yyy3q6+vTDTfcUNT+iU98Qh/+8Id1+PBhfexjHytqv+OOO/S+971PPT09+vjHP17Uftddd+ld73qXduzYodtvv72o/S/+4i905ZVX6qb7btLP7vtZUfslt16illUt6t3Zq33f21fUftknLlPz0mYd33Jc+/95f1H7xts3qr6zXkd+d0QHf3qwqP1Nn3mT6hbU6dVfvqpXf/lqUftbPv8WeXWeDv7koI48faSo/aq7r5Ik7f+n/Tq+9bivzQ27eusX3ipJ6nmsRyd3nfS1h5vDevOdb5Ykvfjwi4r1xLItmSsP1HdEtPFPL5NsWrv/714NHDqj/KsSNC2q1/rb1knWasc3ezR4bGSi3Uot5zXokptXSrLadv9+jcTGfO3taxp10YcWS9bqub89qLHBlCaumCAtvLBB697bIcnq2a+9plTCf0WERZc2au272yVJv7vncNFzs3RTs1Zd3apkPK3NXy9+7lZc2aoVV7UpfialLQ8cVnaFvZxV71iopVe0aySW0LYHDxa1r33PEi3a2KkzR4e181svF+zd6IIPrFTXpR0aeGVQux8qfO0YXXTTOrW/oV3Rnpj2/mNP3v6TkpK6+NbValnVopM7T5Z87TUtbdLxLft14J8PFLVvuH1D7rV36KeHito3fWZT7rV3+JfFz98Vn78i99o7+vTRova33f02SZnX3omtJ3xtbtjVW77wFkmZ117frj5fe7g5rDfd+SZJmddef0+/rz3SEdHG/7pRkrTn7/do4OCAr71pSZMu++RlkqSd9+3U4NFBX3vLqhZdfGumuG3b/9mm0eior71tXZsu+thFkqQtX96isTNjvvbOSzu17sZ1kqTN/3OzUmP+xUe7N3Vr7b9fK0l6+q6nVWjJ25Zo1bWrlIwn9fsv/r6offk7lmvFO1YofjqurV/ZWtS+8o9XaulVSzXSN6Lt9xYX3615/xotetMiDR4Z1M77dxa1X/ChC7TwsoUaODigPX+/p6j9wpsvVPsb2hV7Kaa9j+yVJBljZLKvwU23bVLHmg4d33Fcu7+zW0Ymd8UBI6O3/7e3q3NFpw4+e1DbH9vuazMyuv4L16t9UbteeOoFPffD53L7NdmFLG/9yq1qaW/R75/4vTY/udn3WBnpzm/cqfr6ev380Z9r8083+x5rZHTPd+6Ra1x978HvafMvN/seG4lE9PVHvy7XuPrmX31Tz/3rc77HtrW36YGHH5BrXH35f3xZ25/zj3/p0qX6u3/4O7nG1Wfu+Ix279yde6wkXXDBBXrwwQclSbfddpv27fP/21y/fr3uvfdeSdLNN9+s1157zdf+1re+VV/60pckSR/84AcVjUZ97e985zv1+c9/XpJ07bXXamRkxNd+3XXX6dOf/rQkFf1/K82f/3OfeeYZfe5znytqv/fee7V+/Xr94he/0N13313U/o1vfEPr1q3Tk08+qa9+9atF7Q8//LCWL1+u7373u7r//vuL2h9//HF1dnbqoYce0kMPPVTU/uMf/1gNDQ2677779NhjjxW1//rXv5Yk3XPPPfrRj37ka6uvr9dPfvITSdIXv/hFPfXUU772jo4Off/735ckffazn9Wzzz7ra1+2bJkeeeQRSdLtt9+uHTt2+Np57VXvtZe2aX3q7k8p2hzVD5/4oTY/ulmp7KLUES+i5lCz7vrru3TNZdfo6R8/rQf+/AFt0RbfPnjt8drj9x6vvUK89s7+tVdoOtYAWSop/xPRa9ltRQGIMeY2SbdJUl1d3TQcujoW1i9UvVdftH1p81J1tXbJbXJ12Cv+kLi8ebnaW9tlG62OeAEfshesUHNrsxINCR33jmsiAMjcrqzvUn19nUZCMZ10QvJdMlHSKieikHF0xjqKyUxcOjJzHUetjo9INq1YIq6BdNL3WC+Z1OpTxySbVu/IgAYTo3mPlSLxuFYf3yvZtI4O9mlkzP8hsWlkTKtP9EiSXh05pbGE/0Niczyl1dFMaHMgPqRU0l8N0TJmtHowJhlHPcmklE4p9yHfGLXKaLXJTF94wYTkjq+Q72Ru28ItWr1gpWQc7Qz1K2nTE1cBkNTetESruy+UjKtt4VPyXSVAUmf7Gq1eeYkS8ZR2Rv4lbwX+zO3C7ou0es0bNTIwoj2R4n9UXZ0XafV563Sm/oxerOsvau/uWKfVS9YoloxpX/hkUfvittU6r+s89Z7u1f5Q8WtjyYIVWtK+RJHmozpU4rXV1dqlUFMo8LW3onmF2lvbZRqNjnrFAcXKBSvV3NqsVENKJ7wTRe2rW1arvqVe8Ya4+ry+ovY1LWsUioQ0WD+ofq/4/Ne2ZgKAU/WndNo77WvzQl6uvS/SpyFvyNceCUVy7ccixzTqFbz2wk259sN1hzXm+V97C8ILcu0HwweV8vwBRUtdS659X3ifjOcPr9oibbn2F0MvyvX81S0dkY5c+67QLiUL1izprO/MtW/3igOKhfULtbZ1rRKjCe3ydhW1dzd0a23rWo2YEb3gvVDUvqhhkda2rtWZsTPa6+0tal/cuFhrWtcodjqmfV5xOLakaYnOaz1Pvc29OuAVh2PLmpZpSesSHW06qkPeIdns7wRrrays6kP1qvPq5JrM82JllbZp2ezvn5NDJzV0ekjHh45rODmce+x4383HNis8Ftbxk8cVHYnm9jve/vCLD8ttdtX/ar/6zxS/tv5yy1/KqXMUPRjVwMBAUfsdv7lDktR3oE+n+/2vPSfs6Jaf3iJJ6t3Xq8GoPxzzRj2975/eJ0k63nNcwyeHfe17knt05aNXSpKOvXRMIycm3gwZY7TH7NH2R7bLMY4O7T+keG8805YNiV7+w8va+/heOcbRrsO7FI/Gc4+VpBP7T+iVf3lFjnG09fhWxc/EfQHT8IFh9T7VK8c4ein2kpLxpC+g+dnBn2nwmUE5xtErp1/xhTtGRr969VdKPZ9SajSlo4NHfY+VpGeOPKPw3rCGTg3p5MjJonDq+d7n1XqoVdFjUZ2Kn5o4t2z7vtg+bT2+VYejhzWYGPS1GRkdGzymQwOHdGzwmOKp+MT+swHb4Nigzoyd0WhyVGmb9j0WmCuS6aQGE4OZ12vijIYSQ7rr6bsUWRxRc6JZnfWdago3qTncrJCTmc5yzcprtHzBci5PCwBVYKy1lTtlKkB+VGINkB9J+t/W2t9lv39K0p3W2uI/VebZtGmT3bq1bJe56w8/lwZPVJ7ycFaLSeZNxZhuuYUaA64GUXbKQ9D6DEHTIQqmYhROuSg13cJxueQfgJKstUrZlNI27b9NZ26trFLpgPaA/mmlM99X6D/+ldteon9Rv4L+hX2D7uefS9l9ljr3gsdXGmPh+YwHTvOJkZFrXDnGketkbh3j5LYVfu+7dfL6yfF9X+rWt7+A/mXvO5PYZ/6tM8l+hec/TefiGpcP5mX0Dvdq+4nt2npiq7b3btf+/v2ysvIcTxd3XKyN3Ru1oXuD1net14LwgmoPFwDOScaYbdbaTUFt01EBckTS8rzvl2W31a7ffFl6bUtwW8mrQeSFAF5YqmuexIKOZ3m5yqD1GRyPkAHAvGSMkWe4aNlMKQyYAgOngACoZDAV0L9iqDMeGCldNszJ718u/Cl7v0z4lUwnywZOkzn3WgmYAoMXZ5KhT5nHlA1zsv0dlQ+PSu4vIDwqe79EmFV4rFdOv6JtJzILlr42mCmbr/fqtX7hel2z/hpt6N6gSzovUcSLVPknBwCoZDreUT4h6VPGmO8os/jpQKX1P+a9Dz2UmaJRGGwQMgAA5hkCppllrZ1UADSZap7A8GUK1T/lAqNK1UZTDX/Syqu8yvZJpVMas2Plz6lMQBV07LRNz8rPsa2uTZd3Xa6PvOEj2tS9Seva18lz+HcDAPPNZC6D+6ikqyV1GmNek/TnkkKSZK19QNKPlbkE7n5lLoP7H2dqsHNGy7JqjwAAAMwDxmSm67hyFRKXNJ1u5QKmwPtnEQAtalykVS2rmBoEADVgMleB+WiFdivpP0/biAAAAIBJIGACAEwFFxsHAAAAAAA1jwAEAAAAAADUPAIQAAAAAABQ8whAAAAAAABAzSMAAQAAAAAANY8ABAAAAAAA1DwCEAAAAAAAUPMIQAAAAAAAQM0jAAEAAAAAADXPq/YAAAAAgOlkrZUSCdlkcuIrkZRNJKRkwr8tmchuL+5rkwk5kXp5nR1y2zvkdXbIaW6WMabapwgAOAsEIAAAAMixqVQuBFA2HCgMDJRMTmxPjAcHQdsz91WubyIveMgPI4K2+7aV3q5kcsaeHxMKye3okNfeLrezQ15Hp7yOdrm52w552S+3rU3G4+02AMwV/EYGAACYBtbagiqCxESIULAtFwCU256rQsgPDJL+QKLc9qJt44FGwPZcQJGQrJ35J8txZEIhGc/LBATj933bPBlvYrtTFwncnrn1JC+7PW+b8SpsD4Wybd7Eccf7ZrelR0aUikaVzH6lolEl+6JKxqJK9UUV/8N+pfr6Ms9dIWPktrbK7WgvH5Rkb536+pl/7gHgHEYAAgAAqs6m05kP4GMFUxRy4UDpKQq+wCCZlE2M5aoA8isOAisL8vcRtL1oW7Lk9pmsOvDJCwlyX6GQPxjI224idXK8Jv+2/MBgfHs4lN1WEDAU9g1NBA8T4YLnCySUdz8w6HBqaxk6a63Sg4NK9vUpFYsp2RdVKuYPSpKxmEZfeFHJWEzpM2cC9+M0NOTCkInb/PBkIjRxWlqYigMAU0QAAgDAPFZUdTD+V3zfB/akvxKhYIpCxekMBVMRyk5dCJiioKK+2THmjU/p9Mw/WY7j/yBeGCSE8v76P76tsW4iWMjfHiqoICi3PS8cKAoMctsLtpUYozyPD71zkDFGbnOz3OZmadWqiv3T8XjpoCSa2ZY4fFgjO3cqFYsF//vwvMw0nFwoUqa6pL098zoDgHMcAQgA4Jw1XnXgWywxfyrA656iMFEZMOnpDImCcZTdnhn7rCisKiicilC4PRyW09AQPEVhElMXfJUIedMRfPsIh/zBgBfybZuYzpD93nVn57kCKnDq6uQsXqzQ4sUV+9pUSqmBgYrVJWMvv6xkNCobjwfux21pmXR1iWloIGgDUJMIQAAAU2atlcYXSqwwRaHiFReCpij4pjNM4xSFwvAglZr5J8uYvCkKAVMXwtm//udtcxrqpdCC4ukM4VDxtIVQQWVBpYqDilMXSvTlwxBQFcZ15bW3y2tvr9jXWqv00HAuIMkFJdE+paKx3Bom8Z4eDcViSg8MBB8zEplUUOJ2dsptaam5KU0AahcBCABUkW/6QiLhqz7whQpFbfnbCvsF9M/vM1bY5u+Tm8YQ2Gdi6sKscN2yiyIWbR+vOihVWVBhikLQooi5SoRQeJILKGb7UnUAYJYZY+Q2NcptalR4xYqK/e3YmJL9/YHVJeO3iePHNbpnj5KxWHBo7Lpy29vktZerLpkIT5xweAbOHAAmhwAEQE3IVSQEBgVj5UOEZFDYUPDBPyhoGDvLEGE2g4SCqQm+2/HKg7xtTl0kO90g5K8s8IUFpRdQnNQUhbwFFH0VB4VrHYRCVB0AwAwy4bBC3d0KdXdX7GvTaaUGBiaCkmifktFYUXXJ2KuvKhmLyQ4PB+7HaW6edHWJ09jI/wMAphUBCAAf39SGXBVC3lSGogqFMiHCeLVBuRChXLVCYFtxmKDx25mUX4mQd6vxD+656oBMm9MUKR0ihPyhQ1EfX7+C0CLXLxzYVjTVgrJkAMA0MI4jr61NXlub6tasqdg/PTysZCymVF+fkrFYYJVJ/OUDSj33nFKnTgUfMxyW29kxueqStjYq7gBURAACzCBbWJEwViJE8AUFYxNrFQRWK2T7VAwR8iofSk55KA4RbDIpWTtzT4rrlgkR8j74j1ckNDbmVSt4gX0qBg0lQ4SQf9HEwhAhv40gAQCASXMaGhRuaJCWLavY1yYSSvb3Fy/ymlddkjx5UqMvvZSZihP0Rw9j5La1la8u6ezMXDmns1NOXd0MnDWAuY4ABPOCLapIyLt8YoVpDSoZIiQKwobS0xR8l3EsVZFQECLYRGJmgwRjZMLhSYUIxvNyQUKu31RDhPzpDJWqFUKF/VgPAQAABDOhkEJdXQp1dVXsa61V+vRpJaOx4Gk42fBkZM9upfqiSg8NBe7HaWycqC7p7JDbXrq6xFmwgKk4QI0gADnHBAYJQesTFIYIgW0lpjUUTXmYyrSGbJ+CtRWUTs/ck2KM70O7wiWmKYxXJIxfnaFE0FCyWuF1T3ko2A9BAgAAOMcYYzKX9G1pkVavqtg/PTqqVDSaqSLJrlNSGJqMHXpFyW3blervD/7jVSiUuRJPuWk4nR1ys1frMR4fsYC5in+dZ8mm03lhwNjUQ4TCoGCqizBOIkQIWoRxVoKE/DUISoQIE5d5LBMijC+0mNsWDqxWyC2WmKs0CA4Rcv0Kx0SQAAAAUJOcSETO0qUKLV1asa9NpZTq7y9dXZINUeIH9ivVF5UdGwvcj9vaWlxdMh6Q5E3D8drb5TQ0TPcpAyiDAOQsHPrIRzWyY8eMHiP3l/+iyoGAoCBSJ6e5SYWLMJ7N2ggTlQbhoikP/oqEUFGbXJfyQAAAAMxLxnUzAUVnp6QLyva11io9NORf5DWgumT0xb1KRqNKnzkTfMyGhtLVJQXhidvSwppkwOtEAHIWWj5wvRqvuqpoysOk1kYoDBGCQgiCBAAAAGDOMsbIbWqS29Sk8MqVFfunx8ZyAUmp6pLEkSMa2b1LqVi/lEoV78Tz5LW15apH/AFJQZVJW5tMODz9Jw7McwQgZ6HtxhurPQQAAAAA84QTDstZvFihxYsr9rXptFIDA5nqkrJrlxxSMhqVHR0NPmZLyySrSzrkNDbwB1icEwhAAAAAAGCOMI4jr61NXlub6s4/v2xfa63s8HDZoCQVjSr+hz9oePNmpQYGgo8ZifjWJim3honb0sIaepi3CEAAAAAAYB4yxsg0Nirc2KjwihUV+9uxMSX7+wOvjDM+NSdx4oRGX3xRyVhMSiaLd+I4uSve+C4hHBSadHTIYSoO5hACEAAAAAA4B5hwWKHuboW6uyv2tem00qdPV6wuGTu8U6loVOnh4cD9OM3Nk64ucZqamIqDGUUAAgAAAADwMY6TuaRva6vq1qyp2D89PKxkrD9bSRJcXRI/+LJSW7cqdeqUZG3xMcPhzHol40FJR6e8jvbcGia+9UxaWzNXogSmgFcMAAAAAOB1cRoaFG5okJYtrdjXJpNK9feXDEqS0T6l+qKK9+xTMhqVEoninRgjt60tG5CUqy7J3DqRyAycNeYbAhAAAAAAwKwxnidv4UJ5CxdW7GutVfrMGSX7okrFokr2RZWMRZUav82GJyMv7FEqGlN6cDBwP05Dg38aTpnqEmfBAqbi1CgCEAAAAADAnGSMkbtggdwFC6TVqyr2T4+OKhWLla0uSbx6WCPP71Cqv19Kp4t3EgplgpLxywaXqy5pb5MJhWbgzDETCEAAAAAAADXBiUTkLFmi0JIlFfvaVEqpU6d81SXFVSYxxQ/sV6ovKjs2Frgft6UlU13S0TERmpSqLmlomO5TxhQQgAAAAAAAzjnGdXMBRSXWWqWHhgIuIey/Qk78pR4NRZ9R+vTp4GPW1wcHJQGXEHZbWmQcZ7pP+5xGAAIAAAAAQBnGGLlNTXKbmhQ+77yK/dNjY5mpOGWqSxJHj2pk9y6lYv1SKlW8E9eV296WDUoKQ5OCKpP2dplweAbOvLYQgAAAAAAAMI2ccFjOokUKLVpUsa9Np5UaGMhUkhQGJXnVJWOHDikZjcqOjgYfc8GCktNwCqfjOI2N5+RCrwQgAAAAAABUiXEceW1t8traVLd2bcX+6aEhJWMxJfv6iqpMxqtL4vv3a3hzn1IDA8HHrKvzBSOF1SVNf3SV3JaW6T7VqiMAAQAAAABgnnAaGxVubFR4+fKKfW0ioWSsv+wir4neExrdu1fJWExKJCRJq598ggAEAAAAAADMDyYUUqi7S6Hurop9rbVKDwwoGYsptGzZLIxu9hGAAAAAAABwjjPGyG1tldvaWu2hzBiuqQMAAAAAAGoeAQgAAAAAAKh5BCAAAAAAAKDmEYAAAAAAAICaRwACAAAAAABqHgEIAAAAAACoeQQgAAAAAACg5hGAAAAAAACAmkcAAgAAAAAAah4BCAAAAAAAqHkEIAAAAAAAoOYRgAAAAAAAgJpHAAIAAAAAAGoeAQgAAAAAAKh5BCAAAAAAAKDmEYAAAAAAAICaRwACAAAAAABqHgEIAAAAAACoeQQgAAAAAACg5hGAAAAAAACAmkcAAgAAAAAAap6x1lbnwMaclHRK0kBVBnDuahHPuVRbz8N8OZe5NM5qjmU2jz3Tx+qU1DeD+wfKmUu/U84VPOcZtfQ8zJdzmUvj5D3E9OA9BGbSedbahUENVQtAJMkY86C19raqDeAcxHOeUUvPw3w5l7k0zmqOZTaPPdPHMsZstdZumqn9A+XMpd8p5wqe84xaeh7my7nMpXHyHmLa9s97CFRFtafAPFnl45+LeM4zaul5mC/nMpfGWc2xzOax59JzDkw3Xt+zj+c8o5aeh/lyLnNpnLyHAOaxqlaAAADmL/56AwAAzgbvIVAt1a4AAQDMXw9WewAAAGBe4j0EqoIKEAAAAAAAUPOoAAEAAAAAADWPAAQAAAAAANQ8AhAAAAAAAFDzCEAAANPCGHO1MeZfjTEPGGOurvZ4AADA/GCMcYwx/8sY83VjzH+o9nhQuwhAAAAlGWO+ZYzpNcbsKdj+x8aYHmPMfmPMn2U3W0mDkiKSXpvtsQIAgLljiu8h3i9pmaSEeA+BGcRVYAAAJRlj/o0yoca3rbUXZ7e5kvZJ+rfKvEnZIumjkl6y1qaNMd2S/spae1OVhg0AAKpsiu8h/p2kfmvtN4wxj1trb6jSsFHjqAABAJRkrf2tpFjB5jdL2m+tfdlaOybpO5Leb61NZ9v7JdXN4jABAMAcM5X3EMqEIf3ZPqnZGyXONV61BwAAmHeWSjqc9/1rkq4wxnxA0jWSWiX9TRXGBQAA5rbA9xCSvibp68aYP5L022oMDOcGAhAAwLSw1v5A0g+qPQ4AADC/WGuHJd1a7XGg9jEFBgAwVUckLc/7fll2GwAAQDm8h0BVEYAAAKZqi6TzjTGrjDFhSR+R9ESVxwQAAOY+3kOgqghAAAAlGWMelfSspHXGmNeMMbdaa5OSPiXpZ5L2SnrMWvtCNccJAADmFt5DYC7iMrgAAAAAAKDmUQECAAAAAABqHgEIAAAAAACoeQQgAAAAAACg5hGAAAAAAACAmkcAAgAAAAAAah4BCAAAAAAAqHkEIAAAAAAAoOYRgAAAgHnHGONVewwAAGB+IQABAABVY4xZaYzZa4z5pjHmBWPM/zPG1Btj/tQY86IxZpcx5jvZvv/dGPOwMeZpSQ8bY7qNMT80xuzMfl1Z5dMBAABzGH89AQAA1Xa+pI9aa/+TMeYxSR+U9GeSVllr48aY1ry+F0m6ylo7Yoz5rqTfWGuvN8a4kppmfeQAAGDeoAIEAABU20Fr7Y7s/W2SVkraJekfjTE3S0rm9X3CWjuSvf8OSfdLkrU2Za0dmJ3hAgCA+YgABAAAVFs8735KmQrV90r6W0kbJG3JW/NjaJbHBgAAagQBCAAAmGscScuttb+SdKekFgVPb3lK0ickyRjjGmNaZm+IAABgviEAAQAAc40r6RFjzG5Jz0v6a2vtqYB+/0XS27P9timzPggAAEAgY62t9hgAAAAAAABmFBUgAAAAAACg5hGAAAAAAACAmkcAAgAAAAAAah4BCAAAAAAAqHkEIAAAAAAAoOYRgAAAAAAAgJpHAAIAAAAAAGoeAQgAAAAAAKh5/x9MgB0LqIPI9QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_comparison(normal_double_row, normal_double_col, 700)\n", + "plt.title(\"Row / Column Major Ordering, Full Dot Product\")\n", + "plt.axhline(1.0, linestyle='--', color='k')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "35a7b585", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'CuBLASChunkedLoop'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m fig, ax \u001b[39m=\u001b[39m plot_comparison(redundant_single_row, redundant_single_col, \u001b[39m3\u001b[39;49m)\n\u001b[1;32m 2\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39mRow / Column Major Ordering, Redundant\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m plt\u001b[39m.\u001b[39maxhline(\u001b[39m1.0\u001b[39m, linestyle\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m--\u001b[39m\u001b[39m'\u001b[39m, color\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mk\u001b[39m\u001b[39m'\u001b[39m)\n", + "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36mplot_comparison\u001b[0;34m(t1, t2, outer_label)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[39mcontinue\u001b[39;00m\n\u001b[1;32m 15\u001b[0m r1 \u001b[39m=\u001b[39m get_res(t1, method)\n\u001b[0;32m---> 16\u001b[0m r2 \u001b[39m=\u001b[39m get_res(t2, method)\n\u001b[1;32m 18\u001b[0m ax\u001b[39m.\u001b[39mplot(nsrcs, r1 \u001b[39m/\u001b[39m r2, color\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mC\u001b[39m\u001b[39m{\u001b[39;00mj\u001b[39m}\u001b[39;00m\u001b[39m'\u001b[39m, label\u001b[39m=\u001b[39mmethod)\n\u001b[1;32m 20\u001b[0m \u001b[39m# ax.set_title(f\"Nant x Nfeed={nants_redundant}\")\u001b[39;00m\n", + "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36mplot_comparison..get_res\u001b[0;34m(t, method)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_res\u001b[39m(t, method):\n\u001b[0;32m----> 9\u001b[0m res \u001b[39m=\u001b[39m [t[method]\u001b[39m.\u001b[39mget((outer_label, n), \u001b[39mNone\u001b[39;00m) \u001b[39mfor\u001b[39;00m n \u001b[39min\u001b[39;00m nsides] \n\u001b[1;32m 10\u001b[0m \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39marray([r\u001b[39m.\u001b[39mbest \u001b[39mif\u001b[39;00m r \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m np\u001b[39m.\u001b[39mnan \u001b[39mfor\u001b[39;00m r \u001b[39min\u001b[39;00m res])\n", + "\u001b[1;32m/ocean/projects/phy210034p/sgm/vis_cpu/devel/viscalc-performance/performance_test_large_matrix_multiply.ipynb Cell 21\u001b[0m line \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_res\u001b[39m(t, method):\n\u001b[0;32m----> 9\u001b[0m res \u001b[39m=\u001b[39m [t[method]\u001b[39m.\u001b[39mget((outer_label, n), \u001b[39mNone\u001b[39;00m) \u001b[39mfor\u001b[39;00m n \u001b[39min\u001b[39;00m nsides] \n\u001b[1;32m 10\u001b[0m \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39marray([r\u001b[39m.\u001b[39mbest \u001b[39mif\u001b[39;00m r \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m np\u001b[39m.\u001b[39mnan \u001b[39mfor\u001b[39;00m r \u001b[39min\u001b[39;00m res])\n", + "\u001b[0;31mKeyError\u001b[0m: 'CuBLASChunkedLoop'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plot_comparison(redundant_single_row, redundant_single_col, 3)\n", + "plt.title(\"Row / Column Major Ordering, Redundant\")\n", + "plt.axhline(1.0, linestyle='--', color='k')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43edc168", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From af6f2731477e6cae42ee2eb6839e851cf14cdd8c Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 23 Oct 2023 15:38:04 +0000 Subject: [PATCH 14/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- devel/viscalc-performance/getperf.py | 15 ++++++++++----- devel/viscalc-performance/methods/__init__.py | 1 + .../methods/cublas_chunkedloop.py | 2 +- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 0c80661..1817096 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -10,6 +10,7 @@ from methods._lib import RedundantSolver, Solver from pathlib import Path + @dataclass class TimeResult: times: list[float] @@ -179,6 +180,7 @@ def get_solver(solver): cli = click.Group() + @cli.command() @click.argument("solver", type=str, required=True) @click.option("--max-nants", type=int, default=350) @@ -260,7 +262,8 @@ def main( transpose=transpose, ) -def get_redundancies(bls, ndecimals: int=2): + +def get_redundancies(bls, ndecimals: int = 2): uvbins = set() pairs = [] @@ -274,10 +277,11 @@ def get_redundancies(bls, ndecimals: int=2): u, v = bls[i, j] if (u, v) not in uvbins and (-u, -v) not in uvbins: uvbins.add((u, v)) - pairs.append([i,j]) + pairs.append([i, j]) return pairs + @cli.command() @click.argument("solver", type=str, required=True) @click.option("--double/--single", default=True) @@ -295,7 +299,7 @@ def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): # We also need the pairs for the pol axis if ax_moves_first: pairs *= 2 - pairs = np.array([[p, p + 1] for p in pairs]).reshape((2*len(pairs), 2)) + pairs = np.array([[p, p + 1] for p in pairs]).reshape((2 * len(pairs), 2)) else: pairs = np.concatenate((pairs, pairs + len(pairs)), axis=0) @@ -305,10 +309,10 @@ def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): test_solver(solver, 50, 1000, ctype) nant = len(antpos) - nsrc = 12*nside**2 + nsrc = 12 * nside**2 # now run the actual computation - z = getz((2*nant, 2*nsrc), transpose=transpose, ctype=ctype) + z = getz((2 * nant, 2 * nsrc), transpose=transpose, ctype=ctype) if solver.is_redundant: sln = solver(z, pairs=pairs) @@ -317,5 +321,6 @@ def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): sln() + if __name__ == "__main__": cli() diff --git a/devel/viscalc-performance/methods/__init__.py b/devel/viscalc-performance/methods/__init__.py index b1634d1..1e573a8 100644 --- a/devel/viscalc-performance/methods/__init__.py +++ b/devel/viscalc-performance/methods/__init__.py @@ -3,6 +3,7 @@ from .cublas_vectorloop import CuBLASVectorLoop from .cublas_zgemm import CuBLASZgemm from .cublas_zherk import CuBLASZherk + # from .jax_chunkedloop import JAXChunkedLoop # from .jax_dot import JAXDot # from .jax_vectorloop import JAXVectorLoop diff --git a/devel/viscalc-performance/methods/cublas_chunkedloop.py b/devel/viscalc-performance/methods/cublas_chunkedloop.py index 16f816f..84ee32b 100644 --- a/devel/viscalc-performance/methods/cublas_chunkedloop.py +++ b/devel/viscalc-performance/methods/cublas_chunkedloop.py @@ -42,7 +42,7 @@ def compute(self): # Make new contiguous array for these antennas. m = cuda_take_along_axis(zc, b, axis=1) thisn = len(b) - + self.gemv( self.h, "n", # conjugate transpose for first (remember fortran order) From 92f40762d4c25c779cb2c4c6657ee3ab42c82456 Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Tue, 14 Nov 2023 08:06:05 -0500 Subject: [PATCH 15/16] fix: hera-profile addition of pols --- devel/viscalc-performance/getperf.py | 8 ++++---- src/vis_cpu/gpu.py | 12 +++++++++++- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 1817096..190e8ff 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -194,7 +194,7 @@ def get_solver(solver): @click.option( "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".") ) -def main( +def profile( solver, max_nants: int, n_nants: int, @@ -298,10 +298,10 @@ def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): # We also need the pairs for the pol axis if ax_moves_first: - pairs *= 2 - pairs = np.array([[p, p + 1] for p in pairs]).reshape((2 * len(pairs), 2)) + pairs *= 4 + pairs = np.array([[p, p + 1, p+2, p+3] for p in pairs]).reshape((4 * len(pairs), 2)) else: - pairs = np.concatenate((pairs, pairs + len(pairs)), axis=0) + pairs = np.concatenate((pairs, pairs + len(pairs), pairs + 2*len(pairs), pairs + 3*len(pairs)), axis=0) solver = get_solver(solver) diff --git a/src/vis_cpu/gpu.py b/src/vis_cpu/gpu.py index 234e400..608a9a7 100644 --- a/src/vis_cpu/gpu.py +++ b/src/vis_cpu/gpu.py @@ -426,7 +426,7 @@ def vis_gpu( f"Using {block} = {np.prod(block)} threads in total, in a grid of {grid}, " "for measurement equation." ) - + meas_eq( A_gpu, Isqrt_lim_gpu, @@ -441,6 +441,16 @@ def vis_gpu( ) event["meas_eq"].record(stream) + if t==0: + # FOR DEBUGGING, write stuff to file + _a = np.zeros(A_gpu.shape[:-1] + (len(Isqrt),), dtype=complex_dtype) + _a[..., above_horizon] = A_gpu.get() + np.save(f"t0_f{freq}_sky.npy", Isqrt*_a) + + vcpu = np.zeros((nfeed, nant, nax , nsrc), dtype=complex_dtype) + vcpu[..., above_horizon] = v_gpu.get().reshape((nfeed, nant, nax, nsrcs_up)) + np.save(f"t0_f{freq}_v.npy", vcpu) + _logdebug(v_gpu, "vant") # compute vis = dot(v, v.T) From 48d83f732cd90009a07a653b8e16dedfe8459f40 Mon Sep 17 00:00:00 2001 From: Steven Murray Date: Tue, 23 Jan 2024 05:37:10 -0500 Subject: [PATCH 16/16] feat: add rowswap --- devel/viscalc-performance/getperf.py | 81 +++++--- devel/viscalc-performance/methods/_cp.py | 44 +++++ devel/viscalc-performance/methods/_cublas.py | 20 +- devel/viscalc-performance/methods/_lib.py | 8 +- devel/viscalc-performance/methods/_rowswap.py | 173 ++++++++++++++++++ devel/viscalc-performance/methods/cp_dot.py | 10 + .../viscalc-performance/methods/cp_rowswap.py | 105 +++++++++++ .../methods/cublas_rowswap.py | 99 ++++++++++ .../methods/cublas_vectorloop.py | 24 ++- 9 files changed, 527 insertions(+), 37 deletions(-) create mode 100644 devel/viscalc-performance/methods/_cp.py create mode 100644 devel/viscalc-performance/methods/_rowswap.py create mode 100644 devel/viscalc-performance/methods/cp_dot.py create mode 100644 devel/viscalc-performance/methods/cp_rowswap.py create mode 100644 devel/viscalc-performance/methods/cublas_rowswap.py diff --git a/devel/viscalc-performance/getperf.py b/devel/viscalc-performance/getperf.py index 190e8ff..444b4ad 100644 --- a/devel/viscalc-performance/getperf.py +++ b/devel/viscalc-performance/getperf.py @@ -9,7 +9,7 @@ from dataclasses import asdict, dataclass from methods._lib import RedundantSolver, Solver from pathlib import Path - +import json @dataclass class TimeResult: @@ -75,9 +75,9 @@ def get_timing(sln, repeats: int = 3) -> float: return TimeResult(times, n) -def test_solver(solver, nants, nsrcs, ctype=complex): +def test_solver(solver, nants, nsrcs, ctype=complex, **opts): z0 = getz((nants, nsrcs), ctype) - solver.test(z0, np.dot(z0, z0.T.conj())) + solver.test(z0, np.dot(z0, z0.T.conj()), **opts) def get_timings( @@ -281,6 +281,37 @@ def get_redundancies(bls, ndecimals: int = 2): return pairs +def make_polpairs(pairs, feed_moves_first: bool = False): + if feed_moves_first: + p = pairs * 2 + p1 = p.copy() + p2 = p.copy(); p2[:, 0] += 1 + p3 = p.copy(); p3[:, 1] += 1 + p4 = p.copy(); p4 += 1 + return np.array([p1,p2,p3,p4]).transpose((1, 0, 2)).reshape((-1, 2)) + else: + nmax = pairs.max() + 1 + p1 = pairs.copy() + p2 = pairs.copy(); p2[:, 0] += nmax + p3 = pairs.copy(); p3[:, 1] += nmax + p4 = pairs.copy(); p4 += nmax + return np.concatenate([p1,p2,p3,p4]) + +def get_hera_pairs(hex_num: int, outriggers: bool=False, feed_moves_first: bool = True): + from py21cmsense.antpos import hera + + cachename = Path("hera-pair-cache") / f'hex{hex_num}_outriggers{outriggers}_feedfirst{feed_moves_first}' + if cachename.exists(): + d = np.load(cachename) + return d['antpos'], d['pairs'] + + antpos = hera(hex_num=hex_num, split_core=True, outriggers=2 if outriggers else 0) + bls = antpos[np.newaxis, :, :2] - antpos[:, np.newaxis, :2] + pairs = np.array(get_redundancies(bls.value)) + pairs = make_polpairs(pairs, feed_moves_first=feed_moves_first) + + np.savez(cachename, antpos=antpos, pairs=pairs) + return antpos, pairs @cli.command() @click.argument("solver", type=str, required=True) @@ -288,25 +319,20 @@ def get_redundancies(bls, ndecimals: int = 2): @click.option("--transpose/--no-transpose", default=False) @click.option("--outriggers/--core", default=False) @click.option("--nside", type=int, default=256) -@click.option("--ax-moves-first/--ant-moves-first", default=True) -def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): - from py21cmsense.antpos import hera - - antpos = hera(hex_num=11, split_core=True, outriggers=2 if outriggers else 0) - bls = antpos[np.newaxis, :, :2] - antpos[:, np.newaxis, :2] - pairs = np.array(get_redundancies(bls.value)) - - # We also need the pairs for the pol axis - if ax_moves_first: - pairs *= 4 - pairs = np.array([[p, p + 1, p+2, p+3] for p in pairs]).reshape((4 * len(pairs), 2)) - else: - pairs = np.concatenate((pairs, pairs + len(pairs), pairs + 2*len(pairs), pairs + 3*len(pairs)), axis=0) +@click.option("--feed-moves-first/--ant-moves-first", default=True) +@click.option("--solver-opts", type=str, default="{}", help="JSON-parsable options for the solver") +@click.option( + "--cache", type=click.Path(exists=True, file_okay=False), default=Path(".") +) +@click.option("--hex-num", default=11, type=int, help="Size of side of HERA hex") +def hera_profile(solver, double, transpose, outriggers, nside, feed_moves_first, solver_opts, cache, hex_num): + antpos, pairs = get_hera_pairs(hex_num, outriggers, feed_moves_first) + solver_opts = json.loads(solver_opts) solver = get_solver(solver) ctype = complex if double else np.complex64 - test_solver(solver, 50, 1000, ctype) + #test_solver(solver, 50, 1000, ctype, **solver_opts) nant = len(antpos) nsrc = 12 * nside**2 @@ -315,12 +341,21 @@ def hera_profile(solver, double, transpose, outriggers, nside, ax_moves_first): z = getz((2 * nant, 2 * nsrc), transpose=transpose, ctype=ctype) if solver.is_redundant: - sln = solver(z, pairs=pairs) + sln = solver(z, pairs=pairs, **solver_opts) else: - sln = solver(z) - - sln() - + sln = solver(z, **solver_opts) + + res = get_timing(sln, repeats=3) + + optstr = "_".join(f"{k.replace('_', '')}-{v}" for k, v in solver_opts.items()) + # Cache it + dstr = 'd' if double else 's' + tstr = 't' if transpose else 'n' + ostr = 'o' if outriggers else 'c' + fstr = 'f' if feed_moves_first else 'a' + pth = Path(cache) / f"{solver.__name__}_{nside}_ants{len(antpos)}_{dstr}{tstr}{ostr}{fstr}_{optstr}.yaml" + with open(pth, "w") as fl: + yaml.dump(asdict(res), fl) if __name__ == "__main__": cli() diff --git a/devel/viscalc-performance/methods/_cp.py b/devel/viscalc-performance/methods/_cp.py new file mode 100644 index 0000000..54c8d6a --- /dev/null +++ b/devel/viscalc-performance/methods/_cp.py @@ -0,0 +1,44 @@ +import cupy as cp +from ._lib import Solver, RedundantSolver + + +from skcuda.cublas import ( + cublasCgemm, + cublasCgemv, + cublasCherk, + cublasZgemm, + cublasZgemv, + cublasZherk, + cublasCreate, +) + + +class _CuPyCommon: + def create(self): + self.h = cublasCreate() + if self._z.dtype.name == "complex128": + self.gemm = cublasZgemm + self.herk = cublasZherk + self.gemv = cublasZgemv + else: + self.gemm = cublasCgemm + self.herk = cublasCherk + self.gemv = cublasCgemv + +class _CuPy(_CuPyCommon, Solver): + def setup(self): + super().setup() + if self.transposed: + nant = self.z.shape[1] + else: + nant = self.z.shape[0] + self.out = cp.empty(shape=(nant, nant), dtype=self._z.dtype) + self.z = cp.asarray(self._z) + + +class _CuPyRed(_CuPyCommon, RedundantSolver): + def setup(self): + super().setup() + self.out = cp.empty(self.pairs.shape[0], dtype=self._z.dtype) + self.z = cp.asarray(self._z) + \ No newline at end of file diff --git a/devel/viscalc-performance/methods/_cublas.py b/devel/viscalc-performance/methods/_cublas.py index 03f5a88..9ac6620 100644 --- a/devel/viscalc-performance/methods/_cublas.py +++ b/devel/viscalc-performance/methods/_cublas.py @@ -11,7 +11,7 @@ with warnings.catch_warnings(): warnings.simplefilter("ignore") - import pycuda.autoinit + from pycuda import autoinit from pycuda import compiler from pycuda import cumath as cm from pycuda import driver, gpuarray @@ -44,8 +44,7 @@ def cublasCdotc_inplace(handle, n, x, incx, y, incy, result): class _CuBLASCommon: - def setup(self): - self.z = gpuarray.to_gpu(self._z) + def create(self): self.h = cublasCreate() if self._z.dtype.name == "complex128": @@ -62,18 +61,22 @@ def setup(self): class _CuBLAS(_CuBLASCommon, Solver): def setup(self): - super().setup() + self.create() if self.transposed: - nant = self.z.shape[1] + nant = self._z.shape[1] else: - nant = self.z.shape[0] + nant = self._z.shape[0] + self.z = gpuarray.to_gpu(self._z) + self.out = gpuarray.empty(shape=(nant, nant), dtype=self._z.dtype) class _CuBLASRed(_CuBLASCommon, RedundantSolver): def setup(self): - super().setup() + self.create() self.out = gpuarray.empty(self.pairs.shape[0], dtype=self._z.dtype) + self.z = gpuarray.to_gpu(self._z) + take_along_axis_kernel_code = r""" @@ -128,6 +131,9 @@ def setup(self): if HAVE_PYCUDA: + def sync(): + autoinit.context.synchronize() + def _compile_take(dtype): take_along_axis_template = Template(take_along_axis_kernel_code) take_along_axis_code = take_along_axis_template.render(TYPE=dtype) diff --git a/devel/viscalc-performance/methods/_lib.py b/devel/viscalc-performance/methods/_lib.py index f6750dd..e541a0d 100644 --- a/devel/viscalc-performance/methods/_lib.py +++ b/devel/viscalc-performance/methods/_lib.py @@ -29,13 +29,13 @@ def __call__(self) -> np.ndarray: return out @classmethod - def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): + def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None, **opts): if rtol is None: rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 if atol is None: atol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 - obj = cls(z0) + obj = cls(z0, **opts) result = obj() np.testing.assert_allclose(np.triu(result), np.triu(v0), rtol=rtol, atol=atol) @@ -53,7 +53,7 @@ def __init__(self, z: np.ndarray, pairs: np.ndarray): self.pairs = pairs @classmethod - def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): + def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None, **opts): if rtol is None: rtol = 1e-5 if z0.dtype.name == "complex128" else 1e-3 if atol is None: @@ -62,7 +62,7 @@ def test(cls, z0: np.ndarray, v0: np.ndarray, rtol=None, atol=None): # All the pairs. nant = min(z0.shape) pairs = np.array([(a, b) for a in range(nant) for b in range(nant)]) - obj = cls(z0, pairs) + obj = cls(z0, pairs, **opts) result = obj() np.testing.assert_allclose( np.triu(result.reshape((nant, nant))), np.triu(v0), rtol=rtol, atol=atol diff --git a/devel/viscalc-performance/methods/_rowswap.py b/devel/viscalc-performance/methods/_rowswap.py new file mode 100644 index 0000000..adf62b1 --- /dev/null +++ b/devel/viscalc-performance/methods/_rowswap.py @@ -0,0 +1,173 @@ +import numpy as np + +def get_submatrices(pairs, max_subs: int=4, verbose: bool=False): + """ + Split a full matrix of antenna-pairs into submatrices that contain given pairs. + + Notes + ----- + This function is not gauranteed to return the optimal decomposition. It does the + following: + + 1. Gets the arrays of ant1 and ant2, and sorts each one (in reverse) in order of + how many times it appears in the pairs given. Since the pairs given (if + representing unique baselines) are not a unique representative set, this is + is not necessarily optimum. + 2. Try different numbers of sub-matrices, starting with 1 and going up by one up + to ``max_subs``. Each submatrix is limited to placing cuts in the ant1 array. + That is, the final result is just a partition of ant1 into Nsub sections. + 3. To decide where these cuts should be, we start with the first cut, try it at one + antenna, check the density of unique pairs for that antenna matched with all ant2 + antennas it requires, and if it's above a certain threshold density, try + including the next antenna in ant1, and so on until it crosses the threshold + density (starting at 0.8). + 4. Once it hits that threshold, it starts trying to place the next cut in the same + way, starting from the antenna its up to. + 5. Once all the cuts are placed, checks the density of the last matrix (which didn't + get checked when placing the cuts), and if it is below the threshold density, we + start again with a lowered threshold. + + This obtains N submatrices that all have roughly the same density of desired pairs + within the size of the matrices, as high as possible under the constraints of the + method. Note that having a roughly uniform density for the sub-matrices is not + strictly necessary to achieve optimum *overall* density, but is a reasonably simple + metric to optimize that correlates with the desired metric. + + Furthermore, the "best" solution is the one that affords the fastest matrix + multiplication as a sum over all sub-matrices. This is not achieved simply by + obtaining the highest density partition, but is also a function of the number of + submatrices. + + Since the method is constrained to slicing up the ant1 array, it is not symmetric. + One should also try reversing the pairs as an input to see if that yields a better + solution. In principle, one can arbitrarily reverse individual pairs as well, but + we do not try that here. + + Parameters + ---------- + pairs : numpy.ndarray + A numpy array of shape (n, 2) representing pairs. + max_subs : int, optional + The maximum number of sub-matrices to try. Default is 4. + verbose : bool, optional + Whether to print verbose output. Default is False. + + Returns + ------- + antmap : dict + A dictionary mapping ants to pairs. + all_antlists : list + A list of lists of lists representing the ant lists for each sub-matrix. + + Examples + -------- + >>> pairs = np.array([[1, 2], [2, 3], [3, 4]]) + >>> antmap, all_antlists = get_submatrices(pairs, max_subs=3, verbose=True) + There are 3 ants to go around + Trying 2 sub-matrices + With tol_density=0.80 + Got 0 ants for submatrix 0 with final density 0.000 going to 0.000 + With tol_density=0.77 + Got 1 ants for submatrix 1 with final density 0.000 going to 0.000 + Trying 3 sub-matrices + With tol_density=0.80 + Got 0 ants for submatrix 0 with final density 0.000 going to 0.000 + With tol_density=0.77 + Got 1 ants for submatrix 1 with final density 0.000 going to 0.000 + With tol_density=0.74 + Got 2 ants for submatrix 2 with final density 0.000 going to 0.000 + ({1: [2], 2: [3], 3: [4]}, [[[1]], [[2]], [[3]]]) + """ + # Here's where the magic happens. + ant1, ant1_counts = np.unique(pairs[:, 0], return_counts=True) + ant2, ant2_counts = np.unique(pairs[:, 1], return_counts=True) + + idx1 = np.argsort(ant1_counts)[::-1] + idx2 = np.argsort(ant2_counts)[::-1] + + ant1 = ant1[idx1] + ant2 = ant2[idx2] + n1 = len(ant1) + + if verbose: + print(f"There are {n1} ants to go around") + antmap = {a: [p[1] for p in pairs if p[0]==a] for a in ant1} + + densities = [len(pairs) / (len(ant1)*len(ant2))] + + all_densities = [densities] + all_antlists = [[ant1.tolist()]] + + for n_subs in range(2, max_subs): # try different numbers of sub-matrices + + if verbose: + print(f"Trying {n_subs} sub-matrices") + + # the fraction of the area upper triangle to the blocky upper triangle made + # n_subs equal-height rectangles. This is the highest density we could + # possibly get for this n_subs. + tol_density = 0.8 + + while True: + if verbose: + print(f" With tol_density={tol_density:.2f}") + + sub_densities = [0]*n_subs + antlists = [] + + curr_ant = 0 + next_densities = [] + for subline in range(n_subs-1): # play with where each submatrix starts and stops + cols_included = set() + pairs_included = [] + antlist = [] + + for idx, ant in enumerate(ant1[curr_ant:], start=curr_ant): # try different number of rows + cols_included.update(antmap[ant]) + pairs_included.extend(antmap[ant]) + #print(len(cols_included), len(pairs_included)) + this_density = len(pairs_included) / ((idx - curr_ant + 1) * len(cols_included)) + + if this_density < tol_density: + if verbose: + print(f" Got {idx-curr_ant} ants for submatrix {subline} with final density {sub_densities[subline]:.3f} going to {this_density}") + curr_ant = idx + next_densities.append(this_density) + break + + antlist.append(ant) + sub_densities[subline] = this_density + else: + # We hit the end of all the ants and never broke the density! + antlists.append(antlist) + break + + antlists.append(antlist) + else: + # The last square also should be above the tolerance. + pairs_included = sum((antmap[ant] for ant in ant1[curr_ant:]), start=[]) + cols_included = set(pairs_included) + this_density = len(pairs_included) / ((n1-curr_ant) * len(cols_included)) + sub_densities[-1] = this_density + antlists.append(ant1[curr_ant:]) + + if this_density < tol_density: + # not good enough. try with a lower tolerance everywhere. + if verbose: + print(f" Final sub-matrix density too low ({this_density:.3f}). Size={n1-curr_ant}x{len(cols_included)} Reducing required density...") + tol_density = min(tol_density - 0.03, min(next_densities)) + else: + all_densities.append(sub_densities) + all_antlists.append(antlists) + if verbose: + print(f" Success! Final sub-matrix has {len(ant1)-curr_ant} ants with density {this_density:.3f}") + break + + if len(antlists) < n_subs: + # In the case we hit the end without using all our submatrices + if verbose: + print(f" Success only required {len(antlists)} sub-matrices.") + all_antlists.append(antlists) + break + + return antmap, all_antlists \ No newline at end of file diff --git a/devel/viscalc-performance/methods/cp_dot.py b/devel/viscalc-performance/methods/cp_dot.py new file mode 100644 index 0000000..d2d9076 --- /dev/null +++ b/devel/viscalc-performance/methods/cp_dot.py @@ -0,0 +1,10 @@ +from ._cp import _CuPy +import cupy as cp + +class CpDot(_CuPy): + def compute(self): + if self.transposed: + cp.dot(self.z.T, self.z.conj(), out=self.out) + else: + cp.dot(self.z, self.z.conj().T, out=self.out) + return self.out.get() \ No newline at end of file diff --git a/devel/viscalc-performance/methods/cp_rowswap.py b/devel/viscalc-performance/methods/cp_rowswap.py new file mode 100644 index 0000000..c07aecb --- /dev/null +++ b/devel/viscalc-performance/methods/cp_rowswap.py @@ -0,0 +1,105 @@ +from ._cp import _CuPyRed, cp +import numpy as np +from ._rowswap import get_submatrices +from time import perf_counter + +class CpRowSwap(_CuPyRed): + """This follows a simple method to try make the matrix as dense as possible. + + For now, it uses only the default pairs given (it does not attempt to try use + different pairs in the redundant sets). It orders the ants in order of how many + unique pairs they appear in, both for the first ant and second ant (rows and cols). + It then splits the matrix into some number of sub-matrices that attempt to maximise + the density in each. + """ + def __init__(self, *args, revpairs: bool = False, nsubs: int=3, **kwargs ): + super().__init__(*args, **kwargs) + self.revpairs = revpairs + self.nsubs = nsubs + + def setup(self): + self.create() + self.antmap, antlists = get_submatrices( + self.pairs[:, ::-1] if self.revpairs else self.pairs, + max_subs=self.nsubs + ) + self.antlist = antlists[-1] + + self.ant1list = [ + cp.array(np.sort(a)) for a in self.antlist + ] + self.ant2list = [ + cp.array(np.sort(list(set(sum((self.antmap[a] for a in antlist), start=[]))))) for antlist in self.antlist + ] + + self.out = [ + cp.zeros(shape=(len(a), len(b)), dtype=self._z.dtype) for a, b in zip(self.ant1list, self.ant2list) + ] + + + # TODO: really should figure out the computable size automatically. + if max(self._z.shape) > 12*256**2: + nsrc = self._z.shape[1] + self.z = [slice(0, nsrc//4), slice(nsrc//4, 2*nsrc//4), slice(2*nsrc//4, 3*nsrc//4), slice(3*nsrc//4, None)] + else: + self.z = [cp.array(self._z)] + + def compute(self): + outer = perf_counter() + takes_time = 0 + gemms_time = 0 + mem_time = 0 + res = [0]*len(self.out) + + for _z in self.z: + if isinstance(_z, slice): + _z = cp.array(self._z[:, _z]) + + nsrc = _z.shape[1] + + for a, b, out, r in zip(self.ant1list, self.ant2list, self.out, res): + + #start_gpu = cp.cuda.Event() + #end_gpu = cp.cuda.Event() + #start_gpu.record() + za = _z[a] + zb = _z[b] + #end_gpu.record() + #end_gpu.synchronize() + #takes_time += cp.cuda.get_elapsed_time(start_gpu, end_gpu) + + #gemms_in = cp.cuda.Event() + #gemms_out = cp.cuda.Event() + #gemms_in.record() + cp.dot(za, zb.conj().T, out=out) + # self.gemm( + # self.h, + # "c", # conjugate transpose for first (remember fortran order) + # "n", # no transpose for second. + # len(a), + # len(b), + # nsrc, + # 1.0, + # za.data, + # nsrc, + # zb.data, + # nsrc, + # 0.0, + # out.data, + # len(a), + # ) + #gemms_out.record() + #gemms_out.synchronize() + #gemms_time += cp.cuda.get_elapsed_time(gemms_in, gemms_out) + + + t0 = perf_counter() + r += out.get() + mem_time += perf_counter() - t0 + outer -= perf_counter() + + print("Full compute time: ", -outer) + print("take_along_axis compute time: ", takes_time) + print("Gemms time: ", gemms_time) + print("Memory return time: ", mem_time) + return res diff --git a/devel/viscalc-performance/methods/cublas_rowswap.py b/devel/viscalc-performance/methods/cublas_rowswap.py new file mode 100644 index 0000000..cc0d239 --- /dev/null +++ b/devel/viscalc-performance/methods/cublas_rowswap.py @@ -0,0 +1,99 @@ +from ._cublas import _CuBLASRed, cuda_take_along_axis +from . import _cublas as _cu +import numpy as np +from ._rowswap import get_submatrices +from time import perf_counter + +class CuBLASRowSwap(_CuBLASRed): + """This follows a simple method to try make the matrix as dense as possible. + + For now, it uses only the default pairs given (it does not attempt to try use + different pairs in the redundant sets). It orders the ants in order of how many + unique pairs they appear in, both for the first ant and second ant (rows and cols). + It then splits the matrix into some number of sub-matrices that attempt to maximise + the density in each. + """ + def __init__(self, *args, revpairs: bool = False, nsubs: int=3, **kwargs ): + super().__init__(*args, **kwargs) + self.revpairs = revpairs + self.nsubs = nsubs + + def setup(self): + self.create() + + self.antmap, antlists = get_submatrices( + self.pairs[:, ::-1] if self.revpairs else self.pairs, + max_subs=self.nsubs + ) + self.antlist = antlists[-1] + + self.ant1list = [ + _cu.gpuarray.to_gpu(np.sort(a)) for a in self.antlist + ] + self.ant2list = [ + _cu.gpuarray.to_gpu(np.sort(list(set(sum((self.antmap[a] for a in antlist), start=[]))))) for antlist in self.antlist + ] + + self.out = [ + _cu.gpuarray.zeros(shape=(len(a), len(b)), dtype=self._z.dtype) for a, b in zip(self.ant1list, self.ant2list) + ] + + + # TODO: really should figure out the computable size automatically. + if max(self._z.shape) > 12*256**2: + nsrc = self._z.shape[1] + self.z = [slice(0, nsrc//4), slice(nsrc//4, 2*nsrc//4), slice(2*nsrc//4, 3*nsrc//4), slice(3*nsrc//4, None)] + else: + self.z = [_cu.gpuarray.to_gpu(self._z)] + + def compute(self): + outer = perf_counter() + takes_time = 0 + gemms_time = 0 + mem_time = 0 + res = [0]*len(self.out) + + for _z in self.z: + if isinstance(_z, slice): + _z = _cu.gpuarray.to_gpu(self._z[:, _z]) + + nsrc = _z.shape[1] + + for a, b, out, r in zip(self.ant1list, self.ant2list, self.out, res): + takes_in = perf_counter() + za = cuda_take_along_axis(_z, a) + zb = cuda_take_along_axis(_z, b) + _cu.autoinit.context.synchronize() + takes_time += perf_counter() - takes_in + + gemms_in = perf_counter() + self.gemm( + self.h, + "c", # conjugate transpose for first (remember fortran order) + "n", # no transpose for second. + len(a), + len(b), + nsrc, + 1.0, + za.gpudata, + nsrc, + zb.gpudata, + nsrc, + 0.0, + out.gpudata, + len(a), + ) + _cu.autoinit.context.synchronize() + gemms_time += perf_counter() - gemms_in + + + t0 = perf_counter() + r += out.get() + mem_time += perf_counter() - t0 + outer -= perf_counter() + + print("Full compute time: ", -outer) + print("take_along_axis compute time: ", takes_time) + print("Gemms time: ", gemms_time) + print("Memory return time: ", mem_time) + return res diff --git a/devel/viscalc-performance/methods/cublas_vectorloop.py b/devel/viscalc-performance/methods/cublas_vectorloop.py index 68788ee..c9d87df 100644 --- a/devel/viscalc-performance/methods/cublas_vectorloop.py +++ b/devel/viscalc-performance/methods/cublas_vectorloop.py @@ -1,12 +1,17 @@ from ._cublas import _CuBLASRed - +from . import _cublas as _cu +from time import perf_counter class CuBLASVectorLoop(_CuBLASRed): def compute(self): + total = perf_counter() + dot = 0 + if self.transposed: size = self.z.shape[0] for i, (a, b) in enumerate(self.pairs): + t0 = perf_counter() self.dotc( self.h, size, @@ -16,9 +21,11 @@ def compute(self): 1, self.out[i].gpudata, ) + _cu.sync() + dot += perf_counter() - t0 else: size = self.z.shape[1] - + t0 = perf_counter() for i, (a, b) in enumerate(self.pairs): self.dotc( self.h, @@ -29,5 +36,16 @@ def compute(self): 1, self.out[i].gpudata, ) + _cu.sync() + dot += perf_counter() - t0 + + get = perf_counter() + res = self.out.get() + get -= perf_counter() + total -= perf_counter() + + print("Total time: ", -total) + print("Dot time:", dot) + print("Memory get time: ", get) - return self.out.get() + return res