From 5922c73c071c60cf2f079c663796818948f255e5 Mon Sep 17 00:00:00 2001
From: kferjaoui <khalilferjaoui@yahoo.fr>
Date: Thu, 28 May 2026 16:23:37 +0200
Subject: [PATCH] feat(ClusterFinderCUDA): async submit_batch/collect API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Eliminate the ~200–300 µs inter-batch idle gap by allowing two batches
to be in-flight simultaneously:
  - submit_batch() enqueues H2D+kernel+D2H without blocking
  - collect() syncs via cudaEventSynchronize (not
  cudaStreamSynchronize) so a queued second batch runs uninterrupted.

- Two ping-pong output slots (NUM_SLOTS=2) with per-slot pinned buffers
and cudaEventDisableTiming sync events.
- find_clusters_batched() keeps its direct implementation.

* Measured: 0.026 -> 0.022 ms/frame (~18%).
---
 include/aare/ClusterFinderCUDA.hpp    | 288 +++++++++++++++++++++-----
 python/src/bind_ClusterFinderCUDA.hpp |  68 +++++-
 python/tests/ClusterFinderCUDA.ipynb  | 178 ++++++++++++----
 src/ClusterFinderCUDA.test.cu         | 156 +++++++++++++-
 src/Makefile                          |   2 +-
 5 files changed, 597 insertions(+), 95 deletions(-)

diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp
index b99ee01..bf8fa3d 100644
--- a/include/aare/ClusterFinderCUDA.hpp
+++ b/include/aare/ClusterFinderCUDA.hpp
@@ -38,9 +38,20 @@ class ClusterFinderCUDA {
     static constexpr int col_radius = ClusterType::cluster_size_x / 2;
     static constexpr int row_radius = ClusterType::cluster_size_y / 2;
 
-    size_t m_output_pinned_capacity =
-        0; // # frames currently allocated in h_output_pinned
-    void *h_output_pinned = nullptr;
+    // Two ping-pong output slots. At most 2 batches can be in flight at once:
+    // the caller submits batch B before collecting batch A, so A and B occupy
+    // separate slots. A third submit() without an intervening collect() throws.
+    static constexpr int NUM_SLOTS = 2;
+
+    void *h_output_slots[NUM_SLOTS] = {nullptr, nullptr};
+    size_t m_output_slot_capacity[NUM_SLOTS] = {0, 0};
+
+    // Per-slot state consumed by collect()
+    bool m_slot_in_flight[NUM_SLOTS] = {false, false};
+    size_t m_slot_n_frames[NUM_SLOTS] = {0, 0};
+    uint64_t m_slot_first_frame[NUM_SLOTS] = {0, 0};
+    int m_slot_streams_used[NUM_SLOTS] = {0, 0};
+    int m_next_slot = 0;
 
     // Pointer registered via cudaHostRegister by the caller (for pinned H2D
     // speed). The class tracks it only to unregister in the destructor if the
@@ -72,10 +83,15 @@ class ClusterFinderCUDA {
     float m_total_kernel_ms = 0.0f;
     size_t m_frames_processed = 0;
 
-    // Per-frame kernel timing event pool. Sized lazily to the largest batch
-    // seen; one event pair per frame slot.
-    std::vector<cudaEvent_t> m_kernel_start_pool;
-    std::vector<cudaEvent_t> m_kernel_stop_pool;
+    // Per-slot kernel timing event pools (sized lazily to the largest batch)
+    std::vector<cudaEvent_t> m_kernel_start_pools[NUM_SLOTS];
+    std::vector<cudaEvent_t> m_kernel_stop_pools[NUM_SLOTS];
+
+    // Per-slot, per-stream "batch done" sync events (timing disabled).
+    // Recorded after the last D2H of each submit_batch(). collect() waits on
+    // these via cudaEventSynchronize so it unblocks as soon as the batch
+    // finishes, even if the next batch is already queued in the same streams.
+    std::vector<cudaEvent_t> m_batch_done[NUM_SLOTS];
 
     // Kernel parameters
     dim3 grid;
@@ -83,15 +99,22 @@ class ClusterFinderCUDA {
     size_t shmem_bytes;
 
   public:
+    /**
+     * @brief Opaque handle returned by submit_batch(). Pass to collect().
+     */
+    struct BatchToken {
+        int slot;
+    };
+
     /**
      * @brief Construct a ClusterFinderCUDA
      *
-     * @param m_image_size              shape of the detector frame (rows, cols)
-     * @param nSigma                  threshold in units of per-pixel pedestal
+     * @param shape_                    shape of the detector frame (rows, cols)
+     * @param nSigma                    threshold in units of per-pixel pedestal
      * std
      * @param max_clusters_per_frame    tight upper bound on clusters/frame for
      * fixed-size D2H
-     * @param n_streams               number of CUDA streams for multi-frame
+     * @param n_streams_                number of CUDA streams for multi-frame
      * overlap
      */
     ClusterFinderCUDA(Shape<2> shape_, COMPUTE_TYPE nSigma = 5.0,
@@ -152,6 +175,13 @@ class ClusterFinderCUDA {
             CUDA_CHECK(cudaMalloc(&sc.d_pd_sum2, m_image_size * sizeof(float)));
             CUDA_CHECK(cudaMalloc(&sc.d_output, m_output_bytes_per_frame));
         }
+
+        for (int s = 0; s < NUM_SLOTS; ++s) {
+            m_batch_done[s].resize(n_streams);
+            for (int k = 0; k < n_streams; ++k)
+                CUDA_CHECK(cudaEventCreateWithFlags(&m_batch_done[s][k],
+                                                    cudaEventDisableTiming));
+        }
     }
 
     ~ClusterFinderCUDA() {
@@ -172,18 +202,20 @@ class ClusterFinderCUDA {
                 cudaStreamDestroy(sc.stream);
         }
 
-        for (auto e : m_kernel_start_pool)
-            if (e)
-                cudaEventDestroy(e);
-        for (auto e : m_kernel_stop_pool)
-            if (e)
-                cudaEventDestroy(e);
-        m_kernel_start_pool.clear();
-        m_kernel_stop_pool.clear();
+        for (int s = 0; s < NUM_SLOTS; ++s) {
+            for (auto e : m_kernel_start_pools[s])
+                if (e)
+                    cudaEventDestroy(e);
+            for (auto e : m_kernel_stop_pools[s])
+                if (e)
+                    cudaEventDestroy(e);
+            for (auto e : m_batch_done[s])
+                if (e)
+                    cudaEventDestroy(e);
+            if (h_output_slots[s])
+                cudaFreeHost(h_output_slots[s]);
+        }
 
-        // free pinned memory
-        if (h_output_pinned)
-            cudaFreeHost(h_output_pinned);
         if (m_registered_input)
             cudaHostUnregister(m_registered_input);
     }
@@ -266,11 +298,169 @@ class ClusterFinderCUDA {
     }
 
     /**
-     * @brief Batched cluster finding across multiple frames, using n_streams
-     *        CUDA streams to overlap H2D transfer, kernel, and D2H transfer.
+     * @brief Enqueue one batch of frames onto the GPU without waiting for
+     *        completion. Returns a BatchToken to pass to collect().
+     *
+     * At most NUM_SLOTS (2) batches can be in flight simultaneously. Submitting
+     * a third batch before collecting one throws std::runtime_error.
+     *
+     * Typical pipeline usage to eliminate inter-batch GPU idle time:
+     *
+     *   auto tok = cf.submit_batch(frames_a, 0);
+     *   for (size_t b = 1; b < n_batches; ++b) {
+     *       auto next = cf.submit_batch(frames_b, b * N); // enqueue B while
+     *                                                      // GPU still runs A
+     *       process(cf.collect(tok));  // drain A; GPU runs B concurrently
+     *       tok = next;
+     *   }
+     *   process(cf.collect(tok));  // drain final batch
+     */
+    BatchToken submit_batch(NDView<FRAME_TYPE, 3> frames,
+                            uint64_t first_frame = 0) {
+        if (m_pedestal_dirty) {
+            sync_pedestal_to_device();
+            m_pedestal_dirty = false;
+        }
+
+        const int slot = m_next_slot;
+        if (m_slot_in_flight[slot])
+            throw std::runtime_error(
+                "ClusterFinderCUDA: both batch slots are in flight — call "
+                "collect() before submitting a third batch");
+        m_next_slot = 1 - slot;
+
+        const size_t n_frames_batch = static_cast<size_t>(frames.shape(0));
+        const uint32_t n_pd_samples =
+            static_cast<uint32_t>(m_pedestal.n_samples());
+
+        // Grow pinned D2H output buffer for this slot if needed
+        if (n_frames_batch > m_output_slot_capacity[slot]) {
+            if (h_output_slots[slot])
+                CUDA_CHECK(cudaFreeHost(h_output_slots[slot]));
+            CUDA_CHECK(
+                cudaMallocHost(&h_output_slots[slot],
+                               n_frames_batch * m_output_bytes_per_frame));
+            m_output_slot_capacity[slot] = n_frames_batch;
+        }
+
+        ensure_event_pool(slot, n_frames_batch);
+
+        // Launch all frames round-robin across streams
+        for (size_t frame_idx = 0; frame_idx < n_frames_batch; ++frame_idx) {
+            auto &sc = v_sc[frame_idx % n_streams];
+
+            const FRAME_TYPE *h_src = frames.data() + frame_idx * m_image_size;
+            auto *d_cluster_count = reinterpret_cast<uint32_t *>(sc.d_output);
+
+            CUDA_CHECK(cudaMemsetAsync(d_cluster_count, 0, sizeof(uint32_t),
+                                       sc.stream));
+            CUDA_CHECK(cudaMemcpyAsync(sc.d_frame, h_src, m_image_bytes,
+                                       cudaMemcpyHostToDevice, sc.stream));
+
+            auto *d_clusters = reinterpret_cast<ClusterType *>(
+                sc.d_output + m_clusters_offset);
+            CUDA_CHECK(cudaEventRecord(m_kernel_start_pools[slot][frame_idx],
+                                       sc.stream));
+            device::find_clusters_in_single_frame<ClusterType, FRAME_TYPE>
+                <<<grid, block, shmem_bytes, sc.stream>>>(
+                    sc.d_frame, sc.d_pd_mean, sc.d_pd_sum, sc.d_pd_sum2,
+                    n_pd_samples, m_nSigma, nrows, ncols, d_clusters,
+                    d_cluster_count,
+                    static_cast<uint32_t>(m_max_clusters_per_frame));
+            CUDA_CHECK(cudaEventRecord(m_kernel_stop_pools[slot][frame_idx],
+                                       sc.stream));
+            CUDA_CHECK(cudaGetLastError());
+
+            void *h_out = static_cast<char *>(h_output_slots[slot]) +
+                          frame_idx * m_output_bytes_per_frame;
+            CUDA_CHECK(cudaMemcpyAsync(h_out, sc.d_output,
+                                       m_output_bytes_per_frame,
+                                       cudaMemcpyDeviceToHost, sc.stream));
+        }
+
+        // Record per-stream "batch done" events after all D2H for this batch.
+        // collect() waits on these via cudaEventSynchronize, which unblocks as
+        // soon as this batch's last D2H completes — even if the next batch is
+        // already queued behind it in the same streams.
+        const int streams_used =
+            std::min<int>(n_streams, static_cast<int>(n_frames_batch));
+        for (int k = 0; k < streams_used; ++k)
+            CUDA_CHECK(cudaEventRecord(m_batch_done[slot][k], v_sc[k].stream));
+
+        m_slot_n_frames[slot] = n_frames_batch;
+        m_slot_first_frame[slot] = first_frame;
+        m_slot_streams_used[slot] = streams_used;
+        m_slot_in_flight[slot] = true;
+
+        return BatchToken{slot};
+    }
+
+    /**
+     * @brief Wait for a previously submitted batch and return its results.
+     *
+     * Uses cudaEventSynchronize (not cudaStreamSynchronize) so that a
+     * concurrently running batch already queued in the same streams is not
+     * waited on — the GPU keeps running while the CPU drains this batch.
+     */
+    std::vector<ClusterVector<ClusterType>> collect(BatchToken token) {
+        const int slot = token.slot;
+        if (!m_slot_in_flight[slot])
+            throw std::runtime_error(
+                "ClusterFinderCUDA: collect() called on a slot that is not "
+                "in flight");
+
+        const size_t n_frames_batch = m_slot_n_frames[slot];
+        const uint64_t first_frame = m_slot_first_frame[slot];
+        const int streams_used = m_slot_streams_used[slot];
+
+        // Wait until this batch's D2H is complete in every stream it used.
+        // cudaEventSynchronize returns as soon as the event fires, without
+        // waiting for any later operations already queued in the stream.
+        for (int k = 0; k < streams_used; ++k)
+            CUDA_CHECK(cudaEventSynchronize(m_batch_done[slot][k]));
+
+        std::vector<ClusterVector<ClusterType>> results;
+        results.reserve(n_frames_batch);
+        for (size_t i = 0; i < n_frames_batch; ++i) {
+            results.emplace_back();
+            results.back().set_frame_number(first_frame + i);
+        }
+
+        for (size_t frame_idx = 0; frame_idx < n_frames_batch; ++frame_idx) {
+            const void *h_out =
+                static_cast<const char *>(h_output_slots[slot]) +
+                frame_idx * m_output_bytes_per_frame;
+            uint32_t n_found = *reinterpret_cast<const uint32_t *>(h_out);
+            n_found = std::min<uint32_t>(
+                n_found, static_cast<uint32_t>(m_max_clusters_per_frame));
+
+            if (n_found > 0) {
+                const auto *src = reinterpret_cast<const ClusterType *>(
+                    static_cast<const char *>(h_out) + m_clusters_offset);
+                results[frame_idx].resize(n_found);
+                std::memcpy(results[frame_idx].data(), src,
+                            n_found * sizeof(ClusterType));
+            }
+
+            float kernel_ms = 0.0f;
+            CUDA_CHECK(cudaEventElapsedTime(
+                &kernel_ms, m_kernel_start_pools[slot][frame_idx],
+                m_kernel_stop_pools[slot][frame_idx]));
+            m_total_kernel_ms += kernel_ms;
+        }
+
+        m_frames_processed += n_frames_batch;
+        m_slot_in_flight[slot] = false;
+        return results;
+    }
+
+    /**
+     * @brief Synchronous batched cluster finding across multiple frames, using
+     *        n_streams CUDA streams to overlap H2D, kernel, and D2H.
      *
      * Returns one ClusterVector per input frame (with frame_number set to
-     * first_frame + i).
+     * first_frame + i). Does not go through submit_batch/collect so it carries
+     * no async-slot overhead.
      */
     std::vector<ClusterVector<ClusterType>>
     find_clusters_batched(NDView<FRAME_TYPE, 3> frames,
@@ -280,20 +470,20 @@ class ClusterFinderCUDA {
             m_pedestal_dirty = false;
         }
 
-        const size_t n_frames_batch = frames.shape(0);
+        const size_t n_frames_batch = static_cast<size_t>(frames.shape(0));
         const uint32_t n_pd_samples =
             static_cast<uint32_t>(m_pedestal.n_samples());
 
         // Lazy grow D2H output staging buffer (one slot per frame)
-        if (n_frames_batch > m_output_pinned_capacity) {
-            if (h_output_pinned)
-                CUDA_CHECK(cudaFreeHost(h_output_pinned));
+        if (n_frames_batch > m_output_slot_capacity[0]) {
+            if (h_output_slots[0])
+                CUDA_CHECK(cudaFreeHost(h_output_slots[0]));
             CUDA_CHECK(cudaMallocHost(
-                &h_output_pinned, n_frames_batch * m_output_bytes_per_frame));
-            m_output_pinned_capacity = n_frames_batch;
+                &h_output_slots[0], n_frames_batch * m_output_bytes_per_frame));
+            m_output_slot_capacity[0] = n_frames_batch;
         }
 
-        ensure_event_pool(n_frames_batch);
+        ensure_event_pool(0, n_frames_batch);
 
         std::vector<ClusterVector<ClusterType>> results;
         results.reserve(n_frames_batch);
@@ -320,7 +510,7 @@ class ClusterFinderCUDA {
             auto *d_clusters = reinterpret_cast<ClusterType *>(
                 sc.d_output + m_clusters_offset);
             CUDA_CHECK(
-                cudaEventRecord(m_kernel_start_pool[frame_idx], sc.stream));
+                cudaEventRecord(m_kernel_start_pools[0][frame_idx], sc.stream));
             device::find_clusters_in_single_frame<ClusterType, FRAME_TYPE>
                 <<<grid, block, shmem_bytes, sc.stream>>>(
                     sc.d_frame, sc.d_pd_mean, sc.d_pd_sum, sc.d_pd_sum2,
@@ -328,33 +518,31 @@ class ClusterFinderCUDA {
                     d_cluster_count,
                     static_cast<uint32_t>(m_max_clusters_per_frame));
             CUDA_CHECK(
-                cudaEventRecord(m_kernel_stop_pool[frame_idx], sc.stream));
+                cudaEventRecord(m_kernel_stop_pools[0][frame_idx], sc.stream));
             CUDA_CHECK(cudaGetLastError());
 
-            void *h_slot = static_cast<char *>(h_output_pinned) +
-                           frame_idx * m_output_bytes_per_frame;
-            CUDA_CHECK(cudaMemcpyAsync(h_slot, sc.d_output,
+            void *h_out = static_cast<char *>(h_output_slots[0]) +
+                          frame_idx * m_output_bytes_per_frame;
+            CUDA_CHECK(cudaMemcpyAsync(h_out, sc.d_output,
                                        m_output_bytes_per_frame,
                                        cudaMemcpyDeviceToHost, sc.stream));
         }
 
-        // Sync once per stream
         const int streams_used =
             std::min<int>(n_streams, static_cast<int>(n_frames_batch));
         for (int k = 0; k < streams_used; ++k)
             CUDA_CHECK(cudaStreamSynchronize(v_sc[k].stream));
 
-        // Drain: fan in results from pinned D2H output pool
         for (size_t frame_idx = 0; frame_idx < n_frames_batch; ++frame_idx) {
-            const void *h_slot = static_cast<const char *>(h_output_pinned) +
-                                 frame_idx * m_output_bytes_per_frame;
-            uint32_t n_found = *reinterpret_cast<const uint32_t *>(h_slot);
+            const void *h_out = static_cast<const char *>(h_output_slots[0]) +
+                                frame_idx * m_output_bytes_per_frame;
+            uint32_t n_found = *reinterpret_cast<const uint32_t *>(h_out);
             n_found = std::min<uint32_t>(
                 n_found, static_cast<uint32_t>(m_max_clusters_per_frame));
 
             if (n_found > 0) {
                 const auto *src = reinterpret_cast<const ClusterType *>(
-                    static_cast<const char *>(h_slot) + m_clusters_offset);
+                    static_cast<const char *>(h_out) + m_clusters_offset);
                 results[frame_idx].resize(n_found);
                 std::memcpy(results[frame_idx].data(), src,
                             n_found * sizeof(ClusterType));
@@ -362,8 +550,8 @@ class ClusterFinderCUDA {
 
             float kernel_ms = 0.0f;
             CUDA_CHECK(cudaEventElapsedTime(&kernel_ms,
-                                            m_kernel_start_pool[frame_idx],
-                                            m_kernel_stop_pool[frame_idx]));
+                                            m_kernel_start_pools[0][frame_idx],
+                                            m_kernel_stop_pools[0][frame_idx]));
             m_total_kernel_ms += kernel_ms;
         }
 
@@ -416,15 +604,15 @@ class ClusterFinderCUDA {
             CUDA_CHECK(cudaStreamSynchronize(sc.stream));
     }
 
-    void ensure_event_pool(size_t n_frames) {
-        const size_t old_size = m_kernel_start_pool.size();
+    void ensure_event_pool(int slot, size_t n_frames) {
+        const size_t old_size = m_kernel_start_pools[slot].size();
         if (n_frames <= old_size)
             return;
-        m_kernel_start_pool.resize(n_frames);
-        m_kernel_stop_pool.resize(n_frames);
+        m_kernel_start_pools[slot].resize(n_frames);
+        m_kernel_stop_pools[slot].resize(n_frames);
         for (size_t i = old_size; i < n_frames; ++i) {
-            CUDA_CHECK(cudaEventCreate(&m_kernel_start_pool[i]));
-            CUDA_CHECK(cudaEventCreate(&m_kernel_stop_pool[i]));
+            CUDA_CHECK(cudaEventCreate(&m_kernel_start_pools[slot][i]));
+            CUDA_CHECK(cudaEventCreate(&m_kernel_stop_pools[slot][i]));
         }
     }
 };
diff --git a/python/src/bind_ClusterFinderCUDA.hpp b/python/src/bind_ClusterFinderCUDA.hpp
index 3448e3b..fc6f160 100644
--- a/python/src/bind_ClusterFinderCUDA.hpp
+++ b/python/src/bind_ClusterFinderCUDA.hpp
@@ -31,6 +31,10 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
     using ContigArr =
         py::array_t<uint16_t, py::array::c_style | py::array::forcecast>;
 
+    // Opaque batch handle returned by submit_batch() and consumed by collect()
+    py::class_<typename CF::BatchToken>(m,
+                                        (class_name + "_BatchToken").c_str());
+
     py::class_<CF>(m, class_name.c_str())
         .def(py::init<Shape<2>, float, size_t, int>(), py::arg("image_size"),
              py::arg("n_sigma") = 5.0f,
@@ -91,6 +95,44 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
             list of ClusterVector, one per input frame. The input array is
             converted to C-contiguous uint16 if needed.)")
 
+        .def(
+            "submit_batch",
+            [](CF &self, ContigArr frames, uint64_t first_frame) {
+                auto view = make_view_3d(frames);
+                return self.submit_batch(view, first_frame);
+            },
+            py::arg("frames"), py::arg("first_frame") = 0,
+            py::call_guard<py::gil_scoped_release>(),
+            R"(Enqueue one batch of frames onto the GPU without waiting for
+            completion. Returns a BatchToken that must be passed to collect()
+            to retrieve results and release the slot.
+
+            At most 2 batches can be in flight simultaneously. The intended
+            usage pattern to eliminate inter-batch GPU idle time is:
+
+                tok = cf.submit_batch(buf_a, first_frame=0)
+                for start in range(BATCH_SIZE, N, BATCH_SIZE):
+                    buf_b[:n] = data[start:start+n]       # fill next buffer
+                    next_tok = cf.submit_batch(buf_b, first_frame=start)
+                    results += cf.collect(tok)             # GPU runs buf_b
+                    tok = next_tok
+                    buf_a, buf_b = buf_b, buf_a            # swap
+                results += cf.collect(tok)                 # drain last batch
+
+            Two separate input buffers must be used (one per in-flight batch)
+            so that filling the next buffer does not corrupt the ongoing H2D
+            transfer for the current batch.)")
+
+        .def(
+            "collect",
+            [](CF &self, typename CF::BatchToken token) {
+                return self.collect(token);
+            },
+            py::arg("token"), py::call_guard<py::gil_scoped_release>(),
+            R"(Wait for a previously submitted batch and return its results as
+            a list of ClusterVector, one per input frame. Releases the batch
+            slot so it can be reused by the next submit_batch() call.)")
+
         .def("avg_kernel_time_ms", &CF::avg_kernel_time_ms,
              R"(Average kernel execution time per frame in milliseconds,
             excluding PCIe transfers.)")
@@ -117,7 +159,31 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
             Call unregister_input_buffer() when done.)")
 
         .def("unregister_input_buffer", &CF::unregister_input_buffer,
-             "Release the previously pinned input buffer.");
+             "Release the previously pinned input buffer.")
+
+        .def(
+            "pin_buffer",
+            [](CF & /*self*/, py::array arr) {
+                auto info = arr.request();
+                CUDA_CHECK(
+                    cudaHostRegister(info.ptr,
+                                     static_cast<size_t>(info.size) *
+                                         static_cast<size_t>(info.itemsize),
+                                     cudaHostRegisterDefault));
+            },
+            R"(Pin an arbitrary numpy array as a locked host buffer for DMA-speed
+            transfers. Unlike register_input_buffer(), does not unpin a
+            previously registered buffer — use this to pin multiple buffers
+            simultaneously (e.g. the two alternating buffers in an async
+            pipeline). Call unpin_buffer() on each array when done.)")
+
+        .def(
+            "unpin_buffer",
+            [](CF & /*self*/, py::array arr) {
+                auto info = arr.request();
+                CUDA_CHECK(cudaHostUnregister(info.ptr));
+            },
+            "Release a buffer previously pinned with pin_buffer().");
 }
 
 } // namespace aare
diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb
index 1a47474..a1a8154 100644
--- a/python/tests/ClusterFinderCUDA.ipynb
+++ b/python/tests/ClusterFinderCUDA.ipynb
@@ -53,7 +53,7 @@
                     "text": [
                         "Image size:       (400, 400)\n",
                         "Pedestal frames:  1000\n",
-                        "Data frames:      88999\n"
+                        "Data frames:      50000\n"
                     ]
                 }
             ],
@@ -62,7 +62,7 @@
                 "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n",
                 "\n",
                 "n_frames_pd = 1000\n",
-                "N           = 88999 #88999\n",
+                "N           = 50000 #88999\n",
                 "cluster_size = (9, 9)\n",
                 "rows = f.rows\n",
                 "cols = f.cols\n",
@@ -165,6 +165,20 @@
         {
             "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": [
@@ -172,7 +186,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Pedestal (1000 frames): 0.499s\n"
+                        "Pedestal (1000 frames): 0.659s\n"
                     ]
                 }
             ],
@@ -182,6 +196,7 @@
                 "    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')"
             ]
         },
@@ -195,7 +210,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 10,
+            "execution_count": 11,
             "id": "4573be3d-5ba8-4e18-bab0-c874f2b7dcb2",
             "metadata": {},
             "outputs": [
@@ -203,7 +218,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Reading 88999 frames:        51.133s  (1741 FPS, 531.166 GB/s)\n"
+                        "Reading 50000 frames:        2.294s  (21800 FPS, 6652.882 GB/s)\n"
                     ]
                 }
             ],
@@ -226,7 +241,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 11,
+            "execution_count": 12,
             "id": "ad47af54-c2ba-441a-a874-88dfe04d8a68",
             "metadata": {},
             "outputs": [],
@@ -236,7 +251,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 12,
+            "execution_count": 13,
             "id": "fbb14fda-2852-4b73-ba2c-9952abac1d99",
             "metadata": {},
             "outputs": [
@@ -244,14 +259,14 @@
                     "name": "stderr",
                     "output_type": "stream",
                     "text": [
-                        "100%|████████████████████████████████████| 88999/88999 [13:59<00:00, 106.07it/s]\n"
+                        "100%|█████████████████████████████████████████████████████████████████████████████████████████████████| 50000/50000 [07:46<00:00, 107.08it/s]\n"
                     ]
                 },
                 {
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CPU clustering:          839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n"
+                        "CPU clustering:          466.937s (107 FPS, 50982358 clusters, 1019.65/frame)\n"
                     ]
                 }
             ],
@@ -292,27 +307,26 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 13,
+            "execution_count": 14,
             "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
             "metadata": {},
             "outputs": [],
             "source": [
-                "BATCHED = True"
+                "BATCHED = True\n",
+                "BATCH_SIZE = 3000"
             ]
         },
         {
             "cell_type": "code",
-            "execution_count": 29,
+            "execution_count": 42,
             "id": "50848f8c-2e66-45b8-b6d5-ca80f368e6ba",
             "metadata": {},
             "outputs": [],
             "source": [
                 "if(BATCHED):\n",
-                "    BATCH_SIZE = 2000\n",
-                "\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 ~640 MB\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",
@@ -365,7 +379,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 30,
+            "execution_count": 43,
             "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5",
             "metadata": {},
             "outputs": [
@@ -375,7 +389,7 @@
                             "(9, 9)"
                         ]
                     },
-                    "execution_count": 30,
+                    "execution_count": 43,
                     "metadata": {},
                     "output_type": "execute_result"
                 }
@@ -386,7 +400,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 31,
+            "execution_count": 44,
             "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc",
             "metadata": {},
             "outputs": [
@@ -394,7 +408,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CPU clustering:          839.049s (106 FPS, 90799856 clusters, 1020.23/frame)\n"
+                        "CPU clustering:          466.937s (107 FPS, 50982358 clusters, 1019.65/frame)\n"
                     ]
                 }
             ],
@@ -405,7 +419,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 32,
+            "execution_count": 45,
             "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
             "metadata": {},
             "outputs": [
@@ -413,10 +427,10 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "CUDA clustering:          7.039s  (12644 FPS, 89991186 clusters, 1011.15/frame)\n",
-                        "  Kernel only:            0.063 ms/frame\n",
-                        "  PCIe + overhead:        0.016 ms/frame\n",
-                        "Speedup (CPU / CUDA):     119.20×\n"
+                        "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"
                     ]
                 }
             ],
@@ -428,6 +442,102 @@
                 "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",
@@ -440,7 +550,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 18,
+            "execution_count": 48,
             "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
             "metadata": {},
             "outputs": [
@@ -448,7 +558,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Cluster count diff:       2716962 (2.99%)\n"
+                        "Cluster count diff:       404747 (0.79%)\n"
                     ]
                 }
             ],
@@ -468,7 +578,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 19,
+            "execution_count": 49,
             "id": "aff8db7e-8332-4228-857f-a9875cf940d3",
             "metadata": {},
             "outputs": [
@@ -488,14 +598,14 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 20,
+            "execution_count": 50,
             "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e",
             "metadata": {},
             "outputs": [
                 {
                     "data": {
                         "image/png":
-                            "iVBORw0KGgoAAAANSUhEUgAAAxYAAAJOCAYAAAAqFJGJAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsJZJREFUeJzs3Qd4U9X/BvC3pZPRQoFSWvZUligowwEogsoQ90SciCCKiAO3/FWcgIqIuFBUcCD+VBDBhQMQRJG9lL1a6IBCd+//eU+8IemiiyZp3s/zhLTJyb03JzflfO/5nnMCLMuyICIiIiIiUgaBZXmxiIiIiIiIAgsRERERESkX6rEQEREREZEyU2AhIiIiIiJlpsBCRERERETKTIGFiIiIiIiUmQILEREREREpMwUWIiIiIiJSZgosRERERESkzBRYiEi5WLVqFW666SY0bdoUYWFhqF69Ok477TQ8//zzSExMdJbr2bOnuZ0oU6ZMwfTp00/Y9sV3VMZz4ZdffsGVV16JuLg4hISEIDIyEt27d8frr7+OI0eOOMs1adIEAQEBzhu/j126dMH777/vtj2W69+/f4H7+uOPP8xrvaUOi/s3pqTv6YknnnCrq6pVq6JBgwbo27cvXn31VRw+fLjQY8rKykJMTIx53WeffVbO71jE9yiwEJEye/PNN9GpUycsX74c9913H+bPn485c+bgiiuuwNSpU3HLLbdUWC1XxsaklE5lOxcef/xxnHPOOdi9ezf+7//+DwsXLsSsWbNw3nnnmcbxI4884lb+zDPPxJIlS8yN9cDG75AhQ0wQ4msq4m8Mt8m64v2LL76IRo0a4f7770fbtm3x999/F/iar7/+Gvv37zc/v/3222U+BhFfF+TpAxAR38b/iO+44w6cf/75+OKLLxAaGup8jo/de++95j9qX2ZZFtLT0xEeHg5fkJaW5jPH6i145ZkN76Ag7/xv8dNPP8W4ceNMA5qNbB6r7cILLzQNYH4XXdWsWRNdu3Z1/t67d280btwYEyZMMN9ZX1FRf2MYuNSpU8f5+9VXX40777wTPXr0wMCBA7Fp0ya3fdvBBHuOWGbBggXYtWuX6e0Q8VfqsRCRMnnmmWdMI2fatGn5/tMl/qfL/5QL89NPP5nX897Vtm3b8qUs/Pvvv+Y/+9jYWLOvevXqmau1K1eudKZArF27FosWLXKmNfAx26FDhzBmzBiTSsHjYjrJqFGj3FJIiK9jg4JXQk8++WSzr/fee6/Ievj444/RrVs3VKtWzaRoMI3ir7/+citz4403mue2bNmCiy66yPzcsGFD0zDKyMhwK5uZmYmnnnoKJ510ktl/3bp1TRpIQkKCWzk77ePzzz/HqaeealJEnnzySfMc66JPnz4mtYOvHzFiBObOnetW37zyzcb0zp07872nm2++GbVr1zZBVWGO95m4HiOvMHfo0MEcY7NmzfDKK6/k215xP6Pc3FyTptKxY0cTRNmN6C+//PK454J9zs2YMcPUPffBY+fnYqfF5GVf8ed5mfd98ao1657HwfOFv9uv4e88J8444wyThlNaDCpq1apl6qyg46tRo4b5rIvCOmrdujW2b9+O8sIr+Tyegq7Wf/PNN+Y5+zPhuTt06FBzztvnNHtVvvvuuxP6N6YsTjnlFDz88MPYsWOH+Y672rNnjwloBgwYYHpReE5Wph4ykdLwzkszIuITcnJy8MMPP5grfWwsnGhsjHOfzKlmmsKBAwewePFiJCcnm+fZcL388stN3jnTYMhuiBw9etRcVeQVxYceesg0cNnwfOyxx7B69WrTuHFtsPHKKPPZ+TxzqKOjo4ts+DANhQ1/3jMoeOGFF3D22Wdj2bJlaNOmjduVcTaCeOWZjdqff/7ZNO55zNwXsYFy8cUXm/3zSjRz6NkYZCoMx6ewgeraI/Hnn39i/fr1Zt9skLMhu3fvXvN++TNTX3j8M2fONAGTq9tvvx1PP/003njjDRPI2JizzjQblmcgUNrPxMZAgwECG+6szw8//BB33323qSsGEiX9jBikffDBB6Ye2ehm45L1YDf8izoXbGPHjjXBIAPIwMDAIj/johrW3A4bn9wXg7pLL73UPPb99987G8UPPPCACUK2bt3q/Ox4rPy8mJ5UVIOUn+WaNWtw1VVXmSCxtHju8Txig748G94Mqt5999186Uh8T6xTniM0ePBg8xnxfGvVqpU5R/j7wYMHveZvTEH4feX3kN/VG264we398fgYgNu9Qe+88445FwoK/kT8giUiUkr79u2z+Gfk6quvLvZrevToYW62H3/80WyD9662bt1qHn/33XfN7wcOHDC/T5o0qcjtt23b1m37tvHjx1uBgYHW8uXL3R7/7LPPzHbnzZvnfIy/R0ZGWomJicd9Pzt27LCCgoKskSNHuj1++PBhKyYmxrryyiudjw0ZMsRs+5NPPnEre9FFF1mtW7d2/j5z5kxTbvbs2W7leOx8fMqUKc7HGjdubFWpUsXauHGjW9n77rvPCggIsNauXev2eN++ffPVN48rOjraysjIcD723HPPmfri51CY4n4mPEYey8qVK90eP//8862IiAjryJEjJfqMfv75Z/P7ww8/XKpzwT7nzjnnnHzPPf744+a5vHge8nHX+uD7Cg8Pt3bt2uV8jO+R5erXr+98X/TFF1+Yx7/88kvnY9u2bTOf3c0331zk+1i6dKl57YMPPmgVF4+N51VWVpa58bjt84/nhmu5fv36FbgN+3yzv4OFeeWVV0w513OQ353Q0FDr3nvvdT5WvXp1a9SoUdaJ/htT0vdkf+YJCQkFviYtLc08f+GFFzofy83NtVq0aGHFxcVZ2dnZbtv5/vvvS/AORSoXpUKJiE+IiopC8+bNTU8Ac8SZZsQr+8XF9JR27dqZ1Jns7GznjSlLBaVinXvuuSb15Hi+/fZbsx1eyXTdLq/y8+p73u1yX0ydcMUr867pKTxWpq2wnOs2eey82p93m3w9rwC7YgoQ369rbwldc801+d4Dew7i4+NNHj+xXtnL0a9fP7dUsrJ8JhwAy6vbrq699lqT+sSr1iX5jJhiQ0ztKovLLrsMZcVjZSqVjalPxJ4l194F+3HXz5lXuPn+TtSg33nz5iE4ONjc2DPyySefYOTIkW49U+XhuuuuM71Brr0u7B1jeh978WxMB2MZ7n/p0qWmB8UXOK41IN/3i6lz7G2qUqWKeYzvlecpey1E/JUCCxEpNQ50ZOOJ6R0nGv/DZmoJG5lMu+E0k0zpuOuuu4qcDtLGmVs4XaXd0LJvzE1nw4EpPK7q169frOOyZ4Q5/fTT822bOdl5t8v6yptaxEaZ6zgGbpNpIkzvybvNffv2FetYmV7C8Q55FfQYU1mYtvXaa685G/hM08mbNlWWz4QBUV72Y3YqTHE/I+bqszFX0DZLorifcVEYXLniZ1bU40WNVykMU8yopN+zs846y8yixNS5devWmXOKYzTsYyGOr2E6T0EY9BA/g6LwvTJdiFPZ2ttiAMFAggGljd8HNsTfeustk4LG1zEg5zldnn9jyuM9ubKDQY4jstnB4CWXXGLqlTemwrHOZ8+enS8VUMRfaIyFiJQaG3ccqMsryKWdDcVuZOcdvJy38Wxf4bX/Q+cMLbwCy5x95ukzT74obKAwt72wq4mus8FQcXOk7ddxDnseX3ngNjlourCZbtjQPt6x8vV20OOqsEYcgwFO3cneg8mTJ5seEM64czzF/UwK2q/9GI+1JJ8Rgxc2HPn6sgQHBdWb6/noOiajoPOxovA9tm/f3sw6xHEoxR1nwYZu586diyzDQJPT1xbEfrygYDQvXq1njxenwGUgxIAm77S2/PwmTZpkbhwMzUHdDz74oOktK+xcL83fmPJ6TzZ78Lm9/k5KSooJHuwLCgX56KOPMHz48GLvQ6SyUI+FiJQJB6nyavJtt91mGpN5Md3hq6++KvT1dqoNr1QX9J95Ydjw5WBlNrjsVBpiY5DTrebFgbP//POPacSysZX3VlTKT1F4tZ5XSLntgrZ7vIZdQXisvIrPxnNB2+PMPsfDNCwO+OWValcckF0QXnllg5ADyjlImo2ikg5ALewzIQ7CzrsWABtfDJLY01GSz4jTq9Lx1mMo7FwoSmHnY1HncEV49NFHkZSUZALAglJzUlNTTeBRUhx0XNB5QgwS7YX1joczUjEljIO4eWOAVlDanY3nGnvEGLzmPVfK+jemvN4T8ZzlAHyeF1yY0D5veV5x0oUff/wx340BlNKhxF+px0JEyoQpDWzgsSHKmVs43zzTH/ifPXPuOUUk8+bzjiuwMZ2FDYHx48ebMQ28As70Gk6f6ooNPTZEeFW9ZcuWJp2Ds8XwcV71tLFRy8Yz0y44pSkbOHyMMxLxKiMXGLvnnnvMuASOB+CVUzbI2KAubmPDFRscnJWIM8Fw6tULLrjAvA/2FnBGKM7KZE//WlycvpWzJnE2HY5/YEoJUzd4xZYNF84YxUCgKHy/bNywEc7j4xVaNog2bNhgnucsSHmvDHPMAmcv4jFz1qXjKe5nYqeRMF2GvRm8As8ZnXh1+7nnnnNegS/uZ8S0Lc4wxFx91jMDEgYRPN+4LY4jKOpcKArrnCk69mxTDBqZ1lPQdLxlxRQbjlFhetDxxlmwjhlcsDHLz5DHx9eyB+P33383s3px1qjjTTmbF88vpjDxajxn4mL9MIBhnbEXjmNn8vaQFYTnD9OaWD4iIsLMjMUeExuv8vfq1cuMq+EUytwmezXYU8Gy5fk3prTvacWKFeaYuV1OJcu/Q5ySmDNbMXCxU8j4WfE7ztnMCpoxza4HBiV5xxWJVHqeHj0uIpUDZ8PhrDONGjWyQkJCrGrVqlmnnnqq9dhjj1nx8fGFzgpFe/futS6//HIrKirKzMZ0/fXXW3/88Yfb7C379++3brzxRuukk04y2+YMMx06dLAmTpzonJXFnmmnT58+Vo0aNczrOUOMLTU11XrkkUfMDEw8Ru6rffv21j333GNmn7HxdSNGjCjR++esP7169TKzHHE2HO6X7+m7775zlmH98NiLMxMRZ/J58cUXrVNOOcUKCwsz75fv/fbbb7c2b95crBlw1qxZY/Xu3du8nnV7yy23WO+9957Z199//52vPOuOzw0bNqxY77m4n4l9jJzdiTM1se6bNGliTZgwId82i/sZ5eTkmP20a9fOWa5bt27WV199ddxzwZ4V6tNPPy3wfS1btszq3r27eU+c9Yefz1tvvVXgrFAF1X1B5489y9kLL7yQ7zGeF8W1aNEic15x1qng4GBzvvF9c7uHDh067rEVhPV6xx13mO8uZzhjfZ111lmF1k9hNm3aZN4PbwsXLnR7Lj093ZxXPD94zJxNi58x69Z19qzy+BtT0vdkf//sG7+/rF+eOy+//LJbvfJ7wzJFzW61YcMGUybvTHEi/iCA/3g6uBERkYrBBco4Yw9TrVwH8RIXnGOqDdNIXAfdlhV7dXhF2V44TkREKielQomIVFJM5WEKEtOAmIPPhj1n5OE4CNeggukknHWH5ZlmVZ5BhYiI+A8FFiIilRTHZXCNCY7N4DSbHAfB3G/moLvieA3OsMSxC8ebXUtERKQwSoUSEREREZEy03SzIiIiIiJSZgosRERERESkzBRYiIiIiIhImWnwdgXjYk9ceIeL85R0VVsRERERkYrElSkOHz5sZhnMu7hqXgosKhiDioYNG1b0bkVERERESm3nzp1o0KBBkWUUWFQw9lTYH05ERESFR5wpKSmIjIxUb4nqTeebl9L3VPWmc8436LuqevOX8+3QoUPmorjdhi2KAosKZp8MDCo8EVjwxv0qDUv1pvPNO+l7qnrTOecb9F1Vvfnb+RZQjP1q8LaIiIiIiJSZAgsRERERESkzBRYiIiIiIlJmGmMhIiIiJ1xOTg6ysrIqTU0z3z0zMxPp6ekat6h68+nzLTg4GFWqVCmXbSmwEBERkRPaINq3bx+Sk5Mr5dpUBw8e9PRh+BzVm/fVW82aNRETE1PmoEWBhYiIiJwwdlARHR2NqlWrVpqr+wyY2AvDK72V5T1VBNWbd9Ubt3v06FHEx8eb3+vXr1+m7SmwEBERkROCDSE7qKhdu3alqmU1kFVvleV8Cw8PN/cMLvhdLUtalAZvi4iIyAlhj6lgT4WIeC/7O1rWcVAKLEREROSEUqqQiH98Rz0eWOzevRvXX3+96SJltNSxY0esWLHCrevniSeeQGxsrOmq6dmzJ9auXeu2jYyMDIwcORJ16tRBtWrVMHDgQOzatcutTFJSEgYPHmyWQueNP+cdSLZjxw4MGDDAbIPbuuuuu8wIfFerV69Gjx49zLHExcVh3Lhx5hhFRERERPyZRwMLNvbPPPNMM83VN998g3Xr1uGll14yI9Ntzz//PCZMmIDJkydj+fLlZsT6+eefj8OHDzvLjBo1CnPmzMGsWbPw66+/IjU1Ff379ze5aLZrr70WK1euxPz5882NPzO4sLFsv379cOTIEbMNbmv27Nm49957nWUOHTpk9s0gh8fy6quv4sUXXzTHJyIiIlIRzjnnHHz00Ueq7BN05f6LL77wubr9+uuvceqpp5qZozzK8qAHHnjAOuusswp9Pjc314qJibGeffZZ52Pp6elWZGSkNXXqVPN7cnKyFRwcbM2aNctZZvfu3VZgYKA1f/588/u6devYpWAtXbrUWWbJkiXmsQ0bNpjf582bZ17D19pmzpxphYaGWikpKeb3KVOmmH3zGGzjx4+3YmNjzbEWB7fF/drbrEg8xqSkpGIfq6jedL5VPH1PVW+V6ZxLS0sz/wfz3hft3bvXuvPOO62mTZtaISEhVoMGDaz+/ftb3333namvrKwsq3Hjxub/dd7Cw8Ottm3bOtso9Pjjj1unnHJKvm2zzvmaH3/8sUTH9NVXX1ktW7a0cnJynI9t2bLFGjRokFWnTh2rRo0a1hVXXGHt27fP7XWJiYnW9ddfb0VERJgbf+Yx2N59913n+8h7279/v7Pcxx9/bN4P32ujRo2s559/Pt8xTp482TrppJOssLAwq1WrVtZ7773nfM6utwkTJpjnWIb1OmrUKLfzhPWW9zjq1auXb188vwYMGGDeU/Xq1a0uXbpY27dvt0qL+5kzZ45VHn788UezPdd6Li273or6np566qnWjBkzyv27WpK2q0dnhfryyy/Rt29fXHHFFVi0aJFJLRo+fDhuu+028/zWrVvNNHV9+vRxviY0NNSkIi1evBi33367SZviQBPXMuxRaNeunSnD7S9ZssSkP3Xp0sVZpmvXruYxlmndurUpw9fwtTa+lmlW3EevXr1MGe6bx+BaZuzYsdi2bRuaNm2a7z3y9by59noQz92KTqGy96nULdWbzjfvpe+p6q0ynXP2Nn3x/x7+v37WWWeZLIrnnnsOHTp0MO2Nb7/9FiNGjMD69eudZZ988knTdmHGxPTp0zFs2DDTxrjqqqvc6qA86uaVV17BjTfeaK6s83XMtGAb6JRTTsH3339vyjz22GMmtZvtlsDAQGfmBtPEmSFCbEMxc4NtMbryyitNm8bVTTfdZBZkq1u3rtkXX3vdddeZY+A+WQd832FhYbjzzjvNa15//XXTLpo2bRpOP/10LFu2DEOHDjX1yGMi9rawzNtvv43u3btj06ZNZl/cx8SJE5310rZtWyxcuNB5PJytyLWu/vnnH/MZ3XzzzSZtnnXOY2I7rSznW3mdr1Y5nf/2jFD2OIjCtsXzgtk0/IzK81hLcuweDSz+/fdfcwKOHj0aDz30kDn5OK6BJ8QNN9xgggqqV6+e2+v4+/bt283PLBMSEoJatWrlK2O/nvecPisvPuZaJu9+uE1u27VMkyZN8u3Hfq6gwGL8+PHmD05eKSkpHgks+EePNJBO9abzzTvpe1r6etsRn4is+FTz961GeDCiaxy7CCSeOec4TpGpGWwUuaYn+wJe6GR98AIkx17aTjrpJAwZMsS8HzvthM+z8c0b/8//9NNPTTrN5Zdf7myo5X3/9u92/RTHgQMH8N133+GFF15wvuaXX34xQRBTtCMiIsxjb775pmnjsOx5551nGttMA2eq9xlnnGHKsP119tlnmzR0XmBle4fHb0tISMAPP/xgAgR7XzNmzMDFF1/svADcuHFjjBkzxqStM5hifbEMn+d7t8swwGFwdtFFF5nH+DsDCgZe1LBhQ/Mz34O9L9YZAwnXY3KtN3r44YdxwQUXmLaWjfvLWy6vd999F5MmTcKWLVsQFRWFSy65xARLNvsz4UXv3r17m7qw0/SZSs+AafPmzaZNyPbo3Xffjd9++82c73zs2Wefxcknn4xzzz3XvIb7IAZy77zzjnlvTP1n3e7duxctW7Y07+Wyyy4z5ez9zp07F48++qgZ3ztv3jxzDKxvXvBmXbdo0QJTpkxB586dzeuY0s9j4bE1a9asWOeUa73yfXOogesFcdeL4l4fWPANsDKeeeYZ8ztzwzgwmyc7Awtb3j90/ECO98cvb5mCypdHGTs4KOx4GJEzcHL9cPgFYlRt/wGoKPaxct8KLFRvOt+8k76npbMr6SjGfL4B/6TkwkIAwoOrYMHoHoir6ZifXTxzzvFqN1cKZgOxLHPjV7TExETTM/HUU08V+H913jU52Cvg+v54BT87O9u55gBved+//Xve1xaFDXJOdMMMC7sngr0o3D4ft7fDQIfPMyhizwIv3PLzZWPexjGufOz3339HmzZt8u3rww8/NNtkT4a9XTacXfdj74s9IbyxUc0ynODGtQxfw6CB7T6Oq2Uvw8yZM00DmYEOLzQz8GHbz34d3xMb/o0aNTIXnJl18vTTTzsbzNwWG9v33XefaVD/9ddf5gLvgw8+iEGDBhVah2xjcvwsg5ELL7zQXOhlUOB6vPZnYtex6/nres8bG/J8zwwGqlWrZgI1njOsi88++8wEWBs2bDCP2fXCIIJjgxkUMKj4+eefTbDKi9XMjLH3yzYkg0i+ZwYVnMCIbWW+B26HQQ7PNfuYWI4BJT93brck7Pdbo0YNs01XJfm74NHAgqv75T2ZGeFx0DRxoLbdG+C6EiAX8LB7CliGHygHgrv2WrCM/QVimf379+fbPyNQ1+3wy+WK2+QX1rWM3Xvhuh/K29th45fBNXXKZv+hqWj2fhVYqN50vnkvfU9LLvloFtKyLUy48lRWIEZ9vNI81qCW1k/w5Dlnby/vttMyc/BPgqOXpCI1r1sd4SHHb8QzxYYBF9skhdWJa9aB/f4YTHzwwQfmCvMdd9zh9r7zbqewuikKr46zveHaCO7WrZtp0LJBzQu1PK4HHnjANLzZZuG22QZigzPvfvgYnyto/7yqz/Qp1zVImCp1zz33mJQbpoiz4f/yyy+7ZW6wDFOc2Atw2mmnmeCB22J7ikEm21LsneDP7DHh8bLeWF9sSLumrL///vto1aqVOUYGeQyGeAGagR3bcOxpY08In+M9gxNe9f/xxx9NA70gDE4YWHDiH5vdi5P38yzoM8r7GGcU5T6ZKkfNmzdH3gCUn5nd48HUNaZ7sTeIn539GgY37MFg8GDvgzOP2qn+pld2xw7TY8Hzklg3eXFYAc+Tkn6XizoffSaw4AmyceNGt8eYZ2d3Y/EE5QnI/DpGaGRHhTyBqFOnTib6ZRlG1cRupTVr1piuOeIHx4iUEbt98jCI4GN28MEyPNn4WjuIWbBggQkKuA+7DFO2eAzsMrTLcFxG3hQpERGpeM2jq+vCiQ9gUNH/1V8rfL9fjzwL7eIij1vueNkIebEh/8gjj5gUErYPeBWdYxjKW1paWr6ryUwVYuoVG+ZM5+FV52uuucY06l0DkOJkZbj2jPDKOxv2rpjixKCLM28yUOBVeF6x5/gGe19M3WGQwcCA22ejmoEI22R2GbbjGATxij17IhigcDtsf/H1xN4EW/v27U0bjA3w9957z2SC2GloTM1isENcsoBX66dOnVpgYMGLwXv27DHpYeWFKfyse7YHe/fu7RZkFIT1yp48zjLqim1Lu61rs1OcbAyG+BkweOW+OEbZNZAh9oocPXoUnuLRwIInAhv2PLkYFLDhz2iNN+LJzkrk8+zS4Y0/M3pmFE3sxrvllltM9MnIkHlsjOZ4ErLSiZEdc/D4YbzxxhvmMQ4k4heDeYXEiJC9J8x/Y7cTu0G5Hb7G7gblPpk7yS8IAwzmsPF4OEhKPQAiIiLF7zlgI98T+y0Otjf4/zrHJhSVVmNjIMG2AdsnbBy7tgnYhuCFzLzstbTYjikurrHFbIq82IZhg59jMIKCgszVcV6Ytcd+Fidzw9Vbb71lGun2hVUb3xcv7LLtw+CBQY09YNy+wMqGLccRsL3FfbI+2K5jig2Pnx5//HGzhtmtt95qfmebjVfy2TZjmpCdCuSKvTIsx7aXXRd8rwVlvnAsSUF4bCVhH4dr71Telan5HthLw/EQCxYsMClWHD/B9dUKYgdELM/eBVd5M1xcx/YQ25scmM0UMA6kZz1yeQT2DtnYfs07LqVCWR7GadPatWtnpnXl1GTTpk1ze57TanHKMU47yzLnnHOOtXr1arcynBqL08FFRUWZ6c84FdyOHTvcyhw8eNC67rrrzDRsvPHnvNN/cXqyfv36mW1wW9ym69SytGrVKuvss882x8JjeuKJJ0o0RZ+mm/U9mv5T9abzzfut2plknTnuK3O/eley1fiBr829HJ+mmy3YBRdcYMXFxVmpqan5nrOn57Wnm504cWKh9Tt37lwrKCjITF3r6pNPPjHT3B86dKjYp+ny5cutgIAAM3VsUb7//ntTzp5S3552//fff3eW4RT8rtPu2w4fPmymbX311VeLdUyDBw+2unXrVmQZtt2uueYa8zPrjdOi3nfffW5lPvroIzP1bHZ2doHbYHuMn8eTTz7pfIz75bS5rjjtrr2vgjRp0sR6+OGHizXdrF1va9eudT7Pdiof27p1a4Gvf/DBB6327dubn3/77TdT9sCBA87n+XmzDfn++++XaJragqabvfrqq81Uu67tYS7BwOmQPTXdrMcDC3+jwML3KLBQvel8834KLEpPgUXB/v33X3MBsU2bNtZnn31mbdq0yTS8Xn75ZXMhtLiBBcuwodmjRw/r119/Ndv94osvzBoQw4cPL9FnxUZ3dHS0uSjr6p133jHrc3E9C65jwIujo0ePzhcodejQwZTjjcfEC7F5vfXWW6aBX1DwkpCQYL3++uvW+vXrrb/++su66667TFnXgGXjxo3mGFhffPyqq64yx2M3xFlvjz76qLnIy/XCWB8LFiywmjdvbl155ZXO7dx7773WTz/9ZJ5nEMRj5Wu2bdvmLPP555+bhjQb+5s3bzbBUJUqVaxffvml0DqcPn26OWZ+jjzGFStWWK+88kqBgUVmZqbVsGFDsy4I39fXX39ttW7d2i2wuPvuu826aTzOFStWWGeccYbzfezatcsEeNxnfHy8CdqIgU3t2rXN4/zM/vzzT7P2B38vLLA4cuSIdccdd1g//PCDqQOeS6yz+++/31mGr2NQyLIlpcDCRymw8D0KLFRvOt+8nwKL0lNgUbg9e/ZYI0aMMMEDF8jjFfOBAweaBlxxAwtib8VNN91kyjIrgoHJuHHj8mVFFAeviPNKdd4Fh7l4HBvZXDzvpZdeypdNUZzMDbsX4Nprry1w3wwsunbtalWrVs2qWrWqdd5557ktPkwMvjp27GjeJxetu/jii916RXhcbMQyG4UNYzby2XhnkOV6PAxI6tevb94TFyK+9NJL3XoObG+//bbVokULsx0u3Meg7Xi4gCEDBG6b+xg5cmShC+SxAc8gjNtnxsqnn37qFlgwu4Xvg70QdevWNT04rj0U/JwZoDLAGDJkiLMOGNjYx8DX9e3b11q0aFGhgQXPFdYJ64rnIuuE+3btYRg6dKh1++23W6VRXoFFwH+VKBWE080yn5L5lp6Ybpb71XSzqjedb95L39PSWb0rGXe8+ytev+kskwfOgcHFHajr707kOcdBqlzslrn+eQcd+zp7bQp7StmKwnELXDiOsy3Zk934Ek/Vm6+zjlNvHC/DNVb++OOPAtdVK8t3tSRt1/yjY0RERETEK3GwNadz5dSjIjYGBZxlqzRBRaWZFUpERERESoZTrIq44nIKedfj8AT1WIiISKVQF8kIO7AayM3x9KGIiPglBRYiIuLzglN34/XgSWjxxQAEZntucSgREX+mwEJERHxelfREhAVkYWfPSQg6Go/3g8cjJGWrpw9LRMSvKLAQEZFKI6Nmc9NjcU6V1QjMSvX04YiI+BUFFiIiIiIiUmYKLERExGftTk7Dmt0pWJfdANdljkV61ElFluONP4uISPnTdLMiIuL1GAwkHcl0e+zgkUwMm7ECaVk5CICF5pERqFWjGtKTHM/vTExD+u4Ut3IUHlwFUwd3Qu1qIYXur1a1EMTVDD+xb0pEpJJRYCEiIl4dTOQNDFwxSHjv5jMQk70bNf98HdG5rbGvbmP8X+7NmPPtASR++6tbOeK2hryzrMh9uwYfCjLElwwePBgnn3wyHnroIU8fSqXTpEkTjBo1ytx8yerVq3HhhRdi48aNqFat2gndl1KhRETEa9gpS4s2JaD3S4vQ/9VfnUEAA4OvR57ldvvu3h7o0aouWkVaCN29FEg/hPqxDXHz6Gfw/siL8pXjjT/n3Y7rzQ5AuF/un8fB47FTqZRS5T/27duHkSNHolmzZggNDUXDhg0xYMAAfP/9984ygYGB+OKLL/K9lo3Pnj17On+/8cYbERAQYG7BwcFmBe3zzz8f77zzDnJzcwvcf58+fVClShUsXbq0WMe7atUqzJ071xyzLTU1FXfeeScaNGiA8PBwE3S8/vrr+d4nA5KYmBjT8DzttNPw2WefuZVJSkoyZSIjI82NPycnJ7uVWb58Oc477zzUrFkTtWrVMse/cuVK5/M//fQTBg0aZOqxevXq6NixIz788MN874OPnXLKKahatSrq16+Pm266CQcPHnQ+n5WVhXHjxqF58+YICwszZefPn19ovYwfP97UuzcFBNu2bTPH5Fo/J0r79u3N4nkTJ0484ftSj4WIiHhlz4Tdy1DiXoOjiYjbvhBxLc8Hqkble5rbOd62GHy4HlNBPRw8PpZTylTlxIbfmWeeaRrJzz//PDp06GAatN9++y1GjBiB9evXl3ibF1xwAd59913k5ORg//79pjF89913m0b8l19+iaCgY82yHTt2YMmSJSYoePvtt9G1a9fjbn/y5Mm44oorUKNGDedj99xzD3788Ud88MEH5or7ggULMHz4cMTGxjpX8GaQkJKSYo6hTp06+Oijj3DVVVfhjz/+wKmnnmrKXHvttdi1a5ezAT906FDzuq+++sr8fvjwYfTt29dsc8qUKcjOzsbjjz9uHuPrGEwtXrzYNHLvvfdes/958+bhhhtuQEREhAnY6NdffzWPsRHMx3bv3o1hw4bh1ltvxZw5c0yZRx55xLyfN998EyeddJL5TC655BKzfft4XYOdadOmmc+vssrKyjL1WxQGZ6zHsWPHmmD1hLGkQqWkpFisdt5XtNzcXCspKcnci+pN55t38ofv6a6ko9bqXcnm9tPGeOukR76xGj/wtbnxZz7G51iuuHJ3/WklPdvB3Fu7/7KsxyMc9+V8vPZtzp+7zPHyPu9zJT32ynzOpaWlWevWrTP3vubCCy+04uLirNTU1HzP2fWVlZVl/k+fM2dOvjJ333231aNHD+fvQ4YMsS6++OJ85b7//nuzjTfffNPt8SeeeMK6+uqrrfXr11s1atQo8Dhc5eTkWDVr1rS+/vprt8fbtm1rjRs3zu2x0047zXrkkUecv1erVs16//333cpERUVZb731lvmZnyGPcenSpc7nlyxZYh7bsGGD+X358uXm9x07djjLrFq1yjy2ZcsW52N2vdnn20UXXWTddNNNzudfeOEFq1mzZm7H8sorr1gNGjRw/l6/fn1r8uTJbmVYt9ddd53bY4cPH7ZatmxpLVy40HwW/EyO53//+5/VqVMnKzQ01Kpdu7Z1ySWXOJ9r3LixNXHiRPPz1q1bzXv766+/3M4LANaPP/5ofk9MTLSuvfZaq06dOlZYWJjVokUL65133jHPsZzrzfVcYZmTTjrJHEPr1q2t1157zVlv//77ryn/8ccfm9ewDMtv27bN6t+/vzkHqlatarVp08aaO3euc5sZGRmmLM+3kn5XS9J2VY+FiIh4dLxEqXsmKkhBPRw8Th73qI8LTmPQGA3flpiYaK7MP/300wXmpLMXw9E2LLtzzz3XpPJ8/vnn5qo8cdvs2XjttdfMFflWrVrhk08+MVedi0qDYmpS586d3R4/66yzTE/EzTffbHoJmI60adMmvPzyy25lPv74Y/Tr18+8N+4rIyPDmcrFnhOmP3Xp0sX5Gvag8DH2ErRu3drc2NvB3hWO72CvDH9u27YtGjduXOhxs6eE6Vm27t274+GHHza9GRwXEB8fb3p0eGw2HhtToFwxzYu9Ha7Ys8TX9e7dG0899RSOh2lkl156qdn/jBkzkJmZaR4rrUcffRTr1q3DN998Y+pmy5YtSEtzzEq3bNkyk5703XffmToKCXFMJsFeGPb0sPeJvS9//fUXbrvtNpMWdv311zu3/cADD+Cll14y5wnT9NiDxOP9+eefzTnL/TLdzMbt8zz75ZdfzDl3oiiwEBERj6U4UbkEExGxQNfhjvvDe3Gi8XjtdKm88qZPKcgoxOF9jpur8JpArSZAVjqQsCH/a2I7Ou4PbAYyj7g/V7ORI/XtyAEgZZf7c6E1gNrNi/35sgHIxj0b9RWB+2FgYGNj8+jRoyaNiNigZCO9qMCCqVtMcYmOjnZ7/JVXXjENU46xYKoVx4S89dZbJpiwMahg6lPt2rVNGTZimXbEMQz2GIy82yU+xueI6VcMWpgK9X//93/mMQZETFNyTfFyxYCBqUpvvPGGW2DBMRY8nvT0dJNSNXDgQLz66qvOMqyXCRMm4JxzzjHHyDEv//vf/0wwY5s1axb+/PNPs/3iYiB59dVX48knn3Q+xsZ4ae3YscMEB3awx1Q0W926dc0965xjW2ysOwYMDHCoadOmJkhgOpdrYMHxInYZe1+XXXaZSTUjjgvKKy4uzpwnJ5ICCxER8d7xEsVVPRo45SqgemSFBBbHG6tR2BgNjctw8ce7wKJn3Suu/ZXAZW8Ch3YD03rkr9gnUhz3X9wB7MrTYLxkmuMcWDsHmDfG/bnm5wKDHfn5xWH3RnBwbUXg/lz3xSCCDWu7QX7NNdfgvvvuM7P6sGegILwSzivXeY+ZgQUHf7PXgj0HvKLNMRYcFM0r+faYBQ7OZkDDK+scjM6xGry6bTdUC6oL1+Pm/tkrwnEpM2fONI38F198ERdddJFp3LNHwRWDEA5o5xV6XrG3sRF911134bHHHjMBxN69e8175/gA1guxt4XBEgMy7p/BBYMuXr2nnTt3mrErHE+St2ejKBxIze2WlzvuuMM09hngcCA7B64zcCpMQkKCOfZbbrnF7TgYXLF3yFXeninWGffH98zPlfvNO66EnwED1hNJgYWIiPhmMOEqLQn4ZxFwcg8gpBrQ4HTHvYe4Bh12kLElPtWkTi3fmoik6OpemfZVoTrfBLS+MH+PBUXEAUMXFf7aQa8X3GNBbS9xfP55eyxKoGXLlqbBygHabAwWhVfqmc6TF9OS8jYGC8P98Mq0nYbFhj0H5LrO3sSGOmeQeu655wrcBgMCNhqZDmOn1bCxz7Qk9j7YqURsbLIBzUY/G6D//POPSbtZs2aNs4Fvp8wwFWvq1KnmijoHmxfUEObsVsQB37wazrQp9orYj3F2KPYmsCfAxuCGPRvsdeBA7bwzODE4YTBhHy9Te84++2yTzsSAiFf7WUfs0eBsUUzxevDBB511uGLFCpNC1alTJ7f64375XplKVdAA5rzBT1Hs9+iaEpeVleVWhqlc27dvN+lUDNo4YxbTs1j3BbFnB2Ow5Zp25ro/W94UPabRMRDjvhhcsB7Z8+E6QxjPLbsX6kRRYCEiImUKKjgdq0eCCVdJ24HvngBipgNxpwK3fgdvYQcZecdl+H2KVI0YmFtBgsOOpT0VpE7Lwp+rVsdxK4OoqCjTSGPDmleC8zbiXIMGXjXnFfkhQ4Y4n2djk41bNiyP54cffjDrDHD2JmIaENOW8k5hy3QfNhaZrlNQahGnbrWv+Ns/s6HLW95GKRvVdiPWvoJdVJlu3bqZ4MkeF0C///67ecy+As/tcBuuPRv2767T6bKngqlNzz77rBkXkBe3k/f92UFA3nEt7I1geg/f4+zZs3HllVeax9mAZ526Yo8GPyuOTShsViQGMaznolLO8qYysUfFnolqZQFTx7Ice2Z4Y3DEgImBhR38uaZvMUjj+/n3339x3XXXuW2H7921bEE4jS97duzZnxiguAYWDB4vv/xynEgKLEREpNS9FLwKz6Bi0lUd0aK8r8In7wSOHnTkzfNqdFYakLDRvUzV2kDNhj7xCbqOy1CKlPfjlKlsNLMhzTUT2OhkSsrChQtNTwIb8MSpU9loZKOV6S7sJWA+PHsCeHXaFa+Uc0yC63SzDBb69+/vvHLPdB82/tq1a+f2WqYxsVHMK9L2NLF5G7Bcf4IDmO3AgtO49ujRwzRmeTWe21i0aBHef/9901tAPO4WLVrg9ttvNw1e5vwzqOH7/Prrr00ZDq7mVLlMz7HHQzAo4HHbqVlck4P74XtmY5bBBIMHBgm9evVyBhV8DZ9nqo49PoONbAZzxClmuR/WsZ0KxfEE/BzYM2EHNZyGlu+T90888YTZ3/333+/sRcpbfwwO+d7yPu6Kg6YZlPCqPntY+Hlz4LW9XVesTw5g53vk2IkDBw6YlDJXTOdirwl7gvjZsz7tgeocn8Jt8BxgIMkgicEq3wuDWX52DEz5Ok77y94GpncVhnXE8hzXwrQ2Bqyug+LZm8S6stPfTpjjzhsl5UrTzfoef5j+80RQvVXeeuNUqnmniC336VWTdljWUzGOaWO/GOF4bP86x++ut3F1LCt5p5W79n/5p5v9+2PHz7xl/jeFYuJWx7YL26ddvrAy5ciexjbv1LUVPVWtppst3J49e6wRI0aYaUZDQkLM9LMDBw4004m6Tps6a9Ysq3PnzlZERIQVHR1t9e3b1/rjjz/ctsXpZu2pRYOCgqy6detavXv3NlOFcqpY4mv4/LJlywo8ngEDBphbYaZOnWp17drV7bG9e/daN954oxUbG2umPOX0pS+99JLb35hNmzZZl156qTl2TlXaoUOHfNPPHjx40EznyqlveePP/FvlasGCBdaZZ55pRUZGWrVq1bLOPfdcMy1tQXVQ2FSr9vSynC41PDzcTC3Lfe3atcv5/E8//WSdfPLJzilhBw8ebO3evdsqSnGnm509e7bVsWNH83lzmljWS0HTzRKnZ2V98zj5mgULFrhNN/t///d/5jj5PKfv5ZS4nC7WximGGzZsaAUGBrrVwYcffug8BtbjOeecY47LdbpZ12lu6c4777SaN29u6oTnFuvkwIEDzuefeeYZc14Wprymmw3gPyc2dBFXhw4dMhEpuw8ZjVYkftTcL/dfUQPSKgPVm+pN51v+Xgqm85S5l2L/WiDHPSfZzNzDfPh/fwLevxi49E2gUdfCeywiG5i0F2vqOUg5koHImz91/H177Qwgy2WQ4sg/HduefRuw4WvgqhlA1TqOVBze9q8DXu92rHytpsAtCxyDwj2QTjZ1cKcKSyc7kX/jmAO/detWk/tekkG0vsBOTWFajbf8n8r6Zg8CZ0Ri+pI38sZ68wVWGeqNvR4cN8RB9Ry/UtLvaknarkqFEhGRUjV+T28aVfxGr53W5BIM4IPLgcN73MsN+RpoerYjsAiuCjTqdizVKTi88Lz7S6cBGQGOsvxPd8SyY/uzBwNT12GOwOKDyxy/93gQ6DUW2PdfPvb1sx0Bh32MFUApUlJe2CBkmhPTckRsHEDOtTkKCyrKkwILERE5MWMpsjOAoFAgfj0wpeuxx2vEAkN/BK7/rOAeCzpjKND5luKPn6jbmittHfudryvotXGd3IMOe/AwZycatebYa7gWwp48AzFrtwBCjy04VdGzSJHfzyQlx8UxFSKuOO6Ct4qgwEJERMq/l4I9FH+8DXS789hCZ3ZvAAdcFzUjEHGhuxOloKAjLMJxo0N7galnuvd40C0LgahmxxZfO0EDxwubRYr8fiYpEfFqCixERCRfDwUVu5eCQQTThpiqlLwDOJoIHNgE/PYy0GYQ0KK3e2+At4uo71hDIW9gwXEeP78ILJ3iGHPKVK2bvnGkZ2UedbxnWzkEHXlX99ZMUiLi7RRYiIhIgT0URfZS2GMmjh5wjFewx0Yseh74a4ajDBvebGBzMHYJFyjzuMJSqbreAXS40vG+Px7seK8MLBhUuK4UzffOlKtyCC5c616L7YmIN1NgISLi5wobR0EF9lIwFejV04Acx5V0w05r6nE/cPqtPrfGRKkCDgYOtjqtjq0UfXAL8NUox2rgXB2aK4CXUz0Utdgegw5vXcnbdYE0Eam831EFFiIifqxE4yjsXgqmPI1eX/BYA6YL8eYPXIOFkKrHZqziffv/Vrd9rYsjPcye3rZWEyC8Zpl37ZomlXeQtzcN8ObCZ1x9ec+ePWYBN/5eWaYY1bSpqrfKcL5ZloXMzEwkJCSY76q9InhpKbAQEfFDJZrtiVfed69wpP5wbYiYDsCwXypsOlaf1m8C8OHlx6a3vXqmY2aqw3vL3KPjC70XbKhwXnyunszgojJe5eV7FNWbr59vVatWRaNGjcq8fQUWIiJ+psSzPXFNiU9vdIwb4MxOkZUsvelEanKm+/S27LHgbFnfjyvXcRje3HvBK6BssGRnZ5srrpUFr/QePnwYNWrUqDS9MBVB9eZ99cZekKCgoHLZrgILERE/UaxeCteF7I4kANt/Azpe5xg/UBnHTHhiIHjH6x3B2ee3Odb4KIc69fbeCzZYgoODza0yNfS4ojEXpVNgoXrT+eagwEJExA8Uq5ciPQWYdx+w6Rv3F3OhujotK/iIK7Ea9RwrirPHYuUHQLOejiCuWl0gKKRS916ISOWmwEJExA+woVmsXooBk4DDDx57oXopTgz2UjANKjcbiF/nmKr20jcds0v5wdgLEamcFFiIiPhJ+hMxqGgXF3msAIOK185wDMqm+/45NruRnFh28MDPgL0XTI2ycUHB7AwgKLTUQYZ6L0SkoimwEBHxo/QnXsV2w54KBhX21fIwl6BDKrb3gp+FlQtUrwfUqA+8NwDY82eZBnir90JEKpICCxERfx2k7brAHYMK9VR410rf3UYAs65xBBwnYOYo/qy0KBEpTwosRET8ZZD2kQPAno3A0QOONSkadQWu+wx4cKdjdWjxLhGxjnvnLF3/9S6VsffCZqfH1awajOqaLVVEyoECCxERfxmkvXYOMG+M42fm9PccCwRWAcIiPHrMUggO4qa9K4EW5wF/Tnesf8HxF2Xowcg7qLtqcCC+GHoaIpUFJyJlpMBCRMQfBmlT20uABqc7ftZsT96PwQODCAaBVP+/QfU7ljgGdtdpUS5pUfd8/BfW7UlBRkCoWY9B09KKSGkpsBARqcyDtO2pZNOSHNOannINUDXKswcsxefaM8FxMPbsUY3PAoZ8BexbVapAMe+g7hcXbMLuI5tgIcD8PnVwJ9SuFqIgQ0RKRIGFiEglS3+qkxOPGKY/MaiY1J5rBB8rfPJABRaVYfaokOpAbpZj/QtiwFGK2aMYXCwY3QP7ExIRUrU6Eo9mYdiMFRjyzjLzvNa+EJGSUGAhIlKZ0p+qHQImdXasRxEcDjToDPR8EKhaR+lPlW32qNxcYOgi4MAmRy/G4X2O59IPlWjcDIOL6gHVERkZaVKhNHuUiJSWAgsRkUqQ/hQZnIPoIxuAg9sdBVJ2OaaPvfYT9VBUVoGBjs/YHuQdFOKY+WvuaKDP0+U+e5TGXojI8SiwEBGpDOlPWbsRPb3bsbQYu7Gp8RT+M8ibC+txHM26/wEn9XekTHGhvRr1ymX2KKVFicjxBMKDnnjiCdPt6nqLiYlxPm9ZlikTGxuL8PBw9OzZE2vXrnXbRkZGBkaOHIk6deqgWrVqGDhwIHbt2uVWJikpCYMHDzbdvLzx5+TkZLcyO3bswIABA8w2uK277roLmZkui0cBWL16NXr06GGOJS4uDuPGjTPHKCJSUb0Ua3anmFve2Z9i4po50mJ4K8NKzeKj+Hmzx4IBpT3Am+MvVn5Q6k3as0d9PfIsE8AykGVAKyLitT0Wbdu2xXfffef8vUqVKs6fn3/+eUyYMAHTp09Hq1at8NRTT+H888/Hxo0bUaNGDVNm1KhR+OqrrzBr1izUrl0b9957L/r3748VK1Y4t3XttdeaYGP+/Pnm96FDh5rggq+jnJwc9OvXD3Xr1sWvv/6KgwcPYsiQISZoePXVV02ZQ4cOmX336tULy5cvx6ZNm3DjjTeaQIT7FBGpyNQnt9mfkrYBPzwNnPswUKuJPgh/5jrAm9hjUQZKixIRnwosgoKC3HopbGzUT5o0CQ8//DAuvfRS89h7772HevXq4aOPPsLtt9+OlJQUvP3225gxYwZ69+5tynzwwQdo2LChCVb69u2L9evXm4Bi6dKl6NKliynz5ptvolu3biZAad26NRYsWIB169Zh586dpneEXnrpJRM4PP3004iIiMCHH36I9PR0E+SEhoaiXbt2Jrhg4DN69GjT2yIiUlGpT1QbSah/dKNj8O7qT4BuI4Ba+gz8nj3AOy0ZWP8lULMxEBZZpsH7BaVFaUpaEfG6wGLz5s2mMc/GOhv+zzzzDJo1a4atW7di37596NOnj7MsyzAVafHixSawYK9EVlaWWxlui41+lmFgsWTJEpP+ZAcV1LVrV/MYyzCwYBm+xg4qiK9lmhX3wV4KluG+eQyuZcaOHYtt27ahadOmBb4/boM3G3s+7MCpotOo7H0qfUv1pvPNe+X9ntozP/0Tn4oAWGhetxraxv4348+PU2D9/Jzj5+BqQHgUNwB/pL9vBeDsUF/edex3pkgNX5ovuChO3cVGhmHh6HPMuXjwSCaGf7ACN77zuzPI4JS1rgO+/YHOOdWbv5xvVgn26dHAgo39999/36Q57d+/36Q6de/e3YyjYFBB7KFwxd+3b3fMesIyISEhqFWrVr4y9ut5Hx0dnW/ffMy1TN79cJvctmuZJk3cUwzs1/C5wgKL8ePH48knn8z3OHtbPBFYpKY68rLVw6J60/nmnVy/pwmpjgZcenau+b1L5CFUO7gGKWnBjsLN+gENz3X8HFYTCIjgHxf4I/19KwDPh1t+B9KTHVPR/vEOkJQIHNwPhEY4B3UXt+6qBwDVqwMNq4fgi6Gn4XBaFnYmHTWL63EdDE5Z6090zqne/OV8O/TfRXGvDywuvPBC58/t27c36UnNmzc3KU/sVSio8lixx6vQvGUKKl8eZezAoKjjYY8GU6VcPxymarHHhClWFck+XnuuclG96XzzPvyexh/OQFIq8G9CFv5JycXEKzvipKopaPlZbwTOSTtW+LpPgRaONFB/p79vhYiMPPbzqQMd9+MbAVaOs/eiNHVnbzZkd4pZsZuL6/H1/kTnnOrNX863gBLsz+OpUK44EJoBBtOjBg0a5OwNqF//2OCz+Ph4Z08Bx2Zw5ibO+uTaa8Ey7Pmwy7A3JK+EhAS37fz+u6NL18ZtMs3KtYzde+G6H8rb2+GKqVOu6VM2exasiuY6A5eo3nS+eR+mPo348E8TUFgIQLPgZHSrsR/1Iqs6rjD3fuLYAO2oZvxSe/qQvYb+vhXTgInA7FuAnUuBanXMQoqlrTuW53n6T8IR87O/rXWhc0715g/nW0AJ9ufR6Wbz4lgEDrZmIMHUIjbmFy5c6HyeQcSiRYucQUOnTp0QHBzsVmbv3r1Ys2aNswx7QZh2tGzZMmcZBhF8zLUMX8PX2jigmwEB92GX+fnnn92moGUZjsvImyIlIlJazGFn6hN7Kb69qSm+Cx2DenOuAKJPBu5eCbQd5FgUjbcSrK4s4tSwy7EpaTnwn4vqJWwE9qx03JJ3lmpQd/9XfzUzlzE4FhH/5NEeizFjxpi1Ixo1amSu/nOMBVOFONUroyNOJcvB3C1btjQ3/ly1alUzfazdHXTLLbeY6V451WxUVJTZJns97FmiTj75ZFxwwQW47bbb8MYbbzinm+WUtBy4TRz83aZNGzMF7QsvvIDExESzHb7GTlfiPjlWgjNFPfTQQ6ZXhcfz2GOP6eq/iJS75tHV0TrwAJCdBgx6TTUsJ2ZK2pqNHFMVr/0OSOP4RcsRdBRzLRR7rQsGxFxbhQHG8q2JSIqu7ne9FyLi4cCCa0tcc801OHDggFlDguMqOC1s48aNzfP3338/0tLSMHz4cJOaxMHe7CWw17CgiRMnmilrr7zySlP2vPPOM1PCuq6HwaliueCdPXsUF9GbPHmy83mWnTt3rtnPmWeeaRbAYyDx4osvOsswiGHPyIgRI9C5c2eTesWxE67jJ0RESst19qcQZDkezDziuI9qroqVEzMlLZ15N9D6SqBqiGOg9+aFQEBgide60ErdIhJgae7RCsUeGQYpTMXyxOBt7leDt1VvOt+8d/G7OBzAsJrLcN7gBxB7eA0w6xpg1BqtpH0c+vtWjnWXkQoc3OJ4soRrX9gBst17Ya+7Uhl7L3TOqd785Xw7VIK2q1cN3hYR8SeujTB78bu2Af+izrcTURMHgabnKKiQihe/Dnj7fMfPJUiLIvVeiPg3BRYiIh7upSAOgO1a+yjqJe1FCvPcKbS64yZSkaLbAEMXOQZ2c4C3GYvREEiNB6rnXxequGMv+HNl67UQEXcKLEREPICNLLuXwk4VifntEVjL3wZqtHakoIh4AoNZzjrGc5C3yAaOmaPe7gMM+arEvRc2Bhi2ypgaJSIKLEREPIpBRbu6wcCBjUCXYUDH64HcqhpTIZ7HAGLYb461LjgNbdLWY70XJZB3UDfxd/ZoKLgQqVzUYyEi4qFxFbE4gLADq4GDexwpJ0w/4ZXilBR9JuIdIo4tUFtarmlRpNQokcpLgYWIiAfGVcTgIL4LfQDV56QdGySr9CfxdhmHS/WyvGlRrqlRSosSqTwUWIiIeGhcxeGAXqjO2Z9cp/W0/hu4LeJN7KD30B7g8D7gj3eBzjcBNWJKvCmtdyFSeSmwEBGpQEx/ahe4FS0CqjsGxVbrqPoX78egl+uphEUCif8Ci54FajcH6rQq8VoXmjFKpPJSYCEiUkHjKnZv24TvQu9D1TkZjifqngQM+RqoXlefgXg/O3hgIMHUPY4LovZXAv0nlmhq5IJSo0TE9ymwEBGpoHEVbQO2om9oBhIveA1Rjdo5GmgKKsQXAwwumscZoqha3VKv1G3TeAuRykGBhYjICZ79qVbWfkzpG4u46O44mP4earfpCYTXVL2L72LwYAcQB/8BpvUo1UrdBY23mDq4E2pXC9GgbhEfpMBCROQE9lJwTIVJf1qUAZz3GHD2vapvqVwi4gpeqftoIlA1qtjjLQ4eycSwGSsw5J1l5jmtdSHiexRYiIicwNmfOFDbjKm49E2g6X9XdUUqk+CwYyt1k71S98yrgcvfPW7vhet4CzvI0FoXIr5JgYWIyAnAnoqWtUPQIui/Aa2cPadGPdW1VP6Zo+yVunctL/FK3RrULeLbAj19ACIilU1w6m4sDrsLoUmbHFdv21ysxe/EP+QNIpgexZSoUmLPxZrdKSa9UES8n3osRETKcbA2JezZjdYAAnIyHVdvB04GwiJUz+I/XKekvWQacMpVJXq5FtET8U0KLEREyiGouOyludiXFY4A5GJg4GL0CgFqVK/qKKCgQvx5StqQasCP44GGpwNV6xRrWtqCFtFbvjURSdHVNVuUiBdTYCEiUkap+7diUsCLSBz0JhrH1kPbd65HblA4oqNjVbfiv+wpaZN3OlbqdtX8XODyd4DwWscdb6HeCxHfocBCRKSM6U9MfeoVuB5bwlPQokFbM/VmYCkXChOptIO67QX1iGOPiggqXKn3QsR3KLAQESnDWhVhWUk4J3CVSX2KCA8GAgMdU2+KSMEL6uXmAMnbHbeAKsVarVu9FyK+QYGFiEgZ1qr4qGs8Tl05RalPIsV1aA/wyqnHfi/Bat0F9V7wZ3sdDBHxLAUWIiKlUCU9EVdV+RHVWl4DnKHUJ5FSpUblXa27FGtdMMAgjsVQgCHiWQosRERKM65ixxY8F/wmtmQPAmLPUh2KlCY1ql5bx0DutCTHonolGJukQd0i3keBhYhICcdVxGTvQoeAf46NqxCR0qkS7Fjr5X93Apu+UVqUiI9TYCEiUsJxFZ/GzUKdg8s1rkKkvFzwDNDuUkdaVMKGMqdFkVKjRCqeAgsRkeKychGCLCSe+zzq1ArUlLIi5SWqGRD4X+/f9t+ABp2Bf38CmvUs1rS0edOiiL9zoLfGXYhUHAUWIiLHsW/HZqQm7Uf69jXYFPYAtmTP1bgKkRM1qDsoFEjaDnx6o1kTpjiBhetsUaQZo0Q8Q4GFiMhxgoqYdzo7fz9qhaJ6rXqqM5ETwU6B4pS0JZQ3LYo0Y5RIxVJgISJShIOoiVsynsH9vZsirk6ECSpiGrVUnYlUhJSdpVpwUjNGiXiGAgsRkSKmld1yMBNrrSaofdKZaBEXqboSqQicdpYL5y16Hjh5AHDkAJCy69hzxVipWwvpiVQ8BRYiIgUEFYNfmo3w7GTUDUjG1NCfUSe7OQAFFiIVgoEDV+POOuoIKLhSd05miVbq1kJ6IhVPgYWISB6p+7fihyojgCqO33ODwhEYWU31JFKRXAOHkX+WeqVupUWJVBwFFiIiedKfdiZm4pfsC9G731Vo0ripppUV8ZaVuuu2BoYvBQKDir1St9KiRCqOAgsREZdVtbkAHoUH34gLT+4B5JllRkQ8KDgciD7ZsVL3XzOUFiXiZRRYiIj8t6p2raz9mNI3Fk2qZaFm5m7UCs1giKH6EfE2Pe4Hmp7jSItK/EdpUSJeQoGFiAgvhKbuxneh96HqIgYT/2nXBwivqfoR8TY1GwEIcPRYcIXuuE6O1ChOTRtao0RpUcu3JiIpuroZi6FVukXKRoGFiAiAwKwj2GXVQdj5j6FRs5OKlbstIl4wc1RgFeDgP8B7/R0rdR9n3Qt7tigN6hYpfwosRAT+vrJ2atJ+7EpKx02ZL+DrpmcBsZpWVsQn2MF/arzjnrNGVQkG6rU97ks1qFuk/CmwEBG/Dioi3j4TMQEZqGeFIzx4urmKKSI+uqAex1zUiAXuXV+sl2mtC5HypcBCRPwWeyoYVPxx2nOo2aQDvmt0qnKsRXw5LYrrW7DHYv9a4IPLges/K1bvhdKiRMqHAgsR8Xs1G7dDiw7d/b4eRCrFWhfEgdyH9zgCjJwsoHZzDeoWqQAKLETEb8dVbEsB7s54Gs/XbOHpQxKRE5UaRUO+BpqeXeRLNKhbpOwUWIiI346rWJx9Pv4NuhU1IzVYW6TSpkYRp41mLwYdZ8Y3DeoWKT0FFiLit+MqurQ+B9/Va6pxFSKVOTUqOwP4aTzw28uAlVus1brzDuoWkeJRYCEilV/yTseVy9qOlKdcK8AxrqJ1G08fmYicaEGhQOdbgDaDHNPRMj2Kfw9KsE4NF9MjLaInUjQFFiJSuSXvRO7k0xGYnYZ/Bs7Bpsy6+CnnApwdFuXpIxORiu69qBoFnDoYCKnmSI06TlqUZosSKZlAeInx48cjICAAo0aNcj5mWRaeeOIJxMbGIjw8HD179sTatWvdXpeRkYGRI0eiTp06qFatGgYOHIhdu3a5lUlKSsLgwYMRGRlpbvw5OTnZrcyOHTswYMAAsw1u66677kJmZqZbmdWrV6NHjx7mWOLi4jBu3DhzjCLiveLj95ig4u7M4RjwSRKGf7EDrwZci+r1mnr60ESkotVsBFw8GcjNBqb1AF47w9GjeZzxFl+PPAuTruqItKwcLN+aiDW7U8wt/nBGhR6+iLfzih6L5cuXY9q0aejQoYPb488//zwmTJiA6dOno1WrVnjqqadw/vnnY+PGjahRo4Ypw0Dkq6++wqxZs1C7dm3ce++96N+/P1asWIEqVaqYMtdee60JNubPn29+Hzp0qAku+DrKyclBv379ULduXfz66684ePAghgwZYoKGV1991ZQ5dOiQ2XevXr3M8W7atAk33nijCUS4TxHxTofSshANYND55+K2VmeYx5TOIOLnajUBLn3TkRa18/dijbfI23sRAAvNIwMxfVhPNKhVtQIPXsSLWR52+PBhq2XLltbChQutHj16WHfffbd5PDc314qJibGeffZZZ9n09HQrMjLSmjp1qvk9OTnZCg4OtmbNmuUss3v3biswMNCaP3+++X3dunXsUrCWLl3qLLNkyRLz2IYNG8zv8+bNM6/ha20zZ860QkNDrZSUFPP7lClTzL55DLbx48dbsbGx5liLi9vjvu3tViQeZ1JSUomOV1Rvvnq+7d2+ydq06nfr+x+/tw48Fmdt+nuJ5Qs8XW++SvWmuiuxpB2W9VSMZY2rU+yX7Eo6aq3elWxuc1bstM4c95W55+98TvRdrYx/40rSdvV4j8WIESNMb0Hv3r1Nj4Rt69at2LdvH/r06eN8LDQ01KQiLV68GLfffrvplcjKynIrw7Spdu3amTJ9+/bFkiVLTPpTly5dnGW6du1qHmOZ1q1bmzJ8DV9r42uZZsV9sJeCZbhvHoNrmbFjx2Lbtm1o2rTgtApugzcbez6IvSEVnUZl71PpW6q3yn6+mSll3zkbaVZN3JL5EsKD38SChh184tzX91T1pnOugkQ2AIb/DqQlAvEbgM+HAueMASIbFjr2IjYyzNzMy8ODEB4UgNGf/AULAaY3Y8HoHppN6jj0N8736q0k+/RoYMH0pT///NOkFuXFoILq1avn9jh/3759u7NMSEgIatWqla+M/XreR0czEcIdH3Mtk3c/3Ca37VqmSZMm+fZjP1dYYMGxI08++WS+x1NSUjwSWKSmOma24HgWUb1V1vPtwP49CK8agz1tR+OzVh1RIzwY1QMykZLiPm7KG+l7qnrTOVeBAiKAqhHA4f3AkQzgq0ePPXftJ0AN97aBq+oBFl689CRkIQS7ktPw4oJN2J+QiOoB1Svm2H2U/sb5Xr3ZF8W9OrDYuXMn7r77bixYsABhYY7ovyB5K48Ve7wKzVumoPLlUcYODIo6HvZojB492u3DadiwoekxiYiIQEWyj5f7VmCheqvM51tCSBVEpm1HdINmaNEyDr5E31PVm845D+AimTd/6piGNj0ZOLAFqF0XCI8s8rva6L+/caF7DmH3kU3YmQqEVNU4rqLob5zv1VtJ9uexwIIpRvHx8ejUqZPzMQ6i/vnnnzF58mQzQNvuDahfv76zDF9j9xTExMSYmZs465NrrwXLdO/e3Vlm//79+fafkJDgtp3ff//d7Xluk2lWrmXs3gvX/VDe3g5XTJ1yTZ9y/ZA80bi396vAQvVWGc83pkAlZ1jYm5SOlkxO8NFzXd9T1ZvOOQ+o1chxo3ptgeQdjlsRU9La39Wo6qEICw7CqE/+No8zLYqzSWmRvYLpb5xv1VtJ9uex6WbPO+88M33rypUrnbfOnTvjuuuuMz83a9bMNOYXLlzofA2DiEWLFjmDBgYlwcHBbmX27t2LNWvWOMt069bNpB0tW7bMWYZBBB9zLcPX8LU29qQwILADH5Zh0OM6BS3LcFxG3hQpEYFnxlW8fSbmvzceI79Nxq05Y1E1ppU+ChEpuVWfOKajLcaUtMeblnZ3cpo+AfEbHuux4HSxHDDtilO3cspY+3FOJfvMM8+gZcuW5safq1ataqaPtbuDbrnlFjPdK18XFRWFMWPGoH379mYwOJ188sm44IILcNttt+GNN95wTjfLKWk5cJs4+LtNmzZmCtoXXngBiYmJZjt8jZ2uxH1yrASnmH3ooYewefNmczyPPfaYT14RFalsUpP2IyYgA53P6Y/ebXubqSFja4Z7+rBExBd1uBJoclaJVuoubFpa9V6IP/H4rFBFuf/++5GWlobhw4eb1CTO7MReAnsNC5o4cSKCgoJw5ZVXmrLsCeG6F/YaFvThhx+aBe/s2aO4iB7TrWwsO3fuXLOfM8880yyAx0DixRdfdJZhEMOeEc5ixZ4Vpl5x7ITr+AkR8byYevXQIq7wvGgRkeOqHu24hUUArS4s9krdrr0XSUcysSU+1QQY/FlpUeIPAjjnrKcPwp9w8DaDFKZieWLwNverwduqt8p0vjEF6qAVgfh/V6HXosux5ZK5aHHKWfBV+p6q3nTOeaEjB4AXmgPBVYERy0xwUZzvKlOh+r/6q0mPahFdXYtz6m+cT/7fUJK2q1f3WIiIHC+oiHmnM4ZnPIFtVgyeCDkLZ9QqfDIFEZFSCYs8tlL3jiVARCwQEAhkcBrOwntIlRYl/kaBhYj49LgKGtW7JaJOOhtRwecjJrqOpw9LRCqbKsFAo26OHgsGF60uALIzgO/GARc9dmw2qTyUFiX+RoGFiPis0OQt5j62Tk2NqxCRE4tjK5gGxYHcHHNx8B9g13Jgx1LH6t1cybtanUIHdds47sLuzdC4C6lsFFiIiM/h9I0cDNnux7tx1ApFTliUpw9JRPwluLAHb3Mgd1AYMGcoM+CBi14Ezrit0JcqLUr8gQILEfEp+/9djYT3bsLozNsRjqeRFlQTM+o19fRhiYi/YYBx5ftA4FGuIObosSiC0qLEHyiwEBHfcDTRrIKbuXMlOgZsxqN9mqBuqzOUTiAinlOjHuejB9KSgL9nAtFtgPBahU5Lq7QoqewUWIiIb9i80KQc8L9qpj/FxsahtdarEBFvkHkE+PahY7+7TEtbEKVFSWWlwEJEfEPL84Ghi7AlIRU3zPwH06rHefqIREQcGECMWuMY2J2yC/htEpCdXqK0qOVbE5GktS7ExymwEBHvd+QAkv/4GHvjLsTG3LrYgxRPH5GISMEDu2M7Aif3d6zUXcRq3XZalHovpDJRYCEiXi9+9z+I/vEhXJdhYa3VFOHBVcx/xiIiXmtaj2KlRRXVe0GallZ8iQILEfFuB/9Bxt715scxfVprwLaI+Iahi4ADmxwL6h3a4wgsMlKBUEfAUJzeC+LvDDy05oX4AgUWIuLV61VEfD4KDXf/rAHbIuJbmBLFNCjidLRHDgDzxwLnPVas3gvS+AvxNQosRMQr7U5MxcUTFyAieyDC0VfrVYiI7w7qrlYXSNgArP7EMREFB3kXY0pajb8QX6PAQkS8UtrOlfijyk348dzPlP4kIr7LdaVujrdgalRAFeCc+4BzxgBVggt9qRbVE1+jwEJEvFrDqHC00HoVIlIZAgwO4mZvBXGl7iKCCpsW1RNfosBCRLxuXEXS4SNI377G04ciInJipqRNPwRs/AaIiAVCaxSaFuVKaVHiCxRYiIhXBRW9X1qE8Kwk/Bn2gBmwXb1WPU8flohI+UpPAeYMdX+MYzEYXBzaC0TUz/cSpUWJL1BgISJe48jeTXgFzyHgov/Dlsi5JqiIadTS04clInLiVuo+egCYOwYIDnfMHDX1TMdUtccZ2G3PGkVa60K8hQILEfG81Hgzz3t4/EqcX+VPbIkEWpxylqePSkTkxKdF0S0LgGp1HCt1m2DjYJGpUUqLEm+lwEJEPJ7+FLjkfdT//f/A/0aZ/pQTFqVPRUT8R/Vo99+5sF7tFo7F9LLSgeCwYq/Wrd4L8SQFFiLiMXv27cULr03FquwGCMfT5rG0oJqYUa+pPhUR8T+uU9LeshCIagb8MgHoeke+HozCVuvWSt3ic4HFn3/+ieDgYLRv3978/r///Q/vvvsu2rRpgyeeeAIhISHlfZwiUgkd3f8PJlWZ5FyrgnS1TUT8luuUtOyxOLgFWDrFsYp3IYvqqfdCvElgaV50++23Y9OmTebnf//9F1dffTWqVq2KTz/9FPfff395H6OIVEYJGxGavMW5VkW7uEhzcx2YKCLidxg4MJBgGpTpwQh39GBM6wH8NgnISsv3Ev7d5N/P05tGOXsv+r/6q5llj+mmIl7dY8GgomPHjuZnBhPnnHMOPvroI/z2228myJg0aVJ5H6eIVDazb0XDfas0pkJEpCSL6jHQKIR6L8QnAwvLspCbm2t+/u6779C/f3/zc8OGDXHgwIHyPUIRqXR4Be3oWROxKyEJD3+7B9Oqx3n6kEREvHv2qMyjwI7FQHA1R3BRyKJ6GnshPhdYdO7cGU899RR69+6NRYsW4fXXXzePb926FfXqaTErESlc/KZlqPvhhbgkcxzWWk0QHlzPjKsQEZEisNfig8uO/c5B3uzNKGRaWi2oJz4TWEycOBHXX389vvjiCzz88MNo0aKFefyzzz5D9+7dy/sYRaQyYF5wwkZk7F2HkIBsjOnTygzY1mBtEZESLqrHQd1fjQLSkoDMI0BINS2oJ74bWJxyyilYvXp1vsdfeOEFBAVpBlsRyW//jg2oN6Onc62K2Ng4tI6LVFWJiJQ0LYqDu9tf7njstS5A8o4iey80Ja1UlFJFAc2aNcPy5ctRu3Ztt8fT09Nx2mmnmZmiRERcx1T0m74Tcdlaq0JEpFz1ehj4ZDCwYwkQWgMIr1miQd2knmPxaGCxbds25OTk5Hs8IyMDu3btKo/jEpFKJHXfv3jQehu1+j+MuCat9Z+YiEh5iT312KJ6V88ETrqowGKFDeomLaonHgksvvzyS+fP3377LSIjj6UxMND4/vvv0bSpVswVkf8c3g8c2Yqq+//G1UE/YUv1+9BC6U8iIidmSlqOtZj/ENCsJ1A9+rgL6lHeHgz1XkiFBRaDBg0y9wEBARgyZIjbc1yJu0mTJnjppZfKdEAiUklkZwDrvgCWPoeGVo7WqxAROdFjL5J3Aktfc9yoSigwcgVQvR6Qut8ZZNi9F6TxF+KxwMJeu4K9EhxjUadOnXI9GBGpRIJCcaDZICTU645dSelar0JEpCJnjjp6APjzfceaFwnrgTfOcTxXRA+Gei/EI2MsuF6FiEiBeMXs6EEkHDyA6V//gS9SWiAV4VqvQkSkInsvqMEZQFgEkPhfu40BhxbVkxOo1HPDcjwFb/Hx8c6eDNs777xTHscmIr4YVLx2BpB1FHURgDHhjXFW/zfRoKkGbIuIVDgGFVQl2HF/YBMQ0wEIDCywuHovxCOBxZNPPolx48aZFbjr169vxlyIiCDjEBBWExg0BVuy6uD+r7ZjXJNWaKcB2yIinsNB3PbMUW0uBgJDCy1a2OxRmjlKTlhgMXXqVEyfPh2DBw8uzctFpLKq1xa7b/nTkau7/zASkOLpIxIREdeZo7iYHlft7jYCiIh11E1kQ6Ba7eP2XvBne9C3SLkFFpmZmejevXtpXioilXwhvN4vLUJaVg4CYKF5ZKC56iUiIl40c9SeP4FZ1xx7bsArwEn9gZSdblPUus4eRQwwSFPSSrkGFrfeeis++ugjPProo6V5uYhU0gHbOf+sxQ+Bj2D9he+gbvNTEWpl6OqWiIi39l7Y2GOx4Wvgq7scKVN83mWQd0FpUVMHd0LtaiEKMqTsgUV6ejqmTZuG7777Dh06dDBrWLiaMGFCaTYrIr4aVExqZ35sxElHEIq4mHpoFReJlBSlQomIePXMUTb2WHBqWo7D2Lfa7XnXtKiDRzIxbMYKDHlnmXlOYy+kzIHFqlWr0LFjR/PzmjVr3J7TQG4RPxNeEwcvmoaUwJrYfjhQ61WIiPgijrFo1M3RY7HkNaDVBUBuFhAYbGaRck2L0roXUq6BxY8//lial4lIJUx/ik/NwKCvArAnK9s8HB5cT+MqRER8OU0qOwPYtwqY1gMYugiIdVxMtmnmKCn3dSxExI+5rlcREIjrrf5ocPk4NKsf5cy3tSzL00cpIiIlZadA7Vl5bO0Lim4DBLlPxqF1L6RcAotevXoVmfL0ww8/lGazIuIrOOgv6yhw6Zv4x4rFBzP/wbT6UVqvQkSkMq59QfesAyLj8hVT74WUObCwx1fYsrKysHLlSjPeYsiQIaXZpIj4kqpRONL2WuwKaYv1aTWxR+tViIhU7tmjAgKP9WK4TElbnN4L0hS1/qFUgcXEiRMLfPyJJ55AaqpjjmMRqbx2oy56r7oYaSu2OWcF0XoVIiKVdPao9EPAl3cC6/537LlbfwAadCpW74Xr7FGxkWEV+Q6kggWW58auv/56vPPOO8Uu//rrr5vpaiMiIsytW7du+Oabb5zPM0ebwUpsbCzCw8PRs2dPrF271m0bGRkZGDlyJOrUqYNq1aph4MCB2LVrl1uZpKQks0p4ZGSkufHn5ORktzI7duzAgAEDzDa4rbvuusssBOhq9erV6NGjhzmWuLg4jBs3Tnnk4l/MwkorkfHPbzglZzVeufwkfD3yLPOfhVZjFRGppMIigD5POwZyXz/b8dia2UBaMrBhnuO+gN4L/v/A26SrOpqFU9mDsWZ3CuIPZ3jmfYhvDd5esmQJwsKKH4k2aNAAzz77LFq0aGF+f++993DxxRfjr7/+Qtu2bfH888+bNTGmT5+OVq1a4amnnsL555+PjRs3okaNGuY1o0aNwldffYVZs2ahdu3auPfee9G/f3+sWLECVapUMWWuvfZaE2zMnz/f/D506FATXPB1lJOTg379+qFu3br49ddfcfDgQZPSxcDm1VdfNWUOHTpk9s3xJcuXL8emTZtw4403mkCE+xSp9JJ3Infy6QjMTkMzALNCgI01+qF1XKSnj0xERCpy7YtRa4AqIUDSNscK3pe+CdRpVeiq3a49GAGw0DwyENOH9USDWlX1uVUypQosLr30Urff2QDfu3cv/vjjjxKtxs0eAldPP/206cVYunQp2rRpg0mTJuHhhx927o+BR7169cyq37fffrtZfOvtt9/GjBkz0Lt3b1Pmgw8+QMOGDc3ifX379sX69etNQMFtdunSxZR58803Te8IA5TWrVtjwYIFWLduHXbu3Gl6R+ill14ygQOPib0pH374oVkYkEFOaGgo2rVrZ4ILBj6jR4/W+h1S6cXH70XNrCyMyboT/1j1kRZUEzPqNfX0YYmISEWzA4ycTPcB3nVPAoZ8DVSvW/j4i/2H8eLclfhjayKSj2Zp7EUlU6rAgulErgIDA00DnalBffr0KdWBsNfg008/xZEjR0yjf+vWrdi3b5/b9tigZyrS4sWLTWDBXgkOHHctw8CAjX6WYWDBXhQerx1UUNeuXc1jLMPjZhm+xg4qiK9lmhX3wV4KluG+eQyuZcaOHYtt27ahadOCG1jcBm829nzYwVhFT8dp71PTgKreSrpWhfkxIwBdMt7DxCs74rbo6uY/A+bKFnY+6XzT97Qi6XxT3VU0nXNsEDYAhv9+bIA3fz+0B0jZlW+AN/+/4C0yPAjhQQEY/clfsBBgejIWjFY6rTefbyXZZ6kCi3fffRflheMWGEiwN6B69eqYM2eO6a1go5/YQ+GKv2/fvt38zMAjJCQEtWrVyleGz9lloqOj8+2Xj7mWybsfbpPbdi3TpEmTfPuxnysssBg/fjyefPLJfI+zt8UTgYU9uF4rpKvejuvwfuCTG4DsdPNrZGRzxFW7GQ2rw9yATKSkuI9D0vmm76mn6O+b6k7nnIcERADVIhw/c53UWcMc05EHhQF9xgExpwDBYY5F94JCUT3AwouXnoQshGBXchpeXLAJf2zahf21qqJGeDCiaxy7gCve8TfOvih+wsdY8Go+U434BhkMnHrqqSXeBnsMOFUtB1PPnj3bjG1YtGiR8/m8lceKPV6F5i1TUPnyKGMHBkUdD3s0mCrl+uEwVYs9Jkyxqkj28XLfCixUb8d1ZCtweCNwyTSgTktsTszG7g/3I6Rq9Xy9ljrf9D31NP19U93pnPMSV08FjsQDnwwBZl8F3PYjEN4A+PV54My7YUU2QKP/2iIxKelI/Pof3DPHsQifei+8829cSfZXqsAiPj4eV199NX766SfUrFnTvFlegWfKEAdRcxB0cbFXwB683blzZzMw+uWXX8YDDzzg7A2oX7++277tnoKYmBgzcxNnfXLttWCZ7t27O8vs378/334TEhLctvP777+7Pc9tMs3KtYzde+G6H8rb2+GKqVOu6VOuH5InGvf2fhVYqN6OK6oJDl70BvbX6IJc1MSW7FRYiC/R+aPzTd/TiqTzTXVX0XTOFSD2FMf9iP9SpDiom6t3//EWcNpgkx5l1xsHby+8t6fb2hd/bEtCcrTGXnjT+VaS/ZVqullO78or75z6NTEx0TTCuTgeH+M0rWXBIIVjEphaxMb8woULnc8xiGBvhh00dOrUCcHBwW5lOIicx2KXYZoVg55ly5Y5yzCI4GOuZfgavtbGAd0MCLgPu8zPP//sNgUty3BcRt4UKZHKYHdGGM76KhIXTVuD/q/+av7ga70KEREpFo6viO0IhLjM/MQAI2V3voHd7eIicXrTKOfMUfw/p/dLi7A7OU2V7WNK1WPBWZY469LJJ5/sfIypUK+99lqJBm8/9NBDuPDCC01q0OHDh01vB3tBuH1GR5xK9plnnkHLli3NjT9XrVrVTB9rdwfdcsstZrpXTjUbFRWFMWPGoH379s5ZoniMF1xwAW677Ta88cYbzulmOSUt07CIx8zj5xS0L7zwggmWuB2+xk5X4j45VoIzRfG4N2/ebI7nscce09V/qZQDtrN2bMNIazaaXjwGDRs5gmetnCoiIiXGgdz27FFdRgCd7gT2bOWlcOcg76JW7tb/PZU8sMjNzTU9BXnxMT5XXExRYmOePQUMErhYHoMKrhdB999/P9LS0jB8+HDTK8KZndhLYK9hYa8CHhQUhCuvvNKUPe+888yUsPYaFsSpYtmTYgc9XERv8uTJzudZdu7cuWY/Z555plkAj4HEiy++6CzD42PPyIgRI0zKFlOvOHbCdfyESGVaq4KhxPAgYGPUWK1VISIiZeu9GLHMkRpVtQ6wfyswsx/zVBwBB5/7L7goaOVue9VuLcTq/QKsUkxNxEXsONh65syZzilad+/ejeuuu840uDmzkxSM6WIMUpiK5YnB29yvBm+r3gqzb9t6rHt3BGZknYt4q6ZjrYp7LyvVH3Odb/qeViSdb6q7iqZzrgz1lrAXkVn7EXBws6MXgyt6M20qNR6o7pjJk2lQrr0XXL27hR/3XlgebMOVpO1aqh4LXu1ncMGxBUxj4hvcsWOHSUHiAnUi4pvpT6kpqRiacTdevKqzX/8BFxGRE4jjLup2BKrVcaRCcf2LIweAt/sAQ75S74UPK1VgwWDizz//NKlBGzZsMFEUxyjY4xpExMeCitfOMPOOc362CEw1QQUH04mIiJzQFKlhvzkCjD0rgaStwI4ljpSpqGZAWITGXlTmwOKHH37AnXfeiaVLl5quEI6FsMdDsHukbdu2mDp1Ks4+++wTdbwiUt74B5yLGV36JrZYsTg0878VVEVERE60iPr5B3jT9bOBFo4L1kWNvZg6uBNqVwsxv6uX3ccCi0mTJrnNlOSKuVe33347JkyYoMBCxAcxqFiT2xTZSPH0oYiIiD8P8KaQao5eDCpg5qiDRzIxbMYKDHnn2HICGuTteSUKLP7++28899xzhT7PWZdcZ1ISEe+3O6wFLs55F4kzk5CLFK1VISIingsueKMfxwOLnnX8zJ6MG78G4jo5ey/IDjJIU9T6YGDB6WELmmbWubGgILOitYj4zoDttIRU5GZlYMJVXTRgW0REvEPnm4DWFwJHDwAfDwaWTgUGvgoc2g1ExAHBYW5Bhqao9cHAIi4uDqtXr0aLFhzimd+qVatQv/5/uXIi4hPrVfDbPCm4PepEdkcbDdgWERFvUCPGcSOmSFk5QMIGYFoPMyYQdVo5U6RIC+z5YGBx0UUXmZWmuVp2WFiY23NcnO7xxx83K1qLiHeLj9+D6Ow03J05HFusOMd6FVGOucNFRES8ip0eFbDTfYA3jVoDZKcDmUcQV7U24uIaFjnIWwO8vWiBPKZCnXbaaWalas4O1bp1a7OGxfr16/Haa68hJyfHTENbr169E3vUPkwL5PmeSrUI0n/pT5uScjHjo/fQbcCtaNSw0Qn5Q1up6q0Cqd5UbzrnfIO+qx6qt//+HzO4/gWnqn2rN7Brudsq3vYCe/Yg77SsHJ8e4G1VxgXyGDAsXrwYd9xxB8aOHWveJPEN9u3bF1OmTFFQIeID61WE95yEGTl9cFXDRlqvQkREfHOAt23Q68Cevxw9GQe3uC2w5zrIWwO8vXCBvMaNG2PevHlISkrCli1bTHDRsmVL1KpV68QcoYiU63oVO3u9jFVhpwPYppoVERHfV6clEPRfin78OiCmPbB2DtD2EtOjUdQ6GL7Ye1HpVt4mBhKnn87GiYh4fU9FzYaIT80AR1EMm5+KtdY2TSsrIiKVB3sxON6C618k7wDmjQHCIt0GeWuAtxcHFiLiI0HFpHbAff/gYGBd7Mptgbv6d0Fck1YawCYiIpWLnSKVecR9kHfzc4HL3wHCaxVrFW8N8C49BRYilZk9wC1lF3LCm+LmzPvwQZNWGlchIiL+s4p3RCyQtN1xK8Yq3kqRKj0FFiJ+YEtCKrbkpiIZNTx9KCIiIhU7yDv9kGP9C2JPxlUzgKaOsRUa4F2+FFiIVEYZqUBodSQkH0JdAHfPWom1VorGVYiIiP/huIuhi46t4v3BZSZF2ExV+x8N8C4fCixEKuO4iu/HAReMx6H0bBNYaFyFiIj4rcAqQGxHx892ilRaEvC/O4HONwHV6xVrgDdp/EXRFFiIVDb8g7n6E6DbCKTXbovu6a9gmsZViIiIHEuR4kW4rYuATd8cqxXOKhVaHXFILXAFb9Ig76IpsBCpxOMqNudmYw+OdfWKiIhIngHeRxKA7b8BQaHA6s8cU9WOWoO4mg2dvRdU0CBvzSTlToGFSCWTcDBB4ypERERKMsC75fnHFtujHUvMorJxdVu7LaCnmaSKpsBCpDLgjBe7lgENzoC19VcctUI1rkJERKSkopofWwMjpgMw7Bdg79+AZZmn46rWNmlSVNhYjFrVQvx2NW8FFiKVQeK/jlkuhi5C4snXYdDiZhpXISIiUpYUqeD/goO3egM5jnQoE3Tw+f8Gehe22N539zqms/U3CixEKtm4ig25dTWuQkREpDxSpOjW7xw9Fgc2OXoyzMJ77MEIOO5MUrX8rPdCgYWIrzq0F4iob348uHsTamu9ChERkfJX/xTHfd3WwPClQK0mwLz7gDWzi9V7MXVwJ9SuFuIXQYYCCxFfxGnyuIoo/6BVq4PqvzylcRUiIiInElOjok92/Nx2EPDXDMcgb66TERFrHnbtvShoFqnKniKlwELEF7Eb9uhBbNmyAel12mN/p1fw6DfbNa5CRESkItRpfWyQ91n3AGffCxz8B/4+wFuBhYgPik/NQLRL6hOFB9czf6hERESkAgd5V48G9qwE3usPfx/grcBCxJdkpQPBYUg9lGICizF9WqNuqzPMU5X16oeIiIjXD/IOrWFmZnQb4M3nDu8DasT4zQBvBRYivjSuYunrwNmjUSXT0UsRGxuH1nGRnj4yERER/8bAIrYjULU2UCMWiGwAHDkATOsF3LKg2AO8yZcDDQUWIr7i6EFYS6fgn/oXYX3wKbgm/RVMqx7n6aMSERERW82GwNAfzcQqJj3q8B7HAG/2YNRubgKQogZ4+/pMUgosRHxB8k4k7liDKFj/jatoqjEVIiIi3qhGjOOevRf2AG8a8rUjuEiNL3CANxU0kxSDjKiqwQi1MhDp5UkKCixEfMFvkxC1/C1NKSsiIuKLA7yJQcUvLwG/TixwgLetoN6MAFhoHhmI6cN6okGtqvBWCixEvFnmUcdAsC7DsKXBJbhh5j+aUlZERMRXV/E+YygQ3cbRi3Fgo/tz/3ENNJwDvvcfxotzV5qfvTmwCPT0AYhIERhUTOuBLbv3Y01uU+xBHVWXiIiIr4qIBRp1c/RYrP0CyEoD4tc77gvAAKNdXCSaR1eHL1CPhYi32rvqv3EVx9arYK6l1qoQERGpBClSsICEjeYCIi59E6jTCggIAOqfAl+lwELEW717EaIyD2tchYiISGVT006BCnAf4F0lBHg0wRFwsBeDA8ALSJfyVgosRLzQ7uQ0pPX/BDsPHsHD3+7RuAoRERF/GOAdEOC4n30rsG+VI+i4agYCA1rAFyiwEPGmBfCOHsTBPVuQ9tXjGJZ5F7ZYDTStrIiIiD8N8KbL3gJSdgIfDwY+uAzVz50CwMvnmlVgIeJFQcWkdubH2py3GqG4r/9piGvSyucWxxEREZEyqtvacfuvNyM9MQeDAj9FlaOtGYnAW6nHQsQbhNYABr4K1GyMLYeraFpZERERgd2bERj/C24N+gYJR/sBaOm1NaPAQsQbhNfE7mZXOOaqTknFHqR4+ohERERESkSBhYgXjKs4sH8nFs6Zidcy+yEBNTWtrIiIiPgcBRYingwqXjsDyDpqlr27MRCoP+AejasQERERn6TAQsRTcrOR1uRc7G92ObamV9e0siIiIlKg3JAa+D33JDQJqQFvpsBCxEPpT/GpGei94RocWs05qzM1rayIiIgUKDOiCf4vezBej2gCb6bAQsRD6U/RAKpmvYpxV52HFtHVNa2siIiIFCw3C5FINffeLNCTOx8/fjxOP/101KhRA9HR0Rg0aBA2btzoVsayLDzxxBOIjY1FeHg4evbsibVr17qVycjIwMiRI1GnTh1Uq1YNAwcOxK5du9zKJCUlYfDgwYiMjDQ3/pycnOxWZseOHRgwYIDZBrd11113ITMz063M6tWr0aNHD3MscXFxGDdunDlGkWLhyppZR4FL38SWS+biICJNUNEuLlJrVYiIiEiBwhI34MOQ8ebem3k0sFi0aBFGjBiBpUuXYuHChcjOzkafPn1w5MgRZ5nnn38eEyZMwOTJk7F8+XLExMTg/PPPx+HDh51lRo0ahTlz5mDWrFn49ddfkZqaiv79+yMnJ8dZ5tprr8XKlSsxf/58c+PPDC5sLNuvXz+zb26D25o9ezbuvfdeZ5lDhw6ZfTPI4bG8+uqrePHFF83xiZTEFisWa3KbIkudhiIiIlJZWF4kPj6el/6tRYsWmd9zc3OtmJgY69lnn3WWSU9PtyIjI62pU6ea35OTk63g4GBr1qxZzjK7d++2AgMDrfnz55vf161bZ7a7dOlSZ5klS5aYxzZs2GB+nzdvnnkNX2ubOXOmFRoaaqWkpJjfp0yZYvbNY7CNHz/eio2NNcdaHNwW92tvsyLxGJOSkop9rFKO9Za0w7J2/2Xt+2eV1f6RL60mD3xpNX7ga+ukR76xdiUdrZRVrfNN9abzzTfou6p60/nm/Tb99bOV9GwHc1/RStJ29aoxFikpjkXBoqKizP3WrVuxb98+04thCw0NNalIixcvxu23344VK1YgKyvLrQx7FNq1a2fK9O3bF0uWLDHpT126dHGW6dq1q3mMZVq3bm3K8DV8rY2vZZoV99GrVy9ThvvmMbiWGTt2LLZt24amTZvme098PW+uvR7E9KmKTqGy96nUrQquN46rmNLVpEBVq98Vh7PuxMQrO6L5f+MqYiPDKuVnovNN9abzzTfou6p60/nmI99TBHis/VhcXhNY8KBHjx6Ns846yzTwiUEF1atXz60sf9++fbuzTEhICGrVqpWvjP163nMMR158zLVM3v1wm9y2a5kmTdxH49uv4XMFBRYcR/Lkk08WGER54sRgmhgFBHAmIqmQejuwFwiqi/1dx2BbYCPExR9Gw+owN84GlZLiPo6nstD5pnrT+eYb9F1Vvel8837pmTlIDY0x9/aF+IpiXxT3qcDizjvvxKpVq8z4hrzyNub4R/B4Dby8ZQoqXx5l7OCgsONhbwYDJtcPp2HDhqa3JCIiAhXJPlbuW4HFCa63/6aURWRDxOdaiE7bjuu/S8Fa67BZVbte3ShERoajMtP5pnrT+eYb9F1Vvel88wEx7XHr4VvxQkx70x6pSCVpM3pFYMEZnb788kv8/PPPaNCggfNxDtS2ewPq16/vfDw+Pt7ZU8AynLmJsz659lqwTPfu3Z1l9u/fn2+/CQkJbtv5/fff3Z7nNplm5VrG7r1w3Q/l7e2wMW3KNXXK9UPyROPe3q8CixNYbyb1qYtj9qcBryCx5jmYkHUrhl/cE40aNvSraWV1vqnedL75Bn1XVW8637xbQJUgHEGYua/oNlxJ9hfo6ask7Kn4/PPP8cMPP+RLJeLvbMxzxigbgwjOJmUHDZ06dUJwcLBbmb1792LNmjXOMt26dTPdRsuWLXOWYRDBx1zL8DV8rW3BggUmKOA+7DIMflynoGUZjsvImyIlfuy/KWV39noZ62ueg42HQvBxTi8TVGhaWRERESmpkJStGBf0rrn3Zh7tseBUsx999BH+97//mbUs7N4AdvFwnQhGSJxK9plnnkHLli3NjT9XrVrVTB9rl73lllvMtLC1a9c2A7/HjBmD9u3bo3fv3qbMySefjAsuuAC33XYb3njjDfPY0KFDzZS0HLhNHPzdpk0bMwXtCy+8gMTERLMdvsZOWeI+OV7ixhtvxEMPPYTNmzeb43nsscfUAyCOnoqIOLOiNkf0DJufirXWOlMzTH9iT4WIiIhISQVmpeK0wC1IyHKM+fRWHg0sXn/9dXPPRe9cvfvuu6bxTvfffz/S0tIwfPhwk5rEmZ3YS8BAxDZx4kQEBQXhyiuvNGXPO+88TJ8+HVWqVHGW+fDDD82Cd/bsUVxEj2tj2Fh27ty5Zj9nnnmmCWwYSHCdChuDGPaMMCDq3LmzSb3i+AnXMRTix0HFpHbAPetwMLAu/s09GXf174K4Jq3M0/6U/iQiIiL+KYBzznr6IPwJB28zQGEalicGb3O/Grx9Auptz0pgWg9sGfQV1ljN8fjHv+LDkReY1Cd/pfNN9abzzTfou6p60/nm/Tav/AV1v70TCX0no2XHs7227eoVg7dFfFp2JhJ3rAFXX7n741X/zfwUqdQnERER8SsKLETK6kgCouaPwFEr1Jn+pNQnERERKS9Z1WLxevYAXFzt2ELO3sijs0KJ+LTErcAnN5gZoLZcMhe9M14wQYVmfhIREZHylBNeG3Nzu5p7b6bAQqS00lOAdf/Dlt37sSa3KfagjupSREREyl2V9GT0DFhp7r2ZUqFESuPw/mPjKmatxForRVPKioiIyAkRnLoTY4I/RUJqDwDeu3aaAguR0lj5AaK+H6dxFSIiIiL/UWAhUhJpyTi47iccjOqF3T064OFv92Daf+MqRERERPyZAguR4ji8HziyFYk716L2/BG4IeNprLWaIjy4nqaVFREREVFgIVIMqQnAN/cDexYhCpbSn0RERKRC5QZVxQarIWoFVfXqmlePhcjxVK+LA72eR8KReOxKSlf6k4iIiFSozJrNMSZrGF6v2dyra16BhUhhkncCRw8i/nA67vt8J1amhMNCgNKfRERERAqgwEKksKDitTPM4nfRCMDksFZYNWAKGjZpqVW1RUREpEKFHViNr0MeRsKByUCDs7229hVYiBTk6EETVOzs9TI258Ti1d/iMa5xC83+JCIiIlIIBRYiBaQ/7U+vguE547H2mwhkIBPNI6M0+5OIiIhIERRYiBSQ/hTU5gasyLoAk67qiOZ1qyHUykBczXDVlYiIiEghFFiIFJD+tC6oLfBnPFpEV0fb2AikpKSonkRERESKEFjUkyJ+01ORkYr41AzkWgEYNj8Vt38Vj/DgKkp/EhEREY/LqNkSt2XdY+69mXosxL8xqJjUDrh6Jg4GnYQvcy7AXf27IK5JK+fsT5ZlefooRURExI9ZQWHYa9Ux995MgYX4r31rgPh15sd/U4OwsUooXsi+CrObtNLsTyIiIuI1gg/twL1BnyD4UCMANeGtFFiI/3p/oBlXcdQKxfWf7cUeZCE8OFzpTyIiIuJVqmSmoFfg30jI9O4xnwosxL/ErwdmXgNcMxO44Uts2Z+MG2b+g/uv6m0GatvpTyIiIiJSMgosxD+kHwIS/wUObAKStmLL3oNIr9MeW3JrYQ9STFDRLi7S00cpIiIi4rMUWIh/2LUM+OAy8yNTn9hLwYCCNPuTiIiISNkpsBC/sKdGBxy9ZC52Jqbh4W/3OFOfSOlPIiIi4s2yq0bjo5xe6FU1Gt5MgYVU7qlkjx5EwsEEfP7pLLyX2QsJqIXw4Ho4vWmUxlKIiIiIT8iuWg8f5fTG2VXrwZspsJDKKXknciefjsDsNNQFcHNAKFoOGOa2PoWIiIiILwjMPIzTAjYhMPMUTTcrUtH2pRzBssxO+Dy7OxKsSKQF1cSMtu0UUIiIiIjPCTm0DeOC30PCodMBNIS3Uo+FVMr0p9TkVNyXeSueu+oMTSMrIiIiUgEUWEilTH9qASAmYIKmkRURERGpIAospNKIj9+D6Ow03J05HFusOCQH1dUq2iIiIiIVRIGFVI70p+x0HErLAidhG3T+uajb6gwN0hYREZFKwQoMwR4rCkGBIfBmgZ4+AJHySH86+slQrMltiibpH5mggqtoa+YnERERqQwyolpjaNa95t6bqcdCfNfRRCRuWISo7DSM2tUDCz5eqVW0RURERDxEgYX4rs0LETV/BI5aobisXz/cpTUqREREpBIKPbgeHwY/jYyDE4AG3eCtlAolvufIASQveg2bglrixx6foXfGC2bhO6U/iYiISGUUYGUjMuCoufdm6rEQn1ujInHHGkT9+BCuy3gaa62mCA+up9mfRERERDxMgYX4hrQkpH9+J8J2/IQoDq+wQnFX/y6mp6JWtRAN1BYRERHxMAUW4hO9FPGpGbh06zWIzD7fPJwWVBMz2rZTQCEiIiLiJRRYiE+spM31KZKz3sKYqy4xq2mrl0JERET8RWZkM4zJGop7IpvBmymwEJ9ZSdsKrobTm0apl0JERET8Sm5wNWywGpt7b6bAQrwy9QlhEVpJW0RERARAUOpe3FplLoJSmwOo6bV1oulmxetSnzCtBw59cR/WZjfAaelTUbfFqZpKVkRERPxWUPoBDKqy2Nx7M/VYiNc4sPVv1Pkv9emvzS2xY9NahAfXQq0a3t3tJyIiIiIKLMTT0pJwcPUC7K/TFUHrfkQdABf1uxS3NWllntYgbRERERHfoB4L8fhid7Xnj8ANGU9jv9UJEcGnahpZERERER+kwEIq3pEDyPzwGoQkrNZidyIiIiLHkRMWha9zuqBzGJcJ9l4eHbz9888/Y8CAAYiNjUVAQAC++OILt+cty8ITTzxhng8PD0fPnj2xdu1atzIZGRkYOXIk6tSpg2rVqmHgwIHYtWuXW5mkpCQMHjwYkZGR5safk5OT3crs2LHDHAu3wW3dddddyMzMdCuzevVq9OjRwxxLXFwcxo0bZ45RSmZ3VjX03HcX+mU8bW79cyegXdt2GqAtIiIiUoCs6nGYmjPQ3HszjwYWR44cwSmnnILJkycX+Pzzzz+PCRMmmOeXL1+OmJgYnH/++Th8+LCzzKhRozBnzhzMmjULv/76K1JTU9G/f3/k5OQ4y1x77bVYuXIl5s+fb278mcGFjWX79etnjofb4LZmz56Ne++911nm0KFDZt8Mcngsr776Kl588UVzfFKC9Kc9K5G2fQXSs3Jw25WX4Lk7B2PGvZdpbQoRERGRQgRkp6F5wG5z79UsL8FDmTNnjvP33NxcKyYmxnr22Wedj6Wnp1uRkZHW1KlTze/JyclWcHCwNWvWLGeZ3bt3W4GBgdb8+fPN7+vWrTPbXrp0qbPMkiVLzGMbNmwwv8+bN8+8hq+1zZw50woNDbVSUlLM71OmTDH75jHYxo8fb8XGxppjLS5uj/u2t1uReJxJSUklOt4yy0h13CdssqzHI5y39MeirA0b1lm+wCP1Vgmo3lRvOt98g76rqjedb95v018/W0nPdjD3Fa0kbVevHWOxdetW7Nu3D3369HE+FhoaalKRFi9ejNtvvx0rVqxAVlaWWxn2KLRr186U6du3L5YsWWLSn7p06eIs07VrV/MYy7Ru3dqU4Wv4WhtfyzQr7qNXr16mDPfNY3AtM3bsWGzbtg1NmzYt8H1wG7y59nwQY6mKTqOy91lh+2UPxc/PA+c9joQ921AXARiSeT8SrQikBdXEe9GNfSKVrMLrrZJQvanedL75Bn1XVW8633zke4oAj7Ufi8trAwsGFVSvXj23x/n79u3bnWVCQkJQq1atfGXs1/M+Ojo63/b5mGuZvPvhNrlt1zJNmjTJtx/7ucICi/Hjx+PJJ5/M93hKSopHTgymihHHtJwwh/cD6clA8g5gwy/YWX8t/s2uj+lVJmPIxWegYa2qqBEejOoBmUhJcR/H4o0qrN4qGdWb6k3nm2/Qd1X1pvPN+6Vn5iA1NMbcsw1ZkeyL4j4dWNjyNuT4B/B4jbu8ZQoqXx5l7MCgqONhj8bo0aPdPpyGDRuaHpOIiAhUJPt4ue8T1kDOzgCWzwQWvwJYuThqhWLY59uxB6kID66Nzq0a+Nx4igqpt0pI9aZ60/nmG/RdVb3pfPN+YSFVUD1jH9JCqpj2SEUqSdvHawMLDtS2ewPq16/vfDw+Pt7ZU8AynLmJsz659lqwTPfu3Z1l9u/fn2/7CQkJbtv5/fff3Z7nNplm5VrG7r1w3Q/l7e1wxdQp1/Qp1w/JE41Ue78nbN/BYdjb9hYcie6NnYlpePjbPbj/qt5oEV3dpxe7O+H1Vkmp3lRvOt98g76rqjedb94tILAKjloh5r6i2yIl2Z9HZ4UqClOL2JhfuHCh8zEGEYsWLXIGDZ06dUJwcLBbmb1792LNmjXOMt26dTNdRsuWLXOWYRDBx1zL8DV8rW3BggUmIOA+7DKcHtd1ClqW4biMvClS/jzjU8Ka7/Hc62/h4pn7cNO3mUgKrofTm0ZpKlkRERGRUkqv3RZXZT1m7r2ZR3ssmLe+ZcsWtwHbnAo2KioKjRo1MlPJPvPMM2jZsqW58eeqVaua6WOJXUG33HKLmRa2du3a5nVjxoxB+/bt0bt3b1Pm5JNPxgUXXIDbbrsNb7zxhnls6NChZkpaDtwmDv5u06aNmYL2hRdeQGJiotkOX2OnK3GfHCtx44034qGHHsLmzZvN8Tz22GO6ip28E7mTT0dgdhrqAphUBfj2gu8Q16SVT/dSiIiIiIiPBBZ//PGHmXHJZo9FGDJkCKZPn477778faWlpGD58uElN4sxO7CWoUaOG8zUTJ05EUFAQrrzySlP2vPPOM6+tUqWKs8yHH35oFryzZ4/iInqua2ew7Ny5c81+zjzzTLMAHgMJrlNhYxDDnpERI0agc+fOJvWKx+s6fsLf7NuxGYdTEpGSloUGWeEYl3Ubtlv1zIxPM9q2U0AhIiIiUg5CkzbhteBJCE2KBhqcAW8VwDlnPX0Q/oSDtxmkMBXLE4O3ud/yGITMoCLi7TORgmroljEZ4cFVMHVwJ9SuFlLpeinKs978iepN9abzzTfou6p60/nm/Tav/AV1v70TCX0no2XHs7227eq1g7fF++w+kIykjAAEZqbi6Orv0TkgA2s6j8fXp55V6YIJERERESkZBRZy/EHZRw/iQPwezP18FqZmXohWgbswK+QpM5Vsow7nICauYqc9ExERERHvo8BCijUouw6AqwPC0XjASDSMPQdbDnVD9Vr1ENOopWpQRERERBRYSOH2HUrDr5ld8WX2GThoReQZlB2nqhMRERGpAJk1GuH/sq7HzTUaeXV9q8dCChyYnZq037HAXeYQPHfVGT6/wJ2IiIiIr8oNjcTv1sm4MdS7088VWIibA3/PR8TnNyAmIAMtALQKftEscKeAQkRERMQzgo7G44rAnxB0tBWAml77MSiwEGN3chqSjmTi5P9djwwEYnG3aYiOicPUuDYKKkREREQ8KOjofgwJWoiEoxfzsq/XfhYKLPxM/OEM7ExNQZXMFNTJ3ofo6qE4uOcfpHw1DndnjkAYnkRaUCRmdBmogEJEREREik2BhR/Zu3sH5n04FR8mt8fpgesxJeQV83htAOEIxf39T0Vck1YaSyEiIiIiJabAwo8cObADNwbMQ4c+vRAaPQSXfVwf6dm55jn3GZ9EREREREpGgYUfahgVjpbtWqBJgzgzroI045OIiIiId8oJicCvuW3RIiQC3kyBhR9j74R6KERERES8W1ZEYzybfS1ej2gMbxbo6QMQEREREZHCBeRkog6Szb03U2DhR3JDauD33JPMvYiIiIj4htCkjZge8oK592YKLPxIZkQT/F/2YHMvIiIiIlKeFFj4k9wsRCLV3IuIiIiIlCcFFn4kLHEDPgwZb+5FRERERMqTAgsRERERESkzBRYiIiIiIl4svXZbXJL5pLn3ZgosRERERES8WUAgsrj8XIB3N929++hERERERPxcSPK/GB/8lrn3Zgos/Eh6VBtcmfmouRcRERER3xCYfQTtA7aae2+mwMKfBFbBUYSZexERERGR8qTAwo+EpGzFuKB3zb2IiIiISHlSYOFHArNScVrgFnMvIiIiIlKeFFiIiIiIiHixrOpxeCX7EnPvzRRYiIiIiIh4sZywKCzI7WzuvZkCCxERERERL1YlPRF9Av8w995MgYUfyaoWi9ezB5h7EREREfENwam7cVfQHHPvzRRY+JGc8NqYm9vV3IuIiIiIlCcFFn6kSnoyegasNPciIiIiIuVJgYUfCU7diTHBn5p7EREREZHypMBCRERERMSL5QZVw2qrqbn3ZgosRERERES8WGbNZhibdau592YKLEREREREvJmVi2Bkm3tvpsDCj+QGVcUGq6G5FxERERHfEHZwLeaEPG7uvZkCCz+SWbM5xmQNM/ciIiIiIuVJgYWIiIiIiJSZAgs/EnZgNb4Oedjci4iIiIiUJwUWIiIiIiJSZgosRERERES8WEat1rgx8z5z780UWIiIiIiIeDGrSggOoKa592YKLEREREREvFjwoe14MOgjc+/NFFj4kYyaLXFb1j3mXkRERER8Q5XMQzgrcK2592YKLPyIFRSGvVYdcy8iIiIiUp4UWPiR4EM7cG/QJ+ZeRERERKQ8KbAohSlTpqBp06YICwtDp06d8Msvv8AXVMlMQa/Av829iIiIiEh5UmBRQh9//DFGjRqFhx9+GH/99RfOPvtsXHjhhdixQ70AIiIiIlL+sqvWw3vZ55t7b6bAooQmTJiAW265BbfeeitOPvlkTJo0CQ0bNsTrr79+Yj4hEREREfFr2VWj8WluT3PvzYI8fQC+JDMzEytWrMCDDz7o9nifPn2wePHiAl+TkZFhbraUlBTnvWVZqEiHD6ciJD3X3NvHIcfHz8mur4CAAFVZManeSkf1pnqraDrnVG8637zfkYSd6JjxF44kNEZKjYptixw65JiJqjjtVgUWJXDgwAHk5OSgXj33bij+vm/fvgJfM378eDz55JP5Hm/UqBE85omLPLdvERERESmV155+DJ5y+PBhREZGFllGgUUp5L1qzQiusCvZY8eOxejRo52/5+bmIjExEbVr167wq9+MOJm2tXPnTkRERFTovn2Z6k31pvPN++l7qrrTOecb9F31vXpjO5dBRWxs7HHLKrAogTp16qBKlSr5eifi4+Pz9WLYQkNDzc1VzZo14Uk8IRVYqN50vnk3fU9VbzrnfIO+q6o3fzjfIo/TU2HT4O0SCAkJMdPLLly40O1x/t69e/eSfUIiIiIiIpWIeixKiGlNgwcPRufOndGtWzdMmzbNTDU7bNiwE/MJiYiIiIj4AAUWJXTVVVfh4MGDGDduHPbu3Yt27dph3rx5aNy4MbwdU7Ief/zxfKlZonrT+eY99D1Vvemc8w36rqredL7lF2BV9JynIiIiIiJS6WiMhYiIiIiIlJkCCxERERERKTMFFiIiIiIiUmYKLEREREREpMwUWIiIiIiISJkpsBARERERkTJTYCEiIiIiImWmwEJERERERMpMgYWIiIiIiJSZAgsRERERESkzBRYiIiIiIlJmCixERERERKTMFFiIiIiIiEiZKbAQEREREZEyU2AhIiIiIiJlpsBCRERERETKTIGFiIiIiIiUmQILEREREREpM78NLMaPH4/TTz8dNWrUQHR0NAYNGoSNGzce93WLFi1Cp06dEBYWhmbNmmHq1KkVcrwiIiIiIt7MbwMLBggjRozA0qVLsXDhQmRnZ6NPnz44cuRIoa/ZunUrLrroIpx99tn466+/8NBDD+Guu+7C7NmzK/TYRURERES8TYBlWZanD8IbJCQkmJ4LBhznnHNOgWUeeOABfPnll1i/fr3zsWHDhuHvv//GkiVLKvBoRURERES8S5CnD8BbpKSkmPuoqKhCyzB4YK+Gq759++Ltt99GVlYWgoOD870mIyPD3Gy5ublITExE7dq1ERAQUK7vQURERESkPLEP4vDhw4iNjUVgYNHJTgos/quw0aNH46yzzkK7du0Krax9+/ahXr16bo/xd6ZRHThwAPXr1y9wLMeTTz5Z+k9TRERERMTDdu7ciQYNGhRZRoEFgDvvvBOrVq3Cr7/+etxKzdvLYGeSFdb7MHbsWBO0uPaMNGrUCNu3b0dERAQqEntLGADVqVPnuBGnqN50vnmGvqeqN51zvkHfVdWbv5xvhw4dQuPGjc2ER8fj94HFyJEjzbiJn3/++bhRWExMjOm1cBUfH4+goCCT2lSQ0NBQc8urZs2aHgksMjMzzb4VWKjedL55J31PVW8653yDvquqN3853wL/219xUvj99rI1exrYU/H555/jhx9+QNOmTY/7mm7dupkZpFwtWLAAnTt3LnB8hYiIiIiIv/DbwIJTzX7wwQf46KOPTNcOeyJ4S0tLc0tjuuGGG9xmgGIKE1ObODPUO++8YwZujxkzxkPvQkRERETEO/htYPH666+b8Q49e/Y0g67t28cff+wss3fvXuzYscP5O3s15s2bh59++gkdO3bE//3f/+GVV17BZZdd5qF3ISIiIiLiHfx2jEVxlu+YPn16vsd69OiBP//88wQdlYiIiIiIb/LbHgsRERERESk/CixERERERKTMFFiIiIiIiEiZKbAQEREREZEyU2AhIiIiIiJlpsBCRERERETKTIGFiIiIiIiUmQILEREREREpMwUWIiIiIiJSZgosRERERESkzBRYiIiIiIhImSmwEBERERGRMlNgISIiIiIiZabAQkREREREyiwIPuLmm28u8PHIyEi0bt0a119/PapXr17hxyUiIiIiIj7UY5GUlFTgbeXKlXjsscdMcPHvv/96+jBFRERERPySz/RYzJkzp9Dn0tLScMMNN+DBBx/EJ598UqHHJSIiIiIiPtRjUZTw8HA88MADWLp0qacPRURERETEL1WKwIKioqKQnJzs6cMQEREREfFLlSawWLx4MZo3b+7pwxARERER8Us+M8Zi1apVBT6ekpKC5cuX45lnnsFTTz1V4cclIiIiIiI+FFh07NgRAQEBsCwr33N169Y1YyyGDRvmkWMTEREREfF3PhNYbN26tdB1LGrWrFnhxyMiIiIiIj4YWDRu3NjcZ2RkIDs7G9WqVfP0IYmIiIiIiK8N3j5w4AD69etnVteOiIhA9+7dtSCeiIiIiIiX8JnAYuzYsVixYgWefPJJvPDCCybQuP322z19WCIiIiIi4kupUN9++y3eeecdXHTRReZ33rdr1w5ZWVkIDg729OGJiIiIiPg1n+mx2LNnD0499VTn7yeddBJCQkLM4yIiIiIi4lk+E1hwmtmgIPcOFv6em5vrsWMSEREREREfDCzOO+88nHbaac7b0aNHMWDAALfHiuvnn382r42NjTXrY3zxxRdFlv/pp59Muby3DRs2lMO7ExERERHxbT4zxuLxxx/P99jFF19c6u0dOXIEp5xyCm666SZcdtllxX7dxo0bzaxUrovziYiIiIj4O58OLMriwgsvNLeSio6O1oJ8IiIiIiK+Glikp6djwYIF6NWrF2rUqOH23KFDh0yqUt++fREaGnpCj4MDyHksbdq0wSOPPGKOpyhc0I8312Mljg2p6PEh3B9TyjQuRfWm88176XuqetM55xv0XVW9+cv5lluCffpMYPHGG2/gyy+/xMCBA/M9x9SkV155BTt27MCdd955QvZfv359TJs2DZ06dTKBwowZM8yYDwY055xzTqGvGz9+vFl7I6+EhAQToFT0iZGSkmJOzMBAnxle43GqN9Wbzjfvp++p6k7nnG/Qd9X36u3w4cPFLhtg8Qh9wBlnnIFHH33UDLguyNdff41x48Zh2bJlJd42B2HPmTMHgwYNKtHreCx8LQOekvRYNGzYEElJSW5jNSrqpGRAw3EhCixUbzrfvJO+p6o3nXO+Qd9V1Zu/nG+HDh1CrVq1TGBzvLarz/RYbN682Qy2LkyHDh1MmYrUtWtXfPDBB0WWYWpWQelZPCk80bhnIOSpffsy1ZvqTeeb99P3VHWnc8436LvqW/VWkv35TOsyOzvbRGqF4XMsU5H++usvkyIlIiIiIuLvfKbHom3btvjuu+/MGIeCLFy40JQprtTUVGzZssX5+9atW7Fy5UpERUWhUaNGGDt2LHbv3o3333/fPD9p0iQ0adLE7CMzM9P0VMyePdvcRERERET8nc8EFjfffDNGjx5tGvb9+/d3e+6rr77CU089hQkTJhR7e3/88YfbjE7cNg0ZMgTTp0/H3r17zWBwG4OJMWPGmGAjPDzcHMfcuXNx0UUXlcv7ExERERHxZT4TWAwdOtSsls1ZoU466SS0bt3a5JqtX78emzZtwpVXXmnKFFfPnj3NyPrCMLhwdf/995ubiIiIiIj48BgLYvrRrFmz0KpVKxNMbNiwwQQYM2fONDcREREREfEMn+mxsLFngjcREREREfEePtVjISIiIiIi3kmBhYiIiIiIlJkCCxERERERKTMFFiIiIiIi4j+BRWxsLO644w588803Zk0JERERERHxHj4TWHz00UeoWrUq7rrrLtSpUwdXXHEFZsyYgcTERE8fmoiIiIiI3/OZwIIL2r300kvYvHkzlixZgtNOOw2vvfYa6tevb56bOHEi/vnnH08fpoiIiIiIX/KZwMJV27ZtMXbsWCxduhQ7duzAddddhx9++AHt27dHu3btMHfuXE8fooiIiIiIX/G5BfLyqlevHm677TZzO3r0KL799luEhoZ6+rBERERERPyKzwcWrjgG45JLLvH0YYiIiIiI+B2fTIUSERERERHvosBCRERERETKTIGFiIiIiIiUWaUILHJzc/HVV19h0KBBnj4UERERERG/5NOBBde04LSzDRo0wJVXXunpwxERERER8Vs+NytUWloaPvnkE7z99ttmHYucnByzON7NN9+M6tWre/rwRERERET8ks/0WCxbtgxDhw5FTEwMJk+ejMsuuww7d+5EYGAgevfuraBCRERERMSDfKbHonv37hg5cqQJMFq3bu3pwxEREREREV8MLM4991yT/hQfH4/Bgwejb9++CAgI8PRhiYiIiIiIL6VCLViwAGvXrjW9FXfccQfq16+Pu+++2zynAENERERExLN8JrCghg0b4rHHHsPWrVsxY8YM03sRFBSEiy++GA899BD+/PNPTx+iiIiIiIhf8qnAwtX555+PmTNnYs+ePWbsxTfffIPTTz/d04clIiIiIuKXfDawsNWqVcsEFn/99ReWL1/u6cMREREREfFLPjN4215he/r06fj888+xbds2M7aiadOmuPzyy82A7tNOO83ThygiIiIi4pd8psfCsiwMHDgQt956K3bv3o327dujbdu22L59O2688UZccsklnj5EERERERG/5TM9Fuyp+Pnnn/H999+jV69ebs/98MMPGDRoEN5//33ccMMNHjtGERERERF/5TM9FhyozZmf8gYV9hoXDz74ID788MNib49ByoABAxAbG2tSqr744ovjvmbRokXo1KkTwsLC0KxZM0ydOrXE70NEREREpDLymcBi1apVuOCCCwp9/sILL8Tff/9d7O0dOXIEp5xyCiZPnlys8pzi9qKLLsLZZ59tBoozyLnrrrswe/bsYu9TRERERKSy8plUqMTERNSrV6/Q5/lcUlJSsbfHQIS34mLvRKNGjTBp0iTz+8knn4w//vgDL774Ii677DJUVjt27MCBAwfMz3Xq1DF1UJLXuCrs9UXto7BtFbbd4pQv6bY4vic9Pd2M7WHv1oneX2keL812y/o5i4iIiPhkYJGTk2MWwytMlSpVkJ2dfcL2v2TJEvTp08ftsb59++Ltt99GVlYWgoOD4QsSEhKcDeTilL300ktx9OhR83vVqlXNjFx169Yt9mtcFfT6ovZR1LYK2i4Vp3xJtxUYGGhS4FasWGFmJjvR+yvN4yXdbnE/g7LIG5AVpqhApqRBqoiIiHiOzwQWbKRw9qfQ0NACn8/IyDih+9+3b1++HhP+zmCGDZ/69esXelyux3bo0CFzzwYqbxWJjbQRI0aYIKm4+2Yjk4sP0hVXXGHSwYr7mryN18JeX9Q+CtqWq7zbPV75ohS2LTZi2UDm2Bp+1id6f3nr4XiP5913cbdb1s/5eBiQcQroP//8s8jzjfv+9NNPC30fhQWpBb3Gm/C8adiwYYlfx7ri37uK/vvg61Rvqjudc75B31Xfq7eS7DPA4lH6gJtuuqlY5d59990Sb5tXU+fMmWNmlipMq1atzDGMHTvW+dhvv/2Gs846C3v37kVMTEyBr3viiSfw5JNP5nt8ypQpCA8PR0XiuBKu/8GAqLj7Zi+RHcwxQCpOr5Dra1wV9vqi9lHYtgrbbnHKl3Rb/IrwMf7Oc+VE7680j5dmu2X9nIv7x4gBRmG4n82bNxf6R4uvbdmypVtv5fFe4y0KOvbyqrfSKs53s6zntKfk/Z6K6k7nnHfSd9X36i0tLQ3Dhw9HSkoKIiIiKkePRWkChvLEwIG9Fq7i4+PNB1y7du1CX8dAZPTo0W49FryKec011xz3wylvvHLMKXlfe+01LSZYwkYer57z6viJaOz5e73t3LmzyLEiBV31L+o13qCo3pby6ukpjYJ6evIeqy/0BhV0juh7WnqqO9Wbr55vpfn/o6z7KM52d7q8pryOw5PfU7ZdGVgUh88EFp7WrVs3fPXVV26PLViwAJ07dy5yfAWv/BV09Y8nRUWfGIxwGfHyXg3kktedJz4zf6i3xo0bm1tJlOY1FW3t2rWlCn7ssSlMvSvPq1L2WJqCJq1gMDFv3jzzc2FlvJU9JshOWdyzZ0+l6rGoiPFEbATt2rXLWXf+OoapNJNYlNf/DeU5UYq3s//GlfW7erxxmOUxXrCgfRxvuwkncNxiSEiIyTqp6LZISfbnM4EF168o6ASMjIxE69atzdiBkkSEqamp2LJli9t0sitXrkRUVJT5QrOngYNOeYWfhg0bZqamZe/DbbfdZsYpcOA219cQEcmLf0dK0zjjVSn2hkZHR5f7fx7r168/7mD4wsp4I/s/cE5FnneShcqivBolRdXh5ZdfbmY6zDtBha/0WpWH0jQGiztBxYnYd3EnN/FG5fldZV3Nnz+/wDF69t+GsnLdR3G3W/W/11B5HQfrrXv37vjggw+8+sKazwQWHTt2LPDx5ORkc6WNjf5ff/210HJ5capY18X27HSlIUOGmFW+OW6CVwNsTZs2Nfu55557TCoRF9Z75ZVXKvVUsyLif8FOaQMiT7EDoRPV0+NJ5dk4Kkr16tXNeEBeCWVdVsQ+vVFJG4MnooFc3H27vsbXAsDy/K4W1btTXhdJ8u6jONutcwIu1nA7L7/8stmWAotyMHHixCKfZ48FF62zu/OPp2fPnubkLgyDi7x69Ohh8p5FRMQ72IHQiezp8aSK6EHiOEGm7Np150u9VuWppI3BE9VALm79+2rKWkV9V0/URZKSbrdROR2Hj8y15Ds9Fsdz++23m3UlREREKouK6EGyG3oVuU9vV5w6OFENZNW/+LJKc1mH06fyyoGIiIiIiFS8ShNYcIYmrjUhIiIiIiIVz2dSob788ssCH+diHcuXLzczNBU0LkJERERERE48nwksClsVu0aNGjjppJNMUMFFnkREREREpOL5TGBRmeYlFxERERGpbCrNGAsREREREfEcnwksfvjhB7Rp0waHDh0qcJxF27Zt8csvv3jk2ERERERE/J3PBBaTJk3CbbfdhoiIiHzPRUZGmnUsJkyY4JFjExERERHxdz4TWPz9999FLnHfp08frFixokKPSUREREREfCyw2L9/P4KDgwt9PigoCAkJCRV6TCIiIiIi4mOBRVxcHFavXl3o86tWrUL9+vUr9JhERERERMTHAouLLroIjz32GNLT0/M9l5aWhscffxz9+/f3yLGJiIiIiPg7n1nH4pFHHsHnn3+OVq1a4c4770Tr1q0REBCA9evX47XXXkNOTg4efvhhTx+miIiIiIhf8pnAol69eli8eDHuuOMOjB07FpZlmccZXPTt2xdTpkwxZUREREREpOL5TGBBjRs3xrx585CUlIQtW7aY4KJly5aoVauWpw9NRERERMSv+VRgYWMgcfrpp3v6MERERERExNcGb4uIiIiIiPdSYCEiIiIiImWmwEJERERERMpMgYWIiIiIiJSZAgsRERERESkzBRYiIiIiIlJmCixERERERKTMFFiIiIiIiEiZKbAQEREREZEyU2AhIiIiIiJlpsBCRERERETKTIGFiIiIiIiUmd8HFlOmTEHTpk0RFhaGTp064Zdffim0sn766ScEBATku23YsKHsn4SIiIiIiA/z68Di448/xqhRo/Dwww/jr7/+wtlnn40LL7wQO3bsKPJ1GzduxN69e523li1bVtgxi4iIiIh4I78OLCZMmIBbbrkFt956K04++WRMmjQJDRs2xOuvv17k66KjoxETE+O8ValSpcKOWURERETEG/ltYJGZmYkVK1agT58+bo/z98WLFxf52lNPPRX169fHeeedhx9//PEEH6mIiIiIiPcLgp86cOAAcnJyUK9ePbfH+fu+ffsKfA2DiWnTppmxGBkZGZgxY4YJLjj24pxzzinwNSzHmy0lJcXcJycnIzc3FxXp8OHDZp+85/6leFhnhw4dQkhICAID/TYWLzHVm+pN55tv0HdV9abzzfsd9mAbjm0gsizruGX9NrCwcfC1K1Za3sdsrVu3Njdbt27dsHPnTrz44ouFBhbjx4/Hk08+me/xxo0bw1N69erlsX2LiIiIiO+14RjUREZGFlnGbwOLOnXqmLEReXsn4uPj8/ViFKVr16744IMPCn1+7NixGD16tPN3RpuJiYmoXbt2oQHMiYw4OYaEwVBERESF7tuXqd5UbzrfvJ++p6o7nXO+Qd9V36s3XnRnUBEbG3vcsn4bWDCthSlNCxcuxCWXXOJ8nL9ffPHFxd4OZ5NiilRhQkNDzc1VzZo14Uk8IRVYqN50vnk3fU9VbzrnfIO+q6o3fzjfIo/TUwF/DyyIPQmDBw9G586dTVoTx09wqtlhw4Y5ext2796N999/3/zOWaOaNGmCtm3bmsHf7KmYPXu2uYmIiIiI+DO/DiyuuuoqHDx4EOPGjTPrUbRr1w7z5s1zjn/gY65rWjCYGDNmjAk2wsPDTYAxd+5cXHTRRR58FyIiIiIinufXgQUNHz7c3Aoyffp0t9/vv/9+c/NVTMl6/PHH86VmiepN55v30PdU9aZzzjfou6p60/mWX4BVnLmjREREREREiqBJ+UVEREREpMwUWIiIiIiISJkpsBARERERkTJTYOFHpkyZgqZNmyIsLMys4fHLL7/AXz3xxBNmgULXW0xMjPN5Dj1iGS4GwxnAevbsibVr17ptIyMjAyNHjjSLLVarVg0DBw7Erl27UJn8/PPPGDBggKkH1tEXX3zh9nx51VNSUpKZ+pnzZPPGn5OTk1FZ6+3GG2/Md/5xsU1/r7fx48fj9NNPR40aNRAdHY1BgwZh48aNbmV0zpWu3nTO5ff666+jQ4cOznUBOO38N998o3OtjPWmc63431v+7R81alTl+vvGwdtS+c2aNcsKDg623nzzTWvdunXW3XffbVWrVs3avn275Y8ef/xxq23bttbevXudt/j4eOfzzz77rFWjRg1r9uzZ1urVq62rrrrKql+/vnXo0CFnmWHDhllxcXHWwoULrT///NPq1auXdcopp1jZ2dlWZTFv3jzr4YcfNvXAPxdz5sxxe7686umCCy6w2rVrZy1evNjc+HP//v2tylpvQ4YMMe/Z9fw7ePCgWxl/rLe+ffta7777rrVmzRpr5cqVVr9+/axGjRpZqampzjI650pXbzrn8vvyyy+tuXPnWhs3bjS3hx56yPw/yXrUuVb6etO5dnzLli2zmjRpYnXo0MG0xyrT3zcFFn7ijDPOMCejq5NOOsl68MEHLX8NLPhFLEhubq4VExNjvuC29PR0KzIy0po6dar5PTk52fwhZcBm2717txUYGGjNnz/fqozyNpDLq54Y6HLbS5cudZZZsmSJeWzDhg2WrysssLj44osLfY3qzYHBPutv0aJF5nedc6WrN51zxVerVi3rrbfe0rlWynrTuXZ8hw8ftlq2bGkCgx49ejgDi8ry902pUH6AC/utWLECffr0cXucvy9evBj+avPmzaa7kelhV199Nf7991/z+NatW7Fv3z63+uJ85T169HDWF+szKyvLrQy3xUUW/aVOy6uelixZYrpqu3Tp4izDtCA+Vpnr8qeffjJpK61atcJtt92G+Ph453OqN4eUlBRzHxUVZe51zpWu3nTOHV9OTg5mzZqFI0eOmNQenWulqzeda8c3YsQI9OvXD71793Z7vLKcc36/QJ4/OHDggPny16tXz+1x/s6T2B/xC/f++++bRt3+/fvx1FNPoXv37iaX0a6Tgupr+/bt5meWCQkJQa1atfy2TsurnnjPBnZefKyy1uWFF16IK664Ao0bNzb/mTz66KM499xzzX8a/I9E9ebINR49ejTOOuss858m6ZwrXb3pnCvc6tWrTYM4PT0d1atXx5w5c9CmTRtnA0x/30pWbzrXisYg7M8//8Ty5cvzPVdZ/r4psPAjHCSU9z+gvI/5CzbsbO3btzd/IJs3b4733nvPOYi2NPXlj3VaHvVUUPnKXJdXXXWV82c2/jp37myCjLlz5+LSSy8t9HX+VG933nknVq1ahV9//TXfczrnSl5vOucK1rp1a6xcudIMbJ09ezaGDBmCRYsW6VwrZb0xuNC5VrCdO3fi7rvvxoIFC8wkOoXx9b9vSoXyA5w5oEqVKvkiVaZe5I2M/RVnVmCAwfQoe3aoouqLZZhixpkXCitT2ZVXPbEMe43ySkhI8Ju6rF+/vgkseP6Rv9cbZzz58ssv8eOPP6JBgwbOx3XOla7eCqJzzoFXf1u0aGGCe87Sc8opp+Dll1/WuVbKetO5Vjj2SPNvOGflDAoKMjcGY6+88or52f677ev/pyqw8AP8A8ATeeHChW6P83em/4hj+rb169eb/2w55oJfTNf64heZfwDs+vr/9u49tMY/DuD4Z9jWXCPCLENu5b5QSsOWkQgjrLkOsazMLcY/JIQSci1zTSLNPay1icTmPuZWZk0MucuW6/Pr8+13Ts/Z2WZnZ8t29n7VY+fynOc8vvuenefzfL7fz6Pt6e/v77JOQUGBPHjwoNa0aWW1k2aLdEx4VlaWc53MzEzzWG1py/fv35uzWdr/anO76Rk1PeOekpIi6enppo/Z0ecq1m4loc+V3pb6fUBfq1i70ddKFxkZaYaQaabHsWhgFhsba2536NDBN75Tq3x6OKpVudnk5GRTMSAxMdGUm83Ly7Nqo0WLFlmXLl2ycnNzTeUELcOmJd4c7aFVGbQSQ0pKiin5FhMTU2LJt5CQECstLc2UfIuIiPC5crNaveLOnTtm0T8XmzZtMrcdZYorq520NJ6W3dPKFbr06NGjRpdNLavd9Dntf1oC8Pnz51ZGRoY1YMAAUz6wtrdbfHy86U/62bSX4i0sLHSuQ5/zvN3ocyVLSkqyLl++bD6H2dnZpmyqVtdJTU2lr1Ww3ehrnrFXhfKVv28EFrXI9u3brdDQUCsgIMAKCwtzKUVY2zhqQ2uwFRwcbEVHR1s5OTnO57Xsm5ak1dJvgYGBVnh4uPmQ2xUVFVkJCQlWs2bNrKCgIPOhzc/Pt3yJHvTqgXHxRculVmY76TUcYmNjTXCni97++PGj5Yvtpgd7UVFRVosWLUz/0+sN6OPF26Q2tltJbaaLXqPBgT7nebvR50oWFxfn/E7Uz2NkZKQzqKCvVazd6GveBRa+8PfNT/+p+rwIAAAAAF/GHAsAAAAAXiOwAAAAAOA1AgsAAAAAXiOwAAAAAOA1AgsAAAAAXiOwAAAAAOA1AgsAAAAAXiOwAAAAAOA1AgsAgM8bPHiw+Pn5meXu3bv/endk+vTpzv05efLkv94dAKgUBBYAgFIPeu3L8OHDa3RLzZ49WwoKCqR79+5uz0VFRUndunXl+vXrZbaHv7+/tGzZUoYOHSp79+6VP3/+uKxbWqCQmJhoghuHLVu2mH0BAF9CYAEAcKNBhB742pcjR45UaUv9+PGjSrdfv359adWqldSrV8/l8fz8fLl27ZokJCRIcnJyme2Rl5cn58+flyFDhsj8+fNl5MiR8uvXL4/3pUmTJmZfAMCXEFgAANwEBgaaA1/70rRpU5cz83v27JGxY8eaA/ZOnTrJ6dOnXbbx8OFDGTFihDRs2NCc5Z8yZYq8e/fO+byewdeD+YULF0rz5s1NFkDpdnR7QUFB5gD+wIED5v0+ffok3759k8aNG8vx48dd3uvMmTPSoEED+fr1q8e/zX379pkAIT4+Xo4ePWreo7T2aNOmjYSFhcny5cvl1KlTJsjYv38/PQgACCwAABW1atUqmTBhgmRnZ5sAIjY2Vj58+GCe07P7gwYNkt69e8vNmzflwoUL8ubNG7O+nQYNmkG4evWq7N6922QExo8fL2PGjDFzIebMmSMrVqxwrq/Bw6RJk0wwYKf39XWNGjXy6P9gWZZ57eTJk6Vr167SuXNnOXbsWLleGxERIb169ZKUlBSP3hMAfBUZCwCAm7Nnz5pMg31ZvXq129yDmJgY6dixo6xdu9ac6c/KyjLP7dy505zZ18f1gL1Pnz5mTkJGRoY8ffrUuQ197YYNG6RLly5mvV27dpnbGzduND81iND3sZs1a5ZcvHhRXr16Ze5rFkT3Ny4uzuPfZFpamhQWFsqwYcPMfQ0wShsOVRLdZw2GAAAEFgCAEugQJM0Y2Jd58+a5rNOzZ0+XTIJmC96+fWvu37p1ywQR9sBED8LVs2fPnK/r27evyzafPHki/fr1c3msf//+bve7desmBw8eNPcPHTokbdu2lfDwcI9/lxpETJw40TnvQgOlzMxMsx/lzXjoMC0AgIjrDDYAAP4PFDSbUBatkGSnB9iOKkn6c9SoUbJ+/Xq317Vu3drlff52oK6PFadZi23btsmyZcvMUKYZM2Z4fICvw7a0gtPPnz9NhsXh9+/fJrtS0r4X9+jRI2nfvr3zvgZXnz9/dltP54fohG0A8GUMhQIAVDodBpWTkyPt2rUzAYp9KR5M2GlW48aNGy6P6RyN4nTIklZz2rp1q3mfadOmebyPhw8flpCQELl3755LZmbz5s1m7sffqj2lp6fL/fv3Zdy4cWXuvwZGmsHRoV0A4MsILAAAbr5//y6vX792WewVnf5Gh01pRkCHFum8i9zcXElNTTXzIDQjUBqdrP348WNZunSpmYuhE6kdVZfsGQmtUBUdHS1Lliwx16DQAKEiw6B0wrde18K+6D5qhuHcuXNu7fHy5Uu5ffu2mTsyevRoU01q6tSpzvUWL15stqvZFN1/DVq08pUO/yo+lAwAfA2BBQDAjVZx0iFL9mXgwIHlbqng4GBT6UmDCJ0YrQfset0HHQ5Up07pXz06rEhLyWqlJZ3DoUOUHFWhtOSr3cyZM821LyoyaVszCHrQb8822IczabBin8TtaA/NwOg1LXT+iGZLtOSsXljPQateaSCkGQ+dK6Lb0aDiypUrEhoa6vF+AkBN4meVNHgVAIBqYs2aNaZa1IsXL9yGMmmwotWhAgICytyGXjNDS9/qMKfqRLMwJ06cMOV1AaCmI2MBAKhWduzYYeYp6PAprfikpWftcyi0PKzOq1i3bp0ZOvW3oMK+Xa1OpfMi/rW5c+eafQEAX0LGAgBQrSxYsMBcAVvnaGgZWb1id1JSkrMk7MqVK00WQ8vL6lCk8hyg69yIoqIic1u3Wd5gpKpoWd4vX76Y2zrEqqwJ7QBQUxBYAAAAAPAaQ6EAAAAAeI3AAgAAAIDXCCwAAAAAeI3AAgAAAIDXCCwAAAAAeI3AAgAAAIDXCCwAAAAAeI3AAgAAAIDXCCwAAAAAiLf+A6/NohvI316xAAAAAElFTkSuQmCC",
+                            "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>"
                         ]
@@ -513,9 +623,11 @@
                 "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",
@@ -534,14 +646,6 @@
                 "plt.tight_layout()\n",
                 "plt.show()"
             ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "f9b7c128-6d30-425c-87db-645ea8cda143",
-            "metadata": {},
-            "outputs": [],
-            "source": []
         }
     ],
     "metadata": {
diff --git a/src/ClusterFinderCUDA.test.cu b/src/ClusterFinderCUDA.test.cu
index ac831c5..e4d7d90 100644
--- a/src/ClusterFinderCUDA.test.cu
+++ b/src/ClusterFinderCUDA.test.cu
@@ -477,18 +477,14 @@ int main(int argc, char *argv[]) {
     }
     */
 
-    // --- Batched H2D + multi-stream (enable this block and disable the one
-    //     above to benchmark the batched path against the CPU results) ---
+    // --- Batched H2D + multi-stream (synchronous find_clusters_batched) ---
+    /*
     {
         aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cuda_cf(
             {ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME, N_STREAMS);
 
         feed_pedestal(cuda_cf, pedestal_frames);
 
-        // Contiguous staging buffer reused across batches — registered as
-        // pinned so that H2D transfers run at DMA bandwidth (~22 GB/s) instead
-        // of going through the CUDA driver's internal staging (~15 GB/s for
-        // pageable memory).
         std::vector<FRAME_TYPE> batch_buffer(BATCH_SIZE * ROWS * COLS);
         cuda_cf.register_input_buffer(batch_buffer.data(),
                                       batch_buffer.size() * sizeof(FRAME_TYPE));
@@ -534,6 +530,99 @@ int main(int argc, char *argv[]) {
                gpu_total_clusters, pack_ms, gpu_ms, pack_ms + gpu_ms,
                1000.0 * (pack_ms + gpu_ms) / use_data, BATCH_SIZE, N_STREAMS);
     }
+    */
+
+    // --- Async pipeline: submit_batch / collect ---
+    {
+        aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cuda_cf(
+            {ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME, N_STREAMS);
+
+        feed_pedestal(cuda_cf, pedestal_frames);
+
+        // Two staging buffers so the CPU can be packing batch B into buf_next
+        // while the GPU processes the current batch from buf_cur.
+        std::vector<FRAME_TYPE> buf_cur(BATCH_SIZE * ROWS * COLS);
+        std::vector<FRAME_TYPE> buf_next(BATCH_SIZE * ROWS * COLS);
+        cuda_cf.register_input_buffer(buf_cur.data(),
+                                      buf_cur.size() * sizeof(FRAME_TYPE));
+
+        const size_t n_batches = (use_data + BATCH_SIZE - 1) / BATCH_SIZE;
+        double pack_ms = 0.0, gpu_ms = 0.0;
+        Timer t;
+
+        // Helper to drain batch results into gpu_results
+        auto drain_batch =
+            [&](std::vector<aare::ClusterVector<ClusterType>> &res,
+                size_t offset, size_t actual_batch) {
+                for (size_t f = 0; f < actual_batch; ++f) {
+                    auto &cv = res[f];
+                    auto &out = gpu_results[offset + f];
+                    out.clear();
+                    out.reserve(cv.size());
+                    for (size_t j = 0; j < cv.size(); ++j)
+                        out.push_back(cv[j]);
+                    gpu_total_clusters += out.size();
+                }
+            };
+
+        // Pack and submit the first batch
+        const size_t first_actual = std::min(BATCH_SIZE, use_data);
+        t.start();
+        pack_frame_batch(frames, 0, first_actual, buf_cur);
+        pack_ms += t.elapsed_ms();
+
+        aare::NDView<FRAME_TYPE, 3> view_cur(
+            buf_cur.data(), {static_cast<ssize_t>(first_actual), ROWS, COLS});
+
+        t.start();
+        auto tok = cuda_cf.submit_batch(view_cur, 0);
+        gpu_ms += t.elapsed_ms();
+
+        for (size_t bi = 1; bi < n_batches; ++bi) {
+            const size_t offset = bi * BATCH_SIZE;
+            const size_t actual_batch = std::min(BATCH_SIZE, use_data - offset);
+
+            // Pack next batch into the inactive buffer while GPU runs current
+            t.start();
+            pack_frame_batch(frames, offset, actual_batch, buf_next);
+            pack_ms += t.elapsed_ms();
+
+            aare::NDView<FRAME_TYPE, 3> view_next(
+                buf_next.data(),
+                {static_cast<ssize_t>(actual_batch), ROWS, COLS});
+
+            // Enqueue next batch — GPU now has both batches queued back-to-back
+            t.start();
+            auto next_tok = cuda_cf.submit_batch(view_next, offset);
+            gpu_ms += t.elapsed_ms();
+
+            // Collect previous batch (GPU runs next_tok concurrently)
+            auto prev_results = cuda_cf.collect(tok);
+            gpu_ms += 0; // collect time already elapsed inside GPU execution
+
+            const size_t prev_offset = (bi - 1) * BATCH_SIZE;
+            const size_t prev_actual =
+                std::min(BATCH_SIZE, use_data - prev_offset);
+            drain_batch(prev_results, prev_offset, prev_actual);
+
+            tok = next_tok;
+            std::swap(buf_cur, buf_next);
+        }
+
+        // Collect the final batch
+        auto last_results = cuda_cf.collect(tok);
+        const size_t last_offset = (n_batches - 1) * BATCH_SIZE;
+        const size_t last_actual = std::min(BATCH_SIZE, use_data - last_offset);
+        drain_batch(last_results, last_offset, last_actual);
+
+        cuda_cf.unregister_input_buffer();
+
+        printf("GPU(async pipeline): %zu clusters — pack=%.1f ms  GPU=%.1f ms  "
+               "total=%.1f ms"
+               "  (%.2f µs/frame, batch=%zu, streams=%d)\n",
+               gpu_total_clusters, pack_ms, gpu_ms, pack_ms + gpu_ms,
+               1000.0 * (pack_ms + gpu_ms) / use_data, BATCH_SIZE, N_STREAMS);
+    }
 
     // =========================================================================
     // Phase 5: Comparison
@@ -692,6 +781,61 @@ int main(int argc, char *argv[]) {
                    t.elapsed_ms() / (n_iter_batches * BATCH_SIZE), BATCH_SIZE,
                    N_STREAMS);
         }
+
+        // --- GPU benchmark (async submit/collect pipeline) ---
+        // submit_batch(B) is called before collect(A) returns, so both batches
+        // are enqueued in the CUDA streams simultaneously. The GPU executes
+        // them back-to-back with no idle gap between batches. collect(A) then
+        // drains A's results while the GPU is already running B.
+        {
+            aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>
+                cuda_cf({ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME,
+                        N_STREAMS);
+            feed_pedestal(cuda_cf, pedestal_frames);
+
+            std::vector<FRAME_TYPE> batch(BATCH_SIZE * ROWS * COLS);
+            for (size_t k = 0; k < BATCH_SIZE; ++k)
+                std::memcpy(batch.data() + k * ROWS * COLS, bench_frame.data(),
+                            ROWS * COLS * sizeof(FRAME_TYPE));
+            cuda_cf.register_input_buffer(batch.data(),
+                                          batch.size() * sizeof(FRAME_TYPE));
+
+            aare::NDView<FRAME_TYPE, 3> batch_view(
+                batch.data(), {static_cast<ssize_t>(BATCH_SIZE), ROWS, COLS});
+
+            // Warmup + reset pedestal
+            (void)cuda_cf.find_clusters_batched(batch_view, 0);
+            cuda_cf.clear_pedestal();
+            feed_pedestal(cuda_cf, pedestal_frames);
+
+            const size_t n_iter_batches =
+                (N_ITER + BATCH_SIZE - 1) / BATCH_SIZE;
+
+            Timer t;
+            t.start();
+
+            // Prime: submit first batch without waiting
+            auto tok = cuda_cf.submit_batch(batch_view, 0);
+
+            for (size_t b = 1; b < n_iter_batches; ++b) {
+                // Enqueue next batch while GPU is still executing the previous
+                // one — both batches sit in the stream queue simultaneously
+                auto next_tok =
+                    cuda_cf.submit_batch(batch_view, b * BATCH_SIZE);
+                // Now drain the previous batch; GPU runs next_tok concurrently
+                (void)cuda_cf.collect(tok);
+                tok = next_tok;
+            }
+            // Drain final batch
+            (void)cuda_cf.collect(tok);
+
+            cuda_cf.unregister_input_buffer();
+
+            printf("GPU(async pipeline):  %.3f ms/frame (submit/collect, "
+                   "batch=%zu, streams=%d)\n",
+                   t.elapsed_ms() / (n_iter_batches * BATCH_SIZE), BATCH_SIZE,
+                   N_STREAMS);
+        }
     }
 
     printf("\nDone.\n");
diff --git a/src/Makefile b/src/Makefile
index bd67746..580bf0f 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -8,7 +8,7 @@ LIBS     := -laare_core -lfmt -lstdc++fs
 DEFINES  := -DAARE_LOG_LEVEL=logERROR
 
 TARGET_OLD  := test_cf_cuda_old
-TARGET   	:= test_cf_cuda
+TARGET   	:= test_cf_cuda_asyncpipeline
 
 SRC_OLD  := ClusterFinderCUDA_old.test.cu 
 SRC      := ClusterFinderCUDA.test.cu