From 9921944772a3c11ce17afcbe524d0d5b5017f4e6 Mon Sep 17 00:00:00 2001
From: kferjaoui <khalilferjaoui@yahoo.fr>
Date: Wed, 2 Sep 2026 12:20:38 +0200
Subject: [PATCH] CUDA: zero-copy collection, pipelined slots, optional kernel
 timing

Host-side pipeline work ported from the benchmark branch. The kernel is
unchanged, so cluster results are identical.

  - collect_view()/BatchView: read clusters in place from the pinned D2H
    buffer instead of copying one ClusterVector per frame. The view is
    released back to the finder, so keep nothing that borrows it.
  - reserve_output_slots(), chunk_size_for(): pre-pin the output slots and
    size a batch to fit one.
  - find_cluster_views_batched_iter(): submits chunk i+1 before collecting
    chunk i.
  - time_kernels, default off. avg_kernel_time_ms() returns NaN unless
    enabled, and always for the Graph variant.
  - n_streams defaults to 4 everywhere.

ClusterFinderCUDA.ipynb cut to CPU MT vs batched CUDA plus a cluster-set
diff, and it now reports peak clusters/frame.

Removed src/ClusterFinderCUDA{,_old}.test.cu and src/Makefile (early C++
benchmarks, never in the CMake build), the perf and Frozen-vs-CUDA
notebooks, and helper.py.
---
 include/aare/ClusterFinderCUDA.hpp            |  677 +++++--
 include/aare/ClusterFinderCUDA_graph.hpp      |   10 +-
 include/aare/clusterfinder_kernel.cuh         |    6 +-
 python/aare/ClusterFinder.py                  |   81 +-
 python/aare/__init__.py                       |    2 +-
 python/src/bind_ClusterFinderCUDA.hpp         |  152 +-
 python/tests/ClusterFinderCUDA.ipynb          | 1603 ++++++-----------
 python/tests/ClusterFinderCUDA_perf.ipynb     |  617 -------
 .../tests/ClusterFinderFrozen_vs_CUDA.ipynb   |  309 ----
 python/tests/helper.py                        |  404 -----
 src/ClusterFinderCUDA.test.cu                 |  843 ---------
 src/ClusterFinderCUDA_old.test.cu             |  683 -------
 src/Makefile                                  |   31 -
 13 files changed, 1358 insertions(+), 4060 deletions(-)
 delete mode 100644 python/tests/ClusterFinderCUDA_perf.ipynb
 delete mode 100644 python/tests/ClusterFinderFrozen_vs_CUDA.ipynb
 delete mode 100644 python/tests/helper.py
 delete mode 100644 src/ClusterFinderCUDA.test.cu
 delete mode 100644 src/ClusterFinderCUDA_old.test.cu
 delete mode 100644 src/Makefile

diff --git a/include/aare/ClusterFinderCUDA.hpp b/include/aare/ClusterFinderCUDA.hpp
index 6bd90c03..4b2c0c49 100644
--- a/include/aare/ClusterFinderCUDA.hpp
+++ b/include/aare/ClusterFinderCUDA.hpp
@@ -53,6 +53,10 @@ class ClusterFinderCUDA {
 
     // Per-slot state consumed by collect()
     bool m_slot_in_flight[NUM_SLOTS] = {false, false};
+    // A BatchView handed out by collect_view() still points into this slot's
+    // pinned buffer. The slot must not be reused until the view is released, so
+    // submit_batch() refuses it rather than overwriting live results.
+    bool m_slot_view_held[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};
@@ -92,7 +96,18 @@ class ClusterFinderCUDA {
     float m_total_kernel_ms = 0.0f;
     size_t m_frames_processed = 0;
 
-    // Per-slot kernel timing event pools (sized lazily to the largest batch)
+    // Opt-in kernel timing. Off by default: it costs two cudaEventRecord per
+    // frame (real stream operations) plus one cudaEventElapsedTime query per
+    // frame on the host, and the number it produces is only meaningful when
+    // kernels cannot queue behind one another — see avg_kernel_time_ms().
+    bool m_time_kernels = false;
+
+    // Frames per internally pipelined chunk in find_clusters_batched().
+    // 0 = auto (batch split so one chunk is marshaled while the next runs).
+    size_t m_batch_chunk = 0;
+
+    // Per-slot kernel timing event pools (sized lazily to the largest batch).
+    // Left empty when m_time_kernels is false — no events are ever created.
     std::vector<cudaEvent_t> m_kernel_start_pools[NUM_SLOTS];
     std::vector<cudaEvent_t> m_kernel_stop_pools[NUM_SLOTS];
 
@@ -107,6 +122,132 @@ class ClusterFinderCUDA {
     dim3 block;
     size_t shmem_bytes;
 
+    /// Copy every frame of a pinned output slot into results, turning the
+    /// packed device layout into owned ClusterVectors. This is exactly the work
+    /// collect_view() exists to avoid.
+    ///
+    /// Single-threaded on purpose. Spreading this copy over a thread pool was
+    /// tried and reverted: the work is one 467 kB malloc + first-touch per
+    /// frame at 9x9, so it is allocation-bound rather than bandwidth-bound.
+    /// Extra threads get their own glibc arenas, which destroys heap reuse
+    /// between calls and costs more in page faults than the parallel copy saves
+    /// — measured 2.27 M faults at 8 threads vs 9.7 k at 1, for a 6 % gain at
+    /// best and a 33 % *loss* when results are freed promptly. The fix is to
+    /// stop allocating per frame, not to copy faster.
+    void
+    materialize_slot(const void *slot_base, size_t n_frames,
+                     std::vector<ClusterVector<ClusterType>> &results) const {
+        for (size_t frame_idx = 0; frame_idx < n_frames; ++frame_idx) {
+            const void *h_out = static_cast<const char *>(slot_base) +
+                                frame_idx * m_output_bytes_per_frame;
+            uint32_t n_found = *reinterpret_cast<const uint32_t *>(h_out);
+            // The device counter increments past the cap (only the write is
+            // guarded), so this clamp is an out-of-bounds guard, not a tuning
+            // choice.
+            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));
+            }
+        }
+    }
+
+    /// Default number of pipelined chunks per find_clusters_batched() call.
+    /// Two competing costs set this:
+    ///   - fill/drain: the first submit and last collect are not overlapped,
+    ///     costing min(GPU, host) per batch = min/(C*max) of the total, so this
+    ///     term FALLS as C grows;
+    ///   - per-chunk tail: every chunk ends with all streams draining,
+    ///     ~n_streams * kernel_time of partly-idle GPU, so this term RISES
+    ///     linearly with C.
+    /// Measured 9x9 rates (GPU 26.7 us/frame, host 58.8 us/frame, kernel
+    /// 25.4 us, 2000 frames) put the sum at 23 % for C=2, 11 % for C=4,
+    /// 6 % for C=8 and ~4 % for C=16-32 — a flat minimum past 16. C=8 sits
+    /// inside the knee while keeping chunks large enough that each stream still
+    /// gets a healthy number of frames. Override with set_batch_chunk() to
+    /// measure rather than trust this.
+    static constexpr size_t DEFAULT_BATCH_CHUNKS = 8;
+
+    /// Upper bound on one pinned output slot. cudaMallocHost is page-locked, so
+    /// its first touch is charged to whoever triggers it — keep it modest.
+    static constexpr size_t MAX_SLOT_BYTES = 128ull << 20; // 128 MiB
+
+    /// Frames per pipelined chunk in find_clusters_batched(). Rounded up to a
+    /// multiple of n_streams so chunking never changes which stream a frame
+    /// lands on (the device pedestal is per-stream, so a different assignment
+    /// would mean a different pedestal state per frame — a correctness issue,
+    /// not a tidiness one).
+    size_t resolve_batch_chunk(size_t n_frames) const {
+        const size_t ns = static_cast<size_t>(n_streams);
+        size_t chunk = m_batch_chunk;
+        if (chunk == 0) {
+            chunk =
+                (n_frames + DEFAULT_BATCH_CHUNKS - 1) / DEFAULT_BATCH_CHUNKS;
+            // Keep at least a few frames per stream per chunk, or the per-chunk
+            // drain dominates.
+            const size_t min_chunk = ns * 4;
+            if (chunk < min_chunk)
+                chunk = min_chunk;
+            // Cap by BYTES, not frames. Each slot is cudaMallocHost'd at
+            // chunk * m_output_bytes_per_frame, and there are NUM_SLOTS of
+            // them. Without this, find_clusters_batched(whole_array) scales the
+            // pinned allocation with the array: 20 000 frames at 9x9 gives
+            // 2500-frame chunks = 1.23 GB per slot, 2.46 GB pinned, whose
+            // first-touch cost (~600 k page faults) lands inside the caller's
+            // timed region. Bounding it makes one big call behave like a loop
+            // over slices.
+            const size_t max_by_bytes =
+                std::max<size_t>(1, MAX_SLOT_BYTES / m_output_bytes_per_frame);
+            if (chunk > max_by_bytes)
+                chunk = std::max(max_by_bytes, ns);
+        }
+        chunk = ((chunk + ns - 1) / ns) * ns;
+        return std::min(chunk, n_frames);
+    }
+
+    /// Called by BatchView when it is released, making the slot reusable.
+    void release_slot(int slot) {
+        if (slot >= 0 && slot < NUM_SLOTS)
+            m_slot_view_held[slot] = false;
+    }
+
+    /// Wait for a slot's D2H to land and hand back its bookkeeping. Shared by
+    /// collect() and collect_view() so the two cannot drift.
+    void finish_slot(int slot, size_t &n_frames, uint64_t &first_frame) {
+        if (!m_slot_in_flight[slot])
+            throw std::runtime_error(
+                "ClusterFinderCUDA: collect() called on a slot that is not "
+                "in flight");
+        n_frames = m_slot_n_frames[slot];
+        first_frame = m_slot_first_frame[slot];
+        // cudaEventSynchronize (not cudaStreamSynchronize) so a batch already
+        // queued behind this one in the same streams is not waited on.
+        for (int k = 0; k < m_slot_streams_used[slot]; ++k)
+            CUDA_CHECK(cudaEventSynchronize(m_batch_done[slot][k]));
+        accumulate_kernel_times(slot, n_frames);
+        m_frames_processed += n_frames;
+        m_slot_in_flight[slot] = false;
+    }
+
+    /// Accumulate per-frame kernel times for a slot. Serial by construction:
+    /// it mutates m_total_kernel_ms and queries CUDA events.
+    void accumulate_kernel_times(int slot, size_t n_frames) {
+        if (!m_time_kernels)
+            return;
+        for (size_t frame_idx = 0; frame_idx < n_frames; ++frame_idx) {
+            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;
+        }
+    }
+
   public:
     /**
      * @brief Opaque handle returned by submit_batch(). Pass to collect().
@@ -115,6 +256,130 @@ class ClusterFinderCUDA {
         int slot;
     };
 
+    using value_type = typename ClusterType::value_type;
+
+    /**
+     * @brief Zero-copy view of a batch, still in the pinned D2H buffer.
+     *
+     * The D2H staging buffer already holds correctly laid-out clusters at a
+     * fixed per-frame stride, so there is nothing to copy: this just exposes
+     * offsets into it. Host cost per frame drops to reading one counter.
+     *
+     * @warning The view borrows the finder's slot. It stays valid until
+     * release() (or destruction); until then submit_batch() will refuse that
+     * slot rather than overwrite live results. With NUM_SLOTS == 2 that means
+     * you must finish with a view before submitting two more batches — the
+     * intended pattern is consume-then-release, one chunk at a time.
+     */
+    class BatchView {
+        friend class ClusterFinderCUDA;
+
+        ClusterFinderCUDA *m_owner = nullptr;
+        const uint8_t *m_base = nullptr;
+        size_t m_n_frames = 0;
+        uint64_t m_first_frame = 0;
+        size_t m_stride = 0;    // bytes per frame in the pinned buffer
+        size_t m_cl_offset = 0; // byte offset of the cluster array in a frame
+        size_t m_max_clusters = 0;
+        int m_slot = -1;
+
+        BatchView(ClusterFinderCUDA *owner, const void *base, size_t n_frames,
+                  uint64_t first_frame, size_t stride, size_t cl_offset,
+                  size_t max_clusters, int slot)
+            : m_owner(owner), m_base(static_cast<const uint8_t *>(base)),
+              m_n_frames(n_frames), m_first_frame(first_frame),
+              m_stride(stride), m_cl_offset(cl_offset),
+              m_max_clusters(max_clusters), m_slot(slot) {}
+
+      public:
+        BatchView() = default;
+        BatchView(const BatchView &) = delete;
+        BatchView &operator=(const BatchView &) = delete;
+        BatchView(BatchView &&o) noexcept { steal(o); }
+        BatchView &operator=(BatchView &&o) noexcept {
+            if (this != &o) {
+                release();
+                steal(o);
+            }
+            return *this;
+        }
+        ~BatchView() { release(); }
+
+        /// Give the slot back. Idempotent; the view is unusable afterwards.
+        void release() {
+            if (m_owner)
+                m_owner->release_slot(m_slot);
+            m_owner = nullptr;
+            m_base = nullptr;
+            m_n_frames = 0;
+            m_slot = -1;
+        }
+
+        bool valid() const { return m_base != nullptr; }
+        size_t n_frames() const { return m_n_frames; }
+        uint64_t first_frame() const { return m_first_frame; }
+
+        uint32_t count(size_t i) const {
+            check(i);
+            uint32_t n =
+                *reinterpret_cast<const uint32_t *>(m_base + i * m_stride);
+            // The device counter increments past the cap (only the write is
+            // guarded), so clamp: this is an out-of-bounds guard.
+            return std::min<uint32_t>(n, static_cast<uint32_t>(m_max_clusters));
+        }
+
+        const ClusterType *clusters(size_t i) const {
+            check(i);
+            return reinterpret_cast<const ClusterType *>(m_base + i * m_stride +
+                                                         m_cl_offset);
+        }
+
+        size_t total_clusters() const {
+            size_t n = 0;
+            for (size_t i = 0; i < m_n_frames; ++i)
+                n += count(i);
+            return n;
+        }
+
+        /// Per-cluster sums for the whole batch, concatenated frame by frame.
+        /// The common reduction, done here so callers never have to materialise
+        /// the clusters themselves.
+        std::vector<value_type> sums() const {
+            std::vector<value_type> out;
+            out.reserve(total_clusters());
+            for (size_t i = 0; i < m_n_frames; ++i) {
+                const ClusterType *c = clusters(i);
+                const uint32_t n = count(i);
+                for (uint32_t j = 0; j < n; ++j)
+                    out.push_back(c[j].sum());
+            }
+            return out;
+        }
+
+      private:
+        void steal(BatchView &o) {
+            m_owner = o.m_owner;
+            m_base = o.m_base;
+            m_n_frames = o.m_n_frames;
+            m_first_frame = o.m_first_frame;
+            m_stride = o.m_stride;
+            m_cl_offset = o.m_cl_offset;
+            m_max_clusters = o.m_max_clusters;
+            m_slot = o.m_slot;
+            o.m_owner = nullptr;
+            o.m_base = nullptr;
+            o.m_slot = -1;
+        }
+        void check(size_t i) const {
+            if (!m_base)
+                throw std::runtime_error(
+                    "ClusterFinderCUDA::BatchView: view has been released");
+            if (i >= m_n_frames)
+                throw std::out_of_range(
+                    "ClusterFinderCUDA::BatchView: frame index out of range");
+        }
+    };
+
     /**
      * @brief Construct a ClusterFinderCUDA
      *
@@ -125,13 +390,19 @@ class ClusterFinderCUDA {
      * fixed-size D2H
      * @param n_streams_                number of CUDA streams for multi-frame
      * overlap
+     * @param time_kernels              enable per-frame CUDA-event kernel
+     * timing. Off by default: it adds two event records per frame to the
+     * streams and one host-side query per frame, and the resulting number is
+     * only meaningful at n_streams == 1 (see avg_kernel_time_ms()).
      */
     ClusterFinderCUDA(Shape<2> shape_, COMPUTE_TYPE nSigma = 5.0,
-                      size_t max_clusters_per_frame = 2048, int n_streams_ = 5)
+                      size_t max_clusters_per_frame = 2048, int n_streams_ = 4,
+                      bool time_kernels = false)
         : m_shape(shape_), nrows(shape_[0]), ncols(shape_[1]),
           m_image_size(nrows * ncols), n_streams(n_streams_),
           m_max_clusters_per_frame(max_clusters_per_frame), m_nSigma(nSigma),
-          m_pedestal(shape_[0], shape_[1]), m_clusters(max_clusters_per_frame) {
+          m_pedestal(shape_[0], shape_[1]), m_clusters(max_clusters_per_frame),
+          m_time_kernels(time_kernels) {
         if (n_streams_ <= 0) {
             throw std::invalid_argument(
                 "ClusterFinderCUDA: n_streams must be > 0");
@@ -407,22 +678,20 @@ class ClusterFinderCUDA {
             throw std::runtime_error(
                 "ClusterFinderCUDA: both batch slots are in flight — call "
                 "collect() before submitting a third batch");
+        // Inert unless collect_view() was used: a live BatchView still points
+        // into this slot's pinned buffer, so reusing it would overwrite results
+        // the caller is still reading.
+        if (m_slot_view_held[slot])
+            throw std::runtime_error(
+                "ClusterFinderCUDA: this batch slot is still held by a "
+                "BatchView — release() it before submitting another 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;
-        }
-
+        grow_output_slot(slot, n_frames_batch);
         ensure_event_pool(slot, n_frames_batch);
 
         // Launch all frames round-robin across streams
@@ -439,16 +708,18 @@ class ClusterFinderCUDA {
 
             auto *d_clusters = reinterpret_cast<ClusterType *>(
                 sc.d_output + m_clusters_offset);
-            CUDA_CHECK(cudaEventRecord(m_kernel_start_pools[slot][frame_idx],
-                                       sc.stream));
+            if (m_time_kernels)
+                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,
                     sc.d_pd_off, 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));
+            if (m_time_kernels)
+                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]) +
@@ -506,140 +777,286 @@ class ClusterFinderCUDA {
             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));
+        // 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));
-            }
+        //     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;
-        }
+        //     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;
+        // }
+
+        // materialize_slot() is the original copy loop verbatim, just hoisted
+        // into a helper so find_clusters_batched() shares it;
+        // accumulate_kernel_times is the m_time_kernels branch that used to
+        // live in the same loop.
+        materialize_slot(h_output_slots[slot], n_frames_batch, results);
+        accumulate_kernel_times(slot, n_frames_batch);
 
         m_frames_processed += n_frames_batch;
         m_slot_in_flight[slot] = false;
         return results;
     }
 
+    /**
+     * @brief Collect a batch as a zero-copy view — no allocation, no copy.
+     *
+     * Nothing is copied and nothing is allocated: the returned view points into
+     * the finder's pinned D2H buffer. The slot is held until the view is
+     * released, so at most NUM_SLOTS - 1 further batches can be submitted while
+     * it is alive. Consume, then release.
+     */
+    BatchView collect_view(BatchToken token) {
+        const int slot = token.slot;
+        size_t n_frames = 0;
+        uint64_t first_frame = 0;
+        finish_slot(slot, n_frames, first_frame);
+
+        m_slot_view_held[slot] = true;
+        return BatchView(this, h_output_slots[slot], n_frames, first_frame,
+                         m_output_bytes_per_frame, m_clusters_offset,
+                         m_max_clusters_per_frame, slot);
+    }
+
     /**
      * @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). Does not go through submit_batch/collect so it carries
-     * no async-slot overhead.
+     * first_frame + i).
+     *
+     * Internally the batch is split into chunks and pipelined over the two
+     * async slots: chunk i+1 is submitted before chunk i is collected, so the
+     * host marshals one chunk while the GPU runs the next. A single call used
+     * to be strictly `run the whole batch, then copy the whole batch`, leaving
+     * the GPU idle for the entire host phase.
+     *
+     * Chunk size is rounded up to a multiple of n_streams so the frame->stream
+     * assignment is identical to processing the batch in one go. That matters
+     * for correctness, not just tidiness: the device pedestal is per-stream, so
+     * changing which stream a frame lands on would change the pedestal state it
+     * is evaluated against.
+     *
+     * @note Now shares the two batch slots with submit_batch()/collect(). A
+     *       batch already in flight is no longer silently overwritten — you get
+     *       an exception instead.
      */
     std::vector<ClusterVector<ClusterType>>
     find_clusters_batched(NDView<FRAME_TYPE, 3> frames,
                           uint64_t first_frame = 0) {
-        if (m_pedestal_dirty) {
-            sync_pedestal_to_device();
-            m_pedestal_dirty = false;
-        }
-
         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());
+        if (n_frames_batch == 0)
+            return {};
 
-        // Lazy grow D2H output staging buffer (one slot per frame)
-        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_slots[0], n_frames_batch * m_output_bytes_per_frame));
-            m_output_slot_capacity[0] = n_frames_batch;
-        }
-
-        ensure_event_pool(0, n_frames_batch);
+        const size_t chunk = resolve_batch_chunk(n_frames_batch);
 
         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);
+
+        auto drain = [&results](std::vector<ClusterVector<ClusterType>> part) {
+            for (auto &cv : part)
+                results.push_back(std::move(cv));
+        };
+
+        BatchToken tok = submit_batch(
+            frames.sub_view(
+                0, static_cast<ssize_t>(std::min(chunk, n_frames_batch))),
+            first_frame);
+        for (size_t b = chunk; b < n_frames_batch; b += chunk) {
+            const size_t e = std::min(b + chunk, n_frames_batch);
+            // Submit before collecting: the GPU starts chunk b while the host
+            // is still copying chunk b - chunk out of the pinned slot.
+            BatchToken nxt =
+                submit_batch(frames.sub_view(static_cast<ssize_t>(b),
+                                             static_cast<ssize_t>(e)),
+                             first_frame + b);
+            drain(collect(tok));
+            tok = nxt;
         }
+        drain(collect(tok));
 
-        // Launch all frames round-robin across streams.
-        // If the caller has called register_input_buffer() on frames.data(),
-        // H2D runs at pinned DMA bandwidth (~22 GB/s); otherwise the CUDA
-        // driver stages it internally (~15 GB/s for pageable memory).
-        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[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,
-                    sc.d_pd_off, 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[0][frame_idx], sc.stream));
-            CUDA_CHECK(cudaGetLastError());
-
-            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));
-        }
-
-        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));
-
-        for (size_t frame_idx = 0; frame_idx < n_frames_batch; ++frame_idx) {
-            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_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[0][frame_idx],
-                                            m_kernel_stop_pools[0][frame_idx]));
-            m_total_kernel_ms += kernel_ms;
-        }
-
-        m_frames_processed += n_frames_batch;
         return results;
     }
 
+    // Previous implementation: one launch loop over the whole batch, one
+    // cudaStreamSynchronize per stream, then one single-threaded copy loop over
+    // every frame. Kept for reference — it is what the numbers in
+    // docs/ClusterFinderCUDA_benchmark_results.md opt3/opt4 (Act I, sections
+    // 5-6) were measured against.
+    //
+    // std::vector<ClusterVector<ClusterType>>
+    // find_clusters_batched(NDView<FRAME_TYPE, 3> frames,
+    //                       uint64_t first_frame = 0) {
+    //     if (m_pedestal_dirty) {
+    //         sync_pedestal_to_device();
+    //         m_pedestal_dirty = false;
+    //     }
+    //
+    //     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_slot_capacity[0]) {
+    //         if (h_output_slots[0])
+    //             CUDA_CHECK(cudaFreeHost(h_output_slots[0]));
+    //         CUDA_CHECK(cudaMallocHost(&h_output_slots[0],
+    //                                   n_frames_batch *
+    //                                       m_output_bytes_per_frame));
+    //         m_output_slot_capacity[0] = n_frames_batch;
+    //     }
+    //
+    //     ensure_event_pool(0, n_frames_batch);
+    //
+    //     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) {
+    //         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);
+    //         if (m_time_kernels)
+    //             CUDA_CHECK(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,
+    //                 sc.d_pd_off, n_pd_samples, m_nSigma, nrows, ncols,
+    //                 d_clusters, d_cluster_count,
+    //                 static_cast<uint32_t>(m_max_clusters_per_frame));
+    //         if (m_time_kernels)
+    //             CUDA_CHECK(cudaEventRecord(
+    //                 m_kernel_stop_pools[0][frame_idx], sc.stream));
+    //         CUDA_CHECK(cudaGetLastError());
+    //
+    //         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));
+    //     }
+    //
+    //     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));
+    //
+    //     for (size_t frame_idx = 0; frame_idx < n_frames_batch;
+    //          ++frame_idx) {
+    //         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_out) + m_clusters_offset);
+    //             results[frame_idx].resize(n_found);
+    //             std::memcpy(results[frame_idx].data(), src,
+    //                         n_found * sizeof(ClusterType));
+    //         }
+    //
+    //         if (m_time_kernels) {
+    //             float kernel_ms = 0.0f;
+    //             CUDA_CHECK(cudaEventElapsedTime(
+    //                 &kernel_ms, m_kernel_start_pools[0][frame_idx],
+    //                 m_kernel_stop_pools[0][frame_idx]));
+    //             m_total_kernel_ms += kernel_ms;
+    //         }
+    //     }
+    //
+    //     m_frames_processed += n_frames_batch;
+    //     return results;
+    // }
+
+    /// True if per-frame kernel timing was enabled at construction.
+    bool kernel_timing_enabled() const { return m_time_kernels; }
+
+    /**
+     * @brief Frames per internally pipelined chunk in find_clusters_batched().
+     *
+     * 0 (default) = auto: the batch is split into ~8 chunks so the host can
+     * marshal one chunk while the GPU runs the next. Rounded up to a multiple
+     * of n_streams. Set equal to the batch size to disable chunking and get
+     * the old submit-everything-then-copy-everything behaviour.
+     */
+    void set_batch_chunk(size_t n) { m_batch_chunk = n; }
+    size_t get_batch_chunk() const { return m_batch_chunk; }
+
+    /// The chunk size find_clusters_batched() would use for n_frames. Exposed
+    /// so a caller driving submit/collect_view by hand can match its pipelining
+    /// without duplicating the rounding rules.
+    size_t chunk_size_for(size_t n_frames) const {
+        return resolve_batch_chunk(n_frames);
+    }
+
+    /**
+     * @brief Pre-allocate both pinned output slots for batches of n_frames.
+     *
+     * Processes nothing: no frame is transferred, no kernel is launched, and
+     * the pedestal is untouched. Only the two cudaMallocHost calls that
+     * submit_batch() would otherwise make on its first invocation happen here.
+     *
+     * The point is that page-locking is expensive and is charged to whoever
+     * triggers it: measured ~1.0 us per 4 kB page, i.e. ~66 ms for two 128 MiB
+     * slots (and ~40 % more if an undersized slot has to be freed first). Left
+     * to submit_batch() that cost lands inside the first timed region — worth
+     * 2.8 us/frame over 20 000 frames at 3x3, which is 17 % of the 16.2 us
+     * roofline. Call this before starting a timer, or before a
+     * latency-sensitive first batch. Slots only ever grow, so a later smaller
+     * batch is free and a larger one still re-allocates: pass the largest batch
+     * you intend to use, e.g. chunk_size_for(n) when driving
+     * find_clusters_batched() or the submit/collect_view loop over n frames.
+     */
+    void reserve_output_slots(size_t n_frames) {
+        for (int slot = 0; slot < NUM_SLOTS; ++slot)
+            grow_output_slot(slot, n_frames);
+    }
+
+    /**
+     * @brief Average per-frame kernel time in ms, or NaN if timing is disabled.
+     *
+     * @warning Only meaningful at n_streams == 1. The CUDA events bracket the
+     * kernel on its own stream, so under multi-stream contention the measured
+     * interval includes time queued behind kernels from other streams — it
+     * over-reads by up to ~3.5x. Use Nsight Systems for exclusive kernel times.
+     */
     float avg_kernel_time_ms() const {
+        if (!m_time_kernels)
+            return std::numeric_limits<float>::quiet_NaN();
         return m_frames_processed > 0 ? m_total_kernel_ms / m_frames_processed
                                       : 0.0f;
     }
@@ -704,7 +1121,21 @@ class ClusterFinderCUDA {
             CUDA_CHECK(cudaStreamSynchronize(sc.stream));
     }
 
+    /// Grow one slot's pinned D2H buffer to hold n_frames. Only ever grows, so
+    /// a run whose batches keep the same shape allocates once.
+    void grow_output_slot(int slot, size_t n_frames) {
+        if (n_frames <= m_output_slot_capacity[slot])
+            return;
+        if (h_output_slots[slot])
+            CUDA_CHECK(cudaFreeHost(h_output_slots[slot]));
+        CUDA_CHECK(cudaMallocHost(&h_output_slots[slot],
+                                  n_frames * m_output_bytes_per_frame));
+        m_output_slot_capacity[slot] = n_frames;
+    }
+
     void ensure_event_pool(int slot, size_t n_frames) {
+        if (!m_time_kernels)
+            return; // no events are created when timing is disabled
         const size_t old_size = m_kernel_start_pools[slot].size();
         if (n_frames <= old_size)
             return;
diff --git a/include/aare/ClusterFinderCUDA_graph.hpp b/include/aare/ClusterFinderCUDA_graph.hpp
index 0ea861ae..c2a7b8bb 100644
--- a/include/aare/ClusterFinderCUDA_graph.hpp
+++ b/include/aare/ClusterFinderCUDA_graph.hpp
@@ -400,7 +400,15 @@ class ClusterFinderCUDAGraph {
         return results;
     }
 
-    float avg_kernel_time_ms() const { return 0.0f; }
+    /// Always NaN: the graph variant does not instrument individual kernels
+    /// (the whole H2D->kernel->D2H DAG is replayed as one unit). Use Nsight
+    /// Systems, or wall-clock timing around find_clusters_batched().
+    float avg_kernel_time_ms() const {
+        return std::numeric_limits<float>::quiet_NaN();
+    }
+
+    /// False: this variant never instruments kernels.
+    bool kernel_timing_enabled() const { return false; }
 
     void reset_timers() { m_frames_processed = 0; }
 
diff --git a/include/aare/clusterfinder_kernel.cuh b/include/aare/clusterfinder_kernel.cuh
index 23057362..b3a2d34c 100644
--- a/include/aare/clusterfinder_kernel.cuh
+++ b/include/aare/clusterfinder_kernel.cuh
@@ -38,9 +38,11 @@ __global__ void find_clusters_in_single_frame(
     constexpr int row_radius = CSY / 2;
 
     // Squared threshold constants; avoids sqrt at runtime
-    // c2^2 is for the 2x2 quadrant test
+    // c2^2 is for the 2x2 quadrant test -- commented out along with Test 2
+    //     itself (see below), whose disabled block is its only reader. Left in
+    //     place rather than deleted so re-enabling Test 2 is one uncomment.
     // c3^2 is for the full-cluster total test
-    constexpr int pow2_c2 = ((CSY + 1) / 2) * ((CSX + 1) / 2);
+    // constexpr int pow2_c2 = ((CSY + 1) / 2) * ((CSX + 1) / 2);
     constexpr int pow2_c3 = CSX * CSY;
 
     // Thread/pixel mapping
diff --git a/python/aare/ClusterFinder.py b/python/aare/ClusterFinder.py
index 6f53f131..11319e5b 100644
--- a/python/aare/ClusterFinder.py
+++ b/python/aare/ClusterFinder.py
@@ -69,7 +69,8 @@ def _cuda_available():
 
 
 def ClusterFinderCUDA(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32,
-                      max_clusters_per_frame=2048, n_streams=4):
+                      max_clusters_per_frame=2048, n_streams=4,
+                      time_kernels=False):
     """
     Factory function to create a ClusterFinderCUDA object. Provides a cleaner
     syntax for the templated ClusterFinderCUDA in C++. API mirrors
@@ -91,6 +92,14 @@ def ClusterFinderCUDA(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32,
         but as tight as possible to minimize PCIe traffic. Default 2048.
     n_streams : int, optional
         Number of CUDA streams for H2D/kernel/D2H pipelining. Default 4.
+    time_kernels : bool, optional
+        Enable per-frame CUDA-event kernel timing, exposed via
+        avg_kernel_time_ms(). Off by default because it adds two event records
+        per frame to the streams plus a host-side query per frame, and the
+        number it yields is only meaningful at n_streams=1 — under multi-stream
+        contention the events measure queue wait, not execution, and over-read
+        by up to ~3.5x. Use Nsight Systems for exclusive kernel times. When
+        disabled, avg_kernel_time_ms() returns NaN.
 
     Example
     -------
@@ -101,7 +110,7 @@ def ClusterFinderCUDA(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32,
         cf = ClusterFinderCUDA(image_size=(400, 400),
                                cluster_size=(3, 3),
                                n_sigma=5,
-                               n_streams=5)
+                               n_streams=4)
         for frame in pedestal_frames:
             cf.push_pedestal_frame(frame)
 
@@ -123,7 +132,71 @@ def ClusterFinderCUDA(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32,
     return cls(image_size,
                n_sigma=n_sigma,
                max_clusters_per_frame=max_clusters_per_frame,
-               n_streams=n_streams)
+               n_streams=n_streams,
+               time_kernels=time_kernels)
+
+def find_cluster_views_batched_iter(cf, frames, first_frame=0, chunk=None):
+    """
+    Drive a ClusterFinderCUDA over `frames`, yielding zero-copy BatchViews.
+
+    Same pipelining as cf.find_clusters_batched() — chunk i+1 is submitted
+    before chunk i is collected — but nothing is copied out of the pinned D2H
+    buffer, so the host cost per frame collapses to reading one counter. At 9x9
+    that removes ~467 kB of copying per frame.
+
+    Each view is released as soon as the loop body finishes, which is what makes
+    the next submit legal (the finder has only two slots). Consequently:
+
+    **Anything you need after the loop body must be copied out.** Reductions
+    (`v.sums()`) return owned numpy arrays and are safe; `v.frame_data(i)` and
+    `v.frame_xy(i)` are views and are not.
+
+    Parameters
+    ----------
+    cf : ClusterFinderCUDA
+    frames : ndarray (n_frames, nrows, ncols), uint16
+        Pin it first with cf.register_input_buffer(frames) for DMA-speed H2D.
+    first_frame : int
+        Frame number of frames[0].
+    chunk : int, optional
+        Frames per chunk; defaults to cf.chunk_size_for(len(frames)).
+
+    Yields
+    ------
+    BatchView
+        Valid only until the next iteration.
+
+    Example
+    -------
+    .. code-block:: python
+
+        cf.register_input_buffer(data)
+        for v in find_cluster_views_batched_iter(cf, data):
+            hist.fill(v.sums())          # reduced in C++, nothing materialised
+        cf.unregister_input_buffer()
+    """
+    n = frames.shape[0]
+    if n == 0:
+        return
+    c = chunk or cf.chunk_size_for(n)
+    bounds = [(s, min(s + c, n)) for s in range(0, n, c)]
+
+    tok = cf.submit_batch(frames[bounds[0][0]:bounds[0][1]],
+                          first_frame=first_frame + bounds[0][0])
+    for a, b in bounds[1:]:
+        nxt = cf.submit_batch(frames[a:b], first_frame=first_frame + a)
+        view = cf.collect_view(tok)
+        try:
+            yield view
+        finally:
+            view.release()          # frees the slot for the submit after next
+        tok = nxt
+    view = cf.collect_view(tok)
+    try:
+        yield view
+    finally:
+        view.release()
+
 
 def ClusterFinderCUDAGraph(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.int32,
                            max_clusters_per_frame=2048, n_streams=4):
@@ -166,7 +239,7 @@ def ClusterFinderCUDAGraph(image_size, cluster_size=(3,3), n_sigma=5, dtype=np.i
                n_streams=n_streams)
 
 
-def ClusterCollector(clusterfindermt, dtype=np.int32): 
+def ClusterCollector(clusterfindermt, dtype=np.int32):
     """ 
     Factory function to create a ClusterCollector object. Provides a cleaner syntax for 
     the templated ClusterCollector in C++.
diff --git a/python/aare/__init__.py b/python/aare/__init__.py
index 7c6b3594..cebb26b2 100644
--- a/python/aare/__init__.py
+++ b/python/aare/__init__.py
@@ -32,7 +32,7 @@ from ._aare import corner
 
 from ._version import __version__
 from .ClusterFinder import ClusterFinder, ClusterFinderFrozen, ClusterCollector, ClusterFinderMT, ClusterFileSink, ClusterFile
-from .ClusterFinder import ClusterFinderCUDA, ClusterFinderCUDAGraph, _cuda_available
+from .ClusterFinder import ClusterFinderCUDA, ClusterFinderCUDAGraph, _cuda_available, find_cluster_views_batched_iter
 from .ClusterVector import ClusterVector
 from .Cluster import Cluster
 
diff --git a/python/src/bind_ClusterFinderCUDA.hpp b/python/src/bind_ClusterFinderCUDA.hpp
index 2d555394..13a237fb 100644
--- a/python/src/bind_ClusterFinderCUDA.hpp
+++ b/python/src/bind_ClusterFinderCUDA.hpp
@@ -35,10 +35,84 @@ void define_ClusterFinderCUDA(py::module &m, const std::string &typestr) {
     py::class_<typename CF::BatchToken>(m,
                                         (class_name + "_BatchToken").c_str());
 
+    using VT = typename ClusterType::value_type;
+    constexpr size_t NPIX =
+        static_cast<size_t>(ClusterSizeX) * static_cast<size_t>(ClusterSizeY);
+
+    // Zero-copy view into the finder's pinned D2H buffer.
+    py::class_<typename CF::BatchView>(m, (class_name + "_BatchView").c_str())
+        .def_property_readonly("n_frames", &CF::BatchView::n_frames)
+        .def_property_readonly("first_frame", &CF::BatchView::first_frame)
+        .def_property_readonly("valid", &CF::BatchView::valid)
+        .def_property_readonly("total_clusters", &CF::BatchView::total_clusters)
+        .def("count", &CF::BatchView::count, py::arg("frame_index"))
+        .def("release", &CF::BatchView::release,
+             R"(Give the slot back to the finder. The view is unusable
+             afterwards and submit_batch() may reuse the buffer. Called
+             automatically on destruction and on __exit__.)")
+        .def("__enter__", [](py::object self) { return self; })
+        .def("__exit__", [](typename CF::BatchView &v, py::object, py::object,
+                            py::object) { v.release(); })
+        .def_property_readonly(
+            "counts",
+            [](const typename CF::BatchView &v) {
+                py::array_t<uint32_t> out(v.n_frames());
+                auto *o = out.mutable_data();
+                for (size_t i = 0; i < v.n_frames(); ++i)
+                    o[i] = v.count(i);
+                return out;
+            },
+            R"(Clusters found per frame, as a numpy array.)")
+        .def(
+            "sums",
+            [](const typename CF::BatchView &v) {
+                std::vector<VT> s;
+                {
+                    // Reduce without the GIL, but take it back before building
+                    // the array — constructing a Python object without it is a
+                    // segfault, so this cannot be a call_guard.
+                    py::gil_scoped_release nogil;
+                    s = v.sums();
+                }
+                return py::array_t<VT>(s.size(), s.data());
+            },
+            R"(Per-cluster sums for the whole batch, reduced in C++ straight out
+            of the pinned buffer — the clusters are never materialised on the
+            host. This is the fast path for spectra/histograms.)")
+        .def(
+            "frame_data",
+            [](py::object self, size_t i) {
+                auto &v = self.cast<typename CF::BatchView &>();
+                const uint32_t n = v.count(i);
+                // Zero-copy (n, NPIX) view; stride skips each cluster's x/y.
+                return py::array_t<VT>(
+                    {static_cast<size_t>(n), NPIX},
+                    {sizeof(ClusterType), sizeof(VT)},
+                    n == 0 ? nullptr : v.clusters(i)->data.data(), self);
+            },
+            py::arg("frame_index"),
+            R"(Zero-copy (n_clusters, ClusterSizeX*ClusterSizeY) view of one
+            frame's pixel data, straight out of the pinned buffer. Valid until
+            this view is released — copy it if you need to keep it.)")
+        .def(
+            "frame_xy",
+            [](py::object self, size_t i) {
+                auto &v = self.cast<typename CF::BatchView &>();
+                const uint32_t n = v.count(i);
+                return py::array_t<CoordType>(
+                    {static_cast<size_t>(n), size_t{2}},
+                    {sizeof(ClusterType), sizeof(CoordType)},
+                    n == 0 ? nullptr : &v.clusters(i)->x, self);
+            },
+            py::arg("frame_index"),
+            R"(Zero-copy (n_clusters, 2) view of one frame's cluster centre
+            coordinates as (x, y).)");
+
     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,
-             py::arg("max_clusters_per_frame") = 2048, py::arg("n_streams") = 4)
+        .def(py::init<Shape<2>, float, size_t, int, bool>(),
+             py::arg("image_size"), py::arg("n_sigma") = 5.0f,
+             py::arg("max_clusters_per_frame") = 2048, py::arg("n_streams") = 4,
+             py::arg("time_kernels") = false)
 
         .def_property(
             "nSigma", &CF::get_nSigma, &CF::set_nSigma,
@@ -154,11 +228,77 @@ sqrt(max(sum2/n - mean^2, 0)). Counterpart to `noise` for the device pedestal.)"
             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.)")
+            slot so it can be reused by the next submit_batch() call.
+
+            One allocation and one copy per frame; see collect_view() for
+            neither.)")
+
+        .def(
+            "collect_view",
+            [](CF &self, typename CF::BatchToken token) {
+                return self.collect_view(token);
+            },
+            py::arg("token"), py::call_guard<py::gil_scoped_release>(),
+            R"(Like collect(), but copies nothing: returns a BatchView onto the
+            finder's pinned D2H buffer.
+
+            The slot stays reserved until the view is released, so with 2 slots
+            you must finish with it before submitting two more batches. Use it
+            as a context manager, or call release():
+
+                tok = cf.submit_batch(frames[a:b], first_frame=a)
+                with cf.collect_view(tok) as v:
+                    hist.fill(v.sums())      # reduced in C++, nothing copied
+
+            Anything you want to keep past release() must be copied out.)")
 
         .def("avg_kernel_time_ms", &CF::avg_kernel_time_ms,
-             R"(Average kernel execution time per frame in milliseconds,
-            excluding PCIe transfers.)")
+             R"(Average per-frame kernel time in ms, or NaN if the finder was
+            constructed with time_kernels=False (the default).
+
+            WARNING: only meaningful with n_streams=1. The CUDA events bracket
+            the kernel on its own stream, so under multi-stream contention the
+            interval includes time spent queued behind other streams' kernels
+            and over-reads by up to ~3.5x. Use Nsight Systems for exclusive
+            kernel times.)")
+
+        .def("kernel_timing_enabled", &CF::kernel_timing_enabled,
+             R"(True if per-frame kernel timing was enabled at construction.)")
+
+        .def("chunk_size_for", &CF::chunk_size_for, py::arg("n_frames"),
+             R"(The chunk size find_clusters_batched() would use for n_frames.
+             Use it to match its pipelining when driving submit_batch/
+             collect_view by hand.)")
+
+        .def("reserve_output_slots", &CF::reserve_output_slots,
+             py::arg("n_frames"), py::call_guard<py::gil_scoped_release>(),
+             R"(Pre-allocate both pinned output slots for batches of n_frames.
+
+            Processes nothing: no transfer, no kernel, and the pedestal is NOT
+            advanced. Only the two cudaMallocHost calls that the first
+            submit_batch() would make happen here.
+
+            Page-locking runs about 1.0 us per 4 kB page (~66 ms for two
+            128 MiB slots), and that cost is charged to whoever triggers it.
+            Call this before starting a timer so it does not land inside the
+            measurement. Slots only grow, so pass the largest batch you intend
+            to use:
+
+                cf.reserve_output_slots(cf.chunk_size_for(len(data)))
+            )")
+
+        .def_property(
+            "batch_chunk", &CF::get_batch_chunk, &CF::set_batch_chunk,
+            R"(Frames per internally pipelined chunk in find_clusters_batched().
+
+            0 (default) = auto: the batch is split into ~8 chunks so the host
+            marshals one chunk while the GPU runs the next. Rounded up to a
+            multiple of n_streams, which keeps the frame->stream assignment —
+            and therefore the per-stream device pedestal each frame sees —
+            identical to processing the batch in one go.
+
+            Set equal to the batch size to disable chunking and recover the old
+            submit-everything-then-copy-everything behaviour.)")
 
         .def("reset_timers", &CF::reset_timers,
              R"(Reset the internal kernel timing counters.)")
diff --git a/python/tests/ClusterFinderCUDA.ipynb b/python/tests/ClusterFinderCUDA.ipynb
index 3b904a5e..1522ba82 100644
--- a/python/tests/ClusterFinderCUDA.ipynb
+++ b/python/tests/ClusterFinderCUDA.ipynb
@@ -1,1065 +1,596 @@
-{
-    "cells": [
-        {
-            "cell_type": "code",
-            "execution_count": 1,
-            "id": "789d5aab-0c75-4ed3-94bf-e66172f6737c",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
-                "\n",
-                "from pathlib import Path\n",
-                "import matplotlib.pyplot as plt\n",
-                "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
-                "import numpy as np\n",
-                "import boost_histogram as bh\n",
-                "import time\n",
-                "\n",
-                "from aare import File, ClusterFinder, ClusterFinderFrozen, ClusterFinderMT, ClusterCollector, ClusterFinderCUDA, ClusterFinderCUDAGraph\n",
-                "\n",
-                "from helper import (print_pinning_budget, centers, only_sets, footprint_mask, shift_dist,\n",
-                "                    train_pedestal, scan_mismatches, plot_masked_mismatch)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "id": "3f6089d6-2245-4aca-aad3-2417c16afae2",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "N_BINS = 200\n",
-                "\n",
-                "def make_hist(clusters):\n",
-                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                "    h.fill(clusters.sum())\n",
-                "    return h\n",
-                "\n",
-                "def make_hist_from_batch(result_list):\n",
-                "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                "    energies = [np.asarray(cv.sum()).ravel() for cv in result_list if cv.size > 0]\n",
-                "    if energies:\n",
-                "        h.fill(np.concatenate(energies))\n",
-                "    return h"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 3,
-            "id": "415b09d4-d0d0-4166-8601-9d84302617bd",
-            "metadata": {},
-            "outputs": [
+    {
+        "cells":
+            [
                 {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "Image size:       (400, 400)\n",
-                        "Pedestal frames:  1000\n",
-                        "Data frames:      20000\n"
+                    "cell_type": "markdown",
+                    "id": "title",
+                    "metadata": {},
+                    "source": [
+                        "# ClusterFinder — CPU vs CUDA\n",
+                        "\n",
+                        "Two finders over the same frames and the same pedestal:\n",
+                        "\n",
+                        "| | |\n",
+                        "|---|---|\n",
+                        "| **`ClusterFinderMT`** + `ClusterCollector` | multithreaded CPU baseline |\n",
+                        "| **`ClusterFinderCUDA.find_clusters_batched`** | batched across CUDA streams, over a pinned input buffer, so H2D / kernel / D2H overlap |\n",
+                        "\n",
+                        "**Part 1** times them. **Part 2** compares what they found."
                     ]
-                }
-            ],
-            "source": [
-                "base = Path('/mnt/sls_det_storage/matterhorn_data/aare_test_data/')\n",
-                "f = File(base / 'Moench03new/cu_half_speed_master_4.json')\n",
-                "\n",
-                "n_frames_pd = 1000\n",
-                "N           = 20000 #88999\n",
-                "cluster_size = (3, 3)\n",
-                "rows = f.rows\n",
-                "cols = f.cols\n",
-                "image_size   = (rows, cols)\n",
-                "capacity     = 50_000 #3_000_000\n",
-                "BATCH_SIZE = 2000\n",
-                "\n",
-                "print(f'Image size:       {image_size}')\n",
-                "print(f'Pedestal frames:  {n_frames_pd}')\n",
-                "print(f'Data frames:      {N}')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 4,
-            "id": "0fbb5adb",
-            "metadata": {},
-            "outputs": [
+                },
                 {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "── System RAM ──────────────────────────────────────────\n",
-                        "  Total RAM           : 125.1 GiB\n",
-                        "  Currently available : 38.2 GiB  (free + reclaimable cache)\n",
-                        "  Reserved headroom   : 4.0 GiB  (OS + CUDA context)\n",
-                        "  Safe pinning budget : 34.2 GiB\n",
+                    "cell_type": "code",
+                    "execution_count": 1,
+                    "id": "imports",
+                    "metadata": {},
+                    "outputs": [],
+                    "source": [
+                        "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
                         "\n",
-                        "── Frame layout ────────────────────────────────────────\n",
-                        "  Frame size          : 400 × 400 × 2 B = 312.5 kB\n",
+                        "import time\n",
+                        "from pathlib import Path\n",
                         "\n",
-                        "── Pinning estimate ────────────────────────────────────\n",
-                        "  Max frames pinnable : 114,685  (34.2 GiB)\n",
+                        "import boost_histogram as bh\n",
+                        "import matplotlib.pyplot as plt\n",
+                        "import numpy as np\n",
+                        "from tqdm import tqdm\n",
                         "\n",
-                        "  Note: no swap on this machine — exceeding available RAM\n",
-                        "  will trigger the OOM killer. Stay within the budget.\n"
+                        "from aare import (File, ClusterFinderMT, ClusterCollector, ClusterFinderCUDA)"
                     ]
-                }
-            ],
-            "source": [
-                "print_pinning_budget(rows, cols)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 5,
-            "id": "3e49d862-45f4-4d37-a078-947e6b9ec9e3",
-            "metadata": {},
-            "outputs": [
+                },
                 {
-                    "data": {
-                        "text/plain": [
-                            "500000"
-                        ]
-                    },
+                    "cell_type": "markdown",
+                    "id": "md-config",
+                    "metadata": {},
+                    "source": [
+                        "## Configuration"
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 2,
+                    "id": "config",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "Image size:      (400, 400)   cluster (7, 7)\n",
+                                "Pedestal frames: 1000\n",
+                                "Data frames:     10000  of 100000 in file\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "base = Path('/mnt/sls_det_storage/moench_data/2603_MaxIVBeamtime/2026032408/process/xrf/')\n",
+                        "f = File(base / 'Cu_factor_10_data_master_0.json')\n",
+                        "pd = File(base / 'Cu_factor_10_pedestal_master_0.json')\n",
+                        "\n",
+                        "n_frames_pd  = 1000                  # pedestal frames, taken from the head of the file\n",
+                        "N            = 10000                 # data frames, read after those\n",
+                        "cluster_size = (7, 7)\n",
+                        "rows, cols   = f.rows, f.cols\n",
+                        "image_size   = (rows, cols)\n",
+                        "\n",
+                        "N_SIGMA    = 5\n",
+                        "N_STREAMS  = 4                       # H2D / kernel / D2H overlap\n",
+                        "BATCH_SIZE = 2000                    # frames per find_clusters_batched call\n",
+                        "\n",
+                        "# CPU workers. ClusterFinderMT gives each thread its own ClusterFinder with its\n",
+                        "# own pedestal, and data frames are handed out round-robin -- so at high thread\n",
+                        "# counts each pedestal tracks on only 1/n of the frames while the CUDA finder's\n",
+                        "# single pedestal sees all of them, and the cluster counts drift apart. Keep it\n",
+                        "# low when comparing counts; raise it to measure CPU throughput.\n",
+                        "N_THREADS = 4\n",
+                        "\n",
+                        "# Fixed per-frame output slot the kernel writes into, copied WHOLE on every D2H.\n",
+                        "# Too low does not error -- it TRUNCATES. The CUDA cell prints the peak actually\n",
+                        "# reached, which is how you size this for a new dataset.\n",
+                        "CAP = 3000\n",
+                        "\n",
+                        "capacity = 10_000                    # initial ClusterVector capacity, CPU side\n",
+                        "N_BINS   = 200\n",
+                        "E_MIN, E_MAX = -2, 4000              # spectrum range, ADU\n",
+                        "\n",
+                        "print(f'Image size:      {image_size}   cluster {cluster_size}')\n",
+                        "print(f'Pedestal frames: {n_frames_pd}')\n",
+                        "print(f'Data frames:     {N}  of {f.total_frames} in file')"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-build",
+                    "metadata": {},
+                    "source": [
+                        "## Build the two finders"
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 3,
+                    "id": "build",
+                    "metadata": {},
+                    "outputs": [],
+                    "source": [
+                        "cf_cpu = ClusterFinderMT(image_size, cluster_size, n_sigma=N_SIGMA,\n",
+                        "                         capacity=capacity, n_threads=N_THREADS)\n",
+                        "sink = ClusterCollector(cf_cpu)\n",
+                        "\n",
+                        "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
+                        "                            max_clusters_per_frame=CAP, n_streams=N_STREAMS)"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-ped",
+                    "metadata": {},
+                    "source": [
+                        "## Pedestal\n",
+                        "\n",
+                        "Identical frames into both, so the implementation is the only thing that differs."
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 4,
+                    "id": "train",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "Pedestal (1000 frames): 0.32s\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "f.seek(0)\n",
+                        "t0 = time.perf_counter()\n",
+                        "for _ in range(n_frames_pd):\n",
+                        "    pd_img = pd.read_frame()\n",
+                        "    cf_cpu.push_pedestal_frame(pd_img.copy())\n",
+                        "    cf_cuda.push_pedestal_frame(pd_img.copy())\n",
+                        "print(f'Pedestal ({n_frames_pd} frames): {time.perf_counter() - t0:.2f}s')"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-io",
+                    "metadata": {},
+                    "source": [
+                        "## Read the data frames\n",
+                        "\n",
+                        "Kept out of both timing loops: the two finders run over the same in-memory array."
+                    ]
+                },
+                {
+                    "cell_type": "code",
                     "execution_count": 5,
+                    "id": "io",
                     "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "f.total_frames"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "5531b79d-12ad-4de6-84b7-0224b10d13c3",
-            "metadata": {},
-            "source": [
-                "## Pedestal (both finders trained on identical frames)"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "e33b421f-969a-41d6-8aa6-5bd859a88fb3",
-            "metadata": {},
-            "source": [
-                "- Modify the boolean `SERIAL` to choose between the sequential CPU version (ClusterFinder) and its multi-threaded homologue (ClusterFinderMT)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 6,
-            "id": "6ee7c469-5a23-421a-9bb4-a76e8f57a0c1",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "SERIAL = True"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 7,
-            "id": "bc21879d-a795-43e3-8eed-0be0b4cfccd5",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "N_STREAMS = 1\n",
-                "N_SIGMA = 5"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 8,
-            "id": "9d8f69bf-27f6-48c8-b2da-4157d67e6b04",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "if(SERIAL):\n",
-                "    # cf_cpu  = ClusterFinder(image_size, cluster_size, capacity=capacity)\n",
-                "    cf_cpu  = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                "else:\n",
-                "    cf_cpu  = ClusterFinderMT(image_size, cluster_size, capacity=capacity, n_threads=48)\n",
-                "    sink = ClusterCollector(cf_cpu)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 9,
-            "id": "00e2f63a-5e64-4d3e-becf-5e2835c6d712",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Runs the destructor under the hood in case cf_cuda has already been constructed\n",
-                "# del cf_cuda\n",
-                "cf_cuda_v1 = None\n",
-                "cf_cuda = None\n",
-                "cf_async = None\n",
-                "cf_graph = None"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 10,
-            "id": "5d961cf4-e286-4c2c-a4e1-50cefc8d0b75",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_cuda_v1 = ClusterFinderCUDA(image_size, \n",
-                "                            cluster_size, \n",
-                "                            n_sigma=N_SIGMA, \n",
-                "                            max_clusters_per_frame=1500,\n",
-                "                            n_streams=N_STREAMS) "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 11,
-            "id": "cbdcb805-708b-4205-bda9-2aa163d0e81f",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_cuda = ClusterFinderCUDA(image_size, \n",
-                "                            cluster_size, \n",
-                "                            n_sigma=N_SIGMA, \n",
-                "                            max_clusters_per_frame=1500,\n",
-                "                            n_streams=N_STREAMS) "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 12,
-            "id": "f70d0805-a1e9-488b-8ec7-487900f7e026",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_async = ClusterFinderCUDA(image_size,\n",
-                "                             cluster_size,\n",
-                "                             n_sigma=N_SIGMA,\n",
-                "                             max_clusters_per_frame=1500,\n",
-                "                             n_streams=N_STREAMS)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 13,
-            "id": "09c3ec73",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_graph = ClusterFinderCUDAGraph(image_size,\n",
-                "                                  cluster_size,\n",
-                "                                  n_sigma=N_SIGMA,\n",
-                "                                  max_clusters_per_frame=1500,\n",
-                "                                  n_streams=N_STREAMS)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 14,
-            "id": "1546f405-1bf6-4073-ab35-8134be695a6c",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "Pedestal (1000 frames): 1.030s\n"
-                    ]
-                }
-            ],
-            "source": [
-                "t0 = time.perf_counter()\n",
-                "for _ in range(n_frames_pd):\n",
-                "    img = f.read_frame()\n",
-                "    cf_cpu.push_pedestal_frame(img.copy())\n",
-                "    cf_cuda_v1.push_pedestal_frame(img.copy())\n",
-                "    cf_cuda.push_pedestal_frame(img.copy())\n",
-                "    cf_async.push_pedestal_frame(img.copy())\n",
-                "    cf_graph.push_pedestal_frame(img.copy())\n",
-                "print(f'Pedestal ({n_frames_pd} frames): {time.perf_counter() - t0:.3f}s')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "5df035f0-7a27-4d5a-8f8d-c94e745bcd1a",
-            "metadata": {},
-            "source": [
-                "## Read all data frames into memory (I/O out of the timing loop)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 15,
-            "id": "4573be3d-5ba8-4e18-bab0-c874f2b7dcb2",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "Reading 20000 frames:        2.424s  (8252 FPS, 2518.340 GB/s)\n"
-                    ]
-                }
-            ],
-            "source": [
-                "f.seek(n_frames_pd)\n",
-                "t0 = time.perf_counter()\n",
-                "data = f.read_n(N)\n",
-                "t_io = time.perf_counter() - t0\n",
-                "print(f'Reading {N} frames:        {t_io:.3f}s  ({N/t_io:.0f} FPS, '\n",
-                "      f'{f.bytes_per_frame * N / 1024**2 / t_io:.3f} GB/s)')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "c1e9362e-dcc2-41af-bfa1-c62d0968477e",
-            "metadata": {},
-            "source": [
-                "## CPU clustering"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 16,
-            "id": "ad47af54-c2ba-441a-a874-88dfe04d8a68",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from tqdm import tqdm"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 17,
-            "id": "fbb14fda-2852-4b73-ba2c-9952abac1d99",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stderr",
-                    "output_type": "stream",
-                    "text": [
-                        "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:49<00:00, 400.34it/s]\n"
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "Reading 10000 frames: 0.44s  (22,750 FPS, 3.20 GB at 7.28 GB/s)\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "f.seek(0)\n",
+                        "t0 = time.perf_counter()\n",
+                        "data = f.read_n(N)\n",
+                        "t_io = time.perf_counter() - t0\n",
+                        "gb = f.bytes_per_frame * N / 1e9\n",
+                        "print(f'Reading {N} frames: {t_io:.2f}s  ({N / t_io:,.0f} FPS, '\n",
+                        "      f'{gb:.2f} GB at {gb / t_io:.2f} GB/s)')"
                     ]
                 },
                 {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CPU clustering:          49.960s (400 FPS, 27665227 clusters, 1383.26/frame)\n"
-                    ]
-                }
-            ],
-            "source": [
-                "t0 = time.perf_counter()\n",
-                "for frame in tqdm(data):\n",
-                "    cf_cpu.find_clusters(frame)\n",
-                "t_cpu = time.perf_counter() - t0\n",
-                "\n",
-                "if(SERIAL):\n",
-                "    clusters_cpu = cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
-                "    n_clusters_cpu = clusters_cpu.size\n",
-                "    \n",
-                "    hist_cpu  = make_hist(clusters_cpu)\n",
-                "else:\n",
-                "    cf_cpu.stop()\n",
-                "    sink.stop()\n",
-                "    \n",
-                "    clusters_cpu = sink.steal_clusters() #cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
-                "    \n",
-                "    hist_cpu = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                "    n_clusters_cpu = 0\n",
-                "    for cv in clusters_cpu:\n",
-                "        hist_cpu.fill(cv.sum())\n",
-                "        n_clusters_cpu += cv.size\n",
-                "        \n",
-                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
-                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "8cfd7091-8020-49ff-b033-28bf773983d8",
-            "metadata": {},
-            "source": [
-                "## CUDA clustering\n",
-                "Non-batched: 1 stream + pageable memory (i.e. no pinning)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 18,
-            "id": "4f94cf35-5796-463d-bed8-f44a02d91fc6",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# Simplest: (non-batched) per-frame run on non-pinned data\n",
-                "cf_cuda_v1.reset_timers()\n",
-                "t0 = time.perf_counter()\n",
-                "\n",
-                "n_clusters_cuda_v1 = 0\n",
-                "hist_cuda_v1 = None\n",
-                "\n",
-                "# steal the clusters as we go rather than at the end of the  dataset \n",
-                "# which might trigger an std::bad_alloc...\n",
-                "for idx, frame in enumerate(data):\n",
-                "    cf_cuda_v1.find_clusters(frame)\n",
-                "    clusters_frame = cf_cuda_v1.steal_clusters(realloc_same_capacity=True)\n",
-                "\n",
-                "    n_clusters_cuda_v1 += clusters_frame.size\n",
-                "\n",
-                "    h = make_hist(clusters_frame)\n",
-                "    hist_cuda_v1 = h if hist_cuda_v1 is None else hist_cuda_v1 + h\n",
-                "    \n",
-                "t_cuda_v1 = time.perf_counter() - t0\n",
-                "kernel_ms = cf_cuda_v1.avg_kernel_time_ms()"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 19,
-            "id": "e2ad507c-0d8d-4748-8b32-2a8647dee605",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CUDA clustering:          2.227s  (8982 FPS, 27665079 clusters, 1383.25/frame)\n",
-                        "  Kernel only:            0.032 ms/frame\n",
-                        "  PCIe + overhead:        0.079 ms/frame\n",
-                        "Speedup (CPU / CUDA):     22.44×\n"
-                    ]
-                }
-            ],
-            "source": [
-                "print(f'CUDA clustering:          {t_cuda_v1:.3f}s  ({N/t_cuda_v1:.0f} FPS, '\n",
-                "      f'{n_clusters_cuda_v1} clusters, {n_clusters_cuda_v1/N:.2f}/frame)')\n",
-                "print(f'  Kernel only:            {kernel_ms:.3f} ms/frame')\n",
-                "print(f'  PCIe + overhead:        {t_cuda_v1*1000/N - kernel_ms:.3f} ms/frame')\n",
-                "print(f'Speedup (CPU / CUDA):     {t_cpu / t_cuda_v1:.2f}×')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "a3410e04-1a02-43c3-8d85-e6de9c9df103",
-            "metadata": {},
-            "source": [
-                "## CUDA clustering (batched + multi-streamed + pinned dataset)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 20,
-            "id": "18649d77-5269-4155-8e3a-fcd7107ee22b",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# TEST\n",
-                "# Before warmup, pin the whole dataset (no additional copies, just pinning the buffer)\n",
-                "cf_cuda.register_input_buffer(data)\n",
-                "\n",
-                "clusters_cuda_per_frame = []\n",
-                "\n",
-                "cf_cuda.reset_timers()\n",
-                "t0 = time.perf_counter()\n",
-                "for start in range(0, N, BATCH_SIZE):\n",
-                "    stop = min(start + BATCH_SIZE, N)\n",
-                "    clusters_cuda_per_frame.extend(\n",
-                "        cf_cuda.find_clusters_batched(data[start:stop], first_frame=start)\n",
-                "    )\n",
-                "t_cuda = time.perf_counter() - t0\n",
-                "\n",
-                "cf_cuda.unregister_input_buffer()  # release when done with this dataset\n",
-                "\n",
-                "kernel_ms = cf_cuda.avg_kernel_time_ms()\n",
-                "\n",
-                "n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n",
-                "\n",
-                "hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 21,
-            "id": "502d0d3b-6b1e-4cc9-91df-9d998bd849b5",
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/plain": [
-                            "(3, 3)"
-                        ]
-                    },
-                    "execution_count": 21,
+                    "cell_type": "markdown",
+                    "id": "md-cpu",
                     "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "cluster_size"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 22,
-            "id": "2e3e4b9c-7f23-4fb7-bc3e-fa3d766d51fc",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CPU clustering:          49.960s (400 FPS, 27665227 clusters, 1383.26/frame)\n"
-                    ]
-                }
-            ],
-            "source": [
-                "print(f'CPU clustering:          {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
-                "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 23,
-            "id": "4b8df93b-9a1b-41a5-9fed-9cda295fb523",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CUDA clustering:          1.541s  (12975 FPS, 27665079 clusters, 1383.25/frame)\n",
-                        "  Kernel only:            0.029 ms/frame\n",
-                        "  PCIe + overhead:        0.048 ms/frame\n",
-                        "Speedup (CPU / CUDA):     32.41×\n"
-                    ]
-                }
-            ],
-            "source": [
-                "print(f'CUDA clustering:          {t_cuda:.3f}s  ({N/t_cuda:.0f} FPS, '\n",
-                "      f'{n_clusters_cuda} clusters, {n_clusters_cuda/N:.2f}/frame)')\n",
-                "print(f'  Kernel only:            {kernel_ms:.3f} ms/frame')\n",
-                "print(f'  PCIe + overhead:        {t_cuda*1000/N - kernel_ms:.3f} ms/frame')\n",
-                "print(f'Speedup (CPU / CUDA):     {t_cpu / t_cuda:.2f}×')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "5d6d6da8",
-            "metadata": {},
-            "source": [
-                "## CUDA Graph clustering (pinned dataset)\n",
-                "Pre-records the H2D→kernel→D2H pipeline as a CUDA Graph per stream, reducing per-frame CPU API call overhead (~21 µs vs ~60 µs for the single-frame/unpinned-buffer streamed version)."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 24,
-            "id": "bda3d609",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_graph.register_input_buffer(data)\n",
-                "\n",
-                "clusters_graph_per_frame = []\n",
-                "\n",
-                "t0 = time.perf_counter()\n",
-                "for start in range(0, N, BATCH_SIZE):\n",
-                "    stop = min(start + BATCH_SIZE, N)\n",
-                "    clusters_graph_per_frame.extend(\n",
-                "        cf_graph.find_clusters_batched(data[start:stop], first_frame=start)\n",
-                "    )\n",
-                "t_graph = time.perf_counter() - t0\n",
-                "\n",
-                "cf_graph.unregister_input_buffer()\n",
-                "\n",
-                "n_clusters_graph = sum(cv.size for cv in clusters_graph_per_frame)\n",
-                "hist_graph = make_hist_from_batch(clusters_graph_per_frame)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 25,
-            "id": "e6d28031",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CUDA Graph (pinned):         1.384s  (14446 FPS, 27665079 clusters, 1383.25/frame)\n",
-                        "  Kernel + PCIe + overhead:  0.069 ms/frame  (kernel not individually timed)\n",
-                        "Speedup CUDA graph (vs Streamed/batched) :      1.11×\n",
-                        "Speedup (CPU / CUDA Graph):  36.09×\n"
-                    ]
-                }
-            ],
-            "source": [
-                "print(f'CUDA Graph (pinned):         {t_graph:.3f}s  ({N/t_graph:.0f} FPS, '\n",
-                "      f'{n_clusters_graph} clusters, {n_clusters_graph/N:.2f}/frame)')\n",
-                "print(f'  Kernel + PCIe + overhead:  {t_graph*1000/N:.3f} ms/frame  (kernel not individually timed)')\n",
-                "print(f'Speedup CUDA graph (vs Streamed/batched) :      {t_cuda / t_graph:.2f}×')\n",
-                "print(f'Speedup (CPU / CUDA Graph):  {t_cpu / t_graph:.2f}×')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "561e372d-97dd-4ed9-b66a-b8a1a5888b97",
-            "metadata": {},
-            "source": [
-                "## CUDA Clustering (async pipeline)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 26,
-            "id": "ab26ae22-53bd-4f68-a148-8457ae9b9c03",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "CUDA(async pipeline):    1.673s  (11957 FPS, 27665079 clusters, 1383.25/frame)\n",
-                        "  Kernel only:           0.029 ms/frame\n",
-                        "  PCIe + overhead:       0.055 ms/frame\n",
-                        "Speedup Async (vs Graph):      0.83×\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",
-                "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 Async (vs Graph):      {t_graph / t_async:.2f}×')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "b966cce1-0f73-4565-a707-1aec2a69f75e",
-            "metadata": {},
-            "source": [
-                "## Agreement check: \n",
-                "- Cluster counts should match closely.\n",
-                "- However, as the CUDA CF updates the pedestal once per frame rather than per-pixel, a small divergence after the first few frames is expected."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 27,
-            "id": "d3a850df-7df0-485b-971d-381cfdc6be81",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "Cluster count diff:       148 (0.00%)\n"
-                    ]
-                }
-            ],
-            "source": [
-                "diff = abs(n_clusters_cpu - n_clusters_cuda)\n",
-                "rel  = diff / max(n_clusters_cpu, 1)\n",
-                "print(f'Cluster count diff:       {diff} ({rel:.2%})')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "81638ad3-6112-4bd7-a93a-f4d97f1f94cf",
-            "metadata": {},
-            "source": [
-                "## Plots"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 28,
-            "id": "aff8db7e-8332-4228-857f-a9875cf940d3",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "200 201\n",
-                        "200 201\n"
-                    ]
-                }
-            ],
-            "source": [
-                "print(len(hist_cpu.values()), len(hist_cpu.axes[0].edges))\n",
-                "print(len(hist_cuda.values()), len(hist_cuda.axes[0].edges))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 29,
-            "id": "9adeea2f-9309-4c0a-905b-7d1203ba1f4e",
-            "metadata": {
-                "scrolled": true
-            },
-            "outputs": [
-                {
-                    "data": {
-                        "image/png":
-                            "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",
-                        "text/plain": [
-                            "<Figure size 800x600 with 2 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
-                "    2, 1, figsize=(8, 6), sharex=True,\n",
-                "    gridspec_kw={'height_ratios': [3, 1]}\n",
-                ")\n",
-                "\n",
-                "edges = hist_cpu.axes[0].edges\n",
-                "cpu_vals   = hist_cpu.values()\n",
-                "cuda_vals  = hist_cuda.values()\n",
-                "async_vals = hist_async.values()\n",
-                "graph_vals = hist_graph.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 stream ({n_clusters_cuda} clusters)',  linestyle='--')\n",
-                "ax_spec.stairs(async_vals, edges, label=f'CUDA async  ({n_clusters_async} clusters)', linestyle='-.')\n",
-                "ax_spec.stairs(graph_vals, edges, label=f'CUDA graph  ({n_clusters_graph} clusters)', linestyle=':')\n",
-                "ax_spec.set_ylabel('Counts')\n",
-                "ax_spec.set_title('Cluster energy spectrum: CPU vs CUDA variants')\n",
-                "ax_spec.legend()\n",
-                "ax_spec.grid(alpha=0.2)\n",
-                "\n",
-                "with np.errstate(divide='ignore', invalid='ignore'):\n",
-                "    ratio_cuda  = np.where(cpu_vals > 0, cuda_vals  / cpu_vals, np.nan)\n",
-                "    ratio_graph = np.where(cpu_vals > 0, graph_vals / cpu_vals, np.nan)\n",
-                "\n",
-                "ax_ratio.stairs(ratio_cuda,  edges, label='CUDA stream / CPU', color='C1', linestyle='--')\n",
-                "ax_ratio.stairs(ratio_graph, edges, label='CUDA graph / CPU',  color='C3', linestyle=':')\n",
-                "ax_ratio.axhline(1.0, color='gray', linewidth=0.5)\n",
-                "ax_ratio.set_ylabel('Variant / CPU')\n",
-                "ax_ratio.set_xlabel('Energy [ADU]')\n",
-                "ax_ratio.set_ylim(0.5, 2.0)\n",
-                "ax_ratio.legend(fontsize=8)\n",
-                "ax_ratio.grid(alpha=0.3)\n",
-                "\n",
-                "plt.tight_layout()\n",
-                "plt.show()"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 30,
-            "id": "ea19690e",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "sx, sy = cluster_size              # cluster footprint, e.g. (7, 7)\n",
-                "rx, ry = sx // 2, sy // 2\n",
-                "N_SIGMA_VIS = N_SIGMA              # back-compat alias used by the analysis cells"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 31,
-            "id": "c66373cb-4a10-4898-b488-326ffd025d77",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_cuda_m = None\n",
-                "cf_cpu_m = None\n",
-                "show = None\n",
-                "totals = None"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 32,
-            "id": "7d8f734e-2f77-4d68-ac7b-01842c540a44",
-            "metadata": {
-                "scrolled": true
-            },
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "total CPU-only=148, CUDA-only=0; showing 8 frames with the most mismatches\n"
+                    "source": [
+                        "## 1 — CPU, multithreaded"
                     ]
                 },
                 {
-                    "data": {
-                        "image/png":
-                            "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",
-                        "text/plain": [
-                            "<Figure size 1100x4240 with 16 Axes>"
-                        ]
-                    },
+                    "cell_type": "code",
+                    "execution_count": 6,
+                    "id": "cpu",
                     "metadata": {},
-                    "output_type": "display_data"
+                    "outputs": [
+                        {
+                            "name": "stderr",
+                            "output_type": "stream",
+                            "text": [
+                                "100%|██████████████████████████████████████████| 10000/10000 [00:16<00:00, 615.07it/s]\n"
+                            ]
+                        },
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "CPU MT (4 threads): 16.26s   615 FPS   17,463,321 clusters (1746.3/frame)\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "t0 = time.perf_counter()\n",
+                        "# Pass the frame number: find_clusters(frame) defaults it to 0, and every\n",
+                        "# resulting cluster is then stamped frame 0. Part 2 groups by it.\n",
+                        "for i, frame in enumerate(tqdm(data)):\n",
+                        "    cf_cpu.find_clusters(frame, i)\n",
+                        "t_cpu = time.perf_counter() - t0\n",
+                        "\n",
+                        "cf_cpu.stop(); sink.stop()\n",
+                        "clusters_cpu = sink.steal_clusters()\n",
+                        "\n",
+                        "hist_cpu = bh.Histogram(bh.axis.Regular(N_BINS, E_MIN, E_MAX))\n",
+                        "n_clusters_cpu = 0\n",
+                        "for cv in clusters_cpu:\n",
+                        "    hist_cpu.fill(cv.sum())\n",
+                        "    n_clusters_cpu += cv.size\n",
+                        "\n",
+                        "print(f'CPU MT ({N_THREADS} threads): {t_cpu:.2f}s   {N / t_cpu:,.0f} FPS   '\n",
+                        "      f'{n_clusters_cpu:,} clusters ({n_clusters_cpu / N:.1f}/frame)')"
+                    ]
                 },
                 {
-                    "data": {
-                        "image/png":
-                            "iVBORw0KGgoAAAANSUhEUgAABEEAABCGCAYAAABVHQgFAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QV4U1cbB/B/krpSrEihQHF3dxlsyHAYMtxl+IDh7m6D4bIN94/B8MFwGO5QipRSd4l8zzklpaUCbQqV/H/PE0hu7rk596bJffPeIwqdTqcDEREREREREVE6p0zpChARERERERERfQ1MghARERERERGRUWAShIiIiIiIiIiMApMgRERERERERGQUmAQhIiIiIiIiIqPAJAgRERERERERGQUmQYiIiIiIiIjIKDAJQkRERERERERGgUkQIiIiIiIiIjIKTIJQuqPT6dC7d29kzJgRCoUCN27cSOkqEX1R4u987969PMpERJ+BcQJR/GrXro0hQ4bwEFG6xiQIpTtHjhzBhg0bcPDgQbx58wbFixdHWjnpiB+z0W/t27ePsc61a9fQoEEDZMiQAZkyZZLJnsDAwBjrvHjxAk2bNoW1tTUyZ86MwYMHIzw8POr558+fx3odcRPH7Wu5fv062rRpA0dHR1hYWKBgwYLo1asXHj58GGcdHRwcULNmTZw+ffqTJ2mRDBBlEkP8nXTo0AGFChWCUqmMc7vibyqu4xYaGhq1zsyZM1GhQgXY2toia9asaN68OR48eBAr+J40aRJy5MgBS0tLuR937txBanHq1Cm5X76+vildFSKiL4JxQtqPExI6V5UuXVqeZ/Xy5MkTtQ/ivCset23bFidOnIjztUNCQmTcIS6miftJ8dNPP6FcuXIwNzeX9fnY5x5jEfeI7YhjkC9fPqxatSrWtnbt2oWiRYvK1xL/79mzB6kJL9RQasQkCKU7T548Qfbs2VG1alVky5YNJiYmsdaJfrJPTcQJXvwg199+/fXXqOdev36N+vXrI3/+/Lh48aI8UYofz127do1aR6PRoHHjxggKCsI///yDP/74Q54chw8fHuu1/v777xivVbdu3a+yjyI5VblyZYSFhWHr1q24d+8eNm/eDHt7e4wfPz7OOoogwM7ODt999x2ePXuW7HUSdcmSJQt++eUXlCpVKt71RB2iHzNxE4GJnqjngAEDcOHCBRw7dgxqtRrffPONfD/05syZgwULFmDZsmW4fPmy/BsVia2AgACkJyLZI/afiCi1YZyQfuKEzzVlyhS5D+LCxKZNm+TFJBFTTZ8+Pda64niIC2giobB79+4knwO7d++Odu3aJbheQsdYxDsi7qlRo4ZMCo0dO1YmrET99P7991/5Gp07d8Z///0n/xcJHhEnpjcREREpXQVKT3RE6UiXLl104s9af3N2dpbLa9WqpRswYIBu6NChukyZMulq1qwpl8+fP19XvHhxnZWVlc7JyUnXr18/XUBAQNT21q9fr7O3t9cdOHBAV7BgQZ2lpaWuVatWusDAQN2GDRvk9jNkyKAbOHCgTq1WR5ULCwvTjRw5UpcjRw657YoVK+pOnjyZYN1FHX/66ad4n//11191WbNm1Wk0mqhl169fl/v56NEj+fjw4cM6pVKpe/XqVdQ6v//+u87c3Fzn5+cnHz979kyWEWW/tqCgIF3mzJl1zZs3j/N5Hx+feOv48uVLuWzVqlUJHq89e/bI9ZIqvu3q/xYSw8PDQ9bl9OnT8rFWq9Vly5ZNN2vWrKh1QkND5Xb1+xWftWvX6ooWLaozMzOT2xB/z3riNcR+C+LvTDzWH8vofyfiuArPnz/XNWnSRP7tir9Psd1Dhw5FHffoN/GZ0td99uzZurx58+osLCx0JUuW1O3YsSPqNfSve+TIEV25cuV0pqamuhMnTuhu3Lihq127ts7GxkZna2urK1u2rO7y5cuJOo5ERMmFcUL6iBPiOtfplSpVSjdx4sSoxyJWW7hwYaz1JkyYII/F/fv3YywX5yxxTl65cqWuTp06Bu2PqIeoz8c+5xiPGjVKV7hw4RjL+vTpo6tcuXLU47Zt2+oaNWoUY52GDRvq2rdvn2C9/vnnHxkLi7hWxALffPONztvbO844KHqMoSfiFhEX6WNeEZOI2ET8HYnjPWPGDPmcuB9XXC7s379fxgSijIgtJk2apIuIiIjxuuI9aNasmYxVxPsl6tihQwf5NyJikfz58+vWrVuX4L4SxYUtQShdWbx4scz2Ozk5yYy6uNKut3HjRtkq5Ny5c1EtLETXhyVLluD27dvyedE0ctSoUTG2GRwcLNcRV0tE6wvRBLNly5Y4fPiwvImrE6tXr8bOnTujynTr1k2+jihz8+ZN2aSzUaNGePToUYL1F1c8RNPUYsWKYcSIETFaB4grImZmZrLOeqJZpyCu5uivCIirF6KrhV7Dhg1l2atXr8Z4rWbNmskuG9WqVYtR9y/pr7/+gqenZ6xjrCeuzMTHysoqSVcC9E1OxftmKNH1yNnZWf59NWnSRF6ZSYifn5/8XzSp1V/VcXd3l61D9ETz1Vq1auH8+fPxbmflypWyhYno/nTr1i3s379ftghKKrEt8Tdx5swZub3Zs2fDxsYGuXLlirrCJK6Wic+Q+EwJ48aNw/r162VdRAukoUOHolOnTjG6KAnivRXdgsSVu5IlS6Jjx47yeInPovgbHD16NExNTZNcdyIiQzBOSL9xQlK6rIjf2vv27YvRSkjEUqI1hbiJc/PTp09jlBPdaaJ3tzFEQsdY1CN6vKB/r65cuRIVC8W3TkIxhRgrr169ejLWFOVFDCm6R4nWxEkhYmQRl2zfvl3GDlu2bJHHSNDH4SJ+iB6Xi/dZxBCiZcvdu3dlXC66HX/cMmfixIn4/vvvZawiWtaIlkBi/f/9738yzhAxiYibiRIrdj8BojRMNJUU4zGoVCrZzSA68aNRdEWILvrYD3nz5sXUqVPRr18/rFixImq5ONGIL1kXFxf5uHXr1jLx8fbtW/nDUTSXrFOnDk6ePCmbJIoT6O+//46XL19GBRkioSESKOIkMGPGjDjrLn4sijqIeoukzJgxY2TTRtGtQhBNJIcNG4a5c+fKE7doyiqaRgrixCKIH9ii/2x0ol+rSJ6I5wRRZ9EdQ5xwRUJFnLhEvUUSSJyQviR9Eqhw4cKJKif2VRwP8b6KhEFiiB/cYqwPfRIlqUSdxQm6RIkS8Pf3l4G0OIbiPSpQoECs9UVgJd6v6tWrR41Lo38PPn6PxGNXV9d4X3vatGmyqbJ43/XE2CNJJcaNadWqldwXQfQz1tMnbERQpg82xfEXfzMiSVilSpWoMiJwEoFL9PdEJCFF957orzVy5Mio9zyuY0VE9LUwTkifcUJSiPOdONeJiyV669atw7fffiuPiSAuYIll4jysJ+JBQ394f84xjiumE49FV1ORKBJdv+NbR/9exkXEwuXLl48R64qESFKJ87w4t4t4R1x0EheL9ERXY0HEE9HjcpHsEBdFunTpEhVTiBhcJL9E4kNPjNcmkh/RX6tMmTKy/oI+2UKUWEyCkNHQf2FGJxIXIikhssrih604sYiBLsWPPjFgmCB+POsTIPqTi/jSFSew6Ms8PDyiBi8VP4DFIF7RiassYjDThMYD0RM/msUJRdRZbK9s2bLyBCVOjuKHtT4hIDLo4rXFfb24BgUV9dEvFyducRU/+nHx8fGRJ8X4ghsREJw9exafS/RfFVn6uOqRGGJcFxEciNY44mSvT0IkRs6cOXH//n0YSvRPFjc9EbiI92Xp0qXyKsjHBg4cKFsB6VvpRPfxexT9/fmY+LsS48GIqzbJRfzdiGTf0aNHZZ9okRARrTbiIz4f4nMRPbmhH1tHBCMJfc7E32vPnj1l4lC8lmgVFf3zRESUWjBOSHtxgqGin39FSwgRZ+lbQApif8WxmDx5clSsdfz4cYNf93OPcVzxwsfLExNT6FuCiHNxchFj04n4QFxwEkkj0VL249YpHxOtjkSrkOgtP8TxF7GGiPn0F64+/kyK2EXELCI2Fq8hBqAXsSJRYjEJQkZDn9TQE1fexYBTffv2ldlncUVA/GDt0aNHjC4XHzfdFyeWuJZptVp5X/wvTpTiCz56ckKInjj5FPEDW7yOuCoi7usz4uImWqGI/RGvK64kiBYkgsiyfzwYljipiv35+EpBdOLH/W+//Rbv8+K5xIyQru+m8zF9YkgkJfQtChLy559/ypY2+tlwPh6kVN/dJDoxUrx47ksTyRnRGiOuLk6DBg2SV3VEdxPRFURPfxVEXKERSZ3oiY743p/4jmVC9fo4kPy4C5FISojmsocOHZKJENF9Zf78+bLecdH/bYv1RVIpOtGdJ6HPmWgyLP5mRVkR8IorPKKbWIsWLRK1X0REXxrjhLQTJ+jP8yIO+LiLjIgDRIufT/Hy8sK7d++iYijRRePVq1exBjMVP87FuVIker6kj4+xiBk+btEh4gXRtVsfE8W3TkIxX2LjChFrfpycih5XiBhVdPcV53gx0KvoRiQueiTUhUrEFSKxJLqXfyz6gPMffybFeyDidxFTiNcSF4hEF9958+Ylap+ImAQhoyX6VIqWH+LHn/6Ho+jPaChxZVycMMVJSFzpSCox7oI4yUT/saynP7mJJpriZKG/Qi8CBpFVF91j9OXEiVv8UBVTrMVHjG0R1+voffzDN6lE1l5c/RBXOuKawk0ELtGDGTFGRXytBkRT2biuIokrC+JqxJcmAgJxNSV6yxSxTCQSxL6JMUj0gZWevruT6OKkb0EhWlOIcTXEuBxxEd27RMsjceVJdLv6FH3TU/E3oG/OK+r5MXFsRQJQ3ETLojVr1si6iybRQvS+wfqp90Qz1MR2R9IHteImrnr98MMPslsYkyBElNoxTki9cYJoLStiN3HOj979Qpz7RCLjc+IA0eJDbEO0JhDWrl2L9u3by5niops1a5Z87ksnQT4+xiKmO3DgQIx1REwnWkfoL8aJdURMEb1ViVgnodYRouWniClEEuJziLhC3+1aEBd/RGuNj5NSInkkbqLbuGgR4u3tLS8wirp+PN6ISJyI8UOSMr6ZqI9ofSJuIs4WXW6ZBKHEYhKEjJb4cS2SIKI7gxgQSgxkGtf864klfuyJ8T1+/PFHmWARP3ZF300xnoL4wSxan3xMjCMiBkUVz4mTv+h+IMaAEGVFtws9Ma2qOLGJFiXipCe++MXJWZ84EMGD+MEqpkgTY4eIE5AYj0R0tdFfNRFNPcUJSWxbnPzFCVZ054jvR3hyEhl9cZVDNMMUg4GJbhniBCiOj0hAiR/ZopXA5+jfv788HvoBQ8WVDXFMRKAiul7oiWBIXCkQU+JVrFgx3u3pEwVi8FNxZUg8FgkBcTwFESyIqzQi8BJdp8QxE+ssX748ahuiLtu2bZODrInkhf7qjLgiJeonrqaIcWhEFyyxHXET90WzT9FaIj6iNYVIVoi+yyIIEwPmir/XuFpuiOMpEhyijOjDLIIV8XcYnaiD2I74WxUthcTfZpEiReRzIpgU9RRTFIq/R1FvsS/i70gEWeLqjej3K46BGHhN/C3q+/R+TFwVFH+jIiASCSAxTo4IWEVTViKi1I5xQuqNE8R5qU+fPjJWEi0jxPT2ouuoSGCI89nH3THEeVOck8XFJdFqQQzeKV5HtIQU2xfnfbGfohWnfhwvPXGOa9y4sVxH/AAXMYVI5Itur/F5/PixjCfEa4pzoT7GEDGFiC0+JxYT530R54hupSKOE4OYihhHjDunJ8YKq1mzpiwnBhAV8YdoIRFXV1w9ceFDxKMijhKvIeojuoeLYx7XWCdiTDpRDxEDiRjg559/jtEieuHChTJ5U7p0abkvO3bskBd89LGp/kKOiGfFBRVxgWbChAmy24yIV8TrinKiC7EYADX6+CsfE+XERT3RRVx0Mxexij5+IUqUOOeMIUrDxDRo0afgSmja0wULFuiyZ88upwgTU4pt2rQpxpRrcU2LGtd0Z2LKve+//z7qcXh4uJzKK0+ePHKqUDFtWIsWLXQ3b96Ms84vXryQU5VlzJhRToHq4uKiGzx4sM7LyyvGep07d45aR0xRKur7MVdXV13jxo3lPol1xfS9YhpWPTG1b5EiReR0Y2LKUjGd6ebNm3Vfk5gitWXLlrosWbLIqdHEFGe9e/eOmur3c6fnu3LlinzfxNTBdnZ2uvLly8up/qLTb+tTUxR/PDXsx1O5DRkyRJc7d2557EW9xXRy58+f/+Q2xE0/jZx+qlnxN6SfSk6877du3frkMRPT9RUqVEj+PYm/2UGDBsU7fZ2Y+q5EiRJy+rgaNWrIqWyjT5Er/ibE35h4fbEv4u/K09MzqvyUKVNk/RQKRYwpchcvXhxVB1FOHHv99L9xTVcops0T0/TlypVLHjcxZbR47ZCQkE/uLxHRl8I4Ie3HCYKoszhfibqKfRHn7K5du+revHkTY1vRp2kV5yJxLhdTy4pp3PXmzZsnp4oV8dvHxLSt4jjNnz8/anvRp+CNi4g744oH9Ofhzz3Gp06d0pUpU0bWW8SUYsrYj4lzvP7cLKbU3bVr1yePr9hu1apV5bEV+y3O5/rz98cxs5hOWcQ81tbWugIFCugOHz4cY4rc1atX60qXLi2fF7FYvXr1dNeuXYsxFa54/0xMTGLEVUeOHJF1EO+dKFexYkW5rYSm5p06dWrU+y3eExF7P3369JP7S/QxhfgncWkTIiIiIiIiIqK0J3IgBCIiIiIiIiKidI5JECIiIiIiIiIyCkyCEBEREREREZFRYBKEiIiIiIiIiIwCkyBEREREREREZBSYBCEiIiIiIiIio2CCdEKr1eL169ewtbWFQqFI6eoQERFRAnQ6HQICApAjRw4olSl3TYbxAxERkXHFD+kmCSISILly5UrpahAREVEiuLm5wcnJKcWOGeMHIiIi44of0k0SRLQA0R8MOzu7lK4OERHFoYVTf4OPi9LKyqDy6rceBtdhn98mg7dh7Pz9/eXFC/35O6UwfiAiSv0YP1Byxg/pJgmi7wIjEiBMghARpU4mCjODt6FUGrgNhanBdeB5JvmkdBdWxg9ERKkf4wdKzviBA6MSERERERERkVFINy1BiIgo7XHMnQlLTk6A671X8vGMbqswdn1fed/c0gwmZioMqDE5VjlLa3PM+HMQnAtlx9Am8+D64A1qNiuL5j3rICw0HPOHbIbna1+UqlYQXUc3hVqtwaY5h3Dr30dxXkkYsa4/sudzlINtzeu+Am+evsWItf1RqUk5bJmyA/uWH/kKR4OIiIi+VOwgMH4ggUkQIiJKUbfOPcC0H1dEPR7VZI78v27bysieN2ucZcJCIzDpx1XoMb65fKwyUaJF77oY2WIhCpZ2Roch32LJqN9lAmRcxxVQR2gwdUs/jGq1ONa2XErngam5KYbVmoCy9Uvi+4GNsGrYRqz7ZRtunrkLSxuLL7bvRERE9HViB4HxAwnsDkNERCmqaKX8mP+/0eg2oWWM5TWbV8DZvVfiLKPVaOHnHRj1OGferHjx8I1Mdty9/BR5CueQy5UqJYL8QxAWEi7v22W0jrUtz5deUfdtMljB752/vO/t7pts+0hEREQpGzsIjB9IYEsQIiJKMd7ufuhWZjTCgsMxZGlXVGtaFucOXJOtLzI7ZcSLB68/azvW9pYIDgiNeqxURQ6WFRGhRpacDogIU8uuM9Z2lvD+qKyfZwB0Wh3W3l0kW4QMrT4uWfeRiIiIUl/sIDB+ME5MghARUYqJCFcD4ZH3/9l3FUUrushApvK3pXHh8I3P3k6gbzCsbD90W9FqdPL/1RN2YdjCTvL55/dfw/ddQNQ6rYY2QZWm5XHt75tyHJEeRYcgf5m86DO/C2Z0WJScu0lERESpLHYQGD8YJ3aHISKiFBN9vI0S1Qri9VMPeb9m8/I4u/fyZ2/n9fN3yF0gG0xMVShaIR+evR8s7eF/LzCm7VIsHf0HvNz9EBIUFlVm18KDGFF3Eh5de4pAn8iuNYG+QbDJELvLDBEREaWv2EFg/GCc2BKEiIhSTLHKBdB1fAvZpNXd1RMbp+2RwU2WXJngej/h5qxTNvdDvmJOcHJxxOEt/2Dvb6cwZ9cQhIdFYN5Pm+Q6bQY2QLlaRRAaHI6V43bEuZ2rR2+ifqdamH9yMkzNTbBq+Ea5vPuMDrKliBhLJLuLoxwslYiIiNJu7CAwfiCFTswHmA74+/vD3t4efn5+sLOzS+nqEBFRHBradzf4uCitrQwqr3Z/a3AdjmnjTqhQ2jtvp5Z6EBFR/Bg/UHKet9kdhoiIiIiIiIiMApMgRERERERERGQUmAQhIiIiIiIiIqPAJAgRERERERERGQXODkNElEY0ULU1qLyyZGHDK/H0pUHFQ2oaXodTa9YYVL5hjtIG14GIiCitYPwQifED6bElCBEREREREREZBSZBiIiIiIiIiMgoMAlCREREREREREaBSRAiIiIiIiIiMgocGJWIKI2ytLHA7KPjkadYLgyu+gue33FDrbZV0HJwY4SFhGNut+V499IrRpn8RbKj34jvoNXp4OsViIVT92HcnHYwMzeBVqPD/Il78PaNL5q2rYjWXarh0d3XmDbyz3jrULJ6IXQY1RQqlQq7l/+Fqo3LomKjUtg6ax/2rzkRZ5m8uTNjxIBvoNHqEBISjklz9sPG2hzD+n0DKyszXL/5Ahv+OI+SRZ3Qv3ttWddLV5/hty0ncfvCGti5vMT5Q04oXtgcC1b5YPehIFhbKbB+sSNyZDPB3Qfh6DvSQ25/8qhMqF/TChu3+2PdVn9EqHVw1ylRQFEy5n7UKopO41pDZaLCzoUH8O/+K9jwYAk8X3nL57fN2I1rf99MlveNiIgoLcUOAuMHxg/pCZMgRERplAhWxjebhd5zOsvH4gd8qyFNMKzWBBSqkB8dx7XCor6rY5Tx8gjA2AGbEBYagW4D66NC1QIy8eH1LgBlK7vIxMfyWYdw5tgdXDn/CD1++ibe1zc1N0GrgQ0xrtVCqCM0ctmDq89w89wDWFqbx1vuxStvDPh5m7zftX1V1KhSAJXLuWD+iqPw9A6MWu+HlhUxY9FhvHjpjWWzO2D7PmsUrdAVhRwWyefdPdQ4/Hcwzu7Pics3wjBtrhdW5DHDuE1+WNvEBo59MuC7Xu4yCdKhhS26tLWT5TJn90GoLhgWCqv3+2GK1sOaYux3M6COUEe9fpBfMEbUnZSk94aIiCi9xA4C4wfGD+kJu8MQEaVRWo0Wfp4BUY9zFsgG17svZULizvkHyFs8d6wyPl6BMgEiqNUaRERoZAJE0Ki10Gi08r6fT5BsGZKQopXyIzw0ApP//AkTtgyEQ1Y7eL/1+2S99a8hWJibyiRHNkc7DOhRB4umtUPxwjnkc8/dPGFtZQ6VSgmtVge1Wgczc5uosq4v1ShayAwKhQJl85ni3M5AKGZ54c1LNQqu9oV9+9fIaKuEp5cGpqaK9/usgwlMYQqzqO0Uq1oI4SHhmLr/Z0zcNRIOjhki62ZjgfknJ2PMlp9g6/DhdYmIiIwpdhAYPzB+SE+YBCEiSidsMlgj2D846rFSFf9XfJZs9ihTyQUXzz6Qj1UmSnTsXRv7fr/w2a/nkMUejs6ZMbHdYhzecBqdx3z/2WXLl3bGb4u6oEzJ3PD0CoRLnixYse4kpsw7iEG96sl1zl54hKljmmPLyh64fusFwt+3NtFzcTbFlRuhCAvT4e+JnvAJ10GhBUTqRvyPR+Gw91DD2zey3LwVPihczVUmQFSKDw0hHRztkS1vVoxvNhuH1xzDj5PayOVDqo/D8DoTcfmv6+j8fhkREZGxxg4C4wfGD+kBkyBEROlEoE8QrOwiu3jor/bExcraHKOmtZLdYETrD2HIuGY4tPMy3rz0+fzX8wvGnX8fyatH/525h9yFIltwfI4rN1zRc8hGnDr3AA3rFoPbKx+88wqEt2+QbCmiUiowoHsdDBq9DR36rJFJEmenjDG2kTmTCr1/tEej9q9w5EYYCik+OrEpAT9fLTJmUMmHI/o74MF5Z4QjDH46L7Qa2gTzTkxC9nyOuH3uvuwKc+PEbeQu4iTXD3jfNefMjgtwKZXns/eNiIgovcUOAuMHxg/pBZMgRETpxKvH7nAukhMmpirZxePpLddY6yiVCvw8vTW2rj6FVy8iBz77oWctuL/2xemjtxP1eg+uPkXu911XXErmxpvn7z6rnKlJZFJCCAoOQ0hoBAKDwmBtZSa7x5iYqOSgpmJAVLFcpwOCQ8JhHcc4I13b2eHkHic0L2+BOu+XZRONQAD4awDv98kS0VpEUKkUUMEESqiwa+FBOebHgVVH4fw+8ZG/TF64P/WAiakJTM0ir/aUrFkEr5+4J+rYEBERpZfYQWD8wPghPeHAqEREadj0g6NlKwWngjlwaM0x7F5yWI5jER4ajjldl8dav+Y3xVG0VC5YWpuhQ69aOLr/Ojr1ro07/71AqQp5ce+mG9Yv/Ru1GhZHs3aVkDN3Jsxa1QVj+m2CTmQjognwCcKFwzcw7/DPcsyOBQPXo9vEVqjybWnZnDZ73qz4dewfsepQvkweOeipKOPrH4yZiw7j4WN3zJrQCiYqFdZuPSvX2/D7ecyZ2BoarRZuL71x98Eb3L64Do+VwXj4JBy9Otvjr5PBcsyP3NlUWJ7fFLonEZiuALppAI25ApOmZ5bbmrvcByf+CYZaDVghL2wVGT7sh3cg/j1wBfNPTYZOq8O8Hitg42CN6YfGIjQoFBFhaszvseILvHtERESpP3YQGD8wfkhPFLqPo9o0yt/fH/b29vDz84OdXeQMAERE6UkDVVuDyitLFja8Ek9fGlQ8pKbhdTi1Zk3cTwRpgXV+ULyIgC63KdDdHrCO3eCxYY7SBtfhmHaHwdswdqnlvJ1a6kFE9KUwfojE+CF98E+G8zZbghARUfogEh6DHOTAqERERESMHyguHBOEiIiIiIiIiIwCkyBEREREREREZBSYBCEiIiIiIiIio8AxQYiI0ghVhg8zmiRF9c3XDK7Dyf5VDCpv8dd1g+vwXcl6Bm4hcmpgIiIiY8D4IRLjB9JjSxAiIiIiIiIiMgpMghARERERERGRUWAShIiIiIiIiIiMAscEISJKgwqWzYOeE1vJ+xmz2ePSsdvYveIoBs7pCCtbC/z3zwNsnXswan21Lhy/djgHj8cB6L21GhxyWmLbkKtQh2mhVAEtppaCQ04rPL3oiWNLHkBlokC9gYWQt0ImWf785md4cPotvO7dRsvvh2Do8JbQ6nTw8Q7CjKn70OT7svimYQnodDps3XQO/55/hNJlndGjVx1o1BqsX3sa/914EWs/CpTJi77zf4ROq4OPhx9m/bgM1VtUQItB3yI8JAJze6zAu5fe8R4HpVKBEcu7IXO2DHjr5oWVv/yJX9b2hpm5KbQaLRb8tEkuT4iljQVmH5uAPMVyYXCVsXh+x00ur9W2Klr+1BhhIeGY23UZ3r3kWCJERJS2pVT84GQOLFm8RIxQkuKxg8D4wbgpdOKvLh3w9/eHvb09/Pz8YGdnl9LVISJKdo0y9Y5z+ZBFnXF8+0U07loTaybuhNcb31jraHValNvrir/m30e1rvmQydkKwT4RsHO0wLMT7vBc+wQTC9qh0z8eaLulKrS2ptjc/zJ6bKiCV3f8cPPQK3w7qqgcGNUhozWCg8IQFqZGj1618eiRO7p2r4me3dbAwtwUs+f9gEH9N2Lpyq4YPfJ3aNRazJjTDsMGb4Hqwu0Y9XJwtEewf4hMNHSb2g6PbzxHm6FNMKzOJBQs74JvOtfEov6/xSijzGAfdb9G07LIWzQnNs0+gNYDv4GHmxfuXHwCL3dflK1dBFUalcLy0X/EKK/xjJnMUKqUsHWwQe85nbFj/n6ZBFGZqLDw7FQMqzkBhSq4oEGX2ljU59eoMse0OxL57lFqPW+nlnoQEaXn+OHGuPpJjh2E6PFDUmIHgfFD+uCfDOdtdochIkrDxA/4wuXz4f6Vp3DMnQm9prTBrL3DUKRCvpjrKZSwzmge9djETCUDGNNgNRrPvgPnm74otdcN1u6h6N/3EqxF4KPVIcgnHPdPukMdrsG6Hhfw8PFBeHsFyCBGUKu10Gh0ePXKB+ZmprCyMoe/f0jkayoVCAoMQ2hoBJRKJezsLWPV3+etnwxi5LYiNHAqkB3P776U9+/++xB5iudKcP+z5cmMJ3deyvtPbr5A8coFZAJEvz0RRH2KaDHi5+kfY1nOAtnhetcN6gg17px/gLzFc39yO0RERGnF144fLl76E6Gh4akidhAYPxg3JkGIiNKw0jUK49b5h7B1sEbeok74beIOzO79G/rOaPdZ5ctsfoalr0Pxk7jKotbBDEDwk0C4rHksm76GBkQg0CtcBkvd11aGUmUKj3eRV2OyZrVD2fJ5cOH8I1y++BTrNvfB8tXdsHvXZfm8Wq2R6ziIuuXNAhsbi3jrkSVXJpStWxy3zz2QV3f0xOsmxO2hO0pXLxR5LGoWhs37YEllokTH4Y2x77cTSAqbDFaJqgcREVFaklLxQ2qIHQTGD8aNY4IQEaVhNb4vh5M7LyLQLxgvn7yF5+vIVhCiBYQIAkQrh4QsO/AKvZWAy/vVFgHoJgKa/72GYwFb2GQyh4WtCXKXdpDPO2TIBz8/V1hZmWH0uGaYO/MgzM1N0LhpGfzYYQVMTVSYt6gTrl5+hhVLj2HU2KYI8A/Bs6cesg9wXKxsLfHz+gGY12uVrLOV3YerPp+q/8Wjt1CyWiHM3j0Uz++/hrdHZIuOn+Z3wqGNZ/DmuWe8ZVsNbYIqTcvj3wNXsGvhh/7PQqBPUKLqQURElJakRPyg0bxLFbGDwPjBuDEJQkSURomTvmi2umTYFjmoWJBfiAwKNBqNbK76qSDg1K+P4JTdAu3cPgQYFQAcVwD7GufAhBfBMLc2Qe4yGfHmvh+K1M2GgMDXsLbOjLHjm2Pzhn/w8qU3LCxNER6uRkS4BhqNFqZmKigUwIP7bzBiyFbZlHXwkIYICQmH6uN9UCowetMAbJm+C68eucuxOJyL5ISJqUr26312K/aAaNGJ/V49IXJ8jk4jm+D6mXv4Yei3cH/hiTP7riZYViQ+Pk5+6L167A7nIk4wMTWRY4I8veWa4LaIiIjSipSIH4KC3bF6zbQkxQ5I5thBYPxg3JgEISJKo0rVKIRb/z6SJ3Jhw/Q9mPL7QKhMVdg0Y3+s9Tf1uwT3B/7wfB6IQrUdcXLVIziXzIAaZkrUCNViuokCczQ6HDRXwfuOP74bV1yWK1QzqxzZfW23fxEUmB1du/RBseI5YWlVHZ26VMeBfVdx5vQ9OZiZCEz27b4KUaX2HaugQoV8sl/v0sV/xbkPNdtUQdHKBWFpY4mOY1vi4Opj2LP0f5h3fALCQyMwt/uKBI+BQ1Y7jPm1pwzcrp++L1t+zN49DHcvPUHp6oVx78pTrJ++95PHcvrBMXApnQdOhXLg0OpjOLrxFHYvPoT5pyYjPDQcc7os+8x3hYiIKHVLifjhm3rdUbZcUTg4ZEnx2EFg/GDcODsMEVEaH939c1U//TrO5WJwswrbniPDqxD45rTE5Q55EGEVd45czA5jiI9nh0mK6KO7J8XHs8MkBWeHST+zsqSWehARfSmMHyIxfkgf/JPhvM2WIERERk4kPM73zJ/S1SAiIqI0hPEDpVUc7p6IiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwDFBiIjSCG1AgEHlz5S1NbgOSvUNg8of1UZOZ0tERERfB+MHopjYEoSIiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwDFBiIjSoAJl8qLv/B+h0+rg4+GHWT8uw5CVPVHpu7LYMm0X9q88+lW2oVQqMWrjQGTOmRFvn7/Dgt6roFFrMP/UZLldEzMTLOrzK57fcUumPSciIqK0HD8wdqCUptDpdDqkA/7+/rC3t4efnx/s7OxSujpERMnuG7Mfou47ONoj2D8EYSHh6Da1HR7feI475x6gXIOSsLSx+KwgJinb0KnVMR7XbF0ZeUs6Y+OEP9F2ZDO8dfXE6e3noTJRyWRIyZpFUf/HWljQc6Vc/xgHRqVUdt5OLfUgIjKW+CGxsYPA+IGS87zN7jBERGmQz1s/GXwI6ggNtGoNvN19v/o2sudzxJMbz+X9R9eeoUSNIvK+CGIEKztLPLvlmqhtEhERUfqNHxg7UEpjEoSIKA3LkisTytYtjguHrqfINl7ce4UydYvL+2Xrl4S1vZW8b5/ZDovOTsWg5T1x68y9JNeNiIiI0lf8wNiBUhqTIEREaZSVrSV+Xj8A83pFjsPxNbfRamgTzDsxCTnyZ0NEuBpzj0+EhbU5fN5GXgny8/THkBrjMaX1fHSf3iFJdSMiIqL0Ez8wdqDUggOjEhGlQUqlAqM3DcCW6bvw6pH7V9/GroUH5S26zhPb4Nrft6BUKeVgaWLIqSC/YIQGhSapfkRERJR+4gfGDpRaMAlCRJQG1WxTBUUrF4SljSU6jm2Jg6uPwaVUHlRuUg4qlQI58jli1cjNX3wbDo4Z8MvvQ+RVoGvHb+HOufvIlCMjxm79CVqtViZDlg78LZn3noiIiNJq/MDYgVIaZ4chIkqDo7unlI9nh0ksju5OqW1WltRSDyKiL4XxA6Un/pwdhoiIiIiIiIjo83BgVCIiIiIiIiIyCkyCEBEREREREZFRYBKEiIiIiIiIiIwCkyBEREREREREZBQ4RS4RURpxNPz3lK4CERERpTGMH4hiYksQIiIiIiIiIjIKTIIQERERERERkVFgEoSIiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwCQIERERERERERkFJkGIiIiIiIiIyCgwCUJERERERERERoFJECIiIiIiIiIyCkyCEBEREREREZFRYBKEiIiIiIiIiIwCkyBEREREREREZBSYBCEiIiIiIiIio8AkCBEREREREREZBSZBiIiIiIiIiMgoMAlCREREREREREaBSRAiIiIiIiIiMgpMghARERERERGRUWAShIiIiIiIiIiMApMgRERERERERGQUmAQhIiIiIiIiIqPAJAgRERERERERGQUmQYiIiIiIiIjIKDAJQkRERERERERGgUkQIiIiIiIiIjIKTIIQERERERERkVFgEoSIiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwCQIERERERERERkFJkGIiIiIiIiIyCgwCUJERERERERERsEkpStARET0NTUwaW/4RrQaw8orVQZX4Zj6D4O3QURERJ+H8UP6wZYgRERERERERGQUmAQhIiIiIiIiIqPAJAgRERERERERGQWOCUJEREbN0sYCs4+OQ56iThhcbRye33mJzDkzYvCy7rCys8KNU3ewZequeMsXqpAfvWZ3kvczZnfApf9dw6phG/H9gEao37kWdDodtk3fhQsHryaqDt/3b4j6nWtApwO2zdiNCwevfZH9JyIiosRj/JB2MQlCRERGLSwkHOObzUbv94kMoffsjlg8YC28Xvt8svyDy48xou4keX/Ymr44v/eyvN+0X0P0LjUcFlbmmHlkXIJJkLjq0LRvA/QuMyqy/P/GMAlCRESUijB+SLvYHYaIiIyaVqOFn2dA1GOViQqOebKgz9zOmHNsHIpWKfhZ21GqlChcqQBunb0nH79+7A5zSzNY2lrC3ysgUXWQ5Z/oy1vA3yswSftGREREXwbjh7SLLUGIiIiisc9si7wlcmNqu0XQqDWYsnckBlUZ98ljVKZucdw6c1d2fxEu/3Udv91ZCJVKibndlif6GF/+6z/8dms+VCoF5vZYxfeIiIgoFWP8kHYwCUJERBRNoG8QXj18A89X3vKxRq2VrTzEFZ/oWg1tgipNy+PfA1ewa+FB1GxTBce3npXPWdlaonGvBuhacDBMzUww9/hEXD1287OPsyzfsx66Fh4SWf7YuESVJyIioq+L8UPawSQIERFRNOGhEQj0C4aVnSW0ai1MTVWxEiCCSHyImyCSJEUqF8SiPqvlY61Wh/DQcESERcjWJKbmplAoFFGtRD5Fq9UiPCwiyeWJiIjo62L8kHYwCUJEREZv+oGf4VLKGU6FsuPQ6uNYP/5PTNv/M0xMVdgwaccnj0/pOsXlWCD6JEVoUCjO7LqAJeenywTJ/hVHPpnA+LgOZ3ZdxJJzU6FUKrF/5VEmQIiIiFIZxg9pk0KXTi4r+fv7w97eHn5+frCzs0vp6hARUSrVwKS94RvRagwrr1QZXIVj6j+QlqWW83ZqqQcREaVujB9Sh+Q4b3N2GCIiIiIiIiIyCkyCEBEREREREZFRYBKEiIiIiIiIiIwCkyBEREREREREZBQ4OwwRERkVhcrwQUnXPz9tUPluLnUNrgMRERF9PYwf0g+2BCEiIiIiIiIio8AkCBEREREREREZBSZBiIiIiIiIiMgocEwQIiIyagXK5EHfeZ2h0+rg4+GHWV1WoHGvuqjfsQag02HbrL24cOi6XFeti8BV9QkULOSN/fsyonBhU1Sv8Q7ZskVeUxg8yAY1a5rjl3H+uHs3Amo1MHyYDWrXNsfrNxoMHeoHtVoHb8095FEVibcOc7qtxIyDP8vnzC3NYGJmgv6VfkmhI0RERERJjR2+VPzA2CHpmAQhIiKj5vnaB2ObzEZYSDi6TWmLqs3KoWmfBuhTbjQsrMxlMkIfyCihQhmTWsj63eGo8na2CuzckSnGNnv3soKzswl8fbXo2MlHBjHLlwVh0EBrVK9ujtK5PZBN6QwLhVWcdajcpCxGfjNdPlfvh2rIns/xqx4TIiIiSp7Y4UvFD4wdko5JECIiMmo+b/2i7qsjNNCqtXj9xF22wLC0tYC/d2DU80qFEmawiFE+KFiHVq29kC2bCtPH2MBpbyhKuWmgzqVCaDtLKN93PHV9oUaxYjbyvq0iA/x0nrBQ5I63Dno1WlXCunF/frkDQERERF8sdvhU/JA9sxIL85sgi6cWNrlUCOpqBXNzxSfjB8YOScckCBEREYAsuTKhbN3i2DZzLzJmz4DfbsyBUqXEvF6/Jnh89u7JBAcHJXZuDcLKRl5Y6q+LHHFLC0xYFYQev9jK9QrkN8G5c+Fo1MgcPjoPWOisE6yDYGljgSxOGfHi/iu+R0REROkkdtDHDxnNgCO1PTH/UBiWiF/mWsBqdyj6VzFF925WnxU/MHZIPA6MSkRERs/K1hI/r+uHeb1/lVdxvutRF12LDUePkiNlM9eEiASI0O6dFjd9dVBoAYUa2KAFInx16OQV2apj4EAb7Nsfgh9/9IG5wgrmCst466BRa+SyKk3K4sLBa0b//hAREaWn2EEfP1hvCEb7t1r8h8jYQcQQmx+pgVtqtGhh+cn4gbFD0rAlCBERGTWlUoHRG/tjy4w9ePXIHRbW5ggPjUBEWIRMRpiam0KhUECn08UqGx6uE+OfyWarF69FwEUBQAecBLALwB4VEO4WmdDIlEmJNasdoNHoUCGvFg6KrPHWQa9mq0pYP2H7VzoSRERE9KVjh+jxQwY3Dc4ogPzvVxPxw24AWwupoO9QE1/8wNgh6ZgEISIio1azdWUUrVxAdj3pOKY5Dq4+jrN7LmLxmclQqhTYv+pYjCDmWsRJmJwJx5OnGjRsaI6DB0NhZamApYcWG9+v0xeA6L3bQAOY/huODSKwORmGFSuDZB/fnKqqMFGYJliHS0duyCaurvfYFYaIiCgtxw7xxQ82PlpYa4F10eMHHdD4n3CYdvbGls0Z440fGDsknUIXX3oqjfH394e9vT38/PxgZ2eX0tUhIqJU6hvzjgZvY/2TE7GWKYK0yNLMGyaP1VFjgqjzm+Dd/ozQWcfsfdrNpa7BdTgathVpWWo5b6eWehARkfHFD4mJHQTGD0iW8zZbghARESUDEayIoEX07zV5PzuMGOE9riCGiIiIiLFDymAShIiIKBmDmcABkdPYERERETF2SH14eYqIiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwDFBiNK5Bso2BpU3yeVkUHmtlzcM9VegfuJRIsPp1BEGb6P5LyMNKp9Rdd3gOhAREdHXw/gh/WBLECIiIiIiIiIyCkyCEBEREREREZFRYBKEiIiIiIiIiIwCxwQhMlIFyuZDv4VdodPq4PPWFzM7LYFGrYlzXUtrc8zY2g/OBbNhaPNFcH3ojjnbB8qyJmYqLBm9XS4TFAoFVh0bhYObz+HAxn/iff3abSqj39yOaJdnENbdmA3PNz5y+R9zDuDayTtfaK+JYrO0scDso+ORp1guDK76C9yfeWDS7hEwNTeFVqPFvB4r8db1XZyH7pvKhTCiYx18N2Q1lo1sJZeZm5nA1ESFThO24Ocf6yJvjkxyeTGX7Gg8ZDX8g0Jjbce5qBN+WtoNGrUWIUGhmNF5Gb7pXAP1O1SHTgdsm70PFw9zHBEiIqLUIqXjB8YOScckCJGR8nzljTGNpiEsJBzdp/+Aas0r4MzOC3GuGxYagUnd16DH2GZRy8Z0WCF/sJWo5IIWPWth0ag/5fLa35eBx6vIhEZ8RKKkRvPyePcyctDUIP8QjPp2VrLuH9HnEp+B8c1mofeczvKxSAbO7b4CXq99UK5BSbQd0QxLB62NVU6hAOqVL4i33gFQa7ToO2uHXP5t1SLImdVe3p+96YT83zGjDSb2ahRnAkR4+fANhtWbKu93HNsC1ZqVR5Ne9dG34lhYWJlh+v5RTIIQERGlIikdPzB2SDp2hyEyUqL1h/jyFtQRGpnQiI/IZvt5B8VYpl/fysYCz++/kfeVSgWqf1caZw/dSPC167StgrN7r8iWJIKljTnmHhmD0ev6wtbB2uB9I0oM+fftGRD1OCJcLQOYD5+NuFtINapSBMevPIRWNNWIpl6FAjh+6WGMZXUrFMSJy4/irUP017CwNIPbw9d4/fQtzC3NYGlriQDvQL6pREREqUhKxw+MHZKOSRAiI5clV2aUrVcCFw5eTVQ5+4zWmLdrMAZMa4Vbl57KZXWal8M/h29A+z65EReRKKnZsiJO77wYtWxo/WkY2Wgmrhy7hU5jmxuwN0TJRyWapI5rhT1L/xfrOaVCgfoVC+LYxQcxlltZmMIxoy2evY45NXSdcvlx8mr8SRChbN3iWP7vVJSqVQRvnnrgyrGbWHNtFpaenYy9K44m014RERFReokfGDskDZMgREbMytYSozcNkk334stWx0e0DBnRagmm9d2AriO/i0xuNC2D0/sTHregbvuqOLP7EnTRst8B71uZnNlzCS4lnZO4N0TJa+ivvXFw9TG8efo21nOiyerflx7K8Tqiq1nGBWeuRyYF9bI62ECj1cHLLzjB17t24jYGVBmPs3suo1nfBviuex10KzESPUuPQrfJbZJnp4iIiCjdxA+MHZKGSRAiI6VUKjF6y2BsmboDrx69SVxZlVKO6yEEBYQgNCQcDlnskCGzLSav74WWvWqjSedqyF/cKVZZ58I5Ub9DNUzfMxw5XRzRZ1YHmJpFDk9UolohvH4S+4RB9LV1GNtSDnB2evu/cT6fN2cmfFetCJYMb4ncjg4Y2qGWXF6vQkEcv/wwVvPWEx8t+5j+MyAE+QcjwCcI4aERiAiLQGhwOEzNTKM+c0RERJQ6fc34gbFD0nFgVCIjVattFRSrWki2Buk4rjUOrDqK09vPx7v+lA29kK9oTji5ZMWl43dQtkYh2ZdRjOuxfPwueL31w09NF8h167euIGeUeXz7ZaztrJ2wPer+0jOT8OeCg1h4fDxCg8PkD74F/WIPIEX0pU0/OBoupfLAqWAO2TWs84TWuHPuAUrXKY67Fx5i3S+/x1h/2fazUfc3TuqAhdtOy6as2TLZ4ukrrxjr1ilfAGOWH0zw9cvWK47WQxpDp43sXzyv92qYmZti0amJMul4YPXfMVpPERERkXHHD4wdkk6hSydRlb+/P+zt7eHn5wc7O7uUrg5RqtFAaVgzepNcsVtzJIbWK2bfxqT4K3Cjwdsg0mugamvwwfDtVNmg8hl3GD7d7V/Bm5GWpZbzdmqpBxERpW6MH1KH5DhvszsMERERERERERkFJkGIiIiIiIiIyCgwCUJERERERERERoFJECIiIiIiIiIyCpwdhiidU2WwN6h89+NnDCq/eFR7g8oTJbdjmg8zFKUYjvVLRESUpjB+SD/YEoSIiIiIiIiIjAKTIERERERERERkFJgEISIiIiIiIiKjwDFBiIxIwbJ50XNSa3k/o6M9Lv19C/evPEWLvvURFhKOeQPWwfOVT9T6al04xra6D7fHoZi+oxByF7TExB8eQqEE1BE69J6WWy67/W8Afp//CipTBdoNyYFilWxxapcXdq90R3DQKpQsVQbLly2GRqNFSGg4Js4/gO+/KYValQsiJDQC05cehpdPEMoWz40+nWpArdbit9//wfU7bil4tIiIiIiIKL1hSxAiI/Lw2jOMajZX3m5feIR/D11Hy/4NMLLJHGyauQ8dRjSJsb4SJhi92gWVG2aIWjZ+UwFM2loQHYbnwKH1HnKZSICMXZcfY9fmx/bFb6LW/a5LFpSo0RdKhyroP3YbBo3/A/ceuaNmpQKoUi4f+o3dhjXbzqJrm6pyfZEAGT5lJ4ZP3Ynu7at9teNCRERERETGgUkQIiOkVClRuHw++HkFwPX+a6gjNLh78THyFnWKuZ5CCbtMpjGWmZgq5P+hXhEo7xWBsuNewMw9AnYqBSysVNBqdfD3Vst1/trqiVtnVsDd9VpUeQtzE7i99sEzNy/5+OHTtyhZJGfk6ykVCAwOQ2hYBFRKBextLb/4sSAiIiIiIuPBJAiRESpdszBunXsAa3srBAeERC1XKj/9leDvFYHxre9j8/DnaHvKH3l3ecL+bQQKNr+PgBehcHsYiuAANSo0sMf8w0VQpEp3vH58FqWLZMG6eT+iTPHceO3hhyL5s8HURIXypZxha2Mhtx2h1sIxsy0c7K2QN3dm2Fibf9HjQERERERExoVjghAZoRrfl8fJHRcR6BsMq2itLbRa7SfLipYh2xtkQPDNYIzTAUfUwCIAg5+HQdX3KXIXsoB9JlNY2qjk+iamFrDP7IJTZ/7FjXvv0KF5RTSpWxx7/7qBBRPb4PEzD7x45S3XXbLuBMYO+hb+gaF46uoJb9+gL3gUiIiIiIjI2DAJQmSEXWGKVHDBkqGb5f3chbLDxFQlB019dudlgmU1ap0cFNXaLRym4n9N5PIKAP42Aa4Ws8KQCJ1MgAQHaGBlq4JOp0VYkDssrCrLdYOCw2BiosT/Tt6RtzLFcsHHL1g+d/+xO36auF12gxnaq54cNJWIiIiIiCi5MAlCZGRK1SiMW+cfQqfTQaPWYO+qvzH34CiEh0Zgbv+1sdaf2fMxnt8LwetnYShXxw7//RMAa/dw2GmA5e/XmSXG/1ADmptB6PBbfrns0AYP3DjthzcvlqNdh54Y0K8bdFodfP2DMX3p/zBpWBNksLPC23f+mL/mb1mmU4uKqFg6L0LCIrDot+Nf9bgQEREREVH6p9CJX0LpgL+/P+zt7eHn5wc7O7uUrg5RqtEoY0+Dyve4dD3WMlWQBvXaPIDtk9DIkYW0QICLBY7vKASNdWQ3GL3Fo9rDUP/sHmnwNogodUkt5+3UUg8iIiL6OudttgQhokQTiQ6R8Mi/5Z3sGhOUywyPO2WJlQAhIiIiIiJKTZgEIaIkEQmPB32y8egREREREVGawSlyiYiIiIiIiMgoMAlCREREREREREaBSRAiIiIiIiIiMgocE4QondP4+hlUfm3VCgaVt/S8hPSggaqtQeXVdcoaXAezyw8NKv+X3zqD60BERESfj/EDUerDliBEREREREREZBSYBCEiIiIiIiIio8AkCBEREREREREZBY4JQmTEStYqik7jWkNlosLOhQfw7/4rCa6vVCowYnk3ZM6WAW/dvLBo2GbM2jUUOq0OJmYqLB6+Fa73XyeqDr3ndkbhigXg8cIT87qvgDpCjbTA0sYCs4+OR55iuTC46i9wf+aBSbtHwNTcFFqNFvN6rMRb13cxyuTJkxnDhzSCRqNFSGg4Jk/dh8EDG6BK5fzYuPkf7N13Ta5XorgT+vWpC61Oh0uXn2LT5nOxXt8xdyYsOTkBrvdeycfTu6xE/R+qonqzcggJCsW8fuvg7e77lY4GERERfYnYQWD8QJS8mAQhMlLihNt6WFOM/W7GZyceqjUuA/fn7zCn3zq0HviNfDy61UJo1FqUqFIALfvUw8Khmz+7Di6l88DBMQOG1ZqADmNbokbryjj5+z9IC8JCwjG+2Sz0ntNZPtaoNZjbfQW8XvugXIOSaDuiGZYOWhujjJubNwYN2SLv/9i5GmpUL4jf1p3GfzfdYGlpGrVeu7aVMHPOQbn+kkUdsWv3FQQFhcWqw61zDzDtxxXyvkNWO1RsWBJDv5mBQmXzouOoplg67PPfCyIiIkp9sYPA+IEoebE7DJGRKla1EMJDwjF1/8+YuGukTEZ8SrY8mfHkzkt5/8nNFyheuYBMgAhWthZ49r5VwucqWqUgrh77T96/fOSGrFNaIa7Y+HkGRD2OCFfLIEZQR2hkYPMx0QJEz8LcFC/cvODtHRRrPdcXnrCxNodKpYRWo0N4eNxJqqKV8mP+/0aj24SWyJorc1SrkEf/uaJY5QLJsp9ERESUcrGDwPiBKHkxCUJkpBwc7ZEtb1aMbzYbh9ccw4+T2nyyjNtDd5SuHpmoKF2zMGzsLWGfyQbzD47EwNk/4Pa/jxJVB5sM1gj2D5H3g/yCYetgg7ROdC3qNK4V9iz9X5zPlyubB6tXdUPp0rnx+nXc3VX+OfcIkye2wMb1vXDjvxeIiIgdFHm7+6FbmdEY/u0s2Gexk91jCpbNC1MzE5StXRQ2GaySfd+IiIjo68cOAuMHouTDJAiRkWk1tAnmnZiE7PkccfvcfdkV5saJ28hdxOmTZS8evYWIcA1m7x4KCytzeHv4w88rEMObzMXU7qvR9ZfmiapLgE8QrOws5X3xoz3AJxBp3dBfe+Pg6mN48/RtnM9fvfYcvfuux5kzD9Ckcek41+nfpy4GD92Kzl1+Rb58WZE7d6ZY64irR2HB4fL+P/uuIk+RnDi07hRm7BmO8g1K4OVj92TeMyIiIkqJ2EFg/ECUfDgmCJGR2bXwoLzZZrTB2K0/yWX5y+SF+1OPT5bV6XRYPWGHvN9pZBNcP3MPCoVCLhctOkKDY49bkZB7Fx7KcUn+3nwG5RuWxp1z95GWiXFNxCBnp7f/G+fzpqaqqFYdYowPE1NVnOuJAVHF8zodEBISDmtr8zgHVwsJDJX3S1QrCLcHb/D3H+dxbNs5lKxeKEZzWyIiIkqbsYPA+IEoeTEJQmSkArwD8e+BK5h/arKc3WVej8gBNhMiBt8c82tPaDQaXD99H+6uXpi9J3J2GK1Wh+Wjf09UHZ7ceA6ft75YcHqKnB1m+9z9SEumHxwNl1J54FQwBy4cvIrOE1rjzrkHKF2nOO5eeIh1v/weqylr+7aVZJLDzy8Ys+YcQs8etVCtSn4olUrkyOGAFSuPy5liZs1oI/sAi8HQ7t2LPeOOGPOj6/gWsjWIu6snNk7bgzHr+sA+sy08Xnhh2YjIAViJiIgo7cYOAuMHouSl0IlLuOmAv78/7O3t4efnBzs7u5SuDlGq0UD56bE+EqLKHLsrRmJoPL1gqGPayNYnKamBqq1B5dV1yhpcB7PLDw0q/5ffOoPrQJTeztuppR5ElD4xfiBKfedtjglCREREREREREaBSRAiIiIiIiIiMgpMghARERERERGRUWAShIiIiIiIiIiMAmeHIUrnUsOgoumB0sbGoPLL1i01uA5D89c0eBtERET09TB+IEp92BKEiIiIiIiIiIwCkyBEREREREREZBSYBCEiIiIiIiIio8AxQYiIEskxdyYsOTkBrvdeycfTu6xE/R+qonqzcggJCsW8fuvg7e4btb5aF4Efvn+Hxw/V2LY3MwoUMpXL37xS47vaHth+MItcdvFcGBbP9YeJiQIDh9uiYhVzXL8SjsljfOHjo0XZaHUoUCYv+s7/ETqtDj4efpj14zJUb1EBLQZ9i/CQCMztsQLvXnrzvSUiIkolGD8QpQ5sCUJElAS3zj3AqCZz5E2pUqBiw5IY+s0MbJy6Bx1HNf3oi1aF5esy4pvvLGIsX7syEGXKmUU9FgmQVRszYdWmjFixMEAuy1/QBL/vzwzHbKoYZT1fe2Ns45kYUX8KXj9xR9Xvy6PVT40xot4UbJi0HR3HtuT7SkRElMowfiBKeUyCEBElQdFK+TH/f6PRbUJLZM2VOapVyKP/XFGscoGYX7QKJTJmipnEePlCDYUCyJ5TBWWIFplXBEDpqkG+rUGw0QEaDeDjrYGtnRKWlrG/qn3e+iEsJFzeV0do4FQgO57ffSnv3/33IfIUz8X3lYiIKJ3GDzkclcjwRxCyj/GF4o0GGUwAKysl4weiz8AkCBFRInm7+6FbmdEY/u0s2Gexk81bC5bNC1MzE5StXRQ2Gaw+uY21qwLRtbcNFGodcg72Rda5AbDy1iJ0TgCsmrzD4wcRCPDXfXI7WXJlQtm6xXH73AME+4d8+HJX8eudiIgoPcYP3TtbweZEGDKtD4bD9mBYu2uhavwO3q4RePyQ8QPRp3BMECKiRIoIVwORjTDwz76rKFrRBYfWncKMPcPx5NYLvHzsnmD5F65q+X/OXCYwe6yG2QsNFDpgEYBuOiDjUw2KOqmQKXPCiQwrW0v8vH4A5vVaJZMeVnaWUc9pNVq+r0REROkwfijxdxhU/jooACjUkfFD32caWPX0kWOMMX4gSoNJkNDQUFhYxOw7T0SUWljaWCAkMFTeL1GtINwevMHff5zHsW3nULJ6Ifh5Ro7nEZ8HdyPw5KEafX70wpMnGvTTAScBVABwAsA7FdBHCVjbxJ8EUSoVGL1pALZM34VXj9yhMlHBuUhOmJiqULC8C57depHs+01EREQpHz90OBGK+wAe40P8cNwEeFzcFIMjdIwfiNJCEsTDwwNr167F/v37cePGDYSHh8PMzAylS5dGkyZN0LNnTzg6OqZ0NYmIJNFnt+v4FggLDoe7qyc2TtuDMev6wD6zLTxeeGHZiC2xjlS/Ll64fzcCz5+o0aajNTbtzCyXT2nsgXF31DDVAbMA/AXAWgNM+DYyEfzkUQRmTvSD6zM13NUnUUBVGnYKB9RsUwVFKxeEpY2lHAT14Opj2LP0f5h3fALCQyMwt/sKvltERETpMH4Q44j9PDsAIwCI+eZk/KAGTP4Lx4gNmWQ5xg9E8VPodLpPdzr/gsaPH481a9bg22+/Rb169VC0aFHY2dnB398fd+/exYkTJ3D48GH06tULU6dOjXc7Yn17e3v4+fnJ8kREyamhfXeDyi+4JdIbsSmDtMjb3BPmj9WRozRpgbD8Jni2NzO01jFbggzNX9OgOhwN/92g8kTJKbWct1NLPYgoffoS8UNiYgeB8QOlJ/7JcN5O8ZYglpaWePLkCaytrWM9V7ZsWXTq1AlBQUFYsmRJitSPiOhLEsGKCFoybgyCqZsGEblU8O5iHWcQQ0RERMTYgcgwKZ4EGTt27CfXEQmSMWPGfJX6EBGlRDDj2d+WB56IiIgYOxB9Yan2UqMYHDUk5MN0j0REREREREREaT4JMm/evKj7om9P8+bNYWNjI/v4NGvWDL6+vilaPyIiIiIiIiJK+1JFEmTKlCkxuseIMUBu3bolb2KmmHHjxqVo/YiIiIiIiIgo7Uvx2WEEW1tbBAREzovt4uIiZ4RxdnaWj1++fIlq1arB1dX1s0aJrY3vYaIQk0Ul3jHtjiSVI0rPGijbGFTeJJeTwXVQZ3cwbAOXbiE9UFpETpubVH8Fb062uhCll1lZGD8QfRmMH1IPxg+UnvgnQ/yQKlqCKBSKqPuiFYg+ASI4OTnBy8srhWpGREREREREROmFSXIPZmpiYiJvwp49e+T9pk2bJlguODhYTocriBYhT58+Rb58+eRjd3d32VKEiIiIiIiIiCjVJEEaNGiAuXPnonLlypg8eTJWrVolkyDXrl3DxIkT4y23du3aGI+Vyg8NVK5fv47OnTsnZzWJiIiIiIiIyAglaxLk7t27qFChgry/ceNGHD9+XLbiEGN6JJQE6dKlS7zPffvtt/KWFJY2Fph9bALyFMuFwVXG4vkdN1hYmWPS7pEwtTCFVqPFvO4r8Nb1XZK2T2QsEvNZKl69MHrP/RE6rQ6X/7qOP9ZfiNyGtTlmbO0H54LZMLT5Irg+dMec7QPleiZmKiwZvV0uGzbvB7lOaHA4Lp28i12/npTlCxTKjn5DG8r1fbwDMXPiHjhktMbgUd/BytocN64+x5a1Z9CsVXm06VQVD++9xtSxO+PcH5FoHbVxIDLnzIi3z99hQe9V0Kg18rksuTJjw8MlGFD+Z7mfyXFMPre80HpYE1RvWRmhgaGY2205vN74JPje1G5TGf3mdUY75wGYd/QXaLU6mJqZYNHAdXC9+/Iz32EiSs7PNxElT/xgaOyQ2uKH5PhuYfxAlMqSIBqNRo7v8fjxY2i1WhQtWlQu9/FJOIj39vZGxowZkdzCQsIxvuks9J7zoSWJ+KKa230FvF57o1yDkmg7shmWDozZEoWIkv5Zajvie8ztugxuD15j4ZmpOLDrBoL8QxEWGoFJ3degx9hmUdsY02EFNGotSlRyQYuetbBo1J9y+YIRv8ugJjrPd/4Y89MWhIWp0b1vXVSrVQjVaxfB4jmH4fUucmBl4cyJu7h84Ql6DqgX79tYvWVFvHn2FrM6L5H1rt6yEk5vPy+fa//z97hz7sEX/36Jq7yDYwZU/K4chlQfh0IV8qPj+NZY0n9NvHUQ37c1WlTEu1fe8vHP382SdShRvTBaDmqEhf1+++R+EFHyf76JKHnih5CgcINih9QWPyTHdwvjByLDJevAqKIVyMCBAzFy5Eg0btxYLnNzc0OGDBkSLJc1a1Y0atQIO3fuRERERLLVR2RT/Tz9YyyLCFfLLxlBHaGRX6JElHyfJdd7L2FtbwWViUqWCw9Tf9iGd1CMbejLWNlY4Pn9N/K+mLDqp9ntMH1LX+QtkiNqXR/vIBnAyNd7f9XFMXsG9BncAHOWdUbREpGz0Pj6BMskbEKy53PEkxvP5f1H156hRI0i8n62PFkh5st698Lzi3+/xFXe0TkzXO9GXj16dO0pilcrnGAd6rSrgrN7LkH3fn/1V6Os7Czx/Hb8rViIKGGMH4hSR/xgaOyQ2uKH5PhuYfxAlMqSIGvWrJFT1Ygpa8SYIMKFCxfQsWPHBMuZmpqiYMGC6NOnD3LmzInhw4fj3r17+JLEF2yn8a2xZ8nhL/o6ROndx5+l83svYcLOEVh3bxH+O30HEe8Dj7jYZ7TGvF2DMWBaK9y69FQu+236fgxrsRgrJ+7G4Bmxp+fN4miHshXz4d7tV8ibPytWLzmGmRN2o9+Qhp9d5xf3XqFM3eLyftn6JWXQJbT7+XvsmLcfKfX98vrJWxQq7yK7s4h62ThYx7uuUqlAzVaVcHrnxahl9pltseD4eAxa1AW3zt03aB+IKG6MH4hSNn5ISuyQFuIHQ75bGD8QpWASJE+ePNi6dSs2bNiAzJkzy2Vt2rTBrFmzPpkEWbJkCd68eYPFixfjv//+Q/HixVG1alWsW7dOTpubGK2GNsG8E5Pk//EZ+msfHPz1GN48fZuobRMZm8R+lvrM+xHDak5A14KDkbeEM3LlzxpvWXF1Z0SrJZjWdwO6jvxOLgvwDZb/v3ziEfVjX8/KygyjJ7bA3Kn74OcXjFcvvOD5LkBe5dFotFCqPqyb0HdDjvzZ5JWXuccnwsLaHD5vfeXVHeFTffwN/X5JqLy/V4AsN+uv8aj4bRm8fPA63teo+0M1nNl1UV790vPzDMCwelMxtcMSdJvcNsH9IKLk/3wT0ZePHxIbO6SG+CE5vlsYPxCl0jFBhPXr12Pbtm14+/Ytbt68idOnT8v7bdt+OiA3MzPDDz/8IG/Pnj2Ts8aIAVWHDBkCf/+YTccSsmvhQXmLT4dfWsL9uUdUHz4iit+IupMS9VkSA3MG+QXLH+chASGwtrWMs6xSpZSDlIn1ggJCEBoSLpdb2ZgjODAM9plsYGpuIrcn11cqMHpKS2xZdwav3CKbjQYGhslBzUTTUFNT0Xz2Q0Lgc78bOk9sg2t/34JLKWc4F82FGYd/Qd4SuWWgI/Zd38UkoW186pgkpvzRjafkrWStovD18It3PefCOWWd6/1QDTldsqHP7I5YPXpb5PH0C0ZoUFgCR4KIkvL5ZPxAlLLxQ2Jjh9QSPyTHdwvjB6Lko9BFv4xooOnTp+PPP//E4MGDMWLECPj6+uLhw4eyO8zly5fjLSdmkAkI+DAwUXSib95ff/31yRliRJJEdMOpje9hojD9UKeDY+BSOg/eunri0OpjuHr0P2x5viJq4KK7Fx5i3dht8v4x7Y4k7jlR+tVA2SZRn6Uy9Uqg29T2sk+r28PXWDL5QNS2pmzohXxFc8LjlQ8uHb+DsjUKQavTyYBm+fhd8grOxN96wDaDlQx0Ns49hP/OP4Y6uwPqNCiGgSO+xbP3V3kO7L6Cd2/90XNAfZiYKLF57Rlc/vcxatcvhu/bVEDOXBnluqMHb4Hu4q0Y+yQGIP3l9yEyQLl2/Bb+nL03xvMj1w3Ajvn7E5wdJjHH5HPLi+TH2G1DkCGLHd6+eIelA9YiPDQywBOUFhZxbmfpP5Mxqe0ijF7fX44PIoK/5UM3wu1hZF9pvb+CNye4P0Rfk/68LbrR2tnZpdjBZ/xAlLrjh6TGDkJqjB8MjR3i2gbjBzIm/skQPyRrEiRv3rw4e/YsnJyc4ODgIGeFEUkM0TVGzAATn++++w6HDx/+IkFMYjAJQhR/EJNUJrkiBxwzhAhiDHIpZhCTVsWXBPlcTIJQapLakyCJwfiBKDbGD6kH4wdKT/yTIX5I1jFBxNgd2bNnj5q6URCzvZibmydYztAECBERERERERHRV02CVK5cGcuXL4+xTAxsWq1atURvKyQkBK6urslYOyIiIiIiIiIyZsk6MOqiRYtQr149bNy4EYGBgXJ2FzEo6t9//51gOTc3N3Tv3h2PHz/GuHHjULhwYTRp0kQ2dSlUqJBsKSJmniEiIiIiIiIiShVJkHz58uHevXs4cOCAbMWRK1cumcywtrZOsNzQoUNRpkwZlC1bFv3798fUqVPx6NEjhIeHy0FWf/nlFzn1LhERERERERFRqpki18LCAm3aJG4gxTNnzshpdTUaDebOnYuePXsiY8aM8rlly5ahfPnyyV1NIvpKgtepDN5G6LqEE6mfYnfJ4CrA5bJhg5LenVTC4DqcOTDK4G0QERGlBYwfIjF+IErlSRAxze3ChQtx9erVWFPenjhxIt5yosWHmZmZvC9GetUnQIRs2bLJkV+JiIiIiIiIiFJNEqRz585yfI9WrVp9sgtMdCLRIabQFcmPgwcPxnju1atXMjFCRERERERERJRqkiCnTp3CixcvEj1f7+jRo+X0uiIJ8vFMMseOHUPr1q2Ts5pEREREREREZISSNQkiBkIVXVsSq2vXrkl6LrHqtK+G/ou7o41jj2TbJpGxKVQhP3rN7iTvZ8zugEv/u4ZVwzZiw4Ml8HzlLZdvm7Eb1/6+CbUuAtcHbkXQcy+UWdoB1nkzw+PkfbzafQ1KcxMUGtUIFlnt4HP9BZ6v/QcKEyXydK2GDKVzIexdAB7MOQKdRgs7VWlkL1JbbvubKoUx7Mc6aNRvpXzsmMkWO+d3R5dxW/D0pRfKFc2F/u2qQ63W4ted53Dt3ss496NkraLoNK41VCYq7Fx4AP/uv4IRa/ujUpNy2DJlB/YtPyLXE/twDWdwqkYAWqxvBNucNjg64jTU4RoolQrUnlgFtjls8M/sS/B66AOtRofyfUoiV5UcuLv7ER4feSa343l7L75tMQjTJvSHRqtDSEg4Js3ZDxtrcwzr9w2srMxw/eYLbPjjPEoWdUL/7rWh1elw6eozuYyIUg7jB6K0HT8kV+wgMH4gSvsMToLcvHkz6v7AgQPRrl072bLD0dExxnolS5ZESlIoFKjRqjLeuXmmaD2I0roHlx9jRN1J8v6wNX1xfu9leT/ILzhquZ4SKhSb1gLPVp+Rj7VqDV7tuopSC9sj4IE7Xmy5gILDvpEBTIlZLaFQqXD7l93IULodXvx+Ebl+qAiHss642eV/yORcBubW9qhbsQDeen0Yc+jHphVx8+HrqMciiPlp9m6oNRosHNkS/aZtj7UPpuamaD2sKcZ+NwPqCHXU8nW/bMPNM3dhaWMRYx9Kozrc692JfKyKTHxYZ7WC24XXuLH5Lmr8XBElOxaBnZMtwvzDcGjgCZkEKdqygLwJW+och0+QDQb8vE0+7tq+KmpUKYDK5Vwwf8VReHoHRr3mDy0rYsaiw3jx0hvLZnfAzgNXERgUZvB7R0SJx/iBKG3HD5nzlE2W2EFg/ECUPigN3UDp0qXl9Lbi/379+uHkyZNo2LChfKy/ieeTXEGlEtWrV5fdYgxRt0N1nN11ATqtzqDtENH7z6ZKicKVCuDW2XvysYWNBeafnIwxW36CrYNN5DoKJcwyWEUdspBXvrByzgSlqQr2xXMi5Mk7dPj9Ihzf+OLHA//BBjp55SbCLxihb/xg45JVlrPKkB2Bns/RsGoRnLj0CDpd5Oc4exY7ed/dyz/qNcRrBgaHITRMDZVSCXsby1hvWbGqhRAeEo6p+3/GxF0j4eCYQS73dveNta7cB4V51GOVmUomQORzJkqYanVouOE2+m68I/+3VGuhUCpibMPzvjcsbTLHyDtbmJvKJEc2RzsM6FEHi6a1Q/HCOeRzz908YW1lDpVKCa1Wh/DwD4kaIvq6GD8Qpa74IZtLFlhefo7hC48ho2cAbFVKqCxN440f6pTJniyxg8D4gSh9MDgJotVq5dS24v/4buL5pBJJlT59+uCPP/4wKJFSq01VnPqTTcqJkkuZusVx68zdqKBiSPVxGF5nIi7/dR2dJ8U9TbY6MBQm1pEJBcuQcDg/e4ee688hi18Ivln3D6b034Lg555QB4bBKncm+N54IYMaf48n0KrDUK9SIRy7cD/GlZyth67EeI0IjUY2c81oZ4V8Tplg+/71onNwtEe2vFkxvtlsHF5zDD/GU9+EaNRaXP/1JpZfeoPvV/yHqgeeyP8jWh9AmRb5Y6z75LgrMmePbA1XvrQzflvUBWVK5oanVyBc8mTBinUnMWXeQQzqVU+uc/bCI0wd0xxbVvbA9VsvEB6R9O9QIko6xg9EqSt+ELHDikHbkOldAL49chs5PAMxrt9mKF/7yq4zH8cPgZ7P8G2t8skSOwiMH4jSB4OTINGFhYUhIiIixjLxWCxPqlq1aslZZ9auXZvkbdTrVAOnd5yP+rIlosRrNbQJ5p2YJP8XarapgtM7/o16PuB9d44zOy7ApVSeOLdhamMB9ftuHS32XodluAYqrQ6LAfTQAbPdfJDHxgKmDtayKeu7kw9wa+xumFllQOtm3+D4xQfQf4xzZo2cNeqN54crOcLCzScxoU8jjOxWD0/cPOHtFxRrH7Lnc8Ttc/dlV5gbJ24jdxGnRB+PM9MvoF1WS1R5FQSlVgcTtQ4btTqY+oejj09ojHXdzr1GxqyF5f0rN1zRc8hGnDr3AA3rFoPbKx+88wqEt28QNBotVEoFBnSvg0Gjt6FDnzUySeLs9GHacCL6ehg/EKWu+EHEDs4vvGW7SlONVsYP41/6wm/CXjluyMfxQ6eOHXHk7HWDYofo+8D4gSh9SNaBUUU3mBkzZqBq1apRyy5duoTx48fjxIkTnyz//Plz3Lp1CwEBAbC1tUWJEiWQJ0/cX4aJ4VzUCflL50W9jjWRs0B29F3QRQ7ERESfb9fCg/Kmb8papHJBLOqzWj42MTWBQgFEhKtRsmYRvH7iHuc2LHJmQLCrN7QRGvjefYMSoteIDqgAQHxDvFEq0FapgNLKDLAyQ9FJzeSVnNs9/0bRokVROF92NKpWBLmyOWDZmDbw8A7AolEt4ZIrM3I5OqDf9O249/QtBszYIZuyjuxaF8GhEbD7aB9sM9pg7Naf5LL8ZfLC/alHov4Urv12C3Y5bPC9RzC0SkCpBU6K7QPYqQIuvfowvofnA2/Y57KFysQMpiYqRKgjW3UEBYfBxEQlx/qwtjKDRqOTj8WgqWJAVLFcBG3BIeGwjueKFBF9WYwfiFJX/JBZqcA/YqzB98tF/HBUpcSfBRwxLEIDk4/ih4JP8qBS1dpo1USR6Nghrn1g/ECUPiRrEkQMklq5cuUYy8TjGzduJFjO3d0dHTt2xOnTp5EtWzZkyJABfn5+ePPmDerUqYMtW7bEGmg1MX4bvTXq/vJLs5gAITJQ6TrFZV9efesqGwdrTD80FqFBoYgIU2N+jxVR64orMUFPPBDs5o3sTUoiZ6uy+G/Yn/DwDcZf79eZBcj7VlodGtUogKNifI5Lz+D252U5vkZWl4ZYsf1Dd7YNUzui6/gPn+vxfRrKpq2iJYVo5lq5pDNCwiIwb2PcyVdx1enfA1cw/9RkOU7QvPf17T6jA6o0LS+DtOwujlHfFdd1/yDkgh98Xf3hXMMJV9fchGOpLOjvHoQmap2sf19xHAA00gD+V9+i4vvXevr3C+Sr74ywc0D5MnnkoKdinA9f/2DMXHQYDx+7Y9aEVjBRqbB269nI/fv9POZMbA2NVgu3l964++AN/2aJUgDjB6LUFT+MXH0GubU6bH6/jjj/HtFo4X3/DfLMaCWXRY8f3toHYts/PskSOwiMH4jSB4UuGfuI5MyZE/fu3YOdnf66K2Qyo1ChQjLREZ+mTZsia9asmDlzpvxfz8PDA2PHjpVlDx6MzCDHx9/fH/b29qiN72GiME1S/Y9pdySpHFF61kCZ+PEyogs/5hzncn2/XtGsVatQQKnTwTV3RvRf2gEhlmYx1g1dl92gOtj9fgGGcrn8YcYYPfPgCIzqegTZn/tHtQh5k8cOczY0QphVzO+hu5NKGFyHMwdGGbwNotRCf94WcUL0uCGl6sH4gSj1xw+JiR0Exg+RGD9QeuKfDPFDsrYEqVu3LoYOHYqVK1fCzMxMjgUyfPhw2ZojIadOnZIJD0vLmCMxi4TIkiVLDGoFQkSpkwhWRNAi+vdmd/fHm2x22NO8TJxBTGolEh0i4VF7+wNkehUIr5w2ONW2UKwECBERERkuPcQOAuMHopSVrEmQefPmyVYdmTNnlq1CXr16JVuBHDhwIMFyGTNmxJ07d1C+fPlYz929e1d2jyGi9EcELdt+qIS0TAQyf3UtntLVICIiMgrpIXYQGD8QpZMkiGixcfHiRVy+fBmurq5wdnZGhQoVoBAjHiVAdHlp0KCBnAWmdOnSUWOCiLFExHggopsMEREREREREVGqSYL0798fK1asQMWKFeVNb+DAgVi2bFm85fr06YMCBQpgw4YNsvtLYGAgbGxsULJkSezcufOT3WmIiIiIiIiIiL5qEkS02hBJkI/9/vvvCSZB9OOJiBsRERERERERUapNguzfv1/+r9Fo5Pgf0SecefLkiRy9NbFCQ0Pldj4eLPVTVFmzQKVMW4MjEaVmKgNnbbD4/p3BdXg3OKdB5TNmz2ZwHZ72zmRQeWvv+GfIIqKUx/iBKJk/U4wfJMYPROk0CfLTTz9FJS4GDx4ctVypVMpxQkQXl08NqDpixAh5X4wF0qVLFzklrhhL5Ntvv8WmTZs4OCoRERERERERGUSJZPDs2TN5a9WqVdR9cROtQM6fP48mTZokWH7KlCkxBkkNCgrCrVu35C08PBzjxo1LjmoSERERERERkRFL1jFBtm/fnqRy0bvPHDlyBCdOnJAzywi//fYbqlWr9skxRfQsrc0xd+cIOBfKjiGN58L1wRvUbFYWLXrVQVhoBOb9tAmer33Rf3pbuBR3glKlxJZ5h3D11L0k1Z3IGJWsXgg/jGwKlYkSu5cfRauBDaHTamFiaoLFQzbB9d6rT26jdpvK6De3I9rlGSQfZ3HKiHX/zcHAGhPhejfu8hXyOqFf3UpQKZXY+M9VnLj3FNntbfG/4V3Revk2PH7rhfHN6sIla8bIeubKjjqzVsf4fpjxx0D5/TC06Xz5/TB0QUdUql8MWxccwYENZ+R6fSa3gkuxnDC3NMOuX0/gzP5rcnmBwtnRd0Qj6LQ6+HgHYda4XZizsgu0Wh1MTFVYPP0Anj/xQL8RjeBSMBvMLUyxc/N5nD52J2YdtvSFc4FsGNpyMVwfumPOnwPkNsU2lozdIZcVq5AXPcc2k8uvnL6PbUuOGviuEVFCGD8Qpf7YISXiB0Njh+SIHxg7EKXiJEhYWBgWLFiAU6dOwdPTM0Zy49q1D18EH4s+ha5oBaJPgAhOTk7w8vL6/DqERmDijyvRc3wL+Vh80bbsUw8jmi9AwdLO6DD0WywZ+Tt2/3oc7i+8YGNviem/D2QShOgzmZqboOXAbzC+9UKoIzRy2eWjt6BRa1CiWkG07N8ACwdtSHAb4jNfo3l5vHvpHbWs7bDGuHvhUbxlzExU6Fq9HPps2IMIjTZqeY9a5XHN9XXU46n7T8j/s9nbYEbrhvALCUOGaN8Pk7r8ih7jm0etv2HWAdy68BiWVuZRy36bugcatRYWVmaYt3doVCDj+S4AYwdukdvpNqAeqtYujFH9Nsp1S5R1RssOlbFg6n6sXnQ0srylGRau7R4jCSLr0OM39BjTNGrZmI4rI7dRyQUtutfCotF/onXvOpg//He8fOqBedsHYt/6yCCLiL4Mxg9EqTt2SKn4wdDYITniB0Nih6CA0E8eVyJjkyzdYfSGDRsmZ4j57rvv8ODBAzm2R3BwML7//vsEy4l1ypYtK28BAQF4+vRp1HPu7u6wtbX97DpoNVr4eQVGPc6ZL6vM2Iov3LuXnyJv4RyR230RmViJCFfLLCwRfZ6ilfIjPCQCk/8YjPFbBsAhq50MYgQrW0s8u/vyk9uo07YKzu69Iq+ICI7OmQEd4OEWf8KzTO4cCFOrsbzz91jSsSky21ghp4MdRK71jW9ArPW/KV4AR28/iv394P3h+0Hw8fCPVVYEFYKFlTlePPwwoKmPV6AMRAS1WiO3p1/X2toczx57xCxvaQrXZ+/iqENQnK9nZWOO5w/eyPsvHr2FtZ2FTOSK76jwMHW8x4aIDMf4gSh1xw4pFT8YGjskR/zA2IEoFSdB9u7di0OHDsmBUk1MTOT/e/bskS1DErJ27Vq5rriJKXbFgKp6169fR+fOnZNcJ2s7SwQHhkQ9Ft1fousyuhn2rU24fkT0gUMWO2RzzoyJ7ZfgfxtOo9Po72GfyQbzj4zGwHmdcPv8wwQPl1KpQM2WFXF658WoZe2GNcbOxf9LsFym90HLgM37sOPyLQyoVwU9a1bA+rNX41y/QbEC+PvO4yS/daOW/ogVf4/G9TP3Yz2XJZs9ylbMhwtnH8I+g5W8WjNodGPcuu4atc7oaS3x6x/9cO3Ck0++ln1Ga8zbMQgDprTCrUuR6/979DbGreiKNX+Pxs0Lj2XCloi+HsYPRKkndkgr8UNCsUNyxw+MHYhSSRJEdGXJkyePvG9hYSFniylSpAiuXo37S0ZPtBiJftNvQxCzw8yZMyfJdQr0C4aVjWWMTKpeg3aVYWqqwqk9V5K8fSJjIz5Tty88kq2r/jtzH7kL55Ctr4Y3moWpP65A1/EtEyxft31VnNl9Kaq7XPa8WeX/b194JlguIDQM156/lk1ZLzxxQ81CeeXy176xr8Y42tlArdXCMzA4yfs5Z9Am9K41DW0HfROjy56VtTl+ntIC8ybvk1ds/HyDMbTHOkwZtV02cdWbNW43erRahvbdasQoHxfRMmREm6WY1n8juo5sLJf1/KUZRrRdhh51ZsoWbLlcIo8TEX0djB+IUk/skFbih/hihy8RPzB2IEolSZACBQrgv//+k/dLlCiBhQsXYuXKlcicOTNSyutn75C7YDY56FDRCvnw7F5k37+SVQugeuPSWDl+Z4rVjSgtenD1GZwLRXYrcymZG+/cvKJO0sH+wQgNDk+wvHPhnKjfoRqm7xmOnC6OmHVgFJyL5JSPy9YtjsGLukJloopV7qabe9SAZUVyZIGthRnyO2bCr11boGp+Z0z8vh5M3rcii6srTGKYmkUOlxQWEoGQwNCogEtchRJXaLasOY1XL7xkyzL9vgcFhiI0JHLfRXJVlg+NQEhwWIzxkT4WYxsBIVHHT5QR/XjF/8FBobC2/ZDMJaIvj/EDUeqJHdJC/BBf7PAl4gfGDkSpaGDUGTNmIDAwMOp+hw4d5Bgfv/76q0GDrVpZWUGjiew3+DmmbOkvR2d2csmKw5vPYe+ak5i7e4jsUz938Ea5zuDZP8gvl1nbB8kvmvEdVyS5jkTGJMAnCBf+dwNzD/8sR3XfMHUPZh8cKfvnirErlo/YkmD5tRM+zCK19MwkDKo5Kerx8FU9sXPJ/6L6CUfnFxKKk/efYlOvNtDqdGi5dCte+vjJ56a3+gbr/7kqr97og5ih2w7G+fpTNvVFvmJOkd8PW87BKV9WVP6mhAwosufJjNWTdmPUsi6wc7CGylSF3xf9FVW2ZoNiKFoylxwIrWPPWjh64DoaNisj6yP2f9nsw3K90dNbwc7eCiYmSmz9LfaAplPW9UK+ojnka186cRdlaxSSx04cz+UTdst1ti7+C1PX95LH4uXTd7h/40NTWSL6Mhg/EKXO2CGl4wdDYofkih8YOxAlH4UuoUuUqYBIglhaWkL7/sspPv7+/rC3t0e9rD1hojRL0msdebM8ibUkSr8aZehhUHmd2vCxLNwGlzaovPPGD4MtJ5UmWyaDyqu8Yze7Taz/PVtg8DaIUgv9edvPzw92dnYpXg/GD0TJi/FDJMYPRKkvfkjWliCCaLHh6uoa1SJEr2TJkvGWyZgxsolaXESO5lP96YmIiIiIiIiIvmoSRMwO06tXL3h5xZymSiQxEurOIlp5iPFD8uXLF2dLEDE4KhERERERERFRqkmCDB48GDNnzkTHjh1lF5bPVbZsWZiZmaFWrVpxJkFSeY8dIiIiIiIiIjK2JIiYErd79+5Qvh9h+XNNmDAB1tbWcT4nkiMnT55MphoSERERERERkbFK1ilyBwwYgKVLlya6XO3atVGhQoU4nxNdaeJqIUJERERERERElGKzw7x+/Ro1atSQLUIcHR1jPHft2rU4y4jxQzJl+vSsC59aL7WMMk8UXQOT9oYdEF3CsyJ93jYM+4gf0+4wqHwDZRsY6q/XNwwq/109w+tw5M4Mg7dBlJwM/WypCsQehysxNI8Mm3VJrYvAKexL8fM24wdKjRg/ENEX+35RMn5I1u4wrVu3Rt68edGqVStYWVl9VpmKFSuiZcuW6NatG4oWLRrr+Xv37mHdunVy0NVHjx4lZ3WJiIiIiIiIyIgkaxLk5s2b8Pb2luN4fK4bN25g/vz5qF+/vpwlpnDhwvKKkLgy8+DBA7lOnz594m1JQkRERERERET01ZMglStXxpMnT1CkSJHPLmNra4tJkyZh/PjxuHTpkkyK+Pj4wMHBAaVLl5YtRVQqVXJWk4iIiIiIiIiMULImQcqXL4+GDRuiU6dOyJYtW6zpcxMiEh1VqlSRN6L0ytLGArOPjkOeok4YXG0cnt95icw5M2Lwsu6wsrPCjVN3sGXqrk+UH488xXJhcNVf8PyOG0as7YdKjcthy5Qd2LfirwRfX5Qbsqo3NGotQgJDMa39QoQGhWLE2v6o1OT9NpYf+QJ7/tE+HJsQuQ9Vxsp9EOKrgxg3oMp3brjzIBznDzmheGFzFKrqipzZIpOjY37KiAa1rHDin2CMm+kFUxMFJv+cEbWrWmHDn/6YudgHXm+3wsLEBpUKtsHMtT3gnD8rhvywCq6P36Jll+qo3qAYQoLDMf+XnfB+F4CmP1RG62418PDOK0wfuu2LHg+iL6VO+2rov7g72jj2iHcdS2szzFzfC875HTGk3XK8eu6JGWsj1zezMIWJqQoDWyxB31+aIl/hHLCwNMXOtWdw5n83E3ztAmXzod/CrtBpdfB564uZnZZAo9Yk+z4SGQNDY4f0Ej8QUfqOHwp8xdghWZMgFy9ehIuLC/79999YM7x8KglCZAzCQsIxvtls9J7dKWpZ79kdsXjAWni99vnM8rPQe07nqGXrfvkdN8/chaW1xSfLuz14jSE1xsv7nSa0RvUWFfH3ljNY98u2yG3YfHobhpL70DTmPgjx1UEJFfZvyoFRUz2jltnbKnFitxMQpAXW+UFxMBDjTgTj8MGcMLVXoUnH16i9J3JcosE97XFoa8fI1w5TY2L/Teg5opF87JDZBhVrFcKwTr+iYAkndOhbF8um7sOZv27hyj8P0X1Y5HpEaY0479ZoVRnv3D58buISFqrGxD4b0HPUd/KxOkKDUT+ulvfrNiuD7LkiByRfM/uQ/PFjYWWG+dv6fTIJ4vnKG2MaTZOf9+7Tf0C15hVwZueFZNs/ImNiaOyQXuIHIkrf8YPnV4wdkjUJcvLkyeTcHFG6o9Vo4ecZEPVYZaKCY54s6DO3MzJktcOGCdtx99+Hn11e8Hb3/ezXj55NtbAyx4v7rxK9DUNF7oN/rOXx1UGpUCJL5phd4gKDtKjT7CVy3g/H0kAtMqrEvgEOP7yB7pATNBrA0ytyX1du8MObl5uRO2M5ZLcvCj+foKjtZM2eAa6PPeT9x3dfY+iUlvK+n3cQLCxMk3W/ib6muh2q4+yuC2g9rOmnP4/RPhPR1WhUAuvnR17ZFQGMYGFphheP337y9cUVHD0RGOnLE9HXjx3i2kZajB+IKH3HDz5fMXZQJufG3Nzc4OsbWfmwsDAsXLgQy5Ytg1qtTs6XIUo37DPbIm+J3Fg9agtmdlqKfgt+/OKvWbZ+Say8OgelahfHmyef/jGTGp3d74STDazRMFCLyTpAoQbEcMwvHobj7RIf3H4QDl9/DZo3ssbNU7lRLndbPPe6hLCIwBjbeePmjYLFc8LUVIUyVVxgY2eZYvtElFyUSiVqtamKU3+eT/I2RDPXLNky4MWTyCShMGpee6zcPwTXzj/+7O1kyZUZZeuVwIWDV5NcFyJK+dghvcQPRBS/1BI/fI3YIVlbgoipbteuXYsMGTLg559/xvHjx2FqaipneVm6dGlyvhRRuhDoG4RXD9/I5l+CyHgqVUqZXU1OrYY2QZWm5fHvgSvYtfAg+pUbhbYjm+G73vXx5+y9yfpan1sHQ2TKqILiRQTaKIG17y9OLQLQDUDGvQEoUdgMjllMYGsTmec1UZkjo7UzAsM9YW5qE7Udf99gHN5+CdPXdMfT+2/w8nnCTf+IUjP9Z+zGqds4veM8dDpdkrdVuW5RXDhxN8ayOSP+kInCRdsH4O89nw5MrGwtMXrTIMztvoLjgRClwdghtcQPRGQ88YPVV4odkjUJ8vjxY5QoUULe3759uxwbxMbGBsWLF/+sJIg44EePHsXdu3eRM2dONG7cGNbW1slZRaJUJTw0AoF+wbCys4RWrZUtEr5EECMCF3EzNfvwkQ/yC4ZJtMdfmr4OhgoP10F8N5vnNsUZLZD//fIKAI4rgHctbTHoWYRMgPgHaGFnq4ROp4VfyGvkdigTa3vH9l6Tt5IV8sLXO2ZLEaK0RP8Z6zmrIxp0roV6HWsiZ4Hs6LugC1YN25iobdVoVBIbF34YKFF8N0VEaGQ/3ZCgsE8GSOJq0ugtg7Fl6g68evQmyftERCkXO6SW+IGIjCN+UH7F2CFZv8FExcPDw2XLDzs7Ozg7O8sdDQz89A8LUaZ9+/aoUKGCnBr3+vXrmDVrFvbu3YvcuXMnZzWJUtT0Az/DpZQznAplx6HVx7F+/J+Ytv9nOYryhkk7Pl3+4Gi4lMoDp4I5cGjNMfm/yN6Kq0DZXbJh1fD4v6zKNiiJtiO+h1arhd87f8zttlwu7z6jQ7RtOCb6Cy+xph8cA5fSeeBUKAcOrT6GoxtPJViHxh1f4787YXj4JBzfN7LBjv2BsLZQwNxSgbUhOuhUwCwNcNRcAav/wrBkVhZZbtFqXxw5EYT7zzYhm31RWJplwJSVXeBSODuc8mTB4R2XUK5aQdhntIbHax8sn7Zflqv1bUk061AZOXJnxszfumNsr/Vf9HgQJaffRm+Nur/80qxPfp6nrO4GlyI54JQ3Cw7/eRH/HL31frycD83df57/A+wyWEFlqsK2Fcc/WYdabaugWNVC8opOx3GtcWDVUZzenvTmtUTGztDYIb3ED0SUfuOHWl8xdlDoDGnvEkd3GI1GAy8vL9SoUQMzZ87Eo0eP0KhRIzx58iTecn5+fqhUqRI2btwo/9c7ceIENmzYIG9z5syRXWzEiLVx8ff3h729vdyWSMAQpQYNTNobtgFdMlzZMfAjfkz7ecFVfBoo28BQf72+EfcT+tlhXkRAl9sU6G4PWMce6ui7eobX4cidGQZvgyg5GfrZUhXIZ1B5zaOnBpUX01+fwr4UP28zfqDUiPEDEX2x7xcl44dkbQkixgOZN2+eHAdk1KhRctnDhw8/OT2uGEC1S5cuMgHSsGFDRERERD3n6uoqW5icOXMGmTJlQq9evZKzykSUlomExyAHJFsml4iIiIiI0rVkTYI4ODhg+vTpMZaJcT0+RXR5OXDggLxfr1493Lx5Ex06dMAff/yB2rVry+VTpkzBTz/9xCQIEREREREREaVMEmTVqlXo27evvL9kyZJ410uoNcjLly+RK1cueX/z5s24cuUKzM3NUbduXZQrVw4TJkxAmTJlcP/+fUOrS0RERERERERGyuAkyP79+6OSIHv27IlzHTGOR0JJECsrK7x79w5ZsmSRfXNfvXqFfPnyyeRIQECAXCc4OBgWFhaGVpeIiIiIiIiIjJTBSZDDhw9H3T958mSStlG1alX8/fff+OGHH+TgpzVr1kT16tVx7tw5jB07Vq5z6tQpVKxY0dDqEn1VEfVjT8maGCVnxjMgaCLcrxx7oNCvSZU5k8HbKDOjv0Hlc4S8NLgOlDy+zTHQ4G2o3T+MOp4UqmQYhPOI71qktK1u5wwqb6u8bFD5ZjnFxNRE9CUwfiCKifFD8tnK+CF5xwTRU6vVsuVGdAmN/C5aifTp0wfNmzdH//79UadOHdy+fRsTJ05EkSJFEBYWJu8vWrToS1SXiIiIiIiIiIxAsl4ivnDhAkqVKiW7rYhBUsUtQ4YM8v9PtQQRrUDEVLpubm4y8dGmTRv5v3gsljdp0kS2ECEiIiIiIiIiSvGWIGKa23bt2slZXcQ4H4khur3kz58f33zzDbJmzSoHShVjg7i7u+OXX35Bp06dkrOqRERERERERGRkkjUJ4uHhgcmTJ8uBUJOibdu28vb06VO8fftWDpQqEiNEaVle58wYNrghNBotQkIjMGXGPsya2gY6nQ4mJirMX3wEz1w9UaKYE/r1qiOXX7ryDGs3nsD2H4/C+4k/2mysD7ucNjg0/Cw0YVooVArUn1QRdjls5GvotDpsbfM/lGiTH6XaF8Sb/zxxYtplhPqGoRpaRtWlQJk86Duvs1zfx8MPs7qsQPOBDVG9eQWEBoVhbs9V8H7j+0WPh1KpwIjl3ZA5Wwa8dfPComGb8dP8TqjYoAS2zjuEA+tOxVkuR0Y7bB3xA5688ZKPR204jDldv5P3LUxNYGqiQrs5W5EvW0ZMaFdfvs7yQ//i4sMXUduwtDbHjM194FwgG4a2WgLXh+5yeZYcGbD2+BgM+n6hXDZsTns4F3REaHA4Lp28h11r4q4TJY18H/4cBOdC2TG0yTy4PniDoQs7oVL9Yti64H84sP6MXC93gWwYPPcHKJVKbJp7EDfOPkhwu47OWbDs0iy43nGTj6e2XQA/T//PqlPJ6oXww8imUJkosXv5UbQa2BA6rRYmpiZYPGQTXO+9SjVvtxgwvH79+rh92x2H92dCkcKmqFzdA9mzqeTzQwbboFZNc3lfq9WhVj1PdP3RCj26WeP3P4OxZVsw1God3nno4OunxamD2VCssBlKVHuFHO+3MWqwPerVssRPY7xw/2GEXHb5ejgeX82JjA6R69zTXUUEwlHJtg5mH5uAPMVyYXCVsXj+/viPWNsflZqUw5YpO7Bv+RG5rHj1wug990f5HXTxyFWcmrIvRY4hUXqOHW5e+Q3nq70xKHbocax5jPqkhviBKLXFD2kpdkiO+GHj5iA8eKiBOkKHc39lT1LsMHCUF27q/k1y7HD5r+vYMPn31JUE6dChA/bu3YsWLVoYtB0xM4y4EaUHL156Y9DwrfJ+l47VUL1aQQwb/YcMbEqVyIXWLStg7sL/oX2bipg175Bcf+n8jtix2xpNx9bEP4siB0dVyuClEmyyWuHFv29wbeN91B5TXj738IgrbLN9aH2VMZ8d2m5qgN09jwOREyxJnq99MLbJbISFhKPblLao3bYKKjUqjaG1J6NQ+XzoOLYFlg5a/0WPR7XGZeD+/B3m9FuH1gO/kY83TN+LW+cfwcI68os3Plcfv8KIdQejHvdculP+37h8YThlziDvD2pSDRO2HYVXQDBW9GsRIwkSFhqBST3XosfopjG226ZPXdy5+izGsgWj/oxKklDyku/Dj6vQY/yHIHvDzP249e8jGeDodRnTFAuGboHvuwBM3db/k0GMcPP0XUxtOz9R9TE1N0HLgd9gfOuFUEdo5LLLR29Bo9agRLWCaNm/ARYO2oDUwtLSEgcPHsSgAc5Ry+zslNizM/YgxLv3hiJnjsjAQ6haxQzt21rKJEjzFj6oXOHD8bazVeKvXdlilF88M3KbL1+p0WuIZ1QQ4+qmRhi0UEIpv0/GN52F3nM6xyi77pdtuHnmLixtPszs1nbE95jbdRncHrzGgjOTYb/YPlmOCVF6Y0jsULxsF/jYbDEsdvhIaogfiFJT/JDWYofkiB9at7SAr58Odep5wttHm6TYwf1t5LFKauyw8MxU7Fi0H/BLRUmQadOmyRlc5s6di2zZYh6M3bt3J+dLEaUZImDRMzc3wQs3r6hlVlZmePbsnbzv6uoFa2tzqFRK+bz4kWLp8OELQGWmkkGMYKbRwvmhD9pNuwyP7FY4fNMTBRrkRkSoOvJ1bM3irIvP2w/fGOILO1P2DHh+L3LmlEfXn2PYr73xpWXLkxlP7kS+5pObL1Dl29I4s+/qZ5UtnTcH1v/UFteevMLSgx9mxmhQpiCWHPhH3s9iZ40X7yKvRvkFhSKD9YdjqNVo4ecdFGObjk4Z5RW0d68/XMHSQYefZrRBSHA4fpuxH8/uvzFwrym6yPchMMYyH4/YV1wyZrXH6/efjwCfINhltIb/R+/fx4pVK4QFp6fg9j/3sO6Xz7tSULRSfoSHRGDyH4MRGhKOZcM2R9XHytYSz+6mrtmFTExMZEvJ6IKCtGjeygvZsikxc5o9HBzE94gOBw6FoFlTC4SE6OR6zrkjT/umpgpYWSkQveGm2MY3Ld2RI7MKS/KbIJOnFrpcJlB3t8WeQ8Fo3tg6at35y/3gjHJww+PI9zOOK2be7rGvCrveewlreyuoTFSyXGhoaHIeGqJ0w5DYwcwssqXHx7GD0kQJE50O9dffRYaXgRh1wxOF2xVAqFaXYOyQWuIHotQUP6S12CG54ocsmUWr7shbjNghmwoLfsmArLuDoXBTy/hhjwKxYoef+tqh8zEYFDuEh4YbfiyQjMS4Hebm5qhRo0aixwQhSs/KiWakPWpDrdHg9+0XYW9viWkTWsIxqx1+mRyZIPzn30eYMq4FwiPUOHbiLsLfZ5U/pvIPw8tR57ExTIO8d7yxRaPDkCyWOFgjByIbnn1allyZULZucUxqswBTdo+AqZkJStUuCpsMH76ovhS3h+4oV6cozh28jtI1C8PG3vKzyr3zD0LTqesQEq7GxB/qo17J/Dh+8zGszE2RLYMNnrp7y/Wid8cLDAmDvZVFgselTd862L7yBDr91DBq2W8zDiDANxhO+bJi+Nz2susMfX0xfqD7h8A2Q8JBjPcbH3QtMAihwWEYtqYvqreoiH/2XPrk6zhksUM20fS84UyUrlUEnUZ/j03T92DC1oHI6pQJkzsuRWp3YG9mZHRQYvvOYMxdEIAZU+2xa08ImjaObPXxsSNHQ+GS1xQRER+eO74vGzKZK/BnjdeYdjAYS0SEoAVUu4Owz1aBLb9lles9c42Q740FEn+eP7/3EibsHIGIsAgc23JKzv5GRF8+dtBEaHFl1W384RWCyi+DsBE6DNABnmvv4GCnQp/9FqRk/ECUmuKH9BA7JDV+sLVVIoO98kPskFGFrVsCMKuBO5b4ayOnXtECB8wV2HQ8e4zYIbeTiUGxw/GtZ+X/qWp2mNOnT+P8+fOYPXu2nNI2+o3ImF29/hy9Bm7A6bMP0PS7UvDzC5HNXCdM3YteXSNnPRJ9egeN2IpOPVbDJW8W5M4Vu2macLPfKQwK06CADlCoddihA/q8C0GhS28/qy4iO/3zun6Y1/tX+HkG4OCa45h5aDQqNCyFl49e40u7ePQWIsI1mL17KCyszOEdRwY/LhFqjUyACH/feIxCTpGZ7NolXHDq9tOo9bS6D1/Ytpbm8AuO/0pz9tyRx9jjlU+M5SIBIrx86iH/F+OL0Ncn+n7qWdtZIcA37gCm1dAmmHdiEpoNaCQDGOHsrgtwKZ33s14n0C8Yty88klc3/ztzH7kL54CfVyCGN5qFqT+uQNfxH8bVSa1EACOIoOXOXbW8irNvfyhafP+hJZTenbsRWP1bEOZNiTlzmwhiTNYFoO1bDf4TQaQaUGiBVw8jYOqhRbaskc1Z5y3zx9B+dmg3tAV2n9whj//n6jPvRwyrOQFdCw5GvpJ5ULhwYYP3nSi9Ss7Y4eS0y2iX1VImQMR3604t0EEH2HuGIv/VyCvmqT1+IEpN8UN6iB2SGj+UL20WI3YQ2npo8J+vVsYNIn54pQVMQnRwOhAcI3ZwyNbLoNghbwln5C7shFTVEqRo0aJywBU7O7vk3CxRmmZqqkLE+yszQcFhckAzkQkVv9XFYzHgmSC6ZAQFhcnlwSHhsIljfIzLv91BMdF6QaUA1DqIEStE6kN8jTy+5AGfJ/7IXjIzshbNGGddxI/50Rv7Y8uMPXj1KHK8i2Obz8hbyZpF4PuZCQlDiP1cPWGHvN9pZBNcP3Pvs8qJFh/B7zO/5fLnjGr50aB0ASw7eD5qPU//IOTOkkGOCWJnbQHfoNB4r1fnLZJDDpI6dX0v5CmUHTnyZMbPHVbA3MIUwYFhsM9kI69yicGh6OvzfuePHHmzyD69tg5W8V7F2bXwoLxF7z9aomZRvHjfVPtTHlx9hhb9Gsj7LiVz452bl2xRJP5Wg/2D5QC5qVl4uE5+b5ibK3DhYjjy5FHBw0OLd55adPzRB2/cNdBqgfLlzJDNUYmRo/2wbrUDLC2VsbZh6qbGGQWQP9qf/E4F0NLxw7ov3NQYPNobV06NRfDCAORHCeRQ5PmsuorPUpBfsDy2IQEhsLfnmCBEXyN2sMtpjeYeIdAqgbfayNihsUj2i+1df4dKd73jjR1SS/xAlJrih7QeOxgSP8ydExSr/D/XwuAirhm+jx/EqH2tlJBdY6LHDqGhM3HpwkyDYgfRNSZVJUFatmyJxo0bo3///rHGBGnWrNlnzS4zY8YMXLt2DYGBMft7iWVEaVH5MnnQrnVF+cH19QvB8l+PY+HsH+Rj8aFevPyYXG/j1nOYPbUNNFqtHODs7v3XeD7oNDwf+MD3eQDy1MyBS6tvI9DRCvXVOlQBMBPAFfHloFBgaMWsuFE2qwxivJ/64fSca/B5EYCrEcdRQFUGdsqMqNm6MopWLiC/7DuOaY6Dq4+j2vflYZ/FFm9dPbHspy8/gJNDVjuM+bUnNBoNrp++jzsXn6DbL81RuWFJKFVKZM+TJSpJEl2ZfDkxsElVhIar8crLD8sPnZeJkewOtnjiHjljjCDGCpnS4RsZsK04/G+s7UxZ1xP5iuSAU74sOPz7BYxst1wuFzPC7PrtFDRqLUYu6AjbDFZyG2tm7P/CR8Q4TdncD/mKOcHJxRGHt/wj/6/8TQk5iF9258xYPWk3Ns48gGELO8nR3TfPO/TJbYrRw7tO/QFhwWFwf+aBDeP/+Ky6iP7CF/53A3MP/yxHdd8wdQ9mHxwprySJz+jyEZEDDKYm3333Ha5dC8PjJ2p829AC+w+GwMpKCTMzYNH8DMieXYWjhzPLdf/YHoygIB1KlTTFiJ/94OmlRb+Bvrh33xMmKuDhkwg0bWiFXQeCYeOrgYUWWBfttXZrgW2VPwSIB/5wlP83yFEUj3BTBjHTD46BS+k8cCqUA4dWH8PRjafQfUYHVGlaPvJz7eKIVcM2YvOUHZh+aIz8nL148BIXL1786seOKL3HDreurkcY3GPEDtlLZUZf92A0Vusw633sIKxTABfLZIH5R7HDnr4nkVMbGTsIqSF+IEpN8UNajB2SI36oVf8dgoN0uHknHG2+t5axg7WVAhZvNTFih10AtusgxwaJHjuIwVFrVUKSYwe3h69x7+JDg4+DQie+TZNJ3rxxNx0SWTEx7e2n1KlTByqVCq1atYo1pkiXLl0SLOvv7y+vKPn5+bElCqUatRvNNqh8yZmRM8NEZxYcgWFdjiHbswB5RUepBdzz2mLBxgYItzKNtf79yob1ejsaFjk6fVI1ytoXhnrT/vP7K8clx0HDB6f639PEzThCcfs2x0CDD43a/fO6fsVHlQytFY/4rkVK83iVw6Dytso4BkEM0sK8iTsUjyKi+vTqCpgi7GA2wDrmd0mznBUMen21LgKnsC/Fz9uMHyg1YvxAFBPjh+TjwfgheVuCPHsWc4rJxBKtPd69ewczkYoiojiJRIdIeNT88xEyvQqCV05rnGlXIM4ECBFRolgrZcJDjA2iH91dzA7zcQKEiNIexg9E9MVYp634IVmTIIaqVKkSHj9+LMcWIaKEA5m/u/FzQkRfgLUS6kEcq4MoPWL8QERfTBqKH1JVEmTTpk1o3bo1atasGWtMkcGDB6dYvYiIiIiIiIgo7UtVSZCFCxfiypUriIiIiDEmiBhThEkQIiIiIiIiIko3SZCVK1fKcUHYHYaIiIiIiIiIUn0SJCAgQN5sbW3lLTGyZMmCfPnyJXeViFKM2cmbBpV/1Dxmt7Ck0GneICUd8ViFFLckpStAeo9+Mvw7Xuuc3aDyBXoaPrVaalB1ywiDyhdYY+h3w3MDyxNRfBg/EMXE+CH5VGX8ICfAM5hWq8W0adPkFLkZMmRArly55P958uTB9OnT5fOfY/z48ejVqxcePXokp6yLfiMiIiIiIiIiSvGWIEOGDMHZs2cxd+5clC5dWiZA/Pz8cP36dcycORMeHh5YvHjxJ7fTvXt3+f/WrVvlOCCCTqeT9zUaTXJUlYiIiIiIiIiMVLIkQbZt24Y7d+7A0dExalnmzJnh4uKC6tWro1ixYp+VBHn27FlyVIeIiIiIiIiI6MskQfStNeIilovnP4ezs3PUfU9PT5lIIUovCpTJg77zOkOn1cHHww+zuqyAg6M9Bi3pCitbS/x3+h62TN8dq5yltTlmbO0H54LZMLT5Irg+dMec7QPldkzMVFgyertcNmzeD3Kd0OBwXDp5F7t+PRl7WzYWmH10HPIUdcLgauPw/M5LuTxLrkzYcH8RBlQcE7WM6EspmT0bfq5dI/Jvz9oap58+w/QTp5Hd1hbHe3fD9xu34pGnF8bVq42iWbPCwtQEv126gsP3I8fy0Gm1eLdiJzTe/jDJ4oDMvZpDYaKC2tMXbkMXIueM/jDL5YiQ20/g8+cxQKWCQ9t6sCwa/3gktdtURr+5HdEuz6DIejllxLr/5mBgjYlwvfsqTR/H8k45MbpOTXkuPvPsOZaeuxDz+2VjbzgXcMTQ1kvh+ugtMmezx4DJLWBlY4H/LjzBtqXHkDt/Vgye1hpKlRKbFv6FG+cfxapPnmK5MGRVb2jUWoQEhmJa+4UIDQrFiLX9UalJOWyZsgP7lh/5qseIKD1g/EAUifFD8ijJ+CF5kiA//PADGjVqJMf0KFWqVFR3mBs3bsgxQTp27PhZ2wkODsbQoUOxefNmhIWFwdzcHD/++CPmz58Pa2vr5KgqUYrxfO2DsU1mIywkHN2mtEXVZuVQvXkFLBm0Hl6vfeItFxYagUnd16DH2GZRy8Z0WCF/aJSo5IIWPWth0ag/5fIFI36XCZF4txUSjvHNZqP37E4xlrcf2Qx3zj9Ilv0k+pSbb9zR8fcd8v6MRg1w7NETeb9P5Qq4+up11HqzTp6BWquFlakp/ujYLioJEnzpLkyzZkTWgW3hu/8sgi7fhU2VEgjccwouGe3Qa9cJKPLmwKRLd+E4tisUKhXezt4Ey4n54k3W12heHu9eekctazusMe5eiP1DPy0ex14Vy2PUoSN46u0jj+OGK9cREBb24ful9zr0+LlJ1Po9fm6MZRN2w+vth/G4ugz/Fgt+3g5frwBMXdczziSI24PXGFJjvLzfaUJrVG9REX9vOYN1v2zDzTN3ZRKWiBKP8QNR4s57jB8SdpPxQ/IMjLpo0SI0bdoUP/30E/Lnzy9neRFdYcTjxo0bY+HChZ+1neHDh+Phw4c4fvw4Xr9+Lf8Xg6SOGGHYCPhEqYHPWz+ZhBDUEZFj3Dg6Z0Gf2R0x58hYFK1cIM5yWo0Wft5BMZaJBIggrtQ+vx85w4O4yvvT7HaYvqUv8hbJEf+2PANiLMuWJwtEY613L7ySYS+JPp9KoUDpHNlx2e0lnOzt5N/ha/8Pf58iASJYmprisdeHBEWEhzfM3s8QY543O0LvP4eJmzu+vXgH1Tx88M3luxj+599wcXsLW5USSgsz6HRaaPxjfo706rStgrN7r8jWVYKjc2ZAB3i4eaWL4/jYywu25uYwUSqh1eoQplbH+/2iMlHC0Skjeo1pipmb+6BImcgWmhmz2OG1qyeCA8MQ4BsMOwerWPXQqD+M3WVhZY4X9yNb0Hi7+36xfScyBowfiGJi/JA8VEYcPyRLEsTExASTJ0/Gixcv4O3tDVdXV/m/eCyWi+c/x/79+7Fr1y5UqVJFji8i/t++fTv27duXHNUkShVE15OydYvj/qXHyFciF1aP3oaZXZbLrjKfyz6jNebtGowB01rh1qWnctlv0/djWIvFWDlxNwbPaPPZ22o3shl2LDiYpH0hMkQV59y45PZS5BvQu1IF2eXlY/ObfItD3Tvj3HPXqGWmObIg5E7k373o8qINCkXGX/dgSlAIRMdMU60OKp0OthFqNN19EhrfQES4eUAbHBpr+0qlAjVbVsTpnRejlrUb1hg7F/8v3RxHcaVseYumONqzKy66uSE8gYHG7RyskbdQdvw26yDmDN2GPuMiW6BF7/EaFBAKW/vYQYxQtn5JrLw6B6VqF8ebJ2+TaxeJiPEDURTGD8mjihHHD8mSBIlOdIVxcnKS/yeWuJKtVMasknj8uWOKEKV2YuyPn9f1w7zev8oWGS8fucPzlbe8yiOyoKK//ecQmdcRrZZgWt8N6DryO7lMZFeFl088on7cfUr2fJGDGb91fWfAXhElzbeFC+J/9x8idwZ7+fhVHNOhDz/4P3yzZgP6Vq4oExyCVdlCcgyQN1PXQhcaAV1YOKxDw5H7o8/PfKUC+//5D57rD8A0lyNU9jaxtl+3fVWc2X0p6jyTPW9W+f/bF57p5jiOqVMT7bf+iXqr16HQ/9m7Ezibyj+O49/ZzWDGvu9L9l2W7CKJVEQlKpVSSmRJStosWSJFSkTRLimVqBQlSaWE7DtjN4vZ597/63nmP9MMgxkzY8acz/v1uu69557z3Oece8f53d95FtNSs3Ch85Z1JjRSB/cc0/HgEJ06Hqb4eJf9fyn5eThv/jwKC0n4/8boMaSrJn//rL3/49u/9VCjEVq96Bfd8ECHLNlfwImIH4D/ED9kjs4Ojh8yLQny7bff6tlnn9Wnn547sOPDDz+cpjK6du2qW2+9VevXr9exY8f022+/6bbbbrNdbYArnUlKjJz/sBaMW6yD24MVExWr8NMRCgj0t02/fHy9bdOyi5bj5Zk0EPGZsEhF/b+LTUA+P3sfVDiffPy8bbO1i6lct5zK1yqrcV+OVMMOdfTYzPvl5e2V4X0F0tIEs0GpkvYKRPViRVW1SGHN7dldLSqU1wudOtiml75eCd/FqLg4nYmJsVcqDA9PTxW+6waVHH2fPPP7y7dCSe2KjlXXeJdWSBpgusxIauKW7u7UTEXu6ybvQoHy9E/4G0mufPXS6tC7hcYuHqrSlYtrwhcjVL5GafvctNgaNO2eHP03kZbj6HK7FRadcPzMcTRNW88nJjpO4aGRtqudn7+PvH287P9LJ4+FqVT5Ivb/mfwFAhR66r8gZtHUpRrW/ll9nmzQ0zMhEXZQVAAZR/wApO+8R/xwcV4Ojx8yZWDUt99+247n0a5dO82ZM0czZ87U4sWLlT9/fvv6ggUL7LKLefnllzVo0CC1atXKDozq6+ur3r1724FRgStd61ub2XE/zOCAdz55s5a++Z3mjflILyweJm8fb81/7pPzbvv8vP6qVLO0ylQupnXfbVLDVtXsf0xmDIMZoxfZdYZP62P/czFJktkvnr8L2dgvnlDleuVVplpJffnmd3q87bMJ2895SB+//EWKfnlAVmlWvqztg2pOrMu37bA346UbOtnmmGY8kNduvlEF/fPYE/Fra/6b0STudJiOTf9Q8vKUf+3KKnBTGwV0aaHpo9/QuANHNdjTQ55uaUT+AM3asE3urftU+J4uqdZjzjMfJT1+ddWzerR1wt+DMXTW/fpk+tc5+m8iLcfRzAYzp+ct9vHuk6e04VDCOEKJnn/rXlWqUUplKhXVV++v1fwpy/Tc7H42gHl36jd2nflTvtbjL/Wy/7+8Oy1h2dkadqyrXsNuksvlUsixUE3qN8Muv3dcbzW/sbHdtmTl4pr1+PwsPy5AbkL8APyH+CFzNHN4/ODhzoS+JjVr1rSJkKZNmyoqKkr333+/HdB0xYoVCgwMtMmQsLCUgzFeiKmSaQliBlg939S7ZwsNDVVQUJCdlca8J5ATXOeXtpmRzserRELT/IyIO5jyP6z0WhH3QYbrACSq8tLLGT4YrvKRqS4PiIrWXd+sVZljp3SgaEG906mZIvKce9Wi6v0Js8xkxDfh86/4Y1l1dsb+b4jbtSdj27tj9YOWZPt5m/gBORHxA5AS8UPmqUL8kDktQQ4ePGgTIEaePHlsy48BAwaoffv2NhGS1kSGYZIlX375pQ4cOKCyZcuqc+fOJDUAABdlEh6zbmrDkQIAAGlG/OA8mTImSOHChbVnT8orQrNmzVKTJk1sIiQu2XQ6F7JhwwY7xa4ZW8RMj2vuq1atqj///DMzqgkAAAAAABwsU5IgHTp00Lx5885ZbsYBueaaa2wXmbQw44GMGjVK//77r77++mtt2bJFTz/9tF0OAAAAAACQ7UmQ1157TSNGjEj1tRkzZpzTSuR8/vnnHz3yyCPnzCxjlgMAAAAAAGT7wKiZxQywOnv2bLVo0SJp2S+//KJ7773XtgpxwsBmHT17ZriM6M5XZ2j7gF8yPmjgspNvZbgMZM73Ifa6xhna3isyYzNjfPfjqAxtj9ylo/ftGS7Dq0qFjBVw4lSG67Ds2BsZLsPpcsp5O6fUI6OIH5DZ3wfiB+QkxA/IzPN2pgyMmllMVxgzEGrfvn1VoUIF24Jk4cKFevXVV7O7agAAAAAA4AqXKd1hMkufPn3szDCxsbFauXKlvf/8889tUgQAAAAAACAjclRLEKNVq1b2BgAAAAAAkGuTIF5eXrbVx1tvvSVv7/+qZvr6mL4/Tle1YSU9NPUeuV1unTpyWuP7TFd8XOrjNVQsX0TDHrlO8fFuRUbF6NkJnytfXj89PvA6Bfj76s+/92ne+2t0S5cGur1HE23dHqxnxi9JtayrGlbU/c/eah8XKh6kdd9uVNV65W09vH299MqQd7R3y6Es3Xck8PT01Ij5j6hI6UI6sueYXn5glv0OmOeDZvRXQKC/NvzwjxY8/0mK78LjgzopPt6lyKhYPT9uib0vVjS/Fsx5QA8+Ol+79x7XYw93UJXKxeXl6am3F/yk337fnVRG1atKaOCjHeUy371TZzTuhSXq3qOxWrWprsjIGE0cv1QnToRrxMiuKl+xiKIiY/Xr2h366INf+ehwQf758uil5U+rQs0yGtTiae3ZdMAuL1q2sOb9O00DmzyZtCzFdnl9NX7u/SpfpbgG3z5TB/cc17g599nXfP285e3jrUe6T9fQ8T1Vvkox+51c98O/+mTuqnPK8vDw0OOv3q2S5YvIjJL18qB5uuPxLmrSsY4WTl6qL+b8wKeIKxrxA4gfkNtkd/xA7HBly1FJED8/Px09etROubt48WIVLFjQLs9BY7dmq+MHT+rJ619UdGSM7h17h1rcfLVWfbI21XX3HTipgcPfs4/vueMatWpeVc2urqwpM5br+InwpPVW/rRVv/6+WwP6tTnv+277Y7dGdJtkHw9+5W798uWfmjPmE/vju841V6n7Qx01ddD8TN9fnKtl9yY6vPuIJvSdrl7Du6ll96b68aM1emBiX73y8GydOHQy1e/Co0MX2sd339lCLVtcpRXfbdIdvZrpn80Hk9b76NPfdDg4RPny+WnS2F4pkiDHj4fpiWHvKzo6Tvf1b6N219ZU0+ZVNGjgO6pWvaT63N1Sr7y8zK47acKX2rP7GB8f0sT8fza620t64KU+KZbfPrybNq3Zev7touI0ZsB83T/iBvs8LjZeI+560z5uf2N9lSxXOGndKaM+0d7tR85bVuU6ZeTj661hN05WgzY1dON97TRv7GJtXLNNefL68Uniikf8AOIH5DbZHT8QO1zZctSYIKb1x9KlS1WrVi01a9ZMO3bsSMq0Qbb1h/mDT/yDjY9znfewmKv+ifLk8bE/hEsUC9TA+9pp2rjbVLtGKfva6ZAIuVznLyc5Ty9PVW9cSf/8sj2pBUpAfn/tTvZDGlmrZKXi2rkhYcrp7X/sVp1WNeTl7aXiFYrpwcl3aeK3Y1Sz+VXn/S74+Xlr3/4TKlE8yGQXdfTYfy2sTALEiI2Nl/usr8Spk2dsAsSIi3OpSOF82rPneEI9tgerdp0y9rFbbg0d3lkTp9yhSpWLZdVhQC7iincp5HhYimUlKhS1LTKO7Ttx4e1OnUn1tVbX19XqZRuTkuiDX+hur/JUrFYy1fWPHTqd9DhfkL9CToTr5BFaHyL3IH4A8QNym+yOH4gdrmw5KgmS2FxvxowZeuihh+xUuatWndt02emKli2ihtfW0dqlv19wvcb1y+ut6XerQZ1yOn4yXJUrFtXMOSv1/KSlerT/tel+3/qtq2vjz1vtfwpBhfNpytcj9cjkO/XPmoxPqYu02bfloBq0r20fN+xQV3mDAhRUJL8q1i2nN4e/o/F3vqKHpvY7Z7tGDSpo9mv3qEG9cjp06LR692qqDxetS/U97r+7tRYtWZ/qa8WKBaphowr6+qu/Va1aSfn4eKlRo4rKny+Pff2Nmd/r0Yff0auvLNeQoZ35WHFJbhveTR+/vPSStjXNXIuWCNK+nUft89kTv9KQ21/XzBc/16Dnbkl1m9AT4bZ73+w1z+m+Z3poxftr+OSQKxE/OBfxA5zgcsYPxA5XthyVBEne7WXw4MGaM2eObrnlFkVGRsrJegzpqsnfP2vvTcuLke88qkn3zjzveCCJ1m/Yq/sHzdcPP29Vp/a1tP/gKR0zVzhPnVG8yyUvz/S1sGl1U2OtXpKQeDFXSod2nqAX7n5d94zunqH9Q9q/A6WqlFBsTJwmfTfGNtM3V/fCT0fo4LbDtrmzeW6+F6bVTnK//7lH/R+Zpx9Xb9VNXRvYZcGpXOm+vmMdeft46bsftpzzWkCAr0Y+1c12dwkJidDSz//QS5PvUJOmlbV/f0I3nNDQhL/V/f/PwHum8zsGmKuVxpG9l9alqlm7mlq78r/vb9jpCHt/4P9dtFL7TjZqX1MxUTHqf80YvXjvLD3wQk8+COQKxA8gfoBTXO74gdjhypajxgSZPz/luBJdu3bV999/r88++0xOtmjqUnszrWSeXTxcC174WAe3H77gNj7eXor9f5LkzJlo+8M2/Ey08gb42sFSvb29FO9K+1gr5kd1jasra/qQd+1jc9XUJK0iQiMUFRGd4X1E2r4DyfUd01N/fLvR/ngLP31GAYEBcsXF27ENTFO/RKa1huniYpyJiFahgvlUoXwRTXyxpypWKKrSpQpq8Ij3VadWGbVpeZWefu7Tcz9/Tw+NGn2T3p3/kw4cSEh4fLNso73Vq1/ODpaamCiJiIhRgQIB8vH1sgOpAulRuW45la9VVuO+HKmKtcupVJXiGnbtCxdN+iZqdX0dzZ/2TdLzgLx+ijgTraBCeRP+Ns7znUwMdsJDIpUvKIAPDbkC8QOIH+AU2RE/EDtcuXJUEqR793NbFNSrV8/eILXp1Vy1rqlmW4Pc+fSt+mLWcjsoZmoaN6igO3o0kcvttuN+jJ/6lbbtCNaEMT1sAmTOu6vteu1bV1f3rg1VplRBvTy2l4Y+/VGq5dVrVd0OEmgSH4WKBemJN/vbRIj5D2HGiIRBN5H1ChYvoKfeH2z/Q//ju43a9PO/dvnbT7+vF78YaZNd85754Jzvwm23NrGf3emQSE2Y8qXmL/zZvjZy6A368JN1dtyQxwddp8jIWE2ZcLsd/+OJ0R8nldGmXQ3VqlVa/v6+6nNXC32x5A+1bFVNQQUCdORIiKZPTThpPPl0N+XP7y8vLw/NmvEdXwmkydgvnlDleuVVplpJffnmd3q87bN2+fA5D+njl784bwDz/Bv3qHKNUipTsYi++nCdflq+UcVKFtDeHQlNWY0Rk25T/qAAeXp5aPZLX6Zazh8rN+vans00cclQG+i8+czH6vf0zWrWqZ5N+pasUFRvJvt7AK40xA8gfkBulJ3xA7HDlc3DnUumXjFT6AYFBSkkJMROqXul6uiZ8WbY0Z2vztD2Ab9kfIyPZSffynAZyJzvQ+x1jTO0vVdk2jLo5/Pdj6MytD1yl47et2e4DK8qFTJWwIlTGa7DsmNvZLgMp8sp5+2cUo+MIn5AZn8fiB+QkxA/IDPP2zlqTBAAAAAAAICsQhIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjpCjpsiF5F2yRIYPw51TF2do+w87NuOjyCE8fHwzXMaerl4Z2t7/cMbrACRaEZdyCmcAmYP4AckRPyC3IX5AZqIlCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEdgTJAcyj+vn8Z98IjKVyupITdO0d6thzXk5TvVtEMtLXx5mb6Yt8qu5+PrrQEv9FCpisUUERalMf1m6IWeG3VwR6Se/rC2ylwVoPF3bpKHpxQX69Y9z1eyy2JjXFr44h4d2RMl/3xeGjSzmi1v+bzDWndkkdxyqWm5mzT1wxEqf1UJDbl5mvZuC9bEjx6R2+WWt6+Xpo/8yC576PnuqlyztLy8PPXu1GX6Y9XWbD56uVfVBhU0YHJf+xmcOhqiCXfPVMHiQXp0+j0KyO+vv37cogVjPz1nOw9Jkzt0VtnAILndbj3947ca3bKd/Ly85HK7Nfy7ZToQFqq+derrwQZX6++jR/Twss9TlHF1xTJ6qF1TeXt6at7Pv2vE9a11JDTcvvbGD+u0Zue+hPfykD4fdJfe//Uvvbf2r8t0ZAAAGYkdfjuxRCsbHLvk2GHDylMKPrKf2CEHys7YwSB+AJDTkATJoaKjYvXs3W/ovtE3Jy2bN+ELbVy7Q/4BfknLuvVrrXXfbtKvKz60zz09vPXYG9X10cS9SesMn1dD3j6e2r7qlH57cqd61sqr1w9Hq+EtRVX3+UpJ6+35J1wnDkerSfHbE8qK89Sz987WfaO6Ja3zZO+Zio9zqU7Tyrrl/jaaNuJDLZ79o4L3n1C+QH+9+O6DJEGy0PFDpzSq60uKjoxRv+d76ZpujdTy5qs1/dG3deLQqfNuV7NoMfl6eqnXpx+oZdnyur1mHT3z9efq/OUyXV25iqZ3uE59jh/TVzu26ce9uzXymjYptvf19lK/lo304PzFio132WUPtWumu+d8cs57dalbXYdPh2XB3gMAsip2aFSoq6KvWXJO7PDvulCteOuQXq7irw+/PaVuFfKo2OvVFJfXK0XsMGJ+TTuwOrFD7o4dTOIj7OQJjQmJ0Nz6DbR40Wf6wtMr1djBIH4AkBPRHSaHcsW7FHIy4Sp7olNHQ89Zr1G7mqrdtLJe+niQOvdpIU8PTwUW8kmxjglivM/Eq/Yzu9V20xlVWXRU/6wKUexze/RS701a+cERu96f351SbLRb6458os0nVyo+Lk4hJ8+kKMskQIyAfHm059/D9rFJgBixMXH2KgOyzqkjITaIMeJi4+198fJF9eBLd2rislGq2axqqtsFh//3XQr09VNYWJjeeG6chi1dptZ/b1L9nbu0eMqrijx9yl7dOVuDcqUUFRunmX1v0qt33qgi+QIU4Oujd+7vqUm9OivIPyG49vTwUKfaVbXsn21ZdAQAAFkRO/h6+Z8TOxgxx2PV6ecQNZi6X7//Ha5DS45rVovftWr+4RSxw0t3bSZ2yOWxw4nISJsAMfHCrT/9osoHDtk4Ys6LL8k3OjrVMogfAOREJEGucEVLFdCW3/foydtfU7ubG6lIyQLnrBN6MlaTuv6lEYdj1MYtecVJ+yW1CYnTvNZB+nXpcZ0MjlbIiVh5eXuoSfFb5eXhreCI7eeUFVQoryYvGqSBL/bQxnW7Urx29/AuWjJvdZbuLxIULVtYDdvX1r/rdqhSnbJ6c+R7Gn/3DNvcNTUnIyPkklvf3dlPT7ZoI585c1Ql+Ki8vLzk/fTT8nzlFfv87h9/TnX7wvkCVKZgoB5+d4k++m2jBl7bXHe+8aHueutj/bRtjwa2b27Xu7FedX3zz3a5SIYBwBUfO4y9/R+9N3qXrjsRK0+XdMAtXSPp+yiX/nonOEXs8MQ7NYkdcnns8Mm//9g4ocrxk/IaPVper7wiL7fbxg89fl2fahnEDwByIpIgV7jwkEht+Gmrvfqzef1ula5U7Jx1TMuQj1oV0Ede0qj/LzPhTntPqcChGFVukF/Bu6MUkN9LNZoF2tcL5Smr8NiT55RlWoYM6zFdLw6Yp3uG35C0vGPPJnackB+W/JGFewvD9N99Yu5DmvzAGwo5HqYD24N1/OBJe6UnPi5enl7n/lm3KVdRUXFxunbh2xrw9RJ17XO3XGbwjjfflGbNknbtss/Lnjz3MzfCoqL1x95DtivM2p37VaVoIZ2OjLKvmVYfNUoWta1AOte9Sl/9zZgwAJAbYoenPqitV5sF6qlkscO1kry8pEb5vYgdHBY7jG7RzsYJHsliB8PED6VOh6T6vsQPAHIikiBXuM3rd6lyrTL2caWapXXk/11TEsXHue1V+fAyfirgkvL+f3kLSX+5ZJfv/zdCRcr4qWrD/Nr3b4R9PSzmmPy9ExIiicwJ0sP8cJZ0JixSUf9vWlm3eRW16FxXs55dfBn22Nk8PT00cv7DWjBusQ5uD1ZMVKzCT0coINBfeQL87GB3JqhNTUh0QtIiNDpa8YUKymvUKGn3bumjjxLKdru1v1ChVLfduD9YlYslvFazVFEFh4bLx0TBkhpXKKO9J0+rSP4AFc6XV7PuutmOH3JH03qqWercwBoAcGXEDoZnWT/ldf8XO2wwA2a6pE1RLmIHh8UOgX5+KjPg4RSxgy3f7dahAkGpbk/8ACAn8nCb4Z5zgdDQUAUFBSkkJESBgSl/vF9JOpd+NOnx8+8MUKVaZXT04El9teBnlalUTM2uq2OTEetXbtabz36qAkXy6/GpfRSQP49+/2Gz3p/2jQ5WWaD9W86ocGk/1WtbUJt+Pi1Pt1R00xm9HuVSNS/paLzU199T+6oGqHabAuo2sIxc8W7NH7NbGz/3ka9ngOoVuV4vzh9gA6SjB09p3Xeb1LBVNTtmhBn7Y8boRTqw86hmf/+kIiOiFRkerejoWD1z95v6eu/UbD2OucV1fnemeN62V3M9Mu1u7f7HdGiSlr75nY4dOKH7xt4ubx9vO7r7b9+knJFl25QGtpXG1I43qETefPL18tKklcu18NY7pZ9/lv0PYO1abZ8+TW+++bpub3i1KhQoqK0njqvvko+V53BCsqN303rqXOcq+/lP+eYnPdOtvSJjYhUTH6+nPl2u4JD/+g7f3KCmAvx87OwwW8YOuRyHCsAVJqect3NKPTIrfrjU2GH9iS8UF3goRexgLnyYH7hzj8bo6v3RCvaQ7o2XTuXxVNl+JdV1cNmk2OHI3kid3lgiQ7GDQfyQ+fHDpcQOxo6XG6aIHV746Qd9eMttiv31V/nHxMi1dq00apSOPNhfh59+WuUKFkqKHUxs4U/8ACCHnrdJguTgJMilum1l6v0yzeCoNRYGK9+BaNsCZMudJZJGd0/OjO6eUQQxWZMEuRQmCZKagOho27fXNG01LUDmt2mhCL//Zg9IlBjEXCqSIABycvIhp9Qjo4gfkBzxA4DcKjQTzttMkesgJuGx8YHS2V0N5BAm4fH6de2zuxoAgByO+AHJET8AuNIxJggAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHyHVjgtxU4G55e/hc0rYr4v+b7iu7xB0OznAZ7zeqlqHtPfPHZrgOyBzu2IRpiDOi6qBfla2YHQbAFYD4gfghNyF+AIDzoyUIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAAR8h1Y4Ik558vj15aPloVapXVoGue0p5N+zVszkNq2qWRFjz/sZbM/EY5XfHyRfXaugnau2m/ff5Cr5cVHRGtZz8dLp88PnLFuzT53pk6svdY6tuXK6LpPz6jvVsO2edj75qh0Qsekcvllo+vl6Y9Ok97txxMdVv/vH4a9+GjKl+tpIZ0nay9Ww+rdbeGuvn+doqOitGUwe/q+KHTGjiul8pdVdJuU61BefVp9HSWHQ+nq3Z1FfV/qY99XKhkQa37+g/Neny+5m2druMHT9rl7437VH98+3eav08hx0N108Dr1aFvG7ndbr03dpHWLv39vHU4XxnD5jyspl3//7c1Y1kW7D0AXB7ED5ceP2Qkdgg/HcFXPIsQPwCAQ5Ig0ZExGt1tgh6Y2Ddp2dyn3tffqzbLP28eXSn+/nGzXug1Jem5j6+3Jt07UycOnVSjjnXVa3g3vfrInPNuv/GnrXqx74yk5090naj4uHjVaVFN3R/ppKkD56a6XXRUrJ69a5buG32zfe7l7albHmiv4bdM1VX1y6v34M6aPuJ9zRiVMKBskVIFNHRaX4KYLLT1tx0a1v5Z+/jx2QO05rPf7OMzIRFJy9P7fTJufKiTHqg3VHkC/DR+2dMXTIKcr4y5T72X8LeV78r52wKA1BA/XHr8QOyQMxE/AIBDusOYVhIhx8NSLDsZfFpXmlotqunlH5/XvWPvsM9jY+JsAsSIi41XfJzrgtvXbFZVU755Uv3G9LDPTQBjBAT6a8+mAxc+fifDk56XrlhM+7Ydtu+5+bddqlC9VIr1W3ZpoJ++3JCBPUVaeXp5qnrTqtq4eot9nidfHk1Z+ZyeXPCY8hfMl67vk3FoR7D8/H3ln99foSdS/s2ktYwr8W8LAFJD/HDp8QOxQ85G/AAAuTwJkhucPHxK91R9VI+3eUYFigWp5S1Nkl7z8vZSn9G3avH0r86/ffBp9as3QkM7jVdQ0UC16NZIQUXy6+UVT+nRl/tq489b01yXvEH+igiLSnru6eWR4vUWN9TTmq9IglwODdrX1sZVm233FWNwy6c1tN0Y/fbNn+r7bM90f5/Mdm9tmqoZ68brs1fP/326UBkAgJwjp8QPxA45C/EDAJAEybF6DOmqyd8/q24Dr1dURLRdtnrRWlWuXzFpnSFvPKilb6zQ4V1HzluOaTUSHRFjH/+0ZL0q1ylnW8c83nGsXujzmvqNuTXNdTJ9dQPy/9fVwRWf8APcKFKygG2RcurYxVsR4NK/D+beaN2zuX78+Jek18P+32Jn1cdrVblehXR9nwLy+6tL/46656pBurfGYN07tvclfycBANkrp8UPxA7Zi/gBABw2JsiVbNHUpfaWfHyFOq1rat+WhOanvZ/qruA9R/XjR2suWI7ZPjI8ofWG6cO7f+sheXh42BYEZ0IjkwKktDi055jKVS0hbx8vOybI7mQDorXsUp+uMJfh+5DYlLVGs6s07cE37XNvH295eCQErHVb19ChncHp+j6ZQe5iomIUGx1rmzr7+PkkfUfSWgYAIGfIafEDsUP2In4AAAcmQcYuHWmvjJe5qpS+nL3C3je/sbH9IVmycgnNGjpfOVntltV1zwt32Blhgncf1bzRH6hwyYLq+0xPbfp5q+q3q63Na7dp7qj3Ut2+VvOqumd0D0VHRit4z3F9OWelJn71hNwut/3xO2Pouxd8/+fffUiVapVRmcrF9dWCn/TZWz9o4qLBiomO1eTH3klar0WX+hr3wPkHZ0XmMZ+5GQskMUmRr2Bejf1ylKLORCk2Ok5T7puZru+T6b+9atFaTV8z1v5dfD5z2TkJkIuVYdw7rneyv63idtYaALhSET9cevxA7JAzET8AQAIP94V+7VxBQkNDFRQUpLYeN8vbw+eSylgRnzDLSXbq6Hn+8RzSyjNv3oxtn//CA2umxdeHXstwGcic70N2W+H6OLurACAHn7dDQkIUGBiY7fUgfiB+yE2IHwDkVqGZED8wMCoAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwhFw3Re7p3lfLyzePrlTMpAG+DwBw+RE/IDchngSA86MlCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEfIdWOCJOrUtJqG9W6njo/N0p2dGql9o6qKjIrRs3O/0fHTZ1S/amkNvq21XC63fvlnj2Z/vja7qwwAALIRsQMAALlfrmwJ4uEhXdvoKh05GabCgQFqWbei7hv3gV5fvEb339jMrnPX9Y015q1lunfcB2paq7zy+ftld7UBAEA2IXYAAMAZcmUS5PqmNfTd79vkcrtVokigdh08YZf/u/eIbQFi7Dp8QvkC/OTl5al4l1sxsXHZXGsAAJBdOl9Ti9gBAAAHyHVJEE8PD3W8+iotX7fVPj9w9LRqViwhH28vNalZXvkDElp8/PDHTk18+EYtGnuPfv93v2Li4rO55gAAIDt4enrquqY1iB0AAHCAXDcmSJeWtbXit21yuxOeh4RHadEPf+m1oT20bd9R7Q0+ZZcPua21+k/4UIdPhGriwG6qULJQ9lYcAABkiz59+mj5r1suKXbYc/gknxoAAFeQXJcEqViqiGpULKnOzWuoXLGCevz2Nnr5gx+19OfNalStjE6FRdj1TFeZ8MgYG/BERMUwJggAAA5Vs2ZNtW5ZR11a1iN2AAAgl8t1SZDpH66Ul28e+/idZ3rbBMi4B29QgfwBCj4RqpcWfG9fM7PBvDL4FsW7XPYKzz+7DmdzzQEAQHYYOXKk6m+Mt/EDsQMAALmbh9ud2PjzyhYaGqqgoCDVv3NsUhIkvdbPfTzT6wUAAM5/3g4JCVFgYGC2HSLiBwAAnBU/5LqBUQEAAAAAAFJDEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAj5LrZYfyPxcnbJy67qwHkGJ1LPZKh7WMrl8zQ9t7bDiqjlh2ZmeEyAOBCiB8AAHAGWoIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwhFw3Jkil8kX1xOAbFR/vVmRUjJ596XPly+unxx++TgEBvvrz732a9/4aPTm4syqUK6Ko6Fj98tsuffDpuuyuOpBl/PP6adyHj6p8tZIa0nWy9m49rNbdGurm+9spOipGUwa/q+OHTqtWk8q6/5lb5Ha5tf6HzXrv5a/t9lWvKqGHB3WUy+3W6ZNnNO75Jep6U0N17FRHbrm1cP7PWrtmux4Z3ElVqhaXl5en5s9dpfXrdp1TF09PDw177W4VKVFAR/af0LShCxUf51LR0gU155dn9eh1E7T338N8GwBcVsQPAAA4Q65Lguw9cEIDR7xnH99zxzVq1byqmjWurCkzl+v4ifAU60545Wvt3ns8m2oKXD7RUbF69q5Zum/0zfa5l7enbnmgvYbfMlVX1S+v3oM7a/qI93Xrwx1sQuTAjiOa/NkQLXnrB52WdPx4mEYOfV/R0XG694G2atHqKnW7paH63zNbefx8NGHKHTYJsujDX3X48Gnly5fHLkstCdKiS30F7z2uiQ/P060DO6pFlwZateR39XrkOm3+7dz1AeByIH4AAMAZcl13mPh4V9Jj8+Ns34GTKlE8UAPva6dpY29T7eql7GtutzT80U6a8kIvVa5YNBtrDGQ9V7xLISf/SwKWrlhM+7YdVlxsvE08VPj/34VZljd/HpskMdvERMfa5adOnrEJECMuzmVbWh08cEp+vj7yD/BTaGikfc0kQIzY2Di5zR9ZKkqUL6Kd/xywj3du3KfaTSureLnCdv1jB05m8ZEAgNQRPwAA4Ay5riWI0bh+eQ3o19YGNJ988bsqVyiqMeOX2B9u45/prgcff1cz565UaFiUypUppCcH36CHhi3I7moDl03eIH9FhEUlPff08rD3vyz7W0/Pvl+xMXH6/tPfFPv/xEeiYsUC1bBxBS2c/5MKF86nOe8+aLedNO6LFOuZ1iKLP/kt1ffevz1YjdrW1M9fblD91tWVLyjAtgL56NVv1GdYlyzZXwBIC+IHAAByv1zXEsRYv2Gv7n9svn74eas6ta+l/QdP6diJcJ08fcYmRrw8PWwCxDAtRRLHKQCcIvx0hALy50l67opPaLVx/5hbNOyWabqvxfOqWKO0ylYpnrSOGVPnidHdNGn8Uvn5eeuGbg10d++ZuvfOWbr3gXZJ63W6oa68vb30/bebUn3vX5f/Y1uKvPTpYOUJ8JNfgK9dfmQ/rUAAZC/iBwAAcr9clwTx8fFKenzmTLQiI2MVfiZaeQN8bfcY8+Ms3uVWgH/CD68CQQF2G5cr9ab7QG50aM8xlataQt4+Xqp5dSXt3nLQLjcDop4Ji7RdUyLCo5Q30D8pSfjkMzdrwbyfdHD/STtAqmktEhsTbwcX9vXxkoeHVK9BebVqU10zpi8/73ubst98ZpGe6D5NYSfPaOfG/XbA1hffH6gGbWpo0MQ7bHccALiciB8AAHCGXNcd5uqGldSnZ8uEWSxCIjR+2lfatiNYE8b0kLeXl+YsWG3XGz2sq/Lny2Ob8s+cszK7qw1kuefffUiVapVRmcrF9dWCn/TZWz9o4qLBdtyPyY+9Y9dZ+PLXeuHdh2yLqQM7j+jfP/ZIlUuqTbsaqlW7tAICWqrP3S31xWe/a9UPW/TqrHtsgmTJ4t/tODuDh3VWZGSMJk29044hMmr4B+fUo2DRQD35xr32Pf5c9a8+enV50iw0Q1/pq09e/9bOFgMAlxPxAwAAzuDhPt/ohVeY0NBQBQUFqfl1z8nb579m/umxaumITK8XkN06l3okQ9vHVi6Zoe29tyW0MsmIZUdmZrgMADnzvB0SEqLAwMBsrwfxAwAAzogfaHMOAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHCHXTZG77OPB2TrKPJDTuAPzZWj759+dk6Htx1RqlKHtAeByIH4AAMAZaAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEXLdmCAAzuWf11fj596v8lWKa/DtM3Vwz3GNm3Offc3Xz1vePt56pPt0DR3fU+WrFFNUZKzW/fCvPnhrhfrffEi7t8fozU9LqVI1X7tN8ME43d5+v+Z+Xtoue3HYMbuOv7+nmrfz150PFtDJY/F6ZtBR7Xb/IB/5qo6aydMjZd61Qq2yGjzrAcXHuRQZHqUXb5+qqDNRfIQAAAAAsgRJEMABoqPiNGbAfN0/4gb7PC42XiPuetM+bn9jfZUsVzhp3SmjPtHe7UfsY08PH02cU1wzxp9MUd7CWadVt76fin0YpkpRbgVsjdHTLxRWxfp5ktZZviRc13bNqw2/ttUO9z86rmAVU6kU5ezfekiDW422j/s8c6ta3tJE3y5YlYVHAgAAAICT0R0GcABXvEshp86k+lqr6+tq9bKN9rHb7dbgF7rbViIVq5W0LTcKFvZKsf6h/bHyiJeq/xujkvNCVezjMOX/J0bT7wjW4DsOa/vmaLte+So+ighz2cdxipWvElqRJBcfF5/0OE+An/b9ezBT9xsAAAAAkiMJAji8m0zREkHat/OofT574lcacvvrmvni5xr03C2pbrNgVogGB3rIO9QtD7fkGSdNlrQ2xq3xtXw18akTdr3qdfy0fMkZ/eJerjMKVZD+a22SXMMOdfX67xNVr21tHd6Z0AIFAAAAALICSRDAwZq1q6m1K7ckPQ87HWHvD+w+Zu89PT1SrH9gb6y9rxLqljvZSya94faUakW47fP4eLfenx2i2+8PVHOP61REJXVQu1Ktwx/f/q2HGo3Q6kW/6IYHOmT+TgIAAADA/5EEARys1fV1tHrZ30nPA/L62fugQnnl4+stlyshqZFox5YY7d4Wo9vWRupbtzRAkkmLhErycEkHC3kqNsYtL6+EDElggYSuNN7ysV1izmbeI9GZkAgGRQUAAACQpRgYFXCI59+4R5VrlFKZikX01Yfr9NPyjSpWsoD27kjoCmOMmHSb8gcFyNPLQ7Nf+tIuG9ovWNs3x2jfrljd1Du/Xv+4lDzPuPTaNfv0RJhJeEh94qTjvh4K+ylSjz5VyG7X465AO2vMLvcP8pCHnR3mbA071lWvYTfJ5XIp5FioJvWbcRmPCAAAAACn8XCbkRBzgdDQUAUFBSkkJESBgYHZXR0gx7i++sgMbf/Mso9SXW4SISXfCZXf/jhFl/XW4bsC5cp7buOyMZUaKaNWuD7OcBkAcpacct7OKfUAAACX57xNSxAAl8QkPA4+VICjBwAAAOCKwZggAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIExQYBcLn7bzgxt/3yT6zK0vYdfeIa2BwAAAIDMQksQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjsCYIIDDtbu9hR5+5V71LH7fRdf19PTQsBn9VKREAR3Zf0LTHn9XLbo00C0PXqvoyBhNfnS+jh86dcEyKtQso8deu1fxcfGKDI/W2L6vauxnw+VyueXt66VXBs7Vns0HMnEPAQAAACABLUEAB/Pw8FCrHs10bP/xNK1vEh7Be45pxC0va++2w/Z59wEdNPymKXrnpS/U+/EbLlrG/m2HNaT98xp23VhtXb9TLbo11ojO4zW801jNHf2Ruj96fSbsGQAAAACciyQI4GDte7fU6kVr5Xa507R+iQpFtHNTQiuNnX/v0w13tdLerYcUFxuvzet2qmLN0hctw7QASeQX4GuTIonL8gb6a/em/Ze8PwAAAABwISRBAIfy9PRUm57X6IcP16R5m/3bglW/ZTX7uH7r6vY+IiwqRZlp0bB9bc385UXVa1NTh3cdUVCR/Jr6/TN69JV7tPGnreneFwAAAABIC5IggMP0GNJVk79/Vr2f7q4fP14jtzttrUCMX5dvVGxMvF76dIjyBPgpPCRCAfnzJL3ucrnSVM4f3/+jh5s/rdWL1+mG+9or5HiY7SLz/B2vqN9zvS5pvwAAAADgYkiCAA6zaOpSDWv/rE1idOzbRuO+ekqlq5bUgJfvvui2JmHy5jMf64nuUxV26owWv/G9yl1VUt4+XqrZpLJ2p2FAUx/f/8ZjjgiJVNSZKDs2iXHGPI/4r2UJAAAAAGQmZocBHOqtkQuTHs9YN0GzHp9/0W0KFgvUk2/cr/j4eP3547/a9OsOffbm95q0ZKhiomI16ZF5Fy2j4bW11XNIFzsbjGkBMmvEAk36ZpR9bsYmeW3wxcsAAAAAgEvh4U5PW/gcLDQ0VEFBQQoJCVFgYGB2VwfIMTp69szQ9l5FCmdoe1dYuDJqeeSCDJcBIGfJKeftnFIPAABwec7bdIcBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjsAUuUAut8L1cXZXAQAAAAByBFqCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARvJVLuN1uex8aGprdVQEAABeReL5OPH9nF+IHAACcFT/kmiRIWFiYvS9btmx2VwUAAKTj/B0UFJRtx4v4AQAAZ8UPHu7svgSTSVwulw4dOqT8+fPLw8Mju6sDAAAuwIQfJoApVaqUPD2zr3cu8QMAAM6KH3JNEgQAAAAAAOBCGBgVAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkATBFc/tduuBBx5QoUKF5OHhoQ0bNmR3lYBstWfPHv4WAOD/iBOAjKlQoYKmTZvGYUSuQRIEV7xly5Zp3rx5Wrp0qQ4fPqzatWvrSvDmm2+qbdu2CgwMtD9YT58+nep6X375pZo2bSp/f38VKVJE3bt3T/H6vn37dOONNypv3rz29UGDBikmJibFOt98842aNWum/Pnzq2jRourRo4d2796d9Lo5br1791a1atXk6empwYMH63JbuXKlbrjhBhUuXFgBAQGqWbOmhg4dqoMHD9rXf/jhB3ucEm9mPzp37qy//vrroidps8y8lh6bNm2yx8lsZ94vtXKfffbZFHUytxIlSiS9HhsbqyeeeEJ16tSxn0+pUqV011136dChQynKiY6O1qOPPmo/P7Net27ddODAAeUU5u+rQIEC2V0NALgkxAnOiBMudK4yy83riZKft81xqVq1qu655x79/vvvqW5vzsm+vr6qXr36JdU9KirKlm/iAW9vb918883nrHN2nJN4+/fff1Ost2jRIrvvfn5+9n7x4sXnlDVz5kxVrFhRefLkUaNGjbR69WrlFFyoQU5AEgRXvJ07d6pkyZK65ppr7A9Qc3I529kn+5wgIiJC119/vUaNGnXedcyJrm/fvurXr5/9sf/zzz/bICRRfHy8unTpojNnzuinn37SBx98YLcxQUGiXbt26aabblL79u1tKxkT6Bw/fjxFMsX8CDdBz1NPPaV69erpcnvjjTfUoUMH+/mZ+m/evFmzZs1SSEiIpkyZkmLdrVu32mDMJIdOnTplj6FZLys+n0qVKmnChAkpEhtnq1Wrlq1P4m3jxo0pyvjjjz80evRoe//pp59q27ZtNsmRnAkmTRBjPj/zOYaHh6tr1672881NzP64XK7srgYAhyFOcFackFZvv/22PW+bix4zZsyw515z0emdd945Z12TQOnVq5c9r5tY7FLOf+ZilklAmf24kMQ4J/FmEjSJfvnlF9122202NjRxobk39fr111+T1vnwww9tXGE+qz///FOtWrWyF43MRbPcxlxsAi6JG7iC3X333W7zNU68lS9f3i5v06aNe+DAge4hQ4a4Cxcu7G7durVdPmXKFHft2rXdAQEB7jJlyrgfeughd1hYWFJ5b7/9tjsoKMj9xRdfuK+66iq3v7+/u0ePHu7w8HD3vHnzbPkFChRwP/LII+64uLik7aKjo93Dhw93lypVypbdpEkT98qVK9O0D2Y9U/dTp06lWB4bG+suXbq0+6233jrvtl999ZXb09PTffDgwaRl77//vtvPz88dEhJin3/88cdub29vd3x8fNI6n3/+udvDw8MdExNzTpnm2D322GPuy2X//v1uX19f9+DBg1N9PfG4pHacfvrpJ7ts2bJl9rn5fKZOnXpOGWZZ4nfjUpyv3DFjxrjr1auXrrLWrVtn67x37177/PTp024fHx/3Bx98kLSO+TzN55q4X6kxn+eECRPclStXtsevbNmy7hdffNG+tnv3bvsef/75Z4rvdXKLFy+26yTasGGDu23btu58+fK58+fP727YsKH7t99+SzruyW9mv9PyvU/+91SjRg23l5eXe9euXXadq6++2m5jXr/mmmvce/bsSddxBIC0IE5wTpyQ2rkukVluXk9kzmXmPHi2u+66y54DT548mbTM5XK5K1WqZM/JTzzxhLtfv34Z/k7edNNNaY4Hk+vVq5f7+uuvT7GsU6dO7ttvvz3puTkXDxgwIMU61atXd48cOfKC9VqyZIm7UaNG9rthYudbbrkl1Tjo7BjDMHU2yxJjAHP8evfu7S5SpIg7T5487ipVqrjnzp1rXzs7pjDfp0RmHVNXU4dq1aq5Z8yYkfRa4vt++OGHdhuzjlnfxA9du3a18bmJK2rWrOn+8ssvL7ivAC1BcEV75ZVX9Pzzz6tMmTI2W/7bb78lvTZ//nzbKsRk7M0VBMM04Zw+fbr++ecf+/r333+vESNGpCjTZPnNOuZqiWlCa5onmqshX331lb29++67tivLJ598krSNaalh3sds8/fff6tnz562hcL27dsved9MywHTxNPUuUGDBra1i8nkmysWya8ImO4/pptFok6dOtkrNolNOhs3biwvLy97xcNciTBXTcw+XHfddfLx8VF2+/jjj21LnbM/h0QX6oZhrqpcypWAxCanpklmRpnP2Bx/0+z09ttvt1fULsQcf/PeiftlPidTf/N5JDLlmc91zZo15y3nySef1EsvvWRbmZgrYu+9956KFy9+yftx55132r8j8zdk6jRy5Ej7/TAtrExXINNtK/Gq1LBhw9L8vTd/T+PHj9dbb71lv7tm7B7TDLhNmzZ2G/MdNmP6mGMCAJmNOMHZcUJ6DRkyRGFhYVqxYkWKbjjmXGZacJiWFx999JFdJzlzDkve3SYjEmO+a6+91r53cuacmTxeSPw8E+MFc5zM53r2Oub5hWIK07rWxLqmdbFpPfLdd9/Z78WlSoxNvv76a23ZskWvv/667YplrFu3zt5/++23NqYwrWSN2bNn29YrY8eOtduMGzfOlmPi9eRMN2PTosasY/Z94MCB9vu8atUq2xrXxEb58uW75LrDGc7tNwBcQYKCgmz/VXPyPrvLQpUqVTRx4sQUy5L3YTU/Wl944QU99NBDtu9kIvOD1PxnXblyZfv81ltvtcHAkSNH7H+qpv9lu3bt7InJNEk0zWzff/992180McgwPxJNAsUEFOY/8UuR+GPajDvx8ssv27EpTJNP8+PRdKkwPyaDg4PP+eFbsGBB22/VvGaY7ZYvX25/oD744IM2wGnevLlN6OQE5gez+YFtTvjpceLECT333HP282/SpEm6tjV9iU2/5owGd4nNZq+66ir7/XjxxRdt0sD82Dd9llPrE2ySC6ZLk9lnw3xO5vMyn1ty5nNN/AzPZoIvE9i/9tpruvvuu+0y831t2bLlJe+LaSY7fPjwpP7OyZvfmr+zs8c7Sev33vw9mb+vxObTJ0+etAG26e6T+DdWo0aNS643AFwIcYJz44RLkXgOTH6RZM6cOfYih4k1TRdYE1+aLif3339/0jompjDftYww+2cuspkxPMyPehN7mkSIuXDTunVru05qcV/yeMF0YzKf34XWSY1JPJh9NHFVoox0ezIxhUnmJCZSko/LZrpVGSZOSh5XmJjcxLmJ3bBMnG4SKeZCZmKskxjLJ++qZd7LjGFjxlsxTFdm4GJIgiDXSi2DbRIX5seZ+U81NDRUcXFx9oep6StrBsZK/IGc+OMs8cRh/vNOnlU2y44ePZrUYsO07jM/hJMzJ7DUfginVeLYCSYrbv5zN8yPS3O13lwVMYGKkdoVdFOfxOXmpGdO1OYEcscdd9gf0M8884xN7pgrHZd6Bd4EAnv37k3z+n369LH9dy9U17Qw+2+Yz8z8UDfHolixYkoPkzQ5e6CxS2Fa5iQyJ18TNJrvjrlq8fjjj6dY1yQDTIBhPtfkSbfzudBxMVc/zPfLBEeZxdTXfE9M0GWudplgOPnfwdnS+r03gXbdunWTnpvknRkczly96dixo30v05/5cgS3AJAccULujBMyIqG3xn+xlRm03rRUMOOpJK/n3LlzUyRBMiOmMIkUc0tkYor9+/dr8uTJSUmQ5HVLXuezl6VlneTMWDD9+/dXZjEXGE3samIF0wrFtAA1F4nO59ixY3Zf77vvvhT1MHH62cmls/9uTasQ834mkWdiCvO+yeMOIDUkQZBrJSY1EpkTsRlVfMCAATbbbH6MmZOa+Q83eXeKs1sHmJNGassSkxTm3lwdMM0PzX1yGWmOl/ij0LQ8SWRGAjcZ7sTBrUwGPflgWIYZLNTsT+JVADPYl7mCkrxVzIIFC1S2bFm7rRkN/lKYK0Tp6YaS2PLhbOZHtGkZYJpEpuWHsBnh3JRlriScXaZ5ntogqSaIyegVmrR+50wy5OxuUOY4mR/6ZqR90wUreb3NZ2iar5rPLXlrEJNkO1/AkNgNKK1Ml6rEwC55nZIzLY5MCxXTJNY0Xx0zZozt5nLLLbekWmZav/emrmcHXiaZZ4IW02rEXE17+umnbaB9qd9FALgUxAm5K04w25vBTU1LiOTnJfPcLE9LHGAuMiS2QjBMV1Nzscy0/ExkzqfmHGguqCWP0bKCOfbms0geM5zdosPEC4kxn+lyYvb9QutkNK4wMYWRPK44+3M2F4lM3G1iCtPtxVy0Md1WTEInNYkxtekSk/xYG2fHGGf/3ZpklLmwYt7LJEJMF1zTosTMugecD2OCwDHWr19vM8rmP0ZzUjEn1bOnKr0UprmfOcGaE4xpIpn8dqFZRS7GNIc0SQ8zSnjyk4xpolm+fPmkqwRmfBMTGCQyJwCzndneMP1Yzz6BJD7PyEwdpg5n7++FbudrrWGuNJnWAmd3XUp09tTBJjAxLRRSC5ZMM9bk48IkMsuSX13JKqYVhAmgkgdpiQkQkxgxgcDZrYPM52SSbMn7H5vP03yu50uCmBYwJmAxfXbTwiSMzJU903om+VWfs5m/CdMf2nyHTFNTk6wwzOdz9kw1Gf3em+3NuCamj7Lpr24CTQDITsQJV3acYGIAc14yY1okZ1ojmOVpiQMSx8BKnMHFdIUxM+mYc2bizczKYrpFm9YgWc3sS/KYwsR9yeMFw5yzE+MFc5xMXHH2Oub5hVpimJYT6YkpjOSxZ2oxhVnPtPw0SRxzXE1Xn8Q6GsnjCpOgKV26tO0Kfvb3IjEhdSEmYWcucppWO+bzMskU4EJoCQLHMD+cTRLk1Vdf1Y033mgHdEyt2WV6mR+OZlDJu+66yyZYzI870yfTXPE3rQJM65PUmCy9ue3YscM+N4M5mfEtypUrZ1upmJOw+Q/dXJE3/7mbYGLSpEl2XdNVwTBNDM1VCDNQl3nNjLdgxmUwTQkTkwRmkKupU6faAWQTm7maaXlNeaauZ5/AzNUS0yzRPDcnqqy+ymH2zdTvkUcesV2UzHE03Y/MWBNmvA3TqiCt09+ZLh0tWrSw+2qCJsNMpWdaHCQfEMwMymXex5zwzUk3NaZ1hrnKk/jYDFJrjompjzkpG+ZYm++S+cxMMsCMCWL2IbHvqvm+mXqYAGzp0qX2hJ94dcZ8xub4mitTpjWSOWmbBIlZbso1353zTaOXJ08eOzCYGSTOlGH22XxmZiwSU9bZzFUV083LfO7myojZ/+QDuEVGRtrxQExdTbBhjr1JHCV2wzKfh/lemONl+gibsi71e29aw5hAyEwTbMYSMUk+M8aNKQcAshNxwpUdJ5h6mBYI9957rx1LzXyeZvwqExuY5WfX0yRPzDnZXMAw5yEz9sRnn31myzSDrZr9M+fvhQsXJo0VksgcJ9Nd2bQ6MBcyzOvm8flaTxompjDxhInVzDFOPJ7169e39yZRYPbLdCMy65nkgYlhzC3RY489ZrvGmME/zbTGS5YssRdYknfXMftr4kLTbcQkTcw517QgNjHl+ZhY07TWMMfMdN018YtpFZraYLTmIoy5mDhhwgRbX3PuNy06kzPdqUwyxuyLOb4mBkoc/8sku0wZJjYzXZxNTGNiIdMi1bQSNfGr+bzMdiYxaVrKnt3FODkzRohZ38QlZl0ThzDWGC6KCXJwpUtt+tPzTd/28ssvu0uWLGmnvjVTir3zzjsppiNLbXq11KZBPXt6MzOF3DPPPOOuUKGCne60RIkSdmqxv//++7z1NuWePU2YuSWfws2UO3ToUHexYsXslG0dOnRw//PPPynKMVOtdunSxe5ToUKF7PS9UVFRKdYx0+E1aNDAnTdvXnfRokXd3bp1c2/ZsiXFOqnVJSPTyqbXihUr7GdSsGBBO52amSJt2LBh7kOHDqV56rjEclq1amXLMbeWLVvaZckllmWmWzufxKnYLjSV22233Wa/T+YzN9PEdu/e3b1p06aLlpF8GjkjMjLSfm7m8zOfo5nqbd++fRfcTzOVoZkS13xG5v3LlSvnHjdu3HmnrzNTAZop6syxNeW/+eabSVPkmqluzfR6ZppdMw2h2RdTH1OvRGa6PTNlXvIpci/2vU/t7yk4ONh988032+Nm3svU35SRfGpGAMhMxAnOiBMMM+3vkCFDks535t5MrWumoz/fvpj1zHTzJrb7/fffk9Yxx8lMt5qao0eP2mnfFy1alFRe8vgtNeZYpXYME7300ku2HqY+ifFLalO9mimNzfSx5rxrjkFiHZIzU8ua9zPnWTPl/Y8//ui+GFNO/fr17TZmalsT06Q2Ra6xefNmd7Nmzex3ymyzfPnyFLHNCy+84K5Ro0bSd87EzLt27Urafvbs2TbmMNM3J4+rFi5cmFQHcwxat27t/vTTT88b2yR+Tua4mSlzzXe3b9++7uPHj190f+FsHuafi6dKAAAAAAAArmyMCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBG9dQVwulw4dOqT8+fPLw8Mju6sDAACygNvtVlhYmEqVKiVPz4xdryF2AADAGdxpjB+uqCSISYCULVs2u6sBAAAug/3796tMmTIZKoPYAQAAZ9l/kfjhikqCmBYgRkvdIG/5ZGtdPLwzfug+OzE3w2XcFHRXhsvwDPDPcBmuiMgMl7Ek5J0MlwEAuPKFhobaix6J5/2MIHY4F7EDAMDJ8cMVlQRJ7AJjEiDeHtmcBPHI+KELDAzMcBmZcRw8PXwzXIbLIy5HHA8AQO6RGV1fiR3ORewAAHBy/MDAqAAAAAAAwBGu+CSIf748mv7LOH0e+q4q1PpvvJBbH++qaT+9qAnLnlbhkgXTtF2eAD+7/pQfntOk78aoePmidnntltXtuq/8PFZ9nrn1nLKqNqioKd+P0eRvn9FT7z0mL28vDZ39oD46+Ia6PXSdLiczAMzIdwdp8vfPavjcgbYuxrA5D+vjI3N008Dr01RO257N9OGeV+3jbg920PQfxuiVlc+oaef6590mM48pAAA5LXbIrfFDZsUOBvEDACCnu+KTINGRMRp94wSt/mRt0rKCxQuoyQ2NNLjl03p79Ae6c/StadouPi5ek+6dqaFtx+iDCYvVa3g3u7zXsJs06Z7X9FiLp9SoQz3lDQpIUdbxQyc1qst4DevwvA7tDNY1NzXW26M/1OyRC3W5tezeRId3H9Gw9s9q75b9atm9qV0+96n3NHvEu2luPtTq5sY6duCkfd61f3sNvvYFPdltom4fduN5t8vMYwoAQE6LHXJr/JAZsUN2xQ8AADguCeKKdynkeGiKZcXLF9Hezfvt4+1/7FLtFtXTtF1sTJxOHEo4ccfFxis+zmUf791ywAYu5sqI2S4mKjbFdqeOhNgTeOJ2rrh4nQw+rexQslJx7dywxz7e/sdu1WlVwz5OT33a9Wqu1Z+tl9vlts8P7TwqP39f+efzV9jJ8PNul5nHFACAnBY75Nb4ITNih+yKHwAAcFwSJDWHdh5RtcaV5ePrrYYd6ipfwbzp2t6cWPuMvlWLp39ln6/5bJ2e+WSY5m6Zpr9+3KTY6NR/sBctW1gN29fW2i//VHbZt+WgGrSvbR+bfU9vCwtPTw+17t5EP37ya9Ky9d/+rdnrx+nVVWP02esrLqlel3pMAQC4EmKHKzl+yGjskJ3xAwAAjkmC9BjS1fZdNfdnCz0RpqVvrNCEb0arSecGOrD1UJq2SzTkjQft9od3HbHPH5x8lx5v/YzuuWqQKtYpr3LVS5+zTUB+fz3x9kBN7j/LNuG83BL3q1SVEvbqiemTnCevn04dSd9VnPa3X6NVn66T251wFScgfx7d0K+t+tV7Qvc3HKl+z57bPLj7I52y5JgCAJATYoeLbZvWc13Z6qVyVPyQWbHDpcYPmXFMAQBIrytqitzkFk1dam/ns3z+D/ZWt01NnT4akubtej/VXcF7jurHj9YkLXO53DoTEmFP7JFhkedcITFXP0a+M1ALxi7Swe3Byg6p7VffMT31x7cb01VO+eqlVbleeV17e3OVrlxcfZ/qbpvvmqtXJjjz8fO2fX4Tgxzj09e+0ScTF2fqMQUAIKfEDmnZNk3nusCcFT9kVuxwqfFDZhxTAAAckwRJbuzSJ1W5fgWVqVZKX765wgYwo94brAJFA3Vk3zG9OnBOmrb7fflf6vtMT236eavqt6utzWu3ae6o9/Tu8x9r7JdP2v6o+7cd0pZft8vD+79D17pnc9VsdpXt83rnqO5a+uYKVa5XQc26NpKXl4dKVSquWcPTPrBYRpiB3Z56f7ANOP74bqM2/fyvXX7vuN5qfmNjeXp5qmTl4pr1+PxUt5/zzEdJj19d9azeGPmebh3UWdO+H223/eLN71IEMJl5TAEAyOmxQ0bOdf+u25GinJwSP2Q0dsjO+AEAgPTycF/ojJTDhIaGKigoSG11k7w9fLK1LsmTIJdqecz7GS6jo2fPDJfhGZDxVhiuiIgMl7HC9XGGywAAXPkSz/chISEKDAzMlLKIHf5D7AAAcHL8cMWOCQIAAAAAAJAeJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCFfkFLlexYrKy9P3krff8lyFDNfB70jOOHReNapmuIzS8zI+xdy+phkuAgCALEPskOxYEDsAAByMliAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcIWcMbJFO/nn9NOmTYSpfraQGd5mkvVsPq3W3hrqlfztFR8Vq8mPv6Pih06rX4ird82Q3xcfF652XlurvX7YnleHp4aGpbW9Q8bz5dCAsVCNXfaPrK1bVfXUaKyouVo//8LUOnwnTNaXKafjVrRTncmnK+p+09vD+pDLqliqu4de2so+L5s+rH7fvUbuqFXUkLNwue/2ndVqze5+euq6tapQoKn8fb8355Xd9tXlbph6PKjVLacDIrnK53Dp9IlwvPfGhWnSopVv6tlB0dKwmj/pEx4NDdOMdzXRrv1batumgxg55T3Hx0Vq/932daXNMN869QflK5dN3I1YqPjpeHl6eajW6hfKXyqfgP49o3fT18vDwUJnmpdSgf337vpve36x9q/fLFedSVXdj5fEIOG8d293eQg+/cq96Fr8vU/cdAID0xA/jPxp0yfFDZsQOOSV+uNTYwTDxw+f9vtTpXaczFD9EuuNUW03OGz8QOwAAssIV2RLEBCpj7npdPy390z738vZU9wev1fDu0/TOxKXqPaSzXW4CmKd7z9BTd8xQn+FdUpRxfYWq2hd2Wrcv/VDbT5+wQcz9dRur1xfva8r6nzWoYXO7ngli7v76E9319Sca0qhFijL+PnREfd/9xN5+33dQ327dobDomKRlJoAxXvp2lfq887H6vvOJHmxxdaYfjxNHQ/XUA29rxD2zdWjfCV3Tvqa6391Sw++ZrXdeXaHeA9rZ9VZ9s1Ej75uTtJ2np48aluulCu3LJzz/f+DS5c3Oqnd3bW1c8I9dbu5bj2lpA52D6w4rOixGx7ecUHjwGXWe2cmuf6EEiAl+WvVopmP7j2f6vgMAcLnih8yIHXJK/HCpsUNi/NDx5WszHD809mh73viB2AEAkFWuyCSIK96lkBMJV0uM0pWK2as5cbHx2vzbLlWsXsou9/Ly1JnQSEVHxtjHgYXyJm1TLrCANp84Zh//c/yI7qxRT7uOHdX9X32n7lOmq42nrwKiouXl4aHQmGhFxsXKy9NDBf38z6mPWade6ZJav++g8vr6aMFdPTXlls4KyuNnXzdXggx/Xx/tOH4y04/HqePhNrCz7xUXr9IVimjvjiMJx+PPfapYtYR9LeTkGXvsEnl6eMrX+7/gw8vXS3mLJRwjT29P+bjd6jx/o1oGn1HjD7fIOzRanp4edr19q/YpPiZeXz/0jX6Z9Kvcbvd569e+d0utXrRWbtf51wEAIKfHD6nFDttPnZBPRKSunr9AHeM99dCylfKRLho7ZHf8cKmxQ2L84F8wT4bjh3/df543fiB2AABklSsyCXK2vIH+igiPTHpurkgYsTFxKlq6oAoUyW+bvuYN/O8H/47TJ2xzVaNl6fLydLnV7pd1Gv7ZMvVa85tKhYTps5deU3xcnErlza8i/gG6qmARBfolBCbJNatYVr/tPSBzGr993of2qs3qnXv0aJuEK0LG5Juv1xcP9NHPu/Zm2XEoWjJIDZpX0aY/9iriTHSy4+GRrnJM95a/3tygmesOq/vrf+rhXac0Y9FWLbv+I5WuW1Tefl6KPBlly+38eid55/HWER1ItSxPT0+16XmNfvhwTYb3DwCA7Iwfzo4djKiICBsvmPihcGSkva+y74Aqe/tdMHbIKfFDZsUOlxI/eMkr1fiB2AEAkJVyRRIkPCRCAfn+u8qSeMXijWc+0dBpfTVw/G3a8+8hnT4WmrTOd3t3KsYVrw+63qYAbx8VPHBQBbx85OV2yyfeJY/4eFU5fFR/T5usKW0764UWHbT15HEdjzxzzvt3rnGVvt6S0F/4dGSUvf968zbVKF40aZ1hny3T9a/P14Mtmij9YcXFBeT10/DxvfTyU5/o9Mlw+/y/45G+Fhg/j1ujXsUCdM3BcJsceiJeWi1pZ7xLnqv26/Tu0/LN56uSV5e065dsXEJn9N+xTe7aPq3048drLthSBACAKyF+ODt2CImJVv2TITZeMPGDZ1y8vfcd+IjevrrNBWOHnBA/ZGbscCnxQyEVSzV+IHYAAGSlXJEEObT7mMpdVULePl6qeXUl7d5yyC7f9tc+jew5Xa8+8b6OHz6tyGRXOMyp/YVfVtp+vaeiI7V34TtSzRqSj490zTXS33/L5ekhn7W/6o4vP9Ko1SsUHBGmM7EJTUeTN2WtX6akvZLj4+kpHy8vu/zqcmW099Rp+zhxWWRsnM7ExNj3zkymiemIib303uvf6+DeE7Zvb7nKxRKOR4Ny2r0tOM1lbZjzl/KVyq+b8vrK9f9vh7kLSthZFYhzKSY8VsXrFdXJbQlNc09sOyl//dfVKLnyNcuoY982GvfVUypdtaQGvHx3puwzAACXO344O3aYs3G9SpUoJZefb1LsYLj++F0/DXzwvLFDTogfMjN2uNT4IUynU40fiB0AAFnpipwdxnh+wcOqXKu0ylQupq/e/VmfzV6pSZ8OVkx0nCYNmm/X6fVIRzVqW1NREdGa+dTHKbYv6p9Xr17bVfEut346uEd/HNqvDtNekX78UYqKku66y17FKN3/QX1w7bWKiI3VmDXfnVOPphXK6rd9B21gEuifR7PvuFmRMbGKiY/Xk18st+u8fEtnFfDPI28vL81c/WumH4vW19dRzfrlFRDgZwcyW/rhr/rs3TWaNK+/YmLiNOnJhH1v07muuvVuplLlimj8W/dqVP+3tX7vBzpz9LBC9oaqXKsy+vOtv1S8XjENDD6jG+PcmiBpjKQbzJclzm2v4JSpXcSO77Fv9QF9NWCZ8hTIo0pqlGrd3hq5MOnxjHUTNOvxhM8GAIArLX44O3b4Lfigft6+T92+X5kUOxhew0eoZe/bVSIwX6qxQ06IHzISO5jWncsHf2svgmQkfnDJW7XV9Jy6ETsAALKSh/sK6qcQGhqqoKAgXVvsfnl7+l5yOVueq3DOMjMIqunTa5q0mhYgJgGyo2Qx3fzEI4r4/wBlyfkdyXj+aNvoIRku4/paozJcRul5CVe+kvOLiNWoe79SqT0h9oqOp0s6VCFI4+beoOgAM+RbSvuapt7UNz1WuFImqgAAzpR4vg8JCVFgYGCOjR3SGz/k9tghvfEDsQMAIDvihyu2JUhmM4GKCVju/mGNyh4/qf1FCml+22tSTYA4gQlUTMDS/uN/VeRQuI6Xyqfve1ZPNQECAIBTET+kRPwAAMjpSIKcFci8fn277Ps0cmAg8/XddbK7GgAA5GjEDykRPwAAcrJcMTAqAAAAAADAxZAEAQAAAAAAjkASBAAAAAAAOMIVOSaIR15/eXhe+oClVRbEZLgOPkeOZ7gMjc54EfFbtme4jEN3pD7iffpkfHYYAACyCrHDf4gdAABORksQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjnBFjgnin9dPE999VOWrFteQW1/VwT3HNXZef/uar5+PfHy99Ei3aera5xrden8bbf/ngMY+8m6KMipULKohwzorPt6lyMhYvfDsp2rWvIp63NpE0TFxemnc5zp2NEw+Pl565LHrVLpMIUWcidYzT32SrB6+Gv92f5WvUlyDb5th6zFuzn0J9cjjI2+z7S3TVa9ZZd0z5HrFx8XrnVeW6+91u7Lu2OTLo5dWPKMKtcpqUPNR2rNpv10+bM7Datq1kRY8/7GWzFiW6jEdN/+BpGO6d/sRFSkRpIHP3aKAfHn019qdeu/VFarVuKLuH9lVbrdb61dttcvOp93tLfTwK/eqZ/GEY2IULVtE87ZN18DGTyTVDQCAy+Hsc11644fMiB1yYvxwqbFDaseU+AEAkNNdkUmQ6KhYPfvAXN33RFf7PC42Xk/cOcs+bndTQ5UsV9g+Xv3VX/p91VbdO+KGc8rYv++EHhv4jn3c955Watmqmm7u3liDH3lH1aqXUp+7Wmnq5K90c4/GWvvLDv3y87kDkEZHxWnMg/N0///LN/UYcdeb9nH7bg1UsmxCPUwA8/T9cxQXF68X3rxXI/q+kXXHJjJGo2+coAcm9k2xfO5T7+nvVZttoJOWY2rc90QXvfbMpzpxJDRp2a3922jKiA90YNcxTf7gYS2Zt1pnwqLOKc/Dw0OtejTTsf0pB5C9/YmbtOnnrZmwpwAAXN74ITNih5wYP1xq7JDR+CEklfKIHwAAWe2K7A7jincp5GTqs5G06lxXP339l31s1jFXa1KTfHmePN46eiRUe3YfV1ycS5v+OaBKlYra165uUll16pbVlFf6qGu3BufW49R56nF9Ha1e9rd97OXlYRMF0ZGx9nFgwQBlFVun4/8FHYlOBp9O1zH18vZU8TKF1P/JGzX+3QdVo0F5u3zfjiPKmz+Pfd3lcikmOi7V8tr3bqnVi9bK7XInLStRoZjcbunYvkyYWQcAgMscP2RG7JAT44dLjR2StiV+AABcQa7IJMj5mCaZRUsGad+Oo2lav1Hjipr11n2q36CC4uLjFRERnfSap1fCoSlWLFCbNx3U8McXqn2HWipSNH8a6uGroiUKaN/OhHrExsaraMkCKlA4n8pXLaG8+f2V0wUWzKuK1UrqrQlLNXHIe3rw6W52+S8rNunpGXdp9vIR+vvXXYqNOTcJ4unpqTY9r9EPH65Jsfy2J27Sx5M/v2z7AABAZscPWRU7JNSD+IH4AQCQ1a7I7jDn0+zamlr73eY0r//7+t36/f45uu2OZqpXr7wCAvxSXNkwwsOj9Ofve+SKd9urPGXKFtLxY2EXrkf7mlr7/X/1eGPcFxo6oafCTkdqz7ZgnT5x4e0vRY8hXdX8xsb65Yv1WjR1aYbLOxMaqYN7jul4cEjS1S8T3N3/5I0advtMHT142iZDylYupv3/T/Yk1mHDD//ox4/X2HFDEpWsVNzeH9l7LMN1AwAgu+KHrIodsiN+yOzYIb3xw+5de1LUg/gBAHA55KqWIC0719XqrxOakF6MGbQs0Zkz0YqMjFH5CkXk7e2pWrXLaNeuhB/2mzYeUOUqCT/gzf2Rw6n1YE2p1fV1tXrZxqTn2zYe0Mi7Z+vVZz/V8SOhijwTo8xmgpdh7Z/NtCDGdHMJD420g6L6+ScM0maCO7fLZZvmmgSHGezNdI05uw55AvzUsW8bjfvqKZWuWlIDXr5bleuVV/maZe2yhh3r6rHXH5CX93+fAQAAOT1+yMrYITvih8yOHQziBwBATnfFtgR5/q17ValGKZWpVFRfvb9WP3+zUcVKFdC+7UeS1mnTpZ5u7NtCpSoUsSOXP3XP7KTWCaY5a687mtkxK06fjtDE8V8o5HSEpk7vq5iYOE0Yl9Bt44P3ftGIJ2/UfQ+01W+/7tLhwyn7xz7/Zj9VNvWoWFRfffirflq+UcVKFtDeHf/Vo1f/tmrU6ipFRcRo5otLsvzYjF36pCrXr6Ay1UrpyzdXaPn8H3TvuN72Kou5GlOycnHNenz+RY/p/CnL9NzsfjYB8u7Ub+w6C1/9Vi/MuU/xcS4d2H1M/27Yd045b41cmPR4xroJSe/10+J19n743IH6eMrndrR7AACuhPghM2OHnBg/XGrsYPeF+AEAcAXxcCfvs5DDhYaGKigoSB0qPipvz/+an6ZXTKkCGa6LT7IRzy/Vsq0vZbiMjp49M1yGd6UKGS4j7v9NWjNihevjDJcBALjyJZ7vQ0JCFBgYmCllETv8h9gBAODk+CFXdYcBAAAAAAA4H5IgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcIQrcnaYzBgtHgAAOGd2GGIHAAByN2aHAQAAAAAASIbuMAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHME7uysAAFeKzuWHZLiM+KPHMlyGOzYuw2WsiPsgw2UAAIALI3YAch5aggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAkA7+ef009bPB+nTzBJW/qkTS8qKlCujzbZOSlj045hZN/HCgXvl8iFp3rX/e8irULKOp3z+jycuf0gufDlOevH4J5ZUtrKWn37avX7RO+fJo+poX9fnpeapQq4y8fbw0+btn7M0sf/238XzGAADkkvghM2IHWyfiBzgUA6MCQDpER8Xq2Xtn675R3VIs7/nQtdr0++6k52+NXaL4OJfyBPhq8ieDtGrphlTL27/tsIa0f94+7jPqFrXo1ljfvf+zbnu8qzb/si1tdYqM0ehuL+mBl/rY53Gx8Rp2bUKZ1/ZuqZKVi/MZAwCQS+KHzIgdbJ2IH+BQtAQBgHRwxbsUcvJMimXFyxaS2+3WsYOnkpaZAMYwQcy+HcHnLS8+Lj7psV+Arw1sSpQvKrfcOrr/RNrrdDws1dda39pMqz5Zm6ZyAABAzo8fMiN2SKoT8QMciCQIAGRQzwHXatGbK89ZPuKVPpq5bIT+XH3hqzIN29fWzF9eVL02NXV41xH1GtpVn0z9KsOfi2nmWrRMYe3bcjDDZQEAgJwTP2RV7GAQPyC3IwkCABlQslxhe3/0wH9XcRJNfGyBHmg/Xr0evlYeHh7nLeOP7//Rw82f1urF69S1/7V22ZF9xzP8uTS/sZF+Wfp7hssBAAA5K37IqtjBIH5AbkcSBAAyoGLNUnYwsxfmP6AGra7So+N6ysvbUz6+Xvb16KgYRZ6Jts1dU+Pj+9/QTBEhkfLy9lL5mmU0dskINby2tga92s8uuxR0hQEAIPfFD1kZOxjED8jtGBgVANLp+Xn9ValmaZWpXExfLVyj4T1ftcsfn3yHbdZq+vOOnHWPAgvklZePl96fvvy8ZZlgpeeQLnK53LZf7uT+b2jBuMX2tWFvPqBPpn2Vou/v+Yz94glVrldeZaqV1JdvfqfVn/6qYmWLaO/mA3y+AADkovghs2IHg/gBTuThPt/lyRwoNDRUQUFBCgkJUWBgYHZXB4DDdC4/JMNlxB89luEy3LFxGS5jRdwHGS4DuBLO98QOALITsQNw+aT1nE93GAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAITJELAGkUfzg4w8cq38oCGS7jwKwqGS4DAABkPWIHIOehJQgAAAAAAHCEbEuCREVFZddbAwAAAAAAB7psSZCjR49q/Pjxat68ufz9/ZU3b157b56PHTtWR44cuVxVAQAAAAAADnRZxgQZPXq0Zs+erc6dO2vgwIGqWbOmAgMDFRoaqs2bN+v7779XvXr11L9/f73wwguXo0oAkGFVG1TUgCl3ye1y69TREE246zUVLB6kR1+9VwH5/fXXj5u14MVFSevHuWP1Q/9PFbrnpNq+0V0BJfPr11HfKD4mXh6eHmo4qq3ylgzU39N+0ukdJxQfFaeqd9RTmWv/GwPkz4k/KmTDz6rS+m77/Lpm1TW0bzt1Gvi6endupPZXX6WIqBg9/+YyHT99RsPuaq+ryhWTl5eHZn+6Rms37uWTBwAgmxA7AA5JgpgWHzt37rStP87WsGFD9enTR2fOnNH06dMvR3UAIFMcP3RSo7qMV3RkjPq9cJuuuamxWt7cRNMfmaMTh06ds76nvNR8Ymf9M/MX+9zDy9MmPvyL5tOpVbsVP+ZbDahSWAeL5dOKiTcoXNKqhz9LSoKcORyqqBMRkgITtveQ2jepqiMnw1Q4KEAt61fS/c+/r5qVSui+m5vppXnf6b2vf9ehYyHKH+Cn6SN6kAQBACCXxA5H1u3X7nf+1OhSgbo/Kk4nmpbT5zdU04qhXxI7ANndHWbUqFGpJkCSM68/+eSTl6M6AJApTh0JsUGMERcbb++Lly+iByf20cRvnlbNZlVTrO/p4Sm/gv5Jz718vWwQkyciVg9O/1k1Nx9V+y//1V1z12vCg5/K61Sk8lcomLT+9oUbVPX2eknPOzWvoe/XbbctUUoUCdSuAyfs8q17jqjeVaXtY5MAMWLi4uVyu/nkAQDIBbGDkSfOpZY/7lLv2et03ddb7f3IR5eoQNmgpPWJHYAcMDDqnj179MUXX+i9996z9+Y5AFzJipYtrIbta+vfX7erUp1yevOJhRp/16u2q0xadPzob80KDtdjpnlevFteLrdG7j6l7+/5SMWuLmPXOXMw1N77l0gIfDw9PNShaTWt+PVf+/zAkRDVqFRcPt5eurpWeeXPmyfFezzcs6U+Wv5nJu85AADIjtjBFRevw9N+0siwaBs3mPjhLpdbN+wLUUdXwjrEDkA2docxgoODdeedd+rHH39UiRIlVKBAAYWEhOjw4cNq166dFixYoOLFi1+u6gBApjBjfzzx9kBN7j9LIcfDdGB7sI4fPGlfi49zydPLU674/0cj5/H+N9v0gIdUOVlDjXe8PLSkTSXd/e6fKte5mrYt+FNX9W2Q9HrnFjX07a9bldi4IyQ8Up9+/7defaKHtu09pn2HE+pgdG1VS97eXvrml4SECQAAuLJjhz8nrtKdJQNV6Ui4FJ8QDCyUdMxTarD+gK52uYkdgOxOgphBTytUqKD3339fxYoVSzFrjOkuc99992np0qWXqzoAkGGenh4a+c5ALRi7SAe3B9tl4afPKCDQX644l3x8vS8axPw773fVKJ5Pt5mWHv/PaESb/5zdUkiZIPnsOmkHTY0IDtOGyasVHxOnsKPhKp43RvXr1bPJkLIlCmrInW01deEP+nL1JjWsXkanQs3YIVKjGmXV/uqqGj5tCZ84AAC5JHbIWzK/apQtII8/DyXFDn5miAG35OPvTewAXICH2315Oonnz5/fJjzMIKlni4iIsK1AwsLCLliGmU0mKCjItiAxs8sAwOV0ne8dKZ63ve0aPTLtHu3+Z799vvTNFTq2/4TuG9db3j5edmaY3775K8U2fzf6WSHbT8i/RH6VbFFeW+asV9FaxVRp23G1jorTWC8P9Yp363Aeb+2oVEiV+zRQqdYVk7Y3g6P+NnRj0uwwxvzn7tTdYxbqxYFdVDC/vw4fD9Ok+d8pOjZOH0/sp4ioWDtjTHRMnAZP/tRus+7doVl8tIBLl5nne2IHALkxdihcp7g8XW7duve0podFq6fLLTMy2Bk/LwWMbKsiHf8bW4TYAU4Rmsb44bIlQcqXL69FixapcePG57y2fv163XLLLdq/P+E/g/MhkAGQkwKZS5FvZYFUl5vBUTsv+kfFD4fqSMlAfd2jtqICfFJd98Cs/6bMvVQkQZCTkQQBkFtkZeyQnviB2AFOEJrGJEi6u8NERUXJ29vb3ozFixfbxzfeeOMFtzNdXjp27Ki+ffuqfv36SWOCbNiwwY4HMn78+PRWBQByDROwLE425gcAAADxA5D50p0EMYmMSZMmqVmzZnruuec0a9YsmwT5448/NGbMmPNu9+CDD6pq1aqaN2+epk+frvDwcOXLl09169bVJ598YgdHBQAAAAAAyDFJkM2bN+vqq6+2j+fPn6/vvvvOjvfRokWLCyZBjPbt29sbAAAAAABAjk+CxMfHy8PDQzt27JDL5VLNmjXt8lOnTqVp++joaG3fvt321ylcuLCqVauW/loDAAAAAABkdRLEtAJ55JFHdPjwYXXp0sUuMwOamjE+LjaWyGOPPaZ3333XJkISlShRQs8//7ydIhcAAAAAACDHJEFmz56tp556yo66asYEMdauXas777zzgtsNHDhQBw8e1LJly2xrEjMQ6k033aRKlSrp8ccfl6enp/r163fpewIAWcwzICDDZUQMKJzhMgru2ZjhMgAAQNYjdgByQRKkQoUKWrhwYYplPXv2tLcLMbPI7N692yZPDDMgqpku1ywzrUHuuOMOkiAAAAAAACDLeF7KRm+//badJcYkMowff/xRH3300QW38fPzs2OJJBcbG2vvGzRooAMHDlxKVQAAAAAAALImCTJ27FhNnTpVt912m/bt22eXlSxZ0k6beyGm60uvXr1swmTlyliPYn0AAQAASURBVJW25Ufnzp3ta0ePHlXBggXTWxUAAAAAAICs6w7z1ltvafXq1SpTpoyGDx9ul1WpUkU7d+684HZTpkyxY3+YRIiZVaZr1656+eWX7WsRERF67bXX0lsVAMh2dVtW0x3Db5SXt6c+nbFcOzbs1SNT+iggfx79tXqrFr70+TnbVKlZSgNG3CCX263TJ8L10siP9diYm9WkdTUtnPW9vnj/V7uej4+XHnqyq0qVK6yIM1F6/rH3Uq1D8XJFNP3HZ7R3yyH7fOxdM9ThjhZqeVMjRYZHa/KAt3Qy+HQWHwkAAJBVsUNmxw/EDnCydCdBzpw5Y1t+GIndW0y3FtPd5ULy5s2rN954w95SG2fE3ADgSuLj563uj1yn0bdOVVxsvF028q0H9Orj7+rE4fMnHU4cCdVTA+YrOipW9wzqqGva19C8V5Zr4/rdyhPgm7Ret97NtG7VVq394d+L1mXjT1v1Yt8Z9nHBYkFq0qmuhnQYq2qNKurOJ7rp1SHvZMo+AwCAyx87ZEX8QOwAp0p3d5hmzZppxoyEQDvR3Llz1aJFi3S/eWRkpPbu3Zvu7QAgJ6jZtIpiImP13AeDNHrBQBUpXdBeWen/4m2a8Pkw1WhSOdXtTp0ItwGMERcXr/g4l04eDz9nvcYtr1LthuU1ce59uqHn1ReuS7OqmvLNk+o3poeKlSuc1Cpk+4a9qtW8aqbsLwAAyJ7YISviB2IHOFW6kyDTpk2zY4I0atRI4eHhuuaaazR58uSLjgmyf/9+O5hqxYoVNWfOHP38888qVaqUnSK3Zs2a2rNnT0b2AwAuu4JFA1WifBGNuX26vp73o3oP66qKtcrordEf6aX739SA8bdfcPuiJYLUoFll/bpqa+qvFw/Ulr/2a2T/t9X2hroqUjww1fVMV5d+9UZoaKfxCioaqOJlC+uqRhXl4+uthu1qKV+BvJmyvwAAIHtjh8yKH4gd4GTpToKYpMWWLVs0cuRIjRs3To899pj+/vtvm9y4kCFDhthZYMyYIA8//LBNgmzfvt0mR0wS5KmnnsrIfgDAZRceEqF/1m63zVn/WvWvqtQrrwM7j+j4oVM6dTTUXqHx9Er9v9mAvH4aPv5WvTz6U7tequWHRenPX3fKFe/Slg37VLp8kVTXi42JU3REjH3805L1qlCzjL6cs1LjlgxT4451dGB7cCbuNQAAyI7YITPjB2IHOFm6xwQx8uTJo549e6Zrm1WrVum9995TfHy8bTVy//33q1ChQvY1Myhq48aNL6UqAJBttv6+W7c81NE+rly3nPb+e0jFyhZWQKC/4uPi5e3rbQOQs3l6emjEhJ56b9ZKHdx74rzlb96wT5Wrl9TG9XtUsVoJfb1ofarr+efLo8jwKPu4Totq2r/1kL59f41WLPxJdVtWV8ixsEzbZwAAcPljh8yOH4gd4GTpToKEhYXZ7jC///67fZzc999/f97tYmJi5OubMGBPUFBQUgLEKFGihEJCQtJbFQDIVmGnzmjt1xs06asn5Ha59PLAt1WweJCe/2CQvHy89M7Yxalu17pTHdWsX85ezen9YDst/fBXG6w0a1vdXv0pWbaQ3pz4tT6au0pDX+xhBz/7/eftCj5wKtXyzJgf94zuoejIaAXvOa75L3yqJ99+SEFF8uvo/uN67fF3s/hIAACArIwdMjt+IHaAk3m43W53eja4+eabbReWHj162BlfkjNdY86nevXqWrNmjU1+mK4wyQdSPXjwoJo2baoDBw5c8L1DQ0NtAsUkTAIDU+8bDwBZ5foC92W8kLIJs2tlhHvPhf+vTItvwuZluAwgq2Tm+Z7YAUB2InYALp+0nvPT3RLkhx9+0L59+9IdlJgxRMz0uiYJcvZMMitWrNCtt96a3qoAAAAAAACkWbqTIGXLlrVdW9LrnnvuuaTXAAAAAAAALlsSxMz+kuiRRx7RbbfdZlt2FC9ePMV6devWzZRKAQAAAAAAZEsSpH79+vLw8FDy4UNWrlyZYh3zupn55VJ4enrqmmuu0ZgxY9SxY8JoyQAAAAAAAJc9CeJypT5NU2YxCRUzzsgHH3xAEgQAAAAAAOSM2WGio6Ntyw0fH5+kZbGxsTZR4ufnp6zECO8AAOR+zA4DAACyKn7wTG/BnTp10m+//ZZi2bp169S5c+d0VxIAAAAAAOBySXcSxAyS2qxZsxTLzPMNGzZccLu4uDg9/fTTatu2rQYNGqQjR46keL1OnTrprQoAAAAAAEDWJUH8/f0VHh6eYpl57uvre8HtnnzySX3zzTfq0aOHDh06pAYNGmjTpk1Jr+/Zsye9VQEAAAAAAMi6JEj79u01ZMgQxcTEJI0RMnToULVr1+6C23344YdasmSJHn30UX3yySd67rnn1KFDh6Tpd83sMgAAAAAAANk6O0xykydP1o033qgiRYqodOnSOnjwoKpVq6YvvvjigtuZwUmKFy+e9Lx///4KCAiws8F8/fXXl1Z7AAAAAACArEqCmETGr7/+agdH3bt3r8qXL6+rr776oi05KlSoYMcNadSoUdKyO++802533XXX2RYlAAAAAAAAOaY7zMMPP2wTF02aNFHPnj3tvXn+yCOPXHC7u+66S99///05y3v37q1XX33VtioBAAAAAADIKh5ut9udng3MfLtm/t2zFS5cWCdOnFBOmPcXAABcuTLzfE/sAACAM4SmMX5Ic3eYzz//3N7Hx8fb8T+S50527txp3ywtTp48qUKFCtnHZprcn3/+2U6PW7Vq1bRWBQAAAAAAIN3SnAR57LHH7H1UVJQGDRqUtNzT09OOEzJ9+vQLbm/GELn55psVHByspk2bavbs2Xammfz589vBVd99913deuut6d8DAAAAAACAzBwTZPfu3fbWo0ePpMfmZlqBrFmzRl27dr3g9o8//rgdT2T//v3q1KmTrr/+es2cOVM7duzQe++9pxdffDGtVQEAAAAAAMj6MUEuVcGCBW1XGDOIamxsrPLmzWtblZiWJKYK5vXTp09fsAz69QIAkPsxJggAAMj2MUESmalsX375Zf3www86fvx4irFB/vjjj/NuFxAQYLu9lClTxrYGiYuLs9sXK1bMDqhqXgcAAAAAAMgxU+Sabi0LFizQDTfcoK1bt+ruu+9WRESEbrrppgtuZ6bTbdu2rQYMGKDbbrtN/fr1U58+fWxXGHPfpUuXjOwHAAAAAABA5naHKV26tJ3RpUKFCipQoIDtwrJlyxY73sfKlSvPu52ZVcYMnrpnzx7dd999qlSpkh566CFt2LBBzZs315QpU+wgqRdCdxgAAHI/usMAAICsih/SnQRJTHwYJUqUsEmNPHny2Dcxb5qVSIIAAJD7kQQBAAA5ZkyQqlWr6q+//lK9evVUp04dTZ061SZGihQpku5KRkZG6ujRoypfvny6twUAAAAAAMjSMUHGjRun8PDwpMdz587Vc889Z5MhF2IGQ+3YsaMqVqyoOXPm2C41pUqVst1iatasaVuUAAAAAAAAXPFT5N5666024WGmyJ02bZpeeOEF3XvvvYqJidGgQYPk5+enhQsXXrAMusMAAJD70R0GAADkmDFBEgc53bt3b1KLkER169Y97zZmKtwDBw7YbfPmzWunxy1UqJB9LTg4WI0bN7avZ8ZOAQCAKxdJEAAAkGPGBPnss8/Uv39/nThxIsVy08LDJDjOx7T48PX1tY9NxRITIIkDrJqKAgAAAAAA5JgxQUzXlfHjx+vMmTNyuVxJtwslQBITHSdPnrSPly5dmuK1gwcP2sQIAAAAAABAjkmCREVF2bE8/P3907XdyJEjbeLEaNGiRYrXVqxYYccMAQAAAAAAyCrpHhPEzARjpsR97LHHdLkxJggAALkfY4IAAIAcMyaIGQ+kVatWmjhxoooXL57itT/++CPVbcz4IYULF75o2WldDwAAAAAAIL3SnQQx3VYqVqyoHj16KCAgIE3bNGnSRN27d1e/fv1Us2bNc17fsmWL5s6dawdd3b59e3qrBAAAAAAAkPlJkL///tsOcJo400tabNiwQVOmTFGHDh3sIKrVq1e3zVNMc5WtW7fadR588MHztiQBAAAAAAC47EmQZs2aaefOnapRo0aat8mfP7+effZZjR49WuvWrbNJkVOnTqlgwYKqX7++bSni5eWV3qoAAAAAAABkXRKkcePG6tSpk/r06WOnvT17+twLMYmO5s2b2xsAAAAAAECOToL8+uuvqly5sn755ZcUyz08PC6aBAEAAAAAALhikiArV67MmpoAAAAAAABkIc/0brB//36dPn3aPo6OjtbUqVP12muvKS4uLivqBwAAAAAAkD0tQcxUt3PmzFGBAgX0xBNP6LvvvpOPj4+d5eXVV1/NnFoBAAAAAABkdxJkx44dqlOnjn380Ucf2bFB8uXLp9q1a6cpCeJ2u7V8+XJt3rxZpUuXVpcuXZQ3b95Lqz0AAAAAAEBWdYfx9PRUTEyM/v77bwUGBqp8+fIqVKiQwsPDL7qtaS3SsGFDLVq0SH5+fvrzzz/VqlUr7du3L73VAAAAAAAAyNqWIG3atFGvXr104sQJ3XLLLUmtQ4oVK3bB7UJCQnTTTTdp/vz5atq0adLyjh076umnn9a8efM0ceJE28XGzDQDAAAAAACQrUkQMx7I5MmT7TggI0aMsMu2bdt20elxzQCqd999t02AdOrUSbGxsUmv7d2717YwWbVqlQoXLqz+/ftfyr4AAAAAAABkXhKkYMGCGjt2bIplZlyPi/nss8/0xRdf2MfXXnut7U7Tu3dvffDBB2rbtq1d/vzzz+uxxx4jCQIAAAAAADKdh9uMVHoRs2bN0oABA+zj6dOnn3e9C7UGKVKkiI4fP24fm4FV169fb8cFiYqKUqNGjbRp0ybFx8fbbjWmq01qQkNDFRQUZLvWmPFIAABA7pOZ53tiBwAAnCE0jfFDmlqCfP7550lJkMWLF6e6jhnH40JJkICAAB07dkxFixa1lTt48KAqVaqkAwcOKCwszK4TERGhPHnypKVKAAAAAAAA6ZKmJMhXX32V9HjlypW6FNdcc42+/fZb3XHHHXbw09atW6tly5b6+eefNWrUKLvODz/8oCZNmlxS+QAAAAAAABnuDpOauLg423IjuQs1OVmzZo0efPBBrVu3Tv7+/tqyZYv++ecf1a5dWzVq1FB0dLSaN2+uadOm2QRJamjSCgBA7kd3GAAAkFXxg2d6C167dq3q1atnu62YQVLNrUCBAvb+Yi1BTCuQ66+/Xvv377eJj549e9p789ws79q163kTIAAAAAAAAJd1dhgzze1tt91mZ3Ux43ykh+n2UqVKFV133XV2ANSyZcvasUGCg4P11FNPqU+fPumtDgAAAAAAQNZ0hzEtPk6ePGkHQs2IXbt26ciRI3agVJMYSQu6wwAAkPvRHQYAAOSY7jC9e/fWZ599powyM8OYMUDSmgABAAAAAAC4rN1hXnzxRTuDy6RJk1SiRIkUr3366acZqgwAAAAAAECOSYKYcTv8/PzUqlWrdI8JAgAAAAAAcMUkQX788UcdOnTogn1sAAAAAAAArvgkSM2aNRUWFkYSBECadPS+PeNHyu3KcBGemdBy7ZuweRkuAwAAAMAVlATp3r27unTpoocffvicMUG6det20e2PHj2qcePG6Y8//lB4eHiK18wyAAAAAACAHJEEeeONN+z9+PHjUyw3U+amJQly2223ycvLS3fccQdjigAAAAAAgJybBNm9e3eG3tC09jh27Jh8fX0zVA4AAAAAAEB6eOoya9q0qXbs2HG53xYAAAAAADhculuCZNQ777yjW2+9Va1btz5nTJFBgwZd7uoAuMz88+XRS8ufVoWaZTSoxdPas+mAbnq4kzr0bSW3W3pv3Kdau/SPNJQxWhVqldWga57Snk371aZXc3Uf1EXRkTGa1G+Gjh04ccEyipcrouk/PqO9Ww7Z52PvmqEOd7RQy5saKTI8WpMHvKWTwaczdd8BAAAAOCwJMnXqVK1fv16xsbEpxgQxY4qQBAFyP5OkGN3tJT3wUp+kZTcO6KgHGoxQngA/jf/6yYsmQRLKmKAHJva1z728vdRjcFc93uYZVbu6iu58uoemDXjzonXZ+NNWvdh3hn1csFiQmnSqqyEdxqpao4q684luenXIOxneXwAAAAAOToK8/vrrdlwQM9UuAOdxxbsUcjwsxbJDO4Pl5+8r//x5FHoiPN1llK5aQns3H1BcbLw2rdmalBy5mJrNqmrKN0/qnzXbtObLP5NahWzfsFdDZtyb7n0DAAAAkAuTIGFhYfaWP39+e0uPokWLqlKlSpfytgByqd+++UtvbZwiLy8PTbpvVrq3z1cgryJCI5Kee3pdfLgj09WlX70Rio6I0eDX+ql42cK6qlFF+fh6q17rGrZMAAAAAA4dGNXlcunFF19UxYoVVaBAAZUtW9beV6hQQWPHjrWvp8Xo0aPVv39/bd++XaGhoSluAJwnIL+/utx/re6pPlj31hqqe1+4Ld1lhJ86o4DAgBQtRS4mNibOJkCMn5ast2OUfDlnpcYtGabGHevowPbgdNcDAAAAQC5pCTJ48GCtXr1akyZNUv369W0CJCQkRH/++afGjx+vo0eP6pVXXrloOffem9DEfOHChXYcEMPtdtvH8fHxGdkXAFcgk0CNiY5VbHSs4uPi5ePnY/8/MP8vpNXBHcEqX6O0vH287Jgguzbuveg2ZnDVyPAo+7hOi2rav/WQvn1/jVYs/El1W1ZXyLGUXXYAAAAAOCgJ8t5772nTpk0qXrx40rIiRYqocuXKatmypWrVqpWmJMju3bsvvbYAcoWxXzyhyvXKq0y1kvryze+0atGvmv7zC/L09NTnry9PUwJk7NKRqlyvgspcVUpfzl6hT6d/pSkrn1NMVIwm3pMw2OmF1GpeVfeM7qHoyGgF7zmu+S98qifffkhBRfLr6P7jeu3xdzNpbwEAAADkFB7uNF5uLVy4sLZs2aJixYqd89qRI0dUo0YNnTx5Ml1vfvz4cZtISSvTZSYoKMi2QAkMDEzXewHIHh29b894Ie60dbe7EM9ks1Fdqm/C5mW4DACX93xP7AAAgDOEpjF+SPOYIHfccYeuv/56LV68WLt27bIJD9Oqwzzv0qWL7rzzzjSVExERoQcffNBOj2talZj7AQMG6MyZM2mtCgAAAAAAQLqlOQkybdo03XjjjXrsscdUpUoVO8uL6QpjnpskyNSpU9NUztChQ7Vt2zZ99913OnTokL03g6QOGzYs/bUHAAAAAADI7O4wyZ0+fVrh4eHKly+fHSA1PUqXLq2NGzeqUKFCSctOnDihOnXq2KTIhdCkFbjy0B0GQHrRHQYAAGRV/JDmgVGTM4mP9CY/Epmcixn8MDnz/BJyMQAAAAAAAGmWriTIt99+q59++kl169ZV9+7dU7z28MMPa+bMmRcto2vXrrr11ls1YcIElS9fXnv27NFTTz1lu9oAyH1irmuY4TJWzp2d4TI6laqf4TIAAAAAOGRMkLffflu9evWyXVnMOCAdOnRQWFhY0usLFixIUzkvv/yyypUrp1atWtmBUc19mTJlNGXKlEvbAwAAAAAAgMxMgkyaNElff/21Fi1aZAcyLVGihE2EmH43Rlq7s5hxRObOnWtniQkODlZkZKR9nj9//rRWBQAAAAAAIOuSIAcPHlTTpk3t4zx58tiWHw0aNFD79u116tQpeXh4pPlNTQuSDz/8UO+8844++uijpEQKAAAAAABAtidBChcubMfvSG7WrFlq0qSJTYTExcWlqZwNGzbYKXafffZZOz2uua9atar+/PPP9NceAAAAAAAgswdGNV1f5s2bZ5MWyZnBUAcOHKi//vorTeUMGjRIo0aNsuOKJHr11Vft8tWrV6e1OgCuIBXLF9HQR69TfLxbkZExev6lLzRuTMLgyn5+3vLx9tL9j87XyCGd7bqRUbFa+9sufbBoneLiotX8hv3atDVGa74so9rV/XTgUJwGPnlUYWEutW0RoGeGFtL3P0Xo6fEn5OPtoeeeKKS21wRo/kehmrswVLFxbgW7PVXVo25Snfzz5dFLK55RhVplNaj5KO3ZtN8un7d1uo4fPGkfvzfuU/3x7d/ZdNQAAAAAZDYPdxoH84iJibGtPQICAlJ9fd++fXbA04spVKiQjh07Ji8vr6Rl8fHxKlKkiO1Wkxnz/gLIOdrcMFFeXp6Kj3fZ53f3vkaHg09r+feb7fOO7WqqVMkCmv/eGpsE+fDT37R77/Gk7d2ueH08ebZGvHBcQx8qYJMgvR8K1qRniqh0oKc0N0Qe+2LV/PsIfbW0tHyCvNT1zkNaubiMYmPd8vFJ6KpXpGSIaulq5fFI+D/M08tT+Qvm0wMT++rjKZ8nJUFmrJuggU1GprovK1wfZ/nxApC553tiBwAAnCE0jfFDmrvD+Pr6njcBYqQlAWKYAVXXrl2bYtm6devscgC5U2ICxMjj56N9+xNaWhhtW1bTD6u3Jj0fPqiTpoztpcoVi9rnHp5eKlrkv6SpSWzs3R+rYaOPqUPd3fpl/Anpg1DFH4pTwTsOK6/bvJ90/ER8UgIkLs4tb/nIR75J5bjiXQo5fu54RHny5dGUlc/pyQWP2SQJAAAAAAd2h8kspitM586d1bdvX1WoUMGOM7Jw4ULbJQZA7tW4QXkNuLet4uJceu/jX+0yf39fFSsaqL37T9jnM99aqdCwKJUrU0gjH79BDz9+7tTbx0/G6+/NMfqwub98vnLrJre0Lk42vbFvW4x8p5/SP1tjdDo0XkUKe2nyzFOaNT9EPiojL4+L/5c3uOXTCjsZrg59W6vvsz0187G3s+BoAAAAAMgOaW4Jkln69OmjL7/8UrGxsVq5cqW9//zzz21SBEDutf7PvXbcjx9/3qobO9ezy1o0raKff92RtI5JgBj7DiS0FPH0PHfWqQKBnrqqso/KnnaphFdCJtcMyzxNUj9Jj34WpjrVfVW8aELCY9jDBbV1TXnFKFoh7hPqMaSrJn//rL1PjUmAGKs+XqvK9SpkwZEAAAAA4JiWIEarVq3sDYAzmIFPY+Pi7ePwM9H2udG2VTW9NX9V0noB/r6KiIxRgaAA+fp4yeU6d8gif39PFQj00uliXvKJl2L+/x/Z1ZK+85COdc+vR3fHKn8+T0VHu+Xn5yEvLw95yVue8tKiqUvtLTXePt4ys33HxsSpbusaOrQzOMuOCQAAAAAHJEHMgKim1cdbb70lb+//3t4MXGIGMgGQ+zRuWEG392git8ut06ERGv/yV7YrTPGigdqzL6ErjPH08K7Knz+PvDw9NOOtlUnLu9x5SH9tita2nTHq3zdIL4wspG7Pn1Csn4eej3bL7SVNiJeW+3ko4K9oTZ+QMJ7IpBmn7KwxZgbvAFVUfo8CKeo1dumTqly/gsr8j737AI+ieOM4/sulB0jovfcuTaWDFLEASpcqoIIIShEVERBBFKUpggIqggL+FRGlKaAIiApKUZAq0jskkIT03N3/mY2JCSQIJJBy38/zBPb2duZm9y63b96dma1QWCvnrNWv3+zQhJUjFRkWqZioWE157N3beJQAAAAAZJi7w6QVM7lq06ZNFR4erqVLlypXrlzW+hw5cig0NPSaZZnhHcicd4dJrR/mvp/8E2GOhLvDOIt7Sn0DpGzJj/JrVbhGqtvB3WGA24O7wwAAgHS/O0xaMb0/VqxYoSpVqqhu3bo6eDBuPgA30wcdAG6ESXg8nUvOSfmt/1NKgAAAAACAkS5/MdhsNs2cOVMDBgxQgwYNtHHjv3MCAAAAAAAAZIk5QRKPvhkyZIjKli2rdu3aKSIi4nY3BQAAAAAAuJDbngSZP39+ksetW7fWunXr9NVXX93upgAAAAAAABdy25Mg7du3v2rdHXfcYf0AyHq8v9uR6joerNUq1XW4eV5MdR0AAAAAMjdmEQQAAAAAAC6BJAgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAkkQALdVuZqlNGXdy5r83Ri9tGiw3D3crfX5iuXRitCPVbJK0WTL+Wbz1rQVw/XlX1NUokIha93QaT30v12vq02fxgnb9R/XQW8uGay3Vz2nxm1rpdiOkpWLatoPL2vy2lEa/9Vw+WTz1rNz+unzE++p7YCWab7fAAAAAFzw7jAAXNuFU0Ea+eDrioqIVp/xXVT/oTr6cckWdRneVnt+PpBiuajIGI3tNUuPjX44Yd2815dp1y9/WQmSeB+MWyp7rEM+fl6a/PUwbVy2Pdn6jh84raH3vGIt93ipvRo8dKc+GvO5dv64T77Z/60PAAAAQNZBEgTAbXXxbHDCcmyMXY5YuwqWzCen06lzxy+kWM5hdyg46HLSus6FXLWdSYAYPn7eOnbgTIr12WPtCcvefl46vv+Ugs5cuuH9AQAAAJB5MBwGQLoww19qNauqzSt3qPPwtvpi2oo0q/v5GY/q3e9f1I6N+665Xa3mVfXulgm6o0llnT50Ns1eHwAAAEDGRBIEwG3nl8NXL3w0UJOfmKX8xfNY684eTbkXyI16c9B89Ws8Xp0H3Ss3N7cUt9v+/Z966u6X9OPSX/XAY83S7PUBAAAAZEwkQQDc3i8dm5tGfDxQCyYs0cm/zqh09RIqUbmoJiwfoVrNq+mZGY8lTJZ6Mzy94kb5RUXEKCIs0hpmc63tjPDgcEWGR930awIAAADIHJgTBMBt1bhTPVWuW16+2X3VfWR7rZizVs82i5ugdPgHT1rDYhLP15HYuE8GqHSVoipapoBWLdhk/V/33mqyubupUIm8mjP2Sz0/s7f8c2WTu6dNn771bYrtqNWimjoNfVAOh1PBF0I0+fHZ6ju+i+q2riV3d5sKly6gWc8tuGXHAQAAAMDt5+ZM6TJpBhQSEqKAgAAFBwfL398/vZsD4Drc69U11cfJPW/ckJnUsAdeTHUda6IWproOALf3fE/sAACAawi5zviB4TAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACAS+DuMABuqTXRn3KEAQAAAGQI9AQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAleKR3AwAASG8tbZ2UEdh8fFJdx+rwT9KkLQAAIGXEDpkXPUEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl8DEqAAA/Id7Hmmgp97uq04FHrvuY+Xm5qbhc59SodIF5HQ6Nbnvuzp/PFATV4+ynvfy9ZKnl4cG1H7+mvU07VRXAyb3VJcSA5W3SC4Nequ3/HL46o+Ne7XwtaW8dwAAZEDpGTsYxA8pIwkCAMB/BCSNOtTV+eMXbug4lalRUp7enhrWZIxqtaiuhwbdp1nD5mt4s7HW8827N1KhMgX++7Xb3aXzJ4Osx49P6Kp3Bs9T4KmLvGcAAGRQ6Rk7JLw+8UOKGA4DAMA1NOvWUD8u2Synw3lDx+nCicCE5ew5/RR8PiTJ84071tPGxZuvWcc9Xerpx6W/yulwyN3DXQVK5FW/17vpjVUvqvLd5XjfAADIgNIzdjCIH66NJAgAACmdJG02NelUX+s/+/mGj1HwhVAr+Plwz1t6/I2eWjNvfcJzvtl9lK9YHh3beyLlE7TNTY073K0NX2yxHgfkza7SVYvr/ZGLNLHPu3pyUnfeNwAAMpj0jB3iXp/44b8wHAYAgBQ079FIGxb/bI3LvV4dhrZWvTZ1tP27nYqKjNZjlYeobM1S6j/lUb3W7S1rm3pt6+iX5VuvWU+zrg20ccmWhNe+fClcJw6e1oWTcUNh7LEO2dxtctgdvH8AAGQQ6Rk7GMQP/42eIAAApKBE5aJq2bOJXlv1koqUK6Qnpz76n8dqybQV1tjdv7Yf0uWLl611ly+FKXvObFd0Z/3lmvWUqFhELbo11ISvn1ORMgXV55XOCrsULj9/X3n7ecvDy50ECAAAGUx6xg7W6xM//Cd6ggAAkIIPRixMWJ7560RrcrLrtW3NTrXo0URTfnhFnt4emvXs/ITurPmL59XRPdfuzvrh6M8Slt/Z9Ipmv7DQmgdk/JJn5e7prvnjlvC+AQCQwaRn7GAQP/w3N+eN9NNJZyEhIQoICFBwcLD8/f3TuzkAgCyipa2TMgKbj0+q61gd/okyu7Q83xM7AABuBWKHjOd6z/kMhwEAAAAAAC6BJAgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAneHAQAgDfw1r3aq6yjxP65NAADgKogd0gfRFgAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASmBgVAIAr2Gw2PT9/kPIWya2zR85rar9ZssfaNWX9K3I6nPLw8tBb/WfryO7jSco5HQ5dmPO57BdD5JE3l/L0aS97yGUFzf9ajshI+VQsrZztWihiz9+69MVqubm7K2f7lvKpVDqhjlIl8urZp++V3e5URES0xr2xXK+93N56ztvbQ54e7nr86fnW/8882VxFi+RSWHi0Ro1fyvsIAEA6IXbIPEiCAABwhYbt79Lpw2c1sed0dX6urRq2v1sbPv9Zz7cYZyVDqjeurPZDW2vq4+8lKRe+dbc88+VWvicfUfDKDQrftlvRv+3SkKL5VfVyhI57emh+ZJROf7FaBZ7tI3m469yUeSpYqV9CHcdOBGnQ8EXW8qPd6qthvbIaMuJ/1uOW91RW4UI5reX2bWvpl98O6ecZB3n/AADIQrGD+SnyyP16fNtuFTt/UcdXrNfYrX+qwHOPETukAZIgAABcoVDpAvr79yPW8l/bD6vBw3dZgYwJYgw/f18d3nX0quMWez5InsULW8teJYsoZstOlfp9n/6OidUvksZJevjnHarh4SFbNt+4Qg6H7KFhcs+RzXpotzsS6vPx9tSx40EJj5s2rKA58zZay3fVLqVcObOpc7s6+n7DXi3/5g/eRwAAMnnsYBIgznNBKv/KTH0bEaVXbG7q4pQWeLjL7m5TuLcXsUMqMScIAABXOLb3pGo2q2ot12pRXdkC/KzlgLz+euvH8Xp65uPatXHvVcfNs1A+Re7921qO3H1Quff+rb9iYjVF0qeSnpVU9tR5FbgcrtjAS7IHhyr65Fk5wiOS1FOnZgl98M6jqlm9uE6evmSt8/X1Uv58/jp6PNB6bJZ37zupZ0d+phZNKytfnuy8jwAAZPLYIfb0ecUeO613I6Ks2GG4wyl3p1M5YmL10LJ1xA5pgCQIAAD/6DC0tSavG6vCZQsqJjpWk75/WT7ZvHXxbFwiIvhCiIY0Gq1xHaeo74RuVx033xoVrXk+zrz+vpxR0Srv5aVykopKKvhP98toN+mxEoV14f3FCvp4mbyKFpS7f44k9WzdcdSa92PDT/vV5v47rHUN7i6rn7b8O/Tlcliktv9+VHaHU3/uPamiRXPzPgIAkMljB8/ihVTY11uF3W0JsUOspCk2Ny37aQexQxpgOAwAAP9YMm2F9ZNYz5c7aft3u2Rzt1mTojqdToUFhysyLPKq4+Zmsyl399bW8qWl36lEueIKP3FGwfEJENPV1Sl5lSmmgq2bWsNggj5ZJpuvd0IdZsLTmH+6zl4Oi7IeG00bVdAH8+OGwhh/7jmpsqUL6I8/j6tsqXxa8S3DYQAAyOyxg0+VsnLftluhl8Pl/U/sYGKIu5xSr5b1NaPJncQOqUQSBACAK+QqkFMvfTrEGse7/ftd2v3TPuUpnFsjFw6Ww+GwApp3Bn1w1XGzXwrV+fc+tQIaE8RseOQBjd71lx68cFExksZKOlg4n6bExirk9fdl8/ZUrp5tk9RRp1ZJPdLhLus1LoWE6/Wpq6yhMAXy+evIsbihMMaixVv04rAH9ETvRvp122GdPmNSLQAAIDPHDj7lS8rep53ufesTuUfH6GWbm+xO6fkcfpr1x345DxwhdkglN6dJS2USISEhCggIUHBwsPz9/dO7OQCALKKlrVOq6/hrXu1k1/tFRunR736Jm909Xy7Nb1FP4T7/9vxIrMT/Uj9KdcOq55XZpeX5ntgBAJDZYocbiR+IHW78nE9PEAAAbiETsLzXuinHGAAAED9kAEyMCgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJfAnCAAAKQBv33JT3Z6I5w2cw8ZAADgCogd0gc9QQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXwMSoAABcoWSVYhoyq5/ssQ5FXI7Uq49MU2RYpDoOa62G7esq8nKkJvWZqcDTF686dneWKqoBze6Wu82m+Zu2qWBADrWtWdlMe6pZP/yq9fsOaUKHe1W2QB5FRMdo4/7DmvvjtoTypUrk1fCB98pudyoiMlpj31im+1tUVatmVeV0OvXxZ7/o51//1tABLVWyeB6rTOXyhdT+0fcUejmS9xIAgHRA7JB5kAQBAOAKx/ef0pBGo63lHmM6qmG7u7Rt7U7d9UBtDWk4ShXuLKvuoztq+lPvJynn5eGu3g1rq/+8pYqxO6x1y4f00sPTP5GPp6fe79POSoIYLy1Zo4NnA6869sdOBGng84us5d5d66tRvXJ6+IGa6jPoI3l7e2ry+E5WEmTae2utbfLnzaGRQx8gAQIAQDoidsg8GA4DAMAV7LH2hGUfP28d23dSBUrk1dE9x611f20/pKoNKl513GoWL6yo2FjN7PmQpndvo7zZ/XQ08JK8PTyUzdtTl8L/7akxrl0LfdCnvSoUzJv0tf9Jnliv7e1pJUVOnr4kL29P+fl5KSQkaW+PJg0qaP1P+3kPAQBIR8QOmQc9QQAASEatFtX1xBs9FBtj12dvfC03m5sq1CkjTy8P3XFPVWXPle2qMnmy+6lILn/1mP2Z6pYproHN62nTgSNaPuRRudvcNPKL1dZ2b67aqOCISJXKl0uvdWilrrP+l6SeOjVK6Mk+Ta2EyMIvtmjLtkP65N2+stlsev2tVUm2bVy/nF5+fRnvIQAA6YzYIXOgJwgAAP/oMLS1Jq8ba/2//budGlD7ef245Bc90K+FQgJDtWL2Wk1cPVp33V9TJ/afuuq4hUZGafuRU9ZQmM1/H1e1ogXU+c5qun/qR3pw2nwNubehtZ1JgBiHz8fNKWJzc0tSz9bfj+rxwfOtHh7tW9dSm/vuULd+76vHkx/oiV6NE7bLlye7NXdI0KUw3kMAANIBsUPmQ08QAAD+sWTaCuvH9PaIFxYcLo9/Hq+Zv976qd6ksi6dC77quO08fkY969e0lisVzqfjF0NU0D+7omPtsjsc1pwhJt/h5+WlsKho5c7ma61zOJ0JdXh6uCvmn+E4YWFRivKIVXS0XdExdqtniJdnXB2mSNMGFbSBoTAAAKQbYofMhyQIAABXqNWyujoPf0gOh0PB50OsO8EYIxcNUc58/jp77LzeGfjhVcfN9PD4Yd8hffxEJyuxMWrJWrWsUlafPvmIbDY3fbr5Dyt58Ubn+xTg62MNkTFDYxKrU7Okura/yyp/KTjcGv5iEh/vTe5h1fHlyh1WHUbjBuUZCgMAQAZA7JB5uDnN/fYyiZCQEAUEBCg4OFj+/v7p3RwAQBbR0tYp1XWcHFE/1XXk3RmT6jo2rnhemV1anu+JHQAAtwKxQ8Zzved85gQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJ3hwEAuLy1jsUufwwAAMD1I3bIvOgJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BI8lIk4nU7r/5CQkPRuCgAAuEXiz/Px5/3UIHYAAMA1hFxn/JCpkiChoaHW/8WKFUvvpgAAgNtw3g8ICEh1HQaxAwAAruG/4gc3Z1pcZrlNHA6HTp06pRw5csjNzS29mwMAAG4BE5qYAKZw4cKy2VI3cpfYAQAA1+C8zvghUyVBAAAAAAAAbhYTowIAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEGR6TqdT/fr1U+7cueXm5qbff/89vZsEpKsjR47wuwAA/yBOAFKnZMmSeuuttziMyDJIgiDT+/bbbzVv3jytWLFCp0+fVtWqVZUZzJkzR02bNpW/v7/1B+ulS5eu2mb79u1q2bKlcubMqTx58ljJnsuXLyfZ5tixY2rTpo2yZcumvHnz6plnnlF0dHSSbVavXq26desqR44cypcvnzp06KDDhw8nPL9+/XqrDVf+7Nu3T7fLDz/8oAceeMDaTz8/P1WuXFnPPvusTp48mWwbzX7cf//9+uOPP/7zJG3WmeduxO7du63jZMqZ10uu3rFjx151zAoWLJhkmy+//FKtWrWy3puUknRnzpxRz549rbLmfaxVq5a++OILZRTm98t8BgEgMyJOcI044VrnKrPePB8v8T6Y41KuXDn17t1b27ZtS7b8iRMn5OXlpYoVK95U2yMjI636q1WrJg8PDz388MNXbXO9x3jJkiXWvnt7e1v/L1269Kq63n33XZUqVUo+Pj6qXbu2fvzxR2UUXKhBRkASBJne33//rUKFCql+/frWH5Hm5HKlK0/2GUF4eLjuu+8+jRw5MtnnT506pRYtWqhs2bLasmWLFcSZP8zNSTSe3W7Xgw8+qLCwMG3atEn/+9//rJOjCQriHTp0SA899JCaNWtm/QFuAp0LFy6offv2V73m/v37rURS/I8JCm6H2bNnW/tq3j/T/j179mjWrFkKDg7WlClTkm3jypUrdfHiResYmu1uxftTunRpTZw48arERmJVqlRJcsx27dqV5Hnz3jRo0MCqJyUmAWL2a9myZVZ589506dJFO3bsUFZiPq8OhyO9mwHAxRAnuFaccL0++ugjax9MbDVz5kzrItPdd9+tjz/++KptTQKlc+fOVmzw008/3dT5z9fX10pAmf24lmsd419++cWKD0zcYC4Cmf9Nu0ycGO+zzz7TkCFD9NJLL1lxRKNGjayLRuaiWVYTExOT3k1AZuUEMrFHH33UaT7G8T8lSpSw1jdp0sQ5cOBA59ChQ5158uRxNm7c2Fo/ZcoUZ9WqVZ1+fn7OokWLOgcMGOAMDQ1NqO+jjz5yBgQEOJcvX+4sX76809fX19mhQwfn5cuXnfPmzbPqz5kzp3PQoEHO2NjYhHJRUVHO5557zlm4cGGr7rvuusv5ww8/XNc+mO1M2y9evJhk/ezZs5358+d32u32hHU7duywtv3rr7+sx6tWrXLabDbnyZMnE7b59NNPnd7e3s7g4GDr8eLFi50eHh5J6lm2bJnTzc3NGR0dfc023A7Hjx93enl5OYcMGZLs8/FtSq6NmzZtstZ9++231mPz/kybNu2qOsy6+M/GzUip3pdfftl5xx13XFcdhw8fttpq3sMrZcuWzfnxxx8nWZc7d27nBx98kGJ95v2cOHGis0yZMtbxK1asmPPVV19N9rXiP9eJLV261Nom3u+//+5s2rSpM3v27M4cOXI4a9Wq5fztt98SjnviH7Pf1/O5T/z7VKlSJae7u7vz0KFD1jZ33nmnVcY8X79+feeRI0eu6zgCwI0gTnCdOCG5c108s948H8/sizkPXqlXr17WOTAoKChhncPhcJYuXdqKNV544QVnnz59Uv2ZfOihh65afz3HuHPnzs777rsvybpWrVo5H3nkkYTH5lz85JNPJtmmYsWKzhEjRlyzXV9//bWzdu3a1mfDxM7t2rVLNg5KLp4xbTbr4mMAc/y6devmzJs3r9PHx8dZtmxZ59y5c63nrowpTMwez2xj2mraUKFCBefMmTMTnot/3c8++8wqY7Yx25v4oXXr1lZ8buKKypUrO1euXHnNfQXoCYJM7e2339a4ceNUtGhRK1v+22+/JTw3f/58q1eIydibKwiGzWbT9OnT9eeff1rPr1u3Ts8//3ySOk2W32xjrpaY3heme6K5GrJq1Srr55NPPrGGsiQertCnTx/rdUyZnTt3qlOnTlYPhb/++uum9y0qKsrqemnaHM9cRTDM1Zz4KwJm+E/hwoUTtjFDL0zZ+C6dderUkbu7u3XFw1yJMFdNzD7ce++98vT0TPKaNWvWtHrVNG/e3Op2ejssXrzY6qlz5fsQ71rDMOKPx41eCYjvcmq6ZKaWeY/N8TfdTh955BHritqNatiwoXXlJigoyOopYT5H5j00w6VS8uKLL+qNN97Q6NGjrStiixYtUoECBW56P7p37279HpnfIfPZGTFihPX5MD2szFAgM2wr/qrU8OHDr/tzb36fXn/9dX3wwQfW1TYzd4/pBtykSROrjPkMm2Fe5v0AgLRGnODaccKNGjp0qEJDQ7V27dqEdWY/zbnM9OAwPS8+//xza5vEzDks8XCb1LjWMTbnTPO+JGbez59//tlaNsfJvK9XbmMex2+THNO71sS6pnex6T3y/fffW5+LmxUfm3zzzTfau3ev3nvvPWsolvHrr79a/3/33XdWTGGGDRvvv/++1XtlwoQJVpnXXnvNqsfE64m98MILVo8as43Z94EDB1qf540bN1q9aU1slD179ptuO1wEeSBkdsld5TcZ4ho1avxn2c8//9zKdsczVwnMr8XBgwcT1vXv39/KLCfuMWKy7ma9YbY1V0sSX2Uxmjdv7nzxxRf/sw0pZf7//PNP68rMm2++aV1xN1n19u3bW9u+9tpr1jZPPPGEs2XLllfVaa6YLFq0KOHxhg0brF4l5kq8KV+vXr0kr7dv3z7nnDlznNu2bXP+/PPPVg8Zs0+m3K1mXsvf3/+Gj9OFCxecbdu2ta7YnD179oZ6gmzZssW6wnDixInramNK9ZqeOF988YVz586dzrVr11qfuwIFClhtu5GeIJcuXbI+U+Z5856b47FmzZoU2xMSEmJdAXn//feTff5meoKY42h6OyUnufLX87mP/30yvUziBQYGWuvWr1+f4v4BQFoiTnCNOCEteoJERERYz73xxhsJ60yPhsS9UEwP0CvPvyam+PLLL1PVE+R6jrGnp6dz4cKFScqZx+b9NMw52bT/p59+SrLNhAkTrB7OKTHvd/fu3VN8/kZ7grRp0ybFHjMpxUOmR2viz6Qxfvx4q22Jy7311ltJtqlWrZpz7NixKbYdSM7VkycAWURyGWyTUTeZZZOdDgkJUWxsrDVZlRkraybGMsxkW2XKlEkoY66um8kxE2eVzbpz584lTF5qzqfly5dP8lomK20m77pZZq4Jk/0eNmyYddXfXKUxmW/z2mY5XnJX0E174tebSTcff/xxPfroo+ratat19WLMmDHq2LGjdaXDbFehQgXrJ169evV0/PhxTZ48WY0bN06xfUePHr3u/enRo4c1fvdabb0epreCYd4zM07WXCHKnz+/bsRdd92VJpO5mTG28cxkZ+a4mc9O/Pt2vUaNGmXNb2KuipgrJV999ZXVq8JMZGbqvZK5+mE+X+YqUVox7TWfE3P1z1ztMq+f+PfgStf7uTe9mapXr57w2PQEMfPamKs3ZtJf81pmPLO56gUAtxNxQtaME1IjLj/yb2xlJq03PRXie+DGt3Pu3LnWMYuXFjHF9R7jK49FcsfnerZJzMwF88QTTyitDBgwwJpc18QKpheK6QFqepam5Pz589a+PvbYY0naYeL0gICAa/7emtjYvN6aNWusmMK8buK4A0gOSRBkWfFJjXjmRGxmFX/yySc1fvx4648xc1IzX7iJh1Nc2fXTnDSSWxc/waP53yQlTPfDxMkJI7Xd8bp162b9nD171tof87pTp061hl4YZoKwxJNhGeaPabM/8UMjzGRfZijDm2++mbDNggULVKxYMausmQ0+OWa92S4lZmjQjQxDMW1Ijvkj2nS9NV0ir+cPYZMYMHWZ2euvrNM8Tm6SVBPEXHkSvRXMe2SSFjcyDMpM2DdjxgxriJYJGI077rjD2k/z3iUXEMYPA7peZkhVfGAX78r3ztzpxnzWTJdY03315Zdftoa5tGvXLtk6r/dzb9p6ZeBlulyboMUMNzPDgEwSyATaKX0WAeBWIE7IWnGCKW8mNzVDehKfl8xjs/564gBzkcGIj7PMUFNzscxMmBrPnE/NOdBcUDN3Z7mVrjzGJu4zSavEzEW5+JjPXEgx+36tbZJzI3FF/DDtxHHFle+zuUhk4m4TU5gLPOaijRm2YhI6yYmPqc2QmMTH2rgyxrjy99Yko8yFFfNaJhFihuCayXKffvrp694nuB7mBIHL2Lp1q5VRNl+M5qRiTqrmDixpMXbTnGDNCcbcySXxz7XuKnIjzInL/GFp/mA0tzszV9DjrxKYP55NYBDPnADMbdPMLdEMM471yhNI/ONr3anDjAm9VrBRokSJq/b3Wj8p9dYwV5pMb4HEwVdiV9462AQmpodCcsGSuXVd4nlh4pl1ia+u3CqmF4QJoG6kV4N5f4zEc7/Ev0cpvT+mB4wJWMyY3ethEkbmyp7pPRMvuVv1mt8JMx7afIbM2GCTrDDM+2M+42n5uTflTQ8nM0bZjFc3gSYApCfihMwdJ5gYwJyXrryzmumNYNZfTxwQPwdW/B1cPvzwQ+tOOuacGf9j7spyzz33WL1BbrUrj7GJ+xLPV2KYc3Z8LwtznEz8d+U25vG1emKYnhM3ElMYiWPP5GIKs53p+WmSOOa4mvn04ttoJI4rTJxbpEgRa161Kz8X8QmpazEJO3OR0/TaMe+XSaYA10JPELgM84ezSYK88847atOmjTWhY3JX2W+U+cPRTCrZq1cvK8Fi/rgzt5Yzk66aXgGm90lyTJbe/Bw8eNB6bCZzypEjh4oXL271UjFMDwFz0jIJEHMCe+6556xbrcZPAma6GJqrEGairkmTJlkTa5pJK01XwvgkgZnkatq0adYEsvHdXM1teU1wYtpqmJOTGfJjeiKYSbXMCcvcgs783GrmxGXaN2jQIGuIkjmOpi0nTpywblNn9v16b39nhnSY29GafTVBk2H2wfQ4SDwhmJmUy7yOOeGbk25yzHEwV3nil0+ePGmd5E17zEnZMMfafJbMe2aSAa+++qq1D6ZLcTzznpjb0sUn3Myt7wyTKDA/Jmgz9fXv39+6QmKGkpjhMOb9XrFiRbJtM4kwMzGYmSTOBBNmn01XUjPxqOnZdCVzVcUM8zLvu7kyYvY/8QRuERER1mfLHDMTbJhjbxJHpkupYd4PcxXNHC/TS8XUdbOf+8OHD1uBUNu2ba2J+szxOHDggFUPAKQn4oTMHSeYeMj0QOjbt6/Va9a8n6a3pYkNzPore22Y5ImJw8wFDHMeMpPom/OvqdPEWeacbxIoCxcutM7ViZnjZCbxNL0OTG9h87xZTqn3pGFiCnPsTFxgjnF84qBGjRrXfYwHDx5sDY0xk3+a2xp//fXXVk+LxMN1zP6auNAMGzFJE3PONXGISRKkxPT+NL01zDEzk7ybeNn0Ck1uMlpzEcZcTDTxqGmvOfebHp2JmeFUJhlj9sUcXxPPVKpUyXrOJLtMHSY2M0OcTUxjeumYHqmml6iJX837ZcqZxKTp4XytIcbmdsBmexOXmG1NHBL/WkCKkp0pBMgCE54NHjz4qm2nTp3qLFSokHXrWzMRpbktaeLJNpObVCu526BeOamVuYXcmDFjnCVLlrQmrSpYsKB1azEzYWZKTL1X3ibM/CSeuKtnz57WrVLNhFfVq1e/6jaqxtGjR50PPvigtU9mW3P73sjIyCTbmNvh1axZ07oVa758+awJRffu3ZvwvJkAzNxq1dzGLFeuXM6GDRve9tuLmYlFzXtiXt+0w9wibfjw4c5Tp07d0O35TD2NGjWy6onfF7Musfi6zCRbKYmfgOtat3Lr0qWL9Xky77m5TayZuHb37t1J6omfHDSl28waBw4csMqaSenMJLwpvdeJmVsZmlvims++ef3ixYsnTJib3KRjZgI4c4s6c2zNreTM5GvxpwAz8a65vZ6ZlMx81sy+mM+RmSAunrndnplEOHHb/+tzn9zv05kzZ5wPP/ywddzMa5n2mzoS35oRANIScYJrxAmGue3v0KFDE8535n8zqamZgDyxxOdjs53ZNxPbmUlJ45njZG63mpxz585Zk8guWbIkob7E8VtyzPkuuXjgRo+xuaWxmYjVnHfNMYhvQ2Lm1rLm9cx51tzy/nomsDX1mJsKmDLm1rYmLklpgvg9e/Y469ata32mTBkzmXviiVHNhKaVKlVK+MyZmPnQoUMJ5c3EsibmMLdvThxXmUle49tgjkHjxo0TJpxNaUJV8z6Z42YmjDefXRM7JzdBPZCYm/kn5RQJAAAAAABA1sCcIAAAAAAAwCWQBAEAAAAAAC6BJAgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl+ChLMLhcOjUqVPKkSOH3Nzc0rs5AADgGpxOp0JDQ1W4cGHZbOl3TYb4AQAA14ofskwSxCRAihUrlt7NAAAAN+D48eMqWrRouh0z4gcAAFwrfsgySRDTAyT+YPj7+6d3cwAASFGbByen+uj4vXQmVeVjhqbuXPnlljGpKh8SEmJdvIg/f6cX4gcAQGZB/KA0iR+yTBIkfgiMSYCQBAEAZGQeHj6prsMzm1eqyjvdvVNVPq3Otek9hJX4AQCQWRA/pE38kGWSIAAAZCYlS+bT0Gfvk93uVEREtMa/slSvT+wih9MpTw93TZ3yjY4cOa9nhrRSiRJ5rTKVKhVW+3aTtGnTewprdUYN3+sov0L++u2lb+SIjpWbu001RjSz1u2cukGXjwRZ5S7uOauWX/bW5aMXtXPyekUHR6hpoaEqW7mwnnzhQTkcTl0KvKw3RnyuwS8/rLuaVNTC99Zp+aebkwQbs756Riv+tyXJegAAcPsQP6QeSRAAANLB8eOBGvz0J9Zyz14N1bBRBQ1/dpHsdoeq31FcHTvdqcmTVmn6W6utbfLly6EXRrRReJhd1av10hH/L631VuLjxWbyzZdd5349pr8/3aFqw5qo+rAm1vMRZ0O147Xv5eXvoxylcqvh7I76+eml1nOBZ0P0Uv95ioqMUe/BLVW/WWXNe3utdm09LB+/pD1Fmj5QXedPX7rNRwkAACRG/JB6JEEAAEgHJtkRz8fHU8ePBSasy+bnpUOHzifZvnGTitq4cZ9sNnd5eWVLWO/u5W4lQAybh00eTqc6LNimAqdDdLaQv6ZJKty0jPW8Z/akiY2LgZcTlmNjHdbrB10IvaqtNpubGt1bVRtX/ylvH880OwYAACD94wcfu0PlDl7QU5N+sGKHle2r6e8Nf2fZ+IEkCAAA6aR27ZJ6on8z2WMd+t+nvyggwE/jXu2g/PkDNGbU4iTbNmpUUa+Mjev9kRxHrF0H5/6qL4LC1eBUiJxubnJzOjXT010FP+pyzXbkKxigmnXL6NPZPyT7/D2t79CPa/6Uh0f63coWAACkffzgFRKpqJdXa05UrErvPWfFDk3XHlAdP0/VfPX+LBk/ZKzWAADgQrZtO6In+821rtA82LqmgoPDrSEyY19eor6PN03YLm/eHNZVlosXw1Ksa+ek9eqYL5uVAHF3OOVhd+i0wym/qFh1WP93iuX8snnrudc7aeqoJVYwldxVnCb3VdeGb3amwR4DAICMFD+cHbZMz0TFqrxTVuxgYggdCVLeoAj55Pm350hWih/oCQIAQDrw9HRXTIzdWg4Li5KHh7vMROdOZ9zjyMiYq7qypuTA/K3WZKhtz1+2eoBITmv9F5Lau7lZQ2OSYwKU59/orEWz1unk0cBkt8mVN4dy5smuce/2Up78/rK527T3j2Op3HsAAJAR4oc73aRONpuUaJjNF3JTszx+Op5CucweP5AEAQAgHdSuXUqdH6krp7kzS3C43pu5VlOm9bAemzvExE+IajRunLQr6x875+uy2wmFHb+oAvVL6sC835S7WkENORuqh+wOvfHPdksk/U9OfVco7na2oUeC9OfbPyrs+CX95rZIgx4foco1issvm5e6PXmPVnz2q8pULKS6TSvKZrOpULHcmvPmKj3T5V2rfMuHaloTph7cc+o2Hy0AAHAr4gflz6bmdofqS3r9n+2WOp3qVKNwQhIkq8UPbk6nyRllfiEhIQoICFBwcLD8/eOCPQAAMqLm97yW6jqyjbs6kPAJj9akAUtU9OjFhDlBTpTIpefe66BIP68k20YPCEjV63/754Qscd7OKO0AACA94gefG4gdskr8QE8QAACyCBOsmKDlwS93JdwdxszwnlwQAwAAEOmCsQNJEAAAshATtCzpUTu9mwEAADKJSBeLHbg7DAAAAAAAcAkkQQAAAAAAgEtgOAwAALf75Ltlb6rriOmSuonJ7GcOpKp8S1unVJWPdf57Cz8AAPDfiB+UJvEDPUEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl8DEqAAAZABNO9XVgMk91b3sM3pt+QvWOm9fL3l4uWtgvdHJlvHN5q3XPntaJSoU0tDWk3XmWKDGzH1Cnt6ectgdmjp0gc6dCFLxcgX1zKSustls+njSCv3+4/4U23HPIw301Nt91anAY/Lw9NDE1aOs9V6+XvL08tCA2s8nW65AiXya8etEHd193Ho8vvNUBV8IUcdhrdWwfV1FXo7UpD4zFXj6YhocLQAAcDPxg+8tiB0yW/xAEgQAgHTm5uamRu3u0vmTQYqNsev5+16z1jd7pL4KlS6QYrmoyBiN7TVLj41+2HocH7wEnglWrSYV1fGpFnp35Od69MU21vpL50M1ftFTKQYyVjs61NX54xesx7ExsRrebKy13Lx7IxUqk3JbjJ0b9mh85ykJj3MVyKm7HqitIQ1HqcKdZdV9dEdNf+r9mzhCAAAgLeKHqDSOHTJj/MBwGAAA0tk9Xerpx6W/yulwJFnfuP1d+vHLLSmWM4FLcNDlhMcx0bFWEGOYYMgea7eWc+cP0KnD5xV+OVKhF8PknztbsvU169ZQPy7ZLKfDedVzjTvW08bFm6+5H1UaVNDUDePUd0JX63GBEnl1dE/clZ2/th9S1QYVr1keAADc2vjBkcaxQ2aMH0iCAACQjmw2NzXucLc2fJE0WPHN7qO8RfPo2L5TN1ynu4dN3Yber2UfbrAeu7n9+1xYSIRy5Lw6kDHdXZt0qq/1n/181XOmLfmK5dGxvSdSfM2g0xfVu9zTGtZkjHLmD1DDdnfp1N9nVaFOGasbbK0W1ZU9V8oBFAAASL/4wf0mYofMGj8wHAYAgHTUrGsDbVyyRU5n0qsndR+spc0rt99Unc9M6qZVn2zS6aNx3VITX5nJ5u+n0EthCY87DG2tem3q6Pf1f2rD4p+vaodRr20d/bJ8a7KvFV/ePL9k2gprnbkaVLleBW1a+qtWzF6riatH6+8/jujE/htP6AAAgFsfPzxzA7FDZo8f6AkCAEA6KlGxiFp0a6gJXz+nImUKqv8b3RN1Zf31hut7ZHArnT12QRuX/RsABZ0PUeFS+eSX3Uc5cvkpJOjfQMYEHmbcro+ft1r2bKLXVr2kIuUK6cmpj17RlfWXZF8vvvyq979LWFetcWWdPHjaWl4zf72evedlbVq6Rb//8OcN7w8AALi18cMjNxg7ZPb4gZ4gAACkow9Hf5aw/M6mVzT7hYUJ3UeP7j35n+XHfTJApasUVdEyBbRl7S51H/aA9vx2SHc0qKC92w5r3uvLNP/15Ro2rYfVZfWTySuTreeDEQsTlmf+OlGzhs23lk1b8hc3Y3NT7spqVG1YUb3Hd1VUeJTOHD6neaP/Z60fuWiIcubz19lj5/XOwA+v+7gAAIBbEz+MS6PYIbPGD27O5PqtZEIhISEKCAhQcHCw/P3907s5AACkqJVfz1QfHVvOgFSVjz1zNtVtSNXrO2O0Xl+n+3mb+AEAkFkQPyhN4geGwwAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugbvDAABwm60O/yTVddx71yupKh+7wDtV5T1aHEtVeQAAcGOIH9IGPUEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEpgTBACATKhcxUJ6clgrOR1OXQwK08TRXypXnmx6+vkH5ZfNW39sO6IFH2xQjTol1WdAc8Xa7Zo/6wft3H5UsfYobRu4SGFHAlVrRlf5FgzQny8vkyM6Vm42N1V4vpW17sD073X57/Ny2h0q9Wh95b6zpE5/u1vHFm2Rt9NDPvJVVbe7E9pUvUll9RjVUe4e7vpi2nLt+G6Xxn75nDx9POWwOzS577s6e/R8uh43AABcWbmbjB+2/3ZA2/Z/rMsPnrvp2MErb3b5Ot2SxA7pET+4OZ1Op7KAkJAQBQQEKDg4WP7+/undHAAAbqku909W+OUoRUXFqs+AZjp44IwaNq2oOdPXKvB8aMJ2b3/4mEYOXiB7rEOvvtVNw5+cL4fTrogXz+vv2RtVrHMd+RXJqZjgCHnny6GgrUd04ae/VX5wc0WcuiTfwjkVExqpnS8sUe13u1uBjD0yWiVn5EnSHk9vT43+fJjGdZyi2JjYuHVeHvLP66/AU0Gq3bK66j90p94Z9KH1XKwzRuv1dbqft4kfAACupMtNxg/D+s9VbGyk9uVfedOxQ9GHa141sXp6xA/0BAEAIBO6GBiWsBwb67D+L1A4p/oPvlc5c2fTvPfWac+uE7K5uynscpT1vM1mk3+Ar0KCI+SV0y+hvM3LwwpiDG+7QxX/PqchU9fqdKEALX24huye7pLNLWH7U1//oQtONxVVWRV0K2atq1K/gqIjojV+2QuKDI/W9Kfe18Wzl6wAxmpjjN0KpAAAQOaLH3LmzK6QYPdkYwc3d5s8nU51/fRXFTodbMUPX9xX5arY4fwPB1TMWTQhdkiv+IEkCAAAmVi+Av6qdVcpffv1dpUuW0CvvrhYdrtDr0zuqmf6fGAFD2abmBi7SpbJr+w5fKwkSHK8QiMUOW6F3ouKVal9Z2VzOtXyu726546iKtquprVN3oZlVPDeynJreUjbtVG5nHnl7earXAUCVLBUfg1pOFo1m1dVr7Gd9PaA960ypntrj9EdNfWJWbf12AAAgFsbPzhi7To+/xctCQpTo9PBcri5WfHD5s+3qlS/RkliB3tkjHa2WZgQOxjpET+QBAEAIJPyy+alF15pp8njTbfQcJ04FqgL5+K6sppAxlzFeW/qaj338sMKDY7Q4b/PWuN/UxL63BI9ExWr8magrD3uqsu6o4Eq6eslt2eaW489s/tY/3u4eSqXM58eHnq/mrdtqu3f7dSfP+2zurL+vu5PPTKiXUK9Q2f314rZa3X60NlbfEQAAMDtjB8OTP1O7fNmV6Pdp+TucMpdTn0kySckUgMvRejTxLGDn5dyKZ/CFKpuQzupXps66RI/cHcYAAAyIZvNTSPGtdeCDzfq5LEgRUfF6nJopDWpmY+Ppzw93eWwO3Vg7yk9/9THenviCgWeC1VEeHSy9R1ZsFml3KSOtn9Dgx8kfemUhpT8d/6P2LC4rrFmSrFgBenLaSs1vNlYLZ+1RiUqFbWeK1uzlM4cOmctd3upvc4cOacNn/98i48IAAC4nfHDkQWb5VPQX239vKweIPGxwxJJU2xu1tCYJLGD3WHFDr7KpiXTVqRb/EBPEAAAMqHGLaqocvVi8vXzVve+jbViyVZrHO/4aV3l4e5uzeRudOnVQLXrllFkZIzenfxNQvmdL35pzd4ecfyi8tQrraMfb5ZXvuxqYXeovqTXJT0pKbukF3Yc04URX6r6xPY6sWS7An89LDdFqaCKy9ctm1VfaNBl/bJ8q6asf8WacX7yY+8qT6Fc6jmmk3b/tF817qmqPZsPaO7IRel2zAAAcHWNUxE/bD+wQKEep5PEDv5VC2v42RBtsjv0RqLY4T6HU4F/nFA+KSF2kFMqpCIJsUN6xQ/cHQYAgEzo3rteSVX5mIkhV63ziYjWu4M+VfFjQQljeo8Vz62nZnRVpK9Xkm2vnN39RnF3GAAAbr97iR/oCQIAAOKYRIdJeLT76veE2d3N3WGuTIAAAABk1viB4TAAACCBCVg+7XoXRwQAAGTJ+IGJUQEAAAAAgEsgCQIAAAAAAFwCw2GQId2Xr3+q67AHBqWqvJu3d6rbsCZiQarrAIDk2A6fStWB8ennn6ryzly5UlfeGS1dTFUVwFWIHwDg2mzED/QEAQAAAAAAroHhMAAAAAAAwCWQBAEAAAAAAC6BJAgAAAAAAHAJTIyKTMFmc9PwmX2Ut1BOnT0eqLeGfqJc+fw16M1u8svhoz82HdDCySuusy6bnp8/SHmL5NbZI+c1td8s2WPt/1muZOWiGjyjr7VtxOUoTej5ju7t2Vgtujc0M/xp0cSvtXnVjjTYWwBI/XfkxC+HyelwyMPTQ28/u0BH9109kapvNm+9Nr+fSpQroKEd39HJIxc0Yd4T1nNe3p7y9HLXoLZv6Y66ZdR7+P2KjbHr47dWa9eWQ1fV5ebmpmEzHlWhEvnkdDo19en5qtOiqlp0qWu+IvXplJXasnonby0yZexws/EDsQOAjMzmovEDSRBkCg1a19SZoxf05oC56jjoXjVoXUv1779D7zy3SIFnLt1QXQ3b36XTh89qYs/p6vxcWzVsf7c2fP7zf5Y7fuC0hjYbZy33GNlODdrWUZt+LdT/zhfl4+et15Y/TxIEQIb5jhzRfqrssQ5Vq19O7Z9srmlDPrmqXFRkjMb2m6vHXmhtPTZBygvdZ1nL9zxUS4WK57GWTQAzqs8Hio21a/yHj+n5bnHbJFamWjF5enlqeOtJqtm0kto8fo9qN6usAY3GycfPSxMWDyYJgkwbO9xs/EDsACAja+Ci8QPDYZApFCyRT3//edxa/nvnMVWrV04FiuXVE+M6auKXQ1XpztLXXVeh0gX09+9HrOW/th9WtUaVrqtc4qs93n5eVmBz6u+z8vb1km8OH4UEXr7h/QKAW/EdWbVuWSuAMfyy++rw3uRvp+uwOxQcFJbsc43ur65N3/yRcAU8LDRSUREx1rJ/Lr+rtj9/6t/73Wb391NwYKhOHzovb19P+Wb3UUgKrwNkhtjhZuMHYgcAGVlBF40f6AmCTMEkHGo3q6KfVuxQjSaVVLRsQZWqXEQTHpstu92hsZ88pcGtJl5XXcf2nlSdVndo05dbVKtFdWULuPqXMSW1mlXV4xMesbKZn09Zoa1rd+qDHW/I5m7T5Cdmp2IPASDtviNNEBGQJ7vGfDxA+Yvk1iu93r2h+kw313yFAnTs4DnrcUyMXfkK5VRMdKxKlC+obP6+Cr6ijEkEm+6z728eJ08vDw174A2FBYdrzs+vWN+RUwbO4y1Gpo0dUhM/EDsAyKiOu2j8QBIEmcKWNbtUvWEFvbF0mI7sO6VDfx5Xjlx+unA6rjuryViaXxKTlUxJh6GtVa9NHf2yfKv1izjp+5d1ZPdxXTx7/V1it6/7U0/VG6VOwx5U2ydbquFDd6p31eHWL+yb37yobd//mSb7CwCp+Y4MOhes4MDLevbBSSpfs6R6v9ROo7pMv+766javrM3f70l4POfVrzXszS66HByuI/tP69KFq3u+mSAqOjJGT9Qdo7LVi2vgG12tK0x97xxlfUdO/GqYtq//t04gM8QOaRE/EDsAyKi2uGj8QBIEmYKZJGfO6MXWco/nWmvHxr3WL4mZ2MxczfHw8vjPIGbJtBXWT2I9X+6k7d/tuq42mF9CE/wY4cERivaKVnRUjGKiYqzurp7entbEPqatAJDe35Hx30fhIRGKDI+6ofoa3l9d86d+m/D4wK4TerHnbKsb61Mvt1NEWPL1hV4Kt/43wY5fDt9/viNjrT82zXhfviOR2WKH1MYPxA4AMjKni8YPJEGQKeTK768X5zxu/SKYX87dW/7WvNe+0rhFg+Tu4a6PJ359/XUVyKmXPh1iJS62f79Lu3/ad13lajWvqk5DH5TD4VTwhVBr+ItJfLy9Yax1JWnZ7LUkQABkiO/IM0cD9cZXZnZ3p/WdNfOFRSmWHfdBX5WuVFhFS+fTqk8366fVu5S/cE4d++tswjad+t+j2o3KKzI8Wu+N+yrZerb/sFvNO9+tN5cNl6e3h+aM+lyV7yqjaatHyN3dpuUf/sB3JDJt7HCz8QOxA4CMLJeLxg9uzixy2TokJEQBAQEKDg6Wv79/ejcHqXRfvv6pPob2wKBUlXfz9k51G9ZELEh1HQBwK74n3QJSd650XrxyVO+NiXVG6/uL89P9vE38kLUQPwDArf2edMsC8QN3hwEAAAAAAC6BJAgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAneHQYbkLJI/1XVUWhOSqvJ7a9/YLaEAuI57fXukqrwtDSZetoek7jtu7fnZSk9xE5LOT9c2IOshfgCQkRE/ZIz4gZ4gAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAnMCYIMq2ylwhrw3P1yOJy6FBSmiSMXyx7rUL6CAZq7bIgGdX1PR/8+pzZd7lLHRxvqr92n9Opz/1OsPUpbDy3UDw3OqdP8FspTNqeWPPa93GySPcahZqPutNatf32rgg4FW6915s8g9f22rRyxTn374s+S06lop6fuyt5Uk74bq5JViumZeiN1ZPdx+fh5a+yXz8nTx1MOu0OT+76rs0fPW/W4ubnp/V1Ttfy91fp65rfpfAQB3A4lKxfV4Bl9ZY+1K+JylCb0fEcPPt5MDR++U5GXozSp32wFnb50zTrK1yqlx8d1tJZzF8ipX9fuVImKReT1z/fM1IFzdfZYYIrlC5TIpxm/TtTR3cetx+M7T1XwhRDlLZJbz8x8Qn7+vvp9/Z9aMO6LNN57IOMhfgDgCvFDamMHV44fSIIgwwo8F6KRT32sqMgY9Xm6herfU0k/rt2tzn0aac/vxxK227hmt7b+9JceG9zKemyzeapWqS46U3ppwjYPz7pH7p42ndx2Tr8v3K/mL9+tpi/WsZ4LPROm78ZskU+At3Ys2Kdy9xZXtY5ltbzW7zoVcVyj20xUvzd7JtRlvqgm9X1XgaeCVLtldXV+rq3eGfSh9dw9XRvo3LELt/EoAUhvxw+c1tBm46zlHiPbqUHbOrr7vhoaes84VahTWt1HPKx3Bs+7Zh0Hth/W860nWctDpj+qX1bu0JJ3Vivw9CXVuqeKOj59n2Y+t/CadezcsEfjO09Jss58d7391PvW9xXgKogfALhC/JAWsYOrxg8Mh0GGdTHwspUAMWJjHVYvkAKFc1q9NM6d+TcrGnwxzOotEs/mZpOXR7YkdZkEiBF9OUb5S+RQi4/2qMurv1n/H/nmqMq0KGY9n6uUv7WN9ZqKkbvd3cqGJhYTHZvwhRAbY7faZb2uzabGHetpw+Kfb9ERAZARmcRoPG8/L508eEZH9p60Hv+144iq1q9w3XXZ3G2qWKeM/vz5LyuIMWJjY2W3x33PXEuVBhU0dcM49Z3Q1Xrs7uGuAiXzq//kXnrzu5dVuV75m9g7IPMhfgDgSvFDamIHV40f6AmCDM8Mf6l5d2kten+9Br7woD776Ef1ePKeG6oj4mKkVg7bpNDTYfrCy6aWp8LlsEk2hzTBy6Zan91nbVegcm79PH2n9q08Iqe8FKA8KdZpviB6jO6oqU/Msh43695QG7/4RR6e/FoBrqZWs6p6fMIjio21a8nb36hC7dLy9PLQHU0qK3uupEnZa6nRuJJ2/bRfTqcz4Xum+/Nt9dbT1+5JEnT6onqXe1qR4VEa9v6TatjuLu355YBKVS9uXd0xydpxX7+gp+u+mOp9BTIL4gcArhA/3Gzs4MrxAz1BkKH5ZfPW86920JQxS5W/YIC17uypa4+tT45vLh91/KiFXm5SRFNPhMnmcMoj1qlTDqf8Iu26/7u4cXDbP96nmj0r6IP17+ibH1aqxdB6KdY5dHZ/rZi9VqcPnbV6gTTt3EDr/0cvEMAVbV/3p56qN0o/Lv1VrR5tohXvf6/XV7ygO1vdoRMHTl93PY0erqMfv96a8Hjw2720cu56nT4SN+/QlToMba3J68aq7cD7rADG+HHJZpWpUUqXL4Xr5IHTunAySBfPXrKuOJmrRYArIH4A4Crxw43GDoarxw9cskaGZbO56YXXOmrhnPU6eSxQDZpVVoky+TVhZi+VLFdAhYvl0fNPzE0YjpISR6xDbjY366fIpShlc5P0z+gZM8VPO5uU52RYwvY+/l764fwqfXfP24pRlEq6Vbyqzm4vtdeZI+e04fO4pEeugjmVq0CAXl3xojWRkPmiMFlUAFmfuWJjhskZ4cER8vBy19oFP1o/1RtV0qVzcRMw/xfzvVHpzjKaPuRj63HX4a115ugFbVz6W4pllkxbYf34ZvdJWFetcWUd23tC0ZHRunwpTH7+fnLE2q12monSgKyO+AGAq8QPNxM7GK4eP5AEQYbV+N6qqnxHcflm81a3fk218vNf9WzfuAlInx3XTl/M/8lKgDRpVU1tH7lbRYrn0cRZvfXigPna9vciRZw8o0tHQlWyUWEd23zGSoJsOBOuTxO9xhJJnzmlrUXiuptV71LOmiR1xyf7FG6+DFRXE1a8qDI1SqpohcJaOWettq35Qz3HdNLun/arxj1VtWfzAc0duUgD7xph1XHvo02tL5S/th9Kl+MG4Paq1byqOg190JqbKPhCqCY/MVsjPx6ogLz+OnvsgmYM+e/uqMYdjSpq188HrO6suQvmVPcX2mjPloOq0bii9v76tz4a92WKZas2rKje47sqKjxKZw6f07zR/7PWfzTqU726fIQ8PN01b0zcOiCrI34A4CrxQ2piB1eOH9yc8YOHMrmQkBAFBAQoODhY/v7+6d0cpFKrGqNTfQwrfHTwqnVe4TEa9uhaFTwcmjAnyJlSOTR1fktF+3km2XZv7bjMbGqsdSxOdR0AMp57fXukqrzN2zvVbbCHJJ20ObN9P2WU83ZGaQfSBvEDgIyM+CFjnLfpCQKXYhIdJuHR+LO/rCEwgUWyaWOXclclQAAAAIgfACDrIQkCl2MSHt/1qZzezQAAAJkI8QMAZA1Za5pXAAAAAACAFJAEAQAAAAAALoHhMMiQHH/+leo6DnQpnqrybh7HU90GAFnTycG1U1XeWff6bpt7LUXa7051HUBWQ/wAICMjfsgY6AkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl0ASBAAAAAAAuAQmRkWm4JvdR2+sGaWSlYvqmQajdGT3CeUtklvPzOgrP38//b5+txaMX3J1uWzeen3eEypRtoCGdJ6ho3+dVZse9dXi4VpyOqVP3/1eW37Ya23r5uamWSuHacWiX7R8wc9X1VWuZik9OaWXnA6nLp4L1sReM/TBH5N04dRF6/lPJ36l7d/vug1HA0BGcGfponqy2d1yt9k0f9M2Fc+TUy2rllN4VIxeWrxa50PDNPqhZipdILe1ffVihdTstTkKuhSso89/oKjj51Ry4uPyKZFfp975Wpe3HlDeLk2U+4G7rO2DVv2qoK9+lk/Zwir6fGdr3aXvd+jS2u2SU4px5lRJt4pXtatAiXya8etEHd0dN7nz+M5TFXwh5LYeGyCjSO/4gdgBQFrED01enq6d895W1NunUxU7ZL+rgoool1w9diAJgkwhKiJao9u+oX5v9EhY1++N7np74IcK/CcJkWy5yBi93O8jPf7CgwnrWnerpwFtpsnHx1MT5j6eEMQ0bV1D509dSrGuC6eCNPLB16229BnfRfUfqqOwkAg913J8mu0ngMzBy8NdvRvV1pMfLVWM3aG82f3Us0FN9XjvM1UrWkBPNr9b479ap/Ffr7O2LxiQXa91bqXgiCjZPD1V7KWuOjd/bUJ9+bo3k1+VEvIICdfjSzap6LmL2uufTV+M7Kqjn29I2M6vakkFNKthLZ9uP1OFnSXl5eZzVft2btij8Z2n3JZjAWRk6R0/EDsASIv4ITTWoeIdH9fZP5dcFTs4IqPlFxGtbqt+VY7j53S4fmW9dzoo2djh6MiPFO28w+VjB5IgyBQcdoeCL4QmPHb3cFeBkvnUf1JP5czvr3ljPteeXw4kX+5iWJJ1p48GytvHU77ZvRVyKdxaZ7O5qdH91bTxmz/k7euVbBsunv33lpaxMXY5Yu1WHZO/G2MFOTMHf6TQK14LQNZUs0RhRcbEauajDykiJlafbNqug2cDref2nDqncSXvTbL9vdXKac2uuFt/u9nc5RGQLcnznrlzyCs6Vr2+/kWDQ8LkcHNTB6dTjX/arfbF8iVs51Xg36s3NmtEq1uy7avSoIKmbhinPzft1dyXPk3TfQcyk/SOH4gdAKRF/GDFDn7Zr4odDBM/fPrCByp98oIVPxxzOLTdx0sXIqIV7uuVJHZw83AndmBOEGRWAXlzqFS14prz/AK93uMdDZja67rLbv1xv+aselbTv3hGX3+8yVp3T9ua+vGbXdZQl/+Sr1ge1WpWVZtX7tCQJmM1vMU4bV3zh3qO7piqfQKQeeTJ7qeiufw1cP7XWrxll9rUqqSqRQvK091d9coWl7+vd5LtW1Qpp+/+PHjNOuvuPKS8wZfl7nDK0+6w/i9+Jsj6uVLor/vlp+zyckv6OkbQ6YvqXe5pDWsyRjnzB6hhu7gusgDSL34gdgBwq+KHOnuOWgmQhPjBKWX7p2fIlbGDV6HcxA4kQZBZXb4UppMHTuvCySDrKos91iGb+3/P8+uXzVv3d7lbfVu+qSfum6Tew+63ruI0eeAObVj5+3+Xz+GrFz4aqMlPzJI91q7QoMvW+o1fbFaZO0qkyb4ByPhCIqK0/egpqyvrlr+Pq2TeXPp8y069/1h7NaxQSkfO/9vNvoB/dtkdDl24HHflOCW5Q8LlvKJnh7mi4xsZk2Rd5JGzClq+WeUV17X1SjHRsYoMj7KWf1yyWWVqlErFngJZS3rED8QOAG5l/JAzNNyKFxIzaVkztPbK2KHAY/clW4erxQ4Mh0GmFB0Zo8vB4fLz95Uj1iFPT3er6+p/cTidio6KsX7R7XaHPL3clStfDuXMk0Pj5vRVngL+VjC0d8dRHTgSNzFQPBPsjPh4oBZMWKKTf52Rh6e7NRmaqatao0o6+ffZW7jHADKSXSfOqFfDmtZypcL5dCIoWF9t22P9mAnPghIFLImHwlxLkL+f3Kyw5V82p1MRPp4Jj2OCQnXmvRUq8kJnuT9+LMWJICMuR1rL1RpX1rG9J256P4Gs5nbHD8QOAG51/HAph58VLyRmUiIn8ue6Knawef8bU7hy7EASBJnGhOUvWL0tilYopJVzvtdHoz/Tq8tesJIR88YuTrHcuPf7qkzFwipaKp9W/W+zNn27S9M+Hyh3d5uWL/xFgWdD9EyH6da2LdvVlk82bx3cffKqehp3qqfKdcvLN7uvuo9srxVz1qrzs20UGRalmKhYTek365buP4CMIzg8Uj/sOaT5/TtZfxyN/mKtJnV9QLmz+erUpRC9+lXchGaGmfF92MIVScofG79QUYfPKPpkoHK2qq3okxf09bHz+tXdXX/H2jXZ3abFDoemeHpoz6Uweb38sYq/3FMXPluv2OAwnZq6RBecYaqk2srmFjcmOF7VhhXVe3xXRYVH6czhc5o3+n+37bgAGVF6xg/EDgDSKn44tniOIi+eSBI7hP52QKti7Xrcz0cfhEfqU6f0ntOp/TY3rd3xt4q0a5AkdjByOiu6fOzg5nRekTbKpEJCQhQQEKDg4GD5+/und3OQSi09Hkn1MXQvXTxV5R1X9AS5GWuimZAQyIqqjJiWqvLOuv9OtJxY/OzupguruYKz6IG7rEnNklOk/e5UtWGtI+U//lzpvJ1R2oG0QfwAICMjfsgY5216ggAAkEGYhMcHHRqmdzMAAEAmQvxwY/57JigAAAAAAIAsgCQIAAAAAABwCSRBAAAAAACAS2BOEGRIa2O5mwGAjKvI29tSV8G01M9JniVmNQfSGPEDgIyM+CFjoCcIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJzggAAkAaadq6npyb3VOfiT6lJx7vVbtB9io6I1qQnZuv8iaBrli1Xs6SenNxTTodTF88Fa+Kj7+rBJ5qpRfdGktOpRRO/0uaVO64q55vdR2+sHaOSVYrpmXojdWT3cfn4eWvsl8/J08dTDrtDk/u+q7NHz6t4paIaOru/bO42zRvDvEsAAGTm+CE9Yocd3+9SVkASBACAVHJzc1OjdndawYq7h7s6PHO/hjUfr/J1Sqv7iIf11qC51yx/4dRFjWz9hqIiotVnXGfVb1tbbfq3VP/aI6zA5LUVLyQbyJjtR7eZqH5v9kxYZ4+1a1LfdxV4Kki1W1ZX5+fa6p1BH6rvhK6a3HemLp4N1mvfvMR7DgBAJo4f0iN22JFFkiAMhwEAIJWadamvH5f+JqfDoSJlC+jInpOKjbFrzy9/qWTVYv9Z3gQXJigxTDlHrEOn/j4jb18v+ebwUUjQ5WTLmas1wRdCkqyLiY61gpj4uuyxDms5d6FcOnnwjMJDIxQSGMp7DgBAJo4f0iN28M+TQ1kBSRAAAFJzIrW5qXGHu7Vh8Wbrcfac2axgIeF59+s/1eYrlke1mlXV5lU7tHXNTn3w+5ua8dN4fT1z9Q23y1xR6jG6o5ZOX5VwtSleWHD4DdcHAAAyXvxwO2OHHLmzKytgOAwAAKnQvGtDbVyyRU6n03ocejFMfjl8k1xxuR6mzAtzB2hyv9nWVZwHHmum3lWelaeXh95cPVLbvvu3C2qHwfer7gM19cvyrVoybUWy9ZkxvCtmr9XpQ2etx+YqUzwTaAEAgMwdP9xw7PBgLf2y7Lebjh1CU+hdktmQBAEAIBWKVyqssneUVLOuDVSkbEE9+Ng9KlGpiDw83a0xvYd3Hb+uq0Ej5j+lBa8t1cm/zsgnm7eiI2MUExVjjdP19Pa0rsbEB0pL3v5GX0z+OsX6ur3UXmeOnNOGz39OWBd05pLVPtN9NqtcyQEAwFXjh5uJHcyPMyZuCM3NxA5ZZTitmzP+qGRyISEhCggIUHBwsPz9/dO7OQCALOxe3x7Jrp+xaZwGNRyjpp3q6uGBraxgZNLjs66e3d3hvGpm+EFvParDf8YFPCvmfK98xXKrUbu7ZXN307fzNmjl+98nKRMfxExY8aLK1Cips0cvaOWctdq25g8tOPKudv+033p+z+YDmjtyUZIZ3ue//JneWDNa6SmjnLczSjsAAFlfWsYPNxM7xMcPE24ydtj+3U6tdSxWekqL8zZJEAAA0iiIuW5XJEFuRkpXcq5XVghislI7AABZH/FDxjhvMzEqAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BK4RS4ypJa2TqmuI7pVnVSV9/3171S34dvAOamuA0DGsyZiQXo3AUAyiB8AZGTEDxkDPUEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl8DEqMhUytUqrQHTesvpcOri2Ut6vcd02WPtKW5fqkRePft0K9kdDkVExOiV17/WfS2rqVXzKnI6pU/+97N+3hI3AaqbmzRv1mP6asUOLV2+/aq63NzcNGzGoypUIp+cTqemPj1f9R6ooYZtaikiLEpTBn2koDPBt3T/AQDArY0fiB0AIGsjCYJM5cLJIL1436uKiohW3wld1eDhO7Xxi80pbn/sRJAGDV9oLT/arYEa1S+vh1vXVN8Bc+Xt46nJr3ZOSII0b1pZZ8+FpFhXmWrF5OnlqeGtJ6lm00rq+uwDyl8sj4bd/4bK1yqpbsMf1Izhi27BXgMAgNsVPxA7AEDWxnAYZCrm6o0JYIzYGLvssY5rbm+3//u8j4+Hjp0I1MlTF+Xl7Sk/Xy8Fh0RYz9lsbmrasILW/7gvxbrOn7qYsJzd309njwXq6L5T1uODfxxTlbvLpXr/AABA+sYPxA4AkLXREwSZUr5ieVWreTUtfHXJf25bp2ZJPflYU8XG2rXo8y36dethfTz7MSvx8frUVdY2Le+prPWb9svDPeW8YEjgZTkdDr2/eZw8vTz0XJvJGjm3n7VcvWEFZc/pl6b7CAAA0id+IHYAgKyLniDIdPxy+GrEx09rUt93rzkfSLytO47o8UHztGHTfrVvW0ut779D3R+bo579PtATjza2kiH3NK6kdRv2XrOe2s2qKDoyRk/UHaNXe8/SY2M7aNW8DZrwxRDd2aKqThw8k4Z7CQAA0it+IHYAgKyLniDIVGw2m0YseEYLxi/Wyb9O/+f2np7uiomJC3Quh0XJMzpW0TF268d0d/Xy9FDuXNmUK6efJr7SUfny5JDN3U27957U8V/j5gpJLPRSeFxdweHKHuCrtZ/+Yv1Ub1Bely6E3oI9BgAAtzN+SE3scODg2avqI3YAgIyFJAgylSad66lK/QrW1Zzuozpq+aw12vD5z9fszvpIx7us2eAvBUfo9akr5enpoXen9ZS7zU1LV2zXhcDL6j/4Y2v7+1pUla+vlxXE+F5R1/Yfdqt557v15rLh8vT20JxRn2vE+08oIG92nTsepJnPMykqAACZPX5ITexwJWIHAMh43JzmXp9ZQEhIiAICAhQcHCx/f//0bg5SqaWtU6qPYXSrOqkq75tMT5Ab9W3gnFTXAQBZUUY5b2eUdiBtED8AQNYWkgbnbeYEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCd4dBlhUx+FKqytsml06ztgAAgMyB+AEAsjZ6ggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlMCcIMoVytUprwLTecjqcunj2kl7vMV32WLuadK6v9oMfVFREtCb1nqHzJwIV64zRdm3U5XZfq9K0XvIrmU+Hp67UpS0HVbh7QxVoW9uq88iM1Yo8dsFavrz/tGosGCiPHL46s/Q3a1vbUTc92PoZvfhCJ9ntDkVERuuV8V/r/Vl9dCHwslVuwcKftW37EQ16qoXKlskvbx9Pfb54i35Yvy9djxcAACB+AABcjSQIMoULJ4P04n2vWsmOvhO6qsHDd+qnr35Th6GtNazxGFW4s4y6j+6ot/rPlk3uqqGG2t3wcEL5Ir2bKEe1YrJHxMg3Ilqdlm9TYYdTp+qU1if1ymvvzNVWAiTsrzOKPh+iihO7KtvkAJ09F6Onhyyw6ujVs4EaNSyvsLAoDX12UZL2vTd7nZUo8fHx1Dtv9SAJAgBABkD8AAC4EkkQZAqm90e82Bi77LEOFSlXSEf3HFdsTKx2/7xf/Sb1sp63udnkJe8k5b1yZ7f+94yJ1dyhH6vk8UA53Nxkczp1+qutCup4t/X8pV8OyBEdq30jFsk/sIjKlm8tN7e4UWM+3p46djxQvr5eemtKN10IDNXb76xVaGiklQAxfH08dfSf3iUAACB9ET8AAK7EnCDIVPIVy6tazatp84ptyp7TT+EhEQnP2dz/++Ncc9dxKwHi7nDK0+6w/t9wMUx9/qkn5lK43Nxtqjixm2zunjp3dpdq1yqpObP6qEaN4jp16pKeHvKJhjy7SL/+dli9ezVMqPulF9vog/cf09ZtR27R3gMAgJtB/AAAiEcSBBmaGe4yed1Y63+/HL4a8fHTmtT3XWs+kMsXw+Tn75uwreOf3hjXEhAaYfUAiXfin+5QFf9Jgrhn85Z/jRLWcq5cZRQeds6a86Pfkx9p48b9av1gDYWERFrPr9+wT2XKFEioa8Lry/Vonznq1rWeEr0EAAC4zYgfAAApYTgMMrQl01ZYPzabTWOXPqcF4xfr5F+nredOHjyjEpWKysPTw5oT5NCuo/9ZX3AOX2sITLwvTKDkJp0qGGA9zl6lqML/Pqtc9corNPSUcvjnT9jWzAXi5eUhT093xcTYdUf1Yjp16qL1XPy6qKhYRYRHK9FLAACA24z4AQCQEpIgyBSadK6nKvUrWL1Buo/qqOWz1mjD5z/ry7dXasr6VxQdGa03H52RsP0O5yaFbL+syBNByv9ADUWcCNKlzQe10m7X49m89UFYlNUj5Au7Q5OL5NYLbeLuGJPzzjLWnWH2Pb9QPqEB6ty5t7p2qS+H06ng4HDNmv2DZrzdUxGRMYqJidWbk1dZ5UaNbCt/f195uNv08YKf0u04AQCAfxE/AACu5OZ0Zo1r1iEhIQoICFBwcLD8/f3TuzlIpZa2Tqk+hsGryia7PuHuMGeCrR4gi9vUVoSv11XbmbvDpNYP341IdR0AkBVllPN2RmkH0gbxAwBkbSFpcN6mJwhcjkl4fNy5Xno3AwAAZCLEDwCQNTAxKgAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCc4Igy8rVKe5WujfLEXYwzdqCzC+1k+2558uX6ja4uacub/3NqX/voAQASB7xA9IS8QOQ8dATBAAAAAAAuASSIAAAAAAAwCWQBAEAAAAAAC6BOUGQKVS4s6yeeKOHtZy7UC79+s12zRo233qcr1hezTswXQPrvKAju48nW75A8byavmGMju49ZT1+7dF3NXL+U9ayt4+nPLw8NLDhy9dsQ7lapTVgWm85HU5dPHtJr/eYLnusXQ8NvE8tejaR0+nUoglLtHnFtjTee2SWz+QHLyzUxNWjrHVevl7y9PLQgNrPJynnm81br3/xjEpUKKQhD0zS0X2n1fih2mrX7x5FRcZo8tMf68Kpi3FlJ3RS4dL5FR4aqXG9ZyeUf+2zp63yQ1tP1pljgRoz9wl5envKYXdo6tAFOnciSP3HdVCZKkXl7eulJbO+18Zl29PhKAFA+iJ+QEaSXrFDfB3ED0AckiDIFPb/dlDDm421loe9/6R+/uq3hOceeeEh7f5p/3/WsWvTfr3ac2bC4+cfmGj936xLPRUqlf8/y184GaQX73tVURHR6juhqxo8fKc2frFZbQa0Ur87npWPn7de/3YUSRAX/kzGxsQmrGvevZEKlSlwVTkTrLzc4z09Pqad9djdw6b2TzbT8LZTVb5GCXUbdr+mD1+kto811a/f/anNq3ddVX5sr1l6bPTD1uP4xEfgmWDValJRHZ9qoXdHfq4Pxi2VPdYhHz8vTf56GEkQAC6J+AEZSXrFDvF1ED8AcRgOg0zF5m5TxbvLadePe63HBUvml9MpnT924T/LVq5bTlNWv6g+L3dIsr5xuzv149J/kyopMb0/TALEiI2xW39gGqcOnrGutvvm8FVIYOhN7hmyymcyXuOO9bRx8eartjdJi+DAywmPi5TOr6P7T1ufqT2/HVKpSoWt9XWaVVbVu8vqzS+H6IGeDZOWD/q3fEx0rJUA+fdzabeW4z+fJjl37MCZNN9vAMhMiB/gyrFDQh3ED4CFJAgylZrNqmrXxj3W0BOjywsPafHkZf9ZLujMJfW543k92+p1BeTzV4O2ta31vtl9lLdIbh3bHzdM5nqY4Te1mldL6PHx2+od+mD3NM389XV99c6qm943ZI3PZPznKl+xPDq298R/ls/m72d1WU0cGBn5CufS3q2HNaLTdDVtf6fyFsp5zXrMVaFuQ+/Xsg83JKx7fsajevf7F7Vj476b3DsAyBqIH5CRZJTYwSB+gCsiCYIMrcPQ1pq8bqz1v9G4Uz1tWPyLtVyodFx3wbNHz/9nPeZqeVR4XC+OTV9vVZlqxa3lug/U1OZVv193G/xy+GrEx09rUt93rSvu5vGDT7RU7/LPqG+lIeo7oVuq9xmZ9zMZr17bOvpl+dbrqu9ycLj8cvgkuVJjrQ8J144f91mP9249pCJlrj1k65lJ3bTqk006ffTfXlFvDpqvfo3Hq/Oge+Xm5nZD+wkAmRnxAzKSjBo7GMQPcEXMCYIMbcm0FdZPfJa7Ut3yeqv/HOtxmTtKqETlYnpt1UsqVa24CpctaI2pjB8OkJjJrkdcjsuYV2tQQcf/6flhhsLMe+WL62qDzWbT2KXPacH4xTr512nrOYfDqejIaMVExVivayanNH9sJs7sw3U+k4m7s3406tPrqu/U4XMqXr6QPDzdrXG9h/ectNbv+fWQylQtpl2//KVSlYvomwWbUqzjkcGtdPbYhSTzfpjJ0azkX0SMIsIi+UwCcCnED8hIMmLsYBA/wFWRBEGmUeOeqtbYyfgEw6alv1o/xnNzB2rxlGXJJkCMKvXKqffoDoqKiNKZIxc0f/yXcd0Oi+bW0X3XNxSmSed6qlK/gtX7o/uojlo+a402fP6zNi7ZrOk/T7BOasve/ZY/Nl34M2mYz1X+4nl1dE/K3VnHLXxKZaoWVdGyBbTq4036as46TfpqqKKjYjVpUNxdjz6fsUbPvt1LvUe21bZ1e3TmaKDc/unuOu6TASpdpaiKlimgLWt3qfuwB6wxwXc0qKC92w5r3uvL9PzM3vLPlU3unjZ9+ta3t+FoAEDGRPwAV44dktRB/ABY3JxZ5JJ1SEiIAgICFBwcLH9///RuDlKppa1Tqo+hLVu2VJV3hIWlug1rHYtTXQeyxmfSPV++VLchPglys745NSPVbQCy2nk7o7QDaYP4ARkN8QOQ8c7bzAkCAAAAAABcAkkQAAAAAADgEkiCAAAAAAAAl0ASBAAAAAAAuASSIAAAAAAAwCVkuVvkPhTQSx5unjdV1ubnl+rXX3057hZV6TmreUaQ2ruicFcVZDQeBQukqnzFledT3YZtY2qnug4AySN+yBiIH5DVED8AGQ89QQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASstycIFeq3qSyeozqKHcPd30xbbl+WbZVHYe1VsP2dRV5OVKT+sxU4OmLyZYtUDyvpm98WUf3nrQeT+g5U4+P76K77r9DC1//Wstmf3db98XNzU3D5z6lQqULyOl0anLfd3X60Nn/LOeb3UdvrB2jklWK6Zl6I3Vk93Fr/fAPn9LdrWtrwbjF+nrmtymWL1ertAZM6y2nw6mLZy/p9R7TZY+166GB96lFzyZWWxZNWKLNK7al6f4CGY1vNm+99tnTKlGhkIa2nqyj+09r6LQeurtFFS2c+o2Wf7TR2u6OBuXVe0Qbxcba9fGbK7Xjp936tNd3Cvo7RF3mN1fesgFa/Ng6yeYmR4xDzUfVsdad3H5eG9/6w/pdL1m/oOr2r6Ldyw7rtw/3Klt+X0WfPqCKtbqqeeNKGtyvudr2mKFmDSuq40O1FR0Vq9feWqVzF0JVvXJRPdW3qRxOp37ddljz/vdzeh86INNx9fghtbGDQfwA/PP7RPwAZChZOgni6e2pjsPaaOQDryk2JtZal6tATt31QG0NaThKFe4sq+6jO2r6U++nWMeuTfv1ao8ZCY8/GrtYOzfts4KD261MjZLWPg1rMka1WlTXQ4Pu06xh/z0Ra1REtEa3mah+b/ZMsn7uS4u0c+Oe/9yXCyeD9OJ9r1r19J3QVQ0evlMbv9isNgNaqd8dz8rHz1uvfzuKJAiyvKjIGI3tNUuPjX44Yd2815dp1y9/WQFOPJMAGdX9XcXG2DV+wQD98fN+PfR2Q/341s6EbdrPaip3T5tObDunP+bv02ul/TVx8d96uXkRHRlQVQsG/aga3cpZ29boWk41HilnTYzq5iY1bVDeSna4u9vU+eE6GjRikSqWK6ReXepr8szV6tr+LishcuxEkGa80U1fLN+my2FRt/loAZkX8UPqYweD+AG4dfHDmZ9O6+zYXzWgYi4N3XFerV+9Wzkq5dbnfdcRPwCuPBymSv0Kio6I1vhlL+jlJc9ZCZACJfLq6J64qxl/bT+kqg0qXrOOynXLacqakerzckfrcdDZYKWXCycCE5az5/RT8PmQ6yrnsDsUfOHqbYPOXLqu8qb3hwmGDPOlbI91WMunDp6Rt6+XfHP4KiQw9Dr3Asi8rN+loMtJ1l08d/Xvls3dprCQCOv3xiznzJNDfrmS/sFgAhirzsBIddx8Rg/M3KX6Z8NVY9FfGtjrO9nklIeXu7XNzsV/W0HNuZO/q0WTylr/0wE5HE4VLZxLh49dUGysQ3/uPanSJfNa2x85fkHZ/LytJInZLjo6LgkM4PoQP6Q+drC+H4kfgFsSP3iFx+i+CVt1/96LumvZYTU9HKp2z/8s95AoudnciB8AV+4JkqtAgAqWyq8hDUerZvOq6jW2kz4a9T9VqFNGnl4euuOeqsqeK1uK5c2Jvk/15xQVHq0hM/qqQdva+mlZ+g35CL4Qag1J+XDPW9ZVqqENR93W189XLK9qNa+mha8usR7/tnqHPtg9zfpDy3QLBhAnJiZW+YrkUkxUrDV0Jpu/71WHJvxipJYP+0kxf4foxbAY2ZxSe0km3ep9KFQN78wvD293lbmniCq3LqmYiFgtaPuTmtYfrVGvL1eXh+9UjmzeCg+PS1Aa7ra4xMqPm//S+BcfttqxZv0eRcfYeWuAG0D8kLaIH4C0jR9W9/hOi85E6Gvzx1ysU+1M/HAyXPa236hEl7LED4Ar9gTpMLS1Jq8ba419/fOnfdZQmN/X/anilYpaPRZWzF6riatH6677a+rE/lMp1hMTHWslQIxNX29VmerFlZ770/XFdoqKjNZjlYdoXMfJ6j/l0esqZ/5Pzeua//1y+GrEx09rUt93rflAzOMHn2ip3uWfUd9KQ9R3Qreb3Dsg65kzZomGTeuhga911pF9p3Tp/NU9pcyVnS4fNdfrdfLppX/WPWsSGJL2ukunTlxW0KEQ+eTwsq7qeGXzVN/HntSq1T/L6YzbPvRypPz8vBLqtDviemkN7HuPnh6xSN36v68yJfOpRNHct2fHgUyO+CH1sUPi40j8ANya+OGDegX1mbs0MlH88IO7tLh5EV04GEz8ALhiT5Al01ZYPzlyZ9fIhYOtdWVrltKZQ+es5TXz11s/ZtKzS+dSHt5ixrtGXI60lqs1qKDj10iY3I79ufO+Ggk9Vy5fClP2nNmuq1xqX9dms2ns0ue0YPxinfzrtPWc1cU+MloxUTFWUsT0TDETr5kJ1wBXd+CPY3qx8zvyz51NT03orIgr5uNwxDqsxIb5iS2aXdmc/2alA8wXs1Ny9/dS1OUY68c7u6fVlbZUsdyqW7+RHm7jYQ2FaXNfDZUsllceHjZrTpBDR87H1e90WnOAmF/H8IhoZUs03hhAyogfUh87JD6OxA/ArYkfgopkUxmHFP+XgIkfcjmk/UWzyys6hPgBcMUkSLzQoMv6ZflWTVn/ijWMZPJj71rrRy4aopz5/HX22Hm9M/DDFMtXqVdevcd0UFRElM4cuaD545eoz9hOqvdgTdnc3VSoVH7NHrHotu3PtjU71aJHE0354RV5ento1rP/PSlqvAkrXrQmVi1aobBWzllrJYH6vtZN9drUscYcFipTIMVJVpt0rmeNjza9P7qP6qjls9Zow+c/a+OSzZr+8wSr/LJ3vyUBApcw7pMBKl2lqIqWKaBVCzZZ/9e9t1rcd0KJvJoz9kt1GtRStZtUUmR4tN4btdgq99XTG3V+/yVdPBKq0o0K6ejms3KzyRoG80mxbHKcDJMZ4PaAQ3J4uSuybICqV8utLXP26MhPp2XyJNkckfpybVzids7UXprxwTo1a1RR01/vquhou16bttJ6bt6nP+vNlztaPUOOnwjSnv1xyUsA14f4IfWxg0H8ANya+OFLp1MlfNw1O9KuWHc3jbY71crLXWfXn1TO0gEqSPwAXJObM4tcug8JCVFAQICa6iF5uHneVB02P79Ut2P15etPTCSnpa2TsoK1jrgvbiCruL/woFSVr7gyrpdGcswEZ40+O6jcJ8Osqzs/dimraL+rv8fM3WFSY+Py51NVHrgV5+3g4GD5+/un28ElfshYiB+Q1dyq+OF6YweD+AFZSUgaxA9ZuicIAGQGJmj5vk+l9G4GAADIJIgdgJuXJSdGBQAAAAAAuBJJEAAAAAAA4BJIggAAAAAAAJeQ5eYEOTTxTtl8fG6qbNmhm5XeHA1rpLqOI219U1W+9PO/pLoNQFZjD7yYqvJ778uT6jZ4X9ia6joAJI/4gfgBuBWIH4CMh54gAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAlZbk4QN0mTW96n4gEBckp6bu23alqilNpXqmw9nvHrZn1/+FDCtqt79NaCnb/r452/J9Thm91Hb6wdo5JViumZeiN1ZPdxa/3wD5/S3a1ra8G4xfp65rfWurZPtVKn4W11YOshje88JU32oWSpfBo6/H7Z7Q5FRMTotXFfacy49vLy8pDD7tCbE1fo7JlgPdSutjo/UlcH9p/WK2O+vOo4vHl/KxUzx8EpvfDtan3Usb3OXL5sPf/u5i366eixhG2/6fOoFv7+hz7Z8fvV7alSTENm9ZM91qGIy5F69ZFpigyLVJPO9dV+8IOKiojWpN4zdP5EYJrsP5DRlaxcVINnPiZ7rF0RYZF6vddMjf50sLy8Pa3f2yn9Zuvs0QvJlvXN5q3Xv3hGJSoU0pAHJunovtNq/FBttet3j6IiYzT56Y914VTc/CNubm6atWGUVszbqOVzN1xdl/muWjM67ruq/kvWd9XwDwfo7gf/+Z56d/UtPxZAVpHa+CG9YweD+AHImvEDsQOQtrJcEqRKgYLycndX5y8+U8PiJdTrjppqXLyk7l84X76enpr/cIeEIKZthYo6FRpyVR3mj/rRbSaq35s9k6yf+9Ii7dy4xwp04m1c/It++/Z3PT6xR5rtw/FjgRo88GNruWfvRmrQqLwmvb5CFy6EqvadpdSla11Nn7ZaG37Yq1+3/K1+Tza7qo7K+fNbx+GR/32uBiWKq2fNGgqNilL3zxZftW2bShV1OiQ05fbsP6UhjUZbyz3GdFTDdnfph//9pA5DW2tY4zGqcGcZdR/dUW/1n51mxwDIyI4fOK2h97xiLfd4qb0atK2jyU/MVuCpi6rdopo6DWutGYPnJVvWJDpe7vGeHh/Tznrs7mFT+yebaXjbqSpfo4S6Dbtf04cvsp5r2r6Ozp8MSrEd1ndV26TfVXNf+jTueyrbzU0QDbiq1MYP6R07GMQPQNaMH4gdgLSV5YbDnE4UlPh7eSsoIlwnLgZq4KafNe6btfI/cUJ+UVGyubnpgXIVtPKvA1fVYXpbBF+4OjkSdObSVesunQ+xtk9LJhMcz8fHQ0ePXLASINZzsY6E5y9dCpfDYa5PXe3M5X+TGv7e5jhEKLuHp9a3aqnvq1XV4F+3/HscypfXyv37U25PrP3f9vh569i+kypSrpCO7jmu2JhY7f55v0pVLZ4m+w5kBol/J7z9vHR070krgDFiY+xJnk/2+yUwrkeWUaR0fh3df9oqt+e3QypVqbC13mZzU6M2tbRx2fZr1/XPd8O1vqcA3Pr4Ib1jB4P4Acia8QOxA5C2slxPkKDwcDnk1Hc9+1hXdHounK9ex06p6ZRpkru7HH366Mudf2jeB3O06q/98rC5KyOqXaeUnniymRXQ/G9h3C1r3d1t6vloQ01+c+V/lg8Kj5DJj6zp01teHu56dN7HerhfPxXfv0/OXr00qFFD3TfhNc2bM0erDhyQp+3a+bBaLarriTd6WF/Qn73xtYpVLKzwkIiE523uWS6fBlxTreZV9fhrXa3fic8nL7fWuXu4q/vIdpo24P3rPnrZ/P0UHhp51e/SPR3u0o/Lt8vDI2N+RwFZDfFD/HEgfgAyevxA7ACkTpb7y7VJ6TKKjI1Vi08+0oCVyzS7Rh3lf+QRuZUrJ7eKFeU+YYLKnr+gx/MX0vIDSXs/mOEdk9eNtf5Pb9u2HtaTj3+ojev36sG2Na11w557QMuXbdfpU/99pbdxqZLWcbj3o3ka+PVyzaxRXaX275O70ymPzz6T7Y47VObCeT1WsKBW7Eu+F0ji47H9u50aUPt5/bjkFz3Qr4UuXwyTn79vwra34ooWkJFt//5PPXX3S/px6a964LG4IWlD3n1MK9//XqcPnbvuei4Hh8svh0+S3yXTC6TJQ7W1YenWW9J2AGkXPzxWs3aGiR0M4gcg68cPxA5A6mS5niBGSGRU3P9RUQrw9JQzMlJuUVFSbKzk7S1HoULKmT275rZtpwLZs8vdzabtZ05pydBlWjJtRXo3X56e7oqJiesOFxYWZV0J7t6rgc6cvqT16/Zedz0hkZEJxyF3tmxyeHvL3axr3Fg6eDDuOOTIrg/bxx0H84fXjlOnFP5PeXMszI+n178fk7DgcHl4eejkwTMqUamoPDw9rDlBDu06msZHAci4zO9ETHSstRz+z+9EtxEP68yR89rwxeYbquvU4XMqXr6QPDzdrTlBDu85qVz5/ZUzXw6NW/iU8hTKKZvNpr1bD2n/uuQnWwWQfvHDsDWrtKH7zAzxFhA/AK4RP9xI7HBwZ9wkzQAyeBIkMjJSPj43N6nfxsOH1L76Hfpfh87WcJjvpk5VNzOP+y+/WMNhNHOmbCdP6oPnh2tWi2bqUKmKsnl66s9z51Q2UT0TVryoMjVKqmiFwlo5Z63WzF+vvq91U702dazu6oXKFNCsYfPVtEt9PTTwfhUpV9C6S0NaDYXp3LWunA6nNe/Hu++s1aLFg/TnrhOqUauk9uw+oQ/nrNc9zSrrofZ1VLRoLr05tZteeHaRdScY48cjR/Vw5cpa1CXuOKx76y09smmTyapIJqDr29c6Dh8+O1yzmzVXhyqV5eflpT/PnlPpK9pTq2V1dR7+kBwOh4LPh2hSn5nWmMUv316pKetfUXRktN58dEaa7DuQGdQyk5cNfdCak8fMAfDe8E+04K+3tfvnA6rRtLL2bjmouaM/S7G8CVDKVC2qomULaNXHm/TVnHWa9NVQRUfFatKg+Qo8E6xnWr1hbduyS135ZPNOMYiZsGKEytxRUkXLF9bK99da///7PVVQs56df8uOA5CVpEX8cLOxw4hWr6bJPhA/AFk3fiB2ANKOm9MZ/2dz+jl37pw+/PBDLVu2TL///ruio6Pl5eWlGjVqqHXr1nr88cdVoECBa9YREhKigIAAFZ/4qmyJEihmErMvp01X2bPn5HBzk83p1MEC+dV+6DMK9/ZOUkfZoTd2BTc5ax1X333lRjRvPCHVbTjS9t9hKomPw5J3pqvMubMJx+Hv/AXU4emrj0Pp5+PmIEnP4wBkNPd6d09VeVvOgFS3wX4hdT1B1to/T3UbgLQSf94ODg6Wv79/uh1Y4od/ET8AaY/4Ach48UO69wQZPXq03n//fd1///0aOHCgKleubO2M2bk9e/Zo3bp1uuOOO/TEE09o/PjxN1y/+QPfJDx6/fiTigUG6Xie3Pq4UYOr/vDP6sz+moRHz582qVhQkI7nzq1PGjR0ueMAAMD1IH749zgQPwAAspJ0T4L4+vrq77//VrZs2a56rlatWurRo4fCwsI0ffr0VJ3ATddVV2eOgxn6AgAAru+8SfxA/AAAyFrSPQkycuTI/9zGJEhefPHF29IeAAAAAACQNWXYW+SayVEjIiLSuxkAAAAAACCLyBBJkMmTJycsmwlOHn74YWXPnt2aG6Rt27a6dOlSurYPAAAAAABkfuk+HMYYN26chg8fnjA8xswBsmvXLrm5uWnIkCEaNWqUZsy4vluw5t/ilIdnut/w5qZ5ng1JdR059119d5gb4VHw2nfiAVzRmqiF6d0EALcQ8QPxA3ArED8AGU+G6AmS+C693377rT744ANVqlRJFStWtJaXL1+eru0DAAAAAACZny2t5/GIjY1NeLx06dLrSmCYHh/xTC+QEiVKJDwuWrSoAgMD07KZAAAAAADABaVpEqRly5baunWrtfzKK6/oqaeesn7M8rWEh4dbt8M1P6GhoTp06FDCc2fOnFGOHDnSspkAAAAAAMAFpemcIHv27NGdd95pLc+fP1/ff/+9lcBo0KCBXn755RTLffjhh0ke22z/5mZ27Nihnj173nBbWtavqKF9mqntk7P09kudrHXeXh7y9LDp0RGfqMO9NdS9zZ3ae+isXpq2LNk6SlYppiGz+ske61DE5Ui9+sg0M3ZHY798Tp4+nnLYHZrc912dPXpeac03m5de/+gJlShbQEO6zNTRv86qTfd6avFwbWv40KfvrdOWH/Zq4MsPq0SZ/FaZCncUV/fGE2RaUyiPvz4Z1U1/n4rrRfPCeyv00YuP6Nyly9bjuSu3aMueY6pRroiGdmosh9Opn/88oveXb07UBm+99tnTKlGhkIa2nqwzxwI1Zu4T8vSO2/epQxfo3IkgDZjQSWWqFJW7u02fTF6l7Rv2pvnxAADgVkuL2CE944fUxA6Xg+PuyJfa+IHYAQDgUkkQu91uDW05ePCgHA6HKleubK2/ePHiNcs9+uijKT53//33Wz83woyuuadueZ0LDFWs3aGB4z6z1rdqWElFCua0ltdtPqDNfxzWU92apFjP8f2nNKTRaGu5x5iOatjuLm34/GdN6vuuAk8FqXbL6ur8XFu9MyhpEictREXG6uX+8/T48w8krGvdrZ4GtH1LPj6emvDhY1YgM/OVr6zn8hYM0PA3Ov8TxPhb67btP6EXZq1IKH85Ikr9Jy1O8jq9WtXRy3O/1ZEzF/XhC1306Xc7ErUhRmN7zdJjox+2HscnPgLPBKtWk4rq+FQLvTvycy2dvc5KkGQP8NWriwaSBAEAZDppFTukZ/yQutjhX6mJH4gdAAAuNRzG9AIZNGiQnnvuOT344IPWuuPHjytnzrjgISVBQUFp2Qzd26CSfth8QA5H0rvENKtbQet+OWAtXwwJl/2K569kj7UnLPv4eevYvpOKiY61AhgjNsZuXeW5FUzCIfhiWJJ1p48FytvHw7rKEnIpPMlzjVpV06bVu5Ksq1G2sD54vrMGtmtgPfbz9tKc5zprwhMPyD+bj7Xu8OlAZff1loe7zToe0TGxSdsQFHflx7D2/Uxwon2POz4mARL/vPM/jikAABnRfY2qpknskJ7xQ1rEDqmNH4gdAAAulQR5//33FRwcrICAgIR5QDZv3qzu3btfs1z+/Pl133336YsvvlBMTEyq2mCzual5vQr67pd9Sdb7+XiqQN4cOnLyxiZZrdWiut7b9qbuaFpVp/8+m7De3cNdPUZ31NLpq3S7bP1xv+asfFbTlzytrz/5KclzDe6tqp/W/Jnw+EJwmB4aOVePv/m5cvv76Z5aZdV34v/Ub9Ln+vnPw+rftp613Q87/tabA9poyfje2rb/uKITBW4pcfewqdvQ+7Xsww1J1j/6Qht9PTfpOgAAMjozDLdFg8ppFjtkpPjhRmKHWxk/EDsAALJkEqRkyZJauHCh5s2bp7x581rrOnXqpIkTJ16znKenp8qXL6/+/furSJEievbZZ7V3783NK3F/42r6/pf9ZuhtEg3rlNWPW/++rjo6DG2tyevGWv9v/26nBtR+Xj8u+UUP9GuRsM3Q2f21YvZanT70b2BzK/ll89b9ne9W33sn6Yn7Jqv3sPsSnstbIEB2u0MXLyTqtRFrV2R03FWZ77f9pQrF8is4LNJ6/N3Wv1S+WL64/ejcWI+/+ZkefmmuyhXNp5KFcv9nW56Z1E2rPtmk00cvJKxr2aWuPLw8tH5p3MS4AABkFj169NB3P+1JVeyQEeOHG40dbmX8QOwAAMiSSRDjo48+su4SU716devxhg0b9Pnnn/9nEmT69Ok6ffq03n77bf3xxx+qWrWq6tevr7lz51q3zb1epYrl1f2Nq2jaix1UrFAuDe7V1FrfrG55rdu8/7rqWDJthYY3G6tlM79NWBcWHK7If4KAbi+115kj56zxvbeLmXgsOirW6k4bGRkjT0/3hFsLN7yvmjZ9m7Q7q5+3Z8JyrfJFdfzcRXl6uP/zuIiOn7tkLZvhK5cjoq3ALywy2uraei2PDG6ls8cuaOOy7QnrqtcvpwYP1NCs0V+k6T4DAHA7mDnMHmhaPVWxQ0aMH240drhV8QOxAwAgy06MOmHCBH322Wd65plnNHz4cGtdoUKFrOXOnTv/Z3kvLy917drV+jl8+LB11xhzV5khQ4YoJCTkutow45N18vCMG68697Ueevvj9VZ31oJ5/XX4xL/dWVvUr6COrWqqWMFcmj6qkwZPSDrhl1HLTFw2/CFrktfg8yGa1Gem8hTKpZ5jOmn3T/tV456q2rP5gOaOXKRbYdycPipTqbCKlsqnVZ9tscbtTvtsoNzd3bR80S/WTO9Gw3urasLgBUnKmlnbn2rXQJFRMTp5IUSLvttuze4eERVjdVkd99Fqa7s5yzdr+jPtZHc4rMnN/jx0WvkTt+GTASpdpaiKlimgLWt3qfuwB7Tnt0O6o0EF7d12WPNeX6an33hEEWFRev2zpxUVGa0xPd67JccDAIBbYcSIEaqzJcaKH240driy90h6xw+piR3SKn4gdgAAZGRuzvizYRooVaqUfvzxRxUtWlS5cuWy7gpjAgAzNOZak5+a2+iGhoYm+5wpv3r16v+8Q4xJkpi5SOq0G5+QBLlR2RdvUWqtdVydTLkR91V4IdVtON+oQKrK5191KNVt+ObUjFTXAQDIuuLP22YuMX9//3RvB/ED8QMAwDXihzQdDmOGrZieH0Z8d0sz0am397WHWDRq1CjlBtpsN3yLXAAAAAAAgFuaBKlbt65mzpyZZJ2Z06NBg7hbrKVk1arbd4cVAAAAAADgmtJ0TpC33npLzZs31/z583X58mVrYtOzZ8/qu+++u+G6IiIidO7cOZUoUSItmwgAAAAAAFxUmiZBSpcubd3advny5Tp69KiKFSum1q1bK1u2bNcsd/z4cfXt21cHDx7UqFGjVLFiRaucGe9ToUIFq6eIuf0uAAAAAABAhpgY9WZ17NjRSqCYeURMb5Lx48dbSZHo6GjrTjNmTpGFCxdmignWMoJW2R9NVfkzfWqkug2XakenqvzR3qmfIBbIalraOqWqvHvl8qlvxKmzqSr+bdAHqW8DsoSMct7OKO3ICIgfAAAZXVqct9O0J4i5w8u0adO0bdu2q+72sm7duhTLbdy4UYsWLZLdbtekSZP0+OOPK3fu3NZzM2bMUJ06ddKymQAAAAAAwAWlaRKkZ8+e1tCWDh06/OcQmMRMjw8vLy9r2WR14hMgRsGCBa0sDwAAAAAAQIZJgqxfv17Hjh274W4pJtERFBRkJT9WrFiR5LmTJ09aiREAAAAAAIAMkwQxE6GaXh03asSIEQoLC7OSIFfeTnft2rXWnCG4OQWK59X0jS/r6N6T1uMJPWcq+EKo8hXNrbl/vKlBjV7W0T1xz12pTtmi6nff3XK32fTJD9v0SKMa8vJ0l8Ph1JiFa3QqKETjetyrMgXzKCI6Rj/uPqz5329LKO90OBT4/ueyXwyWR95cyt27g0K/+0nhW/+UzcdbuR/rJI9c/orcc1CXlqyWm7u7Atq3lE/FMrzdwHUw8ygNn/uUCpUuIDO90+S+7+r0obOasv4VOR1OeXh56K3+s3Vk9/GEMmUrF9aTLzxo/R5fCryst8Yu1UtTu8rLy8NaN3XUEp09dUnFS+fT4LEPy2az6eMZ32nH5r+Tff1hM/qoUMm8MrNLzRi+QP0mdJGXt6ccdoemDvpIZ48H8l4CmVB6xQ/EDgCADJ8E2blzZ8LyoEGD1KVLFyupUaBAgSTbVa9ePcU6evfufVPP4frs2rRfr/aYkWRd52EPas/mv1Is4+Xhrl7Nauup95Yq1u6Qp4e79hw7q3PBYapXsbgebV5bry/+wdr25YVrdPD01X/oRGz7Ux75citv/0cUsmqDwjb/rog/9qnASwMUffiEQpZ/r9y92lkJkPzP9pXc3XV+2kfyGUESBLgeZWqUlKe3p4Y1GaNaLarroUH3adaw+Xq+xTjZY+2q3riy2g9tramPv5dQJvBsiF7qP09RkTHqPbil6jQsr6mjvlTguRDVql9WHfs00swJy9V78L2aMupLK1Hy6uxHk02ClKlWTJ7eHhr+4Juq2bSyWvVsZCU+Ak9fUq17Kqvj06008/lFvJlAJpUe8QOxAwAgwydBatSoYV0NTHyTmR9+iDu5xTPPm0lPkT4q1y2nKWtG6s+fDuijV75QgRJ5Jad07hpXaGuULqzImFi90/8hRUbH6tXPvrcCGMMENXbHP++3UxrTtYXCo2I09auNOnDyQkIdseeC5FW8kLXsVaKwQlb/KM8iBazPg3kcNPdI3IYOp2x+vv8sO2QPjXsdANd24cS/v8PZc/op+HyItWwSIIafv68O7zqapMzFwMv//o7GOhQbY7cSINbjGLvsdoe1nDtfDp06Fld/yKUI+ef0U8il8CR1nT918d/XD/C1rhKbBMiVdQHInNIjfkhN7OCe4/rnowMAuC5baitwmBOP3W79n9JPahIgpit2w4YNrWExuHFBZy6pT/Xn9Oy9rykgn78atK2tLsMe1Bdvf3PNcrlz+KlIHn89PftrffHzLg14oJ613sNmU//76mrRhh3W4ylLN6rX1M808YsfNLpLiyR1eBTOr8i9cVePzZAX2WxWDxBnTKz12BEe8c+G7ooNvCR7cKiiT5z9dz2AazJJBzPs5cM9b+nxN3pqzbz11vqAvP5668fxenrm49q1cW+yZfMVDFDNumW0ZcM+67G7h03dBzTT1wt/sR6bPzjihV+OVI6Af/7YSCQk8LL1+u9vHq/HxnbU2k9/+qcud3V/ro2+nv097yCQSaVX/EDsAADI8EmQxKKiohQTE5NknXls1t8s06ukf//++t///pcGLXQ9MdGxigqPm6dl09dbVb9NbWv57LF/e2wkJzQiSjsOnbKu2vx64LhKF4y7Y4+5arP4p506cSHujj3B4ZHW/0fOxl0RtiX6w8n3jopy83DX2TfmyBEVLc+C+ZT9nrt1bsqHiti5Xx4F81nb5eraWoEffK6gBV/Lq2hBufvnuCXHAsgqOgxtrcnrxqrri+0UFRmtxyoP0biOk9V/yqPW88EXQjSk0WiN6zhFfSd0u6q8XzZvPfd6J2v+D3tsXG+NwS8/rJWf/6rTx4OsxyaBHS9bDh+FBl+dnKzdvIqiI6P1RN3RevXR99Tv1S5xdb3VSyvnbdDpI+dv1SEAkEXjB2IHAECmSoK0atVKv/32W5J1v/76q+6///6brrNJkybWrXc//PDDNGih6/HN7pOwXK1BBe1Yt1slKhXRhKXPqlazqnrmrd7WVdsr/XnkjMr8E7hULJpPJwKD9USru3QyMFirtx9I2C6bT9ytjXNn97XGATsSDYtys9mUq2sbFXihn2zZ/eRbq4qyN6yjAiP6y692FflUipv7w7t0MWsbMz+Iey5/2Xy9b+kxATK7JdNWaHizsfpr+yFdvhg3vOXypTBlz5lNNndbQi+OsOBwRYbF/aERz2Zz0/NvdNaiWet08mhcl/au/ZrqzMmL2vjtroTtLl64rMLF81gJE9ML5MqhMPFC/1l/OThc2QP81PXZB3Xm6HltXJr0XAAgc0mv+IHYAQCQqe4OYyZJrVu3bpJ15vHvv/9+zXLxt8dF2qtSr7x6j+mgqIgonTlyQfPHL9F3/3RZf3bW4/pi+jcJ8wckZq7QrN91SHMHd7ICk3eW/6QPB3fS74dO6c7yxbTz8GlNX/6TXut1nwL8fKw/rKZ8tTFJHWZ4y4X3FlkTnvpULiuf8iWtx2bcrkeenMrV8+G411q5XpF/HpCbt5dyd2/LxwC4TtvW7FSLHk005YdXrAlKZz07X7kK5NTIhYOtnhxmqMo7gz5IUqZxq2qqXKO4/LJ5qduT92jN0u3WMJg9vx9VjbtLa+8fx/XRW2s07+01evbV9v9n7z7Ao6i6MI6/6SRAQu+9FykiKkVAEASlKU1RUEApAlIUkF4FlCIWQERBUawIqBQVFAEV0U+xIEiX3lsKIXX3e+6NCQRCTSBl/r/nCdmdnTt7d3bDnD1z75m4q8PM+CbJ59+wapPuaVdTk5YMtM8/e/gnmrxkoDb/vFNV65TXP//bqbfHLeL9BNKh1IofiB0AADeah/v8iqbJVLBgQf3zzz8KDAxMWBYcHKyyZcvq8OHDl2zn7e2thg0b6sknn1TLli3l4+Nzzc8dEhKioKAg+3znP78TNc4SNyT+eh3uXDXZfTh927VfKvl8ezo9l+w+ABlNI8+2yWrvVaFM8jtx8Eiymn91MnFSBs6VVo7baaUfaQHxAwAgrUuJ43aKTodp0KCB+vfvr6iouC/AphbIs88+q/r161+2nUl6lClTxtb+MIkU08YkUwAAAAAAAFJKiiZBpkyZoo0bNypXrlwqX768cufOrT///FPTpk27YhLk1Vdf1aFDh/TKK6/YNrfccotq1aqluXPn6swZLpkKAAAAAADSUE2QvHnz6ueff7bFUffs2aOiRYvq9ttvT3Spxcvx9fVV+/bt7c+///5ri6GOGjVK/fr1s8NeAAAAAAAA0sRIkJ49e9qExx133KG2bdva3+Z+7969L9suqbIkxYsX1/PPP2+TKR9//HFKdhMAAAAAADhQiiZB5s+fn+TyDz/88LLt6tSpc8nHzJUJknOJXQAAAAAAgBSbDvPFF1/Y37GxsVqyZEmikR07d+601VsvZ/ny5bwbKejs3RWT1b74Q9uT3YfwRsmcvtQp2V1ABrmiieHhnbz/qtwxMcnuw0rXAqU2r+zZk9W+xLw9ye7DxrFVkr0NAGkT8QMAwAlSJAnSt29f+zsiIkJ9+vRJNIrD1AkxRU+vldmWSab4+/unRBcBAAAAAIDDpch0GFPE1Py0bt064bb5MaNA1q1bp2bNml3xqjLxzPV+H3jgAWXJksVe97dFixY6ffp0SnQTAAAAAAA4WIrWBPnkk0+uq93YsWMTbg8dOtReEtdcatf8REVFafjw4SnYSwAAAAAA4EQpeoncyMhIvfTSS1q9erWOHz+eqDbIhg0bLtnu/PW++uorrVq1yl5e13jrrbdUu3ZtTZ8+PSW76hj31C2vvt3vUYtHp6tBnXJq0/I2RUXGaMK05Tp6PFQ+3l728UIFsutMeJSeG/OR1nRbqNDdJ1V3VisF5A/UL8O+kisqVh6eHrp1SH277MSfB/X3jJ/ssjx3Fla5zrcrJjxav437RlHBEcoRk0/FveNqkxSrUEh9p3dRbEyszoZFanzH1/T6+vE6fvCUffzDFz/XhlV/p/Kews1W/+Ha6vlKF7XN+4QyBfhp9KKB8snkI1esS1O6zNSRPccu2bb0rcXVY+pjcrvcOnU0WC88Nl2Tvh4ml8stb19vvdLzTe3etP+idv5ZMunFlSNVrGJh9ak5VLs37bPLp64eY7dl2r7c/Q27vEXPxmo7oIW2/bpL49pNVVpjrrz1zPTHlb9obvt/6EtPz9Oh3ceUu2AOzfnfOD3dYLz2bDmYsH6MO0oLH/9KJ3cFq9XbjZWzVDZ91nWF3U5sjEv1ht5pl60a/ZNO7jotn0zeKnJXQd36WAWFnzirlUN/NP9ZK+LgHypX/VE1qneL+nW9R227ztb4IQ/I19fL7v+Jr36pw0dD9OD9t6r9A7dr687DGvFiXN0oABkzdhg2frFiYiKJHwAAzkuCPPPMMzYB0q1bNw0bNkzjx4/X66+/rvbt21+2nQnC45lRIPEJEKNQoUI6ceJESnbTMcxuvbt2GR09FiovL0+1e6C6ej/3gcqVzq/HHq6lKdO/Vuvm1fTT/3bpx1922DZent6q8eL92jTzp7hteHnaxId/7iw6+ss+/fveBo0oEKiZn23Sc/VK6I8n7tDKAUtVsk1l7V2+RflqFVXR5hX0Q73PlN9dXJk8ArRv2yH1bxA32qfD0AdVu0V1nQkO18DG41N1/yD1mL/5Oq1r6Ni+4/a+SZBN7jJTJw6e1G2NKqvdwBZ6rfecS7Y/fvCkhjadqMizUeo87iHValldgxqPt9upVKe8WvW5Xy91n31RO7P+iOYvqNukjomWD2o41ratXLeCWvVvppeefF1rF/yk/331h558oYPSopKVCsvH10cDmk3WrXeXV/Mn62v28E/Urm9jbf5l50Xre8pb9798t3565feEZc1fbygvb08dW3dAJ8b8pN7lcmjLjlO6ffAdynpLroT1tn+5W6UaFVHFNmW0pP0hnT66TXfXam2/DMXGumzi4/jJMN1etZjaP3iHpr3xjb77cat+3vCvnnq87k3bJwBSJ3a4Uvxw+vt/5Rq9Uk+VyqXBfx5UzeEN5Vsut77vuZj4AQCQvqfDfPbZZ1q2bJktlOrt7W1/L1682CZGLic8PFzVqlWzP6Ghodq1a1fCY4cPH1bWrFlTspuO0bBeBa3+cZtcbrc9W/Pv3uOKiXHp738OqESxuC84d9xWXJUrFtIrEx9WiyZV5OHpJb/s54rRevl62QDG8Itx6a41u/Tom7+o7tEw1V3wl57v/qm8zAfJ10snNx1R7jsK23VzeOZXsOvcF9x4fgG+NilizshPWTFMg9/pqazZM9/kPYPU1uCRu/T9wvV29IURHRVjEyBGTHSsHZlwOaeOBNuERvz6rpjYhM9Z5kB//ft33AiPC5lRJsHHL75yUXzbANN2Y9wVVE4fC7Hrp1XH/htJZWQJDFDwiVDlLZLTDNbQsf1x+/J8nh6e8s+eKdEykwDxC49W0/G/qOmWk6q5ZKeKbDmlzd2/0bIe3+j4trjnyFY8UFFnou3t2Oizatmsnlav22r/b4mOibUJECMmNtYmRYzTweFyudLu/gOQcrGDcan4IVN4tLq/+oMqbD6qe5ZtUaM9p9Vt5NfyDYm0o0mJHwAA6ToJYkZxFCtWzN7OlCmTvcJL+fLl9dtvv1223Zw5c2zCxPzMnDnTXlUm3u+//66OHROftcWVeXp62CGsq77/x97PmtlP4eFxXxoNr//2cZ5cgdq05YCeGfaxDXxy54xLeFzIfMk8/Mr3GhIaKS+XW63cUju31Hj3adXy8ZKXn7eiwyLlE+Br1/eWj6LdkQntqzW4RTN/el5V6lXQoV1H1K/BWA24d7x+XfGXOg5vxVvqIObvu17bWlr98bqLHvPy9lKHEW20+NWru2x27sI57Wdr/bLfFZQrq6atHq2nX+2ijf997q9WUK5Avfz9OD0940ltXHttbVNLyIkwuV0uvbl+rJ4Y3VorP1yndn2aaOH0FVe9jbOnIvRVu2UacSRc9dySd4xbZuLP/6JdGlg2u9ZM+Nmul6dCTm3/arc+ardUEeEndP+9tbXqhy2JtmXOGHd6qJY+XXrpqY8AnBU7GPcu+FNvHA6TuY6gd6xL5ojf+1CoVrd/X7luLUD8AABI39NhSpcurT///FNVqlRRpUqVNG3aNGXLlk25cp0bVp2Uxx9//JKP3XffffYH1+beuyto1fdb7FlhIzQsQgH/JSiM2P/O0IadidBvf+5RrMutv7ccUOGCObQ7ie39MWmNOuQPVIkjZ0xjPSvpe0kFPT1U/2CIMu0+JZ+sfooOj7K/YxQlf49zQZGp+dGz5nC1faap7n+igT6essQuX7voZ93X+W7eXgdo3b+Zajavrj9W/601C9YlqgUUr/8b3bX0jZU2UXYlAVn99dzbvTSl6yw7kiP4eKj63z1aZauXVOdxD2tY8xcueu6flvyqhdOWXrQtMzqkX50RKnt7KXUZ/4iG3p/2p2rd1qCioiKi1bXGSJWqXERPTXhYISfDdGTf1U8fNCNDZtfML68vdmhorPSVpJxmRIenVCU8xq5jRsP88d4/qvJoeZVtVkIBC2/T4s+XJfzfEm9Qr3v1+Vd/6OBhruYFODF2OHYibkTYhT76epu6eXio5H8bNfHDd54e2lGvhLrsPKlQ4gcAQHoeCTJhwgSFhYUl3J47d67GjBljkyHX6uzZs9qzJ25YOq5dsSK51KRBRU0e08YOZ23epKqKFc4lb29P3VK+oHb9G1d0cuM/B1SqRF57u1Tx3Dp0JPiibW2d95sy5w9UueqF5PFfEGM+OEHmrJC5Y5IfZyKVo0JeHfslbhrCSddhBXnGJb98fM/l2sKDz9ppDPHLKt1VTgd2XvkLL9I/k3wY0GC0LYLaqGM9TVg+TAVL51ePl+KSoI8Ma6XDu49qzScXjxBJ6mzl4Hd7af74hTqw/bA8vTwTagudCQlXRHhEks+dVAIkUdvgcEWcSdw2LQs9HW5/hwWHq8Z9VVS0XAE9/0kfWyOkz9QOdmTNpbhiXHY60omCWZTdJcVPSjOThTxd0s7sfnJFuez+MfyC4r4IlSldQi2b1tWUUW1UKH92Pf1EfT3Wtob9v2PVD1tvwqsGkB5ih/j4IUveLHroXOk3Gz9kc7t1rECgvAN8iB8AADedhzup07E32b59+9SlSxft2LHDXg63XLlyatasmUJCQlS2bFktX748YZrNpZh1g4KCFBwcrMDAQDlZ3WaTEt2fPe0xdev/rhrULac2LW5TVFSsJry0zBY1zJ4tQEP63a/MAb62iOG7H/2krSdmKHj7cQXky2oLnW6Z+6tyVMonT5dLbfac1muhkfpG0kiXWy4/L524u6QqDWugmLPR2jDuW0WdjlCOLeeuDnPnfVXVtn9Te+UIc7b+zaEfaNSH/RQRHqnoyGhN7fHmRTUMVpydf1P3GW6cRp5tL/nYjF9eUK87Bitn/uyav3umNv0Y9yV68/ptmjv0g4T1PLwTD1q7+6Fa6v1yp4TaHyveXaPGj99ta1CYL/bT+76tfVvPXRnFHRM3qsEYv3SISlYtpiN7jmvZ7JX6beVfGvp+34S2r/V+y7Y1z9Gy130qWDqf/t24V9UaVlZqa5KzW6JE0MDXu9h95+PnbYui/vO/uHpKz07vpE+nr0h0dRjjn3LLbJ2PrPkzq+hdBbXv50PycrtV9J+Tmh0ZqzJeHnowxq0jfl7aVyqbbu9dVYVuz6eww2f07eifJJdbZ/YGqtxtj8jHL4venNpRg8cv0qdvdrdfioxNWw/qjfe+1z11yqnV/bfaL1K79hzXM6M+sWeXv/984E3ea0ir0spxO630I63FD9caOxhJxQ+5KuZRiW3HVS8iRuO9PPWty6XBvl7aXyqXAoplV9Xn7iZ+AADc1ON2iidBYmNj7QiO+BEh8SpXvvQXiDZt2qhEiRL2bOzLL7+scePG2aRIVFSU+vTpIz8/P73//vuXfV6CmEsnQa5VjsFJTYiJYwqc3b9oo/IeCtWR/Fm1vFUlRQT4XLReeKOLi09eC5IgzkiCXK0LkyDX6vwkyPVa6VqgtJQEuR4lVsSNHLmQKY5a75NtynkgzI4MWdOujCKT+Ls2No6NK4J4vUiCIK0dt9NKPzJy/HC1sYNB/AAAuNHHbe+UvjpM165dL7qkrUlumOTIpaxdu1YffPCBXWfy5Ml68sknlSNHDvvY9OnTVb169ZTsJpLBBC2LOlRjHwIZiEl4rOgUN3ILAFIasQMAIMPWBDGjNiZOnGivEmOGlsf/XC4BYpgRH76+vvL397dZnfgEiJEvXz6b5QEAAAAAAEgzSRBzSVwzjcUkM66FSXScPBlXE2Lp0sSFCw8cOGATIwAAAAAAAGkmCdKrVy+99tpr19xu8ODBdvSIUbt27USPrVy50tYMAQAAAAAASI4UrQli6oHUqVNHkyZNUt68cZdOi7dhw4ZLtuvUqdN1PYak+S3/X7J2TeSWy1+J52p4eCddgBHO41WmZLK3sXz1wmS1v79ifWUErvDk/V3tahJ/Idzrl+nEL8neBoC0ifgBAOAEKZoEMSM2ihcvrtatWysgIOCq2pgiqjlz5kyx9QAAAAAAAG54EuSvv/6ytT1MkdOrdccdd6hVq1bq3LmzKlSocNHj//zzj+bOnWuvPLN9+/aU7C4AAAAAAHCQFK0JUqNGDe3cufOa2vzxxx/KnDmzGjZsaAuk3n333WrRooX9nT9/fjVo0MA+frnpNAAAAAAAADd1JEj16tXVuHFjdejQwSY0Lrx8blKyZs2q0aNHa8SIEfrll19sUuTUqVPKnj27qlatakeKeHl5pWQ3HcfDw0MD5vZU/hJ55Xa7NaXLTB3adUT12tVSq75NFXk2SpM7Tdex/ScStfPP7KcJ87qpaOm86t/mNR3YfVzj3+lqH/P185GPr5d6t3hZz7z4kF0n4myUfvnuHy18a02i7eQtkkuvrhmpPf8ctPfHPzZDPr7e6j3tMQVk9defa//R+y98fhP3CFKDf2ZfTZz7pIqWyqt+D8/Unu1H1KpzHd117y06Gx6pqUMW6OTRUPUa2dKuY5StXFjt7hqlmvfv06atUVq3rJDKlPBVk4cP2MfPRrgVFe3WbyuLKDLSrb7Dj2nHv9HKmsVTi9/Jn/Dcm858r2hXpKpmbZjwN/HM9MeVv2hu+zfx0tPzVPP+qrqreTWdPROpqb3f1snDafvS3MUqFFLf6V0UGxOrs2GRGt/xNd3bsa4aPnqX5Hbrgxc+1/rlv192G56eHhowo7Ny5c+mI/tO6OX+72n2j6N14tBp+/iH077U72v+uar+1H+4tnq+0kVt8z5h77fs1UQNO9az+/eD8Qu1fulvKfCqATgldjCIHwAAaT4J8vPPP6tkyZL66aefLjqQXioJEs8kOmrWrGl/kLJKVi0mHz8fPVNvpKo1rKyWvZvozUHz1bp/Mz1Td6TK3l5Sj45oo5e7v5GoXWREtEZ3m6snnmtm78dEx+q5R2fZ2/VbVlP+IudqtLz03Mf2S+2lbPxhq57vOCPh/uC5PfRav3kJX7aQ8UVGxGhUj3l6ctD99n72XFl0R71yeqb96ypTqZAeeeoeTR/zmWaMjUuI5coXpAEvtNPZ0Bh9sbCABo07bpf7+npo1aJC9vb8T0O1a0+0vT197mnd3zCzWjROXPxz975oRbqi5KlzydSSlQrLx9dHA5pN1q13l1f7Z+9XnsI59cx9L6pMtWJ6ZEBTTR/wgdKyfdsOqX+DsfZ2h6EPqnaL6mreraG63z5EmQL8NGHJoCsmQWo3u1WH9xzXpKfmqk3ve1W7WTWdCYnQoAdeuqa+mP/j67SuoWP74t4jo/lTjdWtyrO2LxO/Gk4SBEhn0kLsYBA/AADS9HSY7777LsmfVatWpeTT4BodP+8sTZZsAQo+FqKCpfNrz+Z9iomO0aZ1W1X8liIXtXPFuhR8Mu7SxReqc19l/fDln/a2OUPUd0Jbe6aneLlzZ9/PV6FGaU39eog6j2otL28v5S2aS90mtNeLSwepwp2leE8dwH6eTp37POUpkF17dsQFvzs2H1TF2xJflahO40r64euN8vTwVO5cSY8G+/SzULUJjpXHwKP6+t0Q/fBDuBq02q833j03imPS9FMqlqlyonbHDp5KuJ0lMEBH9p7Qni1xI5V2/LlXFe8srbTOjACJ5xfga5MiB3cekZ+/r/yzZlLIibArbiNf0dza+fc+e3vnX3t1S41S9izupM+f1XOznrD/X1yNBo/cpe8Xrpfb5U5YdnDH4f/64q+QE6HX9RoBODt2MIgfAABpeiTIvn377PSWbNmyKTIyUjNnzpSPj4969Oghb+8UfSpcg+DjofbLyZzNL9uzOv3vGq68xXIrPORswjqeXlefDzNfknLnD9LeHUft/bdeWKrQ0+EqVCK3np30kPq3mZ5o/ZOHT6tzlUGKDI9Sv+mdVbfVHSpRsbDGd5yh2BiXxnzcV33qx53RhnMc2ntCZW4pJB8fL1W+s6SyBPonerx2o4oa3+/9S7YPPRKj/T+cVcXvwm06d1+M9NTyM5qwqrAadTqkpg0z26kyHh6Sv2eWRG1NgsDtcunN9WPt1KyBzado6Nxu9nblu8pe9Zf/1FatwS16cvzDiomJ1SdTl+rXlX/prd9ftH/PU7omPjubFJM4ua1BRf249HdVrVfeJoSeaTpJoafO6J52NdRxUHO9PvTjy27D09NT9drW0qgHJ6nNM80Tlv/v69/11qZp8vLy1OTO50aBAUgfUjt2MIgfAAA3QopmJsxVXubMmWOTIM8995y+/fZbmwTZunWrXnvttZR8KlwFM2S1ZvPq2vDNX4qMiNITFfqp1K3F1X3q45o/doECzvvSac7cXK0a91TQ+m83J9w3QYyxf9exhDoD528tOipGioq7/cPnv6pqvQrav+Owjv93Nj42NtYGUtfSB6R/IafDtfzjnzV+7hPa9c8h7f837vNj5MobqNhYl04dv/Rohi9GHlfzSLc8zB2XlE3SPYdi5P1uiGpWz6Rtu6L08WdhGtwnu7p8lrit+eIfFRGtrjVGqlTlInpidGstf2eNxn/aT7v+3mc/n+nBhlV/q2fN4Wr7TFO16NFId7W8XZ1uGWCTOZO+HKLfvv37su1/XrHRJn1eXPyMdm85qJNHg20CxPj+i9/UpMNdV/z/5Y/Vf2vNgnX2rG48U+unaddG6lSmj+3L5G9H6beVf6XgKweQIWOH80aTGcQPAIA0Px1mx44dqlSpkr39ySefaOnSpVq5cqU+/fTTlHwaXKWF05ZqQIPR2r5hl8JOxX2ZDDt9RlmyZdaBHYdVtHwheft4q2Ktstq1cc9V79e77qus778894UmIIuf/R2UI7P9wnNhEOOfJVPC7Uq1y2r3pn06ExxuAykzjN/0gQSIM61c/JsGdZytdd9s0p/rz11Z6q7/psJczsINEWp73iyZ2uZqU56Sx95o/bk5SsUK+9h6ID2fO6aNZ1brVMxhHYjcelEAHhYcrixB/lr54U8a1GKK1i37XX9+f269tMr8rcULDz5r/7ajIqMVHRmtiPBIe+bW1Oq4HJO4mD1igZ578CWFngzT+q//SthupZqldfDfuDO2l/v/xdT8aNSxniYsH2aHyvd46XH7f0BURNQ19QVA2pBWYgeD+AEAkOZHgphh0VFRUXbkR2BgoIoWLWqD7LCwK89NN8y6K1as0ObNm1WwYEE1bdrUXh4XyfPbir/UsEM9Tf1ujHz8vDXr2Xm2nsCiV5Zp6uox9svKpMcvHoZqjH2ri0qUL2CHqy7/cL1+/Hqj8hTIpr3nFTIbOLW9sgYF2NEcb05YctE2KtYsrU4jWivybKQO7z6ueeMW6eCuoxq3oJ+8fLw17/lFvMUOMfaNTippPk/Fc2n5x7/otrvK2AD46MHTmjH23HANc8WY86fCNH30oP7cFKltO6PUtWOQWjfNor3RblU8L2Z+TlKnWGnY6nA1bh+oEkV99PXHBe1j9ctV19bwn1XQr6y9v+G7Tbqn3Z2a9MUA+zcxe/gnGvxmVwXlyqKj+05qxqC0XRTVqHbPLWrbv6n94mCGrZvpLybZ8Mqa0fZv8Ys3ViYanZGU7HkCNWT2k3Za2u9r/7EjYF5aPkgR4XEJjJf6vnvFfrw1+Nz7NOOXFzTrmXn29tqF6/XquvFxfZn51RX7AiBtSe3YwSB+AADcCB7uFIxMzXQYM7XhxIkTqlOnjiZOnKjt27erSZMm2rnz3FnepJjEycMPP6zbb7/dXhrX1Bf5+uuv9dlnn6lIkYsLb10oJCREQUFBCg4OtgkYJ2vk2TZZ7b1LJC5QeT1cR85NbbgeX4e+k+w+IG1oUm5wsrexfPXCixeeccmj6X5pe1TcmDYzKru0r9zLCkmZEw9yu79i/WT34asTs5Xa7vXvkKz2nlmSn1SOPXEyWe1XuhYkuw/IGNLKcTut9CMtIH4AAKR1KXHcTtGRIKYeyJQpU2wdkEGDBtll27Ztu+Llcc0LaNmypebNm6c777wzYXmjRo00fPhwvfPOO5o0aZKtM8KQagBWZs+4hMfcYDsFxl3ER+oSdFECBAAAAABuSBIke/bsGj9+fKJlZkrLlUybNk2PP/64TYA0btxY0dHRCY/t2bPHTrNZu3atcubMqa5du6ZklwGkZybh8XR2MdECAAAAwE1JgsyaNcteAtd49dVXL7ne5UaDmCkvS5bEzQe955579Ndff+mRRx7RRx99pLvvvtsuHzt2rPr27UsSBAAAAAAApE4S5IsvvkhIgixevDjJdcwUlsslQfbv36/ChQvb2++9955+/fVX+fn5qUGDBrrttts0cuRI3XrrrdqyZUtyuwsAAAAAABwq2UmQ5cuXJ9z+7rvvrmsbAQEBOnbsmHLnzm0LnRw4cEAlSpSwyZHQ0FC7Tnh4uDJlOnepVVwahQeRlsRuu3xR5KvRtFrjZLX3CDjvWrrp2Iqz81O7CwAyMOIHAIAT3JAKgjExMTaZcf7P5dSqVUvffPONvW2Kn9atW9deKaZ+/foaMmSIXb569WrdcccdN6K7AAAAAADAAVI0CbJ+/XpVqVLFjtgwRVLNT7Zs2ezvyzFTZSZMmKCzZ8+qZ8+eWrlypVq3bq0VK1boqaeeUmRkpEaNGqX+/funZHcBAAAAAICDpOjVYcwVXh566CFb0NRMcblaZiRI+/bt1aRJE82fP1/ly5e3P8a+ffv02GOPqVmzZnaECAAAAAAAQKonQY4ePaoxY8bYQqjXaujQoSpVqpTuvfde5cmTxxZKNbVBDh8+rGHDhqlDhw4p2VUAAAAAAOAwKZoEMZe1NZe7ffDBB6+rfbt27ezPrl27dOTIEVso1SRGAKR//lky6cWVI1WsYmH1qTlUuzfts8vf2fqqjh84aW9/MGGRNnzzl3q+3FklqxSTX4CvFkxdoh/X7pR/Zj9N+PhpFS2bX/2bTdGerYfUf1oH3dmwot5/6UsteXut3UavCe1UpEx+e7vsrUXV4bbhCguNjOuD2caHPVW0TH71bznNbmPSp0/L7XLL28dbrw7+2C7rPrqVSlYsKD9/Xy18Y5XWLvk91fYbAAAAgJTj4Xa73Sm1sVOnTtnipSZ5kS9fvkSPLVq0SDeSKb4aFBSk4OBgBQYG3tDnAnD1Gnm2tb89vTyVNXsWdZvUUQumfpGQBJnxywvqdcfgRG28vL0UGxOrTJkz6eXvx6n3/VPi2gcF6IkRD2jhrG9tsiJ7nkDddnd5m9yIT4LEy1Ugm559uaOGtHtN8oq7OkzcNvz1xPCWWvjGd3YbXt6eio1xqVKNkrqn9R16eeCHCcsyBfhqyqK+6t1ksr7c9wpvO5ABj9tppR8AAODmHLdTdCSImbLi5+enOnXqXFNNEAAZnyvWpeDjF18pKlOWTJr63Rg7GmT603MUeirMJkDsY5n9tGfz/nPtT4Ylanvq6KWvPHVX01v1w7I/Lu7DyTOJlplkhxGQJZN2bzmYaFmmAD/t3X7kOl8xAAAAgLQmRZMga9as0cGDBzmTAuCq9btruEJPhqlhx7rqOLqtZvZ92y4f/F4fVWtYSXOGvH9de7P2/VU0oducK64XlCOzRrz1pPIUzK4xT7yVsHzQqx1V9a6yevuFJbybAAAAQAaRopfIrVChgkJDQ1NykwDSudb9m2nKqtH2d1JMAsRYu2C9rQMS74WOr6pL+X56ePCD11xsOVf+bHY0x6ljV/7/yIwMGdDqFT3ffa46PXeuj5P6vKdu9cerXa+G11XsGQAAAEAGHwnSqlUrNW3aVD179ryoJkiLFi1S8qkApBMLpy21P0kxxUhNfiE6KkaV65bXwZ2H7XIfX2+7LDI8UuGhEbrW0kV3Na160VSYpJgaIaYoqtn+mZAIRYRH/ff8XoqOilXk2SidDYu85ucHAAAA4IAkyBtvvGF/T5w4MdFycxb1apIg5hK7EyZM0IYNGxQWlnjuv1kGIH0bv3SISlYtpkJlC2jZ7JX65cvfNX7ZUEWciVB0ZIymPjHTrjfk/b4KzJlV3j5eev/5TxPaj33vKZWoWEiFSubV8vk/2N817q0kTy8P5S+aS7NHxxVgrt206iWnwoyd110lKhZUoRJ59Mu3m1Stbjm5TCLE5daM4QvsOoNee1yB2QNsgdYPX/36puwbAAAAAOns6jDJVb9+fXl5eal169YXFVZ9/PHHL9uW6u5A2r46THJ458ubvA38d3WY5ODqMEDKSivH7bTSDwAAkA6vDpNcZrTHsWPH5Ovrm9pdAQAAAAAAGUyKFkZNrjvvvFM7duxI7W4AAAAAAIAMKE2NBHn33XfVpk0b1a1b96LCqn369Em1fgEAAAAAgPQvTSVBpk2bpl9//VXR0dGJaoKYwqokQQAAAAAAQJpNgpw8eVI5cuS46vVff/11WxekQoUKN7JbAG6ila64K64AGalYb1rA3xYAADcP8UPGkSI1QcylbR955BFVrlxZQ4cO1ZkzZ1S7dm3lypVLRYsW1Z9//nlV28mdO7dKlCiREl0CAAAAAABI+STI008/bRMfgwcP1saNG9W4cWPddddd2rt3r9q3b69nn332qrYzYsQIde3aVdu3b7eXvjn/BwAAAAAAIDk83G63O1lbkJQnTx79+++/ypw5s06fPm1HgISFhSlTpkyKiIhQwYIFdeLEiStux9PTM1EdEMN0z9yOjY294dcLBgBkfAxnTRvSynE7rfQDAJC2ET+kDSlx3E6RmiAulyshgWF+xycuDPM7/vaVmEQKAAA3W+V6FdRheBt5eXvp02lL9NMXv+qdra/q+IGT9vEPJizShm/+uuJ2SlcroaemdZLb5dapI6c1scOrio25fBLf8M+SSS+uHKliFQurT82h2r1pn10+YE5P3dnsNs0fu0Cfz/gqBV4pAABIKcQP6VOKJEHq1KmjRx99VO3atdMnn3yimjVravTo0XaazIwZM1S9evWr2o6pHxLv+PHjdkQJAAA3ko+fj9o801xD75+gmOiYhOVngsM1oMHoa9qWSZoMafK8Is9Gqcv49qr9wO1a++n6K7Yz649o/oK6TeqYaPncYR/or7WbbZIEAACkHcQPDq8JYhIdZrrKxIkT9cADD+idd97RRx99pEKFCunTTz/Vyy+/fFXbCQ8PV/fu3e3lcfPmzWt/9+jRw9YbAQDgRqhYq6yizkZp3BfPadTCgcqeN5tdnilLJk39boyGzO+rrNmzXNW2zOgPk9AwYqJjFRvjuqp2rliXgo9fXP/q5OHT1/RaAADAzUH84PAkSIECBfT555/bq8A89thjKlWqlHbt2qVjx45p69atKleu3FVtxxRQ3bZtm7799lsdPHjQ/jZFUgcMGJAS3QQA4CLZ8wYpX/E8GtHiRS1/c6UeGx13Cd1+dw3Xs/VH6X9f/66O/y27WrkL51K1eypp/dLf2OMAAGRAxA8OT4IkxdQByZkz5zW1+eKLL7Rw4UI7ncaMBDG/zfQak2ABACAlte7fTFNWjVb+Enn1949b7FSYP1b9rSLlC9nHQ0+G2d9rF6xXySrFrmpb5ndAVn8NfvdpTe4y84r1QM5vBwAA0j7ih/QvRWqCXE50dLS9ZO6qVauuuK4pqHr+FWLOL7QKAEBKWjhtqf3JmiOLhr7f1y4rdWtxHd51VN4+3jI1vaOjYlS5bnkd3Hn4qrZljlmjFw/U/HELdGD7oavuAwAASB+IH9K/G54EMVeOWbNmzVWt26xZM7Vp00YvvPCCLZK6e/duDRs2TM2bN7/R3QQAOJQZ8fHTkl81dfUYe1WXKU/MVJbsmTV+2VBFnIlQdGSMpj4x86q2Va9dTTtH2IwGeXR4Gy2ZtUJrPll3VW3HLx2iklWLqVDZAlo2e6VWzFutLhMeUc3m1eXp5an8JfNq1jPzkvlqAQBASiB+SL883CkwzKJVq1aXTYIsWbLEFk69krCwMPXp00cffvihIiMj5evrq0ceeUSvvPKKsmbNesOvFwwAyPgaeV5bfY+0aqVrgdKztHLcTiv9AACkbcQPaUNKHLdTZCTI8uXL1a1btyRrgJjpMCYJcjWyZMmiuXPnas6cObaoau7cuW1tEQAAAAAAgORKkSRIpUqV1LBhQ7Vo0eKixyIiIjRhwoSr3lZoaKiWLVum/fv3q3Dhwrrvvvs4MwMAAAAAANJGEqRTp0522ktSfHx8NGrUqKvazh9//GGLqGbPnl3Fixe3NUHM9JivvvpKt956a0p0FQAAAAAAOFSKJEF69ep1yce8vLyuOgliEh5Dhw5V375xVfqN1157zS7//vvvU6KrAAAAAADAoW741WGuxd9//63vvvsu0bKePXtq5MiRqdYnAEDG4uGd/EPfV3t/TVb7xgXT/+jGxgEdk9U+xh2VYn0BAOBGI37IOPGDp9KQfPnyaf369YmW/fLLL3Y5AAAAAABAhhkJYqbCmEKoHTt2VLFixWxNkPfff99OiQEAAAAAAMgwI0E6dOhgrwxjLqtrpsWY31988YVNigAAAAAAAGSYkSBGnTp17A8AAAAAAECGHQliriRjLrcbExOTaHlgYGCq9QkAkLGVvrW4pq4apSnfjNSwD/rKy9vLLs9dOKeWhr6rYhULJawb447WzzErFFhyp/7eEqmoKLcatNpvf2rev0+3Ndpr14uMdKvHwKNq2OaAHux0KKH9K7NPq1HbA/rV9Z0i3OEJy/2zZNKr68bri2DzfIXtsgFzntKCw2+pZc/GSk/ubltDH++ZkXA/d6GcWnJqropWOLcfAQBwSuxgED+krdghTY0E8fPz09GjR9WwYUMtXrxY2bNnt8vdbndqdw0AkEEdP3hSQ5tOVOTZKHUe95Bqtayu7xf+rIcGtNDmddsSrespL93qVVdFm31r7/v6emjVorgD9PxPQ7Vre5T02ilN/ypM95fwVYt5+aXMcecbfvszQnsPRGvlgoIXXR3GPPeIFi+o26Rz0z/nDvtQf63dLP/MmZReeHh4qM6Dd+jYgZMJy9o920ybf9qeqv0CACC1Yocrxg/vB2vX52HyGHhU0w/G6P52WdVicp6Ethk9fvBIhdghTY0E8fb21tKlS1WxYkXVqFFDO3bsSNgxAADcCKeOBNsgwoiJjpUrJlb5iuW2Cfij+44nWtfTw1O+HkkHFZ9+Fqq2X4TJ44UT+vr3SP3waagaVPpXb7x12j7+xddnFBHptqNDtrh+T5Tgd8W6FHw8NNH2Th6Oa5ee1H+opr5f/IvcLpe9n7dobnMmQ0f3nUjtrgEAkCqxw2XjhzMuLRx9XG1/OCt9FKKvV4XrhyHH1KDlfr3xbrAj4of6qRA7pKkkiOHp6akZM2boqaeeUu3atbV27drU7hIAwAHMENZqDW7R+mW/q92AFvp02tKrbhsa5tL+vyNVYW+0PFzSPrdUS9LKCLc+mn1a+w/G6MixWHl7e+ibTwvKS146on3KSDw9PVS39Z1a8+nPCcseerapPn15ear2CwCAtBg7GKGvn9a+MLcquiWPGNnIoOZpl1Y0CNBHi0MzfPzgmUqxQ5qaDnN+Vqtfv34qVaqUHnzwQZ09ezZV+wUAyNgCsvrrubd7aUrXWcpTJKdddmTPxWdyLsWcpWmex0s6ESu5pGyS7jEHWS+pZqCntu2KUrYgT9WsHncWKIdHHp12H5cy0EDHBu1ra+3CnxOO5fmLxw3lPbL36vcjAABOiR2MJevPqrmJBf77GmzjB0/JZ3+MjRkyevzQIJVihzQ1EmTevHmJ7jdr1kyrVq3S8OHDU61PAICMzZyFGPxuL80fv1AHth9WicpFbSGu8UsGq9o9ldRn+hMJBc8u5dMlYWpTw98mQIzakv4wN1zSnxFuFSvso1q3++vPTXFDZ0N1Wv4eWZSRFC1XUA0fuUvjPx+ogiXz6YVlg1W0fCF7v9o9FdXn1U5X3I8AADgldjAWHItR2/Pu2/jBJbmL+OjPzVEZPn4omkqxQ5oaCdKqVauLllWpUsX+AABwI9RtW1MVapSRfxZ/PTq0lZbOXqlnG4yxjw14q4cd2hobE5uw/oaYNfJdE65tO6PUtWOQWjfNon0HYlRxRl5p7Vm5t0dpkIfUOVYa6uuhxs2zqERRHxUt5K2lK87YK8mEuHPpFo87E/Vj/NLBKlmlmAqVKaBlb660v2s2ry5PL0/lL5lPs55NfKIgrZkz4uOE26/9MEZP3zUq4f6zb3TTp68sT7QfAQBwSuxwyfjB20MVy/ja2MEMTxgUK3UO8NCwr8LU+J7MGT5+mJNKsYOHO4NceiUkJERBQUEKDg7mkroAgEu617d9svfOV3t/TfqBMy5pbrA89kbbszjqEpRwdZjzXVjd/XqsjP1EqalxwLlK9Ncjxh2lVRGfpPpxm/gBAJCq8cNVxg4G8YNSJH5IUyNBAABI10zQ8nT2+Km9AAAAxA5pTJqqCQIAAAAAAHCjkAQBAAAAAACOQBIEAAAAAAA4AjVBMqBGnudfaOnaeWbNmvxOuP67TuR1+jr0neT3AQCS4OGd/ENf4wJVk9XeIwNcKtYVEZG89u7oFOsLUgbxAwBcGvFDxokfGAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEagJ4gD+WTLpxZUjVaxiYfWpOVS7N+2zy3MVzKE+M7oqINBff6z+W/PHfnrJbVS+q6weGdRcXl5eWjTjaz3Y81673M/fV96+XupVZ8wl2+YtkkuvrhmpPf8ctPfHPzZDPr7e6j3tMQVk9defa//R+y98nuKvGwCu1t1ta+ipKR31UNFeylUwu3q/3Onc/08TFl+2bdnbS6nrix3s7Rz5s+uXLzdo1jPz7P3chXPpnW2vqlf15xL+701K6VuLq8fUx+R2uXXqaLBeeGy6+r3+pO68v5rmP79QX7y+Is2/mR4eHhowt6fyl8grt9utKV1m6tCuI3pn66s6fuCkXeeDCYu04Zu/UruruEmxg0H8ACAjS834ISPEDqkVP5AEcYDIs1Ea0fwFdZvUMdFyc/+Vnm/qxMG4D9el+Ph5q3XvxhreeppiomPtsp+W/2F/N2hXQ/mL57liHzb+sFXPd5yRcH/w3B56rd88nTh0+jpfFQCk3MG3zoN36Nh/B9onx7fXa33f0YmDp66q/db/7dCABqPt7Wfe7KF1n/0v4bGHn2upTT9uveI2jh88qaFNJ9r/rzuPe0i1WlbX2yM+1l9r/7FfRtODklWLycfPR8/UG6lqDSurZe8mNpg7ExyesH/gnNjBIH4AkJGldvyQEWKH1IofmA7jAK5Yl4KPhyRa5uXtpbzF8qj7lMc06ZtRqlCzzCXbV7izlKIiojXm474aOb+3sucJTHis7gO36/vPfr1iHyrUKK2pXw9R51Gt4567aC51m9BeLy4dZLcPAKml/kM19f3iX+R2uc79/zTxEb24fIgq3Fn6qrfj6eWpcneW1sbv/7H38xXLI7dbOrb3+BXbnjoSbIMYwySbXTGxOnk4fSWJj+8/kXA7S7YABR+LO+5kypJJU78boyHz+ypr9iyp2EPczNjBIH4AkJGldvyQEWKH1IofSII4VFCurCpeuYhmD3xXEx99RU9N63zJdbPnDrJ/1KMeekXL31mjjkNa2uUmw5irUA7t3Ro3zeVSzB9j5yqD9GzjiQrKHai6re5QiYqF9eawj/RClzfU44VHUvz1AcDV8PT0UN3Wd2rNpz/b+0G5sqjELUX05tAP9ELnmeox+dGr3pG3NrhFG9dutkM5jYeea6kFU764pjcid+GcqtbgFq1f9nu6ewODj4faIblzNr+sJ1/sqBXvrLbL+901XM/WH6X/ff27Oo5O3iXckX5iB4P4AUBGlZbih/QcO6RW/EASJANr3b+ZpqwabX9fKOx0uA5sO2TnWZ06clqxMbE2C5mUsOBwbfppu80wmvltRcoWsMtr3FdV6/+bFnM50VExigyPy1L+8PmvKlm5iPbvOKzjB0/Z+WuxsZd+bgC4kRq0r621C39OCDzM/437d5j/G0/ZMyyxMa5L/v904f+xddvW1JoFP9nbZl6rcWTPsavui5lD/NzbvTSl6yz7f3J6Eb8f2g95UJERUXqiQj+NbTNF3ac+bh8PPRlmf69dsF4lqxRL5d7iZsUOdn3iBwAZVFqJH9Jr7JDa8QM1QTKwhdOW2p+kREVEKez0GQUEBtihU6ZQqRn6mpStv+3Sgz0b2dsmgXFod9wfZd0HquudcYuu2A8zYuRsWIS9Xal2WVvcp8ytxWxRNfPH6u1z6ecGgBupaLmCKlmlqO5pX1sFS+ZT5zHtdOZ0+H//P7ls4edL/f90/v+xJtApX6OMXu4+29432yxaobAmLB+m4pWKqECpfHZe66UCFHNGafC7vTR//EId2H5Y6Un8fri9SVVlyZ7ZLjPHlyzZMtv/3z084pLhleuW18Gd6eu1OVFKxQ4G8QOAjCotxA/pOXZI7fiBJIhDjF86xBadKVS2gJbNXqkV81br7eEf6vklg+Xt46V3Rn50ybahp87YER9Tlj8nl8utl3q/bRMbZujVni2XnwpjVKxZWp1GtFbk2Ugd3n1c88Yt0sFdRzVuQT95+Xhr3vNXTqQAwI0wZ8THCbdf+2GM3njufTuPd9zCZ+Xl46V5Yxde1Xaq1r/FzuWNPyP0w+Jf7I8xcG4vLZj6xWXP0JizQBVqlJF/Fn89OrSVls5eac961Gh2m7y8PFSgRF7NGvie0rLfVvylhh3q2fm7piDmrGfn2aBm/LKhijgToejIGE19YmZqdxM3KXYwiB8AZFRpIX7ICLFDasUPHu74PZ7OhYSEKCgoSMHBwQoMPFe404kaeSZvzpRn1qzJ74QreSM7vg59J/l9AIAkNA5IfLWL6+GKiBvddr08vJN/DmJF1IdKz8eaGHe0VuvzVD9uEz+cQ/wAAJdG/JBx4gcKMQAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARuDpMBuSVK2ey2od/kPzCqP4PHE32NgCkrCb5eyV7G7FHUv9ve6VrQbLafx2e9iulpwvm2nXJ24CUIUqzZxzEDwCSQvwQh/gh48QPjAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI1AYNYPz9PTQgBmdlStfNh3Zd0KvDnhf4z/uYx/zzeQjb18v9b5nQsL6Ma4o/fH0fJ3ZfUJVX31EmfIFafPoz+WKjpWHp4fKDGhilx38/HftX/A/ZSmTVxVGtrRtD3+1UYe/3Ci53coXlU/FfSvZ5XmL5NKra0dpzz8H7P3xHWdo2jfDdfzQKXv/o0lLtOG7TamwdwDn8c/sp4mf9FHRsvnVr+lk7dl6SM9M66A7Gt2i96d+qSVvr7HrPftyR7tORHikfvlmkz59/Ztz28iSSS+uHKliFQurT82h2r1pn10+YE5P3dnsNs0fu0Cfz/jKLvPx9VbPV7uoYKn8Cg8J1+hWky/qU+V6FdRheBt5eXvp02lL9NMXv6peu1pq1bepIs9GaXKn6Tq2/8RN20e4PvZzsWJE3Oei1jD7uajXrqZa9fnvfew8g/cxHSF+AHA+4gdkpPiBJEgGV7vprTq8+5gmPTVXbXrfq5r3VdGgB1+yjzVoc4fyF8udaH1PD29VGNdK/86O+yLk4eWpMgObyC9XVp36dbcOf7hew/Jnk/+eE9pbt4xeOxCXyDCyVSmsvI1vsbf/bvKuCrhLyc/D397f+MNWPd9hesK6Z0LOatB9L9yUfQDgnMiIaI167HU9OeLBhGXvTPxCG3/aoUyZ/RLtqqn93rNJkguZA9KI5i+o26SOiZbPHfaB/lq72R7M4rV8+j79smyDflrya5Jvg4+fj9o801xD75+gmOgYu8wkQ1r3b6Zn6o5U2dtL6tERbfRy9zd4G9M4+7loce5zYd/Hfs30TD3zPpbSo8Nb6+Ues1O7m0iF+OHMuu0KmLBUz5TIra1B/vpi7AP6Z/5PCW2JH4C0j/gBGSl+YDpMBpevWC7t3LTf3t75117dUqN0wmN1mt+m77/YkGh9Tw9P+WYLOHff19sGMEam2Fg1+H67nnz7B7X/bovaf/qrqv2xT/5no+Iez59NHh4ecT/ylPk3XoUapTV1xVB1HtXG3vfP4qfJXw3R4Lk9lDV75hu8FwDEc8W6FHwiLNEOOXk05KId5Ha71W/KI5rwUW8Vr1Aw0WN2G8cvbnPy8OmLlt3euKpuqVNeU1aNVtNuDS96vGKtsoo6G6VxXzynUQsHKnvebCpYOr/2bN5nkyKb1m1V8VuK8AamA3Gfi9CE+wVL59OezfsVEx3L++jg+MHECM/M/E6V/zmk+776W8989IvGj/1CXrGuhHWJH4C0j/gBGSl+IAmSwe3bdlhV7yprb1etW05ZgvwThrTlLphde7ddfJY3Ka6YWIXMWKWhYRHycrnlE+uSl1sKCI9Sq89/T7TuiXU7FOAZKF+PTAlfjDpXHqhn752goNyBqt3iNvVv+LwGNpmoX1duVIehD6T46waQPG+OXaz+zadq5vAF6jOp/XVvJ3fhXPrnp60a1GisGrSvo1wFcyR6PHveIOUrnkcjWryo5W+u1GOj2ypLtgCFh5xNWMfTi0NVepQlW2Y7BSoe76Mz44eWi3/Tm0dC1NeM/DKxg8utggdP258LET8A6R/xA9JD/EBkmcH9vGKjoqNi9eKi/soU4JdwxrdGkypa//VfV72dHdNWqEW+IBX3TPyRcUvKfzg44f6ZXcd0YPFvKud7e8Ky6KgYRYbHjRb54fNfVbJyEYWePGPvr138i0pWLprs1wkgZYWeivsb3b/jSEJ9gFbdG9gRHWaqytUKO31GG77922b5N/20VYXKFLDLzTbMtvKXyKu/f9xiR338sepvFSlfSGGnziggMO4Ll2HaIv2Jex/PjQzgfXRm/LBw5WZ19fBQyfOWuTw8lCkibvpbPOIHIGMgfkB6iB9IgmRwZkj77JEL9FyrafY/pZ++/MMur9Oimr7/4rer2sbe93+SX74glapWVJ5uk/Y4x0x4OZQvyN6OOhGm7S+vUNnnmsrL41y5mfPrA1SqXVYHdx61xRLP3Y/7kgUg7Qj47+82KGcW+/fqcrm16I1VGtBgtBZOW3rV2zHDGEtVLWZvm4Tn4d1H7W2zDbOtJbNWqGj5QnZZqVuL6/Cuozqw47Bd5u3jbafL7Nq454a8RtxYce9jQXn7ePE+Ojh+yJwnqx4+NzvWMrFERKZzcQLxA5BxED8gPcQPFEbN4LLnCdSQN55UbGysfl+zRZt+3mmHsuYpmCPJgofG30MX6szOozq7/6Ry1Cipve/9pMCKBTTE5dYfWfw0PSxSH7ql191ubfX00Opfd6tCuzu05711ij4drq0Tl8rzbLQq+NVQZs8gVaxZRp1Gtlbk2Ugd3n1ci2d+rWnfjrBXnYiOjNZLT8256fsFcLKx83uqZMWCKlQyj5a/96MKlcqjGvdWlqeXh/IXy6XZoxZq0PTHbb0eMwLkzTGLLtrG+KVDVLJqMRUqW0DLZq/Uinmr1WXCI6rZvLodtpi/ZF7NemaePn7xMw18u5e6jG+v/339hw7/G5cEiRd6MswWTZ26eozcLremPDFTsTGxWvTKMrssKiJKkx4/V1QZadv4pYNVskoxO+Jn2ZsrtejV5Zr63X/vY6cZqd09pEL8EFI+v2r7eKleZIye9/LUApdLL/l6a9OpcAUM+kS3vNCW+AFIJ4gfkFHiBw+3SfVnACEhIQoKClJwcLACAwPlZE3y9EhW+/AP4gqhJsUUODM1QMwUGDMCZFHLW3XW3/fi9R5I/EXnWn0dNi9Z7QFcrEn+XsneLbFHkve3nRJWuhakdhcgqZFXu2Tthxh3tFa7P0v14zbxw42PH642drDrEj8AaQ7xAzJa/MBIEFwTE7S8//Cd7DUAAEDsAABId6gJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBGoCZIBxR4/kaz2fvcmr73h9km64BmA1JMSRU2PPF0rWe3zf3cy2X1A2rAy9pMUKUiKtIP4AUCS/zcQPyCDxQ+MBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAI1ARxAA8PDw2Y21P5S+SV2+3WlC4zdWjXEQ2Y01N3NrtN88cu0OczvrqqbZWuVkJPTeskt8utU0dOa2KHVxUbE3vZNsUqFFLfGU/Y9c6eidD4R1/T+M8HyeVyydvXW6/0nKPdm/en0KsFcDn+WTLpxZUjVaxiYfWpOVS7N+2zy3MVzKE+M7oqINBff6z+W/PHfqqeL3dWySrF5BfgqwVTl2jNJ+sStlO9VCF1b3ynvDw99e53v2n137uUL3tWLR3eSQ9P+UA7Dp3QQ3dVUacGt2nzvqN69u2lCW1LlS+gp567Ty6XW6dPnNG0MZ9p+JSH5evnLVesS1NHLtaRg6d1S7Wi6vpsY7verz/u0PuzvuPNBdJh7GAQPwDpW0rED8mJHQziB6QUkiAOULJqMfn4+eiZeiNVrWFltezdRLOemae5wz7QX2s32//UrtbxAyc1pMnzijwbpS7j26v2A7dr7afrL9tm37ZD6l9/jL3dYVgr1W55uwY1mWCTIpXqlFOrPvfppR5vJvt1Argy87c7ovkL6japY6Ll5v4rPd/UiYPnCpe+MeBd+3eaKXMmvfz9uIQgxtfbS4/Xv01PzVqsmFiXXeYfFanJlUrr9G9/6MG/f9b0rIW18o9t+vGf3erfok6i5zpxNERDe7yryIhode7TULfXLq2pIxfpxNFQVatZUm063aUZE5ba31OGLdK+3cc19Z0n9dn7P+lMaARvM5DOYgeD+AFwdvyQVOxg29e/VUf+3KTuP3+tf44G6ys/ryRjB4P4ASmFJIgDHN9/7movWbIFKPhYiL198vDpa96WGf0RLyY6VrEx5/4Tu5TzR4qYjPC+rQcTlmUO9Ne//2WSAdx4ZqRF8PG4/wPieXl7KW+xPOo+5TFlyxOkd0Z8qM0/bUv4O82U2U97zhutVbV4AUVEx+i1ri3t7ynvf6mZaz9U0VuySmEn9Mifa1Xj4HF1aNdXmfLlvqgPp06EJdyOiXEpOjrWJkAM839K7H/B0d6dRxWQNZO8vD3tyLGoyJgbtl8A3LjYwSB+AJwdP1wYOzz/ybcKkksNt/+pQG9P5du5UQ3//ltNt/ymgT1GJtkH4gekFGqCOEDw8VA7fWXO5pf15IsdteKd1cneZu7CuVTtnkpav/S3q1q/2j23aObP41WlXgU7nDYoV1ZN+26Unn6lszZ+vyXZ/QFw/czfY/HKRTR74Lua+Ogrempa54THBr/XR7P/nKIN3/yZsCxn1gAVzBmop9/8XAvXbdSLNUupaI8n5Dl5sjzdbnm53Spx6oja//XDZZ83d74g3XpnCf28dqu9b5Idj3a/W5+//5O9v+67fzTipYf11ud99devuxUdRRIESM+xg0H8ADgzfrgwdnjqvpoaW72Yso4fZ7+Q+rhcCfFDiy3/u+zzEj8guUiCZGCt+zfTlFWj1X7Ig4qMiNITFfppbJsp6j718evelvkdkNVfg999WpO7zLxiPZB4G779Wz3vHKbvF/+i+59oYIMrM0Vm7MMvq/O4dtfx6gBcq/i/4QuFnQ7XgW2H7HB1c7bW/F17esUdHl7o+Kq6lO+nhwc/aGsEGKFnI/X7roN2OOvP2/apVI1qcpsH9uxJ2KbLw0MFQ86dSb5QQGY/DZrQ2tb/iB9R1m9kSy1b8D8d2n/K3u/2bBM92+ktdWn2soqXzqvCxS8eVQIg7cYO52+P+AFwdvxwYexQt0JxZY6KkGvv3kTbNPFD3rC4OCApxA9ICUyHycAWTltqf25vUlVZsme2y8JOn1GWbJmve1uenp4avXig5o9boAPbD11VWx9f74QzuOHB4bYYqvnP0BRaOxNyVhFnIq+5PwCu3YAGo5NcHhURZf9vCAgMkCsm1v7NmmGv8X+7keGRCg+NsH+zxsY9h/VovVvt7fKFcssra1Z5VqggffmlVKmSVKqUPBs00IHAnEk+n6enh557oY3ef2O1DuyJS5S071pPhw+c0pqv/05YzzxfeGik/X02PEqZs/rxtgPpKHY4f3vED4Cz44cLY4cs/r6KLVtG3suWJcQOql9fnrGxOpIluwon8XzED0gpJEEc4LcVf6lhh3qa+t0Y+fh5a9az8+zyLhMeUc3m1W3GNn/JvLbg2ZXUa1dTFWuVtaNBHh3eRktmrUh0xYikVGtYSW37N7VXeDBzCWcNnK/JK4bZ+263S9P7vpNirxXAlY1fOsQWPSxUtoCWzV6pFfNW6+3hH+r5JYPl7eOld0Z+ZNcb8n5fBebMape9//ynCe2DwyNsRfe3n24rl9uth1+Yp0kzx9ohrB5vvy33lCnalTWnjnfpqgn1q6to7mya3bO1ur++0Lav2/gWVahSRP4Bfnqk291a8fkGdehRX5v+2Ksqd5TQP3/u09uvrtT817/TuJkd7UiR/buPa8tfXEUKSI+xg0H8ADg7frgwdmg76X2dPHRU8z95RSWnTlTsSy/ZBMjRLt102+BhKpQ3R0Ls8N85GOIHpBgPd/ypvXQuJCREQUFBCg4OVmBgoJyskWfb1O6CPHx8k9V+ReT7KdYXACn3f8ORp2sludxcHcbUADFTYMwIkA8r36WzvheP3Mj/3bnq8dfr67/GJXsbSH1p5bidVvqRFhA/ALhR/zcQPyAtHbcZCQIASDaT8Jhb/R72JAAAIH5AmkZhVAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5ATZAMaKVrQWp3AUAa5JUCRR/9TievlnYsl7kF0iziBwBJIX5ARsNIEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5ATRAAcKgy1YrrybFt7O0cebPpl5V/qWi5gvLN5CNXrEsv9ZqrI3tPXNQuf65AzRv1iHYdiHts9JtfaViXRvL18ZbL5dbYt77WoeMhGvVkY5UomFNnI6P1w5//av6Xv9r1ixXPrX6D7ldsrEsRZ6M0buQi1ahVWq3a3aHIyBhNev4LHTsaohatblO7R2pq25ZDGjt84U3eOwAAIKXih+TGDgbxA1KKh9vtTl6VuzQiJCREQUFBCg4OVmAKFP8DgIymSbYnLvlYv1cf17cf/6SDu47qxKHTqla/omreX1UzBr6faL0TLSvaQKbvw3U1ePpSu8zH20vZsvrr2Kkw3XlLUdW7taQmvbfKBjImeNn5X8BjBO0Il5eXp02AGB0719Ghg6fVsnV19e85T2XLF9C991XWtEnLlS1bgPwz+6nrUw0SJUG++XH4Ddg7cOpxO630AwAycvzg+0TN644dDOIHpORxm+kwAOBwnl6eKle9pP5et90GMEZMTExCoiIpVUoX0Oyh7dSzTW1Fx8TaICaunUuxrrh2brk1tEsjTR/YWqUL50poe/52/TL56OiRYO3595htu2njfhUvmcc+dvp0uD2jBAAA0n/8kJzYwSB+QEohCQIADle1bnlt/HGr4gcGenl76dFBLfT5rG+SXP/46TN6cOBcdZvwibIHBqj+baXi2nl56skHauijlb/b+698uFZPjPtIk+ev0pBOjRJto9rtxTXr7SdVtVpRG/ycCY9MeMzT0+MGvloAAHCz44eUiB0M4gekBJIgAOBwdR6oru8/Pzfntu8rj2nZ3NU6tPtYkuubszcRUTH29ne/bleZInEjN4Z1bqhFq/7UgaPB9n7wmQj7e8+hU/a3p8e55MaG//2rHp3f0trvtqjKrUWUOcAv4TEzNxgAAGSc+CElYgeD+AEpgSQIADh8KGv520tq44/b7P32A5rp8J7jWrv4f5dsE5DJJ+H2rWULad/RU+rS4k4dPBailb/EbcfInMnX/s6e1V++Pl5y/XemyMfHK2GdM2cidfZslIoWzyVvb09VrFRIu3YcvSGvFQAApE78kNzYwSB+QErh6jAA4GBV6pTTxnXb7FDWHPmy6dHnmmvzzztUtW45/fPLTr09dtFFbaqWKagerWsrIjJaB4+H6NNv/9Rnk7voz+0HVb18YW3ceUgzFvygsT3uU2DmTHZ6y8sfrkk0lNVc9cU8Z/CpcE0a/4VOnwrXSzMeU1RUjF4c94Vd7+57KuiB1rerYOHsmvTyo3qu//vKGKW8AQBwVvyQ3NjBIH5ASuHqMADgEJer7n61zNVhksNUd08urg6TMaSVq7KklX4AQFpF/IC0hKvDAAAAAAAAXCVqggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARuEQuADjEV6fnpHYXkIIaebZNVnuvbEHJah97OjhZ7WPc0clqDwC4OYgfMpZGxA+MBAEAAAAAAM7AdBgAAAAAAOAIJEEAAAAAAIAjUBMEAIB0ztPTU4Pm9Vaugjl0ZPcxvdRtljw8PPTC18Pt477+vvLx9dZTtw1Ksr1Z95npnZW/WC653dJLvd9W6VuL6cEeDRV5NkpTes3V8QOnLtuH0tVK6KlpneR2uXXqyGlN7PCqYmNiVa9dLbXq29RuZ3Kn6Tq2/8QN2QcAAODaeDo0fmAkCAAA6dxdre7QoX+PaECD0drzzz7d1epOxUTH2Pvm5/PpX+rHz3+5ZPuSlQrLx89bA5pO0gdTlqp51wZq1bORBjabpHcnfq5HBjS7Yh+OHzipIU2e17P1R+ngzsOq/cDt8vL2Uuv+zfTs3aM0b+RHenREmxR+5QAA4Hrd5dD4gSQIAADpXP4SebXzj9329vYN/6pSnfKJHq/bpqbWLlh/yfbHDp47S5MlyF/Bx0O1Z8tBxUTHavPPO1S8QqEr9sGcvTFnawzTLjbGpYKl82vP5n02oNq0bquK31IkGa8SAACkpPwOjR9IggAAkM7t/eeAbm1wi71drWFlZQ4KSHjMP0sm5S6cU3v/2X/J9iEnwuww1DfXj9MTo9vorx+3Kjz0bKLhslcrd+FcqnZPJa1f+puyZAtQeMh52/Ei7AAAIK3Y69D4gZogAACkU2aoaM3m1fXTkl8VHRWjyd+O0u5N++xZlXg1W8Q9fjm33VNRURFR6lpjhEpVLqK2fe9TRHhkwuMul+uq+vDlW99q8LtPa3KXmXY+b9ipMwoI9D+3ndhLbwcAANwcrR0eP5AEAQAgnVo4ban9OV/HUW214ZuNiYayvj38wytuK/R0uP0dFhyuwBxZlKdwDnn7eKlMteL6d9P+K/bBnO0ZvXig5o9boAPbD9nHDuw4rKLlC8nbx1tlby+pXRv3JOPVAgCAlLDQ4fEDSRAAANK57HmzadiH/ezZkw3fbtSmH7ckDGXNUySX9my+dBBibFi1Sfe0q6lJSwbaAmezh3+iPIVyaPLSQYqKiNbknnOu2Id67WqqYq2yCsjqr0eHt9GSWSu05pN1WvTKMk1dPcaeKZr0+PQUe80AACB5sjs0fvBwu83FbNK/kJAQBQUFKTg4WIGBgandHQAAbqhGnm2T1d4rW1Cy2seeDk5W+xh3tFbr81Q/bhM/AACcpBHxA4VRAQAAAACAM1CmHQAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCNwdRgAABzon8llktU+258+yWofGxUhvfF5srYBAABurn8yQPzASBAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQE0QAADSOQ8PDw2Y21P5S+SV2+3WlC4zderwaY1eNFA+mXzkinXZZUf2HEvUzu1y6cScjxV7KkTeubIrR8dWOjptTtxj0dFyx8Qq/6i+OvnhF4red1DuqGhlvbeuMt9RJWEb1UsVUrfGd8rLy1PvffebHqt/m1xut3y8vTTuo2+049AJDWlTX2UL5rbrvL78J63bsuem7yMAAJDY9cQPKRE7pHb8QBIEAIB0rmTVYvLx89Ez9UaqWsPKatm7ieYMfl+Tu8zUiYMndVujymo3sIVe6x0XpMQ7u+FveefOoVxd2yvky9UK/32T8g7qbh8789MGxRw7YW9nb9tUHt5eckVE6siLrycEMr7eXnqswW3qOWuxYmJddtkPm3YrxuXSbaUKqsPd1TT6w5V697sNOnAiWFn9/TSrZyuSIAAApNP44WwyY4e0ED8wHQYAgHTu+P64gMPIki1AwcdCFB0VYwMYIyY6VrExcUHG+WKOnZRv4QL2tm/Rgorc/q8CIiL11PLvVPSzr9U5PMLeN0GM4Y6Mkk/+vAntqxYvoIjoGL3WraWmPdFcObMG2ADG9iOTn7YfOm5vmwDGiI6JtWd5AABA+owfYpKIHQwTL+RZ/p2GHjhi44jMMTFJxg5pIX5gJAgAAOlc8PFQuV1uzdn8sj2j0/+u4QmPeXl7qcOINnqp66yL2nnnz6OITdsUcFslRWzeIc+wM/pswgzlPXhEH0ua8u2P6rF5ux4Y2kt731tk18nWuklC+xxZA1QwR6Aef/lj3VmmiJ66r6ZmLF+naU+2UP7sWdX3zS8SPV/vZrX1wZrfb/DeAAAANyp+8L4gdnD9d8Jk/vOvqevhY+p/9Lg8N/ytB9f/rjsK5FXY1l2JYoe0ED8wEgQAgHSqdf9mmrJqtNoPeVCREVF6okI/jW0zRd2nPp6wTv83umvpGyt1aNeRi9r7Vy4nDy8vHZn8hlxRUapyOkSlDh3VMkktTQDkdtv7j69aZ4e9Fnj+WTv01cwHNkLPRur3XQftUNZftu9TiXw5dCrsrDq9/LGenbNEfZrXTniulndWkI+3p778betN2jsAACCl4wf/C2IHr6AsNk7YfPiYWkjyiXUlxA9DihS4KHZIC/EDSRAAANKphdOWakCD0dq+YZfCToXZZWGnzyhLtsz29iPDWunw7qNa88m6JNt7eHoq+8PNlXdgd3lmDtDdAf5yeXpogaS2/61j7uc7Gjcs1cPXVx5+frad8feewyqZL4e9Xa5Qbh0+FSoPj7h2oRFROhsZbW/fXrqQGlYprUkLV9/YHQIAAG5o/OBxQezgf2tFFT5+MlHsYJz1kF1+YeyQFuIHpsMAAJDO/bbiLzXsUE9TvxsjHz9vzXp2nnLmz66OI9tq049bVbX+Ldq8fpvmDv0gUbvY4FAdf+MDyctTmcqXUkDJojrz5z/aK6nif+t4utyasmufjkx6Q+7YWAU1vyehfXB4hFb/vUtz+7S1c3WnL12nt55uayvMu1xuTViwyq43vN09Co+K1hu9WisyOka9Zn12U/cPAABImfgh9oLYIVPp4tqxeYf2nxc7GI+53Ppj83YdmTI7UeyQFuIHD7d5pgwgJCREQUFBCg4OVmBgYGp3BwCAG6qR5/nnW67dtjdvv2iZmdNraoKYIaxmBIhJgOzIn8fWBAnP5Jdo3Wx/+iTr+WOjIrTpjaGpftwmfgAAOEkj4gdGggAAgDgm0WESHmZurxnCui9XDs1rUOuiBAgAAEB6jR+YDgMAABKYgOX1++uzRwAAQIaMHyiMCgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBGoCQIgw1exPjiwVrL7UHjulmS1/+rYG8nuA3A+Dx/fZO2QsjPDk9Xe62RIstrHuCK1KVlbAIDLI34ALuZB/MBIEAAAAAAA4AxMhwEAAAAAAI5AEgQAAAAAADgCNUEApAv+WTLpxZUjVaxiYfWpOVS7N+2zy+u1q6VWfZsq8myUJnearmP7T8jH11s9X+2igqXyKzwkXN1++tGue3uJQupxz53y8vTUvO9/U5Gc2dSoUmmFR0Zr2Cdf61joGY1ve69K5c2p8Khord3yr95e+9tFffH09NCAGZ2VK382Hdl3Qi/3f0/Zcweq96RHFJA1k/78YZven7L0pu8jOFexCoXUd8YTio2J1dkzERr/6Gsa//kguVwueft665Wec7R78/6L2pUul189BjSR2+XWqZNn9MLwhXprQS8dPxpqH/9w7lpt+HmXBox+QEVL5FbE2Wj98sM2LXhvXcI2/DP7acL8HipaOp/6t3pFe7Yd1lurhujEkWD7+EczvtHvP2xTr7GtVaR0XrusbNWian/H0Ju2fwA4F/EDkPbiB//rjB061Bij06cik/2WkgQBkC6YJMeI5i+o26SOCcu8vL3Uun8zPVN3pMreXlKPjmijl7u/oZZP36dflm3QT0t+jVtxYC35enupU53b1GPuYkXHupQrS4A61r5VHWZ+rEqF8trkyLjPVtnVhy1YoR1HTlyyL7Wb3arDe45r0lNz1ab3vardrJpq3VdFrw38QCcOn77xOwO4wL5th9S//hh7u8OwVqrd8nYNajLBBjWV6pRTqz736aUeb160344fC9XQ3vMVGRGtzr3uUa27y+lMWKQGdn/nonWnjvlcu3cevWi5aTv6ibf0xJDmCcvOhEboufYzE603Y+RC+9skD5+d0l6hwckrzAoAV4P4AUh78UPkdcYOYSkUOzAdBkC64Ip1Kfh44qtRFCydX3s271NMdIw2rduq4rcUsctvb1xVt9QprymrRqtpt4Z22a1FCygiJkYzOrXUKx2bq1ju7AmJjs0Hj6pasYL2tlvSmNYN9eaTrVQ2f64k+5KvaG7t/DtuJMrOv/aqUs3Syls4l7qObaMXFvVX+dtL3NB9AVzIBCvx/AJ8tW/rwYQ0PSI5AAEAAElEQVRlmQP99e9/I6cudOpEmA1EjJiYWPt35h/gqymzO2nw+NbKGuhvH3O73eo3vLlemNFRJf47I5Pob/PkmUTL/DP7atJHvTTo5Q7KEhSQ6LG77qusH778kzcRwE1B/ACkvfjBlcqxA0kQAOlWlmwBCg85m3Df0yvuv7TchXPpn5+2alCjsWrQvo7yBmVRziwBKpQ9UL3e+VwLftmo5tXK65bC+eTj5aWapYooMMDPtp28bK0enfmxJnz+nUa1ikugJJU1r1qnnL1dtV55FSqVT8UrFNRboz7Viz3mqMfz7W7K6wfOV+2eWzTz5/GqUq+CDu06oqBcWTXtu1F6+pXO2vj95S/xnDtfkKrdUULrv9+mfl3maEC3d/Truh3q2P1u+/jsl1eoX+c5mjH5S/Uddu6szaU82+Y1DXp4hn5bu0Ud+jVO9FjtJpW17quNvHkAUg3xA5D24oebGTuQBAGQ5pkRHWbay4XCTp1RwH+Z5vissl1++ow2fPu3vb/pp60qliu7QiIitWH3QTsV5ucd++yyT9b/ZUd83FW2uHYfO2XbBodH2N///nff08Pjouf9ecVGRUfF6MXFzyhTgJ92/b1P+3cd0fFDp3XqaIhiY1wJCRngZjGf+Z53DtP3i3/R/U80UPDxUDvEdezDL6vzuEsn5gIy++m5sQ9qypjP7Wc3NDgusbj2m00qWSafvR2/bN/u4wl1cS4n9HTccNXvl/2pEhUKJCzPlS/IPsep43FzhgHgRiJ+ANJP/BB6E2MHaoIASPMGNBid5PIDOw6raPlC8vbxtjVBdm3cY5ebqTGlqhbTX2s3q2Tlonpn4x8KjYjUY3fdah8vXzC39p8M1me/bbY/pmDqybC4/3gz+/nqTGSUcmT2l6+Xl1xuM0EmMTO0b/aIBfZ2h4HN9Pvaf1SqchFbFDU2Nq6QVHxCBrgZTDFgk5gzwoPD7WfQw8PDflbPhJxVxJmki4iZYGTw8600/801OrD3hLy9vWTyftHRsapUragO7DuZEOiEn4lUtuyZ5ePjJZfLLa9L9MXb579tRMXqljtL6NB/gY9x131VmAoD4KYhfgDSR/zgfZNjB5IgANKN8UuHqGTVYipUtoCWzV6pFfNWa9EryzR19RhFRURp0uPT7Xofv/iZBr7dS13Gt9f/vv5D+yPjKk1/t3mX5nVvaxMbIz5dqcmP3G+THQdPhej5/4qivvhwEwX5Z7L/uZupMUnJnidQQ2Y/abPSJgGy6eedemfCZxr7QW9brPXdFz6/iXsFkKo1rKS2/Zva4MLUzpk1cL4mrxhm77vdLk3ve3GhMqNuo4qqULmw/AP89OiT9bT00/+p3eO1bRV3ExRNHRv3WX5uXCtlDfK3fxdmaOuFxs7tas/aFCqRRz+t+Ft1mlZRxNkou41pgz5OWK/2fZU1oec83jIANxXxA5D24oexqRg7eLhNmicDCAkJUVBQkIKDgxUYGJja3QGQghp5tk1W+4MDayW7D4XnXn5O5JV8deyNZPcBON+9fo8mb4fcUjpZzb1OJi5UfK1iXJH6Zu/MVD9uEz8AGRfxA3Cxe4kfqAkCAAAAAACcgcp9AAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIGrwwDI8MIrx12jPFliY1OiK0CKWRH5frrem3EFSWemdjcA4JKIH5ARrSB+YCQIAAAAAABwBqbDAAAAAAAARyAJAgAAAAAAHIGaIADSrdLVSuipaZ3kdrl16shpTezwqmJjEtfuiHFH6+Co1xW9/6jyj+4h38J5dWb9Xwr5ap08fH2Uq3treefMphPvLlXU3kNyR0YrqOldylyjssLWblDo6l/ljnVJ4dlUNuCOhO2WqVZcT45uY2/nyBukX77ZqEUzVqj35EcVkNVff/6wRe9PWnLT9wkAAEib8QOxA5A2eLjdbrcygLgCa0EKDg5WYGBgancHQApq5Nk2yeXZ82ZTeEi4Is9Gqcv49trx+79a++n6ROu43C5tn1lOJz/8UkH315FP/lw6NG628o/oqshdBxT2/QbleuJBuWNi5eHtJVdEpA6Nna2CE55OWGaEdJquWzLXlb9nlov60e+Vx/Xtxz+paed6enPkAp04dPqidb46+VaK7Q8gI0grx+200g8AzoofriZ2MIgfgJQ/bjMdBkC6Zc7emADGiImOVWyM66J1PD085RWYOeF+9JET8i2YRx7e3spUpqhi9xxSjy/WaMK8JfZ3puAw+7gRH8C4Y2Pl7eErX49MF2/fy1PlqpfQll93KW+RXOo6rp1e+OxZlb+j5A185QAAILXihxxF8inHX9s1fs5nemr5DwqIiLQjQa42fiB2AFIX02EApHu5C+dStXsq6f3nF15xXdeZs/LwjwtGTNBSat8RDfj3oFyeHno81qUTn65U0GPNE9YPXvq9Qr/9WXk9csvL4+L/MqvWLaeNP25V1uyZVbxCIY3vPMsOqR39/tPq22h8Cr9SAACQmvGDiR0WjZ6lDieC1Xbtb/J0ufXDkjX60ttb2R5ufFXxA7EDkLoYCQIgXTP1Nwa/+7Qmd5l50XzepHhm9pf7bIS9/diK9QqIjpGX2y2fWJc+kLTF5VbUp9/I7Yo7KxTUrI4KTn1GUe4InY45etH26rSsru8//01hweHav/OIjh88pVNHQxQbG2vP9AAAgIwTP5jYodSBY/ZMsokdTAzxWUSUht1zh4KXrLmq+IHYAUhdROgA0i1PT08Nnt9H88ct0IHth66qjU/enIo6cEzumBiFb9+rSh5xyyP/ezyTp4fMrF0PT0+5o2PsMnPbS972J9Hze3mq/O0ltXHdNkVFROtMcLgNqvwCfOXt4y2XKYgGAAAyTPyQ/8gJ/eAhVda5+MGMJi1xKkSemfyuGD8QOwCpj+kwANKteu1qqmKtsjbx8OjwNloya4XWfLLuovWOTJ6nqD2HFHPouLI0uEOBTWrp8PNvaX5wmL79rzT0I5JOSIpyuVWnShl9b4eyrtXZTbskl0uFvHIoq3eORNutUqecTYDE15d+Z/xijf3oaXn5eOndiZ/dnJ0AAABuWvww4qOvVNzl1ns6Fz8cj3Vpz987FdSxqV12ufiB2AFIfVwdBkC6re5+tXa8d2uSy+Pn9ZphreYsjpnXu6NgbrUa3UPhmfwSrVv26V3J6gPV3YG0eVWWtNIPAOkjfriW2MEgfgDS3nGbkSAAHMsEKyZoMfN7Cx87pX25s+vde2skGcQAAAAQOwDpH0kQAHJ6MDOrRb3U7gYAAEgniB2A9I3CqAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBmiAA0jzPTJmS1b5Ux9+T3YfYZG8BAADcTMQPAJLCSBAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQE0QAOnS3W1r6KkpHfVQ0V5q0aOhGj5yl9xu6YMXP9fPy6++BkjpaiX01LROcrvcOnXktCZ2eFWxMbE3rT0AAEhf8UNKHPuJH4DUw0gQAOmOh4eH6jx4h44dOGnvN+vaUP3qj9WQZi/o4YHNr2lbxw+c1JAmz+vZ+qN0cOdh1X7g9pvaHgAApK/4ISWO/cQPQOohCQIg3an/UE19v/gXuV0ue//griPy8/eVf1Z/hZ4Mu6ZtmTM4kWej7O2Y6FjFxrhuansAAJC+4oeUOPYTPwCphyQIgHTF09NDdVvfqTWf/pyw7NeVf+nNDS/ote/H6LOZK65ru7kL51K1eypp/dLfUqU9AABIX/FDShz7iR+Am4+aIADSlQbta2vtwp/lNhN4JQVkzaT7u9RX50oD5ePrpRe/HKIN3/59TdsMyOqvwe8+rcldZl5XPY/ktgcAAOkrfkiJYz/xA5A6SIIASFeKliuoklWK6p72tVWwZD51HN5aURHRio6MtkGIj6+PnfMbH+RciaenpwbP76P54xbowPZD19yf5LYHAADpK35IiWM/8QOQekiCAEhX5oz4OOH2az+M0RvPva82fe/Xy6tHydPLU0tmf3PVCRCjXruaqlirrD0b8+jwNloya4XWfLLuprUHAADpK35IiWM/8QOQejzc1/JtIQ0LCQlRUFCQgoODFRgYmNrdAZCCGgd0TFZ7V0SEUttK14LU7gKQpqSV43Za6QeAlEf8AGQ8ISlw3KYwKgAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBq8MASPO+Dn8vtbsAAADSGeIHAElhJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAAR/BWBuF2u+3vkJCQ1O4KAAC4gvjjdfzxO7UQPwAA4Kz4IcMkQUJDQ+3vwoULp3ZXAADANRy/g4KCUm1/ET8AAOCs+MHDndqnYFKIy+XSwYMHlTVrVnl4eKR2dwAAwGWY8MMEMAUKFJCnZ+rNziV+AADAWfFDhkmCAAAAAAAAXA6FUQEAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQZDhuN1udevWTTly5JCHh4f++OOP1O4ScEOZz/lnn33GXgaAq0CcAFza3XffrX79+rGLkKGRBEGG89VXX+mdd97R0qVLdejQId1yyy1KD7p3766SJUvK399fuXPnVsuWLbVly5ZE62zbts0uz5UrlwIDA1W7dm199913F23LvP7KlSsrU6ZMypcvn3r37p3o8U8++URVq1ZVQECAihYtqsmTJ+tm+v3339W2bVvlzZvX9rFMmTLq2rWrfX3G7t277Rf7+J/s2bOrbt26WrNmzRUP0iYZYNpcC/M5eeSRR1S2bFl5enomuV2zT8/vU/xPREREwjpr165V8+bNVaBAgcsmJv755x+1aNFCQUFBypo1q2rUqKG9e/cqLVi9erXt++nTp1O7KwBwQxAnpP844XLHKtPv0aNHJ9wvVqxYwjHbxFjmfrt27bRq1aokn/vs2bM27jAn08zt69G3b1/ddttt8vPzs/250IVxTvyP+Wyez8Q9ZjtmH5QoUUKzZs26aFsLFy5UhQoV7HOZ34sXL1ZawokapEUkQZDh7Ny5U/nz51etWrXsgd3b2/uidaKiopTWmIPc22+/bb8gf/311/ZM1b333qvY2NiEdZo2baqYmBh74P7tt9/sgbVZs2Y6fPhwwjovvfSShg0bpsGDB2vTpk369ttv1bhx44THv/zySz366KPq0aOH/v77b82cOdO2mT59+k15nSY5Zb70R0ZG6v3337ev97333rMJgREjRiRa95tvvrEJChMEmKTP/fffr3///TfF+2T6YhJPZr9VqVLlkuuZPpj+nP9jApN4Z86cse0vty/N5/Ouu+5SuXLlbBD3559/2td9/nYyAvP5NZ9VAEhriBMyTpxwtcaOHWuP2Vu3btW7776rbNmyqWHDhho/fnySSQVzAs0kFBYtWnTdx8AuXbrooYceuux68XFO/E+DBg0SHjPxjol76tSpY5NCQ4cOVZ8+fWz/4v3000/2OTp27GjjCfPbJHh+/vlnZTTR0dGp3QVkJG4gA3n88cfd5mMd/1O0aFG7vF69eu5evXq5+/fv786ZM6e7bt26dvnUqVPdt9xyizsgIMBdqFAh91NPPeUODQ1N2N7bb7/tDgoKci9ZssRdpkwZt7+/v7t169busLAw9zvvvGO3ny1bNnfv3r3dMTExCe0iIyPdAwcOdBcoUMBu+4477nB/99131/Ra/vzzT/saduzYYe8fO3bM3l+7dm3COiEhIXbZN998Y++fPHnS9jH+flLat2/vbtOmTaJl06ZNs6/f5XK5b6QzZ864c+XK5X7ggQeSfPzUqVP297///mtf1++//57w2P79++2yWbNmJbynffv2vWgbixcvtutdr0ttN/6zcLVMH0xfLvTQQw+5O3TocM39mjNnjrtChQpuX19fd758+eznOannMp8zcz9+XxpmP5plZr8au3fvdjdr1sx+ds3n02x32bJlCfv9/B/zN2WYz8aLL77oLl68uDtTpkzuypUruxcsWJDwHPHP+9VXX7lvu+02t4+Pj3vVqlXuP/74w3333Xe7s2TJ4s6aNau7WrVq7v/973/X/PoBICUQJ2SMOCGpY128KlWquEeNGpVw38Rqpv8XGjlypNvT09O9ZcuWRMvNMcvEGq+//rq7fv36yXo9ph+mPxdKKs650KBBg9zlypVLtKx79+7uGjVqJNxv166du0mTJonWady4sfvhhx++bL9++OEHGwubz4KJBe69914bQyYVByUVz5h4yMRF8TGviUlMbOLn52f394QJE+xj5nZScbnxxRdf2JjAtDGxxejRo93R0dGJnte8By1atLCxinm/TB8feeQR+xkxsUipUqXcc+fOvexrBZLCSBBkKK+88orN9hcqVMhm1P/3v/8lPDZv3jw7KuTHH3/UG2+8YZeZqQ+vvvqqPdNhHjcjLAYNGpRom+Hh4Xadjz76yA5TNGfvW7VqpeXLl9sfc3Zi9uzZ+vTTTxPadO7c2T6PafPXX3/ZIZ1NmjTR9u3br+p1mBEFZlRI8eLFVbhwYbssZ86cKl++vD2DYR43Z9nN6zBDRc0oEmPlypVyuVw6cOCAXdfsB3NGYN++fQnbNmdWLhx1YIaH7t+/X3v27NGNZEa4HD9+/KJ9HM+cmbkUMyT3es4ExA85Ne9bcoWFhdlhwWa/mhE45szMtTDvzbJly+ywXnPWLU+ePLrzzjuvWM/j9ddfV69evWytm40bN+qLL75QqVKlrvt1mG2Zz4GZvmO29+KLLypLliz2sxZ/hsmcLTN/Q+Zvyhg+fLj9TJq+mDOH/fv3V4cOHRJNUTLMeztx4kR75s4MtTZnE83+Mn+LZvSSOfPo4+Nz3X0HgOQgTsi4ccL1TFkx37U///zzRKOEzOgKs0/Mz7p167Rr165E7cx0mvOn2ySHmRprYgEzvfn8ONIw/TAjgs9nYodff/01IRa61Dqm35diauXdc889qlixom3/ww8/2Km85488vhYmRjZxiZlCZWKH+fPn231kxMfhJn44Py4377OJIczIls2bN9t41kzRunBkzqhRo+w0cBOrmJE1ZiSQWd+MVjJxholJzBRx4JolmRoB0jGT7T8/0xyf1a5ateoV237yySd2pEg8k+U+fzRGfBbeZKTPHzFisu5muWHW9fDwcB84cCDRtu+55x73kCFDLvv8M2bMcGfOnNk+p8n+n/+88aMhzFl2s30vLy870uT8swgTJ060Z+DLli1rz8j/9NNP9nnNfZOpN9544w3bf3MWKDY21r1161b7XOY5161b576RzEgC8zzxZxsu5cIzJGbkjdm/5jX/9ddf1zQSxOwz8/p//vnnq+rjpbZr9uV7771nRzaY0ThmRJA5g7Jt27Ykt5PUmZNDhw7Z5Wb/v/TSS/b1mffMvJ+rV6++ZJ/M+zxs2LBLPn6tI0EqVapkz7gkJan2Zv+bMy4Xfj6eeOIJe8bw/HafffZZonXM6A8zagoA0grihPQfJ6TESBAjb968dhRwvKFDhyYahdKyZcuLjr8NGjRwv/baa8kaCWJG95o4wMQmZnTkiBEj7KgUE2fEK126tHv8+PGJ2v3444/2dR88eNDeNzHf+++/n2gdc9+MGr0Uc9yuXbv2JR+/1pEgTz/9tN0nlxollFT7OnXqJIwWiWdee/78+RO169evX6J1mjdv7u7cufMl+w5crYuLJQAZVPXq1S9aZoqKTpgwwWaVQ0JC7OgKU+jSjLTInDlzwggEU7A0nhl5YTLc5sz5+cuOHj1qb2/YsMGeWTBn+89nzqyY0RyXY86aN2rUyGbLp0yZYs9CmBEl5oyM2WbPnj3tGYPvv//enpV566237IgEk1k3dVDM2R1zdsBk5ePPDHz44Ye2Nop5rebsgCksZs50mHZmXVPnwpwNMWc1vLy8kuzXfffdZ5/zapn5qyZLf6G4Y9rVM3VdzGgdMxrHvD5zlqBSpUrXtI2CBQteVGD2epj5yeYnnjlrU61aNb322mt2f18N8/4Y5qyGGUlhmLou5oyNKXZWr169i9qYz9XBgwftWZuUYs68PPXUU1qxYoWdE926dWs7auNSzN+H+bswn80La+vceuutl/07e+aZZ/Tkk0/aEVPmucyoqPP/ngAgrSBOSH9xQnKZ54svpm5GQphRwfEjIA0zWsEcr8eMGZPw2k0NleQyoxfi44D4z96pU6c0adIk+5zxLiz0Hr9/zl+e1DqXKxBvRoKYY3FK6dSpk40PTHF5M+rZfG4uHJ1yITMy1MSu54/8MPvfxBom5osf/Xvh36SJXUzMYmJt8xwPPPCAjRWBa0USBI4Rn9SIZ4Z0moJTpvDXuHHjbBVwMyTwiSeeSDTl4sKh++bAktSy+C+45rc5UJr/4C8MFs5PnCTFFP0yP6VLl7ZfuE11clPlu3379naqjikWZg6SJiAxTLEyMwXGHLTNNAOTKDBMMa94puCnOdjGX33E9NVMfzDJH1NQ1Twef0CPH754IZNsuZYK6SZBk5T4xJBJStSsWfOK2/n444/tazHDXy9MIJl9EBwcfFEbUyk+fv/cSCY5c/vtt1/1FCfDvA9mStb5749hhiSbz9617MvL9evCQPLCKUQmKWECXTM1xyRCzPSVqVOn6umnn05ym/GfbbO+SSqdz1Sjv9zfmQmazZV3TFsT8JqhrWaa2IMPPnhNrwsAbjTihPQTJ8Qf500ccOEUGRMHmFjqSk6cOKFjx47ZqcfxUzTMNKELi5maL+fmWGkSPTeSifvMfoxnTmCdX/g+/sSIiSPiY6JLrWNOzl3KtcYV5vNwYXLq/LjCnBAyRVzNMd4UejUn8MxJjwun91wYV5jEkplefqHzp2Jd+Ddp3gMTv5uYwjyXOUFkpviaE4fAtSAJAscycyrNyA/z5S/+i6OZz5hc5sy4OWCag5A505Ec5qBjRpAYJjNuxPc1nrkf/yXVjE4wzJxMM8/XOHnypJ1fa2pZnM8kaOK/0JrRIibYMKNMknLhF9/rZbL2JhFgznQkdQk3E7icH8yYGhWXGjVgrq6S1Fkkc2bBnI240cx7Y86mXMvIFF9fX5s4Me/P+cwl/y58f+KZS+iaoNMEoPXr17/ic5hg1TCjiUwSzTD9vJDZtyYBaH6GDBmiN9980yZBTB+N8+cGx196zyTSkhqtciUmqDU/5qyXSeiZucEkQQCkdcQJaTdOMCeLTPxjjvnnHz/Nsc8kMq4mDjAjPsw2zGgCY86cOXr44YftlXPO98ILL9jHbnQSxNQZiz+ZZZj9vWTJkkTrmGSMGR0RfzLOrGNOhp0/qsSsc7nREWbkp4kpTBLiapi4wuzXeObkT3xMen5SyiSPzE+bNm3siBATf5oTjKavF9YbMYkTEwtdT30z0x8z+sT8mDh74MCBJEFwzUiCwLHMl2uTBDHTGUxBKDPtJKnrr18r82XPTGt57LHHbILFJEVMEsKM5DBfmM3okwuZoltm1IM5+Jv/3M0B3JyFMdn6+PXNgc58qX388cc1cuRI+5j54mqy7+bSufHPbaZamGGrplirOSiZL7gmYRD/Bdr0xWTn7777bjvs0HwhXbBgwUUFLm8Ek9E3ZznMMExTDMxMyzAHQNMnk4AyX7LNKIGrYaYGmcv1xRcMNfvDBAImUDFTL+KZfWnOFJiCsnfccccltxefKDDFT82ZIXPfJATiR22YYMGcpTGBl5k6ZabAmHVmzJiRsA3TdseOHQn3zXtj1jFBQJEiRewyc7A2QULdunXte2KK7Zog53KFW81oCpOsMMGnCcJCQ0Pt5zWpkRtmf5oEh2nz/PPP22DFfA7P169fP7sd83kxI4vMZ9OMRjFMMGnO+phRR+azZ/arScQMGDDABlkm4WYu8Wv2gZnGY0Y3mc9kUsxZQfN6TUBkzrSZonomYDVDWQEgrSNOSLtxgjkude/eXc8++6wdGWEuT2+mjpoEhjmeXTgdwxw3zYgJM4LBHJtN8U7zPGYkpNm+Oe6bY7Ep8Gkuj3s+c4wzcZZZx8RoJqYwifzevXtf8nWYWMDEBOY5zbEwPsYwMYWJLcwIXpMcMDGiScSY5zZxhYn94pnjvolzzLRSM0XJFDE1MY5JSMUz8Z6JJ0w7E/+ZIq9mhMSlRpcaJi408aiJo8xzmP6YKdNmnydVZNRcttf0w8RAJgZ47rnnEo2InjZtmk3emOm95rWYz4oZoRJ/Uiv+RI45UWdOqJhY1sSxZtqMiVfM85p25kICpgCqiV0uxbQzFwMwRV3NSUITq8THL8A1uerqIUA6L3iWVLFLU5TKFGEyBS5NcdN33303UaGtpC6LmlSRK3PJPVM8K15UVJS9lFexYsVs0Spz2bAHH3wwoajnhUwR1fvuu8+dJ08eu765DJ25BNiFl20zxbPMZcxy5MhhC06ay6QtX7480TrBwcHuLl262EuemfXM8+7duzdRMS7TzhRgNYXPTEG09evXu28m8zpatWrlzp07t700mrnEWbdu3dzbt2+/6kvHGb/++qt938x+CwwMdFevXt394YcfJlonfltXukTxhZeGvfBSbqY4V5EiRWyxMdNv8z5cWCAuvlDbpS4ze/7lbs1rNsVGzWfpwmKiSTGX6zOF68znw3xmTSGySxUdM5e+M8VPzfZN8TFzKdvzC6OaSzqXLFnS7nvzWjp27Og+fvx4QvuxY8faz6wp2Hr+JXJfeeWVhD6Ydmbfr1mz5pJF6kyRPXOZvsKFC9v9Zgq8muc+e/bsFV8vANwoxAnpP04wIiIi7PGqfPnyNo4zx+xOnTrZIuTnO/8yreZYZI7l5tKy5jLu8aZMmWL3h4nfLmQu22r209SpUxO2d37h1aSYuDOpeCD+OGwKhpt+m/1r4jlT9P78oqjxTNH0W2+91fbbxJTmkrEXMsf4+GOzKWC7cOHCK+5fs91atWrZfWtetzmexx+/L4yZTYxqYh7zeTDFWk3ceX5h1NmzZ9uLD5jHTSxmPi8bNmxIdClc8/55e3sniqtMYV7TB/PemXZ33HGH3dblCqqOGzcu4f0274mJvXft2nXF1wtcyMP8c21pEwAAAAAAgPQncXEBAAAAAACADIokCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARvJVBuFwuHTx4UFmzZpWHh0dqdwcAAFyG2+1WaGioChQoIE/P1DsnQ/wAAICz4ocMkwQxCZDChQundjcAAMA12LdvnwoVKpRq+4z4AQAAZ8UPGSYJYkaAxO+MwMDA1O4OAAC4jJCQEHvyIv74nVqIHwAAcFb8kGGSIPFTYEwChCQIAADpQ2pPYSV+AADAWfEDhVEBAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCN4p3YHAABIbxp5tk1We+/8+ZLdh5hDh5PVfqVrQbL7AAAArh7xQ9rASBAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQE0QAABSiKenpwbN661cBXPoyO5jeqnbLMXGxCa5rn9mP034qLeKls2v/s2nas/WQ5q0sK/cLre8fb306qCP7LJnpnVQ0TL5FBEepV++3aSFs749t40smfTiypEqVrGw+tQcqt2b9tnlU1eP+W873nq5+xt2edX6t6jL+PaKiY7VOyM/4j0HAMCB8YN/MmKHv9ZsVkZAEgQAgBRyV6s7dOjfI3qh46tqN7CF7mp1p9Z8si7JdSMjojX68Tf0xIgHEpYNeeg1xca4VKlGKT3Ytb5eHvCBXf7SM+/bgOaibZyN0ojmL6jbpI6Jlg9qONYGT5XrVlCr/s300pOv2yBmyH3jFRsdq/HLhvKeAwDgwPghMhmxw7P1RykjYDoMAAApJH+JvNr5x257e/uGf1WpTvlLruuKdSn4ZFiiZSaAMQKyZtLuLQftbbfbrb6T22v8h71UvELBi7dxPOSibcefPQoI9Ne/G/fY255enjoTHK6I8Eh7GwAAOC9+cCUjdgjMmVUZASNBAABIIXv/OaDqjavoh0U/q1rDysocFHBN7YNyZNGIuV2Vp2B2jek82y57a9xihZ4KV6GSefXsy4+qf/OXrrydXIEas3igchfJpVEPTLLLYqJilLtwLkVHRqvYLYWv8xUCAICMGD8EXUXskCVbZmUEnAoCACCZWvdvpimrRqtAqXyKjorR5G9HKVNmP506cvqatmPO7Ax4YJqe7zpHnQY3t8tMAGPs33kk7sDt6aEHu9W3z2eeN8ntHA9RvzojNLbNVHUZ/4hdNrP/Oxr4di89Pf1J/btxbzJfMQAASE/xQ6vuDfTigj7Jih2utV9pFSNBAABIpoXTltqf83Uc1VYbvtl41dsww0xNQTIzfPVM6FlbyMwIyJJJ4WERCsqZRT6+3nK53Fo8+zstGPPhlbdjhrCeibDLt/26U4MajrFDWXu/9kSyXi8AAEhf8cOiN1bZn5hDh687djgbFrc8vSMJAgBACsmeN5uGfdjPzqvd8O1Gbfpxy2XXH/tuD5WoWEiFSubRL9/8rWp1y8nldttAZMbQBXadga89pqzZAmyA8ubYzy7axvilQ1SyajEVKltAy2av1G8r/9LQ9/vK5XLZ7bzW+y273kPPPaDq91ZRxJlIzegzV/Ufrs37DgCAA+OH640dMgoPt0n3ZAAhISEKCgpScHCwAgMDU7s7AIAMrJFn22S1986fL9l9SOpMzrVY6YoLkpx+3E4r/QAAZHzED2njuE1NEAAAAAAA4AgkQQAAAAAAgCOkySRIRETGKLgCAAAAAADSjjSRBDl69KgmTpyomjVryt/fX5kzZ7a/zf3x48fryJG4y/oAAAAAAACk2yTIiBEjVLlyZW3btk29evXSjz/+qK1bt9rf5v7OnTtVpUoVux4AAAAAAEC6vUSuGfFhEh1m9MeFqlWrpg4dOujMmTN69dVXU6V/AABcyLt40WTtlOe+/TzZO/XFWo2TvQ0AAHDzED+kDameBBk6dOgV1zEJkiFDhtyU/gAAAAAAgIwp1afDnO/kyZMJt00dkEWLFmn79u2p2icAAAAAAJAxeKb0VV1iYmIS7i9evFhLliy5Yrv//e9/KliwoHLnzq1atWpp06ZNtk7IoEGD7O9PP/00JbsJAAAAAAAcKEWnwzRq1EiTJ09WjRo1NGbMGM2aNUve3t7asGGDRo0adcl2zzzzjHr27KnOnTvrzTffVJMmTTRz5ky1bt3aJlLMttq0aZOSXQUAIFn8M/tpwrvdVbR0XvVv85oO/HtM49/pZh/zzeQjHx8v9W4xTb3GtFKRUnnt8rJVi+ihO4fpqQf2aff2KM1cVEjFy/rp2KEYvTziqM6EuXRrzQA93jeHpo04qj3bo2y7f/6I1IL1xbR3Z5SmDj2m4JOxutPnvz58/LSKls2v/s2m6PDeExo5t6t8/HzkinXppf7zdXT/Sfn4eqvHuDYqUDy3wsMiNK7Lm7z7AACkk/ihQMnsKlOsku6reChZscOi/xUndpDk4Xa73Sn1hubMmdNe7tbLy0slSpTQ0qVLlTVrVtWuXVt79+69ZLvs2bPbqTAeHh6Kjo62NUDMqBJPT0+Z7pnHT58+fdnnDgkJUVBQkIKDgxUYGJhSLwkAgIvcV3KAPL08lTXIX08MbqaFb63Rnm2HEx6v37Ka8hfJqQ9eW5mwLFf+ID07ub2ee3SmnlrwmWZNPK6Humazgcy4PofVY2gu5cvqqYLvBivTvmhFFPbRgceCdCg4Vi8MOKqXPiiosJBYeft4qO9DB1Ti+JP/9SFAT4x4QAtnfauD/x5TYI7MOnE4WNXqlVONxpU1c+gnat3jHu3fdVQ/r9iY0J8vD05P1Xc2rRy300o/AAAZ3/XGD30nttVzHV+VT/X5F8UOufN5y+uMK1H8sKFRZk0Yeeyi2OGNLwprcp37rjt2yCjxQ4qOBImNjbWJjB07dsjlcqlChQp2+alTpy7bLiAgQAcOHFChQoW0b98+O6Xm+PHjypMnj06cOGEfBwAgLTEjLYJPnknysTr3VdY7U75MtOyuJpX1w5d/ydPDU9lyeiUsj4l26/D+aM0ac0wxa8I1IcKtml6Sh0vK81moPnkgi+rel8WumyXQK4k+hCXcj46KsUFM3HZjFRsTa2/fVr+8suXOqlbdGmj1Z7/qy/k/puCeAAAANzJ+WL9ys3y9AuS+IHZ4ffxxnT4ao0mHYlT8QIzcnnHxwydvn9bd3bPZdYkdbnBNkNtvv129e/fWwIED1bRpU7vMJDWyZYt7Ay6lbdu2uvvuu9WjRw899NBDdlqMuTTuBx98YH/HbwsAgPQwzDV3/mzau+NIouW1G1fSuq8Tn00xgk/FateWKI0t7qOPItzq75Y8Y+KCmMw7orT+gxDVbXLxZeQvx8vbU4/0v09fzFlj7+cukF3//Pqvhjz0muo/WF258l/+uAwAANJu/BAfOzw1NJder+6voftibNwQHz8sOxarh066run5vRwUO6RoEsTU8zDDUszwFFPHw1i/fr0effTRy7abOnWqevXqJT8/P82ZM0evvPKK8ubNq4kTJ6pIkSJ66aWXUrKbAADcMDXuqaD1325OtCxXviDFxrp06njoRetnCfRUoeI+Kn7apbxecUM040uM7/OQfKLcypH72gZu9pn8iJa/94MO7Tlu74cFn9UfP2z9P3v3AR1V0YZx/MmmEiCh916lN0XpRRAVEKUqgiAKKChNioAUQVApoqgIKCgqNkSUZkGRDipiQVCK0ntNQkLq7ndm8iUkECCQQMr+f+cs2b17Z3b27ob75r1TZK4+bd+8R4VL5UvBOwQAAGkZP8TFDnkLeqnomZhEscNBM9zDQ3b7tejnRrFDqg6HKVGihObPn39JLw9zuxIzh8jAgQMTbfvggw9Ss2kAANwU9e+tpnlTkx4KkxRfP4ftqnoin6cCYqTIBCfnhU6pRVW/a3r9B/u30LH9J7Vm8Zb4bdt/+U+lKxXR1k27VapiYX0zn+EwAABk1PghLnYw832czu+VKHYw66q2Myu3FvVO9ms/6GaxQ6omQYx3333XDmM5duyY/vzzT61evdre79ix42XLmElRc+XKldpNAQDghho35zGVqlBIRUrm1fJPNmn9N1uVz3Rl3XVRV9a7q2jiUxeS+88+eli7t0fowH+Rat05UI8NzqVHJp6Sj6+HxkW45Pz/nCALfD009Lnc8eX27Y7U9LEndHBPpE5FfqXyAXX16iejVapSERUpnV8/rdiqhwfdawOXavXK6+9f9+i9FxdrwZsrNOjVLuo2vLV+/fFvu4oMAADIOPHD5iNfyHUuLFHsMOKxI4qJdGl8YS+5jsTOCbIwWnqvZOzk6hfHDs90OSS/qBNuHzuk6uowEyZM0Keffqp+/fpp8ODBdkWXnTt32uEwv/zyy2XLmWV0mzVrpscff1xt2rSRt3fys1ZxmN0dAHAzZ3dPiWE/fJXk9otndzcBTEzWpEeuvly3RYrakBlmd89M7QAAZH7ED5lwdZh33nlHa9eutau8mMlRjTJlyujff/+9YjmT9ChXrpx69+6tPn36qGvXrjYhUqFChdRsHgAA6ZpJeOx/MmdaNwMAAGQgxA9pODFqaGioChYsaO+bpXKNqKgoO+Hp1ZIg06dP15EjR+ykqH/88YcqV66sunXrau7cubZeAAAAAACAdJMEueOOO/Tmm28m2maSGPXq1UtWeR8fHz300EP6/vvvtXv3bjVt2lRjxoyJT6wAAAAAAABcr1QdDvPqq6/qzjvv1Lx583Tu3Dnbk8NMimqSGleS1LQkJUuW1AsvvKBx48bp22+/Tc1mAgAAAAAAN5SqSZBSpUrp77//1pIlS7Rv3z4VLVpUrVq1UtasWa9YrkGDBpd9zuFw6J577knNZgIAkCLRe/alqPxLtzdP8ScQcyLxDPIAACB9I37IpEvk+vn5qUOHDtdUZvny5andDAAAAAAAgBuXBAkJCdG0adP066+/2vsJrVy58prqOn/+vI4fP67ixYunZhMBAAAAAICbStUkiFna9sCBA2rXrt1Vh8AkZMr06NHDTob63HPP6ZZbbrHDaMwawOXLl7c9RUqUKJGaTQUAAAAAAG4mVZMgq1at0v79+xUQEHBN5QYOHKgaNWqoZs2a6tOnj8aPH69du3YpMjJS/fr108iRIzV//vzUbCoAAKmibM1SenJad7mcLp05dlYvdpkubx8vjf1iiLz9vOWMcWpKjxk6tu9EonJZsvrqxc/7qXj5ghpw72Tt++eIBr3aVbWbV9b8qcu1ZO5qu1/rRxuqfZ/m2vnHPk14/J2rtqf8bWXU8+Uu9n6ugjn189dbNHPQPD5tAADSEeKHtOPhSmpplutUpUoV/fjjj8qTJ881lcuXL58OHjyomJgY24Pk5MmTypUrl33u6NGjuvXWW+3zV2J6jQQGBiooKOiakzAAAFyL5o4Lc1/lzJ9DYcFhijgfqR4THtLu3/Zo4+LNCsgToFOHT6tW86qq2+Y2vf7UnPgynnnzyuHpUPYc/np89AP6/K3vbRIkV74A1WpSUX5ZfeOTIIF5ssk/q596jLo/URIk5kTipEpSBr39hL7/YI3+XLP9kudWOBek6YeeXs7b6aUdAIDMj/ghfZy3U9wT5M8//4y//9RTT6lTp0569tlnlT9//kT7Va1a9bJ1mB4fPj4+9r55Q3EJEKNAgQL2DQIAkB6Z3h9xoqNiFBPtVFRktE2AJNx2MdNDJOjUuUTbTh8PvmS/oJPn5Jcl9hx5LUyS5Zbby2par1nXXBYAANxYxA9pJ8VJkOrVq8vDw0MJO5SY3iAJmedNL4/LMYmO06dP2+TH0qVLEz136NAhmxgBACA9y1s0j2reWUXzX1gYv83Ty1NdRrXXKz1n3vT21GhaWVvXbE90fgYAAOkL8cPN50hpBU6n0yY4zM/L3a6UADFMz5HQ0FB7v169eomeW7Fihdq3b5/SZgIAkKraDWylKSvH2p/+2bPo2fef1uQeMxQTfeGcN3BWby2dtUJH/jt2U9tjNOxQR6sXbLzhrwsAAJKP+CGTTYwaEREhh8Mhb2/v+G1RUVE2EeLr63vZct27d7+u5wAASCsLpy21N3PeG7toiD4cv0CHdh2Jf77zyLY6uve4Vn+24aa2J24oTIU7yunV3rNvymsDAIDkIX7IZEmQFi1aaOLEiapbt278tp9//lmjRo3SypUrU/OlAABIFxp1rKNKdcvb3iAPP9deS2Z+p7/W/q2uozto2/odqt6ksrZv2qm5Iz66pOy4+X1UunIRFSmTX8vfX2d/3nFXFZvEKFgij2aPXqhG99fSfT0aqVCpfHpxQT+N6Pj6VYe4mNfcuvZvhsIAAJBOET9kktVhzJweZmUXc1UsjhkKkzdvXjvnx/UwdZmkypgxY9S8efPL7sfs7gCAtJjd/XqY1WFSKjmrw1wJq8PEIn4AANwsxA/p47yd4jlBEsqSJYvOnUs80715HLfyy/Uwk6z27t1bn3zySSq0EAAAAAAAuKtUTYI0bdpUAwcOtEvexs0R8swzz6hJkybXXWejRo3UtWtXzZkzJxVbCgAAAAAA3E2qzgkyZcoUtW7dWnny5FHhwoXt8rbly5fXkiVLUvNlAAAAAAAA0jYJkj9/fv3000/65ZdftG/fPhUvXly33XabPDw8rlguOjpaY8eO1bp161S1alWNHDnS1hWnSpUq2rp1a2o2FQAAAAAAuJlUHQ7Tp08fm/CoXbu2OnToYH+ax0899dQVyw0fPlzffvut2rVrp8OHD6tGjRratm1b/PN79+5NzWYCAAAAAAA3lKqrw5jZWc1srRfLnTu3Tp06ddlyxYoV06ZNm1SoUCH7+O2339bo0aNtYsT0DLlcvQkxuzuQOWfBNjzLlU5RedeR4yluw7dBc1NcB4D0d95OL+0AAAA357ydKsNhFi9eHL8crpn/I2Fe5d9//7WNvBLzBhIOf+nZs6f8/f3tkrhff/11ajQRAAAAAAC4uVRJgvTv39/+DA8PV79+/eK3OxwOm9yYPn36FcuXKFFCv//+u2rVqhW/7eGHH7ZDae666y67ygwAAAAAAECaJ0H27Nljf3bs2FGfffbZNZd/5JFHtHLlykRJEKNz5842EWImSgUAAAAAAEg3q8NcTwLEeOaZZy773EMPPWRvADK2LNn89PKK0SpRqaj61RmhvdsO2O1TVz0vl9MlLx8vvdp7lt1+X58W6jD4Pu3c/J/Gd5xq9ytTqbCeGN5KTpdLZ0+e08tDPlG95pX1QLd6igiP1pRnP9PJo0F2X5M8nblkgJZ+vElL5m+8pC3la5bUY+Ni5yrJVSCHfvnuT/2z+V/d/2RzRYZHacoT7+jEoTM39fgAAAAAyGBJEDNs5ZVXXtGqVat08uTJRHODbNmy5ZomO9mwYYO9X7duXSYqAzKBiPORGtX6JfWa1DXR9qHNxikmOkZVG1ZU24Gt9Mrjb2nNgo365Zvf9fhLXeL3O3UsSCMfn6uI8Ch1H9hCde+spLbd62twl1kqV7mIOvdpqumjF9l9G7esphNHzl62LTu27NHQVpPs/QGvd9eGZVv0+LiOeubuF1WuZkl1HnqfXus/74YdCwAAAACZYIncQYMG6cMPP9S9996rHTt2qFu3bgoLC1ObNm2uWM5MhGrmBDE2b96ssmXLqlevXvZWrlw5/frrr6nZTABpwBnjVNDJS1d5MgkQwz8gi/Zs3Wfvnz0RbPdP6MzJczYBYkRHx6hwiTzat/u4oqNitP23fSpZroB9zuHwUIO7q2jN11uv2iaHp0MVbi2loJPntO/vQ7F1/bRbJSoWTpX3DAAAACATJ0G+/PJLLVu2zE6U6uXlZX8uWrTI9gy5ErNPpUqV4ofGmOVx9+/fb29jx46Nn3gVQOYTmCdAr64dr6fffFxb1/x91f3zFgxUjTpltG3LXoWdC080EbPRpHUNrf1ma6KeaJdTvVEF/bl+p7IFZlFYyIW6PD1T9b9GAAAAAOlEqkb6oaGhdqUXw8/Pz64WU6FChav25IiMjIz/g2X79u3q3bt3/HOmN8jWrVe/ogsgfWo3sJWmrBxrfybF9A4Z0GCUxrWfqh4TOl+xLv+svhoyqZNeGfG5zp46J/9sfvHPOZ1O2wuk0T1VtXr5H8lqW8P7b9XaL39RyNkw+We/UFfMRb1QAAAAAGQOqToniBnG8scff6hatWqqUqWKpk2bphw5cihPnjxXLGfm/fjoo4/UvXt3Va5c2Q6JueOOO+xzJoGSO3fu1GwmgJto4bSl9na54ShmUlSTBA0NClN46IXeGJfs6/DQ0CkP6qM3f9ChvSfl6eVQsdL55OXtaecE2bPjqHLmya4cebJp3Kzuyp0/0Jb5+/f92nXkeJKvXeG20nqt//v2frFbCsXWVbOk9mw7mKrHAAAAAEAmTIJMnDhR586di79vlrgNCQnRrFmzrljOTKbatGlTff/996pevbpatGih+++/367wYIbYvP7666nZTABpZMLS4SpdvYSKlC+kZbNX6NcVf2rE/P62F4dJhrz+1Dt2v8ad6qpN33tUuGwBvfzdKI18+mM1vKeqKtYoJv+sd6pznzvtyi9fvr9Okz/opciIaE0e9plOHQ9Wv/Zv2DqaP1BLfv4+2r3tUJJtqd7wFm3dsNMmYMy8JIveWqHJy4cpKjxKk5+IbQcAAACAzMXDlZyB8zfBkSNHbM+R1atX6/Tp08qWLZvtUWImTa1Xr16yVpQJDAxUUFAQq8kA6UhzR+xStCnhWa50isq7kugJcq2+DZqb4joApL/zdnppBwAAuDnn7VTtCWLExMRo37598T1C4lStWvWK5QoWLKhJk2KXrAQAAAAAAEhtqZoEMUNXTM+NU6dOJdpuhrWY5EhSzL7JmfMjufsBAAAAAADc8NVh+vXrpxdffNGuEmPG+MfdLpcAMWrXrq0hQ4bYVWGS8vfff9vn4yZKBQAAAAAASPOeIGZJ3B49esjhSH5u5ffff9fUqVPVrFkzmzC55ZZb7NgeM9Znx44ddh+zZO6WLVtSs6kAAAAAAMDNpGoSpG/fvnYll/79+ye7TPbs2TV27FiNGjVKP//8s02KnDlzRjlz5rQrxZieIp6enqnZTAA3kVfhQimuo/aCv1NU/ud7S6S4DZlBakxS6/DzS1F5Z/jll0FOrhXOBSmuAwAAJA/xAzKbVE2CmPlAGjRoYCc4zZ8/f6LnrtaTwyQ66tSpY28AAAAAAADpOgnSvn17lSxZUu3atZO/v39qVg0AAAAAAJB+kiB//vmnTp8+LR8fn9SsFgAAAAAAIH2tDmNWcPn3339Ts0oAmUSWrL6atnigvvhnkoqXLxi/PW+hnFq8e2r8tifHt9OUhf017auBqtnoFkU7I/VO5zV68fZlOr4rOL5c0JEwTai1NH7bvl9P2f3mdFmr1W/FTqp87lS45j22Xj8dX6gtJ5fK198rWW0oVja/bcMrXw5Q9frllJlkyean6RsnanHwBypRqWii5/IWzaNl5z+K3169SWVN3zBBr6wep6qNKl62zsYd7tCn+968UE+R3FpyZq6KVyxy1faUrVnK1j/1x+f13CcD5ekVOwdUm7536/VNL9q23tGqVgreMQAASCniB2QmqdoT5NZbb1WLFi3UpUsXFShQ4JLlcwG4r4jwKI3tPluPPdcm0fYOfe7Uts3/xT9e9PYqHd1/StkCs+iFD5/U5lXb9dAbt+v7VxIvo71+7m4VrZ4r/vHG93br/gk1lKdkdr3bbZ1uf7iUti47pEotCst5pLF2Bm3QobO7ktWGbsNa6ZVnPtLZk8Ea/8GT+n3dTmUWEecjNar1S+o1qeslzz04rI22rY9NIBk9Jjyk4fdMUExUjCYsG6Fnmoy5pIyHh4caPFBbJw6djt/W8ZlW2r5xV7Lac/LQaQ2/+wXbLvN69e6/TWs+36TWT7ZQr2rPyM/fVy9+85w2Lf31ut8zAABIGeIHZCapmgT56aefVLp0aW3cuPGSIDk5SRCXy6XvvvtO27dvV+HChdWyZUtlzZo1NZsIII04Y5wKOh2aaFv+orns7/2Jw2fit5kEiBEVES2X0yWHh0NZc/kmKnfmYKg8PKSceX1V44t9qhnh1I5z0Yo5EaGYIlnl4fCQl69DeUpmsz1FvCVFOyPk6fJLVhty5QvQ4b0n7P2QM6EKyJk1c30OJy/0qIlToEQ+uVzSif0n47c5PB0KDQqLvx+QO7vOhUYlKtekUx2tXfSz2vW/xz7OXzyv+c9cxw/Efo5Xc+bY2fj70VExiol22vuHdx+VbxYfZcmeRcGnQq7z3QIAgNRA/IDMJFWHw/z4449J3lauXHnVsjt27FDNmjW1cOFC+fr66rfffrMrzezfvz81mwggHenwZDMtnPVjks+Z3hhfvbsmyec2vLtbDTuWUNm1x3THR3tU48v96rfllBb33qgZ961UiVtzy8vXU4Uq5dBfyw9p3dEPdS76jHL45E9WG0ziNk5oSLiy58j8Ez13GtZGC6YsTrQtOjLaDpHJkS9QJSoXVbYciZNBDoeHGra7Xas//+lCPc+01OevLr/m1zevU/POKvE9Pn759je9s22a3vz5RX35+rXXBwAAbjziB8jde4IcOHBA2bNnV44cORQREaEZM2bI29tbTzzxhLy8Lv9SQUFBatOmjebNm6fbb789fnvz5s313HPP6b333rPL7g4bNizRHycAMq6CxXPbn8cPXhhGEad5x9vl5e2pVV9eOgTi9IHYnhwtVh/ThyHRNpPrGe3SEElrnS7tbldM/f86qxP/heiPrw7ojkdKK2JmA+0J2aIDodtULFuVq7bB9ECJkzUgi0LOxvaGyOimrByrjUs2a+G0pYm2FywVmxw6ti+290ucGQPf05B3+yrk9Dnt2bo/Ua8No+lD9bRm4U+2J42tp2S+2HoS9Ca5nHYDW6lO61tte75+5wc9+/7TmtxjhmKiY+SfPYta9myu7uX6ydvHS5N/GKNfV/yZ4vcPAACuHfEDMptUTYK0bdtWc+bMsUkQk7D44YcfbBLE9PJ4/fXXL1tu2rRp6tatm02AmDlFoqIudLfet2+fHA6H1qxZo9y5c6tnz56p2WQAaaRkhcIqXr6Axn/whErcUlCFiufVsE6vq9JtpVTvnmoa9/g7SZY7tiNIx3eHaPSaYzL9xMxUzKYfh0mGBDik3IfP2wlQI0Ji/x/JEuitCEneDl9FxpxPVhtOnwhWoRJ57ZwgphdI8JnEQ2gyqsFNxya5vXS14ipesagmLh+pklWKqVCZAnbfnZv/1dBmz9thME+9/pjOnwuXw88vvlzxWwrbsnc+VE+FSxfQS8uetXN8TPhqiEpUKqJCpfNp6N0v2sTGxUwixtzM/+9jFw3Rh+MX6NCuI/Y5p9OlyPBIRUVE2bLevt42AR6XbAEAADcP8QMym1RNguzevVtVqsReZf3ss8/s3CDZsmVT5cqVr5gE+fLLL7VkyRJ7/84777RL7Xbu3FmffPKJGjdubLePGzdO/fv3JwkCZGDj5vVWqUqFVaRUPi2fv0FD2k232we90tkOSTHzQTz9YkedD43Uix/3sZOpjn5klj7qs0lHdwTp5N5zqtWhuB6dV1/15+zSh6/9bXuAmDk/zJSdrWOkc+uPy/uOvCpcNaey58+ir0b+pqDjh+wf0dVz3Z2sNsx7eakGTe0sh6eHPpj6tTKbCUuHq3T1EipSvpCWzV6h7+at0rpFP9vnhsztqwVTF9vkQ6dh9+vWu6opPDRCb/abe0k9c0Z9Gn//9XXP6+n6FyZOfWZWL33+2vIkEyAJNepYR5Xqlre9Px5+rr2WzPxOqz/boDULN9mVacxcJItnfEMCBACANEb8gMzCw5WKl9ZMT43Dhw/bnh8dO3bUP//8YwPXgIAAhYRcfmK7PHny6OTJ2O7TJomyefNmOy9IeHi4atWqpW3btikmJkb58uXTqVNJT7YXHByswMBAO7TGvB6A9OGeov1TXEft5Xsv2eYTFq3HH16rvHtC5HJ4yMPp0omS2fXO/AaK9E+c3/353hIpbsPXB15TRtfc0SHFdSTsCXI9nOHhKW7DCueCFNeBtJdeztvppR0AkF4RPyA9SY3zdqr2BGnUqJFNfphExQMPPBDfO8QkL67E399fJ06cUN68ee2bOnTokEqVKqWDBw/GJ0/CwsLkl8LgG0DmYRIdJuFR++M9ynkoTGcK++vnh0pekgABAAAAgDip+teCmQ9kypQpdh6QoUOH2m07d+686vK4devW1ffff6+HHnrIziXSsGFD1a9fX+vXr9eIESPsPqtWrVLt2rVTs7kAMjiT8Fj3WNm0bgYAAAAAd0yC5MyZUxMmTEi0rWXLllctZ5IkvXv31v33368+ffqoSZMm+uuvvzRmzBhVqFDBrjRj7r/66qup2VwAAAAAAOBGUpwEmTlzpl0C15g+PXaCwaRcqTeI6QlieoHcfffd+vDDD23iw9zilt195JFH1KpVK9tDBAAAAAAAIE2SIIsXL45PgixatCjJfcyqDFcbEmOGvZQpU0Z33XWXnUOkaNGidm6Qo0ePauTIkerSpUuy2tMm8BF5eZi1IjImJvxDZuMKS7ws7fX4uU2ZFJV3nomdeBkp9+/oGikqX2JpGB8D0iXiBwC4cYgfkKmSIMuXL4+//+OPP6aoLjOpqrn9999/OnbsmJ0o1SRGAAAAAAAAUuqGLKMQHR1tV3NJ6FqWrzErw5gbAAAAAABAanGkWk2SNm3apGrVqtmlbM0kqeaWI0cO+xMAAAAAACDT9ATp1q2bOnXqpE8++UT+/v6pWTUAAAAAAED6SYIcP35czz//vJ0INa1kyeanqd+PV4lKRdWvzgjt3XbAbm/Usa7a9m+piPORmtz9DZ04eEr39WmhDoPv087N/2l8x6mX1JW/eF698fNL2vf/OsZ3fEVBJ4OTrOtyzLEYPLePCpbKL5fLpSk9ZujM0bMa+8UQeft5yxnjtNuO7TtxA48KkH44HB4aPKOH8hTMoWMHTunVAR+oXqsaeuCJOxURHqUpfd7VycNnLimXJauvJn7QW8XLFtDAdtN1aM8JTZjXyz7n4+ctb28vPdX6FbXqWk/tezbWrq0HNKHv+0m2IX+xPJq+Zoz2/X3IPp7Q9U09Pr6Tat9TTfNf/EqLZ30vd9LkwXrq81oPdcj/mH3cpu/data1kf0/66MJC7Vp6a+J9jf/w7/csoWK5giUS9Kzy77V3I5tdezcOfv8jA0/af3e/XquWWNVzJdPft5eeuenzVr+z077fImSeTVgyL2KiXEq/HykJj7/pUaNbycfHy85nU5NnrhEx44G6b62tdTxoTra+c8RjRu1MA2ODNwJ8QMA3Lj4IaWxg0H8gHSZBOncubO+/PJLPfDAA0orJjExqvVL6jWpa/w2Ty9PtRvYSoMajlb520rr4VHt9WrvWVqzYKN++eZ3Pf7S5Vee+XP19kQJksvVdTmlq5eQt6+3BjUarZrNqqrNU3drzrPzNbnHDJ06fFq1mldVxyH36fWn5qTiUQDSr3qtaurovhOa9MQctX+6hU2AtO3TXINbTlK5GiXUeXBLTR/04SXlTIJk7ONz9Nizre3j6KgYDev8lr3fpE1NFSyex95fu/wP/br6H/UY1vKK7di6bode6PJG/ON3xy7Qn+v+sX8IuROTqG3Q7g6dOHBhBZ3WT7ZQr2rPyM/fVy9+89wlSZCK+fPJx9NTD83/TPVKFFPXWtUVGh6uNb2eUJEzp1U5Zy79Vqe+Xlq5RtFOp/y9vfVJl07xgcyB/ac0oM88e7/row1Ut0F5m/g4dTJEtW4rpY6d6+j1V77RmpV/65dN/6nnk01v8lGBOyJ+AIAbFz8kFTuERESo57sfquvGdbr7//HD9KgoBXt7XxI7GMQPSJdzgrzwwgsaOnSo6tatq7Zt2ya6JbcnyYABA9SwYUPVrFkz0S25TM8K01sjocJlC2rf9gOKjorWtg07VLJyMbv97Ilgu/+VVKpXXq+sHqceEx66Yl2XczJBL5FsOfwVdCJYUZHRNgES94dcTPSV2wBkJgVK5NG/fx209//9c7/u7d5Q+/45bH8Xtv/8r0pWLHz53+3ToUk+1+Dealq3/A97P+jUOdvD4Goq3lFWU78boUfHtLePTx8Lkjtq2rm+1i7cJJfTXJeJdXj3Uflm8VGW7FkUfCrkkjJHQi5sC/D1VUhwiMqGhmrw8KHqNKCfBv2ySZ/PmC6f87HLI2fx9tbuk7H/5xkJPx9fP2/t33vCJkCM6OiY+OfPng2zPUOAm4H4AQBuXPxwcexwOuy8snl7a1PzxnrmkYfV/t9dGvTd1/rkjVflHxFxSexgED8gXfYE6dKli3x9fdWgQYPrmhPEzCfiaTKEDz2UqnOKmORDWHBsMG44PJOX+zl95Iy6l31a4WERGvT2E6r/QG2dPnr2muoKOhli/3OYs/1V2yNkYP3nEvUq6TKqvV7pOfO63heQER3YeVS1mlbU+iVbVL3RLXZbWMi1/34mHCaTt2AO7d99LNllzO/xo1WHKCIsUgPe6KF699XS+sWJezu4A4fDoUYd6mrMA5PUflBsDxvjl29/0zvbpsnT06HJj755SbkzYedlYp5ve3a3V3WW9HlKnt99LY9Tp+TRtas0ZoxKDxhgr+yUmzrFXvGZvGpdojpq3lpSvfrcaZMen364wW4zr2d6hkx9adlNePfA1RE/AEDqxA8Xxw6dPvxEPm+8oT4LP5OjSxc5Ro+W+vdX6RPH9EmDO5Tv9tqXxA4G8QPSXRJk9erVOnz48DUth5vQli1bdOLECfn4+FxzWVPmxx9/1PbF/2nRq18neu7cmVD5B2SJf3y13h9muEud1rdq45LNWjhtqd1mMp0V65TX/o/XJauuuDq2fP+nIsIj9VjFASpTo6R6T+2miZ1ftfsMnNVbS2et0JH/kv/HG5DR/fTtn6pav7xe/vIZ7f3nkM6dDZN/9uT/fl7sjmaVtOmHbddUxvTGUmTs/XVfbVbF20u7VRIk7v+n31f9pdULNtixu3HMZ9GyZ3N1L9dP3j5emvzDGP264s9E5RuUKqGI6Gi1ePs9VcqfT9MffUTOTz+Sp3lywQLp8cfl9PCwQ2OeWfK1veKzsFtnfbH1wue0ZfMePdHjHTv0pWWbmvrkww0aOLSlln65RUeSmBMGuFGIHwDgxscPF8cOI5o2UsgH79l4wfP/sYNhHv8xfIQmP9glPna48CrED0iHw2EqVqyokARdna7V7bffrt27d19X2cjISDVp0kQLpi2+5LlDu4+qeIUi8vL2UqW65fXf1n1XrMskPgY3Havlb1+YHLFKw4o6tPtIsuuKq2PXlv907kzshD/nzoYqW46s9n7nkW11dO9xrf4s9goo4C7MCXP2c59p2P1TFXI6VItmfq9i5QvKy9tTFWuX1p5tsZOVJlf9e6rZeUCuRcJ5P6rUK6/D/x6XO4n7/8mM2W3etZEmLh9ph/o98Uo3OZ0uRYZHKioiyvaCMz3YkprsOig83P4MDo+Q8uaTw9s79omGDaXdu+VwuXQkXz67KTw6WqGRkfFBjLe3TZdYoaERdnLUh7vV19EjZ7Vq5fabcQiAeMQPAHBz4oeEsUPurP42TjDxQlzsYJh44mDOXJfEDgbxA9JlTxAz90fLli3Vp08fFShQINFz991331XLv//++2rfvr2dE+Ti8v369Ut2OyYsHW4nJC1SvpCWzV6h7+at0hevLdPUVc/bX85J3WInQ2zcqa7a9L1HhcsW0MvfjdKzLV5IlNGsXP8WdR//kCLCInR0z3G9N+oTe5U6qbou59fv/lSzLo009cfn5e3rpZnPzFPugjnVdXQHbVu/Q9WbVNb2TTs1d8RHyX5/QEaWM1+Ahr/d047r/G3139q2abe+nPmDJi8ZrMjwaE3uM/eyZcfNfVylKhRSkVJ5tfzjTVr/zZ/KVyiH9u+60JuqUavqav1IfRUqkceuJjPykdmX1FOpTjl1H91OEecjdHTvSc0bv1CPju2gOi1ryOHpoYIl82nWs5n/d/KdZ+fH33/z55c0c1DsZKVrFm7S9A0T7NCkxTO+SfT/orFuzz7dX6miPurc0XZpHbviB731089yBJ2VywQsPXro37z5VfXllzU/W1Z5ORx6Y/2m+PI1bytpV30x9QadDdOM177T/IVPa9vWg6pRq4S2/3VQc2b9qMZ3VtT97W5T4SI5NenVhzVs4Hxd1BQgVRE/AMCNiR8ujh0mrVqr52bNVMS+4cpyLkTRjz8uh4eHwj5fqMaVK6upl1ei2MEgfkBq8XBdHN2mQMmSJZN+EQ8P/ffff1ctP2zYML322muqVq1aojlBTPmVK1desWxwcLACAwPVWG3k5fH/K5IZ0ArngrRuApCq7s4du4xtSngEZk9ReefxCzOXX69vz8We4DOy5o4OKa5jz8Q6SW43k5iZOUDMEBhzBeeDOvUV5ut7yX4lloaluA3fr7swtxIyrrjzdlBQ0HUPo03NdhA/AEDSiB+Q2eKHVO0JsmfPnhSVf+utt+y8IGZYDQAg4zAJj1mN70zrZgAAgAyE+AEZfk6QlMqbN69KlSqV1s0AAAAAAACZULpKgowaNUo9e/bUrl27bDeXhDcAAAAAAICUSNXhMCnVo0cP+3P+/PnxswmbKUvM/ZiYmDRuHQAAAAAAyMjSVRIkpXOKGI7K5eTwvHQyvuT4+ptPUvz6LQpVT3EdQGbyzalLV2dBxpXz75SV99q+N7WaghS6p/DTKavAK2UhRLQzQukJ8QMA3DjED5nHPZkgfrhhSZDz58/bXhwJV3m5muLFi8ffP3nypPLkyXODWgcAAAAAANxNqswJMnv2bO3cudPeP3bsmO666y5ly5bNLllz99136/jx48mqJywsTL1797aJk/z589ufTzzxhEJDQ1OjmQAAAAAAwI2lShJk3LhxNmlhDBgwwN43k5vu2LHD3n/66eR1mXnmmWdsMuWHH37Q4cOH7U9Tz+DBg1OjmQAAAAAAwI2lynCYs2fP2l4fxurVq7V79+74YTAzZ85MNMzlShYvXqytW7cqV65c9rFJoHz22WeqUqWK3nrrrWTVUbZiYT01rI2cTpfOng7VSyMWKCbaqbwFAjV38QA99dBb2vfvcVW7raQefbq5YqJjNG/GD9ry0w7VufeAtu2I1IZlRVT5Fl+9MvOMvlgWqqz+Hnr3tfwqVMBLA547oT+2RSjsvEuDnsyhTm2ya95nwZo7P1hR0S4ddTlU1qPqJe1yOBwaOu8p5SmcS8f2ntArvWba1waAtFK2Zik9Oa27XE6Xzhw7qxe7TI//fylv0Tx6b+d09b11mPZuO5CoXME8AZo3prP+O3TKPn72zaWa89yDOnHmnH08d8lP+nnbfo15vIVKFc6t8xFRWvfHHn349eZL2mAmvh70xqMqWCKPXC7plafe1QsLBujUkbP2+Y9fWabfVm2/CUfDPWXJ6quJnzyl4uULamDrqdq344gmLexvvxNePp6aPvQTu+3JFzqodKXC8vRy6IMpy7Vl9T+J65j/pIqXK6CB97+qfTuP6p1VI3TqaJB9/pM3Vui3dTvVe8wDKl2xkHyz+Gjh7B+1cvFPSk+IHwDgxsUPxA6ZS5YUxg/XGzusWfp7+kmClC1bVuvWrVODBg0UGBio06dPxydBzpw5Y+cGSQ6zn0kWJGQeJ7e8cfJYkEb0eV8R4VF69Olmqtukgtau2KaOjzbQ9t/3x+9nEiAj+76v6KgYvfBGV/3+y39a/H4hDR1/0j5/9Hi0ln8fprWLC+uX3yP0wrTTmvFyPk0ek0fe3h46F+pUwzYHbRKk8wPZ1a1jbBIoT8EzCneFyc8j8Vwo9dvW1pE9x/RS1+nqOOQ+1W97u1Z/tiHZ7wsAUtvJQ6c1/O4XFHE+Uj0mPKR699+mNZ9vss89OKyNtq3fcdmyW3Yc1LNvLI1/fO58hJ54acEl+41751v9+/9kSVJKVykqb18vDW45STUaV1Trnk0VGnxeQ++bnOL3h6sz58qx3WbpsVH3x28b3ul1e/Ggyh1l9EDPJnp18EdaNHulju4/pWyBWfTC/L6JkiC2jh5v67ER98VvCw0J17AH30z0Wu9M+MrW6+fvoymf90t3SRDiBwC4sfEDsUPmEZHC+OF6Y4fUSoKkynCY559/Xg8//LDmzJmjxx9/XK1bt9Z7771nb61atVL37t2TVY/Zt3379tq8ebNOnDihX375RZ06dbL1JdeZU+fsQTWio532oOUvlMNkWHT8aOyVRcPh6WEPtNnX4elQjpzZlDePZ/zz+w5Gq2J5H3uVsmYVX63fdF56/Yx8RpywP0NPRqtCOR+7r0mKxL6eS17ylrditydUsFR+/ft77KoIu7bsUZUGFZL9ngDgRjBXb0wAY5iEsPn/0ihQIp/tlXFif2xSOCnVyhbS7BEd1ad9PfvY39dHs4Z31Pgn7lVAVj+7zSWXRvRorjeGtFPZoklPdH3i8Jn4++YEGXQyxF4dmLRkiIbN7qlsObKm6ntGYs4Yp4JOx/bgiRP3PfDP7qe9/xy2900AY0RFRMvlciZRR+K5u7L4+2jSp301dHoXZQv0T1SvCWT27z6a7j6KGxI/lPLW+q9D5THkuLxnnpVCnQoNcxI/AHDL+IHYIfNwpjB+SOvYIVWSIPfdd5+dHHXWrFkaOnSo/vjjD/Xo0UNjx461SY2XX345WfW88sorKlasmO1RYobCmJ9FihTR1KlTr7lNZvhLjdtL6ae1O9Tp0Qb6/P31iZ43v7Bmnxy5sqpEmXzKlj02aI9Turi3Nv8erogIl77/LlRn/ouSx0unpE+C1XXiKVWvt1/Nbs8Sv/+UGWd0S719NgHi6XFpB5v9fx9SjaaV7f2azaoq6/8/WABIa6bras07q2jT0l/t407D2mjBlMWX3f/k2VA9MGSuek38TDkD/NWkVhk9/sIn6v3iZ9q4dY963l/H7vfax2v02PhPNPnDlRrevXmSdQWfOme7Tr69abweG9teKz5er0H3vKShrSdr8w9/qeuwC1cIcHME5sqmKV8OVN+JHbV10+5Ez3V7trW+mrP6qnU80266hnZ6U7+u+kddBraI3z70tS6a8c1Q/bY2djL19CjV4ofTMfqh2QGdORFjYwcTQ3StsVfVmxxQs4YXYgDiBwDuED8QO2R+gSmMH25m7JAqSRDDrALz888/KyQkRAcOHLDDYPbu3asRI0ZcMsTlcsyKMnPnzrWrxBw9etQus2seZ8+e/Zra4p/VV0NfaKepoxcpX4FAu+3Y4QtXcYyZk7/W4HFt9dTw1tq765i9ApRQntye6vVIoO5+8JC+eeusykdLHk7JI1qaL+lvp/TypFN27hFjcJ+c2rGhuCIVoSDXha7f7Qa20pSVY1WoTAFFRUZr8g9j5JfV12ZQASAtxP2/ZH76Z8+iZ99/WpN7zLDjeU2vNePYvhOXLR8VHaPwyGh7/8fNu1SuWD4FhYbbxz/8vEvliue19+O27TsS29vD4RHbay6hWndWUmR4pHreMUovdHtLvV7opJAzsVcG1n61WaWqFE3tt4+rMFd2Bt8/TS/0nKPuz17oidm84+3y8vbUqi9jg90rCTkbZn+uXfaHSlUsHL99Uv8P1avpi+rY507bUyK9SdX44e4D+vpgtMqbuW/+H0N8GOrU9kcC9PLrZ4gfALhV/EDskPkFpTB+uJmxQ6rMCZKQmQskbj6Q62GSKMuWLdPBgwdVtGhR3XPPPfGTriaHw+GhYRPba/7sVTq0/5TqNa2o4qXzacKbj6hE2fwqVDS3hvacq53bDmlYr3cVkMNffZ9tpfNhsV26EureKcDeVnc9rHwmj+OUIiT5mvfpkLL///VMbxFfXw95enrIU15y6EK32IXTltpbQl3HdNCW77de9zECgJSI+3/JJKjHLhqiD8cv0KFdR+xzpasVV/GKRTVx+UiVrFLMJnAHNx2baCJnfz9vhf1/2ECN8kW05/ApeXt52gCnRvnCOvj/JG9WPx+FhkcqZ/Ys8vH2lPMy8zvFnfTOBYUpR57s8vbxsknjKnXL6fCe5C2xjtRhhneYnjlmLq7QkPMK//+5sWrdsqrXsrrG9Xj7qnWYQMfEKFGRMap8eykd2RfbLdrbx9NuiwiP1PnQiGua7+tmSO344dHN4Vr1UbDy/7/3r4kffBxS1qPRyp7VQfwAwK3iB2KHzM2RwvjhZscOqZ4EuVhUVJRatGihlStXXnXf33//3e6bM2dOlSxZ0vYk6devn7755hvVqFEjWa/XqEU1VaxWzI4p79yrsZZ99rOe6THHPvfMuAf0+bz1dmyRmSj11rplFH4+Sm++FJukaPnwYbvyy85/I9Wza6C+/TFMJ0/FqFiwU2/+/3h3lmT6eUTFSCObxI5Vn/zmGa1cF6boaMlfJZXdI8cl7cqZP4dGfjzA/kew5Yet2rb+wqRyAJAWGnWso0p1y9urOQ8/115LZn5nJ2xet+hn+/yQuX21YOriS1ayql6usJ5oV0/hEVE6fDJYH3+7RXNGPWhXgYmKitH4Od/a/cY9cY+dH8T8cfnqx0l3gdyycpvu7FjHzgFiJkidO3ahXvlmuMLDImwi5JWn370JR8K9jXv/CZWqVERFSufTz9//pZoNb7EJKxPMvDkidrLbp1/qZIOPFz95ys6FMbpr4hXbxr3X0161MXVs/HarGrSqbgMg8xlOG/KJ3Wfo9K4KyJFVnt6e+nj6d0pvUj1++D1cxZzSDCWIH6KlqLXnNXJc7Bw5xA8A3CV+IHbIfMalMH5Iy9jBw3WDL8VERETYniExMVdfDrZhw4Zq166d+vfvH7/t9ddft8vkrl279oplg4OD7co0TSsPkZen6atx7b7+JvZgXyLUKY+WB6VdkbEDiMxVnbI+ci0rImVNPNSnRaHqSokVzktXVwCA1NDc0SHFdZztGjvfx/XKvSTly91+c/qdFNcB6Z7CT6fsMHil7DpKtDNC3x98S0FBQdfU4zO13bD44RpiB4P4AUB6RfyAzBY/pEpPkLZt2172Oacz8SzyV/LXX3/pxx9/TLStT58+Gj16tNJUVkds0DI3SB77o+Qq5i31CEwyiAEAACB2AAAgfUqVJMjy5cvVq1cv5c6dO8nhMEuWLElWPQUKFNCmTZtUr17skouGmWzVbE9zJuHxdE6lrxHMAAAg3SJ2AAAgcyZBqlSpombNmtmlci8WHh6uiRMnJqses5KMmQi1a9euKlGihJ0TZP78+XZIDAAAAAAAQEqkyniO7t27X3bYi7e3t8aMGZOserp06WJXhjG9R8ywGPNz8eLFNikCAAAAAACQridGvdkTmzVWG3l5eCujYmJUAMDNUPuRqSkqf6xJdIrKO8+H62DfselmYlTiBwAA3CN+SFcze3p6etpeJdFmrdkE0jI4AgAAAAAAmUO6SoL4+vrq+PHjdn6RM2fOxG/PJJ1VAAAAAABAGkpXSRAvLy8tXbpUlSpV0h133KHdu3fb7R4eHmndNAAAAAAAkMGlqySI4XA49Oabb+rJJ5+0S+WuWbMmrZsEAAAAAAAygVRZIje1JBz2MmDAAJUpU0YPPPCAzp8/f911Vm1UUV2eay9PL099Pm2JNi7erKmrnpfL6ZKXj5de7T1Le7cdSFQmSzY/vbxitEpUKqp+dUbEP9+oY1217d9SEecjNbn7Gzpx8JSqN6msHhMeUnRUjN4b/Yn+XL39msr3efVRla5WQr7+Plowdcl1v08AAK5VwTwBem/sw/rv0Cn7ePgbS3Q25Lzy586uhZN66JHRH9rnqpcrrH4PNbLn6Y1/7tWsBT/q6PhZijp8TPlH9pFPkQIK/fkPhaxYLw9vL+V+vKO8cuXQ6Y8WK2r/Ebkio5T97gbKWruazq3drHNrfpYus6pcenGt8UNKY4drrYP4AQCQVgpm8PghXSVB5s2bl+hxq1attHLlSn355ZfXVZ+3r7faD2qtEfdOVHTUhclWhzYbp5joGFVtWFFtB7bSK4+/laicCTJGtX5JvSZdWJrXBEHtBrbSoIajVf620np4VHsbAJkgZvg9ExQTFaMJy0bomSZjrqn8rMHv27b4ZfXTq2vHX9f7BADgem3556ANXhJ6pGVt/bnrcPzjLvfepudnf6N9R05r9nMP6qNvsilv/246u2C5fd4VHaOQb9cp//DeitxzUKGLVujZAnlVMCJSR6qU17v1amrPtHdtEON3SyllrV/Lzu5+6KnndeLEiXQ3Afr1xA8pjR2utQ7iBwBAZoofPHbsUf43PlT/4oW0N1cOfTigu86Z1WRenJnq8UO6Gg7Ttm3bS7ZVq1ZNY8bEBgfXqlLd8oo8H6nxi4dpzMIhypk/h91uAhjDPyCL9mzdd0k5Z4xTQSeDE20rXLag9m0/YIOhbRt2qGTlYna7w9Oh0KAwhYdF2PsBubNfU/m4tvhl9dW+7Qev630CAHC9qpUrpNkjO+nJ9vXt40J5AuwVm6OnLpzH9hw+pWxZfOTp6ZDT6VR0jEueAdnin48+dlLehfPJw8tLOYsWVImf/9SQL75V5w1b7M+5L89Wlvx57L5eeXPZub7i5vsyK8OlN9cTP6Q0drjWOogfAACZJX7IGh2j7z5eKsfeg+q4brOe/XKFvnxhhvyCz8m7UL5Ujx/SVRIkteXMH6gCJfNp1H0va/nbK/TI2A52e2CeANvr4uk3H9fWNX8nq65sOfwVFnxhWI4JWozoyGjlLZpHOfIFqkTlosqWI+s1lTee/aCfZv8xRVu+/+O63ysAANfq5NlQtR08R70mfKpcAf5qfGsZPdKqtuZ/vTnRfqt/3a2X+t2nBS89ql//PqjIqNhkQBxzVcbh52fvd/tho7yjouTpcsk7xqlHXC61PXZSzS9a6e38n//Yn7ly5cq08UNKY4cr1WEQPwAAMkP80O2HjSpz5LjMQBcTO5gY4vnDx3R0zGvyq1g21eOHTJkEMd1Gp6wcq4Kl8uuv9f/Yqye/r/xLxSoUsc+bqywDGozSuPZT1WNC50vKmZ8XO3cm1F75iWOu1hgzBr6nIe/21dNvPK6Q0+c0eG6faypvvNR1unpUGKAHn30gFY8CAABXFhUdo/DI2OEeKzfvVONasYHGkYt6I/R/qJF6v/CJ2g2do7JF86hEocSBh8M/i5zh4fZ+0ZOnlfDazHxJWx0eWr99l1z/H8cbeeCIzv24KVPEDymNHfZs3a+G7e+45joM4gcAQGaIH4qePC2nwyNR/DDP06GptSorePmqVI8f0tWcIKll4bSl9pY9VzaNmN/fbitTo6SO/nfcXkExk5qZrjq2K2po+CXlknJo91EVr1BEXt5edkzuf//vBrtz878a2ux525X1qdcf08TOr15TeW8fL0VFRisiLEJhIRfaAgDAjebv562w8Ch7v0b5Ivr5r326v3EVvTa4rUoXyaMi+XPqyRc/s+fMc+cjZTpzhIVHKlsW30T1eOXLrajDx+WKjtZaeajq/7dHSDJ7ZnO65PD1lYfDoZizwTr9/iLl7tFeR0a+kuHjh9SIHT55+Ut7u5Y6iB8AAJklfthTrYI2xjgTxQ9eTpeO58sjj0PHUj1+yJRJkDimZ8bGJRdmc5/y2Aw7rtcENmZMktn2+lPvJFl2wtLhKl29hIqUL6Rls1fou3mr9MVry2xdkeGRmtTtDbtfp2H369a7qik8NEJv9pt7zeWHz+9vgyAvb0/Nf+FzPb9o6E06OgAAd1etXGE90a6+IiKjdPhEkGYtXK/l62NXKhnds4U+XL5ZMTFOvf3lRk175gHFOF3af+S0/vr3iI4vfFdR+w8r6uhJZWtUW9mb19exl2frA4dDy/LnUczxU3rQ5dJpcz729pZHx3ttvUFffS9n8Dmdem+hfbxr1y7VqlVLmSF+SGnscC11ED8AADJL/DDhu7Va4uOtTyOjFOXp0EMxTh309tJff/6twNZNUz1+8HAlXJc2AwsODlZgYKAaq428PLyVUa1wLkjrJgAA3EDtR6amqPyxJhdWTbmYf3iEHd9rurceyJNL8+6sozA/30vGAR/sO1ZBQUFpujoM8QMAAGkfPyQndkit+CFT9wQBAAA3nwla3mrZmEMPAADSXeyQKSdGBQAAAAAAuBhJEAAAAAAA4BZIggAAAAAAALeQ6eYE+Sro/TSdYA0AgIwg19c7U1Q+8EOz7sv1i3ZF6aDSD+IHAADcI36gJwgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAADcVJasvnr1m2e1aO9rKn5LIbut4f23atryYXrpi4HKUyin3VasXEFNXTrEbq/R8JYr1tnkwXpacGxO/OP3dkzXlJVj7a1ms6o3+B0BAIAbLUsGjx8y3cSoAAAgeSLCozTm4Tf0+Nh29rGnl0Ntn2imwa0nq1yNEur8TEtNf+ZDdR95v6b2m6ezx4P1wqf99Nuaf5Ksz8PDQw3a3aETB07GbwsNCtPgpmP5SAAAyCQiMnj8QE8QAADclDPGqaBT5+IfFy6VX/t2HFZ0VIy2//yvSlYobLfnyh+ow/8dV9i5cAWfCVVArqxJ1te0c32tXbhJLqcrfptfNj9N/fF5Df+wv7LnzHYT3hUAALiRnBk8fiAJAgAArKyBWRQWEn4hSPD0sD89Yn9YYcHnlT3HpUGMw+FQow51terTDYm2D6j/nJ5pMka/fPubuo7twJEGACCTyZrB4geGwwAAAOvc2TD5Z/eLPxrOmNgrMs4EV2ZMoBNyNjT+cbuBrVSn9a36fdVfWr1gg1yuC/saIadjrxStWbBJ9zx2J0caAIBM5lwGix/oCQIAAKzDe47bScy8vD1VsXZp7dl+0G4/czxYhUrlk382P3sVJ/j0hSBm4bSldsyun7+vmndtpInLR6pw2YJ64pVu8vL2krdP7PWWqg0r6PC/RznSAABkMoczWPxATxAAANzYuI+fUunKRVWkdAEtf3+Nvpz1gyZ/NViREVGa3Pddu897E77UM9O72S6r77+8OMl63nl2fvz9N39+STMHzVOOfIGasGyEwkPDFRURramPzbhp7wsAANw44zJw/ODhurjfSQYVHByswMBABQUFKSAgIK2bAwBAunZ33t4pKh9z6nSKyke7orRKX6X5eZv4AQAA94ofGA4DAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAVWhwEAwA19c2JWmr5+3ISkAAAg4/gmE8QP9AQBAAAAAABugSQIAAAAAABwCyRBAAAAAACAWyAJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFkiAAAAAAAMAtkAQBAAAAAABugSQIAAAAAABwCyRBAAAAAACAWyAJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFkiAAAAAAAMAtkAQBAAAAAABugSQIAAAAAABwCyRBAAAAAACAWyAJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFkiAAAAAAAMAtkAQBAAAAAABugSQIAAAAAABwCyRBAAAAAACAWyAJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFkiAAAAAAAMAteKV1AwAAGUdzR4cUlffwSvlpxxUdnaLyK5wLUtwGAACQfMQPSE/oCQIAAAAAANwCSRAAAAAAAOAWSIIAAAAAAAC3QBIEAAAAAAC4BZIgAIBrkiWbn6ZvnKjFwR+oRKWi8dsbdayr19ZP0KTvxyhvkdx2W7EKRTRtzXi7vcadVS6pq2yNkpq6coymfD9aIz/qL08vT7s9b9HcWhryvkpUKpKsNjV5sJ4WHJsT/3jwnD72cZu+d/PpAgCQieKH1IodDOIH90QSBABwTSLOR2pU65e09vNN8dtMANJuYCs903iM5o3+RA+Pam+395jwkKb0eFPD735B3Z7vdEldJw+f1oiWL2pws3E6/O9R1W1zq93eafB92r5hZ7La4+HhoQbt7tCJAyfjt80d+ZHeHvoBnywAAJksfkiN2MEgfnBfJEEAANfEGeNU0MngRNsKly2ofdsPKDoqWts27FDJysXs9lwFc+rQ7qMKCzmv4FMhCsidPVG5M8eCbFBkREfFyBkdowIl8srlcul4gqTGlTTtXF9rF26Sy+mK33b66Fk+VQAAMmH8kBqxg0H84L5IggAAUixbDn+FBZ+/cHLxdMRfZYkTGhSm7LmyJlnedGGt2bSyNi37TR0H36fPpy1N1us6HA416lBXqz7dkOL3AAAAMk78cL2xg30d4ge35pXWDQAAZBxTVo7VxiWbtfCiQOPcmVD5B2RJdLXHcDljfxrZcmRVyOnQS+r0z55Fw97tqyk9ZypfsdixwMf2XflKjuk6W6f1rfp91V9avWCDvfoDAADcI364ntjBIH6AQU8QAECyDW469pIAxjBdVotXKCIvby9Vqlte/23dFz8spXCZAjZYyZ4rm+3SmpDD4aFn3++rDycs1KFdR1WqanEVr1hEE5Y8q5p3VlG/Nx6Ln/AsIdMG0xY/f18179pIE5ePtF1qn3ilG58mAACZOH643tjBIH6AQU8QAMA1m7B0uEpXL6Ei5Qtp2ewV+m7eKn3x2jJNXfW8IsMjNanbG3a/uSM/1uC5fW331nljPr2knoYd6qjiHeWUJVsWPTyirZbOXqFnmj4fGzC984Tt2hoTHXPZdrzz7Pz4+2/+/JJmDppn7/eY2Nn2FDGvW7B0/vjtAAAgY8cPKY0dDOIH9+bhyiR9iIODgxUYGKigoCAFBASkdXMAIFNq7uiQovIeXinPvbuio1NUfoVzQYrbgMxz3k4v7QCAzIz4AenpvM1wGAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFkiAAAAAAAMAtsDoMAOCm2TGjRorrKLrcI1XaAgAAMgbiB6QmeoIAAAAAAAC3QBIEAAAAAAC4BZIgAAAAAADALTAnCAAgRao2qqguz7WXp5enPp+2RL99v1Vjvxgibz9vOWOcmtJjho7tO6Es2fz05X1dVC5nHt2/+EPtPHNSrUrdoscq1VJ4TLQGrV6uI6EheqRCDfWqWltbTx7Vkz98ZV+jfdnKeqp6HR0NC1FIuXMa9+oyNat/i/o/dqdaP/qm8ubOpmd6NVfWLD7a8tcBvfvZBpUokltDn7xLDodD73y8Tpv/3McnDQBABoodDOIHpDaSIACA6+bt6632g1prxL0TFR0VHbvNx0uTe8zQqcOnVat5VXUccp9ef2qOIs5Hqsd3CzWiduPYE5CHQ49XvlUdln6kankLql+Nuhq+7lst27NDqw7u0fDajRK91rvbNmve9t/sxKgeHlLjOuV1/FSIfa7vI401ZdYKnTx9Ln7/Xg830MQ3vtbps2GaOqo9SRAAADJY7GAQPyC1MRwGAHDdKtUtr8jzkRq/eJjGLByinPlzKCoy2gYxRnRUjGKinfa+ubJzOvx8fNmSgTm168xJRTmd2r7vPzXy8NHEDxaq46Jl8gkPv+S1ulaooQWtHtKd9W5R8wYVtWrjDrmcLnl6OlQgX6Ce6t5Yrz3fUZXLF7L758mZVQePnFXY+UgFh5xXYPYsfNIAAGSg2MEgfkBqIwkCALhuOfMHqkDJfBp138ta/vYKPTK2Q/xzpotrl1HttWj68iTLBvj4KiQqUv7hEfryxTdVKChEHddv1pBF32r2jA/kGXMhAPpu3y41XzhX3b9dqE733aq7G1fUD+v/sc/lCMii0sXz6M15q/T8tGXq16NpbCHTXeT/zoVFKiCbH580AAAZOHYwiB+QUiRBAADXrN3AVpqycqwKlsqvv9b/Y7uz/r7yLxWrUCR+n4GzemvprBU68t+xJOsIigxXdm8fdftxg8ocOS6PmBh5xzjl6XKpxPGTKn7iVPy+wZERckkKjYrU2eAw/bP7mFxmg6SQ0AgdOHxGJ06d0+mzoYoxdTg85IrbQVK2rL4KPndp7xIAAJBxYgeD+AEpxZwgAIBrtnDaUnvLniubRszvb7eVqVFSR/87bu93HtlWR/ce1+rPNly2jr1BZ1UmZx7FnA2Wq3496c8/459zOjzkHxEZ/zibt4/ORUXK4eGh0sXy2glQzTwfRQrmVO+HG+hcaISy+vsoJsYlby9PxThdOnUmVEUK5rBzgpheIEEhF4biAACAjBc7GMQPSCmSIACA6xZy+pw2Ltmsqauet/NzTHlshnIXzKmuozto2/odqt6ksrZv2qm5Iz6y+7/Xop0q5sqv0oG5NP+fPzT3r80aPuMdeR4+Kj3ySGylnTrJ66mnlLtyJc0vW0pdvv5Mj1W+VY2LlpIZ4PLJks1asPRXu+s7k7rq9Xd/tPOATBrRTl5esSvBGLPnr9WIp+6JXR3mk9htAAAgY8UOBvEDUpOHK2F/4QwsODhYgYGBCgoKUkBAQFo3BwAypeaOC+N2r8fO2bddsi1uThAzJMb0AHE4XdpdMJ/uH95XYX6+l+xvVodJiXVfDElReWSu83Z6aQcAZGbED0hP5216ggAA0pRJdJiEh5kbpOjJ0zqQJ5fmNambZAIEAACA+AEpQRIEAJDmTMLjrXuapHUzAABABkL8gOvB6jAAAAAAAMAtkAQBAAAAAABugeEwAIBkc/j5peholZsbkeKj7XXkTIrrAAAANw/xA9ITeoIAAAAAAAC3QBIEAAAAAAC4BZIgAAAAAADALTAnCAAgRRp3uENPTumqTsX76r4nmqlZ5/pyuaSPXv5KPy3/7ZL9S5TKqwFDWyomxqnz5yP1wqiFur1uWbXtdLsiIqI0efxinTgerCEj71PxUnkVfj5SP23YrQUfbYyvI0tWX0388AkVL1tAA9u+pn07j+qdlcN16liQff6TN7/Xb+t2qlqdMuo+pKWio2P0/tSvtfWnf/m0AQBIB4gfkFZIggAArpuHh4caPFBbJw6dto9b9WymJ2qPkJ+/jyYsHppkEuTAvlMa8MR79n6XHg1Vv9Etuq/dbRr05HsqX6GQHn60gV59eZl9fsqExdr734lL6ogIj9LYx97RY8Nbx28LDQnXsIdmJNrPJECe6zZL0dFOjX+3p4Y++CafNgAAaYz4AWmJ4TAAgOvWpFMdrV30s1xOp318+L9j8s3ioyzZsyjk9Lkky5geIHH8/Lx1/GiQ9u05YRMV27YeVMnS+exzLrk08NlWeunVh1WqTP5EdThjnAo6HZpoW5asPpr0SV8NfbWLsgX6x57kHB42ORJxPtLeD8iZlU8bAIA0RvyAtEQSBABwfScQh4catrtdqz//KX7b5hV/6u0tL+n1tc/ryxnfXbZszdtK6q33eqpazeI2+REWGpGoXmPW69+rf6939ea0bzRg6L1Xbc8z7V+3PT1+XfOPugxoYbdFRcUob6EcypEnm4qXL6isAVn4tAEASEPED0hrDIcBAFyXpg/V05qFP8llJgCR5J/dT/f2aKJHqwyRt4+nXv56uLb88FeSZbf8skdPdn9bHR+uo6o1iss/q2/8c05nbH0hwefjh8/EBU1xzyUl5GyY/bl22R9q0el2e3/2+C81aPJDOhcUpr07jujsyRA+bQAA0hDxA9IaSRAAwHUpfkthla5WXHc+VE+FSxdQ1+faKTI8SlERUYqJjpG3j7cd8xuXJInj7e1pe2gYoeci5OXtqeIl8sjLy2HnBPlv9zH7nL+/j8LCIpUjp7+8fbyumAAxdXh4SFGRMap8eykd2XvSbt/55wENf/gtOwymz/NtdT5BjxMAAHDzET8grZEEAQBclzmjPo2///q65zVr2Hy173+vXl01Rg5Ph5bM/v6SBIhR87ZStgeISWoEnQ3T5Be+sj+nzuimyIhoTRr/ld3v2TEPKHuAn61r1usrLqln3NyeKlWxkIqUyqeN3/2lBi2r2ZVkoiKjNW1obNs6PNFUtRreovCwCL01dhGfNAAAaYz4AWnNw5VUhJoBBQcHKzAwUEFBQQoICEjr5gBAptTCv2uKyjurl0txG7yOnElR+a/3vJLiNiDznLfTSzsAIDMjfkB6Om8zMSoAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt8ASuQCAZPs27AOOFgAAuCbED0hP6AkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALXmndACAza5GtW4rKu2JilNa+O/9hWjcBAAC3QvwAADcOPUEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFpgTBLhJ8hfLo+lrxmjf34fs44ndZmjEvD72vq+fj7x8vNS33uir1tO4Yx31mdJVHYv10TOzeun2e6rrw4mLtHjmiquWLVGxiPq/0UMx0TE6fy5CE7q+rmw5surpV7vLPyCL/li93dYFAADSB+IHAEhdJEGAm2jruh16ocsb8Y+H3vOS/dm0U10VLJXvquU9PDzU4IHbdOLgafv43TGf6c+1fytLNr9kvf6BnUc0sOk4e7/LiAdU775bVfvu6pre/12dOnzmOt8VAAC4kYgfACD1MBwGuIkq3lFWU78boUfHtE+0veEDt2ntop+vWt4kS9Yu+kUup9M+Pn307DW9vukBEsfX38cmRfIXz6PeL3XWpK+H2/YBAID0hfgBAFIPSRDgJjEJi0erDtEzd01UYN4A1buvlt1uenHkKZJL+/85fMXyDoeHGra7XasXbEpRO2o2rawZG19QtUYVderIGZWqXFSzh3+sF7vP0BOTu6SobgAAkLqIHwAgdZEEAW6SqMhoRYRF2vvrvtqs0lWL2ft33FtDm5b/dtXydz5UX2sW/iSXy5WidmxZ+Zf61HnO9jxp3rm+Du46qpOHTuvMsSDbU8ThyX8LAACkF8QPAJC6+GsHuEkSzttRpV55Hf73eIKhML9ctXyxCoXU7OH6mvDVUBUuU0BPTHr4mtvg7XNhGqCwoPM6Hxquc0FhdlJUP39feXt7yRkTO9QGAACkPeIHAEhdTIwK3CSV6pRT99HtFHE+Qkf3ntS88QttYJO3aO74FWOuZM5zn8bff2PdOM0cOl89xnXUHS1rytPToUKl8tltV1LzzsrqMLClnE6Xgk6GaErPWdr1216N/2KwvLw9NW/c56nyXgEAQOogfgCA1OXhSmnf+nQiODhYgYGBCgoKUkBAQFo3B7BaZOuWoiPhirkwkWla+e78h2ndBACZUHo5b6eXdgAJET8AwI07bzMcBgAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbYIlcZFr3lByUovJRhXKluA1eXin7FfP9OnuK2xDV2TPFdQAA4C6IH2IRPwDIrOgJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALfAnCDI1LJk9dXED59Q8bIFNLDta9q386jyFAhU3/Ht5J/NT39s3K2Ppn9n9/Xw8NDMb4do6YcbtOT9dXZbiZJ5NWDovYqJcSr8fKTGj/5CTw28W3fULaMP3l2rrxZujn8tDw/pnQ96a/GiXxNtj1OuZkk9Pq69vZ8rfw79vOJP3d6imk4dOWO3fTxlmX5btT1+/2hXlH7qvVQhe0+r/lvtFVAqt9Y/9YU8HB5yRjlVdUhju+2v19YqaPdJxUREq3Sn6ip8Z1md3npEf05Zpcig82ri3zP2OHzcR8XLFdTANtO0b8cR+xp5C+XUnDXP6emWU+y23mPbqnSlwvLN4qOFs1ZqzZLfbvAnBABA+pNR4wcTO2wO/VrnWpxNUexw15c9LhwH4gcAmQxJEGRqEeFRGvvYO3pseOv4beb+G88t1KljQYn2bXxfDR0/fDbRtgP7T2nAk/Ps/a6PNlD9hrdo7qwf9efv+5Qli0+ifZs0r6zjx4Iv25adW/ZoaKvJ9v6A6d20cdlvqlynXPy2iznkqdovt9L2GRvit9V5tY0cXp4K2bRPMS/+oD7l8upQ/mz69uWWOifZQMcEMtlL5lL9We214elFUuj/j0P32XrsuTaJXqNDnzu1bfN/8Y/feeFLxUQ75efvoylf9CcJAgBwSxk1fjCxQ03/5tpV77dLYoeTvx/Svo+2aGyJXOoVHqVTtxfTV/fcoh+GLLk0dkh4HIgfAGQyJEGQqTljnAo6HRr/2NPLofxFcqnnyPsUmDub3p/6tf7eslcOh4fq31tNa5f9bntBxDFXcOL4+nnrwL6TOn3KpBsSM+UbNamg1Su32/2uxOHp0C23ltZr/d+3V1gmLRuqU4fP6M0hH+nc2QttdXg45JMjS+KyXp7yC4tUm6mrFHT8nJrtPiUPl0vNftitpyfeo+wlYle08c7me8XjYOQvmksul0snDp+58H6jY9+vn7+v9u86dsX3AQBAZpVR4wcbO3hcGjvYn6fD1HXzQXX5fpdcHh42fqj0zT/aXCp3krFDUsfBIH4AkNExJwjcSkDOrCp5S0G9M3GxJvX/UL1H32+3N7m/ltYt/0NOp+uSMjVvK6mZ7z6u6jWL6/ChCwmDhO68q7JW//i3nK5Ly1+sesMK2rp+h01ADGrxooa2nKTNP/ylrsPvu2rZiLPn9Vu3jzX22Dk1dkleMU55Ol0avue0Vvf4THluLark6vBkMy2c9eMl24dO76oZ3w3Tb2t3JLsuAAAys4wcP5jYYV2fhfp78iq1PhNm4wYTPzzidKnl/rO6KxmvnRDxA4CMjiQI3EpocLgO7Tmhk0eDdOZkiGKiY+Tt46mGLatr9WXmv9jyyx498eg7WvPjP2rZpmaSV3Ea31lRq77flqw2NLj/Vq39KnbMb8iZ2Ksra7/crFJVil21rG+OLHq9djF96vDQiATb3/d06J2GpbT7w1/lSiIQu1jB4rFXfY4fPH3Jc5P6faBeTSaoY99mdpwzAADuLiPHDyZ2qD+jnUbXKKznEoQI8yX95fDQN5sPJit2MIgfAGQGDIeBW4mMiNK54HD5Z/ezQz+8vL0UkDObcuTJrufn9lTu/IHy9PSwXVz/Ph0mb29PRUXF2LKhoRHy9r40b5gzVzblyJVVEyY/qDx5s9ugZvtfB7Vrx9Eku7JWuK20pg94X17enjbJEBUZrSp1y+nwf8ev2HZntNNObHasYICKuVzK+v/tEeYX2eVSUJFAee05bfe5mpIVCqt4+QIa/8ETKnFLQRUqnlfDOr1u2x4VGaOI85E6fy7CXm0CAMDdZdT4IS52MLfzhQISxQ5m8EtWl0teWbyTFTsYxA8AMgOSIMj0xs3tqVIVC6lIqXxa/tFGzZuyXM/PeVxeXp764JWv7QRn/dtMs/s2a3ebHWe7+6+DUqFctitrx851bDIg6EyYJk1YrMeeaKI69cvZYKVQ4Zx6a/oK9X1sri1/171V7YRnSQUwRrUGt2jrhp22vmw5smr8gv4KD4tUVESUXnnq3Uv2/2nIEjt7e+iBM8pXp4RO/HJAP7lcKuvrpdkR0Yp2OPRQjFOHfTy1e+M+le12qy1nVpQxM7+HHjirX2IWqXxgPb368SiVqlQ49jjM36Ah7abbfQe90tkOizFB3bOzeiggp788vTz18fRvb+CnAgBA+pZR44dfQ79TyC+nE8UOJslh4oePCgcq5kiwHnK6dMokaHy8VLhP3Utih40Dv1K5yPoK8MmncfN6Ez8AyFQ8XJnkUm9wcLACAwMVFBSkgICAtG4O0oF7Sg5KUfmoQrGTjKaE17Y9KSrvsyTx5GZxzOSoLb/YqvxHgm3PkGVtqyjcP/Fs83GiOsdOiHa9vj7wWorKA0B6Pm+nl3Yg/SB+iEX8ACA9So3zNj1BgAzIJDwWdqmV1s0AAAAZCPEDADAxKgAAAAAAcBOsDgMAAAAAANwCSRAAAAAAAOAWmBMEmVbQbYVSVP5IveQtF3clZYeGp6j8uTFlUtwGz8O/pbgOAADcBfFDLOIHAJkVPUEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFpgTBJle83q3aMCjTdXy8Rlq16KG7mlUUS6X9N4XG7X+1/9Uq1JR9X6ogaJjnHr70/X6bfuB+LIODw9NveseFciWTQeDgzRu9Y96897W8vXyUozTqSErvtWhkGDVKVJUQ+rWV7TTqakb1+unQwcvaUeJikXU/83HFBMdo/Oh4XrxkTc16uP+8vH1VkyMU1N7zdKxfScvLVcijwYNusfuc/58pMaN+1KzZ/fQyZMh9vn58zfo11/3aujQlipRIq/CwyP100//6tNPf7qkrizZ/PTyd6NUolJR9as7Unu3HdDUH8fK5XTJy8dLrz4x224DAMDdET9cQPwAIDMhCYJMzcNDanxHOR3/f8KgbYvqemTwe/L19darI9vbJIhJgAyauNAmQaYOb6u+Yz+NL3936bI6EHRWA79drt61blPD4iVt4uNY6Dk1KFbcbhu96gebAOn25ReKdsbo3TZt9eDCzy5py4GdRzSwyfP2fpeRbVXvvls1pecsnTp8RrWaVVGHQa30Rv/3Li134LT69fvA3n/kkfpq0KC8QkMjNGjQR5fsO2nSUu3de2kiJU7E+UiNuu8l9ZrUNX7b0ObjbWKmasMKajugpV7pOfOajzMAAJkJ8UNixA8AMhOGwyBTu6t+Ba3atFNO0/VD0sGjZ+Tr4yV/Px8FhZy32zwdDp0Li1B4RJQcDg8FZs8SX75oYKC2nzxh7/91/JhqFy6skNOn9MT3K/XIDz+qwr598o+IkMPhUEhkhM5HR9v7Of0u1BHHJBri+Pr7aN/fh2wCxIiOikn0fKJyMc4L5Xy9tH//KWXJ4qNp0x7WyJH3KXt2v/jnn3nmXk2a9KBKlcqXZF3OGKeC/p8Qurhd/gH+2rN1f7KOKwAAmRnxQ2LEDwAyE3qCINMyQ1ma1imvZyd/qQdb3Wq3/fT7Xs1/5VGbqJgw42u7LSo6RvlzZ1dkdIxKFc2jbP6+8QmSf0+fVsPiJfTN7l2qV6y4cnp564tp01Xm1Gl5fPutXD176ovQcwrr3FWFsmdXZEyMyufOrQBfX50Jj60joZp3VtbjEx+ySY/Ppiyx2zy9PPXwiAc07cm3L/teatUqoV69mtiEyCefbLI9Q4KDz6t588rq1q2B3nhjhWbOXGm3FS2aS8OGtdJTT72frOMUmCe7nv9iiPIWy6MxD0y+rmMNAEBmQfxA/AAgc6MnCDKtFg0rauXGHXb+D8M/i4/ua1ZVnfrP0UMD59phMMZr837Uc33v0eDHmunf/Sd1Jig0vo4f9vyrSGeMPmrbQf5e3sq/c6fKHDsuz1mz5Jg5U57//msf//nKVE1ufrfGNb5TO06e1MmwC3UktOWHv9Tn9pFau+hn3ftYU7ttwIzHtOztH3Tkv+OXfS9mzo/evd/V6tX/qFWr6jbZYZjHZcrE9vqI22aGzximV0tymJ4hAxqO1rgOU9VjwkPJKgMAQGZF/ED8ACBzoycIMq2SRXKrXIl8atGgoooWzKnHO9ZVZGS0Is3QkxinfLw97Zjfv/89qqfHfWaHwTzT406FhUfF12HyJy+sWWXv97+9joK+/VYaOVLas0f6LHbeD6eHh7w3/aSHv1hgh8E837ipQqMu1BHH28dLUZHR9n5YUJidiLTzs/fr6N4TWv35psu+D29vT0VFxQ5ZMXOB+Ph4xW+rWrWoDh2KHVLj7++jsLBI5cjhb593Ov+f/bkCh6fDTorqcrkUGhSm8NCIaz7OAABkJsQPxA8AMjeSIMi0ZsxfE39/zotdNH3eKj3U+lbNfqGznQdk4be/214iXdvUVu1qJeycIK/MXZmojjz+/nr9nlZ21Zf1B/Zr5/kwNRs9Wlq/XmraVNq4UY6RI1Wod2991LSpwqKjNHZV4jri1DSTnw5saZMTQSeD9dbgD/Thrte0bcNOVW9cUX//tFtzR12YlDVOrVol1anT7bHlgsI0a9ZKvf56V4WHRykyMkaTJy+z+40YETs/iBnqY4bGXM6Epc+qdLUSKlKukH5a9qtqNa8mp9NpkyGvPz0nBUccAICMj/ghacQPADILD5e5BJwJBAcHKzAwUEFBQQoICEjr5iAdqNtxSorKH6l3aXdQMwmqnRPk2HHbA8Thcml3/nxqO7Cfwnx9L9m/7NAtKWpDdL3KSinP1b+lqPyKmEtXugGAzHLeTi/tQPpB/BCL+AFAepQa5216ggDXwCQ6TMLjkbXrVfTUaR3InUvvN6iXZAIEAACA+AEA0heSIMA1MgmPmc1iJzUFAAAgfgCAjIPVYQAAAAAAgFsgCQIAAAAAANwCSRAAAAAAAOAWmBMEmVbWz39KUfkyn6e8DSldemnlyuEpbwQAAEg24gcAyNzoCQIAAAAAANwCSRAAAAAAAOAWSIIAAAAAAAC3wJwgcBtZsvnp5RWjVaJSUfWrM0J7tx2Ql7eXXvr2Ofu8TxYfeft46claQ5NdPk7eonn03s7p6nvrsETbEyp/Wxn1fLmLvZ+rYE79/PUWzRw0T4061lXb/i0VcT5Sk7u/oRMHT92Q9w8AAG5u7HC5OuIQPwDAzUcSBG7DJBlGtX5JvSZ1jd8WHRWtwU3H2vt3PtxABUvnv6bycR4c1kbb1u+44uvv+GV3/GsNevsJbfjyF3l6eardwFYa1HC0yt9WWg+Paq9Xe89KwbsEAADpJXa4XB1xiB8A4OZjOAzchjPGqaCTwZd9vmH7OlqzYNM1ly9QIp9cLunE/pPJaofD06Fbbi+rrWv/VuGyBbVv+wEbUG3bsEMlKxdL5rsBAADpPXa4Uh3EDwCQNkiCAP/vqpq3aG7t//vgNR+PTsPaaMGUxcnev0bTytq6ZrtcLpey5fBXWPD5C7+QnvxKAgCQ2WMHg/gBANIGf3Eh0zPDTaasHGt/Xk6d+27VxiWbr7l8wVKxXWCP7TuR7Ndv2KGOVi/YaO+fOxMq/4Asia4WAQCAjB07XK0O4gcASDvMCYJMb+G0pfZ2JaY767vPfXzN5UtXK67iFYtq4vKRKlmlmAqVKWDHCcdExyRZ3vT0qHBHOb3ae7Z9fGj3URWvUMROsmbmBPlv674UvFMAAJAeYoer1UH8AABphyQI3MqEpcNVunoJFSlfSMtmr9B381bZ7qz5iuXRvu0Hr6v8ukU/2+eGzO2rBVMXJ0qAXKx6k8p2LhAzFMYw+37x2jJNXfW8IsMjNanbG6n4bgEAQFrHDperg/gBANKGhyvur7EMLjg4WIGBgQoKClJAQEBaNwfpQHNHB2V0K5wL0roJAJCpz9vppR1IP4gfACD9So3zNnOCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC1kmolR46Y2MWOEACPaFZXhDwTfZwCZVdz/b2k9NRnxAy5G/AAAmTt+yDRJkJCQEPuzaNGiad0UINWYSX8AIDMz5++0/L+O+AGZEfEDgMwuJAXxQ6ZZHcbpdOrw4cPKnj27PDw80ro5AADgCkz4YQKYQoUKyeFIu9G5xA8AALhX/JBpkiAAAAAAAABXwsSoAAAAAADALZAEAQAAAAAAboEkCAAAAAAAcAskQQAAAAAAgFsgCQIAAAAAANwCSRAAAAAAAOAWSIIAAAAAAAC3QBIEAAAAAAC4BZIgAAAAAADALZAEAQAAAAAAboEkCAAAAAAAcAskQQAAAAAAgFsgCQIAAAAAANwCSRBkOi6XS7169VKuXLnk4eGh33//Pa2bBNxQ5nv+5ZdfcpQBIBmIE4DLa9y4sQYMGMAhQqZGEgSZzjfffKP33ntPS5cu1ZEjR1S5cmVlBL1791bp0qWVJUsW5c2bV23atNE///yTaJ+dO3fa7Xny5FFAQIDq1aunH3/8MdE++/fvV+vWrZU1a1a7X79+/RQZGRn//NixY+0fzRffzP43y2+//aYOHToof/788vPzU7ly5dSzZ0/7/oy9e/cmalvOnDnVsGFDrV69+qonaZMMMGWuhfmedO7cWeXLl5fD4UiyXvOdSuq4hYeHx++zZs0ae+wLFSqUrMSE+czNfq+++qrSi1WrVtk2nT17Nq2bAgA3BHFCxo8TrnSuql69un0PcUqUKBH/HkyMZR537NhRK1euTPK1z58/b+MOczHN3L8e/fv3V61ateTr62vbc7GL45y4m/luJmTiHlOPOQalSpXSzJkzL6lr4cKFqlixon0t83PRokVKT7hQg/SIJAgynX///VcFCxZU3bp1VaBAAXl5eV2yT8KTfXphTnLvvvuu/v77b3377bf2StVdd92lmJiY+H1atmyp6Ohoe+L+9ddf7Ym1VatWOnr0qH3e7Gv2CQ0N1bp16/TJJ5/Yk+MzzzwTX8fgwYPtH/0Jb+akaYKNm8Ekp+644w5FRERo/vz59v1+8MEHCgwM1KhRoxLt+/3339v2mSDAJH3uvfde7dmzJ9XbZNpiEk8jR45UtWrVLrufacPFx84EJnHMcTfl33jjjau+pkmQ/PTTTzZhkhmZ76/5rgJAekOckHnihOQaN26cfR87duzQ+++/rxw5cqhZs2aaMGHCJfua42EuoJn3/MUXX1z3ObBHjx7q1KnTFfeLi3Pibk2bNo1/zsQ7Ju5p0KCBTQqNGDHCJqxM++Js3LjRvkbXrl31xx9/2J8mwWPii8wmKioqrZuAzMQFZCLdunVzma913K148eJ2e6NGjVx9+/Z1DRw40JU7d25Xw4YN7fapU6e6Kleu7PL393cVKVLE9eSTT7pCQkLi63v33XddgYGBriVLlrjKlSvnypIli6tdu3auc+fOud577z1bf44cOVxPPfWUKzo6Or5cRESEa8iQIa5ChQrZumvXru368ccfr+m9/PHHH/Y97N692z4+ceKEfbxmzZr4fYKDg+2277//3j5evny5y+FwuA4dOhS/z8cff+zy9fV1BQUFJfk6v//++yX13iihoaGuPHnyuO6///4knz9z5oz9uWfPHtum3377Lf65gwcP2m0zZ86M/0z79+9/SR2LFi2y+12vy9Ub911ILtMG05akmPdSuHBh119//WW/Q9OmTbtqfXPmzHFVrFjR5ePj4ypQoID9Pif1WuZ7Zh7HHUvDHEezzRxXY+/eva5WrVrZ7675fpp6ly1bFn/cE97M75ThdDpdL7/8sqtkyZIuPz8/V9WqVV0LFiyIf4241/3mm29ctWrVcnl7e7tWrlxpv1+NGzd2ZcuWzZU9e3ZXzZo1Xb/88kuyjyMApCbihMwRJyR1rotTrVo115gxY+IfX+48O3r0aHss/vnnn0TbzTnLxBpvvfWWq0mTJil6P6Ydpj0XSyrOudjQoUNdt9xyS6JtvXv3dt1xxx3xjzt27Oi6++67E+3TokUL14MPPnjFdq1bt87GwiauNbHAXXfd5Tp9+nSScVBS8YyJh0xcFBfzmpjExCbme2SO98SJE+1z5n5ScbmxePFiGxOYMia2GDt2rCsqKirR65rP4L777rOxivm8TBs7d+5svyMmFilTpoxr7ty5V3yvQFLoCYJM5bXXXrPZ/iJFitiM+i+//BL/3Lx582yvkPXr12vWrFl2mxn6MH36dP3111/2edPDYujQoYnqDAsLs/uYqyWmm6Lpgtm2bVstX77c3szVidmzZ+vzzz+PL/Poo4/a1zFl/vzzT3v15O6779auXbuS9T7MFRrTK6RkyZIqWrSo3ZY7d25VqFDBXsEwz5ur7OZ9mK6iphdJ3BUBc/UiYe+CFi1a2KsppudIUt555x3bzdRcabjRTA+XkydPXnKM45grM5fj7+9/XVcC4rqcms8tpc6dO6fixYvb75fpgWOuzFwrp9Npr9QMGTJElSpVSlaZt956S3379rVz3WzdulWLFy9WmTJldL1MXeY7YYbvmPpefvllZcuWzX7X4q4wmatl5nfI/E4Zzz33nP1OmrZs27ZNAwcOVJcuXRINUTLMZ/viiy/aK3dVq1bVww8/bI+X+V0038Fnn31W3t7e1912AEgJ4oTMGydcz5AV87f2V199laiXkImlTG8Kc9uwYYP++++/ROXMcJqEw21S4r777lO+fPns8OaEcaRh2mF6BCdkPqvNmzfHx0KX28e0+3LMXHl33nmnjUFMedMjyAyPStjz+FqYGNnEJZ999pmNHT788EN7jIy4ONzEDwnjcvM5mxjC9GzZvn27jWfNsOOLe+aMGTPGDgM3sYrpWWN6Apn9v/76axtnmJjEDOkCrtWl4wSADMx0lcyePbs8PT3tUJiEzB+NkyZNSrQt4dwPJuEwfvx4Pfnkk5oxY0b8dnOiMf/Jmvk6jPbt29vEx7Fjx+wfjqa7ZJMmTezcHKZLojmBfvzxxzp48GB8kGG6lpoEijkJTJw48bLtN69rTvwmyXHLLbdoxYoV8vHxsc+ZP+TNY3MyMO/RJHBMAsTUGxcUmGExZltCZlyrqSNuyExCcV1NzR+mN0NcEsi8t2thjsfw4cPt59qoUaNrKmv+4DZzfcQlUa6XabM5QVepUkXBwcE2kDZBi+l+WrZs2WTXYxIOJhlnTvzJ9cILL9iuyiZgi3Pbbbfpepl5Y9q1a2ffi2HGGccxY6ANE5TFfa/M8X/llVdskrBOnTrxZUzgZAKXhJ+JSUI2b9480WuZhE/cZ34txwoAUhtxQuaME66HOd+Zc525WBJn7ty5uueee+wxMcwFLLPNnIfjmHgwpX94m/jRnFdNHGHiOZNEMDGkuSBnkgOXi+nMY3MRzCSKzNDvy+2T1GcZx8TCt956a6JYN7kXZZJizvPm3F6/fn0bq5qLRXHMUGPDxBMJ43KT7DDfqW7dusXHFCYGNzGwSXzEMfO1meRHwteqUaOGbb8Rl2wBrhVJELiNuP8wEzKJC5OUMFll84etObGYiS7NH31xE4CZP57jEiBxJxfzn645gSXcdvz4cXt/y5Yt9sqCuWpycSBhenNciblqbv6ANNnyKVOm2KsQpkeJmXfC1NmnTx97wl67dq2d3MtcnTE9Ekxm3ZwMjaQmBTVlk9puxrqGhITokUceuWK7TEBgXjO5zNUik6VPqh3XwszrYoID0xvHvL+4JMS1KFy48CUTzF4PMz7Z3OKYwKVmzZp6/fXX7VWQ5DBX2UzyxHxHkjt5q/leHT582F61SS0mAWOSfd99950dE20SIqbXxuWY3w/ze5EwuRE3t44JRq70ezZo0CA9/vjjNnFoXsv0ikr4+wQA6QVxQsaLE1IqYXxkekKYJERcD0jDJCRMz8fnn3/eXogxfvjhhxS/rkmimHoTfvfOnDljExRxSRDj4lgh7vgk3J7UPleKMUxPkNSc36V79+42PjAXnEzSyMSlF/dOSSoeMrFrwp4f5vibWMPEfHEXri7+nTSxi4lZTBxlXuP++++3sSJwrUiCwG1cPKv5vn377IRTTzzxhM0+mysC5sr2Y489lmjIxcVd982JJaltZpiDYX6aE6X5Dz7uhBknYeLkcleozM1k1M0f3OZKhJnl+6GHHrJX4c1kYeYkaSboNEwW3/QOMSdtk1E3WfaLJ8My+5v3c/GVAiMuiXJxr5mk9ruWGdJNgiYpcYkhk5SI61FwJZ9++qntaWOuIFycQDLHICgo6JIyZqb4uONzI5nkjOmNkdwhToYJEE1So1ixYolO+qaXh1khJuHVqKsdyyu16+JA8uIhRCYpYbrLLlu2zCZCzPCVqVOn6umnn06yzrjvttnfJJUSMrPRX+n3zHQZNldyTFkT8JorPGaY2AMPPHBN7wsAbjTihIwTJ8Sd500ccPEQGRMHmFjqak6dOqUTJ07YnsBxQzQOHTp0yWSm5jxtzpUm0XMjmbjPHMc45phf3KPDxBCmN2lcTHS5fZKK+a43rjAx7sXJqYRxhbkgZCZxNed4M9GruYBnLnpcPLzn4rjCJJbM8PKLJZxw/uLfSfMZmPjdxBTmtcwFIjPE11w4BK4FSRC4LTOm0vT8MH/8xf3haMYzppS5Mm5OmOYklNLxs+akY3qQGCYzbsS1NY55HPdHqgkYTFbd9CSJ6xliTtzmD9W4eUPimBOW6QljumBezcV/+F4vk7U3Vz/MlY6klnAzgUvCYMbMUXG5XgOmq2xSV5HMlQVzNeJGM5+NuZpyLT1TzFwgJjBIyCQjzHYzj0xSzNAn0/PIXHkyw66uJq7rqfkOxHXnNe28mDm2JgFobmao0dtvv22TIHHDrxKODY5bes90Q73W4UhxQa25mateJqFnhoWRBAGQ3hEnpN84wVwsMvGPOecnHH5hzn0mkZGcOMD0+DB1mN4Expw5c/Tggw/aleISeumll+xzNzoJYuYZi4vd4mK6JUuWJNrHxHSmd0TcxTizj7kYlrBXidnnSr0jTM9PE1OYJERymLjCHNc45uJPXEyaMCllkkfmZoaNmx4hp0+fthcYTVsvnm/EJE7M/CHXM7+ZaY/pfWJuJs42Q25JguBakQSB2zJ/XJskiBnOYCaEMsNOklp//VqZP/bMsBbTddQkWExSxIzdND05zB/MpvfJxcykW6bXgzn5m//czQnczB1hsvVx+5sTnfmj1oyfHD16tH3O/OFqkhlmWVzDlDd/sJo/qidPnmxPQGY+kp49e17SO8KMcTUn2xt9Uk/IZPTNVQ7TDdNMBmaGZZgToDk+JgFl/sg2vQSSwwwNMkvRxk0Yao6HCQRMoGKGXsQxx9JcKTATytauXfuy9cUlCszkp+bKkHlsEgLmeBomWDBXaUzgZYZOmSEwZp8333wzvg5Tdvfu3fGPzWdj9jFBgOn9Ya7cXNyjxQQH5krOlQI205vCJCvMUCjzeZmuyeb7mlTPDXM8TYLDlDFjmE2wYr6HF8+FY+ox31XTU8h8N82ku4YJJs1VH9PryHz3zHE1iRjzPTJBlkm4mXG/5hiYiddM76a4Mb0XM1cFTXBiAiJzpc3Mk2MCVtOVFQDSO+KE9BsnmPNS7969bU9K0zPCLE9vho6aBIY5n108HMOcN02PCdODwZybzeSd5nVMT0hTvznvm4SDSfiYiWMTMuc4E2eZfUyMZmIKk8h/6qmnLvs+TCxgYgLzmuZcGBdjmJjCxBamB685/5sY0SRizGubuMLEfnHMed/EOWZYqYnjzCSmJsYx887FMXOFNWzY0JYzc8aZSV5NDwnTs/lyzIUPE4+aOMq8hmmPSXaZY57UXCdm2V7TDhMDmRhg2LBhiXpET5s2zX5Pqlevbt/LggULbFwTd1Er7kKOGUZsLqiYWNbEsaaHkYlXzOuacmYhATMBasL5Vy5mypmLemYOE3OR0MQqcfELcE2SXDMGyMDMMmgJl+C60rKnr7zyiqtgwYJ2iTCzpNj777+faMm1pJZFTWq5M7PkXps2beIfR0ZG2qW8SpQoYZcKNcuGPfDAA64///wzyTabperuueceV758+ez+ZrleswTYxcu2maVFzTJmuXLlssuNmmXSzLK4Ce3bt8/VsmVL+57Mfmb53vDw8ET7xMTE2NcYMWKEKy2Y99G2bVtX3rx57dJoZomzXr16uXbt2pXspeOMzZs328/NHLeAgADXrbfeapf6SyiurqstUXzx0rAXL+U2YMAAV7FixewStabd5nPYsGFDojriluy73DKzSUnuErlmub7y5cvb74f5zj799NOXXb7OLH1XpUoVu3xcgwYN7FK2CZfINd+J0qVL22Nv3kvXrl1dJ0+ejC8/btw4+5318PBItETua6+9Ft8GU84c+9WrV192uUKzbJ5Zpq9o0aL2uJklo81rnz9//qrvFwBuFOKEjB8nGKbN5nxVoUIF+17M+bR79+6uI0eOJKor4TKt5lxkzuVmaVmzjHucKVOm2KViTfx2MbNsqzlOU6dOja8v4RK8STFxZ1LxQNx5+L333rPtNku/mnjOLC3/wQcfXFLPqlWrXDVq1LDtNjGlWTL2YuYcH3duNkvqLly48KrH19Rbt25de2zN+zbn87jz98Uxs4lRTcyTNWtWV9myZW3cmXCJ3NmzZ7uqV69unzex2J133unasmVLoqVwzefn5eWVKK765ptvbBvMZ2fK1a5d29Z1paV5x48fH/95m8/ExN7//fffVd8vcDEP88+1pU0AAAAAAAAynsSTCwAAAAAAAGRSJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAUvZRJOp1OHDx9W9uzZ5eHhkdbNAQAAV+ByuRQSEqJChQrJ4Ui7azLEDwAAuFf8kGmSICYBUrRo0bRuBgAAuAYHDhxQkSJF0uyYET8AAOBe8UOmSYKYHiBxByMgICCtmwMASKfaBD6S4jq88udLUfnoY8dT3Iavgt5XRhYcHGwvXsSdv9MK8QMAIDmIHzJP/JBpkiBxQ2BMAoQkCADgcrw8vFN8cLwcPimrIBXakFnOdWk9hJX4AQCQHMQPmSd+YGJUAAAAAADgFjJNTxAAAK73SsLguX1UsFR+O9nWlB4zdOS/Y3pvx3SdPHTa7vPRxC+05fs/E5XLktVXEz99WsXLF9TAVlO0b8cRTfpigFxOl7x8PDV9yMd2W+9x7VS6UhH5ZvHRwpk/aM3iLZdtS4lKRTVgZi/FRDt1/ly4XnhwmsJDw/lgAQBIZ4gfMi6SIAAAt1a6egl5+3prUKPRqtmsqto8dbdmDpqn0KAwDW469rLlIsKjNPaRmXps1P3x24Z3nG4TGFXuKKMHejXRq898pHfGLbLb/Px9NOWrQVdMghzYcVgDGoyy97uMbq/6D9TW9x+uSeV3DAAAUor4IeNiOAwAwK2dPHgq/n62HP4KOhFs7/tl89PUH5/X8A/7K3vObJeUc8Y4FXT6XKJtJtlh+Gf3096/Dyfa5ufvq/07j16xLTHRMfH37f7/HErRewMAADcG8UPGRU8QAIBbCzoZYoewzNn+qu0RMrD+c3b7gPrPKeT0OTXr2lBdx3bQjP7vXrWuwFzZNOrdnspXOJeef3RW/Pahb3RT9Qbl9e7ExVetw/RG6flyF0VHxejTl79K4bsDAAA3AvFDxkVPEACAW2o3sJWmrByrh4Y/oIjwSD1WcYDGtZ+i3lO72edNAsRYs2CTSlcrkaw6Tc+QwW2m6YXH31H3Z++L3z7pqXnq1XC8Oj51V5Kzmce1xfw0c488WWuo1i7cqHt7NUu19wsAAFKO+CHjoycIAMAtLZy21N5uu7u6suXMaredOxuqbDmyysvbSyZXERUZraoNK+jwv1cexmI4PB22R4mZXDU05LzCwyLtdm8fL1tPxPkonQ8Nt89fri1m3zhmThKvBI8BAEDaI37I+IiuAABu7dfv/lSzLo3s/B/evl6a+cw8mxSZsGyEXZklKiJaUx+bkWTZcR88qVKViqhI6fz6+fu/VLPRLXKaRIjTpTdHfmb3GfpmdwXkzCpPb4c+fvWbK7alZvOq6ji4jZxOp52bZPKjb96Q9wwAAFKG+CHj8nAldUkqAwoODlZgYKCCgoIUEBCQ1s0BAKRTzR0dUlyHV4H8KSofffRYituwwrlAGVl6OW+nl3YAANI34of0ITXO28wJAgAAAAAA3AJJEAAAAAAA4BZIggAAAAAAALdAEgQAAAAAALgFVocBALgVR/bsKa5j+8SiKSrvv7t0itsAAABuHuKHzIOeIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALzAkCAHB7VeuXV+ehreXp6akv3vxWeQvnUrOH6srlkj6avEQ/ffOHPUbRrihtDv1GIU/MV/7n+sinSAGF/vSHQlasl4e3l3I/3lFeuXPo9PtfKurwMVsm8r8DKvTKCJ3fvFWhm36PrefgCd399DCN7tXNPs6bLavW7Nyro8EhuqtSWYVFRmn4wm91IiRUw+9trAoF88rP20vvrvtVX/+10+0/LwAAMkrsYBA/pC8kQQAAbs3b10vtnmqh59pNU3RUjN02+6cX9ETd0fLz99GELwbFBzIOeaqmf3P9Um2HfeyKjlHId+uUf3hvRe45qKAlK5W7e1vleuR++3z0qbM69c5n8szmr2yNb7c349iw17TL6a1ucz63j8ff30w//L1bfZreoc6zP1WVwvnVp/Hten7JSk3+Zo2inU75+3jrw54dSYIAAJCBYgeD+CF9YTgMAMCtVby9jCLDo/T8p/01+sOnlDNfgA7/d0y+WXyUJZufQk6Hxu/r8HDIx+EX/zj62El5F8onDy8v+ZYtoZj9h/XkslWa+N4X9mf0pt/kf1uVRK8Xue+QfHLnk8Pbxz72dHioWtGCioiO0e5jp+y27UeOq2bxwrGv4XTan1m8vfXv8dM35ZgAAIDUiR2uFj/kLFpQubbuiI8d/MMjFLZ5K/HDDURPEACAW8uZN1D5i+fRoLsmqnqjiuo6vI02//CX3v7pBTk8HZrSZ85lyzrDwuXIEhvUmKCl7MGjGrL3kJwODzmcLn3u7aWgcf0VmaBM2C9blb1CtfjHt5cqql/2HNT+02dVpUgBeXt66vZSRRSQxTd+n0kd7lad0sX0ynfrbtBRAAAANyN2SBg/mNjhyxdmqMvpIHVct9nGDg9s/E01/HyV6+muicoQP6QeeoIAANzauaAwbdu4y3Zn/WPN3ypXq5Tu7dZIj9Z8Vo/fNkKPjm532bKOrFnkPB9u73f7YaP8o6Ll6XLJO8apIy6XskVG6bHNfyUqc/7PHcpWukL847srl9M323bpbFi4Pvn5T83p3lYNypbUnpNn4vcZuuAbtXx1nno1rC0PjxtyGAAAwE2IHRLGDyZ2KHP4uO2ZYGIHE0P4HTqmgsHn5BmYPVEZ4ofUQxIEAODWdvz6n4rdUsjeL121mI7uPaHIiChFRUQrPCxS3j5e8rhM5sErX25FHT4uV3S0zu/epyoJdjOzfbT18FDRExeGsETuPyyv/Hnk8PGNHwpTvWhBbd570D7+8rftemTOAn3/92799N8Bu830DDHOR0UrNCLSTrgGAAAyZuyQMH4oeOyk1nlIVRM897mHhxpclAAhfkhdDIcBALi1kDOh2rT8d01ZPkxOp0uvPPWu6reuqVe/H2m7tC55Z6VcCTIPW8K+U/i2YEUdPalsjWsr+131deyl2fow+Jx+SJCgWCjpE5dLH+TNlagra8I5Qm4vWVSb9x6KT2xM7XivcmbNosNngzV+yUq7bUrHe5TD309eDk+9teqnm3JMAABA6sUOl4sfRn22XKWcLn2QYL9FLpca3VIqUVnih9Tl4br408mggoODFRgYqKCgIAUEBKR1cwAA6VSLwB4pruOf18pfsi1uXK/p1ho3J8juQvl0/3N9FObnm3jf3bGToqbE3y8MVEaWXs7b6aUdAAD3ix+uJXaw+xM/KDXO2/QEAQAgFZhgxQQtZnyvGQJzIG8uzbuzTpJBDAAAALFD2iAJAgBAKgYzb7VszPEEAADEDukUE6MCAAAAAAC3QBIEAAAAAAC4BZIgAAAAAADALTAnCADArThDQlJcR7kem5XmMvjqMAAAZCTED5kHPUEAAAAAAIBbIAkCAAAAAADcAsNhAABurWzNUnpyWne5nC6dOXZWL3aZrpjoGLUf1Er1296h8HPhmvzomzp15EyS5cvfVkY9X+5i7+cqmFM/f71FMwfNU6OOddW2f0tFnI/U5O5v6MTBU9fcBiNv0Tx6b+d09b11mPZuO3CDjgIAALgWxA8ZFz1BAABu7eSh0xp+9wt6pskYHf73qOrdf5ty5s+h2vfW0oD6z+ndUZ/o4VHtL1t+xy+7NbjpWHv7a93f2vDlL/L08lS7ga30TOMxmjf6yuUv14Y4Dw5ro23rd6TqewYAAClD/JBxkQQBALg10/PC9NYwoqNiFBPtVP7iebRve2yvi11b/lPlerdctR6Hp0O33F5WW9f+rcJlC9ry0VHR2rZhh0pWLnbNbTAKlMgnl0s6sf9kKrxTAACQWogfMi6SIAAA/H/YSc07q2jT0l91+N9jKn9raXn7eKlms6rKljPrVY9RjaaVtXXNdrlcLmXL4a+w4PMXTraejmtug9FpWBstmLKYzwcAgHSK+CHjIQkCAHBLZrjKlJVj7U//7Fn07PtPa3KPGXYujuBTIVo6a4Ve+naUat9TQwd3HL5ieaNhhzpavWCjvX/uTKj8A7LE7+uMcV5zGwqWym/3ObbvxA06AgAA4FoRP2R8Hi5zySoTCA4OVmBgoIKCghQQEJDWzQEApFPNHR0SPXY4HBq7aIgWvbZMv63865L9qzaqaIfDfDTxi8vWaXp6zPxtsnpXG2x7gpg5QaatGadBjcao/G2l1eyRRnrtidmXL59EG+o/UFttB7RSeGiESlYppqN7jtt5R+ImTF3hXKCMLL2ct9NLOwAA6RvxQ/qQGudtVocBALi1Rh3rqFLd8rYnxsPPtdeSmd9p9WcbNOKjAcqRN0DH9p/Q633nXLGO6k0q27lA4q4rmETFF68t09RVzysyPFKTur1xXW1Yt+hn+/yQuX21YOri+AQIAABIW8QPGRc9QQAAbn0lJ6OiJ0jqoCcIACA5iB/Sh9Q4bzMnCAAAAAAAcAskQQAAAAAAgFsgCQIAAAAAANwCSRAAAAAAAOAWSIIAAAAAAAC3wBK5AAC3ktFXVQEAADcf8UPmQU8QAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2QBAEAAAAAAG6BJAgAAAAAAHALJEEAAAAAAIBbIAkCAAAAAADcAkkQAAAAAADgFkiCAAAAAAAAt0ASBAAAAAAAuAWSIAAAAAAAwC2kyyRIeHh4WjcBAAAAAABkMukiCXL8+HG9+OKLqlOnjrJkyaKsWbPan+bxhAkTdOzYsbRuIgAAAAAAyODSPAkyatQoVa1aVTt37lTfvn21fv167dixw/40j//9919Vq1bN7gcAAAAAAHC9vJTGTI8Pk+gwvT8uVrNmTXXp0kWhoaGaPn16mrQPAAAAAABkDh4ul8ulTCA4OFiBgYEKCgpSQEBAWjcHAABkgPN2emkHAAC4OeftNB8OAwAAAAAAcDOkiyRIdHS0nnvuOTVu3Fj9+vW7ZCLUKlWqpFnbAAAAAABA5pAukiDDhw/Xt99+q3bt2unw4cOqUaOGtm3bFv/83r1707R9AAAAAAAg40vziVGNTz/9VJs2bVKhQoX09NNP6+2331azZs1sYsSsHOPh4ZHsutoEPiIvD+/rasexfnWVUgXf3Zqi8t8GzU1xGwAAwLUhfgAAwD2kiySImdQkf/788Y979uwpf39/NW/eXF9//XWatg0AAAAAAGQOqZoECQ8Pl5eXl70ZixYtsvdbt259xXIlSpTQ77//rlq1asVve/jhh20PkLvuuksRERGp2UwAAAAAAOCGUjUJYnpuTJ48WXfccYeef/55zZw50yZBtmzZojFjxly23COPPKKVK1cmSoIYnTt3tomQkSNHJrsNWbL5aer341WiUlH1qzNCe7cdiH8ub9E8/2PvPsCjqLowjr/poSX03nuTjtIEpQhKEWlKU0ARBUSaja4CFlAQRMWC4idYEFApKiCCCiIoIgpI770mgfTsfs+9MYFACCWBlPn/nmfJ7uzM7N3ZDXNy5t5z9dG2KepX6xm7vHKD8np0woNyu9xa9/2feu3MIbterdKF1eeu2+Tl6amPV/yhormzq2nVMgqNiNLI2d/rePA5De/QWCXz57Tr31K0gJqOeVfBoYkna6o0KKcuT7eWl5eX5k37XgVL5lODNjUVdi5cEx+foVNHzlz1+wMAACkvrcUPxA4AAKSDJMjmzZtVu3Zte3/mzJn64YcflC1bNtWvXz/JJMiQIUMu+1znzp3t7WpFhEVqZOuX9eir3S957oFn7tWmVVvjH3caeq8m9HhT+7ce0qSfXlS2RScVERWth+6oqcenz1d0jEu5smVWt4bV9eAbn6ty0Xzq0/w2jZ2zXOO+XG73kS97Vo3r0vyyCRAfP2+1799cI9pPUnRUjHLkDVDbx5tp0F3jVa5GCXV9urWmDv7fVb8/AACQ8tJS/EDsAABAOpkdJiYmxvbc2LFjh1wulypWrKgiRYro9OnTSW536tSpFGuDK8aloBPBlyzPXzyv3G7p+L4T8cv2bjmgLIGZ5eXtZbczAUy1EgUVHhWtqb3v1aRerVU8bw7tOHLSrr/lwDFVL1EowX6bVS2jpX9tv2x7Kt5WWpHhUXr+8yc16pP+Klwmv/ZuOWif2/7XXlWqUybF3jsAAEj/8QOxAwAA6SQJYnqB9O/fX0899ZRatmxpl+3fv1/Zs2dPcru8efOqRYsW+vLLLxUVFaUb4f5n7tWcid8kWLb6q7Ua9eVQzdgyWX+t3KTI6Bh75aZQrgA98d7Xmvvr32pdq4IqF80vHy8v1SlbVAGZ/RLso2mVMlq2ccdlXzdHnkDlK5Zbo+9/Q4s/WqkmD9RT2Rol5OPrrRp3VFTW7JlvyPsFAADpM34gdgAAIJ0kQczUtmaml8DAQFsTxDBT35oip0nx8fFR2bJl1adPHxUqVMgOj9myZcs1vbavr69+/PFHdRzU5pLnCpSMnXnm6N7jCZb3mfigBjccpR5lB6jELcVUIl9OhYRF6M9dh2xX1t+27VexvDn0xeqNmv54OzWoUEJ7jp3v1ZIvMKuiXS6dDAm9bLvOBoVq06/b7VCYv37aosKl8mnRjBUaP3+IajW7RQd2HLmm9wkAAFJOWowfiB0AAEgnNUHMLC+zZs1KsKxjx472dqUkyJQpUzRx4kTNnTtXH3zwgSpXrqzbbrtNjzzyiO6//35lyZIlyX1ERkbqzjvv1B26V94ePgmeK1W1mIpVLKLxi4erxC1FVbB0fg1tPEYul1vngkLldrsVFhKmbP6++nvvEXVtVN1uV6FwHh04GaRv1m62N1Pw7NTZ8wFLs2pJD4Uxtv6xS/f1bRbbjipFdXjPcS2dvcreTNGzoBMhSW4PAABunLQYPxA7AACQTpIgxocffqjZs2fr6NGj2rhxo1auXGnvd+rU6aquxsQVQt29e7dNhpiCqgMHDlRw8KXjdC9n3MLnVKpacRUuV1CL3l2qJTNX6Jf5a+1zT83opzmvfaOY6Bj974U5GrfoOcVEu7R/2yFt3BvbK2PFP7v04RMd5XK7NerTpXrlwXuUM2smHTodrPH/FTSL68o65KOFSbYl5PQ5rVm8QRMXP2ODptf7f6jnZvRRYO5sOrbvpN4c+slVvy8AAHDjpJX4gdgBAIAbx8NtLmOkkHHjxunzzz/XgAEDNHToUJ05c0bbtm2zw2HWrVt32e3MDDIhIYn3iDAFVr///nvdfffdSb62SZKYYTiJXcm5WkcH1FNyFfjw72Rt/33QjGS3AQCAtC7uvG2G0QYEBKR6O4gfAABwRvyQojVB3n//fS1evNgOYTGzxBilS5fWzp07k9zu9ttvv3wDPT2vmAABAAAAAAC4qUmQc+fOqUCBAvZ+XBLEzPbi55ewIvrFTOIEAAAAAAAg3SRB6tSpo2nTpiVYNmPGDNWvX/+a9xUWFqa9e/emYOsAAAAAAICTpWhh1MmTJ6tJkyaaOXOmzp49q3r16tmiqMuWLUtyu/3796tXr17asWOHRowYofLly6tVq1Z2vE+5cuVsTxEz8wwAAAAAAECaSIKULFlSW7Zs0YIFC2wvjiJFithkxpWmtx00aJCqV6+uGjVqqG/fvnrxxRe1fft2O22dKbI6fPjwS6beBQAAAAAASNUpcv39/dWxY8dr2uann36y0+rGxMRowoQJtrBqzpw57XNvvvmmatWqddX78sqZQ16evroeweVilFwFYpK/DwBITDPPa/u/9WKe2bIl+8C6LjOT19Va6pqT7DYANwLxAwAAzpCiSRAzze2kSZP0xx9/XDLl7fLlyy+7nenx4esbm7gw093EJUCM/Pnz2+lvAAAAAAAA0kwSpHv37ra+R/v27a84BOZCJtFx6tQpm/xYuHBhgucOHjxoEyMAAAAAAABpJgmyYsUK7du3TwEBAde03bPPPmun1zVJkItnklm6dKk6dOiQks0EAAAAAAAOlKJJEFMI1QxtuVY9evS4rueS4unpoaHTeip3gew6uv+kJg/6n+55qKGadqojt1v69PXF+m3Jxvj1M2Xx01ftuqpMzly6b95sbTt1Qq1KlVOvKjUVHhOtIT98q8PnQlQ6Ry691KiZvDw89draX7Tq4D51KFdJ/WrU0dFzZxWas55eeXh6/H7zFc2tKT+N1t4tB+3jcd2nycfXW/0nPaTMAf7666d/Neulr67rPQJwtnzF8ujNtS9r76b99vGLnV5XRGiExsx7Sj7+PnLFuDSx11s6uvd4otuXq1FCD78QW2ckZ/7sWrdko6YP+0x5CufUjPUvqX+jF+L/77qccrVLq/cr3WL3USCH1n67Xh+N+Oyq2wCkNWkhfiB2AAAgDSdBNm48Hwj0799f999/v+3ZkS9fvgTrValSRTdT/VbVdWTvCb36+Ax16H+X6reqoVY9G+nxRi/KP5Ovxn3xZIIgJiI8Sr0Wz9Owuo3sY29PTz1StZY6fvWpquTNr0HVb9XukcPVZcgz+vaFMXqvcjm9076LVs3fZ9f/8O/1+vifP1Xuqb8vacvfv2zV2G5vxj9+9sPHNXXgTJ08fPqmHAsAGdfGlZv1YqfX4h+bJOuEXm/p5KFTqtmsijo91UZT+3+Q6LZb1+/W061etfcHTu2h1YvW2/udBt6jzb/tuKrX37puh4Y2HmPvD37vMa3+ap1iomOuug1AWpOS8cOt2XPp7fxFtfnF51Vr4iQ9+d032h8TrZmt2l8xfiB2AADgxvBM7g6qVatmp7c1Px9//HH9+OOPat68uX0cdzPPX3cDPT3VoEEDOyzmWuQvlkc7/4m9Orpz4z5VrlNah3cfl5+/jzJl9Vfw6bMJ1jdXK0+Fh8U/Lh6Yw17NiXK5tGXPbrWOiNHQb75TIV9/PTx9hj4Z95qCQ0OVwz+TXb97pWr6ou0DatThtkvaUrFOGb22ZJh6ju4gL28ve4Xn0Zce0CuLnlHF20pf55EBAKlS/XJ6feUL6jWusz0cUZHRNvlgREfFKCbadcXD5OnlqQq1Suqf1duVr1humcvdx/afvKbDa/ZR/rYy+vvnLdfVBiCtSKn4wSc0TKMGPaOq2bKr4+p1KiNPTR7+gp1h6XR4+BXjB2IHAADSaBLE5XLZqW3Nz8vdzPPXyyRV+vTpo88+++yattu/7bCq3V7e3q/WqIKyBmTW78s36d1VYzRl6XP6+r3Lz1ZjBPj66WxU7NCeh1aukr/LJS+3W54eHvZn6SPHlHfffmX389eS3Tt01+cfqueiuWrfv4Vy5jtfyPXUkTPqWeUpDblrvALzBKhhu1tVsnIRvTfsM73c8x099krX6zouAHDq8Gn1KPOEBjcapex5A9XgvlvjD4pJuHYb2UHzpyy+4oEy/0duXLVNbrdb9w+8W19O/e6aD271xpX190+b7T6upw1AWpFS8YOJHUys4OHlJR+XSx4eHvaxWR4SGZFk/EDsAABAGk6CXCgiIkJRUVEJlpnHZvn1atSokZ115oMPrq0r9W9L/rZXI1+ZP1j+mf105kSI7n7wdvW6baR61x2tHsPvS3L7oIhwZfWJnba3yMlTcsclclyxVzRdHh7K7uurMxHhCo6MkAn7z0VF6a+ftqhI+YLx+zFtiAiNTab88vXvKlWlqA7sOKITh07r9LEg223cXEEFgKvVflArTVw+Rm36tVB4aOz/rz/PXaNS1UrErzNoeh8tnL5Uh3cdveL+GratpZ+/WqcCJfLYx0f3nbzqNpifdh8d62rlnF8TrHMtbQDSipSKH0zsYGIFXRA/mMdmuUmUJBU/EDsAAHDjpOhf32YYzLp16xIsW7t2re6++27dbOZq5Lsj5+iZ+15XyKmzWrVovSLDoxQVEa3wsEg7bt5clbmcvcFnbJEzH09Pueo3kP7+b6zukSNS6dLyzJpVyplTp8PD4pMlppdIudoldWT3+QKAputsnFvql9OeTQd0LihUmQMyyS+zr7x9vW1XWgC4WnMnLbR1OBa/t+z8/y8NK+rgjsP2fpfh7XRkzzGt/GL11Q2FqV1Kf6/aZnupFStfSOPmDlKNOytpwKQHbW+OpNpgftp91Cmrv3/aEv/8tbQBSEtSKn44mC+vPOvWNcXTYp84ckSepUrpaOFCyu7vn2T8QOwAAEA6mR3GFEmtU6dOgmXm8YYNG5LcLjo6WmPGjNEvv/xiC6gOHz48QWHVW265RX/HJSGuUo68AXru3UfsWPQ/f9qiTb/t1C8L1mvSt8/Iy8tTC2asSNBt2/jwnnaqmDuvSmbPqdmb/9KMjX/o83sfUFRUpHbf107FPTzkGjFC3h9+qEh/f43aFPu+Hq5aU3cULSEPeejX15br6L4T8fusVLeseoxqr4iwCB3Zc0IzX5yrQ7uO6sUvB9k/Lma+OO+a3hcAxKncoLx6vNjZzghzZPcxfTTyM+UqkEPdR3XUplVbVe3Oytq8ZptmDJt92YNWrWF5/b06dijMqgXr7c0Y8lYvfTn1e9tb7UrM65haIHH/p15rG4C0JKXih4envKWI3Xvl17mzXJ6e8hw+XBGf/E93Fi6kietWJxk/EDsAAHDjeLgvPpMnQ6FChbRlyxYFBATELwsKClK5cuV0xPSguIynnnpKK1as0IMPPqiVK1dq9erVthBqpUqV7PPZsmVTSEhIkq8dHByswMBANcnZQ96esVdWrtW/L5S57HOZwyPsOF7TjXV/rpya2ai+Qv39LlkvsdlhrsX3Z2cma3sAGVczz9jpbK+XZ7ZsyW6DKeqYHEtdc5LdBmQMcedtEydcGDekVjtuRPxwtbGDQfwAAMDNiR9StCdI48aNNWjQIL399tvy9fW1tUCGDBmiO++8M8ntPv/8c61Zs0YFCxbUE088offee09NmzbV999/b3uGJNXt9GYxQcvbzRundjMAAEA6QewAAEDak6JJkIkTJ6p169bKnTu37RVy8OBB2wtkwYIFSW5nsjgXDn/p3bu3MmfOrGbNmunbb79NySYCAAAAAACHStEkiElk/Pbbb7Y46t69e1WsWDHVrl37ij05ihcvbuuG1KxZM35Z165d7XZ33XVXsmaXAQAAAAAASPHZYfr27WsTF7feeqs6duxof5rH/fv3T3I7Uwtk+fLllyzv0qWLpk6danuVAAAAAAAApJkkyCeffJLo8k8//TTJ7UzdEFMcNTGdO3fWrl27UqR9AAAAAADAuVJkOMw333xjf8bExNj6HxdOOLNz505bvfVmiTl1Wh4ePte1bfnntiT/9UNDk70PICNJ7owmKcErV85k7+O749OV3u37qGiy91F4gleKtAVIa4gfAABwhhRJgjz55JP2Z3h4uAYMGBC/3NPT09YJmTJlSpLbR0VF6fnnn9cvv/xiZ4MZPnx4gkKpt9xyi/7+O3lTzwIAAAAAAGdLkSTI7t277c9OnTrpiy++uObthw0bphUrVtjaICtXrlT16tW1dOlSVapUyT6/Z8+elGgmAAAAAABwsBSdHeZ6EiDG559/rjVr1qhgwYJ64okn9N5776lp06b6/vvvbc+QK80uczlmu6Ez+qpAyXx2iM7EXm/p+P6Tevn7EfZ530y+8vH11uM1n050+7I1SuiRFzrY+znzZdfapRt14tBpNWhdU2HnIvRa3xk6deRMkm3IVyyP3lz7svZu2m8fv9jpdUWERmjMvKfk4+8jV4zLtuvo3uPX9R6B9KZMjZJ6fFIPuV1unT56Ri91m2J/D6/nd+LOB+qr7xu91DHfw/Zxh8Gt1KBdHYWfDdeEntN08vDpBOtnyuKnl+YOUrHyBTSwxSva++8hNWxbS/c92kQR4ZGa2P8j+zve9+UHVKpyEXl6eeqTVxfojx83Ky27+DgYeYrk1kfbpqhfrWe0Z9N+RbujtOeZ9xWx/5iKv/SI/Irl1eGpX+vsH9uUu1Mj5bjnVrvdub936/gnP8jD20u5O9+pLJWL68zyDTo592d558ymM0cD1ar54xr4dEvFxLgUFhapsSPnqv/gFrqtXhl9MuMnfT33d7svHx8v9R3UXIWK5FTouUiNefb6zhHAzUb8AABAxpWiSRAzle3rr79ue3WcOHEiQW2Q9evXX3a7oKCgBMNfevfurcyZM6tZs2b69ttvr7s9paoVl4+fjwY3GqUaTavo3v4t9M7gmRraeIx9vknX21Wg1PnXvdi29bv1dKsJ9v7AKQ/p10V/quszbTS4+Us2QdLlqVZ6c0jixWAvtHHlZr3Y6bX4x+YPvgm93tLJQ6dUs1kVdXqqjab2/+C63yeQnpw4eErPtRiriLBI9RrXWfXb1tav3/x+zb8T5o+U29vX0fH9J+zjHPmy69Z7ampggxEqV7u0uo7soCl930uwTUR4lEZ3fVOPjGlvH3t5e6rdY001tPUEla1eXF2GtNSUIZ9o3tvLdGTvCWUNzKxxXwxI00mQi49DnAeeuVebVm2Nf+wpLxUe1lnHPl4avyxP18bKVKmYvENC9ci8X1T46Gk9/ecOlR3/sMKz+mv/2NnKMraHXTdny9tsosTUBNm/96QGPvaRXd6tV0M1aFReM975URv/3KtMmXzj939vh9pau3qHfv1l2004EkDKIX4AACDjStHZYQYPHmxniLnnnnu0detWPfTQQwoNDdW9996b5HbFixfXhg0bEizr2rWrJk2apLvuussmV67HiQMn4+9nzZ5ZQceDEzzfsENd/TRnzRX3Y64Gl69VSpHhUfbKsbHjr72qVKfMVbWjUv1yen3lC/YPPiMqMtr+sWdER8UoJtp1Te8LSM9M7w+TALnw+389vxONuzTQz3PX2B4lRr5iubV3c2yPq+3rd6ly/fKXbGN6mQSdPBv/uFDJfNq79ZB9zc1rd6pEhdjpuE0CxIiKjJLrv/2nVRcfByN/8bwyOejj+84nRjw9POUdmCXBtqZnh19ktHp+/asGzl6udss3KO+JYM158RNlNbtzuRQdHFvs+fR367R3+Ic6cuJv2wMkjr+/j/btPaFTFxzXOLXrlFLlqkU08c3uanlvjRt0BICUR/wAAEDGlaJJkK+++kqLFi2yhVK9vb3tz/nz59ueIUkxtUCWL19+yfIuXbpo6tSpKlQo9g+TaxV0IsT+YfDB5sl65JXuWvLR+XZkyuqvPEVyad+WA1fcT7WGFfT3qq06vPu4vVpsenJUv6OiTaxcyanDp9WjzBO2N0r2vIFqcF9sl3PDy9tL3UZ20Pwpi6/r/QHpmRmuUaPJLVqz8I9r/p0wRZcbdaynFZ+vjl92aOdRlatVyv5+mp5fWXMk/IM/MVkCMyk0JPz8fr0SDr17aFhbff3epf83pRWJHQfj/mfu1ZyJsbN2XUmdv3cpd9BZebnc8olxyfTj8DlwXK3n/ayIfcfkOheubLeVV4nJfVV4RBftO7RaEZEhqlG7hN7+qLeq1iimwwcSDjuKkydvoLb8c1BPP/mJGt9VWbnzZEuR9w3caMQPAABkXCk6HObcuXO2V4fh7+9vZ4upUKGC/vjj/B85iRkyZMhln+vcubO9XYv2g1qpbutaWr9sox3n/3DFgSpdvYT6vPaQxneZbNep26aWfl0QO279Sm5vW0s/zlmj4FNntfjDlRo3f7B2/b1fB3YcvWIbzGvMnbTQLjNXayvWLadf5q+1jwdN76OF05fq8K7L7wfIKC78nfj2/R/07MdP2CEwMdEx8etc6Xcibh8bVvyjlXNWJxhyF3wyxG778vcjtfOvPTqwNbbXVlLOnglV5mz+8Y9dMef316xzPZtQWTFvndKapI6DqYFkXG2doRzBoXLLJH9i92H+h+zllkJ//kd+xfLJK3sWeWXys8+ZnzkCS+hc2HGtX7dbj/d4T5261tU9bWvo8/8lTMQYZ8+Ga/3vu+1x3fT3ARUumiuFjgBwYxA/AACQ8aVoT5AyZcror7/+ip/W1gxnefvtt5U7d+5r3ldYWJj27t17Xe0wSQdT98N0iT97OraL9tkz55Q1e5aLhsL8elVDYSrULqW/V8WOaV86e5WebvmqVi9cr79+2nLFNix+b1n8slsaVtTBHYft/S7D2+nInmNa+cWlfzgAGVHc78T8Nxbr2U8G6JMX5+jg9tjfh6v9nYjbh39mPzXr3kjjFw9XoTIF9NjrD9nnl8xcoSF3jtYv83/Thh//uWKbDu0+pqJlC8jbx0sVby2l3Ztje4ZVqV9WDVpV19vDPldalNRxKFW1mIpVLGKX1WhWRU++/ajtYXM5pwMyy+O/BIhRW9IyTw+1bHiLHS5jEh8xobFDEt1mONHZAwrIev7/9HNnIxQeFpXovjf9vV+ly8QmZUqVzqsjh5MuJA2kNuIHAAAyvhTtCTJ+/HidPXs2/r4ZzhISEqLp06cnud3+/fvVq1cv7dixQyNGjFD58uXVqlUrBQcHq1y5clq8eHF8D5Nr8ceSjWrarZFe+/F5+fh5650hM+OHwuQtauoHXHkoTNXby+vv1dvir7Q++0EfBebOpmP7T2ra0CsXRa3coLx6vNjZzghzZPcxfTTyM+UqkEPdR3W0RQur3VlZm9ds04xhs6/5/QHpUaNOdVWpXjllzpZJXUd00IJ3luifn7dc0+/E+8/Oir8/be3LtuCxMWz2QGXPE6Cj+45rar/EC6u+8Gl/O/NL4VL5tfjjn/TV9B804euhioyI0oR+H9p1BkzsameAennuQFtMdeQDU5UWXe44xPU2e2pGP8157Zv43jb7x85SxO4jijx4UtnvqqnIQyf09b7jWuvlpZ3RMZro5akJLpe+9vHWvzsOKU+flna70wt+1dn1O+z9ojlvUf3ba9oeIKZeStCZUE0Y+7V6PdZYdRuUtUOKChTKoXemLLW9Q54a0cY+t27NTh05RBIE6QPxAwAAGZeH+8J+1KmkQ4cOKlmypJ3lYPLkyXrxxRdtUiQyMlIDBgyQn5+fZs06H+wnxiRMAgMDdYfulbeHz3W1wysgQMkVE5yw+Oq1Wuqak+w2AGlJM8+Oqd0EeeXKmex9fHc86WRuejiWB+ZWSnR55rBIdfl2rZ0d5kC+HJp9960KvWCWlwuZ2WGSY+nqkcnaHhlH3HnbzBAXkALn3+S2g/gBAABnxA8p2hPEiImJscNY4nqExKlSpcplt/npp580e/Zsu+2ECRP0yCOPKGfO2D9a3nzzTdWqVSulmwkA+I9JeLzfrgHHAwAAABmed0rPDtO7d2+dPHl+alrD9PAwCY7LMT0+fH1jrzqarE5cAsTInz+/zfIAAAAAAACkmcKoZujKSy+9ZGeJcblc8bekEiBxiY5Tp07Z+wsXxs6kEufgwYM2MQIAAAAAAJBmkiBmSlxTyyNTpkzXtN2zzz5rEydG/fr1Ezy3dOlSWzMEAAAAAAAgzQyH6devn6ZOnaonn3zymrbr0aPHdT0HAAAAAACQKkkQUw/k9ttv16uvvqp8+fIleG79+vWJbmPqh+TKleuK+77a9b4O+jhVq8wDSPlZlxb/+1Oytm/e7kFlBB4+ic/YcrWK9dyf7Da4IiKSvQ8gLSJ+AADAGVI0CWKGrZQoUULt27dX5syZr2qbW2+9Ve3atVPPnj1VsWLFS57fsmWLZsyYYYuubt++PSWbCwAAAAAAHCRFkyAbN260BU7jZnq5Ghs2bNBrr72mpk2b2iKq5cuXtz05zPy/W7dutev06dPnsj1JAAAAAAAAbnoSpE6dOtq5c6cqVKhw1dtky5ZNY8aM0ciRI7V27VqbFDl9+rRy5MihatWq2Z4iXl5eKdlMAKnITJk9+K2eKlAsj9yS3hz8Pz06/gH5+vvIFePS6/1m6Oi+2Gm2g2JO6N+w33TnfUHKm8dbn0zLp3mLz2rKe2eUyd9TH76RV0UK+eiJYcf11z8Rio5xa/TQnGp+ZxYdPR6tLo8dldvt1uZ/P1XrFv00+Nk2iolxKSwsUmNHzlX/wS10W70y+mTGT/p67u/2NStXLaJH+zez261bs9M+lxYVr1hYT057WDHRMQo7F65xXaeq36SHdNs91fXJuHn65u2lKfpZJOWOTnXVd2J3dSraV4063Kb7+rdQZFikJvSeruMHYmf+AgAAADJcEqRWrVpq3ry5unXrZqe9vXj63KSYREfdunXtDUDGVapKEfn4+mjoPa+o+h0V1fzB2+0f2ycPn1GNOyupwxMtNO2pWXZdf4/MqpWlub6fv1rDx5/UV9+d0+TpZ7Tyq8JatyFcYyed1vSJeTWoT3aVLOaj02didHfnQzYJMntuiDq2yarHHgpUqVp5tGHjGg18LPYP8m69GqpBo/Ka8c6P2vjnXmXKdL73Wqcu9TRh7Nfav/ekJr39kOZ/8ZvOnU17dTD2bzusQXc+b+93G95O9e+trQ9HfaGNP/+rTFn9UvyzSCqRcvt9tW2yw8vbS+0H3K3BTV5U2Vol1fXZtprcf0aKvF8AAAAgzSVBfvvtN5UqVUq//vrrJUHylZIgAJzh+MHT8fezBmZW0IkQ+0e3ER0dbXtqxPHzPF9byMdH2r4zUhXL+crX10P1b82kp0efkKaeVql9UXIX9ZFf52zy/G/i7/JlfPXPv5H/7Tdcnh7+8fvy9/fRvr0ndOrk2Uvat3fPcWXJ4icvL0+5XG5FRkYrLTI9QOL4ZfbV/q2HdOpI7HG8EZ/F5TS+v55+nr9OHQbcrUKl82nP5oOKjorR5l+369GXulxTewAAAIB0lQT58ccfU3J3ADKg4JNn5Xa59N7asfLx89bg5i/b5aYXQden22jyEx9dss2+A1H64ecwjX02l46f/O+P/3MuxfwbKY+NJyVPycMljXj7tPqPzG2frlXVX8PGn9T/5oToXFiMArMWVo3aJdS7X1NFR8fo8/+tSrR9q3/aqlHjOyoqKlo/fPePoiLPJxvSmhpNKuuR8Z1t0uGLiQtuymdxIU9PDzVsf5vGdJpkkyBZs2dRaEjY+ee9/stIAQAAAGlEikao+/fv15kzsVcRIyIiNGnSJL355pv2iiIAGDWbVFJkeJR63zpCYx98S4+Ou98uf/KNB7Voxgod3nM8wYGKdkfqoSeO6oNJeZU3t5eCz/7XO2FGkLzC3Tb54REtfeSSIk+71OVEbNLitXdO22EyG1cUVe4cZXXw6B9av263Hu/xnn7+cYvuaVsj0Q+kzxPNNPjxmerRaZpKlM6rosVikypp0fof/lHf24br5/lrdc/DjW/4Z3GxJp0b6Ke5v9n6KUbI6XPKnC1T/POmrggAAACQYXuCmKluP/jgA2XPnl3PPPOMfvjhB/n4+NhZXqZOnZqSLwUgHQs5E2p/nj0TqqyBmdR5aCsd2XtCP81fl2A9t9uljaErNWtwTpUt5auoKLe2bItUZKRbv/8epls8zEqS6YM2V9J8L8nDDI35b/ucOWKLKnt7Z5KHx/m6HqbGh7dP4gWXzRCYc2fDZf6uDwuNVJarrK9xs/n4eivqv6E6oUGh8vb1vqGfRWKKViio0lWLq3Hn+ipUOr9aPnynilUoZI+tqQmy++/919UmAAAA4EbxcMddwksBZkYXM0WuqQFSsGBBWxska9asqly5sg4fPnzF7U1TlixZos2bN6tQoUJq2bKlsmTJclWvbabUDQwMVFBQkJ1iF0Da0CL7w5cMoXhq+iPKVTCH/UP+3eGfa8Kip7X5tx32+S1rd+rDF+bZ+4cjd2pL+BrVq2OyHVKfhwJtcmLq+2fkfzxGM/dHq6hbKmdqWpjZpky9j5I+WryqmPYfjFLPJ4/ZpMbGTQX0aK9R6vLgnfZx0JlQW/y0a8+GqtugrDy9PLTu1x16Z8pSVa9VQj0fvcPWw9i/76Ref2mhfe2lq0cqtd3l1zX+vpkFpuOglrHv50SwJj4yXV2H3ac6rWrYeibrvv9L7zz1SYLtPTP5X/dnEccVkXiR2Dd/eUH9G4zSHR3rqG2/5raHyYRH3rlkdpglYQnbBOdKK+fttNIOAABwc87bKZoEyZUrlw4dOmR7fnTq1En//vuvTWyYxoWEhCS5rdnmgQceUO3ate3UuGZozffff6+vvvpKRYsWveJrE8QA6SMJcj0W/5vINLXnXPJoeUDaHhk7sM+MvCjjK/eiwlKWhCP9mrd7MNltSGtJkOtxcRLkelwuCXK1SIIgrZ2300o7AADAzTlvp+hwmEaNGtnkx8mTJ3XffffZZTt27FDevHmT3M68gXvvvVczZ87UbbfdFr+8WbNmGjFihD766CO9+uqrdoiN6WUCACbRYRMeM4Jih8AU9ZF6BV6SAAEAAACAG5IEMfVAJk6caOuAPP3003bZtm3brjg9rimg+tBDD9kESPPmzRUVFRX/3N69e+Xp6amffvrJ9jTp3bt3SjYZQHpmEh5P5IivAQIAAAAANy0JYmqCjBs3LsEyU9fjSsyQlwULYqd3bNKkiTZu3KguXbros88+0x133GGXv/DCC3ryySdJggAAAAAAgNRJgrzzzjt67LHH7P0pU6Zcdr2keoMcOHBARYoUsff/97//6ffff5efn58aN26smjVratSoUapevbqtMQIAAAAAAJAqSZBvvvkmPgkyf/78RNcxdTySSoJkzpxZx48fV548eWyhk4MHD6pkyZI2ORJXUDU0NFT+/skv6gcAAAAAAJwp2UmQxYsXx9//8ccfr2sf9erV07Jly9S5c2db/LRhw4Zq0KCBVq1apWHDhtl1VqxYoVtvvTW5zYWDNPN+IFnbe5Uqluw2uA8eSdb235+dqfTOHR2d7H2Um/F4srYvtXmTMoIlEbNSuwkAkOERPwBAxpaiNUHiREdH254bF0pq+hrTS6RPnz5q27at+vbtqzvvvFP//POPRo8erQoVKigiIsLenzx58o1oLgAAAAAAcIAUnUtyzZo1qlq1qh22Yoqkmlv27Nntzyv1BDG9QFq0aKH9+/fbxEfHjh3tT/PYLG/VqpXtIQIAAAAAAJDqPUHMNLf333+/ndXF1Pm4FmbYS+nSpXXXXXcpb968tlCqqQ1y5MgRDR8+XN26dUvJpgIAAAAAAIdJ0STIsWPH9Pzzz9tCqNejU6dO9rZr1y4dPXrUFko1iREgucrUKKHHX39IbpdLp48G6fU+72rU54Pk4+8jV4xLEx9+R0f3Hr9ku9KVCumxYa3lcrl15uRZvTL0U9VvVln3PdRAERFRmvjMFzpxJEhDXuqoYmXyKTw0UmtX/qsvP/jpkn3lK5pbU34arb1bDtrH47pPU9CJEOUpnFMz/npV/W8frb2bY5/LyK73OJj/VV5u1VxFcgRKbunZhd8rMiZGY5o3UVY/X63Zu19v/rJGY5o3Vuncuew2VQsWUIOp7166Lw8PDX6rpwoUy2N2pdf7zlDnp1rp1uZVNeuVb7TgveU34UgAANI64gcAyHhSNAnSpUsXffXVV7rvvvuStR8zM4y5ASnlxMFTeu7u8YoIi1SvsQ+odvNqmvDw2zp56LRqNquiTkNaaeqADy/Z7uTRIA1/+ANFhEepx6Dmqte0ktr1vF1Du76jsrcUVpe+TTRl1Dy77mvPzdHe7UeTbMffv2zV2G5vJljWaXBLbV6z3VEf9vUchwr58srX20td/veF6hcvqm61qilPliwa/d0POnr2bPx6Y76PTWDkz5ZVr7ZuoaDwcOW+aF+lqhSRj6+Pht7ziqrfUVGtH22sj16Yp79XbZN/Fr8UfrcAgPSK+AEAMp4UrQkyduxYPf3007bGR7t27RLcgNRken+YBIgRHRWt6MhomwCJexwT7Up8uxNnbQLErhftUqHiubV3x1FFR8Vo8/q9KlE2v33O7ZYGvthe42c8ohLlCly2HRXrlNFrS4ap5+gO9nG+Yrltr4Zj+0/KSa7nOBz5b7psI5u/n4LDI1QoMEDPNm2oj7t0UPVCCY97i/Jl9d2/iSdVjh+M/eyNrIGZbU+UU0eDUuCdAQAyEuIHAMh4UjQJYup2+Pn56fbbb7cFUi+8AWlBniK5VKPJLVqzaL197OXtpW4j2mv+m98lvV2B7Kper7Q2/bFHoWcj4pd7esX+Cr336iINeuAtvTX2aw14IfGk36kjZ9SzylMactd4BeYJUP02NXX/4Jb68o1v5STXexxOh4bZZNN3fXro6cYNNWfDPyqXN49e+eEnDf56sYY3uzPB+neVL60lWxNPggSfPGuHRr23dqwefqGDls5enaLvEQCQsRA/AEDGkaLDYVauXKlDhw4lOR0ukFoyZ8ukZ2f204SH31FMdIxdNuid3lo4fZkO77r8MJbMWfz01Kv36/Xn5sjT01OZs54fLmHqiRghZ2KnhD6wK7auiKenh60jcqGoyGgptjOKfvn6d93ZqY4iQiN0dN8JOcn1HofbSxZXeFS0Wkz/SBXz5dVzTRtpz6nTOhISOxQmxuWSl4eHYtxuOxQmxuXWiXMJp+qOU7NJJUWGR6n3rSNUumpRPTrufr388PSUf7MAgHSP+AEAMpYU7QlSsWJFhVzQZR1IK0xS4tn/9dcnY+fp4PbDdlmXYffpyJ5jWjnn1yS3e3riA5o9bZkO7jmhQ/tOqGipfPL28VLFGsW0e+uR+ESJEZgzi3x8vS5JgBiZsvrH37+lfjn9uXyTilUopHHzh6hG48oaMLmH7ZmS0SXnOJj6HkZIRISy+fkpOCLCFkXN5OMtHy9PmwAxWpQvo+/+3ZZkO+ISV2fPhCprYKYUfIcAgIyC+AEAMp4U7Qlian+0bNlSffv2Vf78sbUS4rRp0+aqZpcZP3681q9fr7MXFDo0zDLgejXqWFeV6pa1V3O6Dm+n7z9aoe4j22vT6m2qdmdlbV6zTTOGf3bJdg3vrqKK1YvZJIcpgrrw0zX6auYvmvC/PoqMjNaEpz+365lESbbATLanyHuvLEq0Deb1e4xqr4iwCB3Zc0IzX5yrZZ+uss8NeecRfTnl2/geKhnZ9R6HX3bvVdtbKmpWt07y9fLS+GUr7PJ3O7WVj6eXJq88P6TlrvJlNGDewsu2Yf3yTWpyf129uuhp+fh6693hn6vnqHaqc3c1O8SpQIk8endY7GcLAHAu4gcAyHg83O7/Lp2mgBIlSiT+Ih4edtrbK7nzzjvl5eWl9u3bK3PmzAmee+ihh5LcNjg4WIGBgQoKCmI4Dqxm3g8k60h4lSqW7CPpPhjbU+R6fX92ptK75lmT/t29GruGJa+uUKlXNyW7Dd+d+SDZ+wCQ9s7baaUdSDuIHwAg7UqJ83aK9gTZvXt3srY3vT2OHz8uX1/fFGsTAAAAAABAitcESa7bbrtNO3bsSO1mAAAAAACADChFe4Ik18cff6wOHTqoYcOGl9QUGTBgQKq1CwAAAAAApH9pKgkyadIk/f7774qKikpQE8TUFCEJAgAAAAAAMkwS5O2337Z1QcxUuwAAAAAAAOkmCWJ6dVSvXt3O+HI18uTJo5IlS97IJsFBtr9RK1nbBxYNSnYb8t/vktOliRluhqV2A5DRNPPqlKztvXLlTHYb3GHhydre4yrPzZcTExycrO2j3VHJ2h64UYgfANwoxA9KE/HDDS2M2qZNG506deqq1x85cqR69+6t7du326lvLrwBAAAAAACkek+QnDkTv6Jl5u4tW7asrelxNcmQXr162Z+zZs2y2xhut9vej4mJSYmmAgAAAAAAh0qxJEjRokX13HPPydfXNz550b59e73//vuXTZJcbPfu3SnRHCCep4eHXm96t/JnyaYDwUF6dsUSdalUVe3Kxdadmfr7r/phzy75enppTMPGKh6YQ2cjI/TI/M+1fegMRew7rtITeso3X3btGT9H7shoyctTRQa0tssOvve9wncdlSsiSnnuq6Pst1ey+z3+9W8KWbdd+yJCdYtPfWXyzKJ8RXNrys/Pa++Wg3adcd2mqlqjimrbv7kiw6I0sfd0HT949T2nAKQ9Jmk/dEZfFSiR154HJz78tg7vOproupmy+OmlLweqWPkCGnj3q9r77yENfuNB3drsFs2auEgLZqyw67Xu1Ugd+t6lbX/t1biH373sa1dpUF5dnmkjL29PzXvze93Xr7ld7ufvI29fb/VrMDrJdg9+q6cKFMsjt6Q3B/9Pj45/QL7+PnLFuPR6vxk6uu9k4u8jq79eWTpKxSsV0YC6w7Rn0367vFGnemr3ZEtFhEVqQo83dfzASRWtUFiDpveRp5enPhj5iVb88PU1HV8gLccOj377tVzh4cQPAG5Y7JBR4odM1xk7fDTqM61btl5pIgnyzz//aNSoURo8eLDeeust3X777Xa5SYjUr19fefPmvar9FCtWLP7+iRMnlDt37pRoHhysRcky2hcUpIFLF6tP9dr2cffK1dTis4+UydtHH7fpYAOZh6pU1/I9u7Rsz067nYePj0qMvF+HP/whdkcm8fFka/nkClDInzt1fP6vKvTY3SrYs6k8vL0UExapnc/OtEmQ0B2HFXUiWCXHdlP++/ckaM/fv/yrsV2nxu7S20vtBtytIU1fVNmaJdXlubZ6o/+Mm3+QAKSYUtWKy8fPW4PvGK0aTW/Rvf1a6J0hidfFiQiP0uhu0/TI6Pbxyz4a95X+Xr1d/ln84pf99M16/b58k3qNbHfZ1/Xx81H7AS00ot1rio6K7Tn566I/7c/G99e1gVWS7a5SRD6+Php6zyuqfkdFNX/wdhu4nDx8RjXurKQOT7TQtKdmJf4+wiI1svXLevTV7vHLzP9v7Qe10uCGo1Sudil1HdlBk/tMV69xnTWx1zSdPhqkcd8O0+s/vJhku4D0FDsYxA8AbmTskFHih4jrjB3Gfzs8RZIgKVITxN/fX6+++qpmzpypQYMG6ZFHHtHp06fjh7RcrdDQUPXp08dOj5svXz7787HHHtO5c+dSoplwoKIB2bX5xDF7/5/jR1W7QGHtCTotf29vZfH11enwMPtco6IlVLtgYX3W9n51qVTFFgz0DswSvx9PH2+bADH8ol2qtOuoRk5bpIe/WqNMYZFyhUfKv0hs0i74t622x8jO4f/Tlsh1crvPF0etWLesXls6Qj2f76jCZfJr75YD9j+czWu2q3ilwjf56ABIaScOnL/akTV7FgUdv3xNK3OFJOjk2QTLTh27dP2gEyFyxZjrK5dX8bbSigyL1PNfDNSo2U8oR97A+Oca3ldbP89fl+T2xw+ePt/uwMz2NU0AY0RHRysmxpX0+ziRsN2FyhTQ3s37FR0VrU2rt6pE5aJ2ec4COXRwxxGFhoQp+GSIcuXKlWS7gPQUOxjEDwBuZOyQUeIHVzJih4Bc2ZSmCqPWqFFDv/32m60DUq1aNVsT5FoMGTJE27Zt0w8//KBDhw7Zn6ZI6tChQ1OymXCQHadPql7h2F+gBoWLKcDPTyv37dHSzj31Tcdu+mhjbCaxQNZsWn/kkLp+/YXuLVNB+bNkTXR/fiFhCnx1nt7bekD3LvtL/T9Zobw939D2Ae8qa7USdp3oM+dsz5FS47rLy8NLR2L22eWnjpxRz8pDNaTZWAXmCVDdVjUUGhwbSBleXje0TjGAm8Cc/N0utz7YNEmPvNxNS2bGdkm90XLkDVC+Yrk1utNkLf5whboPaxvf3TR3oZzat/VQktsHnzwrt8ul99aO1cMvdNDS2avjr8p0fbqNvn5n2TW1J2v2zAn+fzNdWI0LL46cCzp31cNlgfQcOxjEDwDSWuyQ1uKHq4sdQhWQM40lQQwzHe7TTz+tH3/80Q6NCQw8n026km+++UZz585V3bp1bU8Q8/OLL77Q118zZhjX54c9OxUVE6NP7+2kTD4+OhkWaq/W3DnrAzWZNUNP1YkduhUSGaHVB/Yqxu3WH0cOqUT2HInuz2PULD0ZGaWybsknxiUvl1vzwyP1QosaOvblavsfmFcWf2WtUtyun9Mzv865Y5OBUZHRigiNsPd/+WqdSlUtrswBmeL3ndSVVgDpQ63mVW0Xz4crDdILHV9Tn9cevCmvezYoVJt+3W57lv21couKli9ol9e5p7rWLN5wxe1rNqmkyPAo9b51hMY++JYeHXe/Xf7kGw9q0YwVOrzn+CXbmC6rE5ePsT8vac/pcwn+fzNXfAwTKF14tetaZpAD0mvsYBA/AEhrsUNqxA/t+t2V7Ngh+FSIkuuGXXouWbKkHnroIfn5nR+XdCWmEIynZ8ImmcdmOXA9zDfnxVUr1PnrL3QmPFzf7dquiOhoRcTEKCw6Sr5eXjK5xd8PH1TF3LFj3irkzqMDIZd2KTv6+c8yqY0OF3xHTUrD5eGh4qdC5JXJVx6eHspcoYjCd8cWMwpxnVImj6zxGdU4t9Qvr9++/VNFyxeSt4+XKtYpo93/xBYEApC+mZO4/XnmnD1Z3wxb/9gVH7iUqlosPuiI7cq69qr2EXIm1P48eyZUWQMzqfPQVjqy94R+ukxX2LmTFmpo4zH258VMt9ViFQrL28dbleqV066/98b3iCtUOr8yZ8ukbDmz6eTJxIutAhkldjCIHwCkxdghNeKHedOWJDN2yGqHxKSJwqhJiYqKUvPmzbV8+fIrrtuqVSt16NBBL7/8si2SumfPHg0fPlytW7e+0c1EBpUnc2ZNvau1ol0urTqw1wYsi3du0/z2XeTp4an//b3BBjvvrF+riU3utld3Vu7brf3BQTr1xqcK231UEQdPKqB2GR397Gf9kTtATWNcqifpJUldzDi+GJf2b9itvL1jKykH1CqtkHXbtHPYx8rqkm7xrW+XV6pXVj1Gd1BEaKSO7DmumS98qaiIaE1YMlxR4VGa8Mj0VD5aAJLrjyV/qWm3hnpt+Rhb5OydoR8nuf4Ls/urVOXCKlw6nxbP/Nn+rNO8iu0CWqB4Hr07ao4ata2lNg/foYIl8+qlL5/UsI5TLrk4EHLqnL1iM/G75+RyufV63w9s4jVP4Zy2avyVrF++SU3ur6tXFz0tH19vvTv8c01Y9LQ2/7ZD1RqW15a1O/XhC/Muu/24hc/Zwm6FyxXUoneX2q68895YpNdWPK/I8Ei9+tCbdr0Zwz/V0Bn97PubMSrxQqtAeo4djN3PEz8AuHGxQ0aJH8ZdR+wwc/TnSgke7hvczSIiIsIWOI2Jia02m5SzZ89qwIAB+vTTT+12ZnaZLl266I033lC2bEmP/QkODrZDb0wdkoCA2AKWcLbi0yYma/vAopfWtDFFUD956kOVOHDC9gDxdLu1u3BudZvQU2GZYqeHvtDFs8Ncq+9D/5es7QHcGM28OiVre69cya+F4Q4LT9b2poBjcsQEJ1247Uqi3VFaoa9T/bxN/ICLET8AuFGIH5Qm4ocU6QnSrt3lp91xXTCG50qyZs2qGTNm6IMPPtDx48eVJ0+ea55hBriRTKLDJDw6L1qnQkfP6GC+7Pq0Ze1EEyAAAADEDwCQtqRIEmTx4sV69NFHE53qzgyHWbBgwVXvKyQkRIsWLdKBAwdUpEgR3X333fTsQJpiEh4zOsQOcQEAACB+AACHJUFuueUWNW3aVG3atLnkufDwcI0fP/6q9rNhwwZbPyRHjhwqUaKErQlihsd89913ql69eko0FQAAAAAAOFSKzA7To0ePyw578fHx0ejRo69qPybhMWzYMP3777/69ttvtWXLFo0YMcIuBwAAAAAASPWeIP369bvsc15eXledBPnnn3/0448/JljWt29fjRo1KtltBAAAAAAAznbDp8i9Fvnz59eaNWtUv/75egtr1661y4Fr5ROcvI5O+bsdTPZBd0VEJHsfANIer8DkzWby78gyyW5D1n3J+z9u4ZOvJmv7PpXuTtb2nu5IKSRZuwBuCOIHADcK8YPSRPyQppIgZiiMKYTavXt3FS9e3NYEmTVrlqZOnZraTQMAAAAAAOlcitQESSndunWzM8OYGWXMsBjz85tvvrFJEQAAAAAAgAzTE8S4/fbb7Q0AAAAAACDDJkFMEVXT6+P999+Xt/f5pgUEBCg4ODhV24b0yUPSy62aq0j2QMktDf92qV5s0dQ+5+/jLR9PL9374SeqU6yIhjRqoChXjCb/tFpr9x1IdH9VGpRTl6db2+/qvGnfK0+hnGrauZ7cbmn2hAX67bu/kmxPpqz+emXJSBWvVEQD6g3Xkd3HNGbeUPn4+cgV49LEh9/W0b3Hb8ixAHBjeHh4aPCbPVWgeG77f8Hr/T9UVGS0+k/oqszZMumvX/7VrFcXXLKdp4eHXm92t/JnyaoDIUEatnyZPr63vX3O39tbPl5eavnZ/2JfQ9KSrj30v7836OONG+yyykXyaUjL2IsGubNl0c//7lHFwnnldrvttmO+XKYdR0+qRolCGtrqdrncbq3auldvL12jmMhwtW19Utu3RWve1zlVrryPZn50TvO+DJeHh9R/QBY1beavjz86p3enn9MtVXz09vQc9rXmzgnTZ5+Gavu5hcrulU/l/Gvb5eVqlNDDL3S093Pmz651SzaqTLVicrnc8vH11uQnZ2rvluTXWgJuNGIHADdDeosf3ly0Qnu/eEeV3jp63bFDdLR0OnxdfOyQWvFDmkqC+Pn56dixY2ratKnmz5+vHDliD5r5QIDrUSFfXvl6eanLJ1+ofvGi6ly9irrNnmOfa1OpgormCLT3TQKk1+fzFO2K0fud2qnrrC8u2ZePn7fa92+uEe0nKToqxi5797exeqzeKPln9tW4eYOvmASJCIvUyDYv69FXY4d4xUTHaEKvt3Ty0GnVbFZFnYa20dQnPuDDBtKRUrcUsf8/DG35qqrfUVGtezdWzrwBmjr0E508fOay27UoVUb7gs5o4JLF6lOjtu4qVVq9PvufHvpplW6vWVuuMqWVOSJCoX5+alO2vA6FJLwY8M/+o+r5zpf2/vMdmmr5ph16fdHPina5VKtkIT3YsIZGzVmqno1qavhn32v38dP6uG8nffLznwp2xeiDj3LopbHn9/nJx6H6dkluhZ+MUc82p3T/DxF6IKeH7piRXS9NPhe/Xpu2/mrfMZMtbLbu3LcKd52Vv2dWbV2/W0+3ii22OnBqD61etF7vj5pj/5+7pX5Ztet3lyb1//AGfAJAyiJ2AHAzpLf44X9Zs6pou0dU+dj4S2KHsDC3Hup8Su23Ravb9mi1aumvEbtj/166MHYwahQ/ER87GKkRP6SpmiCm98fChQtVqVIl1alTRzt27IjPkgHX40jI+dLB2fz9dCo0LP7x3eXL6Lst2+x9T08PhUREKCwq2mZXc2Tyv2RfFW8rrcjwKD3/+ZMa9Ul/5cgboEO7jsovk6/t4RFy6vwfCZdjensEnTjfJpPtNQkQwyRWzC87gPTl+H+/w0bWwEw6FxSqfEVzq/eLnfTyV0NU4dZSiW5XNCBQm0/E9vz65/hR1c2XX/Nfm6KhC79Vneo1VHfcS/Zx1shItSxTTgu3x/5/dTEvTw9VKVZAf+w+aAMYI4ufn7YdPmHv7zx6Sln9/eTt6akYl1sR0dHy8PRSrlwJQ4BixbwVcTJGWTqeVr5DLmX9PExlpoUqf58geUSfX8/HJ/ac7HK75OPhKx+PhP9fenp5qkKtkvpn9fb4/9PMFa09mxLvYQekNcQOAG6G9BY/RLrc8s4cm7i4MHYID3cr9HiM8u+IUfZXz6rE1+HK8W6o/FdHyuOcK0HsEB3tTjR2uNnxQ5rqCWJ4enpq2rRpmjx5sp0qd86c2Kv2wPU4HRpmu5d992gP2yPkgf99Zpdn8fVRgYBs2nHylH0cFRNjH0dGx6hsnlzK5n/pL2aOPIHKVyy3Bt81XtUaVVT35+7V7z/8o/d+G2t/aSf2vf4eHF7eXuo2or1ef3Q6HzSQzgSfPCu3y6331rxor+gMuecVdXyihcb1fMeexMfMekJPNht3yXY7Tp9Sw6LF9d3O7WpQpJiqBYWo9NFj8sqSRSpcWNq8WaU9PPSyp68Wbd9qh+8l5rbSRfT7rgP2/7ocWTJpSo82KpA9m5746Bv7vLnCM+nBVvb/uYXr/7X/zyWm0R1+uuvOk3KHuPWRuQDxX+LDZ0+MvH0Trjv9nXNadXaucnoXkJdHwlCiWqMK2rhqm+3FGZgrm0bP7q+8hXNpTJcp13mEgfQTO5wOC0+wL2IHABk5fmhkYofGJ2Jjh1C3PMwADlfsMBzPs24FfBSqoH5Z42OHWf8LlY9HyUtih5sdP6SpniAXDnsZOHCgPvjgA913330KCzt/9R64FreXLK7w6Gi1ePcj9Z+3QM81aWSXNylTSj9s3xW/3rhlK/RKy+Ya07yxth4/oZPnLu3VcTYoVJt+3W57bPz10xaVrVlS9zzUSD1rPKtHag9Tz1GxY/Gux6Dpj2rhu0t1eNdRPmAgnanZpJIiwyPVu85IjX3obT069n4d2HlUJw6d1uljwYqJibGJ0ov9sHunDSw+va+jMnn7yPPQYblMz8c2baRvYgMQl5eXEXu39wABAABJREFUqt9WRwu2b73s699VpayW/LXd3j99Lkzdp32ugR8v0JN317fLnmrdSA+99YXueeVDlS2QWyXz5rxkHyEhLn06O1QbWvppi5c0zJyT4570lDxDEw5L7fNYFjXI2l6R7nCdiT6W4LmGbWvp56/W2ftBJ0M0uPlLerH7tGT9HwncTMQOAG6G9B4/hPwXO/z4Ux79fo+fhrsviB0MD8l7f0yC2OHHn3InGjvc7PghTSVBZs6cmeBxq1attHz5co0YMSLV2oT0Lyg89qqMGe4S8F8Pjxbly+rbf893Dfv78FE9+OmXGvXdMh0NOatzkVGX7GfrH7tUtHxBe79UlaI6sue4IiOiFBURrfDQSFu453qGbnUZ1s4WSF35xa/JeJcAUlPImdD4ZGmWgNguraYLp19mX3n7eNuhcBczgcKLv6xQ5/lzdCY8TH/89ac8zcWAjh2l/3pBeubLJ888efVh6/v0SPWa6n5LNVXOkzdBV9aqxQro990H7P24/4LOhkcq7L//x0xhsZDwCHul51xEpLL6+ybSC9PU5fKQVzEvZXZJERcmQVySK/P5/9siImKf8fDwlJe8E1zNsV1Za5fS36u22ftx/yeeCw5TeKjZK5A+EDsAuBnSc/zg+V/s4Osn+Rb3Shg7/NfQ6CJeCWIHLy+PS2KH1Igf0tRwmHbt2l2yrGrVqvYGXI9fdu9V28oVNatrJ9uldfwPK2x31oKmO+uJk/HrPVqntr3yExYVpReWLE90XyGnz2nN4g2auPgZ+5+CqeDcoHUNTV423P6yLnh/+VUV8R238FmVqlpchcsW1JqFf6j7qA7atGqrqt1ZWZvXbNOM4Z/yYQPpyPrlm9SkU129uuAp25313RGxhZVf+OwJefl46eOXvkp0uzyZM2tq81aKdru0av8+jc+TQ7eWLKEyRYsq+t9/bX2iHTHRuu/rOba4WYfylZTZ10f/HD9/9eTWUkX0x66DNkDJlS2zXulyj/1/yFRyHzc/9v+yt5et0dsP36cYl0t7jp/Wxn1H7PKeD57S5k3R2rUrRl26ZtLd9/irycIweflKfSMlDy/p0xjpTT9p2wmXunU+pY9n5dD0t89p9aoIbT23SDm9Ciqb1/krQ9Ualtffq2O7subMG6hn3+8jt8tl2zNtyCc3+JMAUgaxA4CbIT3GD3vnvqvj5yITxA7t7j0lV5RbffJ6yuOES+YvmWkuabuX1HplhD5+PEt87BATI2X2rJQgdkiN+MHDnUGmXjFT6AYGBiooKMhOqQuUeen1ZB2Eki//k+yD6Dp7NlnbL425dJYaAKmvRc5HkrX9v89XSHS5qeZuqrsXOXlK+3Pl1MyG9W0Ak5is+5LXmXPhk7GV2C9mipiZMbymC6u5ghPcI7PcWS59LTM7THJEuyO1PGRWqp+3iR9wMeIHADcK8YPSRPyQpnqCAADgZCbh8XazxqnaBpPwiCtiBgAA0j7ih3RcEwQAAAAAAOBGIQkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEZgdBgCAa9TMs2OyjplnlizJPuaeAdmStb3r9JlkbZ/cyeWi3VH6MeILZocBADgG8YPSRPxATxAAAAAAAOAIJEEAAAAAAIAjeKd2AwAAyAjufKC++r7RSx3zPSz/zH4aM+8p+fj7yBXj0sReb+no3uNJbl+lQXl1eaaNvLw9Ne/N79W6dxP5/rf9a49/oKP7TlyyTaYsfhr/WX8VK1dAg1q/pr1bD+vVuU/K7XLL29dLU57+zC4bPKmbipXNr/DQSK39YZPmvvNDgv3kK5pbU35+Xnu3HLSPJ/aeroHTHj7/+n3eS/T1L1S8YmE9+WYvxUTHKOxshMZ1n6qWjzRWg7a1FX42QhMena5Th5M3BAcAgIwmOfFDasYO6Tl+oCYIAADJHNPr4eGhkV8MVv4SedW31jPy8fVWQO4AnTx0SjWbVVG9e2trav8PLlsTxMfPRyP+108vdp2q6KiY2O1zZdXJw2dUo3El1W1ZQ9OG/O+SmiCeXp7KFphZD49sa4MTE7SYQCgm2qVb6pRWkw63avLQ2TaQiXs+sZogJojp/VJnje06NbY9tv3ZdPLQadVoUll1W9XUtEEzkxzT6+XtZQMYo9uw+3R49zE1f7Chnr77JZWrVVJ3dW+oqU9+FL8+NUEAAE6TkvHD9cQOhneOwOuOHTJK/MBwGAAAkqlxlwb6ee4aexXFiIqMtgGMPVlHxdjAIikVbyutyLBIPf/FQI2a/YSyZs9igxgjxm4fGxxczFxlCTp1NsGyuNfKnM1fe/49FB9wPDmhs8Z92k8lKhZKvA11y+q1pSPU8/mO/7X/9BVfP+Hrnl/HL7OvDu44oj3/XRna/uceVa5X7or7AADASZITP6SF2CG9xg8kQQAASM6J1NNTjTrW04rPV1/ynLm60W1kB82fsjjJfeTIG6B8xXJrdKfJWvzhCnUf1jZ++67P3quv31l61e0JzJlVE78apH7jO+nvNTvssvdfnK/BbV7X2yO+1IBX7r9km1NHzqhn5aEa0mysAvMEqP69tc6//nNt9fVbS67qtWs0rqy3fh2rqo0q6sie4ypXs6S9KmSWZ82R/BlxAADIKJIbP6R27JCe4weSIAAAXIf2g1pp4vIx6jKinVbOWZ3olG+DpvfRwulLdXjX0ST3dTYoVJt+3W6v+vy1couKli9olw+c2kOLPvhRh3cnXU/kQubqztC2kzS29wfq8WxruyzkdKj9eWBnbDs8PT0SbGOu3ESERtj7v3y1TqWqFI19/Wm9tOj95bZr6tVYv/wf9a07Qj/PX6vmDzXSwvd+0EsLn1Ht5lV1YFvC7rQAADhRSsUPqR07pOf4gSQIAADXYe6khRraeIwtYtaseyONXzxchcoU0GOvP2Sf7zK8nY7sOaaVX1x6hediW//YFR+8lKpaTIf3HFfnp1rbqyEr56296jaZGiFmfLFxLiTMFjMzMmf1tz8Dc2W1V1Zc/3W7jZPpv+eNW+qX16GdR9X5mXtjX3/ub1f12ma/cUKDwhR+LlxLP/lZQ+8ap1Vf/64NKzZd9fsAACCjSqn4IbVjh/QcPzA7DAAAyfD+s7Pi709b+7LeGTxTuQrkUPdRHbVp1VZVu7OyNq/ZphnDZl92HyGnzmnN4g2a+N1zNsj46PkvNeHbZ7VpzQ7bNXTL2h36cMyXiW77wsePqWSlwipcKq/WLvtHNRqWl8vttuOLpw2bY9d5auqDypY9sw103nvhq0v2UaleWfUY3UERoZE2cDFXYD7aNNFeYbKv/9sOfTj6iySPgymA1nFQS9v+oBMhtkL8sI/7KTB3gK0M/+bA80XNAABwuuTGD6kdO6Tn+IHZYQAASGZ192t18eww17WPgGzJ2v7C6u7XI7Huu9eC2WEAAE5D/KA0ET8wHAYAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIEAAAAAAA4AlPkAkhS82w9knWEjnWtkuwjnG/+jmRt/93Rt5LdBuBCS12x08fh+gUHByswMOlp8wAAyEiIH9JG/EBPEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5ATRAA16xKg/Lq8kwbeXl7at6b38vXz0dt+92lyLBITezzvo4fPHXJNjXLFlbve+rI29NTn/zwh1b8tVP5c2TT1y/0VJeXZmnnoZPq1KiqHrqrljbvPaqn3l2YYPtMWfz00pcDVKxcAQ28Z4L2/ntYgyd3163NKmvWa4u1YMZKu16/lx9QsbL57f1yNYqra7VhfMIAAAAALJIgAK6Jj5+P2g9ooRHtXlN0VIy8vL30+pJhGtJ8vMrWLGGTI28M+CjBNr7eXuretKb6T52n6BhX/PIezWtrw85D8Y+Xrt+m1Zv26Ml2t1/yuhHhURrd7W09Muq++GUfjf9af/+6Xf5Z/OKXTXv2M/szd8EcGjr1QZ09E8onDAAAAMAiCQLgmlS8rbTt8fH8FwMVERapL9/4Vnv/PWgTIpvX7FDvcQ9csk3VUgUVERWtN/q2VXhUtMbPXiY/H2+5JR05HRK/3umQMPn7+iT6uq4Yl4JOnk2w7NSx4Mu28/bW1fXLgj/5dAEAAADEoyYIgGuSI2+A8hXLrdGdJmvxhyvU7bm2Cg0Oj3/ey/PS/1ZyZcusQrkC9eRbX2nezxv1WKu66tm8tj5e+vsNO/r176mmVYs23LD9AwAAAEh/SIIAuCZng0K16dfttufHXyu3qFTVosoc4B//fIzr/HCXOCFhEfpz50E7FGbt1v1qULmkXX745OV7ciRH7gLZFRPj0unjN2b/AAAAANInkiAArsnWP3apaPmC9n6pqsW0/odNKlq+kLx9vFSxTmnt/mf/Jdv8s+eISubPZe+XL5JXWTP5qmSBXHrziXaqU6GYhndpagumppQGdijM+hTbHwAAAICMgZogAK5JyKlzWrN4gyZ+95xcLrde7/uBytUsqQnfPaeo8ChNePS9S7YJOheulRt36oMhneRyu/XAuE908ESQfe75h5rbYTHRLpea1yqn+++opqJ5s+udJ9vr8Slz5TaFQ/7zwqy+KlW5sAqXzqfFH/9if9a56xZ5enmqQPHcenfUXLteg5bVNe6R9/lkAQAAACTg4XZf+CdG+hUcHKzAwEAFBQUpICAgtZsDZBjNs/VI1vbHulZJdhvyzd+RrO2/O/pWstsAIGOet9NKOwAAwM05bzMcBgAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCU+QCSJKHr2+yjpBP2+PJPsIx7yZ/HwAAAABATxAAAAAAAOAIJEEAAAAAAIAjMBwGwFXz9PTQ0Ld6KXeB7Dq6/6QmD/yf6reqrvsea6KI8ChN7PuhThw6Hb9+tDtSmwfOVNjeE6ow6UH55Q/UjhfmyRUVLQ9PT5UYfI/88mXXnje/V/i+E3abs1sPq9on/XRmzQ4d//4vuaNdyu3OqjIeVS5oh6eentlfuQvl1NE9x/X6o+8oJjpG9/ZroabdG8ntdmv2uLlas/APPl0AAAAA8egJAuCq1W9VQ0f2HtfT976mvVsP2wRIu77N9FTrifp4/NfqMrRlgvU95a0yYzoqR4Ny9nFs4qOlKkzopgKd6urIl2vt8uL9m6v8q11V4qnWylqhoLyzZVLOOyuqwsRuqjj5QQXrtMLdofH7bdDuVh3efVRDG4/R3i371aDdbXZ568eb68n6w/XsXS+q83Pt+GQBAAAAJEASBMBVy188t3b+c8De37lxn+7p0VB7/z2k6KgYbV67UyUqFkr4H4yHp3yyZz7/2Ndbvrmz2fse3p7ydrv14Be/6tkp39mfZ3/cpJwNyseu6+1lf7pjXPKWj3x0vkBrgZL5tHPDHnt/+/rduuX2Cvb+oR1H5JfJV5myZVLwyRA+WQAAAAAJMBwGwFXbv+2IajauqFUL1qtao9hkRWhIWPzznl5Xl1d1RcfoyCc/a96pc2p05IxcHh7ydLs108dL3m89rJj/1jv85W86vmi9cimHvDzO/3e1b8tB1WpeVb/M+001mlZRlsDYRMu67//U+5smycvLUxN6TuOTBQAAAJAAPUEAXLXfvt+oqMgYvfLVEPln9tPZM6HKnC1T/POuGNdV7WfvlO90X65sNgHi5XLLJ8alwy63skREq+sv/8avV6DDbbrl/T6KVISC3CfVflArTVw+RgVL51dUZLQm/DBa/ln8dProGduOlr2bqUfZAepVYaB6jevCJwsAAAAgAXqCALhqpuDouyO+sPe7Pd1aP331ux55voO8fbxUtnpx7d508Ir7OPTpKvnmC1Trk2dtDxAvue3yLyW18/BQwSNB9rErMtoOn/Hw8pSXvGX+nTtpob1dqPvojlq/7G+5XG5FhkcqKiLKFkn18fORh4eHbTMAAAAAkAQBcE1y5A3Qc+/1VkyMS3+u3KJNa3boq3d+0IQFQxUZHq0JfWdcss22kV8odNcxhR84pey3ldahWauUtWIhPXM8WL/FuPTKf+vNlfSZ3JqfP9A+PvLlbwresEfuGLfyKJuyeWQ/34582TX804E22bH+h7+1aVVs75Gf5q7RlNXj7LCcb976jgQIAAAAgAQ83BnkMmlwcLACAwMVFBSkgICA1G4OkGG0yPVosrY/NStXosszhUVqxqCPVXz/yfiaIHuK5FKvSQ8qLNP5IqhG4D07ktWGpa45ydoeQMY9b6eVdgAAgJtz3mY4DIBUYRIdJuHRccEfdgjMofyBmtO65iUJEAAAAABIKSRBAKQak/D4uFNdPgEAAAAANwWzwwAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHCEDFcT5N7AB+Xt4XNd2zKDBHCpmDNnknVYAu85zWEFkOYRPwAA4Az0BAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIGToJUqZGSb2+8gW99uPzGvHZIHl5e9nl9/ZroalrXtKUX8erTquaqd1MIF3JlNVfU1aP0zdBH6t4pSLxy/MUyaVFobMSLLvs9r+O1zfB/0uwbu5COfXCV89o4vIx6jaqw1W15c4H6mvO0Q/sff/Mfnr5uxF6bcXzmvDDaOUrlue63yMAZyN+AAAg48pwhVEvdOLgKT3XYqwiwiLVa1xn1W9bWz99uUatH2+uR6sOsX80vfTdCK1Z+EdqNxVIN8zv08g2L+vRV7snWP7A0221adXWq9u+9aXbm8dv9H1PJw+duqp2eHh46Pb2dXR8/wn7OCY6RhN6vWW3r9msijo91UZT+8cmSADgWhA/AACQcWXoniCnj56xf3AZ0VExiol22fuHdhyRXyZfZcqWScEnQ1K5lUD64opxKehEwt+b/MXzyO12xyckrrx9cIJlppdWvuJ51Wfig3p12WhVrFv2ivtp3KWBfp67Rm6X2z6OioyOT6Bc+PsOANeK+AEAgIwrQydB4uQpkls1mtwS3+Nj3fd/6v1NkzRt7Uv6auri1G4ekO7d/3RbzXltwXVvH5g7m0pUKap3n/pYL3V9Q49P6pnk+p6enmrUsZ5WfL76kudMQqXbyA6aP4XfbQDJQ/wAAEDGkyGHw7Qf1Ep1W9fSrwt+17fv/6BnP37CdpM33eUzZ8uklr2bqUfZAfLx9ba1A/5YujG1mwykWwVK5rM/j+49ftW/l3MnLUzw3NkzoTq47bDtgm6Y31VPL0/baySxfWxY8Y9Wzllte59cbND0Plo4fakO7zqaAu8OgJMQPwAAkPFlyCSI+QPL3MzV4jHzn9InL87Rwe2H7XMul1uR4ZGKioiyf2j5+PnY2gKJ/TEF4MpKVS2mYhULa/ziYSpRuagKlsqvoU2et79fif1eJsb8Tp49c06ZAzLLZX4vfb0vSYBcuI9HXu6qZt0bqUnXhipUpoAee/0hvTN4proMb6cje45p5ReX9hABgCshfgAAIOPLkEmQOI061VWleuVs74+uIzpowTtL7B9HP81dY2e3MFeav3nrOxIgwDUat/BZlapaXIXLFtSi95Zq8B2j7fKnZvS1w2IuToBcuv1zKlWtuAqXK6hF7y7Vkpkr9OGITzV2wbPy9vHSR6M+S3L795+dFX9/2tqXbQIkV4Ec6j6qoy3OWu3Oytq8ZptmDJvNZwvgmhE/AACQcXm4M0gXiODgYAUGBuoO3StvD5/r2sdS15wUbxeQ3jXz6pS8HaSB/2L43QbS7nk7KChIAQEBqd4O4gcAAJwRPziiMCoAAAAAAABJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADhChpsi18PbWx4eGe5tAalmacwXHH0AGR7xAwAAzkBPEAAAAAAA4AgkQQAAAAAAgCNk6CRImeol9Nry0Zq4bJSGz35SXt5ednmeIrm0MORjFa9UOLWbCAAA0hBiBwAAMrYMnQQ5ceiUhrV8SUObvqBDO4+o3r217PL7h7bR5tXbUrt5AAAgjSF2AAAgY8vQFURPHw2Kvx8dFSNXdIzyF88jt9utY/tPpGrbAABA2kPsAABAxpahe4LEMcNfajSurDWL/lSnoW305aSFqd0kAACQhhE7AACQMWX4JEjmbJn0zIf9NLH3O8pbNJdddnQvvUAAAACxAwAATpOhkyCenh569uN++mTcXB3cfkQlqxRTsYqFNW7Bs6rR5BYNePPh+GKpAAAAxA4AAGRsGbomSMOOdVWxTlllyppJXYe108J3l2pI4+ftc0Pff8wOi4mJjkntZgIAgDSC2AEAgIzNw22qhGYAwcHBCgwM1J3e7eXt4XNd+1gS+WmKtwsAAFz+vB0UFKSAgIBUO0TEDwAAOCt+yNDDYQAAAAAAAOKQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjZLgpct0xMXJ7kNsBAADEDwAAICGyBQAAAAAAwBFIggAAAAAAAEcgCQIAAAAAABwhw9UEuVCmrP56ZclIFa9URAPqDdeR3cc0Zt5Q+fj5yBXj0sSH39bRvcdTu5kAACANIX4AACDjytA9QSLCIjWyzcv6ee4a+zgmOkYTer2lIXeO0WevfKVOQ9ukdhMBAEAaQ/wAAEDGlaGTIKa3R9CJkPjHUZHROnnotL0fHRVjkyIAAADEDwAAOEOGToJcjpe3l7qNaK/5U79N7aYAAIB0gvgBAID0z5FJkEHTH9XCd5fq8K6jqd0UAACQThA/AACQ/jkuCdJlWDtbIHXlF7+mdlMAAEA6QfwAAEDGkKFnhzHGLXxWpaoWV+GyBbVm4R/qPqqDNq3aqmp3VtbmNds0Y/inqd1EAACQxhA/AACQMXm43W63MoDg4GAFBgbqDo+28vbwua59LI35IsXbBQAALn/eDgoKUkBAQKodIuIHAACcFT84bjgMAAAAAABwJpIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcIQMN0WuZ+ZM8vTwva5t7/LtnOzXXxLJlLsAAKQ3xA8AADgDPUEAAAAAAIAjkAQBAAAAAACOkOGGw1ysSoPy6vJMG3l5e2rem9+rXqsaurVFVc166Wt98+4PSW5bpnoJPfbag3K73Dp9LEgvP/imYqJjlKdILn24eZL61xmmPZsO3LT3AgAA0nbsYBA/AACQdmXoJIiPn4/aD2ihEe1eU3RUjF229fdd2vjLVmXK4nfF7U8cOqVhLV9SRFiker54v+rdW0s/z/1N9w9to82rt92EdwAAANJT7GAQPwAAkHZl6CRIxdtKKzIsUs9/MdAmMqYO/FinjgZd9fanL1jXBEKu6BjlL55Hbrdbx/afuEGtBgAA6TV2MIgfAABIuzJ0TZAceQOUr1huje40WYs/XKHuw9pe137M8JcajStrzaI/1WloG305aWGKtxUAAGSc2MEgfgAAIO3J0EmQs0Gh2vTrdtuL46+VW1S0fMFr3kfmbJn0zIf9NLH3O8pbNJdddnQvvUAAAMiIUiJ2MIgfAABImzJ0EmTrH7vig5dSVYvp8J7j17S9p6eHnv24nz4ZN1cHtx9RySrFVKxiYY1b8KxqNLlFA958WF7eXjeo9QAAIL3FDgbxAwAAaVeGrgkScuqc1izeoInfPSeXy63X+36gnmM6qO491eXp5akCJfJq+nOfXnb7hh3rqmKdssqUNZO6Dmunhe8u1ZDGz9vnhr7/mB0WY2aLAQAAGUNyYweD+AEAgLTLw22qfGYAwcHBCgwMVOMsneXt4Xtd+3BHRCS7HUsikw6MAADA+fN2UFCQAgICUu2QED8AAOCs+CFDD4cBAAAAAACIQxIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjpDhpsjdMaKSPP39r2vbMs+sT/H2AACAtI/4AQAAZ6AnCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEfIcDVBPD08NKnFPcqfNasOBAfpuWVLtaR7Dx09d9Y+P23tb/pl315730PS99176JONG/TxXxsu2VfxioX15LSHFRMdo7Bz4RrXdapuu7u67nuihSLDIjXhkXd0/MCpm/4eAQBAyiJ+AADAGTJcEqRF2XLaH3RGg75brD41a6t56TI6Fx6ulY89piKnTqlyzpxaf3t9hfr5qU258joUEnzZfe3fdliD7nze3u82vJ3q31tb9z7eTIMbv6CytUqp67D7NLnvBzfx3QEAgBuB+AEAAGfIcMNhimbPoc3Hj9v7/xw7qnr58qvMubN6+qmn9cATAzT01zWaN3mKskZG6p6y5bRo27bL7sv0AInjl9lXx/af0J7NBxQdFaPNv25T8UpFbsp7AgAANxbxAwAAzpDhkiA7Tp5QvSJF7f36RYupanCIvOvUlccdd8jz22/lNXq0Sh89ppe8fbV421a55E5yfzWaVNZbv41T1UYVFRMVo9CQsPjnPL0y3OEDAMCRiB8AAHCGDPdX/A87tisyJkaz23dUZh8feR4+LNfp07FPzpkjVasml5eXqtepowXbtl5xf+t/+Ed9bxuun+evVZXbKyhztkzxz7liXDfyrQAAgJuE+AEAAGfIcDVBTL+OsT+tsPefrFNX6//aoLI+PlJEhNSwobRjhzzz5ZNnnryace99ypc1q7w8PLX+8CFFXLQvH19vRUVG2/uhQaHy9vVWsQqF5e3jZWuC7P5nXyq8QwAAkNKIHwAAcIYMlwTJkyWL3ryvvaJdLq3at0/TCxdS+7W/yfNMkNyRkXL36qUdMdFqN2+OLY7avmIlZfHx0T/HjqnMRfuq0fQWdRzUUi6XW0EngjXxkekKOh6sictGKjI8ShMefjuV3iUAAEhJxA8AADiDh9vtTrooRjoRHByswMBAFX1prDz9/RM8lzkiQg/+vMrODrM/Z059/N/sMBcr88z6ZLdjScSsZO8DAICMLu68HRQUpICAgFRvB/EDAADOiB8yXE+QxJiExztNG6d2MwAAQDpC/AAAQMaT4QqjAgAAAAAAJIYkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEfIcIVR8/wheftc37YeXuSEAABwIuIHAACcgb/6AQAAAACAI5AEAQAAAAAAjpDhhsMUyBOoj1/upd0HTtrHw95YoJcGtpHb7Za3t5defn+Jdv33nIeHNPuVHpq7bIO+XLLhsvu8o2MdPT6xu7qWHqDxC56xy/wy+crb10v96o68Se8MAADcKMQPAAA4Q4ZLghh/bjlgkx9x+o+fo5gYl6qXL6wH7q6p8e8tscvvqldeR04GJ7kvDw8P3X7frTp+8JSio2L0dIvxdnnjB+qpQMl8N/idAACAm4X4AQCAjC9DDoepUrag3hl1vx67v4F9bBIgRpbMvtq5/4S97+nhoca3ldMPa7Ylua8776+rn+evldsVu484Ddvdqp/n/XbD3gMAALi5iB8AAMj4MlwS5MTps+ow+AM99sLnyhmQWXfULq3s2TLp3dEP6KmeTbXh3wN2veYNKmj5b1vtMJnL8fT0UMP2t2nllwmTHZmy+it34Vza9++hG/5+AADAjUf8AACAM2S4JEhUdIzCI6Lt/R/XblOZYnl1JiRMjz7/mZ6b/I3tHWJ6gTStU05LV29Ncl+NO9fXT3N/uyRRUqdlDa1ZtP6Gvg8AAHDzED8AAOAMGa4mSGZ/X0XGxN6vVr6w9hw6ZQugmjzG2dAIhUdEKVf2LMoZmFmvPX2f8uTIKi9PT/29/ZCOXLSvYuULqVTVYmrSub4KlcqvPq901fRnZtmhMB+NmZMabw8AANwAxA8AADhDhkuCVCtfRH273GmTHYeOB2n+D39p2ohOcrvccrndmvjRch0/fVY9R8yy67dsWEmZ/H20dfcxBV60rw9Gfh5/f+ovz9sEiBkKk6dILu3dcvAmvzMAAHCjED8AAOAMHu6kimKkI8HBwQoMDFTNDmPl7eN/XfsI/Ory0+Rere9D/5fsfQAAkNHFnbeDgoIUEBCQ6u0gfgAAwBnxQ4arCQIAAAAAAJAYkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwhAw3Re7yD55I1SrzAAAg/SF+AADAGegJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARvJVBuN1u+zM4ODi1mwIAAK4g7nwdd/5OLcQPAAA4K37IMEmQkJAQ+7NIkSKp3RQAAHAN5+/AwMBUO17EDwAAOCt+8HCn9iWYFOJyuXTo0CFly5ZNHh4eqd0cAACQBBN+mACmYMGC8vRMvdG5xA8AADgrfsgwSRAAAAAAAICkUBgVAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOAJJEAAAAAAA4AgkQQAAAAAAgCOQBAEAAAAAAI5AEgQAAAAAADgCSRAAAAAAAOAIJEEAAAAAAIAjkAQBAAAAAACOQBIE6Z7b7dajjz6qnDlzysPDQxs2bEjtJgGpas+ePfwuAMB/iBOA5ClevLgmT57MYUSGQRIE6d53332njz76SAsXLtThw4dVuXJlpQfvvvuu7rjjDgUEBNg/WM+cOXPJH7IPP/ywSpQooUyZMqlUqVIaPXq0IiMj49c5efKkWrRooYIFC8rPz09FihRR//79FRwcnGBfX3zxhapVq6bMmTOrWLFimjBhwiXtmTZtmipUqGBfq1y5cvr44491M/3444+65557lCtXLtvOihUrasiQITp48KB9fsWKFfY4xd3y5Mmju+++W3/99dcVT9JmmXnuWmzatEnt27e325nXS2y/Y8aMSdAmc8ufP3+CdebNm6fmzZsrd+7cl01M9OnTx36+5tib93Xvvffq33//VVphfr+yZ8+e2s0AgOtCnOCMOCGpc5VZbp6Pc+F5O0uWLCpTpox69OihP/74I9HtDxw4IF9fX5UvX/662h4eHm73f8stt8jb21tt27a9ZJ2L45y428XxwNy5c+17N5+n+Tl//vxL9vXWW2/Z+NHf3181a9bUzz//rLSCCzVIC0iCIN3buXOnChQooHr16tk/QM3J5WIXJg7SitDQUJvAGDZsWKLPm5Oey+XS9OnT7R/kkyZN0jvvvJNgfU9PT/sH8zfffKNt27bZE/yyZcv02GOPxa/z7bffqmvXrnbZP//8Y0+Mr7/+ut588834dd5++20999xz9o9681rPP/+8+vXrpwULFuhmMO+xadOm9vMzJ/fNmzfb9xoUFKTXXnstwbpbt261ya5Fixbp9OnT9hia9W7E51OyZEm9/PLLlyQ2LlSpUiXbnrjb33//neD5c+fOqX79+nY/l2MClA8//FBbtmzR999/b69a3nXXXYqJiVFGYt6P+U4DwM1EnOCsOOFqmfOuOW+b92MSPGfPntVtt92WaHLHHLdOnTrZ2GDVqlXXdf4zyaMBAwbY95GUuDgn7mYSNHF+/fVX3X///erevbu9CGR+mnb99ttv8et8/vnnGjhwoIYPH64///xTt99+u71otG/fPmU0UVFRqd0EpFduIB176KGH3OZrHHcrVqyYXd6oUSN3v3793IMGDXLnypXL3bBhQ7v8tddec1euXNmdOXNmd+HChd2PP/64OyQkJH5/H374oTswMNC9YMECd9myZd2ZMmVyt2/f3n327Fn3Rx99ZPefPXt2d//+/d3R0dHx20VERLifeuopd8GCBe2+b731VvePP/54Ve/BrGfafvr06Suu++qrr7pLlCiR5DpvvPGGfW9xOnfu7O7QoUOCdSZNmmTXcblc9nHdunXdQ4cOTbDOk08+6a5fv777Rtu/f7/b19fXPXDgwESfjzsuiR2nX375xS777rvv7GPz+Zj3djGzLO67cT0ut9/Ro0e7q1atelX72L17t23rn3/+ecV1//rrL7vujh07LrtOTEyM++WXX3aXKlXKHr8iRYq4x44dm+hrxX2vLzR//ny7TpwNGza477jjDnfWrFnd2bJlc9eoUcO9bt26+ON+4c2876v53l/4+1ShQgW3l5eXe9euXXad2rVr223M8/Xq1XPv2bPnqo4jAFwL4gTnxAmJnevimOXm+TjmXGbOgxd78MEH7Tnw1KlT8cvMMShZsqSNNZ555hl3z549k/2dvPfee68rHuzUqZO7RYsWCZY1b97c/cADD8Q/Nufixx57LME65cuXdz/77LNJtuvrr79216xZ0+3n52dj5/vuuy/ROCixeMa02SyLiwHM8evSpYs7d+7cbn9/f3fp0qXdM2bMsM9dHFOYmD2OWce01bShXLly7mnTpsU/F/e6n3/+ud3GrGPWN/FDq1atbHxu4oqKFSu6Fy1alOR7BegJgnTtjTfe0AsvvKDChQvbbPm6devin5s5c6btFWIy9uYKQlzPiSlTptgrHeb55cuX6+mnn06wT5PlN+t89tlntgut6Z7Yrl07LV682N7+97//2aEsX375Zfw2PXv2tK9jttm4caM6duxoeyhs3749Rd+vueJhap9czqFDh+zwi0aNGsUvi4iIsN0hL2SuRpiunXv37k1ynbVr197wLPucOXNsT52LP4c4SQ3DMG00rrWNcV1OTZfM5DKfselmbLqdPvDAA9q1a1ey9md6jpirU2Z/ptvy5Zgrcq+88opGjhxpr4jNnj1b+fLlu+7XNVcBze+R+R0y3YGfffZZ+fj42B5WZiiQGbYVd1Vq6NChV/29N79PL730kt5//317tc18f003YPMdNduYq1qmpo/5PAAgpREnODtOuFaDBg1SSEiIli5dmmAYjjmXmR4cpueFGTpk1rmQOYddONwmOapXr257ODdp0sS+9oXMOdP0FL2QGXK7evVqe98cJ3MOv3gd8zhuncSY3rUm1m3ZsqXtPfLDDz+oVq1a1/0e4mIT08vI9HI1PYnMsGDDfGcM0yPJxBTm+2i89957tvfKuHHj7Dbjx4+3+zHx+oWeeeYZ26PGrGPeu+mRZL6fP/30k+2Na2KjrFmzXnfb4RDkgZDeJXaV32SIq1WrdsVtv/jiC5vtjmOuElx8Bb5Pnz42s3xhjxGTdTfLDbOuh4eH++DBgwn23aRJE/dzzz2XYj1BzOsEBAS433vvvUueM1cATK8Vs5/WrVu7w8LC4p+bPn26bf+yZcts74GtW7faLLtZd/Xq1XYd0878+fO7f//9d3vFw/QAyJs3r13n0KFD7hvJ9MYx7+taj9OJEyfcbdq0sVdsjh49ek09QX777Td7heHAgQNX1cbL7Xfx4sXuL7/80r1x40b30qVL7fcuX758tm3X2hPEXO3IkiWLXcd8Pkn1AgkODrZXQBL7LlxvTxBzHE1vp8Qktv3VfO/jfp9ML5M4J0+etMtWrFhx2fcHACmJOMEZcUJK9AQxx8U898orr8QvMz0aLuyFYnqAXnz+NTHFvHnzktUT5N9//3W/++677j/++MMed/O+zXl25cqV8ev4+Pi4Z82alWA789j0lDHMOdm0f9WqVQnWGTdunO3hfDmmp0/Xrl0v+/y19gQx37HL9Zi5XDxkerTOnj07wbIXX3zRtu3C7SZPnpxgnVtuucU9ZsyYy7YdSAw9QZBhJZbBNhn1Zs2aqVChQsqWLZsefPBBW1zUXH2PY4ptmSKVcczVdVMc88Kssll27Ngxe3/9+vW2hkPZsmXtOnG3lStX2nHIKcFcuTFX2M2V9kceeeSS5029ENOOr776yr7m4MGD45/r3bu3LYLWqlUrW9SrTp06tseC4eXlZX+aTLsZL2qeM1f/TZ0RU8DrwnUSq4Vx4fu90u3C8ccXMsfuWnoBmN4KZn/mioK5CmCuEOXNm1fX4tZbb7U1V8z3IDnMMTPFU02hM3OFyFxJMS6+anG1PTHM1RfzvTHjf80YX1NILTHmfZurHuYqUUox3xnz3TLvw9QvudJ392q/9+Y7V6VKlfjHpieI+W6ZqzetW7e2V2nNlSAAuNmIEzJmnJAcsfmR2J4dhilab3oqdOvWLX4dc3/GjBkJtjMxxX333Zes1zbFZs1nUaNGDdWtW9fWZjE9MyZOnJhgvYuPRWLH52rWuZAp2p6SMcXjjz9ue4maYrumB09SvVCM48ePa//+/XZCgAu/E2PHjr0kHrn499b0CjHrmfprZgIB08sUuJJLK0gCGYSp9n0h06XTVBU3J9kXX3zR/jH2yy+/2P9wL+zKaU7uFzInjcSWxRV4ND9NAGC6H14cCKREdzyTALnzzjvtCdEMw0mMKRRmbqZquamabopgmYDFdKc0bTVdA023wiNHjtjZR0w3RyNuxhTTpdWc0M2woaNHj9rtzGuZRFFc98WLmaFB19IF1gynSIz5I9oM8zF/CJvXvRJT4dzsy7yPi/dpHidWJNUEMYGBgboZ3zmTELmeYVCmfeZmEiAmyMyRI4et+N65c+fLDgO6WmYYWFxgF+fiz84Uu+vSpYtN5JjuqyaQMAHM5YK6q/3em7ZeHHiZ4T4maDHDzUwBtxEjRtiux+Z9A8DNQpyQseIEs70pbmqKkF54XjKPzfKriQPMRQbDDEk1zFBTc0HCFEyNY86n5hxohnuY2VluJHNe/OSTT+Ifm1jPfEYXMhfl4obDms/CvPek1knMtcQVJqYwLowrLv6cTcLMxN0mpjDDXkyCxQxbuTihEycupjZDYi481sbFMcbFv7fmAo65sGJea8mSJXYIrimW+8QTT1z1e4Lz0BMEjvH7778rOjra/sdoTirmpGoSDCkxdtOcYM0JpnTp0gluSc0qcjXMtG9mGl1zVcD84Rh34klK3EnJ9BS4+CRiej6YqzyffvqpTapc3IPCJHtMTwuzrvkD2FwVutxrmin0Ln6/Sd0u11ujQ4cOtk2vvvpqos9fPHWwCUxMT53EgiWTBLqwLkwcs8xcYbnRzDE3AdTVJHOu5nO8+DOMYxIlJmCJC1KvxAS0ZvzyhT2eEpuq1/xOmPHQJogwY4PNd84wn8/FM9Uk93tvtjd1TczVITOttQk0ASA1ESek7zjBxADmvGR6VV7cc9Esv5o4IK4GVtwMLh988IGdhtecM+NuZlYWc3Hq4t4gN4J5LxfGFOYzubBeiWHO2aZ+l2GOk5lx7uJ1zOO4dRJjemxeS0xhXNiLM7GYwqxneguZJI45rnEX8kwbjQvjCpOgMd89U1ft4u9FXEIqKaaGmrnIaXrtmM/LJFOApNATBI5h/nA2SZCpU6fabvimoKOZXi25zB+OZiiDGVpjEizmj7sTJ07YoqumV4DpfZIYk6U3tx07dtjHppiTuaJStGhR20vFJGhMAsQ8Nplz01UwTtwfmeYqi7kiU7t2bXv13VyVMN0OTZfAuKs3pi2miKvZl7maYf6wNUNIzLCFOGbaPFOoymTfzbSzZmq8uOKxN5o5cZnhPKYrbnBwsD2Opu2mIJuZps68r6ud/s4M6TDv3RTLNUGTYabSMz0OLuyKad6reR1zwr/ckBhTXMwcz7j7JiFlTvKmPeakbJgCoea7ZD4jkwww3THNe3jooYfi93Pq1Ck7LV1cws1MfXdh7x1zwje9IUzRMhMwmNcxV+RMkuNy3x1TnM4UBjOftQkmzHs23w9TeNT0bLqY+VzNMC8zvbK5MmLe/4UF3MLCwvTUU0/ZY2aCDXPsTeLIDPUxzOdhrqKZ41W1alW7r+v93u/evdsGQm3atLEFZc3xMN8/sx8ASE3ECek7TjC9MkwPhF69etn2mc8zboiwWX5xrw2TPDFxmLngYN6f6eVihhWbfZpiq+acbxIos2bNsgmWC5lemqaIp+l1YBJD5nlzP6khMSamMPGEiQvMhYm4xIEZMmKYRIF5X2YYkVnPJA9MDGNucZ588kk1bNjQxglmSNLXX39te1qYns1xzPs1BVzNsJG4XsQmDrnccCPD9P40vTXMMTNDoUy8bHqFJlaM1sQn5mKiGTpr2mvO/aZH54VGjRplkzHmvZjju3DhQlWoUME+Z5JdZh8mNjMJNRPTmF46pkeq6SVqklDm8zLbmcSk+b5dOMz7YmY6YLO+iUvMuiYOiXst4LISrRQCZICCZ2bqtou9/vrr7gIFCtjiYKa46ccff5yg2GZiRbUSmwb14qJWkZGR7lGjRrmLFy9ui1aZ4mFmajFTMPNyzH4vnibM3OIKd8UVlUzsFmf58uW2YJRps5mCrEyZMnb6tguLrB4/ftxdp04dW3TTFD4zhSvXrFmToC2bN2+2hWTNcTHFx8x7MwW6biZTWNR8Jjly5LDvxRRlM9PxxRVcu9oCsmY/t99+u92PuTVo0MAuu1DcvkyRrcuJK8CV1FRu999/v/0+mc/cTBPbrl0796ZNmxLs53KfY9w0s6aI2d13320LzJn9mCkJTRG2Kx1/U7zOTIlrvvtmu6JFi7rHjx9/2aJjpgCcmaLOHFszlZwpvhb3XTJT3ZqieaYomSmuZt6LmQb6wsJ5Zro9U0T4wrZf6Xuf2O/TkSNH3G3btrXHzbyWab/Zh3k/AHAjECc4I04wgoKC3IMGDYo/35mfpqjpmTNnEuzrwvOxWc9MN29iO1OUNI45D5rpVhNz7NgxO+373Llz4/d3YeHVxJjzXVIxnSnGatph2hMXvyQ21eucOXNsIVZz3jXHIK4NFxdbN69nzrNmyvsLi6tejtmP+YzNNmZqWxPTXK5AvPk+mO+M+T6YbZYsWZKgMKopaFqhQgX7fM6cOe33ZdeuXfHbm8KyJubw9PRMEFeZIq9xbTDHoGHDhvEFZy9XUNV8Tua4mYLxefLkcXfv3j3RAvXAhTzMP5dPkQAAAAAAAGQM1AQBAAAAAACOQBIEAAAAAAA4AkkQAAAAAADgCCRBAAAAAACAI5AEAQAAAAAAjkASBAAAAAAAOIK3MgiXy6VDhw4pW7Zs8vDwSO3mAACAJLjdboWEhKhgwYLy9Ey9azLEDwAAOCt+yDBJEJMAKVKkSGo3AwAAXIP9+/ercOHCqXbMiB8AAHBW/JBhkiCmB0jcwQgICEjt5gAAgCQEBwfbixdx5+/UQvwAAICz4ocMkwSJGwJjEiAkQQAASB9Sewgr8QMAAM6KHyiMCgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMARSIIAAAAAAABHIAkCAAAAAAAcgSQIAAAAAABwBJIgAAAAAADAEUiCAAAAAAAARyAJAgAAAAAAHIEkCAAAAAAAcASSIAAAAAAAwBFIggAAAAAAAEcgCQIAAAAAAByBJAgAAAAAAHAEkiAAAAAAAMAR0mQSJDw8PLWbAAAAAAAAMpg0kQQ5duyYXnrpJdWtW1eZMmVSlixZ7E/zeNy4cTp69GhqNxEAAAAAAKRzqZ4EGTlypKpUqaJt27apX79+WrVqlbZu3Wp/msc7d+5U1apV7XoAAAAAAADXy1upzPT4MIkO0/vjYjVq1FC3bt107tw5TZkyJVXaBwAAAAAAMgYPt9vtVgYQHByswMBABQUFKSAgILWbAwAA0sF5O620AwAA3Jzzdqr3BLncG1u9erW9X69ePYISAAAAAACQbGkiCdK7d29b/6NatWr6/fff1bJlS/n5+dnnIiMjtXjxYjs0BgAAAAAAIN0WRjXmz5+vSpUq2ftDhgzRqFGjtG/fPnsbM2aMBgwYkNpNBAAAAAAA6VyaqAlixvKcOHFCvr6+ypMnjw4fPixv79hOKi6XSzly5LBjfm702KBmnh2V2jyzZUv2Pr4PmpEibQEAIKPX4iB+OI/4AQCQ1qXEeTtN9AQxdT9mz55t71euXNkOiYnzxx9/KFeuXKnYOgAAAAAAkBGkaE2Q8PBw24MjrheHGeZi7rdu3TrJ7V5//XU1btxYy5Yts3VBmjdvrrZt28rDw0NfffWVpk6dmpLNBAAAAAAADpSiSZBmzZppwoQJqlOnjp5//nm98847Ngmyfv16jR49+rLbVaxYUX/++acmTZqklStXKm/evNq4caOqVq2qRYsWqX79+koNxSsV0cB3HlVMtEthZ8M19oFJCj8Xrkad6qndky0VERapCT3e1PEDJ695Hx9tnaITB0/ZdWaPn6f1yzYmun25GiX08Auxw3Ry5s+udUs2qlSVovaxXyZfeft6qd/tz9+Q9w8AAK4d8QMAAA6pCWKGrRw7dkxeXl4qWbKkFi5cqGzZstkkhilymt7G9Hp5eykmOsbe7zaqg47sOqYfP1ulST+/qMENR6lc7VJq9tAdmtxn+mX3mdg+ln3yk6atfVn9bn32mmqCDJzaQz98tlp/r9pmHzfuVEcFSuTVrFe+SbAeY3oBAGldRq4JQvwAAIBDaoLExMTYISw7duywBU1ND48iRYro9OnT1/zGvvvuO3sz91NLXPLC8M/sp33/HlShMgW0d/N+RUdFa9PqrSpRueg178Pez+qv1358Xs998qSy5ch6xbZ4enmqQq2S+mf19vhlDdvW1s9fna+fAgAAUh/xAwAAaVeKJkFq166t/v3766mnnlLLli3tsv379yt79uxJbte7d29t2LDB3jdFUcuUKaNHH33U3sqWLWuH06SWGk2r6O0/XlXVOyrr8M6jypo9s0KDwxIkJ651H8bABiM05M7RWvf9n+o+5sqz0lRrVEEbV21TXMedTFn9lbtwTu3beihZ7w8AAKQ84gcAAByQBHnvvfdstxTTPcXUBDHWrFmjrl27JrmdKaBaqVIle3/IkCEaNWqUHT5jbmPGjNGAAQN0M7Uf1EoTl4+xP02tjsdrPq2f5/6qex5tqrOnzylzQKb4dV0xrmvehxFy6qz9+dOcNSpVtfgV29SwbS39/NW6+Md17q6mNYtjE0cAACD1ET8AAOCwwqjFixfXrFmzEizr2LGjvSUlMjIyvofD5s2b1adPn/jnTG+QZ555RjfT3EkL7c3H9/zhORcUKm9fbx3ccUTFKhSWt4+3rQmy6++917wPs62HhxQVGa0qDSvo0M4jVx4KU7uU3njy4wRJkY9enJci7xcAACQf8QMAAA5LghgffvihZs+eraNHj9oZXsxsL+Z+p06dLrtNvXr17DY9evRQ5cqV7ZAYM8OM8ccff9iCq6mhRrMq6jT0XlvfJOh4sCb0nGbH+c57Y5FeW/G8IsMj9epDb17zPrLmyKJxi4bZWWKiIqL12sNvJbmPag3L6+/VCYfC5CmSS3v/ZSgMAABpDfEDAAAOmR1m3Lhx+vzzz+3wlaFDh+rMmTPatm2bHQ6zbt35oRwXM70/GjdurKZNmypPnjyaMWOG2rZta4usfvXVV5o6daq6d+9+06u7p4akZoe5WswOAwBI6zLy7DCpgfgBAOAEwWltdpj3339fixcv1iOPPGITGEbp0qW1c+fOJLczs8j8+eefKliwoFavXq28efPaXiTGokWLrpgAAQAAAAAAuKnDYc6dO6cCBQrY+3FJkKioKPn5+V1xW7Pdq6++mpLNAQAAAAAAuDE9QUwdj2nTpiVYZoa21K9f/5r3FRYWpr17Ey86CgAAAAAAkKo9QSZPnqwmTZpo5syZOnv2rC14aoqiLlu2LMnt9u/fr169emnHjh0aMWKEypcvr1atWtnxPuXKlbNDbMzMMwAAAPg/e/cBHUX19nH8l55QEkrovUsvAoI0QRALKh2l/AULKCIKWOgoCChFRLALir2DUiwoTUCQIoL03ntJ77vvuZc3MYEkBBJI2e/nnHVnZ2fu3pkszrPP3CIAAJAVkiDly5fX9u3bNX/+fNuKo1SpUjaZkTt37lT3GzRokOrWrat69eqpf//+GjdunHbv3m2nzjWDrI4YMeKyqXcBAAAAAAAydYpcX19fdelydaOkr1ixwk6RGxcXp8mTJ9uBVQsUKGDfmzlzpurXr68bwd3XN91lHPmifLr2L/1MSLrrAAAAbhziBwAAXDQJEhISomnTpmnDhg12ObElS5akuJ9p8eHt7W2XzXQ38QkQo2jRonb6GwAAAAAAgCyTBDFT2ZrxPTp16nTFLjCJmUTHuXPnbPJjwYIFSd47evSoTYwAAAAAAABkmSTIsmXLdOjQIfn7+1/VfkOHDrXT65okyKUzySxevFidO3fOyGoCAAAAAAAXlKFJEDMQqunacrV69+59Te9db0VKB+qNP17Swe1H7evxPWfo0fEPqOGddfTZxLn68Z2ks97EOmO077kPFHX4tMq9+oh8yxTWgeEfSW5ucsbGqVj/dnadef/YWwskh0OFurdUntrl5YiI1pFp3+vY8VAV9iun6iWaacKnj6tMpaIa1HG6ju4/rfEf97Of4+3rJS8vDw1o95pqN66o3s/do9jYOH089SdtWbs3U84VAAC4+vjBxA7ro35TyAPB1xw7xIVEKPZCaWIHAABuRBJk8+bNCcsDBgxQt27dbMuOIkWKJNmuVq1ayo62rNyhl3vMSHj94ZivtfmPHfLL43PZtu7yUOmRD+rkR/8FN2XG9pKbp4fiNuxRwBs/aEiFYhq37ZAqDO6omKL5deilz2wgc37xRuVtUFm1T1XS+hPfKyj0nF585AM9MuxeW05sTJxeePAtu9yy/c0qVrqgXTYJkJEPvavYWIfGffiYnn/gzRtwVgAAQEbEDyZ2qOfTUn833n1Z7BD27wEFz12tAaUC9fnPG9T11qr6+b7G2jHpmySxQ/429XTqgTnEDgAA3IgkSJ06deRm7lY4nQnrli5dmmQb876Z+eVauLu769Zbb9WYMWPUpk0b3WjVGlfW1MUj9e/qnfpwzDc6dyLlQVrd3dzlGZB0LBQTxOSKiNajby9Q2NlgdThwUlPiHPrs9bnq/uoj8sjrp9jgcEXsOKIifdpIC6WCfmV0LvyovN2SH1el2d219dGkhRc/091NYSGRCcv++dM+FgsAAMjc+MHEDt7yvSx2MLwuhKnvpr0auGKLvnA4NW7+WvX5e68aBPonjR2U/tgh+HxYhh4/AABZlXt6C3A4HDbBYZ5TelxrAiQ+odKvXz99+eWXutHOnbigPjWe1ZA2LyugkL+a3H/1U/XGBoXpzMC39fKZYN3mlLziHHZ9+SNn1H3RX/LI7WubscaFRcrd7+LdIU93b8U4LgYnl/LL7aNCxfLp0J6T9nVMTJwKFc+nfIF5VKZKMeX290vXMQMAgMyNH0zssH/obJ15a4HaB4XJw3HxRpN5NvFDhfOhxA4AAGRWEiSxqKgoxcTEJFlnXpv116pFixZ21plZs2bpRouJjlVU+MW6r5y3ThVqlb7qMkzLkFfrVtBX7m4anuikO9zcVOLkBZv8MK1BPPL4yhFx8bNiHVHyck96Vyheo9bVtea3rQmv3xs3T4MnP6gnx3bSgZ3HdeFM0qmJAQBA9oofTOxQ7pWH9VzNshrpTBqwmfhBIRHEDgAAZIUkSNu2bbVu3bok6/766y/dddddyo788vyXiKjZ5CYd23ux9UVaOeMccjqcOlokn/I5nYpvoFpU0l6HQ3vz57F3cjz9c8mvSkmFbro4qOnZiEPK51M82TKb3l1bfyzalPB61+bDGtbjbc0Y8a3OnghSRNi1J5wAAEDmxg/xsYMRUiRfktjBjBoS6nDonJuIHQAAyAqzw5hBUhs1apRknXm9adN/P9qvlmlFkitXrnR1qblW1W+trN5jOisqPFonDpzWnLHfqs9LXdX4nrpy93BXsXJF9O4LnyXZ59DYzxW5/4Sij51RnvqVFbZpr8Y4pa+9vfRBdIxi3N01zuFQD29P7dy4R4V6tLT75WtTV0enzdWa4xtU2K+8fD3zaOzsx1S+WnGVLF9Yiz7/U6t+3qzCxfPr0O7/gqkuj7fSzc1vUmR4lN5+ce4NP0cAACB98cPGqCUK2xScJHYws8O8aeKHYvkVd/KCXjKDoTucCvfylNejdyWJHS78vkmlfMsQOwAAkAZuzsQjmqZTiRIltH37dvn7+yesCwoKUpUqVXTixIlrToL4+fnZsUVSExwcrICAAPt5iT//arTN1UvpdeSL8smuN4OjmjFATBcY0zLk87sbKtzP+7LtSj+T/u4sP+1/Ld1lAABwPWXEdTur1IP4AQCA7HPdztCWIK1atdKgQYP09ttvy9vb2yYwhgwZopYtL7Z2SEmBAgVSfM/kaMzsMtmdSXh80KlpZlcDAABkI8QPAABkrAxNgkyZMkX33nuvAgMDbauQo0eP2lYg8+fPT3U/08pj2rRpKl/+8lYUJpGSXccUAQAAAAAAOTQJUqRIEa1du9YOjnrw4EGVKVNGDRo0uGJLjnr16tmWI2YmmOSSIBnYYwcAAAAAALioDJ0dpn///jbh0bBhQ3Xp0sU+m9cDBgxIdb/Ro0ercuXKyb5nkiNLly7NyGoCAAAAAAAXlKFJkE8//TTZ9V988UWq+9122222xUhyTBIluRYiAAAAAAAAN7w7zI8//mifzTS2ZvyPxN1X9u7da0dvvVqRkZG2HDMzzI3ijEt9Bpq0CHwnV7r2jzuxN911ALKSNu5dMrsKcs+Vvn+Xxi+hczKkLgByHuIHAABcLAny9NNPJyQuBg4cmLDe3d3djhPyxhtvXHFA1WeffdYum6luHnroIS1YsMC2AjGDon788cfKly9fRlQVAAAAAAC4qAzpDrN//3776NSpU8KyeZhWIKtXr1a7du1S3X/s2LEJy8OHD1dYWJi2bNliH9HR0Ro5cmRGVBMAAAAAALiwDJ0d5uuvv76m/RJ3n/n555+1ZMkSO7OM8cEHH6hJkyaaOXOmbrSy1Urq6TcfUVxsnCLCIjW+xwzd8b/mat2jmam0Pn9lntYs/DvF/W9vUVUDn2it+x+YYV8XLpRXn83qq75PzdH+g2f0VL/bVbFCYfn6eOnL7/7S0hU7Uizrtq6N1X9KL3Ut3V8fbpmiM8fO2/VfvPqDNi759zocPXB9VKpXXk9M6y2nw6nzJy9oYs837L+xqctesus8vT31er93dWDr4RTLKFu9lJ55p6/iYh2KCI3Uyw9Ms/8mX/z+OXn5eskR59CUh9/SyYOnk92/SOlAvbFijA5uP2pfj+/1plo/2ERN76+viLAoTen3vs6duMBXAMANjx+IHQAAyEZJEDOd7WuvvaZly5bpzJkzSZIbGzduTHG/xFPomlYg8QkQo2TJkjp79qwyw+FdxzWo5Ut2ueeIjmpyfwPd26+N+t08VL65fDRhwQspBjHmkFo0raJTp4MT1nXv0kj/br34o8t464OliotzyM/XSzOm9EgxCWLOT7MODXT6yDn7OiwoXM+1HZ/BRwvcGGeOntOwO19WVES0Hh7/oJq0b6AV367R863H2h8MtZpXU8dB7fTao2+nWMbhncf0TLNRdrnn6M5q2qGhln+9WpMffktnj53TzW1qqetz92nGgFkplrFl5U693PNicjV/4QA1vLO2BrV+WVVuLq8eQ+/XjGcYAwTAjY0fiB0AAMhms8MMHjzYzhBz9913a+fOnXZsj/DwcN1///2p7me2qVevnn2EhIRo3759Ce+dOHFCefPmVWYwP8ji+eTytj+8ju09IR8/b/nl9VXwudAU9219WzUtX7lTDsfFRFDRIgE2KXQyUVLEJEAMX18vHTyUcqKnVbdb9cfcdXI6Lm7vl8dXU34doaEf9Vfe/Lkz5FiBG8W0/jAJECM2Js625kj87y2Xv5/2bzmY5n+b5gfFoR1HFRMdaxMgl5abkmqNKmnqr8PVZ0xnFS5dMKFVyO5NB1S9caV0HiUAV3at8QOxAwAA2SwJMm/ePC1cuNAOlOrp6Wmf586da1uGpGbWrFl2W/N466237ICq8f7++2/16tVLmaXe7TX01trxqt2imo7vO6n1v27WB5smaeaqcfrhzV+S3cfd3U0tm9+kJSu2J6zr3uUWffXdX5dtO/L5dpr91sNa//eBFMtq3ukWLf9mTcK6Z1qN1bN3jLd16TWyY4YcJ3CjFSoVqHq319SaBRvs64BAf73+xzg99eaj2pLo305K6rWupbc3TFLt22ro+N6TCes9PD3Uc1RnzX1jUYr7mq4ufWo9pyF3TFBAIX/bPaZyvXLy8vZUvZbVlScfyUUANzZ+IHYAACAbdocxXVnKli1rl319fe1sMVWrVtWGDRd/5KTEtBhJiZkdxjwyy8bf/1X/W0aoy5B2uu+JO9S0fQP1rj7E/lia9Mtwbfhty2X7tGlV3XZtie8NVLzYxZltTpz6rxVIvJcnLVCePD56Z9r/9HMyZd3+YFOt+G5tkq5FIf9/B2nF92t1V5/bMvJwgeum06B2anxvff05f71++uB3Df34Kdt9Jf6OadCZYNvFpUqDinp4fHcNv3t8qmV8N22Bnrj5edvt5e6+rfXVq/PsNoPe7acF7y62PzpSYlqN6GJjFK38Yb2q3VJBC2ct1YQfn9PezYd0ZPfx63UaALiIq40f0hM7JAoRLGIHAABuUBKkUqVK+ueff1S7dm3VrFlT06ZNs1PbBgYGKjsygYr9sWS67ASFK9rbU9GRMYqJirE/3Lx8vOx4HYkTFEbZ0gVVqUIRG9CULFFAr03optNnQjRpXBeVL1tIJYrn1zMvfGHv+sTExCkqKlbhEdGXBTFG6arFVbF2WbV6sIlKVCyqxyf10KyRX9l61Wx6k44mugMOZGUmaWEepqXXi3Of06fjvtHR/082uHu420FRzb8lM+ZNZFhkqmWYf5vxzPZmMFWj+4iOOnHglB0fJDWmS5kZUNWo2aSKbar+2xertPizlarV7CYFJeq2BgA3In4gdgAAIBsmQSZMmKDQ0NCE5e7du9sxPt59991U94uJidFLL72klStXqlatWhoxYoSKFCmS8L5JqJjpcm+0eq1rqsuge+y4HuYu9ZRH35WXj6emr3hJ7h5u+vGdxZclQIx3Zy//b3n6/9Tv6Y8TXg8dfLftFmPGAxkztL38/f3k6eGuj79I/kebSXjEm7lyrL6cMl+vLx2jyPAoG0xNffz9DD9u4Hpq0bWxqt9aRbny+qnHyM6a/86v+nflDg3/7Gk5HA6bDJkx4INUy6hnBj599n67vUlYTO7zpgoWy69eo7to66qdqtOyhrat2aXZwz9Pdv/qjSur9+hOioqI0okDZzRn3Hca9tETCgjMq1OHzmrm4P/+zQLAjYgfiB0AALgx3JzJ/Yq/wZ577jk7bsj//vc/LV++XKtXr9bixYtVvXp1+74ZGNUkU1ITHBysgIAABQUFyd/f/5rqcYdPD6VXVKta6drfZ1n6kz2/Rnya7jKAjNLGvUumn0z3XLnSXcYvocwWA2SkjLhuZ5V6ED8AAJB9rtsZ2hLEiIuL08GDBxNahMQzLTxS8tVXX2nNmjUqXry4nnrqKb3//vtq3bq1fvnlF7tf4il0AQAAAAAAMj0JYmaHeeyxx3T2bNLpXk0SwyRHUmKyOIm7v5gycuXKpTZt2uinn37KyCoCAAAAAAAXlaFT5A4cOFATJ060s8SYvvrxj9QSIIaZUWbTpk1J1vXo0cMOrHrHHXcoKioqI6sJAAAAAABcUIYmQcyUuA8//LD8/Pyuaj8zFsiSJUsuW28GVp0xY4ZKlCiRgbUEAAAAAACuKEOTIE8++aRNWlytIUOG2MFRk/Pggw9q3759GVA7AAAAAADgyjJ0TBAzlkezZs00adKkJGN8GBs3bkx2HzN+SMGCBa9Ydlq3S49foz67ruUDrsgjf/50lxG4KPUudVdytnOedNcBAFJC/AAAQPaRoUmQzp07q1y5curUqZMd2DQtGjZsqI4dO6pPnz6qVq3aZe9v375ds2fPtoOu7t69OyOrCwAAAAAAXEiGJkE2b96sc+fOydvbO837mAFRp06daqfENYOo3nTTTXa+XzP/786dO+02/fr1S7ElCQAAAAAAwA1PgjRq1Eh79+5V1apV07xP3rx59eKLL2rUqFH666+/bFLk/Pnzyp8/v+rUqWNbinh4eGRkNQEAAAAAgAvK0CRI/fr11bZtW/Xs2VNFixa9bPrc1JhER+PGje0DQM7jl8dHE78frDJViumZtq/o4I5jat6+vjo8fruiImM0pf+HOnPsvEpXKaanX+sldw83fTzxR61b9o9+fnihgvZfUNsP7lW+Cvn1Y+dv5VfoYpe7Gr1rq9gtJbRuyp86v+usHHFO1Xqsroo3Kmnf3/HlVu0/fVROp0O3lLpf0755XmUqF9Og+6fp4M7j+mDFSJ09ccFu++WMxfr7j52qfWsl9X6hnWJj4/Tx5EXasmZPpp47AAAAAFkwCbJ27VpVqFBBf/75Z5L1bm5uV0yCAMjZoiJiNObBGXr0pc72tYenhzr2b6Nn75mkynXLqvuz9+iNwZ+q98gOmvrUR7pwOlgvf/20NizbqtumttHfM9YllOWVx0tt3r5bPuExuuPbbSq09IAa5vbSP6+3VXCsQ0uf+cUmQc7uOKOwE6FqWKij3c891l0v9n5Pj4y8P6GssJAIvdB1ZpK6mgTIyF7vKDYmTuM+7qfnu1z9rFcAAAAAcngSZOnSpRlZHIAcxBHnUNDZ0ITXJSoUtq1BTKJh21979djYi8mRAkUCdGzfKbscfC5U+Qr6yzu/M0lZsRGx+r3vAt2y97xuD49RPg833eaQjv55RCNn3mUyr3a7IysOKS46Tn+d/l55PAuoar7mCjoXlqQsv1w+mvTNUzpzIkhvjfpWoRfC5e7hrrDgCPu+u7u7/PPnvu7nBwAAAMD1556RhR0+fFgXLlxsVh4VFaVp06Zp5syZio2NzciPAZAD5Pb3U3jIxUSDYRIPxv/nLyzzft78l880dcd79+j1pqXUPjxGY52SZ6xT7g6nShwI0umhv6tK14szTUWei7DlmpYgHm5eOhFxebeWIR1ety09Nizbrp6D7rTrYqJjVah4fuULzKsyVYoqd4Df9TgFAAAAALJzSxAz1e2sWbOUL18+vfDCC/r999/l5eVlZ3mZMYPm5AD+ExoUrlx5/ZK0FLHPjv9afeT2z6WQ8+G6dL4pnwBfFToWqgbu0uy4/9bPllNeIdEq17aCfe2dx1uBtQpLf0oFfEvqQtTxy/4EIRfC7fMfCzep7YON7PJ7L83V4Ne621YhB3Ye14XTIfzpAAAAgBwgQ5Mge/bsUc2aNe3y119/bccGyZMnj2rUqJGmJIjT6dSvv/6qbdu2qUSJErrnnnuUOzfN0IGc6Ni+03YQVE8vDzsmyP6tR+3686eCVbx8YTsmSN78uW2XmMBE+8XFxElO6XTxPFrpkCr+/3rTGW+uQ+rRtrwW/f+6QrWK6NyuszJtSUKiT8vP0z9JHcxnm5YnMdFxqnFLBR0/cMau3/XPIQ174E3bDab/y50VERZ1Q84JAAAAgGyUBDF956Ojo23LD39/f5UpU8YmNkJD/xsHICVmnwceeEANGjSwU+P+/fffeuWVVzRv3jyVLl06I6sJIJOM/fIpVahZSiUrFtGiOSs0753fNXn+s4qOjNXk/rPtNh+9PFdDZvS+ODvMKz/adUsH/arzu88q+FCQSjYvo0O/79dSbw9V8vXUp5GxivVw0+OxTnl7e2jIn0fltumkWr3eVsWblNSRlYe09tR38vbwU+28bTV2Tj+Vr15CJcsX1p+/bFGzdnUVGRGlmKg4TXv2c/t5Xfq31s0tblJkeLTeHv0t3xcAAAAgh3BzmixFBnaHiYuL09mzZ9WsWTNNnDhRu3fv1p133qm9e/emuF9QUJBuueUWzZkzxz7HW7JkiT766CP7mDRpku1iY2aaSU5wcLACAgJsWSYBAyBruLNg33SXEbgoUZ+XRBJmhzkWaluG/Nq5mqJyeV223dnOedJdh58OT093GQCy3nU7q9QDAADcmOt2hrYEMeOBTJkyxY4D8vzzz9t1u3btuuL0uGYA1YceesgmQNq2bauYmJiE9w4ePGhbmKxYsUIFCxbUY489lpFVBpCNmYTH/P/VzuxqAAAAAMgmMjQJkj9/fo0fPz7JOjOux5WYLi/z58+3y7fffrs2b96s7t2768svv9Rtt91m148dO1ZPP/00SRAAAAAAAJA5SZB33nlHjz/+uF1+4403UtwutdYgR44cUalSpezyJ598ovXr18vHx0etWrXSzTffrNGjR6tu3brasWNHeqsLAAAAAABcVLqTID/++GNCEmTu3LnJbmPG8UgtCZIrVy6dPn1ahQoVsn18jh49qvLly9vkSEjIxakpw8PD5evrm97qAgAAAAAAF5XuJMiiRfGTUUpLl5pJKq/erbfeqt9++00PPvigHfy0efPmatq0qVatWqXhw4fbbZYtW6aGDRumt7oAbrC48+fTXcbZjkXTtX/s8WPprgMAAACA7C9DxwSJFxsba1tuJJbayK2mlUi/fv3Uvn179e/fXy1bttS///6rMWPGqGrVqoqKirLLr7/++vWoLgAAAAAAcAHuGVnYmjVrVLt2bdttxQySah758uWzz1dqCWJagZipdA8fPmwTH126dLHP5rVZ365dO9tCBAAAAAAAINNbgphpbrt162ZndTHjfFwN0+2lYsWKuuOOO1S4cGE7UKoZG+TEiRMaMWKEevbsmZFVBQAAAAAALiZDkyCnTp3SSy+9ZAdCvRZdu3a1j3379unkyZN2oFSTGAGQc/jl8dWri0erbPVSGth4uA5sPSzfXD568fvn5OXrJUecQ1MefksnD55Oul9uH034coDKVCmmQfdO1cGdx+36QsXza9bKUXrqrsl2nZe3px4f10nFyxVWeEikxj3yfprqYNz/5J1q3auFnE6nPh//ndYs2HCDzgoAAACAbJcE6d69u+bNm6cOHTqkqxwzM4x5AMh5oiKiNereV9R3Uq+EdXGxcZr88Fs6e+ycbm5TS12fu08zBsxKul9kjF586F09Mqp9kvVdnmytrev3J7y+r09z/fXbVq1d/NVV1cG494m26lt7iE3KTPx5JEkQAAAAIIfJ0CTIyy+/bGdwmTx5sooWTTqbw/fff5+RHwUgmzItPYLOBCdZFxMdaxMgRmxMnOJiHcnvdy40yboipQrK6ZROH/1vBpqbW1ZTvkJ51bFvKy37YYN++nRVmupgHNtzQj5+3vLL66fgsxen5wYAAACQc2RoEsSM2+Hj46NmzZpd9ZggAODh6aGeozrrtcfeSdPJMK1Avp65WD2H3J2wrlDxfFow5w99OHG+XvlqgNb9vlUnjp9IU3nrfvlbH2ydJg8Pd03u8yZ/EAAAACCHydAkyPLly3Xs2LFUp8MF4Jo6DWqnxvfW15/z1+u7aQuS3WbQu/204N3FOr7v5BXLK1Ym0D6fOnKxBUm80KAIbVq507b22LZ+v0qUL6wTG3dcsQ658vrpnsfaqHflgXZckcm/j9GGxZvTccQAAAAAcnQSpFq1agoJCSEJAuAyJumQUvLD6D6io04cOKXlX69O09krV62EylQupnGfPqGyNxVX8bKBeqHLG9q2fp8qVC+pLWv2qHy1Evr589VpqoPD4VR0ZLRiomLsGCVePl52kGczSCoAAACAnCFDkyAdO3bUPffco/79+182Jsh9992XptllJkyYoI0bNyo0NGnff7MOQM4wfsEwVahTViWrFNfC9xZrw6//qNfoLtq6aqfqtKyhbWt2afbwzy/bb+zHj6t89ZIqWaGwFn26Ss91fN2uHzytp75753c7lsg3b/5mXz809F5tWLZNJw6dTVMdfp2zTCu+W6M3Vo+Xu4e7fnzrZxIgAAAAQA7j5szA25zlypVL/kPc3Oy0t1fSsmVLeXh4qFOnTpeNKfLQQw+lum9wcLACAgIUFBRESxQgC2nj3iXdZXgWS5pUvVqxaRwTJDWLHd+kuwwAWe+6nVXqAQAAbsx1O0Nbguzf/980ldfCtPY4ffq0vL29M6xOAAAAAAAAhntWOg233HKL9uzZk9nVAAAAAAAAOVCGtgRJr48//lidO3dW8+bNLxtTZODAgZlWLwAAAAAAkP1lqSTItGnTtH79esXExCQZE8SMKUISBAAAAAAA5JgkyNtvv23HBTFT7QIAAAAAAOTYJEihQoVUvnz5zK4GgAzErCoAAAAActTAqLGxsZowYYL69OljW3IcPXpUbdq0sVPmPvHEE4qMjExTOaNGjdJjjz2m3bt326lvEj8AAAAAAADSw83pdDrTVYKkwYMHa9OmTXJ3d9fmzZv1+OOPq1atWoqOjtb48eN177336pVXXrliOWb/hIq5udlnUz2zHBcXd93nCwYAADdGVrluZ5V6AACAG3PdzpDuMN98841NgjgcDhUpUkQ9evRQlSpV7Hs1a9ZUhw4d0pQE2b9/f0ZUBwAAAAAA4PokQUw2pmDBgnY5T548CQmQ+CTIqVOn0lROmTJlEpbPnDmjwMDAjKgeAAAAAABAxowJYpqjRERE2OURI0Ykec80U/Hx8UlTOeHh4erXr5+dHte0KDHPpmtNWFgYfyoAAAAAAJD5SZD27dvr0KFDdvmFF15I8t7cuXNVt27dNJUzZMgQ7dq1S7///ruOHTtmn80gqc8++2xGVBMAAAAAALiwDBkYNTWmFYcZ2NS06riSEiVKaMuWLSpQoEDCurNnz9ouNSYpkhoGNgMAIPvIKtftrFIPAACQjQZGTU3u3LnTvK3JxySeIcYwr69zngYAAAAAALiADOkOk5qYmBi1atUqTdu2a9dOnTt31vr163X69GmtW7dO3bp1s1PsAgAAAAAAZOkkiJk2d/ny5Wna9rXXXlPp0qXVrFkzOzCqeS5ZsqSmTp16vasJAAAAAAByuAzpDtOxY8dUkyBpZabXnT17tmbNmmVbghQqVMiOJwIAAAAAAJAlkiCLFi1S3759VbBgwWS7w8yfPz/NZYWEhGjhwoU6cuSISpUqpbvuuouBygAAAAAAQNZIgpjZW1q3bq377rvvsvciIyM1YcKENJWzadMmtW3bVvnz51e5cuV04MABDRw4UD///HOap9kFAAAAAAC4bmOC9O7dO8VuL15eXhozZkyayjEJj+HDh2vHjh366aeftH37do0cOdKuBwAAAAAASA83Zxaaf7ZAgQJ2LBAPD4+EdXFxcQoMDNT58+ev+3zBAADgxsgq1+2sUg8AAHBjrtsZ0h0moxQtWlRr1qxRkyZNEtb99ddfdj0AZGdtPB9IdxluiRLE18Ldzzfddfj5wqx0lwEAANKG+AHIeFkqCWK6wpiBUHv16qWyZcvaMUE+++wzzZgxI7OrBgAAAAAAsrkMGRMko/Ts2dPODGNmlFm6dKl9/vHHH21SBAAAAAAAIMe0BDGaNWtmHwAAAAAAADk2CWIGRDWtPj744AN5ev5XNTPgiRkABQByCr88vnr115EqW62kBjYZqQNbj+j+/m3VulczmeGqP5/wvdYs2Jji/ma/p998RHGxcYoIi9TE/72pUV88LW8fL8XFOTS177s6efBMqnVwc3PT4Lf6qFiZQjIjZL/Wf7ZiomM1YGpP5crrq3/+2KnPXv3xOhw9AAC4FsQPQA5Lgvj4+OjUqVNq3bq15s6dq/z589v1WWgCGwDIEFER0Rp136vq+2rPhHX3Pt5Gfes+L99cPpr407BUkyCHdx3XoJYv2eWeIzqqyX31NeWxd3X22Hnd3Lqmugxup5lPf5RqHSrUKiUvby89e/erqntbNd3bt5UKFA7QjMGf6OzxC/ylAQDIYogfgBw2Johp/bFgwQJVr15djRo10p49exLuVgJATuKIcyjoTEiSdcf2npCPn7f88voq+GxoqvubFiDxfHJ56+D2ozYBYsTGxCV5PyWnj/439XiegFwKC4pQkdKBeuzlbnrlx2dVtWGFazgyAABwvRA/ADmsJYjh7u6uN998U6+//rqdKvebb77J7CoBwA2x7pd/9MGWqfLwcNPkR9654vb1bq+hRyc8aJMeX0+Zb9d5eHqox/AOmvbE+1fc3yRanA6H3v/rZXn5eGrIna+oy8A7Nb732zaJ8uIXT+np28dnyLEBAIDrg/gByMZJkMTdXp555hlVrFhRHTp0UERERKbWCwCut1x5/XTPo7er903PyMvbU5MXj9SGxZtT3Wfj7/+q/y0j1GVIO939SCt9NWW+nnnrES18/3cd33fqip958+3VFR0Zo8cajlTF2qXVd3w3Hdl7Umf+v0VJXKxD7h7u9q4TAADIeogfgGyeBJkzZ06S1+3atdOSJUs0b968TKsTANwIDodD0VExiomKsa0wvHy8bFfAlMZEMokSM4ipER4ULk9vT3Uf2l4nDpzW8m/XpPlzQy6E2+fQC+HK7e+nsKBw5fL3s3UwZZIAAQAg6yJ+ALJ5EqRjx46Xratdu7Z9AEBOM37+C6pQu4xKVimmhe/9rhXfrdUbq8bZboE/vv1rqoNC1zODnw66Rw6HU0FngvX2s5/o093TtXX1LtW5rZq2r92j2aO+SvXzNy7Zqtu7Ndakhc/bpMp7Iy5uP/bLgfLw8tDH4+dm+DEDAID0IX4A0sfNmUOmXjFT6AYEBCgoKMhOqQsAWUkbzwfSXYabh0e69nf38013HX6+MCvdZQBZ6bqdVeoBAMkhfgAy/rqdpWaHAQAAAAAAuF5IggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAuIUtNkQsAybnDr2e6TkzIfXXSfWL9f96WvgKcjnTX4eeDG9K1f9vi6T8PAABkF8QPFxE/AEnREgQAAAAAALgEkiAAAAAAAMAl0B0GQLZ0W9fG6j+ll7qW7q/AEgX01Ou9lcvfT/8s36ZPJ8y9bPuihfw1e0JP7T981r4eMe1HXQiJUJGCefX19EfUZ9in2nf4jLw8PTS4TyuVLJpfYRFRGjrlh2Q/v0q9cnpkbBe7XKBoPq37dbOO7z+l1g/eKqdT+nzyfK39+Z8rHoe7u5uenzNAgcUL6OTB03qt77uKi41Lsk2w87x2OTepZYdQFS7kqU/fLKJ+z53SwsVhGj2kgJ58OJ/dLirKqadHntae/THKm8ddcz8qZtdPf++CFiwO00bnBTXI00LTf5uostVLaWDj4Tqw9bDdpkXXW9Xx6XsUFRGtyb1n6vSRs6rTsoYeHv+gYmPi9NHoL7V5eTq7BAEA4MLxQ0bFDgbxA3DtSIIAyHbc3NzUrEMDnT5yzr5+bMKDeuPpD3X22PlU9/t72xEbvCTW6/6G2rzzWMLrLnfW1aqN+7Ryw95Uy9q5cb+ebzfJLj8zo7dWL9yop177nx6/dbR8c3lr/PeD0xTINO14i47vO6VXes1Q12fvU9OODbX86z+TbOMjP9V1a6bf5m7RiAlnNe/nMI0fVlDNG/spLOy/sUZmzr6gu1vn1n1tcyes2/BPpA4djdHib0rYMUHcIt016t5X1HdSr4RtPDw91GlQOw1uPlpVGlRQj1Gd9Xq/d20CZNhd4xUXE6fxC4drSMsxVzweAACyqsyOHzIqdjCIH4BrR3cYANlOq2636o+56+R0OOwP+CJlAtXvle6a9NMwVWtUKcX9alUprrdffECPP9DUvi5WKMDeeTl5Jjhhm0Z1yqnOTSX15uhuat+61hXr4u7hrqr1y+vf1bt1bN9J+fh5yy+Pr0LOhaXpWIqVK6K9/xywy7v/3q+aTateto2Pm6883C7mrL28JE8PqViRRDlskwiZcV6/vHdBK98+r1b3H9G7HwfZt378JUyRUU617nxUO5x/21YmQYmO1yhRqZgObjus2JhYbV29U+VqlE44trCgcEWGR9ll/4J503RMAABkRVklfkhv7GDrQPwAXDOSIACyFdP8s3mnW7T8mzX2dUBgXpWvUUrvDftCE3u/pccnJz+TzNnzYery9Cw98eKXyh+QSy0aVlKv+xvoswXrkmxXuGBebdl9TANf/lp3NKmqQgXypFqfOi2qavOqXXI6nVr/+796f+3LmrF0tOa9+1uajufQjiOq27KGXa53e03lzpc75W2PxOj3PyLUrk2ibaKccrvniNxeOavDJ+LU+K9ILb4Qpy+/DdGRY7E6eTpOnp5u+u3bEvKQh07qyGXl5smXS+HBEUmCMyM2OlaFSgUqX+EAla1RSnlSqRsAAFlZVoof0hs7GMQPwLUjCQIgW7n9waZa8d1aGzgYoRfCdGT3CZ05ek7nTwbZlg7xP+ITi4mNU2RUjF1euna3WjSoaJdPnE7aKiI0LErrtxxUnMOpLbuOqXSx/KnWp3n7+vpj3jrlyuurux9qoT71hurRBsPVZ3SnNB3PmgUbFRMdq8m/jZZvbh+dP3Eh2e1inTF66KmTmjWtsLy83BIVECHtjpabQzIjg7R2Sp57YtTYU9q1L1r5AtzVqqmflKuPvl36pR4Y1OGyskPPh9n+0PEccRe72Lw16CM99+GTemrmo9q/5ZDOn0y+bgAAZHVZKX5Ib+xgED8A144kCIBspXTV4mrdo6nG//C8SlQsqofHdlVoULj9Ee+by0deXp4JP+ITy+XrlbBct2pJrdtyUOVKBmrasE5qWKuMnn+0tTw83LV551FVLlvYblexTCEdvyTIuaw5a4MK2rJqlxwOp6KjYhQTFavI8Gh5eXvavsdXYoKxd4bM0XOtxyr4bKhW/fBXstv861yrkYMLqHIF76Rvnnck/J+8iaRNtmLS5oOxKlvKS7c28NM/W6Ol8A/1YMv/6fNp315W/tE9J1Smakl5enmq+q1VtG/LQbt+1/q9er71S5r+xHs2SIwIjbzi8QAAkBVllfghI2IHg/gBuHYMjAogW5k18quE5Zkrx+qd5z+z/XjHff+sPL08NGfs5T/yjVo3lVS/bk0UGRWr46eD9N5XK/XTiouznYx84k59vmC94uIc+uTHvzTqibv0+IPNtGbTfh07dXFsjeTUaX6Ttqy+2Jw1MixKK39Yr9d/G2EDnPkfLEm425Sa/EUCNOLzZ+wdqI2/b9HWVTsv2+akDitIZzV+mrvGTzunfg8F6J9/ozT/13DFnYnV3ljpdUkvSOotaXis1Lail8qX8VKZkp5a8GuYWnU8omAVVA3dovELhqlCnbIqWaW4Fr63WL/OWabvpy/U1GUvKToyWpMemmk/t9sL7VX/jtr22N4cODtNfx8AALKirBI/ZETsYBA/ANfOzZnWf2lZXHBwsAICAhQUFCR/f//Mrg6ADHSHX/L9dNMq5L466a6D/8/pmx7WERqa7jr8cvTvy1eGOeyYIKZLjG0RYm5iVfKWc2FJKXfSxn5mdpj0Wuz4Jt1lAFnpup1V6gEg4xE/XET8gJwkOAOu27QEAYDsLLf7xYTH7CC5HYqRs7SX9HDAZQkQAAAA4geAJAgAZH8m4fFUfuWIZn0AAODGIH6Ai+JWIQAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCA6MCyPLcPNP3v6oztdKf7823Mne69nfz9kp3HTJidhcAAFwF8cNFxA9AUrQEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEtgTBAA2VKtpjep+wv3ycPTXd/P/EWFShRQ6webyOl06vPJ87X2p01Jtnd3c9Pk++5Ukbx5dPRCsMYtXqoZHdvJx9NTcQ6nhi74RUeDglUxsIDG3d1GHm5uen35aq0+cCihDL/cPprw5QCVqVJMg+6dqoM7j9v1hYrn16yVo/TUXZPtuuoNK+jRUe1tXdYv3a7Pp/2UpIyJ3w1SmZuK6Zk7X9XBHcfUvH19deh7u6IiozVlwEc6c+y8vLw99cSEbipevrDCQyI19qG3LzsHfnl89eri0SpbvZQGNh6uA1sP2/VTl70kp8MpT29Pvd7v3YT1qanSoKIee7WnXS5QLL/++mmj3hk8Jx1/IQAAsnfskFXiB2IHIGORBAGQ7Xj5eKnTwDs1suNUxcbE2XXvrRuvxxuNkm8ub42f9+xlgcwdVSrq8IUgDfnhJz3WqL6aly+roQt+VciZsxoZE6b369XVvB/n6ubp0zR0/i86GxauWQ92TBLEREXG6MWH3tUjo9onKbvLk621df3+hNedn7hdU5/5VEf2ntSUuc/oh1nLFHomOqGMMT1m6tEXO9nXJhDr+HhrPXvvZFWuW1bdh9yjN4Z8qvsebam/Fm/Rml82p3geoiKiNereV9R3Uq8k659vPVZxsXGq1byaOg5qp9cevTyBcqmd6/bo2VYv2uXB7z+u1fPWXXEfAABycuyQUvzw0nfzdcfin9WgckVNu6ONeq8/rcG3Nb1u8QOxA5Cx6A4DINupdktFRUdE66Wvn9Hoz59S/sIBOrbvlHz8vG3riJBzoZftUzp/Pm0/cdoubz1xSvVLl7QJkG/efUMd165W+eNHNfi3n9Q4IlSnT5xUaHS0LkREKL+fb0IZjjiHgi4pu0ipgnI6pdNHzyesO7TrhHL7+9oEh9knOiomaRln/yujRPkiOrjzmA3Itv21V+WqlrDr67eqrhqNKmnSvMG6+3/Nkj0PtqwzwZetNwkQI5e/n/ZvOXhV59bdw1033VJJW/7YflX7AQCQ02KH5OKHxiWK6c0pE2zM0HT7v6p9YJ+NJYrmzqWD5y9cl/iB2AHIWCRBAGQ7+Qv7q0iZQI3p+roWfbhMvYa31/rFW/T+uvGasXyM5r29+LJ99pw5q0ZlS9nlW8uVlr+Pj3quWakK58/KY9QoeUyfLg+nU76xsXa9ERIZrYBEQUxyzF2c7975Pcm6P3/ZrJHvP6L3l4/U5j/3KCYqNsX9cwf42e4u8dw93OxzoRL5tX39Pg3t9Lpu69RQgcXypfn8BAT66/U/xumpNx/VlhVXl8yo26qGtqzYZpviAgDgyrFDcvFDrdBgVTh9Uh4eHvIcOVLu06fb14GhIQn7XO/4gdgBSB+SIACyndCgcG39c7dtPfHP8u2qfHM53d3nNvWpM1SP3jxMfcZ0vmyfpbv3KSYuTp/06CI/Ly+dDgtTqfPn5Pbee9I770j79tntnA6HXW/4+/ooKOK/BMWlipUJtM+njlzcPt6jozvo2Q7T9UjTcSpXtbhKVSyS8rFcCFeuvInvFl1MPoQGRejvFdvt3Z/t6/aqRIX/yug0qJ2mLHnRPifHtA55ptkoje08VQ+P766r0bxLYy3/5s+r2gcAgJwYOyQXP7gfPy6Hm5uUKH4wr71i/mv1eb3jB2IHIH1IggDIdnZu2KfSNxW3yxVql9GJA6dtk9GYqBhFhkfLy8dTbiZAScSkFib8tly9PvtGFyIi9dvOPSrx5BPS/v3S118nbOd24oRCqtdQHm9vexfnfCpBTLlqJVSmcjGN+/QJ1W1WRU+90s02YTWDkoaFRNjWFOFhUcrt75diGcf2n1LpysXk6eWhag0raP+2I3a96RpToebFO0/lqpfUycNnE/b5btoCO36HeU6uO0v8sYcFhSsyLOX6J7dv1UaVr7r1CAAAOTF2SC5+2Ljhb3kMH54kfnB3OnU+JERl8ue7IfEDsQOQPgyMCiDbCTkXpjWLNmnKz8PkcDj1Wv9ZanrfzXp9ySi5u7tp/ntLLuvOEZg7l17vcI9iHQ6t3n/IDnLWaMCjilyzVn4tW8qxZo00fLgOT52m+p9+qtkeHpq+YvVlnz3248dVvnpJlaxQWIs+XaXnOr5u1w+e1tM2a42LdeizaT9p3CeP2+Uje09px8YDScv4YoAq1CilkhWKatHHKzTv3d81+YdnbTA2+ckP7TZfz/hZQ2b0Vu8R7bXh9606cfBMsudi/IJhqlCnrEpWKa6F7y3WhsWbNfyzp+VwOGwwNWPAB2k+r3Va1rBjgdAVBgCQ01xL7JBc/DC7eGk9+Mzjcq5aJWerVtKaNdo7bbpe2LBFr7S/x84Ocz3iB2IHIOO4OXNItBscHKyAgAAFBQXJ398/s6sDIAO1zds7XfvvG1orxfdyRUXZMUBMF5jD+Qvo00ZNFe7jc9l2Fd/6b/T2a+GMvjg7THrEnU3abDYzLHZ8k9lVQA6RVa7bWaUeALJP/JDW2MEgfriI+AFZ6bpNSxAALs0ELe+1uD2zqwEAALIJYgcge2NMEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlMDAqgCzPERaWrv3Ljl6T7jrEpnMiLUZFBwDgxiJ+AJAcWoIAAAAAAACXQBIEAAAAAAC4BJIgALKlWi2qadLi0Zq69CU1vq++XTd12UuasuRFvb7yZZWtXirFff3y+OqN1eP1Y9DHCdu16NpY01e+bMssVLJgmuvR8oEm+ubkrITXgSUKaOy8F2w9eo7unK5jBAAAOS9+IHYAMhdjggDIdrx8vNR58L0afvcExcbEJqx/vvVYxcXGqVbzauo4qJ1ee/TtZPePiojWqPteUd9JvexrD08PdXqmnQa3GK0qDSqqx8hOev3x965YDzc3NzXr1EinD59JWGfKnN7/fZ09di5DjhUAAOSc+IHYAch8tAQBkO1Uv7WKoiOiNe7HFzTmu+eUv0g+u94EMEYufz/t33Iwxf0dcQ4FnQlJeF2iUlEd3HZEsTFx2rp6p8rVKJ2merTq3lR/fLdGToczIRgqUraw+k35nyb9NkbVGldO55ECAICcFD8QOwCZjyQIgGwnf5EAFS1XWKPue1WL3l+s/73Yxa4PCPTX63+M01NvPqotK7anubw8+XIrPDg84bW7x5X/1+ju7q4WXW7Vsq9WJ6wLCMyrcrVK673nPtbEHtP1xLQ+V31sAAAgZ8YPxA5A1kB3GADZRqdB7dT43vra+Ntm/btqh23KumnJv3pgaAf7ftCZYD3TbJRtkvrw+O4afvf4NJUbej5MufxzJbnTc6U6bFr2r5Z/s1rORFPnhl4I19Fdx3Xm6LmEO0smIEqtPAAAkLPjB2IHIGuhJQiAbOO7aQv0bKsXNf+dX1Wmakm7rmLdcjqx75RNNph+tkZYULgiwyLTXO7RPSdUpmoJeXp52Kay+1JpChtfB99cPmrTq4UmLBqhEpWK6fHXHlJ0ZLRCL1wMiMz7Xt6eJEAAAHDx+IHYAchaaAkCINsJOReqP+evt6O5m/E4pjzylu3XO/yzp+VwOOy6GQM+SLWM8QuGqkLtsipZubgWvr9Y37+xyI4UbxIZk3q/ecU6fDD0s4TlN/96Re8MnmOXPxz5hV6eP9QGRB+N/jIDjhYAAOSE+IHYAcga3JyJ23JnY8HBwQoICFBQUJD8/f0zuzoAMlAb94t9dq/Z/9/hSZd0/q9yseOb9NcByEGyynU7q9QDQMYjfgBynuAMuG7THQYAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACAS2CKXABZXnpnVmnj0TXddXDz8k7X/m3z9k53HX4J+SjdZQAA4CqIHy4ifgCSoiUIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJjggBwOX55fPXqr6NUtnopDbx1hA5sPayPdkzXmaPn7PufT/xeG3/bkuL+ZauV1NNvPqK42DhFhEVqfI8Zuuex29W0fQNFhkVp8qPv6NzxC1esR62mN6n7C/fJw9Nd38/8RYVKFFDrB5vI6XTq88nztfanTRl63AAA4NoRPwA5A0kQAC4nKiJao+57RX0n9UpYFxYUrmdvfylN+x/edVyDWl7ctueIjmpyfwPdcmcdDbrtJVWpX149hnfQjKc+TLUMLx8vdRp4p0Z2nKrYmDi77r114/V4o1HyzeWt8fOeJQkCAEAWQvwA5Ax0hwHgchxxDgWdCUmyzjePr6YueVHDPh2ovPlzp7q/aQESzyeXt47uPq4D24/Y17v/PqAat1a5Yh2q3VJR0RHReunrZzT686eUv3CAju07JR8/b3unKeRc6DUfHwAAyHjED0DOQEsQAJD0TLNRNvHQuldz9RrTVW89k3pLjnq319CjEx60rTi+e32RqtxcQV7enqp9WzXlyZd6EsXIX9hfRcoEanCb8apzWzX1Gt5e6xdv0fvrxsvdw11THv+AvwsAAFkc8QOQ/dASBACkhJYXK775UxVql7niOdn4+7/qf8sI/TH3L7V9qIUWvP+7Ji4cqgZta+vI7mNX3D80KFxb/9xtkyj/LN+uyjeX0919blOfOkP16M3D1GdMZ/4uAABkccQPQPZDSxAALs/Ty0Nubm6KiY5VrebVdGzvyVTPiWnxYbY1woPC5entqcWfrLCPWs2r6sKp4Cue050b9qlD/zvsskm6nDhwWoElCigmKsZ2t/Hy8bR1MoOkAgCArIf4AcieSIIAcEnjFwxVhdplVbJyca3+YZ2ad2msyLBIm9yY+sjbqe5br3VNdRl0jxwOp4LOBGvKo+9q+CcDFFAor04ePKOZT390xc8PORemNYs2acrPw2w5r/Wfpab33azXl4ySu7ub5r+3hAQIAABZDPEDkP25OXPIbcbg4GAFBAQoKChI/v7+mV0dAFlIG4+u6S7DzdMrfft7p29/45eQKydXgOwiq1y3s0o9AGQ9xA9A1pMR123GBAEAAAAAAC6BJAgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEpgiF0COF3Ffg3SX4f7kqXTt73PHgXTXAQAA3DjED0DOREsQAAAAAADgEkiCAAAAAAAAl0ASBIBLad30Js3/6Em7/MB99fX2xO56bUwXFcyf267z8vTQc4/foelju2rC0PaKjYnUP8tnaNW90xW2/3RCOZGngrXy7mkJ68IOntE/z3yhTQM/0/mNB+264K1HteGxD7Wm61uX1cMvj6/e+HOCfgz+RGWrl0pY36LrrZq+arwm/TZGhUoWvO7nAwAAXBnxA5BzkAQB4DLc3KTbbq2iU2dCVCBfbjWuX15PDPtc73/+h3p3vdVu0/meelq9Ya+eHv21hr8yTx4eXqrWqI8Cm1VOUtaRL/+Sf/XiCa8Pzl6pys/eqRoTO+vgnFV2Xa6ygaozo6d8AvNeVpeoiGiNuvcV/fHtmoR1Hp4e6jSonYbcNkZzRn+pHqM6X8ezAQAA0oL4AchZSIIAcBltmlfTstU75XQ6VbSQv/YfOmvX79p7UrWqlrDLt9Qtp9rVSmrGuG66/47acnP3kJdPniTlRB6/ILlJPoX85RMVqx5frlWBbUf16MpdyuvuJi9/X8UEhcszt488fL2SrYsjzqGgM8FJ1pWoVEwHtx1WbEystq7eqXI1Sl+3cwEAANKG+AHIWUiCAHAJ7u5uanVrFf2+aod9ffTEBVWtWNR2f6lfu4zy5va16wsH5tW/O4/pmTFfq3XzqipUMGkCxDj81TqV7NJAnnEOjZqwQI9+uFIBFyLs89tPfSYfHy/FhERedR3z5Mul8OCI/+rswf+iAQDITMQPQM5DhA3AJdzRopqW2FYgF18HhURo3i+b9NqLXdSoXnkdOnbOrg8Ni9SGzQcV53Dq3x1HVap4gSTlRBy7YJ99iwao9OGzKn4iSB4OpzxMdxaHU2UOn1PgvtPyynsxqXIp091lypIX7fOlQs+HKZe/X5LWIgAAIPMQPwA5j2dmVwAAboRyJQuqUvkiatu8mkoWy6+n+rTUjA+X6qelW1W3eimdDwq3223ecUyVyhXWpq1HVLFsYc1fvDlJOWF7Tyn84Bn9O+xbuR06p/5OaZmkopJ2SzIpk+iQSOULyJVsPb6btsA+knN0zwmVqVpSnl6eqtKggvZtuTjAKgAAyBzED0DOQxIEgEt4+5MVCcsfTO5lEyAvDm5nkxUnTwdr6nu/2fc++36tRgy8S317NNfav/fr2MkgbftzlsJijijiyDkVu6e2ak970G4b0/9jvbXnlLyc0gRJfSTFOpxq26i8/pYUfvCs9r75uyKOntdG5wpVVE35u+VPqMf4BcNUoU5ZlaxSXAvfW6xf5yzT99MXauqylxQdGa1JD83MhDMFAADiET8AOY+b04wQmAMEBwcrICBAQUFB8vf3z+zqAMhCmnaYnO4y3J88ddk6v4hoOwaI6QLjcHOTu9Opg6UK6IkZPRTh551kW587DqS7Dosd36S7DCCryCrX7axSDwBZD/EDkPVkxHWbliAAcI1MosMkPDr+8LeKnQjS8aIB+v7+upclQAAAAIgfgKyBJAgApINJeHz2wC2cQwAAQPwAZAPMDgMAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXwJggAHK83L9sTn8hv3mka3dH+msAAABuIOIHIGeiJQgAAAAAAHAJJEEAAAAAAIBLIAkCAAAAAABcAmOCAHBZt3VppCem9FK3Mk+q08C71LR9A0WERmpKv/d07viFVPetcnM5PTKum10uUDRA637ZrB3r9qr9k3coOiJaU/p9oNNHz6VaRq0W1dRzZGd5eHro22nz9eeP6+36QqUC9dGuN/Rk/Rd0YOvhDDxiAACQnWMHg/gBSB+SIABckpubm5p1aGiDjfxFAtTwzjoa1GqsqtQvrx5D22vG0x+luv/ODfv1/N2v2OVnZvbR6gUb9ei4rhrSdoIq31xO3V+4T9MHplyGl4+XOg++V8PvnqDYmNgk7z3wwv3aumpnBh0pAADICbGDQfwApB/dYQC4pJbdGuuPuX/J6XCocOlAHdx+xK7f/fcBVW9cOc3luHu4q2qDCgo6E6KDO44qNiZO29bsUdnqJVPdr/qtVexdn3E/vqAx3z2n/EXy2fVFyxaW0ymdPnQmnUcIAAByUuxgED8A6UcSBIDLcXd3U/NOt2j5t2vt6+P7TqryzeXl5e2peq2qK0/+3Gkuq06Lqtq8cqfy5Mul8ODIhPUe7qn/79XcQSparrBG3feqFr2/WP97sYtd3+2F+/XNlB+v+dgAAEDOjB0M4gcg/UiCAHA5rR5sohXfrZXTNLmQFHw2VAs/WKIJ819Q/Ttq68iu42kuq3mHhvpj7jqFXAhTLn/fhPVxDkey23ca1E5TlryoYuWL6N9VO2xXmE1L/lXpqiXtOuPkwdPpPkYAAJAzYgeD+AHIOIwJAsDllLmphCrULqPbH2yiEhWKqt+rPfTuC59p8ad/qFazmxR0OjjtzVkbVrD9d81y6ZtKyNPLw/br3f9v8gOafjdtgX3kLZBHwz972q6rWLecTuw7ZetUplopTVg0QuVqllbxikX1bKsXFRcbl6HHDwAAsk/sYBA/ABmHJAgAlzNr1FcJyzNWvmSDmGFznlRAYF6dOnxGM5+Zk6Zy6jSvqi2rdtq7QiZRMffNXzX552GKiYzR5L7vp7pvyLlQ/Tl/vaYue0lOh1NTHnlLJ/af0sq5f9n3n5v9pL6Z+iMJEAAAsoCsEDsYxA9A+rk549t0ZXPBwcEKCAhQUFCQ/P39M7s6ALKQtrl6pb8QD4907e4IC0t3FRY7vkl3GUBWkVWu21mlHgCyHuIHIOvJiOs2Y4IAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAlMkQtcR23cu2T785sTZiT5JfyTzK5Cjvk+uufNm74CYmLSXQf+ngByOuKHrIHrzUXED8hpaAkCAAAAAABcAkkQAAAAAADgEugOA2SCKg0q6rFXe9rlAsXy66+fNuqdwXOuuJ+7u7uenzNAgSUK6OSB03qt7zvy8vbUi98/Jy9fLzniHJry8Fs6efD0Fctyc3PTs7P7q1j5InI6nXa/4/tOZsjxIXvwy+OrVxePVtnqpTSw8XAd2HrYrm/R9VZ1fPoeRUVEa3LvmTp95Gyy+1epV06PjL3YxaZA0Xxa9+tmnTl2Xk3vu1kRYZGa8sRsnTtx4Yr1uK1LIz0xpZe6lXlSnQbepabtGygiNFJT+r2nc8evvD8AuIrMjh+IHWAQPyC7oyUIkAl2rtujZ1u9aB//rtyu1fPWpWm/ph0b6vj+k3a/g9sPq2nHWxQXG6fJD7+lIbeN0ZevzFXX5+5LU1kV6pSVl4+XBrcYrc9e/k73D7gznUeF7MYkOUbd+4r++HZNwjoPTw91GtTOfp/mjP5SPUZ1TnH/nRv36/l2k+zj3z93afXCjWrYtpYG3TFBc8bNVY/n771iHUxA3axDQ50+ek75iwSo4Z11NKjVWM0Z+616DG2fYccKADlBZscPxA4wiB+Q3ZEEATLzH6CHu266pZK2/LE9TdubVht7Nx2wy7s37lfNZlUVEx2rs8fO2XWxMXGKi3Wkqawzie7u58mXS0Gng6/pGJB9mTt/QWeS/t1LVCqmg9sOKzYmVltX71S5GqXT9D2uWr+8oiNjdXD7Ubtu9z8HVb1RpSvu27JbY/0x9y85HQ4VLh2og9uPXNz/7wOq3rjyNR8bAORkmRU/EDvAIH5AdkcSBMhEdVvV0JYV22x3lLQ4tP2o3ceo17qWcgfkSnIHv+eozpr7xqI0lRV0JkROh1Oztr2uR1/tpV8/WnaNR4GcxCTEwoMjkgTaV1KnRVVtXrVLx/efUuV65WwT63q3VbNlpcbd3U3NO92i5d+uta9Nd6zKN5e/uH+r6sqTP3cGHBEA5DyZFT8QOyAlxA/ITkiCAJmoeZfGWv7Nn1fcznRPmLLkRRWvWNTeuZn8+xj55vbR+ZP/jZcw6N1+WvDu4jSP61G/bW1FRUbrkWrPaGznKeo39aF0HQuyj/jvk3m+VOj5MOXy90tyt+dKmrevrz/mrVPwuVAtnL1ME+YOUf02NXVkz4lU92v1YBOt+G5tQhAffDZUCz9YognzX1D9O2rryK7j13R8AJDTZVb8QOzg2ogfkFMwMCqQSWwXgkaV9Xq/96647XfTFthHYr3GdNHG37bY5e4jOurEgVNa/vXqq6pD6PnQi88XwpQnH3fdXUVy36d4R/ecUJmqJeXp5akqDSpo35aDV/4eN6ig6U9/bF8v/nyVfdRqWsXeMUxNmZtKqELtMrr9wSYqUaGo+r3aQ+++8JkWf/qHajW7iS5aAJAF4wdiB9dF/ICcgiQIkEnqtKxh+/KmtSmrkb9IPo344hk7mNnG37do66odKlgsv3qN7qKtq3baMret2aXZwz+/Ylkbft2s1j1baOrSl+Tl46l3hlx5dHnkPOMXDLMD3ZWsUlwL31usX+cs0/fTF2rqspcUHRmtSQ/NTHX/Os1v0pbVuxK+x8Nm91NAYF6dOnRWM5/9NNV9Z436KmF5xsqXbAJk2JwnL+5/+IxmPsN3EgCyUvxA7IB4xA/IztycV/N/0CwsODhYAQEBCgoKkr+/f2ZXB7DauF+cPjQ7W+z4JrOrgCz0fXTPmzd9BcTEpLsOv4R/ku4ykPmyynU7q9QDSIz4AVkJ8QOykoy4bjMmCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXwBS5QBbmtqREusvweIR/5rgo9vab030q7py+LF37/1YjnbPLAACuiPgBGYn4ATkNLUEAAAAAAIBLIAkCAAAAAABcAkkQAAAAAADgEhgsALhB/PL46tXFo1W2eikNbDxcB7YetusDSxTQwDcfUy5/P21a9q8+HfutXR/rjNHGJ75U2IFzavhWV+UpF2jXR5wM1qpeH6vRuw8krHM6nPrz4U9V8v5aKt2hto79vE37Pv1LvoF55HsqrxqV66gJH/dTmUpFNKjzDB3cdUIdH2mhJnfWVGRYlKY+/5XOnQq2Zbm5uemdn57Vgs9Wa/4nq/h+5FCtWlbVU/3b6MFeb2vsix3l7eUph8OhV6cs0smTQSpTuqCGDLpT7u7umv3RCv21bpf+2fiBVtc/rv5f3KKilfIq6ESk5o3bpsiwWFVoWECt+1fUvLHbdHJfqP2Mw5uDNHxJC8XFOvXFs//IKSnU6aeaaiR3t6Q5+CJlCmnmX6/o4P//uxjX9TUFnbn4nQQAV3Y18YONHbRCYXeFpit28AnMozpqJ7/cPsQPSIL4ATkBSRDgBomKiNaoe19R30m9kqw3r6f3f19nj51Lst5dHqo78T7temdlkvUHvtigAlWL6M6F/+rmqDidKOavN/P5ybdw0gEnS3eqa4MaMzBqVGSMXnxslh4Z2s6+lz8wrxq0rKohXWaqcq1S6j6gtWaO/t6+d9u9dXTq+PnrdBaQFbi5SS2a3aRTp4MVF+fQpMkLdeZsqOrfXFYPdG2o6TMW69GHW9iEyPnzYXp1Qlet37BPNes8pMj8HyaUs2jKTrUfXU0BRXzlFRareu/vU1uHUxeaBOr32wvr83HblSuft/746IBq3VVMjbqV0jvVD+qMTqiwil9Wr83Lt2lc16k3+GwAQM6JH0zsUEdNtbvFnstih3w1isk7MkbdPl+noseDNS8sSv8E5k42drAeEfEDkiB+QE5BEgS4QRxxjsvubHt4eqhI2cLqN+V/ylc4QB+N+kLb/txl3zN3yj3y5UqyfcTxIHnGOXTb3jO6f8sxVXd3t3fvv/L1kqNfE0U6/tv2yA+bdXLpLpUJratieW5S0LmwhPcKl8ivQ7tP2OU9W4/qmVe6XvxMdzc1vbu2/lj4j3z8vK/n6UAmur1VdS3/Y4e6dm6omJg4mwAxYmMdiosz7TWkggXy6OjRi8mw4OBI5cuXR8HBHor8/zLiYhw6fyxCCyfvVPipKL1+IlLNj0fI6e4mN4dTf3x6UHUeLme3LVwht07s+v/PUIy8lfx3q3qTKnpt+Vj9u3K7Zo/44gacCQDIWfGDiR285XNZ7GB+vOYumFvDXv5ZrU+EKFbSew6nni2YW580LHNZ7FCqfS2VUPWLn038gP9H/ICcgjFBgEwUEJhX5WqV1nvPfayJPabriWl9Ut1+/xfr9Xgeb+UOi5aHUzYh8qVT6hUZo3p/H0nYrlDTCmo8u6fqvnK/DgRtUGTsxR+g8Y4fOqPKNUvJy9tDdZtUUl5/P7u+5f31tHLRP3I4L/4QRs5jEl23tbhJS5dtT7Lew8Nd/+vZRN/PXX9xhdt/74WFRco/r2+S7cMuxOj4rlDd82wVvVovn146GiF3h+QR67TPv56JVo/z0XbbEtUD9PeCY5p2/yqFKVgBKnhZvc4dP6/elZ7S4BajbUDftEPD63L8AOBq8YOJHcp0u1mlD56zLUA8HE595XDK3P4IPBemWv8cvSx2OPjN35fFDgbxg+sifkBOQhIEuM46DWqnKUtetM+XCr0QrqO7juvM0XM6f/KC4mLj5O6R/D/L8KMX7HON0Gg5//8HapykryR1dXNTwIWIhG298vjIzd1Nnrm8VcC3lMJikna1CT4froVf/KnxH/VV/RY36cj+0/bi1vyeOlq+YFPGngBkKW1ur65ly3fo0jyXGf9j/oK/dez4xe+ZM9EGefL4Kjgkvg3IRX55PRVYJpcCivqq/IUYedhWHheZdJyHm+x6448P96tZ77Ia9EMTBaqYjmrfZfWKiY5VZHjUxe2/W6MKdS62IgEAV5UR8UN87OBX1F9+ETFyurklxA4PmP/Xy015gyIvjx3qlLwsdjCIH1wX8QNyErrDANfZd9MW2EdyoiOjFXohTLn8c8kRGycvb0/b9DQ5IXvP2EFSXzgfrvNO2Z+Rn0k6Kek+h1NbD53XhR82K1+1ospVMp88c/vIGefQhajjKuX///17E/ntu/X2UfOWCgo6G6r8hfIqX2AevTTrERUsEiAPd3dt//tAhp8PZK4yZQJVsWIRG8yUKJFf/R+/XcHBETpxIkhLl+9I2O7cuTD7vhkTJG9eX7tNYl6+HjYREhkSo+OFfRST6IJihvbtLOlCiYstjIxcAV722VNeitHFZMelA/9FhF4MxGs2r6ZD2/9r2QQArigj4of42GHj8/MUdy5cTzqc+vz/Y4d7JB11OnX26AWV3nkySewQtP2ESnvWTfaziR9cE/EDchKSIMANNH7BMFWoU1YlqxTXwvcW69c5y/ThyC/08vyh8vTy0Eejv0yy/cah8xSy54zCD59XyXtrqsEbXeQbES3vLrM0KjxaJdzdtdbp1OHS+dWhQ23liXPKv0oR7Z2zRmfXHrR384vnrqpcXgEaO+sRla9aXCXLFdKiL9eofvMqCiiQR6eOntebY75XdFSsnm4/3X5u60715ZfLR3v+vdhEFjnHex8sS1h+582H9NU3a/Xlp0/o361HVbdOGW3ddlQfzF5uHy88e7edHebDOX/Y7Tf//aFi3M/qzIEwNexSSm2frqSP+m/U7GiHXi3mK8fJSDsmyHexTr1dJpd+7V7a7te4e2l9PfxfrfjogC7I084Oc6kaTW9S73EPKio8Sif2n9JHo5L+WwAAV3Y18cPfzpUKWR+SJHYwto//WaO3HVfJEyFa4+YmN6dT0/Ln0pyudS+LHYreXkW5fgqw+xE/wCB+QE7i5kzc5jkbCw4OVkBAgIKCguTv75/Z1QGsNu4XA49r5bakRLLrTSLk/rn/2L69ZnaYHzrUVmQKA5ma2WHS46e9U9K1P7KOlm1eSXcZd07/L4mSmJ0d5vNDync0wrYA2di9tGJyX/7d+61G0lmMrsVixzfpLgOZL6tct7NKPYDEiB+QlRA/ICvJiOs2LUGAbMgkPL7q3iCzqwEkMAmPtY+V54wAQBZG/ICshvgBmYGBUQEAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXwMCowHXknitX+vbvHpvuOjhjItJdBnIGz6Wb0l3GkluKpmt/N5/0f6cBIKcjfkBWQvyAnIaWIAAAAAAAwCWQBAEAAAAAAC6B7jDADVKkdKDeWDFGB7cfta/H93pTXt6eGjDtIeXy99U/K3bos4nzLtvPL7ePJnz1lMpUKaZB7abo4M7jmvT9M3I6nPL09tAbz31h19VuUlm9h96r2Ng4fTxpobb8uTtJGRO/G6QyNxXTM3e+qoM7jql5+/rq0Pd2RUVGa8qAj3Tm2HlVb1RRj73Y2Za9fslWfTZlAd+PHKxSvXJ64rWH5HQ4dP5kkCb2mqmmHRqq49N3KSoiWpP7vK3TR86mWkatpjep+wv3ycPTXd/P/EUdnmxr1/v4esnT21NPNh1zxXrc1rWx+k/ppa6l+2vq4pFy/P93e/qTs3Vg25EMO14AyI6IH5DVED8guyMJAtxAW1bu1Ms9Zya8HvrhE5rxzBydPX4+xX2iImP04v/e0SOj2iesG9b1DcXFOlSzUUV16NtSrw/53CZARvZ4S7ExcRr36RN6vtP0JGWM6TFTj77Yyb42P1g7Pt5az947WZXrllX3IffojSGfqsuTd2jKgA91ZM9JTV3wnOa99/t1OxfIfGeOntOwuybYhMfDLz+gJvfXV6dB92hwizGq0qCCeozoqNefeD/F/b18vNRp4J0a2XGq/d4Zfy782z636tZYxcoVvmId3Nzc1KxDA50+cs6+fv6uiYqLjVPNpjep41N36rUnPsiw4wWA7Ir4AVkJ8QOyO7rDADdQtUaVNPXX4eozprM8PD3s3Z2+Ex/QqwtfULVbKia7jyPOoaBzoUnWmQSIkSuvrw5sP2aX3T3cFRYcYX/QmmX/ArmTlnH2vzJKlC+igzuP2R+u2/7aq3JVS9j1B3cdV25/P5skiYtzKDoq5rqcB2QNpvWH+b4YsTGxKlm5mA5uPWy/F1tX71K5mqVS3d98Z6MjovXS189o9OdPKX/hgIT3mndooD/mrrtiHVp1u9VuZ1qjGCYBYpjv4f6th9N5hACQMxA/ICshfkB2RxIEuEHOnbigPrWe05A7JiigkL+ad2yo8jVK6f3hX+qVPu/o8Vd7pLmsgAJ5NOWHQXpyYjdtWbvHrouJiVWhEvmVLzCv7TpjfkSmJHeAn8JDIhNeu3u42ec/F23SyA8f1/urx2rzql2KiWImD1dQqFRB1bu9pv5dtVPhwf/NJmSSaanJX9hfRcoEakzX17Xow2XqNfxiayW/PL4KLFFAh3ZeTNClxN3dTc073aLl36xJWBcQmFfTlozWU9N72zufAODqiB+QVRE/ILsiCQLcIDHRsYoKv3jXfeUP61WhVmkd2XPCjsVx/lSQvQN+pR+d8UzLkGfvn6aXH/1AvYfeZ9e9N/o7DZ7WU09O6KoDO47pwumQFPcPvRBuW5HEc8Q57fNjYzvbLjKP3DJK5aqVUKlK6ZsOFVlfrrx+GjrnSU1+5B1dOBWkXImSZ6YFUWpCg8K19c/dtuXIP8u3q/RNxe36RnfX1ZpFV56O9/YHm2rFd2vldF78/hlBZ0I0qNVYjX1wuvq81DVdxwYAOQHxA7Ii4gdkZyRBgBvE3B2PV7NJFR3YekRhQeH2R6dPLm87iOSVfnQaJlFixlEwwkIiFPn/iZVd/xzSsK4zNGPolzp7IkgRYVEplnFs/ymVrlxMnl4eqtawgvb//+CTZkBU06XG/CiNCI1MtTUJsj/TEmPoJwP06cvf6+ju4zq656TKVCtpvxfVb62sfZsPpbr/zg37EhIfFWqX0fEDpxN1hfnrip9fumpxte7RVON/eF4lKhbV45N6/PfdDjLf7f9aKwGAqyJ+QFZD/IDsjoFRgRukeuPK6j26k6IionTiwBnNGfedju07qXHfDrLjg8wZ932K+4795AmVr15SJSsU0V+//at6LW6yM2iYpMWbI76223QZ0EY3t6hqkyJvj/zm8jK+GKAKNUqpZIWiWvTxCs1793dN/uFZO+7H5Cc/tNt8NnmBxn3xlE3GmFYqOzbsv45nBJmtRZfG9ntp7uaYQVDnv7NY309fpKlLxyg6MkaTer+V6v4h58Jsi48pPw+z38fX+s+ywXqhkgXsDERXMmvkVwnLM1eO1TevL9LkX4YnfLdnPvNRhhwnAGRnxA/IaogfkN25ORO3Q87GgoODFRAQoKCgIPn7+2d2dQCrbZ6H0nUm3P3zpvtMOmPSN7jpz6ffTXcdkDW08Xwg3WW4+/3XoulaOGPTP87MrxGfprsMZL6sct3OKvUAEiN+QFZC/ICsJCOu23SHAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASmCIXuI5+CZ3D+UWWsTj2y8yuAgAgDYgfkJUQPyCnoSUIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAlkAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXAJJEAAAAAAA4BJIggAAAAAAAJdAEgQAAAAAALgEkiAAAAAAAMAleCqHcDqd9jk4ODizqwIAAK4g/nodf/3OLMQPAAC4VvyQY5IgISEh9rlUqVKZXRUAAHAV1++AgIBMO1/EDwAAuFb84ObM7FswGcThcOjYsWPKmzev3NzcMrs6AAAgFSb8MAFM8eLF5e6eeb1ziR8AAHCt+CHHJEEAAAAAAABSw8CoAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCHIcp9Opvn37qkCBAnJzc9OmTZsyu0rAdWW+5/PmzeMsA0AaECcAKbvtttv0zDPPcIqQo5EEQY7z888/66OPPtKCBQt0/Phx1ahRQ9nFn3/+qVatWil37tzKly+fvRBFRETY95YtW2Z/7Cb3WLduXUIZyb3/zjvvJLx/4MCBZLcx5+1G+fvvv9WlSxcVKVJEvr6+qly5sh577DHt2rUr2Trmz59fzZs31/Lly694kTbJALPP1TDfk+7du6tKlSpyd3dPtlzznUruvEVGRibZ7q233lK5cuXscd188836448/krwfGhqqAQMGqGTJkvLz81PVqlX19ttvK6uI/55duHAhs6sCANcFcUL2jxNSu1bVqVNHL774YsLrsmXLJhyDue6a1127dtWSJUuS/WwTd5m4w9xMi4/BrtbTTz9tYwAfHx9bn0ul9RybuMeUY85B+fLlk/yd4n333XeqVq2a/SzzPHfuXGUl3KhBVkQSBDnO3r17VaxYMd16660qWrSoPD09L9smOjpaWTEBcuedd+qOO+7QX3/9ZRMb5sey+VFumOMxP9YTPx599FF7Ma9fv36Ssj788MMk2z300EOXfd5vv/2WZBuTfLkRTHKqUaNGioqK0meffabt27frk08+UUBAgEaNGpVsHU0Q4O/vr7vvvlv79+/P8DqZuhQqVEgjRoxQ7dq1U9zO1OHSv4EJTOJ99dVXNoFiyjEBXLNmzXTXXXfp0KFDCdsMGjTIBjmffvqpPXbz+qmnntIPP/ygnHanNTY2NrOrAQCXIU7IOXFCWo0dO9Yew86dO/Xxxx/bG02tW7fW+PHjk00qmBtoJqHw/fffX/M18OGHH1a3bt1S3S61c2ziHRP3mFjCxBTDhw/XwIEDbf0Sx47mM3r16qV//vnHPpsEz9q1a5XTxMTEZHYVkJM4gRzkoYcecpqvdfyjTJkydn2LFi2cTz75pHPQoEHOggULOps3b27XT5061VmjRg1nrly5nCVLlnQ+8cQTzpCQkITyPvzwQ2dAQIBz/vz5zsqVKzv9/PycnTp1coaGhjo/+ugjW36+fPmcAwYMcMbGxibsFxUV5XzuueecxYsXt2U3bNjQuXTp0lTrfssttzhHjhyZ5mONjo52Fi5c2Dl27Ngk681xz507N8X99u/fb7f5+++/nTdaWFiYMzAw0Nm+fftk3z9//nyKdTxy5Ihd98477yT8TZ9++unLyjDHnp7/taVUbvx3ITXm7/z4448nWXfTTTc5hw4dmvC6evXql/3N6tWrd8W//axZs5zVqlVzent7O4sWLWq/z8n9zc33zLyOP5eGOY9mnTmvxoEDB5zt2rWz313z/TTlLly4MOG8J36Yf1OGw+Fwvvrqq85y5co5fX19nbVq1XJ+8803CZ8R/7k///yz8+abb3Z6eXk5lyxZ4ty0aZPztttuc+bJk8eZN29ee6zr1q1L9VgB4HohTsgZcUJy17p4tWvXdo4ZMybhtYnVpk2bdtl2o0ePdrq7uzt37NiRZL25ZplY4+2333a2bNkyXcdj6mHqcy3n+Pnnn7cxRGL9+vVzNmrUKOF1165dnXfeeWeSbdq2bet84IEHUq3XypUrbSxs4loTC9xxxx3Oc+fOJRsHJfd9MfGQiYviY14Tk5jYxMfHx57vCRMm2PfMcnJxufHjjz/amMDsY2KLF1980RkTE5Pkc83f4L777rOxivl7mTp2797dfkdMLFKxYkXn7NmzUz1WIDm0BEGOMn36dJvtN10NTEY9cTeROXPm2FYhq1at0rvvvmvXmVYWb7zxhv7991/7vmka+fzzzycpMzw83G7z5Zdf2jv4pglmx44dtWjRIvswdyfee+89ffvttwn79OnTx36O2Wfz5s22Sadp5bF79+5k633q1CmbtS9cuLBt8WGaf7Zo0UIrV65M8Vh//PFHnTlzRr17977sPdOCJDAwUA0aNLBNJx0Ox2Xb3HffffbzmjRpkqTu19Mvv/xi63zpOY5n7sykJFeuXNd0JyC+yan5u6WX6cpSpkwZ+/1q166dvTOTuHXRhg0bbEuexMzr1atXJ7xu2rSp/dsdPXrU3ilaunSpbd7btm3bFD/XdJd58skn7Vg3W7ZssftXrFjxmo/DlGXusK1YscKW9+qrrypPnjwqVapUwh0mc7fM/Bsy/6aMkSNH2juHpi5bt261LVh69uyZpIuSYf62EydOtHfuatWqpR49etjzZf4tmvMzdOhQeXl5XXPdASA9iBNybpxwLV1WzHU4cUtM00rItK4wrSnMw1y/9+3bl2Q/0wI3cXeb9EjtHJt6XBpTmFhh/fr1CbFQStskjjsuZcbKu/3221W9enW7v4k17733XsXFxV3TMZgY2cQlX3/9tY0dTEtXc46M+Dg8vuVR/GvzdzYxhGnZsm3bNhuXm27Hl7bMGTNmjO6//34bq5iWNaYlkNn+p59+snGGiUnM9xi4asmmRoBszGT7E2ea47PaderUueK+X3/9tW0pEs9kuc0/kz179iTJwpuMdOIWIybrbtYbZls3Nzfn0aNHk5R9++23O4cNG5bs5/7555/2cwoUKGAz2hs3bnQ+88wz9q7/rl27kt3nrrvuso9LjRs3zrl69Wp7d2HKlCm2rmZdvNOnTztfe+0159q1a+0d+VGjRtk7IZ988onzejMtCcxxxt9tSMmld0hMyxtzfj08PJybN2++qpYgpgVJlSpV7PGmRUrlmr+ROUemZcOKFStsiyBzByX+72P+3uZzV61alWS/8ePH21ZE8cwdk//97392W09PT/s3/vjjj1Otk2lRNGLEiBTfv9qWIDVr1rR3XJKT3P7m/Js7LuZ7ldgjjzzifPDBB5PsN2/evCTbmNYfptUUAGQVxAnZP07IiJYgRpEiRWwr4HjDhw9P0grl/vvvv+z626pVK+eMGTPS1RIkLee4UqVKNoZIzMQY5riPHTtmX5tWl5999lmSbcxrE1ukxFy3mzRpkuL7V9sS5KmnnrLnxLQYTU5y+zdr1iyhtUg8c+zFihVLsp+JhRO79957nX369Emx7kBaXT5YApBDXTpuhmHuwk+YMMFmlYODg+0YBmagy7CwMDs4aXwLhAoVKiTsY1ppmAy3uXOeeJ1pzWFs3LjR3lkwg3glZu68FyxYMNm6xd+B6devn21FYtStW1e///67Zs+ebe+sJ3bkyBGbRTdZ90uZO/bx4gfjMq1j4tebjLm5i5/4vJw/f16TJk2yWfnkmHEtLh3gMzWm/6rJ0l/q4jUt7UyrGNNax7TGMeO8mLsENWvWvKoySpQooR07dii9TP9k84hn7trUq1dPM2bMsHdB4l06KKs55sTrzLZr1qyxd01MqxLTGqN///72+Ez/5EuZ79WxY8fsXZuMYu68PPHEE/r111/tZ3bq1Mm22kiJ+fdh/l20adMmyXrT+sV8T1P7dzZ48GA7do1pMWU+y7SKSvzvCQCyCuKE7BcnpFfia7RpCWFaBce3gDTM8Zpz8dJLL8nDw8OuM7FZeqX1HCcXU1y6/kpxR3ItQcy1OKOYFskmPjCDy5tWz6al7KWtUy5lWoaaViGJW36Y829iDRPzxbf+vfTfpIldTMxiYm3zGe3bt7exInC1SILAZcQnNeIdPHjQDjj1+OOPa9y4cXYUcNMk8JFHHknS5eLSpvvmwpLcuvhEhnk2F0rzP/j4C2a8xImTxMwPYMMMwpWYmTkk8aCa8UyzQpNQMc0or8T8cDcJnpMnT9pkTUrbfPDBBymWYd67mhHSzejryYlPDJmkROPGja9Yjhlo1JwT0/z10gSSGaQ0KCjosn3MSPHmvevNJGdMM+L4Lk4moDF/7xMnTlyWxIg/7+YcmoHNzMjt99xzj11nkg8mIJkyZUqySZCUzmVq9bo0kLy0C5FJSpjmsgsXLrSJEJNkmzp1qh2gNTnx322zvUkqJWZGo0/t35lpMmxm3jH7moDXNG013cQ6dOhwVccFANcbcUL2iRPir/MmDri0i4yJA8wgqldy9uxZnT592s7oZpibS6ar6qWDmZof5+ZaaRI919Ol59gM7p9cTGG6dsfHRCltk9Lf8VriChPjXpqcShxXmBtCZhBXc403A72abkQmnkmtC5WJK0xiyXQvv1TiAecv/Tdp/gYmfjcxhfksc4PIdPE1MRRwNUiCwGWZPpWm5Yf58Rf/wzG5lhVXy9wZNxdMcxEydzrSwrQsKV68uO1LmZgZK+LSi665EJkkyP/+9780ja1gxq0wF5TU+tGabeITMcm59IfvtTJZe5MsMHc6kpvCzQQuietpxqhIqdXATTfdlOxdJHNnwdyNuN7M38EkL+Jbpnh7e9tp7BYvXpzkB755bfqzxgcN5hH/fYtnkifJ9cc28ubNa78f5s5Ty5Ytr1gvM8uNYfremin+DFPPS5lzaxKA5jFs2DC9//77NglijsNI3Dc4fuo9k5AzY9VcLRPUmoe56/Xggw/a7y9JEABZHXFC1o0TKlWqZK+l5ppvWlXGM9c+k8hISxxgWnyYMkxrAmPWrFl64IEH7Axvib3yyiv2veudBLn0HJsk0Pz585NsY5IxpnVEfPxntjFxRuJWJWab1FpHmJsvJqYwSYi0MHGFOa/xzM0f01rj0qSUSR6ZR+fOnW2LkHPnztkbjKaul443YhInJua9lvHNTH1M6xPzMHH2c889RxIEV40kCFyW+XFtkiCmO4MZEMoMZJrc/OtXy/zYM4NBmiSFSbCYpIgZ5MsMump+MJvWJ8ll2c3/xM1dcjNFq+nGYppkmjshl2bSTTkm425arFzKXCzNHQFzUTSZftPdx1zMzYCa8XfsTbnmgmTqZS7+Zh/TRcMMjnm9mYy+ucthmmGaViymW4a5AJrzYxJQ5ke2aSWQFqYLycyZMxMGDDXHawIBE6iYrhfxTDBk7hSYKfEaNmyYYnnxiQIz+Km5M2Rem4RAfOscEyyYuzQm8DIta8w5M9u8+eabSbp+mOnpTIBi/gZmwFxzTCbREB8kmCSC+Vub+prAzQwsaur22muvpVg305rClGEGTzNBWEhIiP2+Jtdyw5xPk+Aw+7z88ss2WDHfw8TMNL6mHPNdNc1vzXfKtDoyTJ3M99FMUWi+q6aeJhHz7LPP2iDLJGvM4K7mHJiB10zrpuSmVjTMXUFzrCYgMnfaTDcuE7CapqwAkNURJ2TdOMFcl0wX4iFDhtiWESZ2Ml1HTcxjrmeXdscw100TH5kbESaGMoN3ms8xLSFN+ea6b47TdFU10+MmZq5xpvWm2cb8ADcxhUnkm8FlU7Jnzx4bT5jPNNfC+BjDxBQmtkhLLGau+ybOMbHFY489ZgcxNTHOF198kWRw1+bNm9v9zA0XM8iraSGR2sD65saHiUdNHGU+w9THxIvmnCc3yKiZttfUw8RAJgZ44YUXktyEmzZtmk3emNjVHMs333xjW6jE39SKv5FjuhGbWNTcoBk9erTtNmPiFfO5Zj8zkYAZANXELikx+5kbTmZQV9PN3MQq8fELcFXSPHoIkM0HPEtusEszKJUZhMkMcGkGNzUDVCYeaCu5aVGTG+TKTLlnBs9KPH2tmcqrbNmydtAqM21Yhw4dEgb1TMnEiRPtVL1mkLLGjRs7//jjj2QHtLr11luT3f+nn36yA8Ca6UhNGWb639dffz3JlGNmkMqqVava982glWY60xsx2FliZhCwjh07OgsVKmSnRjNTnPXt29e5e/fuq5qeb/369fbvZqYK9vf3d9avX9/5xRdfJNkmvqwrTVF86dSwl07lZgbnKl26tB1szNTbTCd36UChxptvvmn3M9uZqd+WL1+e5P3jx487e/fubQc7NYONmkFbzVTNKQ0oFs9M12e2Nd8n8501A5GlNOiYmfrODH5qyjeDj5mpbBMPjGqmdK5QoYI99+ZYevXq5Txz5kzC/mYKX/OdNQP8Jp4id/r06Ql1MPuZcx9/fMkNUmcGgTXT9JUqVcqeD3PM5rMjIiJSPVYAuJ6IE7J/nGBERkba65Wpq4njzLXXXF/NdTaxxNO0mmuRuZabqWXNNO7xzACxZqpYE79dypwbM3C9uVbHl5d44NXkmLgzubgi/jqc1nO8bNkyZ926dW29TUxppoy9lLnGx1+bzZS633333RXPrynXxJLm3JrjNtfz+Ov3pTGzGfjdxDy5c+e2g7UuWrQoycCo7733no09zfsmFjMTAZgB/hNPhWv+fmYw+MRx1c8//2zrYP52Zr+GDRvaslIbUNUM4Bv/9zZ/ExN779u374rHC1zKzfzn6tImAAAAAAAA2U/SjukAAAAAAAA5FEkQAAAAAADgEkiCAAAAAAAAl0ASBAAAAAAAuASSIAAAAAAAwCWQBAEAAAAAAC7BU9mIw+HQsWPHlDdvXrm5uWV2dQAAwHXgdDoVEhKi4sWLy909ffdriB0AAHANzjTGD9kqCWISIKVKlcrsagAAgBvg8OHDKlmyZLrKIHYAAMC1HL5C/JCtkiCmBYjx0KL75Z3b65rL2Xevb7rr8v3hN9NdBgAAuFxwcLC96RF/3U8PYgcAAFxDcBrjh2yVBInvAmMSIN55rj0J4unmne66+Pv7p7sMAACQsozo+krsAACAa3G7QvzAwKgAAAAAAMAlZJuWIGaAk1atWtnlc/uCVLBSPv005A/FRsfJ3d1NrV68Rf7F89j3nQ6nvui6SDW6VFKtbpUVHR6jxSP/VNSFKJVpVkIBujlJ2bWaVtGDz90rD093ff/mrypevrCa3nuzIsKiNLX/bJ07cSFTjhkAAKQ/fjA+vHOuOn90h/xL5Lmm+CFPZBmV962dpGziBwAAsp9skwTx8/PT119/rQoVKtjX7h4XA5c8hXPp0J/HtXn2Nr1UIo8KHgvV9yEx8i/kl7Dvtrl7Va5ZCVXrUEHzByyVjyNMvu657XtePp7qOOAOjeo8TbExccpf2F/tH2+twW0nqnK9cur+XDvNHPJpph03AABIX/xglGtRMl3xw5e3rFBxR0XiBwAAsrls0x3G09NTgYGBCa89vD1sAGP4xDlUf8lh3fvWZjX4Ya/2Lj6kgfuD5RkdZ98/sfmMSjUqapdL3lJUF+JOJZRT7ZaKio6I0UtfDtSoT59UyUpFdXDHMfvenn8OqnqjSjf4SAEAQEbGD4lda/wQ6Fmc+AEAgBwg27QESUlcjEM7Jm3Q98HRcndKX0nqKinqTIQqbjwt9aqq6JCYhIFUffJ464IzKmH//IX8VbRMoG35UadFVd3erbHKVC0hL29P1Wp2k/LkuxgoAQCAnONq4wczqHoM8QMAANletmkJkpJl4/9S5xJ5VM7DTea+jQliHjD9et2k3EEXkx0+/t6KDo2xy1Eh0fJy80nYPzQoXP+u2W27wvyzYodKVCyqRR8u1/i5g9WgTU0d2XMy044NAABkjfghxkn8AABATpCtkyDrP/jXDmZWp2FRuTukE5JMyuIeSa87pG8PhejU9nMqUrOgDq8x70pH/jqhfB6FE8rYuWG/ylQpbpcr1CqtEwdOa/Hnq/T8PZO0esFG/bNie6YdHwAAyBrxw9nYY8QPAADkANmqO0znzp3t8x+TN6hcy5Ja996/KlqnkAbEOfSbv7emB0drjbtsQDO9oK/m96iiwlULKF/pvFo86k9tn79PZZuVkO+2i4OiGiHnw7Tmp02avOgFOR0Ovfbkhxo6q58CAvPq1OGzevNZBkUFACC7O7rupIKPhqps8xLXFD8U8CiTMCiqQfwAAED25OZ0Op3KJoKDgxUQEKDHlndO6KMbzzs8Ri2+2m1Hdz9bPI+Wd6uk6FxJt4m3p9V/I79fq58vzEp3GQAAIOXrfVBQkPz9/a9b7HA18QOxAwAAOSN+yFYtQVJjApbFfapldjUAAEA2QvwAAIBrydZjggAAAAAAAKQVSRAAAAAAAOASSIIAAAAAAACXkC3HBPl5RzW5+/le8/6VQv/J0PoAAICsjdgBAAAYtAQBAAAAAAAugSQIAAAAAABwCSRBAAAAAACASyAJAgAAAAAAXEK2HBjV6XDo9NtfKe58sDwD86tAz3Y6PfNzOWNiJXc3BT7aWZ6F8uvcp/MVffC4nNEx8r+rmXI3qpVseX55fPXqryNVtlpJDWwyUkd2HdcrP4+w73n7ecvLy0NPNBh2g48SAABkFGIHAACQbZMgEX/vkFehAir0RDcFLVyhiM27VPDRTvIsEKCILbsVtGiFCj50v/I/cLfcPD3kiIzSiZffSzEJEhURrVH3vaq+r/a0r2Nj4vTs7WPt8u3dm6pYhSI39PgAAEDGInYAAADZtjtM7Onz8ipTzC57lymuqF0HbALEcPNwtw+77Olhn51R0fIqXijF8hxxDgWdCUn2veadG2nFt2uuw1EAAIAbhdgBAABk2ySIV7FARW7ba5cjt+6RIzzSLjtj43ThhyXK2+bWhG1Nt5ljI96QX41KV/05pptMoZIFdWj70QysPQAAuNGIHQAAQLZNgvjWrCw3T0+dmPi+beXhEZDHrj/74VzlbXmLvIoUTNjWdJkp/upgBc1fZvsDX43G996sPxdsyPD6AwCAG4vYAQAAZNsxQdzc3VSgxz12+cL3v8m3ekXbAsQMhpp43A8zUKqbl6fcvb3k7ucjN/ery/mYrjAfjvoqw+sPAABuLGIHAACQbZMgcUGhOjXtE5vUMAkQz8IFFPTKB/KpVEYntu2TT8XSyt+1rc6YGWRCw6W4OAXc3yrVMsfPf0EVapdRySrFtPC93/XH92tVuFSgDm47csOOCwAAXB/EDgAAwHBzOp3O7HIqgoODFRAQoFLvjpa7n+81l1Opzz/prsvi2C/TXQYAAEj5eh8UFCR/f/90nSJiBwAAXENwGuOHbDkmCAAAAAAAwNUiCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXkC0HRs2IgdIAAIDrDIxK7AAAQM7GwKgAAAAAAACJ0B0GAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEsgCQIAAAAAAFwCSRAAAAAAAOASSIIAAAAAAACXQBIEAAAAAAC4BJIgAAAAAADAJZAEAQAAAAAALoEkCAAAAAAAcAkkQQAAAAAAgEvItCRIZGRkZn00AAAAAABwQTcsCXLq1ClNnDhRjRs3lp+fn3Lnzm2fzevx48fr5MmTN6oqAAAAAADABd2QJMioUaNUq1Yt7dq1S08++aRWrVqlnTt32mfzeu/evapdu7bdDgAAAAAA4Hrw1A1gWnyYRIdp/XGpevXqqWfPngoLC9Mbb7xxI6oDAAAAAABckJvT6XQqmwgODlZAQICCgoLk7++f2dUBAABZ/HpP7AAAgGsITmP8cENagqRUwdWrV9vlW2+9laQGAAAAAAC4rm5YEuSxxx6z43/UqVNH69ev1z333CMfHx/7XnR0tBYtWmS7xgAAAAAAAGTr2WHmzp2r6tWr2+UhQ4Zo9OjROnTokH28+OKLGjhw4I2qCgAAAAAAcEE3LAliWnvEDz+ybds29evXL+G9vn37asuWLTeqKgAAAAAAwAXdsCSIGffj888/t8s1atSwXWLibdiwQQULFrxRVQEAAAAAAC7oho0J8tprr6lVq1b67bff7Lggbdu2Vfv27eXm5qZ58+ZpxowZN6oqAAAAAADABd2wliDVqlXT33//reLFi9tZYQoXLqzNmzfb9xYuXKhevXrdqKoAAAAAAAAXdEOnyC1WrJgmTZp0Iz8SAAAAAADgxidBjKioKO3evVvBwcF2HJAqVarc6CoAAAAAAAAXdNXdYSIjIxUbG5tk6tv58+enaT8zI0z+/PlVu3ZtNWvWzHaRKVGihGbNmnX1NQcAAAAAALieLUHatGmjyZMnq1GjRnrppZf0zjvvyNPTUxs3btSYMWNS3O/JJ5/U0aNH9fPPPysuLk4TJ07U/fffr/Lly2vw4MFyd3dXnz59rrY6AAAAAAAAaeLmdDqdugqmC8upU6fk4eFhExgLFixQ3rx51aRJEx06dCjF/QoUKKD9+/crICDAvj579qzq169v15kBUx988EHt2LEj1c82XWjM/kFBQfL397+aagMAgGwiI6/3xA4AALiG4DTGD1fdEsS04jDT2u7Zs0cOh8N2aTHOnz+f6n4+Pj52v8RiYmLsc926dXXkyJGrrQoAAAAAAECaXXUSpEGDBhowYICOHz+ue+65x647fPiw8uXLl+p+putL165dNWzYMJs8Md1h7rrrLvueaVlixgoBAAAAAADIMgOjvv/++7Z5iWlmYsYEMdasWaMePXqkut/UqVNVpkwZmwgxDzMg6muvvWbfCw8P18yZM6/1GAAAAAAAADJ+TJDMRL9eAAByPsYEAQAA1yt+uOqWIMaHH35oZ4mpVauWfb18+XJ9/fXXV11ORESEDh48eC1VAAAAAAAAuCpXnQQZP368pk2bpm7duiXMBlOsWDE7bW5qzLghJnFSrlw5zZo1S6tWrVLx4sXtDDNmcNUDBw5cbVUAAAAAAACuXxLkgw8+0KJFi/Too48mzPZSsWJF7d27N9X9Bg0aZGeBMeOB9O/f3yZBdu/ebZMjJgkyYsSIq60KAAAAAADA9RsTpHDhwnZmGA8PDxUoUEDnzp1TVFSUypYta9entp+ZBtdMsZs7d26dOXPG7m+cOHFC9evXv+I0uYwJAgBAzseYIAAAIMuMCdKoUSO9+eabSdbNnj1bTZo0SXW/6OhoeXt7y8/Pz1YsPgFiFC1a1FYUAAAAAADgevG82h1ef/113X777ZozZ45CQ0N166236uTJk/rtt99S3c8kOkyrEZP8WLBgQZL3jh49ahMjAAAAAAAAWSYJYgYy3b59u+bPn29ndilVqpTatWtnu7ikZujQoQoLC7NJkEtbjSxevFidO3e++toDAAAAAABcrzFBMhNjggAAkPMxJggAALhe8cNVtwQJCQmxU+Ru2LDBLie2ZMmSq64oAAAAAADAjXDVSZBevXrZaW07dep0xS4waeXu7m7HFhkzZozatGmTIWUCAAAAAACkKwmybNkyHTp0KNXmJVdr6dKltswvv/ySJAgAAAAAAMgaSRAzEKqZ7jYjtWjRIqGVCQAAAAAAQKYlQTZv3pywPGDAAHXr1s3O9lKkSJEk29WqVeuqK/DGG2/osccek5+f31XvCwAAAAAAkKFJkDp16sjNzU2JJ5IxXVgSM+/HxcWlKZGS2Msvv2yTJ2bq3GtJogAAAAAAAGRYEsThcCi9kkukxGvVqtUVkygAAAAAAADp4X61O0RFRSkmJibJOvParE+N6ULTvHlz7dy50yZV4h+mS83x48dJgAAAAAAAgKyVBGnbtq3WrVuXZN1ff/2lu+66K9X9vvjiCz3//PNq166dxo0bp9jY2IT3TCsQAAAAAACALJUEMWN7NGrUKMk683rTpk1X3NckSjZu3KhTp07Z7jF//PEHCRAAAAAAAJA1p8g1s7iEhobK398/YZ157e3tnab9c+fOrRkzZmjNmjXq27evTp8+fbVVAAAAAAAAuP4tQcwgpoMGDVJ0dLR9bcYCGTJkiFq2bHlV5ZjWI6ZVyJ49e1SoUKGrrQYAAAAAAMD1TYJMmTJFW7ZsUWBgoKpWrWoTGP/884+mTZt2tUXJ09NTP/zwgyIjI696XwAAAAAAgOvaHcbM5rJ27Vo7OOrBgwdVpkwZNWjQ4Ipje5ixRJLz8ssvq1atWipQoIB9BgAAAAAAyBJJkP79++utt95Sw4YN7SPegAEDNHPmzBT3MwOhmkSJ0+lMtouNeS8uLu5qqwMAAAAAAHB9usN8+umnKU6Bm5pu3bqpefPm2rlzpxwOR8LDtCw5fvw4CRAAAAAAAJA1WoL8+OOP9tm01pg/f36SFh179+5VQEBAqvubJMlPP/2kdu3aqWfPnho2bJgdE8S4UlcaAAAAAACAG5YEefrpp+2zGcR04MCBCevd3d1ta4433njjimXcddddtjXI0KFDbfeYt99+mwQIAAAAAADIWkmQ/fv32+euXbvq66+/vuYPzJ07t2bMmKE1a9aob9++On369DWXBQAAAAAAcN0GRk1PAiSxRo0aaePGjTp69KidbhcAAAAAACBLJUGioqL02muvadmyZTpz5kySsUFMUuNqxMTEJHSpAQAAAAAAuJ6uOvswePBgO0PM3XffbWd6eeihhxQeHq77778/1f0OHz6sNm3aqFy5cpo1a5ZWrVql4sWLq3z58qpWrZoOHDiQnuMAAAAAAADI2CTIvHnztHDhQjtQqpndxTzPnTvXtgxJzaBBg1S3bl07pkj//v1tEmT37t02OWKSICNGjLjaqgAAAAAAAKSZmzNxf5Y0yJcvny5cuGCXixYtaltw+Pr6yt/fX8HBwSnuV7hwYR05csROsWsGRzVdaQoUKGDfO3HihOrXr2/fT40p30zFGxQUZD8PAADkPBl5vSd2AADANQSnMX646jFBKlWqpH/++Ue1a9dWzZo1NW3aNJsYudLgptHR0fL29rbLpmLxCZD4ZIqpKAAAAAAAwPVy1UmQCRMmKDQ0NGG5e/fuCgkJ0bvvvpvqfibRce7cOZv8WLBgQZL3zAwxJjECAAAAAACQZZIgZnDTeA0aNLDjeqTF0KFDFRYWZpMgTZo0SfLe4sWL1blz56utCgAAAAAAwPVLghhmXI+DBw8mtAiJV6tWrRT36d279zW9BwAAAAAAkClJEDM7zGOPPaazZ88mWe/m5maTI8kx2xYsWPCKZad1OwAAAAAAgOs+Re7AgQM1ceJE27XF4XAkPFJKgBgNGzbUc889p23btiX7/vbt2+37jRo1utrqAAD+j737gI6iasM4/mRTSAIktNB7B+kC0hEQUSlKVbqiKCLSREWUooiigCgIKoqKigVFLKB+otIEaQJKk947BJJAena/cwcTE0hCIAsp8/+ds2Z2dubundmVefedWwAAAABcn5YgkZGR6tevnxyOtOdPNm3apClTpui2226zEiaVK1dOmFJ3x44d1jaPPPKINmzYcLXVAQAAAAAASBMPl8vl0lV4/vnnrSlxhwwZoqtlWousXbvWSoqcPXtWefPmVa1atayWIp6enm6b9xcAAGRd7rzeEzsAAGAPoWmMH646CXL06FE1bdrUahFSqFChJK9d75YcBDIAAGR/JEEAAMD1ih+uujuMmcq2TJky6ty5s/z9/a+6YgAAAAAAABnhqpMgf//9t4KDg+Xj43N9agQAAAAAAJAZZocxM7js2bOHDwMAAAAAAGTvliB169ZVmzZt1KtXLxUuXPiy6XMBAAAAAACyRRJkzZo1KleunP74448k6z08PNKUBDHjsP7888/atm2bihUrprZt2ypnzpxXWw0AAAAAAIDrmwRZsmSJrtWOHTt03333qV69etbUuBs3btTEiRP1zTffqGTJktdcLgAAAAAAgNuTIIcOHVLu3LmVJ08eRUVFaebMmfL29taAAQPk5ZVycWaamrvvvltz5szRLbfckrC+devWeu655/Thhx/q1Vdf1dNPP221KgEAAAAAAMjQJEinTp00e/ZsKwliEha//vqrlQQxrTymT5+e4n5Tp05V3759rQSIGVMkJiYm4bUDBw7I4XBo+fLlyp8/v/r373/tRwQAAAAAAOCO2WF2796t6tWrW8vz5s3TwoULtXjxYn311Vep7me6vJjBVI1WrVqpaNGiGjFihIoXL24lR4wXXnjBahECAAAAAACQ4S1BTIuN6Ohoq+VHQECASpUqZQ12ev78+VT3O3z4sEqUKGEtf/zxx1q/fr1y5Mihli1b6uabb9aYMWNUu3Zt/fPPP9d+NAAAAAAAAO5KgjRv3lzdunXTmTNn1LFjx4TWIQULFkx1P39/f506dUpBQUEKDQ3VkSNHVLZsWSs5EhYWZm0THh4uX1/fq60SAAAAAACA+7vDmPFAqlWrpttuu02jR4+21u3cufOK0+M2atRIv/zyi7VsxhJp1qyZNVNMixYt9Mwzz1jrly5dqvr1619tlQAAAAAAAK7Iw2X6stwAq1at0iOPPKK1a9fKz89P27dv15YtW6yESpUqVayZZho2bKjXX3/dSpAkx7QgCQwMtGaaMV1xAABA9uPO6z2xAwAA9hCaxvghTd1h3n77bWsKXGPatGkpbpdaaxDTEqR79+6644479Mknn1iJD/OIn3a3T58+ateuXYoJEAAAAAAAgPRIUxLku+++S0iCLFiwINltPDw8rtglZtSoUSpfvrxuv/12awwRM1CqGRvk+PHjevbZZxNmjwEAAAAAAMiy3WEutXfvXp04ccIaKNUkRtKCJq0AAGR/dIcBAAAZ2h0mObGxsdZsLoldTb9dMzOMeQAAAAAAAGTK2WFWr16tmjVrWlPZ5s2b13rkyZPH+gsAAAAAAJBZXXVLkL59++ree+/V559/Ln9//+tTKwAAAAAAgIxOgpw8eVLPP/+8NRAqAAAAAABAtu0O06NHD33zzTfXpzYAAAAAAACZpSXIiy++qPr162vSpEkqXLhwkte+/vrrNLUkeemll7RhwwadP38+yWtmHQAAAAAAQKZIgvTq1Us5cuRQ06ZNr2lMEDOeiKenp7p3786YIgAAAAAAIPMmQZYtW6ajR49e1XS4l7b2OHXqlHx8fK5pfwAAAAAAgBsyJkjVqlUVFhama3XLLbdo9+7d17w/AAAAAADADWkJ0qlTJ7Vt21YDBw68bEyQDh06XHH/jz76SF26dFGzZs0u23/w4MFXWx0AAAAAAIDrkwR55513rL8vv/xykvVmyty0JEGmTp2q9evXKyYmJsmYIGZ/kiAAAAAAACDTJEH27duXrjd86623rHFBTLcaAAAAAACATDsmSHoFBQWpbNmyN/ptAQAAAACAzd3wJMjo0aPVv39/7dq1S6GhoUkeAAAAAAAAmaY7THr169fP+jt37lxrHBDD5XJZy3FxcTe6OgAAAAAAwCZueBIkvWOKAAAAAAAAZEgSJDg4WPny5Uvz9qVKlUpYPn36tAoUKJDeKgAAAAAAALhvTJCTJ0+qR48eqlGjhkaNGqULFy6ocePGVhLDJDb++uuvNJUTHh6uRx55xJoet1ChQtbfAQMGWOUBAAAAAABkeBLk8ccftxIVI0eO1ObNm9WmTRs1adJEBw8eVPfu3fXEE0+kqRyz3c6dO/Xrr7/q6NGj1l8zSOqIESPScxwAAAAAAACp8nCZUUnToGDBgtZ4Hjlz5tS5c+esFiDnz5+Xr6+vIiMjVaxYMZ05c+aK5ZjtTBIlcRcas1/16tWtpEhqzAwygYGBCgkJUUBAQFqqDQAAshh3Xu+JHQAAsIfQNMYPaW4J4nQ65XBc3Nz8jZ/RxTB/45evxOwXX05CJf4tDwAAAAAA4HpJcxKkadOm6tmzpz7//HPdf//9atiwocaNG2e13njhhRdUt27dNJXTrl07denSRevXr9epU6e0bt063XvvvWrfvn16jgMAAAAAAMA9SZAZM2YoLi5OL7/8su655x59+OGHVkKkePHi+uqrr/T666+nqZzXXntNJUuWtJIqZmBU89eUMWXKlLRWBQAAAAAA4PqNCZIcs6uZIjd//vzXtK9pCRIUFJTmrjT06wUAIPtjTBAAAHC94gcvpYNJXlxLAiQsLEyLFi3S4cOHVaJECd15550MdAoAAAAAAK6rdCVBrsWmTZus6XXz5s2rMmXKaP/+/Ro8eLB++ukn1a5d+0ZXBwAAAAAA2ESaxwRxF5PwGDVqlP755x/9+OOP2r59u5577jlrPQAAAAAAQLZJgmzZskWDBg1Ksm7gwIHWegAAAAAAgGyTBClcuLBWr16dZN3atWut9QAAAAAAANlmTBDTFcYMhNq7d2+VLl3aGhNk7ty5mj59+o2uCgAAAAAAsJEb3hKkV69e1swwMTExWrJkifX3u+++s5IiAAAAAAAA2aYliNG0aVPrAQAAAAAAkG1bgnh6eur+++9XbGxskvUBAQE3uioAAAAAAMBGbngSJEeOHDp58qRuu+02nT17NmG9y+W60VUBAAAAAAA2csOTIF5eXlq4cKFuuukmNWjQQLt377bWe3h43OiqAAAAAAAAG3FkyJs6HJoxY4YeffRRNW7cWMuXL8+IagAAAAAAABu54QOjJu72MnToUJUvX14dO3ZURETEja4KAAAAAACwkRueBJkzZ06S5+3atdNvv/2mb7755kZXBQAAAAAA2MgNT4J06tTpsnU1a9a0HgAAAAAAANlqTBAAAAAAAIAbjSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAW/DK6AoAyN7a5Oqb7jI8cuZMf0ViotNdxE/B76W/HgAAAAAyDC1BAAAAAACALZAEAQAAAAAAtkASBAAAAAAA2AJjggC4oQqVLKBpy8fqwPYj1vMJvWeoVvMqumdgG0VHRmvyw+/q1JHgVMtwODw04s2+KlA4j04cOqPXn5iru/o01W3dbpHL5dJnU3/Smp83p1pGxTpl9NC4LtZyvkKBWvvLZs169gsFFcun2esn6PGW43Vg+1E3HjkAAACAjEYSBMANt/n3HXqx15vWsqeXpzoNukNP3D5BFW8uqx4j79Ybj3+Q6v6N29bS8QOn9erAD9XlsdZq3La22t3fTI+2mCBfPx9N+GLQFZMgOzfs01MdJlnLQ9/oqz8WbbSWuw25Q9vW7HbbsQIAAADIPOgOA+CGq9qggqb8PEoPjO2i4hUKW61CYmPitG31LpWuWvyK+xcuVUB7thy2lvdsPqhqt5TTsf2nlMPXW365cij07IU018Xh6VDlumW15Y9dVisVl0s6dTj1ligAAAAAsiaSIABuqODj5/RAjSf1xO0vKTAoQA3b1lZ4WETC656eV/5n6dCu46rVpJK1XKtZZeUK9Nf637Zp1ooxmva/p/Xtu0vTXB+z/+aVO6xuNKYVyPw3/3eNRwYAAAAgsyMJAuCGiomOVVR4tLX8+7frVa5mKfnn9kt4PS7OecUy1vy8RTExsXrl66Hy9c+hc6fDdGfvxurXcKz6N35B94/qkOb6NL27rlZ8+6eKlA6ynpsxRgAAAABkTyRBANxQfrl8E5arN66kNT9uUsnKReXl7Wl1k9m39dAVyzCtNmaNma+nO72usOALWrlok6KjYhUTFavIiGh55/CSh4dHmrrCVKlXTptX7VTZaiVUqnJRvfjlUNW+taoGT+ltjVcCAAAAIPtgYFQAN9RNDSvq/jGdFRURpeP7T2vO+PlW65BJP41STFSMJvWfdcUy8gYF6Jl3+lmtRjYu/0db1+7R799v1NQfnpSnw6Hv319uJUqupGbTylYCxGy7cuEG62E88eYD+mrG/xQXG+eWYwYAAACQOXi40vJLIZMIDQ1VYGCgQkJCFBAQkNHVAZAGbXL1Tfd58siZM/3nOuZiF5z0+Cn4vfTXA8ANvd4TOwAAYA+haYwf6A4DAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEpcgFcXxVKpbuIH378LN1l3Fm2QbrLAAAAAJC10RIEAAAAAADYAkkQAAAAAABgCyRBAAAAAACALZAEAXDdla9SRFNmP6hJ7/XTs690k3+uHHppZh9Nnt1Pr856QIWK5EnY1sPDQ7PmD1KHe+tbz2PjotTwrkMKKLdHW/6JstYdPhqru/seVctOh/XClGBr3bYd0WrW4bAatzukX5aHW+tWrYtQjVsPqmiNfcnW69auDfTFgRnW8hPv9LeWOwy47bqfDwAAAAAZg4FRAVx3Z06GadRjHykqMkYPDLpN9RpV0JSxC3TmVJjqNCinLn0ba8bERda2t95RXaeOhSTs63B467uPiuqp8acT1pnlmRMLqliR//4Je/blM5r9ekEVCvLSXT2O6rZm/rqpko9W/1Bct3Y8Iu1KWieTbGnasb5OHbmYRPlg7Dz9veIf+eXKcf1PCAAAAIAMQRIEwHV39sz5hOXY2DjFxMRZCRAjLtapuDintexweKhZ65u0bPEW+fp6X1zn4VBQAc+E/WNiXDpwKEYjnj+tUydi9UJFHzV2Ssc3R6lCIS8pp0P58jp0+kycCuT/b79Ltbi3oVYsWKvOQ+60ngcf/y/xAgAAACB7ojsMgBsmqHCgat9STmtW7LCee3o51PPhW/XtZ6ut5y3vqqHli7fK5XSlWMbp4Dj9vS1ak0bk09xTcRr+Uaj0eahcR2Pl0fawdMGpwNwOBZ+LS7EMK9nS+RYt+2rNdThKAAAAAJkVSRAAN4R/zhx66sXOVjcY0/rDGPpcBy36ap2OHT57MTFxe3Ut+9/mVMvJE+BQxXLeKv7jBRXeF2M1Z4uL/fcfs13R0vshOhfqVL48KbcCadm9sZbPXyOXK+VkCwAAAIDsh+4wAK47k+B4ekIXzZ21VEcOnrHWdX+ouY4fPadlP2+xnufNn0t58+fU+Gm9lL9ggByeHtr29yHt3n4sSVl+fg7lCfBU6O5oeXlI0f/+Q1bY5EA8pEK7o3X2nDPVrjClKhdTuZql1Kp7YxUrV1iPvNJT7zw99zqfBQAAAAAZjSQIgOuu2e3VVLVmCfnl9FGP/s3183cb1evhW7X1r4OqWa+Mtv99SB9M/0WP93zH2r51+1ry8/dJSIC07XlUf22N0s490erfO1DjR+ZT+4EnFBMnjf/3PV6S1C9OilsZoXFTClrrtu+M1pDnTmnn3mh5R/2iit51FODIp9mjv0io2/Tfn7cSIA88300N29aWw9OhImUKkRQBAAAAsiEPVxZqDx4aGqrAwECFhIQoICAgo6sDIA3a1B6T7vP044+fXb7ygvPiGCCmC4zpC2N62FTwkWtRcWtw1EvdWbZBuuvxv/CP010GgBt7vSd2AADAHkLTGD/QEgRA1pTTcTHh8X6IPA7GyFXSW+oXmGwCBAAAAAAMkiAAsi6T8Hg8r7JMczYAAAAAGYpbpgAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBMUEAXFfOv7anu4w2RWu5oSaR6S6htaNr+qvh8Ex3EYtjP09/PQAAwPW/7rsDsQPgVrQEAQAAAAAAtkASBAAAAAAA2AJJEAAAAAAAYAuMCQIgQ7S4r7EGvtFPXQs9aD0vUCyfBs/oL/8AP21aukWfvPBVivtWqFNWj069Xy6nS2dPnNPLvaYpLjZOXYa3U5NODRR5PlKTHpihM8fOplhGpXrl1f+VXtZyviJ5tfbHDXp7+BzreVCJAvpw5zQ9Vvdp7d96KNXjqNG8qno910WeXp76aur3WvfjJk3833PWaz5+PvL28dKjNz+V4v5+uXz1ys/PqXTV4hrc+Dnt33r44rl4s5/8A/y1aelWfTJ+/hXOJgAAuBGIH4CsjyQIgBvOw8NDTTs30KlDpxPWPfxqb70x8F2dORp8xf1PHwnWM3e8qKiIaPWb0F2N76mnzSv+Uf27btbQJs9ZAUrP0V00beC7KZaxY91ujWg5zloe/u4ArfpmXcJr9z19t7au3HHFenjn8FaX4e016q6XFBsTm7A+vtxWPZuqSLlCqZZhjmF0h1f08L8JGePhV3rqjcdm68zRlJM4AADgxiN+ALI+usMAuOFa9miiFfNXWy05DNOKolDpgnpkch+9+stYVW1YMdX9TesPkzwwYmPiFBfrVKFSBXRg28VWG7s27FW1xpXTVBeHp0OVb6mgzSsuzmJTuHRBuVzSqYP/JWhSclOjSoqOiNb4757W2PlPKm+hPEleb9aloZZ/uTrVMpxxToWcDkt4fvFcBOmRSb316uLnrnguAADAjUf8AGRdJEEA3Nh/dBwONe/aSEu/WJWwLrBAbpWpUVKznvxIL/d8Q49OfSBNZZluK3VaVdfqhX/q6J4TqlS3nNX9pM5tNZQrb840lVG7ZTVtXr5NLpP5kHTv03fry8nfpWnfvIUCVbhMQaslxw/vLlafcV2TdHMJKpFfB7cf1tWwzkX1kpr11Cd6udd0Pfpan6vaHwAAXH/ED0DWRXcYADdE52Ht1LB9XWu8j2VfrkpIOhjnz4XryM5jVjcXw4zvYe6wmFYSyZXxx/fr9eN7v2rkR49rUr+Z1vahZ8K08J3Fmvi/0drz134d3nE01XqYMuZPXahmXRvq17krrNeKlL3YdeXEgVNpOpYNv/ytLSv/sbrCbPpti+4b2TFhm4YdLr7H1Tp/7sIl58KZ7LkAAAA3DvEDkH2QBAFwQ5iEg3k8NLGnWvdurlY9m6lYhSIa8Fpfa0BS8+PfDATqjI2zWnMk96M/vgzTmmTcgif1yfgvdWTXsYTXf56z1HqYwUrPnQxJtR6GSS5UaVBRrz8yy3permYplapaQi/98KzVGqNo+cLW+B4myZJcGbnz5dKouUOsdeVrl9HxvSeTdIX54LnPrvo8RUfG6HxIuDVArDPWKW9vTxIgAABkMOIHIPsgCQLghnpv5NyE5RlrJybMyGISBi9+P1Je3p76cMznqZbRvFtDazwO/9x+6vlcF33/9s9aNm+VRn06VHmCAnTi4ClNf2z2FetSq0U1ayyQ+FYpvy9Yaz2MJ99/TF9O+e6yBEhiYcHnrdYeU5Y+b41vMvnBmQldYQqWNGOUpK0rzITvn7YSMMUrFdGiWb/qg9Ff6MXvnr54LsZ9maYyAADAjUH8AGRtHq7EbdIzudDQUAUGBiokJEQBAQEZXR0AadDa8d84GbCan6T7NCyOTT1JBGR17rzeEzsAyPIxDLED4NZrPgOjAgAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFtgilwA19ViZ+aY4vV2n+7pLmP3R9XSXUahb3zTXQYAALj+PLzS/1OJ2AHIfGgJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBYYEwSALVWoXUYDpvSRy+nS2ZMhmtjnTb36v2fldLrk5eOlNwa+q/1bD1+2n8vp1KmZXykuOFReQXlVoP89OvzkNHnlzW29nueeW+VXo3zCtkeemq6A1rcooE2Dy8pq3aiyht3fQnc9/JZmjr1XLpdL3l6emjjrZ+09fMZaHn5/CxUvnFcXIqI1csq3N+DMAAAAd8YO7owfiB2A9CMJAsCWTh8N1qi2LysqIloPjL9Xje6uq6faTFBcbJyqN62iToPv0muPzLpsv/C12+RdMJ8KDuqmc9+t0IV12+Twy6EiYx66bNsLq/6WV/48yb6/h4fU4pYKOnkmzHr++ItfKi7OqdpViuu+tjfrpXd+Vtc7amvlxn36/c9frsMZAAAANyJ2cFf8QOwAuAfdYQDY0tkTIVYQY8TGxMkZG2cFMUbOAD/t23Io2f1iTgbLp1QRazlHmSKK/Ge/FBElDZ6swkNfU595v8g/Msq6i3NhzVblbJD8jDK3N66iJWt2WXePDJMAsd7bz0d7Dp62lhvULK1alYtpxphuuqdVjetwFgAAwPWOHdwVPxA7AO5BEgSArQWVyK86Latp9aKNCiyQW1OXjtPj0/pp84rtyW7vXTRIEVv3WssRW/bIEXpByzw8tOt0iB46eVZnFizV/NHvKGbJeuW85SbJ4XFZGQ4PD7VqUEm//PFPwro8uf30zvP3acSDt2nj9otNaQvmz63NO49q8Itf6vbGlRWUL9d1Ow8AAOD6xA7uiB+IHQD3IQkCwLb8c/vp6Q8e0+T+b1t3ckJOh2nYreP0wr1T9cD4+5Lfp04leXh56tj42XJFxqjG2TDVO35Gni6Xurtc+ktSmcMnlXvRKuVslHzrjTuaVtGvq3fIdbERiOVcWIQeGfu5Rr32nR69r4m17nx4lNZvOag4p8tKhpQskvf6nAgAAHDdYgd3xA/EDoD7kAQBYEsOh4dGfvSYPpkwX0d2HZfD0yEP09nW9MUNDVdkeGSy+3k4HMrf5y4VGf2gHLn91DynryL+vVmzXJIZ0uyow0NR58N14pWPFbJopUIXr1HU3iMJZZQunl93NquqqSM7qUSRvBrS51arn2984iMiKsZa/nvHEVUsXdBaLl8qSMdOhV7nswIAANwdO7gjfiB2ANyHgVEB2FKzrg1VtUFF+eXyU89RnfTzR8vUpu+tcjqd1qjvbw75INn9Ys+F6dS0LyRPh/yqlZNKFlLzDTuU0/TxlfS+pKIuaUDbxnr77uYKW7ZBrsho5ShbLKGMmZ+uSFh+f0JPffr9es0Y3U1Ol8uaIWby+79Zr3383TqNfvQODbiviVb/tV9HT4bcgDMDAADcGTukO374m9gBcCcPl4m4s4jQ0FAFBgYqJCREAQEBGV0dAFnI7T7d013G7o8uH6TMDGJm+vCWP3JKToeHHE6XdhcLUufxjyjc14Q1SRX6xjfd9fjj8yfSXQZgl+s9sQOAzBY7XG38QOwAuPeaT0sQAEgHE6iYgKXP/1ar+KmzOhyUVx+1aZBsAgQAAID4AchYJEEAIJ1MwsM0XQUAACB+ADI3BkYFAAAAAAC2QBIEAAAAAADYAkkQAAAAAABgC4wJAsAePD3TXUS5HpuUKXye0RUAAMAGiB2AbImWIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBMUEA2FLpqsU15M1+iouNU8T5KL18/wyNnjtYPr7eiotzasrDs3Ti4OkrllOjeVX1eq6LPL089dXU7/XHd+v14Y5pOn0k2Hr905e+1oZf/k5xf79cvnpl8RiVvqmEBjccpf1bD8nXP4fGff2kvH295YxzanK/mTpx4JRbjx8AAGRM7GAQPwAZx8PlcrmURYSGhiowMFAhISEKCAjI6OoAyEJu9+uV5LlJWpggxug1qqNOHDitDUu26MzRs7q5VTU1bHez3hw2J8k+rqioJM+9c3hr9LzheqHLFMXGxCasn7F2oh6rPzJN9XJ4OpQ7by49/GpvfTnlOysJ4u3jpYACATpzNFg3t66hRnfX0/RBsxP2Wez88prOAWDH6z2xA4DMFDtkVPxA7AA7CE1j/EB3GAC2FB/EGDn8fXTgnyNWEGPExsRZd3Su5KZGlRQdEa3x3z2tsfOfVN5Ceaz1vrl8NWXJ83rmkyFWgJIa09Ij5HRoknUx0bFWAJNQl9gr1wUAAGT+2MEgfgAyFkkQALZVp2U1zfzjRdVsXlXH9p5IuMvTc1RHfTPjf1fcP2+hQBUuU1CjO7yiH95drD7julrrhzZ5Tk+0GKt1/9uo3v+uuxamLr1Gd9GCaT9ccxkAACDzxA4G8QOQsUiCALCtDb9t0cCGz2nFgrW668GW1rqhMx7Uovd+1bF9J1Pcr/Owdpr82zgVKVtIW1b+YzVl3fTbFpWsUtx6PSz4vPV3+ZerVa5m6VTLMH9TMuydR7TwncUJQRYAAMiasYNB/ABkDgyMCsCWTL9Z0+3ECA+JkJePp3o8fbeO7z+pZV+tSXXf+VMXWo/c+XJp1Nwh1rrytcvo+N6T8vL2kofHxS4tNZpV0dE9x1MtIyU9nu10sS7zVqXrOAEAQMbHDgbxA5A5kAQBYEt1WlVT12Ft5XS6FHI6TG89+bE+2fG6tv6xS7VuvUnb1+zS+2PmpVqGafHxx/frNWXp83I5XZr84EzlyptTExaNUuSFSMVExWrKgzOvWJcJC59RuVqlVbxSUS2atVh//vyXeo/pqq0rd6hWi2ratnqn3h/1qRuPHgAAZETsYBA/ABmL2WEA2HKE92uR3AjvGYER3pHdMTsMgMyA2AHIWpgdBgAAAAAAIBEGRgUAAAAAALZAEgQAAAAAANgCSRAAAAAAAGALWWp2GJfLlTDgCQBcjVhXjBv+DUp/Ge7Av4HI7uK/4/HX/fQgdgBwrYgdgOwZP2SpJEhYWJj1t0SJEhldFQDIMIGBgZx92IK57qf3+07sAADEDrCXsCvED1lqilyn06mjR48qd+7c8vDwyOjqAACA68CEJiaAKVq0qByO9PXcJXYAAMAeXGmMH7JUEgQAAAAAAOBaMTAqAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCIMtzuVx6+OGHlS9fPnl4eGjTpk0ZXSUgQ+3fv5//FwDgX8QJQPqULl1ar7/+OqcR2QZJEGR5P/30kz788EMtXLhQx44dU7Vq1ZQVzJo1S7feeqsCAgKsH6znzp1L9qJjXkv8GDly5GXbmeOvUaOGfH19VbhwYQ0aNCjhtcjISN1///2qXr26vLy8dM8991y2vzlvPXr0UKVKleRwODR06FDdaEuWLNFdd92l/Pnzy9/fX1WrVtUTTzyhI0eOWK8vXbo0yXkICgrSnXfeqb/++uuKF2mzzrx2NbZu3arOnTsnfAbJlTtu3LjLPh9z/i8Nvs12RYsWlZ+fn/WZm7IvTVgk9/jyyy+VGZjvV548eTK6GgBwTYgT7BEnpHatMuvN6/ESX2tz5sypChUqWOfgzz//THb/w4cPy8fHR5UrV76muqflHF8a58Q//vnnnyTbzZ8/3zr2HDlyWH8XLFhwWVkzZ85UmTJlrM/75ptv1ooVK5RZcKMGmQFJEGR5e/bsUZEiRdSoUSPrwm4uLpeKjo5WZhMeHq477rhDo0aNSnW7F154wQo+4h/PPfdcktdfe+01Pfvss1ZyxPy4/vXXX9WmTZuE1+Pi4qwf34MHD9Ztt92W7HtERUVZSQVTTs2aNXWjvfPOO1bdzOdnLu7btm3T22+/rZCQEE2ZMiXJtjt27LDOw6JFi3T27FnrHJrtrsfnU7ZsWU2cOPGyxEZiN910U5LPZ/PmzUlef/XVV63P6M0339S6deusslq3bq2wsDDr9RIlSiTZ3zyef/55KygzSZ7sxHwXnU5nRlcDgM0QJ9grTkirDz74wLrmmnMyY8YMnT9/Xrfccos++uijy7Y1CZRu3bpZscHKlSuv+r3Sco4vjXPiHyZBE++PP/7Qvffeq969e1s3gcxfU681a9YkbPPFF19YSSrzWW3cuFFNmza14omDBw8qu4mJicnoKiCrcgFZWN++fV3maxz/KFWqlLW+efPmrscee8w1bNgwV/78+V3NmjWz1k+ZMsVVrVo1l7+/v6t48eKuRx991BUWFpZQ3gcffOAKDAx0ff/9966KFSu6/Pz8XJ07d3adP3/e9eGHH1rl58mTxzVo0CBXbGxswn5RUVGuJ5980lW0aFGr7Pr167uWLFmSpmMw25m6nz179rLXzPtNnTo1xX2Dg4OtOv7yyy9pPl933313qtuYczdkyBDXjXLo0CGXj4+Pa+jQocm+Hn9ekjtPv//+u7Xup59+SvV8mXXx341rkVK5Y8eOddWsWTPF/ZxOp6tw4cKuiRMnJqyLjIy0vmNvv/12ivvVqlXL1a9fv1TrFBcXZ5Vbrlw56/yVKFHC9eKLL1qv7du3zzovGzduTPK9TmzBggXWNvE2bdrkuvXWW125cuVy5c6d21WnTh3XunXrEs574oc57rR87xP//1SlShWXp6ena+/evdY29erVs/Yxrzdq1Mi1f//+VI8XAK4FcYJ94oTkrnXxzHrzejxzLTPXwUv16dPHugaa+Crxtbxs2bJWrPH000+7HnjggXQdT0rnOLV4MF63bt1cd9xxR5J1bdq0cd13330Jz821eMCAAUm2qVy5smvkyJGp1uvbb7913Xzzza4cOXJYsXPHjh2TjYMujTEMU2ezLj4GMOevR48ergIFCrh8fX1d5cuXd73//vvWa5fGFOb7FM9sY+pq6lCpUiXXjBkzEl6Lf98vvvjC2sdsY7Y38UO7du2s+NzEFVWrVnUtWrQo1WMFaAmCLO2NN96wWkoUL17cypabO+3x5syZY7UKMRl7cwfBME04p02bpi1btliv//bbb3rqqaeSlGmy/Gabzz//3GpCa5ondurUST/88IP1+Pjjj62uLF999VXCPg888ID1Pmafv//+W127drVaKOzatSvdx/jKK69YTT9r1aqlCRMmJGnVsnjxYuvOumkKWqVKFes8mDsChw4dUlZhunyYY7r0c4iXWjcMc1flWu4ExDc5NU0y08t8xqari2l2et9992nv3r0Jr+3bt0/Hjx/X7bffnrDONF9t3ry5Vq1alWx5pimuGdfmwQcfTPV9n3nmGeu7MXr0aOuO2KeffqpChQpd83H07NnT+v6Y/4dMHcwdQ29vb6uFlekKZLptxd+VGjFiRJq/9+b/p5dfflnvvfeedbfNjN1jmgGbc2D2MXe1zJg+5vMAAHcjTrB3nHC1hg0bZrXUNPFV4m445lpmWnCYlhfz5s1LaM0Zz1zDEne3SY/atWtbLZxbtWplvXdi5pqZOKYwTKue+JjCnCdzDb90G/M8pbjDMK1rTazbtm1bq/WIaS1Ut27daz6G+Njkxx9/1Pbt2/XWW2+pQIEC1mtr1661/v7yyy9WTPH1119bz999912r9YqJdc0+L730klWOidcTe/rpp60WNWYbc+yPPfaY1VJp+fLlVmtcExvlypXrmusOe7i83wCQhQQGBip37tzy9PS8rMtC+fLlra4IiSXuw2p+tI4fP16PPvqo1XcynvlBbf6xLleunPW8S5cuVuLjxIkT1j+qpv9lixYtrAuTaZJomtl+9tlnVn9R82PYMD8STQLFNLU0/4hfqyFDhqhOnTrKmzevddEwP3zND2vzg9IwP7hNcGPewwR65nyY7jKmu4X5gWn6r2Z25gez+YFtLvhX48yZM1a3EfP5169f/6r2NX2JTb9m8yM/PeKbzVasWNH6frz44otW0sD82DeJK5MAMS5NTpjnBw4cSLbM2bNnW4GqKSclJvgyn7fpYtO3b19rnfm+NmnS5JqPxTSTffLJJxP6Oydufmu+V5eOd5LW7735/8n8/xXffDo4ONhqvtyuXbuE/8fM8QLA9UCcYN844VrEXwMT3yQx12Vzk8PEmqYLrIkvTZeThx56KGEbE1OYc5se5vjMTTYzhof5UW9iT5MIMTdumjVrZm1j4orkYor4eOP06dNW15vUtkmOSTyYYzRxVbz0dHsyMYVJ5sQnUhKPy2a6VRkmTkocV5iY3HRtMsmY+DjdJFLMjcz4WCc+lo/fJv69zBhuZrwVw3RlBq6EJAiyreQy2CZxYQIB849qaGioYmNjrcGqLly4YI3BEP8DOf7HWfyFw/zjnTirbNadPHnSWt6wYYM1+KX5IZyYuYCZf+DTe0cinhnQzCRDTFImvnWICWzMj0zTciU+629+mJqLijnWxH1+3c0EAin9kE9Or169rP67lzLn7mpaAZi7WIb5zMwPdXOHqGDBgroaJmly6UBj1yLxmB3m4tuwYUPru2PuWgwfPjzhtUuPL6VjjoiIsFp0mDsfqTF3P8z3ywRH7mLqawI6E3SZu12mVUfi/w8uldbvvQmwzXc3nmkJYgaHM99NE4Sb9zJ3JW9EcAsAiREnZM84IT0u9tb477ptBq03LRV+//33JPV8//33kyRB3BFTmESKecQzMYVpsTN58uSEJEjiuiWu86Xr0hp3xDMtUPv37y93MTcYTWLCxAomPjUtQFO7uXPq1CnrWE0r2MT1MHH6pcmlS/+/Na1CzPv9/PPPVkxh3jdx3AEkhyQIsq34pEY8cyE2o4oPGDDAyjabH2Pmomb+wU3cneLS1gHmopHcuvgBHs1fc3fAND80fxNzd3O8Bg0aWH93795t/dCM/+FoWqckzrCbJofXewAs0zXoarqhmLs4yTE/ok3LANMkMi0/hM0I56Ysc5yXlmmeJzdIqgli0nuHJq3fOZMMie8OEn+Hw9x9SXxsJoGWXNcV08XKNLnt06dPqu8T3w0orUw3sPjALt6ln52ZwcaM/G+axJrmq2PHjrW6uXTs2DHZMtP6vTd1vTTwMi1FTNBiWo2Yu2nmrqRpehz//QaAG4E4IXvFCWZ/M7ipaQmR+Lpknpv1aYkDzE2G+FYIhrkxYW6WmZaf8cz11FwDzQ21xPHX9WCui5988knCcxNXXNqiI3FMYeI/c+ypbZPeuMLEFEbiuOLSz9ncJDJxt4kpTLcXc9PGdFsxCZ3kxMfUpktM4nNtXBpjXPr/rUlGmWSeeS+TCDFdcE2LkscffzzNxwT7YUwQ2Mb69eutjLL5h9FcVMxF9ejRo+ku1zT3MxdYc4ExTSQTP1KbVeRamH6aRnwQ0Lhx44SRxOOZ7gamOWSpUqV0PZnyLz3e1B4ptdYwLVtMa4FLuy7Fu3TqYBOYmBYKyQVLphlr4nFh4pl1ie+uXC+mFYQJoOI/H1NX8x1I3LfY9NddtmxZsndETJPbDh06JDQVTYlpAWMCFtNnNy1MeaYLjWk9k/iuz6XM/xOm9ZEJIkxTU5OsMMznY77j7vzem/1N9y7TR9lMa20CTQDISMQJWTtOMDGAuS7Fx0rxTGsEsz4tcUD8GFjxM7iY67KZhtdcM+MfZlYW0y3atAa53syxJE78mNYhiWMKw1yz42MKc55Md5pLtzHPU2uJYVpOXE1MYZikVGoxhdnOtPw0SRxzXk1Xn/g6GonjCpOgKVasmNXN+9LvRXxCKjVmpj1zk9O02jGfl0mmAKmhJQhsw/xwNkmQ6dOnq3379taAjlL813AAAHSaSURBVMk1u7xa5oejGVTS3L03CRbz484kIcygq6ZVgGl9khyTpTcP06rDMIM5mfEtSpYsabVSMYNfrV692rrQmrsX5oe8+YFqfiSbbeLf++6777bGDjEXF3PhNj8sTSBg9otn7laYH98mQWJ+DMdfrMxgq/Hi15m7JaZZonluLlTX+y6HuXBNnTpVgwYNsroomfNouh+ZsSbMeBumVUFap78zXTpMYsgMlmuCJsNMpWdaHCQeEMyMr2Lex1zwzUU3OeZ8mfMWv2wGlTPnxNTHXJTjx8Aw3yXzeZhkgBkTxBxDfN9V0wLC9F01XbBM4sI8zLLpcmVaXSRmvgdmUC9z5+xKfH19rYHBzCBx5jMyx2w+MzMWSXIDqpq7KuY9zXTM5s6IOf7EA7iZbjhmPBBzzkywYc69+b6ZJqWG+TzM98KcL9NH2JR1rd97M6aN+a6a77EZS8Qk8Hbu3HnF1i8AcL0RJ2TtOMHUw7RA6NevnzU1vfk8zfhVJjYw6y+tp0memDjM3MAw1yEz9sQ333xjlWkGWzXHZxIoc+fOTRgrJF737t2tQTxNqwPTWti8bpZTaj2ZlljMJArMcZluRGY7kzwwMYx5xDPxnukaY7pFm/jv22+/tVpaJO6uY47XDOBquo2YpIm55prWwSZJkBLT+tO01jDnzIwNYuJl0yo0ucFozU0YczNx4sSJVn3Ntd+06ExszJgxVjLGHIs5vwsXLkwY/8sku0wZJjYzXZxNTGPiXNMi1bQSNbGs+bzMfiYxefbs2SRdjC9l4iyzvYlLzLYmDmGsMVwRE+Qgq0tu+tOUpm977bXXXEWKFLGmizNTin300UdJpiNLbnq15KZBvXR6s+joaNeYMWNcpUuXdnl7e1vTopqpxf7+++8U623KvXSaMPOIn8Ltzz//dN1yyy1Wfcz0YmaqMLPPhQsXkpQTEhJiTadqpgbLly+f9b4HDx5Mso05P8m9V2LJvZ6eaWWv1uLFi63PJG/evNbxminSRowY4Tp69Giap46LL6dp06ZWOebRpEkTa11i8WWZ6dZSEj8VW2pTud17773W98l85maa2E6dOrm2bt2apBwztZ753Mx3wkznZqZr3rx582Xv98wzz1jTNpupb9PCbGemxDWfkXn/kiVLul566aUUp68zUwGaKerMuTVTyc2aNSvhO2CmujXT65lpds00hOZYzDTQERERCfub6fbMlHmJp8i90vc+uf+fjh8/7rrnnnus82bey9TflJHW4waAq0WcYI84IT4mGjZsWML1zvw1U+ueO3cuxWMx25np5k1sZ2KveOY6aKZbTc7Jkyetad/nz5+fUF7iKXiTc6Vz/Morr1j1MPWJj1+Sm+r1yy+/tGJCc9015yC+DomZqWXN+5nrrJnyftmyZa4rMeXUqlXL2sdMbWtimuSmyDW2bdvmatCggRVPm31+/vnnJFPkjh8/3lWlShXrdfOdMzHz3r17E/Z/9913rZjD4XAkiavmzp2bUAdzDkzM9PXXX6cY28R/Tua8mRgrKCjI1bt3b9fp06eveLywNw/znyunSgAAAAAAALI2xgQBAAAAAAC2QBIEAAAAAADYAkkQAAAAAABgCyRBAAAAAACALZAEAQAAAAAAtkASBAAAAAAA2IKXsgmn06mjR48qd+7c8vDwyOjqAACAVLhcLoWFhalo0aJyODLungzxAwAA9oofsk0SxCRASpQokdHVAAAAV+HQoUMqXrx4hp0z4gcAAOwVP2SbJIhpARJ/MgICAjK6OgAAIBWhoaHWzYv463dGIX4AAMBe8UO2SYLEd4ExCRCSIAAAZA0Z3YWV+AEAAHvFDwyMCgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBS9lM51KDZKXh8817XumfdV0v3/+H3ema/+fTr6d7joAQHbW2tFVWd1i55cZXQVcgvgBALI34gfEoyUIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAW8h2Y4IkVrFOGT00rou1nK9QoNb+slmlKheVTw5vOeOcem3QBzpx6Eyy+97eoJJG9Gyh2x9/WwXz5tLTfVspp6+P1v9zSO99s1pP9m6piiWD5OlwaNaCVVq95UCy5Xh4eGj4tD4qUqqAXC7ptSFzFBMVq0GvdJd/bj/9tXKH5k5edF3PAwBkV365fPXK4jEqfVMJDW44Svu3HrLWN+/WSJ2GtFVURLQm3f+mTh1O/t/6xAqVCtKbayfqwL9ljO/2mkJOh15zHboMb6cmnRoo8nykJj0wQ2eOnU338SJzxw7uih+IHQDg+iJ+sLdsnQTZuWGfnuowyVoe+kZf/bFoo+a/+T+dOXZOdVpUVZfH22jGU59etp+Hh9SqbkWdCA6zng++r5kmzvlVp86eT9jm05/+1JFTIcrtn0PTn+ycYhKkXLXi8vbx0ogOU1S7eRW179dC+QoGaPpTn+nM8XPX7dgBwA5MkmN0+4l6+NXeCes8vTzVeVg7DW82RpXqlVPP0V30+iPvpKm8v5dt0/huU9Jdh7yF8qj+XTdraJPnVKleeasO0wa+e1XlImvFDu6MH4gdAOD6In6wN1t0h3F4OlS5bllt+WOXFcQYsTFxiotzJrv9HQ2r6Nf1O+V0ueTp6VCRAgEael8zzXy6i2qUL2JtYwIYIzo2Tk6nK8X3PvXv+xm5Avx0ITRchUrmV//nO2vi/KGqUq+sm48WAOzD3Jm/tLVGsQpFdGDbIcXGxGrrqh0qU61kmsu7qXElvbbsBfWb0D1ddShUqoBVB2PXhr2q1rhymstD1owd3Bk/EDsAwPVF/GBvtkiC1GpWWZtX7pDL9Ef59y5hzyfb69t3fr1sW4eHh26rX1GL1+ywnufJ5acKJYL0xufLNfrtHzS8Z4sk2w/s0lhfLN6Y4nuHnjkvl9Old1eO04NjOumnT1aqTJViem/cfL3y6PsaML6b248XAOwsVx5/hYdGJPkxmxbBx87q/gqPa3jzMcpTMFBNOta/5joc3XNCleqWs1oC1rmthnLlzXnNZSHzxw7ujh+IHQDgxiN+sI9s3R0mXtO762rJl2sSng95vY8WfbhMx/afumzbOxtV0S9rd1rjdxjnw6N08PhZnfy3Kau5A+Tp8FCc06X2TW+St6en/rf6nxTf++YWVRUdGaP+jcepfPUSeviFLjq894RO/3tXKS4uzgrQTTYSAJA2prtLw/Z19cf36zV/6sIkr50/e0H+AX4Jz9P672tMdKz1MFbMX62qDSvp9wVrr6kOoWfCtPCdxZr4v9Ha89d+Hd5xlI82G8cO7o4fiB0A4PogfoAtkiAmwVClXjlNG/ax9bz7E211/MApLV+wLtntyxTLr0qlgnRnwyoqWSivBnZtrLDwKOX087ECGC8vhxXA3Fy5hFrUraAn3/j2inUICwm3/p4PjVBO0yUmJEL+uX0vluftRQIEAK6SSTpcmniId2T3cZWqUtz699WMCbJ3c/JjNiU3SFrE+UhruXqzqjq4/fA118H4ec5S61GjeVWdO3mxCwSyZ+xwPeIHYgcAcD/iB9giCVKzaWVtXmXuzLiUr3Cgej7VXtvW7FGtplW0fd0efTD+6yTbvzlvRcLynHE9NPXTZVY/3qnD7pGXp6fe+XqV9doz97dSeFSMZjzVRVExsRoyZUGy779h6Ta16nqLXv1muNUsetbYr6z1L8x9zGpa+9HE767r8QNAdjdh4TMqV6u0ilcqqkWzFluJh6/fWKQpS59XdGS0Xu37ZprKqdaksu4f311R4VE6vu+kPhz9ebrqMOrTocoTFKATB09p+mOz03GEyOyxg7vjB2IHALj+iB/sy8MV39k1iwsNDVVgYKBa5ektLw+fayrjTPuq6a5H/h93pmv/n06+ne46AEB21trRVVndYueXsrv463ZISIgCAgIyvB7EDwCQvRE/ZA+hbogfbDEwKgAAAAAAAEkQAAAAAABgCyRBAAAAAACALZAEAQAAAAAAtkASBAAAAAAA2EK2myL3fJMK8vL2vaZ9izy0N93vH/1tTLrLAACkzOHvn67Tc++G3ek+vR8/1j7dZSBzIX4AgOyN+AHxaAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFrLdmCBlSwZp5OPtFRfnVERktMZO+V53tqimO269SXK5NOer1Vq5fo+8vTw19KFWKl4kjy6ER+upFz/Xike+VNj+YDV5q4sCyubXppd/1YlV+1Xx/noq07mGVf6+rzdrz+cbladSQdUdf4e1LuLkeW166Rc541wKiiqm0jmqJ6lTjSaV1P3J9vL0cujrGT+r/UMt5ePrLWecU6899r5OHDyTIecKALKLW7s20KOTeure0o9bz4OK59P7f72qQU3H6sC2Iwnbxbpi9GLXv3V0d7hGfVFdxSvm1MSeW+RwSLExLvV5oay17tMX9+nQPxcUHRGnNg8WU/27CijyQpzeHbFT58/Fqlyhapo8afTFa01EtJ5/8VsNHtRaDW8przmf/K5vvt1gvV/tWqX0UL9mio116v0PV+ivvw9m2DlC1oofiB0AIHPEDyZ2WB+5WMtqB6crdqjZIq9Kly6gJ4beQfyQwbJdEuTAkTMaOOpTa/mBbo3U7JYK6nhHLd0/7EPlyOGt18Z0tYKYLm3raNWfe7Ry3R5rW09Pb9V/pZ22zVyVUFbl/g2Uv1ZRxYbHyDc8Wm2/3qwc+4N16NZyeuNwSMJ2uz/5U+V736ygm0todcvvVNi7rHwdOa3XvHN4qdOg2zW6y1TFxsTJ28dLuzbu15lj51SnxU3q8vgdmvHk3Bt+ngAgu/Dw8FDTe+rq1OHghHXdhrfVttW7LtvWIU8NeaeK5r26P2HdiA+rysvbod3Lz+rPZ3ar2025VLWIj3a+U0XnJU3ssdkKZJZ/eUI1W+ZTs66FNLLZCvUfMEO+voHq06uxmjapqPfeX6a//j4kPz/vhLJNAuSpZ+ZZwc7ECV019ImL1yfYI37wCIlU50/+VKFjodqVx08/vnSXNs1Zf8X4gdgBADJP/GBihzq+LRXdZsllscOOtSH69b2jmlLeT/Ui4xTVLI82dCyoFx/adlnsMPXBbQr03KfHh35ilUH8kHGyXRLEBJpe/3by8c3hpQNHgnXk+Dn5+HjJ389HIWER1mu31CqjvIH+uq99Xf3y+z/69ue/lCOPX5KyfAv8m8iIidOkR+er+IGzcnl46IDTqSV+3lZiJNLfRxeOhSqwfJC1bW7PfDoXd1KFHWWs51VvKa/oiBg9//lgRUZE683hH1sJECM2NtaqLwDg2rXo1lArvlmvzo9fvLteqFQBySWdPHR5KzuHh0O58/2XpDBMEON1IU7Vx+xR0PFoVfgnXB5OlyotOq1PZlZR0fIXZ6PZszFM3Z4ubS0HBJRRaMhB+fpWl6+vtw4ePKPg4AuXv5/DoQsXov5d9lBAgJ9CQy9eh5C94wfvqDi1+2KTep2NsGKH1i6Xai/ZrftK50vYLqX4gdgBADJP/GBiBx/5KvqS2MGIPh2jNivPqc73p+RyeFjxQ+6vT+qDSjkvix2qNg7Ulh/2q2Chi63+iB8yTrYcE6RuzVJ6f3If1a5W0gpg1mzcp0+m9dN7r/bWV4suNlEuWCC3tuw4qqHj5um2plUUlD9XiuXdtOmolQDxdLrkFeeUp0vyC4+xWoYYuUvl1ekNh+WMdSo49phiXf/9L5I3KECFSxXQ2Pum6ccPl6nXyLut9Z5enur5VAd9+/Yv1/18AEB2ZRILzTrV17Kv1iSsu3d4W331xo9pLiMsOEZT2m3UU8ei1dwleca65HBKj+2K0Li7N6lqo0Bru/CwWPnl8rSWPb18Vb9eRc166wHVqllSR/9Nbl8qNjZOBYMClDePv8qUDlKuXDnSfczIGvFDjT8PKU9w+H+xg9OlIkdCrEe8lOIHYgcAyNzxg4kdXr5vsz4dvUe3n4mx4gYTP/R2Ss32RVqJ70tjB7/cXoqNidDNdUoTP2SwbJkEWf/XAfUb8ZGW/rFTne+srQ6ta6r7Y++px+Oz9UjPptY25y9E6s/NBxTndGnLP0dUosh/d2YulTs00rqLcynTvNUo3+tmHfl1l9Y8tdBqxurj8d8dofMh4dqyepfVFeav5f+oZOWi1vohb/TRoveX6tj+U9fhDACAPbS8r5GWf71Wrn+DjSJlClp/Txw8neYyTMuQL5rm1TxPaVSi9R97eeiHNvn1w6wjcjpdyhngpYjzcdZrsbERWrtupx5+9AMtX7FD7e6qlWzZb878RU8/2VZDHr9de/ed0tmz4ek6XmSd+CEwJFIuJY0dTCyRIzIm4XlK8QOxAwBk7vjBxA7PfF5d0xsE6tlE680gB1s9pY9WhlwWO4SHxsrL209/bthP/JDBsl0SxAxYFu9CeJTCLkQqOiZW0TFxioqKkbe3p0w+4+9/jqpC6Ytf9vKlC+r4qf/uzFwqLMBXHv/+D5LYiSIB1l/TDLbei3eqwaR21v9I+byKJGyz4899KlXpYuKjXI2SOr7/lLqPaKfjB05r+YJ1bj12ALCbUpWL6bYejTVhwRMqVq6QJn7/lEpVKWY9r9Oymga/fr/V8i4lcbEuK0g5XzyH8jili41XJdOBxTRpjSvpK9+cntYdo7K1cmvryostPi6cP6DAwJIXly9EKTLRD9vEduw8riee+kyvvfE/nT4dZg2iCnvEDyGBvvIw7aoTMbFElO9/3bFSih+IHQAg88YP8bGD4SiRQzn//af+YudXKadT8vN3XBY7bF8VogIFLg6ZYBA/ZJxsNyZI/dpl1atzY7mcLp0LDdeE6T/Kx9tL70zsaX0Rv/5xoxnkXXMXrNGzj9+ph3s1s5q7Hj0Rol1Pfq+Q3ad14dBZlepwk84fPKfjK/dpT6xTD+fy0azz0frcJc10ubTT4aHf1x5U/R51dGrdQe3+dKMVHJXyuUleHv8FOGFnL2j1j5s06Yen5XI69cELX2vSoqe0bc1u1WpWWdvX7rHWAQCu3uwx8xKWpy8fp8ebjUt4/sTbD+mraT8qLvbiHZh4r/ffpoPbL+j4vgjVvDWfFZw4XC4V9HXorUin4jw91D3WpZM5HDqx9KzaDSxu7de0SyG99+ROrZx/Uu3aDdXjgx6ygqCQkHBNnLRID/VrrsYNy1vjgBQtklcz3/5V3e9toHp1y1hJkmkzFvMR2yh+WLYvWEu8HNoT49QUT4fmOZ2a6uOlzWcjtH/Yt2owpUOK8QOxAwBkrvhhQ+Svivn9XJLYwfzbbYZJeL9UDjkPRam7Swp2SRE5HLr933FAEscONVvmVQXfmrqv2y3EDxnMwxXfBiiLCw0NVWBgoG5p94K8vH2vqYx8ww6k+Fr87DCmC4xpAbKoU3VrUNRLRbdP34B3P52bna79ASC7a5Orb7r2v3fD7mTXm8FRq849plyHo6yWIdt6FlFszuTvAn38WPt01WHJ4pGyu/jrdkhIiAICArJl/JDW2MEgfgCA64v4IXsIdUP8kO1aglwvJmiZ3+vmjK4GAOA6MQmPvx++2OoDcAdiBwDI/ogfsp5sNyYIAAAAAABAckiCAAAAAAAAWyAJAgAAAAAAbCHbjQnit/DPJLOzXI2on65tQLQkPFOeihEAkH4eXum7dM1rXivddfA68We6y0DmQvwAANkb8QPi0RIEAAAAAADYAkkQAAAAAABgCyRBAAAAAACALWS7MUFS8vCk3qpcv4JOHjytyf1mKjYm9or7lKpaXEOmP6C4WKciLkTqpd5vqu2DLdXknnqKOB+pyY/MUvCxc6mWUahkAU1bNkYHth+1nk9+5F0Nnf6AfHy95Yxzasqjs3Xi4Gm3HScA2E2NJpXU/cn28vRy6OsZP2v3pgMaNKWX/HP76q8VOzT3le8u28cvZw69PG+wSlUqoqFtJ+nAjmNq1qGOOvZvoajIGE0e8pFOHz2ngRO6qVy14nJ4OvTJ5EX6c+n2VOvicDj01JxBKlAsn07sP6XXHn5bcbFx1/HokR3jB2IHALj+iB/syxZJkHK1SitvoTwa3nyMeozqpKZdGmjJZ79fcb/DO49peKvx1nLPUR3VuENd1b+jloa1fEGV6pZVz5H3aPqQD69Yzubfd+jF3jOsZW8fL0159D2dOXZOdVrepC5D7tSMJz52w1ECgP145/BSp0G3a3SXqYqNuZhsGPnew5o+/GPr39mUmETH2D5v6aHRHa3nJoHS6ZFWGnHPa6pYq5R6DLtT0578TF+/86uOHzyjXIF+mvDZoCsmQZp0qq9j+05oYu9p6vZkBzXpdIuWzVvl5qOGHeIHYgcAuH6IH+zNFt1hqjasqD8X/2Utr/tpk25qVClN+yW+e+fr56PDu4/rwPbD1vNdG/frpoYV0/b+DSpoyv+e0QNjOysmOjYhMI+LieMOIQCkQ9Vbyis6IkbPfz5Yoz95TAWK5bXuovd/8V5N/G6EqtQvl+x+piVeyJnzCc+LlS1otQYxiZRt6/aqTOWi1nqTADHMv91Op+uK9SlStpD2bNpvLe/asE/Vm1bh883CMjJ+IHYAgOuH+MHebJEEyZUnp8JDI6zlCyHhyp03V5r3rdOymmb8MV41m1fR8f2nVPHmslZrDtOKI1fenFfcP/j4OT1Q8yk90eZlBQYFqHGHm631nl6e6jnybn379uJ0HBkA2FveoAAVLlVAY++bph8/XKYeI9qpzE3F9d7oeXrloVka8PJ9aSonZ4Cfws9fvE4YpvtLYn1HdtC3s5desZyD24+odstq1nKd22ooZ6D/VR8TMo+Mih+IHQDg+iJ+sDdbJEHCzl6Qf4CftZwrj7/Czv539+9KNvy2RY81HK0VC9apTZ9mWvTeb3rp+6dV9/aaVnPXKzF3D6PCo63l379dr3LVS1rLQ6ffr0Wzl+jYvlPXfFwAYHfnQ8K1ZfUuqwXHX8v/UfmapXR4zwmdPnpWZ0+GWmMyXJrQSKkc/1wXrxPxLUXitb63gby9PbV0wfoU9+88rJ0m/zZORcsXtv7dn/TrWPnmzKGzJ1IfNwqZW0bFD8QOAHB9ET/Ymy3GBNm+eqe6DG+vXz5errptamnryn/StJ+5Y2MCEeNCaLi8vL20+JMV1qNG08oKORV6xTL8cvlag6AZ1RtX0qEdR60B/MxdoWVfr03nkQGAve34c586PtraWi5Xo6QO/HNUBUvkt364mi4JXj5eSRIaKTm675RKViwsL29Pa0yQff8OZl2jUQU1aVtLzz8wK9X9509daD0S6z22qzb8sjldxwd7xg/EDgBwfRE/2JstkiCmf7a5G/fashes0d3nTbp8poDk1GlVTV2GtpXL6VTI6TBNfniWnpnzmAIL5NbJQ6f15tA5VyzjpoYVdP/ozoqKiNLx/ae18L3f9OHfr2rr6t2q2byqtq/drQ/GfeWGowQAe96pX/3jJk364Wnr3+rXHvtAeQsF6oXPB8vT21MfTViQ4r4vfDJQ5W4qpuLlCuqHj1fqm3eXaNLXQxUdFatJgy/++z74le6KCI/SxHmPW4Opju45M9X6mEE0n/1sqJWA2fDr5jT/aEbmlFHxA7EDAFxfxA/25uFyua480lsWEBoaqsDAQN2qu+Xl4X1NZTh8fdNfEU/PdO3+v7ArzzYDAHZ2R54H01eAX/r/rY87cTJd+y92fim7i79uh4SEKCAgIMPrQfwAANkb8UP2EOqG+MEWY4IAAAAAAACQBAEAAAAAALZAEgQAAAAAANgCSRAAAAAAAGALJEEAAAAAAIAtZLvZYTJ6lHkAAJB1rtuZpR4AAODKmB0GAAAAAAAgjegOAwAAAAAAbIEkCAAAAAAAsAWSIAAAAAAAwBZIggAAAAAAAFsgCQIAAAAAAGyBJAgAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgSQIAAAAAACwBZIgAAAAAADAFkiCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAWvjK4AAAC48e7I/3C69o87ezZd+8e6YtK1PwAAuPHuyAbxAy1BAAAAAACALZAEAQAAAAAAtkASBAAAAAAA2AJjggAAAFWsU1oPje1snYl8hQO1dvEWzXpunoKK5dPsdeP1eMsJOvDP0TSdqQp1yurRqffL5XTp7IlzernXNMXFxnGWAQDIRipm0diBliAAAEA7N+zXU3dPsR5b/tilP37YZJ2VbkPaaNvaPVd1hk4fCdYzd7yoJ1qM1dE9x9X4nnqcYQAAspmdWTR2IAkCAAD+Cww8Hapct6wVzBQqmV8ul3TqcPBVnSFzBycqItpajo2JU1yskzMMAEA25chisQNJEAAAkKBW08ravGqnXC6Xug2+Q/Pf/Pmaz05QiQKq06q6Vi/8kzMMAEA2VSuLxQ4kQQAAQIKmd9+sFd/+qSKlg6znJw6duaaz45/bTyM/elyT+s1kPBAAALKxplksdiAJAgAALgYFng5VqVdWm1ftUtlqxVWqclG9OG+wat9aRYOn9JKnl2fagguHQyM/GaxPxn+pI7uOcXYBAMimHFkwdmB2GAAAYKnZtJI2/7HLas66cuFG62E88eb9+urNn9N8V6Z5t4a6qVEl645Oz+e66Pu3f9ayeas4ywAAZDM1s2Ds4OEytc0GQkNDFRgYqJCQEAUEBGR0dQAAyNTuyP9wuvaPO3s2XfvHumK0VN9m+HWb+AEAAHvFD3SHAQAAAAAAtkASBAAAAAAA2AJJEAAAAAAAYAskQQAAAAAAgC2QBAEAAAAAALbAFLkAANiQMywsXfvvnFUvfe8fESkN/jZdZQAAgBvLmQ3iB1qCAAAAAAAAWyAJAgAAAAAAbIEkCAAAAAAAsAXGBAEAwOYq1C6jAVP6yOV06ezJEE3s86aadKynjo/fqeiIGE16cKZOHQ6+bD+X06ngD79U7KlgycND+e7vqlNvzJZnnkDr9YC2LeRXtaKC5y5QzNGT1rrofQdVdNKz8nBwHwYAgKysQhaNH0iCAABgc6ePBmtU25cVFRGtB8bfq0Z311XnIW01vMU4VaxbTj1HddLrA9+7bL+YQ8fkio1VoacfVcS2nTq/ZJUcfr4q8/j96rtklUr8uVmHDhzRnM53Kdw3h2KDz+nM+/PkmdP/4sBmAAAgyzrtxvjBK0cOja1WUSVOB1+MHcqWknp2tLZ3d/xAEgQAAJs7eyIkYTk2Jk7FKxTR/m2HreVtf+zUw6/0THY/z7wX79i4XC65wiPlyJVTiohSrifG66/oGD3g8FABl9Rx9Ubd88xjOv7nZvnfXP2GHRcAAMj88UMO3xwqcOyEfvj6JxX1kKYnih3MTZRwN8cPtEUFAACWoBL5VadlNW1ZuUPhoRH/BQueyYcLjlz+kodDx8ZM0dmvflDOxnX1VL0aWh0TqzslTXC65Olyqfyxk1bLkIgNW+RfpxpnGwCAbCQonfFD/7g4rY6N03JJd7mk8VJC7GC4O36gJQgAAJB/bj89/cFjmtz/bSto8Q/wSzgrzjhnsmcocutOeXh7qej4EYo+cETn5n2vyn6+cjo81DXOpfgGsOa5/5HjkqdDnoG5OdsAAGQT/m6IH5a884meNwmTOKe6Slb8YGIH0zXGdIVxd/xAEgQAAJtzODw08qPH9MmE+Tqy67g8vTxVqkoxeXl7Wn16920+mPK+OS8GOw5/X8WFXtC+ooXlcLqsuznl47dxuvRzRCRdYQAAyEYcboofzNCnMXFOeUsJ8YOJHQ4VyKfwDe7vSksSBAAAm2vWtaGqNqgov1x+1iBmC2ct1oLpP2ryr2MUHRmjSf1mJruf700VdWH1Rp2Y9LZcMbHK0/kuvfjFd/rW20uB0TGa5fBQnEvaXaSgfjsfrnx1GA8EAIDsopmb4ofC3e9Wvbc+Vr6YWOX4tyWIiR3mtGikiDfeV4EBvdxabw+XGY0kGwgNDVVgYKBCQkIUEBCQ0dUBACBTu92ne7r23zGzdoqv+UdGXZwdxozwXiCfFcSYgc0SM6O7Hx48NsOv28QPAABkfPyQltjBXfEDLUEAAIBbmaDlrTtbcFYBAECmix2YHQYAAAAAANgCSRAAAAAAAGALJEEAAAAAAIAtMCYIACDNWjvM7O3pUD/9s4N4pHM475/XjEl3HSBVGX0gXach1hmtw5xIALAF4gdkpviBliAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgTFBAADp1uK+xhr4Rj91LfSg9fzDHdN0+kiwtfzpS19rwy9/J2xboVIRPTqsjVxOl84Gn9fLYxdo9ueP6vSpsIvbf/i7NqzdqydHd1CpMkGKjIzRmpW79OXcP/4ro3IRDUhUxsQxCxQX51RQoQB98NUgDer7rvbvPaXHn7xTJcsEWftUvqmYerSfyqedjAq1y2jAlD4Xz+fJEE3s86biYuMUVCK/Ptg2VYMajNL+rcn3wPXLmUMvzxusUpWKaGjbSTqw45iadaijjv1bKCoyRpOHfKTTR89p4IRuKletuByeDn0yeZHW/PYXnwUA2NjVxA7uiB/SEzuEhUbe4LOTveMHv2uMHf5cut0t9SYJAgBIFw8PDzXt3ECnDp1OWHchJFwjWo5LdvvTp0L1zJBPFBUVq34DWqpx80q6cD5KIwZ+dNm2k1/8zgpILivjZKhGDb5YxgOPtlSj5pW04rfturdPY237+1DCdtMn/Wj9DSoYoCfH3k0Qk4LTR4M1qu3LioqI1gPj71Wju+tqxfw1undEB21btTPVz98EK2P7vKWHRne0nnt6OdTpkVYacc9rqlirlHoMu1PTnvxMX7/zq44fPKNcgX6a8NkgkiAAYGNXGzu4I34gdsg88UPUNcYO7kqC0B0GAJAuLXs00Yr5q627APF8c/lqypLn9cwnQ5Q7b64k258NvmAFMEZsbJx1F8bXz0dTZvbVM893VO4AX+s1l0sa9kx7TZzWS2XLF0q1DGecU4WL5JHL5dLJ4yGX1bFpyypWkgTJO3sixApgrPMZEydnbJwKlw66eD4TBajJMec+5Mz5hOfFyha07uiYcrat26sylYta600QY8REx8qZ6LsCALCfq40d3BE/EDtknvjBmcGxA0kQAMC1X0QcDjXv2khLv1iVZP3QJs/piRZjte5/G9V7XPLT6prmp3Xql9Xq33dp6MMf6ImBc7Ru9R71fqi59fo70xZrSP/3NWPKjxo6sm3KZdS7WEa3Po30VaIuM4k1blFFvy8hCXIlpvlqnZbVtHrRRnUb0UFfTV2oq5UzwE/h5yMSnpsmrIn1HdlB385eetXlAgCyh/TEDu6IH4gdMl/8cKNjB7rDAACuWudh7dSwfV1tWrpFy75cZWX8EwsLvpjdX/7lat35YKvL9vf399HIsR01afy31p2csNCLF77lv23TnR1qXyzj33WHDly8C+BweCS5C+Cf00dPj+uoyeO/VcHCgda6E8cubwVSoGBu6z3MHSCkzD+3n57+4DFN7v+2CpbMf/F8Hki9FUhyzoeEyz+XX5K7PfFa39tA3t6eWrpgPR8FANhMemMHd8QPxA7u54744UbHDrQEAQBctflTF1r9dn39c6h17+Z66YdnVaxCEQ14ra+8vL3k7XMxx16jWRUd3XM86YXH4aGRL3TSJ+8v15FDwfLyclgXN2v7WqV09HBwQqBj5Mnrb72eOAFilfF8J30y+2IZZSsUUqmyBTXh9R7W3aHBI9vK89+7CE1bVtWK37bxKacWDJjz+dFj+mTCfB3ZdVxla5RSqarFNeH7karTqroGv/mgPL0ufkZXcnTfKZWsWFhe3p6qWq+s9m0/evGzbVRBTdrW0lujv+KzAAAbSk/s4I74gdgh88YPR29w7EBLEADANXtv5NyE5RlrJ+rt4XOUp2CgJiwapcgLkYqJitWUB2cm2ad5q6q6qXpxK0jp2a+pvv96vbr1aqTIiBjFxMRpyovfWduNtPr3+lnNZk3T1sSa3VZVVWsUl9+/ZSz8er2eeORD67URoztY3WLMHSKjSYsqevGZL/mUU9Gsa0NVbVBRfrn81HNUJy2ctVhPtHz+4vl8b4DVrNWM9p6SFz4ZqHI3FVPxcgX1w8cr9c27SzTp66GKjorVpMFzrG0Gv9JdEeFRmjjvcWtAtGe6v85nAgA2dC2xgzviB2KHzBU/vHANscPonpd/L66Fh+vSdkhZVGhoqAIDAxUSEqKAgICMrg4AZEutHSn30U2T+tXTXQePdF61fl4zJt11yA5u9+merv0d+fOla/9YZ7R+Pflehl+3iR8A4Pojfsg+bs8G8QPdYQAAAAAAgC2QBAEAAAAAALZAEgQAAAAAANgCSRAAAAAAAGALJEEAAAAAAIAtMEUuAOCGqfLW9nSX8f229M8wA+nn6M8y9DRcnJXlPT4KAMAVET9kHj9ng/iBliAAAAAAAMAWSIIAAAAAAABbIAkCAAAAAABsgTFBAADXrFCpIL25dqIObD1kPR/f7TWFnA5V826N1GlIW0VFRGvS/W/q1OEzinXFaF6f3xS8J1Rd59ymgGK5tOiJFYqLcsrD00O3jauvgKK59PcXu7Tho+0qWDWf7prUxCp327d7tXXBHsklRVQ6o9ijJxUbHCqvoDwq8GBHha/fqtCfVsnDx1sFHuksr/x5dOaDbxV95JS1f/SeQyo+/Wl55vLn0wYAIIvEDgbxA9yNJAgAIF3+XrZN47tNSXju6eWpzsPaaXizMapUr5x6ju6i1x95Rw55qv0bzfT765us7RxW4uMW5Sror6NLD+vkM3+of4U8qps3h8q/3lRLZ21NKLNY3YKq0qGMtfx2u1/lX7OiggZ2U8jC5VYCJOTHlSoyur+i9h7RuW+WWImR/A/cbW0fe+acTr8znwQIAABZLHYwiB/gbnSHAQCky02NK+m1ZS+o34Tu1vNiFYrowLZDio2J1dZVO1SmWsmLFxwPh/zy+ibs5+njaSVAfMJjdO/kDSq/+Yxu+W6ven2wXf2fXClHnCth28BiueTh4WE9FBsn7xJFrPU+pYsq7Ld18ilWUB5eXvKtWEoxh04kqd+FtVvlX+8mPmUAALJY7GAQP8DdSIIAAK5Z8LGzur/C4xrefIzyFAxUk471lSuPv8JDI/670Himfqlp9OlOzTwariGmeWKsSw6nS0GHzqvAofOXbbt32RF5Fc6v6H2HrecRW/ZYfz38/kuuuJzOJPuEryMJAgBAdoodDOIHXCuSIACAq2aarE7+bZw6PHaHIsOjrHUr5q9WuVpldP7sBfkH+CVs64xLmpS41OyF+9XfIZVLtM7pkHJExCbZ7vTOc/pr7g4FDekhDy9PHZ/wnlxR0XLk9JMrIjJhOw/Hf5e22DMh8vB0yCtPbj5lAACySexgED/gWjEmCADgqs2futB6+OX6rwVG9WZVdXD7YR3ZfVylqhSXl7eX1a937+YDKZaz7r2tKlPEX/cdNq0+/uv+4nBKUX7/XaIunIrQkgnrdOfkJlpyKofy9WprrT87/1flvKW6gj/7Sa7YWGtMEO8Shf/bb90W+devxicMAEA2iR0M4gekB0kQAMA1q9aksu4f311R4VE6vu+kPhz9uXX35us3FmnK0ucVHRmtV/u+mbD9d48v0+kdZ3Vuf5hKNyuqtbO26HC1/Gri41CzyDi96OWheXEuvZ7DU1uDI3VowBLdM/NWrXlni8LPRurnUat0KmSD5HTK4ecr35vKybdyaQXc0UjHX3xPHt5eKjCgS8L7ha/dqqDBF/sbAwCArBc7GMQPcCcPl8v13623LCw0NFSBgYEKCQlRQEBARlcHALKl1o6u6dq/yp/J597N4KjNvtil/Ecu6EyxnFp+bwVF+3snu+3326qnqw77eo5K1/7IXtftzFIPAMjOiB+Qma7btAQBAGQ4k/D45YGqGV0NAACQhRA/4FowMCoAAAAAALAFkiAAAAAAAMAWSIIAAAAAAABbYEwQAMAN888t6S+jUq696SugZ/rrAAAAbhziB7gTLUEAAAAAAIAtkAQBAAAAAAC2QBIEAAAAAADYAmOCAADSrcV9jTXwjX7qWuhB+frn0Livn5S3r7eccU5N7jdTJw6cSna/CrXLaMCUPnI5XTp7MkQT+7ypV//3rJxOl7x8vPTGwHe1f+vhFN+3Yp0yemhcF2s5X6FArf1ls0pVLiqfHBff+7VBH+jEoTN8wgAAZDIZFTsYxA/25uFyuVzKBkJDQxUYGKiQkBAFBARkdHUAIFtq7eh62ToPDw+NnjdchcsU1MC6T8vbx0sBBQJ05miwbm5dQ43urqfpg2Zf3NYrae49b6FAhYdGKCoiWg+Mv1e7N+3Xqm/XKy42TtWbVlHrXk312iOzkuzjyJUz2boNfaOvfv3iDx3dd1Jnjp1TnRZV1fDOWprx1KdJtvsp+D03nAlkl+t2ZqkHANgpfria2OHS+OFaYgeD+CF7CHXDdZvuMACAdGnZo4lWzF9t3ZExYqJjrSDGiI2JU1ysM8V9z54IsYKY+G2dsWb7OOt5zgA/7dtyKE11cHg6VLluWW35Y5eVAEl477iU3xsAANg3djCIH+yJJAgA4NovIg6HmndtpKVfrLrsNU8vT/Ua3UULpv1wxXKCSuRXnZbVtHrRRgUWyK2pS8fp8Wn9tHnF9jTVo1azytq8cofiGzea9+75ZHt9+86v13BUAAAgu8cOBvGDPTEmCADgqnUe1k4N29fVpqVbtOzLVQnJh8SGvfOIFr6zWMf2nki1LP/cfnr6g8c0uf/b1p2ckNNhGnbrOFWqW04PjL9Pz7afeMX6NL27rpZ8uSbh+ZDX+2jRh8t0bH/y/YkBAIC9YweD+MGeMmVLkMjIyIyuAgAgFfOnLtSIluOsgcxa926ul354VsUqFNGA1/par/d4tpOO7z+pZfMuv8uTmMPhoZEfPaZPJszXkV3HrWappp+wcSE0XJHhV74emH2q1Cunzat2Ws+7P9FWxw+c0vIF6/gMAQDIJDJT7GCVQ/xgW5miJcjJkyc1e/Zsfffdd9q0aZOio6Pl4+OjWrVqqV27dnrooYdUqFChjK4mAOAS742cm7A8Y+1EvT18jvIXyaveY7pq68odqtWimrat3qn3RyUdnDRes64NVbVBRfnl8lPPUZ3080fL1KbvrXI6nVY/4TeHfHDFc16zaWUrAWLuKOUrHKieT7XXtjV7VKtpFW1ft0cfjP+azw0AgEwiM8QOBvGDfWX47DCjR4/Wu+++qzvvvFOtWrVS1apVrVFezaiv27Zt02+//aYffvhB/fv31/jx41Msh9HdASBjZoe5GpfODnMtUhrdPa2YHSZzyCzX7cxSDwDIzogfkJmu2xneEsTPz0979uxRzpyXB7V16tRRr169dOHCBU2bNi1D6gcAAAAAALKHDE+CjBo16orbmATJM888c0PqAwAAAAAAsqdMOTCqERERoQMHDmR0NQAAAAAAQDaRKZIghw4dUuvWrVWmTBlrgNSVK1eqaNGiKlu2rDVGyP79+zO6igAAAAAAIIvLFEmQYcOGqXbt2urWrZsGDhxoJUF27dplJUdMEuTZZ5/N6CoCAAAAAIAsLsNnhzEKFiyow4cPKy4uzhr/4/Tp08qXL5/12vHjx1W3bl3r9dQwujsAAFlHZrluZ5Z6AAAAm8wOY0RHR8vHx8daNgcUnwAxChcubB0gAAAAAABAlu8OYxIdwcHB1vLChQuTvHbkyBErMQIAAAAAAJDlkyAjR47UhQsXrOXGjRsneW3x4sXq0qVLBtUMAAAAAABkF5miO8z9999/Ta8BAAAAAABkqZYgyYmMjFRERERGVwMAAAAAAGQTDncnLmJjYxOeL1iwQN9///0V95s8eXLCshkE9Z577lGuXLms0V47dOigc+fOubOaAAAAAADAhtyaBGndurXWr19vLT///PMaOHCg9TDLqXnhhRcSlkeNGmWND7J582brYWaOee6559xZTQAAAAAAYEMeLpfL5a7C8ufPr5MnT8rT01Nly5a1ZnrJnTu3NdjpwYMHU9zPbBMWFmYtlytXTr/99ptKlSplPT98+LC1/4EDB677fMEAAODGyCzX7cxSDwAAcGOu224dGDUuLk4eHh7avXu3nE6nqlataq0/e/ZsqvuZfeKZViDxCRCjePHiOnPmjDurCQAAAAAAbMitSZB69epp0KBBOnbsmNq2bWutO3TokPLkyZPqfuHh4apTp461bFqE7N2712pJYhw/ftxqKQIAAAAAAJBpkiDvvvuunn32Wat5Svw4IKtXr1bPnj1T3W/27NlJnjsc/w1VsnHjRvXu3dud1QQAAAAAADbk1jFBMhJ9egEAyDoyy3U7s9QDAADcmOu2W2eHMT744ANrlpgaNWpYz5ctW6Z58+ZddTkRERFXHAwVAAAAAAAgQ5IgEyZM0NSpU3XvvfcmzAZTpEgRTZo0KdX9zLghJnFSpkwZq2vMypUrVbRoUWtcEDO46v79+91ZTQAAAAAAYENuTYK89957+uGHH/TQQw8lzPhSvnx57dmzJ9X9hg0bptq1a6tbt24aOHCglQTZtWuXlRwxSRAzzggAAAAAAECmGROkYMGC1swwnp6eypcvn4KDgxUVFaXSpUtb61Pb7/Dhw9YUuzlz5tTp06et/eNnh6lbt671emro0wsAQNaRWa7bmaUeAAAgC44J0qBBA82YMSPJuvfff1+NGzdOdb/o6Gj5+PjIz8/POqD4BIhRuHBh6wABAAAAAAAyzRS5r7/+ulq1aqU5c+bo/PnzatSokU6cOKFffvkl1f1MosO0GjHJj4ULFyZ57ciRI1ZiBAAAAAAAINMkQcxAptu3b9f3339vzexSokQJtWvXzurikpqRI0fqwoULVhLk0lYjixcvVpcuXdxZTQAAAAAAYENuHRMkI9GnFwCArCOzXLczSz0AAMCNuW67tSVIWFiYNUXun3/+aS0n9ttvv7nzrQAAAAAAADIuCdK7d29rWtvOnTtfsQtMWjkcDmtskbFjx6p169ZuKRMAAAAAANiPW5MgS5cu1cGDB93anHTJkiVWmZ9//jlJEAAAAAAAkDmSIGYgVDPdrTs1b948oZUJAAAAAABAhiVB/v7774TlQYMG6d5777VmeylUqFCS7WrUqHHVZU+bNk39+/eXn59feqsJAAAAAABsLt1JkFq1asnDw0OJJ5kxXVgSM6/HxcWlKZGS2IsvvmglT8zUudeSRAEAAAAAAHBbEsTpdOp6JFLitWzZ8opJFAAAAAAAgCtxyI2ioqIUExOTZJ15btanxnShadasmXbs2GElVeIfpkvNsWPHSIAAAAAAAIDMlQRp06aN1q1bl2Td2rVrdeedd6a632effaannnpK7dq10/jx4xUbG5vwmmkFAgAAAAAAkKmSIGZsjwYNGiRZZ55v2rTpivuaRMmGDRt08uRJq3vMihUrSIAAAAAAAIDMOUWumcXl/PnzCggISFhnnvv4+KRp/5w5c2r69OlavXq1Hn74YZ06dcqd1QMAAAAAADbm1pYgZhDTYcOGKTo62npuxgJ54okn1KJFi6sqx7QeMa1Cdu/erQIFCrizigAAAAAAwKbc2hJk8uTJat++vZW4KFasmI4cOaJKlSrp+++/v+qyzLggBQsWlMPh1jwNgBustaNr+gtpkM4pslcnPw331Vjs/DLdZQAAAADIWG7NMJjZXNasWaNffvlFL7zwgvXXDIxauHDhKyZP4oWEhOiee+5Rrly5rG41HTp00Llz59xZTQAAAAAAYENuTYIMHDjQGsy0fv366tq1q/XXPB80aFCq+5mESbxRo0bpwoUL2rx5s/UwXWuee+45d1YTAAAAAADYkIfL5XK5qzDTciM0NPSy9fnz59eZM2dS3C937twKCwuzlsuVK6fffvtNpUqVsp4fPnxYjRs31oEDB1J9b/O+gYGBVkuSxAOzAsi83WEq1Suv/q/0spbzFcmrtT9u0NvD51y+YYMaqlCpsB4d0kbmn6yzwRf08rgFmv3pAJ0+dfHfjk/n/K4N6/apWs0SenhQa2u7dav36JP3l6fYHabFfY018I1+6lroQXl5e2ni/y4mXH38fOTt46VHb34qYVu6wwDulVmu25mlHgAA4MZct90yJsh3331n/Y2Li7PG/0icV9mzZ49VydSY1iLxTCuQ+ASIUbx48VQTKACyrh3rdmtEy3HW8vB3B2jVN+tS3NYkO54ZNldRUbHq90gLNW5WSRfOR2nEoI+TbNetRyNNevFbHTpwRlPf6qsF89boQgr/7jTt3ECnDp22nsfGxCbUpVXPpipSrpBbjxUAAABAxnNLEmTIkCHW38jISA0ePDhhvRnU1IwTMm3atFT3Dw8PV506daxl0yJk7969Klu2rPX8+PHjVksRANmXw9OhyrdU0NSH30lxG9P6I15srFNxcU75+vtoyow+VoLkzSk/KiwsUgf2n1LOnDnk6emQ0+lSdHRssuW17NFEK+avVpfh7S97rVmXhpo96lM3HR0AAACAbJUE2bdvn/W3W7dumjdv3lXvP3v27CTPE88Is3HjRvXu3dsNtQSQWdVuWU2bl29L0oosJUGFAlSnXhnN/XCF/t50UGGhEbrtjhrq/VBzzZz6P61avkNjXuqqmJhY/frTFsVEx11Whvk3pnnXRhrb8dXLkiB+uXwVVCK/Dm4/7NZjBAAAAJDNpsi9lgSI0bdv3xRfu/POO60HgOyj87B2ati+rv74fr3mT12oZl0b6te5K664n7+/j0aOuUeTJnxntQQxCRBj+W/bdGeHWtbyI4+31vBH5+jE8XNWMqRkqQI6uDrp+25aukXLvlyVbNKlYYeL9QIAAACQ/bg1CRIVFaXXXntNS5cu1enTp5P8wNiwYYM73wpAFmYSH+YR3xWmSoOKev2RWanu43B4aOS4jtZAp0cOBcvLy2GN6xETE6catUvq6OGz1namC8yF85Ey//xEhEcrZ64cl73vQxN7qnXv5mrVs5mKVSiiAa/1TRiQ1XSF+eC5z67r8QMAAADIBkmQ4cOHWwmQhx9+WM8++6wmTJigt956S927d09XYsXf398adBVA9lOrRTVtXrH9il1hmreqqpuqF7dag/R8oKm+X/CnuvVspMjIaKvLy5SXvre2+/j95ZowpbvVUuTQwTPavvXIZWW9N3JuwvKMtRMTEiCmK0zBkgV0YBtdYQAAAIDsyK1T5BYrVkwrV65U6dKllSdPHp07d07bt2/XwIEDtWTJkmtOgvj5+cnpdKa6HVPcAVlvitw0a1AjffunMEXu1WCKXMC9Mst1O7PUAwAAZKEpchNPb2sSIIavr681W0yVKlX0559/prpfvnz5UnzN5GgST6ELAAAAAACQ4UmQChUq6K+//lLNmjVVvXp1TZ061WoRUqBAgVT3M608zLbx0+Je2hKEgVEBAAAAAECmSoK89NJLOn/+fMJyjx49FBYWpnfeeSfV/erUqSMfHx81b9482SSIG3vsAAAAAAAAm3JrEqR169YJy/Xq1dOuXbvStN+YMWOUM2fOZF8zyZFrHU8EAAAAAADguiRBDDOLy4EDBxJahMSrUSPlgQ1vvfXWFF8z44Ek10IEAAAAAAAgw5Ig33zzjfr3768zZ85clshIaYpbs23+/PmvWHZat0P6Z+PwLFQw3acx7uSpdO2/OG5euuuAzMEjR450l/HT1x+la/+7arRKdx0AAAAAZH0OdxY2ePBgvfzyy9YsMWaw0/hHSgkQo379+nryySe1bdu2ZF83U+ya1xs0aODOqgIAAAAAAJtxa0sQMyVuv3795HCkPbeyadMmTZkyRbfddpuVMKlcubI136+Z/3fHjh3WNo888og2bNjgzqoCAAAAAACbcWsS5LHHHtP06dM1ZMiQNO+TO3dujRs3TqNHj9batWutpMjZs2eVN29e1apVy2op4unp6c5qAgAAAAAAG3JrEsSMB9K0aVO9+uqrKlSoUJLXrtSSwyQ6GjZsaD3gXoVKBenNtRN1YOsh6/n4bq8pKjxK475+Ut6+3nLGOTW530ydOJD8OB4Oh4dGTO+rAoUDdeJQsF4fMVd3P9hCTdrWUkR4lKYM+VjBJ0LSVBczPsyI9weqSJmC1tTHkx98S8f2nnDr8SJzK121uIa82U9xsXGKOB+lCb2n663VE3T66Fnr9c9e+VYbftuSsH2sK0YN7zqkrTuitWpRcVWrnEOHj8bqsWdOKizMqVsb+2vME/m0bUe0Bjx5UnFOl55/Kr9ua+avVesiNODJU9p1+iO1KNAnyfdw+LQ+KlKqgMwM3K8NmaOGd9ZSk3a1FXEhSlMen5Pm7zQAAAAAmyZBunTpojJlyqhz587y9/d3Z9FIp7+XbdP4blMSnnv7eGlSv5k6czRYN7euoW5PdtD0QbOT3bfxXbV0/MBpvfrYh+oy8Da16FhP9W+7ScM7TFHFWqXUY9idenPk52mqR7lapeWdw0vDbx2rOrdV192P3aG3n5jD52sjh3Ye07CWL1jLvUZ1VOMOdXUhJFxPtpmQ7PYOeeq7j4rqqfGnE9aZ5ZkTC6pYgEN6P0QeT57Us2sjNHtmYRUq6a27ehy1kiA3VfLR6h+Kq1il0CRllqtW3Pp/YESHKardvIq6D7tLBYvn0/C2k1Sxdmn1eOIuvfnUZ9f5TAAAAADI0kmQv//+W8HBwfLx8XFnsXCDmxpX0mvLXtCW37fr/Wc/U0x0rJUAMWJj4hQX60xx38KlCmjP1sPW8p7Nh9RpQCsd2HHMer578yENe61nmutx+vB/MwflypNTIaeS/jhF9mdagMTL4e9jJUX8cvlq8s/PWq1BZgybo7CzFxK2cXg4FFTgvy5xMTEuHTgUoxGjT+nUknCNj3Cpkad0PFaq+NgJuRYVV768Dp0+E6cC+ZPvSnfq2LmE5VwBfjpx6IzVAsTY/fdBDZva+zodPQAAAIBsMzuMmcFlz5497iwSbhB87Kzur/C4hjcfozwFA9WkY/2E1zy9PNVrdBctmPZDivsf2nVctRpXtJZrNa1sdZ8xLUDMnfTazSorV2DaW/2EnA6Ty+nS7K1T9dDEXvp5ztJ0Hh2yojotq2nmHy+qZvOqVneooS1f0IjbJ2j9z3+r93OdUt33dHCc/t4WrUllvDU3wqVhLskjVnKZF3dFWy1DAnM7FHwu5VmpQs+ct76H764cpwfHdNLPn61K+p3OQ0s2AAAAIDtya0uQunXrqk2bNurVq5cKFy582fS5uLE6D2unhu3r6o/v12v+1IXWuhXzV6tqw0r6fcFa6/mwdx7RwncWpzoux5rFW1SjcUW98tUQ7f/nqA7tPqED/2zShM8Hae/Wwzq852Sa61S3TU1FRUTrwZuGqXztMnpkSh+91OMNNxwtshIz5sfAhs+p6/C2uuvBlvpi8vfW+uVfr9GdD9ya6r55AhyqWM5bJc45JU/JK1aKjc/oOiSPgzE6F+pUvjwpD6h8c4uqio6MUf/G41S+egkrEfLDnBWaMG+w9m45rMO7GacGAAAAyI7cmgRZs2aNypUrpz/++CPJejMIYVqSIGagzJ9//lnbtm1TsWLF1LZtW+XMmdOdVbQVk/gwD9PVIF71ZlV1cPvFri09nu2k4/tPatm8VVf8XGaNnW8t93riLm1csUNb1+7R4nmrVaNhBZ07HXZV9Tr/b1eH8+cuWF1iYC+mtYXpjmWEh0RYg/PGr6vepLKO7Ek9AeHn51CeAE+dK+gp7zgp+t9/yEzadVecVLCQp87+E51iV5h4YSHh1t/zoRFWa6bFX/xhPWo0qnjV32kAAAAANkyCLFmy5Jr33bFjh+677z7Vq1fPmhp348aNmjhxor755huVLFnSndW0nWpNKuv+8d2tGWGO7zupD0d/rvxF8qr3mK7aunKHarWopm2rd+r9UZ8mu3/eoAA98/YD1rghG1f8YyVARr71gALz59bJw8GaMeqLNNflz5//0m29mmnKb+OsAVLfHvGRG48UWUGdVtXUdVhbOZ0uq3vUu6M+1etLxioyPEoxUTGaMuDdy/Zp2/Oo/toapZ17otW/d6DGj8ynDi+cUUwOD70Q5ZLLU5oQJ/Xz9VDcr+EaNzK/td/2ndEa8twpXYiL1bpzC1UpZwMFeBfQhqXb1KrrLXr1m+FWAmbW2K808p0H//1On9GMNA70CwAAACBr8XCZ2/xucujQIeXOnVt58uRRVFSUZs6cKW9vbw0YMEBeXinnW0JCQnTLLbdozpw51t94v/32mz788EPrYabdffrpp61WJckJDQ1VYGCgVVZAQIDsrLWja7r29yxUMN11iDuZ/HS7abU4bl6664DM4Xa/Xuku46d9a5J/4YLz4uwwB2PkKukt9QuUcl4+1NFdNVqlvw4n3053GQAy33U7s9QDAADcmOu2W1uCdOrUSbNnz7aSICZh8euvv1pJENPKY/r06SnuN3XqVPXt29dKgJgxRWJiYhJeO3DggBwOh5YvX678+fOrf//+7qwygKzMJDwez3txUFQAAAAAuJGzw+zevVvVq1e3lufNm6eFCxdq8eLF+uqrr1Ldz3R5MYOpGq1atVLRokU1YsQIFS9e3EqOGC+88ILVIgQAAAAAACDDW4KYFhvR0dFWyw/TNKVUqVLWoJrnz59Pdb/Dhw+rRIkS1vLHH3+s9evXK0eOHGrZsqVuvvlmjRkzRrVr19Y///zjzuoCAAAAAAAbcWsSpHnz5urWrZvOnDmjjh07JrQOKVgw9TEm/P39derUKQUFBVl9fI4cOaKyZctayZGwsIuzNISHh8vX979ZTgAAAAAAADIsCWLGA5k8ebI1DshTTz1lrdu5c+cVp8dt1KiRfvnlF3Xv3t0aS6RZs2Zq0qSJVq5cqVGjRlnbLF26VPXr13dndbMth79/uvbfObVouusQ9H3ZdJeB7MEVFZXuMu6q2Tpd+zvPnU13HQAAAABkfW5NguTNm1cTJkxIsq5t27ZX3M8kSR555BHdc889GjhwoFq0aKEtW7Zo7NixqlKlijXTjFl+/fXX3VldAAAAAABgI+lOgrz99tvWFLjGtGnTUtwutdYgpiWIaQVyxx136JNPPrESH+YRP+1unz591K5dO6uFCAAAAAAAQIYkQb777ruEJMiCBQuS3cbDw+OKXWJMt5fy5cvr9ttvt8YQMQOlmrFBjh8/rmeffTZh9hgAAAAAAIAMSYL88MMPCctLlixJV1lmUFXz2Lt3r06cOGENlGoSI0i/W7s20KOTeure0o/r/U2v6PSxi2MkfP7q99qwZOtl27ucTp2a+ZXigkPlFZRX+fu21YnXP5MrJlYeDocKDOgk76C81vMzcxYq5tgZOfx9VeiJnknKub1hZQ3v00J3PPqW9bxQ/tz6ako/9X3uE+09fEbDe7dQhVJB8vXx1twf1uuX1Tv4uLM5v1y+emXxGJW+qYQGNxyl/VsPWevvfuwO3da7uTWj1KcT5mv1wj+T3d/h8NCIN/uqQOE8OnHojF5/Yq7yBgVo0Cv3yT+Xr/5auVNzp/z371JyKtQuowFT+sjldOnsyRBN7POmmnSsp46P36noiBhNenCmTh0Ovi7HDwAAACCbjAkSLzY21prNJTEzZW5amZlhzAPuYVriNL2nbsKPuguhEXrqzomp7hO+dpu8C+ZTwUHddO67FQr/a5eCBnSWV74Ahf+9SyHf/64C/dor9H+r5Verkgo8VCWZ95Va1q+gE2cuzvBj9GlfX3/vPJrw/I1Plykuzim/HN6aNfY+kiA2EBURrdHtJ+rhV3snWd/+0TZ6uOYT8vXPoZd/ei7FJEjjtrV0/MBpvTrwQ3V5rLUat62tRnfW0PSnPtOZ4yFpqsPpo8Ea1fZlqy4PjL9Xje6uq85D2mp4i3GqWLeceo7qpNcHvueW4wUAAACQeTjcWdjq1atVs2ZNaypbM0iqeeTJk8f6i4zToltDrfhmvXXX2/DLlUOTfnpGI98foNx5cya7T8zJYPmUKmIt5yhTRJH/7LcSIP6RUbp79RY12r5PA75dpqiNOxS144COvfCeQn9Zm6SMNo2q6Le1u6w7+0aRoABr+fiZ0IRtTALEqlMOb+07cua6nQNkHs44p0JO//cdiHd093Hl8PORX24/hSZKnF2qcKkC2rPlsLW8Z/NBVW9QXoVK5Ff/5ztr4vwhqlL3ygnUsydCrASIERsTp+IVimj/tsPW8rY/dqp0tRLpOkYAAAAANkiC9O3bV3fffbc2b95sdWkxj3379ll/kTFM14Fmnepr2VdrEtYNu+1FPXnHy1q/eLN6jbon2f28iwYpYuvFzy1iyx45L0RaCZDPn3tbO5b8qdePntITX/yioJ0HFVCqsAo/+4AurPxbsWcu3ol3eHio1S2VtHj1P0lagcxdtP6y93p+4F2aO7GP1m4+cB3OALKKdf/bqPe2TtWMtS/rm+kpd2c5tOu4ajWpZC3XalZZxSsUUpmqxfTeuK/1yoAPNODFLml+z6AS+VWnZTVtWblD4aERCesdnm79pxEAAABAduwOc/LkST3//PNW9wtkDi3va6TlX69NaI1hhAVfsP4uX7BWd9zfPNn9/OtUUuS2fTo2frZ8iheSZ55c6vO/1Zp85JQelVT531YlQbFxanvstOZ4eipHxZKKOXZaXvkDdUeTKvp1zQ7Fv22xgoHW32PJtAAYO/MH5fbPofdf6KFFK7Ym7IPspfOwdmrYvq7++H695k9dmOQ1/9x+atu/te6vOFjePl6a9OtY/bn472TLWfPzFtVoXFGvfD1U+/85qr1bDit3npw6feyc9XpcrNNKYpgWJ6kx7/n0B49pcv+3re39A/wSXrvSvgAAAACyJrcmQXr06KFvvvlGHTt2dGexSIdSlYupXM1SanVfQxUrV0iPTOyh98fMU0x0rKo3rqSje04ku58Z/DR/n7us5bNf/Sq/auW07uMfVNXDQ/cmylI08pBi9x+zlqMPHlfulnWt5TLF8qtS6YK6o3EVlSicV28+01Ung8P0+lOdVK5EAZUolFePTphntRiJiY1TZHSswiNjSIBkYybxcWnyI57T6VJ0ZLRiomIUFxsn7xzeVjI1cfIunlk3a8x8a7nXiLbauPwfla9RUv65fa3uVV7enldMYpgWUiM/ekyfTJivI7uOy9PLU6WqFLP2NWOC7Nt80E1HDQAAACDbJkFefPFF1a9fX5MmTVLhwoWTvPb111+nqSXJSy+9pA0bNuj8+fNJXjPrcPVmj5mXsDx9+Th98dpCTf11tCLDo6wfnK89OjvZ/WLPhenUtC8kT4eVAPEqmE9f7zumky6XbpXUUNLLkp5ySS2OndbRsbPkV7OCvAvls/af8fmKhLI+HN9T94+em/B89CNtrG4x5gfrhCHtFZDLT15eDs1esJqP2CYmLHxG5WqVVvFKRbVo1mL9PGepls9frWmrJlitMr6b+VOyCRDDzATzzDv9rO+PSYBsXbtHH770nV74ZKA8vT310SvfX/H9m3VtqKoNKsovl581COrCWYu1YPqPmvzrGEVHxmhSv5nX4agBAAAAZDQPV0q/NK5B27ZtdeDAAeuvv79/ktfGjh17xf1btGghT09Pde7c+bL9zXgjqQkNDVVgYKBCQkKuaiaa7KhNrtTP1ZXseq9isuvNmCDzR7+j8kdOyenwkMPp0u5iQeo8/hGF++ZIsm3Q977pqsOauU+ka39kHq0dXdNdhmdQULr2d569OCV0evwc/Vm6ywCQ+a7bmaUeAADgxly33doSZNmyZTp69Og1V8a09jh16pR8fHzcWS24iUl0mISHGRuk+KmzOhyUVx+1aXBZAgQAAAAAgMzIrUmQqlWrKiws7JqTILfccot2795tlYPMySQ83r47+cFUAQAAAACwTRKkU6dOVleYgQMHXjYmSIcOHa64/0cffaQuXbqoWbNml+0/ePBgd1YVAAAAAADYjFuTIO+884719+WXzZCZ/zGzPKQlCTJ16lStX79eMTExScYEMfuTBAEAAAAAAJkmCbJv37507f/WW29Z44LQHQYAAAAAAGTqJEh6BQUFqWzZshldjSzPGR6erv2LfpH+gWlz7g9JdxnIHhY7v8zoKgAAAACAxaFMZPTo0erfv7927dplTX2T+AEAAAAAAJBtWoL069fP+jt37lxrHBDD5XJZy3FxcRlcOwAAAAAAkJVlqiRIescUAQAAAAAAyBJJkFKlSiUsnz59WgUKFMjQ+mQXFeqU1aNT75fL6dLZE+f0cq9piouNU5fh7dSkUwNFno/UpAdm6Myxswn7lClZQE8OuF1xTqciIqI1dsr3urNFNd3R4ibTPEdzvlytlev3qHTx/Hpq4O1yOBx679Pftf7vAwlllK9SRI+OuEtOl0vnzpzXxGe/0tDnOqh+s0qa+84SfffFWmu7J57vqFLlCioyIlprV+zUVx+tzJDzBAAAAADI3tySBKlVq5a6d++uvn37qnDhwtdcTnh4uIYNG6aPP/5YUVFRypEjh/r06aMpU6YoZ86c7qiqLZ0+Eqxn7nhRURHR6jehuxrfU0+bV/yj+nfdrKFNnlOleuXVc3QXTRv4bsI+B48Ea+CoT63lB7o1UrNbKqjjnbV0/9APlSOHt14b29VKgjzcq6lemv6jgs+Fa8qYLkmSIGdOhmnUYx8pKjJGDwy6TY1uraIP3vxFf/+5X37+SQdfnTJ2gQ7sOXkDzwoAAAAAwG7cMjDqtm3b9Omnn6pkyZK6++67tXDhQjmdzqsu54knntDOnTv166+/6ujRo9ZfM0jqiBEj3FFN2zKtP0wCxIiNiVNcrFOFShXQgW2HrHW7NuxVtcaVk+wTF/ff5+ebw0sHjgTryLFz8vHxkr+fj0LCIqzXCuTNqcPHzik8IlqhYREKzO333/ueOW8lQKz3jY2zygw+ff7yCrpcGjrmbr38Vl+VrVjo+pwEAAAAAIDtuaUliK+vr/766y+tXbtW77//vnr16mW13Lj//vv1wAMPqHz58mkq57vvvtPmzZuVL18+63mhQoU0b948Va9eXW+99ZbtP6z0CipRQHVaVdfcF+crZ6C/KtUtJ+//t3cnYFZW9R/Af7MxrDNaoIgiKCqmFmJKohK5a4FlYOVCkmuaErlDWG7kvoRJRFpZqKVZZm7JPxf0r+RufxdUTGR1YZsZttnu/T/3RUdHwJQBZua+n8/zzPO+c+57zj3v5Xm45/nOOedtUxx99t4pOm686kybXfv0iJO/OzDq6jMx6a9PxL+efSMmXXtMFBUWxthx96686L0NbHOWLKuJsk5tGwKShvftWh59v9Qrbr7+4dX2a+LV/4iqiuXRvWfnZGnMyKM/mJECAAAALfIRuf369YsJEybEvHnzYuzYsTFlypTo3bt37LPPPp+ofu5JMLm9JRp1sLAwKefTG/KjQXHFA+clx/ad2sU5vz81Lj9mfLIfSOWCqrjrV5Pjkn+cG/0O7huzX5m7Sv2nnn8zjjn99/HQY6/GkK/2jUMO6BOHn3x9HHHKDXHiUQNW/ptlPvi36dihNCqrVjRqo32H0jjroiHJcpfcDJTVyQUgObNmzH/v3/yDYAUAAABaZAjyvnbt2iWzQB555JFkqcxuu+32ieoNGjQohg4dGk899VS8++678eSTT8a3v/3tGDx48ProZt67/eq74ox9zou//vyeOGfSiJh04W0x57V5Da/ff+NDcfreP41H//qveO7BFxrVLSkuajhfuqw6qpasiJqauqiprY/q6tooKSlKJoEsWLw0tthso2SJTFnHxrNAcmHG2WOHxk0TH4o5MxessZ+5oCSnfOMOycyUzIeCFQAAAGhRy2E+bqZGbibIpZde+onaueqqq2LEiBExYMCAZGPUNm3axBFHHJFsjMraG/it/rHjHr2T2SBHjhkaf59wfzx862Mx+uaRsVGXsnh75rtx7Q9uaFRnt517xOHf6JfM9FhcuSxZ/tKmpDh+dcmRSbjxl3ufzW3lERMnPRKjTz145dNhbnm0URtfPmCn2KFP92jXoU0ccfzAuPu2J2Pr3l2j/8DtkzY22+Iz8asr74uzxg6JTmXtorCoMCZedZ9/agAAANaLgmwLXGuS61JuJkiXLl2i4EN7TnycysrKKC8vj4qKiigrK4s027/wsCbVX/71fk3uQ4cZVU2q/49nL2hyHwBouVrK93ZL6QcAsGG+t9fJTJB1qaqqKu6+++6YPXt2dO/ePQ4++GCDEgAAAKDJWlQI8txzz8WBBx4YG2+8cWy11VYxY8aMZHnMfffdF3379m3u7gEAAACt2HrZGHVt5QKP0aNHx7Rp0+Lee++Nl19+OcaMGZOUAwAAAORNCPLCCy/EKaec0qjs5JNPTsoBAAAA8mY5TNeuXWPq1Kmx5557NpQ98cQTSTmf3OTMbT4uAAAAaMkhSG4pTG4j1GHDhkXPnj2TPUFuuummuPbaa5u7awAAAEAr16KWwxx11FHJk2Fqa2vjwQcfTI533nlnEooAAAAA5M1MkJwBAwYkPwAAAAB5OxOkqKgohg8fHnV1dY3Ky8rKmq1PAAAAQH5oUSFIaWlpvPPOO7HffvvFokWLGsqz2Wyz9gsAAABo/VpUCFJcXBx33XVX7LjjjrH77rvH9OnTk/KCgoLm7hoAAADQyrWoECSnsLAwrrvuujjppJOSR+VOmTKlubsEAAAA5IEWtTHqh5e9jBw5MrbZZps49NBDY/ny5c3aLwAAAKD1a1EhyI033tjo90GDBsUDDzwQd9xxR7P1CQAAAMgPLSoE+eY3v7lKWZ8+fZIfAAAAgLzaEwQAAABgfRCCAAAAAKkgBAEAAABSQQgCAAAApIIQBAAAAEgFIQgAAACQCi3qEbkAq7N/4WFN+mCKu2/R5A+2btbsJtWfnLmtyX0AAACaxkwQAAAAIBWEIAAAAEAqCEEAAACAVLAnCNBqFRQUxBm/OTk223rTyGazccUx42Pef95e4/XtOpTGz246KXps1zV+9I1r4s1X34rLbj0lsplsFLcpinHn3JqUDfrunjH0hH3itf+bFWNP+t3q2+rYNi6d/JPouWP3GNF/dMx4cVZS/rtXxsX8OQuT85t/9pd45n/+vZ7uHgAA+LSEIECr1WvnnlFSWhKnDfxJ7LLfF+LrpxwUE067cY3XV6+ojfOO+XUcO/qQhrJRR4yP+rpMfP5LveLQ4wbGNWf9KR65+/l4+qFpccyowWtua3lNnDv4kjjhsmGNypdWLIsz9jlvHd0hAACwLlkOA7Ra82cvaDjvuFH7qHi38mOvz9RnomLh0kZluQAkp33HtjFj2rzkvGLBkqjPZP57W/NXfb+2HdvGlQ+eH6Mm/TA6bdzxU90PAACwfpkJArRaFfOrkqUsN7x0TTIj5Ed7jfnUbZR/pkOc++tjY5NuG8X5x/+myX0audeYqFq4JPYb9uUYdt5hMf6Hv21ymwAAwLphJgjQ6gz50aC44oHz4vBRh0b1ipo4doeRccHQK+LEK4/+1G3lZoacMWRcXPT938XwM7/6id87d1ydXACSM+W2qdGrT89P3R8AAGD9MRMEaHVuv/qu5Ge3g3aOjht3SMqWLF4aHTdaef5JFRYVJjNJcpuqLq1aHiuW13zi916d4pLiKCiIqK2piy98+XMx9/W3PlV/AACA9UsIArRaT9//79jvqIHJHhwlpcUx4fQ1b4r6vgt+d3xsvcPmsUWvTeKJf74YuwzoHZlsNglDrjv39uSagYP7xuCj94puPbskT5P58VETVtvW2LtGJZuzbtG7W9w9cXI8ce+zMfbu0bFi6Yqora6LK48dv87vGQAAWHsF2dyfQPNAZWVllJeXR0VFRZSVlTV3d4B1aP/Cw5pUv7j7Fk3uQ92s2U2qPzlzW5P7APmkpXxvt5R+AAAb5nvbniAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUsHTYYAW742f9W9aAwVN78M2F1c2vREAAKBZmQkCAAAApIIQBAAAAEgFIQgAAACQCvYEAVqFL2zWNc7ee0By3qVDh3j4P2/Etp0/G22KiyOTycbZ9/wj5lRUxpj9vhI7bLJJtC0pjuv/9VTcM+3VD+p/5b/Ur6xs2ELk3mOPjpuefT7+8Mxzq+/PXr3j8DMHR1FxYfzluvvj+Au/FQvmLUpeu+WKu+PZh17aQJ8MAADwSQlBgFbh3/PeiiNvvi05/9nB+8fkV1+P6//1dLy9ZEns1bNHHN9v1zhv8gNxyQNToi6TifYlJfHHo77dEIIk9W95r/5B+8fk116P65/4UP0vrayfM3iH7WNuZdUa+1JSWhzfPOWAOHfo1VFXW5+UHXHm4Dhr0OUb4JMAAADWluUwQKtSVFAQO3fbLJ6cNTsJMHJyoUddNtNwntOupCSmz1/4X+u3r66Og555KnZ77ZU48aF/Rseamji493Zxz7RX1tiHHb60TdQsr43z/zgizp30g9h4k7Jo16E0Lrv7rDj718dHx406rLf7BwAA1p6ZIECr0r/HlvHEzNmRfe/34sLCOGXP3WP0vfc3XHPl4INjz55bxuUPPbr6+rNW1s8FIH+eOD62/cPvo+6EE+K011+Po7bpFT9/4aXIlLZZYx827lIWXXt0jtMOvDh2Hvi5OOqcryfnVYuWxr7f6R/DRh0Svzz7lvVy/wAAwNozEwRoVQ7efru495WVS1xyLjpov7j52edj5uKKhrLT/35vHDDxd/H9/v2S/T1Wqf/eEplhjz8a21x4QRRMmBAl06cns0S6HnRgdL7h1x/bhyUVy+KFqa8lS2GenzIttty+WxKA5Dxyx1Ox9ee3XKf3DAAArBtCEKDVyIUUfTffLJkJknPyHl+K2RWVDft+5LQpKkqOK+rqYmlNTcOMkYb63TZLZoLkHPj1QyI7Y0bErbeuvKBr18huumkcOebHcWy/XePIvn1ix003WaUfrzz9RvTo3S057/WFLWP+nIVR0mblxLrP77FdzP3PO+vvQwAAANaa5TBAq7F7j+7JXh65YGOTjh3i1D13j2fmzI3+PbrHs3PmxRUPPxpXHfLV2Lhd22SZzC/+d+rH1t/xuGOj8NFHI/beO+LxxyNGj45sv34x6cCD491TTo0ObdrEi2+vGmjkZn1Mvfe5uPyesyObycQNP/1zXHX/qFixrCZqq2vjqlN+uwE/FQAA4JMqyGazH/5DaatVWVkZ5eXlUVFREWVlZc3dHWAd2uaSq5rWwEfXxLwn2RNk/Ljo9c7bkSkoiMJsNl7fZNMYevKIWFZa2rgPF7/YpC7ct/iGJtWHfNNSvrdbSj8AgA3zvW0mCJBauaAjF3jk9gbZYuHCmP2Zz8Qf+u+1SgACAADkByEIkGq5wONXX9m3ubsBAABsADZGBQAAAFJBCAIAAACkghAEAAAASAV7ggAtXrdH6ppUv6gm0+Q+1FdVNbkNAACgeZkJAgAAAKSCEAQAAABIBSEIAAAAkAr2BAFaha16dI4zTjkg6uuzsXxFTZx3yZ1xw7jh8e6ClXt1/OFPj8dTz70ZI7+/X2yz9SZRVFQYv7np0XjymRnJ6z17do7TRx4U9fWZWL68Js6/6G8x4pT9o/+XtokbJz0ad/ztmeS6kaceED16dE7OP7f9ZnHY4ddFVdWKVfrTrmPbuPT+c6Pnjt1jxB4/jhkvzoqB3+of3xzxtaheXhOXf++6eHf2gg36GQEAAB9PCAK0CjNnL4wfnHlzcj788D1iQP9tY8my6vjhqD82uu5PdzwZ896qiI4dS+PKC77VEILMmrUwTh05KTn/7lF7xoC9tovrf/NwPP/vWdGuXUlD/WuuvT85dunSKc45c9BqA5CcXNBx7iGXxAmXDUt+LyouiiEjB8VpA38SvXfbJo4cMySu+f7E9fRpAAAAa8NyGKBVyM3geF/btiVJKNKubUmMu+TwOPfMQdGpY9vktVwAklNbWx+ZbHbN9WcuiIULl67x/QYO2D6mPDJtja9n6jNRMf+DJ8Zsvm3XePOl2VFXWx8vPvZKbLXTlk24WwAAYH0QggCtxq4794jrxx0dfT+/ZcyZtzh+cOZNMeKcW+KJp9+I7x25Z6Nrj//ul+P2O59uVPbFXXrGxF9+L3bus2XMnbf4Y98rN1NkyqOvfuK+ddyoQyyrXNbwe2GR/14BAKClMUoHWo3cnh/HjbgxHvrfV+KQg/tE5XtLVR589JXYdutNGq47eL+doqS4MP7n4Zcb1X/6mRlxwkm/jSmPvBKDvrrzGt+nc+dOycyRRYvWPFPko5YsWhrty9o3mikCAAC0LEIQoFUoKS5qOF+6tDqqq+sayvrstEXMnrsoOe/7hS1j4J69Y9yv/tm4fknj+itW1K7xvQYO6J0EJZ/GnOlvRY/PbR7FJUWx4x694z//9+anqg8AAKx/NkYFWoVd+/aMw4f0S/b5WFyxLH55w0Mx/sojkzCjprY+Lr3m3uS6039wQPL0mKvGfjuqa+rirJ/+uWEpzHe+9aXIZLJRUbEsLrn87jjumIGxZ/9torCwMLpttnGMn7AyOPnygN5x3oV3/Nc+jb3rnOjVp2dssV23uPvXk+Mv4+6JKx88P2pW1MRlw69bz58IAADwaRVksx/aObAVq6ysjPLy8qioqIiysrLm7g6wDn35a5c1qX5RTdOXphQ/sPIRumtrcv2tTe4D5JOW8r3dUvoBAGyY723LYQAAAIBUEIIAAAAAqSAEAQAAAFJBCAIAAACkgqfDAC3elLvPau4uAAAAecBMEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAViiPPfLPf+VFcVLpWdetffq3J7z85c1uT2wAANizjBwBIBzNBAAAAgFQQggAAAACpIAQBAAAAUiHv9gRp16E0Lv/tSdFjm01i5OET4s3pb8fgI3aP/Q7pG9lsxC2/ejD+9dC0KCkpipNGD45uPT4by5ZUxwUjJq3S1ra7bB0nXT08splsLHp7cVx81LgoKCiIS/4xJnm9Tbs2UdKmOE764lnNcKcAwLpi/AAA6ZB3IUj1itr46cm/j+POOKihbNB3do+TDh0XbduWxNiJ30tCkEOO7B9PTJkWUx+ctsa25s9ZGKMOuiiql9fEMWMPjz2/sVtM+fPUOGOf85LX9z1yQGzWa9MNcl8AwPpj/AAA6ZB3y2Ey9ZmoWLS0Udm8mQuitLQ4+StP5eJlSdmue20XO+3SMy777XHx1cP6rbat3OyPXACSU1dbH/V1mUavf3lo/5hy29T1di8AwIZh/AAA6ZB3IcjqPPXoqzHxzpEx7k8nx99ueiwp69K1PF5+flacc9xv4itf6xOdNy1bY/0u3TvHLvt+Pqbe9XRDWbuObaNL98/GzJdnb5B7AAA2LOMHAMg/ebcc5qPadyiNgw/bLY756lXJPiCX/ObYeOax6bGkakU8O3V68pefl597Mzbv2Tnefq/OkB8Niv6Dd43H//5U3Hv9P+Oc358alx8zPurr6hva7X/IytcBgPxj/AAA+SnvZ4Jkstmoqa6L2pq6WLGiNtnINLe56UvPvhm9tu+WXLNV783i7TmLGurcfvVdyb4ff/35PXHOpBEx6cLbYs5r81azFObxDX4/AMD6Z/wAAPkpL2eCXPDLo6PX9pvFFj27xD23PRGP3v9CXH3z96OoqDD+fsvUyGazcesNU+L0sUNi+MgD4ulHX423Zn8Qgrxv4Lf6x4579I72ndrFkWOGxt8n3B8P3/pYshRmky07x5svWQoDAPnC+AEA8l9BNpcI5IHKysooLy+PfXufFsVFpWvVRv3LrzW5H5MztzW5DQDId+9/b1dUVERZWVmz98P4AQDSMX7I++UwAAAAADlCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpkHePyB17+83RsdPaZTsje+6xzvsDALR8xg8AkA5mggAAAACpIAQBAAAAUiFvQpCqqqrkuPdub8drr9Q2lM+bUxd9t53bUPbj0xfFtwe/G8O/PT9+M2FJozZezj4d/84+3vB7u45tY9zjP4s7K/8QPXfs3lD+9R8cFNdOvTh5bfdBX9wAdwcArI+xwz777JOcv/7a2o0dzh+1uNHYIcf4AQBarrzZE6Rdu3bJce8DShuV3/DLJdH3i20alV10xUaxbe+SRmVzZtVFdWSj8EO5UPXymjh38CVxwmXDGl07+KQD44Q+p0fb9qVx8X1jYupdT6+HOwIA1vfY4dZbb41evXqt9djh3XfqV2nX+AEAWq68mQlSXLxqnjN7Zl0UFER027QwNvrj0ths1OJoO602zjtzcRx35PyY9tIHf/W5YcKS6BHbNaqfqc9ExfzKVdqdO/2tKG3XJtp1aheVC1bOQAEAWt/YoXPnzqsdO2y2eVEULs9E5/FV0f6Zmrho+II4/jurjh2OPr7jKu0aPwBAy5U3M0FWJzc4OWF4+7hxyIL4bFU2Ni6K+EV9RMdti+OfY8tj9OjFcfMdXWJWbsATEW2j/Sdq98l/PBvXv3h1FBUVxuXfu2693wcAsOHGDsed1DF+eUVlbD5icWwyqz7GFUR8Nhvx7zb18d2zF8fNf/9g7NBt86JP3LbxAwA0v7yZCfJRM9+sS46f/5/qKKrMRkE2oqAuonM2onR6Xez6SHXyen19Nm4YvyS+d+IHf8kZ8qNBccUD5yXHj2rfqV187fj9Y/h2I+KYz42MY8YesQHvCgBY32OHzbsXR5vpddFmZn0UZCI610dy/MLM+ih+t361Y4cc4wcAaPnydibIKy/Vxuuv1sURD6yIaRExPSIejIjlEdGpMGLxa3VRU52NoqKCmDO7Pi4cUxEvxpOxLKri2qt+Ebdf3XO17WYy2ahZURO11bVRX1cfJaUlUVBQENlsdoPfIwCw7scOJ353Qbz+en2clP1g7FAWEe8URNSuaDx2qF6RjcVREHOzM+L2q+9KflbH+AEAWoa8C0GeeKwm5sxcHIcd2SF+/+fOyVresy+tijMiIred2ZCIWFgXsWJqdZx5xcZJnV9P+mxyPLFHn3gt/h3dCj4IQMbeNSp67dwztujdLe6eODnuv/GhmHL71Bj32NgoLCqMO8ffJwABgFZq6NChyfHi8yrjO8NWjh1yLvjaOzHmxbooyb43dkhmj0b89MC2jcYOuc1Rh+1V0mjskGP8AAAtU0E2T6YwVFZWRnl5eUx9oWt0zE31eE/h0kxs9Y35yRKYZPFPJqJ6m+J4447OkenQeDXQyJ57NLkfkzO3NbkNAMh3739vV1RURFlZWbP3w/gBANIxfsi7mSAflQs6coHHZ25cGiWz6qO2e1EsPLrDKgEIAIDxAwDkt7wPQXJygcf8kzs1dzcAgFbE+AEA8o/pEAAAAEAqCEEAAACAVBCCAAAAAKmQd3uC/Piwo6K4qHSt6haUzljn/QEAWj7jBwBIBzNBAAAAgFQQggAAAACpIAQBAAAAUiHv9gTZdofN4wejvhGZbDYWL1gSl55zW+y57w5x6LA9onpFXVzx49tj/tsVseXWXeKHP/1GFBYVxO9/8c94durrq7TVc4ct4oe/OCbq6+pj+ZLqGDvs2ui4UYc49Zrh0b6sXTz/8Esx6Wd/bZb7BADWHeMHAEiHgmw2m408UFlZGeXl5TF0wPlRszwb1StqY/iI/eP1aXNjyNF7xRlHXx/b7bR57Pf1vjHu/L/FT35+RFx/5T+SoOSiCUfHacMmRmZ6441Ri4qLkgAk56jRh8a8N96JfgftHBNH3RwL5i5abT/uXz5pg9wvAOTD93ZFRUWUlZU1ez+MHwAgHeOHvFsOs2h+VRKA5NTV1cfmPTrHm6+/k5y/9NzM2GrbTZPXPtO5U8yduSCWLa2OysXLomyj9qu09X4AklPavk3MenVebNqjc5x4yRFx2b2jYofdt92AdwYArC/GDwCQDnkXgryvS9fy6Lt7r3jx2Tdj2ZLqhvLCwpW3XFBQ0FC2bMmK6FTebrXt7LLPTjH+8Yuiz8AdYsG8RbH1Tt1j4qhb4uLh4+P7lx+1Ae4EANhQjB8AIL/l3Z4gOe07lMaZFw+Nq879SxJ6tO9Y2vBaJpN57/jBKqAOndpGVcXy1bb1zAMvxMn9x8Rhp30t9j9ir5j92lsxf87ChpkihUWFkalf2SYA0HoZPwBA/su7EKSwsCDOuuSwuHnCgzHnzQVRVFwYW269SRQXFyV7grzx6tvJdYsWVEW3LT+b7AnSqbx9siTmo0raFEdtTV1yvqxieRS3KYolFcuSTVEzdZkoKSkWgABAHjB+AIB0yLsQZOBBfWKHnbdM/ppzxIl7x11/+lfcMemxuPx3x0ZNdV1cPvr25Lrf/XxynH7hN1c+Hea6f662rV323SkO+9HXklkjFfOr4orjfxWvPTsjLvzLGVFcUhQ3XvDnDXx3AMD6YPwAAOmQd0+H2fdzZ0Rx0QfLXz6Njz4dZm14OgwAtL6nwxg/AEDL5+kwAAAAAGl/OgwAAADAhwlBAAAAgFQQggAAAACpIAQBAAAAUiHvHpH7l6nnNusu8wBA62P8AADpYCYIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUkEIAgAAAKSCEAQAAABIBSEIAAAAkApCEAAAACAVhCAAAABAKghBAAAAgFQQggAAAACpIAQBAAAAUqE48kQ2m02OlZWVzd0VAOC/eP/7+v3v7+Zi/AAA6Ro/5E0IUlVVlRy7d+/e3F0BAD7F93d5eXmzfV7GDwCQrvFDQba5/wSzjmQymZg7d2506tQpCgoKmrs7AMDHyA0/cgOYbt26RWFh863ONX4AgHSNH/ImBAEAAAD4ODZGBQAAAFJBCAIAAACkghAEAAAASAUhCAAAAJAKQhAAAAAgFYQgAAAAQCoIQQAAAIBIg/8HIgOArLjaq4MAAAAASUVORK5CYII=",
-                        "text/plain": [
-                            "<Figure size 1100x4240 with 16 Axes>"
-                        ]
-                    },
-                    "execution_count": 32,
+                    "cell_type": "markdown",
+                    "id": "md-cuda",
                     "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "# =====================================================================\n",
-                "# Masked mismatch view — cluster pixels only, both finders side by side\n",
-                "# ---------------------------------------------------------------------\n",
-                "# Non-cluster pixels white, red dot at each cluster centre. Frames chosen\n",
-                "# by RAW mismatch (tol=0) so shifted twins are kept; the cut is centred on\n",
-                "# the strongest mismatch pixel. Scan + plot live in helper.py; `show` is\n",
-                "# reused by the walk-through and shift-check cells below.\n",
-                "# =====================================================================\n",
-                "cf_cpu_m  = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                "                          capacity=capacity)\n",
-                "cf_cuda_m = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                "                              max_clusters_per_frame=1500, n_streams=N_STREAMS)\n",
-                "train_pedestal([cf_cpu_m, cf_cuda_m], f, n_frames_pd)\n",
-                "\n",
-                "show, totals = scan_mismatches(cf_cpu_m, cf_cuda_m, data, rx, ry,\n",
-                "                               scan_count=20000, n_show=8, tol=0)\n",
-                "print(f\"total CPU-only={totals['cpu_only']}, CUDA-only={totals['cu_only']}; \"\n",
-                "      f\"showing {len(show)} frames with the most mismatches\")\n",
-                "plot_masked_mismatch(show, data, rx, ry, rows, cols, zoom=30, show_vals=True)\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 33,
-            "id": "299667d5",
-            "metadata": {
-                "scrolled": true
-            },
-            "outputs": [
+                    "source": [
+                        "## 2 — CUDA, batched + multi-streamed\n",
+                        "\n",
+                        "`register_input_buffer` page-locks the input once so H2D runs at full DMA\n",
+                        "bandwidth instead of through the driver's staging buffer. It is paid once,\n",
+                        "outside the loop, and released when the dataset is done."
+                    ]
+                },
                 {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "frame 5905   centre (x=150, y=375)   CPU-only (CPU accepts, CUDA rejects)\n",
-                        "   ^ strongest >1px mismatch in this displayed frame\n",
-                        "raw cluster (ADU):\n",
-                        "[[5822 6545 6086]\n",
-                        " [5850 7601 6240]\n",
-                        " [5967 6413 6369]]\n",
+                    "cell_type": "code",
+                    "execution_count": 7,
+                    "id": "cuda",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "CUDA batched: 1.17s   8,574 FPS   17,463,350 clusters (1746.3/frame)\n",
+                                "  input pinned in 0.09s, once, outside the loop\n",
+                                "  vs CPU: 13.94x\n",
+                                "  peak clusters in one frame: 2,062 of CAP 3,000\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "t0 = time.perf_counter()\n",
+                        "cf_cuda.register_input_buffer(data)\n",
+                        "t_pin = time.perf_counter() - t0\n",
                         "\n",
-                        "--- CPU   (FP64 host pedestal) ---\n",
-                        "  pedestal-subtracted window:\n",
-                        "    [[  43.7  647.1  112.7]\n",
-                        "     [ -10.5 1595.2  191.5]\n",
-                        "     [  91.1  570.1  144.6]]\n",
-                        "  centre value   =  1595.25   (local max? True)\n",
-                        "  max value      =  1595.25\n",
-                        "  total     =  3385.52\n",
-                        "  rms(centre)    =   54.985\n",
-                        "  Test1: max   > 5*rms      =   274.93  ->  True\n",
-                        "  Test3: total > 3*5*rms  =   824.78  ->  True\n",
-                        "  ACCEPT = localmax and (Test1 or Test3) = True\n",
+                        "clusters_cuda = []\n",
+                        "t0 = time.perf_counter()\n",
+                        "for start in range(0, N, BATCH_SIZE):\n",
+                        "    stop = min(start + BATCH_SIZE, N)\n",
+                        "    clusters_cuda.extend(\n",
+                        "        cf_cuda.find_clusters_batched(data[start:stop], first_frame=start))\n",
+                        "t_cuda = time.perf_counter() - t0\n",
                         "\n",
-                        "--- CUDA  (FP64 host pedestal) ---\n",
-                        "  pedestal-subtracted window:\n",
-                        "    [[  43.7  647.1  112.7]\n",
-                        "     [ -10.5 1595.2  191.5]\n",
-                        "     [  91.1  570.1  144.6]]\n",
-                        "  centre value   =  1595.25   (local max? True)\n",
-                        "  max value      =  1595.25\n",
-                        "  total     =  3385.52\n",
-                        "  rms(centre)    =   54.985\n",
-                        "  Test1: max   > 5*rms      =   274.93  ->  True\n",
-                        "  Test3: total > 3*5*rms  =   824.78  ->  True\n",
-                        "  ACCEPT = localmax and (Test1 or Test3) = True\n",
+                        "cf_cuda.unregister_input_buffer()\n",
                         "\n",
-                        "RESULT:  CPU = ACCEPT ,  CUDA = ACCEPT\n",
-                        "pedestal mean gap @centre = 0.00 ADU;   rms gap = 0.000\n",
-                        "NOTE: recompute did not reproduce the scan's split for this exact pixel. Residual causes are the CPU's per-pixel in-frame pedestal update (affects window neighbours) or FP rounding right at threshold. The mismatch is real; try another PICK.\n"
+                        "hist_cuda = bh.Histogram(bh.axis.Regular(N_BINS, E_MIN, E_MAX))\n",
+                        "energies = [np.asarray(cv.sum()).ravel() for cv in clusters_cuda if cv.size > 0]\n",
+                        "if energies:\n",
+                        "    hist_cuda.fill(np.concatenate(energies))\n",
+                        "n_clusters_cuda = sum(cv.size for cv in clusters_cuda)\n",
+                        "\n",
+                        "print(f'CUDA batched: {t_cuda:.2f}s   {N / t_cuda:,.0f} FPS   '\n",
+                        "      f'{n_clusters_cuda:,} clusters ({n_clusters_cuda / N:.1f}/frame)')\n",
+                        "print(f'  input pinned in {t_pin:.2f}s, once, outside the loop')\n",
+                        "print(f'  vs CPU: {t_cpu / t_cuda:.2f}x')\n",
+                        "\n",
+                        "# One ClusterVector per frame, so this IS the per-frame maximum.\n",
+                        "peak = max((cv.size for cv in clusters_cuda), default=0)\n",
+                        "print(f'  peak clusters in one frame: {peak:,} of CAP {CAP:,}')\n",
+                        "if peak >= CAP:\n",
+                        "    print('  !! CAP REACHED -- clusters were dropped; raise CAP and re-run.')"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-summary",
+                    "metadata": {},
+                    "source": [
+                        "## Summary"
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 8,
+                    "id": "summary",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "                             s        FPS   us/frame      clusters\n",
+                                "CPU MT (4 thr)           16.26        615     1626.1    17,463,321\n",
+                                "CUDA batched              1.17      8,574      116.6    17,463,350\n",
+                                "\n",
+                                "speedup: 13.94x\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "print(f'{\"\":<22} {\"s\":>7} {\"FPS\":>10} {\"us/frame\":>10} {\"clusters\":>13}')\n",
+                        "for name, t, n in (('CPU MT (%d thr)' % N_THREADS, t_cpu, n_clusters_cpu),\n",
+                        "                   ('CUDA batched', t_cuda, n_clusters_cuda)):\n",
+                        "    print(f'{name:<22} {t:7.2f} {N / t:10,.0f} {t * 1e6 / N:10.1f} {n:>13,}')\n",
+                        "print(f'\\nspeedup: {t_cpu / t_cuda:.2f}x')"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-part2",
+                    "metadata": {},
+                    "source": [
+                        "# Part 2 — Where the two disagree\n",
+                        "\n",
+                        "The two implementations are not bit-identical by construction: the CUDA finder\n",
+                        "updates its pedestal once per frame, the CPU finder per pixel, so once the\n",
+                        "pedestals drift apart a few pixels land on opposite sides of the threshold.\n",
+                        "\n",
+                        "Three views, cheapest first: the **spectra**, the **cluster sets**, and **where\n",
+                        "in the run** the difference accumulates."
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-spec",
+                    "metadata": {},
+                    "source": [
+                        "## Spectra\n",
+                        "\n",
+                        "Both curves should lie on top of each other; the ratio panel is the sensitive\n",
+                        "view."
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 9,
+                    "id": "spectra",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "data": {
+                                "image/png":
+                                    "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",
+                                "text/plain": [
+                                    "<Figure size 900x650 with 2 Axes>"
+                                ]
+                            },
+                            "metadata": {},
+                            "output_type": "display_data"
+                        }
+                    ],
+                    "source": [
+                        "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
+                        "    2, 1, figsize=(9, 6.5), sharex=True, gridspec_kw={'height_ratios': [3, 1]})\n",
+                        "\n",
+                        "edges = hist_cpu.axes[0].edges\n",
+                        "cpu_vals, cuda_vals = hist_cpu.values(), hist_cuda.values()\n",
+                        "\n",
+                        "ax_spec.stairs(cpu_vals, edges, label=f'CPU MT  ({n_clusters_cpu:,})',\n",
+                        "               color='C0', linewidth=1.4)\n",
+                        "ax_spec.stairs(cuda_vals, edges, label=f'CUDA  ({n_clusters_cuda:,})',\n",
+                        "               color='C1', linestyle='--', linewidth=1.4)\n",
+                        "ax_spec.set_ylabel('Counts')\n",
+                        "ax_spec.set_title(f'Cluster energy spectrum — {N:,} frames')\n",
+                        "ax_spec.legend()\n",
+                        "ax_spec.grid(alpha=0.2)\n",
+                        "\n",
+                        "with np.errstate(divide='ignore', invalid='ignore'):\n",
+                        "    ratio = np.where(cpu_vals > 0, cuda_vals / cpu_vals, np.nan)\n",
+                        "ax_ratio.stairs(ratio, edges, color='C1', linewidth=1.2)\n",
+                        "ax_ratio.axhline(1.0, color='gray', linewidth=0.5)\n",
+                        "ax_ratio.set_ylabel('CUDA / CPU')\n",
+                        "ax_ratio.set_xlabel('Energy [ADU]')\n",
+                        "ax_ratio.set_ylim(0.9, 1.1)\n",
+                        "ax_ratio.grid(alpha=0.3)\n",
+                        "\n",
+                        "plt.tight_layout()\n",
+                        "plt.show()"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-sets",
+                    "metadata": {},
+                    "source": [
+                        "## Cluster sets\n",
+                        "\n",
+                        "Every cluster is keyed by `(frame, x, y)`, so the two results can be differenced\n",
+                        "directly — no per-frame Python loop.\n",
+                        "\n",
+                        "A cluster whose centre moved by one pixel was *relabelled*, not gained or lost,\n",
+                        "so those are counted separately from genuine adds and drops."
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 10,
+                    "id": "sets",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "CPU    17,463,321 clusters\n",
+                                "CUDA   17,463,350 clusters      net +29  (0.0002%)\n",
+                                "\n",
+                                "exact-position mismatches   CPU-only       25   CUDA-only       54\n",
+                                "  of which shifted by 1 px                  1                   4\n",
+                                "  genuine add / drop                       24                  50\n",
+                                "\n",
+                                "frames touched by a genuine difference: 72 of 10,000\n",
+                                "[2.9s]\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "def cluster_keys(vectors):\n",
+                        "    \"\"\"One int64 key per cluster: frame * rows*cols + y * cols + x.\n",
+                        "\n",
+                        "    Centres are unique within a frame, so keys are globally unique and the sets\n",
+                        "    below need only a sort, never a np.unique.\n",
+                        "    \"\"\"\n",
+                        "    n = len(vectors)\n",
+                        "    sizes = np.fromiter((cv.size for cv in vectors), np.int64, n)\n",
+                        "    frames = np.repeat(\n",
+                        "        np.fromiter((cv.frame_number for cv in vectors), np.int64, n), sizes)\n",
+                        "    xy = [np.asarray(cv) for cv in vectors if cv.size]\n",
+                        "    if not xy:\n",
+                        "        return np.empty(0, np.int64), frames\n",
+                        "    x = np.concatenate([v['x'] for v in xy]).astype(np.int64)\n",
+                        "    y = np.concatenate([v['y'] for v in xy]).astype(np.int64)\n",
+                        "    return frames * (rows * cols) + y * cols + x, frames\n",
+                        "\n",
+                        "\n",
+                        "t0 = time.perf_counter()\n",
+                        "k_cpu, fr_cpu = cluster_keys(clusters_cpu)\n",
+                        "k_cuda, fr_cuda = cluster_keys(clusters_cuda)\n",
+                        "\n",
+                        "# Sort ONCE. np.setdiff1d and np.isin each re-sort their argument on every call,\n",
+                        "# and the shift check below calls one eight times per direction -- about twenty\n",
+                        "# sorts of a 27-million-element array. Two sorts plus binary search instead.\n",
+                        "s_cpu = np.sort(k_cpu)\n",
+                        "s_cuda = np.sort(k_cuda)\n",
+                        "\n",
+                        "\n",
+                        "def present_in(vals, sorted_keys):\n",
+                        "    \"\"\"Which of `vals` appear in an already-sorted key array.\"\"\"\n",
+                        "    if sorted_keys.size == 0:\n",
+                        "        return np.zeros(vals.size, dtype=bool)\n",
+                        "    i = np.searchsorted(sorted_keys, vals)\n",
+                        "    np.clip(i, 0, sorted_keys.size - 1, out=i)\n",
+                        "    return sorted_keys[i] == vals\n",
+                        "\n",
+                        "\n",
+                        "cpu_only = s_cpu[~present_in(s_cpu, s_cuda)]\n",
+                        "cuda_only = s_cuda[~present_in(s_cuda, s_cpu)]\n",
+                        "\n",
+                        "\n",
+                        "def drop_shifted(only, sorted_other):\n",
+                        "    \"\"\"Drop mismatches that have a counterpart within 1 px in the other set.\"\"\"\n",
+                        "    keep = np.ones(only.size, dtype=bool)\n",
+                        "    for dy in (-1, 0, 1):\n",
+                        "        for dx in (-1, 0, 1):\n",
+                        "            if dx or dy:\n",
+                        "                keep &= ~present_in(only + dy * cols + dx, sorted_other)\n",
+                        "    return only[keep]\n",
+                        "\n",
+                        "\n",
+                        "cpu_real = drop_shifted(cpu_only, s_cuda)\n",
+                        "cuda_real = drop_shifted(cuda_only, s_cpu)\n",
+                        "touched = np.unique(np.concatenate([cpu_real, cuda_real]) // (rows * cols)).size\n",
+                        "\n",
+                        "print(f'CPU  {k_cpu.size:>12,} clusters')\n",
+                        "print(f'CUDA {k_cuda.size:>12,} clusters      net {k_cuda.size - k_cpu.size:+,}'\n",
+                        "      f'  ({abs(k_cuda.size - k_cpu.size) / k_cpu.size:.4%})')\n",
+                        "print()\n",
+                        "print(f'exact-position mismatches   CPU-only {cpu_only.size:>8,}   '\n",
+                        "      f'CUDA-only {cuda_only.size:>8,}')\n",
+                        "print(f'  of which shifted by 1 px  {cpu_only.size - cpu_real.size:>17,}   '\n",
+                        "      f'{cuda_only.size - cuda_real.size:>17,}')\n",
+                        "print(f'  genuine add / drop        {cpu_real.size:>17,}   {cuda_real.size:>17,}')\n",
+                        "print(f'\\nframes touched by a genuine difference: {touched:,} of {N:,}')\n",
+                        "print(f'[{time.perf_counter() - t0:.1f}s]')"
+                    ]
+                },
+                {
+                    "cell_type": "markdown",
+                    "id": "md-drift",
+                    "metadata": {},
+                    "source": [
+                        "## Where in the run it accumulates\n",
+                        "\n",
+                        "Cumulative `CUDA − CPU` against frame index. A curve that rises and then flattens\n",
+                        "means the two pedestals settled into agreement and the difference is a start-up\n",
+                        "transient; a steadily sloping line would mean a persistent per-frame bias."
+                    ]
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": 11,
+                    "id": "drift",
+                    "metadata": {},
+                    "outputs": [
+                        {
+                            "data": {
+                                "image/png":
+                                    "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",
+                                "text/plain": [
+                                    "<Figure size 900x360 with 1 Axes>"
+                                ]
+                            },
+                            "metadata": {},
+                            "output_type": "display_data"
+                        },
+                        {
+                            "name": "stdout",
+                            "output_type": "stream",
+                            "text": [
+                                "first half: +16      second half: +13\n"
+                            ]
+                        }
+                    ],
+                    "source": [
+                        "cnt_cpu = np.bincount(fr_cpu, minlength=N)\n",
+                        "cnt_cuda = np.bincount(fr_cuda, minlength=N)\n",
+                        "cum = np.cumsum(cnt_cuda.astype(np.int64) - cnt_cpu.astype(np.int64))\n",
+                        "\n",
+                        "fig, ax = plt.subplots(figsize=(9, 3.6))\n",
+                        "ax.plot(cum, color='C1', linewidth=1.2)\n",
+                        "ax.axhline(0, color='gray', linewidth=0.5)\n",
+                        "ax.set_xlabel('Frame')\n",
+                        "ax.set_ylabel('cumulative CUDA - CPU')\n",
+                        "ax.set_title(f'Cluster-count difference accumulating over {N:,} frames '\n",
+                        "             f'(final {cum[-1]:+,})')\n",
+                        "ax.grid(alpha=0.25)\n",
+                        "plt.tight_layout()\n",
+                        "plt.show()\n",
+                        "\n",
+                        "half = N // 2\n",
+                        "print(f'first half: {cum[half - 1]:+,}      second half: {cum[-1] - cum[half - 1]:+,}')"
                     ]
                 }
             ],
-            "source": [
-                "# =====================================================================\n",
-                "# Manual walk-through: Test 1 & Test 3 on a DISPLAYED mismatch cluster\n",
-                "# ---------------------------------------------------------------------\n",
-                "# Analyses one mismatch cluster from a frame in `show` (masked view above).\n",
-                "# It picks the strongest >1px mismatch (only_sets, tol=1) so the recompute\n",
-                "# lands on a genuine add/drop rather than a 1px relabel. Each finder uses\n",
-                "# its DECISION pedestal captured before the frame: CPU = host (FP64),\n",
-                "# CUDA = device stream 0. With the double build both should now agree.\n",
-                "#\n",
-                "#   value  = centre pixel, pedestal-subtracted\n",
-                "#   max    = brightest of the window      total = sum of the window\n",
-                "#   rms    = pedestal std at the centre\n",
-                "#   Test 1 : max   > nSigma * rms                 (single-pixel)\n",
-                "#   Test 3 : total > sqrt(sx*sy)*nSigma*rms       (total)\n",
-                "#   ACCEPT = (centre is the local max) AND (Test1 OR Test3)\n",
-                "# =====================================================================\n",
-                "PICK = 0                       # which displayed frame (index into `show`)\n",
-                "nsig = N_SIGMA_VIS\n",
-                "c3   = np.sqrt(sx * sy)        # sqrt(sx*sy) for the total test\n",
-                "\n",
-                "def evaluate(frame_img, X0, Y0, mean, rms_img, f32):\n",
-                "    cast = np.float32 if f32 else np.float64\n",
-                "    sig   = (frame_img[Y0-ry:Y0+ry+1, X0-rx:X0+rx+1]\n",
-                "             - mean[Y0-ry:Y0+ry+1, X0-rx:X0+rx+1]).astype(cast)\n",
-                "    value = cast(frame_img[Y0, X0] - mean[Y0, X0])\n",
-                "    rms   = cast(rms_img[Y0, X0])\n",
-                "    thr1  = cast(nsig) * rms\n",
-                "    thr3  = cast(c3) * cast(nsig) * rms\n",
-                "    mx, total = sig.max(), sig.sum()\n",
-                "    localmax  = bool(value >= mx)\n",
-                "    t1, t3    = bool(mx > thr1), bool(total > thr3)\n",
-                "    accept    = bool(value >= -thr1) and localmax and (t1 or t3)\n",
-                "    return dict(sig=sig, value=value, rms=rms, thr1=thr1, thr3=thr3,\n",
-                "                mx=mx, total=total, localmax=localmax, t1=t1, t3=t3, accept=accept)\n",
-                "\n",
-                "# --- pick the strongest >1px mismatch in the chosen frame ---\n",
-                "e = show[PICK]\n",
-                "frame_img = data[e['fid']].astype(np.float64)\n",
-                "cpu_only, cu_only = only_sets(e['cpu_c'], e['cu_c'])\n",
-                "sub_cpu = frame_img - e['ped_cpu']\n",
-                "sub_cu  = frame_img - e['ped_cu']\n",
-                "cand = list(cpu_only | cu_only)\n",
-                "if not cand:\n",
-                "    raise RuntimeError(f\"frame {e['fid']} (PICK={PICK}) has only shifted-twin \"\n",
-                "                       \"mismatches (no >1px difference) — choose another PICK.\")\n",
-                "X0, Y0 = max(cand, key=lambda p: max(sub_cpu[p[1], p[0]], sub_cu[p[1], p[0]]))\n",
-                "is_cpu_only = (X0, Y0) in cpu_only\n",
-                "if not (rx <= X0 < cols - rx and ry <= Y0 < rows - ry):\n",
-                "    raise RuntimeError(f'centre ({X0},{Y0}) is on the frame border; '\n",
-                "                       'the window would clip — pick another PICK/frame.')\n",
-                "\n",
-                "rc = evaluate(frame_img, X0, Y0, e['ped_cpu'], e['noise_cpu'], f32=False)\n",
-                "rg = evaluate(frame_img, X0, Y0, e['ped_cu'],  e['noise_cu'],  f32=False)\n",
-                "\n",
-                "print(f\"frame {e['fid']}   centre (x={X0}, y={Y0})   \"\n",
-                "      f\"{'CPU-only (CPU accepts, CUDA rejects)' if is_cpu_only else 'CUDA-only (CUDA accepts, CPU rejects)'}\")\n",
-                "print('   ^ strongest >1px mismatch in this displayed frame')\n",
-                "print('raw cluster (ADU):')\n",
-                "print(np.array2string(frame_img[Y0-ry:Y0+ry+1, X0-rx:X0+rx+1].astype(int)))\n",
-                "print()\n",
-                "\n",
-                "def show_detail(tag, r, f32):\n",
-                "    print(f'--- {tag}  ({\"FP32 device\" if f32 else \"FP64 host\"} pedestal) ---')\n",
-                "    print('  pedestal-subtracted window:')\n",
-                "    print('   ', np.array2string(r['sig'].astype(float), precision=1,\n",
-                "                                 prefix='    '))\n",
-                "    print(f\"  centre value   = {float(r['value']):8.2f}   (local max? {r['localmax']})\")\n",
-                "    print(f\"  max value      = {float(r['mx']):8.2f}\")\n",
-                "    print(f\"  total     = {float(r['total']):8.2f}\")\n",
-                "    print(f\"  rms(centre)    = {float(r['rms']):8.3f}\")\n",
-                "    print(f\"  Test1: max   > {nsig}*rms      = {float(r['thr1']):8.2f}  ->  {r['t1']}\")\n",
-                "    print(f\"  Test3: total > {c3:.0f}*{nsig}*rms  = {float(r['thr3']):8.2f}  ->  {r['t3']}\")\n",
-                "    print(f\"  ACCEPT = localmax and (Test1 or Test3) = {r['accept']}\")\n",
-                "    print()\n",
-                "\n",
-                "show_detail('CPU ', rc, False)\n",
-                "show_detail('CUDA', rg, False)\n",
-                "\n",
-                "print(f\"RESULT:  CPU = {'ACCEPT' if rc['accept'] else 'reject'} ,  \"\n",
-                "      f\"CUDA = {'ACCEPT' if rg['accept'] else 'reject'}\")\n",
-                "print(f\"pedestal mean gap @centre = \"\n",
-                "      f\"{abs(float(e['ped_cpu'][Y0,X0]-e['ped_cu'][Y0,X0])):.2f} ADU;   \"\n",
-                "      f\"rms gap = {abs(float(e['noise_cpu'][Y0,X0]-e['noise_cu'][Y0,X0])):.3f}\")\n",
-                "if rc['accept'] == rg['accept']:\n",
-                "    print(\"NOTE: recompute did not reproduce the scan's split for this exact \"\n",
-                "          \"pixel. Residual causes are the CPU's per-pixel in-frame pedestal \"\n",
-                "          \"update (affects window neighbours) or FP rounding right at \"\n",
-                "          \"threshold. The mismatch is real; try another PICK.\")\n",
-                "else:\n",
-                "    print(\"-> the test that flips (Test1/Test3) and the mean/rms gap above \"\n",
-                "          \"show whether the pedestal (host vs device) or FP rounding caused \"\n",
-                "          \"it. This is the pedestal each finder actually decided with.\")\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "9eb0f052-7ae8-425f-8ff6-02cb658fd545",
-            "metadata": {},
-            "outputs": [],
-            "source": []
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "Python 3 (ipykernel)",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
+        "metadata": {
+            "kernelspec": {
+                "display_name": "Python 3 (ipykernel)",
+                "language": "python",
+                "name": "python3"
             },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.11.15"
-        }
-    },
-    "nbformat": 4,
-    "nbformat_minor": 5
-}
+            "language_info": {
+                "codemirror_mode": {
+                    "name": "ipython",
+                    "version": 3
+                },
+                "file_extension": ".py",
+                "mimetype": "text/x-python",
+                "name": "python",
+                "nbconvert_exporter": "python",
+                "pygments_lexer": "ipython3",
+                "version": "3.11.15"
+            }
+        },
+        "nbformat": 4,
+        "nbformat_minor": 5
+    }
diff --git a/python/tests/ClusterFinderCUDA_perf.ipynb b/python/tests/ClusterFinderCUDA_perf.ipynb
deleted file mode 100644
index 84fe1160..00000000
--- a/python/tests/ClusterFinderCUDA_perf.ipynb
+++ /dev/null
@@ -1,617 +0,0 @@
-    {
-        "cells":
-            [
-                {
-                    "cell_type": "markdown",
-                    "id": "md-title",
-                    "metadata": {},
-                    "source": [
-                        "# ClusterFinder — CPU vs CUDA performance\n",
-                        "\n",
-                        "Throughput comparison of the serial CPU finder against the CUDA variants:\n",
-                        "per-frame, batched+pinned, CUDA-Graph, and the async double-buffered pipeline.\n",
-                        "\n",
-                        "CPU↔CUDA **correctness** (why the cluster counts differ) is analysed\n",
-                        "separately in `ClusterFinderFrozen_vs_CUDA.ipynb`; here we only sanity-check that\n",
-                        "the counts and spectra agree, and focus on timing."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 1,
-                    "id": "imports",
-                    "metadata": {},
-                    "outputs": [],
-                    "source": [
-                        "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
-                        "\n",
-                        "from pathlib import Path\n",
-                        "import matplotlib.pyplot as plt\n",
-                        "import numpy as np\n",
-                        "import boost_histogram as bh\n",
-                        "import time\n",
-                        "from tqdm import tqdm\n",
-                        "\n",
-                        "from aare import (File, ClusterFinder, ClusterFinderFrozen, ClusterFinderMT, ClusterCollector,\n",
-                        "                  ClusterFinderCUDA, ClusterFinderCUDAGraph)\n",
-                        "from helper import print_pinning_budget"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 2,
-                    "id": "hist-helpers",
-                    "metadata": {},
-                    "outputs": [],
-                    "source": [
-                        "N_BINS = 200\n",
-                        "\n",
-                        "def make_hist(clusters):\n",
-                        "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                        "    h.fill(clusters.sum())\n",
-                        "    return h\n",
-                        "\n",
-                        "def make_hist_from_batch(result_list):\n",
-                        "    h = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                        "    energies = [np.asarray(cv.sum()).ravel() for cv in result_list if cv.size > 0]\n",
-                        "    if energies:\n",
-                        "        h.fill(np.concatenate(energies))\n",
-                        "    return h"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 3,
-                    "id": "config",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "Image size:      (400, 400)\n",
-                                "Pedestal frames: 1000\n",
-                                "Data frames:     20000\n",
-                                "Total in file:   100000\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "base = Path('/mnt/sls_det_storage/moench_data/2603_MaxIVBeamtime/2026032408/process/xrf/')\n",
-                        "f = File(base / 'Cu_factor_10_data_master_0.json')\n",
-                        "pd = File(base / 'Cu_factor_10_pedestal_master_0.json')\n",
-                        "\n",
-                        "n_frames_pd  = 1000\n",
-                        "N            = 20000\n",
-                        "cluster_size = (9, 9)\n",
-                        "rows, cols   = f.rows, f.cols\n",
-                        "image_size   = (rows, cols)\n",
-                        "capacity     = 1000\n",
-                        "BATCH_SIZE   = 2000\n",
-                        "\n",
-                        "N_STREAMS = 4\n",
-                        "N_SIGMA   = 5\n",
-                        "\n",
-                        "print(f'Image size:      {image_size}')\n",
-                        "print(f'Pedestal frames: {n_frames_pd}')\n",
-                        "print(f'Data frames:     {N}')\n",
-                        "print(f'Total in file:   {f.total_frames}')"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 4,
-                    "id": "pinning",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "── System RAM ──────────────────────────────────────────\n",
-                                "  Total RAM           : 125.1 GiB\n",
-                                "  Currently available : 112.7 GiB  (free + reclaimable cache)\n",
-                                "  Reserved headroom   : 4.0 GiB  (OS + CUDA context)\n",
-                                "  Safe pinning budget : 108.7 GiB\n",
-                                "\n",
-                                "── Frame layout ────────────────────────────────────────\n",
-                                "  Frame size          : 400 × 400 × 2 B = 312.5 kB\n",
-                                "\n",
-                                "── Pinning estimate ────────────────────────────────────\n",
-                                "  Max frames pinnable : 364,859  (108.7 GiB)\n",
-                                "\n",
-                                "  Note: no swap on this machine — exceeding available RAM\n",
-                                "  will trigger the OOM killer. Stay within the budget.\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "print_pinning_budget(rows, cols)"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-build",
-                    "metadata": {},
-                    "source": [
-                        "## Build finders\n",
-                        "\n",
-                        "`SERIAL` picks the CPU baseline: the sequential `ClusterFinder` or the\n",
-                        "multi-threaded `ClusterFinderMT`. All finders are trained on the same pedestal\n",
-                        "frames below."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 5,
-                    "id": "build",
-                    "metadata": {},
-                    "outputs": [],
-                    "source": [
-                        "SERIAL = False\n",
-                        "\n",
-                        "if SERIAL:\n",
-                        "    # cf_cpu = ClusterFinder(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                        "    cf_cpu = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                        "else:\n",
-                        "    cf_cpu = ClusterFinderMT(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                        "                             capacity=capacity, n_threads=48)\n",
-                        "    sink = ClusterCollector(cf_cpu)\n",
-                        "\n",
-                        "cf_cuda_v1 = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                        "                               max_clusters_per_frame=1500, n_streams=N_STREAMS)\n",
-                        "cf_cuda    = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                        "                               max_clusters_per_frame=1500, n_streams=N_STREAMS)\n",
-                        "# cf_async   = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                        "#                                max_clusters_per_frame=2000, n_streams=N_STREAMS)\n",
-                        "cf_graph   = ClusterFinderCUDAGraph(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                        "                                    max_clusters_per_frame=1500, n_streams=N_STREAMS)"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-ped",
-                    "metadata": {},
-                    "source": [
-                        "## Pedestal (all finders trained on identical frames)"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 6,
-                    "id": "train",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "Pedestal (1000 frames): 10.831s\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "t0 = time.perf_counter()\n",
-                        "for _ in range(n_frames_pd):\n",
-                        "    img = pd.read_frame()\n",
-                        "    cf_cpu.push_pedestal_frame(img.copy())\n",
-                        "    cf_cuda_v1.push_pedestal_frame(img.copy())\n",
-                        "    cf_cuda.push_pedestal_frame(img.copy())\n",
-                        "    # cf_async.push_pedestal_frame(img.copy())\n",
-                        "    cf_graph.push_pedestal_frame(img.copy())\n",
-                        "print(f'Pedestal ({n_frames_pd} frames): {time.perf_counter() - t0:.3f}s')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-io",
-                    "metadata": {},
-                    "source": [
-                        "## Read all data frames into memory (I/O out of the timing loop)"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 7,
-                    "id": "io",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "Reading 20000 frames: 1.074s  (18614 FPS, 5680.686 GB/s)\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "f.seek(0)\n",
-                        "t0 = time.perf_counter()\n",
-                        "data = f.read_n(N)\n",
-                        "t_io = time.perf_counter() - t0\n",
-                        "print(f'Reading {N} frames: {t_io:.3f}s  ({N/t_io:.0f} FPS, '\n",
-                        "      f'{f.bytes_per_frame * N / 1024**2 / t_io:.3f} GB/s)')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-cpu",
-                    "metadata": {},
-                    "source": [
-                        "## CPU clustering (baseline)"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 8,
-                    "id": "cpu",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stderr",
-                            "output_type": "stream",
-                            "text": [
-                                "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████| 20000/20000 [00:09<00:00, 2184.48it/s]\n"
-                            ]
-                        },
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "CPU clustering:       9.158s (2184 FPS, 28438072 clusters, 1421.90/frame)\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "t0 = time.perf_counter()\n",
-                        "for frame in tqdm(data):\n",
-                        "    cf_cpu.find_clusters(frame)\n",
-                        "t_cpu = time.perf_counter() - t0\n",
-                        "\n",
-                        "if SERIAL:\n",
-                        "    clusters_cpu = cf_cpu.steal_clusters(realloc_same_capacity=False)\n",
-                        "    n_clusters_cpu = clusters_cpu.size\n",
-                        "    hist_cpu = make_hist(clusters_cpu)\n",
-                        "else:\n",
-                        "    cf_cpu.stop(); sink.stop()\n",
-                        "    clusters_cpu = sink.steal_clusters()\n",
-                        "    hist_cpu = bh.Histogram(bh.axis.Regular(N_BINS, -2, 4000))\n",
-                        "    n_clusters_cpu = 0\n",
-                        "    for cv in clusters_cpu:\n",
-                        "        hist_cpu.fill(cv.sum())\n",
-                        "        n_clusters_cpu += cv.size\n",
-                        "\n",
-                        "print(f'CPU clustering:       {t_cpu:.3f}s ({N/t_cpu:.0f} FPS, '\n",
-                        "      f'{n_clusters_cpu} clusters, {n_clusters_cpu/N:.2f}/frame)')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-v1",
-                    "metadata": {},
-                    "source": [
-                        "## CUDA — per-frame (1 launch/frame, pageable memory)\n",
-                        "Simplest path: no batching, no pinning. Isolates per-frame launch + PCIe overhead."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 9,
-                    "id": "v1",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "CUDA per-frame:       3.659s  (5467 FPS, 28445699 clusters, 1422.28/frame)\n",
-                                "  Kernel only:        0.034 ms/frame\n",
-                                "  PCIe + overhead:    0.149 ms/frame\n",
-                                "Speedup (CPU/CUDA):   2.50x\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "cf_cuda_v1.reset_timers()\n",
-                        "t0 = time.perf_counter()\n",
-                        "\n",
-                        "n_clusters_cuda_v1 = 0\n",
-                        "hist_cuda_v1 = None\n",
-                        "for frame in data:\n",
-                        "    cf_cuda_v1.find_clusters(frame)\n",
-                        "    clusters_frame = cf_cuda_v1.steal_clusters(realloc_same_capacity=True)\n",
-                        "    n_clusters_cuda_v1 += clusters_frame.size\n",
-                        "    h = make_hist(clusters_frame)\n",
-                        "    hist_cuda_v1 = h if hist_cuda_v1 is None else hist_cuda_v1 + h\n",
-                        "\n",
-                        "t_cuda_v1 = time.perf_counter() - t0\n",
-                        "kernel_ms = cf_cuda_v1.avg_kernel_time_ms()\n",
-                        "print(f'CUDA per-frame:       {t_cuda_v1:.3f}s  ({N/t_cuda_v1:.0f} FPS, '\n",
-                        "      f'{n_clusters_cuda_v1} clusters, {n_clusters_cuda_v1/N:.2f}/frame)')\n",
-                        "print(f'  Kernel only:        {kernel_ms:.3f} ms/frame')\n",
-                        "print(f'  PCIe + overhead:    {t_cuda_v1*1000/N - kernel_ms:.3f} ms/frame')\n",
-                        "print(f'Speedup (CPU/CUDA):   {t_cpu / t_cuda_v1:.2f}x')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-batched",
-                    "metadata": {},
-                    "source": [
-                        "## CUDA — batched + multi-streamed + pinned dataset\n",
-                        "Pins the whole input once, then submits `BATCH_SIZE`-frame chunks across `N_STREAMS` streams so H2D / kernel / D2H overlap."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 10,
-                    "id": "batched",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "CUDA batched:         3.088s  (6477 FPS, 28439289 clusters, 1421.96/frame)\n",
-                                "  Kernel only:        0.031 ms/frame\n",
-                                "  PCIe + overhead:    0.123 ms/frame\n",
-                                "Speedup (CPU/CUDA):   2.97x\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "cf_cuda.register_input_buffer(data)   # pin the whole dataset once\n",
-                        "clusters_cuda_per_frame = []\n",
-                        "\n",
-                        "cf_cuda.reset_timers()\n",
-                        "t0 = time.perf_counter()\n",
-                        "for start in range(0, N, BATCH_SIZE):\n",
-                        "    stop = min(start + BATCH_SIZE, N)\n",
-                        "    clusters_cuda_per_frame.extend(\n",
-                        "        cf_cuda.find_clusters_batched(data[start:stop], first_frame=start))\n",
-                        "t_cuda = time.perf_counter() - t0\n",
-                        "\n",
-                        "cf_cuda.unregister_input_buffer()\n",
-                        "kernel_ms = cf_cuda.avg_kernel_time_ms()\n",
-                        "n_clusters_cuda = sum(cv.size for cv in clusters_cuda_per_frame)\n",
-                        "hist_cuda = make_hist_from_batch(clusters_cuda_per_frame)\n",
-                        "\n",
-                        "print(f'CUDA batched:         {t_cuda:.3f}s  ({N/t_cuda:.0f} FPS, '\n",
-                        "      f'{n_clusters_cuda} clusters, {n_clusters_cuda/N:.2f}/frame)')\n",
-                        "print(f'  Kernel only:        {kernel_ms:.3f} ms/frame')\n",
-                        "print(f'  PCIe + overhead:    {t_cuda*1000/N - kernel_ms:.3f} ms/frame')\n",
-                        "print(f'Speedup (CPU/CUDA):   {t_cpu / t_cuda:.2f}x')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-graph",
-                    "metadata": {},
-                    "source": [
-                        "## CUDA — Graph (pinned dataset)\n",
-                        "Pre-records the H2D->kernel->D2H pipeline as a CUDA Graph per stream, cutting per-frame CPU API overhead (~21 us vs ~60 us for the streamed version)."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 11,
-                    "id": "graph",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "CUDA Graph:           3.132s  (6386 FPS, 28439289 clusters, 1421.96/frame)\n",
-                                "  Kernel+PCIe+ovhd:   0.157 ms/frame  (kernel not individually timed)\n",
-                                "Speedup (vs batched): 0.99x\n",
-                                "Speedup (CPU/Graph):  2.92x\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "cf_graph.register_input_buffer(data)\n",
-                        "clusters_graph_per_frame = []\n",
-                        "\n",
-                        "t0 = time.perf_counter()\n",
-                        "for start in range(0, N, BATCH_SIZE):\n",
-                        "    stop = min(start + BATCH_SIZE, N)\n",
-                        "    clusters_graph_per_frame.extend(\n",
-                        "        cf_graph.find_clusters_batched(data[start:stop], first_frame=start))\n",
-                        "t_graph = time.perf_counter() - t0\n",
-                        "\n",
-                        "cf_graph.unregister_input_buffer()\n",
-                        "n_clusters_graph = sum(cv.size for cv in clusters_graph_per_frame)\n",
-                        "hist_graph = make_hist_from_batch(clusters_graph_per_frame)\n",
-                        "\n",
-                        "print(f'CUDA Graph:           {t_graph:.3f}s  ({N/t_graph:.0f} FPS, '\n",
-                        "      f'{n_clusters_graph} clusters, {n_clusters_graph/N:.2f}/frame)')\n",
-                        "print(f'  Kernel+PCIe+ovhd:   {t_graph*1000/N:.3f} ms/frame  (kernel not individually timed)')\n",
-                        "print(f'Speedup (vs batched): {t_cuda / t_graph:.2f}x')\n",
-                        "print(f'Speedup (CPU/Graph):  {t_cpu / t_graph:.2f}x')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-async",
-                    "metadata": {},
-                    "source": [
-                        "## CUDA — async double-buffered pipeline\n",
-                        "Two pinned batch buffers: while the GPU processes `buf[cur]`, the CPU fills `buf[nxt]`, so H2D copies and kernels stay back-to-back."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 12,
-                    "id": "async",
-                    "metadata": {},
-                    "outputs": [],
-                    "source": [
-                        "# 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",
-                        "# cf_async.reset_timers()\n",
-                        "# t0 = time.perf_counter()\n",
-                        "\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",
-                        "# for start in range(BATCH_SIZE, N, BATCH_SIZE):\n",
-                        "#     nxt  = 1 - cur\n",
-                        "#     stop = min(start + BATCH_SIZE, N)\n",
-                        "#     n    = stop - start\n",
-                        "#     buf[nxt][:n] = data[start:stop]              # fill next while GPU runs current\n",
-                        "#     next_tok = cf_async.submit_batch(buf[nxt][:n], first_frame=start)\n",
-                        "#     clusters_async.extend(cf_async.collect(tok))  # drain previous\n",
-                        "#     tok = next_tok\n",
-                        "#     cur = nxt\n",
-                        "# clusters_async.extend(cf_async.collect(tok))      # drain final\n",
-                        "\n",
-                        "# t_async = time.perf_counter() - t0\n",
-                        "# cf_async.unpin_buffer(buf[0]); 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",
-                        "# print(f'Speedup (vs Graph):   {t_graph / t_async:.2f}x')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-agree",
-                    "metadata": {},
-                    "source": [
-                        "## Agreement sanity check\n",
-                        "Counts should match to a hair. The residual comes from the CUDA finder updating the pedestal once per frame vs the CPU's per-pixel update (analysed in `ClusterFinderFrozen_vs_CUDA.ipynb`)."
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 13,
-                    "id": "agree",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "name": "stdout",
-                            "output_type": "stream",
-                            "text": [
-                                "  CPU                28,438,072   diff vs CPU      0  (0.0000%)\n",
-                                "  CUDA per-frame     28,445,699   diff vs CPU  7,627  (0.0268%)\n",
-                                "  CUDA batched       28,439,289   diff vs CPU  1,217  (0.0043%)\n",
-                                "  CUDA graph         28,439,289   diff vs CPU  1,217  (0.0043%)\n"
-                            ]
-                        }
-                    ],
-                    "source": [
-                        "for name, n in [('CPU', n_clusters_cpu), ('CUDA per-frame', n_clusters_cuda_v1),\n",
-                        "                ('CUDA batched', n_clusters_cuda), ('CUDA graph', n_clusters_graph)]:\n",
-                        "                # ('CUDA async', n_clusters_async)]:\n",
-                        "    d = abs(n - n_clusters_cpu)\n",
-                        "    print(f'  {name:<16} {n:>12,}   diff vs CPU {d:>6,}  ({d/max(n_clusters_cpu,1):.4%})')"
-                    ]
-                },
-                {
-                    "cell_type": "markdown",
-                    "id": "md-plots",
-                    "metadata": {},
-                    "source": [
-                        "## Spectrum: CPU vs CUDA variants"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": 14,
-                    "id": "plots",
-                    "metadata": {},
-                    "outputs": [
-                        {
-                            "data": {
-                                "image/png":
-                                    "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",
-                                "text/plain": [
-                                    "<Figure size 800x600 with 2 Axes>"
-                                ]
-                            },
-                            "metadata": {},
-                            "output_type": "display_data"
-                        }
-                    ],
-                    "source": [
-                        "fig, (ax_spec, ax_ratio) = plt.subplots(\n",
-                        "    2, 1, figsize=(8, 6), sharex=True,\n",
-                        "    gridspec_kw={'height_ratios': [3, 1]})\n",
-                        "\n",
-                        "edges = hist_cpu.axes[0].edges\n",
-                        "cpu_vals   = hist_cpu.values()\n",
-                        "cuda_vals_v1  = hist_cuda_v1.values()\n",
-                        "cuda_vals  = hist_cuda.values()\n",
-                        "# async_vals = hist_async.values()\n",
-                        "graph_vals = hist_graph.values()\n",
-                        "\n",
-                        "ax_spec.stairs(cpu_vals,   edges, label=f'CPU         ({n_clusters_cpu} clusters)')\n",
-                        "ax_spec.stairs(cuda_vals_v1,  edges, label=f'CUDA single frames ({n_clusters_cuda} clusters)', linestyle='--')\n",
-                        "ax_spec.stairs(cuda_vals,  edges, label=f'CUDA batched ({n_clusters_cuda} clusters)', linestyle='--')\n",
-                        "# ax_spec.stairs(async_vals, edges, label=f'CUDA async  ({n_clusters_async} clusters)', linestyle='-.')\n",
-                        "ax_spec.stairs(graph_vals, edges, label=f'CUDA graph  ({n_clusters_graph} clusters)', linestyle=':')\n",
-                        "ax_spec.set_ylabel('Counts')\n",
-                        "ax_spec.set_title('Cluster energy spectrum: CPU vs CUDA variants')\n",
-                        "ax_spec.legend()\n",
-                        "ax_spec.grid(alpha=0.2)\n",
-                        "\n",
-                        "with np.errstate(divide='ignore', invalid='ignore'):\n",
-                        "    ratio_cuda  = np.where(cpu_vals > 0, cuda_vals  / cpu_vals, np.nan)\n",
-                        "    ratio_graph = np.where(cpu_vals > 0, graph_vals / cpu_vals, np.nan)\n",
-                        "\n",
-                        "ax_ratio.stairs(ratio_cuda,  edges, label='CUDA batched / CPU', color='C1', linestyle='--')\n",
-                        "ax_ratio.stairs(ratio_graph, edges, label='CUDA graph / CPU',  color='C3', linestyle=':')\n",
-                        "ax_ratio.axhline(1.0, color='gray', linewidth=0.5)\n",
-                        "ax_ratio.set_ylabel('Variant / CPU')\n",
-                        "ax_ratio.set_xlabel('Energy [ADU]')\n",
-                        "ax_ratio.set_ylim(0.5, 2.0)\n",
-                        "ax_ratio.legend(fontsize=8)\n",
-                        "ax_ratio.grid(alpha=0.3)\n",
-                        "\n",
-                        "plt.tight_layout()\n",
-                        "plt.show()"
-                    ]
-                },
-                {
-                    "cell_type": "code",
-                    "execution_count": null,
-                    "id": "cbd03f58-0068-4ad6-aec6-51ed9c8f8f1e",
-                    "metadata": {},
-                    "outputs": [],
-                    "source": []
-                }
-            ],
-        "metadata": {
-            "kernelspec": {
-                "display_name": "Python 3 (ipykernel)",
-                "language": "python",
-                "name": "python3"
-            },
-            "language_info": {
-                "codemirror_mode": {
-                    "name": "ipython",
-                    "version": 3
-                },
-                "file_extension": ".py",
-                "mimetype": "text/x-python",
-                "name": "python",
-                "nbconvert_exporter": "python",
-                "pygments_lexer": "ipython3",
-                "version": "3.11.15"
-            }
-        },
-        "nbformat": 4,
-        "nbformat_minor": 5
-    }
diff --git a/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb b/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb
deleted file mode 100644
index c81dc7ea..00000000
--- a/python/tests/ClusterFinderFrozen_vs_CUDA.ipynb
+++ /dev/null
@@ -1,309 +0,0 @@
-{
-    "cells": [
-        {
-            "cell_type": "markdown",
-            "id": "md-intro",
-            "metadata": {},
-            "source": [
-                "# Frozen-CPU vs CUDA — isolating pedestal-update timing\n",
-                "\n",
-                "`ClusterFinderFrozen` is a diagnostic twin of the serial `ClusterFinder`: **identical**\n",
-                "decision logic (negative skip, Test1, Test3, `value == max` store gate, edge handling,\n",
-                "rounding), differing in **exactly one** respect — *when* the pedestal is updated.\n",
-                "\n",
-                "| finder | pedestal update |\n",
-                "|---|---|\n",
-                "| `ClusterFinder` | per-pixel, **during** the raster scan (scan-order dependent) |\n",
-                "| `ClusterFinderFrozen` | frozen snapshot for all decisions; **deferred** to frame end |\n",
-                "| `ClusterFinderCUDA` | frozen per frame; batch update at frame end |\n",
-                "\n",
-                "`Frozen` and `CUDA` share the same update *model*."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 1,
-            "id": "imports",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import sys; sys.path.append('/home/ferjao_k/aare/build')\n",
-                "\n",
-                "from pathlib import Path\n",
-                "import numpy as np\n",
-                "import time\n",
-                "\n",
-                "from aare import File, ClusterFinder, ClusterFinderFrozen, ClusterFinderCUDA\n",
-                "from helper import (centers, only_sets, train_pedestal,\n",
-                "                    compare_finders, print_comparison, plot_spectra,\n",
-                "                    scan_mismatches, plot_masked_mismatch, walkthrough)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "id": "config",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "image (400, 400)  pedestal 1000  data 20000  streams 4\n"
-                    ]
-                }
-            ],
-            "source": [
-                "base = Path('/mnt/sls_det_storage/moench_data/2603_MaxIVBeamtime/2026032408/process/xrf/')\n",
-                "f = File(base / 'Cu_factor_10_data_master_0.json')\n",
-                "pd = File(base / 'Cu_factor_10_pedestal_master_0.json')\n",
-                "\n",
-                "n_frames_pd  = 1000\n",
-                "N            = 20000\n",
-                "cluster_size = (3, 3)\n",
-                "rows, cols   = f.rows, f.cols\n",
-                "image_size   = (rows, cols)\n",
-                "capacity     = 50_000\n",
-                "\n",
-                "N_STREAMS = 4     # single device pedestal -> apples-to-apples with the CPU finders\n",
-                "N_SIGMA   = 5\n",
-                "sx, sy = cluster_size\n",
-                "rx, ry = sx // 2, sy // 2\n",
-                "print(f'image {image_size}  pedestal {n_frames_pd}  data {N}  streams {N_STREAMS}')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 3,
-            "id": "build",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "cf_cpu = ClusterFinder(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                "cf_frozen = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                "cf_cuda = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                "                            max_clusters_per_frame=3000, n_streams=N_STREAMS)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 4,
-            "id": "train",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "pedestal train: 0.78s\n",
-                        "data: (20000, 400, 400) uint16\n"
-                    ]
-                }
-            ],
-            "source": [
-                "# Train ALL three on the SAME pedestal frames, then load the data block.\n",
-                "t0 = time.perf_counter()\n",
-                "for _ in range(n_frames_pd):\n",
-                "    img = pd.read_frame().copy()\n",
-                "    cf_cpu.push_pedestal_frame(img)\n",
-                "    cf_frozen.push_pedestal_frame(img)\n",
-                "    cf_cuda.push_pedestal_frame(img)\n",
-                "print(f'pedestal train: {time.perf_counter()-t0:.2f}s')\n",
-                "\n",
-                "f.seek(0)\n",
-                "data = f.read_n(N)\n",
-                "print('data:', data.shape, data.dtype)"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "md-compare",
-            "metadata": {},
-            "source": [
-                "## The three-way comparison\n",
-                "- All three finders now carry the **same** trained pedestal. \n",
-                "- `compare_finders` runs each over the same sampled frames and reports exact (tol=0) pairwise centre mismatches."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 5,
-            "id": "compare",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "Scanned 20000 frames\n",
-                        "\n",
-                        "Total clusters per finder:\n",
-                        "  cpu                46,478,554\n",
-                        "  frozen             46,478,563\n",
-                        "  cuda               46,478,563\n",
-                        "\n",
-                        "Pairwise exact mismatches (tol=0):\n",
-                        "  pair                             A-only     B-only      total\n",
-                        "  cpu vs frozen                        13         22         35  (0.0001%)\n",
-                        "  cpu vs cuda                          13         22         35  (0.0001%)\n",
-                        "  frozen vs cuda                        0          0          0  (0.0000%)\n"
-                    ]
-                }
-            ],
-            "source": [
-                "SCAN = 20000   # frames sampled across `data` (set to len(data) for the full block)\n",
-                "\n",
-                "totals, pairs, nscan, hists = compare_finders(\n",
-                "    # {'frozen': cf_frozen, 'cuda': cf_cuda}, data, scan_count=SCAN)\n",
-                "    {'cpu': cf_cpu, 'frozen': cf_frozen, 'cuda': cf_cuda}, data, scan_count=SCAN)\n",
-                "print_comparison(totals, pairs, nscan)"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "md-read",
-            "metadata": {},
-            "source": [
-                "**Reading the table.** If `frozen vs cuda` collapses to ~0 while `cpu vs cuda` and\n",
-                "`frozen vs cpu` are comparable and non-trivial, pedestal-update *timing* is the proven\n",
-                "cause. A small non-zero `frozen vs cuda` residual would be a genuine surprise (FP corner,\n",
-                "edge pixel, or the multi-stream path) worth chasing — not expected background."
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "424e2976",
-            "metadata": {},
-            "source": [
-                "## Cluster-energy spectra\n",
-                "\n",
-                "The three finders' cluster-energy distributions, accumulated in the same compare pass\n",
-                "(no extra scan). They should overlap almost perfectly; the ratio panel (each vs `cpu`)\n",
-                "makes any per-bin divergence — e.g. the `frozen vs cuda` residual — visible."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 6,
-            "id": "f057e296",
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png":
-                            "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",
-                        "text/plain": [
-                            "<Figure size 800x600 with 2 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "fig = plot_spectra(hists, totals,\n",
-                "                   title=f'Cluster energy spectra — cluster_size={cluster_size}, n_streams={N_STREAMS}')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "md-resid",
-            "metadata": {},
-            "source": [
-                "## Eyeball any residual `frozen vs cuda` mismatches\n",
-                "\n",
-                "Fresh finders, retrained identically, then the masked side-by-side view of the worst\n",
-                "residual frames. If the table showed 0, this should find nothing to plot."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 7,
-            "id": "resid",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "frozen-only: 0  cuda-only: 0  frames shown: 0\n"
-                    ]
-                }
-            ],
-            "source": [
-                "cf_frozen2 = ClusterFinderFrozen(image_size, cluster_size, n_sigma=N_SIGMA, capacity=capacity)\n",
-                "cf_cuda2   = ClusterFinderCUDA(image_size, cluster_size, n_sigma=N_SIGMA,\n",
-                "                               max_clusters_per_frame=3000, n_streams=N_STREAMS)\n",
-                "train_pedestal([cf_frozen2, cf_cuda2], f, n_frames_pd, seek=0)\n",
-                "\n",
-                "# scan_mismatches(a, b, ...) snapshots a.pedestal/noise (host) and b.device_*(0).\n",
-                "show, res = scan_mismatches(cf_frozen2, cf_cuda2, data, rx, ry,\n",
-                "                            scan_count=SCAN, n_show=8, tol=0)\n",
-                "print('frozen-only:', res['cpu_only'], ' cuda-only:', res['cu_only'], ' frames shown:', len(show))\n",
-                "if show:\n",
-                "    plot_masked_mismatch(show, data, rx, ry, rows, cols, zoom=30, show_vals=True)"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "d470cd40",
-            "metadata": {},
-            "source": [
-                "## Walkthrough of the surviving mismatch\n",
-                "\n",
-                "Manual Test1/Test3 recompute of the strongest residual cluster in `show`, under each\n",
-                "finder's decision-time snapshot pedestal."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 8,
-            "id": "c27d894d-64b2-45b2-aaa8-bfddc754b3f9",
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "No residual mismatches to walk through.\n"
-                    ]
-                }
-            ],
-            "source": [
-                "# Dissect the surviving frozen-vs-cuda residual.\n",
-                "# Recomputes Test1/Test3 under each finder's decision-time snapshot pedestal, so the\n",
-                "# lone mismatched cluster is fully explained (which test flips, and the pedestal gap).\n",
-                "walkthrough(show, data, rx, ry, rows, cols, N_SIGMA, pick=0, labels=('frozen', 'cuda'))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "id": "e2f86c8d-5d44-40ad-9fa7-80997aa260e6",
-            "metadata": {},
-            "outputs": [],
-            "source": []
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "Python 3 (ipykernel)",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.11.15"
-        }
-    },
-    "nbformat": 4,
-    "nbformat_minor": 5
-}
diff --git a/python/tests/helper.py b/python/tests/helper.py
deleted file mode 100644
index d524a1d1..00000000
--- a/python/tests/helper.py
+++ /dev/null
@@ -1,404 +0,0 @@
-"""Helpers for the CPU-vs-CUDA ClusterFinder mismatch analysis.
-
-Pure, parameterised versions of the functions that used to live inline in the
-notebook's forensic-view cell, plus the reusable scan + plot routines so the
-notebook cells stay thin.  Import in the notebook with::
-
-    from helper import (centers, only_sets, footprint_mask, shift_dist,
-                        train_pedestal, scan_mismatches, plot_masked_mismatch)
-
-None of these rely on notebook globals — cluster geometry (rx, ry) and the
-frame shape (rows, cols) are passed in explicitly.
-"""
-
-import numpy as np
-import matplotlib.pyplot as plt
-import boost_histogram as bh
-
-# --------------------------------------------------------------------------- #
-#  Pure helpers
-# --------------------------------------------------------------------------- #
-def print_pinning_budget(rows, cols, dtype=np.uint16, headroom_gb=4.0):
-    """
-    Print system RAM stats and estimate the maximum number of frames
-    that can be safely registered with cudaHostRegister / register_input_buffer.
-
-    Parameters
-    ----------
-    rows, cols : int      Detector frame dimensions.
-    dtype      : np.dtype Frame element type (default uint16 = 2 bytes/pixel).
-    headroom_gb: float    RAM to keep free for OS + CUDA context (default 4 GB).
-    """
-    # /proc/meminfo is always available on Linux — no extra dependency needed
-    meminfo = {}
-    with open('/proc/meminfo') as f:
-        for line in f:
-            key, val = line.split(':')
-            meminfo[key.strip()] = int(val.split()[0]) * 1024  # kB → bytes
-
-    total_bytes     = meminfo['MemTotal']
-    available_bytes = meminfo['MemAvailable']   # free + reclaimable cache
-    safe_bytes      = max(0, available_bytes - int(headroom_gb * 1024**3))
-
-    frame_bytes = rows * cols * np.dtype(dtype).itemsize
-    max_frames  = safe_bytes // frame_bytes
-
-    GiB = 1024**3
-    print("── System RAM ──────────────────────────────────────────")
-    print(f"  Total RAM           : {total_bytes/GiB:.1f} GiB")
-    print(f"  Currently available : {available_bytes/GiB:.1f} GiB  "
-          f"(free + reclaimable cache)")
-    print(f"  Reserved headroom   : {headroom_gb:.1f} GiB  "
-          f"(OS + CUDA context)")
-    print(f"  Safe pinning budget : {safe_bytes/GiB:.1f} GiB")
-    print()
-    print("── Frame layout ────────────────────────────────────────")
-    print(f"  Frame size          : {rows} × {cols} × "
-          f"{np.dtype(dtype).itemsize} B = {frame_bytes/1024:.1f} kB")
-    print()
-    print("── Pinning estimate ────────────────────────────────────")
-    print(f"  Max frames pinnable : {max_frames:,}  "
-          f"({max_frames * frame_bytes / GiB:.1f} GiB)")
-    print()
-    print("  Note: no swap on this machine — exceeding available RAM")
-    print("  will trigger the OOM killer. Stay within the budget.")
-
-def centers(cv):
-    """Set of ``(x, y)`` integer cluster centres from a ClusterVector."""
-    if cv.size == 0:
-        return set()
-    a = np.asarray(cv)
-    return {(int(x), int(y)) for x, y in zip(a["x"], a["y"])}
-
-
-def only_sets(cpu_c, cu_c, tol=1):
-    """CPU-only / CUDA-only centres, ignoring ``<=tol`` px 'shifted' matches.
-
-    ``tol=0`` returns the exact set difference (shifted twins stay counted as
-    mismatches); ``tol=1`` drops any mismatch that has a counterpart in the
-    other finder's 8-neighbourhood.
-    """
-    def near(p, other):
-        x, y = p
-        return any((x + dx, y + dy) in other
-                   for dx in range(-tol, tol + 1)
-                   for dy in range(-tol, tol + 1))
-
-    cpu_only = {p for p in cpu_c - cu_c if not near(p, cu_c)}
-    cu_only = {p for p in cu_c - cpu_c if not near(p, cpu_c)}
-    return cpu_only, cu_only
-
-
-def footprint_mask(cs, shape, rx, ry):
-    """Boolean map: True where a pixel lies in some cluster's footprint.
-
-    Each centre paints a ``(2*ry+1) x (2*rx+1)`` box, clipped at the borders.
-    """
-    m = np.zeros(shape, bool)
-    for (cx, cy) in cs:
-        m[max(0, cy - ry):cy + ry + 1, max(0, cx - rx):cx + rx + 1] = True
-    return m
-
-
-def shift_dist(p, other, R=4):
-    """Chebyshev distance from ``p`` to the nearest member of ``other``.
-
-    Rings are searched inner-to-outer so the first hit is the nearest.
-    Returns ``-1`` if nothing lies within ``R`` px.
-    """
-    x, y = p
-    for r in range(1, R + 1):
-        for dx in range(-r, r + 1):
-            for dy in range(-r, r + 1):
-                if max(abs(dx), abs(dy)) == r and (x + dx, y + dy) in other:
-                    return r
-    return -1
-
-
-# --------------------------------------------------------------------------- #
-#  Reusable scan + plot
-# --------------------------------------------------------------------------- #
-def train_pedestal(finders, f, n_frames, seek=0):
-    """Push the first ``n_frames`` frames of ``f`` into every finder given."""
-    f.seek(seek)
-    for _ in range(n_frames):
-        img = f.read_frame().copy()
-        for cf in finders:
-            cf.push_pedestal_frame(img)
-
-
-def scan_mismatches(cf_cpu, cf_cuda, data, rx, ry,
-                    scan_count=1000, n_show=8, tol=0):
-    """Run both finders over ``scan_count`` frames sampled across ``data``.
-
-    Before every frame it snapshots the pedestal each finder will DECIDE with
-    (CPU: host mean/rms; CUDA: device mean/rms on stream 0), so a later
-    recompute uses the exact decision-time baseline.
-
-    ``tol`` is forwarded to :func:`only_sets` when scoring a frame; ``tol=0``
-    keeps shifted twins as mismatches.  Returns ``(show, totals)`` where
-    ``show`` is the ``n_show`` frames with the most mismatches, each a dict
-    with ``fid``, ``score``, ``cpu_c``, ``cu_c``, ``mism`` and the four
-    pedestal arrays ``ped_cpu/noise_cpu/ped_cu/noise_cu``.
-    """
-    show = []
-    tot_cpu_only = tot_cu_only = 0
-    for fid in np.linspace(0, len(data) - 1, scan_count, dtype=int):
-        snap = dict(ped_cpu=np.asarray(cf_cpu.pedestal).copy(),
-                    noise_cpu=np.asarray(cf_cpu.noise).copy(),
-                    ped_cu=np.asarray(cf_cuda.device_pedestal(0)).copy(),
-                    noise_cu=np.asarray(cf_cuda.device_noise(0)).copy())
-        cf_cpu.find_clusters(data[fid])
-        cpu_c = centers(cf_cpu.steal_clusters(realloc_same_capacity=True))
-        cf_cuda.find_clusters(data[fid])
-        cu_c = centers(cf_cuda.steal_clusters(realloc_same_capacity=True))
-
-        cpu_only, cu_only = only_sets(cpu_c, cu_c, tol=tol)
-        tot_cpu_only += len(cpu_only)
-        tot_cu_only += len(cu_only)
-        mism = cpu_only | cu_only
-        if not mism:
-            continue
-        if len(show) < n_show or len(mism) > show[-1]["score"]:
-            show.append(dict(score=len(mism), fid=int(fid),
-                             cpu_c=cpu_c, cu_c=cu_c, mism=mism, **snap))
-            show.sort(key=lambda e: -e["score"])
-            del show[n_show:]
-    return show, dict(cpu_only=tot_cpu_only, cu_only=tot_cu_only)
-
-
-def compare_finders(finders, data, scan_count=1000, n_bins=200, e_range=(-2, 4000)):
-    """Run several finders over the same frames and score pairwise agreement.
-
-    ``finders`` is a dict ``{name: finder}``; every finder must already be
-    trained on the SAME pedestal frames.  Each is run over the same
-    ``scan_count`` frames sampled across ``data`` (identical ``find_clusters``/
-    ``steal_clusters`` API for CPU, frozen-CPU and CUDA).  In the same pass it
-    accumulates a per-finder cluster-energy histogram (from ``cv.sum()``), so no
-    extra scan is needed to draw the spectra.
-
-    Returns ``(totals, pairs, frames_scanned, hists)``:
-      * ``totals[name]``          total clusters found by that finder
-      * ``pairs[(a, b)]``         dict with ``a_only``/``b_only``/``mismatch``
-                                  summed over frames (exact, tol=0)
-      * ``hists[name]``           boost ``Histogram`` of cluster energies
-    Companions :func:`print_comparison` and :func:`plot_spectra` render these.
-    """
-    names = list(finders)
-    totals = {n: 0 for n in names}
-    hists = {n: bh.Histogram(bh.axis.Regular(n_bins, *e_range)) for n in names}
-    pairs = {}
-    for i, a in enumerate(names):
-        for b in names[i + 1:]:
-            pairs[(a, b)] = dict(a_only=0, b_only=0, mismatch=0)
-
-    fids = np.linspace(0, len(data) - 1, scan_count, dtype=int)
-    for fid in fids:
-        cs = {}
-        for n, cf in finders.items():
-            cf.find_clusters(data[fid])
-            cv = cf.steal_clusters(realloc_same_capacity=True)
-            cs[n] = centers(cv)
-            totals[n] += len(cs[n])
-            if cv.size:
-                hists[n].fill(np.asarray(cv.sum()).ravel())
-        for (a, b), acc in pairs.items():
-            a_only, b_only = only_sets(cs[a], cs[b], tol=0)
-            acc["a_only"] += len(a_only)
-            acc["b_only"] += len(b_only)
-            acc["mismatch"] += len(a_only) + len(b_only)
-    return totals, pairs, len(fids), hists
-
-
-def plot_spectra(hists, totals=None, title="Cluster energy spectrum"):
-    """Overlay per-finder cluster-energy spectra with a ratio panel.
-
-    ``hists`` is the ``{name: Histogram}`` returned by :func:`compare_finders`;
-    the first finder is the reference for the ratio panel.  Returns the Figure.
-    """
-    names = list(hists)
-    ref = names[0]
-    edges = hists[ref].axes[0].edges
-    vals = {n: hists[n].values() for n in names}
-
-    fig, (ax_spec, ax_ratio) = plt.subplots(
-        2, 1, figsize=(8, 6), sharex=True,
-        gridspec_kw={"height_ratios": [3, 1]})
-
-    styles = ["-", "--", "-.", ":"]
-    for i, n in enumerate(names):
-        lbl = n if totals is None else f"{n} ({totals[n]:,} clusters)"
-        ax_spec.stairs(vals[n], edges, label=lbl, linestyle=styles[i % len(styles)])
-    ax_spec.set_ylabel("Counts")
-    ax_spec.set_title(title)
-    ax_spec.legend()
-    ax_spec.grid(alpha=0.2)
-
-    with np.errstate(divide="ignore", invalid="ignore"):
-        for i, n in enumerate(names[1:], start=1):
-            ratio = np.where(vals[ref] > 0, vals[n] / vals[ref], np.nan)
-            ax_ratio.stairs(ratio, edges, label=f"{n} / {ref}",
-                            color=f"C{i}", linestyle=styles[i % len(styles)])
-    ax_ratio.axhline(1.0, color="gray", linewidth=0.5)
-    ax_ratio.set_ylabel(f"/ {ref}")
-    ax_ratio.set_xlabel("Energy [ADU]")
-    ax_ratio.set_ylim(0.5, 2.0)
-    ax_ratio.legend(fontsize=8)
-    ax_ratio.grid(alpha=0.3)
-
-    plt.tight_layout()
-    plt.show()
-    return fig
-
-
-def print_comparison(totals, pairs, frames_scanned):
-    """Pretty-print the output of :func:`compare_finders`."""
-    print(f"Scanned {frames_scanned} frames\n")
-    print("Total clusters per finder:")
-    for n, t in totals.items():
-        print(f"  {n:<16} {t:>12,}")
-    print("\nPairwise exact mismatches (tol=0):")
-    print(f"  {'pair':<28} {'A-only':>10} {'B-only':>10} {'total':>10}")
-    for (a, b), acc in pairs.items():
-        ref = max(totals[a], totals[b], 1)
-        pct = 100.0 * acc["mismatch"] / ref
-        print(f"  {a+' vs '+b:<28} {acc['a_only']:>10,} "
-              f"{acc['b_only']:>10,} {acc['mismatch']:>10,}  ({pct:.4f}%)")
-
-
-def walkthrough(show, data, rx, ry, rows, cols, n_sigma, pick=0,
-                labels=('A', 'B')):
-    """Manual Test1/Test3 recompute of the strongest residual mismatch.
-
-    Dissects ``show[pick]`` (from :func:`scan_mismatches`, run as ``(a, b)``)
-    under each finder's decision-time snapshot pedestal — ``a`` = ``ped_cpu`` /
-    ``noise_cpu``, ``b`` = ``ped_cu`` / ``noise_cu`` — and prints the raw and
-    pedestal-subtracted window plus the accept/reject each finder reaches.  With
-    the double/double build the recompute reproduces the kernel exactly, so a
-    lone surviving mismatch (e.g. the single 7x7 residual) is fully explained:
-    the test that flips (Test1/Test3) and the pedestal gap name the cause.
-    """
-    if not show:
-        print("No residual mismatches to walk through.")
-        return
-    e = show[pick]
-    sx, sy = 2 * rx + 1, 2 * ry + 1
-    c3 = np.sqrt(sx * sy)
-    frame = data[e['fid']].astype(np.float64)
-    sub_a = frame - e['ped_cpu']
-    sub_b = frame - e['ped_cu']
-
-    # strongest mismatch pixel whose full window stays inside the frame
-    cand = [p for p in e['mism']
-            if rx <= p[0] < cols - rx and ry <= p[1] < rows - ry]
-    if not cand:
-        print(f"frame {e['fid']}: all mismatches on the border — pick another.")
-        return
-    X0, Y0 = max(cand, key=lambda p: max(sub_a[p[1], p[0]], sub_b[p[1], p[0]]))
-
-    def evaluate(mean, rms_img):
-        sig = (frame[Y0 - ry:Y0 + ry + 1, X0 - rx:X0 + rx + 1]
-               - mean[Y0 - ry:Y0 + ry + 1, X0 - rx:X0 + rx + 1])
-        value = frame[Y0, X0] - mean[Y0, X0]
-        rms = rms_img[Y0, X0]
-        thr1, thr3 = n_sigma * rms, c3 * n_sigma * rms
-        mx, total = sig.max(), sig.sum()
-        localmax = bool(value >= mx)
-        t1, t3 = bool(mx > thr1), bool(total > thr3)
-        accept = bool(value >= -thr1) and localmax and (t1 or t3)
-        return dict(sig=sig, value=value, rms=rms, thr1=thr1, thr3=thr3,
-                    mx=mx, total=total, localmax=localmax, t1=t1, t3=t3,
-                    accept=accept)
-
-    la, lb = labels
-    owner = la if (X0, Y0) in e['cpu_c'] else lb
-    print(f"frame {e['fid']}   centre (x={X0}, y={Y0})   accepted only by {owner}")
-    print("raw window (ADU):")
-    print(np.array2string(frame[Y0 - ry:Y0 + ry + 1,
-                                X0 - rx:X0 + rx + 1].astype(int)))
-    print()
-
-    ra = evaluate(e['ped_cpu'], e['noise_cpu'])
-    rb = evaluate(e['ped_cu'], e['noise_cu'])
-
-    def detail(tag, r):
-        print(f"--- {tag} ---")
-        print("  subtracted window:")
-        print("   ", np.array2string(r['sig'], precision=1, prefix='    '))
-        print(f"  centre value = {float(r['value']):8.2f}   "
-              f"(local max? {r['localmax']})")
-        print(f"  max          = {float(r['mx']):8.2f}      "
-              f"total = {float(r['total']):8.2f}")
-        print(f"  rms(centre)  = {float(r['rms']):8.3f}")
-        print(f"  Test1: max   > {n_sigma}*rms      = {float(r['thr1']):8.2f} -> {r['t1']}")
-        print(f"  Test3: total > {c3:.0f}*{n_sigma}*rms = {float(r['thr3']):8.2f} -> {r['t3']}")
-        print(f"  ACCEPT = {r['accept']}")
-        print()
-
-    detail(la, ra)
-    detail(lb, rb)
-    print(f"RESULT:  {la} = {'ACCEPT' if ra['accept'] else 'reject'} ,  "
-          f"{lb} = {'ACCEPT' if rb['accept'] else 'reject'}")
-    gap = abs(float(e['ped_cpu'][Y0, X0] - e['ped_cu'][Y0, X0]))
-    rgap = abs(float(e['noise_cpu'][Y0, X0] - e['noise_cu'][Y0, X0]))
-    print(f"pedestal mean gap @centre = {gap:.4f} ADU;   rms gap = {rgap:.4f}")
-    if ra['accept'] == rb['accept']:
-        print("NOTE: recompute agrees for this centre pixel — the split is FP "
-              "rounding right at threshold or a window-neighbour effect; "
-              "try another pick.")
-
-
-def plot_masked_mismatch(show, data, rx, ry, rows, cols,
-                         zoom=30, show_vals=True):
-    """Side-by-side masked view of each frame in ``show``.
-
-    Cluster pixels are coloured by pedestal-subtracted value (value printed
-    when ``show_vals``); non-cluster pixels are white; a red dot marks every
-    cluster centre.  The cut is centred on the strongest mismatch pixel of the
-    frame.  No box, no tolerance discarding — a shifted twin in the other
-    finder stays visible.  Returns the Figure.
-    """
-    cmap = plt.cm.viridis.copy()
-    cmap.set_bad("white")
-    fig, axes = plt.subplots(len(show), 2, figsize=(11, 5.3 * len(show)),
-                             squeeze=False)
-    for r, e in enumerate(show):
-        fid = e["fid"]
-        sub_cpu = data[fid].astype(np.float64) - e["ped_cpu"]
-        sub_cu = data[fid].astype(np.float64) - e["ped_cu"]
-        X0, Y0 = max(e["mism"],
-                     key=lambda p: max(sub_cpu[p[1], p[0]], sub_cu[p[1], p[0]]))
-        half = zoom // 2
-        r0, r1 = max(0, Y0 - half), min(rows, Y0 + half)
-        c0, c1 = max(0, X0 - half), min(cols, X0 + half)
-        win_cpu, win_cu = sub_cpu[r0:r1, c0:c1], sub_cu[r0:r1, c0:c1]
-        mask_cpu = footprint_mask(e["cpu_c"], sub_cpu.shape, rx, ry)[r0:r1, c0:c1]
-        mask_cu = footprint_mask(e["cu_c"], sub_cu.shape, rx, ry)[r0:r1, c0:c1]
-        union = mask_cpu | mask_cu
-        vmax = max(np.percentile(np.concatenate([win_cpu[union], win_cu[union]]),
-                                 99) if union.any() else 50.0, 50.0)
-
-        for ax, win, mask, cs, name in [
-                (axes[r][0], win_cpu, mask_cpu, e["cpu_c"], "CPU"),
-                (axes[r][1], win_cu, mask_cu, e["cu_c"], "CUDA")]:
-            ax.imshow(np.ma.masked_where(~mask, win), cmap=cmap, vmin=0,
-                      vmax=vmax, interpolation="nearest")
-            for (cx, cy) in cs:
-                if c0 <= cx < c1 and r0 <= cy < r1:
-                    ax.plot(cx - c0, cy - r0, ".", color="red", ms=7)
-            if show_vals:
-                for i in range(win.shape[0]):
-                    for j in range(win.shape[1]):
-                        if mask[i, j]:
-                            ax.text(j, i, f"{win[i, j]:.0f}", ha="center",
-                                    va="center", fontsize=6,
-                                    color="white" if win[i, j] < 0.55 * vmax
-                                    else "black")
-            ax.set_title(f"frame {fid} — {name}: {len(cs)} clusters", fontsize=10)
-            ax.set_xticks([])
-            ax.set_yticks([])
-        axes[r][0].set_ylabel(f"{e['score']} mismatches\nzoom @ ({X0},{Y0})",
-                              fontsize=9)
-    plt.tight_layout()
-    plt.show()
-    return fig
diff --git a/src/ClusterFinderCUDA.test.cu b/src/ClusterFinderCUDA.test.cu
deleted file mode 100644
index e4d7d904..00000000
--- a/src/ClusterFinderCUDA.test.cu
+++ /dev/null
@@ -1,843 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-#include <algorithm>
-#include <chrono>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <filesystem>
-#include <numeric>
-#include <vector>
-
-#include "aare/ClusterFinder.hpp"
-#include "aare/ClusterFinderCUDA.hpp"
-#include "aare/File.hpp"
-#include "aare/Frame.hpp"
-#include "aare/NDArray.hpp"
-#include "aare/Pedestal.hpp"
-#include "aare/defs.hpp"
-#include "aare/utils/batch.hpp"
-
-// _____________
-//
-// Timing helper
-// _____________
-struct Timer {
-    using clock = std::chrono::high_resolution_clock;
-    clock::time_point t0;
-
-    void start() { t0 = clock::now(); }
-
-    double elapsed_ms() const {
-        return std::chrono::duration<double, std::milli>(clock::now() - t0)
-            .count();
-    }
-};
-
-// __________________
-//
-// Cluster comparison
-// __________________
-template <typename ClusterType> struct ClusterComparison {
-    size_t cpu_count = 0;
-    size_t gpu_count = 0;
-    size_t matched = 0;
-    size_t position_mismatch = 0;
-    size_t data_mismatch = 0;
-    size_t cpu_only = 0;
-    size_t gpu_only = 0;
-};
-
-// Sort clusters by (y, x) for deterministic comparison
-template <typename ClusterType>
-void sort_clusters(std::vector<ClusterType> &clusters) {
-    std::sort(clusters.begin(), clusters.end(),
-              [](const ClusterType &a, const ClusterType &b) {
-                  if (a.y != b.y)
-                      return a.y < b.y;
-                  return a.x < b.x;
-              });
-}
-
-// Compare two sorted cluster lists
-template <typename ClusterType>
-ClusterComparison<ClusterType>
-compare_clusters(std::vector<ClusterType> &cpu_clusters,
-                 std::vector<ClusterType> &gpu_clusters) {
-    sort_clusters(cpu_clusters);
-    sort_clusters(gpu_clusters);
-
-    ClusterComparison<ClusterType> result;
-    result.cpu_count = cpu_clusters.size();
-    result.gpu_count = gpu_clusters.size();
-
-    size_t ci = 0, gi = 0;
-    while (ci < cpu_clusters.size() && gi < gpu_clusters.size()) {
-        const auto &cc = cpu_clusters[ci];
-        const auto &gc = gpu_clusters[gi];
-
-        if (cc.y == gc.y && cc.x == gc.x) {
-            // Same position/check data
-            bool data_ok = true;
-            constexpr int N =
-                ClusterType::cluster_size_x * ClusterType::cluster_size_y;
-            for (int k = 0; k < N; ++k) {
-                // if (cc.data[k] != gc.data[k]) { // a bit too strict
-                // espacially that pedestal update is slightly different
-                if (std::abs(cc.data[k] - gc.data[k]) > 5) {
-                    data_ok = false;
-                    break;
-                }
-            }
-            if (data_ok)
-                result.matched++;
-            else
-                result.data_mismatch++;
-            ci++;
-            gi++;
-        } else if (cc.y < gc.y || (cc.y == gc.y && cc.x < gc.x)) {
-            result.cpu_only++;
-            ci++;
-        } else {
-            result.gpu_only++;
-            gi++;
-        }
-    }
-    result.cpu_only += (cpu_clusters.size() - ci);
-    result.gpu_only += (gpu_clusters.size() - gi);
-
-    return result;
-}
-
-// ________________
-//
-// Cluster printing
-// ________________
-template <typename ClusterType>
-void print_cluster_comparison(
-    const std::vector<std::vector<ClusterType>> &cpu_results,
-    const std::vector<std::vector<ClusterType>> &gpu_results,
-    size_t max_per_frame = 10, size_t max_frames = 100) {
-    constexpr int NX = ClusterType::cluster_size_x;
-    constexpr int NY = ClusterType::cluster_size_y;
-    constexpr int N = NX * NY;
-
-    size_t frames_shown = 0;
-    for (size_t fi = 0; fi < cpu_results.size() && frames_shown < max_frames;
-         ++fi) {
-        if (cpu_results[fi].empty() && gpu_results[fi].empty())
-            continue;
-
-        size_t n_cpu = cpu_results[fi].size();
-        size_t n_gpu = gpu_results[fi].size();
-        printf("\n  Frame %zu: CPU=%zu clusters, GPU=%zu clusters\n", fi, n_cpu,
-               n_gpu);
-
-        // Merge-walk over sorted lists (assumes already sorted by y,x)
-        size_t ci = 0, gi = 0;
-        size_t shown = 0;
-        while ((ci < n_cpu || gi < n_gpu) && shown < max_per_frame) {
-            bool have_cpu = ci < n_cpu;
-            bool have_gpu = gi < n_gpu;
-
-            // Determine if current entries match in position
-            bool same_pos = have_cpu && have_gpu &&
-                            cpu_results[fi][ci].x == gpu_results[fi][gi].x &&
-                            cpu_results[fi][ci].y == gpu_results[fi][gi].y;
-
-            if (same_pos) {
-                const auto &cc = cpu_results[fi][ci];
-                const auto &gc = gpu_results[fi][gi];
-
-                // Check if data differs
-                bool differs = false;
-                for (int k = 0; k < N; ++k) {
-                    if (cc.data[k] != gc.data[k]) {
-                        differs = true;
-                        break;
-                    }
-                }
-
-                printf("    CPU and GPU clusters found at SAME position "
-                       "(col=%3d, row=%3d)\n %s\n",
-                       cc.x, cc.y, differs ? "DATA MISMATCH" : "MATCH");
-                printf("      CPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(cc.data[k]));
-                }
-                printf("]\n");
-                if (differs) {
-                    printf("      GPU: [");
-                    for (int k = 0; k < N; ++k) {
-                        if (k)
-                            printf(", ");
-                        printf("%6d", static_cast<int>(gc.data[k]));
-                    }
-                    printf("]\n");
-                    printf("     diff: [");
-                    for (int k = 0; k < N; ++k) {
-                        if (k)
-                            printf(", ");
-                        int d = static_cast<int>(gc.data[k]) -
-                                static_cast<int>(cc.data[k]);
-                        printf("%+6d", d);
-                    }
-                    printf("]\n");
-                }
-                ci++;
-                gi++;
-                shown++;
-            } else if (!have_gpu ||
-                       (have_cpu &&
-                        (cpu_results[fi][ci].y < gpu_results[fi][gi].y ||
-                         (cpu_results[fi][ci].y == gpu_results[fi][gi].y &&
-                          cpu_results[fi][ci].x < gpu_results[fi][gi].x)))) {
-                const auto &cc = cpu_results[fi][ci];
-                printf("    (%3d, %3d) CPU ONLY\n", cc.x, cc.y);
-                printf("      CPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(cc.data[k]));
-                }
-                printf("]\n");
-                ci++;
-                shown++;
-            } else {
-                const auto &gc = gpu_results[fi][gi];
-                printf("    (%3d, %3d) GPU ONLY\n", gc.x, gc.y);
-                printf("      GPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(gc.data[k]));
-                }
-                printf("]\n");
-                gi++;
-                shown++;
-            }
-        }
-        frames_shown++;
-    }
-}
-
-// _________________________________________
-//
-// Helpers for the updated (CPU-parity) API
-// _________________________________________
-
-// Copy a ClusterVector into a std::vector<ClusterType> for downstream
-// comparison code that expects the latter.
-template <typename Finder, typename ClusterType>
-void drain_into(Finder &f, std::vector<ClusterType> &out) {
-    auto cv = f.steal_clusters(true);
-    out.clear();
-    out.reserve(cv.size());
-    for (size_t j = 0; j < cv.size(); ++j)
-        out.push_back(cv[j]);
-}
-
-// Feed a set of cached pedestal frames through any finder exposing the
-// CPU-style push_pedestal_frame(NDView) method. Works for both
-// ClusterFinder and ClusterFinderCUDA.
-template <typename Finder, typename FRAME_TYPE>
-void feed_pedestal(
-    Finder &f, const std::vector<aare::NDArray<FRAME_TYPE, 2>> &ped_frames) {
-    for (const auto &frame : ped_frames) {
-        f.push_pedestal_frame(frame.view());
-    }
-}
-
-// ____________
-//
-//     Main
-// ____________
-int main(int argc, char *argv[]) {
-
-    // Parse arguments
-    // const char *default_pedestal =
-    //     "/mnt/sls_det_storage/highZ_data/CZT_Vienna/Khalil/Calibration_CZT/"
-    //     "2025Sept_m694/Sn25300eV/500_us_voltage_40kV/"
-    //     "250922_CZTonly_Pedestal_Tp15C_tint_500_master_0.json";
-    const char *default_pedestal =
-        "/mnt/sls_det_storage/matterhorn_data/aare_test_data/Moench03new/"
-        "cu_half_speed_master_4.json";
-    // const char *default_data =
-    //     "/mnt/sls_det_storage/highZ_data/CZT_Vienna/Khalil/Calibration_CZT/"
-    //     "2025Sept_m694/Sn25300eV/500_us_voltage_40kV/"
-    //     "250922_CZTonly_Xray_Tp15C_tint_500_master_0.json";
-    const char *default_data =
-        "/mnt/sls_det_storage/matterhorn_data/aare_test_data/Moench03new/"
-        "cu_half_speed_master_4.json";
-
-    std::filesystem::path pedestal_path(argc > 1 ? argv[1] : default_pedestal);
-    std::filesystem::path data_path(argc > 2 ? argv[2] : default_data);
-
-    if (!std::filesystem::exists(pedestal_path)) {
-        fprintf(stderr, "Pedestal file not found: %s\n", pedestal_path.c_str());
-        return 1;
-    }
-    if (!std::filesystem::exists(data_path)) {
-        fprintf(stderr, "Data file not found: %s\n", data_path.c_str());
-        return 1;
-    }
-
-    // Defaults: Adjust depending on the test dataset used
-    size_t n_pedestal_frames = 1000;
-    size_t n_data_frames = 10000;
-    double nSigma = 5.0;
-
-    if (argc > 3)
-        n_pedestal_frames = std::atol(argv[3]);
-    if (argc > 4)
-        n_data_frames = std::atol(argv[4]);
-    if (argc > 5)
-        nSigma = std::atof(argv[5]);
-
-    // Detector geometry from master file
-    constexpr uint8_t cs_x = 3;
-    constexpr uint8_t cs_y = 3;
-    using ClusterType = aare::Cluster<int32_t, cs_x, cs_y>;
-    using FRAME_TYPE = uint16_t;
-    using PEDESTAL_TYPE = double;
-
-    // Read actual frame dimensions from the pedestal file
-    ssize_t ROWS, COLS;
-    {
-        aare::File probe(pedestal_path, "r");
-        auto first_frame = probe.read_frame();
-        ROWS = first_frame.rows();
-        COLS = first_frame.cols();
-    }
-
-    constexpr size_t MAX_CLUSTERS_PER_FRAME = 2048;
-
-    // Parameters for batched / mutli-stream runs
-    constexpr size_t BATCH_SIZE = 2000;
-    constexpr int N_STREAMS = 5;
-
-    printf("=== Cluster Finder: CPU vs CUDA ===\n");
-    printf("Detector:  %zu x %zu\n", ROWS, COLS);
-    printf("Cluster:   %d x %d\n", ClusterType::cluster_size_x,
-           ClusterType::cluster_size_y);
-    printf("nSigma:    %.1f\n", nSigma);
-
-    // =========================================================================
-    // Phase 1: Build pedestal from dark frames (sanity check only + frame
-    // cache)
-    // =========================================================================
-    //
-    // Neither ClusterFinder nor ClusterFinderCUDA needs an external Pedestal
-    // object; both build their own via push_pedestal_frame. We still read the
-    // pedestal file once, but cache the frames in memory so every subsequent
-    // finder can be fed without re-hitting disk. We also build a standalone
-    // Pedestal purely to print a sanity check.
-    // =========================================================================
-    printf("\n--- Phase 1: Pedestal accumulation (sanity check + cache) ---\n");
-
-    std::vector<aare::NDArray<FRAME_TYPE, 2>> pedestal_frames;
-    aare::Pedestal<PEDESTAL_TYPE> pedestal(ROWS, COLS, 1000);
-
-    {
-        aare::File ped_file(pedestal_path, "r");
-        size_t total_ped = ped_file.total_frames();
-        size_t use_ped =
-            (n_pedestal_frames == 0 || n_pedestal_frames > total_ped)
-                ? total_ped
-                : n_pedestal_frames;
-        printf("Pedestal frames: %zu / %zu\n", use_ped, total_ped);
-
-        pedestal_frames.reserve(use_ped);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_ped; ++i) {
-            auto frame = ped_file.read_frame();
-            auto view = frame.view<FRAME_TYPE>();
-
-            // Copy into a standalone NDArray that we can reuse as many times
-            // as we have finders to feed.
-            aare::NDArray<FRAME_TYPE, 2> arr({ROWS, COLS});
-            for (ssize_t r = 0; r < ROWS; ++r)
-                for (ssize_t c = 0; c < COLS; ++c)
-                    arr(r, c) = view(r, c);
-            pedestal_frames.push_back(std::move(arr));
-
-            pedestal.push_no_update(view);
-        }
-        pedestal.update_mean();
-
-        printf("Pedestal read+cached+built in %.1f ms\n", t.elapsed_ms());
-    }
-
-    printf("Pedestal mean[0,0] = %.2f, std[0,0] = %.4f\n", pedestal.mean(0, 0),
-           pedestal.std(0, 0));
-
-    // =========================================================================
-    // Phase 2: Read data frames
-    // =========================================================================
-    printf("\n--- Phase 2: Read data frames ---\n");
-
-    aare::File data_file(data_path, "r");
-    size_t total_data = data_file.total_frames();
-    size_t use_data = std::min(n_data_frames, total_data);
-    printf("Data frames: %zu / %zu\n", use_data, total_data);
-
-    // Pre-read all frames into memory to remove I/O from timing
-    std::vector<aare::NDArray<FRAME_TYPE, 2>> frames;
-    frames.reserve(use_data);
-    data_file.seek(n_pedestal_frames);
-    for (size_t i = 0; i < use_data; ++i) {
-        auto f = data_file.read_frame();
-        // Copy into NDArray for consistent access
-        aare::NDArray<FRAME_TYPE, 2> arr({ROWS, COLS});
-        auto view = f.view<FRAME_TYPE>();
-        for (size_t r = 0; r < ROWS; ++r)
-            for (size_t c = 0; c < COLS; ++c)
-                arr(r, c) = view(r, c);
-        frames.push_back(std::move(arr));
-    }
-    printf("Frames loaded into memory\n");
-
-    // =========================================================================
-    // Phase 3: Sequential (CPU) cluster finding
-    // =========================================================================
-    printf("\n--- Phase 3: CPU ClusterFinder ---\n");
-
-    std::vector<std::vector<ClusterType>> cpu_results(use_data);
-    size_t cpu_total_clusters = 0;
-
-    {
-        // Build a ClusterFinder with the same pedestal
-        aare::ClusterFinder<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cf(
-            {ROWS, COLS}, nSigma);
-
-        feed_pedestal(cf, pedestal_frames);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_data; ++i) {
-            cf.find_clusters(frames[i].view(), static_cast<uint64_t>(i));
-            drain_into(cf, cpu_results[i]);
-            cpu_total_clusters += cpu_results[i].size();
-        }
-
-        double cpu_time = t.elapsed_ms();
-        printf("CPU: %zu clusters in %.1f ms (%.2f ms/frame)\n",
-               cpu_total_clusters, cpu_time, cpu_time / use_data);
-    }
-
-    // =========================================================================
-    // Phase 4: CUDA cluster finding
-    // =========================================================================
-    //
-    // The API mirrors ClusterFinder: push_pedestal_frame to train, then
-    // find_clusters / steal_clusters for each frame. H2D transfer and kernel
-    // launch happen internally.
-    //
-    // Toggle between the single-stream and batched paths by swapping which
-    // block is enabled. They both write into gpu_results so only one at a
-    // time makes sense.
-    // =========================================================================
-    printf("\n--- Phase 4: CUDA ClusterFinder ---\n");
-
-    std::vector<std::vector<ClusterType>> gpu_results(use_data);
-    size_t gpu_total_clusters = 0;
-
-    // --- Single frame on a single CUDA stream ---
-    /*
-    {
-        aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cuda_cf(
-            {ROWS, COLS}, nSigma);
-
-        feed_pedestal(cuda_cf, pedestal_frames);
-
-        // Warmup: first CUDA call pays driver/context init overhead. The
-        // pedestal drifts slightly during this single frame, which is
-        // acceptable for timing purposes.
-        cuda_cf.find_clusters(frames[0].view(), 0);
-        cuda_cf.steal_clusters(true);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_data; ++i) {
-            cuda_cf.find_clusters(frames[i].view(), static_cast<uint64_t>(i));
-            drain_into(cuda_cf, gpu_results[i]);
-            gpu_total_clusters += gpu_results[i].size();
-        }
-
-        double gpu_time = t.elapsed_ms();
-        printf("GPU: %zu clusters in %.1f ms (%.2f ms/frame)\n",
-               gpu_total_clusters, gpu_time, gpu_time / use_data);
-    }
-    */
-
-    // --- 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);
-
-        std::vector<FRAME_TYPE> batch_buffer(BATCH_SIZE * ROWS * COLS);
-        cuda_cf.register_input_buffer(batch_buffer.data(),
-                                      batch_buffer.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;
-
-        for (size_t bi = 0; bi < n_batches; ++bi) {
-            const size_t offset = bi * BATCH_SIZE;
-            const size_t actual_batch = std::min(BATCH_SIZE, use_data - offset);
-
-            t.start();
-            pack_frame_batch(frames, offset, actual_batch, batch_buffer);
-            pack_ms += t.elapsed_ms();
-
-            aare::NDView<FRAME_TYPE, 3> batch_view(
-                batch_buffer.data(),
-                {static_cast<ssize_t>(actual_batch), ROWS, COLS});
-
-            t.start();
-            auto batch_results =
-                cuda_cf.find_clusters_batched(batch_view, offset);
-            gpu_ms += t.elapsed_ms();
-
-            for (size_t f = 0; f < actual_batch; ++f) {
-                auto &cv = batch_results[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();
-            }
-        }
-
-        cuda_cf.unregister_input_buffer();
-
-        printf("GPU(batched): %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);
-    }
-    */
-
-    // --- 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
-    // =========================================================================
-    printf("\n--- Phase 5: Comparison ---\n");
-
-    size_t total_matched = 0;
-    size_t total_data_mismatch = 0;
-    size_t total_cpu_only = 0;
-    size_t total_gpu_only = 0;
-    size_t frames_with_differences = 0;
-
-    for (size_t i = 0; i < use_data; ++i) {
-        auto result = compare_clusters(cpu_results[i], gpu_results[i]);
-
-        total_matched += result.matched;
-        total_data_mismatch += result.data_mismatch;
-        total_cpu_only += result.cpu_only;
-        total_gpu_only += result.gpu_only;
-
-        bool has_diff = (result.cpu_only > 0 || result.gpu_only > 0 ||
-                         result.data_mismatch > 0);
-        if (has_diff) {
-            frames_with_differences++;
-            // Print details for first few mismatching frames
-            if (frames_with_differences <= 5) {
-                printf("  Frame %zu: CPU=%zu GPU=%zu matched=%zu "
-                       "data_mismatch=%zu cpu_only=%zu gpu_only=%zu\n",
-                       i, result.cpu_count, result.gpu_count, result.matched,
-                       result.data_mismatch, result.cpu_only, result.gpu_only);
-            }
-        }
-    }
-
-    printf("\nSummary over %zu frames:\n", use_data);
-    printf("  CPU total clusters:    %zu\n", cpu_total_clusters);
-    printf("  GPU total clusters:    %zu\n", gpu_total_clusters);
-    printf("  Matched:               %zu\n", total_matched);
-    printf("  Data mismatch:         %zu\n", total_data_mismatch);
-    printf("  CPU only:              %zu\n", total_cpu_only);
-    printf("  GPU only:              %zu\n", total_gpu_only);
-    printf("  Frames with diffs:     %zu / %zu\n", frames_with_differences,
-           use_data);
-
-    if (total_cpu_only == 0 && total_gpu_only == 0 &&
-        total_data_mismatch == 0) {
-        printf("\n*** PASS: CPU and GPU results match exactly ***\n");
-    } else {
-        printf("\n*** DIFFERENCES DETECTED ***\n");
-    }
-
-    // // Print detailed cluster comparison (side-by-side with diffs)
-    // if (cpu_total_clusters > 0 || gpu_total_clusters > 0) {
-    //     size_t max_clusters_per_frame = 10;
-    //     size_t max_frames = 100;
-    //     printf("\n--- Cluster details (up to %zu frames, %zu clusters each)
-    //     ---\n", max_frames, max_clusters_per_frame);
-    //     print_cluster_comparison(cpu_results, gpu_results,
-    //     max_clusters_per_frame, max_frames);
-    // }
-
-    // =========================================================================
-    // Phase 6: Per-frame timing benchmark
-    // =========================================================================
-    printf("\n--- Phase 6: Detailed timing (%d iterations) ---\n", 10000);
-
-    if (use_data > 0) {
-        const int N_ITER = 10000;
-        const auto &bench_frame = frames[0];
-
-        // CPU benchmark
-        {
-            aare::ClusterFinder<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cf(
-                {ROWS, COLS}, nSigma);
-
-            // Load pedestal
-            feed_pedestal(cf, pedestal_frames);
-
-            // Warmup
-            cf.find_clusters(bench_frame.view(), 0);
-            cf.steal_clusters(true);
-
-            Timer t;
-            t.start();
-            for (int iter = 0; iter < N_ITER; ++iter) {
-                cf.find_clusters(bench_frame.view(), 0);
-                cf.steal_clusters(true);
-            }
-            double cpu_per_frame = t.elapsed_ms() / N_ITER;
-            printf("CPU: %.3f ms/frame\n", cpu_per_frame);
-        }
-        // --- GPU benchmark (single frame, single stream) ---
-        {
-            aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>
-                cuda_cf({ROWS, COLS}, nSigma);
-            feed_pedestal(cuda_cf, pedestal_frames);
-
-            // Warmup
-            cuda_cf.find_clusters(bench_frame.view(), 0);
-            // cuda_cf.steal_clusters(true);
-
-            Timer t;
-            t.start();
-            for (int iter = 0; iter < N_ITER; ++iter) {
-                cuda_cf.find_clusters(bench_frame.view(), 0);
-                cuda_cf.steal_clusters(true);
-            }
-            printf("GPU:          %.3f ms/frame (H2D + kernel + D2H, single "
-                   "frame, single stream)\n",
-                   t.elapsed_ms() / N_ITER);
-        }
-
-        // --- GPU benchmark (batched + multi-streamed) ---
-        {
-            aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>
-                cuda_cf({ROWS, COLS}, nSigma, MAX_CLUSTERS_PER_FRAME,
-                        N_STREAMS);
-            feed_pedestal(cuda_cf, pedestal_frames);
-
-            // Build one contiguous batch of BATCH_SIZE copies of bench_frame.
-            // Register as pinned for DMA-speed H2D transfers.
-            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. The kernel mutates the device-side pedestal for every
-            // non-photon pixel, so after a 500-frame warmup the pedestal
-            // state has drifted. Reset to a clean baseline by clearing the
-            // host pedestal and re-feeding the cached frames; this also
-            // re-arms the dirty flag so the next find_clusters re-uploads.
-            (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;
-
-            std::vector<aare::ClusterVector<ClusterType>> batch_results;
-
-            Timer t;
-            t.start();
-            for (size_t b = 0; b < n_iter_batches; ++b) {
-                batch_results =
-                    cuda_cf.find_clusters_batched(batch_view, b * BATCH_SIZE);
-            }
-            cuda_cf.unregister_input_buffer();
-
-            printf("GPU(batched): %.3f ms/frame (H2D + kernel + D2H, "
-                   "batch=%zu, streams=%d)\n",
-                   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");
-    return 0;
-}
\ No newline at end of file
diff --git a/src/ClusterFinderCUDA_old.test.cu b/src/ClusterFinderCUDA_old.test.cu
deleted file mode 100644
index f98d2246..00000000
--- a/src/ClusterFinderCUDA_old.test.cu
+++ /dev/null
@@ -1,683 +0,0 @@
-// SPDX-License-Identifier: MPL-2.0
-#include <algorithm>
-#include <chrono>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <filesystem>
-#include <numeric>
-#include <vector>
-
-#include "aare/ClusterFinder.hpp"
-#include "aare/ClusterFinderCUDA_old.hpp"
-#include "aare/File.hpp"
-#include "aare/Frame.hpp"
-#include "aare/NDArray.hpp"
-#include "aare/Pedestal.hpp"
-#include "aare/defs.hpp"
-#include "aare/utils/batch.hpp"
-
-// _____________
-//
-// Timing helper
-// _____________
-struct Timer {
-    using clock = std::chrono::high_resolution_clock;
-    clock::time_point t0;
-
-    void start() { t0 = clock::now(); }
-
-    double elapsed_ms() const {
-        return std::chrono::duration<double, std::milli>(clock::now() - t0)
-            .count();
-    }
-};
-
-// __________________
-//
-// Cluster comparison
-// __________________
-template <typename ClusterType> struct ClusterComparison {
-    size_t cpu_count = 0;
-    size_t gpu_count = 0;
-    size_t matched = 0;
-    size_t position_mismatch = 0;
-    size_t data_mismatch = 0;
-    size_t cpu_only = 0;
-    size_t gpu_only = 0;
-};
-
-// Sort clusters by (y, x) for deterministic comparison
-template <typename ClusterType>
-void sort_clusters(std::vector<ClusterType> &clusters) {
-    std::sort(clusters.begin(), clusters.end(),
-              [](const ClusterType &a, const ClusterType &b) {
-                  if (a.y != b.y)
-                      return a.y < b.y;
-                  return a.x < b.x;
-              });
-}
-
-// Compare two sorted cluster lists
-template <typename ClusterType>
-ClusterComparison<ClusterType>
-compare_clusters(std::vector<ClusterType> &cpu_clusters,
-                 std::vector<ClusterType> &gpu_clusters) {
-    sort_clusters(cpu_clusters);
-    sort_clusters(gpu_clusters);
-
-    ClusterComparison<ClusterType> result;
-    result.cpu_count = cpu_clusters.size();
-    result.gpu_count = gpu_clusters.size();
-
-    size_t ci = 0, gi = 0;
-    while (ci < cpu_clusters.size() && gi < gpu_clusters.size()) {
-        const auto &cc = cpu_clusters[ci];
-        const auto &gc = gpu_clusters[gi];
-
-        if (cc.y == gc.y && cc.x == gc.x) {
-            // Same position/check data
-            bool data_ok = true;
-            constexpr int N =
-                ClusterType::cluster_size_x * ClusterType::cluster_size_y;
-            for (int k = 0; k < N; ++k) {
-                // if (cc.data[k] != gc.data[k]) { // a bit too strict
-                // espacially that pedestal update is slightly different
-                if (std::abs(cc.data[k] - gc.data[k]) > 5) {
-                    data_ok = false;
-                    break;
-                }
-            }
-            if (data_ok)
-                result.matched++;
-            else
-                result.data_mismatch++;
-            ci++;
-            gi++;
-        } else if (cc.y < gc.y || (cc.y == gc.y && cc.x < gc.x)) {
-            result.cpu_only++;
-            ci++;
-        } else {
-            result.gpu_only++;
-            gi++;
-        }
-    }
-    result.cpu_only += (cpu_clusters.size() - ci);
-    result.gpu_only += (gpu_clusters.size() - gi);
-
-    return result;
-}
-
-// ________________
-//
-// Cluster printing
-// ________________
-template <typename ClusterType>
-void print_cluster_comparison(
-    const std::vector<std::vector<ClusterType>> &cpu_results,
-    const std::vector<std::vector<ClusterType>> &gpu_results,
-    size_t max_per_frame = 10, size_t max_frames = 100) {
-    constexpr int NX = ClusterType::cluster_size_x;
-    constexpr int NY = ClusterType::cluster_size_y;
-    constexpr int N = NX * NY;
-
-    size_t frames_shown = 0;
-    for (size_t fi = 0; fi < cpu_results.size() && frames_shown < max_frames;
-         ++fi) {
-        if (cpu_results[fi].empty() && gpu_results[fi].empty())
-            continue;
-
-        size_t n_cpu = cpu_results[fi].size();
-        size_t n_gpu = gpu_results[fi].size();
-        printf("\n  Frame %zu: CPU=%zu clusters, GPU=%zu clusters\n", fi, n_cpu,
-               n_gpu);
-
-        // Merge-walk over sorted lists (assumes already sorted by y,x)
-        size_t ci = 0, gi = 0;
-        size_t shown = 0;
-        while ((ci < n_cpu || gi < n_gpu) && shown < max_per_frame) {
-            bool have_cpu = ci < n_cpu;
-            bool have_gpu = gi < n_gpu;
-
-            // Determine if current entries match in position
-            bool same_pos = have_cpu && have_gpu &&
-                            cpu_results[fi][ci].x == gpu_results[fi][gi].x &&
-                            cpu_results[fi][ci].y == gpu_results[fi][gi].y;
-
-            if (same_pos) {
-                const auto &cc = cpu_results[fi][ci];
-                const auto &gc = gpu_results[fi][gi];
-
-                // Check if data differs
-                bool differs = false;
-                for (int k = 0; k < N; ++k) {
-                    if (cc.data[k] != gc.data[k]) {
-                        differs = true;
-                        break;
-                    }
-                }
-
-                printf("    CPU and GPU clusters found at SAME position "
-                       "(col=%3d, row=%3d)\n %s\n",
-                       cc.x, cc.y, differs ? "DATA MISMATCH" : "MATCH");
-                printf("      CPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(cc.data[k]));
-                }
-                printf("]\n");
-                if (differs) {
-                    printf("      GPU: [");
-                    for (int k = 0; k < N; ++k) {
-                        if (k)
-                            printf(", ");
-                        printf("%6d", static_cast<int>(gc.data[k]));
-                    }
-                    printf("]\n");
-                    printf("     diff: [");
-                    for (int k = 0; k < N; ++k) {
-                        if (k)
-                            printf(", ");
-                        int d = static_cast<int>(gc.data[k]) -
-                                static_cast<int>(cc.data[k]);
-                        printf("%+6d", d);
-                    }
-                    printf("]\n");
-                }
-                ci++;
-                gi++;
-                shown++;
-            } else if (!have_gpu ||
-                       (have_cpu &&
-                        (cpu_results[fi][ci].y < gpu_results[fi][gi].y ||
-                         (cpu_results[fi][ci].y == gpu_results[fi][gi].y &&
-                          cpu_results[fi][ci].x < gpu_results[fi][gi].x)))) {
-                const auto &cc = cpu_results[fi][ci];
-                printf("    (%3d, %3d) CPU ONLY\n", cc.x, cc.y);
-                printf("      CPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(cc.data[k]));
-                }
-                printf("]\n");
-                ci++;
-                shown++;
-            } else {
-                const auto &gc = gpu_results[fi][gi];
-                printf("    (%3d, %3d) GPU ONLY\n", gc.x, gc.y);
-                printf("      GPU: [");
-                for (int k = 0; k < N; ++k) {
-                    if (k)
-                        printf(", ");
-                    printf("%6d", static_cast<int>(gc.data[k]));
-                }
-                printf("]\n");
-                gi++;
-                shown++;
-            }
-        }
-        frames_shown++;
-    }
-}
-
-// _________________________________________
-//
-// Helpers for the updated (CPU-parity) API
-// _________________________________________
-
-// Copy a ClusterVector into a std::vector<ClusterType> for downstream
-// comparison code that expects the latter.
-template <typename Finder, typename ClusterType>
-void drain_into(Finder &f, std::vector<ClusterType> &out) {
-    auto cv = f.steal_clusters(true);
-    out.clear();
-    out.reserve(cv.size());
-    for (size_t j = 0; j < cv.size(); ++j)
-        out.push_back(cv[j]);
-}
-
-// Feed a set of cached pedestal frames through any finder exposing the
-// CPU-style push_pedestal_frame(NDView) method. Works for both
-// ClusterFinder and ClusterFinderCUDA.
-template <typename Finder, typename FRAME_TYPE>
-void feed_pedestal(
-    Finder &f, const std::vector<aare::NDArray<FRAME_TYPE, 2>> &ped_frames) {
-    for (const auto &frame : ped_frames) {
-        f.push_pedestal_frame(frame.view());
-    }
-}
-
-// ____________
-//
-//     Main
-// ____________
-int main(int argc, char *argv[]) {
-
-    // Parse arguments
-    // const char *default_pedestal =
-    //     "/mnt/sls_det_storage/highZ_data/CZT_Vienna/Khalil/Calibration_CZT/"
-    //     "2025Sept_m694/Sn25300eV/500_us_voltage_40kV/"
-    //     "250922_CZTonly_Pedestal_Tp15C_tint_500_master_0.json";
-    const char *default_pedestal =
-        "/mnt/sls_det_storage/matterhorn_data/aare_test_data/Moench03new/"
-        "cu_half_speed_master_4.json";
-    // const char *default_data =
-    //     "/mnt/sls_det_storage/highZ_data/CZT_Vienna/Khalil/Calibration_CZT/"
-    //     "2025Sept_m694/Sn25300eV/500_us_voltage_40kV/"
-    //     "250922_CZTonly_Xray_Tp15C_tint_500_master_0.json";
-    const char *default_data =
-        "/mnt/sls_det_storage/matterhorn_data/aare_test_data/Moench03new/"
-        "cu_half_speed_master_4.json";
-
-    std::filesystem::path pedestal_path(argc > 1 ? argv[1] : default_pedestal);
-    std::filesystem::path data_path(argc > 2 ? argv[2] : default_data);
-
-    if (!std::filesystem::exists(pedestal_path)) {
-        fprintf(stderr, "Pedestal file not found: %s\n", pedestal_path.c_str());
-        return 1;
-    }
-    if (!std::filesystem::exists(data_path)) {
-        fprintf(stderr, "Data file not found: %s\n", data_path.c_str());
-        return 1;
-    }
-
-    // Defaults: Adjust depending on the test dataset used
-    size_t n_pedestal_frames = 1000;
-    size_t n_data_frames = 10000;
-    double nSigma = 5.0;
-
-    if (argc > 3)
-        n_pedestal_frames = std::atol(argv[3]);
-    if (argc > 4)
-        n_data_frames = std::atol(argv[4]);
-    if (argc > 5)
-        nSigma = std::atof(argv[5]);
-
-    // Detector geometry from master file
-    constexpr uint8_t cs_x = 3;
-    constexpr uint8_t cs_y = 3;
-    using ClusterType = aare::Cluster<int32_t, cs_x, cs_y>;
-    using FRAME_TYPE = uint16_t;
-    using PEDESTAL_TYPE = double;
-
-    // Read actual frame dimensions from the pedestal file
-    ssize_t ROWS, COLS;
-    {
-        aare::File probe(pedestal_path, "r");
-        auto first_frame = probe.read_frame();
-        ROWS = first_frame.rows();
-        COLS = first_frame.cols();
-    }
-
-    printf("=== Cluster Finder: CPU vs CUDA (OLD) ===\n");
-    printf("Detector:  %zu x %zu\n", ROWS, COLS);
-    printf("Cluster:   %d x %d\n", ClusterType::cluster_size_x,
-           ClusterType::cluster_size_y);
-    printf("nSigma:    %.1f\n", nSigma);
-
-    // =========================================================================
-    // Phase 1: Build pedestal from dark frames (sanity check only + frame
-    // cache)
-    // =========================================================================
-    //
-    // Neither ClusterFinder nor ClusterFinderCUDA needs an external Pedestal
-    // object; both build their own via push_pedestal_frame. We still read the
-    // pedestal file once, but cache the frames in memory so every subsequent
-    // finder can be fed without re-hitting disk. We also build a standalone
-    // Pedestal purely to print a sanity check.
-    // =========================================================================
-    printf("\n--- Phase 1: Pedestal accumulation (sanity check + cache) ---\n");
-
-    std::vector<aare::NDArray<FRAME_TYPE, 2>> pedestal_frames;
-    aare::Pedestal<PEDESTAL_TYPE> pedestal(ROWS, COLS, 1000);
-
-    {
-        aare::File ped_file(pedestal_path, "r");
-        size_t total_ped = ped_file.total_frames();
-        size_t use_ped =
-            (n_pedestal_frames == 0 || n_pedestal_frames > total_ped)
-                ? total_ped
-                : n_pedestal_frames;
-        printf("Pedestal frames: %zu / %zu\n", use_ped, total_ped);
-
-        pedestal_frames.reserve(use_ped);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_ped; ++i) {
-            auto frame = ped_file.read_frame();
-            auto view = frame.view<FRAME_TYPE>();
-
-            // Copy into a standalone NDArray that we can reuse as many times
-            // as we have finders to feed.
-            aare::NDArray<FRAME_TYPE, 2> arr({ROWS, COLS});
-            for (ssize_t r = 0; r < ROWS; ++r)
-                for (ssize_t c = 0; c < COLS; ++c)
-                    arr(r, c) = view(r, c);
-            pedestal_frames.push_back(std::move(arr));
-
-            pedestal.push_no_update(view);
-        }
-        pedestal.update_mean();
-
-        printf("Pedestal read+cached+built in %.1f ms\n", t.elapsed_ms());
-    }
-
-    printf("Pedestal mean[0,0] = %.2f, std[0,0] = %.4f\n", pedestal.mean(0, 0),
-           pedestal.std(0, 0));
-
-    // =========================================================================
-    // Phase 2: Read data frames
-    // =========================================================================
-    printf("\n--- Phase 2: Read data frames ---\n");
-
-    aare::File data_file(data_path, "r");
-    size_t total_data = data_file.total_frames();
-    size_t use_data = std::min(n_data_frames, total_data);
-    printf("Data frames: %zu / %zu\n", use_data, total_data);
-
-    // Pre-read all frames into memory to remove I/O from timing
-    std::vector<aare::NDArray<FRAME_TYPE, 2>> frames;
-    frames.reserve(use_data);
-    data_file.seek(n_pedestal_frames);
-    for (size_t i = 0; i < use_data; ++i) {
-        auto f = data_file.read_frame();
-        // Copy into NDArray for consistent access
-        aare::NDArray<FRAME_TYPE, 2> arr({ROWS, COLS});
-        auto view = f.view<FRAME_TYPE>();
-        for (size_t r = 0; r < ROWS; ++r)
-            for (size_t c = 0; c < COLS; ++c)
-                arr(r, c) = view(r, c);
-        frames.push_back(std::move(arr));
-    }
-    printf("Frames loaded into memory\n");
-
-    // =========================================================================
-    // Phase 3: Sequential (CPU) cluster finding
-    // =========================================================================
-    printf("\n--- Phase 3: CPU ClusterFinder ---\n");
-
-    std::vector<std::vector<ClusterType>> cpu_results(use_data);
-    size_t cpu_total_clusters = 0;
-
-    {
-        // Build a ClusterFinder with the same pedestal
-        aare::ClusterFinder<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cf(
-            {ROWS, COLS}, nSigma);
-
-        feed_pedestal(cf, pedestal_frames);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_data; ++i) {
-            cf.find_clusters(frames[i].view(), static_cast<uint64_t>(i));
-            drain_into(cf, cpu_results[i]);
-            cpu_total_clusters += cpu_results[i].size();
-        }
-
-        double cpu_time = t.elapsed_ms();
-        printf("CPU: %zu clusters in %.1f ms (%.2f ms/frame)\n",
-               cpu_total_clusters, cpu_time, cpu_time / use_data);
-    }
-
-    // =========================================================================
-    // Phase 4: CUDA cluster finding
-    // =========================================================================
-    //
-    // The API mirrors ClusterFinder: push_pedestal_frame to train, then
-    // find_clusters / steal_clusters for each frame. H2D transfer and kernel
-    // launch happen internally.
-    //
-    // Toggle between the single-stream and batched paths by swapping which
-    // block is enabled. They both write into gpu_results so only one at a
-    // time makes sense.
-    // =========================================================================
-    printf("\n--- Phase 4: CUDA ClusterFinder ---\n");
-
-    std::vector<std::vector<ClusterType>> gpu_results(use_data);
-    size_t gpu_total_clusters = 0;
-
-    // --- Single frame on a single CUDA stream ---
-    /*
-    {
-        aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cuda_cf(
-            {ROWS, COLS}, nSigma);
-
-        feed_pedestal(cuda_cf, pedestal_frames);
-
-        // Warmup: first CUDA call pays driver/context init overhead. The
-        // pedestal drifts slightly during this single frame, which is
-        // acceptable for timing purposes.
-        cuda_cf.find_clusters(frames[0].view(), 0);
-        cuda_cf.steal_clusters(true);
-
-        Timer t;
-        t.start();
-
-        for (size_t i = 0; i < use_data; ++i) {
-            cuda_cf.find_clusters(frames[i].view(), static_cast<uint64_t>(i));
-            drain_into(cuda_cf, gpu_results[i]);
-            gpu_total_clusters += gpu_results[i].size();
-        }
-
-        double gpu_time = t.elapsed_ms();
-        printf("GPU: %zu clusters in %.1f ms (%.2f ms/frame)\n",
-               gpu_total_clusters, gpu_time, gpu_time / use_data);
-    }
-    */
-
-    // --- Batched H2D + multi-stream (enable this block and disable the one
-    //     above to benchmark the batched path against the CPU results) ---
-    {
-        constexpr size_t BATCH_SIZE = 2000;
-        constexpr int N_STREAMS = 5;
-
-        aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cuda_cf(
-            {ROWS, COLS}, nSigma, 50'000, N_STREAMS);
-
-        feed_pedestal(cuda_cf, pedestal_frames);
-
-        // Contiguous staging buffer reused across batches
-        std::vector<FRAME_TYPE> batch_buffer(BATCH_SIZE * ROWS * COLS);
-
-        const size_t n_batches = (use_data + BATCH_SIZE - 1) / BATCH_SIZE;
-
-        double pack_ms = 0.0, gpu_ms = 0.0;
-        Timer t;
-
-        for (size_t bi = 0; bi < n_batches; ++bi) {
-            const size_t offset = bi * BATCH_SIZE;
-            const size_t actual_batch = std::min(BATCH_SIZE, use_data - offset);
-
-            t.start();
-            pack_frame_batch(frames, offset, actual_batch, batch_buffer);
-            pack_ms += t.elapsed_ms();
-
-            aare::NDView<FRAME_TYPE, 3> batch_view(
-                batch_buffer.data(),
-                {static_cast<ssize_t>(actual_batch), ROWS, COLS});
-
-            t.start();
-            auto batch_results =
-                cuda_cf.find_clusters_batched(batch_view, offset);
-            gpu_ms += t.elapsed_ms();
-
-            for (size_t f = 0; f < actual_batch; ++f) {
-                auto &cv = batch_results[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();
-            }
-        }
-
-        printf("GPU(batched): %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
-    // =========================================================================
-    printf("\n--- Phase 5: Comparison ---\n");
-
-    size_t total_matched = 0;
-    size_t total_data_mismatch = 0;
-    size_t total_cpu_only = 0;
-    size_t total_gpu_only = 0;
-    size_t frames_with_differences = 0;
-
-    for (size_t i = 0; i < use_data; ++i) {
-        auto result = compare_clusters(cpu_results[i], gpu_results[i]);
-
-        total_matched += result.matched;
-        total_data_mismatch += result.data_mismatch;
-        total_cpu_only += result.cpu_only;
-        total_gpu_only += result.gpu_only;
-
-        bool has_diff = (result.cpu_only > 0 || result.gpu_only > 0 ||
-                         result.data_mismatch > 0);
-        if (has_diff) {
-            frames_with_differences++;
-            // Print details for first few mismatching frames
-            if (frames_with_differences <= 5) {
-                printf("  Frame %zu: CPU=%zu GPU=%zu matched=%zu "
-                       "data_mismatch=%zu cpu_only=%zu gpu_only=%zu\n",
-                       i, result.cpu_count, result.gpu_count, result.matched,
-                       result.data_mismatch, result.cpu_only, result.gpu_only);
-            }
-        }
-    }
-
-    printf("\nSummary over %zu frames:\n", use_data);
-    printf("  CPU total clusters:    %zu\n", cpu_total_clusters);
-    printf("  GPU total clusters:    %zu\n", gpu_total_clusters);
-    printf("  Matched:               %zu\n", total_matched);
-    printf("  Data mismatch:         %zu\n", total_data_mismatch);
-    printf("  CPU only:              %zu\n", total_cpu_only);
-    printf("  GPU only:              %zu\n", total_gpu_only);
-    printf("  Frames with diffs:     %zu / %zu\n", frames_with_differences,
-           use_data);
-
-    if (total_cpu_only == 0 && total_gpu_only == 0 &&
-        total_data_mismatch == 0) {
-        printf("\n*** PASS: CPU and GPU results match exactly ***\n");
-    } else {
-        printf("\n*** DIFFERENCES DETECTED ***\n");
-    }
-
-    // // Print detailed cluster comparison (side-by-side with diffs)
-    // if (cpu_total_clusters > 0 || gpu_total_clusters > 0) {
-    //     size_t max_clusters_per_frame = 10;
-    //     size_t max_frames = 100;
-    //     printf("\n--- Cluster details (up to %zu frames, %zu clusters each)
-    //     ---\n", max_frames, max_clusters_per_frame);
-    //     print_cluster_comparison(cpu_results, gpu_results,
-    //     max_clusters_per_frame, max_frames);
-    // }
-
-    // =========================================================================
-    // Phase 6: Per-frame timing benchmark
-    // =========================================================================
-    printf("\n--- Phase 6: Detailed timing (%d iterations) ---\n", 10000);
-
-    if (use_data > 0) {
-        const int N_ITER = 10000;
-        const auto &bench_frame = frames[0];
-
-        // CPU benchmark
-        {
-            aare::ClusterFinder<ClusterType, FRAME_TYPE, PEDESTAL_TYPE> cf(
-                {ROWS, COLS}, nSigma);
-
-            // Load pedestal
-            feed_pedestal(cf, pedestal_frames);
-
-            // Warmup
-            cf.find_clusters(bench_frame.view(), 0);
-            cf.steal_clusters(true);
-
-            Timer t;
-            t.start();
-            for (int iter = 0; iter < N_ITER; ++iter) {
-                cf.find_clusters(bench_frame.view(), 0);
-                cf.steal_clusters(true);
-            }
-            double cpu_per_frame = t.elapsed_ms() / N_ITER;
-            printf("CPU: %.3f ms/frame\n", cpu_per_frame);
-        }
-        // --- GPU benchmark (single frame, single stream) ---
-        {
-            aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>
-                cuda_cf({ROWS, COLS}, nSigma);
-            feed_pedestal(cuda_cf, pedestal_frames);
-
-            // Warmup
-            cuda_cf.find_clusters(bench_frame.view(), 0);
-            cuda_cf.steal_clusters(true);
-
-            Timer t;
-            t.start();
-            for (int iter = 0; iter < N_ITER; ++iter) {
-                cuda_cf.find_clusters(bench_frame.view(), 0);
-                cuda_cf.steal_clusters(true);
-            }
-            printf("GPU:          %.3f ms/frame (H2D + kernel + D2H, single "
-                   "frame, single stream)\n",
-                   t.elapsed_ms() / N_ITER);
-        }
-
-        // --- GPU benchmark (batched + multi-streamed) ---
-        {
-            constexpr size_t BATCH_SIZE = 2000;
-            constexpr int N_STREAMS = 5;
-
-            aare::ClusterFinderCUDA<ClusterType, FRAME_TYPE, PEDESTAL_TYPE>
-                cuda_cf({ROWS, COLS}, nSigma, 50'000, N_STREAMS);
-            feed_pedestal(cuda_cf, pedestal_frames);
-
-            // Build one contiguous batch of BATCH_SIZE copies of bench_frame
-            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));
-
-            aare::NDView<FRAME_TYPE, 3> batch_view(
-                batch.data(), {static_cast<ssize_t>(BATCH_SIZE), ROWS, COLS});
-
-            // Warmup. The kernel mutates the device-side pedestal for every
-            // non-photon pixel, so after a 500-frame warmup the pedestal
-            // state has drifted. Reset to a clean baseline by clearing the
-            // host pedestal and re-feeding the cached frames; this also
-            // re-arms the dirty flag so the next find_clusters re-uploads.
-            (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();
-            for (size_t b = 0; b < n_iter_batches; ++b) {
-                (void)cuda_cf.find_clusters_batched(batch_view, b * BATCH_SIZE);
-            }
-            printf("GPU(batched): %.3f ms/frame (H2D + kernel + D2H, "
-                   "batch=%zu, streams=%d)\n",
-                   t.elapsed_ms() / (n_iter_batches * BATCH_SIZE), BATCH_SIZE,
-                   N_STREAMS);
-        }
-    }
-
-    printf("\nDone.\n");
-    return 0;
-}
\ No newline at end of file
diff --git a/src/Makefile b/src/Makefile
deleted file mode 100644
index 580bf0fd..00000000
--- a/src/Makefile
+++ /dev/null
@@ -1,31 +0,0 @@
-CXX      := /usr/bin/c++
-NVCC     := nvcc
-ARCH     := -arch=sm_89 
-CXXFLAGS := -std=c++17 -O3 --extended-lambda -ccbin $(CXX)
-INCLUDES := -I../include -I../build/_deps/fmt-src/include
-LDFLAGS  := -L../build -L../build/_deps/fmt-build
-LIBS     := -laare_core -lfmt -lstdc++fs
-DEFINES  := -DAARE_LOG_LEVEL=logERROR
-
-TARGET_OLD  := test_cf_cuda_old
-TARGET   	:= test_cf_cuda_asyncpipeline
-
-SRC_OLD  := ClusterFinderCUDA_old.test.cu 
-SRC      := ClusterFinderCUDA.test.cu 
-
-DEP      := $(SRC:.cu=.d) $(SRC_OLD:.cu=.d)
-
-all: $(TARGET) $(TARGET_OLD)
-
-$(TARGET): $(SRC) ../include/aare/clusterfinder_kernel.cuh
-	$(NVCC) -Xptxas=-v $(ARCH) $(CXXFLAGS) $(DEFINES) $(INCLUDES) $(LDFLAGS) $< -o $@ $(LIBS)
-
-$(TARGET_OLD): $(SRC_OLD) ../include/aare/clusterfinder_kernel.cuh
-	$(NVCC) -Xptxas=-v $(ARCH) $(CXXFLAGS) $(DEFINES) $(INCLUDES) $(LDFLAGS) $< -o $@ $(LIBS)
-
-clean:
-	rm -f $(TARGET) $(TARGET_OLD) $(DEP)
-
--include $(DEP)
-
-.PHONY: all clean
\ No newline at end of file