aare/python/tests/ClusterFinderCUDA.ipynb

{
    "cells": [
        {
            "cell_type": "code",
            "execution_count": 1,
            "id": "789d5aab-0c75-4ed3-94bf-e66172f6737c",
            "metadata": {},
            "outputs": [],
            "source": [
                "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
                "\n",
                "from pathlib import Path\n",
                "import matplotlib.pyplot as plt\n",
                "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
                "import numpy as np\n",
                "import boost_histogram as bh\n",
                "import time\n",
                "\n",
                "from aare import File, ClusterFinder, ClusterFinderMT, ClusterCollector, ClusterFinderCUDA"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "id": "3f6089d6-2245-4aca-aad3-2417c16afae2",
            "metadata": {},
            "outputs": [],
            "source": [
                "# Helpers\n",
                "N_BINS = 200\n",
                "def make_hist(clusters):\n",
                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    h.fill(clusters.sum())\n",
                "    return h\n",
                "\n",
                "def make_hist_from_batch(result_list):\n",
                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    energies = [np.asarray(cv.sum()).ravel() for cv in result_list if cv.size > 0]\n",
                "    if energies:\n",
                "        h.fill(np.concatenate(energies))\n",
                "    return h"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "id": "415b09d4-d0d0-4166-8601-9d84302617bd",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Image size:       (400, 400)\n",
                        "Pedestal frames:  1000\n",
                        "Data frames:      50000\n"
                    ]
                }
            ],
            "source": [
                "base = Path('/mnt/sls_det_storage/matterhorn_data/aare_test_data/')\n",
                "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n",
                "\n",
                "n_frames_pd = 1000\n",
                "N           = 50000 #88999\n",
                "cluster_size = (9, 9)\n",
                "rows = f.rows\n",
                "cols = f.cols\n",
                "image_size   = (rows, cols)\n",
                "capacity     = 50_000 #3_000_000\n",
                "\n",
                "print(f'Image size:       {image_size}')\n",
                "print(f'Pedestal frames:  {n_frames_pd}')\n",
                "print(f'Data frames:      {N}')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "id": "3e49d862-45f4-4d37-a078-947e6b9ec9e3",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "500000"
                        ]
                    },
                    "execution_count": 4,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "f.total_frames"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "5531b79d-12ad-4de6-84b7-0224b10d13c3",
            "metadata": {},
            "source": [
                "## Pedestal (both finders trained on identical frames)"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "e33b421f-969a-41d6-8aa6-5bd859a88fb3",
            "metadata": {},
            "source": [
                "- Modify the boolean `SERIAL` to choose between the sequential CPU version (ClusterFinder) and its multi-threaded homologue (ClusterFinderMT)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "id": "6ee7c469-5a23-421a-9bb4-a76e8f57a0c1",
            "metadata": {},
            "outputs": [],
            "source": [
                "SERIAL = True"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "id": "9d8f69bf-27f6-48c8-b2da-4157d67e6b04",
            "metadata": {},
            "outputs": [],
            "source": [
                "if(SERIAL):\n",
                "    cf_cpu  = ClusterFinder(image_size, cluster_size, capacity=capacity)\n",
                "else:\n",
                "    cf_cpu  = ClusterFinderMT(image_size, cluster_size, capacity=capacity, n_threads=48)\n",
                "    sink = ClusterCollector(cf_cpu)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "id": "00e2f63a-5e64-4d3e-becf-5e2835c6d712",
            "metadata": {},
            "outputs": [],
            "source": [
                "# Runs the destructor under the hood in case cf_cuda has already been constructed\n",
                "# del cf_cuda\n",
                "cf_cuda = None"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "id": "cbdcb805-708b-4205-bda9-2aa163d0e81f",
            "metadata": {},
            "outputs": [],
            "source": [
                "N_STREAMS  = 5\n",
                "cf_cuda = ClusterFinderCUDA(image_size, \n",
                "                            cluster_size, \n",
                "                            n_sigma=7, \n",
                "                            max_clusters_per_frame=1500,\n",
                "                            n_streams=N_STREAMS) "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "id": "f70d0805-a1e9-488b-8ec7-487900f7e026",
            "metadata": {},
            "outputs": [],
            "source": [
                "cf_async = ClusterFinderCUDA(image_size,\n",
                "                             cluster_size,\n",
                "                             n_sigma=7,\n",
                "                             max_clusters_per_frame=1500,\n",
                "                             n_streams=N_STREAMS)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "id": "1546f405-1bf6-4073-ab35-8134be695a6c",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Pedestal (1000 frames): 0.659s\n"
                    ]
                }
            ],
            "source": [
                "t0 = time.perf_counter()\n",
                "for _ in range(n_frames_pd):\n",
                "    img = f.read_frame()\n",
                "    cf_cpu.push_pedestal_frame(img.copy())\n",
                "    cf_cuda.push_pedestal_frame(img.copy())\n",
                "    cf_async.push_pedestal_frame(img.copy())\n",
                "print(f'Pedestal ({n_frames_pd} frames): {time.perf_counter() - t0:.3f}s')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "5df035f0-7a27-4d5a-8f8d-c94e745bcd1a",
            "metadata": {},
            "source": [
                "## Read all data frames into memory (I/O out of the timing loop)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "id": "4573be3d-5ba8-4e18-bab0-c874f2b7dcb2",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Reading 50000 frames:        2.294s  (21800 FPS, 6652.882 GB/s)\n"
                    ]
                }
            ],
            "source": [
                "f.seek(n_frames_pd)\n",
                "t0 = time.perf_counter()\n",
                "data = f.read_n(N)\n",
                "t_io = time.perf_counter() - t0\n",
                "print(f'Reading {N} frames:        {t_io:.3f}s  ({N/t_io:.0f} FPS, '\n",
                "      f'{f.bytes_per_frame * N / 1024**2 / t_io:.3f} GB/s)')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "c1e9362e-dcc2-41af-bfa1-c62d0968477e",
            "metadata": {},
            "source": [
                "## CPU clustering"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "id": "ad47af54-c2ba-441a-a874-88dfe04d8a68",
            "metadata": {},
            "outputs": [],
            "source": [
                "from tqdm import tqdm"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "id": "fbb14fda-2852-4b73-ba2c-9952abac1d99",
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "100%|█████████████████████████████████████████████████████████████████████████████████████████████████| 50000/50000 [07:46<00:00, 107.08it/s]\n"
                    ]
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CPU clustering:          466.937s (107 FPS, 50982358 clusters, 1019.65/frame)\n"
                    ]
                }
            ],
            "source": [
                "t0 = time.perf_counter()\n",
                "for frame in tqdm(data):\n",
                "    cf_cpu.find_clusters(frame)\n",
                "t_cpu = time.perf_counter() - t0\n",
                "\n",
                "if(SERIAL):\n",
                "    clusters_cpu = cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
                "    n_clusters_cpu = clusters_cpu.size\n",
                "    \n",
                "    hist_cpu  = make_hist(clusters_cpu)\n",
                "else:\n",
                "    cf_cpu.stop()\n",
                "    sink.stop()\n",
                "    \n",
                "    clusters_cpu = sink.steal_clusters() #cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
                "    \n",
                "    hist_cpu = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
                "    n_clusters_cpu = 0\n",
                "    for cv in clusters_cpu:\n",
                "        hist_cpu.fill(cv.sum())\n",
                "        n_clusters_cpu += cv.size\n",
                "        \n",
                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "8cfd7091-8020-49ff-b033-28bf773983d8",
            "metadata": {},
            "source": [
                "## CUDA clustering"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
            "metadata": {},
            "outputs": [],
            "source": [
                "BATCHED = True\n",
                "BATCH_SIZE = 3000"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 42,
            "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba",
            "metadata": {},
            "outputs": [],
            "source": [
                "if(BATCHED):\n",
                "    # Before warmup, pin the fixed size buffer\n",
                "    batch_buffer = np.empty((BATCH_SIZE, rows, cols), dtype=np.uint16)\n",
                "    cf_cuda.register_input_buffer(batch_buffer)       # fixed ~610 MB for 2000 frames\n",
                "\n",
                "    # Warmup: first kernel launch pays CUDA context + pedestal H2D upload cost\n",
                "    _ = cf_cuda.find_clusters_batched(data[0:BATCH_SIZE], first_frame=0)\n",
                "    \n",
                "    clusters_cuda_per_frame = []\n",
                "\n",
                "    cf_cuda.reset_timers()\n",
                "    t0 = time.perf_counter()\n",
                "    for start in range(0, N, BATCH_SIZE):\n",
                "        stop = min(start + BATCH_SIZE, N)\n",
                "        batch_buffer[:stop-start] = data[start:stop]  # CPU memcpy into pinned buf\n",
                "        clusters_cuda_per_frame.extend(\n",
                "            cf_cuda.find_clusters_batched(batch_buffer[:stop-start], first_frame=start)\n",
                "        )\n",
                "    t_cuda = time.perf_counter() - t0\n",
                "\n",
                "    cf_cuda.unregister_input_buffer()  # release when done with this dataset\n",
                "\n",
                "    kernel_ms = cf_cuda.avg_kernel_time_ms()\n",
                "    \n",
                "    n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n",
                "\n",
                "    hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)\n",
                "    \n",
                "else:   \n",
                "    # Simpler: (non-batched) per-frame run on non-pinned data\n",
                "    cf_cuda.find_clusters(data[0])\n",
                "    _ = cf_cuda.steal_clusters(realloc_same_capacity=False)\n",
                "\n",
                "    cf_cuda.reset_timers()\n",
                "    t0 = time.perf_counter()\n",
                "\n",
                "    n_clusters_cuda = 0\n",
                "    hist_cuda = None\n",
                "\n",
                "    # steal the clusters as we go rather than at the end of the  dataset \n",
                "    # which might trigger an std::bad_alloc...\n",
                "    for idx, frame in enumerate(data):\n",
                "        cf_cuda.find_clusters(frame)\n",
                "        clusters_frame = cf_cuda.steal_clusters(realloc_same_capacity=True)\n",
                "\n",
                "        n_clusters_cuda += clusters_frame.size\n",
                "\n",
                "        h = make_hist(clusters_frame)\n",
                "        hist_cuda = h if hist_cuda is None else hist_cuda + h\n",
                "        \n",
                "    t_cuda = time.perf_counter() - t0\n",
                "    kernel_ms = cf_cuda.avg_kernel_time_ms()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 43,
            "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "(9, 9)"
                        ]
                    },
                    "execution_count": 43,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "cluster_size"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 44,
            "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CPU clustering:          466.937s (107 FPS, 50982358 clusters, 1019.65/frame)\n"
                    ]
                }
            ],
            "source": [
                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 45,
            "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CUDA clustering:          3.684s  (13571 FPS, 50577611 clusters, 1011.55/frame)\n",
                        "  Kernel only:            0.029 ms/frame\n",
                        "  PCIe + overhead:        0.045 ms/frame\n",
                        "Speedup (CPU / CUDA):     126.73×\n"
                    ]
                }
            ],
            "source": [
                "print(f'CUDA clustering:          {t_cuda:.3f}s  ({N/t_cuda:.0f} FPS, '\n",
                "      f'{n_clusters_cuda} clusters, {n_clusters_cuda/N:.2f}/frame)')\n",
                "print(f'  Kernel only:            {kernel_ms:.3f} ms/frame')\n",
                "print(f'  PCIe + overhead:        {t_cuda*1000/N - kernel_ms:.3f} ms/frame')\n",
                "print(f'Speedup (CPU / CUDA):     {t_cpu / t_cuda:.2f}×')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "561e372d-97dd-4ed9-b66a-b8a1a5888b97",
            "metadata": {},
            "source": [
                "## CUDA Clustering (async pipeline)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 46,
            "id": "09301746-33f1-43be-b395-9ef253d781b9",
            "metadata": {},
            "outputs": [],
            "source": [
                "BATCH_SIZE = 3000"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 47,
            "id": "ab26ae22-53bd-4f68-a148-8457ae9b9c03",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "CUDA(async pipeline):    3.384s  (14774 FPS, 50577640 clusters, 1011.55/frame)\n",
                        "  Kernel only:           0.031 ms/frame\n",
                        "  PCIe + overhead:       0.036 ms/frame\n",
                        "Speedup vs batched:      1.09×\n"
                    ]
                }
            ],
            "source": [
                "# Two alternating batch buffers — buf[cur] is in flight on the GPU while\n",
                "# buf[nxt] is being filled by the CPU memcpy.\n",
                "# Both are pinned simultaneously for DMA-speed H2D (~22 GB/s).\n",
                "buf = [np.empty((BATCH_SIZE, rows, cols), dtype=np.uint16) for _ in range(2)]\n",
                "cf_async.pin_buffer(buf[0])\n",
                "cf_async.pin_buffer(buf[1])\n",
                "\n",
                "clusters_async = []\n",
                "\n",
                "# Warmup: first call pays CUDA context + pedestal upload cost\n",
                "buf[0][:BATCH_SIZE] = data[:BATCH_SIZE]\n",
                "_ = cf_async.find_clusters_batched(buf[0], first_frame=0)\n",
                "\n",
                "cf_async.reset_timers()\n",
                "t0 = time.perf_counter()\n",
                "\n",
                "# Prime: fill buf[0] with the first real batch and submit\n",
                "cur = 0\n",
                "n0 = min(BATCH_SIZE, N)\n",
                "buf[cur][:n0] = data[:n0]\n",
                "tok = cf_async.submit_batch(buf[cur][:n0], first_frame=0)\n",
                "\n",
                "starts = list(range(BATCH_SIZE, N, BATCH_SIZE))\n",
                "for start in starts:\n",
                "    nxt  = 1 - cur\n",
                "    stop = min(start + BATCH_SIZE, N)\n",
                "    n    = stop - start\n",
                "\n",
                "    # Fill next buffer while GPU processes current batch\n",
                "    buf[nxt][:n] = data[start:stop]\n",
                "\n",
                "    # Enqueue next batch — GPU now has both batches queued back-to-back\n",
                "    next_tok = cf_async.submit_batch(buf[nxt][:n], first_frame=start)\n",
                "\n",
                "    # Drain previous batch (GPU runs next_tok concurrently)\n",
                "    clusters_async.extend(cf_async.collect(tok))\n",
                "\n",
                "    tok = next_tok\n",
                "    cur = nxt\n",
                "\n",
                "# Drain final batch\n",
                "clusters_async.extend(cf_async.collect(tok))\n",
                "\n",
                "t_async = time.perf_counter() - t0\n",
                "\n",
                "cf_async.unpin_buffer(buf[0])\n",
                "cf_async.unpin_buffer(buf[1])\n",
                "\n",
                "kernel_ms_async = cf_async.avg_kernel_time_ms()\n",
                "n_clusters_async = sum(cv.size for cv in clusters_async)\n",
                "hist_async = make_hist_from_batch(clusters_async)\n",
                "\n",
                "print(f'CUDA(async pipeline):    {t_async:.3f}s  ({N/t_async:.0f} FPS, '\n",
                "      f'{n_clusters_async} clusters, {n_clusters_async/N:.2f}/frame)')\n",
                "print(f'  Kernel only:           {kernel_ms_async:.3f} ms/frame')\n",
                "print(f'  PCIe + overhead:       {t_async*1000/N - kernel_ms_async:.3f} ms/frame')\n",
                "if 't_cuda' in dir():\n",
                "    print(f'Speedup vs batched:      {t_cuda / t_async:.2f}×')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "b966cce1-0f73-4565-a707-1aec2a69f75e",
            "metadata": {},
            "source": [
                "## Agreement check: \n",
                "- Cluster counts should match closely.\n",
                "- However, as the CUDA CF updates the pedestal once per frame rather than per-pixel, a small divergence after the first few frames is expected."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 48,
            "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Cluster count diff:       404747 (0.79%)\n"
                    ]
                }
            ],
            "source": [
                "diff = abs(n_clusters_cpu - n_clusters_cuda)\n",
                "rel  = diff / max(n_clusters_cpu, 1)\n",
                "print(f'Cluster count diff:       {diff} ({rel:.2%})')"
            ]
        },
        {
            "cell_type": "markdown",
            "id": "81638ad3-6112-4bd7-a93a-f4d97f1f94cf",
            "metadata": {},
            "source": [
                "## Plots"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 49,
            "id": "aff8db7e-8332-4228-857f-a9875cf940d3",
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "200 201\n",
                        "200 201\n"
                    ]
                }
            ],
            "source": [
                "print(len(hist_cpu.values()), len(hist_cpu.axes[0].edges))\n",
                "print(len(hist_cuda.values()), len(hist_cuda.axes[0].edges))"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 50,
            "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e",
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png":
                            "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJOCAYAAAAqFJGJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAzjpJREFUeJzsnQd4FNXext/03gtJ6E0ggqKgFAtiAQsKVvxUxHJVxI7lihWxYEHRawF7V9CrgIIiYMEGiChK751AQhokpJL5nvfE2bubRmjZ3ez781mHnT0zc+bM7Oa8829+lmVZEEIIIYQQQoiDwP9gNhZCCCGEEEIICQshhBBCCCHEIUEWCyGEEEIIIcRBI2EhhBBCCCGEOGgkLIQQQgghhBAHjYSFEEIIIYQQ4qCRsBBCCCGEEEIcNBIWQgghhBBCiINGwkIIIYQQQghx0EhYCCEOCX///TeuvvpqtG7dGqGhoYiMjMSxxx6Lp59+Gjk5OY52p5xyinkdLl555RW88847h23/wntojPfCTz/9hEsuuQRNmzZFcHAwYmJi0Lt3b4wfPx6FhYWOdq1atYKfn5/jxe9jjx498N5777nsj+0GDBhQ47F+//13s62njGF9f2P295xGjRrlMlbh4eFo1qwZ+vfvjxdffBG7d++utU9lZWVISUkx2/33v/89xGcshPchYSGEOGhef/11dOvWDQsWLMDdd9+NGTNmYPLkybj44osxYcIEXHvttQ02yo1xMikOjMZ2Lzz88MM4+eSTsXXrVjz66KOYNWsWJk6ciNNOO81Mjh944AGX9ieccALmzp1rXhwHTn6HDh1qRIi30RC/Mdwnx4rLsWPHokWLFrjnnntw5JFH4q+//qpxm2nTpmHHjh3m32+++eZB90EIbyfQ3R0QQng3/EN844034owzzsCUKVMQEhLi+Izr7rzzTvOH2puxLAvFxcUICwuDN1BUVOQ1ffUU+OSZE+/AQM/8s/jpp59i9OjRZgLNSTb7anPWWWeZCTC/i87ExsaiZ8+ejvenn346WrZsieeee858Z72FhvqNoXBJTEx0vL/00ktx8803o0+fPjjvvPOwatUql2PbYoKWI7aZOXMmtmzZYqwdQvgqslgIIQ6KJ554wkxyXnvttWp/dAn/6PKPcm388MMPZnsundmwYUM1l4V169aZP/ZpaWnmWE2aNDFPaxctWuRwgVi6dCnmzJnjcGvgOptdu3bhrrvuMq4U7BfdSW6//XYXFxLC7Tih4JPQTp06mWO9++67dY7DpEmT0KtXL0RERBgXDbpR/Pnnny5trrrqKvPZmjVrcPbZZ5t/N2/e3EyMSkpKXNqWlpbiscceQ8eOHc3xk5KSjBtIVlaWSzvb7ePzzz/HMcccY1xEHnnkEfMZx6Jfv37GtYPb33TTTZg+fbrLePPJNyfTmzdvrnZO11xzDRISEoyoqo19XRPnPvIJ81FHHWX62KZNG/znP/+ptr/6XqOKigrjptK1a1cjouxJ9BdffLHPe8G+595//30z9jwG+87rYrvFVMV+4s/7sup58ak1x5794P3C9/Y2fM974vjjjzduOAcKRUVcXJwZs5r6FxUVZa51XXCMOnTogI0bN+JQwSf57E9NT+u//vpr85l9TXjvXn/99eaet+9pWlVmz559WH9jDoajjz4a999/PzZt2mS+485s27bNCJpzzz3XWFF4TzYmC5kQB4JnPpoRQngFe/fuxXfffWee9HGycLjhZJzHpE813RR27tyJX3/9FXl5eeZzTlwvuugi43dONxhiT0T27NljniryieJ9991nJriceD700ENYvHixmdw4T9j4ZJT+7PycPtTJycl1TnzohsKJP5cUBc888wxOOukk/Pbbb0hPT3d5Ms5JEJ88c1L7448/msk9+8xjEU5QBg4caI7PJ9H0oedkkK4wjE/hBNXZIvHHH39g+fLl5tickHMim5GRYc6X/6brC/v/8ccfG8HkzA033IDHH38cr776qhEyNvRZp5sN21MIHOg1saHQoEDgxJ3j+eGHH+K2224zY0Uhsb/XiCLtgw8+MOPISTcnlxwHe+Jf171gM3LkSCMGKSD9/f3rvMZ1Tay5H04+eSyKugsuuMCs+/bbbx2T4n//+99GhKxfv95x7dhXXi+6J9U1IeW1XLJkCQYPHmxE4oHCe4/3ESf0h3LiTVH19ttvV3NH4jlxTHmPkCFDhphrxPvtiCOOMPcI32dnZ3vMb0xN8PvK7yG/q1deeaXL+bF/FOC2Neitt94y90JN4k8In8ASQogDZPv27RZ/Ri699NJ6b9OnTx/zsvn+++/NPrh0Zv369Wb922+/bd7v3LnTvH/++efr3P+RRx7psn+bMWPGWP7+/taCBQtc1v/3v/81+/3qq68c6/g+JibGysnJ2ef5bNq0yQoMDLRuueUWl/W7d++2UlJSrEsuucSxbujQoWbfn3zyiUvbs88+2+rQoYPj/ccff2zaffbZZy7t2Heuf+WVVxzrWrZsaQUEBFgrV650aXv33Xdbfn5+1tKlS13W9+/fv9p4s1/JyclWSUmJY91TTz1lxovXoTbqe03YR/Zl0aJFLuvPOOMMKzo62iosLNyva/Tjjz+a9/fff/8B3Qv2PXfyySdX++zhhx82n1WF9yHXO48HzyssLMzasmWLYx3Pke1SU1Md50WmTJli1n/xxReOdRs2bDDX7pprrqnzPObNm2e2vffee636wr7xviorKzMv9tu+/3hvOLc755xzatyHfb/Z38Ha+M9//mPaOd+D/O6EhIRYd955p2NdZGSkdfvtt1uH+zdmf8/JvuZZWVk1blNUVGQ+P+ussxzrKioqrHbt2llNmza1ysvLXfbz7bff7scZCtG4kCuUEMIriI+PR9u2bY0lgD7idDPik/36QveUzp07G9eZ8vJyx4suSzW5Yp166qnG9WRffPPNN2Y/fJLpvF8+5efT96r75bHoOuEMn8w7u6ewr3RbYTvnfbLvfNpfdZ/cnk+AnaELEM/X2VpC/u///q/aOdBykJmZafz4CceVVo5zzjnHxZXsYK4JA2D5dNuZyy67zLg+8an1/lwjutgQunYdDBdeeCEOFvaVrlQ2dH0itCw5Wxfs9c7XmU+4eX6HK+j3q6++QlBQkHnRMvLJJ5/glltucbFMHQouv/xyYw1ytrrQOkb3PlrxbOgOxjY8/rx584wFxRuofNaAat8vus7R2hQQEGDW8Vx5n9JqIYSvImEhhDhgGOjIyRPdOw43/INN1xJOMul2wzSTdOm49dZb60wHacPMLUxXaU+07Bd90zlxoAuPM6mpqfXql50R5rjjjqu2b/pkV90vx6uqaxEnZc5xDNwn3UTo3lN1n9u3b69XX+lewniHqtS0jq4sdNt6+eWXHRN8uulUdZs6mGtCQVQVe53tClPfa0RffU7matrn/lDfa1wXFFfO8JrVtb6ueJXaoIsZ2d/v2YknnmiyKNF1btmyZeaeYoyG3RfC+Bq689QERQ/hNagLnivdhZjK1t4XBQSFBAWlDb8PnIi/8cYbxgWN21GQ854+lL8xh+KcnLHFIOOIbGwxeP7555tx5YuucBzzzz77rJoroBC+gmIshBAHDCd3DNTlE+QDzYZiT7KrBi9XnTzbT3jtP+jM0MInsPTZp58+/eTrghMU+rbX9jTRORsMqa+PtL0dc9izf4cC7pNB07VluuFEe1995fa26HGmtkkcxQBTd9J68NJLLxkLCDPu7Iv6XpOajmuvY1/35xpRvHDiyO0PRhzUNG7O96NzTEZN92NDwXPs0qWLyTrEOJT6xllwotu9e/c621BoMn1tTdjraxKjVeHTelq8mAKXQoiCpmpaW16/559/3rwYDM2g7nvvvddYy2q71w/kN+ZQnZONHXxu19/Jz8834sF+oFATH330EYYPH17vYwjRWJDFQghxUDBIlU+Tr7vuOjOZrArdHb788stat7ddbfikuqY/5rXBiS+DlTnhsl1pCCeDTLdaFQbOrl271kxiOdmq+qrL5acu+LSeT0i575r2u6+JXU2wr3yKz8lzTftjZp99QTcsBvzySbUzDMiuCT555YSQAeUMkuakaH8DUGu7JoRB2FVrAXDyRZFES8f+XCOmVyX7qsdQ271QF7Xdj3Xdww3Bgw8+iNzcXCMAa3LNKSgoMMJjf2HQcU33CaFItAvr7QtmpKJLGIO4+aJAq8ntzob3Gi1iFK9V75WD/Y05VOdEeM8yAJ/3BQsT2vct7ysmXfj++++rvSig5A4lfBVZLIQQBwVdGjjB40SUmVuYb57uD/xjT597poik33zVuAIburNwIjBmzBgT08An4HSvYfpUZzjR40SET9Xbt29v3DmYLYbr+dTThpNaTp7pdsGUppzgcB0zEvEpIwuM3XHHHSYugfEAfHLKCRkn1PWdbDjDCQezEjETDFOvnnnmmeY8aC1gRihmZbLTv9YXpm9l1iRm02H8A11K6LrBJ7acuDBjFIVAXfB8ObnhJJz94xNaTohWrFhhPmcWpKpPhhmzwOxF7DOzLu2L+l4T242E7jK0ZvAJPDM68en2U0895XgCX99rRLctZhiirz7HmYKEIoL3G/fFOIK67oW64JjTRcfONkXRSLeemtLxHix0sWGMCt2D9hVnwTGmuOBklteQ/eO2tGDMnz/fZPVi1qh9pZytCu8vujDxaTwzcXF8KGA4ZrTCMXamqoWsJnj/0K2J7aOjo01mLFpMbPiUv2/fviauhimUuU9aNWipYNtD+RtzoOe0cOFC02ful6lk+TvElMTMbEXhYruQ8VrxO85sZjVlTLPHgaKkalyREI0ed0ePCyEaB8yGw6wzLVq0sIKDg62IiAjrmGOOsR566CErMzOz1qxQJCMjw7rooous+Ph4k43piiuusH7//XeX7C07duywrrrqKqtjx45m38wwc9RRR1njxo1zZGWxM+3069fPioqKMtszQ4xNQUGB9cADD5gMTOwjj9WlSxfrjjvuMNlnbLjdTTfdtF/nz6w/ffv2NVmOmA2Hx+U5zZ4929GG48O+1ycTETP5jB071jr66KOt0NBQc7489xtuuMFavXp1vTLgLFmyxDr99NPN9hzba6+91nr33XfNsf76669q7Tl2/GzYsGH1Ouf6XhO7j8zuxExNHPtWrVpZzz33XLV91vca7d271xync+fOjna9evWyvvzyy33eC3ZWqE8//bTG8/rtt9+s3r17m3Ni1h9enzfeeKPGrFA1jX1N94+d5eyZZ56pto73RX2ZM2eOua+YdSooKMjcbzxv7nfXrl377FtNcFxvvPFG891lhjOO14knnljr+NTGqlWrzPnwNWvWLJfPiouLzX3F+4N9ZjYtXmOOrXP2rEPxG7O/52R//+wXv78cX947L7zwgsu48nvDNnVlt1qxYoVpUzVTnBC+gB//525xI4QQomFggTJm7KGrlXMQL2HBObra0I3EOej2YKFVh0+U7cJxQgghGidyhRJCiEYKXXnogkQ3IPrgc2LPjDyMg3AWFXQnYdYdtqeb1aEUFUIIIXwHCQshhGikMC6DNSYYm8E0m4yDoO83fdCdYbwGMywxdmFf2bWEEEKI2pArlBBCCCGEEOKgUbpZIYQQQgghxEEjYSGEEEIIIYQ4aCQshBBCCCGEEN4dvM2CN3xt2LDBvGcmkoceeshRVZUFmt59912XbVgcad68eY73JSUlpkgN0yeyEuZpp52GV155Bc2aNXO0sauV2pV8WaSJaRVjY2MdbViAicWhWNwpLCzMFPEZO3asS+aUxYsXm2JQLHrFAko33HCDKVi0P9VpWeyJhXdYnGd/q9oKIYQQQgjRkLAyxe7du02WwarFVWtq7Da++OILa/r06dbKlSvN67777jMFf1jUibAQzplnnmmKZ9mv7Oxsl32w4A4LGLEYzx9//GEKVLGglHNxJu6DRZR+/fVX8+K/BwwY4PicbbmO23If3FdaWpp18803O9rk5+dbTZo0sS699FJr8eLF1meffWYK7rCA1f6wefNml0I8emkMdA/oHtA9oHtA94DuAd0Dugfg4WPAOey+8LisULQEMD3itddeaywWeXl5mDJlSo1t8/PzkZSUhPfffx+DBw8262gNaN68Ob766iv0798fy5cvR3p6urFy0NpB+O9evXphxYoV6NChA77++msMGDAAmzdvNmqMTJw40Rw/MzMT0dHRxrIycuRI7NixAyEhIabNk08+aSwfTOVYX+sD+0xLCY/F/TYkvNQ8fkxMjKwlGjfdbx6KvqcaN91z3oG+qxo3X7nfdu3aZebWnJPz+F5Rx2Lv3r349NNPUVhYaCb9Nj/88AOSk5PNZLxPnz54/PHHzXuycOFClJWVoV+/fo72FAas8Prrr78aYTF37lwzCLaoID179jTr2IbCgm24jS0qCLelmxWP0bdvX9OGx7dFhd2GYoOuXK1bt67xvLgPvmxoSiJ0heKroW9KumLJDUvjpvvNc9H3VOOme8470HdV4+Yr95v1jw2iPsd1u7Bg3AKFRHFxMSIjIzF58mRjYSCMtbj44ovRsmVLUxWW8Qynnnqqmexzgs+CToyBiIuLc9lnkyZNzGeES1uIOMN1zm24jTPcJ/ft3KZVq1bVjmN/VpuwGDNmDB555JFq66k6G9pYxOOx+i5RfIfGTfebZ6LvqcZN95x3oO+qxs1X7rddu3bVu63bhQUtBosWLTLmlc8++wxDhw7FnDlzjLiw3ZsILQrdu3c3ImP69Om44IIL6hx850Gv6QIcijb1UXC0aIwYMaKaOYkWE3e4QhG5QmncdL95Lvqeatx0z3kH+q5q3HzlfvPbj+O5XVjQKtCuXTvzbwqHBQsW4IUXXsCrr75arW1qaqoRFqtXrzbvU1JSUFpaarI+OVstGBfRu3dvRxvGRVQlKyvLYXFgm/nz57t8zn3Szcq5jW29cD4OqWrtcIaWFWf3KeeL5A6rgX1cWSw0brrfPBd9TzVuuue8A31XNW6+cL/57cfx/D1RkTnHJDiTnZ1tgp4pMEi3bt0QFBSEWbNmOdpkZGRgyZIlDmFBNyu6HTFFrA1FBNc5t+E23NZm5syZRhDwGHabH3/80QgZ5zaMy6jqIiWEEEIIIYSv4VZhcd999+Gnn34ywc+Mtbj//vtNsPbll19u/MhYn4JB0/yc688991wkJibi/PPPd5iDmD3qzjvvxLfffos///wTV1xxBbp06YLTTz/dtOnUqRPOPPNMXHfddSYbFF/8N7NA0Q2LMPibrldDhgwx++C+eGy2s92VWNeCQoOZoihCGAvyxBNPGDcnPf0XQgghhBC+jltdoeiixMk8LQUUCUcddRRmzJiBM844wxS7o9h47733TPwFrRTMzjRp0iSXbErjxo1DYGAgLrnkEkeBvHfeeQcBAQGONh9++KEpkGdnj2KBvJdeesnxOdsybmP48OE44YQTXArk2bB/tIywiB5dtuh6RVHhHD8hhBBCCCGEr+JxdSwaOwzepkihK5bqWHgHylWucdP95vnoe6qx0z3nHei76p11LOo7d/W4GAshhBBCCCGE9yFhIYQQQgghhDhoJCyEEEIIIYQQB42EhRBCCCGEEOKgkbAQQgghhBBCHDQSFkIIIYQQQgjvrmMhhBBCHCp27tmJreVb4VeyG3F+QUhN66bBFUKIBkTCQgghhNeTkbUUd3x3Dzbu3QILleWZZp7xjsSFEEI0IBIWQgghvJ61m5ehFHuRsK0vYsoDcH/QByjP3wOkubtnQgjhO0hYCCGE8HoKS8rN8upjuqJ5SDMcN+dNrClt2Oq0Qgjh6yh4WwghRKMhOToEIZF78HBiPDJLs93dHSGE8CkkLIQQQjQqSvwD8VdQlFkKIYRoOCQshBBCeD0hIXFoXRxglkkpJ2LR+jFmKYQQouGQsBBCCOH1JDbphSUZw81SCCGEe5CwEEII4fVU7C1FuN8us9y6aTqiOt1rlkIIIRoOOaAKIYTwejK2zoZfq3eRsRXwUzIoIYRwC7JYCCGE8HqaBMfj9uxcsxRCCOEeJCyEEEJ4PZGBEehVXGKWQggh3IOEhRBCCK8nr2wXpkWEm6UQQgj3IGEhhBDC68kuy8f7sdFmWRbVwqyzl0IIIRoGBW8LIYTwekpjWjqWfv5B5t9WQLCbeyWEEL6FLBZCCCG8H79/npP5BSKwcLv5p70UQgjRMMhiIYQQwusJKsxwLIP3liC5vBzB5UXu7pYQQvgUEhZCCCG8lq15RcgtLEVWdq5571e2By0jWuDbzdvwfZt4LNmab9bHRQSjaWyYm3srhBCNGwkLIYQQXiMgiP/uzdic+zf8wtJx22fbEV6xGe0jfwSaAxEhgYgOC0KOvz9e/u4X/P5NKSL9c9EyfC2uObE1IkMq/+xZ/kEoi66MywjKX4/ogFC0i0lBdJgf1hVuQ6tmvREemezWcxZCCG9DwkIIIYRHCgib7MJSDPt4NpKstUixCvGS31sY3DoZHbceB+ASXH7Uz3in+C+0rEhB25Q28AsIwsVNU3FSxF8YddIdWPT3BDyV+V+M2lj7cS/YXYDeO3OwJigIg5ul4sms2xEb0xEFhRuNWIkPrwwEj4tujtS0bod7GIQQwiuRsBBCCOExouL0Z+egqGyvy3q/wDxEtH0Wuf5l6LSnCHHZfhjXcjiie56Mpk3aIKS8FfpnrUBIYBMz6ffz88MHZ72PwMBQJCXHoFX0lWi1ujUKS8od+6xqsfArC8SFM3dgT2kpUtbn4u4VYeje5H78GZft0pdQ+OP5k55CXGkxmoYlISYoAjtL8rGzNB8dO5zXQCMlhBCeiYSFEEIIj7BSrMksMKLi2QtaI3LvIsfnW4p34PlNZRhz9K3oEtEcQUlH4vTY5k576IiEhA7Iz6+MpyDOVoXIqFSceOwldfTgePP/zl1crSX52S2xPWct3vp5PUrLK7A3sBhZTWdh2E93m8/H7shC/z1FmB4dhfFxsZjX4TysXTsLJWWFsmwIIXwSCQshhBBucXGy3Zweef8bhJXnoSw4DykhTdEstAL/+nOMS7uwigp0a9INqanHHrY+MrjbJcC76QkATkDPrpV9r3TJ6grLykZzZGG8FYvEs7riyMAiPFq+2wSK3zfnTqwPsBBaYeH5zsMQ1/Q4xEW3QGpk6mHrtxBCeAoSFkIIIQ6rmDAT8vcXOlycUgLXYXcgUIQQtEYG3g98BU0DinF5ahN0j2iBDs1fx6TgR132ZWIbDqOoqK/gmH3bIJdzunDKnn9aRQL4Ga1C/g9tg7Zha9PvMWzZq8CyVxEWGIapA6dKXAghGj0SFkIIIQ57vERYUADeveZ4BBQvx4iFE+Dv748IAJkAzkQyZnZ/CI8FRyI0Ihmxca3NyxNxERl39qnBCnOicel68rMjcPdJkSgNK8QL619F9qrpSE3pjvzAYMQkp7ul70IIcbiRsBBCCHHI3ZzseInnB3dFu+RIRx2JZSt+QZG/P8Z0vBpt2p0JFGYhLjDSKzMtVXOd+geea75fezz0/V5jnUF7IOarfyOnogJ3N0nCY+d+jMSEjti5ZS5SwxIrNwpPAFziRoQQwvuQsBBCCHHIMznZVorjWse7TL43Zy02yzYxbZCekA4kNL7B5/na1ozswuPx0McBuKG4HNFBO2Dt/QZ5pSHI2/47Lvn5DkzYnom4vXsR5x+C1GHzJC6EEF6NhIUQQoiDzuRkWyacSdybiZQ9K5GVm4eAmGaIj2+Hp1dPQphfZcxEY8bZmvHRbVc7xuqBTzthZW4cosIqU98OS0l2BKdPzV6JVFkthBBejISFEEKIg46fsC0TGfkbkVteiMLMZVgw7Rb03VOEt+JiMDMyChMHTML4k59BVHiyV7o+HazIoIvU3oBE3D6pMpVuWNh9uP/cFiio2IKXlz6GhQUbcOTqr9E6ojKD1LJdG5Ca3AVx8W3dfAZCCFE/JCyEEELsF3z6XlP8RMa2hRg4+1oUWf+4RSUnmqDsa8KTcGVIFJKSjzQvX8XVRaoyq9QDn+TBL7AcEW2DMHLRCziquAQfZuww7Qe3boFRaf1warfhyMisdCFT5W8hhCcjYSGEEGK/3Z8IRUXnpjFGUCzbvhnrti80omJM52Fok9YDcZafT1kmDjSrVGV9DH8kWuuRZVXgwop43HdOJ4y1MtAy7Wh8t/AVjNo202wTVmFhav93Na5CCI9EwkIIIcR+16JoHbwDeTu+QV74cZgw5158XrrdMfHtltoTqakSFAdfHyMGYUGbMflf12BS85OMcBu5cQoWZsxDm6BQxJUVS2AIITwKCQshhBD7VYsixcrCnqk34MrFcZgc8yxu6z8egzOXmDZy1Tl0lgxahhiPsSInFu2S+yK2NB6hG6Zi5JIJwJIJlQHf/d+TuBBCeAz+7jz4+PHjcdRRRyE6Otq8evXqha+//trxuWVZGDVqFNLS0hAWFoZTTjkFS5cuddlHSUkJbrnlFiQmJiIiIgLnnXcetmzZ4tImNzcXQ4YMQUxMjHnx33l5eS5tNm3ahHPPPdfsg/u69dZbUVrqmpd98eLF6NOnj+lL06ZNMXr0aNNHIYRoTGJiydZ881qwPscRSzHtlhPx0Y0dkJSQhb153yK5dA8mdfgXmqUdZ7I9pXccZF5yfTp4KDDoYsaAeIo5iosBL/6MKz7aDb+Nt+HFPu/hjWP/javyd6N4y3wsWzEFZSWFh+DIQgjhxRaLZs2a4cknn0S7du3M+3fffRcDBw7En3/+iSOPPBJPP/00nnvuObzzzjs44ogj8Nhjj+GMM87AypUrERUVZba5/fbb8eWXX2LixIlISEjAnXfeiQEDBmDhwoUICAgwbS677DIjNmbMmGHeX3/99UZccDuyd+9enHPOOUhKSsLPP/+M7OxsDB061IiGF1980bTZtWuXOXbfvn2xYMECrFq1CldddZURIjymEEI0xpoUdsYn/8A8DJw6GEXlRfCzLFwRG4/b2g9ASFicW/vsK8HexLZg5OUmIzU8BMMKSjH3+0dMytpZsa2QktLV3V0WQvg6locRFxdnvfHGG1ZFRYWVkpJiPfnkk47PiouLrZiYGGvChAnmfV5enhUUFGRNnDjR0Wbr1q2Wv7+/NWPGDPN+2bJlNClY8+bNc7SZO3euWbdixQrz/quvvjLbcFubjz/+2AoJCbHy8/PN+1deecUcm32wGTNmjJWWlmb6Wl+4Px7b3m9Dwn7m5ubuV3+Fxk33W+P/nm7J3WMt3pJnTf5ji9Xy39PMku/5+mvlL9bS5ZOtL38cbXV+p7P15Z+vWUtXTLa2bf3d8iR84feN16njA1+ba8RX3wfet9Yt/d5cn9LiggPery+M3eFA46Zx85X7LX8/5q4eE2NBq8Gnn36KwsJC4xK1fv16bN++Hf369XO0CQkJMa5Iv/76K2644QZjlSgrK3NpQ7epzp07mzb9+/fH3LlzjftTjx49HG169uxp1rFNhw4dTBtuw21tuC3drHgMWinYhsdmH5zbjBw5Ehs2bEDr1q0bZJyEEKLBalJsW4h+c29wtDWB2cnHyt3JAywYtvWiMOYYxFQsw78/ORODjrgIiTEtFecihHAbbhcWjFugkCguLkZkZCQmT56M9PR0M+knTZo0cWnP9xs3bjT/pvAIDg5GXFxctTb8zG6TnFxZ2dQZrnNuU/U43Cf37dymVatW1Y5jf1absKA44cuGLlWEblYNHZ9hH1NxIRo33W+eS0N9T+1sT2szC1BcVo7nL+mKtsmRldWyC1dg+fZNCAmJxv3Jp6BlUmdERzRBXHQzpKQe65G/Ib7y+5YWE2pePE8/WFizYzcSAkrxc3keZq9407RhUPezvR9DXGQK4hC4TyHoK2N3qNG4adx85X6z9uOYbhcWtBgsWrTIBFN/9tlnJrZhzpw5js/9/Pxc2psf0yrrqlK1TU3tD0Ube6Dr6s+YMWPwyCOPVFufn5/vFmFRUFCZf35fYyg0brrf3ENDfE8zd5dg+AcLUVxeYd63jfFHelIQkq0dwH+vRH55MUamJuOi+KMx4MRHq/12eSK+9vsWYpWY6zZ2emUV75Yht+LSbmHwK8/G21kz8OiC8Y62L/cYhcSkTrXuy9fG7lChcdO4+cr9tuufh+JeISxoFbCDt7t3724Co1944QX8+9//dlgDUlNTHe0zMzMdloKUlBSTuYlZn5ytFmzTu3dvR5sdOyqrmDqTlZXlsp/58+e7fM590s3KuY1tvXA+Dqlq7XCGrlIjRoxwuTjNmzc3rljMhNWQ2EKGx9YfD42b7jfP5HB+Tx1WiqwyrM2vwLh/rBR25ey1qxbg7uh8PNPlFoyJbYbEhCNMP7wBX/t942V5Z9gpjtoXFIp3zaI7WyzCwq7Ey1d2QGTun9g9+wH45/yJnX670bbtGTXuy9fG7lChcdO4+cr95rcfx3O7sKhp4Og6RNciTuZnzZqFY445xnxGEUFrxlNPPWXed+vWDUFBQabNJZdcYtZlZGRgyZIlJqMUoZsVn7D99ttvOP744806igius8UH2zz++ONmW1vEzJw508RT8Bh2m/vuu8/0gWLIbsO4jKouUs5wH85xGc4XyR0/4PZx9cdD46b7zXM5HN9TiooznvvRKZYiEMe1SXDEUizfsRnrSnZiTXAQSpOPQHqbmiehnoyv/b41iws3LzLrzlNcYi/y85ogLaIXupVaGDv/KfwaGYMp7f6udV++NnaHCo2bxs0X7jc/bxEWnKifddZZ5gn+7t27TcrYH374waSF5UkwlewTTzyB9u3bmxf/HR4ebtLH2qrt2muvNelemWo2Pj4ed911F7p06YLTTz/dtOnUqRPOPPNMXHfddXj11Vcd6WaZkpZuWITB34zrYAraZ555Bjk5OWY/3Ma2KvCYdGliiln2e/Xq1aY/Dz30kH6IhRAeDyeddk2Kdk5WCoqKgd8MRZF/5R+OsMAwxCV3dnd3xQEW2ON1tWtfkDZBYzHymHB0D/U34tIuwieEEIcDtwoLuihxMk9LAUUCi+VRVLBeBLnnnntQVFSE4cOHG9ckZnailcCuYUHGjRuHwMBAY7Fg29NOO83UvbBrWJAPP/zQFLyzs0exiN5LL73k+Jxtp0+fbo5zwgknmAJ4FBJjx451tGH/aBm56aabjMsWXa/o4uTs5iSEEJ6G7f7EJ9mEooLF18je8lIsXDXFiIoxLQehTfrFiAtPQmrk/9xPhfdmjqKL1LD3F+K66XvRLvR37G55P+5qdj6ObN5dmaOEEIcFP+acPTy7FjXBGAuKFLpiuSPGgseVH63GTfeb53Iov6c1pZLlpNN+al2wOwO9Pu9n0shO7f+uV6eR1e9b3cJyyeq5eHb9XSi2LVMVFRh3wuOIC45BbFAUwiPa6W+D7jl9Vz0Yy41zuP2Zu3pcjIUQQohDZ6Woyf1p48af8MQPd+LePk9jUo9H9fTaB1ykgF4ImH0D7j4pEuEhBXhq89sYNvdB0yaywsIHJ72JmJjKOEQhhDhQJCyEEMJXCt5lLcWyFasRtmsbIgqzEVheivSOg9zdZdEAUFTm+7XHQ9/zvkhGWNjdGD+0I5Lz/kKTL0YgQL4LQohDgISFEEL4gJUioyADA7++AkVWOWZt2orn/EOAxNprG4jGX7U7MagN0pP9kA0ge/dWMPJmT0Em8ndt9mq3OCGE+5CwEEKIRmylsMktyTWiYkznYUg4rQcQ2QSIbe7GXgv3uUVVQoGxJ6gIT6SloNfaqbjnmPMxf/F7uHXVu5h5xjsSF0KI/UbCQgghGmkqWcJ0srm7NmNd7irzvk1KNwQ17e7mHgt3UjUlbauwm3Hq8UeZf0eFJZols4W1KdiGuLTuyhImhKg3EhZCCNEIU8mSajUqKioQ5xfktv4Kz3SLumOSha1FyQjdmo9i/zYIrbAwcuMUYOMUU9dk6sCpEhdCiHohYSGEEI3E/YlPoknujiXIyF2DsNBYtEcwrmk/GKnxHZT9SdRaUG/szFXYWrgKFvzQMmw47u0TiVzk4IWNb2L12m+QmtQVCE+Q+5wQok4kLIQQojG5P+VtxncfDcCo+CgsHroYH179h7u7KjwY3jMzR/TBjqwcBIdHImdPGYa9H4A7Z+xFQmAhQtpamPLLo+iVuRPZoZFIuP4nBMW3cXe3hRAeioSFEEJ4Mbb7E7M+LcteD2StwjF7dmNSrzvc3TXhReIi0i/SUXjL2U3qyc/K0atPEn5utxG3ZnyASZl/I6m8COXlxQruFkJUQ8JCCCG8LKaC2HEVxKSSnXIeivYWm/ejQkJwYYs+buunaDxuUqx9cfe3exHp3xQdo/oiKOpofPrLfXgnb7HXV2sXQhx6JCyEEMILYyqc4ypyd/5hRMWY4+9DGysQqf+9vtIfXohDWvsiDiWIR7eWfTF+1xKTbUzCQgjhjISFEEJ4YeE7YsdV5G/PN+/b+IUhvd2ZwK1/K8hWHLbaF2EllfffupwVQPYyxIXEKWuUEMIgYSGEEF5c+K4aQaESFeKw1r5ICcxGaFsLI1d/CKz+EGEBIZg64L9IjW2lkRfCx5GwEEIILyx858zuPZlu6Z/wVbeornjyM+COvk1g+W/B85veRu6KqQhNORbFweFyjxLCh5GwEEIIDyNzdwk2F+RjbVZhjYXvSMHuDPy14jMc3fFCLNz4PcIqLFOnQoiGCuoePWsvUgLCcF/cLqRuHIXPoiLxQnwsZp7xjsSFED6KhIUQQniY+9PwDxZibX6FKVbmXPiO2Z9yM/5AlF8Qdu9cjmEr38CkqGa4+IQHcL7Sfwo3BXU/PSkcx/1fW1wYY+GC6FTEx7fTtRDCR5GwEEIID4KTteLyCoy7pCvaNYlyuD+ZlLJTB6KovAhnFO7BU5k7MYsFy5KPUsEy4dag7m1IxJKK1mgXFImAXZuxPXOKWU8LmrJGCeFbSFgIIYQHZX9a+099irZV3J9yS3KNqBhz1C04OqoVgsKTkcKUsrFyfxKeEdQdE7ADbVo8jzWhlvmM7nmqdSGEbyFhIYQQHpT9yQ8W2sb4/8/9adtCUy9g3Y4/zfs2Ealo3q6fm3ssRM1uUU9+Voix5ySgrGQ5Rm6cgoUZ89CmogRx/iGyXgjhA0hYCCGEB9WoaJsUgRCrpNL9adtC9Jt1laO9CdCOTNP1Eh7rFrW9vA2KQrsiIbo9QjdNx8glE4Alle0U1C1E40fCQgghPKhGRVpMKPLzKwvexUQ3x3+OGIqosESEh8bKZ114jVsUCQu7G/ef2wKJ+X+i5dxRSKyodJESQjReJCyEEMKDalRY1v8mX+GRyejb6y5dH+F1blHZhaUY9v5CPPBJHo70A94P24tlm//C0c26Y295KTIzF8s1SohGiISFEEK4kZpqVGTvXImYwmBsz1+PCUvexLCTH0dKSle39VGIA3GLskXG2nVReOTvROSvmIB3el2LbRkLcPZ3w+QaJUQjRMJCCCE8CMZV3PnrA3hzw0IEw8KitBRYFZXuUkJ4p8g4GmO+uRVPXtDerM/fvc0sF66agja7NiMu7VikRrdwc2+FEIcCCQshhHBTwLYzdvantcU7UeTvj+3nPocjm3TFmwEBSGjSRddIeDUM6s7z64IlW/ORV94EoRWWyRqFjVMQFhCKqYO+QGpkqru7KYQ4SCQshBDCjQHbjK2gqBj4zVAU+fuB/7UKboU4ppSNSkOCro5oZEHdpGXYcIw7NxF5VpbJHMU6LRIWQng/EhZCCOHmgO1l2zcbUTGm5SC07jAIIVaMJlmiUQZ1E1rrbp8E7PTritCKBZWNNs4FSkqx3c9CSuox7u2wEOKAkbAQQogGdn+qKWCbtEnphk4pxzrSzQrRGIO6nS0YKYGb0bplOVKm3YUcAIOap2Fy//eUMUoIL0XCQggh3OD+ROgCtacoB/5+/oiosMxSCN+q1t0VT/43ADmXHIXYwExctvJjBAVHuLuLQogDRMJCCCHc4P5Ukr0W738+GHPDwzH5mr8xr8N5pr1zHQshfKJa996WKE7sgsSmMRjarDu2ZvyBzJ0rVBBSCC9EwkIIIdzg/hRSshv/ysnGhb3u1fgLn8f+nqxc/iZGbf3c/DuswsLU/u/KLUoIL0LCQgghGtD9yWZPeTE2BQXiiKTOGn/hs1TNGJUc0g7jBz6IvF2LTTpapmBOTevm7m4KIeqJhIUQQjSQ+5OjXkV5EdZl/YWRaSmYtGc70nUFhI/iGm/BbFGLKrNFhTPeaArWFWcBK6cgLqq5BIYQXoCEhRBCHELXJ1Kb+1NlvYorTQE8EuYfhLjEThp/4dPY8RbO1gu/wBJEtA3CyL/+Az/LwhUFxbjt/75BSEJbd3dXCFEHEhZCCHGIXZ9qc3+iWwdFxZh2l6FNx4GIC4lTvQoharFe3PEZ8J/L26PtrvmImfUw1q6ehjbhVyI0LE5jJoSHImEhhBCH2PWJOLs/VaVNQiekJ8gBSoi6skVZ5bHYW9wUAbGnITP4KVy58g1MTuqEdm37aeCE8FAkLIQQ4hBRW+E7ukAlJnTUOAtxgEHdrYNHY/zpkQgICMbDH5+Bfu0GIi6qmVLSCuFhSFgIIcQhSilbExQV/WZdhU96PoaU5M44wz/WTIaEEPsX1B3b5ESE+q3B18UZ+HzZq6adUtIK4VlIWAghxGFIKZuxeytyty5A2K5teCJzJ1ICoxAX3w6jB32CyKhUjbkQ++EWRYyAT26HN054DYEVmViXtxojV76H3PIC6BslhGcgYSGEEIc6pWxBBgZOHYSivcW4MTcfw5ksKqG9+UyiQoiDc4vivycMOQFWTBqA97AuawlaIBiR0c2AWFkDhXAnlTkP3cSYMWNw3HHHISoqCsnJyRg0aBBWrlzp0uaqq66Cn5+fy6tnz54ubUpKSnDLLbcgMTEREREROO+887BlyxaXNrm5uRgyZAhiYmLMi//Oy8tzabNp0yace+65Zh/c16233orS0sr0kTaLFy9Gnz59EBYWhqZNm2L06NGwLOuQj40QwnMtFUu25ldLKev8ZDW3JNeIijGdh+Hige8BN/2mCY8QB+kWNe2WE/HuNcebdUPf+g23frga/hWBGLlkAv76eBDw8vFA3maNsxC+arGYM2cObrrpJiMuysvLcf/996Nfv35YtmyZmdzbnHnmmXj77bcd74ODXVM43n777fjyyy8xceJEJCQk4M4778SAAQOwcOFCBAQEmDaXXXaZERszZsww76+//nojLrgd2bt3L8455xwkJSXh559/RnZ2NoYOHWpEw4svvmja7Nq1C2eccQb69u2LBQsWYNWqVUb4sK88phCicVOfitqGfyY3bWLbIan1KQ3dTSEatVuUc+zF/Z8V47lzwpDWKQ+v/PokLs5diyRZLYTwTWFhT/JtKB5ouaAgOPnkkx3rQ0JCkJKSUuM+8vPz8eabb+L999/H6aefbtZ98MEHaN68OWbPno3+/ftj+fLl5ljz5s1Djx49TJvXX38dvXr1MhaSDh06YObMmUbQbN68GWlpNK8Czz77rBEOjz/+OKKjo/Hhhx+iuLgY77zzjulT586djbh47rnnMGLECGNNEUL4pvuT+TxnLTIyF2Pd9oWVK8qK3NdZIXxAZBSWp6AotCvWls3DZ9HROH1vEXLXfI3y8hJljBLC11yhahIJJD4+3mX9Dz/8YATHEUccgeuuuw6ZmZmOzyhCysrKjKXDhsKAk/5ff/3VvJ87d65xf7JFBaE7Fdc5t+E2tqggFCV0s+Ix7DZ0g6KocG6zbds2bNiw4TCMiBDCE6nJ/Yl8t/AVDJ7/IEZunGKy1Sj7kxANE3vxr89DsW39WEQknoIbf7zbfA8HfjPUZGUTQvhg8DZdjvjU/8QTTzQTfJuzzjoLF198MVq2bIn169fjwQcfxKmnnmom+5zgb9++3bhGxcW5VuJs0qSJ+YxwSWFSFa5zbsNtnOE+uW/nNq1atap2HPuz1q1bVzsGhQlfNnSnss+3oWMz7GMqJkTjpvvtwL9Dfqj+PaKl4vuF49G13dmY2Owksy4uuhlSUo/d7++bvqcHfm30++ZbY5cWE4pZI042lsS1rNT9ySLkFJTglZOexqotc3H/pqn4fdMctAkORVxgBFJjWh7S43vruLkbjZv3jdv+HNNjhMXNN9+Mv//+28Q3ODN48GDHvyk4unfvbkTG9OnTccEFF9Q9AXByTarJTelQtLEHuzY3KAaoP/LIIzVaZ9whLAoKKgNO5balcdP9Vn8yd5dgd1EZNufuQdMIoHRPAf4xsBo2bF6C1zKXYEzySWjT6pRqVlh9Tw8/+n3zzbGL9AMiI/mdhPlurt2aieZxRyEqMhSt/ObhpTXfAGu+QQj88VyPh5CY1OmQHdubx82daNy8b9zsh+JeIyyY0emLL77Ajz/+iGbNmtXZNjU11QiL1atXm/eMvWDmJmZ9crZa0F2qd+/ejjY7duyotq+srCyHxYFt5s+f7/I590k3K+c2tvXC+TikqrXDZuTIkcYS43xxGP9BNyzGbTQktpDhsfUjqHHT/Vb/gO1Br811CdhukhSPmJgwk1Y2d8ffiC3Zhhlr5gN9n+QXTN9TN6DfN98euyZWMHJKA3DH5FWOdS3Dzseo/zsKu3f9hfuXvoqS8h2IiXHNKunr4+YONG7eN277c7xAdw8SRcXkyZNNHEVNrkRVYbYmBlhTYJBu3bohKCgIs2bNwiWXXGLWZWRkYMmSJXj66afNewZp88nhb7/9huOPr0xVRxHBdbb4YBsGaXNbe98M6Ka7FY9ht7nvvvuMkLEzU7EN4zKqukjZcHvnmAwbO3VuQ+Octldo3HS/1a+q9p6yCjw/+BiXgG2KikFfDEJReRGOKi7Bh0FhQEQiv2T6nroJ/b757tg1iwvHrDtPMd9ZUlmt2w+JEV1wSmQkzp12H9Z32oaMjIVIS+t+yI7r7ePmLjRu3jVuXiMsmGr2o48+wtSpU00tC9saQDXGOhE0+YwaNQoXXnihmewzQJoTe9aYOP/88x1tr732WpPulalmGfh91113oUuXLo4sUZ06dTIpaxn4/eqrrzrSzTIlLTNCEQZ/p6enmxS0zzzzDHJycsx+uI1tWWDKWro1MVMU+0GryRNPPIGHHnpIPypCNPK0sse1jnfNAFWUY0TFmK634cjwpkBSZ9WqEMKDKnXbAiMoPBjtA8PwwJ/Po93alnjk/2a5rY9CNHbcKizGjx9vlqecckq1tLOcvLMGBQvSvffee6aYHcUFa0hMmjTJCBGbcePGITAw0FgsioqKcNppp5mUsHYNC8JUsSx4Z2ePYhG9l156yfE52zJuY/jw4TjhhBOMsKGQGDt2rKMNRQwtIxREjPWg6xXdnJxdnYQQjbyq9raFyN212ZFStk1IIlq3P8vNPRZC1FWtu03QWDzTMwrxMTFYs3YmmqUdh9Aw16QvQoiDx+2uUHXByf0333yzz/2EhoaaInZ2IbuaoCWD9S3qokWLFpg2bVqdbWgJYSyIEMJ30sraUFT0m3WV471Sygrh2dW6bXdGCozNFV2xM2MO7lo1BpN6PIr0joPc3U0hGh0eEbwthBCeFldRE4kJHfFJz8dQWlaEoMBQFeASwgtco5ytF+1DVwKtgcWb5gN+QFzTHkiNrIyrFEIcPBIWQghRS1wFJyTOBIVEoFOHgRovIbzUerFkdQCeXf8ZHsuYBmRMQ1hgGKae9BxSAyOB8ATFSQlxkEhYCCFEPeIqki0/bMteiaf/egn3nDIWzZv30rgJ4XWB3b0QMPsGjD0nAWUheRi5eDxWzrgLqduWA0HhwE2/SVwIcRD4H8zGQgjRWOMqnEUF4yq2vX0GIqYMR+menQgMcLVkCCG8h+3lbVAU2geRMachJCAUHzdth73nv4qC8iLsLcxyd/eE8GpksRBC+DT7iqvILS8yy/yzn0LzlO54OjAYMcnpDdxLIcThyBYVFjYC1157LFYWLMfgVs0xafcmJO8MR1lpIVLTKmtYCSHqj4SFEMJnqU9cBSLizcK/ZW8gIR0HV1dbCOFp2aK2ZUUiLbw9RjW9AE1Tj8Xbs0fgzYKVmHnGOxIXQuwnEhZCCJ+lXvUq8tZUNi7Z7d7OCiEOW7YoEhbUCz27J6Fb85Px5vKVWLhqCtoU5yAuubMyRwlRTyQshBA+T031KgZ+MxRF/n7mfVhFBeL0cylEo7de8N/tmp2AsKWvYeTGKcDGKZWZowZOlbgQoh5IWAghfI59xVXsKcpBmuWPm9v+H9ISO6lehRCNPltUJeY3Ibkd3jjhNQRWZGJdyU6MXPQCcvdkSVgIUQ8kLIQQPkV94iratj0DU9r+7aYeCiEamupuUQGYfWd/tNn+TWWDnHVA8lG6MELsAwkLIYRPUVdcBfI2A3uysbMkH/4xTREf387d3RVCuNEtKiUkDndl5yJs1zYsWzEFHdqdjYBApZsWojYkLIQQPknVuIr8zGWY98FZ6FmQj49iovFRdDSmnPUBUlK6urWfQgj3uUUFhSdhyJ5yzPphNO5qkoS5TXsgMipVl0SIWpCwEEL4TEwFqS2uYmvOKtyVEI1JvUfgsiZdcXFIpESFED5IVbeoNkFj8foFaZjkvwvFJfnYtHW+WW9ZQEhgE8TE9HRzj4XwHCQshBA+FVNRNa7CkVa2ZGflh61OQmLKse7qrhDCA92iimK6oXlkPu6ZchF+RWXRTD/4oZVfE9xTcRPiI1MQ5xekuhfC55GwEEL4VEwFseMqqqWVDQxDXKTcHITwdWrMFoUY3NTredxWkWnW5ezagqdXTcfweQ/BgmXWqaie8HUkLIQQPhlTQWipoKgY03IQ2rQ6FXGJHZVSUgixz2xRFB2WZeG5ZmeiJLgEpZvnofybkYjb+z/LqBC+iISFEMIna1U40yalG9Jb9W2QfgkhvNstasH6HOQmRxphEWJFIT2hLfxKy4DiEiBAGaOEbyNhIYTwyVoVJD62FYaEtzFLIYSoyy2qqvXCDxbaxvjjgQu6I3jXRkxNSsBtRTuR9k/sVmpaNw2o8DkkLIQQvlWrguRtRvHuDOQUbsPNZ72O8Mhkd3ZXCOFl1guys6AEj33+O65++zc0CdyE1OaRyA9IQWjOGvSbdZXiLYRPImEhhGi07k81xVWYIngvH48tKMPgZql4v3wkuna+zD0dFkJ4bVA3XaHSruiGEr8QrM06Bg//NwJ7g5pje+b3jhguWS2EryFhIYTwKfenbdkr8WpMKK46/kFMik5Dq2a93dBbIURjIDkqBDExMfDz80P+3iYun63bvhCIa4W4iCZKCiF8BgkLIUSjd3+ya1UgIAjrdm/G51GRGBzbHOlHnOvubgshGhG0liYGxCO0wsLIjVOAjVNMGuupA6dKXAifQMJCCNGoqOr+VLVWhaNeRVp3N/VQCNHYqBrY3TJsOMadm4g8/10Y+dcLyM1aKmEhfAIJCyFEo04r61KromlPIL414kLi9EdeCHEY09ICO/26Iqr4ZySXlyMwczkQkgiEJwCxzTXyotEiYSGEaPRxFY5aFe3PaeAeCiF8OS1tGooxOyQbW7Y/giwLSDrhTuDku4xbphCNEQkLIUTjTSsLoEXTHpiQfoNZCiFEQ1svTp/0DII7vIFLmvfFlUech02rp5t2cdHNlTVKNDokLIQQjTet7J5sbNu9GZ3anonIqFT3dFYI4dNpabchEa90ewHHNW+Ov5ZOwrBlr5r1YRUWpvZ/V+JCNCokLIQQjc/96Z9aFSjbg1uap2FgfFdcN+BNBAWFu6fTQgifpnRPE+zIDUZy2jmYFNXMpKJl1qiFGfPQJiQMcWVlSE052t3dFOKgkbAQQjQ696dVOxbhxpRYjO98H16MbYWoqDSJCiGE27NF8d+z7+yPbtHNEbZhCkYumQAsmYAwy8LUfrJeCO9HwkII4ZXU5P5k16tYV7wTmYGBKE/uhPTWp7utj0II36Z6tqhFWLA+B+2S2+H1k95GUGw4crf+jpk/PgyrKNfd3RXioJGwEEI0CqrWqzC1KpKOdHe3hBA+Tk3Zov5nveiD9MRSdMvOxbqspYhtchTCI5Pd3WUhDhgJCyFEo8ClXkWnCxEX0US1KoQQHm294L+bRiRgS2gkBq98A+9HJqFr58vc3VUhDhgJCyFEoyiE51KvoknXBuuXEEIcSLYoYn7PkqMRdckMTCpZg7DQWDz96UBcedIjSEnR75jwPiQshBCNqhCeEEJ4a1B3/vZv8P6edUhf8Rna5G0AQmMQl9hR1lfhNUhYCCG8OxNU3mZsy15pnvQtHrrY3V0VQogDDupODIhHaIVlUtGCr3/ixaYOnCpxIbwCCQshhPdmgvqnXsWrMaFYExGHD6/+w53dE0KIgw7qbhk2HOPOTUR8eDDWlezEyEUvYOOar5GafCwQngDENtcoC49FwkII4bVxFcW7M7AFZbjq+AeB5PQG758QQhx66wUQ2+REpDeNQdy2habNhm8fRLvCPZgeE4tzBk9FYspRGnjhkUhYCCG8Nq5iXeE2DG6WiknRaUhvdYqbeiqEEIchqNvQDh/2ehUtQyxkbP8T45dNQI/8Dcgv3IHwsHikpnXT0AuPQsJCCOF1cRWOQnglOysbR6W4t7NCCHEIqOoW5VzvomPLEzCvx81m3aC3jsI2vwpM7a9q3cKzkLAQQni0+1PVuIoaC+HFtHRbf4UQ4nC4RRHnwO5cpwcsNx/xf7hj7UfmAYusFsKT8HfnwceMGYPjjjsOUVFRSE5OxqBBg7By5UqXNpZlYdSoUUhLS0NYWBhOOeUULF261KVNSUkJbrnlFiQmJiIiIgLnnXcetmzZ4tImNzcXQ4YMQUxMjHnx33l5eS5tNm3ahHPPPdfsg/u69dZbUVpa+eW2Wbx4Mfr06WP60rRpU4wePdr0UQhx6NyfBrz4s/ljWpP7k3MhvEmnvapsKUKIRgWFAx+m8HVc63iHBYO/i/x95O9kWmIn03Zd3hosy16GjIIMd3dbCPcLizlz5uCmm27CvHnzMGvWLJSXl6Nfv34oLCx0tHn66afx3HPP4aWXXsKCBQuQkpKCM844A7t373a0uf322zF58mRMnDgRP//8MwoKCjBgwADs3Vvpm00uu+wyLFq0CDNmzDAv/pviwoZtzznnHHNs7oP7+uyzz3DnnXc62uzatcscmyKHfXnxxRcxduxY0z8hxKF1f5p2y4nmyZ2z+9Pe8lLXQnjNeisFoxCi0Vsw+HvI30X+PtJ6kVMaj7CKCoxc+S4GTxuMgZ+fjYwdf7u7u0IYi4DHkJmZyUf/1pw5c8z7iooKKyUlxXryyScdbYqLi62YmBhrwoQJ5n1eXp4VFBRkTZw40dFm69atlr+/vzVjxgzzftmyZWa/8+bNc7SZO3euWbdixQrz/quvvjLbcFubjz/+2AoJCbHy8/PN+1deecUcm32wGTNmjJWWlmb6Wh+4Lx7X3mdDwj7m5ubWu69C49bQ99viLXlWy39PM0tntm393er8Tmdr06afrezs1db17xxn1jVG9D3VuOme8w4a+ru6JXeP1fGBr81vJF8nj3rZ+mHlj9aXv79kfh+XLp9seQP6jfO+cdufuatHxVjk5+ebZXx8vFmuX78e27dvN1YMm5CQEOOK9Ouvv+KGG27AwoULUVZW5tKGFoXOnTubNv3798fcuXON+1OPHj0cbXr27GnWsU2HDh1MG27DbW24Ld2seIy+ffuaNjw2++DcZuTIkdiwYQNat25d7Zy4PV/OVg9C96mGdqGyjynXLY2bJ91vdkwFWZtZAD9U3y6stAj378xFRFkp4uLa4qmBnyImpkWjvJf1PdW46Z7zDhr6u5oWE4pZI042v5f8rbzjEwvx4V1wQng4+kx7AFkdt2HTpl/RvHkveDL6jfO+cdufY3qMsGCnR4wYgRNPPNFM8AlFBWnSpIlLW77fuHGjo01wcDDi4uKqtbG355IxHFXhOuc2VY/DfXLfzm1atWpV7Tj2ZzUJC8aRPPLIIzWKKHcIC7qJET+/ysBXoXFz5/2WubsEwz9YiOLyCse6tjH+CLFKHA8aDGVBOLM8Adgb/s/6GNfPGxH6nmrcdM95B+74rkb6AZGRQOkeoGkElwUoCIsEIo/A+MWfIGzNdxhxzhvwZPQb533jZj8U9yphcfPNN+Pvv/828Q1VqTqAHNx9DWrVNjW1PxRtbHFQW39ozaBgcr44zZs3N9aS6OhoNCR2X3lsCQuNmyfcb5sL8rE2vwLjLumKtsmRZp1zWlmbnTlF+CooB2cHFCExxqnydiNE31ONm+4578Cd39XgAmBrIX9DgeDwJki86H3cVLIWFUGh2LZ9DkrLihAUGIq46GYelzVKv3HeN277czyPEBbM6PTFF1/gxx9/RLNmzRzrGahtWwNSU1Md6zMzMx2WArZh5iZmfXK2WrBN7969HW127NhR7bhZWVku+5k/f77L59wn3ayc29jWC+fjkKrWDhu6TTm7TjlfJHdM7u3jSlho3DzhfuN6C35o1yTKJaVsVbJK8zA2IRbHleYhyQesbfqeatx0z3kH7vquxkeGIDQoELd/8pd5z8xRE4Z0R8Du5bjxzwcc7RjgPa73o4hL7Ig4yw+p/2STcjf6jfOucduf4x1QVqg//vjDpF21mTp1qkkVe99991VLz7ov9UVLxeeff47vvvuumisR33Myz4xRNtw/s0nZoqFbt24ICgpyaZORkYElS5Y42vTq1cu4Tfz222+ONhQRXOfchttwW5uZM2caUcBj2G0ofpzPkW0Yl1HVRUoIcfAwE9SyFVP+Vwgvvo2GVQjh8zhni3r3muPNeAx96zdc8dFuxG+4EeO7PIgJ6TeY9cPmPVyZOWraYPObKsTh5IAsFgyavvfee9GlSxesW7cOl156Kc4//3x8+umn2LNnD55//vl67YepZj/66CMjTFjLwrYG0MzDOhFUSEwl+8QTT6B9+/bmxX+Hh4eb9LF222uvvdakhU1ISDCB33fddZfp2+mnn27adOrUCWeeeSauu+46vPrqq2bd9ddfb1LSMnCbMPg7PT3dpKB95plnkJOTY/bDbWyXJR6T8RJXXXWVEVGrV682/XnooYdkARDiIIrg1USNhfDCkzTOQgjxTypa223ULqpXWVAPiG1yorECT23aC7lBocjYOhdvzX8axVvmYxmL6iV3QVx8W42j8AxhsWrVKnTt2tX8m2Li5JNPNgLhl19+MSKjvsJi/PjxZsmid868/fbbZvJO7rnnHhQVFWH48OHGNYmZnWgloBCxGTduHAIDA3HJJZeYtqeddhreeecdBAQEONp8+OGHpuCdnT2KRfRYG8OGbadPn26Oc8IJJxhhQyHBOhU2FDG0jFAQde/e3bheMX7COYZCCFG/InjMx05qKoJXtRBemxYnIy65s2pWCCHEPkQGsR/axEWkIz02DOlB0Tht+oPAVyPRpXULjErrhwvPeFZjKTxDWNCFqaKiMovL7NmzzZN/wqDknTt37td+9gWtFqy8zVdthIaGmmJ1fNUGLRkffPBBncdq0aIFpk2bVmcbWkLoDiWEOPgieO2SI2sM1nbGFMJrc4aGWwgh9gF/T+1K3f+LveiGhIhoJA75ESmBhZi0awNCQ6KNm6lju+jmHhfkLXxIWPBp/WOPPWZcjRjvYFseWHeitiBmIYRvU9X9iaKipoDtvbkbsHLHIoSFxuKuxF5ITuzoht4KIYT3xl7wtza7sBTD3l9oYi9skcHP0tO64rNZd2LUtpmO7cIqLEzt/67EhXCPsKDr0RVXXIEpU6bg/vvvR7t27cz6//73v45gaCGE2F/3J+RtRtH43hjcNAFj21yCoee8pkEUQohDEnuxyPybn53abTg6NT/JtFm3cylGrp2IhVl/os2uzbJeiIYXFkcffbRLVigbBj0z1kEIIQ7I/WlPNsJKCzGpw7/RtNP5GkQhhDgssRdpSO9YGbwdV9ADYRunYuSiFxBgWbh+dxGuu3w2guKrF/0V4rCkm23Tpg2ys7OrrS8uLsYRRxxxILsUQvgAtvtTbTEVGwu3Y3iTJEQkdEBMTIsG758QQjT22IsBL/5sLMi0JJPUyFRMHTgVk86eiI86Xodz83OxetUXKCspdHe3hRdyQOaFDRs2YO/eSpcGZ0pKSrBly5ZD0S8hhI/AtLLMAAU/YF1RFn4ND0Oh374TOwghhNj/2AvbLWrB+hzkJkeaz+MiYpGelAoEReOXn5/FsJVvYFarPkhJqcwAKsRhERasjm3zzTffmPSrNhQa3377bbUid0II3yVzdwk2F+RjbVZhvWpVOOpV6I+ZEEIcFreoqpmjnAO7m8Y2x9FDZ2FS9nIUFedhxPsnYdARFyExpqViL8ShFxasrm2ngB06dKjLZ6x+zerTzz6rvMhCiMqA7eEfLMTa/ApY8KsxYNulVkVqNyDxCMSFxKlehRBCNID1glS1YMRFtEB6xw7mwc/P5bmYteIN0y6sogJT+7+nzFHi0AkLu3YFrRILFixAYmLi/mwuhPAh+EeruLwC4y7pinZNolwCtvkHy4LlWquiQ+WDCyGEEA0X1F1T7QtjvUjrZlLQ8gHQuuzlGLnmI0fmqFaJ6QhPVEytOEQxFqxXIYQQ9aFtlXoVeZlLcde0y9EssikeOf+/mBz0LJqlHafBFEIID4u/MJW707pVZo7aMNlkjiLvZ+ah63W/ArHNdc2ECwecG5bxFHxlZmY6LBk2b7311oHuVgjRSArhrf0nrWFVYsvL8OL2HSi+YDRCw+LQrm2/Bu+jEEKIfcdf/C/2ojJzVO6uTcCmeYjZ/AjWrv0Gbbv9S8MoDl5YPPLIIxg9erSpwJ2ammpiLoQQwrkQnh8stI3xr7EQXjwfRsTLjC6EEN5jvYhFeloqSkIS8cLvL2LuX//BZAkLcSiExYQJE/DOO+9gyJAhB7K5EMIHCuG1TYpAiFVSrWbFsl0bMLh1C0zatQHpaUplKIQQXmW9SGiLIRdMwoVFOVix8gtc9et9eLjNRWjZpKsyR4kDExalpaXo3bu3hk8IUWshvCPTopGfn1+tXsW6kp2VK8LjNHpCCOFF1gv+m+tT07o5ftfpDH/Phs+ADZ8pc5Q4MGHxr3/9Cx999BEefPBBDaEQwhFXwT8+9alXYWpVyBVKCCG8JnsUsX/j7Sx/qc6Zo3ZtwMjlb5rMUe12b0HHJscquNsHOSBhUVxcjNdeew2zZ8/GUUcdZWpYOPPcc88dqv4JIbworoLss15Fh4GIi2qqWhVCCOEl1OQWNWFINyREBDtljspA2OqPTOaoiIoKzNuWA9z0m8SFj3FAwuLvv/9G166VvtFLlixx+UyB3EL4blwFXaDsJ1mWZSE3Zy1iYo51rVeR2t2t/RVCCHHgblHZhaUY9v5CDH3rt5ozR+1cAf/ti5Gz+WGUbluAlNjm2FOQifxdm1Vczwc4IGHx/fffH/qeCCG8mnZV6lXQ/WnkT/fh5ZiXkZLcGcl7LRPYJ4QQwrvdomqNvYhMNa/ssERckzYeXZe8iVHpF2D+4vdw66p3MfOMd5CS+r+HTaLxccB1LIQQvs2+4ioCS3ajZ9Ee7M3fguQ2fTFxwCQkJR/Z4P0UQgjRMLEX/6MFRp/8JpKjw827qLBEs1y4agpa796KkKh0xMT870GU8HFh0bdv3zpdnr777ruD6ZMQohHEVSSFxOKq/N2ICYmtfC9RIYQQjTr2wplKF6ljzL+bJndBWIWFkRunwG/jVLQKboUJAyYgLSrNDb0WHics7PgKm7KyMixatMjEWwwdOvRQ9U0I4WVxFc4UlBfhr5BgHFtehCi39VQIIURDxF44U1N6Wjt71NrC7Xhp+WSsXjsTacldgfAEBXj7urAYN25cjetHjRqFgoKa3SKEEI3P/alqXIWjXkV5AdZmLcFLifF4bk8m5AAlhBC+4RbljLOLlJ09KnbH3whZNhlTf30MvTOzsCY4CClDpiGuec8G7LXwihiLK664AscffzzGjh17KHcrhPAS9yfnehX8r1VgC8Qlp7upx0IIITzFRcrOHpWW3AXP9RyFYOzCztJduOT30XhizTT0DInCp788hotPeECus17MIRUWc+fORWho6KHcpRDCi9yfHPUqOlyJ1u3ORkhpCFLj27qtz0IIIdzvImW7Ri1Yn4O2SREICW2D5s2STbzuzLg2iIpKw6at8zF+1xKckrNawsLXhMUFF1zg8p756jMyMvD777+rGrcQjZya3J9scndvMcs2se3RKSEd+fn5Ddw7IYQQnuYi5WzB8IOFtjH+eGfYKWgWF16ttsW67QuBkEjEJR2pQqq+Iiyqpgjz9/dHhw4dMHr0aPTr1+9Q9U0I4QUUF+Viy7YFaJZ2HGaumWoyf6hehRBCiJosGGt27MbY6Yvw+/oc5O0pc1i/+XfDzhyFjVMQFhhmCu6xLoZo5MLi7bffPvQ9EUJ4bLA2qa1exbqNczB4/oOY1ONR3NBnDIbBzzyBoiVTCCGEcLZgxIYHITTQH3d8sggW/P5Xudspc9S64p0Y+dcLWL/ma6QmH6vMUb4SY7Fw4UIsX77c+Milp6fjmGMq8xULIRpfsHZtAdutwlPw/rbtZhme1t0NPRVCCOEtUFy8ckU3lPiFYG1WoSP2ItfE7lVmjorbttC0Xfb9w+i0uwCfRUXiwsu+RlyTzsjLXY/YuNbuPg1xKIVFZmYmLr30Uvzwww+IjY01TybpS83CeRMnTkRSUtKB7FYI4cHB2sQ5YDujIAO5JblAxgK0KCtHeKASNwghhNg3yVEhxq0+PjLEJXuUs/Vi5hnvILR0D4oLt+OF30fjgqBQ5OSswS1TL8HY/q9Xi80QXiwsbrnlFuzatQtLly5Fp06dzLply5aZ4ni33norPv7440PdTyGEJ9WqKMjAwKkDUVReBD/LwhXxCbgtJAohukpCCCEOJPbCKXOUbb2IS6t8kMXMUfHx7bBsxRT87V+GhaumoM2uzYhL7IDUxMp5qPBiYTFjxgzMnj3bISoIXaFefvllBW8L0chrVZDc7YuMqBhz9K1oE5aEuKjmCElQWlkhhBAHFntRtfaFw3rxT+VuUi3A2z8IU8+frgBvbxcWFRUVCAoKqrae6/iZEKLx1qowlJeYRZvQJKR3GNTwHRVCCOFD1otgh8BwBHgXbsXIJROwcOXn6N+kB4L8A1EQFIbIpA7uPhWf5oCExamnnorbbrvNuDylpaWZdVu3bsUdd9yB00477VD3UQjhQbUqhBBCiIa2XkwY0g0JEcH/C/AuyEDY0jeMuOj+1YMItiw8lpSEuwd+rPgLbxMWL730EgYOHIhWrVqhefPmJivUpk2b0KVLF3zwwQeHvpdCCI9iV+EOd3dBCCGED1gvsgtLMez9hRj61m9VXKRSMfWsD5CbvRoJpzXDtp3LsOuvl1BcutvEYtBtSgHeXiIsKCb++OMPzJo1CytWrDBZoRhjcfrppx/6HgohGjxguyZ27lyB6fOfwzk9RmBD1hKzToXwhBBCHO7K3bW7SLVBescjTZuWzbrjja5XomB3Bnp93s/EYtBtSuLCg4XFd999h5tvvhnz5s1DdHQ0zjjjDPMiTDd75JFHYsKECTjppJMOV3+FEG4K2N6ZvRLjM39Bj+xzcFavu9Gn8Cr9YAshhPCIAG+bsLAEjGk5yAR4m+xRgUGIC09SgLcnCovnn38e1113nREVVWE+4htuuAHPPfechIUQjTBgu2NUS8zbuAXo3xKIaYGYmBZu6a8QQgjfpKYAb/7b+W9WQGAwuh0xCGHrJ/8ve1RgGKYOnCpx0QDsl7D466+/8NRTT9X6eb9+/TB27NhD0S8hhCfUq9i2ELmBQfylBrYvRIq/P+J1ZYQQQniAixSp2YW3Hd444TUEVmRiXclOjFz0AnJXfYXUlG7Y7mchJfWYBu2zL7FfwmLHjh01ppl17CwwEFlZWYeiX0IIN7s/UVQM/OZKFPn7O9a1TUvBmwEBSNDVEUII4UaqukVVpdJNqj+67VmGtmXlSJl2F3IADGqehsn935MrrycIi6ZNm2Lx4sVo165djZ///fffSE1NPVR9E0K40f2JecIpKsYceT3atD4NyN+KuNB4JDTpousihBDCY9yiquLsJtW5aTe8ee4niN+7Fztz1+GylR8rc5SnCIuzzz4bDz30EM466yyEhoa6fFZUVISHH34YAwYMONR9FEI0cL2KveWlWLd9ofl3m8jmSE9IB/gSQgghPNQtqiq2m1RcRDsgNgyJaV1x65EX4JufHsVd6z4xmaPGdR6GuLi2iEvpqhiMQ8D/fBzqwQMPPICcnBwcccQRePrppzF16lR88cUXJu6iQ4cO5rP777+/3vv78ccfce6555oie6yFMWXKFJfPr7rqKrPe+dWzZ0+XNiUlJbjllluQmJiIiIgInHfeediyZYtLm9zcXAwZMsQEmPPFf+fl5bm0YR0O9oX74L5uvfVWlJa6qmBaa/r06YOwsDBjvRk9erRJtSuEN7lALdmaX2daWVJUlG2C3vijq5SyQgghvNVNasCLPxvX3zmrsszfP/4d7HnUUExIv8G0HbbsVQz+5R4MnDoQGQUZ7u66b1ksmjRpgl9//RU33ngjRo4c6ZhUc8Lfv39/vPLKK6ZNfSksLMTRRx+Nq6++GhdeeGGNbc4880y8/fbbjvfBwa5+4Lfffju+/PJLTJw4EQkJCbjzzjuN1WThwoUICAgwbS677DIjNmbMmGHeX3/99UZccDuyd+9enHPOOUhKSsLPP/+M7OxsDB061Jzfiy++aNrs2rXLpNbt27cvFixYgFWrVhnhQyHCYwrRGOIqNm78CU/8cCfu7fM0JvV4VAWGhBBCNMoCeyccdzOmNu1l3H7XFWdh5F//wYb13yI1oTMQngDENnf3afhGgbyWLVviq6++MlaANWvWmMl3+/btERcXt98Hp0sVX3UREhKClJSUGj9j7Yw333wT77//vqM4Hyt/s4Df7NmzjdhZvny5ERSsvdGjRw/T5vXXX0evXr2wcuVKY2mZOXMmli1bhs2bNxvrCXn22WeNcHj88cdNet0PP/wQxcXFeOedd0yfOnfubMQF0+uOGDHCiCshvD2uwr+sCBGF2QgsL0V6x0Fu66sQQghx+AvspSM9rRviMv5AWEUFfvr+fhydm49V4VE44upvEZ54hC5CQ1TeJhQSxx13HA43P/zwA5KTkxEbG2vckDjR53tCq0RZWZlJc2tDYcBJPy0rFBZz58417k+2qCB0p+I6tqGwYBtuY4sKwm3pZsVj0ErBNjw+RYVzG1puNmzYgNatW9fYf+6DLxtaPggFWUO7UdnHlPuWb44b++8HC22TInBkWmUtmqrn1CwsCc9mZgNhSQd9vo1l3BoajZvGTfecd6DvqveMW1pMqHnFhgchPMgfd0z602G9mDmiD5qmHIMp/d6FX3E+1mcuwZWr3sTHWcsQW5IPP/h5RAYpy41/U/fnmAcsLBoCWjMuvvhiYyVZv349HnzwQZx66qlmss8J/vbt241rVFVrCd2x+Bnh0hYiznCdc5uqLlzcJ/ft3KZVq1bVjmN/VpuwGDNmDB555JEarS3uEBYFBZW+9bKw+M64Ze4uwe6iMmzO3YOmEUDpngLk57u22blnJ3aV7UL59r8RFN0WzQuKEFi1kY+Nm7vQuGncdM95B/quet+4RfoBU64/1vE3cezMVfh91RbsiAtHVFhzJCe0Q2Jke3wY1QGJ8el4+/t78WvpTtzZ9kJERTQBQqMQHd0SieGJ8KVx2/XPQ3GvFxaDBw92/JsWhe7duxuRMX36dFxwwQV1P5l1GvSaLsChaOMcY1IbtGjQVcr54tBVixaTmiqYH07s/vLYmuj5xrgxrmLQa3Nd4iqaJMUjJuZ/LlAZO5fj8m+HoKiirHJFAjAjMhgJMdWzRfnKuLkTjZvGTfecd6DvqneOm/2nrUleEXKmrcUdk1c5/j6+ckU3JEREI67pyUiODcOAoy/C5HkP45Y1Lzu2ZxXvyedNbvAMUpYbx21/jufRwqIqrJFBYbF69WrznrEXzNzEeA9nq0VmZiZ69+7taMPCflVhIT/b4sA28+fPd/mc+6SblXMb23rhfBxSV8A6LSvO7lM2dparhsY5w5Zo/OOWt6cMe8oq8PzgY2qNq8jLXoU9FaUY03kY2jQ5BnH+IYfM7Out4+ZuNG4aN91z3oG+q947bs3iwjHrzlNcAryvenuBS4B3504XYEpMSxPgTewq3lvXzkBa8rENHuTt56Zx25/j7Ve6WXfDbE0MsLaL8HXr1s1UAp81a5ajTUZGBpYsWeIQFgzSptvRb79VZgMgFBFc59yG23BbGwZ0UxDwGHYbpsd1TkHLNozLqOoiJYSn1quoKirWb/jhf/UqIpoivVlvj/AlFUIIIQ43/JvIv419jkgyQmLaLSeaBCe08jPAm+lpK8LTTTITvrolHWO22z7rfmS92RdPvXcisrb/ZdZlZS7VBXO3xYK+YswsZcM4ikWLFiE+Pt68Ro0aZdLQUkgwQPq+++4zNSbOP/98hzno2muvNelemWqW29x1113o0qWLI0tUp06dTMra6667Dq+++qoj3SxT0jJwmzD4Oz093aSgfeaZZ0w9Du6H29juSkxZy1gJZopiP2g1eeKJJ0zBQD2NFZ7oAmVnwKiLB74fgb/9y1SvQgghhE9jZ5FyroHhbL3gZ3zwNvOMdxBVXordu7dg5vxHcF1wBHJy1uDSaYPxwZnv+vzDObcKi99//91kXLKxYxFYQ2L8+PGmIN17771nitlRXLDtpEmTEBUV5dhm3LhxCAwMxCWXXGKqf5922mkmJaxdw4IwVSwL3tnZo1hE76WXXnJ8zraM2xg+fDhOOOEEUwCPQmLs2LGONhQxtIzcdNNNJtaDrlfsr3P8hBDeUq/C5rG+z6GoOE/1KoQQQogqNTCqpqclTFEbGRsGvpuYlI74+HZYtmIKMgP8sHDVFLTZtRlxyUciNb69T46nn6VckA0Kg7cpUuiK5Y7gbR5XwbSNe9xoumWl0brqVfBHcPD8B00RvMNVr8Lbxs1T0Lhp3HTPeQf6rjb+cav6oM5+WDdhCIO8gx1/XzO2LcTAb4aiyL/yfML8gzH1/GmHNMDbneO2P3NXrwreFkLU3/3JjqtwJiNvA3K3L0Lorm0YlZWN1NAEDakQQgixD+sFqamKd6XIaIc3TngNgRWZWFe4FSOXTEBuSW6DZ47yBCQshPAR96eMggwMnHYRivaWGFFxYYkFxCrxgBBCCFGfCt7EFho1iYzZd/ZHm13/JAvauhAoKcX6wgyERCQhLa27TwyyhIUQjQD+yFFU1OX+xKcnFBVMK3tCwlGVoqIB0+QJIYQQjUlo1BSLkRhQ6aaUMuVWoKICD6Q2Qbvolhg56BNs2bYAzdKOQ2iYa2HnxoSEhRCNiJrcnxzs2mYWbeI7IK7VSQ3bMSGEEMJHMkm1DLsR6/t3Qk5YEEYgG6lJTbFu4xwT2zim5SC0SenWaJOmSFgI4eUxFaSutLLMrZ2Vs9pRrwIldaegFUIIIcSBxWJkGxepAFw4ZY/5LCwoBBOGtERA6R6EVlgYuXEKsHEKwioqMPXM95GaemyjGmoJCyG8kNoyVdSUVvbTXx7D+F1LKttUWOYpiRBCCCEOr4tUdpU4jJZhwzHu3ETkWVkmwHvhjoXoUpCJlklHNhrXZAkLIRpBTAWpKa6CXHzCAzglZ3Vlm0ZqehVCCCE8Pw4DiG1yItrG7EHYincx8q//oPeeIryaUwjc9FujEBcSFkI0spSyzhTszsCqjd/j6I4XIjLK99LeCSGEEJ6UVWqN+fsdiVf7TkLInhUIy1mPzTMfROSOvxAX2xw7d65AWWmh1z4ElLAQohFW1GaxnvI92di9czmGrXwDk6KaHbZCeEIIIYSom6oB3pU1MLojIDQCNzZPw/3rv8GlHQbggzkP4M2ClZiQfgPiopp5naeBhIUQjSilLMnIXIyBM6/CiXv24KnMnZgVGomE5KPc0mchhBBCoIYAb+fYixsRf3RvLNmaj46pA4HVT2PYslfNZ2Hww7iTnkZsSTEigpsiJsaz62FIWAjhZezL/Sk3IABFfsCgEx5EUFJXpIQnNAq/TSGEEKJxBngH4PqJW+mbACDeCI3Hz02EX2Ax7vj7RQz76W74wQ/37IlBy0s/BOJawFORsBCikZLY7HggId3d3RBCCCFEPUQGsYO8d/p1RbuESLx66kkICdwNa+33iPj5bWBPtoSFEOLQBWzXBuMqcndtxrodf1auyF4rYSGEEEJ4kciIqzEWoxuigzpgU3AwYssKEQvPRRYLIRpBwDZFRb9ZVznem3oVkWkN2lchhBBCHJ5YjCNCf4NfuzhEZm/DSa3gsUhYCNEIArZjopvjP0cMRVRYIsJDY70ui4QQQgghaneTWpXRCRNmdED0SafAk5GwEMJL61Vsz/gTKZaf+XdGwVYc3WEQ4uPbuaW/QgghhDh8IsOyLOyxouEfUHOaeU9BwkIIL3R/ouvT+d9cia82b0N8RQXuapqCXrEdcdu57yEktPaMUUIIIYTwPnbumIvOqa9g544AoNlZ8FQkLITwQven3NJdKPT3x/bzxiE+uSvGFmxFeGSKRIUQQgjRCCkpycX60L1m6clIWAjhjfUqoppULptXppRti64N2jchhBBCiKpIWAjhRWllHSlld22oXFFW3HAdFEIIIYSoAwkLIbwormLgN0NR5F8ZsB1WUYG4Csst/RVCCCGEqIqEhRBeEleRv3sr/AE83epCtGzSVSllhRBCCB+hPCzRZempSFgI4eFpZZG3GdtzViMoMAzzrl7ino4KIYQQwm1UhMS4LD0VCQshPLmqdt5m4OXj8V5UMH6NjMGUtn+7p7NCCCGEcBv+pbtdlp6KhIUQHuz+tGfXVqzyL8fFPR/EhQntda2EEEIIHyRwT6bL0lOhy7YQwo3Y7k9VRQXZsGc7hqSloCg6DW3bnuGW/gkhhBDCvTQLbYKxO3aapScji4UQnpxWtmRn5Yro1IbroBBCCCE8ihD/YCSVlyPLv4rLtIchYSGEp6eVDQxDXHQLXSchhBDCR8kszcFnsdE4qTQHnuwYLWEhhIfFVdBSQVExpuUgtGnTH3HxbZEaKYuFEEII4auU+AdgdWAEjvcPgCcjYSGEh6SVpaUiMaGj432blG5Ib3Giro8QQgjh4ySlnIiVXwNJ/T17XiBhIYSHuD/1m3UVPun5GFKSO+MM/1hTAE8IIYQQwluQsBDCA9yfospL8UTmTqQERiEuvh1GD/oEkVFyfxJCCCEEsHXTV4ho/S62btqFLs0u89ghkbAQ4jC6PpE6q2r/Q2RgGM4t3AOExVe+l6gQQgghhJchYSHEYXZ9qrWqNl2gdi5Hrp+F3dlLsDA2BheX5CFJV0QIIYQQXoiEhRCH2fWJ1OT+ZNLKzrwaRX6WeR8WE4XzQ6J0PYQQQgjhlUhYCNGAmZ+qpZX1szCm8zC0aXEK4sqKkZrWTddDCCGEEF6JhIUQDZT5yZncnLVYt32h+XebiKZITzpS10EIIYQQNVIW1dxl6alIWAjRQJmfnPlu4SsYtW0mwiospZUVQgghRJ1YAcEuS09FwkKIhnR/yllrRMUx7c7BpOYnGVEh9ychhBBC1EVg4XaXpafi786D//jjjzj33HORlpYGPz8/TJkyxeVzy7IwatQo83lYWBhOOeUULF261KVNSUkJbrnlFiQmJiIiIgLnnXcetmzZ4tImNzcXQ4YMQUxMjHnx33l5eS5tNm3aZPrCfXBft956K0pLK9OF2ixevBh9+vQxfWnatClGjx5t+ih82/1pwIs/4/ZJi+p0f2Kg9vrVXyNj1TRjqSgu2YX0joMkKoQQQgixT4LLixFXvtcsPRm3WiwKCwtx9NFH4+qrr8aFF15Y7fOnn34azz33HN555x0cccQReOyxx3DGGWdg5cqViIqqzJ5z++2348svv8TEiRORkJCAO++8EwMGDMDChQsREBBg2lx22WVGbMyYMcO8v/7664244HZk7969OOecc5CUlISff/4Z2dnZGDp0qBENL774ommza9cuc+y+fftiwYIFWLVqFa666iojRHhM4XvU1/2JKWWZ/al9STE+zNiBxUHhwEAFaQshhBCifrQMS8OEHVnI6poGj8byENiVyZMnO95XVFRYKSkp1pNPPulYV1xcbMXExFgTJkww7/Py8qygoCBr4sSJjjZbt261/P39rRkzZpj3y5YtM/ueN2+eo83cuXPNuhUrVpj3X331ldmG29p8/PHHVkhIiJWfn2/ev/LKK+bY7IPNmDFjrLS0NNPX+sL98dj2fhsS9jM3N3e/+iuqj9uW3D3W4i151uQ/tlgt/z3N/Lsulu5canV+p7M1+8/XLWvrn5aVu8knhlX3m8ZN95t3oO+qxk33m+ez6s8frdwnjzLLhmZ/5q5udYWqi/Xr12P79u3o16+fY11ISIhxRfr111/Ne1olysrKXNrQbapz586ONnPnzjXuTz169HC06dmzp1nn3IbbcFub/v37GzcrHsNuw2OzD85ttm3bhg0bNhzWsRDe5/5E16dlK6aY17r135l1qU17AWldgVjPzugghBBCCM9iY9E2DGuSZJaejMcGb1NUkCZNmris5/uNGzc62gQHByMuLq5aG3t7LpOTk6vtn+uc21Q9DvfJfTu3adWqVbXj2J+1bt26xvOgOOHLhi5VhEaaho7PsI+puJADH7ecghIUl5Xj+Uu6ou0/7k9pMaEuY0pRcebsa1z2EV5hIba0yKfGXvebxk33m3eg76rGTfeb5xMW2QLJBSlm6Y75o9cLCxsGdVc9uarrqlK1TU3tD0Ube6Dr6s+YMWPwyCOPVFufn5/vlhujoKAye9G+xlDUPG6lewrRNAJoHln5AkqRn+8a5B8c1BTvdn0UZeXFCAyotHBFRzRBeEQ7c919Bd1vGjfdb96BvqsaN91vnk9IcDNsLR5slg09l7Afinu1sEhJSXFYA1JTUx3rMzMzHZYCtmHmJmZ9crZasE3v3r0dbXbs2FFt/1lZWS77mT9/vsvn3CfdrJzb2NYL5+OQqtYOZ0aOHIkRI0a4XJzmzZsbV6zo6Gg0JLaQ4bElLPZv3DJ3lyC3ANhcAGwtBILDI804upC3GdiTjY2F29GiWTri49vBl9H9pnHT/eYd6LuqcdP95vlU7MhALOaiAu0QE9OsQY+9P3NGjxUWdC3iZH7WrFk45phjzDqKiDlz5uCpp54y77t164agoCDT5pJLLjHrMjIysGTJEpNRivTq1csou99++w3HH3+8WUcRwXW2+GCbxx9/3Gxri5iZM2eaeAoew25z3333mT7QRcpuw7iMqi5SznAfznEZzhfJHZN7+7gSFvsXV3HTh39gbX4FLPghLCgQ8ZEhLmO4N3cDisb3RlhpIR5LSUZ0RApGD/oEkVH/E8W+iO43jZvuN+9A31WNm+43zyYn+09sSVmInOzO8PPr1KDH9hphQfeSNWvWuARsL1q0CPHx8WjRooVJJfvEE0+gffv25sV/h4eHm/SxhE+Mr732WpPulalmud1dd92FLl264PTTTzdtOnXqhDPPPBPXXXcdXn31VUe6Waak7dChg3nP4O/09HSTgvaZZ55BTk6O2Q+3sa0KPCZdmphilgJj9erVpj8PPfSQJuk+kFa2uLwC4y7pinZNompMK7tyxyIMbpqASR3+jQcTOiA4IsnnRYUQQgghfAu3Covff//d1IWwsV2GWEOCtSvuueceFBUVYfjw4cY1iZmdaCWwa1iQcePGITAw0Fgs2Pa0004z29o1LMiHH35oCt7Z2aNYRO+ll15yfM6206dPN8c54YQTTAE8ComxY8c62lDE0DJy0003oXv37sb1iv11dnMSjbOq9tp/qmq3rauqdnhi5TKtG1q2OLEBeymEEEII4Rm4VViwknZdAcw0vbDyNl+1ERoaaorY2YXsaoKWjA8++KDOvtBCMm3atDrb0BLCauHCd9LKsgCeHyy0jfGvNa1s7q7NWFe4tXJFRHzDd1YIIYQQwgPw2BgLIdxppViTWeCoqt02KQIhVkk19yeKioHfDEWRf6XvYZh/EOJCXFMfCyGEEEIcLJZ/kMvSU5GwEKIGKwVh8bvjWsebOhXOqd22b1+ElJSuxlJBUTGm5SC0SemGuMROSI307WBtIYQQQhx6yqJbuCw9FQkLIf6BlgrbStHun+J3tFJULX53/jdD8dXAKUhJ7oy2e/3Q7YhBSE2rzB4mhBBCCOGr+Lu7A0J4Gu3+CdKu6vpEgkoKcNmuXajI32rqVLx53n8lKoQQQghxWAnK3+Cy9FRksRA+j3Ncxb5IDInBrbn5QEhldqiExCN8fvyEEEIIcXiJDghF38I9ZunJSFgIn6amuIqasj/t3L0VW8u3YnfmH9gQFYmzygpRS+JZIYQQQohDSnJwPIbl7UJWsGdnn5SwED5roSDO2Z+c4yqcYVzFiDkPYMPebbBgAYnx6BMUKmEhhBBCiAahpKIUmwMD4VdROX/xVCQshE9bKJyzP9UkKJj5aW3GQpTAwuNH3oC2zXohrsJSXIUQQgghGowtxTswrkki7ijegc4ePO4SFsKnMz+RmqwUJcX5eP+X0figcC3g549WfinoltoDaSnHuqnnQgghhPBVkpKPR/LP65DU83h4MhIWwicDtO3MT7UREhqDf532LAZkLgGzzYYENpGVQgghhBBuITg0EetLupqlJyNhIRo99Q3QJnt2rkZ4aSFyC3fgr52L0aPLlQiLSHIpkCeEEEII0ZDkZy/BsQnvIT87Fmh2oscOvoSF8Akrxb4CtO2YiglTLsVtO3dibXAQbk1tgpkt+xphIYQQQgjhLgoKN2FldL5ZejISFsJnrBQ1BWg7k1uwDZ9HhGJw99HoktoDMwMCjPuTc+VtIYQQQghRMxIWwieCtGuzUjhnf1pXlFm5ou1pCE1IR2rDdlkIIYQQwquRsBA+HaRNUTHwm6Eo8vcz78MCwxAXEtdg/RVCCCGEaCxIWAifDNK2oaWComJMy0Fo07Qn4lKPRWqkbBVCCCGE8BwqQqJclp6KhIXwPfenvM1YtWMR4uLaOFa1SemG9PbnNGyHhRBCCCHqQXlYssvSU5GwEL7l/pS3GXj5eNyYEosL47viytOfw4T0G9CiaY+G7bQQQgghRD3x21visvRUJCyET7g/ZRRkILckF9g0Hyl7izG+83DEtT4VkVGpOOG4m93QcyGEEEKI+hG0e4vL0lORsBCN3v0pI28DBk67CEX/qPzkpqmY2PJkJCUf6aZeCyGEEELUnybB8bg9OxdNOsbDk5GwEI3e/Sl3+yIjKsZ0HoY28R1M1qeklKMbuMfiQNm7dy/Kysp8ZgBZN6W0tBTFxcXw86vMViY0brrnDj3BwcHw9/fX10t4BZGBEehVXIKswAh4MhIWolFnf1q2YgrWbV9o/t0moinSW5/eoH0VBzfB3r59O/Ly8nxuGCsqKpCdne3ubngdGjeN3f5AUdG6dWsjMITwdPLKdmF+RDg6lO2CJyNhIRp18bvB8x80y7AKC3HRzRu4p+JgsEVFcnIywsPDfebpPQUVrTQBAQE+c86HAo2bxm5/Rei2bduQkZGBFi1a6LsmPJ7c8gJ8Gh2Jm8orPTU8FQkL0WiL35FJPR41S4qK1LRuDdJPcfBwYm2LioSEBJ8aUk2QNW665xqGpKQkIy7Ky8sRFBTU4OMuxP6Q2rw/smdHIPXUE+HJSFgIrxAT2YWlGPb+wn1nf9q2EHF79yIjayke+OtFPNb3ObRudYobei4OBjumgpYKIYQ4HNguUHyQIWEhxKFBwkJ4VSzFu9ccj4SI4JqzP21biH6zrsJbGTvQtrQM7RITERrs2RUqRd3IFUgIcbjQ74vwJjK3/YDWzV5B5rZyoNkgeCoSFsLrYykoKHJ3bca6kp3mfWD/MYhv0g3/Do5AeGJ7N/RcCCGEEOLQUVa+B5lBfmbpySjPmvA4K8WSrfnmVTWWojZRMfCboSZIe+SiFxAWGIaU9mcDaV0lKoSowsknn4yPPvpI43KYnn5PmTLF68Z22rRpOPbYY00wsxBCHCwSFsLjXJ8GvPized0+aVGdqWTJyk0/oMjfD2NaDsKk017F1IFTkRqZ2qD9FqKmjFa33HIL2rRpg5CQEDRv3hznnnsuvv32W0ebVq1amckoX4wl6dy5M1599VXH56NGjULXrl2r7ZtB7dzmhx9+2O8JJPt16aWXOtadcsopjj7YL+fPSW5uLoYMGYKYmBjz4r+rpgDmefXu3RtRUVFITU3Fv//9bxMQ68w333yDnj17mjYMmr3wwguxfv16x+eff/45zjjjDPNZdHQ0evXqZbZxhm26d++O2NhYREREmPF5//33Xdpw3KqeU0pKikubgoIC3HzzzWjWrBnCwsLQqVMnjB8/Hp4Cry373RCplgcMGGCO9fHHHx/2YwkhGj8SFsJjrBQL1uc4XJ+m3XKiec2+s081S8Xe8lIU7M4wy49XTjKpZLsdMQjpzXpLVAi3s2HDBnTr1g3fffcdnn76aSxevBgzZsxA3759cdNNN7m0HT16tEl3+ffff2PQoEEYNmwYJk2adFj69Z///AdXX311tYJg1113nemD/XIWN+Syyy7DokWLzDnwxX9TXNiw72effTbOPPNM/Pnnn5g4cSK++OIL3HvvvY4269atw8CBA3Hqqaea7SkYdu7ciQsuuMDR5scffzTC4quvvsLChQvNeFGMcZ828fHxuP/++zF37lxzXJ4PX1UFyJFHHulyTrwGztxxxx3mXD744AMsX77cvKcQnDp1KhpbhrGqAq8mrrrqKrz88ssN0ichRCPHEg1Kfn6+xWHnsqGpqKiwcnNzzdJT2JK7x+r4wNdWy39PMy/+m+vqYunyyVbndzqb5YYNP1rbtv7uc+PmDRzMuBUVFVnLli0zS2/jrLPOspo2bWoVFBRU+4zjYdOyZUtr3LhxLp+3b9/euvTSS62ysjLroYceso4++uga98HfkO+//77efcrKyrL8/PysJUuWuKzv06ePddttt9W6Ha8BjzVv3jzHurlz55p1K1asMO9Hjhxpde/e3WW7yZMnW6GhodauXbvM+08//dQKDAy09u7d62jzxRdfmD6VlpbWevz09HTrkUceqfPcjjnmGOuBBx4w91ld4+bMkUceaY0ePdpl3bHHHmv2Uxdvvvmm6VNwcLCVkpJi3XTTTY7POCY8b8Jrw/fO1/vPP/8069avX2/eb9iwwRowYIAVGxtrhYeHm/1Onz7dfM52zq+hQ4eabXiOTz31lNW6dWszvkcddZQZWxv7uDNmzLC6detmBQUFWd999521aNEi65RTTrEiIyOtqKgoc64LFixwbGcfc82aNZYvcbC/M/rbcGBo3A6MLxbNtvq9388sPXnuKouF8JgA7dosFDYZuzaZStphu7Zh7I4sNA1LQsuWJ6k+hfAYcnJyzJNwWiboqlMVuvDURWhoqCPV7qHk559/Nu5WdPmpyocffojExETzlP+uu+7C7t27HZ/RMkD3px49ejjW0Z2J63799VfzvqSkxPTbGboXFRcXG8sDofsSC/69/fbbJrVnfn6+cWHq169frWk+6fPPvtBKUROcy9MFa+XKlSZ2xJnVq1cjLS3NVFWmaxctJs6ceOKJxqqydetWs5/vv/8eq1atQv/+/WsdQ7pK8bpef/31xgLC7du1a4cDhfvi2NFSw/099dRTiIyMNG5zn332mWnDc6PF5YUXXjDvH3jgATOG7MvSpUuNpeWKK67AnDlzXPZ9zz33YMyYMcYac9RRR+Hyyy83bl8LFiww14TWJOdxb9mypakZ89NPPx3w+QghDi9WUKTL0lNRVijhFcXuMgoyMPCLC1G0txh3ZediaJkfENOiAXssPIGi0r1Ym9WwVUfbJkUiLDigXm3XrFljJqodO3bcr2PQXYVuOZxg0h3qcLhnNWnSpJobFCecnHwzBmHJkiUYOXIk/vrrL8yaNct8zpgMTjirwnX8jHAy/vzzzxsf/UsuucSsf+yxx8xnnBTb8SQzZ87ExRdfjBtuuMGIC8ZQ0O2pNp599lkUFhaafTpDUdK0aVMzKadYeeWVV4wLVaXRAEYEvffeezjiiCOwY8cO0xfGf3AibhdbpFsYXcA42Q4MDDTj8sYbbxjBURvcz5133onbbrvNse64447DgbJp0yYTZ9KlSxfznvE4NraY4jjbYpRj8dxzzxkXO46dvQ1FI93X+vTp4+JixzFxPtbdd9/tuC/bt6+eLY9CjPeJEMIzCSjOcVl6KhIWwiPqU9QWoO1IJVu41YiKMZ2HoWd8ZyCuDRDbvIF7LtwNRQUD+xsSWtL2VeHdxp7c1jc/PoOc+RSak2QW6+LkjxNvez+HiqKiompWBcLJtQ2DxznhpHXhjz/+MJmCajsX9s9eT6vDM888YwQRYy8YrP7ggw+aCS8n/oRi41//+heGDh2K//u//zOWiIceeggXXXSRETFVj0GRwiBsxjxUFTYM/macBgOwabEYMWKEmWDbE+uzzjrLsT9O2jkJb9u2Ld59913T1hYW8+bNM1YHPq2n1WD48OEm8Pz000+vdr6ZmZmmQvNpp52GQ8Wtt96KG2+80QguHpMig9aF2li2bJmxAjkLBlJaWopjjjnGZR2voTM8b44/rUQ8FgUex6SqlWnPHs9OYymELxNQnOuy9FQkLIRbrBT1rU/BVLLM+kTC4IdurU5HYkIHXTUfhdYDTvQb+pj1hRNzTmrpgsJg7H1BIcHAWbopcVLLbTlp5xN9Zkbi0/mq2JmC6I5UX+jqxOxO+4Jigi4ydCXiv2nJ4FP/qmRlZRkLiPPElW45tFDExcWZJ9+0ftAaQhgYzPNhMLsNLTR0+5k/f75xr7Jh8Pq1116LTz/9tMZJPq0LtgsSs0JxrOn24/zE3hm6pFFg8JxskXXfffdh8uTJOOecc8w6TugpVsaOHVvjMTnp3h9sy5CzQKzq4saJPq0906dPN+KC50ArDYPIa8JOB8v2tNg4QzFX9ZydoUhjED63/frrr/Hwww+bIPvzzz/f0Yb3BzNyCSE8k1ZhTfH2th3YdaTr99/TkLAQbrNSHNc6vnrGp9wNWLljEZqmHmssFXYq2TYp3RAX3RypEhU+DV2S6ms9cAd0YeFkkRNpPpGuOsGjKHCOs+CEvzY/fbqtbNmyxTztd06XSj9558l1feATbe6Hk0dO/GuD7kKcAFPkED7tp7j57bffcPzxx5t1FAJcR/ciZyiK6E5jWxwoGmyrB5+E29YLG/u9c/0EbnfNNdeYpT3p3xecvNPiUxv8jOLjpJNOMu95fnxVdQtjf2qr5UArCd25aCFhtqp9YU/QbaFFKFyqwjGipYcvCrHXX3/dCAtarwgFpk16eroREHRrqk1E1QVdw/iiAKTViLEatrCgJWTt2rXVLB9CCM8hwM8f4ZaFQj/PDo+WsBCeY6XI24yi8b0xuGkCxra5BN06XYy7EnuhZ+fLkZi4fz7rQrgL+vxz0s2JOH3d+TScMRR0+WHQLSe59YEuRgy2ZvDx448/bibtTLHKAGtORDnZrS+cMHKy+8svv5i6BYQTSQZuM1UsBQ5dbRhDwLYnnHCCacPjM40sXabsNLQMXuY+OnT4n+WQrlBsx8k6a008+eST+OSTTxzigSJh3LhxZjxsVyhaDeiGZE9mKSauvPJKE6hMC4Ydw0FrgW2d4VN9uvnQjYcuQIzRYDyFcw0Kjs95552HFi1aGBcmxkbs2rXLuGERWk44Mae1iPtmHxj8zP0whqE2+NSf407XLLpb8Rw4njVZGCj6KBq4DY9PawmtEc7cfvvtZj+c7FPwMXbCDq5nnyjUWHuE14f95PXmuVEYUAAxHoTnxSB6Bn3b51cVWmh4rnQ7owWJYpXilK5XNnQLo2ixYzeEEJ7HtpIsvJYQhwElWageJeVBNEieKuGT6Wb3O5Xs1j+t8oejraVzn7fy8jZanoJS4zX8uHlzulmybds2k4qUKWWZmpTpZ8877zyXFLE1pZsldtpULjMyMqyrr77atA0LC7M6duxo0qQWFxfvd5/uvfdek8rWZtOmTdbJJ59sxcfHmz62bdvWuvXWW63s7GyX7fj+8ssvN2lK+eK/ndOokr59+1oxMTEmBWqPHj2sr776qtrxP/74Y5MaNiIiwkpKSjLjsXz5cpfUt1XTrDqnWiX333+/1a5dO3OcuLg4q1evXtbEiRNdxm3w4MFWamqqSbWalpZmXXDBBdbSpUtd+sJxveqqq8zn3FeHDh2sZ599dp/36oQJE0xb7pvHuOWWW2pMN0t+/vlnq0uXLmb/J510kkkL65xu9uabbzZjHhISYsZjyJAh1s6dOx3b8zozpS1T8jqnm33hhRccfeB2/fv3t+bMmVNrmtuSkhJz3Zs3b26uM8+Zx3b+bl133XXm5WsptZVu1j3ob+qB8cPCmdbwV88xS0+eu/rxf+4WN74EnzDx6RtdCfjkrCHhpeZxefz6BpcerJWC1bP3GUuR8Qdyg0ORuWUePv71Cdx3+kto2f5MeAoNNW6NjYMZN7pmsCozn7DWFHTcmLFjLPi0/1Deb4yVYEpZphvlE/HGxuEat8YO42XodkerBS0tvjR2B/s7o78NB4bG7cBYvCUPN779M8ZffSK6NKs7dbk7565yhRJuiaWwsz3l7t6CO5aMR9E//s40+QdHKIBQiEMNg63ffPNN46PfGIWFODA4sWZMkB1oL4TwTPaWFSI+YJtZAg0rLPYHj44AoX8qn544v5yDGKl62Ya+x5yQnnLKKSb4sGrgHn1g6UPMQEr63tLH1Bn6tzJNItUYX/y3nXnFhn+Mzz33XLMP7ouBmfTxFf8TFEu25mPB+px9FryjqOg36yoMnv8ghi2r9Nue0OtRTBowCVPPmaiCd0IcJgYOHOgIYhaCMBZo8ODBGgwhPJztGXNQ0uIzs/RkPN5iQdP97NmzHe+dM4swdSGD7d555x0TAMcgOeb4ZrVSO7CRAXJffvmlSa3H4kgMTmTgId0B7H0xDR/FBivm2sGJFBfcjtC8zuBDBj8yN3t2drYJlKOwefHFF+Hr1NdKYRMX1wZvHXU7AgNCEBIcWZntKa1bA/daCCGEEEL4lLBgVVRnK4UNJ/Ws9nr//ffjggsuMOtYAInm/o8++sgUmaIvGE3/dlEg59zpFCtMC8kMLRQU9C9lxVbClH/MjkGBwswnzDHOjCmbN292pFNkhg/mn2e2loaOlfDWuhTM+oQ92cgozEDbln0QH1//dJlCCCGEEMKz8WhXKMI0fZzM0/+TaRfXrVvn8AtlOkKmZLRhujymEWT6PUKrBPOVO7fhvlhh1m4zd+5c4/5kiwrCVIdc59yG29iiglCU0M2Kx/BlKwWrIDNA27ZSsMZAraLi5eOB1/rgge9uwwvf3Ig9e3a6o+tCCCGEEMLXLBac7DO3ON2cmNGErk7MD884CjvHuXP1V/v9xo0bzb/ZhoWGqhaEYht7ey6Zl7wqXOfcpupxuE/u225TGxQfzsWbGFlvW1waOiGXfcwDPa5toSBrMwtQXFaO5y/pirb/WCnSYkKr7dsEaftZWLftN9zfLAkfH3EtHk1oj9CIZISFJTT4GLhj3HyVgxk3extfH3dfPveDQeOmsduf++Rgfqd8/TfqQNC4HRi8zfzgZ5bumD82CmHB4kE2Xbp0Me5JLIxElydaFUjV1Hg8+X2ly6vapqb2B9KmJljQ6ZFHHqm2nm5a7rgxCgoKzL/3N6Vg5u4SDP9gIYrL/1eZtm2MP9KTgpAcyXelyM93DWbfmbUcI+Y+hJJ/Mj61CmiKkMTjEZ/UyTEG3sDBjJsvczDjxsQILALG+Cbn6sO+Qm0VoIXGTffcoYO/LfyusdhhXdXba0N/Gw4MjduBURraDIn+iWbZ0PMn+6G41wuLqjAjEwUG3aMGDRpk1tFikJqa6mjDSqu2dYGxGZygMOuTs9WCbWj5sNvQGlJTbm/n/cyfP9/lc+6TblZVLRlVGTlyJEaMGOFycRjjQVcrd9SxIPtTV8C2UqzNKsPa/AqM+8dCQWqNpQCwas3XWLVlLjZYO/B4u6vQpl1/xAVGIDXG+9JcHsi4iYMbN+aXZ5IEJlhwTtjgS/jqeR8sGjeN3f7cK6wWz2QvB1rHguhvg8atQQgNxs6KnWbJe64h2Z+/4V4lLPhEgcHWTJfImAtO+GfNmoVjjjnGfE4RMWfOHDz11FPmfbdu3RAUFGTaXHLJJWZdRkYGlixZYjJKEVpBqPx+++03k3aPUERwnS0+2IZB2tzWFjEM6GZMB49RF2zDV1Xs9LkNjXPq3vqIijOe+9Ep21MgjmuTUGsMRVbuWuTuLcIR7c7C8J/uQWaAH8IqLHRv0QepiUfCm9mfcRMHP252e18cc2dLpq+d+8GgcdPY7S+H4ndGfxsODI3b/hNckAELllk29N+GRiMs7rrrLlM7okWLFsbKwBgLPvFnqleeJFPJPvHEE2jfvr158d/h4eEmfSyhorv22mtNilmmmo2Pjzf7pNXDzhLVqVMnnHnmmbjuuuvw6quvOtLNMiUtM0IRBn+np6ebFLTPPPMMcnJyzH64TWPMCHVA2Z5ePh6fRgThs+hofNvuLIw/+RmUl5colawQXgJ/3/h7eN9997m7K42OVq1amb9XfHkTixcvNi7JzJBIjwEhhPsIs/aifUmpWXoyHp0VirUl/u///s9M8JlSlsHSTAtrV4295557zA/18OHD0b17d2zdutVYEuwaFmTcuHHGbYoWixNOOMEID9ancDaXf/jhh0ZsUEDwddRRR5kUtTZsO336dGMq5T64L+5z7NixaGwF7uasyqp3tqeM/I1Ylr0MCzbMwpfBwFm97zWCgtBqkd5xkOpTCJ+ELposzNmmTRtjsaT7Ix+SfPvtt442fDgyZcqUatvyN+20005zvGdaa/vpHi2wdL9kvZ633nqr1lgM/o7xd4u/l/Xh77//Nr9x7HNNx7Vfdmzb/hQg5aS66n7uvfdex+esQ1T1c/vFB0q1FUvlq+pkl/1hCnL+jeC4MyaP42TDxB8XXniho09MWV6VH3/80VwrZgGs7Rq5kw0bNph+LVq06LAfi38Xacnn31EhhHtpGtoEj+3MMUtPxqMtFixqVxf8ceUfHL5qg2KARezqKmRHSwbrW9QFrSbTpk2DrxS4e/ea45EQEVyrlYLZngbOvhZFtnJOTsTMZj3QWoXuhI/DiR8fQMTGxhqXSz6oYDzWN998g5tuugkrVqzY733Sqvr222+bYFPGhLH2zm233Yb//ve/+OKLL0y9H5tNmzaZFNk333yzqeNTVQzUxEsvvYSLL77Y5aGM83Ft+HDHmfoUICWjR482Fl6byMjKOC3Cqs88jjMUNYyzsTP20UI8bNgwlzYUX8cdd5zLOj6Iohjhebdr1878u7y83PH5nj17jNjjud5xxx01jkVhYSGOPvpoXH311UaENGZ4X1Ks1gXHgWPPeEHFrwgh9oklGpT8/Hw6UJtlQ1NRUWGt3LTd+ntzrrV4S57jNfmPLVbLf08zS77fkrun1n1s3brAWrp8svXl9w9Ynd/pbH35+0vW0m0LrG1bf7caKxy33NxcsxQNM25FRUXWsmXLzNLbOOuss6ymTZtaBQUF1T7jeNjwd2Dy5MnV2tx6663WySef7Bi3oUOHWgMHDqzW7ttvvzX7eP31113Wjxo1yrr00kut5cuXW1FRUTX2w5m9e/dasbGx1rRp01zW13Zcm7y8PCsoKMiaOHGiY93WrVstf39/a8aMGY51LVu2tMaNG2fVl8zMTLPf9957r9Y2ixYtMuf+448/OtZ99dVXVkxMjLVz5856Hac+/artGtXE1KlTrW7dulkhISFWQkKCdf7559d4rPXr15v9/vnnny73Bdd9//335n1OTo512WWXWYmJiVZoaKjVrl0766233nL0yfnVp08fx37YpmPHjqYPHTp0sF5++WXHZ/ZxJ02aZLZhG7bfsGGDNWDAAHMPhIeHW+np6db06dMd25WUlJi2vN8aGwf7O6O/DQeGxu3A+PqXD61+7/czS0+eu3q0xUIcessEU8Yyu5MF10Ac2+WptixPNq/OGYnPSytrdzAwu1tqT6Sm1h3ALoSvwPgrWhOY7KEmn3RaMQ4Vp556qnmy/vnnn+Nf//qXWcd5Jy0ML7/8Mjp27GhqAH3yySfmqXNdblB5eXnGnbQqP/zwg7EasN8sPsrzsq0I+ypAyiKiNkyo8eijjxqXMFoL7r777mrWDxvWLqLL6kUXXVRrn9944w1zbkzkYUPLDZNp0EpEC7TtmsXjhoXV/bt2sNCNjO66dMOiGy0TiXDdgfLggw9i2bJl+Prrr42b2Zo1a1BUVGQ+sxONzJ49G0ceeaRjHF9//XU8/PDDxvrEhCZ//vmnsRJxHBiXaPPvf/8bzz77rLlP6C7GmEL297vvvjMxg0yQ4mxR4v55n/3000/mnhNCuIfYuHS029kGsd3SPfoSSFj4EAzIZh0Kpoxt18TV5aE2l6eS7LUIKdmN3D1ZWLN7E67qdT8GF+dVbhPdXDEUouHZvb3y5UxYLBDXCigrBrJqcDVK61q53LkaKC10/Sy2BRAeDxTuBPJd4wMQlVL5qiecAHJyz0l9Q8DjUBjYcLJJdx97Un/FFVcYt6C6hAVdt+jiUrVQKIN2KQIYr7B+/Xoz2eXEkoKCE9L6FCAldNk69thjTTtOiulSw/1RHNQEYyKYgKM2McA4CsbFOcdpEO7zl19+MdtNnjwZO3fuNPF3FHvOcRaHAwquSy+91KVmESfjBwrd2SgObLHHmBCbpKQks6TrGTMj2lBAUTBQ4BBmTqQ4YVISZ2FB9zW7jX0svmc8Be8DxqVUpWnTpuY+EUK4j4ioVvhr9zkYFvW/3wNPRMLCB2EdCgZj10ZGQQZyS3KRm70Kv8y8C//KycZfoSG4tUkSZp7xDlq3OqVB+yuEC7+/Dcx50nVdl0uAC18Hdm0FXutTfcBG/VNMaMqNwJYFrp+d/xpw9GBg6WTgq7tcP+tzL9B35H6nPG2oVIBVi3RSRDBmwY65YMwBrQPM6mNnuasKn4RTKFTtM/djQysEJ7kUGfbT+fr2yTmWgfEmFBi0RtCKwcmxM4wN4WSYVovaoIWGBc2uvPJKl/UMZOdxaa2wLUPPPfecORYtOIfTasFAaucYkoPlxhtvNPEdf/zxh7EIMVmInf68Jlh3afPmzSYLonM/GF9SNd99VcvUrbfeao7HxCfMlsjx4nVyhmNHwSqEcB+Fuzfg6KjpKNzdDMA/D8s8EAkLUU1UDJxyLor2VlYhjYgIwZBeY9Ej6UjMDAyShUK4n+5XAx3Oqm6xINFNgevn1L7toPE1WyzIkecDzVyDgffHWkGY9pqTW7qT2EU8a4OB0jVVT+W6+hY/4nH4ZJrwyTwzGNE9afz48Y42DPjmE3u7vk9V6GrDSSPdYWpzTyKs4UNhwQKl9S1AWhN2MDmtO1WFBa0YXbt2rbM+ENswQNz5ab3dPz5Zdx47ps+l0GGmKl6bw8X+iBYWZKtad4PXrKq1aOPGjUbE0QrFQHUG/teWidDODkZ3qB49erh8VjXguqqLHt3oKF4YhM+sZU8++aSxfDhnCOO9VZMlQwjRcOTlLsOaxHVm6cnCwqPTzYqGIz9/E5atmIKFf79nRMWY0nBMGjAJky+ejdRu1yK8RU+JCuEZcLJP1ybnF92gSFBo9c9sNyiS2L76Z3SDIhGJ1T/bT2HBDHN0Q+ITcmYXqgpjGZzdmBYscLWecLJJVyPGD+wL+sSzzoCduYjuQc2aNcNff/1lnqDbL6ZUfffdd12yIznDiTyhpaAuWAmdT8XtIqHOBUht7AKkdQkL+v4Tez82BQUFJh6ET91rg+5O33//fY1teMxt27aZ/disWrXKTOQ5LocTPuF3TiVcF7YrE8fKpqbUsWzH7Fi0wPAavvbaa2a9Lf4oGJ3dzyiq1q1bZ7JhOb9s4VkXjH254YYb8Nlnn5nMXhQozvCa2oVohRCiLmSx8DESA7Yga8sswL/y6d2K3RuRmNABC5d/irvWffK/oOyTH0RqgmcHCAnhibzyyitmkssAW6ZZ5aSTk3pOwGlJoJXBTqFK33cKDD4xpksSJ49r1641rilV4woYt+CcbnbMmDHmyb3tEkQ3KLqx0G3JGVoZGLDLp98DBw6scQLLGIiff/7ZITI4OWcab4oWCgD617NwHq0b559/fr0LkNK1ibU0+vbta9pTSNE1ikHVTOHtzKRJk8w4XX755bWOLS0v7A+f6FeFcRksonrNNdeYWAfGWNANjO9tiwItLLaA4r9Z+4iTegYrcxJunzutKc5ihm14flX7bMOgaVoV+FSfsRY8DwZes9ZSVdgXWm1oGWDsBPv5wAMPuLR56KGHjHBjcDavPVOd0/pCGAvDffAeoGBiSnWOLa8X3ZoYgM3x4Xa///67sSiNGDGi1jFlzAXT/bLvLEBLwWofi/Dac5zsayqEEHXSIHmqhEekm/1h6QLrnHf7WYNe62BZD0ebV4+30q13pl1n5eVtNGlk+WrMqWMPBKXGa/hx8+Z0s2Tbtm3WTTfdZNKMBgcHm/Sz5513niOdqA1TtXbv3t2Kjo62kpOTrf79+1sLFiywysrKXNLN2qlFAwMDraSkJOv00083qUKZKpb8/vvv5vPffvutxv6ce+655lUbEyZMsHr27Ol4v2fPHqtfv37mWEz92qJFC9OPTZs2uWzH63PzzTdb8fHxVlhYmElb6txm4cKFVo8ePUwaWKZNZQrUhx9+2CosLKzWh169epkUq7XBc23WrJl133331fg5x2vx4sVmbNgXth0xYoQ5l6opV+tK2cprVFMbnn9dfPbZZ1bXrl3N9Waa2AsuuKDW1La8tzne7Ce3mTlzpku62UcffdTq1KmT+Zxjy7S/69atc2zPFMPNmzc3qX2d+/7hhx86+hAXF2fSFn/++ee1prklvH5t27Y1KWV5vYcMGeKSsveJJ54w92VjROlm3YP+pjbudLN+/F/d0kMcSvhEiE+X6EfNJ0sNyRfL5uPlPx7CFc0GYMgRJ7lYLBITGyaLjTfCr4jt995QQbm+Pm4sjsYnxXTj4BNZXxs3WiboG99Q9xvHm8HdLHTXq1cveCPuGLfGQm1jR6sHY1M+/vhjU/SxsXGwvzP623BgaNwOjK/nT8bzqyfg9vbDcFaPSsuxJ85d5QrlS1iVPtYxScc6/M47enAAkBCiYeCkipmY6JYjhA0DyFmbozGKCiG8jbKoNJelpyJh4UME5290WuoPhRDif7AAnhDOMIlAfRIJCCEaAKvCdemhKCuUEEIIIYQQHkxw/nqXpaciYSGEEEIIIYQHExcUjYt2FZilJyNhIYQQQgghhAcTHxSDi3cXmKUnI2EhhBBCCCGEB7NnbxH+Cgk2S09GwsKHSG16OqwNQ81SCCGEEEJ4BxklO/FEYrxZejLKCuVD+AcEY48VbZZCCCGEEMI7SEntg5AfCpBygmdn8JPFwofYuWMuOqe+YpZCCCGEEMI7CAiKQM7eNLP0ZCQsfIjA8mIkW4VmKYQQjYXvvvsOnTp1QkWFZ+d390ZGjRqFrl29s5Dqcccdh88//9zd3RDikJCTuQBHN5lglp6MhIUPkRKSiBE5eWYphDh8bN++HbfccgvatGmDkJAQNG/eHOeeey6+/fZbRxs/Pz9MmTKl2ra33347TjvtNMf7q666yrTlKygoCE2aNMEZZ5yBt956q9aJdL9+/RAQEIB58+bBF7jnnntw3333wd+/8k/aDz/84Bgz59eKFStctvvss8+Qnp5urhGXkydPrjaprrqPlJQUlzY1HYevZ555xny+YcOGWtt8+umnLvuaPn06evTogbCwMCQmJuKCCy6o8Xyzs7PRrFkzs4+8vDyXzxYvXmyKHXIfTZs2xejRo2FZFjyFU045xdzjDcGDDz6Ie++9V4JTNAqKirOwJrzMLD0ZCQsfoqyiHNkB/mYphDg8cCLZrVs38xT96aefNhO9GTNmoG/fvrjpppsOaJ9nnnkmMjIyzL6//vprs6/bbrsNAwYMQHm56/d506ZNmDt3Lm6++Wa8+eabaOz8+uuvWL16NS6++OJqn61cudKMm/1q37694zOO0eDBgzFkyBD89ddfZnnJJZdg/vz5Lvs48sgjXfbB6+mM82d8UfBxwn/hhReazykqq7Z55JFHEBERgbPOOstF5LAPV199tenPL7/8gssuu6zGc7722mtx1FFHVVu/a9cuIzrT0tKwYMECvPjiixg7diyee+45NDZKS0v32eacc85Bfn4+vvnmmwbpkxBCwsKn2FScgeEpyWYphDg8DB8+3Ewsf/vtN1x00UU44ogjzOR0xIgRB2xB4BN1PinnE+hjjz3WPJ2fOnWqERnvvPOOS9u3337bCI4bb7wRkyZNQmFhYb2PQwF04oknIjY2FgkJCWY/a9eudZnMUbCkpqYiNDQUrVq1wpgxY8xn11xzjWnvDEUP+83Jtv20+tZbbzUWhvj4ePMZrQLO8An89ddfbywzPEbnzp0xbdq0Wvs8ceJEY6Fh26okJyebY9gvWnFsnn/+eTMJHzlyJDp27GiWtBRxvTOBgYEu+0hKSnL53PkzvnhdKPxorSI8ZtU2tIxQ1ERGRjrGiUKRVo5hw4aZe6ZDhw7m/qnK+PHjzRjddddd1T778MMPUVxcbO4JjhstHrxXKCzqslps2bIFl19+ubnmFDzdu3evJrDqsjgMGjTIWNZsXnnlFSPieE14He3zYJs5c+bghRdecFhtKJbJsmXLcPbZZ5sx4TYUWTt37nQ5Lu89fo9ozeG1I7x/WrRoYb4jFFS8v2w49tznxx9/XOu5CyEOLbJY+BDlYYkuSyHEoSUnJ8dMzmmZ4AStKpywHypOPfVUHH300S4+5Jw8UlhcccUVZrLMCeonn3xS731ShHDixqfddNuia9H555/vcCX5z3/+gy+++MLsk9aADz74wIgL8q9//cucO5/I23z11VcoKCgwlgCbd99914wNJ6606NBVZ9asWeYzHodP8WmF4L452XzyySddBEFVfvzxRzMRroljjjnGiCAKhu+//97lM1osKEic6d+/vzm2M7SGcMLaunVrXHrppVi3bl2tfdmxY4dxZ6JFoTYWLlyIRYsWubT5448/sHXrVjPedp85DkuXLnXZluPB8Xrvvfccbl9Vz4luUJxkO5/Ttm3bHBP4qvD6cNLONhRFtJZQ+B1ovMrvv/9uJvfsJ+8R3hMnn3yy+YyColevXrjuuusc1hvbosN+M5aD23MbjqXzfWPfOxR6tOa8+uqr+O9//4tx48aZf/M60bWwS5cuLtscf/zx+Omnnw7oXIQQ+4/SzfoQFSExLkshvJGsPVnIKqrbxzQ1IhVxoXHILc5FRmEG0hPSzfr1+etRVF53caH2se0RFBCEzbs3IzQgFEnhrk+o62LNmjVmcs9JfUPA4/z999+O97Nnz8aePXvMZJJQYNAdiu419cF237Hhtnzqzwktn4DTzYpPomnV4NPmli1bOtr27t3bPGV///33zcSUUOTQRcl+Mk/owvPwww+bf3NfL730khExfALN/tPSs3z5ciOKiP3kvzY4YebE3xlOzF977TXjklZSUmL6RHHB2At7kss4GD4Zd4bvud6G8Q6cxLMvnOg+9thj5jw54efT/apw4hsVFVVrbIQ9pgw0535sbLHCp++0LlCsPfvss2ayvWrVKmPd4Xn83//9n7Fq8Al9TQKHfbeFnvM52Z9RHFXlo48+QlZWlhEltMbwurZr1w4HCu8RCkdarzgWvEcolkhMTAyCg4MRHh7uEqtCKwwtcU888YRjHa1cFB08f/teYL8oRp2FK/dz+umnm/gjjguFhDO08rFPFEo1iTEhvIW9oXEuS09FwsKH8C/d7bIUwhv5dNWnGP/X+DrbjOo1ChcecSG+2/QdRs0dhcVDK/3iH/jlAfyd9b+JeE3MumgWUiJSMG7hOLSLbYfhXYfXu2+2uwknZw0Bj+d8LE5a6WLDp7qEE9G7777bPDnmpH9f0O2JAa902aIbiv3UmhMzCgu6slAAcF+M++Dk0fmpP60WnNBTWGRmZpqn984B66RqbABFANsSPslnULI9kawPRUVF1dyg2D/n8+VT8s2bN5t4A1tY1HSdqo6ncwwEn4RzP23btjUCgpadqnAyTJeimtyy7L5yIs8xdsYe5/vvv98h7ijKOBYM8L7hhhuMqxYFCcViXdR0TjWtt+GYc+JP8XIo4P1BMUFByHuEL1q9KCbqsuLQouQsQJ3vSft+qGqZomil65p9LLo9MUmCff8TBrFzfCnM+G8hvJW9ofEuS09FwsKHCNyT6bIUwhu5+IiLcUrzU/ZpsSCntjgVnRI6OdY/dsJj+7RYJIRWPom+o9sdxmKxP/AJPCdwfOJOv/O64NNcBpZWhev4ZLc+8Dj2U2i6YdEVpKyszDwBttm7d6+Z8D711FP73B8nZXxK/PrrrxsrACdkFBR2oCyfKq9fv97EdtC6QFcVPi2mSwq58sorTRYePv3mi0/PTzrpJJdj8MmyMxwve2J9IBM/+tvn5ubus13Pnj2Ne5UNn3Q7WycIBU5VK4YzfBJPgUG3m6rQ3YYCjnEttcFxokWJ41RVXBFmprKhOxMnzBR1hMkAGDhuj7UtGHj+FCQMCK/tnEht57W/Y86n/lXjNXjPOd/XdO2idWjmzJl46KGHjCWG7nW1uQLy+vPeq+ketceGVHUv5L3KMacrHe9HxjfRosM4Dvs+4/eCokaiQng7fmUFLktPRcJCCOFV0DWpvu5JdIfiy6Z1THVXkNpoHtV8v/vGp750Q3r55ZeNn3nViRCDbu3JFd2YONkaOnSo43NO2Pj01nZlqgt7onnHHXc4Anf5hLtqCltaDBhg/fjjj7s8ya0phSmFCv3VbTHw888/V2sXHR1trCJ8MSiXT4o5eeO50z2IgopP2yks6uuC5WzNYCCxs/vLvuDTdrpq7Ys///zTZZJK6wMnpPb4EU6EnV2UqsKn3hyjqmLJthbR9YpxL7XBNuedd161AHBuRyHBSTLdzOzJOt28bHczZo2ixcOG9w4D5iloaEWxz4nB2hSCdDmyz4kisaqLlPOYv/HGG+YaVu1XTbCNcxwNheuSJUtMwLoN7zMKTr7o9sZ7nvcrXcTYL27jDAUrz499rOserQkKBo4pX4xt4veK3wvuk7Bv9r+F8GaCCne4LD0VCQshhDiEMCMOJ6f09WYAKyduzPrDSSwtCZyYEmb1oajgRIjuRJw00o2Irh/M6FR1Qssn0ZyQ0defwa0UC3RFsp9+c9LKiT4tDM5wYvrvf//buCUNHDiw1n7HxcUZYcA+cALOJ+W0PjjDQFl+xiBbPrmmmw6fkjs/iaY7FPvFvjqLpvrAmAK6KtEdiLEG9Kln7QlaNShgaoIijK5JztA9hpNUZuPiJJuWCk5c+bJhFiYei0/JOS4MXOZTb2cxxWvEJ+n03eeTf8ZYMKVr1fPiOo4F4yLqir9hoDnjAmoSa8wGxUk4n8Lzmtl1MOw0urZ4sLEzJtE9yh5/pqel5YIuaxQYtKwwboFWg9pcoeguxzYcc95TFCEUYVxSqNSUNIBuYLyf2CfeE861NJjBi/EfHFveUzxfWiRs1zReFwbuUzTR9YmClIKAVjLbdY9WGI4XM35xfW3B+8x+xfuMsTC0SjCWhkLDOfaHwqtqkL4Q3khaSBJGZ2UjrFP94/7cgiUalPz8fNqQzbKh+fqXD61+7/czS1F/KioqrNzcXLMUDTNuRUVF1rJly8zSG9m2bZt10003WS1btrSCg4Otpk2bWuedd571/fffu7SbOHGi1b17dys6OtpKTk62+vfvby1YsMAqKytzjNvQoUPNbwZfgYGBVlJSknX66adbb731lrV3717T5vfffzef//bbbzX259xzzzWvfTFr1iyrU6dOVkhIiHXUUUdZP/zwg9nv5MmTzeevvfaa1bVrVysiIsL0+bTTTrP++OMPl32w3zzvs88+u9r++/TpY912220u6wYOHGjO0SY7O9u6+uqrrYSEBCs0NNTq3LmzNW3atFr7nJOTY4WFhVnLly93jNtTTz1ltW3b1mwfFxdnnXjiidb06dOrbfvpp59aHTp0sIKCgqyOHTtan332mcvngwcPtlJTU83naWlp1gUXXGAtXbq02n5effVV04e8vLxa+zly5EirWbNmjmtWldLSUuvOO+8090FUVJS5xkuWLKl1f7yXeG34HXPm77//tk466SRzDVNSUqxRo0bt8zu4fv16c268puHh4eaenD9/vvns4Ycfto4++miXft54441WfHy86euYMWNcruFPP/1krjPHnWPC+2jSpEmO7VeuXGn17NnTfMb+89hk1apV1vnnn2/Fxsaaz3g9br/9dkffa7p3eF/26NHD9Jv3JPc7e/Zsx+dbtmwx127z5s2H5XdGfxsODI3bgbHqzx+t3CePMktPnrv68X/uFje+BJ9s0X+aftR8StWQfPf7NHz410u4/OibcWp313zzonb4FbH93hsqKNfXx425+OnLz/iB2gJhG/O48Sksn9J64/3GGAI+7WZcR13ZkQ4lDBbnU3Nai7x13NyJt99ztUHrB3+DaIU7HL8z+ttwYGjcDoy5v32B3/54Gscfew96HX8ePHXuqtxrPkRSyolYue1msxRCiEMJ3V1YC4EZj/gHiD7vDQWDl+n+UtV3X/g2TJX86KOPursbQhwS9qACv4eEm6UnoxgLIYTwARgz4Zx1qCoMgGYswcHsn09+GUBO3/f9DcI9GChkGFMgYSGqWiyEaCwkp52C9d8EIvkMz344LGHhQ2zd9BUiWr+LrZt2oUuzy9zdHSFEA0L3JNYsqOvzg4FBufKsFUII30bCwodICo7D9bn5ZimE8C1oQTiYispCCCHcR8bmb5DQ8g1kbC5El2aDPfZSKMbCh4gOjMRpe4rMUgghhBBCeAcV1l4U+/ubpScji4UPsau8AH+Hh6FVuWdXbRTCxq7ILIQQhxq57glx6JGw8CGySnPxWlwM7ijNdXdXhKgTVudlATZmGWKlX75vTGkwfTH15+FG46ax29/7JSsry3zHgoKCDtNdKYTvIWHhQ5RFNXdZCuGpUFQww1BGRoYRF75oqeEYCI2b7rnDB0UFs5jVVtlbCLH/SFj4EFZAsMtSCE+GVgqmPy0vL/epNKJ8krp7925ERUXJYqFx0z13GKGlQqJCeAtlUc1clp6KhIUPEVi43WUphKdjuyn4kqsChUVJSYmpBCxXKI2b7jkhBLECQlyWnops7QfAK6+8Ytw0+Ie/W7du+Omnn+AN+JcVuiyFEEIIIYTnE1iU6bL0VCQs9pNJkybh9ttvx/33348///wTJ510Es466yxTdVYIIYQQQohDTWBJAcIqKszSk5Gw2E+ee+45XHvttfjXv/6FTp064fnnn0fz5s0xfvz4w3OFhBBCCCGET9M6vBneycg0S09GMRb7QWlpKRYuXIh7773XZX2/fv3w66+/1rgNfaX5ssnPz3csGzqHdmHBHuwt2muWdj/EvuF1ssdLPu/1R+N2YGjcNG4Nje45jZvuN89n9+4CBBdXmGVDz+F27dpllvWZt0pY7Ac7d+402WmaNGnisp7vt2+vOSB6zJgxeOSRR6qtZ7Ybd/EtvgVwnduOL4QQQgghDoBRZ8NdMGNhTExMnW0kLA6Aqk+tqeBqe5I9cuRIjBgxwiU/fU5ODhISEhr86TcVJ922Nm/ejOjo6AY9tjejcdO46X7zfPQ91djpnvMO9F31vnGz06CnpaXts62ExX6QmJhocl5XtU5kZmZWs2LYhISEmJczsbGxcCe8ISUsNG663zwbfU81brrnvAN9VzVuvnC/xezDUmGj4O39LNjF9LKzZs1yWc/3vXv33r8rJIQQQgghRCNCFov9hG5NQ4YMQffu3dGrVy+89tprJtXssGHDDs8VEkIIIYQQwguQsNhPBg8ejOzsbIwePRoZGRno3LkzvvrqK7Rs2RKeDl2yHn744WquWULjpvvNc9D3VOOme8470HdV46b7rTp+VkPnPBVCCCGEEEI0OhRjIYQQQgghhDhoJCyEEEKI/2/vTqCjqLIGjl+WEJBNEAmJQECFoGGTxREOsmoiCLKp6EFBURQEBRk+JeCIuDGjDiJHFh1RBFxnWAYMKDhsKiBIwCACoiCJGARkCUIIW33nvpnu0510J510kk51/X/nFKSrq7teXl51v1tvAwAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEjcACAAAAQNAILAAAAAAEzbGBxeTJk6Vt27ZStWpVqV27tvTp00d2796d7+vWrl0rrVu3looVK8qVV14ps2bNKpH0AgAAAKWZYwMLDRBGjBghGzdulJUrV8r58+clISFBTp065fc1+/btkx49esiNN94oW7dulfHjx8tjjz0mCxYsKNG0AwAAAKVNGcuyrFAnojQ4fPiwabnQgKNjx44+j3nyySdlyZIlsnPnTve+YcOGybfffisbNmwowdQCAAAApUv5UCegtDhx4oT5v2bNmn6P0eBBWzU8JSYmyuzZs+XcuXMSERGR6zXZ2dlmc7l48aIcPXpULrvsMilTpkyR/g4AAABAUdI2iJMnT0pMTIyULZt3ZycCi/9l2JgxY6RDhw7StGlTv5l18OBBiYqK8tqnj7Ub1ZEjRyQ6OtrnWI5JkyYV/q8JAAAAhFh6errUrVs3z2MILERk5MiRkpqaKl9++WW+mZqzlcHVk8xf60NSUpIJWjxbRurXry/79++XatWqSUnS1hINgGrVqpVvxAnyjfIWGlyn5Btlzh64Vsk3p5S3zMxMiY2NNRMe5cfxgcWjjz5qxk2sW7cu3yisTp06ptXC06FDh6R8+fKma5MvkZGRZsvp0ksvDUlgcfbsWXNuAgvyjfJWOnGdkm+UOXvgWiXfnFLeyv7vfIF04XfsbWttadCWioULF8qqVaukYcOG+b6mXbt2ZgYpTytWrJA2bdr4HF8BAAAAOIVjAwudanb+/Pny/vvvm6YdbYnQLSsry6sb06BBg7xmgNIuTNq1SWeGevvtt83A7bFjx4botwAAAABKB8cGFjNnzjTjHTp37mwGXbu2jz76yH1MRkaGpKWluR9rq8ayZctkzZo10rJlS3nuuedk2rRp0r9//xD9FgAAAEDp4NgxFoEs3zFnzpxc+zp16iQpKSnFlCoAAADAnhzbYgEAAACg6BBYAAAAAAgagQUAAACAoBFYAAAAAAgagQUAAACAoBFYAAAAAAgagQUAAACAoBFYAAAAAAgagQUAAACAoBFYAAAAAAgagQUAAACAoBFYAAAAAAgagQUAAACAoBFYAAAAAAhaebGJIUOG+NxfvXp1iYuLk3vuuUeqVKlS4ukCAAAAYKMWi2PHjvnctm3bJk8//bQJLvbu3RvqZAIAAACOZJsWi0WLFvl9LisrSwYNGiTjxo2Tjz/+uETTBQAAAMBGLRZ5qVSpkjz55JOycePGUCcFAAAAcKSwCCxUzZo15fjx46FOBgAAAOBIYRNYrF+/Xq666qpQJwMAAABwJNuMsUhNTfW5/8SJE7J582Z58cUX5fnnny/xdAEAAACwUWDRsmVLKVOmjFiWleu5yy+/3IyxGDZsWEjSBgAAADidbQKLffv2+V3H4tJLLy3x9AAAAACwYWARGxtr/s/Ozpbz589L5cqVQ50kAAAAAHYbvH3kyBG59dZbzera1apVk/bt27MgHgAAAFBK2CawSEpKki1btsikSZPk5ZdfNoHGww8/HOpkAQAAALBTV6jPPvtM3n77benRo4d5rP83bdpUzp07JxEREaFOHgAAAOBotmmx+PXXX+W6665zP27SpIlUqFDB7AcAAAAQWrYJLHSa2fLlvRtY9PHFixdDliYAAAAANgwsunXrJq1atXJvp0+fll69enntC9S6devMa2NiYsz6GIsXL87z+DVr1pjjcm67du0qgt8OAAAAsDfbjLGYOHFirn29e/cu9PudOnVKWrRoIffff7/0798/4Nft3r3bzErluTgfAAAA4HS2DiyC0b17d7MVVO3atVmQDwAAALBrYHHmzBlZsWKFdOnSRapWrer1XGZmpumqlJiYKJGRkcWaDh1Armm59tpr5amnnjLpyYsu6KebZ1qVjg0p6fEhej7tUsa4FPKN8lZ6cZ2Sb5Q5e+BaJd+cUt4uFuCctgks3njjDVmyZIncdtttuZ7TrknTpk2TtLQ0GTlyZLGcPzo6Wt58801p3bq1CRTmzZtnxnxoQNOxY0e/r5s8ebJZeyOnw4cPmwClpAvGiRMnTMEsW9Y2w2tCjnwj3yhvpR/XKXlHmbMHrlX75dvJkycDPraMpSm0geuvv17+8pe/mAHXvnzyySfy7LPPyqZNmwr83joIe9GiRdKnT58CvU7Toq/VgKcgLRb16tWTY8eOeY3VKKlCqQGNjgshsCDfKG+lE9cp+UaZsweuVfLNKeUtMzNTatSoYQKb/Oqutmmx2LNnjxls7U/z5s3NMSXphhtukPnz5+d5jHbN8tU9SwtFKCr3GgiF6tx2Rr6Rb5S30o/rlLyjzNkD16q98q0g57NN7fL8+fMmUvNHn9NjStLWrVtNFykAAADA6WzTYhEfHy+ff/65GePgy8qVK80xgfrjjz/kxx9/dD/et2+fbNu2TWrWrCn169eXpKQkOXDggMydO9c8P3XqVGnQoIE5x9mzZ01LxYIFC8wGAAAAOJ1tAoshQ4bImDFjTMW+Z8+eXs8tXbpUnn/+eZkyZUrA7/fNN994zeik760GDx4sc+bMkYyMDDMY3EWDibFjx5pgo1KlSiYdycnJ0qNHjyL5/QAAAAA7s01g8dBDD5nVsnVWqCZNmkhcXJzpa7Zz50754Ycf5M477zTHBKpz585mZL0/Glx4euKJJ8wGAAAAwMZjLJR2P/rwww+lcePGJpjYtWuXCTA++OADswEAAAAIDdu0WLhoy4RuAAAAAEoPW7VYAAAAACidCCwAAAAABI3AAgAAAEDQCCwAAAAAOCewiImJkeHDh8vy5cvNmhIAAAAASg/bBBbvv/++XHLJJfLYY49JrVq15I477pB58+bJ0aNHQ500AAAAwPFsE1jognZ///vfZc+ePbJhwwZp1aqVTJ8+XaKjo81zr776qvz000+hTiYAAADgSLYJLDzFx8dLUlKSbNy4UdLS0mTgwIGyatUqadasmTRt2lSSk5NDnUQAAADAUWy3QF5OUVFRMnToULOdPn1aPvvsM4mMjAx1sgAAAABHsX1g4UnHYPTt2zfUyQAAAAAcx5ZdoQAAAACULgQWAAAAAIJGYAEAAAAgaGERWFy8eFGWLl0qffr0CXVSAAAAAEeydWCha1rotLN169aVO++8M9TJAQAAABzLdrNCZWVlyccffyyzZ88261hcuHDBLI43ZMgQqVKlSqiTBwAAADiSbVosNm3aJA899JDUqVNHXn/9denfv7+kp6dL2bJl5aabbiKoAAAAAELINi0W7du3l0cffdQEGHFxcaFODgAAAAA7BhZdu3Y13Z8OHTok9957ryQmJkqZMmVCnSwAAAAAduoKtWLFCtmxY4dprRg+fLhER0fLqFGjzHMEGAAAAEBo2SawUPXq1ZOnn35a9u3bJ/PmzTOtF+XLl5fevXvL+PHjJSUlJdRJBAAAABzJVoGFp5tvvlk++OAD+fXXX83Yi+XLl0vbtm1DnSwAAADAkWwbWLjUqFHDBBZbt26VzZs3hzo5AAAAgCPZZvC2a4XtOXPmyMKFC+Xnn382YysaNmwot99+uxnQ3apVq1AnEQAAAHAk27RYWJYlt912mzz44INy4MABadasmcTHx8v+/fvlvvvuk759+4Y6iQAAAIBj2abFQlsq1q1bJ//5z3+kS5cuXs+tWrVK+vTpI3PnzpVBgwaFLI0AAACAU9mmxUIHauvMTzmDCtcaF+PGjZP33nsv4PfTIKVXr14SExNjulQtXrw439esXbtWWrduLRUrVpQrr7xSZs2aVeDfAwAAAAhHtmmxSE1NlZdeesnv8927d5dp06YF/H6nTp2SFi1ayP333y/9+/fP93id4rZHjx4ydOhQmT9/vnz11VfyyCOPyOWXXx7Q6wEAAMJNWlqaHDlyxPxcq1YtqV+/fq79OZ/z9/pg+Tu/v3MHItDfAzYLLI4ePSpRUVF+n9fnjh07FvD7aSCiW6C0dUIL0tSpU83ja665Rr755ht55ZVXCCwAAAgjgVZKDx8+bMZ95lyoN5DKZ1FWqENFf/9+/frJ6dOnzeNLLrnETLCjPPd7Pqd5c+bMGZNv+vvnPC4Y/s7v2q83g4P5/QJ9r1p5BFjBjDWuUKGC1K5dW0oz2wQWFy5cMIvh+VOuXDk5f/58sZ1/w4YNkpCQ4LUvMTFRZs+eLefOnZOIiIhiOzcAoPTJ605moHdx83ttSdAKi6uipxXkUKalNFeWc1YkdZHeF154QdavX29mrfSUX+XTV4XVrvR3/fTTT83P+jvdcsstXvs1D1y/rz5XtmxZ0618y5YtJt88jwuG5znySldhf7+cv0d+r1noJ8AqLM239u3bm14zsbGxUlrZJrDQDz6d/SkyMtLn89nZ2cV6/oMHD+ZqMdHHGszoh250dLTfdHmmLTMz0/yvF1POD6LipufTfCzp89od+Ua+Ud6KVnp6ekCVVa3g1qtXL6DXuCrHv/zyS667x8VBKxh33HFHrjuZ//znP83Pns/52+8pkGOKi1ZYdLr2lJQUd0UvVGkpLTQPdOFdVx5oV2hf+dauXTv55JNPvO4iu8qGr9f4OkewFepQ87xOv//+e6+A2rXf8znXtarjVV2BrOdxwfB3fs/9BeXv9/DncI6/f1H9nXft2mW6/Ov7F1V+Baog9cYylv6FbUDHQgTinXfeKfB7a8FetGiRmVnKn8aNG5s0JCUluffpOIsOHTpIRkaG1KlTx+frnnnmGZk0aVKu/TNmzJBKlSpJSdI/tQZC2vJTEl+84YJ8I9/CpbzpTY7ibNkNhJ5/z549AX1RacWtUaNG5udAXlO5cmUzfq6kuNKnf6ucv5e/tHu+xsXfa/NqpS9qem49b2lIS2mgv6/rRmZe141eo/pdnvNaDeRa8zyHkzjhOzXb4+9fVH9n/WzTNdwaNGhgPutKUlZWlhlXfOLECalWrVqex9rmk6IwAUNR0sBBWy1yNoNqgbnsssv8vk4DkTFjxni1WGikeffdd+f7xylq+kWhka5GzfplAfKN8lZ8PO+wF+bOu+tuXnHeYQ8V1x3xvO7g5Uxvfq8prnwryJ3MQP7m/u7OBnJMSX03hDItdsJ3KvlWklJSUsyyCgMGDCjxBaG17qqBRSBsE1iEmjZ3Ll261GvfihUrpE2bNnmOr9Ao1Vekqh/eoajc6xduqM5tZ+Rb6PMtkMGUBe3XXhoGNOaUs/9xUdJ0LFu2LORdLwKdVWXHjh0Bz+qieaU3e7RLSqg+37Tfs6++z/72F/SYkrpWQ50WO+G7gXwrybJmWZa7zJWkgpzPNoGFrl/h6y5U9erVJS4uTkaMGFGguyp//PGH/Pjjj17TyW7btk1q1qxpvry0pUEHsml0qIYNGyavv/66aX3QKWd1MLcO3Nb1NQCn81eh95wxJZiKfiCDKYOpzIdqQGNJ33m32zSJmlY7pRcAnM42gUXLli197j9+/Li5A6eV/i+//NLvcTnpVLGei+25uisNHjzYrPKt4ya08uPSsGFDc57HH39cpk+fbhbW00E0rGEBuyrMXXxfwYG/Cr1WkD1nTAm2oh/IDB+FrcwXB8+82rlzp63uvAMAENaBxauvvprn89pioStza+U/EJ07dzYVH380uMipU6dOpo8bUJKKo3tPYac6zGuO8JwVetfUeMnJyebOe7AVfX8V9UCOCfWdeu68AwCcwDaBRX4efvhhs64EUBoUVZ/+4uzeU9DKvb85wvX1vir0rsV84uPjTZBRlBX9QCrqVOYBAChZYRNY6HRv2i8ZKOjA3/yCgJyLR+WnqBc+Kq7uPYWp3AcSHLgq9K4uPTn3AwCA8BQ2gYXO0KRrTSC8FMWd/7wG/gYSBBRmlp6i7NNfmrr3EBwAAADbBxZLlizxuV8X69i8ebOZocnXuAiUjIJOBRqIorzzn9fA3+KYpae4Kv1U7AEAQGllm8DC36rYVatWlSZNmpigQhdTQskPCi7MVKCBKqo7/3kN/GWWHgAAAAcFFkW9UJRTudYV0Ip1UQ4KLshUoIWdCaiocNcfAADAwYEFgpeenm6WZPdcV6CoBgUXdCpQAAAAhBfbBBarVq2SkSNHysaNG6VatWq5xlnofPmzZs2SG2+8MWRpLO20sp+dnW1WE7/mmmuKbVAwLQIAAADOY5vAYurUqTJ06NBcQYWqXr26WcdiypQpBBYB0DEprVq18tpHMAAAAIBglBWb+Pbbb33223dJSEgw04ECAAAAKHm2CSx+++03iYiI8Pt8+fLlzcBkAAAAACXPNoHFFVdcIdu3b/f7fGpqqkRHR5domgAAAADYLLDo0aOHPP3002ahspyysrJk4sSJ0rNnz5CkDQAAAHA62wzefuqpp8w6C40bNzazQ8XFxZlVkHU2o+nTp8uFCxdkwoQJoU4mAAAA4Ei2CSyioqLM+gvDhw+XpKQksSzL7NfgIjExUWbMmGGOAQAAAFDybBNYqNjYWFm2bJkcO3ZMfvzxRxNcNGrUSGrUqBHqpAEAAACOZqvAwkUDibZt24Y6GQAAAADsNngbAAAAQOlFYAEAAAAgaAQWAAAAAIJGYAEAAAAgaAQWAAAAAIJGYAEAAAAgaAQWAAAAAIJGYAEAAAAgaAQWAAAAAIJGYAEAAAAgaAQWAAAAAIJGYAEAAAAgaI4PLGbMmCENGzaUihUrSuvWreWLL77wm1lr1qyRMmXK5Np27doV/F8CAAAAsDFHBxYfffSRjB49WiZMmCBbt26VG2+8Ubp37y5paWl5vm737t2SkZHh3ho1alRiaQYAAABKI0cHFlOmTJEHHnhAHnzwQbnmmmtk6tSpUq9ePZk5c2aer6tdu7bUqVPHvZUrV67E0gwAAACURo4NLM6ePStbtmyRhIQEr/36eP369Xm+9rrrrpPo6Gjp1q2brF69uphTCgAAAJR+5cWhjhw5IhcuXJCoqCiv/fr44MGDPl+jwcSbb75pxmJkZ2fLvHnzTHChYy86duzo8zV6nG4uJ06cMP8fP35cLl68KCXp5MmT5pz6v54fgdE8y8zMlAoVKkjZso6NxQuMfCPfKG/2wLVKvlHeSr+TIazDaR1IWZaV77GODSxcdPC1J820nPtc4uLizObSrl07SU9Pl1deecVvYDF58mSZNGlSrv2xsbESKl26dAnZuQEAAGC/OpwGNdWrV8/zGMcGFrVq1TJjI3K2Thw6dChXK0ZebrjhBpk/f77f55OSkmTMmDHuxxptHj16VC677DK/AUxxRpw6hkSDoWrVqpXoue2MfCPfKG+lH9cpeUeZsweuVfvlm95016AiJiYm32MdG1hotxbt0rRy5Urp27eve78+7t27d8Dvo7NJaRcpfyIjI83m6dJLL5VQ0gJJYEG+Ud5KN65T8o0yZw9cq+SbE8pb9XxaKsTpgYXSloR7771X2rRpY7o16fgJnWp22LBh7taGAwcOyNy5c81jnTWqQYMGEh8fbwZ/a0vFggULzAYAAAA4maMDiwEDBsjvv/8uzz77rFmPomnTprJs2TL3+Afd57mmhQYTY8eONcFGpUqVTICRnJwsPXr0COFvAQAAAISeowML9cgjj5jNlzlz5ng9fuKJJ8xmV9ola+LEibm6ZoF8o7yVHlyn5Btlzh64Vsk3yltuZaxA5o4CAAAAgDwwKT8AAACAoBFYAAAAAAgagQUAAACAoBFYOMiMGTOkYcOGUrFiRbOGxxdffCFO9cwzz5gFCj23OnXquJ/XoUd6jC4GozOAde7cWXbs2OH1HtnZ2fLoo4+axRYrV64st912m/zyyy8STtatWye9evUy+aB5tHjxYq/niyqfjh07ZqZ+1nmyddOfjx8/LuGab/fdd1+u8qeLbTo93yZPnixt27aVqlWrSu3ataVPnz6ye/dur2Moc4XLN8pcbjNnzpTmzZu71wXQaeeXL19OWQsy3yhrgV+3+tk/evTo8Pp808HbCH8ffvihFRERYf3jH/+wvv/+e2vUqFFW5cqVrf3791tONHHiRCs+Pt7KyMhwb4cOHXI//9e//tWqWrWqtWDBAmv79u3WgAEDrOjoaCszM9N9zLBhw6wrrrjCWrlypZWSkmJ16dLFatGihXX+/HkrXCxbtsyaMGGCyQf9uFi0aJHX80WVT7fccovVtGlTa/369WbTn3v27GmFa74NHjzY/M6e5e/333/3OsaJ+ZaYmGi988471nfffWdt27bNuvXWW6369etbf/zxh/sYylzh8o0yl9uSJUus5ORka/fu3WYbP368+Z7UfKSsFT7fKGv527Rpk9WgQQOrefPmpj4WTp9vBBYOcf3115vC6KlJkybWuHHjLKcGFnoh+nLx4kWrTp065gJ3OXPmjFW9enVr1qxZ5vHx48fNB6kGbC4HDhywypYta3366adWOMpZQS6qfNJAV99748aN7mM2bNhg9u3atcuyO3+BRe/evf2+hnz7Lw32Nf/Wrl1rHlPmCpdvlLnA1ahRw3rrrbcoa4XMN8pa/k6ePGk1atTIBAadOnVyBxbh8vlGVygH0IX9tmzZIgkJCV779fH69evFqfbs2WOaG7V72F133SV79+41+/ft2ycHDx70yi+dr7xTp07u/NL8PHfunNcx+l66yKJT8rSo8mnDhg2mqfZPf/qT+xjtFqT7wjkv16xZY7qtNG7cWIYOHSqHDh1yP0e+/deJEyfM/zVr1jT/U+YKl2+UufxduHBBPvzwQzl16pTp2kNZK1y+UdbyN2LECLn11lvlpptu8tofLmXO8QvkOcGRI0fMxR8VFeW1Xx9rIXYiveDmzp1rKnW//fabPP/889K+fXvTl9GVJ77ya//+/eZnPaZChQpSo0YNx+ZpUeWT/q8V7Jx0X7jmZffu3eWOO+6Q2NhY82Xyl7/8Rbp27Wq+NPSLhHz7b1/jMWPGSIcOHcyXpqLMFS7fKHP+bd++3VSIz5w5I1WqVJFFixbJtdde666A8flWsHyjrOVNg7CUlBTZvHlzrufC5fONwMJBdJBQzi+gnPucQit2Ls2aNTMfkFdddZW8++677kG0hckvJ+ZpUeSTr+PDOS8HDBjg/lkrf23atDFBRnJysvTr18/v65yUbyNHjpTU1FT58ssvcz1HmSt4vlHmfIuLi5Nt27aZga0LFiyQwYMHy9q1aylrhcw3DS4oa76lp6fLqFGjZMWKFWYSHX/s/vlGVygH0JkDypUrlytS1a4XOSNjp9KZFTTA0O5Rrtmh8sovPUa7mOnMC/6OCXdFlU96jLYa5XT48GHH5GV0dLQJLLT8Kafnm854smTJElm9erXUrVvXvZ8yV7h884Uy91969/fqq682wb3O0tOiRQt57bXXKGuFzDfKmn/aIq2f4TorZ/ny5c2mwdi0adPMz67Pbbt/pxJYOIB+AGhBXrlypdd+fazdf/Df6dt27txpvmx1zIVemJ75pReyfgC48kvzMyIiwuuYjIwM+e677xyTp0WVT9papH3CN23a5D7m66+/Nvuckpe///67uZul5c/J+aZ31PSO+8KFC2XVqlWmjHmizBUu33yhzPnPS/0+oKwVLt8oa/5169bNdCHTlh7XpoHZwIEDzc9XXnlleHynFvvwcJSq6WZnz55tZgwYPXq0mW72559/tpzoz3/+s7VmzRpr7969ZuYEnYZNp3hz5YfOyqAzMSxcuNBM+Xb33Xf7nPKtbt261ueff26mfOvatWvYTTers1ds3brVbPpxMWXKFPOza5riosonnRpPp93TmSt0a9asma2nTc0r3/Q5LX86BeC+ffus1atXW+3atTPTBzo934YPH27Kk16bnlPxnj592n0MZa7g+UaZ8y0pKclat26duQ5TU1PNtKk6u86KFSsoa4XMN8pawXjOChUun28EFg4yffp0KzY21qpQoYLVqlUrr6kIncY1N7QGWzExMVa/fv2sHTt2uJ/Xad90Slqd+i0yMtLq2LGjucg9ZWVlWSNHjrRq1qxpVapUyVy0aWlpVjjRSq9WjHNuOl1qUeaTruEwcOBAE9zppj8fO3bMCsd808peQkKCdfnll5vyp+sN6P6ceeLEfPOVZ7rpGg0ulLmC5xtlzrchQ4a4vxP1euzWrZs7qKCsFS7fKGvBBRbh8PlWRv8p/nYRAAAAAOGMMRYAAAAAgkZgAQAAACBoBBYAAAAAgkZgAQAAACBoBBYAAAAAgkZgAQAAACBoBBYAAAAAgkZgAQAAACBoBBYAgLDXuXNnKVOmjNm2bdsW6uTIfffd507P4sWLQ50cACgSBBYAAL+VXs/tlltusXVODR06VDIyMqRp06a5nktISJBy5crJxo0b88yPiIgIiYqKkptvvlnefvttuXjxotex/gKF0aNHm+DG5bXXXjNpAYBwQmABAMhFgwit+HpuH3zwQbHm1NmzZ4v1/S+55BKpU6eOlC9f3mt/WlqabNiwQUaOHCmzZ8/OMz9+/vlnWb58uXTp0kVGjRolPXv2lPPnzxc4LdWrVzdpAYBwQmABAMglMjLSVHw9txo1anjdmX/rrbekb9++psLeqFEjWbJkidd7fP/999KjRw+pUqWKuct/7733ypEjR9zP6x18rcyPGTNGatWqZVoBlL6Pvl+lSpVMBf7dd9815zt+/LicOnVKqlWrJv/617+8zrV06VKpXLmynDx5ssB/zXfeeccECMOHD5ePPvrInMNfflxxxRXSqlUrGT9+vPz73/82QcacOXMoQQBAYAEAKKxJkybJnXfeKampqSaAGDhwoBw9etQ8p3f3O3XqJC1btpRvvvlGPv30U/ntt9/M8Z40aNAWhK+++kreeOMN0yJw++23S58+fcxYiIcfflgmTJjgPl6Dh7vuussEA570sb6uatWqBfodLMsyr73nnnukSZMm0rhxY/n4448Dem3Xrl2lRYsWsnDhwgKdEwDCFS0WAIBcPvnkE9PS4Lk999xzucYe3H333XL11VfLiy++aO70b9q0yTw3c+ZMc2df92uF/brrrjNjElavXi0//PCD+z30tS+99JLExcWZ42bNmmV+fvnll83/GkToeTw9+OCD8tlnn8mvv/5qHmsriKZ3yJAhBf5Lfv7553L69GlJTEw0jzXA8NcdyhdNswZDAAACCwCAD9oFSVsMPLcRI0Z4HdO8eXOvlgRtLTh06JB5vGXLFhNEeAYmWglXP/30k/t1bdq08XrP3bt3S9u2bb32XX/99bkex8fHy9y5c83jefPmSf369aVjx44F/ltqEDFgwAD3uAsNlL7++muTjkBbPLSbFgBAxHsEGwAA/wsUtDUhLzpDkietYLtmSdL/e/XqJX/7299yvS46OtrrPPlV1HVfTtpq8frrr8u4ceNMV6b777+/wBV87balMzidO3fOtLC4XLhwwbSu+Ep7Tjt37pSGDRu6H2twdeLEiVzH6fgQHbANAOGMrlAAgCKn3aB27NghDRo0MAGK55YzmPCkrRqbN2/22qdjNHLSLks6m9O0adPMeQYPHlzgNL733ntSt25d+fbbb71aZqZOnWrGfuQ329OqVatk+/bt0r9//zzTr4GRtuBo1y4ACGcEFgCAXLKzs+XgwYNem+eMTvnRblPaIqBdi3Tcxd69e2XFihVmHIS2CPijg7V37dolTz75pBmLoQOpXbMuebZI6AxV/fr1k//7v/8za1BogFCYblA64FvXtfDcNI3awpCcnJwrPw4cOCApKSlm7Ejv3r3NbFKDBg1yHzd27FjzvtqaounXoEVnvtLuXzm7kgFAuCGwAADkorM4aZclz61Dhw4B51RMTIyZ6UmDCB0YrRV2XfdBuwOVLev/q0e7FelUsjrTko7h0C5KrlmhdMpXTw888IBZ+6Iwg7a1BUEr/Z6tDZ7dmTRY8RzE7coPbYHRNS10/Ii2luiUs7qwnovOeqWBkLZ46FgRfR8NKr744guJjY0tcDoBwE7KWL46rwIAUEq88MILZrao9PT0XF2ZNFjR2aEqVKiQ53vomhk69a12cypNtBVm0aJFZnpdALA7WiwAAKXKjBkzzDgF7T6lMz7p1LOeYyh0elgdVzF58mTTdSq/oMLzfXV2Kh0XEWrDhg0zaQGAcEKLBQCgVHn88cfNCtg6RkOnkdUVu5OSktxTwj7zzDOmFUOnl9WuSIFU0HVsRFZWlvlZ3zPQYKS46LS8mZmZ5mftYpXXgHYAsAsCCwAAAABBoysUAAAAgKARWAAAAAAIGoEFAAAAgKARWAAAAAAIGoEFAAAAgKARWAAAAAAIGoEFAAAAgKARWAAAAAAIGoEFAAAAAAnW/wPBJDDNriMuTAAAAABJRU5ErkJggg==",
                        "text/plain": [
                            "<Figure size 800x600 with 2 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
                "    2, 1, figsize=(8, 6), sharex=True,\n",
                "    gridspec_kw={'height_ratios': [3, 1]}\n",
                ")\n",
                "\n",
                "edges = hist_cpu.axes[0].edges\n",
                "cpu_vals = hist_cpu.values()\n",
                "cuda_vals = hist_cuda.values()\n",
                "async_vals = hist_async.values()\n",
                "\n",
                "ax_spec.stairs(cpu_vals, edges, label=f'CPU  ({n_clusters_cpu} clusters)')\n",
                "ax_spec.stairs(cuda_vals, edges, label=f'CUDA ({n_clusters_cuda} clusters)', linestyle='--')\n",
                "ax_spec.stairs(async_vals, edges, label=f'CUDA_async ({n_clusters_async} clusters)', linestyle='-.')\n",
                "ax_spec.set_ylabel('Counts')\n",
                "ax_spec.set_title('Cluster energy spectrum: CPU vs CUDA')\n",
                "ax_spec.legend()\n",
                "ax_spec.grid(alpha=0.2)\n",
                "\n",
                "with np.errstate(divide='ignore', invalid='ignore'):\n",
                "    ratio = np.where(cpu_vals > 0, cuda_vals / cpu_vals, np.nan)\n",
                "\n",
                "ax_ratio.stairs(ratio, edges, color='k')\n",
                "ax_ratio.axhline(1.0, color='gray', linewidth=0.5)\n",
                "ax_ratio.set_ylabel('CUDA / CPU')\n",
                "ax_ratio.set_xlabel('Energy [ADU]')\n",
                "ax_ratio.set_ylim(0.5, 2.0)\n",
                "ax_ratio.grid(alpha=0.3)\n",
                "\n",
                "plt.tight_layout()\n",
                "plt.show()"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3 (ipykernel)",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.11.15"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 5
}