From ac96d1f688a9146699631fce163f508340bcf789 Mon Sep 17 00:00:00 2001 From: kferjaoui Date: Mon, 27 Apr 2026 14:56:40 +0200 Subject: [PATCH] Implement mixed precision: f32 stencil, f64 pedestal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Stencil arithmetic and shared memory use float (COMPUTE_TYPE alias). - Pedestal accumulation stays double to preserve variance accuracy. Notes: - On RTX 4090, FP32 throughput is ~64× higher than FP64, so moving stencil math to float improves performance. - Using float also avoids shared memory bank conflicts: stride-18 maps to distinct banks for 32-bit values, but caused conflicts with 64-bit. --- include/aare/ClusterFinderCUDA.hpp | 50 +++++++------ include/aare/clusterfinder_kernel.cuh | 61 ++++++++------- python/tests/ClusterFinderCUDA.ipynb | 104 +++++++++++++------------- 3 files changed, 112 insertions(+), 103 deletions(-) diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp index abf8616..4c0b70f 100644 --- a/include/aare/ClusterFinderCUDA.hpp +++ b/include/aare/ClusterFinderCUDA.hpp @@ -26,20 +26,22 @@ template , typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double, typename = std::enable_if_t::value>> class ClusterFinderCUDA { + using COMPUTE_TYPE = + device::COMPUTE_TYPE; // match the kernel's internal precision static constexpr int BLOCK_X = 16; static constexpr int BLOCK_Y = 16; static constexpr int col_radius = ClusterType::cluster_size_x / 2; static constexpr int row_radius = ClusterType::cluster_size_y / 2; - Shape<2> m_image_size; + Shape<2> m_shape; size_t nrows; size_t ncols; - size_t image_size; // nrows * ncols + size_t m_image_size; // nrows * ncols int n_streams; size_t m_capacity; - PEDESTAL_TYPE m_nSigma; + COMPUTE_TYPE m_nSigma; Pedestal m_pedestal; ClusterVector m_clusters; bool m_pedestal_dirty = true; @@ -56,41 +58,43 @@ class ClusterFinderCUDA { /** * @brief Construct a ClusterFinderCUDA * - * @param image_size shape of the detector frame (rows, cols) + * @param m_image_size shape of the detector frame (rows, cols) * @param nSigma threshold in units of per-pixel pedestal * std * @param capacity device-side cluster buffer size per stream * @param n_streams number of CUDA streams for multi-frame * overlap */ - ClusterFinderCUDA(Shape<2> image_size_, PEDESTAL_TYPE nSigma = 5.0, + ClusterFinderCUDA(Shape<2> shape_, COMPUTE_TYPE nSigma = 5.0, size_t capacity = 1000000, int n_streams_ = 1) - : m_image_size(image_size_), nrows(image_size_[0]), - ncols(image_size_[1]), image_size(nrows * ncols), - n_streams(n_streams_), m_capacity(capacity), m_nSigma(nSigma), - m_pedestal(image_size_[0], image_size_[1]), m_clusters(capacity) { + : m_shape(shape_), nrows(shape_[0]), ncols(shape_[1]), + m_image_size(nrows * ncols), n_streams(n_streams_), + m_capacity(capacity), m_nSigma(nSigma), + m_pedestal(shape_[0], shape_[1]), m_clusters(capacity) { // Grid/Block dimensions block = dim3(BLOCK_X, BLOCK_Y); grid = dim3((static_cast(ncols) + BLOCK_X - 1) / BLOCK_X, (static_cast(nrows) + BLOCK_Y - 1) / BLOCK_Y); // Shared memory: one tile of (BLOCK_X + 2*col_radius) x (BLOCK_Y + - // 2*row_radius) doubles + // 2*row_radius) elements + // Mixed precision used -> shmem takes COMPUTE_TYPE = floats (not + // PEDESTAL_TYPE) shmem_bytes = (BLOCK_X + 2 * col_radius) * (BLOCK_Y + 2 * row_radius) * - sizeof(PEDESTAL_TYPE); + sizeof(COMPUTE_TYPE); v_sc.resize(n_streams); for (int k = 0; k < n_streams; ++k) { auto &sc = v_sc[k]; CUDA_CHECK(cudaStreamCreate(&sc.stream)); CUDA_CHECK( - cudaMalloc(&sc.d_frame, image_size * sizeof(FRAME_TYPE))); + cudaMalloc(&sc.d_frame, m_image_size * sizeof(FRAME_TYPE))); + CUDA_CHECK(cudaMalloc(&sc.d_pd_mean, + m_image_size * sizeof(PEDESTAL_TYPE))); CUDA_CHECK( - cudaMalloc(&sc.d_pd_mean, image_size * sizeof(PEDESTAL_TYPE))); - CUDA_CHECK( - cudaMalloc(&sc.d_pd_sum, image_size * sizeof(PEDESTAL_TYPE))); - CUDA_CHECK( - cudaMalloc(&sc.d_pd_sum2, image_size * sizeof(PEDESTAL_TYPE))); + cudaMalloc(&sc.d_pd_sum, m_image_size * sizeof(PEDESTAL_TYPE))); + CUDA_CHECK(cudaMalloc(&sc.d_pd_sum2, + m_image_size * sizeof(PEDESTAL_TYPE))); CUDA_CHECK( cudaMalloc(&sc.d_clusters, capacity * sizeof(ClusterType))); CUDA_CHECK(cudaMalloc(&sc.d_cluster_count, sizeof(uint32_t))); @@ -122,8 +126,8 @@ class ClusterFinderCUDA { ClusterFinderCUDA(ClusterFinderCUDA &&) = delete; ClusterFinderCUDA &operator=(ClusterFinderCUDA &&) = delete; - void set_nSigma(PEDESTAL_TYPE nSigma) { m_nSigma = nSigma; } - PEDESTAL_TYPE get_nSigma() const { return m_nSigma; } + void set_nSigma(COMPUTE_TYPE nSigma) { m_nSigma = nSigma; } + COMPUTE_TYPE get_nSigma() const { return m_nSigma; } void push_pedestal_frame(NDView frame) { m_pedestal.push(frame); @@ -163,7 +167,7 @@ class ClusterFinderCUDA { } auto &sc = v_sc[0]; - const size_t image_bytes = image_size * sizeof(FRAME_TYPE); + const size_t image_bytes = m_image_size * sizeof(FRAME_TYPE); const uint32_t n_pd_samples = static_cast(m_pedestal.n_samples()); @@ -221,7 +225,7 @@ class ClusterFinderCUDA { } const size_t n_frames = frames.shape(0); - const size_t image_bytes = image_size * sizeof(FRAME_TYPE); + const size_t image_bytes = m_image_size * sizeof(FRAME_TYPE); const uint32_t n_pd_samples = static_cast(m_pedestal.n_samples()); @@ -246,7 +250,7 @@ class ClusterFinderCUDA { auto &sc_k = v_sc[k]; const FRAME_TYPE *h_src = - frames.data() + frame_idx * image_size; + frames.data() + frame_idx * m_image_size; CUDA_CHECK(cudaMemsetAsync(sc_k.d_cluster_count, 0, sizeof(uint32_t), sc_k.stream)); @@ -304,7 +308,7 @@ class ClusterFinderCUDA { NDArray h_sum = m_pedestal.get_sum(); NDArray h_sum2 = m_pedestal.get_sum2(); - const size_t bytes = image_size * sizeof(PEDESTAL_TYPE); + const size_t bytes = m_image_size * sizeof(PEDESTAL_TYPE); for (auto &sc : v_sc) { CUDA_CHECK(cudaMemcpyAsync(sc.d_pd_mean, h_mean.data(), bytes, cudaMemcpyHostToDevice, sc.stream)); diff --git a/include/aare/clusterfinder_kernel.cuh b/include/aare/clusterfinder_kernel.cuh index f6002db..0879630 100644 --- a/include/aare/clusterfinder_kernel.cuh +++ b/include/aare/clusterfinder_kernel.cuh @@ -6,6 +6,9 @@ namespace aare::device { +// Implementing mixed precision for shared memory and stencil arithmetic +using COMPUTE_TYPE = float; + template , typename FRAME_TYPE = uint16_t, typename PEDESTAL_TYPE = double, typename = std::enable_if_t::value>> @@ -13,7 +16,7 @@ __global__ void find_clusters_in_single_frame( const FRAME_TYPE *__restrict__ d_frame, PEDESTAL_TYPE *__restrict__ d_pd_mean, PEDESTAL_TYPE *__restrict__ d_pd_sum, PEDESTAL_TYPE *__restrict__ d_pd_sum2, const uint32_t n_pd_samples, - const PEDESTAL_TYPE m_nSigma, const size_t nrows, const size_t ncols, + const COMPUTE_TYPE m_nSigma, const size_t nrows, const size_t ncols, // const uint64_t frame_number, ClusterType *d_clusters, uint32_t *d_cluster_count, const uint32_t max_clusters) { @@ -50,8 +53,8 @@ __global__ void find_clusters_in_single_frame( // CUDA prefers raw bytes + aligned cast // Compile error happens when using: `extern __shared__ T sh[];` - extern __shared__ __align__(sizeof(PEDESTAL_TYPE)) unsigned char smem[]; - PEDESTAL_TYPE *shmem = reinterpret_cast(smem); + extern __shared__ __align__(sizeof(COMPUTE_TYPE)) unsigned char smem[]; + COMPUTE_TYPE *shmem = reinterpret_cast(smem); // Stride includes halo on both sides auto shmem_stride = static_cast(blockDim.x) + 2 * col_radius; @@ -67,7 +70,7 @@ __global__ void find_clusters_in_single_frame( // Cooperative zero-fill for (int idx = static_cast(local_tid); idx < tile_size; idx += static_cast(blockDim.x * blockDim.y)) { - shmem[idx] = PEDESTAL_TYPE{0}; + shmem[idx] = COMPUTE_TYPE{0}; } __syncthreads(); @@ -76,15 +79,16 @@ __global__ void find_clusters_in_single_frame( row_global < static_cast(nrows); // ====================================================== - // Load pedestal-subtracted frame data into shared memory + // Load pedestal-subtracted frame data into shared memory (MIXED PRECISION) // ====================================================== // Helper: read (frame - pedestal_mean) from global memory, or 0 if OOB. // gr, gc are the global row/col of the pixel to load. // Returns the pedestal-subtracted value. - auto load_pixel = [&] __device__(ssize_t gr, ssize_t gc) -> PEDESTAL_TYPE { - auto gid = gc + static_cast(ncols) * gr; - return static_cast(d_frame[gid]) - d_pd_mean[gid]; + auto load_pixel = [&] __device__(ssize_t gr, ssize_t gc) -> COMPUTE_TYPE { + auto gid = gc + ncols * gr; + return static_cast(d_frame[gid]) - + static_cast(d_pd_mean[gid]); }; // A. Interior: every valid thread loads its own pixel @@ -174,10 +178,10 @@ __global__ void find_clusters_in_single_frame( PEDESTAL_TYPE var_px = d_pd_sum2[global_tid] / n_pd_samples - mean_px * mean_px; PEDESTAL_TYPE rms_sq = max(var_px, PEDESTAL_TYPE{0}); // variance = rms^2 - PEDESTAL_TYPE rms_px = sqrt(rms_sq); + COMPUTE_TYPE rms_px = sqrtf(static_cast(rms_sq)); // Pedestal-subtracted value of the center pixel (already in shmem) - PEDESTAL_TYPE val_pixel = shmem[shmem_tid]; + COMPUTE_TYPE val_pixel = shmem[shmem_tid]; // Negative pedestal early exit if (val_pixel < -m_nSigma * rms_px) @@ -185,15 +189,15 @@ __global__ void find_clusters_in_single_frame( // sequential) // Stencil reduction: total, max, quadrant sums - PEDESTAL_TYPE total = PEDESTAL_TYPE{0}; - PEDESTAL_TYPE max_val = -HUGE_VAL; // CUDA-compatible equivalent of - // `numeric_limits::lowest()` + COMPUTE_TYPE total = 0.0f; + COMPUTE_TYPE max_val = -HUGE_VALF; - /* PEDESTAL_TYPE tl = PEDESTAL_TYPE{0}; // top-left quadrant (ir<=0, - ic<=0) PEDESTAL_TYPE tr = PEDESTAL_TYPE{0}; // top-right quadrant (ir<=0, - ic>=0) PEDESTAL_TYPE bl = PEDESTAL_TYPE{0}; // bottom-left (ir>=0, - ic<=0) PEDESTAL_TYPE br = PEDESTAL_TYPE{0}; // bottom-right (ir>=0, - ic>=0) */ + // // Quandrants + // PEDESTAL_TYPE tl = PEDESTAL_TYPE{0}; // top-left quadrant (ir<=0, + // ic<=0) PEDESTAL_TYPE tr = PEDESTAL_TYPE{0}; // top-right quadrant + // (ir<=0, ic>=0) PEDESTAL_TYPE bl = PEDESTAL_TYPE{0}; // bottom-left + // (ir>=0, ic<=0) PEDESTAL_TYPE br = PEDESTAL_TYPE{0}; // bottom-right + // (ir>=0, ic>=0) CT clusterData[CSX * CSY]; int idx = 0; // tracks the pixels in the cluster @@ -202,21 +206,20 @@ __global__ void find_clusters_in_single_frame( for (int ir = -row_radius; ir <= row_radius; ++ir) { #pragma unroll for (int ic = -col_radius; ic <= col_radius; ++ic) { - PEDESTAL_TYPE val = shmem[shmem_tid + ir * shmem_stride + ic]; + COMPUTE_TYPE val = shmem[shmem_tid + ir * shmem_stride + ic]; total += val; - max_val = max(max_val, val); + max_val = fmaxf(max_val, val); - /* // Quadrant accumulation (pixels on the axes contribute to two - quadrants) if (ir <= 0 && ic <= 0) tl += val; if (ir <= 0 && ic >= - 0) tr += val; if (ir >= 0 && ic <= 0) bl += val; if (ir >= 0 && ic - >= 0) br += val; */ + // // Quadrant accumulation (pixels on the axes contribute to two + // quadrants) if (ir <= 0 && ic <= 0) tl += val; if (ir <= 0 && ic + // >= 0) tr += val; if (ir >= 0 && ic <= 0) bl += val; if (ir >= 0 + // && ic >= 0) br += val; // Store pedestal-subtracted value in register array for later // cluster output - if constexpr (std::is_integral_v && - std::is_floating_point_v) - clusterData[idx] = static_cast(lround(val)); + if constexpr (std::is_integral_v) + clusterData[idx] = static_cast(lroundf(val)); else clusterData[idx] = static_cast(val); @@ -260,7 +263,9 @@ __global__ void find_clusters_in_single_frame( // Test 3: total significance (only if tests 1 & 2 didn't fire) if (!is_photon) { - if (total > 0 && total * total > pow2_c3 * nSig_sq_rms_sq) { + if (total > 0 && static_cast(total) * + static_cast(total) > + pow2_c3 * nSig_sq_rms_sq) { is_photon = true; } } diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb index 9987110..5a42e7d 100644 --- a/python/tests/ClusterFinderCUDA.ipynb +++ b/python/tests/ClusterFinderCUDA.ipynb @@ -110,7 +110,7 @@ "metadata": {}, "outputs": [], "source": [ - "N_STREAMS = 1 \n", + "N_STREAMS = 10\n", "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, capacity=capacity, n_streams=N_STREAMS)" ] }, @@ -124,7 +124,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pedestal (1000 frames): 0.498s\n" + "Pedestal (1000 frames): 0.480s\n" ] } ], @@ -155,7 +155,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Reading 40000 frames: 2.002s (19985 FPS, 6098.804 GB/s)\n" + "Reading 40000 frames: 1.922s (20815 FPS, 6352.256 GB/s)\n" ] } ], @@ -186,7 +186,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU clustering: 73.978s (541 FPS, 55449596 clusters, 1386.24/frame)\n" + "CPU clustering: 73.207s (546 FPS, 55449596 clusters, 1386.24/frame)\n" ] } ], @@ -230,32 +230,23 @@ "execution_count": 10, "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CUDA clustering: 3.880s (10310 FPS, 55810704 clusters, 1395.27/frame)\n", - "Speedup (CPU / CUDA): 19.07×\n" - ] - } - ], + "outputs": [], "source": [ - "# Warmup: first kernel launch pays CUDA context + pedestal H2D upload cost\n", - "cf_cuda.find_clusters(data[0])\n", - "_ = cf_cuda.steal_clusters(realloc_same_capacity=False)\n", + "# # Warmup: first kernel launch pays CUDA context + pedestal H2D upload cost\n", + "# cf_cuda.find_clusters(data[0])\n", + "# _ = cf_cuda.steal_clusters(realloc_same_capacity=False)\n", "\n", - "t0 = time.perf_counter()\n", - "for frame in data:\n", - " cf_cuda.find_clusters(frame)\n", - "t_cuda = time.perf_counter() - t0\n", - "clusters_cuda = cf_cuda.steal_clusters(realloc_same_capacity=False)\n", - "n_clusters_cuda = clusters_cuda.size\n", - "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'Speedup (CPU / CUDA): {t_cpu / t_cuda:.2f}×')\n", + "# t0 = time.perf_counter()\n", + "# for frame in data:\n", + "# cf_cuda.find_clusters(frame)\n", + "# t_cuda = time.perf_counter() - t0\n", + "# clusters_cuda = cf_cuda.steal_clusters(realloc_same_capacity=False)\n", + "# n_clusters_cuda = clusters_cuda.size\n", + "# 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'Speedup (CPU / CUDA): {t_cpu / t_cuda:.2f}×')\n", "\n", - "hist_cuda = make_hist(clusters_cuda)" + "# hist_cuda = make_hist(clusters_cuda)" ] }, { @@ -263,27 +254,36 @@ "execution_count": 11, "id": "1fda99ee-db54-40c1-8e5b-51168a33fb96", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA clustering: 2.385s (16774 FPS, 55081141 clusters, 1377.03/frame)\n", + "Speedup (CPU / CUDA): 30.70×\n" + ] + } + ], "source": [ - "# BATCH_SIZE = 500\n", + "BATCH_SIZE = 2000\n", "\n", - "# # warmup\n", - "# _ = cf_cuda.find_clusters_batched(data[:1], first_frame=0)\n", + "# warmup\n", + "_ = cf_cuda.find_clusters_batched(data[0:BATCH_SIZE], first_frame=0)\n", "\n", - "# t0 = time.perf_counter()\n", - "# clusters_cuda_per_frame = []\n", - "# for start in range(0, N, BATCH_SIZE):\n", - "# stop = min(start + BATCH_SIZE, N)\n", - "# clusters_cuda_per_frame.extend(\n", - "# cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)\n", - "# )\n", - "# t_cuda = time.perf_counter() - t0\n", + "t0 = time.perf_counter()\n", + "clusters_cuda_per_frame = []\n", + "for start in range(0, N, BATCH_SIZE):\n", + " stop = min(start + BATCH_SIZE, N)\n", + " clusters_cuda_per_frame.extend(\n", + " cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)\n", + " )\n", + "t_cuda = time.perf_counter() - t0\n", "\n", - "# n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n", + "n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n", "\n", - "# 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'Speedup (CPU / CUDA): {t_cpu / t_cuda:.2f}×')" + "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'Speedup (CPU / CUDA): {t_cpu / t_cuda:.2f}×')" ] }, { @@ -293,14 +293,14 @@ "metadata": {}, "outputs": [], "source": [ - "# def make_hist_from_batch(result_list):\n", - "# h = bh.Histogram(bh.axis.Regular(100, -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\n", + "def make_hist_from_batch(result_list):\n", + " h = bh.Histogram(bh.axis.Regular(100, -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\n", "\n", - "# hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)" + "hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)" ] }, { @@ -323,7 +323,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cluster count diff: 361108 (0.65%)\n" + "Cluster count diff: 368455 (0.66%)\n" ] } ], @@ -350,7 +350,7 @@ { "data": { "image/png": - "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", + "iVBORw0KGgoAAAANSUhEUgAAA3kAAAJOCAYAAAAK+M50AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnI9JREFUeJzt3Qd4VFX6x/FfegHSIAESqiKIFLGuHSsqNuzu2ntXLOvaFXV114r+FXvDhhUrNlYFXXVVEEFUBAXpJqGkQHrm/7wnTswkkxBCJtO+n+e5XObeOzNnztyZ3HfeU2I8Ho9HAAAAAICIEBvsAgAAAAAA2g9BHgAAAABEEII8AAAAAIggBHkAAAAAEEEI8gAAAAAgghDkAQAAAEAEIcgDAAAAgAhCkAcAAAAAEYQgDwAAAAAiCEEegIgye/ZsnXrqqerfv7+Sk5PVuXNnbbvttrr99tu1evXq+uP23HNPtwTKhAkT9NRTTwXs8RE+IvFc+PTTT3XMMccoLy9PiYmJSk9P1y677KIHH3xQ69atqz+uX79+iomJqV/s8/iXv/xFEydO9Hk8O+7ggw/2+1zffPONu2+o1GFrv2M29jXdeOONPnWVmpqqXr16af/999f//d//qaSkpNkyVVVVqUePHu5+r7zySju/YgDhiCAPQMR49NFHtd122+nrr7/W3//+d7333nuaPHmyjj76aD300EM6/fTTO6wskXhhj7aJtHPhhhtu0B577KFly5bp5ptv1ocffqhJkyZpn332cYHKtdde63P8rrvuqi+++MItVg8WiJx88skuIAw3HfEdY49pdWXrO++8U3369NEVV1yhIUOG6LvvvvN7n7ffflu///67+//jjz++yWUAEP7ig10AAGgPdlF07rnnar/99tPrr7+upKSk+n227bLLLnMXTeHM4/GovLxcKSkpCgdlZWVhU9ZQYRkZC4Li40Pzz/PLL7+sm266yQUzFvBYWb0OPPBAF4zYZ7GhjIwM7bTTTvW39913X/Xt21d33323+8yGi476jrEgslu3bvW3jzvuOF1wwQUaOXKkDj30UP38888+z+0N7Cyjasd88MEHWrp0qcsCAoheZPIARIRbb73VXXA+8sgjTS6AjF0A2QVScz755BN3f1s3tGjRoibNqn799Vd34ZWbm+ueq3v37i6LMWvWrPpmWnPnztW0adPqm17ZNq/i4mJdfvnlrrmXlcuavI0dO9anmZux+9nFnWUIBg8e7J7r6aefbrEeXnzxRe28887q1KmTa0ZmTb2+/fZbn2NOOeUUt2/BggUaPXq0+3/v3r3dRWpFRYXPsZWVlbrlllu05ZZbuufPzs52TdUKCgp8jvM2TXvttde0zTbbuGZs48aNc/usLkaNGuWan9n9zz//fL3zzjs+9W0ZIQtslixZ0uQ1nXbaaeratasLcJuzofekYRkt8zJ8+HBXxs0220z33Xdfk8dr7XtUW1vrmtKNGDHCBbTegObNN9/c4LngPeeeeeYZV/f2HFZ2e1+8Tfca82bC7Lxs/Losm2N1b+Ww88Vue+9jt+2c2HHHHV1TwbayAC8zM9PVmb/ydenSxb3XLbE6GjRokH777Te1F8twWXn8ZbHeffddt8/7nti5e9ZZZ7lz3ntOW7Zx6tSpAf2O2RRbb721rrnmGi1evNh9xhtavny5Cy4POeQQl120czKSMscA2iY0fyoEgI1QU1Ojjz76yP0CbhdugWaBkT2n9cGxplSFhYX6/PPPtXbtWrffgoijjjrK9VOypnrGe1G4fv1692u7/dJ+9dVXu2DDgoDrr79ec+bMcReaDS+eLWNg/Z9sv/W5ycnJafEi1JrKWRBmawvQ7rjjDu2+++766quvtNVWW/lkjOyC1DIyFmBMnz7dBVpWZnsuYxeLhx12mHt+y9BYnyu7MLfmetaf0YKFhpm6mTNn6scff3TPbcGRBRUrVqxwr9f+b83zrPwvvPCCC14bOvvss/XPf/5TDz/8sAsqvayPkzUFtOMtKGvre+JlQZ8FaxZEWX0+99xzuvjii11dWVC3se+RBczPPvusq0cLgOxC3+rBG4S1dC54XXXVVS4wt2A+Nja2xfe4pSDHHscCAXsuC7CPOOIIt+0///lPfYDyj3/8wwWECxcurH/vrKz2flkTypaCA3svv//+ex177LEuYG8rO/fsPLLgqj2DIAtwn3zyySZNJu01WZ3aOWJOPPFE9x7Z+TZw4EB3jtjtVatWhcx3jD/2ebXPoX1WTzrpJJ/XZ+WzH0O8WdInnnjCnQv+AnEAUcIDAGFu5cqVHvs6O+6441p9n5EjR7rF6+OPP3aPYeuGFi5c6LY/+eST7nZhYaG7PX78+BYff8iQIT6P73Xbbbd5YmNjPV9//bXP9ldeecU97pQpU+q32e309HTP6tWrN/h6Fi9e7ImPj/dceOGFPttLSko8PXr08BxzzDH1204++WT32C+99JLPsaNHj/YMGjSo/vYLL7zgjnv11Vd9jrOy2/YJEybUb+vbt68nLi7OM2/ePJ9j//73v3tiYmI8c+fO9dm+//77N6lvK1dOTo6noqKiftu///1vV1/2PjSnte+JldHKMmvWLJ/t++23nyctLc2zbt26jXqPpk+f7m5fc801bToXvOfcHnvs0WTfDTfc4PY1ZuehbW9YH/a6UlJSPEuXLq3fZq/RjuvZs2f96zKvv/662/7mm2/Wb1u0aJF770477bQWX8eXX37p7nvllVd6WsvKZudVVVWVW6zc3vPPzo2Gxx100EF+H8N7vnk/g82577773HENz0H77CQlJXkuu+yy+m2dO3f2jB071hPo75iNfU3e97ygoMDvfcrKytz+Aw88sH5bbW2tZ8CAAZ68vDxPdXW1z+P85z//2YhXCCDSRHVzTfs1zJo3WPMe+7XLfjHfWHYdZh2j7ddA+3XWfuGzX0wBRKasrCxtvvnmLkNmfYqsKaRlvFrLmtANHTrUNe+rrq6uX6xZpb/monvvvbdrHrch77//vnsc+4W/4eNa9suyUo0f157Lvv8asoxVwyZ0VlZrWmfHNXxMK7tlwRo/pt3fvgsbsmaK9nobZhHNX//61yavwTJq+fn5rt+XsXq17N9BBx3k09x1U94TG7zCsj4N/e1vf3PNMy2bszHvkTUDNNb8dFMceeSR2lRWVmvu6WXNM41lXBtm3bzbG77Plvmx1xeoATumTJmihIQEt1jG8KWXXtKFF17ok7FtD8cff7z7O9wwG2lZY2uCbNltL2uyasfY83/55ZcusxgO6n73UZPPlzXvtSxsXFyc22av1c5Ty+YBiF5RHeRZ3wr7Y3///fe3+THsouSxxx5zgd5PP/2kt956y/0BAdBxbJACu5C1JmiBZhdP1vzNLvitaaANnW7Nzi666KIWhzj3shHwbAh270Wvd7G+THYRZ80MG+rZs2eryuUdWW+HHXZo8tjWh6fx41p9NW7+aBfIDfu92WNaUzZrgtj4MVeuXNmqsloTOOsf15i/bdbczpqWPvDAA/XBljUlbNy0c1PeEwtOG/Nu8zbXa+17ZH277MLa32NujNa+xy2xQLche89a2t5S/8bmWDNYs7Gfs912282NRmnNe3/44Qd3TlmfPm9ZjPXHtCaH/lgAauw9aIm9VmvSaNMzeB/Lgjn7m2zBvZd9Hiwosr/d1kzW7mc/jtg53Z7fMe3xmhryBub2w7SXNzA//PDDXb3aYs11rc5fffXVJs2VAUSPqO6TZyOB2dIc66NhfUusz4Z9Udovu//+97/r59ayvif2K7P1UbBO5ACCwy60bZANy6y0dVQ5b8DTeOCRxoGMN/Phvbiyke4sM2F9vOw7w/pVtcQuFq0vVHO/sjccVc+0tk+N9342R5aVrz3YY9qAJ82NGGhBz4bKavf3BqANNXdBbYGZDUdvWTX7Ac4ygzZy4Ya09j3x97zebVbWjXmPLJC0i3i7/6YEav7qreH52LAPn7/zsaPYaxw2bJgbvdH6Lba2X54FHdtvv32Lx1jQb1My+OPd7u+HgcYsi2WZYJvWwYJSCy4bT9Vg79/48ePdYgOZ2IAsV155pcsiN3eut+U7pr1ek5d34BjvNUhRUZEL5Lw/7vjz/PPP67zzzmv1cwCIHFGdyWvNH4v//ve/rtO//aprFx4HHHCA5s+f7/Zb1s5GZrNfm60JijUnOuOMM3wmQwXQMWyACcuynHnmme7CvjFrkmWf2eZ4mwPaZ93fhVVzLAixH4Ps4tfb3M/YhblNIdCYDXrxyy+/uIDCLnwbLy01S2yJZbEsc2CP7e9xN3SR7Y+V1bJbFsj4e7zW/LhlTUXthzDL4DRk36v+WEbCLs5tMBgb4MQuUDd28Ijm3hNjA6g0nmvMLoQtYLUM4Ma8R94fCTc031tz50JLmjsfWzqHO8J1112nNWvWuGDcX/PB0tJSFwRuLBswxN95Yixg906iviE2sqc1W7UBWGyxYNlf02AvO9csU2w/JDQ+Vzb1O6a9XpOxc9a6gth5YZPQe89bO69swKSPP/64yWLBLE02gegV1Zm8ltgfeGvLb7/YeZtG2Mhr9iuf/eGwL1sbstuaT9ivht7mIZdccokbSc1G4QLQcazZlV1sW1BgI+DZfFbWRMsuvKyPlg17btn4xv3QvKzJnV2U3Xbbba4PnGWGrAmgTQnQkF1020Wh/eizxRZbuCZn9nm37ZYN8LIAwwIZaxpmPwbZxaZts5Ed7dd3m0zavi+sH5v1H7OMgl0cW3DT2gu/huziz0Z3tBH17LvJfpCy12FZNBtZ00a39E5p0Fo2JYG1ZLBRCa1pujV7s+Zl9r1oF5E28qYFZS2x12sXmhYQWfksc2EXp9a83dhoko0zJtbHzUaBtDLb6JUb0tr3xNj3uTXpsyyfZaZsZEzL+lgrDW9mqrXvkTUttZEarW+X1bMFhxbQ2flmj2X9zlo6F1pidW7NCL2jdloAb00P/U0xsans75j1abQmjBvql2d1bIGeBRb2Hlr57L6W2fvf//7nRke10Tc3NI1CY3Z+2d9Ry1LZiKZWPxZMWp1Zdtr6WjbOHPtj5481vbTj09LS3Aijlkn0suzXXnvt5fph2rQg9piW7bO/7XZse37HtPU1zZgxw5XZHtemR7DvIZtmw0YItSDS28zV3iv7jNu1ib+RZ731YAFi436oAKJAsEd+CRVWFZMnT66/baPO2bZOnTr5LDZ6nXeUujPPPLPJSF4zZsxw23766aegvA4g2tmogjZ6X58+fTyJiYnuc7vNNtt4rr/+ek9+fn6zo2uaFStWeI466ihPVlaWG9XyhBNO8HzzzTc+o+D9/vvvnlNOOcWz5ZZbuse2kfqGDx/uueeee+pHt/OOWDhq1ChPly5d3P1tpD2v0tJSz7XXXutGsrQy2nMNGzbMc8kll7hR/Lzsfueff/5GvX4bPXGvvfZyo0XaqIL2vPaapk6dWn+M1Y+VvTUjOtqIiHfeeadn66239iQnJ7vXa6/97LPP9syfP79VIwl+//33nn333dfd3+r29NNP9zz99NPuub777rsmx1vd2b5zzjmnVa+5te+Jt4w2SqaNeGl1369fP8/dd9/d5DFb+x7V1NS45xk6dGj9cTvvvLPnrbfe2uC54B1d8+WXX/b7ur766ivPLrvs4l6TjZ5o789jjz3md3RNf3Xv7/zxjhZ7xx13NNlm50VrTZs2zZ1XNnpnQkKCO9/sddvjFhcXb7Bs/li9nnvuue6za39rrb522223ZuunOT///LN7PbZ8+OGHPvvKy8vdeWXnh5XZRiW199jqtuEopO3xHbOxr8n7+fMu9vm1+rVz59577/WpV/vc2DEtjRJq1yF2TOMRdwFEhxj7J9iBZiiw5kA2n9GYMWPcbfulzUbqsqY93hGrvKyJhf3qb3NFWUav4chc1nTCfsG1X3tb048EAKKRTUZtrSWsOWjDATiMTS5uzQGtqVvDATM2lWU7LdPinSQcAIBIRXPNZtgob9b80jpiW5Mcf3bddVc3QpY17bTmKt4O/6a9Bj4AgHBnzQ2tmaQ1VbQ+WxZk2ciG1m+uYYBnTd5s9EI73pqCtmeABwBANInqIM8uNmx+GS+7uJg1a5brB2Ed9y2TZ23a77rrLhf02ahm1s/D2tVbfwnrv2Md9U877TQ3Spf12bC+JJbBazxXFABEK+vHZ3PYWV8++2HM+s1ZXyHrs9SQ9e+zkSrth7UNjVIKAACaF9XNNW1CW+uA3Zh1PrcO7tYM0zrUW8dpG+7YRlqzjtc2eIG307x1irbO9dY80wYJsMEFLChsPDcRAAAAAHSEqA7yAAAAACDSME8eAAAAAEQQgjwAAAAAiCBRN/CKDY5i/ehsAlKbNgEAAAAAwoH1tCspKXGjVsfGNp+vi7ogzwK83r17B7sYAAAAANAmS5YsUa9evZrdH3VBnmXwvBWTlpamUMowFhQUKDs7u8WoHNR5OOM8p86jAec5dR4NOM+p82hQG4LX58XFxS5h5Y1pmhN1QZ63iaYFeKEW5JWXl7syhcpJFOmoc+o8GnCeU+fRgPOcOo8GnOfUeUMb6nZGNAEAAAAAEYQgDwAAAAAiCEEeAAAAAESQqOuTBwAAEO1qampUVVW1Sf3D7P42ngBjCXQM6jw66jwhIUFxcXGb/DgEeQAAAFE0x9bKlSu1du3aTX4cuwC2+bqYd7hjUOfRU+cZGRnq0aPHJj0nQR4AAECU8AZ4OTk5Sk1NbfNFpF38VldXKz4+niCvg1DnkV/nHo9H69evV35+vrvds2fPNj8WQR4AAECUNNH0Bnhdu3bdpMci4Oh41Hl01HlKSopbW6Bnn9W2Nt1k4BUAAIAo4O2DZxk8AKHL+xndlH6zBHkAAABRhD50QOR/RgnyAAAAACCCEOQBAAAAbbTHHnvo+eefp/4ClNF6/fXXw65u3377bW2zzTZuZM5gIcgDAABAWIwMeuGFF2qzzTZTUlKSevfurUMOOUT/+c9/6o/p16+fCwxssX5NQ4cO1cMPP1y//8Ybb9SIESOaPLYNSGP3+eSTTzb6Yt7Kddxxx9Vv23PPPevL4F0a7m9cTu9y5ZVX+n2OVatWqVevXm6etuamvliwYIG6dOniht5v7IEHHtDgwYPdgB6DBg3SxIkTffY/9dRTTcpii80N52VTCIwdO1Z9+/Z1j7PLLrvo66+/bvJcP/74ow499FClp6e78uy0005avHixQsEnn3ziXtemTh/SGgcffLB7rmAG/4yuCQAAgJC2aNEi7brrri6Iuf322zV8+HA3KMX777+v888/Xz/99FP9sTfddJPOPPNMlZaWugDmnHPOcfc79thj271c9913n0499dQmE2Xb81s5Go+Y2JC3nF6dO3f2+xynn366e73Lli3zu9/q4a9//at23313ff755z77HnzwQV111VV69NFHtcMOO+irr75yz5mZmekCZK+0tDTNmzfP577Jycn1/z/jjDP0/fff65lnnlFubq6effZZ7bvvvvrhhx+Ul5fnjvnll1+02267ufKOGzfOBXoW9DV8nEgZcbOmpsaNuNkSOy/+7//+TyeccEKHla0hMnkAAAAIaeedd57LjFiQctRRR2ngwIEaMmSILr30Un355Zc+x1oGySaSHjBggG655RZtscUWAWnyV1hYqKlTp7rMVWOWRbQyeBcLeBrzltO7+AvyLEizzNPll1/ebDmuvfZabbnlljrmmGOa7LOg7Oyzz3YBrmVALaNoQdi///1vn+OsbhuWxRavsrIyvfrqqy64tqapVq+WEe3fv78rn9c111yj0aNHu+OsqaI930EHHeSmAWjJE0884d5Ly87avHAXXHBBqzNxs2bNctvsRwDz22+/ueA1MzNTnTp1co87ZcoUt3+vvfZyx9g+u88pp5xSH7RZma28FoxvvfXWeuWVV+qfY9q0aS6Itx8Utt9+e1fOTz/9VN999517THsfLUjebrvt9M0339Tfz84LO19//fVXBQNBHgAgOq1dIi2fVbfY/03l+qbbAATV6tWr9d5777mMnV24N+aviWJDlknalKHom/PZZ5+5YM6aQjb23HPPqVu3bi7IsADNmjs2ZoGWzVdozUf/+c9/qrKy0me/Zcks22fNKxtnCr0++ugjvfzyy65Jpj8VFRVNMmkWyFjw0bBOLOtpTTGtWag1Nfz222/r99k8cZa58vc4VgfG+p698847Lvjef//9XWD3l7/8ZYPBtQWJ9r6eddZZmjNnjt58800XRLaVPZa95unTp7vHszq24Nma9lqgaixjuWLFCt177731QfKTTz7pyjJ37lxdcsklLvtmwV1DV1xxhW677TaXnbTM6vHHH+/qy5qtzpgxwzW3TUhIqD/e6tPqwQLCYKC5JgAg+lgA98COUtX6uts7nCEddJdU+LP0yMi6bQmp0nHPS5vX/fqr/J+k6j/6qKR2lTJ6B6nwQPsqq6zRLwWlbWqyZhM1t3W4982zOyslccMTPVt/M3s+y1ZtDAtOrFmhXeyfe+65am+WHerevXuTAMwu/i3LZdkwa+JozSUt6/Phhx/WH3PxxRdr2223dVklC7jsmIULF+qxxx5z+y1QsSaYd9xxh/r06eM3G2R99SwbZa/RMkn+WMBljzlmzBj3fBaMWObMAjzLRFrmzOrVmrUOGzZMxcXFLvixprFWZsuCWqZq55131s033+wCWnvNL7zwgv73v/+5/d6Juy1Q/Ne//uWypxZcWWB+xBFH6OOPP9bIkX98rzZix1522WWuPrysWWlbWf+/I4880r0WY9k5r6ysLLe2wMv7w8C6det09913u2DZXqP3Pha8Wl9Oy1x6WcC93377+TzX3//+9/rz0lsXDVlTVm+WMaqCPIuYbfG+ePu14/rrr9eBBx7Y7H0sqrbUvEXa1ibYompraw0AQKutX1UX4B3xqNRtYF3QZuz/Z02T1heqdtIJ8kw6QT+e8oPbNeDlE5S8dr77f218imIv+JpADxHBAryD/68uI9OR3r5wNw3Na9qMsTEL8Exrg8l//OMfLjtjgVJiYqK7ELcmi+3NmjH662/WsJ+dDfxiF//WzG/mzJku0DKWLfKyrJAFe9YM1Zvds6DPAqqW+nPZ8/ztb3/zCUQau+6669zAMDYAitWjBWgWGFrzRAvQje2zxcsCPCun9SezPofeZp+nnXaaC1rsfrbfnttek/GOInnYYYfVvzbLUFofwYceeshvkGeB4fLly7XPPvuovVx00UUuoP/ggw9cn0EL+Kx+m2PZUhtgpmHwZiyrak1OG7L3sCGLR6yvotWNPdfRRx+tzTffvEm2c/36P35MjKYgz1KcFvF707JPP/20OzksRWwBX2P2C4e19bWT2n61+O9//+vaaGdnZ7s3EQCAVumULe10vtR3Vym9btAAJzFVyh2hZWvLdGLFnUquLtIPf1z8Dog5U0mq0oCYZbpXE5Sfv1w5ZPMQASyjZgFXMDJ5rWFBkj2HNZOzjNSGWFBngYw1pbRMVcPyWcarqKioyX28/bz89Z1rjjXHXLNmzQaPs4DImvHNnz+/PshrzBtkWdbSgjzLLFkG0ts3zBvo2uu5+uqrXVbJjrHmjXfeeWf9MRZs2YAgjzzyiAvKLMiwzJ1lpX7//Xd3f9tn2Tkrvz+WmbRsmpXXy4IXS7RY5suyffY41s/PMpbeurDn3WqrrXweywJVb5POxvwNRtMSb8bUWxemcTNcC7ose/nOO++4QM+aV951111uVFZ/vMGpHe8dQMbL+t411LipsPVLtEDX7vvuu+/qhhtu0KRJk3T44Yf7NDW2OCXqgryGo/oYa49smT3rQOsvyLNfAixlPX78+PoTxzo42slNkAcAaDUL7A64tdnda9ZV6teqTI0/di8NyPG9EP1t2XKd8XqKLo3vqZaHEwDCgzWZbE1GrSG70LbmkHZh39Ygr7WsmZ1duFu/M8vUNL7YtgCtYb88Czia69dlTeuWLl3qslsNBxexflUWRGxMfzDL9NjjWKBnmbjmWOszC0YsMGqOtw+c9xjrP2aZwobls6DNmj5avzfzxRdfuEDb64033nCZQMueNQ5YLMi05IqxQMT63TXXz8/eWxvQxNvksSGre1vsNdtAJJYRNJYxtcCw8QidP//8s+ub5o8FmjaVhE2B4R0UpSXeYMn603nr28rZmPW/O+ecc9ziHVnUgjwro2lYZxaUWjBnTS/9ZRsbBpT+2Hthi2UvrXmt9e3zBnmWIbQRRxtnBKOuT55VuHUctV8IvG1iG7OTedSoUT7b7EP/+OOPuw9Pw86OXpaqt8XLfn3wRu7BnKCwMSuL9xcYUOeRivOcOg8ZFaUq/HWWClI3V631vWvkl/x1ipVHm2enaqueXXz2eTw99FHttro4sYvf72zO845HnW9cPXmXTeV9jPZ4rA2xAM+aEe64445ueH5rgmdBpvVzsySANbtrWK7mymTN8ixJYKNMWn8w6/oze/ZsNziKNem0QTpa+3qsOaIFHpapsqDJ2EW9DbpiLc8s2LRy2WPbhb7NLWePbdezltCwwMYyhxbAWdM/G43RAhQ7pmFfMlNQUODWNs+dPae/PoreQNWbKLFjLMiyPn82CIoFZvfcc4/rJ2h98Lyv0+rTMomWMbXrZGuiacHT/fffX3+MBXT2f3t+yzZadyn7v2VMvcfY67R6takc7LVZn7y33nrLBabN1allv6x5pb0m665lA9RYS72GmTfv+2nZRKsfy6BZ/0DLNFqWruExNpefPc7AgQPd67Vsp73fts8SRfaDhJXJ3h/LJNr7bX0CLUizWMSmgLA6sEDZ9p188sk+57n3/xaAW8bYmthaNtN+OLD6tz6I3mPsfbYA0ttUdmN4n8tfvNLaWCHoQZ6loi2os2jXKnPy5MlNUr1e9muJtSVuyG7bh9zbebQxS9PayduYfVgaTvIYbPaGWfMBe0Ob+2UF1Hm44zynzkPF2mXzlDHtet1fdaIWy/fviteIbrGKLS9Wfv6fPxSaivzluqzrl6rIz1V+fG6T+3GedzzqvHXsB3GrK7tusmVTeJtrmkBn8oxd3NtAH9bNx4IJy+ZYYGDBk/Uda/h6vK+xOda8zvqqWX836xdmF/82p5k97sbWiwUB1oXogAMOcLftGs4yUxYo2UAkVm4LOqyPYMPs54svvuiaXFoiwp7fsnQtPb+3rm1t76O/Ovde/Dd8DHt8C4Qs2LNkiGWrrNmlZfW8x1kwZAGuXWdb0GnBqwVH1rTUe4w1O7Q6s2DGMquWrbLyWzm8x1gLPQvGLbtnA6lYoGWv04Kc5l6XDVJjfdZssBcLmiwwtkCp4fH2mu22PZf1f7MpFqyM1kfOAj7LoHnPaVts/9KlS13TXEsOWYs/224xg439Ydk9q297/y1RZIGmPa/FDNY1zLLCdl5Z307vZ8Zbr95y2XtpsYe9/9YM1u5vTYmtjrzH2EToVjbLIG7seWXH2/Pa4DqNk1j+Rmr1J8bTET+/tMA6NlqK1FLtlpq2EYDs5PMX6NnJYh9Ce3O8LNq3qNs+7A3T7i1l8uwDZyd0cyMRBYO9kRZ42hcWQR51Hqk4z6nzUPHL7P9q89cP1Sd7vKjsgf5HcsvslKjc9JRm7/vLmDe1+fBdm+znPO941Hnr2I/bNtidZR7aY4Lq5lpRRRO7wLfBVaz7UHPNEtsTdd7xqtpwnts1vWUQLbvn7be4sZ9VCzitOWvjz6rFMtZc1ZJDLcUyQc/kWXTrbf9sEblVhkXz1kG0MQvi7FeGhuwXGPtFxDqp+mNp0sYdJ40FUqEWTNkvFKFYrkhGnVPn0SCqz3ObKsFG0jTxSVJO3XxWScWLFKta9emaqgG9mu9L02x9qlZL15SrYkXTX1Q9nlrFlleqe/corfMgierzvJWsbqyevMumsByB9zE6IpMXquza1LJBS5YscRfkgUSddzxPG89z+zFlwoQJTZrdtpb3M+rvO62133FBD/L8VWbDzFtD1qzT2tE2ZCPnWHAY7b8kAQA2MBdeZn/p4rpO+rmfX6/1niTVJNfNm7Qx0lLq/t7c+cE8zX3fd/JiY335RnSL0X2nd1OvzKYTNwOILDYyPNCQ9R21JZiCGuTZELDWTtmaT1r7Uhvt55NPPnEdNY01y1y2bJkmTpzobtsoOdYJ1Dqn2jQK1qHRfj2xCRkBAGhxLjzL5P1h4egXdPLz8/RIZ98R6Fojp3Pd49x73AiVd2s6+tyC30v06IffuhE6CfIAAFEX5Fk75hNPPNH1p7OOnjZSkgV43gkJbbv11/OyNq1TpkxxI+BYx04bEck6tjJ9AgCgiazNpBNelXrtKCX79luo6DpYy/VHM86NlZwubXWYBuR1lyoXNtntye7DmwEAiN4gz7JwLbHhXRuzUYFmzpwZwFIBACKCBXYD9m3/x83qLx0zUSpaJt2/fZPdMaf+3P7PCQDARgi5PnkAALSLkpXSN09K258qdWk6+vIm65QtnTWtyeaE1Ut1RfyLSlybJ23koC4AALQHgjwAQOQGedP+JQ06MDBBXnyilDuiyebY/E81KGaJSqrXtf9zAgDQCowzDAAAAAARhEweACCiLSgoVbmnyHdbfmnAn3fJ6jJVLPN9Xu8k63kZTSdZBwCgvRDkAQAiUn5phXIkXTxpluY2CvJMSkKcC7jam82j55F094c/6/sPqvw+79TLRhLoAVHARpEfPHiwmzYM7csmnx87dqxbwsmcOXPcFHLz5s1Tp06Bm0uV5poAgIi0piZVk2t21cUH7aC3L9ytyRKoQCs7d4BKR5yu208f3eQ5xx87QmVVNW4OPQAbZ+XKlbrwwgu12WabKSkpyc2zfMghh+g///lP/TExMTF6/fXXm9zXAoE999yz/vYpp5zijrUlISFB3bt3d1N4PfHEE6qtrfX7/KNGjVJcXJy+/PLLVpV39uzZeuedd1yZ/T2vd9lpp5187mflbHzMcccd53PMmjVrXABpU5DZYv9fu3atzzFff/219tlnH2VkZCgzM9OVf9asWfX7y8vLXXmGDRum+Ph4jRkzpslrsOnM/va3v2nQoEGKjY3dYEBlc15beRs/1vTp0917ZdOfNfceBdOiRYtcuRrWT6BYfdtE6ffcc09An4cgDwAQkarS+uiSqvOV239LDc1Lb7IErMlkpyx13mqUttysX5PnHJDTOTDPCUQ4uwjfbrvt9NFHH+n222932RCbW3mvvfbS+eef36bHPOCAA1wQY4/97rvvuse6+OKLdfDBB6u6utrnWJu3+YsvvtAFF1ywwSnAvO6//34dffTR6tKli9/n9S42B3RjZ555ps8xDz/8sM9+C7wsILE6sMX+b4GeV0lJifbff3/16dNH//vf//TZZ58pLS3NbauqqmthUFNTo5SUFF100UXad1//081UVFQoOztb11xzjbbeeusWX+9vv/2myy+/XLvvvnuTfevWrXP3tzqJdFV/1G9LTj31VD344IPuPQgUgjwAQESKqS5X35iVbt2h1q2WFvynbg2gXZx33nku0/LVV1/pqKOO0sCBAzVkyBBdeumlrc6sNWbZwB49eigvL0/bbruta1L5xhtvuICv8VzNTz75pAv+zj33XL344osuaGmJZQNffvllHXrooc0+r3fJyspqckxqaqrPMZat8/rxxx9dYPfYY49p5513dsujjz6qt99+2zUBNLa2bN9NN93ksnBWVzfccIPy8/NdwGqsqaAFGhZQ2nM01yTy3nvv1UknneRThsYsWDn++OM1btw4l2ltzJon3nLLLTriiCO0Md58801tv/32Sk5OVrdu3Zq9v79M3Nq1a922Tz75xN22+rAyWtBqwe0WW2zh3lfTv39/t95mm23cfRpmfZ9++mlttdVWrgxbbrmlJkyY0OR5X3rpJXcfO+bZZ591Aa9lLi2DavVs9d8wmLdge9WqVZo2rek0PO2FIA8AEJGS1s7XtKRL3bpDFS+Rvnqkbg1gk61evdoFNZax89eHyZojtpe9997bZZxee+21+m0ej8cFAyeccIK7yLcA0y7qN9RU04IMC1Aas6AjJyfHPY4FWBZ4Nfbcc8+5oMaCA8uOWWbOyzKKFnD95S9/qd9mTT5t2+eff+5uW2Bn97esY2VlpcrKytz/7fH69u2r9mbBpAVPp59+ers9pjV1taDuoIMO0rfffuua5fqrz9a67rrr9MMPP7gg3gJlC3Ctjoz9eGCmTp3qMqfe99+C5+uvv94FqHafW2+91T2OBX4N/eMf/3AZUTvGAjg7Vy0Las1ULev873//W507/9mSIzEx0Z1nn376qQKFgVcAAACinc0raUtDKRlSZj+pqlwq+KnRHTxS9tC6/xbOlyobZbYy+kipWdK6Qqloqe++pC5S181bXbQFCxa4QMsCrI5gz2NBmpdd+K9fv95dvBsL9ixgsiZ3zbEMj/Xfs2CucUbLmnBaoLVw4UIXMFhgOWPGDJfhM5ZtssySZde+//57XXXVVfruu+/0wQcf1PdNbPy4xrbZPmNNRC2YPOyww3TzzTe7bRZUvv/++67/XXv673//6+qjvfuz/fOf/3R9ES076LWhJqMtWbx4scvUeQNFy1J6WYBqunbt6pPVtODOAjQLNi1jZ++LBYrWfPbkk0+uP876KjbMMtpzHXnkka7/nfGX3bQMsp0ngUKQBwBAIBQvl/K2sXZb0sq6C8bkwlLlqpD6Ruj55klp2r98tw07RjryUal4mfTISJ9dMfbPNX+cy6+fKy392ve+hz8ibX2sNHeyNOVy332b7y2dOLnVRbMAzz1njHvWgLPna/hcFsAce+yx9cHRX//6V/397393TSItY+aPZc4saGtcZnscr6FDh7qAwwI+b9bKWHav4THWrNCOmzlzpoYPH95sXTQstz3/aaedpl133VUvvPCCa0555513avTo0W5AFmuu2B4sw2hBr2W8vFmx9mJBY8O62FTnnnuuC7ysHm0QGhscZpdddmn2+IKCAi1ZskRnn322u6+X9dds3HS1cYbRsnp2HwvMrb+jPa/3vfOy98B+PAgUgjwAQPhav1paW9e/pF5iJ6nbFsEqkZTaVYpPkr58UBp8kFRbVX+BPMCyAklJWlK6g6Tm+7cAHW77U6VBBzbN5Jm0POks375DHjdRyB/GPOg/k2eGHC71svO9USZvI1iQY8GLNYXzNwJkQ5bBKipqOmWKNZ1sqU9ZQ/Y83j5a1lTURoK0wTSseZ+XBU02EqdlefyxgMcu4K2ppDXNa07Pnj1dkDd/fvPNyq2/oI0AasdYoGCZpt9//91vUGKjhJrnn3/eZYmsaaeNiundZn3ErN9h49E62+qXX35xz2P9z7y8o5NaUGyB8Oabtz5r29DGBKLe1+j9QcDfACiWRbW+chZQW3bWRh61ZpUW/PrjfR32vlsw2DCwtixtQ42bEZ9xxhku82vPZYHebbfdprvuustnpFU7t9paN61BkAcACF/zP5Qmn+W7zS4oz5iqqk657mZNctNBDQIqvZc0+i4pPbnudmxC/QXykvmz1PvjixVXzqAsCDFdetQt/iQkS7kjfLfZxbR3BMqWflTp1K1u2QQ2MIldMD/wwAMuQ9L4gtoCOG+/PGtqaZmqhk3p7MLfmkPaRf6G2Oid1ofqkksuqe8b16tXryZD/lv/MLtwtyaF/po/jhhRV1/WtM/7f39s8A3LFlmw15y5c+e6gMV7jA20YoGs9SOzofiNjaBp27yZKQswLfBpGJh4bzc3RURbWH1bfTV07bXXugyfDdhi01y0lQW0Vs8tNYtt3NzS+tNZk0zjr/moHWfTRthio4BaRtaCPG8g3nC0SwuYrUmlNau1gWc2NpNsr/2cc85xizW5tWxnwyDPmuLaIEKBQpAHAAhfW+zXJMPgMnn2xzqlq3Ypv0+PdM7r+HJ1zpa6/tFnxn5h/uMCubg6Tzu9G6vHM/038QLgn41oaAGMBTU2yIcFANZs7sMPP3SZFsu+GRukxAI8Cz6sSZ41W3zkkUdcxqnxVAs2MIb1YbMLe8uM2eAuFrjZKJp2Ue9tqmkX4tZssiHLvtlgG5apsX5v/oIJy8DZ1AXeIK+0tFQ33nija7pnAZtlwGxET8v6HX744e4YK6cFltas0rZbkHjZZZe5wMWaXlrAapOr2zQM1pTRO7XCWWed5crtbT5qc/5ZAGOv2QILC+z+9a9/uYDUporwsse3bKNllSww8wZGDQNT7zYrv2UL7bYFRd4RJxvXjTfgbrjd7mt9K70scLLHsQDepnnwx0YDtWybZbss82jvtw2acsUVV/jN+tngM/Yara9dYWGhCzYbsgFUbBoOG3zG3nsbjdTq0tuf0R7DzgEL6u11WebXymDTathrsvfE7vfNN9+4kTptZNfmWB89+1HB+kHasfbjgfe5jL33y5Yta3bqinbhiTJFRUWWx3XrUFJTU+NZsWKFW4M6j1Sc59R5uyot8Hj+90jd2o85S9d6+v7jbbcOlfM8WGWKdHy3tE5ZWZnnhx9+cOtNVVtb66msrHTrjrJ8+XLP+eef7+nbt68nMTHRk5eX5zn00EM9H3/8sc9xkyZN8my//faetLQ0T05Ojmf//ff3fPPNNz7HnHzyye560Jb4+HhPdna2Z9999/U88cQT9Z9du4/t/+qrr/yW55BDDnFLcx566CHPTjvtVH97/fr1nlGjRrnnSkhI8PTp08eVY/HixfXH2P/32GMPT1ZWlnuNm2++ueeiiy7yrFq1yqfO7fbxxx/v6dKli1vs/2vWrPF5/g8++MCz6667etLT0z2ZmZmevffe2/PFF1/4HGN16a2HhktD/vbb/Zpjr+mwww7z2Wbvkb/HsWNb8uqrr3pGjBjh6qJbt26eI444wqfs99xzT/1tO7etvlNSUtx97PXbc3jPj5tvvtkzePBgt9/q18r466+/1t//0Ucf9fTu3dsTGxvrGTlypNtmdf3000/Xl8Hq0d6f1157ze1fuHChe45vv/3Wp9wXXHCBe++SkpLc+33iiSd6CgsL6/ffeuut7rxsy2e1tbFMjP2jKFJcXOwic0tp26SQocJ+YbEhdO2XBG+7YlDnkYbznDpvV8tn1fV1s0xe46Zk1hRmWZEO/r/P9PaFu7mJyEPhPJ/342wteP4yDfjbXRo02LcTPgJT5/hTeXm5y6BYfzPLVGwKu3y0zIplhjpqQJRwrG/LrE2aNMk1sdxU1HnH8wTgPLdsoPUztQFxLDu7sZ/V1sYyfBMCANBB4iqLdVDcV24NILLZxfnEiRNd00HAywZ/ueaaa5oN8NoLffIAAACAABg50nfqCWDgwIFuCTQyeQAAAAAQQQjyAADhyebaskmVN3LOLQAAIh1BHgAgPHXdXDpxct06TFSndtftVce6NQAAgUKQBwAIT7U1Unlx3TpMVKfmaELNYW4NBEt7ToYNIDQ/owy8AgAITyvnuCkUFhz+jsq7DWuye0F+qUJNbEWR9o2dodgKK2/HTesAGJvA2qaYWL58uZus2263dVh4hvPveNR55Ne5x+Nxk9PbpPP2WbXPaFsR5AEAwlJ+aYUsH3bxpFma6ynye0xKQpwyO7X9j2R7SyxZrMcS79KCkr0l9Ql2cRBl7KLR5t1asWKFC/Q29WLUsg32mMyT1zGo8+ip89TUVPXp02eT5v0kyAMAhKXisioX5F0+apCyB+7o9xgL8PIyUjq8bECossyAXTxadqKmpu1Nne3Cd9WqVeratSsT0HcQ6jw66jwuLq5dMocEeQCAsNY7K0UD8mj6CLSWXTwmJCS4ZVMufu3+NuF3R138RjvqnDrfGHwqAQAAACCCEOQBAMJSedaW2rb8IbcOF564JP1cm+fWAAAECkEeACA8xSZotdLcOlxUZA7UqMo73BoAgEAhyAMAhKXE4kV6NOFOtwYAAH8iyAMAhKXYyhLtFzfTrcNF8qq5mpN0ulsDABAoBHkAAHQUT626xJS5NQAAgUKQBwAAAAARhCAPAAAAACIIk6EDAEJfwTypqsxnU218qm6uOl5HpfYIWrEAAAhFBHkAgND36hnSytk+m5L3maDHaw7S4anZChcVGQN0UMU/dU5lD5UvK/J7TGanROVlpHR42QAAkYMgDwAQ+o58rEkmr7Q8U9L3CicZ6en6NX6ALnx1niRbmkpJiNPUy0YS6AEA2owgDwAQulZ8Jz22r3TGVCl3hM+u2mYyYaEsT4X6ept3tWzI2arqnNdk/4L8Uo19cZbWrKskyAMAtBlBHgAgdHk8Uk1l3ToSrF+lzrOf0qCdTpVy04NdGgBAhGJ0TQAAAACIIAR5AAAAABBBCPIAAAAAIILQJw8AELqyB0nnfSll9lNE6JQt7XR+3RoAgAAhyAMAhK6EFClnsCJGep50wK3BLgUAIMIR5AEAQtfaxdK026WRV0gZfRT2KkqlhdOl5HQpsVPdtth4qcdQ99+k1fOUq8LglhEAEPaC2ifvtttu0w477KAuXbooJydHY8aM0bx5/ieH9frkk08UExPTZPnpp586rNwAgA6yfrX07TN160hQtkaa9FfpqdHSIyPrlomH1u/u8+EZmpr0dyWULgtqMQEA4S2ombxp06bp/PPPd4FedXW1rrnmGo0aNUo//PCDOnX64xfOZlgwmJaWVn87O5v+DQAQqRYUlKrcU9Rk4vCwk9FbGvu9my+vnmXy/vD7Dleqz3/OVVx5hAS1AIDoC/Lee+89n9tPPvmky+jNmDFDe+yxR4v3teMyMjICXEIAQDDll1YoR9LFk2ZpbqMgz6QkxCmzU6LCLtCzxY/KtAhokgoACLqQ6pNXVFT3BzwrK2uDx26zzTYqLy/XVlttpWuvvVZ77bVXB5QQANCRisuqXJB3+ahByh64Y5P9FuDlZaTwpgAAEIpBnsfj0aWXXqrddttNQ4fWdUD3p2fPnnrkkUe03XbbqaKiQs8884z22Wcf11fPX/bPjrHFq7i42K1ra2vdEiqsLFYHoVSmSEedU+fRINzP86rkbppQfZj2yu2tQT27+D0m1F7bptR5RZe+OrnyH7qiS9+Qe12hLNzP83BEnVPn0aA2BL9bWluWkAnyLrjgAs2ePVufffZZi8cNGjTILV4777yzlixZojvvvNNvkGeDu4wbN67J9oKCApcJDKU3zDKZdiLFxjJHPXUemTjPqfONVVydoHe6HK3tqhOUn5+vSD/PS8sqVZg+zK3D5fWGAr5bqPNowHlOnZuSkhKFTZB34YUX6s0339T06dPVq1evjb7/TjvtpGeffdbvvquuusplCBtm8nr37u0Gamk4cEsofHBtlFArF0EedR6pOM+p8421av1ypRX9pM4p27i+2JF+nq8pnq/9SiYrLWFg2LzeUMB3C3UeDTjPqXOTnJyskA/y7FdOC/AmT57smlv279+/TY/z7bffumac/iQlJbmlMfvDG2rBlF0UhGK5Ihl1Tp1Hg3A+z5NKFumFxFu0oGRnxcZu/I+A4VbnCWUFGhv/qhaUnabY2D9brSBwdY62o847HnVOnce28jsuqEGeTZ/w/PPP64033nBz5a1cudJtT09PV0pKSn0mbtmyZZo4caK7PX78ePXr109DhgxRZWWly+C9+uqrbgEAAACAaBfUIO/BBx906z333LPJVAqnnHKK+/+KFSu0ePHi+n0W2F1++eUu8LNA0IK9d955R6NHj+7g0gMAAABA6Al6c80Neeqpp3xuX3HFFW4BAAAAADRFw3UAQMjyxCZohSfLraNBTWK6Jtfs6tYAALQVQR4AIGRVZG2pnSvud+toUJXWR5dUne/WAAC0FUEeAAAhIqa6XH1jVro1AABtRZAHAAhZSat/0hdJF7h1NEhaO1/Tki51awAA2oogDwAQsmJqq9QzZrVbAwCA1iHIAwAAAIAIEtQpFAAAcNYukdav+rMyOudIabmKrVpHBQEAsJEI8gAAwQ/wHthRqlr/57bdLpH2vVHxZYXuZk1ylqLJktVlKl9W1GR7ZqdE5WWkBKVMAIDwQZAHAAgyjzT0SGnIGCm125+ZPEmlvfbULuX36ZHOeYoGKX230+CaF1X2fqX0/mdN9yfEaeplIwn0AAAtIsgDAARXRh/psPv97qpN7Kzl+iPwiwKWpbMgbs26yib7FuSXauyLs9w+snkAgJYQ5AEAgquqTFqzSMrsJyVEeVPEwvnKe/1c5Y15UOq2RbBLAwAIU4yuCQAIroJ50oSd6tbRrnKdtPTrujUAAG1EkAcAAAAAEYQgDwAAAAAiCEEeAAAAAEQQgjwAQHDFxEhxiXXraGcjjR7+SN0aAIA2YnRNAEBw9dxauq6Ad8GkZklbH0tdAAA2CZk8AABCxbpC6atH69YAALQRQR4AILhs6oSHdmcKBVO0VJpyed0aAIA2orkmACD4k6GvnK0FywtUXtnDZ9eC/FJFpcKfpaQuUtfNpdoaaeUcJReWKldk+AAAG0aQBwAIqvzSCuVIunjSLM31FDXZn5IQp8xOiYoKqV2lhFTptTOlzfeWTpxcNzH6IyM1QNLUpCQtKd1BUnqwSwoACGEEeQCAoCouq3JB3uWjBil74I5N9luAl5eRoqiQ0Vs6/ytp/aq6TJ5J7CSdNU1L5s9S748vVlz56mCXEgAQ4gjyAAAhoXdWigbkkaFygZ4tXrFxUu4IVRREadNVAMBGY+AVAEBQVXbprfMqL3JrNK88a0ttW/6QWwMA0BKCPABAUNUmZWhK7U5ujRbEJmi10twaAICWEOQBAIIqbn2BTo97x63RvMTiRXo04U63BgCgJQR5AICgSli/UtclPOfWaF5sZYn2i5vp1gAAtIQgDwAAAAAiCEEeAAAAAEQQgjwAAAAAiCAEeQCAoKpN7KIPa7Z1azSvKrWHbq463q0BAGgJQR4AIKgq0/rpzKrL3RrNq0nN1uM1B7k1AAAtIcgDAARXbZWyVOzWaF5sxVqNjv3SrQEAaAlBHgAgqJJX/6SZyee4NZqXWLJEExLvc2sAAFpCkAcAAAAAEYQgDwAAAAAiSHywCwAAiALrCqWipb7bkrpIXTdXjKc2WKUCACAiEeQBAAJv7mRpyuW+2zbfWzpxsmqS0t3NmuQs3okWeOKS9X1tPyXFJVNPAIAWEeQBAAJvyOFSrx2aZvJsCoXOvbVL+X16pHMe70QLKjK30MGVt+rtzC2oJwBAiwjyAACBtX61tOA/0hb7Sal+snWxcVqubrwLrbQgv9Tv9sxOicrLSKEeAQAEeQCAAFu7WJp8lnTWNP9BHlolZ908/Zx0kg5/6SbN9TSdOD4lIU5TLxtJoAcAIMgDACAc5HROlGKqde9xW6u827Am2b2xL87SmnWVBHkAAII8AADCyYDszlJu3WA1AAD4wzx5AAAAABBBCPIAAIGV2KluZE1bAwCAgGN0TQBAYHXbQjpjKrW8qbIHSed9KWU2HXQFAICQyeTddttt2mGHHdSlSxfl5ORozJgxmjdv3gbvN23aNG233XZKTk7WZpttpoceeqhDygsAQNAkpEg5g+vWAACEapBnwdr555+vL7/8Uh9++KGqq6s1atQorVu3rtn7LFy4UKNHj9buu++ub7/9VldffbUuuugivfrqqx1adgBAKy2fJd2YXrfGpk1F8cYFdWsAAEK1ueZ7773nc/vJJ590Gb0ZM2Zojz328Hsfy9r16dNH48ePd7cHDx6sb775RnfeeaeOPPLIDik3AGDjLSgoVbmnqNWTe8PPpPLfPiPtcIaU0YfqAQCER5+8oqK6P/5ZWc1PlvvFF1+4bF9D+++/vx5//HFVVVUpISHBZ19FRYVbvIqLi926trbWLaHCyuLxeEKqTJGOOqfOo0EonOcFJeXKVqzGTpqlHzxr/R7TKSFOGanxEfEdGLA693jqGuDYutFjezy1ipXHrSOhDsPxPI821Dl1Hg1qQ/C7pbVlCZkgzyrw0ksv1W677aahQ4c2e9zKlSvVvXt3n21225p6FhYWqmfPnk36/Y0bN67J4xQUFKi8vFyh9IZZkGv1EBvLoKfUeWTiPI/OOl+xer08acN10dDNlZ430O8xnZPiFV9Rovz8EoW7gNV5UZmUNrxuHZfvs2t90ToNzvRofdFq5cf/+cNmtAiF8zzaUOfUeTSoDcHvlpKSkvAK8i644ALNnj1bn3322QaPjYmJ8bltFe9vu7nqqqtc8Ngwk9e7d29lZ2crLS1NoXQSWfmtXKFyEkU66pw6jwahcJ6XrJyvnOLZ6p/TWZsP7q9IF7A6r1khFc+W0m0AlhyfXQXVRfpxTYxS07OUkxN9E6WHwnkebahz6jwa1Ibgd4sNPBk2Qd6FF16oN998U9OnT1evXr1aPLZHjx4um9dQfn6+4uPj1bVr1ybHJyUluaUxe6NC5c3yspMoFMsVyahz6jwaBPs8r8wcqL0q7tSEzIFR8/0WkDrv0l3a7WIpqbO0crbPruQ1FapVjGJiovdvSLDP82hEnVPn0SAmxL5bWluOoAZ5loGzAG/y5Mn65JNP1L//hn/h3XnnnfXWW2/5bPvggw+0/fbbN+mPBwAIPk98sn7z9HBrbIK0XGnfG6WFn0pPH+yzq1+nHpLupnoBAMEP8mz6hOeff15vvPGGmyvPm6FLT09XSkpKfXPLZcuWaeLEie72Oeeco/vvv981wTzzzDPdQCw26MoLL7wQzJcCAGhGQvFi3ZPwgBKK+0h5w6inTZU7Qjprms+mRasqpOcKqVsAgBPUvOODDz7oOjPuueeebsAU7/Liiy/WH7NixQotXvznnECW7ZsyZYrL/I0YMUI333yz7rvvPqZPAIAQFVdZpMPj/uvWaAdJXeoCvYaLjT6ddIGSVv9EFQMAgt9cc0OeeuqpJttGjhypmTNnBqhUAACEl5jaKvWMWa0FtVXBLgoAIASERg9CAAAAAEC7IMgDAAAAgAhCkAcACKjq1ByNrz7CrQEAQOAR5AEAAqo6tbvGVx/l1giMyrT+Oq7yWrcGAIAgDwAQULGVJdoj9ju3RmDUJnbWl7VbuTUAAAR5AICASixepImJ/3ZrBEb8upW6In6SWwMAQJAHAECYiy8r0Hnxb7o1AAAEeQAAAAAQQQjyAAAAACCCEOQBAALKE5uoRbXd3RoAAARefAc8BwAgWlSUSqsW+G7z1GrPynv0dtagYJUq4tUkZWpS9Z7aJikz2EUBAIQAgjwAQPvJ/0F6fD+fTf2TsyTdTy0HUFWXXrqy+iy93aUX9QwAIMgDALSDomXSFw9I258qnTXNZ9fCwnLp+VVUcwDFVJdri5ilbi2lU9cAEOXI5AEANt26AunLB6Thx0i5I3x2VXiKJH1GLQdQ0tr5+jDpCi1YO0Tq2526BoAox8ArAAAAABBBCPIAAAAAIILQXBMAgAixZHWZypdZ89imMjslKi8jpcPLBAAIkyBv5syZSkhI0LBhw9ztN954Q08++aS22mor3XjjjUpMZC4kAIgqqV2lHc6oW6PDpaUkqtITrzs/+Flz36/0e0xKQpymXjaSQA8AokCbgryzzz5bV155pQvyfv31Vx133HE6/PDD9fLLL2v9+vUaP358+5cUABC6MnpLB90V7FJErZyBO2rZJUv173X+A7wF+aUa++IsrVlXSZAHAFGgTUHezz//rBEj6kZPs8Bujz320PPPP6///ve/LuAjyAOAKFO5Xir8Weo2UEpMDXZpopI1xaQ5JgCgzQOveDwe1dbWuv9PnTpVo0ePdv/v3bu3CgsLqVkAiDYW4D0ysm6NjlcwT3po97o1ACDqtSmTt/322+uWW27Rvvvuq2nTpunBBx902xcuXKju3ZmfBwCi1YKCUpW7efEabMsvDVp5okZVmbRydt0aABD12hTk3XPPPTrhhBP0+uuv65prrtGAAQPc9ldeeUW77LJL1FcqAESb/NIK5Ui6eNIszW0U5HkH/bDRHQEAQIgGeVtvvbXmzJnTZPsdd9yh+HhmZQCAaFNcVuWCvMtHDVL2wB2b7Gf4fgAAOk6bIrLNNttMX3/9tbp29R0qu7y8XNtuu60bcRMAEEViYlXiSVHvrp00IC892KUBACCqtWnglUWLFqmmpqbJ9oqKCi1durQ9ygUACCPlXYdoWMXjbo0gyOwrHf1U3RoAEPU2KpP35ptv1v///fffV3r6n7/WWtD3n//8R/3794/6SgUAoEOlZEpDDqfSAQAbH+SNGTPGrWNiYnTyySf77EtISFC/fv10111MhgsA0SZpzc/6IPHvilnztJS3Q7CLE31K86XZL0nDj5E6W+9IAEA026ggzzs3nmXrrE9et27dAlUuAEAYiamp0Baxy7SgpiLYRYlOxculD66pC/BsQvrkNClrM6mmSvp9rpILS5Ur5rEFgGjRpoFXbD48AAAQIlK7Sgmp0mtn1t0eeKD0t0lSeZGbpN4mOpqalKQlpZZlZWAcAIh0bZ7vwPrf2ZKfn1+f4fN64okn2qNsAACgNTJ6S+d/Ja1fVXfbMnlunS6dNU1L5s9S748vVlz5auoTAKJAm4K8cePG6aabbtL222+vnj17uj56AAAgyIGeLQ3FJUi5I1RRUBqsUgEAwiXIe+ihh/TUU0/pxBNPbP8SAQDCTmWXPjqj8jJd2qVPsIsCP8qzttLQ8sc0KWsr6gcAokCb5smrrKzULrvs0v6lAQCEpdqkdE2t3c6tEYJi41SqVLcGAES+NgV5Z5xxhp5//vn2Lw0AICzFr8/XeXFvuDVCT2LRQk1MuM2tAQCRr03NNcvLy/XII49o6tSpGj58uJsjr6G77767vcoHAAgD8et/1xUJL2rB+pMkbRHs4qCR2KpS7RE3Rwuq6JsHANGgTUHe7NmzNWLECPf/77//3mcfg7AAAAAAQJgFeR9//HH7lwQAAAAAEJw+eQAAAACACMrk7bXXXi02y/zoo482pUwAgFBVWyutnN10c3yq3qnZUQMS/5iEGyGlqlOurqs6RX/rlBvsogAAQjXI8/bH86qqqtKsWbNc/7yTTz65vcoGAAg1tVXSIyObbv7r/3R+1Vi9ndY3KMVCy2pSuuqZmlE6NqUrVQUAUaBNQd4999zjd/uNN96o0lJG7gKAiFO4QHrrYumQ8dJZ05rsrqm24OGXoBQNGxZXvlZjYj9TXPlQScxlCACRrl375J1wwgl64okn2vMhAQChoLJU+u0zqXKdlDuiyeKJSwx2CdGChNIlGp84wa0BAJGvXYO8L774QsnJye35kAAAAACAQDfXPOKII3xuezwerVixQt98842uu+66tjwkAAAAACBYmbz09HSfJSsrS3vuuaemTJmiG264odWPM336dB1yyCHKzc11o3W+/vrrLR7/ySefuOMaLz/99FNbXgYAAAAARJw2ZfKefPLJdnnydevWaeutt9app56qI488stX3mzdvntLS/hymOzs7u13KAwBoRnpv6ZD76tYIOzbFxczaAeocnxrsogAAQjXI85oxY4Z+/PFHl03baquttM0222zU/Q888EC3bKycnBxlZGRs9P0AAG3Uqau0HVPkhKvKjM11ROVNejtj82AXBQAQqkFefn6+jjvuONd80oIt65NXVFTkJkmfNGlSwDNrFkyWl5e7wPLaa691zwsACKB1q6Sf3pa2PLgu4AMAAJEV5F144YUqLi7W3LlzNXjwYLfthx9+cBOhX3TRRXrhhRcUCD179tQjjzyi7bbbThUVFXrmmWe0zz77uGBzjz328HsfO84WLyu3qa2tdUuosLJYsBxKZYp01Dl1Hg3a7Txfu1h6a6x+idtM5d1srjVfv+SvU6w88nhC67s1GELxuyWpYLZ+TT5Bn8x7UXM8OzTZn9kpUbnpKQpXoVjnkY46p86jQW0Ifre0tixtCvLee+89TZ06tT7AM5ZVe+CBBzRq1CgFyqBBg9zitfPOO2vJkiW68847mw3ybrvtNo0bN67J9oKCApcNDKU3zLKhdiLFxrbrzBagzkMG53n41vnalcXKSBuuu9+fp8Va6/eYEd1iFVterPz8P39Yi0aheJ7X1NQqP224Xv56sRZ/3fT9SYqL1c1jhqpr5ySFo1Cs80hHnVPn0aA2BL9bSkpKAhfk2QtOSEhost22dXSku9NOO+nZZ59tdv9VV12lSy+91CeT17t3b9ektOHgLcFm9WZ9G61coXISRTrqnDqPBu11npesnK+c4tk6eo8+yh7YNBMUCdmgSP5uyalZIRXP1qVjBjXJxFoW9tKXZqk2OU05OekKR6FY55GOOqfOo0FtCH63tHZO8jYFeXvvvbcuvvhi1yzTpj8wy5Yt0yWXXOKaT3akb7/91jXjbE5SUpJbGrM3KlTeLC87iUKxXJGMOqfOo0F7nOfuMVSrPl1TNaBXZruWLxKF3HdLTIxdrmiLnC5Sru/7FxNj76xNSRRC5Y2EOo8C1Dl1Hg1iQuy7pbXlaFOQd//99+uwww5Tv379XFbMXvzixYs1bNiwFrNqjZWWlmrBggX1txcuXKhZs2a5eff69OnjsnAWPE6cONHtHz9+vHvOIUOGqLKy0j3Xq6++6hYAQODUxnfSl7WDlRXfiWoGACDEtSnIs8Bu5syZ+vDDD91E5NZO1frk7bvvvhv1ON98843PyJjeZpU2gMtTTz2lFStWuODRywK7yy+/3AV+KSkpLth75513NHr06La8DABAK1VmbKbjKq/T2xmbUWfhKHtL6cKZUlpesEsCAAi1IO+jjz7SBRdcoC+//NL1Z9tvv/3cYqxTogVdDz30kHbfffdWPd6ee+7pAsTmWKDX0BVXXOEWAEAH89QqUVVujTCUkCx1ZY48AIgWG9W41JpLnnnmmX4HLElPT9fZZ5+tu+++uz3LBwAIAcmr5urn5JPdGmFozSLp1TPr1gCAiLdRQd53332nAw44oNn9Nn3CjBkz2qNcAACgvZStlea8VLcGAES8jQryfv/9d79TJ3jFx8e7+ecAAAAAAGEQ5OXl5WnOnDnN7p89e3aL0xkAAAAAAEIoyLNRLK+//nqVl5c32VdWVqYbbrhBBx98cHuWDwAAtIeYuLp1ebG0fFb9klw4R7kqpI4BIFpH17z22mv12muvaeDAgW6UzUGDBrk58n788Uc98MADqqmp0TXXXBO40gIAgqIic5B2Kv8/PZ45iHcgHKV2lfb4u5TeS1r6lfTskfW7Bkh6PrG7ytbvasOoBbWYAIAgBHndu3fX559/rnPPPddNVO6d/sACvf33318TJkxwxwAAIosnLlEr1dWtEYYyekt7XC7FJUi9dpTOmla/a0FBqY55YYkmpmYHtYgAgCBOht63b19NmTJFa9as0YIFC1ygt8UWWygzM7MdiwUACCUJxb/pgYTxSijuLeUND3Zx0BYW4JnkNCl3RP3mck+RVquIOgWAaA7yvCyo22GHHdq3NACAkBRXWayD4r7SgsriYBcF7Sxp1Y+akXS2Vq96RcrbifoFgGgbeAUAAESWGE+1usaUuDUAIDIQ5AEAAABABGlzc00AQARau0Rav8p3W2a/YJUGAAC0AUEeAKBOaYH03FFSwU++NXLcC6pO3UK3Vx2rQ1MZQRkAgFBHkAcAqNM5WzrlHaloqW+NZPZT9eoYTag5TKNTc6itCFOZvpmOqLhRt6RvFuyiAADaCUEeAOBPnbrVLU0wxH6kqk3opJmegW4NAIgMDLwCAKizYrZ0a6+6NaJGfOkKXRv/jFsDACIDQR4AoI6nVqosqVsjasSXF+qM+HfdGgAQGQjyAAAAACCCEOQBAAAAQARh4BUAgI8FBaUq9/gOtLIgv5RaAgAgTBDkAQCc5Qm9dWHNbZr7Qr7K9VmTWklJiFNmp0RqK8LUJGdpYvV++ktyVrCLAgBoJwR5AABndWW8ZlT11fhjR2hATucmtWIBXl5GCrUVYao65+n66lP1due8YBcFANBOCPIAAE5C6TLdFP+kBqfepEF5XPBHi5jqMg2JWaiY6u0kpQe7OACAdkCQBwBw4spX66T4D7WgfCw1EkWS1i7QO0nX6ONfB8kT7z9TSxYXAMILQR4AAFEsLSXBre/8YJ7mvl/p9xjrjzn1spE01wWAMEGQBwBAFMvpnOTW9x43QuXdhjXZbyOrjn1xltasqyTIA4AwQZAHAAA0ILuzlEufPACIBEyGDgBwqpO76bHqA90aUSQmVkrsUrcGAEQEvtEBAE515566pfpEt0YU6Tlcunpp3RoAEBEI8gAAdX8QqtZp25if3RoAAIQvgjwAgJNY9KteS7rRrRFF8n+SHvhL3RoAEBEI8gAAiGbV5VLBT3VrAEBEIMgDAAAAgAjCFAoAAEAqL6qrhZLfpZIV9TWSXFiqXBVSQwAQRgjyAACOJyZeqzxd3BpRJLVr3Xrtb3XrWc9K/7mpfvcASdck7KjYyn0kMY8eAIQD/pIDQDQqL5ZWNxpgJSZW21U8rLe7Dg5WqRAMGb2lsd9LSV3qbo84QdrcAro6CwpKdd0LSzTR5tIDAIQFgjwAiBYlK6VvnpS2P1X6/Xvp2SN9dvdJ6yvptqAVD0EO9Ly6dK9b/lBRXaBE/aqYmsrglA0AsNEI8gAgmoK8af+SBh0o9dpROmuaz+7Fqyql5wqCVjyEpqQ18/Rl8oVasOYdqU92sIsDAGgFgjwAiEbJaVLuCJ9NFR4beIMgDwCAcMcUCgAAAAAQQQjyAAAAACCCEOQBQLRIyZCGHVO3BgAAEYs+eQAQLTL7adk+92nNukpp/R8TXzewIL80KMVCaCvvOkQDy5/Wa12HBLsoAIBWIsgDgCixrHCNTrv3DS2qSleFEv0ek5IQp8xO/vchSsXEqlIJbg0ACA8EeQAQJcqWzdX7cRfr471fUfbAHf0eYwFeXkZKh5cNoStx7a+alHizEtc+KOVtE+ziAABagSAPAKJM76wUDchLD3YxECZiq9dpp9gftaB6XbCLAgBopaC2vZg+fboOOeQQ5ebmKiYmRq+//voG7zNt2jRtt912Sk5O1mabbaaHHnqoQ8oKAAAAAOEgqEHeunXrtPXWW+v+++9v1fELFy7U6NGjtfvuu+vbb7/V1VdfrYsuukivvvpqwMsKAAAAAOEgqM01DzzwQLe0lmXt+vTpo/Hjx7vbgwcP1jfffKM777xTRx55ZABLCgAAAADhIaz65H3xxRcaNWqUz7b9999fjz/+uKqqqpSQkNDkPhUVFW7xKi4uduva2lq3hAori8fjCakyRTrqnDqPtvO8rOsQbVb+nN7oOoTvmg6q80hQ2SlX/6g6Uyd3yg3Z1xRpdR4OqHPqPBrUhuB3S2vLElZB3sqVK9W9e3efbXa7urpahYWF6tmzZ5P73HbbbRo3blyT7QUFBSovL1covWFFRUXuRIqNZZhq6jwycZ4Ht87XF5VpcKatVys//s8fvxC4Oo+E7/OSCo++Txvp1vn5+QpFkVbn4YA6p86jQW0IfreUlJREXpBnbICWhqzS/W33uuqqq3TppZf6ZPJ69+6t7OxspaWlKZROInsNVq5QOYkiHXVOnUfbeV6y+jvdtG6cOnseVk5O/2AXLWJF2nfL6tJFGlo8TYXF/ZSanuV32o3c9OBOuxFpdR4OqHPqPBrUhuB3iw0+GXFBXo8ePVw2ryH7VTE+Pl5du3b1e5+kpCS3NGZvVKi8WV52EoViuSIZdU6dR9N5HldTpu1i52tBTRnfMx1U55Hwfd6ttkD/TnhUB73ZT3M9TX8cSEmI09TLRgZ9fsVIqvNwQZ1T59EgJsS+W1pbjrAK8nbeeWe99dZbPts++OADbb/99n774wEAgE2T07nuh9J7jxuh8m7DfPYtyC/V2Bdnac26yqAHeQCAEAnySktLtWDBAp8pEmbNmqWsrCw3iqY1tVy2bJkmTpzo9p9zzjluugVrfnnmmWe6gVhs0JUXXnghiK8CAIDINyC7s5SbHuxiAABCPciz6Q/22muv+tvevnMnn3yynnrqKa1YsUKLFy+u39+/f39NmTJFl1xyiR544AE3ifp9993H9AkAAAAAEApB3p577lk/cIo/Fug1NnLkSM2cOTPAJQOAMLfqF6mixEankorKpJoVqo1P1djK83R2597BLh3CSWJnqe9udWsAQFgIqz55AIBWmnK59MtH1kVbShsuFc9W513G6fXa3XRGcgbViNbrNkA69R1qDADCCEEeAESS2hqpcp104O11a28mLz1FRWXp0kc/BruECDc28W5tlRSbYMO6Bbs0AIBW4NsaACLJyjnSv3rXBXi5I6SeW0tZm7l1TYr/qWaAls+p2dItOXVrAEBYIJMHAAA2rPDnunXOVlJ8orR6oZILlylXhdQeAIQYgjwAiEALCkpV7imSx1Or9UXrVFBdpF8K1ge7WAhHqV2lhFTptTPrbl/yg5SeJ029QQN+eENTk5K0pHQHSUyvAAChgiAPACJIfmmFciRdPGmW5nqKFCuPBmd69OOaGNUqRikJccrslBjsYiKcZPSWzv9KWr+q7nan7Lr1vuO0pPve6v3xxYorXx3UIgIAfBHkAUAEKS6rckHe5aMGKXvgjn9k8lYrNT1LMTGxLsDLy0gJdjERjoGeLQ1l9VdFxrJglQgA0AKCPACIIOVZW2rb8oc0ccA2GpqXrtraWuXHVygnJ12xjIyIdlad2l23Vx2rQ1O7U7cAEEIYXRMAIklsglYrrW64eyDAqlNzNKHmMLcGAIQOgjwAiCCJxYv0aMKdbg0EWmxFkfaNneHWAIDQQZAHABEktrJE+8XNdGsg0BJLFuuxxLvcGgAQOgjyAAAAACCCEOQBAAAAQAQhyAMAAACACEKQBwARpCq1h26uOt6tgUDzxCXp59o8twYAhA6CPACIIDWp2Xq85iC3BgKtInOgRlXe4dYAgNBBkAcAESS2Yq1Gx37p1gAAIDrFB7sAAID2k1iyRBMS79OCkv0l9aVqEVDJq+ZqTtLp+mb+s/peO/g9JrNTovIyUngnAKADEeQBQDhau0Rav0qKiZF6bl23rWCektYuCHbJEEXSkuPUJaZMd77/k+a+V+H3mJSEOE29bCSBHgB0III8AAjHAO+BHaWq9VJconRdQd32V89Q75Wztd6TpJrkrGCXElEgp3PdgCv3HjdC5d2GNdm/IL9UY1+cpTXrKgnyAKADEeQBQLixDJ4FeEc8KmUP+nP7kY9pwfICnfTCL3qkc14wS4goMyC7s5SbHuxiAAD+QJAHAGFqgSdX5bX9pGVFf2zpoQW1nbVc3tsAACAaEeQBQJhZlthH59TcqZ9fKFCFPvPbB8oGuwACrttA6axpdWsAQMggyAOAMLOmIk5zqnI1/tgRGpDTucl+RjNEh0lMlXJHUOEAEGII8gAgzCSULNW/4h/R4JRbNSiPvncI8iBA/x0vDRotpXat29YpW0rPkypKlVw4R7kq5C0CgA5GkAcAYSauYo2Oi/9ECyrWBLsogDTreenrx/6siZ3Olw64Vcr/QQMmH6SpSUlaUmpz6DEwCwB0FII8AADQNhm9pfO/qhvx1csyeSZnKy3Z6171/vhixZWvpoYBoAMR5AEAgE0L9GxpLKmzKjIGULMAEASxwXhSAAAQ+Twx8Vrl6eLWAICOQ5AHAGGmOiVbE6oPdWsglFV0HaztKh52awBAxyHIA4AwU92ph26vPs6tAQAAGiPIA4AwE1tZqp1if3BrIJQlrZ6nTxIvcWsAQMehkTwAhOr8YzZiYVyC1H1I3bbf50o1VeqyeJYmJd6iBcU7S2KePISumNpK9Yv9XQtqK4NdFACIKgR5ABCKAd4DO0pV66UuudJlP9Ztf/YoqWS5bBzD9Z4k1SRnBbukAAAgBBHkAUCosQyeBXhHPPpnFs+c8IrL5C0oKNVJL/yiRzqTxQMAAE0R5AFAiFrgyVV5dS9pWdEfW3rVba8t1XJ5twEAAPgiyAOAELM8Pk9X1lyvGS+s1LpmgrmUhDhldkrs8LIBG6MyrZ9OqvyHjqnIVnn9jxV/snM4LyOFSgWAdkaQBwAhZnVVoqZXbanxx47QgJzOfo/h4hjhID2zq76O21bTX1tgOWi/P1ZMvWwkgR4AtDOCPAAIMfHrVuqK+EnastMAbZlHvzuEr7y4Iv1vl6+0fMBxqk7t7rNvQX6pxr44S2vWVRLkAUA7I8gDgBATX1ag8+Lf1IKysyUNCnZxgLYrWam0/92ltK0PlXLTqUkA6CBMhg4AAAAAEYQgDwAAAAAiCM01AQBA4FWVSwU/1d9MLixVrgqpeQAIAII8AAgxNUmZmlS9p7ZJygx2UYBNk9pVGnaMlN5LKl4mPTKyftcASZ8nS/NKd7BxOKlpAGhHBHkAEGKquvTSldVn6e0udZOfA2Ero7d08D1SUmcpsbN01rT6XQsKSnXMC0s0sTMjyAJAxPXJmzBhgvr376/k5GRtt912+vTTT5s99pNPPlFMTEyT5aef/mz+AQBhY12DpmorvpOWz3JL6sqvtVPsD4qpLg9m6YD2YQGeSUiWckfUL+Xdhmm10qhlAIi0TN6LL76osWPHukBv11131cMPP6wDDzxQP/zwg/r06dPs/ebNm6e0tD//MGRnZ3dQiQGgnaxdIk36m3TiZKlTN+mxfaWaSrdrM0mTEqV55QdJ8p1bDIgUiWt/0WuJ1ytx7aNS3rbBLg4ARJSgBnl33323Tj/9dJ1xxhnu9vjx4/X+++/rwQcf1G233dbs/XJycpSRkdGBJQWAdrZ+lbRythYs+MllNJIPfV2Sx+1asrpM17y/XI/QjA0RLLZ6vbaNXaAF1euDXRQAiDhBC/IqKys1Y8YMXXnllT7bR40apc8//7zF+26zzTYqLy/XVlttpWuvvVZ77bVXgEsLAO0rv7RCOZIunjRLcz1FTfanJHRXZqdEqh0AAIRPkFdYWKiamhp17+7bFMlur1y50u99evbsqUceecT13auoqNAzzzyjffbZx/XV22OPPfzex46zxau4uNita2tr3RIqrCwejyekyhTpqHPqPJiK1leqm2J12X4DlT3QRhf0ZQFez7SkTf5O4DzveNR567i/eYptl7991HnHo86p82hQG4LX560tS9BH17SBUxqyimy8zWvQoEFu8dp55521ZMkS3Xnnnc0Gedbsc9y4cU22FxQUuGxgKL1hRUVF7vXHxgZ9PJyoQJ1T58FUWlal/LThykyJV3b8nz9E1auoUH5+ySY/D+d5x6PON+4z4Nb5+dR5mOE8p86jQW0IXp+XlJSEdpDXrVs3xcXFNcna2Rd94+xeS3baaSc9++yzze6/6qqrdOmll/pk8nr37u0Ga2k4eEsonEQW3Fq5QuUkinTUOXUeTKvWlevmwj10Xs5mrp9xoHCedzzqvHVWl5br34W76MzsTf8MUOcdjzqnzqNBbQhen9uMBCEd5CUmJrpmlx9++KEOP/zw+u12+7DDDmv143z77beuGWdzkpKS3NKYvVGh8mZ52UkUiuWKZNQ5dR4snuRMvVO7k85Nzgz4Z57zvONR5xtWm5KpybW7aWRJgmpX+P9l2pot52WkUOchivOcOo8GMSF2fd7acgS1uaZl2E488URtv/32ruml9bdbvHixzjnnnPos3LJlyzRx4sT60Tf79eunIUOGuIFbLIP36quvugUAwknc+gKdHveO4tZbE/T0YBcH6HBdY4p1euJU3fRicbPz5aUkxGnqZSNbHegBAEIgyDv22GO1atUq3XTTTVqxYoWGDh2qKVOmqG/fvm6/bbOgz8sCu8svv9wFfikpKS7Ye+eddzR69OggvgoA2HgJ61fquoTntGD93yQNoAoRdXpqla6LfUJ//euRbhqRxhbkl2rsi7O0Zl0lQR4AbKSgD7xy3nnnucWfp556yuf2FVdc4RYACJsJz20+PK/uQ6S4BGn1r0pauyCYJQNCxoDszlIu2WwAiKggDwAi0tolqr1/B8VWl9Vv+vGEb1WT0lV93v+7ei+eqvWeJNUkZwW1mEDQlayQNEKqrZFWzqnfnFxYqlwVBrVoABCuCPIAIADy85crp7pMF1eepwWePLdt3mNzVK149Yk5SF20l8riM/RM9/7UP6JTalcpIVX66hFp0IFS5TrpkZH1u60R8+fJ0rxSm0eSTB8AbAyCPAAIgPyULbR3+WO65Zi/6Mzu6Zs8ciAQcTJ6S+d/JdVU1t1O7CSdNa1+9y+/r9XZL83T+NTATTECAJGKIA8AAiE2TqVK1YDu6RqaRxYCaDbQa/CZUe6I+ptlniIt8KyTYhOoPADYSKEx4QMARJjEooWamHCbWwNow2eoeJEeTbjTrQEAG4cgDwACILaqVHvEzXFrAG34DFWWaL+4mW4NANg4BHkAAAAAEEHokwcAm2Dl4vkqXfN7/e2qzr1Vk5yh4pXLmOIcAAAEBUEeAGxCgJf2+K7qEVNRv21s5Xl6vXY3jY1/T7vES50zu1O/wCZYsrpM5cuKmmxndFoAaB5BHgC0UXFJiZZ7eqvqLxepa97mbtvZnXvrjOQMxZUN1srEq9WjzxbUL9AGnbr10b9qT9Qr7xeo8P3PmuxPSYjT1MtGMg0JAPhBkAcAbVSZsbmOqLxJb2+9mwY0mSaBaROATdEzr49OvPQOHbzuj3n0GliQX6qxL87SmnWVBHkA4AdBHgAACD1la5T38yvK67aFlJxRty0hRcoe5P7bU6uCWz4ACGEEeQDQRsmFc7Qo+W9aUPiOlLcb9Qi0p4pSacrlvtt6DJfO+VRxZav0SdIlWlS6PVlzAPCDIA8AWrJ2ibT+j4xBSoaU2U+qKpcKflLS2gXUHRAoGb2lsd//+fnzZvJstW65kmKqFVe+mvoHAD8I8gCgOWuXqPb+HRRbXVZ3c8DhWrrXvUosWqSBL41Ub0nrPUmqSc6iDoFABXq2AAA2CkEeADQjP3+5cqrLdHHleVrgyVPR3E5a+v1nSlKlBsT80x1TFp+hZ7r3pw4BAEDIIMgDgGasjsnU89VH6IBDjlXvPv4DOebqAgAAoYYgDwCaUZ3aXeOrj9LbffpraJMpEgAES0XGFtqv4nZdWNXTTZTu8dRqfdE6FVQXKSYmlh9fAEQ9gjwAUW/F0oVaFVPXry5p9TzF1NbNy7U2v0BjYr9SbOXWjOAHhJCM9DQtje+ri175yd2OlUeDMz36cU2MahXDROkAoh5BHoCotnLxfCU9vpdOqrhDq5WmTxIvUb/Y392+AZJ2S5RWxp0W7GICaCBPBfpm+BtaOuwCVXXp9Ucmb7VS07P0S8F6JkoHEPUI8gBEtdI1v2tATInu2r+bsgfuqKrVz2rBH5k80zmzu3r02SKoZQTQyPrV6jT3eQ0atJcUU6XaTtnKj++knPRYpaxaqFwVUmUAohpBHgBI6p2VogHW7y5vR+oDCHWpXaWEVOm1M+tu73qJNOwcacV3GjD5EE1NStKS0h1oZg0gahHkAYiKJpmWsWuoOrmbqjv31Jr8Va5ZJoAwYnPnnf/VnxOlp2ZL5ZJ6bq0le92r3h9fzETpAKIaQR6AiLascLWmPXa1/hb7gc/2x6oP1C3VJ2rf2O+0e2Jds0wAYTpRem2tVJ4vJXVRRQY/2wAAQR6AiLamIk53Vh6hnvuf5Zpkeu2W3E1vd+6p2KpttDL2r/S7AyKEJzZBKzxZWry2yk2v4A/zWwKIdAR5ACLCiuWLtcpTN5dd8qq5kqfW/X91wWoNjV2onM320oC+Pfzck/nvgEiS2nu49q59UGXvrpf0md9jUhLiNPWykcrL+POHHwCIJAR5ACKiz926x8fopIpr3TQIc5JOV5eYMrfPGm7tYdMgxBwtyV+QByCSWOD20blDtK7gN5/tlWn9VZvYWUt/+0U3vTlHa9ZVEuQBiFgEeQAiZBqEpfXTIPy+6jX9/kcmzzANAhBFSlaq5wujpJLlvttPflvK213dv3pZU5MeZ/RNABGNIA9AWI6SWZ3aXdWpOYqtKNL6375vNA3CLkEuKYCg6dJDOv2DP0fe9Oq6uVuV5u2m7O8mMPomgIhGkAcgbAK8tMd3VY+YCnf79qpjNaHmMO0bO0OPJd6l9Z4kRsgE0HTkzUZqkur64S5ZXeZ3YBYGZQEQCQjyAISMZWvWqWzxt022V2QOUv4vi7RXTIW+2fbfyug7VIemdtdol8kbpgUle9MkE0CrpKUkuPWdH8zTgvdLNSBmmc/+svgMPXPZkfTXAxDWCPIAdKhVpRUqqC5STEys7/Z1lbrwmS81O+6EJvfZqfz/VKkE3Zr0F40YsU+j6Q7sV/k+HVByAJEgJydX64b8TXduM1rxZYXa4tVTfPZXeOK16PftpIzBQSsjAGwqgjwA7WrZ2jI3ap0/haUVuu+t7zWr0KN0lSg3xrfPTJf4bM044HWl//FLu9fjmYPkiUtUVvw+6tE9h3cMQNtl9Fanw+7U4MROUlVP6axp9bsWFJTqmBeWaGLnXGoYQFgjyAPQboGcZePGPfO+UqrX6gdPX3kUq/4xK5Sqcre/a0yJRnVdr0v/erz6F36ivE+v8bl/Rd7OShr+vJSaxbsCIHAswDMJKVLuiPrN5Z4irVaRFuSXNntX+uwBCAcEeQA2KhvXMJArVqqWeLorQdUaGLNEXWOK9XbCeKUmVWjuafPliUtS/7ePUacVX7r71ipW+THDldPnTMUOOFoavJPPYyeldiXAAxA02RWLNCXpat378uFa6unmti3xZKtYndVNReoes5o+ewDCAkEeEKVak43zWuLJUbE6KVtrNTj2t/pArqj/aC3Z9yHFl67Qli+c5I6tjU+RjntVQ3p1k2JjpSMfkCr/+FXc47FRDaT0XnX7OnXtuBcMABvQPStL2Qm/6+GYe+q3Ld5ngoo3201dZz+qnv+72Y3k++ncQVrTb2CT+5PlAxAqCPKAKM/GeXkUox88/ZSrQn2efJEU9+fxv416TCV9d1O3Wferx9e31wdy6VmbKz0rXapOqe/XEmvZuIZDl3cb8Of/a2ul/PxAvFwA2HQZvRV7wdc+c+z1yewrpaRL6SdpdWYPZb13via9874+rs1XvKo1KGZJ/bGMzAkgVBDkAWEcrJmkVT8qxlPts21FfC+dNeknpVfluyaUDa3xdHHrxoFcTUJn/XjKD4orW6WqKQOVMPo2KbWuuVLfzH51FzlpZ0jbHNQ0kItP9OnXAgARN8de5xxlbTlStVNTdG+fb7V4/wvd9+XgZ+taMZiWsnyGTB+AjkKQB4R4xu2cZ2YorqpEfWN+99lnUwrM9/TSjKSz3YAmDV1RcaMUP1ivbD1TveY96fuYW52klX+5RoVrXlC3zMy6gQckxcXEamhPm44gXTptitQ5u2mBunSvWwAgijN9abVVGmqtGGpS61sxrF78vcvy3ff2/7RO36nTHwNOea3wdFVZQqYeOnE7de2U2OShCQABtCeCPKADsm3N8TabXFbVSRVKVK+YfKVrnc8x2fFddf8BiRr+SaORKNP6av6xn2r1qle0plEm75b0zZSekam8mGHSSN85oLqmdlXXjB5S39HNF8xfgAcA8M3yxSXUt2LI6jFMy/uP0r8r49X3vZPVZdl0n9qav/0NOvF/Cbr9yRd9tpcpSb96cpWSENdsAGgIAgFsDII8oB0GKrFsW1lVzUbXpbf/27cHvKSEfjup18cXK2PBZJ9jiv9ymdJ2GisN/HMuJ5MUn6ShOelSnu8Ilb7ypPS8jS4XAGAjxcYpt3uO3Ax7R4yXKnxbWGyR3ktTur6rrPd9f7Bbn7Otvt73JV31zMdNAsAFnrz6HwC7x5fp6oMG188jWp2ao+rU7oqtLFFWXJl69NmCtwxAPYI8YCOaTTYXyNkvsE+ftmOzv8AmlC5TXPlq1canqjJjc7ctuXCOktYWSB9L2/TOkPLSpYNulMrG+tw3rUsPKTmNPm8AEC661n3PN5a19UFS32E+21ITO2lkfLk+jzvTp5+0+fmY6apM76fsDy9Q90VvSu/9uW989REaX32UxsR+pvGJEzR7zyeUmtldnthEVWQNarbPdmX6ZqpN6ORGRY4vL1RNcpaqOvv/MZDsIRC+CPIQtc0mPZ5arS9ap4LqIq1eX73BbNxmCWt0x5i8+l9Ry7O2cr/cJhYtVEZ8hXI6L/vzYJsioFM3af1qaflM6ZUTpar1Uq8dpDOm1h3z6EF164RUKc399ivZACeZbX75AIBQlprV/FygY7/3GdXTDMweJCUkS4fdrPyCC1RcVlW/74DUHO2b2l1lyzKkKRM0/JPT3PZFtd21X2XdFBD++mwfUXGjZnoG6tr4Z3RG/LtusJhzqsZqQW2elqubklWhzWOWu2OT42PrsoepSSrvOsRtS1rzs2JqKuTxeFRaVqWSlfNVldZXtUnpil+fr/j1vv3HaxLT3P6YmkolrZnX5GW7x42JVeLaXxVbXdddoaXAMxKDT7t2KSlY4uqvoZrEdFWl9VFMdbmS1s73qfOYmBiVd6v7wSBx7S+KrV7vc9+qzr1Vk5zhBgdKWFf3fnrVJnRWZXp/qbZGyat/aFKe8qwtpdgEJRYvcplin8dN7aGa1GzFVqxVYsmfI8saT1yyKjLrMsrJhd+7cbsbqsjYQp74ZCWULFVcxRqffdUp2aru1EOxlaVKLF7o+7ixCaqwMtn5t/onxdT++TkwlWn9VZvYWfHrViq+rMC3DpMyVdWlV30d+rI6HBpx55MXQR6ittlkrDwanOnRj2tiVKsY9Uoo0b1jutcHcaY2sYsq0/opofg3DXrxbz6/ourKJXUZto/GSb985Pvgo++UdjxTmv+hNPmsukDuhFeljL5/HvNHZ301HqkSABB9mhvV02T2U44t/vbl7aqVPb5R6Zq64MoyeW//kclrrs92XSZvcy1a8zf1mXqWJsb82w3KtWLXW1wrkwGTT/3zDu9JJZ4UDat43N38IPHv2iJ2mWoVq/y04copnq2zKi/R1NrtdF7cG7oiwbfJ6Ts1O+r8qrHqoVX6MvnCJsUfWP60G0hsUuLN2in2x/rtB1X8U3M9/ZWpYuXG+Aa/1irmyhMPUdfUeCWvmtvkMSsyB8kTl+j+dsdV+o4wbU1cralrbEWREksW++zzxCWpIrNuZFT3uJ5a38fNGCBPfEp96xyfx03upurOPRVbtU6JRb/6Pm5MvCq6Dnb/T1o9TzG1f17DFJVV6ex31ugEz1saG/+az/0m1+yqS6rOV9+YlZqWdKlPnceqVv3Kn3fHvZZ4vbaNXeBz37GV5+n12t10YtwHujnhKZ9902uG6aSqq9RZ6/V98hlN6m/b8oe0Wml6NOFO7Rc302ffzVXH6/GagzQ69ktNSLzPZ9/3tf10cOWt7v/zkk5SUozvubdfxe1uwLh/xT+i4+I/8dk3ofpQ3V59nHaK/UGTEm/x2bfCk6X9Ku53//8i6QL1jPGt++Mqr9WXtVvpivhJOi/+TZ99k6r31JXVZ2mLmKX6MOkKn30VnngNqpio3IR1+r+Dsn2u/yq79FZtUoZi1+UrpqJEOTl+P30hLcZjPwtEkeLiYqWnp6uoqEhpaWkKFbW1tcrPz3cnUaxNEh3l2hrIbajjuklaM18xNeX1v4h1Tklwv5TlLXpN6dNv9D144IHS3yZJ+T9JE/5SF6j9Ma2AegxzmTyt+qVJ3wufTN7axQRyf+A873jUOXUeDTjPN8HaJXUZRO8PjpXrpcKf3a780oq67GFMbLOZvLq/oe2XyYsvW61+752olTtcocIRFyjzpxeU9+k/fO7zlWcrHVNxrRJVpZ+TT27ymDuV/59WqqseSBivg+K+8tl3e9WxmlBzmPaNnaHHEu/y2fdzbZ5GVd7h/j8n6XR1iSnz2e8NPG+Kf1InxX/os++x6gN1S/WJ2jbmZ72W5HstscrTRdtVPOz+/0niJeoX61tHZ9RcpdOPOkTZWtOqTJ7VOZm89snk5cd0Vcarx2qrmEU+e86rvEhTanfSFfEv6ois3+Q58lH17Ot/apRQjWUI8kJEtP2B2tT+bxbIddfqJh/mzpk56tFnoFRVJhU0+mMSEyP13Fp6aHdp5WzfX8SOfkLqu6tU7NukwWXqsjaTaqqkkpVk3DZRtJ3noYA6p86jAed5hNW5BZ7WAqZTV2ndKqnIt1ng7xXxKkjs7TJt4Z7JM6k9BrpBezaE8zwwVi6eX58Jb5zJK5o9RZv/+JBK9r5FW4zYXeEU5AW9ueaECRN0xx13aMWKFRoyZIjGjx+v3XdvvhKnTZumSy+9VHPnzlVubq6uuOIKnXPOOR1aZmz6tAEbalbZJ6FYN5+2r8vINWx/bV+e6bVr1bVvsvTpC9Jndf0O6m1zotTnfmnNIumRkb774hKl6wqkIx+rCwItiV1UJqWnSFk22Xemm+zWLxsmmyaVAAAEXsO/txbo2dKAzdZaP2Nrr92af5y84S08ic0L26eF++6ygfu2tC+3hcfdsYX7Ihh62Mi0zYxOO7+gl/RnK+KwEtQg78UXX9TYsWNdoLfrrrvq4Ycf1oEHHqgffvhBffo0/eAtXLhQo0eP1plnnqlnn31W//3vf3XeeecpOztbRx55ZFBeQ6TblP5vNj1AZkxJ/RDQeSpQRkyp27eVdeYeM1idsnKbdLS1phq9PxunuLz9pE7p0qRTpJJGGbaB30s7niVtNcZ3u7dDuw1g4u3z1jCTZ6wju6mtleLyJWtnTVYJAAAAESKoQd7dd9+t008/XWecUdfp07J477//vh588EHddtttTY5/6KGHXPBnx5nBgwfrm2++0Z133hnVQV5bM2qmcZODhiMqlRSt1q3v/Kjy6rrmCr97slSodKWpVL1jCuoDNeuo2nhEpfiyVeoz9R+KrS7T/CM/dMM5506/QlnzJv355DaIyW6XSPveKC2cLU0+2Ldwlm0zJ7xS11zSq+FAJd5RKZu8sBSmHAAAAECb2QB839Zurs0SuyjcBC3Iq6ys1IwZM3TllVf6bB81apQ+//xzv/f54osv3P6G9t9/fz3++OOqqqpSQsKfo+KEozUFy+uHxfXX4bYxGzrXMmr/euatJkPnLvVkq0idlaVi9Ww0KtU6JWuRp6ebXPWzpLEtjqj0qs3Z88e8PSv+cp1WDT9Iab++rT7/+WMyV+9okz2GS+d8Wvf/J8ZINZX1I0puYXMCWdB14DXSyHN9X4S3eWTuCN/MW8NArntdZ28AAACgo1Sm9dX9NYfrX2kNRkcPE0EL8goLC1VTU6Pu3etbVTt2e+XKlX7vY9v9HV9dXe0er2fPnk3uU1FR4RYv66Ro1q5d6zqwhorfl/yi6rcuV/eS79ywuN5hh6+pOsMFY28nXdvkPiPKH3HrZ5Lu17AY306+y3a7VcWb76TMH19Uj6/rhrP1Kum5s5bu95Cb32Tt5Bgt3udB1STXTc72gHU4trnfSm7Wt5Wl6pKSoG5/jFSZ0rmnenXySAN21drst30LY0Hc2rV1/z9mcl1/t5QsKT1PWmf1b0ualNqog6i9VO/9Uvv57vNuDxB7/63zamJiIoOAdBDqvONR59R5NOA8p86jAed5xytZu1op5avcem3nP7r9BJldu5oNTZAQ9IFXvFkrLytw420bOt7fdi9r9jlu3Lgm2/v2DYeI3Ibn/VC/WRczv/uPdf/u4Xff+X8s/lj6rUFA9a+/bXpRAQAAgAj0aqMZtkJBSUmJG2Uz5IK8bt26KS4urknWzobjbZyt8+rRo4ff4+Pj49W1q+/IS15XXXWVG42z4a8gq1evdse3FEwGIyrv3bu3lixZElLz90Uy6pw6jwac59R5NOA8p86jAec5de5NcFmAZ7MMtCRoQZ41kdtuu+304Ycf6vDDD6/fbrcPO+wwv/fZeeed9dZbb/ls++CDD7T99ts32x8vKSnJLQ1lZGQoVFmAR5BHnUc6znPqPBpwnlPn0YDznDqPBmkhdn3eUgbPK6izEVuG7bHHHtMTTzyhH3/8UZdccokWL15cP++dZeFOOumk+uNt+2+//ebuZ8fb/WzQlcsvvzyIrwIAAAAAQkdQ++Qde+yxWrVqlW666SY3GfrQoUM1ZcqU+v5yts2CPq/+/fu7/RYMPvDAAy5Ned9990X19AkAAAAAEFIDr9hk5rb489RTTzXZNnLkSM2cOVORxpqU3nDDDU2aloI6jySc59R5NOA8p86jAec5dR4NksL4+jzGs6HxNwEAAAAAYSOoffIAAAAAAO2LIA8AAAAAIghBHgAAAABEEII8AAAAAIggBHkAAAAAEEEI8gAAAAAgghDkAQAAAEAEIcgDAAAAgAhCkAcAAAAAEYQgDwAAAAAiCEEeAAAAAEQQgjwAAAAAiCAEeQAAAAAQQQjyAAAAACCCEOQBAAAAQASJV5Spra3V8uXL1aVLF8XExAS7OAAAAADQKh6PRyUlJcrNzVVsbPP5uqgL8izA6927d7CLAQAAAABtsmTJEvXq1avZ/VEX5FkGz1sxaWlpCqUMY0FBgbKzs1uMykGdhzPOc+o8GnCeU+fRgPOcOo8GtSF4fV5cXOwSVt6YpjlRF+R5m2hagBdqQV55ebkrU6icRJGOOqfOowHnOXUeDTjPqfNowHlOnTe0oW5nRBMAAAAAEEEI8gAAAAAgghDkAQAAAEAEIcgDAAAAgAhCkAcAAAAAEYQgDwAAAAAiCEEeAAAAAEQQgjwAAAAAiCAEeQAAAAAQQQjyAAAAACCCEOQBAAAAQAQhyAMAAACACEKQBwAAAAARJOyCvAcffFDDhw9XWlqaW3beeWe9++67wS4WAAAAAISEsAvyevXqpX/961/65ptv3LL33nvrsMMO09y5c4NdNAAAAAAIuniFmUMOOcTn9j//+U+X3fvyyy81ZMiQoJULAAAAAEJB2AV5DdXU1Ojll1/WunXrXLNNfyoqKtziVVxc7Na1tbVuCRVWFo/HE1JlinTUOXUeDTjPqfNowHlOnUcDznPq3LQ2VgjLIG/OnDkuqCsvL1fnzp01efJkbbXVVn6Pve222zRu3Lgm2wsKCtz9Q+kNKyoqcoFebGzYtaINS9Q5dR4NOM+p82jAeU6dRwPOc+rclJSUqDViPBZVBNBpp53md3t6eroGDRqkE044wQVqG6OyslKLFy/W2rVr9eqrr+qxxx7TtGnT/AZ6/jJ5vXv31po1a9zALaH0wbXAMzs7myCPOo9YnOfUeTTgPKfOowHnOXUeDWpD8PrcYpnMzEyXHGoplgl4Js+CKX8WLlyo5557TjfffLM+/fRTbbbZZq1+zMTERA0YMMD9f/vtt9fXX3+te++9Vw8//HCTY5OSktzSmL1RofJmecXExIRkuSIZdU6dRwPOc+o8GnCeU+fRgPOcOo9tZZwQ8CDPmlI2p6ysTCeddJKuvPJKvfTSS21+DktGNszWAQAAAEC0CmqfvJSUFP3jH//QEUcc0er7XH311TrwwANdk0trkzpp0iR98skneu+99wJaVgAAAAAIB0EfeCUrK8v1rWut33//XSeeeKJWrFjh+vXZxOgW4O23334BLScAAAAAhIOgB3mff/65Nt9881Yf//jjjwe0PAAAAAAQzgIe5M2ePdvvdhsRxgZMufXWW3XLLbcEuhgAAAAAEBUCHuSNGDHCjQTkb6YGG47U+uSdc845gS4GAAAAAESFgAd5NlWCP9afLiMjI9BPDwAAAABRJeBBXt++fd3apjiorq5Wp06dAv2UAAAAABC1Aj7rdmFhoQ466CB17tzZzcq+yy676Ndffw300wIAAABAVAp4kHfVVVdpxowZGjdunO644w4X9J199tmBfloAAAAAiEoBb675/vvv64knntDo0aPdbVsPHTpUVVVVSkhICPTTAwAAAEBUCXgmb/ny5dpmm23qb2+55ZZKTEx02wEAAAAAYRbk2dQJ8fG+CUO7XVtbG+inBgAAAICoE98RQd4+++zjE+itX79ehxxyiMvoec2cOTPQRQEAAACAiBfwIO+GG25osu2www4L9NMCAAAAQFQKSpAHAAAAAAjTPnnl5eV68803VVJS0mRfcXGx22cTpQMAAAAAwiDIe/jhh3XvvfeqS5cuTfbZ5Oj33XefHn300UAXAwAAAACiQsCDvOeee05jx45tdr/tmzhxYqCLAQAAAABRIeBB3vz587X11ls3u3/48OHuGAAAAABAGAR51dXVKigoaHa/7bNjAAAAAABhEOQNGTJEU6dObXb/hx9+6I4BAAAAAIRBkHfaaafp5ptv1ttvv91k31tvvaVbbrnFHQMAAAAACIN58s466yxNnz5dhx56qLbccksNGjRIMTEx+vHHH/Xzzz/rmGOOcccAAAAAAMIgk2eeffZZTZo0SQMHDnSB3U8//eSCvRdeeMEtAAAAAIAwyeR5WcbOFgAAAABAmGfyAAAAAAAdgyAPAAAAACIIQR4AAAAARBCCPAAAAACIIAEP8nJzc3Xuuefq3XffVWVlZaCfDgAAAACiWsCDvOeff16pqam66KKL1K1bNx199NF65plntHr16kA/NQAAAABEnYAHeXvuuafuuusuzZ8/X1988YW23XZbPfDAA+rZs6fbd8899+iXX34JdDEAAAAAICp0aJ+8IUOG6KqrrtKXX36pxYsX6/jjj9dHH32kYcOGaejQoXrnnXc2+Bi33XabdthhB3Xp0kU5OTkaM2aM5s2b1yHlBwAAAIBQF7SBV7p3764zzzxTb731lgoLC3XzzTcrKSlpg/ebNm2azj//fBcofvjhh6qurtaoUaO0bt26Dik3AAAAAISyeIUA67N3+OGHt+rY9957z+f2k08+6TJ6M2bM0B577BGgEgIAAABAeAiJIG9TFBUVuXVWVpbf/RUVFW7xKi4uduva2lq3hAori8fjCakyRTrqnDqPBpzn1Hk04DynzqMB5zl1blobK4R1kGdB0aWXXqrddtvN9elrrg/fuHHjmmwvKChQeXm5QukNs4DVXlNsLNMXUueRifOcOo8GnOfUeTTgPKfOo0FtCF6fl5SURH6Qd8EFF2j27Nn67LPPmj3GBnqxQLBhJq93797Kzs5WWlqaQukkiomJceUKlZMo0lHn1Hk04DynzqMB5zl1Hg04z6lzk5ycrJAP8uxktRE1H3/8cb3++usbdd8LL7xQb775pqZPn65evXo1e5wN5uJvQBcLpEItmLIgLxTLFcmoc+o8GnCeU+fRgPOcOo8GnOfUeWvjhKBEEzZnnmXYLDg75phjNuq+li61DN5rr73mpl/o379/wMoJAAAAAOGmwzJ5ZWVleumll1zWzqY/qKmpcROhn3baaercuXOrH8emT3j++ef1xhtvuLnyVq5c6banp6crJSUlgK8AAAAAAEJfwDN5X331lc466yz16NFD999/v4488kgtWbLEpRr33XffjQrwzIMPPug6QO65557q2bNn/fLiiy8G7DUAAAAAQLgIeCZvl112cf3nLNgbNGjQJj+eNdcEAAAAAAQpyNt7771dE838/HydeOKJ2n///V2nUQAAAABAGDbX/OCDDzR37lyXxTv33HNd08qLL77Y7SPYAwAAAID21SGja9q8dNdff70WLlyoZ555xmX14uPjddhhh+nqq6/WzJkzO6IYAAAAABDxOnwKhf32208vvPCCli9f7vrqvfvuu9phhx06uhgAAAAAEJGCNut2ZmamC/K+/fZbff3118EqBgAAAABElA6ZJ6+2tlZPPfWUm8B80aJFri+eTWJ+1FFHucFYtt12244oBgAAAABEvIBn8mzKg0MPPVRnnHGGli1bpmHDhmnIkCH67bffdMopp+jwww8PdBEAAAAAIGoEPJNnGbzp06frP//5j/baay+ffR999JHGjBmjiRMn6qSTTgp0UQAAAAAg4gU8k2eDrNgImo0DPO8celdeeaWee+65QBcDAAAAAKJCwIO82bNn64ADDmh2/4EHHqjvvvsu0MUAAAAAgKgQ8CBv9erV6t69e7P7bd+aNWsCXQwAAAAAiAoBD/JqamrcxOfNiYuLU3V1daCLAQAAAABRIb4jRte0UTSTkpL87q+oqAh0EQAAAAAgagQ8yDv55JM3eAwjawIAAABAmAR5Tz75ZKCfAgAAAADQUX3yAAAAAAARlMmz+fFiYmKabE9PT9egQYN0/vnnq3fv3oEuBgAAAABEhYAHeSNGjPC7fe3atZoyZYruv/9+ffbZZ80eBwAAAAAIoSDvnnvuaXG/ZfKuvvpqF/ABAAAAAMK8T97ZZ5+tb7/9NtjFAAAAAICIEPQgLyUlReXl5cEuBgAAAABEhKAHeR988IEGDhwY7GIAAAAAQEQIeJ+8N9980+/2oqIiff3113r88cf11FNPBboYAAAAABAVAh7kjRkzxu/2Ll26aMstt3QB3tFHHx3oYgAAAABAVAh4kFdbWxvopwAAAAAAhEqfPAAAAABAGAV5H330kbbaaisVFxf77Zc3ZMgQffrpp4EuBgAAAABEhYAHeePHj9eZZ56ptLS0JvvS09PdPHl33313oIsBAAAAAFEh4EHed999pwMOOKDZ/aNGjdKMGTMCXQwAAAAAiAoBD/J+//13JSQkNLs/Pj5eBQUFrX686dOn65BDDlFubq5iYmL0+uuvt1NJAQAAACD8BXx0zby8PM2ZM0cDBgzwu3/27Nnq2bNnqx9v3bp12nrrrXXqqafqyCOPbMeSAkDkW7x4sQoLCxVqunXrpj59+gS7GAAARISAB3mjR4/W9ddfrwMPPFDJyck++8rKynTDDTfo4IMPbvXj2ePYAgDhriMCLo/Ho/Lyci1btsw91xFHHKH169cr1KSmpuq1115TdnZ2uz4uwSMAIBoFPMi79tpr3R/ugQMH6oILLtCgQYNcM8sff/xRDzzwgGpqanTNNdcEuhgAEFLZLWum3hEBV2xsrLbbbjvX99nmLbVg6r333mv3YKo96qKl/tvBCB4JEAG09u9ES98X7fU3puGPdnYtHYn43g2jIK979+76/PPPde655+qqq65yJ6ixk3P//ffXhAkT3DGBUlFR4RYv71QOdrETShO1W1msbkKpTJGOOg+/Ol+yZEm7B2MWYBx99NFByW5ZAPLuu+8GNODyXhRYSwr73rU/oL1791ao+eGHHwL23lqLkra+Py+//PJGvz/eOl+6dKnfC7FQfQ/CWTR8nwfi+29TbOg8jySt+TvR3PdFe/6NsR/ttt12W82cOTNiz/W2fu9uim4tfCeH4ndLa8sS4/FGXR1gzZo1WrBggausLbbYQpmZmZv0ePalMnnyZI0ZM6bZY2688UaNGzeuyXYLLlNSUhQqrE6qq6vdQDSR/mUZKqjzwLAfVexcbunLyf5QbSx7zPnz5wfki9bKY99J9vnrSPZ8SUlJAX2OaD/PN3Q+Bup869Spk+tD3t7nW0ecM+EoVM7ztp5vwfz+2xQtneeRpqXP7Yben/b8G9PWv6HhIFjneewG3h/7TrGYIVT+hlp3t/POO8/NN+5virqgBHntrTVBnr9MnkXrFnC2VDEdzU5o+7XHfrmI1A9vqAmXOm/rr7ebki1o63Nu6BfLTf0VMlC/8EVyZiVczvNQ1NbPQePsaXv+qs9noH3O83BsFRCMDEdbz/NItKG/Ey2dU+31NyYavs87OmNd0Irrlp133lkTJ04MmcHBLJaxRNmGgryO/dk6COwXT3+/etqbFmofEPuSDMVyRbJQr3Nrx7/VVlu16aKhrX2RNrWvmD3vlClT/D7vpl4U0FY/Ms/zUNW3b1+3tOVCLD8/Xzk5OX7rfO7cuW3+EcU+m4EYfCxQA990FO93y/Llyzf43RLI/rAtff9tqlD7/tvQeR5t2vp9sbEi/fu8o+qxtd/JNobIvffeq1WrVqlfv34KBa1978MuyCstLXVNPr0WLlyoWbNmKSsrK6S+/ID2YF86diHy7LPPavDgwR02kMWmDM7R0oUIFwWA3OejrX+v7IIjEBmoQA1801EaDzC0IYEagCjUAjEAm/adHMYNHsMvyPvmm2+011571d++9NJL3frkk0/WU089FcSSAW3T0qhbdkFnLMCzZo4ddTHIhQoQeQFiRwePHWljWwnwHQcg0oVdkLfnnnuGdVQNNA7wLIDb0IhddkESKheDACJPuH9f0EoAAMI8yAOirTkmvzgDAABgYxDkAUFskrkpzTEBAAAAfwjygAD3q9vQSG5tbY4JAAAA+EOQF+VaCk4MTQU3XFetGY67pZHcqGMAAAC0J4K8KNbaQT+sSWE4d8jvqGxcS8NxE8gBAACgoxDkRbENDfphwd0JJ5zgjouUIK9hIOcdcnvZsmVuG9k4AAAARAKCPITdoB8bamLanMbZuMaT55KNAwAAQCQgyMMGeUeADIUmiK1pYtqShoFc48lzaVIJAACASECQF0Is02RNBy3gaCwYAYg9pwVF1mSzo/vrtTTlwIbmlWtJw3pk8lwAAABEIoK8ELFkyRKdd955+vzzz13w4S+geu211zp0dEZ7TAuqmgu2LPj79NNP2zSJ96YOcrL77rtHTD9BAAAAoD0R5IUIC3gqKio0ceLEJkGTN+g54IAD/N63pQCwLc0wG7JAyl8wtaEsX0vlYsoBAAAAIHAI8kLMlltu6XcQlOYyahsKADekrRNxt5Tla025GOQEAAAACAyCvDDRXEbNtBRsbcimNPVsqUwbKheDnAAAAACBEXVBno2oaIqLixVKSktLVVNT49YbW7aMjAy3tFWg6mJD5Qr2e2B9H0tKStzomjadAqjzSMR5Tp1HA85z6jwacJ6H1/V5oHjL4Y1pmhPj2dAREWbp0qXq3bt3sIsBAAAAAG0etLFXr17N7o+6IM9+BVm+fLm6dOnid6qCYEblFnzaG5aWlhbs4kQF6pw6jwac59R5NOA8p86jAec5dW4sdLOWaLm5uS22RIu65ppWGS1FvcFmAR5BHnUe6TjPqfNowHlOnUcDznPqPBqkhdj1eXp6+gaPoSMSAAAAAEQQgjwAAAAAiCAEeSEiKSlJN9xwg1uDOo9UnOfUeTTgPKfOowHnOXUeDZLC+Po86gZeAQAAAIBIRiYPAAAAACIIQR4AAAAARBCCPAAAAACIIAR5IWDChAnq37+/kpOTtd122+nTTz8NdpHC1o033ugmuW+49OjRo36/dUG1Y2wCyZSUFO25556aO3euz2NUVFTowgsvVLdu3dSpUycdeuihWrp0aRBeTWiaPn26DjnkEFeHVr+vv/66z/72quM1a9boxBNPdHPB2GL/X7t2raLRhur8lFNOaXLe77TTTj7HUOetd9ttt2mHHXZQly5dlJOTozFjxmjevHk+x3Ced3ydc563rwcffFDDhw+vn/9r55131rvvvlu/n3O84+ucc7xjvmtiYmI0duzYyD/XbeAVBM+kSZM8CQkJnkcffdTzww8/eC6++GJPp06dPL/99htvSxvccMMNniFDhnhWrFhRv+Tn59fv/9e//uXp0qWL59VXX/XMmTPHc+yxx3p69uzpKS4urj/mnHPO8eTl5Xk+/PBDz8yZMz177bWXZ+utt/ZUV1fznng8nilTpniuueYaV4f2FTJ58mSfemmvOj7ggAM8Q4cO9Xz++edusf8ffPDBUfkebKjOTz75ZFdfDc/7VatW+RxDnbfe/vvv73nyySc933//vWfWrFmegw46yNOnTx9PaWlp/TGc5x1f55zn7evNN9/0vPPOO5558+a55eqrr3bXI/YeGM7xjq9zzvHA+uqrrzz9+vXzDB8+3F1ve0XquU6QF2Q77rijO3Ea2nLLLT1XXnll0MoU7kGefej8qa2t9fTo0cN9mL3Ky8s96enpnoceesjdXrt2rfvCteDba9myZZ7Y2FjPe++91wGvILw0Djjaq47tBw977C+//LL+mC+++MJt++mnnzzRrLkg77DDDmv2PtT5prEfiqzep02b5m5znnd8nRvO88DLzMz0PPbYY5zjQahzwzkeOCUlJZ4tttjCBWkjR46sD/Ii+fuc5ppBVFlZqRkzZmjUqFE+2+32559/HrRyhbv58+e7lLs1gT3uuOP066+/uu0LFy7UypUrferb5j0ZOXJkfX3b+1FVVeVzjD3W0KFDeU9aob3q+IsvvnBNHf7yl7/UH2PND20bnw3/PvnkE9fMbeDAgTrzzDOVn59fv4863zRFRUVunZWVxXkepDr34jwPjJqaGk2aNEnr1q1zTQj5Lu/4OvfiHA+M888/XwcddJD23Xdfn+2RfK7HB+VZ4RQWFroPeffu3X1qxG7bCYeNZx+uiRMnugvd33//Xbfccot22WUX17baW6f+6vu3335z/7djEhMTlZmZyXvSBu1Vx7a2gKUx28Zno6kDDzxQRx99tPr27ev+YF133XXae++93R8m+2NFnbedJU8vvfRS7bbbbu4POud5cOrccJ63vzlz5rgAo7y8XJ07d9bkyZO11VZb1V+U8l3ecXVuOMcDY9KkSZo5c6a+/vrrqLpuIcgLAdYBtPEfuMbb0Dr2Bek1bNgw90W6+eab6+mnn64fiKIt9c17snHao479Hc/74N+xxx5b/3+7KN5+++1dwPfOO+/oiCOOoM43wQUXXKDZs2frs88+a7KP87xj65zzvP0NGjRIs2bNcoNDvPrqqzr55JM1bdq0+v2c4x1X5xbocY63vyVLlujiiy/WBx984AY4bE4knus01wwiG6EnLi6uSYRvzawa/6KAtrERkCzYsyac3lE2W6pvO8aa0doISbwnG6+96tiOsUxsYwUFBXw2WqFnz54uyLPznjpvOxtJ7c0339THH3+sXr161W/nPO/4OveH83zTWXZiwIAB7ochG3Vw66231r333ss5HoQ694dzfNPNmDHDXV/Y6PXx8fFusaD6vvvuc//3XndE4nULQV6QP+h20n344Yc+2+22NTHEprMhb3/88Uf3RWl99OxD2LC+7UNrH3Zvfdv7kZCQ4HPMihUr9P333/OetEJ71bFlYK1PzldffVV/zP/+9z+3jc/Ghq1atcr9emnnPXW+8eyXV8smvfbaa/roo4/cec15Htw694fzPDDvg/3d5Lu84+vcH87xTbfPPvu4JrKWPfUuFmAff/zx7v+bbbZZ5F63BGW4FzSZQuHxxx93I/OMHTvWTaGwaNEiaqkNLrvsMs8nn3zi+fXXX90IRzZ0rQ2L661PGz3JRkx67bXX3DC5f/3rX/0Ok9urVy/P1KlT3TC5e++9N1MoNBqh6ttvv3WLfYXcfffd7v/eaT/aq45tKGIb5thGp7Jl2LBhUTuFQkt1bvvsvLfhmhcuXOj5+OOPPTvvvLMb6pk6b5tzzz3XncP2XdJwWor169fXH8N53rF1znne/q666irP9OnT3ffG7Nmz3XD+NlrgBx984PZzjndsnXOOd5yRDUbXjORznSAvBDzwwAOevn37ehITEz3bbrutz5DR2DjeuU0scM7NzfUcccQRnrlz59bvt6FybZoFGy43KSnJs8cee7gPdENlZWWeCy64wJOVleVJSUlxH9DFixfzVvzBgggLNBovNvRze9axzfN2/PHHuyDdFvv/mjVrovJ9aKnO7SJ41KhRnuzsbHfe29xitr1xfVLnreevrm2xedy8OM87ts45z9vfaaedVn/tYd8f++yzT32AZzjHO7bOOceDF+TVRuh1S4z9E5wcIgAAAACgvdEnDwAAAAAiCEEeAAAAAEQQgjwAAAAAiCAEeQAAAAAQQQjyAAAAACCCEOQBAAAAQAQhyAMAAACACEKQBwAAAAARhCAPAIAOsueeeyomJsYts2bNCnq9n3LKKfXlef3114NdHABAOyHIAwCEpIYBSMPlgAMOUDg788wztWLFCg0dOrTJvlGjRikuLk5ffvlli/WRkJCg7t27a7/99tMTTzyh2tpan2ObC9rGjh3rAk2ve++915UFABBZCPIAACHLAjoLQhouL7zwQkCfs7KyMqCPn5qaqh49eig+Pt5n++LFi/XFF1/oggsu0OOPP95ifSxatEjvvvuu9tprL1188cU6+OCDVV1dvdFlSU9Pd2UBAEQWgjwAQMhKSkpyQUjDJTMz0ydj9dhjj+nwww93wdMWW2yhN9980+cxfvjhB40ePVqdO3d22a8TTzxRhYWF9fsts2WB1aWXXqpu3bq57Jixx7HHS0lJccHU008/7Z5v7dq1WrdundLS0vTKK6/4PNdbb72lTp06qaSkZKNf65NPPumCtXPPPVcvvviie47m6iMvL0/bbrutrr76ar3xxhsu4Hvqqac2+jkBAJGJIA8AENbGjRunY445RrNnz3bB3PHHH6/Vq1e7fZb1GjlypEaMGKFvvvlG7733nn7//Xd3fEMWwFlm7b///a8efvhhlyk76qijNGbMGNd37uyzz9Y111xTf7wFcscdd5wLzBqy23a/Ll26bNRr8Hg87r4nnHCCttxySw0cOFAvvfRSq+679957a+utt9Zrr722Uc8JAIhcBHkAgJD19ttvuwxcw+Xmm29u0lftr3/9qwYMGKBbb73VZcC++uort+/BBx90GS/bbsHTNtts4/qwffzxx/r555/rH8Pue/vtt2vQoEHuuIceesj9/4477nBrC+jseRo644wz9P7772v58uXutmUHrbynnXbaRr/OqVOnav369dp///3dbQv2mmuy6Y+V2QJTAAAMQR4AIGRZM0nLpDVczj//fJ9jhg8f7pNhsyxafn6+uz1jxgwX0DUMEi0gMr/88kv9/bbffnufx5w3b5522GEHn2077rhjk9tDhgzRxIkT3e1nnnlGffr00R577LHRr9MCumOPPba+n54Frf/73/9cOVqbCbSmpAAAGN9e3wAAhBAL2izL1hIbabIhC3a8o03a+pBDDtG///3vJvfr2bOnz/NsKGiybY1ZNu/+++/XlVde6ZpbnnrqqRsdbFnTUhsJs6qqymUevWpqalzW0V/ZG/vxxx/Vv3//+tsW6BYVFTU5zvoT2mArAIDIRiYPABCxrKnm3Llz1a9fPxcsNlwaB3YNWbbv66+/9tlmffoas2aVNirmfffd557n5JNP3ugyPvfcc+rVq5e+++47n4zl+PHjXV/BDY2a+dFHH2nOnDk68sgjWyy/BamW2bTmpwCAyEaQBwAIWRUVFVq5cqXP0nBkzA2xpp2WKbPmj9ZP79dff9UHH3zg+s1Zpqw5NtDKTz/9pH/84x+u754NguIdvbJhps5G+jziiCP097//3c1xZ8FaW5pq2mAtNm9ew8XKaJm3d955p0l9LFu2TDNnznR9DQ877DA3KudJJ51Uf9zll1/uHteyjFZ+CyBtBFFrotq4uSsAIPIQ5AEAQpaNhmnNKhsuu+22W6vvn5ub60bMtIDOBjWx4MnmlbMmi7Gxzf8JtKaPNj2CjVhpff6sGaV3dE2bxqCh008/3c2t15YBVyyzZgFYwyxcwyaXFjg2HIDFWx+WmbQ586y/oWURbRoFm0Tdy0YPtaDUMoHWt9AexwK8Tz/9VH379t3ocgIAwkuMx18nAwAA4OOf//ynG3VzyZIlTZpbWuBoo2wmJia2WGs2J59N52BNMUOJZScnT57spowAAIQ/MnkAAPgxYcIE16/NmnjayJk2nULDPnc25YH1w7vttttc884NBXgNH9dG+bR+dMF2zjnnuLIAACILmTwAAPy45JJL9OKLL7o+fTY1woknnqirrrqqfpqDG2+80WX3bMoEay7ZmmDJ+tKVlZW5/9tjtjYwDBSbaqK4uNj935qBtjQYDQAgfBDkAQAAAEAEobkmAAAAAEQQgjwAAAAAiCAEeQAAAAAQQQjyAAAAACCCEOQBAAAAQAQhyAMAAACACEKQBwAAAAARhCAPAAAAACIIQR4AAAAAKHL8P9DOGB9YbtdyAAAAAElFTkSuQmCC", "text/plain": [ "
" ]