From 8ad44b32a82cd6e52ad6ec17bd8b5917ec037582 Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Wed, 13 May 2026 18:52:25 +0200
Subject: [PATCH 01/20] Feat: add parameters align_w_parent_only, tree, and
 root_view for global view fitting

---
 src/pyRATS/_utils.py | 126 ++++++++++++++++++++++++++++++++++++++++---
 src/pyRATS/rats.py   |  24 +++++++++
 2 files changed, 143 insertions(+), 7 deletions(-)

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index d86aae3..32bc6b8 100644
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -3,7 +3,7 @@
 from scipy.linalg import svd, svdvals
 from scipy.sparse.linalg import svds
 from sklearn.decomposition import KernelPCA
-from scipy.sparse import csr_matrix, triu
+from scipy.sparse import csr_matrix, triu, issparse
 import itertools
 
 from joblib import delayed, Parallel
@@ -20,6 +20,8 @@
     minimum_spanning_tree,
     connected_components,
     breadth_first_order,
+    dijkstra,
+    shortest_path,
 )
 
 
@@ -808,9 +810,12 @@ def target_proc(p_num, chunk_sz, n_, Utilde, n_C, c, S):
 def compute_seq_of_views(
     d,  # embedding dimension
     i_mat,  # incidence matrix |#views| x |#points|
+    n_C,
     overlap,  # size of overlap between views |#views| x |#views|
     param,  # d-dimensional parameterization of points in each view
     n_forced_clusters,
+    tree,
+    root_view,
     verbose,
     n_jobs,
 ):
@@ -824,6 +829,8 @@ def compute_seq_of_views(
     i_mat : sparse-matrix, shape (n_samples, n_intermed_views)
         Incidence matrix
 
+    n_C :
+
     overlap : sparse-matrix, shape (n_intermed_views, n_intermed_views)
         Size of overlap between intermediate views
 
@@ -833,6 +840,10 @@ def compute_seq_of_views(
     n_forced_clusters : int
         Minimum no. of clusters to force in the embeddings.
 
+    tree : str
+
+    root_view : str
+
     verbose : bool
         If True, print logs to stdout.
 
@@ -941,10 +952,36 @@ def target_proc(p_num):
         W_ = W[views_in_this_comp, :][:, views_in_this_comp].copy()
         if n_views_in_this_comp > 1:
             # Compute maximum spanning tree/forest of W
-            T = minimum_spanning_tree(-W_)
+            if tree == "spt":
+                _, min_max = compute_farthest_points(
+                    W_ > 0, n_points=100, return_min_max=True
+                )
+                W_.data = 1 / W_.data
+                _, pred = shortest_path(
+                    W_, return_predecessors=True, directed=False, indices=[min_max]
+                )
+                pred = pred[0, :]
+                row = []
+                col = []
+                data = []
+
+                for child, parent in enumerate(pred):
+                    if parent >= 0:
+                        row.append(parent)
+                        col.append(child)
+                        data.append(1)
+
+                T = csr_matrix(
+                    (data, (row, col)),
+                    shape=(n_views_in_this_comp, n_views_in_this_comp),
+                )
+            else:
+                T = minimum_spanning_tree(-W_)
 
-            # center_i = np.argmax(n_C[views_in_this_comp])
-            center_i = center_of_tree(T)
+            if root_view == "center":
+                center_i = center_of_tree(T)
+            else:
+                center_i = np.argmax(n_C[views_in_this_comp])
 
             seq, rho_ = breadth_first_order(
                 T, center_i, directed=False
@@ -965,6 +1002,34 @@ def target_proc(p_num):
     return seq_of_views_in_cluster, parents_of_views_in_cluster, cluster_of_view
 
 
+def compute_farthest_points(nbrhd_graph, s=0, n_points=20, return_min_max=False):
+    if issparse(nbrhd_graph):
+        d_e = nbrhd_graph
+    else:
+        d_e = nbrhd_graph.sparse_matrix()
+    far_off_points = [s]
+    dist_from_far_off_points = np.zeros(d_e.shape[0]) + np.inf
+    if return_min_max:
+        min_max_dist = np.inf
+        min_max = None
+    while len(far_off_points) < n_points:
+        temp = dijkstra(d_e, directed=False, indices=far_off_points[-1])
+        if return_min_max:
+            max_dist = np.max(temp)
+            if min_max_dist > max_dist:
+                min_max_dist = max_dist
+                min_max = far_off_points[-1]
+        dist_from_far_off_points = np.minimum(dist_from_far_off_points, temp)
+        non_inf_indices = np.where(~np.isinf(dist_from_far_off_points))[0]
+        far_off_points.append(
+            non_inf_indices[np.argmax(dist_from_far_off_points[non_inf_indices])]
+        )
+    if return_min_max:
+        return np.array(far_off_points), min_max
+    else:
+        return np.array(far_off_points)
+
+
 def center_of_tree(T):
     """Compute the center node of a tree T"""
 
@@ -986,6 +1051,9 @@ def compute_init_embedding(
     seq_of_intermed_views_in_cluster,
     parents_of_intermed_views_in_cluster,
     C,
+    to_tear,
+    align_w_parent_only,
+    n_Utilde_Utilde,
     verbose,
 ):
     """Initial alignment of datapoints in embedding via Procrustes alignment.
@@ -1001,6 +1069,12 @@ def compute_init_embedding(
 
     C : sparse-matrix, shape (n_samples, n_samples)
 
+    to_tear : bool
+
+    align_w_parent_only : bool
+
+    n_Utilde_Utilde : array-like
+
     verbose : bool
         If True, print logs to stdout.
 
@@ -1032,7 +1106,17 @@ def compute_init_embedding(
             {"view_index": seq_0, "data_mask": C[seq_0, :].indices}
         )
         y, is_visited_view = procrustes_init(
-            seq, rho, y, is_visited_view, d, Utilde, C, param
+            seq,
+            rho,
+            y,
+            is_visited_view,
+            d,
+            Utilde,
+            C,
+            param,
+            to_tear,
+            align_w_parent_only,
+            n_Utilde_Utilde,
         )
 
     if verbose:
@@ -1432,7 +1516,19 @@ def procrustes(A, B):
     return T, v
 
 
-def procrustes_init(seq, rho, y, is_visited_view, d, Utilde, C, param):
+def procrustes_init(
+    seq,
+    rho,
+    y,
+    is_visited_view,
+    d,
+    Utilde,
+    C,
+    param,
+    to_tear,
+    align_w_parent_only,
+    n_Utilde_Utilde,
+):
     n = Utilde.shape[1]
     # Traverse views from 2nd view
     for m in range(1, seq.shape[0]):
@@ -1441,7 +1537,23 @@ def procrustes_init(seq, rho, y, is_visited_view, d, Utilde, C, param):
         p = rho[s]
         Utilde_s = Utilde[s, :]
 
-        Z_s = [p]
+        if to_tear:
+            if align_w_parent_only:
+                Z_s = [p]
+            else:
+                raise RuntimeError("align_w_parent_only=False is not implemented")
+        else:
+            if align_w_parent_only:
+                Z_s = [p]
+            else:
+                # Align sth view with all the views which have
+                # an overlap with sth view in the ambient space
+                Z_s = n_Utilde_Utilde[s, :].multiply(is_visited_view)
+                Z_s = Z_s.nonzero()[1].tolist()
+                # If for some reason Z_s is empty
+                if len(Z_s) == 0:
+                    Z_s = [p]
+
         # Compute centroid mu_s
         # n_Utilde_s_Z_s[k] = #views in Z_s which contain
         # kth point if kth point is in the sth view, else zero
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 78c7063..a04eca9 100644
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -55,6 +55,18 @@ class RATS:
     nu : int, default=3
         The ratio of the size of local views in the embedding against those in the data.
 
+    align_w_parent_only : bool, default=True
+        If True, then aligns child views the parent views only
+        in the spanning-tree-based-procrustes alignment.
+
+    tree : str, default='mst'
+        Type of spanning tree to use. Options are: spt, mst (default).
+
+    root_view : str, default='center'
+        Options are: ['center', 'largest']
+        If 'center' then uses center of spanning tree as root view
+        otherwise uses the view associated with largest cluster.
+
     max_iter : int
         Number of iterations to refine the global embedding.
         In total Riemannian gradient descent is run for max_iter * max_internal_iter iterations.
@@ -103,6 +115,9 @@ def __init__(
         eta_max=25,
         to_tear=True,
         nu=3,
+        align_w_parent_only=True,
+        tree="mst",
+        root_view="center",
         max_iter=20,
         max_internal_iter=100,
         alpha=0.3,
@@ -132,6 +147,9 @@ def __init__(
         self.eta_min, self.eta_max = eta_min, eta_max
         self.to_tear = to_tear
         self.nu = nu
+        self.align_w_parent_only = align_w_parent_only
+        self.tree = tree
+        self.root_view = root_view
         self.max_iter, self.max_internal_iter = max_iter, max_internal_iter
         self.alpha, self.eps = alpha, eps
         self.patience, self.tol = patience, tol
@@ -383,9 +401,12 @@ def _fit_global_views(self, c, n_C):
             compute_seq_of_views(
                 self.d,
                 self.Utilde,
+                n_C,
                 n_Utilde_Utilde,
                 self.param,
                 self.n_forced_clusters,
+                self.tree,
+                self.root_view,
                 self.verbose,
                 self.n_jobs,
             )
@@ -399,6 +420,9 @@ def _fit_global_views(self, c, n_C):
             seq_of_intermed_views_in_cluster,
             parents_of_intermed_views_in_cluster,
             self.C,
+            self.to_tear,
+            self.align_w_parent_only,
+            self.n_Utilde_Utilde,
             self.verbose,
         )
 

From 3dc7a70c99692346191e7e2aec77475464cb1084 Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Mon, 8 Jun 2026 08:49:33 +0200
Subject: [PATCH 02/20] feat: add spacing between distinct clusters + return
 corresponding cluster labels

---
 src/pyRATS/_utils.py | 28 +++++++++++++++++++++++++++-
 src/pyRATS/rats.py   | 13 ++++++++++---
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index 20114b5..5ca76f6 100644
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -1789,7 +1789,33 @@ def procrustes_init(
     return y, is_visited_view
 
 
-
+def add_spacing_between_clusters(y, seq_of_intermed_views_in_cluster, param, C):
+    n_clusters = len(seq_of_intermed_views_in_cluster)
+    if n_clusters == 1:
+        return
+    
+    M,n = C.shape
+        
+    # arrange connected components nicely
+    # spaced on horizontal (x) axis
+    offset = 0
+    cluster_label = np.zeros(y.shape[0], dtype=int)-1
+    for i in range(n_clusters):
+        seq = seq_of_intermed_views_in_cluster[i]
+        pts_in_cluster_i = np.where(C[seq,:].sum(axis=0))[1]
+        cluster_label[pts_in_cluster_i] = i
+        # make the x coordinate of the leftmost point
+        # of the ith cluster to be equal to the offset
+        if i > 0:
+            offset_ = np.min(y[pts_in_cluster_i,0])
+            param.v[seq,0] += offset - offset_
+            y[pts_in_cluster_i,0] += offset - offset_
+        
+        # recompute the offset as the x coordinate of
+        # rightmost point of the current cluster
+        offset = 1.25*np.max(y[pts_in_cluster_i,0])
+    
+    return cluster_label
 
 
 class Param:
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 5ad246d..733e22a 100644
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -16,6 +16,7 @@
     compute_init_embedding,
     compute_final_embedding,
     batched_pdist,
+    add_spacing_between_clusters,
 )
 from pyRATS._tear_coloring import compute_color_of_pts_on_tear
 
@@ -322,8 +323,9 @@ def fit_transform(self, X):
         # Construct Global views
         if self.verbose:
             print(f"[{current_step}/{n_steps}] Aligning global views...")
-        y = self._fit_global_views(c, n_C)
-
+        y, labels = self._fit_global_views(c, n_C)
+        if labels is not None:
+            return y, labels
         return y
 
     def compute_color_of_pts_on_tear(self, y, tear_color_eig_inds=[0, 1, 2]):
@@ -620,9 +622,14 @@ def _fit_global_views(self, c, n_C):
             self.alpha,
             self.verbose,
         )
+
+        labels = add_spacing_between_clusters(
+            y_final, seq_of_intermed_views_in_cluster, self.param, self.C
+        )
+
         self.Utildeg = Utildeg
 
-        return y_final
+        return y_final, labels
 
     def _postprocess(self):
         """Replace high local distortion incuring parameterizations by those of neighboring points."""

From a5db1b510c3a6b438ec71b09d49676d58c65db5b Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Mon, 8 Jun 2026 09:02:19 +0200
Subject: [PATCH 03/20] feat: induce connections when condition_num is provided

---
 src/pyRATS/_utils.py | 24 ++++++++++++++++++++++++
 src/pyRATS/rats.py   | 20 +++++++++++++++-----
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index 5ca76f6..257694a 100644
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -472,6 +472,30 @@ def nearest_neighbors(X, k, metric, sort_results=True, n_jobs=-1):
     return neigh_dist, neigh_ind
 
 
+def induce_connections(X, metric, condition_num, neigh_ind, neigh_dist, k_nn0):
+        d_e = squareform(pdist(X, metric=metric))
+        neigh_ind_ = np.zeros_like(neigh_ind)
+        neigh_dist_ = np.zeros_like(neigh_dist)
+        uniq_cond_nums = np.unique(condition_num)
+        for i in range(uniq_cond_nums.shape[0]):
+            print('Processing condition number:', i, flush=True)
+            cond_num_i = uniq_cond_nums[i]
+            mask = condition_num == cond_num_i
+            inds = np.where(mask)[0]
+            d_e_ = d_e.copy()
+            d_e_[np.ix_(mask,mask)] = np.inf
+            for k in inds.tolist():
+                d_e_[k,neigh_ind[k,:]] = np.inf
+                neigh_ind_[k,:] = np.argpartition(d_e_[k,:], k_nn0)[:k_nn0]
+                neigh_dist_[k,:] = d_e_[k,neigh_ind_[k,:]]
+        
+        return (
+            np.concatenate([neigh_dist, neigh_dist_], axis=1),
+            np.concatenate([neigh_ind, neigh_ind_], axis=1),
+            k_nn0 * 2,
+        )
+
+
 def cost_of_moving_distortion(
     k, d_e, neigh_ind_k, U_k, local_param, c, n_C, Utilde, eta_min, eta_max, n_jobs=1
 ):
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 733e22a..361018f 100644
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -17,6 +17,7 @@
     compute_final_embedding,
     batched_pdist,
     add_spacing_between_clusters,
+    induce_connections,
 )
 from pyRATS._tear_coloring import compute_color_of_pts_on_tear
 
@@ -95,8 +96,7 @@ class RATS:
         relative change in the size of the tear.
 
     metric : str, default='euclidean'
-        To be added in future releases. Metric assumed on the embedding.
-        Currently only 'euclidean' is supported.
+        Metric assumed on the embedding. 
 
     fit_inverse_transform : bool, default=False
         To be added in future releases. If True, computes the inverse of the embedding
@@ -281,7 +281,7 @@ def __init__(
             )
             self.n_jobs = cores
 
-    def fit_transform(self, X):
+    def fit_transform(self, X, condition_num=None):
         """Fit the model on the data in X, and transform X.
 
         Parameters
@@ -289,6 +289,8 @@ def fit_transform(self, X):
         X : array-like, shape (n_samples, n_features)
             Sample data, in the form of a numpy array of shape (n_samples, n_features).
 
+        condition_num : 
+
         Returns
         -------
         y : array-like, shape (n_samples, d)
@@ -299,7 +301,7 @@ def fit_transform(self, X):
 
         if self.verbose:
             print(f"[{current_step}/{n_steps}] Fitting neighborhood graph...")
-        self._fit_nbrhd_graph(X)
+        self._fit_nbrhd_graph(X, condition_num)
         current_step += 1
 
         # Construct low dimensional local views
@@ -414,7 +416,7 @@ def inverse_transform(self, y):
         )
 
 
-    def _fit_nbrhd_graph(self, X, sort_results=True):
+    def _fit_nbrhd_graph(self, X, condition_num=None, sort_results=True):
         """Fitting the neighborhood graph.
 
         Parameters
@@ -422,6 +424,8 @@ def _fit_nbrhd_graph(self, X, sort_results=True):
         X : array shape (n_samples, n_features)
             A 2d array containing data representing a manifold.
 
+        condition_num : 
+
         sort_results: bool, default=True
             If True, sorts neighbors by index in ascending order for deterministic behavior.
 
@@ -431,6 +435,12 @@ def _fit_nbrhd_graph(self, X, sort_results=True):
             X, self.k_nn0, self.metric, sort_results, self.n_jobs
         )
 
+        if condition_num is not None:
+            self.neigh_dist, self.neigh_ind, self.k_nn0 = induce_connections(
+                X, self.metric, condition_num, self.neigh_ind, self.neigh_dist, self.k_nn0,
+            )
+            self.k = self.k_nn0
+
         self.U = sparse_matrix(  # needed for distortion cost_fn
             self.neigh_ind[:, : self.k], np.ones((len(X), self.k), dtype=bool)
         )

From 480b07a6972c51d6bfb2a34e44bd1249e8daef2d Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Mon, 8 Jun 2026 10:28:07 +0200
Subject: [PATCH 04/20] fix: resolve minor issues after merge

---
 src/pyRATS/_utils.py | 1 -
 src/pyRATS/rats.py   | 8 ++++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index 257694a..1c65546 100644
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -478,7 +478,6 @@ def induce_connections(X, metric, condition_num, neigh_ind, neigh_dist, k_nn0):
         neigh_dist_ = np.zeros_like(neigh_dist)
         uniq_cond_nums = np.unique(condition_num)
         for i in range(uniq_cond_nums.shape[0]):
-            print('Processing condition number:', i, flush=True)
             cond_num_i = uniq_cond_nums[i]
             mask = condition_num == cond_num_i
             inds = np.where(mask)[0]
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 361018f..c7e8c62 100644
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -143,8 +143,8 @@ def __init__(
         align_w_parent_only=True,
         tree="mst",
         root_view="center",
-        max_iter=20,
-        max_internal_iter=100,
+        n_iter=20,
+        n_iter_inner=100,
         alpha=0.3,
         eps=1e-8,
         n_iter_without_progress=5,
@@ -258,7 +258,7 @@ def __init__(
         self.align_w_parent_only = align_w_parent_only
         self.tree = tree
         self.root_view = root_view
-        self.max_iter, self.max_internal_iter = max_iter, max_internal_iter
+        self.max_iter, self.max_internal_iter = n_iter, n_iter_inner
         self.alpha, self.eps = alpha, eps
         self.patience, self.tol = n_iter_without_progress, tol
         self.metric = metric
@@ -359,7 +359,7 @@ def compute_color_of_pts_on_tear(self, y, tear_color_eig_inds=[0, 1, 2]):
             tear_color_eig_inds,
             self.k,
             self.nu,
-            self.metric,
+            'euclidean',
             self.verbose,
             self.n_jobs,
             self.Utildeg,

From da0fb5458c7f21d704a0b9e2f1122932d551a2fc Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Mon, 8 Jun 2026 21:39:26 +0200
Subject: [PATCH 05/20] feat: add repel arguments + option 'spectral' for
 global view fitting

---
 src/pyRATS/_utils.py | 488 ++++++++++++++++++++++++++++++++-----------
 src/pyRATS/rats.py   |  55 +++--
 2 files changed, 403 insertions(+), 140 deletions(-)
 mode change 100644 => 100755 src/pyRATS/_utils.py
 mode change 100644 => 100755 src/pyRATS/rats.py

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
old mode 100644
new mode 100755
index 1c65546..a19e450
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -9,6 +9,7 @@
 from joblib import delayed, Parallel, parallel_backend
 import multiprocess as mp_lib
 
+import scipy
 from scipy.spatial.distance import pdist, squareform
 from sklearn.utils.extmath import svd_flip
 from scipy.sparse.csgraph import (
@@ -39,8 +40,10 @@ def _cgroup_available_bytes():
         return None
     pairs = (
         ("/sys/fs/cgroup/memory.max", "/sys/fs/cgroup/memory.current"),
-        ("/sys/fs/cgroup/memory/memory.limit_in_bytes",
-         "/sys/fs/cgroup/memory/memory.usage_in_bytes"),
+        (
+            "/sys/fs/cgroup/memory/memory.limit_in_bytes",
+            "/sys/fs/cgroup/memory/memory.usage_in_bytes",
+        ),
     )
     for max_path, cur_path in pairs:
         try:
@@ -86,6 +89,7 @@ def _available_memory_bytes():
 
     try:
         import psutil
+
         avail = int(psutil.virtual_memory().available * 0.75)
     except (ImportError, AttributeError):
         avail = _FALLBACK_MEMORY
@@ -203,14 +207,20 @@ def target_proc(p_num, chunk_sz):
         return start_ind, end_ind, Psi, mu, var_explained, n_pc_dir_chosen
 
     chunk_sz = int(n / n_jobs)
-    if n_jobs == 1 or n < 1000: # Threshold for Parallel overhead
+    if n_jobs == 1 or n < 1000:  # Threshold for Parallel overhead
         results = [target_proc(0, n)]
     else:
-        with parallel_backend("loky", inner_max_num_threads=_inner_blas_threads(n_jobs)):
+        with parallel_backend(
+            "loky", inner_max_num_threads=_inner_blas_threads(n_jobs)
+        ):
             results = Parallel(n_jobs=n_jobs)(
                 delayed(target_proc)(i, chunk_sz)
                 for i in tqdm(
-                    range(n_jobs), desc="PCA", unit="chunk", leave=False, disable=not verbose
+                    range(n_jobs),
+                    desc="PCA",
+                    unit="chunk",
+                    leave=False,
+                    disable=not verbose,
                 )
             )
 
@@ -295,7 +305,11 @@ def target_proc(p_num, chunk_sz):
         results = Parallel(n_jobs=n_jobs)(
             delayed(target_proc)(p_num, chunk_sz)
             for p_num in tqdm(
-                range(n_jobs), desc="KPCA", unit="chunk", leave=False, disable=not verbose
+                range(n_jobs),
+                desc="KPCA",
+                unit="chunk",
+                leave=False,
+                disable=not verbose,
             )
         )
 
@@ -357,9 +371,9 @@ def batched_pdist(x):
 
     n, k, _ = x.shape
     # Precompute all upper-triangle pair indices (same order as the original loop)
-    pair_i, pair_j = np.triu_indices(k, k=1)          # each shape (num_pairs,)
-    diff = x[:, pair_i, :] - x[:, pair_j, :]          # (n, num_pairs, d)
-    return np.sqrt(np.sum(diff * diff, axis=-1))        # (n, num_pairs)
+    pair_i, pair_j = np.triu_indices(k, k=1)  # each shape (num_pairs,)
+    diff = x[:, pair_i, :] - x[:, pair_j, :]  # (n, num_pairs, d)
+    return np.sqrt(np.sum(diff * diff, axis=-1))  # (n, num_pairs)
 
 
 def batched_procrustes_cost(X, Y):
@@ -473,26 +487,26 @@ def nearest_neighbors(X, k, metric, sort_results=True, n_jobs=-1):
 
 
 def induce_connections(X, metric, condition_num, neigh_ind, neigh_dist, k_nn0):
-        d_e = squareform(pdist(X, metric=metric))
-        neigh_ind_ = np.zeros_like(neigh_ind)
-        neigh_dist_ = np.zeros_like(neigh_dist)
-        uniq_cond_nums = np.unique(condition_num)
-        for i in range(uniq_cond_nums.shape[0]):
-            cond_num_i = uniq_cond_nums[i]
-            mask = condition_num == cond_num_i
-            inds = np.where(mask)[0]
-            d_e_ = d_e.copy()
-            d_e_[np.ix_(mask,mask)] = np.inf
-            for k in inds.tolist():
-                d_e_[k,neigh_ind[k,:]] = np.inf
-                neigh_ind_[k,:] = np.argpartition(d_e_[k,:], k_nn0)[:k_nn0]
-                neigh_dist_[k,:] = d_e_[k,neigh_ind_[k,:]]
-        
-        return (
-            np.concatenate([neigh_dist, neigh_dist_], axis=1),
-            np.concatenate([neigh_ind, neigh_ind_], axis=1),
-            k_nn0 * 2,
-        )
+    d_e = squareform(pdist(X, metric=metric))
+    neigh_ind_ = np.zeros_like(neigh_ind)
+    neigh_dist_ = np.zeros_like(neigh_dist)
+    uniq_cond_nums = np.unique(condition_num)
+    for i in range(uniq_cond_nums.shape[0]):
+        cond_num_i = uniq_cond_nums[i]
+        mask = condition_num == cond_num_i
+        inds = np.where(mask)[0]
+        d_e_ = d_e.copy()
+        d_e_[np.ix_(mask, mask)] = np.inf
+        for k in inds.tolist():
+            d_e_[k, neigh_ind[k, :]] = np.inf
+            neigh_ind_[k, :] = np.argpartition(d_e_[k, :], k_nn0)[:k_nn0]
+            neigh_dist_[k, :] = d_e_[k, neigh_ind_[k, :]]
+
+    return (
+        np.concatenate([neigh_dist, neigh_dist_], axis=1),
+        np.concatenate([neigh_ind, neigh_ind_], axis=1),
+        k_nn0 * 2,
+    )
 
 
 def cost_of_moving_distortion(
@@ -612,7 +626,7 @@ def cost_of_moving_distortion(
 
 def compute_zeta(d_e_mask0, Psi_k_mask):
     """Computes the local distortion zeta for a given parameterization and neighborhood distances.
-    
+
     Parameters
     ----------
     d_e_mask0 : sparse matrix or array-like
@@ -625,16 +639,16 @@ def compute_zeta(d_e_mask0, Psi_k_mask):
     d_e_mask = d_e_mask0.toarray() if hasattr(d_e_mask0, "toarray") else d_e_mask0
     if d_e_mask.shape[0] <= 1:
         return 1
-    
+
     # Use squareform/pdist for efficient pair extraction on small dense matrices
     d_e_mask_ = squareform(d_e_mask)
     mask = d_e_mask_ != 0
     if not np.any(mask):
         return 1
-    
+
     d_e_vals = d_e_mask_[mask]
     dist_embedded = pdist(Psi_k_mask)[mask]
-    
+
     disc_lip_const = dist_embedded / d_e_vals
     return np.max(disc_lip_const) / (np.min(disc_lip_const) + 1e-12)
 
@@ -720,7 +734,7 @@ def cost_of_moving_alignment_error(
     evals = param.batched_eval_(
         c_U_k_uniq_k,
         np.broadcast_to(U_k_list, [len(c_U_k_uniq_k), len(U_k_list)]),
-        n_jobs=n_jobs
+        n_jobs=n_jobs,
     )
 
     m = c_U_k_uniq_k == k
@@ -816,13 +830,17 @@ def best(d_e, U, param, eta_min, eta_max, cost_fn, verbose, n_jobs):
 
     # Vary eta from 2 to eta_{min}
     for eta in tqdm(
-        range(2, eta_min + 1), desc="Intermediate views", disable=not verbose, position=0, leave=True
+        range(2, eta_min + 1),
+        desc="Intermediate views",
+        disable=not verbose,
+        position=0,
+        leave=True,
     ):
-            # tqdm.write(
-            #     "#non-empty views with sz < %d = %d"
-            #     % (eta, np.sum((n_C > 0) * (n_C < eta)))
-            # )
-            # tqdm.write("#nodes in views with sz < %d = %d" % (eta, np.sum(n_C[c] < eta)))
+        # tqdm.write(
+        #     "#non-empty views with sz < %d = %d"
+        #     % (eta, np.sum((n_C > 0) * (n_C < eta)))
+        # )
+        # tqdm.write("#nodes in views with sz < %d = %d" % (eta, np.sum(n_C[c] < eta)))
 
         def target_proc(p_num, chunk_sz, n_, Utilde, n_C, c):
             start_ind = p_num * chunk_sz
@@ -835,7 +853,17 @@ def target_proc(p_num, chunk_sz, n_, Utilde, n_C, c):
             dest_ = np.zeros(end_ind - start_ind, dtype="int") - 1
             for i, k in enumerate(range(start_ind, end_ind)):
                 cost_[i], dest_[i] = cost_of_moving(
-                    k, d_e, neigh_ind[k], U_[k], param, c, n_C, Utilde, eta, eta_max, n_jobs=n_jobs
+                    k,
+                    d_e,
+                    neigh_ind[k],
+                    U_[k],
+                    param,
+                    c,
+                    n_C,
+                    Utilde,
+                    eta,
+                    eta_max,
+                    n_jobs=n_jobs,
                 )
             return start_ind, end_ind, cost_, dest_
 
@@ -855,8 +883,10 @@ def target_proc(p_num, chunk_sz, n_, Utilde, n_C, c):
             # copy-on-write, so the children see the exact same set layout
             # and produce bit-identical costs to a serial run.
             q = mp_lib.Queue()
+
             def _worker(p_num):
                 q.put(target_proc(p_num, chunk_sz, n, Utilde, n_C, c))
+
             procs = [
                 mp_lib.Process(target=_worker, args=(p_num,), daemon=True)
                 for p_num in range(n_jobs)
@@ -921,7 +951,17 @@ def _worker(p_num):
 
             for k in S:
                 cost[k], dest[k] = cost_of_moving(
-                    k, d_e, neigh_ind[k], U_[k], param, c, n_C, Utilde, eta, eta_max, n_jobs=1
+                    k,
+                    d_e,
+                    neigh_ind[k],
+                    U_[k],
+                    param,
+                    c,
+                    n_C,
+                    Utilde,
+                    eta,
+                    eta_max,
+                    n_jobs=1,
                 )
 
             if verbose:
@@ -1032,16 +1072,19 @@ def target_proc(p_num):
     if n_jobs == 1 or n_elem < 1000:
         res = [target_proc(p_num) for p_num in range(n_jobs)]
     else:
-        with parallel_backend("loky", inner_max_num_threads=_inner_blas_threads(n_jobs)):
-            res = list(Parallel(n_jobs=n_jobs,
-                                return_as="generator_unordered")(
-                delayed(target_proc)(p_num) for p_num in range(n_jobs)
-            ))
+        with parallel_backend(
+            "loky", inner_max_num_threads=_inner_blas_threads(n_jobs)
+        ):
+            res = list(
+                Parallel(n_jobs=n_jobs, return_as="generator_unordered")(
+                    delayed(target_proc)(p_num) for p_num in range(n_jobs)
+                )
+            )
     for value in res:
         start_ind, end_ind, overlap_svals_ = value
         overlap_svals[start_ind:end_ind, :] = overlap_svals_
 
-    # In most cases, when almost all overlaps have rank d, 
+    # In most cases, when almost all overlaps have rank d,
     # W_data = overlap_svals[:,-1], the d-th singular value of the overlap
     # is sufficient to determine the priority of the overlaps.
     # overlap_svals[overlap_svals<tol] = 0
@@ -1186,6 +1229,7 @@ def center_of_tree(T):
 
 def compute_init_embedding(
     d,
+    d_e,
     Utilde,
     param,
     seq_of_intermed_views_in_cluster,
@@ -1194,6 +1238,10 @@ def compute_init_embedding(
     to_tear,
     align_w_parent_only,
     n_Utilde_Utilde,
+    repel_by,
+    repel_decay,
+    n_repel,
+    global_init_algo_name,
     verbose,
 ):
     """Initial alignment of datapoints in embedding via Procrustes alignment.
@@ -1215,6 +1263,14 @@ def compute_init_embedding(
 
     n_Utilde_Utilde : array-like
 
+    repel_by :
+
+    repel_decay :
+
+    n_repel :
+
+    global_init_algo_name : str
+
     verbose : bool
         If True, print logs to stdout.
 
@@ -1242,28 +1298,44 @@ def compute_init_embedding(
         rho = parents_of_intermed_views_in_cluster[i]
         seq_0 = seq[0]
         is_visited_view[seq_0] = True
-        y[C[seq_0, :].indices, :] = param.eval_(
-            seq_0, C[seq_0, :].indices
-        )
-        y, is_visited_view = procrustes_init(
-            seq,
-            rho,
-            y,
-            is_visited_view,
-            d,
-            Utilde,
-            C,
-            param,
-            to_tear,
-            align_w_parent_only,
-            n_Utilde_Utilde,
-        )
+        y[C[seq_0, :].indices, :] = param.eval_(seq_0, C[seq_0, :].indices)
+        far_off_points = compute_far_off_points(d_e, n_repel)
+
+        if global_init_algo_name == "procrustes":
+            y, is_visited_view = procrustes_init(
+                seq,
+                rho,
+                y,
+                is_visited_view,
+                d,
+                Utilde,
+                C,
+                param,
+                to_tear,
+                align_w_parent_only,
+                n_Utilde_Utilde,
+            )
+        elif global_init_algo_name == "spectral":
+            y = spectral_alignment(
+                y,
+                d,
+                Utilde,
+                C,
+                param,
+                repel_by,
+                repel_decay,
+                n_repel,
+                far_off_points,
+                seq_of_intermed_views_in_cluster,
+            )
+        else:
+            raise NotImplementedError()
 
     if verbose:
-        err = compute_alignment_err(d, Utilde, param, verbose)
+        err = compute_alignment_err(d, Utilde, param, repel_by, far_off_points, verbose)
         print("Alignment error: %0.3f" % (err / Utilde.nnz), flush=True)
 
-    return y
+    return y, far_off_points
 
 
 def compute_incidence_matrix_in_embedding(y, C, k, nu, metric="euclidean"):
@@ -1315,6 +1387,9 @@ def compute_final_embedding(
     k,
     metric,
     alpha,
+    repel_by,
+    repel_decay,
+    far_off_points,
     verbose,
 ):
     """Align clusters via Riemannian Gradient Descent.
@@ -1394,11 +1469,22 @@ def compute_final_embedding(
             Utilde_t = Utildeg.multiply(Utilde)
             Utilde_t.eliminate_zeros()
 
-        y = rgd_alignment(d, Utilde_t, param, max_internal_iter, alpha, verbose)
+        y = rgd_alignment(
+            d,
+            Utilde_t,
+            param,
+            max_internal_iter,
+            alpha,
+            repel_by,
+            far_off_points,
+            verbose,
+        )
         if (
             patience_ctr < max_iter or verbose
         ):  # If it makes sense to compute the error or verbose
-            err = compute_alignment_err(d, Utilde_t, param, verbose)
+            err = compute_alignment_err(
+                d, Utilde_t, param, repel_by, far_off_points, verbose
+            )
             E_Gamma_t = Utilde_t.nnz
             err = err / E_Gamma_t
             if prev_err is not None:
@@ -1414,6 +1500,9 @@ def compute_final_embedding(
             if patience_ctr <= 0:
                 break
 
+        if repel_by is not None:
+            repel_by *= repel_decay
+
     if to_tear:
         Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu, metric)
         return y, Utildeg
@@ -1421,7 +1510,9 @@ def compute_final_embedding(
     return y, None
 
 
-def rgd_alignment(d, Utilde, param, max_internal_iter, alpha, verbose):
+def rgd_alignment(
+    d, Utilde, param, max_internal_iter, alpha, repel_by, far_off_points, verbose
+):
     """Riemannian Gradient Descent (RGD)
 
     Parameters
@@ -1469,7 +1560,9 @@ def update(alpha, max_iter, O, CC, M, d):
 
         return O_.transpose(1, 2, 0).reshape(O.shape, order="F")
 
-    CC, Lpinv_BT, _, _ = build_ortho_optim(d, Utilde, param, verbose)
+    CC, Lpinv_BT, _, _ = build_ortho_optim(
+        d, Utilde, param, repel_by, far_off_points, verbose
+    )
     M, n = Utilde.shape
 
     Tstar = update(
@@ -1480,7 +1573,7 @@ def update(alpha, max_iter, O, CC, M, d):
 
     Tstar_ = Tstar.reshape((len(Tstar), d, -1), order="F").transpose(2, 1, 0)
     param.T = np.matmul(param.T, Tstar_)  # update transformations of individual points
-    param.v = np.matmul(param.v[:, np.newaxis, :], Tstar_)[:,0,:] + Zstar[:, n:].T
+    param.v = np.matmul(param.v[:, np.newaxis, :], Tstar_)[:, 0, :] + Zstar[:, n:].T
 
     return Zstar[:, :n].T
 
@@ -1492,12 +1585,12 @@ def compute_Lpinv_helpers(W):
     D_2 = np.asarray(B_.sum(axis=0))
     D_1_inv_sqrt = np.sqrt(1 / D_1).flatten()
     D_2_inv_sqrt = np.sqrt(1 / D_2).flatten()
-    
-    #B_tilde = B_.multiply(D_2_inv_sqrt).multiply(D_1_inv_sqrt)
+
+    # B_tilde = B_.multiply(D_2_inv_sqrt).multiply(D_1_inv_sqrt)
     # Create sparse diagonal matrices
     D1_diag = diags(D_1_inv_sqrt)
     D2_diag = diags(D_2_inv_sqrt)
-    
+
     # Sparse matrix multiplication is MUCH faster than .multiply()
     B_tilde = D1_diag @ B_ @ D2_diag
 
@@ -1508,35 +1601,35 @@ def compute_Lpinv_helpers(W):
         # Sparse matrix multiplication here is incredibly fast.
         C = (B_tilde.T @ B_tilde).todense()
         S2, V = eigh(C)
-        
+
         # eigh returns ascending order; reverse to match standard SVD output
         idx = np.argsort(S2)[::-1]
         S2 = S2[idx]
         V = V[:, idx]
-        
+
         # Recover singular values and right singular vectors
         SS = np.sqrt(np.maximum(S2, 0))
         VT = V.T
-        
+
         # Recover left singular vectors: U = B_tilde @ V @ diag(1/SS)
-        with np.errstate(divide='ignore', invalid='ignore'):
+        with np.errstate(divide="ignore", invalid="ignore"):
             SS_inv = np.where(SS > 1e-10, 1.0 / SS, 0.0)
-            
+
         U12 = (B_tilde @ V) * SS_inv[np.newaxis, :]
     else:
         # Fallback if M > n: Compute (n, n) Gram matrix instead
         C = (B_tilde @ B_tilde.T).todense()
         S2, U12 = eigh(C)
-        
+
         idx = np.argsort(S2)[::-1]
         S2 = S2[idx]
         U12 = U12[:, idx]
-        
+
         SS = np.sqrt(np.maximum(S2, 0))
-        
-        with np.errstate(divide='ignore', invalid='ignore'):
+
+        with np.errstate(divide="ignore", invalid="ignore"):
             SS_inv = np.where(SS > 1e-10, 1.0 / SS, 0.0)
-            
+
         VT = (U12.T @ B_tilde) * SS_inv[:, np.newaxis]
     # -------------------------------------------
     U12, VT = svd_flip(U12, VT)
@@ -1551,7 +1644,16 @@ def compute_Lpinv_helpers(W):
     U2 = U12[:, m_1:]
     V1 = V[:, :m_1]
     V2 = V[:, m_1:]
-    return [D_1_inv_sqrt[:,None], D_2_inv_sqrt[None,:], U1, U2, V1, V2, Sigma_1, Sigma_2]
+    return [
+        D_1_inv_sqrt[:, None],
+        D_2_inv_sqrt[None, :],
+        U1,
+        U2,
+        V1,
+        V2,
+        Sigma_1,
+        Sigma_2,
+    ]
 
 
 # Ngoc-Diep Ho, Paul Van Dooren, On the pseudo-inverse of the Laplacian of a bipartite graph
@@ -1570,7 +1672,7 @@ def compute_Lpinv_MT(Lpinv_helpers, B):
 
     # Optimized matrix-vector products using identities to avoid full dense B_n
     # Identity: U^T (diag(D) (B - mu 1^T))^T = (U^T diag(D)) B^T - (U^T diag(D) 1) mu^T
-    
+
     # Compute U^T * B1T terms
     U1T_D1 = (U1 * D_1_inv_sqrt).T  # (m1, n)
     U1TB1T = (U1T_D1 @ B1.T) - (U1T_D1.sum(axis=1)[:, None] @ B_mean.T)
@@ -1617,27 +1719,27 @@ def compute_CC(D, B, Lpinv_BT):
     return 0.5 * (CC + CC.T)
 
 
-def build_ortho_optim(d, Utilde, param, verbose):
+def build_ortho_optim(d, Utilde, param, repel_by, far_off_points=[], verbose=False):
     """Compute the Graph-Laplacian's inverse times B^\top."""
     M, n = Utilde.shape
     W = Utilde.astype(float)
     W_vals_all = W.data
-    
+
     # Vectorized construction of D and B components
     D_list = []
-    
+
     # We still loop over M to build B values, but we use pre-allocated arrays
     # or better, compute B values in blocks.
     B_data_vals = []
     B_cluster_vals = []
     B_cols = []
-    
+
     for i in range(M):
         Utilde_i = Utilde[i, :].indices
         X_ = param.eval_(i, Utilde_i)
-        weights_i = W_vals_all[W.indptr[i]:W.indptr[i+1]]
+        weights_i = W_vals_all[W.indptr[i] : W.indptr[i + 1]]
         sqrt_p_ki = np.sqrt(weights_i[:, None])
-        
+
         # Weighted embeddings for D: sqrt(W) * X
         X_weighted = sqrt_p_ki * X_
         D_list.append(X_weighted.T @ X_weighted)
@@ -1649,19 +1751,21 @@ def build_ortho_optim(d, Utilde, param, verbose):
         B_cols.append(Utilde_i)
 
     D = block_diag(D_list, format="csr")
-    
+
     # Efficiently construct B
     B_data_vals = np.concatenate(B_data_vals)
     B_cluster_vals = np.concatenate(B_cluster_vals)
-    
+
     B_cols_data = []
     for i in range(M):
         B_cols_data.append(np.tile(B_cols[i], d))
     B_cols_data = np.concatenate(B_cols_data)
-    
+
     # Row indices for data values
     counts = np.diff(W.indptr)
-    B_rows_data = np.repeat(np.arange(M) * d, counts * d) + np.tile(np.arange(d), len(B_cols_data) // d)
+    B_rows_data = np.repeat(np.arange(M) * d, counts * d) + np.tile(
+        np.arange(d), len(B_cols_data) // d
+    )
     # Wait, the above tiling is not quite right if counts vary.
     # Correct rows: repeat each row index (i*d + offset)
     B_rows_data = []
@@ -1673,23 +1777,70 @@ def build_ortho_optim(d, Utilde, param, verbose):
     # B indices for cluster nodes
     B_rows_cluster = np.arange(M * d)
     B_cols_cluster = np.repeat(np.arange(n, n + M), d)
-    
+
     # Combine everything
     B_row_all = np.concatenate([B_rows_cluster, B_rows_data])
     B_col_all = np.concatenate([B_cols_cluster, B_cols_data])
     B_val_all = np.concatenate([B_cluster_vals, B_data_vals])
-    
+
     B = csr_matrix((B_val_all, (B_row_all, B_col_all)), shape=(M * d, n + M))
 
     Lpinv_helpers = compute_Lpinv_helpers(W)
     Lpinv_BT = compute_Lpinv_MT(Lpinv_helpers, B)
     CC = compute_CC(D, B, Lpinv_BT)
 
+    n_repel = len(far_off_points)
+    if n_repel > 0:
+        L_r = np.zeros((n_repel, n_repel))
+        L__row_inds = []
+        L__col_inds = []
+        L__vals = []
+        for i in range(n_repel):
+            L__row_inds += [far_off_points[i]] * n_repel
+            L__col_inds += far_off_points
+            p_llp = np.ones(len(far_off_points))
+            p_llp[i] = 0
+            p_llp_sum = np.sum(p_llp)
+            p_llp *= -1
+            p_llp[i] = p_llp_sum
+            L_r[i, :] = p_llp
+
+            L__vals += L_r[i, :].tolist()
+
+        L_ = csr_matrix((L__vals, (L__row_inds, L__col_inds)), shape=(n + M, n + M))
+        L_ = repel_by * L_
+        L__Lpinv_BT = L_.dot(Lpinv_BT)
+        CC -= (Lpinv_BT.T).dot(L__Lpinv_BT)
+
     return CC, Lpinv_BT, D, B
 
 
+def compute_far_off_points(d_e, n_repel):
+    far_off_points = []
+    dist_from_far_off_points = None
+    while len(far_off_points) < n_repel:
+        if len(far_off_points) == 0:
+            far_off_points = []
+            dist_from_far_off_points = np.zeros(d_e.shape[0]) + np.inf
+            while np.sum(np.isinf(dist_from_far_off_points)):
+                inf_inds = np.where(np.isinf(dist_from_far_off_points))[0]
+                np.random.shuffle(inf_inds)
+                far_off_points.append(inf_inds[0])
+                dist_from_far_off_points = np.minimum(
+                    dist_from_far_off_points,
+                    dijkstra(d_e, directed=False, indices=far_off_points[-1]),
+                )
+        else:
+            far_off_points.append(np.argmax(dist_from_far_off_points))
+            dist_from_far_off_points = np.minimum(
+                dist_from_far_off_points,
+                dijkstra(d_e, directed=False, indices=far_off_points[-1]),
+            )
+    return far_off_points
+
+
 # unscaled alignment error
-def compute_alignment_err(d, Utilde, intermed_param, verbose):
+def compute_alignment_err(d, Utilde, intermed_param, repel_by, far_off_points, verbose):
     """Compute alignment error of data in new space.
 
     Parameters
@@ -1704,7 +1855,9 @@ def compute_alignment_err(d, Utilde, intermed_param, verbose):
         Stores parameterisations for all points
     """
 
-    CC, _, _, _ = build_ortho_optim(d, Utilde, intermed_param, verbose)
+    CC, _, _, _ = build_ortho_optim(
+        d, Utilde, intermed_param, repel_by, far_off_points, verbose
+    )
     M, n = Utilde.shape
 
     CC_mask = np.tile(np.eye(d, dtype=bool), (M, M))
@@ -1741,6 +1894,95 @@ def procrustes(A, B):
     return T, v
 
 
+# Kunal N Chaudhury, Yuehaw Khoo, and Amit Singer, Global registration
+# of multiple point clouds using semidefinite programming
+def spectral_alignment(
+    y,
+    d,
+    Utilde,
+    C,
+    param,
+    repel_by,
+    repel_decay,
+    n_repel,
+    far_off_points,
+    seq_of_intermed_views_in_cluster=None,
+):
+    if seq_of_intermed_views_in_cluster is None:
+        seq_of_intermed_views_in_cluster = [np.arange(Utilde.shape[0])]
+    CC, Lpinv_BT, _, _ = build_ortho_optim(
+        d,
+        Utilde,
+        param,
+        far_off_points=far_off_points,
+        repel_by=repel_by,
+    )
+
+    M, n = Utilde.shape
+    n_clusters = len(seq_of_intermed_views_in_cluster)
+    CC0 = np.zeros((M * d, d))
+    # for s in range(M):
+    #     CC0[s*d:(s+1)*d,:] = intermed_param.T[s,:,:]
+    for s in range(M):
+        CC0[s * d : (s + 1) * d, :] = np.eye(d)
+    CC0 = CC0 / np.sqrt(M)
+    v0 = CC0[:, 0]
+
+    np.random.seed(42)
+    v0 = np.random.uniform(0, 1, CC.shape[0])
+    if (n_repel == 0) or (repel_by == 0):
+        # To find smallest eigenvalues, using shift-inverted algo with mode=normal and which='LM'
+        W_, V_ = scipy.sparse.linalg.eigsh(CC, k=d, v0=v0, sigma=-1e-3)
+        # W_,V_ = scipy.sparse.linalg.lobpcg(CC, CC0.T, largest=False)
+        # or just pass which='SM' without using sigma
+        # W_,V_ = scipy.sparse.linalg.eigsh(CC, k=d, v0=v0, which='SM')
+        V_, _ = svd_flip(V_, V_.T)
+    else:
+        # To find smallest eigenvalues, using shift-inverted algo with mode=normal and which='LM'
+        CC_frob = np.linalg.norm(CC)
+        W_, V_ = scipy.sparse.linalg.eigsh(CC, k=d, v0=v0, sigma=-2 * CC_frob)
+        # or just pass which='SM' without using sigma
+        # W_,V_ = scipy.sparse.linalg.eigsh(CC, k=d, v0=v0, which='SA')
+        V_, _ = svd_flip(V_, V_.T)
+
+    Wstar = np.sqrt(M) * V_.T
+    Tstar = np.zeros((d, M * d))
+    for i in range(n_clusters):
+        # the first view in each cluster is not rotated
+        seq = seq_of_intermed_views_in_cluster[i]
+        s0 = seq[0]
+        U_, S_, VT_ = scipy.linalg.svd(Wstar[:, d * s0 : d * (s0 + 1)])
+        U_, VT_ = svd_flip(U_, VT_)
+        Q = np.matmul(U_, VT_)
+        Q = Q.T
+
+        for m_ in range(len(seq)):
+            m = seq[m_]
+            U_, S_, VT_ = scipy.linalg.svd(Wstar[:, d * m : d * (m + 1)])
+            temp_ = np.matmul(U_, VT_)
+            Tstar[:, m * d : (m + 1) * d] = np.matmul(Q, temp_)
+
+    Zstar = Tstar.dot(Lpinv_BT.transpose())
+
+    # the first view in each cluster is not translated
+    for i in range(n_clusters):
+        seq = seq_of_intermed_views_in_cluster[i]
+        s0 = seq[0]
+        temp = Zstar[:, n + s0][:, None].copy()
+        Zstar[:, n + seq] -= temp
+        C_seq = C[seq, :].sum(axis=0).nonzero()[1]
+        Zstar[:, C_seq] -= temp
+
+    for s in range(M):
+        T_s = Tstar[:, s * d : (s + 1) * d].T
+        v_s = Zstar[:, n + s]
+        param.T[s, :, :] = np.matmul(param.T[s, :, :], T_s)
+        param.v[s, :] = np.matmul(param.v[s, :][np.newaxis, :], T_s) + v_s
+        C_s = C[s, :].indices
+        y[C_s, :] = param.eval_(view_index=s, data_mask=C_s)
+    return y, Zstar[:, :n].T
+
+
 def procrustes_init(
     seq,
     rho,
@@ -1787,9 +2029,7 @@ def procrustes_init(
         for mp in Z_s:
             Utilde_s_mp = Utilde_s.multiply(Utilde[mp, :]).nonzero()[1]
             n_Utilde_s_Z_s[Utilde_s_mp] += 1
-            mu_s[Utilde_s_mp, :] += param.eval_(
-                mp, Utilde_s_mp
-            )
+            mu_s[Utilde_s_mp, :] += param.eval_(mp, Utilde_s_mp)
 
         # Compute T_s and v_s by aligning the embedding of the overlap
         # between sth view and the views in Z_s, with the centroid mu_s
@@ -1816,28 +2056,28 @@ def add_spacing_between_clusters(y, seq_of_intermed_views_in_cluster, param, C):
     n_clusters = len(seq_of_intermed_views_in_cluster)
     if n_clusters == 1:
         return
-    
-    M,n = C.shape
-        
+
+    M, n = C.shape
+
     # arrange connected components nicely
     # spaced on horizontal (x) axis
     offset = 0
-    cluster_label = np.zeros(y.shape[0], dtype=int)-1
+    cluster_label = np.zeros(y.shape[0], dtype=int) - 1
     for i in range(n_clusters):
         seq = seq_of_intermed_views_in_cluster[i]
-        pts_in_cluster_i = np.where(C[seq,:].sum(axis=0))[1]
+        pts_in_cluster_i = np.where(C[seq, :].sum(axis=0))[1]
         cluster_label[pts_in_cluster_i] = i
         # make the x coordinate of the leftmost point
         # of the ith cluster to be equal to the offset
         if i > 0:
-            offset_ = np.min(y[pts_in_cluster_i,0])
-            param.v[seq,0] += offset - offset_
-            y[pts_in_cluster_i,0] += offset - offset_
-        
+            offset_ = np.min(y[pts_in_cluster_i, 0])
+            param.v[seq, 0] += offset - offset_
+            y[pts_in_cluster_i, 0] += offset - offset_
+
         # recompute the offset as the x coordinate of
         # rightmost point of the current cluster
-        offset = 1.25*np.max(y[pts_in_cluster_i,0])
-    
+        offset = 1.25 * np.max(y[pts_in_cluster_i, 0])
+
     return cluster_label
 
 
@@ -1899,7 +2139,11 @@ def iter_eval_(self, view_index, data_mask, peak_bytes_per_row=0):
         a one-time RuntimeWarning is emitted so the user knows they're at
         the limit.
         """
-        ks = np.asarray(view_index) if not isinstance(view_index, np.ndarray) else view_index
+        ks = (
+            np.asarray(view_index)
+            if not isinstance(view_index, np.ndarray)
+            else view_index
+        )
         masks = data_mask
         n_eval = len(ks)
         if n_eval == 0:
@@ -1956,8 +2200,8 @@ def iter_eval_(self, view_index, data_mask, peak_bytes_per_row=0):
                     X_ = X_ - np.mean(X_, axis=0)[None, :]
                     X_ = X_ / (np.std(X_, axis=0, ddof=1)[None, :] + 1e-12)
                 chunk = self.model[k].transform(X_)[None, ...]
-                ks_chunk = ks[i:i + 1]
-                masks_chunk = masks[i:i + 1]
+                ks_chunk = ks[i : i + 1]
+                masks_chunk = masks[i : i + 1]
                 chunk = self._apply_post_(ks_chunk, masks_chunk, chunk)
                 yield slice(i, i + 1), chunk
 
@@ -1969,7 +2213,9 @@ def _apply_post_(self, ks, masks, temp):
         """
         if self.noise_var:
             np.random.seed(self.noise_seed[0])
-            temp2 = np.random.normal(0, self.noise_var, (self.X.shape[0], temp.shape[2]))
+            temp2 = np.random.normal(
+                0, self.noise_var, (self.X.shape[0], temp.shape[2])
+            )
             temp = temp + temp2[masks, :]
         if self.noise is not None:
             temp = temp + self.noise[masks]
@@ -2010,8 +2256,10 @@ def batched_eval_(self, view_index, data_mask, n_jobs=1):
             return first_chunk
 
         # Multi-chunk path: accumulate into a pre-allocated output array.
-        out = np.empty((n_eval, first_chunk.shape[1], first_chunk.shape[2]),
-                       dtype=first_chunk.dtype)
+        out = np.empty(
+            (n_eval, first_chunk.shape[1], first_chunk.shape[2]),
+            dtype=first_chunk.dtype,
+        )
         out[first_sl] = first_chunk
         for sl, chunk in it:
             out[sl] = chunk
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
old mode 100644
new mode 100755
index c7e8c62..1863393
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -21,7 +21,6 @@
 )
 from pyRATS._tear_coloring import compute_color_of_pts_on_tear
 
-
 # _postprocess_col_range removed to reduce Parallel overhead in tight loops.
 
 
@@ -96,7 +95,7 @@ class RATS:
         relative change in the size of the tear.
 
     metric : str, default='euclidean'
-        Metric assumed on the embedding. 
+        Metric assumed on the embedding.
 
     fit_inverse_transform : bool, default=False
         To be added in future releases. If True, computes the inverse of the embedding
@@ -149,7 +148,11 @@ def __init__(
         eps=1e-8,
         n_iter_without_progress=5,
         tol=1e-2,
+        repel_by=0.0,
+        repel_decay=1.0,
+        n_repel=0.0,
         n_forced_clusters=1,
+        global_init_algo_name="procrustes",
         verbose=False,
         n_jobs=-1,
         **kwargs,
@@ -262,7 +265,9 @@ def __init__(
         self.alpha, self.eps = alpha, eps
         self.patience, self.tol = n_iter_without_progress, tol
         self.metric = metric
+        self.repel_by, self.repel_decay, self.n_repel = repel_by, repel_decay, n_repel
         self.n_forced_clusters = n_forced_clusters
+        self.global_init_algo_name = global_init_algo_name
 
         if self.patience is None:
             self.patience = self.max_iter
@@ -289,7 +294,7 @@ def fit_transform(self, X, condition_num=None):
         X : array-like, shape (n_samples, n_features)
             Sample data, in the form of a numpy array of shape (n_samples, n_features).
 
-        condition_num : 
+        condition_num :
 
         Returns
         -------
@@ -359,7 +364,7 @@ def compute_color_of_pts_on_tear(self, y, tear_color_eig_inds=[0, 1, 2]):
             tear_color_eig_inds,
             self.k,
             self.nu,
-            'euclidean',
+            "euclidean",
             self.verbose,
             self.n_jobs,
             self.Utildeg,
@@ -411,10 +416,7 @@ def inverse_transform(self, y):
         X : array-like, shape (n_samples, n_features)
             Points in the original space.
         """
-        raise NotImplementedError(
-            "inverse_transform() is not yet implemented."
-        )
-
+        raise NotImplementedError("inverse_transform() is not yet implemented.")
 
     def _fit_nbrhd_graph(self, X, condition_num=None, sort_results=True):
         """Fitting the neighborhood graph.
@@ -424,7 +426,7 @@ def _fit_nbrhd_graph(self, X, condition_num=None, sort_results=True):
         X : array shape (n_samples, n_features)
             A 2d array containing data representing a manifold.
 
-        condition_num : 
+        condition_num :
 
         sort_results: bool, default=True
             If True, sorts neighbors by index in ascending order for deterministic behavior.
@@ -437,7 +439,12 @@ def _fit_nbrhd_graph(self, X, condition_num=None, sort_results=True):
 
         if condition_num is not None:
             self.neigh_dist, self.neigh_ind, self.k_nn0 = induce_connections(
-                X, self.metric, condition_num, self.neigh_ind, self.neigh_dist, self.k_nn0,
+                X,
+                self.metric,
+                condition_num,
+                self.neigh_ind,
+                self.neigh_dist,
+                self.k_nn0,
             )
             self.k = self.k_nn0
 
@@ -601,8 +608,9 @@ def _fit_global_views(self, c, n_C):
         )
 
         # Compute initial embedding
-        y_init = compute_init_embedding(
+        y_init, far_off_points = compute_init_embedding(
             self.d,
+            self.neighborhood_graph_sym,
             self.Utilde,
             self.param,
             seq_of_intermed_views_in_cluster,
@@ -611,6 +619,10 @@ def _fit_global_views(self, c, n_C):
             self.to_tear,
             self.align_w_parent_only,
             self.n_Utilde_Utilde,
+            self.repel_by,
+            self.repel_decay,
+            self.n_repel,
+            self.global_init_algo_name,
             self.verbose,
         )
 
@@ -630,6 +642,9 @@ def _fit_global_views(self, c, n_C):
             self.k,
             self.metric,
             self.alpha,
+            self.repel_by,
+            self.repel_decay,
+            far_off_points,
             self.verbose,
         )
 
@@ -668,12 +683,14 @@ def _postprocess(self):
         zeta = np.empty(n)
         view_idx = np.arange(n, dtype=int)
         masks_init = self.U.indices.reshape(n, self.k)
-        for sl, chunk in self.param.iter_eval_(view_idx, masks_init,
-                                               peak_bytes_per_row=pdist_per_row):
+        for sl, chunk in self.param.iter_eval_(
+            view_idx, masks_init, peak_bytes_per_row=pdist_per_row
+        ):
             chunk_dists = batched_pdist(chunk)
             chunk_orig = original_dists[sl]
             dlc = np.divide(
-                chunk_dists, chunk_orig,
+                chunk_dists,
+                chunk_orig,
                 out=np.full_like(chunk_dists, np.nan),
                 where=chunk_orig != 0,
             )
@@ -681,7 +698,6 @@ def _postprocess(self):
 
         self.param.zeta = zeta
 
-
         connectivity_matrix = self.U.indices.reshape(n, -1)
         future_use_phi_of = np.arange(n, dtype=int)
 
@@ -693,9 +709,8 @@ def _postprocess(self):
         while len(param_changed) > 0:
             changed_mask = np.zeros(n, dtype=bool)
             changed_mask[param_changed] = True
-            reconsider_mask = (
-                changed_mask[connectivity_matrix]
-                & (connectivity_matrix != np.arange(n)[:, None])
+            reconsider_mask = changed_mask[connectivity_matrix] & (
+                connectivity_matrix != np.arange(n)[:, None]
             )
 
             zeta_min = np.full(n, np.inf)
@@ -720,7 +735,8 @@ def _postprocess(self):
                     chunk_dists = batched_pdist(chunk)
                     chunk_orig = batch_original_dists[sl]
                     dlc = np.divide(
-                        chunk_dists, chunk_orig,
+                        chunk_dists,
+                        chunk_orig,
                         out=np.full_like(chunk_dists, np.nan),
                         where=chunk_orig != 0,
                     )
@@ -738,7 +754,6 @@ def _postprocess(self):
                 connectivity_matrix[param_changed, best_col[param_changed]]
             ]
             zeta = np.minimum(zeta, zeta_min)
-
             if self.verbose:
                 pbar.update(n - len(param_changed) - pbar.n)
 

From a362f417f6954b2e10c0d85276a6d3f9504284cf Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Thu, 11 Jun 2026 09:27:04 +0200
Subject: [PATCH 06/20] feat: cut and paste app

---
 examples/cut_and_paste_app.py | 728 ++++++++++++++++++++++++++++++++++
 src/pyRATS/_utils.py          |   5 +-
 src/pyRATS/rats.py            |  28 +-
 3 files changed, 741 insertions(+), 20 deletions(-)
 create mode 100644 examples/cut_and_paste_app.py

diff --git a/examples/cut_and_paste_app.py b/examples/cut_and_paste_app.py
new file mode 100644
index 0000000..6b06a8f
--- /dev/null
+++ b/examples/cut_and_paste_app.py
@@ -0,0 +1,728 @@
+#To run the app, execute
+# bokeh serve cut_and_paste_app.py --allow-websocket-origin=localhost:5006
+# then go to http://localhost:5006
+
+from bokeh.plotting import figure, curdoc
+from bokeh.models import LassoSelectTool, TapTool, TextInput, Button, Div, ColumnDataSource, TextAreaInput, Range1d, CustomJS
+from bokeh.plotting import figure
+from bokeh.layouts import row, column
+from bokeh.events import PanStart, Pan, PanEnd
+import ast
+
+import matplotlib
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.patches import Polygon
+
+import os
+import pickle
+
+from scipy.spatial import ConvexHull
+import vis
+from vis import maximize_window
+
+import sys
+sys.path.insert(0, 'src/')    # TODO: rely on pip install
+import os
+import pickle
+from cut_and_paste import cut_and_paste_bokeh
+
+
+from pyRATS._utils import procrustes, compute_final_embedding, add_spacing_between_clusters
+
+QUIT_KEY = 'q'
+ENTER_KEY = 'enter'
+
+def rgba_to_css(rgba):
+    r, g, b, a = rgba
+    return f"rgba({int(r*255)}, {int(g*255)}, {int(b*255)}, {a:.2f})"
+
+def rgba_arr_to_css_arr(rgba_arr):
+    css_arr = []
+    for i in range(rgba_arr.shape[0]):
+        css_arr.append(rgba_to_css(rgba_arr[i,:]))
+    return css_arr
+
+def path_exists(path):
+    return os.path.exists(path) or os.path.islink(path)
+
+def makedirs(dirpath):
+    if path_exists(dirpath):
+        return
+    os.makedirs(dirpath)
+
+def save(dirpath, fname, data, verbose=True):
+    if not path_exists(dirpath):
+        os.makedirs(dirpath)
+    fpath = dirpath + '/' + fname
+    with open(fpath, "wb") as f:
+        pickle.dump(data, f)
+    if verbose:
+        print('Saved data in', fpath, flush=True)
+
+def read(fpath, verbose=True):
+    if not path_exists(fpath):
+        if verbose:
+            print(fpath, 'does not exist.')
+        return None
+    with open(fpath, "rb") as f:
+        data = pickle.load(f)
+    if verbose:
+        print('Read data from', fpath, flush=True)
+    return data
+
+def create_mask(inds, n):
+    temp = np.zeros(n, dtype=bool)
+    temp[inds] = 1
+    return temp
+
+
+class CutAndPaste:
+    def __init__(
+        self,
+        model,
+        y,
+        color_of_pts_on_tear,
+        metadata_fname=None,
+        save_progress_dir='',
+        cmap_interior='summer',
+        cmap_tear='jet',
+        max_refinement_iter=10,
+        force_compute=False
+    ):
+        self.model = model
+        self.y = y
+        self.color_of_pts_on_tear = color_of_pts_on_tear
+        self.pts = None
+        if metadata_fname is None:
+            self.metadata = []
+        else:
+            self.metadata = read(metadata_fname)
+        self.save_progress_dir = save_progress_dir
+        if self.save_progress_dir:
+            makedirs(self.save_progress_dir)
+        self.cur_iter = 0
+        self.cmap_interior = cmap_interior
+        self.cmap_tear = cmap_tear
+        self.max_refinement_iter = max_refinement_iter
+        self.force_compute = force_compute
+        self.selected_pts_to_move = np.array([])
+
+    def init_metadata_for_current_iter(self):
+        if len(self.metadata) <= self.cur_iter:
+            self.metadata.append({
+                'selected_cluster_mask': None,
+                'init_polygon': None,
+                'final_polygon': None
+            })
+
+    def get_current_embedding_data(self):
+        y = self.y.copy()
+        color_of_pts_on_tear = self.color_of_pts_on_tear.copy()
+        cmap_interior = self.cmap_interior
+        cmap_tear = self.cmap_tear
+
+        matplotlib.use('Agg')
+        color_of_pts_on_tear = self.color_of_pts_on_tear
+        pts_on_tear = ~np.isnan(color_of_pts_on_tear[:,-1])
+
+        interior_handle, tear_handle = vis.Visualize().global_embedding_for_gui(
+            y, y[:,0], cmap0=cmap_interior,
+            color_of_pts_on_tear=color_of_pts_on_tear[:,-1],
+            cmap1=cmap_tear,
+            set_title=True,
+            figsize=(3,3), s=20
+        )
+        if self.save_progress_dir:
+            save_fn = self.save_progress_dir + '/reg_tear_y_at_iter=' + str(self.cur_iter) + '.png'
+            plt.savefig(save_fn, bbox_inches='tight', dpi=400)
+
+        y_face_color = interior_handle._facecolors
+        y_face_color[pts_on_tear,:] = tear_handle.get_facecolors()
+
+        self.y_face_color = y_face_color
+
+        source_data_dict = dict(
+            x=y[:,0], y=y[:,1],
+            color=rgba_arr_to_css_arr(y_face_color)
+        )
+        return source_data_dict
+
+    def get_encolsing_polygon_for_selected_pts(self, selected_pts_indices):
+        selected_cluster_mask = self.select_clusters_to_move(selected_pts_indices)
+        points_in_selected_clusters = selected_cluster_mask[self.model.c]
+        y = self.y.copy()
+        init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters,:])
+        patch_source_data_dict = dict(x=init_polyg[:,0], y=init_polyg[:,1])
+        return patch_source_data_dict
+    
+    # There is one to one correspondence between
+    # clusters/partitions and local views
+    def cut_clusters_to_move(self, selected_pts_indices):
+        self.init_metadata_for_current_iter()
+        if self.force_compute or (self.metadata[self.cur_iter]['selected_cluster_mask'] is None):
+            selected_cluster_mask = self.select_clusters_to_move(selected_pts_indices)
+            self.metadata[self.cur_iter]['selected_cluster_mask'] = selected_cluster_mask
+        else:
+            selected_cluster_mask = self.metadata[self.cur_iter]['selected_cluster_mask']
+        points_in_selected_clusters = np.where(selected_cluster_mask[self.model.c])[0]
+        self.selected_pts_to_move = points_in_selected_clusters
+
+        # Find a convex polygon that represents the points in the selected clusters
+        y = self.y.copy()
+        if self.force_compute or (self.metadata[self.cur_iter]['init_polygon'] is None):
+            init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters,:])
+            self.metadata[self.cur_iter]['init_polygon'] = init_polyg
+        else:
+            init_polyg = self.metadata[self.cur_iter]['init_polygon']
+
+        if self.save_progress_dir:
+            self.save_polygon(y, self.y_face_color, init_polyg, stage='init')
+
+        patch_source_data_dict = dict(x=init_polyg[:,0], y=init_polyg[:,1])
+        return patch_source_data_dict
+
+    def select_clusters_to_move(self, selected_pts_indices):
+        cluster_label = self.model.c
+        selected_pts_mask = create_mask(selected_pts_indices, len(cluster_label))
+        avoid_clusters = np.unique(cluster_label[~selected_pts_mask])
+        n_clusters = np.max(cluster_label)+1
+        avoid_clusters_mask = create_mask(avoid_clusters, n_clusters)
+        return ~avoid_clusters_mask
+
+    def paste_clusters(self, final_polyg):
+        if self.force_compute or (self.metadata[self.cur_iter]['final_polygon'] is None):
+            self.metadata[self.cur_iter]['final_polygon'] = final_polyg
+        else:
+            final_polyg = self.metadata[self.cur_iter]['final_polygon']
+
+        # Use the final location of the polygon to compute the
+        # final location of the points in the selected clusters
+        selected_cluster_mask = self.metadata[self.cur_iter]['selected_cluster_mask']
+        points_in_selected_clusters = selected_cluster_mask[self.model.c]
+        y = self.y.copy()
+        y_new = self.recompute_embedding(
+            y, points_in_selected_clusters,
+            self.metadata[self.cur_iter]['init_polygon'],
+            final_polyg
+        )
+        if self.save_progress_dir:
+            self.save_polygon(y_new, self.y_face_color, final_polyg, stage='final')
+        
+        self.finish_pasting(y_new)
+        # reset
+        self.selected_pts_to_move = np.array([])
+        return self.get_current_embedding_data()
+
+    def finish_pasting(self, y_new):
+        matplotlib.use('Agg')
+        print('Refining...', flush=True)
+        model = self.model
+        model.n_iter = self.max_refinement_iter
+        self.y, model.Utildeg = compute_final_embedding(
+            y_new, model.d, model.Utilde,
+            model.C,
+            model.param, 
+            model.to_tear,
+            model.patience,
+            model.max_iter, 
+            model.max_internal_iter, 
+            model.tol, 
+            model.nu, 
+            model.k,  
+            model.alpha, 
+            model.repel_by, 
+            model.repel_decay,
+            model.far_off_points,
+            model.verbose,
+        )
+        _ = add_spacing_between_clusters(
+            self.y, model.seq_of_intermed_views_in_cluster, model.param, model.C
+        )
+        self.color_of_pts_on_tear = model.compute_color_of_pts_on_tear(self.y)
+        
+        self.save_buml_obj(
+            'buml_obj_and_metadata_after_iter='+str(self.cur_iter)+'.dat', 
+        )
+        self.cur_iter += 1
+
+    def save_buml_obj(self, fname):
+        if self.save_progress_dir:
+            new_emb_info = {
+                'y': self.y,
+                'color_of_pts_on_tear': self.color_of_pts_on_tear,
+                'model': self.model,
+            }
+            save(self.save_progress_dir, fname, [new_emb_info, self.metadata])
+
+    def recompute_embedding(self, y, points_in_moving_clusters, init_polyg, final_polyg):
+        # init_polyg_centroid = np.mean(init_polyg, axis=0)
+        # final_polyg_centroid = np.mean(final_polyg, axis=0)
+        # t = final_polyg_centroid - init_polyg_centroid
+        # final_polyg_centered = final_polyg - final_polyg_centroid[None,:]
+        # init_polyg_centered = init_polyg - init_polyg_centroid[None,:]
+        # U, S, VT = np.linalg.svd(final_polyg_centered.T.dot(init_polyg_centered))
+        # O = VT.dot(U.T) # TODO: check
+        O, t = procrustes(init_polyg, final_polyg)
+        y = y.copy()
+        y[points_in_moving_clusters,:] = y[points_in_moving_clusters,:].dot(O) + t[None,:]
+        return y
+    
+    def save_polygon(self, y, y_face_color, y_polyg, stage, s=20):
+        assert stage in ['init', 'final']
+        matplotlib.use('Agg')
+        _, ax = plt.subplots()
+        maximize_window()
+        ax.scatter(y[:,0], y[:,1], c=y_face_color, s=s)
+        polyg = Polygon(y_polyg, color=[1,0,0,0.25])
+        ax.add_patch(polyg)
+        plt.axis('image')
+        plt.axis('off')
+        plt.tight_layout()
+        ax.set_rasterized(True)
+        save_fn = self.save_progress_dir + '/' + stage + '_polyg_at_iter=' + str(self.cur_iter) + '.png'
+        plt.savefig(save_fn, bbox_inches='tight', dpi=400)
+
+def get_convex_covering_polygon(y):
+    hull = ConvexHull(y)
+    return y[hull.vertices,:]
+
+
+
+# APP itself
+###############################################################
+
+REG_TEAR_TAG = 'reg_tear'
+
+# Spinner using CSS
+################################################################
+spinner = Div(text="""
+<div id="spinner" style="display:none;">
+  <div class="loader"></div>
+</div>
+
+<style>
+.loader {
+  border: 6px solid #f3f3f3;
+  border-top: 6px solid #3498db;
+  border-radius: 50%;
+  width: 15px;
+  height: 15px;
+  animation: spin 1s linear infinite;
+  margin: 5px auto;
+}
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+</style>
+""", width=25, height=20)
+def show_spinner():
+    spinner.text = spinner.text.replace('display:none;', 'display:block;')
+
+def hide_spinner():
+    spinner.text = spinner.text.replace('display:block;', 'display:none;')
+
+# Loggers
+################################################################
+class BokehLogger:
+    def __init__(self, div_widget):
+        self.div = div_widget
+        self.buffer = ""
+
+    def write(self, message):
+        self.buffer += message
+        self.div.text = f"""
+        <div style="overflow:auto;">
+            <pre>{self.buffer}</pre>
+        </div>
+        """
+
+    def flush(self):
+        pass
+
+def get_scroll_js(div_name):
+    scroll_js = CustomJS(code="""
+        // Find the element by ID
+        const el = document.querySelector('[data-name="{div_name}"]');
+        if (el) {
+            el.scrollTop = el.scrollHeight;
+        }
+    """)
+    return scroll_js
+
+
+DIV_WIDTH = 900
+DIV_HEIGHT = 150
+log_div = Div(
+    text="", width=DIV_WIDTH, height=DIV_HEIGHT,
+    styles={'overflow-y': 'scroll', 'border': '1px solid black'},
+    name='log_div'
+)
+log_div.js_on_change("text", get_scroll_js(log_div.name))
+sys.stdout = BokehLogger(log_div)
+print('<h3>Detailed logs are displayed here.</h3>')
+
+main_log_div = Div(
+    text="", width=DIV_WIDTH, height=DIV_HEIGHT,
+    styles={'overflow-y': 'scroll', 'border': '1px solid black'},
+    name='main_log_div'
+)
+main_log_div.js_on_change("text", get_scroll_js(main_log_div.name))
+main_log = BokehLogger(main_log_div)
+def print_main_log(message):
+    main_log.write(message + '\n')
+
+print_main_log('<h3>Short logs & instructions are displayed here. Detiled logs are printed at the end of the page.</h3>')
+print_main_log('Input algorithm, hyperparameter and options, and then press start.')
+
+# Text inputs
+################################################################
+gen_data_path_input = TextInput(
+    title="Generated data path",
+    value="/Users/joshuaoffergeld/Documents/pyRATS/examples",
+    width=550
+)
+
+algo_input = TextInput(title="Algorithm Name: (for ex: rats)", value="rats")
+hyp_param_input = TextInput(title="Hyperparameter: (for ex: 28_5)", value="28_5")
+options_input = TextAreaInput(
+    title="Additional options:",
+    value="{'force_compute': True, 'max_refinement_iter': 10, 'cmap_interior': 'summer', 'cmap_tear': 'jet'}",
+    rows=5,
+)
+
+cut_and_paste_obj = None
+rot_deg = 5
+lasso_tool = LassoSelectTool()
+tap_tool = TapTool()
+
+update_max_fig_height_button = Button(label="Update height", button_type="success", disabled=True)
+start_button = Button(label="Start", button_type="success")
+cut_button = Button(label="Cut", button_type="success", disabled=True)
+paste_button = Button(label="Paste", button_type="success", disabled=True)
+save_button = Button(label="Save", button_type="success", disabled=True)
+rotate_cw_button = Button(label="Rotate -" + str(rot_deg) + " deg", button_type="success", disabled=True)
+rotate_ccw_button = Button(label="Rotate +" + str(rot_deg) + " deg", button_type="success", disabled=True)
+
+source = ColumnDataSource(data=dict(x=[], y=[], color=[]))
+patch_source = ColumnDataSource(data=dict(x=[], y=[]))
+
+MAX_FIG_HEIGHT = 900
+MAX_FIG_WIDTH = 900
+
+max_fig_height_input = TextInput(title="Max figure height", value=str(MAX_FIG_HEIGHT))
+fig = figure(
+    title="Cut & Paste operation on the embedding",
+    tools=[lasso_tool],
+    x_axis_label="x",
+    y_axis_label="y",
+    width=MAX_FIG_HEIGHT,
+    height=MAX_FIG_WIDTH,
+    match_aspect=False
+)
+fig.scatter(
+    'x', 'y',
+    color='color',
+    source=source,
+    nonselection_alpha=0.3
+)
+fig.patch('x', 'y', source=patch_source, alpha=0.4, line_width=2, color='orange')
+
+# Adjust figure size using the scatter x and y coordinates
+##############################################################################
+def adjust_figure_size():
+    print(source.data, source)
+    x_min = 1.25*np.min(source.data['x'])
+    x_max = 1.25*np.max(source.data['x'])
+    y_min = 1.25*np.min(source.data['y'])
+    y_max = 1.25*np.max(source.data['y'])
+    aspect_ratio = (x_max-x_min)/(y_max-y_min)
+    print('Aspect ratio (x/y) of the embedding: ' + str(aspect_ratio))
+    print('Adjusting figure width based on the aspect ratio.')
+    print('MAX_FIG_WIDTH = ' + str(MAX_FIG_WIDTH))
+    print('MAX_FIG_HEIGHT = ' + str(MAX_FIG_HEIGHT))
+    if aspect_ratio >= 1:
+        fig.height = int(1.25*MAX_FIG_WIDTH/aspect_ratio)
+        fig.width = int(1.25*MAX_FIG_WIDTH)
+    else:
+        fig.height = int(1.25*MAX_FIG_HEIGHT)
+        fig.width = int(1.25*aspect_ratio*MAX_FIG_HEIGHT)
+
+    fig.x_range = Range1d(x_min, x_max, bounds=(x_min, x_max))
+    fig.y_range = Range1d(y_min, y_max, bounds=(y_min, y_max))
+
+# Patch dragging logic
+##############################################################################
+dragging = {
+    'active': False, 'start_x': None, 'start_y': None,
+    'patch_start_x': None, 'patch_start_y': None
+}
+def on_pan_start(event):
+    global cut_and_paste_obj
+    selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
+    if len(selected_pts_to_move) == 0:
+        return
+    dragging['active'] = True
+    dragging['start_x'] = event.x
+    dragging['start_y'] = event.y
+    dragging['patch_start_x'] = np.array(patch_source.data['x']).copy()
+    dragging['patch_start_y'] = np.array(patch_source.data['y']).copy()
+
+def on_pan(event):
+    global cut_and_paste_obj
+    selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
+    if not dragging['active'] or len(selected_pts_to_move) == 0:
+        return
+
+    dx = event.x - dragging['start_x']
+    dy = event.y - dragging['start_y']
+    new_x = np.array(patch_source.data['x'])+dx
+    new_y = np.array(patch_source.data['y'])+dy
+    x_out_of_bounds = np.any(new_x < fig.x_range.bounds[0]) | np.any(new_x > fig.x_range.bounds[1])
+    y_out_of_bounds = np.any(new_y < fig.y_range.bounds[0]) | np.any(new_y > fig.y_range.bounds[1])
+    if not (x_out_of_bounds or y_out_of_bounds):
+        patch_source.data.update(
+            x=(new_x).tolist(),
+            y=(new_y).tolist()
+        )
+    dragging['start_x'] = event.x
+    dragging['start_y'] = event.y
+
+def on_pan_end(event):
+    dragging['active'] = False
+    global cut_and_paste_obj
+    selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
+    if len(selected_pts_to_move) == 0:
+        return
+    dx = np.mean(np.array(patch_source.data['x']) - dragging['patch_start_x'])
+    dy = np.mean(np.array(patch_source.data['y']) - dragging['patch_start_y'])
+    new_x = source.data['x']
+    new_y = source.data['y']
+    for i in selected_pts_to_move:
+       new_x[i] += dx
+       new_y[i] += dy
+    source.data.update(x=new_x, y=new_y)
+    
+fig.on_event(PanStart, on_pan_start)
+fig.on_event(Pan, on_pan)
+fig.on_event(PanEnd, on_pan_end)
+
+# Buttons
+#############################################################################
+# Rotate patch button
+#######################################
+def rotate_coords(x, y, cx, cy, angle):
+    x1 = x - cx
+    y1 = y - cy
+    x_rot = x1 * np.cos(angle) - y1 * np.sin(angle) + cx
+    y_rot = x1 * np.sin(angle) + y1 * np.cos(angle) + cy
+    x_out_of_bounds = np.any(x_rot < fig.x_range.bounds[0]) | np.any(x_rot > fig.x_range.bounds[1])
+    y_out_of_bounds = np.any(y_rot < fig.y_range.bounds[0]) | np.any(y_rot > fig.y_range.bounds[1])
+    if x_out_of_bounds or y_out_of_bounds:
+        return x, y
+    return x_rot, y_rot
+
+def rotate_patch(angle_degrees):
+    global cut_and_paste_obj
+    selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
+    indices = selected_pts_to_move
+    if len(indices)==0:
+        return
+    x = np.array(source.data['x'])
+    y = np.array(source.data['y'])
+    cx = np.mean(x[indices])
+    cy = np.mean(y[indices])
+    angle = np.deg2rad(angle_degrees)
+    x[indices], y[indices] = rotate_coords(x[indices], y[indices], cx, cy, angle)
+    source.data.update(x=x.tolist(), y=y.tolist())
+
+    patch_x = np.array(patch_source.data['x'])
+    patch_y = np.array(patch_source.data['y'])
+    patch_x, patch_y = rotate_coords(patch_x, patch_y, cx, cy, angle)
+    patch_source.data.update(x=patch_x.tolist(), y=patch_y.tolist())
+
+rotate_cw_button.on_click(lambda: rotate_patch(-rot_deg))
+rotate_ccw_button.on_click(lambda: rotate_patch(rot_deg))
+
+# Start
+#######################################
+def start_start():
+    start_button.disabled = True
+
+def process_additional_options():
+    try:
+        # Safely evaluate the input string
+        user_dict = ast.literal_eval(options_input.value)
+        if isinstance(user_dict, dict):
+            print(f"Parsed dictionary: {user_dict}")
+        else:
+            print("Error: Input is not a dictionary.")
+    except Exception as e:
+        print(f"Invalid input: {e}")
+    return user_dict
+
+def path_exists(path):
+    return os.path.exists(path) or os.path.islink(path)
+
+def read(fpath, verbose=True):
+    if not path_exists(fpath):
+        if verbose:
+            print(fpath, 'does not exist.')
+        return None
+    with open(fpath, "rb") as f:
+        data = pickle.load(f)
+    if verbose:
+        print('Read data from', fpath, flush=True)
+    return data
+
+def start_main():
+    gen_data_path = gen_data_path_input.value.strip()
+    algo = algo_input.value.strip()
+    hyp_param = hyp_param_input.value.strip()
+    buml_obj_info_path = gen_data_path + '/' + algo + '/' + hyp_param + '/' + algo + '.dat'
+    save_dir = gen_data_path + '/' + algo + '/' + hyp_param + '_' + REG_TEAR_TAG
+    options = process_additional_options()
+    print('buml_obj_info_path=' + buml_obj_info_path)
+    print('save_dir=' + save_dir)
+    global cut_and_paste_obj
+    emb_info, metadata = read(buml_obj_info_path)
+    cut_and_paste_obj = cut_and_paste_bokeh.CutAndPaste(
+        model=emb_info['model'],
+        y=emb_info['y'], color_of_pts_on_tear=emb_info['color_of_pts_on_tear'],
+        save_progress_dir=save_dir,
+        max_refinement_iter=options['max_refinement_iter'],
+        force_compute=options['force_compute'],
+        cmap_interior=options['cmap_interior'],
+        cmap_tear=options['cmap_tear'],
+    )
+    source.data = cut_and_paste_obj.get_current_embedding_data()
+
+def start_end():
+    patch_source.data = dict(x=[], y=[])
+    start_button.disabled = False
+    cut_button.disabled = False
+    update_max_fig_height_button.disabled = False
+    fig.toolbar.active_inspect = None
+    fig.toolbar.active_drag = lasso_tool
+    print_main_log('Select region to cut using lasso and then press cut.')
+
+def start():
+    curdoc().add_next_tick_callback(show_spinner)
+    curdoc().add_next_tick_callback(start_start)
+    curdoc().add_next_tick_callback(start_main)
+    curdoc().add_next_tick_callback(start_end)
+    curdoc().add_next_tick_callback(adjust_figure_size)
+    curdoc().add_next_tick_callback(hide_spinner)
+
+def on_start_button_click():
+    curdoc().add_next_tick_callback(start)
+
+start_button.on_click(on_start_button_click)
+
+# Cut
+#######################################
+def cut_start():
+    fig.toolbar.active_drag = None
+    cut_button.disabled = True
+    save_button.disabled = True
+
+def cut_main():
+    global cut_and_paste_obj
+    patch_source.data = cut_and_paste_obj.cut_clusters_to_move(source.selected.indices)
+    source.selected.indices = cut_and_paste_obj.selected_pts_to_move.tolist()
+    print('len(source.selected.indices) = ' + str(len(source.selected.indices)))
+
+def cut_end():
+    paste_button.disabled = False
+    rotate_cw_button.disabled = False
+    rotate_ccw_button.disabled = False
+    print_main_log('Drag and rotate the polygonal patch, and then press paste.')
+
+def cut():
+    curdoc().add_next_tick_callback(show_spinner)
+    curdoc().add_next_tick_callback(cut_start)
+    curdoc().add_next_tick_callback(cut_main)
+    curdoc().add_next_tick_callback(cut_end)
+    curdoc().add_next_tick_callback(adjust_figure_size)
+    curdoc().add_next_tick_callback(hide_spinner)
+
+def on_cut_button_click():
+    curdoc().add_next_tick_callback(cut)
+
+cut_button.on_click(on_cut_button_click)
+
+# Paste
+#######################################
+def paste_start():
+    paste_button.disabled = True
+    rotate_cw_button.disabled = True
+    rotate_ccw_button.disabled = True
+
+def paste_end():
+    cut_button.disabled = False
+    save_button.disabled = False
+    patch_source.data = dict(x=[], y=[])
+    fig.toolbar.active_drag = lasso_tool
+
+def paste_main():
+    global cut_and_paste_obj
+    patch_x = np.array(patch_source.data['x'])
+    patch_y = np.array(patch_source.data['y'])
+    final_polyg = np.column_stack([patch_x, patch_y])
+    source.data = cut_and_paste_obj.paste_clusters(final_polyg)
+
+def paste():
+    curdoc().add_next_tick_callback(show_spinner)
+    curdoc().add_next_tick_callback(paste_start)
+    curdoc().add_next_tick_callback(paste_main)
+    curdoc().add_next_tick_callback(paste_end)
+    curdoc().add_next_tick_callback(adjust_figure_size)
+    curdoc().add_next_tick_callback(hide_spinner)
+
+def on_paste_button_click():
+    curdoc().add_next_tick_callback(paste)
+
+paste_button.on_click(on_paste_button_click)
+
+# Save
+#######################################
+def save():
+    algo = algo_input.value.strip()
+    global cut_and_paste_obj
+    cut_and_paste_obj.save_buml_obj(algo+'.dat')
+
+def on_save_button_click():
+    curdoc().add_next_tick_callback(save)
+
+save_button.on_click(on_save_button_click)
+
+# Update max figure height
+#######################################
+def update_max_fig_height():
+    global MAX_FIG_HEIGHT
+    global MAX_FIG_WIDTH
+    MAX_FIG_HEIGHT = int(max_fig_height_input.value.strip())
+    MAX_FIG_WIDTH = MAX_FIG_HEIGHT
+
+def on_update_max_fig_height_button_click():
+    curdoc().add_next_tick_callback(update_max_fig_height)
+    curdoc().add_next_tick_callback(adjust_figure_size)
+
+update_max_fig_height_button.on_click(on_update_max_fig_height_button_click)
+
+
+# Put everythig together in a doc
+#########################################################
+curdoc().add_root(
+    column(
+        main_log_div,
+        row(gen_data_path_input),
+        row(algo_input, hyp_param_input, options_input, max_fig_height_input), 
+        row(update_max_fig_height_button, start_button, cut_button, paste_button, save_button),
+        row(rotate_cw_button, rotate_ccw_button),
+        spinner,
+        fig,
+        log_div
+    )
+)
\ No newline at end of file
diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index a19e450..5712f3c 100755
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -1385,7 +1385,6 @@ def compute_final_embedding(
     tol,
     nu,
     k,
-    metric,
     alpha,
     repel_by,
     repel_decay,
@@ -1465,7 +1464,7 @@ def compute_final_embedding(
     ):
 
         if to_tear:
-            Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu, metric)
+            Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu)
             Utilde_t = Utildeg.multiply(Utilde)
             Utilde_t.eliminate_zeros()
 
@@ -1504,7 +1503,7 @@ def compute_final_embedding(
             repel_by *= repel_decay
 
     if to_tear:
-        Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu, metric)
+        Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu)
         return y, Utildeg
 
     return y, None
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 1863393..86dde30 100755
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -324,18 +324,18 @@ def fit_transform(self, X, condition_num=None):
         # Construct intermediate views
         if self.verbose:
             print(f"[{current_step}/{n_steps}] Clustering intermediate views...")
-        c, n_C = self._fit_intermediate_views()
+        n_C = self._fit_intermediate_views()
         current_step += 1
 
         # Construct Global views
         if self.verbose:
             print(f"[{current_step}/{n_steps}] Aligning global views...")
-        y, labels = self._fit_global_views(c, n_C)
+        y, labels = self._fit_global_views(n_C)
         if labels is not None:
             return y, labels
         return y
 
-    def compute_color_of_pts_on_tear(self, y, tear_color_eig_inds=[0, 1, 2]):
+    def compute_color_of_pts_on_tear(self, y, tear_color_eig_inds=[1]):
         """Compute glueing instructions for the tear.
 
         Parameters
@@ -567,16 +567,13 @@ def _fit_intermediate_views(self):
         self.C = C
         self.c = c
 
-        return c, n_C
+        return n_C
 
-    def _fit_global_views(self, c, n_C):
+    def _fit_global_views(self, n_C):
         """Align intermediate clusters via Riemannian gradient descent.
 
         Parameters
         ----------
-        c : array-like, shape (n_samples)
-            Holds the cluster index for each datapoint.
-
         n_C: array-like, shape (n_clusters)
             Holds the number of datapoints per cluster.
 
@@ -592,7 +589,7 @@ def _fit_global_views(self, c, n_C):
         self.n_Utilde_Utilde = n_Utilde_Utilde
 
         # Compute sequence of intermedieate views
-        seq_of_intermed_views_in_cluster, parents_of_intermed_views_in_cluster, _ = (
+        self.seq_of_intermed_views_in_cluster, parents_of_intermed_views_in_cluster, _ = (
             compute_seq_of_views(
                 self.d,
                 self.Utilde,
@@ -608,12 +605,12 @@ def _fit_global_views(self, c, n_C):
         )
 
         # Compute initial embedding
-        y_init, far_off_points = compute_init_embedding(
+        y_init, self.far_off_points = compute_init_embedding(
             self.d,
             self.neighborhood_graph_sym,
             self.Utilde,
             self.param,
-            seq_of_intermed_views_in_cluster,
+            self.seq_of_intermed_views_in_cluster,
             parents_of_intermed_views_in_cluster,
             self.C,
             self.to_tear,
@@ -627,7 +624,7 @@ def _fit_global_views(self, c, n_C):
         )
 
         # apply RGD
-        y_final, Utildeg = compute_final_embedding(
+        y_final, self.Utildeg = compute_final_embedding(
             y_init,
             self.d,
             self.Utilde,
@@ -640,20 +637,17 @@ def _fit_global_views(self, c, n_C):
             self.tol,
             self.nu,
             self.k,
-            self.metric,
             self.alpha,
             self.repel_by,
             self.repel_decay,
-            far_off_points,
+            self.far_off_points,
             self.verbose,
         )
 
         labels = add_spacing_between_clusters(
-            y_final, seq_of_intermed_views_in_cluster, self.param, self.C
+            y_final, self.seq_of_intermed_views_in_cluster, self.param, self.C
         )
 
-        self.Utildeg = Utildeg
-
         return y_final, labels
 
     def _postprocess(self):

From dfbb2d62d26a4bc5808bd30580e2be3c51737753 Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Thu, 11 Jun 2026 09:29:35 +0200
Subject: [PATCH 07/20] fix: use cmap1 in global_embedding

---
 examples/vis.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/vis.py b/examples/vis.py
index 03f84de..663c297 100644
--- a/examples/vis.py
+++ b/examples/vis.py
@@ -2059,6 +2059,7 @@ def global_embedding(
                         y[pts_on_tear, 0],
                         y[pts_on_tear, 1],
                         s=s,
+                        cmap=cmap1,
                         c=color_of_pts_on_tear[pts_on_tear],
                         vmin=None,
                         vmax=None,

From 02effaf2e7ccb4270db47e46954f02ed2fdf87aa Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Thu, 11 Jun 2026 09:40:55 +0200
Subject: [PATCH 08/20] fix: add_spacing_between_clusters every iter

---
 src/pyRATS/_utils.py |  9 +++++++--
 src/pyRATS/rats.py   | 11 ++++++-----
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/pyRATS/_utils.py b/src/pyRATS/_utils.py
index 5712f3c..6f6bc7f 100755
--- a/src/pyRATS/_utils.py
+++ b/src/pyRATS/_utils.py
@@ -1389,6 +1389,7 @@ def compute_final_embedding(
     repel_by,
     repel_decay,
     far_off_points,
+    seq_of_intermed_views_in_cluster,
     verbose,
 ):
     """Align clusters via Riemannian Gradient Descent.
@@ -1502,11 +1503,15 @@ def compute_final_embedding(
         if repel_by is not None:
             repel_by *= repel_decay
 
+        labels = add_spacing_between_clusters(
+            y, seq_of_intermed_views_in_cluster, param, C
+        )
+
     if to_tear:
         Utildeg = compute_incidence_matrix_in_embedding(y, C, k, nu)
-        return y, Utildeg
+        return y, Utildeg, labels
 
-    return y, None
+    return y, None, labels
 
 
 def rgd_alignment(
diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 86dde30..4f192ea 100755
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -623,8 +623,12 @@ def _fit_global_views(self, n_C):
             self.verbose,
         )
 
+        _ = add_spacing_between_clusters(
+            y_init, self.seq_of_intermed_views_in_cluster, self.param, self.C
+        )
+
         # apply RGD
-        y_final, self.Utildeg = compute_final_embedding(
+        y_final, self.Utildeg, labels = compute_final_embedding(
             y_init,
             self.d,
             self.Utilde,
@@ -641,13 +645,10 @@ def _fit_global_views(self, n_C):
             self.repel_by,
             self.repel_decay,
             self.far_off_points,
+            self.seq_of_intermed_views_in_cluster,
             self.verbose,
         )
 
-        labels = add_spacing_between_clusters(
-            y_final, self.seq_of_intermed_views_in_cluster, self.param, self.C
-        )
-
         return y_final, labels
 
     def _postprocess(self):

From ed7d717c1210c710be4f096516d65e21c37cd59d Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Thu, 11 Jun 2026 09:41:38 +0200
Subject: [PATCH 09/20] fix: sort indices of sparse matrices for determinism

---
 src/pyRATS/rats.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 4f192ea..61e1e19 100755
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -552,6 +552,7 @@ def _fit_intermediate_views(self):
                 self.param.model = self.param.model[non_empty_C]
 
             Utilde = C.dot(self.U)
+            Utilde.sort_indices() # determinism
 
             np.random.seed(42)
             self.param.noise_seed = np.random.randint(M * M, size=M)
@@ -586,6 +587,7 @@ def _fit_global_views(self, n_C):
         # Compute |Utilde_{mm'}|
         n_Utilde_Utilde = self.Utilde.dot(self.Utilde.transpose())
         n_Utilde_Utilde.setdiag(0)
+        n_Utilde_Utilde.sort_indices() # determinism
         self.n_Utilde_Utilde = n_Utilde_Utilde
 
         # Compute sequence of intermedieate views

From 6e313b2880e7d91a349059f345e3147a4df05f8c Mon Sep 17 00:00:00 2001
From: ffOj <joshua.offergeld@googlemail.com>
Date: Thu, 11 Jun 2026 09:44:56 +0200
Subject: [PATCH 10/20] feat: switch tear default to False

---
 src/pyRATS/rats.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pyRATS/rats.py b/src/pyRATS/rats.py
index 61e1e19..9b24ef9 100755
--- a/src/pyRATS/rats.py
+++ b/src/pyRATS/rats.py
@@ -57,7 +57,7 @@ class RATS:
     max_cluster_size : int, default=25
         Maximum allowed size of the clusters. The value must be > min_cluster_size.
 
-    tear : bool, default=True
+    tear : bool, default=False
         Whether to tear the manifold.
 
     nu : int, default=3
@@ -137,7 +137,7 @@ def __init__(
         postprocess=True,
         min_cluster_size=5,
         max_cluster_size=25,
-        tear=True,
+        tear=False,
         nu=3,
         align_w_parent_only=True,
         tree="mst",

From 8ac5084d208d3b56871450e715ec4f72d8b65edc Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Fri, 12 Jun 2026 14:26:18 +0200
Subject: [PATCH 11/20] fix: various small fixes

---
 examples/cut_and_paste_app.py | 493 +++++++++++++++++++++-------------
 1 file changed, 307 insertions(+), 186 deletions(-)

diff --git a/examples/cut_and_paste_app.py b/examples/cut_and_paste_app.py
index 6b06a8f..53fb3aa 100644
--- a/examples/cut_and_paste_app.py
+++ b/examples/cut_and_paste_app.py
@@ -1,9 +1,19 @@
-#To run the app, execute
+# To run the app, execute
 # bokeh serve cut_and_paste_app.py --allow-websocket-origin=localhost:5006
 # then go to http://localhost:5006
 
 from bokeh.plotting import figure, curdoc
-from bokeh.models import LassoSelectTool, TapTool, TextInput, Button, Div, ColumnDataSource, TextAreaInput, Range1d, CustomJS
+from bokeh.models import (
+    LassoSelectTool,
+    TapTool,
+    TextInput,
+    Button,
+    Div,
+    ColumnDataSource,
+    TextAreaInput,
+    Range1d,
+    CustomJS,
+)
 from bokeh.plotting import figure
 from bokeh.layouts import row, column
 from bokeh.events import PanStart, Pan, PanEnd
@@ -15,62 +25,68 @@
 from matplotlib.patches import Polygon
 
 import os
+import sys
 import pickle
 
 from scipy.spatial import ConvexHull
 import vis
 from vis import maximize_window
 
-import sys
-sys.path.insert(0, 'src/')    # TODO: rely on pip install
-import os
-import pickle
-from cut_and_paste import cut_and_paste_bokeh
 
+from pyRATS._utils import (
+    procrustes,
+    compute_final_embedding,
+    add_spacing_between_clusters,
+)
 
-from pyRATS._utils import procrustes, compute_final_embedding, add_spacing_between_clusters
+QUIT_KEY = "q"
+ENTER_KEY = "enter"
 
-QUIT_KEY = 'q'
-ENTER_KEY = 'enter'
 
 def rgba_to_css(rgba):
     r, g, b, a = rgba
     return f"rgba({int(r*255)}, {int(g*255)}, {int(b*255)}, {a:.2f})"
 
+
 def rgba_arr_to_css_arr(rgba_arr):
     css_arr = []
     for i in range(rgba_arr.shape[0]):
-        css_arr.append(rgba_to_css(rgba_arr[i,:]))
+        css_arr.append(rgba_to_css(rgba_arr[i, :]))
     return css_arr
 
+
 def path_exists(path):
     return os.path.exists(path) or os.path.islink(path)
 
+
 def makedirs(dirpath):
     if path_exists(dirpath):
         return
     os.makedirs(dirpath)
 
+
 def save(dirpath, fname, data, verbose=True):
     if not path_exists(dirpath):
         os.makedirs(dirpath)
-    fpath = dirpath + '/' + fname
+    fpath = dirpath + "/" + fname
     with open(fpath, "wb") as f:
         pickle.dump(data, f)
     if verbose:
-        print('Saved data in', fpath, flush=True)
+        print("Saved data in", fpath, flush=True)
+
 
 def read(fpath, verbose=True):
     if not path_exists(fpath):
         if verbose:
-            print(fpath, 'does not exist.')
+            print(fpath, "does not exist.")
         return None
     with open(fpath, "rb") as f:
         data = pickle.load(f)
     if verbose:
-        print('Read data from', fpath, flush=True)
+        print("Read data from", fpath, flush=True)
     return data
 
+
 def create_mask(inds, n):
     temp = np.zeros(n, dtype=bool)
     temp[inds] = 1
@@ -84,11 +100,11 @@ def __init__(
         y,
         color_of_pts_on_tear,
         metadata_fname=None,
-        save_progress_dir='',
-        cmap_interior='summer',
-        cmap_tear='jet',
+        save_progress_dir="",
+        cmap_interior="summer",
+        cmap_tear="jet",
         max_refinement_iter=10,
-        force_compute=False
+        force_compute=False,
     ):
         self.model = model
         self.y = y
@@ -110,11 +126,13 @@ def __init__(
 
     def init_metadata_for_current_iter(self):
         if len(self.metadata) <= self.cur_iter:
-            self.metadata.append({
-                'selected_cluster_mask': None,
-                'init_polygon': None,
-                'final_polygon': None
-            })
+            self.metadata.append(
+                {
+                    "selected_cluster_mask": None,
+                    "init_polygon": None,
+                    "final_polygon": None,
+                }
+            )
 
     def get_current_embedding_data(self):
         y = self.y.copy()
@@ -122,29 +140,36 @@ def get_current_embedding_data(self):
         cmap_interior = self.cmap_interior
         cmap_tear = self.cmap_tear
 
-        matplotlib.use('Agg')
+        matplotlib.use("Agg")
         color_of_pts_on_tear = self.color_of_pts_on_tear
-        pts_on_tear = ~np.isnan(color_of_pts_on_tear[:,-1])
+        pts_on_tear = ~np.isnan(color_of_pts_on_tear[:, -1])
 
         interior_handle, tear_handle = vis.Visualize().global_embedding_for_gui(
-            y, y[:,0], cmap0=cmap_interior,
-            color_of_pts_on_tear=color_of_pts_on_tear[:,-1],
+            y,
+            y[:, 0],
+            cmap0=cmap_interior,
+            color_of_pts_on_tear=color_of_pts_on_tear[:, -1],
             cmap1=cmap_tear,
             set_title=True,
-            figsize=(3,3), s=20
+            figsize=(3, 3),
+            s=20,
         )
         if self.save_progress_dir:
-            save_fn = self.save_progress_dir + '/reg_tear_y_at_iter=' + str(self.cur_iter) + '.png'
-            plt.savefig(save_fn, bbox_inches='tight', dpi=400)
+            save_fn = (
+                self.save_progress_dir
+                + "/reg_tear_y_at_iter="
+                + str(self.cur_iter)
+                + ".png"
+            )
+            plt.savefig(save_fn, bbox_inches="tight", dpi=400)
 
         y_face_color = interior_handle._facecolors
-        y_face_color[pts_on_tear,:] = tear_handle.get_facecolors()
+        y_face_color[pts_on_tear, :] = tear_handle.get_facecolors()
 
         self.y_face_color = y_face_color
 
         source_data_dict = dict(
-            x=y[:,0], y=y[:,1],
-            color=rgba_arr_to_css_arr(y_face_color)
+            x=y[:, 0], y=y[:, 1], color=rgba_arr_to_css_arr(y_face_color)
         )
         return source_data_dict
 
@@ -152,110 +177,124 @@ def get_encolsing_polygon_for_selected_pts(self, selected_pts_indices):
         selected_cluster_mask = self.select_clusters_to_move(selected_pts_indices)
         points_in_selected_clusters = selected_cluster_mask[self.model.c]
         y = self.y.copy()
-        init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters,:])
-        patch_source_data_dict = dict(x=init_polyg[:,0], y=init_polyg[:,1])
+        init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters, :])
+        patch_source_data_dict = dict(x=init_polyg[:, 0], y=init_polyg[:, 1])
         return patch_source_data_dict
-    
+
     # There is one to one correspondence between
     # clusters/partitions and local views
     def cut_clusters_to_move(self, selected_pts_indices):
         self.init_metadata_for_current_iter()
-        if self.force_compute or (self.metadata[self.cur_iter]['selected_cluster_mask'] is None):
+        if self.force_compute or (
+            self.metadata[self.cur_iter]["selected_cluster_mask"] is None
+        ):
             selected_cluster_mask = self.select_clusters_to_move(selected_pts_indices)
-            self.metadata[self.cur_iter]['selected_cluster_mask'] = selected_cluster_mask
+            self.metadata[self.cur_iter][
+                "selected_cluster_mask"
+            ] = selected_cluster_mask
         else:
-            selected_cluster_mask = self.metadata[self.cur_iter]['selected_cluster_mask']
+            selected_cluster_mask = self.metadata[self.cur_iter][
+                "selected_cluster_mask"
+            ]
         points_in_selected_clusters = np.where(selected_cluster_mask[self.model.c])[0]
         self.selected_pts_to_move = points_in_selected_clusters
 
         # Find a convex polygon that represents the points in the selected clusters
         y = self.y.copy()
-        if self.force_compute or (self.metadata[self.cur_iter]['init_polygon'] is None):
-            init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters,:])
-            self.metadata[self.cur_iter]['init_polygon'] = init_polyg
+        if self.force_compute or (self.metadata[self.cur_iter]["init_polygon"] is None):
+            init_polyg = get_convex_covering_polygon(y[points_in_selected_clusters, :])
+            self.metadata[self.cur_iter]["init_polygon"] = init_polyg
         else:
-            init_polyg = self.metadata[self.cur_iter]['init_polygon']
+            init_polyg = self.metadata[self.cur_iter]["init_polygon"]
 
         if self.save_progress_dir:
-            self.save_polygon(y, self.y_face_color, init_polyg, stage='init')
+            self.save_polygon(y, self.y_face_color, init_polyg, stage="init")
 
-        patch_source_data_dict = dict(x=init_polyg[:,0], y=init_polyg[:,1])
+        patch_source_data_dict = dict(x=init_polyg[:, 0], y=init_polyg[:, 1])
         return patch_source_data_dict
 
     def select_clusters_to_move(self, selected_pts_indices):
         cluster_label = self.model.c
         selected_pts_mask = create_mask(selected_pts_indices, len(cluster_label))
         avoid_clusters = np.unique(cluster_label[~selected_pts_mask])
-        n_clusters = np.max(cluster_label)+1
+        n_clusters = np.max(cluster_label) + 1
         avoid_clusters_mask = create_mask(avoid_clusters, n_clusters)
         return ~avoid_clusters_mask
 
     def paste_clusters(self, final_polyg):
-        if self.force_compute or (self.metadata[self.cur_iter]['final_polygon'] is None):
-            self.metadata[self.cur_iter]['final_polygon'] = final_polyg
+        if self.force_compute or (
+            self.metadata[self.cur_iter]["final_polygon"] is None
+        ):
+            self.metadata[self.cur_iter]["final_polygon"] = final_polyg
         else:
-            final_polyg = self.metadata[self.cur_iter]['final_polygon']
+            final_polyg = self.metadata[self.cur_iter]["final_polygon"]
 
         # Use the final location of the polygon to compute the
         # final location of the points in the selected clusters
-        selected_cluster_mask = self.metadata[self.cur_iter]['selected_cluster_mask']
+        selected_cluster_mask = self.metadata[self.cur_iter]["selected_cluster_mask"]
         points_in_selected_clusters = selected_cluster_mask[self.model.c]
         y = self.y.copy()
         y_new = self.recompute_embedding(
-            y, points_in_selected_clusters,
-            self.metadata[self.cur_iter]['init_polygon'],
-            final_polyg
+            y,
+            points_in_selected_clusters,
+            self.metadata[self.cur_iter]["init_polygon"],
+            final_polyg,
         )
         if self.save_progress_dir:
-            self.save_polygon(y_new, self.y_face_color, final_polyg, stage='final')
-        
+            self.save_polygon(y_new, self.y_face_color, final_polyg, stage="final")
+
         self.finish_pasting(y_new)
         # reset
         self.selected_pts_to_move = np.array([])
         return self.get_current_embedding_data()
 
     def finish_pasting(self, y_new):
-        matplotlib.use('Agg')
-        print('Refining...', flush=True)
+        matplotlib.use("Agg")
+        print("Refining...", flush=True)
         model = self.model
         model.n_iter = self.max_refinement_iter
-        self.y, model.Utildeg = compute_final_embedding(
-            y_new, model.d, model.Utilde,
+        self.y, model.Utildeg, _ = compute_final_embedding(
+            y_new,
+            model.d,
+            model.Utilde,
             model.C,
-            model.param, 
+            model.param,
             model.to_tear,
             model.patience,
-            model.max_iter, 
-            model.max_internal_iter, 
-            model.tol, 
-            model.nu, 
-            model.k,  
-            model.alpha, 
-            model.repel_by, 
+            model.max_iter,
+            model.max_internal_iter,
+            model.tol,
+            model.nu,
+            model.k,
+            model.alpha,
+            model.repel_by,
             model.repel_decay,
             model.far_off_points,
+            model.seq_of_intermed_views_in_cluster,
             model.verbose,
         )
         _ = add_spacing_between_clusters(
             self.y, model.seq_of_intermed_views_in_cluster, model.param, model.C
         )
         self.color_of_pts_on_tear = model.compute_color_of_pts_on_tear(self.y)
-        
+
         self.save_buml_obj(
-            'buml_obj_and_metadata_after_iter='+str(self.cur_iter)+'.dat', 
+            "buml_obj_and_metadata_after_iter=" + str(self.cur_iter) + ".dat",
         )
         self.cur_iter += 1
 
     def save_buml_obj(self, fname):
         if self.save_progress_dir:
             new_emb_info = {
-                'y': self.y,
-                'color_of_pts_on_tear': self.color_of_pts_on_tear,
-                'model': self.model,
+                "y": self.y,
+                "color_of_pts_on_tear": self.color_of_pts_on_tear,
+                "model": self.model,
             }
             save(self.save_progress_dir, fname, [new_emb_info, self.metadata])
 
-    def recompute_embedding(self, y, points_in_moving_clusters, init_polyg, final_polyg):
+    def recompute_embedding(
+        self, y, points_in_moving_clusters, init_polyg, final_polyg
+    ):
         # init_polyg_centroid = np.mean(init_polyg, axis=0)
         # final_polyg_centroid = np.mean(final_polyg, axis=0)
         # t = final_polyg_centroid - init_polyg_centroid
@@ -265,38 +304,48 @@ def recompute_embedding(self, y, points_in_moving_clusters, init_polyg, final_po
         # O = VT.dot(U.T) # TODO: check
         O, t = procrustes(init_polyg, final_polyg)
         y = y.copy()
-        y[points_in_moving_clusters,:] = y[points_in_moving_clusters,:].dot(O) + t[None,:]
+        y[points_in_moving_clusters, :] = (
+            y[points_in_moving_clusters, :].dot(O) + t[None, :]
+        )
         return y
-    
+
     def save_polygon(self, y, y_face_color, y_polyg, stage, s=20):
-        assert stage in ['init', 'final']
-        matplotlib.use('Agg')
+        assert stage in ["init", "final"]
+        matplotlib.use("Agg")
         _, ax = plt.subplots()
         maximize_window()
-        ax.scatter(y[:,0], y[:,1], c=y_face_color, s=s)
-        polyg = Polygon(y_polyg, color=[1,0,0,0.25])
+        ax.scatter(y[:, 0], y[:, 1], c=y_face_color, s=s)
+        polyg = Polygon(y_polyg, color=[1, 0, 0, 0.25])
         ax.add_patch(polyg)
-        plt.axis('image')
-        plt.axis('off')
+        plt.axis("image")
+        plt.axis("off")
         plt.tight_layout()
         ax.set_rasterized(True)
-        save_fn = self.save_progress_dir + '/' + stage + '_polyg_at_iter=' + str(self.cur_iter) + '.png'
-        plt.savefig(save_fn, bbox_inches='tight', dpi=400)
+        save_fn = (
+            self.save_progress_dir
+            + "/"
+            + stage
+            + "_polyg_at_iter="
+            + str(self.cur_iter)
+            + ".png"
+        )
+        plt.savefig(save_fn, bbox_inches="tight", dpi=400)
+
 
 def get_convex_covering_polygon(y):
     hull = ConvexHull(y)
-    return y[hull.vertices,:]
-
+    return y[hull.vertices, :]
 
 
 # APP itself
 ###############################################################
 
-REG_TEAR_TAG = 'reg_tear'
+REG_TEAR_TAG = "reg_tear"
 
 # Spinner using CSS
 ################################################################
-spinner = Div(text="""
+spinner = Div(
+    text="""
 <div id="spinner" style="display:none;">
   <div class="loader"></div>
 </div>
@@ -316,12 +365,19 @@ def get_convex_covering_polygon(y):
   100% { transform: rotate(360deg); }
 }
 </style>
-""", width=25, height=20)
+""",
+    width=25,
+    height=20,
+)
+
+
 def show_spinner():
-    spinner.text = spinner.text.replace('display:none;', 'display:block;')
+    spinner.text = spinner.text.replace("display:none;", "display:block;")
+
 
 def hide_spinner():
-    spinner.text = spinner.text.replace('display:block;', 'display:none;')
+    spinner.text = spinner.text.replace("display:block;", "display:none;")
+
 
 # Loggers
 ################################################################
@@ -341,6 +397,7 @@ def write(self, message):
     def flush(self):
         pass
 
+
 def get_scroll_js(div_name):
     scroll_js = CustomJS(code="""
         // Find the element by ID
@@ -355,33 +412,42 @@ def get_scroll_js(div_name):
 DIV_WIDTH = 900
 DIV_HEIGHT = 150
 log_div = Div(
-    text="", width=DIV_WIDTH, height=DIV_HEIGHT,
-    styles={'overflow-y': 'scroll', 'border': '1px solid black'},
-    name='log_div'
+    text="",
+    width=DIV_WIDTH,
+    height=DIV_HEIGHT,
+    styles={"overflow-y": "scroll", "border": "1px solid black"},
+    name="log_div",
 )
 log_div.js_on_change("text", get_scroll_js(log_div.name))
 sys.stdout = BokehLogger(log_div)
-print('<h3>Detailed logs are displayed here.</h3>')
+print("<h3>Detailed logs are displayed here.</h3>")
 
 main_log_div = Div(
-    text="", width=DIV_WIDTH, height=DIV_HEIGHT,
-    styles={'overflow-y': 'scroll', 'border': '1px solid black'},
-    name='main_log_div'
+    text="",
+    width=DIV_WIDTH,
+    height=DIV_HEIGHT,
+    styles={"overflow-y": "scroll", "border": "1px solid black"},
+    name="main_log_div",
 )
 main_log_div.js_on_change("text", get_scroll_js(main_log_div.name))
 main_log = BokehLogger(main_log_div)
+
+
 def print_main_log(message):
-    main_log.write(message + '\n')
+    main_log.write(message + "\n")
+
 
-print_main_log('<h3>Short logs & instructions are displayed here. Detiled logs are printed at the end of the page.</h3>')
-print_main_log('Input algorithm, hyperparameter and options, and then press start.')
+print_main_log(
+    "<h3>Short logs & instructions are displayed here. Detiled logs are printed at the end of the page.</h3>"
+)
+print_main_log("Input algorithm, hyperparameter and options, and then press start.")
 
 # Text inputs
 ################################################################
 gen_data_path_input = TextInput(
     title="Generated data path",
     value="/Users/joshuaoffergeld/Documents/pyRATS/examples",
-    width=550
+    width=550,
 )
 
 algo_input = TextInput(title="Algorithm Name: (for ex: rats)", value="rats")
@@ -397,13 +463,19 @@ def print_main_log(message):
 lasso_tool = LassoSelectTool()
 tap_tool = TapTool()
 
-update_max_fig_height_button = Button(label="Update height", button_type="success", disabled=True)
+update_max_fig_height_button = Button(
+    label="Update height", button_type="success", disabled=True
+)
 start_button = Button(label="Start", button_type="success")
 cut_button = Button(label="Cut", button_type="success", disabled=True)
 paste_button = Button(label="Paste", button_type="success", disabled=True)
 save_button = Button(label="Save", button_type="success", disabled=True)
-rotate_cw_button = Button(label="Rotate -" + str(rot_deg) + " deg", button_type="success", disabled=True)
-rotate_ccw_button = Button(label="Rotate +" + str(rot_deg) + " deg", button_type="success", disabled=True)
+rotate_cw_button = Button(
+    label="Rotate -" + str(rot_deg) + " deg", button_type="success", disabled=True
+)
+rotate_ccw_button = Button(
+    label="Rotate +" + str(rot_deg) + " deg", button_type="success", disabled=True
+)
 
 source = ColumnDataSource(data=dict(x=[], y=[], color=[]))
 patch_source = ColumnDataSource(data=dict(x=[], y=[]))
@@ -419,95 +491,102 @@ def print_main_log(message):
     y_axis_label="y",
     width=MAX_FIG_HEIGHT,
     height=MAX_FIG_WIDTH,
-    match_aspect=False
-)
-fig.scatter(
-    'x', 'y',
-    color='color',
-    source=source,
-    nonselection_alpha=0.3
+    match_aspect=False,
 )
-fig.patch('x', 'y', source=patch_source, alpha=0.4, line_width=2, color='orange')
+fig.scatter("x", "y", color="color", source=source, nonselection_alpha=0.3)
+fig.patch("x", "y", source=patch_source, alpha=0.4, line_width=2, color="orange")
+
 
 # Adjust figure size using the scatter x and y coordinates
 ##############################################################################
 def adjust_figure_size():
     print(source.data, source)
-    x_min = 1.25*np.min(source.data['x'])
-    x_max = 1.25*np.max(source.data['x'])
-    y_min = 1.25*np.min(source.data['y'])
-    y_max = 1.25*np.max(source.data['y'])
-    aspect_ratio = (x_max-x_min)/(y_max-y_min)
-    print('Aspect ratio (x/y) of the embedding: ' + str(aspect_ratio))
-    print('Adjusting figure width based on the aspect ratio.')
-    print('MAX_FIG_WIDTH = ' + str(MAX_FIG_WIDTH))
-    print('MAX_FIG_HEIGHT = ' + str(MAX_FIG_HEIGHT))
+    x_min = 1.25 * np.min(source.data["x"])
+    x_max = 1.25 * np.max(source.data["x"])
+    y_min = 1.25 * np.min(source.data["y"])
+    y_max = 1.25 * np.max(source.data["y"])
+    aspect_ratio = (x_max - x_min) / (y_max - y_min)
+    print("Aspect ratio (x/y) of the embedding: " + str(aspect_ratio))
+    print("Adjusting figure width based on the aspect ratio.")
+    print("MAX_FIG_WIDTH = " + str(MAX_FIG_WIDTH))
+    print("MAX_FIG_HEIGHT = " + str(MAX_FIG_HEIGHT))
     if aspect_ratio >= 1:
-        fig.height = int(1.25*MAX_FIG_WIDTH/aspect_ratio)
-        fig.width = int(1.25*MAX_FIG_WIDTH)
+        fig.height = int(1.25 * MAX_FIG_WIDTH / aspect_ratio)
+        fig.width = int(1.25 * MAX_FIG_WIDTH)
     else:
-        fig.height = int(1.25*MAX_FIG_HEIGHT)
-        fig.width = int(1.25*aspect_ratio*MAX_FIG_HEIGHT)
+        fig.height = int(1.25 * MAX_FIG_HEIGHT)
+        fig.width = int(1.25 * aspect_ratio * MAX_FIG_HEIGHT)
 
     fig.x_range = Range1d(x_min, x_max, bounds=(x_min, x_max))
     fig.y_range = Range1d(y_min, y_max, bounds=(y_min, y_max))
 
+
 # Patch dragging logic
 ##############################################################################
 dragging = {
-    'active': False, 'start_x': None, 'start_y': None,
-    'patch_start_x': None, 'patch_start_y': None
+    "active": False,
+    "start_x": None,
+    "start_y": None,
+    "patch_start_x": None,
+    "patch_start_y": None,
 }
+
+
 def on_pan_start(event):
     global cut_and_paste_obj
     selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
     if len(selected_pts_to_move) == 0:
         return
-    dragging['active'] = True
-    dragging['start_x'] = event.x
-    dragging['start_y'] = event.y
-    dragging['patch_start_x'] = np.array(patch_source.data['x']).copy()
-    dragging['patch_start_y'] = np.array(patch_source.data['y']).copy()
+    dragging["active"] = True
+    dragging["start_x"] = event.x
+    dragging["start_y"] = event.y
+    dragging["patch_start_x"] = np.array(patch_source.data["x"]).copy()
+    dragging["patch_start_y"] = np.array(patch_source.data["y"]).copy()
+
 
 def on_pan(event):
     global cut_and_paste_obj
     selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
-    if not dragging['active'] or len(selected_pts_to_move) == 0:
+    if not dragging["active"] or len(selected_pts_to_move) == 0:
         return
 
-    dx = event.x - dragging['start_x']
-    dy = event.y - dragging['start_y']
-    new_x = np.array(patch_source.data['x'])+dx
-    new_y = np.array(patch_source.data['y'])+dy
-    x_out_of_bounds = np.any(new_x < fig.x_range.bounds[0]) | np.any(new_x > fig.x_range.bounds[1])
-    y_out_of_bounds = np.any(new_y < fig.y_range.bounds[0]) | np.any(new_y > fig.y_range.bounds[1])
+    dx = event.x - dragging["start_x"]
+    dy = event.y - dragging["start_y"]
+    new_x = np.array(patch_source.data["x"]) + dx
+    new_y = np.array(patch_source.data["y"]) + dy
+    x_out_of_bounds = np.any(new_x < fig.x_range.bounds[0]) | np.any(
+        new_x > fig.x_range.bounds[1]
+    )
+    y_out_of_bounds = np.any(new_y < fig.y_range.bounds[0]) | np.any(
+        new_y > fig.y_range.bounds[1]
+    )
     if not (x_out_of_bounds or y_out_of_bounds):
-        patch_source.data.update(
-            x=(new_x).tolist(),
-            y=(new_y).tolist()
-        )
-    dragging['start_x'] = event.x
-    dragging['start_y'] = event.y
+        patch_source.data.update(x=(new_x).tolist(), y=(new_y).tolist())
+    dragging["start_x"] = event.x
+    dragging["start_y"] = event.y
+
 
 def on_pan_end(event):
-    dragging['active'] = False
+    dragging["active"] = False
     global cut_and_paste_obj
     selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
     if len(selected_pts_to_move) == 0:
         return
-    dx = np.mean(np.array(patch_source.data['x']) - dragging['patch_start_x'])
-    dy = np.mean(np.array(patch_source.data['y']) - dragging['patch_start_y'])
-    new_x = source.data['x']
-    new_y = source.data['y']
+    dx = np.mean(np.array(patch_source.data["x"]) - dragging["patch_start_x"])
+    dy = np.mean(np.array(patch_source.data["y"]) - dragging["patch_start_y"])
+    new_x = source.data["x"]
+    new_y = source.data["y"]
     for i in selected_pts_to_move:
-       new_x[i] += dx
-       new_y[i] += dy
+        new_x[i] += dx
+        new_y[i] += dy
     source.data.update(x=new_x, y=new_y)
-    
+
+
 fig.on_event(PanStart, on_pan_start)
 fig.on_event(Pan, on_pan)
 fig.on_event(PanEnd, on_pan_end)
 
+
 # Buttons
 #############################################################################
 # Rotate patch button
@@ -517,39 +596,47 @@ def rotate_coords(x, y, cx, cy, angle):
     y1 = y - cy
     x_rot = x1 * np.cos(angle) - y1 * np.sin(angle) + cx
     y_rot = x1 * np.sin(angle) + y1 * np.cos(angle) + cy
-    x_out_of_bounds = np.any(x_rot < fig.x_range.bounds[0]) | np.any(x_rot > fig.x_range.bounds[1])
-    y_out_of_bounds = np.any(y_rot < fig.y_range.bounds[0]) | np.any(y_rot > fig.y_range.bounds[1])
+    x_out_of_bounds = np.any(x_rot < fig.x_range.bounds[0]) | np.any(
+        x_rot > fig.x_range.bounds[1]
+    )
+    y_out_of_bounds = np.any(y_rot < fig.y_range.bounds[0]) | np.any(
+        y_rot > fig.y_range.bounds[1]
+    )
     if x_out_of_bounds or y_out_of_bounds:
         return x, y
     return x_rot, y_rot
 
+
 def rotate_patch(angle_degrees):
     global cut_and_paste_obj
     selected_pts_to_move = cut_and_paste_obj.selected_pts_to_move
     indices = selected_pts_to_move
-    if len(indices)==0:
+    if len(indices) == 0:
         return
-    x = np.array(source.data['x'])
-    y = np.array(source.data['y'])
+    x = np.array(source.data["x"])
+    y = np.array(source.data["y"])
     cx = np.mean(x[indices])
     cy = np.mean(y[indices])
     angle = np.deg2rad(angle_degrees)
     x[indices], y[indices] = rotate_coords(x[indices], y[indices], cx, cy, angle)
     source.data.update(x=x.tolist(), y=y.tolist())
 
-    patch_x = np.array(patch_source.data['x'])
-    patch_y = np.array(patch_source.data['y'])
+    patch_x = np.array(patch_source.data["x"])
+    patch_y = np.array(patch_source.data["y"])
     patch_x, patch_y = rotate_coords(patch_x, patch_y, cx, cy, angle)
     patch_source.data.update(x=patch_x.tolist(), y=patch_y.tolist())
 
+
 rotate_cw_button.on_click(lambda: rotate_patch(-rot_deg))
 rotate_ccw_button.on_click(lambda: rotate_patch(rot_deg))
 
+
 # Start
 #######################################
 def start_start():
     start_button.disabled = True
 
+
 def process_additional_options():
     try:
         # Safely evaluate the input string
@@ -562,42 +649,49 @@ def process_additional_options():
         print(f"Invalid input: {e}")
     return user_dict
 
+
 def path_exists(path):
     return os.path.exists(path) or os.path.islink(path)
 
+
 def read(fpath, verbose=True):
     if not path_exists(fpath):
         if verbose:
-            print(fpath, 'does not exist.')
+            print(fpath, "does not exist.")
         return None
     with open(fpath, "rb") as f:
         data = pickle.load(f)
     if verbose:
-        print('Read data from', fpath, flush=True)
+        print("Read data from", fpath, flush=True)
     return data
 
+
 def start_main():
     gen_data_path = gen_data_path_input.value.strip()
     algo = algo_input.value.strip()
     hyp_param = hyp_param_input.value.strip()
-    buml_obj_info_path = gen_data_path + '/' + algo + '/' + hyp_param + '/' + algo + '.dat'
-    save_dir = gen_data_path + '/' + algo + '/' + hyp_param + '_' + REG_TEAR_TAG
+    buml_obj_info_path = (
+        gen_data_path + "/" + algo + "/" + hyp_param + "/" + algo + ".dat"
+    )
+    save_dir = gen_data_path + "/" + algo + "/" + hyp_param + "_" + REG_TEAR_TAG
     options = process_additional_options()
-    print('buml_obj_info_path=' + buml_obj_info_path)
-    print('save_dir=' + save_dir)
+    print("buml_obj_info_path=" + buml_obj_info_path)
+    print("save_dir=" + save_dir)
     global cut_and_paste_obj
     emb_info, metadata = read(buml_obj_info_path)
-    cut_and_paste_obj = cut_and_paste_bokeh.CutAndPaste(
-        model=emb_info['model'],
-        y=emb_info['y'], color_of_pts_on_tear=emb_info['color_of_pts_on_tear'],
+    cut_and_paste_obj = CutAndPaste(
+        model=emb_info["model"],
+        y=emb_info["y"],
+        color_of_pts_on_tear=emb_info["color_of_pts_on_tear"],
         save_progress_dir=save_dir,
-        max_refinement_iter=options['max_refinement_iter'],
-        force_compute=options['force_compute'],
-        cmap_interior=options['cmap_interior'],
-        cmap_tear=options['cmap_tear'],
+        max_refinement_iter=options["max_refinement_iter"],
+        force_compute=options["force_compute"],
+        cmap_interior=options["cmap_interior"],
+        cmap_tear=options["cmap_tear"],
     )
     source.data = cut_and_paste_obj.get_current_embedding_data()
 
+
 def start_end():
     patch_source.data = dict(x=[], y=[])
     start_button.disabled = False
@@ -605,7 +699,8 @@ def start_end():
     update_max_fig_height_button.disabled = False
     fig.toolbar.active_inspect = None
     fig.toolbar.active_drag = lasso_tool
-    print_main_log('Select region to cut using lasso and then press cut.')
+    print_main_log("Select region to cut using lasso and then press cut.")
+
 
 def start():
     curdoc().add_next_tick_callback(show_spinner)
@@ -615,11 +710,14 @@ def start():
     curdoc().add_next_tick_callback(adjust_figure_size)
     curdoc().add_next_tick_callback(hide_spinner)
 
+
 def on_start_button_click():
     curdoc().add_next_tick_callback(start)
 
+
 start_button.on_click(on_start_button_click)
 
+
 # Cut
 #######################################
 def cut_start():
@@ -627,17 +725,20 @@ def cut_start():
     cut_button.disabled = True
     save_button.disabled = True
 
+
 def cut_main():
     global cut_and_paste_obj
     patch_source.data = cut_and_paste_obj.cut_clusters_to_move(source.selected.indices)
     source.selected.indices = cut_and_paste_obj.selected_pts_to_move.tolist()
-    print('len(source.selected.indices) = ' + str(len(source.selected.indices)))
+    print("len(source.selected.indices) = " + str(len(source.selected.indices)))
+
 
 def cut_end():
     paste_button.disabled = False
     rotate_cw_button.disabled = False
     rotate_ccw_button.disabled = False
-    print_main_log('Drag and rotate the polygonal patch, and then press paste.')
+    print_main_log("Drag and rotate the polygonal patch, and then press paste.")
+
 
 def cut():
     curdoc().add_next_tick_callback(show_spinner)
@@ -647,11 +748,14 @@ def cut():
     curdoc().add_next_tick_callback(adjust_figure_size)
     curdoc().add_next_tick_callback(hide_spinner)
 
+
 def on_cut_button_click():
     curdoc().add_next_tick_callback(cut)
 
+
 cut_button.on_click(on_cut_button_click)
 
+
 # Paste
 #######################################
 def paste_start():
@@ -659,19 +763,22 @@ def paste_start():
     rotate_cw_button.disabled = True
     rotate_ccw_button.disabled = True
 
+
 def paste_end():
     cut_button.disabled = False
     save_button.disabled = False
     patch_source.data = dict(x=[], y=[])
     fig.toolbar.active_drag = lasso_tool
 
+
 def paste_main():
     global cut_and_paste_obj
-    patch_x = np.array(patch_source.data['x'])
-    patch_y = np.array(patch_source.data['y'])
+    patch_x = np.array(patch_source.data["x"])
+    patch_y = np.array(patch_source.data["y"])
     final_polyg = np.column_stack([patch_x, patch_y])
     source.data = cut_and_paste_obj.paste_clusters(final_polyg)
 
+
 def paste():
     curdoc().add_next_tick_callback(show_spinner)
     curdoc().add_next_tick_callback(paste_start)
@@ -680,23 +787,29 @@ def paste():
     curdoc().add_next_tick_callback(adjust_figure_size)
     curdoc().add_next_tick_callback(hide_spinner)
 
+
 def on_paste_button_click():
     curdoc().add_next_tick_callback(paste)
 
+
 paste_button.on_click(on_paste_button_click)
 
+
 # Save
 #######################################
-def save():
+def save_():
     algo = algo_input.value.strip()
     global cut_and_paste_obj
-    cut_and_paste_obj.save_buml_obj(algo+'.dat')
+    cut_and_paste_obj.save_buml_obj(algo + ".dat")
+
 
 def on_save_button_click():
-    curdoc().add_next_tick_callback(save)
+    curdoc().add_next_tick_callback(save_)
+
 
 save_button.on_click(on_save_button_click)
 
+
 # Update max figure height
 #######################################
 def update_max_fig_height():
@@ -705,10 +818,12 @@ def update_max_fig_height():
     MAX_FIG_HEIGHT = int(max_fig_height_input.value.strip())
     MAX_FIG_WIDTH = MAX_FIG_HEIGHT
 
+
 def on_update_max_fig_height_button_click():
     curdoc().add_next_tick_callback(update_max_fig_height)
     curdoc().add_next_tick_callback(adjust_figure_size)
 
+
 update_max_fig_height_button.on_click(on_update_max_fig_height_button_click)
 
 
@@ -718,11 +833,17 @@ def on_update_max_fig_height_button_click():
     column(
         main_log_div,
         row(gen_data_path_input),
-        row(algo_input, hyp_param_input, options_input, max_fig_height_input), 
-        row(update_max_fig_height_button, start_button, cut_button, paste_button, save_button),
+        row(algo_input, hyp_param_input, options_input, max_fig_height_input),
+        row(
+            update_max_fig_height_button,
+            start_button,
+            cut_button,
+            paste_button,
+            save_button,
+        ),
         row(rotate_cw_button, rotate_ccw_button),
         spinner,
         fig,
-        log_div
+        log_div,
     )
-)
\ No newline at end of file
+)

From 386c76f64ffa1e7baefbc055b68a38c99cd1bfb1 Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Sun, 14 Jun 2026 14:20:03 +0200
Subject: [PATCH 12/20] fix: tear for test cases

---
 tests/scripts/benchmark.py          | 39 ++++++++++++++++++-----------
 tests/scripts/generate_snapshots.py | 33 ++++++++++++++++++------
 tests/scripts/thread_scaling.py     | 20 ++++++++++-----
 3 files changed, 64 insertions(+), 28 deletions(-)

diff --git a/tests/scripts/benchmark.py b/tests/scripts/benchmark.py
index 25708c3..93f1908 100644
--- a/tests/scripts/benchmark.py
+++ b/tests/scripts/benchmark.py
@@ -12,6 +12,7 @@
 from pyRATS import rats
 from examples import datasets
 
+
 def construct_rats(
     n_components=2,
     n_neighbors=14,
@@ -31,6 +32,7 @@ def construct_rats(
             cost_function=cost_function,
             n_iter=n_iter,
             nu=nu,
+            tear=True,
             verbose=verbose,
         )
     except TypeError:
@@ -42,17 +44,23 @@ def construct_rats(
             cost_fn_name=cost_function,
             max_iter=n_iter,
             nu=nu,
+            to_tear=True,
             verbose=verbose,
         )
 
-def run_benchmark(n_samples, n_neighbors=14, min_cluster_size=5, cost_function="distortion"):
-    sys.stderr.write(f"Running benchmark for n={n_samples}, n_neighbors={n_neighbors}, min_cluster_size={min_cluster_size}...\n")
+
+def run_benchmark(
+    n_samples, n_neighbors=14, min_cluster_size=5, cost_function="distortion"
+):
+    sys.stderr.write(
+        f"Running benchmark for n={n_samples}, n_neighbors={n_neighbors}, min_cluster_size={min_cluster_size}...\n"
+    )
     sys.stderr.flush()
-    
+
     # Load dataset
     ds = datasets.Datasets()
     X, _, _ = ds.kleinbottle4d(n=n_samples)
-    
+
     model = construct_rats(
         n_components=2,
         n_neighbors=n_neighbors,
@@ -60,40 +68,41 @@ def run_benchmark(n_samples, n_neighbors=14, min_cluster_size=5, cost_function="
         min_cluster_size=min_cluster_size,
         n_iter=3,
         nu=4,
-        verbose=False, # Set to False for cleaner benchmark output
+        verbose=False,  # Set to False for cleaner benchmark output
     )
-    
+
     start_time = time.perf_counter()
     model.fit_transform(X=X)
     end_time = time.perf_counter()
-    
+
     duration = end_time - start_time
     sys.stderr.write(f"Completed in {duration:.4f}s\n")
     sys.stderr.flush()
     return duration
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Run RATS performance benchmarks.")
     parser.add_argument("--output", type=str, help="Output JSON file path")
-    parser.add_argument("--fast", action="store_true", help="Run only a small subset for testing")
+    parser.add_argument(
+        "--fast", action="store_true", help="Run only a small subset for testing"
+    )
     args = parser.parse_args()
 
     if args.fast:
         sample_sizes = [400, 400, 500]
     else:
-        sample_sizes = [500 , 500, 1000, 2000, 5000, 10_000, 20_000]
-    
+        sample_sizes = [500, 500, 1000, 2000, 5000, 10_000, 20_000]
+
     results = []
 
     print("\n| Sample Size | Duration (s) |")
     print("|-------------|--------------|")
     for n in sample_sizes:
         duration = run_benchmark(n)
-        results.append({
-            "name": f"Klein Bottle {n} samples",
-            "unit": "s",
-            "value": duration
-        })
+        results.append(
+            {"name": f"Klein Bottle {n} samples", "unit": "s", "value": duration}
+        )
         print(f"| {n:11} | {duration:12.4f} |")
 
     if args.output:
diff --git a/tests/scripts/generate_snapshots.py b/tests/scripts/generate_snapshots.py
index 1c89122..d143087 100644
--- a/tests/scripts/generate_snapshots.py
+++ b/tests/scripts/generate_snapshots.py
@@ -65,6 +65,7 @@ def construct_rats(
             cost_function=cost_function,
             n_iter=n_iter,
             nu=nu,
+            tear=True,
             verbose=verbose,
         )
     except TypeError:
@@ -76,14 +77,22 @@ def construct_rats(
             cost_fn_name=cost_function,
             max_iter=n_iter,
             nu=nu,
+            to_tear=True,
             verbose=verbose,
         )
 
 
-def run_model(n_neighbors, min_cluster_size, cost_function, dataset_name, dirpath, force_compute=False):
+def run_model(
+    n_neighbors,
+    min_cluster_size,
+    cost_function,
+    dataset_name,
+    dirpath,
+    force_compute=False,
+):
     fname = f"dataset={dataset_name}_k={n_neighbors}_eta_min={min_cluster_size}_cost-fn={cost_function}.res"
     path = os.path.join(dirpath, fname)
-    
+
     if os.path.exists(path) and not force_compute:
         return
 
@@ -119,7 +128,9 @@ def run_model(n_neighbors, min_cluster_size, cost_function, dataset_name, dirpat
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(prog="generate_snapshots", description="Run toy examples to generate baselines.")
+    parser = argparse.ArgumentParser(
+        prog="generate_snapshots", description="Run toy examples to generate baselines."
+    )
     parser.add_argument(
         "--path-to-results-dir",
         type=str,
@@ -127,16 +138,20 @@ def run_model(n_neighbors, min_cluster_size, cost_function, dataset_name, dirpat
         help="Results will be stored in this directory.",
     )
     parser.add_argument(
-        "--force-compute", action="store_true", help="Re-compute if results already exist."
+        "--force-compute",
+        action="store_true",
+        help="Re-compute if results already exist.",
     )
     parser.add_argument(
-        "--fast-mode", action="store_true", help="Run a minimal test subset for fast CI execution."
+        "--fast-mode",
+        action="store_true",
+        help="Run a minimal test subset for fast CI execution.",
     )
     args = parser.parse_args()
 
     force_compute = args.force_compute
     dirpath = args.path_to_results_dir.rstrip("/")
-    
+
     if not os.path.exists(dirpath):
         os.makedirs(dirpath, exist_ok=True)
 
@@ -159,7 +174,11 @@ def run_model(n_neighbors, min_cluster_size, cost_function, dataset_name, dirpat
         min_cluster_sizes = [5, 10]
         cost_functions = ["distortion", "alignment"]
 
-    argslist = list(itertools.product(n_neighbors_list, min_cluster_sizes, cost_functions, dataset_names))
+    argslist = list(
+        itertools.product(
+            n_neighbors_list, min_cluster_sizes, cost_functions, dataset_names
+        )
+    )
 
     Parallel(n_jobs=1)(
         delayed(run_model)(*args, dirpath, force_compute) for args in argslist
diff --git a/tests/scripts/thread_scaling.py b/tests/scripts/thread_scaling.py
index 425e186..40e7d44 100644
--- a/tests/scripts/thread_scaling.py
+++ b/tests/scripts/thread_scaling.py
@@ -28,6 +28,7 @@ def run_once(X, n_jobs):
         min_cluster_size=5,
         n_iter=3,
         nu=4,
+        tear=True,
         verbose=False,
         n_jobs=n_jobs,
     )
@@ -38,12 +39,19 @@ def run_once(X, n_jobs):
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--n", type=int, default=2000,
-                        help="Klein bottle sample count (default 2000).")
-    parser.add_argument("--jobs", type=int, nargs="+", default=[1, 2, 4, 8],
-                        help="List of n_jobs values to benchmark.")
-    parser.add_argument("--repeats", type=int, default=2,
-                        help="Repeats per n_jobs (best time kept).")
+    parser.add_argument(
+        "--n", type=int, default=2000, help="Klein bottle sample count (default 2000)."
+    )
+    parser.add_argument(
+        "--jobs",
+        type=int,
+        nargs="+",
+        default=[1, 2, 4, 8],
+        help="List of n_jobs values to benchmark.",
+    )
+    parser.add_argument(
+        "--repeats", type=int, default=2, help="Repeats per n_jobs (best time kept)."
+    )
     args = parser.parse_args()
 
     print(f"Loading kleinbottle4d with n={args.n}...")

From 3777c11dffffd1690249e152238de466ebc154c8 Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Thu, 18 Jun 2026 08:43:07 +0200
Subject: [PATCH 13/20] real world experiment notebooks

---
 examples/motor_cortex.ipynb | 157 +++++++++++++++++++++++++++++
 examples/r2of_day1.ipynb    | 187 +++++++++++++++++++++++++++++++++++
 examples/t_maze.ipynb       | 190 ++++++++++++++++++++++++++++++++++++
 3 files changed, 534 insertions(+)
 create mode 100644 examples/motor_cortex.ipynb
 create mode 100644 examples/r2of_day1.ipynb
 create mode 100644 examples/t_maze.ipynb

diff --git a/examples/motor_cortex.ipynb b/examples/motor_cortex.ipynb
new file mode 100644
index 0000000..0ede0b0
--- /dev/null
+++ b/examples/motor_cortex.ipynb
@@ -0,0 +1,157 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2d578ee-5af5-4cbe-af23-2a2158fec7e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %pip install git+https://github.com/Mishne-Lab/pyRATS\n",
+    "# if not already installed on the system:\n",
+    "# %pip install pandas imageio seaborn matplotlib\n",
+    "\n",
+    "from pyRATS import rats\n",
+    "from examples import vis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf164db2-636e-4140-a5dc-c6bb7cb1b42c",
+   "metadata": {},
+   "source": [
+    "# Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5ecc8563-e823-48f5-a33c-a8e5ff45076b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pickle\n",
+    "\n",
+    "def path_exists(path):\n",
+    "    return os.path.exists(path) or os.path.islink(path)\n",
+    "\n",
+    "def read(fpath, verbose=True):\n",
+    "    if not path_exists(fpath):\n",
+    "        if verbose:\n",
+    "            print(fpath, 'does not exist.')\n",
+    "        return None\n",
+    "    with open(fpath, \"rb\") as f:\n",
+    "        data = pickle.load(f)\n",
+    "    if verbose:\n",
+    "        print('Read data from', fpath, flush=True)\n",
+    "    return data\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8194cb4d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_fname = '../data/data.dat'             # PATH TO DATA\n",
+    "X, labels, metadata = read(data_fname)\n",
+    "cond_num = metadata['cond_num']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02fb35aa-a1bc-4ff2-8f1a-5e8e30ba3734",
+   "metadata": {},
+   "source": [
+    "# Generate embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f15ced5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f(x):\n",
+    "    z = x.copy()\n",
+    "    mask = x < 6\n",
+    "    z[mask] -= 2\n",
+    "    z[~mask] -= 1\n",
+    "    return z\n",
+    "\n",
+    "\n",
+    "model = rats.RATS(\n",
+    "    n_components = 2,\n",
+    "    n_neighbors = 45,\n",
+    "    cost_function = 'alignment',\n",
+    "    min_cluster_size=3,\n",
+    "    patience=20,\n",
+    "    n_iter=20,\n",
+    "    tear=True,\n",
+    "    postprocess=True,\n",
+    "    root_view='center',\n",
+    "    tree='spt',\n",
+    "    verbose=False\n",
+    ")\n",
+    "\n",
+    "y, _ = model.fit_transform(X, cond_num)\n",
+    "tear_color_eig_inds = [1]\n",
+    "color_of_pts_on_tear = model.compute_color_of_pts_on_tear(\n",
+    "    y,\n",
+    "    tear_color_eig_inds=tear_color_eig_inds, \n",
+    ")\n",
+    "mask_pos = cond_num > 0\n",
+    "mask_neg = ~mask_pos\n",
+    "vis.Visualize().global_embedding(\n",
+    "    y[mask_pos], f(cond_num[mask_pos]),\n",
+    "    color_of_pts_on_tear=color_of_pts_on_tear[mask_pos][:,tear_color_eig_inds] if color_of_pts_on_tear is not None else None,\n",
+    "    cmap0='bwr',\n",
+    "    cmap1='gist_ncar',\n",
+    "    title='color='+str([1]),\n",
+    "    figsize=(5, 5)\n",
+    ")\n",
+    "\n",
+    "vis.Visualize().global_embedding(\n",
+    "    y[mask_neg], f(-cond_num[mask_neg]),\n",
+    "    color_of_pts_on_tear=color_of_pts_on_tear[mask_neg][:,tear_color_eig_inds] if color_of_pts_on_tear is not None else None,\n",
+    "    cmap0='bwr',\n",
+    "    cmap1='gist_ncar',\n",
+    "    title='color='+str([1]),\n",
+    "    figsize=(5, 5)\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be833305",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rats",
+   "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.13.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/r2of_day1.ipynb b/examples/r2of_day1.ipynb
new file mode 100644
index 0000000..1c0d7f5
--- /dev/null
+++ b/examples/r2of_day1.ipynb
@@ -0,0 +1,187 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2d578ee-5af5-4cbe-af23-2a2158fec7e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %pip install git+https://github.com/Mishne-Lab/pyRATS\n",
+    "# if not already installed on the system:\n",
+    "# %pip install pandas imageio seaborn matplotlib\n",
+    "\n",
+    "from pyRATS import rats\n",
+    "from examples import vis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf164db2-636e-4140-a5dc-c6bb7cb1b42c",
+   "metadata": {},
+   "source": [
+    "# Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f7ff57bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pickle\n",
+    "\n",
+    "def path_exists(path):\n",
+    "    return os.path.exists(path) or os.path.islink(path)\n",
+    "\n",
+    "def read(fpath, verbose=True):\n",
+    "    if not path_exists(fpath):\n",
+    "        if verbose:\n",
+    "            print(fpath, 'does not exist.')\n",
+    "        return None\n",
+    "    with open(fpath, \"rb\") as f:\n",
+    "        data = pickle.load(f)\n",
+    "    if verbose:\n",
+    "        print('Read data from', fpath, flush=True)\n",
+    "    return data\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5ecc8563-e823-48f5-a33c-a8e5ff45076b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_fname = '../data/data.dat'         # PATH TO DATA\n",
+    "X, labels, metadata = read(data_fname)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02fb35aa-a1bc-4ff2-8f1a-5e8e30ba3734",
+   "metadata": {},
+   "source": [
+    "# Generate embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88c3109e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = rats.RATS(\n",
+    "    n_components=2, \n",
+    "    kernel='cosine', \n",
+    "    n_neighbors=34, \n",
+    "    cost_function='distortion', \n",
+    "    min_cluster_size=3, \n",
+    "    verbose=True, \n",
+    "    metric='cosine',\n",
+    "    n_iter_without_progress=20,\n",
+    "    tree='mst',\n",
+    "    root_view= 'largest',\n",
+    "    tear=True,\n",
+    ")\n",
+    "y = model.fit_transform(X)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d47b2cd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tear_color_eig_inds = [5, 1, 3] # interior has green color so assigned smallest value of i to g-channel\n",
+    "color_of_pts_on_tear = model.compute_color_of_pts_on_tear(\n",
+    "    y,\n",
+    "    tear_color_eig_inds=tear_color_eig_inds,\n",
+    ")\n",
+    "vis.Visualize().global_embedding(\n",
+    "    y, labels[:,0],\n",
+    "    color_of_pts_on_tear=color_of_pts_on_tear[:,tear_color_eig_inds] if color_of_pts_on_tear is not None else None,\n",
+    "    cmap0='summer',\n",
+    "    cmap1='jet',\n",
+    "    title='color='+str(tear_color_eig_inds),\n",
+    "    figsize=(3,3)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d3f64fa2",
+   "metadata": {},
+   "source": [
+    "To visuallly smoothen the edges, we save the data and use the cut-and-paste app. \n",
+    "To run the app, execute:\n",
+    "- bokeh serve cut_and_paste_app.py --allow-websocket-origin=localhost:5006\n",
+    "- then go to http://localhost:5006"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a0f7be2-24e2-4e37-b58a-3bbd55e0a731",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def save(dirpath, fname, data, verbose=True):\n",
+    "    if not path_exists(dirpath):\n",
+    "        os.makedirs(dirpath)\n",
+    "    fpath = dirpath + '/' + fname\n",
+    "    with open(fpath, \"wb\") as f:\n",
+    "        pickle.dump(data, f)\n",
+    "    if verbose:\n",
+    "        print('Saved data in', fpath, flush=True)\n",
+    "        \n",
+    "emb_info = {\n",
+    "    'y': y,\n",
+    "    'color_of_pts_on_tear': color_of_pts_on_tear,\n",
+    "    'model': model,\n",
+    "}\n",
+    "metadata = {\n",
+    "    'algo': 'rats',\n",
+    "    'hyperparameters': {\n",
+    "        'd': 2,\n",
+    "    },\n",
+    "}\n",
+    "save('./generated_data/rats/34_3/', 'rats.dat', [emb_info, metadata])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4efe1f9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rats",
+   "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.13.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/t_maze.ipynb b/examples/t_maze.ipynb
new file mode 100644
index 0000000..3660123
--- /dev/null
+++ b/examples/t_maze.ipynb
@@ -0,0 +1,190 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "039131b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %pip install git+https://github.com/Mishne-Lab/pyRATS\n",
+    "# if not already installed on the system:\n",
+    "# %pip install pandas imageio seaborn matplotlib\n",
+    "\n",
+    "from pyRATS import rats\n",
+    "import os\n",
+    "\n",
+    "import numpy as np\n",
+    "import scipy.io as spio\n",
+    "np.random.seed(42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9285591c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def de_mean(inputmat):\n",
+    "    #bas\n",
+    "    outputmat=np.zeros_like(inputmat)\n",
+    "    for i in range(len(inputmat)):\n",
+    "        outputmat[i,:]=(inputmat[i,:]-np.mean(inputmat[i,:]))\n",
+    "    return outputmat\n",
+    "\n",
+    "\n",
+    "# Path to where the data folder is extracted\n",
+    "base_dir = r\"../data\"\n",
+    "\n",
+    "experiment = 'IsoExample1'   # 'IsoExample1', 'IsoExample2', or 'IsoExample3'\n",
+    "PCA        = True\n",
+    "PCs        = 6\n",
+    "dim        = 3               # target embedding dimension (d) for RATS\n",
+    "\n",
+    "# Derived paths\n",
+    "data_dir    = os.path.join(base_dir, \"HPC_Manifold_Project\") + os.sep\n",
+    "results_dir = os.path.join(base_dir, \"Results\") + os.sep\n",
+    "saveloc     = os.path.join(results_dir, experiment)\n",
+    "\n",
+    "if not os.path.isdir(saveloc):\n",
+    "    os.makedirs(saveloc)\n",
+    "\n",
+    "# LOAD DATA\n",
+    "data = spio.loadmat(data_dir + experiment + '.mat')\n",
+    "\n",
+    "X_train      = data['X_train']\n",
+    "new_location = data['new_location']\n",
+    "thisvelocity = data['thisvelocity'].flatten()\n",
+    "velocity = data['velocity']\n",
+    "locColor     = data['locColor']\n",
+    "newY         = data['newY']\n",
+    "bestIsoIdx   = int(data['bestIsoIdx'][0, 0])\n",
+    "labelsmat    = X_train[:, 0]\n",
+    "\n",
+    "print(f\"Loaded {experiment}: X_train shape = {X_train.shape}\")\n",
+    "\n",
+    "\n",
+    "# ============================================================================\n",
+    "# PCA preprocessing\n",
+    "# ============================================================================\n",
+    "if PCA:\n",
+    "    standRates = de_mean(X_train.T)\n",
+    "    covariance_mat = np.cov(standRates)\n",
+    "    eigenvalues, eigenvectors = np.linalg.eig(covariance_mat)\n",
+    "\n",
+    "    eigenvalues_indices = np.argsort(eigenvalues)\n",
+    "    sorted_eigenvalues  = np.flip(eigenvalues[eigenvalues_indices])\n",
+    "    components          = eigenvectors[:, np.flip(eigenvalues_indices)]\n",
+    "    projection          = [components[:, i] @ X_train.T for i in range(PCs)]\n",
+    "\n",
+    "    X_input    = np.transpose(np.vstack(projection))\n",
+    "    pca_suffix = f\"PCA_{PCs}PCs\"\n",
+    "    print(f\"PCA reduced X_train to shape {X_input.shape}\")\n",
+    "else:\n",
+    "    X_input    = X_train\n",
+    "    pca_suffix = \"\"\n",
+    "\n",
+    "X_input = np.array(X_input)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4ae7a6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "k=30\n",
+    "eta_min=3\n",
+    "\n",
+    "if not hasattr(np, 'object'):\n",
+    "    np.object = object  # patch deprecated alias\n",
+    "\n",
+    "print(f\"Starting RATS with k={k}, eta={eta_min}\")\n",
+    "model = rats.RATS(\n",
+    "    n_components=dim,\n",
+    "    kernel='rbf',\n",
+    "    postprocess=True,\n",
+    "    n_neighbors=k,\n",
+    "    min_cluster_size=eta_min, cost_function='alignment',\n",
+    "    tear=False, n_iter=1,\n",
+    "    global_init_algo_name='spectral', \n",
+    "    repel_by=1, n_repel=100, repel_decay=0.9, \n",
+    "    alpha=0.1\n",
+    ")\n",
+    "X_rats_org = model.fit_transform(X=X_input)\n",
+    "idx        = f'eta{eta_min}k{k}'\n",
+    "result     = (idx, {'X': X_rats_org, 'hyp1': eta_min, 'hyp2': k})\n",
+    "\n",
+    "print(f\"Finished model with k={k}, eta={eta_min}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e66537be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib widget\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import colorsys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d956167e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rgbloccolor = []\n",
+    "for i, j, k in locColor:\n",
+    "    rgbloccolor.append(colorsys.hsv_to_rgb(i, j, k))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da981a39",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res = X_rats_org\n",
+    "fig = plt.figure(figsize=(8, 6))\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "\n",
+    "scatter = ax.scatter(\n",
+    "    res[:-1, 0], res[:-1, 1], res[:-1, 2],\n",
+    "    c = rgbloccolor,\n",
+    "    s=thisvelocity,\n",
+    ")\n",
+    "\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rats",
+   "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.13.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From ee98727901aba9e1b822ad897c8eaba4cf924a31 Mon Sep 17 00:00:00 2001
From: Joshua Offergeld <joshua.offergeld@ru.nl>
Date: Thu, 18 Jun 2026 14:21:04 +0200
Subject: [PATCH 14/20] add outputs to notebooks

---
 examples/motor_cortex.ipynb | 110 ++++++++++++++++++++++++++++--------
 examples/r2of_day1.ipynb    |  89 +++++++++++++++++++++++++----
 examples/t_maze.ipynb       |  69 +++++++++++++++++-----
 3 files changed, 216 insertions(+), 52 deletions(-)

diff --git a/examples/motor_cortex.ipynb b/examples/motor_cortex.ipynb
index 0ede0b0..66827b4 100644
--- a/examples/motor_cortex.ipynb
+++ b/examples/motor_cortex.ipynb
@@ -2,15 +2,27 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "f2d578ee-5af5-4cbe-af23-2a2158fec7e6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "matplotlib.get_backend() =  module://matplotlib_inline.backend_inline\n"
+     ]
+    }
+   ],
    "source": [
     "# %pip install git+https://github.com/Mishne-Lab/pyRATS\n",
     "# if not already installed on the system:\n",
     "# %pip install pandas imageio seaborn matplotlib\n",
     "\n",
+    "import sys\n",
+    "sys.path.insert(0, '../src/')\n",
+    "sys.path.insert(0, '../')\n",
+    "\n",
     "from pyRATS import rats\n",
     "from examples import vis"
    ]
@@ -25,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "5ecc8563-e823-48f5-a33c-a8e5ff45076b",
    "metadata": {},
    "outputs": [],
@@ -50,12 +62,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "8194cb4d",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Read data from ../data/motor_data.dat\n"
+     ]
+    }
+   ],
    "source": [
-    "data_fname = '../data/data.dat'             # PATH TO DATA\n",
+    "data_fname = '../data/motor_data.dat'             # PATH TO DATA\n",
     "X, labels, metadata = read(data_fname)\n",
     "cond_num = metadata['cond_num']"
    ]
@@ -70,19 +90,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "0f15ced5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/bh/hyvnvd611gq4n0_zb8m0gm6r0000gp/T/ipykernel_94587/4240833365.py:1: DeprecationWarning: The parameter 'patience' is deprecated and will be removed in a future release. Use 'n_iter_without_progress' instead.\n",
+      "  model = rats.RATS(\n"
+     ]
+    }
+   ],
    "source": [
-    "def f(x):\n",
-    "    z = x.copy()\n",
-    "    mask = x < 6\n",
-    "    z[mask] -= 2\n",
-    "    z[~mask] -= 1\n",
-    "    return z\n",
-    "\n",
-    "\n",
     "model = rats.RATS(\n",
     "    n_components = 2,\n",
     "    n_neighbors = 45,\n",
@@ -97,7 +118,54 @@
     "    verbose=False\n",
     ")\n",
     "\n",
-    "y, _ = model.fit_transform(X, cond_num)\n",
+    "y, _ = model.fit_transform(X, cond_num)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6ff92d4b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def f(x):\n",
+    "    z = x.copy()\n",
+    "    mask = x < 6\n",
+    "    z[mask] -= 2\n",
+    "    z[~mask] -= 1\n",
+    "    return z\n",
+    "\n",
     "tear_color_eig_inds = [1]\n",
     "color_of_pts_on_tear = model.compute_color_of_pts_on_tear(\n",
     "    y,\n",
@@ -123,14 +191,6 @@
     "    figsize=(5, 5)\n",
     ")\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "be833305",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/examples/r2of_day1.ipynb b/examples/r2of_day1.ipynb
index 1c0d7f5..d9d8974 100644
--- a/examples/r2of_day1.ipynb
+++ b/examples/r2of_day1.ipynb
@@ -5,12 +5,24 @@
    "execution_count": null,
    "id": "f2d578ee-5af5-4cbe-af23-2a2158fec7e6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "matplotlib.get_backend() =  module://matplotlib_inline.backend_inline\n"
+     ]
+    }
+   ],
    "source": [
     "# %pip install git+https://github.com/Mishne-Lab/pyRATS\n",
     "# if not already installed on the system:\n",
     "# %pip install pandas imageio seaborn matplotlib\n",
     "\n",
+    "import sys\n",
+    "sys.path.insert(0, '../src/')\n",
+    "sys.path.insert(0, '../')\n",
+    "\n",
     "from pyRATS import rats\n",
     "from examples import vis"
    ]
@@ -25,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "f7ff57bd",
    "metadata": {},
    "outputs": [],
@@ -51,12 +63,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "5ecc8563-e823-48f5-a33c-a8e5ff45076b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Read data from ../data/r2of_data.dat\n"
+     ]
+    }
+   ],
    "source": [
-    "data_fname = '../data/data.dat'         # PATH TO DATA\n",
+    "data_fname = '../data/r2of_data.dat'         # PATH TO DATA\n",
     "X, labels, metadata = read(data_fname)\n"
    ]
   },
@@ -70,10 +90,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "88c3109e",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/bh/hyvnvd611gq4n0_zb8m0gm6r0000gp/T/ipykernel_94825/4200613334.py:1: FutureWarning: metric='cosine' is not yet fully supported. Only 'euclidean' is used in the embedding step. This parameter will be extended in a future release.\n",
+      "  model = rats.RATS(\n"
+     ]
+    }
+   ],
    "source": [
     "model = rats.RATS(\n",
     "    n_components=2, \n",
@@ -81,7 +110,6 @@
     "    n_neighbors=34, \n",
     "    cost_function='distortion', \n",
     "    min_cluster_size=3, \n",
-    "    verbose=True, \n",
     "    metric='cosine',\n",
     "    n_iter_without_progress=20,\n",
     "    tree='mst',\n",
@@ -93,10 +121,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "d47b2cd9",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/joshuaoffergeld/Documents/pyRATS/examples/../examples/vis.py:2058: UserWarning: No data for colormapping provided via 'c'. Parameters 'cmap' will be ignored\n",
+      "  ax.scatter(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "tear_color_eig_inds = [5, 1, 3] # interior has green color so assigned smallest value of i to g-channel\n",
     "color_of_pts_on_tear = model.compute_color_of_pts_on_tear(\n",
@@ -126,10 +183,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "4a0f7be2-24e2-4e37-b58a-3bbd55e0a731",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved data in ./generated_data/rats/34_3//rats.dat\n"
+     ]
+    }
+   ],
    "source": [
     "def save(dirpath, fname, data, verbose=True):\n",
     "    if not path_exists(dirpath):\n",
diff --git a/examples/t_maze.ipynb b/examples/t_maze.ipynb
index 3660123..e2532c7 100644
--- a/examples/t_maze.ipynb
+++ b/examples/t_maze.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "039131b8",
    "metadata": {},
    "outputs": [],
@@ -11,9 +11,12 @@
     "# if not already installed on the system:\n",
     "# %pip install pandas imageio seaborn matplotlib\n",
     "\n",
+    "import sys\n",
+    "sys.path.insert(0, '../src/')\n",
+    "sys.path.insert(0, '../')\n",
+    "\n",
     "from pyRATS import rats\n",
     "import os\n",
-    "\n",
     "import numpy as np\n",
     "import scipy.io as spio\n",
     "np.random.seed(42)"
@@ -21,10 +24,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "9285591c",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded IsoExample1: X_train shape = (7334, 104)\n",
+      "PCA reduced X_train to shape (7334, 6)\n"
+     ]
+    }
+   ],
    "source": [
     "def de_mean(inputmat):\n",
     "    #bas\n",
@@ -90,10 +102,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "f4ae7a6b",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/bh/hyvnvd611gq4n0_zb8m0gm6r0000gp/T/ipykernel_94554/1470044022.py:4: FutureWarning: In the future `np.object` will be defined as the corresponding NumPy scalar.\n",
+      "  if not hasattr(np, 'object'):\n"
+     ]
+    }
+   ],
    "source": [
     "k=30\n",
     "eta_min=3\n",
@@ -101,7 +122,6 @@
     "if not hasattr(np, 'object'):\n",
     "    np.object = object  # patch deprecated alias\n",
     "\n",
-    "print(f\"Starting RATS with k={k}, eta={eta_min}\")\n",
     "model = rats.RATS(\n",
     "    n_components=dim,\n",
     "    kernel='rbf',\n",
@@ -115,19 +135,17 @@
     ")\n",
     "X_rats_org = model.fit_transform(X=X_input)\n",
     "idx        = f'eta{eta_min}k{k}'\n",
-    "result     = (idx, {'X': X_rats_org, 'hyp1': eta_min, 'hyp2': k})\n",
-    "\n",
-    "print(f\"Finished model with k={k}, eta={eta_min}\")"
+    "result     = (idx, {'X': X_rats_org, 'hyp1': eta_min, 'hyp2': k})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "e66537be",
    "metadata": {},
    "outputs": [],
    "source": [
-    "%matplotlib widget\n",
+    "# %matplotlib widget\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
     "import colorsys"
@@ -135,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "d956167e",
    "metadata": {},
    "outputs": [],
@@ -147,10 +165,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "da981a39",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfYAAAHoCAYAAAC7N81XAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQecbGV993/TZ3u5hXu5cOkgCIK9IiqILbY3vtFINKIxppjYE1ss0ZhoTKJ5NYoaE41do8aKBUQFNSAC0jsXuL1s351+3s/3mfkv5x7O7M7uzuzuXZ4fn/lcdmbOOc+c8zzP79//iSAIAnl4eHh4eHisCSRXegAeHh4eHh4e7YMndg8PDw8PjzUET+weHh4eHh5rCJ7YPTw8PDw81hA8sXt4eHh4eKwheGL38PDw8PBYQ/DE7uHh4eHhsYbgid3Dw8PDw2MNwRO7h4eHh4fHGoIndg8PDw8PjzUET+weHh4eHh5rCJ7YPTw8PDw81hA8sXt4eHh4eKwheGL38PDw8PBYQ/DE7uHh4eHhsYbgid3Dw8PDw2MNwRO7h4eHh4fHGoIndg8PDw8PjzUET+weHh4eHh5rCJ7YPTw8PDw81hA8sXt4eHh4eKwheGL38PDw8PBYQ/DE7uHh4eHhsYbgid3Dw8PDw2MNwRO7h4eHh4fHGoIndg8PDw8PjzUET+weHh4eHh5rCJ7YPTw8PDw81hA8sXt4eHh4eKwheGL38PDw8PBYQ/DE7uHh4eHhsYbgid3Dw8PDw2MNwRO7h4eHh4fHGoIndg8PDw8PjzUET+weHh4eHh5rCJ7YPTw8PDw81hA8sXt4eHh4eKwheGL38PDw8PBYQ/DE7uHh4eHhsYbgid3Dw8PDw2MNwRO7h4eHh4fHGoIndg8PDw8PjzUET+weHmsMQRCoVCppenpatVptpYfj4eGxzEgv9wU9PDw6Q+bValUjIyPu30wm495PJBLu/1OplPt/Dw+PtQ+vsXt4HOJkXiwWNTk5qdHRUV199dXauXOn+yyXy7nvlctl9+I9Dw+PtQ+vsXt4HGLAvF6pVJy5nX/5G238rrvucpr5EUccMaulJ5NJR+h8j395n/c8PDzWLjyxe3gcAjBy3rt3r7q7u2fJHJJOp9M6cOCAdu3apdNPP90RejabnSVw+x7a/czMjPr6+tzf3jTv4bE24UV3D49VTuaQ8fj4uO69915deeWV7m/InBcEjZn9xhtv1LHHHutIHxN8VCuHxDHZX3bZZdq/f783zXt4rGF4jd3DY5UBzTpsaofg0dBvvvlmHXfccert7Z39Lp/ddNNN6u/v14YNG5ypHcKPgu9de+212rx5s/uuN817eKxdeGL38FgFgLgtPY2XBbqZyfyGG25QT0+P85+HQaAc2vwZZ5zhCN2i4aO44447nKDwoAc96CDTfNjv7k3zHh5rA94U7+GxQoBUMaND6JDzFVdcoTvvvNMRLH5yM7Xv3r3b+dBPPvnkg8iX42699VadeOKJzqceZ4IHY2Njuv322/WQhzzEnRcYuVvOu4+a9/BYO/Aau4fHCqSoQaQQqhWQufvuu515/KijjjqInAuFgm655RZH6pa+BjgOLX7Tpk0aGBhwxG6kHQbnvOaaa3T88ce774UBufPyUfMeHmsLntg9PJYBECyEHvabm2Y+MTHhiP1hD3vYQeTMdyBvfOe8wiC1jfMdeeSRs4F0ccD/jkBwzDHHNB2bN817eKwteFO8h0eHgFYNkU9NTbnANUgWUrcUNV6meR999NEuqC0MyJ5I9hNOOOGg9ylEw2e8j3+8mQkeEz4pcJjg5/OfR03zJnx4eHgcevDE7uHRIb85mjikTu45qWpo3eY3N6K97bbbHDljgg+DY/G3n3LKKQdp4xDu9ddfr+HhYeeXD+erh4EJ/7rrrnPHd3V1tTR2I3f+jboKPDw8Dh14U7yHR5v85paiZtHmpgGTpkaOOYVhwti3b5/TqB/1qEcdpFFzPOQN2ZtfnPMQQMe50OIRBigjC7mjkUPw4fFA6uvXr9fhhx++4N/jTfMeHoc2PLF7eCwSaLNotpjF0YopDmN+cyNqAt/4DF94GAgAFJU56aST7qdRE8GOlg6xo/mT0oYAAOHzOvXUU53GznUw41N0hnS3oaEhd/y2bdsc6T/+8Y9f9LONmubNdeBT4jw8Vj+8Kd7DYwEwosPEjra8Z88e5zuHcKPkx2eY4aNpapwDUoeIDzvssIPOT1W4HTt2OG2bhi7/+7//68id4DeOQxAYHBx0fnVeEDqf/frXv3ame8ZEChxafLOc9oWSOzBrhDfNe3isfniN3cNjHlg6mHVJCxeQwTSONo4GHQbmcggfIs7n8wd9BnGjUYdN8JwP0zwmeP4foYAqcWjnEDQkD9mvW7fuoNQ2jifwDrLnO/jsKWITHc9SYJq7L2jj4XFowBO7h0cMrIwr2nKY1CA5M7VDovwdTSWzNDWIOKqRo+lznGnUBLlhZsfczv+jhUPm+OON9DH1Ux+eQjRWuCYKiJ3gPM5DNDxCAe+1C9407+Fx6MCb4j08QoDM0bYhYHzVl156qdPSIVRrhQrJEci2fft2F3UejUonAt6IOHpuCJ+ANszaaNi//OUvXfoaJAxhP/KRj3Rpb0bqRMdTDpZzzZXahraPJeAxj3mM881ffvnlLte9nSlr3jTv4XFowGvsHg94WIpa2NSO6R0zO9p4OOIcWDc1GrJQvz0MTOwEv1nt9mizFrRytGqIGK0a/zvWAMrJnnbaaQf5xXkfQQDTOho8pB5XXQ4hgTx56sDTIIYXggIV50ZGRmbN+e02zVuevgk8Hh4eqwOJwFeh8HgAwszrVifd/OaWx22+bsg2GglOKhnHRgu/cA6C2PCDQ/qA82NqR4uH1DHPb9261aWxcSzH0IoVIo4WoiGinjrvjAHhIuqrt9+B5s+/D33oQw8aD9f+7W9/66wPCBrRkrLtuIe2ffioeQ+P1QOvsXs8YGBaJkSOeRsCts5m4RQ1NGoINZpfDiBptOC4zzgn72EKRyM3zRzTOoIAZB8tRIO5nDGR5x6Njuf4008/3Y0tajUw4A7AlE9qW3Q8HPPwhz/cjQvTPOZ8hIp2paxZrXmzcHB/rQCPh4fHysETu8eah5E5LwiIiHNSw4zYw8A3jqb84Ac/+H5kap9FG7IAfO5o5QTL/epXv3KEh6kdMoe8IWdINa407CMe8YiDTNmW4w7ZkxvfzK9OYB/fQxtvRvyMgzGQWhc2zTerLb/UqHnutTfNe3isLDyxe6zpFLWwqd1KpRKVThoapBk9xjqmYTKPfgaJbty48aCGLFyDoDX86oDrEFAHkXI9ItTRvqMaPsdxLcgbn3jUF4+Wz3UgyTgS5joQ9ZYtW+7XICYOpL897nGPc6b5X/ziF04YiNamXwrCaXu+oI2Hx8rCE7vHmiPzcDEV85sbOVqd9WgaGiAKHuKnxWkU1pAFvzrnRPPFVE4BGs6PkICPO6w541MnAI+gtqiG36wiHeekyIwF3zULekOQQENGQGkVjAHrAMdS+IZxEZjXTtM8iLaB9dXqPDyWF94Z5nFIw0zAkCimbdLT8GvzfjRFDX80UevRNDQAmWIyR9uORnhbQxZM2hA8KWoICJA4xWE4d9Qcbho+2jRafhi4Ahgj1wqTHqZ1qsYxPs7VzASPUMFYETIWGo3O9RBcaBHLtdDgIeF2IdxIhueCMMS/Hh4eywdP7B6HJPB3W2lXiBdSxMQOSA0LB8MBvoemCplGtWBLK4trnco1MHlDtJA5ggHR6wSroe2i5cdp5Pfcc48bYzTS3SrSRY+xHHfcAESvh6vLhQEJQ8aQ81JM6cQX8BsYD4IK97CdsMA6M81jCfEJOB4eywNP7B6HHNC8ITaIEMKAQIhix59N0FuUEI008Udbo5Qwoq1TISDOh8ZNgxXIlGMhQrRktHCuyeeY9KM+bisqw1iiuexWkS6qxaOBI2BgmrfUsThwTcz+CCFLBYIFBXEQJgj4I/ivE+QOrCSvJ3cPj87D+9g9DilA0n/4h3+oJz3pSS7wDOJAI0QLRjuO6z2OGR1CiaaUAQLbrHUq57FOavy/5ZpDftFCNGGfe5z2b7nqcVo8eelhIERwPisz28wEz7gw48elti0WnIf7Fo6aj3NHtENz57eTPYAg5AvaeHh0Dl5j9zik8K//+q9Ow/7ABz4wSxgEqGGWJr0sCvzuEGpc6VfI28zfBLMRLc73qTYH0aN54++Okrr53KMaOUBTh7SiGjUm/DgtHk3Weq9znWakTgwB3+P4uEI1SwVWBAQGXBqY5hlvu4HwhTvEm+Y9PDoLT+wehwwgtre97W264IILZv3LaLFovPiso1pss5QyC5ajShzfQYvkfI997GNdEBxmcgLL4oQFNHIj4qiPm/OQ+hYVIuyYOC3eouO5TrPUNoQXSsYyLoSQTgGBAesEGjXkzm9pFzgX1hFy6IE3zXt4dA7eFO9xSAAt7w/+4A/0J3/yJy4fe75iMgByDqeUcQ788JjbCaZDEMAsTiBZWCgwYSGuuhwaJ+QbrSCH/xghArN2ND++mRZv0fGkyXHOZkVm8L+jSfO9TgOBhBQ6TPMIEwgrFORZiumcsXNvqKJn1gZLicO1wu/21eo8PNoHr7F7NMVHP/pRR0Zsxo9+9KNdWdK5gBn7z//8z532iUkZM/b3vve9ttzhv/mbv3Fk8Na3vnXeYjJGmuSYo8mjKUJSBMLxPpqvkTrHhsk7XF0uSrRW5jWqkYeLykQ1/GZaPKZ1jiEIkHvVzASPZcHavLazWtx84B4hQOF2ILAOQWgxgLiJ4if4MBwwaGlx1k3PB9Z5eLQPXmP3iMWXv/xlvf71r9fHP/5xR+of+tCH9LSnPc35s6MR3aYNP/WpT3Wffe1rX3MbOalg7egJ/rOf/Uwf+chHdMkll8yS7VzFZCyljGvTYAUSQQDgdyCk/OY3v3GtU9HUwwinnEU/szKvcRp5Mw3ftHjGGD7GctwplMN1mqW2YcKHFBGu4qL5Ow2sHdwzBB1M81hG4uIY5gIWDu5DXCGdcI93X9DGw6N98MTuEYt//ud/1itf+Uqdf/757m8I/rvf/a4+/elP681vfvP9vs/7aKcEoFmeeDtSsiDMl770pXrnO9/ptO9wMRmKrIQJEXLA1A6Z8P+QBpo3BGqES9Abn1n3tTCaCQumkeMfjxKbafj4jqMFakyLR4iImub5DYwP3zsm6jggRPH74sa6XGCM3HczzRM1z9+tmM75LvebHvHNTPnhqHlvmvfwaA+8Kd7jfkA7RdM955xz7psoyaT7G80tDt/61rdc8BmmeHK7Ibr3ve99S6469pd/+ZeO2F71qlcdlE5mwWtW3hWCpOochA8gE8YQ9p9DppB3XK77XJ9ZmVe0zmibVq4L2Uc1fOsQZ0F9fBfXAPeV6xABj/aPCR5TN0JRGHyXfH1IfzX4n3mmmOZxtzBe/OZzAQGJ9DncMa0U0vGmeQ+P9sFr7B73AwFdEGi0njp/o4XGAS304osv1nnnnef86viF/+zP/sxt8GjbiwEm/W9/+9tOmDBys+A1TP5ogxAoY8V8DilD+vijo+Zyi0wnlY3KdM0qz0U/szKvUY0cQNBx2n/4GAQPxmkR5hA8GjzjwC1AYB/peBA+0fu8uGdox1gbor9jJcFYEJiYA1hmiFGIq7kPuJ8IL9Egw7ngTfMeHu2BJ3aPtgDCgmw/8YlPOI2XPuBonP/4j/+4KGKHCNHS8e2bKdu0WMiXQD60ZLRe05Yhx2bV5SBatONo69S4ynPh3wRBxWnkpuHzO8MavmnxjIGxEnCHKwBtn//nOK7D9cxlYWlwV199tbM+AI7nt6w2IGARCMhvsqh5flvYqsCzQzhcTCEdb5r38Fg6PLF73A9EikNW+KvD4O9medSWhx0mOTROq+LWLJUrDmi5+PbPPfdcPe95z3MmbUiSc3EeBAi0xXCtdTT5ZtXlIBnGHpe+xmdWeS76GcSNNh/VyK2oTFT753daPXkC+LgnVg3PKtxhWo9LbYPYMXUjsBCJjsCwmruiMQ/47QgjdIoj/5/faaltWE2WUkgnbJrnvjKvuG+r+Z54eKwWrLzzzmPVAdKBWC666KLZ99hg+Rs/ehzQztB8+Z6BoDLIbSGkDoiAhxzwr0MakAe+XSM/NNwwqc9XXY4IdLTKaLlZ+ww/cPQzhAmIPa68Kr/TtH/z8V933XUunY7/R7hgnAgEnNeuw/uYs5ultllTG8zzV1111Wwp3NUKTO2Y5vGhY5pHcCGKn2celzmxUERN8z4lzsOjNXhi94gFqW6f/OQn9ZnPfMaR0p/+6Z860rEoeSLV3/KWt8x+n88xy77mNa9xhE4EPcFzBNO1CoiNkrGvfe1rHTGykeP3JkodgQEtPUqIVl0OEo1Wl7PIdMzaUV+wpZzxWdQKYeeM88fjDiAXHk0cYQLBA1JHeOHFODC12zit5G1eg0rPDCmVjG/wwu8j2AxhgVgBLAgIFhA892G1AqGH8WKdYfzMkbi2uO1oA8tzYY6EhUcPD4/7w5viPWLxwhe+0JHYO97xDqeJYWq98MILZwmSpiVhkkXL/MEPfqDXve51zgyLfxiS/+u//uuW7/CLXvQiJxBQYY2UOgiddDLM082qy1lJVlqoRoGvF7N2nJndPiNPO/pZM388RWUgfAQI/PloqggeaKeQN+Po1WZd8aUxdfUnddJTerT3wC7tuWNGxeuP1s7ijI5+VEIPf/79TdRYARACjBTJwUe4wY+NNsz9j5ajXU0wiwfuGO4N421nTXsjeFwj3CeEo2hrXg8PjzoSwWq29Xk8oICmjrn/Jz/5iSNWpibFZCDSuAInaM5o5JBztB86vt4rrrjCafkEerX6GcIMmjzCgBETmiLR90T+oy0itPCy5jB2DHXWr/hsQWM7ykokpePOympP4hr1TZ2ku36WUCabUtdASs94c73ynQFLB2SIWTtqIbCoemIIIH2EjdVGZtwf3BCMjRfCD8/GWty2E9wP27IgdgSJ1XY/PDxWGl5j91gVgBgw/ZMyZySNKRrT61zV5SD8KKlbNDvR9FHitqj1uM/snBAopE4EO0F7BN5hLYBAiDEIa6LhcfB+MlmQAqlaCbTttl06+gmbtC7frwM3FlQuSEee0XW/6nT4pblmlNQB38U3jwZvbVVJo1vO8rLzgXttPeKtVC/3jdgI3BI8v3bl4kej5vkXcl8Nuf4eHqsFfjV4rDgg0Je85CV6+9vf7oLVAGZyis3EFYwx/zjR+3F51ByHyTYuQp7PIPfoZ3ZOCJRj0ejxb1t6FwQMYYVJPVwalnE4UvudXg0cmVaxVNH4nV2q7Nig4SNzetKfrdOT/2ydTn36weRtpv24NLwwuIbFHWCa556tBuDSwGLBvQkLLFg0sEAgFHEvcWO0E2HTPMKfkbyHh4cndo9VAHzxaHYUtJmvNSq49957nTk9LkiLaHb8/3ECwVyfYWYnuh6zONomGj2R/gTJIQzE5cczDoLFwm6Cgc0ZpXurqtYqSqey2ndr4CwK3QMZ9R92sNnY8r2jpNgMnOcRj3iEGxtBewTvrSSZWWobFoQ4fzoWCCwc+N8RRkj5ayfCUfMIPD5q3sOjjtVjz/N4QOLrX/+6vvnNb8ZWl4urWgaR8rnlg7faf91yz8OfIUDgC4YgyT1HK+ZzCMmIlmuBqIbP9+PGwXUmE9uV793ghIfND+qKNRMTFGj53lFXwlxgXJi2ETIwzSOIIKgst2neuraR2tas+hxgXGaaJ17Cshza5Rf3pnkPj/vDE7vHioGAtD/+4z92DWesypq1RiUQLUqI5h8nAn6u6nLWfz36mZVwRThAW+Y6+M4hY84ZtQDgz0YrR0sOj8V8+JwrOg6i9NedUNNDHjWgVCKjdDajbddOa/MJeWXz96XAQYqk2S0235tKeJjmIXeEIqLQ43z0nQIWjmZd2+LIl/tLVD/uDSwjCxVoWrmGj5r38KjD+9g9VgSQ28tf/nKdffbZesELXuDegyiatUYFRIeDON85fl5e+MOj2iBaufVhh1jw+eKXhVzw00Pu0QA9a7lKXrpFv4dJjWuQ5x69Dqb1E044Xuu35jW2r6of/ddu/fy/9+l/v35g1mzO7yDozrrVLRYIKghAaMw0ZkErXg4g8HAPFtojHsEDYYRgN2+a9/DoHLzG7rEi+NjHPuYKu7DBR9ucxvX8tupyUe05LjI96ldHy+cYjscyYA1dTCOPsw6geUPo0Xrt5oOPjsPGgIDAGNBGb796VPS2SyQD7b+3rKAmjU+OORM+6XTtMJ8zBiwNWA6wAjC+uGp57QLWDa6D8LWYvHp+M+4LngWmeWt8403zHh7tgyd2j2UHxVz+6q/+Sl/+8pddFDqgCA7kHVcwppXqchaZbqZyTPqQNuQNyVIZDfKzc4fPGdXIGQsEGS1sYxaF6DGMgXNhHueF0ACxHv3gbk38fEwpJXX0Gd2qBVVHihBZu4vNkC8eNc1H71W7U9sWC+5ptPEN2v9CSw8vxDRvKXE+593jgQBfoMZjWQE5QkBES//d3/2dey9cXQ7TeByZoBFDVtGNGfIm3x0SZhPHd86LTRzytepy1knNgBbPWNAew+ckLYuxIAiEi6tADhzDNSCh8DFE2jMOzoUQUc9nr2vzhcmKSoVAfevS7ncQdHfGqY9QOpdUKt3+wioINVgb0Ii5n9YZrx0gJoHfQLZAu6rK8Qyw3CDU8XzjYieWAl/QxuOBCO9j91hW/O3f/q0jckrVhrVdtO04Uje/dZzvnCA4SrFiLkeTRlOFOCFlyBdNEHKLkjq51WjkfC98ThsLhB6tmIYWz/mix3A9/M2Yw7lOtMFLvjftSP1X39iha75OmP0xuuhf9uqnH92nyf0VtRtcG989Qga/xYSRpYJnxrmapbYtFtwzCB0rxq9//Wt3L9uZwheuNY9gggDha817rHV4YvdYNkC8RMBTYc4iotF2CWTDZxuF+a0hqmgENURDIBwbNtoyZmesABA6Wh+kFhc9j0aOKyCuYh1j4ZrRsXAttGBIPWwutnx7rkNgGOeL823v2Tal639T0lSpVzddXtDMWFUj95a0+6aiOgUCBbGMUMiGnHdyzheLcBT/XKltiwXPkNRGYh14BvjemRPtBL+fuvtYcDi3meg9PNYiPLF7LAvQbKku99a3vtVpfYBNlgjxZtXlIGe0eEsJ4z00bTZohAQ2Z8gWAkPjM00SrQ/EVZczjTyaZmZjwTIQDmqzYyC1qEWB66ANYjFA84xaBuz4O+66WSjx6PlJ3N4Zqas/pcEt9/9+O4EvHDcEwo21VV0M+J3tiOKfD8RbYOaH6Bkv2nU7YJ3zEMB47jwTyN0XtPFYq/DE7rFsDV7w97761a92f0PKEOZc1eXQlDFxswnjRyelyyLc2fzpGc9GHTZ9W6Q7wkI00h2/Mxp7VCMPV7qLBrVxXQggmg5HcB7R8VgKGGezwC9nBdCEHvHkfqVzUjkfKHN0Uo9/5bDWHd2+YLFm4B4g/CBM4cvGZbEQUzTk2qwgUCeAcER3P54FsQ5U/VuqZk0NA86Blca3gfV4IMAT+xrFRz/6URe5jBaL1sYm2Qq+9KUvuc3vec97XtvG8q1vfUtf+9rX9PGPf/yg6nJo6XHV5dDu8Z1TAAazueU8o4HzW0hhg2jjqss1i3RHI0fzjKvS1qzSHWZsiCWcPgZB4PfHNM3/Y+Ll/yHwKAHxOzDh4x7Ys62ooCpVy9LorrK2/XZ+03hQCzSys6x9d5dULi6tBzkWB1wVWDwwzSOMtJraxr1ezpaxViMA0zz3n8j5xfakJz6DZ4NgEhb0orXmvWneYy3BE/saBGlkr3/96/XOd77T+SvZ1J72tKc5QpoLbKJvfOMbdeaZZ7ZtLASq/dEf/ZE++MEPzlaEg1wIZIIw43LS2cghWkzjaMJs8A972MOcfxfCb9Z/HSEAQo9+ZtYBS7EKwyrdRcdixyAcYVGwiHsEJLR7/OlolowrjoDM/Ms1ScXbuLVLvemEsmUpORnouovGdc9vmpN7rRbotz+e0GVfGNFlXxrRr746qpnxpQXBcW9ozMLvQViabz6g3SMYRgvxLBdwIeBm4d4zXgS6hQDCxm2DCyEu9S9ca943kvFYS/DEvgZBgNorX/lKnX/++Y6w0JTxt376059uegyb53nnnad3v/vdsZXdllJd7olPfKJ+7/d+76CKbmiBVl2O77Fp8z4bOJoiWrc1YTHte64I+WaR7mHrQDT3ms28WaU7BAjMwiZM0FYWUz5BcggdaOGQBd8JExC+fzR9NHXGYWb/0548qNPPHlJ3NqlaVQqqgXbf2rzj2d47S9p29Yyy3QkXVb/3rpLuvGrxAXAG7gNWC+4TggfCUJxpHmHHeqqvZO43gh0uF4RChCpcI62Y5vkOpI7fPk4IjJI7YN4xJ3zUvMehDk/sawxsTFdeeaXOOeec2ffYuPgb0pkrDQ1/9Ste8Yq2jeUTn/iE02IRNKyHNkSCxoi/nY0UPzUlXvkef/M9NGA+DwfUzRUhP1ekezON3ArboMFHK91RmpZjuD5+fczWNDLBT81nXAfCCae2GQERSMcxEBDH2OeO5B/dq8e9cL16N6RV7Zbu3jGj6Yl4LbxcCFxP91xPUulsQslUQjNjNY3sKGt6iZo74P5imuf3QJjhtqqW2oYA0M7UtsXCetJzf3GnIJAwV+YCQhgCFr+hFcHE4ja8ad5jLcAT+xoDGi2bUzQtib+bRUVfeuml+vd//3eXhtYuoLFi1sdaYClnlguOBgURowVj3uZvTMT4weP843ER8q1Eus9Vex7iZuNHULCNn/uGPxZND6CRMy4IGgGAc+Gr5v+tulwYnAfNkvchCkgoTEB8vuXkLvUenlYinVCpFGhsb7zveHBzWj2DaR24t+x88tVKTffcUNBPP3NAP/n3A9p2zfw+8vlgKYLcb54Fcyec2sZrNaHVnvTMI+bXQqvZedO8x1qBLyn7AAebIGlokHpcgZjFgI2Xc770pS/Vk570pNlAMjRkNECIE0EDH7VFxEPOcf7xcIQ8BBuFRbqziYcxV+15At6IlEYDx5TO8VgOeHEc5nbGFg6yw4cOSUPcvB8XIW5CBuZfNEUIMq7z2imP6VdpelSDh2W04cj4Dme9w2k9/Dn9uv2Kaae9H9hRVmGi6t4vTtV03cWTWn9UVj2DS6sJjxDCfeUeUxcAoYX7gXa8GmE96XGvEASIYMacCQtnaPQEQlLed7FtYDHH87z518rRengcKvDEvsYAObNZ43MOg7/jNDA2SEjr2c9+9ux75mOEvNB80KIXgve+971OYHjXu97lCN1Ik/NBjIwjTIyMDW0xrk689T2HHKNkalXfoiRs1gH89tF679ZylTGwWSNkcG1IgPfwK0evxXnQ5BEe4qrLGbA+4OcnNoDv4FLAP49pHlcAZnqi20e3F7RpS0bHPaJf6UxzM/G6I7LuRXT8t/9pr6ZHqpoaqSmZoqJd0hH8UondADnymxBGLFhwuXu8t6MnPfOV+R9NT1woLKiO+YJ7i+feqcY6Hh7txupcuR6Lhvl6L7rootmUNTYn/rYc8jDQeMz0bHj729/uiPnDH/5wbG/zuYAWRQT8F7/4Reen5Txo4owrrmY7vnM24zjfebjvuTWLieaex0W6W6U46+IWBoIAGinHI1Dga8bczrUoaWrkbUBrsxx3fkczUscKwFgRCux3WPAcY7fOa92lo3T3dVNCdipO17RxU5em9ld0/Jm96t0QX7AmkUyoPFPTzERN2e6kCpN1wSvf1z4tkt+JEAIhUqoX0zzZFIvRepcLjA0hyhrfMBcQrjDXt0PDNoHQoubNUuMbyXisdnhiX4Mg1e0P//APnckSjfVDH/qQ26yJkgeYyNEe//7v/96Zxq0SnMFINPr+fGCDPffcc91xpKTh8yboiffRqqOkPpfvfK6+5/YZm3c00j2skYdJCTLnGDR5S5fjO2hhHEPAIfckWoIWkz33CHM+44/TYjke4ub4aI35aOe1XffepkB8J6FqOdBtP5t0aWzpXEKnPutg4SV8n9DMZ9alVK1I3dmUBjZAMGobLLXNrDOdaqvabphlBLcLv4HnGo2nWAqipnmeBXPAm+Y9VjM8sa9BvPCFL3TRzjRagcjQIi+88MLZgDrMyu3emIiqJ1UOoeBNb3qT085NC47TqufznRNkF9f3HKD5opnF9VEPV4qzNDquw/1gg0ZDtwpkBvLl+W40zQ+zPMeZab5ZIBYCA9fkvM2AMIGQdWPvLbp9fLe6ahtdO1dauXYPptR/WPPysox1w9FZFcaryvYmVJysaf3WjIuYbweYI/xWhA+7LzwzniXZCtxvtPd2tlVtN3DLEFzH78AC1e6e9Gaax9JjfndvmvdYrfBtWz3agk996lN63ete5/zJkIJpuxArRVyiBMxGDOlDmlEzO5oRJn3M39FgOgiUz9Di0ZDDIEoaLRPrABYKCB1NHTJHgOBYPguTOgIEmjRCQjgaHxcB10FAwKIAMcdt5JRcJV0PQSauNO5BYy/W9POv7NPO22cUlMvq6U4om8pr04l5dQ+lVRirad3WrI44o1vJ5MEacmGyqusvntCem0uO0M/4nX4Nb1060XJfiDDHRx0Xg9HptqrtAIIZwipmeeYOz5Nxd6InfbgNrDfNe6xW+FBPjyUDLeltb3ub860bqZtWHVddbi7febiCXJS4LQ+eCPNon3E0KQgIcsUsjimZ49nseQ8Cjxa2sWI50RQ7cxFgyucVl9oWLbk6H6mDffeWtO+eoisrGyQyUq6kQmVK9147rbsun9KeW2d048Xj2h5Tbjbfm1Jfb1rjt1d0989n9MP37dUdv5jSUmCpbbhBmqW2RduqmnVjtQDBkdgAq2WPOwEhDfcHfnfmYDthpnl7/r6RjMdqhCd2jyWBTZ6SsZhxf//3f79pdblWfedzVZCL64nO9dEm0a7Rztnc0T4xe0PsbL74XzGTR4utEGAXl2KHUIAmi/8eQm8WHW5+6aifvxkGN2Zc8Bu8WIMba31SNa2ZqaISmYr6NmZcBPzojvvnttPq9crPjWl0Z1ml6ZrGd1Z0xedGNXLP4mqoA0gaywT3s9W2qrg6OtFWdTEw7RyhIywgIkjyvBFIeEYIfO3oSW8IN5LhvNzDdp7fw2Op8MTusSRQ2AZT9L/8y78cVF0uTqsO+87jNPm5KshFe6KzkVJkBi0SPzCbK2Z2otrxtdpY2NgxpUcL9iAkxAkQlkJHVzm0VYg7Lh7B/NLEB7QaWNbVl9Kxp/e4Lm+ccnqqpg1H9DqT+vj+Ge3bPuHM8UTARzGxp6Lp0Yrr/UoVOhrKFMZrGr233BZNtxVAnghwoJ1tVRcLBDbmSbMSyBa0yDPFRYR7phPau28D67Ha4IndY9GAGPCrf+xjH5uNQEfjjmrVrXRfMxKOqyAX7omOwEBeO8SC9mhtW7le1P+Lj500NEg6KkAgJERT7CyFDg2e6zRLbeN4vodwgu99IdhyUpd6hzKO5Dcdm9PwsVmddOawjjhlQMWJqmbGS9p9y4ymD9xXsW5yf0U3XTKm3EYpv06qJQJH8ETS53qTi9Z0eQ4L7dqGUEXMBBo8Al072qouBghWzLX5atlb0CLzkzmDMNhOeNO8x2qEJ3aPRQFyoLocjWPOPvvsWK26Vd952Pwd7ZUOIA8+w/zL5ozmZeZ2tEY09KhGboVtIN+wRhouQRtNTbMUOsaHth5Nz7Pjibrm2GhFu1aw7vCcnnr+Rj38aYOqFiradu2kbrtiQqc9fZ0ed95mdQ0HmiqPaGz6wH2//8opTR6oqHdjWqmslO2Tcn1JnfiUXm06JaddNxV092+mnRm/HZrufDA3ChkLmPOX0lZ1MWAuYF5nDrQiWPFMEeIQAhDIeHXKNM+68KZ5j5WGJ3aPReF973ufI1XS3MIaNxp0XGnauXznZv6O9kpn84U4ePH/mMUpJmPmdrQvjo2mr80VnEf0NBtvVICgWQyBVrw/V2obVgKsAAgMi0V3X1q5fNIF0eW6kioVatp1W0FdQxk9/g+P0OEn9unXP7rdCUn8lmq5bpof3ppR/6aUjjgjr2e8Y4MGjknr0s8f0CUf36dffm5El352RGO7y/Nqurza0bUNCwnBiYttq7oYLKWWPcIfpnmyJ4jJ4Dm2E0bwVq3OB9Z5rBR8HrvHgoEJ9h/+4R/0gx/8YFZjMsKM1mwP+87jqsvFVZDjPFaGFg0IM2qU9NHacQXg445q1s2C86iCh5AQLUFrzWLQYAn2a2aC53hS+NBUl1pudcNReQ1vyWrvXUWXl/6bbx5QKptUT19apZG0cn1btePuu5zw1J07XlMjVY3vqSjbldRJZ/dpZE9FN16CJl92+e25npQ7128vlJ7w0qFY0jYXQqua7kIqHXLP6RKHkIVA1amCNlhhIM3F1rLn+ZKaiNUCYYRiSu1sdhNuJGMFbZifq7XAj8fahCd2jwUBQv2DP/gD/dVf/ZWLOp6LMEE4gK1ZdTk2Qny2aHyY5CkKg0ZOChmkG25/GtbICc7je60UtjEBguuE/crWLAafOub1ZtXlrLkIEfDtyOXO5JM66sG92n1zWaWJqsrEddVqKo6X1NOb0hGn9emkJz5K1/z6Rl31w53KJfqU70urPCnde3VBu+8sqTwVuHx3zlWerimxIaWp0aqraEer12apbYtxIcwFSAt/vZXO5RlEBbF2gPMyzyDmpZybeYHFhbmDSZ/zIpC0q2hTOKgu3EjGF7TxWC54U7zHgkArVjTo1772tbOEB8k2qy5nvvNoABvANA8JQ6ikUOGrRVtm48bPjbYKQUQ3XDZ3Nstoc5pmeemm6UEGEHsYmPMRKDiGz+P86gCzOBvzQhvizAVqv1eLNZXHHKcryEiVmjQ5U9XeHUVd+Y1xJfcfqYx6NT09oZE7i5rYVdFNP5rSyF0ljW2vCwWV6ZpqpUDTB6oa2pxRKqaxDPcMjX2+1LalgHmBqRuLC9owAl+7wLNFaMBV0krNgFaApk7bWuahN817rCV4YvdoGd/73vf0+c9/XhdccMGs9tGsZnvYdx4NYLPPCEJDs8HnixaJv9Z83GjRCANRkzFkj7AQJXxLs6PSWDQ4D/85BB49Bh8rhI1QwjWbmeDp/kaEPW6GdpbipZRseTpw9d+VkQh9CypStSDd/dsZ3f6rKd1y6aQKk1JhtFfFYqBiqariWE3Dm7IugK6E1p5LqGd9Wt25hNZtqjcp4X5Q6c7K6uK2YPyd7thmtdt5nqSYcd+WCn4D1haEtahgtlRwTuI2EBYoaEMKYzsRNs3zDJhzq6nAj8fahDfFe7QEyO3lL3+5PvCBD8yS+Fw12+MC2NjQCFxisyeYDu3YTKLhgjOQOtp/1PcZTpeLlgq1NLto61f8sbgCokKCpXwhoLDhcjyuhGhBHY5HAEHTjVoBlopaVSqXEo7Q3YgJ1G78kUhJtUqgSilQIlnPe69lUkqW0dCrUqaizSfltO/Oso57fLeOPDWvmy6cUHGipqmRin77vXFN7Kuqb0NSM8M36rgT6qby5YB1tcNlYV3t4oS7VhFuh9sJXzVzAKHP2sAyZ5kv7TTNY5kiDgX3ERYNYhN8IxmPTsETu8e8gGxf+cpXOtJ88YtffFDAWSvV5SB5NCE0bTQWSJtNnvNFo8/RrCH/aB91gHZtndnCsDQ7yCN8vjghAULnGhZpj7aOhs/YMB+j1VosAMfjg4UQ41L0lordt5Qcg3cPSqVyVTWMIATAJ6RUUk6TD2p1kqeojStFW0kpPyzt2z2u7sluDW3p1gmP69HglrR6hlPqWZfW1d8e057bSuoaSOrOa0bVe9SAjn3a4lLblgLiKqyrHdr7Ymq3E9MRbYfbKUC6aO64hLAMUbynHUGGuCSwJhHwx29gPUDuvta8R6fgid1jXvznf/6nM1OyOYery7FJz1VdDpIkBx2Ni00MQoYk8afH5bpD+kSdx/VRRzDAahDVyC0vPS7NjusiJHAMmjeWAsZllesYHxs5mzcaG5aDsMbGdzFjd0pTTKQIspKGtuY0PVrWxL5y3TkWSNVSvexssnEb+BcLbnIwoY0n5tS/Lqvd+3aq+0Gj6tk46MaXyiZ00f/bp/G9ZXUPp6RsSZWgqIH8YSpNB9pze8Fp/oedmFM6uzxeOKvdznNlDnGf4+ZMHKwdLvMmrh1uJ8Ccxu+O0GqC3lKuHQ66tEBPHzXv0Wl4H/sqxEc/+lG3EbApQkqkETXDJz/5SZ155pnOjMjrnHPOmfP7CwWa92te8xr927/9W0vV5awbGFo8mg/aCt+zgDg0a0g4ulma6R7fbLiPOkC7QfOOS5ezNq3RvHSEBEzsWAyMVND+0OrZbLm/bOJhvzrXRsNEgECIYXMnIr9T7Uq3np5X34a0Dtxd1cxEQv0b8uofzqs2lVB5mtKxcmZ4bnEqI2W6pP4tac1MB9p6xqCe8+pT1XPYfTnk+NR33lLUxJ6qpscq2nX7hLrzvdp4dJeu/Pqo0+Sv+taYrvnuuGotFrNpB6x2OxrwQmq389yYF3GBl50EpnmES+Ybc9jqCSwGzFuE2nDQZVxBm8We38MjDp7YVxm+/OUv6/Wvf73e+c53Os2WzfBpT3ta06CeSy65xDVf+clPfuLIC23z3HPPddrmUsHm+9KXvtSd/6lPfer9yrGGCY+NiSA4xgDRYv6GzBk/RM0mZrnumO+jgKC5XjTq3DTyuHQ5tHEsAtHe26Yl4cOHHNhE0RrRvkilQ0OHxONS2/CjM27M+53G0OEZnfnSQZ329F6d9tQ+PficXtFbJb8x40zyEDo14THHO209LXX3138nvvdweVeEubHSTh33mG5tOS2vnhP2a8ODEnr4s9dr+MiMDtxb1sBhGXUPprX3jpKmDix/0xKeH4ITwt58tdsJeGS+MH9WKk0MQRTtHUGW2g3M/YWA9YDbh98Q508PF7RhXfiCNh7tgu/HvsoAqUBCH/nIR9zfLHrI+i/+4i/05je/ed7jITU0d46HlJeCv/u7v9NnP/tZ/exnP3MaOCR71VVXOWK0tCkrJmPtMdFAor3NAZv5lVde6QLUomlxaJucFx8k+eRh4Pvmhc89WpWOzRbfuQXzmS8fMmeThPC4dyaA8BkaFP5afk+zBi8cz2bO8Xyf8yOMtNscv+/eom74+bhG7i6pvzer4x7bq19+dUwTe8pKVGrKNG4TPnbNau4JdQ1n9fgXDmtDqB87FhS0S549lgieCS4E7hnd4n71xZH6PaoErsPcE142rHzfyhAmzwlXDmOMKxCD2+Syyy5zQp61AV5JWNAmlhyEw7jKilEgGPIbWimAE+7xjhDjC9p4LBXex76KwIYG+b3lLW+ZfQ/iwbyOJtwKMEFDatHCLQsF44DYv//9788Gx0GwVl0ObZm/IUuuxSaMJo8PNUrqluseLQ4T3jQxmUdJ3eq9Q8RRzRozOxsg5+QckISlVvE3QkL4WmbOh6Ah9GapbRAkVgBSoBgPMQEQJu+jebUrgKtSqun6n4/pwL0lFSZrmhmfUf+dafUfntDYnppqRSk5I2V6paDhd0dzr1YDBaWa9t9R0J6bi8rmE67U7NCWeuc1rDxoirgQ7J4NbE7rhCf06K4rppXsTuqks3pXjNSBNe1h3pBxQMQ7FiDzPWOq59khlK0GcB+5n8wxBND5BD2LDWi17G1cQRsfNe+xFHhiX0VAI4AEow1N+BtSagV//dd/7YKTEAYWC4QDqsu94Q1vcKbeMMmyqUF0mFExZ2NhQINnw4vznQOOQxOJy0GGoCHLqGZmleLi6r1znyAviJbjsRagpSJccK1o1zIz5+MS4MWmGWfeDRdBMSGDfzHHQjb4srnmUoUmd60SqWw1Vyu+PBkoSAbas2tGQSrQ4NEJlcYSyiQTqtSq95niMc0HcmZ16sJn8MGn6m1cNx6Z0xkvqFfqY3z8XggCc/LYzqqOPK1LRz+s22n9yfTqKG/KvOb+Mp8sap5n28mAxcWCsRDEx7xirhM1j4AbJ+hZ2VuqHy6l1jxzFKFiNd0Hj0MD3se+hkD99i996Uv6xje+4bTSxYJysWxg+PrNrMhmxqYDobIhs/ES1IQ2j+aO/zGuMxvaGH7GuP7r+LvR+PksunlZ4ZtovXc2PEgLqwBj4roQAho612I8UU0PTZ7fgFBim2UcCOzi+KgAwvchdAQGLBmMbalFRpymvTmnVC6h7g0pbTwuJ6UC9a/PqKs/qUy3NDkaqFomqb3uX7fVyqVpphb0S8GwVB0ItGd/QZd+drvSqkehI5C5oMEf3Kiffmqffvn5EWfGXy2kHq3djvCG6RoBFsLsVMDiUoEggmWE8SHoEQsQBnMQi89iYwOitea9391jMfAa+yoCvjs2A/y7YfD3fCa9D37wg47Yf/zjH8c2YmkVNHbBr/7zn//cae6QNtdnXBAwYwyTsFWXi6sTbyVeIfxorruZxhEOokKIFb4J13tno0Ob4xg2PDZYxmPnbZYOZ5YGfJ2Y7pv51RE+EDSaaYq8Z2VzzTS/2Ih5/NxXf3VCe28pq//onI4/t9v1Z7/yewc0srOsmfGayhMJdfWnVC0FqlWqrl0rbVkTiaSCSs2lvyW4dLUeOR/kpKnRso7d8iA3VivvevlPr9PE5Jg2Dy7dytApMLeImucZMi94DsQKrNYCLsxz1hhrA9cHzYN4mcWHOb2UsrdR07w1klmt98Nj9cHPlFUE65R10UUXzb6HWY6/MQc3A9Xg3vOe9+jCCy9csPkvDLSP888/3wXpQa5oxJjE2VA4L2b2MOnFdWaLFodhg4s2HbHP2LyjAku48A1aOdeA5KnlbeZl/N8QgZE6WntcOpyNDxMqgkAzvzraPN+D/OezdPA7IUzuAxobJtmFYmp/VXtuKqkwHmh8W1W9/Rn1DWe0cXOXZnZJE7cHKuwKlEsntOmEnFRJi+o1pamEilOBEtWGRI7fnceBib5WU/9gtwY33BffwG95wlMfpkf9UVLjg9fMBjiuRhCfwfOxdEOi/JcjM2GxMEEPQRLf+69//WsXL8A8a1fAn2nvzGMsVUbyHh7zwRP7KgPmb3LTP/OZzziC+9M//VPnz4ZwAZHu4eC697///fqbv/kbffrTn3amZuu3jaa6EHAMwgMkiRkXczuR6ESzG8lGMVedeM6HrxSyjWrAbITWRz2McOEbhAiqwxE0iGaEAMDnaMlh7X+u7nE2PvzMaDxxDV44ng2Z80djG5qB82ChwGRPZD6m1wVtuJjSx6ua3l1R90BK+f666fWeXxeVKFI7NqVqTdp9W1l77ywrnUvo2Ed2q580uFIgDLyZtBRM1kvRoslng5oe/n82Kt9Ihzs4h/xE567gPv326ut02y8n9NsLx7XzpoWlb3UKaOhWi99iGpgDCE58tpqB4Mp4IV7G2u6WtWHTPEKvN817tAJP7KsML3zhC51Z/R3veIfbjDH7ookb6ZDbi9nY8LGPfcxtKi94wQucZmwvzrGQ5i5sSBAU+fNsVPwNMcY1VQmby+N851biNZrrDhBSMI1zXJRoEQY4r/kv0YaJnsZawKbJOKKBa826x9n4rKlMM5O5dT1jrAuBlctlbNw3nhObbiu4/psTKk9gXk2osL+qajGYjXqnBStEPjURqDBFtbiSCmM1PfjJfXrqn61T31BSub6Ecv1JDW/MaKA3UGKyqKNOHtTU/or231WKvSaCEtrwPVdV9Muv7dRtv5jQ1d8e174m318uYHpHsGI+mPDYzgIxywHmD/MaTZ36Ce2IwQgjWtCG9b6a74fHysP72FchXv3qV7tXs4I0YUAqSwWEiRn0P/7jP/T0pz/9IJKNq9lu5vK49qgWgY4GHM33tepyXC/a0xz/KufkWnwvnNPORsl7+DHDaObfN98+xIt238wEb13PojnyCwG/A8LEt4p1AWFsPv/q9L6K0l0Jl09OH/XSdE2Z7rSOeUyXbvjBlCv/SoEaqs0Nbk4rmU5qYm9Ze+8uqJKuKUhJQVqanimrGhSUKHRp29XTuvPmKaV+ltDDnzGoXbeWVZyq6YnnDyuTq//2dCKnzIHDlQomVUjtU3VkSBN7K1p/9MoEqlmPeOIB4srMMk+sdrulGy4lKLQTCJeMRbhkzEuNwWjFNM+9Y84iBPmoeY8ovMb+AAebBMVvXvSiF82Seri6XFw6D5810+StxGtcdTm0YzYkI2j+H0LHP0k6mdXpJhfeSB2tHSsF70Wry8X5981/z/GY5uOqy9nxkApjWWrXM4uN4H4QC4AVYS6N7Zgn9jitvFIIdPgZeXWvq/+uE5/Uo0e9eEBDm9JKpWmBmnA13bPdCdef/e7bJlXDn+6K1gSqsMFX8s7PXu2rqZoOVKzVdNVFI9p3Z0njuyuO3A07fjuj8XtKCqbSShcGVaxNaP/MthXT/pgrBGjGZUUYzDRPSmVcFPpKA9cR89LmeztiMOaCN817tAKvsT/A8Y//+I/OtP+Vr3zlII0b021cTvpcmjz+eCwI+OijqT7WRx3TNdfAp8rfkApaPxs35Bg+zorXQL7RrmBo6nw36t/nt6CJW1GbOL+6bch8FrUCLBbcCywYCAlocGhszVqVHn1ml4aPyzgT/ODWzOx9nBmtaed1RQ1sSGtiX0WlYuDS3CgTWy6X7iPpRD0PHpbnv1RfveOrfTZTCvTI5/apd11avcNpd7+5Rv/hGQ0ckXHn7N+S1fqTBrVz8nonjKANx3Xp6xQocEQ6HvOh2TOKFohhzhCFjiWGe73SmirZIrh7IPKwRchiMFgLxGDgDiIeo13j9VHzHvPBl5R9AIOo9yc84Qn6zne+MxtNj3bMBhpnnkaTJ1oZv3eU9ONKvIYJmuPw/UMyBM9ZURpMq5guEQaiJmxIHR8sJB3eFNHa0PDJ1w6TEdofY8DSgIkcYSEulxgrAdo6G3InyIz7BLljuWDs43ekdfflMy4tbeujurT51Hhz8s0XTen6b084jfyYx3Zp00NyyvemNLQlrd9eMqobLxtXdZrWrazcmjK5lMtLL9dqqnCQGQkS0nB3Rkef3uN6vt9zdUGZvJTpS2r/PWUVxqsuaG/90Tk94gX9uvPeW2ar1UUDEDsB5gNuC+ZDnGVnPoGA+cKzbVYgZjnAMybvHuEtmvURBgIec4G5zf2dT4hZKFhPCMcIFpYSt9ICj8fKw2vsD1AQcEZ1ude+9rWzpD5XTvp8mryVeI1L9bE0NUyvEC5mdf7lPYgYQSBK6s3y0s2/H82NN/89ggVac7PqcggKCAUIJ53SUK1VKffkkv+5UuVrjlZQqPtaR+4uK9eX0vBR99/g830Upkm6ILrBLRkdfvJ9AsDWU3p059VTmq5VVZsOlAiSynYlXaW6WkWqFBvE3rhVMzNlXfvDMQWlpLoGUhrZUVGhUKs3lgmkbE9SI/eUNHJv5aCWtTw/7m0nc6ZxlfB8og1/WgHzBIGs3ZUAFwLWAvcKIWguUg/HYBAgyHgR9KKpoe0yzVu1Ol9r3sP72B+gIFcdE/gb3/jGeXPSwVzV5dCg0fjCEfJsNGgrEDcEDdkiQNhGzIYUrvfeSpvWuXLjERrQBInmRyiJM4FbHXKu32pP8MWC+0Aw1WH5E7Xn1pIO7Jxx5vU9N5dcjfc4HPnwvE44q1vpZKB7fjWjkVDE+uBhGWWSKZUmA1XK0vSehGYmayoVaqrxtVrjhU2+Uv+nmApUSFelrpqmxmuqVuqR9wgAE3sqruiN1YznfuLLJvsA68pCO5m1CkvHRNterGbZiUqACwHXg0StEdJ8sC58zE3uLXPVR817dBKe2B+A+NGPfuTy3i+44IJZApwrJ900eTS7KGGywZkGjXkUzRnfoxXssHx10pfCfnKr9x4NnJqrTav5z6O58bzHZskYEBSaRcEjnBAHwO9YLnNldSyvFGXhUlWVqwWVZ2oa2RafYkbN9323lFQYpclLSTdfeF8tgnIh0K4bihq5uabK/qQqM4Fq1aCex84XIvFvRUrOdknqlUZmKqplEd7q3+VFvBxV7kZ3lGZJxoIXEfgwM/OM2olwISDmSjsKxOAysgpwzMVOA2GVtYBgsZBMCsZLPAdxJBxvrpp2IlrQxqLnPR548MT+AAOBby972ctc5zbzb7JZNctJb6W6HO9jnsc/j++UPHVM4hAF+ffR6HkTBtBooxt8s7x0/OcEW6ElhVOILMCO8XG9ZqSOgEHAXCf8nHOhayilnnUpdeW7lUqmVclPq0hlmSZIZxth74FcHXnDxOSESsG0UsmUZsb4jHzvhIY2Z5QI792R/3ef0e61u7HYQ58XJgP96r9GtPuW+ywImHK5RwhjxGBwz9tBDpbaxnxopeNZq4hGoTOXOwWIGEJGgFxsyVisRYyXc7FWiBloJ6KmeV/Q5oEJT+wPILDYqWSHGRRyD+d8x+Wkz6fJmwYN0bJJ4Rdn07Pyt5hzowRtwgCm+egGb5aBaDS5+c8xF5PzHAbn4nMEAkz7c7XRhPyjx3catFTt3ZzW0NEZDWzuUkpduv3XE7rw47e62u5RPPh5fTrqcV06+gndOuV3+maFqxtvvlbHPSardCqhWjlQrldKZgON7qqoUjo4cO4gcBvpI1NDaJASmdB3atL0WE23/eT+ggZleCndi1UFdwrukaWA58o5FloIqBVYFDpzFEvRgisBtgDOh4BL+l1cl8KFAOETt5SlRyIQe9O8Rzvhif0BhM9//vP6yU9+oo985COzpui5ctKtehum67jObGjAaMzWox0zI+bzcHW5qLmS86GlRM3pYctANK8cMzufh4Ot0ODRKBEm0PrR5NFQaP8ZLadrWmdcfECnseWMvB50dq/j3Ym9VfUOZ7Tp6GHturaq7330Jt1z3bgm9xDmXkffYWk9/CWDeth5A+rZUL933Gfu44NOP1zDgyltWJ/W+qMyqmJur93H00H4xeNqPDK09kyXlNkgZYak9GD9O/jq8bvvuKWovXcUm+aQQ0RLySEn1XEx5uuFgLkEsRO0CLEzN9pp6iZTBGsAboR2uHEsPRLfOwIpgidrqZ3wpvkHLjyxP0AAOVLNDlI337XlpMfVcw83Y7HocciRzZ1NE/+5tdyE1CFjqxqHdh3XRx0yZhOLKyfbzDJg/nOOwUwMaSMAoOlAGHyfzRZtnk2d34b1wBqeMF40IkhlJbpj4Tc/4ck9OvYJ3RrcmtKRj+jS0OYuHXHcOk3c0KOLPnSvLvnoLt37m/iGJwgu/BbXTeyKgst9TyWloSOy9a5utbpm6prBJEMvWr0GoRfd4fCxV+stYFN4QBpKbaUcaGxXZc5OZpAQfmwEtoVol5AV5mvmUTujwZuBOYepmzEijDB/lgrmHJYhXBTtTq/DgkRHQYRj5i0xIJ0gd9YzAiLCr/e7r334dLcHANB2//AP/1DPf/7z9YxnPOOg6nJoutHNKtyMhehxC4iDINkYrKAM5sRoShkEbXXUwzDC53zR9CSzDEDMYfI1/znnstKdaE2Y8NEmGQOWhnBqG6Z/NncED0idADDeixa4WW7QC93lmjUwsz9QopzR+hNTOrB7VL/5VkmbTjtK6UzqfnXUeUb81un9U8r1JpXKJrT52LzGDpQ1tqceMObS2EKyWcJ87OayD3Gx+3+Iv6HNlyarUrk5Wce1rG21ZzpCGAJgnCunU7AodCodEoXO82f8i9G0bd5xfLREcrvA+rP0SCxOPG9cIe0Cv5u1joBi6ai+DezahtfYHwD4p3/6J2dKfN/73tdSTjokzuaN6RptGc2Hf9ls0FowpaMlR0mdYyg+ExeEh3mUTTJa6c18/GHLgIHNiPNAzmyuCBQWtY2AAVkwhqh5F62d76Htcs1ObcgLwYbjsuoeSunA3WVX6nV6tKpcd1J9gz0aHhrWTGHa+Yctzcy6zjF2hCE25wc/u08bTszp2DN7dNTDe/SU8zfqsS9Ypy0n5VzHNxcZ70LepVpRqozIpcLVOCUme9PmA6kyLSVQ0ilghxW+1nqgGve8lUA1hDWeHXNmuYumxEWhL8bUbXOw024cxss1iBXgmu00zRMLw5o2V4iPml/78JXn1jjY0NiMv/Wtb7nUoFaqy2HmRuvF1G39pTEZonVbBbmoBgZB8xmBRVFtA3Mo5vtwY5dwXrm1Y7XNn78x+TJOxsf1rfUqWgcEiGBBZDLCQJyJHVLBlQDJs6lx/lbbsnYKe+8o6Y5fTqs4GahvY1LTu6sa31lxhWZOPLdLI+nbHRGyAVt5Xsy080Xxc79u/dWErrloTNOUnXX92aXKhFQrS5neekMZKtbZ+2kIP0ioWgqU60noOe/ZpMEtrTUs4XoIehAQZMRciBI3bhdS5vgty1HNbi5g+YAoybZopUnPclUobLVy4VKsTTwHhLDw/Of5mTneaj74anVrC57Y24yPfvSjrv46/ms2tf/3//7fLKHG4atf/arrp84mziZJf/VnPvOZbdsgMJf/zu/8jt72tre594wY0QyiPk8ImI2MDYXNGEINb4KY5zkeM2d0I8DkioYRLTxi5WQh+2hVOjQJzI/46TGfIjhw37gXjB2TO2lXZhlA02DsCBn48KnwFkd6tpkxFn4H50SAYAyYZVfC1x6HSrGmid1VZXsS6llXr+mOwIVAwv9jnl1IVbX/+ZftGttXqReh4SfWpOL+uqaeG2ho8qN1P/vgxoxOekqvtl9b0DGP7tbxT1g4eSD4YZqPlkvlOSIcMr+w3qwGmLCIeZ6YEubCXGRmJWMxi3e6mFEcuIesDQQoglcXM4b5noM1/wmXo/VYG/BPso348pe/rNe//vWupzmBRhD70572NCf5xwHy+f3f/3294hWvcBrt8573PPeChNqBt771rY78/uqv/mp2IUPAkKKROhseEe5U8GLMfAdBxDTi+QrKzBeER0Q6Y+CacT3b2TghbtLVCB5CS+dvCNkC5qIBdqa9x5G6mbCxKpimiICAaR6feyerqi0U6VxSQ1szjtQB944NHJ8rWpRVOIvDzFhVI3eVVWo0hiGIrlSyjbruY0+k6kFzKSrT4uLPSCmXJieN7ilr37aKHvOHw4si9bkC1SAkhDCEstUC7i3uHoRS5iRzpJmp23LucVOtBKmHKxeisSPosSdwTxcCfifrudlzsLryfMcK2nisDXiNvY1A80TLIvIcsGAgNNqiUsI1ihe+8IUuNYwmLAZyh1nMH//4x5c0losvvljPfe5z9dOf/nTWP8iGi18UkzibF4QMobLBQYL4x9n4opo8ix7Jn40xWsoVgibPOa4xDAIN0cQICuE+2twXBBnMm7yPlsq/mPEh3Tg3AYIDmzH3huMIJovTMNDKrONWNAbA5YPfeOOsv3E1+N4NEPOBu8q65cY7VMmP6dFnPtQJYWjF/GbrX7/39pIu/8yY9t9aUq4rqfXHZvSwlwxo6KiMLvzUTu29i6jn0HnLdYJ38XKwPdw/JRVG0eQTesiz+vXo31ta21rmEpow9x5NmDmFIBV2u6wmmKmbec29jY6T38FaYA51Kj1vIWCNMV7mL+ONqzcRBcI61hSew3ymfG+aX3vwGnubwCaB1nvOOefcd3OTSfc3mmgceD/8fYCG3+z7rQLyJgr+Pe95zyypW2BbOCAOAoVMEUj4nP9vVl0OYokWlOEz82NHSd3qvaMthEkdoIki0ED8XBdTIy4DCDuuQI0F2BEdD6E3qy6HxsimjAk+rgEM72GJwLLQzqpqSwVjuOXiSV32H7t12/dqqlx3tIqjSbeJEwCG+wHinNxf1g/+bp9u+9m0RndWNLa/om2/mdGFf7tHk3srOu2sgXqAnDtpXXNPWkEaS3Dn/zNSukvqHkpqyyl5V5p2KffBAtW478wtiGSpJWM7CWvSg8+ZKHTWhQFBijnUyZz7hYJ7iaCLC4p1iwtrLoSzKVrxz1tKHEDIZy8zM73HoYnVMXPXADBVI1FHA7T4G4KLAxpz3Pd5fyn48z//c0eWL3/5y2eJEVMeixwpHhMq5GnNWCC4uN7mAO2XQK64/uuYza04TRzhsxGFf5/lsVtTGHKjTZBolv9uggVaFQIE5ve4DXch+dKY8nEzcC/YyFey/ScojNW07YopTc6M6bDj+zS1J9DO6wo68Sm9s8IWY71z37gm9g7XzewJqVquqVyQZqZq+uHf79Mxj+vS8GFp7b29omROSnZJVdLjKwdl2rlVn85JG0/IaMd1RV35tXF19Sd1xnP6tfH41gLoouA5MVewgvAsISDiOFar1m6mbgRWzO4ImMwdKxm7HDn3Cx0vAilrlvGa6ysqwJobgbUXV3RqvmtYG1jInbUWJyB7rH54jX2N4Ytf/KJr8mLuAIgLvzLkbrnnaIIsfIjacsjjUtSMiJH8o/5syB4tMq66HJYANHLz7YWLyrCBYq6Nmvyb5b8j5KCJIwRwnWYR4pA/5Bw9vhmsqhrng4S4DysFNlN+Yy6XVW9P7+x71UqgqQNV9fXW08zygzUluqeVSNdz1mnXavnqO28q6pefGdPYbYErHVvPf5P77kHXaljjSxVpZHtJt/1i2p2HNLzLvzSmmfHF+Vl55iYkoQ3jskEb5v3VDCxN3Fvm6KWXXurm0HLm3C8UCLeMl5RT1hNrNAzWJKb7xTY64hhevtb8oQ1P7G0CmgrSLf7bMPi7WdML3l/I9+cDvs0/+7M/04c+9CG3OHENoOlB6hA6JBw2zcVVl2uloAyWCT6LM92zQVo5WcgdDQhTMqTMJsr1oznBkGpc/jublqVUETXfzATPPVtMK9CVbv9p2DO2XdnDJ9Sd7deeW4uqFOgAV9Zlnzygn19wQFd8YVQqp/XYs8/QGS/JqPu4CQ0cIw0en1TvJimRl/IDKZe2NnpHoMENmXruOuZ45CBS3YLGi1o0k9LkXmlyoqbieM0d178p43LrESQWW5nNitZ0Mie7E7BCR8x5BNalWsw6Dav4iLUBodTGi9DcDjdC1DTPPuFN84cWPLG3CWxoBKVddNFFs++xGPjbmqJEwfvh7wO07Wbfnwtc67zzztOTn/xkJ2SgaZupHcKM5u5Gq8tF0aygDGDzQIiJNsOwqHuuj+aAUGFFZbAQEJUejaoPCxfhoCATLDDlY5oPV5eLBkLhZuC8i/HrrlT7TwNEcuutt+gJLz5GD3negLr6Usp0JZ0pfvtVM8rkEtpzS0l7biu5sW7eskmbTx5UarCkSq2iGoFxSalcrKlWRdui2UtSxUlpeq9UHJdKU3xerwtfnqGXe11tLxWl6dGK9t5a0uiOsqtq1zO0MNMrz8kqs0Ub7DAP0C7RIONq+K8WmGCCIIJwwhzmtZqjxCFeLGnEjDD/GS/rrZ2ley1qPlzQxuPQgCf2NoJUt09+8pP6zGc+48iKTmporeeff777/KUvfane8pa3zH7/Na95jS688EJXGY6N5V3vepfTbqnpvhAQTHP22Wc7UyJR9WigSPSYd9GS4wqEWHU5Noeolstx+M+j6WYAcuZ6Ue3ais2wiXNea0/JRsP5uR+Y5sPkO5dwQRAW2gKEYUU0orBrWnW2drb/bEeN8VbLlSIgrVu/Tv2b0q5cLI1gcj3Jeve10Wq9T/vtRf384/t1xVdHVJ1Kamhjj6sHGyQqyvdxrkCVUk2bT85q6+n1e1wtUS5Wqhbwx9fJHb97dqDe9hU/fP5IqZSqaGJf2aXDNUrPtwyen2nocwWqMQ/DNfxXC6zzH7EdjBFBci5T92qDpXKyJuNifJYKb5o/NOGD59oI0tdIM3nHO97hzGP4siFuW2yQZZgM2UC+8IUv6O1vf7vLOWdz/OY3v+mk8FZhvmw2oPe+97161ate5a7BtSBZCodEYTnkkHO03rfVZ0dTjwY+mXbNOM10b0Vl0NAJpIOkrNRrOJAOs2F00+E4hACEkLBwYY1frOhJMxM830HbojpbO9t/Yq1Yao3xVsAz4D4h/IAeurYdn9WeG4vKdCV09GO7lMqnNHWgoh3XFlSu1lSaqTmiJvd984N6NFOY0uTYpJJ7etU7lNbJz+rR1ofm9YsvjxIzV0dj+MhGPJXudVKAdyUvJWgMk5MCWsDeW9H1P5zUo36vNY2PuY4PnXk8V3ETPmOOMgeI1uaZxwV+rQQQTEC4vbCZuhG2o1XbViNwZXGPTXhivO2s9heuCMn+wL+sFV+tbvXC57Ef4oBMIaNnPetZTqAIV5dDsIh2WGNRWg55XG9sSBji55zhhRst/wqho32ZsALpE7gWLUTDxg8BY+oOB75xDciTIJ9wPjkbB3nxaCJo4Wj4cdo6JmzMu7g/FlKdbSGbJdo0ZISg1e7UJ8szhhTDLohqOdDItpJrGjO4NeMq013xX6OuyMzo/pImRipKJhNKJqTDTsopk0vq7mumNDVaU6ZbyuRTGj4yq8kDZU2M1lSlvGy1Xn0OGQ6FfJaD040AvKpUOiBVpxI68qFdetab18+7aTPvqMwGIS6kYQnPnd/N/GGOLWep1lafQRhWtRAfPMLJaqvOZuuAYFRcIWjujJd12IkqixY1b9XqVoNw5nF/rK5Z6rFgUCoWc6eZ+OdqmxpOUTMtMbrR8WpWXQ5NmuPQaC1oB+0dzR5TdnSDD/dlD5O6NaGBvKNFYki9Q0MnqrpZapuZT7EOdILUgbkSEFj4re1spxnOM44SCoS+/vicho6qB6EVJqoqTlU1OlLW2P6yKqVApUJNxUJNu24paMdNM85XnsF0r4QLhtv526ImdtQkWrTSxQ1NndvYeKSz8YEVaXqbVBqra/PJXKCdV0/rp/+0X7dePKnCWLxP1ar7cY8WmlKFoIY2zLHhwK/lBrEZ/Abm5lwFX8zUjaCHaR7BZLXgIFdOI76BdcN4SSlFcG73eC2wzkfNr254Yj+Ecckll7gKdfj1jTibpY3Nl6JmBWWQ8qMFZdgcMFlC3mjT4aIykKyZVsPCgAkYbPxWNc2ABg9hRoULEyx4n/E1awuKCdtKhHYSCBj8xnambpnlo1VS7B5MqRwEmhytqDxd175dzfeqVJgOVJyuOeKuFmn4knAR74UDgQr7pRruYbR1TkR6XKONq2sSQy/3KkV75Pq7p7Jo+/VKdbdfPaVrvj6m33xuTOVCrakLZLEpVdHAL6xEyxl1bYIJZNhKbAbET+wKAagII81KRC83WK+sk+g6IGbFKs4xXtZUJ/zu4aj51VDoyeM+eB/7IQpyhgnGe/e73z3rH7TqcpBR1AQ3V4qaFYGBbKKpdmjdmO7ZePke5n07fq6e7ggQfD8aVU9QEho/psOwGQ/Bgg2ewD8Ei2Z+dTQRotfn8+u2CxYYhnBi/eDjggpbBRYTBCziAlohxe51SSXygaoH6K/aKB6XbhA0f6TqPdXJXee9Cio6IA++gCafcE1hZnkzI2X76rns1ZTUfaqU6mqkxpWk7IPq5yklK9o5MqPRe3o0cGRGlWKgrr6kJiaJ4r/VzbH5us7NB+Ya1h7M4WjDzK3lqFjH3CQmJepumgs8bwQZmwfEXjAvVso0j6UDszvzKG4MVmWR8XJ/2z3ecFAd5M7+4E3zqwfex36I4iUveYmLbP/a177mFhiLi80xrm0qgIAhVQg1urjj/OBoZLzHNdgk2ATDKXNz+eqt6xebfzhvHuHC/OfhIiCci++joaN9QOpx2jopN/h1+U7Ul78cQJBhnNxr7kcrNbuXGhdA4Nz3/mm3i46vFhpaUaqhdcPTXXVzu3s7m1BhPNDMnnp71kQ6UIbgeci90RgmO1hvClOakdK0c+1umOaDhphfrfdvdw1j0tIRG3t14Laqa+86dGRawZE3aevxh7XVWsK8QLCErNod+BUF7iRM1ETqx7mqWgFrg3nAWiFnPGrh6jSseyHE3UrNi06P1/zu7EO+DezqgDfFH4L4yle+ou9///uuRaxpHJjKIZo48y7+wbgUtTg/OBufFZWxxRol9bl89RZVj+YdrVONpsc1ovnvaOCQHoIH+ffNNg9ydeN8+csFNkSEH+ICWqnZ3cwfupC4gBsvnFRlKqg3cmmY0QFmdcfHDS0ecoZ8nSqOmT0pVWsJl7ueVKA0wXODdX87AXNOQ+8KkbpZABrTo1as///2u2ZUngmc0HDbr8e096qB2NoGS4Fpw1h+uEfM5U6Y5q3sMHNzsaQOmNeY5hFqETSxIi0XrG4A7qFWC1nZeLGGMG/bPd64gjbeNL+y8MR+iAFT+5/8yZ/owx/+8OzCRqsmvzwuJ90aqMxXXY7/pziLFZUhwAnSx1cfJfW5fPVsylwnSr5sJowzHJjHNTkPZM7GwDgQFtCoosVM+N1YAtBSVjLNxmp2WyET7l8rJBRNbWsFNGcZ217RwHBG2a6kqyJnPGxEHFBLBz6vSRX+PyvV0OYbX6xVElIqoVQ+UCJJs5f6oam5rOi0eG0IEQgB/RvTCtIlBekZZUrkynXm/vP88Q3jE8ay0+72ujwryK3VssNzgXmPdYFI+eVsKGQtceMyWuYbL3MWt10nxmvkbtZD1rGvVrdy8MR+CIGFQte2Zz7zmXrOc57j3mMBQaYs9Kif2wrAQMxxQUIE2kH8+I3Z9MJFZdDI47RrNhUILc5XD3FjHYgKGJjQwwVq+B0QNTm3+Nu5LmZ7zPNoxJaPaxoxpkeOh9SbBdQtN6yQCcLGfIVMLN+bjXUhPk4K03QPp5yvfGg4o0waxq1/hl/dnakqVabrb9NnPZG7rw+7KydLtDs+eY51CJyW74aBuR4TPaZ9gvLMPc/nOYLqEkoUkpqeLLvnmkv1qW8468bVKXRKu2S+8Rwg43YKhgiwjBc3AsII67FT4F7gHiMWYbExHp0erxE8a5xze+19ZeCJ/RDCv/7rvzqJ/f3vf/9BaWOYhuP8klYAJi5infNA3vw/Zj1ICmKFzNlAODYu7Q2zPdJ/lPDRrhAiIO+wgBEuUANhQ3CQNuZ3LAO8OAbC5tpWzARfoJX2xIqAiyHaGnalYYVMEHD4TXHR0gg1zVLbWsEpz+jV4Ja0ajMJ9ebSGuhO6bDDszrssJQe9PgeVwK2MiUV6WFTldL5ug+diHci55No6PxLDnux4ZhHKuB/G/XknYaOqX+G70jJbimZlzYf26UtJ+a0994J1cZ7NHRYlx7yjPnbgLZLG26XdonliXWCYNUJf7g1FGLeI4xgPWs3FtqKdSXH603zKw8fPHeIAIJDm/3GN74xW0secuTF+1GTeFwBGLRtispYuhnCABtFWIuEiNBA0doh/DDYAEhPIvAobNa3QDq0LM4XBkSOVk6wG//POBEg+JdzoX1wLo6N6y7HWBgrgsdSN7ROgvvKMwpHH3NfcG/w//zOxWqKpJxNH6hqbHvZ5ZeXZ2oaPjqrh/7+oMb3lHX5f4/qrssLSvdIXZuk8kS94AyXS6akTE7KHiuVyXoq1y3pqeGgHl2P9g2pj0mFO6TcQ+sBdcl0ve58Nl9TOrFbD37QqVq/Nae+9cubSIPbx+bWYtrrIrgSsIhgGZ2b7QbPm/WIgEscAq92WAc4L02KrGlRuywOnRpvs4I2CO+rrcDPWoUn9kMAkC2aIfXg3/nOd7ZUXQ5CQUNEW4cYIVVeaCxmxourLodWwOKL5igzBgQFFn/UrI/mj6kTwg8LGGzK1tmNRY1vE63bIvghQeIEGFNcIRqsDZgLEUAQKjodMb1URKOP0eBxdyCUtMOFwPPZf0dJhfGaC2a7/vuT2n+gpHK1olKlbpvP9kgVasPva/ji0eIh96Ok6mTdJ+/87Jjqe+tBeamehBKWEtctdfUmlUwlValUVSxUdOrDe/WQR6zcfWe+IAQyH7ivCwk+JNqeuYMwvFykQhAo8wCB1TreLQXEobDGmEdLTTGca7wIT9zfdru7mLdYHHCFsOZ9OdrOw4tPhwD+5m/+xi2OhVSXg4hZRJjcMbdZURneg4DizOxonSxyTOFRwmeDxOQc1eIhb8grHEiHZQCrgJE6wgVWBSNlzoU5kL+bVZdjM6e6HNovwkunI6bb7R8mWprfiTDSro2SZ7L+uJyOeGiXJnZVtfPWgiYPVOqxbKl6oBuNX5zG3Sjzn+qVgpRUHbkvgt586rXRhCojUnUmcPntkDrfKU8HLnCvXC45MiwV6s+nMFnTb783oZ9/ekRXfXvcpeAtBxbbXhciQSPl2OXUFIlpQZBAgGYesPYWC2I4WMP8hk6Qeni83OeljrcZcMfh3vNR88sDT+yrHD/72c/0kY98xFWXM4KYr7ocn0MyaNiYsyFG8tfR4C3QLupr5HtsINHyr4AgtjjCt6I3CAuQPn8jVCBIsKFiNkXLQEu341jcbFZs0mwkzTYrNgI0Hst373TEdLvAb0KAMlM8m2QnoqXXn5BRqj+prsGUI24Ad7lUtmo9tS27TsptlFIb6v7z+7rChJGQygnVZoiYDxzxlwqBZkYrLmeO39Hbn1alHOjyL43qhosmtfvWom6+ZEq//PyoStPLI2QttL1uO33SiwHzmnXHGkXAtYJNCwGWNoRZ3GJLSc9byHixyDHeVoWnVsDzYs2bgOWj5jsPT+yrGOSUU10O87ult0AUmNTjctL5PhseC5LPiDTHFAjpWhBbXKCd9VGHPKNmTgif4CU2yKjmaX3ZibRFQ4fQiYzHksDiZSGHo3c5F2lfBEVxrmbV5SB/zNjRCOZoxHQngpTaAat3z1ixgrBRtrvHO93dBo9Ma/jIdL1ADQFwjVvpWrWW5XzuLsKdz3oaDV8SDc3dtHfKydLljQh4x9FBXft3zWNS6ulL6+gTejRyT1m7by9pYFNag4dnNLQlo/3bytp75/L1ro9rrwthtLOWfTvBGBFMcVGxPuYTRuLqNiCMh4s5dXq8BMW2Kjy1AhQNlAlzSYSj5jm3j5rvDDyxzwPSfM477zxnrkJqfsUrXnG/HOvo9//iL/5iNrULLeMv//IvF9Xfm+PQbGnFGi3+Eo6wtqIymClZNPjj0RrDmgrCAMQabk9pILiNhRYtPGImf8zv1mTCAKlCWmy0BCdZ8xjIHH87WkZ4jHYu0sS4jyzyuJQdNHE2NMYfF8FsEdOY6Nl4EC5WUzEMK3nLfeDedMrEme1KqG9dWtMjgWrTJJzfV6gGjZ3odlehrpHSRjGaWpmguUZKHIFzOSk9VK8y576DTZ8a8/sDBVNSsFt61GOGle9KqdaoiGOpbnyfa63Erbf2upAQVinmb3gO8DeR8IutZd9uMN8RRkAzYSQK1hB7SbvT89olPLUC9it89wgm4f0j3EjGm+Y7A18rfh5A6piif/SjHznp8vzzz9cf//Efuz7qcYDseH3wgx90RIekTkEZ3qP8a6vgu9/+9rddGpVptWi7kCUaMouChc/5kYrRTvge5UqjhWisuhymtqg/G6EA8znafZRoOTcLD0EiDAQEgpkAJnqrSc2CNS0jqinZuRB0rOxkM00Li8JcVbW4DlYBNiA2DgizHUFKS0VcapuZOC3mAIGHjW6pmzUa9tFndGnnTQWVJ2uq0cGNS3LahmbumsWghaO1F6RgXKpNSpmNcto5+e1wOdlv8DbfK++XggN2mkA3fXtSQ3+UdRo6r33bSsr1JFWcqjnNfd3Wzvh95/39DVcUpGk1/JmHZmFCS+6UT3oxYG7iDkPowJWEYIpgEjcPUBywriG8LDQLoN3CE/N2vvE2A7/BykTPV2veerz7qPn2wEfFzzMxIWcmNsQHLrzwQlcgBg24lc5Q4Ktf/ar+4A/+wBFsK329EQKQ1P/lX/5Fz3/+8917mKYJxsJMBpmy4NBuITi0YLT1uIh1NGUIBYk5StAsKDQeBAUIN0r4pBkhKBDoBhBs0Ea5drjJRNh/zqbKGMMbkp2L34TlIy61LRz9S2OLVvufMyaEDK4RlyGwXLCUP+5Fs9Q2q6HPPeBeLJV4nHvlZ5O69gcTmpmuuoC3KgxNG9dcncAJpktC9AW6vtU17K7T6po6BWycaZ55UoLUAxVu5sQJJdH0cenky3ryn2/W1of2amJfRddeOKmxnRX1rk/ptKf3anDzypMnAhWBlqwv7glrIjrXVxMQQpgHzFXWUHgeEKeCME9cCla/1YDFzFv2MPZP1vJ8tQPCKXGse/aW1WBpOZThTfFzgAXG4jNSB+ecc46bgKRrtQpIh0XRClkxwV/2spfpaU972iypW+czCJwFBnmi0WIuQ4om6I3zRyPWAUEwIC7QjvOw6KINVczkzzGQOuTJeaxlJQsP/zFWAluA1uktWgHPzsU4cQ0086tbnXg071ZJPawRowUjgEXNsssFBB6e81zmXzPJMj7u5WLcM2FwnVPO6tNz33qYznnVBj3s3AENZdPSjFTaS7S7lMLs7uaVlBmGOOpafTJDzlv9RanZZDao+9qtQh2aPhpVTbryJze750MO++P+YFDPeNN6nXn+0EGkjlCx++ai7vnNjPPHLyfQChFAmTfMQ+bEanLPRIEwDOEZiXNvDfijWV9oyKsFC523CFhY7lotCBQ2zbPXeL/70uGJfQ6ggUYDzdg8IDQ+a9Xn+p73vMeZ71sBjV1Y3B/4wAdmidEC4pD0IUj8tpAxGwDjYKFFq8uFA+0sSjsMCNr84tHjIFgIGOEBE74tZjQIhAzOFzZ7WwU87lW0OpwFkiF0NEttY4ND44Kco73bFxKkhACG1o/ww+awXMB0Gg4QasUki5UEawkWiqWSUL43pSNOzusEKtENp1ywXG1Kmr6t3l89yEvlMam0S8ptgeDRxOupcJSOdS/+HpByRwTKdNcD7yD3VC2nfGLICbIIL3FjhdSv/vq4fvkfo7riC2O67JMHdMcvm5fY7QRwl0HqxDYwZ5lPrJ3VChNGcFlxb5kH/AY03eVOz2sFNm/Zd5i3WO3i5gJrmfXH9xZSKTJaax4rzGpNaz0UsLpmzzLhzW9+86yPp9kLs/dSgST+rGc9y5Hnu971rnm/j1ZOrvoFF1zg/OSQ1KWXXuo2LIiboDgI0hY91eVMS44SimnK0SC2cH15iDoqUUP2RLZzfYLi8N+jEbPZICTEBdI16/TGuXjxvhWpiYNpKUs1n5omxG+PakKd7raFKyN6X5qB+cVvZaNcLAlBptGNtWc4rROe3Ku+TWllBxKqjUvjd0jl3VK10a2t6zgpPdDIb6eE7HTd765C3Uff8xApvSlQcqOU3ipVuwOVRnLa1HOqrvzupH7yjVvuJzTtuLagu389o67BpIa21gW3G384qcl9y0Os+NWZ65iJrTwy85E5wPxdrQjPA4Rp5gHxGdEYmdU0Xtx9CNBY8Jj30bnAWmZ/igvSbfUaHI+AALmb/91jYXhAEvsb3vAGR6JzvZjAaKzR+t9MNILW5muZyIby9Kc/3ZmyKQM7n1+KSYwf/uUvf7kzuVsDDCY1xMr1okVj2Mx430rGhtGsjaulvWF14DrRMWNCswYOXJcXQWrNAumadXoz9wHfR3hoZoKH+IkAbpeWgvDAxkOsAZoQwkgnNwYEK57LYkynCAJhEpor28IQ1ALdfPGkLvrnffrlp0cOIs9qOVDfxox7bXxwTn3HJ532XiAYn+pzW6XMpno6m6sTTxU687E3OrmVCIDuk4Iu8gul1BZpIl3Rbb8sqTbTrbHtaf3yFwd335sZqzlTP0F13IuuoZTK0zX3/nIJVjxvs64x1wieY20gnDK/VjMQSFkjzF0IczULI2EBGlIPC9AoBO2wOHjT/NLxgIyKx0TUipkIkzeBIwSmYTYDF198sdtM0J6bgYmOj5wN5lvf+lZLfqY///M/d2b1Jz3pSU4DwayLGRuTVpx52uq9x0WcWpc1gtiiZnY2OXxgfGaAWDgfJMjmwrXDrVoxw/M59yAcOd+s05sJDxAXQkez1LZwFHk7tRR+sxX1QAviXuA+WGxHrPlS25ZSrpQ5giCCxsYmiYA0V+71yL1l3f7zaSeS776lpDsum9ZDntuvwmRVP/3Ifu2+vqhMd9IVraHGvCalRBeELg0+qb7iq0THV0MtYLsa6WsIrg2+JgXOpcwxfXDbT0pdfQmlMllltVG/+MUvdeqpD3aE2jWQdMcXJ2vK9iRcXXvGwPudBmuE9RgNNDNhKzwHuLftngPtAFYbfsOZZ57phGSEEdZEtPXxaoIJ0AgiCNDE4zB2rCbtWMs+an5peEBq7K2CxYXW/cpXvtL5lchFfvWrX60XvehFs9HnECWmcD43Uj/33HMdef77v/+7+xvC5gURRkFEN9//1Kc+5SRdSAJiteIr0dxygERPkFjcRtWsyxpgTOHqchA6GieEgj+e9xBYwqQeDaQLg3PFtXZFQOBa+L0ZX7PUNn47QkunioggVKAR47JoVSNuFSaU8OyXWtnMTJdYR3ABcV/i5gogmA3tmOYuFhSHFv/bb01o53VFzRyoaXxHRRPbK642fKJS96FD9Jn1UqqrkcPOyucE2cb/N9Ld3IuiNf1SdnMjhY6Ps1IhE2iqVtNdN2VV2HuSfnvVHW6sh52S0VGP6HI17EfurrjznfK0XvV2uGEMghVuoGghpDAQ4NEumY/tngPtAOuctcxvYJ0gjJBmxhpmfjWbB6vJlcB4EU7Yb+Ksh0u9hjfNLxye2OfB5z//ebd504CFNLcnPOEJ+sQnPjH7OVozi9D6cRPohgTLorQOafZCu4vif/7nf5yE/qY3vUlf/vKXHUnMFfQW1pLDBBzWlNnMmlWXQwsg3Ywxs9FB7hA9AkE09SYc/BZNhwu3dg2PkY2TRQ5RcS6sFXHaLL9vvijydoDrY5aN9nhfCkwoQRtsp1bFGBFEENyYE5BRFENHZnTUo7rcPRs6KqNjHtOl4nTNRaJjCs90JVxOeq0oJcp1AYBod5fT3mgAk9sUuOI0avRud13cBqV8g/j7TpWGHy0NPVJad5bU/0gpiUEG7qQoTUWamQ5UnTxa42MT+t/L/1cbHh7o6KfkdNLTu/W4VwzpmMd01k+8EMGKOYCFqp1zoJ1pevyGsNAMOSKMsKesRmEkTjhBS2ef6ERcgzfNLxw+j32FQcEbJPZvfvObs3WU0f4xwUfT0AAaNlYAAm6ihIn2AmHGtXFFu4aMISMImc0DjZoFiasBzTku+A1BgfOF3QnW6Q1pPZxiZznznAtBgGPiYgsgLGIIkPTbLeHPBeIl2EixtrCZLtZ8joDG/WTz7URRHO4jghfWIIStaDwHgkVpOlA6l1AqnXC+9Z9/4oB231TU1K6KipMwu5TtRxtPKrUuUKI3UP9ZdW09M1xTdY9UuDshDUq5ISmVqWv/BNUREV+rJFxPd0iffu8T5LfjzrdwBSrVpaRjHtSjO28b19RkQgkllQkSOnxdXo997jp19XXG7L2Udrg2B5i30ZbFywn7DVgamrViZR4gWLOuEYBbrZuxnGCPIAoeSyMxPawL9jPuLZa4TrWB5b75gjbN4TX2FcTXv/51R+gf+9jHDqouh0YdpwkiGaNtxNWJR6qPdlkzQORsDpikERzwjUEYaDrWnCJq8keTxyyM5h0m9XCntyjhoKmzkBk7iy6O1C3YCaFlOUkdYMVAIyZuAqsK92Oh4D7z+ztZ6Y5ny8bIM8IygHAVTv3hHqOdQ+oglUno1Gf26bCTcho8NqMs5f6z9ZrxxfGagulApT319Dc09cIOqXxPQpqW0qS6Qepo95D+ANydcP+f7q5r8K4sLZcy831j6uGnv/3aKRWnUo7UA9VUStV09/4Z3XDZ0nL054JVW+T+LJQ4bA4gHGMVMUvbcsN+w1wWK+YBLjWInzkwl4tmJYCVD6sJew57icU1ILCzj/FZu1MOo6Z5/vVR8/eHJ/YVAgRNbvs///M/z/qY0SbQquNyy5nELG4WTjQ4xczzaMnhymtsWryPjxxTH5q3ETqA4NA+o4JCOHI+St7W2jWaN4/QgYZpNeGbbUBI9Jx/sekwSwX3zuIIrOBOq+C3oe0hlLSa2rYUcO/RhAj8mk8QWX9MVme+algnPLFbw1szLicdv3gtg5BWz2Of/F+ptCNQZqBeeAZid776RhMZctkpVZuiV7uZ6VNSdn09mM6RegwHZRqEj3UA1JKBbrlxQtVK+6PimXtosUtpY2pzgLVijYuWE7igFvIbTBiZy0Wz3GANsxYQzqMxMuHYFsbbbldC2DTvG8nEwxP7CoAJSVobfvsXvOAFB2nI0cpt9n1Ms3NVl2OiWxcoy+vFXM4mgnaNlh7OZw83lIn6KC1yPkq+zVq7Yo5jkQP8mJzPGsOEYbXt0XZXsgAHZjw0pYX2eGczBssplPDMqPKHYAYJRe9pGGjuySTlYBPK5xNKY4rHrI6MVZWqE9L+70jjv0oo6E84zTyYqrN1wjV3gZ0bJE8AXab+Suelvgc1BIAwXHu4+iubahxOHYikVErWdP1V9/dll2Zqrs78YrQs5izPi0DOxRQyCoP5xzxG0EWzZO0tR0EU+w2su4X8Bqx4CCMI2/ixWy2Q1SlgnUNj5x7OFduCUMJ4251y6AvazI0HZLrbSuPf/u3fnFmNjRrM1VIVWHW5uPQ1yBItGuJGQsa/xeZPjjrmdYg0zmSJqQzNJWryt8j5qDYR19qVMbHA+ZeFDGFbEA0L2To74btnQ4P8sThEo+tXCvwWhCXGaf2im6UmYpHAnbGU1LbFIlyXn7ESOMk9jRvH8NasAk0pUUkIOW5qX+DqxddPFLje69M3SFM3ST3HSIk99VQ4fO9OAID0iJpnujS4F629a4NU2SpN3R65YGNaMRJkg/opEqplErr2NzNS9hadetrxzmd/ww8ndffVBddxZsPxWZ3+nH7le1u/l5Av7o921oHHKsJ85L5iFcFnD4l2AtaKlfPHlXhu1UXDPGD/YO0vJVZkseC6uPAQNOYq/2zZHoyXtU9QMONvZ8ph2DQfbiSTeIDXmvfBc8sMtEPywYmAf+ITn+jewxzOKy7oDbJG80bDjPqkicjnMzYnpGcjdOsexmcs/KiwgOmRcbAww9YBC36DuKOBdFgFOD8CBOTPwoYMMWdC7ATzQYrhKHhMh2yYvMdi5vz89tW26Mx6gRsEco+a2TH3keoIoUSzA5Ybdk95boyVVPOJUlHJRFKD+ZzyqbRu/MGkfvuNMQWJQDMjgYpTgfv/urk9UTezp6Vu+LEmDT+5cfKklFknZ4qfDZILoTIt7f2xlAiHFoQeJaQerkNGCEAmV9Gmo8Y1XDpaN19cdAF1CArkuh/1yLwe9aLBll1XPKNWmoosBhADwjVrAwF1IeVQWwXCLuuO37DUrm1Yz5gHrCXmwXJVq7O1gNIQTXOdC+xjWCq4zwhP0WqYSwWkblagdKN75GrbZ5YT3hS/jICIrbqckbq1VEWSjZL6fNXl+IzvIBRAnBA152Hja5b2ZnnucSZ/axgTDaSDwNFW0TLQOIjmZWESJMNnBPigSUWry6EJoeFCnPiysQ6sxsU2V49307JwZ8RlKSw37J5yry+78te6fd9ejRUL2jM9qdux3kyOa8OZCZ34nC4NH5FWOpNQrVLvpQ4LO2283t/FvedIOtuoQGdBco0+6+4W2P832rxWY2LNmhnVOVetnNa+nYO65cB+5R5XVPq0snKbpe6hlPbeVlalOL/522JFsFp0gtTDVhHWBYSJRaudpnn8zFb2th2tWMOxIpi6FxIrslhYW2WE+YUKuFgpUFwQmrFUtjvlMGyaL5fLD/ha894Uv4x497vf7STXd7zjHffLLV9IdTnr14z2BulDxOEND6LnOmwirea5YyZDo0AjD5MzpIzZj42EjQnzNcSCyQsSxELAQm9WXY7xM15+I5sC42pHP/J2o1mPdzQ4hBe0rNUyZgQRxnbt3du0e/8+9ePayGZUrFY1WpxRVzqj/CPS2tCf1thYSVPjVVUrtMOs56LTCAY/eI368FSYo7VrXiruqhekyZKzTuEbGLsRGEe52dGbpMRhUtWK2dzXIM5hNlwSTT0rZboaZn03n5IK8jVVMiXV+iqqTmeUHk+7YL25YFkUxJZESyB3AgSCMQdowcscmMs90yrQUq2fQDstARYrgoXNMk0wfXfKNG+R/ItdC4wLwYnxsheYK8Gb5tsPT+zLBKRq+qtfdNFFsxI75uxm1eWI/sVfjonbJr5VnMPfC0mzKKK5rZb2hjYdtQA0I3zI1wLpwiYyvssGh/kNi0G4DSNjh/TZrMz01Sxylk0ZbYiNxzbMdvQj7wTQgBBcEGYwOXJveAadSm1bLNhY1w0Pq5xOa3RiXMlaVSm65yWSqgXk+Sa085aCpgsFbX1iXtt/IVXo9EaRGnzuEHqC7m1SYbvUc2K9Tjx+9swpFgjXuBiVae+WCvtD6nkjaM79WamnuMP1fYdLPevq0fZO4Q8arWJrtJFNqjJVUzJfk44s6+ieXhfwNxeI94AYmevLBYI/mQOsCbTLOPfMQmCNUTrVipX1ZXECFivS7jgBi+QnIG6p6xalgvuLMGJxDe0uKZ0MRc0/EE3z3hS/DIBsX/KSl+htb3ubk7DnSjUDbGRsKmi2EA0kD0FSSAahgI2HxRwl9XDaW7h2e5jwuX6UhDE7hhvGYK4nUInIdqL18YuzsRqpW+14NioWebMGL5A/x9umzJja2Y+8U+A3IcQAxsq9W025sjaWQWIaclnlehHG6ibIlAJHqMXxQCN3lJQbSimnHnUN05il7luncpwj5Umpsk8qbpeKu+vmdsi9uFeuOI2Vma0WpBksveFbYDnt+O0HpO7DpA0nSv2HSalG8B3KONOC6eby4ntJm8NUECjZW1HPSXSiaQ4EWObZXCVjl8s9Y2maCwUm8uVoxWrCCP/Olz2xUDCvEBoQ/MPptO1wJWCpZLztjvJPNMgdPBDbwHqNfRnw2te+1pEmjV7mSzUL12BnESHVouFyPAuXBdCs+Us07a0Vwud81jCGyc9GykaEucyicMPH2Ng5F2NvRuqQNr8jGjlrfZ0hfYL78M+jya82aZqxM1Y2ZHsGbPRzRQF3GtPlsnZNTahUraonk9Xm3l4d2Tegaq2qYirlBLKxiQnlu/Iq7S+6YLfK/qzumpxWeSZw5vfCvkZZ2YZFuDIqJXulqeulBOlxKWlqm1Qel3Ib5XqzO+07SuoGNPKKlO+WsjHxUPZU7fFS3jaXTStI1nTTzTeqVpmMdc1YuVXmx0plUcS5Z5gPrVpvsHhhckaYXo7gtoVkT7QKizFB8F9MJP9Covy5vzzvdgpAyZDmjqCIO+eBEDXvNfYOg+5u//3f/62Pf/zjC6oux8SDUFhQaLloDkzOuBap4bS3uPryED6LPkr41s+dxY/1wGrHo6EjDMT54q12PNYChI84ouNYNmUEl6ggEe7rbH2oO1Ghaimw1DY2cQQc6/GOZrEcPd7jUKnVdO/EmIuArwWBDhSmtXNyUv25nI4aGFJfI3ixq6dHxZmCppMzquzJaGZ3oEQ6UKa/oUkHdY18/DppZmddGy/tqrdxzdOnPVMPkIPM02bN5f/zTQrUNLq/5ecIcmYPtX0UwaGWCNTXm9OjHn6a7rx9m35z5VUH9fUOB2mthoBFrGasQeY77hkIqNViRhBJXO2JTgIlgNoHxIdcccUVTuBbLChRbUJtp8iQOCHuL9fBNN/uaoCJRMLtW+x17G8PhB7vntg7CBbWH/3RH+mDH/zgLInPVV2O963QC4SIhg7poiGYeT5O62ZTJCiO70Y1AyP8uOpySOKY15nwROdDtCxgFhikHy3EgnmPF9eB0JtpLpZvHBc7ENePvFMVqhaDsKZo1pS4Hu/LPq5qRcVqRV24PtJpZZIpTZVL7jkO5PI6dnBYJ63boGMGh5ScnlGwL6mgUnWpbQS+ob0z3dCYk0TBl+sEjsm9wr7fI/UcJfUeLXVtlrq2hMg4kPLErZkM57rMNMLlU/WGMggC86JRjjaXTemodX266XsJTVx2sm74Uo++86mrNToyOtvzYL5yq8sN5juCHnOalFArxdwMZFYwl5YzNiAuewIFAoHUukUuBDwDK5/cjkj+Vkzz7G3tjvLftWuXU5asJv8DwTTvTfEdri531lln6fd+7/cOqi4XbakKkbJRYL5mIcYFa7FRxGndVpUOEor63C0oLkr4TGw0IrRPtCKCV0xYYDHHBd/Z2NHCEQaameBZkCwiCLuVTdkqVFk/8pVsdjFXalu0xzvPbDn7e6do5pJIOjN8LpVQuVZVXzY3e4+zqbR73X3LrequSb0967Wza0bV7pJKu7OOyBMDDe25IgVddW1daPJ5KdVd978ng3oxGurHOz+7admBlOwLFMzUhQJLlXNd4hKBC8zL5Jo/b0ud6wkyyuzI6OffHnHNarp7MurODmjihpwu+vINOu0p612AKILUagxYxLxtpnmEZgTh6Dh5n9+A1rySrhuLE0AQJU4AUzrrt5V1yR5hBaaWo3wyYC2xpjDNtyvKf3p62pn5w33irZEM5I4VZrnjN5YDa1pjZ4Gdd955zpTGhvyKV7yiZa2Qh/+MZzzDLQIatSwUF1xwgZuc//RP/zR7PrRqFgnmOf6GHFhwkKz1LY8jdX5Hs+YvSKNW0Sm8YK1ZC7/diBKtHx86EjzHsGi4npF6M6uAjZ0FR3R8s9Q2yJ9FxDgX4lO0ClXW7AJyXQlpmnQ/ghrnai5idbCXu793LpXWpp5eJZVQoVJ2mvumnoN9z8wRBKvTTj1VfZvSyg+mlSFJPVVVur+mLMVn+qUMHdz66oTuMtq6Q8Hu4emVrP9dodb8eKBktV68hg5wyT4pgam+0cu9bkmP12Ddu4E0c4d09/+UdecvZ1xZWVwExUpZ2YGk8l1d6p4+Stf9ZLfK24eVmFmegiuLAXsJcwCwlpgzBsiCdb+SsQFxcQJow1jusDawTucD67DdVf5aBa4L7i9WBuJwFtOsCbCHIJyw/4VTJV3Z40RiTdeaX9PEDqlDEj/60Y/0ne98Rz/72c9c45VW8KEPfWjRZkBM2/RXp2ub5aeH669D1EbofG6FXiDEKKk307rDPnJIPXqclaHFFMgENx86G79p/lEffzNfPBI/Y0fiNwGkWY9yfNKL9SlaGsxKdN7i97GZxWlgzfp7Q/LL2d97uKtbxw0N67jBYR07MKzuUNpRuIhLd1eXDju8WxselVR5mr6rKad9V4lGp/b7gJTskTI0d+mWyhNShVeh3vwFwndW85RUmpJGbpGCYj3K3b2P9h7KZedNWr2SPhcld/sLP/7UNQ0rfjlQrRooyfoKpOlJCtVUteOqgsb+9zDt+fmAvv33d+iOK+f3Za8ULAgUDR4/NgIz62w1xQY0ixNAGGEPagYEAPaJTkfyt9IjYSlR/jffTK9hxbpDolHz7LNryTS/ZkvKsklDlCw6zHrgwgsv1DOf+UxHVHOZe5Hyfud3fsdJt5DUN77xDT3vec9r6bpMEIKt2Pj//u//fpY0GAfEiB+dv9GKIVYmF7ndTGCk/Diy5N9o8Ir1c447zsrQQviMB7MgC5rrs6Axt0f7uSMdcy3M4mEBAo2U+4CJHC2ez+IWOxsb7gR++1LzXFlgWBsgTH53XP38doLrIUggZHHPFhpHwWa+1B7vSx0/zxsN0dIpmR97xyf1q0+NatfPa46wk8OBgnQgVZKqFevpbcpJ03dIvSdL686SBmn20tDCaynpwA1mR78PHMceWIPos1IfNeeLzjDQ+ML9BWIEi/0/lcr76ilw/O1c9Fk0J6m4I1C1WtQxD+1XOpvWrlsnVMlM6EmvG9JRx6wukowC6xd7BmSPBviEJzxhVdZosHlBDAMKAdo4e0J4X2Fvstz9Tq+7VoGgYVk9BBG3ssZ2N9Ylwsx81kMrR8t9WCum+TWrsaNJITkbqYNzzjnHTQoCoJoBzefFL36xPvrRj96vZWkreO973+vI8J3vfOdBEeJouSwoCxhDK7b3mqWvoXWjyUdbpBqRsolEj7Nqdmzy+K3R1PkOhM1v55xRk74F30VbwloLVqJskfib+dX5vWwUBNm0Y0Ozzlu8FtJ9bbGwHOWogNQKMPEttcf7UkH8BVpHWDNhvuCTP+ZpWa0/Oa3ew1LqH6bTS1K1ZE2JXOD86kTBZ6kQh9k9JVUxqVfrG8P0vfdp5BbZ7vLTiZLPSJm8NLC13luGyPn7cH9dgXMPP77hr0cAaJwLUk9nE0rkprXuiLyyuYzT5Ncd3que7LBu+u3tboNeTX3Io0AgZO4jMIOVmAMLjRNA8WBvQDlgHwHcYwQUrA2rhdSBVbtEa28lyn96etrNGWe9asEluBZN82uW2CGw6OSESDEVz1UM4XWve53bqJ/73Ocu+Jps7P/4j/+oT33qU44E0c4RMJiIaOdMTiP0cHW5uCCsuczsVoEO7Sx8nNWW53OuiTSObw3yaUbeYV981IQOYTDhGTuEHUfaVvITadq6vrULjGchC3oxCBdBWay2vZQe70uFBWrFFXEplirqGU7pxGfn1TWYVHFPoBoacympVBdEWVGwX0qW6yVls8NyneBq5XokPWb42VQ1129dSufqhI5J3wkDXIg68vzTTNExgQBB4LH3Rcej2Kez0oZH7NP6E1JKVrMKanXtqTBeU+9ATo9/0qPdRt0snmH/9pKuuWhMt14xqSo18VcACFUI0wjQkCL7AKS5msnBikWxvi1OwCrkLWdb4laBZRLTvEX5s7fOV4J40wIUMyP3sGl+NT+/NRcV/+Y3v1nvf//75/wOBLbYnPOLL77YmcYXCjYdGrwwPiaUERFScDhArVl1uVabv1ixGaRuO86ZXffudUSMQMBnkLoRlZE3Y4iSN+buuJawEAZxAUTMz5XaRn4ox3WqXKYt6HaV9wwD6RzJPpzattS63RbR247iIPOBzWeuVrjpFOVlAw2fmFH/kSntub6suy4rKDuQ0IYjenTPtWPafw/1A9L1mu+QLX+Sy46pvGEkSTQIuIs890YTGbY8CtNUQ4YUZ8JvaONx4O2uo+otY6sHrDpdValcQY9/0cm68vMTOnB3vZ5BriehU57Rq96BLmdtYp5B7mhhNoeL01Vd/u0RTY5UlM4klUwldNzD2ts1rBUwN4m7sIhzmwOWObGSkfFzAUGd+B4EW4QRxo4rbaX86q32SMCVyh5tLaHD+5Y173nQItIMw5o7+yznOVRN86tzxs2BN7zhDXrZy14253fINYUUo5oTkhiE1UySg9Qhx2jZxN/93d/VmWeeqUsuuWROTZ8FDQkh+SK5MwGZfHFFWqy6XFzrw2bNX6LHMQHROK10K39D6NEKUfiosA6gVYYXAZoQGyabZZi4TbvnPlp/9bjFvlw9yqNpO4yL11JynC21DUJsZ6BTuMd7u5qIzDf+Zu0ze7tymiwUVSxXlMmltPGhaU1OpjR2e6CgnNARJw+quH9SE9trKo/g9064piykrqGZN2LbnLm+F2NMg9FrFjCXqdeaL4UL18z2cQ+UUGLWKB9WfnqPlWb2J5VI11QLijrppJO14di8Hv/Hae26segEiuGjMlp/XH1OMrcQvsJ9vfn7up9NaPedRTcPct1ykfbLDYRfhOpwYxRzt0HuCCOQ51IFx06BMWPRYx/gPkOM7AerNUYAYEGMVgNkj2K/x1LyuMc9bklkbM/xUK41v+aD5wj8opIa+OEPf6inP/3pTYPnMNFHTTwQyoc//GE9+9nPji2piFRHBDwNXhA6zj//fHduyB2yReONK0TDpoyWHG3WgBmdmvBo+VFNPhzghjWAKHbT0CFpKzITJW+sByzWsKbLuCFJrhE2vRlhILFavn1ccQrI3/oyL2ePcgQUCzZsJYK9GZgDbGLt6I29mB7vS0Wr4x+fLmh0Ylrlas0Rdaaa0d6rahq5u6JqUFNtQ0XBhrJqqZrSgwnnP69MJpTvSmhil1x9+V7S5HoCBeS2h+S3BOlvJalK97dkqOVrqXkQHSBwb+Q7zLWy1h2d0bl/ttVp2wvpQ14cT2v0hi0uF35moqZcd1LPevVGDWxYvtx3CzRjjcd1bWONIYgjqLMXWS+G1YRw4CWWHwQnfle4tsVqhblAUNbYq9jzcV0e3qY6GOEe7wgKCDuHCrkfchp7q+ABQ+KvfOUrXTlXiOjVr361XvSiF80+eKTts88+W5/97GcdyaLJx2nzEFccqUMyHIe0S9Q8xE6ahlWXi5q3ARIgZnHINErqcWb28HFMXDYHjsf0b5H1+MfQ2qPXs+A3TJdRYmGz4XrRPFWrHY/JCyk1TnLvlLa7kLQdTOi2qS60MYWltnFspypqdcLK0Mr4y9WqSrWqq0yXTaXU351XTz6rMlXoiPpNp3TE4dL+HUXdMTWiKcprEuE+k1RpoqbUYQll8oFrBpPtq2vcCXzvKECRoQfE4mWlJGlyYY0dbqWTnNsUZ1X4+3LlMeufLk1fldSRD2r92XG+3ddLhd+coAN7xzU5OaW+TTllshkNbEyrf/3yaZnmy2X+N2vFav7qsKWBfWk1mXbZuyzwknGhBFkfB8bOHrNaycxM82jp3N+4OKGlIGya5x4dSqb51elMaRM+//nPuwkLeZPmRhrKJz7xidnPIXs068XmS0NsTCZS4/7zP//TkTpaOudEgoyaYMO+7jgBAjdAnHneamfzL8KIFcjAzM9kY5OPExQIqoojb+vOFg3aQ/tn7IwBrRjhJG5RY9qH/Ocq5LIcvsFwDnGrhier4Y1A1M7e2HMVB0HgMoK3COROEAp15G8bPaDbRg7o1pH9Gi0U3H0hiG56pqTJ6aKmC2WnSE/1FTSTKKk8EqhyIKESpvjJpEoYrGpSaoBSsYHylDpwpN7ccV7rqqe+zb6F9o684aZWcFDlOWP3rmOl/kendOe107r2B2Mur70Z7NnuvKGo6743rsl9VWUT3cpUcprYN6MgM6NTzuxb1rloOdKtBJrxnFivCOOkVSKYrQbgQsCVhoBo+4D1cYDgsQgy11ZTH4coGC/7Fnsf+zkW2tIS11jcNRDSrFrdoRBYt2ZN8csBot/f8Y53OD8aEeHcShYCxGP5xFFCZLGw0UdNyGZmj5rnMc1D3GwKkBGWA9Oird+5BW6FNzbIG3JmgYYDq1ikkCFWi7AAwfcZO4IApIHwgBDCphQWABCCLIit08S4kBxitCIEjfkClTBfs6ERC7GckjebgZXxXYyVIUwozBXGH639f8vIfs2U61XpCpWKMsmk1qW6NDNdUq3BqC6ArSur7cVJTewr133rVI6brinTlVTQE7hCNlSmqxYTSuatYPzsleIHVqub5gmem23jTuoc5WubHIJP36EkHT7Qq4c8fNjN4dJ0TaVizUXI33bFpPbcWVbvcEr5TEq3/++UcgMpZbIJzeyvaOjYlEpD92jg8Koe+rAzOhLPEAUWOdYKZI0w3yogBuYfQh7rdbmbw4SBK491jGAS14wKoKSwv0CczNmoFXE1gLXM+ifOh2dvXeJObzRwaicOJdO8J/ZFAt8ZWuPnPvc5PeUpT3HvsWDRHiHnqAm7ma8bIAVi+kJSNjcBUj0mMbRmJhMmvKiWj/aOVh69HuTN+ViwUf83QgILlbEzKRkXwgYLhMnKgrB2rIyLRcP5+D4CB+dlgUP2qwXhDYhxNivliZWB+AVIcSXKffIceV7MHfyZCFYL2RiYCwhr1nc7jCpFffbvc6yKCZ5ucIVyRb2VtKtQl0olZ7+HZj+ikoLJhKb2VFWipSsW9J6kqpmaqkGgZBe14wlbj2rrc+gBLlS+XoveBd5B6qUmxI4v3tR80uEC6bST1mnmTunaH09obF/ZvUcKG3nuqVxSqWRC4wfqSfa4FRLlwKXxZdellF83ofxR9+iMM06/XyZJuwmR2JKl+HJXuqgR85C9CCKcr2sb38WSyF7EWNlTVguZ2bNgXBa/MF8BnnbAas3z3Farad4T+yIA0REljxT7gQ98YJaIMQPh87EysvMFqoXN7Ew+SB9yYhFBtBC5NWqJHmfXY2FGJVPIm0kfDdzjnHxmvnhIhnQ3jkcLZOyMEQK3zSasZbBhYkFYatRpJ8B9hDCtLkA0UMmC/VjozaLIV6uVASBkMX7LlY77/dvGRzVSmFE6CbFXla4l1VNNqTt/sB8eE/3+oOAIvzBW09i9FWcKJyLeVabrCpTCaASxu0T2We/4/MTOt2g40zC7uwp3MbVl6u/V56ZF3ycK0vhPU5oar6lSwIzQOGXj9pTJl09KmXRClWrgYgOOPMN1odHYnrKGj6qqNnSnTjx1y/3SoNpJiKwP1t1SYEGAgHW6HP3aDRA1SgHruNVUPPYHrBTsAashhY99iWfBfYt7FmNjY+7+LjXIdj5yZ46txqj5Ne1j7xTe9773uYnz7ne/+34V2qKkDtDiEQbiGipArJA3ZIPpG40YUiU1Da2ZCRQ9zq6HxB8ldcyEEHi0KQxarbV2ZVHjPoAsiKJHSOD6pqmHNQj+H4kYawKBdRD/aprABsulR2PnPmKSs2pl4WC/5YzgbwbmCNHsCBuYQ61iWTOE+5M3M5vy+7f09mtdV7eyyZSG891an+1S4qCuLnVklVRKSZWDmroHU/VI+EJQf03UCdXKyjbObiNpPkYE3kw9On62UA2+dhrNBBFNPUL09nktI02PV1WdCVzhHF7i3/F6CVu+xyPFZZDJw/D194mKnx6vafSetPJTD3LzlE2/lWYnCyVEzrnQssNxgJCwHPFMl7OoEVYrLHRWn6JVrLYWy9YWt9mzGIgU4EGYbifias2vJq+2J/YFgg2DAjkE4Zkv3Hozx/Ufh7Qh9miVOJPa0YYhHDR6CBttmsnKpI0LcANopXw3er1wW9iwr9EK3vAeWi1jst7rkDzSLEICZqW4xc7EtZx8FvRKlU5tBdZ9LRyotNLBfnEI93hnnHP1eG+1P3kmldLW/kGdtG69jhoYVF9XvqFZ3Lfh2P+vy+edWX5mquoKzaD94tOmdWtmsNFf3RFwo+96s6ozDRA1X0sHquQClbsCVV2XmLqGTelaVxs+VPSmDqriNF7W9707odQ0ZvZ633jGY+Z899Or0uRIVZWZQBgXRrA21AJ19SVd57nevpxzVXB/52t2shBwHtY5rqp2aatWOpnnijbM2u1k6WTrPIf1bzH+cmuxTEVPFAP2jpUALin2wPmEk0wjyJZ9C+um7dPtJnfr8c7+u1oayXhT/AJgeeLUkn/961/v3iPVDJMPm/T9/J7VqhMEMKlHO6ZhKmeyIelBRpiI7fhmAW5zXY8Jy/to3GH/t2n3aAR8H40djZHJiK+PYCwWCIuWzZCFEvX5of0ihLCoLQqfYzHdr4YAujgwTn4bhMm9YYGv1rGyUREjEA1UBBA6xE8Q5EKDgSC8vSMTmpopKdnIR+O97q6shvu7dd02IudnnBZMdLxr6drY72sEFqN9N3LR6//Em+Jr9GPPwrwHv58uSmm09nSgWkGqjtID9r4vWana8BtdxYwmf5hUuRho6kBVlWKgwlRNNfZvqy3fJ206LqdsUpocremh/3fAVdObmQh05Ml5dfWm3DMnDYo5sFRfK4SIkNBJNw6CKOuX9WfrsZ2wplGs7bjaGgsFVkHmLMVtljOFr5WgvzjYvolAg0LT7gI8q8007zX2BeCNb3yjM0m95jWvOagICZpzXGWpuOpyEDlmJCReC0pjooWP5zgIOmo2nut6EBhatPnimWiQOaTAv2xKELNF77NZsenhPiCyl4mIIBJtXwiBY9q0IBsWMJov5nkWCnmwq8kEZbBqZebOwEe4WqTp+Xq8WzoUzwMNC6FwMRG+kPn6oV73ymczymfTWj/Yow2DvUoGKZWuzEi35pSvZpRfn1S2v64dF++VqpNSQGn+htm8rlTfX3OvQuq5KKnXHey8X8oETiggGC+zmTz5ihKZxvcPInXM9oGqgxUlt9Q0vqui8jR+/3pkvbglBSkxLQUjUrIipfNJJYOEevpSOuKkLp34yB5H6u50iYRbP3HNThYC67AIIXTSjcN6tqBIYikW06Z0LmD9Q0hsl9VqJVL4LAuIPXihxX4GGynCnAPBAFdqO7HaTPOe2FvE9773PZcXf8EFF8xKp5Aa5vi4YCa0MOukZqYaTEFhfw9aWDTtiQUNEdtxYWC2j7seiwthwYJaMBtiDeD7TC4rsGOFFnhZjjWbHtfjOH6X5WpCKkjHbGqYCqM58iwsfITECHCtdvsz2wHuCYuNBQ2xE7/QiUYy7UC4xztzhPuK4MUziYvNaBWpZFL9PXltWt+vTesH1N/b5SLkR/YUNLanpNRkSqnbssqUk0rWEsrUUm5uuFQ1UMYU3/h/5CKatLB50as9K1Uh9VmEEtVDh5TvKyzrzOvaOKUETWisuXumJuXQdojIryl/UqDyTN1E74LoXAc4qXso6drPBmVpal9VO28sanqyqjtvmNKP/n2fdt5eaKnZyUKAGwTX1XK4cTolNENinAs3Qjs1VfYE5ixEa3O20+uZ9TufS6oZsEhicWXfYy9YSP2LQ80074m9BUC2L3/5y10EvJnUmwWpRavLMZnwB5m/j4XLQ4dooylX5iPnuKgpzqrZRa9npnYmq/V2h4zxg/Hi+ozZCJ2JzAbC+5jlsRiwYAguAxC8afRIxxBNs3xbxs+myWbRiQCVdnU9Y5wIIaYNNesMtdKwQEVcHDxDhC4sJe1OhxqfKWjP+JRLh5sulTRaLKiUrmvIhWnqxAaz/drdVIt0TatScQ5+aPjR62i+Qdb7yJFJX1O1VlSylFUykXQkn8zUN8NkkHTpb7gKMusCZfukVL7xb8PX3jMQaOPxSeV6E0qlE0p1JZTblNDe7WWN7i7rwHaTRuYuaMS8aGVDh9CtHXG7o6rnggnN7QgCRHNESEA4jAvsbeecZQ9hL+oEmVlPjIUG/UVhBXhwZRJEyL3hHq21gjbexz4PeCDPf/7z3b//9V//5R4aC81KLuJjiotgBmjjSIVItkwmFhYbBRp2tKZ7uNgM5B8G1yNgjQUUbUWLJA6JEWXL5MfvxAaG2Y3zYRWwsqNMNtPMo+fnu0xAFij+dOtRzvHh9Ldm98hyRxEWECRW0r9kqW2MIxrbgMuCGIG4zlCrBWgll156qXtWPDs2s6jFZLGgIcyO0XFVS4Fu/W5Bk5MVVTOB1p0V1PPOG0XG+JfSr7Rndab0PEJkPS+tkpaqTvGLlJObExWlawWlZ6h8k1DgOsc0+Wa6oPFfZBUUkqqOBCrcGCgoSgNbai7QL9+b0KNfkVOye1iTBwL1rU9pZFdFWx/cpe7+uX29CJ+4N9Dk52p2ghCMWwShNq4Z03LWQmddL6bfgBXM4jys407P9U6l8LE/oTggnLTTHVJqKC+MuxMFeKygjWtSlMst617jiX0efPrTn9Zb3/pW50diYRkBs+nGVZeDONCATSuG0DmOhzpX85dmxW2aBcUBJHprUcsGhBWA70FsCAJo8bzfjNDDMM0fcxrfYzPjWJuYrRRisACV+TbNTqKVzQyhB8sGz4ANczm1sVbGj2uD58j8woLDc25XoOKByWntn5xWdTypWy6bduVZ0ZLXnxUo1UvN+JArvcHXmL/T/YEq5cARMuls5a5EU1JHMw8azvkELWHdySpKlarKFLqkMvW3m92ARiW8Uv1a2PKrE4Fqvy6pNp5Uvi+p455U1NDWonK9g0rlD9fk3kC53qSGj2itElgrGzrCOZ/H9XtYToSDABfab4DjENCxqnWqJ0LcPsKcJRMFa1NU8VnsemAvYa12ojbBHXfc4V7E5LBntvsa8+29nYAn9jlg+Z7UgX/qU586JwEzodFaOYZFRE41G7FNEjYTyNYIM4y5ituwOHlxPTNBQdyYpRgLZmYIwKRjxoHwALHxPmN0ps45NG6C7tgAMPdjekdDICLfAvHMJ28R83Odq9NS8HwgBYdNcL6uZ/wmKz/JODthplwMeK7MI8Zvz5tN0poDLbXH+96JKY1OzWjXbysa213W1IGaKjNSz3GBek+pR6+7PPPQ3pYerEe2l8lxV8KZ0Eu5hIuGDxN7TRWVNa6Ki3SzErYppdWrjLrJnFd6OqvUdM46u9YRU9iOsrZVxkLd+sFA2WxV/aUZHdYVqDvXrVt+EeiGi1IqTqSVyiTUf1haW0/P65EvGFC+EUDX6oYerajG/UZg5hksR4naVoBbAKGZdd6Ka8CyKbAMtruzYCtAGGV94VaAMBc7ZxdTTGcxYM9j3yJIlX2zXddaCVIHntibgOCxJz7xiU7z/OAHP9iUgF3Hqd27Z3uiY36PSpZmnmdyRwM/IGLKnHK+qMkPkz3Xs9rijAmSZ+PnHCxyM+lzHmvWgHkewoqrShcGAgIbGwICKXmYutjIIHq0Xs7Lb4Ugubb55+NS4pqVoSQmYCFpKUsBwgQmeO5/1GVxKLgQCHJC+EOIiwZVMhewMvAsrP/0oq4xXdCu0Qlt+0VJtSDQ1P6aihNEnwfqe0igHFWLXU57nXBTjWYuAYFtRKVTytX516UiOeaNHPSayipoD7HwsddNKqsu9SnJHJrsUrIw9/hdiF4/QXX3/6xwu3T3fyZVmag/K8rLJtPS4GFpnXpurx76nNbbjUYrqlmFv1bn0HKC9QpZMk8YXzNh1NwIrGkUjJUC+yXCiKXYLdSdZCWgWQ/L0UK2WCy6uYArbK7S1K3CLKUrsaes6uA5Hux5553ntD42ule84hUtVTxiUlO/nTQujoWgF1pQ5R/+4R/cov/bv/3b+1V7Y0FZOhkbMeTItdhs42ovowEgcSO5Rj9rVtwmHBTHb7BqcQTsWY1qrsWxLPiwVo3wgFkeIoiL/ISkCSDCj8viY+FwjGknLEBS47guv4/nYJp/XEpcFIzDAvMgTYQaqwLXKVjXMzSEVjdkxokWzG/lPnUikKZV8PwYP8JVXIMYS4dijuFvZG4uBt25jPKZtCPnoJJQvj/pUsr4//0XJ3TgxwkVdzTC2StScadUvLNeGrZeMCZwAW9oyV0QqouSD1TU/oNInfdqjf/q/19SCU0+IVV7CrMCQVNSH6pKB0Xc34f8cdJRf1lTMo+bqF4lr8ZYp2q659qiqy+/mIpqrC+IBEF0tZE6YA1CkAigBNU1K7iCtQGNfinZFO0Ae6L1ZVhodb1wMZ3l6gufy+XcXoBF1YpGLTbozfbilVIUVrXG/oxnPMP5fEkxY8M9//zz3Y3/whe+0PQYFid92N/ylrfo2c9+tru5TJDnPve5LWs5LG6Ege9///uOnIA1SiGaEm2YvxkTi4wJDClEO6mFm7/Eac9zFbfBNA6hEizCArZoTr7H+dCEOZ8VRTDpMKxJc35I1Zq28DkmMsuvR5qfz0zH/WejYBxsFJYyFy7EMBeQfsONZBbSDWshwEqB5QTyW4zpa6VdCDwnyIX5PV9TjsX6XA0zpbJuum5U915fcGRdGKmpsE8q7JBqWNFpvLJOSg9JufUJ5TdJQaam7lMCpbJW2L3hDy9LE9lJFUSmQZ3kofH7A097Qr3BkIuIT03Ea+3u+P6KErlwg/e4+yDt+VZS+3/C3K+PKduV0JYH5/Wsv97gouYXAtYRQizaMFa65bIyLRbNCq6sRjdC2J3EPsK+M5/Fjz2YddyOYjpLKRq12Nr4pgitFFYtsTM5uaGQGMQHLrzwQtdXHUmqWWclJET84e95z3sWdV02dgj6//7f/6s3velN7j0WOwUukB4hOjZgCN3GQIQ8Ul40AtuavyBxRk1i1oENjTyal442xkaP5mypcZjVmOCcDxM8JNuM0KOEhfkOnxvfY0xo03a+VoCVBOHIukFZMRumjvmQ5prE4UYybJpxveiXAgQtXBZL7do2l9+1k2BOYZ1ZyGa81CYXlUpNN/5mTLvvLqpUrGh8R0XFyZqSQyUF5YTK2zIKZlLKDEtDj5Sq5UB9D1e9uIwRe6Pt6kR6nwrJ8TlIvQ6IHfP/oDYoWcgqNRmJmoafMzUFAxU8+fOWsZ3ZntCd/1jPG8YAQADdo39vQA99zv2FsurEqGpjB5TI5pTacPj9nqu1/+S5M1eXu6LaYsDaZp9gfVoamLVUXo0WB6uuZ4FwzeY66w/h1VJpVwqFQsHteyhw3N+4ImSrya9+SBA70ehveMMbDsqNhuSYDF/96lddCloUmHpYkP/6r/+qL37xi87Py0L9u7/7Oz3hCU9o6bqvfvWrnbRIQRoeENfELANx8f+Ybtnw7cERAWqlZqObRVjLjz5oNnJ8OlGJFC3d/NsQul0LcsR8jlbKMUz4VqRCCN187jxqi/xcKKzqHZoCRIKwwpjMYgCxzDcWa1e51ICaVlPbFovl7GSFkMj4FyPwLLXHO/NhdLSomw7s077kflVdWzb7TCpcndPol/q08SkJdR0fKHfEfQ1cEqHpPJXar+nUmDO7z5X6BlmPab+OCE5QqpB3vvbGB/f1cO8tK8DE3gKxlw4kdNvfJp3AkEpLJzyuW09+1Trleu6bV+Udd2n6km9q+tLvqrpvl4JSQcn+IXU99mnqe8GfKrPh8NkypcxJ5ibPBAJibnNfO2Vlagd4hlj0sMKxBk0gWa2wfQSNmPidaItdE9KXy68+H5gD3Fvr2zFfxbuV9KsfNA6tUmAyjkqd3DDMz3wWB4gUvOtd79IrX/lKp+FDuGeffbYjt/nwgx/8QJ/97Ged6Z9roRVB6kjGbLpIkBC7kTSTE7KKqxLHsQRmxTVxsWIz4eMQDtik2VAQXsLXMr82Uiy/n8+jXdiisKpxWAXYmGgzGy5Gs1CfN/cDQkfYwGrAb7NAOitoM9852XQwlSO8tKuRDJsEknQ7a3gvVycriwtgbi3GihEtvLLQSlr0Xb9pZo/2pQ8mdcC0zJ9e1PDLxzRyZXBfJTo+i3BuKjCtau5ro88XNK2ZxKQSlK5zJ7vvVNVURbX03MLB7LkQPLbXy+ZuODatp/zJsJ72uvUHkXrprps08rG/0fjXP6ny3beqVmiU6t23S5Pf+g/tfft5Ktx23azJ1TZtLGV0V2St4dprtt+sBpiLjvGjKLDuLYh2NYL9AkLH+kkMULi6nvnVsW6uBlIH7LGMFQEv2jVytfnVV5TY3/zmN9dNZ3O8uIGLgQV0vepVr3L+eDa9f/mXf3GSOBaA+bQ0jiFojkXCBGPiQaj4PVk8Yc2NSYi7gIcejfY0qXSu6nJYEiBnFiLnYWPmOK6BKwDpO1zelQmG+QqBgHM3W7yMl8WCFsiCgaD4/ZwPwsJcjRAB4S+0vrOVocUCgZDBPWJsRu5ce77AumhAzVJqYuO347nFBSwuFdbJipRFNvdOlMu0OI2laFhm2bFKWpbD3wrunRzTeHlGVdenNebcSSl3UlnJDRUduLLeGMY1h4n0gsnVTKNt/gzQqssqqqSCJjSioEo+fOA0/2qmrMnBA5oc2q9KulgPnpuv8A0p7nsCHX9moLP+KqejH3dwDntQLmn8Sx9R+c4bFZSLSvb0K9U3VP93aIMSPQOq3HO7dn74r1UcH7tfjQjWG8+FucVmzhpdrb0GUC4QlhFGePasK6w4qxlYIq0kNXufKSLEDHSq0U6na+OvFlJfEWLHvM4imesFiaLBRKMombRM4GbajeWHRxcpCxQNsxkgpT/+4z92xMkLU7xpxBwbJWe+DzkTHR83Fog1romLtU9FcOBYTDxMEsgRKRazuZl+IfRwkFqYmK0ATViTtDx6CB1rAaTEphQVOiAsSABtBHJnU1gokKbZRCzgiHHYpLYGCHNtgu2oiU0sBPeS83Sq+IY1kmFOtLtcJiZHawPaDn/cQnu8gx2TEy7zfC7+JO2t78lFR+gVgtpdw5d6ExdIGfJPBymlqpkGrcdtbAl3iXHVW6juCu5VNptWEn96vqKpgRFV03WTQFn1Ri01V+CmWQEcZ27QwFmBsk+d0OTl39GBy3+swuR9jT2KN1+l8r23KqiUlUimlEgf7KtN5vIKUmlVtt2sk7Olpu4WrExs6Dyv1diumPFYPwdcMdYKmLEuJap7OWAlqdnbfv7zn7t7vJpaKzerjR/u52CYLwV4uZFcCcmHDX2uFw8aky3+XEjWcPHFF7uNFVKJgwW0ETEcBsEwc0mB733ve51PnXasEB/kiWYNkcYR91zpa2igvOLM8yw0CIlroAVCiGjnLEr859wbSDNK6GFfujUyYFwQM2lwmAqZaPw/C4NzzhXVbYTFGCEr7tdCCYtxYBHhfiNxc08gqGgjmbkQbSTTavctzo/5lGsvR5AQ12ADYj62Y3OHfM3k2M7o+4X0eHfjqNUDIOcCMzgzEGjgIQnN3FOv2U5eO/+mqlK6Wt9E1lU2aVJGrPXWbfjJ677yQKPap6JmlA3yKgUlTaVHlUymVMhONjT0+nH46cPkXif4unne/kvYq1JS0JXWvcedpuL3L9De975E4z/+goJaTcVr/1fVvTtVGx91fvXq2H5VD+xRdWSPapPjjvDLSihTKSk7MrdwS7Aqew7PaqFpW51E2JVjSk1cqulqN82zN/NbrE7HahZGkiFhn70TgZ/xriZSX9XBc5buhkb58Y9/fDbdjY3L0t0gMvzn+MWRpMCHPvQhvfOd79S///u/O7/IZz7zGVdgBqk2mteJTxILwn//93+7hfulL33JkXmz6nLzpa9ZDXk27KhAgCBgKRwW1W4FJiB1yM0iW+eLdDeg8eEzZzFbf+KFSruYlKxELr9pMSkyWFHYQLh31qTGhBMj+7l+y0KrwGHp4H5BtssZfcrGs9QSr8tVvxuXDddBKImL8wBX7t6u3dPjKiWbu2Rc//OdvUru71I1W1Pu6Joy6aRSlXokehg3ZX6jieQB9ahfGeUctWN6nxLkXdfAt5ROVHelX5fm/kePKz9H1bxp5gffh7Sy7r+6cGCfJZWgcH3jz0SlTLi+lM5o3S/+R+t//Dl3Lr4fYCqdnpZKVanSuAbmBaLsXA/5pIJsXmTFDb7yHep/7stbuq/trAK4VCCQo0Q0S/FcbFT3csIsTFg32U+x4OGuW+7GO4sBAj7CE/d2tY11dYkZEdAmFQ0e8ibNjcj2T3ziEwdNCiY3ZGt47Wtf63LYX/e61zmp6qKLLtKPfvSj2GINmP1/9rOfudQ2vgMxQXSQJQQVJXUrGoN0HCV1M8/zfpjUeR8SMlLnvGzokBfnQwuE2M0Pbq+5NgyrQgaxsyBYCAg5i2lJyrEIMAgbaHmLKXzCb0YwYqIj2PCvmTZbMc3zXZ4VvmI097m6b7XbhL0QcD2sKzxDNiAW9UItHRADglAn4gLCwFyIaT7a4z2MI/oGlE6m62QZc7t5BEExocSufL2GPKRJHAwdV2O+P1w9TJOacCb3A9qlA9rttHirG7+uvEXrypvVGwyoSz26LX1VxNRuZW2qKmlGUxp3r6AQKBGklSyllJpKKTmRUmImqSCJ+b+uv08f8xAplZFKRQWFaSlRk2Nt8u5zEHpjrvC8kjj2K0oVp5XI5pU96qSW7yvWEIgUrd18wysBBDdcb5BKs3UQjRNh7q0mWK97BA6srdZil9+z2rpFNjPNo2iuNlJf9Rp7p/H3f//3LqgO/w4EZ+Vd8VXFlWKEUFjQcelrUS2f28oGjpAA0fGe1XvnOnyOBog/3DQAy01vBiwCnA9BATM2sQgWZAfJ8D6m+MU2C0E4QDiBYHktlHgsNYR7AQHin4TYLSVuqY1kTLrnXrUrtW2xWEyJV8iV8bMZt6OhSyuYq4YAc/DmkX3aNnFAM5qsM7l9xquU0OgXBzR0ZEbpXjntuu9UKU3v9hjvNyb0H+W+Ij7dXDtKtUTFfae3OqDh8uHqqfXXU9OU0RW5H2pH6nY9MfGC+8YakwPv4vSK0rrCJiXoLhf+bVhRuiuuQl1QKyso7ldy/ICGbr5aw7dcp8yuu6Wdd8uF9DMQLPy1qqpJrEhpqVxU5kEP0+Z//Z7Lb19s2tZiOq8tBewDxNKYla4VsG9hVVtN+fnslwR8IoCGyZF5yWfMW/bhlS71vJrz1ZvhAUvsbMpMqO9+97uzBXDmyjuHgDkmrrpctIY834WA2fxZSBAukjPCA2RuvmczuWNxwBxuBWCiEiCbCFosEjobCJM9riUiJmIrQ4uQsBgzIUFXmO84P0SwGGmUTQRhBe3GBKSFVKtrVgWO99jUeD6rYaFbW00EODb3ueryQ7BYRJgfK5FnbDUE8qNHqrJtnTaelNPJz+x1zLm/MK27J8Y0UhzXTKmo0kSg4raUZq7NqXhrVpnehJK0dM3UtPXPUYCb3/vr0pfr9tT1Oqn0UB1XPk3VhrZ+cP25hC7Jf00jqd06LThT6xNbmpB6QqWgoKGJjcpX41uAcvZqf0VBip7l9QC8Wq2iYHK/tv7sBxrYfo+0/XZp392a2XKKxh73bBWOPVWJUkG9116mrUefoPX/51WLuqdsnQjDWP4QhOcTzNsB63bGumS/Wcj1VlN+Pnsk1j3WcjPXW7PqeqsByVWSr94MD0hiZ4JD0BS5If0uTNxx5V3ZwDG7QVTRILywls/nEDomJGuZSs43x/CZBbGY9mqV46IFYFiwnI9zs3EgcEC0kOR8RUgQMiBmFj6LYTER42jGjIW4AMaymJxSE1b4feYvW0ojGb67Gktlhku8srE3s3TwOdodZtyV8stOTkzpO2+/W6WRtIY29eqJr1mvgS33bZbjxRn99Po7VO0vzaa0VSeSmvl5lzLVnNLdgboeFKh30xy91FXWrzI/cob0M2eeq5RSs+ReD6lLaSS5W5fkv+reSCqlx+h3lFWj41sDdRN7TdOVSW2dPLFp5D5v00++lp9SkGTc+OATCtDMJ/fp2K98Qr3lQFO9g9pzznmq5bqVLMwoyGadj703l9fpx5+s3AI0LwLvavj38dOXZjQxPq7rbr5VXf2DHfcNL7XbGXsKc9ECbdtdBbIVWEoeVsf56tlbdT0UjsUUYeoEwvv3asUDkthf85rXOO2JAjZWXQ7iZqJFU9QA5mmIikjT6MNkoaGhQn78a6VlIVS0OctTthz9uYLJjCQwQbHgEDZAtAXsfIBAIWbz5c6lSc7X+QzTOtdfTJ9ixsEmwn1hE8HvGzbNt1KtzoLAOA6teCU2oqWWeCVuAQEPUl/JACae6eWfHtGdV4yo1jWlJ712kw4/qp5VUKiW9ZN7blaxUq53dqs1qssRAQ8B39ujxP6cgmSgAbr5zjEVqqrojtQNmtCYTi4+0gXCGTOPJvfql7nvajo54cgb0j9CJ+pIneT87nVCl4qadv71/uKwNs0cNWdKnguNowNdsqpq17QL1+c8laCkrluv0fH/9f90z5/8o8q9g0qP7lWiWnW+dWWyqm4+WlsHBnXMwPyEUZ2e1MzubSrs3a4SUfbj+6VKSclMVpmeAe2tZbU/1afTHvnYg7RQ119hdK+qEyNKpNLKbDzSHbNQWLczi9BfDW1VFxs8yr7YquWNY7BYshfhfmCPXklSzaxwHfhW8IAjdoLk/s//+T/Or27SIpogWnwccUMsEDT+8WhOuDUK4Biij9HWzESO+Z38bFLTIPlWosMBGjvjwYyPyZ/jF6MBmJnQmoUs1k+F9QGJGUl5seVVCdpBOMJywViskQzgt83lpzITNkFK3MeVNiG2WuKVuYSwZ21AiaBeTCnfpYC67MVKxbU1zaZS7vmXZ2oa2VbWlPbptntumI3uvnV8t24e2a1qkejxhAsgr1eYq+esq5RU6pYBwsnVtSlQdnD++nCY12cS00oESe1J3KMbU1doT/Ie5RPdsyluaPgQ+7A2zXZvD5em7SsN6Yjp4+fU2HG9I3DUk+trqvROOGGEa5QqUzrqS5/QyLP+RKlKWckyVXYa7oH+dar2DSkTVHVyaUZZrFsje1W45meq7t8tdeWV3nKccltPUKJ/nabuvU3FYkm14pRUmJTyPVKux92oRFBVsjSjaiKjOxKDOvqUh7g1V963XZO/ulDFbTeoNj2BDVepgfXqPvWx6n3k05VscT0xj9By2WPaVcAFZQVhlHmxmLaqiwHKAsoQFoeFWhPZixgve1E0/ma5kF7FfvUHLLGbBov5/WUve5l7D586RApxR028LCbylqPpa5ASwR28IHICxczvDhFZ2huCAxp8K6lrmNCRSNHuzHSP1g2hYd5bbHMTSAYJmeMZ52IWg5nDGAta82K0Tkxp4TiCVhvJWGob+e5sCJ1qJNMuRLULhD/rR72cWkaZ1rzjo5oslZz2uqG7W4f39h00hnAA4MThvZosF1UrNkidvcu+yhaRlJK39StZTLvPe4+pvzcXINxKoqyfpv5b9yTvK+mcV7cjcLT1mip6cJVIaOZl3f9+cARfQieNP1RJVPK4a/CC1GcPS6iWn1EtW3TnKqqoDZddrOIpZyldnFGiWmlILBxYUaWrV8lyUUd//n3S9CQ5Yo1zNb7Dd/sGpU1bVTjqNE0e9QilZ8bUP3KHkmjNmZxULLhAPIdS0QkXe1L9yvUMaP32a1Tbt12JTF6Jrh5X8SeYGlcQ1NT14Mdq6JkvV3IeomBOYfHpxDwKp3CyLjtZF4K9iP0UZWWxwYZWdhZFbLm7MCZXuV/9AUns/MwXvehFbjOjQQwPZ668c74PEVmKE9+HtNE+8fuG+/faZ/Zy0cY33+zIzPzlc01UfOho1wgBCAMmyVq3MQQI0v6adbRrRZPE7IbwwHgWsxjM543EvdixROMIGMdcjWSsIUTY9LhSJsTFCJFsxvw20jTjgh07iXsnxrRralL5VNrVhOd13OCQBnL52ADAbT3kg6ccscNpB9eDrxNn8q4+JabrFeZSeamb0upN+qpDuKVkUd9J/YfGk3sbJvb6d/n/jDPPSwPBep1dfJG2Z+/UTJJKihFiTwQaKG7Qlulj47V1/o0Qe5ApO5M8b1HEdsMvLlb56IcpyHU7crec9iCoqtw3pN6br9BhP/rPusJfDQjCqZ+KuUXj+kpdyz/wu29XeeOxTjvvv/zryhUOKNE/3MiTx3fhciJdOl2ip0/l/TuliRFlhjcr13uwYF6F3AtTGnzmy9Vz2uPmfJYIiryIL+mEloolYee9d+uGO+/R1qOPadpWNSB1dccdqoztV238gKqjB1QrTCt7xHHKn/IIpRCA5vGrs29gIVoKwl0YralVp8k2cQj41R+QxP65z33OFaMhnxN/dRxxhwHRspgsRY2oYiYS30fa5HMIBzKy1DVggWGcby4fNd+HsLkGPnAmezNNGK0PMkOaZiIvxhRkmqQtBohxMZN0qWOxOALcFPxm/GXhHu+WEsffmLD5HPNjGAgomORMg1kOE+JCgVDHXLM0Ssa5lJayC8Xtowc0Viiou0EEU+WSjuof1Pru+7sxuP+XbLteY7WSEtWEAhcPYhzbIE1eeE+KaSVHckqMZ5RMJ9S1sU7ys13hGq99yR36Tuozmmn40ik2QyBd/TsNM3swpKeUX6ihYIPKtbK2ZW7RTHoiVCueIjgJHT55gvoq6+r93qwPvLMIhMamMLGXVO2qkzPEvumaa5Tbv08jj3qahObMXCtMqJbvUrI4rU3f/Fd17a4L6+5cDU+AK4BDwEEqqyCZ1sQZz1ThpMcrOTOh/h9foHR5SolcXolsRkJgqJbqufS9A1IXazmpoFpVLZlWKptXprdfqVBaXXnvPcoefry6H/wYV2gne8SJym45bsHR44sFwsX0by5S6Y7rFVTLqnUP6q7MOgVbTtTpZ5wxa8GsTo5q+qqfavKyb6k2MeLKDlanp5XK9yi75VgF5bIyRxyngWe9VMmu+PllGS2mCLWzCyP7MXt4J7swZg4Bv/oDjtghUEzIFLehml2UuJtVl8Pka9IhWi/+YRYXCw1SIxgsmroWJTq0Uya1+aj5Hlo/2i+EBOm3smAxg3MeSAJtd7EaYLRK3GKEBMxgjIV7w31dDLFyXxgHmrhVRgtXq0Ozx5rRLMCG+44LBYFrsVXgOgXGBqkj/PB8Ee6Ya620fWwXdk5OaPvEuDKU+A1qjlyPGxpWX5N87Vtv26/rE3fXCc3dbtTXkLk9UrY9MZZVcmd3XVteX1AwWFYyVTelJ6sJ3Zz4jX6d+olLV7MUNxfQliip6nq/Jl2Q3VP1e3ps+aGqVaf14+zlKqSmlA26ZqvWlRMFZWt5PWTyKeqp9rnBVfPTSpUgkLitK1EPoMuUVXGmfmnrSKDu2y/X/i2namb9JtXYoIOakuWKciPj6rr3FvVe930FvetVOvxkZXZcL6XzjsC6rvuxNDPhCDvI9qg8uEnlzSep+KAnKDW+R31XfUvJsf3SvntdQVyn5WOe7xuSNh9Vr3SXSDpy599k74AyPf1Klgsq77lbwdSEUv3DCmqBkt196j/7heo946yD6jagFLD3tBNE9o//8L9UvOM6pfrXKUEg4cQBBYmU9h7zSO1O9rl1NdyT1/iFn9XM9b9UdXS/lMs7bV3JjJJdfcpsOkbp4cNV2bddA09/sdPco8B9RkAwFod293VAWIDcrQV2J4Tn9CHiV39AETubLJXrWBgf/vCH5y0LC3FiQkVaZbLwXatBDykziRAELD877HdpJtGF87LtOxzPxr8Q6TVciAYJdbH+MH4X44FIWbyLCUZrx1i4L2j/3BcEBMZh8QsIXkSRzyfAsGlA8DwjLACrwVSGUIKmhUXHnjexHNzz5SoQUiVVcnJco4WCuyebe3qdts5y33tLSalsQuuOuS8ok6C6y67cpvEtVIprbAmzPvZG6PlsLdeGaX5Ht4KhstTVqEXemP52PMVkd2mbfqtLXTW6ograWjlRZxde5GrGH0jt1HD+cAXJiu7VLbpHtzpfer2+/H3notDNUHmTHjJ5liP2Ut+IMjMDStS4hwcnyQW0fu2ewjWvksrqKfSqp5RVplpQanyfSvkBFfPdSlSqSk+OKVmrqpbKKFmcVDKdUiLfrQAzPaJFrabeW36u7iu/Le29Z1YjHznv/ar2bXBj6bv0c8rturluvt+/nQ21bo5Pp6S+YQVHHE8Uo4Jcl4J01h1TGdykWianzN03KD1CI5GENDXuYhkSgxs0+MzzVT2wS7t33KvSxmN06u++fFFR9HOhdM/NGvvup5Ua3qRk7j7BvLzjTmWOPFETp59bL1ZFZsLNl6kydsBZJbg/ZQr/ECyY71cwU++cF8xMq+vhZ2n4vNcd1HAHyxXBr0vxq88H5rQJz6ytI1os2rPW/OoPKGL/wAc+4DR1ouAxdc9XXY7JbB3PkJQxBZuJB9M6ZmQins1k3EqkO5s8pmf+5XYz+ZaiubWjEA33AasBvwdNcrHBaEsdC/eDmAUWJQsSUz8g8Iyo8laq1bF5EASG5QABYSVLPJLah/CHdhIVSqxACL8Z7WI5/O4QvBM6GxvTzusKuvwzY06RfMKrhzUYymMH20f36TfbblXQ1e0K0sw6sqP5bWjq5aQS2YZdnNxxyriGQGnYsuvAPqGL9d+uOcvvTb9GmSDvPsmpS7VUTTO5KV2Ndq+Cq0oXVcRdI5iE9MixZyqf6FK5b8wF1aUL3UpWcrPWhVqmqCBXdKROtH2u1KP+YlfDAcBvweUTqOrK6GLFgJ8qSpRm6umoSV743s38nlDvnVeq/85f1bX2234jlQqaOPdPVTrm4UoUp9R/6X8pfWC7e1+Usp0cqZetZQ6yFo48wWm5BOaRNx/0DjvhwNlQZqaUmNiv1MSBRlBDzR2b7BtWbcNWTU+Mqb+7S/1nPV99Z/2fg+8J10skXVObyu5t7r30pqOVXn94UxKq4hefHFGyu1+le27R5M+/oeyW4+/3He7T8O+/UZOFkm75yr+pd+ct6ksGCgqTzqpQobnO9LgSlfp10uu3qDY5pvS6w9T/nJer+2FPdO8jpGO5Ym+J22vbDROeN87RH2Et+9XD6JxTYhWADfbd7363vv3tb8/6ryEQSC1q2mLTJeANUzUTA2IxguD7fI5JnvfR5lshdDRRJEkmHJHukA7kjpZKhCjnWszkY6FgcuL3WSDaQk1cjJ3FBnkSPMV5GM9CiXmpY2HRIOQQKIemjmke6d5M81Znfq77be0fua/45VtpJNMJ4C7BvcCmEkfaCB5o8cwzTKxYjNDgO4lU5J458mrc9+h+xX3edsMtOn5oSMObj9Cv9t0WT+qGLB/WC8LEBdFRfIZ3u9WnY/RgbQ9uVzrIqqKiMolcXTsPUkoHXa4cLaVoOU39TPd1fEODJ3q+mJxWhtrv7gcEqnRTBneqIVggwPC9hJK1tHqKA+qhlaxj70DYAZwmTl6+czc0msymswrSGdXIbRddumC3Sj0ArlpWYmJfnax7BqUTHiFd+1P1fvufVD7u0UplM0rNjEtovJYfSDod3y8iHCSlkT20h5NGdteFia5+aWCDkj1DTouX1imYmmwE6gdSpeBM3TOpnLr51dvv0ciXPqCgXFDmyJNUuOYyFbffpsrUmDOnO/N+vkupXJfS3b3Kn/IY9TzuWa5V7exzLc5o6vILVbztGldHnxz+ZM+A8/87wabRGMeNoDit1OAGJ3z09eV0wmkP1e6dN+tAReovkbNfVqK71wUFBsWKCx6kex4CRWpgWMWbfjNL7Aj87KHzFaFpF3DHIVBfc801TqBYauObQ1FTX/MaO5ss/tlnP/vZeutb39q0LCzmYMgev7eRjEVtRiPdIWmI3/me5ij6wjnRQjETQ3xM7HAqXTt81GE/M0Ekiy1EE1clbjGV3RYzFn4/94j7yvcxp0N61p+e+2IpcYxtvgAWqzGNdQShBWFquRZmuNQnz3Q+WHQ/VorFCFRLGee+28tKZxMa2pq5n7WK+U1q4XS1rEt23qRqBU03FBlnaESiN8SE+2nrBgiZCnIQ913BDTp96olOY7e0tiBN5biaLkt/Q9Wg7NLg7rtUPYCurrEHemjhLOVyGQsCsF/kPnepbbUpFRLSZh3tDu0qJNwwU2jBdQ+4SrWEy96zU9juZz8tlayharqOcbSF7f/Fl9Vz2y+kdZul7gFpx23SrVfUT7DhqLovHRLl75nJetobbWALCByN3vU5tPfZB1APsDvsaKl/Y/1YNHfy5huWQSwG9IpPZVIK9t9bFzQyWaWPOV21SqAapu5Mvm4RcM+i7kJId/cpVZpW/9kvUtcp9W6XYOKn/62Z317qAv1cNcHJUVX37XBR7qmNW5Q/5sFSOusC4yii0/fE56vr1HqkfmX/To1++5Oa2rdbk/v3qqcyrZTLEuBmVpXacITSwxuVXr9ZtdG9Sg6u1/AfvGG278RKVIqs1WpuD8DCiptwMRk8h6Jf/QFB7HR3w/z+wx/+0BFCtCwsf2OG5uFjlmdjRTvEzM4tCadhhf0scxV9sX7CkDqaMOTSLJjDSjuywS+lcUu7CtHEVYnr5FgQshAEeA6kz9n1bFEiaKH5hhvJtELuAO0fqT2ukUynwDNnLmE5aPV6RPcjaPJ9hIGVLJWLVQk3gVXH41n+fNetGqEYi/nXZ3cKyKmeqO7y3YPmxI7JvXG0o2Di5voL65SqZRQkpUoGMg10W+JK3ZO6Vakg7UiaIjW1BISNv7um3mBIpyYe0ahLZ6Hw9f7s/FtxoXIV9QWbGpXu3Oam7omS0tXA+X3R5qtKqtzITGv8klkkE3Svu4/tIfbszlu07tsfkDYcIfUO1aPkr/5RPee9u186HBMzQYbpeuGbqbF6hPzIrkYxAO5VUhreJFWK9c8DNO2ENHykNLy5TsyTo9LkmAJ86d19ziUgrAHT4/VzVwv1YjhHPti5CTSxXypOS/nuerod5xtY7+5PbsMWrX/Z37j8+OrYPo1+/SPOdF6+51ZVR/c5DRtBgPGlevqV3ny0EmQIdPUq/6BHqueR5x7kJy/edb2mL/+hpvfcq7G9e5TsHdThZz1X5esuV3Vkr0vtq40dUGXPDmWPP1XpR56tXx8o6IyHPmxFg1r3NBrfoFyxx7RK1LbPHMroGLEj+f/FX/yFM4Nzo373d3/XBa/NZRqB5N70pje56nD4TYk8f9vb3uaOXQho1frc5z7XtWQ1346VhWUDhTTQ0q0vOoQOyaDhY0aOpq5FiQQzOhouwV4QB98hiAyftQXWtRoownFcG1/+UppIWCEa7u9SyCxaJW4x45lrLNxriJvfbVW04hYccQ6Y8trdSKYTQEih8AapPAt1AVj5X4gVK8ViBKpOdQvbV5jUr3bfripk1igzW885w/KdVDKZUA1Cx3weY4p3RB5qAkOZWDT4LMVjS1R8q0e/J5KBCslJXZm4WDPJqcZxwUEm/YdUn6QBrVM1Ra67fVYndkgdnzrnygVDzvRv/J8plNU9QdBXjyN2zPGVWqBawwoxa/AnGLBScITGd1wg2+ge5XberOHvf1giX33j1noa2w2XuSh4p3kffVr9YAuamxyr94jft6Oe/27FcAaGpU3H1jX57bc5LV3ZtNTTK607Usr31r9PgBpaPHuO23cYIWb+xkD7huvm/j3b6oKEcwOk6n5994Nq7vr40dOHHaHcyY9S4Y7rVdm3UwHCA9fAsoArpm9YmaGN6n7UU5V/8GOVGj5MaczwrLWRPSrvvMsRf2brSVKlrMqBnSqXK7r9FxersuN2bVq/QbrlGve9YJrfk1V63WaNp7uVfvS5OuH5L53Nkyf/HbdH5sgTDjL9dxozC2x8cyj71ZeF2EkrY/O+4IIL3GZ+/vnnu43vC1/4QtNjzj33XOen/chHPuI2OL77zne+05k40aRbAdoapuA3vvGNesUrXuHeY9Nk84RIMP1CJJAo5MvY2JT52zbVZqlrcUVf2NSZCEwcTPhIhwudFBTNgYQQKiDCxaaEtKMQTbhKHKbwxXZ4s7Hw22wsCA2QOpo0Qtt8wWP8Dqs10I5GMu2Mll1MQ4tWovuXq0tY+B4RTMq9ROiNXveO0f26eWyXSjV6nta19GQ1qXS2ro2iJxsJh8mYv+raev18+NXrLVtT93nOg7S6ygNKY4/P1nRT7UptS90YiYrnLGWtCzbrEbWnN8z+JVVcKty0q2wH8M+7FrHBRmWUmw3oIyK9d6KsNFpxol6RL0jUfe+U3HVBbPxRLSk1Pabk6B7VMll1X3Wh8nf8RsnpUaXG99ZJu3+904rF31gyINN1W+rXcZHw+XqQHb7vAzvrBGxaO2SNOb9/nUSd+h13SGP7pMOOkbacpEQ6pQDffGnS5djPWiWY3xChC+hrlANE86dOvfkU0OjTuTrRu9z7esSjE1K4FteeGq3fUHz8aPy4DAozSm7YpKHn/onzy5fuuFZVMgV6+jX1y++pun+X88d3P/aZ6nnYk9zhM9f/ShMXfVnThaIKO7cpn0ooSVBwYUaJrm5V0jmVe4Y0fOyDtO78N9fT6r73GZV33O4IPf/gx6j3Sb9bt0gsE2oLaHxzqOWrLyuxs0FhRsX0bS1RabjyzGc+021gzXweaHgf+9jH9JKXvGT2Pcj3/e9/v/7oj/6opWu/+MUvdtaCr3zlK7PV5Ui3MFM6G6eRrzUk4EFasZVWfSuQH+leCCKcB21nKRWQwlXZEEwWG/zVrkI0VpEMwWW+6nnzjQVyxczM34xpoQ1tsCAgnHFfmA+LbSTTrmjZMEyQoh7CUskYSwfaBQJPp7uEtepC4JntmJjUzdv3qVSoqTaWVOKwghJdLkytno6Glxu/cKKuaaM9O2JpdG3Hv552Xu76cyqpqLQyjuSpI99THnYNW36S+4rT6M2U7mLJEqW6j50U0dpp2pjY6kzuQaL+HptXuuGXTyqrvmBj3QqARt7QpLO7b9e6A2NKoq1OHVCw526ldt6qRLWkWqZLlY3HSPk+JXrWKXPXVUpsu14qzaiW71W6OKUkRGukySPGZeLy0yF0/OcNDduZr5P1srLktrtuOrrvuFxDkO0dlI48Sdp1Tz2NDuHgmNPrkfTTo9KBHUpgkUKQ6N9Q18oZO7XmERyoUz+6a1bzdqb+FMJMDYm6/i/jpb0uwkeyQf6m9kPu1DMoFpzffcMr36PazJSmfvEdJ4zQGY+guuxxp6q6b6fLcx8+703u0MnLvqPpK36oLClx1/1KhV33KF0g8DFwcQClREo9RxznLAHDL32TSnffpIkffVGZLceqNjOp2vSUhv7vXzqfvHt+xC9hpaDQTyjgrxPYNU/VykPdrx5GR2wiRCRCBEbq4JxzznE3Eu2YdqlxYHP58pe/rGc961nueMiZILgnPakuLc4HSsVixuf6bLLWwAQSwNTNA7WHaS1RIS4sCZZWNR9JYNqBqDAVQ+RswJC8Nf9YbI4ykwriwkdPHj1a22KCv0x4QStmTAgKixkT4+G3MR40usV0eIOUMYkDBCwIHWJeyDmsMiDPCnI2FwHPCYLnvPM1ksESQxAPpImQ165GMmwUzAPmbTs0bKwa+LjZfLACoEF3Mrrf0jDjijQZ+F2H9/VKWwLdeOcB1fJSldSnhrIIWaddyFugpDK6MbhSpcSMBjTsasJnlKlHuzeEAEi/olIjSK7umy+lprVbdzvdHMKftaOHg/NUc98ZSmxwV7QCcffVlk+qOwjfK4sJCDTZm9Km63+rDH3Zt9/cMJGnXIBaolZVbtdN7vjK4Scree+tSmAuz/cqVZpSAu04aRozvu4yk1nqwlSeqbsmIEnS2KbH6ppxqR6t7grVOA26VA+Aq0HE+M4n6xr3kafUNXhX5reixNhI/fxErHNziWAvbHN/a3iLNNznLBAqTUtDm6Vdt9cFgwT58UhB5XquvVlOLOzBgh/Jo4c8GctkwdXKD8ozmvz+fzrTe1ApKdE3pOr2212hmuquHS4gLtXdqwOTk+p62BNdAxvq3pfuvU3Z7l6ljjpJhdtucIIB8QvZwQElSkVH0pX9uxxxO+DeJPPAWRjq46lOjWnyJ19zefEU6el54vOdu4CueamhjcoefUpbLVebNm1ya4x9AB5ifZnVkP1krZB6xzT2973vffrMZz7jzB9hoDGRfvanf/qnscdBQi984QtdwBvEwk3/6le/6kz08wECgojQ+M8666zZvuhMjHBnNgjdzLmYidFKIZv5NDlMy2ifaDcEdEG84Wj2dhR9CW+4nMuqsi3WX27pV0sdk1XPQ1hopXQj9xbSw6KBFYbAFY5hLBC9FaNZKBCgIHfmhcU2WJe4uRrJRIvqtKORDAIefulONKRpV3R/hYZE1YoyyZTr7rYUFwJm6xv27dI92yYVdFWU6KkHttVf9UA2Utmuq/1a30l9Wvlat/OND2ujzkr+jvN7o6nDNmw4kD4kjjaOBn5bcLX2Jf5/e+cBJllVbu1VsXOayORABpGMgiQVBUUEE1lQxIDirxi4opgVFBRzAAG5RgRUuIIgSYQBkZwRBmaGybFzrHT+592ndk9N0d1Vdao6zMxePE1Pd1edOnGvL65v7aCGvPUuIXSMAV5X69VpXnqBasJNiodtGiekajWoymscrKjP6t8ZgZlMJqne5Got/Netqn/snz7pxbPPrbVO+E6hGuvCQNIUqfnDYrLnPNGXnQhnh9QnpZbpUkOTz6EUuLFNyNbkj9NS+wZpo68VP5gWGCTcLNnxHJFfh8AohOMz8eqznrZvl3j+vjRM9o2AbP7fFOjhtS972v8ME67Ha474BkVWD98YApmUv88mLWAWM7/wzvwu5BcBJnv9bgAT/s+eGyOBHzL1CeHmqYo0tKj6gDepet9DTbU8bXHxubupd/GTWnnDlYq2r1NVNKxodYPJ14er6xSdvaMyPZuUWr/KHC+SuTV7H6aqXfZW739uU88jdyvaMs0YFqYyv6dDGc5bJKL6N75XTW/z8/SVRDpv8A3r+baQVw/ssTMVjbB4oTB8UHz5y182JHLnnXcaL+vGG2/UiSeeaKrbuQAjLdhnnnmm8fSpxCYnb5XQeB8EnNu6ZmVLIXQ8JEgLmdihyI/X20p3Ktzx7ofKXZMXp42O1i22ZSu6gwACpd8Zz81alkGkEgl/231iO5BykH0iekILFMTMdkaaNoexhEHHd8JdfJ59YOhPx+BiG0FEcfhMzgspCzzv3EEyEBUP7EiheX6PkcHxcG4x/IIMkrHa1+z/aEyZ43xxH3MfYMiwn6UWRDLVbUlHmyF2etnn1Ddqao5OPOeQ+6NYqVIEbmbHJ2lFqFPtqVY1e40KmYK5zX4BBL2T91rVevXqDXUbMm/11hvFOWat22I3SBfST6jP/JtQfWtorR9il2dy5HaJ9Sk64re0hWLqjqTUEVprPhXPv8/r1aE6wYTjczvfQ2nC0Sllku3me/zlJ4xamilSy77Kb5rPysBCqJ2b/KY4vHRLgubgGfZui9Oyewaxcj5NQdqA762vWSIl/VY5NU/JhsGzhW18Bt/ZB9v2n07Ja1utEKF0Npvs8wma8HvDZBNN8Hq7TA97iBA9xgPV7AjhvPiQHx3AE8bowFNnHxPZa2KIOftlPpfv1pghFEakIeJ/H9iUPVBej6ET9Y2LKAZGSB7jaFvXyksn1Hv/LYrNWqCGo04aPD0r1m5S/wFv1dSn7lBy3QqlvZAadjjAiNb0PnibQtUNZnteb6cyPb1KLH9JVbvuK4VZi/1wfHLdGqUhf6r/MUIjUXXdfYNq9z5MsZlbzoooF5FsFJAWWxw7uGY8Ra3G3WMnz0mf8khgobADV1iQLFh4WUjwwIcKxbPgU3zGgstJzw3h8/tf/vKXIxoEeOo/+9nPzILIFwsXCyPeyFCta7mLOX+D/Aj3WkLmtBBm5ffcCLbSvRirjjYLbhhb0R20GCNXla2c6W6V2qeRps1BqvyNiAZFatwHwxER9xHXmWl2QXq42Y/8ATtDDZIZCXaQDK8rVUuAe5VCQIzC0Rw8EbS6n3Px7KYN6k4mVBOJKpFJG2LeY/JU1URjZt8xwEvtMV76SI/++2CXVh/5mDK1ac0Kz88Ww+G1+wgPxPVk6AHdEfujkYKt8mp1QOgI7a79jLKc72HXGKKGxPGyW7VWy/WcekRFvF8FH1fVIFFbwt9FB2Zfv0ZrtNR487FMWDPTc7VL5BBTbU8bepiQb6JPfXFPvZFeNS1+Wgv/epXCNhQ9CDtRJvtJFLyZHeB19rpm/47XboFny73NPUNYn7/z1d/nj321894h6Xh1Vrsn+xq8Z7tlQ/hRhWrQpaeAj1B6Kqs1P8Uv0MOzxnvnGalrVqh5ul95z/5QMMfvkaVlPwbhGzX+P1EIzH7lS/pB3rXZHD0TfqzKYCYnJ2+qDPkKK1Rba3Lv0ZkLNfNHtxt9eQqkWVcOnNms/puv0sCSZ5WI1sqLR1WVHpDX261I4zRTbT+w9DkjkBSug+jDCk+apvSGVcpw3vhcoia2NoA0SX2Tpn78u6p5zes1Wghl63S2NZS0KpEjLaYvkQUPz5vcLB4juPvuuw2B4nENBRYukL/Is/DyvqFATvv88883lfd4lIcffrgJ/UIwLPIQvA3VjlRFze8gGDw5blJCNIRaWVQxKiCgUsI0RAvYD7wtogdBRV/4TAjS5ssxlErpxxxqnyCJoPvE/mAosT8Qs1Wro1gRL52oBWmPQtEF7iGuF+eHAksrRlPKfhCeZj84HvYDg8yG5otRqyMywz5AcISkix0kwzXg/uI+Hm1SByw6PEM20lFMdT8jWhMUP4UjxluvCoXUn0opQag5kTT3eKl98ya9sjih6nhU81fsqofm3K3mmkmqidRn8+JZ1bhMSK/13mBU5R6I3azOUKue0r+1o/b0iTcbuve75lCKS2ujVhoyr1a1+tRvfkcDm59b90Pgc7SbZmtXE5ifpB2MV7+k/169YfUcpZNLlG57XvXh+QrH6hXp71FPQ4169nitMqGIYqaQLVuZvuVRbalUY8Lcvked+5Ihzka2mC5L6oS2jdeN+5nePJmOdQvpV1Ncl62OH3So+ZCoTA1gT0KKUnyHch3knka0Pbs9mu7DCiWT8jrWy+vc4BsK1XV+zry7dYv2v83tcVmjxUzlG4LULen3e1ItVyPvXrZLbsSmKyio8yVviSJkutrVX1Vn7iWioo3Tpike8tT5f1crvGmdksleDSQziqOTnxkw6neo6pm6BvLvGFGsyTPmKbn0v+bYjfHCPmUNpXC8WhEiH6OESJYTtkWMarsbHi+etm13o5jOtrvhHTOc5Te/+Y0hA17D4gyJfu973zPeMaF4+tpvvvlmU1GfjzPOOEN//vOfTc865J6rLsdCDZEV07pmQfiY3AuLtw2tl5MrH6qiOygqNd0tV4imnH1if/B4McggWggeD77U4jpy3twnQUVxML4wetgfm0opRa2ulEEydtrWUKNkxwJU93MPYICMVBPCsT/XukFdiYSZx47HHg2FtVvLZD356KPGIOL9+e/ZONCpVX0b1ZHsNfQ7tapJs2qnKB6OqTvRr6du7VSoO2by9Y96j6jhAE+Tqydng+tRhTMxxfprjScNeZM9Xxl+0fSoN4YmqTHaOFg5P6g8x3FppRkCYyvoB0xrnD8MplaNmqvdNVu7mNfzdz/nnlJsyT167RMrlKGnm8pqisEiMXXuvJeWH/p2JepqjYzr9Afv1A733aIoHu6rkOO1k6vGEzYeezbaZJbHrMduPW+K1BjVyvmH4IkGQhAD/VIPMrdGuzdbXeh7n5vDD74YwBZnwBSU2Qk6aaTysrPgs+9lW4TaTaue/3vTC05FvsmTh7P7tzkZ4WvjZ42MXvZxhBurNuYPrTEGQP4cXFsX4JlcO8cZnb2zpn7zj3ro6edMcSfGpsXAS89o028uUqp9nTHy0kQdahpUPXmWkosfNxGMSF2D0ayPzdpJ1bvvr76nH/SFcyhaNIWNIam6RvVvOE6TzvziqOS+Q9tIv/q4CNSce+65WwjU/PjHP95Cs53F8Z///Odg1TvFQuTxFy1aZEiWRZZ+9Nz2t1x86lOfMvl3cvJcJBZ5vFHynnZ4SzGEDinghRFWwhvivfxcCUIGVo0N4uCYg95Muaps5Ux3K1eIBuLk+lmRH6IbEHPQ/bH7ElSkZ6gUAfvIV7Gh+UKDZGxefaRRsmMBa1ARmUDbYTjDk/nrSzva1U/oNBTSnIYmbVy+whgHRCpyzweFcc93rtDynvVKeWlFQpAqxXemzlmxUMz8PtGfVoYi8RU1WvHvbtWf2KrGumbTuLZBq/UP7zqd3vcFk0/Pln4pgpY5jjDV6bFWZcJ+37lfoWUVbwjJV+kVPa31WqakBrSr3qDJmm08cz/Q76vR8TdeH854mrHkeU1+8DaT585kUkpPnqn0tDkK1TYqFYtr44yZ6mtsUs3ipzTjjmsVx0seqqWKawlZE/amYh0+jOcYzpCN7Q8nxM3rY9k8NKSOZw7R9nT5rW6D+vnZynzkXyFmQ66RLKnnLLvGyc6SuwnPe5sd6MHtYHz4424h8kGCNyH8bI79VcZKNryeoA1uhGUeoRyIHSlA+97888Pn19SZ/a570/u07k0fMJEy7qV8w7nnsX+aFrfMQI8yiYT6+tNKRuvU0L/JD8UzDAcRnZp6hVummnB9iNGx1MpQp1BTp5rXHqKmt55meupHA7FtpF99m5OUveeee/SOd7zDqMtBBix0dtGDYCiKKhRm4T2QE4SAF4QhkesJW71jyLgcQh6qorucvA4eLiEwjBD2OegNGmSfIAbOCecWSx3vrxLT5jDk2BfCwxhTQc4P+0aKwF5/rlfujPdCVfO81rYI5g+SscbZaMyULhXFVvdD2ITfo+Gw2ltbjeFCmqymrlbrenvUn0kbjx6N9ec6XxGy8FaRLWJC62Gl6E83lJoyc91NnVYopTWZZWqJTDGeOGRwo67QRq3R/PSuem3qMC1I72VC9KjTwVn0o/fEfZGUXDlXn+Lw8MmeV+vf+osJxe+vY9WgSVt49wTo+YLoI15Is7p7VB+Ja2DtEiV7Wo0xYQrnMhnF8Z5DIa2bM09d1XEt+OMPVdu6YXMvuYV9piFuq+9OWpCQsBV3wRvm7yb/G5GastKykZhfsY5BAPl3MXo1OxjHbDt7rw22vXGsfkh+80qSJU3AegWxG48166XnGgnGqPBrGkx3gTFSQn5LXv4qzn5A7ABSh9y3cMTtPkLs6O8TVRhifcPIsOeJ1M6kaQp98kd6viNh2jyHixyiRpdct9zIzUYmz9LSlxZrzbIl2jG5SQ3VMcV32tu0taXWrVR02mzVHfQWhRmZa4r+UltI2lYa0W2oX32bInY7RQyPnRA/h2AXbxua5efhcre2h528JR6PHRE6FPLlY8vRECaUCyFDqOzbcJ9ZDCj+srPhg0x3y90nOz98JCEajCY7/Q5jAqMi19CpxP5UQqQnP2WBoVCqWl1+q5ltbYPsx1P7eigDj3t9OMGN3FZMUghct1mzZ+u/7Zu0gcrq7PF2ZzaqP9Ofzfv6ZEv5mk+6Wd10E6nJqC2zQclIQj2hTk3SFNWpSU/qPj2quwepmoK6hsxkHZF8r3b29jHEnoz0qS/auUXnuY/NnxFXnR7Q9ZqiuVro7aeqUO3gPhjteL+s2/yuLpXS3AE/zz2w5FFlGGEaQfDG14jnKzbQr96GJi1fuKPm3X2jmh67x/esTTtYDqnj8ZIDxiPeYScpkZLWLfOFYCBuQ5ImKavQzIVSffa5ta1nqLhtWi2tX+ETuDmx2bMGgZjecYoF/YK0Lbx1ezbYDkI0kDFGBfl2EvDmlGbz/1n5Xp/8wybE7SFYAxFucUqzhXgmP89genL22Xx7LrjefA4h/Ry1v1eBz+fPkZjqzrlYT8RnBGrzDKrdXklEtuG8+lZP7Keddpq5SRCkYTHLr3QfbqAJh8rvqKaGlFi4+VshT7yShGyJA6PCanMHjQRUarrbUFXmdp8gSP5GqBtPmL8PR9qV2B/2hfZCiDWoSM9QKYugg2SoQsdYyM8lThRQ40CUinOE4ZFvyOZLxrYO9OuxjWv9vnNEfrwBbUqtz/Z++/8xE90fubpluBiPPRHq17L0s1oeeV576wi9ohf0lBYZcRneMziNjRZQr1bvTH5MczO7KhXuV3+8Y7DLPKtXZ15n37dKi9Wb6TBCJ/uGjlQE6ddsLztFdXb/ohlpSiqpKYmM0qtfVqZjndKhjJKxWjND3a8ZyyiSTBqCXzNnrmYufVlVLz6i0MoXfLLOVshzfpA9DfN92nyFps73Dxey7tqkEISPJnx9k0K0o+E1Q6xJqt+z3rnJh4d9idhXns8aA1nONp/jV8d7Sb/2YND7Nq1qOYVv6NBnc+km1E9Pum1VgwQRqskk/bGwkDFDYbo2+PPjs6xtNQVkJICzz00/YZbsZ2xpARi1OOOtZ398Fezu8bhU12jdmRepfpe9X1WjUcr9ynPFeed+DVorFAShbTyvvlUT+4UXXmja2vCgyKWO5IHl5pEhGRZ7vC8Ig/eWEjKuJCFb4sCzZL/KkTmt1HS3XCEavHb2iWgF5w9AasV40JXan0qI9NhBMrmjeO2An2IHyaBiCLFTBR9EVncsYA0qjje/ut/WQpBC4HgfWbdaGwb6spntjAbUo351m9C7l/W2fWW3zZ60gSf1eJ16NrRIa7REA+oz7WdP6n7zb1+r3R+hirY7/yZkPiezm05MnqeIF1ZvVas/Bc7zc8O8htA6d0eP16FIknx6VF4so6mhOTkf7fnz0tOYAGi+ZxQJdWn2ksWGTE2hHkZKJG6G0tCdxdYppqvqH1AiilgNbdNpRTauVmz1Yom+bIWUqqpV17z9pR12VLyxRVXJLmWmzVeqpkmZgV5FOzaqesNSoyFvBGGoWoeUCc8br9iGqlGai0url/qeu/GyI1J1oxGzobUttGn9lprvxtsn956dzoYCHUYB9yijXsl9m9o9vxrdeP7MQqctjIlu1ivP9tjbAH8I8ueNhLPpq+eLwjgjs5ttw7NT7JCiNW8a5uaykQd2tzquDSd/Wfu974Nledu52u1WIGYsEI/HtwtS3yqJnYULgkV6lva2QsBDJ+/K4mcLxcoJxRCKJpxEQV1Q+djcEGm5amyVnu7GvrAdohPcGhhBFLWVmjevRAqDfeHa2al8QUR67CAZK9lbyiAZIg94uxhxLEKjNUimUmAfMWRsdT/XIHfq3Ka+Xj2+YZ1SeKeGVAeUNt3l3YqY2QmbQ/D5xM75ekx3aIVeMKpxZLsRnmnVBvN3O2qVmvbcvDiE/5bkGZqf2V3hsKdQLD3Y8ua/zm/PiyZ8gnki8i+9Lvo2k3FHgCap3kHluWi6SrXpJr9VLr1Bc55/SpEUleJI00YMsRspVqIR6YSvBe9l1NVQq5rehCKpjDEOyPvTj91TM0nt03c1xW0MYcEzb6qLa5+d5pp9yWQ8dbe3atmDd6vx+fsUpsIb7x10bszm3bNEPJhLT0hLn/IL5hCUqaNOgJA9xL7Or5zPzx9jLJBmYF2yofY4UYAccZnNGr6+Zw8h47nbVEE2TYFpZdTqIO/qFqON74fuqXpPmehBpL5Fmb4ueXweYXr2f1i+2zyuN1VboymX/E1NO2/WGRlN7fZKIrod5NW3amJnd6+44gp95jOfMRX0fB/KCoM0CR/jtZPTgSTspLFyQul225AFIfpyCRnrlSgA4ecgamyVnO5mw+DsD+F2ohu2BbGc/SnnvFuRHr7Iy7EIlIrcFAFGRjGDZLhfiApZw2Y0B8lUEhhkhOY5JiINudGKxW2tWtbFPHDPeLUJr9v3rMMp9Xl9ZspaaFCr3ffpbYdXpzbpX7reFKhBzGjAd6jNELuvIxfNtqLhgdvKalv0BvzfztJ8He2dpKbQJJ+jMtXqSSbVFWrTw5E7NE0zdFDk7YbU+9Vlvner0xgSAIW5qQOzVJ3u1exnnzCitHZibDocMbl2fwBN2gymScaienG3PVXXEVNTd0oxL6R0vFY9tZMUCROuH1AqFFamqkrhSFjNdVXad74vUMVXJplQoqtNa373PeOlG3071htC9KjO2YErNhwOuW9Y6eu5x6rlRes2V68zw711/ebwvTktOYNabAgfIxhit612/N0I0IRMSD88ZaaijZOUDkWU2bhKHn36hN7DIYViVcaY6Z2xh+p23kuRlx5V5pXnfKEcDNlZuyiUTpv57JmBfqU3bJD6eochdltdj7MfUmi3/TT3BzdX1Ou1QlE8f0OlkiqByHaSV9+qid2Ctrb3vve9xgujh92GSVnE8egJPxLmJicM8Y6URw4Cq1ZHZXJQqdZKqrGVO92NMDxhd84fBAr55VeZByGz3BRGOdPmIGWiG4SZgxTemCll2dSM7XIYTq2O31NBDmgps/truy44R5UaJDMa4JgwSthfvHVb6/BSe5tWdneahd8Uf3tdhr5bqqu1MdmugTRT2KoHs7UmoJ0ll8d0t17R89kMvD/2pUddWq9VxlNHKY4QPKF1C+u1+1IzeOnIxcZ1QOZwnRA61Q/Bq0e/836q9VphJGpPyJylmZE9TBSBbbVp02Au3gIzYlbXFM197jElq6sVTyUUwUvlGoUHlKRezYuqKpHU6hlTNdB4gKID1aoKU77mmYrrdIS57BmlEVxJ41yHFY9HtOuMFg0kklqzsVPVjItFDa+3U4l7/2KmnqVCEUVMGiemdPs6qbPVJ2Tj2fqV8trwiu/NVzX7UQl+Z7XcW3kP3QEUpOGVRzaHxcnrM4WSOecDfSb3P/g3wAjao09T0wnnKBSLqeuxe9R7343y1r6iUH2jPHL5/d1mzrq32+vUsW61wpNnqvmVx5Ra8rSZhx6uqVO4rlm1bz5ZfY/fq/4H/mGiF36b3tAwRZWRiKZ+7RrVHXTUmKaSykVoO8qrbxPEbsPi9LizWP/61782Xh0khNUHeQ+VE7YT32weuVxLrlLysYCQM5EAthFUra7UlAGeKQYKPfyQHWHc3GPAa2efuE1KlV4Nsj+jPdTGpghGGiSDsYYhQl46v+2ukoNkRgtW5pPriYFH1IF/tw30a3F7qwayqYi+TI/C4Yya47VKe2l1prrVm0oa8jYhXdPyFjK943fpWvWqy3jMkDpeOsS7UkuzY1qt7tlmJRQ/PO+PfbHhfT9LHtXnvG+rXg16Wc/pTv3Z73MPdei49KnaIbyL+kME9fHZO7YwEmx6gM+eldnJePwNq15S7abVCoXC6oy0qTodUU1S6qmvU/vC1ymqJiW7kT73RYui8agi4ZASyYwGEmnFoxHNmV6vOVMbFAlJjy9eqYFU2pyF2TUpVTFI5vbfyaOtLV5jUgcgYnLt/X6bHH8zgQ4K3lImVO61bfDr1ci9W6150L7JF8PhvrPLL88cHjf3dMiTx3YxVmJI6/qiOITXp37256rJzkbvX/a82v91oyIYpWZADLrujGKtMUZBonW91kzfTb11k7VnnafYppWG3OO77q/YrB2Val2r9V88ybScoUdv8vZDkXo4rNo3v1dTP/vDUSVIDG/uW1Km5bTxbq959W2G2K21xwAYFO0I9SJYU6jnnFA6nijfrUJdObCVnpBCuYQ8XEV/EIxEhLbIDVLnvOEFD0falswgDPYpqEVdiZqCoXT9S0V+lwO5eztPgGvJ2FwG1owkTDSW+cFSwP7T2maLkqwSI2kZrl1nOqX1vb2GLKIRT6t7N6kqHFU0K9wykE6qM9nnK3vyX0paE1mmR3WnBkSLXMh45z6xp7VBawzh5xO7beqyU9M319z756lBzZqvHdXtbTSGAdtmm6d5X1I4XK1+talPvSYqYLe3JbGnVasmTfPmqaq/V7OevFc9LZPVOn93Uwlft36lBqbtLMVqzM8erd6mRTrkj0fPFqdTfA6xhyMhVUdjmlKdUmtHl/o4yog0swbBHqn/0buUXPykX7xG6J5ivoxtM2PDaZ/kyX/P2tHP9T9xv0JMfqONDW8cz3iw/S3l98vzHkypmmqFGhqUXvmyPArqTPN/9vXZaEC4YZJm/eQuMzXNfGoqqc77b1b/0ucUqWtUmKp5rkBPp9I9napesIfqDz5WL2e1Oogs5s+b6P3PnWq/5uLsDPakMkYBLqtiF4kqGa1WzYLdNP2Lv1B08ugbsaTtiIrhZZcqe7y959W3KWLHU0cvnnGvFNQhPXvZZZcV9Cw5bLwywvPl5rYrLR9brjJcoZQBhEboC6KFlIpVjIPYeV85QjSVqimwFe9BIyW5KQKbmsGY4vhIhxSTesgdJENovpxFqBLg3FIsly8Za7UdWDTZT1vrYBTn2lZrXV+HIXa05SGRvlRC3amBwYLrVZGXB4kdYoXY44qbyerrtcaEze3MdEu9hOdRf29Wi/HReS3eN6+h+A6vvU/tmqxJ2bB+p/b3jtKBoXeaLSTUbqrtO9Q6JLFjDBDWn6U9TI64efUadc/YQR6V5Qx7CoUV9/x2OWNdUECejWoTdabgHF0WOspMGjsrnU4x2bTYgGqqY4r5TrT/ea3r1PevP/tV7BAr6QwTgvdh2uLY+PQ5UkOLX2Gw4iVp+Yv+WFROpK1iz4rQhCF8BIRqG5Tp2qj4zAVKvPy0UuTojbZ92HjYZvtVNYpOn6tpF1yliO2jZ58T/ep56gENLHte6V7fCIrUNqhqwe6q2+sQo/IGWJeIVPH850bMjI7BP/6onjuuNxGJUH2zycWn+nrUvXG9ambM1fSzv6iqnffWWMHqWZAKhNyDrKWR7TCvvk0ROx4KNwIeCeQFwbPgMmGumJGUlcptj5ZaHQ8jRkq5anW2O4Btcc4wGNi/Ui1ayIF9Yl8wYIIK41TivFciUmL71dkG9xGEzkLC/hSjVpebH2QRKifCUi6IqnCdUZfLv662CNHWOtgaEwrMlndt0tq+DuOtsxigK5/qDqkrmZBXldayyDMmx27z55BslWqM17xcS0x9PSrvRp3O/zTN1AJN19xsG112KqmS2qh1OkkfM4bBX3Wl1uoVs70mTdLbdJYmaZ7fvuYRiO80Qjj8Kxd2hrvRks80albbjiTXlWpKK1RrpWyl5liNmUxGdXsikTZpBVM3jtQ7ReMmFy91M3eFUeYQuZkYl9HcBkSvtjy/Ay8/qcQT92XHukazhW9peWaSWkihpinSpOlmmIl5a1+P9Mx//Hw74XiMDr6nUorEqxSNVSvT36Pq+buq/5n7FZu50K/7WP2y0U43EY7qWoWbJvvTziJRTfvcz40Uaz7Svd3+THM0Z5qnKUJkIQ+k1TBEMQBza0T4zMSLT6rvkbs18NwjxmBp709Ke75eOx1/uqLTSi9YLRfsE+u5XUtLkZoObad59W2K2IcKszI45pprrjHV88jOFgI3PIt7JXLblZaPhWwIG5MbLqeynNAxIX4easidorCgx8k+QWbkzdmnIApx+TUFGAlB8vflRkp4H96BbX/jvHDdRmuQzGiB4kJSCGh3j9QWyDXj3qSgjgiO9WrQhe9K9pvCuoH2kJ5fsVF9Df3G0727/g9aH1o+2KKGB463vE6r1WO89USW3P0Q+XTN0WztNNjXDmx+nd+9UcepTg36k36hZWb4i8zs9h21h3bPHKhZ4Z3Nq/u9HnWENmYL8xKGzPlut0lv+Kz2nVXXNdlXW416yjT4pkU4ntH0HapVpzq19fQZad1YOKKBvpTRf6tB6j07kwVix1vHGGiMeUqiQx9PqzrblQbp96RCioU8hVa/oOTLT5k+eF+gxpPqm+VBvhSvZafEoYlusHGN9PIzfli9viFbRJcxkrjhWFx1+79RVTvvpbZrvqVw4yQjqzqcRGv17gep5YwLyi76tT3kQ9WIeIkBLX7+Oa3v6NTrD/G1D8YTrHsYI6wNxSpaxrfTvPo2TewWzH3/0Ic+pLPPPltf+9rXCt6glZp6NlpqdUEr+u3EOqIYeGp4lBxnuSkDa1HjJQZViKtkTYEVxSk2dcH1seeB88ICZ+fJE6okklDpQTKjhfzWvEIgBQO58x1DJrfGZPmLPVr6Ype6ZnVIcU8d6U26s+EaJUKJ7Ox1mXnqVLNv0FpTHkdDms2gUyi3hw4yw1tyK+QtKL6rUq061ab/6okcxXhfHGdf73AdEXqXaXaLKp4dJhPWOr2itsw6eWFU4iLq93q145oDNC0za1A4bRART17UU8P0iBa2TNH6zh519A0Yz91LeKoJZ9vEsy3j3ei3UNCORkwERT6pOZxWU5W/NK7tD6szFTbFd7OqU1L7OiU2rPLb3AjHZ2efm6U0Sf989rhpveM1fT0KdWyUt2G1aVsjvF4zf3fVHfAm1bz2YPPSTVdcqMSSZxXdYZ4Jheci3dVmJp+1nPI5Ve/5+lGVIyb8zT1cyEAcS+BIEN0jusZzNZKi5facV98uiB2wcDNVjhsBD76YfG6lctujoVaXrww3krHCw0DoFaLic1n0c19fqYlzViGORQAPMKgwTiXOe7GREhYvvHQIjfOYG7kYzUEyowEjHPPYY4N9wMWcN7zzJd3rtXzDWvVsbNd+s3fWnFmzjTf75ANt2tjWp9ROvSY3/VzV/Xq2/n77aYZ846o2IXVy5sxbCyllyN6fyx7RfO0+qOueD5Tl+tWrF/X0FqRu/z1FO+gUfca8DsOAqW8r9KIW6UalvaRmevOM0dCYnKLXtb5dES9qJs4NgiLualrMQhpo91SVqtL8HetVOz2kroGE2jv6TB83XjhfvlSuT/JmWFt2OayNZDSnNmN+t7I3rB5U7yD2mrRiqT71b1ijeHW18bozPV0aaN+gTKLPvJ5Igqlo5z6pqlUET93zDEGH0xm17H6A6hbs6f89i+TaV9T2+0uUWveKwrWNCtXUmfw77+F1dYe+Uw3HnFFRTzRfjpjvFF7atWoiwTo31pEYas3a3vPq2w2xAzzVj370o7rrrrvM7HdamMYyt11J+djcQqjhKvqtHj4PAIRFtftwlnelUga5CnFBhHEqOeFtpKE2/M3Of2fxGq6nPr/Fj/BfuYNkRis0yOdgwDFpq5jzxb493bFSy3s3GUJNkv9t7dPU2hZFGurU0ZZQoteTV5OR1x/S47W368Xqx9Ub6lBKA5qkHUyunGp4XzbWU5MaTQGcqT1TSvO1qwnCb6Fcl/3O62hke1nPmrC639/uh/h5DyH+/XSYerwudapdrw+9TU/rAaMjH04jixPXwZ3HadcEQ2LiSvdtoYUziBC2GtyYYgJNSLOjjdpz32a9tGqT1nV0+xHzrF6bv1++x57OeINxhmmxtKZWexrISO3JsOJhT83RjFL9vQqlEvIG+hWrq1cqndGa1avUUh1W2HQUeEqnIXZSORGFjaKcp0h1rZoW7qW6qUPnrFOb1qr3P7ep78n7lMHLJw00a0fVHvgWVe992KjcQzaVRaqO+5xnl2dvooayea4xRlj3ctcIl1ffzogdcIi/+MUvTO79S1/6kpkKV0yoFoIoJ7c9WvKxuRX9NmwMIFYeUvYZ4uL3Y3WclVCIy5/wNtK0uVJTF+SW2S5GDMZVoXx+botfuYNkOKflTgYcClYydv/99y964E4yk9Y9G/5ryLA6ElNvMqF0ylMowVxxT1WRWvX2pZWJp43X/VTiPj1cf1tW1jWjJk3RJq03/4aUm1RnVOjIrdOu1q0eLdSeJuROLjx/ceH3hPBpZesUo1YzWxA7+fT9vcP1hBZpINSnuFfjTwwlMJ+pVjQT19s2fFhzovPlUWROC729DF7OV12W2LtDCqH0ukI6YK9p2kgSoLt/8C02rmDmtWTz6XavCb3PrPZz7r3psJqiKaN4F41Xq2HaDPWsfkUDnW1q7+pRrKpaLZNalBroVaqnQ+nkgGmJ609nVFNbr8Zps1Q/Y75iRcwXp6Au09lmpGcjLdPGhGSJ+uAQEMGrRBHxaII1C8Mbx4RIA2uEy6tvh8Ru8fDDDxu1Om6GX/7ylwVJLJcgKhFKr6R8bG5lOS0s3Nh4b7R/UbxVColUMmVQrkJc/oQ3joW8cZD9wTiwFe8YVJB8qceWP2s+yCAZ9oEoAPddsdGM5wf+qwf6HjREeGTd4ZoX2zJ3jpHBgBruIY6rWFAcd8+GF0wFfG04ru6BhOSFNSlcp/6BHvX39SuZiuq56ke0tmapNmm12rTOSMXaoax43L6MLMTeaArnAESfUEI1atQOmpMtndsszIK3zm+e0xNmG0jd2B53fxHyNCezkxZkdtfqxDItjyxWJBJWXDVqSE0xWvG7dB6oPfpfr/r6mAnB544/t6RO1ftAh1S1wLCzYe++F6R4T1STDvIUjuFR++p7uQkDcyVJk2c3RqkfHnpXitqBkOKhtBbUS43TZylWXaN0MqElTzyidE+Hmhvob/dTCijNxWpqVNU8WV29vXrh5WWaPG2Gdp+gUsS28BJDmmeuEj3kow2rsMnazMyQoFHCbRXbFbHbm/j00083NzAtcdzMpYTS8ZArpVZXiRY7cuVUY0NWhKaK7Ukf6TjJC5ejylcJhThLzGyHhza3grtY4KVzntkP3guxBh0kkztrnu+lhuYxmohmFDNI5uXEEn2v9YdqSyM9Ku0Qna4vTj5f06KbhYHsTAAkY0u9f17p2ajn2ldrYAB1tYgiPTHFkjFFYiF1Zdp0b/XN6o0zO93ThtAK9Yt4tz8cpkfthtT5G9KyjWowuXD/dz5BE0Sfptlq0bTB/Dnf8fqX6L/apI3GU8doqRGRE38Joqhuj8wBRpEu0xfW+t41at4wT148o8zkHs3Z+FpN65+vmniN6lsoTNtyOilMjVJa73IpiS7MzJCiDVKmI6SexZ4apkRVu2daNU1hhSOeCaHjoed67EbEJru5hnhItRFPbeTwQ1JTbZV2mTt90DC0BWivP3B/RVJJ0/YWCkeMVx6trinYZjYRQCSRvDoGNMZrJXrIx3r/Ham/GtsdsQMesG9961u65JJL9P3vf9/I0pYSSq+UWl058rEsFoSKIS88SfLTGAwQYDlay5U6ztyZ6EEV4nLz9xyvVYkrBEjXfjYLFkQKqRKVIIqQr75VDPJnzRP+s2p1ww2SyUexg2Ru7Pqbruu8QbOjs02AelVqtT7WcrYOrz10C9U76kVKaRFMZFJ6snWF1vd1KkX4HZ0UhVU9UK1ImlawtBY1/J+6qmkxq1Yq1KflejnbMR4xhWrtIX+Wu+/RhtWi5sFwug9/ytuAfDasy+bfCb37YjZ9g6/FqGhUs9l2jWo121tovPMDQm9Ss6Yqk/a09OnVWtH0nDKz2xWPxDVl/Y6a27GXGmprFI2HTNG5/7FZ4ZqukLpf8iXYI9GQvN6w79mnpakL4krVJ1Q1y1N1bViZVNpMM4XczTTT7EwWNlUfkxrr/XPbn0yqob5BU1vqFcleY+5HCLHYIUmF2szGAyz9zNzg3uXZsgaLVaXkfi+1h3ws4fLqw2O7JHaLO+64Q6eeeqrpdYfgC5FrpUPpQXqw2QdbMAVB4PHbAhKrDEfoupyHcbgc/ngoxNn9oRWtGGIm6oCXTiEQRg45dYtyh9oMNWt+uEEyw6GYQTL/6L5Tv2i7XAmPnm1PNaEaXTD58zqo9gBDKLS2lUoODDv59/qX1MbUMUTQ6PtGoIX8dSasaF9cS3oX65WpTxoixgvvUqvWaI1CXkQNmqSk+rQutMxMXPNb3zyjHOeH0v2YeI0ajKeO9w3BUwG/Usu0QkuycrJ+Nh1UqUpztUB1alaDmkx+vc5r0gGho0zovyZdr45l/VrS8h/Vz5K6kr3qCXXpwOjrNa1vnno7Qkr3k5PO3lMZqX+tNLAhrEgto11DSndA/p5qmyOaNCuugYGUQlNSapgdVsJoo5uhqn4YnlknDFALS9XxmOLxmLm+yVRKUyc1q6G+dvAZfOihhwZHJJeCiSRFzDPO/Uzh5VDRsNwe8rFs3ywWLq8+PLZrYgeQ9IknnmgWXELzWKjjoVZXTOsZ3jmGAH+H4IZqpapEZXn+cUIg5SxC+TPRg+bubP5+KGKGKK107kh5eYiRbbA446XkEn/QWfNWtS63j3akc1VokMyi3gf01Q1fV7/xemWK085q+qBObzw5MKEs796kp1tX+u1c5IwZwR2lchsCDKsz3abnYw8rHUJ9Dh25AbVrvTrVpyqvVl2h1qyme6epZif0To6cHLvtYSe3jtocBI4KHfl12/uO5780K0Zj+9unetP0rtCHtFTPZT8zqQ6vVW8KnWSMg2iyShue7lL6kBcUjkuv9K1Uykvr6LqjVRup00CX1NceNsV/ySQKcBml1kXVtyJm5NhTnUjLhlTTFFHj1KjRgycqwSk44NhJ6kOOtbtHqaSvuGfm2SH1GmbSm69cRi6eczZz+mRVoUFbQOEvSJvZaIwqLQTWkkcffVSve93rRgxlj3X7ZrFw/eojY7sndhvu/exnP2uI/Ve/+pXRmx/LSWyFWs8Ij7OYQLR44uTCCvVSl1tZnq/KxyLEtoIuQpXS0scA47znEjPHiZeOx4yXXiiHOVTFeyUHyRQbmh/Oe/tdx+91Vfs1ioZihhgT3oAWxnbSZ3rO1aa1m4yHVQqhIBv76IZl2tjfZSq++xK92qBV6ol0qErVmpyeoVWRJWYmOuQNSSfUq3avVf1Kqy/UZYrd/EawpPrVnx3VGlO96rMDWWo1V7ubsLpVdMezh96JAPC7R3SfGetileMO9t6i/UKH6J+6yRgL3UYffkD1yUk6pu9MTV21k1rbV6vmrevUmelSe6pDs8PzNTsyX1XhuCKhsJIDGSV7IoolqlUbqVH3+j6tfzqt2tq4amqqFY2FFKaALouutqQmz6jS/kdNymoUpNXW3qn2Ll9kJxr1tQr4m5FaTaZUV1Ot6VNbzO+sgAukXk46bjRHlVZa0Ci3hxyjGQdkPEPzrl+9MByx5+Daa6/VRz7yEdP3/uUvf3nc1eogCztClG0THSjWgKhUZbk9Ttv/Xe7EuUoI49j8PduioBFPPoj6XX7FezmDZGw3Qamh+aEGydzS/Xd9f9OPfDU2Jol5Ge0Y3kknvHCsDn3doSUXAPYkB/TYxlfUk+nVytQKLfGeNspupuANKVUvrqpwtSF1QuCgVx2KZ5q0KrRUPaEOzdIC9atd67TCHr0h9GpVm3z8PO2suGpzxrb618GXgk2bqMMSvaBXtNj8nn70A71D1Rpaq3a1G0OAeAAmQc1Ao058+UKpLaaV8/+j8I6dqovUaa/qPbVvzb7alOjQhkSbMVhioaimV03WlHiTYmF/6Mui/1ultct7FSVykqkyefOq+rAheSRkX3tos3aYv9lA5Zq1dXSro6vHb2eE1G26IB7XtCnNikWjxsCGECsp4DIao0pHAseKp27vt1KeFwxo7lXb617p9s1i4PLqxcERex6wolGrw4tjclwxRV+joVZHWBmvjweQsHtQo8Gq1dHaF6SyPBeVyuFXQhgHoQori0rOnVqAIItifsV7kKE2+V0T7EcpanX5g2TqJ9XrSxu+qif6nzR/nxKeqoPXHaR3TX2nucdKRXeyX/9c97Q60+16Xo+o1+s2OfCIF1FkoEqpaEKRaHZsq/rNpDWIf6/EEXom9oCaQ5O1Sv81MrDkzC2IJmB80No2RTOMBGyuKI1P7p7ZJqp0q7TMVMUDiH6hdtSLesZI1FA0h9gsxsZOHQfqLa+crZ6OXrUc3KbpM+u1ID5PLdHNYWDC40QNehJJLe/0Z7bPa2xWY1WV1i7p06K/bFASnVizOyFD7hD77oc0ao/XN73q3uW5G0gk1Y2ufDJprheeem1ttSmYG67QrBIgfUYUgG2PdpsZtSoY/ER9ghDzcJMCxwour14cJq4KwTiBhZk8JmRB1TGVr4XAa2k7gvh4QLn5y/HaIRsrZYp3Vs7DQxge3We2hZgJpBoU1BQcdNBBhoDoew16nBwTuT0WT/YJki7VW2eRxdMmJErOGy+EMH2pIGzPvpBiePDBB03usVSQd+QcY2Rw75CmsQYU15Mv9ns4QPwYOITjuX9WLlmpS6ZcpM9NOk/vbXy33t7+Vh0WPqSosOlQeDmxWO2ZTYas+aoO1RhShhgzkaRiGX+B53cDXp/x3CdputpiKzUtNEO9htB7TIW7LzrjV8T7tM0Y1potetn9Dnef9P0KeP87BG9nsk/RdCbCm1dTIIjBQPg/7MU0M7RQyoTV1NWsQ5tfr/1q99mC1AFeNe99sXWT2vr71NbfrxdaN5oiwSdubdfAJk+hZMhU/psJbPS2t3pa+SSte68Gz1t1VVxTJjVp5vQp2mHqJFMsZ6vgIUTSUhjHlQ5DE9LnPobQWW+IQI0GMECJLkHIQb1tiHW//fYzzx73OiH6sSrT4pmaiNX5ExFjTuw/+9nPTBiWm5gFlZtjJPzwhz80Cx4LLzfTeeedF2gBL/VB+/3vf68vfvGLOv744/XjH/+44M1ryYpFulSyyh2qwoMNYWJRY1jwb84RFnJQ2IeRIi1EeogwlHNuOE4WBoiQiEAQWBEMrikkjRdR6BxD4HwmCx/7QCif/cHY4P7gvAchZq4ZCzZRCIiVjoNSFys8fc4xkR6uF8YPx8hiBKlzHa2wzXAgvIuBwPW57unrdH3X9fpH5226JXaLorsEX9Se6X9W7eG1ppgNEjVky6QyWtMiafRpDJJeUqlQQpM0TWkl9XzoYTVrmtq01njczEb3h7L4VM2//dY2nkefsDe3vVk6D2dntye0XquNpz5bczRNO5jcO+Ts5+X9UHxVpkYLvdco1SaF+8Oqnzx8KgMSR0kvGmZAS8j8e+3SfrWtSZqefKa50WsfTUeUSSA7k1HryqTWv5IrLl8cIULs3K+jpUXOdokEEI7HaIaAK0mYViiJzpRyvWzuQyKTKB6yn2zXFo+OFmzky2ECEvuf/vQnfeYzn9FXv/pVc/PyoBx99NEmRz0U/vCHP+gLX/iCeT2hyquuuspsA8IdbXDznnvuubr77rv185//3IjaQCwjwYZzSyErwHYhXAgFgmHiFkRlyYLCGsiCnHA5xwNxsX/ky8ktFyKa4WCr2zHQ8JRJHQRZhNgntsExsnBSSDbUAgExkprgHGGcQOS5hUuVIGb2BWIl8kLunlwinnYpIALBwsy5ITVjhYM4X6ZtqgjvHQMR7+1ftfdqdc8qxbvj6q/t1039f1NQtKc71BnaaFHnAVkAAH+3SURBVAiY3DYEb/zdUFiRcETJSMKE3ztDm1SreuOVv6LnVatGzdJOJndOxXqvugZD7T6p+957mzaaIrzYMMsJBE4h3XztqJ21myF1fxvcf5sFbNhyTbpO3WrV8shzStb0j2jMQOhTauqyYXnP/HvTsoQyKc/0uA9el0jET7GEMkol01r5QnfJhEhefbTDzhwrURnub4x8nq1yon9bzAfICj0FSeUMB1JPOCDc0zgk5UQDR4JNaTlM0Bw7XhYL509/+lPzMwscJPjJT37SEHg+IFYWRwa4WFC9jme2aNGisdptUwlLvzuEgSdfTKtRMYNfeCBsLykPHB7ocDdwJdXqclu+MK7KabepVA5/OGEcFgsIH3DeCxWO5beiBQk5VmLkrh0kA2zuvhS1uvPWfUYvdryoxmSTeup69Nq6vfStqd9UEFzX+hc93fOcGjM7GGLvU7chaartba85IEdOuH2ZnqM+XJM0Q4fqOD2vh/Sk/mkGv0DGVSKUv3nf2eYBOswYC77iu62L9712/HK8cYro2tWmDVpn5qRjFrykp8y2/JB8Wo2ZScaDT2WSmtw3Q++fc5oObzxcdeG64TscNm1QdyKhyTW16n4moqdv61SsOmTa23KRTnpKDKRUv1Or3vDOuQUr0blWGIoAY3ssw8DcgzwP3M88o+W0mVlxJiKAo1HwxnnC8EbitRhlxVLh8uoT2GNnwcYCPeqoozZ/eDhsfkbzeihgDfIeG67Hq/v73/9eVDtaJUEV+K233mrI/U1vepOJJJSSd8UQIW+e+yCQj8fK5fe8Dk9vJKuUEC+GEURKNKCcdAREfsABB5j8O6FtWtDKzeFDWuXk8PND2YSjud782x57MdXgeCW8lkWYYys1JRI0TTDUOcaIZX9s+sAOjuFcFfLcX9O+p2l362noUSgh7bhux8Dhzp2ju2uht69maIEma6bxwhdqLz+XnQ2YV6tWNaozBXJhM34Vj9qPWCzQntpNBxkJWAibPvRUVpAGEKbHQPAHxeCFIxcbkt+s578GUsfrb1aLMQDoae9Rx2BPu83F94f6DLGnIymtb1ih33f9r25ou169mc1Fe7lo7etTR3+/Ccuv7+lW9ZyMolUhpQaQl82ZLpfxTL97dV1U83aeZiIy1GqMdF0hQ4gVA3Gsc7vcKxgTGPxEqiDNID4Y6wWkW05evRA4N4T42V+igRgkQaOB+WCfXV59AnvsLNT060JmhBotzj//fP3rX/8ypDAUyG9/7nOfG2wj+tjHPmYmtY0X/vGPf+i0007TCSecYCRpS1WrwxMlTEuBFZ43Vfel3LiVbrErt+UriDpcIVCQwzHi1bJYBJ3wVonBNuTsWajKmRNguwmKHSTDNXn6mafVdGCTNkY2aZZmKvF8wkQBOB+ltLt1JHr1ZOsrak92akNmgyme873ouOq9FtPPvkRPmyp58t8r9XI2F582ufE36xTz+8f1Tz2rBwzx4w/gpSNQ489Mj2o/vcF43n6YH1KPD/rt/Ez/OsTPtvrUp0W6W3UmetBrDAZ+H/X8saxeSEpR7RbyVBWq1o7RXfXamn1VH23Q1MgUvb7mIDWE/XOwvrtbS9o2GQ+Fuerzmlr0/E19Wv/SwOaZrFmEYyG1zInpsJOmKpnxRWIwKO1o3i3OW0eHMSoxgMdblIXoH/vKc1BKFArjkfY8Gw0cC+BwkLrgszEmyun1d/3q2yix33PPPTr55JONrjteGJYnI1c//OEPmz7z8QLE8773vc8YGojaFJO3YnEnvAvsAl9OIU4lW+wozCNsTMgLYyFIy1clZFutXC4GAoYB3oYVAAqaLqjEAJ9K6Ofnn+PhBskMp0Fe6iAZi6dbl2tdX4fqY9ValVitTelW4xGTk67zmpVQn57VgyYUjie9RssHK9zBbjrAePL/1t/Upx5D4uTqq1RvBGW4uvVq1GwtVIumDHrgltitdny3iJxgUDDhLaO7dbuZEwf1o2zHNhZm9tKL4UeVCfm5e1PjZ0L0McVDNZoRnq09M69Tc7hZb2w6SNWZelMd39nfr+7EgOrjVdp5ylR1rU/p8dva1L4uafLtPBnheEh1k6N67ZHN2mGhb4zz/PJMYrxB7nb0Lb/nGrBeWUNsvMG9x/2DQ1DMlECbRuA7kbCx9Hpt5wrrJIZIEElq16++lRA7NyZ9yzfccIPxdi3OPPNMs4DfdNNNr3rPYYcdZsK8l1566eDvIFJEZFgox1NnmcWeQsA//vGPuvLKK3XMMccM+TpOL941HiiEyaJhi+xGU62uVLBfeJUscuxbOV7KUOpwhcD1ZJGF7MjVk9fOFcYpZ7hNJYg5N/ISVD8//xxzjLlqddwXhP5tfUA5g2RAfzqp/2x4ye8Tj0S1JrFGrek2IyqTysRU5dWbcD+jWVfrJW3UKnWpfZCc00qYkjn8aEgcFTnfAKB1zZeGbTK032g05uZpR1N8B/wcvE/q5PMJxQP04NvUqqf1pFLqNNQ/PbFAB4TfqMWhZ7Qk/LRiISrpY4bYCe4PmAhATB8NXahmb5oh/XqU5kN+mHZaXb3mt7SYYkCL3o6UVr3Ypw3LB8wzOGlmXLN2rVXj5NiQQk48n5A4xZzcu3iceOsTKQxso2J8ERUbKQpF6J4v0pnjpfHOuse5xEhnf0tZr11efSsrnqPi8yc/+Yn5mQWNKlCK5IYqnqOdghz8d7/73cHfQaQf+tCHDKlNhEpJ8u0o1X384x/XhRdeuMU+kT9nwSBPRzgYMrBTniqpVkconc8IWuiV33IHmQZRcgsi25obMreRjPzrWglhHPaHBbHcwTbl6ucPdY5txfySpUu0qP8Btc/uUHWkWkfVv0mvqd4z0CAZK0zz8MaXFQ9HFQ1H1Jps04Zkl2o1WSGPLLgNlmdMiP4x3aH1WmGy4WTM+9RmSuGiqjb5dl+tjvdF1WtC+lKz6k1gfsDk4z0zra1ODaY4jv52wu/I0QITZpenp/SEaUPrVbtmt+6tg3uP0z0zf6cV4cXm73FFFA/5MrRE07uzmvOf0/dNxIBivDrVmONi92uoiZgRPPVjQ+9WARADkEKzciJXownqNTDuqP0ZarzyREojWF18wL1ajJFva1EcthJip1UND/3yyy83BE+P+nXXXWdCyuSazzjjDBP+uvjii83rv/a1r+myyy7TFVdcMRiKP+eccwzhs62JAogVtTrIArU6cqBUumMxY61SGJefF6uEtGq+ljPnhyIWCLKc7bEwYGkT7mPhKKfoZqQcPoYPXjqkBvmPlEuv1HCbSgy2qYR+vj3H3CsYfRD948kn9PjMpxSJkKtOqz7SoE9O/rhmx2YFGgM6kPXYASTYlkyqO5VWxKN6PRd+Lft/9aBe1pOG2BGlgdpDWe13CNrvCq/SgKF4WufCqlXc/MzgVbbBLHarN0972w6aZUjZH/KS0EtabCrj52q+UsmUjn7hs7p7p19pRfXzGjBz36XqkE/efs99WD1Kq05NOkdfNtPkTD4d8yLkt+zNaGjUvObyCYy0DSlB7i3WmLFWVatELtu2nvG8kaKbCOBeZY0nfcjzMtJsBpdX30olZWl1I7TOgs8NSXEcpA2OPPJIQ3TXXHPNYOjy29/+tn7729+aBYxQ7HHHHWd+V85gk9EAEQRy/4yCZcHHKIHsR1ocKhlKz80nY6UPZckHmYOOxU3+sVR98qFkW21+me/WECGcWKgjoNLDbfJb0YIQcyXSBCzC5EGJtnCfvLRwiRYlHtDMyAxDhOsz63Vq88l6Q90hgceAPtu2Umv62hQLxbUpkfIJfZgnfpVe0NO6z4x56dBqQ9Tk430ZGjLdNYZsIW4/0I5iXLcSSqheU0zBXYc6BrXmrJfeoEYz3KVVm0xV/DTNNAH9+RsPUKS/Xo/OvElt4U3GmDGT30Neti6fz+IzpON1pvbR61SrqmxlflL94V7tO2lnTa9tLDtkzvWkO4fryP3Jvcn5LNdIHqtcNvcgjoWN5GCYTLT9tnVGPPNDtey6vHrl4LTiKwRI9ayzztLtt99uFuxvfOMbpj+/0MNViZ7pSueTLbD5KNYi8sAiB3kEBYsNpEwY0fZ0sxiVGiqs1HAb6/GWm78PmibITUFwDsi7b9xtkxZF/61J4RYlM0w/79OHmj+ofer2LnmQjEVXsk9PtS7X+n6y4CFFPF8IJm9vDBVTSPegblaXNqpdKwZr2iHsiKqN/2x/B9IaUK82Zavsa4zGXLc6B6Vk/SC/XwgH+ZN330l7mmr76lSddl57uFY0P6vFdY+qK9SVVbXztGNoD+2l/dWtNv1LN6tXSZ2u/6cF2kV1qjLkD7E/Hvq3Dpqyu95Qu7kYNygwjjiPtChCOFwPjFGuDUb3aCnOVQKk9XjmedY5hkMPPXTCzU4v5l51efXKwSUyKgQ8WrxRiJAqf6RzSTsU6uuuRM90LiqtVkc4j/2DSG1xWxCwWBLax+smrE6KIojHbdW58EjwVGyhU5D9IdeOwcKiiIcW5Lxb/XwWV9QUMawKAaOLxY1rzXFwvfhqWdqs6T3T1J3pViqU0kHxA7VLeOeCPe/k2Cky5TvtTRTYWdRHq82IU+OrD3t4PmHHVK1ddYCqTd7cJzJIdAfNNaROH7pP7P4XpgeeN73qhO1T2Vy671H7LXP2Z5/oMR6ohJdi6RrNCi9UrDaqvhD5ej/APiU0Xe/RB7SXDtSBOlLH6EQxs+0JPWDeO2A+pV9Lws/r0dAiPTPwnMoFIWI7PtV6kbmqanjyo6WqVgkQ2mbtwbnAABlteddyYO9VjJDce9X1q1cWzmMfJZDLPeWUU8zijVodofFKqNWVug94IpVQqwtS6W5BOB9v3Q7R4Lhsfpmfg+bwK5UusK1oGEVB8/c2TcA1HKmrgL9bec/8Y8coePypx7Ve67Xnrntqft18c74xOLh2xRQVUZhHBIG6DSIIL3Wu04vtq023uOf5o1mGA14wdeid2qDHdKfW6CWjG8/omMX6rwnJU9U+WdNNdTzFdRA6mXcAYfvV8puNEEidanq/bS2tHTRbLZqsXQYO0EGRo/Tv8D90T/hvZnuJUL9O1NnaW68z78M8WKYX9b+6zNTFvz52qMm1t4fXKxlKaHVqtd5c+0Z9uOUsleNBkpPm/hkq95urqsYzWU7UarRg2/N4zjFEMFS4j4uZTDmeIL3KM4NxG7SY1WFoOGIfReDdkmunSPBHP/qR6ckvJZTOYjNcxXOphV4QAg97OfKxNqfHwjFSpXt+BTjv4cGlsC936pkNf0KEhfpyR1sYJzd/z3kKUk08UlcBf4Mc2NeRChzzBY0oiuM+4qvYGe/k7I34Sm2NOqdXaSCDlxtT2vP94txBLWbflNHjul1P615DsPvocE3XHC3SjWYK2yP6T85kNlrNmtSgZiXVoz61G5+dPSKUzvR1fHLbFoffDqzc7GzNN5K0r08cq13je+v5zGP6e/gPSofQskvpXH1VkzUtOzsupAd1h+7QDTpAR+r1eou8UEZPxx7QCi1RT6ZHn5r0CR1Yc0DJ18qea1QBudZEbwoZyRh/kCWvnQgdOfa+skV0tj2P9BDPFvdYuQb9aAOjnGd/opzPbQWO2McAyNEyRIZiOlr3CrXR5C7uEGi5lneuWh35QtpkygFhS1sEQ557qIUDgwKi5MGFoIZq68slO5vDD1rwQ+4eg4gUBAQfZKGoVLtfbsU714/t2shCsUbM4nUv6R+r7lBHc4emtEzS62tep93Duxc9452F/j8vPKVNdRmTcEsiDOP50QFfisb3pvnvRT2s+/SnbIAd7zqiQ3SM1mm5mei2Rq8MGgOIyfIetOIYEtNrJr75qRBeAZH3Dc6Q899j8+21qtMMzTG/6/Y6lAj1qSE0RZ0eMrYYfCG9M3SadtaexlRAle4qXWzed5rOy46DDZt9ujFytQ6re4POav6AoqFgpEBkgwgKoeFiyM8ayYXaDMcSrBFEFEgb5K4rGMwUZmJI5+eyJxJcXn104Ih9jIBH+d73vtcs8ojsFDNb2w5+wQvFyyvX8q6kWp2tdLdiO3ZR4fgIseGlY5DgMRQqPLKyrRgcQUm53HRBpdv9bJqA3KwRSMkq3xWzLXLsv2q9Rk8MPK5l6ZcNWU6JTtGnmz+lQ2KHFD1I5olNS/RK1yZDqtB1OhQXM1ptSRxXv1WrdZt+qV51D9IwofR9dKjW6hWt06rBgS4+/Kp4n9wRoq1Xv7qUyg6Soc88oip1qHtQlAYgYzNdM42Ura8qn9BqLdXs0E7qV5/5iqZjWpjZSXvEDjTvfV6PKhPr0+TMDL05fXK2Gj8sbtuWqSntU72XIgFJ3YqnQIil3CfFtBmOFbi3iDhQnzGU4WwLVjlWon/lGvSVhutXHz1M3BjNNgbIlIl0VN0ifkH1fCHY4Sd4FeUOfgEYCHw+BXVY8+WMhMRbYd8I7bO4QM7sH9vFAyecXWzLHaTHtvBoKfjLHZhTCvBKrCgH/cjDjQMuBDoT2J9yBtuwaLEdPGfC/BxjsZXVLw8s1erUWvWEugxxV4dq1JZs0x3td5Q0SKYn0+/LsoZ8nznspbIlbxvVow3q0jo9pTvMSFUrVkNYHpW3GtWrXRuzhW+5sIF3Cua4fyKqVZMaNUWNmqQGtaAJp0lqUZ3qjbdNu5tP6gyLgbJRsIuozuN9kzQrMkeTwpPNbPiVoRW6O3mT7tKflYr0qD5cLy86oI3hFeb97E91bVL71+wTmNTtdEOiKaUaf7boElLHcMPrH+kajBa4p0i30B48nMgVxh/PIdEwnstCQ2/GEoUiTg7lwXns4wA8doR2aIe74IILCnqoLOJ42uT5JqpaHV4MBIKXzkISxMu1c9fxhjAKyklBFJMuGK12P1snwXfOr/XeuW7F5Gef7n9Wv2v/o5ZnlmpNZrXxUqHd/Vr308dqP2bSBHYokp33PpTR8Gjbi1reSZibwjWGpITVqw71hFrF+k4I/Wn924yBga6peudz5mtX7aD5+o/+YX7nk372nJi+csrpIPWQmcPerAYzyc3+nc9Cda5XfYbEIXoa4vziu2rjtRsDwqvWpGpf7x28nHjZNyrSVepk8luYNruIFlbtaLZRlW5Qt7r1iakf0YJ4sKEm3GMYj1RlFzN+udjWrXLHHweZr44hjaFeTOQN4xRyZx9zI2zjAZ5F7teJ1me/LcGZTOMA8u200Pz5z3/Wu971ri3ak4YCCwfeBeF4wt94xOVY3jZ8TjqASABtY0G3B3mx/zyo7Gc5rTY88ITuIXUMD4yFoN4QRgFeN7l3Rv8GiXYEaffj87i2RA/sqFkInX/jKRYTkdg5vpMWxOab1i+8dYhvt/ju+ti8jxmDhbY6znNuISLGQ/65mls7NdtHnu08D0HlfTBDNv/taZ52NaRO6RrfkYdFy52/UoG+OU/uI5VVkLdhdwi+xwyFQYOu2gyHwWvnbw1qUL3q1K5NWqcVWq/V2qi1pvqev8dDcXNsaS+tjakNGvD65XkZzajZQVXhKoU8/2+dqU61Z9q11HtB86tnaX5svoICw5FzV6hYrtTWLarSyxl/XAowfHnmeIaLJUfuQ9IOPPvsKxG28YIj9dGH89jHEXjM6N5DBHjx9EMXglWrs4NCyp2xbNuv6CkvRa0OQ4CQPpEECtbwaEElKt0B2yAHyv4QpQha/AMREy6FcNmOneBVKjAMOE+QAseWXziVq0XPuSDtkb/oFhORSHpJ3dF1p57se0qtXqt2jO2oQ+veoN2qdlU0FH1V9X7+IBmKkXKjEzevXaTeAX/4CgTfprUa8KxhgbJcTHfpJjOohZI6W42+h/YzBPyMHjK5beuzIx9LRpywOK+mmA4ve45mZ9/J76OmDQ6s01ozFY7X+sV5vp78DpqnqlCVUpFu9Wa6NOANmL/Vhuo0IzZTkVBUrwwsU7/Xr3imSlOrpurguoP17sb3qDYcrHYCMsRrZbpkOcJNI7VuERonQjRa3qjNqzO+N0jO3MpP2wLRcuWsS4XLq48NHLGPM3jQaIdjgAxqdcybHw+1OgjZho4LLXq8DrKkyAzPJ7ftzVa6E8LG+y6n0r1SKQhb0EcEAA+cxTeoWp1t98slZkv6XJdizt9IRZGQ+l3dd+vFzItq89pNKdpZjR/UKY0nD6m+lztIxobmbUtcd7pXN2/8p1LJsKLpGlPs1u6tMZKx1gcnJH6PblOfuowWPD9DsHuaca21Wq+VWqVlRsfdl5fFY2fkC9Tdb4id0PoOmma8cxBWldLmM6QVWmaK/3gv8EPz1ZqnndUf6vYjCNnfE3Y3s9lDUc2KzzEe/brkOk3un6xDVxyuA/c8sGCL5Uj3LIIo3JPFjrwtFTyPhOYxQkcj3M31hdQ5BxxHOeDZxcixwlpjoVTndODHDo7YJwhYdE488URTWIeefiFyyJUktYtVuYNk2NZI0894DaFgyBbPlwr24RaESlW6V3JgDhESogDlRjs4B3hnEDOFevy71DY7CgXZFztv3kYkrtj0Kz028LgWZxabvDKystMi0/S/03+t6nD1iG11uakQIh0b0q26o/0BNUca1ZnqUk8iLXmE5jODHjih+od1vzq1OTQLvVLsxmsgYTTeW7VOiWzlO++kqr1dXcYICGf/m6c5Ri4WaVnkZnnlaq004XpL7Hw2Y15nhxaY+vpUqE/xcNx0ArANyD3lJdUSmaQpsalam1yrg2sP0TH9bzPGEEZMqTUT3LeknLhXSwlfBwHnHyOZSFjujPdKgOeJ+8bK3pYL0jdsE4OECMBoDr1xefWxhcuxTxBA6FjQhIwPP/xw4xGPBBYniI4HkhBwOXKvdnssmFjvEHd+tS+LACTC3yB+FsiRrPxKVboDvH4WMzxlPKIgErKA1IAdOITnAzEGAZ461fcIgZAWwdiwxFosqMbmmDDg2BeuO2gINw32iuPpkuPOnTOeCxZi0je9Xq8eeOgBc45tCxwEE0kTFI8okUmoLd2qrr42eRka3zT4ZRTfzDhWn1YhejTal+g5vazn9Zwe0VotNZl0KyVLuN7P3HuGiPmPfaWojnC+2edst3yLpgwOkuELo2FyaLppf2MPZkZma3Z0tprDTcp42fs3FFKf16fudLeZF79fzf7GiCKEjlH18MMPFyXda8HzYVUPRzvszPmH0ImkUNtRbj1MrnFr29YqVU3O80urHLU2PKM4CqNRNW8LPF2x3NjBeewTDJDzV77yFTP1jrn1ePGFwCJnNdMrqVZnx5Li6UL0VqGrlLBdJSvdK5WCKDfaYduluFZUGdt8d9BUQa6+QP3cev2m/Xe6P3G/Or1O1YXr9JHGs3Vc/XHmtW3pdj3a+6j6MwOaFpumF/pf0OrkaqUH0pq9ZpbePPtNhgQ575D7op7HtCKxRhv7W6WOuOoa44pEQqYq3jTBhTzdH7rDTF/DmKBq3vfCMVKsd2/HxGwGxXatajf/ttPc5miOKZyjVY7xMEx2m6EFekGPmT55XlivRlWrznj2/erVlGiT6iLMbU9pVXKl+rx+Q/Dk8CdFJ+vwuiP0vqYTB40bjol7gIgQ90Chc25bRTGAxnoMq53xjvHGvgaNECF5TB0OQjNBhxUVwmgOvXF59bGHI/YJiltuuUXvf//7ddJJJ5n59IXItJIEmitugYeEh2C3GdTqzg1flyO2U8kUhE0XFNuGlpsft219vKcSqQKMFYwzDIWFeyzUaq3R+vR609Y1L+aLGXWlu3VN22+0NrnOkGl/ps8U1E2JTlZ/pl+hdEiveWVP7di4ozke9qN9oFMP9jyp59YtUzKdVkN1teI1EUPskDZSri/qWa3VKkPGyewgF/8IcjXftyR2fiLHTkubr1YXMqS9k15jSJsxsdM02xD9f/WoutRmtmI17/xteoqHQ5oR9e8rvP7WdKs6053at2Y/Hdv4Du0S3/VV59PWGNiaieHElogyUQHOdeFrPIAxynWFnCHmUo2L3HGytkB1tGAdBAxXIoHljGq2cHn18YEj9gkMCtBQq+PhYCY92s9jpVbHdvDSKQAixMvCWAm1ukpUuucPzIHEgnoYxUY7MJyoJCb8zuflK47ZbgVC7Hg8xUQ1aOX6Z/e/9GT/06oKxbVjfIGWrl6mWFdMb1n4ZrXXdioWimnnqp0UD8X0WN8T+mvHjZocmWzEWV7qX2y+71Tl97VvSG/UsTVvl170C+nsrPlEKqEb//Oolk/6r6q8alXVRdUb6TQCOITeIdRVWq71WmNK42wrXC6xDwXC6m3qMMYARW+8Y3ftq0mhaZqmHVSlOuOdr9TLWq7/Dobp/feGje47FffVoYhpb0sTB/A87VW9l86e/FFTPFesR5xfAMb5ILUFIKnxDANbPQSM0VJnvJOvxygg4jAWgi65Q2+4z8spNHR59fGDI/YJDiquP/WpT5me96uvvlpHHXVUwfeQ14ZkMAhyC7OKAQSHJ0QlOsVgEJidfsZ2yq2gtZXutB6V035WydnzQw1eGarQDYwkVVuq8M99Pffr7123mbB3Z6ZDSzJL/f7ttFSXqFdLvEXxaFy7VO2s9zedon/1LtJdXXcZedmacI2WDixRxstoQdV8DWT8SvVTm0/WvNi8V0VvHrh5nRY3PaP2KavVX9Wt/li32YcwojWhXi1nqIq6shXzmz12m3GFiO1AF+CH2xNaqzVZeVlq6uPaWwerIdRoBrnw+wZNMpX1K40Ijq9thxHTFK032+a4d6veWa3pjUZlbv+aA02xHOehGHDOuQc457kFYBATX/RuT5TZ5KWGuzEiuZ84hrESv7Hg+WRfqcAPMmnSdme4vPr4YLsldualX3rppaYXG0+NfPZIfeTkUb/0pS/pL3/5i3lAyYfSpvb2t799TPb3N7/5jT7+8Y/r05/+tL7whS8UtN6DtIrxWhYSisyw1nMNApvbxEuCtILMUq90+1kxpFwKbLQjd8wt9weRi2JH35aSKvh162/0wsCLhqiXppbpxfSLmhWZqY2ZTUacZde+XRSORJSpyWjX+M4ml74xvcmQOb3c1eEq1YSqzM/0fR9Qs792rdpFixMvGU9+Zs8MrXpulYne9K+epg0rB5SZ0aHHFtypVDihcDqmTDijFbGX1aE2U+lOl7qdo26L5fwcuh9C5zukTbX8Yr1oFOJAjWq0hw7QZE01BW/NmmT64CF7quo3ao3x6ok8NMZrjEiOKerLdOi4xmP1lsY3m+hEENgWS4wZzjnkToGdlReeSMAYhTD5Tmh+uHB3oXGyY+VUEBHh2WdfSzGcXV59fLFdEvuf/vQnnXHGGfrlL39pqqQh6Ouvv94QzVAPER4hVev87Ytf/KKp0mbxhtx48MYKeCZMiMOouOqqq4oSqCgm/4vXQ5gZYiNUCIkN9TorbsECOtLo0bFuP6vk7HnrnXNceOZ4LsWMqB0uVQCxDCf8c33HX/RQ7yOaEpmsNZm1ei71nBrCDerKdBminI7Xm0EwLqT6WL2mRCcZUZc1qbWGBE9qeq/x5jekN6gmVGNy8De0/0W96X7DyfFwlQ6uOkjxl6JKt9UruW66wtP79NDOtyiUCctLh5WMDOjl6ucMpVMdT94dDXjC4iwMVLfHs/8Rekc6FoKG4DvUoVVaaeRjX6ejzECYztBGtWiqIX62hJGwSRuM+hwkr7A/njWT8f130BRpMsbNsU1Ha6+aPRUUGNwQEUYt9zv36EREoRnv7D+dEjbNNJ6wKSgMZ57RYuamu7z6+GO7JHbInFYj+sXtzQtJod2ON5wPDAC8ezzgcpXeygUe81lnnWXaU37/+98br6QcAoW48NKxxllkignbE71ge6Wq1Y222E5ub3g5s+c5X7QqscCysBarEV+q8M/61Hr9pu0P2pDa4Feohz1i41o28IohRvrYzYQ0T6pL1mp2fKZqq+vUm+k1+flPTT3XVM1bXN/2Zz3T83y2vcwvjiNPvWPVAu22ehctfyiqSLxGzx2S1YBPRY3n/nLNc9lxqz15k9xkyHh/vVGd2mi2O6BudWmTCdnTTFevFjWKSm2mx/mk3aRJg8YBWfUudZhtM4a1W+2Kq2awBQ4DZlZ8pjrTXaoKx3Xm5NPN/gaBzatD8NSGjOQRTwQMN+Od55HnnHVqogxKofgVx4LoDym64fbL5dUnBrY7Ysf7xhO74YYbdMIJJwz+/swzzzSEddNNN73qPYTbsZ55H3+nQvXUU0/V//zP/5QlvBIUXLLLLrvMtMV9+9vf1oc//OGS1eogeSxxQs1BFOKsuAXhOqIW5Uh0VrLSvdzZ8+Q1Cb2zD1xvzlE5Y24LCf90pbv0SnK58cAXxheoK9Ot72/4obozPUZm1fe8Y5qUaVF3otuE4DNVGe1YtVAfaDlji326YsPVWjWwxvSV8/uUlzLEj9HwlqY3qXbJJD13f5fW7P6CNsx72bS6GRGZ8Ar1qtd41xSz+eNW/bD7QTpKu2k/MxAGX93vdvcNOVsIx3b8qW0poxQPufNvfyI7ffIJdWQnxQ1kB8jwDv5K2H5+bK7Zbmu6Ta+p2UNnTD5VQcAwIq4XOWk8zOE84omE3Bnv1AhgVGIMljpOdiyA4UxEhHuLZz5//1xefeKgcs2KWwnwUHmI8tvB+BmPfCggMnH33XfrtNNO09///ncTRiPfDVl+9atf1ViDB+izn/2ssejpcydsR9/7SOSKl87DCIGSf8QgwZtB9COIZ2vFLSAtogfDqdUVezyETsntYyxYqdogRhPvYTEnmoA3VCwp59ck2H5hIghsx/aql1qIZYV/2A4LNtsh3WE9noZIg14T2Rx+bgjXqynSqISX0NToFKPIxiCY97WcoHu67tParrVq6WjW0bPf+qpjCnv+OFXr5ZNnxxDAw3+5f6nes9deitVv0NqNyLdGlQr5veuTvClKhFaZ4LuvKe//N0WztFB7GglZO74V4ucL4yGcHZvq970z6S1uXsPnW1IHeO+96lG1+a/G1OEbcZxQ2BgfvV6fOW7SDEsGlpnf0cZXCjBYMcggR6JOhOHtPUBaJOj9NNrg2aO2B2MU9UkMwaFIcyKAfWLN4TmhBY/nITdF5URoJg4mRpxngoNQPTfwFVdcof3339/0llNIR4h+PHHooYea0CPe6ZFHHmkWh0LkhYcAIbCAEK4sp2K4kFpdqSAqwrQs9pE56OWo1eXOnmca2kiz56n65/PwSPj8XBEQjB8WMxYtDCiIOQjYJtvGI8Ow4hiHAp77e5repZZIi3rSPaoN1eqExuO0Z82e+sS0j+kr87+kd4Terhce/u+r5s1TVV4dqjJkjqfONqJZ8sUG4JovbnpemtWnSakpaurdQfX9U9WcmWo887naxei+x1SlWdpJh+iYwW0v0F6Deu62bY0CP758lblQtuXNM2H3pXrBaMyv1jI9oNv1vB7TM3rUhONj1NCH2A7wowZborTICPc1Xi9GXG6EhnOO5wvp2+s7EYGRh7HHs8g1IpUwHjPei4GdNImhxDm3ExjdfPWJhe2O2HnwuQnJGeWCn4erqLYFWbkWPzc2pDESYYwFiDTcfvvtOv7443XEEUeYtrihwGIBMUGWeOkUAxJGL1futRTSKgYYGxhPbJPFmHMcFIVI2Vbncw74PD53qBoD3k/6gqgCufegY27xzjA28N7Zn+HGfEKSVI/j0U6OTtKc2OZQciwSMyRAVIIIAKFnSwI7VS801fF14Vo1RhrMMJWk54fECd2vS27U8oE1qglXq7a6VjGvStWZGkXCEU3XHL1OR+s4fUDv1Ad1sN5iWtyW6lk9pNu1TM9ojnYz+fGo9dYt/3qQebcpkoPM79ftek6P6XE9YL78me6+dO1S+VExM7TGS5vtUPjHz0xy27V6p0FjpFhgUHKNMDKHOufcAxQxUmWe/9xPFECQRNV4LnlWuSfLeY5GG1bil3uYYUQTMRqyPWO7I3asYhbwu+66a/B3LIz8zI06FHjYCL/nWtEsqBD+ROiRZVFDnY5iuv/3//6fPve5zw0aHDbETG4MTWiOnZCaJVDa4FhEyl3wLGkRToeQC82YL+TBEEolR86izf4H9WCGI2XbvseixN8LifkQnbDnj9wtId4gs+f5DIqP+CLtYO8rcu3XddygSzZ8Xz/e+DOtTq4x4eiliWW6tuMG09JWaN78XrV7ak58lnoz/epMd5uCNBTp5lXN1R61u+rF3qVKeynFQhElEklDyI2xFs0N7am46vwZ6ao1Hemw9it6QS/pSZMfh7Kf07+NOl2/+pTw+inQMYS+Rsu10VuvdjMqZpX5O+/HeyfbjidvK+n5G/KxhPP5e3O42Rwb+XWiDG+oH/oZHKkmgnt3JA11fo8hzv3EOS/nfhoNsP8YmLZWZTxmvAcB+8iaidPj+tUnFra74jnb7kax3OWXX27yW7S7XXfddeaBZ8GkFY6CG8gSUIhD+In3UDkPGVCZDokSkp9IoB4AtToMDma9Q7CEI9n/4fJ2lVKryy9AgwgZhlHOQz/cFLQgsNX8FA5ChBg3LPalbjO3cJB9Clp5bYV/YvGYHp/3pF5MLdZAJqFur9vkm+dH5xsNd2jw81POU2Pk1fPtMdyeef4Z/XfgJaVmZhSKhsy0NAgcw2Cn6gXao3Y3E+L/84Zb1ZrsUDghJQYyaozNUGNsUrYSPmSI3ebS+f6AbtE6LTe/JzduB8X4RXP+NSV37g938fP7/erRC6EnB8VsCNJD6j7RZ9SoFu0Xf/1gHzvbIiw/LTpVb286WrtUv9rrHg5Emsj1cg2KbUfkPaSvMPiomi/nfqoEuL8hcJ7P/BqVsZrxXg5cv/rExHZJ7IBWNytQwwNO8Zmd/EW+mofpmmuuGXw9C8h5551nPF9IH9Icr6r4QqBY6LDDDjNkjZHy85//vOCiUEm5V0ta5OAqqVZXibnsFA9imHGctAoGJWW2hRHF9vC+MYpKQXu6Q7f13qG+dJ8mr27RP6vuUaqKKeb9JnQNmkMtpgWMArvzp35mSIlVCs1uar1VL/UtVSqVViQSVjgc0dTYJL1v8vGqj2xuh/vTur9pY1+r4pmoauMtasj4+0xFuxeS4uKa24Y3T8v0vB7RXapVncm7G213VRl6h7it121J3JC0ItrkrdO68EpjBDR7k7MjXwdMn/sOoXlqjDTp7MlnGI34TelWVYeqNTc+e9gpdkMBj5t0hh1MFGQOAvcTRkGpnROVAsdAdIsoF8Q+HjPey4HrV5+42G6JfVvGOeecYxaD4447ThdddJE+85nP6Pzzzy9ara4Scq+VVqsD5QxbYV9YzDF68NLx3iHlcqr5AeeKXDceox0KUwg8che1XaonBp4y/54ena7qgajavHbjZadDfvMYoesZ0R303qZ3ab+afYbc1nO9L+iW9juNTCvysP39fZSbKxPL6KCG/XRk4xvM66h/+OvKW9VV369JVc2qSk1WLNNgZp/7U978kaoE4yFsyBg5mgd0sy8s4++5qlTjz0w3r/I9btrX2GMTcDf7EVIkEVM6klJXpF0RL6par4m+OKMF3x1p187xHfXFWZ8OfN6JCHEtCVsHjTDRHsd2uJfKjSwFAc8aqRSOYaT7ZjRnvAeF61ef2HDEvg0C0sITZbGA4AnNs3BdeeWVRXm7ECiLTrlyr7mTuPCSK6FWF2TYihXooQ6A91ivJwgpjzTGFQ9sJC15C1rZzln/KSMyQ8i92+vRm6oO1wM9D8rLZIxHXB2pMR76hyZ9QHtWD++R3tJ2u57tfUENEb/VEQ+6v58A/oBa4s362MwPmKgURk31jg16Jr7YhOUbUrMV86oNPedeDcRkHtc9RkoGoo4obgpxrFdOSB4DgEI4v99d2d50NOb9sHu9mhVNxZXyEuqMtSrsRdXobSajXq/HeOcXTf+aWupKb+sidcT1JL9b7ohi7g2eEe4NSHOsamY4Bu5j0mTFHINVfaS2h2c56BTBSsD1q098bHfFc9sD8IwtSZFmYB41ZEN7HK1fhUCqgUI4CJ5Fj379oMgvOoMAgxSd5Ve6c3yEMYkGFFoMqdTnmOi7zw1lEoJlWxgL5VTzQwqE9Tnv7FN+G1o+IOzdYrua/u3WTJt2iEzT+xrfbXTeayO1ZgKbl/C0Y2Shdq8aeVSnCbflrO940DXV1SYk39PTba43pE4E5qC5+6o50qiOVJdPytn3eTn/PaVF6lGn3+eupHrVuYUaHUbH5s/O/T019OHNnnxEikfivpc+qD3vIxVOqibdoA2b/BGxQYwoQtflkjogDI6BQGqGPnK84tFGkGPgOaKdj5og7mnqBMp5LsuB61ef+HAe+3YCSI6agq9//eumKJAagVLU6vBmWATLwViq1dlJaxA/pDbSMJDckax49Ll97KXCesdEJvCshgsT92R6dHfvv4y63KE1h2iH6HQzh/yO7ru1LrVe1d3VmrF0ql6782tN/n64a/VM7391a/udpn+dMD5Um8gMqM8b0KyuaZqxYooxYDgHLMgv972i/2u9Uy3eDE3STDNylWScLZi7W9cb0ieXzvcedaheTSYszysg8MHzZrx4L1tAZzPzGdMS1+S1+GpyoQ1KeklFU1WqClcrEfbFbg7pP1q7p/bV/rtNVTxWXKSE60QHB/cN16mSyK2/ILIEiY6GR1yJY7DPUdAZ7+XA5dW3Djhi385w7733GoGdN77xjfrRj35U0GOwk7MoFCNcXar0bKkSq5WYyw6Z8zsWT7yiYsOrtpq/ECkXAoWIhFn5XAg1aMET/cws4BAzBXpDpQoonvtr69+1bGC5cd/Jd/O7TCat6mREp005WesXrx8cbZuqzuhPm25WKulppnY1RI0yHO/F26ZYrk3rTa6dSW++ylxUNarTgJn8trlQzi+2Q2kutQWxM4O9wWsyhgGGw4zMfK3QUmNw1IRqta93sPZKHKhEStp75ylqqC1u/oIdVISHPVpFq9xPXDvIstzBREPBjkQu9xjKmfEeFC6vvvXAEft2CAjs5JNPNjlmet/xeIslGXL0lZDntPlt2gtzJVbLmcvOd7xtcvoQcxCvy7aglUvKtvKa81ZOISLRDZu+sBr/+Uhmknqq9zk91vOkGe2aSaZVHYpqoGpAr63ZSyc0Hm8MsyWrX1FoYZ1WhjYo4flh3MmaZUg87SUNaUPehOPbtSFL5P4sdgyAzaSuHClZ/6/W5wd1alTci5sK/zmZBXpr8j0m59+RblOqNaPaWJ3q6xuVSnvaZ5cpqquJFXW/EH6m0Gy0B7tgBHEP0IqGR1xupMoCQie1BamXE60aasY79xdGbDkDmUaCy6tvXXA59u0QeMkI8hx77LFGre6vf/1rwfewcJCPJj9YCbU6m9+ulFod5GnDqRT8BS36Y8Elj8k2aacKmnNNhJJ6fO7TunPhPfrTi9cb7ypIAwptToWEhGLhmPav31vzkzPVl+hQY6xGTbVNptCtPdVhjKbwjFq1LwxprdehSIZgeZ1qVKsOrddKvWhkYAm7463byXCE3+lD90ndz5NveUY3j14dlIUNhcy2KKibnZmvI5LHmi2wL9MjMzVj8kxfNrWtQ+GQp+p4YQMRgw2ixaAci2ltVsSKFAg1E1TPlwsMNI4BxcBKkbp9LinA4xzRkkvabDTg8upbF5zHvp3jxhtv1Ac+8AGdfvrpZlJcodAjOULU0iisY5HKH6ZTKtge4Uly00Hz21Z4Bs/KDvMpdy475GOnhQXx/q/v+ouu6/qzIT5Gk777leO0oGa+8aqChneHExKyNQIvtL6o5+cuVrUaVaU6Q7VI086MT1d3IqWkR2g8qXAmq9Ie9r1uVOU2eWv8trdsaJ1Z61S6+zl1f3qbneY2eI6yAjTk4NluJuRPhaMKfreB/XSYhyztqz3IdMZTe2eP0r3rtdeus0ecvsZ1oPgTsiViMdaV4EQKuLe4L7nfg0SquD4YrxRZcgzjMeO9HLi8+tYHR+wOJk/3nve8xyw8v/3tb4sSW8FzJNQ8nmp1ufn/3FY6OwqTf7OQBp3LDmy+Hk+xFFL+VfuvdWvv7WoON6rP69f5jZ+RXsyYSAf7FDS8S3iYY2OxZTuc96eefkrJRFJz91ygO7sfVF+m3xB2DHHYcJUGMgNmohotbL6hUadar8FMg1sbXmFmpJs8uUew3VOb2gxRWxU6vpCjAbnkzt+Rn21Qoxm/6s9z84fC1CSbdHTvyaqK+SNkc0m9dyBl8uozmqTnnn31PPL8exMjEq90tMLMxXjbnHMKMpkeV2o1PgV5GK62+n48ZrwHhcurb51wxO5gABkyivaWW27Rr3/9a1NcVwjjqVZHHpQcPUTHa/Mrg8udyz7cZ1HNX0w4+MXEYl3W9mN1ed3aM767PtvyaTM3rRKFiBzbwy8+qmfS/1VHXZeRZN29cVcl0tLGRLsRq7Hb7cn0mnw6hOtXufuhWkRmatWkNd5SX9M95BN3l9dlgvKWwKF6suhpCuyGAGpyCNjw+lgortpwtRnikkyn9ZaO0xROxxUOhcx0OUid/YLUd53XrJqq6BbzyMln55ImaRC8dVIjY1n5PRRsVIT6De634QZGjWdtgAXnlFw+hi/nNOgIWJdX33rhiN1hC1x11VX61Kc+pc9//vNm5vt4qNURCSC8PpxanS3ks3KiI3nRq1evNvtX7Fz2QlXIELMl5eGwKrlKzyde0PTIdCMcMzs6a4v54uUWIram2nXtur+oM9WlcCZs3h8KR1SnZjO5jZw7QIudgTCbx6L6+W8InuA6/eYMZcl4+PMZVgN1eJ3qU99gvzq/94eyEqL3vXi7rbjiagg1+yH8bP1AU7QB4TujMHdO/UfV2x1SV1/atNSRT5/aUqOWhiqFeVFeOgbPnHsIbxNjCg11Wy8xUUCkimtHpIpOhZGeD/Le9MbbdsyxxFDntFQ4HfitF47YHV4FPAzU6liQUKsbqQc8d/wpC0ml1eoYfkF43s6Qx9uFXIfqXR8OFBQRWaiEbj0SoCzs5FyHakFbn1qvb2662GigN0UadcGk8zU3NidQtftQ4Bz8dcXNWpxZqrporRm5yrYikZjikXojflMT8SMn3ekeMxo1+04TJKfS3dd4JzTfY8gdWicMD3qNJE3nFp9ZZXTiMQasKA0h+KhqVTuo727GyDCbna9wSPOqZuvs5jPM/kJ+xZAE4WoiIxhNREe4toS+J9rwE/YNj5j9wiMeKtXDcZNXpwhzPGoD8s8pz0opNScur751w1XFO7wKLKaMAoUAGVkL0Y8EFi0WjtFQq6PKHVIm7I+KGgsVodlS+nYLzWUvBXjZhFXZH6rUWeRzsTy1Qm2ZdrVEmtWR7tTS5LLA1e5DeWEUz61IrFY8Flcs6pNlTU2tUXiDTJi/zmQ3WuCQrLU5cggcbx1SDw9mwsObtePMqST/Xq161Wf/GlaTmrWPXqc61Q8OeakyNe41Zpa6T/M+vJBndO4p0usfSKgn1GsIgv3GAye6MxIIb5OH5hoTAaJuYqKROiC0zf3EfTXcaFVqAzC4qMsYz2Ow5xSDlPuMfSoE7qmJONzKoXg4j91hWLAgX3LJJfrmN7+p7373u/rgBz9YlFodHkK5RWIWEAKEjtcNCbLNoAVIVmKW6uFydes5N0QUCPWzeNuxoUxtu6j1u1qTWqvJkUn64qTzNS068kjRYsbmEtYlF80xPD9vqTEeasM5nqInpVNRU8VOIRxEDXnz7/VaY3LrNoxOXrxJLSbMTkEdpJ97jmx+HaKe6c1Tk/z0Sp969ZKeNd5+9gPyz7D5v2mQy0Q0LTNZ75r+Ds2vmmMiE5xrCIOv4TxHihVpMeNa2+FB4zV9rRhw/bl2pHqsIQKJcs9C/pXqgS8XGFUUp9rZ9cOdU5dX3zbgiN2hIO655x4jaHPUUUeZ2fWFinEqpVYHebINyJh0ALlpctKljkgdrj2O/D2tQeVUKtvuAI6RtAGE1Zn11OfE5mhSZOQ0xnDV7rmFiHZQCeeA/X2090kt6vqPGSBDoRpAthWHOE6bm8l3e8qEPK3SMvWr15AtgJT5K6NYIfj1Wm2q5G1O3W958wxHN2uKpodmmvdSILday7VRa0zo3ox6HSTybCg+W5RH/zt/q0rFVZup1ilT361ZdTMNuYwUmof88YA5l3RGjPf0tWJhR6sSduf+pOCP/SXqNNFQaMa7y6tvG3DE7lC0ZwK5U6mMWh2LQiGUUyRmc9BEACA6RD0qNY2t0rr1leoOGGruPIYDHiHkZmsXKIq7qfU2E5InNw6PQ+J48H3pAdWpyeS78cZXhpaZwHuumAy0HMp64LZXHaJHIpbfDyhhQu+v8Q7IUn1IqVBSS/WCeQ8T3IgE+HPjNxfTxczYVtrefEODiMVAckDT2ibp+BlvN9cN8sZgs56hvYYQPueQ68JAHUs41qjBmOQ+GKvpa6XCjlblemGAkZaayIYI6TXbV2/VFV1efduBI3aHogHJXnDBBfrVr36lX/7ylzr++OMLvidIkRjEBpkNVaBGKw8EABFAyOX0qFdSt96GOgnDltsdYMfmEsZlEWZ7+cI96MEv7luixX1LtWRghWlpw7NOeP6Qlbii6sp0qCvUpVDI1rUPHvlgGN6vkOdnO3HPH73aqBYdprebPP06b6V61afucLspvqNtD016v8/dNxjw+Kn8t58CsU+JTDateF4qo91fWqiFMxcMGoQ2NI8xxJcVA6KmI1/G16Z3CM1TrDZUp8REACkeakK4FzjO8RytWgi5M945pxiRTl1u24ErnpsA+NnPfma8MTw98nIUuRSDa6+91iwcJ5xwgsYCeFjf+973TJ/7xz72MUPyhYrkSikSs73CGAJU8JK7zvfKIXK8IRZ3CuGGKlwqFpw7FmAMDir6IeZCBV7Dgf1kfwnBPvTEQ3p46SNKZ4Jti9Ykjg8iI5IwVA83JLp77S6KhKOm8r0uXKuGSK0aww2GZBNKqTFer1goqnA6ZBxrWzJn9lcRUyhnydkPpFMcx4Q4Ty2hFu1eu5N2je+uGZHZ8ryUPHM81MdvDsNvJvXIIKlnvEy2rz1m0gWZSEY77buzMXooysQrt+kP7h/IhXOf6z3m33eQD88IleakeYLI844miE7RDkm0gWcYY5E8+3iNVi0Ezj+GMV0sEDxpkYlqhDiUDuexjzP+9Kc/6YwzzjAeMAsCOezrr7/eEI0tyBoKLG7MV+fBxDtEGnYsQeEYanVUBv/mN78pytsdKh+dP6MaYi3Wsw+iVjccKhUJoM3tovWXanX/au2W3EUXzP98SeFjKy4CmZFP5zwTjuac5BN8f2ZAV6z7gwnHV4U3fwZtbv0eanMD6lSHn1/P+MVwKMXgn8+JzdIRDYfoyrb/NaNjLSD/BjWrOdpkvPKdqxbqvY3HqzXZoX+uuVfPRRYrFGbGuk/eGAhGgCYnIkBlPiI5M6M7mNd1Z3p00qQTzM/5UQ2bn+ZeL9QXDjACbL0BwkPjpUaXCwwV+tV5FimiG+/RqqXC1jw4bDtwxD7OgMzxQH/6058Oeq1Ua3/yk5/UF77whSHfA/kdfvjhOuuss3TfffeZYrCxJnZb8IVa3a233qr//d//NfsUJB9tq8LtpLdScud2GpsdBFNODrYSuvX39i7SL9qvVEwxpRNpnb7qRB3ymoPNwk5Ym9B0oZGhuRPvRqrk70p36+p1fzLEincM8N7b07TzhRQLh9SpTUp4iMxETAQBb3pSuEUf3eEDmhqdovZUux7sflxrB1qVyXiqjVbrkdR/1JvpGRz+snf1Xvro5A+a7f9x1Z/1bPIFpSMZ87m5x8O+UlgHpkYnqz5cl5W3zegDU05RU7RxC80DDDyMPY7Xhq25foWuP6TJecIIojVzrBTdhgLHg2fOtYLAc43L8RitWip4Dl1r27YHF4ofR7BAEZqk2nzwgoTD5mcmNQ2Hb3zjG8bD+dCHPqTxBAVNhOVph8N7J0wPOY4EPHH60PGICaWzQEPq5LiDDNmw09jwOMrtUefcsx94jnhbkGmpId/5sXlqjjQpHUprp/odteOshXr4kYf16MpH9f1N39c/um/f4vUvJ5bovt5FWrpyqSEIIg/sg/VcIQK8wP32289EaWy9AiD8DlkmMjY/bqve/X2OhkOqC9doWqRFe1TtrubIJE0KT1Wst0b/Wf64MRCbo806pvmN+sD09+iDO7xHezXsqL5Mr5mbTjEe+fb/DrxojBLwnhnHaa+6PRTK+J45hgTGAn9nnju0NSnSbEidc9ef6deCqnlmP3M1DyA6RIggFkjdeow8E4SvR7qPIH9C3kSJuOYYCuMFrgnGJYZgPmnzM148qSjIHQPUXruJADP1r8wZDw4TE+6qjiOo8mZxzZd75Ge8xqGwaNEiI/tKAdtEAIvXRz7yEd17772G5E866aSCo04hbxZzvuOt075WzpQ46/2Tg8VQooCpnBwshIGxgDcJ2UI2xQKVuQsn/Y8+1fxxHV59sH5e8ws9ucdTWrZ8mTo6O5XKIWEKzH7dfo1+t/F3un3t7cb7xKuDKLsz3Vtsl9AzwjiQHrUKkAmqb6+r30eRUFg96T4lMkmlst45nnaf162El9Dk6BR1pvo0LbqD5lbNVX19g57zXtKdz9xj+uNzr2Vt2FeTM+p0nqeU0kam1ubm4+G43jvlOB3XcrSqvLjSmdRgWL4h3KAdotON4h7vJQTP6/epfc0Wx8I1p5YCcsfQ43gIyXMdIRrIj3M+Ermzr0QwOGcUGpInDlofERTc5xh/pG5GCmXnj1bl2o03bOHiRIsgOFQGjti3IrD4vf/97zekPtFEO/BKbEiS3D950OEAYbKYE+omDcFCPxpqdeV4R0QCSJMEiQTMis3UQTUH6InEE0ao5qXQyzpwn4P0jk3HquGZeq3uWm1e5yU9VXdUK56o0iG7HGIIALL/VdtV+vaG7+i2rttf5aniuROt4fxRY7B77c46uvkITY61+NPWQhHtWrNQc6unqiXarANrD9TUyAzjx+O949HHUayrCauzpudVM+fnx+aafccD7/F6zNjXdze9cwsC4DMObjxQZ049SdPCUxRPxtSUqdekSJNJCeClt2eYtx7WGxsP1dyqzTrpeNeQMB4u1wtSxJih95u/2ZYrDINi1Op4DiBNng2OJV8JcLRg0wEYF8VU6ZMqIsqAAQu50z46nnCkvm3D5djHESwOhLNvuOGGLSrbzzzzTEMkN9100xavh/zwUHLD1dargVDJWxLKHU+wP9/5znd00UUX6dJLLzXHYsEijadGNCJ3lvtoqNXZHnW2V04Odjjd+mLwcN8jur7rBu0W31VnNp1hCti+veIiIzt7UuxE1a6sUU1tjXZ7zW6qjfmiP2uSa/WDTT80xDgvNldfmnrB4Pbw5B/uf0Q9mR4t6FmgZc8uNZKhdBBQ0NaT6VM8FFVVuGqL99zZsUjP97+kmlCV1qc2mqp2Quhz4zP15oFDtPTFJVvMnOc9zw+8YFT05sbnmEK74bA2uV7/aXtEz3e/qHQ4Y4yPeDimefE52rfutUYz3p5HwtZ8kYvOnz+AcYExZkV4rOdejFpdpYaeFAuOxcosB9Gyx5Dl/uTaDTVvYLTh8urbPhyxjzPwCgn7/uQnPxlcoCCPc88991XFcxAVob9cXHjhhcZb+dGPfmQW+Iki4HH33XcbQZtjjjlGl112mSl0gtRZnIeakW4XfoqNOI6ganW520O1Du+dxbMSanUsxhgdtLUFqcZmn76+8Zta1bdK+63eV/tqHxOxyF3Y8ZR/2/47vZR4WW+ue7PeWH/E4N/u61mkGzr/YsRhXlP1Gp1Z8/5hK/kRsbm962491/+C+TmTDqs/s7n3nP8YFnNI/QHaK7NroJnzuWgbaNdjLz3uV4HvvLfmTdqsusb+WYOOiMNwhhahagw8vnOPYPTyPPBV6iCZUoeelAJroBApCPq8VWq0aqlw89W3DzhinwDtbni1l19+uSF42t2uu+46kzfE66AVDpK7+OKLh3z/Bz7wgXGrii8EvCdy7iyCeON//etfTThypMXWqtURYq2EN1NptTq2xaIcJBJg1NWWP6UnVj2pw2YeqvVr1w8aOrlqdX51eXqLUa/gxs7/0z96bldUEU2JTNFXp3152Er+Ozvv0X09D5hpb4T3KXQLZajVrzK97XjV5PH590F1++r11fvrpecWlxU1GSq6we8ojqQnH1IvRo44XzSISA9f+Wp1w4FjgDR5HaQZVAlwKPCs0UvPfVxo6mEhcO14zgnLc85Ham+tBJwO/PYDl2MfZ0B8VJN/5StfMYsQC9Jtt902GEpkgSOXujWChQ+vib5lvDBy64U8KPLMRDHIlQ41Pa1UYCCwPaIaLMiQclDgnRF6JYTKtkrJk7KImznzy9p1wp7Ha+H8hcZbJ5dPbphztEVhUx6pg4NqDtTs6GxTpHZ0/VtfVcn/6LOPadHLD2j1wFotT6wwBW/Mg2fSHPXy1eG4dohPUWOkTl2ZLqNeR+Hbk73P6p+99xuvHyOSY0MJzhYg8r0302fU7UqpcyAHTcgaouVYi/FKrWgQ4XQrGgRs3p20TaGqeQryKDTkO9rzGHeVAJ/LMbF/5ZK6vXakHYiSsF2Ot1BXSTlwefXtB85jdxg1EJb9xCc+oW9961tmYhftefTef/3rXy8Yyh5uelpQWFU7jKSgPepBIwEYNYS62QfIM9+D5Bjx3Mhx0x41UgrCtJYpPdi3DtJeRnd33qeHux9TXwrt95DisZj61KcWhGaMx57QrMhctaY61JNmDnvSbGNqdJKRnGXU6xlTTjQV7bka//N3na9fd/zO5NwphntHwzE6puEtBc+PHWvLMeOpByHCfNEgCtAKDZLJR6UGyfCZGN32eCpdTc6zYoWJhrpHyoXLq29fcMTuMGaAWOl3p4r4mmuuKVutLgisWh2V2Cz05WyPmgdL2DYnnIuuTLf+r/VvWrdqvQ4PvUH77rll4eMWr+3qMl4b28DwKCV3+9e2m/Voz5PGy68OVWsg2a9+RrFGvEERmQNq91aVavRI75PqyfhRkGnRqaa/HAU7wvVnTH6fUZyzxwa5/6v+fr3Y8LLZhm1r++Tkj2nP6t1HPC90SHAseM2E54PWOQxlkNlBMsWSeyUGyRCBoGYDLfvRqmPhuLjXMRohdwyrSsDl1bc/OGJ3GFPgyZ1zzjm64447DLkfdthhJanVDacnXgqsWh0LNCHfcrY3UiTgitVX6o6BuxWLRnVK80k6ruHYgqFeFvbhJGSHwrLEcv1y/dV2QroJ0/dmek0RnhWq4Q8xRRQLV6kl1GykYtvSHSb/Tq6+z0NEZo7e3XKs8cpzj+0rK76ptaF1qgnXGIJAqvaExuP0tjyvnUjCvb33a3HPyxpY26dDo4do791fOzifHCOhnDoHagg4N9YgA7YVzg6SKXRugw6S4T1EH0gxlDPcp9jIAFEGIjhEbwpFcArB5dW3T7gcu8OYAg8O+dmvfvWreve7360f/OAHBcVk8tXqCBWXA6tWB7Hn93GXCsgOb5Q8N+RF+gDCoQBs3fr1isaQ7Iz6rFsAeJ8QOnlq+rqpryh0blCug9QJv0PkhtSVtjNdDExPuFLqyHSo3WtXc6RZTZEG8zq88Fnx6eoOteuyTT/Wla3XmPy8Pbb5DfMUCoeVSCXUn/LFbJjalo/rOv6s37X9Uf/uf1CPtzytO6b+02wb4HmS88agIn8fpG6CugauGUN/7HAVayDw70KCNkEHyeBFE0mxMxlGGxAxxgt1IRSf2qE5QeHy6tsnnMfuMG6AvN773vcaMmMITiEvKldnnIXWzicPitwq7tw+7qCAuCABiAZS3GnvnXRvaJHJZb+97hjj9ZZSfU1UgXNCgdVwHumKxEr9zHjs/ox1YEepDk5g8/x/Z0Ko0oU0PTLdeOuE19/X8k5d1fG/WpVcZUL5VM+TZz930seM0E5rqk0/3vQL01/vZTLauW9HfWLuR1VbU2vC923pdtWFavXZNRcokU6oKlwtL0wdQEYXTj1f8+JzK1o3gdGE545xZwfJ5M54x1ir1CAZzpu9nrkz4scK5Y6rdXn17ReO2B3GFSzQp59+uiHr3//+94bkC4FQNQtuOX3XuWDhhERp8YJEg27P9iZbmVbypOVUT1uhHdvXTaRhKPxx059NvzrNbKjFQT9Quj9nHc25jDJZrXf+iOQsIfjD6g9ROOLpD+1/Ml68mZ3uedqY3qg3179R72n0RZMovludXK2YF1P7y23asH6DGvds1h9TN5jq+qgXMVXzEGp1uMpU20PsX5p6vubnEHul6iaGMvCM/G1WabBSg2SImBB5oV+93PRPUFh9BzsEqFjj0+XVt2+4ULzDuAKP6+abbzb9+Ay/YQRsIUDAhHZZ9Ki2h+jLAblsQp94g2yPQrZSgYdNHpZtUTdABICQcTmzw4eSkB0KxzUfYwjUeuhQuZ2H7lN7Tmjegywy6vf69NqaPY38K7+3U9ogDca8EtIf3I9QTPPj8zSraqb23GNP7bTzTrqm63dqS7WZYTBMcEP5jo2zPWh95/iOwyrW0cpJWN3OZ6fYrhTYQTK00JGPxpji2lnPuxKDZLinMBwqUdNRDjhWKvrZV8SbMEYKSSU7HXgH57E7TBjceeedOuWUU3Tsscfq+9//fsGZ6LlqdRRl4QGWg6BqdYSWqbTPH6tqIwGViCyQWyYsS67ZjnTNBS1vLw8s0b1dD2jpwHIjPIMHv8nbuAXhRxRWLB2TF8romLq3aGb9DF3eeqUxBOrD9WY2O5K172k6QW+s26x6l4vOdJfOX3OhIdOIF1Y4GjGT3d7ccKR5Lzn4t9S/2QyPGQm8385nJyQepArchqtJg1jRIKtWV2xonnPLdcLgoFaC+4D+d64/EYWJgmLH1RbTKeCwbcMRu8OEAh7YiSeeaBav3/3ud8ZbKQRbdU1F+liq1VmpVKscNhQxWbU6CsYIzZejW2/7usFQsryAavi7Ou/VI72Pqzfdqx51G1rHa4e8Ad+jXlRzO2bpxCnv1uN1T+mOnrs0kBlQNBTTPtWv1fubTxlSJAcwoe7zK76kzhBh+KhSoZQh8YtmfE2NkdIU6ziHto+fa23nspe6DYwxwuYIIuHN29B8sWp1No2CQUAPOUYHEYGJNv3MKvNhzGKEcKy5cHl1B+CI3WHCATL8/Oc/b8LyV1xxhfHgi+0pZ0GGQMvV3i7Uo46naAfNFNL6ZjFmIeYLw6OcyIKVkCVPTRRgOKEdQun3d/1HN3fdOlhI50fjKZ/j/2EdFj5YzS80GM+0en6NNmVa1RCu147xhVu0veWC84uhsiS5VPfN/I96vV5FMmEdsHofvXnGG7eIWJQCQt+c7yB9/BZWWIf0jp1pX+ogGVIDNoKQT5oTCRifeO8Yn9SF2GNzVfAOwBG7w4QFmvlnn322mfeO5O5EUauzWuSWhIoNsVcysmCFdmiNG05RbenAMn1nw/dVLX9cK557OIfYL5j+WdUmagY1AqgyH0nxzEqqcl4wZryo1JpuVVOkSYnOgaKq+EcC20dXnhqHYvv480GhIecY49AaZMWq1dnRrxSoUTg3moNkKgGMSltfQGiecz/RIgwO4wNH7A4TGoRoUatD8x1Bm2LGcVZarS5XHIXFE4+VbZNTL3UhrWRkwQrtUNwFKed7ufd0LdLvOn6vmOKKyy8As+H4Pap200emftD8m33hPOMFDpfrhjDRfecz2O+hjJJKjMsdKqxe6jnG8OD9tDIWO0gGz5456dQwcF0x3jheDJRKD5KpJKzxyb05Fn32DlsHHLE7THhAYB/96Ef1z3/+04jbIOtZCCzMeJdW9KXcyma8OarcIS/y7njKQVHJyIKVIaUqn+PM7XX+W8dt+lfXIm3UWkPpfjldTG+sPULvanmnKbArJtdNfQDHbr3xkQylSo3LzZ/PHiQCkF9wCIYLzfNZ5NnJq9vf2Z55tlNJiddKw+XVHfIxMWNMDg45oH+bQjpmz59wwglm9nwxanW0sFVCrQ4iJjQL8IrIlZerVgfRQFiEnvG4gk71siF0ernJD0Oo9tww1W2j1hkJ2YQG1KcedalTO8SnbUHqALIjCgGxQfCEeAmN26l4pA8wQgpFP9gOqQGMDI4LYrTSr6UAQqelEUOKVj+Mu1LBPrMNuhM4BqIO1kCA4K2wDa1ulrxzjw/i59wSOcCwIQoQtHVxtMD+TtRUgcP4wXnsDlsVWOTf9773mZziL37xi4J52FwxkyDqcrbFCHIiJIvnT+U+pFUJtbpcHfxCOe5ShXbu7b9P13T81kjH2hA8nntjuFEnNb1XR9QeNuS+21w32+O48d6DqPzhAROaH64AsRgMNZ+9VAw1s96SOvuIQcS1HWniXyUGyVQaTgfeYTg4YnfY6kAR2mmnnWbUuFCrgxALIUhPOd4qiznGA+/JzctWSq0uv5/byqQGRW57Xddu3fpT/w1mROtmhFSnOlWHq3X2pA/otdV7DVunACkDogtBct35BYjlpB1yw+p40EEKD3MLDlGsg9TxxNkntjmag2RGA65f3WE4uBiOwxb42c9+ZrwzPEdC2XjIw+FXv/qVUVkjbMoXynEjvb5SINf597//Xe9///v15je/2YTpCwFyzlWrK6Qut379ehO+JTwN2eYTSSXU6izYNqRHBICCLUL95ajVEc3As808m9ZUTVFUlrD8ZjfC8l2ZTj3X//yQ2yDCgceOZ8pEM3LmEFohxbNCQ3LYBrUFQdIONqyO58x1gZRLBecExTuuLXMKIHXuJSISpQySIUrDPuSmPcYaGCEuBO8wHJzH7jCIP/3pTzrjjDPMQBZI64c//KGuv/56E8YcytPCa6aQDS1tDIHvfve7+utf/2pIoVwVuGJx++2369RTT9Xxxx+vSy+9tGAo2/aUo1g3lFpd7t8J2xbyMCtVLJavg09dQSmtdEOBCMB/nntIG3bYqP/UPqJOr9MozwGEZhfE5usb07+6xbFw3HxBYFbnPr+FbDjN+rEoaBxpTG6xIF+PAcrx2jaxUtXqih0kMxpw/eoOheCI3WEQkDnFUz/96U/Nzyx0tNF88pOf1Be+8IWCZwrvlYWO92MgjBVoayLvDvHgvRNxCNJTzv7b3DLEVkq7ViVmjueHfCFCCJBwf1DY9rrrJ/1F66rXD+baI4qYwS8XT/+mqsJVgyp65KHRp88/9twWMlIPhMTHM+1gw+p2Pnux3ivng5w6ZM4x5k72K1WtDoPHVtOPJPFaSbi8ukMxcKF4BwNIkQWPcPrgzREOm5/p7y0G5HUhpbHup2Vxv/fee0304NBDD9Vtt91W8D12RjjkSVgVD8xWTmPglLpIV2LmeH7Il2gC26JYL2jIlwgGA0QmRSYploqpUQ2aHJmkhkiDkYxl+AukjSFBHhvDbqhj516gvxsyhlBpiwsSUq9U2sGG1e18djtRbyTwGkvqGCfk2jk3GCu2QBLP28yvL2KQDBGHkQbJjAacspxDMXDE7mCAOAkLW74ADD/jxRWD//mf/zGh6FzjYKxA+PQnP/mJfv7zn5tJcV/72tcKtllZ0qPSmZwrhEpOOWjFs90exEHenVxuuVO98ATxlIkkBGkbs6R87Iy3qT5ap75Uv3pTfcp4GR1ee6hCmZAJKWPgQOqFKtdtrpu++aC57tzpbJChba0rFaQEIHcIFmIdqQXRkjq1EZC6LQTMr73AMLP5a7z3Qnl3toPBgyGGsYOBFPQ6FYLLqzsUC0fsDhXBd77zHV177bUmxz6eKl0nn3yyWaAZBfvOd76zILlitOD1YZBAVpBo0J7yShaLWRD9IIIAgZIXhoCDgOr3s6ecpf1q99GM3unar3UfHR461JAd+4dBU2zOG20ASJkUAecaozAIeD/HBiDmION3ITty3FS5Dzcm10ajbEdEfnV/foSEPn4iC7neeyGyxuCh1sTK0pYTsRkKrl/doRS4HLuDAYsX3toNN9xgRGAszjzzTEN4N91007Bn6nvf+56+9a1vmbGreKwTAXheH/7wh02InmEyBx988BZ/Z8GGdPEY7WQ2W9yFx07IuVy1ukpuD/KlvY/9xeMsRlp3ONhBLhg9RBfIqQetCbBqdSNp1pciI2sLGoNsZ6iWRkvqCBZhABTKxdtBMtwPGGfsR6mDZCg25Tpxzcu5ThYur+5QKpzH7mAA+eC13XXXXVssUvycT4q5uOSSS/TNb37T5LUnCqnbMO0f/vAHU/SH506Y3npyhH0J/+KpE8q1UqFWrY6IQ6HQbjFge8WGigsBMqHXGsJCzQ3yCBoJwPuHBCF1viP+EjSHT6SDY6Tv3UruBiEuCh7LTTvkh9Up0CuF1PMjJGyD77binfumUN6dz8Ag4PMwEILWIuTC5dUdSoXz2B22aHfDQ7/88svNYk27GxPWWJzwPKh0x5u6+OKLzetpb2PqGgSaq98OqQZtiRoNQKrMeMfwoMKf48Gb4muodjKIoZLqcpXenlWrw3sk2lBK6gMip2iNHDf7QuiYqEIpwj2lataXgtzWOiReIeVyZpZzXKQNSo1IDNUFUGiQTD7sIBley7EESVE5HXiHIHDE7rAFaFWjH5zcM3nHH//4x4N50COPPNJ4VkxZA/ybEGo+vvrVr5ritYkE8sBHH3208dQh+SuvvLIguQZRqxur7dmJbEQdMFCKGVDCOeDzmXiXO8SmUu11ECpESIrDfkZQtbpyWus4Hjx1iJdjYjIgXnSQdAPpCiIIVL4TMQGlhOZtCyXnvtRBMq5f3SEoHLE7bBf485//bCIOKNUxJY5oxCmnnFKSRCsLc7m9ypXentXBx8jKncg2VN83HjVEOZTeuhWnQWynnDw3wGvH68ZAwIAJKt5iZWQtqRYTSofUSQmQ/sBIsaNk+X3QCADXCoOIz7e1EnbGuy2yKzTxjutEmyBFfnwVOrcur+5QDhyxO2wXIAJBaJZ6AeoBUM1797vfbWoEChW1FVKrKxWV3p4Np9tccn4kgBw6hXfFeIz5xWNBi+qsAUOOOuhs9qFIlYr84YAnDanb0Lcl20qI60DkGFB48JxjogB2kAyfU4xueymDZJwOvEM5cMTusF2CFAJqdSzYqNWR9w6iVlcOKrk9O5ENkoc0KCSzuWby+xSmFZqEl6vOxn5BXGwriJdbSbndoUh1OFLHeyaFNBTJ5ofVg2it53cBcIy20I/PrsQgGZdXdygXjtgdtltQqHXeeeeZokEG2hxzzDFFS7SWM4p0tLaX2zaGaAotfxgPtLOVSs6VbK+rlNyuJVWMsNxwNqROkRrbxVMfafulRACGA+eVCAnFcGwDIi41NE+0hvOLgZFbi+Dy6g6VgCN2h+0eVPV/9KMf1Sc+8Ql96UtfKkg8kB4FYhBNOaNIR2t7FGoR8oUkKHwM6nHnerl42xgLQSeKVcqAySdVrhWeOvuFB1yM0VBMBKDULgDqCcodJEP4na9yOiYcHIAjdgcHyZDXe97zHpPvvvrqq4uaGkbensW91EEkw4FecPajnO0R6oX4IB4rixq0aCzXy2WbQdrrRsOAsaQKMVIfYZXjSo0EDBcBCNIFUO4gGWoSjjjiiLLTOw4OwBG7g0MW5KfPPvts3X///frtb3872OY3EiaSWh0kQUia90LmkEslJrIFba8rZBDRS09bXBADBvJEQAajg23QFRDE0+WaQ6w2AhBkToBtY8Rr5zxDznZ2vc2XFwrNcxxjPTzJYduFI3YHh7xFlt79L37xi/r617+uc845pyBhsIjTykRFOR6tnWMeFEFGm0IMhKTt5LJcIqlE0Vip7XWjOZud80MImwgAnjZGQjmtdZUQ18lvYyRCUmxo3lbVOzhUCo7YHRyGwAMPPGCEbJAo/dnPflawXWs81erwOiF1PHKIe6jX5RaNlRNOt58HKZMnJzccdBpeEAOG99gRq1T6Q+SVaK2rhLiObWPkiy4A0joQ+0ihedev7jAacMTu4DAM8HRPPfVUs+D//ve/N55wqWHZ0VarI0oA0eFBFwpH5xaNlRtOJ5ePl0tvtm2vCwIr3sJ+4X2PdAyQJMfKZ1Ppn+udV6q1LldcJ+j1y29jHGmQjOtXdxgNOGJ3cBgBkCESuT/60Y9MiP6kk06aMGp1EDS/L1XkptyisaHa64gUkDMPui0MBEibGQNDiexYUudcQOrDEW4lWusqcf3ytQBoq7MtcTb0TqTDFcs5jAYcsTs4FIG///3vOv30042oDbPnS1GrK8eDHC7MC/ByIcEg1eWVCqcDqtOJKhBKR60uqISsFW+hpS03CgCps32KA0ci9Uq21uVGAIKqA+ZqAWD00C5o0w/f+MY39Je//KWs8+7gMBwcsTs4FAlI+r3vfa/xSqmazx2kMtriLLk96hAyxEOLV5Ae7EqH0/OnsrGtoNP98jXrKfiz+XPGChcbGq9Ua10l1AFpYzzqqKNMvcYFF1ygt7/97WZOAdMRHRxGA47YHRxKAN7gpz/9aV1//fW66qqr9Na3vnXMxFkgPYrpGOhiIwaEistVq7Na8niU9NAHDadzfBAy28NzH2rYTLGgdsCOpiUCwMjdIPluSBXjBY87aGudvX5420HPN10JpHG4dm9729t0ww03lK174OAwHByxOzgEAB47rXD/7//9P+OFFaNWZ0mZ0HcxAjj574ccKKYjHE1VeyXV6gin45nadrmg4fSgU9nyYcPveMwcK9GJoCI7dn49x1Rqa13u/pRzvjEO3vnOd5pUClENijGLMQodHILAEbuDQ0BAhKjVUYSG915MWDyIWp1t8YIQaPHKJSarVleO2EtuOB1C5ns54XRA6Jx9xvu3xWOlRBFsrp3jpSuhXJGdIK11I0UASpHY5bM/+MEPGlJnZDC59XPPPVef+9zn9OUvf9kV0DlUHI7YHRzKAPnps846y6igMSXuwAMPLPgeCAsPshh1Ocjc6r4TBh4qHF2O2Es+7ES4SoTTITSiFJBhsZrsfD6GCueV8LstLquEyI5trWOfENcJqlaXGwHg+o2kCcBnfuELXzDFlygaWsOE91Ov8eY3v1m/+MUvSt4HB4eR4JI8DhMSiMKw8LJoIu360EMPjfh6ct4UN1lpUBbSsQD9znw2U+IoivrlL39pFvORgCd80EEHGQJ+8MEHTRh8uPDtI488Yl6H5zpcjpkQNecIr5jtkZ8OCogOz59zSEscXi5h6CAgPYFxABFDZBgMI52bXFKnUC63YpzQN8dInznnhHMT5NiIbGAwQPAYTBQQlgrON9ePXDvnmyjAcMdDi+S1116rW2+9dYtoAwYYx4HX7uBQaTiP3WHCgTGqZ5xxhiFJFvMf/vCHhjxp7xoqt4lK3OGHH66LL75Y73jHO8y0NiqOUWPDUxwr4JGhVveGN7xBP/3pTwuGskdSl8OrZ//xciHHYjzLUsReRjucXmgqW36bF/tuZV0h3uGiDpWYzDbc/PpKS+xyH3/qU5/S7bffbiriHRzGCo7YHSYcIHNC2pAjwGMkJ/3JT37ShDXzQbUx4dGbb7558HcspBRcYRyMJQg7o1ZHkRUFUrbnvBS1OoRRGOaCdwnhl0rOhdTqRjucXqomO6RutfYh9WLkbishslMpgR2rCcB5ImqDZ04uHSMPcsfYdHAYS7hQvMOEAjnlRx991PT9WpBP5ed///vfQ76H3+e+Hhx99NHDvn40MX36dOOhvetd79KRRx5pIg2FgLeIMQOJEn0gRAtZERIPQjRsD8MG4iL3T2g7KPLD6bTFFUo1DAebk8a75RpDqhhtEHQppA4oXsP4oxgRI4j7plRwbtkXugxo06Ngj2tQKjCguH6E2znvV155pTHuUCs89thjS96eg0O5cMTuMKGAAAuLKwSZC35mER8K/L6U1482IMOLLrrIpATIvX/2s58tSDyEpikMI0QMcZbTbgbsjHL6tx9++GET8g9KyJZIySvjuZMiCEKklkwR9iGHjhANhgzXvBRSzydUzje5biIBQcA0PgiZbgAMIaI/Qc433vkJJ5xgwu+HHnqoKaosJxXi4BAUjtgdHEYJhGDxTCn8o2cZch0OVKETjoaM+SKsS9g6iAdpAamQ92V7eNrlbo+aAYgUEiuHSG1UgV5+yBQEKWIDtjedkDznmvMYxIAhp4/nzj5B7kGMQqIO99xzj+lXJ4pw2mmnmTC9g8NYwxG7w4QCOVw8MDzDXPDzcD3M/L6U148lIFaK6mhVO+SQQ3TnnXdu8XdICNIlFIwXy/HzhQdJwRneNkVs5YApbmyP3D1GRhCPdKRweqlEahX0qCY/+OCDTTSA4yRvHtSAgdhtFMAOXykVpHzoTef4MLJIERTbEcA5ZY4ANRJ//vOfDbFT4EeUgyI9B4exhCN2hwkFQtIs0Hfdddfg71hc+RkSGAr8Pvf14I477hj29WMNQsy/+tWv9P3vf9/kXqne55hs0RhqdISicyuzeQ+/o8AM7xg1t3L3gfOKMAvknm8IBQ2nQ+zk3oslUo4ZBTc+n/fTMkaBIF53uVEKzhUGDN4/XjeGURDgtbMdIhLFGFZ83gc+8AFj9JB+4buttaBX/cMf/nBZaRAHh1LhquIdJhzIVZ555pm6/PLLjcdDu9t1111nPCgWTFrhyB1DkIA87RFHHGGmrlGsRN8wOe6xbncrBpAganUQI5EJKvoptBspvxxErW609dMtyLXjIdNXDjmPNOLURiesIZOvuQ6Bsi2MHiIcQdvrKjWbvZiOAPYVWWGMr/vuu2/IGfecm1LrBxwcyoEjdocJCVrdLr30UkNq5IgR+iC/C6g2JxR8zTXXDL6e6vMLL7zQhGIJp15yySWm9Wgigjww+Vyq1TFCjjnmmIqq1VVaPa0UtbrhiNS+hr5vSH043fdyNfVzQVEele7lTtZjX4isYIzlth9yTBiXv/71r7Vo0SKTdnFwmAhwxO7gMMagqAq1OSqnv/3tb5svwrWFKqgJd9t+b7xjqrnLQaX004shUkid4sGRSH00ohREATBgIOFyogBWYOdf//qXiSZhvGBYfulLXzIFcxifDg4TBY7YHRzGGOTLyQdTXU74lnA8qQSiEoVID4JiIAp5asLoeJHltFSNhlpdPpFaUienXspgGauBX26UolJRAHLpFMiR4vnIRz5i+tT/7//+z+i9OzhMJDhid3AYZ+CdnnLKKSaXi1od3m4panWoy5Xb905aABKFeCG/ctTqcomUvDQRATz1INPiiCrguVciSlGJKADHhgIi3jqRF8b3ul51h4kGVxXv4DDOoC2PKv7jjjvOeO60S5WiVkcFeLn90hgIVs+8XLU6CJNcO4VkkCkecn6hXLEgnI+hQTQBT5kaiqAV5pxnijGJmLAt20NfCoiU/O1vfzMFc/fee68phMTIcnCYSHAeu4PDBAKhXXK4tMWRe88fljJaFeC524M82SaRAyrng3ikbIMv5GgJxVei6K9SGvhBaxUwUt70pjcZMv/e975nIhGnn366Ob4bbrjBpB4cHCYCHLE7OEwwQBT0P0OChHoh17GqALeA9Gg9w+uGnEvZHkaGFdwhEmCHv1AwWG44nTw3x0n+HSIdqb0u6GS9oUAEg+4FzsXvfve7wfNBaB4DDO+dqIuDw0SAI3YHhwkIitDOPfdc48HTToWnOFYV4Ln911bFDUIuppqdljcME0vqQxX9FUOkxUQVli5dOhhVGM0oACF7vHT29+9///uQUQfOUbl1Dg4OlYIjdgeHCQxInWKtz33uc+arUMFXJfvA7fYgY+RekUvNH7YzFKnToz/cfPP8EbXlFOkRCsfw4BhJQwSNUuRGATBgcg0SahhoRUQciVa3oHPbHRzGEo7YHRwmOJ544gkTmqe9jZGgxfSbDyeqUq5aHTl8BIDyDQy8cVTlRiL1XLU6iBTt+nLC6UGjCiNFATgGjpUaB84Zokc33nij0fsvt37BwWGs4IjdwWErALrl6JEzXISWOAi0WLU6Qsd476OlVkeuGq9+3333Nf35xaCSRX+lRBUKgfPLVL43vOENpkvgBz/4gVGVI7fu4LC1wLW7OThsBYAw//rXv+rjH/+4jj76aF111VUF277oG6e9i3A3LWzljFkFeMNsj9w926PADnEbQv8orxVL6gBvmEgCHjvvZwJa0OEvRA/ItUPqRBXYXrFT2fKBcYJoEFGAr3zlK0bauFKk/rOf/cwIAGEQ0arIMJ6RwIwEjovzTe/9eeedZyIUDg6F4Dx2B4etDOR6UatD8Qz1s0I94qOlVkfeGRA9KEeOFrIiEgAZE04P2vNeKQ18Ktzf/e53661vfav++c9/GiOKVEi5g40YXvTLX/7SkDqkzXwDFP/oZMgHU+LOOussXX311WbcL8YKEZuTTz5Zl112WVn74rDtw3nsDg5bGRCxIWRMCJyBOBD2aI1ZHW57eMl8JxrANilAC4rcEbVEAphjXm5UAePARhVKAZ46KoCM2CVCgsLc2Wefrc985jNlHSNkTBHeBz/4QRNZgODZR4h7KDCxkHQAuX68fIwM9quQl+/gAByxOzhshZgxY4aZQf+2t71Nhx9+uCnwKnZeOaRejlodhXl464Tf8SYBY0sroVZH2JvCOoyVoOF0quNpXSM6QeEhbXHFqNVR1Y+nThfCxz72MWO4MFL3kUce0d13360vf/nLgfaHYsFHH31URx111BbHy8///ve/h3wP55X3WCKnHoFWu4k6sdBhYsGF4h0ctnJA6oRp3//+9+tb3/pWwRaycgrXrN46uXE7e7xSanX5w184DkLz5RT9YWwQocCTH0kDH8/+LW95i/GSr7jiildV/aMRQD97KXUEFhT1cU7wwg8++ODB359//vkmrYKRNRQYCkSLI+cXYwxj4xe/+EXJn++w/cF57A4OWzlOOOEE41WSG8aDh0iKKVyDNMndQtTFFK7ZljfeZ0ndbo9Z5BSe0cdeTiEcgITJQxOiJxJQajg9F/Sksy32kW0NpesOaVOzwDmBOIfSCqCALQipBwWjYC+66CL9/Oc/N7r2f/nLX3TLLbfom9/85pjtg8PWC+exOzhsI4CgqJonZEtumFx8pdTqIHVC5JD6SKI3leorz5d9LXekLNsiQoHhYXv7IXD2E7138vp33nlnoAl0xYTiyaejJ48RZsFMADoVbrrpple957DDDjNpk0svvXTwd0jZMi6WNsag8+kdtg+4u8PBoUTgQTKyE28QL+5DH/qQWWxHej15W9u6BLEwHazSU8HYNkp1eHpUcUMKhfLUvOfAAw80x4FHy+SzfEB6xZA6wMumSA+PnvwwBkFQQOK0eVFYB8ETng9awMa2MAyo4KcQjrnqkCqhbuoFmNg2GqQOGIDDOaEmwoLrws+5oflcIN6TT95WWS/odDuH7QeO2B0cSgSkTriZoR8333yzCYHjSQ0HQuN8MREMgsSbvu2224xBMBpgu/Ri/+///q9OPPFEM3ylmMI1vvC2UV+z5AHR8ztax4qVp2V7u+yyiylgI3RPS1fQQjiAkh3eK/tU7khZBtDQT06tAPtHiPvWW28tW3q3UK86xsSvfvUrc01QBDznnHNMLQHFep/4xCeMgQVxc96IuDDCl7TAtddea4r/uNco3uP35Q74cdj24ULxDg4lgEWZdqWHH37YeJIAkqZaGa+y2EI0epgJAbO4j9bwEAidcC/ETBiXHHghEHnAM4aYOBaImaKzoGputq8cMsLjD9JXbgGxQ3K5w1+ChuZpM/vsZz9riun4NwZQuSjUq47YDVEUjAo6CmipQ3SGv2H4kR4gskP0BKODqXFM90MzAMMDUud3Y5nrd9g64YjdwSEAIeR6weRpISwWcdqjigGa7xdccMGQoe9KAk/5u9/9rqmWv+SSS0z1fCEy5HjokydUDdmQ3y4HFNIR7uZY8fxzC+/GY/gLhhgdBPSpUxOA8QMhQ7qEzYMCMietAYHbc08qAbL+whe+8KrXYwDwmZybcobhODjkw4XiHRxKAN5WvlIYHjfKa/ytGDA7nermkcL3lQJhcQwIUgbf+MY3TMsU+duRQO6fHnd65fGOKTorJ69r+8oZHkM0oNi+8uGAYUBonmgAoW6+Fwu6BzBuIFVEX975zneafnFSF+gBBK0JCNKrzkhecuyE4omIEBmhPqKcjgIHB3PvudPg4CDjUeHJjvRlJVTLAfnhY4891oTzv/a1r43ZqX/jG99ovHD6zZntTh59OG8Y8kUoBqKplFodIHRO+oLQMsIxlVCrw6AqtkiPY6ao8Etf+pJJg1gQkaDHnFB30LGsGGsQcn7Kgp+HM/jo+6dSnveRVyeHTnie6IqDQzlwxO7gIJnwOvnzkb4ggB122OFVkqcQHpXv/G0k4AUfc8wxZkwpYeCxDr+SM0dBDSEW2qnwGHPBMVhSx1sfSq1upOr/SvWVBx3+MlKRHsRPqxla6wjD5KcjMBQg/HJqAEoF+0r0B0EcDCh66dkHogkODuVgdKp2HBy2MpCvLaYymtApuWfCrizGALJkkYawRvLUmcqGihqEOpYEkguMCbxCFNbQLYdcv/71rxtSp9KfnLUldQvyzrSJ4WHiHecSf9B9oGee6AGh8XIL4fCKaVUjqsB1yR/+gkH1nve8x3j4jGEtdzb9UJgyZYpJOeRHDvh5OIOPc8i5yK0R4Nzi4RPaLyff77B9w3nsDg4lgIUXr5uBHpDc/fffr3PPPdd4grYinlAzBGlbnSB18rnkgpkUxs8s3nyNVz6VNisq+zFKMFbwyiHX4ar6c9Xq8IyJYJTTwjYaanV2pCzta6i0AQiSQjmiJL/5zW9GrVUsSK86xhXpgdzziBgPhO9I3aEcOGJ3cCgRv//97w1xMzaVNrdDDz3UhFMtyB1DfrZIDUlQwthUcjOYhIXbfjFOdbxAzzQeLOTCvhaTp8YzJTKBcYJhgHJdOSBHjlHBdkothBuuSI90AWRO0SCFaQytQU+/UlGSUnvViYwAivMwaKz6HH8nUvKpT33KEDrGCMVz7LODQzlw7W4ODtspqEwn147gDvlqiIkiQr4XClfjZWK8EHWgyK5cgRe2h4GBFgDkHLRv3oIqd8LvRAEgXsLzlUCpveoMcuF1pB1IOVCzgAdvp/FRMU8vO8WEREwQF/qf//kfJ0LjUBYcsTs4bMdgYpmdnkZ+mqpxiJUIRDFCKHjDeKdWf73c/DWFiYTlSQnQHhdEEx2Dhf2ndoBQP6RK9bmtiSgHpfaqA4wLvPWzzjrLGBzUaBQzZtfBIShcKN7BYTtG7khUiA9yB6QXqJAvBNIJ5LYJ45NyIKddDvB6IU9C1BTWISBTKhiqQusYRYrkuOndh1gh+3L654P0qgP0Aziu0ZIQdnDIhyN2BweHLXLeECIkRFsc+eJCoCIdMqbCmyp7PNJywCQ0jAUK4tgevfXFYtGiRUb4h/2GzCFeQtvkr7/yla+Y/HhQBOlVZ38omCT37uAwVnDtbg4ODlsAMqSfmqK2U045xZDrZZddNuxIV7OQRKMmj00xIF4tYXRC1EFD87YQjg4DIgcUq1FFP9L26GWnF/w73/mOqfrPxZFHHmkEekY6hkqDNjuK+CB1ig4dHMYKLsfu4OAwLCBWBqRQ3c0gmWJ04/HY6SknR494TLlDbiBIyB0PnkK9oYR92E8U9SBSBqWMRq96qXPVKYgjx5/bYmdb2zCeKLijLsHBodJwoXgHB4dhQaX2PffcYyRpybujOV8IVq2Otr9KqNXRgz6SWh0DeRi+Q/shcqyjQepBetXtGFwI3n6hTc+55N9ENBwcRgPOY3dwcCgKtHWdffbZJv+Ozn0hT5xCNcRnli9fXrZand0euvXkranGRwYYLxrvGU+a2oDRFnah3Q0P/fLLLzd1ALS7XXfddWaOALl2WuEwhi6++OIh388AGlcV7zDacMTu4OBQNAgf0x9Okd0111xTUB/fFp0988wzhvjo5Q7SwpYLPGTIlbYziJzCNRT08OwrBYrsbD868rc/+clPDJGD/F51UgAYGxwjaQMq4Glns6/PhSN2h7GAI3YHB4eSQL6dFrI777zTVJ8Toi8ElOXIuwNkacstYmP0KwVxhOUh9WL2oVIiNPlA4Ad52EMOOcSo0X33u981Q37ox8d7d3AYazhid3BwCBQWh/g+97nPmQp6ZFGLVauj550iuKCV4nw2ZPujH/3IhOGvvfZaXXnllabIrxIIIkKTC1riWlpazPsxEBwcxhqueM7BwaFkQOJonVNYh/ALbXGFRrASgifXTjge7x0J2SCCMX/84x+NV0whH5/929/+1vSuY1yUK5ATVIQmF+juUzhIusLBYTzgiN3BwSEw8GwhQua1oztvw+2jpVZHfh0Cx0u3Oezjjz/e7MO9995blEddaRGafCCIgyRurnHg4DCWcMTu4OBQFiZPnmy8Z8LOkBkedLFqdVTWF6tWh8DM6aefbkLcTNXLBf3gDzzwgEkLjCcQx8HoIMdeqWlyDg6lwhG7g4ND2SBcjWQrhHbhhRea0aOFdN4hdQrpUJXD46YtbrjQ/JIlS4ya3Pnnn28qy4cCBXkYGeWAvD+CMvkjbPm5UAfA9773PUPst99+uzkuB4fxgiN2BweHigF9ecLr9HUjGEP1eqFcPZPhEH5hChuCLoT1c7FhwwZTJEebHTPWR0uAJogIjcUll1yib37zm7rtttt0wAEHjNr+OTgUA0fsDg4OFQUV5P/6179Mzp02tL///e8lqdUhXctkN9taxyhZPGBmm5fbA18MmEePvjutfIykpUiQ/fjgBz9o/k7KAQPDgkI+psldffXVJvpALp6vchX3HBwCw3NwcNhqsWnTJu/UU0/1GhoavKamJu+ss87yurq6inpvJpPxjjnmGGLf3l//+tdR2b9rr73W7NtnP/tZr6Ojw+vp6Rnxq7u72/v85z/v1dTUeJdeeqnZv0MPPdTr7e2t+L799Kc/9ebNm+dVVVV5Bx10kPef//xn8G8/+clPvLlz53rxeNz87cEHH/Suu+46b9ddd/VCoZDX3Nzs3XLLLea1bINzmP/11a9+teL77OBQDByxOzhsxYD49t57b0M89913n7fTTjt5p5xySlHvveyyy7y3ve1to0rs4LnnnvN2331374gjjvCWLFlSkNz5uuqqq7xYLGYIdNWqVaNicEDaV199tffss896H/7wh81nrVu3bsjX33///V4kEvEuueQSczwXXnih2b+nn3664vvm4FAuHLE7OGylgGAg5Ycffnjwd7feeqvxKAuR4eOPP+7NmjXLW7NmzagTOyCKgMExY8YM74477ijotX/hC1/wpk+f7u21117egQce6C1btqyi+4MX/olPfGLw53Q67c2cOdO7+OKLh3z9iSee6B177LFb/O51r3ud99GPfrSi++XgUAm4HLuDw1YKBFPITecWa9FuRh6aqWojCaiceuqpRg+9GK33SoD2tt///vf64he/aPrOyZcPVQHP76666iqjakd1+UMPPWSK2fbbbz9TmFYJBBGh4ff5felHH3100aI1Dg5jCUfsDg5bKSjQytcup4UMxbORxFTOO+88o2sOwY4lqGY/99xzjbb7z3/+c9OT3tnZucVrbrnlFkP+tM1RMEcv+C9+8QsjIUsRHYNnykUQERp+X45ojYPDWMIRu4PDBAPqaZDgSF+0kwUBo00hVohyvIAwDS1xRA6onGcqGkCo5qyzzjIeOwNecvH+97/feMe00zk4OIyMkQcqOzg4jDmYMz6cCIvFwoULTRh9/fr1W/yeHvDW1tZhQ+yQOjPSCeHngh5xSBbt97EAQjC0wdH7zdhThGcY6vKtb31r2GEue+21V8U+u1QRGn4fRLTGwWE84Ka7OThspaDHeo899jA93+ShAXnpY445RitXrjR65fkgdEwoOp8wIdXjjjtOCxYs0FiD3Dmf/c53vlM33HDDqArQ5EYN0JpnzroVoUEoh1TBUHrzJ510kokw/O1vfxv8HekM0gXUAzg4TCQ4Yndw2Irxtre9zXiOkAviLoioUEz3hz/8wfx91apVRgHuN7/5zeDQlHxApOS0UXcbLzz55JNmlCue9GiBSAajVyFnIhsU0VFAePjhh5vUxHXXXWdSHOTOEaGhVoFcPMYSqni8nrnrP/jBD0wtwEUXXWRSCuy3g8NEggvFOzhsxaDSHC8T8qaym5A6FecWkD0z0PE2JzL23nvvUf+M0047TWvWrNEdd9xhzsu73vUuozIHye+zzz4mcmAL5NCtZwwtxYhowBMZwTi6+OKLjUIe42dvvPFGR+oOExLOY3dwcNhu0hYPP/zwYHsgRM6UuOHSFkPh+uuvN9X8SMxC+g4OExGuKt7BwWGbR9Ce/3zgxTc2NjpSd5jQcMTu4OCwzSNoz38uKDqkiv8jH/nIKO2lg0Nl4IjdwcFhq8Vo9vznAiGdY4891oTzv/a1r1Vk3x0cRgsuSeTg4LDVYjR7/i26urpMC2FDQ4PpHojFYhXZdweH0YIjdgcHh60WU6dONV+FcPDBB6u9vd1oxNuef8R66F+np30kTx1N+KqqKqPah8Stg8NEh6uKd3Bw2C5Qas8/pP7Wt77VtAriqdfV1Q1uC2NiNHvuHRzKgfPYHRwctguU2vOP+IytmN9pp5222NbSpUs1f/78MT4CB4fi4IjdwcFhm0CuspwlbqRyGRkLqIC33vlQ42LPOecc829C9oBBNEONlnVwmOhwVfEODg7bBFCWe/bZZ42y3M0336x777236NY0JGXHQqPewWEs4HLsDg4O27Wy3BNPPKF3vOMdZpjOjBkzxl0338GhXDiP3cHBYbtVliOffuqpp5phMG4Eq8O2AkfsDg4O262y3HnnnWfGrx5//PFjsJcODmMDR+wODg7bpbIcfen0spNfd3DYluCq4h0cHLZLZTlI/eWXXzYh/FxQTX/YYYfpnnvuqcARODiMPVzxnIODwzZTPEcBnFWWu/32240U7HDFc4ToGeySi7322su0yB133HFasGDBmO2/g0Ml4YjdwcFhu1SWGwqE9l1VvMPWDpdjd3Bw2CpAWJ1edeahEz7/0Ic+pO7u7i2U5XbbbTdD3rS5HXroobriiitMxfyb3vQmox6HstzZZ5+tvr6+cT0WB4fRhPPYHRwcthqPfM2aNbr88ssHPfIDDzxwWDU5AKkTjr/gggtMeJ1K+SeffNJUwTPYxcFhW4QjdgcHh21WgOb1r3+93vKWt+ib3/zmGO+xg8P4wYXiHRwctkkBGqrk+Rv97fSqT58+XUcccYQWLVo0hnvu4DD2cMTu4OCwTQrQLFmyxHz/2te+pg9/+MPGw99vv/1MDn7x4sVjst8ODuMBR+wODg7bpABNJpMx3z/60Y+afPy+++6rH/zgB9p111119dVXV/hIHBwmDpxAjYODwzYpQMNAF0BuPhe77767li9fXva+OzhMVDhid3BwGDdMnTrVfBXCwQcfbOakP/roo4MCNCjH4ZW/7nWvG/I98+fPN0V1tLjl4sUXXzQV9g4O2ypcKN7BwWHCAy+btjVy5Q899JDuv/9+nXvuuTr55JMHK+IRoKGPnb8Dwvif//zn9eMf/1g33HCDXnrpJX35y182oX164B0ctlU4j93BwWGrAAI0kDnFb1TDo+kOaVvQ2453zihWi09/+tPq7+83U9wI2++999664447tOOOO47TUTg4jD5cH7uDg4ODg8M2BBeKd3BwcHBw2IbgiN3BwcHBwWEbgiN2BwcHBweHbQiO2B0cHBwcHLYhOGJ3cHBwcHDYhuCI3cHBwcHBYRuCI3YHBwcHB4dtCI7YHRwcHBwctiE4YndwcHBwcNiG4IjdwcHBwcFhG4IjdgcHBwcHh20IjtgdHBwcHBy07eD/A0rbxy9YjwvLAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "res = X_rats_org\n",
     "fig = plt.figure(figsize=(8, 6))\n",
@@ -162,8 +191,18 @@
     "    s=thisvelocity,\n",
     ")\n",
     "\n",
+    "ax.view_init(elev=15, azim=-175, roll=-36)\n",
+    "\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7983a64",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 09d9d1e14eb0422e735f112ebad37752eb32a382 Mon Sep 17 00:00:00 2001
From: Nas <nasir.y.ahm@gmail.com>
Date: Fri, 26 Jun 2026 10:55:22 +0200
Subject: [PATCH 15/20] Adding reference to motor cortex lit (Saxena et al.)

---
 examples/motor_cortex.ipynb | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/examples/motor_cortex.ipynb b/examples/motor_cortex.ipynb
index 66827b4..d440443 100644
--- a/examples/motor_cortex.ipynb
+++ b/examples/motor_cortex.ipynb
@@ -32,7 +32,10 @@
    "id": "bf164db2-636e-4140-a5dc-c6bb7cb1b42c",
    "metadata": {},
    "source": [
-    "# Load data"
+    "# Load data\n",
+    "\n",
+    "Note that the data loaded here is from:\n",
+    "Saxena, S., Russo, A. A., Cunningham, J., & Churchland, M. M. (2022). Motor cortex activity across movement speeds is predicted by network-level strategies for generating muscle activity. eLife, 11, e67620. https://doi.org/10.7554/eLife.67620"
    ]
   },
   {

From 57dcacfc28ae32adc49d9d52f306c1388b371fd5 Mon Sep 17 00:00:00 2001
From: Nas <nasir.y.ahm@gmail.com>
Date: Fri, 26 Jun 2026 10:59:00 +0200
Subject: [PATCH 16/20] Add data source citation in t_maze.ipynb

Added a markdown cell with a citation for the data source.
---
 examples/t_maze.ipynb | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/examples/t_maze.ipynb b/examples/t_maze.ipynb
index e2532c7..f551d86 100644
--- a/examples/t_maze.ipynb
+++ b/examples/t_maze.ipynb
@@ -22,6 +22,17 @@
     "np.random.seed(42)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "bf164db2",
+   "metadata": {},
+   "source": [
+    "# Load data\n",
+    "\n",
+    "Note that the data loaded here is from:\n",
+    "Guo, W., Zhang, J. J., Newman, J. P., & Wilson, M. A. (2024). Latent learning drives sleep-dependent plasticity in distinct CA1 subpopulations. Cell Reports, 43(12), 115028. https://doi.org/10.1016/j.celrep.2024.115028"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,

From 07aba094d0d8f706d8e0f67a4cbc91ffc6d738aa Mon Sep 17 00:00:00 2001
From: Nas <nasir.y.ahm@gmail.com>
Date: Fri, 26 Jun 2026 11:02:16 +0200
Subject: [PATCH 17/20] Update markdown cell with data source citation

Added citation for data source in markdown cell.
---
 examples/r2of_day1.ipynb | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/examples/r2of_day1.ipynb b/examples/r2of_day1.ipynb
index d9d8974..df196fd 100644
--- a/examples/r2of_day1.ipynb
+++ b/examples/r2of_day1.ipynb
@@ -32,7 +32,10 @@
    "id": "bf164db2-636e-4140-a5dc-c6bb7cb1b42c",
    "metadata": {},
    "source": [
-    "# Load data"
+    "# Load data\n",
+    "\n",
+    "Note that the data loaded here is from the following paper:\n",
+    "Gardner, R. J., Hermansen, E., Pachitariu, M., Burak, Y., Baas, N. A., Dunn, B. A., Moser, M.-B., & Moser, E. I. (2022). Toroidal topology of population activity in grid cells. Nature, 602(7895), 123–128. https://doi.org/10.1038/s41586-021-04268-7”,
    ]
   },
   {

From c8348a5a22aaa0ff584eca4e6d0151b50bd3c280 Mon Sep 17 00:00:00 2001
From: Nas <nasir.y.ahm@gmail.com>
Date: Fri, 26 Jun 2026 11:02:50 +0200
Subject: [PATCH 18/20] Fix notebook formatting

---
 examples/r2of_day1.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/r2of_day1.ipynb b/examples/r2of_day1.ipynb
index df196fd..c22bf2b 100644
--- a/examples/r2of_day1.ipynb
+++ b/examples/r2of_day1.ipynb
@@ -35,7 +35,7 @@
     "# Load data\n",
     "\n",
     "Note that the data loaded here is from the following paper:\n",
-    "Gardner, R. J., Hermansen, E., Pachitariu, M., Burak, Y., Baas, N. A., Dunn, B. A., Moser, M.-B., & Moser, E. I. (2022). Toroidal topology of population activity in grid cells. Nature, 602(7895), 123–128. https://doi.org/10.1038/s41586-021-04268-7”,
+    "Gardner, R. J., Hermansen, E., Pachitariu, M., Burak, Y., Baas, N. A., Dunn, B. A., Moser, M.-B., & Moser, E. I. (2022). Toroidal topology of population activity in grid cells. Nature, 602(7895), 123–128. https://doi.org/10.1038/s41586-021-04268-7”
    ]
   },
   {

From e57f79825e35febf5ebebfc20eddc1f0971361cb Mon Sep 17 00:00:00 2001
From: Nas <nasir.y.ahm@gmail.com>
Date: Fri, 26 Jun 2026 11:04:11 +0200
Subject: [PATCH 19/20] Fix formatting of citation in Jupyter notebook - quotes

---
 examples/r2of_day1.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/r2of_day1.ipynb b/examples/r2of_day1.ipynb
index c22bf2b..5fe1f65 100644
--- a/examples/r2of_day1.ipynb
+++ b/examples/r2of_day1.ipynb
@@ -35,7 +35,7 @@
     "# Load data\n",
     "\n",
     "Note that the data loaded here is from the following paper:\n",
-    "Gardner, R. J., Hermansen, E., Pachitariu, M., Burak, Y., Baas, N. A., Dunn, B. A., Moser, M.-B., & Moser, E. I. (2022). Toroidal topology of population activity in grid cells. Nature, 602(7895), 123–128. https://doi.org/10.1038/s41586-021-04268-7”
+    "Gardner, R. J., Hermansen, E., Pachitariu, M., Burak, Y., Baas, N. A., Dunn, B. A., Moser, M.-B., & Moser, E. I. (2022). Toroidal topology of population activity in grid cells. Nature, 602(7895), 123–128. https://doi.org/10.1038/s41586-021-04268-7"
    ]
   },
   {

From 42a4bd466526fa41b06bf002fba0ce3a5d4969ab Mon Sep 17 00:00:00 2001
From: Dhruv Kohli <dhruvkohli99@gmail.com>
Date: Mon, 29 Jun 2026 04:15:08 -0700
Subject: [PATCH 20/20] add practical guide

---
 practical_guide.md | 90 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 practical_guide.md

diff --git a/practical_guide.md b/practical_guide.md
new file mode 100644
index 0000000..9227b54
--- /dev/null
+++ b/practical_guide.md
@@ -0,0 +1,90 @@
+# RATS: Riemannian Alignment of Tangent Spaces
+
+RATS follows a bottom-up approach to manifold learning, integrating local representations of data into a globally consistent embedding.   
+This guide provides practical instructions for preprocessing data and tuning the key hyperparameters in RATS: `min_cluster_size`, `n_neighbors`, and the `tearing` flag.
+
+---
+
+## Table of Contents
+
+1. [Computational Complexity](https://docs.google.com/document/d/1uWP-hmgtU0tC-d6lGc99Urnz1oW7vLdJnXJmwUUa7cU/edit#computational-complexity)  
+2. [Hyperparameter Guidelines](https://docs.google.com/document/d/1uWP-hmgtU0tC-d6lGc99Urnz1oW7vLdJnXJmwUUa7cU/edit#hyperparameter-guidelines)  
+3. [Preprocessing & Scaling](https://docs.google.com/document/d/1uWP-hmgtU0tC-d6lGc99Urnz1oW7vLdJnXJmwUUa7cU/edit#preprocessing--scaling)  
+4. [Manifold Tearing](https://docs.google.com/document/d/1uWP-hmgtU0tC-d6lGc99Urnz1oW7vLdJnXJmwUUa7cU/edit#manifold-tearing)  
+5. [Future Roadmap](https://docs.google.com/document/d/1uWP-hmgtU0tC-d6lGc99Urnz1oW7vLdJnXJmwUUa7cU/edit#future-roadmap)
+
+---
+
+## Computational Complexity
+
+To understand how to tune RATS, it is helpful to understand the underlying algorithmic time complexities. Let $ n$ be the number of samples, $ m$ be the number of intermediate views, $ k$ be `n_neighbors`, $ D$ be the input dimension, and $ d$ be the intrinsic dimension.
+
+| Operation | Time Complexity | Notes |
+| :---- | :---- | :---- |
+| **Nearest Neighbor Graph** | $\\mathcal{O}(n \\log n \\cdot D)$ | Standard tree-based construction. |
+| **Local Linear PCA** | $\\mathcal{O}(n \\cdot k \\cdot D \\cdot d)$ | Assumes truncated SVD for intrinsic dims. |
+| **Local Kernel PCA** | $\\mathcal{O}(n \\cdot (k^3 \+ k^2 \\cdot D))$ | Kernel matrix formulation \+ eigendecomposition. |
+| **Intermediate Views** | $\\mathcal{O}(n \\cdot k \\cdot \\eta\_{\\min}(k^2 \+ k D d))$ | Where $\\eta\_{\\min}$ is `min_cluster_size`. |
+| **View Post-Processing** | $\\mathcal{O}(n k (k^2 \+ kDd))$ |  |
+| **Laplacian Pseudo-Inverse** | $\\mathcal{O}(n m^2)$ | Linear in $ n$, quadratic in $ m$. |
+
+---
+
+## Hyperparameter Guidelines
+
+### 1\. `min_cluster_size` ($\\eta\_{\\min}$)
+
+To align intermediate views, RATS solves a non-convex optimization problem by computing the pseudo-inverse of a combinatorial Laplacian. This bipartite graph captures the correspondence between $m$ intermediate views and $n$ points. Because the number of views $m$ is typically on the order of $n / \\eta\_{\\min}$, therefore $\\eta\_{\\min}$ should be larger for lower computational time and robust alignment. But too large $\\eta\_{\\min}$ may result in bigger intermediate views which may result in high global distortion. 
+
+* **Recommended Range** for datasets on the order of several thousands of points: `[3, 10].`
+
+### 2\. `n_neighbors` ($k$)
+
+Because the runtime for intermediate view construction scales cubically with the number of neighbors, this value must be kept small, while too small of a value may result in smaller overlaps between views leading to inaccurate alignment. 
+
+* **Recommended Range:** for datasets on the order of several thousands of points: `[15, 50]`
+
+### 3\. `metric`
+
+Metric to find the nearest neighbors i.e. local neighborhoods in the data space.   
+Typical options: `'euclidean','cosine'` etc.
+
+### 4\. `kernel`
+
+The kernel used in local kernel PCA during the local view construction.  
+Typical options: `'linear'/None, 'cosine','rbf'` etc.
+
+---
+
+## Preprocessing & Scaling
+
+### Handling High Input Dimensions ($D \> 100$)
+
+As shown in the complexity table, the input dimension ($ D$) plays a compounding role in nearest neighbor construction, local PCA, and post-processing.
+
+* **Recommendation:** If your dataset has a high input dimension ($D \> 100$), perform **global PCA** on the entire dataset to reduce the dimension to $D \< 100$ before running RATS. This will prevent severe computational bottlenecks.
+
+### Handling Large Datasets ($n \\gg 10^4$)
+
+The current pseudo-inverse computation restricts standard execution times (10–30 seconds) to $n \\approx 10^4$.
+
+* **Recommendation:** If your dataset is orders of magnitude larger than $10,000$, we highly recommend subsampling it prior to embedding. Use **uniform subsampling** or **topological subsampling** ([Kloke, J. & Carlsson, G. Topological De-Noising: Strengthening the Topological Signal.](http://paperpile.com/b/BLBzQS/XNRkN)).
+
+---
+
+## Manifold Tearing
+
+Unlike many existing manifold learning algorithms, RATS is capable of tearing closed or non-orientable manifolds. This is achieved by enabling the `tearing` flag. 
+
+* **If `tearing = False`:** The Laplacian pseudo-inverse is computed once.  
+* **If `tearing = True`:** The combinatorial Laplacian and its pseudo-inverse must be recomputed at each "outer" iteration of the alignment procedure, resulting in longer run-times. 
+
+---
+
+## Future Roadmap
+
+As RATS matures, we are actively developing the following computational optimizations:
+
+1. **Approximate Pseudo-Inverse Solvers:** We plan to implement approximate Laplacian solvers (Spielman and Teng, 2014\) that scale linearly with matrix dimensions, drastically reducing base alignment time.  
+2. **Overlap Tracking for Tearing:** We will track whether the overlapping embedding structure has meaningfully changed between iterations. If the tear has stabilized, we can safely bypass redundant pseudo-inverse updates.  
+3. **Woodbury Matrix Identity Updates:** We aim to model the Laplacian of the new overlapping structure as a mathematical perturbation of the previous state. By employing Woodbury pseudo-inverse formulas, we can efficiently update the inverse instead of recomputing it from scratch.