From 35ebb8a3703d16a5423e8312afbaa09eb5c837e5 Mon Sep 17 00:00:00 2001 From: parashardhapola Date: Mon, 26 Oct 2026 23:20:45 +0100 Subject: [PATCH] Add the quick start, Why pseudobulk and the guides to cubes The quick start goes from cells to a cube to differential expression per cell type and a result traced back to its cube; it absorbs the longer tutorial of the same path. "Why pseudobulk" shows, on a split of control samples, how testing cells instead of samples makes false calls. New guides pool cells into profiles (with the dot plot and the PCA), save, share and trace cubes, and work with AnnData and MuData; the quality guide gains the PCA plot. --- .github/workflows/docs.yml | 2 +- docs/coverage_exemptions.toml | 5 - docs/execute_notebooks.py | 24 +- docs/source/differential_expression.ipynb | 830 ------------------ docs/source/guides/anndata_and_mudata.ipynb | 391 +++++++++ docs/source/guides/bulk_rna_seq.ipynb | 35 +- docs/source/guides/export_cubes.ipynb | 49 +- docs/source/guides/genes_per_cell_type.ipynb | 5 +- .../guides/normalization_and_quality.ipynb | 80 +- docs/source/guides/pool_cells.ipynb | 399 +++++++++ docs/source/guides/save_and_trace_cubes.ipynb | 405 +++++++++ docs/source/index.md | 10 +- docs/source/myst.yml | 10 +- docs/source/quickstart.ipynb | 796 ++++++----------- docs/source/reference/cube_files.md | 3 +- docs/source/statistics/choosing_a_method.md | 5 +- docs/source/statistics/cubes.md | 3 +- docs/source/why_pseudobulk.ipynb | 363 ++++++++ tests/test_documentation.py | 32 +- 19 files changed, 2052 insertions(+), 1395 deletions(-) delete mode 100644 docs/source/differential_expression.ipynb create mode 100644 docs/source/guides/anndata_and_mudata.ipynb create mode 100644 docs/source/guides/pool_cells.ipynb create mode 100644 docs/source/guides/save_and_trace_cubes.ipynb create mode 100644 docs/source/why_pseudobulk.ipynb diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 33d4892..d5d16ec 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -63,7 +63,7 @@ jobs: - name: Check that saved notebook outputs still match the package # Runs pages that need no downloaded data, without saving them, and fails # when what they print has changed. Add such pages to PAGES. - run: make -C docs check-outputs PAGES="quickstart differential_expression guides/export_cubes guides/bulk_rna_seq guides/composition guides/combine_studies guides/replication_across_studies" + run: make -C docs check-outputs PAGES="quickstart why_pseudobulk guides/pool_cells guides/save_and_trace_cubes guides/export_cubes guides/anndata_and_mudata guides/bulk_rna_seq guides/composition guides/combine_studies guides/replication_across_studies" - name: Store the site if: ${{ !inputs.pages }} uses: actions/upload-artifact@v7 diff --git a/docs/coverage_exemptions.toml b/docs/coverage_exemptions.toml index 3120d61..926beec 100644 --- a/docs/coverage_exemptions.toml +++ b/docs/coverage_exemptions.toml @@ -60,10 +60,5 @@ "cytepool.table.Table.to_dict" = "a method of CytePool's minimal table of columns, documented in the API reference; the guides show the common ones" [planned] -"cytepool.table.Table.select" = "guides/pool_cells: sample and group tables" -"cytepool.table.Table.filter" = "guides/pool_cells: sample and group tables" -"cytepool.table.Table.with_columns" = "guides/pool_cells: sample and group tables" "cytepool.plotting.plot_dispersions" = "guides/bulk_rna_seq: DESeq2's dispersion estimates" -"cytepool.plotting.plot_pca" = "guides/normalization_and_quality and guides/bulk_rna_seq: samples on their principal components" -"cytepool.plotting.plot_dotplot" = "guides/pool_cells: the markers of each cell type as a dot plot, from the cube" "cytepool.plotting.plot_quasi_dispersions" = "guides/bulk_rna_seq: edgeR's quasi-dispersions" diff --git a/docs/execute_notebooks.py b/docs/execute_notebooks.py index 59c54ec..a26a9fe 100644 --- a/docs/execute_notebooks.py +++ b/docs/execute_notebooks.py @@ -17,8 +17,11 @@ the text they print differs from the saved outputs, as it does when a change to the package changed their results. Figures and standard error are not compared, and neither is CytePool's own version, which changes with every commit of a development -version and which a page can print, for example in a cube's history: the saved text is -compared with the version that ran it replaced by the version running now. +version and which a page can print: the saved text is compared with the version that +ran it replaced by the version running now, and a version written after "CytePool ", +as a cube's history writes the version that built it, is left out of both. A dataset +prepared before the page ran was built by another version, and on CI every dataset is +built again by the version being checked. Usage, from the repository root:: @@ -31,6 +34,7 @@ import argparse import copy +import re import tempfile import time from datetime import UTC, datetime @@ -155,18 +159,30 @@ def printed_text(notebook: nbformat.NotebookNode) -> list[str]: return texts +# A version of CytePool where printed text names it, as in "CytePool 0.1.dev42+g6991e63f8". +_NAMED_VERSION = re.compile( + r"(?<=CytePool )\d+(?:\.\d+)*(?:(?:a|b|rc|\.dev|\.post)\d+)*(?:\+[0-9A-Za-z.]+)?" +) + + def differences( saved: list[str], fresh: list[str], saved_version: str | None, version: str ) -> list[str]: """The code cells whose printed text differs, other than in CytePool's version. ``saved_version`` is the version that ran the saved notebook (None if it was - not recorded) and ``version`` the one that ran it again. + not recorded) and ``version`` the one that ran it again. A version written after + "CytePool " is left out of both texts. """ + + def compared(text: str) -> str: + return _NAMED_VERSION.sub("", text) + return [ f"code cell {number}: saved {old!r}, now {new!r}" for number, (old, new) in enumerate(zip(saved, fresh, strict=True), start=1) - if (old.replace(saved_version, version) if saved_version else old) != new + if compared(old.replace(saved_version, version) if saved_version else old) + != compared(new) ] diff --git a/docs/source/differential_expression.ipynb b/docs/source/differential_expression.ipynb deleted file mode 100644 index 370bad1..0000000 --- a/docs/source/differential_expression.ipynb +++ /dev/null @@ -1,830 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7cf5ec65", - "metadata": {}, - "source": [ - "(differential-expression-tutorial)=\n", - "# From cells to results\n", - "\n", - "This page runs a pseudobulk differential-expression analysis from cells to results:\n", - "it simulates single cells from six donors, each sampled before and after a\n", - "stimulation, pools them into a cube of counts per sample and cell type, saves the cube\n", - "and opens it again, tests the stimulation in every cell type with limma-voom, and then\n", - "follows one result back through its provenance record to the profiles of the cube that\n", - "produced it. Every step of the test matches limma and edgeR, as the\n", - "[Validation](validation.md#differential-expression) page shows, also on\n", - "[published single-cell data](validation.md#differential-expression-on-published-data).\n", - "\n", - "Pooling the cells of each sample first makes the sample, not the cell, the unit of\n", - "replication: cells from one donor are not independent observations, and a test that\n", - "treated them as such would find differences that do not hold across donors.\n", - "\n", - "The guides of Compare conditions take each question further, with the choices it\n", - "involves; [Genes that change in each cell type](guides/genes_per_cell_type.ipynb)\n", - "runs this analysis on published data." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "ebd69b1a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numpy 2.5.4 and numba 0.68.0\n" - ] - } - ], - "source": [ - "import json\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numba\n", - "import numpy as np\n", - "\n", - "from cytepool.cube import from_cells\n", - "from cytepool.design import Design\n", - "from cytepool.differential_expression import limma_voom\n", - "from cytepool.io import read_cube, write_cube\n", - "from cytepool.table import Table\n", - "\n", - "print(\"numpy\", np.__version__, \"and numba\", numba.__version__)" - ] - }, - { - "cell_type": "markdown", - "id": "e40d2f23", - "metadata": {}, - "source": [ - "## Simulate cells from six donors\n", - "\n", - "Six donors (D1 to D6) each give a control and a stimulated sample: twelve samples in a\n", - "paired design. Every sample holds four cell types in different numbers: many T cells,\n", - "fewer B and NK cells, and few dendritic cells (DC). Donor D1 has almost no NK cells.\n", - "\n", - "Each cell type has its own expression profile over 1,500 genes. A donor shifts every\n", - "gene a little, in all its samples alike, and the stimulation changes 150 genes of each\n", - "cell type, a different set for each, by 0.8 to 2 on the log2 scale. Cells differ in\n", - "depth, 1,500 to 6,000 reads, and in their expression around the profile." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "63d7699f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2,987 cells x 1,500 genes\n" - ] - } - ], - "source": [ - "rng = np.random.default_rng(20261025)\n", - "donors = [f\"D{d}\" for d in range(1, 7)]\n", - "sample_table = Table(\n", - " {\n", - " \"sample_id\": [f\"{d}_{c}\" for d in donors for c in (\"ctrl\", \"stim\")],\n", - " \"donor\": np.repeat(donors, 2),\n", - " \"condition\": np.tile([\"ctrl\", \"stim\"], 6),\n", - " }\n", - ")\n", - "n_genes = 1_500\n", - "genes = np.array([f\"gene_{g:04d}\" for g in range(n_genes)])\n", - "mean_cells = {\"T\": 150, \"B\": 60, \"NK\": 35, \"DC\": 8}\n", - "donor_shift = {d: rng.normal(0.0, 0.3, n_genes) for d in donors}\n", - "\n", - "true_log2_fc = {}\n", - "blocks, cell_sample, cell_type = [], [], []\n", - "for name, mean in mean_cells.items():\n", - " profile = rng.normal(0.0, 1.8, n_genes)\n", - " changed = rng.choice(n_genes, 150, replace=False)\n", - " effect = np.zeros(n_genes)\n", - " effect[changed] = rng.choice([-1, 1], 150) * rng.uniform(0.8, 2.0, 150)\n", - " true_log2_fc[name] = effect\n", - " for sample_id, donor, condition in zip(\n", - " sample_table[\"sample_id\"], sample_table[\"donor\"], sample_table[\"condition\"]\n", - " ):\n", - " n = rng.poisson(mean) if not (name == \"NK\" and donor == \"D1\") else 3\n", - " log2_mean = profile + donor_shift[donor] + effect * (condition == \"stim\")\n", - " proportion = 2.0**log2_mean / np.sum(2.0**log2_mean)\n", - " depth = rng.uniform(1_500, 6_000, (n, 1))\n", - " rate = rng.gamma(4.0, 0.25, (n, n_genes)) * depth * proportion\n", - " blocks.append(rng.poisson(rate))\n", - " cell_sample += [sample_id] * n\n", - " cell_type += [name] * n\n", - "counts = np.vstack(blocks)\n", - "print(f\"{counts.shape[0]:,} cells x {counts.shape[1]:,} genes\")" - ] - }, - { - "cell_type": "markdown", - "id": "122db0bc", - "metadata": {}, - "source": [ - "## Pool the cells into a cube\n", - "\n", - "[`from_cells`](/api/cubes.html#cytepool.cube.from_cells) sums the counts of the cells of\n", - "every sample and cell type into a cube: one pseudobulk profile per sample and cell\n", - "type, with the number of cells behind each. The sample table travels with the cube,\n", - "and so does a provenance record: how the cube was built, and a record of where the\n", - "cells came from, `source`, which the caller gives and CytePool keeps as it is." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "387e3875", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cube with 12 samples x 4 groups x 1,500 features\n", - " layers: counts (uint32)\n", - " filled: 48 of 48 sample x group entries have cells (100.0%)\n", - " samples: sample_id, donor, condition\n", - " groups: group_id\n", - " features: feature_id\n", - "\n", - "cells per sample and cell type:\n", - " B DC NK T\n", - "D1_ctrl 57 7 3 155\n", - "D1_stim 54 12 3 165\n", - "D2_ctrl 56 8 29 140\n", - "D2_stim 56 9 23 174\n", - "D3_ctrl 56 8 29 144\n", - "D3_stim 60 5 35 170\n", - "D4_ctrl 58 6 24 138\n", - "D4_stim 61 10 41 178\n", - "D5_ctrl 58 7 45 152\n", - "D5_stim 55 15 35 138\n", - "D6_ctrl 53 14 33 156\n", - "D6_stim 59 10 38 145\n" - ] - } - ], - "source": [ - "cube = from_cells(\n", - " counts,\n", - " samples=cell_sample,\n", - " groups=cell_type,\n", - " sample_table=sample_table,\n", - " features=genes,\n", - " layers=\"counts\",\n", - " source={\"dataset\": \"simulated study of six donors\", \"seed\": 20261025},\n", - ")\n", - "print(cube)\n", - "print()\n", - "groups = cube.groups[\"group_id\"].tolist()\n", - "print(\"cells per sample and cell type:\")\n", - "print(f\"{'':<9}\" + \"\".join(f\"{group:>6}\" for group in groups))\n", - "for row, sample_id in enumerate(cube.samples[\"sample_id\"]):\n", - " print(f\"{sample_id:<9}\" + \"\".join(f\"{n:>6}\" for n in cube.n_cells[row]))" - ] - }, - { - "cell_type": "markdown", - "id": "aa0be006", - "metadata": {}, - "source": [ - "## Save the cube and open it again\n", - "\n", - "[`write_cube`](/api/cube_files.html#cytepool.io.write_cube) saves the cube as a Zarr\n", - "v3 store, and [`read_cube`](/api/cube_files.html#cytepool.io.read_cube) opens it\n", - "without reading its counts: the layer stays on disk and is read one cell type at a\n", - "time, when the analysis needs it. A cube far larger than memory can therefore be\n", - "analysed group by group.\n", - "\n", - "A cube's fingerprint names its values: its tables, cell numbers and every group of\n", - "every layer. The file stores the digests the fingerprint is built from, so the opened\n", - "cube knows its fingerprint without reading its counts, and it is the in-memory cube's." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "69797fbd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cube with 12 samples x 4 groups x 1,500 features\n", - " layers: counts (uint32, lazy)\n", - " filled: 48 of 48 sample x group entries have cells (100.0%)\n", - " samples: sample_id, donor, condition\n", - " groups: group_id\n", - " features: feature_id\n", - "same fingerprint: True\n" - ] - } - ], - "source": [ - "write_cube(cube, \"pbmc.cube.zarr\", overwrite=True)\n", - "opened = read_cube(\"pbmc.cube.zarr\")\n", - "print(opened)\n", - "print(\"same fingerprint:\", opened.fingerprint() == cube.fingerprint())" - ] - }, - { - "cell_type": "markdown", - "id": "620b9bcf", - "metadata": {}, - "source": [ - "## Describe the design\n", - "\n", - "The design is built from the cube's sample table. `~ donor + condition` compares the\n", - "two samples of each donor, so differences between donors do not count as noise. The\n", - "named contrast `stim_vs_ctrl` is the coefficient of the stimulation.\n", - "[`limma_voom`](/api/differential_expression.html#cytepool.differential_expression.limma_voom)\n", - "matches the design's samples to the cube's by `sample_id`, never by position." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "48c3815b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design: 12 samples x 7 columns, formula '~ donor + condition'\n", - " columns: (Intercept), donorD2, donorD3, donorD4, donorD5, donorD6, conditionstim\n", - " contrasts: stim_vs_ctrl\n", - "Design check: 12 samples, 7 columns, rank 7, 5 residual degrees of freedom; no problems found.\n" - ] - } - ], - "source": [ - "design = Design(\n", - " opened.samples,\n", - " \"~ donor + condition\",\n", - " levels={\"condition\": [\"ctrl\", \"stim\"]},\n", - " contrasts={\"stim_vs_ctrl\": \"conditionstim\"},\n", - ")\n", - "print(design)\n", - "print(design.check())" - ] - }, - { - "cell_type": "markdown", - "id": "c080bd67", - "metadata": {}, - "source": [ - "## Test every cell type\n", - "\n", - "`limma_voom` runs the limma-voom workflow of the limma and edgeR User's Guides in each\n", - "cell type: it leaves out the samples with fewer than 10 cells (`min_cells`) and keeps\n", - "the rows of the design for the others, filters genes by edgeR's `filterByExpr` rule\n", - "with that design, computes TMM normalization factors, gives every observation a voom\n", - "precision weight, fits a weighted linear model to every gene, and moderates the\n", - "contrast by empirical Bayes. voom smooths its mean-variance trend with a span chosen\n", - "from the number of genes tested in each cell type, as limma's voom does since limma\n", - "3.66; `span=` fixes it. One cell type is in memory at a time." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "219874f8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DifferentialExpressionResult (limma_voom): 4 groups, 3 fitted; 1 contrast: stim_vs_ctrl\n", - " B: 12 samples, 1447 features\n", - " DC: not fitted (no_residual_df)\n", - " NK: 10 samples, 1353 features\n", - " T: 12 samples, 1495 features\n" - ] - } - ], - "source": [ - "result = limma_voom(opened, design)\n", - "print(result)" - ] - }, - { - "cell_type": "markdown", - "id": "4227bd74", - "metadata": {}, - "source": [ - "The summary has one row per cell type. The dendritic cells were not fitted: too few\n", - "of their samples have 10 cells or more, and the design, with an effect for each of\n", - "their donors and the stimulation, fits those samples exactly, which leaves no\n", - "residual degrees of freedom to estimate a variance from. The status and reason say\n", - "so, and the other cell types are fitted. The NK cells were fitted without donor D1's\n", - "two samples." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bb793a6a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "B fitted samples used: 12 of 12, genes tested: 1447, residual df: 5\n", - "DC no_residual_df samples used: 5 of 12, genes tested: 0, residual df: 0\n", - "NK fitted samples used: 10 of 12, genes tested: 1353, residual df: 4\n", - "T fitted samples used: 12 of 12, genes tested: 1495, residual df: 5\n", - "\n", - "no residual degrees of freedom: the design has rank 5 on the 5 samples left, so it fits them exactly and no variance can be estimated\n" - ] - } - ], - "source": [ - "summary = result.summary\n", - "for row in range(len(summary)):\n", - " print(\n", - " f\"{summary['group_id'][row]:<4}{summary['status'][row]:<16}\"\n", - " f\"samples used: {summary['n_samples_used'][row]:>2} of 12, \"\n", - " f\"genes tested: {summary['n_features_tested'][row]:>5}, \"\n", - " f\"residual df: {summary['df_residual'][row]:.0f}\"\n", - " )\n", - "print()\n", - "print(summary[\"reason\"][summary[\"group_id\"] == \"DC\"][0])" - ] - }, - { - "cell_type": "markdown", - "id": "3fedb743", - "metadata": {}, - "source": [ - "## A rank-deficient group\n", - "\n", - "Without donor D1, the NK cells' rows of the design no longer separate every column:\n", - "D1 is the reference level of `donor`, and the column of the last donor, `donorD6`,\n", - "equals the intercept minus the other donor columns over the remaining samples. Such a\n", - "group is fitted on the columns that R's QR decomposition keeps, as limma does, and a\n", - "contrast is tested only if those samples can estimate it. The stimulation compares the\n", - "two samples of each remaining donor, so it is estimable; a comparison of donor D2\n", - "with donor D1 is not, and is reported, not computed. (limma would compute it from the\n", - "kept columns, where it means D2 against D6.)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4ff3a6ce", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "left out: {'D1_ctrl': '3 cells, fewer than min_cells (10)', 'D1_stim': '3 cells, fewer than min_cells (10)'}\n", - "aliased columns: ['donorD6']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "no_estimable_contrast\n", - "not estimable from the samples of this group, which cannot separate the effects it depends on: donorD6 = (Intercept) - donorD2 - donorD3 - donorD4 - donorD5\n" - ] - } - ], - "source": [ - "nk = next(g for g in result.provenance[\"groups\"] if g[\"group_id\"] == \"NK\")\n", - "print(\"left out:\", nk[\"left_out\"])\n", - "print(\"aliased columns:\", nk[\"aliased_columns\"])\n", - "\n", - "donors_compared = limma_voom(\n", - " opened, design, groups=\"NK\", contrasts={\"D2_vs_D1\": \"donorD2\"}\n", - ")\n", - "print(donors_compared.summary[\"status\"][0])\n", - "print(donors_compared.provenance[\"groups\"][0][\"not_estimable\"][\"D2_vs_D1\"])" - ] - }, - { - "cell_type": "markdown", - "id": "17ed1394", - "metadata": {}, - "source": [ - "## A result table\n", - "\n", - "Each cell type and contrast has a table of the tested genes in the cube's gene order,\n", - "with the columns of limma's `topTable`. Here are the T-cell genes with the smallest\n", - "p-values for the stimulation." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "717af502", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gene log2_fold_change average_log2_cpm t adjusted_p_value\n", - "gene_1458 1.95 13.2 53.6 1.49e-163\n", - "gene_0090 2.11 10.3 44.4 9.93e-140\n", - "gene_0188 1.87 11.1 43.3 9.52e-137\n", - "gene_0069 1.68 11.9 42.8 1.89e-135\n", - "gene_1305 -1.79 11.1 -42 3.46e-133\n", - "gene_0814 1.57 12 40.3 1.89e-128\n", - "gene_0502 1.71 11 39.9 4.26e-127\n", - "gene_0530 1.88 10.3 39.6 2.3e-126\n" - ] - } - ], - "source": [ - "table = result.table(\"T\", \"stim_vs_ctrl\")\n", - "columns = [\"log2_fold_change\", \"average_log2_cpm\", \"t\", \"adjusted_p_value\"]\n", - "print(f\"{'gene':<10}\" + \"\".join(f\"{column:>18}\" for column in columns))\n", - "for row in np.argsort(table[\"p_value\"])[:8]:\n", - " values = \"\".join(f\"{table[column][row]:>18.3g}\" for column in columns)\n", - " print(f\"{table['feature_id'][row]:<10}{values}\")" - ] - }, - { - "cell_type": "markdown", - "id": "357066dd", - "metadata": {}, - "source": [ - "The simulation knows which genes the stimulation changed. At a 5% false discovery\n", - "rate, few discoveries should be false, and most changed genes that pass the filter\n", - "should be found." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "40ae2c63", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "T : 150 of 150 changed genes found; 5 of 155 discoveries false\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "B : 145 of 148 changed genes found; 4 of 149 discoveries false\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NK : 138 of 143 changed genes found; 6 of 144 discoveries false\n" - ] - } - ], - "source": [ - "for group in (\"T\", \"B\", \"NK\"):\n", - " table = result.table(group, \"stim_vs_ctrl\")\n", - " tested = np.isin(genes, table[\"feature_id\"])\n", - " changed = true_log2_fc[group][tested] != 0\n", - " found = table[\"adjusted_p_value\"] < 0.05\n", - " false_found = np.count_nonzero(found & ~changed)\n", - " print(\n", - " f\"{group:<3}: {np.count_nonzero(found & changed)} of {changed.sum()} changed \"\n", - " f\"genes found; {false_found} of {found.sum()} discoveries false\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "bcd58f77", - "metadata": { - "figure_descriptions": [ - "Volcano plot of the T-cell genes: log2 fold change of the stimulation from about -2 to 2 against minus log10 p-value. Genes significant at 5% FDR are red and lie at fold changes beyond about 0.5 in either direction; the others are grey and cluster around zero." - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "table = result.table(\"T\", \"stim_vs_ctrl\")\n", - "significant = table[\"adjusted_p_value\"] < 0.05\n", - "figure, axes = plt.subplots(figsize=(6, 4), dpi=100)\n", - "axes.scatter(\n", - " table[\"log2_fold_change\"][~significant],\n", - " -np.log10(table[\"p_value\"][~significant]),\n", - " s=4,\n", - " color=\"0.6\",\n", - " linewidths=0,\n", - " label=\"not significant\",\n", - ")\n", - "axes.scatter(\n", - " table[\"log2_fold_change\"][significant],\n", - " -np.log10(table[\"p_value\"][significant]),\n", - " s=4,\n", - " color=\"tab:red\",\n", - " linewidths=0,\n", - " label=\"5% FDR\",\n", - ")\n", - "axes.set_xlabel(\"log2 fold change, stimulated vs control\")\n", - "axes.set_ylabel(\"-log10 p-value\")\n", - "axes.set_title(\"T cells\")\n", - "axes.legend(frameon=False)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5b1f0c2e", - "metadata": {}, - "source": [ - "## Options for pseudobulk data\n", - "\n", - "By default `limma_voom` runs limma's standard workflow. Four options, each off by\n", - "default, are common in pseudobulk analyses:\n", - "\n", - "- `min_counts` leaves out the samples with fewer counts in a cell type, summed over\n", - " every gene, as `min_cells` does for cells; the scverse single-cell best practices\n", - " keep samples with at least 10 cells and 1,000 counts.\n", - "- `quality_weights=True` estimates a weight for each sample from how closely its\n", - " values follow the model, as limma's `voomWithQualityWeights` does, so that a sample\n", - " of poor quality counts less instead of being left out.\n", - "- `prior_weights=\"n_cells\"` weights each sample by its number of cells instead, as\n", - " the dreamlet paper does; it cannot be combined with quality weights.\n", - "- `adjust_across_groups=True` adds a column of p-values adjusted over every cell type\n", - " that tests the contrast, besides the adjustment within each cell type, as muscat\n", - " reports both.\n", - "\n", - "The sample table, and the record of each cell type, keep the weights that entered its\n", - "fit." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "8c4e2a71", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NK samples: cells and quality weight\n", - " D2_ctrl 29 0.94\n", - " D2_stim 23 0.94\n", - " D3_ctrl 29 1.05\n", - " D3_stim 35 1.06\n", - " D4_ctrl 24 0.97\n", - " D4_stim 41 0.96\n", - " D5_ctrl 45 0.99\n", - " D5_stim 35 1.05\n", - " D6_ctrl 33 1.05\n", - " D6_stim 38 0.99\n", - "\n", - "T : 155 genes called within the cell type, 155 across\n", - "B : 149 genes called within the cell type, 149 across\n", - "NK : 145 genes called within the cell type, 144 across\n" - ] - } - ], - "source": [ - "weighted = limma_voom(\n", - " opened, design, min_counts=1_000, quality_weights=True, adjust_across_groups=True\n", - ")\n", - "nk = weighted.samples.filter(weighted.samples[\"group_id\"] == \"NK\")\n", - "used = nk[\"used\"]\n", - "print(\"NK samples: cells and quality weight\")\n", - "for sample_id, cells, weight in zip(\n", - " nk[\"sample_id\"][used], nk[\"n_cells\"][used], nk[\"quality_weight\"][used]\n", - "):\n", - " print(f\" {sample_id:<9}{cells:>4}{weight:>7.2f}\")\n", - "print()\n", - "for group in (\"T\", \"B\", \"NK\"):\n", - " table = weighted.table(group, \"stim_vs_ctrl\")\n", - " within = np.count_nonzero(table[\"adjusted_p_value\"] < 0.05)\n", - " across = np.count_nonzero(table[\"adjusted_p_value_across_groups\"] < 0.05)\n", - " print(f\"{group:<3}: {within} genes called within the cell type, {across} across\")" - ] - }, - { - "cell_type": "markdown", - "id": "a3d9e6f0", - "metadata": {}, - "source": [ - "Every sample here was simulated alike, so the quality weights stay near one, and the\n", - "adjustment over the three cell types calls nearly the same genes as the adjustment\n", - "within each. In data with a sample of poor quality, such as one from an outlying\n", - "donor, its weight falls below the others. In this paired design its donor's other\n", - "sample gets a similar weight: the residuals of a donor's two samples are equal and\n", - "opposite, up to the voom weights." - ] - }, - { - "cell_type": "markdown", - "id": "937c28a3", - "metadata": {}, - "source": [ - "## Trace a result back to the cube\n", - "\n", - "The result carries a provenance record, plain JSON, that says what produced every\n", - "number: the method and settings; the CytePool, numpy, numba and Python versions; the\n", - "cube, by its fingerprint, the digests of its parts and its own provenance; the design,\n", - "with the values of its variables for every sample and the weights of every contrast;\n", - "and, for every cell type, the samples that entered its fit, in the order they were\n", - "fitted, those left out with the reason, and the span of its voom trend." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4d2f6f56", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "method: limma_voom | versions of: cytepool, numpy, numba, python\n", - "cube fingerprint: sha256:986da97c859afbc5d455bb29c5e403ea5b552f5b1d35cedf48a7bc5259fba397\n", - "{\"min_cells\": 10, \"expression_filter\": {\"min_count\": 10.0, \"min_total_count\": 15.0, \"large_n\": 10.0, \"min_prop\": 0.7}, \"normalization\": \"tmm\", \"span\": null, \"robust\": false}\n", - "T-cell samples: ['D1_ctrl', 'D1_stim', 'D2_ctrl', 'D2_stim', 'D3_ctrl', 'D3_stim', 'D4_ctrl', 'D4_stim', 'D5_ctrl', 'D5_stim', 'D6_ctrl', 'D6_stim']\n", - "T-cell voom span: 0.526\n" - ] - } - ], - "source": [ - "record = result.provenance\n", - "print(\"method:\", record[\"method\"], \"| versions of:\", \", \".join(record[\"versions\"]))\n", - "print(\"cube fingerprint:\", record[\"cube\"][\"fingerprint\"])\n", - "# The settings that decide which samples and genes enter each fit, and how.\n", - "chosen = (\"min_cells\", \"expression_filter\", \"normalization\", \"span\", \"robust\")\n", - "print(json.dumps({key: record[\"settings\"][key] for key in chosen}))\n", - "t_cells = next(g for g in record[\"groups\"] if g[\"group_id\"] == \"T\")\n", - "print(\"T-cell samples:\", t_cells[\"samples\"])\n", - "print(f\"T-cell voom span: {t_cells['voom_span']:.3f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "c5f49da5", - "metadata": {}, - "source": [ - "A number in the T-cell table comes from the counts of the T cells of these twelve\n", - "samples, the profiles `(sample, T)` of the cube with that fingerprint: all of their\n", - "genes enter the filter, the normalization factors and the voom trend. A cube at hand\n", - "is that cube when its fingerprint is the one recorded. For the cube file this needs no\n", - "read; `verify_fingerprint()` reads every group whole and checks it against its digest,\n", - "which shows that the file still holds what was analysed. The record also keeps the\n", - "digest of each group's counts, which identifies the T-cell profiles alone. Those\n", - "profiles can then be read back by their ids, and, for example, the library sizes that\n", - "entered the fit recomputed from them." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "de53793f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fingerprint matches: True\n", - "verified by reading: True\n", - "digest of the T-cell counts: sha256:e133ff04638b37a618fa29894a9232ecc1b3bd9623484e9b28546036cc851096\n", - "profiles: (12, 1500)\n", - "library sizes agree: True\n" - ] - } - ], - "source": [ - "print(\"fingerprint matches:\", opened.fingerprint() == record[\"cube\"][\"fingerprint\"])\n", - "print(\n", - " \"verified by reading:\", opened.verify_fingerprint() == record[\"cube\"][\"fingerprint\"]\n", - ")\n", - "t = opened.groups[\"group_id\"].tolist().index(\"T\")\n", - "counts_digests = record[\"cube\"][\"digests\"][\"layers\"][\"counts\"][\"groups\"]\n", - "print(\"digest of the T-cell counts:\", counts_digests[t])\n", - "profiles = opened.select(samples=t_cells[\"samples\"], groups=\"T\").layer(\"counts\", \"T\")\n", - "table = result.table(\"T\", \"stim_vs_ctrl\")\n", - "tested = np.isin(opened.features[\"feature_id\"], table[\"feature_id\"])\n", - "rows = result.samples.filter(result.samples[\"group_id\"] == \"T\")\n", - "print(\"profiles:\", profiles.shape)\n", - "print(\n", - " \"library sizes agree:\",\n", - " np.array_equal(profiles[:, tested].sum(axis=1), rows[\"library_size\"][rows[\"used\"]]),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "a74f2335", - "metadata": {}, - "source": [ - "The cube's own provenance, kept in the record, says how the cube was made, in plain\n", - "terms:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "80f8fee6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Source, as the caller recorded it (unresolved: CytePool does not follow its references):\n", - " dataset: \"simulated study of six donors\"\n", - " seed: 20261025\n", - "Built by from_cells (CytePool 0.1.dev26+gbff0b44e9) from 2,987 cells:\n", - " samples: the rows of sample_table\n", - " groups: the sorted distinct labels\n", - " features: ids given as a sequence\n", - " layers: counts\n", - " normalized values: each cell scaled to a total of 10,000, with library sizes the total count of each cell\n", - "References: CytePool resolves none on its own. The source record's references need the tool that wrote them. A fingerprint names a cube without saying where it is: Cube.fingerprint() of a cube at hand says whether it is that cube.\n", - "Fingerprint: sha256:986da97c859afbc5d455bb29c5e403ea5b552f5b1d35cedf48a7bc5259fba397\n" - ] - } - ], - "source": [ - "print(opened.history())" - ] - }, - { - "cell_type": "markdown", - "id": "bcaf4a58", - "metadata": {}, - "source": [ - "What CytePool can and cannot resolve on its own:\n", - "\n", - "- **It can** go from any number of a result to its cell type, its contrast and its\n", - " gene, to the samples that entered that fit and those left out with the reason, and\n", - " to the cube's profiles of those samples and that cell type, by their ids. It can\n", - " tell whether a cube at hand is the one analysed, by its fingerprint, and check by\n", - " reading it that its values still match their digests. The record also holds the\n", - " design and the settings that the fit used, and how the cube was made: here by\n", - " `from_cells` from the number of cells shown above.\n", - "- **It cannot** find the cube from its fingerprint. The fingerprint names the cube's\n", - " values, not where they are stored: keep the cube file with the results.\n", - "- **It cannot** follow the source record. CytePool keeps it as it was given; what it\n", - " refers to, such as a dataset or its cells, needs the tool that wrote it.\n", - "- **It cannot** go from the cube back to the cells. A cube holds sums over cells, not\n", - " the cells: keep the cell-level data." - ] - } - ], - "metadata": { - "executed_at": "2026-10-25T13:10:13+00:00", - "executed_code_sha256": "32930e71cc2c86920c051e8553aacd102be7c5e0473c549665eba6368a142d76", - "executed_with": "0.1.dev26+gbff0b44e9", - "execution_seconds": 4.9, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/source/guides/anndata_and_mudata.ipynb b/docs/source/guides/anndata_and_mudata.ipynb new file mode 100644 index 0000000..00c2a70 --- /dev/null +++ b/docs/source/guides/anndata_and_mudata.ipynb @@ -0,0 +1,391 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6b28c831", + "metadata": {}, + "source": [ + "(anndata-and-mudata)=\n", + "# Work with AnnData and MuData\n", + "\n", + "Single-cell analyses in Python keep their cells in an AnnData [@virshup2024], and\n", + "scverse tools keep pseudobulk profiles in one of two layouts: a long AnnData with a row per\n", + "sample and cell type, as scanpy's `get.aggregate` and decoupler's `pp.pseudobulk` make\n", + "it [@wolf2018; @badiaimompel2022], or a MuData with a modality per cell type, as LIANA\n", + "makes it for its analyses of several views [@bredikhin2022; @dimitrov2024]. CytePool\n", + "pools cells from an AnnData, reads and writes both layouts, and keeps a cube's\n", + "fingerprint through the conversion, so that a cube can go to these tools and come back\n", + "as the same cube. The conversions need CytePool's `anndata` or `mudata` extra\n", + "([Installation](../installation.md)); the cells are those of the simulated PBMC study\n", + "([Datasets](../reference/datasets.md)).\n", + "\n", + "## Cells in an AnnData\n", + "\n", + "An AnnData of cells has the counts in `X`, or in a layer, and the sample and cell type\n", + "of every cell in `obs`. {api}`from_cells` pools them as they are; the sample table comes\n", + "from the columns of `obs` that describe the samples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31cfc4b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CytePool 0.1.dev57+gb65bc7e32, anndata 0.13.4\n", + "AnnData object with n_obs × n_vars = 19151 × 2000\n", + " obs: 'sample', 'donor', 'condition', 'cell_type'\n", + " layers: None (.X) \n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cube with 24 samples x 6 groups x 2,000 features\n", + " layers: counts (uint32), detected (uint32), log_sum (float64), log_sum_sq (float64), linear_sum (float64)\n", + " filled: 144 of 144 sample x group entries have cells (100.0%)\n", + " samples: sample_id, donor, condition\n", + " groups: group_id\n", + " features: feature_id\n" + ] + } + ], + "source": [ + "from importlib.metadata import version\n", + "\n", + "import anndata\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy.sparse\n", + "\n", + "import cytepool\n", + "from cytepool.cube import from_cells\n", + "from cytepool.io.anndata import from_anndata, from_mudata, to_anndata, to_mudata\n", + "\n", + "arrays = np.load(\"simulated_pbmc_cells.npz\")\n", + "sample = arrays[\"cell_sample\"].astype(str)\n", + "cells = anndata.AnnData(\n", + " X=scipy.sparse.csr_matrix(\n", + " (arrays[\"data\"], arrays[\"indices\"], arrays[\"indptr\"]),\n", + " shape=tuple(arrays[\"shape\"]),\n", + " ),\n", + " obs=pd.DataFrame(\n", + " {\n", + " \"sample\": sample,\n", + " \"donor\": [name.split(\"_\")[0] for name in sample],\n", + " \"condition\": [name.split(\"_\")[1] for name in sample],\n", + " \"cell_type\": arrays[\"cell_type\"].astype(str),\n", + " },\n", + " index=[f\"cell_{i}\" for i in range(sample.size)],\n", + " ),\n", + " var=pd.DataFrame(index=arrays[\"feature_id\"].astype(str)),\n", + ")\n", + "print(f\"CytePool {cytepool.__version__}, anndata {version('anndata')}\")\n", + "print(cells, \"\\n\")\n", + "\n", + "samples = cells.obs[[\"sample\", \"donor\", \"condition\"]].drop_duplicates()\n", + "cube = from_cells(\n", + " cells.X,\n", + " samples=cells.obs[\"sample\"],\n", + " groups=cells.obs[\"cell_type\"],\n", + " sample_table=samples.rename(columns={\"sample\": \"sample_id\"}),\n", + " features=cells.var_names,\n", + ")\n", + "print(cube)" + ] + }, + { + "cell_type": "markdown", + "id": "e487d3fd", + "metadata": {}, + "source": [ + "## A cube as a long AnnData\n", + "\n", + "{api}`to_anndata` writes a row for every sample and cell type with cells, the layout\n", + "that scanpy and decoupler make: `obs` holds the sample and cell type of each row, the\n", + "columns of the sample and group tables and the number of cells, and every layer of the\n", + "cube is a layer of the same name. `X` is left empty, so that no layer is stored twice;\n", + "`pseudobulk.X = pseudobulk.layers[\"counts\"].copy()` gives tools that read `X` the\n", + "counts. `uns[\"cytepool\"]` records the cube's fingerprint and provenance, and\n", + "{api}`from_anndata` reads the AnnData back as the same cube, here after a round trip\n", + "through an `.h5ad` file." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5389b496", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 144 × 2000\n", + " obs: 'sample_id', 'group_id', 'donor', 'condition', 'n_cells'\n", + " uns: 'cytepool'\n", + " layers: 'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + "\n", + "the same cube after the .h5ad file: True\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idgroup_iddonorconditionn_cells
D01_ctrl_B cellsD01_ctrlB cellsD01ctrl58
D01_stim_B cellsD01_stimB cellsD01stim49
D02_ctrl_B cellsD02_ctrlB cellsD02ctrl91
D02_stim_B cellsD02_stimB cellsD02stim72
D03_ctrl_B cellsD03_ctrlB cellsD03ctrl87
\n", + "
" + ], + "text/plain": [ + " sample_id group_id donor condition n_cells\n", + "D01_ctrl_B cells D01_ctrl B cells D01 ctrl 58\n", + "D01_stim_B cells D01_stim B cells D01 stim 49\n", + "D02_ctrl_B cells D02_ctrl B cells D02 ctrl 91\n", + "D02_stim_B cells D02_stim B cells D02 stim 72\n", + "D03_ctrl_B cells D03_ctrl B cells D03 ctrl 87" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pseudobulk = to_anndata(cube)\n", + "print(pseudobulk)\n", + "pseudobulk.write_h5ad(\"pseudobulk.h5ad\")\n", + "back = from_anndata(anndata.read_h5ad(\"pseudobulk.h5ad\"))\n", + "print(\"\\nthe same cube after the .h5ad file:\", back.fingerprint() == cube.fingerprint())\n", + "pseudobulk.obs.head()" + ] + }, + { + "cell_type": "markdown", + "id": "d5c6ef2b", + "metadata": {}, + "source": [ + "## A cube as a MuData\n", + "\n", + "{api}`to_mudata` writes a modality for every cell type, whose rows are the samples with\n", + "cells in it, as LIANA's `multi.adata_to_views` makes them, with the columns of the\n", + "sample table in the MuData's `obs`. {api}`from_mudata` reads it back." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "95dce467", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MuData object with n_obs × n_vars = 24 × 12000\n", + " obs:\t'donor', 'condition'\n", + " uns:\t'cytepool'\n", + " 6 modalities\n", + " B cells:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + " CD4 T cells:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + " CD8 T cells:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + " Dendritic cells:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + " Monocytes:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", + " NK cells:\t24 × 2000\n", + " obs:\t'n_cells'\n", + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "the same cube after the MuData: True\n" + ] + } + ], + "source": [ + "views = to_mudata(cube)\n", + "print(views)\n", + "print(\n", + " \"\\nthe same cube after the MuData:\",\n", + " from_mudata(views).fingerprint() == cube.fingerprint(),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5757d2f5", + "metadata": {}, + "source": [ + "## Profiles that scanpy, decoupler or LIANA pooled\n", + "\n", + "{api}`from_anndata` recognises the layouts of `scanpy.get.aggregate` and\n", + "`decoupler.pp.pseudobulk`, and {api}`from_mudata` that of LIANA's views, and reads from\n", + "each the counts, the number of cells that detect each gene and the number of cells of\n", + "every profile. Each gives the counts, detecting cells and cell numbers that\n", + "{api}`from_cells` computes from the same cells, down to the fingerprint, as the\n", + "[Validation](../validation.md#anndata-and-mudata) page shows for scanpy 1.12.4,\n", + "decoupler 2.2.0 and LIANA 1.10.0:\n", + "\n", + "```python\n", + "import decoupler as dc\n", + "import liana as li\n", + "import scanpy as sc\n", + "\n", + "summed = sc.get.aggregate(\n", + " cells, by=[\"sample\", \"cell_type\"], func=[\"sum\", \"count_nonzero\"]\n", + ")\n", + "cube = from_anndata(summed, sample=\"sample\", group=\"cell_type\")\n", + "\n", + "pooled = dc.pp.pseudobulk(cells, sample_col=\"sample\", groups_col=\"cell_type\")\n", + "cube = from_anndata(pooled, sample=\"sample\", group=\"cell_type\")\n", + "\n", + "views = li.multi.adata_to_views(\n", + " cells, groupby=\"cell_type\", sample_key=\"sample\", obs_keys=[\"condition\"]\n", + ")\n", + "n_cells = pd.crosstab(cells.obs[\"sample\"], cells.obs[\"cell_type\"])\n", + "cube = from_mudata(views, n_cells=n_cells)\n", + "```\n", + "\n", + "LIANA's views carry no cell numbers, so they come from the cells, as the crosstab of\n", + "their samples and cell types. Means, variances and medians are refused: a cube keeps\n", + "sums, and every tool that gives means gives sums too, with `func=\"sum\"` in scanpy and\n", + "`mode=\"sum\"`, its default, in decoupler.\n", + "\n", + "## Choices\n", + "\n", + "- **From cells or from profiles.** {api}`from_cells` on the cells computes every layer\n", + " of a cube, the sums of normalized values included, and needs no other tool; an import\n", + " of the profiles that another tool pooled keeps that tool's choices of cells and\n", + " samples.\n", + "- **Import before filtering.** decoupler's `pp.filter_samples`, which LIANA's views\n", + " apply when given `filter_samples_kwargs`, drops profiles, and a profile that is\n", + " missing looks like a sample without cells. Import every profile, and leave out those\n", + " with few cells in the analysis (`min_cells` of {api}`limma_voom`).\n", + "- **Other layouts.** An AnnData of profiles that no tool above made needs `sample=`,\n", + " `group=` and `layers=`, such as `layers={\"counts\": \"X\"}`, and `n_cells=`, the name of\n", + " a column of `obs` or a crosstab of the cells.\n", + "- **Files.** `.h5ad`, `.zarr` and `.h5mu` files keep the fingerprint through a round\n", + " trip; a cube file ([Save, share and trace cubes](save_and_trace_cubes.ipynb)) also\n", + " reads one cell type at a time." + ] + } + ], + "metadata": { + "datasets": [ + "simulated_pbmc" + ], + "executed_at": "2026-10-26T21:54:17+00:00", + "executed_code_sha256": "09e48cf19350c4949b5f3b57bf234e674a79fd0809f65dea8505084b6c1debd1", + "executed_datasets": { + "simulated_pbmc": { + "simulated_pbmc.cube.zarr": "sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726", + "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" + } + }, + "executed_with": "0.1.dev57+gb65bc7e32", + "execution_seconds": 3.6, + "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.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/guides/bulk_rna_seq.ipynb b/docs/source/guides/bulk_rna_seq.ipynb index 349d951..c61aaac 100644 --- a/docs/source/guides/bulk_rna_seq.ipynb +++ b/docs/source/guides/bulk_rna_seq.ipynb @@ -13,7 +13,7 @@ "([Validation](../validation.md)). This page runs the three on one simulated\n", "experiment whose true changes are known, and compares their calls with the truth.\n", "[Choosing a method](../statistics/choosing_a_method.md) explains how they differ,\n", - "and the [Quick start](../quickstart.ipynb) walks through limma-voom step by step.\n", + "and the table at the end of the page gives the R function of each step.\n", "\n", "The experiment is the simulated bulk dataset ([Datasets](../reference/datasets.md)):\n", "three treatments (control, drug A and drug B) with four replicates each, sequenced in\n", @@ -296,6 +296,39 @@ "[meta-analysis](../statistics/meta_analysis.md) combines across studies, and DESeq2's\n", "likelihood ratio test asks about several coefficients at once." ] + }, + { + "cell_type": "markdown", + "id": "c3a8e41f", + "metadata": {}, + "source": [ + "## The same steps in R\n", + "\n", + "{api}`limma_voom` runs limma's steps in turn, and each step, like the edgeR and DESeq2\n", + "fits above, follows an R function. Run one by one, as a limma user would, the steps\n", + "are these; R stores genes in rows, so its count matrix is the transpose of the one used\n", + "here, and its library sizes are the totals of the genes kept, as here.\n", + "\n", + "| Step | CytePool | R |\n", + "| --- | --- | --- |\n", + "| Filter genes | `keep = filter_by_expression(counts, design=design)`, then `counts[:, keep]` | `keep <- filterByExpr(y, design)`, then `y[keep, , keep.lib.sizes = FALSE]` |\n", + "| Normalization factors | `tmm_factors(counts)` | `calcNormFactors(y)` |\n", + "| Design and contrasts | `Design(samples, \"~ batch + condition\", contrasts=...)` | `model.matrix(~ batch + condition)` and `makeContrasts(...)` |\n", + "| Precision weights | `voom(counts, design, norm_factors=factors)` | `voom(y, design)` in limma 3.66 or later, `voom(y, design, adaptive.span = TRUE)` in 3.60 to 3.65 |\n", + "| The same, with sample quality weights | `voom_with_quality_weights(counts, design, norm_factors=factors)` | `voomWithQualityWeights(y, design)` |\n", + "| Linear models | `fit_linear_model(v.log_cpm, design, weights=v.weights)` | `lmFit(v, design)` |\n", + "| Contrasts | `contrasts_fit(fit, design.contrasts, method=\"limma\")` | `contrasts.fit(fit, contrasts)` |\n", + "| Moderation | `moderated_statistics(fit)` | `eBayes(fit)` |\n", + "| Adjusted p-values | `adjust_p_values(p, \"bh\", axis=0)` | `topTable(fit, coef = j, sort.by = \"P\")`, which adjusts by BH |\n", + "| Quasi-likelihood F-tests | `fit_quasi_likelihood`, then `quasi_likelihood_f_test` | `glmQLFit`, then `glmQLFTest` |\n", + "| DESeq2's Wald and likelihood ratio tests | `fit_deseq2`, then `deseq2_wald_test` or `deseq2_likelihood_ratio_test` | `DESeq`, then `results`; `DESeq(dds, test = \"LRT\", reduced = ~ batch)` |\n", + "\n", + "`method=\"limma\"` gives the standard errors of contrasts as limma computes them; by\n", + "default they are exact, which differs from limma's when the weights differ between\n", + "genes and the contrast combines correlated coefficients ([Designs, linear models and\n", + "contrasts](../statistics/linear_models.md#contrasts)). The\n", + "[Validation](../validation.md) page shows how closely each step agrees with R." + ] } ], "metadata": { diff --git a/docs/source/guides/export_cubes.ipynb b/docs/source/guides/export_cubes.ipynb index c5cf46e..facaf90 100644 --- a/docs/source/guides/export_cubes.ipynb +++ b/docs/source/guides/export_cubes.ipynb @@ -8,12 +8,15 @@ "(export-cubes)=\n", "# Export a cube from another tool\n", "\n", - "A tool that holds cells, such as an analysis platform or an atlas, can hand its\n", - "pseudobulk profiles to CytePool as a cube file: the sums of every sample, cell type\n", - "and gene, the tables that describe them, the number of cells behind each profile,\n", - "and a record of where they came from. This page builds a cube from sums computed\n", - "outside CytePool, saves it, and checks it. [Cube files and provenance\n", - "records](../reference/cube_files.md) describes the file and the record in full.\n", + "A tool that holds cells, such as an analysis platform or an atlas, can give its users\n", + "CytePool's tests without moving the cells: it hands over its pseudobulk profiles as a\n", + "cube file, with the sums of every sample, cell type and gene, the tables that describe\n", + "them, the number of cells pooled into each profile, and a record of where they came\n", + "from. This page builds a cube from sums computed outside CytePool, saves it, and checks\n", + "it against CytePool's own pooling. [Cube files and provenance\n", + "records](../reference/cube_files.md) describes the file and the record in full, and\n", + "[Save, share and trace cubes](save_and_trace_cubes.ipynb) what its users can then do\n", + "with it.\n", "\n", "The cells here are those of the simulated PBMC study ([Datasets](../reference/datasets.md)),\n", "standing in for the exporter's store: 12 donors sampled before and after a\n", @@ -177,9 +180,9 @@ "## Save it and open it again\n", "\n", "{api}`write_cube` reads the lazy layer one cell type at a time, hashes each as it\n", - "writes it, and stores the digests with the file. {api}`read_cube` opens the file\n", + "writes it, and stores the digests with the file, and {api}`read_cube` opens the file\n", "without reading its counts. {api}`Cube.history` prints the provenance record, with\n", - "the source first and the fingerprint last." + "the exporter's source first and the fingerprint last." ] }, { @@ -270,6 +273,36 @@ "print(\"same values as from_cells:\", opened.fingerprint() == pooled.fingerprint())\n", "print(\"stored values verified: \", opened.verify_fingerprint() == opened.fingerprint())" ] + }, + { + "cell_type": "markdown", + "id": "e7b1c0a2", + "metadata": {}, + "source": [ + "## Choices\n", + "\n", + "- **The arrays.** A lazy layer is any array of the cube's shape, cell types x samples x\n", + " genes, that returns one cell type when indexed by its position: a numpy memmap, an\n", + " HDF5 dataset or a Zarr array. An array with orthogonal indexing (`oindex`), as\n", + " zarr-python's arrays have, is asked only for the samples and genes a selection\n", + " keeps. Counts are whole numbers, in an integer array, or float64 for counts that are\n", + " not whole, such as estimated counts.\n", + "- **The layers.** The `counts` and the cell numbers are what the tests need. The\n", + " number of cells with a positive count (`detected`) and the sums of the cells'\n", + " log-normalized values (`log_sum`) give the dot plot, and layers of normalized values\n", + " need a `normalization` record that says how the values were computed ([The cube and\n", + " its additive layers](../statistics/cubes.md)).\n", + "- **The source record.** Record what a reader needs to find the cells again: the tool\n", + " and its version, the dataset, the selection of cells, the annotations that define the\n", + " samples and cell types, and the settings ([Cube files and provenance\n", + " records](../reference/cube_files.md#what-an-exporter-records)). Keep the memberships\n", + " of the cells in the exporter's files; the cube records how to find them.\n", + "- **The check.** The fingerprint does not depend on how a cube was made, so an\n", + " exporter can pool part of its cells, such as those of a few samples, with\n", + " {api}`from_cells` and compare the fingerprint with that of the same part of its\n", + " export ({api}`Cube.select`), with the same tables. {api}`Cube.verify_fingerprint`\n", + " checks every value of the written file against its digest." + ] } ], "metadata": { diff --git a/docs/source/guides/genes_per_cell_type.ipynb b/docs/source/guides/genes_per_cell_type.ipynb index 1d07c35..d26862a 100644 --- a/docs/source/guides/genes_per_cell_type.ipynb +++ b/docs/source/guides/genes_per_cell_type.ipynb @@ -185,8 +185,9 @@ "metadata": {}, "source": [ "A cell type left with too few samples to estimate a variance is not fitted, and both\n", - "the printed summary and the figure say so ([From cells to\n", - "results](../differential_expression.ipynb) shows one); `result.summary` gives the\n", + "the printed summary and the figure say so ([Designs, linear models and\n", + "contrasts](../statistics/linear_models.md#designs-that-cannot-answer-the-question) says\n", + "when); `result.summary` gives the\n", "reason and `result.samples` lists every profile with the reason it was left out. Each fit keeps\n", "the rows of the design for its own samples, so the megakaryocytes, which have no\n", "profile of donor 107, are fitted without that donor's column.\n", diff --git a/docs/source/guides/normalization_and_quality.ipynb b/docs/source/guides/normalization_and_quality.ipynb index de17354..c2aaeac 100644 --- a/docs/source/guides/normalization_and_quality.ipynb +++ b/docs/source/guides/normalization_and_quality.ipynb @@ -38,7 +38,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n" + "CytePool 0.1.dev57+gb65bc7e32\n" ] }, { @@ -70,9 +70,11 @@ "from cytepool.plotting import (\n", " plot_mds,\n", " plot_mean_variance,\n", + " plot_pca,\n", " plot_residual_variances,\n", " plot_sample_weights,\n", ")\n", + "from cytepool.principal_components import principal_components\n", "from cytepool.stats.empirical_bayes import moderated_statistics\n", "from cytepool.stats.linear_models import contrasts_fit, fit_linear_model\n", "from cytepool.stats.voom import voom\n", @@ -103,6 +105,64 @@ "each donor's samples ([Genes that change in each cell type](genes_per_cell_type.ipynb)).\n", "A sample far from its group on such a plot deserves a look before any test.\n", "\n", + "DESeq2's PCA plot ({api}`plot_pca`) places the same samples on the principal components\n", + "of their 500 most variable genes, each labelled with its share of the variance\n", + "[@love2014]. {api}`principal_components` also returns the loadings of the genes, which\n", + "say what each component is made of." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5c0e2f7a", + "metadata": { + "figure_descriptions": [ + "DESeq2's PCA plot of the 16 CD14+ monocyte samples, coloured by condition (control blue, stimulated orange) and marked by donor. PC1, 84% of the variance, puts the control samples between about 15 and 28 and the stimulated ones between about -24 and -19; PC2, 4%, puts both samples of donor 1039 at the top, near 10, and the others between about -6 and 3." + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PC1, the largest loadings: ISG15, IL1RN, IDO1, IFITM3, MX1, APOBEC3A, LY6E, TNFSF13B\n", + "PC2, the largest loadings: HBB, FUCA1, SNCA, NDUFA12, CD52, IL1B, CCL3, CCL4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pca = principal_components(kang, group=\"CD14+ Monocytes\")\n", + "symbols = np.asarray(kang.features[\"symbol\"])[pca.genes]\n", + "for component in (0, 1):\n", + " largest = np.argsort(-np.abs(pca.loadings[:, component]))[:8]\n", + " print(f\"PC{component + 1}, the largest loadings:\", \", \".join(symbols[largest]))\n", + "plot_pca(pca, color_by=\"condition\", marker_by=\"donor\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9a41d3b6", + "metadata": {}, + "source": [ + "The first component, 84% of the variance, is the stimulation again, and the genes with\n", + "the largest loadings on it are interferon-stimulated genes such as ISG15, MX1 and\n", + "IFITM3. The second sets the two samples of donor 1039 apart, as the second dimension\n", + "of the MDS plot does, and the gene with by far the largest loading on it is HBB,\n", + "whose reads come from red cells that contaminate some samples more than others; the\n", + "genes with outlying variances, below, return to it. The two plots agree here: MDS measures each pair of samples by the\n", + "genes that differ most between those two, PCA every sample by the same 500 genes.\n", + "\n", "## Which genes to test\n", "\n", "voom estimates how the variance of the log counts falls with their level, and weights\n", @@ -117,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "872a24f8", "metadata": { "figure_descriptions": [ @@ -198,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "925173f3", "metadata": {}, "outputs": [ @@ -266,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "605b8fa0", "metadata": { "figure_descriptions": [ @@ -335,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "b2a946f4", "metadata": { "figure_descriptions": [ @@ -406,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "c475002b", "metadata": {}, "outputs": [ @@ -472,8 +532,8 @@ "kang2018", "simulated_bulk" ], - "executed_at": "2026-10-26T20:33:00+00:00", - "executed_code_sha256": "22d3a7ff3bb3e8c30a897c9fdf76b3b8ae560b0e10330515c1e8bdb033a09b7f", + "executed_at": "2026-10-26T21:56:54+00:00", + "executed_code_sha256": "eed2efcee4a18d468aece68892293efe57484a6875e7979e1773b3919dc49e87", "executed_datasets": { "kang2018": { "kang2018.cube.zarr": "sha256:a30af3dabe17f21a6c75f41b64a279a1423640b9aa919022cf67897f9cc77a51" @@ -483,8 +543,8 @@ "simulated_bulk_truth.npz": "sha256:a8a0275532e3cafb02401846176a7ddfa037579aceb804c5f9c007700f022977" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 2.8, + "executed_with": "0.1.dev57+gb65bc7e32", + "execution_seconds": 8.8, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/pool_cells.ipynb b/docs/source/guides/pool_cells.ipynb new file mode 100644 index 0000000..c4f9d33 --- /dev/null +++ b/docs/source/guides/pool_cells.ipynb @@ -0,0 +1,399 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "edbefb19", + "metadata": {}, + "source": [ + "(pool-cells)=\n", + "# Pool cells into pseudobulk profiles\n", + "\n", + "Tests of conditions compare samples, so the cells of every sample and cell type are\n", + "first pooled into one profile ([Why pseudobulk](../why_pseudobulk.ipynb)). A cube keeps\n", + "those profiles: for every gene, sums over the cells of each sample and cell type, with\n", + "the number of cells pooled into each. Because every value is a sum, cell types can be\n", + "merged and samples pooled later without the cells, and the same sums give what\n", + "describes the cells: the fraction that express each gene and their mean expression, the\n", + "values of a dot plot. This page pools the cells of the simulated PBMC\n", + "study (the `simulated_pbmc` dataset of the [Datasets](../reference/datasets.md) page),\n", + "looks at the markers of its cell types and at its samples, and merges a rare cell type\n", + "into its lineage. [The cube and its additive layers](../statistics/cubes.md) defines\n", + "every layer.\n", + "\n", + "## Samples, cell types and layers\n", + "\n", + "{api}`from_cells` takes a cells x genes matrix of counts and the sample and the cell\n", + "type of every cell. A sample table, with a `sample_id` for every sample label, sets the\n", + "order of the samples and carries the variables that designs use, here the donor and the\n", + "condition; a group table does the same for the cell types, and may carry their lineage." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cdcc403b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CytePool 0.1.dev61+g194f49f8f\n", + "Cube with 24 samples x 6 groups x 2,000 features\n", + " layers: counts (uint32), detected (uint32), log_sum (float64), log_sum_sq (float64), linear_sum (float64)\n", + " filled: 144 of 144 sample x group entries have cells (100.0%)\n", + " samples: sample_id, donor, condition\n", + " groups: group_id, lineage\n", + " features: feature_id\n", + "Table with 6 rows and 2 columns\n", + " group_id lineage\n", + " str str\n", + " B cells lymphoid\n", + " CD4 T cells lymphoid\n", + " CD8 T cells lymphoid\n", + " NK cells lymphoid\n", + " Monocytes myeloid\n", + " Dendritic cells myeloid\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy.sparse\n", + "\n", + "import cytepool\n", + "from cytepool.cube import from_cells\n", + "from cytepool.plotting import plot_cell_numbers, plot_dotplot, plot_pca\n", + "\n", + "cells = np.load(\"simulated_pbmc_cells.npz\")\n", + "counts = scipy.sparse.csr_array(\n", + " (cells[\"data\"], cells[\"indices\"], cells[\"indptr\"]), shape=tuple(cells[\"shape\"])\n", + ")\n", + "sample_ids = np.unique(cells[\"cell_sample\"])\n", + "cube = from_cells(\n", + " counts,\n", + " samples=cells[\"cell_sample\"],\n", + " groups=cells[\"cell_type\"],\n", + " sample_table={\n", + " \"sample_id\": sample_ids,\n", + " \"donor\": [sample.split(\"_\")[0] for sample in sample_ids],\n", + " \"condition\": [sample.split(\"_\")[1] for sample in sample_ids],\n", + " },\n", + " group_table={\n", + " \"group_id\": cells[\"cell_types\"],\n", + " \"lineage\": [\"lymphoid\"] * 4 + [\"myeloid\"] * 2,\n", + " },\n", + " features=cells[\"feature_id\"],\n", + ")\n", + "print(f\"CytePool {cytepool.__version__}\")\n", + "print(cube)\n", + "print(cube.groups)" + ] + }, + { + "cell_type": "markdown", + "id": "14996e17", + "metadata": {}, + "source": [ + "The cube holds five layers: the `counts`, which the tests read, and four that describe\n", + "the cells: `detected`, the number of cells with a positive count, and the sums of the\n", + "cells' log-normalized values (`log_sum`), of their squares (`log_sum_sq`) and of the\n", + "normalized values themselves (`linear_sum`). Each cell is normalized to 10,000 counts\n", + "and log-transformed, as scanpy's `normalize_total` and `log1p` do.\n", + "\n", + "## The markers of each cell type\n", + "\n", + "A dot plot shows, for chosen genes and cell types, the fraction of the cells that\n", + "express each gene, as the area of a dot, and their mean expression, as its colour, as\n", + "scanpy draws it [@wolf2018]. {api}`plot_dotplot` reads both from the cube, pooled over\n", + "every sample, and gives the values scanpy computes from the cells\n", + "([Validation](../validation.md#principal-components-and-dot-plots)). The simulation\n", + "gave each cell type 20 marker genes; here are three of each, with the means of each\n", + "gene scaled from 0 to 1 over the cell types, as scanpy's `standard_scale=\"var\"` scales\n", + "them." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b27788be", + "metadata": { + "figure_descriptions": [ + "Dot plot of 18 marker genes (columns, three for each cell type, under a bracket that names it) in six cell types (rows): a dot's area gives the percentage of the cell type's cells that express the gene, from about 5 to 100, and its shade of blue their mean expression, scaled from 0 to 1 over the cell types for each gene. Each cell type's three markers have the darkest and largest dots of its row, under its own bracket; a few markers, such as gene_0204 of the NK cells and gene_0213 of the dendritic cells, are expressed in most cells of every type and are darkest in their own." + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "markers = {\n", + " cell_type: list(genes[:3])\n", + " for cell_type, genes in zip(cells[\"cell_types\"], cells[\"marker_genes\"])\n", + "}\n", + "ax = plot_dotplot(cube, markers, standard_scale=\"gene\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "93bf5afa", + "metadata": {}, + "source": [ + "Each cell type's markers are expressed in more of its cells, and more highly, than in\n", + "the other cell types, as an annotation that is right shows them. A cell type whose\n", + "markers light up in another row is worth a second look before any test.\n", + "\n", + "## What changes in the cells\n", + "\n", + "{api}`Cube.collapse_samples` pools the samples that share a value of a sample column,\n", + "here the condition: the profiles of the 12 control samples are summed into one, and so\n", + "are those of the 12 stimulated ones. From the pooled sums, {api}`Cube.fraction_detected`,\n", + "{api}`Cube.mean` and {api}`Cube.variance` give the fraction of the cells that detect\n", + "each gene, and the mean and the variance of their log-normalized values. For one gene\n", + "of the response program that the simulation gave every cell type:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ad6d32f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table with 2 rows and 3 columns\n", + " sample_id condition n_pooled_samples\n", + " str str int64\n", + " ctrl ctrl 12\n", + " stim stim 12\n", + "\n", + "gene_0191, control -> stimulated detected mean variance\n", + "B cells 0.86 -> 1.00 1.98 -> 3.44 0.90 -> 0.43\n", + "CD4 T cells 0.78 -> 0.99 1.59 -> 3.26 0.92 -> 0.48\n", + "CD8 T cells 0.85 -> 0.99 1.87 -> 3.50 0.91 -> 0.49\n", + "NK cells 0.74 -> 0.97 1.49 -> 2.89 0.98 -> 0.64\n", + "Monocytes 0.65 -> 0.97 1.20 -> 2.88 0.92 -> 0.60\n", + "Dendritic cells 0.75 -> 0.96 1.53 -> 2.78 0.97 -> 0.82\n" + ] + } + ], + "source": [ + "by_condition = cube.collapse_samples(\"condition\")\n", + "print(by_condition.samples)\n", + "\n", + "gene = cube.features[\"feature_id\"].tolist().index(\"gene_0191\")\n", + "detected = by_condition.fraction_detected()[:, :, gene]\n", + "mean = by_condition.mean()[:, :, gene]\n", + "variance = by_condition.variance()[:, :, gene]\n", + "print(f\"\\ngene_0191, control -> stimulated{'detected':>12}{'mean':>16}{'variance':>16}\")\n", + "for g, cell_type in enumerate(by_condition.groups[\"group_id\"]):\n", + " print(\n", + " f\"{cell_type:<32}{detected[g, 0]:>6.2f} -> {detected[g, 1]:.2f}\"\n", + " f\"{mean[g, 0]:>8.2f} -> {mean[g, 1]:.2f}{variance[g, 0]:>8.2f} -> {variance[g, 1]:.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "0ab8d511", + "metadata": {}, + "source": [ + "After the stimulation nearly every cell of every type expresses the gene, and the mean\n", + "of their log-normalized values about doubles. These pooled values describe the cells;\n", + "they are no test, since the samples pooled are the replicates a test needs ([Genes that\n", + "change in each cell type](genes_per_cell_type.ipynb) tests the change). Pooling the\n", + "samples of each donor, `collapse_samples(\"donor\")`, gives one profile per donor, for\n", + "questions about donors ([Repeated measures and donors](repeated_measures.ipynb)).\n", + "\n", + "## The samples of each cell type\n", + "\n", + "DESeq2's PCA plot places the samples of one cell type on the principal components of\n", + "their 500 most variable genes [@love2014], prepared as for an MDS plot: profiles of\n", + "fewer than 10 cells are left out, genes are filtered by expression, and the values are\n", + "log-CPM ({api}`plot_pca`, {api}`principal_components`). It shows at a glance whether\n", + "the samples group as the design expects." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "270631f2", + "metadata": { + "figure_descriptions": [ + "Two PCA plots of the 24 monocyte samples, coloured by condition (control blue, stimulated orange). Left, PC1 (58% of the variance) against PC2 (4%): the control samples lie near -9 on PC1 and the stimulated ones near 9. Right, PC2 against PC3 (4%), each donor with a marker of its own: the two samples of most donors lie next to each other, such as those of D09 at the top left, of D03 at the right and of D04 at the bottom." + ] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABLsAAAHXCAYAAABUCFh9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAydFJREFUeJzs3Xd0FNXbB/DvbE02ZVMgREKAUEILVXrvTbqU0EG6KCKggOAPRRQUQSyIoqJSpIsoAkGK9N47IiUkQAglu0k2yZaZ94+8WVlSSMKWbPh+ztlzsnPvzDxR17l59rn3CpIkSSAiIiIiIiIiIioEZK4OgIiIiIiIiIiIyF6Y7CIiIiIiIiIiokKDyS4iIiIiIiIiIio0mOwiIiIiIiIiIqJCg8kuIiIiIiIiIiIqNJjsIiIiIiIiIiKiQoPJLiIiIiIiIiIiKjQUrg7AHYiiiNu3b8PHxweCILg6HCIicgOSJCExMRHFixeHTMbvluj5xrEUERHlB8dTlF9MduXC7du3ERoa6uowiIjIDd26dQslSpRwdRhELsWxFBERPQuOpyivmOzKBR8fHwDpHzBfX18XR0NERO5Ar9cjNDTU+gwhep5xLEVERPnB8RTlF5NduZBRbu/r68sBGhER5QmnbBFxLEVERM+G4ynKK056JSIiIiIiIiKiQoPJLiIiIiIiIiIiKjQ4jZGIiIjczu3btyGKonVanNlsxt27dwEARYsWhVqtzvH8vPYnIiIiKkwePXqE5ORkKJVKFCtWDAAQFxcHk8kELy8v+Pv7P/Uaee3vTKzsIiIiIrcTHh6O0NBQzJ8/HwBw6dIlhIaGIjQ0FLt27bL2u337NmJiYqDX623Oz64/ERER0fPgzTffRGhoKFq1amU91qxZM4SGhuKtt96yHnv06BFiYmIQFxeX6RpZ9S8omOwiIiIit6dUKhESEoKQkBB4eHhYj1euXNkmKfa0/kRERETPq+DgYISEhCAgIMB67K233sqUFMupf0HBaYxERESULyaTCQkJCShatGiW7WlpaUhISIC/vz9UKpVNW1bTCJOSkqBSqTL1BQBRFJGQkJDtYKps2bI4dOiQ9XoZ15ckCUD61uUxMTEAgBIlSmTq78jYiYiIiLLz8OFDeHl5ZbmkgiiKePDgATw8PODj45Op/clphGazGQaDIdudjx89egQfHx8oFFmnglavXm29Xsb1DQYDgPTxT8ZYKiAgABqNJlN/R8aeV6zsIiIiojy5cuUKOnfuDB8fH4SGhqJ48eJYsGCBtf3s2bNo3bo1vL29UbZsWXh7e6NDhw74559/rH0en0Y4ZcoUvPjii/D394enpycGDhwIi8Vi7fvHH3+gRIkSCAwMRGhoKN555x1rEiur6+3atQs3b95E/fr1kZiYCAD4/vvvUb9+fdSvXx9paWnZTmO0d+xERERET0pJScHkyZNRtGhRFClSBMWLF8eAAQPw4MEDAEBSUhJee+01+Pv7o1SpUtBqtahcuTLWrl1rc52MaYT9+/dH586dERQUBK1Wi+rVq+PKlSvWfjExMWjSpAkCAgJQtGhRdOzYEXfu3MkU15PTEvv374+NGzcCAP7991/rWCoqKirL/o6IPd8keiqdTicBkHQ6natDISIiN1FYnx2xsbFS0aJFJQDSsGHDpLS0NCk5OVmaPXu2ZDabpejoaMnf318CIH3++eeSJEnSBx98IAGQgoODpfv370uSJElnz56VAEgApBo1akh6vV46dOiQ9dgvv/wiSZIkxcTESJ6enhIAaeHChZIoitLEiROt/WbMmJHpelu2bLHGq9VqbfplyKq/vWOn/xTWzwMRETlWYX1+dOnSRQIgVahQQbp586YkiqK0Y8cOadeuXZIkSVK7du0kAFLr1q2ltLQ06eTJk5JarZYASBs2bLBep0KFChIASaFQSEeOHJEMBoNUvnx5CYDUo0cPa7+WLVtKAKS2bdtKRqNR2rdvnyQIggRAqlKlSqbrDRs2zHps2LBhmfrl1N/esecXK7uIiIgo1xYuXIj4+Hio1WrMmzcPKpUKGo0GU6ZMgVwux9dff41Hjx7B29sbY8aMAQC88cYbkMvluHv3Ln744YdM1xw1ahR8fHxQr1496/pZFy5cAAAsXrwYKSkp0Gg0GDFiBARBwPjx4x3yu9k7diIiIqInnTx5Er///jsAYPr06ShZsiQEQUDLli3RvHlzHD9+3Fo5NW7cOKhUKtSoUcO6ZtZHH32U6ZrNmjVDnTp14OnpiXr16gH4bzxy9uxZ7Ny5EwAwduxYKJVKNGrUCHXr1rX772bv2J8Fk11ERESUa6dPnwYAhIaGQqvVZmo/e/YsACAkJARKpRIA4OPjgyJFiti0Py40NNT6c8aaVyaTCUD6lEEAKF68uPV6ISEh2a418SzsHTsRERHRkzLGUgBQtWrVTO2PjzfCwsIy/ZzfsRQAlCpVyvpz6dKl8xr6U9k79mfBZBcRERHlWsYgxGg0ZtmekSQym802xzMGLRntj5PL5dafBUGwactYrPXxQY8oihBFMa+hP5W9YyciIiJ60uOb2WQ1nnp8vPH4mORZx1KPX+PJn+3F3rE/Cya7iIiIKNeaNGkCIH2h0+joaOtx6f8XjG/cuDEA4NatW9Dr9QCAO3fu4NGjRzbtuVWzZk0AwO3bt63Xu3TpUq6TXRkDKOmJBe2zYu/YiYiIiJ7UsGFDyGTpqZgDBw7YtEmSZNN+/vx5a1vG1L68jkeqV69uvd7jVV65nSqYl7GUvWN/Fkx2ERERUa6NHDkS1atXhyiKGDBgAI4cOYIDBw6gW7dusFgsGDlyJCpXrgyj0YiJEyfi7NmzmDhxIiRJQp06ddC/f/883W/EiBEIDg6GyWTCW2+9hTNnzmDq1Km5/uavfPnyAIDDhw/j+vXruHfvXo6/mz1jJyIiInpS6dKlrbsXzpw5E+vWrcO5c+cwa9Ys/PbbbwgLC8Mbb7wBAPjwww9x7NgxfPfdd9i/fz+8vLzw4Ycf5ul+pUqVwqBBgwAAs2fPxvHjxzF//nxcvnw5V+dnjKWio6Nx6tQpxMTEZLvztL1jfxYFJtmVmJiIb775BjVq1ICHhwf27NmTZb+vv/4aFSpUgJ+fH5o0aYIjR4489dr5OYeIiIgy8/Lywr59+zBz5kyYTCb07dsXH374ISZPngy5XA4fHx8cOHAA06ZNw8mTJ9GlSxdcvXoV7733Hnbt2mUtpVcqlQgJCUFISIh1YXcA1mMZ64F5e3tj165d6Ny5M3bs2IFJkyZh6NChKF++PEJCQuDr65vj9RYuXIi2bdvin3/+QZMmTTBw4MBs+9s7diIiIqKszJkzB2vXrkX9+vUxZcoUDBs2DH5+fujatSsAYP78+Vi2bBlCQkLQu3dvfPbZZxg8eDCOHTtmrXoHgODgYISEhCAgIMB6LCAgACEhIXjhhResx77++mtMmDABZrMZr776Kh49eoQxY8YgJCQEwcHBOV5v9OjRGDZsGEJDQ9G5c2fUr18ft27dyra/vWPPL0HKTS2aE7zzzjt48OABOnfujM6dO2PXrl1o3ry5TZ+lS5di5MiRWL58ORo0aIBPPvkEP/30Ey5cuICQkJAsr5ufc56k1+uh1Wqh0+msg2oiIqKc8NlB9B9+HoiIKD/4/KD8KjDJrgwxMTEIDQ3NMtlVpUoVNG/eHAsXLgSQvkBtiRIlMHTo0GzL4fJzzpP4ASMiorzis4PoP/w8EBFRfvD5QflVYKYxPs2jR49w4cIFtGjRwnpMJpOhRYsW2L9/v93OISIiIiIiIiIi9+U2ya47d+4AAIKCgmyOBwUF4e7du3Y7BwDS0tKg1+ttXkREREREREREVPC5TbIrQ8Y2lo+/f9pMzLyeM3v2bGi1WusrNDQ0/wETEREREREREZHTuE2yq1ixYgCA+Ph4m+P37t2zttnjHACYOnUqdDqd9ZWx0wARERERERERERVsbpPsCgwMRPny5bF7927rMUmSsHv3bjRo0MBu5wCAWq2Gr6+vzYuIiIiIiIiIiAo+t0l2AcCbb76JH374ATt27EBycjLee+893L9/H6NGjbL2GTNmDF588cU8nUNERERERERERIWDwtUBZFi2bBlGjBhhfd+2bVvIZDJMnz4d06dPB5CeyHr06BH69u2LBw8eoFKlSti0aRPKlCljPc9kMiEtLc36PjfnEBERERERERFR4SBIT1vd3UksFgtMJlOm4wqFAgpF5pycKIqZFp4HALPZDFEUoVKpcn3O0+j1emi1Wuh0Ok5pJCKiXOGzg+g//DwQEVF+8PlB+VVgpjHK5XJ4eHhkemWV6AIy77CYQaFQZJnoyukcIiIidyeKEgxGEaJYIL7DyhWj0YiIiAicPHnS1aEQERHRc84dx1IAMHbsWHz88ceuDqPAKTDTGImIiCjvLt1JxbJ9D7H5tB5GiwSVXEDH6r4Y2DgAFV/wcHo8KSkpqFOnDn755RdUq1Ytx76iKOL8+fNITk52UnREREREtgraWAoARo8ejfLly2PixIlP7Xvz5k0olUonROVeWOpERETkpv48pUOvL6/jj1M6GC3p30IaLRL++P/jf57SOT0mi8WC8+fPw2AwOP3e5HiHDx+Gp6cnSpcu7epQiIiInllBHEsBwI0bN3Dnzh2X3LuwYLKLiIjIDV26k4opa25DlACLaNtmEQFRAqasuY1Ld1Ltfm+j0YhPP/0ULVu2ROPGjTF79myYzWYAQJMmTQAA/fv3R0REBHr27ImEhARERERg27ZtGDBgAGrVqoU1a9bYPS5yLJ1Oh/79+6NZs2bWf99ERETuypVjKQDYunUrunfvjjp16mD48OGIiYkBAEydOhX79+/HTz/9hIiICERERODWrVsYOnQo5s2bh5kzZ6Jhw4Y2G/xRZkx2ERERuaFl+x5CEHLuIwjAsv0P7XpfSZLQtWtXfPPNNxg1ahTmzJmDxMREfPnllwCA7777DgDwwQcfYNWqVfj4449hNptx/vx5DBgwAM2bN8ePP/6INm3a2DUucrwRI0YgMjISjRs3dnUoREREz8xVYykAWLx4Mbp37466deviiy++QMOGDTFu3DgA6WtwVa9eHZ07d8aqVauwatUqFCtWDNevX8fUqVPx8OFDzJ8/H9OmTbN7XIUJ1+wiIiJyM6IoYfNpfaZvIZ9kEYHNp/SY9fILEJ42msulLVu24K+//sL58+dRoUIFAEDjxo2tOypXrFgRAFCmTBlEREQAAO7fvw8AeOeddzB8+HDrtVJTHfNNKdnf4sWLcf36daxYsYKL4BIRkdtz5VjKaDRi8uTJeO+99zB58mQAQIMGDTBw4EAAQIkSJeDt7Y3AwEDrWCpDnTp1sGDBArvEUdgx2UVERORmUs2SdV2JpzFaJKSaJHiq7DNA279/P8LDw62Jrgy5WRi1bt26domBnOv8+fOYNm0aDhw4kOsFcNPS0pCWlmZ9r9frHRUeERFRnrlyLHX+/HkkJCSgc+fONsdz84ytV6+eXWJ4HnAaIxERkZvxUAhQyXM34FLJBXgo7TM4A9KrsTQaTb7Oze955DpGoxF9+vTBRx99hPLly+f6vNmzZ0Or1VpfoaGhDoySiIgob1w9lgLyNy7iWCr3mOwiIiJyMzJZ+pbY8qc8xeUyoGMNX7uV3QNAhQoV8M8//yA5OTnre8rlANLX9iL39/DhQ5w/fx5jxoyBQqGAQqHAjBkzEBsbC4VCke1GA1OnToVOp7O+bt265eTIiYiIsufKsVT58uUhCAJOnjyZ/X3lco6lnhGTXURERG5oYOMAPG0MJEnAwEYBdr1v79694eHhgXHjxlmnqZ05cwYbNmwAAHh6esLX1xc3btyw633JNYKDg2EymZCammp9zZgxAyEhIUhNTUWvXr2yPE+tVsPX19fmRUREVJC4aixVpEgRREZGYtq0abh+/TqA9On+n332mbVPcHAwx1LPiMkuIiIiN1TxBQ/M6V0cMgGZvpWUywCZAMzpXRwVX/Cw6339/PwQFRWF48ePw9/fH6GhoRg8eLDNGl5vv/02hg0bhkqVKqFnz552vT85X0ZFV8ZLJpNZj9vzm24iIiJnctVYCkjf+KVWrVqoUKECSpUqhXLlyqFIkSLW9pEjR2L37t0ICwtDREQEK6TzQZBYG/dUer0eWq0WOp2O30wSEVGuOOvZcelOKpbtf4jNp/QwWiSo5AI61vDFwEYBDhmcPe727dsAgOLFi2dq0+v1uH37NpRKJUqXLo2LFy+iXLly8PD4LyZJknD+/HmUKVOGa1C4kVmzZuGbb75BTExMrs/hWIqIiPLDGc8PV46l9Ho94uPjUbp0aetSEBmMRiNiYmJgMBgQHh6O2NhYeHl5ISgoyKZfdHQ0VCoVgoODHRqru2GyKxc4QCMiorxy9rNDFCWkmiV4KgVW25BDSZIEURQzDcpzwrEUERHlhzOfHxxLFS4KVwdAREREz04mE6Cx05bYRDkRBCFPiS4iIiJ3wLFU4cI1u4iIiIiIiIiIqNBgsouIiIiIiIiIiAoNJruIiIiIiIiIiKjQYLKLiIiIiIiIiIgKDS5QT0RERERE5MYkswli4kMIcgUELz8I3ESCiJ5zTHYRERERERG5KdGQCNOV40j6aQagVMF31FzIQ8pB5unt6tCIiFyG0xiJiIiIiIjckJiUgOS185H47VuQ0gyQkhKgmzcCKVt/hJisc3V4REQuw2QXEREROYzZbMakSZNw48YNV4dCRFSoSGkpSPh4CNIObcrUlrJtKfRfjoOYkuSCyIjI3pYsWYLff//d1WG4FSa7iIiICgFJFCGlpUASRZfFYDQaMWnSJERHR1uPmc1mzJs3DzExMS6Li4ioMJJMqRBUHtm2CxpfQHLdM4HI3RSEsRQAfP/999i0yTaJ/euvv2Lnzp0uisg9cc0uIiIiN2aOuYKUHSuRdiwKMJsAhRLq2u3g2aovFCXCnRqL0WjEvHnz0LNnT5QsWRIAoFQqMXfuXISFhTk1FiKiwk7Q+EJdtwMMv32VZbtHo66QaXydHBWR+ylIYykAWLduHSIiItCpUyfrsWHDhsHPz8/psbgzJruIiIjcVNrRKCT+9D8AAiBa0g+aTUg7sgVpRzbDZ8hMqOu0s/t9Y2NjsX79ejx8+BDVq1dH165dIZPJMGPGDADAl19+iXXr1iEkJASvv/467t69C5PJBAAwGAz43//+h7Fjx+LYsWM4f/48XnjhBQwcOBByuRyrVq3C1atXUblyZURGRkIQBLvHTwVLqkmEIABqBSccEOWFIJNDXbtt1skumRzKCrWdHxSRm3HVWCotLQ3r16/H5cuXERISgh49eqBIkSJYuXIlLl++jAcPHmDSpEkAgKlTp+LRo0eQP7bL6qJFixAWFgYfHx/s378fZrMZkZGRKFOmDPbs2YMdO3bAz88PAwcORJEiRewevzvgqIKIiMgNmWOupA/ORPG/wVkG0QKIIhJ/+h/MMVfset+LFy+iYsWKOHz4MORyOVauXIkePXoAAIoVKwYACAwMRHBwMAIDAzNNYzQYDJg3bx6aNWuGjRs3QpIkfPTRR2jfvj1atGiBnTt3QhAETJw4EePHj7dr7FQw3bxvxE97HuJRshlpZk65IsoLQe0JWdHQTMeV5WoA/LKAKEeuGkuJoogWLVpg3rx5kMvlOH36NFq0aIFbt25Bq9VCrVbDy8sLwcHBCA4OhlwuzzSNcfXq1RgxYgQmTJgAg8GAXbt2oUaNGhg9ejSmTJkCQRDw22+/oV69ekhLS7Nr/O6ClV1ERERuKGXHSgBP+0NGQMrOVfAZ9D+73fe3335DrVq1sGLFCuuxK1fSB4GvvvoqJk+ejH79+qF+/foAgNTU1CyvM2jQIMyaNQsA0LBhQ7Rv3x6zZs3CtGnTAADVq1dH//798dlnn0Em43dzhVmaScIXf8Xjhz0PMKxpIHrX84NGLWOlF1EuCJ4+8B39KcSEezbH5UElIfPSuigqIvfgqrHUv//+i4MHD+LevXsoWrQoAOD+/fuQyWTo2LEjvvjiC0RERFgru7Kj1Wqxf/9+KBQKGI1GFC9eHEePHsXRo0chk8nw9ttvIygoCFFRUejSpYvd4ncXHEUQERG5GUkU09eVePJbyCeJFqQd3QpJkux277CwMJw9exa//vqrNZEVHp739Sw6duxo/blixYoAgA4dOtgcS0tLw7179zKdS4VTcpqIL/6KR7u5/7LSiyiXBLkciuJloKpc3+YlL1Lc1aERFWiuHEsFBQXBy8sLCxYswN27dwEARYoUQUBAQJ6u07ZtWygU6fVLKpUKYWFhaNeunfVLQo1Gg9DQUJuNg54nTHYRERG5G1Na+gKquWE2pfe3kz59+mDmzJn48MMP4e/vj5YtW2Lbtm15vo5Go7H+nLEGRVbHzGbzM0ZM7oZJLyIicjgXjqW0Wi2ioqJw6tQplCtXDpUqVcKcOXPyPOZ5fNwEpI+dsjr2vI6lmOwiIiJyN0o1oFDmrq9Cmd7fTgRBwGuvvYbjx4/j9u3baNGiBTp16oSYmBguJk92lZwmYsXBh9h/JRmWp3zxTkRElCcuHEsBQKNGjfDnn3/i0aNHWLBgAT755BMsXrwYADieshMmu4iIiNyMIJNBXbsdIJPn3FEmh7pOe7sOmg4ePIikpCQAgL+/PwYPHgyTyYT4+HhoNBqoVCrodDq73Y+eT4HecszoFozf3yyD9tV8oFFzyErPJ32KBUmpzPYS2Zsrx1LR0dG4fPkyAECpVKJdu3YoV64cYmNjAQB+fn4cS9kBF6gnIiJyQ56t+iLtyOan9JLg2TLSrve9fv06BgwYgBdffBFFixbF1q1b0bFjR1SrVg2CIKBNmzaYOHEitm7dipIlS2LMmDF2vT8VboHecrzWuijaVvWBt1oGhZxJLnp+JRjMWLA1HkFaBfo3CIBW85Q/yokoT1w1lrJYLOjZsydeeOEFhIeH4+LFi4iOjsbQoUMBAO3atcO4ceOgUCjg5eWFqVOn2vX+zwsmu4iIiNyQokQ4fIbMTN8yG4LtAqsyOQAJPkNmQlEi74vH56Rfv35o27Ytdu7ciYcPHyIyMhJNmjSxtv/666/4448/cOvWLQQEBECpVGLu3LkICwsDAHh5eWHu3LkICQmxnuPn54e5c+ciKCjIeiwoKAhz586Fn5+fXeOngolJLqL/pBgtiNOb8erPMbh53wgA2Hs5CQv6l0CAlxxK7lRKZBeuGkuFhYXh1KlT2LlzJ/755x+0bNkS7du3t663NWTIEISHh+PUqVMwGAyQy+UYNmyYzZhozJgxKFGihM11x40bhzJlytgcmzRpEqpVq2bX+N2FINlzW4FCSq/XQ6vVQqfTwdfX19XhEBGRG3DWs8MccwUpO1ch7ejW9AVUFUqo67SHZ8tIuw/OiPIrp89DcpoFJovEJBcRAF2KBVFn9PjojziYLLZ/pnmrZZjbNwQ1SnrC15NVXvR8cMZ4imOpwonJrlxgsouIiPLK2c8OSRTTdwpSeXBhUypwOJYiyp0EgwWt5/yDFFPWf6KFBiix8tXS8PfiBB16Pjjz+cGxVOHCr8+IiIgKAUEmg6D25OCMiMiNKWRA43DvbNtfqqGFjwf/hCNyBI6lChf+n5KIiIiIiKgA8PaQo2ddv2zbu9TUcrovEVEu8P+UREREREREBURECQ8o5ZkrS17QKuDryT/fiIhyw60mex89ehQWiyXT8aCgoEy7DmS4fv064uLibI5pNJrndkcCIiIiIiIquOQyAV1raXHypsHmeOeaWnipmewiIsoNt0p2TZ48GQbDf//TN5lMOHHiBKZMmYLZs2dnec7HH3+MtWvXonz58tZjZcuWxYoVKxweLxERERERUV74eMgxvl1RPLmNmFwGqBRMdhER5YZbJbt27txp83716tWIjIzEoEGDcjyvRYsWWLdunSNDIyIiIiIisgvutkhE9Gzc+quBH374AY0bN0alSpVy7Gc0GnHmzBncvHkT0pNfkRARERERERERUaHhtl8Z3Lx5Ezt27MCPP/741L6bN2/G1atXERcXBx8fH3z77bdo166dE6IkIiIiIiIiIsrZhQsXcPv2bXh7e6N+/fquDsftuW1l15IlS+Dr64tevXrl2K9NmzaIiYnBhQsXEBcXh5dffhkvv/wyrl27lu05aWlp0Ov1Ni8iIiIiIiIiIkf45JNP0KZNGwwfPtzVoRQKbpnsEkURP/30E/r37w9PT88c+7788ssIDg4GACgUCnz88cdQKBTYuHFjtufMnj0bWq3W+goNDbVr/ERERERERERE5BhuOY3xr7/+QnR0NEaMGJHncxUKBYoUKYLY2Nhs+0ydOhUTJkywvtfr9Ux4EREREREREZFdGI1GHD9+HEWKFEHZsmVz7BsbG4tr167Bw8MDERERmYp+Dh48iOTkZISEhKBChQr4999/8ejRI1SuXBne3t7PdL3w8HBcvXoVjx49cqvplW6Z7Prhhx9Qp04dVK9ePVPbtWvXkJSUhGrVqkGSJKSlpcHDw8PafvXqVdy4cQNVqlTJ9vpqtRpqtdohsRMRERERERHR8+vUqVPo1KkTYmNjERERAbVaDYUic3omJiYGQ4YMwY4dO1C5cmXExcUhNTUVU6ZMwfTp0639hg4disuXL6Nhw4Ywm81ISkrChQsXEBAQgN9//x2NGjXK1/Xq16+PR48eoUiRIggPD2eyy5EePHiAjRs3YuHChVm2f/TRRzh06BDOnTsHk8mEF198EaNGjUKVKlUQHR2NWbNmoXr16ujbt6+TIyciIiIiIiKi55koihg8eDBiY2MxcOBALF26FNeuXUPFihUz9evcuTNOnTqF/v37Y/ny5bh9+zYqVqyId999F4GBgRgzZozNOadOncLFixcRGhqKOnXq4Pjx45g5cyaioqLydb2TJ0/i1KlTmWJzB263Zte+fftQp04dREZGZtletmxZa8WXSqVCVFQUYmJiMGfOHGzZsgXjx4/HwYMHbaq9iIiIiIiIiIgc7dixYzhz5gwAYMCAAQCAMmXKoGHDhjb99u3bh1OnTgEAhgwZAgAoXrw42rRpAwD46quvMl27ZcuWKFmyJARBsM5mu379er6v17p1a7dMdAFuWNnVtWtXdO3aNdv2qVOn2rwvUaIEPvnkE0eHRURERERERESUo3///df68wsvvGD9uXjx4jb9rl69mmVbSEhIpvYMQUFB1p+VSiWA9Aqx/F6vWLFiOf0qBZrbVXYREREREREREbkjPz8/688GgyHLnwHAx8fH+nNKSkqmfo+3ZxAEIdv72vt6BR2TXURERERERERETlCrVi3rskonTpwAAEiSZP05Q9OmTa0b5x09etR6/NixYwBgnX6YW/a+XkHndtMYiYiIiIiIiIjcUbFixTBx4kR8+OGHmDlzJnx9fbF37148ePAgU7958+bh9ddfx3vvvQdvb2+cPHkSp0+fRmhoKD7++OM839ee1yvomOwiIiIiIiIiInKSDz74AKVKlcKmTZuwbds2tG3bFmXLlkVUVBTCwsKs/caOHYs6depg2bJl+OWXX+Dh4YE5c+Zg5MiR8Pf3t/Zr2LAhSpQogcqVK1uPVa5cGa1atbKuyfWs13M3giRJkquDKOj0ej20Wi10Oh18fX1dHQ4REbkBPjuI/sPPAxER5QefH5RfXLOLiIiIiIiIiIgKDSa7iIiIiIiIiIio0GCyi4iIiIiIiIiICg0mu4iIiIiIiIiIqNBgsouIiIiIiIiIiAoNJruIiIiIiIiIiKjQYLKLiIiIiAodSZJcHQIRERG5iMLVARARERER2ZuUrINoSoOg1kCm8XF1OERERORErOwiIiIiokJIQsLMPkj6ZTYsD25DNCS6OiAiIiJyElZ2EREREVGhJEkijMf/gvHEdqhqtYZX99cgePqw0ouIiDKRJAkmkwlKpRKCILg6HHpGrOwiIiIiosJNkmA8/hcevduNlV5ERGTjXtxdbN60EfM//QgL5s/B/E8/wuZNG3Ev7q7D7jl48GAoFAooFAp4enoiJCQE7dq1ww8//ACLxZKp/7Jly1CpUiV4eXmhZs2aiIqKsmk3GAxYsmQJ6tSpA4VCgTVr1jgsdnfBZBcRERERPR8eT3qt+hhSWgoki8nVURERkYtcuHAOP//0Hc6fP2tNMlksFpw/fxY///QdLlw455D7WiwWNGvWDKmpqdDpdDh06BAiIyPx7rvvol27djAajda+mzdvxiuvvIIpU6bgxo0b6N27N7p06YIzZ85Y+3z77bfYt28fPv/8c1gsFoii6JC43QmTXURERET0/BBkUNVuB69ur0ESLRDkSldHRERELnAv7i7+/GMDJEmCJNkmhyRJhCRJ+POPDQ6r8BIEAQqFAiqVCqGhoRg6dCh27dqFPXv24Ouvv7b2+/TTT9G1a1cMHjwYRYsWxdSpU1G5cmUsWLDA2ufNN9/EkiVLULduXYfE6o6Y7CIiIiKiwk+QQVWnPfxnbYR338mQBwRD5unt6qiIiMhFjh09DOApa3MJAo4dO+yUeACgQoUKaNu2LdatWwcAEEURhw4dQosWLWz6tWrVCgcOHHBaXO6IyS4iIiIiKryY5CIioidIkoSLF89lqujK1E8UcfHCOUiS5KTIgIoVK+LatWsAgISEBKSkpCAoKMimT9GiRXH3ruPWFCsMuBsjERERERVK6jrtoenwCgRPbya4iIjIymQyZbkQfFYsFgvMZjOUyoIz7V0mkzk1AeeOmOwiIiIiosJHroRXj3FMchERUSZKpRJyuTxXCS+5XA6FwnmpkytXriAsLAwAoNVqoVarER8fb9Pn3r17KFasmNNickecxkhEREREhY6M1VxERJQNQRBQqVIEBCHnlIggk6FS5QgIwlPW9rKTa9euISoqCt27dweQnmirV68edu/ebdNv586daNiwoVNicldMdhERERERERHRc6V2nXoAnjIVUJJQu3Y9h8fy4MEDrF69Gq1atULt2rXx2muvWdsmTpyIDRs2YPXq1UhMTMSCBQtw5swZjBs3zuFxuTMmu4iIiIiIiIjouRJULBgvde4OQRAgyGxTI4JMBkEQ8FLn7ggqFuyQ++/cuRMKhQIKhQLlypXDwoULMWHCBOzatQseHh7Wfl26dMHChQsxefJk+Pn54dtvv8W6detQq1Yta59t27ZBoVBYz+vfvz8UCgXGjh3rkNjdgSBxVbOn0uv10Gq10Ol08PX1dXU4RETkBvjsIPoPPw9ERJQfznh+3Iu7i2PHDuPihXOwWCyQy+WoVDkCtWvXc1iiSxRFiGL6TpByufyZp0lKkpTl+mMymQwy2fNZ48QF6omIiIiIiIjouRRULBgdX+qKDh27wGQyQalUOnyNLnsnoQRBcOoi+u6A/zSIiIiIiIiI6LkmCAJUKpWrwyA7eT7r2YiIiIiIiIiIqFBisouIiIiIiIiIiAoNJruIiIiIiIiIiKjQYLKLiIiIiIiIiIgKDSa7iIiIiIiIiIio0GCyi4iIiIiIiIiICg0mu4iIiIiIiIiIqNBQuDoAIiIiIiIiIiJn0ut0MKQYntpP46mBr1brhIjInpjscjJDmgVGCwBIgAT4efFfAREREREREZGz6HU6fLd4ISwW81P7yuUKjBg51q4Jr3nz5mHXrl0AAKVSiYCAAERERKBHjx4oVapUpv5Xr17FwoULER0djfDwcIwfPx7FihWztptMJqxcuRK7d++GxWJB3bp1MWzYMKjVarvF7G44jdFJzBYRd3UmzN4Uh9Zz/kHjWf9g7NIYHPwnCYmpFleHR0RERERERPRcMKQYcpXoAgCLxZyrCrC8OHnyJGJiYjB69GgMHToU9evXx6FDhxAeHo6PP/7Ypu+VK1dQu3ZtxMXFoVu3bjhx4gTq1q2LBw8eWPvUq1cPu3btQqNGjdC0aVMsXLgQTZs2RVpaml3jdiduVVYUFRWFkydP2hwrWrQohg0bluN5SUlJ+OOPPxAXF4eqVauiVatWjgwzS3cSzOj11XUkporWY6eiUzB8yS1MfikIPer4wVstd3pcRERERERERORcRYoUQadOnazvR4wYgdWrVyMyMhIRERF46aWXAADvv/8+KlasiBUrVkAQBPTu3RtlypTBZ599hlmzZgEAtmzZYlPp1bp1a5QqVQpRUVHo0qWLc3+xAsKtKrs2bNiAn376CQkJCdZXYmJijufExsaiWrVq+PTTT3H+/Hn0798fkZGRkCTJSVEDOoMF7224Y5PoetynW+4h1ei8eIiIiIhyS5Ik/P777xg5ciS6d++Od955B7Gxsa4Oi4hcJCnVgodJZjxMMiOJM1SI7KpPnz6oU6cOvvnmG+uxqKgodO/eHYIgAADUajU6deqErVu3Wvs8nugC0ouC5HI59Hq9cwIvgNyqsgsAIiIiMGfOnFz3nzJlCvz9/XHw4EGoVCpcuHAB1apVQ+/evdGjRw8HRvofUZJw6N/syx4tIhB1Vo/+DQOcEg8RERFRbo0YMQL3799Hx44dUbRoUSxbtgwRERE4evQoypUr5+rwiMjJjGYJTT78BwCwd1p5F0dDVPjUq1cPf/zxBwBAr9fjwYMHKFGihE2f0NBQrFu3LttrfP7551AqlWjRooVDYy3I3C7ZFRsbiy+++AJarRYNGjRAeHh4tn0tFgs2bNiAjz76CCqVCgBQuXJlNG7cGGvXrnVasivV9PSqrTsJJidEQkRERJQ3n3zyCQIC/vtCrkuXLqhQoQK+/fZbzJ0714WRERERFT4ajQYGQ3qxjNFotB57sk9G25O2bt2Kd999FwsXLkRISIhjgy3A3GoaIwAkJibi0qVL+PXXX1G1alXrHNWsREdHIzk5GRUqVLA5XqFCBVy8eDHb89LS0qDX621ez0KjkkGtEHLsUzXU85nuQUREROQIjye6AEAul8PPzw/JyckuioiInO3xqYuPDP9NXXxk4JRGInu7ffs2goODAQC+vr6QyWR4+PChTZ8HDx7Az88v07k7d+5Ejx49MGvWLIwcOdIZ4RZYblXZNXbsWCxatMg6V3X9+vXo1asXWrZsiYYNG2bqn5SUBADQPrFFqJ+fn7UtK7Nnz8b7779vt7iVcqBzTV+sO6rLst3XQ4Z6ZTRZthEREREVJLt27cLx48cxc+bMbPukpaXZ7AD1PK8ZQlQYPD518XFdPrtm/ZlTGomeXUpKCrZt24bIyEgAgEqlQsWKFXH69GmbfqdOnUL16tVtju3atQudO3fGu+++i8mTJzst5oLKrSq7qlatak10AcDLL7+MYsWKYefOnVn29/LyApB5gKXT6axtWZk6dSp0Op31devWrWeKW6OWY3y7IFQu7pGpzVMpYPErJaFRu9W/CiIiInoO/fPPP+jTpw+GDx+Ojh07Zttv9uzZ0Gq11ldoaKgToyQiInI/8fHx6Nu3L0RRxKRJk6zHBw0ahJUrVyI6OhoAcOLECWzfvh2DBg2y9tm9ezc6deqE6dOnY+rUqU6PvSByq8qurMjl8myrtEqWLAkPDw9cvXoVbdu2tR6/evVqjmt9qdVqqNVqu8bp76XA98NK4lS0AWuPJCDFKKJeWS+8XMcP3h4yqBRMdhEREVHBde3aNbRq1QqtWrWy2SUqK1OnTsWECROs7/V6PRNeRG5MpRCslVuPDBZrRdfvb5aBv0Zu7UNEuXf69Gl06tQJoigiPj4e586dQ8uWLbFv3z6bZ+aECRNw9OhRVK1aFRERETh16hRGjRqF3r17W/t06dIFcrkc+/fvR6dOnazHBw4ciD59+jj19yoo3CbZZbFYcOnSJVSpUsV6LCoqCrGxsWjWrJn12JYtW3D79m0MGzYMCoUCnTp1wvLlyzFq1CjI5XJcu3YNu3fvxtKlS53+O2g1cjSr6IMXS2tgkQCNSoBSziQXERERFWzXr19HixYt0KBBAyxfvhxyuTzH/o744pCIXMfbI+vPvL9GjgBvt/mTkshK46mBXK6AxWJ+al+5XAGNp32XHZo0aZJ1qqJCoYC/vz8qV64MHx+fTH2VSiXWrVuHS5cuITo6GuHh4ShdurRNn5UrV0IUxUznVqxY0a5xuxNBkqSnbxVYAJjNZtSvXx8lS5ZElSpVEB0djdWrV2P48OH46quvrP2GDx+OQ4cO4dy5cwDSB2cNGzZEhQoVULduXaxZswaVK1fGpk2bIJPlLtGk1+uh1Wqh0+ng6+vrkN+PiIgKFz47qLC4efMmmjVrhnr16mHFihVQKPL+hy0/D0SFx8Mks3X9rr3TyjPZRQ7lyOeHXqeDIcXw1H4aTw18n1gHnAo+t/k/k0KhwJEjR7B161acPHkS9erVw8SJE1GtWjWbfh07dkRERIT1fVhYGM6dO4fVq1cjLi4On376KXr06JHrRBcRERHR82z06NGIjo5GWFgY2rdvbz1ep04dzJ4924WRERER5Z+vVsskViHmNpVdrsRvI4mIKK/47KDC4vjx43j06FGm40WKFEGNGjVydQ1+HogKj6RUC4zm9D8hVQoh2ymORPbA5wfll9tUdhERET0LSZIAswlQKG129iWinL344ouuDoHouZRqEnE93oij15Oz7VOpuAcqveDh1IQTk1tE5A6Y7CIiokJNTE0G0lKRevAPWO5ehzy4NDwadAHUHpB5eLk6PCIioix5KGUo6qPA/C3xMFmynoyzeWJZJp+IiLLAZBcRERVaYmoyjCd2IGn5h4D03w41ht+/gXe/KVC92AYyT28XRkhERJQ9jUqGPvX8sPxA5qnEzSt5w9+LiS4ioqxwlXYiIiq0xIdxSFr2gU2iCwAgiUha8RHEh3dcExgREVEuaNQyjGheBEp55un3b3csBl9PJruIiLLCZBcRERVKYkoSDJu/z7GP4c/vIaYkOSkiIiKivMuo7nocq7qIiHLGZBcRERVOJiPMNy/k2MV88wJgNjopICIiorzLqrqLVV1ERDljsouIiAonQYDwlPW40tu5MyMRERVsj1d3saqLiOjpuEA9EREVSoKXLzwad0fyyjnZ9vFo3B2Cl68ToyIiIsq7jOquNUcS8EGXAHhb9BCfMgtfUKgheGicEyAR5clff/2Fy5cvAwCUSiUCAgIQERGBSpUqZdnfbDZjx44diI6ORnh4OJo1a5apj06nw969e/HgwQOEh4ejQYMGDv0dCjomu4iIqFASZHKoX2yN1F2rYbl7PVO7vFgpqOu0gyDjt+NERFTwaVQyLOgfArWHB8zXzkC/eHK2fb37vAV1nQ5OjI7I/d24cQ07/tqKVm3ao3TpMg69188//4zdu3eja9euEEURcXFx2Lt3L4oVK4Zvv/0WDRs2tPZNTExEmzZtcO/ePTRo0AD/+9//UK9ePaxbtw4KhcJ6vQ8++ABVq1aFr68vpkyZgnLlymHz5s3w8fFx6O9SUDHZRUREhZbMSwvthG+RvOlbpB36EzCmAioPqOt1hFfn0ZB5aV0dIhE9A53BgofJZgR4KaDVMHFNhZtGLUPD8t5QygWIJStDpi0K8V50pn6Cjz9U1ZpCUPBPPaLckiQJe/7eiQcP7mPP3ztRanAYBMGxS11UqFABX331lfV9Wloaxo0bh7Zt2+LYsWOoWLEiAGD27Nm4c+cOTp06BX9/f1y/fh0RERH48ccfMWLECABA6dKlcfbsWXh6egIA7t+/j1KlSmHZsmV49dVXHfp7FFRcs4uIiAo1mY8/vHu8gYAP/0DAx1EI+PAPeL88HjIff1eHRkT5lJRqQfQDI8Ytj0Gn+dfwyvc3cflOKvQpFleHRuRQGYvUC16+8Hr5jSz7aDqNgqD2cmZYRG7vxvV/cffubQDA3bu3ceP6v06PQa1W4+uvv0aRIkUwd+5c6/HVq1cjMjIS/v7pY9ewsDB07NgRq1evtvZp1qyZNdEFAL6+vlCr1RBF0Xm/QAHDdD8RERV6gtoTgtrz6R2JqMBLSrVgQdQ9rD6cAFFKP3bpThp6fHEd7av6YEb3F7hLHRV6giBAWaY6ZEElbaq7BB9/qF9szaouojyQJAl79/wNQRAgSRIEQcDePX+jdFhZh1d3PUkul6NVq1bYv38/ACA1NRXXrl3LtJZXpUqV8P3339scu3//PlatWoXk5GT88ccfaNmyJV555RWnxV7QsLKLiIiIiNxGYqqIlYf+S3Q9buvZRFy7l+b8oIhcIKvqLlZ1EeVdRlWXJKU/WCRJcll1FwAULVoUDx8+BAAkJaXvROHn52fTx9/fH3q93uZYWloaLl26hDNnzuDmzZvw9X2+N2FisouIiIiIiMjNPF7dBeStqktMSYaY+Cj9lZLs6FCJCqzHq7oel1HdlZEAcyadTmdNVGVMTUxMTLTpo9frodHY7rYaEhKCr776CitWrMDp06exbds2zJo1yzlBF0BMdhEREREROYFoSIRo0D+9I1EuPV7dlaeqLrMRD99ui4dvtwXMRgdGSFSwPVnVlcGV1V179+7Fiy++CADw8vLCCy+8gOvXbXcWv3btGsqXL5/tNQICAtC4cWMcPXrUobEWZEx2ERERERE5kGhMg0V3H0krP0bSL3Ng0d2HaEx1dVhUCGRUdynKVudaXUR5lF1VVwZXVHd99tlnuHjxIsaNG2c91qVLF6xZswZGY3piOiEhAZs2bUKXLl2sff755x+b66SkpODYsWMoV66ccwIvgPL9f8Pk5GRs374d165dw5tvvgkAuHLlCsqXL+/0RdyIiIiInhf79u3D2bNn0apVK4SHh+POnTvw8vJ6btbm8PaQ4fU2RfDtrgcwmv/7A0QuA/rW90eZILULo7MliSIkQyJSD/wGw6bvAFP6emLGM3ug6TAMHk16QNB4Q5BxQX3KP8HLF9pxXwGynP+0E1OSrVVcYlLCf8cf+xkAoFBB5sl1v6jwe3wHxqw8Xt0VVsb+SaOYmBh89dVXEEUR8fHx2L59Oy5cuICffvoJjRo1svabMWMG6tWrhzZt2qB169ZYv349QkND8dprr1n7DB06FKGhoahevToMBgPWrVsHuVyO6dOn2z1udyFI+UhTXrlyBW3btkVqairi4uKsmc6BAwfipZdeQmRkpN0DdSW9Xg+tVmszd5aIiCgnfHaQvYmiiB49euCvv/6CXC7HkiVL0LNnT2zcuBHLli3DunXrXB1ituz9eUgxWpCYKmL2H3HYdi4R9cpoMPPlF+DvJYeXuuAkjsRkPZJ+fg/Gs3uzbFdWqg+fV2ZB5q11cmRU2EgWMwT5U5JdiY/Spy0+RcAn2yDz8bdXaETPxFHjKUmSsOznH3JMdmUIDi6OgYOH2bWoZ+nSpThy5AgAQKFQwN/fH1WrVkXbtm3h7e2dqf/Dhw+xdOlSREdHo0KFChg4cKDNml2iKGLTpk04cuQIlEolIiIi0LVrVyie42rPfP3m48ePR+/evfHxxx9DJvtvJuQbb7yB0aNHF7pkFxEREZGr/fTTT7h16xZu3bqFUaNGWY937doV48ePx/Xr1xEWFubCCJ3HUyWHp0qO93u8gGldgqGUC9BqCk6S63FSDtMVJROnMpJ9PC3RRUS2LBYL9HpdrvomJupgsVjsmjgaNGgQBg0alOv+AQEBGD9+fLbtMpkMXbp0sZna+LzL17+tgwcP4pdffsmU2axYsSLOnj1rl8AKE32KBRZRgkYlg1rJZdKIiIgo7w4ePIgxY8YgICAgU1uFChVw7ty55ybZlcHXs2AmuIgKJIUKAZ9sA5A+dTFhZm8AgN//1kDm7WfTj6iwUygUGDRkOAwGw1P7emm8nusKKXeVr39joihaF0d7POF148YNaLUsw86gM1hwOtqAXw49gj5FRLVQDwxqFAg/Lzk0Kia9iIiIKPeyG38BwM2bNzkGI6Icpa/DlXktLpm3H6ct0nPJ11cLX18+OwurfGVc2rRpg08//RTAf4Ot+/fvY9y4cWjfvr39onNjCQYzXlt2C2N+jsHey8k4HZ2CZfsfof2nV3Hwn2SkGC2uDpGIiIjcSJs2bfDdd99Bp9NZx1+iKOLDDz/EvXv3UKdOHRdHSJnIZJCHVsi2WRFaAZDxC1AiIiJ7y9cC9Tdv3kTz5s3h4eGBy5cvo1mzZjh27BiKFi2Kffv2oXjx4o6I1WXyuihemlnE4l0P8M3O+1m2K2TAzqnlEejNUkgiosKKC9STvYmiiH79+mH79u2Qy+UoXrw4Hjx4gLt372LlypV4+eWXXR1itp7nz4No0EN8cAeJP78HS+xVAIC8eFl4D5oBedEQyDTP1z8PKhge35mRuy9SQfY8Pz/o2eQr21KqVCmcOXMGy5cvx7Fjx6y7Aw0ePJj/AQIwpIlYeehRtu1mEfjtuA5DmwRAJrPfjg5ERERUeMlkMqxatQp//vknoqKikJCQgNDQUAwcOBAVK1Z0dXiUDZnGFzKNL7RvfgPj+QOAKEJVtTFkXpw6Q66T3ZRGIqLCIt+lRT4+PhgzZow9Yyk0JCl9va6cXL6TCqNFggeTXURERJQHL730El566SVXh0F5JPPSQl2rDQAJgkLp6nCIiIgKtXwtEqDX67Fy5cpMx1euXAm9Xv/MQbk7mUyAWpFzEquYVgGlnIkuIiIiyr1169bhwYMHNscOHz6MU6dOuSYgyhNBoWCii4iIyAnyleyaOHEikpOTMx1PSkrC22+//cxBuTuVHOhYI+fpnJH1/SFnVRcRERHlUlRUFL7//nsEBgbaHA8JCUFkZCRSUlJcFBkREbkT0ZAIMSXJ1WEQOVS+kl2//vprlougvvzyy/j111+fOSh3p1HLMb5tEF7QZj1LdFSLQPh6yJ0cFREREbmz7MZfJUqUQPHixXH06FEXREVERO5EEi0wXToCicmuTA7s34NP5szEgf17XB0K2UG+kl2iKGYqoQeABw8ewGg0PnNQhUGgtxxrXgvDiOaBKOIth0ohoEZJT3wzJBRDmgTCx5PJLiIiIsq97MZfAMdgRESUO1JKEpLXf47k375yWXWXySK55L45ObB/D/bt/RsAsG/v3w5PeMXFxeHq1au4evUqbt68mavloFJTU3Hr1i2YTKYc+5nNZly9ehVxcXH2Ctct5SvZ1aZNG0yaNAlJSf99OBITEzFhwgS0bt3absG5M0EQEOCtwJhWRbBhfBnsmlIOXw0qgSYVvOHLRBcRERHlUZs2bbBgwQJcunTJ5vjChQtx/fp11KtXz0WRERGRO5BEC4wXj0B8eAfGY3+5pLor1SQizSQ6/b45eTzRlcHRCa+JEyeiWrVqaN++PVq0aIGQkBCUKlUKb731FnQ6Xab+06dPR0BAAGrUqIEiRYrg66+/zvbakydPRvny5fHGG284LH53kK/dGOfOnYsmTZqgVKlSqFmzJiRJwsmTJ+Hj44Pdu3fbO0a3plbIoFbkK6dIREROIibrYLlzHcZz+yF4aKCu3Q6CxhsyTc7rLxI5U8+ePbF27VpERESgdu3aCAwMxJUrV3Djxg38/PPP8PHxcXWIRERUgEkpSTBs+PL/34hI/u0rePedApmnt9NiMBhFvPrzLXwzJBR+mnylI+wqq0RXhozjDRs1dci9GzZsiO3btwMAJEnCoUOH8Oqrr2LTpk04ePAg/Pz8AAA//vgjFixYgJ07d6J+/frYsGEDevbsiUqVKqFFixY219yyZQu2bNmCJk2aOCRmd5KvLEypUqVw9uxZvPfeewgNDUWpUqXw/vvv48yZMyhdurSdQyQiInIcS8I96OYOg27eCKRE/QTDxq/x6N2uSFr9KUQDdximgkMmk2HNmjVYv349ateujYCAAPTp0wdnzpxBv379XB0eEREVYI9XdWVIr+5KdFoMqSYRKw8+wtlbqbgQm+q0+2Ynp0RXBmdMaQTSZ4Y1aNAAUVFRiImJwfz5861tixYtQq9evVC/fn0AQPfu3dGwYUMsWrTI5hp37tzBiBEjsHz5cmg0GofHXNDlO5Wq1Wrx+uuv2zMWIiIipxKTddB/PhaWuJuZ2oxHtiAl8AV4tn8FMpXaBdERZSYIArp27YquXbu6OhQiInIjNlVd1oMikn9b6LTqLoNRxE9709ee/PjPe/h5pIfLqrtyk+jK4OgKr8cFBQWhQ4cO2Lx5M2bOnAmz2YxTp05h+PDhNv0aN26M1atXW9+LoogBAwbg9ddfR61atRwepzvI939ZBoMBly5dwsOHDzO1cd0uIiJyB5a4aFju3si2PfXvNfBs2Q9gsosKCEmScOXKFcTGxkIUbdc8qVatGoKCglwUGRERFVRZVXVlMB77C1K3sYCDk10ZVV0GY/ri9Ffj0nAhNhUNyztvCmWGvCS6Mjgz4VW6dGns2ZNeTabT6WAymRAYGGjTp0iRIrh//771/ezZsyGKIt566y2Hx+cu8pXs2rZtG/r165ftjkCSVPB2VyAiInqS6eKhHNullKT0xVu9tU6KiCh7Dx8+RNu2bXH8+PEs29euXYuePXs6OSoiIirosqzqsjY6p7rr8aquDK6q7sprouvx85yR7DKZTFAqlQDSlzDIOPY4o9EIuTx947vTp09j9uzZ+OOPP3Dt2jUA6cVJCoUCV69eRVhYmLXv8yRf/1WNHz8ew4cPx+TJk+Hv72/vmIiIiJzDw+vpfRSuXzyVCAAWLFgAlUqFK1euoGzZstYBMBERUU4EtQba8Qtz6CCDoPZ02P2frOrK4KrqrsZNmucr4dW4SXN7h5Kl06dPo0KFCgAAPz8/eHt74+7duzZ97t69ixIlSgBIX6srODgYI0aMsLbfuXMHMpkM7du3x759+xAcHOyU2AuSfI2Sbt68iXfffZeJLiIicmvqWq1ybJcHh0FQcgojFQw3b97EqFGjUL58eSa6iIgo1wSFEvKiodm/ioRAkDmu8ierqq4MH/95DwkGs8PunZWGjZrmOXHVuElzp1R1HT58GLt377ZuPCMIApo1a4aoqChrH0mSsGXLFjRv3hwA0L59e1y9etXm1aRJE7z00ku4evXqc5noAvJZ2VWxYkXcuHEDVapUsXc8RERETiOoNVA36YG0vb9m0SjAK/JtCBpf5wdGlIWM8RcREZG7SDWJ2HxaDy+1HF5ZfH+oM1hwI96IGqWcW0mfkbjKTYWXoxJdKSkpuHr1KkRRRHx8PLZv34558+ahX79+GDJkiLXf9OnT0bRpU7z//vvo2LEjlixZgri4OEyYMMHuMRUm+fovasyYMRg8eDDmzp2LcuXKQRAEm/aMcjp7S0xMxJIlS3DgwAEoFAo0btwYw4YNg0qlyvaczz//HH/88YfNsbCwMHz33XcOiZGIiNyHTOMDr25jIQ8IRsr2FZCSdQAAefGy8OrzFhQlK0FgBQ0VEL1790br1q1RsmRJNG3aFGq17V8NgYGB8PR03DQUIiKivLKIEjpU80WHajl/eWg0i1ApnDvmyk3Cy1GJruDgYBw6dAjt27eHQqGAv78/qlativXr16NNmzY2fevXr4+tW7fik08+werVq1GhQgXs3r0bYWFh2V6/ePHi8PV9vr+wFaR8rCb/ZHLrSY5YoF4URZQpUwbdu3dHgwYNYDAYMGvWLJQuXRpRUVHZLrg2evRoXLhwAf/73/+sx7y9vVG/fv1c31uv10Or1UKn0z33/8EQERVGkskIKS0FkjEFglwByBUQvLRPfd7lhM8OsreePXti/fr12bYX5AXq+XkgIqL8cMbzI7vdGZ01dZEcI1+VXRcvXrR3HE8lCAJOnjxps05Y1apVUbt2bRw7dgz16tXL9tygoCC0bt3aGWESEZEbEpQqCEoVAO66SAXXF198gVmzZmXbHhIS4sRoiIiICoesKryY6HJ/+V6zy9kEQci0IH5gYCAAIDk5OcdzT5w4gS5dukCr1aJJkyYYNmzYc7n1JhEREbmv4sWLo3jx4q4Og4iIqNB5POHFRFfh4Nb7qc+dOxdFihTJsapLrVajc+fOaNasGWJjY/HBBx9gzZo12LZtW7Y7GaWlpSEtLc36Xq/X2z12IiIiIiIiIioYGjZqyiRXIZKvZJfZbMaiRYuwdu1aREdHw2y23So0JibGLsHl5IcffsC3336LjRs3wsvLK9t+H330kU1769atERERgV9//TXbdS1mz56N999/3+4xExERET2LvXv3Yu7cubhy5QqSkpJs2hYvXoyOHTu6KDIiIiKigiNf2x18+OGH+Oyzz9CjRw/cvHkT06dPR9u2bXH37l1ERkbaO8ZMli9fjjFjxmDp0qV46aWXcuz7ZCKsUqVKKF26NE6cOJHtOVOnToVOp7O+bt26ZZe4iYiIiPLrzJkzaN++PSpVqgQfHx907twZQ4YMgclkQtmyZVGlShVXh0hERERUIOQr2fXzzz9j9erVGD9+PABg1KhRWLJkCb799lucOnXKjuFl9ssvv2DYsGFYsmQJ+vXrl+fzRVHEw4cP4eHhkW0ftVoNX19fmxcRERGRKy1fvhyvvfYaPv74Y5QqVQotW7bErFmzcOzYMVy4cAGenp6uDpGIiIioQMhXsis6Oho1a9YEAHh6eiIxMREA0Lt3bxw8eNB+0T1h1apVGDp0KJYsWYIBAwZk2Wf+/PkYMWIEAMBkMmHhwoWwWCwAAEmS8N577yExMRHdu3d3WJxERERE9vb4+Euj0VjHX6GhoahVqxaOHz/uyvCIiIiICox8JbssFgsUivTlvsLCwrBv3z4AwOXLlx32raJOp8PAgQPh4+ODH3/8Ea1bt7a+tmzZYu134cIFa8JNLpfj6tWrCAkJQYMGDVCyZEksWbIEq1evRtWqVR0SJxEREZEjmM3mLMdfZrMZ165dY2UXERER0f975t0YR48ejb59+6JBgwY4cuRIthVXz0qj0dgktR5XuXJl688TJ06ETqcDAMhkMnz22WeYOXMmLly4AH9/f4SFhUGpVDokRiIiIiJnGDRoEKpVq4Z///0X9+7dgyiKqF+/vqvDIiIiIioQBEmSpLye9Pg3iwCwceNGHDx4EBUrVsSgQYMgk+WrYKzA0uv10Gq10Ol0XL+LiIhyhc8OsjdRFCEIAgRBAJBezb527VqoVCoMGzYMQUFBLo4we/w8EBFRfjjy+aHX62AwGJ7az0vjBR8+u9xOvpJdzxsO0IiIKK/47CD6Dz8PRESUH456fpjNZnzz9ecwGJKf2tfLywujxrxhU/DzrCZNmoTffvsNAKBUKhEQEICIiAj07t0brVq1ytR/165d+OSTTxAdHY3w8HDMmDEDNWrUsLZ/8cUX+OKLL2zOCQgIwJEjR+wWs7vJ9b+tS5cuAQAqVqxo/Tk7FStWfLaoiIiIiAi3b9+GXq9HSEgIEhMTodfrs+0bEhICHx8fJ0ZHRETknuRyOXx9tblKdvn4aCGXy+16/7t376JYsWL4+eefIYoi4uLisH37dnTt2hW9evXCkiVLrJXchw4dQrt27TBt2jTMnDkTP/zwA5o1a4ZTp04hLCwMAPDw4UP4+flh1apVNr/j8yzXya5KlSoBSN/RMOPn7LBYLGeJqRYYzRJiH5mgUclQxFsObw8ZFPLCNf2TiIiIns24ceOwfv16rF27FqtWrcL69euz7bt27Vr07NnTidERERG5J0EQ0KRpc6xd88tT+zZp2tyaeLInT09PlCtXDgAQHh6OJk2aoH379mjUqBGaNm2KoUOHAgBmzZqFVq1aYcaMGQCA2rVrY+fOnZg/fz6+/PJL6/U8PDys16M8JLtu3bqV5c+UNwkGM2b/EYetZ/Qwi+nHgrUKTO8SjDplNPD2eL6zr0RERPSfxYsXY8GCBQgMDETLli2xYMGCbPsGBgY6LzAiIiI3VzqsLIKDiyMu7k6WBTuCIKBYsRdQOqys02Jq0KABWrRogeXLl2Po0KGQJAm7d+/GBx98YBNXhw4dsHPnTptzL1y4gBo1akCj0aBevXqYNm0aihQp4rTYC5pcJ7tKlChh/fnQoUP85jAfdAYLxq+IxdFrtovg3dWZ8fryGHz3SknUL6txSNaYiIiI3E9AQAACAgIAAKdPn0ZoaChCQkJcHBUREZH7e1p1lyRJDqvqykm1atWwbt06AEBCQgKSkpIQHBxs0yc4OBgxMTHW915eXpg4cSLatm2LR48eYebMmXjxxRdx5swZaLVap8ZfUORr3lzfvn0hiqK9Yyn07iSYMiW6MkgSMPfPOCQYLE6OioiIiNzB559/jv3797s6DCIiokIjo7rryYSWIAgIDi7u1KquDEqlEiaTCQCseRelUmnTR6VSwWL5L3cwYcIETJs2DXXq1EHbtm3x559/Qq/X49tvv3Ve4AVMvpJd5cuXx7lz5+wdS6EmSRJ+P5mQY5/Ld9PA5c6IiIgoKxx/ERER2VdGddeT0xhdVdUFADdu3EBoaCgAQKvVQqlU4sGDBzZ97t+/bzNF8cnF6LVaLSIiInD+/HnHB1xA5SvZNX78ePTv3x+bNm3CtWvXEBMTY/OizCQJMOaiaEtksouIiIiyMGjQIPz444/46quvcOHChUzjr5SUFFeHSERE5HaerO5yZVVXfHw8tmzZgg4dOgAAFAoFatSogYMHD9r027dvH2rXrp3tdSRJQnR0NPz8/BwZboGWr2TXqFGjcO7cOXTu3Blly5ZFaGiozYsyk8kEtIvIeTvwEv5KcENGIiLHEk1pEI2prg6DKM+mTJmCmJgYvP7666hSpUqm8deff/7p6hCJiIjczpPVXa6o6pIkCYcPH0aHDh1QvHhxTJgwwdo2evRorF27FocPHwYA/Pbbbzhw4ABGjx5t7fPWW2/hzp07AACTyYTJkycjNjYWAwcOdNrvUNDkeoH6x128eNHecTwXygd7oExRFa7FG7Nsf7V1Efh6cjdGIiJHEJP1MN+6hLSDmwBJhKpmKyjDa0HQ+HJjEHILX3zxBWbNmpVtOxeuJyIiyp+M6q67d287rarrwIEDKFeuHERRxP379+Hn54devXph+vTpNhVZr7zyCq5du4bmzZtDo9HAbDbjiy++QMuWLa19IiIi0KhRIyQnJ0Ov16NcuXL4888/c6z+KuwEKas9NsmGXq+HVquFTqeDr6/vM10rPtGM15fewtmY/6oKVAoBr7Uuil51/ZjsIiJyADHxEXSfj4Ul9h+b47KAF6Cd9B3k/sXsfk97PjuI3B0/D0RElB/OfH7cuHENO/7ailZt2qN06TIOvVdcXBwSExMBpE9V9Pf3f+quiSkpKYiPj0dwcDBUKlWWfeLj4+Hl5QWNRmP3mN0Nk125YO8PWEKyGQ+TLTgVnQIfDxlqh2mgUsjgpeYcRiIiexOT9Uj8aQZM5/Zl2S4vEQ7tGwsh8/az6335xz3Rf/h5ICKi/ODzg/IrX9MYzWYzFi1ahLVr1yI6Ohpms9mmnYvU58zPSwE/LwXKBKldHQoRUaEnmdNgOr8/23ZLzBWI+od2T3YROcLevXsxd+5cXLlyBUlJSTZtixcvRseOHV0UGREREVHBka9Sog8//BCfffYZevTogZs3b2L69Olo27Yt7t69i8jISHvHSERElG9ifGz6lriPEbz9IPgEAP+/Vpf51iVXhEaUJ2fOnEH79u1RqVIl+Pj4oHPnzhgyZAhMJhPKli2LKlWquDpEIiIiogIhX5VdP//8M1avXo06dergzTffxKhRozB69Gg0atQIK1eutHeMRERE+SZo/n8nXJkcHk16wKNRN0hpBkAUIXj7Ie3wZsi8/V0bJFEuLF++HK+99ho+/vhj9OzZEy1btkSvXr0watQo1KpVC56enq4OkYiIiKhAyFeyKzo6GjVr1gQAeHp6IjExEb6+vujduzfGjRtn1wCJiIiehcw3ELIixeHVYzzER3eh+2ocJP0DAOmJMI/mfaAoVcnFURI9XXR0NLp16wYA0Gg01oVtQ0NDUatWLRw/fhwdOnRwYYREREREBUO+pjFaLBYoFOl5srCwMOzbl77o7+XLl/mtIhERFRiS2QQxJQk+w+bAcj8WyWvnWxNdACAZEpGy+XsY/loGMTXZhZESPZ3ZbM5y/GU2m3Ht2jWOwYiIiIj+X74qux43evRo9O3bFw0aNMCRI0cwYMAAe8RVqJgtIvQpIgBApRDg7SF3cURERM8HKTUZutkD4TftF6Rs/THbfqk7foGm9QDAw8uJ0RHl36BBg1CtWjX8+++/uHfvHkRRRP369V0dFhEREVGBkK9kl8lksv78+uuvo2TJkjh48CAiIyMxaNAguwVXGCQkm7HhuA4bjifAkCaiWklPjGlZBC/4K+GtZtKLiMhRJEmC8fRuCF5aWO5eh2TQZ9/ZYobp6kmoa7Z0XoBEebRmzRoI/7+pQtmyZXH06FGsXbsWKpUKw4YNg4eHh4sjJCIiIioY8pXs2rVrF1q1agWZLH0WZNeuXdG1a1e7BlYY3E80o/+iG4h59F9y8M7ZRCQYLJjeJRjJahEGowg/jRwqhQAvJr+IiOxGMhthunIckMkhmYy56G96ah8iVzp8+DAqV64MrVYLAKhcuTJmzJjh4qiIiIiICp58rdnVsWNHlChRAhMnTsTJkyftHVOhkJRqwaeb42wSXQDQt74/Rrcsgsmrb6PlnKvoNP8aWsy+io9+j0NCstlF0RIRFT6CTA7B0xviw7uQB5cGFMoc+yvLVnNOYET59MUXX6BYsWLo2bMnfvvtNxiNT0/iEhERET2P8lXZFRsbi9WrV2PFihWYP38+KleujAEDBqB///4oWbKkvWN0S2YR2Ho20eZYhWA1OtfUYuh3N5FmlqzHTRYJv53Q4d97afh2aEloNazwIiJ6VoJcAY+mLyN191qYzu2Hul5HpO3fmGVfZZWGENRcr4sKtp9//hmRkZFYsWIF+vbtC41Gg169emHAgAFo1KiRdYojERER5Y1ep4MhxWB9r/HUwPf/K6kdYenSpThy5AgAQKlUIiAgABEREWjbti28vDKPSR8+fIhly5YhOjoa4eHhGDRoUJYb0xw8eBBbt26FTCZD7969UanS87vjeL4qu4KCgvD666/j0KFDuHr1Kvr06YOffvoJpUuXRrNmzewdo1symUWYLJLNsb4N/LF4132bRNfjzsak4vKdVGeER0T0XJBpi0L1YmsYtv4Iz6Y9oarVOlMfZcW68BnyPmRevi6IkCj3VCoVunbtijVr1iAuLg7z5s3Dv//+i2bNmlnX8CIiIqK80et0+G7xQiz96Tvr67vFC6HX6Rx2z23btmH79u2oWLEiwsLCkJqaijlz5iAkJAS//PKLTd87d+6gRo0a+PXXX+Hn54dFixahYcOGSE623Ul83Lhx6NChAwwGAzw8PDBo0CDs3bvXYb9DQffMuzGWLVsW77zzDurWrYspU6Zgz5499ojL7SkVAlQKAcbHElu1Smkw87e7OZ637mgCqoV6wkOVrzwkERE9RublC+9+U5G691fof/wfNB1egab9UBgvHQHkCqgjGkLw0kLm5bhv7ogcwdfXF0OGDEHdunXx6aef4scff8TNmzdRp04dV4dGRETkVgwpBlgstksKWSxmGFIMDq3uKlGiBF577TXr+w8//BBz587FwIEDUbp0aTRs2BAAMHPmTPj6+uKvv/6CSqXCa6+9hnLlymHhwoV4++23AQArV67EokWLcOTIEdSsWRMA8Oabb+L+/fsOi7+ge6aMyuHDhzFu3DiEhISgW7duKFOmDNavX2+v2NyaUi6gYzWfTMfFrIu6rNLMEizSUzoREVGuyTS+8GzVH34TF0NVsQ5kAcXg0bQHNC0jIQ8qyUQXuZ3Y2Fh8+umnqFmzJqpUqYIzZ87gs88+Q+vWmSsXiYiIKGt6nQ53797BgwdZJ4QePLiPu3fvOLTC60lvvfUWKlWqhM8//9x6bOPGjejduzdUKhUAwN/fH506dcLGjf8tz/H111/jpZdesia6gPSK8OLFizst9oImX5VdM2bMwIoVK3Dt2jU0bdoUs2bNQq9eveDn52fn8NyXl1qOCR2K4WR0Km7eT19ANuaRCRVfUOPSnbRsz2ta0QueSlZ1ERHZk6BQQvD2c3UYRM9k06ZNmD9/Pnbv3o3SpUujX79+WLVqFSpUqODq0IiIiNxKxtTFjIouQRAgPVZ0IggC/vxjAwBALldgxMixDq3yelyTJk2wbds2AEBycjLu3LmDsLAwmz5lypTBli1brO+PHz+OmTNn4o8//sCePXsQFBSEbt26oXz58k6JuSDKV7Jrw4YNGDFiBPr164fQ0FB7x1RoBHor8MuY0th8Wof1RxOw84Iew5sXwaSVsVn299PI0aqyD2QyLjBLREREtv78809UqlQJs2bNsk5tcKZt27bhzJkz1gG0ry/XuSMiIvf05NRF6YnZVY+/d8aUxsdptVokJqZvdpeSkgIA8PGxnTXm6+sLgyF9QX2z2YyUlBT8+OOPCA4ORtu2bXHmzBm8++67WLNmDbp06eKUuAuafCW7zpw5Y+84Ci0/jRxVQjwQ4FUEaoWAF/yUGNemKBbtjIfJ8l+/Yr4K/DC8JLzV3ImRiMiRRGMqYEqDqLsPyBWQeflB8NRAkCtdHRpRjhYtWuSye0dGRmL37t3o1q0b1q5di+nTp2Pfvn3chZuIiMjO4uPjERgYCADw9vYGACQkJNj0efTokfVLJ4VCAQ8PDygUCvz111+QydJniqnVakyePJnJLnIMiyhhwzEd1h5NAAAoZMDrbYri13FlsP+fZOgMFpQPVqN2mAZ+nnLI5azqIiJyFNGgR8rOVUjd8Quk1PQdbATfQHh1ew2q6s0g02Rea5HoebdhwwasW7cO586dQ8WKFWEymdCwYUO8/fbbWLVqlavDIyIiKjQsFgt27NhhXYfTw8MDZcqUwcWLF236Xbx4EZUrV7a+j4iIQKVKlayJLgCoWbMmVqxY4ZzACyAuDuVgMgHw8fyvWsssAp9FxaP3V9dx6Goyoh8Y8dPeB5AJYKKLiMiBxJQkGP74Fil/fmdNdAGApH+ApKXvw3hyJySzyYUREhVM69atQ6NGjVCxYkUAgFKpxJAhQ7Bx40aYTPzMEBGR+9F4aiCX/1f7Iwi2f4s//l4uV0DjqXF4TEajEa+//jri4+MxceJE6/E+ffpg1apVePToEQDg+vXr2Lx5M/r06WPt069fP+zbt886tREA/vrrL5sF6583rOxyMEEQ0LOOH5bseWBzPMUk4e9LSQCAumU04DJdREQOZkpD6u512TYnb1wIVfXmELy5OyPR4y5duoRatWrZHAsPD0dqaipu3ryJcuXKZTonLS0NaWn/bcij1+sdHicREVFu+Wq1GDFyLAwpBjx4cN+6GH0GSZLwUufuCAwsAo2nxiHrdV2+fBmvvfYaRFFEfHw89uzZgyJFimDr1q2oVKmStd/UqVOxc+dOvPjii2jQoAF27tyJ1q1bY+jQodY+Y8eOxY4dO1C1alU0a9YM586dQ2xsLDZv3mz3uN2FXZJdycnp35B7eXnZ43KFjr+XHJ1q+GLTqcwDPZVCwLQuxaDVMO9IRORIxotHAEnMtl1KfARRFw8Zk13kJsxmM/R6PQICAhx6n6SkJGifGORn7MCdlJSU5TmzZ8/G+++/79C4iIiInoWvVptjEiswsAiCg19wyL0HDx6M+vXrA0hfc8vf3x/vv/++zdTEDD4+Pti3bx+2b9+O6OhojBw5Ek2bNrWpPlOpVNi0aRP27NmDy5cv4+WXX0aLFi2g0Ti+Iq2geqYMy+nTp/HKK6/gxIkTANLnhP7444+oXr26XYIrLHw95ZjWJRjliqmxdN9DPExOX5m+TpgG07oUQ4kAlYsjJCJ6DpiNT+3CaYzkDlJSUjBixAisXr0aZrMZRYoUwUcffYQRI0Y45H5eXl6ZKrN0Op21LStTp07FhAkTrO/1ej138HYyKdUACRJkHvwymogoJxlTGh/fndHRUxfbtGmDNm3a5Lq/QqFA+/btn9qvadOmaNq06bOEVmg8U7Jr4MCBGDp0KPbu3QsA+PbbbzFo0CCcPn3aLsEVJr6ecgxuHIBedfxgFgG5DBAEwI8VXURETqEMf/EpHdSQBzrm2zsie5o7dy50Oh1u3LiBYsWK4ejRo+jWrRuaNm2KChUq2P1+FSpUwNWrV22O/fPPP1Cr1ShdunSW56jVaqjVarvH8rxLNYnwUOa85K6UaoCYZkDaoc3waNgJYLKLiChHj09pzOCoqYvkPHlaoL5fv36Ij4+3vr916xb69u0LjUYDjUaDvn37Ijo62u5BFhYqhQx+XgoU8VHA30vBRBcRkRMJGh8oK9TOtt2j6csQlKy0pYJnxowZOHDggPX9rVu30K5dO4SEhEChUKBBgwYoX748YmJiHHL/Hj16YO/evdaEl8ViwdKlS9GpUycolUqH3JNs6QxmXI1LQ1JqDlOxUw2w6O4jeeNCPJreBan7fnVihERE7s1Xq0Vw8AvWFxNd7i9P2ZbatWujdu3a+OCDDzBo0CAMGTIEzZo1Q7du3QCkb009ePBgR8RJRET0TGReWvgMn43ExZNh+ufEfw2CAHW9l6DpMAyC+vld14AKrnbt2mH48OFo2bIlZs+ejQEDBqBbt244e/YsihUrhmPHjuH+/fvWtT/srWfPnvjll1/QokUL9OzZE8ePH8eNGzee6+3MnUVnMCM+0YI5m+Jw8GoyNrwRhiI+tsN3KdUAKS0Fhq1LkLpvA8Dp2ERERBAkSZLycsKNGzcwatQoSJKERYsW4dy5c9ZpjI0bN0bXrl0zbdvp7vR6PbRaLXQ6HXx9fV0dDhERPQMxWQcxSQfTxUOAXAlVRCMIag/INPb9/zufHWRPaWlp+OCDD7By5UosWLAAZcuWxZo1a/DgwQOEh4dj8ODBDv3vTJIk/PHHHzh9+jSCgoLQq1evPC2Mz89D3jyZ5Mqw4Y0whAd7AHh6kktWJAR+by+BzMexGxgQETkSnx+UX3meR1e6dGlERUVh2bJlaNmyJcaNG4ePP/4YcrncEfERERHZlcxLC5mXFopiJV0dClGuqdVqzJo1C5GRkRg+fDhKlSqFL774AsWKFXPK/QVBQJcuXdClSxen3O95lV2S60mSyQhJtEC/aALMNy84MUIiIiL3kKc1uzJYLBb069cPx48fx8mTJ1GvXj2cOnXKzqFl7csvv0TZsmXh7e2NBg0a4ODBgw45h4iIiKigKV++PA4cOIBGjRqhbt26WLJkiatDIjuRJAlL9z9C1wXXckx0AYCgVEGm8YHva1/Ad/w3kJcId1KURERE7iFPya4LFy6gSZMm8PDwgIeHB3r06IHp06dj1qxZ6NWrFyZPnoyUlBRHxYoff/wRkydPxrx58/Dvv/+iYcOGaNu2LW7dumXXc4iIiIgKirS0NIwcORLe3t7w8PBAmTJlEBgYiL1792L9+vVo1apVpt0Syf0IgoCBjfyxckxpVAv1yNU5Mm8tVBVehPaNr5n0IiIiekyekl0DBgxAu3btEBsbi9jYWLRt2xYDBgxA+/btcerUKRiNRtSoUcNBoaZvtf3KK6+gW7duKFasGD799FP4+vpi0aJFdj2HiIiIqKCYN28erl+/juPHjyMhIQHfffcd3nzzTRiNRvz5558YPnw4Wrduzcr1QsBPo0C1kp5YNCSUSS8iIqJnkKdk17Vr1zBq1CgEBQUhKCgIo0aNsn6T6OXlhc8++wzLly93SKCPHj3CxYsX0aJFC+sxQRDQokULm+24n/UcIiIiooLk2rVr6NGjBypUqACtVos2bdqgUqVKuHHjBgCgb9++OHHihNPW7yLHs0vSa+THDo6SiIio4MrTAvWRkZFo3bo1evbsCQBYu3Yt+vbta9OnTp069ovuMXfu3AEABAUF2RwvWrQojh07ZrdzgPTpAmlpadb3er0+XzETERERPavevXujb9++uHr1KooVK4Zjx47h1q1bqFevnrVPQEBAnnZHJPfgp1HAr6QCi4aEIvq+CVpN7jaEknlrIfPWQjKbHRwhERHlx6lTpxATEwMAUCqVCAgIQKVKleDt7Z3tOZcvX0Z0dDTCw8NRqlQpm7Zdu3YhOTnzeo/FihVzWI6moMtTsmvhwoVYuXIl9u3bBwB4++23MyW7nE0mk0GSJLueM3v2bLz//vvPGhoRERHRM2vbti22bt2KVatW4eLFi6hZsyYWLlwIHx8fV4dGTpKR9DIYxTydJyjyvPE6EdFz58D+PTh8aD86vNQVFStWxqWL57Fl8++oV78RGjZq6pB7fvrpp4iKikK9evUgiiLi4uJw4cIFtG7dGvPnz0f58uWtfU0mE/r27Yu//voLEREROHnyJEaMGIHPP//c2mflypW4ffu29b0oitiyZQtGjhzJZFduyOVyDBgwAAMGDHBUPNkKDg4GAMTHx9scv3fvXrZl+/k5BwCmTp2KCRMmWN/r9XqEhobmK24iIiKiZ1WnTp3ndrBK/9Go8rWROhERZePA/j3Yt/dvAEDUlk0IDCyCqK2bYDKZrMcdlfCqXr06Nm3aZH1/7949DBs2DI0aNcKJEydQokQJAMD8+fOxe/dunD17FiVLlsSJEyfQoEEDNGrUCL179wYALF682ObaUVFR2LJlC4YOHeqQ2N2BXZ6YnTp1ssdlchQQEIDw8HDs3r3bekySJPz9999o2LCh3c4BALVaDV9fX5sXERERUUEyZ84c7N+/39VhEBERuaXHE10AYDSmYdnP38NoNFqP7dv7Nw7s3+OUeIKCgrB69WoIgoC5c+dajy9duhR9+/ZFyZIlAQC1atVC69atsXTp0myv9cMPPyAiIgL169d3eNwFVZ4qu/7+++8sj//55582bc2bN3+GkLI3ceJETJgwAR07dkT9+vXxySef4OHDhxg9erS1z6hRo3D48GGcOnUq1+cQERERFVTnz5/PVKUOAFu2bEFaWhpMJhMAoEqVKihatKizwyMiInJLhw/ZfmEkSRJEUcy05NHhQ/sdVt31JI1Gg3bt2mHnzp0AAKPRiEuXLtnMPAOAGjVqZJvsevDgATZu3GiTMHse5SnZ9fiuhjm15XUNrdwaOXIkEhISMHToUNy7dw8RERHYvHkzSpcube1jsVhgfmwxztycQ0RERFRQzZgxA+vXr8+ybc+e/75tXrt2rXUTISIiIspZh5e6ImrLJhiNadYchij+tzaiIAhQqdRo18HxM9ke98ILL2Dr1q0A0pdUEkUx0yY0gYGBSEhIyPL8ZcuWQSaTYeDAgY4OtUDLU7KrWrVqKFWqFD755BN4ePy3BXJYWBiuX79u9+Cy8vbbb+Ptt9/Otn3x4sWZkm1PO4eIiIiooKpevTqOHz+OxYsX2yxY++qrr6Jz587o0KEDgMy7TxMREVH2KlasjMDAIlj28/cQRdEm0SWTySCTydB/wBAUKerc56vBYIBGowEAqFQq67En+2S0PemHH37Ayy+/DH9/f8cGWsDlac2uw4cPo0SJEujZsyd0Oh1Kly5trZDK+NnVFVMymQxyee62ZSYiIiIq6N59913Mnj0bQ4YMwfbt263jLY1Gg6JFi9q8JyIioty5dPE8fln+IywWi02iC0iv8LJYLFix/CdcunTBqXEdPnwY1apVAwD4+voiMDAQMTExNn1u3bqFsLCwLM89d+4cRowY4ZRYC7I8Jbs8PDzw9ddfY+bMmWjfvj3mzZvnsCmLRERERJQuMjISe/fuxeLFi9GjRw88ePDA1SERERG5tS2bf0daWppNTkMm+y9FIkkS0tJSseXPjU6Lad26dTh69ChGjhxpPdauXTts2LDBGmdaWho2bdqE9u3bZzr/hx9+QHh4OJo1a+a0mAuqPE1jzNCjRw/Url0b/fr1w5YtW+wdExERERE9oUyZMti/fz/eeecdVK9enbtFExERPYN69RvZ7MYoCAJkMhkkSbJJgNWr38gh979//z42bdoEURQRHx+P7du349dff8WsWbPQqdN/64TNmDEDdevWxYABA9C+fXssX74ccrkcb775ps31DAYDVq1ahXfffdch8bqbPFV2Pa5kyZL4+++/0bhxY7Rq1cqeMRERERFRFpRKJebOnYvvv/8eJUqUQLFixVwdEhERkVtq2KgpGjdpbn2vUqkxaPBwm7WwGjdp7pCdGGvWrIkSJUrgm2++wZIlS7Bv3z7UqVMHly5dwrRp02z6hoeH49ixYyhatCg2bNiAWrVq4ciRIwgMDLTpd/r0aTRr1gyDBw+2e7zuSJA4D/Gp9Ho9tFotdDodv0UlIqJc4bOD6D/8PBARUX444/lxYP8eHD60Hx1e6oqKFSvj0sXz2LL5d9Sr38ghiS5yjnxNYyQiIiIiIiIicncNGzW1SWpVrFQFFStVcWFEZA/5nsZIRERERERERERU0DDZRUREREREREREhQaTXUREREREREREVGgw2UVERERERERERIVGvpNdkZGRiIyMfOoxIiIiIrKPBQsWIDIyEocPH87xGBEREdHzLN+7Md64cSNXx4iIiIjIPu7du4cbN27AYDDkeIyIiIjoeSZIkiS5OoiCTq/XQ6vVQqfTwdfX167XtogS9CkWyAQBoiTBSy2DSsHZpURE7s6Rzw4id8PPAxER5QefH5Rf+a7somenM1gQdVaPH/c+QPQDE4p4y9Gnvj/61feHnxf/1RAROZqYlABIIiSzGYJSDag9IFOqXR0WERERERE9g3xlVCRJgiAIWbbdv38fRYoUeaagnge6FAumrbuNXReTrMfuJ1mwcPt9bDubiJ9GloSfhgkvIiJHEI0psNy5geSVc2C+eQEAIGh84dGiDzxbRkKm4TeHVPDodDp4eXlBoUgfHxw9ehTR0dGoV68eSpQo4eLoiIiICh9JkmCxWKzPXnsRRRGiKAIA5HJ5tvkVyr88zZczGAwYOnQofH19ERISgvfeew9ms9mmT9GiRe0aoLsyWUQkGMyIeWhEzEMjEpLNMFtEa/ul26k2ia7H/ROXhvVHdTA91p+IiOzHcvcmdHNfsSa6AEAy6JHy53dIWvkxxGS9C6MjsmU2mxEZGQl/f3+UKFECp0+fxtixY1G3bl307NkT5cqVw6+//urqMImIiAoNSZJw/dpVLPv5B3zz9efQ63V2vf6gQYOgUqng4eEBlUqFwMBANGvWDAsXLoTJZMrU//vvv0dYWBgUCgUqVaqE33//3aY9OTkZY8eORfHixaFUKlGyZElMnz4dFovFrnG7kzylJ9977z3s2rULH374IeLj4zF//nwcPnwYGzZsgIeHh6NidDv6FAs2n9Zh0Y77uJ+U/h9XkK8Cr7cpitZVfCAIwM/7HuZ4jdWHH6F7bS0CvLh+FxGRPYlJCUhePRewmLNsNx7bBqnzaMCL1V1UMKxbtw67d+/GypUr8c8//2Do0KG4c+cO9u3bh4oVK2LhwoUYP348OnXqBJVK5epwiYiI3JYkSbhx/V/s3fM37t69bT1uMBjg66u1671atmyJ7du3Q5Ik3L9/H9u3b8fkyZOxevVqbNu2zZpj+f333/Hqq69i2bJl6NixI77//nu8/PLLOHz4MGrVqgUAmDRpEjZv3oytW7eiUqVKOHjwIDp37gxfX1+8/fbbdo3bXeQpk7J27VqsWbMG48aNwwcffIATJ07g33//RefOnZGSkuKoGN2KwShizeFH+GBjnDXRBQD39Ga8u/4ONp3SwWyR8DAp6z+yMjxMMoOFjEREjiDBfO1Mjj1SD/yeYzuRM+3duxdvvvkm+vTpg+nTp0Mmk2HcuHFo1KgRAgMD8e6770KtVuPChQtPvxgRERFl8ngl19o1vyAu7o7T7i0IAooWLYq+ffti165dOHz4ML766itr+7x589C9e3f06dMHPj4+ePPNN1GtWjV88cUX1j6nTp1Chw4dUK1aNSiVSjRt2hT169fHqVOnnPZ7FDR5Snbdu3cPERER1vflypXDnj17EBsby4TX/0sziVi083627V9siwcAhBfLeQHkMkFcIJmIyCFyMUVcSk2CJHIqORUMKSkpCA4Otr4vVaoUypYta30vCALCw8Nx+/btrE4nIiKibGSX5JIkySXxlC1bFu3atbMuTyCKIg4fPoxmzZrZ9GvZsiUOHDhgfd+/f39s3rwZx48fR3JyMrZv344jR46gX79+To2/IMlTsqty5cq4ePGizbHg4GD8/fffuHv3Lrp27WrX4NzR+dhUpJqy/2Akpoq4Hm/EqJY5L+I/vHkg/LkjIxGR/cnlEHwDc+yirNIIgozTyKlgqFu3rs03s+3atUP58uVt+sTExKB06dLODYyIiMiN3bhxrcAkuR5XoUIF3LhxAwCQkJCAtLS0TGujBwUFIS4uzvp+7Nix6NatG2rXrg1vb2+0a9cO06ZNQ6dOnZwZeoGSp5H88OHD8f3332c6HhQUhJ07d+LOHeeV+hVUqaanVwIYzRL8veSY1rlYlu0v19aiflkve4dGREQAJEmEZ7Ne2bbL/IKgLFPViRER5WzQoEHYsmULHj5MX+9z5MiRqFmzprX93Llz8Pb2RuXKlV0VIhERkdvZ8ddW67pcBSHJlUEUxafuzvhknzfffBN//vknjh8/jrS0NOzcuRMfffQRvvzyS0eHW2DlKdk1dOhQdOzYMcu2oKAg7Nq1C999951dAnNXESU8c2yXy4ByxdTQqOXoUkuLrZPKIrK+P+qW0aBTDV+sez0MkzoWg4dSQEKyGTfup+HmfSMSDGbuzkhE9IxEQyKSV34MZfiLUDfonKld5l8M2je/geDp44LoiLKm0Whw8uRJaLVZL4yblpaGH3/80clRERERubdWbdojOLg4ADw1ueRMly9fRpkyZQAAfn5+8PDwwL1792z6xMfHW5c4sFgsWLRoESZOnIhatWpBpVKhWbNmGD58OD7//HOnx19Q5GmenEqlQufOmf84yFCkSBEMHz78mYNyZ55KGZpX8sbfF5OybG9X1RdqRfoHydtDDm8POd7qGIQ0kwSlQoBGJYM+xYLVhxPw7a77eJScvsh9EW85xrYpig5VfeHjKXfa70NEVKhIIoyn/obp4mF4Rb4NzxZ9kHZyF6Q0A5Slq0AeHAZT7FV4BIW6OlIiGzntev3iiy86MRIiIqLCoXTpMig1OMxm90VBEFxa5XXlyhVs27YNn3zyCQBAJpOhQYMG2LVrF8aOHWvtt2PHDjRs2BBAeqJOoVBkilsURSiVSucFX8DkeYH6GTNmZNs+Y8YMxMfHP3NQ7kyrkePDl19AnTBNprbG4V6Y1iU4U7LKQymDViOHRiWDIU3ELwcfYs6mOGuiCwDuJ1nw/oa72HhCl6upkkRElJlkTAMkEVJqMpKWzoTum0kQH96BZExFyp71SPioP8QHdyAm62D65ySSN3wFw5/fw3I/FmKy3tXh03Ns1qxZiI2NzbJt48aNiIqKcnJERERE7k8QBISVKYeBg4ehV+9+KFbsBetxR5MkCWazGUajEbGxsfj555/RqlUrNGrUCGPGjLH2mzRpEjZu3Iiff/4Z8fHxmDNnDi5cuIDx48cDSE+Ide/eHXPnzsXBgweRmJiIqKgofP/993j55Zcd/nsUVHmq7Jo3bx6KFct6nSkA8PX1xbx58zBnzpxnDsyd+Xkp8PmAEniQZMbOC4kQBAFtqvhAq0lPauUkzSxi8a4H2bZ/+Vc8OtX0hYeSCycTEeWVoFJD9WIbeDZ9GYK3H2A2ATIZUg9ugvnmBShKV4G6RjPo5g6DJe6m9TzDpm+hqt0W3n0nQ6bxdd0vQM+lo0ePYvPmzZg+fXqW7REREejSpQvOnj0LGTdWICIiyrOMpFfpsLI2lV6OIpfLsXv3bnh4eEChUMDf3x9Vq1bF//73PwwdOhQKxX+pmo4dO2LJkiX48MMPMWbMGFSoUAEbN25EtWrVrH0WLVqE9957DwMGDMC9e/cQEhKCiRMnYsqUKQ77HQo6QcpDjV6VKlWwfv16VKxYMcv2ixcvolevXjh37pzdAiwI9Ho9tFotdDodfH0d+0fO3stJGP3TrRz7LBtVCrVKZ64cIyKinFmSdDBfPQXDxq9guXsDACB4+8GzeR8oK7wIyJVIWjoTlrvXszzfs91geHYcDpkq+yllGZz57KDCbcaMGVAqldkmu4Cnj9FcjZ8HIiLKD1c9PyRJsia9EhN1GDR4BHz4/HIrearsunbtGsLCwrJtDwsLw7Vr1545qOdZmjl3uzkSEVHeSKIFlhvnkLj4LeCx73mkpAQYNn0LjWwMlOG1s010AUDq7nXwbD0QyEWyi8herl27hvbt2+fYJ2MMVlCTXURERO7k8Uovi8ViU2lF7iFPte6enp64f/9+tu3379+Hp2fOuxFSzqqW8ERO04PlMqB8sNp5ARERFRKSIRFJq+faJLoeZ7lzHabLR3O+RmoyJAPX7iLnetr4C+AYjIiIyBEyFn8n95OnZFe9evWwdOnSbNuXLVuGevXqPXNQzzMPpQwtKnln296xui9U8oKzLSoRkbuQUg0Q72e9wDcASGYjoMzFlwlKlR2jInq6evXqYcWKFRDFrKu/L168iNOnT6NWrVpOjoyIiIioYMpTsmvChAl477338MEHHyAxMdF6PDExER988AHee+89TJo0ye5BFhaJKRY8TDLjYZIZJkvWA1atRo4PeryAhuW9MrU1r+iNqZ0y7+ZIRERPJ5nScmw3XTkOdfVmyKm8Vh5cGkJuEmJEdhQZGYnbt2+jW7duuHLlivW4KIrYuHEjOnbsiFdeeQVardaFURIREREVHHmqx2vTpg3mzp2LiRMnYsaMGShevDgkScKdO3egUCiwYMECtGzZ0lGxuq2kVAtiHpqwcEc8zkSnQKOWoWstLfrU84efRp5pW1M/LwU+jQxBgsGCvy8lQiYALSr5wMdD/tTdHImIKGsyH39A7QmkpWTZLiXrAJkc6iYvI23PuswdBAFefd6GwN0Yycm8vLzwxx9/oEuXLqhQoQK0Wi0CAwMRExMDo9GIrl27Yt68ea4Ok4iIiKjAyNNujBlu3LiBtWvX4sqVKxAEAeXLl0fv3r1RqlQpR8Tocs+yA0Rymoht5/SYvu5OprYXtAr88mppBPkq7RUqERFlQzKmIvn3b5C6Y0WW7fIS4dC+sRCQyZC6dwNSdqyAlPgovS2kHLx6T4KiZEXIPDJX3maFu8+RvaWkpGDt2rU4evQokpOTERwcjPbt26Np06auDu2p+HkgIqL84POD8ivPK62dPXsWW7duhSRJGDduHKpWreqIuAqNVJOI937NnOgCgDs6Mz7eFIf3e7wAbw9WbBEROZKg8oCmwysQE+7BePwvmzZ58bLwfe1zyLz9AACerfrCo1FXSKY0CDIFIJdD8NJmqsQlcpaEhASsXr0ad+/eRZs2bdClSxdXh0RERERUYOUp2bVlyxZ07doVgiBAEARMnz4dGzduRIcOHRwVn9vbcloPc9bLcwEAtp9PxLtdg50XEBHRc0zm5QvvflMgdRuLtGPbIBlToaraBPKgUMi8/lvvSFCoIHhzIXoqGHQ6HWrUqIHo6Gh4eXkhKSkJo0ePxqJFi1wdGhEREVGBlKcF6mfOnImxY8ciOTkZSUlJGDNmDGbOnOmo2NyeJEm4ft+YYx+zCJgseZ5JSkRE+SClpQCiBYKHFzyavgyvLmOgDIuwSXQRFTTff/89/P39cfv2bSQmJiIqKgpLlizBrVu3XB0aFVCSxezqEIiIiFwqT5VdFy5cwObNm6FQpJ/23nvvoXTp0o6Iq1AQBAEVgnPetUulEKBUcFoMEZEjSWYzxKRHMGxZAuPxvyCZjVCWqwmvLmMgCwrN9TpcRK5w4cIFvPrqqwgOTq8Eb9u2LRo3boxLly4hNDTUxdFRQSNZLIDFDMjzvFoJEdFzxWw2Qy7PvGEcFQ55egrq9Xr4+/tb3/v7+0Ov19s9qMKkTYQPZm+Kg9GcdfVWx2q+UMr54SIiciTx4W0kzBkMKSXJesx0/gASLhyE99CZUFVrBpna04UREmVPp9PZjL+A9DGYTqdzUURUkEkpiTBsWgxNl9GQcfdYIqIs6fU6LP3pe/j6atGkaXOUDivr1KTXnDlzsH37dgCAUqlEQEAAIiIi0LNnT5QvXz5T/4sXL+KLL75AdHQ0wsPDMXHiRJQoUcKmz8aNG7Fx40bEx8ejRo0amDBhQqbxw/Mkz1/5rFuXeTv2J4/17Nkz/xEVMh5KGeb1DcH4FTGwPLF2V1hRFSZ0CIKXmovTExE5ipikQ+LSmTaJLitJQtKyWQj4qD7AZBcVYIcOHbJ5Hxsbm+lYgwYNEBIS4sywqACQJAlSSjIgWQAAov4BUvf+Cs8Or0BM/v+EqFzBClYioscYDAYYDMkwGJKxds0vCA4u7tSk17lz5/Dw4UN88sknEEURcXFx2L59O6pUqYJp06ZhxowZ1r4XL15EvXr10LNnTwwZMgRLly5FvXr1cPLkSQQFBQEA/ve//+HLL7/EjBkzUKpUKSxbtgwNGzbEsWPH4OX1fP7/X5AkKdcLRuX2X3oeLplnFosFV65cgUKhQFhYmHVKZXb+/fdf3Lljuxuil5cXatasmet7Put2p4Y0EQ+SzPh+932cvJkCjVqGnnX80LqKD/w0LDEnInIkUXcfD6fkvJGKzyuzoK7Tzq735VbZZC89e/bE+vXrn9pv7dq1BfYLR34eHEtMTYYl7iYSF02CqIu3HpcHl4bvmPkQ/IpCpvJwYYRERPnjqOfH3bt3sPSn76zvBUGAJElOS3oNGDAAd+/etVZ3Zfjtt9/QvXt3bNiwAd26dQMAREZG4tatW9i/fz8AwGg0omzZshgwYABmz54Nk8kEb29vzJs3D6+99hqA9Cma5cqVw+uvv46JEyc67PcoyPKUaUlMTHRUHLny4Ycf4ssvv0RAQABSUlJgMpnwzTffoFOnTtmeM3fuXKxbtw4VK1a0HitTpgyWLl3qjJABABq1DBq1CpM7BSPVKEIQAK2nHDIZpy8SETmaaHj6s8vy8M5T+xC5yvLly/HTTz89tZ+nJ6sTn1cyDy8IoRXgN20FHk7tCFjMkGmLQjvpB8i8mFwkInqajIKduLg7Lqn0ytCtWzfUr18f3333nTXZtW3bNkyZMsXaR6VS4aWXXsK2bdswe/ZsPHr0CEaj0WY9dYVCgRIlSmDLli1MduWGt7e3o+J4KovFgpSUFFy4cAEBAQEA0hfI79OnD/7991/roq1Zad68eZbTL51No5JBo8rTBphERPSMZN5+gEwOiJZs+8hDMq+NQFRQeHiwIoeeTpDJIVpMEJRqqOp2gPHkTgDc8ZuIKC+ySno1bd4SpUuXcVoMderUwcaNGwGkV7Y9evQo0/pcJUqUwNq1awEAQUFBKFeuHJYuXYoOHTpALpfjzJkzOH78OIoXL+60uAsat8m8yOVyzJo1y5roAoAxY8bAYDDgxIkTOZ6bmpqKEydO4N9//4Uoijn2JSKiQkaugKpak2ybBS8tlKUjnBgQEZH9SaIIS3ws/P63Bl593oLflKUQ9Q9cHRYRkVvKSHrdvXsbO/7a6tR7e3p6IjU1FUD6lMWMY4/TaDTWNgBYsWIFjh07hrCwMNSvXx9du3ZFq1atYDKZnBd4AePWC0YdPXoUAFC2bNkc+0VFRSE6Ohp3796FWq3Gt99+i44dO2bbPy0tDWlpadb33HGSiMh9yTQ+8O47BQm3r0G8F23bqPKA72ufQ/DQuCY4IiI7kdIMUISUg0zjk36gWEmIqcmQjKkQuF4XEVGePL6GV9PmLZ1679jYWOvMNV9fX8hkMjx8+NCmz4MHD2x2Wqxbty4uX76MK1euQKfToWbNmhg5cmSOM+AKO5cmu/755x/ExcXl2Kd27dpZlu/fv38fr7/+Onr37o0KFSpke367du0wc+ZMBAUFwWKxYOrUqejVqxfOnDmTbZJs9uzZeP/99/P2yxARUYEl8w2E39tLYDy7D2kHfodkNkJZuT48m/SEoPGBoFC6OkQiomci88y83Ah3YCQiypuMJFexYi+4ZM2u5ORkREVFYeDAgQDS1+eqXLkyTpw4gWHDhln7nThxAjVq1LA5V6lUokqVKgAAk8mE7du3Y8iQIc4KvcBxabJr7dq12Lx5c459Vq9enWkbbZ1Oh/bt2yM4OBjff/99jud3797d+rNcLsfs2bOxePFi/P7773jzzTezPGfq1KmYMGGC9b1er0doaOjTfh0iIirAZF5aqOt2gKpqY0CSIHhoIChUrg6LiIiIiFzM1UkuALh9+zaGDx8OuVyOSZMmWY8PGTIEH330ESZNmoSwsDAcPnwYO3bswKpVq6x9/vrrL1SpUgXFixeHKIqYMmUKjEYj3njjDaf+DgWJS5Nd77zzDt555508naPX69G2bVvI5XJs3boVPj4+eTpfLpcjMDAQsbGx2fZRq9VQq9V5ui4RERV8gkwGwUvr6jCIiIiIqABxRZLr5MmTaN26NURRRHx8PK5evYqOHTviwIEDNgvLv/HGGzh58iQiIiJQsWJFXLhwAePHj0ePHj2sffz8/NCiRQv4+fnhzv+1d+dhUZX9/8DfMwMM27DKIquYO6jgbqihqGkuua/Zk7llppampT1+s8VsM1OfpyxTHk3L3HLH3RAS3HFf0EQEEVGEYV9m7t8f/JicYBCQYZjh/bourqu5z32f8zkHD+f0mft8TnIyrK2tceDAAT7GaCxKEl1A8es37e1L/w/LzZs3kZmZiaCgIAghkJeXp1XMLS4uDnfu3EFAAIsRExEREREREdU1NtY2sLGxgUJhb5CZXPPmzdM8YmhmZgZHR0c0bdq0zBJOZmZmWL9+PeLj45GQkIDGjRujfv36Wn3at2+PS5cuITY2FlZWVvD396/xmWm1jUSUvGaglissLERISAhu3ryJNWvWaCW6GjduDDc3NwDAxIkTERMTg0uXLqGgoACBgYGYOHEi/P39kZCQgM8++wwuLi6IjIys8OwtpVIJe3t7ZGRkwM7OTi/7R0REpoXXDqK/8XwgIqKq0Of1o6ioCDKZrM4nhUyV0czsysnJgUQiQePGjbF48WKtZe+//z769+8PoDjxVfIKTgsLCxw+fBgrVqzAt99+C0dHR8ydOxcTJ06EuTmLERMRERERERHVRWZmRpMOoSowmpldhsRvI4mIjI9QqyByMgGhBiRSQCqF1Lrm/obz2kH0N54PRERUFbx+UFUxlUlERCZHnZOJgjMHkbPvf1CnJQMSCcxbdIbN8FmQOblDYs6XkBARERERmSomu4iIyKSoczKRs/sH5B397e9GIVB4+TjSb5yBw7x1MKvf0HABEhGRSVLnZgNFBeV3MrOA1MqmZgIiIqrDmOwiIiKTIvKytBNdTyrMR/avX0Ax5UtIbUq/0ZeIiKjKigqQNrd3uV2cvjwAgMkuIiJ9kxo6ACIiouqUH72n3OWFcWcBlqskIiIiIjJZnNlVQ/IK1cgrVKNIBZjJAJlEAoWVzNBhERGZFCEE1FmPn96vqLAGoiEiIiIiIkNgsqsGZOSo8FPEQ2w6kY6sfDVkUiCkmS3mDXCHi8IMZjKJoUMkIjIJEokE5k3aIe+PTbr7WCsgMTOvwaiIiIiIiKgm8TFGPcvIUWH6+rtYcywNWflqAIBKDRy+koVhK24jLbvIwBESEZkW8yZtIFE46lxu+cJwQG5VgxEREREREVFN4swuPbt6Lw9nbueWuSw9R4XvDz/EnH5usLZg3pGIqDpILG1h/85KZCyZDJGdobXMvGVXWIWOhdRcbqDoiIiIiKg2EkIg7dFDODnXg0Si36ev9u7diytXrgAAzM3N4eTkhICAAAQGBpa5bSEEjhw5gnPnzmHAgAFo2rRpqT4FBQUIDw9HQkICmjRpgt69e+t9P2ozJrv0KCtfhY0x5deO2R2bgZkvusLaooaCIiIycRKZDDJXXzgu3IqCy3+i8EoMJJY2sOw2FFIHV0ht7AwdIhERERHVIo8fp+HggXDE376FBn7PoVfvvnB0dNLb9n755RdERkZi+PDhUKvVOHnyJObNmwdra2v8+OOPCAkJ0fQ9dOgQ3nrrLbi7uyMiIgJeXl6lkl0ZGRno3r07cnJyEBwcjC+//BIBAQHYuXMnzM3rZvkOJrv0SKUSmkcXdckp4BvBiIiqm0Qmg8TWHpYdX4JFm1BIpDJIZLzkERGRYamFQHqW7jImFmYS2FryJVZENaWwsBAx0VE4EfMnxP9/W/ed+NtYveo7dOwUjE6du+gtWdS4cWN8/fXXms9FRUWYNWsW+vbti1OnTiEgIAAAoFAosHPnTjRs2FBnLIsWLcLjx49x/vx52NnZ4e7du2jRogVWr16NN954Qy/x13a889cja7kUbRtYIfpmts4+LTwsNScVERFVPz6ySEREtUV6jgovLIvTuTzyg8Y1GA1R3SWEwM246zh4IBzZ2Vla/08uhBpCANHHo3DxQix69e6LRo2b6v2RQDMzM3z77bfYvXs3lixZgrCwMABAx44dARQnw3TZvHkzRo0aBTu74icYvL298dJLL2HTpk1MdlH1M5dJMbyDI1b98Qj5RWUntF7t4og6/BgtEREREZFpMLOA05cHylykFgLpOSqkF3DWFlFtkJKSjN+3bYJEIiln8olAVlYmft+2Ca++Ngnu7vX1HpdUKkVoaCiOHTtW4TG5ubmIj48v9Whjs2bNKrUeU8Oq6HqmsJTih/HesLbQzmhJJMD4rk5QWMnw6Y77yMpTGShCIiIiIiJ6VlIrG0gVjmX+KKV2eGHZQ7z8fYqhwyQiAG5u9WFtbV2hp6ysrW3g5uZeA1EVc3Z2xuPH5df+flJWVhYAwMHBQavdwcEBmZmZ1RmaUeHMLj2Tm0uRXyTw2zQ/RN3Iwq0HBXC0kaFvKzvEJuTinQ1JUKsF/v1yzZ08RERERERERHWVRCJBs+YBOHfuNIRad51tiVSK5s39a/Sthunp6ZrHESvC2toaAKBUKrXaMzIyYGNjU62xGRMmu/RMCIE/rmZhy6l0hDSzhYejOR5lFWHi6gSkZf89m6tAx2OORERERLXBgwcPkJqaCj8/P82NNRERkbFq1qwFzp45WW4foVajafMWNRRRsYiICHTo0KHC/W1sbODp6Ylbt25ptd+6dQuNG9fdOoB8jFHPJBIJmrjLUagSOHg5E2uj0rDtdIZWosvCTAILMxbuIiIiotrn8OHD6NChA1q2bIkRI0bAxcUF8+fPN3RYREREz8TTy/upX95YW9vA09O7hiICFi9ejLi4OMycObNS415++WVs2rQJ+fn5AIBHjx5h9+7dGDx4sD7CNAqc2VUDegUosHh3is7ZWy+1UsBcxmQXERER1T7Xrl3Dd999h3bt2gEAYmJiEBISgiZNmuC1114zbHBERERV9LRHGfX9CGNCQgK+/vprqNVqpKam4tChQ0hISMAvv/yieQMjAMTHx2PLli1Q//8Yd+/ejcTERAQGBqJnz54AgA8//BDh4eEICQlBjx49sH37djRq1AhvvvmmXmI3BpzZVQMszaVYMtoTsjKOtp+LBWb1dYONnG9mISIiotpn2rRpmkQXAHTq1Ant2rVDZGSkAaMiIiJ6ds2atdBZs0ufjzD269cPAwcOxP3795GWloZ69eph0aJFSEpKwogRI7T65ufn4/79+3jw4AFmz54Nd3d33L9/HxkZGZo+rq6uiI2Nxb/+9S8IITB37lxERUXByspKL/EbA4moyOsH6jilUgl7e3tkZGRUqlDck3Ly1XiUXYTVEQ9xNj4XNnIphrZ3QE9/BRysOcGOiMjUVMe1g6g2ysnJga+vL2bOnIl///vfZfbJz8/XPEoBFJ8P3t7ePB+ozsrKU1WoRq+FmQS2lvwSnKiEvu+nhBBISbmvc7mbm3uNFqen6sMsSw2xlkthLbfA3H7uyCtQQyIB7K1kkEp54hAREVHNSU9Px7Vr18rt4+PjAw8PjzKXTZ8+HVKpFJMnT9Y5fvHixfjoo4+eKU4iU8IEFlHtJJFI4O5e39BhkB4w2VXDrC2ksLbg06NERERkGJcvX8bs2bPL7TNt2jSMGzeuVPuCBQuwadMmHDhwAK6urjrHz5s3D7NmzdJ8LpnZRURERFQTmOwiIiIiqkOCg4MRExNT6XELFy7Et99+i/DwcHTu3LncvnK5HHK5vKohEhERET0TTjEiIiIionJ9/PHHWLJkCfbu3YsuXboYOhwiIiKicnFmFxERERHptGTJEixcuBBffPEFzM3NNbPCHBwc0KxZMwNHR0RERFQak11EREREpNOtW7fQoUMHbN26FVu3btW0d+7cGUuXLjVgZERERERlY7KLiIiIiHT67rvvDB0CERERUaWwZhcREREREREREZkMJruIiIiIiEyUSi2QlacydBhEREQ1io8xEhERERGZKGWuCuYyiaHDICIyCgUFBbCwsND7dhITE5Geng4AMDc3h5OTE1xcXModk52djdu3b8Pb2xv29vZV7lNXcGYXEREREZGJKigSiLiWZegwiIhqtZycHOzftwfLv/0SB/bvQU5Ojl639/7776NTp04YNWoUBg8ejObNm8PNzQ3Tp0/Ho0ePtPrevn0bM2bMQKNGjdCyZUuEh4eXWl9F+tQ1nNlFRERERGQi8gvVyC1QQwAwk0mwOzYDf1zLQkhzWxQUCQCApbkUVhb8zpuISKVS4dzZ04iKPIrCwkIIIXA+9iyuXL6Irt26IzCoHWQymV623alTJxw6dEjz+dy5c5gyZQo6duyIkydPwsnJCQAQHR2NRo0a4eLFizpnf1WkT13DZBcRERERkYmQm0uRXySw/Ww6lu1PRV5hcYLr+Y9voFeAAh8MdIfcjI81EhE9SLmP7du3IP1xmla7EAIFBQU4fGg/zp45hZcHDYOrm7ve4wkKCkJ4eDgaNmyIJUuWYNGiRQCAMWPGAACKiop0jq1In7qGX+kQEREREZkQOysZhrVzwBcjPDRt/QLt8eHg+nC0MYNUymQXEdG9e0mlEl3/9PhxGu7dS6qhiABnZ2f07dsX+/btq7Ftmiomu4iIiIiITIyVhRSPc1R4ztUCzze2QVp2EYQwdFRERPQ0Pj4+SExMNHQYRo+PMRIRERERmZiMHBXkZhKsm+ILmUSC6JvZkHBCFxFRrVdQUAC5XG7oMIwek11ERERERCbG1lKG7s0VUFgVF1Z+oZktzGTMdhER1XaxsbFo1qyZocMwenyMkYiIiIjIxJjJJJpEF1BcuF7GWl1ERLVaVFQUjh07hldeecXQoRg9zuwiIiIiIqJyZeSqoFYLFKoELMwkkJtJYGUhe/pAIqJaysPDE46OTnhcTpF6R0cneHh46mX72dnZuHTpEtRqNVJTU3Ho0CEsX74cEyZMwLhx4zT9srKyEB8fD5VKBQBITEzEpUuX4OTkBA8Pjwr3qWskQhhPqcrw8HCcOXNGq83V1RWTJ08ud1xmZia2b9+OlJQUtGzZEi+++GKltqtUKmFvb4+MjAzY2dlVOm4iIqp7eO0g+hvPB+NVpFIjOb0In+y4j+M3syEEYG0hxdB29ngj1AUO1kx4EZH+6Pv6oVKpEHvuNCKPHUVhYSGEEJBIJDA3N0fXbj0QGNQWMln1/52bN28edu3aBQAwMzODo6MjWrZsieHDh6Nr165aff/8809MmTKl1DpGjhyJBQsWVLhPXWNUya433ngDERERGDp0qKbNzc0N06dP1zkmMTERXbp0gaurK9q2bYsdO3YgODgYmzZtgqSCVTp5g0ZERJXFawfR33g+GK/k9EIMXvYXMvPUpZa1aWCF/4zzhj0TXkSkJzV1/cjJyUFU5FFcOH8OrVq3QZeuIbC2ttbb9kj/jO4xRn9/f3z66acV7v/ee+/BxcUFf/75J8zNzfH222/D398fW7duxbBhw/QYKRERERGR8crOV2HZgQdlJroA4Gx8Lq7fz0OHhjY1HBkRUfWytrZG7xf7IaR7L1hYWBg6HKoGRleg/u7du/jmm2+wevVqXL16tdy+KpUK27dvx6uvvgpzc3MAQNOmTdG1a1ds2bKlJsIlIiIiIjJKhSpg34XMcvtsjHmM7Pyyk2FERMaGiS7TYXTJrvz8fMTHx2Pv3r0IDAzEwoULdfZNSEhATk4OmjRpotXepEkTXLt2rdxtKJVKrR8iIiIiorqluCB9eXIK1FCrjaYqChER1REGfYxx165dOH/+fLl9pk2bBkdHRwDA9OnTsXLlSs2y7du3Y/DgwejVqxeCg4NLjc3KygIA2Nvba7U7ODholpVl8eLF+Oijjyq8H0REREREpkYIoFl9Oa4l5+vs0+k5G1hZGN3350REZOIMemUqLCxEXl5euT9P1s/39/fXGj9o0CDUr18fR48eLXP9NjbF9QP+OTMrIyNDs6ws8+bNQ0ZGhubn7t27Vd1FIiIiIiKj5GAtw5uhLjqXW1tIMDDIHmayir30icjQ1Hk5pdvycw0QCRHpm0Fndg0ZMgRDhgx5pnVIpVKds7R8fHxgZWWFmzdvonfv3pr2uLg4NG3aVOc65XI55HL5M8VFRERERGTMJBIJOjS0xrSe9fDd4Yd48h3uCkspVk3wga0lZ3WRcVDnZiH/zEHIW3WD1M65uC1bibw/t8MyeBCkNnxTLJEpMZqrk0qlwoULF7Ta9u7di6SkJISEhGja9uzZgx9//BEAYGZmhgEDBuDnn39GUVERAODWrVs4duzYMyfZiIiIiIhMncJKhnHBTjjyfiO808cFYzo74qtRHtg35zk0dZfDwsxo/neC6jB1bhbyIrcie8NnyPhmCtTKR1DnZCLr18XI+X0FMtf8G+ps1mkmMiUGndlVGUIITJo0CW5ubvD390dCQgK2bt2KmTNnok+fPpp+v//+O2JiYjB58mQAwBdffIHg4GB0794d7du3x5YtW9CnTx+MGDHCULtCRERERGQ0FJYyKCxlmPhCPUOHQlQ1QqAo6SYAQJVyB+lfT4LMuT4Kr50EAKjT7gNqlSEjJKJqZjTJLjMzM8TExODgwYM4d+4c/Pz8MH/+/FJ1vPr374/WrVtrPjdo0ACXLl3C5s2bkZKSguXLl2PgwIGQSvktFBERERERkamTWitgO3IOsgAUnNwHdepdqFOL6zLL3P1g/85KSBWOhg2SiKqVRDxZAZ7KpFQqYW9vj4yMDNjZ8VluIiJ6Ol47iP7G84GIagNRWIBHc3oCTxSld5i/Hmbeuus5k2Hx+kFVxelNREREREREZNLU2Upkrv1QK9EFAJmrP4Ba+chAUVFtkpx8Dxt/WYfk5Ht639aMGTPg5eUFLy8v+Pn5oW3btvjXv/6FPXv2lOqrVquxd+9eDBgwAF5eXti5c2epPgkJCZg1axbatm2LwMBATJ48GQkJCXrfj9qMyS4iIiIiIiIyWSXF6AvOHAIAyNx8Ye7/PIDiGl4Z30yBOvOxIUOkWuDypQtISIjHlUsXnt75GaWlpcHPzw8xMTGIiIjAypUr0axZM4wZMwajR4+GWq3W9F2yZAn+85//YPz48UhKSkJOTk6p9Q0bNgy+vr5YtWoV1qxZg6SkJHTp0gVpaWl635faymhqdhERERERERFVmgQwaxCAgjOHNDW6YGaOrN++RMHJfZC6eAFSmaGjpBqWqVQiOydb8/na1UsAgKtXL8O/5d91wG1sbKBQVP8jlHK5HF5eXgAAHx8ftG/fHr169ULHjh3Ro0cPTJo0CQAwa9YszJkzB0VFRTrXFR0dDZns73/Dv/zyC5ycnHDgwAGMGjWq2mM3Bkx2ERERERHVIUKtgsjJBISAxMoGEjOLp48RAhKJpAaiI6p+UisFLIMHQmptB4uAYEjtnAAAtiPnIM+nOSw79YfUhvWg6potm39FampKqfacnGys+98qzWcXFzeMnzClRmJq164devTogV9//VWT7HoyiaXLP/sUFRVBCAFzc3O9xGkMmOwiIiIiIqoDhFoNkaNE/qn9yD+1H1CrYB4QDKtuQyGxVuhMeqlzs6F+mAipswek1ooajpqoekitFJC37QmJ3OrvNms7WHUdAomFpQEjI0Np2qx5mcmusvrVpJYtW2LTpk3PtI758+ejXr166NmzZzVFZXyY7CIiIiIiqgPU6anI+Op1qNMfaNqK7lxB3uFfYD97FWT1G0Lyj9kB6txsFJw9iKz1i2A9cCosXxjOhBcZrScTXZo2JrrqrOeDuwEAoiL/0NmnS9cQTb+aYmZmBpVKVeXxy5Ytw//+9z/s3bsX9vb21RiZcWGBeiIiIiIiE6fOykBm2AKtRFcJkZcN5XfvQORmao95ItEFADk7v0dexGaoczJLrYOIyBg9H9wN7dp3KnNZ+w6dajzRBQB//fUXvL29qzT2+++/x9y5c7FlyxaEhoZWc2TGhckuIiIiIiITJwrzUHTznM7l6scpUKX8/Zr6fya6SjDhRUSmRjzx5sMnqdWihiMB7t+/j3379qF///6VHrty5Uq8/fbb2LRpEwYMGKCH6IwLk11ERERERCaurBld/1SU/FdxXx2JrhJMeBGRqRBC4Or/fwujXG6J54O7QS4vfrT16pVLEKJmEl4qlQoRERF48cUX4evri7fffrtS41etWoW3334bmzdvxssvv6yfII0Mk11ERERERCZOqnB6ah+Zc/2nJrpKMOFFRKagsLAQCoU9GjdphomTp6FL1xBMnDwNjZs0g52dHQoLC/W27aioKHh5ecHDwwMKhQKTJk1C//79ER0dDTu7v98O+scff8DLywsNGjQAAEybNg1eXl6YN2+eps+0adMAAG+++Sa8vLw0P8uXL9db/LWdRNRUqtKIKZVK2NvbIyMjQ+sfHRERkS68dhD9jeeD4amz0pHx7ZtQJcWVuVxiYw+HhVtRdOM0Mle9X+H12oyaC3nHlyC1tKmuUImINGri+qFWqyGVlp4HpKu9Ojx+/BjZ2dkAigvSOzg4wNKy7Jcl5OfnIzU1tVS7ra0tHBwcAABJSUllzkKzt7eHQlE3XyrCtzESEREREZk4iY09FK9/iowvx0Pk52gvlMqgeP1TSOXWMG/cBjLPRlAl3XzqOqX1PGHROoSJLiIyaroSWvpKdAGAo6MjHB0dK9RXLpfDy8ur3D6enp7VEZZJ4WOMREREREQmTiKRQObqBYcPN0PebSgkCkdIrO1g0aYnHBZshNlzrSExN4dU4Qj7md9B5tmo3PVJ63nCfvYqyBxcamgPiIiIKo4zu4iIiIiI6gCJmQVkjq6wHTITov+U4kYzc0itbLX6lSS8Mpa9WeYMLya6iIiotuPMLiIiIiKiOkQit4JU4Vj8849EVwldM7yY6CIqTZmrwuPsIq22x9lFSM9RGSgiImKyi4iIiIiISvlnwouJLqLSlLkqLNp5H2NX3sHDzOKE1+PsIkwJu4t3f01kwovIQJjsIiIiIiKiMpUkvCxadWOii+gf8gvV2H9Rid2xStx5WIBXf7yDWw/yMSXsLi4n5SH6Zg5+/vMRcvKZ8CKqaazZRUREREREOkkVjrAd/zHfukj0D3JzKV5saYcz8TnYda444TVw6V+a5cGNbfBqsDOs5TIDRklUN3FmFxERERERlYuJLqKy2VnJMH+AO3q00K5/18rbEl+P9oS9NRNdRIbAZBcRERERERFRFanUAvceF2q1pWWpUFAkDBQRETHZRURERERERFQFJcXoryXnAwAszCQAgMTHhRj3Q7ymaD0R1Swmu4iIiIiIiIgqKa9QjeM3s3E5KQ9AcY2u6P9rgoFBdgCAhEeF2HkuA9ksUE9U41ignoiIiIiIiKiSLM2l6NbUFu/1d0XU9Wx8NcoTluZSzBvgDgBwsjXDsPYOsGGBeqIax2QXERERERERURUoLGUY3NYBg9s4QGFVnNSys5JpEl52Vkx0ERkCk11EREREREREVaSwLJ3QYpKLyLBYs4uIiIiIiIiIiEwGZ3YREREREZFGZq4KAoDCUgqJRGLocIiIiCqNM7uIiIiIiAhAcaLrt5OPMWT5X3igLIIQwtAhERERVRqTXUREREREpEl0Ld2XiuT0IoxdGc+EFxERGSUmu4iIiIiI6rgnE10lmPAiIiJjxWQXEREREVEdVlaiqwQTXkREZIyY7CIiIiIiqqPKS3SVYMKLiIiMDZNdRERERER1kLICia4STya8iIiIajsmu4iIiIiI6iCpBHBVmFW4v41cBjOZRI8RERERVQ8mu4iIiIiI6iBbSxl6tFBg8fD6T+3byE2ONRN94Gxb8eQYERGRoTDZRURERERUR1Uk4cVEFxERGRsmu4iIiIiI6rDyEl5MdBERkTFisouIiIiIqI4rK+HFRBcRERkro7pyDRgwALm5uaXa+/Xrh3feeafMMcuWLcOuXbu02vz8/LBq1Sq9xEhEREREZIz+TngBa46lYTUTXUREZKSM6uo1e/ZsFBX9/brjGzduYNq0aZgwYYLOMVevXkVBQQH+7//+T9Nma2ur1ziJiIiIiIxRScIr1N8ONnI+BEJERMbJqJJdISEhWp8PHDgAJycnDBkypNxxrq6u6Nmzpx4jIyIiIiIyDbaWMkOHQERE9EyMKtn1pMLCQqxbtw6vvvoq5HJ5uX3Pnj2LgQMHwt7eHl27dsWECRMgk/EiTkRERERERERkaow22bV7926kpKRg0qRJ5faTy+UYMGAAXnjhBSQlJeGTTz7Bpk2bcODAAUilZU/Nzs/PR35+vuazUqms1tiJiIiIiIiIiEg/DJrs+uqrr7B///5y+6xbtw4eHh6l2levXo3nn38eLVq0KHf8Z599BhsbG83nnj17IiAgANu2bcOwYcPKHLN48WJ89NFHFdgDIiIiIiIiIiKqTQya7OrXrx+CgoLK7ePo6Fiq7d69e9i3bx9++umnp27jyUQXADRv3hwNGjTA2bNndSa75s2bh1mzZmk+K5VKeHt7P3VbRERERERERERkWAZNdrVo0eKpM7PK8r///Q+2trYYMWJEpceq1WqkpaXB0tJSZx+5XP7UOmBERERERERERFT7GN37hIUQWLNmDcaOHQtra+tSy7/55htNHa/CwkL897//hUql0oxduHAhMjMzMXjw4BqNm4iIiIiIiIiI9M/oCtRHRETg1q1bmDhxYpnLr1y5gpiYGACATCbDzZs34enpCT8/PyQmJkIIgd9++w0tW7asybCJiIiIiIiIiKgGSIQQwtBBVMbt27dx584dhISElLn86tWryMjIQKdOnTRtmZmZuHLlChwdHeHn5wdzc/NKbVOpVMLe3h4ZGRmws7N7lvCJiKiO4LWD6G88H4iIqCp4/aCqMrqZXX5+fvDz89O5vHnz5qXaFAoFOnbsqM+wiIiIiIiIiIioFjC6ml1ERERERERERES6MNlFREREREREREQmg8kuIiIiIqqQU6dOQaFQoFGjRoYOhYiIiEgnJruIiIiI6KmUSiXGjh2Lzp07Iy8vz9DhEBEREelkdAXqiYiIiKjmTZkyBUOHDoWNjQ2uXLli6HCIiIiIdOLMLiIiIiIq1+rVq3Hjxg18/PHHhg6FiIiI6Kk4s4uIiIiIdLp69SrmzZuHyMhImJubV2hMfn4+8vPzNZ+VSqW+wiMiIiIqhTO7iIiIiOqQ8PBwWFpalvvz9ddfAwAKCwsxatQofPLJJ2jatGmFt7F48WLY29trfry9vfW1O0RERESlSIQQwtBB1HZKpRL29vbIyMiAnZ2docMhIiIjwGsH1VZqtRoFBQXl9jE3N4dMJsP9+/dRv359yOVyzTKVSoWioiLI5XL8/PPPGD58eKnxZc3s8vb25vlARESVwvspqio+xkhERERUh0ilUlhaWlaor7u7O3Jzc7XaPv/8c/z000+4efMmLCwsyhwnl8u1EmRERERENYnJLiIiIiLS6Z+JMTMzszLbiYiIiGoL1uwiIiIiIiIiIiKTwWQXEREREVXYvHnzcOvWLUOHQURERKQTH2MkIiIiogqTyWSQyWSGDoOIiIhIJ87sIiIiIiIiIiIik8FkFxERERERERERmQwmu4iIiIiIiIiIyGQw2UVERERERERERCaDyS4iIiIiIiIiIjIZTHYREREREREREZHJYLKLiIiIiIiIiIhMBpNdRERERERERERkMpjsIiIiIiIiIiIik8FkFxERERERERERmQwmu4iIiIiIiIiIyGQw2UVERERERERERCaDyS4iIiIiIiIiIjIZTHYREREREREREZHJYLKLiIiIiIiIiIhMBpNdRERERERERERkMpjsIiIiIiIiIiIik2Fm6ACMgRACAKBUKg0cCRERGYuSa0bJNYSoLuO9FBERVQXvp6iqmOyqgMzMTACAt7e3gSMhIiJjk5mZCXt7e0OHQWRQvJciIqJnwfspqiyJYIr0qdRqNe7duweFQgGJRGLocCpNqVTC29sbd+/ehZ2dnaHDqTLuR+1iCvthCvsAcD9qm5L9SEhIgEQigYeHB6RSVg2gus3Y76UMyVT+NtZGPLb6w2OrX3Xp+AohkJmZyfspqjTO7KoAqVQKLy8vQ4fxzOzs7EzijyH3o3Yxhf0whX0AuB+1jb29vUnsB1F1MJV7KUMylb+NtRGPrf7w2OpXXTm+nNFFVcHUKBERERERERERmQwmu4iIiIiIiIiIyGQw2VUHyOVyfPjhh5DL5YYO5ZlwP2oXU9gPU9gHgPtR25jKfhBR7cC/KfrDY6s/PLb6xeNL9HQsUE9ERERERERERCaDM7uIiIiIiIiIiMhkMNlFREREREREREQmg8kuIiIiIiIiIiIyGWaGDoD0IyUlBXFxcWUua9OmDaytrUu1CyHw559/lmpv3Lgx3Nzcqj3GikhPT8elS5dKtbdr1w6Wlpbljs3IyEBcXBzc3Nzg7e2trxArTK1W4+bNmxBCwM/PDxYWFuX2v3PnDu7evavVJpfL0b59e32GqeX69evIzs6Gv79/hQtgVmWMPqWnp+P27dvw9vZGvXr1yu2rVqtx/PjxUu1NmjSBq6urvkIs1+PHj3H58uVS7e3bt3/q8S05B9zd3eHl5aWvECvk5MmTKCgoKNXu4uKCpk2bljkmPj4eiYmJWm2WlpZo166dXmLUJS8vD2fPnoWHhwcaNGhQZp+qHOva9PshIuOSlpaGO3fuwNfXF05OToYOxygJIXDt2jXk5+fD398f5ubmhg7JZKhUKsTFxUEqlaJhw4YwM+P/clY3IQSio6NhZWWFoKAgQ4dDVDsJMkm7du0SwcHBWj+enp5CKpWK5OTkMsfk5uYKAKJly5Za43bt2lXD0f8tPDxcACi1L4mJieWOW758ubCyshLNmzcXVlZWYsiQISIvL6+Goi7tm2++EZ6enqJJkybiueeeE66urmLjxo3ljnnvvfeEvb291n4PHjy4RuK9d++eaNu2rXB0dBQNGzYUzs7OYu/evdU+Rp+uXLki+vXrJxwdHUVgYKCwsbERgwYNEhkZGTrHZGZmCgCiVatWWsfdkPuxa9cuIZFISp0Dus7jEkuXLhWWlpaac2DYsGEGPQcGDhyoFX+nTp0EADF9+nSdY2bPni0cHBy0xg0bNqzGYk5NTRWzZs0S9evXF1ZWVmL27Nll9qvKsa5tvx8iMg6xsbGid+/ewsnJSQQGBgpra2sxatQokZ2dbejQjMqtW7dEQECAqFevnvD19RXu7u4iIiLC0GGZhEWLFgl3d3fRrFkz4efnJzw8PMT27dsNHZbJWbJkiZBKpcLf39/QoRDVWkx21SEdOnQQffv21bm8JNkVGRlZg1GVLzw8XMhkskqNiYmJERKJROzcuVMIIURSUpLw8PAQ8+bN00eIFbJgwQJx//59zeelS5cKc3NzERcXp3PMe++9J0JDQ2sivFL69Okjnn/+eZGbmyuEEOLDDz8UdnZ2IjU1tVrH6NOOHTvE7t27NZ/v378vGjZsKCZNmqRzTEmyKzo6uiZCrJBdu3YJuVxeqTFRUVFCIpGIPXv2CCGEuHv3rnB3dxcLFizQR4hVsnPnTgFAnDlzRmef2bNnixdffLEGo9J2+vRp8fXXX4uHDx+K1q1bl5nsqsqxNobfDxHVTps3bxYHDhzQfL57967w9PQU77zzjgGjMj6dO3cWvXv3FoWFhUIIIWbOnClcXV1FZmamgSMzfvPnz9e69/vkk0+EpaXlU7+opoo7ffq08PHxEa+++iqTXUTlYM2uOuLSpUs4efIkJk2a9NS+SUlJOHPmDB4/flwDkVXMtWvXcOHCBeTm5j6175o1a9C6dWsMGDAAAODh4YHXX38da9as0XeYOn388cdaj4K+8cYbKCwsxMmTJ8sdV1BQgHPnziEuLg4qlUrfYQIA7t27h/3792Pu3LmaR0XnzJmDwsJCbNmypdrG6NvAgQPRr18/zWc3NzcMGTIEUVFRTx2bmJiIM2fOID09XY8RVs7Vq1dx8eJF5OXlPbXvmjVr0LZtW7z00ksAAC8vL7z22msGPQf+afXq1WjTpg3atGlTbr+Sc+DmzZs1dg6UaNu2LWbPng1nZ2edfapyrI3h90NEtdOwYcPQq1cvzWcvLy8MGDCgQtc2Knb16lVER0dj/vz5msfrPvjgAzx69Ai7d+82cHTGb9GiRVplI6ZOnYq8vDycOXPGgFGZjszMTIwePRo//PADXFxcDB0OUa3GZFcdsXr1ari5uWkSQOV56623MH78eLi7u2P48OFIS0urgQh1U6lU6NevH4YOHQpHR0csWLAAQgid/c+dO4e2bdtqtXXo0AEpKSlITk7Wd7gVcvr0aQBAo0aNyu13/PhxjBs3Dt26dYOnp2eNJI5iY2MhhNA6hjY2NmjevDnOnTtXbWMM4fTp00895kDxjdlrr70GNzc3jBw50uBJr/z8fPTv3x9DhgyBo6MjFi5cWG5/XedAUlISUlNT9RhpxaSkpGDPnj0VSr4fO3YMr776Krp27QovLy9s27atBiKsuKoc69r++yEi4yGEwJkzZyp0baNiJfclT/4ddnFxga+vb626ZzEVp06dAgA899xzBo7ENLzxxhvo06cP+vTpY+hQiGo9Vgs0EiqVCtHR0eX2cXJyQosWLUq1FxQUYP369Zg4cWK5BSKlUinCwsLwr3/9CxKJBLdv30avXr0wdepU/Pbbb8+8D0BxQdUrV66U28fPzw+enp4AgPr16yM6OhqdOnUCABw+fBgvvfQSPDw8MHXqVJ3b+OdMjJLPaWlpqF+//rPuBm7fvo2kpKRy+wQGBsLW1rZUu1KpxOTJk/Hiiy+iQ4cOOsd37doV06dPh6enJ4QQ+OyzzzBmzBg0adIErVq1euZ90KUkuVnWMdSV+KzKmJq2cuVKREVF4dixYzr7mJmZYd26dRg3bhwA4K+//kLPnj0xbdo0bNiwoaZC1eLp6YmTJ09qXkxw4MAB9O/fH56enjqTRU87Bwz9TeDatWthYWGBMWPGlNvvhRdewOzZs1G/fn2o1Wp88sknGD16NM6ePQt/f/8airZ8VTnWtf33Q0Q1Jz8/X5MM0MXV1RVNmjQpc9mSJUtw/vx5/Pjjj/oIzySlpaXBwsKi1D1abbpnMRWPHj3CtGnTMGTIkFpz3TZmYWFhOH/+vOZLcyIqH5NdRiI3Nxfvv/9+uX2Cg4PxxRdflGrfsWMHHj16hAkTJpQ73sLCAq+99prms5+fH95//31MnToVBQUFT317YEVcvnwZ8+bNK7fPW2+9hVGjRgEAWrdurbUsNDQUw4cPx8aNG3Umu8zNzUs96lXy+GN17AMA7Nq1C5s2bSq3z+rVq0u9ZS4nJwcDBgyAubk5fvnll3LHP/kInkQiwfz587Fy5Ups3bpVr8mukrcR5eXlwcrKStOem5ur83/CqzKmJm3duhUzZszADz/8gM6dO+vsZ2lpqUl0AUDDhg0xd+5czJw5E2vXrjXI24T++Yad3r17Y8iQIdi4caPOZFdNnAPPYs2aNRg5ciTs7OzK7ffkTFSpVIr/+7//ww8//IBt27bVmpvmqhzr2v77IaKa8/jx46fe37344otYsGBBqfaff/4Z8+fPx7p16xAYGKinCE2Pubk5CgsLoVKpIJPJNO25ubn8G1yNlEolXnrpJTg7OyMsLMzQ4Ri91NRUTJ8+HV9++aUm2ZWUlIScnBxERUUhICAADg4Ohg2SqJZhsstI2NraVrkew+rVq9G9e/cqTXF3c3NDUVERHjx4AC8vrypt/0ldu3Z95roSbm5uiImJ0bnc19e31KyrpKQkSKXSatkHAJgxYwZmzJhRqTG5ubno378/0tLScOTIkUq/KlwikcDV1fWpM8qela+vL4DiY+bo6KhpT0pKQpcuXaptTE35/fffMWbMGPznP//B66+/Xunxbm5uKCgowMOHD+Hu7q6HCCvPzc0NsbGxOpfrOgdkMhk8PDz0HF35oqKicP369Srd+EokEri4uOj9HKiMqhzr2vz7IaKa5e7uXqX7og0bNmDChAkICwvTfEFIFePr6wshBJKTkzX3hSWffXx8DBydacjMzESfPn2gUqlw6NChp365RU+Xm5uLwMBA/PLLL5ovzOPj4zUJ8yVLlqBjx44GjpKodmHNLhOXkJCAgwcPljkDRK1WIyoqCikpKQCA7OzsUn0OHDgAJyenann0ryr+GZNKpcKRI0cQEBCgaXv8+DGioqI0MyV69eqFQ4cOIScnR9Nnx44dCA4O1pp1VJNKEl2pqak4cuRImbOd4uPjtR5l+Oe+JyYm4urVq1r7rg9t27aFk5MTdu7cqWm7ePGi5rHWEufPn8eNGzcqNaam7dixA6NGjcLy5csxefLkUstVKhWioqLw4MEDALrPARcXF7i6uuo93rKUdQ4cPXpU699BWloaoqKikJ+fD6D4HDh48KDW7KEdO3agW7dukMvlNRO4Dj/99BP8/f3LnGF3+/Ztran5/9z3hIQEXL9+Xe/nQGVU5Fgb0++HiGq/X3/9VfPinbFjxxo6HKNTcj/45D1LVFQUHj16ZNB7FlNRkugqKCjAwYMHOduomvj4+CAqKkrrZ9SoUfDz80NUVBQTXURlMeCbIKkGLFy4UDg7O4u8vLxSyzIzMwUAsWrVKiGEEP/973/F8OHDxfr168XevXvF9OnThZmZmWa5Ibzyyiti1qxZ4vfffxdbt24Vffr0EXZ2duLcuXOaPrt27RIARFxcnBBCCKVSKRo2bCh69+4tduzYId577z1hZmYmIiIiDLQXQvTu3Vs4ODiIbdu2icjISM3Pk69hnj17tvD09NR8btmypfj8889FeHi4CAsLE02bNhX+/v5CqVTqPd7//ve/wtLSUixbtkxs2rRJNG/eXPTu3VurT9u2bcXYsWMrNaYmHTx4UFhYWIjXXntN65hHR0dr+jx+/FgAEGFhYUIIIZYtWyZGjhwpNmzYIPbs2SOmTZsmzMzMNMsNYfTo0WL27Nli+/btYsuWLaJ3797C3t5eXLhwQdPn999/FwDE7du3hRBCpKeniwYNGog+ffqIHTt2iHfffVeYm5uLqKgoA+1FMaVSKaytrcW3335b5vKZM2cKX19fzWd/f3/x5ZdfivDwcLFmzRrRuHFj0bJlS5GVlVUj8RYWFmr+3TRq1EiMGjVKREZGitjYWE2fihxrY/n9EFHtt2PHDiGTycTUqVO1rm0nT540dGhGZdGiRUKhUIiVK1eKX3/9Vfj5+YkRI0YYOiyjV1hYKLp27Srq1asndu3apfVvNDk52dDhmZzZs2cLf39/Q4dBVGvxMUYTFxcXh7lz55Y5W0AmkyE4OFjzaNabb74JX19fbNq0CSkpKWjYsCFOnjxZqmZQTVq9ejVWr16Nn3/+GUVFRQgKCkJYWJjW42ROTk5as7YUCgX+/PNPfP7551i2bBnc3Nzwxx9/IDg42CD7oFKpkJ2dDX9/fyxZskRr2ZP1yfz8/LQK1h85cgQrVqzA8uXLoVAo8MYbb2Dq1Kk1MvPjzTffhIuLCzZs2ICcnByMGTMGs2bN0uoTGBioeXyxomNq0s2bN9G+fXvExcVp1UNRKBQIDw8HUFyQPjg4GG5ubgCKH0/18/PD5s2bkZqaioYNG+L06dOlasfVpP/973/46aefsHbtWqhUKrRr1w7r1q3TxAwUF9UNDg6GpaUlAMDe3h7Hjx/XnAPu7u6IiIgot15ZTYiJiUHbtm216qI9qWHDhppC/ABw9OhRzTlgZ2eHt956C1OmTKmx2U/Z2dmafztubm64e/cu3n//fTRr1gw//fQTgIoda2P5/RBR7Xfr1i106tQJFy5cwIULFzTtrq6ute5ttbXZ/Pnz4e3tjc2bNyM/Px9Tp07FzJkzDR2W0cvLy4NarUbTpk3x+eefay2bM2cOXn75ZQNFZpr8/PzQpk0bQ4dBVGtJhBDC0EEQERERERERERFVB9bsIiIiIiIiIiIik8FkFxERERERERERmQwmu4iIiIiIiIiIyGQw2UVERERERERERCaDyS4iIiIiIiIiIjIZTHYREREREREREZHJYLKLiIiIiIiIiIhMBpNdRGR0Dh8+jEuXLhk6DCIiIiKjsG3bNiQmJho6DCKiGiMRQghDB0FkrCIjI5GUlAQAsLCwgK+vL4KCgiCVaueRCwsLcebMGSQnJ8Pd3R0tWrSAvb19qfVduHABV65cQUhICNzd3Ssdz7lz53D9+nWtNoVCgX79+mm15eXl4dSpU0hLS4O3tzfatGmjtVwIgejoaBQWFqJLly6QyWRay3fu3ImuXbvC0dGx0jFWhy5duqBnz55YuHChQbZPRERE+rNr1y5kZ2cDAKytrfHcc8/B39+/VL/s7GycPn0ajx8/ho+PD1q0aAFLS0utPsnJyYiNjYVCoUBQUBBsbGyeKbYbN27g7NmzaNu2LRo3bqxpz8/PR1RUFOzt7dGuXTutMQUFBdi+fTuGDBkCMzOzZ9p+VTk4OOCnn37CsGHDDLJ9IqKaZpi/tkQm4osvvsD58+cRHByM/Px8xMTEwNnZGXv37oWPjw8AYN26dZgzZw4cHBzQokULpKamIj4+HmPHjsUXX3wBAIiIiMD8+fORmpqKuLg4hIeHo0+fPpWOZ+3atdi8eTO6du2qaXN3d9dKdh0/fhxDhgyBi4sLGjZsiFOnTqF+/frYv38/6tWrBwB4/fXXER0drUng7dq1SzN+27Zt+OabbzBgwIAqHbPq0LNnTwQEBBhs+0RERKQ/06dPh62tLQICApCdnY1jx46hffv22LlzJ6ytrSGEwKJFi/DFF1+gSZMm8PX1RWJiIh48eIB58+ZhypQpyMjIwOTJk3H8+HG0bNkSycnJuHfvHtauXVuleywAyMjIQL9+/fDXX39h2bJlmmSXSqVCSEgI1Go1UlJSMHr0aCxevFgz7vPPP0dSUhJGjBhRLcenKoYOHQpvb2+DbZ+IqKYx2UX0jDp27IiNGzcCADIzM9G6dWu89957+PXXX7Fhwwa89tprWLt2LcaNG6cZk5eXh/Xr12s+Z2Zm4osvvkCzZs3g4uLyTPEEBQVp4inLnDlz0LFjR+zYsUOz7aZNm2Lp0qVYtGgR/vrrL2zduhVJSUmwsLBAw4YNER0djc6dOyMjIwOzZ8/G3r17IZFIdG7j9OnTyMrKQkhIiFb7qVOnkJ2djZCQEPz555+4e/cuJBIJXFxcEBgYCCcnJ63++/fvR4MGDeDo6IiTJ0/C0dERwcHB6Nq1K9zc3DT9KrMuFxcXnDt3DmZmZujUqRPkcrlWP7VajdOnT+P+/fsIDAzUJC1LqFQqnDx5Eg8ePEDjxo3RokULnceBiIiIqmbYsGGaGdx//fUXWrZsiaVLl+KDDz7AvHnz8N1332HPnj3o1q2bZkxaWhr27dsHAMjNzcXQoUPx66+/ambcv/vuuxg1ahQePHgACwuLSsc0efJkjB07Fl9//bVW+549e5CdnY3Y2Fjcu3cPjRs3xpw5c+Dk5IRr164hLCwMsbGx5a778OHDcHJyQlBQkFb7oUOH4OzsjKCgIOzduxdKpRJSqRQeHh5lzlTbtGkTunXrhtzcXJw/fx6NGjVCQEAA+vXrB09PT02/yqxLrVbj/PnzcHR0RMeOHUvdA+bn5+PEiRPIzMxEx44dNV+elsjLy0N0dDRycnIQEBAAX1/fco8FEVF1YLKLqBopFAqEhoYiKioKarUac+fOxejRo7USXQBgaWmJiRMnaj73798fAPDw4UOd6y6ZNj9q1KhyY8jIyMDOnTthZ2eH1q1bl3rUMD8/Hw0aNNCKuV69eigoKAAAxMXFoVGjRlAoFACAVq1aIS4uDp07d8acOXMwfvx4NG/evNwYrl+/jmnTpiElJUUrmTRu3DiMGTMGISEhOHXqFGJiYgAAiYmJuHjxItauXYtBgwZp+r/33ntwdHTE7du30apVK/To0QPBwcH48MMPtWZ3VXRdTk5OuHPnDpo3b47Lly/D2toaMTExmn3966+/MGjQIKSlpaF169a4du0a3nzzTcyePRsAEB8fjwEDBkClUqFRo0Y4c+YMOnbsiN9++w3m5ublHhMiIiKqmoYNG6JVq1aIjY1FcnIyvvnmG3z00UdaiS4AcHJywpgxYwAUz2z/50yqIUOGYMmSJYiPj0eTJk0AFN9DPHr06KmzvX788UckJCRgw4YNpZJdcXFxCAwMhFQqhZeXF+rVq4f4+Hg4Ojpi0qRJWLJkSZnlK5506NAhHDx4EKdPn9a0KZVKDBgwABs2bEBQUBAOHz6MpKQkqNVq3LhxAw8fPsTOnTu1ylGMGTMGvXr1wvXr1xEUFITRo0cjICAAr7/+utZjjBVd14svvogbN26gWbNmOHHiBNq3b4/du3drEl5//vknRowYAVtbWzz33HN46623sHTpUs092PHjxzFs2DB4eXnB1dUVx48fx8SJE/Hll1+WezyIiJ6ZIKIq69evnxg6dKhW2wsvvCC6d+8uYmNjBQCxZcuWCq8vNTVVABDh4eGlli1dulQ87ZSdOXOmcHJyEn369BFBQUHC1tZW/PDDD1p9/vjjD9GgQQOxYMECERYWJl599VXRrl07kZycLIQQ4tSpU8LDw0Oo1WohhBCtW7cWu3fvFhERESIgIEDk5+eLEydOiCNHjoiCgoIy48jKyhI2NjZa+37q1CkBQNy8ebPMMWvXrhWurq5a62zdurWoX7++ePDggVbf4OBg8eGHH+o8DrrW5efnJ9LS0oQQQmRnZwsPDw+xfPlyTZ82bdqIvn37itzcXCGEEEVFRWLXrl2a5R07dhTvvvuu1n76+/uLr776SmcsREREVDm+vr5a1/n8/HxRv359MX36dLF+/XoBQFy7dq3S6/3oo4+EjY2NyM/P17RNmDBB+Pv7lzvu0qVLwtXVVXMPY2NjI1asWKFZHhYWJnr16iWEECIvL09YW1uL+Ph48d1334lBgwaJwsJCcfToURETE1PuNv65X2FhYcLBwUHk5eWVOWbOnDmiS5cuWm0ymUx06tRJ5OTkaLXb29uLzZs369y+rnWFhoZqjtft27eFmZmZOHLkiBBCiIyMDOHs7CxmzJihuW/MzMwUhw4d0vy3q6urCAsL06wzISFBODo6lnmvS0RUnTizi+gZJSYmYuPGjSgoKMChQ4cQGRmJ3bt34/79+wBQ6jG4qmratClGjhxZbp/Bgwfjs88+g7W1NQDg+++/x5tvvok2bdpoiqX6+PigadOm2LJlCxo1aoTY2Fi8/PLLmm8cg4KCoFAoMH36dCgUCjx48ADPP/88goODsXr1asydOxe7d++Gvb097O3tcfjw4VLT2W1sbDBo0CBs2LABQ4cOBQBs2LABnTt3xnPPPafpd//+fVy6dAmPHj1CUVERHjx4gPj4eK2Cr6NGjarQo50VXVfJTDdra2t06NBBU9D/4sWLOHv2LE6fPq0pbiuTyTSz7q5cuYITJ05g3Lhx2LJlC4QQEEKgUaNGOHr0KN59992nxkhEREQVc+nSJWzcuBHZ2dn47bffoFQqMW3aNOzevRtA5e+vTpw4gcWLF+Ozzz7TeoSxQ4cO5b5wJzc3FyNHjsTnn3+udQ/zpP79++Odd97Bp59+qplRZWZmhsWLFyM6OhovvfQSHj16BKVSiT59+mDFihWl1uHv74/WrVtjw4YN+PjjjwEU3zsNHz5ca5b87du3ce3aNSiVStjY2ODUqVMQQmjdi02aNAlWVlZPPSYVWdfrr7+uOV4NGjRAgwYNcP36dXTv3h179uxBRkYGPvvsM80YW1tbhIaGAih+VDIjIwM2NjbYvHkzgOKXIPn5+eHo0aNVrp1GRFQRTHYRPaOkpCRs374dFhYW8Pb2xvnz5xEQEIDjx48DAB49elQt2+nbty/69u1bbp8XXnhB6/PUqVOxaNEi7N27V5Ps6t+/P9q0aYPw8HBIJBJkZWWhbdu2AIAVK1ZAJpPhyJEjWLp0KXJzcxEZGYklS5YgNDQUfn5+mmn8jo6OaNasGQ4fPoyePXuWimXs2LEYPHgw0tPToVAosHHjRixYsECz/LPPPsOiRYvQpk0buLm5aepplNTCKlG/fv2nHpuKruufdbzkcjny8vIAAAkJCQCgeazhn+Lj4wEUv0zgybdtWlpalvmGKCIiIqq6a9euYfv27bC2tka3bt0QFhYGT09PREREACi+v/Ly8qrQui5evIh+/fphwoQJeOedd7SWTZ48udyxS5YsQW5uLqysrDQ1UYuKinD27Fns2rULAwYMQL169RAREYFVq1bBx8cHy5cvx/jx4/HBBx/gxo0buHXrFm7cuIH09HT4+Pjg/fff16qfVWLs2LFYuXIlPv74YyQnJ+PIkSM4evQogOIk0fjx47F161Z07NgRTk5OyMjIQH5+PpRKpdZjkk+7d6rMup527+Th4aHzDZfx8fEwNzfH1q1btdobN24MPz+/cmMkInpWTHYRPaMnC9Q/qVWrVpDL5YiJiTHoN1cKhQKpqakAgNTUVFy5cqXUN3B9+/bFoUOHNGM8PDzw1VdfASi+Qfz1118RGxuLCxcuaGpRAEBgYCBu3LhRZrKrd+/esLe3x5YtW+Dr64tHjx5pZqalpKTggw8+wLFjxzRvjkxMTMTmzZshhNBaT3mF8Cu7rvI4ODgAKL55Lqnh9SQ7OzsAwKeffqozIUZERETV48kC9U/q0KEDACAmJkZTf6o8Fy9eRI8ePTB8+PAyZ1Q9jY+PD9q3b4/t27dr2lQqFc6fPw8bGxvN26lbtWqlWf+WLVuQlpaGyZMn48cff0Tr1q0hk8ng7OwMHx8f3Lp1q8xk15gxY/D+++8jJiYG0dHR8Pb21tzbHD16FL/99htu3boFDw8PAMC+fftw4MCBSt87VWZd5XFwcEBaWprO5XZ2digqKsKGDRsgk8kqvF4iouogfXoXIqoKW1tbTJ48GUuXLsWdO3dKLS+ZSVRRN27cKPctiwCQnJys9fnixYuIi4tD+/btAQDOzs6wsrLC1atXtfpdvXq1zG9H1Wo1Jk2ahGXLlkGhUMDZ2RkPHz6ESqXSbM/Z2bnMWGQyGUaOHIkNGzZgw4YN6NOnj6ZvSkoKgOJHM0ts2bKl3H3TpbrW1bZtWzg5OWHdunVa7SWJwnbt2sHZ2RkrV67UWi6EwL179yq9PSIiIqq8wMBAdO/eHQsWLEBmZmap5U/eX12+fBmhoaEYNmwYvvvuuzKTQKdOndK8wbEsr776KjZu3Kj1I5fLMX78+DKTZ+np6ZgzZw5+/PFHSCQSODs7a0pbqFQqPHjwQOe9k6enJ1544QXNvdOYMWM0Md+/fx/29vZas7aqeu9UXesKDQ1FTk4Otm3bptVecu/Uq1cvFBQUYO3atVrLCwoKNH2IiPSFM7uI9OjLL7/EnTt30KZNG0ycOBH+/v5ITU3F6dOnERcXp3njTkJCAo4fP665aYuIiEB6ejpatGiBVq1aASiue/DOO++U+zbG0NBQ9O7dGwEBAbh37x5WrFiB0NBQjB49GgAglUrx73//Gx9//DEyMjLQuHFjHD16FEeOHNGa2VVixYoVaNCggaZuVdOmTdGgQQNMmTIFXl5euH79ermz1l555RV06tQJVlZWCAsL07Q3b94cTZo0wahRo/DKK6/g8uXL+Pnnnyt5dKt3XZaWlvj+++8xbtw43L17Fx07dkRsbCwyMjLw888/w9LSEj/99BNGjRqF5ORk9OjRA6mpqdixYwcmTpyISZMmVSl+IiIiqpxffvkF/fv3R6tWrTBhwgT4+PggKSkJx44dg7OzM9avX4/k5GSEhobC2dkZ3bp1w2+//aYZ36NHD7i6ugIAfvjhh2qdhT9nzhxMmDABzZo1A1A8033q1Kn48MMPce/ePfj6+qJFixY6x7/yyiuYOXMmsrKytL6A6969O3Jzc/HKK68gNDQUERER2LlzZ5VirK51NWrUCAsXLsTYsWMxY8YMTR3T5s2bY8GCBXjuueewePFivPHGGzh37hyCgoIQHx+PLVu2YOXKlRWqyUpEVFWc2UX0DLp164YuXbroXG5paYkdO3ZoahUcPnwYKSkpGDJkCE6cOKHpV1L36/Dhwxg5ciRu376N7du34/Lly5o+FSlQf+bMGTRv3hwnT55EZmYmVq1ahf3798Pc3FzTZ/78+dizZw+KiooQGRmJhg0b4urVq6XqfRUWFuLy5ctYtmyZpk0ikWDfvn2oV68e0tLSEBkZWe6rtDt06IBJkyZh0KBBGDhwoKbd3Nwcx44dQ5cuXfDHH3/A2toa0dHRGDlypNaNT58+fTQ3i0/q2bMnAgICnnldzz//vOZxCAAYMWIETp06BUdHRxw/fhz+/v5Ys2aNZvmgQYNw4cIFNG7cGFFRUcjNzcX333/PRBcREVE1GjBggOY6XxZ3d3ecOHEC33zzDR4+fIjDhw8jJycHs2fPxvr16wEA2dnZCAkJQevWrbFjxw5s375d8/Pw4UPNujp06PDUmqj/NGzYsDJLGqSkpEAikeC9997TtNnZ2SEyMhKPHz+Gs7Mz9u/fX+5jhkOHDkX//v0xY8YMraRY/fr1ceLECbi7uyMiIgItWrTQ3Dc+WXB/5MiRZdbsGjp0KLy9vZ95XX379tWaTb9gwQLs3bsXubm5OH36NF5++WWtGq1z585FZGQkLC0tcezYMcjlcuzZswfdunXTeQyIiKqDRFTmwWwiIiIiIiIiIqJajDO7iIiIiIiIiIjIZDDZRUREREREREREJoPJLiIiIiIiIiIiMhlMdhERERERERERkclgsouIiIiIiIiIiEwGk11ERERERERERGQymOwiIiIiIiIiIiKTwWQXERERERERERGZDCa7iIiIiIiIiIjIZDDZRUREREREREREJoPJLiIiIiIiIiIiMhlMdhERERERERERkcn4f7+wM86uittAAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "figure, (left, right) = plt.subplots(1, 2, figsize=(12, 4.6), layout=\"constrained\")\n", + "plot_pca(cube, group=\"Monocytes\", color_by=\"condition\", ax=left)\n", + "plot_pca(\n", + " cube,\n", + " group=\"Monocytes\",\n", + " color_by=\"condition\",\n", + " marker_by=\"donor\",\n", + " components=(2, 3),\n", + " ax=right,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d42dccd5", + "metadata": {}, + "source": [ + "The first component, more than half of the variance, is the stimulation. On the second\n", + "and third, each donor's two samples lie near each other: donors differ, which is why\n", + "the design of [Genes that change in each cell type](genes_per_cell_type.ipynb) pairs\n", + "them.\n", + "\n", + "## A cell type with few cells\n", + "\n", + "Six profiles of dendritic cells pool fewer than 10 cells, and {api}`limma_voom` leaves\n", + "them out of the dendritic cells' fit ([Quick start](../quickstart.ipynb)). Where a rare\n", + "cell type matters less than its lineage, {api}`Cube.regroup` merges it with related\n", + "cell types: every layer of the merged cell type is the sum of its members', as pooling\n", + "the relabelled cells would give. Here the group table's lineage names the myeloid cell\n", + "types ({api}`Table.filter`)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1c46e742", + "metadata": { + "figure_descriptions": [ + "Heatmap of the cells pooled into each of the 24 samples and five cell types, after the monocytes and dendritic cells are merged into myeloid cells: the myeloid cells hold from 183 to 450 cells, and no entry is pale; the other rows are as before, with the fewest cells, 38, in the NK cells of D06_stim." + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table with 5 rows and 2 columns\n", + " group_id lineage\n", + " str str\n", + " B cells lymphoid\n", + " CD4 T cells lymphoid\n", + " CD8 T cells lymphoid\n", + " NK cells lymphoid\n", + " Myeloid cells myeloid\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myeloid = cube.groups.filter(cube.groups[\"lineage\"] == \"myeloid\")[\"group_id\"]\n", + "merged = cube.regroup({\"Myeloid cells\": list(myeloid)})\n", + "print(merged.groups)\n", + "plot_cell_numbers(merged)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "76314086", + "metadata": {}, + "source": [ + "Every profile of the merged myeloid cells holds enough cells. The merged profile mixes\n", + "two cell types in proportions that differ between samples, and the stimulation changes\n", + "those proportions ([Cell-type composition](composition.ipynb)), so a change in the\n", + "merged profile can come from either; testing the monocytes alone, and the dendritic\n", + "cells on their 18 profiles, keeps the two apart.\n", + "\n", + "## Choices\n", + "\n", + "- **Samples.** A sample is a biological replicate: one donor in one condition, or one\n", + " tissue of a donor. Pool technical replicates, such as lanes or libraries of the same\n", + " sample, by giving them one sample label, or later with {api}`Cube.collapse_samples`.\n", + "- **Tables.** The sample and group tables take a pandas DataFrame or a mapping of\n", + " columns, and a cube keeps them as {api}`Table` objects: {api}`Table.select` keeps some\n", + " columns, {api}`Table.filter` some rows, {api}`Table.with_columns` adds columns, such\n", + " as a variable for a design, and {api}`Table.to_pandas` gives a DataFrame.\n", + "- **Cell types.** Annotate at the level the question needs. {api}`Cube.select` keeps\n", + " some cell types, {api}`Cube.regroup` merges them, and the minimum of cells\n", + " (`min_cells` of {api}`limma_voom`, 10 by default) leaves out the profiles of too few\n", + " cells, with the reason in the result.\n", + "- **Layers.** `layers=\"counts\"` keeps only what the tests read: 4 bytes per sample,\n", + " cell type and gene, against 32 for all five layers, which matters for atlases of\n", + " thousands of samples. The dot plot needs `detected` and `log_sum`, and\n", + " {api}`Cube.variance` needs `log_sum_sq`.\n", + "- **Normalization of the cells.** `target_sum` (10,000) sets the total that every cell\n", + " is scaled to, and `library_sizes` gives the totals when the matrix holds only some of\n", + " the genes.\n", + "- **Bulk data.** {api}`from_bulk` wraps a samples x genes matrix of counts as a cube\n", + " with one group, which every test of a cube takes ([Bulk RNA-seq](bulk_rna_seq.ipynb)).\n", + "- **Other tools.** Cells in an AnnData, and profiles pooled by scanpy, decoupler or\n", + " LIANA, become cubes too ([Work with AnnData and MuData](anndata_and_mudata.ipynb))." + ] + } + ], + "metadata": { + "datasets": [ + "simulated_pbmc" + ], + "executed_at": "2026-10-26T22:21:37+00:00", + "executed_code_sha256": "cda3726c97acc5f96fb34da2f1a14df7ca8fd0725e2e817bb1c83427700dfef3", + "executed_datasets": { + "simulated_pbmc": { + "simulated_pbmc.cube.zarr": "sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726", + "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" + } + }, + "executed_with": "0.1.dev61+g194f49f8f", + "execution_seconds": 6.4, + "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.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/guides/save_and_trace_cubes.ipynb b/docs/source/guides/save_and_trace_cubes.ipynb new file mode 100644 index 0000000..0be7efb --- /dev/null +++ b/docs/source/guides/save_and_trace_cubes.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fa47edfc", + "metadata": {}, + "source": [ + "(save-and-trace-cubes)=\n", + "# Save, share and trace cubes\n", + "\n", + "A pseudobulk analysis passes through several hands: one person or tool pools the cells,\n", + "another tests the profiles, and the results are read months later, often on another\n", + "machine. Each step should be checkable: which values did a result come from, and is the\n", + "file at hand still the one analysed? A cube answers both with three records. Its file\n", + "opens without reading its counts and checks every value it reads; its fingerprint, a\n", + "digest of every value it holds, names it; and its provenance record says how it was\n", + "made, and goes into every result computed from it. This page saves and opens a cube,\n", + "derives one from another, shows a changed file being caught, and traces a result back\n", + "to the profiles it came from. [Cube files and provenance\n", + "records](../reference/cube_files.md) describes the file and the records for programs\n", + "that read or write them.\n", + "\n", + "## A cube file\n", + "\n", + "{api}`read_cube` opens a cube file, here the simulated PBMC study of the\n", + "[Datasets](../reference/datasets.md) page, by reading its tables and the digests of its\n", + "values; its layers stay on disk until an analysis reads them, one cell type at a time,\n", + "and a selection of genes reads only the chunks that hold them. The fingerprint comes\n", + "from the stored digests, without a read of the layers." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b8a75dce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CytePool 0.1.dev57+gb65bc7e32\n", + "Cube with 24 samples x 6 groups x 2,000 features\n", + " layers: counts (uint32, lazy), detected (uint32, lazy), log_sum (float64, lazy), log_sum_sq (float64, lazy), linear_sum (float64, lazy)\n", + " filled: 144 of 144 sample x group entries have cells (100.0%)\n", + " samples: sample_id, donor, condition, sex\n", + " groups: group_id\n", + " features: feature_id, symbol\n", + "\n", + "the cells 32.4 MB\n", + "the cube, layer counts 0.5 MB\n", + "the cube, layer detected 0.4 MB\n", + "the cube, layer log_sum 2.1 MB\n", + "the cube, layer log_sum_sq 2.1 MB\n", + "the cube, layer linear_sum 2.1 MB\n", + "\n", + "fingerprint: sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726\n" + ] + } + ], + "source": [ + "import os\n", + "import shutil\n", + "import textwrap\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import zarr\n", + "\n", + "import cytepool\n", + "from cytepool.design import Design\n", + "from cytepool.differential_expression import limma_voom\n", + "from cytepool.io import read_cube, write_cube\n", + "from cytepool.normalization import library_sizes\n", + "\n", + "\n", + "def megabytes(path):\n", + " files = [path] if path.is_file() else path.rglob(\"*\")\n", + " return sum(file.stat().st_size for file in files if file.is_file()) / 1e6\n", + "\n", + "\n", + "cube = read_cube(\"simulated_pbmc.cube.zarr\")\n", + "print(f\"CytePool {cytepool.__version__}\")\n", + "print(cube)\n", + "store = Path(\"simulated_pbmc.cube.zarr\")\n", + "sizes = {\"the cells\": megabytes(Path(\"simulated_pbmc_cells.npz\"))}\n", + "for name in cube.layer_names:\n", + " sizes[f\"the cube, layer {name}\"] = megabytes(store / \"layers\" / name)\n", + "print()\n", + "for what, size in sizes.items():\n", + " print(f\"{what:<28}{size:>5.1f} MB\")\n", + "print(\"\\nfingerprint:\", cube.fingerprint())" + ] + }, + { + "cell_type": "markdown", + "id": "5f88c490", + "metadata": {}, + "source": [ + "The counts of 19,151 cells, pooled into 144 profiles, take half a megabyte; the layers\n", + "that describe the cells take more, since their values are sums of real numbers, which\n", + "compress less. In memory, a study of 100 samples, 30 cell types and 30,000 genes needs\n", + "0.36 GB for its counts and 2.9 GB for all five layers, and an analysis of its cube file\n", + "holds one cell type at a time.\n", + "\n", + "## How a cube was made\n", + "\n", + "A cube is never changed in place: {api}`Cube.select`, {api}`Cube.regroup` and\n", + "{api}`Cube.collapse_samples` derive new cubes, and each adds a record of what it did to\n", + "the provenance, with the fingerprint of the cube it was applied to. Here the lymphoid\n", + "cell types are kept and the CD4 and CD8 T cells merged; {api}`write_cube` saves the\n", + "result, and {api}`Cube.history` prints its record: the source that the study's\n", + "simulation recorded, how {api}`from_cells` built the first cube, and the two operations." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "48fb45fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Source, as the caller recorded it (unresolved: CytePool does not follow its references):\n", + " dataset: \"simulated_pbmc\"\n", + " generator: \"docs/datasets.py, numpy.random.default_rng(20261026)\"\n", + " cells: \"every simulated cell\"\n", + " samples: \"donor_condition\"\n", + " groups: \"cell type\"\n", + "Built by from_cells (CytePool 0.1.dev42+g6991e63f8) from 19,151 cells:\n", + " samples: the rows of sample_table\n", + " groups: the rows of group_table\n", + " features: the ids of a table\n", + " layers: counts, detected, log_sum, log_sum_sq, linear_sum\n", + " normalized values: each cell scaled to a total of 10,000, with library sizes the total count of each cell\n", + "1. select, applied to the cube sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726\n", + " samples: every sample, as they were\n", + " groups: B cells, CD4 T cells, CD8 T cells, NK cells\n", + " features: every feature, as they were\n", + "2. regroup, applied to the cube sha256:bf51250542c52709ed8d3b9a2bd6ee7cc8b57987a37474a30a43e2c4b056de72\n", + " T cells: CD4 T cells + CD8 T cells\n", + "References: CytePool resolves none on its own. The source record's references need the tool that wrote them. A fingerprint names a cube without saying where it is: Cube.fingerprint() of a cube at hand says whether it is that cube.\n", + "Fingerprint: sha256:dc89e3961d73b0f35d90cb69fccfeb7f8c004c3f0a1bc23ecaadd840d1dfaaec\n" + ] + } + ], + "source": [ + "lymphoid = cube.select(groups=[\"B cells\", \"CD4 T cells\", \"CD8 T cells\", \"NK cells\"])\n", + "lymphoid = lymphoid.regroup({\"T cells\": [\"CD4 T cells\", \"CD8 T cells\"]})\n", + "write_cube(lymphoid, \"lymphoid.cube.zarr\")\n", + "opened = read_cube(\"lymphoid.cube.zarr\")\n", + "print(opened.history())" + ] + }, + { + "cell_type": "markdown", + "id": "b068aaf9", + "metadata": {}, + "source": [ + "Each operation names its input by fingerprint, so the chain can be checked link by\n", + "link: the first, the cube of the study, is the file opened above.\n", + "\n", + "## A changed file is caught\n", + "\n", + "The fingerprint read from a file rests on the digests stored with it, and a cube checks\n", + "each group of a layer against its digest whenever a read covers all of it. Here a copy\n", + "of the file is changed, one count more in the T cells of one sample, with zarr-python,\n", + "as a damaged copy or an edit would change it. Opening the copy and asking for its\n", + "fingerprint still succeed, since neither reads the counts; {api}`Cube.verify_fingerprint`\n", + "reads every value, and so does any analysis of the T cells, and both stop." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8e6b6a00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the fingerprint, from the stored digests, as before: True\n", + "\n", + "ValueError: group 'T cells' of the layer 'counts', read from the array at\n", + "edited.cube.zarr/layers/counts, does not match the digest stored with its cube file: the\n", + "file was changed after it was written. If the change was meant, delete the root\n", + "attribute 'digests' of the cube file (with zarr-python, for example) and open it again\n" + ] + } + ], + "source": [ + "shutil.copytree(\"lymphoid.cube.zarr\", \"edited.cube.zarr\")\n", + "counts = zarr.open_array(\"edited.cube.zarr/layers/counts\", mode=\"r+\")\n", + "counts[1, 0, 0] += 1 # the T cells of the first sample\n", + "edited = read_cube(\"edited.cube.zarr\")\n", + "print(\n", + " \"the fingerprint, from the stored digests, as before:\",\n", + " edited.fingerprint() == opened.fingerprint(),\n", + ")\n", + "try:\n", + " edited.verify_fingerprint()\n", + "except ValueError as error:\n", + " message = str(error).replace(os.getcwd() + os.sep, \"\")\n", + " print(\"\\n\" + textwrap.fill(f\"ValueError: {message}\", width=88))" + ] + }, + { + "cell_type": "markdown", + "id": "418d2430", + "metadata": {}, + "source": [ + "## Trace a result back to its profiles\n", + "\n", + "{api}`limma_voom` records in its result the fingerprint of the cube it read and, for\n", + "every cell type, the samples it fitted, in order, those it left out with the reason,\n", + "and the library size and normalization factor of each sample. From these, the\n", + "profiles of a cell type can be read back by their ids and the values of the fit\n", + "recomputed." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c3e54d8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "computed from this cube file: True\n", + "T cells: 24 profiles fitted, left out: none\n", + "library sizes as fitted: True\n", + "average log2 CPM as in the table: True\n" + ] + } + ], + "source": [ + "design = Design(\n", + " opened.samples,\n", + " \"~ donor + condition\",\n", + " levels={\"condition\": [\"ctrl\", \"stim\"]},\n", + " contrasts={\"stim_vs_ctrl\": \"conditionstim\"},\n", + ")\n", + "result = limma_voom(opened, design)\n", + "record = result.provenance\n", + "print(\n", + " \"computed from this cube file:\",\n", + " record[\"cube\"][\"fingerprint\"] == read_cube(\"lymphoid.cube.zarr\").fingerprint(),\n", + ")\n", + "\n", + "table = result.table(\"T cells\", \"stim_vs_ctrl\")\n", + "fit = next(group for group in record[\"groups\"] if group[\"group_id\"] == \"T cells\")\n", + "used = result.samples.filter(\n", + " (result.samples[\"group_id\"] == \"T cells\") & result.samples[\"used\"]\n", + ")\n", + "profiles = opened.select(\n", + " samples=fit[\"samples\"], groups=\"T cells\", features=table[\"feature_id\"]\n", + ")\n", + "counts = profiles.layer(\"counts\", \"T cells\")\n", + "print(\n", + " f\"T cells: {len(fit['samples'])} profiles fitted, left out: {fit['left_out'] or 'none'}\"\n", + ")\n", + "print(\n", + " \"library sizes as fitted:\",\n", + " np.array_equal(library_sizes(counts), used[\"library_size\"]),\n", + ")\n", + "# The log-CPM values that voom computes, from the effective library sizes.\n", + "size = used[\"library_size\"] * used[\"norm_factor\"]\n", + "log_cpm = np.log2((counts + 0.5) / (size[:, np.newaxis] + 1) * 1e6)\n", + "print(\n", + " \"average log2 CPM as in the table:\",\n", + " np.allclose(log_cpm.mean(axis=0), table[\"average_log2_cpm\"], rtol=1e-12),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e11f1ba3", + "metadata": {}, + "source": [ + "The profiles read back give the library sizes that entered the fit, and their log-CPM\n", + "values the average expression of every gene in the table. They can be drawn too: here\n", + "the gene with the smallest p-value, in every sample that entered its test, the two\n", + "samples of each donor joined by a line." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ee46000a", + "metadata": { + "figure_descriptions": [ + "The log2 CPM of gene_0191, as voom computes it, in the T cells of the 24 samples that entered its test, controls on the left and stimulated samples on the right, the two samples of each of the 12 donors joined by a grey line: every line rises, from between 9.0 and 9.7 to between 11.3 and 12.1, for a log2 fold change of 2.35." + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gene = int(np.argmin(table[\"p_value\"]))\n", + "donor = profiles.samples[\"donor\"]\n", + "figure, ax = plt.subplots(figsize=(6, 4))\n", + "for name in np.unique(donor):\n", + " ax.plot([\"ctrl\", \"stim\"], log_cpm[donor == name, gene], color=\"0.55\", marker=\"o\")\n", + "ax.set_xlim(-0.4, 1.4)\n", + "ax.set_ylabel(\"log2 CPM, as voom computes it\")\n", + "ax.set_title(\n", + " f\"{table['feature_id'][gene]} in the T cells, \"\n", + " f\"log2 fold change {table['log2_fold_change'][gene]:.2f}\"\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cd0b8f15", + "metadata": {}, + "source": [ + "## What CytePool can and cannot resolve\n", + "\n", + "- **It can** go from any number of a result to its cell type, contrast and gene, to the\n", + " samples of that fit and those left out with the reason, and to the profiles of the\n", + " cube that entered it, by their ids. It can tell whether a cube at hand is the one\n", + " analysed, by its fingerprint, and check, by reading it, that every value still\n", + " matches its digest. The record also holds the design and the settings of the fit,\n", + " and how the cube was made.\n", + "- **It cannot** find a cube from its fingerprint, which names the cube's values, not\n", + " where they are stored: keep the cube file with the results.\n", + "- **It cannot** follow the source record, which CytePool keeps as the tool that pooled\n", + " the cells wrote it; what it refers to, such as a dataset or a selection of cells,\n", + " needs that tool.\n", + "- **It cannot** go from a cube back to the cells, since a cube holds sums over cells:\n", + " keep the cells too.\n", + "\n", + "## Choices\n", + "\n", + "- **Compression.** {api}`write_cube` compresses with gzip by default (level 4);\n", + " `compression=\"zstd\"` uses Zstandard, on Python 3.14 or newer, and `compression=None`\n", + " stores the values uncompressed.\n", + "- **Checking a copy.** {api}`Cube.verify_fingerprint` reads every value of a file and\n", + " checks it against its digest: run it after copying a file, or before reporting\n", + " results computed from one.\n", + "- **Memory.** A cube from {api}`read_cube` reads its layers as an analysis needs them;\n", + " {api}`Cube.to_memory` reads them all at once, when they fit in memory and are read\n", + " many times.\n", + "- **Meant changes.** Derive a new cube with {api}`Cube.select`, {api}`Cube.regroup` or\n", + " {api}`Cube.collapse_samples` and save it, so that its record says what changed.\n", + "- **Records of results.** A result's `provenance` is plain JSON: save it with the\n", + " tables, for example with `json.dump`.\n", + "- **Other tools.** Any Zarr v3 reader opens a cube file. [Export a cube from another\n", + " tool](export_cubes.ipynb) builds one from sums that another tool computed, and [Work\n", + " with AnnData and MuData](anndata_and_mudata.ipynb) converts cubes for scanpy,\n", + " decoupler and LIANA." + ] + } + ], + "metadata": { + "datasets": [ + "simulated_pbmc" + ], + "executed_at": "2026-10-26T22:03:19+00:00", + "executed_code_sha256": "bc541ca76208660d90591cf1253aa41a17b7b9a4cf7fbad83ff44a07b86181d5", + "executed_datasets": { + "simulated_pbmc": { + "simulated_pbmc.cube.zarr": "sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726", + "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" + } + }, + "executed_with": "0.1.dev57+gb65bc7e32", + "execution_seconds": 2.9, + "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.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/index.md b/docs/source/index.md index 5eabfdc..1654471 100644 --- a/docs/source/index.md +++ b/docs/source/index.md @@ -15,10 +15,12 @@ the methods that are standard in R: limma, edgeR, DESeq2, dream, propeller and metafor. Its only required dependencies are numpy and numba, and every method is compared with the package that defined it ([Validation](validation.md)). -[Installation](installation.md) · [Quick start](quickstart.ipynb) · -[From cells to results](differential_expression.ipynb) · -[Choosing a method](statistics/choosing_a_method.md) · -[Capability matrix](reference/capabilities.md) · [API reference](/api/index.html) +Start with [Installation](installation.md) and the [Quick start](quickstart.ipynb), +which goes from cells to results in a few minutes. [Why pseudobulk](why_pseudobulk.ipynb) +shows why the tests compare samples, [Choosing a method](statistics/choosing_a_method.md) +which function answers which question, and the [Capability +matrix](reference/capabilities.md) and the [API reference](/api/index.html) list every +method. :::{note} Early development Nothing is released yet, and the interface may still change. diff --git a/docs/source/myst.yml b/docs/source/myst.yml index f51b467..ee74694 100644 --- a/docs/source/myst.yml +++ b/docs/source/myst.yml @@ -34,12 +34,18 @@ project: title: Installation - file: quickstart.ipynb title: Quick start - - file: differential_expression.ipynb - title: From cells to results + - file: why_pseudobulk.ipynb + title: Why pseudobulk - title: Build and share cubes children: + - file: guides/pool_cells.ipynb + title: Pool cells into pseudobulk profiles + - file: guides/save_and_trace_cubes.ipynb + title: Save, share and trace cubes - file: guides/export_cubes.ipynb title: Export a cube from another tool + - file: guides/anndata_and_mudata.ipynb + title: Work with AnnData and MuData - title: Compare conditions children: - file: guides/normalization_and_quality.ipynb diff --git a/docs/source/quickstart.ipynb b/docs/source/quickstart.ipynb index f78d551..ab6f73f 100644 --- a/docs/source/quickstart.ipynb +++ b/docs/source/quickstart.ipynb @@ -2,305 +2,134 @@ "cells": [ { "cell_type": "markdown", - "id": "0c754eaa", + "id": "fbb2d170", "metadata": {}, "source": [ "(quickstart)=\n", - "# Quick start: differential expression in bulk RNA-seq\n", + "# Quick start\n", "\n", - "This page runs a limma-voom analysis of simulated bulk RNA-seq counts from start to\n", - "finish: filtering genes by expression, TMM normalization factors, voom precision\n", - "weights, a design with named contrasts, a linear model for every gene, contrasts,\n", - "empirical Bayes moderation and adjusted p-values. Each step matches the R function\n", - "it mirrors, as the [Validation](validation.md) page shows; the one deliberate\n", - "difference here, exact standard errors for contrasts, is explained where it arises.\n", - "Because the counts are simulated, we know which genes truly changed, and the last\n", - "step checks the results against that truth.\n", + "Which genes does a stimulation change in each cell type, in a way that holds for other\n", + "donors and not only for the cells that were measured? This page answers that question\n", + "for a simulated study, from the cells to a result whose origin can be checked. It pools\n", + "the cells of every sample and cell type into a cube of pseudobulk profiles, tests the\n", + "stimulation in every cell type with limma-voom, and traces a result back to the\n", + "profiles and the cube it came from. Each step agrees with the package it follows\n", + "([Validation](validation.md)), and [Why pseudobulk](why_pseudobulk.ipynb) shows why the\n", + "tests compare samples, not cells.\n", "\n", - "The analysis runs in a few seconds. The first run in a new environment also compiles\n", - "CytePool's numerical routines, which takes longer once." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a01c9cfe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "numpy 2.5.4 and numba 0.68.0\n" - ] - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numba\n", - "import numpy as np\n", - "\n", - "from cytepool.design import Design\n", - "from cytepool.normalization import (\n", - " filter_by_expression,\n", - " library_sizes,\n", - " tmm_factors,\n", - ")\n", - "from cytepool.stats.empirical_bayes import moderated_statistics\n", - "from cytepool.stats.linear_models import contrasts_fit, fit_linear_model\n", - "from cytepool.stats.multiple_testing import adjust_p_values\n", - "from cytepool.stats.voom import voom\n", - "\n", - "print(\"numpy\", np.__version__, \"and numba\", numba.__version__)" - ] - }, - { - "cell_type": "markdown", - "id": "6486193d", - "metadata": {}, - "source": [ - "## Simulate an experiment\n", + "The study is the simulated PBMC dataset ([Datasets](reference/datasets.md)): 12 donors,\n", + "each sampled before and after a stimulation, 19,151 cells of six cell types over 2,000\n", + "genes, with changes planted in every cell type. In a clone of the repository,\n", + "`uv run --group docs python docs/datasets.py prepare simulated_pbmc` writes its files,\n", + "which the code opens by name. The figures need CytePool's `plot` extra\n", + "([Installation](installation.md)). The code runs in a few seconds; the first run in a\n", + "new environment also compiles CytePool's numerical routines, which takes about half a\n", + "minute, once.\n", "\n", - "Twelve samples: three treatments (control, drug A and drug B) with four replicates\n", - "each, sequenced in two batches that each hold two replicates of every treatment.\n", - "Data matrices in CytePool, such as counts and log expression values, are samples x\n", - "features, so the counts have one row per sample and one column per gene. Results of\n", - "the fits have one row per gene, as in limma.\n", + "## Pool the cells into a cube\n", "\n", - "The 6,000 genes have log-normal baseline abundances, so a minority of genes takes most\n", - "of the reads and many genes have only a few. Drug A changes 600 genes, up or down, by\n", - "0.6 to 2 on the log2 scale. Drug B shares 400 of those changes and makes 300 of its\n", - "own, mostly upwards; its extra reads go to those genes, so every other gene receives a\n", - "smaller share of drug B's libraries. Batch b2 shifts every gene by a small random\n", - "amount. Counts are negative binomial: gamma-distributed biological variation with a\n", - "coefficient of variation near 0.2, plus Poisson sampling. The libraries hold 2 to 5\n", - "million reads." + "{api}`from_cells` sums the counts of the cells of every sample and cell type into one\n", + "profile, and records how many cells it pooled into each. It takes a cells x genes\n", + "matrix of counts, dense or sparse in the CSR layout in which an AnnData's `X` usually\n", + "holds them, the sample and the cell type of every cell, and a table of the samples,\n", + "here the donor and the condition of each, which stays with the cube." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "8f6efb85", - "metadata": {}, + "execution_count": 1, + "id": "edaf48a1", + "metadata": { + "figure_descriptions": [ + "Heatmap of the cells pooled into each of the 24 samples (columns, a control and a stimulated sample of 12 donors) and six cell types (rows), shaded in blue on a logarithmic scale from 10 to about 450 cells, with each number written. Monocytes and CD4 T cells hold the most cells, up to 444 and 351; dendritic cells the fewest, from 4 to 30. Six entries of dendritic cells with fewer than 10 cells are pale grey: D02_stim, D03_stim, D06_stim, D08_stim, D10_ctrl and D10_stim." + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "12 samples x 6,000 genes\n" + "CytePool 0.1.dev57+gb65bc7e32\n", + "Cube with 24 samples x 6 groups x 2,000 features\n", + " layers: counts (uint32), detected (uint32), log_sum (float64), log_sum_sq (float64), linear_sum (float64)\n", + " filled: 144 of 144 sample x group entries have cells (100.0%)\n", + " samples: sample_id, donor, condition\n", + " groups: group_id\n", + " features: feature_id\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "library sizes (millions): [3.41 4.67 2.12 4.02 2.32 4.25 4.55 2.79 4.45 4.99 2.22 3.11]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "rng = np.random.default_rng(20261024)\n", - "n_genes = 6_000\n", - "treatments = np.array([\"control\", \"drug_a\", \"drug_b\"])\n", - "treatment = np.repeat(treatments, 4)\n", - "batch = np.tile([\"b1\", \"b1\", \"b2\", \"b2\"], 3)\n", - "genes = np.array([f\"gene_{g:04d}\" for g in range(n_genes)])\n", - "\n", - "# Log-normal baseline abundance of each gene.\n", - "log2_abundance = rng.normal(0.0, 2.0, n_genes) / np.log(2.0)\n", - "\n", - "# True log2 fold changes of drug A and drug B against control.\n", - "true_log2_fc = np.zeros((3, n_genes))\n", - "changed_by_a = rng.choice(n_genes, 600, replace=False)\n", - "signs = rng.choice([-1, 1], 600)\n", - "true_log2_fc[1, changed_by_a] = signs * rng.uniform(0.6, 2.0, 600)\n", - "shared = changed_by_a[:400]\n", - "true_log2_fc[2, shared] = true_log2_fc[1, shared]\n", - "unchanged_by_a = np.setdiff1d(np.arange(n_genes), changed_by_a)\n", - "changed_by_b = rng.choice(unchanged_by_a, 300, replace=False)\n", - "signs = rng.choice([-1, 1], 300, p=[0.2, 0.8])\n", - "true_log2_fc[2, changed_by_b] = signs * rng.uniform(0.6, 2.0, 300)\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy.sparse\n", "\n", - "# Batch b2 shifts every gene by a small random amount.\n", - "batch_shift = rng.normal(0.0, 0.3, n_genes)\n", + "import cytepool\n", + "from cytepool.cube import from_cells\n", + "from cytepool.design import Design\n", + "from cytepool.differential_expression import limma_voom\n", + "from cytepool.io import read_cube, write_cube\n", + "from cytepool.plotting import plot_cell_numbers, plot_significant_genes, plot_volcano\n", "\n", - "# Each library is shared out among the genes in proportion to their expression.\n", - "log2_expression = (\n", - " log2_abundance\n", - " + true_log2_fc[np.searchsorted(treatments, treatment)]\n", - " + (batch == \"b2\")[:, None] * batch_shift\n", + "cells = np.load(\"simulated_pbmc_cells.npz\")\n", + "counts = scipy.sparse.csr_array(\n", + " (cells[\"data\"], cells[\"indices\"], cells[\"indptr\"]), shape=tuple(cells[\"shape\"])\n", ")\n", - "proportions = 2.0**log2_expression\n", - "proportions /= proportions.sum(axis=1, keepdims=True)\n", - "depth = rng.uniform(2e6, 5e6, treatment.size)\n", - "expected = depth[:, None] * proportions\n", - "\n", - "# Negative binomial counts as gamma-Poisson mixtures.\n", - "dispersion = 0.04 * np.exp(rng.normal(0.0, 0.5, n_genes))\n", - "counts = rng.poisson(rng.gamma(1.0 / dispersion, expected * dispersion))\n", - "\n", - "print(f\"{counts.shape[0]} samples x {counts.shape[1]:,} genes\")\n", - "print(\"library sizes (millions):\", np.round(library_sizes(counts) / 1e6, 2))" - ] - }, - { - "cell_type": "markdown", - "id": "8147d253", - "metadata": {}, - "source": [ - "## Describe the design\n", - "\n", - "A [`Design`](/api/designs.html#cytepool.design.Design) holds the sample table, the fixed effects as an R\n", - "formula, and the comparisons to test. The formula `~ 0 + treatment + batch` gives one\n", - "column per treatment, its mean log expression in batch b1, and one column for the\n", - "difference that batch b2 makes. Column names follow R's `model.matrix`. Named contrasts\n", - "are linear combinations of the columns, written as in limma's `makeContrasts`.\n", - "\n", - "[`Design.check`](/api/designs.html#cytepool.design.Design.check) looks for problems that silently ruin an\n", - "analysis before anything is fitted: aliased columns, confounded factors, levels with a\n", - "single sample, contrasts that cannot be estimated and more." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "78be8a87", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design: 12 samples x 4 columns, formula '~ 0 + treatment + batch'\n", - " columns: treatmentcontrol, treatmentdrug_a, treatmentdrug_b, batchb2\n", - " contrasts: drug_a_vs_control, drug_b_vs_control, drug_b_vs_drug_a\n", - "Design check: 12 samples, 4 columns, rank 4, 8 residual degrees of freedom; no problems found.\n" - ] - } - ], - "source": [ - "design = Design(\n", - " {\"treatment\": treatment, \"batch\": batch},\n", - " \"~ 0 + treatment + batch\",\n", - " contrasts={\n", - " \"drug_a_vs_control\": \"treatmentdrug_a - treatmentcontrol\",\n", - " \"drug_b_vs_control\": \"treatmentdrug_b - treatmentcontrol\",\n", - " \"drug_b_vs_drug_a\": \"treatmentdrug_b - treatmentdrug_a\",\n", + "sample_ids = np.unique(cells[\"cell_sample\"])\n", + "cube = from_cells(\n", + " counts,\n", + " samples=cells[\"cell_sample\"],\n", + " groups=cells[\"cell_type\"],\n", + " sample_table={\n", + " \"sample_id\": sample_ids,\n", + " \"donor\": [sample.split(\"_\")[0] for sample in sample_ids],\n", + " \"condition\": [sample.split(\"_\")[1] for sample in sample_ids],\n", " },\n", + " features=cells[\"feature_id\"],\n", ")\n", - "print(design)\n", - "print(design.check())" + "print(f\"CytePool {cytepool.__version__}\")\n", + "print(cube)\n", + "plot_cell_numbers(cube)\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "a00c0f49", + "id": "e9cf2732", "metadata": {}, "source": [ - "## Filter out genes with too few counts\n", + "The profiles pool from 4 to 444 cells. A profile of a few cells is noisy, so\n", + "{api}`limma_voom` leaves the profiles of fewer than 10 cells out of their cell type's\n", + "fit: the six pale entries, all of them dendritic cells.\n", "\n", - "Genes with only a few reads carry almost no information about differences between\n", - "treatments, and they distort the mean-variance trend that voom fits.\n", - "[`filter_by_expression`](/api/normalization.html#cytepool.normalization.filter_by_expression) applies edgeR's `filterByExpr`\n", - "rule: a gene is kept when it reaches 10 reads at the median library size\n", - "(proportionally more in larger libraries) in at least n samples, and 15 reads in\n", - "total. Given groups, n is the size of the smallest group. Given a design, it is the\n", - "inverse of the design's largest leverage: 3 here, a little less than the four\n", - "replicates of each treatment, because the batch effect is estimated from the same\n", - "samples." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "31d63e47", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "kept 5,294 of 6,000 genes\n" - ] - } - ], - "source": [ - "keep = filter_by_expression(counts, design=design)\n", - "kept_counts = counts[:, keep]\n", - "kept_genes = genes[keep]\n", - "print(f\"kept {keep.sum():,} of {n_genes:,} genes\")" - ] - }, - { - "cell_type": "markdown", - "id": "51e72503", - "metadata": {}, - "source": [ - "## Normalization factors\n", + "## Test every cell type\n", "\n", - "Library sizes account for sequencing depth, but not for composition: drug B's\n", - "upregulated genes take a larger share of its reads, so every other gene looks a little\n", - "lower in drug B. [`tmm_factors`](/api/normalization.html#cytepool.normalization.tmm_factors) computes edgeR's trimmed\n", - "mean of M values (TMM) factors, which scale the library sizes so that most genes do not\n", - "change between samples. Here they are computed from the genes that were kept. The\n", - "factors of the drug B samples are the smallest." + "Every donor gives a control and a stimulated sample. The design `~ donor + condition`\n", + "compares the two samples of each donor, so that the differences between donors do not\n", + "count as noise, and its coefficient `conditionstim` is the log2 fold change of the\n", + "stimulation. {api}`limma_voom` then takes one cell type at a time: it keeps the genes\n", + "with enough counts, normalizes the libraries by TMM, gives every observation a voom\n", + "precision weight, fits the design to every gene and moderates the contrast by empirical\n", + "Bayes [@law2014; @ritchie2015]." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "bae77060", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "control b1 1.049\n", - "control b1 1.047\n", - "control b2 1.023\n", - "control b2 1.028\n", - "drug_a b1 1.008\n", - "drug_a b1 1.018\n", - "drug_a b2 1.012\n", - "drug_a b2 0.997\n", - "drug_b b1 0.967\n", - "drug_b b1 0.962\n", - "drug_b b2 0.953\n", - "drug_b b2 0.944\n" - ] - } - ], - "source": [ - "norm_factors = tmm_factors(kept_counts)\n", - "for sample in range(treatment.size):\n", - " print(f\"{treatment[sample]:<8} {batch[sample]} {norm_factors[sample]:.3f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "166a77b5", - "metadata": {}, - "source": [ - "## Precision weights with voom\n", - "\n", - "[`voom`](/api/voom.html#cytepool.stats.voom.voom) turns the counts into log2 counts per million, using\n", - "the library sizes times the normalization factors, and estimates how their variance\n", - "depends on the expression level: it fits the design to every gene, smooths the square\n", - "root of the residual standard deviations against the mean log count by LOWESS, and\n", - "gives each observation the inverse of its predicted variance as its weight. Low counts\n", - "are noisier on the log scale, so the trend decreases. Each local fit of the LOWESS\n", - "uses a fraction of the genes, the span, which voom chooses from the number of genes as\n", - "limma does and records in its result." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "c0f8a44c", + "execution_count": 2, + "id": "2e532d8d", "metadata": { "figure_descriptions": [ - "Scatter plot of the square root of each gene's residual standard deviation against its mean log2 count, from about 2 to 16. A red LOWESS curve falls from about 0.85 at the lowest counts and levels off near 0.53 above a mean log2 count of about 10." + "Horizontal bars of the genes up (red, to the right) and down (blue, to the left) at an adjusted p-value below 0.05 in each of the six cell types: B cells 82 up and 61 down, CD4 T cells 85 and 59, CD8 T cells 81 and 58, dendritic cells 76 and 43, monocytes 95 and 62, NK cells 83 and 54." ] }, "outputs": [ @@ -308,14 +137,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "VoomResult(n_samples=12, n_features=5294, features_in_trend=5294, span=0.448)\n" + "DifferentialExpressionResult (limma_voom): 6 groups, 6 fitted; 1 contrast: stim_vs_ctrl\n", + " B cells: 24 samples, 1951 features\n", + " CD4 T cells: 24 samples, 1998 features\n", + " CD8 T cells: 24 samples, 1974 features\n", + " Dendritic cells: 18 samples, 1498 features\n", + " Monocytes: 24 samples, 1997 features\n", + " NK cells: 24 samples, 1918 features\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -323,313 +158,244 @@ } ], "source": [ - "voom_result = voom(kept_counts, design, norm_factors=norm_factors)\n", - "print(voom_result)\n", - "\n", - "# Plot each gene's square-root standard deviation against its mean log\n", - "# count, with the LOWESS trend that gives the weights.\n", - "order = np.argsort(voom_result.mean_log_count)\n", - "figure, axes = plt.subplots(figsize=(6, 4), dpi=100)\n", - "axes.scatter(\n", - " voom_result.mean_log_count,\n", - " voom_result.sqrt_sd,\n", - " s=3,\n", - " color=\"0.45\",\n", - " alpha=0.4,\n", - " linewidths=0,\n", - ")\n", - "axes.plot(\n", - " voom_result.mean_log_count[order],\n", - " voom_result.sqrt_sd_trend[order],\n", - " color=\"tab:red\",\n", + "design = Design(\n", + " cube.samples,\n", + " \"~ donor + condition\",\n", + " levels={\"condition\": [\"ctrl\", \"stim\"]},\n", + " contrasts={\"stim_vs_ctrl\": \"conditionstim\"},\n", ")\n", - "axes.set_xlabel(\"Mean log2 count\")\n", - "axes.set_ylabel(\"Square root of residual SD\")\n", - "axes.set_title(\"voom mean-variance trend\")\n", + "result = limma_voom(cube, design)\n", + "print(result)\n", + "plot_significant_genes(result)\n", "plt.show()" ] }, { "cell_type": "markdown", - "id": "79fb356a", + "id": "cc0f5e71", "metadata": {}, "source": [ - "## Fit a linear model to every gene\n", + "The simulation changed 140 genes in each cell type, and about as many are called in\n", + "each. The dendritic cells, fitted on their 18 profiles of 10 cells or more, have the\n", + "fewest calls.\n", "\n", - "[`fit_linear_model`](/api/linear_models.html#cytepool.stats.linear_models.fit_linear_model) regresses the log2 counts per\n", - "million of each gene on the design by weighted least squares, with the voom weights,\n", - "as limma's `lmFit` does. Its coefficients are named after the design's columns." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a57d45d2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('treatmentcontrol', 'treatmentdrug_a', 'treatmentdrug_b', 'batchb2')\n", - "residual degrees of freedom: 8.0\n" - ] - } - ], - "source": [ - "fit = fit_linear_model(voom_result.log_cpm, design, weights=voom_result.weights)\n", - "print(fit.coefficient_names)\n", - "print(\"residual degrees of freedom:\", fit.df_residual[0])" - ] - }, - { - "cell_type": "markdown", - "id": "8b7ba4b4", - "metadata": {}, - "source": [ - "## Contrasts\n", - "\n", - "[`contrasts_fit`](/api/linear_models.html#cytepool.stats.linear_models.contrasts_fit) re-expresses every gene's fit in\n", - "terms of the named contrasts, as limma's `contrasts.fit` does: the coefficients become\n", - "log2 fold changes. By default, the standard error of each contrast comes from the\n", - "gene's own covariance matrix of the coefficients, which is exact. limma instead\n", - "combines the gene's standard errors with the correlations of the coefficients in the\n", - "design without weights. The two agree when one factorisation of the design serves\n", - "every gene (no missing values, and no weights or only sample weights) and for\n", - "contrasts of uncorrelated coefficients. Here voom's weights differ between genes and\n", - "the batch column correlates the treatment coefficients, so limma's standard errors\n", - "are approximate; `method=\"limma\"` reproduces them." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "fe976211", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('drug_a_vs_control', 'drug_b_vs_control', 'drug_b_vs_drug_a')\n" - ] - } - ], - "source": [ - "contrast_fit = contrasts_fit(fit, design.contrasts)\n", - "print(contrast_fit.coefficient_names)" - ] - }, - { - "cell_type": "markdown", - "id": "da828344", - "metadata": {}, - "source": [ - "## Empirical Bayes moderation\n", + "## The genes of one cell type\n", "\n", - "With eight residual degrees of freedom, each gene's variance is poorly estimated on\n", - "its own. [`moderated_statistics`](/api/empirical_bayes.html#cytepool.stats.empirical_bayes.moderated_statistics) estimates a prior\n", - "distribution of the variances from all genes and replaces each gene's variance by a\n", - "weighted average of that variance and the prior variance, with their degrees of\n", - "freedom as weights (limma's `eBayes` and its posterior variances). The moderated\n", - "t-statistics have the residual and the prior degrees of freedom combined." + "Each cell type and contrast has a table of its genes with the columns of limma's\n", + "`topTable` ({api}`DifferentialExpressionResult.table`). The volcano plot shows their\n", + "p-values against their fold changes and names the genes with the smallest p-values;\n", + "the table converts to a pandas DataFrame for sorting and export." ] }, { "cell_type": "code", - "execution_count": 9, - "id": "adc1099d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "prior degrees of freedom: 13.46\n", - "prior variance: 0.9854\n" - ] - } - ], - "source": [ - "moderated = moderated_statistics(contrast_fit)\n", - "print(f\"prior degrees of freedom: {moderated.prior_df:.2f}\")\n", - "print(f\"prior variance: {moderated.prior_variance:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "bea13e41", - "metadata": {}, - "source": [ - "## Adjusted p-values and top genes\n", - "\n", - "[`adjust_p_values`](/api/multiple_testing.html#cytepool.stats.multiple_testing.adjust_p_values) with the Benjamini-Hochberg\n", - "method controls the false discovery rate. `axis=0` adjusts each contrast (each column)\n", - "as its own family of tests, as limma's `topTable` does for one coefficient." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8f5373e6", - "metadata": {}, + "execution_count": 3, + "id": "6572bdf4", + "metadata": { + "figure_descriptions": [ + "Volcano plot of the monocyte genes: -log10 p-value, up to about 300, against the log2 fold change of the stimulation, from about -2 to 2.5. The 95 genes up, in red, and the 62 down, in blue, lie at fold changes beyond about 0.7 in either direction; the 1,840 genes that are not significant, in grey, gather near zero. The ten genes with the smallest p-values are named, all of them up, among them gene_1493, gene_0766 and gene_0640." + ] + }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "drug_a_vs_control: 462 genes at 5% FDR, 256 up and 206 down\n", - "drug_b_vs_control: 555 genes at 5% FDR, 380 up and 175 down\n", - "drug_b_vs_drug_a: 386 genes at 5% FDR, 258 up and 128 down\n" - ] - } - ], - "source": [ - "fdr = adjust_p_values(moderated.p_value, \"bh\", axis=0)\n", - "log2_fc = contrast_fit.coefficients\n", - "for j, name in enumerate(contrast_fit.coefficient_names):\n", - " significant = fdr[:, j] < 0.05\n", - " up = np.count_nonzero(significant & (log2_fc[:, j] > 0))\n", - " down = np.count_nonzero(significant & (log2_fc[:, j] < 0))\n", - " print(f\"{name}: {up + down} genes at 5% FDR, {up} up and {down} down\")" - ] - }, - { - "cell_type": "markdown", - "id": "e757393b", - "metadata": {}, - "source": [ - "The genes with the smallest p-values for drug A against control, with the columns of\n", - "limma's `topTable`: the log2 fold change, the mean log2 CPM, the moderated\n", - "t-statistic, its p-value, the adjusted p-value and the B-statistic (the log-odds that\n", - "the gene changed). This is the order of `topTable(sort.by = \"P\")`; by default\n", - "`topTable` sorts by B, which can order genes with different weights slightly\n", - "differently." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "64508d0c", - "metadata": {}, - "outputs": [ + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "gene logFC AveExpr t P.Value adj.P.Val B\n", - "gene_3774 2.68 6.96 13 1.28e-11 6.77e-08 16.7\n", - "gene_1529 2.11 6.43 12.2 3.85e-11 1.02e-07 15.6\n", - "gene_0118 1.99 11.4 11.9 6.47e-11 1.14e-07 15.2\n", - "gene_0744 2.25 9.19 11.5 1.18e-10 1.56e-07 14.6\n", - "gene_1858 2.26 5.98 11.2 1.92e-10 1.62e-07 14.1\n", - "gene_4276 1.93 10.2 11.1 2.29e-10 1.62e-07 13.9\n", - "gene_5034 -2.29 5.9 -11.1 2.31e-10 1.62e-07 13.9\n", - "gene_2462 1.77 10.7 11 2.56e-10 1.62e-07 13.8\n", - "gene_4195 1.97 8.52 11 2.75e-10 1.62e-07 13.7\n", - "gene_4928 2.26 4.92 10.7 4.57e-10 2.31e-07 13.2\n" - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
log2_fold_changeaverage_log2_cpmtadjusted_p_value
feature_id
gene_14932.0711.596.41.6e-301
gene_07661.8711.9933.99e-295
gene_06401.6212.690.52.77e-290
gene_15362.4110.385.19.77e-279
gene_05712.4910.284.91.72e-278
\n", + "
" + ], + "text/plain": [ + " log2_fold_change average_log2_cpm t adjusted_p_value\n", + "feature_id \n", + "gene_1493 2.07 11.5 96.4 1.6e-301\n", + "gene_0766 1.87 11.9 93 3.99e-295\n", + "gene_0640 1.62 12.6 90.5 2.77e-290\n", + "gene_1536 2.41 10.3 85.1 9.77e-279\n", + "gene_0571 2.49 10.2 84.9 1.72e-278" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "j = contrast_fit.coefficient_names.index(\"drug_a_vs_control\")\n", - "top = np.argsort(moderated.p_value[:, j])[:10]\n", - "columns = {\n", - " \"logFC\": log2_fc[top, j],\n", - " \"AveExpr\": fit.mean_expression[top],\n", - " \"t\": moderated.t[top, j],\n", - " \"P.Value\": moderated.p_value[top, j],\n", - " \"adj.P.Val\": fdr[top, j],\n", - " \"B\": moderated.lods[top, j],\n", - "}\n", - "print(f\"{'gene':<10}\" + \"\".join(f\"{name:>10}\" for name in columns))\n", - "for row, g in enumerate(top):\n", - " values = \"\".join(f\"{column[row]:>10.3g}\" for column in columns.values())\n", - " print(f\"{kept_genes[g]:<10}{values}\")" + "table = result.table(\"Monocytes\", \"stim_vs_ctrl\")\n", + "plot_volcano(table)\n", + "plt.show()\n", + "columns = [\"log2_fold_change\", \"average_log2_cpm\", \"t\", \"adjusted_p_value\"]\n", + "top = table.to_pandas().sort_values(\"p_value\").set_index(\"feature_id\")[columns]\n", + "top.head().map(\"{:.3g}\".format)" ] }, { "cell_type": "markdown", - "id": "ac88da77", + "id": "4c5e07a2", "metadata": {}, "source": [ - "## Compare with the truth\n", + "## Trace a result back to its cube\n", "\n", - "The simulation knows which genes changed in each comparison. At a 5% false discovery\n", - "rate, the share of discoveries that are false should be about 5% or less, and most of\n", - "the genes that changed should be found." + "Every result keeps a record of what produced it: the method and its settings, the\n", + "versions of CytePool, numpy, numba and Python, the design, and the cube, named by its\n", + "fingerprint, a digest of every value it holds. For every cell type the record lists the\n", + "profiles that entered the fit, and those left out with the reason. {api}`write_cube`\n", + "saves the cube and {api}`read_cube` opens it, on this machine or another, without\n", + "reading its counts; its fingerprint then says whether it is the cube the result was\n", + "computed from." ] }, { "cell_type": "code", - "execution_count": 12, - "id": "f7a51c0f", + "execution_count": 4, + "id": "18e4e310", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "drug_a_vs_control: found 441 of 544 changed genes; 21 of 462 discoveries are false (4.5%)\n", - "drug_b_vs_control: found 535 of 636 changed genes; 20 of 555 discoveries are false (3.6%)\n", - "drug_b_vs_drug_a: found 372 of 458 changed genes; 14 of 386 discoveries are false (3.6%)\n" + "computed from the cube sha256:1ec128cf0fb164a6c39ce11aef964d237b81ec6c87fa06b5ab44eebcff052438\n", + "the saved file holds that cube: True\n", + "Dendritic cells: 18 profiles fitted, left out:\n", + " D02_stim: 9 cells, fewer than min_cells (10)\n", + " D03_stim: 8 cells, fewer than min_cells (10)\n", + " D06_stim: 8 cells, fewer than min_cells (10)\n", + " D08_stim: 6 cells, fewer than min_cells (10)\n", + " D10_ctrl: 4 cells, fewer than min_cells (10)\n", + " D10_stim: 4 cells, fewer than min_cells (10)\n" ] } ], "source": [ - "truth = {\n", - " \"drug_a_vs_control\": true_log2_fc[1] - true_log2_fc[0],\n", - " \"drug_b_vs_control\": true_log2_fc[2] - true_log2_fc[0],\n", - " \"drug_b_vs_drug_a\": true_log2_fc[2] - true_log2_fc[1],\n", - "}\n", - "for j, name in enumerate(contrast_fit.coefficient_names):\n", - " changed = truth[name][keep] != 0\n", - " found = fdr[:, j] < 0.05\n", - " true_found = np.count_nonzero(found & changed)\n", - " false_found = np.count_nonzero(found & ~changed)\n", - " print(\n", - " f\"{name}: found {true_found} of {changed.sum()} changed genes; \"\n", - " f\"{false_found} of {found.sum()} discoveries are false \"\n", - " f\"({false_found / max(found.sum(), 1):.1%})\"\n", - " )" + "write_cube(cube, \"pbmc.cube.zarr\")\n", + "opened = read_cube(\"pbmc.cube.zarr\")\n", + "record = result.provenance\n", + "print(\"computed from the cube\", record[\"cube\"][\"fingerprint\"])\n", + "print(\n", + " \"the saved file holds that cube:\",\n", + " opened.fingerprint() == record[\"cube\"][\"fingerprint\"],\n", + ")\n", + "dendritic = next(\n", + " fit for fit in record[\"groups\"] if fit[\"group_id\"] == \"Dendritic cells\"\n", + ")\n", + "print(f\"Dendritic cells: {len(dendritic['samples'])} profiles fitted, left out:\")\n", + "for sample, reason in dendritic[\"left_out\"].items():\n", + " print(f\" {sample}: {reason}\")" ] }, { "cell_type": "markdown", - "id": "bf0a91dd", + "id": "17e27e5d", "metadata": {}, "source": [ - "## The same analysis in R\n", + "## Next steps\n", "\n", - "Each step corresponds to an edgeR or limma function. R stores genes in rows, so its\n", - "count matrix is the transpose of the one used here. Library sizes are the totals of\n", - "the genes that were kept, in both.\n", - "\n", - "| Step | CytePool | R |\n", - "| --- | --- | --- |\n", - "| Filter genes | `keep = filter_by_expression(counts, design=design)`, then `counts[:, keep]` | `keep <- filterByExpr(y, design)`, then `y[keep, , keep.lib.sizes = FALSE]` |\n", - "| Normalization factors | `tmm_factors(counts)` | `calcNormFactors(y)` |\n", - "| Design and contrasts | `Design(samples, \"~ 0 + treatment + batch\", contrasts=...)` | `model.matrix(~ 0 + treatment + batch)` and `makeContrasts(...)` |\n", - "| Precision weights | `voom(counts, design, norm_factors=factors)` | `voom(y, design)` in limma 3.66 or later, `voom(y, design, adaptive.span = TRUE)` in 3.60 to 3.65 |\n", - "| Linear models | `fit_linear_model(v.log_cpm, design, weights=v.weights)` | `lmFit(v, design)` |\n", - "| Contrasts | `contrasts_fit(fit, design.contrasts, method=\"limma\")` | `contrasts.fit(fit, contrasts)` |\n", - "| Moderation | `moderated_statistics(fit)` | `eBayes(fit)` |\n", - "| Adjusted p-values | `adjust_p_values(p, \"bh\", axis=0)` | `topTable(fit, coef = j, sort.by = \"P\")`, which adjusts by BH |\n", - "\n", - "`moderated_statistics` estimates the prior as `eBayes` does by default: by limma's\n", - "moment estimator when all genes have the same residual degrees of freedom, as here,\n", - "and by its likelihood estimator when they differ. The\n", - "[API reference](/api/index.html) documents every function, and the\n", - "[Validation](validation.md) page shows how closely each one agrees with R." + "- [Why pseudobulk](why_pseudobulk.ipynb): what goes wrong when cells are tested as\n", + " replicates, and what benchmarks and replication studies found.\n", + "- [Pool cells into pseudobulk profiles](guides/pool_cells.ipynb): samples, cell types\n", + " and layers, merged cell types, the dot plot of markers and the PCA of samples.\n", + "- [Save, share and trace cubes](guides/save_and_trace_cubes.ipynb): cube files,\n", + " fingerprints and provenance records in full.\n", + "- [Genes that change in each cell type](guides/genes_per_cell_type.ipynb): the same\n", + " analysis on published data, with the choices it involves.\n", + "- [Choosing a method](statistics/choosing_a_method.md): which function answers which\n", + " question, for which design." ] } ], "metadata": { - "executed_at": "2026-10-25T08:32:14+00:00", - "executed_code_sha256": "8d82fd0b16b2233b7dd3ac699e715b42e946e4fb8f7c1653294cfaa459b82f34", - "execution_seconds": 2.1, + "datasets": [ + "simulated_pbmc" + ], + "executed_at": "2026-10-26T22:13:56+00:00", + "executed_code_sha256": "c45a47a9acccc6128493bc7f749914d4619686b9fe4c7d9948ad08dba4a141a5", + "executed_datasets": { + "simulated_pbmc": { + "simulated_pbmc.cube.zarr": "sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726", + "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" + } + }, + "executed_with": "0.1.dev57+gb65bc7e32", + "execution_seconds": 5.0, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/docs/source/reference/cube_files.md b/docs/source/reference/cube_files.md index fedad8b..1705cb3 100644 --- a/docs/source/reference/cube_files.md +++ b/docs/source/reference/cube_files.md @@ -8,7 +8,8 @@ A cube file stores a cube so that any Zarr v3 reader can open it, and so that a can tell whether it holds what was written. Its fingerprint names the cube's values, and its provenance record says how the cube was made. This page describes all three, for programs that read or write cubes; [Export a cube from another -tool](../guides/export_cubes.ipynb) shows the steps in code. +tool](../guides/export_cubes.ipynb) shows the steps in code, and [Save, share and trace +cubes](../guides/save_and_trace_cubes.ipynb) what a reader can check with them. ## The file diff --git a/docs/source/statistics/choosing_a_method.md b/docs/source/statistics/choosing_a_method.md index 0cd5392..3e2a23f 100644 --- a/docs/source/statistics/choosing_a_method.md +++ b/docs/source/statistics/choosing_a_method.md @@ -8,8 +8,9 @@ CytePool's tests compare samples, not cells: each takes one profile per sample, a difference is measured against the variation between donors. Cells of one donor share its genetics and environment, and a test that treats them as independent replicates finds differences that do not hold across donors [@squair2021; @zimmerman2021; -@murphy2022]. Pool the cells of each sample and cell type into a cube first -({api}`from_cells`); the methods below then run on its pseudobulk profiles. +@murphy2022], as [Why pseudobulk](../why_pseudobulk.ipynb) shows. Pool the cells of +each sample and cell type into a cube first ({api}`from_cells`); the methods below then +run on its pseudobulk profiles. ## Genes that change in each cell type diff --git a/docs/source/statistics/cubes.md b/docs/source/statistics/cubes.md index 873a37a..57c786c 100644 --- a/docs/source/statistics/cubes.md +++ b/docs/source/statistics/cubes.md @@ -8,7 +8,8 @@ A cube holds one pseudobulk profile for every sample and group (usually a cell t the sums, over the cells of that sample and group, of each feature's counts and of a few statistics of its normalized values. {api}`from_cells` builds it from a cells x features count matrix and the sample and group label of every cell; {api}`from_bulk` wraps a -samples x features matrix as a cube with one group. +samples x features matrix as a cube with one group. [Pool cells into pseudobulk +profiles](../guides/pool_cells.ipynb) shows these steps on data. ## The layers diff --git a/docs/source/why_pseudobulk.ipynb b/docs/source/why_pseudobulk.ipynb new file mode 100644 index 0000000..0046619 --- /dev/null +++ b/docs/source/why_pseudobulk.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3a703fce", + "metadata": {}, + "source": [ + "(why-pseudobulk)=\n", + "# Why pseudobulk\n", + "\n", + "A study of 12 donors that measures 300 cells of a cell type in each donor has 12\n", + "replicates of that cell type, not 3,600. Cells of one donor share its genotype, its\n", + "environment and the handling of its sample, so they resemble each other more than they\n", + "resemble the cells of other donors. A test that treats the cells as replicates measures\n", + "a difference against a standard error that shrinks with every cell sampled, and calls\n", + "differences that other donors do not share [@squair2021; @zimmerman2021]. Pooling the\n", + "cells of each sample and cell type into one profile, a pseudobulk profile, makes the\n", + "sample the unit of every test: a difference is then measured against the variation\n", + "between donors, with the methods that bulk RNA-seq developed for it.\n", + "\n", + "This page shows the problem on a comparison in which nothing differs, then what\n", + "benchmarks and studies of replication found.\n", + "\n", + "## A comparison in which nothing differs\n", + "\n", + "The control samples of the simulated PBMC study come from 12 donors who were treated\n", + "alike ([Datasets](reference/datasets.md)). Split at random into two groups of six,\n", + "they differ in no gene, beyond the small shift that the simulation gives every gene of\n", + "each donor, in all of the donor's cells, as real donors differ. Every gene of a cell\n", + "type is tested between the two groups in two ways:\n", + "\n", + "- **Cells as replicates:** Welch's t-test on the log-normalized values of the cells,\n", + " the test that scanpy's `rank_genes_groups` runs by default [@wolf2018]. The cube\n", + " holds what it needs: the cells of each group's samples, pooled by\n", + " {api}`Cube.collapse_samples`, give the mean and the variance of the cells' values\n", + " ({api}`Cube.mean`, {api}`Cube.variance`).\n", + "- **Samples as replicates:** {api}`limma_voom` on the pseudobulk profiles of the 12\n", + " samples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "547cc1b3", + "metadata": { + "figure_descriptions": [ + "Two histograms of the p-values of the 2,000 genes of the CD4 T cells, in 20 bins of width 0.05, between two random groups of six donors that do not differ, each with a dashed line at the count expected without differences, 100. Left, cells as replicates: the first bin, p-values below 0.05, holds about 750 genes, the second about 150, and the other bins fewer than the dashed line. Right, samples as replicates: every bin holds close to the expected count." + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CytePool 0.1.dev57+gb65bc7e32\n", + "group A: D01, D05, D06, D08, D09, D12\n", + "group B: D02, D03, D04, D07, D10, D11\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import cytepool\n", + "from cytepool.design import Design\n", + "from cytepool.differential_expression import limma_voom\n", + "from cytepool.io import read_cube\n", + "from cytepool.plotting import plot_p_values\n", + "from cytepool.stats.distributions import t_sf\n", + "from cytepool.stats.multiple_testing import adjust_p_values\n", + "\n", + "cube = read_cube(\"simulated_pbmc.cube.zarr\")\n", + "controls = cube.select(samples=cube.samples[\"condition\"] == \"ctrl\")\n", + "donors = controls.samples[\"donor\"]\n", + "in_a = np.isin(donors, np.random.default_rng(1).permutation(donors)[:6])\n", + "print(f\"CytePool {cytepool.__version__}\")\n", + "print(\"group A:\", \", \".join(donors[in_a]))\n", + "print(\"group B:\", \", \".join(donors[~in_a]))\n", + "\n", + "\n", + "def pooled_cells(cube, group, samples):\n", + " # The cells of some samples of one cell type: how many, and the mean and\n", + " # variance of every gene's log-normalized values. Every control sample has the\n", + " # condition ctrl, so pooling by condition pools them all.\n", + " pooled = cube.select(samples=samples, groups=group).collapse_samples(\"condition\")\n", + " return pooled.n_cells[0, 0], pooled.mean(group)[0], pooled.variance(group)[0]\n", + "\n", + "\n", + "def test_of_cells(cube, group, in_a):\n", + " # Welch's t-test of every gene between the cells of two sets of samples.\n", + " (n_a, mean_a, var_a), (n_b, mean_b, var_b) = (\n", + " pooled_cells(cube, group, samples) for samples in (in_a, ~in_a)\n", + " )\n", + " se2_a, se2_b = var_a / n_a, var_b / n_b\n", + " t = (mean_a - mean_b) / np.sqrt(se2_a + se2_b)\n", + " df = (se2_a + se2_b) ** 2 / (se2_a**2 / (n_a - 1) + se2_b**2 / (n_b - 1))\n", + " return 2 * t_sf(np.abs(t), df)\n", + "\n", + "\n", + "design = Design(\n", + " controls.samples.with_columns(group=np.where(in_a, \"A\", \"B\")),\n", + " \"~ group\",\n", + " levels={\"group\": [\"A\", \"B\"]},\n", + " contrasts={\"B_vs_A\": \"groupB\"},\n", + ")\n", + "of_samples = limma_voom(controls, design)\n", + "\n", + "cd4 = \"CD4 T cells\"\n", + "figure, (left, right) = plt.subplots(\n", + " 1, 2, figsize=(12, 3.8), layout=\"constrained\", sharey=True\n", + ")\n", + "plot_p_values(test_of_cells(controls, cd4, in_a), ax=left)\n", + "left.set_title(\"CD4 T cells, cells as replicates\")\n", + "plot_p_values(of_samples.table(cd4, \"B_vs_A\"), ax=right)\n", + "right.set_title(\"CD4 T cells, samples as replicates\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f67977c8", + "metadata": {}, + "source": [ + "Without a difference, p-values are spread evenly between 0 and 1, and each bin of the\n", + "histogram holds about as many genes as the dashed line. The test of the samples gives\n", + "that. The test of the cells gives p-values below 0.05 to more than a third of the\n", + "genes, every one of them a false positive.\n", + "\n", + "## More cells, more false discoveries\n", + "\n", + "The same two tests in every cell type, with the genes each calls at a false discovery\n", + "rate of 5% ({api}`adjust_p_values`, as Benjamini and Hochberg's method adjusts them):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "79dc75c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cell type cells calls, cells calls, samples\n", + "B cells 1,161 203 0\n", + "CD4 T cells 3,097 553 0\n", + "CD8 T cells 1,412 288 0\n", + "NK cells 1,114 153 0\n", + "Monocytes 2,533 442 0\n", + "Dendritic cells 191 6 0\n" + ] + } + ], + "source": [ + "print(f\"{'cell type':<16}{'cells':>7}{'calls, cells':>14}{'calls, samples':>16}\")\n", + "for group, n in zip(controls.groups[\"group_id\"], controls.n_cells.sum(axis=0)):\n", + " by_cells = np.sum(adjust_p_values(test_of_cells(controls, group, in_a)) < 0.05)\n", + " by_samples = np.sum(of_samples.table(group, \"B_vs_A\")[\"adjusted_p_value\"] < 0.05)\n", + " print(f\"{group:<16}{n:>7,}{by_cells:>14,}{by_samples:>16,}\")" + ] + }, + { + "cell_type": "markdown", + "id": "536fac72", + "metadata": {}, + "source": [ + "Every call is false. The test of the samples makes none, and the test of the cells\n", + "makes hundreds in every cell type with many cells, more the more cells it is given: the\n", + "dendritic cells, about 16 in each sample, have the fewest calls.\n", + "\n", + "## Why the test of the cells fails\n", + "\n", + "Take the gene of the CD4 T cells that the test of the cells finds most significant,\n", + "and draw the mean of every donor's cells, and the mean of each group's cells with the\n", + "95% confidence interval that the test of the cells gives it:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "83e56681", + "metadata": { + "figure_descriptions": [ + "The mean log-normalized value of gene_1915 in the CD4 T cells of each of the 12 donors, as grey dots, six in group A, from about 3.4 to 4.4, and six in group B, from about 3.4 to 3.8; beside each group, a red dot at the mean of all its cells, about 3.82 for group A and 3.57 for group B, with a 95% interval of about plus or minus 0.03." + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gene_1915: p-value 4e-27 testing cells, 0.02 testing samples\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAF0CAYAAADM21gFAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXbFJREFUeJzt3XdcU9f/P/BXwgYhWEUQwQE4ETe4WuuqW6HujRWtflrrrLNWbbWltVpXsVqtlloVxSqOOlu31lkHKg5ExAEKKoS9cn5/+CU/IwGSEGZez8eDx8N77rnnvm8SzJtzzzlXIoQQICIiIjIQ0pIOgIiIiKg4MfkhIiIig8Lkh4iIiAwKkx8iIiIyKEx+iIiIyKAw+SEiIiKDwuSHiIiIDAqTHyIiIjIoTH6IqFSoW7cuJk6cWGznc3BwwOzZs4vtfFQwdZ+B4v5ckGFg8kNUDqSlpWHnzp0YPHgw7OzsYGtrm2ddIQTWrl2Lli1bwt7eHnXr1sXnn3+OhISEQrU7bNgw2Nra5vqpW7euRteQkJCAlJQUjepqqkaNGpg6daraffHx8UhNTdXr+fKzZ88eDBw4ELVr14a9vT0aN26M/v37Y9euXcjKylLW8/LyUr5277zzDqpXrw5PT0+MHTsWhw4dKvA8mZmZaN26NWxtbTFjxox8686ePVvte/b2j6ura6GvXxPqPgNF8bkgMi7pAIio8CZNmoTY2FgMHDgQcrkcBw4cyLPuhAkTsG7dOvzwww/w8fFBREQExo8fj6NHj+Ls2bMwNzfXqd3k5GS88847+O+//1TKpVLN/sa6e/cuTExMNKqrqdLwxZmeno7Bgwfj4MGD+Pzzz/HFF1+gatWqePr0KbZu3YrBgwfjhx9+UPZuyOVyODo64uzZswBev64REREICQlBnz590K5dO/z555+wsbFRe7758+fj3r17Gl37vHnzMHPmTOV2WFgY2rRpo4wzh6bvIVFZweSHqBxYs2YNJBIJAGDHjh151rt9+zZ+/vlnTJgwAZMmTQLwundk8+bN8PT0REBAAKZNm6Z1uzmkUmm+vUP5yevLvKybMmUK9uzZg0OHDqFz587K8ipVqqBJkyYYMGAAbt26pXLMm6+jra0tqlWrhvfeew+9e/fGBx98AF9fX+zatSvXuc6ePYvFixdj48aNGDlyZIGxWVhYwMLCQrltbW0NADAzM9P5fSQqC5jOk8HKyMjA/PnzUbduXTg5OWHw4MGIiYlBhw4d4OPjk6t+SEgIPvjgAzg6OsLZ2RkDBw5EWFiYSp2ccSTXr19Ht27d4ODggGbNmmH79u1qY9CkTU3kJCgFOXPmDIQQKl/CANCiRQvY2tpiy5YtOrWrD+rGdmj7euZISEiAra0tEhISsHHjRuXtm169euWqW5TvVVRUFH755Rf0798/12ueo0WLFholKgDQvn17DB48GCEhIbh586bKvuTkZIwcORIjRozABx98oFF7+rJ7925069YNTk5OcHNzw6hRoxAZGalSR1+fdQA4fPgwunXrhpo1a8LV1RV9+/bFuXPn9HAlZCiY/JDB8vX1xdKlSzF79mycPXsWo0aNwpgxY/Dy5UskJSWp1F24cCEGDBiA9957D8eOHcOhQ4dgamqKli1bqvwHHh8fj7t372L+/Pn4+uuvcfbsWTRv3hyDBw/GlStXdGpTn3LGlhgb5+70NTY2RmhoqMr4E209efIErq6uyl6NuXPnQi6Xa3Ssuts02ryeb7KxsUFkZCRsbGwwbNgwREZGIjIyEkFBQSr1Hj16VKTv1aFDh5CdnY3evXtr9Bpoonv37gCAf/75R6V82rRpSEpKwo8//qi3c2li/vz56Nu3Lxo3bowDBw7gyJEj6Nixo8ptM31+1i9cuIAePXqgWbNm+Oeff3Ds2DF89NFHmDZtGrKzs/V9eVReCSIDdP78eQFA/PjjjyrlJ06cEABEp06dlGV37twRUqlUzJgxQ6VuVlaWqFevnujbt6+yzMzMTFSsWFEkJCQoy1JTU4Wtra0YO3asTm1qq1+/fiKvX+1///1XABBz585VKb9z544AIACI2NhYrdsVQogJEyaINWvWiFu3bonw8HCxZs0aUbFiRVG/fn0RHx9fYNz29vbCz89PpUzT1zMvMplMjBs3Tu2+4niv5syZIwCIU6dOFRhrjrp16wp3d/c89588eVIAUIln//79AoAIDg4WQggRHR0tAIhPP/1U4/MKIURoaKgAIL744guN6t+6dUtIJBIxZcqUPOto8/qp+wy8XfbNN98IqVQqMjMzNYqRSB32/JBB+vvvvwEAffv2VSlv164dKleurFK2Z88eKBQKDB06VKXcyMgIH3zwgbKtHB07dlQZv2Jubo569eohPDxc5zb1pVWrVujUqRNWrFiBffv2ITs7Gw8fPsRHH31U6Ftcq1atwrhx41C/fn24urpi3Lhx2LRpE8LCwrB06VKd29Xk9SzKtgvzXuX0ROhzwHBOW0IIAMCLFy/g5+eHDz/8EP3799fbeTSxd+9eCCHw0Ucf5VlH35/1unXrQqFQYNy4cbh+/brydSDSBgc8k0GKjY0F8HpMydveLnv69CmA11+UEokEQgjlf7ipqalIS0tDRkYGTE1NAQCOjo652pTJZHj27JnOberTrl27MGvWLIwYMQLJyckwNzfHmDFj4OTkhD179qBixYp6O1ePHj1QoUIFnDhxQuc2NHk9i7LtwrxXzs7OAIDHjx8XOta348n5nM6dOxepqakICAjQ2zk0FR0dDeD/X6c6+v6s9+vXD4sXL8bKlSuxYcMGvPPOO+jUqRMmT56MNm3aFPKKyFAw+SGDJJPJAABxcXGoVq2ayr7Y2FjY29srt3NmvZw4cQJOTk5q23vzP+68/sp/8y9UbdvUJ2trawQEBCAgIAApKSmwsLCARCKBh4cHWrduDSMjI72dSyKRwMTEBJmZmTq3ocnrWZRtF+a9yhnkfOTIEQwcOLAQkf5/OWN92rVrB+B1ApKUlIT69esr6+TEv27dOvzxxx/YsGFDrl5OfahUqRIAICYmJs/ZYUXxWZ8+fTqmT5+Ou3fv4uTJk1i9ejXatWuHM2fOoGXLllq1RYaJt73IIOV8cRw+fFil/Pr167l6FHIGmB47dizPReC0VRRt6sLS0hISiQRnzpzBjRs38Nlnn+m1/XPnzuHVq1fw8vLSa7uasrS0LFTiBRTuvapbty769++PTZs2ITQ0VG2dyMhIhISEaBTLzZs3sWnTJrz//vto0aIFAGDz5s2IjY1VDuqOjIzExYsXAbwe1B8ZGanXAddv6tq1KwAgODg4zzpF+VmvU6cOxowZgx07diA7OxtHjx7VuS0yLEx+yCB16NABHTp0wJw5c3Dy5EkoFArcuXMH8+bNQ7169VTqenp6Yty4cZg9ezbWrVunnL305MkTrF+/XmWROE0VRZua+vbbb3HgwAGkpaUhOzsbBw4cwMCBAzF69Gh8+OGHOrV5/fp1jB8/HteuXUNGRgYyMjJw5MgRDB06FA4ODpg+fbqer0Iz9erVw6VLl5CcnKxzG4V9r9atW4fGjRujY8eO2Lhxo/L4+Ph4rFmzBs2bN881Lfxtjx8/xk8//YR27drBxcUFW7duVe6zsrLKlUzkjGMyNTWFra2t3hePzOHp6YnRo0fD398fa9asQWJiIjIyMnDq1Cnlytr6/qx/++23WLZsGaKioiCEQFpaGjZv3gwAJZZkUxlU/GOsiUqH+Ph4MWLECGFubi5MTU1Fy5Ytxa1bt0SjRo1E9+7dVeoqFAqxZs0a0ahRIyGVSoW5ublwcnIS48ePF3fu3FHWMzMzE5MmTcp1rq5du4rGjRvr1KYmNmzYIGQymZDJZMLExEQAUG57e3ur1L19+7bw8fERNjY2wtTUVNSvX18EBAQIhUKhc7sZGRliw4YNwsvLS1hZWQkjIyNRuXJl4evrK6KiojS6hrxme2n6eqpz8eJFUb9+fWFkZCRkMpno2bOnTm0X9r1KS0sTy5cvF82bNxfGxsbC0tJS2NjYiObNm4sff/xRvHz5Ulm3bt26QiqVKl9nU1NTUalSJdG5c2exdu1akZ6eXuD5imu2lxBCZGdni6VLlwpXV1chkUiEtbW16NChg/j333+VdTR9/TSZ7RUVFSU+//xzUbNmTWFubi7Mzc2Fp6encqYbkSYkQnCoPBk2hUKBrKws5biDSpUqoU+fPti4caPa+tnZ2cjOzlY7TiEhIQGmpqYqq+YCrxegUygUyhV0tWlTExkZGXk+ysDExARWVla5yhUKBbKzs/PtFdC13fT09FyvQUHkcjlMTExUjtP19Xxbeno60tLSYGRkhAoVKhSq7cK+V0IIpKamwtLSUu3+xMRElVlilpaWatdlKugcCQkJMDMz0+p9UCgUkMvlMDc3V3nMiabS09NhYmKS7+y2/F4/dZ8BdWVvns/U1LRYF+Ok8oHJD9Ebzp49i7Zt22L9+vXw8/Mr6XCIiKgIMPkhg7VlyxYIIdCzZ09UqFABFy9exKhRo5CdnY1r166p7dUgIqKyjwOeyWB17NgRhw8fRp06dWBpaYkPPvgAjRo1wrFjx0pF4jNs2LA8Z8fk/Ny7d6+kwyQiKnPY80OE14utaTtGpaglJycXOE3bxsZGr6sHExEZAiY/REREZFD4JyMREREZlFLzeIvff/8dK1euxNChQ5WLYxXFMcDr6ZxPnz6FtbU1p0gSERGVA0IIJCYmwtHRscDhAKUi+QkLC8PcuXMhhEBUVFSRHZPj6dOn+T6Ij4iIiMqmR48e5fkcuRwlnvykpaVh0KBBWLZsGRYuXFhkx7wpZ/GyR48eKZeBJyIiorJLLpfD2dlZo8VPSzz5mTJlCjw9PdGvXz+NExldjnlTzq0uGxsbJj9ERETliCbDWUo0+dm5cyeOHDmCq1evFukx6enpSE9PV27nPFiPiIiIDE+JzfZ6+PAhxo8fj82bNyuftVMUxwCAv78/ZDKZ8ofjfYiIiAxXia3z89NPP2HWrFmoV6+esuzWrVuwtraGs7Mzzp8/DyMjo0IfA6jv+XF2dkZCQgJvexEREZUDcrkcMplMo+/2ErvtNWjQILRq1UqlbNiwYWjevDmmTp2qNonR5RgAMDMzg5mZmf6CJyIiojKrxJIfOzs72NnZqZRZWFigSpUqaNGihbJs0aJFuHHjBoKCgjQ+hoiIiCgvpX6F58jISNy4caOkwyAiIqJyosSnur9py5Ytuebnf/nll0hKStLqGDJcCoUCERERSExMhLW1NVxcXPjgTyIiUlGqkp8GDRrkKqtRo4bWx5BhCg0NRUhICBISEpRlMpkMPj4+8PDwKMHIiIioNOGfxFQuhIaGIjAwUCXxAYCEhAQEBgYiNDS0hCIjIqLShskPlXkKhQIhISH51tm9ezcUCkXxBESUh/T0dDx58gQpKSlFdo7ExETExsYWWftlkVwuV3lN3t4mw8Pkh8q8iIiIXD0+b4uPj0dEREQxRUSFlZSUhMePH+PVq1e59mVmZuLx48eIiYkpgch09+mnn6JixYpo2bIl/vrrryI7T0BAAHr37l1k7esiMTERL168KLHzL168GAMGDMhzmwwPkx8q8xITE/Vaj0remjVr4OzsjDZt2uTat379ejg7O5ep5S1u3ryJ1atXIywsDI8fPza4L94VK1bAz8+vpMMgUmLyQ2WeprP9OCtQdwqFAuHh4bhy5QrCw8OL5RainZ0dnj9/jrNnz6qUr1+/XmWV97fjjIuLUxtfcnIyHj9+jMePH+fZU5iQkKDsocjKytIqYc7MzMTz58+RnZ2tUi6Xy/Hff//B1NQURkZGePz4sdrjNYkvLykpKQXeSssrPkC769a0nZSUlAJ75+RyOTIzM/Otk0MIked7C+T/3mtKm3iobGPyQ2Wei4sLZDJZvnVsbW3h4uJSTBGVL6Ghofjmm2+wZs0abN68GWvWrME333xT5IPITU1NMXz4cGzYsEFZdvXqVdy7d09tz8ny5cthb2+P2rVrw8bGBn5+firLZAQHB6NVq1Zo1aoVnJycUKNGjVxjxebPnw9vb28MGTIEDg4OqFy5Mtq0aYPo6Og848zOzsbnn38OW1tbuLm54Z133sG3336r3L9+/XpMmTIFGRkZyvO/+bgdbeJ7W1ZWFsaOHQuZTAZHR0e0aNECYWFhWsWn6XVr007//v3h4OCALl26qI37+PHjqF27NqpVqwY7OzsMGDAAz58/z/M6ly9fDgcHB9SsWROVK1fGkiVLcu3P770viLbxUNnH5IfKPKlUCh8fn3zreHt7c70fHZT0LDo/Pz9s27ZN+UW2bt06DBkyBJaWlir11q1bh+XLl+PYsWN49eoVIiMjcefOHcycOVNZZ9SoUcqelcTERHz33XcYPnw4Hj16pNLWmTNn8P777yM2NhaxsbHIyMjAggUL8owxICAAv/32G06ePAm5XI6dO3di4cKFCA4OBgBMnToVv/32G8zMzJTnV/e4HU3je9OKFSuwb98+XL16FfHx8fjyyy/xxx9/aBWfptetTTtt2rRBfHw8rl+/DgCwsbFB5cqVVa7V19cXcrkccXFxGDp0KC5fvqz2GlevXo0vv/wSGzZsQGJiIiIjI/Hs2TPlfk3e+4JoEw+VD/w2oHLBw8MDvr6+uXqAbG1t4evry3V+dFAaZtE1atQI9erVw/bt25GWloYtW7aoHTvyww8/YPz48ahcuTKio6ORkZGBMWPGYPv27bnqZmVlITo6Gu+99x4cHR1x/PjxXOccP348JBIJbGxsMGjQIFy8eDHPGFetWoXPPvsMzZs3BwB06tQJI0aMwMqVK3W65oLie9PPP/+MSZMmwd3dHcDrJL9Hjx46xVfQdWvajqurK6ZOnaryx8bEiROxfv165faLFy9Qt25dSCQSGBsb48MPP0T37t3VXuOSJUswYcIE9OzZUxnbDz/8oNyvzXufF23iofKhVC1ySFQYHh4ecHd35wrPeqLNLDo3N7cii8PPzw8bNmyAqakpnJyc4OXlhaNHjyr3p6en4969e1i6dCl++uknlWPNzMyQmpoKCwsLhIeHY/z48Th58iRsbGxgbm6O2NjYXGNwnJ2dVbatra0hl8vVxpaZmYkHDx6gSZMmKuXNmjXD7t27tbpOTeN789yRkZG5EvvGjRvj77//1jq+/K5bm3Y0+SwsWLAAI0aMwMaNG9GxY0f4+PioPS4tLQ0PHjyAl5eX2nY0fe/1FQ+VH/xWoHJFKpXCzc0NTZs2hZubGxOfQigts+iGDBmC//77DwsXLsTo0aNz7ZdIJJBIJFi2bJnyttGbPzlffqNHj4a9vT1iY2MRFxeHx48fo06dOmoH7mrKyMgIxsbGyMjIUClPT09Xe2srP9rGl9e539zWV3zatGNsXPDf1NOmTcPDhw8xZMgQXLlyBR4eHti8ebPa80okErVjpADN33t9xUPlB78ZiEit0jKLTiaTYdSoUUhLS8OIESNy7Tc1NUWzZs3U3qJ785bc9evXMWDAAOWt0ejoaNy9e7dQsUmlUjRs2BAnT55UKT9x4gQaN26sVVvaxieVSuHu7o7Tp0+rlJ86dUrv8enzOoUQEELA3t4eI0aMwObNmzFq1CgEBgbmqmtiYoJmzZrh8OHDKuU576um772+4qHyg7e9iEitnFl0+d36Kq5ZdKtXr853/3fffYcePXpgypQpGDlyJBQKBU6cOIGLFy9i69atAIAWLVrgp59+gqurKxITE/H555/rZVrz/PnzMWDAADRo0ADt27fH7t27sXfv3lxJSUF0iW/27NkYMWIEGjRogNatW2PTpk24cOECPD099R6fvtpJTExE586dMW3aNDRp0gSxsbE4duxYnpMWFi1aBG9vb1SvXh39+/fHs2fP8M033yhvfWry3uszHiof2PNDRGqV5Cw6a2trVK1aNc/9NjY2Kvs7d+6MU6dOISoqCgMHDsT48eMRExODVatWKets3LgRlSpVQt++fTFx4kT0798fPXv2hI2NjbKOra2tyqwkAKhQoUK+sfTu3Rt//PEHtmzZgp49e+LIkSPYv38/WrZsqaxjYWEBJyenfK9Zk/je1r9/f6xcuRKrVq3CkCFDIJfLsWjRIlSpUkWr+DS5bl3beZuNjQ1+/vln7Nq1C97e3pg6dSqGDRuGhQsXqq3frVs3HDp0CBcuXICPjw8WL16sMgtNk/deJpPBzs5O7ba28VD5IBFCiJIOorjJ5XLlX7T5/cdCRK+nu4eEhKj0ANna2sLb25uz6Iio1NDmu523vYgoX5xFR0TlDZMfIipQziw6IqLygH+6ERERkUFh8kNEREQGhckPERERGRQmP0RERGRQmPwQERGRQeFsLyJSkfn8ObJiY7U+ztjODiZvLK5HRFRaMfkhIhXx27YjLiBA6+Mqf/op7D6bUAQRERHpF5MfIlJhO2ggKnTsoFIm0tLwcNhwAECNzX9AYm6e6zjjNx4fQLnt3LkTq1evxrNnz5TPq6Li8eGHH6Jfv34YPny42u3yorxcV3FcB8f8EJEKkypVYOHurvJjVqeOcr8iORnm9erlqqPPW16//fYbGjZsiJEjR+bad/jwYTRs2BCdO3fW2/mK2pMnTzB48GAMHz4cW7duxfvvv1/SIRWrwYMHY/fu3SV2/nv37iEuLi7P7cJIS0vD999/jw8++ABeXl6YOnUqXr58qVJn7ty5aNiwocrP4MGDVeqcOnUKXbp0Qbdu3XDhwgWVfU+ePEGHDh2QlJSUbyy6XFefPn00egBscdLn+5MX9vwQUb7khw/j2aJvlNuPPh4HYwcH2M+ZDZsuXYrknHFxcYiKikJ4eDi+/vpr1KxZU7kvICAAMTExiI+PL5JzF4Vbt24BAEaNGlWygZSQ8PBwvHr1qqTDKBL9+/fHvXv3sGTJElSsWBFLly5Fp06dcOHCBZiYmAAAHj9+jFq1asHf3195nIWFhfLfCQkJ6NOnD1asWIGUlBT06tULDx48gJWVFQDgk08+wZAhQ1ChQoV8YwkJCUHFihW1iv/u3bt48eKFVseUB+z5IaI8yQ8fxpNJk5H1/LlKedazZ3gyaTLkhw8X2bltbGzQs2dPbNy4UVkWExODQ4cOYciQIbnqX716FcOGDUOLFi3Qp08fBAcHq+zfunWr8q/u1q1bY9y4cXj06JFKne+//x6ffvopAgMD0atXL7z77rv4+uuvkZmZmW+shw8fRp8+fdCsWTP069cP586dU+5bvXo1xowZg6ysLOX5MzIycrWhSXzqBAUFoUOHDmjfvj3mzp2LgIAADBs2LNc1rV+/Hu3bt0e7du0AANnZ2Vi6dCnatWsHT09PTJw4Ec/fep+9vLxw9OhRlbLBgwfj119/VW537doVv/32G6ZNm4b33nsPXbp0waFDh/KN+cyZMxgwYAC8vLwwZMgQXLx4Md/6OU+Sb9myJSZPnpwrkdq8eTO6desGLy8vjBw5Erdv3863vcLGkyM8PBx//fUXVq9ejd69e+Pdd9/F1q1bER4ejm3btqnUlclkKj0/rq6uyn2nT5+Gq6srRo4cifHjx6Ny5crK3p/g4GDEx8dj7NixBcYzffp0HDhwQLndtWtX/P7775g9ezbatWuHrl27qvTAjRw5Eg8ePMC3336rjCs7OxtAwa9p165dERgYiKlTp8LLywvz58+Hv7+/2gR/1KhR+Oab139AjR07Fg0bNoSHhwc6d+4Mf39/tb8PRU4YoISEBAFAJCQklHQoRKWWIitL3H2/vbhVt576n3r1xd332wtFVpbez/3DDz+IatWqib/++ktUr15dZGdnCyGE8Pf3Fz169BD+/v6iWrVqyvpnz54Vtra24ocffhDnzp0TW7ZsEQ4ODmLNmjXKOi9evBChoaEiNDRUnD59Wvj6+gpnZ2eRkpKirDNp0iRhYmIi+vfvL06cOCF27dolqlSpIr755ps8Yz1y5IgwMTERixYtEmfOnBGff/65MDU1FVevXhVCCPHs2TMREBAgTE1NledXKBS52tEkvrft3r1bmJiYiKVLl4rTp0+LTz75RJiYmIiWLVvmuqY+ffqI48ePi7CwMCGEEBMnThSOjo5i+/bt4p9//hHvv/++cHd3F5mZmcpjraysxK5du1TO2bx5c+Hv76/crlGjhjAxMREzZ84UZ86cEfPnzxcmJibi3LlzKsds3LhRCCHEo0ePhIWFhfj222/FxYsXxY4dO0Tbtm2FXC5Xe41z5swRtra2IiAgQJw9e1asWLFCfPzxx8r98+bNE7Vr1xbbtm0T58+fF1999ZWwsrIS9+/fV9Zxd3cXy5YtU7utbTxvunTpkgAgrl27plLu4OAgfH19ldu+vr7CyclJtGjRQnTp0kV88803Ku9rcHCweP/995XbXl5eYt++feLVq1eiZs2a4vbt2wXGou46a9SoISwtLYW/v784d+6c8Pf3F1KpVFy/fl0IIURERISoVauWmDNnjvKzJ4Rmr2mNGjWEubm5+Prrr8XFixfFkydPxPHjx4WRkZGIiYlR1ouOjhZGRkbi6NGjQgghHjx4IEJDQ8X169fF3r17RePGjYWfn1++16Epbb7bmfwQkVpJ587nnfi88ZN07rzez52T/GRlZYlq1aqJQ4cOCSGEqF27tvjzzz9zJT/vvfeemDdvnkobGzduFDVr1szzHAqFQlSvXl3s2LFDWTZp0iTh5OQkMjIylGVffvmlaNOmTZ7ttG7dWowZM0alrHv37uLDDz9Ubu/du1eYmZkVcNUFx/c2T09PMWHCBJWyFi1a5Ep+KleurPJl+/jxY2FsbCz27dunLHvx4oWwsrISgYGByjJNk59u3bqp1BkwYIDo1auXcjs8PFy8evVKCCHEgQMHhI2NjUoCmJWVpUxw3/TkyRNhbGwsgoKCVMpz3p+YmBhhYmIi/vvvP5X93t7eYvLkycrt/JIfbeJ5W0pKirC3txejRo1SJo2bNm0SAESHDh2U9SZPniy+//57cfbsWREUFCTq1KkjWrVqJbL+7w+HO3fuCBsbG/H8+XPx+PFjYWVlJR4+fCj8/PzEokWLxKVLl0S3bt3EBx98IE6cOJFnPOqSnzcTRSGE8PDwEIsXL1Zu161bV6xatUq5relrWqNGDTFs2DCVOjmf2eXLlyvLli1bJpycnPJ8PS9duiSMjIxEenp6ntehKW2+2znmh4jU0nStH13WBNKUkZERRo0ahV9//RWmpqaIj49H7969sXTpUmWd7OxsnD17Fo8ePcLu3bshXv9Rh6SkJDx8+BDp6ekwMzNDamoqAgICcOTIEcTExCA7OxuxsbF48OCByjnd3d2VYzUAwNHRMdftoBxCCFy9ehWTJk1SKf/ggw+wcuVKra5V0/jePHdoaChmzZqlUt6+fXucOnVKpczDw0NljEloaCiysrLQqVMnZdk777yD5s2b48qVK2oHmuenQwfV2YEdO3bEokWLlNtv3uJp0aIFzMzM0Lt3bwwfPhzt27eHg4OD2nbPnz+PrKws9OrVS6U85/05d+4cMjMz8dFHHwGA8r2Pjo4u8FalLvG8zcLCAn/++SdGjx6NKlWqwMrKCtWrV0fnzp1VbuX88MMPMDZ+/XXbunVrNG/eHHXq1MGuXbvQv39/1KlTB+PGjUPt2rUhhMD06dMRERGBixcvYunSpahbty6++uorWFpawtvbGxERERqP7WnatKnKdn6fZ0C719TLy0tlWyKRYMiQIdi8ebPyd2Lz5s0YOnQopNLXo2wePHiAH3/8EdeuXcOrV6+QmZmJ7OxsREVFwc3NTaNr0gcmP0SklqZT14t6ivvo0aPh7u6OpKQkjBw5UiUxAYCMjAxkZ2dj0qRJameA5dT/5JNPcPnyZcybNw81a9aEubk5Bg4ciLS0NJX6OV9SbxJCqI0tKysL6enpKokFAFhaWiI5OVmr69Q0vhyZmZlqz/32dk48b0pOToaxsTFMTU0LHbe6c+bXTuXKlREaGorAwEBs3LgRfn5+6NKlC7Zs2ZKrnbS0NBgZGcFczdIKAJCSkgKpVIqNGzfm+lwUNDhYl3jUadu2Le7cuYOYmBhkZGSgevXqaNWqlUrC9/Znys3NDY6Ojrhx4wb69+8PAFi8eDFmzpwJqVQKCwsLNGnSBIGBgbh27RpsbW0xbtw4AMCqVatw+vRp9O7dW6Pr0+bzDGj3mr79uQKA4cOH4/vvv8fdu3cBAJcuXcKGDRsAAElJSWjXrh3ef/99zJs3D3Z2dnj+/Dm6dOmS5+e8qDD5ISK1LFs0h7GDA7KePQPU/WcpkcDY3h6WLZoXaRwuLi5o3bo19u/fjx9++CHXfgsLCzg5OeHx48do2LBhnu3s3bsXv/zyC/r27QsASE9Px9OnTwsVm4mJCapXr46bN2+iT58+yvIbN25o/VestvGZmprC2dkZYWFh6N69u7I8LCyswHO5ubkhKysLd+7cQf369QEACoUCt27dUunFqVChQq4kRl1MObPZcty8eVPly/9t9vb2mDFjBmbMmIGYmBjUr18fW7duxejRo1Xq1a1bF9nZ2bh+/XquHgwAqFOnDhQKBZKTk/Huu+8WeN2FjSc/Ob1FT548waVLl/DJJ5/kWTctLQ1xcXGwsbFRKa9UqRIAYPbs2ejWrRtatmyJgwcPqiQd1tbWSElJ0eby8mVkZKSSDBX2NW3YsCEaNWqELVu2QAiBRo0awcPDA8DrSQlPnz5VSawKGhxfVDjbi4jUkhgZwX7O7P/beHvn6wL7ObMhMTIq8liCgoJw69YtNGjQQO3+KVOmYPXq1Sr/kd66dQvff/+9ctvOzg5nzpwB8PqLfsaMGUhISCh0bOPHj8eqVasQHh4OAPjvv/8QGBiI8ePHa9WOLvGNHj0aK1euVM4KO336tEbr6TRu3BitW7fGzJkzkZ6eDgBYunQpXrx4gREjRijrNW3aFNu3b1fOAFq+fDmio6NztffHH3/gv//+A/D6dV+/fn2es5OOHDmCrVu3IisrC8Dr3jOFQqG2p6ZZs2Zo06YNJk6ciNj/u70aExODtWvXAgCaN2+Odu3a4bPPPkNUVBSA16/d7t27NV5XqKB4Vq9ejTZt2uR5fGBgoPL1j4+Px+jRo+Hh4aFcxycpKQlff/21MolMTU3Fp59+CqlUin79+uVq79q1awgODlbeNnR3d8ft27fx+PFjxMbG4vLly2jcuLFG16YJBwcHREZGKrf18ZoOHz4cmzdvxpYtW1QWKrSzs4NCocC///4LAHj+/DnmzJmjt2vRBpMfIsqTTZcuqLZiOYztVBcwNLa3R7UVy4tsnZ+3ValSRdlDoc6UKVMwd+5cDBo0CPb29qhSpQoGDx6s8iWxatUqBAYGolq1aqhUqRLCwsJQr169Qsc2ZcoU9OjRA+7u7qhRowbatGmDcePGqSQRmtAlvhkzZqBJkyZwdXVF9erVMWrUKPTs2TPX7Qp1Nm3ahOjoaFSqVAn29vb48ccfsWXLFlStWlVZZ/Hixbh+/TqqVq2KqlWr4t9//0XdunVztfXhhx/C29sb1atXR+PGjeHt7Q0/Pz+153V3d8e+fftQsWJF1K5dG/Xq1cOwYcOUt3/etnPnTlhbW6NatWqoWbMmPD09VdZ9+vPPP+Hq6go3NzfUrFkTtra2+P333zVOEAqK58aNGzDKJ8F3c3NDx44d4eLigmrVqsHMzAyHDh1S3lK0sLCAkZERatasiVq1aqFSpUq4cuUKjhw5gho1aqi0lZ2djbFjx2LVqlXK5MvZ2RkzZsyAu7s76tSpg48//lgvn9scEydOxC+//ILatWsrp7oX9jUdMmQIIiIiEBERgaFDhyrL69atiy+++AIffPABXFxc4OrqCk9PT71di1a0Hk5dDnC2F5F2suRy5eyuxBMnimR6+5vi4uLynd4bGxurdn9mZqYIDw8XL168UHtcRkaGCA8PF7GxsUIIIe7fvy+eP3+u3B8dHS0ePnyocszLly/F3bt3C4w5Pj5e3LlzRyQlJeXaJ5fLxc2bNwtso6D48vL06VPx9OlTIYQQI0eOFAMHDlTuU3dNb3ry5IkIDw/PczaOQqEQkZGRyut6Mz4hXs/6WbdunRDi9bTxN/flJzU1VYSHh+c7lf9NL168EA8ePFC7TIAQr1/ju3fvitTU1Fz77t27J+Li4vLczi8eFxcXcf58wTMaHzx4oJzRpo5CoRAPHjzIdwp9WlqacimCt718+TJXzG97+7ru3LkjXr58qVInMjJSREdHq5SlpqaKe/fuKae658jvNVXX9ptu376d5+9wQkKCuHPnjkhOThaZmZkiNDRUpKWl5XkdmtLmu10iRD4jn8opuVwOmUyGhISEXPdciQyduqe6a/psLz7VvXjFxMTg2LFjGDx4MCQSCU6ePIkuXbogMDAQgwYNKpYYatasiblz52LMmDHFcr7iJITAvXv3UOeNx7tQ6aXNdzsHPBORioKe6p6TBL2NT3UvfhUrVsT+/fsxYcIEmJubIz4+Hl9++WWxJT7lnUQiYeJTTrHnhz0/RCrU9fxogj0/JSclJQXPnz+Hs7NzvuNTisLdu3dhZ2en9TOliPSNPT9EpDOTKlWYxJQxlpaWKoOAixN7Rqgs4mwvIiIiMihMfoiIiMigMPkhIiIig8Lkh4iIiAwKkx8iIiIyKEx+iIiIyKAw+SEiIiKDUmqSn/3798PHxwe//vprvvXS0tLw66+/ws/PD+PGjcOmTZuUTxwmIiIiKkipWOTw0aNHGD9+PNLT0/NdqEuhUKBBgwbo1KkT2rZti5SUFHzxxRfYvn079uzZA4lEUnxBExERUZmkc/KzY8cO/Prrr4iIiMCdO3cAAP7+/hgzZgzs7Ow0bic7OxvDhg3D3LlzsXr16nzrSiQSnD17Fg4ODsqyFi1aoHXr1rh06RI8PT11uxgiIiIyGDrd9tqwYQPGjx8PT09P3L17V1lubW0Nf39/rdpasGABKlasiI8//rjAuhKJRCXxAYBq1aoBABISErQ6LxERERkmnZKfJUuWYMeOHfj6669Vynv16oWgoCCN2zl+/Dg2btyI9evX6xIGAGD58uWoWLEivLy88qyTnp4OuVyu8kNERESGSafkJyIiAi1btgQAlXE2FStWxIsXLzRqIy4uDsOHD8f69eu1uk32pq1bt2L58uVYt25dvk9w9ff3h0wmU/44OzvrdD4iIiIq+3RKfhwdHXHr1i0AqsnPwYMH4erqqlEb27dvR2JiItasWQMfHx/4+PjgwYMH2Lt3L3x8fKBQKPI9fufOnRg1ahTWrl2Lfv365Vt39uzZSEhIUP48evRIoxiJiIio/NFpwPO4ceMwevRorFixAhKJBHfu3MHBgwcxf/58LFy4UKM2unfvDkdHR5Wya9euoUGDBhg1alS+M7dCQkIwZMgQrFq1CmPGjCnwXGZmZjAzM9MoLiIiIirfdEp+ZsyYAblcjh49eiA7Oxv16tWDmZkZPv/8c0yYMEGjNmrVqoVatWqplC1YsACurq7w8fFRlgUEBODu3btYsWIFAGDPnj0YPHgwVq1apdEgaSIiIqI36ZT8SCQSfPPNN/jiiy9w8+ZN5fo71tbW+o4PV65cwblz5wAAcrkcAwYMgEwmw/79+7F//35lvQkTJqBz5856Pz8RERGVL4Va5NDS0lKva+ssW7YMlStXVimbMGEChg4dCgAwNzfHtm3b1B5bu3ZtvcVBRERE5ZdECCG0PWj8+PH57l+zZo3OARUHuVwOmUyGhISEfGeJERERUdmgzXe7Tj0/cXFxKtsKhQL37t3DjRs30KNHD12aJCIiIioWOiU/O3bsUFu+YMECxMfHFyYeIiIioiKl16e6T5o0CTt37tRnk0RERER6pdfkJzY2FomJifpskoiIiEivdLrttXz58lxlr169wh9//MExP0RERFSq6ZT8qHsQacWKFTFo0CDMnj270EERERERFRWdkp8bN27oOw4iIiKiYqHXMT9EREREpZ3GPT+TJ0/WuFF1Y4KIiIiISgONk5/w8PCijIOIiIioWGic/Ozbt68o4yAiIiIqFhzzQ0RERAZF56e6Z2dn486dO4iKikJWVpbKvl69ehU6MCIiIqKioFPyEx4ejr59++LmzZtQKBQwMjJCdnY2AMDMzAxpaWl6DZKIiIhIX3S67TV58mS0bt1a+SiLtLQ0nD9/Ho0aNcKSJUv0GiARERGRPkmEEELbgypVqoRbt27B3t4eEokEGRkZMDExwbVr19C3b1/cv3+/KGLVG7lcDplMhoSEBNjY2JR0OERERFRI2ny369Tz8/LlS9jb2wMAKleujGfPngEA3Nzc8PjxY12aJCIiIioWhZ7t5enpicWLFyMyMhLfffcd3Nzc9BEXERERUZHQacCzn5+f8t/+/v7o2bMnVq1aBZlMhu3bt+stOCIiIiJ902nMz9sUCgWioqJQtWpVmJmZ6SOuIsUxP0REROVLkY/56devH3bt2oWMjIzXjUilqFmzZplIfIiIiMiw6ZT8GBkZYejQoXBwcMC4ceNw6tQp6KEDiYiIiKjI6ZT8bN++Hc+ePcOPP/6IiIgItG/fHrVq1cIXX3yBsLAwfcdIREREpDd6GfMTHR2NoKAg/PLLL7h9+3ap7wXimB8iIqLypcjH/LwpLS0Np0+fxokTJxAREQEHB4fCNklERERUZHRKfhQKBf7++2989NFHsLe3h5+fH2QyGfbu3ctFDomIiKhU02mdHycnJ8TFxaFLly5Yu3YtvL29YWFhoe/YiIiIiPROp+Rn7ty5GDhwICpXrqzveIiIiIiKlE7JzyeffKLvOIiIiIiKRaEHPBMRERGVJUx+iIiIyKAw+SEiIiKDwuSHiIiIDIrGA57Hjx+vcaNr1qzRKRgiIiKioqZx8hMfH6/8d3JyMvbt2wcHBwc0adIEAHD16lXExMSgV69e+o6RiIiISG80Tn6CgoKU/x43bhwmTJiAH3/8ESYmJgCAzMxMTJ06FZmZmfqPkoiIiEhPdHqwqaOjI0JDQ1GpUiWV8hcvXqBRo0Z48uSJ3gIsCnywKRERUflS5A82lcvlap/h9ejRI8jlcl2aJCIiIioWOiU/AwYMwIABA7Bz5048evQIUVFR2LlzJwYOHIiBAwfqO0YiIiIivdHp8RYBAQGYMWMGhgwZgoyMDACAqakpPv74YyxevFivARIRERHpk05jfnIkJSXh/v37AABXV1dUqFBBb4EVJY75ISIiKl+0+W7XqecnR4UKFdC4cePCNEFERERUrHRe4XnHjh3o3r076tatqyzz9/dHbGysXgIjIiIiKgo6JT8bNmzA+PHj4enpibt37yrLra2t4e/vr7fgiIiIiPRNpzE/DRo0wOrVq9G+fXtIJBLkNBEZGYk2bdrg6dOneg9Unzjmh4iIqHwp8nV+IiIi0LJlSwCARCJRllesWBEvXrzQpUkiIiKiYqFT8uPo6Ihbt24BUE1+Dh48CFdXV50CuXDhAiZPnoxdu3YVWPfZs2dYtmwZZs2ahc2bNyMrK0uncxIREZHh0Sn5GTduHEaPHo3jx49DIpHgzp07WLFiBcaNG4f//e9/Wrf36tUrDBkyBIGBgThx4kS+de/duwcPDw8cPHgQJiYmmD9/Prp164bs7GxdLoWIiIgMjE5T3WfMmAG5XI4ePXogOzsb9erVg5mZGT7//HNMmDBB6/b8/PwwatQo/PnnnwXWnTlzJurVq4cDBw5AKpVi7NixcHNzw5YtWzBixAhdLoeIiIgMiE49PxKJBN988w3i4uJw4cIFnDt3DrGxsVi0aJHKbTBNBAQE4Pnz55gzZ06BdTMzM7F//34MHToUUunr0KtXr4727dsjJCREl0shIiIiA6NT8tO5c2f4+/vDwsICnp6eaNmyJaytrZX7NHX9+nV8/fXX2LRpE4yMjAqsHxUVhfT09FzjilxdXXHv3r08j0tPT4dcLlf5ISIiIsOkU/Lzzz//4Pvvv8fAgQORnJyca58mkpOTMWjQICxZsgS1atXS6JiUlBQAUCZaOWxsbJT71PH394dMJlP+ODs7a3Q+IiIiKn90XuH5/PnzuH79Otq2bYuHDx9qffzmzZsRHR2Ny5cvY/LkyZg8eTKePHmCEydOYPLkyVAoFLmOyUl64uPjVcpfvXqVKyF60+zZs5GQkKD8efTokdbxEhERUfmgc/JTt25dXLhwAY6OjvD09MTJkye1Or5ly5ZYsGABatasqfwxNTWFjY0NatasqXbsUPXq1VGhQgXcvn1bpfz27dto0KBBnucyMzODjY2Nyg8REREZpkI92FQmk2Hfvn2YNWsWOnfujJUrV2p8bOPGjXM9FPW3335D06ZNMXnyZGXZtm3bEBkZiZkzZ0IqlaJfv3747bffMH78eJibm+P69es4c+YMdu7cWZhLISIiIgOhc8+PsgGpFIsXL8Zvv/2GqVOn6iMmFUeOHMGmTZuU29999x1SU1Ph6emJkSNHomPHjhg+fDi8vb31fm4iIiIqf3Tq+Tl27FiusqFDh8Ld3R3//vuvzsFMnz4dTk5OKmWDBw9G+/btldsODg64evUqDhw4gGfPnuHjjz/Gu+++q/M5iYiIyLDo9GDTso4PNiUiIipftPlu17jnJ2cczvLly1XG5KizfPlyTZslIiIiKlYaJz/h4eFq/01ERERUlvC2F297lSsKhQIRERFITEyEtbU1XFxclI9CISKi8qtIbnsRlXahoaEICQlBQkKCskwmk8HHxwceHh4lGBkREZUmWo/50QTH/FBxCw0NRWBgYK7yhIQEBAYGwtfXlwkQEREB0HHMD1FpolAoEBISkm+d3bt3w93dnbfAiIhI8+Rn3759RRkHkc4iIiJUbnWpEx8fj4iICLi5uRVTVEREVFrxz2Aq8xITE/Vaj4iIyjedBzxnZ2fjzp07iIqKQlZWlsq+Xr16FTowIk1ZW1vrtR4REZVvOiU/4eHh6Nu3L27evAmFQgEjIyNkZ2cDeP0E9bS0NL0GSZQfFxcX5fTGvNja2sLFxaUYoyIiotJKp9tekydPRuvWrZW3EdLS0nD+/Hk0atQIS5Ys0WuARAWRSqXw8fHJt463tzcHOxMREQAdFzmsVKkSbt26BXt7e0gkEmRkZMDExATXrl1D3759cf/+/aKIVW+4yGH5pG6dH1tbW3h7e3OaOxFROafNd7tOyY9EIkHOYXZ2drhy5QqcnJyQnJyMd955B+np6bpFXkyY/JRfXOGZiMgwFesKz56enli8eDGmTp2KX3/9lVOJqURJpVJ+BomIKF86JT9+fn7Kf/v7+6Nnz55YtWoVZDIZtm/frrfgiIiIiPRNLw82VSgUiIqKQtWqVWFmZqaPuIoUb3sRERGVL8X+YFOpVIqaNWvqoykiIiKiIqVz8nP37l38+++/ePXqVa592jwElYiIiKg46ZT8/Pzzz5gwYQKqVq0KW1vbXPuZ/BAREVFppVPys3DhQmzZsgWDBg3SdzxERERERUqnBVASEhL4/C4iIiIqk3RKfjp16oRDhw7pOxYiIiKiIqfTba+ffvoJLVu2xJ49e+Dq6gqJRKKyf+7cuXoJjoiIiEjfdEp+Vq5ciZiYGJw7dw63b9/OtZ/JDxEREZVWOiU/v/76K/bs2YPevXvrOx4iIiKiIqXTmB9jY2N07NhR37EQERERFTmdkp/WrVtjz549+o6FqNAUCgXCw8Nx5coVhIeHQ6FQlHRIRERUyuh02+udd97ByJEjERISAjc3t1wDnhctWqSX4Ii0ERoaipCQECQkJCjLZDIZfHx84OHhUYKRERFRaaLTg03bt2+f7/7jx4/rGE7x4INNy5/Q0FAEBgbmud/X15cJEBFROVbkDzYt7ckNGRaFQoGQkJB86+zevRvu7u6QSnW600tEROWITt8Epqam+o6DSGcREREqt7rUiY+PR0RERDFFREREpZlOyU/FihURGxur71iIdJKYmKjXekREVL7plPz4+flh/vz5yMjI0Hc8RFqztrbWaz0iIirfdBrz888//+DChQsICgqCm5tbrttgp0+f1ktwRJpwcXFRDnLLi62tLVxcXIoxKiIiKq10Sn66d++O7t276zsWIp1IpVL4+PjkO9vL29ubg52JiAiAjlPdyzpOdS+f1K3zY2trC29vb05zJyIq54p8qjtRaeTh4QF3d3dEREQgMTER1tbWcHFxKbYen8znz5Glw0QAYzs7mFSpUgQRERGROjonP8HBwfj+++8RFhYGAKhfvz5mzpyJAQMG6C04Im1JpVK4ubmVyLnjt21HXECA1sdV/vRT2H02oQgiIiIidXRKflavXo1p06bBz88PkydPhkQiwb///ouRI0ciNjYWn3zyib7jJCr1bAcNRIWOHVTKRFoaHg4bDgCosfkPSMzNcx1nbGdXLPEREdFrOo35cXV1xffff4/+/furlAcHB2PWrFm4f/++3gIsChzzQ8VFkZKCO82aAwDq/ncZUkvLEo6IiKh80ua7XafBEI8ePULXrl1zlXft2hWPHj3SpUkiIiKiYqFT8lOjRg0cOHAgV/n+/ftRo0aNQgdFVF6I7Gzlv1MuXVLZJiKikqHTmJ8ZM2bA19cXR48ehZeXFwDg/PnzCAwMxE8//aTXAInKKvnhw3i26Bvl9qOPx8HYwQH2c2bDpkuXEoyMqPRRKBQlNlOTDI/O6/zs2bMHixcvxq1btwAADRo0wIwZM9CnTx+9BlgUOOaHipr88GE8mTQZePvXSyIBAFRbsZwJENH/UbdGl0wmg4+PD9foIo1p893ORQ6Z/JCeiexshHfqjKyYGPUVJBIY29vD7Z+/ITEyKt7giEqZ0NDQfFdn9/X1ZQJEGinyAc9ElLeUS5fzTnwAQAhkxcQg5dLl4guKqBRSKBQICQnJt87u3buhUCiKJyAyGDqN+YmJicHs2bNx5swZvHz5Mtf+uLg4jduKjo7G8ePHkZSUBHd3d7Rp00aj8x89ehSvXr1C9erV0bVr11wPVyUqKZqu8qzLatBE5UlERES+DyQGgPj4eERERJTY4qVUPumU/IwZMwbR0dGYMmUKKlasqPPJv/vuO2zcuBGtWrWCsbEx5s6di8aNG2PPnj0wV7MYHAD8+eefGD58ODp27IiaNWvi559/xsSJE3Hq1Ck4OTnpHAuRvmi6aCEXNyRDl5iYqNd6RJrSKfk5ceIEwsLCCp1stG3bFtOnT4fR/417ePjwIWrVqoV9+/blWkAxx4IFCzBs2DCsX78eAJCWlgZXV1esXbsWCxcuLFQ8RPpg2aI5jB0ckPXsWe4Bz4ByzI9li+bFHxxRKWJtba3XekSa0mnMj52dHSwsLAp98vfee0+Z+ABAhQoVIJVKVcreZmZmBisrK+W2iYkJTE1N9RIPkT5IjIxgP2f2/228vfN1gf2c2RzsTAbPxcUFMpks3zq2trZwcXEppojIUOg022vevHlISkrCkiVLCr0OQ2RkJHbs2AG5XI69e/eiTZs2WLVqVZ7tXr58GWPGjEGLFi1Qo0YNnDhxAra2ttiwYUOefx2kp6cjPT1duS2Xy+Hs7MzZXlSkctb5yXr+XFnGdX6IVHG2F+mLNrO9dLrtdejQIVy4cAFBQUGoVasWJBLVP29Pnz6tcVvp6emIiYlBXFwcYmNjkZ2djaysrDwHMGdnZyM7OxtRUVEwMTFBTEwMbG1t850N4O/vj6+++krjmIj0waZLF1i1bo27nq8XAnX+ZS2s2rZljw/RGzw8PODr65trnR9bW1t4e3sz8aEioVPPz4IFCwq1Py9Pnz6Fu7s75s2bhylTpuTan5WVhRo1amDYsGFYvHgxACAzMxNNmzbFu+++izVr1qhtlz0/VFL4YFMizXCFZyqsIu/50TW5KYijoyMaN26M//77T+3+6OhoPH36FJ07d1aWmZiY4L333sOFCxfybNfMzAxmZmZ6j5eIiPRDKpVyOjsVG72k1WPGjNH6mMzMTNy9e1elLDY2FqGhoahbt66y7PDhw/jtt98AvE6OLCwscP78eeV+IQQuXbrEXxoiIiLSiF4ebyGRSKBtMxkZGWjVqhXq1KmDBg0aID4+Htu3b1c+MT6ny2rMmDE4d+4cbty4AQAICAjA1KlTMWTIELi4uODvv//GjRs3cPr0aTRo0ECjc/PxFlQUMp8/z7VwoUhLw8NhwwEANTb/AYma9auM7exgUqVKscRIRFReFfuzvXRJfoDXg5f/+usvXLlyBVZWVmjatCk6deqkUic4OBhRUVGYNm2asuzmzZs4cuQIXrx4gRo1aqB///6wtbXV+LxMfqgoxK76CXEBAVofV/nTT2H32YQiiIiIyHCUmeSnpDD5oaKgrudHE+z5ISIqvCIf8Py2WD6jiEqJkpwxYlKlCpMYIqIyQC/JT+XKlfXRDFGhhIaG5lorRCaTwcfHh2uFEBGRkk7JT7169fLcZ2ZmBhcXF3z00Ufo06ePzoERaSOvVWITEhIQGBjIVWKJiEhJp/sB3t7euH//Pho3boyPPvoIo0ePRqNGjXD//n20b98etra26N+/P7Zt26bveIlyUSgUCAkJybfO7t27810FnIiIDIdOPT/Xrl3Dxo0bMXz4cJXy33//HVu3bsWBAwfQvn17+Pv7Y9CgQXoJlCgvERERKre61ImPj0dERATXgyIiIt16fs6fPw9vb+9c5T4+Pjh37pzy3+Hh4YWLjkgDiYmJeq1HRETlm07Jj6mpKY4fP56r/NixY8rHSMTGxqJGjRqFCo5IE9bW1nqtR0RE5ZtOt70mT56MIUOGwM/PDy1atIAQApcvX8b69evx5ZdfAgBWrlyJTz/9VK/BEqnj4uKiXNshL7a2tnBxcSnGqIiIqLTSeZHDoKAgrFixArdv3wbwegbYpEmTMHjwYACvZ9nIZDL9RapHXOSw/MlrtlcOzvYiIirfin2F57KGyU/5pG6dH1tbW3h7ezPxISIq54p9hWei0sDDwwPu7u4ltsIzERGVDTp/KwQHB6NFixawsrKClZUVWrRogeDgYH3GRqQ1qVQKNzc3NG3aFG5ubkx8iIgoF516flavXo1p06bBz88PkydPhkQiwb///ouRI0ciNjYWn3zyib7jJCIiItILncb8uLq64vvvv0f//v1VyoODgzFr1izcv39fbwEWBY75ISIiKl+KfMCzqakpXrx4kWvdFLlcjsqVKyMjI0PbJosVkx8iIqLyRZvvdp0GRNSoUQMHDhzIVb5//34ubEhERESlmk5jfmbMmAFfX18cPXoUXl5eAF4/8iIwMBA//fSTXgMkIiIi0iedkp+xY8fC3t4eixcvxvbt2wEADRo0wPbt29GnTx+9BkhERESkT1zkkGN+iIiIyrwiH/NDREREVFZpfNurSZMmGjd69epVHUIhIiIiKnoaJz/Dhw8vyjiIiIiIioXGyc/nn39elHEQEZEBUygUfC4fFRs+2JSIiEpUaGgoQkJCkJCQoCyTyWTw8fGBh4dHCUZG5RXTaiIiKjGhoaEIDAxUSXwAICEhAYGBgQgNDS2hyKg8Y/JDREQlQqFQICQkJN86u3fvhkKhKJ6AyGAw+SEiohIRERGRq8fnbfHx8YiIiCimiMhQMPkhIqISkZiYqNd6RJrSacBzTEwMZs+ejTNnzuDly5e59sfFxRU6MCIiKt+sra31Wo9IUzolP2PGjEF0dDSmTJmCihUr6jsmIiIyAC4uLsrHEeTF1tYWLi4uxRgVGQKdkp8TJ04gLCwMTk5O+o6HiIgMhFQqhY+PDwIDA/Os4+3tzfV+SO90+kTZ2dnBwsJC37EQEZGB8fDwgK+vL2QymUq5ra0tfH19uc4PFQmdnuo+b948JCUlYcmSJWUyI+dT3YmISheu8EyFpc13u063vQ4dOoQLFy4gKCgItWrVgkQiUdl/+vRpXZolIiIDJZVK4ebmVtJhkIHQKfnp3r07unfvru9YiIiIiIqcTre9yjre9iIiIipftPlu5w1VIiIiMig6P9U9KioK+/btQ1RUFLKyslT2LVmypNCBEemCgyaJiKggOiU/f//9N7y9veHh4YHz58/j/fffx40bN/DixQu0a9dO3zESaSQ0NBQhISEqC6bJZDL4+PhwuiwRESnp9CfxnDlzsGzZMpw7dw4AcPz4cURFRWHw4MFo2LChXgMk0kRoaCgCAwNzrRSbkJCAwMBAhIaGllBkRERU2uiU/Ny8eRNDhw4FABgZGSEtLQ2WlpZYsmQJduzYodcAiQqiUCgQEhKSb53du3dDoVAUT0BERFSq6ZT8pKSkoEKFCgAABwcHREREAABMTU359F0qdhEREfk+GwgA4uPjlZ9TIiIybDoPeM7RtWtXfPLJJxg1ahS2bduGVq1a6SMuIo1pmnAzMSciIkDHnp9NmzYp/7148WJUrVoVCxYsgBAC69at01twRJqwtrbWaz0iIirfdOr5GT58uPLflSpVwtatW/UWEJG2XFxclAtb5cXW1hYuLi7FGBUREZVWhVoARQiB6OhofcVCpBOpVAofH59863h7e3O9HyIiAqBj8pOamooJEyagQoUKcHR0VJb7+vrixo0bWrWVkpKCU6dO4cCBA4iMjNT4uPj4eBw8eBAnT55EZmamVuek8sfDwwO+vr6QyWQq5ba2tvD19eU6P0REpKTTba/58+fjwoUL2Lt3Lzp16qQs//DDD/HVV18hODhYo3Z+/fVXLFq0CC4uLjA2Nsbp06cxaNAgrF+/Pt+/0gMCAjBr1iw0a9YMlpaWiIuLQ0hICKpVq6bL5VA54eHhAXd3d67wTERE+dIp+QkKCsKRI0dQt25dlfK2bdvC19dX43YqVqyI69evKweihoaGolGjRvjwww/Ru3dvtcfs2bMHEydOxL59+5RPlr916xZSU1N1uRQqZ6RSKdzc3Eo6DCIiKsV0Sn6ePXsGJycnAIBEIlGWZ2VlaXULqm/fvirbOT1A+U1J/vbbb+Hj46NMfACgQYMGGp+TiIiIDJtOyU/Dhg1x9OhR9O7dWyX5WbduHZo3b65VWzExMTh+/Djkcjn++OMP9OjRA/3791dbNzU1FRcvXsRHH32EyMhIXLt2DY6OjmjWrBmMjIzyPEd6ejrS09OV23K5XKsYiYio/Mp8/hxZsbFaH2dsZweTKlWKICIqajolPwsWLMDIkSMxadIkAMDatWtx8OBB7NmzBwcPHtSqrWfPniEkJARxcXG4c+cOPvvsMxgbqw/rxYsXUCgUOHz4ML777jt4eHjg2rVrkMlk+Ouvv+Ds7Kz2OH9/f3z11VfaXSQRERmE+G3bERcQoPVxlT/9FHafTSiCiKioSYQQQpcDDx06hG+//RaXLl2CQqFAs2bNMG/ePHTt2lXnYG7dugUvLy8sW7YMY8eOzbU/Li4OdnZ2cHd3x8WLF2FhYYG0tDS0adMGrq6ueQ60Vtfz4+zsjISEBNjY2OgcLxERlX3qen5EWhoeDnu9pl2NzX9AYm6e6zj2/JQucrlcueZbQd/tOj/eomvXroVKdNRp0KABmjdvjlOnTqlNfipXrgyZTIbu3bvDwsICAGBubo6ePXti8+bNebZrZmYGMzMzvcZKRETlg0mVKrmSGEVKivLf5vXrQ2ppWdxhUREqsTnA2dnZiIuLUylLSkrC3bt3VW5fXbx4UeVWWq9evXD79m2V48LCwvK85UVERET0Jq16fnKe5F6QpKSkAutkZmaiXbt26NGjBxo0aID4+HgEBgaiQoUKmDhxorLe2rVrce7cOXTr1g0AsHDhQrRs2RJ+fn5o27Ytzp8/j3379uHQoUPaXAoREZUiCoWiVK3RJbKzlf9OuXQJVm3bQpLPxBoqW7RKfpKTk1GjRg2MHDlSZWVnXZibm+PixYsIDAzEv//+CysrK0ydOhVDhgyBqampsp6XlxcqVqyo3K5VqxauXr2KtWvX4uTJk6hevTpu3LjBtV2IiMqo0NBQ7Nq1S2Umro2NDT788MMSWZ1dfvgwni36Rrn96ONxMHZwgP2c2bDp0qXY4yH902rA8549e7B+/XocPnwYnTt3hp+fH3r16gUTE5OijFHvtBkURURERSc0NBSBgYF57i/ux9PIDx/Gk0mTgbe/Gv9vWZdqK5YzASqltPlu16pPsU+fPtizZw8ePHiANm3aYPr06XBycsL06dMRFhZWqKCJiMiwKBSKAh+HFBwcDIVCUSzxiOxsPPvWP3fiAyjLnn3rr3JLjMomnW6oVq1aFXPmzMG9e/cQFBSEEydOcJVlIiLSSnh4OFLemFWlTkpKCsLDw4slnpRLl5EVE5N3BSGQFRODlEuXiyUeKjo6jyaTy+X45ZdfMGvWLISFheGjjz7SZ1xERFTORURE6LVeYWm6yrMuq0FT6aLVgGchBE6ePIlff/0Vf/75Jxo3boyPP/4YgwYN0ngmGBEREfD6O0Wf9QrL2M5Or/Wo9NIq+alduzYSExMxYsQIXLp0CfXr1y+quIiIqJxzc3PDP//8o1G94mDZojmMHRyQ9eyZ+nE/EgmM7e1h2UK7Z1hS6aPVba/79+9DLpdjzZo18PT0RIUKFdT+EBERFcTV1RWWBaycbGlpCVdX12KJR2JkBPs5s/9v4+2drwvs58zmej/lgFY9P+vWrSuqOIiIyMBIpVIMGDAg36nuAwYMKNbFDm26dAFWLMezRd8g6/lzZbmxvT3X+SlHdH6waVnGdX6IiEqP0NBQhISEICEhQVkmk8ng4+NTIoscAkB2YiLuenoBAJx/WcsVnsuAYnmwKRERkT54eHjA3d29VD3e4s1Ex7JFCyY+5QyTHyIiKnFSqbTEHlOU+fx5runrIi1N+e+0sDBIzM1zHWdsZ5frafBUNjD5ISIigxa/bTviAgLy3P9w2HC15ZU//RR2n00oqrCoCDH5ISIig2Y7aCAqdOyg9XFc76fsYvJDREQGzaRKFd6+MjAlN5qMiIiIqAQw+SEiIiKDwuSHiIiIDAqTHyIiIjIoTH6IiIjIoDD5ISIiIoPC5IeIiIgMCpMfIiIiMihMfoiIiMigMPkhIiIig8Lkh4iIiAwKkx8iIiIyKEx+iIiIyKAw+SEiIiKDwuSHiIiIDAqTHyIiIjIoTH6IiIjIoDD5ISIiIoPC5IeIiIgMCpMfIiIiMihMfoiIiMigMPkhIiIig8Lkh4iIiAwKkx8iIiIyKMYlHQCRPikUCkRERCAxMRHW1tZwcXGBVMocn4iI/j8mP1RuhIaGIiQkBAkJCcoymUwGHx8feHh4lGBkRERUmvBPYioXQkNDERgYqJL4AEBCQgICAwMRGhpaQpEREVFpw+SHyjyFQoGQkJB86+zevRsKhaJ4AiIirSkUCoSHh+PKlSsIDw/n7ysVKd72ojIvIiIiV4/P2+Lj4xEREQE3N7diioqINMVb1lTc2PNDZV5iYqJe6xFR8eEtayoJTH6ozLO2ttZrPSIqHrxlTSWFyQ+VeS4uLpDJZPnWsbW1hYuLSzFFRESa0OaWNZE+MfmhMk8qlcLHxyffOt7e3lzvh6iU4S1rKiml4tvgwYMHCA0NRVJSklbHJSQk4PTp03jw4EERRUZlhYeHB3x9fXP1ANna2sLX15eDJolKId6yppJSorO99uzZg5kzZ0KhUMDY2BiRkZGYNm0avv766wKPFUJg2LBhOHDgAD777DMsX7686AOmUs3DwwPu7u5c4ZmojMi5ZZ3frS/esqaiUKLJT0xMDA4dOoTq1asDAI4ePYpOnTqhXbt26Ny5c77HLlu2DNnZ2WjYsGFxhEplhFQq5XR2ojJCKpWiadOmOH78eJ51mjRpwj9gSO9K9BP18ccfKxMfAHjvvfdgbGyMJ0+e5Hvc5cuX8eOPP2Ljxo2QSCRFHSYRERUBhUKBK1eu5Fvn6tWrnO1FelfiixzGx8fjxo0bkMvl2LBhAxo3box+/frlWT8xMRGDBw9GQEAAHBwcNDpHeno60tPTldtyubzQcRMRUeFwgVIqKSWe/Ny5cwezZs1CXFwcnj9/jiVLlqBChQp51v/f//6HTp06wdvbW+Nz+Pv746uvvtJHuEREpCec7UUlpcRvpLZs2RKnT5/G7du3sXPnTvzvf//Dtm3b1Nbds2cP9u3bh759++L06dM4ffo0kpOT8fTpU5w+fTrPc8yePRsJCQnKn0ePHhXV5RARkYY424tKSon3/Lypffv28PLywoEDBzBo0KBc+7OystCwYUOV2WDR0dFISUnB06dPceLECRgZGeU6zszMDGZmZkUaOxERaYezvaiklFjPj0KhQFpamkpZZmYmoqKiUKlSJWVZzlN+Aaj0+OT8uLm5YcCAATh9+rTaxIeIiEonLlBKJaXEen7S09Ph6emJMWPGoEGDBoiPj8cvv/yClJQUTJgwQVnvu+++w7lz53Djxo2SCpWIiIpIzgKlbz/V3dbWFt7e3lyglIpEiSU/FhYWOHz4MH766SccOnQIVlZW6NChA7Zt26bS81O7dm1kZGTk2U7Tpk3ZJUpEVIZxgVIqbhIhhCjpIIqbXC5X3me2sbEp6XCIiIiokLT5bmdaTURERAaFyQ8REREZFCY/REREZFCY/BAREZFBYfJDREREBoXJDxERERmUUvV4i+KSM7ufT3cnIiIqH3K+0zVZwccgk5+cJwQ7OzuXcCRERESkT4mJiZDJZPnWMchFDhUKBZ4+fQpra2tIJJKSDof0TC6Xw9nZGY8ePeIilkRlCH93qTCEEEhMTISjo2OBq4MbZM+PVCqFk5NTSYdBRczGxob/gRKVQfzdJV0V1OOTgwOeiYiIyKAw+SEiIiKDwuSHyh0zMzPMnz8fZmZmJR0KEWmBv7tUXAxywDMREREZLvb8EBERkUFh8kNEREQGhckPERERGRSDXOeHSk5KSgouX76MuLg4ODg4oF69eqhYsWJJh6Wxs2fP4tGjR+jXrx+MjfnrQ4YlISEBly9fhlwuR7Vq1VCvXj1YW1uXdFj5ioqKwtmzZ5XblpaWcHNzQ4MGDUowKippHPBMxSI7OxsLFy7E0qVL4ebmhlq1auH58+eIiIhA586dsWrVKo0XpyopWVlZcHZ2RkxMDEJCQuDt7V3SIREVi9TUVEyfPh0bNmxAo0aN4OjoiKdPnyIqKgp9+/bFypUrC1xRt6QEBQVhyJAhGDBgAKRSKZKTk3Hy5Em0bdsWu3bt4swyA8U/XalYTJs2DYGBgTh48CDatm2rLM/KysK2bduQmpoKmUwGIQS2bduGjh07Qi6XIzQ0FPXq1UP9+vUBAHfu3MGtW7dQqVIltG7dGiYmJsq27t+/j9u3b6Nnz57KsufPn+Po0aMYNGgQJBIJHj9+jAsXLsDb2xuhoaF4+PAhmjZtiurVqxd4Dfv27UNGRgZGjx6N9evXM/khgzFkyBBcvXoVly5dUukxSU1NxcaNG5GdnQ2pVIqkpCTs27cPvXv3RkREBO7evQtPT0/l79fVq1cRERGBatWqwcvLS+XxQtevX8fLly/Rvn17ZdmDBw8QGhqKPn36AHj9+x8ZGYkOHTrg6tWriImJQevWrWFnZ1fgNfz+++8wNzdXtuvq6oo///wTQ4cO1cdLRGWNICpiDx48EEZGRmLZsmUF1s3MzBQARPfu3YWLi4vo16+f2L17txBCiLFjx4oKFSqIrl27ChcXF1GnTh3x4MED5bE///yzcHV1VWnv2LFjAoDIzMwUQggRHBwsLC0txfvvvy9atGgh3n//fWFmZiY2bNhQYGw9e/YUkydPFteuXRNGRkbiyZMnmr8IRGXUyZMnBQCxa9euAuveu3dPABC9evUS9erVEwMGDBBnz54V6enpomfPnuKdd94R3bt3F1WrVhUtW7YUL1++VB47c+ZM0alTJ5X2Nm7cKKpVq6bc/uGHH4STk5No1KiReO+994SXl5ewsrISBw4cyDOmrVu3CgAiNTVVWZaeni5MTU3F2rVrtXglqDxhzw8VuX/++QfZ2dn48MMPNT4mOTkZt27dUnZJ//nnn/j9999x+fJluLu7Iz09HV27dsXEiROxZ88ereJJSUlB8+bNsXTpUgDAmjVrMHHiRPTq1SvPvyCfPn2KgwcPYvHixWjQoAGaN2+O3377DXPmzNHq3ERlzeHDh2FsbIxevXppfIy1tTVu3rypvBW2dOlSXLp0CaGhoXB0dERCQgJatWqF+fPnY+XKlVrF8/jxY8ycORMTJkwAAMyaNQvjxo3DvXv3YGpqmudxwcHBMDExQXJyMoKDg+Hu7o4BAwZodW4qP0rnTVoqV2JiYiCRSFQeJvvq1SsEBQUpf+7du6dyzLhx41TuxQcFBcHb2xvu7u4AXq8EO336dOzduxfJyclaxzRjxgzlv8eOHQsTExPs378/z/obN25Eq1atlF3+H3/8MTZs2ADBIXNUzsXExMDR0VFlgP/jx49Vfn+fPn2qcsyECRNUxgAFBQXB19cXjo6OAF4/fHLChAkICgrSOh5ra2uMHz9euT1z5kxERUXh33//zfe4vXv3IiQkBHv27EFYWBhatmzJ8T4GjD0/VOQqVKgAIQRevXqFypUrA3id/ISEhAB43auzbNky1K5dW3lM1apVVdp4+PAhOnXqpFLm6uoK4PVsjpwxQZowNzeHvb29ctvIyAjVq1fHw4cP1dYXQmDjxo1o06aNyn/WEREROH78ODp06KDxuYnKmgoVKuDFixcqZU+ePEFISAgyMjKwa9cu7N27V5nYAOp/f11cXFTKXF1dERsbi5SUFFhaWmocT7Vq1VQSsYoVK0Imk+X5+5vjzTE/ycnJaNKkCWbMmIGffvpJ43NT+cGeHypyXl5eAIDz588ry1xcXJR/Nar76+vNgZAAULlyZbx8+VKlLGc7J6GSSqVQKBQqddLS0nK1nZaWhtTUVJWyNxOztx07dgzPnz9HRkYGQkJCEBISgiNHjqBx48ZYv3692mOIygsvLy8kJyfj5s2byrKWLVsiKCgIv/zyi9pjNP39tbKyUiY+mv7+vnr1SmU7KysLSUlJef7+qmNlZYUOHTrgn3/+0fgYKl+Y/FCRa926NVq1aoUvvvgCCQkJOrXx7rvv4q+//kJ6erqyLDg4GHXq1FGO06lWrRqio6NVboMdO3ZMbXu7d+9W/vvy5ct49OgR2rRpo7bu+vXr0adPH5Vu/qCgIKxcuRI7d+7M9Z8xUXnSt29f1KxZE9OmTVObjGji3Xffxa5du1RuEwcHB6vM/KxWrRoiIiJU6qj7/X327BnOnTun3N69ezdMTEzQvHlzrWIKDw+Hg4ODVsdQ+cHbXlQsgoOD0bt3b9SvXx++vr6oXbs2MjIylP+JOTs753v8pEmT8Ntvv6Fjx44YOXIkbty4gbVr16okMR06dEDlypUxYMAA9O/fH1evXsWOHTtytWViYoLPP/8c9+/fh5WVFX744QcMHToUTZo0yVX31atX2LVrFzZt2pRrX9u2bWFtbY3NmzcrB18SlTdmZmbYs2cP+vTpg8aNG2PQoEFwcXFBcnIy/v77b8hkMpXbyOrMnz8fTZs2Re/eveHt7Y0TJ07gyJEjOH36tLJO3759MWvWLIwYMQIdO3bEiRMncPz4cZXlLIDXY34GDx6MiRMnIj09Hd999x2mTZtWYAw5A55TU1Nx7NgxnDx5Mt9xflS+seeHioWTkxMuXbqE1atXIy0tDcePH0d4eDhatWqFhw8fKtfMkUqlGDRoEKpUqaJyvJWVlXJ9nrNnz8LY2Bjnzp1D9+7dlXUsLS1x7tw5NGnSBOfOnUO9evWwf/9+DBo0SGXwpaWlJU6ePImMjAxcvXoVX3zxBTZu3Kg27ps3b8LHxwfdunXLtU8qleKLL75gzw+Vex4eHggLC8O8efPw6tUrHDt2DI8ePYK3tzceP34MT09PAK8Tk0GDBsHKykrl+GrVquHq1ato0aIFTp06BScnJ1y5ckXlD46qVaviwoULcHBwwMWLF9GpUyds27Yt13paLi4uCAkJQWxsLO7evYuAgAAsXLgwz9hr1KiBQYMG4a+//kJISAhOnDiBWrVqISwsDF26dNHfi0RlCld4JoOyY8cOjBkzBvHx8SUdChFpacmSJfjjjz9w9erVkg6Fyjj2/BAREZFBYfJDBsXZ2Rn9+vUr6TCISAf16tVTewuaSFu87UVEREQGhT0/REREZFCY/BAREZFBYfJDREREBoXJDxERERkUJj9ERERkUJj8EBERkUFh8kNEREQGhckPERERGRQmP0RERGRQ/h+ntCG8id8rIgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_cells = test_of_cells(controls, cd4, in_a)\n", + "gene = int(np.argmin(p_cells))\n", + "name = controls.features[\"feature_id\"][gene]\n", + "table = of_samples.table(cd4, \"B_vs_A\")\n", + "p_samples = table[\"p_value\"][table[\"feature_id\"] == name][0]\n", + "print(\n", + " f\"{name}: p-value {p_cells[gene]:.0e} testing cells, {p_samples:.2f} testing samples\"\n", + ")\n", + "\n", + "pooled = [pooled_cells(controls, cd4, samples) for samples in (in_a, ~in_a)]\n", + "figure, ax = plt.subplots(figsize=(6.5, 4))\n", + "ax.scatter(\n", + " np.where(in_a, 0, 1),\n", + " controls.mean(cd4)[:, gene],\n", + " color=\"0.45\",\n", + " label=\"Mean of a donor's cells\",\n", + ")\n", + "ax.errorbar(\n", + " [0.15, 1.15],\n", + " [mean[gene] for _, mean, _ in pooled],\n", + " yerr=[1.96 * np.sqrt(variance[gene] / n) for n, _, variance in pooled],\n", + " fmt=\"o\",\n", + " color=\"tab:red\",\n", + " capsize=5,\n", + " label=\"Mean of a group's cells, 95% interval\",\n", + ")\n", + "ax.set_xticks([0, 1], [\"Group A\", \"Group B\"])\n", + "ax.set_xlim(-0.5, 1.6)\n", + "ax.set_ylabel(\"Mean log-normalized value\")\n", + "ax.set_title(f\"{name} in the CD4 T cells\")\n", + "ax.legend(frameon=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3a3f7125", + "metadata": {}, + "source": [ + "The donors of one group differ from each other more than the two groups differ. The\n", + "test of the cells measures the difference against the precision of each group's mean\n", + "over some 1,500 cells, the red intervals: that precision says how well these 12 donors\n", + "were measured, not how another 12 donors would differ. The test of the samples measures\n", + "the same difference against the spread of the donors, and its p-value of 0.02 is no\n", + "discovery among 2,000 genes.\n", + "\n", + "## What benchmarks found\n", + "\n", + "Studies that compared methods on data whose truth was known report:\n", + "\n", + "- @squair2021 compared differential expression methods on eighteen datasets with\n", + " matched bulk RNA-seq. Methods that ignore the variation between biological replicates\n", + " were biased and prone to false discoveries, and the most widely used methods could\n", + " discover hundreds of differentially expressed genes in the absence of biological\n", + " differences.\n", + "- @zimmerman2021 showed that cells of one individual are not statistically independent\n", + " and that ignoring it leads to highly inflated type 1 error rates. They proposed\n", + " mixed models with a random effect for the individual, and found pseudobulk methods\n", + " conservative and underpowered in comparison.\n", + "- @murphy2022 reran that benchmark with the Matthews correlation coefficient, a measure\n", + " that balances false positives and false negatives, and found that pseudobulk methods\n", + " performed best.\n", + "- @junttila2022 compared 18 methods for differential states between conditions in data\n", + " of several subjects: pseudobulk methods performed generally best, and methods that\n", + " treat cells as independent were more sensitive but gave many false positives.\n", + "- @crowell2020 surveyed cell-level mixed models and methods on pseudobulk data for\n", + " differential state analysis, with a simulation of single-cell data of several\n", + " samples and conditions.\n", + "\n", + "## Results that replicate\n", + "\n", + "Results that rest on cells as replicates include many that a test of donors does not\n", + "find, and even results that compare donors replicate less often than their p-values\n", + "suggest:\n", + "\n", + "- @murphy2023 re-analysed the first single-nucleus study of Alzheimer's disease. A\n", + " pseudobulk analysis of the authors' processed data found 26 differentially expressed\n", + " genes at a false discovery rate of 0.05, 549 times fewer than the 14,274 of the\n", + " analysis of cells.\n", + "- @nakatsuka2025 found that over 85% of the Alzheimer's disease genes called in one of\n", + " 17 datasets, with pseudobulk tests, failed to reproduce in any of the 16 others, and\n", + " that a meta-analysis of ranks across datasets found genes that predicted disease\n", + " better.\n", + "- @garg2021 re-analysed COVID-19 single-cell studies in a standard way and confirmed 8\n", + " of 20 published results across datasets.\n", + "\n", + "Pooling the cells removes the false positives of pseudoreplication. Small studies and\n", + "differences between cohorts remain, which combining studies addresses\n", + "([Meta-analysis](statistics/meta_analysis.md)).\n", + "\n", + "## Choices\n", + "\n", + "- **Pool, then test.** {api}`from_cells` pools the cells of every sample and cell type\n", + " ([Pool cells into pseudobulk profiles](guides/pool_cells.ipynb)), and the tests of\n", + " [Compare conditions](guides/genes_per_cell_type.ipynb) compare the profiles.\n", + "- **Profiles of few cells.** A profile of a handful of cells is noisy: `min_cells` (10\n", + " by default) leaves such profiles out of a fit, and `prior_weights=\"n_cells\"` instead\n", + " weights every profile by its number of cells [@hoffman2026a].\n", + "- **Several samples of a donor.** They are not independent either: pair them in the\n", + " design, `~ donor + condition`, or give the donor a random effect with\n", + " {api}`dream_voom` ([Repeated measures and donors](guides/repeated_measures.ipynb)).\n", + "- **Models of the cells.** Generalized linear mixed models with a random effect for\n", + " each individual model the cells themselves [@zimmerman2021]; CytePool does not fit\n", + " them.\n", + "- **Descriptions of the cells.** What fraction of a cell type's cells express a gene,\n", + " and how much, describe the cells and need no test: the dot plot draws them from the\n", + " cube ([Pool cells into pseudobulk profiles](guides/pool_cells.ipynb))." + ] + } + ], + "metadata": { + "datasets": [ + "simulated_pbmc" + ], + "executed_at": "2026-10-26T21:42:08+00:00", + "executed_code_sha256": "0a4cdd530679e2d54393bbd5fe8f70152188a7e8bd5ff86cfbbf7d1f71cffb79", + "executed_datasets": { + "simulated_pbmc": { + "simulated_pbmc.cube.zarr": "sha256:554a2b5b4188308ea900cf907fa87f42d12e0458e6d5dc11525e862f3ad8a726", + "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" + } + }, + "executed_with": "0.1.dev57+gb65bc7e32", + "execution_seconds": 3.4, + "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.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test_documentation.py b/tests/test_documentation.py index 7188f0d..a859369 100644 --- a/tests/test_documentation.py +++ b/tests/test_documentation.py @@ -430,7 +430,7 @@ def test_prose_can_change_without_executing_again() -> None: assert build_docs.code_fingerprint(notebook) != fingerprint -def test_output_checks_ignore_only_the_version_of_cytepool_that_ran_a_page( +def test_output_checks_ignore_the_versions_of_cytepool_a_page_prints( monkeypatch: pytest.MonkeyPatch, ) -> None: # The runner imports nbclient, a documentation dependency. @@ -452,8 +452,20 @@ def test_output_checks_ignore_only_the_version_of_cytepool_that_ran_a_page( changed = [fresh[0], "t = 4.3\n"] reported = runner.differences(saved, changed, "0.1.dev24+gabc", "0.1.dev31+gdef") assert [line.split(":")[0] for line in reported] == ["code cell 2"] - # Without a recorded version, a different version is a difference. - assert len(runner.differences(saved, fresh, None, "0.1.dev31+gdef")) == 1 + # A version named after "CytePool " is left out, whichever version ran the page: + # a dataset prepared earlier was built by another one. + built_earlier = ["Built by from_cells (CytePool 0.1.dev18+g123) from 9 cells\n"] + now = ["Built by from_cells (CytePool 0.1.dev31+gdef) from 9 cells\n"] + assert ( + runner.differences(built_earlier, now, "0.1.dev24+gabc", "0.1.dev31+gdef") == [] + ) + assert runner.differences(built_earlier, now, None, "0.1.dev31+gdef") == [] + # A version printed on its own is compared, replaced only by the recorded one. + alone, alone_now = ["0.1.dev24+gabc\n"], ["0.1.dev31+gdef\n"] + assert ( + runner.differences(alone, alone_now, "0.1.dev24+gabc", "0.1.dev31+gdef") == [] + ) + assert len(runner.differences(alone, alone_now, None, "0.1.dev31+gdef")) == 1 def test_every_public_module_is_in_the_api_reference() -> None: @@ -901,7 +913,7 @@ def test_every_page_has_a_kind_and_the_lists_of_kinds_name_pages() -> None: assert kinds["statistics/choosing_a_method.md"] == page_index.EXPLANATION assert kinds["reference/cube_files.md"] == page_index.EXPLANATION assert kinds["reference/capabilities.md"] == page_index.INDEX - assert kinds["differential_expression.ipynb"] == page_index.GUIDE + assert kinds["quickstart.ipynb"] == page_index.GUIDE @pytest.mark.parametrize( @@ -909,13 +921,13 @@ def test_every_page_has_a_kind_and_the_lists_of_kinds_name_pages() -> None: [ ("index.md", "/"), ("installation.md", "/installation"), - ("differential_expression.ipynb", "/differential-expression"), + ("why_pseudobulk.ipynb", "/why-pseudobulk"), ("statistics/empirical_bayes.md", "/statistics/empirical-bayes"), ("guides/Bulk_RNA.seq.ipynb", "/guides/bulk-rna-seq"), ], ) def test_page_urls_follow_the_rule_of_myst(file: str, url: str) -> None: - # MyST 1.8.1 serves differential_expression.ipynb at /differential-expression and, + # MyST 1.8.1 serves why_pseudobulk.ipynb at /why-pseudobulk and, # with folders, stats/a_page.md at /stats/a-page; build_docs.py checks every page # against the built site's myst.xref.json. assert page_index.page_url(file) == url @@ -1120,17 +1132,19 @@ def test_api_entries_link_back_to_the_pages_that_use_and_explain_them() -> None: for page in links.explained_in["cytepool.differential_expression.limma_voom"] } - assert "differential_expression.ipynb" in used # its code imports it + assert "quickstart.ipynb" in used # its code imports it assert "guides/bulk_rna_seq.ipynb" in used assert "statistics/choosing_a_method.md" in explained # Index pages link to many names and give no links back. index = {page.file for page in page_index.pages() if page.kind == page_index.INDEX} for pages in (*links.used_in.values(), *links.explained_in.values()): assert not index & {page.file for page in pages} - lines = page_index.backlink_lines("cytepool.stats.voom.voom", links) + lines = page_index.backlink_lines( + "cytepool.differential_expression.limma_voom", links + ) assert lines[0] == "" assert lines[1].startswith("**Used in:** `Quick start <../quickstart/>`__") - assert "`Precision weights <../statistics/precision-weights/>`__" in lines[3] + assert "`Choosing a method <../statistics/choosing-a-method/>`__" in lines[3] assert page_index.backlink_lines("cytepool.stats.special.lgamma", links) == []