diff --git a/README.md b/README.md
index 77c58de..a3b00c1 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
# TMAP2
-Tree-based visualization for high-dimensional data. Organizes similar items into interactive tree structures. Ideal for chemical space, protein embeddings, single-cell data, or any high-dimensional dataset.
+TMAP2 draws high-dimensional data as a tree in 2D. Similar items land on the same branch, and the branches show how groups connect to each other. It works for chemical space, protein embeddings, single-cell data, and any other dataset you can turn into fingerprints or vectors.
@@ -18,7 +18,7 @@ Tree-based visualization for high-dimensional data. Organizes similar items into
Most dimensionality reduction tools (UMAP, t-SNE, PCA) produce point clouds. TMAP produces a **tree**, a connected structure where every point is linked to its neighbors through branches. This makes the layout itself explorable because you can follow branches, trace paths between any two points, and discover how regions connect.
-For example, in a TMAP of pet breed images, following the branch from terriers toward cats reveals that the bridge between the two groups runs through chihuahuas and sphynx cats (the bald ones) which is both hilarious and logical since both are small, have short hair, big eyes... The tree doesn't just cluster similar things it also shows you *how* dissimilar things are connected.
+For example, in a TMAP of pet breed images, the branch from terriers to cats runs through chihuahuas and then sphynx cats (the bald ones). It's hilarious and also logical: both are small, short-haired, and have big eyes. So besides grouping similar things, the tree shows *how* groups that look unrelated are connected.
@@ -31,9 +31,10 @@ path = model.path(idx_a, idx_b) # nodes along the tree path
d = model.distance(idx_a, idx_b) # sum of edge weights along the path
n = model.hops(idx_a, idx_b) # number of tree edges between two points
pseudotime = model.distances_from(idx) # tree distance from one point to all others
+steps = model.hops_from(idx) # tree edges from one point to all others
```
-The same path tracing and tree-distance colouring are available inside the interactive HTML: pin two points and the inspector lists the path, or colour the whole map by tree distance from a selected point.
+The same path tracing and tree-distance coloring are available inside the interactive HTML: pin two points and the inspector lists the path, or color the whole map by tree distance from a selected point. For analysis on the tree itself, `tmap.graph` has helpers such as `boundary_edges`, `subtree_purity`, and `path_properties`.
## Installation
@@ -43,17 +44,19 @@ pip install tmap2
Wheels are published for Linux x86_64, macOS arm64 (Apple Silicon), and Windows x86_64 on Python 3.11 to 3.13. Other platforms build the OGDF layout extension from source and need CMake and a C++17 compiler.
-On Windows and macOS the chemistry helpers (`fingerprints_from_smiles`, `molecular_properties`) start worker processes with the `spawn` method, so scripts that call them need the usual `if __name__ == "__main__":` guard. Notebooks are unaffected.
+The chemistry helpers (`fingerprints_from_smiles`, `molecular_properties`, `murcko_scaffolds`, `reaction_properties`) run on several worker processes. Python starts those workers by re-importing your script, so scripts that call the helpers need the usual `if __name__ == "__main__":` guard on every platform. Notebooks don't need it.
Optional extras:
```bash
-pip install rdkit # chemistry helpers (fingerprints_from_smiles, molecular_properties)
-pip install jupyter-scatter # notebook interactive widgets
-pip install biopython # protein helpers (ProtParam properties, PDB parsing)
+pip install "tmap2[chemistry]" # RDKit: fingerprints, molecular properties, scaffolds
+pip install "tmap2[notebook]" # jupyter-scatter: viz.show() and model.plot() in Jupyter
+pip install "tmap2[proteins]" # Biopython: ProtParam properties, PDB parsing
+pip install "tmap2[singlecell]" # anndata: from_anndata and the other single-cell helpers
+pip install "tmap2[all]" # everything above
```
-> **Note:** The import name is `tmap`, not `tmap2`.
+> **Note:** You install `tmap2` and import `tmap`.
## Quick Start
@@ -87,25 +90,24 @@ viz.show() # inline in a Jupyter notebook
# viz.write_html("tmap.html") # or save as interactive HTML
```
+`viz.show()` needs the `notebook` extra. The notebook widget draws the points and skips the tree edges (it warns about this); the HTML export draws both.
+
## Key Features
- **Tree structure**: follow branches, trace paths, count hops, compute pseudotime
- **Always one tree**: a too-low `n_neighbors` can fragment the kNN graph; TMAP bridges the pieces so `path` and `distance` stay defined (`connect_components=True`, inspect with `n_components_`)
-- **Deterministic**: the layout is always seeded and deterministic. For cosine/euclidean, pass `reproducible=True` to also make the HNSW index build bit-identical across runs (slower)
-- **Multiple metrics**: `jaccard`, `cosine`, `euclidean`, `precomputed`, or bring your own kNN graph
-- **Incremental**: `add_points()` and `transform()` for adding new data into an existing TMAP
+- **Reproducible on request**: the layout is always seeded. The HNSW index used for binary Jaccard (and for cosine/euclidean from 50,000 points up) is built on several threads, so two runs can differ slightly. `reproducible=True` builds it on one thread and gives identical coordinates every time (slower)
+- **Multiple metrics**: `jaccard`, `cosine`, `euclidean`, `precomputed`, or bring your own kNN graph with `fit(knn_graph=...)`
+- **Incremental**: `add_points()` adds new points to a fitted map and `transform()` places them without changing it. For cosine/euclidean, fit with `store_index=True` first
- **Model persistence**: `save()` / `load()`
- **Three viz backends**: interactive HTML, jupyter-scatter, matplotlib
## Visualization (add colors, labels...)
-**Notebook widgets**: color switching, categorical filtering, and lasso selection with pandas-backed metadata:
-
### Add Colors & Labels
-Adding colors is quite simple. Just pass the name of the layout (e.g. Molecular Weight, Age, Protein Lenght ...), a list of values for each node and matplotlib color.
-If the data is categorical (e.g. Age or Heavy Atom Count) pass `categorical=True` so that categorical colors like `tab10` become available.
-To add labels (i.e. data that is not needed for coloring the nodes) just pass a name for the labels and the list of values.
+To add a color layer, pass a name (e.g. "Molecular Weight" or "Protein Length"), one value per point, and optionally a matplotlib colormap. Continuous values use a colormap like `viridis` (the default). For categories such as scaffolds or cell types, pass `categorical=True`; these use a qualitative palette like `tab10` (the default) or your own list of hex colors.
+Labels are values you want to see in tooltips and cards without coloring by them. Pass a name and one value per point.
```python
model = TMAP(metric="jaccard").fit(X)
@@ -116,26 +118,28 @@ viz.add_label("SMILES", smiles_list)
viz.show(width=1000, height=620, controls=True) # to see in jupyter notebook
# viz.write_html("mytmap.html") # to save and see as HTML in the browser
```
-> Here SMILES are added as a plain label, so no 2D structure is drawn. To render structures in tooltips and cards, use `viz.add_smiles(smiles_list)` instead. For image datasets use `viz.add_images(paths_or_urls)`.
+> Here SMILES are added as a plain label, so no 2D structure is drawn. To render structures in tooltips and cards, use `viz.add_smiles(smiles_list)` instead. For image datasets use `viz.add_images(data_uris)`, with one `"data:image/png;base64,..."` string per point.
### Filters, cards and structures
```python
-viz.add_filter("Ring Count", n_rings, categorical=True) # filter-panel column without a colour map
-viz.configure_column("UniProt ID", link_template="https://www.uniprot.org/uniprotkb/{value}")
+viz.add_filter("Ring Count", n_rings, categorical=True) # filter-panel column without a color map
+viz.configure_column("UniProt ID", link_template="https://www.uniprot.org/uniprotkb/{UniProt ID}")
viz.configure_card(title_column="Name", fields=["Molecular Weight", "Scaffold"])
viz.add_3d_structures(alphafold_urls, source="url", fmt="pdb") # or add_3d_structure_files(local_paths)
```
-`add_filter` puts a column in the filter panel without computing colours for it, which is cheaper than `add_color_layout` when you only want to filter. Colour layouts are always filterable. `configure_column` and `configure_card` control links, formatting and what the pinned card shows. `add_3d_structures` and `add_3d_structure_files` attach PDB or mmCIF structures that render in the card.
+`add_filter` puts a column in the filter panel without computing colors for it, which is cheaper than `add_color_layout` when you only want to filter. Color layouts appear in the filter panel by default; set `viz.filterable = [...]` to choose the exact list. `configure_column` and `configure_card` control links, formatting and what the pinned card shows. In `link_template`, `{column name}` is replaced with that column's value for the point. `add_3d_structures` and `add_3d_structure_files` attach PDB or mmCIF structures that render in the card.
### Interactive HTML
-`viz.write_html("name.html")` writes a self-contained page with lasso selection, light/dark theme, filter and search panels, pinned metadata cards, and a binary mode for large datasets. Selecting a point opens the **inspector**:
+`viz.write_html("name.html")` writes one HTML file with the data embedded. It opens in a browser without a server, but it loads a few JavaScript libraries from a CDN, so the viewer needs internet access. The page has lasso selection, light and dark themes, filter and search panels, and pinned metadata cards. For maps too big for a single file, `viz.write_static("my_map/")` writes the page and its data as separate files for any static web host, and `viz.serve()` does the same in a temporary folder, opens it in your browser, and keeps serving until you press Ctrl+C.
-- **Neighbors**: the point's tree neighbours with similarity scores, property differences and structures or images. Hovering a neighbour highlights the connecting edge.
+Selecting a point opens the **inspector**:
+
+- **Neighbors**: the point's tree neighbors with similarity scores, property differences and structures or images. Hovering a neighbor highlights the connecting edge.
- **Path**: pin a second point to trace the tree path between them, listing each node with its step number and running tree distance.
-- **Colour by tree distance**: colour the whole map by tree distance from the selected point, using the normal colour menu.
+- **Color by tree distance**: color the whole map by tree distance from the selected point, using the normal color menu.
For publication figures use matplotlib: `model.plot_static(color_by=labels)`.
@@ -151,19 +155,23 @@ from tmap.utils.singlecell import from_anndata
| Domain | Metric | Utilities |
|--------|--------|-----------|
-| Chemoinformatics | `jaccard` | `fingerprints_from_smiles` (`return_valid=True` flags unparseable SMILES), `molecular_properties`, `murcko_scaffolds`, `reaction_properties` |
-| Proteins | `cosine` / `euclidean` | `fetch_uniprot`, `fetch_alphafold`, `read_fasta`, `read_pdb`, `read_pdb_dir`, `read_protein_csv`, `sequence_properties`, `parse_alignment` |
+| Chemoinformatics | `jaccard` for binary fingerprints (Morgan, MAP4, MHFP, DRFP); `cosine` / `euclidean` for count fingerprints (MQN, MXFP) | `fingerprints_from_smiles` (`return_valid=True` flags unparseable SMILES), `molecular_properties`, `murcko_scaffolds`, `reaction_properties` |
+| Proteins | `cosine` / `euclidean` | `fetch_uniprot`, `fetch_alphafold`, `read_fasta`, `read_id_list`, `read_pdb`, `read_pdb_dir`, `read_protein_csv`, `sequence_properties`, `parse_alignment` |
| Single-cell | `cosine` / `euclidean` | `from_anndata`, `cell_metadata`, `marker_scores`, `obs_to_numeric`, `subset_anndata`, `sample_obs_indices` |
| Generic embeddings | `cosine` / `euclidean` / `precomputed` | No domain utils needed |
## Examples
-Runnable scripts for chemistry, images, proteins and text live in [`examples/`](examples/README.md). The shortest one is:
+Runnable scripts for chemistry, images, proteins and text live in [`examples/`](examples/README.md). The quickest to try uses the bundled CSV and downloads nothing:
```bash
python examples/chemistry/molecules_tmap.py --nrows 3000
```
+## Documentation
+
+The guides in [`docs/`](docs/index.md) cover each part of the pipeline in more depth: the [molecule tutorial](docs/molecule_tutorial.md), [visualization](docs/visualization_guide.md), the [API reference](docs/api_reference.md), and the lower-level [MinHash](docs/minhash_guide.md), [LSHForest](docs/lshforest_guide.md), [USearch](docs/usearch_backend.md), [graph](docs/graph_guide.md), and [layout](docs/layout_guide.md) guides.
+
## Notebooks
| Notebook | Topic |
@@ -171,7 +179,7 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
| [01 Quickstart](notebooks/01_quickstart.ipynb) | Shortest end-to-end walkthrough on a small molecule table |
| [02 Cheminformatics](notebooks/02_cheminformatics.ipynb) | SMILES → fingerprints → interactive molecular map |
| [03 Continuous Embeddings](notebooks/03_continuous_embeddings.ipynb) | Cosine and euclidean on MNIST: when to use each |
-| [04 What's New](notebooks/04_new_functionalities.ipynb) | `add_points`, `transform`, tree paths, save/load, external kNN |
+| [04 Working with a Fitted Model](notebooks/04_working_with_a_fitted_model.ipynb) | `kneighbors`, `transform`, `add_points`, tree paths and hops, disconnected graphs, save/load, external kNN |
| [05 Single-Cell](notebooks/05_single_cell.ipynb) | RNA-seq with PBMC 3k, pseudotime, UMAP comparison |
| [06 FAQ](notebooks/06_faq.ipynb) | Troubleshooting and common questions |
| [07 MinHash Deep Dive](notebooks/07_minhash_deep_dive.ipynb) | Encoding methods and when to use each |
@@ -179,28 +187,34 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
| [09 Card Configuration](notebooks/09_card_configuration.ipynb) | Pinned card layout, fields, and links |
| [10 Protein Analysis](notebooks/10_protein_analysis.ipynb) | FASTA, ESM embeddings, AlphaFold |
| [11 USearch Jaccard](notebooks/11_usearch_jaccard.ipynb) | Native binary Jaccard backend (high recall, low memory) |
-| [12 Legacy LSH Pipeline](notebooks/12_legacy_lsh_pipeline.ipynb) | Lower-level MinHash + LSHForest + layout workflow |
+| [12 Lower-Level Pipeline](notebooks/12_lower_level_pipeline.ipynb) | MinHash + LSHForest + OGDF layout + `TmapViz`, step by step |
| [13 Local Protein Structures](notebooks/13_local_protein_structures.ipynb) | Pinned cards with locally stored PDB/mmCIF structures |
| [14 CAZyme Analysis](notebooks/14_cazyme_analysis.ipynb) | GH43 glycoside hydrolase family map, contributed example |
## Lower-Level Pipeline
-For direct control over indexing, hashing, and layout, see the [legacy pipeline notebook](notebooks/12_legacy_lsh_pipeline.ipynb). The main building blocks:
+For direct control over indexing, hashing, and layout, see the [lower-level pipeline notebook](notebooks/12_lower_level_pipeline.ipynb). The main building blocks:
```python
-from tmap.index import USearchIndex # dense / binary kNN
+from tmap.index import USearchIndex, KNNGraph # dense / binary kNN, or your own neighbors
from tmap import MinHash, LSHForest # Jaccard on sets / strings
from tmap.layout import LayoutConfig, layout_from_lsh_forest
```
+`TMAP.fit` picks the neighbor search from the input:
+
```text
Your Data
- ├─→ Binary matrix ─────────→ USearch (Jaccard / cosine / euclidean)
- └─→ Sets / strings ───────→ MinHash → LSHForest
+ ├─→ Dense binary matrix (0/1) ────→ USearch, Jaccard
+ ├─→ Dense float matrix ───────────→ USearch, cosine / euclidean
+ ├─→ Sets, strings, sparse matrix ─→ MinHash → LSHForest
+ └─→ Distance matrix or KNNGraph ──→ precomputed neighbors
↓
- k-NN Graph → MST → OGDF Tree Layout → Interactive Visualization
+ k-NN Graph → bridge components → MST → OGDF Tree Layout → Interactive Visualization
```
+USearch runs an exact search for cosine and euclidean below 50,000 points and switches to HNSW above that. Binary Jaccard always uses HNSW.
+
## Development
```bash
diff --git a/docs/api_reference.md b/docs/api_reference.md
index 8b1afb2..83fe2bb 100644
--- a/docs/api_reference.md
+++ b/docs/api_reference.md
@@ -4,190 +4,353 @@ This is a practical reference for the public API. For a guided workflow, start w
## `TMAP`
-High-level estimator for building a tree-shaped 2D map.
+High-level estimator for building a tree-shaped 2D map. Import it with `from tmap import TMAP`.
### Constructor
```python
TMAP(
n_neighbors=20,
- metric="jaccard",
- n_permutations=512,
- kc=50,
- seed=42,
+ metric="jaccard", # "jaccard", "cosine", "euclidean" or "precomputed"
+ n_permutations=512, # MinHash only (sets, strings, sparse input)
+ kc=50, # LSHForest only (sets, strings, sparse input)
+ seed=42, # layout seed
+ minhash_seed=42, # MinHash seed
layout_iterations=1000,
layout_config=None,
store_index=False,
+ reproducible=False,
+ connect_components=True,
)
```
-### Key Methods
+| Parameter | What it does |
+|-----------|--------------|
+| `n_neighbors` | Neighbors per point in the kNN graph |
+| `metric` | Distance to use. See [Input routing](#input-routing) for which inputs each metric takes |
+| `n_permutations` | MinHash signature length. Only used when the input goes through MinHash + LSHForest |
+| `kc` | LSHForest search multiplier: each query collects `n_neighbors * kc` candidates and ranks them exactly. Larger values give better recall and cost query time. Only used on the LSHForest path |
+| `seed` | Seed for the OGDF layout |
+| `minhash_seed` | Seed for the MinHash permutations |
+| `layout_iterations` | Force-directed iterations. Ignored when you pass `layout_config` |
+| `layout_config` | A `LayoutConfig` for fine control of the layout. The estimator sets its `deterministic` and `seed` fields in place; everything else is yours. See [layout_guide.md](layout_guide.md) |
+| `store_index` | Keep the cosine/euclidean index after `fit()`, which `kneighbors()`, `transform()` and `add_points()` need. Binary Jaccard keeps its index regardless |
+| `reproducible` | Build the HNSW index on one thread so repeated runs give identical coordinates. Slower (roughly 5 to 7 times for the HNSW build at 10k+ points) |
+| `connect_components` | If the kNN graph falls apart into several pieces, add the cheapest edges that join them so the result is one tree. `False` keeps the forest |
+
+`metric` is case-insensitive.
+
+### Fitting
+
+```python
+model = TMAP(metric="cosine").fit(X) # from data
+model = TMAP().fit(knn_graph=KNNGraph.from_arrays(indices, distances)) # from your own neighbors
+x, y, s, t = TMAP(metric="cosine").fit_transform(X) # coordinates and tree edges
+```
+
+`fit()` takes either `X` or `knn_graph`, never both. With `knn_graph`, TMAP skips the neighbor search.
+
+### Methods
| Method | What it does |
|--------|---------------|
-| `fit(X)` | Build the graph, tree, and 2D embedding |
-| `fit_transform(X)` | Fit and return `(x, y, s, t)` |
-| `kneighbors(X)` | Query nearest fitted neighbors for new points without placement or mutation |
-| `transform(X_new)` | Place new points on the existing map without changing the model |
-| `add_points(X_new)` | Add new points into the fitted model |
-| `to_tmapviz()` | Create a `TmapViz` object for notebook or HTML output |
-| `to_html(path)` | Write an HTML visualization |
-| `serve(port=8050)` | Start a local HTTP server for the visualization |
-| `save(path)` / `load(path)` | Save or load the fitted model |
-
-### Key Attributes
+| `fit(X=None, *, knn_graph=None)` | Build the graph, tree and 2D embedding. Returns the model |
+| `fit_transform(X=None, *, knn_graph=None)` | Fit and return `(x, y, s, t)`: coordinates plus the tree edges as source and target arrays |
+| `kneighbors(X, *, return_distance=True)` | Nearest fitted points for new data. The model doesn't change |
+| `transform(X)` | Coordinates for new points, placed next to their nearest fitted neighbors. The model doesn't change |
+| `add_points(X)` | Place new points and append them to the embedding, tree and graph. Returns their coordinates |
+| `path(a, b)` | Node indices along the tree path from `a` to `b` |
+| `distance(a, b)` | Sum of edge weights along that path |
+| `distances_from(i)` | Tree distance from point `i` to every point |
+| `hops(a, b)` | Number of tree edges between `a` and `b` |
+| `hops_from(i)` | Number of tree edges from point `i` to every point |
+| `to_tmapviz(include_edges=True)` | A `TmapViz` with the coordinates and tree edges filled in |
+| `to_html(path, *, title=None, include_edges=True)` | Write an HTML map and return its path |
+| `serve(port=8050, include_edges=True, **kwargs)` | Serve the map on a local HTTP server. Extra arguments go to `TmapViz.serve()` |
+| `plot(...)` | Notebook widget through jupyter-scatter. Takes `color_by`, `color_map`, `data`, `tooltip_properties` and size options |
+| `plot_static(...)` | Matplotlib figure. Takes `color_by`, `color_map`, `data`, `edges=True` and styling options. Returns the `Axes` |
+| `save(path)` | Save the fitted model, including any stored index |
+| `TMAP.load(path)` | Class method that loads a model written by `save()` |
+
+`kneighbors`, `transform` and `add_points` need the fitted index. For cosine and euclidean that means `store_index=True`; without it they raise `RuntimeError`. `add_points` only works for binary matrix input under Jaccard. If `fit()` got sets or strings, it raises `TypeError`, although `transform` and `kneighbors` still work.
+
+### Attributes
| Attribute | Meaning |
|-----------|---------|
-| `embedding_` | 2D coordinates, shape `(n, 2)` |
-| `tree_` | Tree extracted from the kNN graph |
-| `graph_` | k-nearest-neighbor graph |
-| `lsh_forest_` | Jaccard search index for set / string inputs |
-| `index_` | USearch index for cosine / euclidean (`store_index=True`) and binary Jaccard |
+| `embedding_` | 2D coordinates, shape `(n, 2)`, float32 |
+| `tree_` | The fitted `Tree` (see [Graph](#graph-tmapgraph)) |
+| `graph_` | The raw kNN graph as the search returned it, before any components were joined |
+| `n_components_` | Number of connected pieces in the raw kNN graph. `1` means it was already connected, `None` means `connect_components=False` |
+| `n_bridges_` | Number of edges added to join those pieces |
+| `index_` | The USearch index (binary Jaccard, or cosine/euclidean with `store_index=True`). Raises otherwise |
+| `lsh_forest_` | The LSHForest (sets, strings and sparse input). Raises otherwise |
+
+### Input routing
-### Metrics
+`fit()` chooses the neighbor search from the metric and the input type:
| Metric | Input | Backend |
|--------|-------|---------|
-| `jaccard` | Binary matrix | USearch |
-| `jaccard` | Sets / strings | MinHash + LSHForest |
-| `cosine` | Dense float matrix | USearch |
-| `euclidean` | Dense float matrix | USearch |
-| `precomputed` | Distance matrix | Direct graph construction |
+| `jaccard` | Dense binary matrix (0/1 NumPy array, bool array, DataFrame) | USearch, HNSW |
+| `jaccard` | Lists of feature indices, lists of string tokens, SciPy sparse matrix | MinHash + LSHForest |
+| `cosine` | Dense float matrix | USearch, exact below 50,000 points, HNSW above |
+| `euclidean` | Dense float matrix | USearch, exact below 50,000 points, HNSW above |
+| `precomputed` | Square distance matrix | Neighbors read from the matrix |
+| any | `knn_graph=KNNGraph(...)` | Your neighbors, used as given |
### Reproducibility
-The `seed` parameter controls the OGDF tree layout, which is fully
-deterministic: same kNN graph + same seed = identical coordinates.
+The OGDF layout always runs seeded and deterministic, so the same kNN graph and the same `seed` give identical coordinates.
The kNN step depends on the backend:
-- **MinHash + LSHForest** (sets / strings): deterministic for a given
- `seed` and `minhash_seed`.
-- **USearch HNSW** (binary Jaccard, cosine, euclidean): approximate and
- multi-threaded. Neighbor sets may vary slightly across runs or
- platforms. The resulting trees are nearly identical in practice because
- the MST is robust to small kNN variations.
+- **MinHash + LSHForest**: deterministic. The permutations come from `minhash_seed`.
+- **USearch exact search** (cosine/euclidean below 50,000 points): deterministic.
+- **USearch HNSW** (binary Jaccard, and cosine/euclidean from 50,000 points): built on several threads by default, so neighbors at equal distance can come back in a different order between runs. That can change the tree and the layout. Pass `reproducible=True` to build on one thread and get identical results every time.
-If you need bit-exact kNN reproducibility for binary data, use the
-MinHash + LSHForest pipeline directly:
+## `TmapViz`
-```python
-from tmap import MinHash, LSHForest
-from tmap.layout import LayoutConfig, layout_from_lsh_forest
+Interactive map object. You usually get one from `model.to_tmapviz()`. To build one from your own coordinates, use `from tmap.visualization import TmapViz` and call `set_points()` and optionally `set_edges()`.
+
+### Points and edges
-mh = MinHash(num_perm=128, seed=42)
-signatures = mh.batch_from_binary_array(X)
+| Method | What it does |
+|--------|---------------|
+| `set_points(x, y)` | Set the coordinates |
+| `set_edges(s, t, weights=None)` | Set the tree edges. Weights feed the neighbor list in the HTML inspector |
+| `set_edge_style(color=None, width=None, opacity=None)` | Edge color, width in CSS pixels, and opacity |
-lsh = LSHForest(d=128, l=64)
-lsh.batch_add(signatures)
-lsh.index()
+### Columns
-cfg = LayoutConfig(k=20, kc=50, deterministic=True, seed=42)
-x, y, s, t = layout_from_lsh_forest(lsh, cfg)
-```
+| Method | What it does |
+|--------|---------------|
+| `add_color_layout(name, values, categorical=False, add_as_label=True, color=None)` | A column you can color by. Also filterable, and shown in tooltips unless `add_as_label=False` |
+| `add_filter(name, values, categorical=False, add_as_label=True)` | A filter-panel column without a color map. Raises if `name` is already a color layout |
+| `add_label(name, values)` | A column shown in tooltips and cards |
+| `add_smiles(values, name="SMILES")` | SMILES strings, drawn as 2D structures in tooltips and cards |
+| `add_images(values, name="image", tooltip_size=128)` | One image per point as a `data:image/...;base64,...` URI |
+| `add_protein_ids(values, name="UniProt ID")` | UniProt accessions. Cards load the AlphaFold structure and UniProt metadata on demand |
+| `add_3d_structures(values, *, source="url", fmt="pdb", name="structure")` | PDB or mmCIF structures, either as URLs (`source="url"`) or as file text (`source="text"`) |
+| `add_3d_structure_files(paths, *, copy=True, directory="structures", fmt="pdb", name="structure")` | Local structure files. With `copy=True`, `write_html` and `write_static` copy them into `directory` next to the page |
-### Lower-Level Search Backends
+For `add_color_layout`, `color` is a matplotlib colormap name. Continuous layouts take a gradient colormap (default `viridis`). Categorical layouts take a qualitative one such as `tab10` (the default), `tab20`, `Set1` or `Dark2`, or a list or dict of hex colors. Mixing them up raises an error.
-`TMAP` is the main entry point for maps. For direct nearest-neighbor queries,
-the lower-level search classes are also public.
+### Panels and cards
-#### `USearchIndex`
+| Member | What it does |
+|--------|---------------|
+| `filterable` | Columns in the filter panel. Empty by default, which means every `add_filter` column plus every color layout. Assigning a list sets the exact columns |
+| `searchable` | Columns for text search. Empty by default, which means all label columns |
+| `configure_column(name, *, display_name=None, link_template=None, copyable=None, format=None)` | Per-column display hints. `link_template` takes `{column name}` placeholders. `format` accepts `"fixed:N"`, `"percent:N"`, `"scientific:N"`, `"integer"` and `"stars:N"` |
+| `configure_card(*, title_column=None, subtitle_column=None, fields=None, links=None)` | What the pinned card shows. `links` is a list of `{"label": ..., "url": ...}` dicts with `{column name}` placeholders |
-Use for dense cosine / euclidean search and binary Jaccard search.
+### Output
| Method | What it does |
|--------|---------------|
-| `build_from_vectors(X, metric=...)` | Build a dense cosine / euclidean index |
-| `build_from_binary(X)` | Build a binary Jaccard index |
-| `query_point(x, k)` | Query one vector |
-| `query_batch(X, k)` | Query many vectors |
-| `query_knn(k)` | Build the all-vs-all kNN graph |
-| `add(X)` | Append new vectors to the index |
-| `save(path)` / `load(path)` | Persist the index |
+| `show(*, width=800, height=420, controls=True)` | Display a jupyter-scatter widget in a notebook |
+| `to_widget(*, width=800, height=420, controls=True)` | Build the same widget without displaying it |
+| `to_dataframe(*, include_coords=True, ...)` | All columns as a pandas DataFrame, one row per point |
+| `to_html()` | The HTML page as a string |
+| `write_html(path)` | Write a single HTML file with the data embedded. If `path` is a directory, the file is named after `title` |
+| `write_static(output_dir)` | Write the page and its data as separate files for a static web host. Better for very large maps |
+| `serve(port=8050, open_browser=True)` | Write static files to a temporary folder, serve them, and open a browser. Blocks until Ctrl+C |
+
+The notebook widget needs the `notebook` extra (`pip install "tmap2[notebook]"`). It draws points only and warns if the map has edges. The HTML page loads a few JavaScript libraries from a CDN, so viewers need internet access.
-#### `LSHForest`
+Page settings are plain attributes: `title`, `background_color`, `point_color`, `point_size`, `opacity`, `edge_color`, `edge_width` and `edge_opacity`. Read-only helpers: `n_points`, `layouts` and `labels`.
-Use for lower-level MinHash workflows and Jaccard on sets / strings.
+### Minimal example
+
+```python
+viz = model.to_tmapviz()
+viz.title = "My Map"
+viz.add_color_layout("Score", scores.tolist(), color="viridis")
+viz.add_color_layout("Group", groups, categorical=True, color="tab10")
+viz.add_label("Name", names)
+viz.write_html("my_map.html")
+```
+
+### Static figures
+
+`tmap.visualization.plot_static(embedding, *, color_by=None, color_map=None, data=None, edges=None, ...)` draws any 2D embedding with matplotlib and returns the `Axes`. Pass `edges=model.tree_.edges` to draw the tree. `model.plot_static()` does the same for a fitted model.
+
+## Graph (`tmap.graph`)
+
+### `Tree`
+
+`model.tree_` returns a `Tree`. It stores `n_nodes`, `edges` (shape `(n - 1, 2)` for a connected tree), `weights`, and `root` (the node with the most edges).
| Method | What it does |
|--------|---------------|
-| `query(signature, k)` | LSH-only candidate lookup |
-| `query_linear_scan(signature, k, kc)` | Query one external signature with candidate refinement |
-| `query_linear_scan_by_id(id, k, kc)` | Query one indexed signature by ID |
-| `query_external_batch(signatures, k, kc)` | Batch query external signatures |
-| `get_knn_graph(k, kc)` | Build the all-vs-all kNN graph |
-| `get_all_distances(signature)` | Exact MinHash distances to all indexed signatures |
-| `save(path)` / `load(path)` | Persist the index |
+| `neighbors(node)` | `[(neighbor, weight), ...]` |
+| `children(node, parent=None)` | Neighbors other than `parent` |
+| `bfs(start=None)` / `dfs(start=None)` | Iterate `(node, parent, depth)` from `start` (default `root`) |
+| `subtree(node, depth=None)` | Nodes within `depth` edges of `node`, closest first. `depth=None` returns the whole connected component. Despite the name, it walks outward in every direction, including toward the root |
+| `subtree_sizes()` | Size of each node's subtree when rooted at `root` |
+| `path(a, b)` / `distance(a, b)` / `hops(a, b)` | Same as on the estimator |
+| `distances_from(i)` / `hops_from(i)` | Same as on the estimator. Unreachable nodes get `inf` or `-1` |
-## `TmapViz`
+### Analysis
+
+| Function | Returns |
+|----------|---------|
+| `boundary_edges(tree, labels)` | Indices of edges whose two ends have different labels |
+| `confusion_matrix_from_tree(tree, labels)` | `(matrix, classes)`: how often each pair of labels is joined by an edge |
+| `edge_delta(tree, values)` | Absolute change in `values` across each edge |
+| `path_properties(tree, a, b, values)` | `values` along the tree path from `a` to `b` |
+| `node_diversity(tree, method="mean")` | Per-node summary (`"mean"`, `"max"` or `"median"`) of the weights of its edges |
+| `subtree_purity(tree, labels, min_size=10)` | For each node, the share of its subtree that has its most common label. `NaN` for subtrees smaller than `min_size` |
+
+`tree_from_knn_graph(knn, config=None)` builds a `Tree` straight from a `KNNGraph`.
+
+## Index (`tmap.index`)
+
+### `KNNGraph`
-Visualization object returned by `model.to_tmapviz()`.
+Holds `indices` and `distances`, both of shape `(n, k)`. Missing neighbors have index `-1`.
-### Common Methods
+| Constructor | Use it when |
+|-------------|-------------|
+| `KNNGraph.from_arrays(indices, distances)` | You have neighbors from FAISS, Annoy or another library |
+| `KNNGraph.from_distance_matrix(D, k)` | You have a full distance matrix |
+
+Properties: `n_nodes`, `k`.
+
+### `USearchIndex`
+
+```python
+USearchIndex(seed=None, mode="auto", connectivity=32, expansion_add=256, expansion_search=200, threads=0)
+```
+
+`mode="auto"` uses exact search below 50,000 dense vectors and HNSW above. Binary Jaccard always uses HNSW. `threads=0` uses every core; `threads=1` makes the build reproducible.
| Method | What it does |
|--------|---------------|
-| `add_color_layout(name, values, ...)` | Add a colorable column |
-| `add_filter(name, values, ...)` | Add a filter-panel column without colors |
-| `add_label(name, values)` | Add a tooltip column |
-| `add_smiles(values)` | Add molecule structures to tooltips |
-| `to_widget(...)` | Build a Jupyter widget |
-| `write_html(path)` | Write one self-contained HTML file |
-| `write_static(path)` | Write static assets for hosting |
-| `serve(port=8050)` | Start a local HTTP server |
+| `build_from_vectors(X, metric="euclidean")` | Build a dense cosine or euclidean index |
+| `build_from_binary(X)` | Build a binary Jaccard index |
+| `query_point(x, k)` | Query one vector. Returns `(indices, distances)` |
+| `query_batch(X, k)` | Query many vectors |
+| `query_knn(k)` | All-vs-all kNN graph as a `KNNGraph` |
+| `add(X)` | Append vectors |
+| `save(path)` / `USearchIndex.load(path)` | Persist the index. `save` writes `path`, `path.meta` and `path.vectors.npy`, and `load` needs all three |
-### Minimal Example
+Properties: `n_nodes`, `metric`, `effective_mode` (`"exact"` or `"hnsw"`), `is_built`.
+
+### `LSHForest`
```python
-viz = model.to_tmapviz()
-viz.title = "My Map"
-viz.add_color_layout("Score", scores.tolist(), color="viridis")
-viz.add_label("Name", names)
-viz.write_html("my_map.html")
+LSHForest(d=128, l=None, store=True, weighted=False)
```
-## Chemistry Helpers
+`d` is the signature length and must match the MinHash `num_perm`. `l` is the number of prefix trees and defaults to 8. With `store=False`, only `query()` works; the methods that look up signatures by ID raise. Import it with `from tmap import LSHForest`.
-These live in `tmap.utils`.
+| Method | What it does |
+|--------|---------------|
+| `add(signature)` / `batch_add(signatures)` | Add signatures. Call `index()` afterwards |
+| `index()` | Build the prefix trees. Queries before this use the old index |
+| `query(signature, k)` | Candidates from the prefix trees only |
+| `query_by_id(id, k)` | Same, for an indexed point. The point itself is among the results |
+| `query_linear_scan(signature, k, kc=10)` | Collect `k * kc` candidates and rank them by exact MinHash distance. Returns `[(distance, id), ...]` |
+| `query_linear_scan_by_id(id, k, kc=10)` | Same, for an indexed point |
+| `query_external_batch(signatures, k, kc=10)` | Batch version for new signatures. Returns `(indices, distances)` padded with `-1` and `inf` |
+| `get_knn_graph(k, kc=10)` | All-vs-all kNN graph as a `KNNGraph` |
+| `get_all_nearest_neighbors(k, kc=10)` | The same neighbors as a flat index array of length `n * k` |
+| `get_all_distances(signature)` | Exact MinHash distances to every indexed signature |
+| `get_distance(a, b)` / `get_distance_by_id(a, b)` / `get_weighted_distance(a, b)` | Distance between two signatures |
+| `get_hash(id)` | The stored signature for a point |
+| `clear()` | Remove everything |
+| `save(path)` / `LSHForest.load(path)` | Persist the forest |
-| Function | What it does |
-|----------|---------------|
-| `fingerprints_from_smiles(smiles, fp_type="morgan", ..., return_valid=False)` | Build fingerprints from SMILES |
-| `molecular_properties(smiles, properties=None)` | Compute RDKit properties |
-| `murcko_scaffolds(smiles)` | Compute Murcko scaffold strings |
+Properties: `d`, `l`, `size`, `is_indexed`, `is_clean`.
+
+### `MinHash` and `WeightedMinHash`
+
+Import both from `tmap`.
+
+| Class | Main methods |
+|-------|--------------|
+| `MinHash(num_perm=128, seed=1)` | `batch_from_binary_array(X)`, `batch_from_sparse_binary_array(index_lists)`, `batch_from_string_array(string_lists)`, the single-item `from_*` versions, `encode(data)`, `MinHash.get_distance(a, b)` |
+| `WeightedMinHash(dim, num_perm=128, seed=1)` | `batch_from_weight_array(X, n_jobs=None)`, `from_weight_array(x)`, `encode(X)`, `WeightedMinHash.get_weighted_distance(a, b)` |
+
+To reproduce the signatures that `TMAP` builds, use `MinHash(num_perm=512, seed=42)`. See [minhash_guide.md](minhash_guide.md) for when to use each method.
+
+## Layout (`tmap.layout`)
+
+| Function | Use it when |
+|----------|-------------|
+| `layout_from_lsh_forest(lsh_forest, config=None, create_mst=True)` | You built an `LSHForest` yourself. Reads `config.k` and `config.kc` for the kNN query |
+| `layout_from_knn_graph(knn, config=None, create_mst=True)` | You already have a `KNNGraph` |
+| `layout_from_edge_list(vertex_count, edges, config=None, create_mst=True)` | You already have weighted edges as `[(source, target, weight), ...]` |
-### Chemistry Example
+All three return `(x, y, s, t)`: float32 coordinates scaled to [-0.5, 0.5] and uint32 tree edges.
+
+`LayoutConfig` holds the layout settings. It takes no constructor arguments, so set fields one at a time:
```python
-from tmap.utils import fingerprints_from_smiles, molecular_properties
+from tmap.layout import LayoutConfig, layout_from_knn_graph
-fps = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048)
-props = molecular_properties(smiles, properties=["mw", "logp", "n_rings"])
+cfg = LayoutConfig()
+cfg.deterministic = True
+cfg.seed = 42
+cfg.untangle = False
+x, y, s, t = layout_from_knn_graph(knn, config=cfg)
```
-`fingerprints_from_smiles` skips any SMILES it cannot read, so it can give
-back fewer rows than you passed in. `molecular_properties` and
-`murcko_scaffolds` keep every input and fill the bad ones with `NaN` or `""`.
-If a SMILES might be bad, ask for the flags and drop those inputs first.
-Otherwise the lists stop matching and points get the wrong colors and labels:
+The enums `Placer`, `Merger`, `ScalingType` and `UntangleMode` live in the same module. `OGDF_AVAILABLE` tells you whether the compiled extension loaded. For every field and what it does, see [layout_guide.md](layout_guide.md).
+
+## Utilities (`tmap.utils`)
+
+The functions below are also importable from `tmap` directly.
+
+### Chemistry
+
+Needs RDKit (`pip install "tmap2[chemistry]"`). All four functions run on several worker processes, so scripts that call them need an `if __name__ == "__main__":` guard.
+
+| Function | What it does |
+|----------|---------------|
+| `fingerprints_from_smiles(smiles, fp_type="morgan", n_workers=None, return_valid=False, **kwargs)` | Fingerprints from SMILES. `fp_type` is `"morgan"` (binary, takes `radius` and `n_bits`), `"map4"`, `"mhfp"` and `"drfp"` (binary), or `"mqn"` and `"mxfp"` (integer counts, use cosine or euclidean). `map4`, `mhfp`, `mxfp` and `drfp` need their own packages |
+| `molecular_properties(smiles, properties=None, n_workers=None)` | Dict of RDKit descriptors, `NaN` for SMILES that don't parse. Names are in `AVAILABLE_PROPERTIES` |
+| `murcko_scaffolds(smiles, n_workers=None)` | Murcko scaffold strings, `""` for SMILES that don't parse |
+| `reaction_properties(rxn_smiles, properties=None, n_workers=None)` | Dict of reaction descriptors. Names are in `AVAILABLE_REACTION_PROPERTIES` |
```python
-fps, valid = fingerprints_from_smiles(smiles, return_valid=True)
+from tmap.utils import fingerprints_from_smiles, molecular_properties
+
+fps, valid = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048, return_valid=True)
smiles = [smi for smi, ok in zip(smiles, valid) if ok]
props = molecular_properties(smiles, properties=["mw", "logp", "n_rings"])
```
-## Power-User Layout API
+`fingerprints_from_smiles` skips any SMILES it cannot read, so it can give back fewer rows than you passed in. `molecular_properties` and `murcko_scaffolds` keep every input and fill the bad ones with `NaN` or `""`. Filter with `valid` as above before computing anything else, or the lists stop matching and points get the wrong colors and labels.
-If you need lower-level control, these functions are still available:
+### Proteins
-| Function | Use it when |
-|----------|-------------|
-| `layout_from_lsh_forest(...)` | You want the classic MinHash + LSH workflow directly |
-| `layout_from_knn_graph(...)` | You already have a `KNNGraph` |
-| `tree_from_knn_graph(...)` | You want a `Tree` from a custom kNN graph |
-| `layout_from_edge_list(...)` | You already have weighted edges |
+`sequence_properties` and `read_pdb` need Biopython (`pip install "tmap2[proteins]"`). The fetch functions need internet access.
+
+| Function | What it does |
+|----------|---------------|
+| `read_fasta(path, max_seqs=None)` | `(ids, sequences)` from a FASTA file |
+| `read_protein_csv(path, id_col="id", seq_col="sequence")` | `(ids, sequences)` from a CSV or TSV file |
+| `read_id_list(path)` | UniProt accessions from a text file, one per line |
+| `read_pdb(path, chain=None)` | Sequence and structural properties from one PDB file |
+| `read_pdb_dir(directory, pattern="*.pdb", chain=None)` | `(ids, sequences, properties)` for a folder of PDB files |
+| `sequence_properties(sequences, properties=None)` | Dict of physicochemical properties. Names are in `AVAILABLE_SEQUENCE_PROPERTIES` |
+| `fetch_uniprot(ids, fields=..., chunk_size=50, max_workers=4)` | Annotations from the UniProt REST API |
+| `fetch_alphafold(ids, max_workers=20)` | Structure metadata (such as pLDDT) from the AlphaFold DB API |
+| `parse_alignment(path, k=20, score_col="bitscore", as_distance=True)` | A kNN graph from BLAST, MMseqs2 or Foldseek tabular output, for `TMAP().fit(knn_graph=...)` |
+
+### Single-cell
+
+Needs anndata (`pip install "tmap2[singlecell]"`).
-For the parameter details, see [layout_guide.md](layout_guide.md).
+| Function | What it does |
+|----------|---------------|
+| `from_anndata(adata, use_rep="X_pca", layer=None, n_top_genes=None)` | A float32 matrix for `TMAP.fit`, from `adata.obsm[use_rep]` or from expression values |
+| `cell_metadata(adata, keys=None)` | Columns of `adata.obs` as arrays, ready for `add_color_layout` |
+| `marker_scores(adata, gene_list, layer=None)` | Mean expression of a gene set in each cell |
+| `obs_to_numeric(values)` | Numeric version of an `obs` column, or `None` if it isn't numeric |
+| `subset_anndata(adata, *, obs_mask=None, obs_indices=None, copy=True)` | Subset cells in one step |
+| `sample_obs_indices(groups, *, max_items, seed, mode="proportional")` | Sample cells per group without replacement |
diff --git a/docs/graph_guide.md b/docs/graph_guide.md
index 028c8b3..1d3a0fc 100644
--- a/docs/graph_guide.md
+++ b/docs/graph_guide.md
@@ -12,27 +12,41 @@ The graph module sits between neighbor search and visualization:
Data -> k-NN graph -> MST extraction -> Tree analysis / layout
```
-TMAP keeps the public graph API small:
+`tmap.graph` has three parts:
- `tree_from_knn_graph(knn)` computes a minimum spanning tree from a `KNNGraph`
-- `Tree` exposes traversal, path, distance, and subtree helpers
+- `Tree` exposes traversal, path, distance, hop-count, and neighborhood helpers
+- analysis functions that combine the tree with per-point labels or values: `boundary_edges`, `confusion_matrix_from_tree`, `edge_delta`, `node_diversity`, `path_properties`, `subtree_purity`
-The supported MST path is OGDF-based. There is no separate SciPy MST builder anymore.
+The MST is computed by OGDF, the same library that draws the layout.
---
## Quick Start
+If you fitted a `TMAP`, the tree is already there:
+
```python
-from tmap.graph import tree_from_knn_graph
+from tmap import TMAP
-tree = tree_from_knn_graph(knn)
+model = TMAP(metric="cosine").fit(X)
+tree = model.tree_
print(tree.n_nodes)
print(len(tree.edges))
print(tree.root)
```
+The estimator also has shortcuts for the most common queries: `model.path`, `model.distance`, `model.distances_from`, `model.hops` and `model.hops_from` do the same as the `Tree` methods below.
+
+If you have a `KNNGraph` and no estimator, build the tree yourself:
+
+```python
+from tmap.graph import tree_from_knn_graph
+
+tree = tree_from_knn_graph(knn)
+```
+
Use this when:
- you already have a `KNNGraph`
@@ -60,25 +74,44 @@ This makes downstream layout and tree analysis practical.
### From LSHForest
```python
-from tmap import LSHForest
+from tmap import MinHash, LSHForest
from tmap.graph import tree_from_knn_graph
+signatures = MinHash(num_perm=128, seed=42).batch_from_binary_array(fingerprints)
+
+lsh = LSHForest(d=128, l=32)
+lsh.batch_add(signatures)
+lsh.index()
+
knn = lsh.get_knn_graph(k=20, kc=50)
tree = tree_from_knn_graph(knn)
```
+### From USearch
+
+`USearchIndex.query_knn` already returns a `KNNGraph`:
+
+```python
+from tmap.index import USearchIndex
+from tmap.graph import tree_from_knn_graph
+
+index = USearchIndex().build_from_vectors(X, metric="cosine")
+tree = tree_from_knn_graph(index.query_knn(k=20))
+```
+
### From another k-NN backend
+For FAISS, Annoy, an alignment tool or anything else that gives you neighbor indices and distances, wrap the arrays in a `KNNGraph`:
+
```python
from tmap.graph import tree_from_knn_graph
-from tmap.index.types import KNNGraph
+from tmap.index import KNNGraph
-knn = KNNGraph.from_arrays(indices, distances)
+knn = KNNGraph.from_arrays(indices, distances) # both shape (n, k); use -1 for missing neighbors
tree = tree_from_knn_graph(knn)
```
-That second path is the answer for USearch, Annoy, or any external neighbor search:
-convert the arrays into `KNNGraph`, then extract the tree with `tree_from_knn_graph`.
+To get a full map from those neighbors, pass the graph to the estimator instead: `TMAP().fit(knn_graph=knn)`.
---
@@ -91,7 +124,9 @@ At a high level:
3. Recover the returned MST edges as a `Tree`
4. Reattach edge weights from the original k-NN graph
-For duplicated directed edges such as `i -> j` and `j -> i`, the smaller observed weight is kept.
+For duplicated directed edges such as `i -> j` and `j -> i`, the smaller observed weight is kept. Self-matches, `-1` entries and non-finite distances are skipped.
+
+The optional `config` argument takes a `LayoutConfig`. You rarely need it: by default the function runs OGDF with the cheapest settings, since only the tree topology is used.
---
@@ -101,12 +136,12 @@ The result is a `Tree` object with:
```python
tree.n_nodes
-tree.edges
-tree.weights
+tree.edges # shape (n_edges, 2), int32
+tree.weights # shape (n_edges,), float32
tree.root
```
-`root` is chosen automatically from the highest-degree node in the extracted tree.
+`root` is chosen automatically as the node with the most edges in the extracted tree.
---
@@ -134,6 +169,8 @@ for node, parent, depth in tree.dfs():
print(node, parent, depth)
```
+Both start at `root` unless you pass `start=`.
+
### Children
```python
@@ -147,6 +184,8 @@ sizes = tree.subtree_sizes()
print(sizes[tree.root])
```
+`sizes[i]` is the number of nodes below `i` (itself included) when the tree hangs from `root`.
+
---
## Paths and Distances
@@ -162,39 +201,82 @@ path = tree.path(10, 42)
### Tree distance
```python
-distance = tree.distance(10, 42)
+distance = tree.distance(10, 42) # sum of edge weights along the path
+hops = tree.hops(10, 42) # number of edges along the path
```
### Distances from one source
```python
-distances = tree.distances_from(10)
+distances = tree.distances_from(10) # float32, one value per node
+hops = tree.hops_from(10) # int32, one value per node
```
-### Local subtree
+### Nearby nodes
```python
nearby = tree.subtree(10, depth=2)
```
+This returns every node within two edges of node 10, in any direction, closest first. With `depth=None` it returns the whole connected component.
+
These are useful for pseudotime, branch inspection, and neighborhood summaries.
---
+## Analysis
+
+The functions in `tmap.graph` take a tree plus one value or label per point:
+
+```python
+import numpy as np
+from tmap.graph import (
+ boundary_edges,
+ confusion_matrix_from_tree,
+ edge_delta,
+ node_diversity,
+ path_properties,
+ subtree_purity,
+)
+
+labels = np.asarray(cell_types) # one label per point
+values = np.asarray(molecular_weight) # one number per point
+
+cross = boundary_edges(tree, labels) # edges joining two different labels
+cmat, classes = confusion_matrix_from_tree(tree, labels)
+jumps = edge_delta(tree, values) # |value change| across each edge
+along = path_properties(tree, 10, 42, values) # values along the path from 10 to 42
+spread = node_diversity(tree, method="mean") # mean weight of each node's edges
+purity = subtree_purity(tree, labels, min_size=10) # NaN below min_size
+```
+
+A few ways to read them:
+
+- `len(cross) / len(tree.edges)` is the share of edges that cross a label boundary. A low number means the labels form clean branches.
+- `cmat[i, j]` counts the edges between points labeled `classes[i]` and `classes[j]`. Large off-diagonal counts show which groups touch each other on the tree.
+- Nodes with high `node_diversity` have long edges, so they tend to sit at the bridges between clusters.
+- `subtree_purity` is the share of each node's subtree that has its most common label, so it shows which branches belong to one group.
+
+---
+
## Disconnected Graphs
-If the k-NN graph has multiple components, the extracted tree will also have multiple components.
+When `k` is too small, the k-NN graph can fall apart into several pieces, and a minimum spanning tree of it is a forest.
-You can detect that with:
+The estimator handles this by default. With `connect_components=True`, `TMAP.fit` finds the pieces, adds the cheapest edges that join them, and warns you. Afterward, `model.n_components_` tells you how many pieces there were and `model.n_bridges_` how many edges it added. Pass `connect_components=False` to keep the forest.
+
+`tree_from_knn_graph` does not bridge anything. You can detect a forest with:
```python
n_components = tree.n_nodes - len(tree.edges)
```
+On a forest, `path`, `distance` and `hops` raise `IndexError` for points in different pieces, `distances_from` gives `inf` and `hops_from` gives `-1` for unreachable points, and `bfs`, `dfs` and `subtree_sizes` only cover the piece that contains their start node.
+
Common reasons:
- `k` is too small
-- `kc` is too small
+- `kc` is too small (LSHForest only)
- the data genuinely has separated groups
Possible responses:
@@ -244,7 +326,7 @@ fingerprints = (np.random.rand(1000, 2048) < 0.1).astype(np.uint8)
mh = MinHash(num_perm=128, seed=42)
signatures = mh.batch_from_binary_array(fingerprints)
-lsh = LSHForest(d=128, l=64)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(signatures)
lsh.index()
diff --git a/docs/index.md b/docs/index.md
index 55a712c..fb5584e 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -15,29 +15,33 @@ Most users only need one pattern:
- [Visualization Guide](visualization_guide.md)
Learn when to use notebook widgets, HTML export, and `serve()`.
- [API Reference](api_reference.md)
- Quick reference for `TMAP`, `TmapViz`, chemistry helpers, and layout functions.
+ Every public class and function: `TMAP`, `TmapViz`, the index and graph classes, layout functions, and the chemistry, protein and single-cell helpers.
## Choose Your API
### Estimator API
-Use `TMAP(...).fit(X)` when you want the simplest path.
+Use `TMAP(...).fit(X)` when you want the simplest path. After fitting, the same object answers tree queries (`path`, `distance`, `hops`, `distances_from`), places new data (`transform`, `add_points`), and saves itself (`save`, `TMAP.load`).
### Lower-level pipeline
-Use `MinHash`, `LSHForest`, `layout_from_lsh_forest`, and related functions when you want direct control over hashing, indexing, or graph construction.
+Use `MinHash`, `LSHForest`, `USearchIndex`, `layout_from_knn_graph` and related functions when you want direct control over hashing, indexing, or graph construction. [Notebook 12](../notebooks/12_lower_level_pipeline.ipynb) walks through it end to end.
## Quick Example
+Run this from the repository root:
+
```python
import pandas as pd
from tmap import TMAP
from tmap.utils import fingerprints_from_smiles
-df = pd.read_csv("../examples/cluster_65053.csv", nrows=3000)
+df = pd.read_csv("examples/cluster_65053.csv", nrows=3000)
smiles = df["smiles"].tolist()
-fps = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048)
+fps, valid = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048, return_valid=True)
+smiles = [smi for smi, ok in zip(smiles, valid) if ok]
+
model = TMAP(metric="jaccard", n_neighbors=20, seed=42).fit(fps)
viz = model.to_tmapviz()
@@ -46,28 +50,39 @@ viz.add_smiles(smiles)
viz.write_html("cluster_65053.html")
```
+`return_valid=True` drops SMILES that RDKit can't parse, so the SMILES list stays aligned with the fingerprints. In a script, put the code under `if __name__ == "__main__":`, because `fingerprints_from_smiles` starts worker processes.
+
## Supported Input Paths
| Input | Metric | Good for |
|-------|--------|----------|
| Binary matrix | `jaccard` | Molecular fingerprints and other 0/1 features |
+| Lists of feature indices, lists of strings, SciPy sparse matrix | `jaccard` | Sets of tokens, k-mers, very sparse features |
| Dense float matrix | `cosine` | Embeddings where direction matters |
| Dense float matrix | `euclidean` | Embeddings where magnitude matters |
| Distance matrix | `precomputed` | Distances you already computed elsewhere |
+| `KNNGraph` | `fit(knn_graph=...)` | Neighbors from FAISS, Annoy, alignment tools and so on |
+
+The first two rows use different search backends (USearch and MinHash + LSHForest). The [API reference](api_reference.md#input-routing) has the details.
## Choose The Right Output
| Goal | Method |
|------|--------|
-| Quick notebook exploration | `viz.to_widget(...)` or `model.plot(...)` |
+| Quick notebook exploration | `viz.show()` or `model.plot(...)` |
| Share one file | `viz.write_html(...)` or `model.to_html(...)` |
+| Host a large map on a web server | `viz.write_static(...)` |
| Browse a large map locally | `viz.serve(...)` or `model.serve(...)` |
+| Figure for a paper | `model.plot_static(...)` |
## Advanced Guides
- [MinHash Guide](minhash_guide.md)
- [LSHForest Guide](lshforest_guide.md)
+- [USearch Backend](usearch_backend.md)
- [Graph Guide](graph_guide.md)
- [Layout Guide](layout_guide.md)
-The files in `docs/` that are not linked here are planning notes or historical material and may not track the current public API line by line.
+## Notebooks
+
+The [`notebooks/`](../notebooks) folder has worked examples for cheminformatics, embeddings, single-cell data, proteins and the notebook widgets. The [README](../README.md#notebooks) lists them all.
diff --git a/docs/layout_guide.md b/docs/layout_guide.md
index ddc0b21..f4a1fd4 100644
--- a/docs/layout_guide.md
+++ b/docs/layout_guide.md
@@ -1,6 +1,6 @@
-# Understanding TMAP Layout: A Visual Guide
+# Understanding TMAP Layout
-This guide explains how TMAP creates tree visualizations from your data. Instead of diving into technical implementation details, we'll focus on **what each piece does** and **how parameters affect your visualization**.
+This guide explains how TMAP turns neighbors into a 2D tree, what each layout setting does, and which ones are worth changing. It stays at the level of what you see on the map; the OGDF internals are only mentioned where they explain a setting.
---
@@ -17,19 +17,21 @@ Think of it like creating a family tree, but for your data points based on their
```txt
Your Data (1000 molecules with 2048-bit fingerprints)
↓
- [Encoding] → Compact signatures
- ↓
- [Indexing] → Find similar neighbors
+ [Neighbor search] → Find the k most similar items for each point
↓
[Graph Building] → Connect neighbors
↓
- [Tree Extraction] → Keep essential connections
+ [Tree Extraction] → Keep the minimum spanning tree
+ ↓
+ [Layout] → Arrange the tree in 2D space
↓
- [Layout] → Arrange in 2D space
+ [Untangle] → Rotate small branches to remove edge crossings
↓
- Beautiful Tree Visualization
+ Tree map (x, y coordinates plus tree edges)
```
+The neighbor search depends on the input. `TMAP.fit` uses USearch for binary matrices and dense vectors, and MinHash + LSHForest for sets, strings and sparse matrices (see the [API reference](api_reference.md#input-routing)). Steps 1 to 3 below show the MinHash + LSHForest route through the lower-level API, because that is the route where you set the neighbor-search parameters by hand. From Step 4 on, everything applies to every input.
+
---
## Step 1: Encoding with MinHash
@@ -47,8 +49,8 @@ signatures = mh.batch_from_binary_array(fingerprints)
| Parameter | What it controls | Trade-off |
|-----------|-----------------|-----------|
-| `num_perm` | Signature size (default: 128) | Higher = more accurate similarity, but slower |
-| `seed` | Randomization seed | Set for reproducible results |
+| `num_perm` | Signature size (class default: 128; `TMAP` uses 512) | Higher = more accurate similarity, but slower |
+| `seed` | Permutation seed (class default: 1; `TMAP` uses `minhash_seed=42`) | The same seed always gives the same signatures |
### How to think about it
@@ -65,7 +67,7 @@ Imagine each molecule as a long barcode. MinHash creates a much shorter "summary
```python
from tmap import LSHForest
-lsh = LSHForest(d=128, l=64)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(signatures)
lsh.index()
```
@@ -74,14 +76,14 @@ lsh.index()
| Parameter | What it controls | Trade-off |
|-----------|-----------------|-----------|
-| `d` | Signature dimension (must match MinHash) | Must equal `num_perm` |
-| `l` | Number of "trees" in the forest | Higher = better recall, but more memory |
+| `d` | Signature dimension | Must equal `num_perm` |
+| `l` | Number of prefix trees in the forest (default: 8) | Higher = better recall, but more memory |
### How to think about it
-The LSH Forest is like a library catalog system. Instead of one index, it maintains multiple overlapping indexes (`l` of them). When searching for similar items, it checks all indexes and combines results. More indexes means fewer items slip through the cracks.
+The LSH Forest is like a library catalog that keeps `l` separate card indexes, each sorted by a different slice of the signature. A search looks in every index and pools what it finds. More indexes means fewer similar items slip through the cracks.
-**Rule of thumb:** Use `l=32` for small datasets (<10k), `l=64` for medium (10k-100k), `l=128` for large (>100k).
+**Rule of thumb:** `TMAP` uses `l = d // 4` (at least 8) for up to a million points, so `l=32` for `d=128` and `l=128` for `d=512`. That is a good starting point for the low-level API too.
---
@@ -89,14 +91,18 @@ The LSH Forest is like a library catalog system. Instead of one index, it mainta
**What it does:** For each item, finds its k most similar neighbors.
-This happens internally when you call `layout_from_lsh_forest`, controlled by two parameters:
+With the low-level API this happens inside `layout_from_lsh_forest`, controlled by two `LayoutConfig` fields:
```python
+from tmap.layout import LayoutConfig
+
cfg = LayoutConfig()
cfg.k = 20 # Number of neighbors to keep
cfg.kc = 50 # Search multiplier
```
+`cfg.k` and `cfg.kc` are only read by `layout_from_lsh_forest`. The estimator uses its own `n_neighbors` and `kc`, and `layout_from_knn_graph` takes the neighbors you give it.
+
### Parameters
| Parameter | What it controls | Trade-off |
@@ -106,9 +112,9 @@ cfg.kc = 50 # Search multiplier
### How to think about it
-Imagine you're at a party trying to find your 20 closest friends (`k=20`). You could ask everyone in the room, but that's slow. Instead, you ask around in your general social circle, checking maybe 1000 people (`k * kc = 20 * 50 = 1000`), and pick the 20 you're closest to.
+Imagine you're at a party trying to find your 20 closest friends (`k=20`). Asking everyone in the room would take all night. So you ask around your general social circle, check maybe 1000 people (`k * kc = 20 * 50 = 1000`), and pick the 20 you're closest to.
-**Why kc matters:** LSH is approximate. By searching more candidates (`k * kc`), we're more likely to find the true nearest neighbors, not just "pretty close" ones.
+**Why kc matters:** LSH is approximate. Checking more candidates (`k * kc`) makes it more likely that the true nearest neighbors are among them.
**Rule of thumb:**
@@ -126,9 +132,9 @@ The k-NN graph has many connections (each node connects to k neighbors). The MST
1. Connect all points
2. Minimize total "distance" (maximize similarity)
-### The Key Insight
+### Where the MST comes from
-The MST is computed by OGDF (the layout engine) on the **full k-NN graph**. This is important:
+The MST is computed by OGDF (the layout engine) on the **full k-NN graph**:
```
k-NN Graph (many edges) → MST (n-1 edges) → Tree Structure
@@ -137,34 +143,65 @@ k-NN Graph (many edges) → MST (n-1 edges) → Tree Structure
connections connected
```
-If your k-NN graph has disconnected clusters (some molecules have no path to others), the MST will also be disconnected. This shows up as a grid of isolated points in your visualization.
+If the k-NN graph falls apart into disconnected pieces (some molecules have no path to others), its MST is a forest, and each piece is laid out as a separate island.
+
+The estimator bridges the pieces for you. With the default `connect_components=True`, `TMAP.fit` adds the cheapest edges that join them into one tree and warns that it did so; `model.n_components_` and `model.n_bridges_` tell you how many pieces and bridges there were. The low-level `layout_from_*` functions leave the forest as it is.
-**To fix disconnected trees:**
+**To get fewer pieces in the first place:**
- Increase `k` (more neighbors)
-- Increase `kc` (better neighbor quality)
+- Increase `kc` (better neighbor quality, LSHForest only)
- Increase `l` in LSHForest (better recall)
---
## Step 5: Force-Directed Layout
-**What it does:** Arranges the tree in 2D space so it looks nice.
+**What it does:** Arranges the tree in 2D space so that branches are readable.
-This is where OGDF's magic happens. It uses physics simulation:
+OGDF runs a physics simulation:
- **Edges act like springs** (pull connected nodes together)
- **Nodes repel each other** (prevent overlap)
- **The system finds equilibrium** (balanced forces)
+It does this on several levels. The tree is first coarsened into smaller and smaller versions, the smallest one is laid out, and then each finer level starts from the coarser layout and relaxes again.
+
+### The adaptive layout (default)
+
+With `adaptive=True` (the default), TMAP sets the repulsion separately for each level. A level with `n` nodes gets a node size of
+
+```
+min(ns_cap, ns_coef / n ** ns_exp)
+```
+
+so small, coarse levels use `ns_cap`, and very large levels use a smaller size so that millions of points still fit. With the defaults (`ns_cap=0.03`, `ns_coef=2.5`, `ns_exp=0.4`), the cap applies to every level below roughly 60,000 nodes.
+
```python
cfg = LayoutConfig()
-cfg.fme_iterations = 1000 # Simulation steps
-cfg.node_size = 1/30 # Repulsion strength
-cfg.mmm_repeats = 2 # Refinement passes
+cfg.fme_iterations = 1000 # Simulation steps per level
+cfg.ns_cap = 0.03 # Spread
```
-### Layout Parameters Explained
+#### `ns_cap` (default: 0.03)
+
+**The main spread knob.**
+
+| Value | What the map looks like |
+|-------|--------|
+| 0.01 | A few long branches with open space between them. Easy to follow individual branches |
+| 0.03 | Default. Branches fill a disc evenly |
+| 0.1 | Fills the disc even more evenly, with short, bushy branches |
+
+These descriptions come from a 10,000-molecule map; the exact look depends on your data, so try two or three values.
+
+#### `ns_coef` and `ns_exp` (defaults: 2.5 and 0.4)
+
+Control how fast the node size shrinks on large levels. They matter mostly above about 60,000 points. Leave them alone unless a very large map looks crowded or too sparse at the finest level.
+
+#### `quad_rotate` (default: True)
+
+Rotates the simulation frame at each level. Without it, a faint cross can show up through the center of the map.
#### `fme_iterations` (default: 1000)
@@ -176,42 +213,41 @@ cfg.mmm_repeats = 2 # Refinement passes
| 1000 | Default. Good balance. |
| 2000-5000 | Smoother, more refined. Takes longer. |
-Think of it like shaking a box of magnets. More iterations = more time to settle into a stable arrangement.
+Think of it like shaking a box of magnets. More iterations = more time to settle into a stable arrangement. The estimator sets this from `layout_iterations` unless you pass your own `layout_config`.
-#### `node_size` (default: 1/65 ≈ 0.015)
+### The legacy layout (`adaptive=False`)
-**How much nodes repel each other**
+`adaptive=False` switches to the older single-pass multilevel layout from the original TMAP. In this mode two other fields take over, and they are ignored in adaptive mode:
-| Value | Effect |
-|-------|--------|
-| 1/100 (0.01) | Compact, tight clusters |
-| 1/65 (0.015) | Default, balanced |
-| 1/30 (0.033) | Spread out, more space between branches |
-| 1/10 (0.1) | Very spread out |
+- `node_size` (default 1/65): one repulsion size for all levels. Larger values spread the tree out more.
+- `mmm_repeats` (default 1): how many times each level is refined.
-Larger values = nodes push each other away more = more spread out tree.
+Use this mode if you want maps closer to the look of the original TMAP.
-#### `mmm_repeats` (default: 1)
+---
-**Multilevel refinement passes**
+## Step 6: Untangle
-The layout algorithm works in levels:
+**What it does:** Removes edge crossings after the layout is done.
-1. Coarsen (simplify) the graph
-2. Layout the simplified version
-3. Expand back and refine
+A force-directed layout usually leaves some branches lying across each other. The untangle pass (`untangle=True` by default) goes through the subtrees of the finished tree, smallest first, and tries turning each one rigidly around the point where it attaches to its parent. It keeps a move only if the total number of crossing tree edges goes down. Edge lengths don't change, and the pass uses no randomness, so the same layout always untangles the same way.
-More repeats = more refinement at each level = smoother result.
+| Field | Default | What it does |
+|-------|---------|--------------|
+| `untangle` | `True` | Turn the pass on or off |
+| `untangle_mode` | `UntangleMode.Rotate` | `Rotate` tries rotations; `Reflect` only mirrors each subtree across the line from its parent |
+| `untangle_max_sub` | 2000 | Largest subtree (in points) that may be moved. `0` means no limit |
+| `untangle_max_angle` | 90 | Largest turn in degrees. `0` means no limit |
+| `untangle_rot_steps` | 64 | Rotation angles tried per subtree, spread around the full circle |
+| `untangle_passes` | 4 | Sweeps over all subtrees. Stops early when a sweep changes nothing |
+| `untangle_slide_eps` | 0.0 | Lets a subtree also slide along its stem by up to this fraction of the stem length. `0` keeps edge lengths exact |
+| `untangle_slide_steps` | 5 | Slide positions tried when `untangle_slide_eps > 0` |
-| Value | Effect |
-|-------|--------|
-| 1 | Fast, good enough for most cases |
-| 2 | Noticeably smoother |
-| 3+ | Diminishing returns, mostly for very large graphs |
+Because it counts crossings only, the pass will sometimes swing a large branch to a spot with fewer crossings that looks worse, for example out to the edge of the map. If that happens, lower `untangle_max_sub` or set `untangle=False`. [`examples/layout/untangle_demo.py`](../examples/layout/untangle_demo.py) shows the pass on and off side by side.
---
-## Step 6: Scaling and Final Touches
+## Step 7: Scaling and Final Touches
### `sl_scaling_type`
@@ -221,12 +257,17 @@ More repeats = more refinement at each level = smoother result.
|------|-------------|
| `RelativeToDrawing` (default) | Most cases. Scales based on current drawing. |
| `RelativeToAvgLength` | When edge weights vary a lot. Respects average edge length. |
-| `Absolute` | When you need exact control over scale. |
+| `RelativeToDesiredLength` | Scales relative to the desired edge length. |
+| `Absolute` | Fixed scaling factors (`sl_scaling_min`, `sl_scaling_max`). |
#### `sl_extra_scaling_steps` (default: 2)
Additional refinement steps for scaling. Higher = smoother scaling transitions.
+### Output coordinates
+
+The final `x` and `y` are each rescaled to [-0.5, 0.5] on their own, so the returned layout always fills a square. The original aspect ratio is not kept.
+
---
## Advanced: Placer and Merger
@@ -242,7 +283,7 @@ These control the multilevel algorithm's internal behavior.
| `Median` | Median of neighbors | Outlier-resistant |
| `Circle` | Circle around neighbors | Spreading out |
| `Solar` | Solar system arrangement | Hierarchical data |
-| `Random` | Random placement | Exploration (non-deterministic!) |
+| `Random` | Random placement | Exploration. Still reproducible with `deterministic=True` and a seed |
### Merger (how to simplify the graph)
@@ -253,34 +294,61 @@ These control the multilevel algorithm's internal behavior.
| `Solar` | Sun/planet hierarchy | Hierarchical data |
| `IndependentSet` | GRIP-style | Very large graphs |
+`merger_factor` (default 2.0) sets how much each coarsening step shrinks the graph for `EdgeCover` and `LocalBiconnected`, and the search depth for `IndependentSet`. `Solar` ignores it.
+
**Rule of thumb:** Stick with defaults (`Barycenter` + `LocalBiconnected`) unless you have a specific reason to change.
---
+## Using a LayoutConfig with the estimator
+
+Pass a config to `TMAP` to change the layout while keeping the high-level API:
+
+```python
+from tmap import TMAP
+from tmap.layout import LayoutConfig
+
+cfg = LayoutConfig()
+cfg.ns_cap = 0.015
+cfg.untangle_max_sub = 500
+
+model = TMAP(metric="cosine", layout_config=cfg).fit(X)
+```
+
+A few things to know:
+
+- The estimator sets `cfg.deterministic = True` and `cfg.seed` to its own `seed`, on the object you passed. Everything else you set is kept.
+- `layout_iterations` is ignored when you pass a config; set `cfg.fme_iterations` instead.
+- `cfg.k` and `cfg.kc` are ignored; use `n_neighbors` and `kc` on `TMAP`.
+
+---
+
+## Reproducible Layouts
+
+The layout is reproducible when `deterministic=True` and `seed` is set. `deterministic=True` runs the simulation on one thread with a seeded random generator. Without it, the simulation uses all cores and each run comes out a little different, even with a seed. With `deterministic=True` and no seed, the seed is 0.
+
+The estimator always uses a deterministic, seeded layout. If two estimator runs on the same data still give different maps, the difference comes from the neighbor search: the HNSW index is built on several threads. Pass `reproducible=True` to `TMAP` to build it on one thread.
+
+---
+
## Putting It All Together
-Here's the recommended setup for different scenarios:
+Starting points for common situations:
### Quick Exploration
```python
cfg = LayoutConfig()
-cfg.k = 10
-cfg.kc = 20
cfg.fme_iterations = 500
+cfg.untangle = False
```
-### Publication Quality
+### Clear Branches For Figures
```python
cfg = LayoutConfig()
-cfg.k = 30
-cfg.kc = 100
-cfg.node_size = 1/30
-cfg.mmm_repeats = 2
-cfg.sl_extra_scaling_steps = 10
-cfg.sl_scaling_type = ScalingType.RelativeToAvgLength
-cfg.fme_iterations = 1000
+cfg.ns_cap = 0.015 # longer branches with more space between them
+cfg.fme_iterations = 2000
cfg.deterministic = True
cfg.seed = 42
```
@@ -289,42 +357,49 @@ cfg.seed = 42
```python
cfg = LayoutConfig()
-cfg.k = 20
-cfg.kc = 50
-cfg.fme_iterations = 500 # Lower for speed
-cfg.mmm_repeats = 1
-cfg.merger = Merger.IndependentSet # Better for large graphs
+cfg.fme_iterations = 500 # Lower for speed
+cfg.merger = Merger.IndependentSet # Worth trying on large graphs
```
+`Merger` comes from `tmap.layout`, like `LayoutConfig`.
+
---
## Common Issues and Fixes
-### Problem: Disconnected points (grid of dots)
+### Problem: Separate islands instead of one tree
**Cause:** The k-NN graph has disconnected components.
**Fixes:**
-1. Increase `k` (more neighbors per point)
-2. Increase `kc` (better quality neighbors)
-3. Increase `l` in LSHForest (better recall)
-4. Check if your data naturally has isolated clusters
+1. With the estimator, keep `connect_components=True` (the default) and check `model.n_components_`
+2. Increase `k` (more neighbors per point)
+3. Increase `kc` (better quality neighbors, LSHForest only)
+4. Increase `l` in LSHForest (better recall)
+5. Check if your data naturally has isolated clusters
-### Problem: Tree looks too compact/cluttered
+### Problem: Tree looks too compact or cluttered
**Fixes:**
-1. Increase `node_size` (e.g., from 1/65 to 1/30)
-2. Increase `sl_extra_scaling_steps`
-3. Increase `fme_iterations`
+1. Lower `ns_cap` (e.g., from 0.03 to 0.015) to get fewer, longer branches with more space around them
+2. Increase `fme_iterations`
-### Problem: Tree looks too spread out
+### Problem: Tree looks too sparse, with lots of empty space
**Fixes:**
-1. Decrease `node_size` (e.g., from 1/65 to 1/100)
-2. Use `ScalingType.RelativeToDrawing`
+1. Raise `ns_cap` (e.g., from 0.03 to 0.05)
+
+### Problem: A big branch jumped to a strange place
+
+**Cause:** The untangle pass moved it to reduce crossings.
+
+**Fixes:**
+
+1. Lower `untangle_max_sub` so only smaller subtrees can move
+2. Set `untangle = False`
### Problem: Layout changes each run
@@ -335,14 +410,15 @@ cfg.deterministic = True
cfg.seed = 42 # Any fixed number
```
+With the estimator, the layout is already deterministic; pass `reproducible=True` to `TMAP` to make the neighbor search deterministic too.
+
### Problem: Layout takes too long
**Fixes:**
1. Decrease `fme_iterations` (e.g., 500 instead of 1000)
-2. Decrease `mmm_repeats` to 1
+2. Set `untangle = False`
3. Decrease `k` and `kc`
-4. Use `l=32` in LSHForest
---
@@ -351,7 +427,7 @@ cfg.seed = 42 # Any fixed number
```python
import numpy as np
from tmap import MinHash, LSHForest
-from tmap.layout import layout_from_lsh_forest, LayoutConfig, ScalingType
+from tmap.layout import layout_from_lsh_forest, LayoutConfig
# Your data: binary fingerprints (n_samples x n_bits)
fingerprints = load_your_data() # shape: (1000, 2048)
@@ -361,16 +437,14 @@ mh = MinHash(num_perm=128, seed=42)
signatures = mh.batch_from_binary_array(fingerprints)
# Step 2: Index
-lsh = LSHForest(d=128, l=64)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(signatures)
lsh.index()
-# Step 3-6: Layout (all in one call!)
+# Steps 3 to 7: neighbors, tree, layout and untangle in one call
cfg = LayoutConfig()
cfg.k = 20
cfg.kc = 50
-cfg.node_size = 1/30
-cfg.mmm_repeats = 2
cfg.deterministic = True
cfg.seed = 42
@@ -385,31 +459,45 @@ print(f"Laid out {len(x)} points with {len(s)} edges")
## Parameter Reference Card
-| Parameter | Default | Range | Effect |
-|-----------|---------|-------|--------|
-| **k** | 10 | 5-100 | Neighbors per point. Higher = denser graph. |
-| **kc** | 10 | 10-100 | Search depth. Higher = better neighbors. |
-| **fme_iterations** | 1000 | 100-5000 | Simulation steps. Higher = smoother. |
-| **node_size** | 1/65 | 0.001-0.1 | Repulsion. Higher = more spread. |
-| **mmm_repeats** | 1 | 1-3 | Refinement passes. Higher = smoother. |
-| **sl_extra_scaling_steps** | 2 | 0-20 | Scaling refinement. Higher = smoother. |
-| **merger_factor** | 2.0 | 1.5-4.0 | Coarsening aggressiveness. |
+| Parameter | Default | Effect |
+|-----------|---------|--------|
+| **k** | 10 | Neighbors per point (`layout_from_lsh_forest` only) |
+| **kc** | 10 | Search depth (`layout_from_lsh_forest` only) |
+| **fme_iterations** | 1000 | Simulation steps. Higher = smoother |
+| **fme_precision** | 4 | Accuracy of the multipole approximation of repulsion |
+| **adaptive** | True | Per-level node size. `False` = legacy layout |
+| **ns_cap** | 0.03 | Spread (adaptive mode). Lower = longer, more separated branches |
+| **ns_coef** | 2.5 | Node-size coefficient for large levels (adaptive mode) |
+| **ns_exp** | 0.4 | Node-size exponent for large levels (adaptive mode) |
+| **quad_rotate** | True | Rotate the frame per level to avoid a central cross (adaptive mode) |
+| **node_size** | 1/65 | Repulsion (legacy mode only) |
+| **mmm_repeats** | 1 | Refinement passes (legacy mode only) |
+| **sl_repeats** | 1 | Scaling layout repeats |
+| **sl_extra_scaling_steps** | 2 | Scaling refinement. Higher = smoother |
+| **sl_scaling_type** | RelativeToDrawing | How scaling is measured |
+| **sl_scaling_min / sl_scaling_max** | 1.0 / 1.0 | Scaling range |
+| **placer** | Barycenter | Where nodes go when a level is expanded |
+| **merger** | LocalBiconnected | How the graph is coarsened |
+| **merger_factor** | 2.0 | Coarsening step size (see Merger above) |
+| **merger_adjustment** | 0 | Edge length adjustment when merging |
+| **untangle** | True | Crossing-reduction pass (see Step 6 for its other fields) |
+| **deterministic** | False | One thread, seeded random generator. The estimator sets it to True |
+| **seed** | None | Random seed. The estimator sets it to its own `seed` |
---
## Next Steps
-- Try the example script: `examples/chemistry/smiles_tmap.py`
-- Experiment with parameters on your data
+- Run the lower-level pipeline end to end in [notebook 12](../notebooks/12_lower_level_pipeline.ipynb)
+- Compare untangle on and off with `examples/layout/untangle_demo.py`
+- Experiment with `ns_cap` on your data
- Check `TmapViz` for interactive visualization options
---
## Related Documentation
-- [MinHash Guide](minhash_guide.md) - Data encoding with MinHash signatures
-- [LSHForest Guide](lshforest_guide.md) - Building the LSH index and k-NN graphs
-- [Graph Guide](graph_guide.md) - MST extraction and Tree traversal
-- [API Reference](api_reference.md) - Quick reference for all functions
-
-Happy mapping!
+- [MinHash Guide](minhash_guide.md): data encoding with MinHash signatures
+- [LSHForest Guide](lshforest_guide.md): building the LSH index and k-NN graphs
+- [Graph Guide](graph_guide.md): MST extraction and Tree traversal
+- [API Reference](api_reference.md): quick reference for all functions
diff --git a/docs/lshforest_guide.md b/docs/lshforest_guide.md
index 62d6e9e..143108e 100644
--- a/docs/lshforest_guide.md
+++ b/docs/lshforest_guide.md
@@ -8,7 +8,9 @@ This guide explains how LSH Forest works in TMAP and helps you choose the right
LSH Forest is an **index structure** for fast approximate nearest neighbor search. It takes MinHash signatures and enables rapid similarity queries.
-**The key insight:** Instead of comparing every item to every other item (O(n²)), LSH Forest uses sorted MinHash prefixes to find likely neighbors efficiently.
+Comparing every item with every other item takes O(n²) time. LSH Forest sorts slices of the MinHash signatures so that likely neighbors end up next to each other, and then only compares those.
+
+**When TMAP uses it:** `TMAP(metric="jaccard").fit(X)` builds an LSH Forest for lists of feature indices, lists of string tokens and SciPy sparse matrices. Dense 0/1 matrices go to USearch instead (see the [USearch guide](usearch_backend.md)). The estimator picks `l` itself and uses its own `n_permutations` (512) and `kc` (50); after fitting, the forest is available as `model.lsh_forest_`. This guide covers using the class directly.
```txt
MinHash Signatures
@@ -30,7 +32,7 @@ mh = MinHash(num_perm=128, seed=42)
signatures = mh.batch_from_binary_array(fingerprints)
# 2. Build the index
-lsh = LSHForest(d=128, l=16) # d must match num_perm
+lsh = LSHForest(d=128, l=32) # d must match num_perm
lsh.batch_add(signatures)
lsh.index() # Don't forget this!
@@ -54,17 +56,17 @@ Think of LSH Forest as maintaining several sorted indexes over different parts o
```txt
Signature (128 values)
↓
-Split into l=16 bands (8 values each)
+Split into l=32 bands (4 values each)
↓
-Tree 0: sort values 0..7
-Tree 1: sort values 8..15
-Tree 2: sort values 16..23
+Tree 0: sort values 0..3
+Tree 1: sort values 4..7
+Tree 2: sort values 8..11
...
↓
-Query: try prefix lengths 8, 7, ... 1 until enough candidates exist
+Query: try prefix lengths 4, 3, 2, 1 until enough candidates exist
```
-**Why adaptive prefixes?** A strict eight-value collision is often too rare. Backoff preserves selective matches when they exist but still returns useful candidates for moderately similar data.
+**Why adaptive prefixes?** A strict full-band collision is often too rare. Backoff preserves selective matches when they exist but still returns useful candidates for moderately similar data.
---
@@ -85,26 +87,28 @@ Controls the **recall vs speed** tradeoff.
| Configuration | Band width | Tradeoff |
|---------------|------------|----------|
-| `d=128, l=8` | 16 | Legacy TMAP default; lowest index memory |
-| `d=128, l=16` | 8 | Good compatibility/quality starting point |
-| `d=128, l=32` | 4 | More trees and memory; useful for difficult set data |
+| `d=128, l=8` | 16 | Constructor default (`l=None` means `min(8, d)`); lowest index memory |
+| `d=128, l=16` | 8 | Fewer trees, less memory |
+| `d=128, l=32` | 4 | What `TMAP` picks for up to a million points |
| `d=128, l=64` | 2 | Aggressive, usually unnecessary with prefix backoff |
-**Rule of thumb:** Start with `l=d//8` and tune `kc` first. More trees consume memory linearly and are no longer required merely to avoid empty exact-band buckets.
+**Rule of thumb:** Start with `l=d//4`, the same band width of 4 that `TMAP` uses (it was the best setting on 100k molecules), and tune `kc` next. Memory grows linearly with `l`. Above a million points `TMAP` widens the bands gradually (width 5 at about 2M points, 6 at about 4M).
+
+If `d` is not a multiple of `l`, the last `d % l` values of each signature are not indexed. For example, `d=128, l=48` gives bands of 2 values and leaves 32 values out.
```python
# For a 50k molecule dataset
-lsh = LSHForest(d=128, l=16)
+lsh = LSHForest(d=128, l=32)
```
### `store` - Signature Storage
-Controls whether signature-dependent refinement and inspection methods are exposed. Adaptive prefix lookup itself must retain the indexed band values, so `store=False` no longer removes the core signature memory.
+Controls whether the methods that look up signatures by ID are available. The prefix search keeps the band values either way, so `store=False` saves no memory.
| Value | Capabilities |
|-------|--------------|
| `True` (default) | Full functionality: queries, distances, k-NN graph |
-| `False` | Prefix queries only; no linear scan, distances, or k-NN graph |
+| `False` | `query(signature, k)` only |
```python
# Prefix candidate queries only
@@ -114,7 +118,7 @@ lsh = LSHForest(d=128, store=False)
lsh = LSHForest(d=128, store=True)
```
-**Note:** `store=False` disables `get_knn_graph()`, `linear_scan()`, `get_distance_by_id()`, etc.
+**Note:** With `store=False`, `get_knn_graph()`, `query_by_id()`, `query_linear_scan()`, `query_linear_scan_by_id()`, `query_external_batch()`, `linear_scan()`, `get_distance_by_id()`, `get_all_distances()` and `get_hash()` all raise `ValueError`.
### `weighted` - Weighted MinHash Support
@@ -134,19 +138,21 @@ lsh = LSHForest(d=128, weighted=True)
## Query Methods: Which One to Use?
-LSH Forest provides multiple query methods. Here's when to use each:
+Which query method to use depends on whether the point is already in the index and whether you need distances.
### Decision Tree
```txt
What do you need?
│
-├─ k-NN graph of ALL points → get_knn_graph() ⭐ MAIN METHOD
+├─ k-NN graph of ALL points → get_knn_graph() (main method)
│
├─ Query a NEW point (not in index)?
│ │
│ ├─ Need accurate distances? → query_linear_scan()
│ │
+│ ├─ Many new points at once? → query_external_batch()
+│ │
│ └─ Just need candidates? → query()
│
└─ Query an EXISTING point (by ID)?
@@ -163,15 +169,16 @@ What do you need?
| `get_knn_graph(k, kc)` | KNNGraph | High | Fast | **Build TMAP layout** |
| `query_linear_scan(sig, k, kc)` | [(dist, idx), ...] | High | Medium | Query new point |
| `query_linear_scan_by_id(id, k, kc)` | [(dist, idx), ...] | High | Medium | Query existing point |
-| `query(sig, k)` | [idx, ...] | Low | Fast | Get candidates only |
-| `query_by_id(id, k)` | [idx, ...] | Low | Fast | Get candidates only |
+| `query_external_batch(sigs, k, kc)` | (indices, distances) | High | Fast | Query many new points |
+| `query(sig, k)` | int32 array | Low | Fast | Get candidates only |
+| `query_by_id(id, k)` | int32 array | Low | Fast | Get candidates only (includes the point itself) |
| `linear_scan(sig, indices, k)` | [(dist, idx), ...] | Exact | Varies | Refine candidates |
---
## Method Details
-### `get_knn_graph(k, kc)` - The Primary Method
+### `get_knn_graph(k, kc)`: The Primary Method
**Use this for building TMAP visualizations.**
@@ -197,7 +204,7 @@ print(f"Each point has up to {knn.k} neighbors")
---
-### `query_linear_scan(signature, k, kc)` - Query New Point
+### `query_linear_scan(signature, k, kc)`: Query New Point
**For querying a point not in the index.**
@@ -219,9 +226,11 @@ for distance, idx in neighbors:
2. Linear scan computes exact distances to candidates
3. Returns best `k` sorted by distance
+For many new points, `query_external_batch(signatures, k, kc)` does the same in one call and returns `(indices, distances)` arrays of shape `(m, k)`, padded with `-1` and `inf` where fewer than `k` neighbors were found. `TMAP.transform()` and `add_points()` use it on this path.
+
---
-### `query_linear_scan_by_id(id, k, kc)` - Query Existing Point
+### `query_linear_scan_by_id(id, k, kc)`: Query Existing Point
**For querying a point that's already indexed.**
@@ -236,7 +245,7 @@ for distance, idx in neighbors:
---
-### `query(signature, k)` - Fast Approximate Query
+### `query(signature, k)`: Fast Approximate Query
**For getting candidate indices without distance computation.**
@@ -246,11 +255,11 @@ candidates = lsh.query(signature, k=100)
print(f"Found {len(candidates)} candidates")
```
-**Note:** Results are not sorted by distance. Use `linear_scan()` to refine.
+**Note:** Results come back as an int32 array, not sorted by distance. Use `linear_scan()` to refine. `query_by_id()` works the same way for an indexed point, and the point itself is among its results.
---
-### `linear_scan(signature, indices, k)` - Refine Candidates
+### `linear_scan(signature, indices, k)`: Refine Candidates
**For computing exact distances on a subset.**
@@ -278,14 +287,14 @@ How many neighbors to keep per point.
| k | Effect | Use Case |
|---|--------|----------|
| 5-10 | Sparse graph, may disconnect | Quick exploration |
-| 20-30 | **Good connectivity** | Most cases |
+| 20-30 | Good connectivity | Most cases |
| 50-100 | Very dense graph | When connectivity is critical |
-**Tip:** If your TMAP shows disconnected clusters (grid of dots), increase `k`.
+**Tip:** If your map falls apart into separate islands, increase `k` or `kc`. `TMAP` itself joins the pieces with bridging edges by default (`connect_components=True`) and reports how many there were in `model.n_components_`; the low-level `layout_from_lsh_forest` leaves them separate.
### `kc` - Search Quality Multiplier
-How many candidates to consider before keeping best `k`.
+How many candidates to consider before keeping best `k`. Every `LSHForest` method defaults to `kc=10`; `TMAP` uses `kc=50`. The candidate count `k * kc` is capped at the number of indexed points.
| kc | Candidates Searched | Quality | Speed |
|----|---------------------|---------|-------|
@@ -359,7 +368,7 @@ knn = lsh.get_knn_graph(k=20, kc=50)
```python
# Build index (expensive)
-lsh = LSHForest(d=128, l=16)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(all_signatures)
lsh.index()
lsh.save("index.pkl")
@@ -373,7 +382,7 @@ knn = lsh.get_knn_graph(k=20, kc=50)
```python
# Initial index
-lsh = LSHForest(d=128, l=16)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(initial_signatures)
lsh.index()
@@ -389,7 +398,7 @@ knn = lsh.get_knn_graph(k=20, kc=50)
```python
# Build index of known compounds
-lsh = LSHForest(d=128, l=16)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(known_signatures)
lsh.index()
@@ -405,29 +414,29 @@ neighbors = lsh.query_linear_scan(new_sig, k=10, kc=50)
### 1. Forgetting to Call `index()`
```python
-# ❌ WRONG - index() not called
+# Wrong: index() not called
lsh = LSHForest(d=128)
lsh.batch_add(signatures)
-knn = lsh.get_knn_graph(k=20, kc=50) # RuntimeError!
+knn = lsh.get_knn_graph(k=20, kc=50) # RuntimeError
-# ✓ Correct
+# Right
lsh = LSHForest(d=128)
lsh.batch_add(signatures)
-lsh.index() # Don't forget!
+lsh.index()
knn = lsh.get_knn_graph(k=20, kc=50)
```
### 2. Mismatched Dimensions
```python
-# ❌ WRONG - d doesn't match signature dimension
+# Wrong: d doesn't match the signature dimension
mh = MinHash(num_perm=128)
signatures = mh.batch_from_binary_array(fps) # Shape: (n, 128)
-lsh = LSHForest(d=64) # Wrong! Should be 128
-lsh.batch_add(signatures) # ValueError!
+lsh = LSHForest(d=64) # should be 128
+lsh.batch_add(signatures) # ValueError
-# ✓ Correct
+# Right
lsh = LSHForest(d=128) # Match num_perm
```
@@ -443,30 +452,32 @@ lsh.index()
assert lsh.is_clean # Now it's clean
```
+Querying a stale index does not raise. `get_knn_graph()` and the other queries quietly answer from the old index, so points added since the last `index()` are missing from the results.
+
### 4. Using store=False Then Expecting Full Functionality
```python
-# ❌ WRONG - store=False limits functionality
+# Wrong: store=False limits functionality
lsh = LSHForest(d=128, store=False)
lsh.batch_add(signatures)
lsh.index()
-knn = lsh.get_knn_graph(k=20, kc=50) # ValueError!
+knn = lsh.get_knn_graph(k=20, kc=50) # ValueError
-# ✓ If you need k-NN graph, use store=True (default)
+# Right: if you need a k-NN graph, use store=True (the default)
lsh = LSHForest(d=128, store=True)
```
### 5. Mixing Regular and Weighted Signatures
```python
-# ❌ WRONG - weighted mode mismatch
+# Wrong: weighted mode mismatch
wmh = WeightedMinHash(dim=100, num_perm=128)
-sigs = wmh.batch_from_weight_array(weights) # Shape: (n, 128, 2)
+sigs = wmh.batch_from_weight_array(weights, n_jobs=1) # Shape: (n, 128, 2)
-lsh = LSHForest(d=128, weighted=False) # Wrong!
-lsh.batch_add(sigs) # ValueError!
+lsh = LSHForest(d=128, weighted=False) # should be weighted=True
+lsh.batch_add(sigs) # ValueError
-# ✓ Correct
+# Right
lsh = LSHForest(d=128, weighted=True)
```
@@ -490,11 +501,10 @@ print(knn.distances.shape) # (n_nodes, k)
# Access neighbors of point 0
point_0_neighbors = knn.indices[0]
point_0_distances = knn.distances[0]
-
-# Convert to edge list (for debugging/export)
-edge_list = knn.to_edge_list()
```
+To get a tree from it, use `tmap.graph.tree_from_knn_graph(knn)`; to lay it out, use `tmap.layout.layout_from_knn_graph(knn)`; or pass it to `TMAP().fit(knn_graph=knn)` for a full map.
+
**Special values:**
- `indices[i, j] == -1`: No valid neighbor (sparse)
- `distances[i, j] >= 2.0`: Invalid distance marker
@@ -506,11 +516,11 @@ edge_list = knn.to_edge_list()
### 1. Batch Add Is Faster
```python
-# ⚡ Fast
+# Fast
lsh.batch_add(all_signatures)
lsh.index()
-# 🐌 Slow
+# Slow
for sig in all_signatures:
lsh.add(sig)
lsh.index()
@@ -519,7 +529,7 @@ lsh.index()
### 2. Index Once, Query Many
```python
-# ⚡ Index once
+# Index once
lsh.index()
# Can query many times without re-indexing
@@ -531,8 +541,8 @@ knn3 = lsh.get_knn_graph(k=30, kc=100)
### 3. Tune Candidate Budget Before Adding Trees
```python
-# Compatibility-oriented starting point
-lsh = LSHForest(d=128, l=16)
+# Same band width as TMAP
+lsh = LSHForest(d=128, l=32)
# Search more candidates before increasing index memory
knn = lsh.get_knn_graph(k=20, kc=100)
@@ -557,7 +567,7 @@ mh = MinHash(num_perm=128, seed=42)
signatures = mh.batch_from_binary_array(fps)
# 3. Build LSH Forest
-lsh = LSHForest(d=128, l=16)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(signatures)
lsh.index()
@@ -573,6 +583,8 @@ print(f"k-NN graph: {knn.n_nodes} nodes, {knn.k} neighbors each")
cfg = LayoutConfig()
cfg.k = 20
cfg.kc = 50
+cfg.deterministic = True # same coordinates on every run
+cfg.seed = 42
x, y, s, t = layout_from_lsh_forest(lsh, cfg)
print(f"Layout complete: {len(x)} points, {len(s)} edges")
@@ -587,4 +599,4 @@ lsh.save("molecular_index.pkl")
- See [MinHash Guide](minhash_guide.md) for encoding options
- See [Layout Guide](layout_guide.md) for visualization parameters
-- Try the example: `examples/chemistry/smiles_tmap.py`
+- Run the lower-level pipeline end to end in [notebook 12](../notebooks/12_lower_level_pipeline.ipynb)
diff --git a/docs/minhash_guide.md b/docs/minhash_guide.md
index 06a2a27..1dd3c2d 100644
--- a/docs/minhash_guide.md
+++ b/docs/minhash_guide.md
@@ -2,13 +2,15 @@
This guide explains how MinHash encoding works in TMAP and helps you choose the right method for your data.
+**When TMAP uses MinHash:** `TMAP(metric="jaccard").fit(X)` sends a dense 0/1 matrix (such as Morgan fingerprints) to USearch, which compares the raw bits and skips MinHash entirely (see the [USearch guide](usearch_backend.md)). MinHash + LSHForest is used for lists of feature indices, lists of string tokens, and SciPy sparse matrices. The estimator then encodes with 512 permutations and `minhash_seed=42`. Everything below is about the lower-level `MinHash` class, which you can use directly on any of these inputs.
+
---
## What MinHash Does
MinHash is a **locality-sensitive hashing** technique that compresses your data into compact "signatures" while preserving similarity information.
-**The key insight:** If two items are similar (high Jaccard similarity), their MinHash signatures will also be similar.
+If two items are similar (high Jaccard similarity), their MinHash signatures are similar too.
```txt
Your Data (2048-bit fingerprint)
@@ -18,11 +20,12 @@ Your Data (2048-bit fingerprint)
Compact Signature (128 values)
```
-This compression is essential for TMAP because:
+TMAP uses this compression because:
+
+1. **Fixed length**: every item becomes the same number of values, whether it has five elements or five thousand. Sets of tokens and sparse features can't be packed into a fixed bit vector, so this is what makes them searchable.
+2. **Indexing**: LSH Forest indexes these signatures, so similar items can be found without comparing every pair.
-1. **Speed**: Comparing 128 values is faster than comparing 2048 bits
-2. **Indexing**: LSH Forest can efficiently index these signatures
-3. **Scalability**: Smaller signatures = less memory for millions of points
+A signature takes 8 bytes per permutation (1 KB at 128 permutations), which is more than a bit-packed 2048-bit fingerprint (256 bytes). For dense fingerprints, compression is not the reason to use MinHash.
---
@@ -40,7 +43,7 @@ signatures = mh.batch_from_binary_array(fingerprints)
# Now use with LSHForest
from tmap import LSHForest
-lsh = LSHForest(d=128, l=64)
+lsh = LSHForest(d=128, l=32)
lsh.batch_add(signatures)
lsh.index()
```
@@ -49,7 +52,7 @@ lsh.index()
## Choosing the Right Method
-TMAP's MinHash provides multiple encoding methods. Here's when to use each:
+`MinHash` has one encoding method per input type, each in a single-item and a batch version.
### Decision Tree
@@ -60,7 +63,7 @@ What type of data do you have?
│ │
│ ├─ One fingerprint at a time? → from_binary_array()
│ │
-│ └─ Many fingerprints? → batch_from_binary_array() ⭐ RECOMMENDED
+│ └─ Many fingerprints? → batch_from_binary_array() (most common)
│
├─ Sparse indices (list of "on" positions)?
│ │
@@ -79,23 +82,23 @@ What type of data do you have?
### Method Comparison
-| Method | Input | Backend | Speed | When to Use |
-|--------|-------|---------|-------|-------------|
-| `batch_from_binary_array()` | 2D array (n, bits) | Numba | ⚡⚡⚡ | **Most cases** - many fingerprints |
-| `from_binary_array()` | 1D array (bits,) | Numba | ⚡⚡⚡ | Single fingerprint |
-| `batch_from_sparse_binary_array()` | List of index lists | Numba | ⚡⚡⚡ | Sparse data (< 30% fill rate) |
-| `from_sparse_binary_array()` | List of indices | Numba | ⚡⚡⚡ | Single sparse fingerprint |
-| `batch_from_string_array()` | List of string lists | Numba + xxhash | ⚡⚡ | Text data with xxhash64 token hashing |
-| `from_string_array()` | List of strings | Numba + xxhash | ⚡⚡ | Single text document |
-| `encode()` | Auto-detect | Auto | Varies | General purpose, flexible |
+| Method | Input | Backend | When to Use |
+|--------|-------|---------|-------------|
+| `batch_from_binary_array()` | 2D array (n, bits) | Numba | Many dense fingerprints |
+| `from_binary_array()` | 1D array (bits,) | Numba | Single fingerprint |
+| `batch_from_sparse_binary_array()` | List of index lists | Numba | Data already stored as "on" positions |
+| `from_sparse_binary_array()` | List of indices | Numba | Single sparse fingerprint |
+| `batch_from_string_array()` | List of string lists | xxhash64 + Numba | Text data, tokens, n-grams |
+| `from_string_array()` | List of strings | xxhash64 + Numba | Single text document |
+| `encode()` | Auto-detect | Auto | General purpose, flexible |
---
## Method Details
-### `batch_from_binary_array()` - The Primary Method
+### `batch_from_binary_array()`: Dense Fingerprints
-**Use this for most molecular fingerprint work.**
+**Use this when your fingerprints are a 0/1 matrix.**
```python
import numpy as np
@@ -111,7 +114,7 @@ signatures = mh.batch_from_binary_array(fingerprints)
print(signatures.shape) # (10000, 128)
```
-**Performance:** ~150,000 fingerprints/second (2048-bit, 128 permutations)
+**Performance:** the time goes into the set bits, so speed depends mostly on how many bits are 1. Sparse fingerprints such as Morgan (a few percent of bits set) encode several times faster than the half-full random matrix above. If fewer than 30% of the bits are set on average, the method switches to the sparse kernel by itself.
**When to use:**
@@ -121,7 +124,7 @@ print(signatures.shape) # (10000, 128)
---
-### `from_binary_array()` - Single Fingerprint
+### `from_binary_array()`: Single Fingerprint
**For encoding one fingerprint at a time.**
@@ -138,11 +141,11 @@ print(sig.shape) # (128,)
- Querying a new point against existing index
- Testing and debugging
-**Note:** For multiple fingerprints, use `batch_from_binary_array()` instead - it's faster due to Numba parallelization.
+**Note:** For multiple fingerprints, use `batch_from_binary_array()` instead. It encodes rows in parallel with Numba.
---
-### `batch_from_sparse_binary_array()` - Sparse Data
+### `batch_from_sparse_binary_array()`: Sparse Data
**For fingerprints stored as lists of "on" indices.**
@@ -159,9 +162,10 @@ signatures = mh.batch_from_sparse_binary_array(sparse_fingerprints)
**When to use:**
-- Your data is already in sparse format
-- Fill rate is low (< 30% of bits are 1)
-- Memory efficiency is important
+- Your data is already stored as lists of "on" positions
+- The full 0/1 matrix would be too large to build in memory
+
+Each row must be a list, tuple or array of non-negative integers. Python sets work with `encode()` but not with this method.
**Important:** Sparse and dense representations produce **identical** signatures:
@@ -174,12 +178,12 @@ dense = np.zeros(100, dtype=np.uint8)
dense[indices] = 1
sig_dense = mh.from_binary_array(dense)
-np.testing.assert_array_equal(sig_sparse, sig_dense) # ✓ Same!
+np.testing.assert_array_equal(sig_sparse, sig_dense) # same signature
```
---
-### `batch_from_string_array()` - Text Data
+### `batch_from_string_array()`: Text Data
**For text data like words, tokens, or n-grams.**
@@ -200,11 +204,11 @@ signatures = mh.batch_from_string_array(documents)
- Chemical SMILES treated as character n-grams
- Any string-based set data
-**Important:** String signatures use `xxhash64` token hashing before the Numba MinHash path. This is different from the binary hash function, so **binary and string signatures are NOT comparable**.
+**Important:** Each string token is first turned into a 63-bit integer with `xxhash64`, and then goes through the same MinHash as the binary methods. Those integers have nothing to do with bit positions, so a string signature can't be compared with a binary one, even when the tokens are `"0"`, `"5"`, `"42"`.
---
-### `encode()` - Auto-Detection
+### `encode()`: Auto-Detection
**Flexible method that auto-detects input type.**
@@ -236,9 +240,9 @@ sigs = mh.encode(data)
---
-## WeightedMinHash - For Float Vectors
+## WeightedMinHash: For Float Vectors
-When your data has weights (not just 0/1), use `WeightedMinHash`:
+When each feature has a weight, such as a count or a TF-IDF score, use `WeightedMinHash`:
```python
from tmap import WeightedMinHash
@@ -250,8 +254,8 @@ wmh = WeightedMinHash(dim=100, num_perm=128, seed=42)
weights = np.random.uniform(0.1, 10, size=(1000, 100)) # Must be > 0
# Encode
-signatures = wmh.batch_from_weight_array(weights)
-print(signatures.shape) # (1000, 128, 2) - note: 2 values per hash
+signatures = wmh.batch_from_weight_array(weights, n_jobs=1)
+print(signatures.shape) # (1000, 128, 2): two values per hash
# Distance calculation is different
sig1 = wmh.from_weight_array(weights[0])
@@ -262,9 +266,10 @@ distance = wmh.get_weighted_distance(sig1, sig2)
**Key differences from MinHash:**
1. Requires knowing `dim` at construction time
-2. Input must be strictly positive (> 0, not just >= 0)
-3. Output has shape `(n, num_perm, 2)` - two values per hash
+2. Every value must be greater than zero; a zero raises `ValueError`
+3. Output has shape `(n, num_perm, 2)`, two values per hash
4. Use `get_weighted_distance()` for comparisons
+5. It runs a Python loop over rows (built on `datasketch`), so it is much slower than `MinHash`. `batch_from_weight_array` starts a process pool when `n_jobs` is left at `None` and there are 100 rows or more. That needs an `if __name__ == "__main__":` guard in scripts, and for a few thousand rows `n_jobs=1` is often faster.
---
@@ -278,9 +283,9 @@ Controls the tradeoff between accuracy and size.
|-------|----------|--------|-------|----------|
| 32 | Low | 256 bytes | Fastest | Quick exploration |
| 64 | Medium | 512 bytes | Fast | Development |
-| 128 | Good | 1 KB | Good | **Default, most cases** |
+| 128 | Good | 1 KB | Good | `MinHash` class default, most cases |
| 256 | High | 2 KB | Slower | High precision needed |
-| 512 | Very High | 4 KB | Slowest | Publication quality |
+| 512 | Very High | 4 KB | Slowest | `TMAP` default, publication quality |
**Rule of thumb:** Start with 128. Increase only if you need better Jaccard estimation accuracy.
@@ -293,10 +298,10 @@ mh2 = MinHash(num_perm=128, seed=42)
sig1 = mh1.encode(data)
sig2 = mh2.encode(data)
-np.testing.assert_array_equal(sig1, sig2) # ✓ Identical
+np.testing.assert_array_equal(sig1, sig2) # identical
```
-Always set a seed for reproducible results.
+The default seed is fixed (`seed=1`), so the same input always gives the same signatures even if you don't pass one. To reproduce the signatures `TMAP` builds internally, use `MinHash(num_perm=512, seed=42)`.
---
@@ -352,13 +357,13 @@ estimated_distance = mh.get_distance(sig1, sig2)
### 1. Mixing Binary and String Signatures
-**Problem:** Binary and string data use different hash functions.
+**Problem:** String tokens are hashed to integer IDs first, so they don't line up with bit positions.
```python
-# ❌ WRONG - these signatures are not comparable!
+# Wrong: these signatures are not comparable
sig_binary = mh.from_binary_array(fingerprint)
sig_string = mh.from_string_array(["1", "2", "3"])
-distance = mh.get_distance(sig_binary, sig_string) # Meaningless!
+distance = mh.get_distance(sig_binary, sig_string) # meaningless
```
**Solution:** Use the same encoding method for all data you want to compare.
@@ -368,11 +373,11 @@ distance = mh.get_distance(sig_binary, sig_string) # Meaningless!
**Problem:** Overhead from method dispatch.
```python
-# ❌ Inefficient - calling batch method in a loop
+# Slow: calling the batch method in a loop
for fp in fingerprints:
sig = mh.batch_from_binary_array(fp.reshape(1, -1))[0]
-# ✓ Efficient - one batch call
+# Fast: one batch call
sigs = mh.batch_from_binary_array(fingerprints)
```
@@ -381,11 +386,11 @@ sigs = mh.batch_from_binary_array(fingerprints)
**Problem:** Passing 2D array to single-item method.
```python
-# ❌ WRONG - will raise error
-fp = np.array([[1, 0, 1], [0, 1, 1]]) # 2D!
-sig = mh.from_binary_array(fp) # Error!
+# Wrong: raises ValueError
+fp = np.array([[1, 0, 1], [0, 1, 1]]) # 2D
+sig = mh.from_binary_array(fp)
-# ✓ Correct
+# Right
sig = mh.batch_from_binary_array(fp) # For multiple
sig = mh.from_binary_array(fp[0]) # For single
```
@@ -395,11 +400,11 @@ sig = mh.from_binary_array(fp[0]) # For single
**Problem:** WeightedMinHash requires strictly positive values.
```python
-# ❌ WRONG - will raise error
-weights = np.array([1.0, 0.0, 2.0]) # Contains 0!
+# Wrong: raises ValueError
+weights = np.array([1.0, 0.0, 2.0]) # contains 0
sig = wmh.from_weight_array(weights)
-# ✓ Correct - add small epsilon
+# Right: add a small epsilon
weights = np.maximum(weights, 1e-10)
sig = wmh.from_weight_array(weights)
```
@@ -415,8 +420,8 @@ mh2 = MinHash(num_perm=128)
sig1 = mh1.from_binary_array(fp) # Shape: (64,)
sig2 = mh2.from_binary_array(fp) # Shape: (128,)
-# ❌ Will raise error
-distance = mh1.get_distance(sig1, sig2) # Mismatched lengths!
+# Raises ValueError: mismatched lengths
+distance = mh1.get_distance(sig1, sig2)
```
---
@@ -426,44 +431,29 @@ distance = mh1.get_distance(sig1, sig2) # Mismatched lengths!
### 1. Use Batch Methods
```python
-# ⚡ Fast
+# Fast
sigs = mh.batch_from_binary_array(all_fingerprints)
-# 🐌 Slow
+# Slow
sigs = [mh.from_binary_array(fp) for fp in all_fingerprints]
```
### 2. Ensure Correct dtype
```python
-# ⚡ Fast - uint8 is optimal
-fps = fingerprints.astype(np.uint8)
+fps = fingerprints.astype(np.uint8) # or bool
sigs = mh.batch_from_binary_array(fps)
-
-# 🐌 Slower - requires conversion
-fps_float = fingerprints.astype(np.float64) # Wastes memory
-sigs = mh.batch_from_binary_array(fps_float) # Internal conversion
```
-### 3. Use Sparse Format When Appropriate
-
-```python
-# If your fingerprints have < 30% fill rate:
-sparse_fps = [np.nonzero(fp)[0].tolist() for fp in fingerprints]
-sigs = mh.batch_from_sparse_binary_array(sparse_fps)
-```
+Other dtypes are converted with `astype(np.uint8)`. That costs a copy, and it truncates: a value of 0.5 becomes 0, so the bit counts as unset. Make sure float input holds only 0.0 and 1.0.
-### 4. Numba JIT Compilation
+### 3. Skip Manual Sparse Conversion
-The first call compiles Numba functions (takes ~1-2 seconds). Subsequent calls are fast:
+`batch_from_binary_array` already switches to the sparse kernel when fewer than 30% of the bits are set, so converting a dense matrix to index lists yourself doesn't speed anything up. Use `batch_from_sparse_binary_array` when your data starts out as index lists.
-```python
-# First call: ~2 seconds (compilation)
-sigs = mh.batch_from_binary_array(batch1)
+### 4. Numba JIT Compilation
-# Second call: ~0.01 seconds (already compiled)
-sigs = mh.batch_from_binary_array(batch2)
-```
+The first call after installing TMAP compiles the Numba kernels, which takes about a second. The compiled code is cached on disk, so later calls and later Python sessions skip that step.
---
@@ -487,7 +477,7 @@ signatures = mh.batch_from_binary_array(fingerprints)
print(f"Encoded {len(signatures)} molecules to shape {signatures.shape}")
# 4. Build LSH Forest index
-lsh = LSHForest(d=128, l=64) # d must match num_perm
+lsh = LSHForest(d=128, l=32) # d must match num_perm
lsh.batch_add(signatures)
lsh.index()
@@ -508,4 +498,4 @@ print(f"Layout: {len(x)} points, {len(s)} edges")
- See [LSHForest Guide](lshforest_guide.md) for indexing and querying
- See [Layout Guide](layout_guide.md) for visualization parameters
-- Try the example: `examples/chemistry/smiles_tmap.py`
+- Work through [notebook 07](../notebooks/07_minhash_deep_dive.ipynb) for the encoders and [notebook 12](../notebooks/12_lower_level_pipeline.ipynb) for the full lower-level pipeline
diff --git a/docs/molecule_tutorial.md b/docs/molecule_tutorial.md
index 8fdf1ab..6eaba58 100644
--- a/docs/molecule_tutorial.md
+++ b/docs/molecule_tutorial.md
@@ -1,6 +1,6 @@
# Molecule Tutorial
-This is the clearest end-to-end TMAP workflow for chemistry:
+This tutorial walks through a full chemistry workflow:
1. Load SMILES from `examples/cluster_65053.csv`
2. Compute Morgan fingerprints
@@ -11,24 +11,25 @@ This is the clearest end-to-end TMAP workflow for chemistry:
## Requirements
```bash
-python -m pip install .
-python -m pip install rdkit jupyter-scatter
+pip install "tmap2[chemistry,notebook]"
```
-`rdkit` is needed for fingerprints and molecular properties. `jupyter-scatter` is only needed for notebook widgets.
+The `chemistry` extra installs RDKit, which the fingerprint and property helpers need. The `notebook` extra installs jupyter-scatter, which is only needed for notebook widgets.
+
+Run the code from the repository root. The helpers in step 2 start worker processes, so if you paste the code into a script, put it under `if __name__ == "__main__":`. Notebooks don't need that.
## 1. Load A Molecule Table
```python
import pandas as pd
-df = pd.read_csv("../examples/cluster_65053.csv", nrows=3000)
+df = pd.read_csv("examples/cluster_65053.csv", nrows=3000)
smiles = df["smiles"].tolist()
print(f"{len(smiles):,} molecules")
```
-Use a small subset first. Once the workflow is working, remove `nrows=3000`.
+Use a small subset first. Once the workflow is working, remove `nrows=3000` (the full file has about 64,000 molecules).
## 2. Compute Fingerprints, Properties, And Scaffolds
@@ -51,23 +52,21 @@ scaffolds = murcko_scaffolds(smiles)
Without `return_valid=True` you get just the matrix, and a single bad SMILES
shifts every row after it in `props` and `scaffolds`.
+`molecular_properties` can compute any of the names in `tmap.utils.AVAILABLE_PROPERTIES`, such as `"tpsa"`, `"hbd"`, `"hba"` or `"fraction_csp3"`.
+
## 3. Fit TMAP
```python
from tmap import TMAP
-model = TMAP(
- metric="jaccard",
- n_neighbors=20,
- n_permutations=512,
- kc=50,
- seed=42,
-).fit(fps)
+model = TMAP(metric="jaccard", n_neighbors=20, seed=42).fit(fps)
print(model.embedding_.shape)
print(model.tree_.edges.shape)
```
+For a binary matrix like this one, TMAP finds neighbors with a USearch HNSW index on the raw bits. The index is built on several threads, so two runs can give slightly different maps. Pass `reproducible=True` if you need identical coordinates every time; the build gets slower.
+
## 4. Build A Visualization
```python
@@ -87,44 +86,60 @@ This gives you:
- multiple property views
- scaffold labels in the tooltip
+The [visualization guide](visualization_guide.md) covers filters, search, pinned cards and links.
+
## 5. Explore In A Notebook
```python
-widget = viz.to_widget(width=1000, height=650, controls=True)
-widget.show()
+viz.show(width=1000, height=650, controls=True)
```
Use this when you want to switch color layers, filter categories, and inspect points interactively in Jupyter.
-Note: notebook widgets do not draw tree edges yet. HTML export does.
+Note: notebook widgets do not draw tree edges yet, and they warn about it. HTML export does draw them.
+
+## 6. Follow The Tree
+
+The fitted model answers questions about the tree directly:
-## 6. Save A Shareable HTML File
+```python
+a, b = 0, 100
+print(model.path(a, b)) # molecules along the tree path from a to b
+print(model.hops(a, b)) # number of edges on that path
+print(model.distance(a, b)) # summed Jaccard distance along the path
+
+steps = model.hops_from(a) # edges from molecule a to every other molecule
+```
+
+`model.distances_from(a)` gives the summed distances instead of edge counts. Both make good color layers: `viz.add_color_layout("Hops from 0", steps.tolist())`.
+
+## 7. Save A Shareable HTML File
```python
path = viz.write_html("cluster_65053.html")
print(path)
```
-This writes one self-contained HTML file that you can open in a browser.
+This writes one HTML file with the data embedded, which you can open in a browser without a server. The page loads a few JavaScript libraries from a CDN, so it needs internet access.
-## 7. Serve A Larger Map Locally
+## 8. Serve A Larger Map Locally
```python
viz.serve(port=8050)
```
-Use `serve()` when the map is large enough that one HTML file becomes inconvenient. `serve()` writes static assets and starts a small local HTTP server.
+Use `serve()` when the map is large enough that one HTML file becomes inconvenient. It writes the page and its data files to a temporary folder, opens your browser, and keeps serving until you press Ctrl+C. To keep the files, or to put them on a web server, use `viz.write_static("cluster_65053_site/")` instead.
-## 8. Save The Model Too
+## 9. Save The Model Too
```python
-model.save("cluster_65053_model.pkl")
-loaded = TMAP.load("cluster_65053_model.pkl")
+model.save("cluster_65053.tmap")
+loaded = TMAP.load("cluster_65053.tmap")
```
This is useful when you want to keep the fitted tree and coordinates for later analysis.
-## 9. Script Version
+## 10. Script Version
If you want the same workflow as a script, run:
@@ -133,3 +148,5 @@ python examples/chemistry/molecules_tmap.py --nrows 3000 --output examples/clust
```
Add `--serve` if you want it to start a local viewer.
+
+For a longer version with the full 64,000 molecules and more color layers, see [notebook 02](../notebooks/02_cheminformatics.ipynb).
diff --git a/docs/usearch_backend.md b/docs/usearch_backend.md
index a495781..b70f157 100644
--- a/docs/usearch_backend.md
+++ b/docs/usearch_backend.md
@@ -6,13 +6,18 @@ This guide explains the USearch nearest-neighbor backend in TMAP, when it's used
## What USearch Does
-USearch is an HNSW (Hierarchical Navigable Small World) index that supports multiple distance metrics. TMAP uses it for:
+[USearch](https://github.com/unum-cloud/usearch) is a nearest-neighbor library with several distance metrics. TMAP uses it for:
-- **Binary Jaccard** (new default for binary fingerprints)
+- **Binary Jaccard**: the estimator's backend for 0/1 matrices such as molecular fingerprints
- **Cosine** distance on dense vectors
- **Euclidean** distance on dense vectors
-For binary data, USearch computes exact Jaccard distance on bit-packed vectors — no MinHash approximation is needed.
+It runs in one of two modes:
+
+- **Exact**: compares each query with every vector. Used for cosine and euclidean below 50,000 points.
+- **HNSW** (Hierarchical Navigable Small World): an approximate graph index that stays fast at millions of points. Used for cosine and euclidean from 50,000 points up, and always for binary Jaccard.
+
+For binary data, USearch computes the Jaccard distance on the packed bits themselves, so there is no MinHash approximation in the distance.
```txt
Binary Matrix (0/1)
@@ -38,10 +43,12 @@ from tmap import TMAP
# Binary fingerprints → USearch Jaccard (automatic)
model = TMAP(metric="jaccard", n_neighbors=20).fit(fingerprints)
-# Sets/strings → MinHash+LSH (automatic)
-model = TMAP(metric="jaccard", n_neighbors=20).fit(list_of_sets)
+# Lists of feature indices or string tokens → MinHash + LSH (automatic)
+model = TMAP(metric="jaccard", n_neighbors=20).fit(list_of_index_lists)
```
+After fitting on a binary matrix, the index is kept as `model.index_`, so `transform()`, `kneighbors()` and `add_points()` work without `store_index=True`. For cosine and euclidean, pass `store_index=True` if you need those methods.
+
### Standalone (no TMAP, no layout)
Use the index directly for kNN queries without building a tree:
@@ -50,20 +57,27 @@ Use the index directly for kNN queries without building a tree:
from tmap.index import USearchIndex
# Build
-idx = USearchIndex(seed=42)
+idx = USearchIndex()
idx.build_from_binary(fingerprints) # (n, d) of 0/1 values
# Query
neighbors, distances = idx.query_batch(new_fingerprints, k=50)
+# All-vs-all kNN graph, ready for tmap.graph or tmap.layout
+knn = idx.query_knn(k=20)
+
# Incremental
idx.add(more_fingerprints)
# Persistence
-idx.save("my_index.usearch")
+idx.save("my_index.usearch") # writes my_index.usearch, .meta and .vectors.npy
idx = USearchIndex.load("my_index.usearch")
```
+`load()` needs all three files that `save()` writes.
+
+For dense vectors, use `idx.build_from_vectors(X, metric="cosine")` or `metric="euclidean"`. Euclidean distances are returned as plain (square-rooted) distances. `idx.effective_mode` tells you whether the index ended up exact or HNSW.
+
---
## How It Works
@@ -80,91 +94,92 @@ Jaccard distance = 1 - popcount(A AND B) / popcount(A OR B)
This is computed on packed bytes using hardware popcount instructions, making individual distance computations very fast.
-**Key difference from MinHash+LSH:** USearch operates on the *original* bit vectors. MinHash first compresses the data into fixed-width hash signatures, losing information. This compression is why LSH has much lower recall on sparse binary data.
+**Difference from MinHash+LSH:** USearch compares the original bit vectors. MinHash first compresses the data into fixed-width hash signatures, and the Jaccard distance is then estimated from those signatures. That estimate is part of why LSH finds fewer of the true neighbors on binary data.
### When USearch is used vs MinHash+LSH
| Input type | Backend | Why |
|---|---|---|
-| Dense binary matrix (ndarray, DataFrame) | USearch HNSW | Native Jaccard on bits, high recall |
-| Sparse matrix (scipy CSR) | MinHash + LSH | Avoids densifying large sparse data |
-| List of integer sets | MinHash + LSH | Variable-length, can't pack to fixed bits |
+| Dense binary matrix (NumPy array, bool array, DataFrame, rectangular list of 0/1 lists) | USearch HNSW | Native Jaccard on bits, high recall |
+| Sparse matrix (SciPy CSR) | MinHash + LSH | Avoids densifying large sparse data |
+| List of feature-index lists | MinHash + LSH | Variable-length, can't pack to fixed bits |
| List of string tokens | MinHash + LSH | Variable-length, needs MinHash encoding |
-The estimator detects the input type automatically.
+The estimator detects the input type automatically. A dense matrix with values other than 0 and 1 raises an error under `metric="jaccard"`; use cosine or euclidean for counts.
---
## Performance
-All benchmarks run on a MacBook (Apple Silicon, 24 GB RAM).
-Reproducible via `python scripts/bench_usearch_vs_lsh.py`.
+All numbers below come from one Apple M4 Pro laptop (12 cores, 24 GB RAM, usearch 2.23) and use the settings `TMAP.fit` uses: USearch with `expansion_search=512` on all cores, and MinHash with 512 permutations plus an LSHForest with `l=128` and `kc=50`. Rerun them on your own machine with:
+
+```bash
+python scripts/bench_usearch_vs_lsh.py
+```
+
+Two datasets are used: random binary vectors (1024 bits, 10% of bits set), and Morgan fingerprints (radius 2, 2048 bits) of the 64,098 molecules in `examples/cluster_65053.csv`. Timings are single runs (best of 2 for the smaller sizes) and move by a few percent between runs.
### Recall
-Measured against brute-force ground truth (1024 bits, ~10% density, k=20):
+Recall@20 against exact Jaccard neighbors, with the point itself left out. Jaccard distances have many ties, so a returned neighbor counts as correct when its true distance is no larger than the true 20th neighbor's.
-| Method | Recall@20 (n=10k) | Recall@20 (n=50k) |
-|---|---|---|
-| USearch (expansion=512) | **98.5%** | **81.6%** |
-| USearch (expansion=256) | 97.0% | — |
-| LSH (d=512, kc=50) | 0.6% | 1.5% |
+| Dataset | n | USearch | MinHash + LSH |
+|---|---:|---:|---:|
+| Morgan fingerprints | 10,000 | 99.9% | 83.9% |
+| Morgan fingerprints | 64,098 | 99.9% | 82.6% |
+| Random binary | 10,000 | 99.6% | 24.6% |
+| Random binary | 50,000 | 87.3% | 12.5% |
-USearch recall decreases at larger N because HNSW is approximate, but it remains vastly better than LSH for sparse binary data. LSH fills all neighbor slots but with essentially random points — MinHash has fundamental recall limitations when bit overlap between vectors is low.
+On real fingerprints USearch finds almost every true neighbor, and LSH finds about five in six. Random vectors are a worst case for both. In random data the true 20th neighbor is barely closer than an average point (Jaccard distance about 0.89 against 0.95), so neither the MinHash prefixes nor the HNSW graph have much to go on. For the Morgan fingerprints the gap is wide (0.45 against 0.82). A higher `expansion_search` brings USearch back on random data: 96.0% at 1024 and 99.3% at 2048 for 50,000 points, at 1.4 and 3.3 times the query time.
### Build + kNN graph time
-1024-bit fingerprints, ~10% density, k=20:
-
-| n | USearch build | USearch kNN | USearch total | LSH total | LSH mem |
-|---:|---:|---:|---:|---:|---:|
-| 10,000 | 1.6s | 1.0s | **2.6s** | **0.7s** | 41 MB |
-| 50,000 | 7.2s | 8.9s | **16.1s** | **2.3s** | 205 MB |
-| 100,000 | 16.2s | 21.8s | **37.9s** | **5.9s** | 410 MB |
-| 250,000 | 47.5s | 82.7s | **130s** | **22.9s** | 1,024 MB |
-| 500,000 | 114.9s | 225.3s | **340s** | **84.6s** | 2,048 MB |
-| 1,000,000 | ~250s | ~550s | **~800s** | ~250s | 4,096 MB |
-| 2,000,000 | ~550s | ~1200s | **~1750s** | -OOM- | 16 GB+ |
+Random binary vectors, k=20:
-LSH is 4-7x faster for building the full kNN graph. But those neighbors are wrong (1.5% recall), so the resulting TMAP tree is meaningless. At 1M+ points, LSH hits memory limits on a 24 GB machine while USearch fits in 128 MB.
+| n | USearch build | USearch kNN | USearch total | LSH total | USearch memory | LSH memory |
+|---:|---:|---:|---:|---:|---:|---:|
+| 10,000 | 0.3s | 0.4s | 0.7s | 0.5s | 21 MB | 44 MB |
+| 50,000 | 2.2s | 3.3s | 5.6s | 3.5s | 43 MB | 220 MB |
+| 100,000 | 6.0s | 10.3s | 16.3s | 8.6s | 98 MB | 439 MB |
+| 250,000 | 22.3s | 45.8s | 68.1s | 25.2s | 215 MB | 1,099 MB |
+| 500,000 | 61.9s | 98.8s | 160.7s | 49.7s | 441 MB | 2,197 MB |
-The USearch kNN query (all-vs-all search) takes longer than the HNSW build itself. This is the main bottleneck at scale.
+LSH builds the kNN graph 1.3 to 3.2 times faster. The LSH total includes MinHash encoding (5.6s at 500,000) and indexing (3.9s). The all-vs-all USearch query takes longer than the HNSW build itself, and it is the main cost at scale. For the 64,098 Morgan fingerprints, USearch took 4.3s and LSH 3.3s.
-### Batch queries (100 queries against existing index)
+### Batch queries (100 new points against an existing index)
| n | USearch | LSH |
|---:|---:|---:|
-| 10,000 | 6.5ms | 10.5ms |
-| 50,000 | 11.8ms | 15.9ms |
-| 100,000 | 17.0ms | 20.5ms |
-| 500,000 | 33.7ms | 80.7ms |
+| 10,000 | 5.4 ms | 4.9 ms |
+| 50,000 | 9.4 ms | 7.2 ms |
+| 100,000 | 13.7 ms | 9.9 ms |
+| 250,000 | 18.7 ms | 8.6 ms |
+| 500,000 | 23.2 ms | 8.9 ms |
-For `transform()` and `add_points()`, USearch is consistently faster because HNSW queries are O(log n). At 500k, USearch is 2.4x faster per query.
+This is the cost of `transform()`, `kneighbors()` and `add_points()`. LSH time levels off at about 9 ms because each query checks a fixed budget of `k * kc = 1000` candidates. Encoding the 100 queries with MinHash adds another 0.9 ms.
-### Memory (vector storage)
+### Memory per vector
-| n | USearch | LSH (d=512) |
-|---:|---:|---:|
-| 100,000 | 13 MB | 410 MB |
-| 250,000 | 32 MB | 1,024 MB |
-| 500,000 | 64 MB | 2,048 MB |
-| 1,000,000 | 128 MB | 4,096 MB |
-| 2,000,000 | 256 MB | -OOM- |
+| | USearch | MinHash + LSH |
+|---|---:|---:|
+| Index | about 800-900 B (HNSW graph plus its copy of the bits) | 4,096 B signatures (512 × 8 bytes) plus 512 B prefix trees |
+| TMAP's packed copy of the bits | 128 B (1024 bits), 256 B (2048 bits) | none |
+| Total, 50,000+ points | about 0.9-1.1 KB | about 4.6 KB |
-USearch stores packed bytes (128 bytes per 1024-bit vector). LSH stores MinHash signatures (4,096 bytes per vector with d=512). USearch uses **32x less memory** for 1024-bit fingerprints (16x for 2048-bit).
+USearch uses about 4 to 5 times less memory. Below about 50,000 points the USearch figure is higher per vector (about 2.2 KB at 10,000), because it reserves space up front.
### Summary
| | USearch Jaccard | MinHash + LSH |
|---|---|---|
-| **Recall** | 82-98% | 0.6-1.5% |
-| **Build speed** | 4-7x slower | Faster (but wrong neighbors) |
-| **Query speed** | 1.2-2.4x faster | Slower at scale |
-| **Memory** | 16-32x less | OOM at ~1-2M |
-| **Max scale (24 GB)** | 2M+ | ~500k-1M |
-| **Hyperparameters** | None (auto) | d, l, kc |
+| **Recall on fingerprints** | 99.9% | 83-84% |
+| **Recall on random bits** | 87-100% | 12-25% |
+| **Build speed** | 1.3-3.2x slower | Faster |
+| **Batch query speed** | Slower, grows with n | Faster, flat at about 9 ms per 100 queries |
+| **Memory** | About 1 KB per vector | About 4.6 KB per vector |
+| **Settings** | `expansion_search`, `connectivity` (TMAP picks them) | `n_permutations`, `kc`, `l` (TMAP picks `l`) |
-**Bottom line:** USearch is the right default for binary data. It trades some build time for vastly better neighbor quality and lower memory. The build cost is one-time; queries are faster.
+USearch is the default for binary data because it finds more of the true neighbors, and the tree is built from those neighbors. LSH is faster to build and query, so it remains a reasonable choice when speed matters more than neighbor quality, and it is the only option for sets, strings and sparse input.
---
@@ -174,13 +189,17 @@ USearch stores packed bytes (128 bytes per 1024-bit vector). LSH stores MinHash
The main quality knob. Higher values improve recall at the cost of slower queries.
-| expansion_search | Recall@20 (n=10k) | Effect |
-|---|---|---|
-| 128 | 96.1% | Fast, slightly lower recall |
-| 256 | 97.0% | Good balance |
-| 512 | 98.5% | Best recall (TMAP default) |
+At n=10,000 (recall@20, same tie-aware count as above):
+
+| expansion_search | Morgan fingerprints | Random binary | kNN time (random) |
+|---|---|---|---|
+| 128 | 99.7% | 97.4% | 0.20s |
+| 256 | 99.8% | 98.3% | 0.31s |
+| 512 | 99.8% | 99.5% | 0.52s |
+
+On real fingerprints the setting barely matters at this size. On harder data, and on larger datasets, the higher values pay off.
-The estimator uses `expansion_search=512` by default. For standalone use, you can set this in the constructor:
+For binary Jaccard, the estimator uses `expansion_search=512`. For cosine and euclidean it uses the `USearchIndex` default of 200 (which only matters once the index switches to HNSW at 50,000 points). For standalone use, set it in the constructor:
```python
idx = USearchIndex(expansion_search=256) # faster, slightly lower recall
@@ -194,11 +213,27 @@ Controls the HNSW graph density. Higher values use more memory but improve recal
idx = USearchIndex(connectivity=64) # default is 32
```
+### mode
+
+`mode="auto"` (the default) picks exact search below 50,000 dense vectors and HNSW above. Pass `mode="exact"` or `mode="hnsw"` to force one. Binary indexes always use HNSW.
+
+---
+
+## Reproducibility
+
+The HNSW build uses every core by default (`threads=0`). Threads insert points in a slightly different order on each run, so the graph, and with it the returned neighbors, can change a little between runs. That can change the tree and the layout.
+
+- Standalone: `USearchIndex(threads=1)` builds on one thread and gives the same index every time.
+- Estimator: `TMAP(..., reproducible=True)` does the same for you. The HNSW build gets roughly 5 to 7 times slower at 10k+ points.
+- Exact search (cosine/euclidean below 50,000 points) gives the same neighbors on every run.
+
+The `seed` argument of `USearchIndex` is stored with the index as metadata. USearch itself does not use it.
+
---
## Limitations
-- **Sparse matrices** go through MinHash+LSH to avoid OOM from densification
+- **Sparse matrices** go through MinHash+LSH so they don't have to be densified
- **Variable-length data** (sets, strings) requires MinHash encoding, so LSH is used
-- **HNSW is approximate** — recall decreases with dataset size (82% at 50k vs 98% at 10k)
-- **Build time** is O(n log n) with high constant for binary distance — slower than LSH for one-time builds
+- **HNSW is approximate**: recall can drop on large datasets with weak neighbor structure (87% on 50,000 random vectors at the default settings, see above)
+- **Build time**: the HNSW build and the all-vs-all query dominate the run time at large sizes
diff --git a/docs/visualization_guide.md b/docs/visualization_guide.md
index 46031ab..ae16b7a 100644
--- a/docs/visualization_guide.md
+++ b/docs/visualization_guide.md
@@ -4,11 +4,12 @@
The most useful mental model is simple:
-- `to_widget(...)` for notebooks
+- `show(...)` for notebooks
- `write_html(...)` for one shareable file
-- `serve(...)` for larger local maps
+- `serve(...)` or `write_static(...)` for larger maps
+- `model.plot_static(...)` for figures
-This guide uses the molecule example from `examples/cluster_65053.csv`.
+This guide uses the molecule example from `examples/cluster_65053.csv`. Run the code from the repository root. In a script, put it under `if __name__ == "__main__":`, because the chemistry helpers start worker processes.
## Build A Base Visualization
@@ -17,11 +18,13 @@ import pandas as pd
from tmap import TMAP
from tmap.utils import fingerprints_from_smiles, molecular_properties, murcko_scaffolds
-df = pd.read_csv("../examples/cluster_65053.csv", nrows=3000)
+df = pd.read_csv("examples/cluster_65053.csv", nrows=3000)
smiles = df["smiles"].tolist()
-fps = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048)
-props = molecular_properties(smiles, properties=["mw", "logp", "n_rings", "qed"])
+fps, valid = fingerprints_from_smiles(smiles, fp_type="morgan", radius=2, n_bits=2048, return_valid=True)
+smiles = [smi for smi, ok in zip(smiles, valid) if ok]
+
+props = molecular_properties(smiles, properties=["mw", "logp", "n_rings", "qed", "tpsa", "hbd"])
scaffolds = murcko_scaffolds(smiles)
model = TMAP(metric="jaccard", n_neighbors=20, seed=42).fit(fps)
@@ -36,15 +39,18 @@ viz.add_color_layout("QED", props["qed"].tolist(), color="magma")
viz.add_label("Murcko Scaffold", scaffolds.tolist())
```
+`return_valid=True` drops the SMILES RDKit can't parse. Filtering `smiles` with it keeps the properties, scaffolds and tooltips on the right molecules.
+
## Notebook Workflow
-Use notebook widgets when you want fast iteration in Jupyter.
+Use notebook widgets when you want fast iteration in Jupyter. They need the `notebook` extra (`pip install "tmap2[notebook]"`).
```python
-widget = viz.to_widget(width=1000, height=650, controls=True)
-widget.show()
+viz.show(width=1000, height=650, controls=True)
```
+`viz.to_widget(...)` builds the same jupyter-scatter object without displaying it, if you want to customize it first.
+
Good for:
- switching color layouts
@@ -52,9 +58,12 @@ Good for:
- inspecting tooltips
- staying inside a notebook
-Current limitation:
+Current limitations:
+
+- The widget draws points only. It warns about the tree edges and skips them; the HTML export draws them. Use `model.to_tmapviz(include_edges=False)` if you only need the widget and want to avoid the warning.
+- The widget's filter menu lists categorical columns only. Continuous `add_filter` columns and the `filterable` setting apply to the HTML output.
-- notebook widgets do not draw tree edges yet
+For more on widgets, see [notebook 08](../notebooks/08_jscatter_demo.ipynb).
## HTML Workflow
@@ -68,24 +77,21 @@ print(path)
Good for:
- sharing a result
-- opening the map in any browser
+- opening the map in a browser without a server
- keeping edge rendering
-## Local Server Workflow
+The data is embedded in the file. The page loads a few JavaScript libraries from a CDN, so the person opening it needs internet access.
-Use `serve()` when the map gets large and one HTML file becomes awkward.
+## Larger Maps
+
+For maps with millions of points, one HTML file gets heavy. Two options keep the data in separate files that the page fetches over HTTP, loading color columns only when you select them:
```python
-viz.serve(port=8050)
+viz.write_static("cluster_65053_site/") # files for any static web host
+viz.serve(port=8050) # same files in a temp folder, served locally
```
-This writes static assets and starts a small local HTTP server at `http://127.0.0.1:8050`.
-
-Good for:
-
-- larger maps
-- faster reloads during local work
-- lazy loading of data files
+`serve()` opens your browser at `http://127.0.0.1:8050` (pass `open_browser=False` to skip that) and keeps running until you press Ctrl+C. In Jupyter that blocks the kernel, so use `write_static()` there and serve the folder from a terminal, for example with `python -m http.server`.
## Adding Data Columns
@@ -96,7 +102,7 @@ viz.add_color_layout("MW", props["mw"].tolist(), color="viridis")
viz.add_color_layout("LogP", props["logp"].tolist(), color="plasma")
```
-Use this for values you want to color continuously.
+Use this for values you want to color continuously. Continuous layouts take a gradient colormap such as `viridis` (the default), `plasma`, `magma` or `coolwarm`.
### Categorical Properties
@@ -109,26 +115,34 @@ viz.add_color_layout(
)
```
-Use this for discrete labels or small integer sets.
+Use this for discrete labels or small integer sets. Categorical layouts take a qualitative palette such as `tab10` (the default), `tab20`, `Set1` or `Dark2`. You can also pass your own colors, either as a list of hex strings (one per category, in order of first appearance) or as a dict from category to hex color:
+
+```python
+viz.add_color_layout("Series", series, categorical=True, color={"A": "#e41a1c", "B": "#377eb8"})
+```
+
+A gradient colormap on a categorical layout, or a qualitative palette on a continuous one, raises an error.
### Filter-Only Columns
```python
-viz.add_filter("MW", props["mw"].tolist())
-viz.add_filter("Ring Count", props["n_rings"].tolist(), categorical=True)
+viz.add_filter("TPSA", props["tpsa"].tolist())
+viz.add_filter("H-bond Donors", props["hbd"].astype(int).tolist(), categorical=True)
```
Use this when people should be able to filter on a column, but it does not need
to be one of the colors they can switch between. Numbers get a slider, groups
get one clickable bar each. Choosing colors is the slow part of
`add_color_layout`, and this skips it, so extra filter columns cost very little.
+A name can only be one or the other: calling `add_filter` with the name of an
+existing color layout raises an error.
-Color layouts can already be filtered on, so `add_filter` columns go into the
-panel on top of them, not instead of them. To say exactly what the panel shows,
+Color layouts are already filterable, so the panel shows the `add_filter`
+columns and the color layouts together. To say exactly what the panel shows,
set `filterable`:
```python
-viz.filterable = ["MW", "LogP"]
+viz.filterable = ["MW", "LogP", "TPSA"]
```
Pass `add_as_label=False` to keep a filter column out of the tooltip.
@@ -139,7 +153,11 @@ Pass `add_as_label=False` to keep a filter column out of the tooltip.
viz.add_label("Murcko Scaffold", scaffolds.tolist())
```
-Use labels for text that should appear in the tooltip but should not control colors.
+Use labels for text that should appear in the tooltip but should not control colors. Label columns are also what the search box looks through. To limit search to some columns, set `searchable`:
+
+```python
+viz.searchable = ["Murcko Scaffold"]
+```
### Molecular Structures
@@ -147,15 +165,80 @@ Use labels for text that should appear in the tooltip but should not control col
viz.add_smiles(smiles)
```
-This enables SMILES structure rendering in tooltips.
+This enables SMILES structure rendering in tooltips and cards. The column is called `"SMILES"` unless you pass `name=`.
+
+### Images, Proteins And 3D Structures
+
+| Method | What each value should be |
+|--------|---------------------------|
+| `viz.add_images(values)` | A `data:image/png;base64,...` string per point, shown as a thumbnail |
+| `viz.add_protein_ids(values)` | A UniProt accession. Cards load the AlphaFold structure and UniProt details on demand |
+| `viz.add_3d_structures(values, source="url")` | A URL or relative path to a PDB/mmCIF file, fetched when a card opens |
+| `viz.add_3d_structure_files(paths)` | A local PDB/mmCIF path. `write_html` and `write_static` copy the files into a `structures/` folder next to the page |
+
+[Notebook 13](../notebooks/13_local_protein_structures.ipynb) walks through the structure options.
+
+## Cards, Links And Formatting
+
+Clicking a point pins a card with its details. `configure_card` picks what goes on it:
+
+```python
+viz.configure_card(
+ title_column="Murcko Scaffold",
+ fields=["MW", "LogP", "QED", "SMILES"],
+ links=[{"label": "PubChem", "url": "https://pubchem.ncbi.nlm.nih.gov/#query={SMILES}"}],
+)
+```
+
+In link URLs, `{column name}` is replaced with that point's value in the column. Values are URL-encoded, so build the link from an ID column; a column that already holds full URLs won't work as a link template.
+
+`configure_column` sets per-column display hints:
+
+```python
+viz.configure_column("MW", display_name="Molecular weight", format="fixed:1")
+viz.configure_column("QED", format="fixed:2", copyable=True)
+```
+
+`format` accepts `"fixed:N"`, `"percent:N"`, `"scientific:N"`, `"integer"` and `"stars:N"`. See [notebook 09](../notebooks/09_card_configuration.ipynb) for more card layouts.
+
+## Styling
+
+Page settings are plain attributes on the `TmapViz`:
+
+```python
+viz.background_color = "#FFFFFF"
+viz.point_size = 3.0
+viz.opacity = 0.8
+viz.set_edge_style(color="#999999", width=1.0, opacity=0.4)
+```
+
+## Static Figures
+
+For papers and slides, draw the map with matplotlib:
+
+```python
+ax = model.plot_static(color_by=props["qed"], color_map="magma", point_size=2)
+ax.figure.savefig("cluster_65053.png", dpi=300)
+```
+
+Tree edges are drawn behind the points by default (`edges=False` turns them off). For an embedding that didn't come from a fitted model, use `tmap.visualization.plot_static(embedding, edges=tree_edges, ...)`.
+
+## Shortcuts On The Model
+
+If you don't need extra columns, the fitted model can skip the `TmapViz` step:
+
+| Call | Same as |
+|------|---------|
+| `model.to_html("map.html", title="My map")` | `to_tmapviz()`, set the title, `write_html()` |
+| `model.serve(port=8050)` | `to_tmapviz().serve()` |
+| `model.plot(color_by=..., data=df)` | A jupyter-scatter widget colored by a column of `df` |
## Common Patterns
### Quick Notebook First, HTML Second
```python
-widget = viz.to_widget(width=1000, height=650, controls=True)
-widget.show()
+viz.show(width=1000, height=650, controls=True)
viz.write_html("cluster_65053.html")
```
@@ -163,10 +246,22 @@ viz.write_html("cluster_65053.html")
### Save Model And Visualization
```python
-model.save("cluster_65053.pkl")
+model.save("cluster_65053.tmap")
viz.write_html("cluster_65053.html")
```
+`TMAP.load("cluster_65053.tmap")` brings the model back. `TmapViz` objects are not saved; rebuild them from the loaded model.
+
+### Get The Data Back
+
+```python
+df_viz = viz.to_dataframe()
+```
+
+This returns every column plus the map coordinates as a pandas DataFrame, which is handy for working with a lasso selection in a notebook.
+
### Start Small
For tutorials, start with `nrows=1000` or `nrows=3000`. Once the workflow is working, use more rows.
+
+For a step-by-step chemistry example, see the [molecule tutorial](molecule_tutorial.md).
diff --git a/examples/README.md b/examples/README.md
index 6bb7f58..9a8e59d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,8 +1,11 @@
# Examples
-Runnable scripts grouped by data type. Each one is self-contained: run it from
-the repository root and it downloads or caches whatever it needs under
-`examples/data/`, then writes its output to `examples/`.
+Runnable scripts grouped by data type. Run them from the repository root. Each
+script's docstring lists the extra packages it needs (for example `torch`,
+`datasets` or `sentence-transformers`). Datasets and cached embeddings go to
+`examples/data/`; some raw datasets and model weights use their library's own
+cache instead (Hugging Face, scikit-learn, torchvision). Outputs are written to
+`examples/`.
```bash
python examples/chemistry/molecules_tmap.py --nrows 3000
@@ -13,7 +16,6 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
| Example | Description |
|---------|-------------|
| [`chemistry/molecules_tmap.py`](chemistry/molecules_tmap.py) | The simplest chemistry example: SMILES → fingerprints → interactive map, with molecular properties and Murcko scaffolds |
-| [`chemistry/smiles_tmap.py`](chemistry/smiles_tmap.py) | The same map built step by step: `MinHash` → `LSHForest` → OGDF layout → `TmapViz` |
| [`chemistry/molecules_tmap_legacy.py`](chemistry/molecules_tmap_legacy.py) | `molecules_tmap.py` with the adaptive layout and untangle post-pass switched off, for comparison |
## Images
@@ -25,7 +27,7 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
| [`images/emnist_characters_tmap.py`](images/emnist_characters_tmap.py) | Handwritten digits and letters together, showing where OCR confuses the two |
| [`images/flowers_tmap.py`](images/flowers_tmap.py) | Oxford Flowers 102: morphological gradients across species |
| [`images/cub200_birds_tmap.py`](images/cub200_birds_tmap.py) | CUB-200 birds: morphological paths across 200 species |
-| [`images/wikiart_tmap.py`](images/wikiart_tmap.py) | WikiArt paintings coloured by artistic style |
+| [`images/wikiart_tmap.py`](images/wikiart_tmap.py) | WikiArt paintings colored by artistic style |
## Proteins
@@ -37,7 +39,7 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
| Example | Description |
|---------|-------------|
-| [`text/word_embeddings_tmap.py`](text/word_embeddings_tmap.py) | ~800 common English words embedded with a sentence-transformer |
+| [`text/word_embeddings_tmap.py`](text/word_embeddings_tmap.py) | About 1,200 common English words in 19 categories, embedded with a sentence-transformer |
| [`text/word_embeddings_50k.py`](text/word_embeddings_50k.py) | The same idea at 50,000 WordNet nouns |
## Layout internals
@@ -48,13 +50,17 @@ python examples/chemistry/molecules_tmap.py --nrows 3000
## Data
-- `cluster_65053.csv` — ~6k SMILES from an Enamine chemical cluster. Used by the
- chemistry examples, the layout demo, and several docs and notebooks.
-- `data/` — datasets and cached embeddings downloaded by the examples on first
+- `cluster_65053.csv`: about 64,000 SMILES from an Enamine chemical cluster. Used
+ by the chemistry examples, the layout demo, and several docs and notebooks.
+- `data/`: datasets and cached embeddings downloaded by the examples on first
run. Not tracked in git, and can be deleted to reclaim the space.
-Outputs (`.html`, `.png`) are written to `examples/` and are not tracked either.
+Scripts write their outputs (`.html` maps, `.png` figures, `.txt` reports, and
+`esm_atlas_out/` for the protein example) to `examples/`. Only the `.html` files
+and `data/` are in `.gitignore`, so the others show up in `git status`.
## Notebooks
-Step-by-step walkthroughs live in [`notebooks/`](../notebooks) rather than here.
+Step-by-step walkthroughs live in [`notebooks/`](../notebooks). The lower-level
+MinHash → LSHForest → OGDF layout → `TmapViz` pipeline is in
+[`notebooks/12_lower_level_pipeline.ipynb`](../notebooks/12_lower_level_pipeline.ipynb).
diff --git a/examples/chemistry/molecules_tmap.py b/examples/chemistry/molecules_tmap.py
index dc1f3e7..fbf8fce 100644
--- a/examples/chemistry/molecules_tmap.py
+++ b/examples/chemistry/molecules_tmap.py
@@ -4,7 +4,7 @@
properties using domain utilities, fit a TMAP, and export an interactive
HTML visualization.
-For the step-by-step low-level pipeline, see smiles_tmap.py.
+For the step-by-step low-level pipeline, see notebooks/12_lower_level_pipeline.ipynb.
Usage:
python examples/chemistry/molecules_tmap.py
diff --git a/examples/chemistry/smiles_tmap.py b/examples/chemistry/smiles_tmap.py
deleted file mode 100644
index ccb2bb8..0000000
--- a/examples/chemistry/smiles_tmap.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""Low-level TMAP pipeline from SMILES strings.
-
-Demonstrates each step of the pipeline explicitly:
- SMILES → Morgan fingerprints → MinHash → LSHForest → OGDF layout → TmapViz
-
-For a simpler high-level approach, see molecules_tmap.py which uses the
-TMAP estimator to do all of this in a few lines.
-
-Requirements:
- pip install rdkit
-
-Usage:
- python examples/chemistry/smiles_tmap.py
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import pandas as pd
-
-from tmap import LSHForest, MinHash, fingerprints_from_smiles, molecular_properties
-from tmap.layout import LayoutConfig, ScalingType, layout_from_lsh_forest
-from tmap.visualization import TmapViz
-
-# Scripts live in a subfolder; data, caches and outputs stay at examples/.
-EXAMPLES_DIR = Path(__file__).resolve().parents[1]
-
-
-DATA_PATH = EXAMPLES_DIR / "cluster_65053.csv"
-
-
-def main() -> None:
- # 1. Load SMILES and compute fingerprints
- df = pd.read_csv(DATA_PATH)
- smiles = df["smiles"].tolist()
- print(f"Loaded {len(smiles):,} molecules")
-
- fps, valid = fingerprints_from_smiles(
- smiles, fp_type="morgan", radius=2, n_bits=2048, return_valid=True
- )
- # A SMILES that cannot be read gets no fingerprint, and so no point on the
- # map. Drop it, so the list still matches the coordinates worked out below.
- smiles = [smi for smi, ok in zip(smiles, valid) if ok]
- n = fps.shape[0]
- print(f" Valid fingerprints: {n} x {fps.shape[1]}")
-
- # 2. MinHash encoding
- # Converts binary fingerprints into compact hash signatures for
- # fast approximate Jaccard similarity search.
- num_perm = 128
- mh = MinHash(num_perm=num_perm, seed=42)
- signatures = mh.batch_from_binary_array(fps)
- print(f" MinHash signatures: {signatures.shape}")
-
- # 3. Build LSH Forest index
- # Locality-sensitive hashing index for fast approximate kNN queries.
- # d = number of permutations, l = number of hash tables.
- lsh = LSHForest(d=num_perm, l=64)
- lsh.batch_add(signatures)
- lsh.index()
- print(f" LSH Forest indexed ({lsh.size()} points)")
-
- # 4. Compute OGDF layout
- # layout_from_lsh_forest queries the kNN graph internally,
- # computes an MST, and runs the OGDF tree layout algorithm.
- # Returns (x, y, edge_sources, edge_targets).
- cfg = LayoutConfig()
- cfg.k = 20
- cfg.kc = 50
- cfg.node_size = 1 / 30
- cfg.mmm_repeats = 2
- cfg.sl_extra_scaling_steps = 10
- cfg.sl_scaling_type = ScalingType.RelativeToDrawing
- cfg.fme_iterations = 1000
- cfg.deterministic = True
- cfg.seed = 42
-
- x, y, s, t = layout_from_lsh_forest(lsh, cfg)
- print(f" Layout: {len(x)} nodes, {len(s)} edges")
-
- # 5. Build visualization
- # TmapViz takes pre-computed coordinates and edges directly.
- props = molecular_properties(smiles, properties=["mw", "logp", "n_rings"])
-
- viz = TmapViz()
- viz.title = "Molecular TMAP (low-level pipeline)"
- viz.background_color = "#FFFFFF"
- viz.set_points(x, y)
- viz.set_edges(s, t)
-
- viz.add_smiles(smiles)
- viz.add_color_layout("MW", props["mw"].tolist(), color="viridis")
- viz.add_color_layout("LogP", props["logp"].tolist(), color="plasma")
- viz.add_color_layout(
- "Ring Count",
- props["n_rings"].tolist(),
- categorical=True,
- color="tab10",
- )
-
- out = viz.write_html(str(DATA_PATH.with_suffix(".html")))
- print(f"\nSaved: {out}")
-
-
-if __name__ == "__main__":
- main()
diff --git a/examples/text/word_embeddings_tmap.py b/examples/text/word_embeddings_tmap.py
index af1cc30..6846f90 100644
--- a/examples/text/word_embeddings_tmap.py
+++ b/examples/text/word_embeddings_tmap.py
@@ -1,6 +1,6 @@
-"""Word embedding TMAP — semantic map of English words.
+"""Word embedding TMAP: a semantic map of English words.
-Embed ~800 common English words with a sentence-transformer, build a TMAP
+Embed ~1,200 common English words with a sentence-transformer, build a TMAP
with cosine metric, and explore semantic neighborhoods: animals cluster near
animals, countries near countries, and the tree paths between them reveal
thematic transitions (e.g., "salmon → trout → bass → guitar").
@@ -42,7 +42,7 @@
OUTPUT_DIR = EXAMPLES_DIR
-# Vocabulary: ~800 words across 15 semantic categories
+# Vocabulary: ~1,200 words across 19 semantic categories
VOCABULARY: dict[str, list[str]] = {
"animals": [
diff --git a/notebooks/01_quickstart.ipynb b/notebooks/01_quickstart.ipynb
index 8ca588d..90bd070 100644
--- a/notebooks/01_quickstart.ipynb
+++ b/notebooks/01_quickstart.ipynb
@@ -40,7 +40,10 @@
"df = pd.read_csv(\"../examples/cluster_65053.csv\", nrows=2000)\n",
"smiles = df[\"smiles\"].tolist()\n",
"\n",
- "fps = fingerprints_from_smiles(smiles, fp_type=\"morgan\", radius=2, n_bits=2048)\n",
+ "fps, valid = fingerprints_from_smiles(\n",
+ " smiles, fp_type=\"morgan\", radius=2, n_bits=2048, return_valid=True\n",
+ ")\n",
+ "smiles = [s for s, ok in zip(smiles, valid) if ok] # drop SMILES that RDKit could not read\n",
"print(f\"Loaded {len(smiles):,} molecules\")\n",
"print(f\"Fingerprint matrix: {fps.shape}\")\n"
]
@@ -69,7 +72,7 @@
}
],
"source": [
- "model = TMAP(metric=\"jaccard\",seed=42).fit(fps)\n",
+ "model = TMAP(metric=\"jaccard\", seed=42).fit(fps)\n",
"\n",
"print(model.embedding_.shape)\n",
"print(model.tree_.edges.shape)\n"
@@ -81,7 +84,7 @@
"source": [
"## Notebook View\n",
"\n",
- "Use `to_widget()` when you want an interactive Jupyter view.\n"
+ "Use `to_widget()` when you want an interactive Jupyter view. The widget draws points only and warns that the tree edges are ignored. The HTML export below includes them.\n"
]
},
{
@@ -97,14 +100,6 @@
"execution_count": 3,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_37637/684963885.py:5: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n",
- " widget = viz.to_widget(width=1000, height=650, controls=True)\n"
- ]
- },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
diff --git a/notebooks/02_cheminformatics.ipynb b/notebooks/02_cheminformatics.ipynb
index 297a8ef..f89827d 100644
--- a/notebooks/02_cheminformatics.ipynb
+++ b/notebooks/02_cheminformatics.ipynb
@@ -66,7 +66,11 @@
"source": [
"from tmap.utils import fingerprints_from_smiles, molecular_properties, murcko_scaffolds\n",
"\n",
- "fps = fingerprints_from_smiles(smiles, fp_type=\"morgan\", radius=2, n_bits=2048)\n",
+ "fps, valid = fingerprints_from_smiles(\n",
+ " smiles, fp_type=\"morgan\", radius=2, n_bits=2048, return_valid=True\n",
+ ")\n",
+ "smiles = [s for s, ok in zip(smiles, valid) if ok] # keep labels aligned with fingerprint rows\n",
+ "\n",
"props = molecular_properties(smiles, properties=[\"mw\", \"logp\", \"n_rings\", \"qed\"])\n",
"scaffolds = murcko_scaffolds(smiles)\n",
"\n",
@@ -98,7 +102,9 @@
"source": [
"from tmap import TMAP\n",
"\n",
- "model = TMAP( metric=\"jaccard\", n_neighbors=20, n_permutations=512, kc=50, seed=42,).fit(fps)\n",
+ "# Dense 0/1 fingerprints go to the USearch Jaccard index.\n",
+ "# n_permutations and kc only apply to sets, strings and sparse input (MinHash + LSHForest).\n",
+ "model = TMAP(metric=\"jaccard\", n_neighbors=20, seed=42).fit(fps)\n",
"\n",
"print(model.embedding_.shape)\n",
"print(model.tree_.edges.shape)\n"
@@ -131,7 +137,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## 5. Explore In Jupyter\n"
+ "## 5. Explore In Jupyter\n",
+ "\n",
+ "The widget draws points only and warns that the tree edges are ignored. The HTML file in the next step includes them.\n"
]
},
{
@@ -139,14 +147,6 @@
"execution_count": 5,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_85663/54314555.py:1: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n",
- " widget = viz.to_widget(width=1000, height=650, controls=True)\n"
- ]
- },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
diff --git a/notebooks/03_continuous_embeddings.ipynb b/notebooks/03_continuous_embeddings.ipynb
index 54e7c90..6e2ccc2 100644
--- a/notebooks/03_continuous_embeddings.ipynb
+++ b/notebooks/03_continuous_embeddings.ipynb
@@ -7,7 +7,7 @@
"source": [
"# Continuous Embeddings on MNIST\n",
"\n",
- "Most data is not binary. TMAP supports cosine and euclidean for dense vectors. Both go through USearch (HNSW) under the hood. This notebook walks through both metrics on MNIST so you can see what the output looks like and pick the right one for your data.\n",
+ "Most data is not binary. TMAP supports cosine and euclidean for dense vectors. Both go through USearch, which uses exact search below 50,000 points and HNSW at 50,000 points and above. The 10,000-point MNIST sample here uses exact search. This notebook walks through both metrics on MNIST so you can see what the output looks like and pick the right one for your data.\n",
"\n",
"You will need scikit-learn for the MNIST download:\n",
"\n",
@@ -222,7 +222,7 @@
"\n",
"For binary fingerprints (molecular Morgan, MACCS, ECFP), use `metric=\"jaccard\"`. The estimator auto-routes to USearch with native Jaccard distance on the bits. See `02_cheminformatics.ipynb` for a full chemistry walkthrough.\n",
"\n",
- "For sparse single-cell data, `metric=\"jaccard\"` with a CSR matrix routes to MinHash and LSHForest. See `05_single_cell.ipynb` for that path.\n"
+ "For sparse binary data, `metric=\"jaccard\"` with a SciPy sparse (CSR) matrix routes to MinHash and LSHForest, as do lists of feature indices and lists of strings. See `07_minhash_deep_dive.ipynb` for how MinHash works.\n"
]
},
{
@@ -232,13 +232,13 @@
"source": [
"## Next\n",
"\n",
- "Now that you have a fitted TMAP, head to `04_new_functionalities.ipynb` to learn how to add new points, project held-out data, measure recall, and walk paths in the tree.\n"
+ "Now that you have a fitted TMAP, head to `04_working_with_a_fitted_model.ipynb` to learn how to add new points, project held-out data, measure recall, and walk paths in the tree.\n"
]
}
],
"metadata": {
"kernelspec": {
- "display_name": "tuputamadre",
+ "display_name": "Python 3",
"language": "python",
"name": "python3"
},
diff --git a/notebooks/04_new_functionalities.ipynb b/notebooks/04_working_with_a_fitted_model.ipynb
similarity index 81%
rename from notebooks/04_new_functionalities.ipynb
rename to notebooks/04_working_with_a_fitted_model.ipynb
index ead7ad0..3fcc847 100644
--- a/notebooks/04_new_functionalities.ipynb
+++ b/notebooks/04_working_with_a_fitted_model.ipynb
@@ -5,11 +5,11 @@
"id": "2cf66838",
"metadata": {},
"source": [
- "# What's New in TMAP\n",
+ "# Working with a fitted model\n",
"\n",
- "Once you have fit a TMAP, here is what you can do with it. Some of these features (incremental updates, tree paths, named distances) are things UMAP either cannot do or does not do as cleanly.\n",
+ "Once you have fit a TMAP, you can keep using the model. This notebook shows how to add new points, project held-out points, look up their nearest neighbors, check kNN recall, walk the tree, save and load the model, fit on a kNN graph you built yourself, and deal with a kNN graph that splits into pieces.\n",
"\n",
- "We continue with the MNIST data from `03_continuous_embeddings.ipynb`: same 10k subsample, same cosine metric. The first 8,000 rows are the training set. The last 2,000 are held out for the `add_points` and `transform` demos.\n",
+ "We continue with the MNIST data from `03_continuous_embeddings.ipynb`: same 10k subsample, same cosine metric. The first 8,000 rows are the training set. The last 2,000 are held out for the `add_points`, `transform` and `kneighbors` demos.\n",
"\n",
"You will need scikit-learn (same as notebook 03).\n"
]
@@ -73,6 +73,11 @@
"\n",
"print(f\"train: {X_train.shape}, held: {X_held.shape}\")\n",
"\n",
+ "# store_index=True keeps the cosine index after fit(). add_points, transform\n",
+ "# and kneighbors need it and raise a RuntimeError without it.\n",
+ "# Below 50,000 points the cosine search is exact, so this fit gives the same\n",
+ "# map on every run. On larger data TMAP builds an HNSW index on several\n",
+ "# threads; add reproducible=True there to make runs identical.\n",
"model = TMAP(metric=\"cosine\", n_neighbors=20, seed=42, store_index=True).fit(X_train)\n",
"print(f\"base embedding: {model.embedding_.shape}\")\n",
"\n",
@@ -199,48 +204,67 @@
"plt.show()\n"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "3c6da5d7",
+ "metadata": {},
+ "source": [
+ "## 3. kneighbors\n",
+ "\n",
+ "`kneighbors` returns the nearest fitted points for new data. Like `transform`, it leaves the model unchanged. `transform` uses the same lookup to place each new point next to its nearest training point.\n",
+ "\n",
+ "You get one row per query and `n_neighbors` columns, sorted from nearest to farthest. Distances use the fitted metric, so here they are cosine distances. Pass `return_distance=False` to get the indices alone.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4da4f9fc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "neigh_idx, neigh_dist = model_t.kneighbors(X_held)\n",
+ "print(f\"indices: {neigh_idx.shape}, distances: {neigh_dist.shape}\")\n",
+ "print(f\"nearest training point to held-out row 0: idx {neigh_idx[0, 0]}, cosine distance {neigh_dist[0, 0]:.3f}\")\n",
+ "\n",
+ "# indices only\n",
+ "neigh_idx = model_t.kneighbors(X_held, return_distance=False)\n",
+ "\n",
+ "# a quick check: does the nearest training digit have the same label as the query?\n",
+ "same_label = (y_train[neigh_idx[:, 0]] == y_held).mean()\n",
+ "print(f\"held-out digits whose nearest training digit has the same label: {same_label:.1%}\")\n",
+ "print(f\"model_t.embedding_ shape: {model_t.embedding_.shape} (unchanged)\")\n"
+ ]
+ },
{
"cell_type": "markdown",
"id": "2c874921",
"metadata": {},
"source": [
- "## 3. Measuring kNN recall\n",
+ "## 4. Measuring kNN recall\n",
"\n",
- "When TMAP uses an approximate index (HNSW for cosine and euclidean, LSHForest for sparse Jaccard), the kNN graph is approximate. A reasonable question to ask is: how close is the approximate index to the exact answer?\n",
+ "TMAP builds its tree from a kNN graph, so it is worth checking how close that graph is to the exact answer.\n",
"\n",
"We define recall@k as: for each point, what fraction of its true k nearest neighbors (computed by brute force in the original space) appear in TMAP's k nearest neighbors. A recall of 1.0 means TMAP's index found exactly the same neighbors as brute force. A recall of 0.5 means it missed half.\n",
"\n",
- "For cosine on MNIST at k=20, expect recall in the 0.95 to 0.99 range.\n"
+ "For cosine and euclidean data, TMAP searches exactly below 50,000 points and uses an approximate HNSW index from 50,000 points up. This 8k subset is below that cutoff, so recall here should be 1.0, give or take a tie: when several points sit at the same distance, the two methods can keep different ones. On larger data, run the same check to see how close the HNSW graph gets. Binary Jaccard input always uses HNSW, and sets, strings and sparse input use MinHash + LSHForest, which is also approximate.\n",
+ "\n",
+ "TMAP leaves each point out of its own neighbor list. Calling `kneighbors()` with no argument on a fitted scikit-learn `NearestNeighbors` does the same. Passing `X_train` again would return each point as its own nearest neighbor and pull the recall down.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "32ca10f4",
- "metadata": {
- "execution": {
- "iopub.execute_input": "2026-04-30T10:10:38.909044Z",
- "iopub.status.busy": "2026-04-30T10:10:38.908949Z",
- "iopub.status.idle": "2026-04-30T10:10:42.925306Z",
- "shell.execute_reply": "2026-04-30T10:10:42.924713Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "recall@10: 0.896\n",
- "recall@20: 0.946\n"
- ]
- }
- ],
+ "metadata": {},
+ "outputs": [],
"source": [
"from sklearn.neighbors import NearestNeighbors\n",
"\n",
"k = 20\n",
"nn = NearestNeighbors(n_neighbors=k, metric=\"cosine\").fit(X_train)\n",
- "true_distances, true_neighbors = nn.kneighbors(X_train)\n",
+ "# no argument: each point is left out of its own neighbor list, as in TMAP\n",
+ "true_distances, true_neighbors = nn.kneighbors()\n",
"\n",
"# tmap stores its kNN graph in model.graph_\n",
"tmap_neighbors = model_t.graph_.indices # shape (8000, k)\n",
@@ -265,13 +289,15 @@
"id": "5a2633a3",
"metadata": {},
"source": [
- "## 4. Tree exploration: path, distance, distances_from\n",
+ "## 5. Tree exploration: path, distance, hops\n",
"\n",
- "The tree layout is what makes TMAP different from UMAP. Once a tree is built, every pair of points has a unique path along the tree, and the sum of edge weights along that path is a meaningful distance.\n",
+ "TMAP lays out a tree. Every pair of points has a unique path along the tree, and the sum of edge weights along that path is a meaningful distance.\n",
"\n",
"- `model.path(i, j)` returns the list of node indices along the tree path from `i` to `j`\n",
"- `model.distance(i, j)` returns the sum of edge weights along that path\n",
- "- `model.distances_from(i)` returns tree distance from `i` to every other point, useful as pseudotime\n"
+ "- `model.distances_from(i)` returns tree distance from `i` to every other point, useful as pseudotime\n",
+ "- `model.hops(i, j)` returns the number of edges on that path, ignoring their weights\n",
+ "- `model.hops_from(i)` returns the hop count from `i` to every other point\n"
]
},
{
@@ -337,12 +363,31 @@
"plt.show()\n"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1a6916c7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# hops count edges and ignore their weights\n",
+ "print(f\"hops from idx {i} to idx {j}: {model_t.hops(i, j)} (the path has {len(path)} nodes)\")\n",
+ "\n",
+ "hop_counts = model_t.hops_from(i)\n",
+ "print(f\"farthest point from idx {i}: {hop_counts.max()} hops\")\n",
+ "\n",
+ "# the tree neighborhood of i: every point within 5 hops, counted by digit label\n",
+ "nearby = np.where((hop_counts > 0) & (hop_counts <= 5))[0]\n",
+ "print(f\"{len(nearby)} points within 5 hops of idx {i}\")\n",
+ "print(f\"labels (counts for digits 0 to 9): {np.bincount(y_train[nearby], minlength=10)}\")\n"
+ ]
+ },
{
"cell_type": "markdown",
"id": "4f48a3be",
"metadata": {},
"source": [
- "## 5. save and load\n",
+ "## 6. save and load\n",
"\n",
"Persist a fitted model to disk and reload it later. Uses pickle under the hood.\n"
]
@@ -388,46 +433,23 @@
"id": "92e863a7",
"metadata": {},
"source": [
- "## 6. External kNN\n",
+ "## 7. External kNN\n",
+ "\n",
+ "If you already have a kNN graph from another tool (FAISS, ScaNN, hand-built), pass it directly via `fit(knn_graph=...)`. TMAP skips the index step and goes straight to layout.\n",
"\n",
- "If you already have a kNN graph from another tool (FAISS, ScaNN, hand-built), pass it directly via `fit(knn_graph=...)`. TMAP skips the index step and goes straight to layout.\n"
+ "Leave each point out of its own neighbor list. TMAP drops self-matches, so a graph that includes them gives each point one real neighbor fewer. The brute-force result from the recall section already leaves them out.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d9299e22",
- "metadata": {
- "execution": {
- "iopub.execute_input": "2026-04-30T10:10:43.116958Z",
- "iopub.status.busy": "2026-04-30T10:10:43.116863Z",
- "iopub.status.idle": "2026-04-30T10:10:43.984246Z",
- "shell.execute_reply": "2026-04-30T10:10:43.983832Z"
- }
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "external kNN embedding: (8000, 2)\n"
- ]
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAH4CAYAAABQVwcWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd4XNW1tr/Tphf1ZlmSu7GNjbHpkNDBhBCSkEsKhOSmQW5CevlDei6BkJACaTcJIXQSCBB6MR1swDbuVW7q0mh6n1P/Z+3RyJIsyZIty5K93+cRZtqZc86U/c1a31pLsCzLAofD4XA4HM4kRDzSO8DhcDgcDodzsHAhw+FwOBwOZ9LChQyHw+FwOJxJCxcyHA6Hw+FwJi1cyHA4HA6Hw5m0cCHD4XA4HA5n0sKFDIfD4XA4nEkLFzIcDofD4XAmLVzIcDgcDofDmbRwIcMZd5LJJD772c+iqqoKgiDgq1/9Kvbu3cv+/x//+Ad/RSY49Dr9+Mc/7r1MrxldR6/h0cqnPvUpNDQ0HPB+h+N9PNLzS/vo8XjG7HmPFfh5m/xwITPBoS+wkfy98sorvV+i9Pe///u/g27vE5/4BLt9uC+8k08+md3nT3/607BfrIU/h8OB2bNn40tf+hK6uroOeEw///nP2Tauu+463HPPPbj66qsHvd/TTz/db8E8Gkmn0+wY6fXjcMaDs88+m31u3//+9+93W+E75Fe/+lXvdfTeLHzW16xZs99juBDgHGnkI70DnOGhhb4vd999N1544YX9rj/uuOOQyWTY/5OweOCBB/D973+/331SqRT+85//sNuHorGxEatWrWK/Pu+77z4mNobipz/9KaZNm4ZsNos33niDCR8SH5s2bYLL5RrycS+99BJOPfVU/OhHP+q9jkZ+0f4ritJ7HW3rD3/4w1EtZkjI/OQnP+ldYDgTk7/+9a8wTRNHE08++SQTJkuWLBnxY+iz+MQTTxzW/eJwRgsXMhOcq666qt/lt956iwmZgdcThdDzJZdcgkceeQTr16/HokWLem8nEaOqKi6++GImJgbj3nvvRUVFBW699VZcccUVbJtDhdSXLVuGpUuXsv+nVFFpaSl+/etfs+f52Mc+NuQxBQIBzJs3r991hcgOZ2wg0ep2u4+500mi2mazQRTHNtjcV2AfDdTV1SGRSDAR/fjjj4/oMSeccAITP++++y5OPPFEjCe6rjMhSa8thzMQnlo6CjnttNNYpOT+++/vdz1FWEjElJSUDPlYegwJmEsvvRR+v3+/bQzHueeey/7ds2fPoLcXQtR0+1NPPdUbriaxNNBbQOFqisYQfdNYB+KPf/wj5s+fD7vdjpqaGvzP//wPotFov/tQ5GPBggXYsmULzjnnHBY9mjJlCm655ZYRHysJPvol63Q62fn86Ec/ipaWlt7b77zzTra/f//73/dLq9H1FG2iYy4vL2fX04JSOMa+Eaht27ax14Oeg4QeCceBC08h1ffqq6/ii1/8IhOitbW1ozpWErg//OEP2THR604i6KyzzsLLL7+M0XLNNdegrKwMmqbtd9uFF16IOXPmDPv4wj5TtOD0009n55jez3/+858HfT89+OCDLPpIx0XHF4/H2e0PPfRQ72tE+0Piv62trffxlD6hxzc1Ne23D//v//0/tmhGIpEhPTL0vqLr6XwVFRWx4x74XhvN60hs3ryZfY5on+k1pBTxoUSC1q1bx95jdE7Jm1bA6/Xia1/7GouukDAZCV/+8pdRXFx8SBFSek3oRwydA3qNH3300f3Obd/01m9/+1vMmDGDfZ7pPTzS92nfbfzmN79BfX09O6fvfe97WcR4MOi9cfnll7O0O52zb37zmzAM46CPlTOOWJxJxf/8z/9YQ71se/bsYbf98pe/tL73ve9ZdXV1lmma7Lbu7m5LlmXrgQcesK655hrL7Xbv9/i33nqLPf71119nl//7v//bmjdv3n73u/POO9n9Vq1a1e/63/3ud+z6P//5z4PuX2dnp3XPPfdYZWVl1gknnMD+n/6SyWTvvtO2iRUrVlgXXHABu65wP/objh/96Efs/ueff751++23W1/60pcsSZKsk046yVJVtfd+733ve62amhpr6tSp1le+8hXrj3/8o3Xuueeyxz799NPWgfjf//1fSxAE68orr2SP/clPfsKOqaGhwYpEIr33u/TSSy2/3281Nzezyxs2bLBsNpv1mc98hl2m4/7Tn/7EnveDH/xg7zGuX7+e3b5p0yb2eHoNfvGLX1i///3vrfe85z3suR955JH9Xg+6Hx0bHfvNN988qmOl90d1dbX19a9/ne3TLbfcYs2ZM8dSFMVau3Ztv+Onx9K5Hvj89BoSL7zwArv8xBNP9HtcR0cHez1++tOfDnt+C/tcUVHBXsPbbrvNOvPMM9k277jjjt77vfzyy73HTe+nX//619ZNN91kpVKp3n2i1/43v/mN9d3vftdyOp39XqOmpiZ2LulYBzJ9+nTrfe97X+9l+szU19f3XqbPFb0WoihaX/ziF9k5p/O6cOHCfu/j0byOdH7Ky8ut4uJi68c//jH7HM+aNat3m4XzOxQDP9fvvPMO2xZ9jtLpdL/zO3/+fCsWi7Hb3//+9w/6HTLwPD/00EPstaP/X7NmzZDPOxRPPvkkO2Y6HnqtfvCDH7DnX7BgQb9zW9gHOl/0OtB7mV5Der1G+j4tbOP4449nrzmdd/qclpSUsHNM30V999/hcLBzQt95tN0Pf/jD7PH0eeFMfLiQOUqFDH159hUlf/jDHyyPx8O+5If64qFFgxa8gvh5/vnn2TYGLmSFRWL58uXsi6WlpcV68MEHrdLSUrZYtLa2DnsM9KXVd5Hou+99F4DhjnUggUCAiYQLL7zQMgyj93paNGgbf//73/t9kdN1d999d+91uVzOqqqqYl9gw7F37162GN944439rt+4cSMTin2vp4WJvjhpIaHtL168mIlLWkAK0PkbKAwKnHfeeeyLOJvN9l5Hr83pp5/OFriBrwct9rqu99vGSI+VHkfX94UW/MrKSvblPhohQ+e/traWCb2+0OJFC9nu3buHOLv99/nWW2/tt88kVkjcFERpYYGlxa7vQk230/1ogcxkMv0WUrr/D3/4w97rTjvtNGvJkiX9np8EwMBzNlDIPPbYY+w+fUUQncOzzjprv/fxSF/Hr371q+yxb7/9dr/3NYmg0QqZN954w/L5fOxz1vd5C+eXFm2CFve+wuRAQiYajTLxcdlllw36vMNB54DeF4lEove6V155hW17MCFD+0/H35eRvk8L2xj4fUTnlq7/2te+1m//6bqBAps+rwPfG5yJCU8tHaVQemXhwoXM9EtQiugDH/jAkCZcykH/85//xJVXXtmbwqEQN6UpKCU1GOeffz4LwU6dOpWlVigkS6FiCvGPN8uXL2dhZyrl7uuP+NznPgefz8dSWX2hfe3rM6I0AlVr7d69e9jnIe8Rhfr/67/+C8FgsPePSslnzZrVL8RN11F6jDxNFP6mMD+lmmh/DkQ4HGY+Jnoe8jIUnicUCuGiiy5ipuy+aZLCsUqStN+2RnKs9LiC/4COj56f3hOUAhlp6qEAnX+qjqPUCe17AXofUaqI0kQHQpZlfOELX+i3z3SZ/FUDK2copUNpgwKrV69m96M0W1/f1fve9z7MnTu333uB3u+0vV27dvVeR58DSmXQ52UoKDVI+9jXDE/nkNIvB/s60jbJBE+vTQH6fNG5HA30HqRtn3feeez9SscyFF/5yldYuqhgOD8QlM6hzxi9tmvXrh3xPrW3t2Pjxo345Cc/2a9iklI9xx9//KCP+fCHP9ybej3Y9ymlivp+H9G5PeWUU9i5Hsi1117b7zJ9Zg/0fcCZGHAhcxTz8Y9/nOWkd+7ciRUrVrDLQ/H888+ju7ubfdDp/vRHXhbyVZAYGixPX1ik6YuT8tf0oacv0CNBwecw0H9BX3rTp0/fzwdB/oOBnhv6Qi94IoaCFh4KSpBooS/Zvn9bt25lC2hfSODRAvrOO+8woUGLy0ig80/P84Mf/GC/5ylUew18rqEEwkiP9a677mLilxZ/Mm7Tc9GiH4vFMFpowaIqNBK2xPbt25lgGKrUfiDkbxpoVqYSf2JgP5WBxz3Ue4EgIdP3vfCRj3yECS8SLwSdc/rMkJF9OMFJ26iurt6vjcHA5xzN60jbpPfVQA7kKRpodqb32+LFi/Gvf/3rgObYgxEmJH7IEzQar0zhnM+cOXO/2wa7brj382jep4OdT3ofDXwP0bYGiqaRfB9wJga8aukohiqHyLRICyh94MloORSFqAv9chwMMpKSqOkLiZ5C1dJkY7DIBZHPnAwNCToSBc8888yQ0Y++0C9vihAQJPbo8SOpqCkIRzIcDiUOBy4AfaMSoz1WMi+T6ZJ+wX7rW99ikTh63E033dQvWjFSyNBJhkzaLoka+pcW1aHeX4fCUMc9UsFEv7xp0f/e977HqgKbm5vxi1/8Ykz27WBex0OBoi9UtUiVg88++ywz7Y9EmJAhlqIyZK49EAXxQ0JmNFGZsXhdx/p9eqDPCGdywIXMUQyVWJ5xxhmsuoNC4BQKH4xCfxkKs1NlxUCuv/56JnQGCpnDzUiqlApQVULhlz9FYApQuokiS5QGGwuogoIEAP1aLEQIhoOqpiilQF+0JCppofj6179+wGMsHAOV/Y7Vvg/Hww8/zJ6TUhF996lvr5/RQgKGjrWjo4OlNilSQL9yR5qKGFhCvmPHDvbvgTrs9n0vFCrpCtB1hdsL0Pue0lB0G0VmKP06WLO4gc/x4osvskqgvuKVtnGwryNtkyJ+Axm4zeGg144+q5QWo2gTCe4D9SfqK0woTTcS6P70XibxQ9GZA1E45xShGshg143V+3Sw80nvo5F0aeZMHnhq6SiHyjfpQz4wd98XCv/TokGLLgmZgX/0q+7f//43crncuO57YREbqqS1L7RI0C/+2267rV+k4Y477mAhZ1pEx4IPfehD7NcbfYEPjN7QZYrA9P3SpYXx5ptvxne/+12WZqIy4cKCTBQ8SwOPkX5p0gL0f//3f0wIDITSgGNJ4Rdp32N6++23sXLlykOKCNJiQ7/4Ke04WO+joSDfAx17X0FKlyn8f6AGbhQlpPNH5dp937O0qFP6b+B7gbwYdPyUQqW0Er3fD9SDh6IetI99u19Tqe7tt99+0K8jbZMiQpSG7Hv7UB61oaDPAS30J510EhNkfbc3nDAhQUJNLkdCQfzQDyDyfo0k8kXl1tTQs28ZOEV6yTtzuN6njz32WD8vGZ0Luj+lDjlHDzwic5RDZjr6Gw76oqTUExkxB+Oyyy5jnU0pD00L+XhRWLAoIkRhefoSIzEwGLTAUcSDBAb1yqF9pl+y1FeGvtBHs4geKCJD4pCei/LsFOKmnhwU9SFB+PnPf56lEcj3QFEwimLR6Abi97//PfMTUWicOiFTionC55SGIcFDER7qM0Jf+PRHHqQzzzyTmSEpPUi/RGkEBH1pt7a2soaHYwUt3rT4ffCDH2QLPR0PCQHat74Lz2ig14ReCxIHtEiORkzSwkfpHTrHdF7o/NCC+Ze//OWAzenodnrspz/9afbeJ0FF5+13v/sd+yVO/VMGig16naiZI0XPKEJzIEggULSTBCrtI50nOn+D+TRG+jp++9vfZh276ZyR+CMxRcdL0YwNGzZgNND7iprXUUSKFm0SDPSeGk6Y0HOO1PTbNyVF+z+S5ovUQ4kiRXTe6LUh/wl9Jmi/RvoeG+37lNJ2dO7ps0iilqJI9F1H55pzFHGky6Y4h6f8ejj6lkt2dXWxsuGrr756yPtTaavL5WK9TobrIzNSRlp+TaWWX/7yl1nfByrbHcnblcqt586dy/pKUEnmdddd16+3y8Dy074MLLEdjn//+9+s3JnOI/3Rc9Jrs337dnb7hz70Icvr9bJy7b785z//YcdBfS0KUM8cKvOk8vGBpc27du2yPvnJT7JyaTqmKVOmsP40Dz/8cO99hns9RnqsVA7885//nF1nt9tZ6SmVKw92Tg5Uft2Xf/3rX+y2z3/+8yM6r333efXq1aw8mnp80D7Qa9uXvmXBg/HPf/6THQcdD5XBf+ITnxiyNcBf//pXti16zfqWbBcY7DyEQiH2uaEyYSqRpv+nVgUD38cjfR0LvYbo+OmY6T4/+9nPWO+cg+kjQwSDQdaPhZ63sbGx3/kdCH1OCqXeQ5VfD9W7aSTl1wS1aaDPCr0mVB7/+OOPszYAdN1IvsdG+j7tuw0q46e2EnR/Ko8v9Gka7rz1PTbOxEeg/xxpMcXhcI5OKPVAUavXXnuNmWpHAqViqER5qA6snKMLGn1A0TuqgBwrKEpGPrZf/vKXLELKObrhHhkOh3PYoJQkpVIovM85tqGRFeQr6gsVIlBqig9M5RwK3CPD4XDGHJp/RL4O8lWRN2U0FWicoxMy3ZIpn/xq5IGi+VPkb6HGkQOb0XE4o4ELGQ6HM+aQwZbKkj/zmc+w0mYOh0rvycD/t7/9jVVjkUGYDLtU1UcGXA7nYOEeGQ6Hw+FwOJMW7pHhcDgcDoczaeFChsPhcDgczqSFCxkOh8PhcDiTFi5kOBwOh8PhTFq4kOFwOBwOhzNp4UKGw+FwOBzOpIULGQ6Hw+FwOJMWLmQ4HA6Hw+FMWriQ4XA4HA6HM2nhQobD4XA4HM6khQsZDofD4XA4kxYuZDgcDofD4UxauJDhcDgcDoczaeFChsPhcDgczqSFCxkOh8PhcDiTFi5kOBwOh8PhTFq4kOFwOBwOhzNp4UKGw+FwOBzOpIULGQ6Hw+FwOJMWLmQ4HA6Hw+FMWriQ4XA4HA6HM2nhQobD4XA4HM6khQsZDofDOUjC99yDluu+yP7lcDhHBsGyLOsIPTeHw+FMWki8dP7iFkTsMqIuB2rPfA8W3fSLI71bHM4xh3ykd4DD4XAmI6kVKxFxO7Bt3kyoahZNW9dB/fiVqJ27AP5lF8N10kmHVUTFn34GUmkJSq+55rA+F4cz0eERGQ6HwzlIMbHyL3/E7nI/vG4fdLsN1dt2YnowBtHjwdQ//XFMBMa7z92L7ndXotI3BVUhHanVq5HbuQtWURGEWAyy14va22/jYoZzzMIjMhwOh3MQlFx9NWq3bGKRmEQqDptmR7GvCKZqAfE4On76M1T/8AeHJDDW/eHnsP7vXlQpDkipDEKKAmvKFAjFxRCiUQiGASOVQmbTZi5kOMcsPCLD4XA4h8CW396KvU/8B/5oAkWmALOqClJHB4RcDqLbjfKvXM9ED5FetYqJDueC+QcUHp033ojQfffB9PpgiSIEWYaoaSwKI/SxNkpFRTwiwzmm4UKGw+FwDhESKIHf/haZNe/CkiQYDQ2AIEDeuRMQRTgXnwDfxRcj+Ne/wUwmIXk8mHLrr4YUMyRiwvfcC9PvZ9sSW1shhUL5L+3CnWQZzkULUfHVr/JoDOeYhgsZDofDGSNavvQlJF96GZZpwvR4AI8HYnc3SwGR8GDXJRIQDQPFH/8Yqn74w35iKP7MM8hu34FEYyPMmTMg79rNIjAF7LNmwVZfD6WiHL5ly7iA4XC4R4bD4Yw1b+8OYWNbDMdP8eOU6aXH1AmmCqLsho3QAwFIySRMTYO+cCGEbdsgZzJMyIiZDGAYzLRL4iX2zLPQA13IrF4DLZmEVVMDybIgrV23L4UkipBKSw/Zc8PhHI3wiAyHwxkzfvz4Jjz4Tgto+XUqEr5y/ix8+oxpx9QZLkRWUqvXQN2xA4YkASUlLCqTneuA6e6EskeHK1oBS9Ng5HKISEC8qhI+xQb/rr2QNK13e4LTiaIPXs4jMBzOEHAhw+FwxoQ739yDXz27FS5ZQHfGZNcVuRT831VLjrnITF+vS+T+B0B9RzMnlSF95QIY5mYIuSyKXy6FvLILkYY6bPPZkU0lIKgaFrUEUJLKQnA44D7zTJRe80keheFwhoGXX3M4nDHhzZ1BpDULPpuASpeIrrQJTTdZmulYFTJVN9wArasLiReWw6wyYRjrIQQ7YBYDmt+CJAhIl5dCS0ehZLJQHQ5kFh2P4oaZPALD4YwQLmQ4HM6YcMbMMry4NQBZFNCRNNh1ggDmlTkWoRRT6K67EH/tdZi1tZC3t0M42c1EjJADlCYLYioF1+o1sC06DilFgc1hx9xvfhtV8xYc6d3ncCYNXMhwOBPMKNu6IYCiuIaoT0HtwoojEs1o3bIJ21a+BgEC5px2FmpHsLCSF4bSS9lsDvnEEjClyHlMRmOo62/3726DoaowamogJBJwtBjA/TnolRKUZgFuoQpGWRQl4TDmbNyORH0dvNv2wrVmLcCFDIczYriQ4XAmkIi544EN+GxahN0CvCbwt82dwMcWjqsYIBHz5G23IBWNAJaFbStewwe+ccOIxEy5146mTBYOCUjrgMcx/FcMCR9KSVE052gxBReGSZrl5eyyFAxCSCbZ/zs254DNEqtCKv5/H4Fj7lx0/PgnKNm9G0Ud3YDNgciD/2TX8+okDmdkcCHD4UwQyEtSmTYgeyQENQvlaaA6M/4ek87djcimkqibWw1viY5oa4pFZ0YiZCiNtLU9hpnFe1Dl2oO5U09mAu3JDR3s9ksXVrNjIQFzxxt7EExkkdUtvLwtwG6f7GKGREzgl7+C5fFA0HXWQ6YvziUnQvL54T79tN5uv8UfvRJdN/8CYiiEcFU5muwisjf9EPMufB9OvfZLR+hIOJzJAxcyHM4EQRIFbDB0XKrJKE8LyMDCdsHAJePsMamaPgtTprpQvmQzYHOhaloMUvf8ET3WMIEGXyOuOu5pyEIQJt7ELY8HsaazgXWkfXRtK0s37QkkUe6WMLtUxuYuDYYFPLmhfVILGfLEdP/hjzCcTiCTgRiN7rvRbofs9w/ahbcgaBr/9U+s80iw19Qi1d2FN19+Frb6Opy47LLxPhQOZ1LBhQyHM0HY3Z3CZsHA3xQNJQC2wUDlrLIj4jGpnO6BIacgaMUw7Ul4S9pH9LiueBa1nma4bZXoTKgodkRQ6WyCV5kGSRJgWhYsLYsih4iulMFMwQU/TanbjskMzVCCaUJMpwFd39cD5ooPQ6mZMux8JRIzZjKC3MvPIdvaBGdRMfRcFntef4ULGQ7nAHAhw+FMEEgEUMXP2xkNcViwyyK+d+b4RijIH/PGH+9FeWkxpBoRprMblpVD3LESgS0voWLeuUM+llJIK3cGMbNoOnJGK4odceQMG5oTU3FcmYKWhIFo1sSusA6bLEDfN/cQHruMz4zzsY41JFQkfz56ZhkG3Kedyjr9jtTrMvW952LNW68jl81ATaVgc7nheXcDWr70ZT6SgMMZBi5kOJwJ1LLfbRMQyZqQnLsxpSYMyUWG0fGLyGx9dRsWuM6ABDsike3I1XQApgemnEJn11PDChnywSRUAzvCDdgQLIWCVmwJ+9CamAoRGovIyCKQoehFj4pRJAHnzKlgImayVzeRYKn5+Y0jnm49EPIgXf6dH+HNX9+MZFcXpto9qG0LIBGIQMhkkFj+4rCDJjmcYxUuZDicwyxirn9gLZI5ikKIuHRhTa/hdTBEARAcu+GoeRhBWcO3X12BW957I5ZWLR2X18nUSqAIGlKZBCRzKmDpsKw97La40CeEMgQ2CTheiaBrWwRhqRJbzFIk1ELyyILY5zgX1xXj2xfNmfQCpi8kMg5FaJSkMli8aReMaJSNebCqqmAaBuR0GnosxkQSbb8wBsGCAP+yi7m44RzTFL5XOBzOCKGKm8/etYr9eyAoStGdzAGWiWRWw/3vNOPLD6xlAqcvdHl9S5T1bRGdbbDLgNOoQncqjmd2rBq316ZiyUykBAUOFMFqnYt0tg0WypFS/Xhw74L99rsv08tdOE4IYn7zS2hoW4Ulobfhi7f13m6TBLY4k4gp89iPOhEzFpA4MWIxmBUV0CsrYcoyrLIydpsgCBBkiaWamj/zWYQefwLRBx5A69e/wYQNh3OswiMyHM4oIPFy89NbmWn1pW0BNIVS+PFlC4b1vdDCXe4WkVItdKdNBJM5JnD6LuKUesrqBmyCBbdehzJ5D9rMJsCw46nVEtZvXoHjqn3DRnPGgsVn1GEtgE0bAliTW4i1Gz+JucVdSBkz8GJTJV7ZsxrfuHB2b3VRIW0micATa5rhTnQC6QRCkhvFRhQzK5MoSJmPn1LHqpqIw30ckxWKsBBCJAKlZ3Ck5fOxcm4yEHdRfxrDAEjcUG8ay4IZj/dGajicYxEuZDicUfDAO83IGRaqPCI6kybufasZ9aXuIcuGK30O6CbQnTThs+cXKWuQDA35Z1TdQqVHQFydhl27DYjOaTAzU6DlpiAqRLG6KYLnNnfi9o8tPuxihv7ir+/GY8/Nxo7ITDhlAUV2AdGcjluf24551T52X4oupXI6qj0SwlkTx5VNhRFajyIrjYwuo8X09cZ9WyMZ/O0avtgOB6WJEk8/zaIyhGW3w1QUWCUlEJuaAEmCVVfH/p+maTMUhXlyOJxjFS5kOMeEiXasojFt4RTsIpDMWWxxJ9Pq75Y3soV9sH2gyMPDa1qQ0kxWckyQjqEIxsDjqC2yIZtTYVoCquSZgDoLogykTBNxNa9+yGszXg3y6Lz6nQq6Ezl2nOUuiR1HUjXwjX+tR5XfgWQmhxqfgj0RFU6bjG1yOdLTluHqmSJei9ixp9PJtkXVWNS9lzM8FFWpvf02lmJKrVoNtbERUi4HLRqFetZZsCJh2Ddv2SdiHA5UfOX6EUdjKAV1sGZkDmeiwoUMZ1KbaGMZDbIk9kt3HC6olX5Ks1BkF+FSBJS7RKwPaEjmtP1SRQXourNmleP5LV0Q+oiXx9a1Y9mCavb/33p4AyTLgGVZaE0YMHsiNuVOEd2ZglF2X5nyeA1hpH2n6A8d28vbA2iPZlDilBDJGuiIZRBOZeG1S9gT0Zg4O31GKU6eVoLjp5zIHvshAIuOwhEE42UYJtHR9PkvsOZ6kscDa+NGCDYb88oQ8pQpmHLzTSMWJGz+0x/+yHrdUJk4VVhxMcM5GuBmX86khBZXVdWQ1U0Wpbj1+e3DGlHHAlqMye8SzZloTxoIpg04JIGljp5Y3z7k8582o5Q5H1Qd8FM4B4Cmm2hseR1NzXdgpm8XSr12JDTg/OMqMbvSw+5TEDG0btUWO3H1qfWHPa00EHqun12+ALd+ZBFKPXbkdBPTiiRUuiVm3qWmdookotxjZyXUnz1rer/9I/FC6SQuYkYPiYzKr3+NRV3EWAy2UAgSRWLIOyOKKP3UyHvUFEYn6KIIM51mqSvWwI/DOQrgQoYzKSETLXlVpngkdjmrGSzlcjihxfgHl85jooJoS5qYWSzDZxNYZIhmBw3VsZfEiMcGKD2fuGm+RhSpv0IJXsYldXcD2ka4e5rCPf+19+JTp9fDIYtw2SRMLXYxIUGC4kgZZOl5rz17BnxpASeKCqoNIKPlQ0fzp/hx2zgLrGMF6vhb/9e/oOjjH4fn/PPgmtYA6bjjINdUI/X2OyOqVqL7BH77Oxh2O5DNMtMwNezjvhrO0QIXMpxJS1q3ervDUlSEZhUdbkjMvPGdc3HhvEomTrYGNXhsIou4vLQ9sF9JNkVpKFpDkDmYBiQS0/wtEFCBjoQKnyOF/1qUxC+v2Dflmiqh7vrvk/H1C2b3u/5I0rI9govTChoSEk7sklGeo2JxDOkP4hw6JEJizzwLPdAFuaISjtmzoWazyKXSSC5fzkqxDyRmKPJimiab98TGJ1DjxdNO5WklzlED98hwJiVU9uxWBMh9mrRR5GO8oMjJupYoAokcAmkDiyoVrO3Seit6Cgs7K6vWDJQ5Reg0GVEQ4LKAcG4m0trr8CoZmPDggkVno7i4vxigbUwkgaDEdJZOCiYN2MiQbIhQixVmaOaMLYWGd5Gnn4Epkrs8CXi9gN0GIRZnosQsL2e3pTdtRnbbNqRWrOydqk2P3/PaK4i77LCv3wi71wuhZxK36PGw0QkcztECFzKcSQdFOXZ1p6CbFqb6JLgyFnKmxSYrj1d/koIR9gf/2YTGriSLzJBYieTMfsZfMuZS5CaQNlHrE1Fc50aTXcGr3S50b/woZvhbEDdm4m/bdZSXP4SaiiCWzT5p3Dr5joaTTqzExo4kbEkLuggsPL4c3zq7fkKJraMBEiHU5E4Ph2G5XNArymEtXQrlxRchkkeG3lCpvGgXfD5EXlyObGsbBFVF8tVXoTY3Y+8br2G1S4ROwtnrx3zLQAnV/UsSfJddxqMxnKMKLmQ4kw7WgE0Aipwim91DP1jp+13VzXErTe41wn5gAa69dw0iaQ0OE3DIwPObO/sJKkp5lThF2Ke44a91sz4yJaU2dO8+AbGO2bBJIlR5I1od/8Eb8Qhe7nhsXMcSHAhKl1H/HPIlTXMCigYknAJ+wkXMmAuY0F13IbNuPTRZglVdDSEWg5hIQnzjjbyIoeGUJy4GK20TBcT0rVArtkJ0lsGxNsmiNPEVK9EqmFBqpkLt6oRuU9CugE1UFxSF9arhcI4muJDhTDooyuGyyQhmNIiCgGSP6dRtG7/S5AIkVv581RLc8tx2bG6L4TR3DEawDff+Jwp84BwmrGjNSWRNKC4TW0wgrBswJBlOlwkrRZVJJpSSPbCZYQh6EZJqEptDmyeEkCER87MntzDhaJeAoE1EwgfEciY+f89qzKrwjkvH4aOZvBn3t0zAmH4/LLcbYiAAMZeD6fNBTKV6vS2UFqr46leRm2mh8dWfImnPQRQagPhuSB0m7DuTkGfOgJxNQEunYfcXQ00l8iXbgoCij1xx2KIxvEcN50jBzb6cSQctmJcuqmF+DVGwWEk0lSz/+eolR2QxpeekuUE0Z6h+8xM4Ud+Dyk1P4eY7n2bRGOr9UuGRIDS3gjSXV5YgWBYqO/bNIaIOvjDtEJQYPDY35pdOjE6t1ANGEQX4HSIq3BLcdhF2SUC1R4QNJja2RnHvW02sp8/hLn8/GqHFv+X6ryC1Zy/0qVNZVZHU0gIhl4MlSXkhE4+z+8q1tZj6pz8yEbNpw/VI+poBexkMaTtMlw6tzmJ9ZlzTp6O8cTfcDhdK6qZDTudQHUvDc965qLrhhn7PHbrzH2Myp6lz5d3Y+tDn0frUb/jsJ864wyMynEnJ9HI3i3RQF1yKynzs5LojGhGg56Zuto17DXRF0ih3CijKBlhJ9vxKF5wOG0K7gtDeegmxqQ2Y17IXkXAJls4sRjyrwedYgvLiqgnnkaHeOTRTKpimydUSAmmdXS/3KRCzxrnj8NEEVRQZqRTr1CuHw/1uY9e1tub/3+nElJt+zqIpweY7oBtJWGYWEHRAtCAIMmwBOyq+9U1m+i2JpzD7rTWI+Xeg3uZECcReg2+hEopGIZiqyprtTbn1VwcdqYlE3sH2rpthnmFBOEmBdVcXQnfdzX04nHGDCxnOpMQwLdhlEQ5FhE3PXz7SnHzSInS8tRx6PIVYSkarvxjFso71bTFYkHD9+Wfg3sdegre1EQFHOeL+WnxiQRVrIjdRKTSyI4+MZOqwRIn5gchoXUAY547DRxPUy0V2uWBEo73XUeTFe87ZSDz3PHTyyCgKyvuMIfB6j4cseaBaWcDKQTAdqIyeh4bvXN17HzL9lqSy7A8uF4q/8204ly7NR4C+9GU2aNKkSqZMBlYmwyqkRitkqMle/OlnEJ7dBPNEGVLSA8MdhFYHpN54gz0X7xzMGQ+4kOFMGih1QRGOUEpFuccGVTfYROmcZo5LD5kDUTtvAT7w5W/gnVXrcVejgRarDAslIJwxIQkmE1tXXX4um81E07OLXLYjvviPZF4ViRkBFtbsCeG/ppWx8nJ6HfaGUvA5lDHzyIz37KyJNFuJTL56KAz/JctY+TThu/DCQeciFRefjAULb0P7zkdgJDVU1bwPFRee23t74fEkMqTSEijV1ci9+hr2btyI3IsvwSC3eXk5jIZ6iBs2Qspmkd2+fdQipvNXt7LmekJWgHhCDUy/BjHrh9ySYOM2+ERuznghWPSO43AmOLTIfeGeNciqOlTDgtmT3vDZRUSyJq46tZ51vp0oC+IVf1rBplXPL1OwOaix6370/nlMFEyE/SNoP2jOUzCZg2la+OjJU1kjvsEMv/94bQfaYpTGEHDD+44b05EDBYH6emOQLYA+pzLuoxiOVvZedTUyq1fDpL4zNhtQWwvTNCCm0pC6uvJCxLLgXLwYDQ/cf8DtFdJS8aeegqoo7LGCaUItDUGvs6A0C7DvFCFXVBxSuorDGQ08IsOZFNDCn1J1uGSg1Cmy6dGxjAmXLICcBVQafKSGSQ4GRSk2tUbREs97SsiYXEh/TZRGd3ROScS4JAtB1cRdK5pQX+re73yR4VfVLEiyAFW32OWDPaf0+jzeGoLls+H9DWUQwzkmUKMZDVUuEYGMyfZpqCGcnJE304u/sBx6NArtlFMgdHZCTCQgbNsGsaKClXULNLOpB98ly4bcVuPD/0Qok0bV9BmQHngIRiYD6iFgLVoEccsWVlHliCuwCdMh+X1wfHw2fMuWcRHDGTe4kOFMCih64bbJbMGL5SwWjanxSMhR63UKdadU9i8tgMmMynq1kAH1F89sOyIt9MmMXOaW0RanEnFMiDTSQGh/dMMEVYDXeUU0J0zmhRkoUs6YWYqNzSEmYiiFRwbggxUx//PsFnQ1OKFnBDwciqJsVxKZnIbjShV0JPOibwLYnSYtnTfeiPADD7JZSlZ5OSwSLe3tkMJhVsbN6OqCWVoK0CTtbBbFV/5Xbzqqbwk1seH/fQcbKouRy6SxrWUXFpka/DU1EJJJyKtXM38U4TnnHEz9/e1H6rA5xzhcyHAmBSRE/u/qJfjlc9vZaAAymzYnDFS5aWikgc3tcbZQbu2Is9lHNBWbJgHRv+P9655SMTSN26vkL5e6bbju7BkTLsJA+7OwtoilwBKaAKcsYFcgic/fvZqNYCjs71UnT2UL1hs7Q0zEHGw0hiJAIcXCNEXArpSBuINM2gYqXRKaYjqbnUU4FZGPPTgIyLcS/ue/YBYXMwEjNjdDCgT63UcqK4PzhBPgPuVk6PSqyhLMxkZ0/PRnsE9rQOivf4ORTLJKJs/55yOsqxDcLtjjMeQUBckF8+Fr64IUDPZuU/T7UXrNJw/qPcHhjAVcyHAmDbSwPnzd6b2eihe3diGWMzDVK6E1aTCRs6E1hlklIpqiQJZmG40ztG+3PLsdDtFiDeTKXCK6kyoz+E7E4YrfumgOPnXnKkSyBqrdEjpSBp7f0oVXtgfw8VPqsGxBNba3h3FcTQk+dcboq6v6+oFaI2kY4Ry0qS54nRJspoUFNhPvZgxk801roUgCvn3x3Al3niYDVHZNoUiRREYwyPwrvYgi5LKyfr4VNgrh+z+AKgqQmppZDxrD5YKYyUCnv0AX/BkV7TkVOYcDbp8fnk1bIceSvdt0LFqEyq9/jaeROEcULmQ4k46Cx4QiBy9s6YJq5js7bmiLwaUAu8K0MOa/xCmtQ36a8YKiPxnNwPHVCrrTJrrT+RU6kdMmZJ8V1szv4jm46emtiKkGji9XsLFbY4Zq8sw8trYdFS4JWat1VFO4ScDQuXj03VbopomZRTsxtySA05y16N41E4JLQVtAxcqIygSUAQtdqXxlFw0E5YweGhhJZdcsr0pIEmzTp8N96ilQaqbsV/3EpmJ3d7PPDo02ELu7ES0tRlQpRlEyDWckilJVx3HxHBKCBO/6rShJZnofT8KIixjORIALGc6kpabIwURKME3TpSWEMgZ8bonNX6qQRaQ1C9GcibtXDm5iPVxQN/imuIlAqifMQJEGUZxwHpkCdF5W7gqxSExnKj+pm4RgUqUmeCbcTidCkeywQqwgXAr+oNuWNzI/E5mx3zcjhNMqn4codCJniLhz8yfQ3jKTpatoyW1PGbCJQLVbRGdq/F+vo4WBZdfUAG+4qiESNpRCsiiCY1mINNRjk9cG0eNCUygEORmDt6QEHgvwtXdBtDlhOSzmq5GnTMGUm2/ikRjOhIALGc6khHwoD61qRpFdZIMaqW2+1yZjd1RnpdlEYaEkDqXSZjRQP5XnNndCZjGGfETILkss6jHRojEFCqMFnLKIUNrEvDIZ20J54y2lx7Z2JlkF2FC9eujx1/ZUHtExy6IARbRQ65Xyc7DMRkhCAOGsGyWOGBp8zdgdm8XSSAum+LG1PY6kajARQ4+ngMJ4vV5Ho5gpCJoDQSKHUk1U4WRBQOvOLRBkATKlkmQZiaJS+Nq3QOnoABwOVunEEEWUfmp4kcThjCdcyHAmJbTQZTQLKSoLFgC/zYLfITARQ5cps1QQMbT+HmylzWghsXL7Rxdha3uMdcGlVMmR7hczHIVy9XhGRUan5QxIaPn5VYpAE8UtaIbJTNMUZdndneptflfwv7yzJ8zK3acXSdgVNeCxCfDbRLQnDWgmsDFYiqWVQLEjBktw4uwF78HJC+b2nhfaDvmb1jRF2D6REBqv1+tYh8RIQZAEvvMt7Nq1Bba6ejgjETi3N8Jz2qlIvrAcoKGVgsAiMWTsHalY4nDGA94QjzNpIzL/++QWJlgKkJcjmDHwydPqYZhgFUx0My28Y/Xr/kDN7Oj2Fze3M/PqtHLPhBQyhTQQnR/yowSTKjMlp3uEIXkmSl30XwGqZrJBkSRKCBI6bpuEb1w0B3e+uRepnI6cprMwytxSGS0JE9GsiVyfF4YiOXOKd2JuaRuuOPV8nD7vgiFfUxKoh1IZdSgVP2SWJZ/JsbpIk/l37de+gnhxEXxdAZRBQtl110GQpWP+3HAmNlzIcCYttPCxvjFZDSnVgEe2YIoyGyA5Vgth38WVqo4oekH9aWi20G0Dus/SfW95dht8NoH5Y6yeRb/UYx+VUXY8IjChVA5UuK6bVLyeZ4pXQiJnIq5aqHRLLK1EAzn3xnQoIlDrEVl4K6kC1X47sqqBCp8D27sSyOoWiuwCsobQa3Cm1NEneiqfJkIn4+F6r0TuvQ8W9VXRNBR/4uODmmOPBUjQBe66G8jlIDscqPn5jcfcOeBMPriQ4RwVXHvPaqzb2838FaGMiat6ojLEgeYADYyyFC5TufB9bzXnZ9MAmFXhwZ5gEjZBQFK3MLfKgyuWTGX3W7ErhF3dSfgUETWe/IJO+xHLmfA6ZFx/3qwJMRzyb6/vxm9e2AHTNJlQod4xdinfd4c675AYieYsVDkFFomhVBEdvcYiLBZUHUgbFpt15bTJLCKTyOnQ9by/pdIlwmMXsTOS99hcOK8Sf/nkxJjkPVQUounT/81a9VOTODEUYh4Q0eOB5Pcfkwt5ctUqpLdth2funGPu2DmTEy5kOJOaQk+Zd/cEMLtUwep2FcVOiXk8qJqJeqy5bTKuWDIFtcWu/cQKpT3+/MqunpEGAs6cWcYav1HHW9JBmm6yxbkzTct83ndT7hKRVE3YRAEumwjLBHwOgXlz6Lq0ZqI9ZbI0DVHkVFgzv4kUkelK5Pa7jQzT1GiQNMs0v4ScbjGzLkVo/E4ZsUxenBCfOr2+N9JCQu6elU29aT6qVKr3S9ga0tn5/f4Yz2Y6VApTm6myh5JlibfegpXNAn4/hGgUltfL2vmLbjdLrZR++lM4lqB5V6qqIvWvf/GUEmdSwIUMZ9LQN3JCkIBZsSsIh2RBNShNYiKj5cUGlWDPK5WR1IAElRELYBEGn8OGK5bW4sF3WpFhAyhNGIaBYke+9JdwkcvVslhUhaDIRZGD0kX5lZq2TfOeWmI6W+hpAad7FqqlKMrhkAU2zNKp5CuWJtJC3tcjE89qbII1lYy/2xRh4wFoLhSdA9p/Os5Sh4imuNHre5la7MSvPrJov7Takxvasb4lxnxBfrvASuNDGQseu4Q7rjlpQgg5EjFdN90M9Iy2oOgLRadQUQGTmsGl0xC6u1kzObGoCFNvv+2YjEq0/vrXSPz1b/kSMlFE5f/77jHrHeJMfLiQ4UwKCpOaQ8kcq6JxKSLrPVLiFBBIGAir+8yltBBLggCHBGR0s7drbJXPzlIki+uKsL45iuoiB3Z0JfITl20iSwWRIiEhQtEIiubQtmg7XruAtkQ+HUMznvbE8htlzcQG7CuJJorazKj04yvnj67s+khOxi74gWaXOXD/6g4WpSJBQrhtItoS+/ri0Hmhzr8Dp2XTNm58eit0w+o9Nw5ZxDcvmjMhUmst132RRWBM6p9imZCD+dJzQqurg9zczEQpdbmt+NY3J/3iXRggqQW6oVSUj2iYIz1m9//7Hvt/MRyGkE6PeDo2h3Mk4OXXnAlLIXJAk623dMTRHs2w6hqnQ0BMtRBIm7AsERE1XzY8pdjJDLk0J+gH/9mEXV1JLPDloKUiCJluZDQZfqeNGXd3dCXRFs2y/ijJnIFuEjFM2aM3JST0pEkq3QK2h/OLOKVKCiKGWFxfxETHxrY4m6l02ozS3kqlRTVurG9LMl/KSIQJiQAaZUCdgem5P3ry1P2EwuGEokafOr0BmqbhvcfV4BsPrUdXLMNKqNOagYUVNNjRYCIlkrMGbVxX+H8yPWe0fDrO71QmTDNA1v32lVeYqdeqrIRRV8eMrSaFpLLZ/BBEWZ70IqZ3AvbTz0BPJGBJEkRVRWL5i/3GFAxG7JlnYTkckFpaIOTyKUiJhkxyOBMULmQ4E1bEfPmBtYimc/AqIquAqfGKzGzaEs/7VwhRFFgqiX710yJc+NVPi2eZkMDJjhDiuQgsUUb94nosXTCbCQoSPIN5ZK5YUstMwiSc1rdE4bHnTbsFqHdNAY9NwrcvGnou0Nu7gvjZ4xuwN6LCPUiV08Dj/d2L+W641FmXxBSNCDgcHW77duEdaIQmb4TNZmPXkSD82ZNb8tebQDhjsG6/pmmxaBhdN1jjOrpM53eo5ziSkDhRm5sReeBBiG1t7L3DvE9eL1BCnhnANm3apBcx7d+7AXogACuXg1VUBLOqCuK2bdBDIYT+fie731Bihj5RYizWK2JoSjYfCsmZyHAhw5mQkMigMmdFpCqavFejvY+AISpcIkQKodAbWeo/AmBulQ/plhQS8ShSloJSycTiMqt3QS3MayIKoqavEZj8I7TttGohnLV60ylnz6lAKKWy6EvfCdGD8eTGTnTGs2zR707mhp3CTc+f1QxUuumYgGzGYossPWYshQwd2xfuWYNEVmPenofXtDLxRmLj5Gn5hVyg6ESf6AqJlW2dCYQSWTaDqWDqHa7RYN/zO9GouuEG+C68EIHf/haZNe+y6+REAqbDwc65umcPK8mm+01GaIaSEYuxAZBWWRmLOAmpFEyKyhgGm8eUWbsWtUP4fyj9FFvzLqx4HIKioPwr1x+TPiHO5IELGc6EhEQF9WoJ9FTXhDP7RAxV0KSyOjPxUhdZYm6Vt9/CSQvzOxuLoOsBeEUdLocTNTU1B1x0C5GgeJqGGZLJdZ90KnYdWLwMhERQlUeGRKGkYaDIUE4zITskFNlEdCRNLIKEc+ImcrtjsE8fm9QMCaN4RsP8cgWbgxpLY937VhMTNBcdV4aPnVKPU2aU996fxAz9UdqLojNkBi50373q1LHr1zPe0MLccN99vRVMamsrjHgcxuzZkPfsYX1liMMpZihyQqJjrPvV0PZYCXkkAisSgWm3A6kUizgZogAhkwWiUXT89Geo/uEP9ntuulz5/Rtg9OxbbqaF5uY74PUej+Lik8dsPzmcsYKbfTkTvrT69cZuZvCl5mxkMKXUzz1vNfVGBWhxvfrUevzs8gX7PX71ph0oFVM4dcFMNDQ0HPA5yc9C/g4y+LoVER0pg5VVn3dc5ahFTEEUUa+VhmIbfviB/pU+A5/35me2QhEEKBIwTRXxPTjgFkR4PDZUf+y4MREzP3hsExMudhlMMPntIhoj+flUVW6JNRS8fYgUWKEB4UiiUZMNEhXNn/s8TJuNVTQJySRLqdTf8bcxj0bQc4XuuguplW9BkKTD0q+GNba79df5svICggDT6YRRWQF5bxOrzCI/kHPRIlR89Sv9nj+Xy8HYsAG71/0awboN1N0QNkcpjjvuF1zMcCYcPCLDmbAUIiWDNax7Yn0785OQiCl2KiwCM/jjTxvVcxbSU9Q7JU413QBmVHhG3dSt4EOpK3GxEudp5W7ANIasSqKIDB1LkVOAZQk42a7AoYroypmwZXSobYkxETJ0nh5d28bSdmHLZGm7EpcIryKw8nNB1Ieccl2IzhyN0CJe9JErELnnXmYAFlMpCKqK0F13j5nAKBhwY48/ASOVyveroRlGPemgsRQy5PFxzJ3LBJMRCsOxYD60jg4kX3wJQnMLrKoqmLoOMRhEZs0aNF97HYo+cFlvVVP00UfR8dBNCH/KgKAUwdS7oGaBRGIjFzKcCQcXMpwJz0C/Bf0/NZg7HGZS2g5FfchoW5heTSMPRhtFenlbF6v2KZhiqUpqQ0sYsZzFms4NHHFAlU6UriF/SjRrYLdLQla0UA4BMcNASjSxeIyO745rlrKKpNZIhl2XS5uQ3RKy1LHXKU+YCqPxhtJI2S1bkNqwEVZxMYRwGKk332QC5FBFBm2j7RvfZGZbyzBgTJ8OsakJMAyWBmLpoDGmsM9UhUQixohEkJsNaFNUSO0BSJ7FzAhMTQApQRt+8SUk3lyB0qs+gdCd/4A2T4dsXwpNewuQLOoOydJLHM5EgwsZzqTkcJpJqeSZqoVGO8CQzVp6ZhskwYJbFlDsElHikNASz7f5JzNvjVvEtpDBvCl9zb8UkaHH0QTqjAG8mFARhIG5kLBXsnCBqY+JkCHoOW/9yCKW9qJqrXKniNoyLy6o9E2oCqMjQcVXv8pSTJrbDSSTELNZFkU5VCFDkREtGAQcDtZ4T2pthWAYrF9N+f988bCYaUk8tX79G6z82nC7oc51IvmhIsDTAEtvgfvxt+FZTRO38kgzZ4AK/8NvroBW5IeoO2FGVkBw5UfJl3ctRPFFJ48o6kQNEfzLLt7vuPJptbthhELwXbJsUleHcSYOXMhwOIMw2jQKRWJufX47bD3emqRmojNhoClq9JqUWaM1WCyVE+lT0k3s7k6h3K30Dlwk1sPABhgod9rHPEpCYoW8MJvaolhQ7cEpMyvHdPuTFVp43WeegcTLr+Qrfrq6kFq1+pCiMuRXSb72OhMwlt8PKRJhaavD3a+G0lUmmXwNgxl/TXsAht0OUc7AkDsQ/6AFwelAWfdCaC0tsCJRyC4X7LKE7K7dkMLFkFpFaHUWbF0OTPvuN4Y1KzPh9OXroVNaTtMQf+opTP397b3njQ3nfOBBWLIMIZtFZv16dj0XM5xDhQsZDmcMIF8JNYpL6jQosv9t1OGWIjJ2WUQwY6LEKaKh2NHr66FIzhPrWyHDQk43mefnpJ5S6Eqf47BFSWib1LTPTlUtnF7cp5zCvCSmYUCnhnmNjSwtdKBGcoMt8ETgt7+DpaowZsxghnWhrY1d71y08LAu4vT8NC/KCgaZsVfudAKSHaawB7CcgJJG4jIDMxZfD/tOod8+Z1avgUaDRXeKcLQ6UPGNr/c79kKqzEgmIXk87NxQCkunWVVlZRCCQZixGLuuEJGic5peXAT1BDuQbIXzXZHNcuJChnOocCHD4YwBFDHxORWoyRwz7dI8punlHpw+o5QNq6TUEflgCv8eX+3G0voi/PhxqiJqZn1yAimT3X7popr9KrAOB7quQ5Kk3r4xExkqQSfDs22Kd8xK0YfC0g1WsSTRYlxcDEtRoEciaPz33Vjn2oL5pfOxtGrpsM3oNGrtbxhQ6upgUQ+XmhrIgQDz3RSwz5l7WI+DhEftr29lIiLx+htQ0tWQm3ZAn+2GIChMXJsw8gbekz7TT6hQj5nIiy+SeQvFF16wn4Cj9JFKlV2GASsQYJdz27dDJxFTVMRMxOx+Tz2F6COPsGhU9tQqJD6kwHR2wIKJ7AkmSrT9TfoczmjhQobDGcNUzWgMyPet2Il/r2piQxm9MtBN4oKJnbF5SYaqkMpXVLXDLVs4Z96UCe+JIRETemAbrJwOwS6j9GNzD6uYoaiE7PdDp+GRPREGBLuRWv4iXvC+ibtmFeGW99wyqJihqAYZemmWkxAIQN2xA5YgwCovg7B9R77kmaJ0Hg/zkBxuSIDQPqVefwNoaYHSLkKbmSrkOSFJ9n4G3r7RpJrvfId1eh4sYpdavSZvFO7qYpcTr70OrasLVnl5Phpjs7HbdbpPLAohFIbpzMGUDFhWjy/HZwNmD97bicMZDVzIcDhHyID8cmMEXruElEZDMPP9Y3IGpanih7wvJFauvWcN0qrOxjh8++K5zPNT6G0DQ2MNBR9dHxh2dMJEIL2hG3pahUULb0Jllw+nkKHFn1Ilq+77Hax1m1GsG8h6FSiGhZlRFzZkgnhu73ODChkSAJRGQjoNY9YsyI2NrAJK3LqN9XFhyDL8l71/3LrlshSTz8dSTM61ErInApZPhijZMH3613vLqQseFyoNl9xuFpWRFi5kQ1X7Ru3ofuquXbBKSiBRRIYGbsbjUN/zHgjt7RDc7rzACYchBQK9j1PaZIiGCMOuA4II2VbEq6A4YwIXMhzOEYIqol7ZFsD0Yhk7wvs6/1LDuUOFSsAjVJHkEtGdNnHT09t6RzFQgz4a7xDM6KyfzFB9Y44EhQncfavFcnui0F0C5FQ+mqF1JA/7fjzq3oHbl+7EhTY3PvRcHK6iEphOBzztLbAWiAik9y3QfSFxIldVQSMfTCwKw2aDUVEBhWYXUak1femWlLB+LeNFIcVEfhUym1dVNkCdou3XqZdGNmiyBFHTYESjLCXlOvVUJNaug++ERb1eFlaB5XRC8Pn2GdkzGShvvQXL7WZpJYGaCvbdCUFA1cmfQP2ZFyAQeIqJn8qK9/GeNJwxgQsZDucIQQv1yl0hvLYj0Cs4nIrEuuYeKntDKdaRmAQLDXrM6CZLe1HKq9avYE8o3/GV+tlMlL4xJGJ+8fQWZA3g5W15ofDx6hKo3VnAAQj9C70OK291vIWUkYKWFmB43YDPCyEaw1ldJt6ZK6B8zr4xDgOhAYtdP78JYjQG7cwzIG3c1HubbdasQccCHG7o+YZ7ToqyRJNroZ3qg7xTgmObwSqtyKBrVFUh89RTiDz0ECp/8AOkA90shUQznMTublZSLnm9MLq7852EqTsy/dvTNZg6JfctteZjDjhjDRcyHM4RhEQLDWS0DA1VXhlfOHvmmERHGkrd2BVIIqtRJVQ+kvH2nhAuPb4KP71sPp7cnDdjTqS+MeTbocGcBDXno8t1uxKohQm7yWZUs/4kzoVDi4ix4tTqU/Fa22vYVWlAT0ZhD0ZhVFVAtICFQRcubrj4gBO2w/c/ADO+Hplz8qLMucGO+hvGX8SMhO7GpxH9uArB6wPOKoP5SBKODXGYZNxVVfZvNhpD6w9+CNHQYWtphVlayvw/gq6j7POfQ/zZ55B59928iBEEFH/so5N28CZncsGFDIdzBCER8csrFuZNuVUunDxG/VxIIL20LYDWpMEGa5IfZmcgiR8/tgE/vnzhuFRFjRYqTabRENP8EvbEDHQncvh7ZwbXOxT40hYU6kVS78HUM6Yc9n35xLxPsH+fLXsWG9QETn+uDZIkw2Zz47LMHBT/5O8In751yNJhmq7dtfdlxJY1w/SJVAoF9UyJDWB0YeKh1VuwgoDQ3QrTr8Es9gCSDFD5NlVdVVZC2rKFVXA53/seJFvbIIZC7LHU1I8qvRruu5f1zKGSavfpp/Gyas64wYUMhzNBTMKmaQ5ZJXIwOBQJgmnAaxdR6RawN6YjlFLx5MZOnDKjDBMNmi5O0EgHuwS0hDPoFIHfiyamQECLTcD1F9WP2/6QmGGC5hIgPPseBP70Z8Djh/jmWiRkGclXX2X3G0zMRJ95FmppDnD5IAh2WFYnTFmfsLOKSuddgo5VT0K3IhBygLIzDTEpQkwmWRM/cedO5nkhE3DpNddAqa5G9KGH2XgFubS0t/8MnQveF4Yz3nAhw+FMIIPrVSfX4u2dAWzsSO5XNj0aKMJD1SaUVqpWBOwM6yh1SQjR/INDKN0+nFDzP6ItYaDCJSGQNlDplvFmQmPm0GuW1o/bvgzsWksRB4oYQZJgUu8duw1CLof408/st3DTYyMrVkByxiCc7oMp50uUhYSGzB0vokNqH7R9/5GExNWCk/6IrlfuRO7hlbA10aAwgU3nNr0eiJkMnEtOZCMcCn4bijr1PUcczpGCCxkO5wgKGKouCsazrH/MK9u70RRKYUNTEC0xDU6bzNJOB7N4kwAhI2+XarBxCIXqWZssDjopfKCIuf6BtayiaeBwy8NJfjJ3K5I5A6ZlwSkJMCyTVcZQV2RqLDjYOWzdEMDpbifOPLP+kMuy87OA7mJGV2r2JjgccJ92Kmu6Qos6mVt1KqcmHwgN+6QRAAO3sWkzLF2HLeCD91E71OOmAJYJ29ocjC2bEdXWIfHCC6ySaKKJmeIPnox0bf/OxPEdO+CbPXu/fT2QgZjDGS+4kOFwjmCFDvWNoYqlQNqCaFlYuzcEVTOwsNKJzYHMQZdG02OuPXsGbnxqKzQLqHBLCKQMnHdcZe/2hoq6UHVTNqcipVpIq/2HWx5O6Dk+uLgW973dxCaHz6+QsTmQL0unaq6B1VXUFXn9ilZ81+6EI5dF094k6q+af9BipndCdSAAU5aZwVUKh9lEaJoNRO3+meXY72dRGSkWAywLrVs2YfvK15kVuW5JKTC7A0Z1ErZVUbhWAs6V+fJjmjFUgGYgkViYiEKgr0ChdKdywglQFHIocTgTEy5kOJwjAKWSqJio1itBEgTmYaGmrzRj6fmtQazrzGCKT2GjDAY2JBuMwUQJDaKkSE+xXUSNW2IDKV/f0c3u+8ymDtz/djO7X5HLhuvOnpEfnTDFj60dcSawKt0SulIGuzxeUFTmodUtiOVMdKdFZAyLzap6/6KafgKMIlmvbuvCp4scsCepK7KF2pzBxhgcrJAhYUGzgyyPB5bLxUSKOWMGS2uJ0SjCThsSTju8agZer5c9JihZWHvbLUhFI3BXpaCVdsDproZ0tYaK6YshvtkNvbWVbYsGKTIEgYmiQsRjIkNjLLiI4Ux0uJDhcA4zg4mMM2aWYn1TCG6bgF0RnUUg5lR68P33H48L5u+7/0kNxcjlcmwxoblIBVZGk1gfT2ORzwUxnMO3Ht6AYDIH3TCxaGoRvnnhHMRSWSaURAHImha8NhGKKOA3z21GNJFh1UGBtIlEWsWvaXK3LMFtl1lah8qffTQ0iiqF4tlx883Qds+eU45nN3chQ6EkihDYJCZw8qMVOvDE+naYpoG6IhlrEzrO0SVUQIApi2wW08FCwoIGIFrd3ZBojhBBfVJogrXbgfVlFXBNt5Cq9cDakUbJTgkxhw25VBIOfzHcFVGItlKo4RQUZxzShbMx8yf3s0oe8tLQCyEVF0OuqJxwHpmhGImI5nCONFzIcDhjRCTyDiJ7V8Eeb0DZ1DNZZIBSSLc8uw2qbkKRRHxn2Rx8fOkUzKtwI6VZkEULek+jt3BKZYv1wFEHDoeDVTPRr2ObzYa3Yilct3EPEroJryxiaRRoj6ZR4hAR0y3s7orhB4+sxeyqIrQm8ubeEqcFTbcQ0U3kAhnEMjpLk1DfFqoQ8toENJQ60Z3MwamISDtEVHokhLImWiMZnPWLl9AVz7JjILFzwtSiwzaZe2lDCV5vDMImC2z/Tp9ZxgTMo2vbMMO7A/81qxGqnsWKjvl4W5uJn8PCPEHC0sUVmHcIHpnCaAIagJhavRrq7j0UkmC3Rb0u2GuzqDozBMEuIFOXQy5bg9oTTse2Va/DMgykuhTmq4E7ACsLKE0CcMbkreQhEVMQzas2b8ecpt04a1bDpBBgnGMLLmQ4nDESMRvXfhWmqkHUFWSe/Dw2NpyKG9/aRY1NWYddUQT+/tpOdv/blu+ETSQhAZS5RGimhe6kyky2g5lrScCQX4GiM8/uCUDLZqDmkuhSPHipPQO7AMwsltCREtES1xHN5XDKTAcqvXaEUjmEMyaqPRLSKQOnTS/FC1u6YFg028mCKErQIGFbd4aJlIZiLzZ3plHvkzCrWGa/yDOahlqviFjWQjiZY48nHl7dgvlT/Diu2refqBksgjOSqA7dVuqxQ4YOScyboAWYeE9tJz4443ko4hZ2vwVlq/CXjZ/ChshMdHpkXL6wYkz9IeSZIVFDTfjmLDgOyZ23Q7Cp0OMSHG4T8tl1mDL/PZj1n0fRMrcYljENza92wOkrgR6wo+7ciZ866kv/yFEJTJuCdXY3fnLyOchIMpy2InzvT3+janQuZjgTCi5kOJyD5N1nHkfTxnWoP/4EyGUboeUSsJunQpc2IaU0om3lVPjtAspcEjTDQnPcAAQLb+4MIZ7V4LMLiGTAmsAVgvdDzT6iyA51ui112xFytsFR5IXXqSBsJDBTCSHn9WNH2EAwkw/vUFSFhAX90fZaI2kEYhnUFjuQ0QXMrPCwCFBDmZuloYiCwCComd7WsA7VsFDmJDNyfruKCBTZRfgcImuyl9NN7OqKYXVThFUcXbGkllUX0fM9tq6d/ar3O22s+oqgFFg0rbJS5q+cP6t3nlJf6Ng/fUYD7n2jEU7ZQjUzKgNVrjehSO2QxGqYZge8tiwunBXBKWL9YYkMDazKMdcZaO28GUqJBputCOXl5yPwm9+iPpyEPxBDsx0I6CKsjBeq140oqdRJJGK6brqZvV6m283GC5CpeceJp6BIkVAeCaO5qARbSytxzgQ1KXOOXbiQ4XBGCYmKzcufQs325Syasfvd1ag+pRqVMxXo8ioIVi2U5DTILgGCKaAxrPcO1yt2yqgtdoLsJ5ZFnWzztzBDqTD47CN6vv99cgsUSUBWt2ArWYniqREs8p2KXel1kNQpSGvH94oYqWfadWFh7xsN+fnj67AznGMVSQXhtKUjzgRFXyFw1al1uGtFE9svSoHR5ACK4JCXJ2UICEXzKZciez79U+4UoVsW7n+rCaIoIqubTPAkcmavSCJIxMgwWYTolme3s0GWAwUI7SeZoU1YSGTz9yVMi9JkMZhmjKqhYZdt+Mw5l6C4eHy6FM8+4UqUR6axpna2NgXxb/8NejAItaoKbqcbU7duQnhqBXI2GQ6PF1XTZ2GyQN14LbudiRgSMEIsBtPhQF3jdkQWn46srwiOTAbHhbrgXPD+I727HE4/uJDhcEYBiYqbnt6KC9u3wzB0iN4imNEQ1q0zsCS8GDNrq6BkZiBjTMMzqRxoOZZFATV+B1u0aXQALepkYI1SaVCPT+XsORVDek5oUScRQykoUkCWOANa5hFs01sQzKbgiM5Fr1IC8P33HTdopIOetzOpwyUJqCoSkdaBjqTBBAVVOPV97h9ftgD1pW5WHUQemQIXz69k26brycdCx2D1HAdFa2o8Ehv66JAEZHSL7VYqZzBxRcevGSZ8DgHhLJDRDLadgekoitqIlo7OuM5KxwusDy7FydWb4FLSUCQbpk//+rh3ybXvFGBukpBeswpGOAyrpAQo8sPKpOFTHFjUEkDU7URpyoB+481oKS464ubegc39BoNGCiRfeQVSJgMEg/kZSrBwfDyB79z9Z2yvn44Fhopl132WR2M4Ew4uZDicUcAiBaaFWOl0eLwq1FQC7ooqbHTMx8NSGZZFLHR2O7GrWMNGwWChlhPrivCva0/vtx3mAcmozH/ylfMGT7EUoAgORWKoS2+dT8a6zhogdQlmVSeR6/Qgla7DNL+AaDYfNRkKFukRJAiChV1RA2VOKvum6dgmK3l+YkN7v32hf+mvb+fhwm0kPgpVRFSevaEtxgzNTXEDsgBM8UpQJLBtkw/n1ud34PQZpSziZFj5aE5hSndfaHvhVA6zS+2IZE3Mr/CwdFpe5J2K2cWnsIiI13v8uIsYEgStX/8GjGiUCTRryhRWlm3fug1mRQX0igr4IhH47A4IXUGkm1oBRYGgqog+8ggqv/H1cTf9Usqo+3e3wdI0SH4/MzMPJmYKgy4jDzyYNzhTz5xkiu37op3bcEJHC+r+/CcuYjgTEsEqWNM5HM6w0ML9y+e2Mz8IcWpuK6ZbEahV0/BItJp1za0rdWFPIIlTa+3YElQRylgs4nLPZ045oBF2KL70xG14qekNlJknINh1AjTLYimeDy6sRJHHjjtXNDNjLkVXKFO1pL4Y/76uv3Dq+7w3PbkB69rTvdf5bAI8NhGdSQOiKGB6uRsfO7luWHE1EBI7v1veyCIulDbLavkojVsR4LaJcClAR9yAIQgosgno7kkXXTivEn/55NLefbv23jWwCSaCGYMJmNvHqavwSGj50pcRf/NN6OXlkHM5CN3dEMyetFdxMczyMsg7GmGKIqyyMpgkYhx2NlxRjMYgeDyo+9Mfx00MkPBqvvY6GJQuymQgJRKwzZqF6h8OPYG7YHDWnC64qyqh7tnDzM4jjSiNJPrD4Yw1PCLD4RyAQuTh0XdbYZkmji9XEMsaWC/PwwZYENNUU2NBlgQ26NDvEJkvJqOBNXOjhX2ggXdgifVQ3LflPrwe/jumlFQgpP4bWjoJLXoGMweXeOyYUuyCLIJFQgqUuvPDF4eiO6nDLQtIkd9GEln6pjNl4KTqFswo6sbqTh9++kSSjUugFNNIINFDqaOCOCPfDZmTt7QnWFM9osghwi4JLAXFOuQCqCly9EZ8WsJpNuTSEqijLFiJ95EWMbQwx555FnqgC8nX34BZWgqrogLi6tX77iTLEKJRCE4nuyjSzgcCIKsvpWhYp0NC08a1m2+mZ1SCEAjAov12OqE2NqL5c59HxRDRoYLBmarjRju8dLjoDxc4nMMJFzIcziAUIias+mZtOzRdh0sWoNhEbAtpLCJCVLokdKXzHpA5VT7sDCRYNKGSyq2R94jYJXE/A+9IuXvTgyhVSlBpq0Sn2gG5+B0gcSZKXDZcOL+KLZIUuehK5Nj9PTaJ+XCGggRZR0LF3FIFW4IappW58NGT6/DvlU/i8hn3wKV4sbjcgb9tBP65SsSyBSOvBuorzvKVR9N6PUVU/USCzjBNlDslpHWRmXgfWt0KwzBZAz4qR59TqmBjd74D7trmCD78pxXMuzOa6NCYppK+fD30dD56ZRUXQ+rqgtTR0XsfinC4Tz0Fkfvuz0+KdjiglOUni+udnRB6+tCwbr4+37h282UN/nw+GNTgLxRiUSPLZoMYi6Hr5l8g9fY7KL3mk/sJq4NpgkfnKnDrr2F4PKyDsRUIsMgOQbOr0m+9zSZlk8Cp+fmNPFrDGVO4kOFw+kAL7wPvNGNvMA1JsOCUqWGcAEkSEMrkBxgWIEMr+UAI8s0cP8WH7kQOyazOSqrZtGSav1PiPKjIAompQFxFqUvE5tRmdh115r3ipDq2uFPXX8MwWN8ZEijESMqQSVBQ916qRNrelY+8fOqkLKSMimBaR7GjHfW+ZrSm5hz0rKcCJEDoOKhTr2VaUBQBm4I6XIqAKrfEOhGXuEXE1HxPG+pyTP1uaC5UOqthfXOECZrCtsYTWojJD2NMnQrL7YaybVu/26Wiot40ja2uDskVK2GUFEMOR5h51jF3bm8050gYfum5aDBl6K67mZFXjERgVFZClyTI4TCSy5cj9eabsM+dC/8ly3ojNNR4sW8X6cEYGGGh4zQ1jc2oklSV3Sfx2uusL41GESpZZn4iihBN1BlTnMkLFzIcTh8R88tntrKxAcW2/KRoSrkUOu8S5HehX6sORWTdcQudc6mqiPqnUL+Ubzy0Hu3RDEv5EB7HyAbu5XvFdCCZ1VjahSi1n42A/GA+tiMI+Ojcj+B7Z+XTPW/vCmJbRxRza4rxs8tHlgIi/wuR1SxWBdWVMvHgOy34+8dPQDb4BGQxjpRqQ2e6gRmSDzaSVIBEzFu7w/DbRRiWhY5k/mTS+AFNNzC9WEZ70mA9aQg6Z11JAwsrFHSnDAQyFkszUZpqvIVMdvsOFsGggZESzUvqicDY6uuhVJTDt2xZ74JcEAHt/7iLpXKSr72Gyu9+hwmdI0khVcT6xPziFhZRMioqoM6fD2XLFiCTQWbLFmTXreuN0JAMMQb4XDpvvJGVaJNA8114IYtU0eRvye1G7e23MbFmVlUxczDrQaNp0GIxGBXlTDmTiCLIqyPIk6e/DmdywIUMh9MD+TTSusX++kLixWWXcfkJNUysFBZ3MqZG0xozfNDgxYJxl1I71PdFNcCiHhQlGYmI+dmTW1gEiMqWSQNRN+BgcCGkoiQcvt34yLxz8L2zPt8rEK5/cB0coomsKQ7aDXgwqMya4kThXL7RHbl7yOC7JTQDHz7+V6wiqDVZh8v8M8ZkphJFdCj6k9ZoFIPVO8n6ypNq8fT6NiYEqU8NcXJDMUvPUbfg9QENVR6JnQ9Ls5jXpjC+YdwgBUWRq555S7RAD2eUpYWe+VEqKoD2dnb5UKuUaLJ25+5G1pOmdt7B98spVCWF770vb1BOJNh+GokEREmCkMuxCA0JMDIqk0G54HMJ/O42pHtEj7prFxIvvwKVtqEozDPWetttMJIpljoSLIv1oaEIFtJpyLt2M1FuFSI8JHL0fX4uDmcs4EKGw+mByoupo23PetvrOfngibWDpmz+fNWSQVM6hcjBwJLlA5Z1W/mJ02xYomAx03A4ayEbOh1XzvlYbySGoOelIZENRRK64xq7POJFXgDiORNuJW/ApaZ8q/eG8dmzTmYlzXUABq95Gj0khkjkASoTNKfPKOv18LyxvROhtM6iWZ84pa7XWExRo58/vZVVUZ051Y6VrblBe84cbnyXLENm/fr8BUFA8cc+OmxKhPViee01mLkcLEVhlw9VxDx52y1QM2nYnC5cev23D0nMKDVTINpssIJB2HqMyNa842AGQ8wIbBUV0awNmJWVUNJplrbs+Pvfke4OwJw2DRIZmnM5qIYOY9YsJnbQ0QF91WqILhccFeXQKPJCIicYhOlysbJ0qu4SaQYVLTjFxZNi6jdncsGFDIfTQ0FwkCigqMVg84P6MlzlUaEHy0ghwfPi1gD2RHX2C5bKluM5SmtZ7HLfpnQF8l13R/fy0fE8vIaqrwwkVYv5UUgkkIflx49vGnGV0kih80PptoGl5j94bBNg5hc3w7Rg9Enf0XlbuSuE57d04Y2WHKrc+RTYK9sDLHI1XimmQjSlkFI5UHSlcHty5Vuwv+cslHz0o4cUhWlctRIapWhyOfa3beVrhyRkmPnX72fdiElsUPREjEQhBgLs/81kEgYZlVNJIJmEYBgwNmyEFIlALC2F2BOZksrLIa5ZA5MmhTudEEm4ZTIwwhEoNTXwnP1eRB96GGI6DSudzo/fEEU4Fi1C5de/xv0xnDGHCxkO5xAEyFhBz0mm2/vebmZzmcgM290z34hGF5DQGShIntvcCZtooswjjyh9RZCQmF/jw4bWCGuwF82S9yZ/2/ItAfz4srE/tsEE3+5AnPmP6AgHq4+hqM2qPWFEMhq60iYq3ORXMnHr84OPNThcjHZydeH+VL58MNU/JGKe/fNvkY7F2GBQd3kltFQKlmUiGQnjUOg73Tu7dRsyGzaw1BmJGIKEC/WaEZub8w8QBNga6lkHY9AfIcvwXnABYg8/nK/SKpRoyzJcS5ag9L8/3Wt+plJsM5Vi25FKS7mI4Rw2euyIHA7nSEOlznZZhE3Y9wuDPDafPK1+P3FFCzk1i/vsWdNG3TSOIk1UPk7N82gYpFfJL7ajXHMPCvK5fOTPK9AajLGIEK2hLkXaT4jR8fz56iWsYR5Vf0WzFkocIpI5gzUlnOjQtPL46tUI3fkPVuEzUigSk00mWASDMFQSRHlB6ykuOeT9IpFR9cMfsrQZSwHZlHyvG4rwlZZCSCTybwRFgVxejoqvfhXFV30CIjX3c7mgVFez6quKb32T9c2hVBPdn1JGBRFDkJib+qc/snRc0Uc/yqqneKUS53DBIzIczgSBUlpp1cC0IpqWnb9OkvK9XAaDFvsTpnhG3biMRMPzmzsRy2hsuKON+uOIQFskc9hSN7Rd8rh0xLLMZEwpLapgIjE1Z4gISyGS8/m7V7M0E3l6aKD0mqbIuKaYRkok8k7v+ATbTgEdt/8eQnMzJEUZce8UMvVSmbqhqnAUFcPs8ZbQNuae9p4x21dmuCVzbjjC/DxwOOBsqIf/6qtZVRHdXqhaoj+qVOpbbk1/hfJymsnUt4JrqOnhHM7hggsZDmcCQJGKJ9a3s6iDpgPNPWXdlFY61F4uA6FtUZUTbfcfK/YimsqyH+H0u/9wlDlfe89qPLe5i5VgzymRsDOsQ6PFusdUTf13hoPSTOSPCWWpN88+c/REEjIkYjZt/go0LQ7BLIG0/WSkgh0onTEN/j1NI+6dQh6YqfMXYtfqtyBIErR4fmp4w6Ilh+SPGQgJEhZRoeolMv2WFMPZMA2ln/7UoPcfTJRwocKZKPDUEoczASBRkchprNutx74vx+NQpEPu5TKUmPnsWdOZ34RSPFQqTlCX4LGEIifPb+7CVJ/EuvpuD+ksCqPqFvO9EO007fIA+/rxU+qYiKFUFHVRHugZGm/R0tx8B/u3QFfgKahqBAJmYBuqcF+RDc/PmoWV8U40V5fDNopKHV9ZOURJhkE+G9OEzenE0vddPqbHQCKk4ivXQ6ROvNXVkHvmKXE4kxEekeFwJgA0CoEqd2q9IqtcImjhpmnUw0Vj1jVH8OTmIPv/QoVVYTZU3+uGgplq94aRzOlsMvVw4w0OBoqcUHl1e8JA3/Y81CvHSzMJADaX6UBQNVV9qXtUJe1jDQkXEixdXU/CslRIkgcL5v+O3ZZM7IUoFGGroeAR6XPoKrPDeZ4B66VHIITaMdvlgEPTkHjwwWGroMjsu/nV5XAUFyMdzFcJTZ2/aEyjMQXo+W1z5yK1fQe8c2bzNBBn0sKFDIdzhCHhQfOcKPVC3phCdGRWhWfYBZsed/MzW7CtK4uMYeGh1S04e045Xt0RRI42JIBVNg1nBmam2quWjHgS92gh0fHK9u5eEVPusaHEbWOjEZw9DY87Y9kRNbs7UhVlJC5a9z4L1f0odDMIyzIgCG4YRgC7dt8KNadD07tgWiE04lSIlh0lmSQiih+d5TVoCLWje89OuNZvRNff7oBI4wFefZVte6CYaXn1JYiCBJ1MtD14Sw5fhZZ8/PGoWLp01NVVHM5EgqeWOJwjTKH7LTWpo1b9hYZ8FIE40OO6kxocMlDvp+SAxbwo5U7A7xDYduIZjd1vJGmmw1HSTMLjhvcdh/OPq8CP3j8Pq75/AX76gQUsSpPuGUtAvXLICDwR2bHun1i14osIZf4BVesidwklYdi/gIRkshOq1gSHowSy7MHUaBDZrI4W2Y+cmkNVdzscbg8z8aaeeBKWIsMsKmIpI5pD1BdW3fSvf8PlcsPIZlkezabYMOe0s8b8uNiQx7vvgbpxIxcxnEkPj8hwOEeYQvfbrGaw8Qj025h+IFf6HAd8nCwKiOQsJDUdHpuIaUUydoS03giILAmHxWMzGgZGUkgw0bEJRn64ILE3lMJEgtJILS1/R3fwJXgbJAhiESxLyfddEcshiUthmK/BMNogSW7kcp0QLBe8b4dwrvtlbFNcTMTM1zNY1tORt6W0BPLatbCoTX91NUSaQ9RHWDQ/8WukznXA1r4TvrAMbzaHGdNnj3laiZ6r7Xs3wHC7IadSkPk0as4kh0dkOJwjTKH77ZUn1aHIqcBpk1DusR+wyR2LpLxnOptdRH1hIlkTTTEd/h6zMP33iiW14zufaIRU+x3MZFzAX8gzTaAKpGDoHYhSJQSRjMU0d8mABQ2WFYZptsA0Q6y/ssMxBQ31X4At9UGkOp3wbl2HkzaswNSOvZi2eF+1Uek117CJ2ZTGkTMZ+K66ColVq9DypS9hxy2fR8fSNIwlMRRfGIA204RHNdDw3nPG/PhSm7dA83hYkzoznWYVVRzOZIZHZDicCUChZwqJl9H4VT6yZCpmVRWzJnGrmyLMRDvbCuI4NYjdhg/PbLSzPjQTTczMrfJh9V6q8tl3eaJAvWB0PQnLysBCT1qOxl/1/uxTYJob8uKG9fpxo67uMxCTm+Bwb0BKi7DIjcPj7df7hSqFaFJ0oR8L0fKjH0OnLr5nuqGJTVATJhQ34KzIInHi8aPqKkyRFuraa/VUIA0sl6ZOw6qqwjZ/HpT77oMZjQJ1dRS2Q8dPf8YmWCsVFYP2hOFwJjJcyHDGhLGa0nusM9z8pqE4eVoJHr7udNavZcPqtVgUfR2KoWK6JeINRcTGtsPjfzkUCiMWCtVSIx2xMB5QQzvyu6jqvvlWomSHbPqgWmFI8iLoOpVe51NjlZWXsn/pfU+DHWkmkgCBeVsGfhb69l6hrr9mczO0adMgGh4ImVVQ3AJMTUQ27MaCZfntjjhd9I1vQg8E2OX444+zzrr0XCRgaGYT/Usdh+0nnQTl5zfmIzGyhO5HH4PR1gYxlhdt5N0hwTWRxAx9v6x+6jFk4jHMOf0snLjsMMzS4ExauJDhHDKF+TDUWl0QRJx2xcf4F8040bfa5M9XL8WN7atgdmcQF93wmClM0UNH3CMzGIURC4erWupQoAngVFYdCDyFbK4LdnslisIz0Lj9Zgh1HpjGzl4R4/cvRd3Ua3ofS8JlpEJea2+DSXOIaCjjThEl7WUITkkh65mDpRdcParPEIkSLRyGQVOq29vZAMjQXXfBtngxdF2HoiiQJGk/QcXE1K5dMOrrWGM8kYY/RqMI/Pa3aLjvPkyU75f/3HojDMNkIxs6Grex67mY4RTgQoZzyOybDyMjm4jh9fvvQkX99DGJzOR2x5DeQL8yBbgW5s2RalsCtile2KdPvAV6PKGS5Rc2tUOzgEuOr2Fi4Jr3n4X/7H0HjlQalt2Jq99/xoQSCYcafRpPMUN/BZru/wnU8hwEVq3kzo8eFwRUVFxy0M+htbax1JoYCgGhEMT6ekx9NwrvOeWYOsqIA40VEHQdlpoDqJGeoiCToPQYeXiGNo1TikuUZci790BduBBCZyeU7m5k3l2L8D33jCq1dTi/X3KZNHw1UxFva2HHtH3F61zIcHrhQoZzyFA6ydB1VJZOg1uYjYjagTVPPXbIQibxZhuiz++FZZgQdSC9pis/LdmyIDoVlH5s7jErZkjEXHvvGlh6vlPuM5u68v1i5i3AB778DZ7mG2O0eqplJ9lhwTRbmZNaFO00tOigt0lN8aifTGH6tNXWBqu8nF0/Wmg2kiVJEDUdZkUFEzXGhg3Q1q2DMkyKiKIy7jNOR+LFlyC1tQGaBrO8HGJ7O2vcNxGEDH2/0ODQXCwKy+xpssT73nD6wIUM55AhwTK/4kzU+Y6HIgvQrBwao+sPaZutL6+FuZzm1ojQfYAtBpiaCa1IgC1qwUyqSG/oHnchs/ORh9G+7l3UnHAiZn7oChwpqHNvLK1hql9Cd8pkAyALM5lGk97gjIzSeZegde3DMKEDQr5ZnSDIzE9zsBREAnlSjFQKktsN12Xvh23mTJbyKQxoHGlExigthTFjBuS9eyEWvDLPPHPgbdBwL8uC1N0NwTRZNMeqqYHr9NMmhPeNnrdqxmyEOtr37XJXJ/ssDvcZnAj7zhkfuJDhjEn6Z7b9RJimAMsNODIy5vgP3ihIX0DbnngZM+TFgEeEqAsw7BYsWYAc6ynZZf/06Xk/DtAX5wsP3AlVFPDu1vU4bscWXPTdH+KIIQDBtMn+VYQj3y/maIalmsrORDC4vOcaAcXFp/VLPx2smOkb9SDTbsuvfwPQ1GyXa0RTs03ThCpKkLJZSGvWAOq+/jz5rkQjiAy99hptiF1WKitRcs0nkVi8CM/9/lfIJuLMvLx4+lwsufTycTcB0/dBNNAJq3AoloVgOIgnH/g7Tg104tRrvzToY5687RaomTRsThczYXMxc/TC+8hwDhnyrFBbdUsDLDFvQHUmnEzgHAz0K0rTcoAnr7M1J2AoAiSaftyjXQSnDNfCinF79eiL8d2XnkMWAhR/CSybgk1r38E/vvFFvPvM4xhvqMqnzGOHXRbhsUn4xkVzJqzf5Gihbup/w2YrhyS52L90eawh067V0QFx5swR9XihaiT6886eBdluh6CqvdJF9PtHNAiShFTld78Dz9lno/KG72HW8hdQevXV2PX2mzBMCzZfMTRVxZrN72LDD7+f70A8jtD3ga7mYLPnvT42jw/24lIYgoB3XlvOPpsD2b7ydeSyWWjZLFLRCLvMOXrhEZljABIUh9MgS9slz4qSUKHZBAhpC5ZmHnTqh0LBUWUPpJQJ3SMiVwm4myygJz0uVzpR/IFZ45ZWKlRlJcNBmIKFXDIJm9uNXDKBcEcbXr3njnGvoihU/Wxpi7AJ1qfMHD9Rd6xSqGaiPjOUUjrUaMxgUDpJVhTo3d2seR5dJuFQ6D1TiIawKIyqsmok+qOS6tpf34rYM8+yfjByReWgvWRGGhkiLFjIRELwVFbDW1WNVFsrIlqO7ctItjvYfh8MoiRBzWQg9ggZQRKhZ/Ol8aaQFzoDoy2JcAgSnUe6m2WxywcVGR6mlJ4zceBC5iimUPGT2RCEqRrsC8B3YT28Z0wZ0+chQUHG2/BD25GFBqUn5WPE9w2+Gw3sC+P9GswX4rClAGkPIKX3RWLGU8QQ9EWZjkUh2u2wef0wTQOO4hJYpoVcKsGqKJo2rhv3KgoWgTGN/PRoUeIRmSNQzTTW0IJP6SQSALrLieBddyH95gpm6hbsdlR85Xp4rrySvefsFIHpY3rt26NmLKBmfltfXo5kZzsUpwtuXxH8oRQTJlTRNNwU70Jfm4CuIuF3Y+bnrj1oT5lpGKyySpAkSIoNNo8XiXiMGX7pMv3wGUisqwOyw4kc3a+ny/VovDSF1FSKmgZaFja9shwVDdMw5/T38GqpCQgXMkcpJGLCD++AEcvBlCz6LELKGYg/3wRbtWfMhQBtzzGnBOqGzt7rJJ/9oLdXe85iJGxtiD3dM0xQBBxzS+A9s3bcDb70BUeixTI0ZNKkqCw4i0tg6JRLy4u2+uNPwJGoXPrOvzcipeoQRQm3DTPlmjN5KIiR1u98Fyr1dtHzlVFWLoeO++5H/dy58IyDT4UW9WUf+jjW33UHrHgINTkDM75wHVKNjei++ReA3caqrtTmZlTdcEM/UaC8/iaSmSS2LZiNdCyCpkcegGPu3IOKatDnT7HZoSYSEG32vCohAWdZKJ1at982KdUbbGmCw198wG3TfVc+/AAsy2SdmC++9qtse6ylRCoJb2U1Ep3trCqzY2cjOnc1sseN5kcLNx0ffriQOUqhVJKZ1qD3HWFj0LgYk912OMSATGOXDQuWBAhGz+VDxBQpwE1fWoB9RtERKbemL7bjz70Qa597Mm+fFCWkg93s1yCFuGvnzj8iv9J+9fx2RNI5KKKArpTOLj907enjvh+csYdFZIJBWHNmQxdFFpGRRBHi3r1IPPPsuAgZgqIoNVPr+6WImr76VUSnTkHMocDX0gb881/wXXghwm5nb2NMI52Go6qEdQ62azqyujpoCmgk0GNKp0xF2/YtKJk+B5G9O/PDOwUBc0/fNwKiAEVHRUmGp6oGajoJU9OGFBjU80pyOJCLJ2AaZu8+kngivUSPJ+weL+uRRb9bRhN9LUR2SBRJkowzrryKR3QOA9zse5RCvhU2H0a3oHsFyD2FDIIiAaKAxOutB23GHQq9Ow3BBHR3PpZLlw+F3M5oPuBhWuxYUu90HHJfmuBdm9m/o+XcT38B51zzObj8RayXhZqiBoD5gLXd68V4c+ebe9isIpciQhIAWQS7TNdzJj+swR0twNu2Q1+8mPWaoT4vLBgxztV6JF5KP/2p3khR1GnH9pkq0ud4sOucWoQVkXlzCo0xLYjQaSxCRRlgdyBjU2AaGqJFPSa3g8C0TJZeopRaoZfM9CWnDCoKKDpK6d9kR1uviPGU7B+ppF5XFGmRexoGatkM8+MQJGbqF50IPZeFZLPlH9ATfRUFcVCD8WCQyTibTEFUbKyC6s1/3jPix3JGDhcyRzECVfrogJgtXAHYp/mQeKUV8ReaEHpg2xiLGQqDg5VL03etEd9XBnow2GcWsUF9ArW5IKEUyByUCCHocZFn9yCzNYzYE7sR+NO6UR87fWm+/6vfZSFogkyAFJ3Zveadca9cenNnkJ0Tvw3w9kTbrZ7rOZMf1uDO6WRDHW3PPw8x19O7xulkQx2PJCHHXlRfkIR/ThKVZ3UhcaKfiSuKYui5HExDh6u8ko0rSXZ3wpNVIdkiaCtOHfRzUuTF1HVkwvn+OPQZXPq+y4f8nNbOmdcr9wRRRHHNPl8gfVYfveWnCDTtYcJIQM/oBlFkfpwCdfMXwsip8E2ZCjWd33eKAjVtWseiLLSd1U8+OqwwIZOxaerMeExQ9deqJx/hYmaM4ULmKIQW6O57t0Cj7p42QOr5bIpOGWZKg5FQYcDsaSqX/2IYC2iEgODYl61U98ZHJBboPkNFiKh3jOnoMetZ+SjNQUd3BIuVh5sSoDYlDkrI0S+1D3zjBnjLy/MRGUGAZZos3DyenDGzjD19S8JEe9KCZuZ3h67nTEzIAEuN7kZSvmyj0QF1dZB27WL9YQRZBpxOFF3x4Xz046c/Hfcy6AIuGtUgxZCN7gWkKJzlOTh7xBUJAZqHxKIXPT6WmMuOQIkf80vzE78PBhp5YiNhx348iDjuzLOHTFMVPCkFg69ss/UKFBIfVGXYvGkD4t1dLMqTjee/U2x2ez/jMHuMKEDPZmGSH4567Lg80LI5pCJhvHL3HXjrkQdZOm0oMUP7YHO6YfT09qHviuaN64Z9DGf0cI/MUQh5YJAzIFBUxEFiwGK/OcizorYmobsFSGlrTKImfSH/CkV8cu0RgLJKGf2AJdgFUzL5eSwTcMz0M0MvkXixGboNUPJpaobWmUTw7s2jNv1KxfZ8ZMcGGE4BSsSCmdFG5BcaaNajv5lLTsX6F56B4nRCTSbgL6/sd0yJN1qZaHQuLB/zKjHi02dMQ1MohSfWtUI3LDgVAVeeNJVdz5l4UJVP9+9uY6kMSZbh/+DlUGqmDFqaTH1h7IsWoe6G7/WWU1uiyH7NR/75L7YYCoaBxPIXMeXWX417g7qGxR/ClratkFxZiFkR0xZdAs+JJ2LN/f9gEQ5vVQ0UhxualoWuqjDULIoCIjb/6k5U/bfjoHwyVAatZrPweP3IxkxsfnU5Zp9yxqDbopSRrmpwlfuYSCFBUhAo9IODLiseL0sbKXYHtGyaVUQdd9Y5/bZHj5FlBVoq/wUkykrPZASLVU5ZhoFcKtXPWzMYdE70LIk/CXaPD9lYBOlY7KA9Q5z94UJmgjEWDnfyxwg2CWJGh5gGDFc+8aCHsqz6huJwhcZykq8n/ztG0OItp6z8O4sVW1gjMiVrggFJBbJbwsg1RmGfVQRLN2E5LZauYlsSAC2uwoiEWbSn9Kp5BxQhqztXY+3qlZi/uxZTzTLodgFyoqffqSDkvUTDMFSHUF95BQsXU36dDL+Uky+ImOA9W2BldBb9ociPHsqg+LKZGGt+fNkCLJtXgc0dCcyfUsQrliYoFDlhIsYwYLlc0GMxRO65F1AUVtJf/pXre0uYqTcMpS9sNhtsPeXUhVLmXE96AlOnQtqzB0YsNuKeLmNJ1WmfBFYCkbYVKJ5yev4yfT41Hc7iUiQ6O+DwFcE0VNbywenPV/hRJdGjt/wEH/z2j0b93UZpXBIShW8TOpckbui7skg1UBxL9orCNIuwkCmfjeSEoWnY8fab7DnJcEsRnbzfJR/doZQVeWNKavI/oAoEmnazzzVFYei7wlVWjmw0DE9lDUufZaOR/bw1A6HvLCpd1zJpeCqqkehozV9vmoOWjXMODi5kJhBj1VabFveyq+ch9tweqM2J3uvNpMZmFSnRnq8DWRzT7rjkQ8k1JWDRu0oht68Fudw17GNISFi6Relp6B5AVAFJNZHdHoEgi1AylL7JR49MGSzNJCYAM2scMJpCIuaOp/6A/+74AIqTHvblJmp5H0/+ud0HFEJk1lOzOfYLT8uG2eVCVQOFuunXHf0y27nqLdZ3wx8qgpnTka0QIOVoRpSF1MoOyKXOwxKZObG+GEunlUIa4ouUc+QhsUGmU5phZBYVsWiKlUjAstuBZJKJHPvcuZAXLoQsy/u9lqyCKRZjwkc/+WTIb7+dv0EUmSmY0lX0L/lqDrX53Egh8VKFvIApUF9Uii2pBIqmNiDe3swEAkERDerpItsdrLEdCZDRfq9RQ7ptK16Dkc0xUUHl2DQB2yDvUC6HmpSK2n+JWPjT/2W9Xtp3bEM6FITidDARse65J1FUVQ3DINEiQ7LbobjdTKgU+tP09ccQ9HxM7NgU5ALxfhVQJIAoLUXQvwMfWyATj7PncpaUsn48BagKkkdjxg4uZCYQLHyay0HLqay19sF84AvQAl1x3QmIPNaI2KYudp2pAHK6JxohC/AvaxjTcmbyodC2TZsA0w5IGSC3KzrsAk7PL5faoXdlWJdOzSfAzFhQUhakMht0+uLI6uwHlO4Ea5BHCNKBoymbQ5tRkyiFK+cA3ArMNO2blU97UcAolGMRlOHOARkCKfTs8FFIO4rda1djzpZN7HWZddJpCG7Yg9KpJyKUamW/DsvnncsqtwQVkONUOp7XYYerfw/RtykaZ+KkkmgYZKGyjS18ySSsTIZNl2ZzjXqEjJHNIrGjERVLlkAkRT8AEies3FjTIAaDEEpLYXV3Qy4tRecvf8UmXbPtKQrrBkwdfsc7SkNzyHY9fzuq58lIJEWWQiEBQaMFaN8LnXjZuRjB/KfBuuqedsXHsPWtN6EmvXC6PWjbsRV2r48JxCYhhU7DgPe1V1CxbBmLlpI4kSh1lEn3Nq2kiiYy56e7AyidOQfJrg72Q0S3cvtFVeg1o+3Hm/OVgL2Tt3tgvhcax+L1DR1dsSwWjaIOydSrhu6/+KJLWRUkZ+zgQmYCEWzai1J7NfzeSoRjTezyIdPzRUrj4EwbIJMQkEUmYsa8w+/MImS3hpn/xrLnnzfbGEXksZ3MCDzUIu4+uZpVEslUmCFYMO0CLNGCHs7BPt8HPRKFTr6WpMVEAn0P+i4+sAgjc+Fb3lcgdJMwAgyPANUlQsyZkDMUCh8+qkNfpl27GtkvuIqSGShzlMLSLGz685PAe7KYU3QS6lzTIckKGoTj4MiVMk+QQZFrG6A7BMBBfhwDVk5H96vbUDv9FIwlD77TjCc3dsHvsuEzZ0476PTSii0voDWwFrUViyE5TmTTtbviWVT6HGyuE2+0NzoR0/mb3zIRK6bTMJ3OfDSmogICRRDostMJqbUVliTBqiiHYhqDihiCRIlcUQ41FIbc2gqkUrAqK6FFIjB9PoC6/ioKhGgURjDIfDXjKWTIQPvuG/+HKctS8Nu8cGU3ofnVGkh6JRZeeAksTcOG5c+ykQe06JMwGQ763P3n1htZ7xWicdVK5ochX4zkoDRNCslQkH3u6Bw7yyqg51qQE4Bt4U4UrXydpZMUFsjdl9omEUMVTWue+g+S4RDUdAamnhcnJHTC7a39jinWHci3WaAUvKJg+uKTWESHtkPmY4rO0vYpEjvYD05m5hUEJlRJLHERc/jgQmYC4TWK0eCeD8nlAJT52GUMPzBuJGhtSWaiVYsF2GlytIjDImII2mZudxTZzWHISYtFgETNRGpVJzKbQ2yMwWCigR5HPhKWgskCVtZivWgk3URmRxSCk7oSWxBJxEgC/JdMG9H+L61aCrzvf7DlxQ1Yumk6Mw0LpsVEDEbgkaEIC/WvqHDXYaF5CuQqD+tpQx4bc02KDcq0Wy5oLsChKcC7WaTMDmhugUWXZOr9ETV7J3Xv2bAW2OIecZSNOvdubIuxqdaDCQnqGfPXlxsRzRpI68A7e8L4v6uXjFp0/PrJf6IGv4ZDstC8+9+4e+snsCU0I1/SKADPbe5kc524mBkZkX89BIsqXSoqYBUVAQ4HzGAQUnd3vg9MZ2dewFBkhQRNMAj0LKiDQR4ZIxIF3C4gFM73lMlkkHO5YNXUQNq7F2J3d7/7U1UTlWkfbkHDmso9cDfKFlCqRUQ21gW7x0TtXA9q6j+GRRe+j5mXZ518Ona89UY/YTFwO2TSJX8LlW2r2QxcJWVIh7rZ9O2NL78AR0kpTBKCgghLECA7nSxlRaZdd0UVM92H4jHYqBmfr4j1f7E5vTD95A002WNIsFROm4FsOoVUoB3OohIWKaGI0dbXX2GihHjr0X8x0UTpMap6WnD2BTjvM9f12+fhPscFMaaTgDFNJoQWnncxj8QcJriQmUBMrz8RtkaBTXW1Sz72i38sEFSLRvGwaAYNXDwcIqZ3OGVzknlZRI0a4wmsM6+cs3pKvYeuYCIzLPlIYs/shaCbLHKk+oX8PhfMudQ/Yk7xqPafxMzSTyxl/h0ad9D7m1cS4Du/btioDoWL7U4X/CiDDXaIifyXoekWIZJSoWnctCmtp4uLYUH1AUrahEK9eyjiTz1eTPL06GhOboFzd+WIhAyJmC8/sBbRdL6q7ISpRfA5FVZeXahMop4x0/xNKK3Yi22RKuyJz2LCZ6SCg57jjjf2QEyvwoxpfoSzEsocEuaWBBHMzEJKs5DWLSRz+qi2y+lJJYXDEFUVls3Goi1CttDQid7I1FNAgNyTImLpo+EmYtM7zOOFGAyxFJJcUQFj507mtUFREftXoPQSfQ6bm6Hu2jUuVU2U/qEUixr3wVCboHhMiKITZ1z5/d6ZVHTsgbZmvLi3Gc2+UtQ/9C9c95F9QqCw6Odo/AdVbPf4TUh8EIJiY511091ded8NnTdFQS6d6p2l1Iupw+VysUiKbFJVUYJFRIiWzRtRNrUBgZZmOIqKmfBRU0m2bRIylAajKEs81A3Z6UIqGGDCR7bZDxhFGrwRXgIl02cjvKeRnYPC8XDGHi5kJhC18xcguntXfoK0bsERtrMF+FCEh1LtgRBIQknkfwnZpxXhcMEqkDIay2ORCCExY1Hb2d5fYcNXMNFxko+EettoHSlYwRSg7RMxNDCyUJpNtL68FvEdnfDNrmKzmYaDtkvmYUM28qLOsFin4OF8K4WeMdv+8zKMqA6ZXMwWTfcWoDkBtUqEPWzmvchCT6m7SYZiumzlr6fokqljU/Q1JKToiCsVKLWTyalwSkBMtbC2OQLdBF7elu/7Q2JmXuluTC3/NyQhiNNqZDzUeA2OnzKy1FVBKKWyKhaW0z6FUezYiaSmYlOwFIG02ZuZ9NhlFhXijIzi//oIun5+U967wn5I9GlxIAgQysvhff+lcFVVjcigS7eLXi9MEi2iCLm4mD1H8A9/hEG+m1AIRnU1W3RJOFHqSSJvRjJ52KuayMNCUZZwYwa5ZA08VRpOvvhL/QZrtm3djH++/Ao2nXkJukUFqylCs7cFn+oRMhT5pAgMGwjpzYsKEhi0dZqXRH1pSFRQVIOKIKbOX4i6BQvxzn8eRiYRZwKB/C0UOaFGeSQi6QcHPTbe1txz2gXUzVuA7j07kY1HmPeOBBhFbUjAOPxFzLTbuPptmLDY81OZvM3hZN6c0XoVu5vyvppUKMB8MmQGJvMwn6J9eOBCZiJh5ksGLVZlme+OSwbaQ4qgUMhAFiBIFkSXjXlVDhes7FsSIeoGpIQF3Z9vpq6kR14hxXrRTPez6I726A6YWY31brDPyPeXKYiO1n+vhvZ2FE7BjuyuLrRi7bBihkQWlXOLNgGaq8dr05VB9x0bh01VFfrG5CeJd7OJ3tkdESgZC3LWZBVaJGA0pwBbgtJWArUaRFduLyLoxtTjjkdY7YB7bjUuPe2/RvWFmFAtlDhETPEK0AwwcWFYeZFD7GpfjRn1MiKZCvgdnfj4iel+UZNCakoSBezuzrukp5e7YZgW1jeH4RF1KHYBK9trEcpk0eArxt54HRojM+FUJMyv8eG4ah/3yIySQik1TYdWaqcg/uxzMFMp5mPxfPByeM47D/4RiIu+hmF5zmxInV2wLz4Bpddcw8QJDWEkoaK2tCD0yMPQZ82GuGkzRGrj3xMJoWqmwwktzORhyaWS0KJOzLvoasw+of/YABIq7SWV2CsoKE7F4fX40Vm6733KKgAdThbBoDSRp7IKNq+PNZJTU3FW6szc/qaJMz6+b1YR+VQKrSoKz0P//9oD/2CzqXQ24DUvHk+46FL2OIr+kNih56JSbNo2Ey2SjKLKKsSC3XCWlkFNJlFePw1nfeyaUYsY8te0N25jM5woukQiKZeIM8/PoRRwcIaGC5kJBBMCigQlYYB1sDPzjdwOFormpN7qhEUV0CbgPL70sA5dpG37Lqxnxl2BRjqRv62n1Nkxa3QDH+m+JZfPRLY9DteU/o+NPL4T+qoULK8dUtaCpEtIrQ8A5wy9PeaFEQUWibGlwYZpql4w8RF77sAVRQWBRbA01bN7IWgmBA2suZ7myUegRI8MHKdAsPswb/qSg/7SIoPtv1a3sNSOSxYwq4TmzOjozphoDqVw41NbMa+0HqbQBZ99A3K6HTpm9RMxf7pnHabkLGw2dayjiaH0OojA1GIbEqqJzoQBv13AnBIZ28MzmYCZXenBVaeWcvEyBmKmIGhooCIJDmXBfDhPOAFKoR/MgQzDv7qVmYSRycCYPQvy9u0wu7qAa65h93H16TPT+tTDsDc2wiwrA4J5vwwZi0N//RsTPIcrKkPvb2oTMVzvK7q+fs1arNY1dLr8qFBseG9D7X6Rz2f+9BvEA11s0Q/VzUSzy4/inI4pyc5BRwgUfmT0vUxCpXvvHkg2e74bMqV+JYmZhQv3oQnXAwUQRXReu/fv8FTXIt7ewnq/eMoqDurzS9VRFCUi/w1FfSj91ZsmG0HFFmf0cCEzQaAPIOVVq+VaeHNFrN+LLWoxs+6BSoSHgqI5BgV+Kb1DFo5Ifl7L4YQiG5kN3awRnKhZ+WZ8ktAvJTRSHNOLIE11w2rNsBEGJEQyG7uR7kjA8EqQsmZPTxgBbv/wKbPEm62wNBNWjy6UKf1T+E40RzcRfGAKjHr1SPQ9JQrwnlPHbq/FUhwKFFmpL3Ux0RLM0C9sA4oksFRPd1KFQxLQmZqBB7bKKLKVoyszDd+7fF8e/9//2YbrIMNhAVlRxl3FGtbmDOR0C+FMfqQBRWpiOQtexUKRXUA0Z2FPMIWffmDBMe+HIXHQd+LzocCqjhYtYhES6hMzEiiaQ0LEoBLtGTMgUGdYKvmNxRB/5pl++0T/3/7NKxG9+14cH8pBqq5hURl0dEDv7t7v/mPNQEEx2O3kiaF0Umd5Kd47azpO8bmQzWZht9tZ2ofus+y6r+H5v/8J2yUnXlhyHkzZhsycHJa98iimduyFw+05YGqWRAlVFpER2NR6xgL0XF/Yx8EE0PI7/ghDN6Am47AMk/lnXD4f9m7agODeXUzoFDoEH0jcFLp8U0QpEY/1jjegSNBQXpuxaIR6LMOFzARqhOcxilDpqQBsFiQ1r9zV1gRr4V9yxexRixkqh07tjTCzLK2AdHk88F80Ld/dNqezlJLvvOFNtQMptPjXQhlYfglWSxaGaTDfiWETWFdiO/P8CHkvil1E+XvnDrk9iqCkt4VhuKi6e59np1DKLTqVA/akGS5CQxGi5O4QZK/EJn4frPAcSEOpGzu68iWobUmDZQkr3BLiORNVHgl7ozosNCCSrcMN7zuuV3z8+PFNUELUVNGObstEuVPEAreMl6MqMga9JBZqipw4fYYXz27uYtuu9EgQcwZUw2IG4GPZ2Ns7TiCXY83M+nbePRgxJC+YD/fixSMWMQSlpMjnITodEBobWYVTgX2usX184CPfwwu7OiA98BIE2cF61uTvbEEL7KtoOlLQ4lzwxBTo3tWI9a8sR3DPLhRVVeGEiy/DBZ++Fpu37kJUtsGTiEHz+NFVWYtTvM4RpXlIcDCzsGnle9jQIqcoBxRAKTJmyzKLBtEZptLu4qpqLP/r7TAtAWnqA2MarHz8QI1KE8FuKE43q4bSeoZNltTW4YLPfHHQx1EqiqZik1Cyuz0H3Qj1WIYLmQkAKXGvUYQl5RfD5nDDohJkWKzvC6UrqIX/aCIGBShqYJvthxQ1hp35w6qN2hJsMR+LBbjQWZjEiBrLILsnCnv1yLZN+xKigZemnjfQ6vnIgalY+ZlLZj7KY6n5r3O52IGSj8wZfp7TzihLc4F+oJEDl3rXnF6db64Di3l3Rrpv+SGbQm9fHJa+e7uTVSdpaZU19ku904lMUQ7OGUXwV1Qd9HmlvjBUUh3PanTYbHc7UwZmFUvoTtPYTxbsYiKGzL+FKqTlW7twrkeGqlko94jIpk0sb80h01M0UeVz4JdXLGRihUTPXSua0JWk2F2eUGrs5m9NNkh8BH53G0xVhVlcDCEQQNetvz5geoa6SFMDRupdNK/FQuiuu5B+622YFeWQHxYx5cc/gjyKqAjNYaLUiNCVN3cXXhvJ74d/2cWDPuaM8z6J1qfWsyjM1pNPwyZPEeY07caJq1ez4xrvJnkH+vH2+G9ugk5jDYqK0b5zJ9p/9wtc9rX/hyvOPx8vrtmKBIpg01VMV9Mj9qpE2tvYv2QcZg3o2BTrRQd8rIdKuwteHDZPagkTFlT6bUJAUf10pAKdSEejvd29h4JKyKkJn9rj0SFxNVDEFCIwdNvr998FQZLZd1MqGjng9jn7w4XMBIB+LYRcO2HXbBANWqhF1ryNvBf0DUafx9FGDJggeGAbNMmAYkhM1Ay1MGc2h1lbfVrjXSdVHvJcIFrck2+0Qo+qbN6QFs5Ca4yj7Jr5B1zQWeUTDbzM949iERTywWi+Hs+QSuJu329SperAYwYKjfpIbIg9PWRGMzKgYPRNr+9mZdR0nlKrO2GfU4Tsnhg0N1jZtegRIZFhO2PBlrDBWJ1CTNkDyeNgEbXC8RWEDfWBoRLqviXVfSGhQX1hCoZdEimtkQwiWYulmewS4JBFZuSlbf3l1V3wyQbmlSkIisDDTVswX9WwQZTwrqeBbZOEz2fO2tc4j+Y1ESRmCEpdkT/nWIWayVnpNCy/H5bPByMUYtOnh2syd9+W+3D7utuhGirmNpv4ymMGPCQMq6uBZApiNjvq6iFKaSlVVdDa21mEwfR6IIZCcC5dOuR26Hrq6vvs/Q/h5++5GDVeJ/6VyOCH9/0VpUdgJtNwsEqlDJVbi8hEw2xBJ6MvXX/avAX405Lj8GrjblR1t+H8j4zcJF/oU0O+FJqDNlrTcmE8zNJLLmfX05BP+uESb21iU7Dt1IBQUVgp95qn/4NMPIY5p5/Va0Bm2zr9PQi2tyETDrIvsUUXXNJv//tGYNgAS7eXpbdzmXz0ZuuKV1FcM6XfNjnDw4XMBIC9yS/XoC0PQzRE1trfUqx9RtmZ+9IYI4UECvVuMYoFSDGDXe67jYLQoWgPlcIYtMhrOOS5QCRiok/uhuEETIqcsKiSBStjHHASNkGLvEgrdFpnDfWoDJ0Q+9h7eoIqI06X0bEk32iDnqOBfPkHk4+HwhwFUdE3KkX0/X9K7RlJFWt9AvbUKZitm5gVMWHsibLycGrUZwuB9cuhVBebCUUl3qIA1WlCFg3ENnex50DWgChLeGeWBze+tYdVEL2yPR/6n1ft69cAb6DQeeCdZibgkqqFrGGh2i2h1rsX8eDLeL1jBixzCmJZoDNt4jR1G6Ym16I7EQPJks/VXYo9lScOKppIzNSXuocVVccCFLVIPP00W1TESASg+UY0TqCri02gHioSc/va22GDDW7JjYauMBRDxM6LL8ZGU8DcUDfmr1uNxPLl0FqaR9ykju5T8/Mb0fHTn0FtbISYyKeKlIryAz5uZVZEpwq4RQtxnw0vLTgRpyx/YdzmMI2EvpVKpgbWwI4uF1JApxV5cNpJCwHQ38ihhnabX3mRpZUoKkIihKItB2NaJsFBQoumeUf27uqdG1VUXoHn/vZHpKNhGJqKjp3b2W0F4UH/WqKE5vVrersAr37yUbZdGl5Jc59sXj/0TKxnXpOFXDLe09wvxyZqv3LXX/ttkzM8XMhMEKh0OFef94bQ9GclZTIRAFOEfUbRqMUEDV2kKCkNLszTP69OwsZIq2zRlSilTEKm574DS75Hk3pi85Zo+DWLqlLoYt/07QP1kSFo+zTVms5DNplhERijM9N7HNRLxrW4nBmXScSMRHDR/tOQSRbhoRQTzXQKZKC/0grBLsFzRg2Sb7azSJBFwy5FCv5YEBwS7NP80EQDm+rt+GW1AEsCnCbwpXAOJ6aNfAiDTM1OgXVcpUZ5Yo/4ol+HsiVC8khQDAFq3IBYrLDhnYnmKKpcIqg6lrTk69s68NjqJmQ0A0/aJJR7bNjSHmMde9fsCaItnEQ8nYNDFuCUBfjsIqb69uKjc7YD1koY5lMQzYuxouNs9kqXhPdAzcUh2J0QchnMQxduuGboRYzEy7EqYPoNd6QGdj4fTLsNcOYHnhrFxUi+9joazzsf3nPPQdUNN/Q+htJJmqUhbaThEl1Iz6zHHvts3HPGheiWFLyuqfh0NIqiQBu6Q22oWPEazvrZTSMWFHpHB/PKFFIeGMFwUIk6CrcHsds0UUnveVhIb9qM5s9/AXV/+b8JIWYKlUqrn3oM0c4OlE6bjsXnXnTIKRV6/Fkfv6af52Skzez6moAp9bPy3w+y8SSZcKj3PlUzZrMIWSLQAcXjg9LTWZgqlQrl3ZQaolL7ky79EHsMNfujPjn5qFMONo8XppUvy6ZBmiSGXOUVbD5VqruL9dGhxn+FbXIODBcyE4i+PVRoIU+2xSCmTCReaR3xwEEWEXlmD5s8TSXcVG4s2CTI5c5+9zPiKlvUTXd+IabvyYLU6Rvl6Be5IW/JKVXDpp5YGmdbuL9moS9Tn23Ek7Z7z0Mux6oa6JgogiK6lX69ZIaicP5o7IFU5gD8NhhuAZaswJB0VtJupHWIXgVmQkOqKQxVMCCVK7CCWZbCkoscQExjAsQwJWywTGQkCf4M0OoQsMUn4sSoAfepFP5PIhPsMVeKgOCVkHKm4J5a0uuRIbI7orAiGiS7BG+dF53tERaRobSRrNjQGk+h2u9AYzCFTZGNmFoaRyjih5Wdjrd3h2GXRVT57OiI5+B1yKhw7oUkbIMiumBJ3fjQ7OfQnJyCHZGZaHFOQUO2GWKOvkBF9suQMzwUsZA8HjaQUYrvewNbbjcTM2Z3NyL33AutqwtTb7uN3UaeGL/Nj+5MN2RRxprSEBIhE82ijJJwGPayEmw79VSU7lwDNZ1CNxnV770TZ49ATFC1kUlDJWtrYblcLLUUe+JJVs49nBj5QGUxngnGEE+lYc+ksCwezI9ESKeZd2ciCJmBwqHwWR8LaPHv22PmYMQRq37SNOiaCndpORDveY/0DIhk0aRomF1HhvDiKXV48e6/YcvLLwCSDD2Txo4Vr6Gooio/+FYQICl2FnXxTW1AeNcOZDP5OU4FMsFgr6+HKrn4Z3bkcCEzAaGFmqWG2klpoKe9f//U0HAREeouazrAUh7U58QSTBZx6CuGJB+Fe/KpG8st9Hb+tdV7+0U56Hn1rMrMshS9Sa0YPvVUuL4gPCiapAZTzLg7ap9NUxie+hK2zeEiLwPTQoH7tyDn0CEaAqTdWVaiLSuk6gDBboNnUTU7H1YgLyrc9SWwWrOwuqkRDIWoyCyhsWgNiS/6m7ayGTlNQ5sDcBnA3IQJ92nVTNTRhPFUMAHLkZ/4LWYFNFx5yn6vF/lkCvv5wel+REvtvekcSitt60ygI5aFad8Ff9UTsBQZkj2FbPsVWDLtHLy0rRvxnI4KnxNzq7zIJEzYxBgsK8FEqFMx8flTVTy7twJnzPwoFsXn90785b/sDgwt8NTSnxb75JsrAGptT1OnU3nvgjFvHqzGRiRfernXPEsjMG456xa82vQqtkW24d3gu2grbWIVT61FJajJqpBadkKyO2nIBXLpBFp3N47IfKsFAqyPjKBrENvb81ea5gH9NpSW+fP8Bqx8+XXU3PEXzEhGe8cjGKH84nu0c6CS8ANBYoU6+2rZDJKBzn6m4H7RpK4O2F1ubHv9Jdbwzu7zo7h+BkKN21jnpqyahd1fzCK3uUgYejKLXGIjHD4/6zFjGTqL1LBqK9NkQ8y9peVY8r4P8M/sKOBCZsIisBJsEiWsf0R8ZJUkBWOrTjpFzzcQl1Rrv8onudzFPlw0qdrw9phnaSr2Rf3TC2xUABl2KfXUU/VCImU4YdFXeJDIiL/YDF00oa4LsbTRgQQZiyo9vQeqB9C35Gep9N1eocOu5LOzSBNLC2lkiKRUkC//5cDS4xRpEiBoFkzBgvvE8t5qIxJ1fdNlfS8TA1NpZxm1+PB/tiPgAhYkTZx0ah2K31PojSMw0STkelJK1IdikCqzviXbg6VzqJKIPDIvdbyLDYkEMmkfBCWHedPizMeybMG+IZLEP18RkKPoEVRIIvULs+G849+LK95bWOSm8S/DUdK3yRwZfMkboza3QN2xA9K6dTBLSpi4aL72OihTauBcehJmLLsYJ578NdYnplC9hLYUulqCaHjuafgTAWz22CC73RBFGaWR8IgmVMsVlRA0Le+PKTRUE8Vh5zIVYB6TDy7D3n/fj/TuHbDKylgFFjWVm2gVTIUIxPa1/0SwayXKq07D7BOuPKL7Q2KFRhNQikrNUIWAAIdnX5qqIJIeveUnCGUybNClq7wSei6DTCzCPDqUIvJ6fUgF8p24hZ60IJVxk8GZpZV6BkrOe8+5KKqs5n1kDhIuZCYotOAmNwRg2QwIKpDbFRtRf5K8sbUVclxFtlqAo6MnRG7tq3xiqZdXWvORG3oHGHkPi2NO/w66JChy1NiOFvYywBnMX0+RlqEY6KeJv9ECndqAU2PdgInY83tQcW3/NAd7np3RXs9LZneEmYUlGrooWSwyY1taxhrPxR7dBT2pQncCyl5mAGClOFKJA2KQUkESVE2EopvMt0IVT4UTIJc6eo9voKgY7HJfamYV43MfmINAUwIV9V52ue9rldjYxYzEtDsH05eGIIMv/Z3QeR6++uJypOQE3LIXPzrvon63FzCy5yPRtR4SdMiSgWnTru8344Zz6IKmwN6rrkZm9ep8kzqfF0ZREfTmFmTjCSRefBH2X/2yN0LDpq7PB5tAHdm0DkZDA8z2IILeFMqSOTSE4+wHxoGwT2tgKQmDpmSnUlAymfz051HgPe88ZLdsgUnTuEtKkNm0Ce3fu4EZiSeKmCFT7d4dz8A1bSULiMabn2fXH2kxU0hR0VgB+kk4cE7SXx97FI2zT8RcPYPS9r1sqCXNioru2Q1/fQNiLXsRamtB7dz5aN22mXlrKPIyY8kpLFJKvhkScFQlRSZlXnJ98HAhM4ERciY0rwBFo6FLBvN9jCS9RJEKPaZCTFn5/in0pThj30LN0lYJlXUPNkwaJWCxNwKZUPtCkRcyAZN/RsnsayRXMB8PFC10mSp8LDLNuiX43j8Nmqax6islCphOAZnu/p2KqZkcpauoyoe8NToMyNN9kLfSA/KN/Ci9RPnzXGcgH1kqzuepLM1iqRyB7pfNQvTkZ0lRlCb21B7ImX2LBc2AOhhx0RcSL30FTAG1IwlLNdm5IpPzoY6CoIXwt+fd1NuXhC2Mg3D6vAsQrPAjmdwCv38eFzGHESYINm5kAxlFEjM1NTDnz4eyZg3zrwyW7ik0CaAKqPp0Dg2JLOsNI5WVseqlA0EDJQWnkzW3o4GQ7N2czY6qUy8bOOl2wwoGYU6dCiubYSXdbf/ve5DLy+G/ZNlBNfsbKQfqWEsi5rX77kTp/Ag8SilyySgUp47G9Y8ecSEzXIrq8XUb8fD8M1Bms2OrmsV7w2FMtcIsYmYaGou6UJTGMDSU1tVj1qln9EvzFkzB9KpyEXPocCEzQWFDDmmsgM2ijE/emJvqLzSGgprfUfRCKfx4k8UBIwLyX7BK1IJEJc7W4JEWukzVQpoNsOTCnfJN6UiMBO+l7r0GmyrtWlwBUzBZhY9QoUAIa0BnFt65FYg1JnsElQXTKSLZHoFpmUi92Y7sljA0ynLlAN0lILc5hKrPL4YCqV+UhrBP8UGyRDjC1OU331OmgFxkR/Hls/rPRHqxmQ2KpP3zjrK78Gig/cw318uLPbp8qN19e3/ZH4Di4iXw+xePaH4P5xCNwH4/9EAAgsMBiTrnUkqBfU7cg6Z7qHFd/KmnYEQiMGtrIQUCcJ9+Wu/Qx5E8p0jTmckn09XVa8YfrLPvUNDz+C44H5GHHobU3AyzshJId0Fra2N/2fXr2f0Oh5jZ+cjDeP7RB6EaOiSbgjOuvHq/VCct7tSrRU+Xg+aH2N1Z6LkU2jdG2GI/UaMUb3cGoCl2ROJRJGkIZnkNGsIdzBtFRJv2wlNeiWSgA21bt+D8z3yx37EfqoeH0x8uZCYoFD2QHBJsCSMfcegRKCOBFv7s7gjS1OeEvmhtYr8ICkUsqIzZyugw7AIk1v8kH2kpVPyQaFKmeJgIUlQTGpUl02/CnplCrCrIyjeHMyUTsY1kiBMgmQKkTN4oW4jUUPVQ6p0uJoIUpw02QUHw0R0w0hql7FnJM/lwJIogmfkv6cEMvr1DKZ/eA92B3u6+hPuU6n7CoTAPaSw7Fg9Ft2jBSVmunrJrPZhB9z82w39R/aFNLh8BFJqmX+uc8TECR156CWnyyuzeDbOoCLaiIhT/10cGFSb59NRSxF96OT/wUJZZGbf7lFNG3EtGoj42NDm7UIKtKEN29h0Kiv7EHn8CpqbB8PtYiknp7oZAvXIMg811GmshQz6c9Xf9DaqP5oKIzGfy+r13stv6ziyiCMXuNe8gE3Sh5Y0EXKXFiLXYkQ25WSQn0LR7UMM6iZzVTz/GBkQqdgcWnn/RuPrBTqmqwKMtYSS9fiiaioZ0HO6SMjbjKkr9a2g8QTbNhlcGW/ayyBM33B8+uJCZIAxM0xT6qcTebGFVPzIrpRn5trLUO0WwWJsTM63n+9N0plnI03JJcF9Qg/S6bgjBfKtbSvskm8NQ32yGbhmQqICnIwH7FA+0ltS+d4pE6SgDqqbClARoZZROsSCn8imeqACUnFyO0hP2tf2nyh7XgvLe46N/hYjGZkolp4pQUhZssZ7Gd67hIwskDPTuDBLv/n/2vgO+zrO8/rzfult7y7Jl2Y63neFsEkhCIBDaUEobViAhpYUyS8efthAo0JZRKJu0QCCEEAIhhJKQvYed2I6nvK29x9Xd937z/f+e97tXkm1JlmTJvnLu4Secu75xdXXf8z3Pec7pEyPVtO/jJ60m073MB3a82AF5Xxg+2V1nLJUStqlaZCP22MlTtU8VW1vDONA7glV1Za/pfKT5ylyiRZ6qKLTQU/Bj9XnnwdixA7v+4dMYkTmKB/tg/++Ppo4w8HggDQ3Brq6G1NqK/q//l7j7ZOSByIDe3g5n2TJIJNS1LGhLl85Y2yII1SUXI/HEk5A7uyCVl4njEZAkcX5zDWq1wbSEtkQNBoTxG3mkkNEbiVtzmULnXfcn6G1twaEXnkE6bCHWrsITaoAvxBAbHMDOxx6CpKiC7Bza/ALOufR16Ny7G627tmetdbjQ+p1uA7k/PXc9gD2iMnPxkirUa5fh1UceRDoeFeGQejIhcpt8pWVIh/WCJ8w8o0BkTiMm0pTQBI7Zm4DRk3Q1IbKEwKYq2BFdVEWkoAorY4FHDaH7IJzsKl8ELipZZ2DKK/IyGJYBm9lQQip42BXFBuqKkewkkQmVEbjIZCIXYMnhokJCFRRbA5xSWRg4WeQ5I2rpDMFVlXAOJ0ZbTxQhoEWBEAdGbI76KSZ2SFNCbsJCO0MkKD3uPWqNnbQtQzqYdPMwDG4K3YA1rM9ZUONMMXxkBEskwCCfGtLIZDgkg0GiaVdrZqnaMwVlK33lZw+jxg7jAbkMn7nlrQUyMwcgAtH7pS9BP9oipoUSzzyD2P79aPjSlyDLMprv+zV2VZXAW1uHTr+Kde29U0QAMEBRwA0DLBwWImE5EhF5TifLb3LJgAkYhqjEEJFx4sd6j0wX1M5Kb9sORCIi30hErsoySt/z7nlpK1FbrP7XMjrTaei2DUXzwFNUIti+nojDMsL4w7e/iob152HjVdeidmkTDr70nNCVVC5ZimUXvw5b7r9HkBTyXrENHd0H96H36GGoPj+8pRUiVZr8Wig6gKqSp9tAjsgM7Y2qLdsfeQjpaER8PmjaiUz+yMGXdE5E4gqeMPOLApE5TaDJnOjDbRDqWtJ3FHtEpYQbtpunRG6yKjnxUqm3150mokqJxw1MlPwMLMVPsNY/HoIcHYnAquJQR7KvNThCK6tc75SwKSIA6PX0QzlLlFLNPIpoXZHjLdKW64BLngarqkSic2zfgHCpJQJC7aPQFYuQ2T0Eoz0OjbLWaOdkqseAUgr0mQK0PfF0FVCJvzGOTDGDN0pRBm71aKrFnx7zrS2DvXMAqFDhjBho+7+XEXhT3WnvO5cvLwXfH4VKliOWS8pEqjbpm+ZAYDwVdryyHee3PIjyijLUDYWx45VqXNz0pnnb32ulCjPwzf8GT6fBNQ32kiVwQiHwBx/CYCAgXH3D6QRM24TS0y0cgKMB7xQj0RyM0pgtS3i5jM7Q6fpJ/WCYIgu3aDkaARMjwIBaWzOr8xI5TN/9jog8cEbCQDAIJBJIbnlZ3EftqrmcYqJtbfjil5H5xc/wak8rDMsUQtjiRY3iYo2+wziTcHjzc2jfsVX4shxPQl741c/gKy0X+hr6XiHYpgUjEYced20ZcjhTBnLCAfi+e6AEiwTZkrxe0Tq7+pa/QUlNLdr37kJJ7SJ0NO/GgZeew6rLriy0mOYBBSJzGkDkIvJIG0ldYRYxMVZsWDokiYH5smTDZGJyhyzwCWaI2i2ubkRMFGlctFIyvSnoXa2iZDuRy67eHYPjB7x9LlGgiglTJdHiGG/IliMK5e9edYKfSk4jk0vMJhJGVRgiXeNHi8lzZuiufS7xoS9nImg+GRXnnszB1/1WklOUxwTRxhrfOSMH3JNXZaoECTNSJpjpQOuRsO9HjwAfGvN4OB1YU1uMzmo/eDwlSFmO0SUYQ9Eb509gTAj1NiNupQArCK+VEreBApE5lUrM4Pd/ANvrFb4rJOYFTQ2RnsQwEPnNfcJVt+EN1+DA3XcgIzF4JQn1F106KQkQXjC0HaHct0c1XczjOakfjJha8vvBIu6izTQNVZ/61KzPT2huikKQDh+G1bgEcjIpcpzoh0TJDd/77pyTGXIw9t7+Pbzy3BMwbQuRzlbRKipZukycX3pkGJlUUuhhjk+HHmptQaC+Hpo/iJEjh4SV/yjIKVeW4QmEhNvu6dbI5I7x+Xt+JmIjMiNDcBxHVJRyeVG58e1HfvR9ZBIx4SvTd+TQ6GMFzB0KROY0gIiCMLSSsq0HPffGu9dnWZuk0bWcpng8QzQW7d72ri0T1RE7bSARTsJRGDxRfoLLrk1XfjVeqLYCTq0kNdsi4lyMXOemesbjZH4qRCiij7bD8TiQyQWYKkjjnltx0xo3tylmCLdgIhgnW7xzrSFbd6ewRJ6SxIUBnkZO/5ZzUifjXFUmebAHrITeDw0r1HMxvKP1tBGZXHyDoruZVTRKaTMHaclC9LIAVo8a5s0Pqos86CMNqGkILRTdPuvR9iLQswOoOw9ovHxONy1aORQYSRNJIyPCv0WKxyHnXHUlSTxn+S03I7l1K7q3b0WxFwj07ZjUZI4qHfHHH4cTi4n2ErWZiMRUffITJyUNRHSU8nLYFF4pSaj86N+eMtGgVo0LBrupSbgWy319cKLRaZn0zQaXfPhj4t9dm5+FTgRE80CPjAhTOILE2OjinwONJtuWCSMSQWY4LFKnU8NDKKqsRtN5m8742DKRGMpQotBLb0mpyFCi9hm1lcYfE51HOh6DrGqwDZeQFjKU5h4FInMaIBKdNXdK6BgwQFscEmPOVAExuhPZjCQSjLpfOEq1DxU3uVduIw8cgdaWgFXEYPmYEMkmX+kVZVpW6xPbKlpRCc+7NVFVSR+KwPZyIYhNbXfJxnSyisZDVGccG3oJoBDJOM7PZjaCWiFkfvcqpLojkCQZ8UfaoZJnjsJEWCNxr9SuoZOTIonB9rRBD3XDkqoQCJ+D8kgAp5OgOjShRenhRTTGznAI7bin9hFctfQtuBSXzev+6Yv8yNYtYIqKQEmpuH02Y9tTt6F5791Yq+vYxALAO++YUzKTG7HmpEVRVXAS5x50k43pqptIBT2H2k/aH/6IJeTyq8dhp9OTtolES+eb3xCPU6uIqhDTTaHOJWDTa+cquVqprBD/Csfgri43kDKL6Zj0zWbB3/v73+LQq1tRtHIl9O4uZKIjwsrfMd3vw43XvvUEQpLIBjWS9sVIxGDrmghZrGxcimtu/QjONIigEIkpWbxUkBhgRFyMUgVm/LlTO4lM8KiCJNKtM2nIcmHZnWsU3tHTgFzlIhdkSJC8riYlV02JP98FozMOPWv2NhrgOC75mioZya19UGOuOZbjZ8gkdaSfb4cKCZXvWgM0aaPkgohPfFev0N4wymjZF4bRmRAkYrrkQwiOhaEdcz1tdCBzZHouwycDtaK8tSFI1zUi+lCLuG0HASYIkzWlUFb42Bx5DgOrH4KDVkj1K1C9i66OV5824a9osTFKvSZSCbC0jZbSLnSUDAgju/kGffnT5EdfewtqljSd1b4U23b+DJ9rvQ+rMw3obemD5I3j/L33zymRyRGHwbvvRnLbdsiHD4t2EMG7YQOqP/134r9p6shsWARpcEgY1lGwo9nTPeV2Z0tCTuW1E8EedKeViKwx+sneL5eUTMukbyYgESzpRxzbglJWikR/P0zKrRIDA1R/5lA0DedcfOLvMEepKI9I/Gsa8EohFNfU43df++IZzw/L2hMiE4sgExkZPebxLTL6b9PQoXr9sNJJeIIhoaPpaz2S1x45CxEFInOacLLKhTXipi5Tm4XyjwSoFVXqPWYbxW9ditgjJBrmkDOAHiR3Ww6YzokiWTLSI+1uLXVrjsL0HoYvsRSh7vppL/REtvTOOBTT1dsQGE3pnMI0Ts4BmMzzdGdAaHfiy0vhOzgCpyjri+IAeltUiIonAu0/HWiBwwYhp0vg+HqQLulEYGTltB2QZ4tcGjdBLASaG85pyQ6UtcX42qavTcvMbi5AX4aVy1YgldqFjo6fIBRaf1Y6/DZ3v4SGHhV/vicIT6sXisER9rah7G1ztw9qDyX37Yf3kktgvLoDlmUJoioVFQkSQ4SChLG7Fjeh59zzUbd7J9b1dsIuLsbIL++BtnjxvLrkzgkkSVRhSB9DIJ8aMswjEjNXhIkIDFUihjrb4SkuExWVNAmMc+CAL1gEkyotpikiAI5f1ENl5eK9pwoGoe6c1ahuWo49Tz4MX1klWnf+BAe3vCC2paeSIqdo0/Vvn3dyIKosm58TkQO5c8nBGwge0yKjSgydX6CqGLHuDpipFILVNUgMDuLB73xNXIQUyMzcoEBk8gT2iC7+JqQMH+e0q50w9TLe6C25rQ9WMgM5K1sZ7/wrppe2D4D85QzWipHVj8Hm+xG1PQigFiFMT79B+3ICMqRkdieaJLxeTmUaR7gW6zakKlUkUNPt4ivqET40glCaw/YzqGmOzP6RSasrtH//juWIWE/A9sYhWR5o+jLxWObg5K+bLXKj8pmDwyL+gapHNNlFGiSjjME7xCEzFW85eAHS+0bQVfkyKl8//crXqaCn97dob/8qODehKMVYt/bbZx2ZWVt/GXr/8AI8B49CLa2CnNDR/+AhxNrfg6I5sNknEtP9udtgaZrINCr/0F/BaG0VLrrjJ3peLSrFdz70CQxrXsgXXI7b7vgu1sVcY7nYHx/OeyLjXXkO0q++KiaWiCgQiam57bY5IzC7n3wU4Z4uMWpNWhiRHM3dYETymeLcQUdVAw7WNcFvcTT0tYvBheNBuUaHt26GkU6JLKIr3v0BbH3wfpjpNNR0CsGqOkTDYVHhMdMpDHe2o333Dlzxng/MS6WGPh/bH3wAO1r2wzQMkWbuLS4VthQ0xl6zbAWufPfNxxCTkWyVjjKWSD9j6RkxcSUpMtKxqBAKX3HcawqYHQpEJk8gUqsPjoxqY8jkjaaCJloIR6s7FA3/VKs77suOdf4VZMGyAQ9g+VphoxOytQK2chjDzZtRUf+6aaVQJ17ohi05QrciND21gUmPa7oQJMgjw4mbkLOj4HVNxXDWlIFTZEGJW5miDKjoo62o+siJY5W0/4a3/Rm05iIk0/shH6mGYjaByzTuyue0KpMT9dIXGNcYuM91I6YwT5FMrrnxCgQes+DNeMCHdQy27kblzRvmnMyMjLyCeHyPqL4QWtt+BM7J6jgBwxhE/8BDZx2R2XTuzZBe3wl186/AhkfAFy8B7+xEav9+pOfAZj+1txm2zweNQhpTKfG3M9EC//QFl4K8HBO0KKsanj7/Eqx76iFxEZI5cEDoZ/KZzFDlJf7Ek7ATCcjB4Jy0k8T0zq9+jp5D+12Pl+IScMdBhsbGJUmY35EIlvQjDz72BB5dsg5Bnw+RZRvx1md/h6vq6idvm47LaSKX37ad25EaHkRx3WKYlim8ZLwlJSIawEgmRCuL9jOX5IBIzO7bPotdJV7IgSBkn18QNZq4Ig8bVdNOIDGEOOl8SOOTjAsSQ6BjJHEwtaN6Dh0QgmEaPS+QmVNDgcjkCXJamePzhaaC/5IaWHBgH4md8BoiByQulDM2/OF6xGpNOOoIJLsE3mgjRn5/GDV/t2lKEjPyYIsonZKHjYgmYORjcepOtfT60j9fjkxPDP76scTt4qXFiO4LQxuiqgzAUoDRdWzI5PHbWdz0DvHfff+9DWbYzb4hTDeXavoVJMvNdtLH0rRzoCtKageSUJnMBy3KjjJc/x6q4swlkSESs3///4Nh0rinBUgVIphOYpKY8M0lcM+EDI0nPZPdnw84/92fQ+eL/cKhlg8MwKL8IhqNdhyM/Po3ooJiDgxCraqcVquEFqickFYhoe+998KOxyH5/ZOORivVVYh200hhVqdGuq7qauERQ2Z1/V/9mnhevpKZXNTCXAiIicBsf+gBtO3ZKTKh/KUVohWUzgp1CWX1DXjjBz8iFmp6v9uHEwit9GCxnsCgGkB/VYPwXZkIx+cR5SotL//uN0iGB6H6A0JomyMJVGGiis/xo9ynCnqvRuhvjUlCEyN7vNDjcXhCIUGk6OiJZB2/z0w8Jsaxc5NiROqC5RUwTUv46US72oRgeKLWWgEzQ4HI5BEmyheaCqnWEcgO4L/ixEmkXC4R2eT7Y6tQ0/xXSBe3wxtdAv/ISti+cZ4ME6Bv9wA0cBhFTJSEJXLB0RQhOJ4LqEtC0BqLhBfEMdNdfgVIWZBczzwxwTUdPU7golpEs8Tr+OrUqUKQQo/rzppDqvQgMhVtUIcb4M+4i55ElGZ84raYCJnbSRAiGS6J8bkhnFYPGFsEBi84BuBwBp9/bHJiIhBZ2dv8Sdh2ArIcHG1FdXTeiZaWbwo/DFUduz+fQA61yeeeF4ZyvKQEIOt+Iputrci0t4tpHDKRo6oDLdiTLdS0qHZ9+u/FWLRTWYmqW25G/Ze+eNIF/oaqUjw8GEXCdqAlorhm13ZII9n4AVkWrr393/zvk7r2nknMhYCYSAzpPGwy7NM8otJgOLGxJ0gSvP7AKIkh0Htb3N+BqG7AFwwikMygqr8TsZqxgYaTgcgMta52PfZHOJaFkqVNiLQeFY9R5hLFAxw/yn2qoM9DqaRA1jNgsiQEuwQ6byJTZiqJF++964RKEAXj0neRmaLpBaC0bhFKyQ16fzOMJL1X7vdDMjxOP1TArFAgMgsUI/93BLHmASH0lYOaEMwev9iP19Mo273wt60cfexkxKA1IGMlBxSLQw9J0BIcNrWq5gBUYYk190G2JQTGjViP5ks91iqmq4jE0LlNR48zm4rWjMfFs3ESSV8z+urvgGnFodY1obS7BCVH6sTXEgtJsFM2ZEZaItdXZy5BlRK66uR8GIyVg7EqgPlg21EkzAA89BfNjxvzPw7UejKMITAWhG0PoqPzDnE/kRjbdsAgiRbVQB62qGgBLrnxLzFy1y+g7d7tpjlnMq59/znnQOrrA4vFYEWjUzrnkmeKmYiDh0KQYjEM/dc3sPh//wflt9w85f4vLQni9rWN2BVLIXT7L7Fh/x6kr1gM298BRbHho5xWwzipa+9CB1U9SL9i6Yb4POYgKyqazr8QdStXj7aExhOCht/fi3dsfQyDZdW4prMFDb1tiNbN7G+EbAaan3kClmEg1tEu8oz0WBTeUBAVixsx18i5FIeeewadRgoH9+0S+yZCk0u7pqrS8ZUgcvElAzxqs1E1ZuMbrxMkjES/FmPCG4eOm1x/C1NMp4YCkVlgcA3qWqG3x2GXMMgGh50wJq1a5PQ0NP0zdFczjPYYtCVFo940k6H4dfXo3B/G4rQEj5T1tOGnNq2UO/7Bu/bBUmwoCY5McxihNyxyc6ZEwiVH8ZuWiufONLl6phWt2U6ddXRsh3UoCVlfDAQoB2YPrGCd8NmRTAmBVaXTNgecKYhY1NXdiK6un8Ph1IMH0qYBiwfBkYaDwKh2ZjJk1Tx0VgBiCIdfgMdTDdtOQ2LlcLhb5cjo/chHUEyA2duLxFNPCyElTQ2R8y6LRAQpIUiqOqVzrjXQD4e0HERk2trATROxhx+eFvkgMkM/vd4A+lZwxN8Wg6MmwDKAdIcC32DxSV17FzqIpJAIlxZ0+kTRGHXj+vNwwRSTQ/TeeteuQU1fB8pb9osFnjDTaAHa/hXvuRnP//JnYv8UzugJFSM+OCR+OvfuwuU33jSnol869rUXXohimlrau1PogAJVNchE9rseMZrnhEpQbv/j07uJsJD3U5JGtjmDp7gUenREJHkX2kuzR4HILCDkRKeGYcCopBHKbNvCcrOXToaTkZfxoCTl/WsqYLdExH5IByJ5lFPODiLHXtKbGEXZiIK47raECHQ6MmlyNFEBmWz0+kxDbq+BYvrBfQ5g9MAXu0acC4VqKikbmQNhMXE219WYHFaecxt8viU42v4AdvcyPNTyepR4PagJtOBdl1170iqK23qiN9vtwzlOBpHI1iyx8WX/1aeltTmTLabM7j3A0BCcigpBZqThrDaDMVSexDlXrqoGZ/sgt7S4WUhuKtKMjoGmmdrV38AJJmkwB5xE3zfUo+Hcr57V1ZjxYlzSd9B3A00ZTWchjhsZ0YLLkZjyxUtmRThy9v9iFHpfM+KxCIoXNyI9PDhvol8C7c+mFHLGkBpyLRgI9avXTrgvOs7x55d73/74g28gFYlCo8wrxjDQdlRMfXXs3S0mmlZedsUxr6PHxhOiAo5FgcgsIOREp4oBOBROSDPAtBg5XCRKz/W4cXFHEhkPIJGVA8McZQe5i4UnSu7EHDKFRnogkrAdciuOczhx46QRBWcKJIJ2HilCRc1HoQc74R+oQCCySjzGkhx6BaBSUSBuCEE1aXemCvmcLRY3fED8+FuGMaT2wi9zXL32L6aVfp1OtYCxADgncXQROKIwzTAYq4XDaWTULZdrnmrkK3Ki1eE770T8xZdEWF/OGyV47RtPKrb1v+U6eB55ZFRoKhUXC2Iy02MIZi5H0njcDUKkquCVV8C/8uwmMZOJcU8GWoxHentQvbEeln4UqSEfSqtqT3n/D3z9yxju7hh10CUYmfS8iGgTI2HImgY9FoMWCGbvZQiWls3ouDdd/2d45uc/FpNdvpIyxIeG8PTP/heqLwAznRQTYAc3vwB/qAiR/j4MdbaJ19LUFqFAZo5FgcgsIOREp45lCLddM8QgmVyEUJKol/Qwc7FY5tpXlPArohBoEoaMp45GTrl1Q2Lh2OFBSMOmCMjMVLtj1iq1ZShBepTq5Gc9QBjh2UBwcAlCfUvclHA6Wp8s4hs8ZCmiAgbpF/vTiP6hBVAY5CLPhDqmUwURF/rRdR0ez/SyluKJA+A8CcaqhR6GcyIyNPlB2hp3AoREwNVV10+5nTM94UREgrQo6R07YXs0ITD1nXcuGr7znUlfQyLf4aefgWwaqPzIhyf0ipkJ6tfdgpHmnbCsBBQliKqTvGevZVBFwVcRRdnKBJhswzZ64EnlVP2zhzDP4xyZkTBUfxDekjJkImGhoymrWzSniz4RlpzYV0/EBXHSfN4Zx4PQMUX6erHz0QehBULQQsXQo2GUrViDSMshEQsTDQ9juJdyvrhonZGomFySC1lNJ6JAZBYQcqLTgQcPQOoz4BnhopohtJ3HZSCdiog4uaUPRhEXoZWeCE0rua6+JHQ9VWhLi+BbVQ7jpX4whYtwTLHQZycoCcw3d9NRcw3KxRKi3vFDXwzwn1eF9J5hUU2iSTIahdaLGCTLzbqyI5n8qTIJcSaRHvrXbRUyVgnHca/6vJ5FWLPm65OSEyIwJBAmbQ1t40ya8JEWhcalbdMCKy6Gd80adH7sY7CGwyg+ziiPSEzHZ/4Ztp5BJJ1EtCiIxhvejjWf+vtZ75/Omc49X0fW8wmUMRSqU8DkQRgJG2rQQeWiU89Gy5nnUTgjTQhJSjEUj1eMZT//yzvFc+aKzBBhOfjS88gkE0LkrPl8Qo8zm8oPkRVyMbf0tKgMUpUnNdgHnRyPx01IjgdNQs5UU/RaQIHILBBQlYRaS2pdEJ6lJTB6B8QFNFUEzBIGLcKRORw5JUdbEgOT+NYMUqQyRK4SgaoLEiVUx61Zbz/njGvJNjxlAVhBTbRfaEcZClwkSxQLkEs9KPuLlfmx4E8ACt002mJwdBtMYlDrAqOZWf51laKdZPWnoRLxo0RsCTA9XNxObuuHUumfN0HydFFV/TZEY6+C80FRiWesCNzpyxIbCeUVb5h0QT546Ivo7v4VOKcPR5FoQ53JCSeqopS9/yb0/+jHIugxfPcvwf1+keqcGWeURySm77vfhSUxRCWgeVUT9HQS7c89Dm3xEix/xztnfQx03gUCc3I49gF4SxU4ThpqwAFzNDQsvxZzqdcRJCMWQ6CiUoQ00lTQsz//sah+XH3L38zJvsjAbqbaoMnaVARJ0ZAc6hJXP5GOVvcqaALQRNiGN15XaCtNgAKRWUAiX0padoISgmsqBRFwkoZw9aUQSQFykZzlVBFpPwSJCbiTULmWCUHWXS2ObRnouPv/UH/dzDwycsdPEwaWyuCxw0JvYw2mkN47BDVtwfIwKDS5NKKLyhIhH8lMbkR8ookqYfR3wwoM3dksIhiUpAPDy+CEGGSbg1kOog+3zFkL8PgrNfJ/kSRXqzEVQsHVkCQfXL2lHxILwOZuNUZRiiZtKRGJ6eq6U1RvJKkcnPdlCc1cu+XMDOTCK9P0UmmpMMpzFi+GfOSIGIOm2ADydOn67Oegh0Ik/EE84AV8XnjiMeiqgp6dr54SkSng5KAqXmj9dnA5BMuwEW0pQo11Pkr/ZG7Ib04vQxWTJ+/4IeKRKGwjA29RCfREFDsefRAlNbVzQgJmqg2aDLkoGpPypHLkJfsvTYQ1rN3gOs0wt6VF51aYbJoYBSKzAECVDBqxNskx1nKQ2tKPwCU14gI6+eoAmJEVLPpmn4FE/iv0ByNn3JbSKGQGppMxHiAlGY60HsTwbb8QvgrTJTO06BMJIyt/arXwjCVITOnbV8DsTcLuigudjCBRlLE0i5TufAkAHTUifKIDVjoDNSMBaQazyBUyW6aFwVcPY1HT3IZK7h7ajf3h/VhdsfqkgZXUBnE1SBmABeA4biYMYwqqq982YXXBJTF3QZKWUCgDHKeTPpniMSJFJ9PTnI72khl3fWF4PAaQXohGcw8fRuThR+D4/VB6eoBwGKGAFxaqYCsyFDDUnXv+GTv21wqoYgcPXXiZULwOSk2OC6/86znfDy30RVXVGOnvBbcdpCNhSCqVRnneaUsCZa5AWFbk0YuR0voGLF6z/pQqPa9FnPzyrYA8QDZI0mZCjklTMKmt/UJHUnnzWgQuqRXE5lQWfjKRoz+kHImRSzWxTe/KUuHsK5scksPg91QKu24SWc5IpCxLYvvKqBbGFfNSW4aqSnSLSAxFBolTTLthkgsR1DqquGkN0k0GjsR2wHYMqDFXOGM6Oob13jnd37a+bfjdq59Apvt/cP+2j4nbUx5faL0Qpoo6Ch8UU0v0G1DVsgkJiUtifglJqoLjDMJxqGJGE0JckJhly/7xjLZWcu0lFo/DrqwEi0TFfxMczmEH/JBTKUiUZi1JKDNsbByIYnVJJa597wcL1ZjTgNGKnUS2/Qx1F148byPqpCEh11+KDxDu1+T2LEl5py0hITIhF7FAmVTX3vq3uObWMTfkAqaHQkVmAYD8SBJb+wGv+B52vxRMR1RqSt++fE6qFpM54448cMRNp+VUqWHwS354JGVahl+uLobM1Rh8F1TCbh4EFEdUjnJi3tx+4k93AAkrd5EviM+petacSdDvZPVfvxnph3Xse2ErQvFioakZQBcuPu/dc7qvto478Aa/Don5sUQZFLenqsrkBKpHW76BdDomCExJyYWCxOQISU7Qm0jsh66nIUlNcJz27FSThEBgxQmvOZPQW9vAUikwTYOSJTGciHljI8quvBLsyisF+ab8MWpFLTnFnKECZgb6nAwOPjYai1G/9pZ5ewtzVZfW55+BE09ACgWx9Io35FU1hkCeMWTcSKSLUL9qYi+aAk6OApFZIIuiurYEaB6BPW7C1o5l1bhzhImccZVKMkgjrxe37VMdWoHATV846SKQ08XYccNNiC6SEFpXBbXUd4K2JBelkNMBEYmh9kw+tpVmCvHlmXX0JAvzi5vmvmRciSEYPAKTB8lPUNw+GeKJ/YjFdoGhGqbZJ9yCx5OYXbs/BNtWIMs1QhRMkQguGBYtukmY8uUTGNF7Ii5ZZ1/hW3zVVai55WYEsp/VAnE5czjd013HG9HlG+j7oH33q/CXlMNMp/LYcGJhoEBk8hS5KR/6Svatr4T/wmrEmiOAyYWWhb6pM2MRJ/Pqm0K+KDRuTMnOSkZG5iA/6fQStYXslCkmquQYB7c5Ui/3o/LW9ZNGKVBrbKaxBAsFcyUQnAhLa6/H4cROyEwH57K4PRWIqHR2/AScm0JxyB0LvVvugNbFYNSbCI9sg+OUQJK8sO2Do40B0tDU178370gMgdKuSdjrUAo1hTc2NaF6HIkp4MyjMN01BrqoIXE+CX1p3LqAU0OByOTzlFLCEGtIbHc/fE0lSNUGoHYmBJExiMgEVMyniT9NMlGmE/cDagrCwI5AIrqTTUcJXQwl0kY49FIIoSsZyU3lpTKViLaAyUEOv4Tw8G6UlW8YvT1V8rVhjIjbDKQjCMBs78F+9UtAuhiSXAzOe8H5mOo7p4WZattnElRtqfjo36L/Bz+EtWI5lFi8IAAsIG9BuUySJMM2x/xixAVqAbNCgcjkIUanfMjsLvsBN/aOwO9TcEhm4BZHUpWw6dz5NY0jvQxBpogCWvSy69p0pqOIkAQurkHipV7IJoNs5eR+hb/WuUJH550YCb8Ir28RsUtonkoEA6unfA2V9i2LBJdl4M4gmFQNB/ugr+VgGtnF27DsdkiSB5xMcMBRVHQuljX9fV5oYaYCaV+EKZ7XBz44dNYnUBewcEHV2cYN5+HIti2jsQoziTko4FgUiEweIjflI2dsWCRRIX8VQSQcrNxUjcEiD1YvCaFuRem8HgeJfjMHR0b3r1T7hBkfCXWnUzkp/dPlsCQH6a0DYoxb8o+JfAs4dRJz5MhXwcVlHFVVGBjzY3j4Eaxb+7VJSQfpE6hFRNNHktQo4gnodUzzw+H9WXMLhrKyK1BacuGCcqv1rlsL9kgxeGenGMc+2xOoC1jYoKTw3qOHYKRTwjdmpjEHBYyBcfJILiDvQG2d2CNtMDUOJZtyLYXcVOjT2X4R7aXjJpmmC/poUQYQ69HPWu3LmcKuXX+NoeGnhDkd5/HsaHQPZLkMTUtvxeLFt0762jFjuxowFgJ3esDtNGTZDy5R5EDwjEUOnEqOE33WrN27kdnbLEhMoRpTQL4jNwRArabCxNLsUajI5FH8wPiFnkiDXONHikaWI6YIHZxuJWS+J5mmO3atp3ThS6OG6NirMNQVR/zpToRWlKD+yvlU95z9KC27HEPDT4PzAUisClwEblFlRhGL/1TIZCiIjkFiZbCd/aJ9VFl9LRoaPpgXmUE5HU8uiHE6pIqEk+RPQuLeaMlydLbHUXV4ZN6rlgUUkK9DAK8lFIhMHsUP0OLiPacEnmUlop3Da7wIrqUwQhqnXRiFs9E4gpQBy8uEkR7lnyVf7gPJZFQOpA6PgLxkC2Rm9iDRbTrdjq6uX8AhMiNVC00LdxwxWj3Vwm8aNErtgcPdqThqNRGJyZepEnKBNc00OE/DMFLC70ZVigV5O15sTKSHnm87AdRUvwFdu2rx0u9bYNsOPH4Vb/2rtQUyU0ABZzkKROYMgyoXlJhsegElw5E+EBYW/VwFHJ8MOeXAZhyyBaSbw3lr258DVZa4bsHJOvTqlDNk0Pg2B1foHN20bvPZTgw0u34nudDFAmYGGoP2+ZbgyJGvCM2LLC0VbabW1u+IPKXJSAmFRsYTvXAcchhmYqQ6HwhMDvHEAZHh5LbNBhCN7haBlkPDz4jHc2SGSMzuPR+Bbbs6of7e+9D27AchqythGg5iMQNbX+3HDYWqTAEFnNUoEJkzjtwUD4MdACwfh5JiYmJJG7FhEyGgaSE+Ztufz0RGCJU9CuCYUNMcEgekNOBIgO1hcDRRDICjWEiLjCXA6HCdWAtkZuZQMn8Kzd4LXfo9HD4EhmJY1sgJadTjNSf1de+DYyuIRp+dsMpxpsE5GSQZo19PjAXBOY2Lcwz0Pzh6vHSOlhWBJK2G4+yHbekI1UUwfIA+d64bdb98GsyW5hNtLwJ773e/Jta+A2i8/EwfUQEF5B0KROYMg3QvqV2DIgFa/EKS9HXNRRq0GXIrGJK5cGz7iWT531AH69E2OCogp9zvYCIsChnjZZ9n0zQWrTXMHZQhQXGByMxMBNhzeATP//53KF27BZJGjDcFSa4HbAt9/Q+hKhsfkNOcmCaRAYba2luxetU/AHjvaflM5EgUmIJUqkV8HnLHNhEouDIW20l2jOIrisgZR9h9kI3Fw41EtoKxZeDOkJjeYqwW8a5SmMIugGPQx3D5+dVY0CTmvg/CTkch2xmX0Nz4i+mRGXrtlu+jq3MYff6NqLnq/QUtRgFnLQpEJg8WfgoYjL/Q5Y462zkXVcBhDJxKGln4L6jK62pMTrRsRFKQIYHr466GJZexkBcNnRERHDej3iUzNBVVgItXH/4/vHjvXXBsWwTJve0T/zThIjTQHofkOwom58zt/HAcWsU10Zoh8kBkoT+rOQF38y16e38BSUrB562fd2EvjYm3tHwTjpPJGuy53jR9/Q9iw/ofTrhvqrhERjZjaOgZSFYluBJ3PzSMIRRcNTp5lUwegSStgMN1yFIj4gNLkBpa4dY4ZQnXvL0JFzeVL9yPVc8OIBOBqZVAyuhg6TDw5BeBWx+dmLjQ8yUFaHsOOPwEOuNePDFyLjLJnVB3teG6T91WIDMFnJUoEJk8QM7RlohA+DcHYaR0UMy1N8Zh+RgsD4eiA8ltA/CvO/2TS9OBOPb7DsEy3fKRrGSvnDm5rlaL4xZp1hJD9HAEAwfDUGw3BLPkkppCNWZcJYZIjBosQnKwH5YRxhN3/BCLVq8VPhPjCU3VkhAO7lwGx/JAlqPgVMHgCTBWDFkem14SfJHHwVgVGFsLx3kWXV0/F6Z3ilKEJUs+LIRLc01qqBJz9Oh/AbwUnLtp2VQ1AR8RLSEiWJPtj8THI32bYctkzDciPkeSrYpKDm23u/seKPKlcJw2EbVg2R0Yan6neJ6sSbjsz5Zhw+sbsKBRdx4gqdDS/UgHF8OfaAc6Xwa23A5c8uGx57W9COc3t4ClhsG4BUv2IxNcgv6kF7puIajoSKRTosJXmJAp4GxEgcjkEYigyEUauGlAjbmVGApqtEIM0Dlg2KJyk49EhkTLVlyHXsLhGQQcmcG7shSh1y0aPd7xo+XS4RFRUag4DcZ++URSDm5+XrQOjyclOdBiQ2TQicWg+Pyw0ikMd3WIn4MvPY8b/v5fR19H79sVN/wZutsrIQdfhOyLCNKiqEtRW3PVKEmgxb+r+x4w5oXjvAjGKkTbhiacDGMAhw9/GZKkiRiCmurrp2z7zAREVBwnBcZKwFh5NngyA56NODf0/klfS/sPeVYjYh5w2TC1IRVbTGQR6SLdjO3sFZNNgI5MZAWsxGos3ViKc9/YcHZ8pqiFdO57IL3yv5CtFEwlCNVKANt/diyReeqLsGwLEpNheSshW0kEoodQ4xRBcc5BwvFADfpFm7KAAs5GFIhMHoHM5yjRmjluAZ4gFqYUH9WSOMmsYCbPqjHp3UNwFECLAHaACRM//XBEjJJPRLxooTkrFpsZtIuev+dOWLqbWH48KcmBFhtFVWGk0/AWl8LWdQQqq5EY6EUmEceBzc8d8xr3ffwTAPQzZgzn8YzFpJeUXIi6ur9GT8+PxXQPTQIxhLL6kj2iguM4STjOCLp7foXevgfg9dZDlgNCrzJbMbBLVOgrxoHEqmHzYUhEQLJJ2lMZClDVJcoPgtTiEiuCwyOkHMORI/+BurqboKrV0HWX5MhSADWlH8UFH91wdn2m2l4E3/NbGL5qMEeHHmyAGtkPDB4cq8pQS6lrG2xvDYxgKQKxo24SOKWUF+m4rlhHX8llBY1MAWc1CkQmj0hM9MEW99vdz0QLJnBJjXgs+VLvKKuhUeV8A6V0m9yCrQFqmvSY3A2YNB1xTslXehG4qHbBtI/m2m0z1y7iDgeTJCge74SkhEC3L7/xJjx390+RiUbgLS2FZVDLyF32k+Gs6HUarspkEEcwDAMrz/k0AoFKMfUTHdkFLsXB+SHI8kZQH5OLeIIAOE/AcRhSqWFw3p4V3Y6NPM8EmoeEtlZ2mop+92y0xUT/7RGPT4yOzjuyJnfVYMxH9n1gTBIj4/39z6Gx8b3IpFvElqrnqIKUd+jZAWbE4LEN2EyFLEWg+6rhSfe7VZma9cBDf49kcAm0zBB8qS73dUwGzrkOuPSjWNR4+bwGyxZQQD6gQGTyBDS1I8Ihg9RPcltKmf1hqLUBBC6rhT2izyomYL6Qc++1YwaMfkrkZpBMaoMBzASMIuZWkmTAGU7DIpK2AEasiXQ8+J2vjeafTCa0nQmIFNm2DcXnc6duHDd9s3t/84TPP/8tfyr+JfKTGQmjpHEZ9EhUjCWnEjE8+ZMfTtmekmUZ4fBWDA49BO74UVV1FcrLLxJkhH6OvvAltCV/JkbiOO8DGOUskQ6FDPJOBAVTzobIRJRlSDkSfMyCzXdBksaqJYpSIgjI1KZ9CZe/sXXgfL8QCzNWCtseBIOFlSv/DWc1SCOjBYF0GDI34Uv3wtBKkQwuRmBwP/jP345UcDG8yR7Idi7ZVQbe/B/Htp4KKOAsx9gsYwFnFERSqHUkcwYtzmEGGMwRXZjjJbf25xWJoerR0J3NSG7pQ/JwGIZuQkpxyBlAJT2vAejFECRGSQESTZZnR6zzHVQlSUYiJDRBMjKC5+75mSA3pwKq7HgDQeixKMxUAkxSRGVmqLNdtJwmIzNrrrhaPC/a0Qot5I7d9x46gN1PP45djz8sCBcdG/1se/B3o8fZ3XM39uz9B/T0PIee3ruwb/8nRasmh2Wv+xxCnpXiz5/DhON0ZXUzE0ESXjOzwZODnfjZcABbkiFELQsOgtl2EkNpyaYpqyhk2ud+PelwOMUoEPmjdhmDqnpPGsNwVoA0MjRuvfJ6YNHFQKAamjECb3oQuq8Ghrcc3kT7GImRtYVPYqhV9tL33H8LKGCaKFRk8ihnyf+2JTD2DsMZzICnLZjlDGqUQzIdESBpDaZEZtGZFPvS8UYfbQc3bUG2SA/jGXRcRpydtpYcINDJwX3Ureejln/5PGJNhKJ9z07EBvoB7kCWZJFc1HvkEB65/Vu47sOfmnVlhl5HlZ1tDz2Ao9tfBpMZVF8ARjKOLb+7F1VLmibc9spLr8C+558W1SHF6xNEiMmKaE0ZpoFMMiGIV9uuV4VA2FtUjEve9Xr0x39O9IlqKULUa1nO6Cg2gUhNgrdCkmrgCL0Kmc+5AlxCIHCOmGaiCtBsNTK0j5LYH7Hem8IhowYWT+F1KulcSCPEsm2nyZHbZ3vbj2FaKezHWgxJ56JO7sJ1S15/draSJiMzOd8Y0sU8+s+CuJgoggMZHseNNoEWAK7+3MInMfd9UIycQ1aBqz578vPJjZ1T9apgFviaRYHI5MHIsp2ghQTQLq5Ezd+cN6qX8QxzWH7A9jMoMUfkFaV2DKLoTUvOSHWGjnfk94dhw4ZVRJNJgBZ1hHsvslNKTorch5OQTQdOmsOoYNCGXDJjDWevHPOQxDx710/g2M6YBJUxeItKkImOIBWNnPLoai4c7p7P/xN6Dh6At9gldeloVFRWJmphuXqZ9+G5X9wBPRqBFgxBkmToyThUfwCa3w9Z84ApCopKyxEb6MVw//NwvL0ATwnRp2u/oh5TwaBpIs4pN4IWQVd8zHks+6iEkpKLsOoU2jauAd+nsFLRcU7QwZVyE46kBqE7HKrEoMn+0eedjJAYZgJt7Hw8yG5Eh6NBIT+a1rvxl1NEMJy1oEU93AJs/yk86UEYvkrXN6Z+E3DNbQt/IW++H04qDM4kyHoceOILrg5osvMiYvfsV8SFB3ylwA0/WPjvQQGzQqG1dAZBlRgiMZbqwFQ59Of7MfJ/RwRJKX5bE6SgIlozSoLDLAZsFeC6LUjOwA93CmJxusMgzYE0bNWdi1ANQHbXQUFiKt6/FlUfPheVt6yDUk3WvYAsjp2JiAISLQ/dNbEu5EyCKjEkjvWVloqKB8FxLJgZl3g5ljVno6tX3Ph+yIoM7tgI1dYLAStVVogoEag99MDXv4x7PvePgmBRi2nDm64XhKWkYSm8peXw0TSTYaCkvBIrLrgY3LIQ7e2ComqorLkUijJWsaOR6qamTx+z6LsVMhLeusJhxjShWZFlPzStYkrtynRA1R/Los9mGorcBPBWLPVweCQitA722ovx454U7mv+n2NaXhNpc0jo24oqSMyLJWwEGXhx2K5xnYJfi3jr14ALbskKuck10wJG2nBWgKbsHRMZXx04LU1WWpCbSSsxT38ZBl17EOlJDrqVmQJekyhUZE4jESAPGBqfzoUkirgB2w1TdDwcLOmmRJN5nHi8NugmYycMkLkp5S7ZPiY8Zoz2OIbu2idcgU9Hq4lIF2U9URVGsrnQ8kgZt3oh+RXhF5MDHY9S5oM5lHaJDuOiqsQSHJnmsKg45Yveh7Bk/blofXUr0iNheIqKIakqzERirDgj0QjW7Hxhjgc9p3rZCvQePCDaRdS+YWCCKNH2fv+Nf4fl2JAUFSMP3AcuySiqrIKRTiLW3SHWLiOVhGOZ8IaKxPao7TV+yqpyZCnaO+5GNBXBoBxASF2LxeOOgXxiBgYfE2SDiAIRHQqZzGUxnWqlg7ZBidoMCdgOjQO7PjIMaRxl5+G3eD96uAePmQYqB1rx9kn25/UtAsM+NLIe/J+TQgal8CKDFXIfQqG/mNWxpbZuRezhh0XDs/gt18F/4YVYcCPZr/4chqcMurcCWroPjFoxtIgv9GrEuneA7fg5FDMGR9bcWIa+vce2j/r2uFENiT44ZgZcK3b/howk8PKPgI6XgGCt2NaCfz8KmDYKROZ0VTN+sQ+WbgmLfiIh1GYp/dPlUCq90I0M1JHsqsn5aDAk/VDadfTRVvEaKeXmMFGyNAlruWGfthBJEQYpU8nXhiPy+Ljwu6HKS+kNK044BtLDiMgFzqHQ9LBQMruazXzLVaKqR6SvFzsffVDoUIhEhOrrwS1HkAd6z49vLeVIB41RT+ULM/75pGch0uILFoltGsmE0LsUV1bD4RwDHa1gmgaPpMAydaQjYRx64Wlc8e6boaqqeM/p+HIIlZUf07Yaj5HYdhhWETz2S7h/26vApu9hU80m8RgRlXVrv30CcZmrVg1th8jR0aNfE9EEABn1lUGSlmAIK5FxPCjDEMKoRCuWTbgNqtQMU0QBq0aTtQUfl2V0+jdhnc/CtQ0fn/Gx0vb6n/kp9F+8CHW/DcY54o8/jkXf/MbCIjN77xej2IoeRRerw16cjzoeRSMt8qeI8F13IfnSZgQuuxRlN92E0w4iHsuvhXbwj9B9VZDTGaDnVeDe9wG2Lib+HFMHo+k1bsPylMPhQCbYICa3zEwcTvs20XZjBx4E3nlHgcy8RlAgMqcBopqh2yL9mRYwleIGtvRCKfdBbiqC+nLa1ZnQ1b8qHxMMSQSh+M1L3cpM0hDkgUiMeK527HPnE3QcpM2JPN4m8p/kFAfzKROSGEKOqKR3D8LojIvjFoMneZqrdPUtfyP+3fHIH0S1I97TDc1Ps/DUW+IntJaoEkPkg7QqtqELQkMTTle+++ZRUpETEBNR2f/CM6Okh8a6A6XlYtyeXm+aJp782f9gw9VvgpmIwzJczRTBX1Qitrdk/XnoOnJoNKBK8XiEGHjy1s4IFFYDmTm43DuEw71/HCUyBCIC86kxIbEuVXlIjzM48AgMk4Idg6hBJ5LIIIMKBCTgkupVk56DaXBIAzE4XhsXbNmL9/7ZR+DfMHPSQSRmz46Pw/IMg72Xo/iBRfC9QtYBMaT3No8SmZ6s2zRFP+StsR4DFDOONtThcVyJOHRojo0b+kbQ2HhqJKbvG98k0yEknnkGya1b0fCd7+C049KPgrU8DUsrAU8PgNkGHGodMRmSnYSj+KF766FacST9S4Tfli/ZKfKoFCMCSeR5UdkyfnZUqQqYFgpE5jRAVDMUCWqKJn0gfrQYEHmoBZ7Lq6H4NdG2oYoHkYUTqhvZygwRImskA7M7ASmgHmP/P/+eMYNUC4L/TYsgDZBIlJ90gorIDP1M1FbLR+TIzO4nHoFNMQG2BdnjgWMYGGhvOabqEQ8PwzYN+ErLkeh3DQtpwul3X/s3YWhHFZijr24VpIj0LVR5KWlcDjMVh5XJoHblKox0dSGViJNOGpl0Ety2ccV7bsbzv/yZCIwkwnPB9W8X2w73dJNwR2gjhJ6nqHjS6g9VWSTy9eEJ2JCgMQeLkDVVPI3IESVy+B0cehKcd2IpS+Gv0Yd2aR2ubXoHLi3JksXjEAyuh2x6YHqPiIwlpY0fQzpmggEKzXQyYFopuCcAvWkAvlcojFuBb91aQWB2PtGJjv1hQVo9ARVv/qu1+Ulm1r4D2P8gepK1sJiKYiWNqKWip2U/Gi+hkfXZgSoxRGLsulo0+4tw0NZw6b2/xZtu/HPMK46fOqKfmg3w9B8UOVsSadWUEGwtCNk2YKohEdeg6BGUZoage6sg2TpU8zi9oBZyt1nAawIFInMaQIu9/7wqJF/uhZoEbIUM4wDZYtBf7IdvdRk8jcWC8ExGDHKtptONnMiXRMlmCFC3Syi5rnFGZORMHftsycw5F1+Oh3/wTcQGBxCqrke8vxu7nnh4dEyaSAq1okhwa6VdQTCRFaq2mYaBl357r/B/CVbXwYhHYRk6jEQcZpq0LWSqQx5nYYS72oUmJ0ETST7fqMaF9jNe8+LurxvFS5pg2xaMeAypyIi4fyIyQwSiOLQW8VgvwHyQkESxPFUgwHwnX5tCSOz11uEoLkJYWY5rq1bhTQ2Tk5JAYCOWBd+D3qe/J0iMf7BUkI7ZINl3kP4fkrwStt0M0Miy4kXVpz6J7S3F2PPsDpAMSvYw2DpHKmbg8LaB/CQytNC/8w7Ubfk9th9JICX5obEU6ppWn9JmqZ2UePpp7Cutwu3vuhl9iobfORZ6Wrbh5qaxSt6c631+/X5Aj4GR8d/r/x8wdBi2kYGl+ADFL3QyZAaopPogOwY86b6x10sKPJkBWFoRMlnHY0aGgPS5uvosmOIqYNooEJnTBP+GSqSbh+HEDcgW6VsAI8ThMSBM7zxNE2cS5cVkVdqEUcKE0R0jT5vH2oUQOR+Pdy5A5IAqITSSnY4MQ/X5MdLbI8akieQ0P/sETMpMYkxUbGhMWysuhSQxpIYHBWHhtgM9ERNVFgK1gnI5S95gCJlkErLXJwgQQWxv3P7HExQiNdTGSg4NCRIjwE/U7YxHMLgKsdjB0dydk/m2zDWoneOSGC/ANdh2GLuNWvyGX4OujIY/ZGSEQokJKzLkgixJEmovfT+KldWiEkMkZjbVGDqOmL4XkCgw8zBYKgPraBM63/lx7OurR39LFxQ/gywBmQSfOgAqX9B4OaiL9Cft/w898iLUoQ2NQ0QMSme9eJdd0YTkEgetjUtRGfCCRQbRU1yOB7Y+gHV+HNOWPCXQyHTLM0DTG4DW52DrKXDJCzUdhv34F5AOLoEnPQCfSV4ylHnizy5TKiBnPyukl6GKy5obgFd/DsWIgUlpmFoZNCPsZlEV8JpCgcjMg7HdRAt8rj1ELZbU0RHhVK8laKDH/fKMP92RF4Z3x7eTzN6EmJRSEg5sd6JaiIzpsXw4zvkWAO949EGULV8FPTICW8/gwMsvwlNSDi9j0OMxSLKKZGxATBU5ZtbCOAeXw2DFRZeJ7Y2fcHr+Vz+HTJWYUBFS4SFBeMgwbyJiIsmyeJzGtqnSQ6nVNEk11Ug4jVAPDj4Bx1EgScYpj1TPFKRxIaEvZTfJ0nI43IODZhHijGMxetFmlOHBfT9EfUPVMYZ71DYjzZDX6xW3ibycihiX2kq2nIEsNcK2W2H2L8bR0n+C2S9D1mLwV1IVBjDTYyTGG1CwYlMV8ho9O9Bot6JWjsJjdAA7jgLNvwVe/5nZmeL17EDD6+NYuW8Xfp2+AiXVFQg5aVxVvAttHeFjiUzbi9h29CE0ax6sXXH99EnOltthP/klSGYK7NAjwsRPsVNIa3Ww1CLIdgrB6IGsEMgDNF0FXPbx0eMbbRWNb0WVNYkxbFlPQCYSQ7465CtT0Me8plAgMrMkJsc/V4hxx+lcjm+95HQiVsaA96IqoCMFvT0OO8iE14qTsMTodbo5LAjPmXbvpfMh0anlgZg6ogBIh2ITZEC1GZKvDogq00InMxMFRObui4WH4SsphR4JZ1tDKVGFAQ8LzYsY086QIy6HY46lklPFZfXr3oDoYL8Y7c5lJ43ffnSgT5CSRG83ZNUDy06hffeOCdtFpJeRFEVUe3JYsvG8Kce93cmk/0YkchAlJStPu3mca8Dn2lTZDoUZ2ljFRtAOA50og5enUZ/ZjMOH9yCdbsfKc24TzyUSo2nanB1HX/QgHHjAHXI5poHwZYBHgc/LoCccJAeOfX7tsmJc8vam/GwrjUekA9xIgctBZLxV8GYGgLQBPPvVqU3kpsx1CuHS6G58bMcP0Pq69VjMOrBU2Qcp2TpmXkgk5sGP4HM+CynG4O98DF+6+tvTIzMtz0CyUkiFGuGPt4AZCVhqCPGydQiF90I1cjoXDnhLXBKTO4/x5zP+v4m00flu/j7Q+iyxftccr6CPeU2hQGSmcNwll1ryeZHLPCekN48nOiI8MW7A9lO2kI3oH48NSKTnkueLoVDKMIPWmhCGd4T4cBx6LYNvmIvWDXnG0PbOJEGg8+LZUXFZYmCWAy4xKDoD93AkPAdgFLXBeqUTjU03YqHiqZ/+D3Y/QZ4igC9UJNx1CdRC4lT5sG2kI7QAUpXbXVyp5UHEwtKpd+/AEypGJhIWVZOm8y5EsKxcTBNNRTK2/fEB0UpSNA8yqaQwxSNMNOZNIJJFx0fZT+I7PhjEpre6IuCpQAuP378RHo/bvjqdoH3X178bXV13AnDH7Jr4C3gTMzGC9SjHYSxFh8i16Om5F1WV16G4eJOoyNB7PBegxTeZ2Auv3ADu9MG2FiMRO19UX4wkpYMDqleGN6BC1SSsvbIeG65qwIJApEN4rdCYMnNs4XhMLRbYxuyqEVntTZH2Y1z4/Mto3NQMFqwHd0ohmSOIt/+fS2R6dqDZSaLIswxlmT50ZSJoPvzQ1EQmJ+gtWQxGfzPpfpieMvHfnMmo7H5CGCWOouGSmTkV50TChbiC1ywKRGaycemUCYvZIvDQ6U8j+ocWJF/phWdpCZRKH6JPdACGLUagPUuLxFCsRLxHA2QDiD7cNqojEToTGgvkDCr14bNp1wTSy5ARnumjaaaDMIpakTq6DP6WM9diEiPdigRb46JaRN4nltcduU6VHcTg+gdgsx5EnKfg31eJqjVXY6GBRqOpbURRAeTNkhwJi9ZOqLwCjiQLUa4edUkMgYS9tPJtvPatiA8NomXHVnGfmUqKx2kBbli3YbT6MtV+j257Gb7SMjiW23siQy8RiRAITtguymU15XxoTkaUjofw/BFOsKcXVGXR9T4MDj6aDXw0sJzvBZPisJ19WfUOQRKtKJ9vwzGki8TC5O5LoZUzzXsiEtPR8WMozIeorcHr2BjprEW8swnBkIbqpUUIFHtECynvqy8ToekNkA89guDIfpjecpfEECijaLbViMbL4f/E5VgW+heoe36JvguGIcnFUE0bod5O4FxXYLs2lcCjJWl0MQt+Dqw1xvRdJ4DIxe//FkgOuanv3lIomRHEAw3QMsPw6OMT1xmw6m3Au34x6+MvCHxfmygQmckWcg5IGYhoAPIqoKtlPpCG1Z8Wf29EWAR5SVtuhpDMIJkcGQpSZBya7ohWEkEPp8E9EtRoVjSR9VIhjxUiP3RBnvZmCQIGIdlPItBZjfqm06trGP3iaT4E27MccpKBScL9DkqaCYdeqsTYbBCyXg7bO4zIwI68JDI5D5fxrZ3xoMfE71hR4SkpRSYcRvvenahsWo50eBhKrgKjKCitrRdTRasuu3J0W1TNIc8Zb0mZiDVIhwfx/C/vnDQAModdTzwixMNC+GvbCNgM5SMRqA0N2DRB3lIOE5neTQeyLMNxHPHvmYAhFioZirwatpOk7Go4Tic42VRDh6R44NEq4Pevh6IognARCTna8g1Eo5TmncHQ8NNiW9MlM/T63Xs+AttmIH9hle9DnDMcDg7gomtfwIrFV2H5+g1Y0KCWStsLkA/8AVa2oid0JaSROcVpHf9V12PVfb9F9f4BRIszCKRUlEYeBSLvAdLD2Oh48On+DjTLNtY6CjZdM8X3FFVikkMwmAeaNSxiBwxvJbypXjgKTfrRd4wM1F/gjpYv5NDLAs4YCkRmsnHhZcVimkiLUjgihxVko2JXIjHUBrIDEFUKJ0r5Q7RoUIuWnHcZHIcj2T6C5FACzOZQHRnKEjcsb7yXCjn2GjKHHmqDjW7ImVLYvhHoRWcgP6XtRei//gZiiTcIYYxa5IOdIIEpEy63tPCH/GtEJYZIjOR4UVJ1Xl6SmOfv+bnwgqHoARLt5jxiciCTOjqhTDaWoKh+sUij7t23F7KiiJFpArV03vjBj5xAIig2gMkykgO91G8ShIheQ4Leqdx9o/198JdVIN7fI97PoKFjXW8YJW94M2pPIZRyMhCBId3J6SQywkV34CFB9NOZTqGPsR3ysdHgcPpcm1DlNagrfx+8ZQn0GCqe6XgOtf1/REPRUrS2fkfEJ0hsMRzeL8hMf/+DJyUyVMEZ6H9Q7JMmnxirguMchU+iLCk/XlfdC1l6CAPxF1E+Elr4oZPcgSOpYlRZVkNQyNKf9CLHXJTc74qYZ2LZn20zlT7xbyjt3gFDKxF+RPLBP4q/Gdtfi03JXohm0srrp94uVYdsEzJsJEPLoVhxyGYSipWgj4ELxQus/tMCiSlg1igQmUlAZnNGZ0KMS0s2pTyPm0Yht/00ZQ4BwkiSA3YJgxx17fgp9Zkg6RyOYkENeMEzJnzrKhC6YiyTiFpPVMlhDodmnAPJfgK2dwSKFkRp4+m3Tdf3HMJg4hZYZD6VYLANC1KRF8HL64RRmCt8vhyBfbWiEkMkJh+rMVRtoYqHSK+OjWDnYw+hpKb2mMqMQ2VuxkbzjvRYRBjgEWiQbNkFF4sIgMnaONQCInIgnJpVD8xkYtQobzKIYEgGJIdzClOOIsOCXFEhcn/mAzkDvdNJYnbt/hBs230/GIJgrAacuyGS2aPCkmXvRuOSv8T2/u14svnzOFdtQxwZHO5XBdGR5fNg21SRcVc7j+bGMUxFYg4f/rIY02WM2lMKuBMZfZ81TlULDY6ThGG6U1ULnsikhoRVv2zEkPYvQii63yUuRCy23A7+5BcBk6pgDJipZT89742fB+59L9TMEFKhJvgS7aKaouREubJHOPFOiiyR4t5SOJbhxqtAgodITPESCKU1VWMCFQVxbgGnhAKRmQTjx6Uz5PiZWwtoMjD7fZxLfqZqjBbhgtgQRqWKmnsVbA+kIfnUE+IESDvDZAYlzeFRmlC970PQQy0oWbTptH7J5oTLevdykcJN4l768lPLZRTfcM4JWh0iL/lIYHJVD0qTpl+YZWSyZCaCF++96xhDuyNbt0CSFSHizURHxEhzTtBLcpJFq9di09v+bNL9iNiAjeejZdsrsCgT5rj8o4lA5Id0MKTHoZ14vD6svvgNWHTlG+Y17yca3YW+vjugG8Oorn7bjPUmM0FH5x3ZagjFVKbAWBHVtcC5a2RGYZL19e9Fw6K/FM870vMoNmn9UFgJOCf3aBMyq3SN67IkhhK8Gxo+OOk+iagN9D8JidVAkpZRzQDgcbEtoEYcxz7Hj1bWhKU4ivWsJztVlSeYrUh17TvAOl+BNzOYFYxTGzi7vSe+AEMtApM80PQwMJtgSXru6z8D9vSX4Y8dgR5YBIczyJarCxOjz8dvL3cukgL+4reR4TIkLkG1kgjqYSSKVrh8lkjMG7/gpnfP9LwLKOA4FIjMNBxpKa2ZxLm5jKDoo+00Uyommui7Qx6bvBUsRmsIiQgBvZUM0SxAGOBlWc4E0QXMcKBGOTScg0D4HARq6cv3NE9opU1wk4F5GWSdzkuCurRmQY1XE0GhiaNUzBU+Wpk0VL9fjDmT4y6JZakqQu0dMrLzqR63NUR2/rLsCnrBRKr0VB4tOdDkUPf+5tEMJRq7niz/aLxod6aJ2aeCg4e+iJ7ux+BwWnySiMV2ivtPhcxQ1WWypGzToIoU+cdQS4mDc/rjcCtdkhTAuRt/PPqa/v5XUKvvh0mhkmy1qB4xEAkqA8TrqDmlQ5K8x4h/S0ovR33dewURItDrFLUYDu+DY5MmhxZ1HYzRZ9ePDqzDL9nbMQSvSM/+bOkR9705+Hmx7vv9TQAn1T15kFhzkgA+I3fbe28Co2ygnLvtdBd30pOEW4DtP3P9U6hF098MHH4c3NLBVQkeIjEEaZYi4Ox4M3vgw1CSI8h4q7MCbQAX3DyhsJenIyJWgEOGasRFNpSovDBJTCxZahCKmQDangPe9cuZH1MBBRyHApGZBnKZQeNbQlTBIBEwmdildw/BoQmmcR4y8ee7RPoztZyUBAfXTzSRo/8OXbNYOOVCz34p+xRhindaJ7TSJmzHBlcYpDQX2g+qIJ3O45gLEEkx0inIqgq1qFgQGJoMKl2yTHiwHHplC6DIUCQZGUq5zvmVcGDp+RciWFo2o6kgeg4lXs9kmmi2ot3ZgBb+rq5fgLEAJLYUDiezMX1aepPJttfdfY/wfSGSoarFIkV7/KJfVf02RGO7RhNCJaka3BkWnMTnW4lA4Fzoui6qRAcO3QXHTkGWV4AxTVTFXPIzDFmqA+fi0l2Y+rV3/BrhMDkVRzEc3oV0ugurVv7r6H6XLL4JIyNPw3HS4yo1Sdh2HLulTSiSfKhCBIMoQUvKh+Z9X4BBPixONyjRVOyfyIw4Zg3l5VeCOxaYpLiCZSYhFFyFqqrr55bkbP4+TIeDEiTkdBh49J9dN1tqt9zwg5OTmbd+TVRGnC13wEkPQercDFsJQPdXw5fOtjDJtv/qz86+6kGvu+SjUB77VxHWyCGBlSx2CReRFwJVYUZaYVo2dF8d/NEjkCgKQuyffvllQGkj1M4tyPhqXSJz8BHgj//knkMBBZwCCkRmFjg+O4gW/BPM80ggSx40mfFjrydqFYj0EDEikjOdIMa5hmh3UXGJbpDZXQbQlgRF4vZCqsYQqIpCQYvUuqFqDJnWUbr0SPtR1w1XVhCsrEK8rweeQBBWRoenuFSMWadjMbz9Hz47432eTmIyU1D1YkynQs61rleHbWdbAzNAe8edOHLkm2DMC8aWA3wYlsnR1/eU8KrJobrqXbBtFcNDTyEWbwbnAyBDItIhKbICVSUNDHB44FEkTfq9jMDDBsRa54KqKRyMp8BFD4LanBoyGdpWL5hUI8hHT88vUF117SipoH/P3XiHaG1RVShUtB4+bz3C4Riaws/hCZ5GBsXwIo1q3gxT7wDji8CkVWDMBOdUFaoCR0S4EQ8O0ntHFTo3IJUQjW7HwOBjJ5C3U0K4BYoRRyZQD1+iQ2hQqGohMN1WEBEubsPWQjBYOUxPqTvansoGharZKYU5mJJSDz2KjL8Wvkgb8NSXAa/7HeEwCYa3CoptIpA45I77awGgei1Qvd4VG/ftATpfhqGEkC6rQPHIfkiv/I/boipMKxVwCigQmTnAhKGIDgfXGJjpfgkyjzxpheNMhCqOtgdK14sJLbNjBHLSbZWptYEFR2IIRCguuuGdIiNJ8fkhqxrSI2PiW5pGskWMgOuWS+F0is9tWwy0Hp00hHGhgvxXhoafEpM/skQGjO4VsiwHjnleOPwKYrFmBAJrUVQ0RkrGYyS8I0s2SO9CCz+9r1SxSJ9guLe08T3ih9paXV0/zxIBGVXV1yES2YpYbA8GU0mY1lEUK8tdskMfPcagaRUoLj4Pg4OPZV/HhLFeJtODZPKQGCVnrFwQD4ofGE8o6L+PJxiLFwNlnWWQj96Bo3wxVsj9uKb+jWjd/yQs6bAg8SQCFqSFxbOaHlfbxlgQ4H4KGBM6G87jsKzEzIXCU2lgvMWQuAnJMZDx1cCbyZIYEqNPsxW0ufQC7K/uwer+F3BpdBccOJDhCD0KueVq+jDYo//iPvlUCINjiSqL6SsXYY6qPgykLBiBWqCkEZ7wfrCGi4COzS5p9pUA13x+7JyFdkaGZifBjGFhiCdAAuUCkSngFFAgMvMF8l9hJJx1b/ovyI8MpRyJ2b///8EyEmAZFdXJD8NrL4OkMjDP6W1tzTWEnT+NHKdTIlaAQC0mj98vSuLpEUrXAzSvF2YmPfqcyVx1FzKofTQw8EdEo9tEq4exCtEC07Slor1DoBbPoUO3wbIjkGUNa9f8F8rKTlyky8rPw3D4D+KdkkTbhz7Y0pQZTmSI5/MtEZUhr28RRkY2iyBJxkpQxFPYolPEAzBilqNMjqDWV4H1Sz6MDcvef4IZHn1m6fXuNBQTJIOqI9Np9dDr3xVcndX1/KV4vtbFcPjAV2A0UPgnkRhktT1jwm132Guc0B8MihKcmVCYSMx9H3TFtqRjufpzxy7aNeuAzi1um4b2IMYgGXD++6dVjdkcSeBTQx74Kt+MdMnr8K1DX8WlEVcHpYnWUm70wHHDGk+FMFDQ46GHhfleyl8Hr6SKUFIt0QNmxlziQlNM9DMRcaPbqg/eVPex2/VXzP6YCiigQGTmD9ZgGuT5JefiQ8Y5cJ9p0Bc6kRgpXg9LHUDS1wt/eilYUEXoDYvyhnDNtr1EbSNh508fcE3D+qvfLKIIgtX1IpGaUFJdC9uyshNOmNRVd6FjWdPfY+euT7sTQTzqTvLwyGgVpaPzGzDMnqyeRMLA4EMTEhkiAy0t3xBp1o7jimU1rfykJCIUXI1UqgV9fb+HZVEcA4lFQ+BOF87XJPw2YaLfqsbmJJCKxlEZ/Rm+FliDTQ0fOEbHQ/vZuOFHOHr064gn9sGjNcIwB7C3+ROQeRGCkSvAY+ei/LylE5LR46s1NZe+H0XKanS0/RSpqiFUZM0ne3p+hXTaFSoToQiF1rkeC7PVyOy9Hzw1DN1bAY00LI98Btj8Q6B2LRCsdUWwJMRlMjyUlyTe7EunrRvZFUshY+i4wIrgOTmEXcFzcGl8n3iMUVxB7ouHdDJERE4FRIK2/AC+SDucohWwtGIEowddgkbHPFk2Ug5031WfFRNVZIwnQCnWU41wz1XSdo7AFWIMzkoUKjLzBEqNZiaDlL2cs2NT2HifZtAVJZnZWUo7FLYOSqJeHKWTMBF7xDXiOz70cqFgosmg7Q89IEiLG/CIUaO7mQp1FxpoLJls/2tr3yJEuoyRVoKLKgeBqh6k+6BKDYlqXT3KxKCKiIhSGKcZKSoiz/qTV/4yeq9oRzG2SOhd3PlbBapj4Zx4HEdVU7RDaN8JM4Hm4eYJs3uIQCxb9o9im4bZikPOBgzZq1DMt2GV7+cobovh5f/dAvz1u6f1u6SR91XHjb3nqj+TTWXNGFSYdSx4Un1IBRpgK34xLq0ceiwrhqWzZuBiYiuLrO5kOthY5IfXTuGIUoQ6O4ON8Wx69Pk3AeUrgNbn3HgA0qicYvum5/AIBuQPo1z+A+oTW2Fqxa4zL7XBiCxMR8+TC3mcjVHfTLDldjiP/xuYnQI7/NioHonvuMsdVZ+umHoyFAhRXqFAZObLl6UrASeIvAKNkVMsAmkCauUPIWEfhMdcCX/PElghV8+jZByMPHQEUWMAi67KP9femQpwyeWXcpEoFkD1BsCUEXDLQteBZlxw/dvxxlv/FmcjSEtiGIaovNB0j9+/CAP9z0NKJsCfb0NqxVYMsAfB4M9OB7keL1RxmAi0sDNG8QLJUW+XxVN4u+ReY5jDAC8GAxEZC9xJg3Oqljmi66G2xOCs9CDjZIRGJqgGsbZ87aTbJGKxevVX8Zu9P8T/2jdio+xHp3MRZP5jbKw4iqqj155yi3Airc2sQbb7e+8HS4dFQrVk6yIw0VKL4EgKbLVIjCc7ig+27IVCHi3piLtQTmORvTSyC986+BXsL16P1SM7RXq1GMMuXeqShjnSnhCJefInO2DG6+AP3YorpQjqnH1uvgpNWWVbY3mTibT9Z8JPyPKUC40QXvgmrHQMjuyDZmRH0mcTrpmr9Dz7FYi+KJH7smVA42Xu77rgh3NGUCAy8wAxgWRzkaOUg1yUHfU9gyRm5JEWOFTJJqdicymK/U2QM3RNBUhxLlphlsohGwztD24DqtUFXaUg8S4Z4Sm+ABzbhJ6IQKYoAarOGPqC0MTMpjpA50ceK0RixodFJuNHYBldiPq3I/7DJ2C/PyRGs4XYNlthmWwftH9NLRFzPHRFu3TpJ07eVgqth+Po4EhCks6B4xx2vV24e0zKsIIrTQYn46DdZqhsfD2u23Dz1EnKWRy2ayAxHw7ag7BZBdrQiMvCHvi1pfAGKH4iT0AL242/AB76R8iDZPIHd2HNITuh5ElTcGw1dDUErXcn2D03Ao1Xum2XqRbH5vtx6fBWbDDDCMTclh+8JXPulDvQHoeZsVBSnkQ0FsKAdw3qlFbq3QK+0vxy5iUSGD4KxrlICBdNwkQ/LH+tyHgSoHbhTI45F/cQ7wU/9Bh0TwW81ggcpsAZaYcyuA/YP0P35ALmDAUiMy9wS+8UYyCgSmdcQEuGfiKg0gQcBXACDKafQ0kBcqkGO2pAylCkglAcCrv+hbDQTwU6fhL/csuGbRrwBEuQiWZt6x2e95oYIjF7mz8pJmVIZDqdsV+qwhB5GT9JRNshkS1HFZhaBUfux8jlg7DMJHj2G0CWg0JPc7JKyExIVTyxP9uOkoUux/WIybjdFMrtqj8X51/2Cazt2QdP3ZppLwB0DMukDjxm6YigHF4ng43dixEcWAnN70MgGhQ+TsfYIZxJ0Hl99CXXM+Xgw67xna/INa8TimJy1VSh2gk4lgndVw3JTECjbCOaAKL2y2RX+zRVz2SoZDpHKFkCvP2Hc76YVi0JQfUqSBnFIiepqjgMXJWnzrxUaWESbKaKnChxjEyCRFlUOZw3PTG1IDBbvg8cfVp8J9JvK166AbIRgRNsEG01Tyab4E2mhrOt8hRwSigQmXkAkZZ0c1gYzeVM8s70Fyq5EmcOhImjQCazYQ+gpNxUbydlI3BJLZJbe8ENS5T5B9CFi5smd6ldiMJfSx8zSwuUluU9SaPxYsMgMbIMwxg8Ydz4eD0MTSKRT0suIDIXoqgbA7Bt0gcNgcEdvTYaTEiqF9wZFM65NTVvPyk5mWnLpbPzDtcThq2Dww9n781khSMMgZpV4kuf1V0IrtIEzPRARGqD8gt8BHei1V6Ki/sW4ZL2c2H4JfCYg8HDz0IfbIdvzwo0XHfDGf/bGwUJeMeLeMfrLAh774e05154k51iFJsIDU0esV33AEeemFjTUbEChhwAt7MavMSA69cyV4sptVGa70cdY3jDumswZDaiuiSFuvP+IX8XbHo/vSVQE31QI/uRCC6DZoah6e73ABomEVNP8Pugc3cyMVieEqRCDfCluhAa2Ss+vzSCfgxIuJxPlanXEApEZh5zmk4wyTuDyIl3k6/0Qk9kIBl0KQdwD4TrsB3RUXnLBgy+ehhRPYGLz5ueYHKhCH9bdmxDfCh75QSgsnEp8h0ZvT+bV1QpPEziCRJyTq2HybWS3BDFr2dN3XLxGDERqCjqhaSjAJnTkS+LMuUY9WxA+89kBiGxOshyGUwrl5tE+5VEhSmnxyHiRe2wnFneyZCrDi3KVYeuuggj/3cE9ku9iC/twvDiR2GjFZLzBHyd5ajPTiTlHY7XitB/V6wQRnPedJ9Ittb9tdCYA4l0My99d+x5ObQ+ByNYD9gGZMag0mL97FddQe2pEo0tt8N+4kuwSAMDhnLll2ggPdVVed4+yaZ3g0IzO7dAcdKQjeRY0OU1n5t6TJ5czknVRcaCzAsrUCzIZXHGbQnS5d8oqI1ZvhSoXlfQyJxBFIjMPOFMmNxNBWovDFQ8hMTGNmCoEqGu1fAPnAMjwKDpHJlDIyLxe9E7N2Esn3vhIyf8XblvL37/jX+HkUlD8/pETlI+g35fbm6RcE0RX52x2G5BEMaPJU+mh3FdffXsRJKbCO04NJHGhMhWkkrgOF3idlnppXOeLZTbPxnXuQGQrhi0vOwKlJRceEx7KkdkZqIHOr46ZHYnxHnpSiu4YkNOlMD2DiOJgwDylMhMhKw4lz9+GywlCC3VA9NPlv465I6X3IrB6reNLZrhFlFp4DkSQ6Cx67locbQ8A9lKiB/6/Bm+aoB8fE5z+yS1dSvSe5vhW7f2xHDVyaaH6L9vfRS44y1Qe3aBKx4KAgNWvMl9/KG/B2JZvQz92VBmVaIPyeDSUYNCSv2WuA23SZv925LdUXkEK4Fz3lKIV8gTFIjMawC0QOze8xFYFl2R+4EKjnjoadSZH4FirxROE5LFT8iCOpuQy0Ui3Qy1nPK52pQbWxYTP6I5k8o66qbR2vod4c1Ci/hEepjjXX1zQl6gTIQxMqkOTHjBuNUpRSmeMll6tnD3/6Q4dsbqAU77k8W+xhMQOldqQSUS/cjoBybNcDoZKKSVPsj+oSokalOwvXEw24PMgBv0uqAwfBjcNmGrCsxgIyRuIe1fBK/KoIwccUMid94N1JwLRLsAOTAmYiXI2ty0OGikmkaXuQ1H9roaE6ponGzbOWEsEYWi2lOqVITvuguD3/8BlR0hFxej7j/+fYzMkObo1Z+7XjyTjVNXrYHVd0BoZBRQm9YB7n0fkA4Lcka5VETQJCsN5qsR56lmouCSIkiMQOVqYEm2WpaPmqACCkTmtQDSVlhWFJLUKBYKh7eAaz5kilpR0rlStJegu943Zxrb+rYJHxEawZ3O9MrZkos0HlSVMK0IHCckPFfIrE6SlsJxWoTWhVKbq6vfj8WL/3JUD3M8qGpD4Y5dXXeLagjn4dGcJUlkCpFeSEZ19dvmJemZ9t/e/kOh7aG2GMHrrT2BxOza8SE4Ip+ApqfI5yYNwxgQ5GYmx0XVREqbD4ysRNWedyJRGwa3WtBRejfizd24fO0E7YR8hYhrAFQzClhxOJIGn9EpxrbTvlpIZgyKnYHcuRmcErs9pe7ryJjOE3ITtGez0B5f3cima/NtP0MmsAie9IAbGDnZ88e3aBL9rscMEYfx0zyTVVAmMK+jSszgt76BoWAIEW6hVE+hdG8z/JUG8NQXwTu2wPBVieMa1bQcv+1ELxQ7BUemliqDHelDRq2A7VssAjBJg+SLt2bPicOT7jtR93L9NwrEJc9RqMi8BuB2dLloLUii1UBmol4E5JWQHDfWJR9AJOafnvsnYYpGfiJfu/Jrc05m8h20uKfSHXAcyjPqhyxvgG0fBrJkgHMJ6UwCrW1fgqwYU6ZYU0RAVeV1gsiS3iYW2ymIhWg38Q5xder3N014DHNhCEfxBAZ5dnDXTdnjqTnm8eF9f4RtJcCUOoCXQ5LIp2aHeGxo+Gns2v1h4VUznWOgSmLFTWuQ2j0AY4cNJB5HbOVBeNGBVN+d2J1SseHCz2BBYN07wHbfC9mIIxVqQiDeIu5WJQdSZgjxkrVicfYnWoW7rpbodgnM+htnbzBHBOP3fwsYSTjeEljXfxu8fhNQskI4EKt6VFQ1TDUI3rMPsBnw+OfgmAbkXfeBvfnfgYaLwHr2gFkG9MBicElyK0WmDvTsEsUQ/tCnAYuSaQPgb/m6eA3f/nOYL9wO2clAadsMBhnsoluR+uNPMFzsx8GlS5CMhKEyhkpnCCW/+ybsdBR60QpomWFYahBgGnDkGXD+FLi3CPxN/+G2g/qPQA8tFaPYmuyD4gki0PfqsToXgWxCNzkUp8KuVobCLE82/l5AXqBAZF4DcBcrGZJUDcdx2xUlJZtQtfYaRFtbIFnZv+MNlWf0OB9pewQpPYW0k0bGyojbryUiQ/qXlpbviBFlLsraHLa9F5JUKYy3GI1PS6VwnEOjOpSpiMx4LQmRkx07bgF4wI0pyPrBQGQmjYGCHnt67hNp2ZpaIUS1syUzweAqkfNEPjK52+OhtjOwIAMP9EGiDyEnLU9Fdkx7GM8PdaM9/Dtcu4zhTQ3HaSOm0KV1LAqjvft5FCEOOKVgbARHm++FNbQG57/lT5H3oIVz6ZWwjz4DxYiOK3NdDrnlKZSEXxXVBZqkSYSWoTQ96JqzUetjuiPF2coFX3KZ0FjZRE4kP1DeCCneBaVvJ6SmywEai3cyQFavBc3r3tfzKhA5ikxoMdRYO3jfTvAllwiRMZc9kM0EHaGohDBK367Z6E5TmWkgVAMW7wHr2wXWeCnYC/8Fk2vQMkNilJzvvAfOBTdD1bqRXLIYFrcR8vpgeBVEybvFTIvn7S1Zj70siHXxA7iIhPC0z6JFYPFusP4dbpUl2QXN0KEHa6EZEbDUgJsGTi0iaklRey5Q5sZFzJfLcAHzjgKROctBC1h7++3u5IpYHN0xTa+nGqEN9aMeMzSefaZjCQ6NuAu0X/Ij5aRGb79Wfk9Hj34NnNKWQVNKNLHkBWOl4E4ZFHUVbPsVOA6JVwlsNGpgOuhqfRm25UBSqIXTmw1/9B0TgEhEitKqKV3acYZgYGjmSc/jQJNQlGJNQY/kU3P8ZFTlircKY76Ry4dgLnHAZFtkQhHp7pGuxx/49WhzNDzRkkIolMClJdOzyt646WIkfNci1XsnJKkGnIcQ7fDhucfvQNWSpgXRXkRqWOg3tJxHCeUxUXVg6ZViqokZSSHuJRO8dHAx/Il21212/LTScW0cGtF32g752doAAPNxSURBVF6C/ci/wjJ0yPaPwNb8GeRrPwetdg2YkwKGm0W1BHXnHjsBRG0bYgY5vUvfHnAKnU0MgOkxMCIF1OYk8nPFp6A89WWARsJJU/O6T7r3U36lzIBIS3YfG4FX/hdI9EAKLMpGNpgAWQWoKoobQ1jasgUtsWVIUTK640HNinVQt9yJzb6l+H+1fwFF8SFppvCtI9/EpekWINae3XZWx6OFwMw0PMleGL5KeAb3u/crPuCaLxRSt88SFIjMWQ6htzCjYKwITFoK2NRP5vBlWwpEXs40gckhrscFganWqpEyUuhP9ePufXeLykyptxTvX/P+s7ZCQ5oQh658xaQRea+QOy2JfFNgkge2fVSQixwkSROi3+kiE26EY/nBZIoMKKf6BZqaPn0MSaHARLHaCBM70ldaM0t6Pg60bRLtTtamItGmT38T4olt0BQHRdWXwDD7MTT0EA7yANLMgyo+hH6nHM90PItLS6Y/fUSamCf3tSMa2wo9uhzRIwy2lRG5WwuCyHAO1RgZa4GULx8b185lFe26V5ix6f46NyrANkcninjri3Ae+rSotnDP74BrvwQsugBy7x6okaOCLDrMA8+W/waIwJCvCollJ5sAGn+bCNKrPxOmkqKqRyABMuU65UDjyLEeQPMfu53j95EdKR/1eCFccLP776UfxfKOzfCOHEWfUYaat/09Fl39bsAfxa59uxGWvKhN9yPpqcKuko249KK/OFGMK8awvyTGsDNqKRKV9Sgf3Oa2t4Zy3kYFLHQUiMxZDlpAaLKFNBeOsydrUKac0FLIB4S0kDDoC0iuaVtfog/f2PYNWNwSssHnup7DjStvxD9f/M/IB8yVloS2Mxx+QVRfGIrhiIqJ+8UuhLncAOd7IbFV4BgWFRWy/u+fwiDveNQveR1afv9RaGVboGherNpwAxY3XHPMMaRSbSJCgFKyCUVFG05ZCDyViR61sbqM34B5FoM7B5DsO4qysrdClgOosfcgwq9EEatAMU8jNPQjbHn5e6ire9dJ22k5rFz7Kfzmy/9KMdBwLPfznoplnZ3zHeveAal7m/vfNO6bW9zHEwuqjjz1RWCgBWkfRTbQXL0f0HWgtxmyZUDxlkCKtwP9rwLLLgPq1pMzJFTbRDpQBxsy5G0/AdbcML0MJCIx974PPB2Gw1TxPSLiPsMtYIMHRomXqYTgqH4oyUHIj/6L+1oS8R6/DxL3HnkcMmVM0XZWvW2sSpKNd1jUswOLxpOTSz6MjcWbEeix0Cs3IMAcbLzwL4DVl554vPQaX4mYQtKMKDyZfiGaVvUwcOAPx1aZCliwKBCZsxy0iGhaJQxDguOQwJMgndKV9qlOIxEmmkw6p+wc7BjcgaTtaiooEblarUbGzqBULUVLpgX3HLgHi0OL8d4170U+jEjTdBHZ8JeWXjptYerxIDLk6kIi4FkCQ2STsSoR0iixanD0wOH7IUlN4JwmlWwkJjHImwh1K0pxxQ1/hu72SsjmVsgHtiGlF4mqiNvW+rpIqJblRbBtd8KpquqtmC/QPru7fw1ZWgTONYAFwXkCkch2QWTWoQ1/bX8frXwZVrJBLOO9SCaHcPjwl8Q0FgmZTwaqvGy89q3Y8eiD4jaTJKy87EosCOQW8+Mmeca3i5zFl8Jc9U6w6A/gcQxIFFNA1RUax69bS7HbQLzz2FYLLdh154GRUZyZEou6rA+65nHku3Iy9OwAN9PCdZiqH4ZWCUWmqguHLfuhGcOwJQ8Yt+FL9Yy9js5jogDLyc4zh0nI1aWrL8W3ahPYFUuJBPAp244li922lSRBIS2RJCNesga+RDuUrT9222aUh1UgMwsWBSJzloMWDF04xNIor3u15Pc3zsvI7WQE5q59d4lqisMdKJIClaZT4ECTNHxk40dGScl1jdfh90d+Dxs26rQ6UYmh50SsCPpNN1yPKjZbereccSKTG5G2bVmMRw8NPY5w+AUsW/aP064Y5ECkUlGKxEQRXSKSdqWs9C0YDj+c1TTlxuJtYWLnBj3GRMtwJvBVHEay87Ow5QSiRZUYfOZXqNDfgX7pKaQznWK7jk2mecjmI1nzY8w48BCGhp8RGiDH6RZtT3oPCSR0rqy4TqR112a60dNzr2i50XPIC4fGyOk+msaazmf46lv+BiU1tWjfsxNL1p+7MMS+ORyfXp0dbbZtC2awHtJb/tPVttDooaUfG944URsnh2tuA37+pyIFOlp+PjzGsCA2wpdlIuv+8SASpPrgzYZdMkk9cWSZKjJqkYhZIIdigZLF0z/PaYLIy7R0U9wGZ5IQHot0cTEBNiiO0U0bD7t5SgUis2BRIDJnOWjBlSQFtp1L3GWiPH86x6kdyxG6Fy8NwxodSFpJFCvFiBpRfH3b1wXRoWrMxTUXI6AGoDgKhswhGNwQ2r/xoPL5JbWX4EzDrWhJ4HwEElsKh/fDcVKispEzrJuploRaRcQ1S0uvJ60jRiKPwnECcHjPuD9X8n+h1puEdLrtBKffqdDReQeFsoMp9WBSAIlzDyGVvkcER1IMArn92naneC61I+e6apcLwTQMMmYsgSTVi6ksqjy54YmEFMrL34LKyotGR7jpPXUcd4TbPTZpRiJkIi8LisBMAvvpryCpVsBjDcAztAds3/3A274xfW3L+PvPeTNw4CEUDe9Exl8Db6oHjFpMNHI8FanIpXk/8BE4sR7YyjgNDLXAyMuG21DJ68aMjQlrpyIy8w36aHEH3oT72SZ4M4MwtRLESteiaKQZOPSo62UzC0JVwJlHgcic5aDFiMZoaQKFWiB1dTfOuGIwW1D7iDxh0lZaTCKRzsUn+1DCSlCqlEKCJCozg6lBIex9tvNZlKglGLaGXRIDYEXJCjSEGjCSGRHVGKranOlqDIEW0aVLP4EjR74Ch7e6rrmg0ehuHDz0eaw8599Gx56JoFArnrKFJlt86X6y7qfgx1zcAEUHDA3vAmMk+lXF7y4S2Ypk8ggYWwzO28Sk03SIExGe8PBzAKPYABmMLQGkQ3CYAXASbMbBcA5d9ovn+/3L5rxqNyo8h1focEi3JcDp/FyEQqsEp+no+In47NJnlc7vaMs3REQDkXL6PJ/u1ugZQbaNZNeeB7P/EOTevdBkBVpmQPwtjTrTTUfbcjwu+SjQ8hyYERd6kXSwUbRa2OOfm15Ok6WLdo2rbcmSlfPe6+pNCJu/D9ZGnzdZaFTOaJgi+fI03w+ZKi8EGr+WvVAyEWiSB5lAPbzJbuDxbLuyQGYWHApE5ixHLmBvLkSpMwVpYMjYjogMTSMJOBB6lwFzAAk7IQgNiXzjdhwKU7DIuwhd6S7oXBePR/QI/uXif8nLaaUcITx8+Muuey3pWuBHMnkIu/f8LZYu/ThaWr4pJkco9Xlg8LFJrfePD34kAjQS2QoGDQ63hc6JxpcT8X2ixZSLHiAycLLqhBsg+R9CyCtRG4eZsO3doirDeQqy7IPjqLDszaMBk0Sq5kd4LsHhUUisQVSzCHw01NLFkSP/CcvuhSL7Rn1sNl1w75yJqxcE2l6E/YdPwmIeSNKv4dG8YEYYkux1+QvFEORIw2xAROU994rKihJph+noYzlNJ2uzUPXHiEP3ViEVXAw1MwyJpoCItOReN5WL7+lGroo0foScCkh3/zm8JP7VSqB7yuHRh4HH/hVo/p3bfiu0mhYMsrNzBZzNoC/9xYtvPe1f/kQ+yJ2XJo2osuKhHjVTRGuJdC+kgRk0B9GldyFqRWE6JlJWCmErLEgMXXUmzaSo7OQriMwEAsuzBECHJK8g6zdYVkTkIjkO/YlpYrk2zZGssPfk6dVurEQKYJQWzVFUtFH8/qqq35YNsHOJoaKETlqdcAMcScsTgcMHs6LihGjv0LYotoAqPDSSTWBMm/M0bAIdf1nZ69xz5l3iGAT4WNilZUZhmL2AU4V0ahCdRx4/45/j0w0ivpme/SD+qyky1GQPGGUJSQpkyjui6SSaYjrVhZZe//Yfiu16yFQvFzqaGBvznxDUPjJSYI4JRY8IwbDo31DuEZGX8du/7GP5QQjoGKgNl4sboB/ykVF8UI0IZDstND2cbM5JL3TPjceeSwF5jQKRKWDeycxnL/ks7r/hfvzd+X8n2kPUNiKSsqJ4Bc6rOg/Li5ejSCtCzI6hPdOOkBwaTX0mzUxu0ilfkdMcUbuEKh2SRMcvwbZIP0BEJNc6OVF3MhGJIcQTB7KiXlfQSyQoR5xWrPgciorOR2XFtdiw/ocnT4oWxnkk3HUrHyQmXrToAygtuQAStfxYABAVHlfc6/ctmTeyQJNdikLZQHyUNHGQloLOnUFRi4Wey+aSyIM6suMxdO3biwUP0l/88l3uv8eDFsyXvger5UVkMhnxmfDWrYbGTOGAK6aOyAzvTf/uJi6/+T/nLnWZFvRNt4qAREb+QVRVIYfbqUBeLbIqdDCaGYWayQWTcrcCs1BALaT3/RZYeT0UxxCePMnilUIYDD3uevUUsCBQaC0VcNqQ07bQ1BEJdsdrXcj47qtbvypIToiFxLTS6+pfh5vW3JSXbaXj4fXWwTCGhL+L4/RDEmPFepY8uFqQ+vp3H0MQ6Mrbsix4vUR2jkUmQ9MeStbp1q1U5EBkZiY6p9xzB/ofhKqVj46Jh8OvIBbfB8sagiNCJUmXxFBX/+55C/Sk/W5Y/4NR3RAZM5LzdM79V1VLhTBTkupgs8MINXajq+2RhWFiNxm23A7nsdvAGYN86BHhuTJKRKiF9OCnYXIFCrsb3rf911jF4HgRby7Ica5Bx0Ii38lGoI8HHY+vDCzRB8VMwNGKIBkx1334TGphZoPc+/rHfwJ75X8QiJIXDoHluHYBCwAFIlPAaQWRl4nEunTfK32v4Pnu51GilaDhcAyXHR3CmhAHjs0azCu4+pMvu+KfUVCLhmdrSjI4mY7JPsRje4QJnM9bD79/PUKhjaISczxIC0IJ0IzVgXMq83NRqTgVTER+vEcZlBEFdqgIHK5RXHHxBSc8T2RAdf0K7dFe9NgOXjhSClz8jVMiM+MJHYl5c9oXaqnRGmJZu0VLjskZIPAqFjT23g/J0ZEKLIYv2QFGtvz0W33LV2H0NIPZDrweGQi3AhSqeMEtE5vHzSdmMgJNx0QGeq/8Dyw1BN1TiSJjL+Arz4820myQJZZs+0/d2xQgebLKVAF5gwKRKSBvQNWXPUN7UNzSh5sfA/zxHWh97h+w9Kv/JYzb8hGu/oTM64rAWNCdwBFZRW6mC4X70Wgz0IhY/CCisVchSxXQtFqsXv0v8HhObOG4OhpyY24bt9gfG7h4qkht3Yoj3/4Y0u+OQ8KiLO9io/vJTVuR6V40uhNgxWjwlKPOacMqJ43DvX+cs0rZ8cSmq5uiEgZcV2PEoHiOm8FfaAi6ifOKHkXKvwi+TD/49jthdu6Apmoi0RqRqBhbdoaPQhrvhJuviHQIXxbZiMJn67AoWTraBvzkzQtXKEtkhghaPgiUC5gRChqZAvIGtDBes/gaLOnSESitxUiRBCuZQHpv/op9c/oTqpwQ8aBkacc5kn2UZUW2g3AcyrcJQZLIc8aBabVPKPwlUGVCFRWYrG5EKRGj23MJek/1iiSYXA7G6kXqtGQHxX6oavTqjvcJ591YrC3r85IcJVZexrFYG1+BmjsQoVm0iCp2DhijtpycFTgvYNCos+yBZkVhe4oRK16NeMla8EgHzP59sIy0SDunRGeTfu8U7vrEF4BfvSd/BadNb4DkWFDsjBDLWp4ytxNDQtn7Ppi/x30y5JNAuYBpo1CRKSCv8ObGN+OnS55ApjWB0jgHD2jwrctfsW+uDUOhj5lMNyRWAjs7VhwIrBDC2cEhmryhqgJlJrnTQ0DJpNNGOYM8arPQ4kATRKea5ZTblt/fhHSqBeayARiZIkBj4LwbnA+jRLsSkegRdHdvhyyth8PbxP1jwlx3ex61BGvq5i++gOIHyAivv/95eDRlRuGYeQlaFK/9IpzHPy/yfigtWrNigqbaTBGZRGlfFTLeKmHUltSK4En3QznwENC+OT/t83PVos0/AKLtUIQXzVL4E61AJjIaXllAAacDBSJTQN5VZQ6+9a/wc+cHWDZcha5K4JYGhnyW+9JCa5qRbDZSeIyQlFwkKhzhkc1wHCIDLomRJK8w05uKnEwVtjg7N11Xa+P+BCFJQTgryQSPKj9JgHHYgTiGhn5HfQM4wmnXB8AVGStKMTyeGuEvc6rEarrvaVfnr5FKDWMk8hHxfp0uI8c5AU0nUSI04YKbYZz/QXBo8DzxL2AUJ5CFzC3IZEpnxCCbSWFOJwiOnBWAG4n8JQU5Xc0db4bSsQUKkRiCvABFvwUsaBSITAF5B/KXObxEgb5qEQ7FD6Gu7dG8nlyiFhEFLnLu5s/kRpxzTr6Njf+Ijo474DhDwrvldC7Ko266Ilmbog0ykKSVsB0aaSY9j390OIPM6ghuxYgmmGh6qIrqOLCsDhE66vMtFtUn0s/MJ6Fxs6wo5Zv0Ri3CWHCm0Q9ndkrp87DJtI5IyQvfgwoJ8iV/DdSsdIlJpAPo3Qn4K4ClVwJbfgAt2uW21OiL2c6O7GvB/CcFV9/mtpOoEkOTS1d9Nj+JVwFnLV7zROb73/8+vv71r6Ovrw8bN27Ed7/7XVx00QL4sjyLQeO9MpPRmegU48kPtz4sWk75Smbc0MfibOgjFySGwiNp0TVNE/V1N6K46Jwz40rLaITbBGPk4EPVFRm2c3TUVXcszEpFMnkUgcCy7H20CCfEKDlNTzFWLoo54fAhEcNAuqDe3t/A610sxsrnmpjR+0S6EXBVfE3ReDbFFJDDb96j5RkwJwPTXwWHqQjEW8BangKIyEw2iVSzHixHBsjPJVgL1K5z9TX5Tgro+N55R0EkW8AZA+N8NK3tjIJK7809MYRTBsr8GtbWFUGSxgzC5gP33nsv3v/+9+P222/HxRdfjG9961v4zW9+g4MHD6Kqiq5EC5hr9BwewUB7HFVLQqhbQcZoE+MTT30CL3S9gCq1Ct1GtzDN+9dL/jVvycx4HUquUkEkhqBSAuQZAmUWHTn69SyZcY36ciZ7Y6D7ZQAx4VKcTB4e9xj9DTpigsgRpnkhMOZzzfqcWNad1xAmfXNNZnbt/jCGh3dmW3Lkq8PmZT9zgnF2/FbfPljPf1tkIkm27jrxkondyaaQ8sXSv4ACFhjygsi8dGQIP3z2KI4OJGDaHKrMsKwqiI+8fhkuW+6OLs4HiLxceOGF+N73viduk6NmQ0MDPv7xj+Mzn/nMvO33tUJYDm9zHT9XbKoSpIXue/LO/UjHTaHBWHt5Ha64kYIKT8S/b/l33HvwXpSr5Rg2h4UjcLFWjG9d9a3TTmamS77GIx9IDJErqmJEo9vciooQG8fFY4xGxiUVjkMtJC70PZTfVFFxDWKxXbCsBBQliOLi8zA4+GiW6BybiUTZTe72HBQXnY9Nm34z58e/Y+dfi7Rv1xjQQUX51di40fVhmXPMlkjQ637/t3BMHUaoAfK1X4A6sOcYjUxej1IXUMACh5IPJOZffrcHCd1CqV+DJkswbAf7e+Pi/v/4s/XzQmbIFn779u3453/+59H7JEnCG9/4RmzeTOF5BZzKwv/oj5th6CasDMe+F7pR1ViMikVBJKMGFC+HmeDY/TRpAoDiKh8694fRsLpMPIdIw6XBa/AH5Q/i8cWexaIqEzWi+Par38Ynz//kaSMzOfIVN4dgawlc9uYNuOB16xYEiXFFvuGsyzAFTQ6L8MnKyjePZimR1qW//0FwrkGWK4TrL2F8G4zGsXt67s1OXJmjVZrxlR1yDJ5r0L7r69+Bnu5HwcU4tpwdd58HEBmh1o4RB7SQ2yqZLpnp2QETKpyyJfAM7wfr2+GO8BbISwEFnP1EhtpJVIkhElNT5B3NmvFKMmqKJPTFdPH4JU3lc95mGhoaEhbx1dXVx9xPtw8cODCn+3qtgYiImbFhGxz+MgYzA/QdjWKgLQrKZKMff7mEdNhxyQxzq+/te4eh+RTxu1Y9MjatvBJ7pVdgwxYCYMLuwd34p+f+CbeuuxVtMfJt4biu8bp5Izbb9+zDYLobVmUX0qkUHny6BVutF7Bp1Saxz+Nt+/OBxOSIiGVFBYkhnYsr3gV83gasWvlvx5AFIjV9fU+DSakJJ6ZoHLqq8jrX94YpALeQznSjp+fXgtjIcmiUAM01aN+athyx6DOCxMxbW2nv/eICSjPTAP1QUvI0iAwVtPXq86HKd0Ed3ufmIuW7OLeAAs4ynFEiQ5oYaidRJWZ8YB6Bbpf4VfE4PW/9olOzaC/g9IFaMLLCYOpAKsyh+oFgNYOZBGiQwzZpLeTwljBQZ4PCdBndnyZC46Coyo94NAU+rMFX7YOP+aAxDcVKMeJ2HIPpQXxz+zfFImJzG091PCVStueazBBJuWvwRzjfd7kI1AsGizCc7sfjux/H3X1348MbPoyf7v0p4mZchFt+7fKvYWPVxjNOYghUTWFMhW2PuQMTJjKXiyf2Y2DwcThOLwYHHxMeNscLkicaB8+Rm/kWMC9ylkBKngu5mFLG5wnxXuHCLIS22duTjlVTJlHJYlglTbAlDzxOEmzTLW6YYkHfUkABry0iQ8Je0sRQO2kieGQJUYeL5801KioqIMsy+vvHRmYJdLumJo/DfRYIbJtD8TPIsvv9nuifXIoVqJaQ7HcXEEVjiPXpiDpxdNceRcbJYMQawbmhc9GZ7hS3CRIkBJUghswh0XKiqshcExnaZntwP5wyE6sSy6EyGaHyIDKeDMowjJ62b+Banw+bnQQGDQX37foRmkn7U38ZNp17M84kiFg0NX1ajC074j2TJpwuohYUPYfzcnDuF5NX1G6aDjGZK6+bKdH2IpQ/fBQZuQi+rf/jBinOlxCWO3AgU275hLoZ3rcH5jP/5RLo7n1QnRQ8mbDrm+ItmVk7arYoCIILKCC/iAxNJ5Gwl0q61E46HrrtQJWYeN5cQ9M0XHDBBXjyySfx9re/fVTsS7c/9rGPzfn+XksgkS+1lrQAgx4fR2AYoKiSa8tmczhEYgM0ceoI+wnHhNDIaMt13N97FwaCbVjrXYsOvQNbY1vhlbyo1qqhMhUJOyFIDIFuU2tnrkHbpErLwfLdGPb3oNQoRUSJoLGU4U9LAggyKiGpOMer4r6IgycGX8aLDkewfzO+ROZ+Z5jMEGkZH8g4EemgxxyHPHC6hHiXML+zgjNEzw6MeFLoXdQEOdGD6q4/oHSuyQJVWdpfgmKmYWshSEaEhuhhtbwoUqthpoDd94PJGhxJhWzGAEeGmh6EwyTYkgY10T/tdtSpHCd/+j/AaBLqdBGnAgpYADijRIZGrGk6iYS9pIkZ316iq55IysTq2pB43nzg05/+ND7wgQ9g06ZNwjuGxq+TySRuueWWednfawoMMJJZa3uZoXF9ORatLBXkhVpPRHaan+8Bd7ggMKKiz4AVF1ZjR9VT6EkegQIFnXqnICykhUk7aWSMDNYG1kJ3xtxRb1h+w7xoZGib1LJ6tO1RHAwfxEBqAIPJQaxlJO1kgLQUMiuBlx9EmRRBsVqLIWMISXD8+/470BB+FdX+6jPqgXOyqkku14kqMTTJJCvFc57rdCoYKfVhzzINttwO+EswaD+OdSPvmLtK0JbbYT/xRZhqCEagApa30vV9UQOQ+3ZBjbcDoTogclSUFk3I0P11UA1X6OzIPjCHPrwcSEzSjpoF2tra0NPTg7q6OjQ2NrqVmCe+AEMtgkePUokTaJ5n4lRAAQsEZ5TIkKiTRqxpOomEvaSJoXYSVWKIxAQ9snh8vvxkbrzxRgwODuK2224ThnjnnnsuHnnkkRMEwAXMDDRu3bJzEHrKgiQzXHJDEzZc1XDC8w6+3AczPVbGr2kqFs976OUemI6JBm+DqMZQwV+RFKwvX4/94f1oTjZjlW+VIDdEcl7pe0XoWeaLzNDP3fvuxm8O/wYyZPSYChxWBVn4slTA4C3wKJsQNGNwVAcBOYhucwBHOp8W23jgyAP41PmfwnvXUBhifoEIwZIlH0Z39z2wbRmK4gjNTL446PZLHXDUMoAbwnnY4hFRRZqT42t7EXz7z2ApflFZYZKM0oGX3IoUJTmbcUBPAOlmtGIRep0y1KIfNUpydBMW5SKl5o7AELZs2YKnnnpKVIi9Xi/e+c53orH5fgwHLIxUlqN8cBilUTILRP6j0Aor4DXpI+Nw0U46HT4yBZxZ75XdT3diy+9b4NgOPH4Vb/6rtegJHcXHnvwYPPQ/yYOwGYbOdVzVcBW+c/V3BKH46tavwif5UCwXw2EOho1hlPpKcfXiq2c9wURE6JG2R8DATqig/OfL/4l7Dtwj2lrFajFkLsNyDuDiQBECSh0ei+xBq66gTqvDsDUsqkV+2S9aYYwzcZ9f9eN7V38v7wz9SCOza/eHYNsGJEZj2n3gyGDFis/mhfHcwYOfR3fPI9nwSg8UqRgblCtRuuhPZu71Ms4jxm55EeZjt4GlwlATnZCovTa+rab6YXMGSw2gi9fgac+bkDEdKFzHNcp2LLZawSn92dGhmGQKyIALbwWu/8YpV2J++ctfiolK0vCRTcTKlStxnfND7C+Lw2IpKLaO1UcyKL3ht/lVkTmetFDL7qkvuz3jQiusgLPZR4ZAZIVGrE+3s28B8wciLyczj6PqS843Jkd4Hm9uhu3Y8CgeYYQn0Vw2p2XC/SxQVYNaPTsGd4hWZMpOCYLRn+7Hrw/+Grs77sO7l16GNyy/edpX7URiaKQ7monC5KYgNP/9hv92x6t7t+Gp1qew3LccSSeJg8mDo2LjQYuhTNXRopO+iwtRMlWSqFKUtJPih46bbluONS+C5FMF5SbZdJysBhzusZNHzEj4xbwgMrqIffBkKUYGql4M7P8NsP3h6Qt/swsqd2yYRUvAr/8mpP498MTbwahtlKKRcltMpgkoPtHrlCwTHiuJfixC1Egg4MQQRxCDMkdVSQ2C0UOQrbT7Gl8psPYdp3y+1E6iSgxdX9L0GxGZliOH0V43BFtdDk9qH3SNId64eu61QnPpw/O6vwOe/IIgZDSWKM+lhoj2RduijwS95/n0PhTw2iUyBCIthRHr1x6OJzwiZ0mS0Wtky/XZemGlv3L0OZ84/xP4yBMfEUSBMGAMoMHTgEUax7XBQbDIY9i5dyfOXfetaZEZIi7DmWEUyUWimhLRI7h9x+34/tXfx6HhQ0g5KfTpZJF/LOh+2XJF6kRY6HYORMDof+R/Q48VaUXzIkg+VegGVTpY1jmXHH5LwLk+f8ZzM0BH550YHHwCsrxKeE5x3oOMmsLuZT5sOJpA6VSp0LnqgKTAeeYryGhU2XXgjRyFtP+3wLp3uJ4v8R4gVA1c/BFg+LD7eatYAbzw32C0+NJnFP2i8kIkRoOJOrsL3pTlkhjyE1h+LXDp3GQikSaG2kmJREKQADLpNG0bPYlGlJgd0DUbig2Eznkf8grN90M3bXiMFEA/m38AbqaRLj4Hgegh9zlzcV1K7cB7bwJLZ1Pm9z9YED0XkD9EpoACCFSx+Ph5H8e3Xv0WMrY7ak3RBNQyGv8c0pz8cPcPYdomMlYG3Xo3XhdcA5kdwYgNKEYY+3r+iMtPQmSoGvNQy0NwuIOYFcOG4AYM6APYP7wf9x25DysrVqLIUyQICVVViIysLl+NXx34lai+OLIDj+wRRMWwDaTttJiionNYWbZSVI/m27TvVFBd/TbEYpRn5BoOkvOvolQIzcxQy8Mo716NyhVvhf/CC087iTly5D/A4IPjkBcOVWg3wLH3wFEr0F9uonQy47lsZIBtWbDUIJjsg6oPQ6VpI+G+mA06pIrOZJEENetdMW2sF40kKE/F0YNK1AVkNLanoKslpDACXv+ZOXXwJWEvaWIeeughod/z+zxIpy0wqwErD25DMsAQ8q9E6epbkVeI9ULiJmzZA5n+bmOdML0V8MY7Xf5CVa45qFhRJSYNHxStCBoJrilkcypCW8BrAgUiU0DegdpHJyMBuedQu+bJjiexY2AHdqeO4hxPJUqVOJJ2Cj9vfgDPJTz454vHYiiOB+2DErbPC54nRrpb062I2RSGyLGlbwveu/a9+NLlXzrGvZewOLQYW3u3oiHYgIpgxWi15fjn5SN5GY9c+2io5SHIYQkjJf3QdYqO0JDiRxEp3ob4D59AE7552sgM6XaOHPmqiESQpSbYTrOopgA07u4qWdjS1x+7eGUrMLz2PFi9e2BLfsgl5dAGd7sto5yOZXwLaLIk6gkea8z+CGxpBDpeBRafPy8xBERmrr/+etz3yzuFp02RrGOlsRvluo7yCGlxTi+pnBbIWsGIwfBVQE5nKGZUePJoThrCW+GNX5gbstG+GTJMl8SI/Upz4qQ8UTZcAQsHBSJTQF4iNy00necQcfj4Ux/H3nQCKcfGOZ4gUliK/ekWHDhwjyAdx08MkQaBCIwPPnhlL3YldonpqPGtoUtqL5n0WGh771r5LrEdRRn7M8p34nI8wnfdBfPXv4WvqwvhD8lA6VIwyjWCj2bCwL0jSCwfQXpv82kjMh2dd4BzCZK0DLbTQspbQWI4d/UoFHZZueyvxl7Q9iKc338cFlPBPQ9A2XijMKtDeNAlLuPbRtRSOpUFlQjTyz8EJD/Q+7JbuZnrakDbi2js2YF3NqXRc3gHykpL0TS0z33ME5ybysZcp20LHZsDW/aLm7Hy81A0vMN9rP6CuSF8W26HM3wYjm/cVGnTVad87ERi/nj7HuhJSxAymrikwYMCmVk4KBCZAhY8iDx89+rviupKf6ofT3W/CAV9qNFqxNTTfYfuEzqYMm8Zblp9E9aXrRevIwJyZeOVeLDjQaicnGGYqLAEtICoAp1sXHpH3w7sG9mHNRVrFhyByZGY/v/8Chy/H5n1QWSWxiFx8pMBHJ5d+GmBUlT41p0+fY8pdDtpOM5hujXuEQmy7MfSomsQPLATvNaEtegiOD37hDGh5vGBxdoA8hiaqm10KujZAYtLsIMNMKNHoZLodC6Fp9m2GE9H0GimsBgSjASN+WfbM1d9du4Es/e+DzASgBYEbvzFybfb9iK6tj6JvnQINZuuxaI148JTQ7WiLCNZSejeSvjiRyFl89FQM3XI6rTR8owwH5RpLF6AAalh4KG/P6X3nioxDreheJkIuSXbCBpAKBCZhYMCkSngrMD4qkluXDplpFCuliORTqA73i0iDf5t+N/w+dd9HptqNx1jend8S2gyPc3P9/0cnbFOhDwhDCeGxeg3jVbPR9bTfCP50mayswb3eODU2ACLwXFikKTKUS2JYgew5Iq/O60aGcqDigrdTs70UIGiFKOm+npUOYtR+th3kNDKwXczKG/+ItS6NQAnXcbwWGjjVG2j2aLtRdiRTjiyF/6hV2GpRdBbXoQcbYdCQWFEaKZDCKYCka90BCYUIRZ31CA0I0KuksD575+7VtaTX0SaeamBCJmEs5u/P/VxE4n56d/isc5F0HUb6ubtuO7jnxkjM1Tp2n0vPJlBpIpWIBA7nJ3mKptVBYnai/H2/0OopxOlvAIoXyHIneGvhmQmES9ehUDsCFjnFvDu7ZC2/wzYdCvw1q/NeF9D3QnxWbf0rIEnc/PiClg4KBCZAs46kCaG2klberegeagZIRaCX/KjJdMiKjTN4eZRIjPdNhaRGPK3SVpjZmiVaqXwlKEQy3949h/wofUfykvTu8kQuOxSJJ55BvLwMNR9DqRLAKeYqjERMb0kSSaWrvg0ahref0Z0OzQC7vUtgs9bPxax8NL34FgGtKAfWvgA0LsDuOxj81eByWHL7bCe/pqIMPBYMbE4K2TuvOOXiBevQDB2GHJ6BHji34A3fn72x0DHzyRo6SGxWKtmFJzJ4I4Jtuc3wJobTr01tvn7cLpfBfOUQcoK6pFy4z4mxd770TdiwVH9CFqDSKTi6Gs5PEZk6Jg23gjsuBuqnXKTYOsumNV7QSRm/55PwkpHofAUVh+KozguwwjUwZfoBOM2LCsFUyuG4a2CYsbgS3UDr/wvUNY0I7In/K7aYvAWU6itS2QqFk/ufVVAfmLitMYCCljgIELxgdUfEMZ6pVICazwjaPLYkJk8qzFoak1RnAKRl3pPvaj0rPStFP96mRfhTBhf2/o1vP+P78eXt3xZEJ98R9lNN6H0fe8F0zR42j2o+F0lgvI5wkFXVZcKwe9A/4M4cPDzYnE53WRm48b/xcpzbsPixbeOjdHXnQczUAc1fHCs+kKgxZIIzXyQGNLgPPFFJIOLoMXbACIshPIVYFYasq3Dln3QfVXgfbtFa0gQhuxriXyN3j4Z6Phf//+EQNafaEey6ByhOxGTP9QGIrJ2il4v1tFnkPHXQkv3j01E15479WvjvajxxqAyBwlLg8os1DStOPY55SuES7JMQZqYvR6JKjFWZhge0wNbW4FIUSlMTyk88TbRriJnJppA8+jDCEX3QzGisJSA2welZPIZtpWYxGEbY76wFfVBzBZEjHY+0SH+LeD0oVCRKeCshGmaOBQ+BD+68ZYiFTJL4FyfjW3Oilm1gHI+MeO9YsJqWPjLVGlVyPCMaDORUd/OwZ14quOpBdFuqvnXf0XRm94kxLykg+ksfhjJ7iEYxl5IUimisWbR5hkcfAzr1n77jEcX8CWXAdd+Caz/1fmrvhwf1Pj8N2F4yuBJDWQXfqFsFQJiW/FD1cPQ9GERKJmpWA9vvA2MKjPUo+hvJpMsV3Q8XQM/qii0PQd28FEEI83QjCwxIC3LTCd0yAyQFvemN7gx9OkwdG+NGEvXFL/QtIjqScniqbcTqsUifxyv97dhSE2jJmRjkT87OZRD63OwZS9UbgJMc/c3E5JF4+7xXoSGN0NpBHRFh8qLEEpZ8KQHx3RC9L7StsmU3jGhWomxCSY6zxkgGdGFNobMhwmSwsTU0lQgR/LO/WE0rC4bjV5xCUwnug6OiMPzBlRc84HVhcrOacJrmsg899xz+PrXv47t27ejt7cXv/vd70aTsAtYOKDqR07jckH1BcINlYzEzqk4B40eQGFpjNg2SmSOVX7frPZBsQU05k2VF5pUWupdii69C2meFnlQlMFUqVWKCk17ph1D6SF89oXPCiO/6QiHzyRI/0I/VHXp3nkPmIgqSMFx+iFJTXCcDmSMIext+ymuOMNEhgiquvQSYNll87+zP/4TnK0/RsZXC8WKjU7kCL0K6T6e/KKoQLgRBRAxB97wASF2Vbu3w9aKIXEGxci2IyfyO5lscuiSj8Lp2QslSS0fBlSuAa7/+syIG5GwRz8LRsTi8GPAyreCUxQFt1A8QiPtWfgrTk6QyCSQCje+OBrL+11CMf58aF8HHwEP1AF6zNXG5LaZO8dIh/tDZIOmvXIiaXo/d/4SluPAUXxQPRVY3h5Hws9QFHkBFZFs+8sTcsXO9Nrce9a3ByB9DG3n/JtnrCE66OM4tNiDon4Li9MWlqwrn5J8PH/vITS/2AXbANr3hsdidn53FJJMpo0Qj2VgFgTDr0kiQwmyfbtcFbq/HKjZ6F7JzCMo6Xrjxo344Ac/iHe8Y45GGgs4reRFYQp+svcnSJpJhNQQvnLpV3B+/fmCyFA1pKXxRhgDP0OpTPMvCtbWvXVW+8uJgu9svhMvdL/gGujZZLAGBJQAvIoXfZk+Yap3/lAJ6vq96K+V8FzJLuwa3IVH2x9FiafkjKdhnyyuAPDCcbpH73OcVgCLAN6N+PATeLH5S7h87efOyPGdkAg9bztydST80CNIlK6FP3oIitCSZCsQi7LC554dMIrPgULtJso+lT1gNevh6d2J4dor4YscRECnCSzyGzTcysdktv7U5a9e4xKk7GJsQ4FKImKqAKWz25kJ9t4PS/YALADVjABHnoDhrYCWGR6rYJzzlum5ElMFRPHCUkLQ0A9mZY49HyIlsGFqRfARbwtWu9vMnSMJim1DVLDkQ4+Ibdmcg0sabGoLyQEY/jL4Y0cQzAyBmjvH1EUaLgWu+dzYcY7/d5YC6D/s7cWPKixU1nkwsMSDd+zO4M+uOTHcdnwlZs9z3VB9TLSiqNXc/Fw3ooNpaCEGPcFHKztMYgXB8GuOyLQ8KyzBMXTYDRgjAyW6AqC8jqbXz9tu3/KWt4ifswFThR6ebaDgyO/u+K6IE6AvEwpopCoJtzl+cfgX2NQwdu5/ee6/YsvRBnQPv4SG8stwybLZC1dz7ym913HHHQGl9/tPlv2JeM8/9tTHsPhoAjdu1uDpG4JeVwXzqkrsrEpg58BOaJIGwzHwh6N/wIrSFXlVqaFqTHhksyAygEvQCKZUBGb3Q5ZqoTrdSA7ci5G6N5/2FhORmAcffFB4/1DG1g033DA/ZCY3lpwOw/RVIRA97DrVIls58BYD19zmtkFsXbQ8RseBl79RkAJ219tRNLwLnEnQfdWuFoUuysh/ZrzvzN774aQjwrVHtpNwenZB7spqq4YOw6IOllYMzRiZnYNtoEK0XTK+GsiWBGYb0ENNUHNmchUrgXf/cnrbouqHpEAloXNOWUPePOP2RfdqerZKQaJbAr1PyQHonjJAcSDZJixvhXgvLcUHb3oQWrpXvFY2oqI1JTuGS+xIA1W1xtXazIPx4HNHh0VuVaXuoEuRkFgenLQaQ60jCrglUukQac0iMpyGFmDIxByK6xptT130tqWFttJrSuxLJObBT7m9ZPrgEpOnf+k23U+PFzCt0EMKTfzVwV/hbx7/G3zyqU8uCMHpTEHn9N2d34Wf+WkoFzZsERpZppSJzKUXe1484byJvPz5RbefEokZT2Y+ee4nYTFLRBNU+CpGiePHz/04VvbL8GRsDIcAT88ASlv6hMB4fXC9EAWLQEkrKXQ0X9/2dUHK8gHx+B4h8uU8J1KUsWjRB1DS8CmY3AJ3BsFYBWSu4+DB2067+JcqMQTKIaLWYe72nIPGkNNhjJRvgu0AMlVEiMCs+hPg2i+OjVf374XDFHHhJZZ1ylzKVTZCtWCOAdlMCP2MHmiAU77SFQm/9N0x4S9NPdk6LK0EplZKSVcivDLXKlGslEtiCHRxN1N9DB2P7IEnPSCme3R/DUIj+0QLTOzggpunvy06r6YrRZgmETQhBOHH7svxlkOmbVNoZPEi4CdvAg49Li4ydF+NIHVc8Qo9kSfdh0C8DbJFgaWyqA7RCDv5AQvQ699zL/BXj80LiSE0mRI0i6NHY+LfVTIZL04uCjYzNvxlEvFXAcXDoGhAJjpGYhRNwuV/vnxUO1PAa6EiQ+0kqsToCddQif44CKpPlB5J+CUeb7xi3ttMC7kKs71/u9BkLPIuQr/eLzKAnup8CnuG9uDWdbeKnKCTeaQsFFA7iTKPok4UPsmHi4ovwr7UPkSsiHic3HnnM2Wa3nNKJ/7wxg+f8L7+f/beA76uuzwff845d1/tLVny3o7txJlOQgZJgECoCStlhFBCgf4oLeXXf2koP1oolJTSQkspBMoMKyFkkD3tTM94b9naW7qS7l5n/D/Pe3VkSZZs2daydZ9wudYd55x7dXW/z3nf532ej6z8CH54+VYkd7yAkrSChMtC6xwPwkYYbck2ObblvuUiCmZFJ2Em5Pc3E6oyHG92OpgfRKhYsOCvBsegX080Itr5K2hKEoqyANFYLXbtvguLF//9lCVkV1ZWQtM0hMNhuFwuaS9NOCiMPfoM4v5qOGVqZoBELH0H8Ke/OvE4EpH2vTJJw0VZULXuRLWk4iI4Dj8tn0Z+o7mTPUglfHCYFrSmzUD3oYzwd9WA90q8E5H8pXDH2gASp54jsDyFUOjim/YAXGDPxgiPj19yM5TDT8IiRbAyWeyCuevPnCDMvw6o25IhQVy5Dz+e0aiwYlKxGmlvKSyu8pYH5r4/wlCdUM0UFF8F3JFm6J5SIXcSGUFituRtQF6lTDtRKIwjT2f0RiQ2ExTCeSpcZDiwvjaBrkonlrSlcc26U4t8CdPI6GC8xQpULdNispFb7MHNH88KfGcfkaEmhu0kKvptEmODP/N23s/HTUCexoVYhYmn4tKuYFAhAwtztVzRjXSmO9Eb78W3d3wbLs0lrrbMDDrfyQyJAwMaQ8mQRAvUxesQ1INCKuyAyYlOmeZ7TdfgI71HZBKKBIr6mPcvfT/uWjV8Ib/s7R/Dz7r3obw5gs6aHLzjnZ9E7e7voSed8ek4GjuKcmc5crQcITLcJrc/3b8XtopWrPhXqcwMerYMgJqY7fG9CIU4+kuxdB4sK4Rjx74p908FmSFxecc73iGi/EnRyJCcbPw60iqnYhzIidSfmJLhojoUbPFYplRMZFEmyoe41171WSiNmwddc5Xrvwh33SYJFTVcfjh7D0OhG+27/l0IivL8V5AbPIy0q0DaQK54F8zO/dAMA0nlYqSKb4er7ENwn83rIvk48gxUxRK/FRIaRglIi2y09+BUXjw9tVCYdaUoMFQPlEgXlGg30LoDqVUfEH7jyikGuo9ANXVY1AxpLpn2IuiJQy8YNRqHQs0N9ZA2YSGpGjphNUlVmKGtomeOdaP5Eg86VOB4joY9Rgprxnh8YYUPDi+JIBsGChK9JDTWMJnQ6YTCWVyoRIYfZJYiHWP8ifJ29ob5uCyGgVWHSDqCpJFEobMQJY4StKfaxeOkNp7pXbMCUOwolkU0GUniP3f+J/563V9P+6I5HrDlYmt+GA5pt29EdHvNt/D1zV9HS7xFCFzaYnlfwQ01N+BjKz82oa/PJoyseBHz3PPQnGyWltZvR8lxkn1/9N/k9/POIdUaanrYUuLvpCPdIWSIIAGbzArSmYDkZSztSyYlexcsqwuqUg3TSkv20bFj9yI3Z8Wkama4YBALFiyQy6Rg8/dhkDj454i5nWCssEMu9J4CaJHOE0GUrErY4OPZghpKCipWw/XAR6HHuxHNWQBPoAEOanHoGUNtzbHn4Uz1Q9PciOUvgWKmYYXzEdQ/CaXODeVX21H00cvhXjgKARkLDa/DeuXbSLkLZTTcLenfA1qfkWPKQ4XHbA29/6cnv+5wu7TTkp5ymJ4iuKJMvM6Y5Lm6DkClu3IwADicQDwqbbmUq1CM66jLYU3dGe9G3D8P7mQ3tOYtGT2S3a4jeZlkAmODEQQtuSq8TsATstDrU1GrGcM/Ev0RvFoXQGWvjnm9KXh8DqQTFvSkAUVTYOnW4IS52+847dh2FhcqkeF0Er8s9GSmnTQSvJ3383FZDAOrDjnOHMT1OALpgFz8ml8M2xriDdChix6D+gxanXPhpS6Di/JM9zchifmPHf+BlJWpNO3t3ovfH/091pasxefWfA6XVF6CXF8urJiFiJkZfV1UsAj/9db/mvBjIcngRBSdgVkBKnAUIGSGENEjcnx0Dx7ZGhrpFGwndZOY7ezYiWPBY4N+ND6Hb8IrSJMBVl3i8Ua0tNwP02qBqs6DaTbDslIS8jgZRIYC3/3790sm1rJlyyaPxDz1d9CPv4ykp+wEiWElhiRmtIWViy4XegpZxwqiHBmRwH/nlEMJHJfKiO7KkXRo58v/CkXVMuPKhfOhduyFP3gEoYKLYKjLYCoeONANKzkHqdbwqYnMyIpK2y4oiT5YzgI4B4g4CRhuuOfk13XgYdEeOVIxqBwX52sbevysltS/AkvzIyfWAj0dFC8aTmN5oq1AzcVSiRo5Fu0K1ELXfEJ+3IlO0dC4El0nPGZsk7/J9gMaAUYQVG81UZ+GkBiXYWGJoQ1Wa15s7MW3rQhMS0eOAlzSm8bluiIKh5wCN9beVIO+jhiiwST8+e5sYvasJjIcseZ0EoW91MQMbS/xLIziuPJVmcdNAiKRCI4dOzb4c319PXbv3o2ioiLMnXsag6hphj0OzOyfzW2bpWwdNaJ4JfiKkBlO8LB1QT1JkbNIJnyo1QilQjOmAjAWNu3dhGXhZbD8Fvpd/VJx4bG3BlvxhVe/gP+48T9k4mdvz97BpOr3L3n/pBwLSYbf6ZcYApIPt+qWmAMbdkL26TCU3NjVJgmxXHnnjP5dDAVddr3eeait/bp4y2QmnOIDIY8TT2Ieeugh+RvNzc3F9u3bccstt+Cqq8b3fo8bW34IY8fPRN/hjTRkbsufC9z+w1MvrmeT5VS0EFr3IWhxVnIA0+FDMrcGTm8+NDoVs7Jz0z9COfAoPD11gL4PSf0mWCiB4tbgmnOK/B+7osIKNk/+3vplmTIyLU2mvByMDaBIdzQSI89/QyanEjk18EWagH1/AIKtJzxfXvo60pYCS3Ui6asSka4n1p55Lis4JDFD35Mh7SLHS1+HoocRyVuMnNCxTC6VjbMx+ZsAsAX0jsWlcO/rwjG3ivkJ4Kb3FcmINaeTXp3vhLnCjTVuYBOdQea7sLokD+sLcoQEZVtIMwvTS2RIbzlizekkCnv5h8x2EisxJDE0QOL9kyT03bFjB2688cbBn7/whS/I9V133YWf//znmOmwF0fbU6Ut0iZajkAiIC0mCmBZlalyV6Ex3ijPoX5mJlcAuIBVNFRknHT7Yugo6YCRa4h7bkOiAU7VKa/V1qawIkIyMVmCWZsw3n/wfuzu2D1IYvg+fnDZB89qv3zOTBD4nltl5pdCYigMZsjjRINTSfF4HHl5ebIQU2D9/PPPo6KiYuL0MU/9HaztP0UsfxH8/UcGRjiVyROacrsU+9IwjkLYdXfCU/ss0pFO6FouXE1bodhC4I4jcL/5IxQlHkGq/L1wXX39qasxA6PcKVc+rGgZ9Ce2wFWYguUvh5sVE7aTlr1j7NYNRbgkV2qmza8baWhHn4Zy7HkYNeuha34Ei9agoGsLXGxRkbwse1dmSONUUQTcX6AW2o6fwhttEbNABktKxWvRW6dE1DsaSFgOvt6GKreF4rAlraGelogY21H/tCypYg+zNU0VqglYioXwQj8uXjezT3BnK6bfR4Y+Mbd994SPjH1GwUrMJPvI3HDDDYP99/MZQ8/2b5l3i7SPWuOt4q/CBbcr2TVo3va5Sz43oysAXMC8ihc9Rg/clhsL1YXYa+5FX6LvpFbMVBGCQcLYsgPPtjwr5JAVoZn8Pk5FZYahjoVF10yK2NeeSqJvTE5OjhgcUsPy1FNP4Z3vfOc5k5kdL30Fzx5/EHnVF2N9z35cZk/z1Fw5eTqN0bQzDRvgfON7sJq3IVW2FkqkHU6OgGs5Mh7tvuoz4xP5yih3AogtQafnC7DghpJOoSTVBY/VlKnGUPg7FpbeCnXbfTJVFPPNgSWJ4355nhrrEwFyYcdrSObUwBkMQUmzwgPgtn8//bFxOmv3r6Gl49CdufJOS+19mkiM7QmjOC14i1Qkw4boXnY/3wRFM+Ev1aC0pXGJI4FXVnlhKUChy4G3LMxKHGYqFGumrOTT4Ox7ocKesnmh8QVEUhGs8a/B9vB2aKqGH9/y41EX4JnS7mBF5rHHHkNKT0F1qchfk499xj40hhsxL3fetB5bMpmE231WsyNZnAWeeeYZaSnRO4ZfU4wn4IXE5v3vf/9Zkxn+fXzx2U/B765Ca7IF+XoS3+oO4DLFf0J4OpVgW4hBk9EemCbdcQuQcJcjN3wUKtOjbWJ1qqkebuOXGxA0NiCo3Q5HvAvx4koUxv+IQvN3UuEUHxwGa45xDOav70DENxcOPYiUpxw5/YcyLam5VwPdh8Vfx1RdSPgqMu0nbvOKTwHv/NbpXyOP/bkvZ4Y7WB3iaPl1fzf28UwiGOpIImPqJpw+Bakop48UOP2Ay6cg3MESTOaxrXNccFxbhlsvqZK2UhYzE9NfkbFB0pIdsZ7QCgIrBzTJ2x/dLzqZPr1v1Mklkph/3f6vojUxLAM7u3biOzd8Z0oJw2BeUtEq3Hbbbejs7Jx8K/ozOLaDPQexsnAlLpszO6sw0wG2fY8fPz7oHcNWE5FIJKRyd7afDZn4U4BgshWGpSOiqDhQtgSXvfVb01IhEFicYAM0PYFUTgHc8VZxuU037wIuSULddT8cz30ZpqJlLP4bXhvubcPjvuwT8Gx5HbF4DJZVAmc6Aa++H4piAk7f8O/XAWGwWXkJ0lWXAW0Hobrz4Y/UQyN5YaONVRyC1VASvAMPQz34R0mbDucvl5FxbPsR0L4n43Z8qvfOJl4v3yutG5ERTNP3PTUubp8DqURafGCotS6c40FfaxzJYIbBUK45f00Jbr+5JquHOQ8wc4hMFhMOtj+eqX8GwVRQJm7cilsmgP7yxb/Ef9/034NEhZUYtqE4WnwodkiqOGMJglmW5ejiRAre7BFnVmGqvFX4u6v+DldfPQWhgOM8ts9v/Ly4CLNP/u83/PusbSlNdaYS9TDFxcXo6emR1pLFqu2AHfm5GOKJgNtTgAAneRQFOS4/Vt38n8B0/F45Iv3gx5A2DFiKA8Hyq+EPHYOHOhKi5hLA7YZR/zLi7hLoPkYedEGtfwPalh9Bu+pTJ6aVVm6Au2ghil7+LVLhfKh6C5yOY5kcqEvuHCQaRt3rSD79ZaiJXmgw4LrmL6FUrWYjDzAzcQy+aBNS7mKAydLJ2Akhb/ESuJ75e2hGCuGCVfDEWuBo3gpl6Bj1qcjM0MDHCSSNHJXeE4phbZ7vtJUTfm9d+o552PFMHVIxA06/ilBXSviVQAFW31CNt9yxdMKOL4vJRZbIXMDggvuuhe/Co8ceFZHqav9qHIoeEj8TTjvZCzLLzpx46k53SxWHlZnRBMEvbdmCw48Eoeku+LzuCYupZxvMY2Ts+4+EjkjA4mWVM4Ms8H2KpWOodFVKyvXQ9y2LyWstkrhQ4Ms2EttKFPwSimXhqty8c6rU2QJufu6mXe/ERT0ZgsMypaXkCzdKJSSjIzkxxaktuAa+I39EXNHgSPRmDBUOPwO99CLg+a/ASseg7v0D1Ld9Hc4Prob7wY/ASoTEfdiCCb1gEcxkxltfO/wkXL2HkfKWwxNplufjzkdOjJQffR4INp5wLa4cavb3GeDAI+IBw/gFmAx+dEBJBMc3Rn02017jIDGfP9SEnpQOExY+XFWMbyypPuVzODqteSy4HSpiAROaQ8H81SXyWatZUZSNGDjPkCUyFzDYMnro6EMinq1x14gDbqGjEN1696B4lhWH5nCz/JtVG6SBXE6LjbKtF17eiUuUG9GDTpREKyckpp5fHF540Wv0yri4uJ8PC3GZXvB9YtK1QsXfwM9ZTB5YiaGo1+/3o6+vT9pKhMftRiIeh5lKYc6ycz9THun1M6VgBWXL94EAQwhVIWem4hTtiDfWAkN1I54zD95IE5SXvp6pYsgo8//A098Mw5kDNR2CakSBzp0AyU9uFaxwC8yOvTAq1iCdtwiW0oaEt1K26ehvgNPWd5lJwIjBTAeRdvjh1KPAi/8M3P1MhmSsGgjOHHAmltHqoWAb6f7b4Y63I+GvhhYdMNobme49RWAlpieVhscyELAU/KSlB8/1BPHpmjJ8srp01KpyoC2MZMhCOp75rlEdKi7OtpHOW2TVtBcwOJpMH5mIERE3WlYUklYSeVqenIXabRMuzjz7Y8QBrwPxgLR67PBFO6ixK6cRlisNbzIPIasfvTnnFtwnTqrJJK6bdx18Lp9EKRR7iuXYZgp4LAyH5BQVK1Uz6dguRLBl5PP5hMRQF+Mks2bQZjQqnxc4HAjk5eG8BUW1v7sT6WMbke5vQ6qvERF/jVRO3Ike0Y5oZnIgodqShG2pdBBLbpGsJBrqCeOvuCjTomHIbrgNissHTVXgfPgT0HoOwlCc8MaaJctJ6x+IXCA4Lq06JKna1AaMSNvePBFmaU9X3fSPo7eL+PMtX5OwR3esHaaTvw8lM3U6DWA7iV2hkKVgsWLCDxPNiTS+UtuKr75wRIiLDf772f89gGBvVFx6mZfk9Gi4asPCCakuc/sUEw/dZxaTj2xF5gIG/VVeaX1FBLw2SGouLr4YywqWDbrW5jvyJfuH9vms2FAUzPgDWyfDaxruhfO7cNC/ERGvhb7cdlTmvpt7Oe1xsJoz0u+FLqIEJ1LYRmKpX8S+MyzcksfrNJ14tfPVSfWrySKDefPmifGdLfbu2Px7PNtvIZVOyVrpcSqTExg5Vdj/MKxUKBOgaCRhKB6pahR2vpERweZUiIcW4woEmvuEKJZjzIeeOBEjwJ9JKug7Y+tOeJ3oF7M9Thw50qxoKcMjCUQYfDew7T4JtMzsxzm8NXS6FhArRPWvQD3yFFQJelQGZqqnHtTEsJ3ESkyTpeBi1cIB00DUUvAzPYI9m0P4s2Q13n1RJbY8WgdLTSPRbwlPpNZv/e2LzpnEsL319K42GG90Y36PDo/fOWGt9yxOjyyRuYBhL7oU80ZTUTRHmiWbaVdgF7708pdklJitnV69V5xzl3mXoSXZIs9h/IGtk+E1ow5MxcR29TWkq9JwqA7xqBkPifnW9m/BpbqwqWWTtLEW+hdic+dmITD2MU5rqf90k1QFq/DBiz446fuys6XsXKnZKvJl0rUt9p6Pq4Gmb2N/shI5jjSuumnDjJhkO2uE28Wm3xtrEzGtw0ojN3gU2kDoKd1/xQyUflojU6/taISRYtmRpENzSrUl6a3IeMuUrjx5XNsemd75y8zEqL/0zKeI6APT+uZwYjVNoCZmfziGrcEYtpkmKmFhkWphn0vBG9UO7O/qQnBjHIfiUeiL3LAadczr1lFSkzshJOZTe+rRr6dReYUHK/clcU1zekJa71mcbz4yWUwqfnHgF/j+7u/DZbmQ48iRnKAKZwUOxw5LBABR4iyRgMkSTwk+ufqTw6oPH3vqY+iP9KM+Xj8oQizxlpw2t+nOp+6U0WUmPlMHk6PmiKiY1R9u50PLP4R7rrxnxv327UmqpJ5EqbsUX77my2dNLsYiKVu2bMGuQ7tQr9Vjo7oRaSMt+qBib/GMz8OarEgCTdOkhTTMJ+Z0qcznC/g6HvgojHgvdNr8p4Jw6FHEcufDF27IjDu//ZvnPtnz1N/JWHQ0Zx78jF1gjtNYE0Xn+t7OoN8NCcXd++rRq2cq0DUwMEcFdhgKdEXFnLiFfI+JLh1Ip3TctqsX//dPrzpnsvH3R5vxx9ZuidURf+Q0cOeOOD77wZVZIjNFyFZkZlnIJDODggb770BPqkfIC0W2rMgwkTlXy5WIg5/s/4kEHdqLKf/9Qv8L8m8+h1NQTITmAn2qBZcGe2xt8b8yZxkaE40odZVCg4a2VJuIkelGfKT3yKTHDZwJONEST8UlW6kx0ig/269zsFIzjjbYyPTsp+ufxl+s/Qt07OxArD4G3dBR6C3EyoKVOOg7KJlYbPfN9DysiQbDISW00OEQvxj+PEhkJmHSZVrQtguWkUKs8CL4+muhWWkYqhO66s1MKfH/GKZ4rq+3YK5EvahsVdF8ztbZjLbNc93XDPrdsMX0k9ULcM/RZhyOJkGVSqUFlKgKOmio6LMQtYAehwpFdWDfIh0pJ78Lz43IHIzEUahY6IeClMVgSQva1aVZEjOFmLVi329+85u4/PLLJZCurKwM73nPe3DkyBFcqLBHTi8pPVE+5tk/KzBcrJnqTELjUlxyu72Y2rAXYgZSUmdDYoIRI6IjwWLfnUvvxBzvHLSn2tGcaMYi7yLxZOEEFaFbuuQYfWvHt6T1dO/2e/Hex96L3/7zR7HvEx9G7/33Y6pB8vFq66vyvjA5nEniXbGuwVbZ5zd9Hj/a+yP8v9f/36AgeizwPaSPz1xPJqOF//75az9HuDGMvPw80Qgl4gm4+92ZqS1AQipnch7WZFRjqImxSQxhj1tfMNjyQ1gHH0fSX42c4BFoPG1XMxNLjlQfDBHdmkA/HXPPEVWXwHQXwEEPGJIZtn1midkoycw3l9bAqyqIQMM2S0PAAlZrJioVC5oCrFJNuFTgaEk5nm/pOOcqUGsoLHobTkzxG9HhUMUJOItZWJHhiOuh3kPoT/SjwFOAFUUrZEpksvDyyy/js5/9rJAZ5rl86Utfwtve9jYcPHhQRj8vVDLzy3f+cjCOgIvF0sKlon85+NIfsDToQFOJikApZILIXky5WL/W+pp4qXAhjpuZxSbfnS+tktGqFLSSZ4tgXdU6fPW6r4qj8J7uPWiIN+Cy3MtkJLw+VS+/d1ZiihxF4mVDYrPkxeNYudUNJZ5Ex1ZGtwFFd945Je+RXUEJJ8ODAmgbfN++vePbMvXFQE5irMqJ/X6IjsiCvDYSRKfixDLHMvls9/ZmAih5e5e3S8bfr666+rxKxJ6olhLdep1Op/jHeL1erFp1ARE5Jmy/+A0k3cUyCq3QHZpZcqom+Ub8llNp3U+07Z6QXXIKypluyUQBMLNuhlRNporM/MOiKtxb1464YSINBQkLOG4q0tBeqmRuU1QVdQO2CmdLYj69qxaGbqJX0zI3KhYqPC481pWZWsrGGswiIrO1fSt+su8nqA/Vy7gwhaQL8hbg7tV348rKKyctx2UomHbNysybb76J6647RbjaBYCRYYs7n/0Vrv5jHA3LVsJXugZN/VsQLTtxpsIFmQtvRI+IzoVgZeev1v2VLLhc4H+w5wey6Je5y/DlK76MSyovkYWJ4GM4tkwiQ33O9sh2aTcVO4tlkY9bcZmcYnWH7ac13Y1Q4zGkjRTcJhB9Y/OUERl7kosEhE7HbIURzaFmvNLySsacDfxCNGWSayjZs4kcQTIUSoXksYZpQNEUeY3c7sHYQXhMDzyKR9K8MQe4fOXl+PL8s9fhnK8k5oUXXkAsFpOTh0gkIkTm2muvnfmC3vFoQwaykcz+Fkml9sY7obB15C3IhC3S1Xfb/yLhq5TpIlXXgWTk7I6H+9r/sOhsDMUBExr0oiVw9R6ZtrHo6QT9Y1blePFYZx8e6OhF2FKFxPAL56iZOUF2WRYWKicmOs8U3HavZeEyh4otJqSV51QVtMaT+EVrD57uDuKHq+ZnycxsIDIkMV/b/LXMGLA7XyoBXCCO9h2V27+y/iuTRmaGIhjMtDqKioow29C9czNaqpfhifd9DMcsBwocaxGO/mKwtbSzc6doWthi4fTRddXX4eKyiwcX8B/s/QEUU4FP9aEn1oNv7PgG/uGqfxi2KLPS4nV4ZbTbBttadBuuS9ShKdGENNIiBK4pNrFGN+FiMURT4b96/YS8Th4rnXnpm0NiNZoWR+zrnX6pDDYmGxEzYyh3laMr2iWvga01VlWIHFdOJhV7oIrDahXvW1q0FKFESMgfL9zeEt8SHI4eRiAdgOpVsa98H5aqS1FWWYZb1916zgQmtn074vsPwHvRKvguvxwzHRQ6v/TSS1K5Y0uJIl977oCOvjOexDz0icxkEY+5aCEaim9Am1mMqoUrMP+q2wZCEv9BzO10Vz48sfZME5bBPvYodNsuKKqCvN59UGyLBFZQzqZt9eyXkXb6kXbkQLMMIU1JfyUsPQnl8BMZ75hZVJWxqyG8LPO68N2GDrhMC2lLgWIa4qR8XWcDbrn2HP5WFEgy+aGBcRmXAsxRLXRZCsKmhXAqLWZ92arMBU5k2FZgJYYkpsxXNtgX9zg8YkJGXQLvv7zi8kltM/GL8/Of/zyuueYaXHTREDvuWYLSdevxYmAPDloOFAZ70VlejErfaqke2ELVPEeeVGS4mG9q3iQakjxXHm6eezNy1VypNnSlukQ7cyx4TIz2vnvjdwcXaBIECn8dKYdUY0hquN3WZKtoUdh6YSWOmpQXrjTh0oDbemuw7G0fOOdqjJ0G/vjxx5HQE/K6mDlF3B5dOowAiJboLd/CY0cewzMtz0i+UsSKwK/5UaqUYk5jBEv6fdifY6F2Xr9Uo1hJjCQjkmVFB+C2vjYUu4rl3wE9IMLoN4JvyHs03zMfbck2tLna0I52KD0KNr6y8ZymlI488wyO3P8rFHR2QvV5YXzkI5h35ZXDqhr2aPNMCOLksWzcuFGIC03vqBOyHXz5HTDjfWIOPAwz1oeUu1DM6Vq6Q/hjTwpppReO2o3YQA1s3SYknflI+qqQ17cv43pbdWmGUNij0KzmuPOgxntPSBZ5/5nizZ8Dlg7FMsFwA0+8fcDwLoBk+Tp4QvUnTPV4zWNhZWgGTBpNBT5cXoDluT7sCcfhUBV0BQIoDfcLiTmbvwW7+poOLUCh5UUbVOQpFqpVgCq3FMmtosJl6GLWl8UFTmSoieEiwErMSHEff+btvJ+Pm0zxI7UynJJ47bXXMBux7u0fxT7Fhyd1oLOiHOwI/fnCm2AmDkl7hIv4cv9yNMWbBhOyO1OdMNIGovEoomYULfGM/4xH9cg185yG6kd4/c/X/PNg+4UaHSZz08OGVQ5ut9BdiLsvulvI0qpbJsYYj186FOVyWoseOmxdsXLUkGzAjmd/iSufspCMBJFyqWj6y3ejf+UcrMpfJbqeDV0bBnUuvzr0K5Qc6cLdL2lwz6nCda0x/M/1Mfyv63+xvny9aHxIVI7FjyFkhKRylTYz49Q2KHDmhUnkbKsFUgF5/XRSHjoVdaak4MktW5BYMB+O5cuRSCagHDoEb3OzjDATmzdvlsfxb4r6kw0bpteLxY4hsKMI6GfEthLB21itIaabcI0Ji5qWFNzxDqRchWjLXQsHCuGOdCBk+dC25SFUV3rF+VZIDOFwAyv/ZLifi+2gu/n7QKwn48My0u/ldJWhzd+H1XMUKU8xdGcu/OEBB193HhTNBTUWkDaTevhJgHEHrPwY6cyoNwnNpR8/4SlzAcKu8q0vzJWLYJTYgjP5PvmbTX+DXmUO4vl/gbUuE0WKggYTOGiybp35i9dMA7e51Ww1ZjYQGZbvqYlhO2k08HYupHzcZOEv//Iv8cQTT+CVV15BdfWpg8YuZNz1tvdi6YgE2R0tkJYSowt6U70yecTWSbGjGCWuEvSn+2Vh/PSaT+O7O7+LhJE4MXnjOHnyZqTp3UtNL6Ev2SfC2QXeBdJe2taxDf/51v+csNdlTw3lIEf8YELMqBmo7uUc70As5ER7mRt5rb3YsunX2GZUCIH+0vovDTtejp8Hjv4MucHX0FXQjgJPPi43q/EsQsjx5iBgBNCaapXHUhdz7ZxrpcrIrzXqvfi63mh7Q94jVmjccAuhSmtpGX1ntehsjPBICpKKAs3nh8PtkqkMwzSFGLB1Q0Ex/02ywDgI+znTSRJYcWEVhsdFkS8roowloOierabDhw+jsbERd9xxx8wkM6yaHHgYSrwX7lQfqlJ7sMe9EClPKXKRRnn8GMy2GFwUxdOZV3OMbTh3tuPLA+0tI9aLlLdSjO/YvhLkzwNu/wHQsQ/Ol/8VUW8VXJ2HkXaXSq5SrHAhfOHjGV3Oth9lTPjOhEDNUDy+vx3bOkO4ojxPXHxtYszW5UThv3b+FzRTg+VdgGKHE82RGLo8fohmWGOUZ2aOs0TT8L7VSyZsv1nMYCLD6SS2E6iJYTtpJHg77+fjJoOpf+5zn8MjjzyCTZs2YcGCBZitsFsvg0nABZnF9NI5l+KW6lvwTPMz6Eh1SGWGkzwkHiQs+a78weRgLvTUn9C5tya3Bh9b+bFTLsr2ODgrM3889kfxtOHCzhFstmsmykuGZIrtKhINxVCkUuIwHeKFU1vRi341gbywAwmfE70LSmRR7Ux0Dqsm8Xh+X/t7VDn68WGPisIoEO9vxQF3HgyLHiAW3rvkvXjs+GNCzNlyGzl5xNfD9/nrW7+O4/3H0W/0ixEhj42gf8zZeMeQFCgcW04mkEglxU4gkUyKJ0tLS4tUYVj1oKDWTpGe7tYNyQmrRSRaPT09cmw22Gqi4Jdj2AcOHJiZRMaupFBcW/s85odacGvyUbShDBVKAJU+Ay7TAJweYM0dQNGCiW/jsEVER13NDU/MJtCZzGwsvSWzL2pwLENymzQ9hoi3Bs50P3IDu2SxpWRdykt1m857IkMS8/eNbQg7Ffy0I4p/7Qvg2rJ8bCjyY33pueseWdH8zdF92JG4Evl5V6DA6EKnEYPhzoFHT+Pi9nr4lywHCotQ7nJiQ3lhthozW4gMR6x5tkphLzUxQ9tL/NINJoMyHszHTUY76Te/+Q0ee+wx+fLv6MhM6eTn50uV4UKCPW7NmAK/yz9M6Mr7GAiZSCdkEueZ+mcGtS38fTBkcqF7IfqMPqkcGKqBFSUr5Pdik5izjRiwH/9I7SNCMLg/tl5+vO/HaAg1TIhVP59PAzq7YkTCwAsrSzlL5uLnt/ejvDkEc8VqNBX2oifVMszHhe/Pd3d8V3Q8fVUafvWeEhTWdaBljhe1c4EKZz6ea3wOPocPn7v4c5m22BhGebzty1d+WfRDrBINxWgVrPGAC/0NN92El55/HinDQCgclmkxfoZZ7cjJyZEqh11iX7169YwgBzyGj3/849i2bZtMCgYCASGRdgYXPwsz2nTcrqSwMvLY/8H8cCfm6y1I+OfCHe3IiHY5nTRZIlsJi8yFFs34GwlY2aaLrx0VwNZRimP/HmhGAoXB/ZKq7Uw1DJAYvtFDxMfnMViJSTqBcqclMaPH02kcb+vBS50BfCppjJqCfSYk5nsvbMIfalbAKqhCqQo0pKNwhh7FjcU34mpHKW5ZeR5M2l3AmFYiwxI/R6w5nURh79CpJZIYLii8fzKEvj/4wQ/k+oYbhv8R/+xnP5Mv2PMdtiCtLdKGR2sflRMvTuDQ8I5j0E3hJnHU/d6u74mehe0iOv6yFPtyw8tYXbgaj9U+hl0du2QMuSXVIlNLH7/o47hr1V0Tdpw8Ri5anFaqdFRm8p5SLfjdkd+JC+5QwfDZgqSNFSOWhfna6ZtT7a6W0erWCg351UVY4vWjPZyZ0qryVZ2IEWjfIpUTaX+oPuwtjyJe6sC1c67Gbf5ybG7ZLMLepmiTkMW/XvfXp61E8TXxsUd7jyKcDo+rgnUqXHXVVaioqBBtSW1t7aCHDwl6KMSk5AxY6SgomPjq5tmCx3nllVfK8XOxoJbn+PHjch9bT+eN8L5sFRDuRNRTib5QCXoS61BWVoyqW983eWJaO3dJRq4BFC85WcDLnx0eKE4vkFCkOuONNMLU3NCMOMBK9w33nPfVGILtpJ+1R9FOnS3buZop33mthip+MhzFPtvpIbZi9+cWIc/lkMiDg4aCpJaLOSW34GfX3zrhryWL83D8mqPVHLG2fWSoiWE7iWf8k+kjM6PP9k6D01nk21UWEkJOhlGcSxO3GneN3M9JIQptA9GATNpUeCoy8QRGLjrSHdjTu0c0FUx8ZsuH2+Di74UXLeEW2f9E+Z3wNbCtSCFuSkmJcJiEgVNMrFqQfNDE71zB471p3k042HsQPvhQn8iIIvna+tJ9CLvC8m+CVSsbjExgu4vvYaFWKCJnTlzZZO6J40/I8XJCaXf3bvzFC3+Bz6/7/ClbY5MRkMmzQV5sbxa7wjgU/J1Od1vJRn19Pdrb2wenqIYe/0yZrhpNWIveOsCTD/iK0dCbQltfAmXuKKrdJWhzXYWt7W9FKuWB80ASN60yUTWZL+F0+hrVASudhOFWBxTKTihmOkNiWK25QEgMQU3Mi7EoHohERK9SZwIVioUkNSuWdU5j0Pwsaq194LPTFlCgWui0gHZUiSledrx6+jHtRIYgWeGI9VQ6+55vsIMHu2Pd2NezT9ok1FewbULYOUXEf7z5H5KZxPZJv9kvUzcci2ZlgZWIBe4FOBg/iEOBQzJSTXlaQ6IBczxzRPvC3wP3x+293vq6PJe6mOt6K6FtfREPuzah/z2fxs3XZqZizrn1s+YvxDGXomJeeLycZOI+SQ4mSjND0kT9ih23wHZWia9EJn1iemxwwmhl8crB57CSw+MhEbTTvpcVZjKoeFx8ntvpRr6aL+8dfy+scg3NqZoKsBrDyTsKeu1WEq/tSgyF7G9961tnBDngsfLCNhLJ1dApKpvQzCjQuO6BO2GkYlLNMKJBtPUk8DzeAiU3B4lgFzaYzyASdcPUfPBrXYiaJeg62oyq6fTWDNTSjhEKE7BtD5ulb6PfRKaddIGQGBvfvWIxLmrpxv2tPWiMJyREhStIvkM7ozFokpNX6wKo7NVx07wizFs8D38RTeLzXVFErRNrEr8tsj4xMwMzgsgQJC2zKV/mTGAbrjHMkVUDEhi2grr1bsko4l8Ux553tu+UagEXXZIYr8uLQrNQ9C1cZKk/IWmhKRvTr4u1YiE3/Jng1BDBBZ0VH1YdVEvFjs4dKK3twuo/HkLf5Vejr6kOB376WywvWo7qlede/idJodiYxIqVH44vD0Q5DZK0iSAyQwXGdhL1843PY1PdJnkvCe6/KudE1YLvw/JmE4t74mgoi6O1KpP6bR8X32deaJpHPZEt4p3K0EeSAlZhOJ3BlpJNYGyQ1JSXl085QWB1hYJd7p9tIrviwngQ6nhIutiym+4pqnEJa9NRWKoTDj0G1UyiU69AGEnkJfuQMn1oQznmOFugJGlHUAKnlkLZ0kwFdFrw1N/B2vGLDDW3Twj1JDD/uguOwAwFtTC8bO7pw+OBsLj5nonwliTmc3sbEIgnpWX3g319uLEvF7ctqcI9+Ql843gb4ibdvc+cIGUxeZgxRCaLscFFMZKOwK/6pQVkxzis8a1Be7pdMpDYKiFZiSfj4pDLdgfDGZtTzVJJIDnhc1nlIIkh7IWcI9DcJsEFnlULm1S+b8n78Kcr/xR79n8ddeox9NQfRX5OIYKpGDb95FtY26djzo23nrNpHatwKTMlXixRRAdvJ7GwK00TgZFtnd8e/C1CemgwP4qRAUMJ9eoWDfMeT8Odm4dEuAc/eJcGvTrzXvG4Xm55WdpNXKxJYghOc00lKa+rq5PRZZIYEgTqS6g74jWnf3hsU91KJWF54IEHBkMg9+zZg5tuukmIC4+Rt/N4OaU0U9pdY6LqEihOH5wDxnWqCVShEy6kETJ9cEFHldKDUncvbsr/b3Sll6Bs9TJUXfen03O8W34IfeevoXtLkPKUQNFTsKBmhikG/s4vdKzL9WF9yZmnWrPC0q/ryHNmzqWUIgU/jcTwxMFGiRv4zdpFEk1AJrOhbPwEqa22D7U7MsLsJZeVZZOxJxhZInMewB4h5pm+T/HJ9JCpmDiSOCITOKy02OSEwYNcICjsTaYyviHz8zJnu42hRtkGMSdnDu658h4R/Nqmb5wUGhzBHljs7ZHdpevfgfCTG9FhAOFICO6SQsx9/RDUaBIdW8492NHOL7LbidU51VhcsFjIwkSNYo+GK8uuxIstL2b2DVXGqIcSnXltOppMN1pTPShOAYs7gFUDxIrHRdE09UYUQtt2WHzPmOhNTEVVZuHChSLy5X7tqZ+hYKVmqoWzrMSQrBQXF6O/v1+qRM8//zxuueUWGQfncfK4rr/++pldjRlpXDegkZnvK8aGWBhtKEWVX8P8w82IoQZVroOoch0Clt47fcdbt0mSr3mht0zSWzEwpTRggneBg2T5bNPTWWGxVAVxE1irAW8agCXTlIaQnM/MLTuj6g6fMydkYPsT9Wj2kkdaUJ7pxfLnnXjninKsuXEaq3YXEC78T/UFAC6GSwqXyMQNz/4JimFtUmKTmBxnDv7y4r/E1o6tEiNAbQsX5/cvzWhZvrU94+DJ2+5ccecZCU9p33/p1/8VRa9swkuhfSg62Iq8mgUwjx+Hlk4j9NTT50RkSn2lQmbsygHzkNjaOlciMDSFmqPRQ68Z5riyYCX+v8v+v0GN0UjSxOiC3PxSzA31IuYzceUN78eGIY8hGWyPtmNr21bM986XqlLMiMn7/2bnmxMydXU6cOqHsDUy9GWJRqOijSHs66mE/Xvk1BRHwJllRoJ95MgRITMUI884Qe8ZCmt55HL0T/5f6A4fTNWdqXyQNExnUCP1L7XPZVx8B1rFMmbN6aVZUJHZGghiTyyFtfn+Mxbi8vHXF+Zgd38IrxuAOUCIHIpyxjqbT+2rQ9Aw4WCg5Bo3Ch1AC7PjTBNvpoG+jQ3y2CyZOXdkicx5AlZJKPLl9AxhkxgKVlmxobjU9l3hYkwh6miL81gL9lgk4Gj3USwtXSrbJZlZdfnleGTL15G7cwecDd2wGLIZi6HVEUHPOUwz8fU9UfeEuN6yncTF92x1JrbB35HeIyJcZlSAPXkl16om72ONtwaWauGr13x1zPeDr7nqX74xZiAj97W9YzuKtCKplDFvygaFwFOllSGZsQnNk08+Kd4sPCu1z0ynWofCCpBdlSGBsX1huru75Xd79dVX44KBBZkEciYCSLvy4Ur1AZEBl93pgK2BYQZT4JgIkE0GmKYHppVmODaPcBgfL/63pRu/au1BPJlEv6KhwKHhuyvmnnIbI/fFz+ifVxbi7lAU1kB4qVdV8PcLK8/oWH7U3IWErssCG1NUOF2KZDDN1UxEFaCH32/VTjQf6s0SmQnAzP9UZyGwF1oSEYpRuSCPbAONfPzIxXm028YCF+i/f+XvoVka0kp6WKgh9/mjtzyNFS298IT6EJtbjp9e1I221/8fPrrio6c0hRsLfCwN5X6w5wfS5jlbnYktjGZbjXqXPDUPRe4iIUgU5VKQy5FzXpc4SlCfqj8t2SB5GStR+r92/ZeYCSadmRZfgaNAdEjyPIdvSrUythfLsWPHpLxOAmEHM061DoWkiREDL774Ipqbm8VoklUitpRItN71rnedP9WY0+Gi90LZ+XOoVkqCGwWxjIB+WskMq0KBWqhmAqrJEx8FqH9lRot9/6G2Bfe3dkt1tsDpEF3KeAgEScxXalvhg4lCFQgNDAucaqqIJOYzBxrQl2aVSsGdVUX4f3NLcVVpIX7ico1bC8N9v9IbxnVFuYPGe/vDcYShYJFq4rgJlDgsqJaCVhPQmcDNBylAzYpzdx3OIktkziucCRE5F5AM/OfO/5R8IhIATj1R8zHUxRcf+080zX8a6YOHsTG3E8mF1eiLHZPRb1tvMjd3rrS1xnvMtnHdqTxyTgc+l2nqHOO2jEx7g1NZbLMNhZ3WndST2Nm586z2x6rXrq5dMirek+4RYlntqBYiw+oPR+OnanKJJOahhx4SokANCjUpmqbJfStXrpwW0sB93n333fj+978vrSW7xcSqDIXAMzZL6UzBllPxEji6j8CyJ4Smw6eKXjcHHgY69wPxINB7HJapw4CGlCsfzlQYypGnZKJpJgZF/vvORvyqv1cS5/MVC50pHfc1dY2LyDza2Qc3TKx3WHhDz4xGG5Z1ynbQY1196EqlUa2YaLZUPNnWg65kGp+oKRMCNNa009AqzhPd/fhVS7f41bwYCKE+npT9diTTyFWApJXxswlaKixVhWFacCiAPw386eKybDVmgpCtyMxykLQ0vfI0cuu6cLxSwaEaBbWBWuiGLiZ1hc7M+PbLzS8PM8ITbc0HM14qW3b8GwriulQ65nvmoynZJFqRtnAb7t1+r7R5/mrdX41rUT9XszgSEjpCx/XMtAwxksTQPbrAWSDTSpQzvNT8EnZ27cR3bvjOGe2b1TGCLSXbg4YOxRyF5wTZs43PTgnxtFtHJDH2hbCjNii2nU7MmzdPWl0kVzwmanjYcqKm54IgMsSlH4fy7JegWHpGj2LHBEwB2l55FV2vPouy2CZUOffBoA7MVQDdVw2NfweqEylvhWQuCXb9Eli5YfJch88CnOp5sKEb6QIV5Zyw5N8SgOcDIal4nC5ioNTlAD/1hw0gigyBv7Yw59QkSFyAgX4LWKeYaIWCJ3qCeK0/CtOi9tBEicshrsDXFuZCJwlRFXyvsRMRw4RbURDSDRTCAmtI/Jb5dWs3clRFiBgp7RKa81kmYlChmZa0uzaUF5zRxFMWp0eWyMxikJj86Jd/jQ8/3Ad3ysKyojzsutWP/vKEtF5y1ByZImJYJMXFDIUcudDTjZnVFy7edAzmiDcrMks8S8SMT9VV7OreJe2eoe2pyYLtFUPyxNgLEoyBQq4IipntZZmWELPunm4s9y/HzvBO9Cf75TlncnzUGr3a+qqQFu6Dk2AtkRas9q/G4dhhqdZ8c+s3RRA82WDriC0km8RwxJkj2dMl9h2plzl69Ki0ltjusnG2kyUzEna7hgGMU2g2RxLz4oOt0JVL4c1Zg6u8D6JCOQBHqh/OaHCgpQSkXQWI5zL1ug5goCW9cWYQkelqDMOfsJDD9HZOX1pAqWKi21LxtWNt8phTkZlP1ZRhX18Y3UamtVfo0PDpmrJBksTtl83LHTb2vKGsAJu6ehE3gGOWCadlSY6Sw9CRq5jQLSCS1LE9kcTOQB/yNCcMWNAMA6WwhJwUK8Bi1YKHOWH8FlCAIqcDhxNp8bAhIeu0FKnK6LCQsFQcCMex2OfJEpkJxKwlMsxa4oUleWLVqlX4yle+gltvvXXWkJhvbP0GljX2w10xD/1eCwV9CRTWdSFSoopPDQlJKB0SEkMw2XokuIBTE8MxcKIt2Ya5nrnYH98v91GMTNAHZ6qEr2NVdWwRcCwRw+7Absmdakm0SKJ3xIiIOPhsdUu21w0rUG2pNiF/bDE9XPuwjLhP9uu2E6UpsD148KBoY2wPF+plphM8Nrr3MiCSnjc8Nnrc8G/uggLJyxTrT+gebGhe5Dj6EA5Sn+XFfH9m4RcMiHsz1RgLaWcBnOkg0J8xv5wpIMm4fncbflqiIeRQ0aUoKLEMLFUN1JqqGNHZoHal2OnAp4eMQvP6eytq8FhfVCotdluIJObpH+5DKmHA5dFw62dWo3JxgRD+dT4XvnPRQnxqdy1Cloo8xULAVKDRboeJ9DQaBZCwLMSoa7F09CmqVGt8UBDiCRIzzTRIxpOuKOC3nW4AbpUVGBOhgW10DGy/zEzjYEjHjlAMD+9oxZx8N4rn5GQrNBcKkaFCPHHwEIy+PmiFhfCsXAFlEs8kadl+7733YsmSJfLF+otf/EK+bHft2nXhfcGOIYjtjnfDVakhFclBgTsHifotqKvQRKTK2Ih9HfvggksqMxEzgo5ox0k5S5yUevz444OtFV4zn8kWvdoEh6Ph0+nczOP+m01/gwKrQMIxJQkbSfHbyXPkyWkgidaZ5kgN1S394sAvRGBMAmcLfm2X5KkgcLa9Pysd+/btG/QAos8MCTtbOfyZn++pbOlw3/S5YYilbYp3Xo1ez2DQPVjb3YpwqgBONY4y53GgYB6QUwFUXQwUzM2QmZfvhTPeJ54yph6CuvvXM6q9xErJn29YhoWNvXjSq2NzMoEeS0O/aaFKBTpNA/9Y2yp/T04wQ0nF1mAUP129QAgLK32XFeRifelw8ezuF5tx1A/0zXejsEvHnFebUDzXJxVLVirXu934dvtxfC63AjGPF3mJOPJcTiRdTiEz7QORBIppIk7hvNuBCL20hvSmSF4KFQvdloUSzYFPzS3D1mAET/cwsFWFrdIJWwrCUFGgANUwsD8P2GkmgJYkHurok8moc0npns2YEUQmumULen70Y6Tq62Gl01CcTrgWLEDJp/4c/oGR0onGu9/97mE/f+Mb35AKDe3eL3Qiw4WV4ZysGkQWF+M+5TgWdqs4+i4NR+c58IFF70Z1bjUOdx+WdGabpHCMeeSizH9vWLwBT9c+LU7CNIZj8KNfyQQvclFfW7r2tKnQkw1WYtg+KveWD+pn2DZjNanIkZlqoq5nqKj5TEGixgqUTd4IVramenKJFRnbPZfXvb29uH/7LnT78lAY7sOhQ4ekejPZRMImTyRVXDR4PNTIXDAi3xmAquvegpvwKrq2vooyx3FUrf/Y2FWh5/8fnIku6J4SuBI9meTsGUJkbDJzJy8Dk0D/fLwNLpMtHgvrNGCfYYGNsirFQr1lIajrg1NJbKOytToSe80Unrvcj1wPEF3pxvHmJNY0xYa1mN6yZD7+5Qf/i0PF5VgR6MRP7/o0dpoqyga0dSQx73vzDSy99mr45lUOamQMVjoVoJlVl4EuaWF7En9S6cTamjK81hdB2KA+JqPFWeZz40gsiT4zQ4TmKEAKHMdWZMrq3+s7zimlezbDMRNITPs//iPMSBRaQQEUlwtWKoXk0aNye+VXvzppZMYG2fzvf/976eGvX78eFzq4sHKBjaVjou9oqjawr5p/bCpKPEVSZSE4ecPqxekWZY6CU/Ca58wTQkCCwHYUSQxziaabxBAkY3TeZaYSXzOxumS1pHnT76XCVYGOVAf2du89633wNbKStbF546Au54qKK6b0tduiX7rmsvrCL/jHjtZhx7JLYGgaYroBx/G9k+4rY09R8W+KC4w9QUUyw/bXROx778ZmvNAQQP98H269pGrWLgAkM7ycEiQ39a9APfKUqMZkqio8jV43p4EIaxUFMSgIWyo6DaBYBLT8OyYsqZikEk2wrNJRNVeix1qZAy0dRcIBdHP8ea4TX33xKP4RSwfJDK0V3gngRvGKejf6K2uwq7YVvZTrKoAXlpCYv7rmUnk8yQYJ1Jb+CJ4NhJDg95+lQDMsXH08ha7iMNYvmYtfrlmI+5q7EEjp0upitYXj5b9q6YGhq2hTLUnSDjGuW4xNzy2lezZDne52EisxJDGO8nKozIhRVbl2lJXBjMbkftuYaKLBM0WOhDKB9zOf+QweeeQRGVW90GF7trCFRNLBWINLSi/BHcvuGBTk8rKubF3GnA4q/A6/PGe0RZkkgZNBJAoEH//Wmrfig8s+OCUC3/GA3jc1vhoEqQ9gtpO7QAjW6tLVaEu3STWJ6En0yCTW2eLOlXcKefM4PHL9sZUfw1SClQ+2bobmKwVyC5Dr1KAn4khrGjp8eXiqvhl/9ezLeOTQsUk5DlZiSKh4PKwKDcVE5D6RxPx6Yz3uLzHwm0QY/2dXnYzFZjHGWPYb/w0suA7wcvEeWPCbNmfum4HgaHOOpopg1kbAUhA0M0SmJkPH8HpfGD9taMfOaKYKasd02IGk16+dgw6HhiZLwVyVz7Wwq1QT8e9QkMwU/9nH5ZqE4xPVJXCqHHTQUOr34fJVywYfS6LBqAJqdMpcDrgVFW7dwq2HU1gay+h97Mf9fPVCPH7p0sGW0TeWVON3lyzGh+MuLGpPo1+n9oYkDHCdoXtwFjOkIkNNDNtJUokZwab5s5afL/fzcXRVnWgsW7YMu3fvFm8Lnj3eddddksw7G8jMWJ4tIgLe8g281vIa3KZbqi2sLrB9NNYoMUnCI7WPCJHJ1XKlOkN8+aovY8bAAm6suRENsQaU+8oHXZCJV1peEQ0Qgzapmfnxvh/Le3M2BMyemjoXL5xzqYK89tprg+SBZ6SshKxSdLxMczyPF7mGAbdl4rniavRBw7MNGSfi21csntBj4d8vFxSfzyfCXv6NETyeich9qt3eie4iB6rdQEvYQlg50WbIYghIVB76BJAKA5ob0JiGOEAkE/0Z35kZ1F6ywd8jzfDo9UJPFsJsjOJoKoRQoR+cx+Pk0NZ4PhqauxBs6sIVOR4s9ntwS1kR1hflZbZT6MS6fB+2BWM4JifECnL1E2RjLJBw3FZacEqHYfsY7TylGjWNsncMn4wa67Wt/5NVeHx/O77S1Y2IasGhqfi/Cyqyn9/zkchQ2CuamFF6m4S0mZjR0tc3KftnyXvx4swX+KWXXort27fjP//zP3HfffdhNmDkdI8tAu6L96HcXS7GVKyusNrSFmk75XZofncseOLsvjeRSQqeCWCF5df7fy0kxev0SpVkqB/OmpI1MiJe7iyXFOxAInBO4+Ln6oUzEV4y/GyTyPDfSlMDlociqMgvREkkiG5/PnoVDZ5kHFG3D1u7e3H7iok9FurMeJLAVhKJFT1kCIrrJ6Kt5M11oaQthtq0GyGfClfaQs7xCDA3M3I7lNzxfeksLENt3Annvn7M7UxjyeUXaGAficuW7wOBOqBoIRAPIJ2MQjOSQDoJw5WHRE4NXPFOKKyMHX0eWPX6jCUzQwnEy/uP4KmDwMPX6Eg6VLgUFYs0Cz7LkKmjjaEYng8l8IdAZJgj8D0Lq/CJffUI64DXAj6/as640qdH7v+0jzlDfv7uiypR0p97VnEMWcwgIsPpJAp7qYlRPBxSGw653emUx00FWIpkSXK2glUECmJ9mk8qGFErKiSGFRl7vHgs0MGXoZS2qy+rNDMBJGc/2PsDFKvFMkrOgM2RgmWa9X36+U+LdobTVn16n4ihp2raaKLASSBbi0ISM9SzpaK/Ry5ESjegVsxH1O2FyzRwZenwxf9cQcE8x6yLq4vR19EnBngEhb52HtS5IrfIg4WHdOTtj6HJp6GgS4fmSAM3LhxGYr73wiZsL6xEXdQFDxQ4S4ANdTF0PJgJdbygyAxJzG/uQEpxwpnsBbqPwHD6YLjyEXcvhDvaKqPX/tBxJH1VcKRDcAQbgfvfAyy+BVj/2RlJaGwsuawMy3d34/3bUugsdaFhuRN9MNFu0gnYRAKqiIEpxB1aneM1p5tmImEYD1nKYoYTGY5YczqJwl7F7R7WXmKv0wgG4V66VB430bjnnnvEM2bu3LkIh8P4zW9+g02bNuHZZ5/FbIUkQzMdV4O0WejoS1ArczqH2pGeKlPlaHs6kIz4VT+6U93y2kiyRgqWSVaunXOtOPwOfS+mc1z8TEgDxbP8DLPqQSLOVo7tHVNTUyPVkUAgIEnUxHJFwdxYN7pyC3Hj/DkT2lbi8Tz33HPyt5w20lAKFLShTcw03v+WiZuUCgXiMFJASVsa5U4dqYiFkMsU3xCebVMvc19jNzbNXYE8pwOKpWCJZqFBAw5UuVDTqZ//gX1bfpiZPOL3pq8Y6NgvLSTFkYNQ0SVwpIJwJbrgjrYLibG/XWmSl3YVQte80NIRuXYeeRJofRN4/09nLJnh7/Xtn1yFSxrDMDwh/EtHIyLFFbKIJawTgk9ej9SaZAnDhY1pJTIU9nLEmtNJeleXaGLsqSWSGNXvl/snw0+mq6sLH/vYx9De3i6BdmvWrBESc8stt2C2gqPInEyixoXVCfqrUOx749wbZ1QW1KlaSM80PIMiT5GIbklQSEZK3CVieMfX8xdrRs8/4uOZLs5KDN+DsYTNMwk/eX0rnjx0DCXhGBYmE6KLIYkhbFffiayCjAeMIiCJojbGaTnhMl2Ip+LYW7wXHe6OCdsPw/Ya9gXAjoljQEtM8kQRZ2OpE58/1IQOy4mkw0INTHhVCwcNiP9Iv18//wP7SGKe/ZII7UlETIdPohEsb7kYt+X27oKiaFCs4fEccHiBwgXwdh9CwlOGcMEq+ELHM/dFu2fcSPZoZIaXN954A0t6O7EjtwRJ54A0gapZKFjmz7rmzjZM+/g1R6s5Yj3oIxMMSjuJlZjJ9JH5yU9+MinbPZ/BRZ/TPD3xHmnBECQF50NlgiTm33f8u0Ql7DZ247XW17CqZBXKPeWozK3EyvKVwwS+M0mkezZgxeG7MQXeeYsRMg34ju1DYU/n4EQQiYQ9NTRVYDWGlR+pxqTTUDUViWQCLsOF0nTphH6O7ErK7uebEAkm0VnjQL3PAZ+mY39XHzpTaUlCNjk0wFaUBdCikI3jRI6Kt3xwyfldjanbBFN1IO3IlTwlVzJwInnbBis1niJg7oClRF5lJgOKROW3H4aHAZKaAw4zAVN1ZuIMKP69aOAxMxjl5eUo3bwZ7zi0HVvnLUdHXhHPjCWQ8T3lUyNFyGLmYNqJDEGy4rviiil19s3i1DlFnbFO5Cg58HnPj3FAtrTSVhqapUkaNbU6xwPH0a12oyXdIpUlRhCcKrxyukS6ZwP2+1MOJ6xwEN1uD3LdfhQMkBhWZWytDDOOSDCmoipDXQxhV4ZYFaLY16E58NErPzrh7y2JiGlY+P2WZrx2qQetFrDVCiPRZomQ1Q9LbOEP051V3ptMc6WgNBdrrjmPSQyx8Aaotc/Bnczonk5AAdw5wNoPZ1x9qy4ZnZRQD1P/CrRkENGcBXCmeuFijAFLXDMsh2kkWPFjy/R973uftFXfbSVwsMSP/YoT1xXlZt1xZyFmBJEhSFomY8Q6izODvZhTJPvtN76N+rZ6vNT00ozxgxkL1OVwjJotMdvwrsRZAq/DixXOFWhKNMlk0uc3fh7fvfG7M/q1jAfUABR43OhHPrzpJBZYurRIaSnAtOv6+noxxSOZIMGYCiLDKARGEdjBlZycYoVo+ZLlePu6jMniRINjtJ3HnVThoEIF6hQTKxQTaQs4bimQDEFVyVQnwCk8BXfMq8B5D9u9d6hGhi8xd0jV5VTg/Rd/GI5tP0JSrYQzPeDBQ8JH8jODwWofP1t2JAdx23QfVBbTihlDZLKYWWDSdXeiG3lqHjriHaMmX88k2Nqch44+hPpgvUxblbpKcTx2XFodFPly+iqqR8+7aaTRQPHid1fMPTGJ8bYTROV3v/udfNmzvUQik0hkiN1kwyZLL7300mBFiIhEJs+ojnqJDckavNHVhR7VED3McQNgHrl4VVsmCkwdt8+tQHM8dWGdsZ9rSCX1M0omDDHlKYIz0QeVYv8ZDE7isV16QSWnZ3HOyPZushhVb/JK8ytCBJg/VOgoxKbmTXjPY+85J9fbqSAzj7znEfx/l/9/MnXE8EpqfZh9RH8YCiPpUHw+aH7GA9thdOT4pj2xRMdqgj4qdsr7VJAZ6he40Njj35O96NCP44qSXKQsBX1QkVBIohS400lc3nAA9xa7xeCMlvEXDImZCHTuh675RWPjjndDtTix6Mq0lmYoSNBHOkVnkUW2IpPFqL4rEihpRNCr94qAttpdjfr+enxrx7fkcTNlvHq0468P1aPGX4M+nmFClSmkUm8plhYtHWaGd6HCbvEw54iVEbZ3JjtbyQb3VVlZie7ubiEwbAGQ2JBIbd68WTxlOA4+ka0uCp+ZhFyqmOgaSCu+2KngTxN9uPnqdaheee5OwhccGl5HbNcBhBIlyHG2AbQSIgH0l8zY1lKWxGQxFrJEJothYNuFixFJDJOcCWpOutPdIqClUR6FtTORyLBa9N2d34VqqVjqXYoGvWHQrO+eK+/BbAFJAhOwm5qa4Pf7hdBQN3MuGA8RYSWI+pgVK1bI/u2IgpKSEjz44IPiccMqTXNz8+BxTgTYXosaJooVID4g6r24vBgff8vFE7L9CxGxjU+idbMPRn4OIv35qLqyH751lwA3/+OMFPryO4mfr2w1JovRkCUyWQwD2y55rkxOCbOTnKoThmkMCmgZMnk6l9/pqsR8b/f3hMQs8i6SOAL6xgT1IA4GDmK2gVNDQ1s6FP+eDradPx2Ch1ZveDsNI2234JaWFrm9oqJCwiGpgaHQeOnSpVINWrBgAd7//vcPbovXrAzxMb29megKPm+iiExzMoWUZSAsuhhqoTLZWlmMjXivE5auwhlth6FriIfz4ZthJIaVtsc6+0TEvKEwB1cW50/3IWUxQ5ElMlmcZCjHRYDCWBKBzlSntGeW5C+B3+WX6IGZUo2xjzeajiKejsu4eEyJYV90n0wsuZRMRYlEho+dKcc9FSCh4Oi1DbZ6TjWGTbLC4FQ7p4lExCYzdpJ1bm6ukBaeHXPslQGrrLIwQZ6tLN5mP2/oRAnBMWy7QsPnsFI0UYvdwx19yKGQe2D83K+p2JD1EjklvNfdBvWJjTDCQag5Grwf/NyMIzHMR4rpOuvAeK2rD/92kTNr55/FqMgSmSwEXOipfylxlMjPOWoOwnpYhL7MHiKJuf+d98+Yd+ubW7+J3x7+LSpcmVFapnR3pbtE0EvQN6Y33YtKZyXa0+34tx3/hqZw06xpMZGwsBVEcMqDZflTVUFIctg2YuWErSg+1iYinZ2dw8apCTuTjFUWtq14O4nKaFoc/nzzzTfjxRdfFJ0DCdEVV1wh++R+SIR4XGej4RE/HdNCuWqh3lBkEvmOyqLsgnca+C6/HFXf+nfE9x8Q2wv+PJPASkyfbqBMsWSROp425LZsLlEWoyFLZLIQUPdCMhA1oyLu7Uv1CRlwKpkJgUJP4YxqIz1c+7BUXQLpAKrcVWhIZPQwPGYHHPAoHjHIi5gRlLvK0ZXqEuLDlO7ZUpnJy8uTNhDbTHZFZChIJPZu2QIrFkdXOgWP1zsY8MjspqHtJm4jGAzKbWxZkXywTcTt2iDRYStpNNgEihEGBKs5dAEmAWptbRWvmw9/+MNnTGbmhAyYaRNRzYJlKXAZFvLDI2z5sxgVJC8zjcAMYqArWq5YYFPbslR0pDIJ6ucL7NYYXabLXU6pEmaJ2OQgO349gHvvvVe+oD//+c9P0ls9s0Hdi/isGFGpZJAEUBfjVt3waB5cWXElZpIgmb8rCpA5Xt2ROpHhk+PMkdtIyAjmRpHEWAP/kbDNFnBaiETBFkiSeNhj2CQxzz7zDAKxGDrTKTGktPOZCFZNCLaLaKxXWFgo+hhWbHgf9TAkN7yPFxrxDW1HjQT3S/LS19eHnp4eEfzy+SQ/dj4UqzNnAgZE7nymEaZhIE8hibWg6SZy6zK/+yzOX2woLcBcDWi0VAQtVVyaK9zOQYLwnSM78OiRB9DXtw0zEXZr7OdtATzdE5LrO3Yfwz/UZvRlWVygFRnLtNDdHEYikoYnx4nSmlwodOScAmzfvh333XefBEfOVrBKwdYLDeUo7tVUDfPz5iMcD0M3dPxk/0+wrGjZjBhdpiC52FOMrngXUkZqUIhMEnNp+aXY2LwRxkBYXom3BIF4YLBaMxOFypMFTgvZrSV6yrAdRGJCssEKCMkLCQr1MyQUsYHqCoMmL7roosHKDEkj20d8DP/NbbHCQrHvaOLg0cDH0ZiPpKqoqEi2S2Jlt6p4OwkRf25sbBzXdhkQuatYwXJXxtzWgAL9hA/ftC1gvz3agVg4jQ3lBeJxM5tAcrn7hWbEwyksubx81DwrvkeDRo4jPJAItkEv8Trx6QWV+GZ9J0KWhflOFRuK8/DIoWP4p44AItChoAp3dD6Ov10NFBZegZmEx7oyrbEa1RB/o5ClIG4p+FlLDxZ43Vk/owuRyLQc7sXOZxvR1xGT7BRVU1BY4cO6t89D9fLJTailePEjH/kIfvzjH+PrX/86ZjOoH2Hr5aHah9Cf6Eddf51MAAWsgARJUlg7E4gMj+Gfr/lnqczQ+I6+MawmMRTy+cbnMyLfgamVt817m7wmVmJIYmZLW8leEFhBYUvIFtnaxMEWA7O9k19QgL6BaaLS0lK8613vGiQQfDzJCy/cHjUuN9xwg9w3UtA7FliNOXz48GB1KBqLIplKSiuTvzfCruqQYD3++OPS4hopOh4tniDU3QmmDQUHukmWoiC8cGKExGcKLtCf2lOPiJ5CCgpebIkj2B3HR29ciNlCYp764T7oKR11BQ48ursZb0d62Ovne/SZAw2IGAZyNA0/XDV/GJlhVZCVP5Llu2vKsTLXP0h6ynu78B+HatGTX4Ia1YMuKPiNcSsu76rHe2YYkcl8/1jwWUDCsjCHGi5TFbL9Sm84S2QuNCJDErPp10eQSujw+J3QHCoM3URPa1Ruv+EjyyaVzHz2s5+VL26KEWc7kaH25Id7fwjoQI4jBwXOAmnbcOTanmSaKRgr4PEbW76RGRmHMTixRII2mwiMDVY0WF0hWSeJ4eLASgiJBSsq1KuwKiKTSAPPGUpOnnrqKamODNXHUKR7JmPT3NcDDzwgWhqSKS5S8USm8mMqJrxFXqxduFa8abjf3/72t5nkbFU9SXQ8Eo2lThwvc2KRYgwa4XkUBW9ZWIzpABfcoKFjmQbUm0DEpeD39d14a3WhRClMFU5X8ZgssEKWjuvoXeDEU6t8CDmAbckgFvVHBo+DlYqulI4SxUSnbuJv9x7Dt9csxlX5/sG0dtuRmuDz7Of+eP9+HM0twkpNRcACYmIZ5MHLycV4D2YWqIf5TXsAjZaCUsXCMTNTKuSnlDEZWVxARIbtJFZiSGL8Be5B3wuHS4PfqSIaTMn9c5YWTkqbiZk0O3fulNZSFhntCUeZeeYcToaFDJC8FDuL4Xa4peIx04kY22P5Wr7EEhDnaybLWJ4uZwI+b+XKlfIZZyWEROLIkSMirr322msRCoXkNlvgy6oICcWgEHjvXhmTJgnhZ4L3k9A88cQT0noaz3GxlUUSRULF1pIdn0C9UndhNz75gU8OElK+Zl64LxIePmfo72/kAv2j5i74VWOY0O8yv3faBJU8Lk1R0GUBLsVieUgyGLnATxWRGax46CZyHOpJFY/JxH5Nx5MX+xCf44DfB6h87RbwL8fb8KVFVXIcHYm0kOYcy0KI00g68Bd7avGDFfNwZUmBEJmx0J1bgJ5EVLZ7kQp0GBZMS0Eq5R32uP9t6Zaqx3TnarlVFX7TRLOVITEuRcGdc4qz1ZgLjchQE8N2EisxIxcc/uzxOeR+Pq5sXsakbaJAseFf//Vf4/nnnx8UG852UHvid/rRnzzhAktdSYWvAk6XM+MxM4T08PEzodU09JhYNKII2MbSwqU438DF/LHHHpOKBBf+devW4Z3vfOdZbYvaFpbr7fBIkgMSl1dffVUIhn0GzNvsthP3yb8PVkZYsWF7in8jfD79Yng/W0WnavuMdGQdOt1EcuzwOHD7tbcP+/yQuPHvnmfmNplZvnw5NveF8aOWbrzal6kc8ZviLYU5qIsl4VYU1A64+fJ/84t8mC5woX6b4cJOLY5eVjAtoCRmSgtsqnBfUxciqRQ439OVUqdsZJkE6mtWGK4lThZ0sUYBDsrHScGuUFTIFUlVhccpCdu5CqtnFlyWBbcJ7Imnsf4UJIa4cV41/rfvGNpNC32GJWnn3WkTFydIiTKgmPbnLd1Cbl8MZG6fKjIzlGiz8qSZBqJWZl0rdWr4k/JC1Lhd8rjs9NIFRGQo7KUmhu2k0cDbkzFdHjfRYFm9q6tLFgkb/OJ85ZVX8N///d/yJT80wXc2gIvKd274Du4/eD+aQk3IdeXicN9hhBNhqAkVD3Q/IGJgGXFWHdLC+Yu1fzFj2jYkVvmufNHzEHQopoHf+QYu6GwBsYrCRX3btm0ikD0bJ1w7d4nEwCYHtlcMQeJgV2T4b+6bWUk1NTU4dOiQPIckiISH49w8HhKa07V9bLByQ9JjJ3Bz25ymGq2iY7fC7GO5/vrr0VVUhnsO1KMxrSMOVfKU+kzIJAiXiDJFQZLLlgLkTJMR3h9378PLx1uxSPeivKwSpqnQ2Agqp6guKpjSasyLvWHQBrJQATot4GB0apLPuXCHFQts6pHAHTMzhLVEzVR1u1JpPPjyZriLCqEoKvpYsYCCpAL0KyrW5p9e18TF/0uL5+BfjrUioZvoM0y8p68VNy9eO/j6f9HSgwLFQtDKiL9J5KaCyJzQ/pjyOZzvdcEDC7QTJXrSBn7a0gOnBThVBavyvFiZ48WGsuxI9nlPZDidRGEvNTFsJ40Eb+f9fNxE46abbsK+ffuG3fZnf/Zncgb4xS9+cdaRmNG0J3/90l8joSegaqq09ipdlfKlxIkg/hdMByUWYKZMM/EYvnXdt6RyZIt/Z8JxnSlIGkgeWAWxp41IvM+GyNjPYYvH9n3hNBP/zf0M/ZyTqHASyZ5KIii+5XPYjiJ5oQCXZIPHxJYVzfLYfqKvzGjkhD8PjSs4FfHhfRs2bBj22L8/0iwkZpHCRcFCj2nhcgfQbhgyqUQ1RaeEaUyPER5JzN+2BmHmFMIyDJQEupEq8SLNg1NUbNLSU3YGTjKRpqCa4/OyiALB9ImR+kmFaOiAHmhQYaGPlQgFKIeBGliiadnf3Ye8tg4ULF+JKhXYZQBpRcVdlcXjfn9ISlbleLGxsQWl4X4hMfys8O+FpMWEhQWqhR1G5nNd7By+xPF38UTrEThS9ViQPx8Jx9wJ0RLxvY+m0mDdkblfcT0N0tciGMhRgIClogAmWOtWTGB3MIrtwRie7g5OafvvQsW0EhmOWHM6icJeamKGtpd4JpiI6SiZ45fHTTTohWGPmNrgF3JxcfFJt89W9CYyydftqXYJkAwZmVJtrpYrsQX0mtHT+oyZZjqVCPh8AlsxJBmslNjCR9sD5mz0MiQlvDz55JOiB+O4NaeTuH2SFGpf+NmnkJcVnJHPs+MLKAq2W0QkLqzukMiQDPF2kqU77rhjVDIz3uM+6bEKkICK/VamDbFcBVoMoJ06FEtFuWoiXzHFa4RRBbeVFkzpoiDkwePHHBWIwoFGt4JSS4GmmMhTTPQbGZfaqTimcCgMp2WiUrUQGVBvtyWnhkixEvZ0TxB9aQO0XWQdgmooLuC9liltoEhVpRCrSgXYbiowFRW5Z1FFywiAlw+7jZXC5kgUfgU4ZAxoLQF8ei5jvTPg+3D3vlr0p3RYqAH6LHjUVpS53fjuirljvkecxqLOiS3Csapr1P6kYCFPsWBCRZ4FxKnrNCwZO2D3k4U626qRVSt+tlnBYTsqS2TOY0M8nuVzxNrl1kTYq6cMEQDzmj+7PJrcP1V+MlkMB9sy9GghYZHJpQHQZM4mNfJ7nEHTTDMBXPjfeOONQfO5MwXPMCnCJaFhBYQgaaDF/7mAQl67AkNTOm6bRImkiS2fsSo+dlWF1UpbjGmTGm7DjiuwycxEgqX3MpcDLkuBogNWk460AZRISylDckhitIGFk4vCVMKbl48EFNRZgFcB8qlEVYDFKhCk2JcPmqI/D2pFFMNAo5k5FpZJkqZ1Ru8JhbIf21sn11z4f9jUJdenAxdiVha+tLASX18yBx+rKpYWC91e0lDRZipYmOODJz9PqhaM9iTReN843G4z3jRNcj0W3oylsD+axErVRHzgDb+lJG/Ytu9r7kJKN1GiOgDFiQpVRdKy0JPWx3yP9m5sxlP37cOOpxrw4i8OjXkMPAdPQUWNkhGyt1gK+k0FAWhosTRE2ba1VGmP8pIcOGnne8SKUBbn+fg1R6s5Ym37yFATw3YSKzFT4SMzFJs2bZqyfZ1PJnl/OPoHcfil4Rw1KN3xbqTNtBCYfHf+jJ9mmkpw2ocOtqwosgXDVsmZVlFs4sAKCgkDK5UkEBTgnir4cTzbvfTSS6UqQ5LEs1j72tbJnOq5vHD/dmaSTV5IhuxKjS0YnijYC+SrdQFEnmtFeWMCjSUOvHaxD94SDap40WjwaCoKHNqULwofWb4Im/YcQ69uos5UkKuSxJg4ZJJYZRZrYiqqIrdUV+Dl17ZjY8VCRPiZYaXCsiQdfDwgefmn2hYhhc8HQvCoClxq5n09VcVitFFpgpWWbx5vw85QBEtVC3t0oBcKeF5aoEhBRGIHTvXekDg8+78HkIylpapRUOqVNSG32CPrBDWWzRVO/N6MI2paaISCMoXtWQWfqhlejXmtLyIUJ2lBjuc4f0f0R7KsUT83v9pYhweOdyFvpQvVjSksCeujTqBx290pXXKh6kwOSGRuX+h1ozOlI26YQnSudHmxIgr05GkIe1QRPmc1MhcIkSH4weSI9XQ5+2YxNqpyqiQwcn7OfNRGavGhFR8SUe35rkOZDLAC89JLLw1O3hCjhSiOB3zOggULRBtTUFAg00e2ZuVsiQzB6ScKh7du3TrYumJFhSSJdgSnC2+0HX1ZeaGhHsexbRLDFtVktGVlgVyXg7bcPNTu6AL3ULLAg1/GwljuBlIJExfl5+ADqhd9v6vDH0IpdCy30Fxg4crSIty+YvGEH9PQY/vx2sXSPnqgoxdh08IBgy2ETOWKVaJHOvuxMRAeFxk4F/D39r64ju0dQSiKhXmwUG9p467I3N/aAwMW8tkSggKPZSCkZ4jp2bQ/+Ph3leQjFE+gNq2Dpz78HwmeVzHRYyl4rieIl3vD+IdFVaOKcvn7jrE6n6NAT1jobY/JxUZTmRMPX+VH3KugSOG4tyLbf09hDi7xOAbbtPz9JAwT6zi2bQFHRMPDbzAFH646WaPz+P52fC3eB32BE14VeKPSiQ/vTOCdIybQSGI+f6gJ0NPiaxMlDRzQC11VmCNEZTo8fWYbZgSRIUhaJnrEOotzB0kLIwsawg0i8rVHrrPk5WS/F6ZNk8CwEmOPHY8Vojge7xiSF7aU7HFk4lQ+G+OFrY+xje7YxuI+OF3ECSdWbU417m1XZ9iqonaGE0k8rre+9a1n7XkzHvBM2D4bdvVH8IdDURxOmqhyaLhDcaHjZ7VoLAKeWuJAm88NZ9LEo42ZUfzJJjO8LPZ7cG9dO8KGhVIFiFqcHjLRO6C3nWwtBBfVe/tTiCqaTO1UiBAjo8MYz3MbEimpKtCMQoWJKKfc2NYco2JxOvCzu8bnxM80DT76vZiZiR7qaCKmhbmKgW62W0wTXzvWJiLesd4fIw04vZlWHUmCww3E+yzUz3Mi4gFKRZmiIl/JCI1f6ItiVzyNS1UVbwajeLqrV+47aKrI1GUyuoo/qy7BN5ZUn7S/bZ0hRF0qlmomjpoKDJeCrquLTqrGUCOVTKdR7tSEmLlkWg3Id2iD1ZYsgZlFRCaLmYkjvUcQSUXgdXkRToXl5yyJGd5G4hc2wXYLyYH9sx3WOB7YglqbFFx88cUSsEjYJnKs9NDQ7lzaS6y+UKDLY7Tdeu04ABIwVlfYehrPuPeZTCRNNLg4sMJhn+163uzBtmIFD13iQ44HIH3spjYBCrZ29+L2FZPvesuKgrOuA/+c1pHjUlGgAu1mxq3+bMnAmRwvH9evG8jnos4QTdmzhiPRhLSNTjWGzOdyee+0VFQrJophITRgs7/OpZ7xe8W/BZLv9aVF+I7TJdt3qAq+U9sm0RQ+BeCgfZViShUlbFmjiqKXXFaG2h2dSEZ1GBkpFhQNSMcBp09Bfr4iCdkXq0CzZSKTqgbo1AaF41hfmIvHAx0oMXQhZQwzsUVL7yjNH5XEEAWFHpj9UfQPjHHzDS2uyjnpd7Opux+GaWJfwkKpy4HPLSyXfWcrMFOLLJHJYhCx7dtxdPMz2JLfjUM1Ckp9pXiz800ZteakUgc6JIdppvjGTCdIPDZu3CjEwDaLI0gIbI8WXpOcjMc4jp4sdquHZILeMbYbLyeK2LbhPrhA8LHjJTJDqzwU9HI7/DePmfobG7Y9PMkSF6DxtrDOZCJpojH0bLdtbhpdtR1QXUCJCuw2Mi0GOu2yvWQvPJ/eVTvo9XHfJUsmlMy8+dp+NL30OHLXXIFIYSEWKUDLOZABO0GZ47x+TcX/XVBxykWSt6sDk0J+mHAoJAoG2izttPk+fK5PVZEwLVnmD3PEhhofw8At+gCDGCdsDy6byNu/p69sPIpoWscSJ1BrMfKRolhN2mCCUZQErIC88zOrpcXUdqwfve1RMA+Wz0hGLOw2VPHL4Xg3m7kdpjqQcaRgTihzQmGqCg5YmlSo+L7w1VAHdEXe2N41+52GRAvEBlpQXlU5abpqbzACj2VB9bgRS+qY53ENOgpnqzBTiyyRyWKQxNR/8W+RTMewTNXx0s06XpqbuY8j2CQyDGNsCDZIFMBsr8rY1vscQya5oDcLKyisnvAL3CYk4zWOs0MZuU36udhuvPyZBIbbswW2420v2VUekhRuk5li1N3YlRS+BpIWHvvBgwfR1NQ0uP2hY9jnA2TBS87DS50diFtsM1DIaWG+2znYVvqfvUc4DZtxfzYt/GHfEax/y6VjbtO2ul+ra7ipVznl+C3B37Ol6LjIiOMwClFrADGocJhnTgbsKZuErqNIsdChm/habTNyHQpyHKOPC/Nnkp1vHG9D1FSltcVqBSszTYnUKUW1vP2KAj9e6AkOqHsyrGJtXztuWbJ6XMfLzxI/r/z8j/ThomjXeKMbpes8OO7IkEwa13VYJnRTQelAK+Z0LUU7XZthnKGeOFMgpLLTKmRGwTzFRG6LjsuOpdDa14enVnbjmmtL8QdNRYdhoEpV4TQt5DgcQt5Gq3hJpaU3jHxFgf1urMn1Drv/1eM96AlG0KyaSKZTooXaNlDVeql3ah2Fs8gSmSwGEN9/AHo0goAvgULdh1XhXPS53PCpPrH8b0w2yuRSzIxJFMBsJzK2ZsUePbYdc+2KzNDpnfHkPfExfD4JC59vt6dskMRw27YGZzzZTFxYeXys6LCNROJCIjNaJYXVF7asWIkhiTkXQfF0oaQ6F6kAM5FN5KmZiaG3l+RlzPtCMRw1MmPRx62MPqI7GBpM9x6Zz8Of761tQRIWnrMUPNhv4J272/DnG5aNSWa8uS6Y7Sa8zQ0I5JagwOWEy9BxXWcDbrn28jN+PQFOvNCocEAZ4mflQg8igoIx9Ta2Ydw9R5tRG00iZJlYR9+WaBx376vHT1YvOOl5XJjZ1nkzFJV4AbcUY/j+Wbhm2ZJxVdzs6Td+fkf7vHPaZ0HAwFu3RPHQFX7oXgWdJvNpFRTGDfydZ/io9FgYSWp2NrZjo5IQt+ckFCxtSODafTTxVJBKW6jf3QNffQj/ceciPGzFUR9L4DqvE3fUVOCJ7n78pi0AVVFQ4nQMkkO+t3w9XrtSBGCF3zv4Xn1ubz1K0ik08iRPdFAZUTdfS9hSkLCyCddTjWxFJguB96JVcPhzUByMI+aMoLaAgWxO9Ov94hvDBnOps1RE2S82vohHjz2KXGeuuPrOxsklTucwVJFf3mzT2HoWO2DRBkmHHcR4KtjC3pFj0DY54n22E299ff0wnYydzWQHLb7tbW9DdXW1tJH4HJIgVndOR6hsA7zzFVyA2AIIGDRhU6R9dEtliSyue+JBtEKFbpky9kt3nuRA5AKnjX7W0C7i1n19QcnIeaKbhAFYypFay0JvsYpf5LiwsLEXdy4plEX0xcZebM+z4CtwSzXhimvWoaHlOKrD/XjH0d0wV61BwuXChksvOSUZGEsHw1bGjoGJowqa61n0zSlAiZU+SW8zdBsHInEhMQWKAW7tsAh/gU7dEILzzaU1w6oLtNaPkyjDFDfa0EA+UJ7DIflGpwM/d/x8jUViCFaz3D6HjDAXxS1Evax2ZB6bn1Jw07Izt9lg+vmWLhPFKQv1igpX2sLiTgO6DNFZ0FyAkQLSCQM1HWn87OZMlZF/n79qbMcvWrqlKtQj7aiMlwzfF2p5+PmgEJng54hCbnrqNMYTyDENBFJAnBNzUgnShrXFsgnXU48skclC4Lv8ciz412/jt49+HZty2tE4141gultylezcIo/LA1fKhf09++U2ji7u6t6FF5telGiA2URmuDCtXbtWxqNtfYwN+8t8zpw5uPnmm8d1RssqyLFjxwaFvcw6IgGyJ59YXdm9e7eQJlZsOOZNXHLJJVKJIWGhnoaVF4p5Fy1aJAZ2zEviIsOqzHgI1fkMLkA8O+5WVRQqGU2JvWCLfkRR0TNAMuOKgqg/RxbfF4Jx1JmqVCJSpoXX+qKY49RQrgCUQ3Nkt82yEHcr2KYkUfLjPXi1I4Tfr/MhHlZgRNVBq/kP3vEB+X10FpbhPwIxNOkmtvXEUTFGW4eVn/+ob4dhKShwDvdrYXXlj1192BcMi2Mtzf80GHhbwXC9jT0CTC1NjqagggaCsISUcE13KyrcsLBGMdEWS+Bv9tXhOyvn4crCXOwJRiUpO24BHnq8wJLHEn9SNrZLsl3Bemu+Dx+uLBp0oB4LrKLcdNcKqcwEiyz8R7BPDOToH/iB+SVnlUdF4hFKG5LZRC0U7XJbczSUKGkR0ZDEkGA4Pdqw4E7+fT4YCIsDMjVBRNo0B8nh631h+FRLhOJ8TxhQ+uPmbiTTulTFAjRj1GimJwHnw0gMdUl3zSnJtpWmGFkik8UwMtNuXI49Rx6ElTmtgW7pYoS3pGAJDnYfRIWrAuWucnH8jRgR+cKIpqOzst1EYkDyYadUc9KHAlq7InMmkzxDs43Gau0wG4xfwtS0hEIhMaajpwv3w0kjVnVYvbFHvrnvP/mTPxFiM9VTRVMNLubfa+yEQ88kDr+9NGfYYsIF+c45xRLcx8WH9NwWb7KdRF0DFyYuiOuL86Q981iANRlVtDY8O9eo6WiMoHF/BLEVHlzkpcGbhX6YcOs6DvWFsK6qUkTVf76/HjlGGrRkSxoWftvUjnXeAdHZAL7d0IGH2ntRziBMS4Wim5lteE9Mu13pd6MtFJGxaA2mJBnpyMXm7l6sGxCr8jkeQ8c8twMdKUNI2EGFuhE+NmOLLyGNCtDDv1fDwP5wHJfl+bDW58I8pyIVBsp8WU2groaZRbkUxg60TodWWn7T3ovv1LfDAxObe4N4JRzHTy/KtCzH0xa6mFWYFt+wVt7ZINoTh5rSEXVSX2Yhx1RQ0HUiWyq3yI15q0tk8mkkUSpxOfGmCVSqimhmLs7LCJJJ0J7rCaFaQjcVFDlUlLucOKBHkGvpOGaoIry+rSAXJSEDPbkamhwm+tMGFvrcYsKXFfpOPbJEJouTYgleanoJoRTThRVcXXU1KvwVePDwgyhzlYlWpsRVgkA6IFbcBFOw6S8z2zAy5JCxBCQ1rI6Q2NgmduPF0NbOUM3L3LlzZXFcvHix6FzYDmE5344tuPvuu08KW7TBFhOrMxc6qPEIpJKokjwbDU91B08aOeao7QKv+6QF1L4eejuJEbUTXMzpDyJebpaCJY0pEUR42nXsq3Ej6lGFzBdaClYU5kllgs/dGEpgjZqZIKIEdE8803qx8Yn99Xi+u1+IBu36O7gP3cJx3Rz2uCNJA62WIiPKxZLqzGpCFI/1xXBjUS4+XVMm+0109ONgktNNGj46twIFXo8Y3PFvWLU4rWOhUSITFBknvqggR0S560sL8Q2nE9+sa8PeYBQ1qiX74mVLJCnHMrRVyn/f19oDr2WiWgO2Ghj1vT4d+NhzEcPyPf5loF80T/UpC0s703iP6UFBSkXKpcLlceDmP1s5ZqWHhGNrfxTdhoFFThX3zC8b/AyQxDGNiWA8hs80Mg7JpioLJsnuqoo8fOaKE87BWUwvZi2R+ad/+id89atfHXbbsmXLxBRsNsNOkGaFxTa/+9yLn4OmahIeSfJCEkNS05livm6mInP/wfsHnz+bMFQ0y8kfVlRsIkNH3tPBJiz2c+xqCjUvdkvolltukSrN5ZdfLm66tuCXLa2hsQUjKy6jCYAvVHSm0hJGOIetJbaBoODRzr6TFsuxFtCRt7Nt4VQUBEQ/kekevD8nB0uiEcTSQE2njvduieJgtQsOt4q7LzuhO+FzLcUUAWhmjgXIH5LCzEX/2e5+lCmmTNzQPI+tK5KMB9p7hwVf2tUiajHaOVKsGlgK4Kip4pmekCzGP129YJinjj3uzO3wtq3BCJ7pCQ4szcCNxcPHg/nvAo73Q0G9mWnPEbax+tBqzE9ae9CUTOMi+raYfL8zuUKnG++eaPB1xaQcbMF0KZgbMLCuwoMln5x72oBH+zVT+Gy/Z5f6XKIlq/G6JDmcBJTTXulkEo8FdCQVVmIsITHTEYWRxXlCZCzTRFdDHeKhoASxlc1fCGUCXExP1xp44YUXBn+mODKLkxOkr6q8Cq+2vjpYgeFViaMEmvypZ4jNS80vYV/PvlmnlRkKEheesbK9w2v+PBqZGEpeGBXAKg7JCYW8JCgrV66Uf3O0m6nXtuaFz7/pppvw7LPPiqjYXmBG83zhPh5//HGp2vBxp8p84ug9p9Yo+GZ78XwEy/+7oAxkHGXAisrZggtVicsBpHQ5Q6eNPSs6bYXF4mkS7U9igQK8K899UuuCzy1WNdQOOOryKFb66ZeLIWf9GfM5btsh/iYQcbFuZUIeh+pkiPvbenAkmpTx8bYBi/+opaFPN3BfUxd+vmbhqOPYvKzt98nUlu2fwyrOSJAwPRcIwQlL9DL8Iy8c5fuQx079TbOloNdSpeXlsCwUJU7vHjyRoEeMM2kg5FHgTAFzY9bg72G8epuRrrskMsF4An5FAZt7noH20gK3E8mkjg1lBZjvdZ+x2Z0txKaGK2uWNzmYESt30/492Pbo79Hb1grD0KFpDhRVzcEV7/kA5l60dtL2S+JCjUEWp4ZtgLelfQtaI61oC7dJNSaNNIJ6UPxliPNVK3OmlYuhRIQp0iQKJMVsJdkj1AQfw8km6gxIbt7+9ky45lNPPSW3seJiEw1+FlnqZ1WGOhveThIzVPNCkLDwdmpiSJbG8nzhvmWE1OsVPc1omU98HXs2bkR0yxbMbWlFxW9+g6p/+cZ5QWbskWFJmvZ55NqhKOhnSrbUNoaTh3N1DrYXrvEulDcU+PDHvig8loJ8pzbMTM2usmRijBQELAv2rJpXPTkNmWTmWDSBumhCWktMT2arqAgmeqFiY1/4tB4xFCKfyiGY+3i4rQlNsYy5HN/DQlHWDAeP/WBfEK0DvKXXsFBtWXiuOyT5RO++qBJTAe21btzRF0WgwAFPm45r5hSclWB4KP6poRMvBoJYqwLbTBUBU0G+qqA9qYsuhr/DszE1pBCbFUMmkbtVRUj3ZOduzTY4ZgKJef7H30cqHoMnNxdehxO6nkZ3U4Pcfsuff3bSyAxzZWyX0/Xr1+Ob3/ym6BGyGJ3M8HLnU3ciakTB/6pcVQgiiJSVCUj0O/3nnVaGbRlOAJE4kExwEomVlJEVFD6OBIO383PDigjJiE1AOBJtExhWWHh2x7YPyUpubq48t6OjQ+5n9YUTRhy1JhHh83jNEW5b+zKW5mVo8OOphMF8HrdLEjOSDA193eL9MW8e6ktLcf2u3Sjcf2DGE5nMyHA9ulKMOOSXGImLhWJ68YiGQUXhCPJwNjibnBx74fIauowv31qSf9ICOFSTQ6O6Vjo6k6AowBK/Z/R9ivZHEa8SghM1rJ7wtSfNTObPqY51PK/lU/nHcE+0HG544UUc17vZOh5uGPhnlUXi9vtSMIZIdwx70kmUmEC/Zkk+0VQQmb0bm9GwL4A5fgVVgSRSEQtBZ2Y44awIcVcfOpJpvNITRIGqossy4YYpZoaVrQlcV1WAWy+qOiviQbLdk0jCARMFCr1zFPSkT4x6Z3EBEBm2k1iJIYnJKSoeLJU7XW44ilyI9Abk/pqVqye8zXTllVfi5z//uehi2tvbRS/zlre8RcZcufBkMbYYeG/3XlABwImmtW1uVLfE0TM3H5+56/xqK9kxA3ZFhMSE0QCsqvA2imtZ9SBx4TUvbPOQhNieGXweSQoJAVtBJCT2OLZNUMLh8DAywUpJV1fX4HFwu0P9Y/j5O531/+k8X/hcamuGTiwNrSTZJIavJR6LwdI07FmyBOsumvlElItAJG2gDKaMw7IVQkKTkJBDTbxkPjevfFoWCh5bmg6ybgd6kqa0IsaqgPBy6+sH4TYtVCsWDlmqCG5Hq67Qp4Yj3mwP8ZswZpjoH3Cdlf8/occ9a1xftgBf6L4PtUY5lmiduL7s0yc9hsT8rrnl+LiiSAXmi43tOKxZMqren6udsjI0EaB/z+ZHjsOTpyARNOHiXLoC9LZFheCsubHmtNvg38HzLR143pGDrQkDSSszcj5fNXHEzHgQLVAt9HESKmKi+rF2zCP5PI3kbaiXT0d7hxCk1yyHTKXlKcDugdiHoaPeWVwARIaaGLaTWIkZaaTEnz05uXI/H1e+cGLTa2+99dbBf69Zs0aIzbx58/Dggw/KFEgWp24z/c+e/0HxsU58cm8N3I0tSO8MYUfFL4G3nz+CXy7qdgXEzjXiFzXJCSsutvCbn8XCwkJZ+El2SExIRvh4/tsGt2GPqxKs9LF6MrKyQn+XXbt2yeO5be7LBltBNNs7V5AcDZ1YGhpXYFefbELG2/i6A4UF6CotxUyXBXMR4IlNJ+eKLQtVMOFUThi5cciGWoTpAHUQPlg4nMhUZE61YFH0uzeZzJCAgds4Aj5adWVke4imd0za5usc2bo6WxQWXoH3rwLC4X3IzX2P/DwU/Mzz82p/V9vVF1Ydap06Xk3Fse1Q06S2TXa/2Aw9ZcLBJGwTMHRAcykwkhZqt3eelsjw7+B7L2zCEzXLAVcSJfJ6LBE47zMznlkUPUcsA5VJCytbUjANSwTEp2pd2caC9ORh9UVlYj11boqJRqjiE2Tj4jx/thpzIREZCnupiWE7aTQ4uDBEI/K4yQbbCUuXLhVfkCxOT2a2dWyD97UX4GZCbHURClr70bjtJTzo3X/eCH6HhifaBIZf1vw3b7eJBaslbPvYY6i2+RwfZ4PVG26Hmhkb3NZolRX6wJBMcBs2keE2+fkbbfrobMBWF1tZ3G4gEJAvcB4fK0M8LlZ92HbiayKhEq2Oqo6qpZkJ4Nl286Fe1Kwowvoba/D3CyslUyhuUvyqoRzUmVAfA+Q4TtaZTDa4kP2ouUsyeoosE1GoeG/FqW332VriAXeZiuQpCQPjqJB1+vYQr+l1M9FJ3iQvIwnMyJiMoSCZac3TsLWpEyvcqoyA85iIjY0t8LQ1Y6mRFHI+EZ+rYGcMioN/W5mf9YwyeTAi4nTg57vF5YXFCqwJBFVmNanIpCNl4FEVLGrUsagxiaoeHe481zBDvdFAMted0pEnI/IWljo09DLEku7AQ87RczUV9yycGh3RbMK0EhlOJ1HYS00M20kjoafTUDWHPG6ywS/548eP484775z0fV0IKPOVYW+FgsTefhQE0kgU+FFXYZ5Xgl87PPHRRx8Voe7IeAC2irjY24SFpIBuvWxFsn1ku/CSAJGAkDi0trbKbSQoo1VWqE2hG7AdEmknZXPb1GdNxJc9Sctzzz0nr8muENkkjOGR3CcFw/bx2yBpG6mlmSkk5rXfH0NDsYaDjjhcCCG/xIv5XpfkEbFAUExxqtOFq/L9ZyXKPBewsvK1Y60yIr1EMUAKTO+XkaPUIzEo+lVZATDhVzNOvLTDnywNz9liZDXmpORsTRMzvnxNxbZQVEimZugoVHNwxZEjUt0cTwr86eD2OaE5FKTCmc+zQp7AKSOPhotvPn1biZ/v6oNHsYOBrM7MmlOoWGgbqJiwLfkPi6rwzjkOHPN3wFqijmqoNxIdqbRMotF3iALh4wb1TBksdGpYmp+DCrdTWoRZbcwFRmQ4Ys3pJAp7qYkZ+kfCL95EJIzSufPlcRONv/3bv8W73/1uaSeRpf/jP/6jaCM+9KEPTfi+LkQwX+nFZS/if9U+zG0zUVeRwOG5GorPM8Evv1hJQrjw21/WrMbYVRI7vDE/Px+33367/JstGpuAsJrBkeihlZexRLgkMc8///xgQvbINtREkQh+ntku4j5IuFj54TXPpvn6uF+bxNhOwTx2Tl7NxGoMKzGt5RpeucKPmJsFiySUngS6xUouc8LrdqhQDHPKSQwrMSQxbsvAwgEZn61ZSRiZ6sRYx2OLfpnh05pMiaNuzAJe65taT5bxvMbDfSEsL8jF+hEVmWETXsEoDofC+GN3vyzozGVrV104VlKFeU2HJ6TaV1ydg/bjJyr081cz3qDgtL4xg4+fPx+fu/kG9DV24WlTQRkMqerxU+QZIDH2e99YAPyxN4ynzQg29DvH/D3y/dnWHxXxNd+deloAKKrEPRRpKv79opNH47O4gIgMS9kcseZ0EoW91MSwncRKDEmMy+uT+yfDT6alpUVIC8vupaWluPbaa2Wh4b+zOAPjvFUH4FAc8IfqsQbKeRkgOTQegC1G6lfsxd+uZHCqzf4S5pklReH22PXIFOmxRLisxNhtHYLVHhKkJUuWTFjpndUYVlvssEiCr4PVJf7c3d09+Fh+1t/1rnfNSPIyFGwnNSWjaGOi8YDLbg4s8TChHkWM5+haexriMBmgnoU+Kj4FOG7SfZfZ25nPjDGgmTkVZLQ6lsAvWgPyPD77hUDojJ1yJwtcpL9wqAFOw0Syo39M/Yt9230NbZgjHjds+Z343h5tcu5swOpI3e5upBK6uPeyCnOmY9ftBSV4pSkEP3Txi+mECocJ/JnpGXzP+bo/e7QFxekU6i0VT/f043PzKmQMnp+/oZUV+QwYKZSyEiMGipnpuVtK8sWzJ0tiZsH4NUerOWJt+8hQE8N2Eisxk+kj87vf/W5StjubjfPOZ9gEhDEDI6eIGOA4lJycbqJoLIJBYTCrfqy+2NtnyCNJx0SRGFvQS0fg1atXy9QSx8BJoEaKis8HEkNQwPl2pLEtHUI6kwiACDREBuQR1CU4oIj+YMqnQayMe2/M0mQUmtSRY9Ic301CHVd1hYsi21C9poLFMHHUAr5am2lRTjeZITHkVJXL7URv0jglUeR9vQN5VXQhZs/PYZl4V1EO3nvtubeVCJKWt39y1bjce0/1mmg8SFGvSGwsYFnAwJ+vKxv2mLBhSrWPQZBuw8BP69ukzdwJZTAklKLrTT1BeQxHq/nfHLcTn5lbNu2/u9mEaScyBMkKR6yn2tk3iyxOJQC2F3y2js6VYDBygBURbpuEhl+IrJJwPzS3oy/Mqcapx7MP5i7Zgl5WYajZYcWR+7FJFC922+t8IDE2PnrjQiwaMMGjHoELTG9aF6fbtc4Q8q1WXFw09SPXbGU91tUvDrusRLRYqlRiyijitYCXe09tVkfwvqtcHmyMxZDUgELTQJ+iyVQSBb3TeUa/NteLx1QFzUlDTOFORRR5X4HTiXbGRahAhwmso45n4VLMn8DXcCbuvWMdZ75DQzJlwZQ8LeDzq+ac7M6sqQgYqnj26AzrNDLe5nmKAq9p4LeN7djSH5KKYLupwglF3KC/t3JetgozxVCsoYlgWWSRhZAChjPyT2MiWj6s8rz++usiCiahYEvKHvnm+DPJBwkGfV/OlMw0bHlC2lwHug0kUrocM8kXKzDUwrAyQ1LD7fN1XH311ecVgTkdnmvejkfq30TSTGK9Yy/ev+rTY07dTBY27DyKPcEwLlOBN0zGDijS+opQd6EoMmHFM/RT4f4XjuPvrSA4AVyhWGi3NLhUBV8ax3MnE/wM7YylsCccH9d0FEnbfc1d2NIbhM8y0WFpKHU5pHoxk1osthEemclYuqrNPX34YyAsDT8KsJmuzskkgq9prseFQ6GwtJQaDAVzFQ1/afhx07wiecy5VI2yOA8rMllkMZNwNq2jsUDdFTU3JBIUCA+dFGKFhsSDZIYLBnO/GJkx3n2TxDz47BuIwwlV1QbFyazIcF+2e7Cd/3ShkBg7nuBgNIE9QQU+5XIRWb6SXofSrnq8ZwqJDI/lQCQBtwLUSnZSRhNDEsN6Mj1extPu4uK3fGcfDpRqA20ZCJGZTuO0QX1YYa5cxgMSArZl2FJTLFM0TPRWmWlOtuOZ+FqX68P6khMkhNUxOxaD7UC2lZhh1WyYEp65alcY4doePKY2QdUUaA4Vbp8DN921IktmJhlZIpNFFpMEkhi2e+wpKJtQECQ2JB3Us5CAsDpDYrN58+Zxk40tb+5F2uFDvp8tqjCcTtfgtBXJkR0syf1ff/31FwyJofFYMp2GE3RMVUAlAg3lIvDjvv7FKJ9kd9mhkKRrGvBZbEFgcIT3+qJcVLic456i4ln755Nz8MWuLkQVC05NlUrOZLwOhoQe3fwM6iqAudfdOqbOjZ9N+/M61MfndKZzJF9+TUO7YaFStdALC1v6IxL0WNORlipFY6lzwj1wJsI1mFUUkpC+DvrVmFh8ccUgCRlJfvjvYzs68UY4hotDaVyV0pEqUZCOAaZuIRnTTzLTO5P3MYvxI0tksshiksApJZIXEhRqYkhemOVEl2B7guP3v/+9VE9IPgh7rHs8iChsIYURCgWlheTz+QdHue0Ray5EJDHnor8Zzd69O7cAN86rnvJFSOIJdDMzpSSzIWyQ82cLlYqFuriKD+85jhuL81DmdJw0YTIpLsMKZGqpm0RVUXBHZRHuXXrmixTN5Ur6cyd1gSeJ2fVP/4WAlQ9vqgk/a3oJ+Oi/nURm7GoMifCrDxzF3pdbJFa8cX/voAB7LNguxGwxbQ4EZTro2UAIL+v9KAsaUEJd6C5ywqGpKHBoMyJAka9x/6utQjz4+3T6FDh8wPEdAREXj9Ueuq7dRM3eCHzFKlIqkIpCiJCiZd6/dNJA3Z5utB7tQzKuo702CM0JNOwNYMfTjahYkHdWk1dZDEeWyGSRxQTDFt5yvJrtHV4TJBUjx7WZ7/Xss88OeticSTxB1fxlaOnaNtBSyuQ38d8cv2aFh+Z33DfzpOg4fK56H76u7zzzAh6fvwrpRAS/CR7Hj9csmtJFiAs8nXvjKXvImb4tmURoerDkKhYqLR0vdPeDkmA+5tdtAXxsTgm+saR6Uo7JqWTaSDySQqdDiNPZYrJN7hrfOIb9le+Hs8SHVFcMcxp/PaqBJck3P0OsIOx7uQWeHAWJsAXLtKSicLpqAl/D77a9iaTixzKXAqdloMYFHCjS4FYsuCwd/boK0zj1JNRUgK9x76YWqE6goFJDrC/jgWMZQCKcQu2OrjGJhr9AjI0Q6zHhzmU1JjMGpWqAv0SFnrTQWR/MmDY7FPhLVSTDJlweRWxG6vf0oO1YP975mdVZMnMOyBKZLLKYQPz++d/j4NaD8Dg9QirskWdWSe64446TiMRQD5uxkqzHAj1vWOWhiNge5+Z+WNVhRcbOj2KLYO/eveJczVRtTjOdzf7YKmvIL0a5y4UGS0FAN3DvpjdwT0XehFV8Tgf7bJ9ahZd6w2hJpKQu41YVpEwLIQugX2ueYqJKARrMTAbTT1p60J5M46cXLZjQ4+EizJwnTvSouoV5Xte0VxfsNgkXYGKoM+2xaBV0TYfDUGE4cwDn9cMMLJN1QXTv7kSfYsIq8OONR45LdSJJJ90B5si2yHg+K4mD+1C18lIcNl0yXXbIyJgX5igQF2TFspDUDZRHSfSnT9BMYiYOwaxy9hjQExBSkgyZkuN0eHM7ov3JUSsnfG/ZXkomdMl/kveJTsgGkIxY0BMW3HmA5uT2LKnYMCOKt5sZmyekE8Zps5yyODWyRCaLLCYIz+58Fnu37UWBr0CmkzwuD9KpzLdVecmJ0MgzTbIeC2xPcULJbkfx39TdlJWVSXWGZ9V2Pk6uLx/9ff144LcPIZ7MjJYz1dve/3iqMcwh8yxZg8BA2DJ9U+LRCJ59dvO4tzMRIFGg0PIXbQHkKiYKYaHNVJCj0dgsDcYWdYuvC4XVmWTpfssS74+JNJqjXofaD1PX0WxlDPB2BGPTbmZHEvPs/x5AKpGCngIObW7H3BVFshBH0m5AMQC2PhSgyFwB16Fy7N7fBFcwCfeuLhhOE864hd0xAw4vF91MDBRRsTh/XNoOEuU5oV4oB9/EK4tWi9lpF+tWFhBh0KViym9nTm83vPEgsGJiQ4HPBCRmjfsDMFKZn9n6MTianQY8+azMWKjf24OG/QGsvm4O3nLH0sHnknxULi5AS21A0rhV5kDpjN9xIR7KbDAZ4nYAI83LyUPCjFc4XZZTFqdGlshkkcUE4UjjEZiGmfGgMTP6AkKxNNQULp+0rCiOX3OfbCWtXLlSbucZse0+3N3Zg3AkgvzCXCE9dnAkdTvU8TBgkhUdtr1GkhESGFrLNzU1ybYqulqRU1CKHM0BVdexsLtN9BRcuKaKyNiBixpdfUlaBt5nimx7DPp5ZNBjZfw/WKUZ+rxzJRkkMN+sa5OJFZ5eL6EhnwIELba4FDza2TdlRIZtEaY+MzDRrhjw7J5n+XoScOex3WFKC6PxQAAF5RlND3UcDrY3EhZe+30tHE4NcxULC1wq4v5MVavIqSKqm5IsTbA1sn7D+OJiWO0j8a3o78GKjkbULR6o+iiAZlpCZnx6Che3NMMx/2JMJ2xitvuFZoQDCXlfWFnh6+VrZwVF2kZRS1pQ+WXeYWSO7aVMS+kEqH3pbAhlfg8pQyo0rZUONOc6UB0xcZnXi1RcR36pN6uRmQBkiUwWWUwQls1bhrZDbXI2p1katJQfnlgB/GYFVq5ZMmnvMwkGow6WL18+WPUZWuX53XdfRF3HAfSm+5CXnystJxrlEbymfoZkhLEd9nOHOgXbE1cUFFdGg7jy0JvoyMlHabgfFcGA7J8L11SCgYsvBkIy5swRX5KYPykvxM9besDzYGpWvJqGmGFKpYQg2eDzzpXE3L2vDpauo4iOr4qFPgbc8sx7YPSaHiNTRWI2P1orlQRWTEhUrnnfYjm75yKMJKsBFnzFirQ5+KBIMAa3VBkAzQFoORkdkdOtIKJbMnXjiQJmykJvyIThgrRMmDJNfczmx+pQMifntEGKQ1umyZolaLScKIOFXsPCRR4Pyvd3oTjYh+WhKqz8k8n72xgvSEwo9H3zmXq4/Ros3UDRnBwE2kKZ1z6Ep4zUCPG9qGV7KZrxmPH4M9EJBEnl8V3d2BqKYtvlfjQrCly6hasXVOF9F2VTsCcKs5rIMKn4i1/8Ip5++mk5I128eDF+9rOf4bLLLgzb/SymFm9f93a53v9iE9TmYrjTBfIFuGBtyaT0v22iQS0OP7808RstYXjl2qXoqA8h7QoiFAzB5XYNZkkRxcXF6Ovrk7YUt0EvG7sKY4dPUovDdhlRnkhgfjIqYZPI841ayZlssOJRH0/i5609AzbyiiRNL/C6pepCwkLfD2pYmpMpNMdTctu5Vkq4vaiRaYukrYzEl5lPPbLQKaLV+VTN1Og9uKCy6uLKUUSomui3RNPCNpKRNqG5AYdLEaLjK1IQC1iDlQNZmAcWZ+pDrLSFrjTLiEBOHOjXLQQobNEBh4fPVxEPmug4HkTHsaDkHZ1qmmcomSb5+/3e48g1dejQsC+Vwi2XL8BNvQtnlGEcq1ROv4pEyITH7xTC1tUYEo1QiuFRhHKyRojHT7HuaJokXvM1PvbUIaQ1oCxmosuj4pXjAZlSy+ICIzJk++m2CMyYDtXngLMqR5TjkwV+cV9zzTW48cYbhcgwQI+aAY7GZpHFuZCZ1bkDGgXlRLDdZIBkgxqYoZ40oyUM22ePO9600BY/KI+1Ay9JXNhuslO+ebud18Rt04+GfxMUCBOs/CxdunRGJGW3JVLwWBbKVBP7DAU/au7Cz1YvHEZWJlp4y6kpn6ahL3PyLdBhSSvGUBR8qKJoysS+XFAb9gWQimRGhkloLN1CW10Amkd+mUgGBwIs0xlCQ2guFQ6HCtO0UL28ENXLCjNjxxoQ7Iki0pNGZYEb+aEU6vd0i0ZGT5iyfYL7o0fKmQhUk6aFhQqF1yaiULHHYeD/3jy1VbzTVbe2PF4HVTNhmirW3pT5mzHTFjxlGvREpj1UVOUfVSN0qtgE3n5Jvh/b6TPjUaUis5ChYVlcWEQmcawf4ZeboXfFJcFWoWivzIvc62vgWVwwKfv813/9VwkDZAXGxoIFEzvRkMXsxEQE241rP1VVootha+h0CcP88uWloWGdkB0+jhoaEhU7m4mVHQqGOfFE/QwrMUR7e/vgdpgCPtXVl7FAu3jm4HTSCXfg58kGScpPVy/AfU1dCKR1qc50xqJiY88CRld68o/BBn+frUf7UberGw0lDgTLHKgMGyhrS4tGa6DTBYdLFSIiUCAVm6olBSd9Nvk7l8c7HMMWeFZ5jJQpBGZo9WK8AlVGAegW0MzoBkWRZOwab8ZobyaAHjL7NrUgp0JDuNOSkSMa4lG/QoIY7jAGq1cu94B30Rnijmvmou8Ph9DoUzAvZmHD+2YOibsQ4JgJJKbvkVpYSUMqMQobt4aJdHtUbi+8fcmkkJk//vGPePvb344PfOADePnllzFnzhz8n//zf/Dnf/7nE76vLGYfzjXYbjyorq7GrbfeikOHDo07F4qVFbakSFooEB4ak8DWKv/NhYwEiffZ4ZnEFVdcMWNIDPGe8sKM4HYgDoA/TwVsr5d/qG3BL1q6UD0wusv20kRPRp0KJBlNBwLoqnGi8TIfDrITlAY2pGLioCtQgJXXVOHYzi6kEicqhKN9Nu14i5FkqaQ6R4SwbGWxcqM5VVy1YeH4P9+ZASn0WyqKFVOqVy/0hHBb6dQ5MJ/OQ8ZbNGBiN8D3osGktIhcPseg9oUvYsnl5We1H75Xn3nfimz+0oVIZNhOYiVGSEyea3DKg25Cap4KM5SS+90L8ye8zUQR2g9+8AN84QtfwJe+9CVJIP6rv/or+UO+6667JnRfWWQx0SDh4Bk0RbanEtqStDD2gCZ5bBdR58LnHj16VP7eWIGhvobX1IaxSsOKDIkOiYydDUUSw4Tun/zkJ6KvYWVmultL1MAwxdhl6sjXNPl5qkDdx69aA6hUIKPfzNrpA4XFKu5v7Zl0IsMF+LWHjsHhBvoLNezlZE3MQsynwrikEGsSLoQC8UEr/EXrSse1iA5+B49Cym0L/zOtMjKm4emeIPrSBnotBQscKlpTaTx27BDWp7YCVZcA86/BdIATXzSvY9st0XsiB82f7x7UvpDExcMpITHnEiswFSc3sxXTSmSoiWE7SSoxI/6A+DNv5/18nKt6Yufs+QXNL+5/+Zd/kZ8vueQS+RL/4Q9/mCUyWcz4ZG7+faxYseKU7VA+9sEHHxysspD40DDP1siQtJOsEDk5OYPExNbN8P5M9IFPRrS3bds2uG0KgUcz+JtKUHjL8esCpwNhPfPzVJ3hZ9olJsI0d4OKHsuQ1OpWCyJCJtGZrGMhodjyWB0cLupdAF+XDtS4EfapyPM48N71JydNn24R5WfCjsmY6IV4MLKgqQvPBULQDR2qBTzUY2LeLh0b8G1UfQhTTmZaDu5HsHMzjFQBtOICRI0+ONI5yNGKpRpDZMnH+YFpVRxR2EtNDLQxDkNTYZmmPG6iUVlZKZ4bQ8GFgV/QWWQxE2FPKe3bt08uf/jDH+S2sUAtDKsrHJ9mJYbXrMpw0bInlkhwKBbu7u4W7xkSExIUknySJD6W27B9ali5IQmyhcXTCYeqIGIYoo3hNX+eMojRrYLgwORSDGomtZpfqooipGqywKqIqZtif89JpeoOHe/eFsVtQQ3/c8nCsyJQJLlDtTETDR7TVQU54vETsBQUc9rL6cAb7svwRNPd2Pvi2J/jySIxf/zOt9HX+ios/y5EfceRyG1BOP8oylar2crJeYZpJTIZTYwqmphRQeGvqsrjJhqcWDpy5Miw21hunzdv3oTvK4ssJgIkDiQQXHBIRE5HJijoHal54IJlizpZjWFbyZ5YYruVIJm57bbbBnUy3A81NMxtGpriPZaweKpwLJaAChN+aekAr/VlxsOnAmyX0C/Gp6oodGgyyWRJ6hOk3cXppskCWztuv1OM2mwsjQFfvPTswhdZ4Tn4ehvajzFDfPLA9GstZSIfmcpVOxQUegBD9eD1nZV46gd75VimArue2454OIbiZWuRsAxEoiEoNM1RDbhLB8a7sjhvMK2tJY5YczqJwl5qYoa2l/hlyUqMs9Ivj5to/M3f/A2uvvpqaS198IMflLL5j370I7lkkcVMgu2uy9I/W0BDQyhPRSbs6oqtkWFbia0ito3sCIOhY9cjtTb8G+T9vAw9W+d2mKg93RqZjkQaBr1bFAuqZeLl3vCktnRGa5fYSdUE858mO2176FQcfUsoSqWe43QGdWOBxOHFXx6CaRlIRppkFJsj2S1H+sRi/1x1IUNBAfK8gIH+ShrXZFyQ6xwaVns1se6fqgBFvubmI054cgsRajoCxeGB5Vdhakn4fB4sX7No0vadxQVIZCjg5Yg1p5Mo7JXKy0CFhiRGcWty/2T4yVx++eV45JFHcM899+BrX/ualNG/+93v4iMf+ciE7yuLLM4GtlCXYY+2zoVaLhKL8U4p8f6hj+E2X3jhBWkR2YSI5IYp3CMnkrh96mVYhSH54XP4bxKg1157TYzzppPMVHicMKGg1crEEnBCdip1MiOTqqdyAmeitBtsU6WYB6ZY0FOZKANebDdfGikSE0FmWEkqaOtEO9UEjJcg62PYZ8SSTCea+nFC6FRp0xMBvmZFnQNn7o2I9TbDbZZDi+Rg7qUeXHpdJuIji/ML0z5+zdFqjlgP+siYurSTWImZTB8ZguVzXrLIYqbqYezxZ1ZBqGXZuXMnPvzhD5/Vly23+dhjj0lb6kBpNZprlqMo0IkP5LlHHaseWtFhbg5FvwTJDI+L4vjp/NJn5eOhjj7ohiFExqWqk9rSuRCxqa0fdfOdKOjVsbyQ7r80vlMl+Vkcf82TLfnPFiQnF7fkY78ZRq4C9FnA6rJcaI64kKapAgkVR8hTsTI4PBlR77IVJXjnx9ZM2TFkcYERGYJkhSPWU+nsm0UW54Mehu0jXthWIoHgtN1o7r3jaU01NjaKJub4nAV4dc4SOBXgcEEZ5qZD+NMxnsv98LmsCpEAUStjC4ZtkmVvn22uqSY2LkWBwiRlpiobBu5rztjET7c/yfmAx/e34+elaSyuceO1mBuJLVHMC1tQVFOM4GxDvbziiRtrbzYNJBQFPsWSCtoRv4UPvW+xTGHRo8btcwxODE0WSKjogzN0nxcPOPlmcX5iRhAZgqRlokess8jifIUt1CVZYBuJbR07jmA8IluSC04h0QCP2yAB4oVVlQPefMQVTgQasFQVzQUlpz0WEim2l1gZ4vEQ3DZ9ZWznX943WtbTZIFtpKRlSeYR3fNVy8IzPSFs7Y+K+26WzJwaj3X2w+cB9phAygMcrHFhXrcu1RFThwRLsiqTW8y8g4mBL9cJPZJA3P4dqgailxTituo1U2oWZxv9TeU+s5g8ZAMfsshiBoJkgKSABIYCXzuwcajfy+n8Y1iBsaeMWEkhieFlcSgAxbKQoPEkgHdUn9qtlPt761vfKpEFrMpQU0NC1d/fj+bmZrmdJImE6aWXXsJUgW2kHE2ViSUHTHGNJfp0Q3xessgIW1/+7RG5jJwIIqmIQUEEqnjhSIlEgQRRMleI8Oa6xh1FMB58aGmFTHqFLBWaosChqUJIpe1089wpJRTTsc8sJgdZIpNFFjMUJBC0A7DJCEGB7enANg+fwwtDHlnZIdFgW4m3LW2rx9XH92F+byc+X+wblwstNTQUGhN2GjZJFt1+eWz2xCF9mFgJmgqw4vK5eeXyJVakAAP5iBlMneRixoLEheGl+19pxf6XW/HUD/cNIzMfWlKOfM0BlwXkpCy8uzQft3/hElx0/RwsuLhErk+XcH02v7N7Fleh0KkhR9NQ4JzcUfUsZgdmTGspiyxmM2zH3pHTSJyuY2WFxIGEhNEApwPbQHYVhoGSdswAQSLjdrmwurUOlx7biw+v/LNxHyMrMITtYWNvj+CxkczQo4Z+NFOVyaSbFjRVAbWiEWQC/byqIj4vsx1smyQiabh8irSKRk4EXep3497VC7AnHBcyYbfiJrtCQeLMOAl7dD3bAsziXJElMllkMQNIzAMPPCAOuiQdu3fvRmFhIUpLS8Vhl5NDZyKm5TZILLg9GyRCrJ70dHfD43IiHo2CtnhbN76A6pUXjes46TNTW1s7zM6+pKREyJJNbEbzo5lMcCHMdziQSluDJOYfFlVlF8eBhGqKWdMxwOlTgCQQaDkRAkqyu74wVy6s1Oze0TRlepGRo+tZZHEuyBKZLLKYZtheLXZcAEW9jAyguJYZRyQyNG8cL0h4qGOxKzMkP3Yl5ze//CViiSTcXi+SqopDPUEhUuMhSKyy8Fgp8mV7iUSJra93vvOdMqLN1tWqVaumNCHbNqb7bVM76tOWVGKmInl6poPE5MCrbRIq6aTZW2pAoN0QksDJ4jl+dDUHUT63AD0tEZngMdLmYLL1RJngZZHFVCBLZLKY1ZjO0WEbFPKSdJAcUIzLFk5ZWZm4757NuDUfu2HDhlFfV2VlBdq7usWriVWbVDp9Rn4wttB36LGPNN2bDtRGk2g2gB83d0vbYjaf7dvaGJlycyqwDAtOH6CnmPJsYdtTdfDSM6bHAswm6GkTcPAxCpJhQ0gNJ3qyItgszhdkiUwWsxaPHDqGB7bvRHEwgAVvvDGlo8NDwUkkEhbbNZci2qEZSLY25UwwFrnw5OTC6Ohk/2lYPMGZHCs1MjxG++fpBrUWcdNCiaWiI57Gq3UBrF83/cc1XRC33oQuoZKDUABvcaYyw6DeRBhw5yqIBy0ojkwbKhnJPJ7tKG4jS2SyOF+QnVrKYlaCmTxfbunF/oq5eHnRGhzV3NIeefLJJ/HEE0+cMlV6okFxLwkBKx0Uy5JgDE0jpmZmoo6HQZB2fhLBfbAdNF5QE2MTH17z58mAaDZeaBpXiCB1MmrCQHMkASWmI/5S+5SFD85EiHOt48RXu8uvwFukIB4woccVOL2apGbH+034ShR489SMs+4A76FB3ESOXGeRxWRjVhMZnrHyy3jk5bOf/ex0H1oWk4yNjS1UO6IklYDPqaE7t0DSz7dv344dO3ZIPMBUkRnbM+amm27CFVdcMejiawtqSTpOlXJ9JiBpIWkigeFU080333xGVShWjvg8boPXQyeiJro1svXxOrk+HSnx7+rDW7aG8Y66JN69NYrK5qRUFGYzWFXRnIArT4HDoyDBPAALKKj04JKb54kWhn4xlm4h0mPAlcPHAU6PhkvfMS9bjcnivMKMaS3xC5EiQpbUqROgX4b9RT5Z4KJln5kS1Arccsst+MAHPjCp+81i+lEa7kdaN9Di9KDMMFCTiEi7hJUQTuCwfXKm2pTTVYBONW5qt4IozqXIl6JaexJovG6+Z0KazlYXxOfYLsMk/ZPxN8oR4XgkBdUBxIIp7H6h+ZQLK7OAqgNplLemxY3WdKmzuqLA98/QDQlhTIUspJSBaosCrLi6HGtvmIeDr3agty2KZCzjuZMMW/AVOuD0qDAMUwTBfF9rVhRlhb9ZzHjMCCJD3wmm6dqeF/xyZMn62muvndRRTo63DsW9996LRYsW4frrr5+0fWYxM3BLdQX2P/MCmhxuITVVyShy8vJkWojg5/BsyQMN4fiZ5meXEzwkMX+5rw4RXUeOw4H/Xr1wTDEqCQJHrukdQzLFvwW66k6kdudcxLl83pVXXimvkaRr69atE56CHQ0mhZC48xTEkhYa9vXIwjrWJA0X2/bjvbAYuARg3qriWV9RoDMvvWMEVkYDs/qtlVh93TypcAW749JyGiqPSseYsK4iGorLxJOZBhr2BRDsiuMtdyydsN9vFllccESGX/jUJHCUk2d6LHnzrLizs1NuZzr1VPhS8Oz3V7/6Fb7whS+ckfgxi/MTXHj/5h03iy7maGsvLTbEYt8W2p4N7HwjJkXzM0zPFWKjtwDBeByV6QRaHB78cd8hrH/L5aNug+RgwYIF51Q1mWzY7ST60gSDwQmtXBH+fLdc6wMLMROY33jk+Cknaawhf7Ith3plsZ6tYlWGLtbt7kYypksVpqwmF8U1fsy7qFiIsbTdLEYRWEJwbHAke/3ti7D5keOZtpSfadgW9r/aivwyr7SrsrlEWcxEOKb7C5GVGJKY3NzcQQLBMVQSGo528n5+SU52m+nRRx+V6ZCPf/zjk7qfLGYO7MrEU089hW3btgmBoe7DHi9me2e8CzRJzGOPPSafIW6DRIakhO1Kz5x5UC0fok43/LqOvjd3oaGmdNi2+Xw+lp/75cuXj6tqYj+HBIx/P9S/TAXpIbni324oFJK/2bOtXJFssA1iL7428eC/D21uh5m2ZLKG0zRGyhx0peXzhob91W7vlPHizOIMpBLGMAfb2Qa+bkYL8D0iUXnzmUaEghHU7erB2z+ZEfJS0Mu2Hd9jGyU1A2Z4ioJkCPAWAZ48Fem4KURS0xR4/E7cdNeKWfveZjEzMa1EhpoYtpN4FjyyCsKfeTvv5+MmSiMwFpjie+utt076frKYeaChG6sLrM5wcWaKM8k1p4WKi4vlMUNbRUO9Z/jZ5H38vIr9v9s9jHTz9qVGEjfUHkaquATFkTBy+3vw4osv4u6775bHcHsUF9PXhfqYN998E2vXrh0WVTAUfDyf39raKoSCxJ8tqUOHDk3ZCLndAj5bsS9bRWLCphvSBjmytWPQiI2L5KprqrB3YwucfmVYbtKgR0rCEGEqF2yojL5WhDja7ZSe5vCsrsrwdfPy1A/2wlJ1mVCCkSF4139ombxv1B5RB8MYLxIbEkjCm+OUayMFpCImnF5FiGKi30QCadnGaAQ0iyxmJZHhGTC/CO0x05Hg7dQJnG2pf7ygHuGFF17Aww8/PKn7yWJmo7y8XIgIjeiiFXNQ5/CgZeubqOjvkUWbraLe3l65ZiuSn107BmDowm6bxtlCchISTkIhGEBBQQHoCsPtEFx8SYpIePhZp9Cd17t27cLx48dFj2LrdUhQSGJ++9vfyn75WD7fzjviMU10m2c0cB+sOHn8HoRDYWw7sk32OVIbNObza/uw7Yl6ISMuf8aojf9+7aFatBzpw8U31SC32COTNemIBc2VWVRVVZEFNK2nkU5aSKcyC3PJnBz07QyJFb8NViNIeCY69PB8At/ntuN98v5Ztl5mBNEZWd0SDJxTOj0KUhEL6bgFw7DgymF1xsKh19sBxYShQ1pYnHLKtp2ymLVEhl/E/PLnlyLPKkeCt/N+Pm4y8bOf/UycVN/1rndN6n6ymJlga4lEw64utOUXo3HBSqgODXvSJnx1+1GTigl5IOkleWD1hISDhIWfXZuUk5CwqsLPLAlGe3u7bHPu3LmSDG2nWHNbJCrV1dWorKwcZoDH7ZIM8bGvvPKKbJPb5sgzt0nCQj8Y20DPBo9pKiqK/Jvk8ctxpU28uf1NNB9pRrg3M/JMjRAxFpnhwmnqlpzpc9EsqNHQW6+L8LR+dw9aD/dhzrJCaYukEybcuaq0lo5s60Bhhd9eZ6VSQ3v99e9ZiKZDXUiGM+8FRcKcwomFUrO6xdTZGILbryLcnXlfWMGyqy4jCc0wDFTA0okTpTDFUmGmFbhzeLspuiWkgXgohdcfOia+Nd7cbNspi1noI8NpB04n8QvZ/oK3YZ9p8n4+brLABYJE5q677hqzMpTFhQtWOHbu3DnojcIWU7q4FA3Q0ByNo11RUefyivaFn8dAICD/5oXEg+SBpIXEgq3QOXPmDJIQVl9Icg4fPiy6F5uQU8/Czxp1Odwvxb2XXnqp3EeCINEBqZRc7NgCgm1W21WX+jGbxHD6jinZU9VW4ntgwYLP7xMi5zN9SMcyjsT8mX9TrMyMBZ79qw5Fzu55xk8S48lVkFOe+TqixoXTMkbagKKSxFGUCskCSsWHlxbYQiKZcbg0qTx4ClXo1H3w62T4V8qsQ0mND4qlweVxwO13SOtuPKQuHk3L+80LQUK54upKLL28Qgii5uD3c4ZO8mvb4QXSSQPxcHpM/x62Ep/8nz1ynUUWE41pXbl5ZscRa04n8Yt56NSSrTfg/ZMp9GVLiWfKn/jEJyZtH1nMXNhGcy53I+IVpTiKGoRCHP81EPfmIM+poSqeSQzmZ5PEgkSEhIOfU1ZfeCH4OWVFhNvkZ5kTPVzUSXpIZEg8SH64DRISVmTswEZbp0Pxrq0XY6WGbSwSB9tFl8+321IEDfT43KmCLTD2uD0y7kzSxveCF/tk5HQJ2FxMr7htgQhIWWkRH5OoJeGG7gIFVjrDQdJRQNEs2R6N3TiSnUqn4PBnTN4oAub7y+148iw4fArSMRPGQOi35lJPqkBciOB4P2MZcuuiWJnOVF3KF+ahfEE+3nrnipNbR6dBKpoeNr7tz3eJroZtKLaSKBLm++/OUaCoFlJ0BRYTPnNU/55XHzgqeieCBJXIhlJmMZGY9hIEv/A4Ym37yNjeGdQrTLaPDPG2t73tpGpQFrMHJB6FhT1ILgxgq+e9OGg6oRYAF7fW4+LLLsON86rRG23Hjt6uQUEvYV8PNazj1JDthWRfCFZ6SFb4WW5ubh4kPsRQTQsrj/w74PNIWKjVufHGG0WETFLE6SSSJ1Zo2Iqa7Em+0cDj5bGxWsS/GztSYeh7werS6RKwOUrtcPL4TWiujFA33D6Q/aQCvmJFqjZmCtDjgMfhRDKuS/vIU6BAjzHwEHA4FaguC648FdG6IcfhUnH17Ysu+LYSSczn9jYgEU/CcgPv2hPFws3tWP++eVh7/QJULXGd8XuQX+5Db3tMfGWIkrm5w6ah2K5r3NeDeDwp8QbJSOZzXjovb5juhpWclsN9aNjbI9W2aJcpFRxOmWWJTBYXFJEh+AXPL/OpdvbNIgt+7tasycMfEg4hMUUIoEcrx6Kly/CltcvlDWpYtUqqECQvXKhtga9dpaHNv71wM6tpKNHh/RT7spLB20iGbOLM6aihmhaSBPsxrHSQvNTX12PJkiWDGh4SB14XFhbKhBXbU3wMX8dUjF/zeO3WF4+TJIZ/p2yp8eRjrEmrkeBCR4Ev05kVDUgFM7ezGEX9Bc3YksGB98nvkARnWQWpnUtkxqyJ/DIfelujUCwTmluBkbSQW+TGzX+28oIiMWONqtMtOqIb8EUtuP0KguUOaLEkXv99PUId6bMysqPYur22X1p8bo8mP4/U1PyhOYxwbxLhAQ2THjcR7Uvg6fv2ofVoH1JxQyp2rNww/iARMjMiYgvw5rkm8J3JIosZQmSGluWzyGKqcdFFt2H/3u/jJSOBPpQgz+3Cn6xeMXg/F+Y77rhDRMGsktioqamRfKShCzfJBMegbSEwKyrEAw88MLjo2+LfkY699uefRMX2tGH1Zv369di7d+8ggeJ2+vr6BluxdCPmhWPbdAX+/9s789g46zOPf+fwjMf3FewQSJoDJ0BcktC0TQqEFSyn2HSLWqCtWoi6oipqtys1W/6gCImtqiJtVcRWdFntSmwvAQrsqmUpCpACKYEGSu7TzunER3yNPfe8M+/q+7zzcybGSex4xp4ZPx/JGs/heWcmkd+vn+f7fJ98tZpMW4kiynhhZHqpvPwTn8PFYAuCokUMpTHnNk4qyYqGYFwmYuS2jCih8Dny8Rl0dQSdBYcM5Lu8Euvub8Xvn9kJS7Y6Z5J925rkZFsqMfsUMX/4xS7YSMOK2TiwrUve04pbr8R1cypQ5fVgMJBCIGFjUcJZTWCH6UvpRO+JETFDT0bU8bF3frvtgi2pq1Y3o+fYsIjO+HBaDNZWOi6tJ4oViheXyw0rlkI8djZawzdGGClKLnDZ2ldRFAwO/gVv9x7FUSzG55uXnXeFwERGjLNzZnhyf++99yT3hcKEPhl+tba24qtf/eonftaE8xFWZSiMaBqmAOLzsr3E7+nrIvyej+NzUjyRO+6446Ktnclism4orMzUlpkopAeIZmdWjiZTFcr2TvCv9Ru/cpVE44eCESTY1rCBliW1uPcH14+e0F/75W6pFPCEyJOtESzMpPEGbLjSXml/dPz1DHb9iYtBnVbVDV++qmjFDLNgju7qA3MafdWc5IJUnmiEXnvvYkTaavD2nm7Et/Wh+XQCgUa33B/lokhOcVV6cVfms8olRij2HB1GMmnJ0kn6angZqHUjeCqFFAVm2jEML1jeJOKrlCplSmGgQkZR8gxFACsyxLSObr/99vOKDSOWKGA47k3xQuGwfv36UZFAwcMKjPGnUFSYKIPziaSpQDH21ltvnROHQAHDihDNz3xfFFL0A01meiq7akLfjFQe7LTE55Pl6+aJ0dQwbu5J5vb2nd2wky5EhpNSGahudiNEX0YaaFlUg3v/+TOYSc732i/Gpqc+lOqHx+/k6fgqnLF1tuRY9bjtweW4orVRPss/v3xYTLixYRsVDW6Ez6TH/Rxzycv/+hH6OoczVTFIi8/xOAGRMykko0DLnAjuffKevBxfUQqmtaQopQpP6lxEyrYMvSWrVq26YMWE9/GL4oGTTax20A+TbQxm++iaa64RIzAnm4y5+GITQ5eKEUlsZ/E4ZvSbt/GYpu1FQTOZUD5WSUylZMcbJ6TdxJP1pHJPMrRvPwMrkQLcNqoucyPcn/FlMK22emZ9GSaRmPuPWJ0wKcYToaLWL2KMpme2jbx+VmVsxIc50ZVC34mwCBk+X+fhAdk1RUFhREy+31ffyZC0kjhOT1gNCnUzQA8iYkg4UZn316LMXlTIKMo0VGS2b98u1ROe9Ceai8TWFH+OomG8sDuzj4nPT0FDXw1bO7luKxGOgNMXQ0HD9pLZR0Xo12FVhmIr2wc0WVip4C4fxuCzbcIR7YlWLhi3Hx22UL/Qg+GTKYR6zp7EOf3ElsZYsqdr8p1MS6OuGVtmoBxD5Mh4Yib7dbV/2Cu+IFZjvD63BM+F+85m6bjL3OeMPFfXlUsCMseinZYOUF7ly9sYuiQtx+jLcRQjX1/KcqpgHIPn4slEGAiNONW3Ym3vKYWNChlFyQMUF1w6aSxovKQplnlJE61Y8DFsJ/HxFAcm82bsz05kweRU4eunSDGj49kj17yPFRmzooFTVJcipigiuJBwou0XM8nDQLzeY8Oy4DDal0ZZhRspTsnYjoj5wr1LPvFc9Ofsfe+0jHDzxCtZNQFPXrwkBooKESR+F2JBG1tfOoxgbxSLV82R9xEeiksYXV/nCKx4WopJHDWvbnEjNpJGfCSNlkVVSCUiEgzo9p47Yk6hsHfrKRGB/G+3aOUczF1cOy0bq02CxfxrG3DFMmeRZ88xhuPZCDS4ER1IY+tL7dj7zilce9M8FTRKTlEhoyg5JnsfEmH1gt4RBtlNdo2AESj/+faf0eHyYu6+Q/jurTdPS4JvNhyrZkKxSeHme+LJn5e8Tn+MCfLLzsmZLBdqHY3XqomGEs6UTKWTZ+IkANuobPCgur5K9jDRe8OTPE+ubDHxRM8JKNmszaRaP1ct2IiHLans5PKkny220gz+C/J4mQTiaBp73u3EwQ+7nGodXCgrByrnuAHbjeiQLYKHY8yCy5kW4vsZT+zx/fExXr8zoh4JxrHi1vnIJ1wDkXlp0hakiDHtQjEp7+yDleCItkt2ajGf5t0XD8vPaHVGyRUqZBQlx7DNQxHD1QHMgjHrBtgiym7JTJTNnd3YdNlCNPu8+ChhYVlnN/5hmoUMhRNNvGYai2RvAH/99ddF0FDMUPTkG57I6TfxlAG1l3sRPG2JL8QUihZ/ugWnjw7gyI5etH/Yg1jmsfTfcIopUM92EsQYm7adNgy/oiMZg04OMFNWfJ2sWNCcy/Rhif93O2bcSL8NK5mWBd40OMviy8GUvK5EOLNqIdMeW37j2UrGeGKL01wUFMzm4Q/yej6hOKSpmiKFe7OYtDzYfXZzJ9t5p9uHRCCKYCxzPgP+O9HgrUJGyRUqZBQlx5iKBD0jPLHTrEtYzeAXhQ7JHtG+EGeq6xCLDCMZj8Pj9eOI7RIj8ER+NpeMbWGZ783lRDZf5wrZ1+RxiTdjuNuSiowVc3wxC1c0oboxgPCHFurn+zHQGZGwOFlhELZFVMgqJq48oFjIQIHDikeuYCUmFrZQXucWDw5D/pgDQ6FBMTN82nm9sncqa4UUhQF3UBkR07K4dkJZMBxJZ1Cgu8wevZ5PKEYIR+VliSR3X3U66zwIXy9bdaxyndg7ILuyBBdkSk1RcsWsFTIs5T7xxBP49a9/LX9R8qTw4IMP4rHHHhstkSvKpcCKRGdn52hriTkvrMhw4odChlNGPOmzgsEvtp0ods5n1OWahE3DR3DG8uIKpDG8YzveCvaL52a6FkVeDDNplQ9MW4i9C25YlhO8y0bzkip0HQpKlYU7lsykkwlcK/N7EO5PIB13IRFLS8VAYBBf1GnBSJBbzJbnWHjdnNxXCVxAbOjc6SFWXkzgn/HwMMqfWTEUOBRdnEgi2Tk6F4MirPvosDOolWlD5ROKkWO7+kUQZi/xZCXKiC7TKuRtO96kITshr0urMUpJChlmR4yM7EUyOYiysnpUV18rGQn54qc//SmeffZZPP/883ICYQT8Qw89hNraWnzve9/L23GV0vfHcMKHbSVO85j9TPyiGZaLHzldRFOsme6h4OEOJoofMlYQMJzv39oWYcvxTvRv24qWWAgJl0vyZRi0N9lU3WKCIoamWJnA8TrBavy1UF7vkowYfobces1UX0+Z+5wNzzQO73rnBI4PDMLFn2Ml51M1MsEjwoH+DSYLZ+DSw1zC47D1wtYSDz5nfjUGOkPS8pG8lcw+KBmbPjDovK9aN6IZEUMClWUoVPi6D3/Ui+72oPiSCKtdbPuNrR5N1PukKEUrZAYG3sPx4/+OcIR/pSbhcpWhsmIRFix4GA0Na/NyTJbmORFy9913y3WeCGjQNKmqinKp6bfGEEuxwmqMaTXxOr/nqDJXCvAxPBFzGzbhdVZqxqtsUMzY+wbw5pku+GtrR1N8KYB++9vfyrqD6WjpTDdsX1DAsB0jG5kpWDzO0kjbAlJIY+F1XElQN+50TufBIbj9NqwRWwo5rOgYMyr3AtH0S2gAznW7wyxZzDbmnm9nEr05FDeM+085ET1CZZ1/Up8Vi8mciuI28enwoaxZvwj/Rx9Q2BFr/grvuBuwFaWkhQxFzIGDjyFlheEtYxS7D+l0AqHwAbl92dJ/yYuYWbt2LZ577jkcOnRIklB37twpm4d/9rOf5fxYyuyAnhe2kAjTb2nsZdWEVRleN4KGlRozlk1xY1pQFwuzo+hhS5SPZ+XQjDxzpJupu8ynKbXKDMXF8T39EnUvuNg+4sj0uSf78aZzKBiseEqmgFh5oUflxL6B0dbHnQ+35X0f09hKxPkqE2Z3kRExrDyVV5VNKv/F+awGJGGX/5emw4difDDjiTNFmRVChu0kVmIoYnz+5lFvisfDUKdmJBI9cn99/edz3mZ69NFHxYy5bNkyOeHwBPHjH/8YX/va13J6HGX2YHJU+H+JAobihd9z5LqhoWF0T5FJxWW8Pxcw8v899zBdLMyur69PLvl8Zgt29iLJySTqFgtGXNAjEw4mkEzFZYSZ0y/GY3Khkz29L/SbeH0uJJLOYsns1kd2svBMYl4DRVVNY0AWaE42/8U8x+mOfly+2En6nQ60baTMaiFDTwzbSazEjDXY8rrXWyf383E1NW05PfaLL76I3/zmN1KW5wlkx44d+P73vy+m329+85s5PZYyO9pKrOhRXFBo0NhLoUxWrFght7MNZFpC9NCwrTkZ4cHKC5+blxQ+bGHR8MvnJpeaqFvoMDeFY72xcB+o22TqKFOR4Ujy+U72FDj7t3XJD5jpJPpoCrX1kQtRxc8qZVtymc35WlqKUgrMqJChsZeeGLaTxoO3W1ZQHpdrNm7cKFWZ+++/X663tbXJgr6f/OQnKmSUKbWVKqvOoKnRDRsRDAebpQpjAuX4GIqRyYoYQm+NOYbJo6EwMtuvP/jgg5JrL40G340kZMRaxpIzMLn2xvtaz/uzPFkvuLYRJw/1weV1xA/bLaV6Eudn9ebz+wFPGntSXWJ2Jmb82eWxZWLq8Ic9eU0wVpRZJWQ4nURjLz0xbCeNhbfzfj4u13ByZOxfsDw5mL9uFWUysJJHgVIeOInW1g64XMOorYvi0KG1ImTGBspditigGPr444/PWQ9A2GaigOG0VKm0l0wF4fThIcQiCTQu8qLviFOGqW7wY8Xfzp9Q9YKTSOmELYFtiRE755NJhQRbZnCnUVnnQ2ggLgKm8+Cg7ELiqgOG0hEac/nZqpBRSoUZFTIcseZ0Eo299MRkt5f4y9+yhlBVuUwel2vuuece8cTMnz9fWks8QdDou2HDhpwfSyl9KB64jbqv7zBc6EMs5obfb6GxMTSadDvVnUj82SVLluDgwYOj3hj+/2WriW0sCnP+P2Zlcc2aNUUraEwVhksWywI097ow0sORJef+piurJ9yCEQPs3n4WKYT+zlDJLS80oi88HJPpq6HTcdhIo+v4gOTtyHqAGH1CQJKdzbNFLUUpCWZUyNDAyxFrTifR2EtPjJlaoojxeKrk/nzkyTzzzDP40Y9+hO985zvo7e2Vv5IffvhhPP744zk/llL6/hhWQnjpctfBSqXg91No+PHZ1V/OqaCgQDl16tRoi4pj14RpwbydJmOOdp84cQL33XdfUYoZVhZioaRsTuYeJC4c5PeXMpJMr4ibfrtKXnMhEopLLg0pRjFjNmNnj3NT9MVCCfir3EhbbjS0VMrGbMKFk+G+NNLZycGV3rxtw1aUWTl+zdFqjlibHBl6YthOYiUmnzky9Bv8/Oc/ly9FuRQoXBhIZ7ZTU1hEo5WIRteiunoA11x9B66++u9y+uGer0XFXCSKGPpljHdmz549RSlkRvpjkhfD6kJ08NxWkNfnntRJmO2VVMpGVZMX/UFLpphIMe76oWhhZgtbRUwwps+FoobX/bVuJEbSEqoXiyQlJNDjc4Qg22rJzPj5RNcdKEoxMeNChlCscMR6OpN9FWWqIuaFF14YHa82uTAkNDIXl89dhy98wTGS55rxWlTMn+HqA3q/OPbNy127dqGnp+eiY92FdrI++Jdux9NiliZmDTQ2zZ/cSDJ3/3AVweDxs60pUoy7fijKZFGmj4F3Fv74H3sRqPRmtl3bUnUJ1HhR31KJwa6I7FwK91P0uGXSy4KN/lNndyEpSqlQEEKGULTkesRaUaZjSslccmcSzeL0ek13JcQIlffff1/Gsk2iMNtN/Mp+TCHDCoOddnYfcS0B/5bhJRcTUtA0zTt3rPhioog+G2+5s5mZXhFG6bOaMXY8uRjg5BZTjsv8gMfrknZSMp4QYdM0twaNV1RJtYqf4dGdZ5DmZ2gDqZjTWvJXO4s1/3tzB/r3leOmxY24Z/ncmX5bijJltOShKFOYUjITRCZUMTsYb7qhUPniF78o3/O1UFhRVPG1cPVBMUDvR3llmbSQ6OVoW3cFKmp9cr2ixjepthINsGk7LSPHhCd1TvR4y9zOhE+RwfRfrjGIDdsi7AINbtTNd8s0UjySxLoHlkq1ip9hoNonKcEUMMYfEx9JY/BTXrw834WXfQn88Nhp/H5P10y/LUUpnYqMohQTrLjQTMsKCFs6FA2shGQLnZmCmTIMzKPQMmsR6Jl5afNL6Ap1YemCpbh91e0oRHgiZv5JtqF18ao551yfFGnGODjfckdTLGxJ/D+/ig3j6dmx+QRGBuJIxW2EB5z7Bnuio6sXzI4nM35t2nPlFV7s9rvQ4ge8I2n0BNx47a9dWpVRih4VMooyBTHT3d0tQXcUD6bFxHUEM2WyZcsre+O2aTFxisk+aSNlp9C7uxdHdh3BnTffWZBm4InuJ5ro9ulEzILH63a8Nm5LRpC3/+GotJeKzfRqxMwHf+iQnUp2zIavyiVBge//zxF8aeP153xm2VNOrFDt2deDrQv8aKp0oTxho+pwGO++cOiCwYKKUuhoa0lRpgBbNiZl17Bw4cIZ+0xZCeJ6BMG2kbIs1NbUyG2XzbkMFf4KeNIe9BzrkU3dNC2XKqYy8bl7FuGqzzQ7wXC1zq88VmZMZH8xQWHCHBzujmJFhpNIHmd5OrqOBOW+sZ8BF2ryksJuaQS46y9hLNofxwP7I1hwxsKuP3WKmFGUYkWFjKJMAU4L0YPCKSFCUVNXVzdjn6kZz26rqkJtKCRemUQyKdWZoaGh0SkrwgoSKziljDmR8yRup12womeny04fGhRhUAxsGwrh8S2H8NwrzpqLsrIy2RtFYkGnKsMW0vv/e+S870k2fn+7DZ+rrcT1B2KoP5ZERZPzHLu2dH5CBClKsaBCRlGmaLBdvXq1bLKmQKipqZlRf4wRM3euW4fPHjsOm6s4MonZyUQSKSsll4Svd6Zf63TCT4GbUJixQga6IhImV+hihiLmux934I+JEfzxGh9O1HgQ7I3BX+FFw7xKmepKZpZiMn/nQkZmipl7f3A9WpbUin8o0p8eregwW0dRihEVMooyRe666y58/etfx80334z169cXhO+kYvVqrHz0h2jiSLhtj7a/6J+hEXjp0qVSuSmE1zod8OTOkzynftwMisuIGfpnCnmCiSLr5bePYTCWQiBio7Uc6Kp2/i1rmgJYd38ryiu9MpFFpUZxM5Ht3mvWL4Kv3CNVHAkJdBVnto6iEDX7KkoOmOoepXyJmbqODnQfOCBTVUz+ra2tlRHtQnut+YYnd7Zi4iMpmVgyCb++8omd+Gcyybe8HrhqZaW0jw7GgS8lLREePUeCEvjHdpHx+7CFNhEDMx9z9yOfxo43TyI6nJDR7mJLOlYUw6wWMly2x31Lr7zyiuxbWrlyJZ5++mlpFShKKWDybEzyMJdLctJqtgkZnrgZptdzPCiboEPdNgI1Plx/x4KCnVyiOGGC70KfG9b2MPoavFg+YKExlkbK55J8nL3vnsYDj3/ukt7DpU6DKUqhUTCtJZa/d45EsKV/WC55Pd9861vfwubNm/GrX/0Ku3fvxm233YZbb711NAlVUUrBjEzMKDaFzRtvvFHS00rjwamcrqNBlFW4kYw6Kb+sRPx5U3vBTuyEh+LSAosF07ii28KKfTHM67YQH0rDlRmUC/Y5+TGKMpspCCGzdXAED+w8gg27j+IfD5yQS17n7fmCv9g3bdqEp556CjfddBOWLFmCJ554Qi6fffbZvB1XUabbjHzllVeKgDHVGcuyZKHkbIHTOJzK8Ve5JN2W0f30P/trXbBTtowfF+LEDrd8m1UNguTgON8mubKBJXVvcaYUK0pJCRmKlY0HT2JfKIoKjxuX+bxyyeu8PV9ihr/MOYpaXl5+zu3M29i6dWtejqkoM8Ett9wiU1XZycM0/c4WDm/vkR1F8pZtSEWG8f0MkZPfgHZhTuzQ78L1DPT2cD/UjV+5Cn//Tyux8LomuU5j70TNvYpSysyoR4bto2eO9yJkpdHi947+cg14XCh3u9Adt+T+tXVVoyOkuaK6uhpr1qzBk08+iauvvhrNzc343e9+h23btklVRlFKBfph2DLdsmXLqHjnRuzZAr0w3DfEvBUDxcwoBTqxYwL9xq5nGJvYqz4XZbbjso0LcAagF4ZtJFZgAp5PFoeiqTQiqTT+q20hrquuyPnxOzo6sGHDBrzzzjsynrpq1Sq0trbio48+wv79+3N+PEWZSeiLYQAes2Nmk9mXJ/3XfrkbiVhKFkbOW1qPrvYhuU4Rs/zGeRrRryhFzIwKGRp76YlhO2m8igsrNr0JC08vm4+/aazJ2+vgLhpOc8ydO1cWAXJM9dVXX83b8RRFmV7GVjC0oqEopcOMtpYafF6UuVyIp21pJ42Ft/N+Pi6fcJqDX4ODg3j99dfFAKwoSumQq0WUiqIUHjMqZNqqAlhSUS7GXnpisg2ILBQNJVO4piogj8sHFC08DlNO29vbsXHjRixbtgwPPfRQXo6nKIqiKEoJTS2xnfTdBZehyusWYy89MWwn8ZLXeTvvz7XR1xAMBvHII4+IePnGN76BG264QcQNF7IpiqIoilL4zKhHxsARa04ntUdiSNpOO4mVGoqYG+p1tFBRFEVRlAIWMoSVmN2hKAYSlnhi2E7KVyVGURRFUZTSoGCEjKIoiqIoStEl+yqKoiiKolwqKmQURVEURSlaVMgoiqIoilK0qJBRFEVRFKVoUSGjKIqiKErRokJGURRFUZSiRYWMoiiKoihFiwoZRVEURVGKFhUyiqIoiqIULSpkFEVRFEUpWlTIKIqiKIpStKiQURRFURSlaFEhoyiKoihK0aJCRlEURVGUokWFjKIoiqIoRYsKGUVRFEVRihYVMoqiKIqiFC0qZBRFURRFKVpUyCiKoiiKUrSokFEURVEUpWhRIaMoiqIoStGiQkZRFEVRFBQr/w9qBQyD6Ei4nwAAAABJRU5ErkJggg==",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
+ "metadata": {},
+ "outputs": [],
"source": [
- "from tmap.index.types import KNNGraph\n",
+ "from tmap.index import KNNGraph\n",
"\n",
- "# reuse the brute-force result from the recall section\n",
+ "# reuse the brute-force result from the recall section (no self-matches)\n",
"external = KNNGraph.from_arrays(\n",
" indices=true_neighbors.astype(np.int32),\n",
" distances=true_distances.astype(np.float32),\n",
@@ -442,6 +464,63 @@
"plt.show()\n"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "b8a1abcd",
+ "metadata": {},
+ "source": [
+ "## 8. Disconnected kNN graphs: connect_components\n",
+ "\n",
+ "With a low `n_neighbors`, the kNN graph can split into separate pieces: small groups of points whose nearest neighbors all lie inside the group. The minimum spanning tree of such a graph is a forest of several trees, and `path` and `distance` have no answer between two of them.\n",
+ "\n",
+ "By default (`connect_components=True`), TMAP joins the pieces. It searches further out for neighbors, adds the shortest edges that link the pieces, and warns you. `model.n_components_` reports how many pieces the raw kNN graph had, and `model.n_bridges_` how many edges were added to join them. `model.graph_` keeps the raw kNN graph; the tree and the layout use the joined one.\n",
+ "\n",
+ "On this data, `n_neighbors=2` is low enough to split the graph.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "656412a9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "low_k = TMAP(metric=\"cosine\", n_neighbors=2, seed=42).fit(X_train) # warns about the split\n",
+ "print(f\"pieces in the raw kNN graph: {low_k.n_components_}\")\n",
+ "print(f\"bridge edges added: {low_k.n_bridges_}\")\n",
+ "print(f\"tree edges: {len(low_k.tree_.edges)} for {low_k.embedding_.shape[0]} points\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7a97c643",
+ "metadata": {},
+ "source": [
+ "Pass `connect_components=False` to keep the forest. `n_components_` is then `None`, because TMAP skips the check. The tree has one edge fewer for each extra piece, and points in different pieces cannot reach each other: `hops_from` gives them `-1`, and `path` between two pieces raises an `IndexError`.\n",
+ "\n",
+ "The warning is a hint to raise `n_neighbors`. On this data, `n_neighbors=3` already gives a single piece.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "27ac435a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "forest = TMAP(metric=\"cosine\", n_neighbors=2, seed=42, connect_components=False).fit(X_train)\n",
+ "print(f\"n_components_: {forest.n_components_}\")\n",
+ "print(f\"tree edges: {len(forest.tree_.edges)} for {forest.embedding_.shape[0]} points\")\n",
+ "print(f\"points with no tree path to idx 0: {(forest.hops_from(0) == -1).sum()}\")\n",
+ "\n",
+ "fig, axes = plt.subplots(1, 2, figsize=(14, 6))\n",
+ "low_k.plot_static(color_by=y_train, color_map=\"tab10\", point_size=4, ax=axes[0])\n",
+ "axes[0].set_title(f\"n_neighbors=2, pieces joined by {low_k.n_bridges_} bridge edges\")\n",
+ "forest.plot_static(color_by=y_train, color_map=\"tab10\", point_size=4, ax=axes[1])\n",
+ "axes[1].set_title(\"n_neighbors=2, connect_components=False\")\n",
+ "plt.show()\n"
+ ]
+ },
{
"cell_type": "markdown",
"id": "64d7d243",
@@ -451,9 +530,10 @@
"\n",
"- `02_cheminformatics.ipynb`: chemistry workflows with binary fingerprints\n",
"- `10_protein_analysis.ipynb`: protein sequences and embeddings\n",
- "- `05_single_cell.ipynb`: large sparse single-cell data\n",
+ "- `05_single_cell.ipynb`: single-cell RNA-seq (PBMC 3k), pseudotime and a UMAP comparison\n",
"- `08_jscatter_demo.ipynb`: interactive notebook widgets\n",
- "- `06_faq.ipynb`: short answers to common questions\n"
+ "- `06_faq.ipynb`: short answers to common questions\n",
+ "- `12_lower_level_pipeline.ipynb`: the MinHash, LSHForest and layout steps one at a time\n"
]
}
],
diff --git a/notebooks/05_single_cell.ipynb b/notebooks/05_single_cell.ipynb
index 5e67f46..1c23399 100644
--- a/notebooks/05_single_cell.ipynb
+++ b/notebooks/05_single_cell.ipynb
@@ -11,10 +11,10 @@
"\n",
"1. Fitting TMAP on PCA-reduced single-cell data\n",
"2. Coloring by cell type and gene expression\n",
- "3. **Pseudotime** \u2014 computing tree distances as a proxy for biological progression\n",
+ "3. **Pseudotime**: computing tree distances as a proxy for biological progression\n",
"4. Side-by-side comparison with UMAP\n",
"\n",
- "**Requirements:** `pip install scanpy tmap`\n"
+ "**Requirements:** `pip install scanpy \"tmap2[singlecell,notebook]\"` (the `notebook` extra installs jupyter-scatter for the interactive views)\n"
]
},
{
@@ -30,6 +30,7 @@
"import scanpy as sc\n",
"\n",
"from tmap import TMAP\n",
+ "from tmap.utils import from_anndata, marker_scores\n",
"\n",
"warnings.filterwarnings(\"ignore\", category=FutureWarning)\n"
]
@@ -42,7 +43,7 @@
"\n",
"Scanpy ships a pre-processed version with PCA, UMAP, and Louvain clusters\n",
"already computed. We use the PCA embedding (`adata.obsm['X_pca']`) as input\n",
- "to TMAP \u2014 the same 50-dimensional representation that UMAP consumes.\n"
+ "to TMAP. Scanpy's UMAP in this dataset was built from the same PCA representation.\n"
]
},
{
@@ -106,7 +107,7 @@
],
"source": [
"model = TMAP(metric=\"euclidean\", n_neighbors=15, seed=42)\n",
- "model.fit(adata.obsm[\"X_pca\"])\n",
+ "model.fit(from_anndata(adata)) # adata.obsm[\"X_pca\"] by default\n",
"\n",
"# Store back into AnnData so Scanpy plotting functions can use it\n",
"adata.obsm[\"X_tmap\"] = model.embedding_\n",
@@ -119,8 +120,10 @@
"source": [
"## Color by cell type\n",
"\n",
- "Using `model.plot()` with a metadata DataFrame lets us color by any column.\n",
- "Here we color by the Louvain cluster labels (cell types).\n"
+ "`model.to_tmapviz()` builds a viewer, and `add_color_layout` adds a color layer from\n",
+ "any metadata column. Here we color by the Louvain cluster labels (cell types).\n",
+ "The notebook widget draws points only and warns that the tree edges are ignored.\n",
+ "The HTML file written in the next cell includes them.\n"
]
},
{
@@ -128,14 +131,6 @@
"execution_count": null,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/Users/afloresep/work/tmap2/src/tmap/visualization/tmapviz.py:830: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n",
- " scatter = self.to_widget(width=width, height=height, controls=controls)\n"
- ]
- },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
@@ -162,11 +157,9 @@
}
],
"source": [
- "# model.plot(data=adata.obs, color_by=\"louvain\")\n",
"viz = model.to_tmapviz()\n",
"\n",
"viz.add_color_layout('Louvain', values=adata.obs[\"louvain\"].to_list(), color=\"tab20\", categorical=True)\n",
- "viz.set_edges(model.tree_.edges[:, 0], model.tree_.edges[:, 1])\n",
"viz.show()\n"
]
},
@@ -186,7 +179,8 @@
"## Color by gene expression\n",
"\n",
"CST3 is a marker for monocytes and dendritic cells. We extract its expression\n",
- "and pass it as a raw array to `color_by`.\n"
+ "with `marker_scores` (the mean expression of a gene list per cell, here a\n",
+ "single gene) and pass it as a raw array to `color_by`.\n"
]
},
{
@@ -220,7 +214,7 @@
}
],
"source": [
- "cst3_expr = np.asarray(adata[:, \"CST3\"].X).ravel()\n",
+ "cst3_expr = marker_scores(adata, [\"CST3\"])\n",
"model.plot(color_by=cst3_expr, color_map=\"viridis\")\n"
]
},
@@ -231,11 +225,17 @@
"## Pseudotime via tree distances\n",
"\n",
"**Pseudotime** is how biologists study differentiation trajectories.\n",
- "Pick a \"root\" cell (e.g., a stem cell or progenitor), compute tree distances\n",
- "to all other cells, and color by this value.\n",
+ "Pick a \"root\" cell, compute tree distances to all other cells, and color by\n",
+ "this value. In a differentiation dataset the root is usually a stem or\n",
+ "progenitor cell. PBMC 3k has no annotated stem or progenitor cells, so here we\n",
+ "use a CD14+ monocyte as the root to show the mechanics. The colors then show\n",
+ "how far each cell sits from that monocyte along the tree.\n",
"\n",
- "TMAP's tree gives exact geodesic distances \u2014 `distances_from(root)` returns\n",
- "the unique tree distance from the root to every cell. No approximation needed.\n"
+ "`distances_from(root)` returns the tree distance from the root to every cell:\n",
+ "the sum of edge weights along the unique tree path. These distances are exact\n",
+ "for the tree. The tree itself is an approximation of the data: it keeps only\n",
+ "the minimum spanning tree edges of the kNN graph, so two cells can be farther\n",
+ "apart along the tree than in PCA space.\n"
]
},
{
@@ -300,20 +300,9 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
+ "outputs": [],
"source": [
"fig, axes = plt.subplots(1, 2, figsize=(16, 7))\n",
"\n",
@@ -340,7 +329,7 @@
"\n",
"# Legend\n",
"handles = [plt.Line2D([0], [0], marker='o', color='w',\n",
- " markerfacecolor=cmap(i / len(categories)),\n",
+ " markerfacecolor=cmap(i / (len(categories) - 1)),\n",
" markersize=8, label=cat)\n",
" for i, cat in enumerate(categories)]\n",
"fig.legend(handles=handles, loc=\"lower center\", ncol=4,\n",
@@ -349,34 +338,6 @@
"plt.tight_layout(rect=[0, 0.08, 1, 1])\n",
"plt.show()\n"
]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": "# \"\"\"Enamine REAL TMAP \u2014 scalability test with chemistry utilities.\"\"\"\n\nimport os\nimport time\n\nimport numpy as np\n\nfrom tmap import TMAP\nfrom tmap.layout import LayoutConfig\nfrom tmap.utils.chemistry import fingerprints_from_smiles, molecular_properties\n\nN = 40_000 \nFP_BITS = 1024\nFP_RADIUS = 2\nDATA_PATH = \"../data/20M_smiles.txt\"\n\n\nprint(f\"=== Enamine {N // 1_000_000}M TMAP ===\\n\")\n\n# ------------------------------------------------------------------\n# 1. Load SMILES\n# ------------------------------------------------------------------\nprint(f\"Loading {N:,} SMILES from {DATA_PATH}...\")\nt0 = time.time()\n\nsmiles: list[str] = []\nwith open(DATA_PATH) as f:\n for i, line in enumerate(f):\n if i >= N:\n break\n smiles.append(line.strip())\n\nprint(f\" Loaded {len(smiles):,} SMILES in {time.time() - t0:.1f}s\\n\")\n\n# ------------------------------------------------------------------\n# 2. Compute fingerprints\n# ------------------------------------------------------------------\nprint(f\"Computing Morgan fingerprints (radius={FP_RADIUS}, {FP_BITS} bits)...\")\nt0 = time.time()\nfps = fingerprints_from_smiles(\n smiles, fp_type=\"morgan\", radius=FP_RADIUS, n_bits=FP_BITS\n)\nprint(f\" {fps.shape[0]:,} valid / {len(smiles):,} total in {time.time() - t0:.1f}s\\n\")\n\n# ------------------------------------------------------------------\n# 3. Compute molecular properties\n# ------------------------------------------------------------------\nprint(\"Computing molecular properties (MW, LogP, NumRings)...\")\nt0 = time.time()\nprops = molecular_properties(smiles)\nprint(f\" Done in {time.time() - t0:.1f}s\\n\")\n\nmw = props[\"mw\"]\nlogp = props[\"logp\"]\nn_rings = props[\"n_rings\"]\n\nprint(f\"Fitting TMAP on {fps.shape[0]:,} fingerprints...\")\nt0 = time.time()\n\ncfg = LayoutConfig()\ncfg.node_size = 1 / 30\ncfg.deterministic = True\ncfg.seed = 42\n\nmodel = TMAP(metric=\"jaccard\", n_neighbors=20, n_permutations=512, kc=200, layout_config=cfg)\nx, y, s, t_edges = model.fit_transform(fps)\nprint(f\" Layout done in {time.time() - t0:.1f}s\\n\")\n\n# ------------------------------------------------------------------\n# 5. Build visualization\n# ------------------------------------------------------------------\nprint(\"Building TmapViz...\")\nt0 = time.time()\nviz = model.to_tmapviz()\nviz.title = f\"Enamine_{N // 1_000_000}M\"\nviz.add_smiles(smiles)\nviz.add_color_layout(\"MW\", mw.tolist(), categorical=False, color=\"viridis\")\nviz.add_color_layout(\"LogP\", logp.tolist(), categorical=False, color=\"plasma\")\n\n# NumRings as categorical (discrete integer values)\nn_rings_str = [str(int(r)) if np.isfinite(r) else \"?\" for r in n_rings]\nviz.add_color_layout(\"NumRings\", n_rings_str, categorical=True, color=\"tab20\")\nprint(f\" Built in {time.time() - t0:.1f}s\\n\")\n\n# ------------------------------------------------------------------\n# 6. Export + serve\n# ------------------------------------------------------------------\nprint(\"Exporting HTML (binary mode)...\")\nt0 = time.time()\noutpath = viz.write_html(f\"examples/enamine_{N // 1_000_000}m_tmap.html\", mode=\"binary\")\nfsize = os.path.getsize(outpath)\nprint(f\" Written to {outpath} ({fsize / 1e6:.1f} MB) in {time.time() - t0:.1f}s\\n\")\n\nprint(\"Starting serve mode on port 8052...\")\nprint(\"Open http://127.0.0.1:8052\")\nprint(\"Press Ctrl+C to stop.\\n\")\nviz.serve(port=8052, open_browser=True)"
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "PosixPath('31fme.html')"
- ]
- },
- "execution_count": 9,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "viz.title = '31fme.html'\n",
- "viz.write_html('.')\n"
- ]
}
],
"metadata": {
diff --git a/notebooks/06_faq.ipynb b/notebooks/06_faq.ipynb
index 9a98e0a..cec2403 100644
--- a/notebooks/06_faq.ipynb
+++ b/notebooks/06_faq.ipynb
@@ -11,20 +11,21 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## My TMAP has detached branches\n",
+ "## My TMAP has detached branches, or TMAP warns about disconnected components\n",
"\n",
- "Try these in order:\n",
+ "With the default `connect_components=True`, TMAP returns a single tree. If the kNN graph splits into several pieces (usually because `n_neighbors` is too low), TMAP adds the lowest-weight edges that join the pieces and warns. `model.n_components_` is the number of pieces it found and `model.n_bridges_` is the number of edges it added. Pass `connect_components=False` to keep the separate trees.\n",
"\n",
- "1. increase `kc`\n",
- "2. increase `n_neighbors`\n",
- "3. for `jaccard`, increase `n_permutations`\n",
- "4. check whether your data really is split into separate groups\n"
+ "If you see this warning, or branches that look detached, try these in order:\n",
+ "\n",
+ "1. increase `n_neighbors` (all metrics)\n",
+ "2. for sets, strings or sparse input (the MinHash + LSHForest path), increase `kc` and `n_permutations`\n",
+ "3. check whether your data really is split into separate groups\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
- "source": "## My map changes between runs\n\nSet `seed=42`. If you also pass a `LayoutConfig`, set `cfg.deterministic = True` and `cfg.seed = 42`.\n\nThe `seed` controls the OGDF tree layout, which is fully deterministic: same kNN graph + same seed = identical coordinates.\n\nThe kNN step depends on the backend:\n\n- **MinHash + LSHForest** (sets / strings): deterministic for a given seed.\n- **USearch HNSW** (binary matrices, cosine, euclidean): approximate and multi-threaded. Neighbor sets may vary slightly across runs or platforms, but the resulting trees are nearly identical because the MST is robust to small kNN variations.\n\nIf you need bit-exact reproducibility for binary data, use the MinHash + LSHForest pipeline directly (see [12_legacy_lsh_pipeline.ipynb](12_legacy_lsh_pipeline.ipynb))."
+ "source": "## My map changes between runs\n\nThe layout step is always seeded and deterministic: the same kNN graph and the same `seed` give identical coordinates. If you pass a `LayoutConfig`, the estimator sets its `deterministic` and `seed` fields itself, on the object you pass.\n\nDifferences between runs come from the kNN step, which depends on the backend:\n\n- **MinHash + LSHForest** (sets, strings, sparse matrices): deterministic for a given `minhash_seed`.\n- **USearch exact search** (cosine and euclidean below 50,000 points): deterministic.\n- **USearch HNSW** (dense binary matrices, and cosine or euclidean at 50,000 points and above): the index is built on several threads, so repeated runs can return slightly different neighbors. That can change the tree and the layout.\n\nFor identical coordinates on every run, pass `reproducible=True`. TMAP then builds the HNSW index on one thread, which is slower (roughly 5-7x for the HNSW build at 10,000+ points).\n\n```python\nmodel = TMAP(metric=\"jaccard\", reproducible=True).fit(binary_matrix)\n```"
},
{
"cell_type": "markdown",
@@ -32,9 +33,10 @@
"source": [
"## TMAP is slow\n",
"\n",
- "- for `jaccard`, try smaller `n_permutations`\n",
+ "- for sets, strings or sparse input (the MinHash + LSHForest path), try smaller `n_permutations`\n",
"- for dense metrics, USearch uses exact search for small datasets and HNSW for larger ones\n",
- "- reduce `layout_iterations` if layout quality is good enough\n"
+ "- reduce `layout_iterations` if layout quality is good enough\n",
+ "- `reproducible=True` makes the HNSW build several times slower; leave it off if you do not need identical runs\n"
]
},
{
@@ -43,28 +45,34 @@
"source": [
"## Do cosine and euclidean need extra installation?\n",
"\n",
- "No. Dense metrics use USearch from the core install. A plain `python -m pip install .` is enough for the dense backend.\n"
+ "No. Dense metrics use USearch from the core install:\n",
+ "\n",
+ "```\n",
+ "pip install tmap2\n",
+ "```\n",
+ "\n",
+ "PyPI has wheels for Linux x86_64, macOS arm64 and Windows x86_64 on Python 3.11 to 3.13. Building from source (for example `pip install .` in a clone) needs CMake and a C++17 compiler. Optional extras add domain tools: `tmap2[chemistry]` (RDKit), `tmap2[notebook]` (jupyter-scatter), `tmap2[proteins]` (Biopython), `tmap2[singlecell]` (anndata), or `tmap2[all]`.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Why do edges not show in the notebook widget?\n",
+ "## Why do edges not show in the notebook widget, and why does it warn?\n",
"\n",
- "Notebook widgets focus on points, colors, and filters. Use HTML export when you want browser rendering with tree edges.\n"
+ "Notebook widgets focus on points, colors, and filters. When a `TmapViz` that holds tree edges is shown as a widget, it warns \"Edges are not supported in notebook mode yet\" and skips them. Build the viewer with `model.to_tmapviz(include_edges=False)` when you only need the widget. Use HTML export when you want browser rendering with tree edges.\n"
]
},
{
"cell_type": "markdown",
"id": "iaeeohoyhtj",
- "source": "## How do I choose between Jaccard and cosine/euclidean?\n\n- **Jaccard** (default): binary fingerprints, one-hot encodings, sparse binary data. Uses MinHash + LSHForest.\n- **Cosine**: dense embeddings (ESM-2, ProtTrans, sentence transformers). Uses USearch.\n- **Euclidean**: dense features where absolute magnitude matters. Uses USearch.\n- **Precomputed**: you already have a distance matrix. Pass it directly.\n\n```python\n# Binary fingerprints → jaccard\nTMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# Dense embeddings → cosine or euclidean\nTMAP(metric=\"cosine\").fit(embeddings)\n\n# Pre-computed distances\nTMAP(metric=\"precomputed\").fit(distance_matrix)\n```",
+ "source": "## How do I choose between Jaccard and cosine/euclidean?\n\n- **Jaccard** (default): binary fingerprints, one-hot encodings, sparse binary data. A dense 0/1 matrix (NumPy array or DataFrame) uses USearch. Lists of feature indices, lists of strings and SciPy sparse matrices use MinHash + LSHForest (see the last question below).\n- **Cosine**: dense embeddings (ESM-2, ProtTrans, sentence transformers). Uses USearch.\n- **Euclidean**: dense features where absolute magnitude matters. Uses USearch.\n- **Precomputed**: you already have a distance matrix. Pass it directly.\n\n```python\n# Binary fingerprints → jaccard\nTMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# Dense embeddings → cosine or euclidean\nTMAP(metric=\"cosine\").fit(embeddings)\n\n# Pre-computed distances\nTMAP(metric=\"precomputed\").fit(distance_matrix)\n```",
"metadata": {}
},
{
"cell_type": "markdown",
"id": "u6x4433h1r",
- "source": "## How do I add new points to an existing map?\n\n`add_points()` inserts new points into a fitted model — extends the tree and embedding without refitting.\n`transform()` places new points on the map without modifying the model.\n\n```python\nmodel = TMAP().fit(X_train)\nmodel.add_points(X_new) # mutates model, extends tree\ncoords = model.transform(X_test) # read-only projection\n```",
+ "source": "## How do I add new points to an existing map?\n\n`add_points()` inserts new points into a fitted model. It extends the tree and embedding without refitting.\n`transform()` places new points on the map without modifying the model.\n\nFor cosine and euclidean, fit with `store_index=True`, because both methods query the stored index. On the Jaccard path, `add_points()` needs a binary matrix and raises `TypeError` if `fit()` used sets or strings.\n\n```python\nmodel = TMAP(metric=\"cosine\", store_index=True).fit(X_train)\nmodel.add_points(X_new) # mutates model, extends tree\ncoords = model.transform(X_test) # read-only projection\n```",
"metadata": {}
},
{
@@ -88,7 +96,7 @@
{
"cell_type": "markdown",
"id": "14585wqhmi1",
- "source": "## What is `kc` and when should I change it?\n\n`kc` controls the number of random augmentation edges added during MST construction. Higher `kc` produces better-connected trees (fewer detached branches) at the cost of longer layout time. Default is 50, which works well for most datasets.",
+ "source": "## What is `kc` and when should I change it?\n\n`kc` is the query multiplier for the LSHForest. Each query collects `n_neighbors * kc` candidates from the forest and ranks them by the Jaccard distance estimated from their full MinHash signatures. Higher `kc` usually gives better recall and a better-connected kNN graph, at the cost of longer query time. The default is 50.\n\n`kc` only matters on the MinHash + LSHForest path: sets, strings and sparse input with `metric=\"jaccard\"`. Dense binary matrices and the cosine and euclidean metrics use USearch and ignore it.",
"metadata": {}
},
{
@@ -100,7 +108,7 @@
{
"cell_type": "markdown",
"id": "zu61ntx8o8",
- "source": "## Binary fingerprints: MinHash or USearch Jaccard?\n\nThe estimator auto-routes binary matrices to USearch and sets/strings to MinHash + LSHForest.\n\n| | USearch binary Jaccard | MinHash + LSHForest |\n|---|---|---|\n| **Distances** | Exact Jaccard | Approximate (via signatures) |\n| **Speed** | Fast (multi-threaded HNSW) | Moderate (Numba-accelerated) |\n| **Determinism** | Approximate (HNSW is multi-threaded) | Fully deterministic for a given seed |\n\nIf you need exact reproducibility across runs, use the MinHash + LSHForest path by passing sparse index lists instead of a dense binary matrix:\n\n```python\n# USearch path (fast, approximate determinism)\nmodel = TMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# MinHash+LSH path (deterministic)\nsets = [np.where(row)[0].tolist() for row in binary_matrix]\nmodel = TMAP(metric=\"jaccard\", seed=42).fit(sets)\n```",
+ "source": "## Binary fingerprints: MinHash or USearch Jaccard?\n\nThe estimator auto-routes dense binary matrices to USearch, and sets, strings and sparse matrices to MinHash + LSHForest.\n\n| | USearch binary Jaccard | MinHash + LSHForest |\n|---|---|---|\n| **Distances** | Exact Jaccard | Approximate (via signatures) |\n| **Speed** | Fast (multi-threaded HNSW) | Moderate (Numba-accelerated) |\n| **Determinism** | Can vary slightly between runs (multi-threaded HNSW build); identical with `reproducible=True` | Fully deterministic for a given `minhash_seed` |\n\nFor identical results across runs on the USearch path, pass `reproducible=True` (see \"My map changes between runs\"). To use the MinHash + LSHForest path, pass lists of feature indices (or a SciPy sparse matrix):\n\n```python\n# USearch path (fast)\nmodel = TMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# USearch path, identical results on every run (slower build)\nmodel = TMAP(metric=\"jaccard\", reproducible=True).fit(binary_matrix)\n\n# MinHash + LSH path\nsets = [np.where(row)[0].tolist() for row in binary_matrix]\nmodel = TMAP(metric=\"jaccard\", seed=42).fit(sets)\n```",
"metadata": {}
}
],
diff --git a/notebooks/07_minhash_deep_dive.ipynb b/notebooks/07_minhash_deep_dive.ipynb
index 555bbbf..bc5be60 100644
--- a/notebooks/07_minhash_deep_dive.ipynb
+++ b/notebooks/07_minhash_deep_dive.ipynb
@@ -3,7 +3,7 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": "# MinHash Deep Dive: Choosing the Right Encoding Method\n\nThis notebook explores the different MinHash encoding methods and when to use each one.\n\n## Key Concepts\n\n- **MinHash** compresses data into fixed-size signatures that preserve Jaccard similarity\n- **Binary methods** use permutation-based hashing (fast, for fingerprints)\n- **String methods** use xxhash64 hashing (for text/tokens)\n- **Binary and string signatures are NOT comparable** (different hash functions!)"
+ "source": "# MinHash Deep Dive: Choosing the Right Encoding Method\n\nThis notebook explores the different MinHash encoding methods and when to use each one.\n\nIt covers the lower-level `MinHash` API. With `metric=\"jaccard\"`, `TMAP.fit` sends dense 0/1 matrices to USearch and uses MinHash + LSHForest only for lists of feature indices, lists of strings and SciPy sparse matrices.\n\n## Concepts\n\n- **MinHash** compresses data into fixed-size signatures that preserve Jaccard similarity\n- **Binary methods** use the positions of set bits as element IDs (fast, for fingerprints)\n- **String methods** first map each token to a 63-bit integer ID with xxhash64 (for text/tokens)\n- All methods then run the same Numba permutation MinHash on those IDs. Because the IDs differ, **binary and string signatures are not comparable**"
},
{
"cell_type": "code",
@@ -50,7 +50,7 @@
"source": [
"## 1. Binary Methods (for Fingerprints)\n",
"\n",
- "Use these when your data is binary (0/1) - molecular fingerprints, one-hot encodings, etc."
+ "Use these when your data is binary (0/1): molecular fingerprints, one-hot encodings, etc."
]
},
{
@@ -106,7 +106,7 @@
}
],
"source": [
- "# RECOMMENDED: batch_from_binary_array for dense fingerprints\n",
+ "# batch_from_binary_array: the MinHash method for a dense 0/1 fingerprint matrix\n",
"mh = MinHash(num_perm=128, seed=42)\n",
"\n",
"start = time.time()\n",
@@ -153,7 +153,7 @@
"source": [
"## 2. Sparse Methods (for Large/Sparse Fingerprints)\n",
"\n",
- "When fingerprints are very sparse (few bits set), storing only the indices is more efficient."
+ "When fingerprints are very sparse (few bits set), storing only the indices is more efficient. `batch_from_binary_array` already switches to the sparse kernel when fewer than 30% of the entries are 1, so on typical fingerprints both methods run the same kernel."
]
},
{
@@ -304,6 +304,7 @@
"lsh.index()\n",
"\n",
"# Query: which documents are most similar to doc 0?\n",
+ "# Doc 0 is in the index, so it comes back as its own nearest neighbor.\n",
"neighbors = lsh.query(signatures_text[0], k=3)\n",
"print(f\"\\nDocuments most similar to doc 0 ({documents[0]}):\")\n",
"for idx in neighbors:\n",
@@ -313,7 +314,7 @@
{
"cell_type": "markdown",
"metadata": {},
- "source": "## 4. Critical Warning: Binary vs String Incompatibility\n\n**Binary and string methods use different hash functions!**\n\n- Binary: Permutation-based (fast, Numba-accelerated)\n- String: xxhash64 based (slower, handles arbitrary strings)\n\n**You CANNOT compare signatures from different methods!**"
+ "source": "## 4. Warning: Binary and String Signatures Are Incompatible\n\n**Binary and string methods give the same data different element IDs.**\n\n- Binary: the position of each set bit is its element ID (fast, Numba-accelerated)\n- String: each token is first hashed to a 63-bit integer ID with xxhash64 (slower, handles arbitrary strings)\n\nBoth then run the same permutation MinHash. Bit 3 and the string `\"3\"` get different element IDs, so their hash values differ.\n\n**Do not compare or mix signatures from different methods.**"
},
{
"cell_type": "code",
@@ -332,7 +333,7 @@
"\n",
" Are they equal? False\n",
"\n",
- "⚠️ NEVER mix binary and string signatures in the same LSHForest!\n"
+ "Do not mix binary and string signatures in the same LSHForest.\n"
]
}
],
@@ -352,7 +353,7 @@
"print(f\" Binary signature: {sig_binary[:8]}...\")\n",
"print(f\" String signature: {sig_string[:8]}...\")\n",
"print(f\"\\n Are they equal? {np.array_equal(sig_binary, sig_string)}\")\n",
- "print(\"\\n NEVER mix binary and string signatures in the same LSHForest!\")\n"
+ "print(\"\\nDo not mix binary and string signatures in the same LSHForest.\")\n"
]
},
{
@@ -418,9 +419,9 @@
"| num_perm | Accuracy | Speed | Memory | Use Case |\n",
"|----------|----------|-------|--------|----------|\n",
"| 64 | Lower | Fastest | Lowest | Quick exploration |\n",
- "| 128 | Good | Fast | Low | **Default, most cases** |\n",
+ "| 128 | Good | Fast | Low | **`MinHash` class default**, most cases |\n",
"| 256 | High | Medium | Medium | High precision needed |\n",
- "| 512 | Very High | Slower | Higher | Very similar items |"
+ "| 512 | Very High | Slower | Higher | Very similar items; **`TMAP` default** (`n_permutations=512`) |"
]
},
{
@@ -451,7 +452,7 @@
"fp1 = np.zeros(1000, dtype=np.uint8)\n",
"fp2 = np.zeros(1000, dtype=np.uint8)\n",
"\n",
- "# Set bits to achieve ~0.7 Jaccard similarity\n",
+ "# Set bits so that 70 of the 130 bits in the union are shared: Jaccard = 70/130, about 0.54\n",
"fp1[:100] = 1 # 100 bits in fp1\n",
"fp2[:70] = 1 # 70 shared + 30 unique to fp2\n",
"fp2[100:130] = 1\n",
@@ -487,7 +488,7 @@
"├─► Binary fingerprints (0/1 arrays)\n",
"│ │\n",
"│ ├─► Dense format (numpy 2D array)\n",
- "│ │ └─► batch_from_binary_array() ✓ RECOMMENDED\n",
+ "│ │ └─► batch_from_binary_array()\n",
"│ │\n",
"│ └─► Sparse format (list of index lists)\n",
"│ └─► batch_from_sparse_binary_array()\n",
@@ -495,7 +496,7 @@
"└─► Text/tokens (strings)\n",
" └─► batch_from_string_array()\n",
"\n",
- "⚠️ Never mix binary and string signatures!\n",
+ "Do not mix binary and string signatures.\n",
"```"
]
}
diff --git a/notebooks/08_jscatter_demo.ipynb b/notebooks/08_jscatter_demo.ipynb
index c3d7b53..fe45276 100644
--- a/notebooks/08_jscatter_demo.ipynb
+++ b/notebooks/08_jscatter_demo.ipynb
@@ -16,10 +16,9 @@
"- **Export** to DataFrame\n",
"\n",
"\n",
- "First install jupyter-scatter\n",
+ "First install jupyter-scatter and RDKit:\n",
"\n",
- "`pip install jupyter-scatter` or \n",
- "`pip install \"tmap2[notebook]\"` <- don't forget the `\" \"`!"
+ "`pip install \"tmap2[notebook,chemistry]\"` <- don't forget the `\" \"`!"
]
},
{
@@ -53,7 +52,11 @@
"df = pd.read_csv(\"../examples/cluster_65053.csv\", nrows=2000)\n",
"smiles = df[\"smiles\"].tolist()\n",
"\n",
- "fps = fingerprints_from_smiles(smiles, fp_type=\"morgan\", radius=2, n_bits=2048)\n",
+ "fps, valid = fingerprints_from_smiles(\n",
+ " smiles, fp_type=\"morgan\", radius=2, n_bits=2048, return_valid=True\n",
+ ")\n",
+ "# Keep only the SMILES RDKit could read, so every row lines up with fps\n",
+ "smiles = [s for s, ok in zip(smiles, valid) if ok]\n",
"props = molecular_properties(smiles, properties=[\"mw\", \"logp\", \"n_rings\"])\n",
"\n",
"model = TMAP(metric=\"jaccard\", seed=42).fit(fps)\n",
@@ -112,7 +115,7 @@
"source": [
"## 2. TmapViz Widget with Controls\n",
"\n",
- "`to_tmapviz()` builds a visualization object with multiple color layers. The `to_widget()` method renders it as a notebook widget with a dropdown to switch between layers."
+ "`to_tmapviz()` builds a visualization object with multiple color layers. The `to_widget()` method renders it as a notebook widget with a dropdown to switch between layers. Notebook widgets draw points only, so we leave out the tree edges with `include_edges=False`."
]
},
{
@@ -121,14 +124,6 @@
"id": "2234ye50sdz",
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_38011/3818785059.py:8: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n",
- " widget = viz.to_widget(width=1000, height=650, controls=True)\n"
- ]
- },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
@@ -146,7 +141,7 @@
}
],
"source": [
- "viz = model.to_tmapviz()\n",
+ "viz = model.to_tmapviz(include_edges=False)\n",
"viz.title = \"Molecule Explorer\"\n",
"viz.add_smiles(smiles)\n",
"viz.add_color_layout(\"MW\", props[\"mw\"].tolist(), color=\"viridis\")\n",
@@ -305,21 +300,13 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": null,
"id": "rdhb71a8yia",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Showing 2000 of 2000 points\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "# Show only molecules with >= 3 rings\n",
- "heavy = df[df[\"n_rings\"] >= 3].index.tolist()\n",
+ "# Show only molecules with >= 4 rings\n",
+ "heavy = df[df[\"n_rings\"] >= 4].index.tolist()\n",
"scatter.filter(heavy)\n",
"print(f\"Showing {len(heavy)} of {len(df)} points\")\n",
"\n",
@@ -334,7 +321,7 @@
"source": [
"## 7. Export to DataFrame\n",
"\n",
- "Two export paths: `viz.to_dataframe()` for full metadata with coordinates, or use `scatter.selection()` indices to slice your own DataFrame."
+ "Two export paths: `viz.to_dataframe()` for full metadata with coordinates, or use the `widget.selection()` indices to slice your own DataFrame."
]
},
{
@@ -343,14 +330,6 @@
"id": "79451f09",
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_38011/2819450684.py:1: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n",
- " widget = viz.to_widget()\n"
- ]
- },
{
"data": {
"application/vnd.jupyter.widget-view+json": {
@@ -385,40 +364,21 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": null,
"id": "ggadel3cohe",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Index for selected poitns: []\n",
- "\n",
- "Selected subset: (50, 4)\n",
- " smiles mw logp \\\n",
- "0 C=C1CCN(C(=O)C2=CC=C(Cl)C=N2)C(C(=O)N2CCC(=C(F... 395.121211 3.6688 \n",
- "1 C=C1CCN(C(=O)C2=CC=C(F)C(F)=C2)C(C(=O)N2CC=CCO... 348.128549 2.4556 \n",
- "2 C=C1CCN(C(=O)C2=CC=C(F)C(F)=C2)C(C(=O)N2CCOCC2)C1 350.144199 1.9844 \n",
- "\n",
- " n_rings \n",
- "0 3.0 \n",
- "1 3.0 \n",
- "2 3.0 \n"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "# # Export all metadata + coordinates from TmapViz\n",
- "# viz_df = viz.to_dataframe(include_coords=True)\n",
- "# print(f\"Exported DataFrame: {viz_df.shape}\")\n",
- "# print(viz_df.head(3))\n",
+ "# Export all metadata + coordinates from TmapViz\n",
+ "viz_df = viz.to_dataframe(include_coords=True)\n",
+ "print(f\"Exported DataFrame: {viz_df.shape}\")\n",
+ "print(viz_df.head(3))\n",
"\n",
"# Check the points you just selected\n",
- "print(\"Index for selected poitns: \",widget.selection())\n",
+ "print(\"Index for selected points: \", widget.selection())\n",
"\n",
"# Export just selected points\n",
- "selected_idx = scatter.selection()\n",
+ "selected_idx = widget.selection()\n",
"if len(selected_idx) > 0:\n",
" selected_df = df.iloc[selected_idx]\n",
" print(f\"\\nSelected subset: {selected_df.shape}\")\n",
@@ -432,9 +392,9 @@
"source": [
"## Notes\n",
"\n",
- "- `model.plot()` is the quickest path -- returns a `jscatter.Scatter` directly\n",
+ "- `model.plot()` is the quickest path and returns a `jscatter.Scatter` directly\n",
"- `viz.to_widget()` adds a color-switching dropdown for multiple layers\n",
- "- Tree edges are not drawn in notebook widgets -- use `model.to_html()` for edge rendering\n",
+ "- Notebook widgets draw points only; `model.to_html()` writes an HTML map with the tree edges\n",
"- Full jscatter API: https://jscatter.dev"
]
}
diff --git a/notebooks/09_card_configuration.ipynb b/notebooks/09_card_configuration.ipynb
index 7ec4aa6..deea8d1 100644
--- a/notebooks/09_card_configuration.ipynb
+++ b/notebooks/09_card_configuration.ipynb
@@ -38,8 +38,6 @@
}
],
"source": [
- "from urllib.parse import quote\n",
- "\n",
"import pandas as pd\n",
"\n",
"from tmap import TMAP\n",
@@ -48,14 +46,19 @@
"df = pd.read_csv(\"../examples/cluster_65053.csv\", nrows=1500)\n",
"smiles = df[\"smiles\"].tolist()\n",
"cluster_ids = df[\"cluster_id2\"].astype(str).tolist()\n",
+ "\n",
+ "fps, valid = fingerprints_from_smiles(\n",
+ " smiles, fp_type=\"morgan\", radius=2, n_bits=2048, return_valid=True\n",
+ ")\n",
+ "# Keep only the rows RDKit could read, so every list lines up with fps\n",
+ "smiles = [s for s, ok in zip(smiles, valid) if ok]\n",
+ "cluster_ids = [c for c, ok in zip(cluster_ids, valid) if ok]\n",
"molecule_ids = [f\"Mol-{i:05d}\" for i in range(len(smiles))]\n",
"\n",
- "fps = fingerprints_from_smiles(smiles, fp_type=\"morgan\", radius=2, n_bits=2048)\n",
"props = molecular_properties(smiles, properties=[\"mw\", \"logp\", \"n_rings\", \"qed\"])\n",
"scaffolds = murcko_scaffolds(smiles).tolist()\n",
- "pubchem_urls = [f\"https://pubchem.ncbi.nlm.nih.gov/#query={quote(s)}\" for s in smiles]\n",
"\n",
- "model = TMAP(metric=\"jaccard\", n_neighbors=20, kc=50, seed=42).fit(fps)\n",
+ "model = TMAP(metric=\"jaccard\", n_neighbors=20, seed=42).fit(fps)\n",
"print(f\"Fitted: {model.embedding_.shape[0]} molecules\")\n"
]
},
@@ -66,7 +69,7 @@
"metadata": {},
"outputs": [],
"source": [
- "def make_viz(include_urls: bool = False):\n",
+ "def make_viz():\n",
" viz = model.to_tmapviz()\n",
" viz.title = \"Card Configuration Demo\"\n",
" viz.add_smiles(smiles)\n",
@@ -77,9 +80,7 @@
" viz.add_color_layout(\"QED\", props[\"qed\"].tolist(), color=\"magma\")\n",
" viz.add_label(\"Molecule ID\", molecule_ids)\n",
" viz.add_label(\"Murcko Scaffold\", scaffolds)\n",
- " if include_urls:\n",
- " viz.add_label(\"PubChem URL\", pubchem_urls)\n",
- " viz.configure_column(\"smiles\", display_name=\"SMILES\", copyable=True)\n",
+ " viz.configure_column(\"SMILES\", copyable=True)\n",
" viz.configure_column(\"Murcko Scaffold\", copyable=True)\n",
" return viz\n"
]
@@ -229,7 +230,10 @@
"source": [
"## 6. Add Links\n",
"\n",
- "Here we add a per-molecule PubChem search button.\n"
+ "Here we add a per-molecule PubChem search button. In the `url` template, `{SMILES}` is\n",
+ "replaced with each molecule's SMILES, URL-encoded. Any column name in braces works the\n",
+ "same way. Because the inserted value is URL-encoded, keep the fixed part of the address\n",
+ "in the template and fill in an ID or SMILES column.\n"
]
},
{
@@ -250,13 +254,13 @@
}
],
"source": [
- "viz = make_viz(include_urls=True)\n",
+ "viz = make_viz()\n",
"viz.configure_card(\n",
" title_column=\"Molecule ID\",\n",
" subtitle_column=\"Murcko Scaffold\",\n",
" fields=[\"Cluster\", \"MW\", \"LogP\", \"QED\"],\n",
" links=[\n",
- " {\"label\": \"PubChem Search\", \"url\": \"{PubChem URL}\"},\n",
+ " {\"label\": \"PubChem Search\", \"url\": \"https://pubchem.ncbi.nlm.nih.gov/#query={SMILES}\"},\n",
" ],\n",
")\n",
"viz.write_html(\"card_5_links.html\")\n"
@@ -278,14 +282,6 @@
"id": "edf0cd06",
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81838/959893289.py:2: UserWarning: configure_card references columns not yet added: ['smiles']. Add them before calling to_html() or the card will be incomplete.\n",
- " viz.configure_card(\n"
- ]
- },
{
"data": {
"text/plain": [
@@ -298,13 +294,13 @@
}
],
"source": [
- "viz = make_viz(include_urls=True)\n",
+ "viz = make_viz()\n",
"viz.configure_card(\n",
" title_column=\"Molecule ID\",\n",
" subtitle_column=\"Murcko Scaffold\",\n",
- " fields=[\"Cluster\", \"MW\", \"LogP\", \"Ring Count\", \"QED\", \"smiles\"],\n",
+ " fields=[\"Cluster\", \"MW\", \"LogP\", \"Ring Count\", \"QED\", \"SMILES\"],\n",
" links=[\n",
- " {\"label\": \"PubChem Search\", \"url\": \"{PubChem URL}\"},\n",
+ " {\"label\": \"PubChem Search\", \"url\": \"https://pubchem.ncbi.nlm.nih.gov/#query={SMILES}\"},\n",
" ],\n",
")\n",
"viz.write_html(\"card_6_full.html\")\n"
diff --git a/notebooks/10_protein_analysis.ipynb b/notebooks/10_protein_analysis.ipynb
index a1955c8..bc767fe 100644
--- a/notebooks/10_protein_analysis.ipynb
+++ b/notebooks/10_protein_analysis.ipynb
@@ -7,17 +7,17 @@
"source": [
"# Protein Analysis Workflow\n",
"\n",
- "Two common starting points for protein TMAP:\n",
+ "Three common starting points for protein TMAP:\n",
"\n",
- "- **Part A** -- You have a FASTA file and want to explore sequence properties. \n",
- " No external dependencies beyond TMAP.\n",
- "- **Part B** -- You have pre-computed embeddings (ESM, ESM-2, ProtTrans, etc.) and want\n",
+ "- **Part A**: You have a FASTA file and want to explore sequence properties. \n",
+ " Uses Biopython for sequence properties and jupyter-scatter for the interactive plots.\n",
+ "- **Part B**: You have pre-computed embeddings (ESM, ESM-2, ProtTrans, etc.) and want\n",
" to build a large-scale map with AlphaFold / UniProt annotations.\n",
- " Requires pre-computed embedding files.\n",
- "- **Part C** -- You have all-vs-all alignment results (MMseqs2, Foldseek, BLAST)\n",
+ " Requires pre-computed embedding files and network access.\n",
+ "- **Part C**: You have all-vs-all alignment results (MMseqs2, Foldseek, BLAST)\n",
" and want to build a TMAP from sequence or structure similarity.\n",
"\n",
- "**Requirements:** `pip install tmap`"
+ "**Requirements:** `pip install \"tmap2[proteins,notebook]\"` (Biopython and jupyter-scatter)"
]
},
{
@@ -28,15 +28,19 @@
"---\n",
"## Part A: From FASTA to TMAP\n",
"\n",
- "The most common starting point -- you have a FASTA file of protein sequences.\n",
+ "The most common starting point: you have a FASTA file of protein sequences.\n",
"\n",
- "TMAP provides three file readers in `tmap.utils`:\n",
+ "`tmap.utils` provides these readers for sequence and ID files:\n",
"\n",
"| Format | Function | Input |\n",
"|--------|----------|-------|\n",
"| FASTA (.fa, .fasta) | `read_fasta(path)` | Sequences + headers |\n",
"| CSV / TSV | `read_protein_csv(path, id_col, seq_col)` | Tabular data |\n",
- "| ID list (.txt) | `read_id_list(path)` | One UniProt accession per line |"
+ "| ID list (.txt) | `read_id_list(path)` | One UniProt accession per line |\n",
+ "\n",
+ "For structures, `read_pdb(path)` and `read_pdb_dir(directory)` extract sequences and\n",
+ "B-factor statistics from PDB files (needs Biopython). For alignment results,\n",
+ "`parse_alignment(path)` builds a neighbor graph from MMseqs2 / Foldseek / BLAST output (Part C)."
]
},
{
@@ -44,7 +48,12 @@
"id": "fasta-header",
"metadata": {},
"source": [
- "### 1. Load sequences from FASTA"
+ "### 1. Load sequences from FASTA\n",
+ "\n",
+ "This example uses the SCOPe ASTRAL 40% subset (protein domains with a SCOP structural\n",
+ "class). The file is not in the repository: download the SCOPe ASTRAL 40% FASTA from the\n",
+ "SCOPe website (scop.berkeley.edu) and save it as `../examples/data/scope_cache/astral_40.fa`,\n",
+ "or point `fasta_path` at your own FASTA file."
]
},
{
@@ -58,7 +67,7 @@
"output_type": "stream",
"text": [
"15177 sequences loaded\n",
- "Length range: 20 -- 1664 aa\n",
+ "Length range: 20 to 1664 aa\n",
"First ID: d1dlwa_\n",
"First seq: SLFEQLGGQAAVQAVTAQFYANIQADATVATFFNGIDMPNQTNKTAAFLCAALGGPNAWT...\n"
]
@@ -68,11 +77,12 @@
"import numpy as np\n",
"from tmap.utils import read_fasta\n",
"\n",
- "# SCOPe ASTRAL 40% subset -- protein domains with structural classification\n",
- "ids_fasta, sequences = read_fasta(\"../examples/data/scope_cache/astral_40.fa\", max_seqs=50_000)\n",
+ "# SCOPe ASTRAL 40% subset: protein domains with structural classification\n",
+ "fasta_path = \"../examples/data/scope_cache/astral_40.fa\"\n",
+ "ids_fasta, sequences = read_fasta(fasta_path, max_seqs=50_000)\n",
"\n",
"print(f\"{len(sequences)} sequences loaded\")\n",
- "print(f\"Length range: {min(len(s) for s in sequences)} -- {max(len(s) for s in sequences)} aa\")\n",
+ "print(f\"Length range: {min(len(s) for s in sequences)} to {max(len(s) for s in sequences)} aa\")\n",
"print(f\"First ID: {ids_fasta[0]}\")\n",
"print(f\"First seq: {sequences[0][:60]}...\")\n"
]
@@ -101,7 +111,8 @@
"### 2. Compute sequence properties\n",
"\n",
"`sequence_properties` computes physicochemical descriptors from amino acid\n",
- "sequences -- no external dependencies, no network access."
+ "sequences. It runs offline and uses Biopython (ProtParam) for molecular weight,\n",
+ "isoelectric point, GRAVY, charge and aromaticity."
]
},
{
@@ -155,7 +166,7 @@
"\n",
"For a quick exploration without pre-computed embeddings, we can encode\n",
"sequences as **k-mer frequency vectors** and use cosine distance.\n",
- "This is fast and dependency-free -- a good first pass before investing in\n",
+ "This is fast and dependency-free, a good first pass before investing in\n",
"ESM-2 embeddings."
]
},
@@ -251,8 +262,13 @@
" \"d\": \"Alpha+beta\", \"e\": \"Multi-domain\", \"f\": \"Membrane\", \"g\": \"Small\",\n",
"}\n",
"scop_re = re.compile(r\"\\s([a-g])\\.\\d+\\.\\d+\\.\\d+\\s\")\n",
+ "# read_fasta keeps only the first word of each header (the domain ID), so read\n",
+ "# the SCOP class from the full header lines, e.g. \">d1dlwa_ a.1.1.1 (A:) ...\"\n",
+ "with open(fasta_path) as f:\n",
+ " headers = [line for line in f if line.startswith(\">\")][: len(ids_fasta)]\n",
+ "\n",
"classes = []\n",
- "for h in ids_fasta:\n",
+ "for h in headers:\n",
" m = scop_re.search(h)\n",
" classes.append(scop_class_names.get(m.group(1), \"other\") if m else \"other\")\n",
"\n",
@@ -274,8 +290,10 @@
"source": [
"### 5. TmapViz export\n",
"\n",
- "Pass the sequence properties dict directly to `add_color_layout` --\n",
- "it auto-detects continuous vs. categorical for each column."
+ "Add each sequence property as a color layer with `add_color_layout`. Layers are\n",
+ "continuous by default; pass `categorical=True` for discrete columns such as the SCOP class.\n",
+ "This viz is only shown as a notebook widget, which draws points only, so we skip the\n",
+ "tree edges with `include_edges=False`."
]
},
{
@@ -285,8 +303,8 @@
"metadata": {},
"outputs": [],
"source": [
- "viz = model_fasta.to_tmapviz()\n",
- "viz.title = \"SCOPe Protein Domains -- 3-mer TMAP\"\n",
+ "viz = model_fasta.to_tmapviz(include_edges=False)\n",
+ "viz.title = \"SCOPe Protein Domains (3-mer TMAP)\"\n",
"\n",
"# Bulk-add all sequence properties as color layers\n",
"for key in seq_props.keys():\n",
@@ -325,9 +343,10 @@
"metadata and UniProt annotations.\n",
"\n",
"ESM-2 embeddings can be generated with:\n",
- "- `esm` Python package (Meta)\n",
- "- ESM Metagenomic Atlas API\n",
- "- Local inference with `fair-esm`"
+ "- Local inference with Meta's `fair-esm` package (imported as `esm`)\n",
+ "- ESM Metagenomic Atlas API (ESM-2 data for metagenomic proteins)\n",
+ "\n",
+ "ESM C embeddings come from the `esm` SDK, first released by EvolutionaryScale and now maintained by CZ Biohub (github.com/Biohub/esm). `examples/proteins/esm_atlas_tmap.py` shows the install line."
]
},
{
@@ -335,11 +354,12 @@
"id": "load-emb-header",
"metadata": {},
"source": [
- "### 5. Load embeddings\n",
+ "### 6. Load embeddings\n",
"\n",
- "This assumes pre-computed embeddings saved as NumPy arrays.\n",
- "The paths `../data/embeddings.npy` and `../data/ids.npy` are dataset-specific --\n",
- "replace them with your own."
+ "This assumes pre-computed embeddings saved as NumPy arrays: one embedding row per\n",
+ "protein in `embeddings.npy` and the matching UniProt accessions in `ids.npy`.\n",
+ "These files are not in the repository. The paths `../data/embeddings.npy` and\n",
+ "`../data/ids.npy` are dataset-specific; replace them with your own."
]
},
{
@@ -362,7 +382,7 @@
"id": "fit-emb-header",
"metadata": {},
"source": [
- "### 6. Fit TMAP on embeddings\n",
+ "### 7. Fit TMAP on embeddings\n",
"\n",
"Euclidean is the recommended metric for ESM-2 embeddings.\n",
"USearch handles the dense nearest-neighbor search automatically."
@@ -375,7 +395,7 @@
"metadata": {},
"outputs": [],
"source": [
- "# Euclidean is the recommended for ESM embeddings. Cosine should work as well\n",
+ "# Euclidean is recommended for ESM embeddings. Cosine should work as well\n",
"model = TMAP(metric=\"euclidean\", n_neighbors=20, seed=42).fit(embeddings)\n",
"\n",
"print(f\"Embedding: {model.embedding_.shape}\")\n",
@@ -387,9 +407,9 @@
"id": "af-header",
"metadata": {},
"source": [
- "### 7. Fetch AlphaFold structural metadata\n",
+ "### 8. Fetch AlphaFold structural metadata\n",
"\n",
- "`fetch_alphafold` queries the AlphaFold DB REST API -- one request per protein,\n",
+ "`fetch_alphafold` queries the AlphaFold DB REST API with one request per protein,\n",
"threaded with 20 workers. For 49k proteins this takes a few minutes.\n",
"\n",
"Returns `float32` arrays with NaN for proteins not in AlphaFold DB (~14% missing)."
@@ -417,7 +437,7 @@
"id": "uniprot-header",
"metadata": {},
"source": [
- "### 8. Fetch UniProt annotations\n",
+ "### 9. Fetch UniProt annotations\n",
"\n",
"`fetch_uniprot` batch-fetches text annotations (organism, GO terms,\n",
"subcellular location, etc.) via the UniProt REST API."
@@ -446,10 +466,11 @@
"id": "viz-emb-header",
"metadata": {},
"source": [
- "### 9. Visualize with `add_metadata`\n",
+ "### 10. Visualize with `add_color_layout` and `add_label`\n",
"\n",
- "Now we combine everything into a single visualization. `add_metadata`\n",
- "auto-detects continuous vs categorical -- pass the AlphaFold dict directly."
+ "Now we combine everything into a single visualization. Numeric AlphaFold and\n",
+ "UniProt fields become continuous color layers with `add_color_layout`; text fields\n",
+ "become tooltip labels with `add_label`."
]
},
{
@@ -460,7 +481,7 @@
"outputs": [],
"source": [
"viz = model.to_tmapviz()\n",
- "viz.title = \"Protein Embedding Space -- 49k ESM-2\"\n",
+ "viz.title = \"Protein Embedding Space (49k ESM-2)\"\n",
"\n",
"# AlphaFold structural metrics as color layers\n",
"viz.add_color_layout(\"pLDDT\", af_data[\"plddt\"].tolist())\n",
@@ -508,7 +529,7 @@
"id": "explore-header",
"metadata": {},
"source": [
- "### 10. Tree exploration\n",
+ "### 11. Tree exploration\n",
"\n",
"Pick a high-confidence protein and trace pseudotime from it."
]
@@ -535,10 +556,10 @@
"id": "cache-header",
"metadata": {},
"source": [
- "### 11. Caching fetched data\n",
+ "### 12. Caching fetched data\n",
"\n",
- "`fetch_alphafold` and `fetch_uniprot` are stateless -- they don't cache\n",
- "results. For large datasets, save the results yourself:"
+ "`fetch_alphafold` and `fetch_uniprot` keep no cache, so each call queries the\n",
+ "APIs again. For large datasets, save the results yourself:"
]
},
{
@@ -566,8 +587,8 @@
"\n",
"When you have all-vs-all alignment results from MMseqs2, Foldseek, or BLAST,\n",
"you can build a TMAP directly from pairwise similarity scores using\n",
- "`parse_alignment`. This avoids embedding entirely -- the alignment scores\n",
- "*are* the similarity metric.\n",
+ "`parse_alignment`. The alignment scores define the neighbors directly, so this\n",
+ "route needs no embeddings.\n",
"\n",
"Input: standard BLAST6 / m8 tabular format (12 tab-separated columns):\n",
"```\n",
@@ -605,11 +626,15 @@
"\n",
"This works with:\n",
"- **MMseqs2** `easy-search` or `search` output\n",
- "- **Foldseek** `easy-search` (structure similarity via 3Di + TM-score)\n",
+ "- **Foldseek** `easy-search` (structure similarity from 3Di+AA alignments)\n",
"- **BLAST** `-outfmt 6` tabular output\n",
"\n",
- "Use `score_col=\"evalue\"` for E-value-based ranking (lower = better;\n",
- "`parse_alignment` handles the inversion automatically via `as_distance=True`)."
+ "Use the default `score_col=\"bitscore\"` (or `\"pident\"`).\n",
+ "\n",
+ "**Note:** avoid `score_col=\"evalue\"` for now. It selects the right top-k hits, but\n",
+ "with `as_distance=True` it converts E-values to distances as `-log10(evalue)`,\n",
+ "which gives the best hits the *largest* distances, so the tree favors the\n",
+ "weakest of those hits."
]
},
{
@@ -639,8 +664,8 @@
"| Interactive plot | `model.plot(color_by=\"gravy\", data=props_df)` |\n",
"| TmapViz export | `viz.add_color_layout(key, props[key])` |\n",
"\n",
- "For higher quality, replace k-mers with ESM-2 embeddings\n",
- "(see `examples/protein_fold_space.py`).\n",
+ "For higher quality, replace k-mers with protein language model embeddings such as\n",
+ "ESM-2 or ESM C (`examples/proteins/esm_atlas_tmap.py` builds maps from ESM C embeddings).\n",
"\n",
"### Part B: Embeddings + API annotations\n",
"\n",
diff --git a/notebooks/11_usearch_jaccard.ipynb b/notebooks/11_usearch_jaccard.ipynb
index bce2a0a..fafc846 100644
--- a/notebooks/11_usearch_jaccard.ipynb
+++ b/notebooks/11_usearch_jaccard.ipynb
@@ -7,9 +7,12 @@
"source": [
"# USearch Jaccard: Binary kNN without MinHash\n",
"\n",
- "TMAP now uses USearch's native Jaccard distance on bit-packed vectors for binary\n",
- "fingerprint data. This replaces the MinHash+LSH pipeline for dense binary matrices,\n",
- "giving higher recall (98% vs 1%), lower memory (16x), and faster batch queries.\n",
+ "TMAP uses USearch's native Jaccard distance on bit-packed vectors for binary\n",
+ "fingerprint data. This replaces the MinHash+LSH pipeline for dense binary matrices.\n",
+ "On the 64,098 Morgan fingerprints in `examples/cluster_65053.csv`, USearch finds 99.9%\n",
+ "of the true 20 nearest neighbors, where MinHash+LSH finds about 83%, and it needs about\n",
+ "a quarter of the memory. MinHash+LSH is faster to build and to query. The\n",
+ "[USearch guide](../docs/usearch_backend.md) has the full benchmark.\n",
"\n",
"This notebook shows:\n",
"1. How the estimator auto-selects the USearch backend\n",
@@ -24,25 +27,21 @@
"source": [
"## 1. Estimator: Automatic Backend Selection\n",
"\n",
- "Pass a binary matrix to `TMAP(metric='jaccard')` and USearch is used automatically."
+ "Pass a binary matrix to `TMAP(metric='jaccard')` and USearch is used automatically.\n",
+ "The fitted index is available as `model.index_`.\n",
+ "\n",
+ "For binary input USearch always builds an HNSW index, on all CPU cores by default.\n",
+ "The multi-threaded build can return slightly different neighbors from run to run,\n",
+ "which can change the map a little. Pass `reproducible=True` to build the index on one\n",
+ "thread; runs are then identical, and the build is slower."
]
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": null,
"id": "cell-2",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Embedding shape: (5000, 2)\n",
- "Backend: USearch (index_ available: True)\n",
- "LSH forest: False\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"import numpy as np\n",
"from tmap import TMAP\n",
@@ -53,8 +52,13 @@
"\n",
"model = TMAP(metric=\"jaccard\", n_neighbors=20, seed=42).fit(fingerprints)\n",
"print(f\"Embedding shape: {model.embedding_.shape}\")\n",
- "print(f\"Backend: USearch (index_ available: {model._index is not None})\")\n",
- "print(f\"LSH forest: {model._lsh_forest is not None}\")\n"
+ "print(f\"Backend: {type(model.index_).__name__}\")\n",
+ "\n",
+ "# lsh_forest_ raises a RuntimeError when the model has no LSH forest\n",
+ "try:\n",
+ " model.lsh_forest_\n",
+ "except RuntimeError:\n",
+ " print(\"LSH forest: none\")\n"
]
},
{
@@ -62,36 +66,21 @@
"id": "cell-3",
"metadata": {},
"source": [
- "Sets and strings still use MinHash+LSH automatically:"
+ "Sets and strings use MinHash+LSH automatically. The fitted forest is available as\n",
+ "`model.lsh_forest_`:"
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"id": "cell-4",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Backend: LSH (lsh_forest_ available: True)\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_53388/2928182983.py:3: UserWarning: kNN graph is very sparse: 994/1000 neighbor slots are empty (-1). Embedding quality may be poor. Consider increasing kc (currently 50) or n_permutations (currently 128).\n",
- " model_sets = TMAP(metric=\"jaccard\", n_neighbors=5, n_permutations=128, seed=42).fit(sets)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"# Variable-length sets -> MinHash + LSH (automatic)\n",
"sets = [sorted(rng.choice(500, 30, replace=False).tolist()) for _ in range(200)]\n",
"model_sets = TMAP(metric=\"jaccard\", n_neighbors=5, n_permutations=128, seed=42).fit(sets)\n",
- "print(f\"Backend: LSH (lsh_forest_ available: {model_sets._lsh_forest is not None})\")\n"
+ "print(f\"Backend: {type(model_sets.lsh_forest_).__name__}\")\n"
]
},
{
@@ -191,9 +180,13 @@
"metadata": {},
"outputs": [],
"source": [
- "# Save and load\n",
- "idx.save(\"/tmp/fingerprint_index.usearch\")\n",
- "restored = USearchIndex.load(\"/tmp/fingerprint_index.usearch\")\n",
+ "# Save and load (writes three files: the index, .meta and .vectors.npy)\n",
+ "import tempfile\n",
+ "from pathlib import Path\n",
+ "\n",
+ "index_path = Path(tempfile.mkdtemp()) / \"fingerprint_index.usearch\"\n",
+ "idx.save(index_path)\n",
+ "restored = USearchIndex.load(index_path)\n",
"print(f\"Restored: {restored.n_nodes} points, metric={restored.metric}\")\n",
"\n",
"# Restored index supports all operations\n",
@@ -209,7 +202,8 @@
"## 3. Transform and Add Points\n",
"\n",
"The USearch index is stored automatically for binary Jaccard, so `transform()` and\n",
- "`add_points()` work without `store_index=True`."
+ "`add_points()` work without `store_index=True`. See `04_working_with_a_fitted_model.ipynb`\n",
+ "for more on these two methods and on `kneighbors()`."
]
},
{
@@ -248,12 +242,12 @@
"\n",
"| Use case | Tool |\n",
"|---|---|\n",
- "| Build a TMAP from fingerprints | `TMAP(metric='jaccard').fit(X)` — auto-selects USearch |\n",
+ "| Build a TMAP from fingerprints | `TMAP(metric='jaccard').fit(X)` (auto-selects USearch) |\n",
"| Just need kNN, no layout | `USearchIndex().build_from_binary(X)` |\n",
"| Similarity search against a database | `idx.query_batch(queries, k=50)` |\n",
"| Incremental insertion | `idx.add(new_data)` |\n",
- "| Sparse binary data (single-cell) | `TMAP(metric='jaccard').fit(csr_matrix)` — auto-selects LSH |\n",
- "| Variable-length sets/strings | `TMAP(metric='jaccard').fit(list_of_sets)` — auto-selects LSH |"
+ "| Sparse binary data (single-cell) | `TMAP(metric='jaccard').fit(csr_matrix)` (auto-selects LSH) |\n",
+ "| Variable-length index lists or strings | `TMAP(metric='jaccard').fit(list_of_index_lists)` (auto-selects LSH) |"
]
}
],
diff --git a/notebooks/12_legacy_lsh_pipeline.ipynb b/notebooks/12_lower_level_pipeline.ipynb
similarity index 55%
rename from notebooks/12_legacy_lsh_pipeline.ipynb
rename to notebooks/12_lower_level_pipeline.ipynb
index 195ee24..370d086 100644
--- a/notebooks/12_legacy_lsh_pipeline.ipynb
+++ b/notebooks/12_lower_level_pipeline.ipynb
@@ -4,16 +4,16 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Lower-Level API: MinHash + LSHForest + Layout\n",
+ "# Lower-level pipeline\n",
"\n",
- "Use this notebook when you want the original staged TMAP workflow instead of the estimator.\n",
+ "This notebook builds a TMAP one step at a time: SMILES to Morgan fingerprints, fingerprints to MinHash signatures, signatures into an LSHForest, the forest to a kNN graph and an OGDF tree layout, and the layout into an HTML page with `TmapViz`.\n",
"\n",
"This path is useful when you want direct control over:\n",
"\n",
"- MinHash settings\n",
"- LSHForest construction\n",
"- kNN graph inspection\n",
- "- layout from the forest or from a precomputed graph\n",
+ "- layout settings, and layout from the forest or from a precomputed graph\n",
"\n",
"For the shortest workflow, use `TMAP(...).fit(X)` instead.\n"
]
@@ -24,24 +24,16 @@
"source": [
"## 1. Load Molecules And Build Fingerprints\n",
"\n",
- "We use the same molecule dataset as the main chemistry tutorial so the two APIs are easy to compare.\n"
+ "We use the molecules from the main chemistry tutorial (`02_cheminformatics.ipynb`), but the kNN graph is built differently. For a dense 0/1 fingerprint matrix like this one, `TMAP(metric=\"jaccard\").fit(fps)` searches the fingerprints directly with USearch (see `11_usearch_jaccard.ipynb`). The MinHash + LSHForest steps below are what the estimator runs for sets, strings and sparse input. We apply them to fingerprints here so each step is easy to follow.\n",
+ "\n",
+ "`return_valid=True` also returns one flag per SMILES. A SMILES that RDKit cannot read gets no fingerprint, so we drop it from the list to keep the SMILES lined up with the rows of `fps`. We read the first 2,000 rows to keep the notebook fast; remove `nrows` to map the whole file.\n"
]
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- " [Props] 2,000 done, 0 invalid\n",
- "Loaded 2,000 molecules\n",
- "Fingerprint matrix: (2000, 2048)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"import pandas as pd\n",
"\n",
@@ -49,8 +41,12 @@
"\n",
"df = pd.read_csv(\"../examples/cluster_65053.csv\", nrows=2000)\n",
"smiles = df[\"smiles\"].tolist()\n",
+ "\n",
+ "fps, valid = fingerprints_from_smiles(\n",
+ " smiles, fp_type=\"morgan\", radius=2, n_bits=2048, return_valid=True\n",
+ ")\n",
+ "smiles = [smi for smi, ok in zip(smiles, valid) if ok]\n",
"props = molecular_properties(smiles, properties=[\"mw\", \"logp\", \"n_rings\"])\n",
- "fps = fingerprints_from_smiles(smiles, fp_type=\"morgan\", radius=2, n_bits=2048)\n",
"\n",
"print(f\"Loaded {len(smiles):,} molecules\")\n",
"print(f\"Fingerprint matrix: {fps.shape}\")\n"
@@ -78,13 +74,6 @@
"(2000, 128)\n",
"(128,)\n"
]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n"
- ]
}
],
"source": [
@@ -104,29 +93,25 @@
"source": [
"## 3. Build LSHForest\n",
"\n",
- "This is the main lower-level index for the Jaccard workflow.\n"
+ "This is the main lower-level index for the Jaccard workflow. `d` is the number of MinHash permutations and `l` the number of prefix trees; each tree indexes `d // l` of the hash values.\n",
+ "\n",
+ "We use `l=32`, the value the estimator picks for `d=128` (it uses `l = max(8, d // 4)` up to 1M points). The class default is 8, and every extra tree adds index memory and query work.\n",
+ "\n",
+ "`get_knn_graph(k, kc)` returns the `k` nearest neighbors of every point. For each point it collects up to `k * kc` candidates from the trees and keeps the `k` closest by the Jaccard distance estimated from the signatures.\n"
]
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(2000, 20)\n",
- "(2000, 20)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"from tmap import LSHForest\n",
"\n",
- "lsh = LSHForest(d=128, l=64)\n",
+ "lsh = LSHForest(d=128, l=32)\n",
"lsh.batch_add(signatures)\n",
"lsh.index()\n",
+ "print(f\"LSHForest: {lsh.size} signatures in {lsh.l} trees\")\n",
"\n",
"knn = lsh.get_knn_graph(k=20, kc=50)\n",
"print(knn.indices.shape)\n",
@@ -139,33 +124,34 @@
"source": [
"## 4. Compute The Layout Directly From The Forest\n",
"\n",
- "`layout_from_lsh_forest()` is the closest match to the classic TMAP pipeline.\n"
+ "`layout_from_lsh_forest()` is the closest match to the classic TMAP pipeline. It builds the kNN graph with `cfg.k` and `cfg.kc`, computes the minimum spanning tree, and lays the tree out with OGDF. It returns the coordinates `x, y` and the tree edges `s, t`.\n",
+ "\n",
+ "The estimator sets `deterministic` and `seed` on its layout for you. The low-level functions leave them unset, so set them yourself to get the same layout on every run.\n",
+ "\n",
+ "`fme_iterations` sets the number of force-directed iterations, and `sl_extra_scaling_steps` and `sl_scaling_type` control the scaling rounds at each level of the layout. Older TMAP scripts also set `node_size` and `mmm_repeats`. Those two only apply with `cfg.adaptive = False`, which switches to the original single-shot layout. The default adaptive layout sets the node size per level, and `ns_cap` is its main knob for how spread out the map is.\n",
+ "\n",
+ "The estimator also joins a kNN graph that has split into pieces (`connect_components`, see `04_working_with_a_fitted_model.ipynb`). The low-level functions skip that step. If the graph splits, OGDF lays out each piece on its own, and `s, t` has fewer than `len(x) - 1` edges.\n"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "2000 1999\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
- "from tmap.layout import LayoutConfig, layout_from_lsh_forest\n",
+ "from tmap.layout import LayoutConfig, ScalingType, layout_from_lsh_forest\n",
"\n",
"cfg = LayoutConfig()\n",
"cfg.k = 20\n",
"cfg.kc = 50\n",
+ "cfg.fme_iterations = 1000 # default\n",
+ "cfg.sl_extra_scaling_steps = 10 # default 2\n",
+ "cfg.sl_scaling_type = ScalingType.RelativeToDrawing # default\n",
"cfg.deterministic = True\n",
"cfg.seed = 42\n",
"\n",
"x, y, s, t = layout_from_lsh_forest(lsh, cfg)\n",
- "print(len(x), len(s))\n"
+ "print(f\"{len(x)} nodes, {len(s)} tree edges\")\n"
]
},
{
@@ -203,27 +189,19 @@
"source": [
"## 6. Build A Visualization Manually\n",
"\n",
- "Here we create a `TmapViz` object without using the estimator.\n"
+ "Here we create a `TmapViz` object without using the estimator, add the SMILES and three color layouts, and write an HTML file you can open in a browser.\n"
]
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "legacy_lsh_pipeline.html\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"from tmap.visualization import TmapViz\n",
"\n",
"viz = TmapViz()\n",
- "viz.title = \"Legacy LSH Pipeline\"\n",
+ "viz.title = \"Lower-level pipeline\"\n",
"viz.set_points(x, y)\n",
"viz.set_edges(s, t)\n",
"viz.add_smiles(smiles)\n",
@@ -231,7 +209,7 @@
"viz.add_color_layout(\"LogP\", props[\"logp\"].tolist(), color=\"plasma\")\n",
"viz.add_color_layout(\"Ring Count\", props[\"n_rings\"].tolist(), categorical=True, color=\"tab10\")\n",
"\n",
- "path = viz.write_html(\"legacy_lsh_pipeline.html\")\n",
+ "path = viz.write_html(\"lower_level_pipeline.html\")\n",
"print(path)\n"
]
},
@@ -246,6 +224,7 @@
"- you want direct MinHash control\n",
"- you want to inspect the LSH forest or the kNN graph\n",
"- you want to lay out an externally built graph\n",
+ "- you want MinHash + LSHForest neighbors for dense fingerprints, which the estimator sends to USearch\n",
"\n",
"Use the estimator when you just want to pass data and get a map.\n"
]
diff --git a/notebooks/13_local_protein_structures.ipynb b/notebooks/13_local_protein_structures.ipynb
index 2cfb033..4346bd0 100644
--- a/notebooks/13_local_protein_structures.ipynb
+++ b/notebooks/13_local_protein_structures.ipynb
@@ -5,26 +5,28 @@
"id": "90809d15",
"metadata": {},
"source": [
- "# Local protein structures — render any PDB without AlphaFold\n",
+ "# Local protein structures: render your own PDB files\n",
"\n",
"This notebook shows how to add 3D protein structure viewers to a TMAP visualization\n",
- "when **you already have the structures on disk** — no AlphaFold lookup, no UniProt\n",
- "required. Structure data comes from your files or URLs; the browser still loads\n",
- "3Dmol.js from its CDN for the viewer.\n",
+ "when **you already have the structures on disk**. Structure data comes only from\n",
+ "your files or URLs; the browser still loads 3Dmol.js from its CDN for the viewer.\n",
+ "\n",
+ "**Requirements:** `pip install \"tmap2[proteins]\"` (Biopython, used by `read_pdb` and\n",
+ "`sequence_properties`). The first run downloads 10 PDB files from RCSB.\n",
"\n",
"The recommended API is `TmapViz.add_3d_structure_files`: pass local paths,\n",
"then `write_static()` copies the sidecar files into the output bundle.\n",
"\n",
- "Two transports:\n",
+ "Three modes:\n",
"\n",
"| Mode | When to use | What gets stored | Per-point cost in HTML |\n",
"|---|---|---|---|\n",
"| `add_3d_structure_files(paths)` | Local PDB/CIF files, static bundle | Relative URLs + copied sidecars | ~50 bytes per row |\n",
"| `add_3d_structures(urls)` | Already-hosted URLs or hand-managed sidecars | Just the URL/path string | ~50 bytes per row |\n",
- "| `add_3d_structures(texts, source=\"text\")` | Tiny demos where raw PDB text is acceptable | Full PDB/CIF text gzip+base64 in HTML | KB–MB per row |\n",
+ "| `add_3d_structures(texts, source=\"text\")` | Tiny demos where raw PDB text is acceptable | Full PDB/CIF text gzip+base64 in HTML | KB to MB per row |\n",
"\n",
- "The walkthrough builds a realistic project folder, fits a tiny TMAP from\n",
- "sequence-derived features, and renders file-backed plus text-backed modes for comparison.\n"
+ "The walkthrough builds a realistic project folder, projects sequence-derived\n",
+ "features to 2D with PCA, and renders file-backed plus text-backed modes for comparison.\n"
]
},
{
@@ -47,8 +49,8 @@
"```\n",
"\n",
"The PDB files might come from your own AlphaFold runs, downloaded from RCSB,\n",
- "generated by ESMFold, modeled by Rosetta — TMAP doesn't care. Whatever produced\n",
- "`.pdb` is upstream of this visualization.\n",
+ "generated by ESMFold, or modeled by Rosetta. Whatever produced `.pdb` is\n",
+ "upstream of this visualization: the viewer only needs the file.\n",
"\n",
"The cell below builds that exact layout for the notebook: it downloads ~10 small\n",
"proteins from RCSB once (cached on disk) and writes a small `proteins.csv`.\n"
@@ -292,15 +294,14 @@
"id": "4c76a269",
"metadata": {},
"source": [
- "## Build a small TMAP from per-protein features\n",
+ "## Build a small 2D layout from per-protein features\n",
"\n",
"For the demo we derive a tiny feature vector per protein from physicochemical\n",
"properties (no external models needed) and project to 2D with PCA. In a real\n",
"project you'd substitute pre-computed embeddings (ESM, ProtTrans, …) or use\n",
"`TMAP(...).fit_transform` on a larger dataset.\n",
"\n",
- "The point of this notebook is the structure viewer wiring, not the projection,\n",
- "so any 2D layout will do.\n"
+ "This notebook is about the structure viewer wiring, so any 2D layout will do.\n"
]
},
{
@@ -365,12 +366,12 @@
"## Render the visualization in URL mode (sidecar directory)\n",
"\n",
"This is the path you want for thousands of structures. The HTML stores only the\n",
- "relative URL string (`pdbs/1CRN.pdb`) per row; the browser fetches each file\n",
+ "relative URL string (`structures/1CRN.pdb`) per row; the browser fetches each file\n",
"lazily when the user pins that point.\n",
"\n",
- "Note the call to `viz.write_static(out_dir, ...)` — it writes `index.html`\n",
- "plus a few JSON/binary support files into `out_dir`. We then copy our `pdbs/`\n",
- "folder next to it so the relative URLs resolve.\n"
+ "Note the call to `viz.write_static(out_dir, ...)`: it writes `index.html`\n",
+ "plus a few JSON/binary support files into `out_dir`, and copies the PDB files\n",
+ "into `out_dir/structures/` so the relative URLs resolve.\n"
]
},
{
@@ -401,7 +402,7 @@
"OUT_URL.mkdir(exist_ok=True)\n",
"\n",
"viz = TmapViz()\n",
- "viz.title = \"Local proteins — file-backed mode\"\n",
+ "viz.title = \"Local proteins (file-backed mode)\"\n",
"viz.point_size = 18.0\n",
"viz.set_points(xy[:, 0], xy[:, 1])\n",
"viz.add_label(\"PDB ID\", df[\"id\"].tolist())\n",
@@ -426,31 +427,7 @@
"shell.execute_reply": "2026-04-30T16:33:35.974246Z"
}
},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "col_Name.bin (1 KB)\n",
- "col_PDB_ID.bin (1 KB)\n",
- "col_structure.bin (1 KB)\n",
- "coords.bin (1 KB)\n",
- "index.html (597 KB)\n",
- "metadata.json (1 KB)\n",
- "pdbs/\n",
- " 1A3N.pdb (450 KB)\n",
- " 1BNA.pdb (74 KB)\n",
- " 1CRN.pdb (48 KB)\n",
- " 1HHO.pdb (238 KB)\n",
- " 1IGT.pdb (1116 KB)\n",
- " 1MBN.pdb (143 KB)\n",
- " 1UBQ.pdb (76 KB)\n",
- " 2JOF.pdb (648 KB)\n",
- " 4HHB.pdb (462 KB)\n",
- " 6LYZ.pdb (131 KB)\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"# Inspect the output bundle.\n",
"for p in sorted(OUT_URL.rglob(\"*\"))[:30]:\n",
@@ -478,7 +455,7 @@
"because browsers block `file://` `fetch()` calls for security reasons. The\n",
"`http.server` step is one line and only needed for URL mode.\n",
"\n",
- "Pin a point and the card fetches `pdbs/.pdb` and feeds it to 3Dmol.js.\n"
+ "Pin a point and the card fetches `structures/.pdb` and feeds it to 3Dmol.js.\n"
]
},
{
@@ -486,11 +463,11 @@
"id": "f4932a2b",
"metadata": {},
"source": [
- "## Inline mode (self-contained single file)\n",
+ "## Inline mode (single HTML file)\n",
"\n",
"Same data, different transport. The PDB text is gzip+base64-embedded so the\n",
- "single `index.html` is fully portable — you can email it, drop it in a Slack,\n",
- "upload to a static host, no sidecar needed.\n",
+ "single `index.html` is portable: you can email it, drop it in Slack, or\n",
+ "upload it to a static host without any sidecar files.\n",
"\n",
"The trade-off is file size: each PDB shows up in the bundle, even ones the user\n",
"never pins. Practical limit is a few hundred small structures.\n"
@@ -524,7 +501,7 @@
"OUT_TEXT.mkdir(exist_ok=True)\n",
"\n",
"viz_text = TmapViz()\n",
- "viz_text.title = \"Local proteins — text mode\"\n",
+ "viz_text.title = \"Local proteins (text mode)\"\n",
"viz_text.point_size = 18.0\n",
"viz_text.set_points(xy[:, 0], xy[:, 1])\n",
"viz_text.add_label(\"PDB ID\", df[\"id\"].tolist())\n",
@@ -549,8 +526,8 @@
" Relative URLs also need a static file server (`python -m http.server`, S3, GitHub Pages).\n",
"- **Text** only for tiny demos where embedding raw PDB/CIF text is acceptable.\n",
"\n",
- "In both cases the rest of the pipeline — colors, layouts, tooltips, search,\n",
- "filters — works exactly the same; you swap one method call.\n"
+ "In all three cases the rest of the pipeline (colors, layouts, tooltips, search,\n",
+ "filters) works the same; you swap one method call.\n"
]
},
{
@@ -575,8 +552,8 @@
"viz.write_static(\"out/\")\n",
"```\n",
"\n",
- "Whatever you can write to disk as a PDB or mmCIF file, this renders. No\n",
- "AlphaFold required.\n"
+ "Structures from any source work this way, as long as they are saved as PDB or\n",
+ "mmCIF files.\n"
]
}
],
diff --git a/notebooks/14_cazyme_analysis.ipynb b/notebooks/14_cazyme_analysis.ipynb
index 56cb3c3..efcc216 100644
--- a/notebooks/14_cazyme_analysis.ipynb
+++ b/notebooks/14_cazyme_analysis.ipynb
@@ -7,9 +7,12 @@
"source": [
"# CAZyme family GH43 Analysis Workflow\n",
"\n",
- "Analysis of the Glycosly Hydrolase 43 family of CAZymes.\n",
+ "Analysis of the Glycoside Hydrolase 43 family of CAZymes.\n",
"\n",
- "**Requirements:** `pip install tmap2`"
+ "**Requirements:** `pip install \"tmap2[proteins,notebook]\" torch scikit-learn umap-learn`.\n",
+ "The extras install Biopython and jupyter-scatter; SciPy, pandas and matplotlib come with `tmap2`.\n",
+ "Section 7 also runs the `diamond` command-line tool (DIAMOND), which must be on your `PATH`.\n",
+ "To compute the ESMC embeddings yourself you also need the `esm` SDK for ESM C (first released by EvolutionaryScale, now maintained by CZ Biohub at github.com/Biohub/esm) (see Part B)."
]
},
{
@@ -20,7 +23,9 @@
"---\n",
"## Part A: From FASTA to TMAP\n",
"\n",
- "Load GH43 enzymes. Subset from dbCAN's full CAZyme dataset. "
+ "Load GH43 enzymes. Subset from dbCAN's full CAZyme dataset. \n",
+ "\n",
+ "The input files in `./cazyme_data/` (FASTA, embeddings, annotations) are not bundled with the repository."
]
},
{
@@ -54,7 +59,7 @@
"sequences = [str(rec.seq) for rec in records]\n",
"\n",
"print(f\"{len(sequences)} sequences loaded\")\n",
- "print(f\"Length range: {min(len(s) for s in sequences)} -- {max(len(s) for s in sequences)} aa\")\n",
+ "print(f\"Length range: {min(len(s) for s in sequences)} to {max(len(s) for s in sequences)} aa\")\n",
"print(f\"First ID: {ids_fasta[0]}\")\n",
"print(f\"First seq: {sequences[0][:60]}...\")\n"
]
@@ -66,8 +71,9 @@
"source": [
"### 2. Compute sequence properties\n",
"\n",
- "`sequence_properties` computes physicochemical descriptors from amino acid\n",
- "sequences -- using BioPython protparams."
+ "`gh43_sequence_properties` (defined below) computes physicochemical descriptors from amino acid\n",
+ "sequences using Biopython's ProtParam. Its columns differ from `tmap.utils.sequence_properties`:\n",
+ "charge is computed at pH 7.4, and charged residues are split into negative and positive fractions."
]
},
{
@@ -81,7 +87,7 @@
"import pandas as pd\n",
"from Bio.SeqUtils.ProtParam import ProteinAnalysis\n",
"\n",
- "# AT PH 7.4, the following AAs are considered charged:\n",
+ "# At pH 7.4, the following AAs are considered charged:\n",
"STANDARD_AAs = set(\"ACDEFGHIKLMNPQRSTVWY\")\n",
"_HYDROPHOBIC = set(\"AVILMFYW\")\n",
"_POLAR = set(\"NQST\")\n",
@@ -91,11 +97,11 @@
"\n",
"PROP_KEYS = [\n",
" \"length\", \"molecular_weight\", \"isoelectric_point\", \"gravy\",\n",
- " \"charge_at_ph7\", \"aromaticity\", \"aliphatic_index\",\n",
+ " \"charge_at_ph7_4\", \"aromaticity\", \"aliphatic_index\",\n",
" \"frac_neg_charged\", \"frac_pos_charged\", \"frac_hydrophobic\", \"frac_polar\", \"n_cysteines\",\n",
"]\n",
"\n",
- "def sequence_properties(records):\n",
+ "def gh43_sequence_properties(records):\n",
" n_invalid = 0\n",
" rows = []\n",
" for rec in records:\n",
@@ -104,12 +110,12 @@
" if seq and set(seq).issubset(STANDARD_AAs):\n",
" try:\n",
" pa = ProteinAnalysis(seq)\n",
- " aa = pa.get_amino_acids_percent()\n",
+ " aa = {a: p / 100 for a, p in pa.amino_acids_percent.items()} # fractions (0 to 1)\n",
" row[\"length\"] = len(seq)\n",
" row[\"molecular_weight\"] = pa.molecular_weight()\n",
" row[\"isoelectric_point\"] = pa.isoelectric_point()\n",
" row[\"gravy\"] = pa.gravy()\n",
- " row[\"charge_at_ph7\"] = pa.charge_at_pH(7.4)\n",
+ " row[\"charge_at_ph7_4\"] = pa.charge_at_pH(7.4)\n",
" row[\"aromaticity\"] = pa.aromaticity()\n",
" row[\"aliphatic_index\"] = (\n",
" aa.get(\"A\", 0) + 2.9 * aa.get(\"V\", 0) +\n",
@@ -125,10 +131,10 @@
" else:\n",
" n_invalid += 1\n",
" rows.append(row)\n",
- " print(f\"sequence_properties: {n_invalid}/{len(records)} sequences invalid (non-standard AAs or empty)\")\n",
+ " print(f\"gh43_sequence_properties: {n_invalid}/{len(records)} sequences invalid (non-standard AAs or empty)\")\n",
" return pd.DataFrame(rows)\n",
"\n",
- "props_df = sequence_properties(records)\n",
+ "props_df = gh43_sequence_properties(records)\n",
"\n",
"for col in PROP_KEYS:\n",
" values = props_df[col]\n",
@@ -148,10 +154,7 @@
"1. **Embeddings** ESMC mean-pooled embeddings (.pt torch files)\n",
"2. **Annotation file** Custom cazyme annotation file as UniProt's auto-generated annotations are not accurate.\n",
"\n",
- "ESM-c embeddings can be generated with:\n",
- "- `esm` Python package (Meta)\n",
- "- ESM Metagenomic Atlas API\n",
- "- Local inference with `fair-esm`"
+ "ESMC embeddings can be generated with the `esm` Python SDK for ESM C, first released by EvolutionaryScale and now maintained by CZ Biohub (github.com/Biohub/esm)."
]
},
{
@@ -162,7 +165,7 @@
"### 3. Load embeddings\n",
"\n",
"This assumes pre-computed embeddings saved as .pt torch files.\n",
- "The paths `./cazyme_data/GH43_esmc_300m.pt\"` and `.cazyme_data/merged_cazyme_annotations.tsv` are dataset-specific --\n",
+ "The paths `./cazyme_data/GH43_esmc_300m.pt` and `./cazyme_data/merged_cazyme_annotations.tsv` are dataset-specific;\n",
"replace them with your own."
]
},
@@ -231,8 +234,8 @@
"source": [
"### 4. Fit TMAP on embeddings\n",
"\n",
- "Euclidean/Cosine are the recommended metrics for ESM-c embeddings.\n",
- "USearch handles the dense nearest-neighbor search automatically. This is the longest step so we save the file as a .pkl to prevent re-running."
+ "Euclidean/Cosine are the recommended metrics for ESMC embeddings.\n",
+ "USearch handles the dense nearest-neighbor search automatically. This is the longest step, so we save the fitted model with `model.save()` to prevent re-running (reload it with `TMAP.load(\"tmap.pkl\")`)."
]
},
{
@@ -243,13 +246,11 @@
"outputs": [],
"source": [
"from tmap import TMAP\n",
- "import pickle\n",
"\n",
"model = TMAP(metric=\"cosine\", n_neighbors=100, seed=42).fit(embeddings)\n",
"print(f\"Embedding: {model.embedding_.shape}\")\n",
"print(f\"Tree edges: {model.tree_.edges.shape[0]}\")\n",
- "with open(\"tmap.pkl\", \"wb\") as f:\n",
- " pickle.dump(model, f)"
+ "model.save(\"tmap.pkl\") # reload later with TMAP.load(\"tmap.pkl\")"
]
},
{
@@ -257,10 +258,11 @@
"id": "viz-emb-header",
"metadata": {},
"source": [
- "### 5. Visualize with `add_metadata`\n",
+ "### 5. Visualize the metadata\n",
"\n",
- "Now we combine everything into a single visualization. `add_metadata`\n",
- "auto-detects continuous vs categorical."
+ "Now we combine everything into a single visualization. The loop below adds the columns in\n",
+ "`LABEL_COLS` as tooltip labels (`add_label`), the other numeric columns as continuous color\n",
+ "layers, and the remaining columns as categorical color layers (`add_color_layout(..., categorical=True)`)."
]
},
{
@@ -271,7 +273,7 @@
"outputs": [],
"source": [
"viz = model.to_tmapviz()\n",
- "viz.title = \"CAZyme Embedding Space — ESMC-300M\"\n",
+ "viz.title = \"CAZyme Embedding Space (ESMC-300M)\"\n",
"\n",
"LABEL_COLS = {\"organism\", \"cazy_family_base\", \"id\", \"taxid\",\n",
" \"char_protein_name\", \"char_uniprot\", \"char_pdb\", \"raw_annotation\", \"ec_numbers\"}\n",
@@ -323,8 +325,8 @@
"id": "4fa6d6d0",
"metadata": {},
"source": [
- "### 6. Distance correlations Cosine-TMAP hops\n",
- "We pick a sequence and calculate all the raw cosine distances to it. Next we calculate all the tmap 'hops' between the sequence and all the other sequences and plot a correlation between the two."
+ "### 6. Distance correlations Cosine-TMAP tree distance\n",
+ "We pick a sequence and calculate all the raw cosine distances to it. Next we calculate the TMAP tree distance (the sum of edge weights along the tree path) between the sequence and all the other sequences and plot a correlation between the two."
]
},
{
@@ -346,7 +348,7 @@
"# TMAP distances from query to all sequences\n",
"tmap_dists = model.distances_from(QUERY_IDX)\n",
"\n",
- "# Cosine distances — normalise first so dot product == cosine similarity\n",
+ "# Cosine distances: normalise first so dot product == cosine similarity\n",
"norms = np.linalg.norm(embeddings, axis=1, keepdims=True)\n",
"embeddings_normed = embeddings / norms\n",
"query_normed = embeddings_normed[QUERY_IDX:QUERY_IDX+1]\n",
@@ -383,7 +385,7 @@
"metadata": {},
"source": [
"#### 7. Blastp-TMAP correlations\n",
- "Next we plot the Diamond blastp sequence similarity vs the tmap hops."
+ "Next we plot the Diamond blastp sequence similarity vs the TMAP tree distance."
]
},
{
@@ -433,7 +435,7 @@
" names=[\"qseqid\", \"sseqid\", \"bitscore\", \"evalue\", \"pident\"])\n",
"print(f\"Diamond hits: {len(blast_df):,} / {len(ids):,} sequences\")\n",
"\n",
- "# Similarity: pident as fraction (0–1); NaN for no-hit\n",
+ "# Similarity: pident as fraction (0 to 1); NaN for no-hit\n",
"id_to_pident = dict(zip(blast_df[\"sseqid\"], blast_df[\"pident\"]))\n",
"blast_sim = np.array([id_to_pident.get(sid, np.nan) for sid in ids]) / 100.0\n",
"\n",
@@ -520,8 +522,8 @@
" color_map = color_map or \"tab20\"\n",
" figsize = (9, 9)\n",
" else:\n",
- " # continuous plots get a colorbar, which narrows the axes box and —\n",
- " # combined with set_aspect(\"equal\", adjustable=\"datalim\") — makes the\n",
+ " # continuous plots get a colorbar, which narrows the axes box and\n",
+ " # (combined with set_aspect(\"equal\", adjustable=\"datalim\")) makes the\n",
" # data limits expand vertically to compensate. Extra width keeps the\n",
" # box proportions (and the visible data range) the same as categorical.\n",
" figsize = (10, 8)\n",
@@ -544,14 +546,14 @@
" return ax\n",
"\n",
"\n",
- "# categorical — grouped into top 19 + \"Other\", tab20 colors, NaNs skipped\n",
+ "# categorical: grouped into top 19 + \"Other\", tab20 colors, NaNs skipped\n",
"plot_static_grouped(model, meta[\"cazy_family\"],\n",
" savepath=\"tmap_cazy_family_grouped.png\")\n",
"\n",
"plot_static_grouped(model, meta[\"domain\"], color_map=\"tab10\",\n",
" savepath=\"tmap_domain_grouped.png\")\n",
"\n",
- "# continuous — passes straight through to plot_static's own colorbar path\n",
+ "# continuous: passes straight through to plot_static's own colorbar path\n",
"plot_static_grouped(model, meta[\"diamond_pident_from_query\"],\n",
" savepath=\"diamond_pident_from_query.png\")\n",
"\n",
@@ -567,7 +569,7 @@
"metadata": {},
"source": [
"---\n",
- "## Classical Methods\n",
+ "## Part D: Classical Methods\n",
"\n",
"PCA, UMAP, and t-SNE applied to ESMC-300M embeddings, colored by taxonomic domain.\n",
"t-SNE uses 50 PCA components as input to keep runtime manageable."
@@ -578,7 +580,7 @@
"id": "8c0e6916",
"metadata": {},
"source": [
- "#### C.1 PCA"
+ "#### D.1 PCA"
]
},
{
@@ -592,10 +594,10 @@
"import matplotlib.pyplot as plt\n",
"from sklearn.decomposition import PCA\n",
"\n",
- "# Verify alignment — meta must have exactly one row per embedding\n",
+ "# Verify alignment: meta must have exactly one row per embedding\n",
"assert len(meta) == len(embeddings), (\n",
" f\"meta ({len(meta)} rows) != embeddings ({len(embeddings)} rows); \"\n",
- " \"a merge created duplicate rows — deduplicate meta.drop_duplicates('id') first\"\n",
+ " \"a merge created duplicate rows; deduplicate meta.drop_duplicates('id') first\"\n",
")\n",
"\n",
"GREY_LABELS = {\"nan\", \"NaN\", \"Unknown\"}\n",
@@ -638,7 +640,7 @@
" ax.scatter(X_pca2[mask, 0], X_pca2[mask, 1],\n",
" c=[domain_color_map[d]], s=2, alpha=0.4 if d in GREY_LABELS else 0.6,\n",
" label=f\"{d} ({mask.sum()})\", rasterized=True)\n",
- "ax.set_title(\"PCA — colored by domain\")\n",
+ "ax.set_title(\"PCA, colored by domain\")\n",
"ax.set_xlabel(f\"PC1 ({pca2.explained_variance_ratio_[0]:.1%})\")\n",
"ax.set_ylabel(f\"PC2 ({pca2.explained_variance_ratio_[1]:.1%})\")\n",
"ax.legend(markerscale=5, framealpha=0.8, fontsize=9)\n",
@@ -651,7 +653,7 @@
"id": "427d2e8f",
"metadata": {},
"source": [
- "#### C.2 UMAP"
+ "#### D.2 UMAP"
]
},
{
@@ -672,7 +674,7 @@
" ax.scatter(X_umap[mask, 0], X_umap[mask, 1],\n",
" c=[domain_color_map[d]], s=2, alpha=0.4 if d in GREY_LABELS else 0.6,\n",
" label=f\"{d} ({mask.sum()})\", rasterized=True)\n",
- "ax.set_title(\"UMAP — colored by domain\")\n",
+ "ax.set_title(\"UMAP, colored by domain\")\n",
"ax.set_xlabel(\"UMAP 1\")\n",
"ax.set_ylabel(\"UMAP 2\")\n",
"ax.legend(markerscale=5, framealpha=0.8, fontsize=9)\n",
@@ -685,7 +687,7 @@
"id": "1aad8768",
"metadata": {},
"source": [
- "#### C.3 tSNE"
+ "#### D.3 t-SNE"
]
},
{
@@ -706,7 +708,7 @@
" ax.scatter(X_tsne[mask, 0], X_tsne[mask, 1],\n",
" c=[domain_color_map[d]], s=2, alpha=0.4 if d in GREY_LABELS else 0.6,\n",
" label=f\"{d} ({mask.sum()})\", rasterized=True)\n",
- "ax.set_title(\"t-SNE — colored by domain\")\n",
+ "ax.set_title(\"t-SNE, colored by domain\")\n",
"ax.set_xlabel(\"t-SNE 1\")\n",
"ax.set_ylabel(\"t-SNE 2\")\n",
"ax.legend(markerscale=5, framealpha=0.8, fontsize=9)\n",