diff --git a/README.md b/README.md index c8a9a6d..5a07a05 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,35 @@ df = load_meds_events("~/.cache/synthlab/meds/synthea_100") Install the optional extra: `pip install synthlab[meds]`. +### Olink NPX simulator (NEW) + +Simulate case/control Olink proteomics data with LOD-driven missingness +and configurable group effects — the first greenfield open-source +simulator targeted at Olink's NPX / PEA readout (existing tools like +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +target LC-MS/MS, and [OlinkAnalyze](https://github.com/Olink-Proteomics/OlinkRPackage) +ships demo data but no simulator). Priors reflect UKB-PPP +([Sun et al. 2023](https://www.nature.com/articles/s41586-023-06592-6)) +and OlinkAnalyze `npx_data1` / `npx_data2` baseline distributions: + +```python +from synthlab import OlinkSimConfig, default_explore_3072_panel, simulate_olink_npx + +cfg = OlinkSimConfig( + n_samples=500, + panel=default_explore_3072_panel(), + group_effects={"CRP": {"case": 1.8}, "IL6": {"case": 1.2}}, + group_assignments=["case"] * 250 + ["control"] * 250, + seed=42, +) +df = simulate_olink_npx(cfg) +``` + +See [`synthlab/olink.py`](synthlab/olink.py) for the full API +(`OlinkPanelConfig`, `OlinkSimConfig`, `simulate_olink_npx`, +`default_explore_3072_panel`, `write_olink_parquet`, +`load_olink_parquet`). + ## Installation ```bash diff --git a/notebooks/README.md b/notebooks/README.md new file mode 100644 index 0000000..15296a6 --- /dev/null +++ b/notebooks/README.md @@ -0,0 +1,41 @@ +# SynthLab notebooks + +Demos and walkthroughs for the [SynthLab](https://github.com/bschilder/synthlab) +synthetic-healthcare-data toolkit. + +## Index + +| Notebook | Module | Description | +| -------- | ------ | ----------- | +| [`olink_demo.ipynb`](olink_demo.ipynb) | [`synthlab.olink`](../synthlab/olink.py) | Olink NPX proteomics simulator — generate, analyse, visualise case vs control with LOD missingness + plate batch effects. | +| [`Synthea.ipynb`](Synthea.ipynb) | [`synthlab.synthea`](../synthlab/synthea.py) | Run Synthea and convert CSV to OMOP. | +| [`Coherent_MultimodalDataset.ipynb`](Coherent_MultimodalDataset.ipynb) | [`synthlab.coherent`](../synthlab/coherent.py) | Load and explore the Synthea Coherent multimodal dataset. | +| [`Generate_MultimodalDataset.ipynb`](Generate_MultimodalDataset.ipynb) | [`synthlab.coherent`](../synthlab/coherent.py) | Generate multimodal synthetic cohorts. | +| [`MedGemma_SOAP_Notes.ipynb`](MedGemma_SOAP_Notes.ipynb) | [`synthlab.soap`](../synthlab/soap.py) | MedGemma-based SOAP note generation with causal graph analysis. | +| [`SNOMED_Entity_Linking.ipynb`](SNOMED_Entity_Linking.ipynb) | [`synthlab.snomed`](../synthlab/snomed.py) | SNOMED entity linking with SapBERT and FAISS. | +| [`UKBiobank_Synthetic.ipynb`](UKBiobank_Synthetic.ipynb) | [`synthlab.download_ukbiobank_synthetic`](../synthlab/download_ukbiobank_synthetic.py) | Download and explore the UK Biobank Synthetic Dataset. | + +## Running the Olink demo + +The Olink NPX demo notebook needs the `viz` optional dependency group +(`matplotlib`, `seaborn`, `scikit-learn`, `umap-learn`). Install alongside the +core SynthLab package: + +```bash +pip install 'synthlab[viz]' +``` + +Then open [`olink_demo.ipynb`](olink_demo.ipynb) in Jupyter — it runs +end-to-end in under a minute on CPU with no external data dependencies. + +## Reproducing `olink_demo.ipynb` + +The notebook is assembled from +[`_build_olink_demo.py`](_build_olink_demo.py) so the cell layout stays +reviewable under version control. After editing the builder: + +```bash +python notebooks/_build_olink_demo.py # rebuild cells +jupyter nbconvert --to notebook --execute --inplace \\ + notebooks/olink_demo.ipynb # embed outputs +``` diff --git a/notebooks/_build_olink_demo.py b/notebooks/_build_olink_demo.py new file mode 100644 index 0000000..3c9f50d --- /dev/null +++ b/notebooks/_build_olink_demo.py @@ -0,0 +1,498 @@ +"""Build notebooks/olink_demo.ipynb as a hand-authored nbformat notebook. + +Run once with the SynthLab source on ``PYTHONPATH``. Emits a fresh +``.ipynb`` next to this script; outputs are embedded in-place by a +follow-up ``jupyter nbconvert --execute`` step from the shell. +""" + +from __future__ import annotations + +from pathlib import Path + +import nbformat as nbf + + +def _md(src: str) -> nbf.NotebookNode: + """Wrap ``src`` in a markdown cell.""" + return nbf.v4.new_markdown_cell(src.strip("\n")) + + +def _code(src: str) -> nbf.NotebookNode: + """Wrap ``src`` in a code cell.""" + return nbf.v4.new_code_cell(src.strip("\n")) + + +def build() -> nbf.NotebookNode: + """Assemble and return the Olink demo notebook.""" + cells: list[nbf.NotebookNode] = [] + + # === Section 1 — Title + motivation ================================== + cells.append(_md(""" +# Olink NPX simulator — end-to-end demo + +This notebook walks through [`synthlab.olink.simulate_olink_npx`](../synthlab/olink.py) +— a minimal, dependency-light simulator for [Olink](https://olink.com)-style NPX +(Normalized Protein eXpression) proteomics data. As of 2026-04 there is no +widely-used open-source Olink simulator; the closest analogues are +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +(LC-MS/MS, not NPX) and the [OlinkAnalyze R +package](https://github.com/Olink-Proteomics/OlinkRPackage), which ships demo +tables but no generative simulator. + +The model implemented in [`synthlab/olink.py`](../synthlab/olink.py) is deliberately +minimal and covers the three features needed to exercise downstream ML / +biomarker-discovery pipelines: + +- Per-protein NPX ~ N(mean, sd) draws with user-configurable **group-mean + shifts** (the "biomarker" signal). +- **Limit-of-detection (LOD)** driven missingness: 80% of sub-LOD values are + dropped (MNAR), 20% are retained and can be flagged with `qc_warning`. +- **Per-plate batch effects** — 96 samples / plate, plate intercepts drawn + from N(0, `plate_effect_sd`^2). + +Deferred to follow-up PRs: full MAR missingness, multi-factor batch effects, +panel-version LOD bridging, and a realistic PEA dilution noise model. See +[PR #2](https://github.com/bschilder/synthlab/pull/2) for the roadmap. + +**Install extras for this notebook** (`matplotlib`, `seaborn`, `scikit-learn`, +`umap-learn`): + +```bash +pip install synthlab[viz] +``` +""")) + + # === Section 2 — Minimal generate + peek ============================= + cells.append(_md(""" +## 2. Minimal generate + peek + +Draw 500 samples split 250/250 case/control, with three manually-injected +biomarkers (CRP, IL6, TNF). We use the built-in 50-protein +[`default_explore_3072_panel`](../synthlab/olink.py) — a UKB-PPP-informed subset +of the Olink Explore 3072 panel. +""")) + + cells.append(_code(""" +# NOTE: only the `viz` extra is required in addition to core deps. +import warnings + +import matplotlib.pyplot as plt +import numpy as np +import polars as pl +import seaborn as sns + +warnings.filterwarnings("ignore", category=UserWarning) +warnings.filterwarnings("ignore", category=FutureWarning) + +sns.set_theme(style="whitegrid", palette="colorblind") +plt.rcParams["figure.dpi"] = 100 +plt.rcParams["savefig.dpi"] = 100 + +RNG_SEED = 42 +""")) + + cells.append(_code(""" +from synthlab import ( + OlinkSimConfig, + default_explore_3072_panel, + simulate_olink_npx, +) + +panel = default_explore_3072_panel() +cfg = OlinkSimConfig( + n_samples=500, + panel=panel, + group_effects={ + "CRP": {"case": 1.8}, + "IL6": {"case": 1.2}, + "TNF": {"case": 0.9}, + }, + group_assignments=["case"] * 250 + ["control"] * 250, + seed=RNG_SEED, +) +df = simulate_olink_npx(cfg) +df.head(10) +""")) + + cells.append(_code(""" +df.describe() +""")) + + cells.append(_code(""" +# Frame schema + size + row-count + missingness summary. +n_samples = 500 +n_proteins = len(panel.proteins) +n_expected = n_samples * n_proteins +n_observed = df.height +drop_rate = 1.0 - n_observed / n_expected + +print(f"schema : {dict(df.schema)}") +print(f"rows : {n_observed:,} / {n_expected:,} possible") +print(f"overall drop rate : {drop_rate:.2%}") +print(f"unique samples : {df['sample_id'].n_unique()}") +print(f"unique proteins : {df['protein_id'].n_unique()}") +print(f"unique plates : {df['plate_id'].n_unique()}") +print(f"qc_warning rate : {df['qc_warning'].mean():.2%}") +""")) + + # === Section 3 — Per-protein NPX distributions ======================= + cells.append(_md(""" +## 3. Per-protein NPX distributions + +A 4x4 grid of NPX histograms for a representative slice of the panel. Case +(orange) vs control (blue) KDEs are overlaid; the red dashed line marks each +protein's LOD. Proteins with a non-zero `group_effects` entry are annotated +with their injected mean shift. +""")) + + cells.append(_code(""" +# Focus on a mix of injected biomarkers (first 3) plus 13 unrelated proteins. +display_proteins = ["CRP", "IL6", "TNF"] + [ + p for p in panel.proteins if p not in {"CRP", "IL6", "TNF"} +][:13] +group_shifts = {"CRP": 1.8, "IL6": 1.2, "TNF": 0.9} + +fig, axes = plt.subplots(4, 4, figsize=(14, 12), sharex=False, sharey=False) +fig.suptitle( + "Per-protein NPX distributions (case vs control)", + fontsize=15, + fontweight="bold", +) + +palette = sns.color_palette("colorblind", 2) +for ax, prot in zip(axes.flat, display_proteins): + sub = df.filter(pl.col("protein_id") == prot) + for (grp, color) in zip(["control", "case"], palette): + vals = sub.filter(pl.col("group") == grp)["npx"].to_numpy() + if vals.size == 0: + continue + ax.hist(vals, bins=25, alpha=0.45, color=color, label=grp) + sns.kdeplot(vals, ax=ax, color=color, linewidth=1.5) + ax.axvline(panel.lod[prot], color="crimson", linestyle="--", linewidth=1.2, + label="LOD") + shift = group_shifts.get(prot) + title = f"{prot}" if shift is None else f"{prot} (case +{shift})" + ax.set_title(title, fontsize=10) + ax.set_xlabel("NPX") + ax.set_ylabel("count") +axes.flat[0].legend(loc="upper left", fontsize=8) +fig.tight_layout(rect=[0, 0, 1, 0.97]) +plt.show() +""")) + + # === Section 4 — LOD missingness ===================================== + cells.append(_md(""" +## 4. LOD-driven missingness + +The `mnar_lod` missingness model in +[`simulate_olink_npx`](../synthlab/olink.py) drops 80% of sub-LOD values and +retains the remaining 20% (which downstream pipelines would flag with +`qc_warning`). On top of LOD dropout, a small MCAR pass removes +`missing_rate` (default 5%) of the survivors. + +**Left:** per-protein mean NPX vs LOD, coloured by observed drop rate. The +closer a protein's mean is to its LOD, the larger its drop rate. +**Right:** top-20 most-dropped proteins, with rate bars. +""")) + + cells.append(_code(""" +per_protein = ( + df.group_by("protein_id") + .agg(observed_mean=pl.col("npx").mean(), + n_observed=pl.col("npx").len()) + .with_columns( + drop_rate=1.0 - pl.col("n_observed") / n_samples, + lod=pl.col("protein_id").map_elements( + lambda p: panel.lod[p], return_dtype=pl.Float64), + prior_mean=pl.col("protein_id").map_elements( + lambda p: panel.mean[p], return_dtype=pl.Float64), + ) + .sort("drop_rate", descending=True) +) +per_protein.head(5) +""")) + + cells.append(_code(""" +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) + +# --- (a) observed mean vs LOD, coloured by drop rate ------------------------ +pp = per_protein.to_pandas() +sc = ax1.scatter( + pp["lod"], pp["observed_mean"], + c=pp["drop_rate"], cmap="viridis", s=70, edgecolor="k", + linewidth=0.4, +) +lo = min(pp["lod"].min(), pp["observed_mean"].min()) - 0.2 +hi = max(pp["lod"].max(), pp["observed_mean"].max()) + 0.2 +ax1.plot([lo, hi], [lo, hi], "k--", linewidth=1, alpha=0.5, label="y = x") +cbar = plt.colorbar(sc, ax=ax1) +cbar.set_label("drop rate", rotation=270, labelpad=14) +ax1.set_xlabel("per-protein LOD") +ax1.set_ylabel("observed mean NPX") +ax1.set_title("(a) per-protein mean vs LOD") +ax1.legend(loc="lower right") + +# --- (b) top-20 most-dropped proteins --------------------------------------- +top20 = per_protein.head(20).to_pandas() +ax2.barh(top20["protein_id"][::-1], top20["drop_rate"][::-1], + color=sns.color_palette("colorblind")[2]) +ax2.set_xlabel("drop rate") +ax2.set_title("(b) top-20 most-dropped proteins") +ax2.set_xlim(0, max(top20["drop_rate"].max() * 1.1, 0.05)) + +fig.tight_layout() +plt.show() +""")) + + # === Section 5 — Plate batch effects ================================= + cells.append(_md(""" +## 5. Plate batch effects + +With 500 samples at 96 per plate we get 6 plates; each plate gets an +intercept drawn from N(0, `plate_effect_sd`^2). The violin plot shows that +CRP still separates case vs control *within* each plate, despite the +plate-level offset. +""")) + + cells.append(_code(""" +subset = ( + df.filter(pl.col("protein_id").is_in(["CRP", "IL6", "TNF"])) + .to_pandas() +) + +fig, axes = plt.subplots(1, 3, figsize=(15, 5.5), sharey=True) +for ax, prot in zip(axes, ["CRP", "IL6", "TNF"]): + sub = subset[subset["protein_id"] == prot] + sns.violinplot( + data=sub, x="plate_id", y="npx", hue="group", + split=True, inner="quartile", ax=ax, palette="colorblind", + density_norm="width", + ) + ax.set_title(f"{prot}: per-plate NPX (case vs control)") + ax.set_xlabel("plate") + ax.set_ylabel("NPX") + ax.tick_params(axis="x", rotation=30) + +fig.tight_layout() +plt.show() +""")) + + # === Section 6 — PCA + UMAP sample-level ============================= + cells.append(_md(""" +## 6. Sample-level dimensionality reduction (PCA + UMAP) + +Pivot long -> wide (`sample` x `protein`), impute missing NPX with the +per-protein median (the standard Olink convention), then run PCA and UMAP. +Cases are expected to separate along the three injected-biomarker axes. +""")) + + cells.append(_code(""" +wide = ( + df.pivot(values="npx", index="sample_id", on="protein_id", + aggregate_function="first") + .sort("sample_id") +) +# Per-protein median imputation. +imputed = wide.with_columns([ + pl.col(col).fill_null(pl.col(col).median()) + for col in wide.columns if col != "sample_id" +]) +# Sample-level group labels. +sample_groups = ( + df.group_by("sample_id").agg(group=pl.col("group").first()) + .sort("sample_id") +) +X = imputed.drop("sample_id").to_numpy() +y = sample_groups["group"].to_numpy() +print(f"sample x protein matrix: {X.shape}") +print(f"label counts : case={int((y == 'case').sum())}, " + f"control={int((y == 'control').sum())}") +""")) + + cells.append(_code(""" +from sklearn.decomposition import PCA +from sklearn.preprocessing import StandardScaler +import umap + +Xz = StandardScaler().fit_transform(X) +pca = PCA(n_components=2, random_state=RNG_SEED) +pcs = pca.fit_transform(Xz) +umap_model = umap.UMAP(n_components=2, random_state=RNG_SEED, n_neighbors=15, + min_dist=0.1) +emb = umap_model.fit_transform(Xz) + +fig, (axL, axR) = plt.subplots(1, 2, figsize=(14, 6)) +palette = dict(zip(["control", "case"], sns.color_palette("colorblind", 2))) +for grp, color in palette.items(): + mask = y == grp + axL.scatter(pcs[mask, 0], pcs[mask, 1], c=[color], label=grp, alpha=0.75, + edgecolor="k", linewidth=0.3, s=35) + axR.scatter(emb[mask, 0], emb[mask, 1], c=[color], label=grp, alpha=0.75, + edgecolor="k", linewidth=0.3, s=35) +axL.set_xlabel(f"PC1 ({pca.explained_variance_ratio_[0]:.1%} var)") +axL.set_ylabel(f"PC2 ({pca.explained_variance_ratio_[1]:.1%} var)") +axL.set_title("PCA of sample x protein matrix") +axL.legend(title="group") +axR.set_xlabel("UMAP 1") +axR.set_ylabel("UMAP 2") +axR.set_title("UMAP of sample x protein matrix") +axR.legend(title="group") +fig.tight_layout() +plt.show() +""")) + + # === Section 7 — Correlation heatmap ================================= + cells.append(_md(""" +## 7. Protein-protein correlation + +Pairwise Pearson correlations for the 25 most-expressed proteins, ordered by +hierarchical clustering. Injected biomarkers (CRP, IL6, TNF) are expected to +cluster together because every case sample shifts all three simultaneously. +""")) + + cells.append(_code(""" +means = ( + df.group_by("protein_id").agg(mean_npx=pl.col("npx").mean()) + .sort("mean_npx", descending=True).head(25)["protein_id"].to_list() +) +wide_top = imputed.select(["sample_id", *means]).drop("sample_id").to_numpy() +corr = np.corrcoef(wide_top.T) + +g = sns.clustermap( + corr, cmap="vlag", center=0, xticklabels=means, yticklabels=means, + figsize=(12, 11), linewidths=0.1, cbar_kws={"label": "Pearson r"}, +) +g.fig.suptitle("Protein-protein NPX correlation (top 25 by mean)", + fontsize=14, y=1.02) +plt.show() +""")) + + # === Section 8 — Volcano ============================================= + cells.append(_md(""" +## 8. Case vs control differential expression + +Per-protein Welch t-test of case vs control NPX. The volcano plot shows the +mean NPX delta on the x axis and `-log10(p)` on the y axis. The three +manually-injected biomarkers (CRP, IL6, TNF) should sit in the upper-right +corner (positive delta, small p). +""")) + + cells.append(_code(""" +from scipy import stats as sstats + +records = [] +for prot in panel.proteins: + sub = df.filter(pl.col("protein_id") == prot) + case_vals = sub.filter(pl.col("group") == "case")["npx"].to_numpy() + ctrl_vals = sub.filter(pl.col("group") == "control")["npx"].to_numpy() + if case_vals.size < 3 or ctrl_vals.size < 3: + continue + delta = float(case_vals.mean() - ctrl_vals.mean()) + t, p = sstats.ttest_ind(case_vals, ctrl_vals, equal_var=False) + records.append({"protein": prot, "delta": delta, + "neg_log10_p": -np.log10(max(float(p), 1e-300))}) +volc = pl.DataFrame(records).sort("neg_log10_p", descending=True) +volc.head(10) +""")) + + cells.append(_code(""" +fig, ax = plt.subplots(figsize=(10, 7)) +vp = volc.to_pandas() +injected = {"CRP", "IL6", "TNF"} +is_inj = vp["protein"].isin(injected) + +ax.scatter(vp.loc[~is_inj, "delta"], vp.loc[~is_inj, "neg_log10_p"], + color="grey", alpha=0.6, s=40, edgecolor="k", linewidth=0.3, + label="other") +ax.scatter(vp.loc[is_inj, "delta"], vp.loc[is_inj, "neg_log10_p"], + color="crimson", s=110, edgecolor="k", linewidth=0.6, + label="injected biomarker") +for _, row in vp[is_inj].iterrows(): + ax.annotate(row["protein"], (row["delta"], row["neg_log10_p"]), + xytext=(7, 4), textcoords="offset points", fontsize=11, + fontweight="bold") +ax.axhline(-np.log10(0.05), color="steelblue", linestyle="--", linewidth=1, + label="p = 0.05") +ax.axvline(0, color="black", linewidth=0.5) +ax.set_xlabel("NPX delta (case − control)") +ax.set_ylabel("-log10(Welch t-test p)") +ax.set_title("Volcano plot — case vs control differential NPX") +ax.legend() +fig.tight_layout() +plt.show() +""")) + + # === Section 9 — Parquet round-trip ================================= + cells.append(_md(""" +## 9. Parquet round-trip + +[`write_olink_parquet`](../synthlab/olink.py) and +[`load_olink_parquet`](../synthlab/olink.py) are the canonical on-disk +serialisation entrypoints — snappy-compressed, schema-validated. +""")) + + cells.append(_code(""" +import pathlib +import tempfile + +from synthlab import load_olink_parquet, write_olink_parquet + +tmp = pathlib.Path(tempfile.mkdtemp()) / "olink_demo.parquet" +write_olink_parquet(df, tmp) +round_trip = load_olink_parquet(tmp) +assert df.equals(round_trip), "round-trip mismatch" +print(f"wrote {tmp}") +print(f"size : {tmp.stat().st_size // 1024} KB") +print(f"rows : {round_trip.height:,}") +""")) + + # === Section 10 — Where to next ====================================== + cells.append(_md(""" +## 10. Where to next + +The simulator is deliberately minimal — the scope of this PR (see [PR +#2](https://github.com/bschilder/synthlab/pull/2)) is "smallest viable NPX +simulator with LOD + plates + group effects". Follow-up work: + +- **Full MAR missingness**: model missingness as a function of sample-level + covariates (age, QC batch) rather than aliasing to MCAR. +- **Multi-factor batch effects**: plate x run x operator, with per-factor + variance components. +- **Panel-version LOD bridging**: Olink Explore HT vs Explore 3072 have + different LOD distributions; a bridging mode should allow cross-panel + simulation. +- **PEA dilution / matrix effects**: the real [PEA + assay](https://olink.com/technology/proximity-extension-assay) has a + noise model that scales with dilution; currently we use a flat per-protein + sigma. + +Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2); +please open issues for missing features. +""")) + + nb = nbf.v4.new_notebook() + nb["cells"] = cells + nb["metadata"] = { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3", + }, + "language_info": { + "name": "python", + "pygments_lexer": "ipython3", + }, + } + return nb + + +def main() -> None: + """Entry-point — build and write the notebook.""" + nb = build() + out = Path(__file__).resolve().parent / "olink_demo.ipynb" + nbf.write(nb, out) + print(f"wrote {out} ({len(nb['cells'])} cells)") + + +if __name__ == "__main__": + main() diff --git a/notebooks/olink_demo.ipynb b/notebooks/olink_demo.ipynb new file mode 100644 index 0000000..87d76ce --- /dev/null +++ b/notebooks/olink_demo.ipynb @@ -0,0 +1,949 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6fb1db04", + "metadata": {}, + "source": [ + "# Olink NPX simulator — end-to-end demo\n", + "\n", + "This notebook walks through [`synthlab.olink.simulate_olink_npx`](../synthlab/olink.py)\n", + "— a minimal, dependency-light simulator for [Olink](https://olink.com)-style NPX\n", + "(Normalized Protein eXpression) proteomics data. As of 2026-04 there is no\n", + "widely-used open-source Olink simulator; the closest analogues are\n", + "[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/)\n", + "(LC-MS/MS, not NPX) and the [OlinkAnalyze R\n", + "package](https://github.com/Olink-Proteomics/OlinkRPackage), which ships demo\n", + "tables but no generative simulator.\n", + "\n", + "The model implemented in [`synthlab/olink.py`](../synthlab/olink.py) is deliberately\n", + "minimal and covers the three features needed to exercise downstream ML /\n", + "biomarker-discovery pipelines:\n", + "\n", + "- Per-protein NPX ~ N(mean, sd) draws with user-configurable **group-mean\n", + " shifts** (the \"biomarker\" signal).\n", + "- **Limit-of-detection (LOD)** driven missingness: 80% of sub-LOD values are\n", + " dropped (MNAR), 20% are retained and can be flagged with `qc_warning`.\n", + "- **Per-plate batch effects** — 96 samples / plate, plate intercepts drawn\n", + " from N(0, `plate_effect_sd`^2).\n", + "\n", + "Deferred to follow-up PRs: full MAR missingness, multi-factor batch effects,\n", + "panel-version LOD bridging, and a realistic PEA dilution noise model. See\n", + "[PR #2](https://github.com/bschilder/synthlab/pull/2) for the roadmap.\n", + "\n", + "**Install extras for this notebook** (`matplotlib`, `seaborn`, `scikit-learn`,\n", + "`umap-learn`):\n", + "\n", + "```bash\n", + "pip install synthlab[viz]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "795f4b66", + "metadata": {}, + "source": [ + "## 2. Minimal generate + peek\n", + "\n", + "Draw 500 samples split 250/250 case/control, with three manually-injected\n", + "biomarkers (CRP, IL6, TNF). We use the built-in 50-protein\n", + "[`default_explore_3072_panel`](../synthlab/olink.py) — a UKB-PPP-informed subset\n", + "of the Olink Explore 3072 panel." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "691b0609", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:04.708702Z", + "iopub.status.busy": "2026-04-23T20:15:04.708309Z", + "iopub.status.idle": "2026-04-23T20:15:05.427946Z", + "shell.execute_reply": "2026-04-23T20:15:05.427408Z" + } + }, + "outputs": [], + "source": [ + "# NOTE: only the `viz` extra is required in addition to core deps.\n", + "import warnings\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import polars as pl\n", + "import seaborn as sns\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", + "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n", + "\n", + "sns.set_theme(style=\"whitegrid\", palette=\"colorblind\")\n", + "plt.rcParams[\"figure.dpi\"] = 100\n", + "plt.rcParams[\"savefig.dpi\"] = 100\n", + "\n", + "RNG_SEED = 42" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7d72c821", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.429242Z", + "iopub.status.busy": "2026-04-23T20:15:05.429156Z", + "iopub.status.idle": "2026-04-23T20:15:05.924886Z", + "shell.execute_reply": "2026-04-23T20:15:05.924497Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[38;5;199m ░██████╗██╗░░░██╗███╗░░██╗████████╗██╗░░██╗ ██╗░░░░░░█████╗░██████╗░\u001b[0m\n", + "\u001b[38;5;165m ██╔════╝╚██╗░██╔╝████╗░██║╚══██╔══╝██║░░██║ ██║░░░░░██╔══██╗██╔══██╗\u001b[0m\n", + "\u001b[38;5;135m ╚█████╗░░╚████╔╝░██╔██╗██║░░░██║░░░███████║ ██║░░░░░███████║██████╦╝\u001b[0m\n", + "\u001b[38;5;99m ░╚═══██╗░░╚██╔╝░░██║╚████║░░░██║░░░██╔══██║ ██║░░░░░██╔══██║██╔══██╗\u001b[0m\n", + "\u001b[38;5;75m ██████╔╝░░░██║░░░██║░╚███║░░░██║░░░██║░░██║ ███████╗██║░░██║██████╦╝\u001b[0m\n", + "\u001b[38;5;51m ╚═════╝░░░░╚═╝░░░╚═╝░░╚══╝░░░╚═╝░░░╚═╝░░╚═╝ ╚══════╝╚═╝░░╚═╝╚═════╝░\u001b[0m\n", + "\u001b[38;5;49m ▌║█║▌│║▌│║▌║▌█║▌║█║▌│║▌│║▌║▌█║▌║█║▌│║▌│║▌║▌█║▌│║▌│║▌║▌█║\u001b[0m\n", + "\u001b[38;5;99m ════════════════════════════════════════════════════════════════════\u001b[0m\n", + "\u001b[38;5;255m \u001b[1mSynthetic Healthcare Data Toolkit\u001b[0m\n", + "\u001b[38;5;99m ────────────────────────────────────────────────────────────────────\u001b[0m\n", + "\u001b[38;5;199m ◈\u001b[0m EHR \u001b[38;5;255mSynthetic patient records (diagnoses, meds, labs)\u001b[0m\n", + "\u001b[38;5;165m ◈\u001b[0m Genomics \u001b[38;5;255mSynthetic genotypes with realistic LD structure\u001b[0m\n", + "\u001b[38;5;135m ◈\u001b[0m Imaging \u001b[38;5;255mDatasets + synthetic generation (CT, MRI, X-ray)\u001b[0m\n", + "\u001b[38;5;51m ◈\u001b[0m Multimodal \u001b[38;5;255mLinked EHR + Imaging + Genomics per patient\u001b[0m\n", + "\u001b[38;5;49m ◈\u001b[0m AI Notes \u001b[38;5;255mSOAP notes with causal graph analysis\u001b[0m\n", + "\u001b[38;5;99m ════════════════════════════════════════════════════════════════════\u001b[0m\n", + "\n", + " \u001b[38;5;51mVersion:\u001b[0m \u001b[38;5;255m0.2.0\u001b[0m\n", + " \u001b[38;5;51mCache:\u001b[0m \u001b[38;5;255m/Users/bschilder/.cache/synthlab\u001b[0m\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "shape: (10, 6)
sample_idprotein_idnpxqc_warninggroupplate_id
strstrf64boolstrstr
"S0000""CRP"6.922412false"case""plate_0"
"S0000""IL6"6.055962false"case""plate_0"
"S0000""TNF"5.935627false"case""plate_0"
"S0000""IL1B"4.533881false"case""plate_0"
"S0000""IL10"5.573346false"case""plate_0"
"S0000""IL8"5.512383false"case""plate_0"
"S0000""IFNG"5.085326false"case""plate_0"
"S0000""BNP"5.326213false"case""plate_0"
"S0000""NT-proBNP"4.530132false"case""plate_0"
"S0000""TROPT"5.266958false"case""plate_0"
" + ], + "text/plain": [ + "shape: (10, 6)\n", + "┌───────────┬────────────┬──────────┬────────────┬───────┬──────────┐\n", + "│ sample_id ┆ protein_id ┆ npx ┆ qc_warning ┆ group ┆ plate_id │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ bool ┆ str ┆ str │\n", + "╞═══════════╪════════════╪══════════╪════════════╪═══════╪══════════╡\n", + "│ S0000 ┆ CRP ┆ 6.922412 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL6 ┆ 6.055962 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ TNF ┆ 5.935627 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL1B ┆ 4.533881 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL10 ┆ 5.573346 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IL8 ┆ 5.512383 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ IFNG ┆ 5.085326 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ BNP ┆ 5.326213 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ NT-proBNP ┆ 4.530132 ┆ false ┆ case ┆ plate_0 │\n", + "│ S0000 ┆ TROPT ┆ 5.266958 ┆ false ┆ case ┆ plate_0 │\n", + "└───────────┴────────────┴──────────┴────────────┴───────┴──────────┘" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from synthlab import (\n", + " OlinkSimConfig,\n", + " default_explore_3072_panel,\n", + " simulate_olink_npx,\n", + ")\n", + "\n", + "panel = default_explore_3072_panel()\n", + "cfg = OlinkSimConfig(\n", + " n_samples=500,\n", + " panel=panel,\n", + " group_effects={\n", + " \"CRP\": {\"case\": 1.8},\n", + " \"IL6\": {\"case\": 1.2},\n", + " \"TNF\": {\"case\": 0.9},\n", + " },\n", + " group_assignments=[\"case\"] * 250 + [\"control\"] * 250,\n", + " seed=RNG_SEED,\n", + ")\n", + "df = simulate_olink_npx(cfg)\n", + "df.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "922fda35", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.926041Z", + "iopub.status.busy": "2026-04-23T20:15:05.925966Z", + "iopub.status.idle": "2026-04-23T20:15:05.950966Z", + "shell.execute_reply": "2026-04-23T20:15:05.950605Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (9, 7)
statisticsample_idprotein_idnpxqc_warninggroupplate_id
strstrstrf64f64strstr
"count""23737""23737"23737.023737.0"23737""23737"
"null_count""0""0"0.00.0"0""0"
"mean"nullnull5.0096210.010995nullnull
"std"nullnull0.661795nullnullnull
"min""S0000""AB40"2.7264760.0"case""plate_0"
"25%"nullnull4.569688nullnullnull
"50%"nullnull4.992854nullnullnull
"75%"nullnull5.424174nullnullnull
"max""S0499""VWF"8.4487661.0"control""plate_5"
" + ], + "text/plain": [ + "shape: (9, 7)\n", + "┌────────────┬───────────┬────────────┬──────────┬────────────┬─────────┬──────────┐\n", + "│ statistic ┆ sample_id ┆ protein_id ┆ npx ┆ qc_warning ┆ group ┆ plate_id │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ str ┆ str ┆ f64 ┆ f64 ┆ str ┆ str │\n", + "╞════════════╪═══════════╪════════════╪══════════╪════════════╪═════════╪══════════╡\n", + "│ count ┆ 23737 ┆ 23737 ┆ 23737.0 ┆ 23737.0 ┆ 23737 ┆ 23737 │\n", + "│ null_count ┆ 0 ┆ 0 ┆ 0.0 ┆ 0.0 ┆ 0 ┆ 0 │\n", + "│ mean ┆ null ┆ null ┆ 5.009621 ┆ 0.010995 ┆ null ┆ null │\n", + "│ std ┆ null ┆ null ┆ 0.661795 ┆ null ┆ null ┆ null │\n", + "│ min ┆ S0000 ┆ AB40 ┆ 2.726476 ┆ 0.0 ┆ case ┆ plate_0 │\n", + "│ 25% ┆ null ┆ null ┆ 4.569688 ┆ null ┆ null ┆ null │\n", + "│ 50% ┆ null ┆ null ┆ 4.992854 ┆ null ┆ null ┆ null │\n", + "│ 75% ┆ null ┆ null ┆ 5.424174 ┆ null ┆ null ┆ null │\n", + "│ max ┆ S0499 ┆ VWF ┆ 8.448766 ┆ 1.0 ┆ control ┆ plate_5 │\n", + "└────────────┴───────────┴────────────┴──────────┴────────────┴─────────┴──────────┘" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "24982f57", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.951908Z", + "iopub.status.busy": "2026-04-23T20:15:05.951852Z", + "iopub.status.idle": "2026-04-23T20:15:05.955301Z", + "shell.execute_reply": "2026-04-23T20:15:05.954886Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "schema : {'sample_id': String, 'protein_id': String, 'npx': Float64, 'qc_warning': Boolean, 'group': String, 'plate_id': String}\n", + "rows : 23,737 / 25,000 possible\n", + "overall drop rate : 5.05%\n", + "unique samples : 500\n", + "unique proteins : 50\n", + "unique plates : 6\n", + "qc_warning rate : 1.10%\n" + ] + } + ], + "source": [ + "# Frame schema + size + row-count + missingness summary.\n", + "n_samples = 500\n", + "n_proteins = len(panel.proteins)\n", + "n_expected = n_samples * n_proteins\n", + "n_observed = df.height\n", + "drop_rate = 1.0 - n_observed / n_expected\n", + "\n", + "print(f\"schema : {dict(df.schema)}\")\n", + "print(f\"rows : {n_observed:,} / {n_expected:,} possible\")\n", + "print(f\"overall drop rate : {drop_rate:.2%}\")\n", + "print(f\"unique samples : {df['sample_id'].n_unique()}\")\n", + "print(f\"unique proteins : {df['protein_id'].n_unique()}\")\n", + "print(f\"unique plates : {df['plate_id'].n_unique()}\")\n", + "print(f\"qc_warning rate : {df['qc_warning'].mean():.2%}\")" + ] + }, + { + "cell_type": "markdown", + "id": "15a3a5dd", + "metadata": {}, + "source": [ + "## 3. Per-protein NPX distributions\n", + "\n", + "A 4x4 grid of NPX histograms for a representative slice of the panel. Case\n", + "(orange) vs control (blue) KDEs are overlaid; the red dashed line marks each\n", + "protein's LOD. Proteins with a non-zero `group_effects` entry are annotated\n", + "with their injected mean shift." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5b3eb348", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:05.956259Z", + "iopub.status.busy": "2026-04-23T20:15:05.956186Z", + "iopub.status.idle": "2026-04-23T20:15:06.813185Z", + "shell.execute_reply": "2026-04-23T20:15:06.812704Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Focus on a mix of injected biomarkers (first 3) plus 13 unrelated proteins.\n", + "display_proteins = [\"CRP\", \"IL6\", \"TNF\"] + [\n", + " p for p in panel.proteins if p not in {\"CRP\", \"IL6\", \"TNF\"}\n", + "][:13]\n", + "group_shifts = {\"CRP\": 1.8, \"IL6\": 1.2, \"TNF\": 0.9}\n", + "\n", + "fig, axes = plt.subplots(4, 4, figsize=(14, 12), sharex=False, sharey=False)\n", + "fig.suptitle(\n", + " \"Per-protein NPX distributions (case vs control)\",\n", + " fontsize=15,\n", + " fontweight=\"bold\",\n", + ")\n", + "\n", + "palette = sns.color_palette(\"colorblind\", 2)\n", + "for ax, prot in zip(axes.flat, display_proteins):\n", + " sub = df.filter(pl.col(\"protein_id\") == prot)\n", + " for (grp, color) in zip([\"control\", \"case\"], palette):\n", + " vals = sub.filter(pl.col(\"group\") == grp)[\"npx\"].to_numpy()\n", + " if vals.size == 0:\n", + " continue\n", + " ax.hist(vals, bins=25, alpha=0.45, color=color, label=grp)\n", + " sns.kdeplot(vals, ax=ax, color=color, linewidth=1.5)\n", + " ax.axvline(panel.lod[prot], color=\"crimson\", linestyle=\"--\", linewidth=1.2,\n", + " label=\"LOD\")\n", + " shift = group_shifts.get(prot)\n", + " title = f\"{prot}\" if shift is None else f\"{prot} (case +{shift})\"\n", + " ax.set_title(title, fontsize=10)\n", + " ax.set_xlabel(\"NPX\")\n", + " ax.set_ylabel(\"count\")\n", + "axes.flat[0].legend(loc=\"upper left\", fontsize=8)\n", + "fig.tight_layout(rect=[0, 0, 1, 0.97])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f6df3c9c", + "metadata": {}, + "source": [ + "## 4. LOD-driven missingness\n", + "\n", + "The `mnar_lod` missingness model in\n", + "[`simulate_olink_npx`](../synthlab/olink.py) drops 80% of sub-LOD values and\n", + "retains the remaining 20% (which downstream pipelines would flag with\n", + "`qc_warning`). On top of LOD dropout, a small MCAR pass removes\n", + "`missing_rate` (default 5%) of the survivors.\n", + "\n", + "**Left:** per-protein mean NPX vs LOD, coloured by observed drop rate. The\n", + "closer a protein's mean is to its LOD, the larger its drop rate.\n", + "**Right:** top-20 most-dropped proteins, with rate bars." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9c3d3f39", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.814388Z", + "iopub.status.busy": "2026-04-23T20:15:06.814308Z", + "iopub.status.idle": "2026-04-23T20:15:06.826812Z", + "shell.execute_reply": "2026-04-23T20:15:06.826421Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 6)
protein_idobserved_meann_observeddrop_ratelodprior_mean
strf64u32f64f64f64
"GHRL"4.9230214640.0723.05.0
"HGF"4.9339044670.0663.05.0
"IGF1"4.9809174680.0643.05.0
"FABP4"4.9776094680.0643.05.0
"TGFB1"4.9739234680.0643.05.0
" + ], + "text/plain": [ + "shape: (5, 6)\n", + "┌────────────┬───────────────┬────────────┬───────────┬─────┬────────────┐\n", + "│ protein_id ┆ observed_mean ┆ n_observed ┆ drop_rate ┆ lod ┆ prior_mean │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 ┆ f64 ┆ f64 │\n", + "╞════════════╪═══════════════╪════════════╪═══════════╪═════╪════════════╡\n", + "│ GHRL ┆ 4.923021 ┆ 464 ┆ 0.072 ┆ 3.0 ┆ 5.0 │\n", + "│ HGF ┆ 4.933904 ┆ 467 ┆ 0.066 ┆ 3.0 ┆ 5.0 │\n", + "│ IGF1 ┆ 4.980917 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ FABP4 ┆ 4.977609 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "│ TGFB1 ┆ 4.973923 ┆ 468 ┆ 0.064 ┆ 3.0 ┆ 5.0 │\n", + "└────────────┴───────────────┴────────────┴───────────┴─────┴────────────┘" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "per_protein = (\n", + " df.group_by(\"protein_id\")\n", + " .agg(observed_mean=pl.col(\"npx\").mean(),\n", + " n_observed=pl.col(\"npx\").len())\n", + " .with_columns(\n", + " drop_rate=1.0 - pl.col(\"n_observed\") / n_samples,\n", + " lod=pl.col(\"protein_id\").map_elements(\n", + " lambda p: panel.lod[p], return_dtype=pl.Float64),\n", + " prior_mean=pl.col(\"protein_id\").map_elements(\n", + " lambda p: panel.mean[p], return_dtype=pl.Float64),\n", + " )\n", + " .sort(\"drop_rate\", descending=True)\n", + ")\n", + "per_protein.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "947b60ed", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.827755Z", + "iopub.status.busy": "2026-04-23T20:15:06.827700Z", + "iopub.status.idle": "2026-04-23T20:15:06.943679Z", + "shell.execute_reply": "2026-04-23T20:15:06.943295Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n", + "\n", + "# --- (a) observed mean vs LOD, coloured by drop rate ------------------------\n", + "pp = per_protein.to_pandas()\n", + "sc = ax1.scatter(\n", + " pp[\"lod\"], pp[\"observed_mean\"],\n", + " c=pp[\"drop_rate\"], cmap=\"viridis\", s=70, edgecolor=\"k\",\n", + " linewidth=0.4,\n", + ")\n", + "lo = min(pp[\"lod\"].min(), pp[\"observed_mean\"].min()) - 0.2\n", + "hi = max(pp[\"lod\"].max(), pp[\"observed_mean\"].max()) + 0.2\n", + "ax1.plot([lo, hi], [lo, hi], \"k--\", linewidth=1, alpha=0.5, label=\"y = x\")\n", + "cbar = plt.colorbar(sc, ax=ax1)\n", + "cbar.set_label(\"drop rate\", rotation=270, labelpad=14)\n", + "ax1.set_xlabel(\"per-protein LOD\")\n", + "ax1.set_ylabel(\"observed mean NPX\")\n", + "ax1.set_title(\"(a) per-protein mean vs LOD\")\n", + "ax1.legend(loc=\"lower right\")\n", + "\n", + "# --- (b) top-20 most-dropped proteins ---------------------------------------\n", + "top20 = per_protein.head(20).to_pandas()\n", + "ax2.barh(top20[\"protein_id\"][::-1], top20[\"drop_rate\"][::-1],\n", + " color=sns.color_palette(\"colorblind\")[2])\n", + "ax2.set_xlabel(\"drop rate\")\n", + "ax2.set_title(\"(b) top-20 most-dropped proteins\")\n", + "ax2.set_xlim(0, max(top20[\"drop_rate\"].max() * 1.1, 0.05))\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "648eee95", + "metadata": {}, + "source": [ + "## 5. Plate batch effects\n", + "\n", + "With 500 samples at 96 per plate we get 6 plates; each plate gets an\n", + "intercept drawn from N(0, `plate_effect_sd`^2). The violin plot shows that\n", + "CRP still separates case vs control *within* each plate, despite the\n", + "plate-level offset." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dc3e730e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:06.944895Z", + "iopub.status.busy": "2026-04-23T20:15:06.944813Z", + "iopub.status.idle": "2026-04-23T20:15:07.119529Z", + "shell.execute_reply": "2026-04-23T20:15:07.119043Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subset = (\n", + " df.filter(pl.col(\"protein_id\").is_in([\"CRP\", \"IL6\", \"TNF\"]))\n", + " .to_pandas()\n", + ")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 5.5), sharey=True)\n", + "for ax, prot in zip(axes, [\"CRP\", \"IL6\", \"TNF\"]):\n", + " sub = subset[subset[\"protein_id\"] == prot]\n", + " sns.violinplot(\n", + " data=sub, x=\"plate_id\", y=\"npx\", hue=\"group\",\n", + " split=True, inner=\"quartile\", ax=ax, palette=\"colorblind\",\n", + " density_norm=\"width\",\n", + " )\n", + " ax.set_title(f\"{prot}: per-plate NPX (case vs control)\")\n", + " ax.set_xlabel(\"plate\")\n", + " ax.set_ylabel(\"NPX\")\n", + " ax.tick_params(axis=\"x\", rotation=30)\n", + "\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c0812ae5", + "metadata": {}, + "source": [ + "## 6. Sample-level dimensionality reduction (PCA + UMAP)\n", + "\n", + "Pivot long -> wide (`sample` x `protein`), impute missing NPX with the\n", + "per-protein median (the standard Olink convention), then run PCA and UMAP.\n", + "Cases are expected to separate along the three injected-biomarker axes." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "27289b07", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:07.120686Z", + "iopub.status.busy": "2026-04-23T20:15:07.120601Z", + "iopub.status.idle": "2026-04-23T20:15:07.135576Z", + "shell.execute_reply": "2026-04-23T20:15:07.135214Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample x protein matrix: (500, 50)\n", + "label counts : case=250, control=250\n" + ] + } + ], + "source": [ + "wide = (\n", + " df.pivot(values=\"npx\", index=\"sample_id\", on=\"protein_id\",\n", + " aggregate_function=\"first\")\n", + " .sort(\"sample_id\")\n", + ")\n", + "# Per-protein median imputation.\n", + "imputed = wide.with_columns([\n", + " pl.col(col).fill_null(pl.col(col).median())\n", + " for col in wide.columns if col != \"sample_id\"\n", + "])\n", + "# Sample-level group labels.\n", + "sample_groups = (\n", + " df.group_by(\"sample_id\").agg(group=pl.col(\"group\").first())\n", + " .sort(\"sample_id\")\n", + ")\n", + "X = imputed.drop(\"sample_id\").to_numpy()\n", + "y = sample_groups[\"group\"].to_numpy()\n", + "print(f\"sample x protein matrix: {X.shape}\")\n", + "print(f\"label counts : case={int((y == 'case').sum())}, \"\n", + " f\"control={int((y == 'control').sum())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3f92ba55", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:07.136684Z", + "iopub.status.busy": "2026-04-23T20:15:07.136621Z", + "iopub.status.idle": "2026-04-23T20:15:20.480665Z", + "shell.execute_reply": "2026-04-23T20:15:20.480186Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.decomposition import PCA\n", + "from sklearn.preprocessing import StandardScaler\n", + "import umap\n", + "\n", + "Xz = StandardScaler().fit_transform(X)\n", + "pca = PCA(n_components=2, random_state=RNG_SEED)\n", + "pcs = pca.fit_transform(Xz)\n", + "umap_model = umap.UMAP(n_components=2, random_state=RNG_SEED, n_neighbors=15,\n", + " min_dist=0.1)\n", + "emb = umap_model.fit_transform(Xz)\n", + "\n", + "fig, (axL, axR) = plt.subplots(1, 2, figsize=(14, 6))\n", + "palette = dict(zip([\"control\", \"case\"], sns.color_palette(\"colorblind\", 2)))\n", + "for grp, color in palette.items():\n", + " mask = y == grp\n", + " axL.scatter(pcs[mask, 0], pcs[mask, 1], c=[color], label=grp, alpha=0.75,\n", + " edgecolor=\"k\", linewidth=0.3, s=35)\n", + " axR.scatter(emb[mask, 0], emb[mask, 1], c=[color], label=grp, alpha=0.75,\n", + " edgecolor=\"k\", linewidth=0.3, s=35)\n", + "axL.set_xlabel(f\"PC1 ({pca.explained_variance_ratio_[0]:.1%} var)\")\n", + "axL.set_ylabel(f\"PC2 ({pca.explained_variance_ratio_[1]:.1%} var)\")\n", + "axL.set_title(\"PCA of sample x protein matrix\")\n", + "axL.legend(title=\"group\")\n", + "axR.set_xlabel(\"UMAP 1\")\n", + "axR.set_ylabel(\"UMAP 2\")\n", + "axR.set_title(\"UMAP of sample x protein matrix\")\n", + "axR.legend(title=\"group\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a1f6479a", + "metadata": {}, + "source": [ + "## 7. Protein-protein correlation\n", + "\n", + "Pairwise Pearson correlations for the 25 most-expressed proteins, ordered by\n", + "hierarchical clustering. Injected biomarkers (CRP, IL6, TNF) are expected to\n", + "cluster together because every case sample shifts all three simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e75c4988", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.482029Z", + "iopub.status.busy": "2026-04-23T20:15:20.481900Z", + "iopub.status.idle": "2026-04-23T20:15:20.606389Z", + "shell.execute_reply": "2026-04-23T20:15:20.605860Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKAAAARkCAYAAABFIGweAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA7eBJREFUeJzs3QeYXGXZMOAnZZPNpjcSQglSpAtBSoAgQkC6ICBiQZQSBCmGIgT4aCJBQSIQUFBQ6QQIXT5KUCHwUQVBkWAj1BRIIcmmLGT/6z04+29NNmUyZ3fv+7rmmpkzZ868856ye5553ue0q66urg4AAAAAKJL2xVowAAAAAAhAAQAAAFB0MqAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACaGOuvPLK2HDDDRvcNttssxg2bFh8//vfjz//+c9F+/w333xzud73zjvvZO0844wzojVY3n5IUj8cdthhK60thb4dMmRIvP32203Ot+uuu2a3+m2pf9t4442zZe2///4xduzYmD9/fs38N9xwQzbPN7/5zVi8eHGjn3PLLbdk85xzzjnRmowfPz77Xul+eU2ePLnO87QdpGWW2v/+7//GzjvvXGddz5kzJ2bMmFGyNs2cOTN+9KMfZdtsOr4NHTo0TjrppPjXv/7VYN6rr7660W053dIxs9jrta248cYb48tf/nJUVVWVuikAlEDHUnwoAKX3ta99LT7/+c/XPP/444/jvffey07+//jHP8Yvf/nL2GmnnVbqZx577LExd+7c7CRkWfXp0yd++tOfxtprrx0t3YUXXpj18WOPPbZc70/90K9fv5XersrKyjjzzDOzIFG7du2a/b7evXvHqFGjap5XV1dny3riiSeyk/dnn302fve730X79u2zgEma/uSTT8avf/3rGDFiRJ1l/e1vf4vRo0fHZz/72TjrrLNW6vdr6X71q1/F5ZdfHn/9619rpn3ve9+Lgw8+uKTtSoGeCy64IE4//fTo0qVLNm3ixIlx2mmnxc9//vPYbrvtVnmbFi5cGN/+9rfjn//8Zxx44IGx+eabZ4HWdHxLbbvttttigw02qJl/0qRJUVFREeedd16DZeUhwNdafOMb34hbb701+/tywgknlLo5AKxiAlAAbdSWW26ZZajUl7IFDjrooCzIsbIDUI8//nhsu+22y/XedHLYWHtbotQPK6KY/fDcc8/FTTfdtEwZVk2tm3SymYKO6fs++uijsccee2SBrRRgSlkQV1xxRZZ1t8kmm9RkzPzgBz+Ijh07ZoGLzp07r9Tv1tKlwF39zJEdd9wxSu2yyy7LgpD77bdfzbSXXnqppNlPv/3tb+ONN97IAmMp2F6w1157xSGHHBKXXHJJXHvttTXTX3/99Vh//fVbzTEmrzp06JAFnlJwMvV1a/hBAYDmMwQPgDo23XTTLDMgnbzNnj1b77QhO+ywQ/To0SN+9rOfxVtvvbVSlnnAAQdk988//3zNtP79+8ePf/zjLJiSTkRTtkqSMp7S56ahd+utt95K+XyKa+rUqXH33XfHV77ylSzDLS+eeuqpKCsra5Adlo5vKdBUe3tMwwbTdlc7I4ri2W233bKg9XXXXaebAdqY/PynAEBuFE4kP/nkk+w+ZcPsu+++ceedd2ZBipQ9lbIeCvOkIXXp1+zPfe5zsdVWW2VDX/70pz/VLC8NwSoMY0kZNvXrpbzyyivZUKKUHZWGyqTPuv7662s+v6kaUIV2peyFo48+OhtSmGoPHXHEEdkym6NQvyVll5x77rnZcKH0HdKyU1trS5+dlp++2y677JJ931NPPbXm9fvuuy/Ltkj9k27p8b333tvgO7z77rvZrX59mX//+99x8sknx/bbb5/VrPnSl76UZQItWLBgiTWgCu1Ky08ZROk7pLYdeuih2XCj5howYEA2BC+dkKchdU3VaFrWjIek9rosZNql/klDpMaMGZNtWw8//HAWsErBjOZ69dVXs4yK1GeFulO33357NgywtqWtm9rbaRqmlbahtA6+8IUvZEGWJe0Dyf33359l1qTpqR2pxlVzMt1SO++4444sW2zrrbfOAiQpKyxtB7XrPaV2FbbH2vtBYzWgUkDvqquuij333DP7Dmm/SvvXyy+/3Gg9uFQT6eyzz86yqdL+l/owfZ/mSPt+CiSmzypIbUq1v5J0LKhdNywFtS+++OIYPnx41ra03tJ3rV+XKX2/lBmXAkNp3059mmo4nXLKKdl2vjQpiJrWVWH7q93fH374YZ1g2T/+8Y9sW0/DPgv9tzw1itKw0/PPPz/b/9J28K1vfSuefvrpBseaNPS0vrRu0mu/+MUvmlx+YX2l9qb+KXxO6u80LQ2FTPtvmp62paOOOir+85//NFhOc7fVDz74IC666KIsczEdT9Jt7733zratNGR7ebejFBhM6z8FLkuZJQfAqicABUAd77//fhYIWWONNbK6SwXppO8nP/lJfPe7382GVaUT83TSdvzxx2c1jXr27JmdHKaTnrSMVNvnN7/5TfbelM2ShvQl6667bvZ4m222yZ5PmDAhO/lORbnTe1MdmbXWWiv7rFQwuH4gob7p06dnJ3opcydl06STqXSintqZhnQ1V6r9kuoSHXnkkVnb04lbWkbtQFrh5HTkyJFZXZl04pxOzpJU7Dh9fjpxTX2SbosWLYof/vCHWf/UrmOVhiulW3q8++67Z6+lgFnK1njhhRey75BOJNMJYqqVcvjhh9dkCTUlfW7qxxQ8OvHEE+OYY47JgjvpuyxLwfMU/EnBtdSOVAtqRRUCYOnktb4U5PrMZz6TfU7KiErbRgoCNldaX1//+tezbJYUbEt93bdv3yyDKgXuCpqzbmpLw7PSMMD/+Z//yYajpsBcU/tAYf4UiOzWrVu2TRx33HExb968bJ40FGxJ0nDEdNKetoe0XaX1nvaN3//+99k6LAQB07aS+qfwuPawstrS+k8BiTS8Me13qY/T9pS2r3T/0EMPNXhP2kZS8CB9XtrnUlAgfZ9nnnlmqesgDa1MgaI111yzZloKdhW26/Q4fadCQCNt46lP0ndM09P29oc//CHr57TN1Zb2/bTtp75M/ZoCGilImb77lClTltiulGW30UYbNZieAiLpmFG7LlUKYBfqj6UheltssUV2S8Gz1157LZorBb0Kx5C07lMAMT0u1HpLQbquXbs2CHwm99xzTxYUK2QMLkkKyKXvkLaX1Bep31I/p/am6Wkdpn5OWWApOFs7kNzcbTUdO1OQ6q677srWZdoX0n6ThtCmbauxINqybEdpmemYtiwBcgBagWoA2pQrrrii+rOf/Wz1jTfeWP3hhx/W3KZMmVL9xz/+sforX/lK9vqdd95Z855vfetb2bSbbrqpzrLuvvvubPrpp59evXjx4prpc+bMqd5zzz2rN9lkk+rJkyfXTE/zpmUVVFZWVm+33XbZZy5cuLDOsseMGZPN/+CDD2bP33777ZrPqt+ua6+9ts57r7rqqmz67bffvtT+uOuuu7J5d9xxx+oZM2bUTH///fert9xyy+pdd9215rulz07z/uQnP6mzjOeffz6bfvjhh1cvWrSoZnp6fNhhh2WvPfvsszXTd9lll+xWkJa/zz77VO+8887VM2fOrLPscePGNfiO9fux0K5zzz23znvvueeebPpll122xD6o37dTp06t3mabbao/97nPVf/73/9ust2FtqR2196W0u2NN96ovvLKK6s32mij6i996UvVCxYsaPSzC32Xbk899VR1c6U+S23Zdttts2234JNPPqn++te/Xr3ZZptlfbks6+aZZ57Jnn/xi1+snj9/fp3Pa2of+Mtf/pJNP++88+pMLyx/0003zbal2ttauk/S9pb2kWOOOabB9zvxxBOzef/61782aENj7SoYO3Zs9vzyyy+vM9+0adOyfW3rrbeu/uijj+ocC44++ug6+2+hz04++eQlroPU72m+M888s8FrhWWnPi0YNWpUg2NLkraV1E+777579ccff1xnmz7yyCNrpiWPPvpoNv2MM86oXlaTJk3Kvn/q81dffbVm+gUXXJAtM21PN9xwQ/Vjjz2WbbtDhgyp3mKLLapfeeWVJS63sF532mmn6tmzZ9fpn7SMtNy0XSapr9K8f//732vmS8e+tL9997vfXeLn1F5ftR133HHZ9Prb0Q9+8INseuEYvCzb6u9+97ts3ocffrjOvOn7pfn23XffRtvV3O1oSdsOAK2XDCiANiplhaThL4VbyuZIv2BPmzYtyyBJGQn1pWET9S+9nqRhX7WvmpZ+XU+/yKdhGiljoSlpeEoaNpKyiNLV8dIv5oVbGupRyLBYmlTQurY0/CNJ2QDNlbIHUhZKwcCBA7OMi5T1Uj8LovaQoqSQVZIyBNLwkoL0OGUjJSmjpSnpClxpCE26jH3KVqjdDykbKRXjXlX9kKy22mpZPaY09K85Q/FSxlvtbSnd0nC1NFQnbVcps6KpguIpw6IgDbtcWsZbQVonaRhj+s6FDKUkZZGkLI+UZZK2w+VZN2mIXXl5eaOfW38fePDBB7P7tL3WXm8pgyRNS1lXKcOnMWl7S9krl156aZ3pH330Uc3V5NKwrmWR9slUXydlodTPCErbeFp2ytKpLRUPr73/FrLVUsbSkhQy6wYPHrzUdqVt6JFHHsnmTdmDtaXaS2lfSxlDKQuptrTeag+jS/WDUg2ntD80d1spbC8pmyp9/5R5lYb/FaQhj+l4lYbspeyxtI7T56btNmXKpey85kjLT5mYBWm7TN8rbaeF71U4rtbOgkrD39LQxPr90pTCsbEg9Ueyzz771JleKPCdhpAu67aatpV0fE79XVs6Xnfv3r3R7XJZtqPUN2kfW1m15gBoGVwFD6CNSkND0olXQadOnbKT1HTSUvskorZ+/frVeZ5OHtJJfgrW1Feop7Kkei2F+iSplk7tejq1pZO3pUntri19l6QQOElDTOqfMKUARK9evRq0t7bCkKf0PVNtnqY+r3AS1VgR42Xph3Rp+HQrVj8si8JwpzREMg2lTNtLU9J2kYI+BWn7SdtFGl6X7puS6jKlujjpJDedgKfASKoplE5+l6bQn40VK0/DR1dk3dTfzpf0WmHdpWGgTVnSukuBudTH6cQ/tTW1JQX0Cvvgsq67tIwU5Gks4Nfc79vc7aZQv6d20KUpKXCRAh1p6F1jx5fC+kltqz1cs7H9Mm1XaXhpWmbtYcJNScNo03C1dAxIgdU0FLG2FORNt/pSO1KNpBdffDELkC9pW64dCKptnXXWqVkvKSCc6sul48oDDzyQDQtNAdM0/C4FdQrDFpd1P0/DRZc0vbAel3VbTW1LhcJTnbW0XlKAMPVDUgiQrsh2lL6zGlAAbYsAFEAblU6WUqbHsiic0BSkDISmglWFotOFk5DGFE5MUiZKOtFrTKqZsjRLu/pWyqwpFEUuSIWZU7CjoLF2Fr5D/e/dWGHjpixLP6QT4/oZBwX129CYptbF8kqXsE8n35dffnl88YtfbHK+FOxY1m0pncymulspCyjVfUrZVinolbKBUrHpxgIPtRWKIC/tOy/PullSX9d/rbCMq6++utGT8mT11VdvdHqhJtUf//jHLCMn3VI2YKqplIIm11xzTSyr5dknl/fqdYX3NSdIVlgPTbWtsIzabUvzNrYuCuu+/n7YmFtvvTXL9kxtTdtWysxbFqmmWGp7Cl4tLQDV2HcrfO/abU2ZTqkt//d//5fVqUqB15QZ1VSWYH1NbZ9L2xeWZVtNV0FN2WCpTlOql5X275ThVbhAQ2OWdTtK6zFPV04EoPgEoABYbilbKhUsTwWB62dBpQyFZNCgQU2+v1C4OA3FqB/ASL+0pwK19X/VXx6psG+6Ql5t9bM20nCi+m1I3612FkNTCkNd0jC6dPWp5e2HpH4b0ol5ykRKhdlXtZTRkIoPp+LyaSheOoFtzkn/0qRhTSkjJWWmpRPxNOQvSUOjUkHu9HlpaN6SgnaFPmvsKl+p+HLKKklF7Vd03SxNoR3pOxSGPNYOsqVtKA2Ja0wa+peCT2noa/rOtaUrhC2P9H1Ttk0KHNQPaKQ+WNHvW1th30yZSEuTMpVSACf1eWNBskLbagfr0nxvv/12gyy3tM7T8tKFD5YkDaFLRd7TfGk4aOHCB7Wlz/jqV7+aPU5D8OpLRbVTEDwFopYmtbW+xo4hqfB6KpKfhkumzKIUiGlsyPPKtizbarr6XRqumDK1avd/Cpqm9d2c/liS1O9p+bUzSwFo/fzsAMByK1wBLp1M1c40SdkC1157bRasqJ3Rk37trp0tkYYAppO7dKJY/yQ2Xf0tXUmp/lXolkcK3qTATu1b7RowyU033VTnSnPpxDANEUuZOI0N32qsH1KWVe3Lk6fHhcyrwjyN9UNqSxo2loIO9Wui3H777VmNrdq1klallDHypS99Kf7yl78s9cpjzZWu4pZq4qSr9tWup5UCAan+Tsq+qD2krzHpxDUFPdNVzWoP40nbYRo2lOrdpADJsq6bZZWubFa4FH0hw6Rwop6Cdqm2UKEGT32FbT5dwr5+MKBQO632MpuTcZS+S9r/6mdPffjhh9k2nva32kNvV0RhqGNjQwzrtzU9T0PM0ndLwy7rB3nSekz7acr+qq3+1dZS0C4Fi+vXO6ovZRVdfPHF2TDb9L0bCz4lKRCW5knDzApXqytIQcwUMEuZec0JvKbhsym4WjsglWo9pSF3tddxCuzutNNO2dDLVBcrBXjSVfeKbVm21bRtpiyp+oHvlDWashVr70vLIw0zTW2oPVwWgNZPBhQAyy2dmKVf8VPg5L333suCB+ky8Ol5OklMl+CufQKTfjVPlzy/5ZZbsmyUFNxJBc/TyU8qYJsuKZ5+nU+X7U4nmqkGSwpSrAop4JQCIGl4TMq+uvnmm7OT0zQMbWnSEJXU9hQsSpcuL5wcpyBIIdBS+wQ4nYC+8sorWW2lNPRwyy23jAsvvDArHJ0+/9BDD80yWdJJcQo8pcfpcumlkobKPf/8883KdFmaVHA5ncSmIaCnn356g9dTP6RgV5onFTBPJ+pNDUM6//zz4/vf/362HaY+S8P5UhAhZUClbS9lySzrullWqeB6uuR9yp5Jy0/FnFPmVgpepnWcll+7plFt6bv97Gc/y4pcp8BjCpilTKC0zgsn+ClLpH6NnSuuuCIbQtrYsMdUqyvVk0oZPymQl9qXAnTp+6dlpeBfUxlZyyoVkk778J///OcGrxXamobApQsbpHWUsryee+65rA5T2p5S0CXtdylwkwI8KeumfmZUWk9pu0t9lTKf0vLS/nDCCScssW2pT1MwMgU4//73v2e3+lKbkjPOOCPb5k4++eRsW0kBobTu0nEsBZ9Ttl5zpGLbaTtM2UypzekYktqQhgDW/15pm0nrKWV5pm11VViWbTUdy9M2dMQRR2Tzpe/xxBNPZBl7KWM11fNaEWlob5L2cQDaDgEoAJZbOmlM9UR+97vfZdkCaThV+tU8De9IJ5n1Ty5++MMfZvOkE830a3s6eU3D49Kwm5TpcMMNN2RZSGmI0LHHHpudTK+sk+WlScGQdKWslBWTThbTCX6qTVU/O6UpKVCVTt7SyXQKEKS+SfVd0vdNwbXaUmZXCryl4EO6ilsKQKVgwrhx4+IXv/hFFoBIJ3gpwyedFKbA1MoYiri8UuAwtbe5J+JNSRlUKdiYTnrTd2/sSnMpaJS2jzQsLc2bTo6bKjSd6lKlk/y0DaZgXsqoSMGDVNC+dobMsqyb5ZGCZmkdpiBPyi5Jy09DrtL0dMLflNTWlCmY2pSytpK0L6Qi0SlbJe0bKZOnkLly9NFHZ0GltK+kgEljAai0v6SMn7TcdAXAFDBIxZ7TENQ0JDG1c2VKAZ6UrZgyZ2pfjTD1f7pSXfr8VOsoZT+lbTgFP9L6SoHINLwrZR+lZaTjQWMF5VMmV7r95Cc/yYbSpQBRCj4tafhdCoYXhmambKv6GVf1A1ApGJr2uVTrLLUp7XspEP6d73wnOw41p8h6kmqZpYzNlBGaAoipXlIKajU2zCxtuylIlwJVhXasCs3dVlPAO72WjuuFYYyp+HsKSqXAeFrn6QqO9Ye1Ntezzz6b7f877rjjSvx2AORdu+pluYYtALQy6eQ0BTrSSVZzL4MORM3wuzTsLxVTT0GklSVlJaUMpDRMrXaNtNYiBahSECoNv03BnLYkZcmmjLYU/E1BOwDaDjWgAABYLqmGTyqqfccddzTranj8/6GF06dPj69//ett8runOlIpow+AtkUACgCA5ZaGxKW6aaUqlN+SpNpUaXhbutpjGqrc1mogpSLtKePru9/97kq7GiMALYcAFAAAyy3VS0o1wlItq3QFPpo2b968rEh+qsOUajDVL07e2qULUKQ6gUsrIg9A66QGFAAAAABFJQMKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAAoAAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAKpErr766jjssMOWOM/MmTPjlFNOiW222Sa7/c///E9UVlausjYCAAAArAwCUCXw29/+Nq644oqlznfiiSfG22+/XTP/U089Feeff/4qaSMAAADAytJxpS2JpZo6dWqcddZZ8eKLL8ZnPvOZJc770ksvxXPPPRe///3vY7311sumXXDBBXHUUUfFySefHAMGDNDjAAAAQIsgA2oV+tvf/hY9e/aM++67L7bYYoslzvvCCy9E//79a4JPybbbbhvt2rXLAlgAAAAALYUMqGU0fPjwJb4+YcKEJl/bdddds1tzs6VWX331OtM6deoUvXr1ivfff7+ZrQUAAABoBQGocUOHRZvStfMq+Zj58+dnAaf6OnfuHAsXLlwlbQAAAABYGWRALaMlZTitTOXl5bFo0aIG01PwqaKiYpW0AQAAACAfAaj27VZKQ6hr4MCB8dhjj9WZlgJSs2bNUoAcAAAAaFtFyNu1a9+mbqvKNttsE1OmTInJkyfXTHv22Wez+6222mqVtQMAAABgRbkKXk588sknMX369FiwYEH2PF0lLwWaRo4cGa+88ko888wzce6558YBBxwgAwoAAABoW0Pw2hmCt1KkK9ulK+yNHj06DjzwwGjXrl2MHTs2zj///Dj88MOz4uN77rlnjBo1auV8ICyHtP0VgqQAzalnmP6uAQCAAFSJXHzxxXWer7nmmjFp0qQ60/r27RtXXHHFKm4ZNC0Fn8aMGaOLgGZJWbwAAJAYggcAAABAzq+CtwoLcwMAAADQ8hiCBwAAAEBRSV8CAAAAIOcZUO3arZyWAAAAANAqrYQheJKoAAAAAChmEfL2MqAAAAAAaJr0JQAAAACKSg0oAAAAAIpKDSgAAAAAisoQPAAAAACKyhA8AAAAAIrKVfAAqDFq1KhYsGCBHmGlmDZtWowcOVJvstKUl5fH6NGj9SgAtMkAFACtRgo+jRkzptTNAGiUgCYAtOkheMpIAQAAAFDUq+C1W9FFAABtnOGfNIdhnTSHoZoA+WQIHgBQcoZ/AiuLoZoArTYDyhA8gNaS2dGSsgv8wg0AAC2HDCiAIpPZURwtJVAGtCwt6UcDWv6PKTTOj0zQOq14BlQHGVAAbUWeTszycoLhn2RoXfxoAKWXh7/vwMonAwqAZnNi1pB/kgHI+482LU1efmRqqfw4RuvNgGonAwoAWotSnTCV6mTDP+lAsfjRhlIRvKP1ZkC1b7dSGgIAlF5bO2HyTzq0fgLrtObtLM8ZZH7koT5D8AAAaNMna3k8cWuMk7nlI7DOqtDWtrPmyOuxlBY9BE8GFABt9wR4ZZysOqksXXBiVQUbrOOGnKwtOydzLZvjGtDWrXgAqr0aUM21ePHiGDt2bNxxxx3x0Ucfxec///k499xzY/DgwY3OP3369Bg9enQ89dRT2fOhQ4dmf7gGDhy4oqsNgBydADupzO+6WVmsY8BxDWjrRI9Woauvvjpuu+22uPDCC+P222/PsseOPvroWLRoUZP/rL7//vvxm9/8JrtNmTIljjvuuFXZZAAAAIAc1IAyBK9ZUpDp+uuvj9NOOy123nnnbFr6ZXennXaKRx99NPbZZ58686cMqeeffz5+8YtfxCabbJJNGzFiRBaAmjlzZvTu3XuFVx3QtuRluFliOBIAALQtipCvIq+//nrMmzcvG0ZX0KNHjyy4lAJN9QNQnTt3joqKirjnnnti2223zabde++9sc4660TPnj1XVbOBViRPqf+GIwEA5Fdefrj0o2XrogbUMho+fPgSX58wYUKj09PwuWT11VevM3211VbLhtnVlwJQP/7xj+OCCy6IrbfeOhuu179//7jpppuivbpbAAC5obg0bXF7FVxo3fLyw6UfLVsXV8FbRebPn5/dd+rUqUGgafbs2Q3mr66ujkmTJsWQIUPiqKOOik8++SQ7AHz/+9+PW2+9Nbp167aqmg4AbZpfgWkpJ2orixO+1i1P26ttDdoWQ/CWUVMZTs1JHSzUgio8ThYuXBhdunRpMP+DDz4Yt9xyS/zhD3+oCTb98pe/jF122SXuuuuuOPzww5erHQBAyzxZc6JGcwiYAtB6M6A6dFg5LWnlCkPvUqrq2muvXTM9Pd9oo40azP/iiy/GZz7zmTqZTqn2U5r25ptvrqJWAwDQkgiYApBXMqBWkRRkSsGkZ599tiYAla5099prr8W3vvWtRgNWv//977MMqTRMrzCM75133on99ttvVTUbAACgVctL5mCi6Dat2UooQt5u5bSklUu1n1Kg6dJLL40+ffrEGmusEZdcckkMHDgwdt9996zG04wZM6J79+7ZQeeAAw6I6667Ln7wgx/ESSedlC3j5z//ebacAw88sNRfBwAAoFXIS+ZgYrg1rZkMqFXoxBNPjI8//jjOPvvs7CC3zTbbZEGmFFRKmU3pCnujR4/OAkzp6nipBlQKUqV6T+nKd+lqeKkAeY8ePVZlswEAariCFgBQoqvgtV/RRbQZHTp0iNNOOy271bfmmmtmV72rbb311ssKjwMA5IVMAQCgNBlQhuABAAAAsATSlwAAAADI+xA8RcgBAAAAKOpV8CRRAQAAANA00SMAAAAAcl6E3BA8AAAAAJbAEDwAAAAAikoGFAAAAABFpQYUAAAAAEVlCB4AAAAAOQ9AKUIOAAAAwBIYggcAAABAzouQt2+3UhoCAAAAQOu0EobgSaICAAAAoGmiRwAAAADk/Sp4huABAAAAUMwaUIbgAQAAALAEhuABAAAAUFSG4AEAAABQVK6C10o9/fTTseWWW0ZFRUWpmwIAAAC0cSs+BC8VIW9Ltxbihz/8YUyYMKHUzQAAAABQA6q16tSpU3Tu3LnUzQAAAAAwBK+1OuaYY+Kcc86J119/PTbYYIPo169fg3m22WabkrQNAAAAaFtWuAZUSxqW1pace+652f3VV1+d3bdr9//XU3V1dfb873//e8naBwAAALQdKx6AIpduuOGGUjcBAAAAIOMqeKvQ4sWLY+zYsXHHHXfERx99FJ///OezTKXBgwc3On9VVVVcccUVcc8998ScOXNis802i7POOis23njjpX7WtttuW4RvAAAAAFCCq+C1a9+uTd1WRBoOd9ttt8WFF14Yt99+ezYM7uijj45FixY1Ov95550Xd955Z/zoRz+Ku+66K3r16pXNn4JRAAAAAG0mAEXzpCDT9ddfHyeccELsvPPOsdFGG8WYMWNi6tSp8eijjzaY/+23386CT6NHj44vfvGLsd5668VFF12UXd3ur3/9q24HAAAA2lANqFrFrWlauhrdvHnzYujQoTXTevToEZtsskk8//zzsc8++9SZf+LEidnrX/jCF+rM//jjj+tmAAAAoI3VgGoviao5pkyZkt2vvvrqdaavttpq8f777zeY/80334y11lorHnnkkbj22muzTKkUrDrjjDOybCgAAACAlsJV8JbR8OHDl/j6hAkTGp0+f/787D4Noautc+fOMXv27Abzz507N956662sbtQPf/jDLPvpF7/4RXzjG9+I3//+99G3b99lbToAAABAS70KniF4zVFeXl5TC6rwOFm4cGF06dKlwfxlZWVZsfFUJ6qQ8ZQep/pRd999dxx11FFL/LwU8PrlL38Zf/jDH7LH6Qp89dfbY4891qy2AwAAAKwIGVDLqKkMp6UpDL2bNm1arL322jXT0/NUkLy+gQMHRseOHesMt0uBqzQs75133lnq5/34xz/Orpy37bbbxsYbbxztDZUEAAAAWmwGVIcOK6clrVwKMnXr1i2effbZmgDURx99FK+99lp861vfajD/1ltvHR9//HG8+uqrsfnmm2fTFixYkF0dr37B8sak2lEjR46MESNGFOHbAAAAADSfDKhVJNV+SoGmSy+9NPr06RNrrLFGXHLJJVmm0+677x6ffPJJzJgxI7p3755lOqUA1A477BCnn356XHDBBdGrV6+44oorokOHDrH//vsv9fNS8Opzn/vcKvluAAAAAEuy4pewa9e+bd1WwIknnhgHH3xwnH322fH1r389CyZdd911WXAqXQlv2LBhWYHxgiuvvDIbQnf88cdn70uFyW+44YYsgLU0aVlPPPHECrUXAAAAIB9D8NorQt5cKeB02mmnZbf61lxzzZg0aVKdaWnI3nnnnZfdltXee+8d5557bpZVtcUWWzRa6PyAAw5Y5uUCAAAALCtD8FqpH/zgB9n9Pffck93qS1fBE4ACAAAAWkYG1AoOSyNfV+sDAAAAWNlkQLVSqch5wfz587P6UamQeVlZWUnbBQAAALQ9Kx6AUgMqt1544YXsSnuvvvpqVFdXZ9PSlfFGjhwZQ4cOLXXzAAAAgDbCELxW6s9//nN85zvfibXWWiuOO+646NevX0ybNi0efPDBOOqoo+LGG2+MIUOGlLqZAAAAQBtgCF4r9fOf/zy23nrruO6667Kr7xUcf/zxceSRR8aVV14Z119/fUnbCAAAALQNK1xBvF37dm3q1lKkYXff/va36wSfkvbt28e3vvWteOWVV0rWNgAAAKBtWfEMKFfBy6WuXbvGxx9/3OhrVVVVNTWhaD1GjRoVCxYsKOpnpGGcqYZYsZWXl8fo0aOL/jkAAACsGobgtVJbbbVV/PKXv4wdd9wxC0YVpKvhXXvttdnwPFqXFHwaM2ZMtAarIsgFAABASypCXm+IF/lwyimnxIEHHhi77bZbfPGLX4z+/fvH9OnT449//GMsXLgwLrroolI3EQAAAGgjZEC1UoMHD47bb789xo4dG0888UTMnj07evbsGdttt11WiHz99dcvdRMBAACANmLFM6BaUGHutiYFmdLV8AAAAABa9FXwyK/nn38+/vznP2eP33333RgxYkTst99+cdVVV5W6aQAAAEAbssIBqHbt2repW0tx7733xre//e147LHHsufnnntuFpBKQ/NScfJUiBwAAABgVVjxiEoagteWbi3Eb37zm/jKV74SP/zhD+PDDz+Mp59+Oqv9lGpCpSuM3XXXXaVuIgAAANBGtJyUHpbJv//979h///2zx6kIeXV1dQwfPjx7vvnmm8f777+vRwEAAICWUoRcDCuPevToEfPmzcse/+lPf4pBgwbFOuuskz1/6623onfv3iVuIQAAANBWrHAAKtq1nGFpbcnQoUOz4Xb/+Mc/4tFHH40jjjgim/7www/H5ZdfHsOGDSt1EwEAAIA2QvpSK3XWWWdlWU7pinc77LBDHHPMMdn00aNHZ9lQp5xySqmbCAAAALQRhuC1Un//+9/jiiuuiK5du9aZfsstt2QBKAAAAIAWkwHVrl27NnVrKdLV7x5//PEG0wWfAAAAgJZXA0oR8lzq1KlTdO7cudTNAAAAAFgJAShyKdV8Ouecc+L111+PDTbYIPr169dgnm222aYkbQMAAADalhWvAdWChqW1Jeeee252f/XVVzdYT9XV1dnzVCcKAAAAoNgUIW+lbrjhhlI3AQAAACBjCF4rte2225a6CQAAAAArKQDVboUvpNdmLF68OMaOHRt33HFHfPTRR/H5z38+Gyo3ePDgpb73/vvvj1NPPTUmTJgQa665ZrM+7+WXX47nnnsuqqqqsmF3SbqvrKyMF198McaNG7fC3wkAAABgFQzBUwOquVI9pttuuy1Gjx4dAwYMiEsuuSSOPvroeOCBB7Kr1jXl3XffjfPPP3+Z1svNN98cF154YU3gqbb27dvHsGHDlml50FyjRo2KBQsWrFCHTZs2LUaOHLlCyygvL8/2NQAAAErPELxVZNGiRXH99dfHaaedFjvvvHM2bcyYMbHTTjvFo48+Gvvss0+TWVPpPZtuumk888wzzf68m266KQsyXXrppXHttdfGnDlz4swzz4w//elPccYZZ8SXv/zllfbdoLYUfErbdqmtaAALAACAlaf9ShmC15Zuy+n111+PefPmxdChQ2um9ejRIzbZZJN4/vnnm3zfL3/5y2wI3THHHLNMn/fOO+/Et771rejZs2dsvvnm2ZC7lBGyxx57ZMtSpBwAAABYVQzBW0bDhw9f4uupRlNjpkyZkt2vvvrqdaavttpq8f777zf6nldeeSXLmrrzzjtj6tSpy9TOsrKyLOCUrLPOOjF58uQskJWmb7XVVtlyAQAAAFYFFcRXkfnz52f39Ws9de7cORYuXNhg/lQoPBUdT7cUQFpWG2+8cfzhD3/IHqci52koXypKXjsYBgAAANAyMqDa2FXwmspwWppCNlKqBVV4nKTgU5cuXRrMnwqIp8DToYceulyf993vfjeOP/74mD17dlaIOWVu/fCHP8yG4KUr6qUr8AEAAAC0jCLkroLXLIWhd+nqXmuvvXbN9PR8o402ajD/XXfdlWVLDRkyJHv+ySefZPf77rtvVkD8ggsuWOLn7bbbbln9qH/961/Z8zT/Kaeckl2FL9WEOuecc5q/jgEAAABWgAyoVSQFmbp16xbPPvtsTQDqo48+itdeey0rFl7fI488Uuf5X/7yl+xqeOmKduutt16zPvOLX/xidkt69+6t7hMAAADQQjOgaJaUzZQCTZdeemn06dMn1lhjjbjkkkti4MCBsfvuu2cZTjNmzIju3btnQ/RS3abaCnWbBg0aFH379m12r//pT3+Kp59+Osu0Ovnkk+Pvf/97bLrpptnnAwAAAKwKroK3Cp144onx8ccfx9lnnx0LFiyIbbbZJq677rosOPXOO+9kdZpSvaYDDzxwpRQ9//73v58Fn1Lm1bx58+Koo46KW2+9Ncu6uummm2KDDTZYKd8LAAAAoLgZUG2sCPmK6NChQzaMLt3qW3PNNWPSpElNvne77bZb4uv1XXbZZfG3v/0tfvvb38bWW28dm222WTb9pz/9aRx55JFx+eWXx9ixY5fzmwAAAAA0n+hRK/XQQw9lQ+6GDh0a7dq1q5nev3//OPbYY+PFF18safsAAACAtmMlDMETw8qjVOC8qTpPPXv2jMrKylXeJgAAAKBtWvHoUcquaUu3FiLVd7r//vsbfe3xxx9X/wkAAABYZVwFr5VKw+yOP/74mDVrVuyyyy7ZMLznn38+xo8fH7fddlv87Gc/K3UTAQAAgDbCELxWarfddotLLrkkCzT96U9/yqZdfPHF0bdv3zjvvPNizz33LHUTAQAAgDZCBlQrtt9++2W3f//731kmVI8ePWLdddeN9up2AQAAAC0rA6rl1EVqK1555ZV49913Y+21145NN900CzoBAAAAtNwMqHaugpenK98dc8wx8fLLL0d1dXVW92nLLbeMyy67LFZfffVSNw8AAABoo0SPWpGf//zn8dprr8UJJ5wQ1157bZx++unxn//8J/7nf/6n1E0DAAAA2rAVzoBq36HDymkJK+wPf/hDnHzyyXH44Ydnz7/whS/EgAED4tRTT43KysqoqKjQywAAAMAqJwOqFZk+fXpW86m27bbbLj755JN4//33S9YuAAAAoG1b8RpQrqiWGx9//HF06tSpzrSePXtm9wsXLixRqwAAAIC2bsWvgtfOVfBaglSUHAAAAKAUDMFrIwQKAQAAgJabAWUIXq6cd9550a1btwaZT+lKeF27dq0TkPrd735XkjYCAAAAbcuK14AiN7bZZptGh9s1Nt2QPAAAAKDlBKDUgMqNG2+8sdRNAAAAAGjAEDwAAAAAikoRcgAAAACKSgYUAAAAAEWlBhQAAAAARWUIHgAAAABFZQgeAAAAADkPQLVrt3JaAgAAAECrJAMKAAAAgKJSA2oVWrx4cVxxxRWx0047xRZbbBFHHHFETJ48ucn5//GPf8SIESNiu+22i+233z5OPPHEeO+991ZlkwEAAAByEIBq375t3VbA1VdfHbfddltceOGFcfvtt2fDF48++uhYtGhRg3lnzpwZ3/3ud6Nr165x0003xa9+9ats2lFHHRULFy5coXYAAAAAtKgAVAqitKXb8kpBpuuvvz5OOOGE2HnnnWOjjTaKMWPGxNSpU+PRRx9tMP9jjz0W8+fPj4svvjg22GCD2GyzzeKSSy6Jf/3rX/HnP/95BdcaAAAAwKpjCN4q8vrrr8e8efNi6NChNdN69OgRm2yySTz//PMN5k9D7q666qro3Llzg9dmz55d9PYCAAAArCyKkK8iU6ZMye5XX331OtNXW221eP/99xvMv+aaa2a32q655posILXNNtsUubUAAAAAOQpARbu2lUQ1fPjwJb4+YcKERqen4XRJp06d6kxPAaXmZDTdcMMNccstt8SoUaOib9++y9RmAAAAgJYdgKJZysvLa2pBFR4nqaB4ly5dmnxfdXV1XH755fGLX/wijjnmmPjOd76jxwEAAIC2NgRv+Qtzt0RNZTgtTWHo3bRp02LttdeumZ6ep4Lkjamqqsoynh544IH44Q9/GEceeeRythoAAACgdNSAWkVSkKlbt27x7LPP1gSgPvroo3jttdfiW9/6VqPvSUGndIW8n/3sZ7HPPvusqqYCAAAA5CwA1a5tZUAtr1T7KQWaLr300ujTp0+sscYacckll8TAgQNj9913j08++SRmzJgR3bt3z4bojR8/Pn7/+99nQahtt902pk+fXrOswjwAAAAALUHbqiBeYieeeGIcfPDBcfbZZ8fXv/716NChQ1x33XVZcCpdCW/YsGFZ0ClJw+6Sn/70p9n02rfCPAAAAABtowh5ezGs5koBp9NOOy271bfmmmvGpEmTap5ff/31K7xqAAAAAFrJEDwBKAAAAACaJnoEAAAAQN6vgqcIOQAAAABFDUBJogIAAACgaaJHAAAAAOT8KniKkAMAAACwBGpAAQAAAFBUhuABAAAAkPMMKEPwAAAAAFgCGVAAAAAA5DwDqmOHldMSAAAAAFolGVAAAAAAFJUaUAAAAADkPADVvt3KaQkAAAAArZIheAAAAADkOwMq2olhAQAAANA0Q/AAAAAAKCrpSwAAAAAUlavgAQAAAFBUMqAAAAAAyHsR8nYrpSEAAAAAtE4rYQieABQAAAAATTMEDwAAAICcD8Hr0GGlNAQAAACA1kkGFAAAAAA5z4AKNaAAAAAAaJoMqFVo8eLFccUVV8ROO+0UW2yxRRxxxBExefLkJuefOXNmnHLKKbHNNttkt//5n/+JysrKVdlkAAAAgBwEoNq1sdsKuPrqq+O2226LCy+8MG6//fbsCoJHH310LFq0qNH5TzzxxHj77bfjt7/9bRa4euqpp+L8889fsUYAAAAAtLwAVLu2dVtOKch0/fXXxwknnBA777xzbLTRRjFmzJiYOnVqPProow3mf+mll+K5556L0aNHx6abbhrbb799XHDBBXHvvfdm7wEAAABoKQzBW0Vef/31mDdvXgwdOrRmWo8ePWKTTTaJ559/vsH8L7zwQvTv3z/WW2+9mmnbbrttljX14osvrqpmAwAAAOShCHnbMnz48CW+PmHChEanT5kyJbtfffXV60xfbbXV4v33328wf8pyqj9vp06dolevXo3ODwAAAJBXroK3isyfP78miFRb586dY/bs2Y3OX3/ewvwLFy4sYksBAAAAVi4ZUMuoqQynpSkvL6+pBVV4nKRgUpcuXRqdv7Hi5Gn+ioqK5WoDAAAAQCmoAbWKFIbTTZs2rc709HzgwIEN5k/T6s+bAlKzZs2KAQMGFLm1AAAAADkKQFW3sdvySle969atWzz77LM10z766KN47bXXYuutt24w/zbbbJPVjZo8eXLNtMJ7t9pqqxVoCQAAAMCq1a66unpF4iqxqLIy2pJOKzD8bcyYMXHbbbfFRRddFGussUZccskl8c4778T9998fHTp0iBkzZkT37t2z4XdptXzjG9/Ihtydd955UVlZGWeeeWZst912MXr06JX6nQAAAACKSQBqFQagPvnkk7jsssti/PjxsWDBgizL6Zxzzok111wzC0SlK+yl4NKBBx6Yzf/hhx/G+eefH08++WRWfHzPPfeMUaNGZY9pXcYNHVbqJsQhz0zM7ifd9LuStmPDbx2e3b9xy41Rap/9xmHZfdXcOSVtR1m37v9tx9wSt6Nbdj9/6qdX9SylLgM+HbpcNXtWSdtR1rPXp+2YV9p1k7Wl66frZ9HMGSVtR6fefXKxneRlG6m9neRl3Sz4YHqUWnm//rnYdwr7TVWJf1At++//l1WV80rajk/b0jVX66ZyyntRahUDB2X3C6ZPLWk7yvsPyMWxpPbxJC/7Tqn7pKY/Svw/Y+3/GxfMK+3xpLxr19wd12gFRchXLH+qbUlZTqeddlp2qy8FoSZNmlRnWt++feOKK65YhS0EAAAAyGMAaoUqIwEAAADQ2rkKHgAAAABFZQgeAAAAAEUlAAUAAABAvgNQFd1VlAcAAACgaWpAAQAAAFBUAlAAAAAA5HsIHgAAAEBrcsYZZ8Tdd9+9xHm+8pWvxH333Re33357bL755nVeGz9+fIwaNSomTZqUPb/yyitj7NixjS5no402invvvTdaOwEoAAAAgFrOOuusOOWUU2qeDxs2LM4888zYe++9a6b97Gc/i08++SQLNKWAU6dOnZbYhwMHDow777yzYWCmY9sIzbSNbwkAAADQTN27d89u9af179+/QVDpzTffzLKbTj755CUus0OHDg3e35aoAQUAAACwHNZee+049thj49e//nW88sor+nAJBKAAAAAAltMxxxyT1XFKQ/EWLVqkH5tgCB4AAADQag0fPnyJr0+YMGGFlp9qOI0ePToOOuigrNh47dpRtb333nsxZMiQBtNfeOGFbHheaycA1YKl6OqCBQtK3QxW0JgxY/QhAABAC7bhhhtmQ/Guuuqq2H333RudZ7XVVosbb7yxwfS2EHxKBKBasBR8ErwAAACA4mU4LctQvPRZKVnksMMOazRTavDgwdFWqQEFAAAAsIIKQ/EmT54c1113nf6sRwAKAAAAYCUNxTvuuOPirbfe0p/1CEABAAAArCQjRoyITTfdVH/WowYUAAAAwBJMmjSpwbSLL764yaF448ePrzPthBNOyG5tmQwoAAAAAIpKAAoAAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAiqpddXV1dXE/gmIZOXJkjBkzRgcDAAAAuSYDCgAAAICi6ljcxQPNMemm35W8ozb81uHZ/bihw0rajkOemZjdvzzm0ii1LUeemt1XzplX0nZUdO+a3VfNnlXSdpT17JXdz586JUqty4CB2f2imTNK2o5OvfvkYt3UXj9Vc+eUth3dumf3C6ZPLWk7yvsPyO6r5s6NUivr1i27r5zyXknbUTFwUC7aUbstVZWlPb6WVfz3+FpZWeJ2VHzajjkflbQdWVu69/i0LfNKu++Udf10v1k444Motc59+mX38+eWdnvt0q1r7vqk1H//Cn/7cvP/QIn3m9r7Tm6OrznqE0pPBhQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAC3rKnijRo2KBQsWrOzF0ohp06bpFwAAAKDtBaBS8GnMmDEre7E0YuTIkfoFAAAAyD1D8AAAAABoWRlQAAAAAK3Fxx9/HDfffHPce++98Z///Cc6deoUm2yySYwYMSK23377bJ7DDjssnnvuuTrvKysri9VWWy2GDx8ep5xySpSXlzc6b7t27aKioiLWX3/9bJm77bZbtEYCUAAAAACNWLRoUXz3u9+N999/P0444YQYMmRIVnrorrvuiiOOOCJGjx4dBxxwQDbvXnvtFWeddVbNeysrK2PixInZPJ988kmcc845Na/Vnre6ujrmzZsXv/71r7PPGDduXGy++eatbn0IQAEAAAA04oorrojXX389HnzwwRg4cGDN9BQ8SgGmiy66KHbfffdsWspw6t+/f533Dx48OP76179m768dgGps3nPPPTd+//vfxwMPPCAABQAAANAWVFVVxR133BEHH3xwneBTwUknnRRf+9rXaobWNaVz587Rvv3SS3B37PhpjlAa4tcayYACAAAAWq1Ug2lJJkyY0Oj0t99+O2bNmhVbbrllo6+n+k7ptqTaUWkIXqod9bWvfW2JbZg5c2ZcddVVsXDhwpqMqtZGAIoGRo0alY1pZdUYM2aMrgYAAMiZ2bNnZ/c9e/Zs1vz3339/PPzwwzXP03n1oEGD4sgjj4zvfe97Tc6b6kOlwNMaa6wRP/7xj+Nzn/tctEYCUDSQdhJBEQAAAFqDpjKclqZPnz7ZfcqCao5dd901Tj311Fi8eHH85S9/yYqP77DDDlnwqeN/h9fVnzdJw/O6desWvXv3jtZMAAoAAACgnrXWWiv69esXL730Uuy9994N+ufNN9+MCy64IE4//fTsedeuXbOi48lnPvOZrG5UuoJehw4d4rzzzqvz3trzthVLr4IFAAAA0MakzKRUgHz8+PExderUBq//+te/jpdffjkbOteYoUOHZgGoW2+9NZ544olo6wSgAAAAABqRhs+lTKVDDz007rnnnnjrrbfi1VdfjbPOOivuuuuu+NGPfpQNn2tKulLeOuusE+eee27MmzevTfexABQAAABAI7p06RI33XRTHHTQQfGrX/0q9t9//zj66KNjypQp8bvf/S722WefJfZb586dsyDV+++/3+ZrLasBBQAAANCEioqKOP7447NbU2688cYmX9t2223j9ddfb9a8rZkMKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoqo7FXTzQHBt+6/DcdNQhz0yMPNhy5KmRFxXdu0YelPXsFXnQZcDAyItOvftEHuRl3SRl3bpHHpT3HxB5UNatW+RFxcBBkQd5aUdSVpGT42tFReRBWfcekRdlXfOx73Tu0y/yoku3fGyveeqTvPz9y83/AznZb3J1fM1Rn1B6AlAtWHl5eYwcOXKlL3fatGkrfZkAAABA2yUA1YKNHj26KMstRlCLJXvjlhtL3kWf/cZh2f3LYy7NRebTuKHDIi/ZYFWV83LxC9aiWTNL2o5OvXrnoj9q90nV3Dm5yDZaOOODyMsv4gumT81F5lPle++WtB0Vg9bIxTZSezupmj0rF5kKcya/GaXWffA62f2imTNykTWxqLKytO34bwZWqfujdp9UlbhPCllp86dOibxk/pb671/hb9/ctydHqXVba3Cujmt5+R9pwQfTo9TK+/XPVZ/k6bhG6akBBQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAUM8ZZ5wRhx12WPY43afnSzJt2rQ4+eSTY+utt47tttsuTjnllJgxY4Z+/S8BKAAAAIAVsGjRojjiiCPi7bffjt/85jdxzTXXxGuvvRann366fv2vjoUHAAAAACy7Bx54IN5999149NFHo1+/ftm0M888M84///yYO3dudOvWrc13qwAUAAAAwAp48sknY+jQoTXBp2SnnXaKxx57TL/+lwAUAAAA0GoNHz58ia9PmDBhhT/jzTffzGo/XXXVVXHPPffExx9/HMOGDYvTTjstevToscLLbw0EoGigvLw8Ro4cqWdWkTFjxuhrAACAFiwNs0uBp+233z5+9rOfxezZs2P06NFx3HHHxY033hjt2rWLtk4AigbSTgIAAACtwcrIcFqasrKyqKioyIJP6XHSs2fP+OpXvxqvvvpqfO5zn4u2zlXwAAAAAFbAwIED4zOf+UxN8CnZYIMNsvt33nlH3wpAAQAAAKyYVP/p9ddfjwULFtRMe+ONN7L7wYMH615D8AAAAACWburUqfHEE080mJ6udnfooYfGzTffHKecckqcdNJJMWfOnDjvvPNiu+22i0033VT3CkABAAAALN3TTz+d3er729/+Fn369MkCUKmm8iGHHBKdOnWK3XbbLUaNGqVr/0sRcgAAAIB6Lr744prH6Up2S7POOuvENddcox+boAg5AAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABRVu+rq6uqVucCRI0fGmDFjVuYiAQAAAGjBZEABAAAAUFQdi7t4oDmq5s4peUeVdeue3VfOmVfSdlR075rdV1WWth1JWcWnbRk3dFhJ23HIMxOz+wXTp5a0HeX9B+Rue10444OStqNzn37ZvT7JX58UtpFFM2dEqXXq3Se7r5rzUUnbUda9x6ftmDu3pO3I2tKtW662k1L/zSn8vcnVuslJn5T6OF/nuFZZWdJ2lFVUfNqO2bNK2o6sLT175Wo7ycvxNU/b66ISb6+d/ru95unvMKUnAwoAAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAiqpjcRcPAAAA0PIcdthh8dxzzzX5+sSJE6N///7Z48ceeyxuv/32eO2112L27NnRt2/f2H777WPEiBGx7rrrNmuZ3/72t+Oss86K1koACgAAAKARe+21V5NBoRRkSi644IK4884746ijjoqRI0dGr1694q233orrrrsuDj744Bg3blysv/76S11mly5dWvU6EIACAAAAaER5eXlNllNjHnroobj55pvj6quvjuHDh9dMHzRoUGy77bbxta99La688sq4/PLLm73M1koACgAAAGA53HDDDbHddtvVCT4VtG/fPsaOHRvdu3fXt4qQAwAAACy7jz/+OF5++eXYYYcdmpxnwIABUVFRoXtlQAEAAACtWWPZSbVNmDChydfuv//+ePjhhxtM32WXXeKMM86IxYsXR58+feq8lmpC3X333XWmvfTSS0tc5pAhQ+L666+P1qxFDMEbNWpULFiwoNTNgKIYM2aMngUAAMihXXfdNU499dQG01NWU8+ePaNdu3Yxa9asOq8df/zxcfjhh2ePH3nkkbj00kuXusxUF6q1axEBqBR8cpIOAAAALKslZTgtTdeuXWPw4MFNvr755pvHc889FyNGjKiZljKiCllRhSvlLcsyW6v2pW4AAAAAQEv0ne98JyZOnBhPPvlko6+///77q7xNedUiMqAAAAAASjEia/r06Y2+1qNHj9hnn33ir3/9axx77LHZsLs99tgjy3qaPHlyjBs3Lh566KEYOnToKm93HglAAQAAADQiBZDSrTGXXXZZFoA6/fTTY9iwYXHbbbfF97///Zg5c2b06tUrttxyy/jFL36R1XxCAAoAAACggRtvvLHZvbLjjjtmt5W5zNZGDSgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAAoAAACAohKAAgAAAKCoBKAAAAAAKKqOxV080Bxl3brnpqMquneNPCiryEc7kkOemRh5UN5/QORBnrbXzn36RR7ok/z2SafefSIvyrr3iDwo69Yt8iIv20le/ubkat3kpE/ycpxPyioqIg/KevaKvMjLdpKX42uettdOOdle8/R3mNKTAQUAAABAUcmAghyomjs3N7+6Vs2elYtf9RbNmhml1qlX7+x+wfSpuch8Gjd0WC4ywSrfezdKrWLQGtn9gg+ml7Qd5f365257LXVbCu1YOOODXPwKXTXno8jLL/NVc+fkItuoqrKypO3I2vLfX+bzsg/npR2l3n9r78Pzp04paTu6DBiYi3bUbktetpNS/69W+/+1qnml/R+2rOun/78umjkjF1k+pd5G8rSd1GwjlfNK2o48ZeohAwoAAACAIjMEDwAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAAoAAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAIBaDjvssNh///2b7JNzzjknttlmm9h4441j3rx5dV4bM2ZMbLjhhjF27Ng602fMmBEbbbRR3HvvvfHOO+9k8zR1+/vf/97q1ocAFAAAAEAtBx98cLz++uvxj3/8o0G/LFq0KP73f/83Dj/88Fi8eHG88sordV5/8sknY/XVV48nnniizvQXXnghqqurY4cddqiZduWVV8bEiRMb3DbYYINWtz4EoAAAAABq2WOPPaJ79+5x//33N+iXCRMmxJw5c+Kggw6K/v37x4svvlgny+m1116L733ve/Hqq6/GzJkza157/vnns+ym9J6Cnj17Zs/r3zp27Njq1ocAFAAAAEAt5eXlse+++8YDDzyQZS3VlobQ7bjjjlmW09ChQ+Oll16qeS1lL6UAUgpOVVRUxFNPPVUnA2rHHXdss/0sAAUAAADQyDC8d999t06G04cffpgNsfvqV7+aPU/D6V5++eVsKF4hADVs2LAoKyuL7bbbLps3mTt3bjakL73WVrW+nC4AAACA/xo+fPgS+yINqWvMZpttlhUNT8Pwtt5662xaetyjR4/YddddawJQKbj0xhtvZMPrUsbTWWedlb2Wgk1XXXVV9vjFF1/MglKF5RQcffTR0aFDhwYFzr/yla+0uvXX6gJQo0aNigULFpS6GdBs6QoJAAAA5DMLKl3N7uyzz84CSPfcc08ccMAB2eNk4MCBsc4668Sf//znLAsq1YAqFBnfaaed4vzzz49//vOfWf2nFHzq3LlzneVfeOGFscUWW9SZ1rdv32iNWl0AKgWfnNADAAAAS8pwao799tsvfvrTn2ZXtFtrrbXi73//e/zsZz+rM09hGF7KhNp8882jV69e2fQ0/9prr50Fn1544YXYfffdGyx/wIABMXjw4DaxotSAAgAAAGhECialwNH//u//ZsPvttpqq1hvvfUaBKDSFe+effbZBjWe0vNUpPyvf/1rmy5AnghAAQAAACxhGN4f//jHLAiVHteXio2/9dZbWZ2nxgJQjz76aBbISvWk2jIBKAAAAIAmbL/99tG9e/fsCnh77bVXg9dTUfKNN944qwtVv55TCk5VVVXV1IVqy1pdDSgAAACAlaVdu3bx+OOPL3GeO++8s9Hp3bp1y4bf1bfmmmvGpEmToi2RAQUAAABAUQlAAQAAANC2huCNGjUqFixYUGfatGnTStYeAAAAAFpZACoFn8aMGVNn2siRI0vWHgAAAABWjCF4AAAAABSVABQAAAAARSUABQAAAEBRCUABAAAA0LaKkENbVNatW+RFWc9ekQedevWOvCjvPyDy4JBnJkYeVAxaI/KivF//yIM8ba95aUvnPv0iD8q694i8KOvWPfKgrKIi8iIv+3Be2pGX/TfpMmBg5EFe2pGn7SQv/6slZV3z8T9sp959Ig/yso3kaTspq+ha6iaQIy0qADVq1KjsKnlLMm3atFXWHgAAAABaWQAqBZ/GjBmzxHlGjhy5ytoDK8v8qVNy8wtjqdtSaEdV5bzIyy82VXPn5CJrovK9d3OR+TRu6LDISzbYgg+m5+KXzkUzZ0Refv1dMK+0+05510/3m4UzPshFBtaiysootU7/zTjKy7EkT9trXvpk7tuTS9qObmsNzu6rZs+KvGRN5OVvTq621xL/b1L4vyRXfTJvbi4ysPKybkrdjjptmTs3FyM88tQnlJ4aUAAAAAAUlQAUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABRVx+IuHgAAAKDlOeOMM+Ldd9+NG2+8sWbaY489Frfffnu89tprMXv27Ojbt29sv/32MWLEiFh33XVr5jvssMPiueeea3S53/72t+Oss86qM+3555/Ppv/973+P1koACgAAAGApLrjggrjzzjvjqKOOipEjR0avXr3irbfeiuuuuy4OPvjgGDduXKy//vo18++1114NAk1Jly5dorZnn302jj/++Fi8eHG0ZgJQAAAAAEvw0EMPxc033xxXX311DB8+vGb6oEGDYtttt42vfe1rceWVV8bll19e81p5eXn079+/yWV+/PHHcfHFF8ett94aG264Yfztb39r1etAAAoAAABgCW644YbYbrvt6gSfCtq3bx9jx46N7t27L1MfVlZWxl//+te4/vrrs6F+o0aNatXrQAAKAAAAaLUaCxrVNmHChCW+njKVXn755TjppJOanGfAgAHL3K4ePXrEbbfdlj0eP358tHatLgCVUtzSWExoKcaMGVPqJgAAANCEGTNmZPWZ+vTp06Am1N13311n2ksvvVTz+P7774+HH364zutDhgzJMp7aolYXgBo9enSpmwAAAADkxNIynJYmFRtv165dzJo1q870VDj88MMPzx4/8sgjcemll9Z5fdddd41TTz21QdJMW9XqAlAAAAAAK0unTp1i8803j+eeey5GjBhRMz1lRBWyovr27dvgfV27do3BgwdbEf/VvvAAAAAAgIa+853vxMSJE+PJJ59stHvef/993bYUMqAAAAAAlmCfffbJrlh37LHHZsPu9thjjyzrafLkyTFu3Lh46KGHYujQofpwCQSgAAAAAJbi9NNPj2HDhmVXrvv+978fM2fOzOpDbbnllvGLX/wiq/lE0wSgAAAAAOq5+OKLG/TJjjvumN2W5sYbb1ym/jzwwAOzW2umBhQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFFXH4i4eaI4uAwbmpqPy0payiq6RF2XdukceVAxaI/LgkGcmRl6U9+sfedCpd5/Ii/Ku+dh3OvfpF3nQqaIi8iIvx5I8ba956ZNuaw2OPCjr2SvyIi9/c3K1vebkf5Nc9UnXbpEHeVk3eWlHUtbNuiF/WkQGVHl5eYwcOTKmTZtW6qYAAAAA0BozoEaPHp3dpyAUtEZVs2fl5lfXRTNn5OJXvaq5cyIvv8wvnPFBLjJJFnwwPRfZRqVuR+22jBs6LBfZYPOnTom8ZC8umjWzpO3o1Kt3dr9g3rxcZIJVzZ0befkVuqpyXi5+mc/TPlw1b24usjeq5nxU2nZ075GL/qjdJ3k5lpS6HbXbkpd9uKqysqTt+LQtFbn4H7bw/6t9uJHjWk6214XzSr+9du6an2zotq5FZEABAAAA0HIJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEUlAAUAAABQz6677hobbrhhzW2zzTaLPfbYI37961/XzHPGGWfEJptsEq+++mqD/hs/fnz2vtrzblhreem25ZZbxv777x933HFHq+//jqVuAAAAAEAeHXHEEdktWbBgQfzlL3+Js88+O7p06RLf/OY3s+mffPJJjBo1Kgs4derUaYnLGzJkSFx55ZU1z9My77rrrmyZPXv2jC996UvRWsmAAgAAAGhERUVF9O/fP7uttdZase+++8Z+++2XBY0KBg4cGG+++WaMHTt2qX1YVlZWs7zCMn/wgx/EOuusE/fdd1+rXgcCUAAAAADNlLKfalt77bXj2GOPzYbmvfLKK8vVjx06dFhq9lRLZwgeAAAA0GoNHz58ia9PmDCh2ctKAab7778/y1qq7ZhjjsmWk4bi3X333c0OJs2dOzduueWW+Ne//tVgma1NqwhApRWcxk1CSzRmzJhSNwEAAIBGXHPNNXH99ddnj6uqqrLbFltsEXvvvXed+Tp27BijR4+Ogw46KKvxdMoppzTany+88EJWByqprq6O+fPnR9++fePUU09t1fWfWk0AKgWfnMQDAAAAK5LhVN+hhx4ahx12WPb4448/zmo9pfjDN77xjTp1oJJ0Vbs0FO+qq66K3XffvdHlbbbZZnHppZdmj9u3b5/VmEoBqLagVQSgAAAAAFa2dGW6wYMH1zxfb731smnpCnhPP/10g/lrD8UrBK5qKy8vr7O8tkQRcgAAAIBltHjx4gbTCkPxJk+eHNddd50+rUUACgAAAKARlZWVMX369Ow2bdq0rIbTRRddFKuttlpsv/32jfZZGop33HHHxVtvvaVPazEEDwAAAKARqQB5oQh5qtnUu3fv+PznP5/VcerSpUuTfTZixIh47LHH4m9/+5t+/S8BKAAAAIB6Hn/88aX2ycUXX9zo9DQUb/z48c2at60wBA8AAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAiqpjcRcPNEdZz1656ahOvftEHpR16x550blPv8iD8n79Iw/y0o7kkGcmRh50GTCw1E2o0alX78iD8q5dIw/KunWLvCiryEef5GkfLuuaj/VT1r1H5EFe+iNPx5K8tCNP+3BZRUXkRV7+h7UP53d77dw1P9srpdeiAlDl5eUxcuTIBtOnTZtWkvYAAAAA0MoCUKNHj250emNBKWhJqubNzc2vrlWzZ+Xil7SFMz6IvGQ+Vc2dk4tssEWzZubiV+hFM2eUtB21M/XmT52Si8yncUOHRV6ywaoqK3Pxy/yCefNykYFV6mNa7ePagg+m5yLzKU/7cOV775a0HRWD1sjVcT5P22tejiVVlaU9lnzalq652HcK+03VnI8iLxlHC6ZPLWk7yvsPyNX/A3laNwvnVeYi8ylPfULpqQEFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEUlAAUAAABQz2GHHRYbbrhho7cf//jHNfOdcsop2bTHHnusQR8+++yzDd671VZbZct++eWX68xbf75NNtkktttuuzjmmGPijTfeaHT9/Oc//4khQ4bE+PHjc7/+Opa6AQAAAAB5tNdee8VZZ53VYHqXLl2y+zlz5mSBp8985jNx6623xm677dbocu64445YffXVY/HixTF79uy46aab4sgjj4yHHnooVltttZr5zjzzzNh7772zx2neadOmxYUXXhhHHHFEPPLII1FRUVEzb1VVVZx66qlRWVkZLYEMKAAAAIBGlJeXR//+/RvcunXrlr3+wAMPRPv27eP73/9+PPXUU/H222832o99+vTJ3jdgwID47Gc/G2effXYWYEpBpdq6d+9e8xlp3s033zxOP/30mD59evzf//1fnXmvvPLK6Nq1a4tZbwJQAAAAAMshDX1Lw+RS5lPKirrtttua9b6ysrLs1hwdO346eK1Tp041055//vm4/fbb4yc/+UmLWW+G4AEAAACt1vDhw5f4+oQJE5Zruf/85z/jlVdeiYsvvjgLPu2yyy5ZQOqkk06qEyyqb+HChfGb3/wme7zHHns0OV91dXW89dZbcckll2TZUKnWU/LRRx/FD3/4wyyLKg3rayk6tpaUuJEjR5a6GbBcxowZo+cAAABy6P7774+HH364zrQUCLr++uvjrrvuygJNhbpP++yzTzz44IPZsLp99923znv23XffaNeuXRZUWrBgQXafipenoXa1nXvuufGjH/2opsbTxx9/HJtuummMHTu2ZtjfeeedF1tuuWXst99+0ZK0igDU6NGjS90EAAAAIIeWN8Mp2XXXXbNC3/WTYFJg6L777ouddtopq9uUpMc9evTIipHXD0Bde+21WRZTMm/evHjmmWfisssuywJR6Sp3BSeeeGJ86Utfyh536NAhevfuXafO0z333BMvvPBCFhhraVpFAAoAAABgZUvBn8GDBzeYnq5898EHH8Tjjz8em2yySc30Tz75JAsQpeF566+/fs30QYMGxZprrlnzPL3nX//6VzYUr3YAqm/fvo1+XkHKuvrwww/ji1/8YoPMqeuuuy7LwMorASgAAACAZZACQSk76be//W12FbyCd955J4499tisGHmq0bQ01dXVy9Tvl156aTaEr7aUMZUyp/bee+/IMwEoAAAAgGZKGUhPPPFEHHnkkbHRRhvVee2zn/1sdlW8NFQu1XgqmDFjRnTu3Dl7nIbvTZw4MRvCd+ihhy5TvxeG8dWXMqfWWGONXK9DASgAAACAZrr33nuzzKWvf/3rjb6eAlMjRoyIBx54INZee+1s2le/+tWa18vKyrJgUZrvuOOOazP9LgAFAAAAUM+NN97YaJ8cccQR2a0pO++8c0yaNKnmee3HS9Lc+VbW+1a1/z9QEQAAAACKQAAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoqo7FXTzQHGVdu+Wmo8p69oo86NynX+RFWbfukQedevWOPOjUu0/kRZcBAyMPDnlmYuRFWUVF5EF5166RB3k5piXl/fpHHuRpH64YtEbkQV6O83naXvNyLCmryMexJE/7Tln3HpEX5f0HRB7k5f+BPK2bzl1zsg/nqE8oPRlQAAAAABSVDCjIgUUzZ+TmV72quXNy8Sv0gulTIy+/6i2c8UEussEWzZqZiwysBfPmRV6ya/LSJ1WVlZGXbIVxQ4flIhus1PtwXvbf2vtwXvqk1O2o3ZaqeXNzkYFcOeW9krajYuCgXPRH7T6pqpyXi8ynUrejTlvmlnh77fbfdTN7VknbUTtbr9Tb7P/fXitz8Tc4V9trXtZNifeb2vsOpScDCgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAAoAAACAohKAAgAAAKCoBKAAAAAAKCoBKAAAAACKSgAKAAAAoAn3339/fO1rX4shQ4Zkt4MOOihuu+22mtfPOOOM2HDDDZu8vfzyy9l8V155ZYPXNtlkk9h+++3jxBNPjHfeeadmmY3N+7nPfS722muvuOaaa6K6ujqbL70nvfbss89mz9N9ev7jH/+40e+SXhs/fnyd9zZ1O/LIIxu8f/Hixdn01L5l1dEWBgAAANDQnXfeGRdeeGGceeaZsc0222SBn//7v//LAjwffPBBHH/88dl8KTDVVFCmV69eNY8HDhyYLbOgqqoq/v73v8ePfvSjOPbYY+O+++6Ldu3aNTrvwoUL409/+lPWnk6dOsV3v/vdJlfZjTfeGHvssUdsvfXWS12tqd2p/fWlz6htwYIFcdZZZ8XEiRNjyy23jGUlAAUAAADQiFtuuSUOPvjgOOSQQ2qmrbvuujFlypS44YYbagJQZWVl0b9//6X2YYcOHRrMN2jQoJgzZ06cfvrp8cYbb2TZR03N+81vfjMmTJiQBaqWFIBac801Y9SoUdl8Xbp0WWKbevbsudS2//nPf86CTylg1qNHj1gehuABAAAANBY0ad8+C77Mnj27zvSjjz46br/99pXWZ53+m22Ugk5Lk+apn51U33nnnRfTpk2Ln/3sZyulfU8++WTsvvvucc8990T37t2XaxkCUAAAAACNSIGmNETuC1/4QowYMSKuvfbaeOWVV7IgzGc+85mV0meTJk2Kq6++OjbffPMsu6opaQhcqt/01FNPxZ577rnEZa6zzjrxgx/8IG666aZ4/vnnV7iNJ510Upx88snRrVu35V6GIXgAAABAqzV8+PAlvp6GtDUl1VFKmU6pplKqfZRqMBUCPBdddFF8/vOfz56/8MILjdZRSsPpahcsf++99+rMt2jRoiyos+uuu8Zpp52WZVw1NW9lZWUW+Dr88MOz29KkeR5++OGsftWShuKlIFtjmVeXXXZZ7LLLLrGytMgAVBrHmCJ/0BqMGTOm1E0AAACgCenqc5dccklWgDzVaEpBqFT/KQVuHn300WyezTbbLC699NIG760/VG611VbLglmFq9D99Kc/jYqKiiy7qE+fPk3OmwqTl5eXZ7WaCkXKlyYFs0aPHh0HHHBANhTv7LPPbnS+VNR8iy22aDC9OTWtWn0AKgWfnLQDAAAAS7OkDKclSYXGf/WrX2VD7wYMGJAFflJGU7qlrKq99967ZnhbCg4NHjx4qcvs2LFjzXzp/rrrrssCROkzUqZV7YBV7XmXVxommIbi/eQnP8myuRqTvtuKfk5zqAEFAAAAUE8KBqWgUBq+Vl+hFlK/fv1WqN/69esXP/7xj+O1116LK664oijrIA3FS0P50lC8UmqRGVAAAAAAxZSGxB111FHx85//PObOnZsV/k6Bp3/+859Z0fDtttsutt5667jzzjujqqoqpk+f3uhyunbtmg2za8rOO+8cX/7yl+M3v/lNllW1ySabrNTvkYbipXpVKdOqMekKf421PWV8rWiArTYBKAAAAIBGpOFrqeD4uHHj4uabb85KAq2++upZoOiYY46pme+ll16KYcOGNdqHp5xySjbEbklSdlIqcp7qNN1xxx0rfV2koXgjR47MakLVd8IJJzSZAfbqq6+utDa0q05VtFai9IVWpD5Tc96/op8BebNo5oxSNyE69f604F3V3DklbUdZt+7Z/YLpU6PUyvsPyO4XzvigpO3o3OfTXx0WzZpZ0nZ06tU7u18wb16UWnnXrrnqk6rKyii1sv/+qjZuaOP/+KwqhzwzMRf7cF7239r7cF76pNTtqN2WqnlzS9qOsq6fDp+onPJeSdtRMXBQLvqjdp9UVZb2WF9W0TUX7ajTlrkl3l7/O9ynavaskrYja0vPXrnah0v9d7jwNzhX22te1k2J95va+w6lpwYUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABRVx+IuHmiOTr375Kajyrp1jzwo7z8g8qJzn36RB5169Y48KO/aNfIiL31SVlEReXHIMxMjD/KyD+dl/81Tn+SlHUlZ126RBxUDB0Ue5KU/krKKfBzr89KOpKxbPtZPWc9ekRd52Wbz8nc4V9trXtZNTvYb8kEGFAAAAABFJQMKcmD+1CmlbkJ0GTAwu18wfWoufpmvfO/dKLWKQWtk91Vz5+QiK23hjA9ykUlS6nbUbsuCefNykQ1W6nbUaUtO9uFxQ4flIhMsT9vrnMlvlrQd3Qevk90vmjkj8pL5+9G//1nSdvRYd/3svqpyXi6yJvK0bqpmz8pFls+iWTMjL9m2Cz6YXtJ2lPfrn7vjWlVlZS4yn2b/8x8lbUfP9TfIRX/U7pNSbyf/fxsp/f9IecpMa+tWegCqvLw8Ro4cudzvnzZt2kptDwAAAACtLAA1evToFXr/igSvAAAAAMgfNaAAAAAAKCoBKAAAAACKSgAKAAAAgKISgAIAAACgqASgAAAAACgqASgAAAAAiqpjcRcPAAAA0PKcccYZ8e6778aNN95YM+2xxx6L22+/PV577bWYPXt29O3bN7bffvsYMWJErLvuujXzHXbYYfHcc881utxvf/vbcdZZZ2XLv/vuu2umt2/fPlverrvuGj/84Q+jW7du2fTx48fHqFGj6iyjrKwsBg4cGLvvvnuMHDkyOnXqlE1/+umnY8yYMfHGG29Ez549Y7/99ouTTjqp5vVSEoACAAAAWIoLLrgg7rzzzjjqqKOyoE+vXr3irbfeiuuuuy4OPvjgGDduXKy//vo18++1115ZoKm+Ll261DweMmRIXHnlldnjqqqqbHnnn39+nHnmmXHFFVfUed/EiRNrHqd5X3rppWy+9Pjss8+O119/PQuEpdtll12WLSsFuRYuXJi9Xmq5DUCl6N6CBQsafW3atGmrvD0AAABA2/TQQw/FzTffHFdffXUMHz68ZvqgQYNi2223ja997WtZIOnyyy+vea28vDz69++/xOWWlZXVmSct77jjjovTTjst5s6dW5MFldRfVpr3mWeeifvuuy8LML333ntx4IEHxoknnpi9vtZaa2VBsKeeeiryILcBqBR8SmljjUmRRgAAAIBV4YYbbojtttuuTvCp9tC5sWPHRvfu3VfKZ3Xp0iXatWvXrHk7dOhQM7wuDd1Lt6S6ujpeeeWVePTRR7NhenmQ2wAUAAAAQKl9/PHH8fLLL2e1lJoyYMCAlfJZU6ZMiV//+tex995718l+qm/RokVZvad77703DjrooDqvffLJJ7HVVltliT2bbLJJHH/88ZEHAlAAAABAq9VY1lJtEyZMWOLrM2bMiMWLF0efPn0a1ISqXUQ8SXWZCu6///54+OGH67w+ZMiQuP7662uev/DCC9m0QuAo1WtKtaV+9KMfNWhHYb5k/vz50blz5yxQdfLJJ9eZL7X1pptuipkzZ8ZFF10URx99dNx6661ZplYptYoA1JLqRUHeNTXUFAAAgNJLAaE0JG7WrFl1pqfMosMPPzx7/Mgjj8Sll15a5/U0HO7UU0+tM628vLzO880226zmfSkA9eGHH8Zvf/vbOPTQQ7Oi5uutt17NvPfcc092n9qSgk/9+vXLhuA1Vldq8803zx6nK+Edcsgh8eKLL8Y222wTpdQqAlBLqhcFAAAAtF1Ly3BamlRjKQV0nnvuuewKcwUpI6qQFdW3b98G7+vatWsMHjx4icsuLy+vM8+6664bn/vc52Lo0KHZFfdOP/30mteWtqy//vWvUVlZmRVFL9hggw2y+6lTp0aplTb/CgAAACDnvvOd78TEiRPjySefbPT1999/f6V9Vrt27bJhdKmQ+LJI9aDOOOOMLJOq4C9/+Ut2v/7660eptYoMKAAAAIBi2WeffbIMo2OPPTYbdrfHHntkWU+TJ0/Ohso99NBDWdbSsqqqqorp06fXPE91m6699tqsyPi+++67TMv65je/mWVNnXfeeXHEEUfE22+/nT1Obd1oo42i1ASgAAAAAJYiDYcbNmxY3HbbbfH9738/Cxal+lBbbrll/OIXv8hqPi2rl156KVtmIfMpDdvbeOON45e//GVWH2pZrLPOOvG73/0uLrnkkjjwwAOzZe23334xcuTIXKxbASgAAACAei6++OIGfbLjjjtmt6W58cYbm7X8ixv5jPpSMCndmiPVj2rOZ5eCGlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQdi7t4oDm6DBiYm44q7z8g8qBi0BqRF2XdukcedO7TL/IgL+1Iyrt2jTzISzvytA8f8szEyIM8ba/dB68TedCpd5/Iix7rrh95UFaRj304T+umrGevyINOvXpHXpT36x95kKfjWllFReRBz/U3iDzIS3/kaTvJy/GVfJABBQAAAEBRyYCCHKiaPSs3v3RWzZ1b2nZ06/bfdswpaTtqZz4tmjkjF7+IV835qKTtKOveI7tfVFkZpdbpv78w5mZ7zdE+vHDGB7n4xTUv7Rg3dFjkJRtszuQ3c5GBVTnlvSi1ioGD8rUPl/i4VsiaqKqcV9J21M5WyMs+XOp1U3v9zH17cknb0W2twblYN3XWT0724UWzZuYiU6/U/zPW+b+xxMeTvBxL8pQNhgwoAAAAAIrMEDwAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIqqY7RA5eXlMXLkyJrn06ZNK2l7AAAAAGhlAajRo0fXeV47GAUAAABAvhiCBwAAAEBRCUABAAAALMHcuXNjiy22iB122CEWLVpU57UzzjgjNtxww5rbxhtvHMOGDYtzzjkne19Tzj777Nh1113rTJs1a1b2vi984Qux1VZbxde//vV44YUXWsW6EYACAAAAWIIHH3ww+vbtmwWUHn300QavDxkyJCZOnJjdJkyYEJdeemk8//zzceaZZza6vMceeyzuuOOOBtNPPvnk+Mtf/hKXXXZZ3HnnnbHpppvGkUceGf/6179a/PoRgAIAAABYgrvuuivLatp+++3jtttua/B6WVlZ9O/fP7sNGjQohg4dGscdd1w88sgjDbKgpk2bFv/zP/8T2267bZ3pkydPjqeeeirOPffc2HrrrWPdddeNs846KwYMGBAPPPBAi18/AlAAAAAATUjZRykraccdd4w999wznnvuuWZlJHXp0iXatWtXZ1p1dXU2ZG///fdvEIDq3bt3XHvttbHZZpvVTEvvT++ZPXt2i18/LfIqeAAAAADNMXz48CW+nobMLUkaCldRUZHVZfr444+jU6dOceutt2Y1nJoyZcqU+PWvfx177713dOvWrWb6b3/725g+fXr88pe/jGuuuabOe3r06BE777xznWkPPfRQvPXWW1n2VUvX6gNQo0aNigULFpS6GdCkMWPG6B0AAIAcSgGn+++/P3bZZZcsoylJQaJ77703TjnllJppqVB4qgOVfPLJJ7Fw4cLo1atX/OhHP6pZ1uuvvx5jx46Nm2++OQtiLc2LL76Y1ZBKAbT6xcpbolYfgErBJyf4AAAA0DYtLcNpSf70pz9lGUspk6kgPU6FyFNh8oMPPjiblobNpcLjhQDUhx9+mGU7HXrooTFu3LhYc80149RTT41jjz02Ntpoo6V+bipSnuZPV95LBclbg1YfgAIAAABYHuPHj8/uTzzxxAavpWLkhQBUeXl5DB48uOa1VED8c5/7XFaMPA3h22WXXeIf//hHlgF11VVXZfNUVVVlGVYpc+r888+PL3/5y9n0m266KX784x/H7rvvngW1mpMt1RIIQAEAAADUM2PGjCwD6sADD4zvfve7dV773e9+lwWW/va3vzXZb6mA+OLFi7Mi4p/73OeyK+LVduONN2bT0n3fvn2zabfccks2bO+www7Lht+1b996rh0nAAUAAABQT6rzlDKUjjrqqFhvvfXqvPa9730v7r777qwYeSGbKQ3VK5g5c2Z2RbtFixbFvvvu2yBDKunZs2d07NixZvp//vOfuOiii7LMp2OOOSYbxleQ3t+9e/cWvY4EoAAAAAAaGX63ww47NAg+JWuttVYWKEp1oHbcccd46aWXaq5UlzKfunbtGhtvvHF2tbtUH6o5Hn744SyQlepLpVttX/nKV+Liiy+OlkwACgAAAKCedPW7Jbn88stXqM9OOOGE7FY7qyrdWqvWM5gQAAAAgFwSgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIqqo/6F0ivr2Svyoqxbt8iDsm7dIy869e4TeVDWvUfkQaeKisiL3GyvOdqHO/fpF3mQl3Yc8szEyIvug9eJPKgYOCjyIjf7cE6Oa2UVXSMv8rIP52XdJN3WGhx5kJd1k6d9uFOv3pEHefmfMU/Hkzxtr5ReqwhAlZeXx8iRIxt9bdq0aau8PQAAAAC0sgDU6NGjm3ytqcAU5MmimTNy84tN5ZT3cvHLfNXsWZGXrJaqOR/lIvOpau6cXGSllbodddpSOS8Xvy4u+GB6lFp5v/6ftmX61NK2o/+A7H7O5DdzkW1U6nbUbsu4ocNykQ2Wp+Prolkzc5E1kZf9xvG14fG11P+X1P7fpNT/r+Xlf7XafVLqv3+Fv315OZbk6fial+Pa/KlTotS6DBhY6ibwX2pAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAANKG6ujrGjx8fhx12WAwdOjQ222yz2G233eKCCy6IqVOn1sy34YYbZvM15YwzzsjmqX3bcsstY//994877rij0ff85z//yeZ55513Wvz66VjqBgAAAADk0SeffBLf//73489//nN873vfi3POOSe6du0a//jHP+Lqq6+Ogw46KO65557o169fs5Y3ZMiQuPLKK2ueL1iwIO666644++yzo2fPnvGlL32p5rVJkybFMcccE/Pnz4/WQAYUAAAAQCN+85vfxJNPPpndH3HEEbHBBhvEoEGDYuedd47f/va3UVZWFtdff32z+66srCz69+9fc1trrbXiBz/4Qayzzjpx33331cz3i1/8Ig455JDo06dPq1kvMqAAAAAAGhl6d/PNN8eXv/zl2HTTTRv0T5cuXeKmm27KAkkrqkOHDtGpU6ea5ynodckll2RZUd/+9rdbxboRgAIAAABareHDhy/x9QkTJjQ6PdVdeu+992KHHXZo8r1rrLHGCrVt7ty5ccstt8S//vWvLBOqIE1Lnn322WgtWn0Aqry8PEaOHFnqZkCTxowZo3cAAABy5oMPPsju6w+DS7WgageG0pC8Bx98sFnLfOGFF7I6UIUMq1TfqW/fvnHqqafWqf/UGrX6ANTo0aNL3QQAAACgRJrKcFqa3r17Z/ezZs2qM/3888/PiocnN954Yzz++OPNXuZmm20Wl156afa4ffv2UVFRkQWg2oJWH4ACAAAAWFapQHiq7/Tcc8/FPvvsUzN9wIABNY9TjaZlHaU1ePDgNrkyXAUPAAAAoJHC4KkA+D333BOvv/56o/3z/vvv67dmkgEFAAAA0IijjjoqXnvttfjGN74RI0aMiC9+8YvRrVu3eOONN7Ir4D311FNx0EEH1cyfpj/xxBN1lpGypLbYYos2378CUAAAAACNSHWafv7zn8dDDz0Ud911V9xwww3x0UcfRb9+/WLrrbfOglDbbLNNzfy/+c1vslttW221Vdx6661tvn8FoAAAAACWYK+99spuSzJp0qQlvn7xxRcvcx9vt912S11uS6EGFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUVcfiLh5ojk69++SmoyoGDoo8KOvZK/KirHuPyIOybt0jD/LSjqSsomvkQXm//pEX5f0HRB50H7xO5EFe2pEc8szEyIM8HV879eodeZCX/cbxNb//l+Tp/7U89Ule/v7l5ViSp+NrXo5rXQYMLHUTyBEZUAAAAAAUlQwoyIEFH0zPzS9YlVPey8WvenMmvxl5yZyomju3pO0o69bt03ZUVpa2HRUV2f2imTMiL79Cl3rfKew3ueqT6VNz8Ytrqfuk0B+lPqbVPq5VzZ6Vi1/mxw0dFnnJBpv9z3+UtB09198gV8eSOW/+O0qt+zrrZvez/jGppO3otcGGuTiW1D6e5OX/gVIf52sf60t9jC0cX+dPnZKLLJ9SbyN5/L+x1H/78paZ1tbJgAIAAACgqASgAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAAAoKgEoAAAAAIpKAAoAAACAoupY3MUDAAAAtDy77rprfOUrX4kTTjihwWvjx4+PUaNGNfneU045JUaMGNHofGVlZTFw4MDYfffdY+TIkdGpU6doCwSgAAAAAJbDxIkTG53etWvXJuerqqqKl156Kc4888zs8dlnn90m+l4ACgAAAGA59O/ff7nmGzRoUDzzzDNx3333tZkAlBpQAAAAAKtYhw4d2szwu0QGFAAAANBqDR8+fImvT5gwIValRYsWxdNPPx333ntvHHTQQdFWtLkAVCr+tWDBglI3A2qMGTNGbwAAALRAQ4YMaXT6E088Ed27d290vvnz50fnzp1j7733jpNPPjnaijYXgErBJyf8AAAA0DYUM8PpnnvuaVYR8nv+O1+7du2y4FO/fv2yIXhtSZsLQAEAAACsDIMHD16p87VmipADAAAAUFQyoAAAAAAaMXny5KyeU21pCF3B9OnTG+23dHW7nj176tNaBKAAAAAAGnH//fdnt9oGDBgQP/jBD7LHw4YNa7Tf0vTrrrtOn9YiAAUAAABQz+OPP77EPjnwwAOX2mdpnubM1xaoAQUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARdWxuIsHmqO8X//cdFTFwEGRB90HrxN5UdatW+RBWUVF5EGn3n0iL/Ky7+SqT/oPiDzIS5/k5ZiWlPXsFXlwyDMTIy96rr9B5EFejiXd11k38qLXBhtGHuTlWJKn/wfycpzP0zG2y4CBkQd52Uby9H9jXv72kQ8tPgA1atSoWLBgQbPnnzZtWlHbAwAAAEArC0Cl4NOYMWOaPf/IkSOL2h5YHlXz5pa848q6fvqLTVXlvNK2o6Jrdr9o5ozIy6+uVXPnlLQdZd26Z/cLPpieiwyBUvdH7T4p9b5T2G8q33s3Sq1i0Bq56pOP/v3Pkrajx7rrZ/dVc+fm5hfxRbNmlrQdnXr1zu5n//MfkZfMp3FDh+UiG6zUx7XCMW3hjA+i1Dr36ZeL41rhmFbq/ab2vlPq40nhWFI55b3IS+ZTXv43mT91Si4ysEp9LKnzP1JOttc8/U9P6akBBQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAUM8ZZ5wRhx12WPY43W+11Vbx3nvvNeinK6+8Mnbdddc60yZOnBjf/va34/Of/3xsscUWsd9++8W1114bVVVVbbafBaAAAAAAlmLevHlx9tlnL7Wfnn766fje974Xw4YNi3HjxsX9998fRx55ZFx33XVxzjnntNl+zl0Aqry8PEaOHBnTpk0rdVMAAAAAMmuttVY89dRTcfvtty+xR2677bYs+DRixIhYb731Yu21144DDjggi3Xcfffd8dFHH7XJHs1dAGr06NExZsyYWG211UrdFAAAAIDM1ltvHQcddFD85Cc/aXQoXkG7du1i0qRJMWXKlDrT999//3jwwQejoqKiTfZo7gJQAAAAAHk0atSo6N69e5x11llNzvOd73wnPvzwwxg+fHhWB2rs2LHx7LPPRllZWZYR1bFjx2iL2ua3BgAAANqEFAhakgkTJjR7WSn49KMf/SiOPvrobKjdoYce2mCeIUOGZEPtfve738Wf/vSnLPiUpJFe5557buy2227RFrW5AFShxhTkRRpyCgAAQMvwhS98IRuK99Of/jR22mmnRudJmU4XXHBB9vjNN9/Mrop3ww03xEknnRTjx4+PDTfcMNqaNheASjWmAAAAgLZhWTKclmUoXipInq6Kt9VWW9VMr6yszJIMUoBqo402yqats8462W3ffffNglcpGNUWA1BqQAEAAAAsg8JQvKeffjruu+++OqOu0vM0PK++Ll26ZPWf+vbt2yb7us1lQAEAAACsqJTNdPDBB8edd94Za6yxRjatffv2ceqpp2aZUdXV1VkmVJ8+feKtt96K66+/PgYOHBh77rlnm+x8ASgAAACAFRiKV9tXv/rV6NevX1bzKRUrnzdvXvY8FUNPdaNSllRbJAAFAAAAUM/FF19c8/jGG29stH+6desWf/zjHxtM32WXXbIb/58aUAAAAAAUlQAUAAAAAEUlAAUAAABAUQlAAQAAAFBUAlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVB2Lu3igOcq6dstNR5VVdI086NS7T+RFWbfukQfl/fpHHuSlP/K071QMWiPyIi990mPd9SMPyrrloz+STr16Rx70XH+DyItDnpkYeZCX41rnPv0iL/JyXMvLfpOn40nFwEGRF3n536TLgIGRB3k5luRpe83T//SUngwoAAAAAIpKBhTkQFVlZambEGUVFbloS6Edi3LQJ51q+mReLrLSFnwwPRe/cs59e3KUWre1Bmf3VXM+Kmk7yrr3+LQdc+eUtB21f3WtnPJeLn6Zz8t+U+pj2qdt+fRYsmD61JK2o7z/gFwcS2ofT0q97xT2m3FDh+UiEyxPx9dSt6XQjvlTp0ResmvmvfN2SdvRdc21ctcnVXPn5iLLJy/ba6mP83WO9f7m5C5TDxlQAAAAABSZIXgAAAAAFFWLGYI3atSoWLBgQYPp06ZNK0l7AAAAAGhlAagUfBozZkyD6SNHjixJewAAAABoHkPwAAAAACgqASgAAAAAikoACgAAAICiEoACAAAAoKgEoAAAAADq2XXXXWPDDTesuW222Waxxx57xK9//euaec4444zste9973uN9t+DDz6YvX7YYYfVTKu9zHTbZJNNYrvttotjjjkm3njjjZr5Zs2aFeecc0584QtfiK222iq+/vWvxwsvvNBi11OLuQoeAAAAwKp0xBFHZLdkwYIF8Ze//CXOPvvs6NKlS3zzm9/MppeVlcVTTz0Vc+fOjW7dutV5/+9///to165dg+WeeeaZsffee2ePFy9eHNOmTYsLL7ww+6xHHnkkKioq4uSTT44PP/wwLrvssujTp0/ccsstceSRR8b48eNjvfXWi5ZGBhQAAABAI1IgqH///tltrbXWin333Tf222+/uOuuu2rmSZlR5eXlMWHChDrvTQGpJ598Mj7/+c83WG737t1rljtgwIDYfPPN4/TTT4/p06fH//3f/8XkyZOzoNa5554bW2+9day77rpx1llnZfM+8MADLXJdCUABAAAANFPKfqotZUANHz48HnrooTrTH3vssWyIXQpcNUfHjp8OUuvUqVP07t07rr322iy4VZAyqaqrq2P27NnREglAAQAAADTDK6+8Evfff3987WtfqzN9r732qhmGV3v43T777LPUZVZXV2cZT5dcckmW4TRkyJDo0aNH7LzzzlkwqiAFuN56660YNmxYi1xXakABAAAArVbKTlqS+kPnarvmmmvi+uuvzx5XVVVlty222KKmflPBDjvskA3XS8vaf//9syylNJTuRz/6Ubz++usNlpuG1qXXCsv9+OOPY9NNN42xY8c2qCOVvPjii1ndqPRdUnH0lqjVBqBGjRqVFQiDvBszZkypmwAAAEAjDj300Jor2KUg0Ztvvpmdw33jG9+oUweq9jC8FIBKhcS33HLLLKOpMSeeeGJ86Utfyh536NAhG3LXtWvXRudNQ/lOPfXULPCVCpK3VK02AJWCT07sAQAAoG1bUobT0vTs2TMGDx5c8zxdfS5NS1fAe/rpp+vMm7Kijj322GwYXgpE1c+Sqq1v3751ltuUm266KX784x/H7rvvHpdeemmdIXktjRpQAAAAAMto8eLFdZ4PHTo0y2K6++6744UXXog99thjhfr0lltuyYbppWDXz3/+8xYdfGrVGVAAAAAAK6KysjKmT59eUyw8FQG/6KKLYrXVVovtt98+G2pX+yp2KVMpBYu22Wab6NOnz3J/7n/+85/sc9LyjjnmmPjwww9rXisvL4/u3bu3uBUrAAUAAADQiFSAvFCEvH379lmtps9//vPZcLguXbo0mD8Nuxs3blyzrn63JA8//HBWnPzRRx/NbrV95StfiYsvvjhaGgEoAAAAgHoef/zxpfZJ/UBQyoqaNGnSEueZVO/1xnzve9/Lbq2JGlAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQdi7t4oDnKKipy01F5aUunnLQjKavoGnlQ3q9/5EG3tQZHXpR17xF5UNate+RFxcBBpW5CrvabvBzTkvL+AyIP8nIsydO+c8gzEyMP8nR8zUtbugwYGHnRdc21Ig/y1Cdl3bpFHuRle83LcT5PbcnT3xxKTwYUAAAAAEUlAwpyoKpyXm6yFarmfJSLjJZFM2dEqXXq3Se7r5o7Nxe/Li6aNbOk7ejUq3d2XzV7VpRaWc9en7ZlXonXTddP140+adgnpd6Ha/bfPB1f587JRbbRnDf/HaXWfZ11s/uFMz4oaTs69+mX3c99e3IusjfGDR0WeckGmzP5zZK2o/vgdXLxt6/237/5U6fkIvOp1O2o3Za8/I9U6r/Dhf9LSr3f1N53FkyfmosMrAUfTC9pO7K2yMLKDRlQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAEXVMVq48vLyGDlyZIPp06ZNK0l7AAAAAGhlAajRo0c3Or2xoBQAAAAAq54heAAAAAAUlQAUAAAAQC1nnHFGbLjhhku8jR8/PrsvuPLKK7Pn++23X6N9+fLLL2ev77rrrjXT0uPay9x4441j6623jsMOOyxeeOGFRpdz77331llGSyEABQAAAFDLWWedFRMnTqy5JWeeeWaDafWVlZXFG2+8Ef/+978bvPb73/8+2rVr12D6EUccUbPMP/3pT3HLLbdE165d46ijjoopU6Y0WEZqW0skAAUAAABQS/fu3aN///41t6am1bfaaqvF+uuvH//7v/9bZ3p1dXU2LWU31VdRUVGzzPT+z372s3H++efH/Pnz45FHHsnmmTt3bpx66qlx2mmnxXrrrdci15UAFAAAAMBKsueee8ZDDz1UZ9qLL74Yixcvjm222aZZy+jY8dNrxnXq1Cm7f+edd2L27Nlx5513xm677dYi11WLvwoeAAAAQFOGDx++xM6ZMGHCSu28vffeO8aOHZsNw1t33XWzaQ8++GAWmGrfful5QFOnTo2LLrooy4z6whe+kE3baKON4le/+lX2+LHHHouWqNUHoEaNGhULFiwodTOgSWPGjNE7AAAArUQaIpeG0aUhd8cdd1x88skn2VC6FJRqrHbUNddcE9dff332+OOPP45FixZly/j5z38egwYNitai1QegUvDJCT4AAAC0TSs7w2lZhuGlANRzzz0XnTt3jiFDhjQagDr00EOzq94lKUOqV69eWb2p1qbVB6AAAAAAVqU0DO+KK67IhuGlK9ftvffeTc7bs2fPGDx4cLR2ipADAAAArESf+cxnsrpNKQsqDb/bZ5992nz/CkABAAAArGR77bVXVtupd+/esfHGG7f5/hWAAgAAAFjJ0rC7uXPnyn76LzWgAAAAAJZg0qRJDaYdeOCB2a3ghBNOyG4Fa6+9doP3nVBvnscff3yZ+73+MloKGVAAAAAAFJUAFAAAAABFJQAFAAAAQFEJQAEAAABQVAJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQdi7t4oDnKKrrmpqPKuveIPOjUu0/kRVm3bpEHnXr1jjwo69kr8qKsaz7WjT7J7z6cq+Nrt+6RB93XWTfyonOffpEH3dYaHHlwyDMTIy+6D14n8iAvf/uSLgMGRh7kpR15+h8pL3+H87LfJOX9B0QelPfrX+omkCOtNgOqvLw8Ro4cGdOmTSt1UwAAAADatFabATV69OjsPgWhIO+q5s3NTSZJqdtS047KypK2I2tLRcV/2zIvFxkc86dOycUvrpXvvRulVjFojex+0ayZufhl3vbacHutmj0rF7+GL5zxQeQlyycvx5JZ/5gUpdZrgw1zcTwpHEvmvj05FxlYcya/GXnJ4Bg3dFgussFKvd/U3ncWfDA9F5kkeeqTvOw7i2bOyEXWb6nbUbstVXPn5iI7bsH0qVFqeckGoxVnQAEAAACQDwJQAAAAABSVABQAAAAARSUABQAAAEBRCUABAAAAUFQCUAAAAAAUlQAUAAAAAAJQAAAAALRcHUvdAAAAAIC8+vjjj+Pmm2+Oe++9N/7zn/9Ep06dYpNNNokRI0bE9ttvXzPfJ598ErfffnuMHz8+/vWvf0WHDh1i/fXXj6997WtxwAEHRLt27Wrm3XXXXePdd9+t8zmdO3eO1VdfPfbbb7847rjjon379o3OV9u2224bN954Y7QEAlAAAAAAjVi0aFF897vfjffffz9OOOGEGDJkSCxYsCDuuuuuOOKII2L06NFZcCkFqVLQ6NVXX43jjz8+dtxxxywg9dRTT8VFF10UEyZMiMsvvzwLShWk96dbwUcffRQPPfRQXHnlldGlS5c48sgj484778yWk7z00ktZG+64444sUJWUlZW1mPUmAAUAAADQiCuuuCJef/31ePDBB2PgwIE1088666yorKzMgku77757/OY3v4kXX3wxy34aPHhwzXzrrbdelqV08MEHx3XXXZdlTRVUVFRE//79a56nxyl49dxzz2WflwJQffr0qXm9Z8+e2X2aVvt9LYUi5AAAAAD1VFVVZdlGKXhUO/hUcNJJJ8Wvf/3rKC8vj5tuuim+8pWv1Ak+FWy00Uax//77Z0PlFi9evNR+TkPx0vC71kYGFAAAANBqDR8+fImvp+FxjXn77bdj1qxZseWWWzb6+mqrrZbd/v3vf8fMmTNjq622avIztt9++2w43TvvvBNrr712k8P9fv/732fD9kaNGhWtTasPQKVI5MiRI0vdDGjSmDFj9A4AAEDOzJ49u87Qt6akIFXSu3fvJufp/d/XZsyYUROAuuaaa+L666+vmWf+/Pnxmc98Jhve941vfCNam1YfgEoFwQAAAIC2qakMp6Up1F8qBJia0qtXr+x+zpw5Sw1m9a4VpDr00EPjsMMOywqYP/3001lywp577hnf/OY3ozVqfYMKAQAAAFbQWmutFf369cuuPteYN998M7uKXRo6l4qCp+LhTXn22WezedZcc82aaSmzKtWMSoXKUyDqnHPOiauvvjp+9atftcp1JwAFAAAAUD9g0r59VoA8Xdlu6tSpDfonFSB/+eWXs6DSt7/97azG0z/+8Y8G86Wr6N1zzz3ZsLoOHTo02c8HHHDA/2vvTuC0nPf/j3+iqWlmWqZdizhJKFmyhGzlIFoOiURliWNXhJItWyGFLIeEo2yVQwvlUEgcpUM6OOI4okWb9mmbNP/H+3v+9/275557pgnXdX1n7tfz8bgfM3PP3T3frvtaP9fn8/m6DKiHH37YFixYUO4+DwJQAAAAAAAAKVx22WUuS0nlcgoi/fjjj/avf/3L9Wl69dVX7a677rKcnBy7+OKL7dhjj7Xzzz/fXnjhBfvhhx/cQ9/37t3bjjzySLv00kt3uoyVBZWdne3evzQz5pUl5b4HFAAAAAAAwK9RpUoVGzt2rGsWrtK4pUuXWuXKla1Fixb217/+1Y444gj3OmU2PfLIIy5bavz48a6fU0FBgTVr1sz69+/vMqkqVKiw079Xq1YtNwPeTTfdZM8//7xdcMEF5eaDIwAFAAAAAABQjKysLLvqqqvcoyQKMHXt2tU9dmbGjBklluLpkUxZVGW5NI8SPAAAAAAAAASKABQAAAAAAAACRQAKAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAhUxWDfHkBpZGTneLOgfBlLRlaW+SIjK9t8UKVeffNBVoOG5otKNXLNB6yvKZZJ9Rrmg8o1a5svfNmX1GjW3Hzhy/4kp3ET80HVJnuZL87+eJb5wJftRjJr1zEf+LRMfNl2KuXWNB/4Mg7JyPHjnD6zTr2ohwCPkAEFAAAAAACAQJEBBXhg07KlUQ/Bsuo3cF+3rl7lRbbC5uXLzJeMI5ZJ4eWxbc1q8+UO47a1a7zIwMrflGe+3BGPeiyxcfjz2WwyXzLkot7Xx/bzbMNF1xNv9q8Rbzc+7ddi+5JxbdqaL9lgvqwnW1YuN1+yWrasWulFVlrUy8SX5ZG4TPI3boh0HBk5Vf83jnVrIx2HT1nZIAMKAAAAAAAAAaMEDwAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoAhAAQAAAAAAIFAEoAAAAAAAABAoAlAAAAAAAAAIFAEoAAAAAAAABKpisG8PAAAAAABQ9rRr18527NhhU6ZMsZycnEK/GzBggC1ZssTGjBljPXv2tDlz5hT7PrNmzbI6deq4f/Paa6+lfE379u3t8ccft5EjR7rXzJgxw8obAlAAAAAAAAAp/PTTTzZ06FC7++67S1w+HTp0sEGDBqX8Xa1ateLfH3LIIS7IlKxy5crlfvkTgAIAAAAAAEihcePGNn78eDvllFPs2GOPLXYZZWZmuiynncnIyCjV68ojbwNQ+vD69esX/3nFihWRjgcAAAAAAKSXzp0726effmq33nprylI8lIMA1JAhQwr9nBiMAgAAAAAACFqFChXsnnvusU6dOrk4hb5HOQtAAQAAAAAA/FZq8F2S6dOnl/j7hg0b2g033GB33HGHnXrqqSlL8SZPnmxvvfVWkedPPPFEGz58ePznuXPnuj5QierWrZvy35Y3ZTYANXDgQNuyZUvUwwB+sxEjRrAUAQAAAMBj3bt3d0GiWCleqhnz+vfvX+T5rKysQj+3bNnShg0bVui53Xff3dJBmQ1AKfjEhTsAAAAAAPgtGU6/phQvWXZ2tjVp0qRU/a6blOJ15dFuUQ8AAAAAAADAdyrFu/HGG23ChAmulA5pkgEFAAAAAAAQRSneRx99ZHvssUehKq2VK1em/DfVqlWzypUrl/pv6L1mzpxZ5PkDDzzQcnNzrawiAAUAAAAAAFBKd999tyvFSzR16lT3SEVNyE8//fRSL9+ff/7ZLrnkkiLPP/vss3b00UeX2c+JABQAAAAAAECSGTNmFFuK9+mnn8Z/HjNmTKmW3dChQ3f6mquvvto9yiN6QAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAAASKABQAAAAAAAACRQAKAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgKgb79gBKI6t+A28WVOWatc0HVerVN1+wTAqrlFvTfFGpRq75ICMr23zhy1j8+WyyzBe+7OvZhv095viy3fi0Lzn741nmC1/Wk8w69cwXmbXrmA98WSa+LA/JyKlqPsioXiPqIcAjZEABAAAAAAAgUGRAAR7YsnK5N3eONm/Mi3QcVXL+d8c1f1O040i8+5u/aZMXGRxbVq304q6eX59Nnhfj2LZmtfmS1ZK/cWOk48jIyfFqfd246AeLWk7jJl6sJ76sI4nrSdRjiY0jb/GiSMeR3aix+7p5+TLzJcvHl23Yp2Uyrk1bL7LBNi1bar5kdEb9+cQ+G1+24fyNG8yXzKdNS5dEOo6sBg3d162rV1nUfKlmABlQAAAAAAAACBgleAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAkUACgAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoAhAAQAAAAAAIFAEoAAAAAAAAJIMGDDAevbs6b7XV/1cGqtXr7a2bdva7NmzCz3frl07a968efzRsmVLO+WUU+zpp59Oi2VfMeoBAAAAAAAAlAdLly61yy67zFauXJny9xdddJF7yJYtW+zzzz+3W265xapUqWLnnXeelWdlLgA1cOBA9yGtWLEi6qEAAAAAAAA448ePtwceeMAaNWpU7BLJysqyOnXqxH9u3Lixy5R69dVXy30AqsyV4Cn4NGLECKtbt27UQwEAAAAAAHDeffddu+GGG+zhhx/epSVSpUqVtFiCZS4DCgAAAAAAwDePP/64+7p48eJS/5v58+fb5MmTrW/fvlbeEYACAAAAAADlVvv27Uv8/fTp00Mby5NPPmnPPPOM+z4/P989DjroIDvttNOsvCvzAahYTyigrFJJKQAAAACg/OvevXt8Zr3t27fbwoUL3TVhjx49XB+oSpUqWXlV5gNQsZ5QAAAAAAAAUWY47Uz16tWtSZMm8Z+bNm3qnlMD8o8++shOOOEEK6/KXBNyAAAAAACA8mbHjh1WnpX5DCgAAAAAAICgLV++3GbOnFnk+WOPPdYqVKhQqvfYtGmTrVy50n1fUFBgP/74o917771Wt25dO+qoo6w8IwAFAAAAAACwEyqR0yPZl19+aRUrli688swzz8SbkO+2226Wm5trrVu3tmHDhlmVKlXK9WdAAAoAAAAAACDJ0KFD49+PGTOm1MunUaNGtmDBgiLPz5gxI62XMT2gAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAkUACgAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoAhAAQAAAAAAIFAVWb5A9DLr1DNfVMnJNh9kZPkxDsnIyjIfZNauYz7w67PxYyyVcmuaLzJycswHvqyvOY2bmC98WU98WUd8Gkt2o8bmgyr16psvfNmGfVomZ388y3yQVb+B+cKXz8eXbTgjp6r5IqtBQ/NB5Zq1ox4CPEIGFAAAAAAAAAJFBhTggW1rVntzZ37r6lVe3CXZuOgH8yVzIn/d2kjHkVG9hlfj8Gl9zd+0yYvsuPwN6yMdhxtL1WperSe+7EuiHkfiWDYtW+pF1sSWlcvNl8xfX5bJ5uXLvMgiiXociWPJ35TnRYYr62vR9XVcm7bmSzbYhh8WRjqOqk32cl/z8zZGOo6M7P9lc+YtXmS+ZIP5sn/16TiM6JEBBQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEqswGoDIzM61fv362YsWKqIcCAAAAAACAElS0MmrIkCHuq4JQAAAAAAAA8FeZzYACAAAAAAAISrt27ax58+b27LPPpvz9bbfd5n4/cuRImz17tvv+gAMOsNWrVxd57bZt2+ywww5zr1m8eLF7bsCAAe7nxMfBBx9sXbp0sfHjxxf696+++qp16tTJ/f7kk0+2p556yn755RcrSwhAAQAAAAAApJCRkWHTpk0r8vz27dvt73//u1WoUKFwkGW33dzzyWbOnGkbN24s8vwhhxxis2bNij8mT55sJ554ot1yyy3x99Fzt99+u/Xq1csmTZrkKsFGjRplTzzxRJn6zAhAAQAAAAAApHDUUUfZ559/bj/99FOh5z/++GPLysqyPfbYo8jrUwWspk6d6jKgUgW46tSpE380btzY+vbta3vttZcLNsmLL75oZ5xxhnXr1s323HNP69Chg1144YU2YcKEMvWZEYACAAAAAABIoVWrVtagQYMiQaU333zTBYKSM6D03Jw5cwqV4W3ZssVmzJhhp512WqmX8e67726VKlVy3/fv398uuuiiIq9Zt25dmfrMCEABAAAAAAAUQ0GlxACU+jm98847dvrppxd57eGHH241a9YsVIb37rvvusympk2b7nQZq0xP/Z2+++47O/XUU91zrVu3tr333jv+mvXr19tLL71kbdu2LVOfWZmdBQ8AAAAAAGBn2rdvX+Lvp0+fvtMA1OjRo10ZnkruPvzwQ8vNzXUNx5MpI+qUU05xAavu3bvHy+9OTxGskrlz57o+UFJQUGCbN2+2WrVquawnNRtPlpeXZ1dccYVt3brVbrzxRitLym0AauDAgS7NDfDdiBEjoh4CAAAAAKAYLVu2dBlMCiqp95LK7zp27FhiwEoNw1WGV7lyZdeA/IYbbrClS5emfO9hw4bFG5irr5QCUKmsXLnS/vznP9uiRYtcQExjKkvKbQBKwScu7AEAAAAASG87y3DalTK8Hj16uPcbP358sa9VyVzt2rVdGV52drbtu+++LliUKgCVmZlpTZo02enfV0lenz593Ox7Y8eOtebNm1tZU24DUAAAAAAAAL8HBaDUm0kzz+2sn1OsDO/tt992GVC70nw8FWU89e7d26pXr25PP/10kZn3ygqakAMAAAAAAJRg//33d5lKw4cPL7afU3LAavbs2fbRRx+573+Lm2++2TU+f/DBB61ixYquFC/2KEvIgAIAAAAAANgJBZKeeOKJUmU0qbG4yvCULVWvXr1fvWyXL19uc+bMcd936dKlyO8XLFhgZQUBKAAAAAAAgCQzZswo9HPfvn3do7jXJAaDVIb33nvvFXrtkUceWeg1Q4cO3ekyV/CqLAWZSkIJHgAAAAAAAAJFAAoAAAAAAACBIgAFAAAAAACAQBGAAgAAAAAAQKAIQAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAAASKABQAAAAAAAACVTHYtwdQGpVya3qzoCrXrG0+yGncxHyRUb2G+cCXcfi0vmZkZZkPMqpWM1/4sp74si/xZRySVb+B+SCzTj3zhS/LpEq9+uYDX8YhGVnZ5gPW16LO/niW+aJqk73MBxnZOeaD7EaNzRe+7F99Og4jemU+AJWZmWn9+vUr8vyKFSsiGQ8AAAAAAADKWQBqyJAhKZ9PFZQCfJW/aZM3mST569Z6kb0R9TgKjWVTnhd3ofPzNnpxdzHqcRQaiyfr65aVy82XLIGoP5/4ZxPxfi2+T9vowfqa879lsmXVykjHkVm7jvu6adnSSMeReGfel2US9XoSW0eiHkfiWDYu+sGLTOio15HE9WTz8mVeZMht+GGh+ZL5NK5NWy+ywaJeJrHl4dM2nL9xQ8TjqOrdOT2iRw8oAAAAAAAABIoAFAAAAAAAAAJFAAoAAAAAAACBIgAFAAAAAACAQBGAAgAAAAAAQKAIQAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAgCTt2rWz5s2bxx/777+/HXbYYdazZ0+bO3duode+9tpr1qNHDzv88MPda7p3725Tp04tskxnzZplvXr1statW9tBBx1knTp1sqeeesry8/PjrxkwYID7G8mmTZtmLVq0cL/fsWOHe+7NN9+0zp0728EHH+y+6mdfVYx6AAAAAAAAAD666KKL3EMKCgps7dq1Nnz4cOvTp48LCNWrV8/69etn//jHP+zqq6+2Nm3aWIUKFezvf/+7XX/99fb999/bFVdc4f79Rx99ZJdddpldc801dvvtt1tGRoZ9+umnNmTIEPc6fS3OW2+95d6va9euNnjwYPc3FGzS377qqqusY8eO9q9//ctuueUW2759uwtG+YYAFAAAAAAAQApZWVlWp06d+M9169Z1AaDjjjvOBZkURNLXCRMm2AEHHBB/3eWXX+4CVo899ph16dLFGjZsaC+//LK1bdvWLr300vjr9txzT9uyZYvdcccdNnDgQKtWrVqRMej9r7vuOjv33HNt0KBBLvgko0aNslNPPdUFvmTvvfe2JUuW2COPPOJlAIoSPAAAAAAAgFKqWPF/uTyVKlWyF1980ZXqJQafYlRq99xzz8UDWBUqVLAFCxbYsmXLCr1OAao33njDBbtSBZ+U5aT3UnZTLPgkyppSyV8ijWPRokVF/oYPyIACAAAAAADlVvv27Uv8/fTp00v9XsuXL7d7773XBYuOPfZYV0qnAFIqOTk5hQJEF1xwgfXu3duNRz2gjjjiCPd7fd+0adMi//7tt992mU8tW7a0m266qcjvFdj66aefCj23ePFi93XVqlVWv35980m5DUBlZma6KCHguxEjRkQ9BAAAAABACk8++aQ988wz7nv1Vtq2bZsLFj300EOu/E6qV69eqmV3yCGHuGblf/3rX+3999+32bNnx8v6FMg66aST4q/99ttvXUxDQaoPP/zQ9YA65ZRTCr3fmWee6RqY6zUq7fv666/jY9U4fVNuA1AlNe8CAAAAAADpYVcynJJpNrvYjHS77bab1ahRw6pWrRoP8qgkbs2aNaV+v6ZNm9qdd97pvl+4cKGbFe/555+3a6+91v72t7+52fZE73nDDTe4ZufqGaXyO2VCqZdUjH6npuhXXnmlmxWvQYMGdskll7hgVmyMPqEHFAAAAAAAQArKbmrSpIl7NG7cuFBgRz2gFBSaN29eymW3ceNGV3L38ccf26ZNm+yee+5xWUoxe+21l51//vk2btw423333V0wKubQQw91ASZRyZ9+r1nwlIUVowwsNS7/7LPP7N1333Ule3vssYfrUZUYqPIFASgAAAAAAIBf4eyzz7b33nvPvvrqqyK/GzNmjM2ZM8cFgzIzM23SpEluJrxkVapUcUGjWrVqFWl0LrVr17a7777bBZpGjhwZf15lgI8++qgLRNWrV89lY02bNs31lErV0Dxq5bYEDwAAAAAAIEhnnXWWK/G78MIL7ZprrrFjjjnGtmzZYlOmTLHRo0e7JuLKnJL+/fu7UrqCggLr2rWr1axZ03788UfXt0kNw0899VQrjvpD6d+o59NRRx1lbdq0cVlZgwcPtv322889FOCaPHmy6zHlIwJQAAAAAAAAv4L6Qj322GM2duxYGz9+vD344IMue2mfffZx2UqJjcW7devmspnU80m9mvLy8tzPmhXv/vvvd1lSJRk0aJDLqFJvqIkTJ9oZZ5zhZrtTid7q1atdEGrUqFEuA8pHFcvarHYrVqyIeigAAAAAAKCcmzFjRqlep4DTBRdc4B47c+KJJ7pHSYYOHZry+ezsbHvnnXcKPadAlh5lQcWyNqudglAAAAAAAAAoO2hCDgAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAlWhoKCgwMqQfv362YgRI6IeBgAAAAAAAEqJDCgAAAAAAAAEqmKwbw+gNLatWR35gqqUW9OLscTHsXZNpONwY6mR677mb1gf6Tgyqlbz6rPJ35RnUcvIyvbqs9m8fJlFrUq9+u5r/qZNkY4jIyvLfV33n28jHUf1fZp5ty+Jeiyxcfi0vkY9ltg4Ni76IdJx5DRu4r7mr1trUcuoXsOrY86Wlcstapl16rmveYsXRTqO7EaN3df8vI0WtYzsHPd1ww8LIx1H1SZ7ua/j2rSNdBxnfzzLi2Nf4vFv09IlkY4jq0FDL459icc/RI8MKAAAAAAAAASKABQAAAAAAAACRQAKAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAhUxWDfHgAAAAAAoOzp2bOnzZkzJ+XvevXqZYMGDXLf6zVjx461efPm2erVq6169erWunVr69Onj7Vq1Sr+bwYMGGCvvfZayvdr3769Pf744+77V1991Z577jlbtGiR1a1b18466yy7+OKLbffdd7eyjAAUAAAAAABACh06dIgHmhJVqVLFfR01apQ99NBD1qNHDxs5cqQLGC1btsxeeukl95x+f9RRR8X/3SGHHOJel6xy5cru6+TJk+322293jyOPPNK+/PJLu+2222zbtm121VVXlenPiAAUAAAAAABACpmZmVanTp2Uy+bzzz+34cOH28033+yypWL22GMPF2jasmWLPfjggzZhwoT47zIyMop9P3nxxRftjDPOsG7durmf99xzT/v+++9t3LhxBKAAAAAAAADSzZgxY6xRo0Z23nnnpfz9HXfcsctlc/3797eaNWsWeX7dunVW1pEBBQAAAAAAyi31VyrJ9OnTf9X7zp0714499ljbbbfU87ulCiTtjHpHJVq/fr0r52vbtq2VdWkTgBo4cKBLfwN8M2LEiKiHAAAAAABIQT2Z3nrrrULPqbzumWeesVWrVhUJMqnnU6yZeMwbb7xhDRo0iAet9O8TqW9U8t+QvLw8u+KKK2zr1q124403lvnPJ20CUAo+caEPAAAAAEB6+bUZTtKuXTtXFpfcF0pyc3NtzZo1hX539tln28knnxzvEXXDDTfYjh074r9v2bKlDRs2rNC/SVWmt3LlSvvzn//sZsIbPXq0NW7c2Mq6tAlAAQAAAAAA7Irs7Gxr0qRJseVyn3zySaHnqlev7h6i2fCSZWZmFvt+Md9995316dPHtm/fbmPHjrXmzZuXiw8tdaEiAAAAAAAAitWrVy9buHChm6EulZ9++mmXl96iRYusd+/elpWV5d63vASfhAwoAAAAAACAXXTooYfagAEDbPDgwfbFF19Y586dbY899nCBp0mTJtmECRPsgAMOsBo1apT6PW+++Wbbtm2bPfjgg1axYkVXihdTp06dMv0ZEYACAAAAAAD4FZStpKbiKpVTvycFjHJyclyvp6FDh9ppp53mAkmlsXz5cpszZ477vkuXLkV+v2DBAivLCEABAAAAAAAkGTNmTKmWSatWrez+++/f6euGDh1a4u/r1atX5oNMJaEHFAAAAAAAAAJFAAoAAAAAAACBIgAFAAAAAACAQBGAAgAAAAAAQKAIQAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAAASqQkFBQYGVIf369bMRI0aE9u8AAAAAAADw21S0MmrgwIG2ZcuWUr9+xYoVgY4HAAAAAAAA5SwApeDTrmQ0KQMK8FX+xg1RD8Eycqr+byx5G6MdR3aO+7pl1UqLWmbtOu7r1tWrIh1H5Zq1vVgmseWRvynPopaRle3V+pq/YX2k43BjqVrNi88n/tls2hTxOLLc121rVlvUKuXWdF/z162NdBwZ1Wv8bxwbo91u3Fhycrw4/sWOfVtWLo90HJl16rmvG35YaFGr2mQvL7ad2HYT9bGv0PHPk/U1b/Eii1p2o8Ze7E9i+5J1//k20nFU36eZ+zquTVuL2tkfz/Jqv+bTNozo0QMKAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAlUx2LcHAAAAAAAouwoKCuy1115zj2+//dY2btxo9evXt+OOO87+/Oc/W7169dzrmjdvXujfVapUyb3utNNOs8suu8yqVKkS/127du1syZIlKf/ewIED7YILLij03MSJE+3hhx+2GTNmFHr+0UcftZEjRxZ5jy+//NIqVvQr5OPXaAAAAAAAADzxyy+/2JVXXmmffvqpCyLddtttlp2d7QJRjz/+uHXt2tVef/11q127tnv9zTff7AJOsmnTJps/f77dd999Nm/ePBs9enShoNBFF13kHslycnIK/fzmm2/aoEGDrG7dukVeu2DBAuvSpYvdcMMNhZ73Lfgk/o0IAAAAAADAA88++6x98MEHNm7cOGvRokX8+QYNGtgRRxzhgk3PPPOM3Xjjje75qlWrWp06deKva9Kkie2999521llnuUCVvsZkZWUVem0yZVrdcccdNnXqVNtnn31sw4YNRV7zzTff2Lnnnlvi+/iCHlAAAAAAAAApSu9eeOEF69y5c6HgU4xK6saOHWt9+/Ytcdm1bNnSWrdubVOmTNmlZbx48WJbt26dTZgwwU466aQiv9+8ebP9+OOPLjhVFhCAAgAAAAAASBEAWrp0qR199NHFLpuGDRu6Xk87s++++9q///3vXVrG++23n40aNcr233//lL9XGeCOHTts2rRpdvLJJ9sJJ5zgMrFWrFjh5WdJCR4AAAAAACi32rdvX+Lvp0+fnvL5VatWua81a9Ys9Lx6Qc2ePbtQOd4bb7xR4t+oVq2aK6lL9OSTT7ryvUQq6bvnnnusNBSAipX9PfLII268w4cPt169ermG6YlNz32QNgGozMxM69evX9TDAIoYMWIESwUAAAAAPJObm+u+rl27ttDzgwcPti1btrjvx4wZU2RmulQ2bNhQpLl49+7drWfPnoWeU4Pz0lIDdJXmVa9ePf5cs2bN7Pjjj7d333033gzdF2kTgBoyZEjUQwAAAAAAACErLsNpZxo3buyae8+ZM8dOP/30+PP16tWLf58Y/CnJl19+WaSPlP6tmpT/Fsl/X2OrUaOGLVu2zHxDDygAAAAAAIAku+++uytn0+x1X3/9dcrl89NPP+10uX3xxRc2b94869Sp0++6jB988EGX5aRm6Yl9q9asWeNlY/K0yYACAAAAAADYFX369LGvvvrKevToYZdeeqlr9K1Sum+++cbNgPfhhx+6UrjEUruVK1e67zdt2mTz5893gaIjjzzSzab3ezr11FPtueees7vuusuV8qkH1L333muHHnqoHXvssd590ASgAAAAAAAAUthtt93soYcesqlTp9qrr75qzz//vK1fv95q165thx12mAtCHX744fHXKwCkhyhQ1ahRIzvvvPNcJpUyqn5PKul7+umn3fjOPPNMNxufGq7fdNNNVqFCBe8+TwJQAAAAAAAAJejQoYN7lGTBggWlXoYzStG4PNHVV1/tHsmUWfXSSy9ZWUAPKAAAAAAAAASKABQAAAAAAAACRQAKAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAhUxWDfHkBpZORU9WZBZWTnmA8ya9cxX1SuWdt84MsyycjKNl/4sr5mVK1mvvDl88nIyjIfVMqtab7IqF7DfJCR48d249PxL7NOPfNB1SZ7mS982XZ8Ofb5tL5mN2psvvBlf1J9n2bmg7M/nmW+8GW/5tM2jOiVuQyozMxM69evn61YsSLqoQAAAAAAAKAUKhQUFBRYGaQg1IgRI6IeBvC72JKXF/mSzMz+X9ZE/qY8L7I3tq1dY1GrVCP3f2PZtCnacfz/TJL8dWu9yN7I37gx0nEk3nH1ZX3dmhftOiKVs///epK30YustK2rV3mRuRj1OpK4nmxZudyLu+H5Ee/TEjPkot6fxPYlvnw2UY8jcSy+fDb5GzdEOo7EzKdNS5dEOo6sBg3/N45lSyMdhxtL/QZefD6+fTY+bcPj2rT1Ihssb/Eii5pPWYPprsxlQAEAAAAAAKBsIQAFAAAAAACAQBGAAgAAAAAAQKAIQAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAAASKABQAAAAAAAACVTHYtwcAAAAAAChbevbsaevXr7eJEyem/P1tt91ms2bNsj/96U/22GOPFfs+w4cPt9NPPz3+81dffWXPP/+8zZ4921auXGnZ2dnWqlUru+CCC+yYY46Jv27kyJH26KOPpnzP/fbbr9C4xo0bZ7feeqv17t3bbr75ZvMVASgAAAAAAIAEZ511lt1444327bffWrNmzQotm23bttm0adOsV69eVlBQYPXr17cJEyakXH7VqlWLfz9p0iQXIDrttNPsgQcesIYNG9rq1avd83369LEhQ4a4gFZMce9bsWLhUM7f/vY323vvve3111+36667zjIzM738LCnBAwAAAAAASHDKKadY1apVbfLkyUWWy/Tp023Dhg3WtWtX9/Puu+9uderUSfmoXLmye83ixYtd1tT5559v999/vx122GG2xx57WIsWLWzgwIEuA2rYsGH2yy+/xP9Oce+bm5sbf813331nn332mfXv39+N6c033/T2cyQABQAAAAAAkEBZRB07drQpU6a4LKdEKn9TuZwCSKU1fvx4q1Chgl177bUpf3/FFVe4DCYFnXaFsp+UZXXCCSe4oNZLL73k7edIAAoAAAAAACBFGd6SJUvsn//8Z/y5n3/+2T744APr1q3bLi2vuXPn2iGHHGJVqlRJ+XtlW9WuXXuX3lPZUgqGnXTSSa4sT72m5s+f7/pM+YgeUAAAAAAAoNxq3759ib9XSV0qLVu2dA2/VYan7CLR98o4ateuXfx1S5cudcGlVEGlmTNnuu9XrVrl3i+RyuUGDRpU6LlRo0bF/1Zx76tgljKl9N5qZK6eUrGywbvvvttefvllu/POO8035TIApfrJLVu2RD0MoFRGjBjBkgIAAAAAT7OgNBvdLbfcYhkZGa5MTo3C9X1M3bp1bcyYMUX+7W67/V/RWW5urq1du7bQ748//nj3frJ8+XI3815iD6ji3jdWpvfqq69ajRo17Kijjor/DX2vIJkaqOfk5JhPymUASsEnLuoBAAAAAEBxGU6l0alTJ9c0XNlGjRs3tn//+9/24IMPFnqNyt+aNGlS4vu0bt3aXnnlFTeDXqVKldxz2dnZ7iGpej+V9L6aPe+9996z/Px8a9WqVfz5HTt2uJ5VKs0777zzzCf0gAIAAAAAAEhBGUZ//OMfbdq0aS6z6NBDD7WmTZvu8rLq3r27bd++3R577LGUv1+2bNkuvd+kSZNc8EnvpyyqxEetWrVcGZ5vymUGFAAAAAAAwO9VhqfZ6xSMuuyyy4r8XmVz6sWUipqOqxSucePGNmTIEBswYIAtXLjQBaT23HNPl8k0depUe+GFF9xrGjZsWKoxqfxO/aHUgDxZjx49bOTIka55ujKvfEEACgAAAAAAoBjqq6SG4poBr0OHDimzl9q2bZvy355zzjnxhuAdOnSwfffd155//nm77bbb3L/LzMx0jc5vuukmO/PMM93PO/PFF1/YN998Y8OGDUv5ewWg1MxcWVAEoAAAAAAAAMqAChUq2IwZM1L+7uqrr3aP0mratKkNHjx4p68r6X01m96CBQuK/bc1a9a0zz//3HxDDygAAAAAAAAEigAUAAAAAAAAAkUACgAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoAhAAQAAAAAAIFAEoAAAAAAAABAoAlAAAAAAAAAIVMVg3x5AaWRmZ3uzoDKy/BhLpRq55otKWVnmg4zqNcwHGTk55gtf1tfK2X6sI5KR7cfnU7lmbfOBL+uIZNapZz7I8GSf5tP+xJfPxpdx+PTZZORUNV9kNWhoPsiq38B84cvn48tn49M2fPbHs8wH2Y0aRz0EeKTMBqAyMzOtX79+KX+3YsWK0McDAAAAAACA1CoUFBQUWDmjwNSIESOiHgZQavmb8rzJEsjP2+hF9sa2NastapVya3oxltg4ol5P4uuIR+vr1rxNXmQ+5W9Yb1HLqFrtf2PZuNGLrImo15P4OrJ6lfmSDbZ5+bJIx1GlXn33NX/dWvMlo9OX/euWVSsjHUdm7TpejKPQWFYu9yKTxKf1Ner9SWxfEvU4EscS9ecT35esXeNF5r5P23De4kVeZD6Na9PWouZLNhjoAQUAAAAAAICA0YQcAAAAAAAAgSIABQAAAAAAgEARgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAACAABQAAAAAAgLKrYtQDAAAAAAAA8E27du1syZIl8Z932203y87Otv3339+uvfZaO+yww6xnz542Z86c+GsqVqxoubm5dtRRR1m/fv2sQYMGRd73nXfesVdeecW++uorW7dundWqVcu9/tJLL7U//OEP8dclv3eiXr162aBBg+I/X3/99TZlyhR77LHH7KSTTjIfEYACAAAAAABI4aKLLnIPKSgosLVr19rw4cOtT58+Nm3aNPd8hw4d4sGgrVu32qJFi2zEiBF2zjnn2Pjx461+/frx97vzzjttwoQJ7t8rQFWjRg378ccfbfTo0XbWWWfZuHHjbJ999om/PvG9E1WpUiX+/YYNG1xQa++997aXXnrJ2wAUPaAAAAAAAABSyMrKsjp16rhH3bp1bd9997XBgwfb5s2b7e9//7t7TWZmZvw1jRo1ctlMCigpY0rBqpipU6faCy+84IJT11xzjR1wwAEuQ6pNmzb25JNPWtOmTW3kyJGF/n7ieyc+cnJy4q9R5pP+1pVXXmkffvihC4D5iAAUAAAAAABAKanMTipVqlTsa6pWrWpnnnmmC1Jt27bNPff888/bkUceae3bty8anNltN3v00UdtyJAhu/w5/O1vf3Pvq8wnZUa9/PLLXn6WBKAAAAAAAABKYfny5a6MTplRxx13XImvVbaUMqUWLlxo27dvt3nz5tnRRx9d7Ovr1avn3ndX/Oc//7H58+fbKaec4oJPJ554ogtIxYJePqEHFAAAAAAAKLdSZRwlmj59erG/U2ncM888475XEEmBHZXKPfTQQykbjCeqVq1avEfT6tWrbceOHVazZs1Cr1Ew67XXXiv03GeffRb/fvLkyfbWW28V+v0hhxwSH9Orr77qMrFifZ9OP/10e+ONN1zmVceOHc0n5TIApRpJNfMCygLV/wIAAAAA/NO9e3c3G12sTE5Nw1VeVxoKPIleX6NGDatQoYJrYp7oqquust69e7vvFTQaNmxYkZn4+vfvXyTmEQuITZo0yY499tj4mPS9Al9qRk4AKgS/pmYSAAAAAACUPyVlOO1M9erVrUmTJr/q33755ZeuLE6z02VkZNiBBx5oc+bMsUsvvTT+GmVExbKiatWqVeQ9srOzi/377733nq1atcpmzJjhGprH/PLLLzZ37lxXnpc4o17U6AEFAAAAAADwO8rLy7PXX3/dOnTo4IJPcsEFF9isWbPsgw8+sFR++ukn2xUqv8vNzXV/J/HxxBNPuN/71oy8XJbgAQAAAAAAhGHLli22cuVK931+fr7997//tccff9wKCgqsb9++8dedfvrp9sUXX9jll1/uyu7UOFxZTz/88IONGzfOpk6dam3atCnV3/z5559t5syZdvHFF9t+++1XpPm5ZsVTMOr66693WVg+IAAFAAAAAADwKylwpIdUrlzZ6tev72bIGz58uJvZLtFNN91kbdu2ddlJV155pa1Zs8b1hzr44INd5pJ6PpXGxIkTXYDr3HPPTfl7BaZU6jdlyhTr1q2bF58tASgAAAAAAIAk6q20M2PGjNnl5XbMMce4x29574suusg9inP88cfbggULzCf0gAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAkUACgAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoCoUFBQUBPsnAAAAAAAAkM7IgAIAAAAAAECgCEABAAAAAAAgUASgAAAAAAAAECgCUAAAAAAAAAgUASgAAAAAAAAEigAUAAAAAAAAAkUACgAAAAAAAIEiAAUAAAAAAIBAEYACAAAAAABAoAhAAQAAAAAAIFAEoAAAAAAAABAoAlAAAAAAAAAIFAEoAAAAAAAABIoAFAAAAAAAAAJFAAoAAKS977//3kaOHGl33323vf/++0WWx8aNG23gwIFpv5wAAAB+LQJQQBlxxhln2Lp16wo9V1BQENl4vvzyS7vvvvtsxIgR9sUXX0Q2Dvyfr7/+2nbs2MEiAXbRP//5T7ePnTJlis2cOdMuu+wyu/rqq23btm3x12zZssVef/11li2QoFevXrZ+/XqWCbALUp2rbd261aZOnWrPPfecffjhh94sz88++8xuuukm84GW0auvvhr1MPAbEYACyoh///vftn379kLPtW7d2hYtWhT6WKZPn27dunWzV155xcaMGWPdu3e3iRMnWpTy8vIK/ayg2LRp09xyC8OQIUNs06ZNFiVdQK9Zs6bQc7pgTl426eidd96xa665xq6//nr3vY86depkP/30U9TD8MbcuXPtzTfftAULFgT+tx588EE766yz7K233rK///3vNnz4cHcBoEBUfn6+pSsF4O655x478sgj7dhjj7V7773XBeKioiy0xAu3b7/91p599lmbNGlSoWBhkMiUK2zOnDllahtZu3at/eMf/4jkb+scTtmV7733nruQTlfLly+3r776yubNm2ffffddpPuUqLRo0cJ+/vnn+M8rV660P/3pT3bdddfZk08+aRdffLGdf/75tmHDhkjGp/PGl156ybp06WI9evRwx8UoaT3RsUjHoVtuuSXSseC3q/g7vAeAiESVAfXUU0/ZmWeeabfffrvtvvvu7qLkkUcecQeqsCngojszCxcudAdIHayvuOIK++STT9zvK1SoYG3atHGlNTk5OYGN4/nnn7dLL73UsrKy4s/pBEKBqbp161pU68Odd97pApXZ2dmWrsaPH2+33nqr7bXXXm59VVDjhhtusIsuuij0sZSUQfPDDz+4u581a9Z0P+tkNCiPPvpoqV971VVXWZAUOBg2bJi7KGzbtq1deeWV1qdPH3dxEtuGTznlFHvggQcsIyMjkDEoyKX9WEyHDh3cdqtx3HjjjS7TMyxLly4t9WsbNGgQ6Fgeeught/107tzZdtttN/e9Au0qUwz7wv22225z288bb7xhe++9t7sRcu2117ptumLFijZq1Ch3Q6RGjRqBZsppv16vXj23v33hhRfspJNOcgHMSpUqFcqU074/KO3atXPbRWloOeH//Otf/3LH6qBvTr344ov2t7/9zX1/zjnnuH2KLuS/+eYb91z9+vVdpouOS0FRsPaJJ55wGSMKvOniXce+Ro0axV+zatUq93wYN+uUYapzxeQbp9qGDzvsMOvbt68dfPDBgY7Bl2WSfL6mY2CVKlVcgFLHnsWLF7ubZvfff7/dddddFmYmvQJP+qy0r9f5iM4BtO6GTft9nddrPLohpWWmmyFRnLvh90UACsAu+89//uMOirGLQV0w6kRcJYLVq1cPdYnqjogO1Lo4EV2krl692l0oNWvWzF1Y6m6JygWDPIinCv58+umnkd/ljLJM0xdaNy+//HJ3sRoLoD7zzDORnMQMHjw4frc31Wej7Up0cRlkAEop9R999JFVq1atxOCkxhF0AEoXJMpW1AWaMpBmz55tmzdvtnHjxrltWIEobcMKhuhCIQgKTiuYnXgxqMCt9ie6CFAw4ZJLLrEwnH766TvNCNC6o88m6IvGt99+2wXmTjvtNPfzCSecYP369XP70tIGQH4P2l4VSNFNDwXdfvnlF7ctNWzY0K0nmZmZbj197LHHbNCgQYFnysXuwCtgrL+nTDllLQQVIE2mfZnGsM8++1j79u0tasuWLSvVsS7ogKkvRo8e7YL8ympVUEEBbAU8YkFLfdU+Rc8//PDDgY3j6aeftr/+9a924YUXur/58ssvW9euXd34WrZsGep5gm78aPvVfnT//fd3523KXlQwUAFdHQNUzqkxH3HEEWmxTJIzCXU+G7thqYCYeg7q+BN0AEo3gfT5KNAzf/58FxA8+uijbdasWe4z2nfffS1MWjdUYaEArs7nq1at6p7/y1/+4o5BKAcKAJQJzZs3L1i1alWh5w4++OCCH3/8MfSx7LfffgUrV64s9FyrVq0KFi1aFPpYjjjiiILPP/88/vOJJ55YMGvWrEKvmTt3rntdef98fBhDov3339+tK6V5BEnLIHHd3Lhxo1tWP//8c0HY/vvf/xaceeaZBb179y5YtmxZZJ/Vjh07Cq677rqCP/7xjwV5eXkFUTr++OMLPvroI/f9vHnz3PrwwQcfFHrN+++/X9C2bdvAxnDrrbcW/OlPf3J/f9u2bYV+N2bMGLe+XH311YGvq7F1RMuka9euBbNnzy7xEbSWLVsW/PTTT/GftWy0DJYvX14Qpo4dOxZMnDgx/rP+7/pMxo4dG3/uww8/dPv/IB166KEF33//fZHji7bdvn37up91bAxjPXnjjTcKWrRoUfDvf/+7IEr6HHa2f4+9xgczZ84MfCwnn3yy+3xidI6iZTBjxoz4c5988knBMcccE/g4pk2bFv953bp1Beedd547H/r2229DXV+7dOlSMGnSpELPffHFF+4YFPPYY48VdO/ePS2Wid4/8RxE41qwYEGh12hfo31OkIYMGeL+7zpf69mzZ8HLL79csGbNGve7Aw44IL5MwjB9+vSCPn36uGWjfarOUfTc1q1bQx8LgkUGFFBG6G5z8h3nMO9Ap7r7nkjlGVFk2yidWuUXMfpeWR2J9HNY/UHwf3SXUdlxjRs3dr0MoqJsGt2FjlHGj36OpZeHSaVDurMXK1lV5l4suyRM2n6V2aK+YcoIU+lDVFQGoXVEDjroIKtcubLl5uYWes2ee+4ZaC8z9QZTZo/62SmT5bjjjov/Tuuu9m+JJXpBryMag8p21NxZJV5RUW+fxKwefa9so7AzO1Wyc8ghhxTKFtA6rDKZmCZNmrg+KkHyKVNO+40ZM2a4LBqtL1HS/izs7GefqYxW+7KYVq1auXMTraMx+j65Z+PvbcWKFXbAAQcUOhfS/l77NJUX61ikbJcwqMRcyyGRMqGWLFnitts6deq4Y6JKadNhmeh8WRnPGosyGZX1pV52/fv3j79m7Nixtt9++wU6DpWB/uEPf3D7LmUX6VgXFbXP0FhUjqjMTh1rUD4RgALKCB2slCaceHDQhXXPnj2LHCzD6PkQVfArmS5AVIqhmn4FE1S2pBRrNRHWclHgSSfHqhtPh2Wi0qrECwGtN0qpVolEosMPPzzwsehvqPeWeqYowKAeDz6JqjxRFyJqNKp1V/3LtL3ecccdoY9DgR6l/H/wwQcWJaX3q2dOrNRPpauJjab1OakEK7E84vembUZ/48cffywS/BL1vzjqqKNCa8TavHlz+/Of/+wuDqIMQPlC20xio2v1+FMPHQUmY9TQN8g+f3L88ce7vnraXnXhGAvO6TO6+eabXW+sMCcS0DhUrhK1Qw891GrVqhX1MLyhdTX54lnrSmIwV+cLQc9aqzIuBWtjAX5Rn0oFLM8++2wXcNHFfhi0raqvkG5KxajES+dpsRtBKilOtf8tj8tExzv1A1NJpgLsWhe0Tmi/r5IzlWJr29b5bJC0P1Opm4I/Og5qX6a/HcY5czL9XZ0P6cacev2p96PGk849TMsrAlBAGRF0H5ZdpRNtXcAmnnDpLnDygSLIRqyiGnnV8usgpQtEnVyombF+ViaBGioqaKeGoOmwTFKtJ8ruSBRG75gYncQoq0QBwTA+g9JmD/pAAToFXhRA7dixYyQzSSmrJDGzJArKvtJJtxq/6oJa22ss0K5Aw4ABA1yWlDLqgpYY0IjRRZOaPmt/onGGRX3L9IiSL5m3mjHq3XffdXfHNYOWmoGrF1MiXUQlZjaU90w5UcAt6AyJsqQ0zdnTaca1Cy64wO1TdRNKPQ9jGVjKNlJgo3fv3q7vUhi079SNF81mpqxB3RTTOcF5553nglDq36YxBX2u68sySfx/ap3UjJ56xPodKQPo1FNPDXyfpqCbHvpctA9VFpa+ajIHBcUUHFOGVhjUY08znU6ePNlee+01d4NO59S6WacbUfQ0LT8qqA4v6kEAKFuUdVVampUoaMpy0kWi7qZpNjwdwHSnUXfIlXWji4Wg76r5sEyUyl5aat4bFjUMVrlb7MQqbLpAU5Al8e6zZlQ58MADCwUMY7MZRkGBKJ306c5rWLMm+kSBYmWOnHjiiYWe//LLL23ixInuIiWxfCXs7A6NIfGOebrQtpN8QZ+qBFuCDGpr365G3wr4aF1RtpO2GQUFNdGEymbUQFdNapWlFLRYplyqfdr333/vMuWCDlYqEKcm8Zp9T8tFx7uogj5qsB30MbY0lHFb2gBpkIEObTfK/E0s/VbAUucisQxlHRPV4Dnom0G6mNe2oQkckm82KMNGN/F0PAzjppQaXSvIo21EAR/NpqySVQWg1Ixd+/ggJ9/wcZn4RkEnzcSnbfq9995z52+amVDnuGG3C9CERxqHPi/doFKmnIJl5557rmtcj7KLABSAtDmoRlnbHgYdpI855pjQ+xr5TieTpRV0xl7sbqey9HThqJNfpf+HTSf9ykpLvIDWSacy1mKlI7rI18Xl559/bumcOaF+LjrZjZU6h1Hi/M4777g70QqaanbAqMrwdBe6tNRPLEiatVEzVmk/riyG2HTtyjjSslJ2Urdu3Swdtl9dHGsbVhm+KMtWF/Bt27Y1XymDUdkl6UD7k9JSH6+oqS+SLzc+lO2q7Juo+bRMoqIeZbr5oiCQgkFRBeQUBFMGrMYRaxnwxRdfRDIW/D4IQAFl+E50KnrNV199ZVHTibGao6ovRtR0wNJUv+X9bpYaesb6xygQpYsRpbrrQikKCuZouvAoLtB8pRR73RnXya0oa0HTdQfZ36i4dUVZJYl9W5IzfXTHUeuQMk6CzmBUqaqCCFpXFXBRqUaYDUg1pf2ECRNcI9jEKcCV7RPLXIhdFAVdIjJ+/Hi79dZbXaNrBb3++9//ujv1KhdB6mON1pUwSgNTbb8qHVKJYJhUIqSgk8p3tY6oj4tKaJQJHAVl8uhvayxqJK2MxcRlNmjQIPvXv/4V+DFY2+bQoUMD7wVWlvgSzNaNoJ3d4Jk9e7bdeOON7mZIUFhHit44UK/B5N6hyftTZSMHvZ8rzTmjboxpfVbrDZRd9IACygjd5S3uBFsXcKNHj3ZlAbEgRJA0A5IuGBNPODVzRyzDSBe2aiKoGn8fAlBh0QWAggk6iOqCSHfHE/tNqEeVGh0HmSGgnjm6O6479Loo0AW9glAKJCgopYbPYVE5mwJ/iScTunjT8knXO4vqcdCgQQOXraBtR9uRLh7HjRsX6jhSVd+nei6Mi/qHHnrIBV06d+7s9iH6XuUp6qkWFv0tzQCk/ZZOshUAi5VsaptV5kZYJXhqSqveTzoRF83QpDFEEYDSjFQqvUgMBqrEOfECXzP1Kfso6NmripNY5hTF9qsgUNjbrwI5KiGK7Ud1nNX6m/zZhEHHPD2UPamSZu3ftWwUtNV5ibZvHQPCyC5VdqLOTxKXgYIuGoc+t3STHMxWCVxUwWxlaGv9SDXhhjLUVT6pYL/6eKbDOlKafmUxQWbdal+yffv2Qs/pnDG57DyMIHtpzhl104zgU9lHAAooI1Qrn4rSUNWkV/1T1Mw3jCmgdRKuUghdMCrAoe9VyqOeF7qQ04mxmvmG0TTYF+ppoNp0NWvUBVnsgk0XZjpgqoxHJ1i6sxdUjxL14Dj55JPdQ3Qxoma9CkipJ4ky0nSXS8GoMC4GUgU0NMNZ2FO4+5Q9OG/ePHeiGzuZ0/aik19lcYR5Ie0T9bFRgD3WX0IX0mr0fNddd4Xa8FqZAZomXHfqNeOo9nPNmjWzsGm6cv39GGWTqFxy9erVoZfX6u/q2JMYgFK/ocSLE90A0U0HHy7W9BplfJT37TcvL69QmZJKRBUwXbduXegBKAUWrrnmGjeLlqg3l4KRK1eudNlhaqSswG4Y626qY45uhKmEJx35FMxWf0PdqNQ5Y+KNSZ276jxJ5wba7ylbLh3WEX0myrzVOaMajvskqvbQvpwzIngEoIAySjNm6a6jToaV1aLa6LCyW3SCr5MENQKMXTBqOnedSKiMRSc3OrhGVfoVBZ3Y6a6R7uAlXihpGtnYhVqsoWIYTXJFFyL6W7qjqKbjCgoqEKXMtTACUL7wKXtww4YNhbK/1HRVWT/qtZCuASid/Kv8L0aZesoc1AVs2Jly+ntaH5Q92KNHj0hmoUsOZqjUSj8rKyzsAFRpM+XCKBMpKQClkgxtw0FnMPiy/cambE+kDBc9H8X2qyBcjALJCuLqBpTK4cJoKu0bZSLvymyo6RDMViBS66yCTTo3VDBKNx8UhNE2pPPZqMoDo6DKAQWNVXKo8zFms0Q6IQAFlEHKetIJnrJudNdRmUexBrlh0IVhYrNTTZGqGdh0MqELN6XipxuVvN1///0lXiSpQa6mlQ2a7oJ/+OGHrveVHqqZV/BJF/bK6ki3z8en7EHdZU1uhq+T0HS9Qx8LpifOUKjvlXET5V1PpfirZFblKr5M257OkxZfffXVKZ9XZqkuYBV8CmP/yvZblLbTatWqxX9WcEHbr7IY0zH4JPq/67i7s+1W5wtB9sXyKZgduyGn/7NKnJWZrQkulFGpm0SJ/QjThYK1akKv7HTdvATSBQEooAxmPWkaWzWa1rTtYfb0SRxHYo22gl+q7VdQLOzgRmlmONN01UFTw2YFeZIDH4nlEOrDoBlegqJyBwWc1OxVJ5n6LK688koXLIxqCvkwS6jKQvagTz777LMijUfnz5/vMhpigcx0pjvSWjd0kRTmlM/aZnzcbnyjvksK+msfq5Iv3QhJJyqlSgwuqI+LeqgkbtNhNM0vztFHHx363/Rl21FGnmZqVDBOPbB8GJMvwWy1CFAWloJQWkfCDrz4so7EqCfW4sWLI/v7qZZHlMvHp88GwSEABZQRmoFC2RoLFy50J5TKekrOpIjaQQcdFPrfLO2B+7DDDgt0HOrHoeCSZkWKUfPPRLojGuRdR/WYUgnK7bff7tLuw8yKK456pCg4mRj8UeNe3YlNFFZJYNTZgzJ16tRCgUmVzSh7MHndCDp7QFklyRciKo8I+2TQpxNg9daR2PqpzM733nvP3aXu1KmTHXDAAYGPQZ+JAseJWWHKMlHJSuK2JAo4pBsFSFUCrixP7ee0PYfZ98iH7Vf7eY0jUZ06dYo0K9Z2FFUAqmLF8C8xfNl2tC785S9/caWjmtktsQwunYMtiUEoBeaUKaas+TCbSvuyjsRoXxJl+Z2Wh9bPxOsJZc5p8onkc6Mgm6H7es6IYBCAAsoINbhW+r8CHCr30qM4YRw0U53URBEQGzNmjPlAF6bqjVXSicRbb70VaJBOwRQ1A1YAStlQynxSertKiRJLJMKi3hYq10ykmQHVL0WPdMwelFSzuymTI3n7CvICNowTyV05AVZ5aPJzsWb6iYIqV1HDfpVyqUealr1KIy677DI755xz3H5X49F+VReVQWfa6KI1mXq4RcGn4GBsVi/1FdKkF1FlPfmw/Sog6hNfsrG0zJPXz6i2HQUJFdR49913IwtA+RRs6dWrV8rgi7YdnTslBjuCHIsv+1f9H3V8Sf4cwhZVgNr3c0YEq0JBOjcVAMqQ0pSahXVnQEEWXaAlHjg1E45mKgr7LkWqk5pUdFIa5Kx8OoHSSZ3u6qkpezIFhpRxo3RzBYSCpAO1SvGUIaCHfj7wwANdQEoPBcF8vCsaRvZgLOvJt+zBdPbaa6/9pouH34OCtmocrPVD/WtUnqn1RZmT6psmmrlJ5by+BL2jmkFSp42p9h9B9rKJZT199NFH7mJe23PYs70hNR33S0PrjE+B73Sg7aS0x/qgz9V8Oof1gSY90XlhYu8rZc0rKyyK/lxAmAhAAWX4YBUVpeaWVtAXaz6d1Nx555324osvWps2bVxvg9zcXFeWpwtbfXa9e/cOpQl5qgtD/X2VAvzzn/90fSn0fbrQlOmx7MHkPl3J0qWkSVOll1Y6NBJWYFZ9SY444oh4wEOB5LFjx8bLd7/55hs3i9SuzHAVFPXquu+++9w06z4EB4PO+NEMo2qcrF52+j7dL153Zdr2dAr6qMx9Z+dImvlUN4x0Ey1qKt/kZkj0tL9PnEFSmXvJN1ODCO7rBmHi+qrZYCdOnBhJz87EGws6T0xcHsoQC3qGUaQXSvCAMsKnZMVYUEl14sqCSjyB+vbbb93BKrFJeZB8uti47bbbXAqxlo8yoWJTZSv7aNiwYZGc8OqiWU2Uv/vuOzdjlErR9tlnn9D+vv6uSt/0OSmzROnUibOKKRtM5RtBUu8enzK+1LBe5Zixqal1AvrUU0/Zc88959YZXcgrmy7IHiq6M16SxOUVVgAquf+S+nRNmDDBLZPOnTu7IHxQNC15YnBSwUrt22rXrh1/TnelY2OMmhrEf/rpp4H/ndJknM2ZM8dNJR7kepLYeyvKhr2lzbgNOpit3mTaRhUcVdDUp/3bokWLXNatbsA0atQo1LEpkJx8o0597ZS9GHtu/fr17rmoA1DKUr700ksDzRzUMb+0wgowqNxZ54ex80adM+oz075Ws+TpBlnQPv74Y3fDQZmuKuft0KFDofMS7W9U7ht2cDCq83zdkFKmr4JfOs716dPHLY/YeJo0aeKqHML4bHw4Z0TwCEAB+FV0oNLUueqpowBLjPpzKOBx1113uYN6ut151f9ZD2Xc6KJWzclj/ReCvvOqgKCWvS5M9dD3GzZscLPvKSNLs85oZjydcIVBAQT1LlPASyf9OpkQnfxrWenkWI3T33//fTv++OMDG4fWyVQUjFNJj06ydFITRi8GfSYXX3yxC6povXjkkUfcyZ6+6gJeY1EWnYIwxU09/3v4+uuvi/2dpsfWBduKFSusb9++FjQf+i/FPo9EuvhIbsLq040AX6inTNAzjfpS9qhgm9YLZWEpuBKVV155xd58802bNm2a/fDDDy6Qffrpp0cyEUhsu9DFvD4n7TdiFFQ4//zz7ZJLLgnlYj7V9ql+WdqPJQal0mU7VnlkYgAwVfls7LkgA2GxvmC6SadgxxtvvGF77723y8679tpr3X5WN1x0I0brkM6bgqJZgnXMVRahxhSjXlSa7VTnJSr3VZN/bVPlnc6BdLyPzdoYo2OugpI//fSTW17KhtUxOR3OGRE8AlBAGZI8+05xgs5YUAN0lb6deeaZtsceexT6nU4w1BxWGRyalSfo2ed8kXznVSdUCnyEeedVF0U6mdRJv8oA9bcVeApzCvlEOpnUmNT3KvGkV3c5Yynm//nPf9xU90GfTCioo8bjopMoBQlVTqUMMdEyUo8w3ekLUiwTTr0eFPBQUEV3YlWaqRNAOfjgg90dviADUMUFEnQXVGVnuuuoz0/By6Bphht9DroAiPVf0kWrgoKJ/Zc0nqACUL7OFgW/ev1pfdRxWNkruqGgbVn7krp164b6USnQpIeOwwoYKxilZtPafjQmPcKcWeuaa65xs0V26dLFbbfKflKWnjJNnnjiCfvss8/cvs4X6bKt63xRWZs6D1Mw5Q9/+ENkY9ExTQEn9dtTYEM3FwYPHuwy5seNG+fWXTXE1gQqCgAFRTdNtSxUwpy4Pui4Gzsv0Q083WRNhwCUMq+1f1UWa+LyUBawPhs9evTo4YKGQQegfDpnRLAIQAFlSKrZd8LuxSEKMOkCUReFyXQBr3EqEKITTh3s04EPd151sqk+U2eddVZkQafkQKWCCiWd7Hfr1i3wvlgKaCilW6V4mqlpxIgR7gRGWS8KtugzUbq3Li6ViRSkr776yp2Ax7JtLrroInv44YddwDBGQRZlEIZJF7E66Vcmi05EtR6FdZGmi5LE/kstW7Z0/Zc0htgdWZWqKGAY5WxRyphDNKKaySyZLkj1UNae1lsFfrTuKhjUsWNHN3NjkNkbqSi4oIeyCNXbTwEyBbNVSqOxar0OkjJa9HdVspQc9FJw7txzz3Xbsva5Uc0Gl66U3aJgqdZTHYtVZqzgpNaLsLcplXDpGKNy6lg2obLldDMmNlvihRde6NbjIANQ6m+kIFei5PMyBVLDuAHkw+yR6ieoxuclLQ+tM9p+0+WcEcEjAAWUIckNC6Oii+id9ZDRSacuGlFYkBf1KsPQycvjjz/uMrJ0oD7xxBOLlBGF2esouem3suYSs/iUYaNG7UHS3dV77rknnnmmk2+leevOfKyhsTIJwig3093oxJNLBVh05zex4alKEcIKdsSynlT2oDvAuvMYRtaTb/2XSjs1t7I6fWgQv2DBAksnPvX6E+3DdJGqhzJ9VD6qcjiVpasPoPYxYTfvV4mbso+UlaxtSBe3CrwHHYBSOaAyoIrLuNLz+j0BqPDp+KJSMz20r3/33XddMErHvubNm8cz+MLYr6k3mDJrYxSA0vlQYlarbmCuXLky0HFoe9X2kUjbSGLgWNuQgsxBUhaYgsWJ9DkkTxqgZRRkAErH1eRZ93S+lHz8TezDVN7PGRE8AlBAGeFTyrhKD2K12cXRRXYYBywUnoVPdw91AqP0cQVU9DnoQkjBqLADCzqh04lC4sme7nYm984Kesph9Q1I7I3SqlUrF+RJLLfT92qcGwZfZj3SnWBlMSrrSXcUw8x68q3/0s4CHOqPojJOldkGbWfB/ZgwPisFMHZGPYjSmfax2r/qQl7BQ01AofUkzADUwoULXQBMF7QqZ1XQR32Xwmi0rZKYY445psTXKMig5ZIu50qlmZ036L5pyRTU100qPTSjpDK0tb4oI1jHxCBLV1PdWNFsoskz0+p8oDRtJn4LnW9o2SdmiavHUSL1PUoMwARBy98HCnppYofE5ZG839A+PjloV57PGRE8AlBAGeFT00w1j1RPh5KmtFcNvS9lE+l2xzPWCF2ZJZMmTXLBKN0N1xS/Ks/T73YWQPw9aCYZNV0vqReJZoMLunGuTnqT/78KeCQGPXTRkjjtcNBTPutudCKdEMcCLjrBCpoCLsp6UiNlZcwpOKmT7ihmR/K1/5I+I/W9ePnll13jWgXF/vjHPwb+d0tqEB+2WN+0nUnuBZgulD0Qu5BXhrIyGWNZJWEFnZTRoqBTs2bN3N9VSW+YNxtUNlSaLNuwtnG1AEicUEL7f/WZi2WZJu97g1DamRqj6pGpZaAglG4SavkoOyloLVq0cBlY6kOl451ugOh8JHl/kzjjZRB0vqFtRkG34ui8KVYSXt5pYhqVz8aywYvLIlc/0XQ5Z0TwCEABZYRKRMKYpas0VMOvXjlK90/VfFV1/ToJTrd+D75dROsukXqB6KGpjtWDQan3KhPR3cegqcxNPXRiPX2SKUtAJYMq+0onySfdCi737Nmz0M9Br0uxu90//vijm5UvlbBmR/Kt/9J///tfF3RS4FblGloG2pdpZr6wZj5T8FhBY80QpeWi/mW6YIzRxUAYfcJ8uUvva9BJ+zD1cDnppJNcIFe93MIoeVbpn4JOmi1KDXqVXRRVg2mNQb2GSrohpT5ETZs2DXwsKn9MLuFS2ZeyWxMzXIMO/Pgya2Mi/f/ffvttF7RU+ZvaOWjdUXlXYmlcUJSRp32oAk8Ksms7UdZtrKRYpZx6BN2sXv1L1XtRTa1T9RVUMEblojoGBE03vZQ1OWXKFHec1azFmqVYgRidZ+sR9LmAzj3UXFznizreJAdvlQWrCQZKezPit+CcMX1UKPAprQJAmaDZSzRrhk6AdTGt3jHVqlVzqbPz5s1zByqVNKnBcxiZNj7QHRvd+U48eCvgo2mQE++86qIl6Av6VJ/XzJkz3d/WiYROcJL7DARZFqjSJV2Y6aJZsyNpPVEATBdvOgENuqGkPhsFWRKbfSro1b1793g/Jl3cP/vss4F/NjrxL60g78D6Mo5YyVlpT7KD6gWkLA718dFFh9ZNBX00y44yStSUXRcJutAOgwL4CnhpDC+88ILLLtIFop5TiYJKSjUlti5y02WWUV9cccUVLtNJxzXt27XP140YlReFSfs0/U3dANrZthP0vl77dzV11rYTm6kquURPF7najlL1WiuPfJm1MTnopOOvgk4qw4ti36FApdYTZZPqxpjOHUU3xZR1pFmCVc4aNE2ko9JDra/KAFLwJXZeosxCnZOU9jP8tZR9dvnll7uZIpV9tO+++7pzM/We+vLLL925tPYtOleJTcYRFC17TY6iz0WfSWx5fP755y4IpeOu1pl0OWdE8AhAAfjVfaCUBaW7RcoSiFHdvC6UdGBNl+CTJGaw+HJ3VGWQCoIp8KQAi8qHFDDUSU2Y9PeV6aSTGd3x00n3gQce6E5Aw+hRogvFspTxoUCl7oimWwZhlNS0Xyf+OunVibYyWmK9SFQ6omyosAJQymzSBYimx47tQxWA0kVC7AJfAVVlMGjGIIQf+FFW584uCrXPi7I3V0yQDYxF+3RltqgsXw2Dta4qUKrtSbPjTZgwwfWACnqGUZ8CP6XpARVGg32tp/q/6kJewXQFnYrrQRh0qXVJNm/e7PZ1YWaR63xE52LKyFLzawU6FAjSOhRGRpgCYLpZq4wvHWOSffHFF24mPp1bKmMraEuWLHGldsnLQ9lRqQLLQZ8z6rNREC6Kc0YEjwAUgN+cOaD+AQpC6a6JDlS+laKlk++++85dqCqAoUwJzXSjoJNKeJKn9g2bMrFUWqSLk+Sm0/jfZxcr/VIqfpDZWLtSgqmyliDpAkyp/1lZWRYV9ZRQQOe4445zDZX1NZbNGHYASoFiNV7VGGKSA1AKlKrXjQ8B03TiQ7aej7RvV3m3MvYSS910Q0oZCwqYhjH5ws4CP3PnznXnKwou6/vyLrGXTnHrbVil1jHqNajG14lZg8rOUs/QMPqG+nC8kZNPPtmNQzNmFkc3EFWKrYzXdMQ5Y/lFDygAv20nUrGia0qO6GnWJfVS0Ml1x44dXeAp1Z21sOxKCnuQ2QI+i5V+vfTSS+6CSBcDKgkI+o6n7qrqomNnVfhhXJjos7/00ksLXRDoglUXCql6zAVBZVVqTBvr/aGxKHNOWQNhB9TVpF7lGIm0TiRmlCqwHPR05Shq6NChKReLylRUXqTtSRmmvvRrDIv6+WibVYmiZsxSyYxuNCibU72hwpr5s7ign7Kx9Nkp+KRsIAVv04Fvx1UFKVWuqezOxBJA9U/TTRGV4AV97PPheBPbz5fUCD12Y6S0De1/LR33lPFbUkantp9hw4bZHXfcYWHRPlX7Et2MW79+vZtYIYz+eggHASgAKCfUh+u+++5zPR58uABiFsTi6aRSDVeVgq+sMPV+EKXjp2rY/nsLqwdYaaQKgql8NIzZqmIUtFUDVD2UiaayId19ViahAlC6YNJU3WHMLqaxqNF1ouTGvDopjzqjMV2pP0msIa/KUxSkVDNj9UQUTWeu8i71QQwys6W0gdEwMlvUI00X8E8//bQrlUm8sFepk8pKw5gZsLjgsjIKdRE7ePBg95mlC596/akPlUpHVRK6//77F/qdnlfJ1YMPPuj2sbtSNl8WjzexNhY7y8LS7xX8CZKCfuqtpAzgGJ2DKJsxdg6nflU6XwkjAKUZElWeqNnu9HdjdANG5XfKGgszUIhgEIACgHLCt7ud6VSCUloqmVK2k074Yo2MlYKvHkQqswprljWCg8XTbF1qcqpZ+NS0X+UPusBW0EHZE7rIDpJK/XY2a9j7778f+HTlKGr06NHuYlklzZrUQBdKyppTnxJNuqGLW+33dCEdZM8jn/at//jHP+zmm292/Z/UMD/Rbbfd5ho+a1tS2VWYja8VxFXWk/pUKivtnnvuibTPURS0rir7rH79+iW+TsHMoHuFKSirnkbqF5Yq6K6+ofrMVHIWZAAKOw/IqaWG9mlhU3mmAsRaZy+88EKXCawbq7rhop5YKoXXsVHbtAL9KLsIQAEAEBKVqGi6dKWzt2/fPtJG/crqUV8hpd4rOyE2JTb+R+n++oz0UJaaTn7DmIpaM4Upk1EN0RN7uMSozFYX9bqgRrjUpFfLPdYIV8FjZc2ptEgNe2N9iPr27RvoOBTwSc5aiIrWRU1trzElUxaYyt10kassvqCDt8lZT7qQVtaGZjxNR1o3NQtebF3VI9U+JQyaDXFn+yy1DlBwIV2o2XZssotUFHhJJwroK4itQH/yclFmv4KXKp/U71Ptb1B2EIACACAkugBQ+ZsyA9544w13UqX+C9nZ2aF+Bk899ZQ99NBDLjNAgRbNprZixQq74YYbLAq+T1ygCRZ0R1aPoCmTRH3B1MNNfd30Genvq7mz+qQoG+vEE0906w7CpYkd1JclRj1c1AcxsdxO3yc24g7Cznq3hemrr75yzdlLcu6557oLx6Apg0bB28Ssp+SsrHSiKe1vv/12+/jjj12vH91k0L5EgR4di8IoKY4pTc9BZRWq8XQYY/FBaXqR+TLWMKiPnm7OFReU03mSMuVU0ksAqmwjAAUAQEhUmqOeDuovpNIulXqpX5emKdfJeVgXlgpiDBo0yPWuEWX2qFwlqgCUTsQT+5apAekDDzxQJDDnU+lRkNSUV6Uo6jekflQxKmPSCfgll1wS6fjSldbL5KxFzeiZOKunLhijKF+JinrZ7CyTU/3KEvu5BEWlkSrj0WyRhx56qCuPLE7QJWe+0A0Gzeyph7LBlDmnzJuuXbu6BvHK5lMwKujyxGbNmtns2bNLLC1W5prGlA7Hm6+//jqw9y6rNHnBzj5/rT/qE4WyjQAUAAAh0t09ZQToobIEXSQpIKWLVt2hVtmEfhdkj4MlS5a4LJoYXYDojuKqVavc1OlhOvzww4vM6KZ+WMoiCTqTxFfqgaGm53po5q6ff/7ZcnNz3YV1WDOKoWyX78Qoiy5ImgX3s88+K/HCUU2ew+o7p4wnzS5aUrlsGD2PfKRAqfb7eihwqEwxlT0NHz488Gb1yuhUpq0Cg6nKABWQUd80BdjT5Xij0m7daFBjbX02CqBu2rQp/nv1HFS2T5C0LSRnWUWVdaXtdmcT6Gg5hd0wHr8/AlAAAIREd1R1shmb/UYNp2MNr999910XjFKfFD3UdDMoOoFLPNHT9yp/2Lx5s4VNsx+heAo66QE/6IJR20riRZMmgIjNSph4AelD+U7QAajOnTu7wIFK3lLNTqXS3ocffthl3IQxyQNKpuwRBS81K51mKFTJaM+ePUPpbafJExSIUpPxgw8+2DWYVtbLvHnz3IQPmowj6LH4crzRdqFtQgEVZSIrcKrZcfVcjRo1XLmvsl+7dOkSaPN+ZV3rbybe2NB5gD4HZc9JmBmd6VRymM4IQAEAEBJdqKoXSuL0y5qqXIEp9YLSQ9kuag4OwC8qU9LFeyKVRaqvW6Iw+g6pXMmHJuRqQK6eZcqiVHAhObCgTCQFObSfgx9BJwW0NfGESvLCbEquvoOaBVYPrTOxgEPLli1dryqtP+kSgHjyySddVqAmA0ksYVUWdOyGgz43TXwQZADqyiuv9GqZJ5dHJiP7qXwgAAUAQEhS9XhSeUriSZUuKoNudp0q7T5K3333nZsyXIE4nYyrJCKxZ4yyK5R5AkTJlwwbn7ZdZUk8++yzLgtKJV36PkblvD169HBlVVHO+JmuFNxQ0Gn+/PkueKqgk2YHbNGiRSTjUUBFTcYVtFTfQzXwV7ZPYg+1dDFz5kz3WZS0XSgzqjSZjr+FelF269bNTX4RZNn/ry2PTCXIgBzCQQAKAIA0kyrtXgGfxLT7mOTsjt/b999/7/peqRxx/fr18RPy66+/3gXjVIowcuRIV75x/PHHBzoWoCzwaRY8qVSpkisj7tu3r+tZtm7dOjfbmjI5fAqWpRtNLKHgjoI9Bx54oHtOpd56JAu6J9bcuXPd5AmxMm81/FZppsru0tGyZcts3333LfTckUceWSgg1bx581IFZH4LLX8FKnUDSI3qdSxWj7Dk84AwqDxSQcq3337b7VOOO+44q1+/fujjQPAIQAEAkGZ8asD71FNPWevWrV1JQuLF6imnnBIvRYg1aycABfyvn87OmvVGQRktakoOP8Rmtvv222/dI8qm7MqQa9OmjQ0ePNgFN+68804XIJsyZYqlI00gkJeXV+i5v/zlL4V+3rBhQ7y3XFD0Odxyyy3uRtPEiRNdEFl/U73jVBIZ5vZMkDJ9EIACACBEPmQElPZiI4xMi3/84x9udqSSlotKBNSsHUCw08Oj/PClZFQ0y556P8Ua1WvW1RNOOME2btxYqtkcyxtl/H7wwQfWtGnTYl+jrN8DDjgg8LEo20jlmXpoZj71oFQwSmXvmrVQgSj9LugyWoKU6YMAFAAAETbZzM/PtwceeMCVJIR9kam74irDS3USrGmxBw0a5DKPgrRq1aoiU7irH0XiRclee+3lmhoDAMoeZfuo31OM+g2pPFDlmukYgFIW43333eeywlI1gl+wYIGNGjXK7rnnnlDHpdLZCy64wD10fjB58mR74okn7N5777VPPvkk0L9NkDJ9EIACACDCJptquL1mzRr3CMuSJUtcY+BYWUarVq1cCZwuEBQQU88l3f0MOv1f9DcVXErs9aDmrIk0M6BOjAEAZc+OHTuKZLmqFE/PpyPdZNFMgMouUrmbJtrQMU7nAQr0vP76664Xk0rRo6Bm8YsXL3a9qnR81syWQSNImT4IQAEAEGKTTR/ozqv6SyjLSun3usOpLKzrrrvONYr96quvrHPnzq5MImgqMXjnnXdKnA78rbfesoMOOijwsQAAEIbHH3/c3eh58cUXbcKECfHn69Sp424Q6VgcNs3Kq6ynqVOn2qZNm+yPf/yjaxavAFnQCFKmDwJQAACkGTX7VGq/7rCKSvB69eplCxcutBUrVrhsqLAafmvWHc2g1bJlS9cTJNmsWbPs+eefd2MCAJRNCrZUqVIl/vP27dvdvj0509anSTKCpPL3Pn36uIdmj1Smb25urpt8I3GG2qB99913ru+TGsJr1lnNvqfPoFOnTqFkQSP9EIACACDNqO/G/vvvH/9ZJ5xKf9cdTzUfrVWrVmhjOemkk1w5wmWXXeb6YRx99NHuJFxp/ypFUACqd+/eodyBBQAEMyOfsmoSKdNHs6+FPSOfjxR0is36GiaV/6nflPpwdezY0ZUEtmjRwqJCkDI9VCgIY4obAADgDZW7ffjhh4UCTepFpZKAqAI9ujjR3fDPP/88nop/4IEHumaop512WiRjAgCgvFLms4JO6jWVODlKFNq1a1eq1+ncIDlwibKFABQAAGmmuACU0vCjuAub3PxUU0GrOblmSQIAAED5QAkeAABpRncQk2ckivIObGkpQwoAAABlEwEoAADSjKrvu3btWqjR6ZYtW6xnz55uauxEQae6N2zYMND3BwAAgB8owQMAIM08+uijpX5tOjaEBQAAwO+PABQAAAAAAAAC9X+59wAAIC3Mnz/fNfsuyebNm23UqFGhjQkAAADlGwEoAADSzDnnnGNr164t9Ny5555ry5cvj/+cl5dnw4cPj2B0AAAAKI8IQAEAkIZNyJN9/fXXtm3btkjGAwAAgPKPABQAAAAAAAACRQAKAAAAAAAAgSIABQAAAAAAgEARgAIAIM1UqFDBPQAAAICwVAztLwEAAG+akF955ZWWkZERf27r1q3Wv39/q1y5svs5Pz8/whECAACgvCEABQBAmjnjjDOKPNewYcMiz+21114hjQgAAADlXYWCVHMxAwCAtLN69WqbO3eu1apVy1q3bh31cAAAAFCO0AMKAIA09Pjjj9uRRx5pP/zwg/v5008/tZNPPtmuvfZaO//88+3CCy+0LVu2RD1MAAAAlBMEoAAASDOvvPKK/eUvf7FzzjnHZTvJzTffbFlZWTZlyhR77733LC8vz5588smohwoAAIByggAUAABpZvz48TZgwAC77rrrLCcnx+bPn28LFy60Xr16WdOmTa1evXp2+eWX25tvvhn1UAEAAFBOEIACACDNfPfdd3b00UfHf/7444+tQoUKdvzxx8ef22effWzp0qURjRAAAADlDQEoAADSkAJOMf/85z+tZs2a1qxZs/hzKsGrUqVKRKMDAABAeUMACgCANNO8eXP75JNP3Pfr16+32bNnW9u2bQu9ZurUqbbvvvtGNEIAAACUNxWjHgAAAAjXeeedZ7fddpstWLDAPvvsM9u2bZv17NnT/W7FihU2efJkGz16tN1zzz18NAAAAPhdEIACACDNdOrUybZu3WovvfSS7bbbbvbQQw9Zy5Yt3e+eeuope/nll+2SSy6xLl26RD1UAAAAlBMVCgoKCqIeBAAA8MPy5cutUqVKlpubG/VQAAAAUI4QgAIAAAAAAECgaEIOAAAAAACAQBGAAgAAAAAAQKAIQAEAAAAAACBQBKAAAAAAAAAQKAJQAAAAAAAACBQBKAAAAAAAAASKABQAAAAAAAACRQAKAAAAAAAAFqT/B+8hmhANRh8UAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "means = (\n", + " df.group_by(\"protein_id\").agg(mean_npx=pl.col(\"npx\").mean())\n", + " .sort(\"mean_npx\", descending=True).head(25)[\"protein_id\"].to_list()\n", + ")\n", + "wide_top = imputed.select([\"sample_id\", *means]).drop(\"sample_id\").to_numpy()\n", + "corr = np.corrcoef(wide_top.T)\n", + "\n", + "g = sns.clustermap(\n", + " corr, cmap=\"vlag\", center=0, xticklabels=means, yticklabels=means,\n", + " figsize=(12, 11), linewidths=0.1, cbar_kws={\"label\": \"Pearson r\"},\n", + ")\n", + "g.fig.suptitle(\"Protein-protein NPX correlation (top 25 by mean)\",\n", + " fontsize=14, y=1.02)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f9e27417", + "metadata": {}, + "source": [ + "## 8. Case vs control differential expression\n", + "\n", + "Per-protein Welch t-test of case vs control NPX. The volcano plot shows the\n", + "mean NPX delta on the x axis and `-log10(p)` on the y axis. The three\n", + "manually-injected biomarkers (CRP, IL6, TNF) should sit in the upper-right\n", + "corner (positive delta, small p)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ef50da65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.607626Z", + "iopub.status.busy": "2026-04-23T20:15:20.607542Z", + "iopub.status.idle": "2026-04-23T20:15:20.658192Z", + "shell.execute_reply": "2026-04-23T20:15:20.657694Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (10, 3)
proteindeltaneg_log10_p
strf64f64
"CRP"1.675523109.558062
"IL6"1.25766573.416442
"TNF"0.87871240.838176
"ADIPOQ"0.1592762.149671
"PSA"0.1310941.616747
"IL1B"-0.0989931.216589
"IFNG"0.1051991.17137
"LEP"0.0981481.130072
"AFP"0.0905350.874606
"APOA1"0.0807060.820205
" + ], + "text/plain": [ + "shape: (10, 3)\n", + "┌─────────┬───────────┬─────────────┐\n", + "│ protein ┆ delta ┆ neg_log10_p │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ f64 │\n", + "╞═════════╪═══════════╪═════════════╡\n", + "│ CRP ┆ 1.675523 ┆ 109.558062 │\n", + "│ IL6 ┆ 1.257665 ┆ 73.416442 │\n", + "│ TNF ┆ 0.878712 ┆ 40.838176 │\n", + "│ ADIPOQ ┆ 0.159276 ┆ 2.149671 │\n", + "│ PSA ┆ 0.131094 ┆ 1.616747 │\n", + "│ IL1B ┆ -0.098993 ┆ 1.216589 │\n", + "│ IFNG ┆ 0.105199 ┆ 1.17137 │\n", + "│ LEP ┆ 0.098148 ┆ 1.130072 │\n", + "│ AFP ┆ 0.090535 ┆ 0.874606 │\n", + "│ APOA1 ┆ 0.080706 ┆ 0.820205 │\n", + "└─────────┴───────────┴─────────────┘" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats as sstats\n", + "\n", + "records = []\n", + "for prot in panel.proteins:\n", + " sub = df.filter(pl.col(\"protein_id\") == prot)\n", + " case_vals = sub.filter(pl.col(\"group\") == \"case\")[\"npx\"].to_numpy()\n", + " ctrl_vals = sub.filter(pl.col(\"group\") == \"control\")[\"npx\"].to_numpy()\n", + " if case_vals.size < 3 or ctrl_vals.size < 3:\n", + " continue\n", + " delta = float(case_vals.mean() - ctrl_vals.mean())\n", + " t, p = sstats.ttest_ind(case_vals, ctrl_vals, equal_var=False)\n", + " records.append({\"protein\": prot, \"delta\": delta,\n", + " \"neg_log10_p\": -np.log10(max(float(p), 1e-300))})\n", + "volc = pl.DataFrame(records).sort(\"neg_log10_p\", descending=True)\n", + "volc.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9af521e0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.659218Z", + "iopub.status.busy": "2026-04-23T20:15:20.659156Z", + "iopub.status.idle": "2026-04-23T20:15:20.718058Z", + "shell.execute_reply": "2026-04-23T20:15:20.717666Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9cAAAKsCAYAAADm5U6fAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhS9JREFUeJzt3Qd4FOXaxvEnkFBC7yCIIEgVUBBFsdHsBeQoFlBB7IiKgAWUYgGxYMUGgopKF7seVBQLKsVKUxSQ3iFAIJCw33W/nsm3GxJIMgnJTv6/61qW3Z2dnZ13drP3vC0mFAqFDAAAAAAAZFuh7D8VAAAAAAAQrgEAAAAAyAHUXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQCIOqFQKK83AbmEsmVfAkC0IlwDQC7o3r27nXjiibZ3794Ml7n44ovt0ksvzdT6pk2bZvXr17dVq1ZZkHTr1s1dsmLevHl244035to2IW+sW7fOlevq1atzZH36vDz77LNZeo4+X3qePm/yww8/uNu69jz++ON20kkn2XHHHWfTp093j5199tl27LHH2nXXXWf5xQsvvGBjxoxJva19ofeSFZl5jh4/88wzbefOnYfcn97yaS9Nmza1888/31555RXbv3+/W27JkiXWpEkTt0/TO+EyYsQIt89//fXXLL0nAMhNhGsAyAX/+c9/bPv27TZr1qx0H1+8eLG7aDlkzeTJk23p0qXstoD57rvv7Msvv7T8pHHjxjZx4kR3LX/88YcLgGeddZaNHj3aTj/9dHv00UddIHz55Zetf//+ll889dRTtnv37tTbOpGn95Ib1q5da8OHD8/08vre07Z4l5deesmdjNSJi5EjR7plFLrvuusu++abb+yNN96IeP7MmTPt1VdftT59+rhgDgD5RWxebwAABFGHDh2sTJky9t5771n79u0PeFw1XvHx8a62BkD+VLJkSVdD7dm2bZu71uf2hBNOSL2vZcuWdsopp1h+VrVqVXfJDaVLl3Ynvc4991xr3bp1prYlfL/KySefbH///be9+eab1rt3b4uLi7NrrrnGnaBU6Nb+rVu3rmvZcPfdd7sTG2ohBAD5CTXXAJALihQpYhdeeKGrYdmxY0fEYykpKfbBBx/YOeec4368y7fffmtXXnmltWjRwjU5VY2NaoMORs+56qqr7Pjjj7dTTz3VHnjgAVdb7pkzZ45rUqkf/mo+2bZtW9fM02t26TXZ/Pjjj92PWa1Hyw4YMMB27doVsb36wav3o1oiNQHVj92kpKSDbp/WPX78ePdDWOvWj+OHHnrI9uzZk+FztM7nn3/e7Rs1CVUNoWoEvW2+55577J133nE/sNM2Nz0ctF+GDRvmftgrHFxyySX2xRdfpD6u9/bEE0+47dY+b968uQsAixYtSl1my5Yt1rdvXxdC9B7VPUAnW8KtWbPG1cqpNq9Zs2YuZCxcuDDD7Zo/f77bH5999lnE/X/99VdqGctHH31kF110kSvHVq1aue3YsGHDQd/z5s2b7b777nPlp3LUMaem+ZktM1HTfx1Xul/Hj5a7/PLL7ZdffnGPqxzvvfde9/927dq5chYds4888oh7/9qXOsZF26zlzzjjDPdeVBP6+eefW1b997//Td0fnTp1cq1JwoU3C9dnx+vCoO3RtukxHYsqv/Dm46rhVhN3bbMut956q61cufKA9U6YMMHatGnj9q1qaGXu3LnWtWtXV+4qf31+dMx4tK8aNWrk9l2XLl3cvtQ+VY26x2vK/dxzz6X+P20Tb32uVR4XXHCBe/86nlUms2fPzvJ+1HbUrl3bBg4cmG7z8MzSZ0afMe97LCYmxn3eihcv7o5VHWv6bixWrJirKdfjAJCfEK4BIJfoB7/6XH/yyScR9+tH9MaNG1ObhL/77rvWo0cPq1Klij355JMuNPz000/uB6uCTXq++uor69mzp5UtW9Y1o+zXr58LeQrJopBw7bXXpj6u/pf6ka8f2x9++GHEugYNGmTVq1e3UaNGuXVOnTrVXnzxxdTHFWgUcBQmtB6FK4XmW2655ZCDTz399NPuPaiJqtY9adIkt63p0bpuuukm19xW+0bboMCm52obRa+pQFWpUiXXnFSh4nBRWNR7ULi/4YYb3L6oV6+e9erVKzVUqVnwlClT3ONqtqqQqKB15513pu4rvX81ax8yZIgLNwpKClDeOhSkFHIWLFhg999/vwvrem3td4Xl9KhsjzrqKBeew73//vtWqlQpV3YKxAooCr8KYjrOvv/+exdWMpKYmOi2RU22tZyOnxIlSrj9oG3JTJl5Pv30UxeAFcB0nG/atMkdrwp5Ksebb77ZLafXUDl7dGLH6z+tExF6nl7rxx9/dPtV9+v4VYBVS5HM8j4vxxxzjHtN1bpmdGx6zaq9cK9rfa50DOpY1DHpNR9ftmyZ22c67hUAH374YResr7jiigM+z1qHyl4XhVudENPnVuFR+1AnNfQ+r7766oiTUjoe7rjjDjvvvPPcMaSTcjrh9fXXX7vHvebfXvPr9Gh5nRTR94zKb+jQobZ161a7/fbbXblnRdGiRV0IVr959YXOLu07teipUKFC6n36XnzwwQfdCSrtV/Wx1meifPny2X4dAMg1IQBArunYsWOoW7duEffdfvvtoXPPPdf9PyUlJdS6devQtddeG7HMihUrQo0bNw6NGDHC3Z46dWqoXr16oZUrV7rbl1xyiVt3uE8++SR01llnhdatWxd65513Qj179nTr9+j/LVq0CN1///3uttaldfbt2zdiPdreCy64wP3/zz//dMuMGjUqYpnp06e7+7/88ssM37se1/bs27cv9b6xY8e6+//44w93u2vXru4iWpcee/fddyPW8/zzz7v7tS1y9913h9q0aRM63GbOnOm247PPPku9b//+/aHLL7889NRTT4WSkpJCPXr0CH344YcRz3v11Vfd89avX+9uH3vssRH7U+UyfPjw0Jw5c9ztJ598MtSkSZPQqlWrUpfRutu1axe67bbbMty+Z599NnTccceFEhMTU+9r3759aMCAAe7/L730knt8z549qY9rn+t5eh/pGT9+fKh+/fqhRYsWpd6n559zzjmht99+O9NlpjJu1qxZaMeOHanL6BjVMr/99lu6x7ionM8888yI41ifCX02/vnnn4jXvOaaa9xnyVtW63rmmWcy3F/6DOkSTvtIz9O2yPfff+9u6zq929426pj09OnTJ3TyySdHvNetW7e6z57KOXw9KutwXbp0cZ+95OTk1Pv+/vvvUMOGDV1ZhO+nSZMmRRwfOmaGDh2ael/a96//677w7dTnMdynn37qlpk/f366z0lP+OsMGzbM3f72228jvmO8/ektr8+Lvhd02bt3b2jNmjVu3+tY877z0tL3pp4b/h4BIL+h5hoAcpFqjlQbpRodURNx1Zh5tdaqqVEttppch6tZs6Zrghs+SrFHNViq1Uzbl1sjFqt2UDU9HTt2dLWT+/btsz///NM1F1YNn2oJdV+4tH0f1R/Sq7lSrZmk3T71OS1cuHC625d2udjY2Iht9Jq+pqXX0jpVGxdOzXblUK8VXquXnJzs65IebbP6gaoZr0fNUt9++21X26euABqdWduvZssqd9UaqmuAePtdzf5VFnqOmviqplo1l14fXjXLbdiwoStHb3sKFSrkmqKrBjkjqtVVuXmvpxq+f/75x90vavKvY0dlqRpT1WSrO4Fq3jNqXqv3XKNGDWvQoEFELaWamasWMStlpv6yXjcI0fuT8EG30lOnTh33/j16TX02jjzyyANeU58l9ds9FO8zpCbo4VR77ZdaA6iMVfvslZ/et8o3bfmFN9PWflBTb9WCq0WA91y9T+0DdQMJp33g0bGnmtys1Dir9le15Dr+1FJGx6JX85/2OyKzVJteq1atQzYPVysZ1fLroqbgarmg1gOqRfda34RTjb+ORR2nasqvGnYAyI8Y0AwAcpGCjEYTVh9rNaVVs12FPy/weAMkVaxY8YDn6r70+tmqP6J+fIc3nUwvPKgppZqc6we6ApJ+jCvopm3Krf6M4RRkvGW8vo9q+hpO6ylXrtwB/cnTqly5csRtb5sTEhLSfV9aZ3gYD3/tQ72WR01p1XTbDwVjDdIUTmWlZvbhQS8tNctVE3oFPDWfVnjStXj7VMFWzacVUNVlQOtTn9vBgwe7IKXXWbFiReoI1WkphKUtM9Fz1Txczf4VdtUkXM2lvdCu8lcT4nHjxrmTANoG7dvrr7/e9SFOj7blYMdZVsosveNMwvtmpyftZ0OvqeM5o+XSO7bS226VR9qmxWmP1+zQPtPnPG0TfUn7euH7VtutfaGTYuH9p8NPaoRTeM/oc5sZv/32m+uaoGutSyc/dLz4mWtc69Hxrz7jah6u7hHpueyyy9xFFJj1GVGZ6uRVWtoWdbfQd9ozzzzjArzCu5q0A0B+Q7gGgFykgKaRwxV0FK418JH6v3o/qhXWRP1I01ItnIJLWqoF0w/S8EGORP27VeupwYnUp1W12Oq3qeCmfozeiLxZoRHPvW0JDzSq2VLtUXrbF847eeDx3md6/SX1WlqnTgaEhzVvwK1DvZZHNbHqn+yHF4jDqe+y3o8CUHjAVl9QbbO2X/1+VRuqqYXU+sDrM+z1hfXWo769uiiEqx+yavIUdNT3VY9rIKuMpnVSLWVGdNJGfXwVahXeO3fuHFErfdppp7mLArpqWF9//XUXhtR6QQNopfee05tbXTWdOg5zqsyyQq+Z0ecls6/pnSRJu560x2t2aJ/pM5feSNZpT0KkPeZUVqpNTm8WgfROqGSXapX1faSTPzrx57UO0FgO+t7wQ/2/NfCbji0NtpYencTI6LG0dKJB41R4AwXqZJBODKlViGq6ASA/oVk4AOQyNQHXAGNqzqpQEj63tUbYVS2fwnc4DYD0888/u5rI9H6Eq9lw2tGR9QNUNUVqgq4mv2qaqqbjXrD+/fffXSA/VE1hOIU8Sbt9qh1VE3P9kD6Y8JG0RT/cFSA0UnV6r6V1pq3x85qqeq91sJpj0UkA/XD3c1FT57RUA6yTCgog4bVqGgVbg5tp/2o0Y40S7QVr8YK1ltXI0mr26w1yd/TRR7uwoDDmdR3QflB3AR0b4duk/aDpjtLbtrTNmjWQnMKm1zxb1IJCx562Q0FNzdvVHF0yGple71nH4pIlSyJO4tx2221ucLrMlllmHKpcPWrers9R+Ojb3mvqs6SB3Q5FtcCqyVcT4/Ba2rTHa3Zon2jAOn1GvbJT02e1GJgxY0aGz9PJCg1upxMu4eXuDbiW2W4Rmdmfeg2dSNBAaVq/t6ymvZKsfEekRyPd6zOgY84PfQfqWNZJI41q7p080/7UAGr6nABAfkLNNQDkMgVJBT6N/Kz+zOrn6tGPWv0Q1cjNGvlYfaVVE6gf06qhy2geV/VL1OjKaiKp6aAUmlWzo8CkH/WqvVbNpfoDq1ZK4V4BUMH2UH1cw6mpqKYo0vaoWaYCu2pqdVv/Vy3owajfr0ao1o9jBTQ161Rz0LT9ZUV9irVOjTKtmk8FDZ2QUM2VtkHb4rUGUI2jQq7ea0405c0M9QtVIFNZqb+0QpxOOmg0cJWtauNVM/nYY4+50d8VQtWP9csvv3TPV39Y1RTqGNCUZKo9VABRKNd7USgX1VyqOb+utR7VxCq8Ksx601VlRMeMjoG33nrLBTOVvUetFsaOHetGMFfo1okC1ZSrFje9kx2iY+uNN95wx5res96jauJ1LKh2UuWYmTLLDK8ZvgKojoXwbQ+nz4SCtK4VtLR/1CJENfGqhc9sSNfnTs3htQ7VgC5fvtx9RvzSSOfqj67y1AjhCvKqZdW4Bzr+D7VNOkGmkdlVRjpxoVHn1RfbG009K/tTJyHUxcHrGuDRiRuFedUA65jVRSe+NNK9ZOU74lDNw7NLzeS1P6pVq5Y6Sruo6bg+Yzo2tZ+0b9NrTg4AeYGaawDIZQq0+iGoH++6TvvjX/fpR7f62apZsabvUYjTD920fZ09ClBqeqwmu3qOmoGr1lIBWxSgVGutZuH6ka8aT/04V7DVD279aM8sNTNWAFFttX74K1wpWClAHSrIKLyoybCer+m7NG1T2imawveT3pOCiZqU6rVUw6uTDtqG8P3lTb2Udn7o3KQaY71nTTWlAckUolRzpoCq8lLY1v5fv36929deIFA41XvzBnHTiQmdlFCNnMKzToBo/+j9eAN9af5jvUf1w9Y+00kK7QMF7kPxQll4rbUosGr6JQ1wp9dTcFENtva11z0hLQUwlZven15fAVu183pPOjGQ2TLLDIV01eBrHx6sxlOfCe0z1V5626SadzWtVzP4zFLgVHmqvLQ/tM8VCP3S4G/6jGjfqGm/ToSpFYH6CKtZ88HoxJv6w6sVg56n5+u400mRtAMPHoqOG/WnVsuItC0T1HRd+0u19tp/eh3Nra6yVsuY9AYczCrtXz/hWi1CVDY6ZsMHwvNafKhbhQal0+cIAPKLGA0ZntcbAQAIHtXSKrSoCTEAAEDQUXMNAAAAAIBPhGsAAAAAAHyiWTgAAAAAAD5Rcw0AAAAAgE+EawAAAAAAfCJcAwAAAADgU6zfFQSN5n/V7GRxcXF5vSkAAAAAgFy0b98+i4mJseOPP973uqi5TkPBmqm/c5726aZNm9i3ASnLvXv3UpYBQFkGB2UZDJRjcFCWwUFZBr8cQzmY/6i5TsOrsW7SpEmO7GD8KzEx0Xr16mWffPKJxcfHs1uivCwXLVpkdevWpSyjHGUZHJRlMFCOwUFZBgdlGfxy/O2333Lsdai5BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwKdYvysAAAAAACCnJCUl2bhx4+yDDz6wFStWWGxsrDVu3Ni6d+9ubdu2dcvoevXq1RHPK168uFWpUsXOPfdc69Wrl3uenHfeebZ27drU5QoXLmwlSpSwpk2bWufOne3II4/Mke0mXAMAAAAA8oXdu3fbNddcY7/88osLwM2aNbONGzfajz/+6C4PPPCAXXXVVanLH3/88Va+fHkLhUK2Y8cOmz9/vr3wwgtWqFAh6927d8S6FaYrVqxoe/bssV9//dW++eYb+/333+3ZZ5/NkW0nXAMAAAAA8oWnn37aBesGDRrYK6+8YpUrV3bB+YknnnC3dX3xxRenLn/LLbfY6aefnnpbyzz++OM2efLkA8L1DTfcYB06dHD/V022arS3bdtmc+bMsRNPPNH3thOuAQAAAAB5LiUlxYVi6du3rwvWEhMT40K0bp9wwgkWHx+f4Tpq167trnfu3HnQ16pWrZodc8wxLshv3rw5R7afcA0AAAAAyHPLli1LDcVqDh5Ogfrqq6/O8Ln79+93tdATJkxI9/npvdaff/7p/q+m4jmBcA0AAAAAyHPbt29P/b/6W2fG9ddff8B9GtTs3nvvPeD+l19+2aZNm2aJiYn222+/uWvVhrds2dJyAuEaAAAAAJDnSoQFag1OVrZs2UM+RwOaaVTwuXPnur7ZGv17wIAB6YZzDWImWr506dLWunVr69SpkxUrVixHtp95rgEAAAAAee7oo49202mJ+kKHU79oTb81dOjQiBpu9cUeP368Pffcc26EcNVMT5o0Kd31a5klS5bYggULbPbs2W6U8EqVKuXY9hOuAQAAAAA5Kjk52ZYvX+6mutK1bh9KkSJFrGPHju7/Tz75pJuCyxvo7NFHH3XzWs+aNctKlSp1wHPbt29vN954o6u9HjFihKvJPtxoFg4AAAAAyBHr1q2z8WNetekTJ1v1/bEWH4qxxJiQrSmUbB27XGZde/ZwfaIzolHCf/75Z1u0aJGdc8451rhxYxeqV61aZXFxcTZ48GBXQ52eXr162XfffedqvdXn+r333kutCT8cqLkGAAAAAPj2zuQpdlnbs6zQC1PshbXx9sj6YjZwQ1F3PWptvMW8MNkubdPBpk+dmuE6SpYsaW+99ZbdeuutbhTv+fPnW1JSkmsS/uabb9qpp56a4XPVl1pzXGtk8X/++cdGjhx5WEuVmmsAAAAAgO9gPeb+B+2ZzSWtlBU+4PF4K2QXJ5WwthtTbOCAoWYhs47/6ZzuuhSOe/fu7S4Z+eKLL9K9v2bNmvbTTz9F3PfRRx+5mvCGDRtabqLmGgAAAADgqyn4yEFD7aHNJdIN1uH0uJZ78oEhtn79+kDtdcI1AAAAACDb1Me6Y0LsIYO1R8tdnBDrnhckhGsAAAAAQLZoFHANXtYhKWsDh52VVNymT5iUqVHEowXhGgAAAACQLRrF240KblmLllq+2v5YNxJ4UBCuAQAAAADZsnPnTjfdVnaUCMW45wcF4RoAAAAAkC2aOkvzWGfHrpiQe35QEK4BAAAAANlSo0YNW10o2RJtf5aep+XXFkq26tWrB2bPE64BAAAAANkSGxtrHbtcajOK7s7S8/5bdLd1vPwy9/ygIFwDAAAAALKtW8/rbHrpZNthKZlaXstp+a7X9QjUXidcAwAAAACyrUqVKtZn6CAbWGHXIQO2Htdydz04yD0vSIJTBw8AAAAAyBMd/9PZXfd+YIhdnBDr5rEOn55LfazVFFw11grWHTv/u3yQEK4BAAAAADkSsFud2treHDPWbpk4yc1jrem2NCq4Bi/rdEUXm9Kje+BqrD2EawAAAABAjqhatardNeBeu/3ufrZ69Wo3j7Wm29Ko4EEavCw9wX53AAAAAIDDLjY21o466qgCtecZ0AwAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAAAQpHA9atQo69atW8R9ixYtsq5du9pxxx1nZ555po0ZMybi8f3799szzzxjp512mjVr1sx69OhhK1asOMxbDgAAAAAoyPJNuB43bpwLyeG2bt1q3bt3t1q1atnUqVPttttus6efftr9PzyQT5gwwR566CGbOHGixcTE2PXXX2979+7Ng3cBAAAAACiIYvN6A9avX28DBgywefPmWe3atSMemzRpkhUpUsQGDx5ssbGxVqdOHVcr/corr1jnzp1dgH711VetX79+dsYZZ7jnjBw50tViz5gxw84///w8elcAAAAAgIIkz2uuFyxYYGXKlLH33nvPNesON3fuXGvZsqUL1p5WrVrZsmXLbPPmzbZ48WLbtWuXu89TunRpa9Sokc2ZM+ewvg8AAAAAQMGV5zXXbdu2dZf0rFu3zurVqxdxX+XKld31mjVr3ONSrVq1A5ZZu3Ztrm0zAAAAAAD5KlwfzJ49e1yz8HBFixZ110lJSbZ79273//SW2b59e7ZfNxQKWWJiYrafjwN5ZeVdI3pRlsFBWQYHZRkMlGNwUJbBQVkGvxxDoZAbtyvw4bpYsWIHDEymUC3x8fHucdEy3v+9ZYoXL57t1923b58bpRw5b/ny5ezWgKAsg4OyDA7KMhgox+CgLIODsgx2ORZJU1kbyHBdtWpV27BhQ8R93u0qVapYcnJy6n01a9aMWKZBgwbZft24uDirW7dutp+PA3lniTTyu58TH8gfZakvJsoy+lGWwUFZBgPlGByUZXBQlsEvx6VLl+bY6+TrcK3BzDTNVkpKihUuXNjdN3v2bDeqeIUKFaxUqVJWsmRJ++GHH1LDdUJCgi1cuNDNjZ1dahagmnHkPB3M7NtgoCyDg7IMDsoyGCjH4KAsg4OyDG45xuRQk/B8MVr4wWi6rZ07d7qpunRGYdq0afbaa6/ZjTfemFp9rxD9+OOP2+eff+5GD7/zzjtdjXeHDh3yevMBAAAAAAVEvq65Vu306NGj7eGHH7ZOnTpZpUqVrH///u7/nt69e7vm4QMHDnQDoKm2e8yYMTnWbh4AAAAAgKgK18OHDz/gvqZNm9rEiRMzfI6ai/fr189dAAAAAADIC/m6WTgAAAAAANGAcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAKAghOt9+/bZyJEj7cwzz7Tjjz/errzySps/f37q44sWLbKuXbvacccd55YZM2ZMnm4vAAAAAKBgiYpw/cILL9jUqVPtoYcesunTp9vRRx9t119/va1fv962bt1q3bt3t1q1arllbrvtNnv66afd/wEAAAAAOBxiLQp8/vnndsEFF9ipp57qbt9zzz02efJk+/nnn2358uVWpEgRGzx4sMXGxlqdOnVsxYoV9sorr1jnzp3zetMBAAAAAAVAVNRcly1b1mbOnGmrVq2ylJQUmzhxogvUDRs2tLlz51rLli1dsPa0atXKli1bZps3b87T7QYAAAAAFAxRUXM9YMAAu/POO61du3ZWuHBhK1SokGv6XbNmTVu3bp3Vq1cvYvnKlSu76zVr1liFChXyaKsBAAAAAAVFVITrv/76y0qXLm3PP/+8ValSxTUJv/vuu238+PG2Z88eV4sdrmjRou46KSkpW68XCoUsMTExR7Yd/9q9e3fENaIXZRkclGVwUJbBQDkGB2UZHJRl8MsxFApZTExMwQjXq1evtn79+tm4cePshBNOcPc1adLEli5das8++6wVK1bM9u7dG/EcL1THx8dne3RyjUCOnKc+8ggGyjI4KMvgoCyDgXIMDsoyOCjLYJdjkTSVtYEN17/++qsLuwrU4Zo1a2azZs2yI444wjZs2BDxmHdbtdzZERcXZ3Xr1vWx1UjLO0ukUd2LFy/ODorystQXE2UZ/SjL4KAsg4FyDA7KMjgoy+CX49KlS3PsdfJ9uK5WrZq7XrJkiTVt2jT1/j/++MOOOuooN7f1hAkT3EBn6o8ts2fPttq1a2e7v7WaBWS31hsHp4OZfRsMlGVwUJbBQVkGA+UYHJRlcFCWwS3HmBxqEh4Vo4UrUKs5uPpYf//99+6Mw1NPPeUC9A033OCm29q5c6cb9ExnHaZNm2avvfaa3XjjjXm96QAAAACAAiLf11xrZPBRo0a5QH3vvffa9u3b3ejg6oOtWmsZPXq0Pfzww9apUyerVKmS9e/f3/0fAAAAAIDDId+HaylTpowNGjTIXTKq3dbc1wAAAAAA5IV83ywcAAAAAID8jnANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAIJ+oX7++u/z111/udrdu3dztt99++6DP++eff+zWW2+15s2bW6tWrez++++3Xbt2HaatBiCx7AYAAAAgem3evNmuuOIK27RpkzVu3Ni2bt1qkyZNsn379tnw4cPzevOAAoOaawAAACCKjR071gXrs846y6ZNm2aTJ0+2UqVK2eLFiy05OTmvNw8oMKi5BgAAAKLYN998464VrqVixYo2d+7cPN4qoOCh5hoAAACIYupvLaqpbtu2rZ100kk2cOBA+lwDhxnhGgAAAIhiu3fvdtejR4+2ypUrW7FixVzT8AEDBuT1pgEFCuEaAAAAiGIK09KlSxebMGGCvf/++1a6dGn7+OOPXV9sAIcH4RoAAACIYkcccYS7btCggbtWsK5du7b7/9q1a/N024CChHANAAAA5AKN1L18+XL7/fff3XVujdytea3l+++/d9d79uyxlStXuv/XrFkzV14TwIEYLRwAAADIQevXr7cJ416z2V/OsuqhOIsPxVhiTMjWFEq2jl0us649e1iVKlWytM4XX3zRNfkOV6JECXvrrbese/fuNn36dPv000/tkksusZ07d9qWLVvs0ksvtTJlylC2wGFCuAYAAAByyDuTp9iTDwyxjglx9sLeEhYf1lA00fbbjBcm26Vvvm19HhxkHTt3zvR6161b5y7hNJe11KhRw9544w0bNmyY/fLLL24qrhtuuMF69epFuQKHEeEaAAAAyKFgPeb+B+3ZzaWslBU+4HEF7YuTSljbjSk2cMBQs5BZx/9EBuwlS5ZE3FZozoxGjRplelkAuYM+1wAAAIBPqlUeOWioPbS5RLrBOpwe13Kq4VYTcgDBQLgGAAAAfBo/5lXrmBB7yGDt0XIXJ8S65wEIBsI1AAAA4INGAZ8+cbJ1SCqepeedlVTcpk+YlGujiAM4vAjXAAAAgA+rVq2y6vtjIwYvywwtX21/rK1evZr9DwQA4RoAAADwQVNfabqt7CgRinHPBxD9CNcAAACADyVLlnTzWGfHrpiQez6A6Ee4BgAAAHzQPNOrCyW7eayzQsuvLZRs1atXZ/8DAUC4BgAAAHyIjY21jl0utRlFd2fpef8tuts6Xn6Zez6A6Ee4BgAAAHzq1vM6m1462XZYSqaW13Javut1Pdj3QEAQrgEAAACfqlSpYn2GDrKBFXYdMmDrcS1314OD3PMABANtUAAAAIAc0PE/nd31bfcPsYsTCtvZe+MjpudSH2s1BVeNtYJ1x87/Lg8gGAjXAAAAQA4G7GYtmtuokU/ZzTO/siNCcW66LY0KrsHLOl3Rxab06E6NNRBAhGsAAAAgB6mp9+XXXG33P/Sgbd261c1jrem2NCo4g5cBwUW4BgAAAHLjh3ZsrB111FHsW6CAYEAzAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA5GW4TkpKsk2bNllycrLf7QAAAAAAoOCMFj5r1ix777337Pvvv7fNmze7+2JiYqxixYp22mmn2bnnnmunnnpqbmwrAAAAAADRHa5/+OEHGzZsmC1ZssSOP/54O//8891cfcWLF7eEhARbu3atzZ8/39555x1r0KCB3XXXXda6devc3XoAAAAAAKIlXA8dOtQ+++wzu/rqq+2ll16yKlWqZLjshg0bbNKkSXb33Xdb+/btbfDgwTm5vQAAAAAARGe4LlWqlH366aeulvpQKleubL169bJrr73WXn755ZzYRgAAAAAAoj9c33nnnVleccmSJa1Pnz7Z2SYAAAAAAII9oJnnr7/+srlz59r27dutQoUKdtJJJ1mNGjVydusAAAAAAAhiuNb0W/369bMZM2ZYKBRKvb9QoULWpUsXe+CBB9zo4QAAAAAAFBRZDtePPfaYffXVV3bPPffY2WefbeXLl3dTcn3yySf21FNPWdWqVe3GG2/Mna0FAAAAACAI4frjjz92fbCvueaa1PuqVatm3bt3t5SUFHvrrbcI1wAAAACAAqVQVp+QmJhoRx99dLqPaX7rrVu35sR2AQAAAAAQ3HCtpuDjx4+3/fv3H/DYu+++a23atMmpbQMAAAAAIJjNwps0aWJPP/20nX/++e6iea23bdtmX3zxhf3666+uufhzzz3nltXAZrfeemtubDcAAAAAANEbrh988EF3nZCQkBqiw40dOzb1/4RrAAAAAEBBkOVwvXjx4tzZEgAAAAAACkqfawAAAAAAEIlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAJDfwnVycnJOrxIAAAAAgGCF63bt2mU4YrjmuW7dunVObBcAAAAAAMGaiuuDDz5IrZFevXq1zZgxI92APXv2bNu3b1/ObyUAAAAAANEern///XcbN26c+39MTIw9//zzGS7bvXv3nNs6AAAAAACCEq779Olj3bp1s1AoZO3bt7fnnnvOGjZsGLFM4cKFrWTJku4CAAAAAEBBkqlwXaRIEatevbr7/+eff26VK1e2uLi43N42AAAAAACCOaCZQvaHH35oX331lbu9aNEiO//886158+Z233332d69e3NjOwEAAAAACE64Hjt2rN177722cOFCd3vIkCG2fft2u/TSS+2zzz6zZ555Jje2EwAAAACA4ITrSZMmWc+ePe3mm2+2NWvW2M8//2y33HKLC9x33XWXq9UGAAAAAKAgyXK4XrVqlZ1++unu/2oartHD27Zt624fffTRtnnz5pzfSgAAAAAAghSuy5cvb5s2bXL/nzlzpgvUVatWdbeXLFliFStWzPmtBAAAAAAg2kcLD6da6ieeeMJmz55ts2bNsjvvvDO1L7bmv77kkktyYzsBAAAAAAhOuFbf6pSUFJszZ45dfvnl1qNHD3f/hAkT7IwzzrA77rgjN7YTAAAAAIDghGvNeT106NAD7n/vvfesaNGiObVdAAAAAAAEN1x7NJjZd999Zxs2bLA+ffq4+a4bN27s5sEGAAAAAKAgyXK43r17t916660uWJcsWdJ27drlpuZ6++233dzX48ePt2OOOSZ3thYAAAAAgCCMFv7kk0/aggULbNy4cfb9999bKBRy948YMcKqVKliTz/9dG5sJwAAAAAAwQnXH3/8sWsG3qpVKzfHtadSpUp2880327x583J6GwEAAAAACFa4TkhIyLBfdZkyZSwxMTEntgsAAAAAgOCGa/Wnfv/999N97IsvvqC/NQAAAACgwMnygGZq+t2rVy/btm2btWnTxjUN15zX06ZNc3NdP/HEE7mzpQAAAAAABCVct2/f3h577DEXojUdlwwfPtwqVKhggwcPtnPOOSc3thMAAAAAgGDNc33hhRe6y99//+1qsEuXLm1HH320FSqU5VbmAAAAAABEvSyn4auvvtr++usv938F6ubNm1vdunVdsF68eLEL3QAAAAAAFCSZqrmeO3du6nzWP/74o+tjvWXLlgOWmzlzpq1cuTLntxIAAADAYZeSkmL79u0rsHs+KSkp9ZpWutEnLi7OChcunL/C9ZQpU2z69Olu8DJdhgwZcsAyXvi+4IILcn4rAQAAABw2+m2/bt061wW0INu/f7/FxsbamjVrCNdRqmzZsq4bc74J1wMGDLBLLrnEfciuueYae+CBB1xT8HA6k6ON1lRdAAAAAKKXF6wrV65s8fHxroKtoNbcq9a6aNGih7UGFP4puyYmJtqGDRsOW+uLTIXrUqVK2Yknnuj+//rrr1vjxo2tRIkSub1tAAAAAPIgUHrBWjMCFfR9IcWKFSNcR6HixYunnizKlwOaKWR7wVoHW8OGDW3BggWW29Qs/bzzzrMmTZrY+eefbx9//HHqY4sWLbKuXbvacccdZ2eeeaaNGTMm17cHAAAACCKvlk811kC0iz+Mx7HvubO8vta56d1337X77rvPunTpYh988IEL2X369LGffvrJtm7dat27d7datWrZ1KlT7bbbbrOnn37a/R8AAABA9hTUpuAIlpjDeBxna57rw0nhXWFZfb11kVtvvdXmz5/vRi7XpUiRIjZ48GA32ECdOnVsxYoV9sorr1jnzp3zevMBAAAAAAWA75rr3Pb333/b6tWrD5g/W02/b7zxRjdNWMuWLV2w9rRq1cqWLVtmmzdvzoMtBgAAABANVJH3zjvvpOaGadOmWf369fN6sxClfNVca4TwXr16ucEOcsvy5cvdtUZ6u+6662zhwoVWo0YNu/nmm61t27auc3q9evUinuNtj4bMz84gDN7Icsg5u3fvjrhG9KIsg4OyDA7KMhgox+CI9rLU6NiagkrjK3kDegXVnDlz7J577rEZM2a4KZv0vsV7314XWF0HfV8EVUpKSmo5pveZ1GM51XQ8y+H63nvvtVtuucWOPPJItxEK1+G1zCNGjLAXX3zRcsrOnTvd9d133+1eq2/fvvbpp5+6bRg7dqzt2bPHNQsPp6Hywyd9z84gDhokDbl3sgTRj7IMDsoyOCjLYKAcgyOay1KtQrP7WzojycnJ7re7Rt4Ob3Wal7z3qGttmzeYm/6f3nKIPklJSaknRjL6TKbNk9mVqaNaNcDho3a3b98+3aHoZ82aZd99953lpLi4OHetWutOnTq5/2uEctVgK1zrw7l37950D/7sjgyn10w7jzf88c4SaeA5b0h8RG9Z6ouJsox+lGVwUJbBQDkGR7SXpX5L6/e/Kqz0W9uv7du32+eff25btmxxLV9VO1y+fHlr166dlSlTxnKbphV79tlnbebMmW4wZE0rfMcdd7jtuOGGG9wyF1xwgT388MOp2UMzE6nCcP369W5MpwceeMCaNWvmHlP20Pref/9927Fjhx1zzDFuUOXWrVu7x9XM/Pnnn3fvT9mpRYsWNmrUqFx/n8iYsqtO7qT3mVy6dKnllEyF66FDh9pXX32Veju8tjptlbp3UOWUqlWruuu0Tb8Vfr/88kurXr26mxg8nHe7SpUq2XpN1cgz9UDu0MHMvg0GyjI4KMvgoCyDgXIMjmgtSwVgXRRI0qtQy2qwnjRpklWrVs2OOOKI1PsVbCdPnmyXX355rgZs1Vhef/31rkb60UcftUqVKtn48eNdxd1bb73lQrKCsbZFeeOjjz5yz9M2P/nkk65GU8FaMxUpe8jAgQPtzz//tMcee8xlFYV2tap97rnn3LTA2nc6OaFMoqCtWnC/+xHZp33vNftO7zOZk6OJZypcDxkyxNVIKzxrSiz1d65Zs2bEMjqISpcubSeddJLlpEaNGrl5tX/55Rc74YQTUu//448/3DY0b97cJkyY4D443kE7e/Zsq127doGf9B4AAADIS5999pkL1soK4XRbwVSP5+YMP998840tWLDA1TJ7lXUKy8oWr776ql1xxRXuPtWkh9fSP/LII64yTxmjW7durmuqBj1Tl1VNDTxlyhRr0qSJW1bTAi9evNgNuKxw7fG60qLgyFS4Vg2w1yRbyV4HTbly5exw0EHes2dP17RC29G0aVP78MMP7dtvv7Vx48a5g3706NE2YMAAt9yvv/5qr732mjshAAAAACBvqBmumoJ7LVHTUsDW41out/pgq0KuVKlSEa1glWdUaff1119n+DxV1HlUgSiqgVbXVLn66qsjllfNuLecR02QUbBk+Sj2QvbhpLM+qsIfOXJkar8HNeHwaskVrtVHQtumph79+/fPk+0EAAAA8P99zzPT5FahtWTJkrmy2zIaCVrN0g8W6NNrxq11eaNOv/nmm651bbi0tfM50V8d0SV/DNOXCWpuoUt6VJs9ceLEw75NAAAAANKnyjEvjB5MboZQzVmdkJDgarDDa6/nzZvnWsBmtb+tBi8T9acObwKuSkCtSwOloeCKPL0CAAAAADlANcPqy+zNHZ2WN2p4bk7LpcGWFbDvuusu++GHH+yvv/5y3UcVtq+55prUwa3UZ3rXrl2ZCtdt2rSxQYMGuRHQV65c6fpav/TSS/SvBuEaAAAAQO7QFL7r1q07IGDrtu7X47lJwV3T92oqX40KrsHTFKw1dtNxxx3narPPOOMMV+Oc2ZawqqU+++yzXcA+77zzbOrUqfbggw/m6sBsiA5R0ywcAAAAQHTRNFuabkujgmvwMo9qrHN7Gi5PhQoVbMSIEek+pqm2Xn755Yj7LrnkkojbGvxMA5l5/bDV3F0zKOmSHj0/7TpQMGQrXGvO6++//971X0h7Fkp9DTR0PQAAAAAoQKtWV6OCa/Ay9bHOzabgQF7J8lGt+eB05icuLs4qVqx4wCAAOTkJNwAAAIBgUKDOrVHBgagM12+88Yadc845NmzYMNckAgAAAACAgi7Lo4Vv3rzZunTpQrAGAAAAACC74bpRo0a2bNmyrD4NAAAAAICC3Sx8zZo1qf+/+uqr3dxw6jPRokWLdGuwjzjiiJzdSgAAAAAAoj1ct23bNmKgslAoZA888ECGg5ctWrQo57YQAAAAAIAghGtNrcUo4AAAAAAA+AjX6U2CvnHjRqtUqZL7/7Zt22zdunXWoEGDzKwOAAAAQAGiOa5XrVplO3fudNNx1ahRg7muEThZHtAsISHBunfvbt26dUu979dff7WOHTvaLbfcYrt3787pbQQAAAAQhVQB9/jDj9iZzVva3Rdcak906eGu2zRvaU88PMzWr1+fq69fv359mzZtWqaWVfjX8j/88EOOvPa+ffts3LhxufoetK16XNueEeW2e+65x/KbZ5991nU/LtDh+vHHH7c///zT+vTpk3pfq1atbNSoUfb777/bM888k9PbCAAAACDKvDN5il3W9iwr9MIUe2FtvD2yvpgN3FDUXY9aG28xL0y2S9t0sOlTp+baNnzzzTd23nnnZWrZatWqueWPP/74HHntDz74wIYNG2b5IcQOGDAgrzejQMhUs/BwX3zxhd1999121llnpd5XpEgRd9ZBtdpPPfWUexwAAABAwQ3WY+5/0J7ZXNJKWeEDHo+3QnZxUglruzHFBg4YahYy6/ifzjm+HV431swoXLhwlpY/FA0CnR+ULVs2rzehwMhyzfWuXbusdOnS6T5WoUIF27p1a05sFwAAAIAobQo+ctBQe2hziXSDdTg9ruWefGBIrjQRD29SrabR/fr1s0cffdROPvlka9asmevWqrGk0msWrnA8ZswYu/DCC6158+Z28cUX23vvvRex/pUrV9qtt97qpig+6aST7M4777RNmza517z33ntTt8Fb58yZM914Vk2bNrUOHTq4ism9e/dG7Lubb77Z1Z6feeaZ9uGHH2bqfWq9qvzUetWFV9uVUbPwn376yU2v7G3zfffdZ9u3b099XJWmb7zxht12221uH51++uk2efJk9zx1BdZ9l19+uf3zzz+pz5k3b557Xa3z2GOPtQsuuMDV3Hv0+r169bIePXq4ffnSSy8d8B5ef/1199zPPvvM3dZ+eeyxx+y0005z++Oyyy5zLQs82sfa1ocffthOOOEEu+mmmyzqwnXjxo1tagZNN/QGdfAAAAAAKJjGj3nVOibEHjJYe7TcxQmx7nm57eOPP3aDMY8fP96ee+45FwpHjhyZ7rK6/6233nKBfPr06S6QDh482N588033+I4dO+zKK6+0xMRE17dal9WrV7tQqqboCq3iNTWfNWuW3X777XbppZe64Dlo0CC3PVq/N+hbz549XWWltk+v/8orr2TqfekkwP33329TpkyxokWL2hVXXJHuWFgaK0thu27dujZx4kTXpVf3KfTu378/dbknnnjChVptp0K+3re2VyFZ26YTEuouLDopouc3aNDA5cF3333XmjRp4k4u6ESDZ8aMGXbKKae4LHnRRRdFbJf2s9anMmnfvr27T8//+uuvXcB+55137Nxzz3UB+ssvv0x9nva3Xl+P33XXXRZ1zcJ1JuX66693Z1x0tkW11Vu2bLHPP//cFixYYC+++GLubCkAAACAfE0BcfrEyfZCUnyWnndWUnG7ZcIku71/v1wdRVwjlQ8dOtTi4uKsTp06rjb6q6++OmA5LzAPHz7c1dwWK1bMateu7cKcguxVV11lH330kQvYCsFe02vVoipcahrjUqVKufu8pubKSf/5z39c8JWaNWvakCFD7JprrnG15suWLXNjWymE6jFRn23VFh/KwIEDXRiWESNG2BlnnOGCsYJ8uFdffdVVhj7wwAPutkK2grTCroKsnid6z6opFp1UUBBXKNdYW6KgG17DrFrp6667zgoV+rfu9sYbb3RBe/ny5VaxYkV3X5kyZdzJg7QmTZrkWhM8//zzqe9hxYoVbvt1skBBXVQzvnjxYrf/Ffg9an1w5JFHWn6Q5SO3devW9sILL7izHLqouYQOnoYNG7pBzVQQAAAAAAoehcTq+2Ndn+qs0PLV9se68HrUUUfl2vZp3QrWHgVgjeqd1tKlSy0pKcnVnirriK518kBhcs+ePbZkyRKrVatWRJ/mY445xvr27Zvuay9cuNDVEquWNW2/7L/++su9pgKoF6xFGat48eKHfF9qFu1RF15t1x9//HHAcrpPeS6cwraeo/fjhWudSPDoxIJo+jSPase95uwKtp07d3Y12noPCtSLFi1yj6WkpKQ+J71y3bBhg6sV1wmV8PVrX3nBPpzKKm0XZb3X/CJbp4W003XRAadmFToo4+OzdnYKAAAAQLBoHuv40L9hNKtKhGLc83OTBmLODC/0Pvnkk3bEEUe4MKkBz8LXo0DoBe/MULNr1dx26tTpgMdUu61gmt4gaJmpyQ/fNi/UpvdevYrR9LYt/KRDeq/p1UqnpRMDqo1v1KiRC+7t2rWzcuXKHVBr7oX0cNoWNX1/+umn3YkMNQ/X63j7QU3wS5QocdDtSG+9eSVTp5TWrFmT7mXz5s2u4BSww+8HAAAAUPCo2XViTPZGyd4VE3LPzw+OPvpoFzCVbVSTrFpXXdSEXM2SFfDUpFq1tGoaHl7jqkHCVAOfNsSqVvvvv/9OXZcu6i+sZtwaNFrhVLMvqWm4R03Fw9efEU2J7FGXXW2XXi+tevXq2dy5cyPuU1NrndRQM/nsePvtt11X4XHjxrnuw6qE9fpaH2rEdJ1UUCB/6KGH3Ht47bXX3P3etqtmO3x/qal5RuN/RU3NtUZhy8pZGa8ZAAAAAICCQ017VxdKtkTbn6Wm4Vp+baFkq169uuUHapmrEbHVDVY1wArMGi1bg2spQIpGEVe3WA1Idscdd7gm4+rPrQCr9+G17FVoVBDX87Sc5p3WaNoaGVx9pVUzrpCpgKqRuPv37+8GD1NttEJnRjXG4dSHWq+tJurqJ645u9Ob3/vaa691/cW1rK5VWar/K9hrBPXsqFq1qnsvX331lXufGodL2y3hI6EfjPaZavU1enqbNm1cuNa19oPemx7/73//60YZV7/2qA7XjzzySJbCNQAAAICCR7W9HbtcajNemOLmsc6s/xbdbR0vvyxXBzPLKjVTVvNmDUT24IMPuhCpgbtuuOEG97j6QqsWW2FWzaIVwlUpqXAsGvzLm7ZKoVyDgGnwMwVEXdS/WgHSGy1cIVr3K5hq9G01d9bAYOrHfiga1Evbq1prnQgYPXp0us3CNWq51wxbA6WppYBG59ZI2+HNwrNC/aJVI9+/f38XptUHuk+fPqkjkWd2TC69h08//dS9DzUH177SRQFbU4Wpb7fKQf2786uYUH6Z3Tyf+O2339y1NyodcoZGXDznnHPsk08+oX9+AMpSrVM0wAZjLUQ3yjI4KMtgoByDI9rLUoN1qTmyBrXKTn9WNXW+tE0He2ZjyUxNx7XDUuy2SjttyswZVqVKFcsrGqFac0WrmbPmYhZ1gdX+0H5I268Z0WHPnj2uX7iu0/tM5mT+y/I816IzEupsrjM3Xbp0cRurg1BnJgAAAAAUXArIfYYOsoEVdrngfDB6XMvd9eCgPA3WK1euTJ0/WTXUQHZkud2FmhpoLjZV/aujv0a101kAtbFXkwh1ZFdzAwAAAAAFU8f//Nt0t/cDQ+zihFg3j3V4H2z1sVZT8Omlk12w7pjHTX01qNh3333nmmOrDzRwWMK1N5qdJk1XR/1jjz3W3a92+5o4XG3rx44dm62NAQAAABCcgN3q1Nb25pixdsvESW4ea023pVHBNXhZpyu62JQe3fO0xtqjQcaAwx6uZ86caffdd58bCj18UnDN/aYzPffcc4/vjQIAAAAQ/dTE+q4B99rtd/dz01NpyicNoqVKuvw0eBmQE7J8RCclJbkh3tOjTv779u3Lie0CAAAAEBAK0qqcA4IsywOaaRQ1DWaWnvfffz+1mTgAAAAAAAVFlmuub7/9djf5+MUXX2xnnHGGm//6gw8+cP0UvvnmGzenGgAAAAAABUmWa65POOEEN2CZJk1XkNY02RohfOPGjW7Sc02WDgAAAABAQZKpmmtvEnlPy5YtbcKECW4Kru3bt7tBCUqUKJGb2wkAAAAAQHSH63PPPdfN99a6dWs79dRTXe10mTJlrFixYu4CAAAAAEBBlqlwPXDgQJs7d66bhmvy5MluVPDGjRu7sK3L8ccf7+4DAAAAgIJm//799txzz7mslJCQYC1atLBBgwYddIT0rVu32kMPPWSzZs1yt8855xy79957LT4+PnWZtm3buinMwl144YX2+OOP5+K7Qa6G665du7qLLF++3ObMmePC9rvvvmsvvPCCaxJ+0kknpdZsM8w+AAAAgIJi1KhRrtvssGHDrEqVKvbYY4/Z9ddf7wZ+LlKkSLrP6d27t5vmWONXKZAPGDDAhgwZYo8++qh7XHOCr1mzxo1rpYpNDy2HAzRaeK1atdzl0ksvdbfXrl3rgvZnn31mw4cPt5SUFFu4cGFubCsAAAAA5Ct79+61V1991fr16+dmU5KRI0faaaedZjNmzLDzzz//gOf89NNP9uOPP9pHH31kderUcfcNHTrUevbsaX369HEB/Y8//nCDRzdv3txKly592N8XDkO49qxYscK+++47++GHH2z+/Pm2YcMGq1ixop1yyinZXSUAAAAA5Jj69evb4MGD7b333rMFCxa4FrZ33HGHtWvXLt3lp02b5ppmp6d69er2xRdfHHD/4sWLbdeuXRGzJikMN2rUyLX4TS9cq3KyUqVKqcFaTjzxRDfN8bx58+y8886zJUuWuGUI1gEM14mJifb999+7uay//vprW7VqlcXGxrr+BN26dXNnZho0aJC7WwsAAAAAWTBixAjr27evPfzwwy489+rVy958801XI5yWQq1yjUetctV0u2jRohk27163bp27rlatWsT9lStXdq1807N+/foDltf6y5Ytm/oc1Vyr//Vtt93marrLly9vl1xyiV199dVWqFCWZ1RGfgnX11xzjaudTk5OdlNynXnmma5vtfpZ0+YfAAAAKDg279hjW3YmRdxXqlicVS0Xb3uTU2zFxp0HPOeYamXc9cpNO23PvpSIx6qULW6lixexbbuSbGPCnojH4ovEWvUKJSxlf8g9XqFU1mcq6ty5s1111VXu/wrZqk0eP358uuE67WxICteaflj3ZTSA8+7du9112vCtQK5pizN6TnphXc9RmJc///zTduzY4QK/TgiotlsDmWmdt99+e5b2AfJRuFbT73Llytl1113nzpborAkAAACAguej+f/Y+Fl/RtzX9tgj7O5Ox7tw3Gv0Nwc859P7/20a/cR7v9ii1dsiHut/cTNr17SGzVq41p7/ZEHEYy2OrmiPXHWS7dmX7F632xn1sry9am4drlmzZq57a3rUfFyjfHvU59mjZuEffvjhAc/xwrj6XocHc4Xk4sWLp/s6Wk7Lp6XneKOFjx071t0uWbJkahN3NT/XgNKqzab2OkrD9T333OOag2t4+SeffNI1/1bNtS4646Pm4QAAAACC77zmNa1VvSoH1FxLpdLF7Lmep2b43LsuapZuzbWc3qiaNaxR7oCaaykWF+teNzvSZhVNm5VRMNXUVwrf6TUL1yU9XvNujUFVs+b/b6NuZ9RttmrVqm5A6HAK29u2bXODmUlcXJy7hKtXr57rrqvaa1V+In/JVCq+9tpr3UUFrlrsb7/91j7//HN7+eWX3ZkVNQ9X0Fb/hPADCgAAAECwqGl2Rs2zi8QWTm0Cnp4jK/5bC5uesiWKukt6CheKyVaTcPntt99caPb8/PPPEVNbhVMtsVdTnNlm4QrQeo5ykpeFNLWWZlDypjNOq2XLlq6JtwaJ9qYx1vNFlZc6AdC+fXs3Q9PNN98c8V40iDTBOn/KUpWz+gUoQOui2mx1tleNtsK25nbTJOg1atRwQ84DAAAAQF577bXX7Oijj7Zjjz3WJk2a5Eb3Vm7JKcpICtEKy+o+q+bjmudatdMdOnRIDelbtmyxUqVKuaCu2nGF6DvvvNONZq7aaDVH79ixY2rN9dlnn22jR4920yDrZMDs2bPdbc2HjfzJV3tu1VpreHgNcqZJznW2Rc0fAAAAACA/6NKli+u/rAHCVMs8ZsyYHJ/lqHfv3m7w54EDB7qabtVM63W8QctUKanpv4YNG+bGsNKUW+pyO2TIEDd4tJqcn3POORHTgN11111uGq4nnnjCjUiuSkwF68suuyxHtx15FK7VbEGjhnuXv//+2x0YOjhPPvlk6969u51wwgk5uHkAAAAAkH3HHHOM3X333bm6C9VkvF+/fu6SHgVjzVsdrkKFCvbMM88ctK+4moSHNwtHAMK1hn5XmN66dasbMU99CRSmNUqdJkvXfGwAAAAAABRUmQrXCtYK07qccsopdsQRR+T+lgEAAAAAEKRw/eWXX6Y7yfmh7Nu374Dh4wEAAADgcEjbFBvITelP8JbGxRdffMA8bIfyySef2AUXXJDd7QIAAAAAIFg1148++qibeuupp56yiy66yA0L783HFm7p0qX21VdfuSHuNTfbiBEjcmObAQAAAACIvnDdtGlTmz59ur355ps2btw4GzlypBsWXnO4FS9e3E2Svn79etuxY4eb261nz5525ZVXuiHlAQAAAEQfDWQMRLvQYTyOMz0Vl/pca6otTZD+/fffuzmtV65c6ea31gTpbdq0sdatW7upuDQUPQAAAIDo442ZlJiY6CrSgGiWmJiYP+e59j5sp512mrsAAAAACBZVlGmq3Q0bNrjb8fHxFhMTYwVRSkqKJSUluf9TgRh9NdaJiYnuOC5VqpTt2bMnf4XrvXv32ty5c23ZsmW2a9cu9yHThtatW9c1Hc/OiOIAAAAA8he1TBUvYBdUGkcqOTnZYmNjrVChTI0FjXxGJ4rUpXnjxo35J1y/9NJL9vLLL7tQnZ4yZcrYTTfd5JqOAwAAAIheqkSrVq2aVa5c2U2vW1Dt3r3b/v77b6tZsyZN5KNQXFyca3FwuJqGZypcK1RrpPDrrrsudaTwEiVKuMcUtlesWOGm3nrsscfcB/Haa6/N7e0GAAAAkMsUTApyc2jVXIsGai5WrFhebw7yuUyF6wkTJrha6dtvv/2Ax1TF3qRJE3fRmQGNKE64BgAAAAAUJJnqOLBlyxZr0aLFIZdr3ry5m5ILAAAAAICCJFPhuk6dOvbBBx8ccrmpU6da7dq1c2K7AAAAAAAIVrNwNQe/5ZZbXGf+Dh06uACtPtfqX615rv/55x/773//a7/++qs988wzub/VAAAAAABEW7g+/fTT7fXXX7fnn3/ehee0IwZqkIMTTjjBXn31VWvVqlVubSsAAAAAAPlSpqfiUn/qMWPGuLmuV65caTt27HCj52lAMw1NzxzXAAAAAICCKtPh2qMQrT7YAAAAAAAgCwOaAQAAAACAjBGuAQAAAAA4HM3CGzRo4EYGzwwtt3DhQr/bBQAAAABAsMK1Rgnv27evFS1a1Lp27Zr7WwUAAAAAQNDCdbt27WzUqFHWs2dPq1Klil166aW5v2UAAAAAAAStz/XJJ59sPXr0sKeeesqSkpJyd6sAAAAAAAjqVFw33XSTVaxY0TZs2GBHHnlk7m0VAAAAAABBDdclSpSwa665Jve2BgAAAACAoIdrAACAaHHPPffYO++8c9Blhg0bZvfee6+VLl3aPv74Y9dCz9OtWzf78ccf7fXXX7eTTjrJpk2b5pbNyOeff241atTI0fcAAAhwuD7YH5VChQpZfHy81apVy8477zwrV66c3+0DAADIlkaNGllCQoL7/9q1a91UoWXKlLETTjghdZnNmze7ay03fPhwe/zxxw+53rTr8BQvXpySAoACLMvhet26dTZ//nw3qFn16tWtUqVK7g/TqlWrXLjWGV/dfuGFF+ztt9+mbzYAAMgTV199tbuIV+usCgDNgOLR/Z7333/fOnfu7AZxPZi06wAAIEujhXvatGljpUqVsgkTJrjmT7qeMWOG++OkabpuueUW+/bbb12zqCeffJK9DAAA8j1VEMjgwYNt7969eb05AICCEK7HjRtnd911lx133HER9zds2NBuv/12e+mll1xzKU3b9cMPP+TktgIAAOSKdu3audZ4y5cvt5dffpm9DADI/XC9detWK1++fLqPKVR7fZe0TGJiYta3CAAA4DArWbKk3Xfffe7/CtcrVqzIcNlffvnF6tevH3EJb14OACiYYrMzOMjo0aNdf6QiRYqk3q8mVK+++qqrwZYFCxZYtWrVcnZrAQAAcokGY1VI/vrrr23o0KFZGtCM3zwAgCyH6759+1r37t2tbdu2duaZZ1qFChVcbfVXX31lO3fudMF77ty5rr/1zTffzB4GAABRY9CgQXbBBRfYN998Y8WKFUt3GQY0AwDkSLPw448/3qZOnWqnnHKKO7Or2mr1rT7ttNPs3XfftRYtWti+ffusd+/edtNNN2V19QAAAOlKTk52faJ///13d63bOe3II490g7PKnj17KAkAQO7VXEudOnVsxIgRGT6uJuOHmsYCAAAgs9OAjh/zqk2fONmq74+1+FCMJcaEbE2hZOvY5TLr2rOHm7Ekp2hQ1vfee8+WLl1KAQEAcjdcb9myxcaOHetqrBMSEqxcuXKu79G1117rmokDAADkhHcmT7GRg4Zax4RYeyEp3uLDGt0l2n6b8cJku/TNt63Pg4OsY+fOOfKacXFxNmTIEOvatauFQqEcWScAIPhis3P2uEuXLi5gazouDXC2ceNGF7anT59uU6ZMydGzxwAAoOAG6zH3P2jPbC5ppazwAY8raF+cVMLabkyxgQOGmoXMOv4n/YB9ySWXuEtm71elweLFizO1LAAA2QrXjz32mMXGxtpHH33k+iV5Vq5c6ZpRjRw50oYPH87eBQAA2aaT+aqxzihYh9PjD20uYb0fGGInn3YqJ/kBANExoJlGz9RgZeHBWnT71ltvtVmzZuXk9gEAgAJIfazVFPxQwdqj5S5OiHXPAwAgKsJ1SkqK62OdnvLly7vpuAAAALJLo4Br8LIOScWz9Lyzkorb9AmTcmUUcQAAcjxc169f3025lR71ua5Xr57llmXLlrmpwKZNm5Z636JFi9yAI+r/rXm3x4wZk2uvDwAAct+qVav+HRU8iz9TtHy1/bG2evXqXNs2AAByrM+15n687rrrbNu2bXbhhRdaxYoVbdOmTfb+++/bd999Z88884zlBs2d3bdvX0tMTEy9b+vWrda9e3dr3769G9Xz559/dtdly5a1zjk0YigAADi81ApO021lR4lQDK3oAADREa5bt25tjz76qBvY7Ntvv029XyH7kUcesQ4dOlhuePbZZ61EiRIR902aNMmKFCligwcPdoOsaf7tFStW2CuvvEK4BgAgSpUsWdLNY50du2JC7vkAAETFPNcXX3yxXXTRRfb333/b9u3brUyZMnb00UdbTEz2zjIfypw5c2zixImu2bmafnvmzp1rLVu2dMHa06pVK3vppZds8+bNzLkNAEAUqlGjhq0ulOzmsc5K03Atv7ZQslWvXj1Xtw8AgGyH6zVr1qR7f/Hixd1F1q5dm3r/EUccYTklISHB+vfvbwMHDrRq1aodME1H2j7elStXTt3mChUqZOs1Q6FQRPNz+Ld79+6Ia0QvyjI4KMvgCGJZXnBJJ5vxynS7eG9kq7WD+W+R3XZ+5062d+9ed4k2QSzHgoqyDA7KMvjlGAqFcqySOFPhum3btll6QQ0yllPU5FuDlal/d1p79uxxzcLDFS1a1F0nJSX56t+dk+8B/2/58uXsjoCgLIODsgyOIJVli9Yn2+C3JlrbvcUyNR3XDkuxqSX22JBTTo76v+FBKseCjrIMDsoy2OVYJE2mzNVwrb7UudXk+2DUDFxNvzVYWnqKFSt2wJlpL1THx8dn+3Xj4uKsbt262X4+DuSdJapVq1ZqawdEb1nqi4myjH6UZXAEtSx7DxpgA4YOt4e3lDxowFawHlB+p90+6H43Nky0Cmo5FkSUZXBQlsEvx6VLl+bY62QqXF9yySWWF6ZOner6Tof3s5ZBgwa5KbfU/HzDhg0Rj3m3q1Spku3X1YkEP+EcGdPBzL4NBsoyOCjL4AhaWXa56krXIq33A0Ps4oRYN491eB9s9bH+b9HdNr10st314CDrGJCZQoJWjgUZZRkclGVwyzEmByuRszWgmSclJcWOPfZYmzJlijVu3Nhy2uOPP+6afoc766yzrHfv3nbeeefZhx9+aBMmTHDbUbjwv2e0Z8+ebbVr12YwMwAAAqDjfzpbq1Nb25tjxtotEye5eaw13ZZGBdfgZZ2u6GJTenT3dVIdAIA8D9deB/DcktEfSg1UppFANZf16NGjbcCAAdazZ0/79ddf7bXXXnNzXQMAgGCoWrWq3TXgXrv97n62evVqN4+1ptvSb4HwGUMAAMhLUf0XSSFb4frhhx+2Tp06WaVKldzI4vo/AAAIFgXpo446Kq83AwCAYITrJUuWRNxu2rSpmwMbAAAAAIC8UsjXkwsVsl69eqXOLQ0AAAAAQEHkq+ZaI6spXAMAAAAAUJD5qrkGAAAAAACEawAAAAAAfKPmGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAACgIITrbdu22QMPPGCnn366NW/e3K644gqbO3du6uOLFi2yrl272nHHHWdnnnmmjRkzJk+3FwAAAABQsERFuO7Tp4/98ssv9uSTT9qUKVOscePGdt1119lff/1lW7dute7du1utWrVs6tSpdtttt9nTTz/t/g8AAAAAwOEQa/ncihUr7Ntvv7W3337b1VrLgAEDbNasWfbBBx9YsWLFrEiRIjZ48GCLjY21OnXquOe88sor1rlz57zefAAAAABAAZDva67LlStnL7/8sh177LGp98XExFgoFLLt27e75uEtW7Z0wdrTqlUrW7ZsmW3evDmPthoAAAAAUJDk+5rr0qVL2xlnnBFx38cff2z//POPnXrqqTZy5EirV69exOOVK1d212vWrLEKFSpk+TUV3BMTE31uOcLt3r074hrRi7IMDsoyOCjLYKAcg4OyDA7KMvjlGAqFXOVtgQjXac2bN8/uu+8+a9eunbVt29aGDRvmmoWHK1q0qLtOSkrK1mvs27fPDZKGnLd8+XJ2a0BQlsFBWQYHZRkMlGNwUJbBQVkGuxyLpMmTBSJcf/bZZ9a3b19r1qyZG9xM1Od67969Ect5oTo+Pj5brxMXF2d169bNgS2GxztLpIHnihcvzo6J8rLUFxNlGf0oy+CgLIOBcgwOyjI4KMvgl+PSpUtz7HWiJlyPHz/eHn74YevQoYM9/vjjqWcXqlatahs2bIhY1rtdpUqVbL2WmgVkN5jj4HQws2+DgbIMDsoyOCjLYKAcg4OyDA7KMrjlGJNDTcKjYkAzeeutt+zBBx+0q666yp566qmIansNZqam4ikpKan3zZ4922rXrp2t/tYAAAAAAAQuXGvU70ceecTVWN94441uBPCNGze6y44dO9x0Wzt37nTTc6lKf9q0afbaa6+5ZQEAAAAAOBzyfbPwTz/91A0wNmPGDHcJ16lTJxs+fLiNHj3aNRnX7UqVKln//v3d/wEAAAAAOBzyfbi+6aab3OVgmjZtahMnTjxs2wQAAAAAQFQ1CwcAAAAAIL8jXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAPhEuAYAAAAAwCfCNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgG8pHk5GTbsWOHuwYAAAAQPWLzegMAmG3fvt0+++wz27Jli8XExFgoFLLy5ctb+/btrUyZMuwiAAAAIJ+j5hrIB8H67bffttjYWKtatapVqVLFXev2hAkT3OMAAAAA8jfCNZDHTbxVY12tWjUrVCjy46jbCtl6HAAAAED+RrNwIA+beCt4azmF6PQoYOtxLaeabAAAAAD5EzXXUYhBr/Lvfs9qE+/du3e7AH4oe/bsyZH3AAAAACB3UBUWRRj06vBSiFb43bt3r3355ZeZqonOTBPvzp07p95fvHhxt75DKVasWA6+MwAAAAA5jXAdJbwaUQW38CbE+/fvdzWil19+OaNKZ5Fqg7du3WrlypVLDa8K1OvXr7dvv/3W7XPdXrJkiZUtW9YaNmxo8fHxGe737DTx1rWCutaXNpB7r6PHaRIOAAAA5G+E6yiR1RrRQ9XGxsXF2b59+1zNaRCDm/c+03t/y5Yts5deesk9XrRoUbcfFK5r167t/q/HixQp4h7T8+vWreue99NPP9nxxx/vAnZ6+z0rTbxLliyZels14ArqWl94+SpYr1u3zgV4AAAAAPlb8FJVDtgfCtmfayP7xpYqFmdVy8Xb3uQUW7Fx5wHPOabav7WXKzfttD37UiIeq1K2uJUuXsS27UqyjQmRfWfji8Ra9QolLGV/yP5en3DAemtXLmUW2m//bNhupctXinisZJxZfJzZ3v2FbNn6HbZ41RYrXLiwe6xobCGrWamU+//Stdttx86d9uMPP9iGjRts3dp1Frtvh5UqUdzKVK5hpctXthNPOskFyaSkPValfGmrWq6kJSYl2+otuyJeM7ZQjNWuUtr9f9n6BEveH9mkuXr5EhZfNNY2JeyxrbuSIgLlvv3//j9pX4r9sylyHyqS1v3fPvxn4w5LSv7fwv9TtWy8lSoeZ1t3JtmmHXts794kV+tcuHCslS0Vb8fUqGTJKfvtxwV/2/x589zrFY4tbGpxrX14Vof2tnbbbnv/o09s/vyfrFy5spZcuLCl7NtrNatVs51JyTZzzgI78sgaVrZGPReSC4VS7K9FP9kxxxxjSXFlrGTVo23u4n+sQYMGbpvKF/u3JnrVpgTbvS9kKSkptmVvrMUkmpWI+/eyN8Vs2//vBtu6L87W70g2L1urzFP2m53Y9gJXPtsTtlqpwskWWyhkRUqVd/dvSDTbkPjv8VgmvohVLlPcHWM61sIVijGrU/Xffbhi4w7bm2YfVisXbyWLxdmWnXts846kyGOpWJx7fF/Kflu+YccBx2GdqqWtUEyMrdq807Ym7LLV2/dZkfU7rFixfW57tF3bE/fahu27I55XvEhhq1GhpPtM/bXuwOO7VuVSFle4kK3dmmg79+yLeKxCqaJWvmQxd78eD1cktpAd9b/j+6912y3NYWhHVixpxeIKu+3RdoUrW6KIVSpd3HbvTbZVmyOP78KFYuzo/x3f2g/aH+GOKB9vJYrG2eYde2zLzqR88x0RW7iQrdmyy3YlRY4HULFUMStXsqjt2L3P1m2L3If6jqhY4t/vi7/X77CixSL3f82KJa1oXGFbvy3REnZHPlauRFGrWLpYjn5HSOnicValbHyOfEeEK1E01o4oX8J9RyxL5/hWmavsV2/eZYl7I/dhpdLFrGyJopawe6+t3xZ5fOsY07Emaf9myFGVSlqR2MK2bmui7UhzfJcvWdQqlCpmu5L22ZotkWWjz4Q+G///HRG5D2tUKGHFi8TaxoTdtm3Xv8e3vvP0uayYsMeOio/P0++I3friC8N3RNa+IzbuTE79fs3r74jw3xFpOzDxHXHw7wh9JlWWDf93O6+/Izz54XdEtH1HrN+yI+J3D78jovM7Iils/KK0vyN03Oo4ygmE63SooPuP/ibivrbHHmF3dzre/VHrleYx+fT+8931E+/9YotWb4t4rP/Fzaxd0xo2a+Fae/6TBRGPtTi6oj1y1Um2Z19yuuud2Ke9Fd6/137ZUcbWboos9NZH7LfjK5ut2mn2+eZK9vnY2amP1a1a2p6//jT3/9tf/fZ/B2ZRfV2YlTrSziy92koV3mvztpe0NduL2rRlP6c+t36JHXbGUXFWrcEJNmTa7wf8IX6t1xluYK/73pxrW9J8aQ+7sqU1r1PZ3puz3CZ+91fEY5t3/ftHXV9wad+rDugP7jvX/X/4Oz/ZX+sjv5gHdG5up9SrZBO++Mmm/7I54rFC21ZYyX9mmsUVt4SGXRSfIh7vWTXZXn/9dZu9o4ptTqlkVvMs2/K/x44ptNr+/HOOFanR1LbUbPbv/f976bKF91iTI4+0VatW2aIK//vzWKi6/frHv//t2vDfD+VrM5fYrMUb/rfGSmabzVpWCdlJ1UK2dpfZ+3+Hl1slWzj1JxvXq427dc/4H8LCn8qnkj3S5ThrdnQVG/PFH3bPhP8vF7nwhKOs17nHuj+IafehfmC9c/fZ7v8PTZl/wJfK4MtOsJPrV7H//rzKxs5cEvHYaQ2r2sD/tHA/3NI7Dt+/9xz3A+DpD3+zX1f8b+99+2853HFBEzv3+Jr23ZJ19tQHv0U8r+lR5e2xq092oSa99Y6/va0LumM+X2RfL1oX8Vj3NvXt8lPr2m8rttjgSXMP+MJ+5eYz3P/7vvb9AYHouZ6nuh+qk777y96fuyLisUtOqm03ntXIhaw7x34X8Zj+uE+6q8O/+2vS3AP+GD985Yl2Qp1K9tH8f2z8rD/zzXeEfti99N+F9v2f3nH4rxs6NLTOrY62n5Ztsoenzo94TN8Rj13Vwv3/7rfnWXJK5B+vl2483f1oeevrpfbJzysjHutySh3r0a6B+7HY/43vD/iOePOOdu7/A9+ec0DQHdGtlTWrVSHd74hzjjvS7ryw6SG/Ix6d/rMtTfMjS98RpzeqZl/8vtpenrEo4rFWx1S2IZe3dD+w0tuH0/qf5U6aPP/J7zbv700Rj916TmO7qGUtm/PnBhvx7i8RjzWsXtae6tHa/T+99b5665nuR8BrXy6xL35fE/FY19OPsW5n1LNFq7bZgLd+jHhMP1DT/47418jup1ijGuVs2vfLbNoPyyL34c5/7M6LyueP74j/4Tsia98RU37dbitnzc0X3xHe74g7xn53wMlGviMO/R1xZNk4O72l5avviHz1OyLaviP+97uH3xHR+R0RWzjGhp5dJd3fEX3PrOhO0ueEmFBmRlPK59R89rnnnrPJkydbQkKCtWjRwgYNGmRHHXVUltf122+/ubNj8ZWOylc118++8nqGNdd7ks2Wrd1sF110Ubo11y+Nn+buX/LHH65/sGplSxXeZ4VjQrZ51z5bsWqdaxIdspAdcUR1i9cpl7077evvvreUIqXd8mpavX9/ig4Yi9uX4O5LLlrWUvbvt7jYOKtcpYp7jcJ7E6xUfDFr2vIU2xeKteLx8VaiRLxt3rzF7rzxGnv/3XdsW8JOW74hwfV11iUlJdl2JOyw2pVL2vvvv2+z5v7uanOTU1LcmV+9do2KpaxqxXK25O+VZkVLWmj/fitXvrwVLVrELHmv/b3wJ4uNK2KFSlW2I444wooUibPExN22NynJTm3e0DasX2erN+90NcnhTbKL2F4L7U201es3W6Ujj7a//vrbGjVq9O97sf2WsnOT64NduXZji1Gf6c2bre4xda1IkaJWvpjZpg3r7NxOXVzNtezcudM+/fRTq1m1gpUqWii15lrbu2nzZjv77LOtXJnSUX3GWTXXajqvY0bN6fP7GWdqrg9ec71o0SIrWr6GFU0zaF5+O+NMzfWha671uWzWqJ4dVbU8tVJR+h2RmJhos+b8ZtVr1ooYyJKa6+j7jnCtSf5Zbqe3bOK6k1FzHc011wkRv3uouY7emuukLavcGEqbdqVEfEfsWL/cHUdNmjQxvwIRrhWs33rrLRs2bJib+uixxx6zlStX2gcffOD6zmY1XEtO7NycNHXqVBcyMxr0Sn2M0+tzrfvHjh1rlSpVsjlz5rjgGe7PP/+0ihUrugG71Ge4fv367vqHH35wfxhq1KjhArnu++OPP9xr1axZ0y2vUbT1ZaP/q3ZXzbR1n5pHe/2Vd+3a5Z6jEP3NN9/YiSee6O5TuWhZvYbWrxMher5qxNUMu3Tpf0O9nrt8+XJ3v97/0Ucf7Z6rw1avqfJW/3HdXrBggRv8S8G4Vq1a7j6tX+vRH7ZNmza5x8JH+NYy2g71bdZ71fupU6eOlSr175eFTtboedWrV3fvac2aNdayZUu3noz2e/io7p6MRhePRvrxp0AWPsAbohNlGRyUZTBQjsFBWQYHZRn8cvwtB/Nf1DcLVzB69dVXrV+/fnbGGf827xg5cqSddtppNmPGDDv//H+bWUW77A565Q2ypf2UdmAvPVcXb3opUTBevHixu1aI1rUXZBUoFUC1vAKyanQV2pcuXeoO2BIlSrjXUNjWdiqo6j4dxFrH/Pnz3UGrbVGoV4j+559/XG2v1qVQq6CsA1/hWAFbz9N2rF692oXVDRs2uG3QPtC17lfw1W2dTfRG3Q6/TkpKco8plGc0X7S2W+9V2xZeW6Dt14kaPa5t0Tq8YJ3RfleAVuBW8NbraX1BHDQOAAAAwP/LmZ7beUhBUEGvVatWqfcplKlpr2pqg0KBTUFOgU2hzrvo9sGm4fLmUVYo1LLhNDK2wqyEj3KtQKjnePcpdOq5bpCvQoXcY3quAqZCscKraqZ1n64Vhjdu3Ohuqxy0vHdCQOvQtnjBWo/r7JEXsLWc7lMw9wK/7lOg1fO8EwLeurwALV4odk3W//devSbtuq3ltEx4Yw09rou2VevSsgrY4a+tmn3dVs293l9m9rtoXWqCTrAGAAAAgi/qq9MUdETTVIWrXLmyrV27NlvrVJBSTWx+oyB87rnnplsjerDtVcBTQFZA1bUXmnXbC5UKnlq/arq9/2s/eEHaC7he6PTu07Z4AV3h16vh9YKsF17Dw7sXir2wrBMA3rq8Gmc1wdZtL8xrvV4Tf+9+b5/otrbN2ydah7etuug9636dBFCzdzX98Pqee/tB69CJmtNPP909pubfWp9q7NXHRseTaqO1DZnd70GlYyT8GtGLsgwOyjIYKMfgoCyDg7IMfjmGwioVraCHa28Hpe1brXCmvq/ZoeCopslBoX7Ws2bNcgFRTbi9pt06kLT/FFTV31knKBQWVXPr9Z0OD9je/72aaC0bHsR17YVd3U5bSxxOr68y8pps67W8PsxegFW49fpE6PW9pu3hNcG6/9/B1v6/+bd4odqrddexoP9rnapZV625F+TVp1snINQsXTXumzdvTj05cMEFF6T241bNOv6f9huCgbIMDsoyGCjH4KAsg4OyDHY5FsniOF2BDddemErbV1ZBSzWi2aGAWLduXQsS1djOnDnT7RfVxio8qj+x3qf6MWuQLoVd0WBe27Ztc8uoib1Xy6znindby7v5q/8XcHXt/V/h2RtMLL2Arfu0Pm8dCsD6vxecvVpob1mv6bdXY+7d751pWrhwYeqHQv29tbyamitU6715fe+9faA+3VqXXvOmm25yJx6EftKHphMy+mLSPszuZwz5A2UZHJRlMFCOwUFZBgdlGfxyXLp0aY69TtSHa685uAKiaiQ9ut2gQYNsrdMbXTpI9H6uuOKK1PDo9UNWgFWfdY1urVGxRX2MFUo1Urb6GGt/HHnkka7PsWp8tZ8VzDXC99y5c916dJDqBEd432yv77Z38XhhWctrOR3sCrwaCM17TLd1kkP/X7FihRstXCODN2/e3PXHVq25tkWvpa4BCslaVtd6TOvVCYWLL77YKlSokPra4fsgo4HGdEIBh6YyD9rnpKCiLIODsgwGyjE4KMvgoCyDW44xOdQkPBDhWgFaTXo1dZQXrhUKVZPZtWvXvN68fMcbZOtQo1srcL/33nv2yy+/uObUep43PZVG7VYzct2n0cJ1IkM13Qq2ekwBWbXHWofKQaOFezXP3tRXGi1c5aXHFYYVgDXImUL1vHnz3LrUB1qPKWQr3OtMkzeKubbl+uuvd4Fc2+u9J9VWy8EGEktvHwAAAABAgQ7XagqsEP3444+7vrGalknzXCvcdejQIa83L6qEh04F7m7durma3rSBVSE8/D6F6Lfffts1uVZw1tRVCtzePNc//vijqwHX/zWYmDfPteal9ua5VrjWAHQKzZpKTddaTjXkCtDe6x5qaistCwAAAACHW9SHa+ndu7cLXgMHDnThS31sx4wZk2Md0wsyb97qg92ncKx+yz179nQ12ArF3sjkCscK4Arbl112mT377LOuGbguan6ui8pOz/NqoT16LO3rUuMMAAAAID8KRLhWkOvXr5+7IO8o/HqBOS3dp5MdCtAavTzt89TSAAAAAACi1b/DLgMAAAAAgGwjXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrAAAAAAB8IlwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfYkKhUMjvSoJk/vz5pl1SpEiRvN6UQNE+XbdunVWtWtViYmLyenPgsyz37dtncXFxlGWUoyyDg7IMBsoxOCjL4KAsg1+Oe/fudfc1b97c9+vE+l5DwBD8cm+/VqtWLZfWjsNdlpx8CgbKMjgoy2CgHIODsgwOyjL45RgTE5NjGZCaawAAAAAAfKLPNQAAAAAAPhGuAQAAAADwiXANAAAAAIBPhGsAAAAAAHwiXAMAAAAA4BPhGgAAAAAAnwjXAAAAAAD4RLgGAAAAAMAnwjUAAAAAAD4RrgEAAAAA8IlwDQAAAACAT4RrZMv+/fvtmWeesdNOO82aNWtmPXr0sBUrVmS4/NatW+2uu+6yli1busv9999viYmJEct8/PHHdt5551mTJk3swgsvtFmzZlE6+bAs//zzT7vhhhvspJNOspNPPtl69+5ta9asiVimbdu2Vr9+/YhL3759D8O7KdiyWpbvvPPOAeWkS/hz+Fzm73J89tln0y1DXe69997U5fhM5r1Ro0ZZt27dDroMfyuDU5b8rQxGOfJ3Mhhl+ezh/FsZArLh2WefDZ188smhL7/8MrRo0aJQjx49Qh06dAglJSWlu3zXrl1Dl156aej3338Pfffdd6E2bdqE+vfvn/r47NmzQ40bNw698cYboaVLl4aGDx8eOvbYY93/kX/KcsuWLaHWrVuH7rjjjtAff/wR+u2331zZnnvuuaE9e/a4ZXbs2BGqX79+aObMmaENGzakXhISEijKfFSWMmzYMFd+4eWkS3Jysnucz2X+L8edO3ceUH6jRo0KNW3a1D1X+EzmvbFjx7rvRX3eDoa/lcEoS/5WBuczyd/JYJTlzsP4t5JwjSzTD7zjjz8+9NZbb6Xet337dneAfvDBBwcsP3/+/FC9evUigvLXX3/tDuB169a52/rxqMAWrkuXLqH777+fEspHZTlp0qRQ8+bNU4O0rF271pWvTprIvHnz3G2tB/m3LKV79+6hhx56KMN18rmMjnIMt2LFilCzZs0ins9nMu/ob9x1110XOu6440LnnHPOQX/88bcyOGXJ38pglKPwdzI4ZXm4/lbSLBxZtnjxYtu1a5e1atUq9b7SpUtbo0aNbM6cOQcsP3fuXKtUqZLVqVMn9b4TTzzRYmJibN68ea4J5Pz58yPWJ2p2rOci/5SlmoE///zzVrRo0QMe2759u7tesmSJK2+tB/m3LL2yqlu3brqP8bmMnnIMN3z4cDvmmGOsS5cuqffxmcw7CxYssDJlyth7773nmvgfDH8rg1OW/K0MRjkKfyeDU5aH629lrK9no0Bat26du65WrVrE/ZUrV7a1a9cesPz69esPWLZIkSJWtmxZt3xCQoLrf121atVMrQ95V5Y1atRwl3AvvfSSC9vqSy9//PGHxcfH22233WY//fSTlS9f3i655BK7+uqrrVAhzufll7LcsmWLbdq0yQW2N954w7Zt2+b+OKlvUe3atflcRkk5hvvtt9/s888/t9deey3is8ZnMu+o/54umcHfyuCUJX8rg1GO/J0MTlkezr+V/NJFlu3evTs1IIdTwEpKSkp3+bTLhi+/Z8+eLK0PeVeWab3++uv21ltvWZ8+faxChQqpg7js2LHDDU43ZswYd1bw6aefdoNJIP+Upf6ISOHChe3RRx+1kSNHupNcV155pQvdfC6j7zM5btw4d4IkbSsgPpPRgb+VwcXfyujE38lgGpfLfyupuUaWFStWzF3v3bs39f+iH37FixdPd3ktm5aW1xkir4lx2mUyWh/yriw9Gq9BXzgvvPCC3XjjjXbttdemPjZ27Fj3/JIlS7rbGmlRzVy1rM4GUnudP8pSf1R+/PFH16TKoyb/bdq0sWnTptmll16aur5wfC7z52dSJ0ZmzJhhgwYNOuAxPpPRgb+VwcPfyujG38ngSTwMfyupuUaWec0VN2zYEHG/bqdt2i26L+2y+uGoZqhVqlRxzcMVsjO7PuRdWcq+ffusX79+9uKLL1r//v1drXW4uLi41C8mT7169dwXmtcvG/mjLMODtehzqOaMap7K5zJ6ylG+/vpr10++Q4cOBzzGZzI68LcyWPhbGQz8nQyWrw/D30rCNbKsQYMG7uD74YcfUu9Tv+mFCxfaCSeccMDy6ourfoTh87R6z23evLkb2EzXqkULp2VatGhBCeWjshQF6k8++cSeeOIJu+666yIe0xeW+r/oLF/a/i0VK1a0cuXK5dI7QVbLUs35NWig1/xbdu7cacuXL3eDnPG5jJ7PpGhwyMaNGx8wEAufyejB38pg4W9l9OPvZPDMOwx/K2kWjixTX8CuXbva448/7jr7V69e3R577DF31l1nglJSUtwgEKVKlXLN3NSvQeH5zjvvtMGDB7szQGqO0bFjR1dzLd27d7cbbrjBjYh7+umn29SpU23RokX28MMPU0L5qCzVXPijjz5yPxo04vvGjRtT1+Utc/bZZ9vo0aOtVq1a7gts9uzZ7vaAAQMoy3xUlmr+/dRTT7myVHMnhewnn3zSPbdTp05unXwu8385ho8yrjPsaakZG5/J/Im/lcHB38pg4O9kcKTk5d9KXxN5ocBKTk4OjRgxItSqVSs3v9z1118fWrlypXtM15onburUqanLb9q0KXTbbbe5ZU866aTQoEGDIuZKlnfeeSfUoUOHUJMmTUKdOnVKnTcZ+acsNd+jbqd38ZbZt29faNSoUaF27dqFGjduHDr77LNDEydOpBjz4edy4cKFbi7rFi1auPnL9Rlds2ZNxDr5XOb/cpRzzz039Pjjj6e7Pj6T+cPdd98dMQ8rfyuDW5b8rQzOZ5K/k8Epy8P1tzJG/+TEGQIAAAAAAAoq+lwDAAAAAOAT4RoAAAAAAJ8I1wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAA8lgoFMrrTcAhUEYAgEMhXAMA8o1u3bpZo0aN7Lfffkv38bZt29o999wTsXz9+vUjLscee6ydeeaZNmTIENu+fbtbLjEx0c4++2w79dRTbevWrQes96uvvrIGDRrYuHHjsrS9zz77rHvNrJg2bZp7zqpVq9ztpUuX2hVXXGE56aabbrLJkyfn6DoLss8//9zuvvvuHFlX2vKfNGmS3XjjjTmybgBA3iJcAwDylZSUFLv33ntt7969mVpeYXzixImpl7Fjx9q1115rU6dOdaFFNY7x8fH22GOPuWB9//33Rzx/zZo11r9/fxfI9bzD7eOPP7affvopx9an8LZ27Vrr3Llzjq2zoNNJF+3T3PCf//zH1q9f745XAEB0I1wDAPKVUqVK2Z9//mnPP/98ppYvWbKkHXfccamXli1bupCsYK3Q+ssvv7jlmjZtarfeeqvNmDHDpkyZ4u7bt2+f3XHHHVasWDEbPny4RbukpCR74okn3HsvVIg/8dFA5XTDDTfYk08+6coPABC9+MsLAMhXGjZsaB07drTRo0fb77//nu31qHm4VzPtUehs3ry5Pfzww7Zy5Up76qmn3GsokJYtW/ag61PwGTZsmLVu3dqOP/54V7ueXhiaO3eude3a1Zo1a2Ynnniia068ZcuWDJuVP/fcc+7/aiqs26Ll1ay9TZs27n1oPTox4DUlzohOGuzevds1nw/37bff2lVXXeW2W03jH3jggdQm8zJnzhy77rrr3IkJvZ6er23Zv39/6jIfffSRXXTRRe4kRatWraxv3762YcOGiNdRU/Tzzz8/tWm+1pGcnGy55VDva/ny5da7d29XZjrxom4E8+bNS31c+1P7Xa0HtJzWo30wYMAA27Vrl1tGz/nxxx/dRcv+8MMP7qL/T5gwwZXRKaecYt98803qNl155ZXWokULO+mkk+yuu+46ZK13u3btbM+ePaknfQAA0YlwDQDIdxRuypcvn6Xm4WktW7bMXR955JGp9xUuXNg1D1dtocLqq6++6kLVCSeccMj19evXzzU7v/76610oV4hL20dbIVW15qoJ1zL33XefC2VXX321C09pXXrppa5ZsGjduq1m7DoJoJCmYDZmzBi75ZZb7LvvvnPh8WDee+89F/b0+uH9yXv27OlOHowcOdK9jy+++MK9b1m8eLHbZu/xF154wZ2AUOj/8MMP3TIKpArTZ511lr3yyiuuXL7//nu3fZ6XXnrJNbk/+eST7cUXX3ShV8seapuz61DvS33ZL7nkEncSZeDAgfb4449bTEyMXXPNNa5Mwg0aNMiqV69uo0aNcutUE229B+8xdT3wuh80btw49Xl6XZ080UXh/d1337UePXpYlSpVXE209pNaT3Tp0sU2b96c4XspWrSoK7f3338/V/YVAODwiD1MrwMAQKaVLl3a1dzefPPNrnn4nXfemeGyCqPhtaMKvQpPCokKPF4NtqdGjRouFGr9qn1Uk9xDUTP1Tz/91AVFhUY57bTT7MILL3QhzqMa8Nq1a7ugqSAvqsFWba4Cm/dcT9WqVd1FtK2i/rfFixd3gc0L/aoBVS2rakozsnPnTjcQ3Lnnnhtx/zPPPOMGawtvZq/wrfCn11K4Vs2rd9JBVNP75ZdfupMFeo8K1wqAOrGga1Go1etp/+u1tb8VIhVkRTXJWka3u3fvbsccc8wB27xp0yZ3EiEjNWvWdLXJ6TnU+9LJgbi4OHv99dddVwNRbfoFF1zg3mv4gG9nnHFG6oBlOjmgbdL713FSt25d1/UgvIw8l19+uZ1zzjnu/6rl13q1LxW6PTpRcd5557kTOToBkJEmTZq41gHal97rAQCiC+EaAJAvqWmymiGrebhqTMNrDMMpAKZ9TCFRIenBBx90tZXhFILU71r3KxjPnz//kDXXaurtNd8Nfw2NQO6FazXHVv9uNa8OD/yqOa9Tp05qE+ZDUa2nAqHXpH3FihX2119/ue1UH/GMqOmxBoPTyQOPassXLFhgt912W8Sy2m5dRE3wdVET93/++ce9np6jdXmvp6bSCowK2grvp59+ugvPCqWi2lmvOXr4iQ6vebree3rhWu9Lg8llpFOnTumG68y8L51gUW2wF6wlNjbWnehQIPeafacXmnXCY/Xq1XYo4SPFq6XExo0brU+fPumeIFBT8oNRzbn2+bp161ygBwBEH8I1ACDfUq3n7Nmz3fRbGY2mrGCtWmhRYFbNarVq1TKs/VOtsppYq5ZRTYUV7tScNzyEpeX141VT9XCVKlVK/X9CQoIL7moKrUtaXo1vZqh5t2pgFZhV+6sa2vCm3unZsWOHu9bI6OHbraBfoUKFDJ+noKqTENoHCsYK5wqDCqLe3M66/fLLL7tm8GqmribTeu+qyVYz623btrnlMmoFkLZvtkc18kuWLLGsysz70jIVK1Y84H7d59W2e9RSIJxOnGRmXuvw1/f2QUavuXDhwoOuyys3rxwBANGHcA0AyLfKlCljgwcPdv2j1ew4PSVKlHBNajNDzZvVXFjNl1UrrnCkmma9hpp0Z6RcuXKpzZiPOOKIAwKVtx0K9+q/rNrRtNIGuIPVkquJsgZF07Z5zcZHjBgRMRhXRtuokO/RCQZtU9oB1dSPXSctNDiZQryavKuPuJo0eyFPNf/h1AxeF9VQq7+1atcfeeQRV+urZvyikxW1atU6YNvSC5x+ZOZ96dhReaWl2mVvf2UU+rPDGxAvo9f0yudQJ3AOtRwAIP9iQDMAQL7Wvn17109WNacZjbqdGQovGpRLzXQ10JTXt1gh9oMPPnA1txnR6NjyySefRNw/c+bMiMCnQa/+/vtvF/a9i5pDK9Bn1Cw47ZRZamKtGnANzOUFazUXVm27hI/gnbY5ufp5q1lxeODX6Ouff/55xLIa2Vq1zFpWgV01yNrPXrDWCOra195rPfroo27gNdXm6iSBmlt7fZRVu65+5erfrL7O4e9d9+mkxaFGOc+qzLwvNWVX+YTXBGs/apA2bVuRIkUy/XqZmdZMfe1Vm592UDINqPbzzz+7vtcHo21W+akcAQDRiZprAEC+p1GoVVuaXq1gZilQqwZx0qRJEbXIGmRKtZ1Dhw510yeF91n2HHXUUa62W/2O1XRawU5hPG2TZvW3VbjTQFiqGVeY00BW6outwdnS49X6KuArpKrWVbQ9nTt3djXR48ePdwOPSWJiYrpN3hWMFeDUN1u15x6FdL225vPW6NkKzQq8Csh6H3o9TUX19ttvu77heh21ElDNsGqpvVrssWPHuub5el/qi62+8Kqt1YkHXWuU7aeffto1t1ZYV9DWba1Hzdpz2qHeV69evWzWrFlupHaVicK09qPCrrY9K1RGOumh40QnUDIK4Cp/HWcagE/92Ldu3epOrKgWXYO6HYxOcqjvf2ZbOAAA8h9qrgEA+Z7Cm5puZ5eaMKuWU+EnbThSX2g1Z9aAXgraCsTp0ZRM6mOsgKbgpr7KN910U8QyGuRLfZJVC6nwp/7cqo1UME07aJZHg7WpJlXBVc9VMNWo5Apzej3Nra2m6N582AdrGq7BvHQSInz+bYVN9TNX7bGa16sZuAYl85rB63VVa61m4ZoCTKNoK7Redtllbhu0PzSAmfaRRk3Xe9d+VAjUfvWaQyvkal0aLE7brT7tOlmh/XWw/uzZdaj3pRYDb731lmuSrinRVLaqedc2q/l7VmggOtXC630psGdEIV+jmGtQOG3T8OHDXX91zV8d3j8/LZWXBmDzRh4HAESnmFBmRuwAAAD5nmqaFZQVJFVziujwzjvvuJMCn3322SEHrgMA5F/UXAMAEBCqTdb0VKoBz6gGHvmL13VALQII1gAQ3QjXAAAEyOWXX+4GQlPzbuR/KqfKlSu7cgMARDeahQMAAAAA4BM11wAAAAAA+ES4BgAAAADAJ8I1AAAAAAA+Ea4BAAAAAPCJcA0AAAAAgE+EawAAAAAAfCJcAwAAAADgE+EaAAAAAACfCNcAAAAAAJg//wcjPXLrM5EhWQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(10, 7))\n", + "vp = volc.to_pandas()\n", + "injected = {\"CRP\", \"IL6\", \"TNF\"}\n", + "is_inj = vp[\"protein\"].isin(injected)\n", + "\n", + "ax.scatter(vp.loc[~is_inj, \"delta\"], vp.loc[~is_inj, \"neg_log10_p\"],\n", + " color=\"grey\", alpha=0.6, s=40, edgecolor=\"k\", linewidth=0.3,\n", + " label=\"other\")\n", + "ax.scatter(vp.loc[is_inj, \"delta\"], vp.loc[is_inj, \"neg_log10_p\"],\n", + " color=\"crimson\", s=110, edgecolor=\"k\", linewidth=0.6,\n", + " label=\"injected biomarker\")\n", + "for _, row in vp[is_inj].iterrows():\n", + " ax.annotate(row[\"protein\"], (row[\"delta\"], row[\"neg_log10_p\"]),\n", + " xytext=(7, 4), textcoords=\"offset points\", fontsize=11,\n", + " fontweight=\"bold\")\n", + "ax.axhline(-np.log10(0.05), color=\"steelblue\", linestyle=\"--\", linewidth=1,\n", + " label=\"p = 0.05\")\n", + "ax.axvline(0, color=\"black\", linewidth=0.5)\n", + "ax.set_xlabel(\"NPX delta (case − control)\")\n", + "ax.set_ylabel(\"-log10(Welch t-test p)\")\n", + "ax.set_title(\"Volcano plot — case vs control differential NPX\")\n", + "ax.legend()\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6338f541", + "metadata": {}, + "source": [ + "## 9. Parquet round-trip\n", + "\n", + "[`write_olink_parquet`](../synthlab/olink.py) and\n", + "[`load_olink_parquet`](../synthlab/olink.py) are the canonical on-disk\n", + "serialisation entrypoints — snappy-compressed, schema-validated." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "60bd83c5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-23T20:15:20.719468Z", + "iopub.status.busy": "2026-04-23T20:15:20.719377Z", + "iopub.status.idle": "2026-04-23T20:15:20.744318Z", + "shell.execute_reply": "2026-04-23T20:15:20.743894Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /var/folders/fm/7t4z124s3kz76r077_dfn7m80000gn/T/tmpzd1rjuxs/olink_demo.parquet\n", + "size : 196 KB\n", + "rows : 23,737\n" + ] + } + ], + "source": [ + "import pathlib\n", + "import tempfile\n", + "\n", + "from synthlab import load_olink_parquet, write_olink_parquet\n", + "\n", + "tmp = pathlib.Path(tempfile.mkdtemp()) / \"olink_demo.parquet\"\n", + "write_olink_parquet(df, tmp)\n", + "round_trip = load_olink_parquet(tmp)\n", + "assert df.equals(round_trip), \"round-trip mismatch\"\n", + "print(f\"wrote {tmp}\")\n", + "print(f\"size : {tmp.stat().st_size // 1024} KB\")\n", + "print(f\"rows : {round_trip.height:,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "0a6279be", + "metadata": {}, + "source": [ + "## 10. Where to next\n", + "\n", + "The simulator is deliberately minimal — the scope of this PR (see [PR\n", + "#2](https://github.com/bschilder/synthlab/pull/2)) is \"smallest viable NPX\n", + "simulator with LOD + plates + group effects\". Follow-up work:\n", + "\n", + "- **Full MAR missingness**: model missingness as a function of sample-level\n", + " covariates (age, QC batch) rather than aliasing to MCAR.\n", + "- **Multi-factor batch effects**: plate x run x operator, with per-factor\n", + " variance components.\n", + "- **Panel-version LOD bridging**: Olink Explore HT vs Explore 3072 have\n", + " different LOD distributions; a bridging mode should allow cross-panel\n", + " simulation.\n", + "- **PEA dilution / matrix effects**: the real [PEA\n", + " assay](https://olink.com/technology/proximity-extension-assay) has a\n", + " noise model that scales with dilution; currently we use a flat per-protein\n", + " sigma.\n", + "\n", + "Tracking discussion in [PR #2](https://github.com/bschilder/synthlab/pull/2);\n", + "please open issues for missing features." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.20" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 456850c..bec1d41 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,13 @@ dependencies = [ aws = [ "boto3>=1.26.0", ] +viz = [ + # Notebook visualisation stack used by notebooks/olink_demo.ipynb. + "matplotlib>=3.8", + "seaborn>=0.13", + "scikit-learn>=1.5", + "umap-learn>=0.5", +] genomics = [ "numpy>=1.20.0", ] diff --git a/synthlab/__init__.py b/synthlab/__init__.py index 121106f..322a079 100644 --- a/synthlab/__init__.py +++ b/synthlab/__init__.py @@ -155,6 +155,16 @@ print_meds_info, ) +# Olink NPX proteomics simulator +from synthlab.olink import ( + OlinkPanelConfig, + OlinkSimConfig, + default_explore_3072_panel, + load_olink_parquet, + simulate_olink_npx, + write_olink_parquet, +) + from synthlab.coherent import ( list_coherent_components, list_coherent_files, @@ -357,4 +367,11 @@ def _print_banner(): "get_meds_cache_dir", "get_meds_info", "print_meds_info", + # Olink NPX proteomics simulator + "OlinkPanelConfig", + "OlinkSimConfig", + "default_explore_3072_panel", + "load_olink_parquet", + "simulate_olink_npx", + "write_olink_parquet", ] diff --git a/synthlab/olink.py b/synthlab/olink.py new file mode 100644 index 0000000..aef5ef5 --- /dev/null +++ b/synthlab/olink.py @@ -0,0 +1,399 @@ +"""Olink-NPX proteomics simulator. + +Simulate case/control Olink proteomics data (subject x protein -> NPX) +with limit-of-detection (LOD) driven missingness, group effects, and +per-plate batch effects. NPX ("Normalized Protein eXpression") is +Olink's log2 relative quantification unit used across all +[Olink Explore](https://olink.com/products/olink-explore) panels. + +As of 2026-04 there is no widely-used open-source Olink simulator; +closest analogues are +[MSstatsSampleSize](https://bioconductor.org/packages/MSstatsSampleSize/) +(LC-MS/MS, not NPX) and +[OlinkAnalyze](https://github.com/Olink-Proteomics/OlinkRPackage) (NPX +demo tables, no simulator). Priors are informed by the +[UKB-PPP paper](https://www.nature.com/articles/s41586-023-06592-6) +(Sun et al. 2023, 2,923 proteins x ~54k participants) and the +OlinkAnalyze ``npx_data1`` / ``npx_data2`` tables. + +Model: ``NPX[i, j] = mean[j] + plate_eff[i] + group_shift[i, j] + eps`` +with ``plate_eff ~ N(0, plate_effect_sd^2)`` (96 samples / plate) and +``eps ~ N(0, sd[j]^2)``. ``mnar_lod`` drops 80% of sub-LOD values +(soft LOD); ``mcar``/``mar`` add uniform ``missing_rate`` drop (MAR +currently aliases MCAR). Full MAR, multi-plate batch effects, and a +realistic PEA dilution noise model are deferred to a follow-up. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path +from typing import Literal, Mapping, Sequence + +import numpy as np +import polars as pl + +__all__ = [ + "OlinkPanelConfig", + "OlinkSimConfig", + "simulate_olink_npx", + "default_explore_3072_panel", + "write_olink_parquet", + "load_olink_parquet", +] + +# 50 protein symbols drawn from UKB-PPP Explore 3072 — illustrative mix of +# inflammation / cardiovascular / oncology markers. Downstream users should +# override with biologically-relevant subsets where needed. +_DEFAULT_PANEL_PROTEINS: tuple[str, ...] = ( + "CRP", "IL6", "TNF", "IL1B", "IL10", "IL8", "IFNG", "IL17A", "BNP", + "NT-proBNP", "TROPT", "TROPI", "LEP", "ADIPOQ", "GDF15", "NEFL", "TAU", + "AB42", "AB40", "NRGN", "PSA", "CA125", "CEA", "AFP", "CA199", "VEGFA", + "PDGFA", "FGF2", "EGF", "HGF", "TGFB1", "BMP2", "IGF1", "IGFBP3", "INS", + "GLP1", "GIP", "GHRL", "CORT", "FABP4", "APOA1", "APOB", "LDLR", "PCSK9", + "MMP9", "MMP2", "TIMP1", "SERPINE1", "VWF", "FGB", +) + + +def _unique_preserve_order(items: Sequence[str]) -> tuple[str, ...]: + """De-duplicate ``items`` while preserving first-seen order. + + Parameters + ---------- + items : Sequence[str] + Strings that may contain duplicates. + + Returns + ------- + tuple[str, ...] + First-occurrence order preserved. + """ + seen: set[str] = set() + return tuple(x for x in items if not (x in seen or seen.add(x))) + + +@dataclass(frozen=True) +class OlinkPanelConfig: + """An Olink panel specification — proteins + per-protein priors. + + Built-in presets (:func:`default_explore_3072_panel`) hard-code + priors from the UKB-PPP paper (Sun et al. 2023) and the OlinkAnalyze + ``npx_data1`` / ``npx_data2`` demo tables: NPX ~ ``N(mean, sd^2)`` + with ``mean ~ 5`` log2-units, ``sd ~ 0.6``, ``lod ~ mean - 2*sd``. + + Attributes + ---------- + name : str + Panel label, e.g. ``"explore_3072"`` / ``"explore_ht"`` / custom. + proteins : tuple[str, ...] + Ordered tuple of protein IDs (UniProt IDs or gene symbols); + duplicates rejected. + lod : Mapping[str, float] + Per-protein limit of detection on the NPX scale; values below + LOD are candidates for ``mnar_lod`` missingness. + mean : Mapping[str, float] + Per-protein baseline NPX mean. + sd : Mapping[str, float] + Per-protein NPX stddev (must be ``> 0``). + """ + + name: str + proteins: tuple[str, ...] + lod: Mapping[str, float] + mean: Mapping[str, float] + sd: Mapping[str, float] + + def __post_init__(self) -> None: + """Validate uniqueness, key coverage, and ``sd > 0``.""" + if len(set(self.proteins)) != len(self.proteins): + raise ValueError("OlinkPanelConfig.proteins must be unique.") + miss_l = [p for p in self.proteins if p not in self.lod] + miss_m = [p for p in self.proteins if p not in self.mean] + miss_s = [p for p in self.proteins if p not in self.sd] + if miss_l or miss_m or miss_s: + raise ValueError( + f"OlinkPanelConfig missing lod={miss_l}, " + f"mean={miss_m}, sd={miss_s}." + ) + for p in self.proteins: + if self.sd[p] <= 0: + raise ValueError( + f"OlinkPanelConfig.sd[{p!r}] must be > 0; got {self.sd[p]}." + ) + + +@dataclass(frozen=True) +class OlinkSimConfig: + """Configuration for :func:`simulate_olink_npx`. + + Attributes + ---------- + n_samples : int + Number of subjects to simulate (``>= 0``). + panel : OlinkPanelConfig + Panel specification. + group_effects : Mapping[str, Mapping[str, float]], optional + Per-protein NPX shift per group label, e.g. + ``{"CRP": {"case": 1.2}}``. Proteins not listed get no shift. + group_assignments : Sequence[str], optional + Length-``n_samples`` sequence of group labels; ``None`` means + every sample is labelled ``"baseline"``. + missingness : {"mcar", "mar", "mnar_lod", "none"}, default "mnar_lod" + Missingness model; ``"mar"`` currently aliases ``"mcar"`` (full + MAR is deferred). + missing_rate : float, default 0.05 + Extra MCAR rate on top of LOD-driven missingness; ``[0, 1]``. + qc_warn_rate : float, default 0.01 + Per-row Bernoulli rate for ``qc_warning=True``. + plate_effect_sd : float, default 0.15 + Stddev of the per-plate intercept (96 samples / plate). + seed : int, default 0 + NumPy RNG seed; deterministic under fixed seed. + """ + + n_samples: int + panel: OlinkPanelConfig + group_effects: Mapping[str, Mapping[str, float]] = field(default_factory=dict) + group_assignments: Sequence[str] | None = None + missingness: Literal["mcar", "mar", "mnar_lod", "none"] = "mnar_lod" + missing_rate: float = 0.05 + qc_warn_rate: float = 0.01 + plate_effect_sd: float = 0.15 + seed: int = 0 + + def __post_init__(self) -> None: + """Validate scalar bounds and ``group_assignments`` length.""" + if self.n_samples < 0: + raise ValueError(f"n_samples must be >= 0; got {self.n_samples}.") + if not (0.0 <= self.missing_rate <= 1.0): + raise ValueError(f"missing_rate must be in [0, 1]; got {self.missing_rate}.") + if not (0.0 <= self.qc_warn_rate <= 1.0): + raise ValueError(f"qc_warn_rate must be in [0, 1]; got {self.qc_warn_rate}.") + if self.plate_effect_sd < 0: + raise ValueError(f"plate_effect_sd must be >= 0; got {self.plate_effect_sd}.") + if self.missingness not in {"mcar", "mar", "mnar_lod", "none"}: + raise ValueError( + f"missingness must be one of 'mcar'/'mar'/'mnar_lod'/'none'; " + f"got {self.missingness!r}." + ) + if ( + self.group_assignments is not None + and len(self.group_assignments) != self.n_samples + ): + raise ValueError( + f"group_assignments length ({len(self.group_assignments)}) " + f"must equal n_samples ({self.n_samples})." + ) + + +_SCHEMA: dict[str, pl.DataType] = { + "sample_id": pl.Utf8, + "protein_id": pl.Utf8, + "npx": pl.Float64, + "qc_warning": pl.Boolean, + "group": pl.Utf8, + "plate_id": pl.Utf8, +} + + +def simulate_olink_npx(config: OlinkSimConfig) -> pl.DataFrame: + """Simulate an Olink-style long-form NPX DataFrame. + + Pipeline: (1) assign each sample a plate (96 per plate, in order); + (2) draw plate intercepts ``~ N(0, plate_effect_sd**2)``; (3) per + cell, ``npx = mean[p] + plate_eff + group_effect[p][group] + eps`` + with ``eps ~ N(0, sd[p]**2)``; (4) apply missingness — ``mnar_lod`` + drops 80% of sub-LOD values (soft LOD), ``mcar`` adds uniform + ``missing_rate`` drop, ``mar`` aliases ``mcar``, ``none`` skips; + (5) flag Bernoulli ``qc_warn_rate`` QC warnings on surviving rows. + Deterministic under fixed seed. + + Parameters + ---------- + config : OlinkSimConfig + Full simulation spec. + + Returns + ------- + polars.DataFrame + Long-form frame with columns ``sample_id`` (``str``), + ``protein_id`` (``str``), ``npx`` (``f64``), ``qc_warning`` + (``bool``), ``group`` (``str``), ``plate_id`` (``str``). + + Examples + -------- + >>> from synthlab.olink import default_explore_3072_panel + >>> cfg = OlinkSimConfig(n_samples=3, panel=default_explore_3072_panel(), seed=1) + >>> df = simulate_olink_npx(cfg) + >>> sorted(df.columns) + ['group', 'npx', 'plate_id', 'protein_id', 'qc_warning', 'sample_id'] + """ + panel = config.panel + n_proteins = len(panel.proteins) + n = config.n_samples + if n == 0 or n_proteins == 0: + return pl.DataFrame(schema=_SCHEMA) + rng = np.random.default_rng(config.seed) + sample_ids = np.array([f"S{i:04d}" for i in range(n)], dtype=object) + plate_idx = np.arange(n) // 96 + plate_labels = np.array([f"plate_{p}" for p in plate_idx], dtype=object) + groups = ( + np.full(n, "baseline", dtype=object) + if config.group_assignments is None + else np.array(list(config.group_assignments), dtype=object) + ) + # Plate intercepts per sample. + n_plates = int(plate_idx.max()) + 1 + plate_intercepts = ( + rng.normal(0.0, config.plate_effect_sd, size=n_plates) + if config.plate_effect_sd > 0 + else np.zeros(n_plates, dtype=np.float64) + ) + plate_eff = plate_intercepts[plate_idx] + # Per-protein priors in panel.proteins order. + mean_vec = np.array([panel.mean[p] for p in panel.proteins], dtype=np.float64) + sd_vec = np.array([panel.sd[p] for p in panel.proteins], dtype=np.float64) + lod_vec = np.array([panel.lod[p] for p in panel.proteins], dtype=np.float64) + # Group shift matrix; nonzero only for (protein, group) pairs in config. + group_shift = np.zeros((n, n_proteins), dtype=np.float64) + for j, p in enumerate(panel.proteins): + mapping = config.group_effects.get(p) + if not mapping: + continue + for i, g in enumerate(groups): + if g in mapping: + group_shift[i, j] = mapping[g] + # NPX = mean + plate + group + eps. + eps = rng.standard_normal(size=(n, n_proteins)) * sd_vec + npx = mean_vec[np.newaxis, :] + plate_eff[:, np.newaxis] + group_shift + eps + # Missingness masks. + keep = np.ones_like(npx, dtype=bool) + if config.missingness == "mnar_lod": + below_lod = npx < lod_vec[np.newaxis, :] + keep &= ~(below_lod & (rng.random(size=npx.shape) < 0.8)) + if ( + config.missingness in {"mcar", "mar", "mnar_lod"} + and config.missing_rate > 0 + ): + keep &= ~(rng.random(size=npx.shape) < config.missing_rate) + # Flatten (row-major), mask, build frame. + flat_keep = keep.reshape(-1) + flat_samples = np.repeat(sample_ids, n_proteins) + flat_plates = np.repeat(plate_labels, n_proteins) + flat_groups = np.repeat(groups, n_proteins) + flat_proteins = np.tile(np.asarray(panel.proteins, dtype=object), n) + flat_npx = npx.reshape(-1) + n_kept = int(flat_keep.sum()) + qc_flags = ( + rng.random(size=n_kept) < config.qc_warn_rate + if n_kept > 0 and config.qc_warn_rate > 0 + else np.zeros(n_kept, dtype=bool) + ) + return pl.DataFrame( + { + "sample_id": pl.Series("sample_id", flat_samples[flat_keep], dtype=pl.Utf8), + "protein_id": pl.Series("protein_id", flat_proteins[flat_keep], dtype=pl.Utf8), + "npx": pl.Series("npx", flat_npx[flat_keep], dtype=pl.Float64), + "qc_warning": pl.Series("qc_warning", qc_flags, dtype=pl.Boolean), + "group": pl.Series("group", flat_groups[flat_keep], dtype=pl.Utf8), + "plate_id": pl.Series("plate_id", flat_plates[flat_keep], dtype=pl.Utf8), + } + ) + + +def default_explore_3072_panel( + mean: float = 5.0, + sd: float = 0.6, + lod: float = 3.0, +) -> OlinkPanelConfig: + """Return an :class:`OlinkPanelConfig` mirroring Olink Explore 3072. + + Uses 50 named proteins — a tiny subset of the real 3,072-plex panel + chosen for test stability. Priors reflect aggregate UKB-PPP NPX + statistics (Sun et al. 2023) and the OlinkAnalyze ``npx_data1`` / + ``npx_data2`` demo tables: NPX ~ ``N(5, 0.6^2)``, LOD typically + ``mean - 2*sd``. + + Parameters + ---------- + mean : float, default 5.0 + Baseline NPX mean applied to every protein. + sd : float, default 0.6 + NPX stddev applied to every protein (``> 0``). + lod : float, default 3.0 + Limit of detection applied to every protein. + + Returns + ------- + OlinkPanelConfig + 50-protein panel with name ``"explore_3072"``. + """ + proteins = _unique_preserve_order(_DEFAULT_PANEL_PROTEINS) + if len(proteins) < 50: + proteins += tuple(f"PROT{i:04d}" for i in range(50 - len(proteins))) + elif len(proteins) > 50: + proteins = proteins[:50] + return OlinkPanelConfig( + name="explore_3072", + proteins=proteins, + lod={p: float(lod) for p in proteins}, + mean={p: float(mean) for p in proteins}, + sd={p: float(sd) for p in proteins}, + ) + + +def write_olink_parquet(df: pl.DataFrame, path: str | Path) -> Path: + """Write an Olink NPX DataFrame to parquet (snappy compression). + + Parameters + ---------- + df : polars.DataFrame + Long-form NPX DataFrame — typically the output of + :func:`simulate_olink_npx`. + path : str or pathlib.Path + Output path; parent directory is created if absent. + + Returns + ------- + pathlib.Path + The resolved output path. + """ + out = Path(path).expanduser() + out.parent.mkdir(parents=True, exist_ok=True) + df.write_parquet(out, compression="snappy") + return out + + +def load_olink_parquet(path: str | Path) -> pl.DataFrame: + """Load an Olink NPX parquet and validate its schema. + + Parameters + ---------- + path : str or pathlib.Path + Path to a parquet file written by :func:`write_olink_parquet`. + + Returns + ------- + polars.DataFrame + DataFrame with the canonical Olink NPX schema: ``sample_id``, + ``protein_id``, ``npx``, ``qc_warning``, ``group``, + ``plate_id``. + + Raises + ------ + FileNotFoundError + If ``path`` does not exist. + ValueError + If the loaded frame is missing expected columns. + """ + p = Path(path).expanduser() + if not p.is_file(): + raise FileNotFoundError(f"Olink parquet not found: {p}") + df = pl.read_parquet(p) + missing = [c for c in _SCHEMA if c not in df.columns] + if missing: + raise ValueError( + f"Olink parquet at {p} missing expected columns: {missing}. " + f"Found: {df.columns}." + ) + return df diff --git a/tests/test_olink.py b/tests/test_olink.py new file mode 100644 index 0000000..94e3025 --- /dev/null +++ b/tests/test_olink.py @@ -0,0 +1,301 @@ +"""Unit tests for :mod:`synthlab.olink`. + +Covers determinism, the group-effects model, LOD-driven missingness, +MCAR overlay, plate intercepts, QC warning rate, parquet round-trip, +and empty-frame edge cases. No network / filesystem heavy dependencies +— everything runs on in-memory polars DataFrames. +""" + +from __future__ import annotations + +import pytest + +pl = pytest.importorskip("polars") +np = pytest.importorskip("numpy") + +from synthlab.olink import ( + OlinkPanelConfig, + OlinkSimConfig, + default_explore_3072_panel, + load_olink_parquet, + simulate_olink_npx, + write_olink_parquet, +) + + +# --------------------------------------------------------------------------- +# Panel helpers +# --------------------------------------------------------------------------- + + +def _uniform_panel( + proteins: tuple[str, ...], + mean: float = 5.0, + sd: float = 0.6, + lod: float = 3.0, +) -> OlinkPanelConfig: + """Build a small OlinkPanelConfig with uniform priors across proteins.""" + return OlinkPanelConfig( + name="test", + proteins=proteins, + lod={p: lod for p in proteins}, + mean={p: mean for p in proteins}, + sd={p: sd for p in proteins}, + ) + + +# --------------------------------------------------------------------------- +# Core simulator tests +# --------------------------------------------------------------------------- + + +def test_simulate_is_deterministic_under_seed() -> None: + """Two calls with the same seed return bit-identical DataFrames.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=20, panel=panel, seed=42) + df1 = simulate_olink_npx(cfg) + df2 = simulate_olink_npx(cfg) + assert df1.equals(df2) + + +def test_group_assignments_mean_shift() -> None: + """A +2.0 delta on CRP for "case" group moves the case NPX mean by ~2.0.""" + # Zero plate SD and no LOD loss so the mean is clean to compare. + panel = _uniform_panel(("CRP", "IL6"), mean=5.0, sd=0.5, lod=-1000.0) + assignments = ["case"] * 500 + ["control"] * 500 + cfg = OlinkSimConfig( + n_samples=1000, + panel=panel, + group_effects={"CRP": {"case": 2.0}}, + group_assignments=assignments, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=1, + ) + df = simulate_olink_npx(cfg) + crp = df.filter(pl.col("protein_id") == "CRP") + case_mean = crp.filter(pl.col("group") == "case")["npx"].mean() + ctrl_mean = crp.filter(pl.col("group") == "control")["npx"].mean() + delta = case_mean - ctrl_mean + # With sd=0.5, n=500 per arm, SE of the difference ~ 0.5 * sqrt(2/500) ~ 0.032. + # Shift should be ~ 2.0 within 2 standard errors. + assert abs(delta - 2.0) < 0.1, f"expected ~2.0 shift; got {delta:.3f}" + + +def test_lod_missingness_kicks_in() -> None: + """With mean << lod, >60% of rows are dropped under mnar_lod.""" + # mean=1.0, lod=2.0, sd=0.5 → most values fall below LOD. + panel = _uniform_panel(("CRP", "IL6"), mean=1.0, sd=0.5, lod=2.0) + cfg = OlinkSimConfig( + n_samples=200, + panel=panel, + missingness="mnar_lod", + missing_rate=0.0, # isolate LOD effect + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=7, + ) + df = simulate_olink_npx(cfg) + kept = df.height + total = 200 * 2 + drop_rate = 1 - kept / total + assert drop_rate > 0.6, ( + f"expected >60% LOD drop with mean << lod; got {drop_rate:.2f}" + ) + + +def test_mcar_missingness_adds_rate() -> None: + """With missing_rate=0.3 on top of LOD, observed drop exceeds 0.3.""" + panel = _uniform_panel(("CRP", "IL6"), mean=5.0, sd=0.3, lod=3.0) + cfg = OlinkSimConfig( + n_samples=300, + panel=panel, + missingness="mnar_lod", + missing_rate=0.3, + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=11, + ) + df = simulate_olink_npx(cfg) + drop_rate = 1 - df.height / (300 * 2) + # LOD contributes a tiny bit since mean=5, lod=3 → ~0 sub-LOD; MCAR + # contributes ~0.3. Combined rate should exceed 0.3. + assert drop_rate > 0.3, f"expected drop > 0.3; got {drop_rate:.3f}" + + +def test_plate_effects_vary_by_plate() -> None: + """2 plates (192 samples) get different means at non-zero plate_effect_sd.""" + panel = _uniform_panel(("CRP",), mean=5.0, sd=0.2, lod=-1000.0) + cfg_off = OlinkSimConfig( + n_samples=192, + panel=panel, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=0.0, + seed=3, + ) + df_off = simulate_olink_npx(cfg_off) + p0_off = df_off.filter(pl.col("plate_id") == "plate_0")["npx"].mean() + p1_off = df_off.filter(pl.col("plate_id") == "plate_1")["npx"].mean() + # With plate_effect_sd=0 the two plate means are independent samples + # from the same protein noise — their difference is small but may be + # nonzero from the Gaussian noise. We check that plates EXIST. + assert p0_off is not None and p1_off is not None + + # With plate_effect_sd=1.0 the plates typically differ by > 0.2 (most + # draws from |N(0,1) - N(0,1)| exceed 0.2 by a wide margin). + cfg_on = OlinkSimConfig( + n_samples=192, + panel=panel, + missingness="none", + qc_warn_rate=0.0, + plate_effect_sd=1.0, + seed=3, + ) + df_on = simulate_olink_npx(cfg_on) + p0_on = df_on.filter(pl.col("plate_id") == "plate_0")["npx"].mean() + p1_on = df_on.filter(pl.col("plate_id") == "plate_1")["npx"].mean() + assert abs(p0_on - p1_on) > abs(p0_off - p1_off), ( + "plate_effect_sd=1.0 should produce larger inter-plate spread " + f"than 0.0; got |{p0_on - p1_on}| vs |{p0_off - p1_off}|" + ) + + +def test_qc_warning_bernoulli() -> None: + """qc_warn_rate=0.1 yields ~10% qc_warning=True rows (within tolerance).""" + panel = _uniform_panel(("CRP", "IL6", "TNF"), mean=5.0, sd=0.2, lod=-1000.0) + cfg = OlinkSimConfig( + n_samples=500, + panel=panel, + missingness="none", + qc_warn_rate=0.1, + plate_effect_sd=0.0, + seed=13, + ) + df = simulate_olink_npx(cfg) + observed = df["qc_warning"].sum() / df.height + # With 1500 rows, expected SE ~ sqrt(0.1 * 0.9 / 1500) ~ 0.008. Allow 3 SE. + assert abs(observed - 0.1) < 0.03, ( + f"qc_warning rate out of tolerance: {observed:.4f}" + ) + + +def test_parquet_roundtrip(tmp_path) -> None: + """write then load returns a frame bit-equivalent to the source.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=12, panel=panel, seed=5) + df = simulate_olink_npx(cfg) + out = write_olink_parquet(df, tmp_path / "npx.parquet") + assert out.is_file() + loaded = load_olink_parquet(out) + assert loaded.equals(df) + + +def test_schema_types() -> None: + """Column dtypes are (str, str, f64, bool, str, str) in that order.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=3, panel=panel, seed=1) + df = simulate_olink_npx(cfg) + assert df.columns == [ + "sample_id", + "protein_id", + "npx", + "qc_warning", + "group", + "plate_id", + ] + assert df.dtypes == [pl.Utf8, pl.Utf8, pl.Float64, pl.Boolean, pl.Utf8, pl.Utf8] + + +def test_default_panel_sizes() -> None: + """Default panel has exactly 50 proteins and complete lod/mean/sd maps.""" + panel = default_explore_3072_panel() + assert panel.name == "explore_3072" + assert len(panel.proteins) == 50 + assert len(set(panel.proteins)) == 50 # unique + for p in panel.proteins: + assert p in panel.lod + assert p in panel.mean + assert p in panel.sd + + +def test_empty_samples() -> None: + """n_samples=0 returns an empty frame with the canonical schema.""" + panel = default_explore_3072_panel() + cfg = OlinkSimConfig(n_samples=0, panel=panel, seed=1) + df = simulate_olink_npx(cfg) + assert df.shape == (0, 6) + assert df.columns == [ + "sample_id", + "protein_id", + "npx", + "qc_warning", + "group", + "plate_id", + ] + + +# --------------------------------------------------------------------------- +# Config validation +# --------------------------------------------------------------------------- + + +def test_panel_rejects_duplicates() -> None: + """Duplicate protein IDs are rejected in __post_init__.""" + with pytest.raises(ValueError, match="unique"): + OlinkPanelConfig( + name="bad", + proteins=("CRP", "CRP"), + lod={"CRP": 3.0}, + mean={"CRP": 5.0}, + sd={"CRP": 0.6}, + ) + + +def test_panel_rejects_nonpositive_sd() -> None: + """sd <= 0 raises.""" + with pytest.raises(ValueError, match="sd"): + OlinkPanelConfig( + name="bad", + proteins=("CRP",), + lod={"CRP": 3.0}, + mean={"CRP": 5.0}, + sd={"CRP": 0.0}, + ) + + +def test_sim_config_rejects_bad_missingness() -> None: + """Unknown missingness mode is rejected.""" + panel = default_explore_3072_panel() + with pytest.raises(ValueError, match="missingness"): + OlinkSimConfig( + n_samples=10, + panel=panel, + missingness="bogus", # type: ignore[arg-type] + ) + + +def test_sim_config_rejects_mismatched_assignments() -> None: + """group_assignments length must match n_samples.""" + panel = default_explore_3072_panel() + with pytest.raises(ValueError, match="group_assignments"): + OlinkSimConfig( + n_samples=5, + panel=panel, + group_assignments=["case", "control"], + ) + + +def test_load_parquet_missing_file(tmp_path) -> None: + """load_olink_parquet raises FileNotFoundError on a missing path.""" + with pytest.raises(FileNotFoundError): + load_olink_parquet(tmp_path / "nope.parquet") + + +def test_load_parquet_bad_schema(tmp_path) -> None: + """A parquet without the expected columns triggers ValueError.""" + bad = tmp_path / "bad.parquet" + pl.DataFrame({"foo": [1, 2, 3]}).write_parquet(bad) + with pytest.raises(ValueError, match="missing expected columns"): + load_olink_parquet(bad)