diff --git a/README.md b/README.md index a6b2163..1048240 100644 --- a/README.md +++ b/README.md @@ -12,11 +12,11 @@ what is planned. | Area | Implemented | Checked against | | --- | --- | --- | -| Pseudobulk cubes | `Cube` (additive layers per sample, group and feature; merging groups; pooling samples; lazy layers, read as a selection needs them), `from_cells` (dense or CSR counts), `from_bulk` | scanpy, decoupler | +| Pseudobulk cubes | `Cube` (additive layers per sample, group and feature; merging groups; pooling samples by one or more columns, or all of them; columns added to its tables; lazy layers, read as a selection needs them), `from_cells` (dense or CSR counts), `from_bulk` | scanpy, decoupler | | Provenance and fingerprints | A record of each cube's source (the caller's record, kept unchanged), of the settings that built it and of what each operation kept, merged or pooled, with the fingerprint of the cube it was applied to; `Cube.history()` reads it back. A content fingerprint (SHA-256, documented encoding) of the tables, cell numbers, normalization and layers | a reimplementation of the documented encoding, zarr-python | | Cube files | `write_cube`, `read_cube` (a subset of Zarr v3, with orthogonal selections; a read opens only the chunks that hold the selected features; gzip, and zstd on Python 3.14 or newer; stored digests, checked when a file is opened and when a read covers a whole group) | zarr-python | -| AnnData and MuData | `to_anndata`, `from_anndata`, `to_mudata`, `from_mudata` (optional extras `anndata` and `mudata`): cubes to and from the long AnnData of `scanpy.get.aggregate` and `decoupler.pp.pseudobulk` and the MuData of LIANA's `adata_to_views`, whose layouts are recognised; an import takes sums and counts of cells, refuses means, and gives a cube exported and read back with the same fingerprint | scanpy, decoupler, LIANA, anndata, mudata | -| Several studies | `CubeCollection`: the cubes of several studies aligned, each kept as it is: samples named `study::sample_id`, with donor ids alike; genes aligned by id, with which study measured which, so that a gene a study did not measure is missing there, not zero; cell types aligned by Cell Ontology id, group id or a mapping for each study, merging those that a study splits; each study's cube on the collection's axes, for analyses study by study; and one cube of the genes and cell types every study has, for a joint model. `align_study_results` lines up the studies' results gene by gene, with the reason a study has none for a gene | anndata, pandas, limma | +| AnnData and MuData | `to_anndata`, `from_anndata`, `to_mudata`, `from_mudata` (optional extras `anndata` and `mudata`): cubes to and from the long AnnData (with a layer copied into `X` on request) of `scanpy.get.aggregate` and `decoupler.pp.pseudobulk` and the MuData of LIANA's `adata_to_views`, whose layouts are recognised; an import takes sums and counts of cells, refuses means, and gives a cube exported and read back with the same fingerprint | scanpy, decoupler, LIANA, anndata, mudata | +| Several studies | `CubeCollection`: the cubes of several studies aligned, each kept as it is: samples named `study::sample_id`, with donor ids alike; genes aligned by id, with which study measured which, so that a gene a study did not measure is missing there, not zero; cell types aligned by Cell Ontology id, group id or a mapping for each study, merging those that a study splits, and named as given; each study's cube on the collection's axes, for analyses study by study; and one cube of the genes and cell types every study has, for a joint model. `align_study_results` lines up the studies' results gene by gene, with the reason a study has none for a gene; `analyse_each_study` runs one analysis per study, and `StudyResults` keeps the results with the collection, lined up or as a studies x genes matrix | anndata, pandas, limma | | Normalization and filtering | TMM, upper-quartile and RLE factors, DESeq2 size factors, CPM, log-CPM, `filter_by_expression` | edgeR, DESeq2 | | Designs | Model matrices from R formulas, named contrasts, design checks | R, limma, lme4 | | Linear models | Ordinary, weighted and generalised least squares for every gene (in parallel when each gene needs its own fit), contrasts (named contrasts are matched to the coefficients by name) | limma | @@ -28,13 +28,13 @@ what is planned. | Quasi-likelihood F-tests | `fit_quasi_likelihood` and `quasi_likelihood_f_test`: edgeR 4's `glmQLFit` and `glmQLFTest` with their defaults: the common negative binomial dispersion of the most highly expressed genes by Cox-Reid adjusted profile likelihood (`common_dispersion`), deviances adjusted for small counts with exact moments of the unit deviance (`negative_binomial_unit_deviance_moments`), the average quasi-dispersion, limma's prior for unequal degrees of freedom with a trend in the average log CPM (`average_log_cpm`) or robust, prior weights and offsets, and F-tests of coefficients and named contrasts with edgeR's columns (logFC, logCPM, F, PValue, FDR) | edgeR, limma, mpmath | | DESeq2 | `fit_deseq2`, `deseq2_wald_test`, `deseq2_likelihood_ratio_test` and `deseq2_dispersions`: DESeq2's analysis with its defaults, from gene-wise dispersions (Cox-Reid adjusted profile likelihood), the parametric trend and the maximum a posteriori dispersions to its fits of every gene, Wald tests of coefficients and contrasts, and likelihood ratio tests of a reduced design (all the levels of a factor at once, a time course), with the columns of `results()`, its independent filtering and its Cook's distance flags | DESeq2, PyDESeq2 | | Empirical Bayes moderation | Moderated t and F statistics, B-statistics, TREAT, with constant, trend and robust priors, estimated as limma estimates them by default: by the method of moments, or, when the residual degrees of freedom differ between genes, by weighted moments and profile likelihood (limma's `fitFDistUnequalDF1`); either can be chosen | limma | -| Gene-set tests | `camera` (competitive, allowing for the correlation between the genes of a set, given or estimated per set; parametric or rank-based) and `fry` (self-contained, directional and mixed p-values), for one contrast of a linear model, with voom or other precision weights and trend or robust moderation; the rotation tests `roast` and `mroast` (self-contained, with the mean, floor-mean, mean-50 and mean-square set statistics, contribution weights per gene or per set, and the proportions of active genes) and `romer` (competitive, by the ranks of the genes), with rotations from a seeded generator; gene sets named by gene id or position. Gene sets read from and written to GMT files (MSigDB, Reactome, WikiPathways, the Gene Ontology), with the source, version and licence of the collection, matched to an analysis and filtered by size; over-representation analysis of the genes up, down or either way in a differential-expression result, a table or a list of genes (limma's `kegga` and `goana`), with its dot plot; gene set enrichment analysis (`gsea`) of genes ranked by a statistic, as fgsea computes it: enrichment scores, leading edges, normalized scores, and p-values by fgsea's multilevel method or by permutations, from seeds that a numpy generator draws, with its enrichment plot and table; scores of gene sets in every sample, as the GSVA package computes them: `gsva` (with the Gaussian, Poisson or no kernel, chosen as GSVA chooses it, and its three scores), `ssgsea`, `combined_z_scores` and `plage`, from a matrix or a cell type of a cube, with their heatmap, ready for linear models | limma, R, decoupler, fgsea, GSVA | +| Gene-set tests | `camera` (competitive, allowing for the correlation between the genes of a set, given or estimated per set; parametric or rank-based) and `fry` (self-contained, directional and mixed p-values), for one contrast of a linear model, with voom or other precision weights and trend or robust moderation; the rotation tests `roast` and `mroast` (self-contained, with the mean, floor-mean, mean-50 and mean-square set statistics, contribution weights per gene or per set, and the proportions of active genes) and `romer` (competitive, by the ranks of the genes), with rotations from a seeded generator; gene sets named by gene id or position. Gene sets read from and written to GMT files (MSigDB, Reactome, WikiPathways, the Gene Ontology), with the source, version and licence of the collection, matched to an analysis and filtered by size; over-representation analysis of the genes up, down or either way in a differential-expression result, a table or a list of genes (limma's `kegga` and `goana`), with its dot plot; gene set enrichment analysis (`gsea`) of genes ranked by a statistic, as fgsea computes it: enrichment scores, leading edges, normalized scores, and p-values by fgsea's multilevel method or by permutations, from seeds that a numpy generator draws, with its enrichment plot and table; scores of gene sets in every sample, as the GSVA package computes them: `gsva` (with the Gaussian, Poisson or no kernel, chosen as GSVA chooses it, and its three scores), `ssgsea`, `combined_z_scores` and `plage`, from a matrix or a cell type of a cube, with their heatmap, and tested for a contrast of a design by limma (`score_tests.limma`, as for activities) | limma, R, decoupler, fgsea, GSVA | | Activities of regulators and pathways | `ulm`, `mlm` and `weighted_aggregate`, as decoupler computes them: the activity of every source of a network (transcription factors, pathways) in every sample, cell type of a cube or group and contrast of a differential-expression result, by a linear model of each source's weights, one model of all of them, or the weighted mean or sum of its targets with permutations; the networks CollecTRI (`collectri`, at a licence level for commercial or academic use) and PROGENy (`progeny`, human and mouse), downloaded from their releases on first use and checked against pinned SHA-256 digests, or any network given as a table; their heatmap and bar plot | decoupler, progeny | | Multiple testing | Bonferroni, Holm, Hochberg, Hommel, Benjamini-Hochberg, Benjamini-Yekutieli | R | -| Differential expression | `limma_voom` and `limma_trend`: limma-voom and limma-trend on every group (cell type) of a cube, and `dream_voom`: dream, with the design's random intercepts, such as a donor's, in every group's fits, dream's choice of Kenward-Roger's or Satterthwaite's degrees of freedom by the number of samples in each group, and F-tests of several contrasts, with the design matched to the cube by sample id, samples with too few cells left out, rank-deficient groups fitted on their column space with the contrasts they can estimate, and a provenance record for every result. Options for pseudobulk data, off by default: sample quality weights, prior weights from the number of cells, a minimum total count per sample, and p-values adjusted across cell types | limma, edgeR, variancePartition; on simulated data and on published single-cell data | +| Differential expression | `limma_voom` and `limma_trend`: limma-voom and limma-trend on every group (cell type) of a cube, and `dream_voom`: dream, with the design's random intercepts, such as a donor's, in every group's fits, dream's choice of Kenward-Roger's or Satterthwaite's degrees of freedom by the number of samples in each group, and F-tests of several contrasts, with the design matched to the cube by sample id, samples with too few cells left out, rank-deficient groups fitted on their column space with the contrasts they can estimate, and a provenance record for every result, which keeps the cube and design it analysed and computes a cell type's fit again on request. Options for pseudobulk data, off by default: sample quality weights, prior weights from the number of cells, a minimum total count per sample, and p-values adjusted across cell types | limma, edgeR, variancePartition; on simulated data and on published single-cell data | | Variance partitioning | `variance_fractions`: the fraction of every gene's variance that each variable of a design explains, as variancePartition's `fitExtractVarPartModel`: a mixed model of every gene by maximum likelihood (or REML), with the categorical variables as random intercepts, the continuous ones as fixed effects and precision weights such as voom's, or a linear model without random effects; `variance_partitioning`: the same on every cell type of a cube, with dream's precision weights, the samples each fit used and a provenance record | variancePartition, lme4 | | Meta-analysis | `meta_analysis`: for every gene, the fixed-effect (inverse-variance) or random-effects estimate of a common effect from the effects and standard errors of several studies, with the between-study variance by DerSimonian-Laird, REML or Paule-Mandel, Cochran's Q, I² and H², z-tests or the Knapp-Hartung adjustment, and genes measured in some studies only; `differential_expression_meta_analysis`: the same for the `limma_voom` or `limma_trend` results of several cubes, matched by cell type, contrast and gene id, with p-values adjusted over the genes and a provenance record | metafor | -| Combined p-values and replication | `combine_p_values`: every gene's p-values combined over the studies that tested it, by Fisher's, Stouffer's (weighted), Tippett's, Wilkinson's, Pearson's, Mudholkar and George's or Simes's method, one-sided or two-sided with the directions of the effects; `partial_conjunction`: the p-value that at least u studies have an effect, in one direction (Benjamini and Heller); `proportion_of_true_nulls`: pi0 and pi1 as qvalue's `pi0est`, with its smoother and bootstrap; `differential_expression_replication`: for the studies of a `CubeCollection`, every gene's combined and replication p-values, the studies that find it, its sign agreement and heterogeneity, pi1 and sign agreement of every pair of studies, and the genes found in at least k studies, with their figures | scipy, metap, qvalue, metafor, mpmath | +| Combined p-values and replication | `combine_p_values`: every gene's p-values combined over the studies that tested it, by Fisher's, Stouffer's (weighted), Tippett's, Wilkinson's, Pearson's, Mudholkar and George's or Simes's method, one-sided or two-sided with the directions of the effects; `partial_conjunction`: the p-value that at least u studies have an effect, in one direction (Benjamini and Heller); `proportion_of_true_nulls`: pi0 and pi1 as qvalue's `pi0est`, with its smoother and bootstrap; `differential_expression_replication`: for the studies of a `CubeCollection`, every gene's combined and replication p-values, the studies that find it, its sign agreement and heterogeneity, pi1 (estimated at lambda = 0.5 by default) and sign agreement of every pair of studies, and the genes found in at least k studies, with their figures | scipy, metap, qvalue, metafor, mpmath | | Replication across studies | `sumrank`: SumRank (Nakatsuka et al. 2025), which ranks every gene within each study by its signed -log10 p-value and sums its best normalized ranks across studies, for genes up and down, with p-values from the Irwin-Hall distribution and from a null pooled over permutations; `differential_expression_sumrank`: the same for one cell type and contrast of the studies of a `CubeCollection`, with permutations that re-run each study's limma analysis from a seeded generator; `held_out_prediction`: each study left out in turn, genes chosen from the others by SumRank and by meta-analysis, its cases scored by UCell's rank score, and the AUC by study and method; with SumRank's Manhattan plot and the held-out AUC of every study | the authors' code, mpmath, scikit-learn | | Composition tests | `propeller`: differences in cell-type proportions between conditions, from the cell numbers of a cube or a table of them, with the logit or arcsine square-root transform, a design matched by sample id, t-tests of its contrasts and the F-test of a factor, robust empirical Bayes moderation, speckle's columns (baseline and mean proportions, proportion ratio, statistic, p-value, FDR) and a provenance record | speckle, limma | | Figures | `cytepool.plotting` (optional extra `plot`, matplotlib): the plots of limma, edgeR, DESeq2, speckle and metafor from CytePool's results, in one call each: MDS plots of pseudobulk samples (`plotMDS`), the cells pooled into each sample and cell type, cell-type composition and `propeller`'s results, voom's mean-variance trend, residual variances and their prior (`plotSA`), sample quality weights, MD and volcano plots, p-value histograms, the genes up and down in each cell type, barcode plots and summaries of gene-set tests, DESeq2's dispersions (`plotDispEsts`), edgeR's quasi-dispersions (`plotQLDisp`), forest plots of meta-analyses, the fractions of variance of every variable over the genes (`plotVarPart`) and of chosen genes (`plotPercentBars`), and heatmaps of pathway scores | limma, edgeR, DESeq2, metafor, speckle, variancePartition, GSVA | diff --git a/cytepool/_analysis_records.py b/cytepool/_analysis_records.py index 5b2c35a..f241ad3 100644 --- a/cytepool/_analysis_records.py +++ b/cytepool/_analysis_records.py @@ -6,8 +6,10 @@ it fitted, with the contrasts it tested; and the versions of the software. """ +import json import platform from collections import Counter +from collections.abc import Mapping from typing import Any import numba @@ -71,6 +73,73 @@ def mixed_design_record(design: Design, contrasts: Contrasts) -> dict[str, Any]: return record +def keep_provenance( + record: Any, method: str, cube: Cube, settings: Mapping[str, Any] +) -> None: + """Give the record of scores of a cube's group, such as ``PathwayScores``, its + provenance: the method, the software, the cube's fingerprint, digests and + provenance, the layer read and the settings. ``provenance_of`` reads it back. + + The record keeps it as JSON text in its own attributes, outside its fields, so + that a record built from fields alone, or copied with ``dataclasses.replace``, + has none. + """ + text = json.dumps( + { + "method": method, + "versions": software_versions(), + "cube": cube_record(cube), + "layer": "counts", + "settings": dict(settings), + }, + allow_nan=False, + ) + object.__setattr__(record, "_provenance", text) + + +def provenance_of(record: Any) -> dict[str, Any] | None: + """The provenance that ``keep_provenance`` gave a record, as a new dict, or + None.""" + text = vars(record).get("_provenance") + if text is None: + return None + found: dict[str, Any] = json.loads(text) + return found + + +def provenance_text(record: Any) -> str | None: + """The JSON text of the provenance that ``keep_provenance`` gave a record, or + None: what a pickled record carries, for ``restore_provenance``.""" + text: str | None = vars(record).get("_provenance") + return text + + +def restore_provenance[R](record: R, text: str | None) -> R: + """Give a record the provenance it was pickled with, if it had one.""" + if text is not None: + object.__setattr__(record, "_provenance", text) + return record + + +def only_key(value: Any, available: list[str], argument: str, what: str) -> Any: + """The key of a result's table: ``value`` when given, else the only one. + + Results that keep one table per group, contrast or both let a key be left out + when they have one. ``what`` names the keys in the message, such as "groups". + + Raises: + ValueError: If ``value`` is None and there is not exactly one key. + """ + if value is not None: + return value + if len(available) == 1: + return available[0] + raise ValueError( + f"the result has {len(available)} {what}; name one with {argument}" + + (f", one of {quoted(available)}" if available else "") + ) + + def software_versions() -> dict[str, str]: """The versions of CytePool, numpy, numba and Python that run an analysis.""" return { diff --git a/cytepool/_expression_values.py b/cytepool/_expression_values.py index 5545328..28f4e5b 100644 --- a/cytepool/_expression_values.py +++ b/cytepool/_expression_values.py @@ -3,9 +3,11 @@ A cube's group is read as limma_voom reads it: the samples with at least ``min_cells`` cells and some counts, over the genes that edgeR's ``filterByExpr`` keeps -(:func:`~cytepool.normalization.filter_by_expression`), as log2 counts per million -after TMM normalization with a prior count of 2, edgeR's ``cpm(log = TRUE)`` (Robinson -and Oshlack 2010; Chen, Lun and Smyth 2016), or as counts. +(:func:`~cytepool.normalization.filter_by_expression`), with the samples as one group +or grouped by a column of the cube's samples (``{"sample_groups": "condition"}``), as +log2 counts per million after TMM normalization with a prior count of 2, edgeR's +``cpm(log = TRUE)`` (Robinson and Oshlack 2010; Chen, Lun and Smyth 2016), or as +counts. References: Robinson MD, Oshlack A (2010). A scaling normalization method for differential @@ -17,6 +19,7 @@ quasi-likelihood pipeline. F1000Research 5, 1438. doi:10.12688/f1000research.8987.2 """ +from collections.abc import Mapping from typing import Any, NamedTuple import numpy as np @@ -24,6 +27,12 @@ from ._columns import text_column from ._gene_ids import is_missing +from ._group_fits import ( + FILTER_DEFAULTS, + SAMPLE_GROUPS, + check_sample_groups, + filter_setting, +) from ._masked_arrays import Missing, real_array, reject_masked, unmasked_array from ._messages import quoted from ._options import checked_choice, checked_flag, integral_number @@ -47,6 +56,7 @@ class ExpressionValues(NamedTuple): samples: Table gene_ids: list[str | None] # one per column; None for a gene without an id settings: dict[str, Any] # how a cube's values were taken + cube: Cube | None = None # the cube whose group was read def expression_values( @@ -73,7 +83,8 @@ def expression_values( values: For a cube, ``"log_cpm"`` or ``"counts"``. min_cells: For a cube, the fewest cells a sample needs in the group. expression_filter: For a cube, whether to keep only the genes that - filter_by_expression keeps. + filter_by_expression keeps: True or False, or a mapping of its settings, + which may name a column of the cube's samples as ``sample_groups``. missing: How the values mark missing ones, for messages. matched_to: What the gene ids are matched to, for messages, such as "the gene sets". @@ -200,7 +211,13 @@ def _cube_values( fewest = integral_number(min_cells, "min_cells") if fewest < 0: raise ValueError(f"min_cells must be at least 0, got {fewest}") - filtered = checked_flag(expression_filter, "expression_filter") + if isinstance(expression_filter, Mapping): + filter_settings = filter_setting(expression_filter) + check_sample_groups({"expression_filter": filter_settings}, cube.samples) + filtered: Any = dict(filter_settings or {}) + else: + filtered = checked_flag(expression_filter, "expression_filter") + filter_settings = dict(FILTER_DEFAULTS) if filtered else None if group is None: if cube.n_groups != 1: raise ValueError( @@ -223,8 +240,17 @@ def _cube_values( ) kept = counts[rows] genes = np.ones(kept.shape[1], dtype=bool) - if filtered: - genes = filter_by_expression(kept, group=np.zeros(rows.size)) + if filter_settings is not None: + numbers = { + name: value + for name, value in filter_settings.items() + if name != SAMPLE_GROUPS + } + if SAMPLE_GROUPS in filter_settings: + labels = cube.samples[filter_settings[SAMPLE_GROUPS]][rows] + else: + labels = np.zeros(rows.size) + genes = filter_by_expression(kept, group=labels, **numbers) if not genes.any(): raise ValueError( f"no gene of group {group!r} passes filter_by_expression; pass " @@ -265,6 +291,7 @@ def _cube_values( cube.samples.take(rows), ids, settings, + cube, ) diff --git a/cytepool/_group_fits.py b/cytepool/_group_fits.py index c15320d..997f13e 100644 --- a/cytepool/_group_fits.py +++ b/cytepool/_group_fits.py @@ -14,8 +14,9 @@ column must be estimable. With random effects, those of the design are checked on the samples used. 3. Features. Features are filtered by expression with the group's design, by edgeR's - ``filterByExpr`` (Chen, Lun and Smyth 2016), and the library sizes are taken over - the features kept. + ``filterByExpr`` (Chen, Lun and Smyth 2016), or with the groups of samples that a + column of the design's samples gives (``filterByExpr(y, group = ...)``), and the + library sizes are taken over the features kept. 4. Normalization. TMM normalization factors (Robinson and Oshlack 2010), when asked. This module also checks the options these workflows share, and builds the table of @@ -63,6 +64,10 @@ } """edgeR's ``filterByExpr`` defaults.""" +SAMPLE_GROUPS = "sample_groups" +"""The setting of ``expression_filter`` that names a column of the samples whose +values group them for ``filterByExpr``, in place of the design.""" + @dataclass class GroupRecord: @@ -211,6 +216,14 @@ def prepare_group( filter_settings = settings["expression_filter"] if filter_settings is None: keep = np.ones(y.shape[1], dtype=bool) + elif SAMPLE_GROUPS in filter_settings: + numbers = { + name: value + for name, value in filter_settings.items() + if name != SAMPLE_GROUPS + } + labels = design.samples[filter_settings[SAMPLE_GROUPS]] + keep = filter_by_expression(y, group=labels[inputs.model_rows[used]], **numbers) else: keep = filter_by_expression(y, design=x_kept, **filter_settings) fit.tested = np.flatnonzero(keep) @@ -361,22 +374,35 @@ def threads_setting(value: Any) -> int | None: return number -def filter_setting(value: Any) -> dict[str, float] | None: - """The settings of ``filterByExpr``: its defaults, changed ones, or None.""" +def filter_setting(value: Any) -> dict[str, Any] | None: + """The settings of ``filterByExpr``: its defaults, changed ones, or None. + + A mapping may also name, as ``sample_groups``, a column of the samples whose + values group them; ``check_sample_groups`` checks it against the samples. + """ reject_masked(value, "expression_filter") if isinstance(value, bool | np.bool_): return dict(FILTER_DEFAULTS) if value else None if not isinstance(value, Mapping): raise TypeError( "expression_filter must be True, False or a mapping of filterByExpr " - f"settings such as {{'min_count': 5}}, got {type(value).__name__}" + f"settings such as {{'min_count': 5}} or {{'{SAMPLE_GROUPS}': " + f"'condition'}}, got {type(value).__name__}" ) - settings = dict(FILTER_DEFAULTS) + settings: dict[str, Any] = dict(FILTER_DEFAULTS) for name, number in value.items(): + if name == SAMPLE_GROUPS: + if not isinstance(number, str): + raise TypeError( + f"expression_filter[{SAMPLE_GROUPS!r}] must name a column of the " + f"samples (str), got {type(number).__name__}" + ) + settings[name] = number + continue if name not in FILTER_DEFAULTS: raise ValueError( f"expression_filter has the unknown setting {name!r}; the settings are " - f"{', '.join(FILTER_DEFAULTS)}" + f"{', '.join([*FILTER_DEFAULTS, SAMPLE_GROUPS])}" ) settings[name] = non_negative_number(number, f"expression_filter[{name!r}]") if settings["min_prop"] > 1.0: @@ -386,6 +412,41 @@ def filter_setting(value: Any) -> dict[str, float] | None: return settings +def check_sample_groups(settings: Mapping[str, Any], samples: Table) -> None: + """Refuse a column of ``sample_groups`` that the samples do not have, or in which + a sample has no value. + + Raises: + KeyError: If ``samples`` has no such column. + ValueError: If a value of the column is missing. + """ + filter_settings = settings["expression_filter"] + if filter_settings is None or SAMPLE_GROUPS not in filter_settings: + return + name = filter_settings[SAMPLE_GROUPS] + if name not in samples: + raise KeyError( + f"expression_filter[{SAMPLE_GROUPS!r}] names {name!r}, which is not a " + f"column of the samples; their columns are: {listing(list(samples.columns))}" + ) + values = samples[name].tolist() + missing = [ + position + for position, value in enumerate(values) + if value is None or value != value + ] + if missing: + where = ( + f"sample {samples['sample_id'][missing[0]]!r}" + if "sample_id" in samples + else f"the sample in row {missing[0]}" + ) + raise ValueError( + f"expression_filter[{SAMPLE_GROUPS!r}] names {name!r}, which is missing for " + f"{where}; every sample needs a group for the filter" + ) + + def normalization_setting(value: Any) -> str | None: """The normalization: "tmm" or None.""" if value is None or (isinstance(value, str) and value == "tmm"): diff --git a/cytepool/_messages.py b/cytepool/_messages.py index 4d63e47..41d7919 100644 --- a/cytepool/_messages.py +++ b/cytepool/_messages.py @@ -1,7 +1,10 @@ -"""Text in messages and reprs: lists of ids and names, hints, ranges of values.""" +"""Text in messages and reprs: lists of ids and names, hints, ranges of values, and +lines that fit the width of a page.""" import difflib import os +import re +import textwrap from collections.abc import Sequence from typing import Any @@ -10,6 +13,17 @@ LISTED = 8 """The most items a message names before it says how many more there are.""" +WIDTH = 80 +"""The most characters in a line of a repr or a printed record, as pages show them.""" + +KEEP_TOGETHER = "\ue000" +"""A space at which :func:`fitted_lines` does not break a line, such as the one in +``counts (uint32)``; the text it returns has a plain space there.""" + +_NUMBERED = re.compile(r"\d+\. ") +# A line that begins with a short key and a colon, such as " layers: ...". +_KEYED = re.compile(r" *[^\s:][^:]{0,29}: ") + PACKAGE_DIRECTORY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "") """The package's directory, ending in a separator: warnings skip the files under it, so that a warning is attributed to the first caller outside the package.""" @@ -39,6 +53,54 @@ def close_matches(name: str, candidates: tuple[str, ...] | list[str]) -> str: return " (did you mean " + " or ".join(repr(match) for match in found) + "?)" +def fitted_lines(text: str, width: int = WIDTH) -> str: + """Text whose lines are at most ``width`` characters, broken between words. + + A broken line continues below the text after its key, as in ``layers: ...``, + or after the number of a numbered line (``1. ...``), and otherwise, or where its + longest word would not fit there, four spaces deeper than it began. A word + longer than a line stays whole, and so do words joined by ``KEEP_TOGETHER``; a + fingerprint, 71 characters, fits on a line of its own. + """ + lines = [] + for line in text.split("\n"): + if len(line) <= width: + lines.append(line.replace(KEEP_TOGETHER, " ")) + continue + body = line.lstrip(" ") + indent = line[: len(line) - len(body)] + numbered = _NUMBERED.match(body) + keyed = _KEYED.match(line) + longest = max(len(word) for word in line.split()) + if numbered: + hanging = indent + " " * numbered.end() + elif keyed and keyed.end() <= width // 2: + hanging = " " * keyed.end() + else: + hanging = indent + " " + if len(hanging) + longest > width: + hanging = indent + " " + lines.extend( + part.replace(KEEP_TOGETHER, " ") + for part in textwrap.wrap( + line, + width=width, + subsequent_indent=hanging, + break_long_words=False, + break_on_hyphens=False, + ) + ) + return "\n".join(lines) + + +def fitted_message(text: str, width: int = WIDTH) -> str: + """A message, such as a warning's, broken into lines of at most ``width`` + characters between words.""" + return "\n".join( + textwrap.wrap(text, width=width, break_long_words=False, break_on_hyphens=False) + ) + + def value_range(values: float | np.ndarray) -> str: """A value, or the range of the finite values of an array, as reprs show them.""" if isinstance(values, float): diff --git a/cytepool/activity.py b/cytepool/activity.py index 4b72a2a..b9b259d 100644 --- a/cytepool/activity.py +++ b/cytepool/activity.py @@ -127,6 +127,12 @@ import numpy.typing as npt from numba import prange +from ._analysis_records import ( + keep_provenance, + provenance_of, + provenance_text, + restore_provenance, +) from ._columns import is_data_frame, text_column from ._expression_values import MIN_CELLS, expression_values from ._jit import by_chunks, jit, thread_limit @@ -140,6 +146,7 @@ random_generator, ) from ._ranked_genes import ranked_genes +from .cube import Cube from .differential_expression import DifferentialExpressionResult from .networks import Network from .stats.distributions import t_sf @@ -199,11 +206,41 @@ class Activities: method: str settings: Mapping[str, Any] + def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: + # The settings are a read-only view, which pickle cannot write: a dict + # travels in their place, and the provenance kept outside the fields with it. + return ( + _restored_activities, + ( + self.scores, + self.estimates, + self.p_values, + self.adjusted_p_values, + self.n_targets, + self.profiles, + self.network, + self.method, + dict(self.settings), + provenance_text(self), + ), + ) + @property def sources(self) -> tuple[str, ...]: """The sources scored, in the order of the columns.""" return self.network.sources + @property + def provenance(self) -> dict[str, Any] | None: + """A JSON-serialisable record of what produced the activities of a cube's + group, as a new dict: the method, the CytePool, numpy, numba and Python + versions, the cube's fingerprint, the digests it is built from and its + provenance (``"cube"``), the layer read and the settings; None for + activities of values given as an array, or of statistics, whose result + keeps its own record. The cube's record costs what it costs for + :func:`~cytepool.differential_expression.limma_voom` ("Provenance").""" + return provenance_of(self) + def table(self) -> Table: """Return the activities as a table with one row per source and profile. @@ -235,6 +272,33 @@ def __repr__(self) -> str: ) +def _restored_activities( + scores: FloatArray, + estimates: FloatArray, + p_values: FloatArray, + adjusted_p_values: FloatArray, + n_targets: IntArray, + profiles: Table, + network: Network, + method: str, + settings: dict[str, Any], + provenance: str | None, +) -> Activities: + """Activities unpickled: read-only again, with their provenance.""" + restored = Activities( + read_only(np.asarray(scores)), + read_only(np.asarray(estimates)), + read_only(np.asarray(p_values)), + read_only(np.asarray(adjusted_p_values)), + read_only(np.asarray(n_targets)), + profiles, + network, + method, + MappingProxyType(settings), + ) + return restore_provenance(restored, provenance) + + class _Profiles(NamedTuple): """The values scored, profiles x genes, with their genes and profiles.""" @@ -242,6 +306,7 @@ class _Profiles(NamedTuple): gene_ids: list[str | None] profiles: Table settings: dict[str, Any] + cube: Cube | None = None # the cube whose group was read class _Edges(NamedTuple): @@ -263,7 +328,7 @@ def ulm( group: str | None = None, contrast: str | None = None, min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, id_column: str = "feature_id", statistic_column: str = "t", min_targets: int = _MIN_TARGETS, @@ -307,7 +372,11 @@ def ulm( scored, at least 0, as for :func:`~cytepool.differential_expression.limma_voom`. expression_filter: For a cube, whether to score only the genes that - :func:`~cytepool.normalization.filter_by_expression` keeps. + :func:`~cytepool.normalization.filter_by_expression` keeps, with the + samples as one group; or a mapping of its settings, which may name a + column of the cube's samples whose values group them, such as + ``{"sample_groups": "condition"}``, as + :func:`~cytepool.differential_expression.limma_voom` takes it. id_column: For a differential-expression result or a table, the column of gene ids, such as ``"feature_id"`` or ``"symbol"``. statistic_column: For a differential-expression result or a table, the @@ -392,7 +461,7 @@ def mlm( group: str | None = None, contrast: str | None = None, min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, id_column: str = "feature_id", statistic_column: str = "t", min_targets: int = _MIN_TARGETS, @@ -494,7 +563,7 @@ def weighted_aggregate( group: str | None = None, contrast: str | None = None, min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, id_column: str = "feature_id", statistic_column: str = "t", min_targets: int = _MIN_TARGETS, @@ -647,6 +716,7 @@ def _prepared( list(ids), profiles.profiles, profiles.settings, + profiles.cube, ) return kept_profiles, graph, edges, smallest @@ -770,7 +840,11 @@ def _profiles( ids = samples["sample_id"] table = Table({_PROFILE_ID: ids, **samples.to_dict()}) return _Profiles( - expression.values, expression.gene_ids, table, dict(expression.settings) + expression.values, + expression.gene_ids, + table, + dict(expression.settings), + expression.cube, ) @@ -933,7 +1007,7 @@ def _activities( p = p_values[:, scored] adjusted = adjust_p_values(p, axis=1) if p.size else p.copy() settings = {**options, **profiles.settings} - return Activities( + result = Activities( read_only(np.ascontiguousarray(scores[:, scored])), read_only(np.ascontiguousarray(estimates[:, scored])), read_only(np.ascontiguousarray(p)), @@ -944,6 +1018,9 @@ def _activities( method, MappingProxyType(settings), ) + if profiles.cube is not None: + keep_provenance(result, method, profiles.cube, settings) + return result def _two_sided(t_values: FloatArray, df: FloatArray) -> FloatArray: diff --git a/cytepool/composition.py b/cytepool/composition.py index 3a18da2..314a87b 100644 --- a/cytepool/composition.py +++ b/cytepool/composition.py @@ -125,11 +125,12 @@ cube_record, design_record, matched_samples, + only_key, software_versions, ) from ._columns import is_data_frame, text_column from ._masked_arrays import reject_masked, unmasked_array -from ._messages import listing, quoted +from ._messages import fitted_lines, listing, quoted from ._options import checked_choice, checked_flag from ._summation import accurate_mean from .cube import Cube @@ -358,16 +359,21 @@ def provenance(self) -> dict[str, Any]: record: dict[str, Any] = json.loads(self._record) return record - def table(self, contrast: str) -> Table: + def table(self, contrast: str | None = None) -> Table: """Return the table of one contrast. Args: - contrast: A contrast name. + contrast: A contrast name; it may be left out when the result tests one. Raises: + ValueError: If ``contrast`` is left out and the result tests several, or + none (an F-test alone, which ``f_test`` holds). KeyError: If the contrast was not tested; the message lists those that were. """ + contrast = only_key( + contrast, list(self._contrasts.names), "contrast", "contrasts" + ) found = self._tables.get(contrast) if found is None: raise KeyError( @@ -382,16 +388,16 @@ def __repr__(self) -> str: used = len(record["samples"]) lines = [ f"CompositionResult (propeller, {record['settings']['transform']}): " - f"{tested} of {len(self._summary)} groups tested, {used} of " - f"{len(self._samples)} samples used" + f"{tested:,} of {len(self._summary):,} groups tested, {used:,} of " + f"{len(self._samples):,} samples used" ] if len(self._contrasts): lines.append(" t-tests: " + ", ".join(self._contrasts.names)) if record["f_test"] is not None: factor = record["f_test"]["factor"] levels = record["f_test"]["levels"] - lines.append(f" F-test across the {len(levels)} levels of {factor}") - return "\n".join(lines) + lines.append(f" F-test across the {len(levels):,} levels of {factor}") + return fitted_lines("\n".join(lines)) def propeller( diff --git a/cytepool/cube/collection.py b/cytepool/cube/collection.py index 53d87da..821ca71 100644 --- a/cytepool/cube/collection.py +++ b/cytepool/cube/collection.py @@ -29,7 +29,7 @@ from .. import __version__ from .._columns import text_column, values_equal from .._masked_arrays import reject_masked -from .._messages import close_matches, listing, quoted +from .._messages import close_matches, fitted_lines, listing, quoted from ..table import Table from ._axes import INT64_MAX, selected_positions from .cube import LAYER_NAMES, Cube @@ -100,13 +100,16 @@ class CubeCollection: (Diehl et al. 2016), when every study's group table has that column, and ``group_id`` otherwise. ``group_mapping`` gives the aligned id of some of a study's groups instead, or None to leave a group out. Each aligned group is - named by its aligned id, and groups of one study with the same aligned id are - merged: their layers and cell numbers are summed, exactly, as - ``Cube.regroup`` sums them. ``group_members`` lists the groups of each study - under their aligned ids. ``groups`` has ``group_id``, the aligned id, and - every other column of any study's group table: a group keeps a column's - value where the studies that have the column agree on it for every member, - and has a missing value otherwise. + named by its aligned id, or by the name ``group_names`` gives it, such as + ``{"CL:0001054": "CD14 monocytes"}`` for groups aligned by their Cell Ontology + ids, and groups of one study with the same aligned id are merged: their + layers and cell numbers are summed, exactly, as ``Cube.regroup`` sums them. + ``group_members`` lists the groups of each study under their aligned ids. + ``groups`` has ``group_id``, the aligned id or its name, and every other + column of any study's group table: a group keeps a column's value where the + studies that have the column agree on it for every member, and has a missing + value otherwise. With ``group_names``, the column ``align_groups_by`` holds + each group's aligned id, unless the groups are aligned by ``group_id``. Analyses of each study: ``aligned_cube(study)`` is the study's cube on the collection's axes: its @@ -151,6 +154,10 @@ class CubeCollection: take the place of those groups' values of ``align_groups_by``; None leaves a group out. Groups of one study given the same aligned id are merged. + group_names: Aligned id to the name that becomes the group's id, such as a + cell type's name for its Cell Ontology id, for some or all of the + aligned groups; the others keep their aligned ids. Each name must differ + from every other group's id. within_study: Sample columns whose values mean something only inside their study, such as donor ids, written ``study::value`` as sample ids are. @@ -158,13 +165,16 @@ class CubeCollection: TypeError: If an argument has the wrong type, a column of the sample or group tables holds different kinds of values in different studies, a column of ``within_study`` holds neither text nor integers, or - ``group_mapping`` or ``within_study`` is or holds a numpy masked array. + ``group_mapping``, ``group_names`` or ``within_study`` is or holds a + numpy masked array. ValueError: If there is no study, a study name is empty or holds ``::``, a group has no value of ``align_groups_by`` and no aligned id, a study has - no group or measured no feature, or a study shares no feature, or no - group, with any other study. + no group or measured no feature, a study shares no feature, or no + group, with any other study, or a name of ``group_names`` is empty or + the id of another group. KeyError: If ``group_mapping`` names a study or a group that is not there, - or ``within_study`` or ``align_groups_by`` a column that no study has. + ``group_names`` an aligned id that no study has, or ``within_study`` or + ``align_groups_by`` a column that no study has. Example: >>> import numpy as np @@ -222,6 +232,7 @@ def __init__( *, align_groups_by: str | None = None, group_mapping: Mapping[str, Mapping[str, str | None]] | None = None, + group_names: Mapping[str, str] | None = None, within_study: str | Sequence[str] = (), ) -> None: studies = _checked_cubes(cubes) @@ -233,6 +244,14 @@ def __init__( study: _aligned_groups(study, cube, by, mapping.get(study, {})) for study, cube in given.items() } + names = _checked_group_names(group_names, members) + if names: + members = { + study: { + names.get(aligned, aligned): ids for aligned, ids in groups.items() + } + for study, groups in members.items() + } group_ids = list( dict.fromkeys(group for study in studies for group in members[study]) ) @@ -252,11 +271,15 @@ def __init__( if len(studies) > 1: _check_shared_features(studies, feature_ids, measured) _check_shared_groups(studies, members, by) - settings = { + settings: dict[str, Any] = { "cytepool_version": __version__, "align_groups_by": by, "group_mapping": {study: dict(groups) for study, groups in mapping.items()} or None, + } + if names: + settings["group_names"] = names + settings |= { "within_study": within, "groups": { study: {aligned: list(ids) for aligned, ids in members[study].items()} @@ -391,8 +414,9 @@ def provenance(self) -> dict[str, Any]: It holds ``studies``: each study's cube, by study name in order, with its ``fingerprint`` and its own ``provenance``; ``alignment``: the version of CytePool that aligned them, ``align_groups_by``, ``group_mapping``, - ``within_study`` and ``groups``, each study's groups under their aligned - ids when the collection was made; and ``operations``: each selection since, + ``group_names`` (when given), ``within_study`` and ``groups``, each study's + groups under their aligned ids when the collection was made; and + ``operations``: each selection since, with the studies, groups and features it kept (null for an axis given as None). The fingerprints cost what ``Cube.fingerprint`` costs: nothing for a cube file, which stores them, and a pass over the values of a cube in memory @@ -439,7 +463,7 @@ def __repr__(self) -> str: f" in every study: {shared_groups:,} groups, {shared_features:,} " "features" ) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) # Each study on the collection's axes. @@ -451,7 +475,9 @@ def aligned_cube(self, study: str) -> Cube: the study's own samples with their own ids. It is derived from the cube as given with ``Cube.select`` and ``Cube.regroup``, whose records its provenance holds; a cube that needs neither is returned as it is. A lazy cube, such as - one read with ``read_cube``, stays lazy; a cube in memory is copied. + one read with ``read_cube``, stays lazy; a cube in memory is copied. Integer + layers keep their dtype, such as uint32 counts, unless groups of the study are + merged, which sums them in int64. Args: study: A study name. @@ -684,6 +710,11 @@ def stack( for study in self._studies }, "align_groups_by": settings["align_groups_by"], + **( + {"group_names": settings["group_names"]} + if "group_names" in settings + else {} + ), "within_study": settings["within_study"], "layers": names, } @@ -736,7 +767,8 @@ def _assemble( operations: tuple[str, ...], ) -> None: """Build a collection's tables from its aligned parts and set its state.""" - within = json.loads(settings)["within_study"] + alignment = json.loads(settings) + within = alignment["within_study"] measured = np.array(measured, dtype=bool) # a copy the collection owns measured.flags.writeable = False # Each study's aligned groups in the collection's order. @@ -755,7 +787,11 @@ def _assemble( members, measured, _sample_table(studies, cubes, within), - _group_table(studies, cubes, members, group_ids), + _named_groups( + _group_table(studies, cubes, members, group_ids), + alignment["align_groups_by"], + alignment.get("group_names"), + ), _feature_table(cubes, feature_ids), settings, operations, @@ -958,6 +994,61 @@ def _checked_group_mapping( return checked +def _checked_group_names( + value: Any, members: dict[str, dict[str, list[str]]] +) -> dict[str, str]: + """The names of the aligned groups, by aligned id; empty for None.""" + if value is None: + return {} + if not isinstance(value, Mapping): + raise TypeError( + "group_names must map aligned group ids to names, such as " + f"{{'CL:0001054': 'CD14 monocytes'}}, got {type(value).__name__}" + ) + reject_masked(value, "group_names") + aligned = list(dict.fromkeys(a for groups in members.values() for a in groups)) + names: dict[str, str] = {} + for key, name in value.items(): + if not isinstance(key, str): + raise TypeError( + f"group_names must be keyed by aligned group ids (str), got " + f"{type(key).__name__} {key!r}" + ) + if key not in aligned: + raise KeyError( + f"group_names names the aligned group {key!r}, which no study has; the " + f"aligned groups are: {quoted(aligned)}" + close_matches(key, aligned) + ) + if not isinstance(name, str): + raise TypeError( + f"group_names[{key!r}] must be a name (str), got {type(name).__name__}" + ) + if not name: + raise ValueError(f"group_names[{key!r}] is empty; names are non-empty") + names[key] = name + taken: dict[str, str] = {} + for key in aligned: + name = names.get(key, key) + if name in taken: + raise ValueError( + f"the aligned groups {taken[name]!r} and {key!r} would both be named " + f"{name!r}; give each group a name of its own, and none the id of " + "another group" + ) + taken[name] = key + return names + + +def _named_groups(table: Table, by: str, names: dict[str, str] | None) -> Table: + """A collection's groups table whose aligned column holds each group's aligned + id, when its groups are named; else the table as it is.""" + if not names or by == "group_id": + return table + aligned = {name: key for key, name in names.items()} + ids = [aligned.get(group, group) for group in table["group_id"].tolist()] + return table.with_columns({by: text_column(ids)}) + + def _alignment_column(value: Any, cubes: dict[str, Cube]) -> str: if value is None: if all(_ONTOLOGY_COLUMN in cube.groups for cube in cubes.values()): diff --git a/cytepool/cube/cube.py b/cytepool/cube/cube.py index 24742c9..d5bc43f 100644 --- a/cytepool/cube/cube.py +++ b/cytepool/cube/cube.py @@ -9,6 +9,7 @@ from .._columns import values_equal, with_missing from .._masked_arrays import reject_masked, reject_masked_table, unmasked_array +from .._messages import KEEP_TOGETHER, fitted_lines, quoted from ..table import Table from ._axes import ( INT64_MAX, @@ -368,7 +369,7 @@ def __repr__(self) -> str: described = [] for name, stored in self._layers.items(): lazy = "" if isinstance(stored, np.ndarray) else ", lazy" - described.append(f"{name} ({stored.dtype}{lazy})") + described.append(f"{name}{KEEP_TOGETHER}({stored.dtype}{lazy})") lines.append(f" layers: {', '.join(described)}") if self._n_cells is None: lines.append(" cells per entry: not recorded") @@ -386,7 +387,7 @@ def __repr__(self) -> str: ("features", self._features), ): lines.append(f" {label}: {', '.join(table.columns)}") - return "\n".join(lines) + return fitted_lines("\n".join(lines)) # Layers and derived statistics. @@ -681,7 +682,8 @@ def history(self) -> str: ``cytepool.cube.provenance``): the caller's source record, how the cube was built, and each operation in order, with the fingerprint of the cube it was applied to. A last line gives the cube's own fingerprint when it is known - without reading lazy layers (see ``fingerprint()``). + without reading lazy layers (see ``fingerprint()``). Lines are at most 80 + characters, a longer item continuing on the next line. """ lines = [describe_provenance(self.provenance)] fingerprint = self._known_fingerprint() @@ -692,7 +694,7 @@ def history(self) -> str: ) else: lines.append(f"Fingerprint: {fingerprint}") - return "\n".join(lines) + return fitted_lines("\n".join(lines)) # Deriving cubes. @@ -776,7 +778,8 @@ def regroup(self, mapping: Mapping[str, Sequence[str] | str]) -> "Cube": position of its member that comes first in the current group order. In the group table, a merged row keeps a column's value where all members agree and is missing otherwise; an integer or boolean column that needs a missing - value becomes float64 with NaN. Integer layers of the result are int64. The + value becomes float64 with NaN. Integer layers of the result are int64 when + groups are merged, and keep their dtype when groups are only renamed. The provenance record gives each merged or renamed group with its members, in the current group order, and names this cube by its fingerprint (see "Fingerprint and provenance" in ``Cube``). @@ -896,57 +899,174 @@ def regroup(self, mapping: Mapping[str, Sequence[str] | str]) -> "Cube": sums=True, ) - def collapse_samples(self, by: str) -> "Cube": + def with_columns( + self, *, samples: Any = None, groups: Any = None, features: Any = None + ) -> "Cube": + """Return a cube with columns added to, or replaced in, its tables. + + Use it to give the samples a variable of a design, or a set of samples to + pool with :meth:`collapse_samples`: + ``cube.with_columns(samples={"pool": labels}).collapse_samples("pool")``. A + replaced column keeps its place, and new columns come last. The layers are + kept as they are: a lazy cube stays lazy and reads nothing, and the digests + of its groups are kept, while the fingerprint changes with the tables. The + provenance record lists the columns added and those replaced on each axis, + null for an axis given as None, and names this cube by its fingerprint (see + "Fingerprint and provenance" in ``Cube``); the values are those of the new + tables, which the new cube's fingerprint covers. + + Args: + samples: Column name to one value per sample, as a mapping or a Table, + in the cube's order of the samples; None changes nothing. + groups: Column name to one value per group, likewise. + features: Column name to one value per feature, likewise. + + Raises: + TypeError: If an argument is neither a mapping nor a Table, a column + holds values of a type that cube tables do not take, or is or holds + a numpy masked array. + ValueError: If a column has the wrong length, or names the axis's id + column (``sample_id``, ``group_id`` or ``feature_id``), which ids + select and ``regroup`` and ``collapse_samples`` derive. + """ + tables = { + "samples": self._samples, + "groups": self._groups, + "features": self._features, + } + changed: dict[str, dict[str, list[str]]] = {} + for axis, given, id_column in ( + ("samples", samples, "sample_id"), + ("groups", groups, "group_id"), + ("features", features, "feature_id"), + ): + if given is None: + continue + if isinstance(given, Table): + columns = given.to_dict() + elif isinstance(given, Mapping): + reject_masked(given, axis, missing="None or NaN") + columns = dict(given) + else: + raise TypeError( + f"{axis} must be a mapping of column names to values, or a Table, " + f"got {type(given).__name__}" + ) + if not columns: + continue + if id_column in columns: + raise ValueError( + f"with_columns() adds or replaces columns, not the ids: {axis} " + f"names {id_column!r}; select() chooses {axis} by id" + ) + current = tables[axis] + try: + updated = current.with_columns(columns) + except (TypeError, ValueError) as error: + error.add_note(f"(while adding columns to the {axis} table)") + raise + tables[axis] = checked_axis_table(updated, axis, id_column)[0] + changed[axis] = { + "added": [name for name in columns if name not in current], + "replaced": [name for name in columns if name in current], + } + if not changed: + return self + operation: dict[str, Any] = { + "operation": "with_columns", + "input": self._known_fingerprint(), + } + operation |= {axis: changed.get(axis) for axis in tables} + digests = _Digests( + { + part: digest + for part, digest in self._digests.parts.items() + if part not in changed + }, + {name: list(kept) for name, kept in self._digests.layers.items()}, + ) + return _assemble( + dict(self._layers), + tables["samples"], + tables["groups"], + tables["features"], + self._n_cells, + self._normalization, + add_record(self._provenance, operation), + digests, + ) + + def collapse_samples(self, by: str | Sequence[str] | None = None) -> "Cube": """Return a cube with the samples that share a value of a column summed. Use it to pool, for example, the tissues of one donor. The new ``sample_id`` - is the shared value, in the order the values first appear. Sample columns - that are constant within every pooled set are kept and the others are - dropped. The column ``n_pooled_samples`` holds the number of original - samples behind each new sample and comes last; if it already exists, it - keeps its place and is summed, so collapsing twice counts the original - samples. Integer layers of the result are int64. The provenance record gives - each new sample with the ids of the samples it sums, in the current order, - and names this cube by its fingerprint (see "Fingerprint and provenance" in - ``Cube``). + is the shared value, in the order the values first appear; with several + columns, the values joined by ``_``, such as ``D1_stim``; without columns, + ``all``, a single sample that pools every sample, whose values are those of + each group's cells together, as :func:`~cytepool.plotting.plot_dotplot` + pools them. Sample columns that are constant within every pooled set are + kept and the others are dropped. The column ``n_pooled_samples`` holds the + number of original samples behind each new sample and comes last; if it + already exists, it keeps its place and is summed, so collapsing twice counts + the original samples. Integer layers of the result are int64 when samples + are pooled, and keep their dtype when every new sample is one sample. The + provenance record gives the columns (``by``), each new sample with the ids of + the samples it sums, in the current order, and names this cube by its + fingerprint (see "Fingerprint and provenance" in ``Cube``). Args: - by: A text or integer sample column without missing values. + by: A text or integer sample column without missing values, a list of + them, or None to pool every sample. Raises: KeyError: If there is no such sample column. - TypeError: If the column is not text or integer. - ValueError: If the column has a missing or empty value, or an existing - ``n_pooled_samples`` column does not hold non-negative integers. + TypeError: If ``by`` is none of these, or a column is not text or + integer. + ValueError: If a column has a missing or empty value, ``by`` is an empty + list or names a column twice, two combinations of values join to + the same id, or an existing ``n_pooled_samples`` column does not + hold non-negative integers. OverflowError: If a pooled ``n_cells``, ``n_pooled_samples`` or value of an in-memory layer does not fit (see "Sums" in ``Cube``). A lazy layer raises it when the group is read. """ - if not isinstance(by, str): - raise TypeError(f"by must be a sample column name, got {type(by).__name__}") - if by not in self._samples: - raise KeyError( - f"no sample column named {by!r}; columns are: " - f"{', '.join(self._samples.columns)}" - ) - column = self._samples[by] - if column.size == 0: # no samples: any dtype will do, as for [] (float64) - keys: list[str] = [] - elif column.dtype.kind == "O": - keys = column.tolist() - sample_ids = self._samples["sample_id"] - for position, key in enumerate(keys): - if key is None or key == "": + if not isinstance(by, str) and by is not None: + reject_masked(by, "by") + if isinstance(by, str): + keys = self._pooling_keys(by) + elif by is None: + keys = ["all"] * self.n_samples + elif isinstance(by, Sequence | np.ndarray) and not isinstance(by, bytes): + names = list(by) + if not names: + raise ValueError( + "by names no sample column; give one or more, or None to pool " + "every sample" + ) + for name in names: + if not isinstance(name, str): + raise TypeError( + f"by must name sample columns (str), got {type(name).__name__} " + f"{name!r}" + ) + if names.count(name) > 1: + raise ValueError(f"by names the sample column {name!r} twice") + parts = [self._pooling_keys(name) for name in names] + combinations = list(zip(*parts, strict=True)) + keys = ["_".join(combination) for combination in combinations] + first: dict[str, tuple[str, ...]] = {} + for key, combination in zip(keys, combinations, strict=True): + if first.setdefault(key, combination) != combination: raise ValueError( - f"sample column {by!r} is missing or empty for sample " - f"{sample_ids[position]!r}; every sample needs a value" + f"the values {first[key]!r} and {combination!r} of the sample " + f"columns {quoted(names)} both join to the id {key!r}; give " + "the samples a column of their own pooled ids with " + "with_columns(samples=...), and pool by it" ) - elif column.dtype.kind in "iu": - keys = [str(key) for key in column.tolist()] else: raise TypeError( - "collapse_samples() pools by a text or integer sample column; " - f"{by!r} has dtype {column.dtype}" + "by must be a sample column name, a list of them, or None to pool " + f"every sample, got {type(by).__name__}" ) members: dict[str, list[int]] = {} for position, key in enumerate(keys): @@ -1018,7 +1138,7 @@ def collapse_samples(self, by: str) -> "Cube": original_ids = self._samples["sample_id"] record = { "operation": "collapse_samples", - "by": by, + "by": by if by is None or isinstance(by, str) else list(by), "membership": { new_id: [original_ids[position] for position in positions] for new_id, positions in members.items() @@ -1038,6 +1158,33 @@ def collapse_samples(self, by: str) -> "Cube": # Internals. + def _pooling_keys(self, by: str) -> list[str]: + """The value of a sample column for every sample, as text, for pooling.""" + if by not in self._samples: + raise KeyError( + f"no sample column named {by!r}; columns are: " + f"{', '.join(self._samples.columns)}" + ) + column = self._samples[by] + if column.size == 0: # no samples: any dtype will do, as for [] (float64) + return [] + if column.dtype.kind == "O": + keys: list[str] = column.tolist() + sample_ids = self._samples["sample_id"] + for position, key in enumerate(keys): + if key is None or key == "": + raise ValueError( + f"sample column {by!r} is missing or empty for sample " + f"{sample_ids[position]!r}; every sample needs a value" + ) + return keys + if column.dtype.kind in "iu": + return [str(key) for key in column.tolist()] + raise TypeError( + "collapse_samples() pools by a text or integer sample column; " + f"{by!r} has dtype {column.dtype}" + ) + def _derive( self, samples: Table, @@ -1070,11 +1217,21 @@ def _derive( target=(groups["group_id"], samples["sample_id"], features["feature_id"]), ) shape = (len(groups), len(samples), len(features)) + # Integer sums are exact in int64; an operation that sums no two entries, + # such as a regroup that only renames groups, keeps the integer dtype. + summed = sums and ( + any(members.size > 1 for members in group_sets) + or ( + sample_starts is not None + and sample_order is not None + and sample_starts.size < sample_order.size + ) + ) layers: dict[str, np.ndarray | _LazyLayer] = {} digests = _Digests() for name, stored in self._layers.items(): dtype = stored.dtype - if sums and dtype.kind in "iu": + if summed and dtype.kind in "iu": dtype = np.dtype(np.int64) if isinstance(stored, np.ndarray): layers[name] = plan.apply(name, stored, shape, dtype) diff --git a/cytepool/cube/provenance.py b/cytepool/cube/provenance.py index da81dd1..fed6666 100644 --- a/cytepool/cube/provenance.py +++ b/cytepool/cube/provenance.py @@ -100,8 +100,13 @@ - ``regroup``: ``membership``, the id of each merged or renamed group with the ids of the groups it sums, in the input's order. The groups not listed are kept as they are. - - ``collapse_samples``: ``by``, the sample column, and ``membership``, the id of - each new sample with the ids of the samples it sums, in the input's order. + - ``collapse_samples``: ``by``, the sample column, a list of them, or null when + every sample was pooled into one, and ``membership``, the id of each new + sample with the ids of the samples it sums, in the input's order. + - ``with_columns``: ``samples``, ``groups`` and ``features``, each with the + names of the columns ``added`` and those ``replaced`` on that axis, or null + for an axis that was given as None. The values are those of the cube's + tables, which its fingerprint covers. - ``from_anndata`` and ``from_mudata``: the import of an AnnData or MuData that CytePool exported, whose provenance the cube continues. ``input`` is the fingerprint that the export stored, which the cube's own fingerprint equals @@ -113,6 +118,7 @@ from collections.abc import Mapping from typing import Any +from .._messages import fitted_lines, quoted from ._provenance_records import provenance_as_texts, provenance_from_texts __all__ = ["describe_provenance"] @@ -160,7 +166,8 @@ def describe_provenance(provenance: Mapping[str, Any]) -> str: a cube that a result keeps. Returns: - Text with one item per line, for printing. + Text with one item per line, for printing, in lines of at most 80 + characters: a longer item continues on the next line, indented. Raises: TypeError: If ``provenance`` is not a mapping, holds a value JSON cannot @@ -196,7 +203,7 @@ def describe_provenance(provenance: Mapping[str, Any]) -> str: lines.append(f"{key}: {_json(record[key])}") if references: lines.append(_REFERENCES) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def _source_lines(source: Any) -> list[str]: @@ -334,8 +341,15 @@ def _operation_lines(number: int, operation: Any) -> list[str]: fields = dict(operation) name = fields.pop("operation", None) header = f"{number}. {name if isinstance(name, str) else _json(name)}" - if name == "collapse_samples" and isinstance(fields.get("by"), str): - header += f" by {fields.pop('by')!r}" + if name == "collapse_samples" and "by" in fields: + by = fields["by"] + if isinstance(by, str): + header += f" by {fields.pop('by')!r}" + elif _is_text_list(by) and by: + header += f" by {quoted(fields.pop('by'))}" + elif by is None: + del fields["by"] + header += " of every sample into one" if "input" in fields: found = fields.pop("input") named = found if isinstance(found, str) else _json(found) @@ -362,6 +376,19 @@ def _operation_lines(number: int, operation: Any) -> list[str]: lines.append(f" {axis}: {_listing(kept, ', ')}") else: lines.append(f" {axis}: {_json(kept)}") + if name == "with_columns": + for axis in ("samples", "groups", "features"): + change = fields.get(axis, False) + if change is None: + del fields[axis] + elif _is_column_change(change): + del fields[axis] + parts = [ + f"{kind} {', '.join(change[kind])}" + for kind in ("added", "replaced") + if change[kind] + ] + lines.append(f" {axis}: {'; '.join(parts) or 'no column'}") if name in ("regroup", "collapse_samples") and _is_membership( fields.get("membership") ): @@ -384,6 +411,14 @@ def _is_text_list(value: Any) -> bool: return isinstance(value, list) and all(isinstance(item, str) for item in value) +def _is_column_change(value: Any) -> bool: + return ( + isinstance(value, dict) + and set(value) == {"added", "replaced"} + and all(map(_is_text_list, value.values())) + ) + + def _is_membership(value: Any) -> bool: return isinstance(value, dict) and all(map(_is_text_list, value.values())) diff --git a/cytepool/design/checks.py b/cytepool/design/checks.py index 52f2e7b..8a784ed 100644 --- a/cytepool/design/checks.py +++ b/cytepool/design/checks.py @@ -50,6 +50,14 @@ numeric_codes: a numeric covariate whose values are a few consecutive whole numbers, each shared by several samples, which is how codes for batches or plates look; as a number it enters the model as one slope. + numeric_ids: a numeric covariate whose name says ids and whose values are at + least three whole numbers that are not consecutive, each shared by several + samples, as donor ids such as 101, 107 and 1015 are; as a number it enters + the model as one slope, where ids need a group each. A name says ids when + its last word is donor, patient, subject, individual, participant, sample, + batch, plate, lane, run or id (or their plurals), as in donor_id or + subjectID, or is number, no, nr or code after one of them, as in + run_number; donor_age names an age, and n_donors a count. missing_label: a factor level such as "" or "NA" that looks like a missing value, which then forms a group of its own. similar_levels: factor levels that differ only in case or surrounding spaces, @@ -65,6 +73,7 @@ using lme4. Journal of Statistical Software 67(1), 1-48. doi:10.18637/jss.v067.i01 """ +import re import textwrap from collections.abc import Iterable, Sequence from dataclasses import dataclass @@ -73,6 +82,7 @@ import numpy as np from .._linear_algebra import RANK_TOLERANCE, column_space +from .._messages import WIDTH, fitted_lines from ..table import Table from .contrasts import Contrasts from .formula import RandomEffect @@ -105,6 +115,27 @@ ) _LISTED = 6 # items listed in a message before "and n more" _MISSING_LABELS = frozenset({"", "na", "n/a", "nan", "null", "", "nat", "?"}) +# Words that name a column of ids, words that do after one of them (run_number), +# and the words of a name: runs of letters, split where a capital starts a word +# (donorID is donor and ID), and runs of digits. +_ID_WORDS = frozenset( + { + "donor", + "patient", + "subject", + "individual", + "participant", + "sample", + "batch", + "plate", + "lane", + "run", + "id", + } +) +_ID_NUMBERS = frozenset({"number", "num", "no", "nr", "code"}) +_COUNT_WORDS = frozenset({"n", "num", "number", "count"}) +_WORDS = re.compile(r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])|[0-9]+") @dataclass(frozen=True) @@ -171,8 +202,8 @@ def __str__(self) -> str: f"{_count(self.residual_df, 'residual degree')} of freedom" ) if not self.errors and not self.warnings: - return summary + "; no problems found." - lines = [summary + "."] + return fitted_lines(summary + "; no problems found.") + lines = [fitted_lines(summary + ".")] for title, issues in (("error", self.errors), ("warning", self.warnings)): if not issues: continue @@ -181,7 +212,7 @@ def __str__(self) -> str: lines.append( textwrap.fill( f"{number}. [{issue.kind}] {issue.message}", - width=88, + width=WIDTH, initial_indent=" ", subsequent_indent=" ", break_on_hyphens=False, @@ -409,6 +440,7 @@ def _variable_checks( ) else: _numeric_codes_check(name, variable.values, distinct, warnings) + _numeric_ids_check(name, variable.values, distinct, warnings) continue counts = np.bincount(variable.codes, minlength=len(variable.levels)) observed = [level for level, count in zip(variable.levels, counts) if count] @@ -623,6 +655,53 @@ def _numeric_codes_check( ) +def _numeric_ids_check( + name: str, values: np.ndarray, distinct: np.ndarray, warnings: list[DesignIssue] +) -> None: + """Warn about whole numbers that are not consecutive in a column named as ids, + such as donor ids 101, 107 and 1015.""" + if distinct.size < 3 or not np.all(distinct == np.round(distinct)): + return + if distinct[-1] - distinct[0] + 1 == distinct.size: + return # consecutive: numeric_codes warns about them + counts = np.unique(values, return_counts=True)[1] + if np.any(counts < 2) or not _names_ids(name): + return + warnings.append( + DesignIssue( + "numeric_ids", + f"{name} holds whole numbers ({distinct.size:,} distinct values, from " + f"{int(distinct[0])} to {int(distinct[-1])}), each shared by several " + "samples, and its name says they are ids; as a number it enters the " + "model as one slope (a linear trend in the ids), not as a group for each " + "id. If the numbers label donors, batches or other groups, convert the " + "column to text so that it becomes a factor; a measurement, such as an " + "age, can ignore this warning", + ) + ) + + +def _names_ids(name: str) -> bool: + """Whether a variable's name says that it holds ids: its last word, digits + aside, names ids (donor_id, subjectID, batches), or is a number or code after a + word that does (run_number). A name that starts by counting (n_donors) does + not, nor one whose last word names something else (donor_age).""" + words = [word.lower() for word in _WORDS.findall(name) if not word.isdigit()] + if not words or (len(words) > 1 and words[0] in _COUNT_WORDS): + return False + if _is_id_word(words[-1]): + return True + return words[-1] in _ID_NUMBERS and any(map(_is_id_word, words[:-1])) + + +def _is_id_word(word: str) -> bool: + return ( + word in _ID_WORDS + or (word.endswith("s") and word[:-1] in _ID_WORDS) + or (word.endswith("es") and word[:-2] in _ID_WORDS) + ) + + def _leverage_check( variables: dict[str, _Factor | _Covariate], leverage: np.ndarray, diff --git a/cytepool/design/contrasts.py b/cytepool/design/contrasts.py index 38c4267..408f63c 100644 --- a/cytepool/design/contrasts.py +++ b/cytepool/design/contrasts.py @@ -52,7 +52,7 @@ import numpy as np from .._masked_arrays import reject_masked -from .._messages import close_matches +from .._messages import close_matches, fitted_lines from ._contrast_weights import ( is_named_contrasts, reject_masked_contrasts, @@ -173,12 +173,12 @@ def __reduce__(self) -> tuple[type["Contrasts"], tuple[Any, ...]]: return (Contrasts, (np.array(self.matrix), self.names, self.columns)) def __repr__(self) -> str: - lines = [f"Contrasts: {len(self.names)} over {len(self.columns)} columns"] + lines = [f"Contrasts: {len(self.names):,} over {len(self.columns):,} columns"] for position, name in enumerate(self.names): lines.append( f" {name}: {_describe(self.matrix[:, position], self.columns)}" ) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def make_contrasts( diff --git a/cytepool/design/design.py b/cytepool/design/design.py index 60fe07b..dc7a604 100644 --- a/cytepool/design/design.py +++ b/cytepool/design/design.py @@ -23,7 +23,7 @@ from .._columns import missing_mask from .._masked_arrays import reject_masked -from .._messages import close_matches +from .._messages import close_matches, fitted_lines from ..table import Table from .checks import DesignReport, check_design from .contrasts import Contrasts, make_contrasts @@ -265,7 +265,7 @@ def check(self) -> DesignReport: def __repr__(self) -> str: n, p = self._model.shape lines = [ - f"Design: {n} sample{'' if n == 1 else 's'} x {p} " + f"Design: {n:,} sample{'' if n == 1 else 's'} x {p:,} " f"column{'' if p == 1 else 's'}, formula {self.formula!r}", " columns: " + (", ".join(self.columns) if self.columns else "(none)"), ] @@ -273,7 +273,7 @@ def __repr__(self) -> str: lines.append(" random: " + " + ".join(str(e) for e in self._random)) if len(self._contrasts): lines.append(" contrasts: " + ", ".join(self._contrasts.names)) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def _restore(*state: Any) -> Design: diff --git a/cytepool/design/model_matrix.py b/cytepool/design/model_matrix.py index 93c1014..0e894a2 100644 --- a/cytepool/design/model_matrix.py +++ b/cytepool/design/model_matrix.py @@ -60,7 +60,7 @@ from .._columns import is_data_frame, missing_mask from .._masked_arrays import reject_masked -from .._messages import close_matches +from .._messages import close_matches, fitted_lines from ..table import Table from .formula import FormulaTerms, parse_formula, quote_name @@ -168,8 +168,8 @@ def shape(self) -> tuple[int, int]: def __repr__(self) -> str: n, p = self.shape names = ", ".join(self.columns) if self.columns else "(none)" - return ( - f"ModelMatrix: {n} sample{'' if n == 1 else 's'} x {p} " + return fitted_lines( + f"ModelMatrix: {n:,} sample{'' if n == 1 else 's'} x {p:,} " f"column{'' if p == 1 else 's'} from {self.formula!r}\n columns: {names}" ) diff --git a/cytepool/differential_expression.py b/cytepool/differential_expression.py index dcc2f4b..4014726 100644 --- a/cytepool/differential_expression.py +++ b/cytepool/differential_expression.py @@ -261,6 +261,7 @@ design_record, matched_samples, mixed_design_record, + only_key, software_versions, ) from ._columns import text_column @@ -270,6 +271,7 @@ FITTED, GroupInputs, GroupRecord, + check_sample_groups, filter_setting, group_positions, min_cells_setting, @@ -282,8 +284,8 @@ threads_setting, ) from ._jit import thread_limit -from ._masked_arrays import reject_masked -from ._messages import PACKAGE_DIRECTORY, listing, quoted +from ._masked_arrays import read_only, reject_masked +from ._messages import PACKAGE_DIRECTORY, fitted_lines, listing, quoted from ._options import ( checked_choice, checked_flag, @@ -320,7 +322,13 @@ from .stats.voom import VoomResult, _quality_weighted_voom, voom from .table import Table -__all__ = ["DifferentialExpressionResult", "dream_voom", "limma_trend", "limma_voom"] +__all__ = [ + "DifferentialExpressionResult", + "GroupFit", + "dream_voom", + "limma_trend", + "limma_voom", +] _ACROSS_GROUPS = "adjusted_p_value_across_groups" # The settings of sample quality weights: limma's defaults (arrayWeights and @@ -350,6 +358,58 @@ # number above this (variancePartition's NEWS for 1.31.16; the bound found by probing). _CONDITION_LIMIT = 1e6 _METHODS = ("limma_voom", "limma_trend", "dream_voom") +# The settings that the provenance records besides those of the call. +_RECORDED_ONLY = (*_FIXED_SETTINGS, *_DREAM_SETTINGS) + + +@dataclass(frozen=True, eq=False, repr=False) +class GroupFit: + """The fit of one group of a differential-expression result. + + :meth:`DifferentialExpressionResult.fit` computes it again from the cube and + design the result keeps, with the settings it records: the values, weights and + moderated statistics behind the group's tables, which figures such as + :func:`~cytepool.plotting.plot_mean_variance` and + :func:`~cytepool.plotting.plot_residual_variances` draw. Rows of the arrays are + the samples fitted, in the order of ``samples``, and columns the features + tested, in the order of ``features``. The arrays are read-only. + + Attributes: + group: The group's id. + samples: The samples fitted, in the order of the fit: the rows of the + design's sample table, with ``n_cells`` (when the cube records cell + numbers), ``library_size`` (over the features tested), ``norm_factor``, + and ``prior_weight`` or ``quality_weight`` when the fit used them. + These columns take the place of design columns of the same names. + features: The features tested, the rows of the cube's feature table. + log2_cpm: ``(n_samples, n_features)`` the values fitted: voom's log2 counts + per million (limma-voom and dream), or those of limma-trend, with its + prior count. + weights: voom's precision weights, ``(n_samples, n_features)``; for + limma-trend, the sample weights of the fit, ``(n_samples,)``, or None + without them. + voom: The :class:`~cytepool.stats.voom.VoomResult` of limma-voom and dream, + with the mean-variance trend; None for limma-trend. + moderated: The moderated tests of the group's estimable contrasts: a + :class:`~cytepool.stats.empirical_bayes.ModeratedFit` for limma, whose + ``fit`` holds the linear model after ``contrasts_fit``, or a + :class:`~cytepool.stats.dream.ModeratedFixedEffectTests` for dream. + """ + + group: str + samples: Table + features: Table + log2_cpm: np.ndarray + weights: np.ndarray | None + voom: VoomResult | None + moderated: Any + + def __repr__(self) -> str: + n_samples, n_features = np.shape(self.log2_cpm) + return ( + f"GroupFit(group={self.group!r}, n_samples={n_samples}, " + f"n_features={n_features})" + ) class DifferentialExpressionResult: @@ -409,18 +469,33 @@ class DifferentialExpressionResult: left out, and of groups not fitted. Built by :func:`limma_voom`, :func:`limma_trend` and :func:`dream_voom`, from the - contrasts, tables and record they computed. Immutable. + contrasts, tables and record they computed, and the cube and design they + analysed, which the result keeps (``cube`` and ``design``, the objects given, not + copies) so that :meth:`fit` can compute a group's fit again. A pickled result + carries them: a cube read from a cube file refers to its file, and a cube in + memory carries its arrays. Immutable. Raises: TypeError: If ``method`` is not a string, ``contrasts`` not a ``Contrasts``, ``summary`` or ``samples`` not a ``Table``, ``tables`` not a mapping of - (group id, contrast name) to ``Table``, or ``provenance`` not a mapping - that JSON can write. + (group id, contrast name) to ``Table``, ``provenance`` not a mapping + that JSON can write, ``cube`` not a Cube or ``design`` not a Design. ValueError: If ``method`` is not ``"limma_voom"``, ``"limma_trend"`` or - ``"dream_voom"``, or ``provenance`` holds a NaN or an infinity. + ``"dream_voom"``, ``provenance`` holds a NaN or an infinity, or only one + of ``cube`` and ``design`` is given. """ - __slots__ = ("_method", "_contrasts", "_summary", "_samples", "_tables", "_record") + __slots__ = ( + "_method", + "_contrasts", + "_summary", + "_samples", + "_tables", + "_record", + "_cube", + "_design", + "_last_fit", + ) _method: str _contrasts: Contrasts @@ -428,6 +503,9 @@ class DifferentialExpressionResult: _samples: Table _tables: Mapping[tuple[str, str], Table] _record: str + _cube: Cube | None + _design: Design | None + _last_fit: GroupFit | None # the group fitted last by fit(), kept def __init__( self, @@ -437,6 +515,9 @@ def __init__( samples: Table, tables: Mapping[tuple[str, str], Table], provenance: Mapping[str, Any], + *, + cube: Cube | None = None, + design: Design | None = None, ) -> None: if not isinstance(method, str): raise TypeError(f"method must be a string, got {type(method).__name__}") @@ -472,6 +553,17 @@ def __init__( raise TypeError( f"provenance must be a mapping, got {type(provenance).__name__}" ) + if cube is not None and not isinstance(cube, Cube): + raise TypeError(f"cube must be a Cube or None, got {type(cube).__name__}") + if design is not None and not isinstance(design, Design): + raise TypeError( + f"design must be a Design or None, got {type(design).__name__}" + ) + if (cube is None) != (design is None): + raise ValueError( + "give both the cube and the design that the result analysed, or " + "neither: fit() needs both to compute a group's fit again" + ) state = { "_method": method, "_contrasts": contrasts, @@ -480,6 +572,9 @@ def __init__( "_tables": MappingProxyType(dict(tables)), # JSON holds no arrays: json.dumps raises TypeError for one. "_record": json.dumps(provenance, allow_nan=False), + "_cube": cube, + "_design": design, + "_last_fit": None, } for name, value in state.items(): object.__setattr__(self, name, value) @@ -492,7 +587,7 @@ def __delattr__(self, name: str) -> None: def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: return ( - DifferentialExpressionResult, + _restore_result, ( self._method, self._contrasts, @@ -500,9 +595,23 @@ def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: self._samples, dict(self._tables), json.loads(self._record), + self._cube, + self._design, ), ) + @property + def cube(self) -> Cube | None: + """The cube analysed, as given to the analysis; None for a result built + without it.""" + return self._cube + + @property + def design(self) -> Design | None: + """The design analysed, as given to the analysis; None for a result built + without it.""" + return self._design + @property def method(self) -> str: """``"limma_voom"``, ``"limma_trend"`` or ``"dream_voom"``.""" @@ -582,18 +691,27 @@ def provenance(self) -> dict[str, Any]: record: dict[str, Any] = json.loads(self._record) return record - def table(self, group: str, contrast: str) -> Table: + def table(self, group: str | None = None, contrast: str | None = None) -> Table: """Return the table of one group and contrast, or F-test. Args: - group: A group id. + group: A group id; it may be left out when the result has one group. contrast: A contrast name, or the name of an F-test of - :func:`dream_voom`. + :func:`dream_voom`; it may be left out when the result tests one + contrast and no F-test. Raises: + ValueError: If a key is left out and the result has several. KeyError: If the group or contrast was not analysed, or the group was not fitted or cannot estimate the contrast; the message says why. """ + group = only_key(group, list(self.groups), "group", "groups") + contrast = only_key( + contrast, + [*self._contrasts.names, *self.f_tests], + "contrast", + "contrasts and F-tests", + ) found = self._tables.get((group, contrast)) if found is not None: return found @@ -620,13 +738,77 @@ def table(self, group: str, contrast: str) -> Table: f"{entry['not_estimable'][contrast]}" ) + def fit(self, group: str | None = None) -> GroupFit: + """Compute the fit of one group again: its values, weights and moderated tests. + + The fit is computed from the cube and design the result keeps, with the + settings it records, by the steps that computed its tables, so that it is + what the analysis computed, bit for bit, on the same machine. It takes the + time of the analysis of one group; the result keeps the group fitted last, + so a second call for it costs nothing. The values it holds take memory as + the counts of the group do. + + Args: + group: A group id; it may be left out when the result has one group. + + Returns: + The samples fitted, the features tested, the values and weights fitted, + the voom result (limma-voom and dream) and the moderated tests. + + Raises: + ValueError: If the result keeps no cube and design (it was built by hand + without them), ``group`` is left out and the result has several + groups, or the group's fit no longer gives what the result + records (a lazy cube whose source changed). + TypeError: If ``group`` is not a string. + KeyError: If the group was not analysed or not fitted. + """ + if self._cube is None or self._design is None: + raise ValueError( + "this result keeps no cube and design, so its fits cannot be computed " + "again: it was built without them. limma_voom, limma_trend and " + "dream_voom keep both; DifferentialExpressionResult takes them as cube " + "and design" + ) + name = only_key(group, list(self.groups), "group", "groups") + if not isinstance(name, str): + reject_masked(name, "group") + raise TypeError( + f"group must be a group id (str), got {type(name).__name__}" + ) + record = {entry["group_id"]: entry for entry in self.provenance["groups"]} + if name not in record: + raise KeyError( + f"no group {name!r} was analysed; groups are: " + f"{listing(list(record)) or '(none)'}" + ) + entry = record[name] + if entry["status"] != FITTED: + raise KeyError( + f"group {name!r} was not fitted ({entry['status']}): {entry['reason']}" + ) + kept = self._last_fit + if kept is not None and kept.group == name: + return kept + found = _group_fit( + self._method, + self._cube, + self._design, + self._contrasts, + self.settings, + name, + entry, + ) + object.__setattr__(self, "_last_fit", found) + return found + def __repr__(self) -> str: statuses = self._summary["status"].tolist() fitted = statuses.count(FITTED) lines = [ - f"DifferentialExpressionResult ({self._method}): {len(statuses)} " - f"group{'' if len(statuses) == 1 else 's'}, {fitted} fitted; " - f"{len(self._contrasts)} contrast" + f"DifferentialExpressionResult ({self._method}): {len(statuses):,} " + f"group{'' if len(statuses) == 1 else 's'}, {fitted:,} fitted; " + f"{len(self._contrasts):,} contrast" f"{'' if len(self._contrasts) == 1 else 's'}: " + ", ".join(self._contrasts.names), ] @@ -637,12 +819,12 @@ def __repr__(self) -> str: continue used = int(self._summary["n_samples_used"][row]) tested = int(self._summary["n_features_tested"][row]) - text = f" {group}: {used} samples, {tested} features" + text = f" {group}: {used:,} samples, {tested:,} features" missing = self._summary["not_estimable"][row] if missing: text += f"; not estimable: {missing}" lines.append(text) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def limma_voom( @@ -653,7 +835,7 @@ def limma_voom( contrasts: Mapping[str, Any] | Sequence[str] | str | None = None, min_cells: int = 10, min_counts: float = 0, - expression_filter: bool | Mapping[str, float] = True, + expression_filter: bool | Mapping[str, Any] = True, normalization: Literal["tmm"] | None = "tmm", span: float | None = None, prior_weights: Literal["n_cells"] | None = None, @@ -728,7 +910,13 @@ def limma_voom( ``min_prop=0.7``), using the group's design, as the edgeR and limma User's Guides do; a mapping with some of these settings to change them (see :func:`~cytepool.normalization.filter_by_expression`); or False to - test every feature. + test every feature. The mapping may also name, as ``"sample_groups"``, + a column of the design's samples, such as ``{"sample_groups": + "condition"}``, whose values group the samples for the filter in place + of the design (``filterByExpr(y, group = ...)``): analyses of the same + samples with different designs, such as :func:`limma_voom` with + ``~ donor + condition`` and :func:`dream_voom` with a random donor + intercept, then test the same features. normalization: ``"tmm"`` for edgeR's TMM normalization factors, the default of ``calcNormFactors``, or None for library sizes alone. span: The LOWESS span of voom's trend, in (0, 1], for every group; None @@ -784,9 +972,11 @@ def limma_voom( ValueError: If the design has random effects or no ``sample_id`` column, names samples the cube does not have or names a sample twice, if there are no contrasts to test, an option is invalid, ``prior_weights`` and - ``quality_weights`` are both given, or ``prior_weights`` is - ``"n_cells"`` and the cube does not record cell numbers. - KeyError: If a group is not in the cube. + ``quality_weights`` are both given, ``prior_weights`` is ``"n_cells"`` + and the cube does not record cell numbers, or the column of + ``"sample_groups"`` is missing for a sample. + KeyError: If a group is not in the cube, or the design's samples have no + column of ``"sample_groups"``. """ standard_errors = checked_choice( contrast_standard_errors, "contrast_standard_errors", ("exact", "limma") @@ -822,7 +1012,7 @@ def limma_trend( contrasts: Mapping[str, Any] | Sequence[str] | str | None = None, min_cells: int = 10, min_counts: float = 0, - expression_filter: bool | Mapping[str, float] = True, + expression_filter: bool | Mapping[str, Any] = True, normalization: Literal["tmm"] | None = "tmm", prior_count: float = 3.0, prior_weights: Literal["n_cells"] | None = None, @@ -855,7 +1045,8 @@ def limma_trend( min_counts: The fewest counts a sample needs in a group, over every feature of the cube, to enter its fit; 0 by default. expression_filter: True for edgeR's ``filterByExpr`` defaults with the - group's design, a mapping of changed settings, or False. + group's design, a mapping of changed settings or of the column of + ``"sample_groups"``, as for :func:`limma_voom`, or False. normalization: ``"tmm"`` for TMM normalization factors, or None. prior_count: The average count added to every observation before taking logs, scaled by library size as edgeR does; positive. 3 by default, as @@ -927,7 +1118,7 @@ def dream_voom( f_tests: Mapping[str, Sequence[str]] | None = None, min_cells: int = 10, min_counts: float = 0, - expression_filter: bool | Mapping[str, float] = True, + expression_filter: bool | Mapping[str, Any] = True, normalization: Literal["tmm"] | None = "tmm", span: float | None = None, prior_weights: Literal["n_cells"] | None = None, @@ -1008,7 +1199,8 @@ def dream_voom( min_counts: The fewest counts a sample needs in a group, over every feature of the cube, to enter its fit; 0 by default. expression_filter: True for edgeR's ``filterByExpr`` defaults with the - group's fixed effects, a mapping of changed settings, or False. + group's fixed effects, a mapping of changed settings or of the column + of ``"sample_groups"``, as for :func:`limma_voom`, or False. normalization: ``"tmm"`` for TMM normalization factors, or None. span: The LOWESS span of the trend, in (0, 1], for every group; None chooses it in each group from the number of features tested, as @@ -1089,7 +1281,7 @@ def dream_voom( @dataclass class _GroupFit(GroupRecord): - """What happened in one group, and its tables.""" + """What happened in one group, and its tables; with ``keep``, its fit.""" prior_df: float = float("nan") quality_weights: np.ndarray | None = None @@ -1097,6 +1289,10 @@ class _GroupFit(GroupRecord): df_method: str = "" # dream: the degrees of freedom of the group's tests features_satterthwaite_fallback: int = 0 # dream: Kenward-Roger tests not used f_test_df1: dict[str, int] = field(default_factory=dict) # dream: per F-test + values: np.ndarray | None = None # kept: the log2 CPM fitted + weights: np.ndarray | None = None # kept: their weights + voom: VoomResult | None = None # kept: voom's result + moderated: Any = None # kept: the moderated tests def _analyse( @@ -1141,16 +1337,8 @@ def _analyse( "this cube does not record (a cube of bulk samples has none); leave " "prior_weights at None" ) - cube_rows, order = matched_samples( - cube, - design, - no_ids="the design's sample table has no 'sample_id' column, so its rows cannot " - "be matched to the cube's samples; build the Design from cube.samples, or from " - "a table whose 'sample_id' column holds cube sample ids", - text_ids="the cube's does", - data="the cube", - data_ids="the cube's sample ids", - ) + check_sample_groups(settings, design.samples) + cube_rows, order = _matched(cube, design) tested = _contrasts_to_test(design, contrasts, method) if settings.get("f_tests"): _check_f_tests(settings["f_tests"], tested) @@ -1196,11 +1384,97 @@ def _analyse( _group_record(fit, sample_ids, method, settings) for fit in fits ], }, + cube=cube, + design=design, + ) + + +def _matched(cube: Cube, design: Design) -> tuple[np.ndarray, np.ndarray]: + """The cube position of every design sample, increasing, and its design row.""" + return matched_samples( + cube, + design, + no_ids="the design's sample table has no 'sample_id' column, so its rows cannot " + "be matched to the cube's samples; build the Design from cube.samples, or from " + "a table whose 'sample_id' column holds cube sample ids", + text_ids="the cube's does", + data="the cube", + data_ids="the cube's sample ids", ) -def _fit_group(inputs: GroupInputs, design: Design, g: int) -> _GroupFit: - """Fit one group by limma, or record why it cannot be fitted.""" +def _group_fit( + method: str, + cube: Cube, + design: Design, + contrasts: Contrasts, + settings: Mapping[str, Any], + group: str, + entry: Mapping[str, Any], +) -> GroupFit: + """The fit of one group computed again, as the analysis computed it.""" + cube_rows, order = _matched(cube, design) + g = group_positions(cube, group)[0] + inputs = GroupInputs(method, cube, order, cube_rows, contrasts, settings) + fit_group = _fit_dream_group if method == "dream_voom" else _fit_group + fit = fit_group(inputs, design, g, keep=True) + tested = int(fit.tested.size) if fit.status == FITTED else 0 + if fit.status != FITTED or tested != entry["n_features_tested"]: + raise ValueError( + f"the fit of group {group!r} no longer gives what the result records " + f"({fit.status}, {tested} features tested; the result records " + f"{entry['n_features_tested']}): the cube's values changed since the " + "analysis, as a lazy cube's source can" + ) + assert fit.values is not None and fit.moderated is not None + used = fit.used + columns: dict[str, Any] = {} + if cube.n_cells is not None: + columns["n_cells"] = np.asarray(cube.n_cells)[cube_rows[used], g] + columns["library_size"] = fit.library_sizes + columns["norm_factor"] = fit.norm_factors + if settings["prior_weights"] is not None: + columns["prior_weight"] = fit.prior_weights + if settings.get("quality_weights") is not None: + columns["quality_weight"] = fit.quality_weights + return GroupFit( + group=group, + samples=design.samples.take(order[used]).with_columns(columns), + features=cube.features.take(fit.tested), + log2_cpm=fit.values, + weights=fit.weights, + voom=fit.voom, + moderated=fit.moderated, + ) + + +def _restore_result( + method: str, + contrasts: Contrasts, + summary: Table, + samples: Table, + tables: Mapping[tuple[str, str], Table], + provenance: Mapping[str, Any], + cube: Cube | None, + design: Design | None, +) -> DifferentialExpressionResult: + return DifferentialExpressionResult( + method, + contrasts, + summary, + samples, + tables, + provenance, + cube=cube, + design=design, + ) + + +def _fit_group( + inputs: GroupInputs, design: Design, g: int, *, keep: bool = False +) -> _GroupFit: + """Fit one group by limma, or record why it cannot be fitted; with ``keep``, + the record keeps the values, weights and tests of the fit.""" cube, settings = inputs.cube, inputs.settings fit, data = prepare_group(_GroupFit, inputs, design, g) if data is None: @@ -1285,6 +1559,19 @@ def _fit_group(inputs: GroupInputs, design: Design, g: int) -> _GroupFit: fit.norm_factors = np.ones(n_used) if factors is None else factors fit.prior_weights = prior fit.quality_weights = quality + if keep: + if inputs.method == "limma_voom": + fit.values, fit.weights, fit.voom = ( + weighted.log_cpm, + weighted.weights, + weighted, + ) + else: + sample_weights = quality if prior is None else prior + fit.values = read_only(values) + if sample_weights is not None: + fit.weights = read_only(np.array(sample_weights, dtype=np.float64)) + fit.moderated = moderated features = cube.features identity = {"feature_id": features["feature_id"][fit.tested]} if "symbol" in features: @@ -1309,8 +1596,11 @@ def _fit_group(inputs: GroupInputs, design: Design, g: int) -> _GroupFit: return fit -def _fit_dream_group(inputs: GroupInputs, design: Design, g: int) -> _GroupFit: - """Fit one group by dream, or record why it cannot be fitted.""" +def _fit_dream_group( + inputs: GroupInputs, design: Design, g: int, *, keep: bool = False +) -> _GroupFit: + """Fit one group by dream, or record why it cannot be fitted; with ``keep``, + the record keeps the values, weights and tests of the fit.""" cube, settings = inputs.cube, inputs.settings fit, data = prepare_group(_GroupFit, inputs, design, g, mixed=True) if data is None or data.mixed is None: @@ -1364,6 +1654,9 @@ def _fit_dream_group(inputs: GroupInputs, design: Design, g: int) -> _GroupFit: fit.library_sizes = data.sizes fit.norm_factors = np.ones(n_used) if data.factors is None else data.factors fit.prior_weights = data.prior + if keep: + fit.values, fit.weights = weighted.log_cpm, weighted.weights + fit.voom, fit.moderated = weighted, moderated features = cube.features identity = {"feature_id": features["feature_id"][fit.tested]} if "symbol" in features: diff --git a/cytepool/gene_sets.py b/cytepool/gene_sets.py index 65c2dae..9024f47 100644 --- a/cytepool/gene_sets.py +++ b/cytepool/gene_sets.py @@ -89,7 +89,7 @@ from ._gene_ids import gene_ids, listed_values from ._masked_arrays import reject_masked -from ._messages import close_matches, listing +from ._messages import KEEP_TOGETHER, close_matches, fitted_lines, listing __all__ = ["GeneSets", "read_gmt", "write_gmt"] @@ -408,14 +408,14 @@ def __repr__(self) -> str: lines.append(f" read from {self._file}{digest}") if sizes: shown = [ - f"{name} ({len(members):,})" + f"{name} ({len(members):,})".replace(" ", KEEP_TOGETHER) for name, members in list(self._sets.items())[:_SETS_SHOWN] ] more = count - len(shown) lines.append( " sets: " + ", ".join(shown) + (f" and {more:,} more" if more else "") ) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def _record(self) -> dict[str, str | None]: return { diff --git a/cytepool/gsea.py b/cytepool/gsea.py index 55c118d..680da80 100644 --- a/cytepool/gsea.py +++ b/cytepool/gsea.py @@ -153,7 +153,7 @@ from ._columns import text_column from ._jit import by_chunks, jit, thread_limit from ._masked_arrays import reject_masked -from ._messages import PACKAGE_DIRECTORY, quoted +from ._messages import PACKAGE_DIRECTORY, fitted_message, quoted from ._options import ( checked_choice, number_at_least, @@ -422,13 +422,28 @@ def _gene_set_enrichment( log2_error[tested] = _permutation_error(beyond[tested], n_perm) else: unbalanced = of_sign < _FEWEST_OF_SIGN - if unbalanced.any(): + none = of_sign == 0 + few = unbalanced & ~none + if few.any(): _warn( - f"{int(np.count_nonzero(unbalanced))} gene set(s) have fewer than " - f"{_FEWEST_OF_SIGN} random scores of the sign of their enrichment " - f"score among {n_perm} permutations, as statistics mostly of one sign " - "give; their normalized scores and p-values are NaN. More permutations " - f"(n_permutations={10 * n_perm}) may give them some" + fitted_message( + f"{int(np.count_nonzero(few))} gene set(s) have fewer than " + f"{_FEWEST_OF_SIGN} random scores of the sign of their enrichment " + f"score among {n_perm} permutations, but some; their normalized " + "scores and p-values are NaN. More permutations " + f"(n_permutations={10 * n_perm}) may give them enough" + ) + ) + if none.any(): + _warn( + fitted_message( + f"{int(np.count_nonzero(none))} gene set(s) have no random score of " + f"the sign of their enrichment score among {n_perm} permutations: " + "random sets of their size almost always score with the other " + "sign, because most statistics share one sign, so more " + "permutations are unlikely to give them any; their normalized " + "scores and p-values are NaN" + ) ) normalized[unbalanced] = np.nan p_value[unbalanced] = np.nan diff --git a/cytepool/held_out_prediction.py b/cytepool/held_out_prediction.py index 6d874d3..83f02e7 100644 --- a/cytepool/held_out_prediction.py +++ b/cytepool/held_out_prediction.py @@ -109,7 +109,7 @@ from ._analysis_records import software_versions from ._columns import text_column from ._masked_arrays import reject_masked -from ._messages import listing, quoted +from ._messages import fitted_lines, listing, quoted from ._options import index_integer from ._ranks import average_ranks from ._study_statistics import StudyStatistics, study_statistics, studies_summed @@ -237,14 +237,14 @@ def __repr__(self) -> str: lines = [ f"HeldOutPrediction of {settings['case']!r} against {settings['control']!r}" f" ({settings['variable']}), contrast {settings['contrast']!r}: " - f"{len(set(table['study'].tolist()))} held-out studies, " - f"{settings['n_genes']} genes up and down per group" + f"{len(set(table['study'].tolist())):,} held-out studies, " + f"{settings['n_genes']:,} genes up and down per group" ] for method in settings["methods"]: values = table["auc"][(table["method"] == method) & ~np.isnan(table["auc"])] mean = f"mean AUC {values.mean():.3f}" if values.size else "no AUC" - lines.append(f" {method}: {mean} over {values.size} studies") - return "\n".join(lines) + lines.append(f" {method}: {mean} over {values.size:,} studies") + return fitted_lines("\n".join(lines)) def held_out_prediction( diff --git a/cytepool/io/anndata.py b/cytepool/io/anndata.py index 10af16b..07df5ae 100644 --- a/cytepool/io/anndata.py +++ b/cytepool/io/anndata.py @@ -95,8 +95,8 @@ ``n_cells``; ``obs_names`` are ``_``, or the row positions when those repeat. ``var`` holds the feature table, indexed by feature id, and each layer of the cube is a layer of the same name. ``X`` is left empty, so - that no layer is stored twice: ``adata.X = adata.layers["counts"].copy()`` gives - tools that read ``X`` the counts. + that no layer is stored twice, unless ``x_layer`` names a layer to copy into it: + ``to_anndata(cube, x_layer="counts")`` gives tools that read ``X`` the counts. ``to_mudata`` writes a modality per group, named by the group id, whose observations are the samples with cells in that group (every sample, without @@ -191,6 +191,7 @@ from .. import __version__ from .._columns import values_equal, with_missing from .._masked_arrays import reject_masked, reject_masked_table, unmasked_array +from .._messages import quoted from ..cube._axes import axis_codes, checked_n_cells, count_dtype, first_index from ..cube._provenance_records import source_record from ..cube.cube import LAYER_NAMES, Cube @@ -235,14 +236,15 @@ _TOTAL_SLACK = 1e-9 -def to_anndata(cube: Cube) -> Any: +def to_anndata(cube: Cube, *, x_layer: str | None = None) -> Any: """Return a cube as a long AnnData, with a row per sample and group with cells. The rows of each group come together, groups and samples in the cube's order; a cube without cell numbers gives a row for every entry. ``obs`` holds ``sample_id`` and ``group_id`` (categorical), the other columns of the sample and group tables, and ``n_cells``; ``var`` the feature table, indexed by feature id; - each layer of the cube is a layer of the same name, and ``X`` is empty. + each layer of the cube is a layer of the same name, and ``X`` is empty unless + ``x_layer`` names a layer to copy into it, as tools that read ``X`` need. ``uns["cytepool"]`` holds the cube's fingerprint and provenance, and what ``from_anndata`` needs to give back the cube with the same fingerprint. The module documentation describes the layout ("Export") and the record ("The record @@ -250,18 +252,34 @@ def to_anndata(cube: Cube) -> Any: Args: cube: The cube. A lazy cube is read one group at a time. + x_layer: The layer to copy into ``X`` too, such as ``"counts"`` for tools + that read counts from ``X``; None leaves ``X`` empty. The copy takes as + much memory as the layer. Returns: An ``anndata.AnnData``. Raises: - TypeError: If ``cube`` is not a Cube. + TypeError: If ``cube`` is not a Cube, or ``x_layer`` is not a string. + KeyError: If the cube has no layer ``x_layer``. ImportError: If anndata is not installed. ValueError: If a lazy layer gives a value that breaks a constraint (see ``Cube``). OverflowError: If a sum of a derived lazy layer does not fit. """ _check_cube(cube, "to_anndata()") + if x_layer is not None: + if not isinstance(x_layer, str): + reject_masked(x_layer, "x_layer") + raise TypeError( + f"x_layer must be a layer name (str) or None, got " + f"{type(x_layer).__name__}" + ) + if x_layer not in cube.layer_names: + raise KeyError( + f"the cube has no layer {x_layer!r} to copy into X; its layers are " + f"{quoted(list(cube.layer_names))}" + ) anndata = _optional("anndata", "to_anndata()", "anndata") pandas = _optional("pandas", "to_anndata()", "anndata") samples, groups = _entries_with_cells(cube) @@ -295,7 +313,10 @@ def to_anndata(cube: Cube) -> Any: name: _long_layer(cube, name, samples, groups) for name in cube.layer_names } record = _record(cube, _FORMATS["anndata"], features) - return anndata.AnnData(obs=obs, var=var, layers=layers, uns={_RECORD_KEY: record}) + x = None if x_layer is None else layers[x_layer].copy() + return anndata.AnnData( + X=x, obs=obs, var=var, layers=layers, uns={_RECORD_KEY: record} + ) def from_anndata( diff --git a/cytepool/meta_analysis.py b/cytepool/meta_analysis.py index 4309ef5..9b375ac 100644 --- a/cytepool/meta_analysis.py +++ b/cytepool/meta_analysis.py @@ -161,11 +161,11 @@ import numpy as np import numpy.typing as npt -from ._analysis_records import software_versions +from ._analysis_records import only_key, software_versions from ._columns import text_column from ._jit import jit from ._masked_arrays import read_only, reject_masked, unmasked_array -from ._messages import PACKAGE_DIRECTORY, listing, quoted +from ._messages import PACKAGE_DIRECTORY, fitted_lines, listing, quoted from ._options import checked_choice, index_integer, real_number from .cube import CubeCollection from .differential_expression import DifferentialExpressionResult @@ -953,23 +953,27 @@ def provenance(self) -> dict[str, Any]: record: dict[str, Any] = json.loads(self._record) return record - def table(self, group: str, contrast: str) -> Table: + def table(self, group: str | None = None, contrast: str | None = None) -> Table: """Return the table of one group and contrast. Args: - group: A group id. - contrast: A contrast name. + group: A group id; it may be left out when the result has one group. + contrast: A contrast name; it may be left out when the result has one + contrast. Raises: + ValueError: If a key is left out and the result has several. KeyError: If the group or contrast was not analysed, fewer than ``min_studies`` studies tested it, or none of its features; the message says why. """ + groups = list(dict.fromkeys(self._summary["group_id"].tolist())) + contrasts = list(dict.fromkeys(self._summary["contrast"].tolist())) + group = only_key(group, groups, "group", "groups") + contrast = only_key(contrast, contrasts, "contrast", "contrasts") found = self._tables.get((group, contrast)) if found is not None: return found - groups = list(dict.fromkeys(self._summary["group_id"].tolist())) - contrasts = list(dict.fromkeys(self._summary["contrast"].tolist())) if group not in groups: raise KeyError( f"no group {group!r} was analysed; groups are: " @@ -997,18 +1001,18 @@ def __repr__(self) -> str: analysed = summary["status"].tolist().count(_ANALYSED) lines = [ f"MetaAnalysisResult ({settings['method']}, test {settings['test']}): " - f"{len(record['studies'])} studies; {n} group and contrast " - f"pair{'' if n == 1 else 's'}, {analysed} analysed" + f"{len(record['studies']):,} studies; {n:,} group and contrast " + f"pair{'' if n == 1 else 's'}, {analysed:,} analysed" ] for row in range(n): label = f" {summary['group_id'][row]}, {summary['contrast'][row]}: " used = int(summary["n_studies"][row]) if summary["status"][row] == _ANALYSED: features = int(summary["n_features"][row]) - lines.append(f"{label}{used} studies, {features} features") + lines.append(f"{label}{used:,} studies, {features:,} features") else: lines.append(f"{label}not analysed ({summary['status'][row]})") - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def differential_expression_meta_analysis( diff --git a/cytepool/networks.py b/cytepool/networks.py index ea42422..36bb685 100644 --- a/cytepool/networks.py +++ b/cytepool/networks.py @@ -114,8 +114,9 @@ from ._columns import is_data_frame, text_column from ._gene_ids import is_missing, listed_values from ._masked_arrays import real_array, reject_masked -from ._messages import close_matches, quoted +from ._messages import KEEP_TOGETHER, close_matches, fitted_lines, quoted from ._options import checked_choice, positive_integer, real_number +from .gene_sets import GeneSets from .table import Table __all__ = ["Network", "collectri", "progeny"] @@ -415,6 +416,30 @@ def select(self, sources: str | Any) -> "Network": taken = [row for source in chosen for row in rows[source]] return self._derived(np.array(taken, dtype=np.intp)) + def to_gene_sets(self) -> GeneSets: + """Return the targets of each source as a gene set, without their weights. + + The gene-set tests and per-sample scores take gene sets, such as the + regulons of CollecTRI to test with :func:`~cytepool.gsea.gsea` or score with + :func:`~cytepool.pathway_scores.gsva`. Each source becomes a set of its + targets, in the order of the edges, named by the source. The weights, and + so the signs that tell activated targets from repressed ones, are left out: + :func:`~cytepool.activity.ulm` and the other activity methods use them. The + sets keep the network's name, as their ``source``, version, licence, file + and digest. + + Returns: + A :class:`~cytepool.gene_sets.GeneSets` with one set per source. + """ + return GeneSets( + {source: list(self._targets[source]) for source in self._sources}, + source=self._name, + version=self._version, + licence=self._licence, + file=self._file, + sha256=self._sha256, + ) + def __repr__(self) -> str: n_edges = len(self._edges) n_targets = len(set(self._edges["target"].tolist())) @@ -437,14 +462,14 @@ def __repr__(self) -> str: digest = f", SHA-256 {self._sha256}" if self._sha256 else "" lines.append(f" read from {self._file}{digest}") shown = [ - f"{source} ({len(self._targets[source]):,})" + f"{source} ({len(self._targets[source]):,})".replace(" ", KEEP_TOGETHER) for source in self._sources[:_SOURCES_SHOWN] ] more = len(self._sources) - len(shown) lines.append( " sources: " + ", ".join(shown) + (f" and {more:,} more" if more else "") ) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def _record(self) -> dict[str, str | None]: return { diff --git a/cytepool/pathway_scores.py b/cytepool/pathway_scores.py index 1a59639..4669742 100644 --- a/cytepool/pathway_scores.py +++ b/cytepool/pathway_scores.py @@ -182,6 +182,12 @@ import numpy.typing as npt from numba import prange +from ._analysis_records import ( + keep_provenance, + provenance_of, + provenance_text, + restore_provenance, +) from ._columns import text_column from ._expression_values import MIN_CELLS, ExpressionValues, expression_values from ._jit import by_chunks, jit, thread_limit @@ -244,6 +250,31 @@ class PathwayScores: method: str settings: Mapping[str, Any] + def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: + # The settings are a read-only view, which pickle cannot write: a dict + # travels in their place, and the provenance kept outside the fields with it. + return ( + _restored_scores, + ( + self.scores, + self.samples, + self.gene_sets, + self.method, + dict(self.settings), + provenance_text(self), + ), + ) + + @property + def provenance(self) -> dict[str, Any] | None: + """A JSON-serialisable record of what produced the scores of a cube's group, + as a new dict: the method, the CytePool, numpy, numba and Python versions, + the cube's fingerprint, the digests it is built from and its provenance + (``"cube"``), the layer read and the settings; None for scores of values + given as an array. The cube's record costs what it costs for + :func:`~cytepool.differential_expression.limma_voom` ("Provenance").""" + return provenance_of(self) + @property def n_genes(self) -> IntArray: """The number of genes of each set that were used, in the order of @@ -279,6 +310,25 @@ def __repr__(self) -> str: ) +def _restored_scores( + scores: FloatArray, + samples: Table, + gene_sets: GeneSets, + method: str, + settings: dict[str, Any], + provenance: str | None, +) -> PathwayScores: + """Pathway scores unpickled: read-only again, with their provenance.""" + restored = PathwayScores( + read_only(np.asarray(scores)), + samples, + gene_sets, + method, + MappingProxyType(settings), + ) + return restore_provenance(restored, provenance) + + def gsva( data: Any, gene_sets: Mapping[str, Any], @@ -288,7 +338,7 @@ def gsva( group: str | None = None, values: str = "log_cpm", min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, kernel: str = "auto", min_samples_without_kernel: int = 200, exponent: float = 1.0, @@ -327,7 +377,11 @@ def gsva( scored, at least 0, as for :func:`~cytepool.differential_expression.limma_voom`. expression_filter: For a cube, whether to score only the genes that - :func:`~cytepool.normalization.filter_by_expression` keeps. + :func:`~cytepool.normalization.filter_by_expression` keeps, with the + samples as one group; or a mapping of its settings, which may name a + column of the cube's samples whose values group them, such as + ``{"sample_groups": "condition"}``, as + :func:`~cytepool.differential_expression.limma_voom` takes it. kernel: How each gene's distribution is estimated (GSVA's ``kcdf``): ``"gaussian"`` for continuous values, ``"poisson"`` for counts (whole numbers of at least 0), ``"none"`` for the empirical distribution @@ -423,7 +477,7 @@ def ssgsea( group: str | None = None, values: str = "log_cpm", min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, exponent: float = 0.25, normalize: bool = True, min_size: int = 1, @@ -517,7 +571,7 @@ def combined_z_scores( group: str | None = None, values: str = "log_cpm", min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, min_size: int = 1, max_size: int | None = None, ) -> PathwayScores: @@ -592,7 +646,7 @@ def plage( group: str | None = None, values: str = "log_cpm", min_cells: int = MIN_CELLS, - expression_filter: bool = True, + expression_filter: bool | Mapping[str, Any] = True, min_size: int = 1, max_size: int | None = None, ) -> PathwayScores: @@ -787,13 +841,16 @@ def _result( file=collection.file, sha256=collection.sha256, ) - return PathwayScores( + result = PathwayScores( read_only(np.ascontiguousarray(scores, dtype=np.float64)), expression.samples, used, method, MappingProxyType(dict(settings)), ) + if expression.cube is not None: + keep_provenance(result, method, expression.cube, settings) + return result # GSVA: the kernel estimates, their ranks and the walks. diff --git a/cytepool/plotting.py b/cytepool/plotting.py index 3cefa75..1815a52 100644 --- a/cytepool/plotting.py +++ b/cytepool/plotting.py @@ -201,7 +201,7 @@ import numbers from collections.abc import Mapping, Sequence from dataclasses import dataclass, field -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING, Any, Literal, cast import numpy as np import numpy.typing as npt @@ -333,6 +333,12 @@ _MARKERS = ("o", "s", "^", "D", "v", "P", "X", "<", ">", "p", "h", "*") _DENSE = 8.0 # area of the points of scatter plots of genes, in points squared _SPARSE = 48.0 # and of samples +_FEW_ENTRIES = 4 # the most entries of a legend that may sit inside a plot +_ROOM_ROUNDS = 4 # the times the room for the numbers beside bars is measured +# The places inside a plot a legend may take, in the order they are tried. +_INSIDE_PLACES: tuple[ + Literal["best", "upper right", "upper left", "lower left", "lower right"], ... +] = ("best", "upper right", "upper left", "lower left", "lower right") # limma's plotMDS takes the 500 largest log fold changes, and edgeR's plotMDS of # counts adds an average count of 2 before taking logs. _MDS_TOP = 500 @@ -431,9 +437,21 @@ def _patch(label: str, color: str, **properties: Any) -> Any: ) -def _legend(ax: "Axes", handles: list[Any]) -> None: - """A legend to the right of the plot; entries without a marker or line are - headers, set in bold.""" +def _legend(ax: "Axes", handles: list[Any], *, inside: bool = False) -> None: + """A legend to the right of the plot; with ``inside``, a legend of a few entries + inside the plot instead, where it covers no point, line, bar or label at the size + the figure is laid out at, so that panels side by side keep their width. Where + every place inside would cover something, or the legend has more entries, it goes + beside the plot. Entries without a marker or line are headers, set in bold.""" + if inside and len(handles) <= _FEW_ENTRIES: + legend = ax.legend(handles=handles, loc="best", framealpha=0.85) + _bold_headers(handles, legend) + obstacles = _obstacles(ax) + for place in _INSIDE_PLACES: + legend.set_loc(place) + if not obstacles.covered_by(legend.get_window_extent()): + return + legend.remove() legend = ax.legend( handles=handles, loc="upper left", @@ -441,12 +459,126 @@ def _legend(ax: "Axes", handles: list[Any]) -> None: borderaxespad=0.0, frameon=False, ) + _bold_headers(handles, legend) + + +def _bold_headers(handles: list[Any], legend: Any) -> None: for handle, text in zip(handles, legend.get_texts(), strict=True): header = getattr(handle, "get_marker", lambda: "o")() in ("", "None") if header and handle.get_linestyle() in ("None", "none", ""): text.set_fontweight("bold") +@dataclass(frozen=True) +class _Obstacles: + """What a legend inside a plot must not cover, in display coordinates: points + (x, y and the radius of their marker), line segments (two ends and half the + line's width) and the boxes of labels, bars and other shapes.""" + + points: FloatArray # (n, 3) + segments: FloatArray # (n, 5) + boxes: list[Any] + + def covered_by(self, box: Any) -> bool: + """Whether a box, such as a legend's, covers any of them, with a pixel to + spare.""" + x0, y0, x1, y1 = box.x0 - 1.0, box.y0 - 1.0, box.x1 + 1.0, box.y1 + 1.0 + x, y, r = self.points.T + if np.any((x + r >= x0) & (x - r <= x1) & (y + r >= y0) & (y - r <= y1)): + return True + if _segments_cross(self.segments, (x0, y0, x1, y1)): + return True + return any( + other.x1 >= x0 and other.x0 <= x1 and other.y1 >= y0 and other.y0 <= y1 + for other in self.boxes + ) + + +def _obstacles(ax: "Axes") -> _Obstacles: + """The points, lines, bars and labels of a plot, where the figure's layout puts + them.""" + root = ax.figure.figure # the Figure, also of Axes in a subfigure + if root is not None: + root.draw_without_rendering() + scale = ax.figure.dpi / 72.0 # pixels per point + collections = _module("matplotlib.collections") + points, segments, boxes = [np.empty((0, 3))], [np.empty((0, 5))], [] + for collection in ax.collections: + offsets = np.asarray(collection.get_offsets(), dtype=np.float64) + if isinstance(collection, collections.PathCollection) and offsets.size: + xy = collection.get_offset_transform().transform(offsets) + sizes = np.asarray(collection.get_sizes(), dtype=np.float64) + radius = np.resize( + np.sqrt(sizes) / 2.0 * scale if sizes.size else 0.0, len(xy) + ) + finite = np.isfinite(xy).all(axis=1) + points.append(np.column_stack([xy[finite], radius[finite]])) + elif isinstance(collection, collections.LineCollection): + width = np.max(collection.get_linewidths(), initial=1.0) / 2.0 * scale + transform = collection.get_transform() + for segment in collection.get_segments(): + ends = transform.transform(np.asarray(segment, dtype=np.float64)) + segments.append(_segment_rows(ends, width)) + elif collection.get_visible(): + boxes.append(collection.get_window_extent()) + for line in ax.lines: + if not line.get_visible(): + continue + ends = line.get_transform().transform( + np.asarray(line.get_xydata(), dtype=np.float64) + ) + if line.get_marker() not in ("", " ", "None", "none", None): + finite = np.isfinite(ends).all(axis=1) + radius = np.full(int(finite.sum()), line.get_markersize() / 2.0 * scale) + points.append(np.column_stack([ends[finite], radius])) + if line.get_linestyle() not in ("", " ", "None", "none"): + segments.append(_segment_rows(ends, line.get_linewidth() / 2.0 * scale)) + for text in ax.texts: + if text.get_visible() and text.get_text(): + boxes.append(text.get_window_extent()) + for patch in ax.patches: + if patch.get_visible(): + boxes.append(patch.get_window_extent()) + return _Obstacles(np.concatenate(points), np.concatenate(segments), boxes) + + +def _segment_rows(ends: FloatArray, half_width: float) -> FloatArray: + """The segments between consecutive points, as rows (x0, y0, x1, y1, half the + line's width); segments with a missing end are left out.""" + if len(ends) < 2: + return np.empty((0, 5)) + rows = np.column_stack([ends[:-1], ends[1:], np.full(len(ends) - 1, half_width)]) + return rows[np.isfinite(rows).all(axis=1)] + + +def _segments_cross( + segments: FloatArray, box: tuple[float, float, float, float] +) -> bool: + """Whether any segment, widened by half its line's width, crosses a box: the + clipping of each segment to the box (Liang and Barsky) leaves part of it.""" + if not len(segments): + return False + x0, y0, x1, y1 = box + w = segments[:, 4] + start = segments[:, 0:2] + step = segments[:, 2:4] - start + low = np.zeros(len(segments)) + high = np.ones(len(segments)) + for axis, (lower, upper) in enumerate(((x0, x1), (y0, y1))): + origin, delta = start[:, axis], step[:, axis] + lo, hi = lower - w, upper + w + flat = delta == 0.0 + with np.errstate(divide="ignore", invalid="ignore"): + first = (lo - origin) / delta + second = (hi - origin) / delta + enter = np.where(flat, -np.inf, np.minimum(first, second)) + leave = np.where(flat, np.inf, np.maximum(first, second)) + outside = flat & ((origin < lo) | (origin > hi)) + low = np.where(outside, 2.0, np.maximum(low, enter)) + high = np.minimum(high, leave) + return bool(np.any(low <= high)) + + def _text_transform(ax: "Axes") -> Any: """x in data units and y in axes units, for text above the plot.""" return _module("matplotlib.transforms").blended_transform_factory( @@ -670,73 +802,17 @@ def plot_mds( f"dimensions {first} and {second} need at least {max(first, second) + 1} " f"samples, got {n_samples}" ) - colors = None if color_by is None else samples.labels(color_by, "color_by") - markers = None if marker_by is None else samples.labels(marker_by, "marker_by") - remedy = "give it as marker_by, or as labels" - hues = {} if colors is None else _hues(colors[1], "color_by", remedy) - # More levels than hues that scatter plots keep apart get a marker each, too. - shapes_follow_colors = ( - markers is None and colors is not None and len(colors[1]) > _SCATTER_HUES - ) - if markers is not None: - shapes, by_shape = _shapes(markers[1], "marker_by"), markers[0] - elif colors is not None and shapes_follow_colors: - shapes, by_shape = _shapes(colors[1], "color_by"), colors[0] - else: - shapes, by_shape = {}, None - if isinstance(labels, bool | np.bool_): - texts = list(samples.ids) if labels else None - else: - texts = samples.labels(labels, "labels")[0] + styles = _sample_styles(samples, color_by, marker_by, labels) pairwise = selection == "pairwise" and count < n_genes coordinates, eigenvalues = _mds(values, count, pairwise) share = np.maximum(eigenvalues / np.sum(eigenvalues), 0.0) x, y = coordinates[:, first - 1], coordinates[:, second - 1] ax = _axes(ax, (6.5, 4.5)) - color_of = [hues[level] for level in colors[0]] if colors else [_BLUE] * n_samples - marker_of = [shapes[level] for level in by_shape] if by_shape else None - marker_of = marker_of or [_MARKERS[0]] * n_samples - for marker in dict.fromkeys(marker_of): - rows = [i for i in range(n_samples) if marker_of[i] == marker] - ax.scatter( - x[rows], - y[rows], - c=[color_of[i] for i in rows], - marker=marker, - s=_SPARSE, - edgecolors="white", - linewidths=0.6, - zorder=3, - gid="samples", - ) - if texts is not None: - for i, text in enumerate(texts): - ax.annotate( - text, - (x[i], y[i]), - xytext=(4, 4), - textcoords="offset points", - fontsize=8, - gid="sample labels", - ) + _draw_styled_samples(ax, x, y, styles) axis = "Leading log2 fold change, dimension" if pairwise else "Principal component" ax.set_xlabel(f"{axis} {first} ({100 * share[first - 1]:.0f}%)") ax.set_ylabel(f"{axis} {second} ({100 * share[second - 1]:.0f}%)") - handles: list[Any] = [] - if colors is not None: - if isinstance(color_by, str): - handles.append(_key(color_by, marker="")) - for level in colors[1]: - shape = shapes[level] if shapes_follow_colors else _MARKERS[0] - handles.append(_key(level, marker=shape, color=hues[level])) - if markers is not None: - if isinstance(marker_by, str): - handles.append(_key(marker_by, marker="")) - for level in markers[1]: - handles.append(_key(level, marker=shapes[level], color=_GREY)) - if handles: - _legend(ax, handles) return ax @@ -1237,33 +1313,66 @@ def plot_proportions( # Mean-variance trends. -def plot_mean_variance(result: VoomResult, *, ax: "Axes | None" = None) -> "Axes": +def plot_mean_variance( + result: VoomResult | DifferentialExpressionResult, + *, + group: str | None = None, + ax: "Axes | None" = None, +) -> "Axes": """Plot voom's mean-variance trend. voom's plot (Law et al. 2014), as limma's ``voom(plot = TRUE)`` draws it: the square root of every gene's residual standard deviation against its average log2 count (``VoomResult.sqrt_sd`` against ``mean_log_count``), with the LOWESS trend from which the precision weights are read (``sqrt_sd_trend``). Genes left out of the - trend, such as those without counts, are not drawn. + trend, such as those without counts, are not drawn. Of a differential-expression + result, the trend of one group, which + :meth:`~cytepool.differential_expression.DifferentialExpressionResult.fit` + computes again. Draws the genes (gid ``"points"``) and the trend (gid ``"trend"``). Args: result: The result of :func:`~cytepool.stats.voom.voom` or - :func:`~cytepool.stats.voom.voom_with_quality_weights`. + :func:`~cytepool.stats.voom.voom_with_quality_weights`, or of + :func:`~cytepool.differential_expression.limma_voom` or + :func:`~cytepool.differential_expression.dream_voom`. + group: The group of a differential-expression result; it may be left out + when the result has one group. ax: The Axes to draw into, or None for a new figure. Returns: The Axes. Raises: - TypeError: If ``result`` is not a VoomResult. + TypeError: If ``result`` is neither a VoomResult nor a + DifferentialExpressionResult. ValueError: If no trend was fitted, because the design leaves no residual - degrees of freedom. + degrees of freedom; the result is of limma-trend, which fits no voom + trend; or ``group`` is given with a VoomResult or left out of a result of + several groups. + KeyError: If the group was not analysed or not fitted. """ _check_axes(ax) + if isinstance(result, DifferentialExpressionResult): + if result.method == "limma_trend": + raise ValueError( + "limma-trend weights no observation, so it has no voom trend to draw; " + "plot_residual_variances(result) draws the trend of its residual " + "variances" + ) + result = cast(VoomResult, result.fit(group).voom) + elif group is not None: + reject_masked(group, "group") + raise ValueError( + "group applies to a differential-expression result, and result is a " + f"{type(result).__name__}" + ) if not isinstance(result, VoomResult): - raise TypeError(f"result must be a VoomResult, got {type(result).__name__}") + raise TypeError( + "result must be a VoomResult, or the DifferentialExpressionResult of " + f"limma_voom or dream_voom, got {type(result).__name__}" + ) shown = np.isfinite(result.sqrt_sd) if not shown.any(): raise ValueError( @@ -1303,12 +1412,16 @@ def plot_mean_variance(result: VoomResult, *, ax: "Axes | None" = None) -> "Axes linewidth=2, ), ], + inside=True, ) return ax def plot_residual_variances( - fit: ModeratedFit | TreatFit, *, ax: "Axes | None" = None + fit: ModeratedFit | TreatFit | DifferentialExpressionResult, + *, + group: str | None = None, + ax: "Axes | None" = None, ) -> "Axes": """Plot the residual standard deviations of the genes and the prior they were moderated towards. @@ -1320,27 +1433,55 @@ def plot_residual_variances( whose two-sided p-value as a variance of the prior, from the F distribution on the gene's residual and the prior's degrees of freedom (those of the genes that are not outliers), is below 0.5 once adjusted by Benjamini and Hochberg (1995), as limma - marks them (found by probing). + marks them (found by probing). Of a differential-expression result, the + moderation of one group, which + :meth:`~cytepool.differential_expression.DifferentialExpressionResult.fit` + computes again. Draws the genes (gid ``"points"``), the outliers (gid ``"outliers"``) and the prior (gid ``"prior"``). Args: fit: The result of :func:`~cytepool.stats.empirical_bayes.moderated_statistics` - or :func:`~cytepool.stats.empirical_bayes.treat`. + or :func:`~cytepool.stats.empirical_bayes.treat`, or of + :func:`~cytepool.differential_expression.limma_voom` or + :func:`~cytepool.differential_expression.limma_trend`. + group: The group of a differential-expression result; it may be left out + when the result has one group. ax: The Axes to draw into, or None for a new figure. Returns: The Axes. Raises: - TypeError: If ``fit`` is neither a ModeratedFit nor a TreatFit. - ValueError: If no gene has a residual standard deviation. + TypeError: If ``fit`` is neither a ModeratedFit, a TreatFit nor a + DifferentialExpressionResult. + ValueError: If no gene has a residual standard deviation; the result is of + dream, whose moderated variances are those of mixed models; or + ``group`` is given with a fit or left out of a result of several + groups. + KeyError: If the group was not analysed or not fitted. """ _check_axes(ax) + if isinstance(fit, DifferentialExpressionResult): + if fit.method == "dream_voom": + raise ValueError( + "plot_residual_variances draws limma's moderation of the residual " + "variances of linear models; dream moderates those of mixed models, " + "which limma's plotSA does not draw" + ) + fit = cast(ModeratedFit, fit.fit(group).moderated) + elif group is not None: + reject_masked(group, "group") + raise ValueError( + "group applies to a differential-expression result, and fit is a " + f"{type(fit).__name__}" + ) if not isinstance(fit, ModeratedFit | TreatFit): raise TypeError( - f"fit must be a ModeratedFit or a TreatFit, got {type(fit).__name__}" + "fit must be a ModeratedFit or a TreatFit, or the " + f"DifferentialExpressionResult of limma_voom or limma_trend, got " + f"{type(fit).__name__}" ) linear = fit.fit sigma, x, df = linear.sigma, linear.mean_expression, linear.df_residual @@ -1397,7 +1538,7 @@ def plot_residual_variances( handles.append(_key("Prior", marker="", linestyle="-", color=_ORANGE, linewidth=2)) ax.set_xlabel("Average log-expression") ax.set_ylabel("Square root of residual standard deviation") - _legend(ax, handles) + _legend(ax, handles, inside=True) return ax @@ -1744,7 +1885,11 @@ def plot_md( ax.set_xscale("log") ax.set_xlabel(tests.abundance_label) ax.set_ylabel("log2 fold change") - _legend(ax, _significance_keys(int(up.sum()), int(down.sum()), int(rest.sum()))) + _legend( + ax, + _significance_keys(int(up.sum()), int(down.sum()), int(rest.sum())), + inside=True, + ) return ax @@ -1817,7 +1962,11 @@ def plot_volcano( _label_points(ax, x, y, names, chosen) ax.set_xlabel("log2 fold change") ax.set_ylabel("-log10 p-value") - _legend(ax, _significance_keys(int(up.sum()), int(down.sum()), int(rest.sum()))) + _legend( + ax, + _significance_keys(int(up.sum()), int(down.sum()), int(rest.sum())), + inside=True, + ) return ax @@ -1966,11 +2115,12 @@ def plot_significant_genes( ax.axvline(0.0, color=_INK, linewidth=0.8) reach = max(int(up.max(initial=0)), int(down.max(initial=0)), 1) gap = 0.02 * reach + numbers = [] for y, n_up, n_down in zip( positions[tested], up[tested], down[tested], strict=True ): for value, side in ((n_up, 1.0), (n_down, -1.0)): - ax.text( + text = ax.text( side * (value + gap), y, f"{value:,}", @@ -1979,6 +2129,7 @@ def plot_significant_genes( fontsize=8, gid="numbers", ) + numbers.append((float(value), text)) ax.set_yticks(positions, labels) ax.set_xlim(-1.2 * reach, 1.2 * reach) # Genes down are drawn to the left; the axis counts them as numbers of genes. @@ -1988,9 +2139,38 @@ def plot_significant_genes( adjusted_over = "over every group" if across else "within each group" ax.set_xlabel(f"Genes at adjusted p < {level:g} ({adjusted_over})") _legend(ax, [_patch("Up", _UP), _patch("Down", _DOWN)]) + # Last, once the legend beside the plot has narrowed it. + _make_room(ax, numbers, gap, 1.2 * reach) return ax +def _make_room( + ax: "Axes", numbers: list[tuple[float, Any]], gap: float, limit: float +) -> None: + """Widen the symmetric x limits of a plot of bars to the left and right of zero + so that the number written beyond each bar, ``gap`` from its end, fits inside + the frame, at the size the figure is laid out at.""" + if not numbers: + return + root = ax.figure.figure # the Figure, also of Axes in a subfigure + pad = 4.0 # pixels between a number and the frame + # New limits change the tick labels, which a layout engine may make room for by + # narrowing the plot: measure again until the numbers fit. + for _ in range(_ROOM_ROUNDS): + if root is not None: + root.draw_without_rendering() + width = ax.get_window_extent().width + needed = limit + for value, text in numbers: + share = 2.0 * (text.get_window_extent().width + pad) / width + if share < 0.9: # a number wider than the plot cannot fit, however set + needed = max(needed, (value + gap) / (1.0 - share)) + if needed <= ax.get_xlim()[1]: + return + limit = needed + ax.set_xlim(-needed, needed) + + def plot_p_values( result: Any, *, @@ -3292,7 +3472,7 @@ def plot_dispersions( handles.append( _key("Outlier, gene-wise", markerfacecolor="none", markeredgecolor=_BLUE) ) - _legend(ax, handles) + _legend(ax, handles, inside=True) return ax @@ -3385,6 +3565,7 @@ def plot_quasi_dispersions( linewidth=2, ), ], + inside=True, ) return ax @@ -4277,20 +4458,11 @@ def plot_sumrank( linestyle=":", gid="threshold", ) + statistic = np.asarray(table[f"{side}_statistic"], dtype=np.float64)[order] shown = np.flatnonzero(passed) - shown = shown[np.lexsort((shown, p[shown]))][:named] - for i in sorted(shown.tolist()): - ax.annotate( - names[order[i]], - (x[i], heights[i]), - xytext=(0.0, 3.0), - textcoords="offset points", - ha="center", - va="bottom", - fontsize=7, - color=color, - gid="labels", - ) + # The smallest p-values first; of equal ones, which permutations give, the + # smallest statistic, the best ranks. + shown = shown[np.lexsort((shown, statistic[shown], p[shown]))][:named] ax.set_xticks([]) ax.set_xlim(-1.0, len(order)) ax.set_ylim(0.0, max(1.0, float(heights.max(initial=0.0))) * 1.12) @@ -4302,6 +4474,7 @@ def plot_sumrank( ) ax.set_xlabel(f"Genes, in alphabetical order ({len(order):,})") ax.set_ylabel(f"-log10 p-value, genes {side} ({source})") + # Beside the plot: the labels run along its top, where a legend inside would go. _legend( ax, [ @@ -4309,9 +4482,105 @@ def plot_sumrank( _key("Other genes", color=_INK), ], ) + # Last, at the size the legend leaves the plot. + _label_above(ax, x, heights, [names[i] for i in order], shown, color) return ax +def _label_above( + ax: "Axes", + x: FloatArray, + y: FloatArray, + names: list[str], + chosen: Any, + color: str, +) -> None: + """Label points from above, at the size the figure is laid out at. A label that + would cross the side of the frame moves in, one that would overlap a label placed + before it moves up, and a moved label has a line to its point; the top of the plot + is raised to show the highest label.""" + textpath = _module("matplotlib.textpath") + root = ax.figure.figure # the Figure, also of Axes in a subfigure + if root is not None: + root.draw_without_rendering() + fontsize = 7.0 # points + order = sorted(chosen, key=lambda i: (-y[i], x[i])) + widths = [ + textpath.TextPath((0.0, 0.0), names[i], size=fontsize).get_extents().width + for i in order + ] + places = _label_places(ax, x, y, order, widths, fontsize) + # Raising the top of the plot changes the scale the labels were placed at: place + # them again until the top stays where it is. + for _ in range(_ROOM_ROUNDS): + bottom, top = ax.get_ylim() + highest = max(level for _, level, _ in places) + 1.25 * fontsize * ( + (top - bottom) / (ax.bbox.height * 72.0 / ax.figure.dpi) + ) + if highest <= top: + break + ax.set_ylim(bottom, highest) + places = _label_places(ax, x, y, order, widths, fontsize) + for i, (center, level, moved) in zip(order, places, strict=True): + ax.annotate( + names[i], + (x[i], y[i]), + xytext=(center, level), + textcoords="data", + ha="center", + va="bottom", + fontsize=fontsize, + color=color, + arrowprops=( + {"arrowstyle": "-", "color": _GREY, "linewidth": 0.6} if moved else None + ), + gid="labels", + ) + + +def _label_places( + ax: "Axes", + x: FloatArray, + y: FloatArray, + order: list[int], + widths: list[float], + fontsize: float, +) -> list[tuple[float, float, bool]]: + """Where each label goes, in data units: its centre, the height of its bottom, + and whether it moved from just above its point.""" + offset, margin = 3.0, 2.0 # points above the point, and from the frame + low, high = ax.get_xlim() + bottom, top = ax.get_ylim() + per_point_x = (high - low) / (ax.bbox.width * 72.0 / ax.figure.dpi) + per_point_y = (top - bottom) / (ax.bbox.height * 72.0 / ax.figure.dpi) + line = 1.25 * fontsize * per_point_y + placed: list[tuple[float, float, float]] = [] # left, right and bottom of each + places = [] + for i, width in zip(order, widths, strict=True): + half = width / 2.0 * per_point_x + inner = margin * per_point_x + lowest, greatest = low + inner + half, high - inner - half + # A label wider than the plot is centred on it; it cannot fit. + center = ( + min(max(x[i], lowest), greatest) if lowest <= greatest else (low + high) / 2 + ) + left, right = center - half, center + half + level = start = y[i] + offset * per_point_y + clear = False + while not clear: + clear = True + for other_left, other_right, other_bottom in placed: + apart = right < other_left or left > other_right + # Each move takes the label to the top of another: it ends. + if not apart and other_bottom - line < level < other_bottom + line: + level = other_bottom + line + clear = False + placed.append((left, right, level)) + shifted = abs(center - x[i]) > fontsize * per_point_x + places.append((center, level, shifted or level - start > 0.1 * line)) + return places + + def plot_held_out_auc( prediction: HeldOutPrediction, *, ax: "Axes | None" = None ) -> "Axes": @@ -4491,8 +4760,9 @@ def plot_pca( samples = _component_samples(data, result) x = np.asarray(result.coordinates[:, first - 1], dtype=np.float64) y = np.asarray(result.coordinates[:, second - 1], dtype=np.float64) + styles = _sample_styles(samples, color_by, marker_by, labels) ax = _axes(ax, (6.5, 4.5)) - _draw_samples(ax, x, y, samples, color_by, marker_by, labels) + _draw_styled_samples(ax, x, y, styles) share = result.variance_explained ax.set_xlabel(f"PC{first}: {100 * share[first - 1]:.0f}% variance") ax.set_ylabel(f"PC{second}: {100 * share[second - 1]:.0f}% variance") @@ -4536,24 +4806,29 @@ def _component_samples(data: Any, result: PrincipalComponents) -> _Samples: ) -def _draw_samples( - ax: "Axes", - x: FloatArray, - y: FloatArray, - samples: _Samples, - color_by: Any, - marker_by: Any, - labels: Any, -) -> None: - """Samples as points, coloured and marked by their variables, as plot_mds draws - them: a hue per level of color_by, a marker per level of marker_by, or of color_by - when it has more levels than scatter plots keep apart; labels when asked; and a - legend of the levels.""" - n_samples = x.size +@dataclass(frozen=True) +class _SampleStyles: + """How each sample of a scatter plot is drawn: its colour, marker and label, + and the legend's entries.""" + + colors: list[str] + markers: list[str] + texts: list[str] | None + handles: list[Any] + + +def _sample_styles( + samples: _Samples, color_by: Any, marker_by: Any, labels: Any +) -> _SampleStyles: + """The colours, markers and labels of samples, by their variables, as plot_mds + draws them: a hue per level of color_by, a marker per level of marker_by, or of + color_by when it has more levels than scatter plots keep apart, and a legend of + the levels. Checks the variables before anything is computed or drawn.""" colors = None if color_by is None else samples.labels(color_by, "color_by") markers = None if marker_by is None else samples.labels(marker_by, "marker_by") remedy = "give it as marker_by, or as labels" hues = {} if colors is None else _hues(colors[1], "color_by", remedy) + # More levels than hues that scatter plots keep apart get a marker each, too. shapes_follow_colors = ( markers is None and colors is not None and len(colors[1]) > _SCATTER_HUES ) @@ -4567,15 +4842,38 @@ def _draw_samples( texts = list(samples.ids) if labels else None else: texts = samples.labels(labels, "labels")[0] + n_samples = len(samples.ids) color_of = [hues[level] for level in colors[0]] if colors else [_BLUE] * n_samples marker_of = [shapes[level] for level in by_shape] if by_shape else None marker_of = marker_of or [_MARKERS[0]] * n_samples - for marker in dict.fromkeys(marker_of): - rows = [i for i in range(n_samples) if marker_of[i] == marker] + handles: list[Any] = [] + if colors is not None: + if isinstance(color_by, str): + handles.append(_key(color_by, marker="")) + for level in colors[1]: + shape = shapes[level] if shapes_follow_colors else _MARKERS[0] + handles.append(_key(level, marker=shape, color=hues[level])) + if markers is not None: + if isinstance(marker_by, str): + handles.append(_key(marker_by, marker="")) + for level in markers[1]: + handles.append(_key(level, marker=shapes[level], color=_GREY)) + return _SampleStyles(color_of, marker_of, texts, handles) + + +def _draw_styled_samples( + ax: "Axes", x: FloatArray, y: FloatArray, styles: _SampleStyles +) -> None: + """Samples as points of their colours and markers, labelled when asked, with a + legend of their levels: inside the plot where a short one covers nothing, and + beside it otherwise.""" + n_samples = x.size + for marker in dict.fromkeys(styles.markers): + rows = [i for i in range(n_samples) if styles.markers[i] == marker] ax.scatter( x[rows], y[rows], - c=[color_of[i] for i in rows], + c=[styles.colors[i] for i in rows], marker=marker, s=_SPARSE, edgecolors="white", @@ -4583,8 +4881,8 @@ def _draw_samples( zorder=3, gid="samples", ) - if texts is not None: - for i, text in enumerate(texts): + if styles.texts is not None: + for i, text in enumerate(styles.texts): ax.annotate( text, (x[i], y[i]), @@ -4593,20 +4891,8 @@ def _draw_samples( fontsize=8, gid="sample labels", ) - handles: list[Any] = [] - if colors is not None: - if isinstance(color_by, str): - handles.append(_key(color_by, marker="")) - for level in colors[1]: - shape = shapes[level] if shapes_follow_colors else _MARKERS[0] - handles.append(_key(level, marker=shape, color=hues[level])) - if markers is not None: - if isinstance(marker_by, str): - handles.append(_key(marker_by, marker="")) - for level in markers[1]: - handles.append(_key(level, marker=shapes[level], color=_GREY)) - if handles: - _legend(ax, handles) + if styles.handles: + _legend(ax, styles.handles, inside=True) def plot_dotplot( @@ -4617,6 +4903,8 @@ def plot_dotplot( samples: Any = None, standard_scale: str | None = None, mean_only_expressed: bool = False, + vmin: float | None = None, + vmax: float | None = None, ax: "Axes | None" = None, ) -> "Axes": """Plot how many cells of each group express each gene, and how much, as dots. @@ -4632,7 +4920,8 @@ def plot_dotplot( A dot's area is 200 (f / f_max)^1.5 points squared, f its fraction and f_max the largest fraction shown rounded up to a tenth, as scanpy sizes its dots, and the key of the areas shows fractions in scanpy's steps. The colours run from the - smallest to the largest value shown. + smallest to the largest value shown, or from ``vmin`` to ``vmax``, scanpy's + names, which put several dot plots on one scale. ``standard_scale`` scales the means of each gene over the groups (``"gene"``, scanpy's ``"var"``), or of each group over the genes (``"group"``), to run from 0 @@ -4662,10 +4951,15 @@ def plot_dotplot( standard_scale: ``"gene"``, ``"group"`` or None. mean_only_expressed: Whether the mean is taken over the cells that express the gene only. + vmin: The value of the lightest colour; the smallest value shown by default. + Smaller values take that colour. + vmax: The value of the darkest colour; the largest value shown by default. + Larger values take that colour. ax: The Axes to draw into, or None for a new figure. Returns: - The Axes. + The Axes of the dots. The colour bar and the key of the dot sizes are Axes + of their own, the figure's other Axes (``ax.figure.axes``). Raises: TypeError: If an argument has the wrong type, or is or holds a numpy masked @@ -4673,8 +4967,8 @@ def plot_dotplot( ValueError: If the cube lacks cell numbers, ``detected`` or ``log_sum``, a group has no cells in the samples pooled, ``genes``, ``groups`` or ``samples`` is empty or names one twice, a symbol names several genes, - ``mean_only_expressed`` is asked of a cube without a pseudocount of 1, or - an option is out of range. + ``mean_only_expressed`` is asked of a cube without a pseudocount of 1, + ``vmin`` is not below ``vmax``, or an option is out of range. KeyError: If a gene, group or sample is not in the cube. """ _check_axes(ax) @@ -4686,6 +4980,10 @@ def plot_dotplot( else checked_choice(standard_scale, "standard_scale", _DOT_SCALES) ) expressed_only = checked_flag(mean_only_expressed, "mean_only_expressed") + for name, value in (("vmin", vmin), ("vmax", vmax)): + if value is not None: + reject_masked(value, name) + real_number(value, name, finite=True) lacking = [name for name in ("detected", "log_sum") if name not in cube.layer_names] if cube.n_cells is None or lacking: what = ( @@ -4720,7 +5018,17 @@ def plot_dotplot( colors = _module("matplotlib.colors") ramp = colors.LinearSegmentedColormap.from_list("cytepool_blues", _BLUES) low, high = float(shown.min()), float(shown.max()) - norm = colors.Normalize(vmin=low, vmax=high if high > low else low + 1.0) + if vmin is None and vmax is None: + norm = colors.Normalize(vmin=low, vmax=high if high > low else low + 1.0) + else: + lightest = low if vmin is None else float(vmin) + darkest = high if vmax is None else float(vmax) + if not lightest < darkest: + raise ValueError( + f"vmin ({lightest:g}) must be below vmax ({darkest:g}); without one " + f"of them, the values shown run from {low:g} to {high:g}" + ) + norm = colors.Normalize(vmin=lightest, vmax=darkest) width = min(14.0, 3.0 + 0.4 * n_genes) ax = _axes(ax, (width, min(12.0, max(4.0, 1.6 + 0.4 * n_groups)))) y, x = np.indices((n_groups, n_genes)) diff --git a/cytepool/principal_components.py b/cytepool/principal_components.py index 0794c0f..94164db 100644 --- a/cytepool/principal_components.py +++ b/cytepool/principal_components.py @@ -53,6 +53,12 @@ import numpy as np import numpy.typing as npt +from ._analysis_records import ( + keep_provenance, + provenance_of, + provenance_text, + restore_provenance, +) from ._columns import text_column from ._masked_arrays import read_only, real_array, reject_masked, unmasked_array from ._messages import quoted @@ -112,11 +118,38 @@ class PrincipalComponents: samples: Table settings: Mapping[str, Any] + def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: + # The settings are a read-only view, which pickle cannot write: a dict + # travels in their place, and the provenance kept outside the fields with it. + return ( + _restored_components, + ( + self.coordinates, + self.variance_explained, + self.loadings, + self.genes, + self.samples, + dict(self.settings), + provenance_text(self), + ), + ) + @property def n_components(self) -> int: """The number of components.""" return int(self.coordinates.shape[1]) + @property + def provenance(self) -> dict[str, Any] | None: + """A JSON-serialisable record of what produced the components of a cube's + group, as a new dict: the method, the CytePool, numpy, numba and Python + versions, the cube's fingerprint, the digests it is built from and its + provenance (``"cube"``), the layer read and the settings; None for + components of values given as an array or a VoomResult. The cube's record + costs what it costs for + :func:`~cytepool.differential_expression.limma_voom` ("Provenance").""" + return provenance_of(self) + def __repr__(self) -> str: n_samples, n_components = self.coordinates.shape shares = ", ".join(f"{100 * v:.1f}%" for v in self.variance_explained[:3]) @@ -127,6 +160,27 @@ def __repr__(self) -> str: ) +def _restored_components( + coordinates: FloatArray, + variance_explained: FloatArray, + loadings: FloatArray, + genes: IntArray, + samples: Table, + settings: dict[str, Any], + provenance: str | None, +) -> PrincipalComponents: + """Principal components unpickled: read-only again, with their provenance.""" + restored = PrincipalComponents( + coordinates=read_only(np.asarray(coordinates)), + variance_explained=read_only(np.asarray(variance_explained)), + loadings=read_only(np.asarray(loadings)), + genes=read_only(np.asarray(genes)), + samples=samples, + settings=MappingProxyType(settings), + ) + return restore_provenance(restored, provenance) + + def principal_components( data: Any, *, @@ -197,7 +251,7 @@ def principal_components( coordinates *= signs loadings *= signs settings["top"] = count - return PrincipalComponents( + result = PrincipalComponents( coordinates=read_only(np.ascontiguousarray(coordinates)), variance_explained=read_only(singular**2 / total), loadings=read_only(np.ascontiguousarray(loadings)), @@ -205,6 +259,9 @@ def principal_components( samples=samples, settings=MappingProxyType(settings), ) + if isinstance(data, Cube): + keep_provenance(result, "principal_components", data, settings) + return result def _signs(coordinates: FloatArray) -> FloatArray: diff --git a/cytepool/replication.py b/cytepool/replication.py index dc04b1c..487ee52 100644 --- a/cytepool/replication.py +++ b/cytepool/replication.py @@ -33,11 +33,17 @@ For an ordered pair of studies, the discovery and the replication, the genes the discovery finds that the replication tested are compared: pi1 = 1 - pi0 of their p-values in the replication study, Storey's estimate of the proportion of them - with an effect there (:func:`~cytepool.stats.multiple_testing.proportion_of_true_nulls`, - with qvalue's defaults unless ``null_proportion`` says otherwise), which counts - effects that the replication study is too small to find on its own; the share of - them whose log2 fold changes have the same sign; and how many it finds too. pi1 - measures replication in the replication study's p-values, so it is not symmetric. + with an effect there (:func:`~cytepool.stats.multiple_testing.proportion_of_true_nulls`), + which counts effects that the replication study is too small to find on its + own; the share of them whose log2 fold changes have the same sign; and how many + it finds too. pi1 measures replication in the replication study's p-values, so it + is not symmetric. + + pi0 is estimated at lambda = 0.5 by default: the share of p-values above 0.5, + over 0.5 (Storey and Tibshirani 2003). qvalue's default, a smoother of the + estimates at lambda = 0.05, ..., 0.95 (``null_proportion={}``), reads the + largest lambdas, where the few dozen p-values of the genes one study finds + leave too few values, so that it often gives pi1 of 0 or 1 there. Heterogeneity: Cochran's Q, its p-value, I^2 and tau^2 of the log2 fold changes and their @@ -87,7 +93,7 @@ from ._analysis_records import software_versions from ._columns import text_column from ._masked_arrays import reject_masked -from ._messages import quoted +from ._messages import fitted_lines, quoted from ._options import checked_choice, integral_number, real_number from .cube import CubeCollection from .differential_expression import DifferentialExpressionResult @@ -106,6 +112,9 @@ # The columns of the studies' tables that the analysis reads. _COLUMNS = ("log2_fold_change", "standard_error", "p_value", "adjusted_p_value") _NULL_PROPORTION_OPTIONS = ("lambdas", "method", "smooth_df", "smooth_log") +# pi0 of pi1 by default: at one lambda, steady on the few dozen p-values of the genes +# a study finds, where qvalue's smoother often gives 0 or 1. +_NULL_PROPORTION_DEFAULT = {"lambdas": 0.5} class ReplicationResult: @@ -253,11 +262,11 @@ def __repr__(self) -> str: replicated = self._genes["replication_adjusted_p_value"] with np.errstate(invalid="ignore"): n_replicated = int(np.count_nonzero(replicated < settings["alpha"])) - return ( + return fitted_lines( f"ReplicationResult of group {settings['group']!r}, contrast " - f"{settings['contrast']!r}: {analysed} of {len(self._studies)} studies, " - f"{len(self._genes):,} genes; {n_replicated:,} found in at least " - f"{settings['at_least']} studies in one direction at adjusted p < " + f"{settings['contrast']!r}: {analysed:,} of {len(self._studies):,} " + f"studies, {len(self._genes):,} genes; {n_replicated:,} found in at least " + f"{settings['at_least']:,} studies in one direction at adjusted p < " f"{settings['alpha']:g} ({settings['conjunction_method']})" ) @@ -316,8 +325,9 @@ def differential_expression_replication( (:func:`~cytepool.meta_analysis.meta_analysis`). null_proportion: Options of :func:`~cytepool.stats.multiple_testing.proportion_of_true_nulls` for pi1: - ``lambdas``, ``method``, ``smooth_df`` and ``smooth_log``; qvalue's - defaults by default. + ``lambdas``, ``method``, ``smooth_df`` and ``smooth_log``. None, the + default, is ``{"lambdas": 0.5}``; ``{}`` takes qvalue's defaults (see + the module description). Returns: The tables of genes, pairs of studies, counts by number of studies and @@ -516,7 +526,7 @@ def differential_expression_replication( def _null_proportion_options(value: Any) -> dict[str, Any]: if value is None: - return {} + return dict(_NULL_PROPORTION_DEFAULT) if not isinstance(value, Mapping): raise TypeError( "null_proportion must be a mapping of options of proportion_of_true_nulls, " diff --git a/cytepool/score_tests.py b/cytepool/score_tests.py new file mode 100644 index 0000000..7b0cd9a --- /dev/null +++ b/cytepool/score_tests.py @@ -0,0 +1,317 @@ +"""Tests of per-sample scores with a design: limma on pathway scores and activities. + +Pathway scores (:mod:`cytepool.pathway_scores`) and activities of regulators +(:mod:`cytepool.activity`) give every sample of a cube's group one value per gene set +or source, which differ between conditions as expression values do. GSVA's guide +tests its scores with limma, as decoupler's guides test activities: a linear model of +every set's scores on the design (``lmFit``), the contrast (``contrasts.fit``), +moderated t-tests (``eBayes``, Smyth 2004) and a table of the results (``topTable``). +:func:`limma` takes these steps in one call, with the :class:`~cytepool.design.Design` +built for the cube: its rows are matched to the scores by ``sample_id``, so that the +samples a score leaves out, such as those with too few cells, leave the fit too. + +The fit: + The samples fitted are those of the scores that the design has, in the order of + the scores. The design matrix is the design's rows for them, so every column keeps + its meaning; when those rows do not determine every column (the samples left out + took a donor's every sample, say), the fit keeps the columns that span them, as + R's ``qr()`` keeps them and :func:`~cytepool.differential_expression.limma_voom` + fits a group, and the contrast is tested when it is estimable from these samples + (see "The design of a group" in :mod:`cytepool.differential_expression`). Missing + scores (NaN) leave a set out of the fit of the samples they miss, as limma's + ``lmFit`` does. + +References: + Smyth GK (2004). Linear models and empirical Bayes methods for assessing + differential expression in microarray experiments. Statistical Applications in + Genetics and Molecular Biology 3, article 3. doi:10.2202/1544-6115.1027 + + Haenzelmann S, Castelo R, Guinney J (2013). GSVA: gene set variation analysis for + microarray and RNA-seq data. BMC Bioinformatics 14, 7. + doi:10.1186/1471-2105-14-7 + + Benjamini Y, Hochberg Y (1995). Controlling the false discovery rate: a practical + and powerful approach to multiple testing. Journal of the Royal Statistical + Society B 57, 289-300. doi:10.1111/j.2517-6161.1995.tb02031.x +""" + +from dataclasses import replace +from typing import Any + +import numpy as np +import numpy.typing as npt + +from ._columns import text_column +from ._masked_arrays import real_array, reject_masked, unmasked_array +from ._messages import listing, quoted +from .activity import Activities +from .design import Contrasts, Design +from .design._design_matrices import refuse_random_effects +from .design.checks import _aliasing, _contrast_violations +from .pathway_scores import PathwayScores +from .stats._result_tables import feature_id_column +from .stats.empirical_bayes import moderated_statistics +from .stats.linear_models import contrasts_fit, fit_linear_model +from .stats.multiple_testing import adjust_p_values +from .table import Table + +__all__ = ["limma"] + +FloatArray = npt.NDArray[np.float64] + + +def limma( + data: Any, + design: Design, + *, + contrast: str | None = None, + feature_ids: Any = None, + sample_ids: Any = None, + weights: Any = None, + trend: Any = False, + robust: bool = False, +) -> Table: + """Test a contrast of a design on scores of samples, by limma. + + limma's ``lmFit``, ``contrasts.fit``, ``eBayes`` and ``topTable(sort.by = + "none")`` for one contrast: a linear model of the scores of every gene set, + source or feature on the design, moderated t-tests of the contrast, and + Benjamini-Hochberg adjusted p-values over them. The module description says + which samples are fitted and how a design that its samples do not determine is + fitted. Sort the table to read it, as ``limma(scores, design).sort("p_value")``. + + Args: + data: :class:`~cytepool.pathway_scores.PathwayScores`, such as + :func:`~cytepool.pathway_scores.gsva` returns; + :class:`~cytepool.activity.Activities` of samples, such as + :func:`~cytepool.activity.ulm` returns for a cube's group; or an array of + values, samples x features, NaN where missing, such as log-expression + values of another platform. + design: A :class:`~cytepool.design.Design` whose sample table has a + ``sample_id`` column, such as the design built for the cube, with named + contrasts; random effects are refused, as by + :func:`~cytepool.differential_expression.limma_voom`. + contrast: The name of one of the design's contrasts; it may be left out + when the design has one. + feature_ids: For an array, one id per column, as text; ``feature_0``, + ``feature_1``, ... by default. + sample_ids: For an array, one sample id per row, among the design's; by + default the rows are the design's samples, in order. + weights: Weights of the fit, as ``lmFit`` takes them: one per sample, in the + order of the rows of the scores, or one per sample and score; positive + and finite. None weighs every value alike. + trend: Whether the prior variance of the moderation follows the mean of the + scores (``eBayes(trend = TRUE)``), or one covariate value per gene set, + source or feature, such as ``scores.n_genes``, as GSVA's guide passes the + sizes of the sets. + robust: Whether to estimate the prior of the moderation robustly, as + ``eBayes(robust = TRUE)`` does. + + Returns: + A table with one row per gene set, source or feature, in the order of the + data: ``gene_set``, ``source`` or ``feature_id``; ``estimate``, the + contrast of the scores (``logFC``); ``standard_error``, its moderated + standard error; ``average``, the mean of the scores over the samples fitted + (``AveExpr``); ``t``; ``p_value``; ``adjusted_p_value``; and ``log_odds``, + the B-statistic (``B``). + + Raises: + TypeError: If an argument has the wrong type, or is or holds a numpy masked + array. + ValueError: If the activities are of statistics rather than samples, + ``feature_ids`` or ``sample_ids`` is given with scores or activities, the + design has random effects or no ``sample_id`` column, no sample of the + data is in the design, the design leaves no residual degrees of freedom + on its samples, the contrast is not estimable from them, or the design + has several contrasts and none is named. + KeyError: If the design has no contrast of that name. + """ + if not isinstance(design, Design): + raise TypeError( + "design must be a Design whose sample table has a sample_id column, got " + f"{type(design).__name__}" + ) + refuse_random_effects(design, "limma") + values, rows, id_column, ids = _scores(data, feature_ids, sample_ids, design) + name, column = _contrast(design, contrast) + data_rows, design_rows = _matched(rows, design) + x = design.matrix[design_rows] + aliasing = _aliasing(x) + kept = list(aliasing.kept) + n_used = len(design_rows) + if n_used <= len(kept): + raise ValueError( + f"no residual degrees of freedom: the design has rank {len(kept)} on the " + f"{n_used} sample{'' if n_used == 1 else 's'} of the data, so the fit " + "cannot estimate a variance" + ) + chosen = Contrasts( + design.contrasts.matrix[:, [column]], (name,), tuple(design.columns) + ) + violations = _contrast_violations( + replace(design.model_matrix, matrix=x), aliasing, chosen + ) + if violations: + raise ValueError( + f"the contrast {name!r} is not estimable from the samples of the data, " + "which cannot separate the effects it depends on: " + + "; ".join(violations[0]) + ) + columns = tuple(design.columns[j] for j in kept) + fit = fit_linear_model( + np.ascontiguousarray(values[data_rows]), + np.ascontiguousarray(x[:, kept]), + weights=_weights(weights, values.shape, data_rows), + coefficient_names=columns, + ) + tested = contrasts_fit( + fit, Contrasts(chosen.matrix[kept], (name,), columns), method="exact" + ) + moderated = moderated_statistics(tested, trend=trend, robust=robust) + p_value = moderated.p_value[:, 0] + return Table( + { + id_column: ids, + "estimate": tested.coefficients[:, 0], + "standard_error": tested.stdev_unscaled[:, 0] + * np.sqrt(moderated.posterior_variance), + "average": fit.mean_expression, + "t": moderated.t[:, 0], + "p_value": p_value, + "adjusted_p_value": adjust_p_values(p_value, "bh"), + "log_odds": moderated.lods[:, 0], + } + ) + + +def _scores( + data: Any, feature_ids: Any, sample_ids: Any, design: Design +) -> tuple[FloatArray, list[str] | None, str, np.ndarray]: + """The values (samples x scores), the sample id of each row (None: the design's + rows), the name of the id column and the ids of the scores.""" + if isinstance(data, PathwayScores | Activities): + for name, value in (("feature_ids", feature_ids), ("sample_ids", sample_ids)): + if value is not None: + reject_masked(value, name) + raise ValueError( + f"{name} applies to an array; the {type(data).__name__} name " + "their samples and scores" + ) + if isinstance(data, PathwayScores): + rows = data.samples["sample_id"].tolist() + ids = text_column(list(data.gene_sets)) + return np.asarray(data.scores, dtype=np.float64), rows, "gene_set", ids + if isinstance(data, Activities): + if "sample_id" not in data.profiles: + raise ValueError( + "limma tests scores of samples, and these activities are of the " + "statistics of contrasts (their profiles are groups and contrasts, " + "with no sample_id), which are tested already; score the samples of a " + "cube's group, as ulm(cube, network, group=...) does" + ) + rows = data.profiles["sample_id"].tolist() + ids = text_column(list(data.sources)) + return np.asarray(data.scores, dtype=np.float64), rows, "source", ids + if not isinstance(data, np.ndarray | list | tuple): + raise TypeError( + "data must be PathwayScores, Activities of samples, or an array of values " + f"(samples x features), got {type(data).__name__}" + ) + array = unmasked_array(data, "data", missing="NaN") + values = real_array(array, "data", boolean=False, objects=False) + if values.ndim != 2 or values.shape[0] == 0 or values.shape[1] == 0: + raise ValueError( + "data must be a 2-D array of values with at least one sample and one " + f"feature, samples x features, got shape {values.shape}" + ) + if np.isinf(values).any(): + raise ValueError("data holds infinite values; mark missing values with NaN") + ids = feature_id_column(feature_ids, values.shape[1]) + if sample_ids is None: + if values.shape[0] != design.n_samples: + raise ValueError( + f"data has {values.shape[0]} rows and the design {design.n_samples} " + "samples; give sample_ids, the sample id of each row, to match them" + ) + return np.asarray(values, dtype=np.float64), None, "feature_id", ids + given = unmasked_array(sample_ids, "sample_ids") + if given.ndim != 1 or given.size != values.shape[0]: + raise ValueError( + f"sample_ids must hold one id per row of data ({values.shape[0]}), got " + f"shape {given.shape}" + ) + rows = given.tolist() + if not all(isinstance(row, str) and row for row in rows): + raise TypeError("sample_ids must hold text ids, as the design's sample_id does") + if len(set(rows)) != len(rows): + raise ValueError("sample_ids must be unique: each row is one sample") + return np.asarray(values, dtype=np.float64), rows, "feature_id", ids + + +def _contrast(design: Design, contrast: Any) -> tuple[str, int]: + """The name of the contrast tested and its column among the design's.""" + names = list(design.contrasts.names) + if contrast is None: + if len(names) != 1: + raise ValueError( + f"the design has {len(names)} contrasts; name one with contrast" + + (f", one of {quoted(names)}" if names else "") + + ( + "" + if names + else ", after giving the design contrasts, as in " + "design.with_contrasts({'stim_vs_ctrl': 'conditionstim'})" + ) + ) + return names[0], 0 + if not isinstance(contrast, str): + reject_masked(contrast, "contrast") + raise TypeError( + f"contrast must be the name of a contrast of the design, got " + f"{type(contrast).__name__}" + ) + if contrast not in names: + raise KeyError( + f"the design has no contrast {contrast!r}; its contrasts are: " + f"{listing(names) or '(none)'}" + ) + return contrast, names.index(contrast) + + +def _matched(rows: list[str] | None, design: Design) -> tuple[list[int], list[int]]: + """The rows of the data and of the design fitted: the data's samples that the + design has, in the data's order.""" + if rows is None: + every = list(range(design.n_samples)) + return every, every + if "sample_id" not in design.samples: + raise ValueError( + "the design's sample table has no 'sample_id' column, so its rows cannot " + "be matched to the samples of the scores; build the Design from the " + "cube's samples" + ) + position = { + value: i for i, value in enumerate(design.samples["sample_id"].tolist()) + } + data_rows = [i for i, sample in enumerate(rows) if sample in position] + if not data_rows: + raise ValueError( + "none of the samples of the data is in the design: the data's samples " + f"are such as {quoted(rows[:3])}, the design's such as " + f"{quoted(list(position)[:3])}" + ) + return data_rows, [position[rows[i]] for i in data_rows] + + +def _weights(weights: Any, shape: tuple[int, int], rows: list[int]) -> Any: + """The weights of the samples fitted: one per sample, or per sample and score.""" + if weights is None: + return None + array = real_array(unmasked_array(weights, "weights"), "weights", boolean=False) + if array.shape not in ((shape[0],), shape): + raise ValueError( + f"weights must hold one weight per sample ({shape[0]}) or per sample and " + f"score {shape}, in the order of the rows of the data, got shape " + f"{array.shape}" + ) + return np.ascontiguousarray(array[rows], dtype=np.float64) diff --git a/cytepool/stats/_result_tables.py b/cytepool/stats/_result_tables.py new file mode 100644 index 0000000..127b0eb --- /dev/null +++ b/cytepool/stats/_result_tables.py @@ -0,0 +1,84 @@ +"""Tables of the tests of fits on arrays, with the columns of the result tables. + +``ModeratedFit.table``, ``QuasiLikelihoodTest.table`` and ``DESeq2Results.table`` +lay out the statistics of every feature as the tables of the workflows on cubes lay +them out, a ``feature_id`` column first, so that an analysis built from the building +blocks reads like one of a cube and its calls can be found by gene. +""" + +from typing import Any + +import numpy as np + +from cytepool._columns import text_column +from cytepool._masked_arrays import reject_masked, unmasked_array +from cytepool._messages import quoted +from cytepool._options import integral_number + + +def feature_id_column(feature_ids: Any, n: int) -> np.ndarray: + """The ``feature_id`` column of a table of ``n`` features: the ids given, one per + feature, or ``feature_0``, ``feature_1``, ... as ``from_bulk`` names the + features of counts without ids. + + Raises: + TypeError: If an id is not a string, or ``feature_ids`` is or holds a numpy + masked array. + ValueError: If there is not one id per feature, or an id is missing or + empty. + """ + if feature_ids is None: + return text_column([f"feature_{j}" for j in range(n)]) + if isinstance(feature_ids, str): + raise TypeError( + "feature_ids must give one id per feature, as a list or an array, not a " + "single string" + ) + array = unmasked_array(feature_ids, "feature_ids") + if array.ndim != 1 or array.size != n: + raise ValueError( + f"feature_ids must hold one id per feature ({n}), got shape {array.shape}" + ) + ids = array.tolist() + for position, value in enumerate(ids): + if not isinstance(value, str): + raise TypeError( + f"feature_ids must hold text ids, got {type(value).__name__} " + f"{value!r} at position {position}; convert numeric ids to text first" + ) + if not value: + raise ValueError(f"feature_ids has an empty id at position {position}") + return text_column(ids) + + +def coefficient_position(value: Any, names: tuple[str, ...]) -> int: + """The position of a coefficient or contrast of a fit, given by name or position, + or the only one when ``value`` is None. + + Raises: + ValueError: If ``value`` is None and the fit has several. + KeyError: If no coefficient has the name. + IndexError: If the position is out of range. + TypeError: If ``value`` is neither a name nor a position. + """ + if value is None: + if len(names) != 1: + raise ValueError( + f"the fit has {len(names)} coefficients or contrasts; name one with " + f"coefficient, one of {quoted(list(names))}" + ) + return 0 + reject_masked(value, "coefficient") + if isinstance(value, str): + if value not in names: + raise KeyError( + f"no coefficient or contrast {value!r}; they are: {quoted(list(names))}" + ) + return names.index(value) + position = integral_number(value, "coefficient", expected="a name or a position") + if not -len(names) <= position < len(names): + raise IndexError( + f"coefficient position {position} is out of range for {len(names)} " + "coefficients" + ) + return position % len(names) diff --git a/cytepool/stats/deseq2.py b/cytepool/stats/deseq2.py index 9aca8f2..31116c5 100644 --- a/cytepool/stats/deseq2.py +++ b/cytepool/stats/deseq2.py @@ -224,12 +224,14 @@ from cytepool.design.design import Design from cytepool.normalization import median_ratio_size_factors from cytepool.stats._negative_binomial import linear_predictors, log1p_ratio +from cytepool.stats._result_tables import feature_id_column from cytepool.stats._scalar_special_functions import log_gamma_increment, stirling_error from cytepool.stats.distributions import chi2_sf, f_ppf, norm_sf from cytepool.stats.multiple_testing import adjust_p_values from cytepool.stats.negative_binomial_models import negative_binomial_deviance from cytepool.stats.smoothing import lowess from cytepool.stats.special import digamma_scalar, lgamma_scalar, trigamma +from cytepool.table import Table __all__ = [ "DESeq2Dispersions", @@ -535,6 +537,36 @@ class DESeq2Results: rejections: FloatArray rejections_fit: FloatArray + def table(self, *, feature_ids: Any = None) -> Table: + """Return the test as a table, one row per gene in the order of the counts. + + DESeq2's ``results()``, with the columns of the tables of + :func:`~cytepool.differential_expression.limma_voom`: ``feature_id``; + ``base_mean`` (``baseMean``); ``log2_fold_change`` (``log2FoldChange``); + ``standard_error`` (``lfcSE``); ``statistic`` (``stat``); ``p_value`` + (``pvalue``); and ``adjusted_p_value`` (``padj``). + + Args: + feature_ids: One id per gene, as text, such as the gene ids of the + columns of the counts; by default ``feature_0``, ``feature_1``, ... + + Raises: + ValueError: If ``feature_ids`` does not give one id per gene. + TypeError: If an id is not text, or ``feature_ids`` is or holds a numpy + masked array. + """ + return Table( + { + "feature_id": feature_id_column(feature_ids, self.p_value.size), + "base_mean": self.base_mean, + "log2_fold_change": self.log2_fold_change, + "standard_error": self.standard_error, + "statistic": self.statistic, + "p_value": self.p_value, + "adjusted_p_value": self.adjusted_p_value, + } + ) + def __repr__(self) -> str: significant = int(np.count_nonzero(self.adjusted_p_value < self.alpha)) return ( diff --git a/cytepool/stats/empirical_bayes.py b/cytepool/stats/empirical_bayes.py index 59af495..deb588f 100644 --- a/cytepool/stats/empirical_bayes.py +++ b/cytepool/stats/empirical_bayes.py @@ -110,6 +110,7 @@ posterior_variances, ) from cytepool.stats._optimize import brent_minimum +from cytepool.stats._result_tables import coefficient_position, feature_id_column from cytepool.stats.distributions import ( _f_log_x_density, _f_tail_quantile, @@ -131,6 +132,7 @@ natural_spline_basis, ) from cytepool.stats.special import digamma, trigamma, trigamma_inverse +from cytepool.table import Table __all__ = [ "FDistributionFit", @@ -336,6 +338,52 @@ class ModeratedFit: proportion: float prior_estimator: str + def table( + self, coefficient: str | int | None = None, *, feature_ids: Any = None + ) -> Table: + """Return the tests of one coefficient or contrast as a table. + + limma's ``topTable(sort.by = "none")``, with the columns of the tables of + :func:`~cytepool.differential_expression.limma_voom`, one row per feature + in the order of the fit: ``feature_id``; ``log2_fold_change``, the + coefficient (``logFC``); ``standard_error``, its moderated standard error, + ``stdev_unscaled`` times the posterior standard deviation; + ``average_log2_cpm``, the mean of the values fitted (``AveExpr``); ``t`` and + ``p_value``; ``adjusted_p_value``, Benjamini-Hochberg over the features + (``adj.P.Val``); and ``log_odds``, the B-statistic (``B``). The names of the + effect and of the mean are those of log2 counts per million, such as voom's, + as limma names them ``logFC`` and ``AveExpr`` whatever the values. + + Args: + coefficient: The coefficient or contrast, by name or position; it may be + left out when the fit has one. + feature_ids: One id per feature, as text, such as the gene ids of the + columns of the counts; by default ``feature_0``, ``feature_1``, ... + + Raises: + ValueError: If ``coefficient`` is left out and the fit has several, or + ``feature_ids`` does not give one id per feature. + KeyError, IndexError: If ``coefficient`` names or points to none. + TypeError: If an argument has the wrong type, or is or holds a numpy + masked array. + """ + j = coefficient_position(coefficient, self.fit.coefficient_names) + ids = feature_id_column(feature_ids, self.t.shape[0]) + p_value = self.p_value[:, j] + return Table( + { + "feature_id": ids, + "log2_fold_change": self.fit.coefficients[:, j], + "standard_error": self.fit.stdev_unscaled[:, j] + * np.sqrt(self.posterior_variance), + "average_log2_cpm": self.fit.mean_expression, + "t": self.t[:, j], + "p_value": p_value, + "adjusted_p_value": adjust_p_values(p_value, "bh"), + "log_odds": self.lods[:, j], + } + ) + def __repr__(self) -> str: return ( f"ModeratedFit(n_features={self.t.shape[0]}, " diff --git a/cytepool/stats/quasi_likelihood.py b/cytepool/stats/quasi_likelihood.py index 5828d69..3449f34 100644 --- a/cytepool/stats/quasi_likelihood.py +++ b/cytepool/stats/quasi_likelihood.py @@ -214,6 +214,7 @@ unit_deviances, ) from cytepool.stats._optimize import brent_minimum +from cytepool.stats._result_tables import feature_id_column from cytepool.stats._scalar_special_functions import stirling_error from cytepool.stats.distributions import f_sf from cytepool.stats.empirical_bayes import squeeze_variances @@ -223,6 +224,7 @@ fit_negative_binomial_model, ) from cytepool.stats.smoothing import lowess +from cytepool.table import Table __all__ = [ "QuasiLikelihoodFit", @@ -1682,6 +1684,42 @@ class QuasiLikelihoodTest: df_test: int df_total: FloatArray + def table(self, *, feature_ids: Any = None) -> Table: + """Return the tests as a table, one row per gene in the order of the counts. + + edgeR's ``topTags(sort.by = "none")``, with the columns of the tables of + :func:`~cytepool.differential_expression.limma_voom`: ``feature_id``; + ``log2_fold_change`` (``logFC``), or, for several coefficients or contrasts + tested together, ``log2_fold_change_`` for each, as the F-tests of + :func:`~cytepool.differential_expression.dream_voom` name them; + ``average_log2_cpm`` (``logCPM``); ``f_statistic`` (``F``); ``p_value`` + (``PValue``); and ``adjusted_p_value`` (``FDR``). + + Args: + feature_ids: One id per gene, as text, such as the gene ids of the + columns of the counts; by default ``feature_0``, ``feature_1``, ... + + Raises: + ValueError: If ``feature_ids`` does not give one id per gene. + TypeError: If an id is not text, or ``feature_ids`` is or holds a numpy + masked array. + """ + columns: dict[str, Any] = { + "feature_id": feature_id_column(feature_ids, self.f_statistic.size) + } + if len(self.names) == 1: + columns["log2_fold_change"] = self.log_fold_change[:, 0] + else: + for j, name in enumerate(self.names): + columns[f"log2_fold_change_{name}"] = self.log_fold_change[:, j] + columns |= { + "average_log2_cpm": self.average_log_cpm, + "f_statistic": self.f_statistic, + "p_value": self.p_value, + "adjusted_p_value": self.adjusted_p_value, + } + return Table(columns) + def __repr__(self) -> str: n_significant = int(np.count_nonzero(self.adjusted_p_value < 0.05)) return ( diff --git a/cytepool/study_results.py b/cytepool/study_results.py new file mode 100644 index 0000000..7d11bad --- /dev/null +++ b/cytepool/study_results.py @@ -0,0 +1,430 @@ +"""The differential expression of every study of a collection, analysed alike. + +Studies of one question, such as cohorts of a disease, are compared or combined only +once each is analysed on the collection's axes: its aligned cube +(:meth:`~cytepool.cube.CubeCollection.aligned_cube`), with a design built from its own +samples. :func:`analyse_each_study` runs one analysis per study that way, and +:class:`StudyResults` keeps the results with their collection: it lines them up gene +by gene (:meth:`StudyResults.table`, as +:func:`~cytepool.meta_analysis.align_study_results` does) and gives one column of every +study as a studies x features matrix (:meth:`StudyResults.matrix`), the form that +combined p-values (:func:`~cytepool.stats.combined_p_values.combine_p_values`) and +SumRank (:func:`~cytepool.sumrank.sumrank`) take. + +Memory: + Each result keeps the cube it analysed (see + :class:`~cytepool.differential_expression.DifferentialExpressionResult`), here the + study's aligned cube. The aligned cube of a cube read with + :func:`~cytepool.io.read_cube` stays on disk; that of a cube in memory, when its + groups or features are selected or renamed, holds a copy of the study's values, + which the results keep for as long as they exist. +""" + +from collections.abc import Iterator, Mapping +from types import MappingProxyType +from typing import Any, Literal + +import numpy as np + +from ._columns import text_column +from ._masked_arrays import reject_masked +from ._messages import fitted_lines, quoted +from .cube import CubeCollection +from .design import Design +from .differential_expression import ( + DifferentialExpressionResult, + dream_voom, + limma_trend, + limma_voom, +) +from .meta_analysis import align_study_results +from .table import Table + +__all__ = ["StudyResults", "analyse_each_study"] + +_ANALYSES = (limma_voom, limma_trend, dream_voom) + + +class StudyResults(Mapping[str, DifferentialExpressionResult]): + """The differential-expression result of every study of a collection. + + A read-only mapping of study name to result, in the order of the collection's + studies, with the collection the results analysed. Each result is the analysis + of the study's aligned cube, such as :func:`analyse_each_study` makes, so that + its groups are the collection's aligned groups and its features those the study + measured. Immutable. + + Args: + collection: The collection whose aligned cubes the results analysed. + results: The result of every study of the collection, by study name, from + :func:`~cytepool.differential_expression.limma_voom`, + :func:`~cytepool.differential_expression.limma_trend` or + :func:`~cytepool.differential_expression.dream_voom`. + + Raises: + TypeError: If ``collection`` is not a ``CubeCollection``, ``results`` not a + mapping, or a result not a ``DifferentialExpressionResult``. + ValueError: If ``results`` does not give the result of every study of the + collection, and no other. + """ + + __slots__ = ("_collection", "_results") + + _collection: CubeCollection + _results: dict[str, DifferentialExpressionResult] + + def __init__( + self, + collection: CubeCollection, + results: Mapping[str, DifferentialExpressionResult], + ) -> None: + if not isinstance(collection, CubeCollection): + raise TypeError( + f"collection must be a CubeCollection, got {type(collection).__name__}" + ) + if not isinstance(results, Mapping): + raise TypeError( + "results must be a mapping of study names to " + "DifferentialExpressionResult, one for every study of the collection, " + f"got {type(results).__name__}" + ) + studies = collection.studies + missing = [study for study in studies if study not in results] + extra = [name for name in results if name not in studies] + if missing or extra: + parts = [] + if missing: + parts.append(f"missing {quoted(missing)}") + if extra: + parts.append(f"not in the collection: {quoted(extra)}") + raise ValueError( + "results must give the result of every study of the collection, and " + "no other: " + "; ".join(parts) + ) + for study in studies: + if not isinstance(results[study], DifferentialExpressionResult): + raise TypeError( + f"results[{study!r}] must be a DifferentialExpressionResult, from " + "limma_voom, limma_trend or dream_voom, got " + f"{type(results[study]).__name__}" + ) + object.__setattr__(self, "_collection", collection) + object.__setattr__( + self, "_results", {study: results[study] for study in studies} + ) + + def __setattr__(self, name: str, value: object) -> None: + raise AttributeError("StudyResults is immutable") + + def __delattr__(self, name: str) -> None: + raise AttributeError("StudyResults is immutable") + + def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: + return (StudyResults, (self._collection, self._results)) + + # The mapping. + + def __getitem__(self, study: str) -> DifferentialExpressionResult: + """Return the result of one study. + + Raises: + KeyError: If there is no such study. + """ + try: + return self._results[study] + except (KeyError, TypeError): + raise KeyError( + f"no study named {study!r}; studies are: {quoted(list(self._results))}" + ) from None + + def __iter__(self) -> Iterator[str]: + """Iterate over the study names, in the collection's order.""" + return iter(self._results) + + def __len__(self) -> int: + """Return the number of studies.""" + return len(self._results) + + # What the results hold together. + + @property + def collection(self) -> CubeCollection: + """The collection whose aligned cubes the results analysed.""" + return self._collection + + @property + def studies(self) -> tuple[str, ...]: + """The study names, in the collection's order.""" + return tuple(self._results) + + @property + def designs(self) -> Mapping[str, Design | None]: + """The design each study's result analysed, by study name (read-only); None + for a result built without one.""" + return MappingProxyType( + {study: result.design for study, result in self._results.items()} + ) + + @property + def summary(self) -> Table: + """The summary of every study's result, one after another, with ``study`` + first: one row per study and group, with the status, samples, features and + degrees of freedom of the group's fit. A column that some studies' summaries + lack, such as dream's ``df_method``, is missing in their rows.""" + parts = [(study, result.summary) for study, result in self._results.items()] + names = list( + dict.fromkeys(name for _, table in parts for name in table.columns) + ) + columns: dict[str, Any] = { + "study": text_column( + [study for study, table in parts for _ in range(len(table))] + ) + } + for name in names: + present = [table[name] for _, table in parts if name in table] + text = all(column.dtype.kind == "O" for column in present) + if text: + values: list[Any] = [] + for _, table in parts: + values += ( + table[name].tolist() if name in table else [None] * len(table) + ) + columns[name] = text_column(values) + elif ( + len(present) == len(parts) + and len({column.dtype for column in present}) == 1 + ): + columns[name] = np.concatenate(present) + else: + columns[name] = np.concatenate( + [ + np.asarray(table[name], dtype=np.float64) + if name in table + else np.full(len(table), np.nan) + for _, table in parts + ] + ) + return Table(columns) + + def table(self, group: str | None = None, contrast: str | None = None) -> Table: + """Line up the studies' results of one group and contrast, feature by feature. + + :func:`~cytepool.meta_analysis.align_study_results` of the collection and + the results: a row for every study and every feature of the collection, with + ``status`` and ``reason`` saying whether the study tested the feature, and + why not, and the studies' numeric columns, NaN where a study did not test + the feature. + + Args: + group: An aligned group id; it may be left out when the studies analysed + one group. + contrast: A contrast name, or the name of an F-test of + :func:`~cytepool.differential_expression.dream_voom`; it may be + left out when the studies tested one. + + Returns: + A table of ``collection.n_studies * collection.n_features`` rows. + + Raises: + ValueError: If a key is left out and the studies analysed several, or a + study's result did not analyse its aligned cube. + KeyError: If ``group`` is not a group of the collection, or no study + tested ``contrast``. + TypeError: If a key is not a string. + """ + group, contrast = self._keys(group, contrast) + return align_study_results(self._collection, self._results, group, contrast) + + def matrix( + self, column: str, group: str | None = None, contrast: str | None = None + ) -> np.ndarray: + """Return one numeric column of every study, studies x features. + + The rows are the collection's studies and the columns its features, in its + order (``collection.features``), as :meth:`table` lines them up: for + example the p-values of every study, as + :func:`~cytepool.stats.combined_p_values.combine_p_values` takes them, or + the t-statistics. A feature that a study did not test is NaN. + + Args: + column: A numeric column of the studies' tables, such as ``"p_value"``, + ``"t"`` or ``"log2_fold_change"``. + group: An aligned group id; it may be left out when the studies analysed + one group. + contrast: A contrast name; it may be left out when the studies tested + one. + + Returns: + A read-only float64 array of shape ``(n_studies, n_features)``. + + Raises: + KeyError: If no study's table has the column, ``group`` is not a group of + the collection, or no study tested ``contrast``. + ValueError: If the column is not numeric, or a key is left out and the + studies analysed several. + TypeError: If an argument is not a string. + """ + if not isinstance(column, str): + reject_masked(column, "column") + raise TypeError( + f"column must be a column name, got {type(column).__name__}" + ) + table = self.table(group, contrast) + numeric = [ + name + for name in table.columns + if table[name].dtype.kind in "biuf" and name != "study" + ] + if column not in table.columns: + raise KeyError( + f"no study's table has a column {column!r}; the numeric columns are " + f"{quoted(numeric)}" + ) + if column not in numeric: + raise ValueError( + f"matrix gives a numeric column, and {column!r} holds text; the numeric " + f"columns are {quoted(numeric)}, and table() gives every column" + ) + values = np.asarray(table[column], dtype=np.float64).reshape( + self._collection.n_studies, self._collection.n_features + ) + values.flags.writeable = False + return values + + def __repr__(self) -> str: + groups = self._union("groups") + contrasts = self._union("contrasts") + lines = [ + f"StudyResults of {len(self._results):,} " + f"stud{'y' if len(self._results) == 1 else 'ies'}: {len(groups):,} " + f"group{'' if len(groups) == 1 else 's'}, {len(contrasts):,} " + f"contrast{'' if len(contrasts) == 1 else 's'}: " + ", ".join(contrasts) + ] + for study, result in self._results.items(): + statuses = result.summary["status"].tolist() + fitted = statuses.count("fitted") + lines.append( + f" {study}: {result.method}, {len(statuses):,} " + f"group{'' if len(statuses) == 1 else 's'}, {fitted:,} fitted" + ) + return fitted_lines("\n".join(lines)) + + def _union(self, what: Literal["groups", "contrasts"]) -> list[str]: + """The groups, or the contrasts and F-tests, of any study, in order.""" + if what == "groups": + return list( + dict.fromkeys( + group + for result in self._results.values() + for group in result.groups + ) + ) + return list( + dict.fromkeys( + name + for result in self._results.values() + for name in (*result.contrasts.names, *result.f_tests) + ) + ) + + def _keys(self, group: Any, contrast: Any) -> tuple[Any, Any]: + """The group and contrast asked for, or the only ones the studies analysed.""" + found = [] + for name, value, what in ( + ("group", group, "groups"), + ("contrast", contrast, "contrasts"), + ): + if value is None: + available = self._union(what) # type: ignore[arg-type] + if len(available) != 1: + raise ValueError( + f"the studies analysed {len(available)} {what}; name one with " + f"{name}, one of {quoted(available)}" + ) + value = available[0] + found.append(value) + return found[0], found[1] + + +def analyse_each_study( + collection: CubeCollection, + formula: str, + *, + analysis: Any = limma_voom, + random: str | None = None, + levels: Mapping[str, Any] | None = None, + contrasts: Mapping[str, Any] | None = None, + **options: Any, +) -> StudyResults: + """Analyse every study of a collection alike, each on its aligned cube. + + For each study, in the collection's order: its aligned cube + (:meth:`~cytepool.cube.CubeCollection.aligned_cube`), a + :class:`~cytepool.design.Design` built from the cube's own samples with the + formula, random effects, levels and contrasts given, and ``analysis`` of the + cube with that design and ``options``. The loop a meta-analysis or a replication + analysis starts from, in one call: ``analyse_each_study(collection, "~ + condition", levels={"condition": ["control", "case"]}, contrasts={"case_vs_control": + "conditioncase"})``. A study whose design or analysis fails stops the run, with + a note that names the study. + + Args: + collection: The studies, aligned. + formula: The design's formula, such as ``"~ condition"``, over the columns + of each study's sample table. + analysis: :func:`~cytepool.differential_expression.limma_voom` (by default), + :func:`~cytepool.differential_expression.limma_trend` or + :func:`~cytepool.differential_expression.dream_voom`. + random: The design's random effects, such as ``"(1 | donor)"``, for + ``dream_voom``. + levels: The levels of the design's factors, the reference first, such as + ``{"condition": ["control", "case"]}``. + contrasts: The design's named contrasts, such as ``{"case_vs_control": + "conditioncase"}``. + **options: The options of ``analysis``, such as ``groups``, + ``prior_weights`` or ``expression_filter``. + + Returns: + The result of every study, with the collection. + + Raises: + TypeError: If ``collection`` is not a ``CubeCollection``, ``formula`` not a + string, or ``analysis`` not one of the three. + ValueError, KeyError: As ``Design`` and ``analysis`` raise them for a study, + with a note that names the study. + """ + if not isinstance(collection, CubeCollection): + raise TypeError( + f"collection must be a CubeCollection, got {type(collection).__name__}" + ) + if not isinstance(formula, str): + reject_masked(formula, "formula") + raise TypeError( + f"formula must be a formula such as '~ condition', got " + f"{type(formula).__name__}" + ) + # Refused before any study is analysed, so that the message names no study. + for name, value in ( + ("random", random), + ("levels", levels), + ("contrasts", contrasts), + *options.items(), + ): + reject_masked(value, name) + if not any(analysis is known for known in _ANALYSES): + raise TypeError( + "analysis must be limma_voom, limma_trend or dream_voom, the analyses of " + f"a cube that StudyResults holds; got {analysis!r}" + ) + results = {} + for study in collection.studies: + cube = collection.aligned_cube(study) + try: + design = Design( + cube.samples, formula, random=random, levels=levels, contrasts=contrasts + ) + results[study] = analysis(cube, design, **options) + except (TypeError, ValueError, KeyError) as error: + error.add_note(f"(in study {study!r} of the collection)") + raise + return StudyResults(collection, results) diff --git a/cytepool/sumrank.py b/cytepool/sumrank.py index 80302a8..a4c7edc 100644 --- a/cytepool/sumrank.py +++ b/cytepool/sumrank.py @@ -186,7 +186,13 @@ from ._columns import text_column from ._jit import jit from ._masked_arrays import read_only, reject_masked, unmasked_array -from ._messages import PACKAGE_DIRECTORY, listing, quoted +from ._messages import ( + PACKAGE_DIRECTORY, + fitted_lines, + fitted_message, + listing, + quoted, +) from ._options import index_integer, random_generator from ._ranks import average_ranks from ._study_statistics import signed_statistics, study_statistics, studies_summed @@ -662,8 +668,8 @@ def __repr__(self) -> str: table = self._table lines = [ f"SumRankResult for group {settings['group']!r} and contrast " - f"{settings['contrast']!r}: {settings['n_studies']} studies, the best " - f"{settings['n_studies_summed']} summed; {len(table):,} genes" + f"{settings['contrast']!r}: {settings['n_studies']:,} studies, the best " + f"{settings['n_studies_summed']:,} summed; {len(table):,} genes" ] if settings["p_values"] == "permutation": lines.append( @@ -679,7 +685,7 @@ def __repr__(self) -> str: lines.append( f" adjusted p-value below 0.05: {counts[0]:,} up, {counts[1]:,} down" ) - return "\n".join(lines) + return fitted_lines("\n".join(lines)) def differential_expression_sumrank( @@ -792,10 +798,13 @@ def differential_expression_sumrank( summed = studies_summed(proportion_of_studies, len(studies)) if summed < len(studies) and not permutations: warnings.warn( - f"the Irwin-Hall p-values of a sum of the best {summed} of " - f"{len(studies)} studies' ranks are too small, as the sum of the best " - "ranks is smaller than a sum of uniform ranks; the p_value columns hold " - "them, so take p-values from permutations (n_permutations and permute)", + fitted_message( + f"the Irwin-Hall p-values of a sum of the best {summed} of " + f"{len(studies)} studies' ranks are too small, as the sum of the best " + "ranks is smaller than a sum of uniform ranks; the p_value columns " + "hold them, so take p-values from permutations (n_permutations and " + "permute)" + ), RuntimeWarning, skip_file_prefixes=(PACKAGE_DIRECTORY,), ) diff --git a/cytepool/table.py b/cytepool/table.py index 8e68ab3..0125f94 100644 --- a/cytepool/table.py +++ b/cytepool/table.py @@ -31,7 +31,7 @@ import numpy as np -from ._columns import is_data_frame, values_equal +from ._columns import is_data_frame, missing_mask, values_equal from ._masked_arrays import reject_masked, unmasked_array _REPR_ROWS = 5 # rows shown at each end of a long table @@ -179,32 +179,80 @@ def take(self, indices: Any) -> "Table": n_rows=positions.size, ) - def filter(self, mask: Any) -> "Table": - """Return the rows where ``mask`` is true. + def filter(self, mask: Any = None, /, **values: Any) -> "Table": + """Return the rows where ``mask`` is true and each named column has its value. + + ``table.filter(group_id="B cells", used=True)`` keeps the rows of one group's + samples that were used. A missing value (None in text, NaN in numbers) keeps + the rows where the column is missing. Args: - mask: A boolean array with one value per row. + mask: A boolean array with one value per row; None keeps every row. + **values: Column name to one value: a string for a text column, a number + for a numeric column, True or False for a boolean column, or a + ``numpy.datetime64`` or ``numpy.timedelta64``. A column whose name is + not a valid Python identifier can be filtered with a mask, as + ``table.filter(table["my column"] == value)``. Raises: - TypeError: If ``mask`` is not boolean, or is a numpy masked array. + TypeError: If ``mask`` is not boolean or is a numpy masked array, or a + value is not a single value of its column's kind. ValueError: If ``mask`` does not have one value per row. + KeyError: If a column named is not in the table. """ - keep = unmasked_array(mask, "mask") - if keep.dtype != np.bool_: - raise TypeError( - f"filter() needs a boolean mask, got dtype {keep.dtype}; use take() for " - "positions" - ) - if keep.shape != (self._n_rows,): - raise ValueError( - f"mask must have one value per row ({self._n_rows}), got shape " - f"{keep.shape}" - ) + if "mask" in values and "mask" not in self._columns and mask is None: + mask = values.pop("mask") # the keyword of calls written before **values + keep = np.ones(self._n_rows, dtype=bool) + if mask is not None: + keep = unmasked_array(mask, "mask") + if keep.dtype != np.bool_: + raise TypeError( + f"filter() needs a boolean mask, got dtype {keep.dtype}; use take() " + "for positions" + ) + if keep.shape != (self._n_rows,): + raise ValueError( + f"mask must have one value per row ({self._n_rows}), got shape " + f"{keep.shape}" + ) + for name, value in values.items(): + keep = keep & _equal_to(name, self[name], value) return self._with_new_arrays( {name: column[keep] for name, column in self._columns.items()}, n_rows=int(np.count_nonzero(keep)), ) + def sort(self, by: str, *, descending: bool = False) -> "Table": + """Return the rows ordered by the values of one column. + + The order is stable: rows with equal values keep their order. Missing values + (None, NaN, NaT) come last, in their order, whichever the direction. + + Args: + by: A column name. + descending: Whether the largest value comes first. + + Raises: + KeyError: If there is no such column. + TypeError: If ``by`` is not a string or ``descending`` not True or False. + """ + column = self[by] + if not isinstance(descending, bool | np.bool_): + raise TypeError( + f"descending must be True or False, got {type(descending).__name__}" + ) + missing = missing_mask(column) + present = np.flatnonzero(~missing) + values = column[present] + if descending: + # Sorting the values in reverse gives equal values in reverse order; + # reading that order backwards restores theirs. + reverse = np.argsort(values[::-1], kind="stable") + order = (values.size - 1 - reverse)[::-1] + else: + order = np.argsort(values, kind="stable") + return self.take(np.concatenate([present[order], np.flatnonzero(missing)])) + def select(self, names: Any) -> "Table": """Return a table with the given columns, in the given order. @@ -552,6 +600,46 @@ def _columns_from_data_frame(frame: Any) -> dict[str, np.ndarray]: return columns +def _equal_to(name: str, column: np.ndarray, value: Any) -> np.ndarray: + """Where a column equals one value; a missing value equals a missing one.""" + reject_masked(value, name) + kind = column.dtype.kind + if value is None or (isinstance(value, float | np.floating) and math.isnan(value)): + if kind == "O" or (kind in "fc" and value is not None): + return missing_mask(column) + if kind in "iu" and value is not None: + return np.zeros(column.shape, dtype=bool) # integers are never missing + elif kind == "O" and isinstance(value, str): + return np.asarray(column == value, dtype=bool) + elif kind == "b" and isinstance(value, bool | np.bool_): + return np.asarray(column == bool(value), dtype=bool) + elif ( + kind in "iufc" + and isinstance(value, numbers.Number) + and not isinstance(value, bool | np.bool_) + ): + return np.asarray(column == value, dtype=bool) + elif kind in "mM" and isinstance(value, np.datetime64 | np.timedelta64): + if np.isnat(value): + return missing_mask(column) + try: + return np.asarray(column == value, dtype=bool) + except TypeError: + pass # a datetime compared with a timedelta, refused below + kinds = { + "O": "text, a string", + "b": "booleans, True or False", + "M": "datetimes, a numpy.datetime64", + "m": "timedeltas, a numpy.timedelta64", + } + expected = kinds.get(kind, "numbers, a number") + raise TypeError( + f"filter() compares the column {name!r} with one value; the column holds " + f"{expected}, got {type(value).__name__} {value!r}. For several values, give " + f"a mask such as numpy.isin(table[{name!r}], values)" + ) + + def _repeated(names: list[Any]) -> list[Any]: seen: set[Any] = set() repeated = [] diff --git a/cytepool/variance_partitioning.py b/cytepool/variance_partitioning.py index 9c3b4dc..6afbec2 100644 --- a/cytepool/variance_partitioning.py +++ b/cytepool/variance_partitioning.py @@ -123,6 +123,7 @@ cube_record, matched_samples, mixed_design_record, + only_key, software_versions, ) from ._columns import text_column @@ -132,6 +133,7 @@ FITTED, GroupInputs, GroupRecord, + check_sample_groups, filter_setting, group_positions, min_cells_setting, @@ -145,7 +147,7 @@ ) from ._jit import thread_limit from ._masked_arrays import real_array, reject_masked, unmasked_array -from ._messages import listing +from ._messages import fitted_lines, listing from .cube import Cube from .design import Contrasts, Design from .design.checks import _aliasing, _relation @@ -730,16 +732,18 @@ def provenance(self) -> dict[str, Any]: record: dict[str, Any] = json.loads(self._record) return record - def table(self, group: str) -> Table: + def table(self, group: str | None = None) -> Table: """Return the table of fractions of one group. Args: - group: A group id. + group: A group id; it may be left out when the result has one group. Raises: + ValueError: If ``group`` is left out and the result has several groups. KeyError: If the group was not analysed or not fitted; the message says why. """ + group = only_key(group, list(self.groups), "group", "groups") found = self._tables.get(group) if found is not None: return found @@ -758,8 +762,8 @@ def __repr__(self) -> str: statuses = self._summary["status"].tolist() fitted = statuses.count(FITTED) lines = [ - f"VariancePartitioningResult: {len(statuses)} group" - f"{'' if len(statuses) == 1 else 's'}, {fitted} fitted; variables: " + f"VariancePartitioningResult: {len(statuses):,} group" + f"{'' if len(statuses) == 1 else 's'}, {fitted:,} fitted; variables: " + ", ".join(self._variables), ] for row in range(len(statuses)): @@ -769,8 +773,8 @@ def __repr__(self) -> str: continue used = int(self._summary["n_samples_used"][row]) features = int(self._summary["n_features"][row]) - lines.append(f" {group}: {used} samples, {features} features") - return "\n".join(lines) + lines.append(f" {group}: {used:,} samples, {features:,} features") + return fitted_lines("\n".join(lines)) @dataclass @@ -787,7 +791,7 @@ def variance_partitioning( groups: str | Sequence[str] | None = None, min_cells: int = 10, min_counts: float = 0, - expression_filter: bool | Mapping[str, float] = True, + expression_filter: bool | Mapping[str, Any] = True, normalization: Literal["tmm"] | None = "tmm", span: float | None = None, prior_weights: Literal["n_cells"] | None = None, @@ -829,7 +833,12 @@ def variance_partitioning( min_counts: The fewest counts a sample needs in a group, over every feature of the cube, to enter its fit; 0 by default. expression_filter: True for edgeR's ``filterByExpr`` defaults with the - group's fixed effects, a mapping of changed settings, or False. + group's fixed effects, a mapping of changed settings or of the column of + ``"sample_groups"``, as for + :func:`~cytepool.differential_expression.limma_voom`, or False. With a + random effect that separates groups whose expression may differ, such + as the tissues of each donor, ``{"sample_groups": "tissue"}`` keeps the + features expressed in any one of them. normalization: ``"tmm"`` for TMM normalization factors, or None. span: The LOWESS span of voom's trend, in (0, 1], for every group; None chooses it in each group from the number of features, as ``voom`` @@ -887,6 +896,7 @@ def variance_partitioning( "this cube does not record (a cube of bulk samples has none); leave " "prior_weights at None" ) + check_sample_groups(settings, design.samples) cube_rows, order = matched_samples( cube, design, diff --git a/docs/coverage_exemptions.toml b/docs/coverage_exemptions.toml index 926beec..23ac7a5 100644 --- a/docs/coverage_exemptions.toml +++ b/docs/coverage_exemptions.toml @@ -60,5 +60,18 @@ "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.cube.Cube.with_columns" = "guides/pool_cells: a column of the samples to pool by, with collapse_samples" +"cytepool.differential_expression.DifferentialExpressionResult.fit" = "guides/normalization_and_quality: the trend figures of a group of a result" +"cytepool.differential_expression.GroupFit" = "guides/normalization_and_quality: the values and weights behind a group's tables" +"cytepool.networks.Network.to_gene_sets" = "guides/gene_sets: CollecTRI's regulons tested as gene sets" +"cytepool.score_tests.limma" = "guides/pathway_activity: pathway scores and activities tested with the design" +"cytepool.stats.deseq2.DESeq2Results.table" = "guides/bulk_rna_seq: DESeq2's calls by gene" +"cytepool.stats.empirical_bayes.ModeratedFit.table" = "guides/bulk_rna_seq: limma's table of a fit on arrays" +"cytepool.stats.quasi_likelihood.QuasiLikelihoodTest.table" = "guides/bulk_rna_seq: edgeR's calls by gene" +"cytepool.study_results.StudyResults" = "guides/combine_studies: the results of every study, kept together" +"cytepool.study_results.StudyResults.matrix" = "guides/combine_studies: the p-values of every study, combined" +"cytepool.study_results.StudyResults.table" = "guides/combine_studies: the studies lined up gene by gene" +"cytepool.study_results.analyse_each_study" = "guides/combine_studies: every study analysed alike" +"cytepool.table.Table.sort" = "guides/genes_per_cell_type: tables read from the smallest p-value" "cytepool.plotting.plot_dispersions" = "guides/bulk_rna_seq: DESeq2's dispersion estimates" "cytepool.plotting.plot_quasi_dispersions" = "guides/bulk_rna_seq: edgeR's quasi-dispersions" diff --git a/docs/source/guides/anndata_and_mudata.ipynb b/docs/source/guides/anndata_and_mudata.ipynb index 00c2a70..bf0a736 100644 --- a/docs/source/guides/anndata_and_mudata.ipynb +++ b/docs/source/guides/anndata_and_mudata.ipynb @@ -36,7 +36,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev57+gb65bc7e32, anndata 0.13.4\n", + "CytePool 0.1.dev61+gcd5dbe953, 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", @@ -48,7 +48,8 @@ "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", + " layers: counts (uint32), detected (uint32), log_sum (float64),\n", + " 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", @@ -274,13 +275,7 @@ " 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": [ + " layers:\t'counts', 'detected', 'log_sum', 'log_sum_sq', 'linear_sum'\n", "\n", "the same cube after the MuData: True\n" ] @@ -358,7 +353,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T21:54:17+00:00", + "executed_at": "2026-10-27T08:55:59+00:00", "executed_code_sha256": "09e48cf19350c4949b5f3b57bf234e674a79fd0809f65dea8505084b6c1debd1", "executed_datasets": { "simulated_pbmc": { @@ -366,8 +361,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev57+gb65bc7e32", - "execution_seconds": 3.6, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 2.1, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/bulk_rna_seq.ipynb b/docs/source/guides/bulk_rna_seq.ipynb index c61aaac..0a9e243 100644 --- a/docs/source/guides/bulk_rna_seq.ipynb +++ b/docs/source/guides/bulk_rna_seq.ipynb @@ -32,7 +32,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev42+g6991e63f8, numpy 2.5.4\n", + "CytePool 0.1.dev61+gcd5dbe953, numpy 2.5.4\n", "Cube with 12 samples x 1 groups x 10,000 features\n", " layers: counts (uint32, lazy)\n", " cells per entry: not recorded\n", @@ -90,7 +90,8 @@ "Design: 12 samples x 4 columns, formula '~ batch + condition'\n", " columns: (Intercept), batchbatch2, conditiondrug_a, conditiondrug_b\n", " contrasts: drug_a_vs_control, drug_b_vs_control\n", - "Design check: 12 samples, 4 columns, rank 4, 8 residual degrees of freedom; no problems found.\n" + "Design check: 12 samples, 4 columns, rank 4, 8 residual degrees of freedom; no\n", + " problems found.\n" ] } ], @@ -133,8 +134,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "DifferentialExpressionResult (limma_voom): 1 group, 1 fitted; 2 contrasts: drug_a_vs_control, drug_b_vs_control\n", - " bulk: 12 samples, 9593 features\n", + "DifferentialExpressionResult (limma_voom): 1 group, 1 fitted; 2 contrasts:\n", + " drug_a_vs_control, drug_b_vs_control\n", + " bulk: 12 samples, 9,593 features\n", " control_1 1.12 ######################\n", " control_2 1.13 #######################\n", " control_3 1.10 ######################\n", @@ -232,13 +234,7 @@ "drug_a_vs_control limma-voom 355 337 5.1%\n", "drug_a_vs_control edgeR QL 320 312 2.5%\n", "drug_a_vs_control DESeq2 Wald 360 338 6.1%\n", - " called by all 320\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " called by all 320\n", "drug_b_vs_control limma-voom 204 192 5.9%\n", "drug_b_vs_control edgeR QL 193 184 4.7%\n", "drug_b_vs_control DESeq2 Wald 238 203 14.7%\n", @@ -335,7 +331,7 @@ "datasets": [ "simulated_bulk" ], - "executed_at": "2026-10-26T11:06:57+00:00", + "executed_at": "2026-10-27T08:56:02+00:00", "executed_code_sha256": "67f2aedd5235275db9b92304c750ae470acbb2e4e039e0f53b09918a38cd08b2", "executed_datasets": { "simulated_bulk": { @@ -343,8 +339,8 @@ "simulated_bulk_truth.npz": "sha256:a8a0275532e3cafb02401846176a7ddfa037579aceb804c5f9c007700f022977" } }, - "executed_with": "0.1.dev42+g6991e63f8", - "execution_seconds": 4.8, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 2.6, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/combine_studies.ipynb b/docs/source/guides/combine_studies.ipynb index ec9f612..31cbd4b 100644 --- a/docs/source/guides/combine_studies.ipynb +++ b/docs/source/guides/combine_studies.ipynb @@ -38,7 +38,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev55+g941b81fb5, numpy 2.5.4\n", + "CytePool 0.1.dev61+gcd5dbe953, numpy 2.5.4\n", "cohort_1: 60 donors (30 cases), 2,000 genes\n", " B cells, CD4 T cells, NK cells, CD14 monocytes\n", "cohort_2: 32 donors (16 cases), 2,000 genes\n", @@ -179,7 +179,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -292,7 +292,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -563,7 +563,7 @@ "datasets": [ "simulated_cohorts" ], - "executed_at": "2026-10-26T21:28:59+00:00", + "executed_at": "2026-10-27T09:54:56+00:00", "executed_code_sha256": "deba02883cab4b6b05bc7a5808e0573f453613d3e37d64804183954b8783d956", "executed_datasets": { "simulated_cohorts": { @@ -576,8 +576,8 @@ "simulated_cohorts_truth.npz": "sha256:6599ea11dddb183f630183846f7ece9991003a4cc77875e4e7822317f66346ec" } }, - "executed_with": "0.1.dev55+g941b81fb5", - "execution_seconds": 6.3, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 12.5, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/composition.ipynb b/docs/source/guides/composition.ipynb index 974cb30..492dc56 100644 --- a/docs/source/guides/composition.ipynb +++ b/docs/source/guides/composition.ipynb @@ -32,9 +32,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n", + "CytePool 0.1.dev61+gcd5dbe953\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", + " layers: counts (uint32, lazy), detected (uint32, lazy), log_sum (float64,\n", + " 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", @@ -267,7 +268,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T20:36:49+00:00", + "executed_at": "2026-10-27T08:56:04+00:00", "executed_code_sha256": "d4125bfed85af28d3d315f60e96cece11a74191a8dd57278c89324d736db6c36", "executed_datasets": { "simulated_pbmc": { @@ -275,8 +276,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 3.6, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 1.8, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/export_cubes.ipynb b/docs/source/guides/export_cubes.ipynb index facaf90..d68fedf 100644 --- a/docs/source/guides/export_cubes.ipynb +++ b/docs/source/guides/export_cubes.ipynb @@ -34,7 +34,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev42+g6991e63f8, numpy 2.5.4\n", + "CytePool 0.1.dev61+gcd5dbe953, numpy 2.5.4\n", "19,151 cells x 2,000 genes in 24 samples\n", "cell types: B cells, CD4 T cells, CD8 T cells, NK cells, Monocytes, Dendritic cells\n" ] @@ -203,7 +203,8 @@ " groups: group_id\n", " features: feature_id\n", "\n", - "Source, as the caller recorded it (unresolved: CytePool does not follow its references):\n", + "Source, as the caller recorded it (unresolved: CytePool does not follow its\n", + " references):\n", " tool: \"example-exporter\"\n", " version: \"0.1\"\n", " dataset: {\"id\": \"simulated_pbmc\", \"file\": \"simulated_pbmc_cells.npz\"}\n", @@ -211,8 +212,12 @@ " samples: {\"columns\": [\"donor\", \"condition\"]}\n", " groups: {\"column\": \"cell_type\"}\n", " settings: {\"layer\": \"raw counts\", \"filters\": null}\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:b4a9d782cf081e10a8e835d66ae7b061874fc377ef838f168cf29911f79e7501\n" + "References: CytePool resolves none on its own. The source record's references\n", + " need the tool that wrote them. A fingerprint names a cube without\n", + " saying where it is: Cube.fingerprint() of a cube at hand says\n", + " whether it is that cube.\n", + "Fingerprint:\n", + " sha256:b4a9d782cf081e10a8e835d66ae7b061874fc377ef838f168cf29911f79e7501\n" ] } ], @@ -309,7 +314,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T11:06:52+00:00", + "executed_at": "2026-10-27T08:56:07+00:00", "executed_code_sha256": "c2858033ad96e552e104f8ef84dab502009618f5110bec0d214b3f5cfbdb1c68", "executed_datasets": { "simulated_pbmc": { @@ -317,8 +322,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev42+g6991e63f8", - "execution_seconds": 4.2, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 2.4, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/gene_sets.ipynb b/docs/source/guides/gene_sets.ipynb index d9cd6e7..518e4e8 100644 --- a/docs/source/guides/gene_sets.ipynb +++ b/docs/source/guides/gene_sets.ipynb @@ -32,7 +32,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n", + "CytePool 0.1.dev61+gcd5dbe953\n", "92 of the set's 97 genes are among the 5,125 genes tested\n" ] } @@ -186,7 +186,11 @@ "output_type": "stream", "text": [ "GeneSets: 199 sets of 15 to 435 genes, 1,893 genes in all\n", - " source: CollecTRI; version: 2.0 (Zenodo record 8192729); licence: CC BY 4.0 (Zenodo record 8192729); level 'commercial': the interactions of resources that OmniPath lists for commercial use, without those that GEREDB (listed for academic use) alone supports; each resource keeps its own terms\n", + " source: CollecTRI; version: 2.0 (Zenodo record 8192729); licence: CC BY 4.0\n", + " (Zenodo record 8192729); level 'commercial': the interactions of\n", + " resources that OmniPath lists for commercial use, without those that\n", + " GEREDB (listed for academic use) alone supports; each resource keeps\n", + " its own terms\n", " sets: MYC (383), SPI1 (133), SMAD3 (41) and 196 more\n" ] }, @@ -293,7 +297,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_728278/842382742.py:1: RuntimeWarning: 1 gene set(s) have fewer than 10 random scores of the sign of their enrichment score among 1000 permutations, as statistics mostly of one sign give; their normalized scores and p-values are NaN. More permutations (n_permutations=10000) may give them some\n", + "/tmp/ipykernel_933368/842382742.py:1: RuntimeWarning: 1 gene set(s) have fewer than 10 random scores of the sign of their enrichment\n", + "score among 1000 permutations, but some; their normalized scores and p-values\n", + "are NaN. More permutations (n_permutations=10000) may give them enough\n", " enrichment = gsea(\n" ] }, @@ -385,7 +391,7 @@ "kang2018", "hallmark_interferon_alpha" ], - "executed_at": "2026-10-26T20:33:15+00:00", + "executed_at": "2026-10-27T08:56:13+00:00", "executed_code_sha256": "65d587e5aec480f66e3aa702a3669b97888f1ef3304ffcd2fb053c0476c85a24", "executed_datasets": { "hallmark_interferon_alpha": { @@ -395,8 +401,8 @@ "kang2018.cube.zarr": "sha256:a30af3dabe17f21a6c75f41b64a279a1423640b9aa919022cf67897f9cc77a51" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 4.7, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 5.0, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/genes_per_cell_type.ipynb b/docs/source/guides/genes_per_cell_type.ipynb index d26862a..189066d 100644 --- a/docs/source/guides/genes_per_cell_type.ipynb +++ b/docs/source/guides/genes_per_cell_type.ipynb @@ -32,7 +32,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n", + "CytePool 0.1.dev61+gcd5dbe953\n", "Cube with 16 samples x 8 groups x 35,635 features\n", " layers: counts (uint32, lazy), detected (uint32, lazy)\n", " filled: 128 of 128 sample x group entries have cells (100.0%)\n", @@ -104,9 +104,11 @@ "output_type": "stream", "text": [ "Design: 16 samples x 9 columns, formula '~ donor + condition'\n", - " columns: (Intercept), donor1015, donor1016, donor1039, donor107, donor1244, donor1256, donor1488, conditionstim\n", + " columns: (Intercept), donor1015, donor1016, donor1039, donor107, donor1244,\n", + " donor1256, donor1488, conditionstim\n", " contrasts: stim_vs_ctrl\n", - "Design check: 16 samples, 9 columns, rank 9, 7 residual degrees of freedom; no problems found.\n" + "Design check: 16 samples, 9 columns, rank 9, 7 residual degrees of freedom; no\n", + " problems found.\n" ] } ], @@ -150,20 +152,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "DifferentialExpressionResult (limma_voom): 8 groups, 8 fitted; 1 contrast: stim_vs_ctrl\n", - " B cells: 16 samples, 2768 features\n", - " CD14+ Monocytes: 16 samples, 5125 features\n", - " CD4 T cells: 16 samples, 6295 features\n", - " CD8 T cells: 16 samples, 1453 features\n", - " Dendritic cells: 14 samples, 2281 features\n", - " FCGR3A+ Monocytes: 16 samples, 2947 features\n", + "DifferentialExpressionResult (limma_voom): 8 groups, 8 fitted; 1 contrast:\n", + " stim_vs_ctrl\n", + " B cells: 16 samples, 2,768 features\n", + " CD14+ Monocytes: 16 samples, 5,125 features\n", + " CD4 T cells: 16 samples, 6,295 features\n", + " CD8 T cells: 16 samples, 1,453 features\n", + " Dendritic cells: 14 samples, 2,281 features\n", + " FCGR3A+ Monocytes: 16 samples, 2,947 features\n", " Megakaryocytes: 12 samples, 704 features\n", - " NK cells: 16 samples, 2292 features\n" + " NK cells: 16 samples, 2,292 features\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -212,7 +215,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -418,7 +421,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,7 +479,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFcAAAHNCAYAAADbm5R/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAA4ftJREFUeJzs3WdUFMnbNvCLHCQLSlIRFUVAQcGAIKKgKGYxra5pjZjT35wDu65Z15zDigHDqpjTmjOirhgwAiIqCILk6fcDL/04DtFBktfvHM5xqqq7q3rGrpm7q6sUBEEQQERERERERERE30WxqCtARERERERERFSSMbhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVohLu9u3b8PHxQUhIiJh26tQp+Pj4IDo6ughr9v2yalNByu/5OXjwIHx8fPDly5cC33dxlZ82/2hZndPScp6J6Ocxb948jB8/XiptzJgxWLBgQRHVSH5ZtYkKxsuXL+Hj44Nr167lmEZExQeDK0TFQGpqKnr06AEfHx+8fv06X9u+ffsWAQEB+PDhg5gWGhqKgICAH/rD+OjRo/Dx8cGnT58KfN9ZtakgZXV+cmpPSEgIAgICkJKS8l37Lony0+YfLatzmtfz/CM/p0T08zlx4gR8fHwwffr0fG978eJFnDp1Sirt5MmTuHLlSkFVL0vDhw/HokWLfsi+s2oTFYxPnz4hICAAYWFhOaZl5enTp/Dx8cHNmzd/dDWJ6CsMrhAVA4cPH8bff/+NgwcPYuPGjXLvr3nz5ti7dy/Kli1bALXL2tOnTxEQEICkpKQfdowfJavzU1DtKYxzT3lXkj+nRFT8/PHHHzh48CD8/Pzw9u1bufe3ZMkSTJgwoQBqlr1jx47h6tWrP/QYVLx8/PgRAQEBCA8PL+qqEP1UGFwhKgbWr18Pe3t79OzZE5s2bYJEIpFrf5aWlvDx8YGGhkYB1bB0+ZHnh+eeiKh0Cg0Nxfnz5zF//nwoKytj8+bNcu/T09MTDRs2LIDaERFRUVMu6goQ/exev36NkydPYs2aNahduza2bt2K48ePo1WrVjJl4+PjsWbNGgQFBaF8+fIYOHBglvs8deoU1q5di3Xr1sHAwAAAsHHjRpw/fx7bt2+XKnvz5k388ccf8PPzQ7Vq1aT2cezYMbx//x4VK1ZE69atxS+AW7ZswZYtWwAAAwYMgJqaGgBg1qxZsLGxAQAIgoDAwECcOHECHz58gJmZGXr06AF7e/vvatO3QkNDMWHCBEyYMAFOTk4AgC9fvqB3794oU6aMWD8gY2TQtm3bsHHjRujo6Micn7y0J9OVK1ewfft2fPnyBc2aNcOvv/4KBQWFHM/9wYMHsWPHDmzbtg1BQUE5bp+dvJzPzPcSABQUFKCpqQkbGxv8+uuvMDExkdnn8ePHceLECbx//x5VqlTBr7/+iqpVq8qUy63NOcntGHn9nHyPnN7X9+/fY+XKlZg9ezZq1qwptd3Tp08xadIkDB48GB4eHlLv37Vr17B7926kpKTA09MT3bp1g6Ki9H2KH9kmIio6GzZsgK6uLoYNG4YHDx5g48aNmDRpUpbXw9u3b2P79u2Ijo5G/fr10b9//yz3OWbMGBgbG+N///ufmObj44MOHTqgR48eUmVnz56NhIQE8ToPALGxsdi6dSsePHgAiUQCW1tb9OnTB3p6egCArl27IjIyEteuXYOPjw8AoGLFili8eLG4j48fP2Lbtm24d+8eJBIJnJyc0LdvX2hpaX1Xm7Iye/ZsBAcHAwCUlJRgZGSEJk2aoGPHjjLX0OjoaOzYsQNBQUFQUlJCgwYN0KtXL6ioqAAABg0aBBsbGwwYMAAbNmzAzZs34eHhgV69egHIGKkTGBiIjx8/wtzcHF27dkXdunWljvHgwQPs2rULb968gaGhIVxdXdG+fXup9zIvZbJz584dBAQE4NWrVzAxMUG7du3g4uIicz737t2L169fQ19fH61bt0bLli3zfE6zc/nyZUybNg0AsGDBAuzYsQMA0LNnTzg5OWHkyJH49ddf0a5dO6ntUlNT0adPHzRq1Ai+vr54+PAhZsyYgalTp0JdXR3r1q3D+/fvUadOHQwcOBBlypSROXZe2iTPeSUq7jhyhaiIbdq0Cdra2ujRowfq1asHR0dHrF+/Xqbcx48f4eTkhCVLlqB27dqwtLTEwIEDcffuXZmyWc1HcffuXRw4cECmbHh4OAICAvDx40cxbfLkyWjfvj00NTXh5eUFXV1d/O9//8OqVasAAA4ODnBwcAAAtGvXDt26dUO3bt1Qrlw5AEBKSgratm2Lrl27okyZMmjevDk+f/4MJycnqTt9+WnTtypUqIDjx49j7969YtqFCxewb98+bN26FY8ePRLTt2zZgnv37kFHRyfL85NbezLt3r0bixcvhqOjI8qVK4e+ffti8uTJuZ77zPlLtm/fnuv2Wcnr+TQzMxPr3qVLFzg5OWH//v2wsbHBy5cvxXLJycnw9vZG+/btAQAeHh5QUVFB+/btcePGjXy3OSt5OUZe2/W9cnpfa9eujcDAQKxYsUJmu7/++guHDh2Cra0tgP97/9auXYuVK1eiXr16MDY2Rr9+/dCtWzcIgiBu+6PbRERFIy0tDVu2bEGfPn2gqakJX19fPH/+HGfPnpUpu2vXLtSrVw8vXryAm5sbwsLCZK4VmbKacyUgIAD379+XKfvvv//izJkz4uuPHz/C3t4e27dvh729PVxdXREWFgYnJydxnqmuXbtCW1sbFSpUEK+BX//YvXbtGqpXr45du3ahTp06aNCgATZu3Ig6deogMjLyu9qUFXd3d/H4bdu2hba2NgYMGIDevXtLlbt8+TKsrKywYcMGWFtbo0GDBrh+/Tq8vLzEMkePHsWVK1fQoUMHfPjwAU5OToiIiIAgCOjZsyfatm0LVVVVeHh4IDw8HE5OTlJzzhw8eBC1a9dGVFQUPDw8ULlyZfz999/o06dPvspkZ8qUKXB0dBTPlbGxMaZMmYI1a9aIZaZPn4569erh/fv38PT0hKGhITp37gxfX988nc+cVKpUCZ6engAAV1dX8bxbW1vDzMwMoaGhmDVrlsx2AQEB+Pvvv1GpUiUAwPv37xEQEIAjR45g8ODBqFq1Kuzs7LBgwQI0aNAAsbGxUtvnpU3ynFeiEkEgoiKTnp4uVKhQQRgxYoSYtnHjRkFZWVl4+/atVNnBgwcLqqqqwvPnz8W0hIQEwdraWgAgXLx4UUxfvXq1AEB48+aNmDZ06FChTJkyMnU4cOCAAEC4evWqIAiCIJFIBB0dHWHixIkyZb+u05IlSwQAMvUUBEGYNm2aoKioKFy7dk0qfcaMGYKampoQERGR7zZlpWXLlkLt2rXF16NHjxacnJyEcuXKCcuWLRMEQRDS0tIEPT09wdfXN8fzk1N7/Pz8BADCgAEDpNKHDx8uaGhoCDExMTnuOz/bZyWv5zMrKSkpgpWVldC7d28xbdKkSYKCgoLM+U1OThaio6MLpM55OUZe25XVOc0qLSs5va/9+vUTtLS0hLi4ODEtISFB0NPTE9q1ayemZZ6LXr16SW3/999/CwCEv//+W0yT570iouJr//79goKCgvD48WMxrU6dOkLXrl2lysXExAhaWlpCx44dpdL37NkjqKurS/VZgiAINjY2UtcbQRAEAMKECRNk6tCsWTOhbt264uutW7cKAISwsDCpctHR0UJSUpL4ukqVKkKnTp1k9peYmCiYmpoKzs7OQlpampiekJAgVKhQQfjll1++q015deTIEQGAcPPmTfG4xsbGQv369aXqLwiCEBkZKf7bzMxMUFdXF86fPy/Vlm3btgkAhM2bN0ttO2zYMEFRUVEIDg4WBEEQPD09hSZNmsjU5+t+Ii9lsnLo0CEBgLBw4UKZvMw2HD16VAAgrFixQir/2LFjAgAhMDBQEARBuHv3rgBA2Lt3r1gmq7SsXL16VQAgHDhwQCZv3bp1AgDhypUrUumurq6Cqamp+Fk4d+6cAECoXbu2kJiYKJZ7/PixoKysLPXdNa9t+t7zSlRScOQKURE6ceIE3rx5gyFDhohp3bt3h7a2ttRjLQCwd+9etG7dGpUrVxbTNDU1ZYYNy0tBQQFqamq4ePGi1F0rADA2Ns7TPjZu3Ag3NzfUr19fKr1///5ITk7GkSNHAMjfJg8PDwQHB+Pdu3cAMh7Jad68OTw8PHDy5EkAwK1bt/Dp0yd4eHjkaZ856devn8zxExMT8eTJkx+6fV7PJwA8efIEc+fORe/evdG5c2d0794d8fHx4nBsIGO0lLu7u8wQZVVVVejr6xdInfNyjPy060cYOnQo4uPjpR6V27VrFz59+oTffvtNpvy3Q+C7du2KcuXKYffu3WJaUbeJiH6MDRs2oFmzZrCyshLThgwZgoMHD0qN/Dx27Bji4+MxbNgwqe19fHzER0ULirq6OgBg//79SE9PF9P19fXFxyBzcuzYMURERGDs2LFQUlIS0zU1NfHLL7/g4MGDSE9PL5A2SSQSHDhwACNHjkT37t3h4+OD1atXA4DYPwUGBiIyMhITJkyQqX/58uWlXlepUgVubm7ia3V1dfj7+8PAwAC//vqrVNkxY8ZAIpGI12p1dXWEhITIjA76+jtOXspkZdOmTdDV1cWIESNk8jLbsHHjRmhpaUl99wMALy8vmJmZYd++fTkeQ149evSAnp6eeP4B4OHDh7h48SL69Okj9VnILJ/5WQMAKysreHl5yfR9eWnT955XopKCc64QFaH169dDU1MTU6dOlUpXV1fHhg0bMGHCBCgoKCAuLg4fP35ElSpVZPaR1RwZ8lq9ejV+++03mJmZwdHREW5ubujUqZPMD8asxMfHIyIiAhoaGlJDhgVBECfqff36dYG0ydPTE4Ig4NSpU/Dw8MCDBw/w119/4cWLFxg2bBhSU1Nx6tQpKCkpwd3dPR9nIGuWlpZSr42MjABAJghVkNvn9XwCwL59+9C9e3d4eXnBy8sLhoaGUFJSwps3b8Qv/58/f8a7d+/EZ+9/RJ3zcoz8tOtHqVOnDurXr4/Vq1eLw5ZXr14NExOTLJ97//azqqioCEtLS7x48QJA8WgTERW8N2/e4Pjx47CxsZG6riUmJiI5ORnbtm3D6NGjAUC8Hnx7vVBQUIClpSU+f/5cYPXq2LEjfHx8MGLECMycORONGzdGs2bN8Msvv+Qp6PH48WMAGd9F9uzZA0EQxOvW06dP8eXLF3z48EHuNkkkErRs2RI3btzAwIED4eXlhTJlyiA6OhpHjx5FXFyceEwAsLa2zrXuWX13ePnyJSwtLWWCAxYWFlBVVRXbMXfuXHTo0AG1atVCjRo14ObmhlatWqFNmzbivB95KZOVp0+fomrVquL8MFl5/PgxlJWVxRtJmeddEAR8+fLlh/cTmpqa6N27N9asWYPFixfD0NAQq1atgoKCgswNFSDrc121alUcOXIEiYmJ0NDQyHObvve8EpUUDK4QFZF3797h8OHDmD17ttREsgDQqVMn9OzZE+fOnUPTpk2hqqoKAFLzeGTKKi0rampqSE1NlUnPfC772+O3bNkS586dw6VLl3D06FH8+eefmDp1KubMmZPjcZSVMy4rVapUyfLHdbdu3VCjRo0CaZOdnR2MjY1x8uRJCIIALS0tNGzYEFWrVkV8fDyuXLmCU6dOwcnJSZzcTx6Zdc6U+UUgr6s7fc/2eT2fADBx4kQ0atQIhw8fliqzcOFCqTooKCggISHhh9U5L8fIT7t+pKFDh6JXr164ePEi1NTUcPv2bUycOFGs39ey+6xm3mEtLm0iooK1adMmVK5cGdOnT5fJK1++PDZs2CAGVwqib1NVVUVKSopM+rf9tbKyMvbu3YsXL17g9OnTuHjxIqZMmYLp06fj8uXLuQYpMgMALVq0gLm5eZZldHR05G7TyZMncfLkSezdu1fq2njr1i2pcpnX0rz0T9ra2jJpqqqqSExMlElPSUlBamqquP9atWrhyZMnuHr1Kv7991+cPn0a69atQ/PmzREYGAhFRcU8lcmKmpparvVXUVGBvr5+lv1E165dxZsYP5Kvry+WL1+OzZs3Y8iQIdixYwfc3NyyDKRk974rKCiIn6G8tul7zytRScHgClER2bJlC9TU1DB27FiZH7AAsGLFCmzYsAFNmzaFuro6atSoIfNFBMhYISYvKlSogJSUFLx7905qeG1W+wQy7mx4e3vD29sbfn5+8PLywrJly8TgSuYPyW9/ZKurq8Pe3h4fPnzIdXSEvG0CMh5TOXXqFARBgJubG1RUVGBqaoqaNWviwIEDuHr1KiZOnJjrfrJrT1HLz/kMDw+XGXHx4cMH3L9/X1wtSE1NDfb29rhy5QrS09Nl7vAVhLwcIz/tkkdu72uXLl0wZswYrFq1SvzindWdOyDj/8rXo6o+ffqEZ8+eoWfPngAKr01EVHgkEgk2b96MDh06ZPn/2tLSEps3b8aVK1fg7OwsTqJ969YtqWBqXFwcnjx5kuWP129VqFABb968kUr7/PkzHj9+jOrVq8uUr1y5MgYMGIABAwbg6dOnsLKywrZt2+Dn5wcg4zqY1TWwQYMGAABdXd0cr1nytik8PBxAxg2Rr307GXBmfS5evCizuk9eODg4YNeuXfj48SPKli0rpt+4cQOCIIjtADJWLHJxcYGLiwsmT56MGTNmYPbs2Xj06JG4SmBeynyrQYMG2LBhAyIiImBqapptmS1btqB58+biRPsFLbe+z8rKCs2aNcOaNWugpaWFuLi4LB+HBTLe98x+7us0Ozs78Tj5adP3nFeikoLhQaIiIAgCNmzYAHd39ywDKwDQsmVL7N+/X3ycY/jw4bh+/bq4pB6QEYS4dOlSno7ZokULKCoqSj1je+3aNVy+fFmqXGxsLNauXYukpCQxLT09HYmJiVJfVipUqAAAePXqlcyxZs2ahbt372LWrFlSz4GnpaVh586d4vBQedsEZDwaFBkZiX379qF58+ZievPmzbF27VqkpqaKs+bnJKf2FLW8nk8HBwecOnVKvGuWkpKCkSNHyizDPH36dDx58gSTJ0+W2t/Vq1fx33//FUid83KMvLZLHrm9r2pqavjtt9+wf/9+7N69G40bN5YZSZZp165diIqKApDxhXXChAlISUmRWgmhMNpERIXn5MmTePXqldRqNV9zcHBA+fLlxVX+3N3dYWtri3nz5omPTwqCgKlTp0r1oTlp2bIljh07Jl63JBIJpk2bBkNDQ6lyx44dk1nhLfP6/3XZChUqZHkNbNSoEVq0aIHJkyfj3r17UnlhYWHiCmfytikzqHHw4EExLTg4GIcOHZIq5+zsDA8PD8ybN0/qJktKSorU94TsDBs2DGlpaRg3bpx4/f306RP+97//oVy5cmKAYPXq1Xj//r3UtgkJCVBSUhLnBMtLmayMGTMGampqGDBggNRqOi9fvhRXeho3bhxUVVXRr18/8ZGoTJkjhuWVl+80Q4cOxfPnzzFx4kTo6uqiU6dOWZa7cOGC1CqOGzduxJ07dzBy5EgxLa9t+t7zSlRiFOLkuUT0/509e1YAIKxcuTLbMjdv3hQACEuWLBEEIWMVn1GjRgmKiopC3bp1BVdXV6Fp06bCjh078rRakCAIwtSpUwUFBQWhfv36QqNGjYR27dqJK55krhaUmJgoDB48WDA2NhYaNmwotG7dWqhYsaJQrVo14dKlS+K+kpKSBBsbG6FcuXJC27ZthU6dOgkPHjwQ8/39/QVTU1PBzMxMaN68udCoUSPB2NhY6Nmzp7haTH7alJ3w8HABgABA+O+//8T0zJnrtbS0hJSUFKltsjo/ObUnc7WYb1fIyWo2/pxWC8rL9tnJy/m8ffu2YGZmJpiYmAheXl5C5cqVhRUrVgidOnUSqlSpIrW/zZs3C2XLlhXMzc2FFi1aCDY2NoKLi4vw+vXrAqtzbsfIa7vkWS0ot8+pIAjCixcvBEVFRQGAsHXrVpl9ZJ6LS5cuCba2toKHh4dQpUoVoUyZMsL27dtlyuelTURUMnTs2FHQ0NCQWi3lW7179xY0NTWF2NhYQRAE4enTp4K1tbWgp6cneHp6CjVq1BBWrFghtGjRIk+rBUVGRorbN2/eXLC2thZ27Nghs1rQ5cuXhYYNGwqVK1cWWrRoIbi7uwtlypQRevToIVXfw4cPC8rKyoKTk5PQqVMnYfTo0WJeXFyc0KdPH0FVVVWoU6eO0KpVK8HGxkaoUqWKsHHjRrFcftqUlSlTpgiKiopC/fr1BVdXV6F27drC5cuXpb7nCELGykSdO3cWVFRUhLp16wqenp6Cubm5MHv2bLGMmZmZ0KNHjyyPs2fPHsHQ0FCoVKmS0Lx5c8HQ0FCwsrISbt26JZb5888/hYoVKwr29vZC69atBTs7O8HQ0FCqvXkpk53Lly8L1apVE/T19YWmTZsKTk5OQo0aNaS+09y8eVOoXbu2oKenJ7i5uQnNmjUTzM3NhWbNmol9lDyrBQmCIPTs2VPQ0NAQvLy8hE6dOsn022lpaUKFChUEAMKQIUNkts9cLWjXrl1CkyZNhMaNGwt16tQRlJSUhPHjx8uUz0ub5DmvRCWBgiDkcYF6IiowDx8+xKNHj+Du7p7tXR9BELB//36YmJjA2dlZTH/16hXu37+PcuXKwcnJCe/evcOlS5ek9rVmzRoMGTIEb968kXmO+vnz53j48CHMzc3h4OCAiIgIXLlyBU2bNpWaAC8+Ph73799HTEwMzM3NYWdnJzPZWFpaGm7cuIF3794hPT0dbm5uUs8Kp6Wl4d69ewgPD4eRkRGsra2znPskL23KyeHDh5GamoqOHTuKaYmJiTh69CgMDAzQtGlTmXNw584deHt7Q0NDI9f2PH78GPfv30e7du2kJqmLjo7G2bNn4ezsLA7/zWrf+dk+J3k5n1++fMGdO3cQHx+POnXqoFy5crh27Ro+ffokc+c1OTkZt27dQkxMDKpVqyY13Lyg6pzTMfLarqzOaXbvYXbnLafPKZAxRPrdu3d4+/YtNDU1pfJ+//13TJo0CTExMVBXV8eVK1eQkpKCBg0aZDuXT14/+0RUvP3zzz/Q1NTMccW5Z8+eISgoCK6uruJjt+np6bh+/TpiYmLg4OAAU1NTXLp0CUlJSVL7srW1RdWqVaVGdQAZ15CrV6/i8+fPcHJygpGRES5evIjU1FSZPu3Vq1d49OiR+AhxViuvvHv3Dnfv3kVCQgJ0dHRkRnR+/PgRQUFBSEpKgqWlJaysrGQe6cxrm7Lz+vVrPHz4EHp6eqhXrx7S0tJw+PBh2Nvby0xkHxERgXv37kFdXR21a9eW+n4SGBgIIyMjODk5ZXmcpKQk3Lp1C9HR0TAzM4ODg4PMXB6pqal4+PAhwsLCUK5cOdSuXVtmhaK8lMmORCJBcHAw3rx5AzMzM9jZ2WU5yW1ISAhCQ0OhqamJGjVqSI00jY2NxalTp9CwYUOYmZllm5aT4OBgvHjxAqmpqbCzs5Ppg3v16oXt27fj1q1bMo9inT9/Hu7u7jh27BhatGiBGzdu4P3796hdu7Y4MiYrObUJkO+8EhV3DK4QlULLly/HyJEjER0dzWGWRLl4/PgxatSogUGDBmHNmjUy+V8HVxggIaKCZGVlBScnJ+zcubOoq0I/mfT0dBgbG8PMzAxBQUEy+V8HV7J7LI6IpHHOFaJS6L///oOhoSEDK0R5sH79eigqKmLEiBFFXRUi+ol8/vwZYWFhsLKyKuqq0E/owIED+PDhA0aNGlXUVSEqNRhcISpFrl27hqZNm2LTpk2YN29eUVeHqFhbtGgRPDw8sHjxYkyaNAk1a9Ys6ioR0U9i2rRpsLe3h7GxMQYNGlTU1aGfyOHDh9G2bVv06tULzZs3R69evYq6SkSlBh8LIipFwsPDce/ePdjZ2eX4PCwRZQQjIyMjUb16dVhbW2dbLrv5Z4iIvte///4LRUVF1K1bN9d5o4gK0pMnT3D//n2YmZmhfv36MvPpZXr//j0uXLggNZcQEeWMwRUiIiIiIiIiIjnwsSAiIiIiIiIiIjkwuEJEREREREREJAfloq4AUW4kEgkiIiKgra2d7XOhRERUNARBwOfPn2FqagpFRd6zKYnYzxIRFU/sY0sWBleo2IuIiODkrERExdybN29gbm5e1NWg78B+loioeGMfWzIwuELFnra2NoCMi4qOjk4R14ZIPnFxcahevToeP37MzzOVCnFxcahQoYJ4raaSh/0slSbsZ6k0YR9bsjC4QsVe5hBlHR0ddpJUKigoKPDzTKUOHycpudjPUmnDfpZKG/axJQMf3CIiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBEREX1l0aJF6NWrl0z6q1ev0KBBAwQHBxdBrYiIiEqHyZMnY/To0TLpd+7cQYMGDRAWFlYEtZIfJ7QlIiKiQhXWqmWhHs888Fi+yr948SLLAEpiYiKuX7+OuLi4gqoaERFRgSvu/eyTJ08QHx8vkx4XF4fr168jKSmpoKpWqBhcISIiIvoOq1atQkhICFxdXbFv3z58+PABbdq0wYgRI6CoyMHBRERE8pgzZw7S09NRsWJFHD16FJ8/f0bXrl3x22+/FXXVssTgChEREdF3eP36NdavX4+rV69i2rRpiI6Oxrhx4/DhwwfMnTu3qKtHRERUooWGhmL37t1wdnbGmDFj8OrVK4wcORKJiYkYNmxYUVdPBoMrRERERN8pPT0dhw4dgqmpKQBAQ0MD/fr1w7hx46Cnp1e0lSMiIirh1NTUcOjQIWhpaQEAUlNTMXv2bAwePBjKysUrnMExq0RERETfqWbNmmJgBQCaN2+OL1++4L///ivCWhEREZUODRo0EAMrQEY/+/79e7x+/boIa5U1BleIiIiIvqKurp7lZHqZaerq6mJamTJlpMpkvuakt0RERFkrrf0sgytEREREX7G0tERYWBhSU1Ol0p8/fw4AqFKlipj27NkzpKeni69DQkLEfRAREZEsS0tLvHjxQib9+fPnUFdXlxoR+vjxY6kyISEhUFBQQOXKlX94PfOLwRUiIiKir7Rr1w4KCgqYP38+BEEAAMTExODPP/9Eq1atoK+vL5aNiorCsmXLAGQ8Bz59+nQ4OzvDysqqSOpORERU3HXt2hVv377FmjVrxLS3b99ixYoV+OWXX6RW3Hv48CH+/vtvAMCXL18wd+5cdOjQAbq6uoVe79wwuEJERET0FTMzMwQEBGDbtm0wMTFBrVq1YG5uDiMjI2zYsEGqbK1atRAQEIAqVarA1NQUwcHBWL9+fRHVnIiIqPizsbHBzp07MXv2bJibm8PW1hZVqlRB3bp1sWjRIqmyjRo1wu+//w4rKyuYmZkhJiYGS5cuLZqK56J4Ta9LREREpZ554LGirkKumjdvjtDQUERERODDhw+oXLkytLW1ZcoZGRnh9OnTYjkbGxsoKSkVQY2JiIgylIR+tnPnzvDx8UFYWBhiY2NRuXJlmflVAMDCwgI7duzA69ev8fnzZ9SsWRMKCgpFUOPcMbhCRKWezaRHRV0FkSQlHgAQ4dMJccVs+biclIROmuhHMDU1lXr2W95yRKVJcepfM5XUfhZgX0s/HwUFBVSoUAEVKlTItWzFihULoUby4WNBRERERERERERyKFnhXCIiIqJiYujQoYiPjy/qahAREZVK06ZNK+oq5AuDK0RERETfIS/DmImIiOj7VKlSpairkC98LIiIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QgXixYsXCA8Pz/Y1ERERERERUWnF4Eop8vr1awQFBSEoKAj37t3D69evkZ6eXijHHj16NPz8/LJ9TZQbQRCwceNGtGjRAq1bt4a/v7+Yl5aWhj///BPNmjVD27Zt8e+//+Ypj348X19feHt7S6Vt27YNLVu2hKenp9T7+HVekyZNMHHiRK60QkRUSIKCguDk5IRDhw6JadOnT4ejoyMcHR1x5MgRqfLh4eEYNGgQXF1dMXDgQERFRRV2lX96I0aMEN8fR0dHLFu2TMz78uULxo0bh0aNGqFfv3549+6dmPf8+XP069cPrq6uGDZsGD59+lQEtSf6+TC4UopMnz4dLi4u6NOnD3r37o369evDzMxM5scNUXG0ceNG3Lt3D//73//Qs2dPDBs2DOfOnQMAzJs3D7t378bEiRPRpUsX+Pj4ICIiItc8+rH8/f3x9OlT3Lt3T0wLCAjAlClTMHDgQIwYMQKTJ0/GhQsXAABnz57FuHHjMHDgQMycORM3btzAlClTiqr6REQ/jZSUFIwYMQIA8P79ezG9b9++WLNmDTQ0NPDhwwepbVq2bAkVFRXMmzcP2tra6NatW6HWmYAnT56gd+/eWLNmDdasWYNOnTqJeePHj0dQUBBmzpwJRUVF/PLLLwCA1NRUeHp6wsjICPPmzUNqair69etXVE0g+qlwKeZSxtHREefPnxdfT58+Hb169ULr1q2hpaWV47afP39GREQEKleuDFVVVZn82NhYvH37FpUqVYKGhka+65aYmIiwsDCYmJjkWhf6+fTq1Uv83KWnp2PRokWIjY0FABw/fhxTpkyBp6cnAODcuXPYvHkzpkyZkmMe/Tjv3r3DihUrsHDhQnTu3FlMP378OAYOHIgOHToAAJ49e4Y1a9bAzc0NiYmJsLCwQLt27aCoqIgLFy7w8UEqlm7cuIHAwEAAgJKSEnR0dGBlZQVXV1f2X1QizZ49G3379pUatQIAlStXRuXKlaGrqyuVHh4ejpCQEAQFBUFRURGNGzeGnp4eHj9+jOrVqxdm1X961apVg6Ojo1Raamoqtm7diqCgIFStWhVNmjRB+fLl8ezZMyQnJyM2NhZ//PEHAMDZ2Rmampp4+/YtTExMiqIJRDLOnj0rjjZXVlaGrq4urK2t4erqCjU1tSKu3fdjcKWUc3d3x5w5c/Du3btsvxAmJCTA19cX/v7+MDMzEy/I/fv3B5Ax7HDw4ME4cOAATExMEB4ejr59+2Lp0qVQVs7bR2jZsmWYOnUqTExM8PHjR7Ro0QJr166FtrZ2gbWVSjZVVVVcunQJI0eORFhYGLp374527doBAExNTXHz5k106NABycnJCAoKEh95yymPfhxfX18sXLhQJtBqamqK27dvQyKRQEFBATdu3MDTp08BAN7e3vj3339hbm4OHR0d6Ovriz9g6ediM+lRoR7voZ91vsrfuHED8+fPx+TJk5GWlobnz5/j77//xn///YdZs2ZhzJgxP6imRAXv1q1bCA4Oxty5c2WCK9kpW7YsFBUVcffuXdStWxcPHz7E58+f8fTpUwZXCtm0adPw+++/w9HRERMnToShoSHevn0LiUSCqlWrAgBUVFRQvXp1PHv2DI6OjoiPjxcDYTdv3kRqaipCQ0MZXPmJFPd+9uzZs1i1ahVGjBiB1NRUPH78GBs2bEBYWBgWL16M3r17/6Ca/lgMrpQy8fHxCAoKAgBERUVhzpw5cHd3h6WlZbbbDBkyBDdu3MCjR49gaWmJhIQEbNiwQcwfPnw43r17hzdv3kBPTw+RkZFwd3fHsmXLMHbs2Fzr9PHjR4wePRpnzpyBu7s7BEHA3r178fbt2yyDK8nJyUhOThZfx8XF5eMMUElmZ2eH1atX49GjR5g0aRJ8fHzg4uKCOXPmwNvbG3v27EFqaipq1aolfkZyyqMfY/v27bC0tETDhg3F602mkSNHokWLFqhYsSKUlZXh6Ogovh+3bt3Crl27sHjxYhgZGWHGjBlYtWoVRxlRsaSqqoqZM2dKpe3btw9du3aFrq4ufvvtNzE9ISEB+/fvx5s3b1CpUiV07NhRDDxGR0dj+fLlGDNmDHR0dAAAS5cuhYGBAXr16gUAePnyJbZv344pU6bg7NmziIiIgKenJ06ePIno6Gg0adIEDg4OBdY29rM/j+TkZIwcORJ79uzJ13bq6upYsWIFmjZtCnNzc2hqasLKyor9ayFbsWIFYmNjERsbi1WrVqFt27a4cuUKEhMToa6uLlVWXV0dX758gaGhIebNmwcnJydUqFAB+vr6qFSpEt87KnYMDAxk+tnVq1ejb9++KFu2LFq3bi2mx8TE4MCBA3j37h2qVauGdu3aQUVFBUDGvKNbtmzBlClToKSkBCBj2gBra2t07NgRAPDgwQOcOHECY8eOxcGDByGRSFCnTh2cOXMG8fHxaN68Oayt8xcgygrnXCllQkJC0KdPH/Tp0wcDBgzAs2fPMH78eCgoKGRZPjo6Gjt37sTcuXPFAEyZMmUwcuRIABmPAm3duhU9e/ZEWFgY7t+/j6ioKLRo0QIHDx7MU50SExMhCII4ckZBQQFdunSBlZVVluX9/Pygq6sr/lWoUCGfZ4FKKl1dXdSrVw+9e/dGz549sW/fPgBAzZo18fTpUxw9ehR3795F2bJlUaVKlVzz6MdYunQpjh8/DkdHR/To0QNRUVFwdHRESkoKDAwMcOPGDVy8eBFXrlxBgwYNxPfD398fnTt3Rrdu3dCsWTP4+flh8+bNRdwaorzz8fFB9+7d8fvvv4tpb9++hZ2dHZYuXYoPHz5gwYIFqF27tjivha6uLpYsWSIOf46OjsbYsWMxduxYCIIAADhw4AD2798PRUVFnD59GpMnT4a7uztu376NoKAg1K9fP88jDvKC/ezP4+TJkwgJCUG7du3g6OiICxcuYO7cuVi5cmWu2w4YMABhYWHYs2cPzp8/j6ioKPavhSzzkaBmzZrh77//xvXr1xETEwMTExN8+vQJCQkJYtnw8HCYmpoCAMaOHYvXr19j7969OHLkCN69e8f3jkqEIUOGoGnTpuJjbUDG3EM1atTA5s2bERUVhcmTJ6NBgwb48uULgIx+dtasWbh79y4A4NGjR5g6dSqmT58u7mP79u04ffo0AODgwYMYP348WrVqhfv37+Py5ctwcHDA5cuX5a4/R66UMt/OuXLw4EG0adMGFy9eRMOGDWXKP3v2DBKJJNs7Yk+ePEF6ejr++OMPmUeAzMzM8lQnc3NzTJw4EY0bN4azszPc3d3RrVs3cSjjtyZNmiQ15DouLo5f/H4CO3bsQNu2baGjo4MvX77g8uXL6Nq1q5ivrKwsDm8NCAjAnTt38pRHBW/79u1ih/bkyROMHj0aa9asEe8gKCgooHLlynj9+jWWL1+Ov/76CwBgbGyMI0eOIDU1FSoqKrhy5Yr4RZCopGjatCl27tyJ6OhoGBgYYNq0aTAwMMCVK1egqqqKpKQk1K1bF7Nnz8aKFSugpKQEFxcXnD9/Hq1bt8aFCxfg4OCAV69e4eHDh7C1tcX58+fRpEkT8RgfP37Ev//+K9700NbWxtKlS8VHJeXFfvbn4erqihMnToivx40bB1dXV3FerNxoa2vDxsYGM2fOROXKlVG7du0fVVXKxcmTJ6GlpQUdHR0oKSmhQYMG2LhxI0aMGIELFy4gLi4OderUEcvr6elBT08Po0aNgrOzMywsLIqu8kT50LRpU8yaNQuCIEBBQQFjxoyBg4MDAgMDoaioiJkzZ8La2hpLlizBlClToKurC3t7e5w/f178Ldy0aVNcunQJ79+/h5GREc6fPy+OYgGAT58+4fHjxzA0NASQcfNk5cqVaNSokVx1Z3CllGvfvj3Kly+P/fv3ZxlcyRy2nN1yqJkTCm3duhV169b97nr4+flh3LhxOHfuHA4fPgwbGxscO3YMTZs2zfKYJXkiI/o+BgYGsLGxgY6ODsLCwtC8eXMMGjQIAHDhwgWMHTsWCQkJCA8Px+LFi1GtWrVc8+jHqFmzpvhvZWVlqKioiJPthYWFoX379khJSUFoaCiGDRuGNm3aAAAGDhyIAwcOwNzcHLq6uoiPj0dAQECRtIHoexkYGADIGKJsYGCAY8eOYdKkSeKE3Orq6ujduzfWrVsnbtOkSRNx5b7ML32hoaE4d+4catasiYsXL0qt5lG7dm2px3nt7e1x9OjRAmsD+9mfh56entRkqHp6eqhUqZJ4g2zTpk1YtWoVnj17hocPH2LlypU4ePAgzM3NMX36dAQGBuLt27coU6YMDhw4kO1IaCp48fHxYtA189Ggbdu2iY89LFy4EO3atcPy5csRFRWFdevWideh0aNH4+LFiwgLC4ORkVGBjnwj+tEMDAyQkpKCL1++QENDA6dOncLOnTuhqJjx0I2uri66deuGY8eOiY+WN2nSBOfOncO4ceNw/vx5eHt7IykpCefPn0fLli1x584dLF++XDyGq6urGFgBCq6fZXCllEtJScHnz5+znczW2toaZcuWxeHDh6XuRqSkpEBVVRU1a9aEoaEh/P39ZYIrSUlJMs97ZiU5ORlqamooW7YsfHx84OPjg1evXuHIkSNZBlfo59SqVSu8ePECT58+Rfny5cUfMEDGD43MkRFVq1ZFmTJl8pRHP1716tWlJqU1MjLCmjVroKSkhEqVKkm9jzo6Orh8+TLevHmDL1++wNLSUhztQlRSREdHAwD09fUhCAIiIyNlJok0NTWVWgmrSZMmmDhxIj59+oTz58/Dz88PFSpUwLlz5+Di4oLY2Fg0btxYLP9tn62srIzU1NQf2Cr6WSxatEhqZaCWLVuiVq1aUmWMjIwAZCzT3LZtW2hpaaF69eoMrBQyDQ0NrFmzBkDGj0kLCwupPtPZ2RmvX7/Gs2fPULFiRan3dejQoejRo4e40hlRSRIdHQ1VVVWUKVMG7969Q0pKSp762fXr1yMtLQ3//vsvJkyYgI8fP+LcuXPQ0tKCurq61G/ZH9XPMrhSynw9oW1MTAxWr14NQRDQvXv3LMsrKytjwYIF8PX1hSAIaNKkCR4/fozDhw/j0KFDUFZWxpIlS9CvXz8oKirC29sbMTExCAwMhIGBAfz8/HKt0/379zF8+HAMHjwY1atXR0hICG7fvo0RI0YUZNOpFFBWVs5yMqlv77zlNY9+PA0NDakv5mpqarm+H3z8gEqys2fPomrVqmLg0NjYGG/fvpUq8/btW6lHZ+vUqQMtLS0cPHgQjx49gqurKypUqIBZs2bh3LlzqFWrFvT19Qu1HfRz+nbeDRMTk2xXkMlcppmKhpKSUq79qYaGBuzs7GTSs3v0nqgkOHv2LOrVqwcgI9irqqqaaz/buHFjJCQkYOfOnUhKSoK9vT0+fvyIkSNHQltbGy4uLnle5VYeDK6UIhUrVkRQUBD69OkDAOJ64Tdv3swxat2vXz+Ym5tj7dq1CAwMRO3atbF69Woxv2fPnqhUqRLWrFmD8ePHw9TUFK1btxaPA2R0wOXLl8/ytaOjI5YtW4ZVq1Zh7dq1KF++PLZt25bn532JiIiKgwMHDsDf31+8mwxk3Pnftm0bBg0aBBUVFSQnJ2Pr1q1o2bKlWCZz3pW5c+eiTp060NbWhq2tLRQUFLBq1Srx0TkiIqKf2bp163D27FnxUTZFRUV4enpi06ZN6NSpExQUFBAXFwd/f3/4+vqK22XOuzJnzhy4ublBUVERjRo1QmhoKAICAjBgwIBCqT+DK6XI7NmzMXv27O/atnnz5mjevHm2+a6urnB1dc02f8mSJTm+rlevnhiBJCIiKu5SUlLEJSI/ffqE69ev48GDB5g/fz769+8vlpszZw6cnZ3RsGFDNG7cGGfPnkVKSorUKgVAxpDlwMBA+Pj4AMiY+Llx48bYv3+/1GS2REREP4Po6GjMnDkTgiAgOjoaly5dwqtXr7B+/Xqpmw6LFy+Gq6sr3Nzc4OjoiKNHj8LY2BijR4+W2l+TJk2wePFiDBs2DACgqakJR0dHXLlypdD6WQZXiIiIiL5Sr149TJ48GUDGqBMLCwt4enrCzc1N5jltExMTPHjwAPv378ebN28wfvx4dOzYUZwwPlOnTp2QkJAgBlcAYOTIkbCzs5P60ufh4SE1aTSQMdHe16v7EBERlWRNmzYVH9NRUVFBtWrV0KZNGzRu3FhmTk8rKyuEhITgwIEDiIyMxLx589CuXTuZeft69+4NbW1ttG/fXkybMmUKbt68KTXfSvv27SGRSKS2dXFxkZon8HspCIIgyL0Xoh8oLi4Ourq6iI2NhY6OTlFXh0ogm0mPiroKIklKPN6sdcct54bQKoRnPwuKeeCxoq4CFVO8Rpd8fA/pexWn/jVTSe1nAfa1JIvX55JFsagrQERERERERERUkjG4QkREREREREQkBwZXiIiIiIiIiIjkwOAKEREREREREZEcGFwhIiIiIiIiIpIDVwuiYo+zZFNpEhcXB1NTU0RERPDzTKUCr9ElH99DKk3Yz1JpwutzycKRK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREclAu6goQlRY2kx4VdRWoBJCkxAMAInw6IU6Zl2D6PuaBx4q6CkTFDvthAtjP0vdj30ry4sgVIiIiIiIiIiI5MLhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDkW++LtEIkFwcDDCwsJgaGgIa2tr6Orqivm3bt3Cy5cvAQAqKirQ19eHjY0NypYtm+0+nz17hqCgINSrVw8VK1bMtlxsbCxOnToFc3NzNGjQoMDalFnnmjVrombNmlJ5z58/x507d2BsbAwXF5cCO2ZhuXz5MrS0tFC7du2iroro7NmzWLBgAQCgSZMmmDhxYrZlT506hUWLFomvjYyMsH37dqkyqamp6NOnD2rWrIkpU6YAANLT07F+/XqcPXsWOjo6GDNmjMx7S0RUVGbPno0rV64AAKZOnZpr//Lvv/9i8+bNiIyMhKGhoXgdzGk/79+/x8KFC/HkyRPY2dlhwoQJKFOmzA9qEZUkz58/h6+vLwDAwsICa9asydN248ePx6dPn7B+/Xox7cKFC9i8eTPS0tLQpk0bdO3aVczbv38/AgICkJKSgkaNGmHYsGFQVi7yr7JEVApduHABfn5+AABXV1fxN0FWvv4tAgAGBgb4+++/c82TSCTYuHEjTp06BW1tbYwePRq2trY/ojlUSIq0Rzp8+DBGjBiB9PR01KpVCzExMXjx4gU6duyIFStWQEFBAStXrsTRo0fh5uYGiUSCqKgo3L17Fw0bNsTSpUulPoB37tzBpEmTEBoaitDQUGzfvh09e/bM9vj9+/fHoUOH0LZtW+zbty/bcpcvX0b58uVRtWrVPLVr5cqV2Lp1Kxo3bowLFy5I5U2YMAH79u1DixYtcPz48Tztrzjx8/ND1apVsXTp0qKuisja2hqjRo3C4cOHERQUlGPZ8PBwpKenY+zYsQAAdXV1mTJz5szB8+fPkZycLJV24MABTJ48Ga9fv0azZs3w+PFj6OjoFGhbiIi+R5s2bVCvXj3873//Q2RkZI5lT548iS5dumDKlCno0qULNDQ0ct2PRCKBh4cH6tati19//RV79+7FgAEDxC+I9HMzMjLCqFGjEBwcjG3btuVpmz179uDSpUuIiYkR086dO4eFCxeie/fuSE5OxpgxYwAAXbt2xalTpzB48GD8/vvv0NLSwvz58xEfH4+pU6f+kDYR0c+tevXqGDVqFAIDA3H37t0cy0ZERCA1NRXjx48HAKipqeUpb/78+di9ezemTp2KsLAweHh4ICQkBHp6egXfICoURRZcOXHiBNq3b48FCxZg9OjRUFTMeEIpJSUFGzduhCAIUFBQAADY2NhIBT9iYmIwaNAgNG7cGLdv30blypUBAB8/fsTo0aPRokULcX/ZWbt2LaKiouDh4ZFrXf38/ODh4YFRo0bluX1OTk64ceMGnj17JgZlPnz4gCNHjmR5RzE1NRU3btxAdHQ0bG1txTZlunjxIvT19WFhYYGgoCCkp6ejXr16Ul+K87KfTMHBwXjz5g1sbW1RqVIlAMDDhw/x9u1bmXPy4MEDREZGQk9PT/yynfl+tGjRAtra2gCAoKAghIWFwdLSMstRHaGhoXjy5AlMTU1hZ2eX63uUVyYmJjAxMcGzZ89w6dKlXMubmZnBy8sry7w7d+4gKCgIvXv3xunTp8X0AwcOYMGCBWjRogUA4Pr169i5cyeGDBlSIG0gIpKHg4MDAOD333/PteykSZOwePFi9OvXL8/7CQ0NxcuXL3H37l0oKiqiTZs20NHRQWRkJDQ1NQugBVSSaWtrw8vLC+rq6nkKrkRFRWHZsmWYPXs2hg8fLqY7OTnh6NGj4uszZ87g9evXAIDIyEg4ODiIn9v79+/nGkgkIvpexsbG8PLywsuXLxEREZFreRMTk2x/X2SXd+DAAfz+++/w9vYGANy8eRPbt2+Xui5SyVJkwZXx48fD3d1dHEGQSVVVNdcfrPr6+ti+fTssLS3xxx9/iMNPPT0983TsBw8eYNasWbh27Zo4jLWgGRgYoH379ti0aRPmz58PANi6dStcXV1Rrlw5fPjwQSwbGhqKli1bIi0tDZUrV8a1a9cwcOBALFmyRCwza9YsJCcn4+3bt6hSpQpCQ0MBAFeuXEG5cuXyvJ93796hU6dOePz4MRwcHBAaGooePXpg9uzZiIqKQqtWrRAWFibuEwD69esHFxcXVKlSBeHh4YiNjYW/vz8AwNnZGYmJiejQoQMiIiJgbW2N+/fvw8bGBgEBAeKQ8REjRmDbtm1wdnZGVFQU1NXVcfDgQRgaGv6Q85+Tq1evon379qhQoQJ8fX1hbW0NICOwN2LECPj7++PIkSNS25QtWxaPHz9GixYtkJaWhtDQUJiamhZ63YmI5JGcnIygoCCUK1cOXbp0ga6uLoYOHQp7e/sct9PX10diYiLCwsJQsWJFhIaGIikpCU+ePMl1W6Jv+fr6YsGCBRAEQSpdS0sLr169wqBBg/Du3TtUrlxZ/J7WvXt3XLp0CbVr10aZMmWgrq6O3bt3F0X1iYhk3LhxA+3bt4e5uTmGDBkCGxubXPMyf194e3sjPT0dz549g4GBQVE1gQpAkQRXIiIicP/+faxevfq796GmpgYvLy+cP38+X9slJiaiW7duWLRoUY7zsRSEfv36oU+fPpgzZw6UlJSwceNGTJ8+XeaHu6+vLywtLXH48GGoqKjg5s2baNiwIVq0aCEV5QwJCUFQUBDMzMyQkpKC2rVrY9WqVZg5c2ae99O7d2/xP6+uri4EQcDBgwcBZMxXUqlSJezYsUMcivvw4UPcvHkTmzZtgq2tLY4dOybzWFCbNm1QrVo1/Pvvv1BSUkJSUhKaNm2KefPmYf78+YiIiMCKFSvw4MED8WJy48YNJCQkZBlcSU5OlnokJy4uTu73IpOnpyeMjY2RkpKCy5cvo2HDhggKCoKFhQVmzJiB3377Debm5jLbzZ49G+3bt4e/vz+io6NhYmKChISEAqsXEVFh+PTpEwRBwPLlyzFw4EA8evQIbm5uePjwYZbXvkyGhoaYNGkSHBwcYGtriy9fvqBSpUq8DpZQP7Kfzc3OnTtRqVIlNGrUKMvRpmXLlsWoUaPw4sUL+Pn54cKFC2jVqhXu3buHEydOYMKECdDT08PcuXNx9OhR9OnTp9DqTkSUlWbNmsHQ0BCpqam4cuUKnJ2dcffuXVhaWuaYN3PmTHF6Cv6+KB2KJLiSOYwz83GU72ViYoKoqKh8bTNixAg4ODige/fu2ZZ5+PAhHj16JL6OjIzEvXv3pB5NcnNzg5GRUY7H8vDwgIqKCo4fPw59fX28e/cOHTp0kAquxMTE4OTJkzhz5gxUVFQAZAyL9fLywq5du6SCKx06dICZmRmAjBE+Li4uCAkJyfN+IiMjceLECRw7dkycNFhBQQEdOnQQ//3bb79h06ZNYnBl06ZNcHJyynZypaioKBw5cgQLFizA4cOHIQgCBEFAtWrVcObMGQCAsrIyFBUVERISIgZX6tWrl+158/Pzw6xZs3I8t9/LzMxMPIdt27ZFSEgITpw4gb59+2LJkiVo0qQJdu/ejTdv3uDjx48YOnQo/vrrL7i4uCA0NBT3799HxYoVMXHixGwfuSIiKq6MjIygqKiIOXPmoH79+gAyJu07d+4cfv311xy3nTVrFvr164dXr17B1tYWFhYWvA6WUD+yn83NvHnzYGRkBC8vL3z69AlhYWHw9vYWHwfS0tISv/ukpaVh/fr1aNWqFTZu3IiePXuKo5u1tLQwY8YMBleIqMhlTlEAZNx0fvLkCY4dO4ahQ4fmmOfs7Iznz58jODgYFSpUwLRp09ivlnBFElzJfFTk48ePcu0nPj4+XysVXL58Gdu2bcPq1avFQElkZCRUVFSwb98+tGrVCpqamrh//75UICU8PBxpaWn4/PmzmGZtbZ1rcEVBQQF9+/bFxo0boaenhx49ekhNYgQAL168AABYWlpKpVetWlVm8qRvh4mpqanh/fv3ed7Pq1evAGRM0JSdPn36YNq0abhx4wYcHBywY8cOzJ49O9vymSs5nT9/HtevX5fKq1u3LgCgXLlyWL16NYYOHYoxY8bA3d0dvXr1QtOmTbPc56RJk8TgDpBxR61ChQrZ1uF7xcfH4/Hjx+jduzeUlZXFETwAxMmrevToIabp6urCxcUF9+7dw+HDh3M8L0RExZGioiKaNWuGR48eoX79+khMTMSLFy+kHgXNSaVKlVCpUiXMnTsXNWrUQI0aNQp11AMVjMLqZ7Oydu1a8c7sw4cPER4ejpEjRwLImI+vQYMG4sjaO3fuiDdE9PX18fjxY3E/jx494vB5Iip2EhISEBISIrXSWU55Ojo6cHFxwYMHD3DgwAHcunWrMKtLBaxIgitVq1aFvr4+bty4keNqPrm5evVqvpYEVlVVRZs2bRAYGCimhYeHQ0lJCf7+/nBzc4Ompia6deuGbt26iWVat26d7wltM/Xt2xdWVlZQVlbG5cuXZfIzl5T+9OmTVHp0dHSOy01/z34yR6t8/Pgx26iosbExvL29sWnTJrRo0QKfP3+WOhffypzMdsqUKXB2ds623MCBA9G/f38EBwfj8OHDaNmyJXbu3AkfHx+ZsmpqajJBqJw8ffoUw4cPx+vXrxETEwMvLy8MHToUbdq0QVBQEJYvX45NmzYByFha9NatW0hNTcW9e/fg4eGBdu3aQVFRUWqUUObkVZltylxGLT4+HsHBweKqSURExcHmzZuxe/duBAcHY968ediwYQN27doFfX19rFixAlpaWujbty+AjJEDrVq1woYNG/Dy5Us4OzujefPmue4nc5nmsLAwxMbGyjziSiVHfvvZ3KSmpqJNmzaIjo7Gq1ev4OXlBW9vbwwfPhwxMTHo3r27+Miyq6uruJ2WlhbKlCkjfv5UVVVRt25dmJiYIDw8HNra2uLKikOHDoWbmxtq1qwJHR0dPH36FIcOHSqwNhARfS1zifnM0exeXl4YPHgw2rdvj+DgYCxevBhbtmwBAMyYMQPXr18Xf1+4u7ujU6dOueZlLvec+ftizpw5Od4Ep+KvSIIrSkpKGD58OP744w8MGTJEnFA009u3b2FsbCyuFpSV3bt348aNG/n6cufk5CSz5HLr1q2hrq6e41LM8qhYsSJGjx6Nz58/ZxkIqlChAipWrIgDBw6IkwJ++fIFx48fx4QJE/J8nLzsp3r16qhYsSJ27NgBR0dHcduPHz9KBXIGDBiAHj16IDQ0FJ06dRKDMkDGF6Gvn9OuUaMGKlWqhHXr1skEVyIjI2FsbIzY2FioqqpCQ0MD9vb2sLe3x/nz53HlypUsgyv5Vb58eZnAV+ZqRWfPnpWaR6BDhw5wcXGBqqoqLC0tYWFhkeU+vb290aBBA/F15nLPKioqsLOzy/NdXiKiwtCoUSNx2HGmzJGd+/btw+LFi8V0R0dHhIaG4s6dOyhfvjxq1KiRp/1kLtOso6MDR0dHqKqq/qjmUAmjpKQk0w9nzmt38+ZNaGpqio8sf83W1hYbNmwQX7u7uyM4OBhBQUHQ1dVFzZo1xe+Cpqam+O+//xAcHIzk5GTY2dmJN3iIiApa5hLzX8v8zXr+/HmphS3atWuHhg0bZvn7Iqe8zOWe+fui9Ciy1YKmTZuGZ8+eoWHDhhgwYADs7e0RExODoKAgnD9/Hk+ePBE71Pfv32Pfvn2QSCR4//49zp49iyNHjuCPP/4Ql64CMub/+Pfff8XXN2/ehLq6OipXriw+olIU/Pz8ss1TVFTE4sWL0b17dyQmJsLKygobN25E2bJlMXTo0DwfIy/7UVBQwNq1a9G+fXvExMSgSZMmePz4MR48eCAVpPLy8oK2tjZOnz6Ns2fPSh2nbt26WLFiBbZs2QItLS20aNECGzZsQLt27fD582d4e3sjJiYGR48ehYeHByZPnow3b96gY8eO6Nq1K6pXr46QkBBcuXIF06ZNy+eZzJqOjk62S581bdpUarbuvH4OKlSoIDVE+uvnJYmIihsrKytYWVllmbdw4UKZa5+2tjbc3NzytZ/MZZqJvvXt6M+vValSRSqA8jU9PT24uLhIpWlqamY7ElZFRaVIv88R0c8jc4n5rLi5uUkNDqhTp062+8kpL3O5Zyo9FIvqwMrKyti5cyeOHDkCRUVFBAYG4unTp3BxccHDhw+hqJhRNScnJ1hbW8Pf3x/79+/HgwcP0LRpU4SGhuJ///uf1D7fvXsHf39/+Pv7o1OnTggPD4e/vz9u3ryZbT1cXFzQsGHDHOvq4uKCatWq5bltTk5OUsNev1WvXj2p/E6dOuH8+fP48uULzp07h/bt2+PatWtQV1cXyzRu3Bh2dnZS+3FwcJD6ApKX/Xh5eSEoKAjGxsY4e/YsDA0NsWfPHqn9KikpoW3btrC0tESTJk2k8kaMGIExY8bg3Llz8Pf3x+fPn+Hh4YEHDx7A1tYWZ86cQWRkJGbMmIHJkycDyLgzde7cOaipqeHkyZNITk7GlStXZPb9I9jb22d5t4yI6Gfh5ORU1FWgn1iVKlU4NwoRlSq1a9fm6E3KkoIgCEJRV4KKF0EQUL16dfTt2xeTJk0q6uogLi4Ourq6iI2NhY6OTlFXJ1s2kx7lXoh+epKUeLxZ645bzg2hpVxkgwephDMPPFbUVRCVlGs0Za+0vIfshwlgP0vfrzj1rZlKy/X5Z8ErDkk5evQojh07ho8fP2Lw4MFFXR0iIiIiIiKiYo/BFZLyzz//IC0tDSdPnoS+vn5RV4eIiIiIiIio2GNwhaSsXbu2qKtAREREREREVKIU2YS2RERERERERESlAYMrRERERERERERyYHCFiIiIiIiIiEgODK4QEREREREREclBQRAEoagrQZQTru9OpUlcXBxMTU0RERHBzzOVCrxGl3x8D6k0YT9LpQmvzyULR64QEREREREREcmBwRUiIiIiIiIiIjkwuEJEREREREREJAcGV4iIiIiIiIiI5MDgChERERERERGRHBhcISIiIiIiIiKSA4MrRERERERERERyYHCFiIiIiIiIiEgODK4QEREREREREcmBwRUiIiIiIiIiIjkwuEJEREREREREJAcGV4iIiIiIiIiI5MDgChERERERERGRHBhcISIiIiIiIiKSA4MrRERERERERERyYHCFiIiIiIiIiEgODK4QEREREREREclBuagrQESlh82kR0VdhWJPkhIPAIjw6YQ4ZV6CfxTzwGNFXQUiou/CvlQ+7GeLDvte+tlx5AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCBSI1NRVpaWnZviYiIiIiIiIqrbj4+w8ikUigqCgbu0pNTUV6ejoAQEVFBUpKSnneZ1JSEpSUlKCiopJtfk6UlZWhrPxj3vLOnTvD3NwcK1euzPI1FR+JiYnYuHEjgoODoaenh169esHW1lbM27RpE+7fvw8bGxv0798fGhoa4rbPnz/Hhg0bEBYWBolEgh07dhRVM4jyJfOz++HDB7Rp0wZt2rTJU17//v3Fa+u6deugqalZ6HUnouInNTUVW7duxc2bN6GlpYVu3brByckJAJCeno4tW7bgxo0bMDU1xYgRI6Cvrw8A2L9/P/bv3w8AaN++PXx8fIqsDUQ/2qFDh7B3714AQJs2bdC1a9ccy584cQL79++HgYEBhg8fDlNTU6n8hIQEjBgxAh4eHujevXuetyMqLBy5UoAiIyPh6+sLc3NzqKqqwtDQEJ6enjh+/LhYZsCAAdDU1ISenh40NDSgo6MDZ2dnLF26FCkpKdnue+HChdDQ0JC6kHwtISEBenp64p+2tjY0NDSk0kaPHl3gbaaSx9fXF/7+/qhXrx6UlJTQqFEjREREAACaNm2KkJAQODg4YM+ePWjfvr243ePHj1G3bl3ExcWhWbNm8PLyKqIWEOVPeHg4HB0dkZaWBnt7e4wZMwZ79uzJNQ8APD090bx5c+zcuTPHazQR/VwmT56MVatWoW7dutDR0RH7TwAYOnQo1q5dizp16uDNmzdo0aKFuF3VqlXh5eWFDx8+ICgoqIhqT1Q4qlSpAi8vL8TExODu3bs5lj1x4gS6d+8OKysrvHv3Dk2aNJEZBT9hwgTcvHkTt2/fztd2RIWFI1cKyKtXr+Ds7Aw7OzscOXIEtWrVQlxcHIKCgvDnn3/C09NTHKXSuHFjnD9/HgDw6dMnnDlzBuPHj4e/vz/Onj0rc2f05s2bWLlyJRo0aJDt8cuUKSM1cmXlypUYN25crqNZvpXdiJu85udGEAQoKCh89/YkvydPnmD8+PFo3749BEGAv78/wsPDYWpqioCAADHa3759e5iYmCA5ORlqamqYPn06Bg4ciD/++KOIW0CUP0eOHIGzszMWLFgAAKhcuTKmT5+OLl265JgHAF27dkVaWhp69+5dZPUnouLnyZMn8PX1Rf/+/QEA//zzD168eIEaNWrg77//xo0bN1CjRg0MGjQItra2uHDhAtzc3FCrVi3UqlULt27dKuIWEP14tra2sLW1zVMgcdmyZZgzZw6GDh0KAHBycsKRI0fEG31nz55FbGwsWrVqJRU8yW07osLEkSsFZPjw4VBTU8M///wDe3t7KCoqQk9PD02aNMHRo0ezffxHT08PnTp1wrlz53Dv3j0sXbpUKj8uLg6//PIL1q9fj7Jly/6QukskEvj5+aFixYpQVVVFrVq1cObMGTFfEATMnz9fHJFjaWmZ78d9/vnnH9jY2EBNTQ0VK1bE7NmzkZqaWtBNoTxYvnw5/Pz84OPjgwYNGqBXr17iUOavh1EGBQWhRo0aUFNTAwBcvHgRDRo0wKhRozBu3DgEBwcXSf2J8ktLSwvv3r2DIAgAMkYZPnjwINc8IqLs/PHHH9i8eTM6duyIRo0awcXFRRyhUqZMGURGRgLIeGQ7JiYG9+/fL8rqEhV7Dx48gLOzs/i6YcOGYn/8+fNnTJkyBcuWLcvXdkSFjcGVAhAXF4fAwEAMGTIEqqqq37WPSpUqwdvbGwcPHpRKHzx4MFq3bg1PT88CqGnWJk+ejKVLl2L9+vVISEjAzp07cfjwYTF/2rRp2L17NwIDA5GcnIxdu3Zh7ty52L59e572//nzZ3Tp0gWjRo3Cly9fcOPGDQDAo0ePsiyfnJyMuLg4qT8qOCdOnACQ8bhDo0aNsG/fPsTExEiVCQ0NxbBhw7Bp0yYx7f3795g/fz6qVKkCdXV1NGrUSBwCTVScdezYEenp6ahTpw7atWuHbdu2ISkpCcnJyTnmEZVW7Gfld+HCBXz+/Bmenp5wc3NDYGCg+IjtzJkz0bFjR3Ts2BENGzaEoaEhzzFRLmJjY6GlpSW+1tbWxqdPnwAA48aNw8SJE2FgYJCv7YgKGx8LKgAvXrxAeno6qlWrJtd+qlWrhn///Vd8vXHjRjx48ACbN2+Wt4rZSkhIwNKlS/HXX3+Jd1zs7OzEETSJiYlYvHgxDh06hJo1a0IikcDBwQGDBw/G1q1b8euvv+Z6jPfv3yM5ORkeHh5QVlaGsbExpk+fnm15Pz8/zJo1q0DaR9IEQcDcuXMRHByMqlWrAgC8vb2xZ88eDBo0CAAQEhKCdu3aYcOGDVKPopUrVw7jxo0TJyN7+fIlDh06hBo1ahR+Q4jyQUNDA9evX8fFixfx5csXaGtro1u3buKorJzyiEoj9rPymzt3Lvbu3Sv2k+Hh4di6dSumTJmCQYMGoVmzZggODkbt2rXRq1cvVKpUqYhrTFS8lStXDu/fvxd/T0VFRcHKygqvXr2Cv78/EhISsHfvXgQFBUEikcDc3ByjRo3KdjuiosDgSgHInENEIpHItR+JRCLuKzQ0FOPGjcOpU6cgCAKSkpIgkUggkUiQlJQENTW1Apm7JCQkBMnJyWjUqFGW+Y8ePUJiYqLU6hmZLC0t83QMS0tLdOjQAfXr10fnzp3h7u4OLy8vqSjz1yZNmoQxY8aIr+Pi4lChQoU8HYtypqCgAA0NDbx9+xZVq1aFIAiIjIxEmTJlAAD3799H+/btsXnzZjRu3FhqWzc3N/GuHABERERk+7khKm5UVFTQtGlTSCQSdO7cGZ07d85THlFpxH5Wfpqamnj79q34OiIiAg4ODuLrqlWromrVqrh48SIePHggNaktEclydXXFvn374OzsjISEBBw/fhz9+/eHvr4+/vrrL7FcbGyseLM3p+2IigKDKwXA0tISysrKcj8iERISgipVqgAA/vvvPyQmJsLFxUXMz5yjRE9PD48fPy6QuyB5DQzdunVLXK73e+zfvx/Xr1/HqVOn8Oeff8LX1xenT59GrVq1ZMqqqanxrvEPNHXqVLRt2xbu7u549uwZFBUV0aFDBwBA8+bNYWRkhHXr1mHdunUAgBUrVkBfXx9Tp06Fu7s7Tp8+jaioKKSmpuZp5BJRcdC/f398+fIF9+7dg4qKivj5zi1v+vTpCA0NBQAMGjQIlpaW8PPzK/T6ExUk9rPymzx5Mvr06YOtW7ciLCwMnz59EvvEzOWWo6OjcfnyZaxYsQKGhoYAgGvXrmHlypW4ffs2lJWV8fLlS/zvf//L8vsQUUl38+ZNLFu2DHfu3IGioiLCwsIwbtw42Nvb4/z587h27RomTpwIIGMloEaNGuH+/ft49eoVnJycUL9+fQBAz549xX0+ePAAaWlpcHNzy3U7osLG4EoB0NLSQvv27bFq1SqMGjVKZrWfvHj69CmOHz+O+fPnA8hYC/7blX5at24NdXV17Nu3r0DqDQDW1tbQ1NTEhQsXULNmzWzzAwMD5QquAED9+vVRv359TJ06FQ0aNMDWrVuxaNEiufZJ+Td69Gi0adMG9+/fh76+PlxcXKCsnHEpWLx4MdLT06XKZ34Br1mzJh49eoQLFy5AV1cXrq6uUFFRKfT6E30PT09PpKWloX///mjcuLH4mc8tr2HDhrCyskLLli0BZAS3iYh69+6NJk2a4O7du9DW1oaLi4vYX2Yut6yuro7169fDzMxM3M7ExAReXl7w8vIS04yMjAq9/kSFoXz58tl+3o8ePSr1f6N69ep4/PgxLly4AAMDA5kR1Jm6desmdVM4r9sRFQYGVwrI8uXL4ezsjObNm2PevHmwt7dHTEwMgoKCsHDhQly4cEFcMSjz0R6JRIL379/j7NmzmDZtGpydnTFs2LBCrbeGhgb+97//YerUqTA0NESTJk3w+PFjbN68GRs3boSGhgamTJmCOXPmwMjICN7e3oiJiUFgYCBiY2Mxc+bMXI9x9epVrFmzBr6+vqhevTpCQkLw4sUL9OvX78c3kLKUOVz5W927d89xOwMDA3GUC1FJkjlXUH7zMoMqRETfqlSpUpajiDOXW87PNkSlUcWKFaVGnXytRYsWaNasmVRa2bJl0bFjxxz3aW9vL5OWl+2ICgODKwXExMQEt2/fxoIFC+Dr64uwsDAYGhrCwcEBCxcuFAMrKioquHHjBvT09KCsrAx9fX3Y2tpi1qxZ6NOnT7ZLNgOAqqpqnlcjUlZWhrq6ep7KzpgxAwYGBpg5cyYiIiJQu3Zt/Pnnn2L+5MmTYWxsjJUrV2LUqFEwNTVF69atMWnSJKm6fT2K4evX9evXx9OnTzFy5Eg8efIE5cuXx6hRozBgwIA81Y+IiIiIiEoPDw+Poq4CUYFTEARBKOpKEOUkLi4Ourq6iI2NhY6OTlFXh3JgMynr5bXp/0hS4vFmrTtuOTeEljLj2z+KeeCxoq7CT4PX6JKP72Hxwr5UPuxniw773oLH63PJoljUFSAiIiIiIiIiKskYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQHBUEQhKKuBFFOuL47lSZxcXEwNTVFREQEP89UKvAaXfLxPaTShP0slSa8PpcsHLlCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRwYXCEiIiIiIiIikgODK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQH5aKuABFRSWYz6VG+yktS4gEAET6dEKdccJdg88BjBbYvIiKiopbf/jXTj+pnM7G/JaLscOQKEREREREREZEcGFwhIiIiIiIiIpIDgytERERERERERHJgcIWIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QkREREREREQkh4Jf/J1+St27d4epqSkWLVqU5WuiorR69Wo8fvwYADB48GDUqFFDpsyzZ8+wcuVKDBw4EDVr1kRaWhrGjRsnU27GjBnQ19f/4XWW14cPH/D3338jJiYGnp6ecHZ2FvOSkpKwY8cOvHz5EnXq1EG7du2gpKSUax4REdHXTp06haNHjwIAPDw80Lp1a6n82NhYbN++HS9evEB6ejrmzJkDbW1tMT8lJQXTpk1Do0aN0LZt20Kte0EJDQ3F3r17IQgCOnToIH7HSExMxKRJk6TKjh07FhUqVMhxOyIquThypQDFxsZi+vTpsLe3h6GhIWrUqIHu3bvj1q1bYpnBgwdDS0sLWlpa0NfXh6WlJdq2bYsdO3ZAIpFI7S+zw6lZsyYMDQ1Rq1Yt/PHHHxAEQebYCQkJ4n6z+xs1atQPa3tiYiKSk5OzfU1UlMqXLw8LCwvs378fL1++lMmXSCQYMmQI9u3bh+fPnwMAFBQUYGFhIf4lJCTgwIED0NXVLeTa519oaChcXV3x7NkzpKamonXr1tiyZYuY7+Ligtu3b0NDQwNTp07FmDFj8pRHRET0NV1dXVhYWCA4OBiXLl2SyouOjoaDgwOOHz8OY2NjWFhYyATrZ8yYgQMHDuDff/8tzGoXmNOnT6N9+/aIjY3F27dv4ejoiKtXrwIAkpOTsXbtWqnvEmpqarluR0QlF0euFJCoqCi4uLigbNmyWLhwIezt7RETE4N79+5h2LBhuHz5MpSUlJCUlAQHBwccO3YMEokEUVFROHPmDMaNG4cdO3bgn3/+gaqqKgBgypQp2LZtG/bs2QMbGxtcu3YN3bt3h4qKiswPnjJlyiAyMlJ8vW7dOkyePBkfPnwQ01RUVArnZBAVMx07dgQA7NixI8v8xYsXo1WrVvj8+bOYpqSkJBWQHDBgAPr27QtFxeIfk9bV1cXly5dhYGAAAKhQoQJ27dqFPn36AAACAgJQqVIlAECtWrUwc+ZMcduc8oiIiL5Wr1491KtXD2FhYTJ5f/zxB+rUqYN9+/Zlue2NGzfw+PFjdOzYEWlpaT+6qj9EtWrVcOvWLTFoIggC9u3bh4YNGwIA1NTUsry5mdt2RFQyFf9fCSXEiBEjkJCQgNOnT8PDwwOGhoaoVq0afHx8cO3aNalIvZKSErS0tKCjo4OqVati0KBBOH/+PM6ePYu//vpLLHf16lW0adMGbm5uMDQ0ROvWrdG4ceNsI9tfj1LJDNB8nZZ5Ac/K+vXrUadOHRgZGaFp06a4ffu2VP66devEETn16tWDv79/vs7PhQsX4ObmhvLly8PBwQGrVq3KcgQOUWELCQnB8ePHMXLkyGzLJCQkYO/evejbt28h1uz7GRoaioEVAHj+/DmqV68uvq5UqRLmzZuHQYMGYf78+fj999/zlEdERJRXZ86cQfv27fHHH39g7ty5+O+//8S8pKQkjB49GqtWrSrCGsqvUqVKUt+vv+1vU1JSMH36dPj5+eHBgwd53o6ISiYGVwpAQkIC9u/fD19fX5QpU+a79lGjRg14eXlh7969YlqHDh1w5swZPH36FABw584dXL9+HR06dCiQemeaP38+/ve//2Hs2LG4d+8epk2bhhUrVoj5CxYswJ9//onFixfjv//+w4wZM+Dr64uDBw/maf9fvnxB69at0apVK9y/fx/bt29HSEgI7t69W6DtIMqv9PR0+Pr6YvXq1TmOSPH390f9+vXFER0lyfHjx3Ho0CFMnz5dKt3MzAxmZmb49OkT7t+/n+c8IiKivIiMjMQff/yB2NhYfPz4EfXr18edO3cAAFOnToWvry+MjY2LuJYFZ9myZUhISBBvxGhoaGD+/PnQ19dHREQEnJ2dERgYmOt2RFRy8bGgAhAaGorU1FRYW1vLtR9ra2upeRHGjh2L8PBwWFlZQVlZGRKJBH5+fvjll1/krPH/SUpKEu9O9+jRAwBgamoKd3d3ABnPi86dOxd79uxB06ZNAQDe3t4YPnw4Vq9ejfbt2+d6jLdv3yI+Ph49e/ZEuXLlUK5cOSxfvjzb8snJyVLztcTFxcnRQqLs7dmzB5GRkeKIsVevXmH9+vXQ1taGm5ubWG7Dhg0YPXp0UVXzux05cgQTJkzAqVOnYGhoKJWX+YhQly5d4ODggFGjRokBppzyiKjkYz9LhcHIyAi//PILxo8fDyDjhsbff/+NcuXKYcOGDejTpw9u3ryJy5cvQyKRYOPGjfjtt9+KuNbfZ8mSJThw4AACAwPFx/C/fSTIysoKa9asQatWrXLcjohKLgZXCkDm4y3yrqihqKgo9ajMzJkzsXv3bpw+fRp2dna4du0aevXqBX19fQwYMECuY2V69OgREhISxMBJVvmfP39Gly5dxPoJgoCUlBSYm5vn6RiVK1dGkyZN0LhxY/Ts2RPu7u5wcXGBsnLWHz8/Pz/MmjXru9tElFe2trYYOHCg+FpNTQ3ly5eHjo6OmPbff//h6dOnaNeuXVFU8bsFBARg6tSpOHnypLgyAQCEhYVBWVlZvFsYExMDDQ0NKCoq5phHRKUH+1kqDA0bNkRCQoL4Oj4+HiYmJihTpozUfF4PHjyARCJBuXLliqCW8ps/fz5OnDiBwMBAaGlpZVsuNjZW6lGgvG5HRCUHgysFoHLlylBSUhIf3/leT58+hYWFBYCMgM3ChQsxe/ZsNGvWDADQtm1bDBw4EL///nuBBVcyVyjKLjCUOcHY2bNnZZaIy+sPLkVFRZw+fRrHjx/HqVOnMGDAAKSnp+PkyZOoWrWqTPlJkyZJTdgbFxcn9eOQKL8CAgJw8eJFvHnzBmvXrsXx48exYMEC2NnZwc7OTizn7++Ptm3bwsHBQUxbv349evbsmeOcRcXNvXv30K1bN7Rr105cDt3MzAzjx49Heno62rZtC2traygqKiIwMBBz5swBgBzziKj0YD9LBeXevXvYvHkzLl68CEVFRYwaNQoDBw5EzZo1MXbsWDRq1AhPnjxBYmIirl69ihs3bkBfX19qREdkZCTS0tLQpk2bomvId9q9ezemTZuGfv36YerUqQAAR0dH9OzZE1euXMGePXsgCAKeP3+OS5cu4cSJE7luR0QlF4MrBUBHRwdeXl5YvXo1RowYIU4mmx9hYWEIDAzElClTxDRBEGT2paqqWqATwVavXh2qqqq4cuVKlhNp1ahRA6qqqrh69SocHR2/+zhKSkrw9vaGt7c3Fi9eDEdHR6xduxZ//vmnTFk1NbUS9UOWir+yZcvCwsICkyZNEtMUFBRkyo0ePRo2NjZSaXXq1IGrq+sPr2NBMjAwkPm/ZWRkBCBjEr3z58/j+PHjSEpKwowZM8QgZ055RFR6sJ+lglKmTBlxmeFMGhoaAIAqVarg3r17OHr0KNTV1bFp0ybo6+vL7KNNmzbizb6SxsrKSryJkSmzv9XW1oaFhQUUFRXh7OyMLVu2oGzZsrluR0QlF4MrBWT58uVo2LAhOnbsiD/++AM2NjaIj49HUFAQFi5ciICAgCxHhyQkJODs2bMYN24crK2txUi+goICWrdujWXLlsHd3R01a9bErVu3sH79enTr1q3A6q2lpYVhw4ZhypQpsLCwgKurK549e4YNGzZg4cKF0NLSwqhRozBjxgxYWFigRYsW+Pz5MwIDAxEZGSk+R5uTmzdvwt/fH76+vrC0tMTz588RFRXFu2RUaJo0aYImTZrkWq5r164yab/++usPqNGPVaFChSyXfsyko6ODLl265DuPiIjoa1WrVs2xvylfvjz69euX4z4aNWpUwLUqPA4ODlKjXb/27ejYvG5HRCUXgysFxNLSErdv38bMmTPRtGlTxMTEQFNTE/b29hg7dqxUYOXixYvQ0tKCRCKBIAiwtbVFv379MGLECDHaDwBr1qzB//73P7i5uSE2NhZly5bFL7/8gvnz5xdo3RcsWAAtLS1069YN0dHRqF69OhYvXizm+/n5oWzZshg2bBjCw8NhYGAAb2/vPD+vXbt2bVy8eBEtWrTA69evoauri169esHX17dA20FERERERERUFBSEgnzGhESpqalZzvqdnJyM1NRUAICysjLU1dXztL+0tLRsJ4DN7vgpKSn5Xho6t+Nk166kpCQoKiqKjzF9+zpTenp6vif+jYuLg66uLmJjY6UmGiUqDmwmPcpXeUlKPN6sdcct54bQysf/6dyYBx4rsH0R5Qev0SUf30MqjvLbv2b6Uf1sJva3VJh4fS5ZOHLlB8luObXvfc45P4GVzON/z5JuuR0nu31+GyTKLmgk74pKRERERERERMUN19ckIiIiIiIiIpIDgytERERERERERHJgcIWIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QkREREREREQkBwVBEISirgRRTri+O5UmcXFxMDU1RUREBD/PVCrwGl3y8T2k0oT9LJUmvD6XLBy5QkREREREREQkBwZXiIiIiIiIiIjkwOAKEREREREREZEcGFwhIiIiIiIiIpIDgytERERERERERHJgcIWIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QkREREREREQkBwZXiIiIiIiIiIjkwOAKEREREREREZEcGFwhIiIiIiIiIpIDgytERERERERERHJgcIWIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QkREREREREQkB+WirgARUXFiM+nRD92/JCUeABDh0wlxysX3EmweeKyoq0BERKXEj+5bv1ZS+lmAfS1RacORK0REREREREREcmBwhYiIiIiIiIhIDgyuEBERERERERHJgcEVIiIiIiIiIiI5MLhCRERERERERCQHBleIiIiIiIiIiOTA4AoRERERERERkRyK9+Lvpdjo0aOhpqaG33//PcdyAwcOhImJCWbNmiVXmR/t2zoUhzpR6fXmzRv8888/UFZWRvv27VG+fHkxLzw8HIcOHUJCQgLq1asHNzc3AMCnT5+wdOlSqf2MGDECBgYGhVn1Eu/YsWO4e/cuJk+eDACIj4/HwoULpcr4+vqiXLlyOW5HRETFT3BwME6fPg0DAwN06NABurq6Yl5ISAgOHz4MfX19dO/eHWXKlAEAbNq0Ca9fv5baT7t27eDg4FCodS9N4uLisGTJErRs2RL16tUT0z99+oSAgACEhYVBSUkJU6dOzVMeERWOn27kyrhx42BhYQELCwtUq1YN9erVQ79+/XD8+PFCrcf79+/x4cOHXMtFRUXh48eP4uvffvsNs2fPzrFMUfi2DsWhTlQ6BQYGonnz5vjvv/9w7tw51KhRA48fPwYAvHjxAra2trhx4waioqLwyy+/YPHixQCyDq5Q/rx48QLjxo3D/PnzxbSsgit52Y6IiIqX1atXY+DAgXj79i327duHWrVqIS4uDgBw584d1KtXD6GhofD394e7uzsEQZDZR1paGubMmQNlZd6/lceYMWOwceNG3LhxQ0x7/fo1bG1tsX//fqSnp0uVzymPiArPT3fl+/DhA4yNjeHv7w+JRIKoqCicOXMGXbt2hbe3N3bs2AFFxeITc1q3bp1UB/Xu3Ttoa2vnWIaoNKtcuTLu3LkDDQ0NAEC3bt2wd+9eTJ06FXfv3oWNjQ22bNkCAKhevTr++ecfjBkzBgCgp6eHmTNnFlHNSzZBEDBkyBAsWLAAXbt2lcrT0tLK9rzmtB0RERUfTZo0wZAhQ8TXZmZmCAkJQb169bBw4UKMHTsWM2bMgEQiQa1atXDixAl4eXmhX79+4jYHDhxA3bp1YWdnVxRNKBWOHz8OBQUFODs7S6VPmzYNbdu2xapVq2S2ySmPiApP8YkiFCJ1dXVYWFjA0tISDRo0wJQpU3D27Fns2bMH69evlyq7f/9+eHh4oEaNGmjVqhVOnTolld+zZ0/Mnj0b06ZNQ4MGDeDk5CTeKc8kkUgwb9481KpVC40aNcL8+fNloso9e/bErFmzMHHiRNSqVQvdu3cHAEydOhXLli0DkDHq5uzZs9i0aZM4+iY0NFSqTKYDBw6gefPmsLa2RpcuXfD06dMcz0lu5XM7D7m5e/cuOnXqBBsbG3h6emLPnj352p4ok7W1tRhYATJGSVWuXBkA4OXlhXLlyqFv374YP348tmzZgokTJ4plExISsHDhQqxduxbh4eGFXveSbOXKlXBzc4ONjY1MXlJSEhYtWoQ1a9bgzZs3ed6OiIiKD2tra1y5cgXTp09H586d4eHhgbp16wIAbt26hebNmwMAFBUV0bRpU9y6dUtmHxs2bMBvv/1WqPUuTT59+oRZs2Zh0aJFMnnHjx9Hx44dsXz5cqxdu1ZqBHxOeURUeH7K4EpW6tatCw8PD+zcuVNMW7t2LUaMGIGBAwdi//796Nq1Kzp27IjTp0+LZSIjIzF79mwoKSlh/fr1GD9+PKZMmYJ9+/aJZebPn49ly5Zh1qxZWL58Oe7evSsTXMjcj4KCAv7++28sWbIEgPTjNRMnTkTDhg3h4+OD8+fP4/z586hYsaLMIzh//fUXevbsCW9vb+zevRudO3fGpEmTsm17buXzch5ykpSUBA8PD1StWhV79+7FlClTcPDgQQQFBeVpe6LsLFmyBIIgiCMikpKSEBUVhcTERKSnp+Pjx4/49OkTgIxRK0OHDkVcXBzOnTuHmjVrZvnFkGQ9e/YMAQEB+N///ieTp6WlhVGjRiEuLg7//vsvbGxscOXKlVy3IyKi4kkikSA2Nhbv3r1DSkoKAODjx4/Q09MTy+jr6+P9+/dS24WHh+PixYviDULKv1GjRmHmzJnQ0dGRSk9LS0NUVBSmTp2KFy9e4PTp07C1tcW7d+9yzCOiwsVnSb5Sq1YtbN++HUDGRWzy5MnYuHEj2rdvDwCoWbMmQkJCsGTJEnh4eIjbeXh4iEPi7ezssGfPHpw8eRI+Pj5ISUnBn3/+iSVLlqBDhw4AgG3btuH8+fMyx2/YsCH8/PyyrZ+hoSE0NDSgo6MDCwuLLMukpKRg6tSpmDlzJkaOHCm2q1OnTt9VPj/nITthYWGIjo7G6NGjYWxsjJo1a6JJkybZPhOanJyM5ORk8XXm875EX1u6dCkOHDiAwMBA8bG4devWoUKFCti1axcAwNPTE2PGjEGrVq1kHgmaOnUq/vrrL2zevLkoql+iTJgwASYmJpgzZw4+ffqElJQUzJw5E+PGjZN5JGju3LlYsWIFnJ2dc92OiIoG+1nKjrOzs/g4SqNGjbB371706tULZcuWFW9WAEBMTIzMxOWbNm1Cx44dZQIDlDc3b97EmTNnYGFhgatXr+LBgweIi4tD1apV4eXlBR0dHYwYMQK//PILgIzRugEBAfD19c0xj4gKD0eufEVZWRmpqakAgEePHiE6OhojR45E1apVUaVKFVhaWmL9+vUyj8x8+1ypsbGxGM1/8eIF4uLi4OrqKuZraGjA0dFR5viZQy/l8ejRI3z69AleXl5S6dnNI5Nb+fych+xUrlwZDg4OaNmyJVasWIEHDx4AAJSUlLIs7+fnB11dXfGvQoUKeToO/Tzmz58vBla+/pGenp4OBQUF8bWCgkKOE7t9XZay16ZNG1SvXj3P5TPPa363I6LCwX6WsvLo0SPx34IgIC0tDSoqKgAyvqOePHkSQMbIlrNnz0p9bxUEAZs3b+YjQXLQ19fP8fw5OTnJpGV+X88pj4gKD0eufOXFixfiF4ykpCQAGVH4KlWqSJX7dvLYrIIEmTOoZ94ZUlVVlcpXV1eX2ebreSS+V2ZwKK/7yq18fs5DdpSUlHD58mXs2bMHp06dwpw5c2Bubo5//vkH5ubmMuUnTZokTkAKZNxR4xc/yrR161ZxpFXmKjX16tVDq1at0LVrVzg6OqJHjx4wNjbGzp07MW7cOADApUuXcPr0aUgkEjx58gTHjx/HmTNnirIpJUafPn3Ef798+RIbNmwQR6tcu3YNx48fhyAIePr0KY4ePSquvpbTdkRUdNjPUlb8/PyQkJCAqlWr4tq1a/jy5QvatGkDABg7dizc3d3x9u1bPHv2DOrq6lI35k6fPg1lZWWpm4mUP1WrVpXqI0NCQuDi4iKe5ylTpqBr1664efMmwsLC8N9//4nTGeSUR0SFhyHN/+/Dhw84evQovL29AQBWVlZQVlbGixcvxMljM/+yCghkx9LSEkpKSuJoDSAj8HL//v3vqqeSklKWS99lqlatGpSVlXHz5s087S+38gV1HjQ0NNC7d2/s2LEDb968QUpKClauXJllWTU1Nejo6Ej9EWWqVKkSJk+ejDJlysjkVa1aFf/99x9cXV1hYmKCgIAAMbiSSVlZGR4eHnj8+HGBjBb72ejp6WHy5Mky6UpKSnB3d8ejR4/QsGHDPG9HRIWP/SxlZdu2bfjtt99gaGiI4cOH4/bt2+LoUEdHR9y4cQOWlpbo2rUrzp8/LzX6UyKRYPny5UVV9VLJx8cH9erVE1+7u7vjzJkzMDExQYsWLRAcHIyyZcvmmkdEheenH7kikUhw/fp1DB8+HMbGxhg7diwAQFdXFwMGDMC0adNgY2ODhg0bIjU1FadPn8bLly+llqrLiZaWFn755RdMnz4d9evXR9myZbF48WKEhoaiSZMm+a6vqalpjo/j6Orqom/fvpgyZQpsbW1hZ2eHqKgorFu3DlOnTs13+YI4D0FBQTh27BiGDBkCPT09xMXF4cuXLzAwMMh3+4maNGmS4/8dU1NTDB48WCbdxcUFLi4uP7BmP4dvgyQNGjRAgwYN8r0dEREVP61atUKrVq2yzLO2toa1tXWWeS1atPiR1fop+fj4yKTZ2dllu8x1TnlEVDh+ypEr165dg4WFBSpWrAgdHR388ssvcHd3x40bN6Cvry+WW7p0KX799Ve0aNEC+vr6MDAwwKpVq/IdFFm8eDH09PRgbGyMsmXL4vjx42jWrNl31X3w4MG4f/8+jIyMxKWYv7V8+XK0bNkS9erVQ9myZWFvbw8rK6ts95lbeXnPQ7Vq1fD582dYWlrC2NgYFhYWcHV1xYgRI/LdfiIiIiIiIqLiRkHI6RmTUujDhw+Ij48HkPF4gJ6eXq6rVqSnpyMqKgpGRkYy84y8e/cOqqqqUkGZ6OhopKWlycyi/vHjR5QpUwbq6ur48OEDFBQUxCF7We0HyFiKWVlZWWqUhyAI+PDhAxISEmBmZoaYmBiZMkDGSkAxMTEoX758ns5NbuVzOg/f1jOrememGxgY5Hm+FiDjWXBdXV3ExsZy6DL9cDaTHuVeSA6SlHi8WeuOW84NoZWP/weFzTzwWFFXgUoIXqNLPr6H9KP96L71ayWlnwXY11LueH0uWYr3FecHMDQ0hKGhYb62UVJSgomJSZZ5WQUisnvc5etnH7+tQ3YBjW8DNEDGShxGRkYwMjLKtgyQMYluXgMreSmf03n4tg7Z1Sm7dCIiIiIiIqKS6qd8LIiIiIiIiIiIqKAwuEJEREREREREJAcGV4iIiIiIiIiI5MDgChERERERERGRHBhcISIiIiIiIiKSA4MrRERERERERERyUBAEQSjqShDlhOu7U2kSFxcHU1NTRERE8PNMpQKv0SUf30MqTdjPUmnC63PJwpErRERERERERERyYHCFiIiIiIiIiEgODK4QEREREREREcmBwRUiIiIiIiIiIjkwuEJEREREREREJAcGV4iIiIiIiIiI5MDgChERERERERGRHBhcISIiIiIiIiKSA4MrRERERERERERyYHCFiIiIiIiIiEgODK4QEREREREREcmBwRUiIiIiIiIiIjkwuEJEREREREREJAcGV4iIiIiIiIiI5MDgChERERERERGRHBhcISIiIiIiIiKSA4MrRERERERERERyUC7qChARAYDNpEdFXYVCIUmJBwBE+HRCnDIvwdkxDzxW1FUgIiq1SnOfy342d+xjiX4MjlwhIiIiIiIiIpIDgytERERERERERHJgcIWIiIiIiIiISA4MrhARERERERERyYHBFSIiIiIiIiIiOTC4QkREREREREQkBwZXiIiIiIiIiIjkkK/F31NTU5Geni6TrqamBgUFBZl0iUQCRcXc4zc5lfv6mMrKylDOw3r1giBkWZ+vJSUl5Xl/+ZVZZxUVFSgpKUnlSSQSpKSkQElJCSoqKgV+7B8tNTUVCgoKP+S8Ucnw+vVrnD17FvHx8bCxsYG7u3uueenp6Th9+jTevXuH+vXro3r16kVVfSqhJBIJTp8+jdevX8PCwgJNmzYV+43du3fj/fv3AICuXbvCyMhIZvvXr1/jn3/+QefOnVG+fPlCrTsR0fd68uQJLl68iMTERNSrVw/16tUDAHz69AmnTp2CgoICPD09oaurK26TUx7Rt16+fIkjR45Ipenp6aFnz54AgMTERBw/fhyfPn1C8+bNYWZmJpaLj4/HqVOnkJKSgmbNmsHQ0LBQ605U3ORr5MqAAQOgqakJPT09qb+rV6+KZSIjI+Hr6wtzc3OoqqrC0NAQnp6eOH78uNS+3r17h+HDh6NSpUpQVVWFrq4u6tSpg0WLFiEuLi7LY2pqasLExAS+vr5SZYCML86DBg2CiYkJ1NXVUbNmTWzcuDHLdty8eRMaGhpwcXHJU7uzCyplZ8CAAdDQ0EDv3r1l8saPHw8NDQ20adMmz/srTjp06IBx48YVdTWoiAQEBMDOzg5Hjx5FSEgI3r59m2vely9f0LhxY6xYsQKnTp1CgwYNsGnTpqJqApVQLVu2xPjx43H9+nWMHDkSHTp0EPNevHiBkJAQTJ48Ga9evZLZVhAEDBgwAFOmTMGLFy8Ks9pERN/tr7/+QoMGDXDmzBmEhITgw4cPAIDLly+jfv362Lt3L9avX49q1arh2bNnueYRZSUhIQEhISHi36ZNm3DgwAEAGYG6WrVqYeXKlThz5gwcHBxw7949AEBwcDCcnJywfft27Ny5E9WqVcPdu3eLsilERS7fww8aN26M8+fPZ5n36tUrODs7w87ODkeOHEGtWrUQFxeHoKAg/Pnnn/D09ISSkpJYztbWFgEBAXBwcEBycjKePXuGHTt2ICAgAH379pU5piAIuH37Nry9vZGWloZ169aJZbZu3YrGjRtj/vz50NbWxu7du9GnTx8YGxvD29tbqp4bNmxAw4YNcf36dTx48AC2trY5trlDhw7w8PDAqFGj8nyeKleujP379yM2Nla8Y5CSkoLt27ejcuXK2W6X3Sie/I4YycuooW/LpKWlQSKRQFVVVapceno60tPToaCgAIlEgvT0dCQlJQGQHbWU23HzMqqIiqeEhAQMHToU/v7+aNmyZZ7z0tPTsW7dOtjY2AAA1q5di3379qFfv36FVncq2ZKSknDy5ElER0dDX18fERERqFixoni9mThxIgDI3HnLtHz5cnh4eCA0NLQwq01E9N3evn2LiRMn4tKlS6hdu7ZUXpkyZXD58mVxlEC3bt2wbds2zJ49O8c8oqzY2Nhg5cqV4mt7e3v0798fALBr1y5UrlwZJ0+eBACsWbMGc+fOxd69e6GiooLTp0+LI1mGDRuG9evXY9WqVYXfCKJiokDnXBk+fDjU1NTwzz//wN7eHoqKitDT00OTJk1w9OhR8RGZr8s5OjpCSUkJmpqaqFWrFhYsWCAVWPmagoICHB0d0aNHDxw7dkwqb9q0aejRowfKli0LVVVV/PrrrzAzM8OtW7ekyn358gX+/v6YMWMGmjdvnu3oFnlZWVnBwcEBf//9t5h26NAhGBgYwNnZWapsUlIShg8fDj09PaioqMDOzk6mfS1btsSAAQPQuXNnGBgYQEdHBwMHDkRaWlq+9iORSODn54eKFStCVVUVtWrVwpkzZwAAO3fuhKmpKVJSUqS26dq1K3r06AFfX1+cOHECq1evFkctPX36FIIgYP78+eJoJUtLS6mLNAD8888/sLGxgZqaGipWrIjZs2cjNTX1+08wFbpr165BW1sb1apVw6ZNm3Dp0qU85Wlra8PGxgbr1q2Dn58fNm/eDF9f36JoApVQ6urqGDt2LAYOHIjFixfD19cXEydOzNNjp0+fPsWhQ4cwZsyYQqgpEVHBOHnyJBwdHaGgoIBNmzbhzp07Yp69vb3U4xcpKSkwNjbONY8oNzdv3sSHDx/QvHlzABm/Lb5+rExPTw+XL18GAFhbW0s9IsTPGtF3BFckEgmSkpLEv8wf4nFxcQgMDMSQIUNkRj587etyampq31XptLQ0qaBCJkEQkJSUhI8fP2Lt2rX49OkT2rdvL1Vmz5490NfXh6enJwYOHIjt27fLBBMKym+//Sb1+MOGDRvw22+/yZSbPHkyjh49ivPnz+Pz58/o0aMH2rVrJzOMc/v27ejUqRMiIyNx6dIl7N27V2r/ednP5MmTsXTpUqxfvx4JCQnYuXMnDh8+DADo3Lkz0tLScOjQIbH8hw8fcPjwYfTr1w/r169Hy5YtMWzYMPH9t7KywrRp07B7924EBgYiOTkZu3btwty5c7F9+3YAwOfPn9GlSxeMGjUKX758wY0bNwAAjx49KoCzTIUlLCwMEokE3bt3x6VLl9CjRw+MGDEi17xMjx8/RnBwMGJjY6Gurl4UTaASTE9PD8+fP8fDhw/x6tWrPM0hIJFIMGTIEKxatUpm/isiouIsLCwM7969w4ABA3Dx4kW0bNkSCxYskCnn7++P58+fo0+fPvnKI8rKhg0b0LdvX7HP7NChA06fPo3hw4dj3rx5WLx4sTjH2ddOnDiBCxcuYPjw4YVdZaJiJd/BlUuXLknNt5I5YeWLFy+Qnp6OatWq5bh9duWSk5PFH+zfjmjIDOjEx8fjzJkz2LFjhzjJ0tcePXoEPT09GBkZYdSoUfjrr79khlJu2LAB/fv3h6KiItq0aQNVVVXxucJMaWlpUgEkiUSSZVpuunTpgpCQEAQHB+P169e4cOECevXqJVUmMTERf/31F+bOnQt7e3toampi4sSJsLOzw/Lly6XKdujQAd26dRNHnHh7e+PKlSt53k9CQgKWLl2K+fPno0WLFlBTU4OdnR2WLl0KANDU1MQvv/wiFbDZsWMHjIyMxAj2txITE7F48WIsXLgQNWvWhEQigYODAwYPHoytW7cCAN6/f4/k5GR4eHhAWVkZxsbGmD59OmrVqpXlPpOTkxEXFyf1R0VPT08Pb9++xenTp7Fp0yZcvnwZf/31FxISEnLMy7Ro0SLs2rULv//+O4YOHVqELaGS5smTJ1i0aBH+/fdfbNy4EefOncPs2bOznF/la1u2bEFSUhJOnz6NlStXIjY2Fvv27cOTJ08KqeZExRP72eJPT08PcXFxuHTpEjZv3oxDhw7h999/lyqze/du/P777zh58iQ0NTXznEeUlS9fvmD37t1STxBYWFjgzp07KF++PFJSUjB16lSZ0SknTpzA6NGjcfLkSejr6xd2tYmKlQKbcyVzHo3cgg7ZlatSpQo+fPiA1NRUtGzZUurZ+cyATlpaGtLT09G+fXuZDgYAatasiaSkJCQmJmLv3r3o378/NDU10alTJwAZd86vXbuGrVu3inOG/Prrr9i4cSO6du0q7mfevHnw8/MTX6empuLUqVOYOnWqmHby5Ek0btw4x7ZqaWmha9eu2LhxI/T19dGyZUuZVSqeP3+OlJSU/9fefcfndP1xAP9ky5AgCRkiC5ElVpCgQsSu2LtmzaL2qLYoRVHUqtYetWLEqD1CEMSInUERkhgRErJknN8fXrk/V54kTzwhEp/36+XVPvd877nn3tz1fJ9zz4W7u7tsep06dbL17LCzs5N9LlWqFB49eqR0PaGhoUhNTUW9evVybPOAAQNQq1YtPHr0COXLl8eaNWvQu3fvHH/1vX37NpKTkxUO0JvVXjs7O7Rr1w516tRBp06d0KhRIzRv3hwGBgYK65w1axamTZuWYxupcFStWhXa2trQ1dUF8PZxH+Dt8ZFb2ePHj2FiYiKNF1SyZEmFPc+IcvL69Wtoa2tLPZ709fWhqamJpKSkXOeztLREtWrVEBoaCuDt/vjgwQPEx8d/9DYTfc54nf38VatWDbq6utKbJY2MjJCeni6NXbdu3TrMnz8fR44cQdmyZWXz5lZGlJOtW7eiZs2a2b5v2NraSt+Bhg4disaNG0tlu3fvxoQJE3Do0CFYW1t/0vYSfY4K7H26dnZ20NTUlG5i84oLCwuTTc9KEnTs2FFKfGTJSuhkZmZi9+7d6NatG7Zt24Zu3bopXIauri569eoFf39/rFy5UkqurFy5EmpqatLAmlnS0tJw//592NjYAACmTJmCKVOmSOWtW7fO94C2Wfr374+vv/4aenp6Cgd4yhoz4P1kU2ZmZraERm4DwSpTjzIJsOrVq8PNzQ3r1q1Ds2bNcP36dezYsSPH+CwXL17MdWDgnTt34vz58zhy5Ajmzp2LoUOH4ujRowp7r0yaNEk2PkJCQgKsrKzybAN9XLa2tmjRogVat24NHx8f7Nq1C+3bt5d6seVUdvbsWbRv3x4tWrRAamoqVq9ezTdOUb64urrC1NQUbdq0QaNGjXDo0CFUrFgRlStXBvA22R0eHo5Xr15h27ZtuHjxIgYPHoxmzZqhWbNmUj0HDx7EmDFjsiWhib40vM5+/urVqwczMzN07NgRtWvXxoYNG9C/f3+oqalhz549GDBgACZNmoRt27YBeDsoaaNGjXItI8rNypUrFfYsXrJkCTIzM3HhwgUcOnQIwcHBAIDAwEB06tQJI0eOlIYYsLOzQ8uWLT9pu4k+JwU2oK2BgQHatm2LZcuW5fprooGBAXx9fbFs2TIkJyfnaxnq6upo164dxo8fj+HDh+f562NycrKUWEhLS8P69euxadMm2eM9KSkpaNiwIdasWZOvtijLw8MD5cuXh7q6era3qABvT0K6uro4d+6cbHpQUFC2JFBulKnH0dERenp6OHnyZK51DRgwAGvWrMGqVavw1VdfoWLFilKZlpaW7LXUWXXu378/zzbWqVMHP/74I86fPw87OzvpsaH36ejowNDQUPaPPg/r1q1Dx44d8fTpUwwaNAhbtmzJs8zT0xOrVq1CZmYmtLS0sH37dg4uSvmipaWFs2fPonnz5njy5AnatWuHgIAA6fweFRWF0NBQdOvWDUlJSdmS91m++eYbDrZHBF5ni4oDBw6gfv36iI2NxZQpUzB//nwAb39EHDhwIJ4/fy69PjcmJibPMqKcJCYmombNmmjfvn22stDQUNy5cweurq64du2a9GO0pqYmBg4ciKSkJGlfi4qK+sQtJ/q8FFjPFeDt6y49PT3RtGlT/Prrr6hWrRpevHiBkJAQzJs3DydPnoSGhgYWLVqEevXqwdPTE7/++ivc3Nygq6uLsLAwhIeH59mtbPz48fj7778xe/Zs6fGdr7/+Gt9//z3c3NyQnJyMf/75B4cPH5Z6Xezduxfx8fEKExxt27bFvHnzMGXKFKXePpFfISEhOZbp6Ohg1KhRmDx5MmxtbVG5cmUsXrwYERERUhZYGcrUo6uri/Hjx+PHH3+EiYkJvLy8EBYWJiVSsnTv3h1jx47FypUrs71NydbWFufOnUNsbCwMDAxQokQJTJ48GdOnT4epqSlatWqFFy9eYP/+/YiPj8fUqVMRFBSE5cuXY+jQoXBwcEBoaCju3bvHV/EWQdra2hg4cGC+yxwdHWW9wYjyy9DQMMeB8vr27ZvjW+bexX2QiIoSAwMDhb2mfXx84OPjo3Ce3MqIcqKvr59trMcs778BNIuHhwc8PDw+ZrOIipx8JVe0tLRyfROQubk5Ll26hDlz5mDo0KF49OgRTExMUL16dcybN0/6ldHCwgKXL1/GvHnzMHHiRERGRkJfXx82Njbo2rUrBg0alOsyDQwMMHXqVPzwww8YMWIEzM3N8fPPP2PGjBk4f/48tLS04OzsjIMHD0oXmI0bN+Y4zkfbtm0xYcIEHDt2TOEFSVtbWxovoiC2k7a2tqx82rRpUFNTQ69evfDixQtUrVoVhw8fRoUKFWTzZD13m9NylKlnypQpKFOmDKZOnYro6Gi4ublh7ty5snqNjIzQoUMH7N69Gx07dpSVjRw5Ev369YODgwMSExNx7do1/PDDDzAzM8OSJUswcuRIWFhYoHXr1pg0aRKAtz1WIiIi8P333yM8PBzlypXDyJEjMWDAAKW3KREREREREdHnSk0IIQq7EfT58fb2RsWKFfHXX38VdlOQkJAAIyMjxMfHs+tyMeY86ct4NXfmm9d4+FcjXPT0gEE+krZfmvL7DxR2E0hJPEcXffwbfnmK8zWX19m88RpbdPD8XLTwjEMyqampOHbsGAICArB48eLCbg4RERERERHRZ4/JFZJxdnbGq1evsGDBAjg5ORV2c4iIiIiIiIg+e0yukMydO3cKuwlERERERERERUrBvxqHiIiIiIiIiOgLwuQKEREREREREZEKmFwhIiIiIiIiIlIBkytERERERERERCpQE0KIwm4EUW74fncqThISEmBhYYHo6Gjuz1Qs8Bxd9PFvSMUJr7NUnPD8XLSw5woRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQo0C7sBRERfkjrTwgAA0R07IEFTfgouv/9AYTSJiIioyHOedBsAkPnmNQDF19ksvN4S0cfAnitERERERERERCpgcoWIiIiIiIiISAVMrhARERERERERqYDJFSIiIiIiIiIiFTC5QkRERERERESkAiZXiIiIiIiIiIhUwOQKEREREREREZEKFL/8nT7YP//8g/Pnz2PRokWF3RQi+gi2bNki/X+XLl2gpqYmK4+Li8OZM2eQmJiIypUro0aNGiotLyYmBufPn0dKSgrc3Nzg6OgIAMjIyMC5c+fw+vVr1KlTB6VKlVJpOURERIXt4cOHCAkJgZ2dHZydnbOVJyUlYc+ePfDw8IC1tXWBLTc1NVW6dteoUQOWlpay8ujoaFy4cAEpKSmoXr06HBwcCmzZRFR8FMmeK4cPH0aTJk0wYMCAbGU3btxAkyZN0LJly0JoGXDv3j1cuHChUJb9Kfz444/4888/C7sZRIXG398ffn5+6NatGzIyMmRl+/btg729PRYsWAB/f39cvXpVpWWtXr0ajo6O+PPPP+Hv74+IiAgAbxMu9erVw48//ojffvsNtra2OHfunErLIiIiKkwzZ86Et7c3Vq5cCR8fHwwcODBbzKRJkzBkyBAEBgYW2HKfPHkCBwcHTJ48GX///TecnJzg5+cnla9YsQJOTk5Yvny57FpMRPS+ItlzJTo6GgEBAQgKCsLo0aOlX3IBYPny5QgODkZqamohtrD4CgkJwevXrwu7GUSFZsuWLXj58iV27twpm56UlIQBAwZg7dq18PX1VXk5jx8/xsiRI3H06FHUrl1bVpacnIy1a9eiSpUqAIBRo0Zh06ZNqFu3rsrLJSIiKgw1atTApEmToKamhgcPHsDOzg7Lli2DpubbrysnT55EbGws6tSpU6DLDQgIgKWlJc6cOQMAWLRoETZt2oROnTohOjoao0ePRkBAAGrWrFmgyyWi4qdIJlcAQFNTEx06dMCqVaswb948AEBKSgo2bdqErl27Yt26dbL4mJgYLFq0CDdu3EDZsmXRqVMnNG/eXBZz7tw5LF26FCkpKahduzYqV66MnTt3SnUFBARgxowZAAB9fX04OTlh5MiRKFeuXI7tTElJwYgRI1C6dGnMmjULixcvxt69ewEAxsbGqFu3Lr777jtoa2tL84wfPx6VK1cGAOzfvx92dnaoV68etm3bhs2bN8vqnz9/Pp48eYLffvsNAHDw4EH8888/iIuLQ9WqVTFq1CiULVtWNs+VK1ewYsUKPHz4EK6urhg3bhxKly6NXbt25boMExMTnD9/HteuXcONGzcAAGvWrIGVlRUuXbqEFStW4NGjR7Czs8PQoUOlL34A8OjRIyxevBihoaGwsLBAv3794O7unuN2IypqTp06BSMjI7i7u2PPnj1wcHBQqdvwvn37ULt2bZiYmGDv3r2oWrWq1AXazs4OKSkp2LJlC54/f44TJ05g8eLFBbUqREREn1zz5s0RFBSEO3fu4NChQ+jdu7eUWHn9+jUmTpyIffv2oUePHgW63EaNGuG3337DnDlzYGxsjM2bN2PChAkAgD179qBevXooVaoU9u7dCzc3N1SoUKFAl09ExUeRfCwoS//+/bFhwwakpaUBAHbs2IHy5ctn+9J+//591KhRA/Hx8ejfvz9q1qyJ3r17yx5vuXLlCho2bIiSJUuiW7duuHnzJnr27CllsQHA0dEREydOxMSJE9GnTx/cu3cPNWvWzLEnR0JCApo3b46IiAhMnjwZ6urqaNasmVRHmzZtsHHjRnTu3Fk23+XLlzFq1CgcPnwYvXr1Qrdu3VC7dm34+fnJuv6npaVh1qxZsLe3BwBs2LABvr6+cHBwQJ8+fRAcHIzatWvL2rdr1y7UrVsXGhoa6Nu3L0qWLImePXsCQJ7LaNWqFezt7eHu7i6tg7GxMfbu3YumTZuiQoUKGDhwoPQFMyQkBACQnp6Or776Cg8ePJC2/6hRo3D79m2l/9ZEn7sHDx5AXV0dzZs3x8qVK+Hp6YnZs2erVN+LFy/g6+uLv//+G25ubli7dq1UnpqaCn9/f2zZsgUlSpSAhYVFAawFERFR4QkODsaOHTtw7tw5WU+R8ePHY/z48TA2Ni7wZZYsWRIuLi7YunUrduzYgdTUVNja2gJ4ey2OjY1F27Zt8ffff8PV1RUbN24s8DYQUTEhiqA1a9YIHR0dIYQQFStWFDt37hRCCOHl5SUWLlwoVqxYIZULIUT37t1F7969ZXVs27ZNGBsbS5/bt28v2rRpI4tp0KCBsLe3z7EdmZmZwtHRUaxatUqaNn36dFGnTh3x5MkTUb16deHr6ytSUlJyrCMmJkYAEHfv3pWmeXt7i6pVq4rMzExZbKtWrcSAAQOkz9u3bxd6enoiPj5epKenCzMzM/Hrr79K5SkpKcLc3FzMnDlTCCFERkaGsLCwEBMmTJDVm5CQoNQyssq///57qTwjI0OUL19erFmzRlbn0KFDRYcOHYQQQkRERAgA4unTp1J5enq6SExMVLhNUlJSRHx8vPTv4cOHAoDUBqLC9uLFCwFApKWlSdM2bdok9PX1xfPnz4UQQly7dk1oa2uLN2/eyOatMvqC0NfXF7d9moiHLZrL/r1rzpw5onz58iI5OVkIIcT+/fuFlZWVwvb88ssvom3btgW5ikRKi4+P5zm6iOF1lj53jx8/Fvr6+uLevXvi3LlzokqVKmLz5s1i8+bNws3NTXz33Xfi+vXrsnmcJt4SThNv5XqdVXS9XbBggWjVqpX0ed26daJu3bpCCCFmzpwprK2tRWpqqhBCiD179ghbW9uPvPZE/8drbNFSpHuuAEDfvn2xevVq3L17F0FBQVIvjHcdO3YMwcHBaN68OZo1a4amTZtiwYIFeP78OZ48eQIAuHDhQrbHhN7/LITAjh070LdvXzRv3hw+Pj549uwZ7ty5I4t79uwZ6tevDzc3N+zYsQM6OjpSWWJiIhYtWoTu3bujadOm6NmzJzQ0NLLV0aBBg2xvIfn222+xdetWJCUlAXg72GWHDh1gaGiIyMhIPH78GK1bt5bidXR00LRpU5w/fx4AcPv2bURHR2frKVOyZEmllqFIeHg4Hj16hFWrVsm27/Hjx3Hz5k0AgJWVFaysrNC/f38cOHAACQkJ0NDQgJ6ensI6Z82aBSMjI+mflZWVwjiiz4mLiwv09fVRunRpAG/3+7S0tA8e/8nFxQUmJiYoUaKEVF9WL7Tnz5/LYitUqIBXr16p0Hoi+pLwOkufm8zMTLx8+VL6nHX9e/36NTIzM+Hm5gZ/f3/4+/vjyZMnuHTpEkJDQwtk2bGxsbJjoEKFCnj27BmAt9diU1NT6fH9d6/FRETvK7JjrmTp06cPfvnlF0yfPh1t2rRR2F0wISEB3bt3V/gGISMjIwBAfHy8LMkAIFtCYcaMGVi2bBnGjRuHdu3aQU9PD5MmTZISEVnS0tLw+vVrlCpVChoaGrKyNm3aICEhAYMHD4aFhQW0tLRw6tSpbHUYGBhka2vr1q2hr6+P7du3o0mTJjh06BCOHj0KANIF6f02GxkZ4f79+wDeJnYA5PrK1tyWoUhCQgKAt0mZ919bp6urC+Btkuf8+fNYtmwZpk2bhmvXrqFVq1ZYuXKltP3fNWnSJIwePVq2DN740edi//79ePz4MQBg27ZtKFu2LJo0aQJXV1e4urqiZ8+eaNKkCTZt2oQ2bdooPJaV0axZM4wdOxbDhg1D9erVsXz5cnTv3h0AsHv3bhw8eBA+Pj6IjY3FwoUL8fvvvxfYOhJR8cbrLH1uMjIy0KRJE3Ts2BEmJibYsWMH7O3t4ejoCA0NDXh4eEixzZs3R8+ePdGxY8cCWXbr1q3h4+MDS0tLlC1bFn/88QfatWsHAGjZsiXGjRuHESNGwM3NDcuWLZOuxURE7yvyyRULCws0adIE69atw8GDBxXG2NraIjk5GU2aNMmxHhsbm2y9R97/vGXLFvz0008YOnSoNG3IkCEK27Rq1So0atQIampqmD9/PoC3PVqyenQ4OTkBeDvQa9aYMXnR1NRE7969sXr1akRFRcHGxgYNGzaU1hF425PExsZGmicsLEwqy/rvrVu3YGdnl+9lAIC6uryzU9aySpQokev2NTc3x/Tp0zF9+nTExMTA09MTCxcuxJQpU7LF6ujoyHr7EH1Ojh07hqioKHTp0gV79uxBpUqVpH1/586d+OOPP3Dq1Cm0atUKgwcP/uDlqKur4/jx4/jjjz9w9uxZDBw4EP369QMA9OvXD2ZmZtizZw/09PSwfft2NGjQoEDWj4iKP15n6XOjpaWFffv2YdmyZTh//jxatmyJfv36ZfuREgC8vLxk97qqqlu3Lg4fPowtW7bgwYMHGDNmDHr37g0A0NDQQEBAgHQtHjp0KPr06VNgyyai4qXIJ1cAYOnSpRg1ahQaNWqksHzw4MEYN24cunbtKiUKXrx4gU2bNuG7774DAPTo0QNLlizBoEGDYG5ujnv37mHjxo2yXh76+voICwuTPv/555/ZEjBZnJ2dcfz4cTRu3Bhqamr4/fffoaurC3V1dYSFhcHJyQnp6emYOHFivtb122+/xZw5cxAWFoZhw4ZJjw6VKlUKvr6+mDVrFho0aABdXV2cOnUKR44cwbFjxwAApqam8PX1xZQpU1CnTh2YmpoiPT0dmzZtQq9evfJcRlYdWb/aA0DZsmXRvn17/Pzzz/Dw8JBGUA8LC8P169fRsWNHhIaG4vr16+jUqROAt109DQwMIITI17oTfQ5y6yFiaGiIn376qcCWVa5cOcycOVNhWcuWLRX2xiMiIiqKzMzM8Msvv+QZl997Z2V4eHjIese8y8zMDLNmzSrwZRJR8VPkx1wBAGtra3h7e2frVZFl2LBhGDt2LFq0aAEXFxdUr14dLi4u0uvdAGDEiBFwdHSEg4MD6tSpA09PT9StW1cWM2PGDKxduxZVq1aFs7MzFixYAFdX1xzb5eLiguPHj2PDhg0YO3YsDAwMMH36dHTt2hUeHh6wtrbGixcvpDEVlGFvb4+GDRvi6dOnUlY9y5IlSxAfHw8bGxvUqlULzZs3x88//wwvLy8pZtWqVTAxMYGdnR3q1KmDChUq4OnTp0ovo2fPnti3bx/q1q2LJk2a4OHDh1i1ahWcnZ1RpUoV1K5dG5UqVULHjh2lV0CbmprCz88P5cqVQ/369WFtbQ1DQ0MMHz5c6fUmIiIiIiIi+lypiSLYfSAmJgahoaE59lSJjo5GWFhYtvKEhATcuHEDBgYGqFKlijQ41btu3LiBlJQUODk5Yfr06Th79ixOnjwplcfHx+PmzZvQ19eHi4sLbty4AV1dXVSuXBnA29c+P3v2TPY66AcPHiAiIgJ169aFgYEBoqKi8N9//8Hc3BwVK1ZEQEAAnJ2dYWpqCuDta6FLliyJihUrKly/3r174+nTpzhw4EC2MiEEbt68iRcvXsDR0REmJiYK67h37x6io6Ph5OQkDcCp7DLi4uIQFhaGxMREeHp6SgPTRkdH4+7du7CwsICdnV22AXmfPXuGiIgIlCtXTnp9tDISEhJgZGSE+Pj4HAfWJSoqHMcE4+FfjXDR0wMGmvLOg+X3Zz/eiD53PEcXffwbUnHgPOk2ACDzzescr7NZeL2looLn56KlSD4WZG5uDnNz8xzLLSwsYGFhkW26oaEhPD09Fc6TkpKCQ4cOwdfXF8Db5MPq1atlA74BbweIfbcONzc3WbmNjU2250Ctra1hbW0tfba0tJQN/vpuzxIAqF69eo7r9vjxY/j5+cHPz09huZqaGlxcXHKcP4utra00Bkt+l1GmTBmFXSdz2u5ZTE1NpQQSERERERERUXFRLB4LKghaWlpYv3497Ozs4O7uDicnJzRv3hwjR44s7KZJunXrhho1asDLy+ujjbXwKZZBREREREREVJwUyZ4rH4OGhgZ27NiBqKgoREZGwt7eXhoz5HPx3XffYfTo0ahZs2a2R26K0jKIiIiIiIiIihMmV97z/iM7n5P69esXi2UQERERERERFSd8LIiIiIiIiIiISAVMrhARERERERERqYDJFSIiIiIiIiIiFagJIURhN4IoN3y/OxUnCQkJsLCwQHR0NPdnKhZ4ji76+Dek4oTXWSpOeH4uWthzhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBZqF3QAios+B86Tbn2Q5mW9eAwCiO3ZAgmbhnoLL7z9QqMsnIqLi71NdX7N8TtdZgNdaoi8Je64QEREREREREamAyRUiIiIiIiIiIhUwuUJEREREREREpAImV4iIiIiIiIiIVMDkChERERERERGRCphcISIiIiIiIiJSAZMrREREREREREQqKPyXv1Ox8Pvvv6NMmTLo27evws9EBSU1NRVXr15F6dKlUalSJVnZmzdvcPnyZRgZGcHR0VHpMnorMzMTN27cAAC4uLhAXf1t/j0iIgIPHjyQxVpaWmbbjtevX0dKSgrc3d0/TYOJiKjAPHnyBP/99x8cHBxQpkwZWdmDBw/w9OlTODs7Q09PT+kyUuz169e4ceMGLC0tYWVlJSuLjY1FeHg4Spcune06m1VmY2MDCwuLT9lkIlICe64UEX/++Se6du2KI0eOyKaHhYWha9euiI+Pl+J++eUXWcyLFy8wYMAATJ8+HUKIj9K+wMBAXLp0KcfPRAXh+PHjcHJywvfff4+GDRuiRYsWePPmDQDg8ePHcHZ2Rv/+/dGoUSP0799fmi+3MnorIiIC7u7u6Nu3Lzp06ABnZ2dER0cDAE6cOIHZs2dL/zp16oSdO3fK5r979y6aNGmC4cOHF0bziYhIBWPHjoW7uzvGjBkDW1tbrFixAgCQkJCADh06oGHDhhg0aBBsbW0RFBSUZxnl7J9//oGjoyPGjBmDatWqYeDAgVLZqlWrYG9vj/Hjx6NZs2bw9vaW7nNWr16NSpUqYezYsahatSqWLVtWWKtARDlgcqWIOH/+PLZu3Yrhw4cjIyNDmv7s2TNs3boVycnJUtzx48el8piYGHz11Ve4ceMGvvvuO6ipqX3ythMVlKSkJAQHByMoKAj37t3D1atXpSTevHnzUKdOHdy8eROhoaE4dOgQLl68mGcZvfX8+XNs3rwZly5dQkREBKysrLBjxw4AwMCBA3H06FEcPXoU/v7+EEKgd+/e0ryZmZkYMmQIxo4dW1jNJyIiFbi5ueHBgwc4e/YsNmzYgHnz5gEA4uPj0bNnT9y/fx+XL1/GsGHD8NNPP+VZRjnT0dFBeHg4zpw5g7CwMKxatQrPnj0DACxduhRr1qzB6dOncefOHYSGhiIkJAQZGRkYMWIEDh06hLNnz+LKlSuYOnWq9OMqEX0e+FhQEVK7dm2Eh4dj1apVsix3Tu7cuYOmTZuicuXK2LFjB/T19XOM/e+//7B27Vo8fPgQrq6uGDJkCHR1dWV1rV27Fo8ePYKdnR369+8PS0tLpdv+4sULrFy5EqGhobCwsMA333yDypUrKz0/EQC0bt0aDx8+xMWLF3Hz5k2ULl0azs7OAIBjx45h9uzZAIBSpUrh66+/xuHDh1GrVq1cy+itunXrIj4+HkePHkVUVBQiIyPh5eWVLW7z5s3w9PRE+fLlpWl//PEHfHx8+LgVEVER9c033+D8+fN49uwZ1q9fj7Zt2wIArKysZI+tWFlZQUdHJ88yylnHjh0RFhaG+/fv49SpU/D09ISxsTEAoEOHDli/fj20tbVx584dmJiYwMnJCYmJiUhMTJTueaysrKChoYGzZ8+iRYsWhbk6RPQO9lwpQkqXLo2JEydi6tSpSEpKyjU2JCQE9evXR506dbB3795cEyvHjh2Di4sLIiIi4OHhgaioKHTq1EkqDwgIQJ06dZCUlISvvvoKMTExcHFxQVhYmFLtzsjIQIMGDXD06FHUq1cP+vr66Nq1KyIiIpRbcaJ3BAcHY+bMmZgzZw7atWuHkiVLAnjbS8vc3FyKMzc3R0xMTJ5l9H8PHz7ErFmzMGXKFLi5ucHGxiZbzMqVK2WPVYWHh2Pv3r0YPXr0J2wpEREVtDVr1mDGjBm4fPmywi/sz549w8yZMzFhwoR8lVF2R44cwa+//opVq1ahe/fu0hhnTZs2RXh4OH799Vf8/vvv6NixIwwMDGBoaIj69eujf//+2Lt3L0aMGIHExETeyxB9ZthzpYj5/vvvsWTJEsyfPx8//vijwpi7d+/Cy8sLPXr0wOLFi6UTtiJCCHz77bfo168flixZIk3P6p4ohJDGaxk6dCgAoF+/fnjz5g2mTp2KzZs359nm+/fv4+bNmzhx4gRMTU0BACNHjpSeIX1famoqUlNTpc8JCQl5LoO+HO3bt0f79u2RlJSEmjVrolatWmjbti0MDAykx+OAt48QGRgYAECuZfR/Li4uOHbsGDIzM9G5c2f89ttvmDFjhlR+48YN3Lt3D23atJGmDRgwAJ06dcKJEydw9epVJCQk4NSpU/jqq68KYxWISAm8zpIiy5cvB/B2fLMOHTrg6dOn0NDQAAA8ffoUzZs3x/Tp07Od33MrI8WGDRuGYcOG4cmTJ3ByckL9+vXh6uqKjh074q+//kLz5s2RnJyMatWqwd3dHc2bN4e/vz9+++03/P3332jZsiUcHR2zDTxMRIWLPVeKmBIlSmDatGmYM2cOYmNjFca8efMGycnJ0NXVzTWxArz91fn+/fvo06ePbHpWEuTOnTu4c+cODhw4gJ49e6JHjx7o3r07rl69imvXrinVZgsLC5iammLs2LEIDg5Geno6SpQoAUNDQ4Xxs2bNgpGRkfTv/VHU6cuVmJgo/b+enh4qVqyIJ0+eAAAcHBxkgyhfvnwZDg4OeZbRW+9uW3V1dbi6ukrbNsuKFSvwzTffQEtLS5pmYmICf39/zJ49G35+foiKisIff/zxydpNRPnH6yy9Kzk5GZmZmdLnatWq4eXLl9KPYFFRUWjcuDEmTpyILl26yObNrYwUe/d6W65cOZQrVw5Pnz5FRkYGoqOj4erqCgDQ1dVFpUqVEBkZCQAwNjbGnDlzsHfvXrRu3RrXr19HjRo1CmUdiEgx9lwpgnr37o358+dj+vTpssd3sjg6OmLcuHHo0KED0tPTsXDhwhzrevnyJQBIz3q+Ly4uDgDg4+ODsmXLyspye9ToXbq6ujhz5gzmz5+Pbt26ITY2Ft26dcPvv/+u8JV9kyZNkj1ikJCQwBs/AgD06tUL9erVQ6VKlXD+/HmcOXNG6nE1aNAgDBgwACVLlsTdu3cREhKCXbt25VlGb02fPh3q6uqoW7cu7t27h0WLFsl6pqWmpuKff/7BqVOnZPNlDXoLAPv27cOMGTNk04jo88PrLL3r4cOHGDZsGHr16gUdHR0sX74crVu3hq6uLmJjY9GwYUM0adIEZcqUwdGjR6GnpwdPT89cyyhnzZs3R48ePWBhYYF///0XSUlJqFOnDjQ0NODt7Y2BAwdi0KBBCA0NRUBAABYsWAAACA0NxaNHj/D06VPMnj0bAwYMQIUKFQp5bYjoXUyuFEEaGhqYOXMmOnXqhJo1ayqMadWqFXbv3o22bdsiIyMDixcvVhiXdVKOiIiAra1ttvKsm60KFSpIg5t9iEqVKuHPP/8EANy+fRs+Pj6wtrbGxIkTs8Xq6OhwQDRSaPXq1Zg7dy5WrlwJGxsbBAUFwdraGgDQpk0bJCQkwM/PD0ZGRjh27JiUAMytjN6aMWMGli5ditWrV8PExAQ7d+5Ew4YNpfKQkBC0a9cOTk5OOdZhamqK2rVrf4rmEpEKeJ2ld1WuXBnTp0/Hn3/+icTERLRq1QqDBw8G8PYxcRsbG9y5c0caGN7S0hKenp65llHONm/ejLlz5+LgwYNwdHTE2bNnpUeVN2/ejPnz52PlypUwNjbGkSNHUKlSJQDAoUOHpHEUBw8ejEGDBhXmahCRAmpCCFHYjaC89enTB48fP8bBgwelaQ0aNEB0dDT+++8/xMTEwMzMDH369MH9+/cREBAA4O1gtW3atEGvXr2wbNkyha9i9vHxQUpKCg4cOAADAwMIIbBv3z58/fXXAIBmzZrhyZMnOHbsmNTDJTo6GlevXpUGPGvbti3Kly8v9SJ49/Pdu3cRGRmJRo0aAXj72lZ3d3e0aNFCNp5DThISEmBkZIT4+PgcHyUiUpXzpNufZDmZb17j4V+NcNHTAwaahZvfLr//QKEun4oHnqOLPv4N6WP6VNfXLJ/TdRbgtZZUw/Nz0cIxV4qwOXPm4L///ss1xtvbG//++y82bNiAQYMGQVEube3atUhOTkbFihXRqlUrODg44Ny5c1L5+vXrYWhoiMqVK6Nly5bw8PBAw4YNFdaliL6+PmbMmAFHR0e0bdsWLi4uSEpKkgbIJSIiIiIiIirKCj+dS0oZMmQIUlJSZNM8PDywb98+vHr1CqVKlZLi3h0oCwC8vLwQFBSEmzdv4vHjx7JX0gJvu3AGBwfj4sWLiI6ORtWqVWWPCJUrVw6nTp3C9evXcefOHVhYWKBatWqyLsVjx46VjZ/y7mczMzMcO3YMoaGhCA8PR7ly5eDu7p7nYLtERERERERERQGTK0VEnTp1FE5v1aqVUnGurq7S6OOKqKmpwd3dPdc25FZH/fr1c/0MAFWqVEGVKlVyXQYRERERERFRUcOuA0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFSgJoQQhd0IotwkJCTAyMgI8fHxMDQ0LOzmEKkkISEBFhYWiI6O5v5MxQLP0UUf/4ZUnPA6S8UJz89FC3uuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKtAs7AYQ5UUIAQBISEgo5JYQqS4hIQFCCO7PVGxk7ctZ52oqenidpeKE11kqTniNLVqYXKHP3qtXrwAAVlZWhdwSooLD/ZmKm1evXsHIyKiwm0EfgNdZKo64P1Nxwmts0aAmmAajz1xmZibCwsLg5OSEhw8fwtDQsLCbVGwlJCTAysqK2/kj4jb+NLidP76sbRwZGQk1NTVYWFhAXZ1PGxdFmZmZiI6ORsmSJaGmplbYzclTUTy+i2KbgaLZbrb50ymK7S5qbRZC4NWrV7zGFhHsuUKfPXV1dVhaWgIADA0Ni8SJsKjjdv74uI0/DW7nj8/IyIjbuIhTV1dH+fLlC7sZ+VYUj++i2GagaLabbf50imK7i1Kb2WOl6GD6i4iIiIiIiIhIBUyuEBERERERERGpgMkVKhJ0dHQwZcoU6OjoFHZTijVu54+P2/jT4Hb++LiNqbAUxX2vKLYZKJrtZps/naLY7qLYZio6OKAtEREREREREZEK2HOFiIiIiIiIiEgFTK4QEREREREREamAyRUiIiIiIiIiIhVoFnYD6MuRmZmJiIgIqKmpwdbWFlpaWgrjHj16hMePH6NixYooVarUR40prq5du4bU1FS4u7srLM/IyMDNmzehpqYGZ2dnqKtnz7MWVAz9nxACoaGhSE1NhbOzc47HAP3f3bt3ERMTgzp16uS4vSIiIvDq1Ss4OTmhRIkSHzWmOIqNjcXDhw9hY2OD0qVLK4xJTk7GrVu3YGRkhIoVK37UGPpyREZGIjIyEjVq1ICenp6sLDQ0FLGxsbJpRkZGcHV1zVbPvXv3EBcXhypVqkBfX1/hspSJUUZqaiouXboEMzMz2NnZKYxJSEhAeHg4ypYtiwoVKnzUmPx69uwZwsLCsk338PCAhoaGbFpcXBzu3r2L8uXLw9zcXGF9ysR8Sp/Tfcn9+/fx6NEj2bQSJUqgVq1a2WKjoqIQExMDe3v7HM/DysR8qKioKNy7dw9ubm4oWbKkwpgHDx7g2bNncHBw+OgxykhLS8PFixdhYmKCSpUqycpevXqFq1evZpunWrVqMDAwkE17/fo1QkNDYWJiAhsbG4XLUiaGCAAgiD6B2bNnC3Nzc1GlShVha2srzM3Nxc6dO2UxqampokuXLkJXV1c4OjqKEiVKiLlz536UmOLqr7/+Eq6urqJUqVLC0tJSYczly5eFtbW1sLS0FGZmZsLe3l5cv379o8TQ/929e1e4uLgIExMTYW1tLczMzMTJkycLu1mfrQMHDojGjRuLMmXKCAAiJiYmW8yTJ09E3bp1RalSpUTFihVF6dKlxe7duz9KTHF04cIF4eXlJUxMTES1atWErq6u6N27t0hNTZXF7dy5UxgZGYmKFSsKIyMj4enpKZ49e/ZRYujLcOrUKdGqVSthbGwsACi8dnTo0EGYmZmJevXqSf+GDRsmi4mPjxdNmjQRBgYGonLlysLAwECsX78+3zHKeP78uRg3bpywsLAQenp64rvvvlMYt3TpUqGrqyuqVKki9PT0hK+vr0hKSvooMR9iw4YNQktLS7Zd69WrJ169eiWLmzZtmtDR0RFOTk5CR0dH9OnTR6Snp+c75lP63O5LxowZI0qVKiXbzh07dpTFvHnzRnTv3l2UKFFCumedPXt2vmM+1Llz54Svr68wMTERAERQUFC2mMTERNG6dWuhp6cn7Y9//fXXR4lRRnx8vPjhhx9E+fLlhYGBgejdu3e2mKCgIAFAeHh4yLZ/aGioLG7NmjVCX19fODg4CH19fdGsWbNsx4IyMURZmFyhT2Ly5Mni6dOn0udZs2YJHR0d8eDBA2na1KlThZmZmYiMjBRCCLF//36hpqYm+wJaUDHF1bhx48TVq1fFrFmzFCZX3rx5I+zs7KQLUWZmpujUqZOoUqWKyMjIKNAYkvPw8BBNmzYVaWlpQgghvv/+e1G2bFleoHMwd+5cceTIEXH48OEckytt27YVtWrVEomJiUKIt+cVPT09WWxBxRRH//zzjwgICJA+3717V5iamoqffvpJmvbw4UOhq6sr5s+fL4QQ4tWrV8LNzU106tSpwGPoy7F06VKxd+9ecenSpVyTK4MGDcq1nm+//VY4ODiIuLg4IYQQK1asEJqamiIsLCxfMcq4du2amD17tnj69KmoU6eOwuRKcHCwUFNTk348iomJEeXLlxfjxo0r8JgPtWHDBlGuXLlcY/bt2yc0NTXFqVOnhBBChIeHi1KlSonff/89XzGf0ud4XzJmzBjRrFmzXGNmzJghypYtK+7fvy+EEOLw4cNCTU1NHDt2LF8xH2rFihVi586d4vbt2zkmV0aOHClsbGzEkydPhBBCbN68WaipqYkrV64UeIwywsPDxYwZM0RMTIzw9vbONbmS2z3WzZs3hYaGhpRsjY2NFfb29mLIkCH5iiF6F5MrVChevnwpAIgdO3ZI0ypUqCAmTpwoi6tVq5bspFlQMcVdTsmVrC+qd+7ckaaFhIQIACIwMLBAY+j/bt26JQDIvsg+ffpUaGhoiM2bNxdiyz5/R44cUZhcefbsmVBXVxdbtmyRpiUnJ4uSJUuKBQsWFGjMl6Rnz56iUaNG0uc5c+aI0qVLS0lBIYRYu3at0NTUFC9evCjQGPryXLlyJdfkyjfffCOCg4PF/fv3RWZmpqw8JSVF6OnpiSVLlkjTMjMzhYWFhZg8ebLSMR8ip+TK0KFDhYuLi2za1KlThYmJidT+gor5UBs2bBBly5YVN27cEDdu3BApKSnZYtq3by+aNGkimzZ48GDh7Oycr5hP6XO8LxkzZoxo1KiRuHz5soiIiFDYq8fOzk6MHTtWNq1u3bqiR48e+YpRVUREhMLkSkZGhihdunS2njKVKlUS33//fYHGfIi8kiuXL18WV65cEa9fv84WM378eGFjYyObNm/ePGFgYCDevHmjdAzRuzhAAhWK4OBgAJCeuY+Li0NkZCRq1qwpi6tduzauXLlSoDFfsitXrsDIyAj29vbSNDc3N2hra0vbp6Bi6P+ytsm7+6WpqSmsra25vT7QtWvXkJmZKdumJUqUgKurq7RNCyrmS5GZmYnLly/LxkK5cuUKqlatCk3N/w/RVrt2baSnp+P69esFGkP0vq1bt6J///6oUaMGKleujFOnTkllYWFhSEpKkh27ampqqFWrlnTsKhNTkK5cuaLw/iM2NlYae6OgYlTx9OlTtGvXDl9//TXKlCmDefPmKbUet2/fRmpqqtIxn9Lnel9y6tQp9OrVCw0aNED58uWxc+dOqSwhIQH//fdfrvesysR8TPfv38eLFy+yLd/d3V1afkHFfAy+vr7o2rUrypQpg9GjRyMjI0Mqy2kffv36Ne7cuaN0DNG7mFyhT+7FixcYMmQI2rRpg6pVqwJ4mxQBAGNjY1mssbGxVFZQMV+yuLi4bNsGyL4NCyKG/i8uLg7a2trZBlHj9vpwPGcUvF9++QX379/HmDFjpGmKjvWsz7mdDz4khuhdnTt3xpMnT3D16lXExMTAy8sL7dq1w5MnTwB8nsd3UThe7O3tce3aNYSHh+O///7D+vXrMX78ePj5+eW5HpmZmXj58qXSMZ/S53hf0rBhQzx8+BDXr19HVFQUBg8ejG7duuHmzZsAPs99+H1F9VpbpkwZHD9+HJGRkQgNDcXJkyfx999/Y86cOVJMYR+LVDwxuUKf1OvXr9GqVSsYGRlh/fr10vSst4CkpKTI4pOTk6GtrV2gMV8yLS2tbNsGyL4NCyKG/k9LSwtpaWmyX0wAbi9V8JxRsJYvX45Zs2Zh8+bNcHBwkKYrOtaTk5MBINfzwYfEEL2rc+fO0pv+tLW1sXDhQsTHx+Pw4cMAPs/juygcLx4eHrI3LnXo0AFNmzbFli1bCnw9PqXP8b7k66+/lt6gpK6ujp9//hnGxsZS75XPcR9+X1G91lauXBmNGjWSPtetWxd9+vQp8vs5ff6YXKFP5vXr12jRogVSUlJw+PBhGBkZSWUWFhbQ0tJCVFSUbJ6oqCjp9YMFFfMls7a2RmxsLN68eSNNS0xMRHx8vLR9CiqG/s/a2hpCCMTExEjTsj5ze30Ya2trAMj1WC+omOJuxYoV+P7777Flyxa0adNGVmZtba1w2wCQbcOCiCHKjb6+PgwMDKT95nM8vnPaz9XU1GBlZVWgMQWpXLlysuXltPySJUtKrwBWJuZTKgr3JWpqajA1NZW2m5mZGXR0dHLdP5WJ+ZiK07VW2f0c4LWLPhyTK/RJJCYmomXLlkhMTMTRo0dRpkwZWbmWlhYaNmyIPXv2SNNSUlJw6NAh+Pj4FGjMl8zb2xtpaWk4ePCgNG3Pnj1QV1dH48aNCzSG/q9evXrQ1dWV7ZenT5/G8+fPuV9+IFdXV5QrV062TcPDw3H79m1pmxZUTHG2cuVKDBs2DJs3b0a7du2ylfv4+ODatWt48OCBNG337t2wtLSEo6NjgcYQZUlLS5N9SQaA8+fPIz4+Hi4uLgCA8uXLo0qVKrJj9+nTpwgKCpKOXWViCpKPjw+OHz+OxMREadru3btRt25d6bHQgor5UO/WCby9RwoMDJS2a9byDxw4gPT0dNnymzRpkq+YT+lzvC95f1tHRkYiLCxM2tYaGhpo1KiRbP9MTU3FwYMHpf1TmZiPqVSpUqhVq5Zs+fHx8QgICJCWX1AxBen9bQ8AR44cybafnz59Gi9evJCm7d69W7ovUDaGSKawR9Sl4i89PV14eXkJY2NjsXv3bhEYGCj9i46OluKCgoKEtra2GDNmjNi9e7do0aKFqFChguxNEgUVU1xdv35dBAYGisGDBwtTU1NpOycnJ0sxQ4YMEWZmZmL9+vVizZo1wtjYWIwePVpWT0HF0P/9+uuvomTJkmL58uVi8+bNwtbWVnTu3Lmwm/XZun//vggMDBQLFiwQAKRzx7Nnz6SYVatWCW1tbTF//nyxfft24erqKho2bCh7m0ZBxRRHWa/BHD16tOy8fOnSJSkmIyND1KtXT1SvXl3s2LFDzJ07V2hqaop169YVeAx9OR49eiQCAwPFmjVrBACxfv162T3BkydPhKurq1i0aJE4dOiQWLJkiTAzMxPe3t6y1+ru2rVLaGhoiOnTp4tdu3YJDw8P4ebmJnuLhzIxysjIyJCOEScnJ9G+fXsRGBgoLl++LMW8fv1aVKpUSXh7ewt/f38xadIkoampKY4fP17gMR/q66+/FpMmTRJ79uwR27ZtEw0aNBCmpqayt+w8fvxYmJmZifbt24s9e/aIIUOGCF1dXRESEpKvmE/tc7svcXZ2FnPmzBEHDhwQq1evFpUqVRKurq6yN9dcuHBB6OjoiJEjR4o9e/aIVq1aifLly4vnz5/nK+ZDxcTEiMDAQLFlyxYBQPz1118iMDBQPHz4UIo5fPiw0NTUFD/99JPw9/cXDRs2FA4ODiIpKanAY5SVdSzWqlVLtGjRQgQGBorg4GCpfOjQoeK7774TO3bsELt27RLt27cXurq64vTp01JMSkqKcHFxEfXr1xe7du0SU6dOFRoaGmLv3r35iiF6l5oQQhRyfoeKueTk5Byz0qNHj0b79u2lz+fPn8fixYsRExMDZ2dnTJgwAZaWlrJ5CiqmOBo1apT0JqZ3bd26VVr/jIwM/Pnnn/j333+hpqaGNm3aYODAgVBX/39HtoKKIbkNGzbAz88PqampaNKkCb7//ns+s5uD5cuXY+PGjdmmT5s2Dd7e3tJnf39/rF+/Hq9evUK9evUwbtw46Ovry+YpqJjiZubMmdi/f3+26dbW1vjnn3+kz69evcLcuXMRFBQEQ0ND9O7dO9vjQwUVQ1+GLVu2YMmSJdmmv3tPcP/+fSxZsgQ3btyAiYkJmjRpgl69emW7xhw5cgQrVqxAXFwcatWqhQkTJmR7LEWZmLzkdC9jZ2cnG0Pu6dOnmD17Nq5evYqyZcti6NChaNCggWyegor5EMnJyVi+fDlOnjwJNTU1uLm5YcSIEdl6FD948AC//fYbwsLCUL58eYwcORLVq1fPd8yn9Lndlzx79gyLFy/GxYsXYWhoCE9PTwwaNAg6OjqyuODgYCxatAjR0dFwdHTExIkTUb58+XzHfIjdu3dj7ty52aYPGTIEPXr0kD6fPHkSf/75J549e4Zq1aph4sSJMDU1lc1TUDHKqF+/frZp5ubm0sDMGRkZWLduHQ4ePIjk5GQ4Ojpi+PDh2R6ri4uLw+zZs3Hp0iUYGxtj0KBBsnsMZWOIsjC5QkRERERERESkAv7ETERERERERESkAiZXiIiIiIiIiIhUwOQKEREREREREZEKmFwhIiIiIiIiIlIBkytERERERERERCpgcoWIiIiIiIiISAVMrhARERERERERqYDJFSLK0/79+3H37l3p8549e3Dv3r1CbFHO3m8rZZeWloatW7ciPT093/Mq87ffuXMnHj16pHI9nwtl1qcoio6OxuHDhwu7GUT0jrCwMNlxeePGDRw7dqwQW5Sz99tKip09exbh4eGF3Qz6hPz9/fHixYvCbgYVAiZX6IuRkpKCs2fPYteuXThz5gyePXtW2E0qULt378aDBw8+St2jR4/GkSNHpM9Dhw7FyZMnC6z+gmz7+239XKSnp+PUqVPYvXs3Hj58WCDznD59Glu2bJH9CwgIyLPeRYsWYfPmzdDU1MzvamT72yv62/Xr1w/nzp3LVz2fM2XWpygqVaoU+vTpg4sXLxZ2U6gYCg8Px759+3Dw4EGEhYVBCFHYTSow169fx/Hjxz9K3Xv37sUPP/wgfd6+fTumTJlSYPUXZNvfb+vnJCIiAv7+/jh37hwyMzNVnic6Ojrb9XbLli1ITEzMtc6oqCj4+vpCV1f3g9eFip6TJ09i8uTJhd0MKgT5v7MmKoLmz5+P6dOnw9LSEpUqVUJcXBzu3LkDT09PLFmyBOXKlSvsJqps0KBBmDdvHqytrT/6snx9fWFra1tg9X3KtheG6Oho+Pj4IDk5Gba2tggKCsL06dMxZswYleaZN28ebt26hRo1akjTXF1d4eXllWO9r1+/xowZMz7418b3//Yf+rcr6H2I8k9PTw/Dhg3D5MmTcejQocJuDhUTV65cwbfffov79++jdu3a0NDQwN27d6GhoYFZs2bh66+/Luwmqmzr1q04ffo0Gjdu/NGX5eLiUqD1fcq2F5axY8di+fLl8PT0xI0bN2Bra4sDBw7A0NDwg+e5fPkyevTogU6dOsnm8/b2hr6+fo71Tp8+He3bt4eVlVXBrBwVCePGjYOtra30X/pyMLlCxd6MGTMwc+ZM7Nq1C82aNZOmZ2Zmwt/fH69evZIlV968eYOgoCC8evUKTk5OsLOzk9W3c+dO1K5dG5qamggJCYGhoSHq1q0LdXV5R7C86gGAS5cuISoqCg4ODnBwcMhxHQ4fPoy4uDioqanBwsIC1apVQ8mSJaXygwcPIiUlBefOnYOmpia0tLTQoUOHfNeT5fHjxzh//jwsLS3h5uaWrbxZs2aoUKECAEAIga1bt6Jx48YoW7asFPPvv/+iSpUqsLe3z3V9c2u7Mtswr7a+L+vvp6amhmvXrsHIyAgeHh5QU1PLc96c3L17F9bW1jn2BBkxYgQMDAxw+fJl6OjoYPv27ejcuTOaNm0KV1dXleZp2rQplixZonRbN27cCAsLC7i7uwN4e8OYlJSE+vXrAwCePHmCEydOoEGDBrC0tAQAnDt3DhoaGnB3d5f97fPa7x4/fpzjMfJuPYDyx9X78tpHlN3n09LScP78ebx8+RLu7u4KE665rY8iMTExuHDhgrRvHjlyBA4ODtIxkbXOmZmZuHz5MmxsbFCtWjUAwL1793D16lUYGRnB09MTOjo6Ur2PHj3ChQsX0L59e2lafHw8Dhw4gLZt26JEiRJ4+vQpjh8/js6dO+PmzZv477//4OzsjIoVK8ra+M033+DHH39EREQEKlWqlOv6EOUlPDwcXl5e6NKlC86cOYMSJUrIym7cuJFtntDQUISGhsLc3Bw1atSAlpaWVBYSEoL4+HjUrVsXISEhiIuLg7u7O0xMTPJVD/A2YZ11/NasWTPHngR3795FcHAwAKBkyZJwdnaGjY2NbD1u3bqFp0+fYsuWLQAAT09P2flMmXqypKenIzAwEOnp6dLx/64qVaqgdOnS0ufz589DCIG6detK027fvo2HDx+iadOmua5vXm3Paxvm1db3Zf39ateujStXruD58+do0KABSpUqlee8OUlOTsbz589Rvnx5heUHDx7EggULcPbsWdSpUwcvXrxAzZo1MWXKFCxYsEClebS0tKTtpoyEhARs2LABR48elU0XQiA4OBiPHj2CjY2N7AeShw8fIigoCJ06dZLdl0RGRuLcuXOy6cocO7Vr18bZs2eRkJCAdu3a5djWnOr6mO1xd3fH2bNnlar7XWlpaQgMDERGRgaqVauGuLg4PHjwQNr/c1v3xMREnD17FklJSahVq5Z0n5Ml67r87v519OhRWFhYwMnJCcD/728NDAwQEhKCEiVKoH79+tDQ0JDmsbCwgJeXF/766y/Mnj07x+1OxZAgKsaeP38udHV1xeTJk5WKv3TpkrCyshI1atQQrVu3FsbGxmLo0KGyGCMjI9G8eXNhb28vWrduLczMzISXl5dIT09Xup7k5GTx1VdfiQoVKghfX1/h7OwsOnbsmGO7fvjhB9GlSxfRuXNnUaNGDVGuXDlx5swZqXzs2LGiRIkSom7duqJLly6id+/eH1SPEELs3r1b6OrqCg8PD1GvXj0p7s8//5RiLC0txZo1a4QQQqSlpQkA4sSJE7J67O3tpXlyW9+c2q7M30KZtr7PyMhI+Pj4CEtLS9GiRQthbGwsmjZtKlJTU3OcR5GkpCSxceNG0ahRI6GmpiZev36tMC4hIUFoamqKdevWyaZbW1uLiRMnqjSPr6+v6Nixo9i1a5c4ffq0ePXqVZ7tbtWqlRg2bJj0efny5aJSpUrS54ULFwoA4tdff5WmVatWTcyfP18IIf/b5/S3U+YYebceZed5nzL7iDL7fHBwsKhQoYKwt7cXLVu2FDY2NmLTpk0qtc3Pz0+UKFFCeHh4iPr16yvcN42MjETTpk2FtbW1aNeundi4caMQQogJEyYIPT094ePjIxwcHISVlZW4ceOGrG4jIyPZ8q5fvy4AiJiYGCGEECdOnBAARIsWLYSrq6to3Lix0NHREfPmzcvW1ooVK4oFCxbkuC5EyurevbuwtrYWycnJecampKSIzp07i3LlyonWrVsLFxcX4eTkJO7evSvFjBkzRlSpUkW4uLgIHx8f4e7uLoyMjMT58+fzVc/SpUuFgYGBaNq0qWjUqJFwdHQUISEhCtt15MgR0aVLF9GlSxfRokULYWBgICZMmCCV79+/Xzg5OQlTU1Mp7uzZs/muRwgh4uLiRLVq1YSlpaVo3ry5sLCwEA0bNhQ1a9aUYqZMmSLq1asnfe7du7fo0aOHrJ5Zs2bJ5slpfXNquzLbUJm2vm/MmDHCwcFBVK5cWTRu3FhUrVpVlClTRvb3U1ZwcLAYPHiwMDIyEgsXLswxrkePHqJBgwayab/88oswMTFRaZ69e/cKbW1tcfjwYbF//37x4MGDPNu8a9cuoa+vL7tWvHz5UtSrV0+YmZmJFi1aCBMTE9G0aVORlJQkhBAiOjpaqKuri8DAQFldQ4cOldqo7LHj4OAgHB0dhbe3t+jXr5/CNuZV18dsz9OnT4WWlpY4duyYrO5vv/1WNG7cWGF7nz17JlxcXET58uVFixYthKWlZbb9MKd1DwoKEqampqJq1aqicePGQldXV/z222+y+o2MjISfn59sWp06dcT06dOlz/b29qJx48bCwsJCtGjRQpiZmYm6deuKhIQE2XyzZ88Wzs7OCteDii8mV6hY8/f3FwDExYsX84xNSUkRVlZWYvHixdK0x48fi3LlyslOtEZGRsLDw0O6EMbExAhdXV2xZ88epevx9/cXJiYmIjExUYrZsWOH0us1bdo0Ua1aNdm0cuXKiQ0bNihdh6J6EhMThZmZmewiMmvWLAFApeRKXuv7ftuV2YbKtvV9RkZGwtbWVjx//lwIIURUVJQwNTUVixYtynlDvePSpUti6NCholSpUsLY2FgMHz5cXL58Ocf4CxcuCADi0qVLsumtWrUSrVq1UmkeX19fYWZmJlq1aiWqVKkiTE1Nhb+/f67tNzc3F8uWLZM+h4aGCgDi0aNHQggh2rZtK2rVqiV8fHyEEEK8ePFCqKurS+v4flJE0X6X1zGiqB5l5nmXssfr+97f55OTk4WFhYXo37+/dAOclJQkDh069MFte/36tTA1NZXtm3Pnzs22bxoZGQk3NzdZUiwgIECoq6tLX9bS09NF27ZthaenpxSTn+RKnz59RGZmpjSflpaW7IZXCCHatWsnunfvnuM2I1KWiYmJGDx4sFKxP/zwg/Dw8JBdFwYMGCCaNWsmfR4zZozQ0NAQ586dk6Z17NhRtGnTJl/1mJiYyBKmkZGRIjg4WKl2RkRECD09Pdl9xOTJk0XDhg2Vmj+3ekaNGiVcXFykL2X//fefKFmypMrJldzWV1HbldmGyrT1fWPGjBEAZOfkPn36iGrVqknnpdzExsaKP/74Q1StWlWoq6uLZs2aiS1btoiUlJQc56lataoYMmSIbNquXbtk58cPmWfv3r1CR0dHfPXVV8LLy0toa2vLrhuK/PTTT6JGjRqyaWPHjhWVK1cWcXFxQoi31xNzc3PZDxre3t6y4ygtLU2YmJiIv/76Swih/LEDQBw/fjzH9ilb18dsT8eOHWX7c2JiojA0NBT//POPwvaOGDFCth/ev39fGBoaZkuuvL+stLQ0UaVKFTFgwABpmr+/v1BXVxfXrl2TpimbXDE1NRVRUVFCiLc/5Nra2oqff/5ZNt+///4rAEj3DvRl4IC2VKw9fvwYAGTddRMTE2WDkWV1Uz527BiioqJgYmKC7du3w8/PDydPnoSdnR1OnDghq7dPnz5Sl2IzMzM4ODggLCxM6Xp0dXWRnJwsGz3+3S7+ijx48ACHDh3C1q1boaOjg6tXryI1NTXf2yS3ek6dOoVnz55h9OjRUvzIkSOhra2d7+W8K7/rq8w2VKWt/fv3R5kyZQC87br5zTffYNu2bTnGv3jxAkuWLEH16tVRu3ZtPHjwACtWrEB0dDQWLVqE6tWr5zhvfHw8AEjLy2JsbIyXL1+qNM+wYcMQGRmJffv24datW+jfvz969uyZ64C5sbGxsi7mDg4OMDc3R0BAAIQQCAwMxNSpU3HmzBm8efMGJ0+ehKGhoVKPXL0rt2OkIObJz/Ga2z5/5MgRREdH47fffpO69Orq6sq61+e3badOnUJcXJxs3xw+fLjs0Z4s/fr1g4GBgfR5y5Yt8PLygoeHBwBAQ0MDEydOxNmzZxEZGZnzxsvB2LFjpW7VHTt2hJWVFXbt2iWLKV26NGJjY/NdN9G7MjIyEBsbm+3xmICAAOl6u2fPHmn6mjVrULVqVezfvx9+fn7Ytm0bypYti5MnT8oGE61Rowbq1Kkjffby8pIde8rUo6uri5s3b0pvSLOyskKtWrVyXJekpCScPn0a27dvx8WLF1GuXDlcuHAh39skr3q2bduGwYMHS48q2traZhvT40Pkd32V2YYf2lYbGxt07NhR+jx+/HiEhITk+PaczMxMHDlyBF27doWlpSWWLl2Krl27IjIyEgcPHkSXLl0UnkuzxMfHK7x2Asj1mpvXPPb29ggNDcXJkydx4sQJXLhwAZs3b8b8+fNzbMv711vg7Tl+8ODB0nQzMzP0799f9rhRz5494efnh7S0NADAoUOHkJCQIG1vZY8dV1dXNGrUKMf2KVvXx2zPt99+i507d0r3PX5+flBXV8/xHnH79u2y/dDa2hqdO3fOFvf+sq5evYrQ0FBMmjRJmubr6wsnJyf4+fnluo0U6dGjBywsLAC8vVcbMGBAtvvIrL8xr69fFo65QsVa1peW58+fw9TUFMDbmx1/f38Ab0e6HzduHFxcXHD//n1oa2tLZVkqVKiQbSyC9y/COjo6SElJAQCl6vHx8cHQoUPRsGFDmJubw9vbG4MGDULVqlUVrsfQoUOxfv161K5dG8bGxkhKSoIQArGxsdmeF81NXvVERkbC1NQUenp60jwlSpSAubm50stQJL/rq8w2VKWt7z/3bmtrm+vFtXv37jh48CD69++P/fv352t7ZN0Evn79Wjb99evXsvEIPmSeJk2aSP+vpqaGKVOmYO7cuThx4gR69eqlsG4DA4Nsbzdo2LAhTpw4ARcXF6ipqaFly5YoW7YsLly4gICAAHz11Vd5ji/yvtyOkYKYR9njVZl9vkyZMtKNdEG07eHDh9n2TR0dHYX7zfvTHjx4kG3cmKwxWh48eJDti2teFO3r77/dKTExUeE4NET5oaGhAV1dXTx//lw2/cyZM7h+/Tpu3bqFuLg4tGnTBm/evEFMTAxu376d7Quvr68vUlJSpOMnt2NP2XrWrl2LYcOGYenSpfjqq6/QsWNH9OjRQ+F57ejRo+jatSssLCxgZ2eHEiVK4NWrV3j69Gm+tkde9aSnpyM6OlrhMXr16tV8Let9+VlfZbahtrb2B7dV0TzA2/OZorHmdu3ahY4dO6JSpUo4dOgQGjZsmPcKv0NHR0fhtRNArtfcvOZxdHSUlbu5uaFjx47SfaQi719v09PTERUVpfAc/+55uX379hg6dCgOHjyIr7/+Gv/88w9atWqF0qVL5+vYyeteRdm6PmZ7fHx8ULZsWWzevBmDBw/G6tWr0a1bN4V/q/T0dMTExGTbp2xsbHDlyhXZNEXXVnV19WyD77+/7ZWl7LUVAK+vXxgmV6hYq127NoC3A8BVqVIFAGBqair9QvDuydHQ0BBv3rzB6tWrZV+K8kuZetTU1DBnzhz8+uuvuHjxIjZu3IhatWrh2rVrUjuzXLhwAX///Tfu3Lkjtff06dPYv39/vl5tqUw9WT0jhBCyQcRevHiRY71ZN2vvv7bw3S+e+VlfQLlt+CFtzSnmxYsXCgdIzDJ8+HC8efMGa9asQWhoKPr27YvOnTsrdcHM+mIcGRkpe+vDgwcPZIPYqToP8PYGUVtbO9fXjFeuXBn37t2TTfPy8sLcuXOlNw2pqanBy8sLAQEBCAgIyDFRU5iU2UeU2edLlSqFhIQEpKenf9CrqRUpU6aM9CvcuxTtm+8P1mdiYoK4uDjZtKzPWfuourp6rsfb+8t8900Wivb1e/fuyRJ1RB/K3d09Ww+PrNeRzpgxA8uXLwfwdmDQEiVKoEuXLhg6dOgHL0/Zeho3boxbt27h/v37OHToEMaNG4fbt29j5syZ2WJHjx6N7777DtOmTZOmValSJd+vks6rHk1NTRgZGSm8HuVGmeM/P+ur7Db8kLYqisn6nNM1t27duhgyZAg2bdqEbt264ZtvvkGfPn2yJTdyYm9vn62X34MHD6CtrZ3jILgfMg/w9jqU1/V2/fr10mdNTU2UKlVK4Tn+3e1haGgoJTEaNWqE3bt3Y8OGDQDyd+zkNVC/snV9zPaoq6ujX79+WL16NXx8fBAYGIjff/9d4fxZx8z7SRxlr62ZmZmIj4+X9SaKi4uTvXhB2eurMveR9+7dQ9myZVUawJmKHj4WRMVapUqV0Lp1a0ybNi3PX50aN24MDQ0NrFy5UjY9PT0dT548UXqZytTz+PFjZGZmQktLCx4eHli6dCl0dXVx+fLlbPU9fvwYenp6stf4bd++PVucgYFBrj0DlKmndu3ayMjIkL2W9dixY0hISMixXnV1dZiZmeHOnTvStPDwcERHR8uWndv6vt92Zbbhh7Q1y7u9HYQQ2LVrF+rVq5djfMuWLXHs2DHcuXMHjRo1wtSpU2FmZoZevXrhxIkTud50W1hYwM3NTdYz5s6dO7h8+TJatWolTQsMDERAQIDS8yQnJ2f7An/w4EEkJydLbwJSxNvbG2fOnJFN8/Lywt27d7Fx40bpNc5eXl7YtWsXrl27luurnfPa7z4WZY+zvPb5Ro0aQU1NDZs2bZJNz+2GOS+1a9dGWlqa7HXXJ0+eVJhweV/9+vVx7NgxWayfnx/MzMykG0BLS0u8evVKdl56/1GoLO/u63fv3sXVq1dl+3pSUhJCQkKYXKECMXr0aAQGBub5RhU1NTU0a9YMK1euREZGhqwsKipK6eUpU09GRoZ0rNjY2GDQoEHo0aMHzp07p7DOx48fy3pUXLt2DREREbIYZc57ytRTv3592TGanp4ue3RKEUtLS9n1FoB07QDyXt/3267s3+JD2goA169fx927d6XPO3fuRJkyZRT+sJK1fsuWLUNMTAzmzJmDCxcuwNnZGXXr1sVff/2V53m0ZcuWOHLkiOwL+LZt29C0aVMpgR4VFYUtW7ZIPQuUmScmJka2nJSUFBw4cCDP6+2TJ09k61+/fn3s3LlT+iyEwI4dO6Q39mXp0aMH9uzZgw0bNkBbW1u69hfUsZPfuj5me/r164fLly9j7NixcHV1zfURNk9PT+zevVv6nJmZiX379uW5jKpVq8LQ0FC27R8+fIjz58/Ltv37x1dMTIzCR4D37Nkju/fbuXNntvvIM2fO8Nr6BWLPFSr21q5dC19fXzg6OqJv376oUqUKMjMzcenSJTx//lz6RdvCwgILFizAyJEjcevWLbi7u+Phw4fYsWMH5s6di+bNmyu1PGXqOXXqFGbNmoUOHTrAysoKR48ehba2tsIvsfXq1YOOjg66dOmCli1bIigoCDt27MgWV6tWLaxcuRI6OjrQ09PL9ipmZeqxsrLCiBEj0KNHD0yYMAHq6ur4448/ZL98K9KrVy/8/PPPSElJQUZGBlauXCl7zWVe66uo7Xltww9tK/D22dvOnTujSZMm2LNnDyIjI7F3794857O1tcX06dMxbdo0HDp0CKtWrUKzZs1gaWmJ27dv59jleP78+WjevDl0dXXh6OiIJUuWwNvbG23atJFifvvtN6SkpEjbJK95Xr16hYYNG8LX1xeVK1dGeHg4lixZgj59+uCrr77KcR369++PuXPnIioqSnqkLGvclYsXL2LdunUA3iYd+vTpg1KlSuU63kpe+93Hosxxpsw+b2FhgdmzZ2PgwIEICQmBo6MjTp8+DXNz8w9+fWKFChXw3XffoXv37tK+uXjxYujr6+f5S2K/fv3w119/wcvLCwMHDsS9e/ewcOFCrF27VhpPqFatWnByckKnTp3Qu3dvhIWF5fhldvbs2Xj69CnKli2LhQsXokmTJvD29pbKd+3ahQoVKuSaQCNSlq+vL2bPno2ePXti+/bt8PT0hLGxMSIjI7Fu3TpZsmH+/Plo2LAhPD090bNnTwghcOrUKWhra2dLduYmr3rS0tJQv359NGvWDNWrV0dsbCzWrFmDX3/9VWF9bdu2xQ8//ICXL18iMTERCxYskI2LBLw9BqdOnYo//vgD5cqVU/gqZmXq+eWXX+Dp6YnevXujXr162LZtG16+fAkjI6Mc17dbt26YPXs2hg4dipo1a+Lff//FrVu3pOXntb6K2q7M3+JD2gq87fHSokULDB8+HLGxsfjtt98wb968PHsI6+rqomfPnujZsyfu3r2L1atX45dffsGoUaOwfv162Tgu7/r222+xcuVK+Pj4oG/fvjh9+jSCg4Nx9uxZKSY4OBjdunXDvXv3oK+vr9Q8kydPRlJSEho0aID09HSsWbMGaWlpsp5J77O1tYW3tzc2b96MH3/8EQAwa9YseHh4oFu3bmjcuDH27duH0NBQ/PPPP7J5W7RoAT09PYwfPx7dunWTjTNTUMdOfur6mO0pX748mjVrBn9/fyxcuDDX2GnTpqF+/fro27cvPD09sX37djx//jzPnsSlSpXC9OnTMXz4cOmx8sWLF6NBgwayV1T36tULM2fOhLa2NnR0dLBy5UqFY/k9fPgQrVu3hq+vL44dO4Zz585Jr14HgNTUVOzevVuWzKEvA3uuULFnbGyMwMBAbNy4EcDbL/qhoaFwdXVFeHg4+vTpI8V+9913OH/+PIyMjBAYGAgNDQ3s3LlTlljJShC8y8fHB87OzkrX07lzZ2zYsAGpqak4efIkHBwcEBISIg2O9X77z507Bzs7O5w8eRK2trYICAhAly5dZDcnS5cuRatWrXDkyBGFiQJl65kzZw5+//133L59Gy9evMCBAwcwaNAgVKxYUVbfu18SZ82ahenTp+PatWuIi4vDrl27MGDAAGmevNZXUduV+Vso29b3LV68GN7e3rh48SIcHR0RHBycr7Fr1NXV0aJFC2zfvh1RUVEYPnx4rl+aGzdujAsXLkBHRweXLl3CiBEj8O+//8rm+eqrr2SDr+U1T9myZXH27FmUK1cOZ86cgZqaGvbs2YM1a9bk2nY7Ozt07doVS5YskU0fPXo0evfuDScnJwBvEwQDBw7E2LFjZc/p+/r6Ss/MA4r/dsocI+/Xo8w878trH1F2nx89ejSOHTuGzMxMXLhwAT4+Ppg1a5ZKbZs/fz7mzJkjjTOxb98+6Orqym4AFdWrqamJU6dOoU+fPjh37hxSUlJw4sQJdO/eXYrR0NDAyZMn0bhxYwQFBcHCwgJHjhxBly5dZElNADh79iy0tLRw6dIlDBkyJNsYNUuWLMEPP/yQZ9KHSFkTJkxAWFgYatWqhRs3buDMmTNQV1fHmjVrcOzYMSnOzs4O169fR/fu3XH58mXcu3cPPXv2lH3JrF69erbEn729Pb7++mul6ylRogRCQkLg5OSEoKAgPH78GH5+fhgyZIjC9i9ZsgRjx45FcHAwHj16BD8/P4waNUr2iGaTJk2wdu1a3Lp1C7t371b4C70y9VSvXh3nzp2DoaEhQkJC0LdvX6xZswbNmjWT1fXu8Zm1Htra2rhy5Qp69OiBlStXSvPktb6K2q7s30KZtr6vdu3aWLNmDSIjI/Ho0SNs2bIFw4YNy3We99nb2+PXX39FZGQk/Pz8cn2Mt0SJEjh9+jQ6d+6M8+fPw8rKCleuXIGrq6sUU758eXTp0kX6MUaZeVavXo3u3bsjLCwM4eHhGDRoEEJDQ2XXMUV+/vln/P3339Ig6s7OzggJCYGtrS0CAwPh5uaGq1evZhvDQ0tLC1OmTEGrVq0waNAgWdmHHjuKKFPXp2hP27Ztoa2tjZ49e+ba3lq1aiEoKAgGBga4cuUKevXqhW+//VZ2bc1pWSNGjMDu3bvx7NkzXLp0CaNGjcK///4rixk3bhwWL16MsLAwxMTEYMOGDRgxYkS26/0vv/yCTp064cqVKzA3N8eFCxdkvbE2bNgAZ2fnPAcUpuJHTeT3IVIi+uIZGRlh48aNshvcoqJUqVJYuXJljr96fQliYmLw008/Yfny5QU2zgjJxcXFyQbivHjxItzd3XH79u0cu8MXpICAADRq1AhpaWk5/o3v3LmDhQsXYvHixUyuEH2mRo8ejbt378oehSgqxo4dixs3buDgwYOF3ZRCNW3aNDRp0iTXx4+/dO3bt4e2tnaejxSmpKRACCH9kCCEQM2aNeHt7Y25c+d+iqaiYsWKGDt2LAYPHpxjzLhx49CzZ898v2mRij7eVROR0kJDQ7F27VqkpaXJXo1JRYu5uXm2sUqoYG3atAmnT59G48aN8ezZM/zxxx/45ptvPkliRVkVK1bM1oOJiD4PaWlpWL9+Pfz8/GSvdaeiZ8qUKYXdhM9WYGAgTp06hX///TfHcZDelZiYiGbNmqFTp04wMjKCn58fYmJiMHz48E/QWuV9qkQPfX6YXCEipd25cwevXr3C8ePHUbZs2cJuzgdR9CgGUUEbNmwYzM3Ncfz4cWhpaWHZsmWftLdU2bJl0aVLl3y/QpuIPg9paWk4deoUJk2alO0xjKKievXquT7CQxQUFIQ7d+5g165dqF69ep7xxsbG2LRpEzZs2ICIiAg0a9YMfn5+2V7Z/jG1bt06z8fP6cvFx4KIiIiIiIiIiFTAn7SIiIiIiIiIiFTA5AoRERERERERkQqYXCEiIiIiIiIiUgGTK0REREREREREKmByhYiIiIiIiIhIBUyuEBERERERERGpgMkVIiIiIiIiIiIVMLlCRERERERERKQCJleIiIiIiIiIiFTwP/xNqOjql6h1AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -537,15 +540,15 @@ "datasets": [ "kang2018" ], - "executed_at": "2026-10-26T20:33:04+00:00", + "executed_at": "2026-10-27T09:55:08+00:00", "executed_code_sha256": "bb23383e315edef7514f1417c29a2b2f3b81a0df2423690be65e81a452f6b544", "executed_datasets": { "kang2018": { "kang2018.cube.zarr": "sha256:a30af3dabe17f21a6c75f41b64a279a1423640b9aa919022cf67897f9cc77a51" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 3.5, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 12.1, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/normalization_and_quality.ipynb b/docs/source/guides/normalization_and_quality.ipynb index c2aaeac..c73fd72 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.dev57+gb65bc7e32\n" + "CytePool 0.1.dev61+gcd5dbe953\n" ] }, { @@ -196,7 +196,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFcAAAGbCAYAAAABTH+VAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4FNXXwPHv1vQEAgQICb33Kh2kKk3pTVQUEFARRSxYwYoFxPKzIKioKFIEVJQqRXqRLr0lIYSQuunb5v0j7LxZ0jabkAQ4n+dBkyl372zCzuHMvedqFEVREEIIIYQQQgghhBBu0ZZ0B4QQQgghhBBCCCFuZZJcEUIIIYQQQgghhCgESa4IIYQQQgghhBBCFIIkV4QQQgghhBBCCCEKQZIrQgghhBBCCCGEEIUgyRUhhBBCCCGEEEKIQpDkihBCCCGEEEIIIUQhSHJFCCGEEEIIIYQQohAkuXKH+/LLL5kwYYLLx8+ZM4cpU6bcxB7dngr6PoviJT8fIYS49Y0ePZrvvvuupLuRr++++47Ro0ffMX1IS0vjww8/5MEHH2To0KGcP3+exYsXM3ToUKfjli5dytChQ7Hb7cXSLyGEKGr6ku5AcbHZbPz1119s27aNK1eu4OnpSUhICM2bN6dv374YDIaS7mKJ2L9/P3/88YfTtk8++YTjx4/z1VdfZTt+165dHDp0qJh6VzLyun535fQ+F9bN6Oed6mb8fIQQorSJj49n5cqVHDhwgPj4eMqVK0dISAg9evSgdevWJd29Qvv1118JCgoq9tddvHgxK1euZPny5S4df+jQIX799deb3Ku8+1VcfQC4//77iYyM5Pnnn8fb25uyZcty9OhRVqxY4XTcf//9x4oVK7Db7Wi12nyvQQghSps7Irly4MABRo0aRUpKCmPGjKFnz54oisLBgwcZN24cGo2GrVu30rBhw5LuarGbPHkyAwcOdNq2d+9etmzZUiL9KQ1uxvXn9D4X1p3+cxJCCOG6r776iunTp9OwYUMGDRpEx44dSUxM5O+//+aVV16hRYsW7N27t6S7eUvKKVFQGpSGfl26dIkNGzbwww8/MGbMGHX7mDFjXErolYZrEEIIV932yZVTp07RvXt3WrduzerVq/H19VX3jR07lpkzZzJx4kTi4uJKsJclp1WrViXdhTuCvM9CCCFKyoIFC5g0aRJvvPEGr776qtO+yZMnc+TIEZkaKW6KS5cuAVC+fHmn7Y0bN6Zx48Yl0SUhhLhpbvvkynPPPUdGRgaLFy92Sqw4lC1bll9++YXk5GSn7WazmSVLlrB9+3ZSUlKoW7cu48aNIyQkRD1mzpw5XLx4kU8//ZRly5bx119/YTAYGDp0KL169cr2Wq60abFYWLZsGTt37iQpKYnatWvzwAMPULNmzVyvcf369cyfP5/58+cTGBgIZGb6Z82aRbNmzZwCqXnz5nH69Gk+//xzILPWxIEDB/j6668BePXVV/nnn3+Ii4tzmgv7448/4unp6fS6rlxzTsxmM0uXLmXHjh2kpqbSuHFjxo0bp/YdMocuf/fddxw6dAiNRkPLli0ZO3Ys/v7+6jEvvfQSBoOBWbNmObW/ZMkSli9fztKlS9Vhpa7+rPK7fnd+Pjm9zwXpU07y6ue2bdvc/n1w9b3PiSvvjeNnA6DVavH396dNmzaMGTMGHx+fbO/NJ598wuLFi9m0aRNly5blySefpGbNmtjtdpYsWcLGjRvx8vJi/PjxtGjRwqk/Wdv48ccf+fvvv/H09GTYsGF07949z2txuFl/Z4UQoriYTCaee+45OnTokC2x4tC0aVPWr1+fbfuVK1f4/vvvOX78ODqdjvbt2/PQQw85xQOjR4+md+/eDB06lC+//JJDhw4RHBzMpEmTcvwcdKXNa9eusWjRIk6ePIlOp6NZs2Y8/PDDTvcJVx06dIh33nmHu+66i+nTpwOZU8VXrlzJ33//TUJCAjVq1ODhhx+mbt266nnfffcd69ev56effmL16tX8/vvvAAwYMID7779fPW7evHmsWrUKwOl+/MknnxAcHJxv//Jqe9WqVfz44485trVv3z7ee+89XnzxxRxHgBSkX+vXr2fZsmXY7Xb69u3LkCFDsrXnynt2o7fffpt169apXy9YsCDbMXlN93HlGgr6s1y7di0rV65Ep9M5xT5CCFEUbuuCtklJSfz11190796dSpUq5XqcRqPBz89P/f7KlSu0bNmSl19+mZo1a9K9e3f2799Po0aN2LVrl3rcrl27+Ouvv3jppZfYsmULnTt3Jikpid69e2e7WbjSpqIo9O/fnxdeeIGqVavSq1cv7HY79913H9u3b8+1/xUrVmTFihVs3LhR3bZq1SpWrFjBnDlzsFqt6vaPPvqIhIQE9fv9+/erN3WAHj16UK1aNby8vBg5cqT658aaNK5cc04uX75MixYtePbZZ6lYsSLdunUjJiaGdu3akZSUBGTOuW3YsCELFiygZcuWNGvWjM8++4zGjRtz7tw5ta2///6brVu3ZnuNY8eOqXN2HVz9WeV1/e7+fHJ6nwvSp5zk1c/C/D64+t7fyNX3pkmTJmpfhwwZQp06dXj//fdp37496enp2d6bZ599lgMHDtC5c2cOHz5M27ZtCQ8P5/HHH2fPnj106tSJ06dP07FjR06dOpXj+zt16lT27NlD586dycjIoEePHrz33nt5vr9wc//OCiFEcVm3bh0JCQk88MADeR4XEBDg9P369eupW7cuf/75J23btqVFixbMmTOH9u3bk5iYqB7366+/snv3boYNG4bZbKZLly5s2LCB1q1bExUVVeA2w8PDady4Mb/99htt2rShbdu2nDp1ihYtWhS40Onvv/9O586dAXjyySeBzNiwa9euTJw4kaCgIHr37s2lS5do2rSp033aUZNk9uzZrFixgg4dOuDj48PgwYOdCvu3b9+eBg0aADjdj7PGlbnJr+1mzZqxcuVKpwczDnPmzGHDhg25Tml3tV+ffvopP/74I+3bt8doNDJ06FA+/vhjp2Ncfc9u1LVrV7p166Z+nbUfNpst3+k++V1DQX+W77//Pj/++COtW7fGZDLl+dpCCOEW5Ta2b98+BVCmTZtWoPP69OmjlC9fXomOjnba3r9/f6VOnTqKzWZTFEVRhgwZonh6eirz5s1zOq59+/ZKkyZNCtzmqVOnFEBZvny50zFms1mJiYnJtb92u10JCgpSxo0bp27r3Lmz0r9/fwVQduzYoSiKorb/zTffqMeNGzdOqVixolN7DzzwgFKlSpUcX6sg15yTXr16KWXLllUiIyOdtsfFxSkZGRmKoijKXXfdpVSuXFlJTExU98fExCjlypVT7r77bnVb27Ztla5du2Z7jZdfflkBFIvF4la/c7t+d38+ipLz+1zY9zK3fhbm98HV9/5GhXlvoqKiFL1er3z66afqtiFDhigeHh7KZ599pm5LSUlRAgIClDZt2igfffSRuj0tLU0pW7asMmHCBKd2HW28//77TtunTZum6HQ65cSJE+q2nH4+N/PvrBBCFJfXX39dAZS///7b5XNiY2OVgIAApX///ordbnfaHhgYqDz11FPqNg8PD8XPz8/pM/XKlSuKwWBQZsyYUeA258yZo2i1WiUlJcWpT1FRUU7n5cTDw0OZOnWqoiiK8tFHHyk6nU6ZMWOG03kTJkxQvLy8lNOnTzudO3HiRCUwMFBJTk5WFEVRpk6dqmi1WmX69OlOx82dOzfb+/nCCy8oBQmpC9J23759lSpVqjjFNFFRUYrBYFAmTpyY5+vk1S9HH1566SWn7cOGDVPKly+vWK1WdZur71lONmzYoADKX3/9lW/fHL+rWa81r2so6M8y678H0tLScu2zEEK467YeuZKamgqAl5dXtn1Tp05l6NCh6h/H0n1Xrlzhr7/+4pFHHqFChQpO54wbN44zZ85w+PBhdZvFYmHixIlOx/Xs2ZPjx4+rIwRcbdPDwwOAP//8k5SUFPUYg8FAuXLlcr1OjUZDjx491CG9ycnJ7N69m3HjxlG3bl11+4YNG9T+FYYr15yTiIgINmzYwIQJE6hcubLTvrJly2I0Grlw4QJ79+7l0UcfdZqGUq5cOR5++GG2bNmS7UnYze63g7s/n5vZp5y4+/tQmPe+IO/Nzp07mTFjBg888ABDhw7liSeewGAwcOTIEafjrFYr48ePV7/39vamdevWHDhwwOk98/T05K677uLgwYPZ+mWxWHj88cedtj311FPYbLY8Rwfd7L+zQghRXHKLhaKiopzioKFDh3L06FEAVqxYQWJiIs899xwajUY9JzAwkEGDBmX7/OzQoQP169dXv69UqRKNGzd2Wl3Q1TY9PT2x2+2sXLkSRVHU4ypWrOh0Xm6sViuTJ0/mhRdeYMGCBbzzzjvqeRkZGfz4448MHDiQOnXqOJ03fvx44uLi+Pvvv9Vtdrudxx57zOm4yZMnYzAY+OWXX/LtS15cbfuJJ57g8uXL/Pbbb+q2BQsWYLFYGDduXKH7cGOtnZ49exITE8Ply5eBgr9nxcWdn2XWa71xqrsQQhSF27rmiqN4Vk7Favv164fJZCIhIYEJEyaoNRQcUwu2bNnCyJEj1Ru7oijExsYCEBYWptZ3CA4OzvYBXaFCBex2O9HR0QQHBxeozTfeeIM33niDn376iY4dO9KtWzdGjBhB7dq187zWXr168fPPP3Py5EnOnj2Loih0796d3r17s2HDBmbOnMmGDRuoV68eoaGhBX8zs3DlmnNy5swZAHWIZ04uXrwIkO1GCajzZy9cuJDnNK+i7rdDtWrV3P753Kw+5cad34fCvPeuvjevvPIKs2fP5pFHHqFbt24EBASg0WjYsmVLtiG6wcHBavLCoVy5clSsWDHbPxLKlSvHf//9l61fFStWzDZHv2rVqmoiLzfF8XdWCCGKQ26xkJ+fHyNHjgRg06ZNfPnll0yaNIkmTZqon4Fz587l888/R1EU9XPw2LFjREZGYrVa0eszw8icaqtUqFDBKSHvaptjx45l9erVjBkzhmnTptG1a1d69uzJqFGjXJpq8/XXX2M2m/n0008ZO3as077w8HDS0tI4cuRIts92RxIqLCxMPV6j0VCjRg2nNjw9PalSpUqe9xBXuNr2vffeS82aNfn8888ZPHgwNpuN+fPn06RJE9q0aVOoPuh0OqpWreq0zfFAISoqiqpVqxb4PSsu7vwspRaaEOJmu62TK/Xr16ds2bLs3r07277evXsDZHsS76gt0rp16xyLXk6ePNmpcJjRaMx2jOMJiWNucEHafPXVV5k8eTIbN25k+/btfPXVV8yaNYuffvrJqZjXjRwFUNevX8+5c+e466678Pf3p1evXnzxxRfExsayefNmHnrooVzbcJUr15wTxz+Usz7hz63ttLS0bPsc5zna8fDwwGw2Zzsuaw2Rouh3Vu7+fHJTFH3KiTu/DwV573OS33sTGxvL7Nmzefrpp/nwww/V8+x2e461AHJ7b3LbntP75QiwsrJYLFgsljyvpTj+zgohRHFo3749ALt376Zv377qdh8fH/Uz6sb7puMzcMCAAdlqsQwfPhxALRgPuX9eZ/1cdrVNb29v1q1bx8mTJ/n777/Ztm0bzzzzDDNnzmTv3r1OBcVzMmrUKM6cOcMrr7xC8+bN6dSpU7Y+NG7cOMfP57Fjx9K8eXP1e0VRSE9Pz7YgQmpqap73EFe42rZWq2XSpEm88MILnD59mpMnTxIWFsa8efMK9foAer3e6ecIucewrr5nxaWg/TIajTn+ngohRFG6rZMrWq2WiRMnMnv2bLZs2cLdd9+d7znNmjXD09MTm81WZP8wKmib5cuXV4t2ffDBB9StW5f//e9/eZ4bEhJC/fr1Wb9+PefPn1cDlW7duqHRaJg9ezYmk8mlFX30en2h/mGfm2bNmuHl5cU///zDE088keMxjRs3Rq/Xs2fPHiZNmuS0b8+ePXh6eqojX0JDQ3MsaLt///5C9TO/63fn53Mz5NVPd34fCvLe5yav9yYqKgqbzUaTJk2cztm+fXuOSbKikJiYyNmzZ51Gkezfvx9FUbKtLpRVcfydFUKI4tCpUyeaNGnCwoULmT59er4rvwG0a9cOgKCgIAYMGFAk/Shom/Xr16d+/fo8/vjj7Nq1iw4dOvDLL7/w7LPP5nlemTJl2LBhA4MHD6Z3796sWLGCPn36AJkjFytXrkxSUpLLn8/79+93ih8vXbpEdHS00z3EMYLHbrdnS1YUtm2ARx99lNdee40vvviCEydOYDQaGTNmTL7tu9uvrNx5z4pSbtdQ0v0SQoic3NY1VwBee+012rVrx/Dhw9Xl4LJyTIVw8PX15fnnn2fhwoX8+uuvTvuSkpLcelLgaptHjx5l9erVTnOMMzIysFgs6rDevPTq1YuNGzdy4sQJdWSOn58f7dq147PPPkOv17uUYAoNDSU2Njbb8tSF5ePjw7Rp01i6dCk//fST076lS5eSnJxMQEAAjzzyCD/99BPbtm1T969bt44VK1YwadIkdUpInz59iIiI4I8//lCPW7hwYa4jV1yV2/UX9udT1PL7ORX096Eg7/2NXHlvateujZ+fH7/99puaFIqJieGtt95yWoa7KJUvX54333yTjIwMILP+zIsvvkjFihUZMWJErucV199ZIYS42TQaDYsXLyY1NZV+/fpx/vx5p/12uz3btI7+/fvTpk0bnnnmGU6fPu2079y5c9nu4a5wtc2VK1eqtV8cHKMnXf1c9fb25vfff1eXNnbUMNFoNMyaNYs///xTnZrkkJ6ezvz5851WQjIYDHz11VfqtFWLxcK0adPw8fFxqnfimF576dIll/pXkLYhc+rriBEjWLhwIevXr2fgwIEu1fVyp183Kuh7VtRyu4aS7pcQQuTktk+ueHl58ffff/PII48wfPhwatSoQd++fenbty+NGzema9euDBgwgGHDhqnnzJw5k5kzZzJ27Fjq1atHv379aN26NfXr1ycyMtKtfrjSZpkyZVi0aBFVqlShW7du9OnTh5o1a1KnTh3mzJmT72v06tWLjIwM/P39ueuuu5y2p6en07ZtW5eeWD366KP4+PjQokULBg8ezNChQ52WyS2MN954gxdffJFHH32UBg0a0KdPH2rUqMGvv/6qDvGcN28ew4YNo2fPnnTo0IH27dszYMAAxo4dy+zZs9W2Ro4cSf/+/RkyZAjdu3enZcuWnDx5stBPMHK7/sL+fIpafj8nd34fXH3vb+TKe+Ph4cGCBQtYv349DRs2pHfv3tx111288MILLs2jd0dAQABDhgyhadOm3HPPPdSuXZvz58+zevXqfP8uFMffWSGEKA5NmjRh//79lC9fnvr169OyZUvuv/9+unfvTmhoKJ9//jmTJ0+mcePGQGYtjr/++osWLVrQpEkT7rrrLvr160eDBg0YMGCAW9MrXG3T19eXhx9+mLp169K3b1+6dOnC/fffz8SJE10areFgMBj4+eefeeSRRxg9ejTz588HYMKECXzxxRe89tpr1KxZk759+9K+fXtq1KjBv//+m21KzpQpU7jrrru45557qFWrFlu2bGHp0qVOtUqGDx9OaGgoXbt2ZeDAgQwdOjTfeNHVth2eeOIJkpKSUBTF5UK27vQrJwV5z4paXtdQkv0SQoicaJSsqd7bnNVq5fDhw1y5cgWj0UhwcDDVq1fPNt/VITU1lX///Zf4+Hh1mkXWJ/e7d+8mISGBe++91+m8c+fOcfDgQfr165ftSX9+bQJcu3aNY8eOYbFYqFWrFrVq1XLp+lJTU/nzzz8pV64c3bp1U7dHRkayc+dOatWqlW2o6YEDB7hy5Qr9+/d32p6cnMzevXtJSEjAbrczaNAgdDqdW9eck8TERPbv34/FYqFRo0Y5FtmNiIjgyJEjaDQamjVrlmtx10OHDhEeHk7Dhg2pVasWx48f58SJEwwZMkSdO1zQfud2/eDezyen97ko3su8+unO74ODq+/9jVx5b2JjYzl48CBarZa2bdvi4+PDX3/9RWBgIG3bts3zvdmzZw9xcXHqEG+Hffv2ce3aNad6AkOHDuXQoUOcPXuWuLg49u7di6enJ+3bt88WcOX29wBu7t9ZIYQobomJiRw+fJiEhATKlCmjxkKO6Rc3unr1KocPH8Zms1GzZk3q1q3rtGrPypUrqVmzJs2aNXM6b/v27aSnp+e4QmF+bULmvfD06dP4+PjQsGFDl0at5NaXP//8k7S0NPr27at+fpvNZg4ePMjVq1epXLkyDRo0cIoHn376ab788kvS09NJTk5m165dQObKSDcWSofM0RJ79+4lJiYGu93OPffck+uDg8OHD3P+/HkGDRrkUtuQOcIoMDCQgIAALly44PI0n9z6lbUPWTlihO7du2cbVZrfe5aT6Ohotm3bRufOnalYsaK6/dixY9keiP3333/8999/TvFbXtfgar9yu1YhhChqd1RyRQhx58iaXBFCCCEKImtypTTYunUrd999N6+//jozZ84s6e4IIYTIwW0/LUgIIYQQQohb2ddff42XlxcTJ04s6a4IIYTIxW29WpAQQgghhBC3qldffZUtW7awY8cOPv74YypXrlzSXRJCCJELmRYkhLgt5Va3RQghhMhPaanTsWXLFhITE2ncuLHU8xJCiFJOkitCCCGEEEIIIYQQhSA1V4QQQgghhBBCCCEKQZIrQgghhBBCCCGEEIUgBW1zYbfbiYyMxM/PD41GU9LdEUKUAEVRSEpKIjg4GK1WctFCCPdITCGEkJhCiNufJFdyERkZSWhoaEl3QwhRCoSHhxMSElLS3RBC3KIkphBCOEhMIcTtS5IrufDz8wMyPwD9/f1LuDdCiJJgMpkIDQ1VPw+EEMIdElMIISSmEOL2J8mVXDiG7fr7+0sgJMQdTobxCyEKQ2IKIYSDxBRC3L5kwp8QQgghhBBCCCFEIUhyRQghhBBCCCGEEKIQJLkihBAlSFEUzGYziqKUdFeEEEIIcQuTmEKIkiU1V4QQogREX41i/749nDhxDJvNhk6no0GDxrRu05agipVu2utGRUWxYMEC9uzZQ1JSEqGhobRu3ZpHHnlEakEIIYQQt6CSiilsNhsrVqzgjz/+ICwsjICAAOrUqcOYMWNo3rz5TXtdIUorSa4IIUQx+++/Y6z5fSWgQVHsQGaAcvz4UY4fP0K/AYNo2LBxkb/upk2bGDJkCF26dGHMmDFUrlyZy5cvc+DAAZo0acKlS5eK/DWFEEIIcfOUVEyRkpJCv379OH/+PM888wyPPPIIqampnDlzhvHjxzNt2jRGjx5d5K8rRGmmUWTcWI5MJhMBAQEkJibK01wh7lA343Mg+moUi777Os8huxqNhofHTijSp03x8fHUrFmTwYMHs3Dhwmz7k5KSnJaHTE9P57PPPmPjxo1otVo6duzItGnT8PLyAuD8+fOMHj2azz//nIULF3Lq1Clq1KjBq6++StWqVV1uB+Dnn39m2bJlJCcn06ZNG55//nkCAgKK7NqFKGkSUwghbqeYAmDixIksW7aMEydOULFixWz7b4wrNm/ezNdff01kZCS1atXi6aefpkmTJk7ttWzZkvT0dP7++28AxowZw7Bhw5zaza+dM2fOMGfOHE6fPk1oaCgTJ06kQ4cORXrtQuRGaq4IIUQx2r9vD5DPMowaDfv37ynS1/3pp59ISEjg7bffznF/1gDIZrPRp08f1q1bx+OPP86UKVPYsmUL9957rxrApaamsmfPHoYMGULLli154YUXiIiIoE+fPthsNpfb+fnnn3niiSe47777ePHFFwkICOCxxx4r0msXQgghbkclFVOkpqayaNEipk6dmmNiBZzjih9//JGRI0fSsWNHXn/9dWrWrEm7du04dOiQeszx48d5+umnOXv2LFOmTKFr166MHDmSLVu2uNxOWloaXbp0QVEUXn31Ve655x5efvllzp49W6TXL0RuZFqQEEIUE0VROHHimDpsN9fj7HZO/HeMPn3vQ6PJJ2hy0eHDh6lYsSKVKuX/5Grp0qWcPXuWs2fP4uHhAUDnzp2pVKkSW7du5e6771aPnTNnDoMHDwagdu3a1KxZk7Nnz1KvXj2X2tmxYwd9+vRh7NixAHTv3p20tLQiuWYhhBDidlWSMcXJkyfJyMigWbNm+R5rNpt55pln+Oqrr9R4oVu3boSHhzN79myWLFmiHtu5c2c+/fRTAHr27Mm6detYvXo1d999t0vtnDt3jqioKD788EM1uTNy5EgsFkuRXLcQ+ZHkihBCFBOLxaKO6siPzWbDarViMBiK5LXT09OzDUNet24dr7/+uvr9p59+Sps2bdi8eTPJycn06NEDRVHUUSY2m42TJ086JVfatGmjfh0SEgJkFs2tV6+eS+1069aNhx56iFdeeYV+/frRpk0bpylDQgghhMiupGMKIFtc0b17d1JTU9Wv33nnHY4dO0ZMTAzvvvsuc+fOVeOByMhIypQp43R+1pgCMuOKqKgoAJfaqVWrFlWrVmXYsGFMmDCBrl27Ur58efUBjxA3myRXhBCimBgMBnQ6nUvBkE6nQ68vuo/o0NBQfvnlF+x2O1pt5ozQVq1aMW/ePK5du8Z9991HYmIiAMnJyTRo0IAPP/wwWzvVq1d3+j5roOZ4IuZIorjSzpAhQwgKCmLx4sWMHTuWa9eu8fbbbzN58uRCX7MQQghxuyrpmALgwoULTtvfe+89bDYb06dP5/Tp00BmLADwyiuvZJtCdOPDlBuTPxqNximmyK8dLy8v9u/fz4IFC/jf//7Hgw8+SM+ePfn++++zJXKEuBkkuSLEdSZTIvFxcQQGlsNPCg6Km0Cj0dCgQWOOHz+a5zBejVZLg4aNi2z4LsCAAQN45513WLp0KSNHjgSgfPnylC9fnoiICKdja9euzdatW2nVqlWhnnK52k7nzp3p3LkzAD/88ANjx45l6NChVKhQwe3XFkKI4iCxgygpJRlThIaG0qxZM3744QfGjRunbneMPMmayKhVqxYAVquVdu3auf2arrZToUIFZsyYwYwZM4iJiaFVq1Z8/vnnvPTSS26/thCuKnRBW6vVmu2PELcakymRPbt3cPLkcXbv3k6SyVTSXRK3qdZt2gL5LNKmKLRu3bZIX7ddu3Y8+OCDTJ06ld9//91pn2PIrcMjjzxCQkICzz33nPqZbrFY+PTTT4mMjHT5NV1pZ/78+Zw8eVI9xzFHuqiGLgtRGI6h9Fn/yCKLwkFiB1HSSiqmAPj444/ZuXMnTz31lDqqBDKnDCUkJKjfV6lShUGDBvHSSy9x/vx5dfu+ffuc6q3kx5V2Dh06xI8//ojdnpls8vLyQq/XS0whio1byZXz58/Tp08f/P39MRgM2f4IcauJj4tTP4jtdjtxcbEl3CNxuwqqWIl+Awah0WjQaJ0/gjVaLRqNhn4DBhX5kokA3377LVOmTOHRRx+lTJkytGjRgtq1a3Pvvffy/PPP06pVKwBq1KjBmjVrWLNmDUFBQTRp0oQKFSpw9uxZypYt6/LrudJOzZo1GTJkCNWqVaNx48Y88sgjfP755zJ8V5SY9PR0Jk+eTFBQkBqUZ/2zadOmku6iKCUkdhAlrSRjiq5du/L333+zd+9eAgMDqVevHk2aNKFixYr4+/vz9NNPq8d+9913tGjRgoYNG9KwYUMqV67MU089RZ06dQr0mvm1Exoayvr16wkMDKR58+aEhITQoEEDmWosio1GceMRTLdu3dDpdDzxxBM5BtpZix3mx2KxsHr1ak6ePMmDDz5ItWrV8jz+/fffx2w2Z9veokUL+vXrB8Bff/3FgQMHnPYHBQUVaHnPm7EWvSi9kkwmdu/ertajaNeukwzvFTf1cyD6ahT79+/hxH/HsNls6HQ6GjRsTOvWbW9KEJSV3W7n/PnzJCUlERwcnOsyigDnzp0jLS2NOnXqOBWES0tL4/Dhw9mm/OzevZuGDRtme79ya8fh0qVLpKSkULNmTTw9PYvgKoVwz9tvv82CBQt4/fXXqVatWrah9M2aNStQkhEkprhdSewgCuJ2jSkAYmJiCA8Px8/Pj6pVq2I0GnM8Li4ujkuXLhESEpJt6u9///2Hv7+/WhwfMh/o2+12ateu7XI7kFmf5dy5c1SuXJmgoKAiuEIhXONWcsXX15fz588X+pf1559/5oUXXqB+/fps2LCBzZs355uYefPNN8nIyFC/j42N5csvv2TOnDlMmzYNgEmTJrF161aGDBmiHlexYkWmTJnict8kELrzJJlMxMXFyrxpoSqOzwFFUbBYLBgMhiKdDy2EcM/AgQMZPnw4o0ePLrI2Jaa4fUnsIFwlMYUQtz+3CtoGBwerwyALo2rVquzZswebzaZWnc7Pq6++6vT93LlzMRqNPPTQQ07bGzVqxFtvvVXoPoo7h5+/vwRGothpNJpcn/AIIYpfUcU44s4gsYMoTSSmEKJkuVVzZeLEibzwwgukpaUV6sU7duxI5cqVC9XGN998w6BBgyhfvrzT9vDwcObOncvChQs5ceJEoV5DCCGEEHeGRx99lI8++ijbKlpCCCGEEHlxa+TK559/zvnz5/nll1+oUqVKtmFnZ8+eLZLO5Wf37t0cP36cjz/+ONu+jIwMLl68yOXLl3n88ceZMWMGM2fOzLWtjIwMp+lGJqn4LoQQQtxxPv30U44fP061atWoUqVKtqfA33//PR06dMizDYkphBBCiDuPW8mV5557rqj74ZaFCxdSs2ZNunfv7rR9ypQpfPnll+r3q1atYtCgQfTq1YuOHTvm2Na7777LrFmzbmp/RfExmRKJj4uTOdBCCCEKZNiwYbRv3z7X/fkV3geJKW5FEjcIIYQoLLcK2ha1iIgIQkNDXSpo65CSkkLlypWZMWMGM2bMyPf44OBgHn/8cV555ZUc9+f0lCk0NFSKz92CTKZE9uzeIdX7RaFJEUohhDskpri1SNwgioPEFELc/twauZJVUlISiqIU+4fE0qVLSUtLY+zYsS4dr9VqSU5OznW/h4dHjsuDiltPfFycWozQbrcTFxcrQZIQQogCM5vNmEymbHXd8iMxxa1F4gYhhBBFwa2Ctoqi8OmnnxISEoK/vz8BAQGEhITw6aefUtQDYdasWcP8+fOzbV+4cCH9+/fPVhDXZrNx5MgRp21//vknly9fdnlUjLi1BQaWQ6vN/NXWarUEBpYr4R4JIYS4lWzcuJFWrVrh5eVFhQoV8PPzY8qUKSQkJJR018RNIHGDEEKIouDWyJV3332XDz74gGeffZZ27dqh0WjYtWsXr732GklJSbz00ksutXPkyBF+++03tdDbDz/8wPbt2+nSpQtdunQBYOXKlezevZvHHntMPe/UqVPs2LGDNWvWZGtTURQmTJhAxYoVadSoEWFhYaxYsYKpU6dy7733unO54hbj5+9Pu3adiIuLlbnTQgghCmTnzp307duXsWPHMmvWLAICAjh16hRz5szh+PHj/P333yXdRVHEJG4QQghRFNyquVK1alUWLFhA7969nbavW7eOCRMmEBYW5lI7Bw8eZMWKFdm2d+/eXS1Su2rVKsLDw5kyZYq6f8eOHWzYsIHXXntNfdKQlaIobNiwgYMHD1K2bFk6duxIo0aNCnKJMi9SCCGfA6LIzZ07l549e9K0adNcj4mLi2P+/Pk8//zzOd7j7nQ2m43Zs2czZcqUm/L38tFHH6V8+fK8//77TttjY2OpXbs2e/bsoW7dugVqUz5LhBDyOSCK2rZt2zh79iyPPvponsctWrSIFi1a5Bl73MnWrFmDl5dXtkVy3OHWyJWoqCjatWuXbXu7du24evWqy+20aNGCFi1a5HnMwIEDs23r2LFjrqv+AGg0Gnr37p0t+SOEEHeq9PR0Zs+ezciRI6lfv36ux125coW1a9dy5coVypUrR8+ePalVq5a6f//+/axdu5aXX34ZjUajbv/kk0/Q6/U8/vjj6jabzcbbb7/NgAEDaNGiBWvXrmX37t3ZXtPf359p06ap38fGxvLnn39y5coVqlWrRq9evQgMDHQ6x5Vjsvr111/RarU53lOK09y5cwkKCsozwHn55Zfx9PS8JRIrUVFRrFq1isTERDp06EDnzp1dPnfr1q1s3ryZvn37ctdddzntS0pK4pdffiEiIoJp06Y5/UNEp9Nx8eJFZs2axZw5c4rsWhyioqLo379/tu3lypWjdu3aXL16tcDJFSGEuN0sX76c9PR0xowZk+sxVquVDRs2cOzYMTQaDc2aNaNHjx7q/U1RFN566y369etHy5Yt1fN27tzJ+vXrefTRR6lataq6/bfffuPq1atMmDCBmJgYPvvssxxfd/To0erntKIobNy4kePHj+Ph4UH79u1p3ry50/GuHJNVWFgY33zzDa+88gp6faFLmLpt27ZtrF27Ns/kysGDB3nxxRc5c+ZMMfbMPXa7nd9//50TJ04QHBzM4MGD8fX1denc5ORk5s6dS/ny5Z1i0f/++4+lS5dmO3769Olq25UqVWLAgAGcOnUKPz+/Ql2DW5Fb3bp1+eWXX7JtX7JkCXXq1ClUh4QQQhS99PR0Zs2axcmTJ3M9Zs6cOdSqVYtVq1aRnJzMtm3baNq0Kc8++6xaT8tms/Hqq69y/Phx9bzExESeffZZnnnmGVJTU9Xt//77L6+//rp67tq1a/nyyy/z7Oe6deuoUaMGP/74I7Gxsfz222+0adOGxYsXF+iYG/3666+sWrUqz9cuDcLDw/nmm2949tlnS7or+dq/fz/169dn9erVXLx4kfvuu4/p06e7dG54eDgPPvggb7/9Nnv37nXa9/7771OvXj1+/vlnZs2apU4dzmr69On873//Izo6ukiuJavcYpzjx49z/Phxp2SjEELcqZYvX86PP/6Y6/7//vuPRo0aMXXqVK5cucLly5eZPHkyzZs35/z580DmA/Fff/2Vb775xunc//3vf7z55pv89ttvTttnzZrFvn37AIiJiWHWrFlERETk2oeUlBQ6dOjA+PHjOX/+PCdPnmTChAn07du3QMfcKCwsjFmzZmG1WnN/g0qJ119/nccee8zlJEVJsVqt9O3bl6lTpxIZGcknn3xC8+bNiYqKcun8yZMn89FHH/H55587bf/vv/+YPXt2nue2atWKevXqZTvXHW6l2mbOnMnIkSNZs2aN+rRpz549rFmzhiVLlhS6U0IIIYrX0qVLmT59Or/++iuDBg1Stx88eJAOHToQFBTECy+8QOvWrfHz82Pz5s00btwYyByBUL9+fex2Ozt27KBXr14AbN68mbJlyzo9/alUqRIzZ87MtR9PPfUUDzzwAF988YW6LTk5mVOnThXomKzWrl3LkSNH0Gq16muPHz+enTt34u3tTZ06dfjrr7/w8vJi4sSJQOY//v/44w9SU1Np2rSpek0Ob7zxBqNHjyYyMpIDBw5QtmxZhg0bho+Pj9Nx27dvZ8eOHYSGhtKnT59cr9vh66+/pnPnzoSEhKjbkpKSWLlyJVevXqVBgwb06dMHnU7n1I9Lly5x+PBhypUrx/Dhw/Hy8lLP/+yzz4iJiUGr1RIcHEzPnj2pXr26W9eT1eTJk+ndu7f6RGjQoEHcc889jB492ukJ5I1sNhujR4/mtdde4+mnn862v02bNpw6dYoDBw7kWt+kXr16NG7cmO+++47nn38+19dyx9SpU2nVqhWtW7emb9+++Pv7c/r0aX7++WcefvhhgoODi/T1hBDidpOUlESfPn1o2rQpv/76KwaDAYD33nuP/v3707dvXw4fPoyHhwfdunVj3bp1Tudv2bKFYcOGsXnzZp588kkAEhISOHToEM8995zTsePHj89xRgXA/PnzOXXqFOfPn6dMmTLq9q1btxbomKxiYmLUZNBbb72FXq+nefPmNG3alO+//54XXniB5cuXc+nSJcaOHUtISAgWi4Xff/+d06dPU6VKFfr27Uu5cv9fOPvPP//EZDLRqVMnNmzYQGJiIj169KBJkyZOrx0dHc2yZctQFCXPWRwO4eHhrFmzhrlz5zpt37Jli3qvv+eee6hSpYpTP9q1a8emTZuIj49nwIAB1KtXTz139+7drF27Fsgcedy0aVN69uzp1L6r15PVokWL+Oeffzh16hQhISGkp6fTqlUrXn/9db766qs8r/O7777jzJkzPPzww2zcuDHbfk9PzzxjT4AHHniAd955hxdeeCHP4/Lj1siVoUOHsmPHDvR6PT/88AM//vgjBoOBHTt2MHTo0EJ1SAghRPF74403uPfee50SK5A5fXPSpEm8++67mM1mdDodnTt3ZvPmzeoxmzdv5u6776Zr1645bi/I9Jbw8PBsIyB9fX1p1apVgY5xxdKlS3nmmWe47777uHTpkjrCZunSpTRp0oRdu3Zx5coVnnzySe6//36n1fDeeOMNBg8ezMyZM4mMjGTu3Lm0a9cOi8WiHvPee+/Rq1cvzp49y/r162ndujWJiYl59mnt2rVOU2scCZXvv/+e2NhYFi5c6BTEvPHGG9x///28/PLLhIeH8+6779K+fXvS0tKytW21Wtm4cSNNmzZVA6OCXE9WYWFh7N+/32kocu/evalatWqOtdSymjlzJuXLl2f8+PE57u/WrZtLw3K7du3KX3/9le9xBVWjRg2OHj3KXXfdxZo1a/jiiy+4cOECX3zxRZE81RJCiNvdokWLuHz5MvPmzVMTKwBGo5GPP/6Y06dPqyMEu3Xrxn///aeORDx16hQJCQlMnz6drVu3qvferVu3Yrfb6datm8v9CA8Pp3z58k5JE8i8fxTkGFecP3+eWbNm0a5dO9auXaveP69du0br1q358MMPiYuLY+XKlTRs2JBDhw6p5/7555+8+OKL9OrVi0OHDrFv3z5at27Nhg0b1GPOnTtHo0aNWLJkCefOnWPEiBF5jtgF2LBhA0FBQdSuXVvd9uSTT/LAAw8QHh7Ovn37uOeee9Qp23/++ScvvPACXbt25eDBg+zatSvHmMEhLCyMRx99lFGjRjltd+V6brRixQp69eqlPlzy9PTkgQceYPny5Xle4+nTp5kxYwY//vhjrlO0LBYLn3zyCfPmzWPTpk05HtO1a1cuXLiQ64M6lykiR4mJiQqgJCYmlnRXhBAl5Hb6HIiPj1cAZeXKldn2xcXFKYAyd+7cHM9ds2aNAij79u1TFEVRPvzwQyUwMFCx2+2KoihK8+bNleXLlytLlixR2rdvryiKolgsFsXPz0/55JNP1HamTp2qVKxYUXn99ded/vzyyy/qMUOGDFECAwOV2bNnK/v27VMyMjKy9ceVY270wAMPKA8//HC2dsqUKaPExMSo26KjoxVvb2/l77//VrclJSUpVapUUX7++Wd1m06nU0aPHu30Hnp6eip//PGHoiiKEhkZqXh6eirLli1Tj/nyyy8VQPnhhx9y7aeXl5eyePFi9ftvv/1WqV27ttMxhw4dcupHx44dFavVqihK5u9scHCw8sEHH+T6GnPmzFGaNm3qtC2/67nR+vXrFUA5e/as0/bu3bsrQ4YMyfW1//77byUkJES5du2aoiiK4uPjo3z66ac5Hrt582YFUMLDw3Pc/+WXXyqBgYG5vlZpcjt9lggh3HO7fQ6MGDFCueeee3LcN3z4cKVu3bq5nhsaGqqMGzdOUZTM90Wn06mxwJdffqn07NlTsdvtSrly5ZTDhw8riqIoTz/9tNKwYUO1jRMnTiiAMm7cuGxxRUpKiqIoirJhwwYFUEaNGqX8/vvvSnR0dLa+uHLMjf755x8FUNLS0rK187///c/p2AcffFAZPny407YXXnhB6dq1q/r9E088ofj6+iqXL19Wtz388MNK//791e+HDx+u9OrVS7HZbIqiKEpsbKwSGBiodOzYMdd+PvPMM0rnzp3V7+12u+Ll5aVs2LBB3ZaUlKScO3dO7YdGo1H+/fdfdf/06dOVunXrqnHGja5evar4+voqO3fuLND13KhmzZrK9OnTnbYtXbpUAdSY4Ubp6elK8+bNlYULFyqKoijPPvus0qhRI6djli1bpoSEhCiTJk1SHnvsMSUwMFDp3r27089OURTFZrMpWq1WWbp0aa59dEXJVeARQojbSMK7D2E3xRbra2r9y1FmxveFbicuLg6AypUr57jfMQ0iNjbz+rp168b06dM5cuQIoaGhHD16lK5du2Kz2XjwwQdJTk7m2LFjJCUlFbjy+qJFi/jggw9YtGgRL774Ij4+PvTr148PPvhALWrnyjGu6tGjh9PQ3L/++gubzcaOHTvYvn07kFnozs/Pjz179jBy5Ej12KyjfMqWLUu1atW4ePEikDlqx2g0MmTIEPWYsWPHOhVZu1FGRgZpaWlOxVtDQkKIjIxk5cqV9OvXD6PRSLNmzZzOe/DBB9VpQv7+/gwbNoy//vpLrX9it9tZv349J06cwGQyER4ezn///YfVanV6ypPX9dwoOTkZgICAAKftZcqUUffdKCYmhgcffJBvvvmG8uXL5/o+uMrf35+EhIRCtyOEEKVNScQUULRxRW4xBWTGFY6Ywt/fn5YtW7J582aGDx+ujnrVaDTqSNmmTZuyefPmAscUPXv25K+//uKjjz5i2LBhpKen07RpU1599VV1toUrxxTE8OHD1a/tdju//vor/fr146233kJRFBRF4fLly+zduxdFUdTFAdq2bes07bR58+YsXLhQ/X7t2rV8/vnn6mjgwMBABg0alGctvfj4eKeYQqPREBwczJIlS2jUqBGVK1fG19fXqR5Ls2bNnBacGTduHB9++CHnz59XRw2fOXOGLVu2EBUVhc1mw8fHhyNHjtC+fXv1vPyu50bJyck5xhSOfTnFDdOnT6dmzZp5FvR1TDX29vYG4LXXXqNp06bMnj3baaqQVqvF19eX+Pj4XNtyhcvJlUqVKgGZVfQdX+fG1cIzQghxu7CbYrEnFH1xzeJQtmxZIHOloJxERkYCqEmI5s2bU7ZsWTZv3ky1atVo0KCBetOrWbMm27dv5+DBgwQFBdGoUSOntvKrueLj48PMmTOZOXMm8fHxbNiwgeeff54+ffqoqw24coyrbrxZX7lyBS8vr2xF6kaMGJFt5YAbi8Pp9Xp1GPCVK1cICgpy6ouHh0eeKxp5eHjg5eXlVMC1Z8+efPDBB7z++uuMGTOGTp06MXXqVKdCezfekytXrqzOX8/IyKBbt27ExMTQu3dvAgMD0Wq1WK1WkpOTnYZB53U9N3Icm5iY6PQeJiQkqL9PN5ozZw5Go5GdO3eyc+dOAMxmM3/++SdWqzXH+it5MZlM2YZxu2v48OFs27aNZcuW8emnn7Jt27Zcj122bFmBVkUSQoiCupVjCsj8h3/WaS83ioyMVOu2QeZDm9WrVwOZ9UCmTJkCoE43HjNmDEeOHOG1117L1lZeNVcA7r33Xu69916sVisHDx7ko48+UpM4jqk/rhzjqqz3xKSkJFJSUjAajU5xRa1atXj++eex2WzqQ4687sEpKSmYTKYc7/d5JVfKli3LuXPnnLatWrWKl19+mTp16hAaGsqwYcN48cUX1eRDTq8BmT+zOnXq8OWXX/Lcc8/Rr18/qlevrq5ueGNSoiAxheP4G6dOOx6g5FSM9+LFi3z22WdMmTJFjSt37txJdHQ0M2fOZMyYMdSuXZtq1ao5nVelShX69+/P5s2bneJRu91OcnJyrjGMq1xOrnz44Yc5fi2EECLzac+t+pqBgYE0atSI9evX88wzz2Tbv2HDBgICAtTlg7VaLV26dFGTK3fffbd6rCMQOnjwYIHmReekbNmyDB8+HEVRGDlyJBEREYSGhhb4GMDlhEtQUBDJycm88MILTkVhC6py5cpER0c7PZXKyMhQRwnlplGjRtnm+z7++OM8/vjjREdHs2jRIgYMGMCRI0fUxNWNDzSuXLmiPi3auHEjx44d48qVK2px2t9++42vv/7a7WsD1OJ2Z86ccVo95+zZs7kuy9m1a1c8PDwK9bpZnT59Os/ieAUxceJE7rvvPurUqaN+nRtZFVEIcbOVRExRlK/buXNnVqxYwfnz56lZs6bTvhMnThAREUGXLl3Ubd26deP9999n48aNJCUlqQumdO3alVmzZrF582Y0Go1TvFFQer2eNm3a8OOPP7Ju3TrWr1+fLXHiyjHgekzh6+uLl5cXbdu2VQvzusPHxwd/f/8c7/d5adSoET/99JPTtsaNG7N69WosFgv//PMPEydOJDExkY8//hjIOaaA/x/F/PbbbzN37lwmTJigHjN//nz3LiyLevXqZVsu+syZMwQGBuY4asXX15fXX3/drddSFMVpdUvIrGljt9sLHVe4nFzJGixdvHiRV155Jcfj3nrrrUJ1SAghbkVFMYy2JL366quMHDmSVatWMXDgQHX7wYMH+fLLL5k5cyZGo1Hd3q1bN2bOnElwcDBvvPGGur1r16588MEHnD59mo8++qjA/di4cWO2qvOnTp3CaDQSFBTk8jE3CggIyDcIAejTpw8Gg4H33nvP6YnG1atXSUlJyRYk5ubuu+/GbDazYsUKdVjxd999h91uz/O8e++912nUxNGjR6lRowa+vr4EBQUxZcoUXnrpJS5duqQmV3744QfGjx+PTqfDZDKxbNkydRRIamoqer1efTJmt9uLJAiqWrUqrVu35ptvvuHee+8FYP369YSFhTF48GD1uO+++w5PT09GjhypPhnM6sMPP6Rv375uBZ3btm0rsiL6PXr0UL/etGkTnTp1yraiEsDixYtJT08vktcUQojc3OoxxcMPP8z777/P1KlTnVYLMpvNTJ06lbp16zJixAj1+E6dOmEwGHj99dfp0KGDerxjGuxHH31Es2bN8hz9mZN9+/ZRp04dp1GOkZGRJCUlqYVTXTnmRo7pK0lJSXh6eub6+jqdjoEDB/LJJ5/w0EMPqVN07HY7+/bto23bti5fyz333MOiRYsYPXo0Go1GLY7boEGDXM/p1asXjz32GKdOnaJevXqkpaVx6tQpmjdvjsFgoHv37tx9991cuHBBPefw4cMcPHhQnRq0cOFC6tSpo8Y/qampTte8evVql+Kr/AwZMoSnnnqKiIgIdbWgxYsXO02vPnbsGMuXL2f69OmUL18+20jo5ORkTCaT0/Z9+/bRpk0b9fvLly+zZs0axo0b53Tutm3bqF69OvXr1y/UdbhVc+XVV1/NNbmS1z4hhBAla8mSJdmG6o4ZM4YRI0YQERHBqFGj6N27N40bN+bSpUusXLmSyZMnZ1vutnv37jz99NMkJiY6PdXp2rUrDzzwAECOI1eioqJynBb02muvodVq+fTTT5k6dSpt27YlKCiI48ePs2HDBj766CN11IMrx9yoe/fuPPjggzzzzDMEBATkulJNpUqVWLRoEQ8//DA7duygRYsWXLx4kUOHDqkrG7giODiYV199lQcffJB169ZhtVrZunVrjkNbs5owYQLvvfce4eHhhIaGcuHCBQYNGkSHDh0IDg5m48aNNGrUyOk9j4+Pp1OnTrRv354///yTcuXK8cQTTwCZK/j4+/tz991307lzZ/755x+uXbvm8nXk5YsvvqBHjx706dOHGjVq8PPPPzNt2jSnVZu+++47ypQp41SrJj9///0327ZtU+u9zJ07F39/fwYPHqyOnjp9+jRHjhxhzZo1RXItWX377bdUrFgxx+TKt99+S6VKlXLcJ0RJMJkSiY+LIzCwHH5ZaisIURzOnj2b7Z5ev359Ro4cydq1axk0aBCNGzemf//+KIrCb7/9hre3N3/++afT/drX15c2bdqwc+dOpwf1Wq2WTp068ccffzBt2rQc+7BgwYJsq9n07duXu+66izNnzjB06FBatWpF7dq1MZlMrFy5krZt2/Lwww8DuHTMjerWrUtISAgPPfQQd911Fy1atMj1/v7xxx9zzz330LhxY+677z5sNhvbt29n4MCBBUquvP3227Rv356uXbvSunVr/vjjj1wfKDlUrVqVfv368eOPP/Lmm2+iKArjx48nMDCQZs2acfXqVZYvX+60yl9oaCgDBw5kwIABREVF8dtvv7Fq1Sq1tttjjz3G1KlTOXDgAAkJCaxZs4YKFSq4fB25efjhh1m6dCmdOnXi/vvvZ8eOHaSnpzs9wDt27BizZs1i0qRJ+cZTDsuWLeOJJ56gXbt2mM1mli9fTrNmzXj55Zedjlu8eDETJ04s9HVoFCXL2pKunqTRkNNpp06dolOnTkUWuJUkk8lEQEAAiYmJToWAhChqEhiVXrfT50B6ejqzZ8/OcZ9jXipkPq1Zu3YtV65coVy5cvTs2dNpCT8HRVF4++238fHxyTaV6P3338dqtfLSSy85bV+7dq263N+NHMkVyAx0tm/fTnR0NJUqVaJnz55UqVLF6XhXjrnRtm3b2Lt3L8nJyYwfP56dO3fi7e1N//79sx0bFRXFmjVruHbtGnXq1OHee+9Vp9VA5tLFo0ePdnpvPv/8c1q2bOk09/uff/5hx44dhIaG0rdvX7799lt69uypJglyMnnyZDw8PJg3bx6QuYzj2rVriYqKok6dOvTr1099qqfX6/njjz/Q6/UcPnyYwMBARowYoc6dhsw5y8uWLSMmJoaGDRvSsmVLFi5cyIsvvqg+fXL1em505coVVq1ahclkokOHDtlqkWQduZKTd955h549e6pDwOH/kys3yppcmThxIj4+PsydOzfXvrmrZ8+evPjii9lGR5nNZho2bMiKFSuyFRXOz+30WSJKD5MpkT27d2C329FqtbRr10niiFLsdvscWL58OceOHcu23ZFcAbBarWzYsIGjR48CmTXbevToof5DPas///yTvXv38sADDzhNv3TcE7LeAyCzSPpnn32WY98cyRXIrFeyceNGTp8+jY+PD40bN3aakuTqMTeKiopi1apVREdH07RpU5o2bcr333+f4wMkm83GunXrOHr0KGXLlqVr167q9FrHtZtMJqd75d69e9m7d6/TyM6rV6+ybNkyADp27EhSUhJnz57Ns6DrwYMH6dOnD2fOnMHPzw9FUdi0aROHDh3C39+fPn36qNOpn3zySSIiIpg3bx4bN24kISGB/v37ZxvNsW7dOg4ePEjZsmW57777+P3332nYsCGdOnUq0PXcyG6389tvv3HixAmCg4MZMmSIUxIl68iVnJIr69ev5+zZs9kWDzh+/DhbtmxBURSaNm2a7Wf777//0r9/f06ePFnov5sFSq44hkZdvnw5WxBrt9u5du0a48eP54svvihUp0qD2+0DUJROEhiVbvI5IEpCbGwsX3/9Nc8//7yacMqNI7ly43Sb25nNZmP27Nk8+eST2VYWKIxRo0bxzz//EBMTg5+fX7ZRUHFxcVSvXp3Dhw+ryS1XyWeJuBkuXbzAyZPH1e/r129Eteo1SrBHIi/yOSBKyqJFi2jevHm+DwYcyZVVq1YVT8dKiTVr1uDl5VXg1ahyUqBpQY5hWo888ki22ioGg4Hq1avTsWPHQndKiDtFfFycWoPBbrcTFxcryRUh7nDlypXjxRdfLOlulFo6nS7bcN6i8Mgjj3DPPffwwQcf0K9fPxo2bKju02q1VKhQgbvvvrvAiRUhbpbAwHJotVr1AU1gYMkUQRVClG65TW8Smfr161dkbRUouTJ27Fggc4mpnIZRCyEKRgIjIURhvPbaazlO2xIF17t3bwAaNGhArVq1clydQIjSxM/fn3btOhEXFytTi4UQhda3b19MJlNJd+OW5lbNlTuBDN0TxSXJZJLAqJSSzwEhRFGQzxIhhHwOCHH7c2u1IIBDhw7x66+/EhYWhtVqddr3448/FrpjQtwp/Pz9JakihBClSHR0NN999x1nz54lNTXVad+MGTPUZbCFEEIIIRzyrpSXixUrVtC+fXuOHDnCokWLsFqt7Nmzh8WLF5OcnFzUfRRCCCGEKBZhYWHUq1ePP/74gz/++IOoqCjOnj3L4sWLOXPmDBqNpqS7KIQQQohSyK3kyhtvvMH333+vVhJesmQJJ0+e5IknnijSyv1CCCGEEMXp448/Zvjw4Wzbto2GDRvy4osvsnv3bpYuXcrVq1epW7duSXdRCCGEEKWQW8mVU6dOqVV19Xo9qamp6HQ6XnvtNf74448i7aAQQgghRHHJGuMYDAZ1WtCwYcPw9/fn6NGjJdk9IYQQQpRSbiVXMjIy8Pb2BiA4OJhTp04BYDabycjIKLreCSGEEEIUo/T09BxjHACLxSJxjhBCCCFy5HZBW4eBAwfyyCOPMHLkSFatWsXdd99dBN0SQgghhChZAwcO5OGHHyYtLY3Tp08TExND48aNS7pbQgghhCiF3Bq5smHDBvXrd999l27durFq1Srq16/PggULiqxzQgghhBDF6YMPPqBly5YADBgwgLfeeotNmzYRFxfHH3/8ga+vbwn3UAghhBClkUZRFKWkO1EayVr0Qgj5HBBCFAX5LBFCyOeAELc/t0auCCGEEEIIIYQQQohMLtdcqVSpEgBRUVHq17mJiooqXK+EEEIIIYqJY+nlZcuW8emnn7Jt27Zcj122bBmdO3cuxt4JIYQQ4lbgcnLlww8/zPFrIYQQQohb2cSJE7nvvvuoU6eO+nVu6tSpU4w9KziTKZH4uDgCA8vhJ1MPhBBCiGLjcnJlzJgx6tf33XefzBUsIRI0CSGEEEWrR48e6tfe3t63bIxjMiWyZ/cO7HY7Wq2Wdu06SawghBBCFBO3aq5UrFiRESNG8Pvvv2OxWIq6TyIXjqDp5Mnj7N69nSSTqaS7JIQQQtxWhg4dSpcuXZg/fz7x8fEl3Z0CiY+Lw263A2C324mLiy3hHgkhhBB3DreSK4sXL8ZqtTJs2DAqV67ME088wa5du4q6b+IGEjQJIYQQN9e7775L06ZNeeWVV6hUqRKDBw/m119/JSMjo6S7lq/AwHJotZmhnVarJTCwXAn3SAghhLhzuJVcGTx4MCtWrODq1au89957nDhxgk6dOlG7dm1ef/31ou6juE6CJiGEEOLmatWqFZ999hmRkZH8+uuveHp68uCDD1KpUiUee+wxrly5UtJdzJWfvz/t2nWifv1GMiVICCGEKGYaRVGUomjo+PHjPPDAAxw+fJgiarJElda16JNMJuLiYqXmihDFoLR+Dgghild8fDyPP/44S5YsYcOGDfTs2bNA58tniRBCPgeEuP25XNA2JxkZGaxZs4bFixezZs0aAgICmDJlSoHbiYmJ4eLFi9SrVw8/P788jw0LCyM6Otppm5eXF40aNcp2bHR0NNHR0dSsWRNvb+8C96s08vP3l6SKEEIIUQx27tzJ4sWLWbp0KcnJyQwbNox69eqVdLeEEEIIUQq5lVzZvHkzixcvZvny5VitVu6//35WrlxJr1690Otdb/Lw4cN88MEHrFu3jpiYGDZv3szdd9+d5znvvPMOS5cupWbNmuq22rVrs2TJEvV7s9nMI488wooVK6hcuTLXrl3jo48+YsKECQW+ViGEEELcOU6fPs0PP/zA4sWLuXTpEnfffTfvv/8+Q4YMkafNQgghhMiVW8mV3r1707NnTz777DMGDRqEj4+PWy++b98+7rnnHmbNmkXt2rVdPq979+4sX7481/1vvfUWmzdv5syZM4SGhvLLL78watQoWrZsSatWrdzqqxBCCCFuf0888QQxMTE8/vjjjB49muDg4JLukhBCCCFuAW4lVy5fvkxQUFChX3z8+PEAREREFOg8i8XCf//9R0BAAFWqVMm2f8GCBYwfP57Q0FAARowYwRtvvMHChQsluSKEEEKIXC1evLhIYhwhhBBC3FncWi3IEXQkJiZy8ODBIu2QK37//XcGDhxIo0aNqFWrFhs3blT3XblyhStXrtCmTRunc9q2bcu///5b3F0VQgghxC3EEeNkZGRw/PhxkpKSSrhHQgghhLgVuJVcSUxMZOjQoZQpU4aWLVuq2wcPHsyePXuKrHM56dGjB+Hh4Zw+fZpr164xYMAABg0axMWLFwGIjY0FoFw552WKy5cvr+7LSUZGBiaTyemPEEIIIe48b775Jv7+/jRu3FiNa+bNm8eHH37o0vkSUwghhBB3HreSKy+++CImk4njx487bX/sscd44403iqRjuRk2bJg6FchgMPDhhx+i1WpZtWqVug0yA5us0tLS1H05effddwkICFD/OKYUCSGEEOLOsWLFChYsWMDatWvp0qWLun38+PHMmTOHtLS0fNuQmEIIIYS487iVXFm9ejVff/01DRs2dNretm1btm7dWiQdc5Ver6dChQpq3ZaQkBA0Gg2RkZFOx0VGRlK1atVc25kxYwaJiYnqn/Dw8JvabyGEEEKUPqtXr+a1116jW7duGI1Gdbuvry/BwcEcPnw43zYkphBCCCHuPG4lV+Li4tRpNxqNRt2ekpLi9H1RuHTpkjpCRlGUbCNSzp8/z8WLF2nQoAEAPj4+tGvXjjVr1qjHpKWlsWnTJnr06JHr63h4eODv7+/0RwghhBB3ltxiHHA9zpGYQgghhLjzuJVcadWqFatXrwacA48PPviAdu3audxObGws+/fv58iRIwCcOnWK/fv3O406efPNNxkxYgSQuUpQ69at+fzzz9m6dSs//PAD9957L40bN2b06NFO5yxbtoxZs2axfv16tT7MxIkT3blcIYQQQtwhcotxfvvtNyIiImjSpElJdU0IIYQQpZhbSzG/88479O/fn3/++QdFUZg1axbr1q3j33//ZcuWLS63s2vXLmbOnAlkBjNff/01X3/9NY899hiPPfYYANWrVyc5ORkAo9HImjVrmDdvHsuWLaNs2bJMnjyZxx9/HA8PD7XdHj16sG7dOj777DPWr19PkyZN+Oqrr+TJkRBCCCHyNGXKFFq1asWAAQM4f/48S5Ys4auvvuLXX39l9uzZeHt7l3QXhRBCCFEKaRRFUdw58cCBA7z//vvs378fu91Oy5Yteemll2jVqlVR97FEmEwmAgICSExMlKSMEHco+RwQ4s509epV3nnnHTZu3EhSUhI1atRg0qRJjBo1yq325LNECCGfA0Lc/txOrtzu5ANQCCGfA0KIoiCfJUII+RwQ4vbnVs0VIYQQQgghhBBCCJHJ5ZorZcqUcbnRhIQEN7oihBBCCFH8Bg4c6HLNuNWrV9O1a9eb2yEhhBBC3HJcTq5899136tdHjx7l3Xff5dFHH6VNmzYA7Nu3j2+++YYZM2YUeSeFEEIIIW6W559/nrFjxwKQmprKxIkT6d69O/369cPPz48zZ84wf/582rdvT8OGDUu2s0IIIYQoldyqudK1a1eefvppBg0a5LR95cqVfPzxxwVaMai0knmRQgj5HBDizvPmm28SFRXF//73P6ftly9fpkWLFpw7dw4/P78CtSmfJUII+RwQ4vbnVs2VgwcP0qNHj2zbe/Towb///lvoTgkhhBBClITcYpwqVapQvXp1Tpw4UQK9EkIIIURp51ZyJSAggJUrV2bbvnLlSsqWLVvoTgkhhBBClISAgABWrVqVbfuZM2c4duxYgWrQCSGEEOLO4XLNlaxef/11xo8fz5o1a2jTpg2KorB//35WrlzJ/Pnzi7qPQgghhBDFYtq0aXTs2JEOHTrQp08ftebKTz/9xODBg6lbt25Jd1EIIYQQpZBbyZXx48dTr1495s2bxzfffANAw4YN2bJlCx07dizSDgohhBBCFJcmTZpw5MgR3nvvPVauXEliYiI1atRg3rx5jBkzpqS7J4QQQohSyq2CtncCKTolhJDPASFEUZDPEiGEfA4Icftzq+aKEEIIIYQQQgghhMgkyRUhhBBCCCGEEEKIQpDkihBCCCGEEEIIIUQhSHJFCCGEEEIIIYQQohAkuSKEEEIIIYQQQghRCC4vxVymTBmXG01ISHCjK0IIIYQQxW/gwIFs2bLFpWNXr15N165db26HhBBCCHHLcTm58t1336lfHz16lHfffZdHH32UNm3aALBv3z6++eYbZsyYUeSdvB2ZTInEx8URGFgOP1mOTQghhCgxzz//PGPHjgUgNTWViRMn0r17d/r164efnx9nzpxh/vz5tG/fnoYNG5ZsZ4UQQghRKmkURVEKelLXrl15+umnGTRokNP2lStX8vHHH7v89Kc0u5lr0ZtMiezZvQO73Y5Wq6Vdu075JlgkGVN48h6KgrqZnwNCiNLpzTffJCoqiv/9739O2y9fvkyLFi04d+4cfn5+BWpTPkuEEPI5IMTtz62aKwcPHqRHjx7Ztvfo0YN///230J263cXHxWG32wGw2+3ExcXmebwjGXPy5HF2795OkslUHN28rch7KIQQwhW5xThVqlShevXqnDhxogR6JUqKyZTIpYsXJG4QQgiRL7eSKwEBAaxcuTLb9pUrV1K2bNlCd+p2FxhYDq02863XarUEBpbL8/iCJmNEdvIeCiGEcEVAQACrVq3Ktv3MmTMcO3asQDXoxK1NHswIIYQoCJdrrmT1+uuvM378eNasWUObNm1QFIX9+/ezcuVK5s+fX9R9vO34+fvTrl0n4uJiXZqi4kjGOKYR5ZeMEdnJeyiEEMIV06ZNo2PHjnTo0IE+ffqoNVd++uknBg8eTN26dUu6i6KY5PRgRqYVCyGEyI1byZXx48dTr1495s2bxzfffANAw4YN2bJlCx07dizSDt6u/Pz9Xb5BFzQZI7Irbe+h1H8RQojSqUmTJhw5coT33nuPlStXkpiYSI0aNZg3bx5jxowp6e6JYlQaH8xI/CCEEKWXWwVtly9fztChQ29Gf0qN4iw6FXk5goiIMEJDq1E5uMpNfS1R8twpaCxKhhSfE+LO888//1CvXj2CgoKKrE35LLl1JZlMperBjMQPty75HBDi9udWzZVRo0apwyRF4URejmDtX79z5Mgh/vrzN65EXpbiabc5qf8ihBCl1zvvvMOhQ4dKuhuilPDz96da9RqlIokh8YMQQpRubiVX6tSpw7Fjx4q6L3ekiIgw7NcHD9kVhbNnTknxtNtcQQsaCyGEKD4S44jSSuIHIYQo3dyqufL000/zwAMP8O6779KwYUOMRqPT/pCQkCLp3J0gNLQax44exq4oaDUafHz9SE1LBaR42u2qtNV/EUII8f/Gjx9P37598fPzo3Pnzvj6+jrtr1ChAh4eHiXUO3Enk/hBCCFKN7dqrmg0mjz3u9FkqVOc8yKvRF4mPPwSoaHV8PX1Y/fu7bnOp5VCZkIUH5kfLcSdp2fPnmzatCnX/Rs2bKBnz54FalM+S4QQ8jkgxO3PrZErJ06cKOp+3LFMpkQSEuLx8/PH19cvz6cSkZcj2L1rO0ajEQ9PzxwLmUnyRQghhHDft99+S0pKSq77q1atWoy9uTkkVhBCCCGKnlvJlfr16xd1P+5IJlMif29cR1TUFXQ6HcFVQujSpXuOyzSbTIns3r2duPg4NBqoGFQp25QhqSIvhBBCFE5oaGhJd+GmklhBCCGEuDncKmgrisbliHAiIy+TlpZKSkoKCfFxnDhxzKmIrWPloMsR4RgMRjQaUBQwm83ZCplJFXkhhBBC5EViBSGEEOLmcGvkitVq5YsvvmDZsmWEhYVhtVqd9kdERBRJ52538XGxpGekY7Pa0GhsJCQkcPVqFImJCbRr14mkJBP//LMZRVHw9PTEYDASFFSJ1NQUqteola09RxV5x9MoqSIvhBBCFNz69euZN28eZ8+eJTU11WnfkiVL6NSpUwn1rPAkVhBCCCFuDrdGrrz99tt89NFHDB48mEuXLvHKK6/Qu3dvoqKiGDlypMvtpKWl8d1339GuXTvKlCnD9u3b8z3n0KFDPPjgg9SqVYt69eoxbty4bMmcadOmUaZMGac/HTp0KPB13kyRlyM4c+Y0Go0GnU6HwWDAz8+XjIwMMtLTiQgP459tm4m6coWrV6O4Fh1N5cpVqF2rLh5GD86fP8u2bX+TZDKpo1sA2rXrRP36jWSYrxBCCOGG7du3M3jwYFq1aoXBYGDEiBGMGTOG1NRUmjRpQq1a2R9u3EoUFEJCqlK1ag2JFYQQQogi5NbIlUWLFvHLL7/Qpk0bnnnmGSZOnMikSZPo2LEjP//8s8vtzJw5k6ioKJ577jmGDh2abQTMjWw2G+PGjWPatGnMmjWL1NRUnn76aXr06MHBgwfx9vYGIDU1la5du7Jo0SL1XJ1O586lFilHATmjwcju3dvJyEhHA+j0evz8/cgwWzBb4tFqNARXCQUU0GT+z2az4eXlDYpCbFwMipI58mXTxrUkJibi5e0FCtSuU5c6depLsCSEEEK44fvvv+fll19mxowZ7Nq1i3vvvZdevXrxyCOP0LFjR/z8/Eq6i267sd5KSMjtXV9GCCGEKE5uJVfCwsJo0aIFAF5eXiQlJeHv78/w4cN56qmnXG5n9uzZaDQal6cR6XQ6Dhw44LRt/vz51KpVi927d9O9e3d1u8FgoEyZMi735WZzBDTp6enExsag2BUsFjMAWq0WnVaPwcuIXq/Hx8cXLy8vPDw9MegNAFSqHExAmQDOnTmN3WZHURRSUlNINCVmFmEB9Ho9cXExXLkSqRbGFQUjKygIIcSdLSwsjMGDBwPg7e1NUlISAPXq1aNWrVocPXqU9u3bl2QX3ZZTvRW51wkhhBBFw61pQTabDb0+My9To0YNdTrPqVOn8PLycrkdjUbjzss7SU5OBsj2ups2bSI4OJgGDRrw2GOPcfXq1UK/VmHEx8WRnp7OlSuXiY+LIzb2GunpGdjtdnx8vElLSyU5yURiQjxxsTEkmUyYMzLwDwigTJkyBPgHsH3bZmJiroFGg9HogU6rQ6fN/BEqinL9SZSOpCRTtsK4In+OBNjJk8fZvXu7vH9CCHEHslqtOcY4aWlphIWFFSjOKW0c9VYAqbdShBzTsyVuEEKIO5tbI1eymjRpEqNGjaJ9+/bs3buXMWPGFEW/XGK323n++edp0KABbdq0UbdXqVKFTz75hK5du3L58mWee+45OnbsyOHDh/Hx8cmxrYyMDDIyMtTvTUV4gzSZEklNTSU1NRWbzQZkjsLRarXYbDZSUlKw2e2ULRtIbEwMFouVnTu3YTR6AJmJk2sx11DsCt4+3lQoH0T58kFEXY0kMvIyaDQodgUvLy80Gg1JJhPRWQrjKigyGsMF8kRPCCFEVo8++ijt2rXj0KFDhIWFUaFCBRo3bpzveTczpigMP39/2rXrRFxcrMQERUSWthZCCOHgVnLFYrGoX0+ZMoWqVauya9cuRo4cyUMPPVRkncvP008/zd69e9m2bZv6lAng1VdfVb+uWrUqK1euJCQkhCVLljBu3Lgc23r33XeZNWtWkfcx603Xw8NIgH8ZtBoTGRnp6PUGjEYNer2OjAwz6WlpaHVatFoNdrtCamoKgHrDttvtaDQaTKZE2rXvRPMWrThz5iQpySlUDq6CxWLh2rWrmBITMBiN2O12IiLCiIgIk5u+C2QFBSGEEOvXr1dH1jZr1oydO3eyatUqfHx8mDBhglO8kZubEVMU1bRVP39//Pz91dEWkmQpHHkwI4QQwsGt5MqNgcX999/P/fffXyQdctX06dP54Ycf2LBhQ75PkSpUqEC1atU4depUrsfMmDGDadOmqd+bTCZCQwtf6C3rTdfLy5t69RqSlpZKWNglUlNSiI+PIzXVDCgYjb7Y7DZsVhs2W2ZxX+V6PRVHGxaLmfT0dP79dx9dunSnZau7svQ5EYC4uBjSkzLUocvp6elkZGTg4eEhN/08yBM9IYQQjmkzDi1atFDrzLmqqGOKoh4dIaMtio48mBFCCOHgcnLl0KFDLjfavHlzN7riuueff54FCxawYcMGWrdune/xKSkpREREEBQUlOsxHh4eeHh4FGU3gew3Xb1Bz4kDx4mJicZuV1CUzO2KohAfH4deb0SjUdDp9CgoKHa7OmJFURT0egM6vZ6kJBMHD+6nQoWKhISEoqCoBXOvXbt2fTUDLwwGA9eir2JXFLQaDUajsciv8XbieKInhBDiznHu3Dm1cG1+ateuja+vb57HFHVMUdSjI3JqT6YQu0cezAghhHBwOblSkKc2jtEWReGpp55i//797Ny5E8h8GvT111+zYcMGpzorDhkZGUyaNIkZM2ZQp04doqKiePLJJzEajYwaNarI+uUqx003IiKMtNRU9u3ZxbWYaKwWC1qtDpvN5rQEtcViAY2GzAHJmeswO4Yna7VaFBRsVguxMTFEX426/pSkPPUbNMJut5ORkaEen5aWxpXIywQFVcws/KvRkJCQQOXgKsX+PgghhBCl1cSJE9m0aZNLx27YsIGePXve5B45K+rREY720tPTsZjNWCxmGclSCPJgRgghBBRgtaD4+Hj1z9dff02tWrVYtmwZFy9e5OLFiyxbtoxatWqxYMECl1/8p59+okyZMjRq1AiA/v37U6ZMGWbPnq0ek5qaqhaCi42NZfbs2aSmptKrVy/KlCmj/vnhhx+AzKdFPXv2ZOjQoXh7e1OvXj3S09PZsWMHVaoUf1LBZEokIiKM8+fP8t+JY0RFXcFiNmO327HbbTmvmKQo1xNUyvW6LEaMRiMVgioSXDkYP78A0tJSSU9PJzU1lStXIjl54hhWqxWtVos5I4P4uDhirkUTdTUKq9VGSmoyKSlJnD9/5paqZi8V+IUQQtxsq1evVmOcgwcPUqFCBebOncupU6eIjIxk69at9O7dmzFjxnD33Xff9P7YTbFYoy6q3zse1NSv36hIEh9+/v40atwUi8WMwWjkyJGDZKSnZ7729ZEstyqJG4QQQpQUjeLGMJMmTZrwww8/ZJv+c+jQIR566CGOHDniUjtms5nU1NRs2z09PfH09AQyR19YrVb8/PxQFIXExMQc2/L29s425cVsNrs9DcZkMhEQEEBiYiL+bgYxjjnNiYmJxMfFkpaWRnp6mtMxjuk+udFoNOj1BjQaCA4OwWq1kpiYQFKSyemYysFVqBIcwvkLZ7HbFZKTkvDy8sJgNFCtak0SEuPVIcoVK1aiQYPGpf4pi8wJFyWtKD4HhBC3lmeeeYYqVaowffp0p+1ms5nq1atz8OBBKlasWKA2Xf0sUew20v/5ldTVn6OrEErAC9+i0eqytFM0RW0BLl28wMmTx4HMa7OYMxMtFrOZ9h0635KjXCVuEKWZxBRC3P7cKmh79uzZHAuzhYaGcvbsWZfbcYzIyIujKCtkJhHKlClToPZLUnxcHOnp6Vit1usrLGVPohgMmX00mzOy7YPMKVYajYZy5coTFxdLenq6WuzWQavVkpGezrFjh7HZbNeTNRoUFOw2OwqZyzTb7XauRV8FUJdpLs1Bh1TgF0IIUdzOnj1Lu3btsm03Go1UrFiRc+fOFTi54jJFIX3bCpS0ZKxhJ0jftgKvu4cDRZ84yDrVyNPTk2pVa3DkyEF8fHz499991EyIJySk6i1135W4QQghRElyeVpQVvXr1+eNN95wqhVitVp54403qF+/fpF17lZnMGYWk01OTkKj1eLh4ZXDEo7K9ZUJcpge5DhCUTCZEklJScFszsBmy5xOpNXq8PDIHOWTkpKc+eTJYsGuKOj0Ovz8MgOKjPQ0LGYzGsDX15eMjAzS09NL/bBfR+AHSAV+IYQQxaJ+/fp89NFHxMfHO21fvnw5J06coFatWjfttTU6Pb6jZ6jfp67+HHtiDJBz4sAdjmkzgDrVqHGjZpw9d4r0jHRiYq4ReTmC48ePsnv39ltqeo3EDUIIIUqSWyNXPv/8c/r378/y5ctp3rw5iqJw6NAhzGYza9asKeo+3rIsZgtlypbFlJiYWTDOZkGjybzp63R6QMHLy5uUlGQ0GshtdpDNZkWr9URR7Oo2RVHw9DRityt4e/uQnJyMzWYDwG6z0bx1ezy9PIi+GoUCxMbF4OnhRWzsNTw9M5M8ro7sKcphyAUhFfiFEEIUtxdffJGNGzcSGhpK27Zt8fPz48yZM5w+fZqPPvro5o1auc5QqxkeHe4jY+dvKOkppKyYh9+jbxVJUducRr9Uq16DSxcvYDAY0WjAYrOiQYOHh8ctN/pD4gYhhBAlya3kSvv27Tl//jzff/89//33HwB9+vTh4YcfljmEWRgNRhLi40lNTSUtLRVFUdBenztts9tAUTBbzNhs9nxagvSMDOw3ZF/S0tLQaDTExcVht9vU7TqdDo1GoUGDxly7Fk18bCx2mx2dXo+npxdeXt6ULVsWs9mc7+uW9PxlqcAvhBCiOJUrV479+/ezfPly9uzZQ2JiIq1bt2bUqFE3ddRKVj6DpmA+vBUlJZGMfevw6HAffvXvKnTiILdpM4GB5fD09CQoqBKpqal4eGRO2y5oEqekHsZkJXGDEEKIkuJWcgUgICCAKVOmFGVfbjtmixlfXz/i4mLVorVqEuT692k5FPS9kd1uB6vl+sLMzhRFwWazOq06ZLPZSUpOIupqJMnJydgVG2azGXNGBhqtljJly+Lh6akGTHkFQ7f7/OXSEAgKIYQoXXQ6HSNGjGDEiBEl8vpa3zL4DJpC8o9vAZDy83sYXvnZ5cRBTvc2kymR1NRUrFYrer3eKXFy44gPIMckTl73zJJ+GFNcJG4QQgiRG7eTK6mpqZw8eZK4uLhs+3r27FmoTt0uDEYDCYnxanKiMJzbyJ5mybrikEaTuQrApYsX0Gg0pGeko9gz67ZUrFSZ2rXrqkXq8guGimIYcml1pwSCQgghCsZms3Hq1CmioqKy3cNbtmxJYGDgTe+DR/sBpO9cjfX8UWzRYaRt+AHvvuPyPS+ne5uCwj/bNpOWloZer6dmzdrZitUqWeKKnJI4+d0zb/eHMSBxgxBCiLy5lVxZv349o0ePJjY252JqbqzufNsxmRI5+O9+bFZb/gcXgCPRkRdFUUhLS8VozFx6Wbl+vNFoRKPR4O3towYD+QVDt/P85TshEBRCCFEwkZGR9O7dm+PHj+e4f8OGDcXyEEmj1eI7agYJ7z4Idhupa7/Fo8096CqE5HleTve21NQUoqIiUZTMBzDQ0GlEy+WIcM6fP6uOaMkpaZDfPTMwsBxWq5W0tDS8vLxuq4cxkPk+nTxxnIz0dAxGo8QNQgghsnFrtaCnn36a8ePHExcXh6Io2f6IzCAkKcmEotiLbEnozKWrPfM9zvFz0Gg0BAaWR6fTo9Pp1KHABqOBSxcvkGQyuVRZX8lhCelbmWOlBMd8cpBVBYQQQmSaPXs2lStX5sKFC9jt9mwxTnGOztWH1MGz2/WpSZYMkn/5IN84y7UVczLbcIzEOH78KFFRkZjNZjVp4LhXOlYLyq/d2y1WyMrxPl29GkV09FUsZrPEDUIIIbJxa+TKpUuXePXVV/Hx8Snq/tw2DEYDiYkJpF6vqaLT60HJXPnHXd7ePiiKnYwMTb7Bld5gwN8/gERTPBaLBUWxo9PpsJgtHPx3v9PTqbxGppT2IbAFnft84/U0btwMs9l8243KEUII4Z5Lly7x5JNPUr169ZLuCgDe/R/DfGAj9oRoLMd3Yj60GY8W3XM9PqcRpyEhValUKVgdVRISUhX4/9Eonh4eJAIZGRl4enpiMBpyvPfnFS/Ex8Wh1+vx8/MDuK1GdTjeJ6PRSIWgigRVrESDBo1vm+sTQghRNNxKrtSvX5+LFy/SqFGjou7PbcFkSiQiPAxPT09SkpMBDXq9Ti0+WxBarRaNJjOZYjIlZq4YdD2xotcbsFotOZ6nAeLiYsjIyFC32e120jPS0Gg1+Pn5qU+nqlWvkWuA4MrUmZIq7uZO4ufG6zGbzVSrXqM4uiuEEOIW4IhxSgutpw8+w54l6esXAEhZNgdjg3ZoPL1zPefGmil+/v506dI9W2LEaDCSkpKMwWCkUqVgtRZLXFxsjvf+vArqulKjrTQUg3WnD1mvzdPTUxIrQgghcuRWcmXy5Mk8/PDDfPDBB9SuXdtppRqAkJC85wPfzhz/4E9OMpGYkKgOoc0cPVLwIbN51VfJK1GTkZGR7fXS0tIoW1aDl5cXkJm4MRqMnPjvGEC24naQf7BUkiNb3KmZcjsX6BVCCFF4Dz74IAMGDKBChQq0a9cu29TeChUq4OHhUax9MrbohqFheyz/7cIeH03qmvn4DHk63/MciQSD0YDFbMm2etCx44cxGoyYzWZq165HUpKJ5OSkXO+VeSUm8hvZUhpGwrrbh9u5/pwQQoii41ZyZcKECQB0757zsNQ7ue6Ko9ZK9NWraDQabDYbGo0Wm61oC9vmLXOkS07Fb2Nioqlbtz5oMhMN/x7cR1RUJACVKgXTpUv3fAvaZg2uSrIorDuJEgmQhBBC5OXpp5/m4sWLPPDAAznuL66CtllpNBp8Rz5P/JsjwZJB2t9L8GjbD31InVzPcSQS0tPTuRZ9lQpBFfH09FQTCo77twKkpaWyffsWjB4eHDt6mD5978vx3u9YccjLyytbvADZR8yUlnjBoTB9cHUZbCGEEHcut5IrJ06cKOp+3DYMRgPRV6+SlpaGxWK+vvXmJFZyS2JptVp0Oi06nQ6bzYbF4pg6pMFms3P06CFCQqsSERGG2WzGZrVhs9tISjLlGGhkDShyqllSUiNB3E2USIAkhBAiN99++y0pKSm57q9atWox9ub/6SqE4H3vWFJ//wrsNpJ/nk3As1+j0ea8NoEjkZCRkYFdUcjIyMBoNKr3+cDAcqSlphIVdQWLxYLVasVut2O329m6dRNdu/agbGAgcXGxJCclcfbsKS5fDker1ZGYGE9ERBgNGjbOtb+lKV5wkNGrQgghbia3a66InFnMFoIqViLs0sUS64Oi2AEteoMBu92uJlkyVwdQ8PLyJikpCZ1Wi91mJz09DUWBJJMp35WNcqpZUpIjQXJLlJSGed1CCCFuPaGhoSXdhVzvYV69HiJjz1/YosOwnj9Cxq7f8ex4f45tOJZGtlqtKIqCh4eHU0JBQcFszkAhc6SrzWbFas2cwhx5+TK//baCihUrodPpuRZ9FQ8Pz8xRK55eaDQaYq5dI8lkcrlmW0nHC5D3QxmJG4QQQhSWW8kVkbvAwHL4+fkREODPtWvXSqQPiqJgtVrRZGSoT6IcKlcOJiU1hdS0VLQaDfUbNEKn06IAvj6+JCTEZ1s9J2vAkdNTn7xGgpREsFIa5nULIYQQ7sjrHqYxGPEZ+TymT54EIGXlp2TUbEFChi3bfdaxNLJer6dChQrUrl3XqbZafFwcXt4+GJOTSE9LR6fToyiZI1c0GshITycmJgY/X1/sioJOr8fbyxuDwYDFaiUhMZ7du7dnu8c67vtGo1GNF6xWK6mpqQQGlsuziHxxxAw5xSwSNwghhCgKbiVXrFYrX3zxBcuWLSMsLAyr1bmwakRERJF07lbkeCryj8VMTExMidWfURQFs9mcbXtU1BW8fXwoW6Ys3j6+lC0bSEpKshr8nD9/1mmZZgUlW8DRrl0nIsLD4IZCxjcqqWClNMzrFkIIcetav3498+bN4+zZs6SmpjrtW7JkCZ06dbppr53fPczYoC3G1r0x71+PkpLIlUVvc6n5gGz32RuXRvb29nFux2DEYjHj5elNclIyOp0Wm80Rs2iw2+3YrFbiE+Kx2xU8jEb8qoTg5+dPYmICRqMxW/9ymgqUEB/P+QtnCQu7QETEpVxjgVutQL4QQghxo5wn6ubj7bff5qOPPmLw4MFcunSJV155hd69exMVFcXIkSOLuo+3nKioSE6fPlUqC/va7XbsNhs6vQFPT08MegOeHp5UqFCRmjVro9fr1ePi4mJzDDgUFCIuhxEWdoHdu7eTZDLl+Fo5nVscHKNrAJlTLYQQokC2b9/O4MGDadWqFQaDgREjRjBmzBhSU1Np0qQJtWrVuqmv78o9zHfoM+CRuRRz+Uv/4h0Xke0+m1c7jpWCNEBsbAx2uw2r1YZOr6dO3XrUrlOXqtVqUCEoCBQI8PdHURRatmxDixat8fT0zLHdnKYCefv4ZIstclJSMQNI3CCEEKJouDVyZdGiRfzyyy+0adOGZ555hokTJzJp0iQ6duzIzz//XNR9vKWYTIns2L4Nc0ZGSXclRzqdDo1Gi7eXN3qdgc1bNqLRZK4u1KhRE6xWqzpyxRFc3DgNKC4u1qUnPK4s43wzhv/KikBCCCHc9f333/Pyyy8zY8YMdu3axb333kuvXr145JFH6NixozoS5GZx5R6WrDEQUbcLIUfXAlDl4O+c6DLO6T6bVzuORIbNrqDRcL0umwab1UpoaHXq1KnH7t3bSUxMRKvTotfrMRgzl2xWUAgJqQYoTtOMIPf7vitFZEuy2KzEDUIIIYqCW8mVsLAwWrRoAYCXlxdJSUn4+/szfPhwnnrqqSLt4K0mPi6OXAr3lyitVovRaMRo9MBmsxEWdhGz2YzVasXoYcScYebY0cMEVaxEzZq1nQKmnAKO/AIgR+KkceNm2Wq4OPbfzOG/siKQEEIId4SFhTF48GAAvL0zC8AD1KtXj1q1anH06FHat29/U/uQ3z0sPi6Oq9XbEHjhAN7J1/BPjqZC+CHAeYno3Nr5/2K3FjQaDTqdDkVR8PT0Ij09lRMnjhHgX4akJBN2m53ExETi4uLw9fUl9Viq+hAmJKRqttfLKWbIL3GRX8yQ9ZiblfyQuEEIIURhuZVcsdls6hDPGjVqsH37dvr27cupU6fw8vIq0g7eagIDy6HXG0q6G9nodDrSMzIwWywodjtGxxMoRcFqzVyqOSUlmWvRV6lXr6FTgHFjwJHfEx5XEicyv1kIIURp5BjBCf8f4wwePJi0tDTCwsJKRZwTGFgOrV7PqTrdaHFwKQBVT24h7vJQ/Pyb5nu+o9gtgNHDE6vVqq4YdPjwQTRoSElJvv5AxopGo8FisXDw4AH0Oh1lypRVR7LeeO/OKUmRX+H73GIGtTiuwcix44el4KwQQohSrdCrBU2aNIlRo0bRvn179u7dy5gxY4qiX7csP39/6jdozNWrUVgslpLujsrRF7vNBkBGDtOWbDYbZnMGaWkpXLp4gcDAciQlmYiICCM0tBqVg6uox+YVKOWVOMlpFQGZ3yyEEKI0evTRR2nXrh2HDh0iLCyMChUq0Lhx45LuFn7+/jRu1IwzHp5EXzlKUNQJ9JY0jHtWQoP8kyuO+7TJlEhKcrJ6z9bp9FgslusrB4Gi2LHZ7disNkDJLH5vsRAdfZW09DRatW5b6GvJLWbImnRJSUnGaDBiyKGIrhBCCFFauJVcyZo0mDJlClWrVmXXrl2MHDmShx56qMg6d6vS6XXX5y/fWhQFbHaFsLCLXLsWTVpqKtdirqHY7Rz8dx89evahdp26+baT27zpnFYRyG347+2mJJakFkIIUXDr169Hc301vGbNmrFz505WrVqFj48PEyZMUEe1lCRHQVq73U5Eo16Uj72A1pKOfe8aLN2GYajWMNvxl8PDQaMhJCQUo8FIXGwM6Wlp2BUFmy1z+WWN5nrtFVtmMsVo9MBut6No7djt/z/aRVEU9Dq906qEJlMilyPCAbLVYslLbjFD1qSLwZA52tZw/cHMnfRARuIHIYS4dbgVIdx7771s3LhR/f7+++/n/vvvB6Bnz55O++40kZcj2L5tsxoQlFaOQMZBp9Ph4eFJmbJlsVozE0NJSUlYzBlYrFZQYPfu7VSsWCnfm3tu04ZyWkWgWvUaN+kKS4+SXF5SCCFEwbz44ouMGjVKrS3XokUL9evnn3/eaV9JyXo/VXzLYuk4FI8tP4KikLLkAwKeW0hSchLxcXEYjAYO/rufqKhIAMoFVgCNQnp6OlarFZvVmtmOkhkL2Gw2dDodRg9vqlarQWJiPNHXR+M6XlOj0ZCWls7x40cwGo34+Pry98Z1REVFotXpqFIllC5durt0r8stZsiadPH09KR167Z3zAMZB4kfhBDi1uJWcmXTpk05brfb7WzevLlQHbqVmUyJ/PPPFlJSUkq6K7lyLDVoNBqx2WzY7QoBAQFYrVbKlC2Lp6cnqSkpJFgteHp5kpycBAqgAW9vH5eH4uY0bagkVwIoSVJfRgghbh3//vsvvXv3znHf/v376dOnTzH3KLsb76d+vR/EdnIHtqgLWC8e4+pfP3DUUCFzSk1yMmaLGbPZcr3GWgxGgxGdXo/BkDnNRlEUNJrMESuenl7o9XpsdhsZ6WkYDEbKV6hITEy0uhKi3W4nLS2VE/8dIzw8jCZNmhEVdYWMjMyRLElJJpfvdbmNzJAVfCR+EEKIW02Bkitnz57N8WvI/NDfuXMnVapUufG0O0Z8XBzpaakl3Y08KYqCokB6erq6LcOcQVBQRXy8fYmJiSYtLQ1FUahUOZiOne7myJF/8fb2wc/Pr1AJEVcCpdtx+OudmlQSQohbSWRkJKmpqaSlpREZGZktzomKiuLo0aOlIs7J6X6aMOBx+Po5AOzrFmLtOhGtTwBGo5Hk5CRSUpIBsFltVKxUifT0NDWpotFo0Wg0+Pn5k56ehtmcgQKEh19Co9GiKApajRa93oDNZkNRMqcNKYoGizmD2NgYdDodZM6mQqNx7V6X28iMrLHAnTDCNTcSPwghxK2lQMmVOnXq5Pi1g6enJ59++mnhe3WLMhqMpKSW/uRKtm12hbTUVK5GRWE2m9FqNXh7+5CSnMSVKxG0a9cJg8HgcsIjrwSJuysGuPt6pYE8fRNCiNLvoYceUkfm7ty5M8djHn74YerWzb/2WHG48X6aGFiNjOBGBEYex2hJo/J/f3O2fk+8vLwIrhKaORIVDXq9ngoVgtBptRiNRuLiYrHbM4vVmi0Z+Pj4kpAQj0aDuqqgRpN5Xuayzdos04PAYPSgWrUapKWm4u3tg8FgoHOXbi7d63IamaGgyFSY6yR+EEKIW0uBkisXLlwAMpcmdHztYDAYqFixYqko9FZSzBYzlStV5kxSEpA9iVFaZWRkEB0djUaTuWKQRqMhJSWF1NQUUlJSuBwRTp++9+WZFHEkN3ILilxJgLgz/LWk5yO7mtjJK6kkhBCi5C1evJi0tDTGjBnD5MmT6dixo7pPq9VSoUKFUrEMc24CA8txoOk9BFw9jc5moUrkUaKqNMXmVY3q1WsSdukCVqsVRbHj7e2TOTVYUdDr/78wbVpqKlaLBZvN6vQwxjHq1cfHG6vViqenBq1Oi59fAJUrB3P+/Bnsih399cRK1tUF8+vzjSMzMpM9rsUC7j5cKQ0PZSR+EEKI20+BMiHVq1cHMgud+vr6Ou27ePEiZrP5jk6uBAaWw+jhwa2UWAGw2axO3yuKgs1mzRziC9gVhfDwS1QOrpItGLgxuRESUtXtp1DuDH8tyvnIBQ22SjqxI4QQouhUrFgRgI0bN2IwGNR7IEB0dDTJycmlOrni5+9Pq279SEqLQrf1JzQo1D+3lVOVH8FgMNClSw92796Oj48P8fFxWCxmTKZELBaLmkix2+1kXK+rciOr1YKCgre3N97e3sTFxxEXG0N8XAxWqxUvL290eh0JCfF5JlduvNfmNDLDlVigMKNdS/reXRr6IIQQouhp3Tnp1KlTTJkyRf1+zJgx1KhRg0qVKuU6lPZOoKBwLTq6pLvhFseyk5C55KFOp89MsthtaDUaQkOrZRbs3baZfft2s23b3ySZTNmSG6BRi+Y6gqKcEiA5cQRZ9es3cjnQcCRksr6eOxyBzsmTx9m9eztJJlO+57h6XUIIIW4dVquV4cOHk5SUBMA333xD5cqVCQoKYu7cucXWD5MpkUsXL7h0P3Lw8/en8tAn0ZQPAcA3Lpzyl48SGFgOg9FAhaAgvH180Ov1lAusQGBgeSpVClZjAK1W6xQPZKUoChnp6aSmphIVFUVqSgpWq4WMDDM2mx2b3Xb9SE2u/c/pXuvn70+16jXUe76rsYC79+DScO8uDX0QQghR9NwaZjJ9+nTefPNNAI4dO8bvv//O7t27Wb9+PTNmzGDr1q1F2slbgcmUyJrfVxEdHVXSXXGbRqPFYNCTmSDREBQUTHCVEOrUqYePry+HDh4g8nIEGq2WxMR4IiLCCAmp6vSEKSQklJCQUJeeQuU0UqSgw1+Laj6yI9Axm81kZGQQERFOg4aN8jxHCs0JIcTt5+OPP6ZJkyb4+fmhKAovv/wyX331FVWrVmXYsGGMGzeOgICAm9oHd0Y2ON1TR72A6dPMh2DVTm3Bx/AUXL9npaenYzGbqVWrLukZaZlLMtsspKVmfm2zWbHZ7CiKPdtrmM1mNBotNpsVu6KgRYNWm/lQpmzZQPz8/AkJCSXycgTb/9mCXbHj5+evLsvs6mhTV2IBd+/BRX3vdmeKkcQPQghxe3IrubJ//35atWoFwPr16xk0aBBt27alUaNGfPjhh0XawVtFfFwcsbExJd0Nt2k0GrRaHR4ennh4elC/fmOaNGnmNPUnLjaGtLRUPD290Ol1gCbX5EZ+yykW5ZDYopiPHBhYDqvVqibHzp8/Q0hIaL7zoKXQnBBC3F7279/Po48+CsDRo0fR6/WMHz8egAYNGnD69GnatGlzU/tQ0CmvOd1Tjc27YT60GZLjSf39K/yGP0ujxk35Z9tmFEXh2LFDBAVVIj4uDl9ff9JS0zAaDSQnZ6DRaMih/r26BLPBYECn1eLp5YmfXwBt23ZQC98nJZnYsP4v4uPj0Gg1JJlM6gOLgiYVbqzpljWJoaAQElINUAgJqeryPbgo792O992RsGrfobNL9WYkfhBCiNuTW8kVX19fLl68SIMGDfjjjz8YO3YsAImJidlqseQnIiKCBQsWcPLkSV577TUaNmyY7zlnzpxhwYIFXL16lSZNmjBp0iR8fHwKfExRcvzj/FbhmEpjt9uzDAFWUBQ7iqIQF3uNqKtXiIuLJTU1FbvdjrePL15e3nh6eREYWI6QkFDAteTGjcfktkJASRWY8/P3p2bN2qSlpeHh4YFer3epfktu114aiuUJIYQoOEeMA/DHH3/QrVs3dZ87cY47CpqEyOmeGjL0GczHd4Ilg/StS/HseD+JCekkJydhs9q4ejWKhPj469N/tZhMiWrtlZxWFszKbrej0+nw9PCiTJkyVKxYSX1wsnv3dpJTkrDarOjRYbNlLtsMmffMRo2bEhEeRmhoNZcTRo74Sq/Xo9VqadyoGceOH3aq91YQRVUkNj4ujvT0dKKjo1AU2LXrH3r16utS21KoVgghbj9u1VwZOnQo/fr147777uPQoUMMGDAAgHXr1tGnTx+X25k7dy6dOnUiNjaWX375hWgX6pUcOnSIFi1aEBkZSZs2bVi8eDFdunRRK927ekxRU64nJm4VGo1GDcQyVwHIXIYxNTWNuNhYzp49zZ9/rOLAgb2cP39GDWwCAgJo1KipOsTXVZGXI9i7Zydnz5zi0sULGI1Gp1opRoOxwDVPilpISFUCAgLUvhVn/RYhhBClw9ChQ3n55ZcZMWIE77zzDg8++CCQuWKizWajXr16N70PBa1BllP9sRSDN5G1r694ZLeTuPhd9Xir1YLdZker1ZCRYSYm5lquCRWtVqsuVqDV6tBqteh0OgwGA55enihZaobEx8VhMBgxGozo9Xr0egOVKldWkx8mUyLHjx0hPj6OY8cO53p/NJkSOXniOBnp6QCkpaWRlpZ2/VLshEdcKhU1SwIDy2Exm1GU68tSG4xSP0UIIe5gbo1cmTt3LrVr1+bSpUvMmjWLsmXLAnDy5Elef/11l9sZNGgQU6dO5cqVK3z22WcunfPiiy/SuXNnfvjhBwBGjBhB1apV+fbbb5k4caLLxxS1yxHhuRaBK40ynyT9v8yASXN9mUYFq9WKVqslJTkZHx8fKlQI4uyZ09gVhStXLlOpcmWXh7NGXo5g7V+/Y7FayUhPIzS0Gr5+fjRu3Ayz2VygpRdv5oiQohqmezkinMTERDw9PDAYjYVawUgIIUTxuv/++/n+++/ZsmUL3333Hb169QJg+/btzJs3T01i3GwFGdmQ0/3r0sULRNVqT2DYQTxT4lEuHKFyzBnKBVbg8uVwQCEpKRmzOSPPkSoajQa9Xq8eo9Pp8fXzJz09ndjYWGKuXaNqtZqYTImkpqai1WqpVDmY1NRU6tSpS5069dXrcGW6U9apNteirxIUVNFplSatVktoaDUSExNcGtlzs+OG9h06s2vXPxgMRjw9PQtVP8VkSuRyeDhoNPlOTRZCCFH6uJVcMRgMTJ06Ndv2999/v0Dt1KhRo0DHZ2RksGnTJr766it1W/ny5enevTtr1qxh4sSJLh1zs2i1uvwPKqUUxY7Vqjgtx5g5FNeijlpJSjahKJBkMpGcnEyZMmVcqpcSERGGXVGw220oCiSnJOPt44PZbKZa9f//HchvCHRxLF1Y2GG6JlMi58+fJTExnkSgUqXgEi1UJ9OThBCi4AYOHMjAgQOdtjlGsJRWN96/AgPLoTEYCW/Shzq7fwLAuuYrqg2aQVTUZTw8PElLS8WeT2LFbreTnp6eOQ3I0wsvLy9sNhuK3U5qehoaNGzdsoFjRyvg6eWF1WIhJLQqtWsHqrVQHPcii8VMSkoyBkPmCNHU1BR1xSAHRwLGaDRSIagiQRUr0aBBYwCn5JGvr1++D0OKI26oHFyFXr36FvrBjGNFxqioSCAzfijoKOGbQeIIIYRwnVvJlZISFhaG1WqlalXnubXVqlVTVyhy5ZicZGRkkJGRoX5vKuBUDr1BT3p6WoHOKS0cSY0baTQazGYLiQnxaNBgt9nRaLWZQdX1KVDp6emcOHGMkNCqJCYkAFAmoCxmi1m9EYeGVuPY0cPotDo0GvD18c2WQHFl1EhBC/yVhPi4OPR6PUFBlcjIyKBmzdol1sfiCCqFEEJkV9iYoig47qsR4VWJv7CPslfPQFIs/ofWYTCGkJaahs1mx1EPBRzxgKJuyzqiRaPRYLPZ1BEjjhGwCgppaWlER19Fq9VgNHoQFxdLlZBQzp8/S+XKwVy5Eondbuda9FXKlg0kLTUVo4eRsLCLRESEOd2fHDXs0tLS8PLyokGDxrkWy8/vnlZccUNR1E+Jj4sjLS1NLSSclpZW4nGOxBFCCFEwt1RyJf363Nsbi8n5+vqq+1w5Jifvvvsus2bNcrtvly5ccPvckpS5IkDOT60URcFiyeBaTBoJCQnodDoC/P3R6XTY7QopKSkkxMdhtVg4fPigmnDRaLRUrlQZD09P2rXrROXgKvTpex/h4ZcIDCyvrihw4w06v+DkVli60NFHozFzeHBBi+wVpVshGSWEELejwsYURcXP3x9vHx/ON+lDwLXzaO02/I9tpkr7sZxINJM1sQJgNHqQkZGe40pBVqs1z8L9drsNjUaP1WrFaDSSkpJMSkoycXGxmM0Z+Pj4YlcUbHY7Wp0Oq9WG2Zw5kmXP7h1UCQklJKQqCnkX0wXXR1PcCnGDQ2BgOby8vEhMjAfA6/riASVJ4gghhCiYWyq5EhAQAEBcXJzT9tjYWMqUKePyMTmZMWMG06ZNU783mUyEhoa63Dez5eYVy72ZFEVBo9FyY4DlYLVa4XoCxtfXl+DgEJKSTCh2OwmJCZQtG4jt+vQhtU27hZiYGDy9PNXlFysHV3FpecK83ApLF5amPt5KQaUQQtxOChtTFKXAwHKc9ivH1VrtqXxmOxq7lfphuzmmr+V0nFarRVEU9Ho9Fosll9Zyp9cb0Rv0lC9XnkRTIulpadhtdnx9fIkzZ47i0Wo0eHp4oNFqsVjMXLlymbTUVKKirnDhwjmCq4RQs2Zt9Ho9fn5+ANn+QV+Q0RSl6Z6cHz9/f7p06U5ERBhQOmquSBwhhBAFc0slV0JDQylTpgzHjh2jb9++6vajR4/SpEkTl4/JiYeHBx4eHm71y2RKJCI8zK1zS4O8VjnS6w1YLGYsFgumJBNRVyIxWyyUCQigTEAZUlJTURQ72utTfhS7Qpo5HbM5Ho1Jw6lTx4s0QCjupQvdmWtcWpZXvJWCSiGEuJ0UJqYoauq9oFp1WPgfJMXhG36MikG+XPGqoB5nt9uxWMxAZgHbvEap5MTLy4MKQRWpGlqDc+dPk5KcjF2xYzAYqFQpODNpYjAQHxdLaGg1EhISSDIlYbVYsVgsWG3W6ysCafL8B31BR1OUxD3Z3Tolfv7+NGjY+Cb2rGAkjhBCiIJxObly8uRJlxutX7++W53Jyfz58zlz5gwffPABGo2G0aNHs3DhQiZNmoS/vz/bt29n7969vPPOOwAuHVPUDuzfTUJCfKHb0SgK3rZ0tIqdZL03SilYfUir1eLh4YHNZictNZWw5EuAQkpyEhUrVcLDw4jVaqNixYpUrVqD5OQkwsIukZSUiE6bOezXlWGkpbFg2u0w17i0JHqEEKI0Cw8PJyUlxaVjq1atire3903uUdFx3F8Nfv5kdB6Jx5+fA9A2/jirPbugaBxLOOvIHMWqYLXacm8wBxqNBm9vH+x2O6fPnCAxISGzRovVhqenF23bdURB4Z9tm0lLS+PatWhatmxDYLlypKenYbVa0Ov0eHl5ERISSkhIaK7/oC/toyluh9ghK4kjhBDCdS4nVxo0aOByo3kt6ZfV1q1b+eKLL64/qYA33niDL7/8kqFDhzJ06FAA9u7dy+7du/nggw8AePvttzlw4AANGzakYcOG7Ny5k+eff54ePXqo7bpyTFEKu3TJ7XONdgt1k8OonRxOgCUZ3fXpOVa0JBp8ifYI5IJPZaI8ykExJ1s0msynR5mFbVOvF6/ToNFk7gsMLE9iYgJWqw2dTk+5cuWpU6ceSUkmMjIyf6auzBkurYGIzDUWQog7wyOPPMKmTZtcOnbDhg307NnzJveoaNy4rHGFCkE0LROMT0IkgZYk6iWHcdKv+vVVgQqWUHHQaDQYDAZS01K5ejUKvV6P2WxGp9Oj1WmJjYsF4HJ4OFFRkSgKJCbGk5AQr06DcRSvdawuBOR6vy3toykkdhBCiDuXy8mV8PDwIn/xqlWrqksdjho1St2edeTLxIkT1UQLQJkyZdi5cye7d+/m6tWrfP7559SuXdupXVeOKUruDP3VKHYaJF2kRcIpPJTsQ2/12ClnMVHOYqJB8kWSdF4cKFOf8z5Vii3JoiiKugKSI1+m0WT+x9fXj+DKIZw9cwq7oqDVaDAajVnmDIcD/8fen0fJfVZ3/vjrs9Ze1fsitXbJ2traLNmSsYVtbAfbrJ6ELRAmhLBMEjIwc3JgkjP5DkwmHiZxMHBmwvxCQnIYHzJhAsQQjBewLdmSvGhtWXtLve+1dm2f9ffHp6rcq9Tdaqlb8vM6x4fqWp7PU9Win1v3vu/7uuMCpemYSSCyEMqWxV4dEwgEAsH88IMf/OCypvdjqa+vv/KTFgnl87VYLOK4LtlcljNr9rLjjR8AcFvqLH1167A0H9nR0TlcQaK2th5N0xgeHsRxHAzDQJI9NYymauiaRjw+MkXsIs25DWYmaoqFUsSK2EEgEAjevsw4udLS0jLvF1+1ahWrVq267HN27do16T5Zlrnzzjsv+7qZPGe+qKtvpLNz5uqVxsIIe+Jt1JjjRzPGtQgZNYiLRJU5StTKIpeULBE7zz0jR2jNtHOgppUhX828voepKKtWHMehqqoKwzCRJIlQOMK99z2AYRg0NDRSKBbx+3wYhmfqG4lGWdrSQmKCqfB0XCkQWShly2KvjgkEAoFgfqirq1voLVwTyuerIssYhkEymSCrBVjSsJ6mwTP47CJbRt7kQNXM1cljkSTIZjPouh/wCiSSJKHKMoqi4uIyPDKMruvU1NTS1LRkjErl2hn8LqQiVsQOAoFA8PblhjK0XaysWLmKw2+8OqPnLsv1c//Qa4yt35wNLeNEbA0pLTLuuapjsTzfz7rRLpYWhgGoM1I80v8yx2K3cDS2rtIrfS2QJKkyMSCdTlNTW0c4FKaxqZlw2Nurz+9H0/VxSZHZBjVXCkQWUmIreo0FAoFAcKMSiUbZ3LqFgwf2E43GSKeS+MN+Lqy6k7qh86iuzZqRM5wOL2eI2atwXdcln89TLBooileQkSSJcDhaMsM3KDgOfX297LhtF3v33nddkg4L3ZojYgeBQCB4ezKn5IplWfyv//W/+Kd/+ic6OzsnOcp3d3fPy+ZuFHRNn9HzZNdmd+JkJbEyrMc4UHMrQ77qKZ9vySrtoRbaQy0syQ9xe+JNasw0MrA9dZbmwjDP1++kqMz/RIKyakXTvNGKpmkSHxkmHh+hs/MSly62c+99D0yZFJlLUHO5QERIbAUCgUBwPXnmmWf4xje+wfnz58nlcuMe+8EPfsBdd921QDubPaZhEgqFkYCRkSHSmTQpF8413srG/qPIuGwfPMqvlt41pxHMHi6apgMSsaoqFFkmnU5WYoGjR96guXkJzUuWEolGSadTdFy6WIkd5ruFR8QNAoFAIFgI5iR7+LM/+zP+6q/+ikcffZSOjg7+5E/+hAcffJD+/n4+8pGPzPceFz2GWZzR8zZkOohYXpDW66vlqaa7p02sTKQ3UM9PmvfyRmw9Tik901SM80j/y4St3BVePTc0Tcc0DbKjoxQLBYrFIqZhYBgGAwN9PPPMzxgdzbBi5apxwVA5qAHmJagpK1s2bNi8aMxuBQKBQHBzsn//fh599FFuu+02NE3jwx/+MB//+MfJ5XLceuutrFmzZqG3OCvKZ7LtuAQDQaKRKIosczyymlElAEBLfpD6TN+cr+G6LpZl4roOqVSSeCKB7Tg4pf9yuSwHDuwjk05X1K2nT5/k4MH99PZ2j/s5k05f+YJXQMQNAoFAIFgI5pRc+fu//3v+8R//kX//7/894JnO/u3f/i3f+c53OHr06Dxu78bg3Jkrj6lWHYttqbOVn1+r3jTrUcuuJHGs6hb+tfFOciW1SpWV5T39+6k2rj4YGYvjOOTz3oSgsdOfHMfBdV1M0yQRT7DvpV9OCoSuRVATiUYnJXEEAoFAIJhv/uEf/oE//uM/5mtf+xrNzc28+93v5rHHHuPAgQO89tprRCKRKy+yiCifyatXrSEWq0JRVa8Aovl4o/qtAQK7Em++5V4/S8pxgW3bmIaBZRq4jos3YdDzbpOQiMdHJqlbu7s6J6ld5wMRNwgEAoHgejOn5EpnZyfbt28HvFG7mUwGgA996EMcOHBg/nZ3g5BMJa74nE2Zi/gdT257IbiUEV/VnK836K/hp013kVRDAATtIu8eOEDUnIvT/9yxbYt8vkA8PlKR+Pb2dtNx6SLATR/UlN/zfFTZBAKBQLA4GBvjBIPBSoyzfv161qxZw4kTJxZye3PCxWUkPkwgGESSZEIhL364GF7GiO6d07VGirX5/rlfw3UrxZi3ijLefaqqkkjEK8a2ZXWrZVmoqoZlWRiGQTY7iq7PrNVaIBAIBILFxpySK7Zto6qeXcuqVavYv38/AGfOnCEQCMzf7m4QZFm57OOqY9GavgCAAxypuuWqrzmqBvlZ0zsY0qsACDgG7x44QOgatQhNheM4jIwM0d/fz6GDL3P8+BGe/tenOH78yLxJexcrE2XNN/N7FQgEgrcT3hf+yTFOPp+ns7PzusQ5Y5P385HIL6tFdF2nqqqKlavWoGkaSBKvVW2qPG9H4iSKNDf1ymTeWseyTHw+H8lkoqKkWb58JQBDQwOYhkk+l0XXdNrajokzVSAQCAQ3JFc9Lehzn/scH/3oR9mzZw+vvvoqH//4x+djXzcUjmNf9vG12e6KaqU9tJS0Fp6X6xYVH79o3M1D/a9Qa6YJ2wUeGjjAT5vuonANTG7LqKpaGbcoyzJtbUdobGiiWCxiWRbJRILq6mq6uzsJBkM35CjCK5nrzfckgvk28xMIBALB1fOpT32K3bt3c/ToUTo7O6mvr6e1tfWaXnPsxL3ywAC11Moz11bbsQavlmWRSMTxBwIkkwl6A/V0++tpKQwRtvJsSl/iZGxN5Yy7WiRJxjBNEokEZ86coqVlOZFolGAwVEliWbaFrKhour4g032uN/N95osYQiAQCBYHc0qujHWT/4M/+AOWL1/OgQMH+MhHPsJv/dZvzdvmbhTky41Ddl02pdsrP56Irp3Xaxuyxi8ad/NI/8vErCxRK8e7hl7j6cY92NLlFTVzxXFd9FIA5LoukiSTy+VQNY1CIQ9AoVjAsi0CgeBVBYQLwUxGSc/nJILZjq4WCAQCwbXjmWeeQSp5om3dupVXXnmFH//4x4RCIX73d3+3khC4VoxN3ufz3pkaiUSuKulQVot0d3UyPDxEKpUgl81WHn+9eiNL+4aQgC3JM5wLL6MgXf379Iownu+KqqqMjAzR3d3Fxk2bqampxbIs8vk8qqp6ShpmZoS/mJMJV9rbfJ/5IoYQCASCxcOcTs6JgcX73/9+3v/+98/Lhm5EksnpPVeWFoaosrwAps9XS0Kf/wOvoPh4unEP7+nfT8gu0FhM8I6RY7xUux1maZo7E3RNZ8WKlVy61I5tO2TSKSKRKPV19QAYRpFCoUChUCAQCM4oIFxMgdJMVCnlQHXiGOprdT2BQCAQXB/KfiBltm/fXvFguR6MTd6PbUG62kR+JpPm1Kk2JElieGQYw3hr0mFcj3Eh1MLabDc+x2RL+gKvxtZf1fsAUFWN+oYG75xzHa/9J++1L7tj2oY0TWPHjl0YhnHFM3UxJxNmsrf5PvNFDCEQCASLhzklV640EWjbtm1zWfaG5NjRw6Qv0xu8KX2xcvvN6Kprto+sGuC5+l08PPAKmmuzNttDSg1zbB78XSbi8/uob2ikp6cbxyngup65bV19I+lMmkRiBMd2MA2DUCiM3++/bEC4kIHSVEmdmapSItHovOxzPlUwAoFAILg6Lly4UDGxnYq1a9cSDs9Pe+9UTEzeA1edyO/t6eaXv3yGXDaLoioEAgFkWaJYLFbMZ9+oWs/KbC8qDhuS5zkZWkZWDc75fciyTFVVFfH4CKZhYuctVE3jwoWzrFu3nkQ8jqqq+Hw+8vk8yWSSjZs2X3HdxZBMmK4gNJO9zfeZL2IIgUAgWDzMKblypQqOO8dRfjci586dmfaxqDnKssIgABklQGeg6ZruZcRXxUt123nX0OsA3JY6Q1KP0BFsnrdrRKJRblm3gYH+fk/uq3itR5Ik09KyDHDJZLxkk0/30djYxMaNrdNKYxPxOLlcdkECpemSOvOpSpkJ1/t6AoFAIJiez372szz//PPTPv7ss89y//33X9M9TEzeX23byMED+8lls+QLeQL+AHpYR9N0ioVi5QzOqkHejK5iS/oCKg47kmfYVzd3xY6u66TTaRzHxrY9bzrbsujp6ebcuTOsW7cey7IYHPQmFLW3n6OlZdkVVSu5XK5iOrwQyYTLFYRmkuiY7zNfxBACgUCweJhTcmVoaGjcz47jcO7cOf7wD/+Q3//935+Xjd0oXM7wbWPmUuX2qcgq3GvQojORjmAzr1dtYGfyNAB3Dx8l0RyZFxNdRVFxbIejR9/Ath0kyQskQqEwd++9l0g0SlWsmlw2i+O65KQsrVu2EY+PAOODw8sZ9l2vQOlyFaaZqFLms5UpEo3i4k75WQkEAoHg+vHP//zPGIYx7r7BwUG+/vWvI0kS73znOxdoZ3MjEfdGICuqQsAfIBgKcffee8lmR3n+uacJBILk8zkcx+F4dC3rRzvxOSZrs92cjK4mrsfmdF3XdYlEYiRTCcqTgyRJwnUcsqMZItEo1VU19PX2Eo1GUVX1ssWVsXEDwPLlKyvmuNeTK8UOM0l0jG2Jmg/mS0krEAgEgqtjTsmVurq6Sfc1NDTw93//93ziE5/g3/7bf3u1+7phSKdSU96vOSa3jHYCYEoKZ8PLrtuejkfXUmOkWZ3rRXct3jX0Ok813YUlz92cTlEUVFUtTQR6y9A4M5ph/YZNhMMR0ukUXd0dVFfXYJeqNieOHyEUCk+q7owNTlRVZfnyVQSDwetadbkaKa0wpBMIBIKbk+gUf3vr6ur47ne/y6pVq0ilUlPGQYsVTdc8L5PqWkzTZO269YTDEQzDoL6hia7OSxXFsaHoHIut4/bEm0jAzsQpnmncPafrGoaBaRpoqoZbMsBXFIVgKMTadevp7enm5JsnyOWyZHOj6D79sufwxLghGAwtyDl5pdjhSomOa3XeLybvOoFAIHi7Mq+W98uXL+fs2bPzueSi55ZbNnLw4L5J968b7UJzPRnshVALhqJfv01JEvtrt1Jtpqk2R6k2M7xj5Dgv1s3d4Na2bVzXnaTUKeTzHD3yBoOD/WiaN0FoeHiIaDSKI0kEgiFgcnVnYnByJSnwteBqpLTCkE4gEAjeXiiKQnNzM+fPn79hkivpdIqTbcfRdJ1cLofPpzM0NEBfXw/NzUsp5POVyX9lTkVWsjF9kYidp6UwxJL8EL2B+llf23VdstnR0tre1KBwOMq99z1AKBzmpReexzQMfLoPF5famnpcXDouXZzyTJ5rQWS+kw7TxQ4zvc61OO9FgUYgEAgWB3NKrhQKhUn3JRIJHnvsMdasWXPVm7qR2HvPvZOSK5Lrsikzxsg2cu2MbKfDklV+Wb+T9/btR3ct1uR66B+t5UxkxZzXnK4FyjCKjIwMo+s+wiEvmWKYJpFItDJ1YWIgNNfExrUIkuayjjCkEwgEgpsT0zQrHiFlCoUCP/vZzzh27BgrV65cmI3NgbFf5A2jiGkaFAoFMuk0mUyaQqGALCvAW4pUW1J4o2oD94wcAWBn8k3+xb93TsWZsW2/AIoiY5oG+176Fd09XeTyOVRFJRQO07RkyWUTBHOJG65V0mFi7DCb61yL814UaAQCgWBxMKfkytjRgGNpamriH//xH69qQzcax44ennTf0vwgUcsbNdjjryOpR673tgBIaRH21W7lXcNvAHB74iR9/tp58V8Zi+M4ZEezFNUimXQKTdOprqpG0/XLtvvMNrFxvSozM0ngCEM6gUAguDl56KGHpjS09fl8/Pmf/zlNTdfWnH4+qamprZjGWqZFoZBHVTUsy8RxHBzXxTRNzwtljHqlPbSU1swF6ow0dUaa1dke2sMtc95HOcmSSiVJJOLk894+wqEwqqqx47ad6CX1K0yfIJitV8n1SjrM5jrX4rwXBRqBQCBYHMwpubJv3+Q2mOrqatauXYvP57vqTd1I7N/3wqT7Nox2VG4vhGplLB2hJZwuDLFhtBPNtbln+DA/bboLR5Ln7RqqquPz6UiShGVZhEJhNF2fc7vP1Yw4vFpmk8CZbwM5YUgnEAgEC883vvENksnkuPsCgQBr164lFpubuetC4eISjUQrU/yklISu+7wJQa6DRMmTpVgc9zpJlnm9ahPvHjwIwG3J03SEmrElZVbXlyQJTdMxjCKSJCNJMslkEtu2cRwbTddoalrCunUbAC6bIJhLgeV6JR1me51rET+IAo1AIBAsPHNKrtx1113zvY8blmx2dNzPQStPS37Ae0zx0x1oWIhtjePV6s00F0aIWVnqjBTbk2d4o3rjvK2vKDK2baOqKj6/jw0bN1NbWzenA/5qRxxeLUJaKxAIBG9vWltbF3oLM+ZySsvyeVosFMhls1RX16CqKrV1dVTZVRhFbyJSX1/PJOWK67r0Burp9tfTUhgiYufZkLnEyejsWr8VRcG2rdKaDpZl0n7hPJFIhHAowoaNm1m3bn1l75dLEMzlfL5eSYfFkNwQBRqBQCBYeGacXDl69OiMF922bdsctnJzsC7bRVkTcja8DHceFSJzxZJVXqjbwXv79yPjsiV9np5APf3++THky+dzFTPbmvDVBRVTBU8ubiV4vNbBi5DWCgQCwduPCxcukMlkZvTctWvXEg7Pb3vtXLiSkqN8nmq6TkNDIw2NTezec5c3Oah0tp061YaqaXR3dYzz0ysnW16v3sjSviEkYFvqHGfDyzFlbcZ7LJvhl3Ech1xulFw+S8AfID4yTHcgUBmpfLkEwXTn81QJpon3XY+kg0huCAQCgWDGyZXt27fPeNGxB+nbCtflltEu7yZwNrx8YfczhhFfFW9UbWBX8hQSsHf4CD9ufue8TDFyHAfTNLAsiWKxwL4Xf0l9QyN+v/+Kst2JAdDE4EnTtUnB44qVs2+1mqkR7mKoPgkEAoHg+vLZz352Sp+VqXj22We5//77r/GOrsyVihFjz1Of38/Gja24uBjxOP39fSQSI9TU1DE0NDhpbZ/PR6FQIK7HuBBqYW22G59j0ppu50jV+hnvcdp40HXJ53OcOnWSjs6LNDUtYe/e+2Z9Pk+VYHJxxeQcgUAgECwIM06uJBKJyu0f/vCHPPbYYzz22GPs2rULgNdee40vf/nLfOUrX5n/Xd4gLCkME6kY2daTVYMLvKPxtEXX0JIfpLk4QtgucGf8BC/U7ZjzeOaxlAO8VCqJruvksqPoul6R7U5XWZoqABobPMXjI5W1C4UCp061sXFj6xUDpbHXm22gdT2qT/M99UggEAgEc+cnP/kJpulNzLl06RIPPvggX/nKV3jkkUeIRCKcO3eOP/uzP6OhoYF77rlnYTdbYmIxQtf0SWfd2PO0fBZmMhm6uzrw+wOoqsqq1WsIBAIYhtcmJMsyVVXV9Pf3AXAkdgursz3IuLSmL/BmZCVFZX789RzXwbZshgYHOHrkDbZtv21W53NPVxepVAqfz1eJOYCbvr1XxBACgUCwOJlxcqWqqqpy+4knnuCHP/zhuPafFStWsHbtWn7rt36L3/md35nPPd4wrB9jZHtmEalWyriSxEt12/lA34v4HJPVuV66sg1cCC+bt2tYloXruqTSKcIRT4kyXRLlSlW3csAgyzKFQoGhwQEkvATO5tYtmIZ52T7z8vVaWlYsqkDrek09EggEAsHMCIVCldt///d/zx/90R/xxS9+sXJfc3Mzu3fvZuXKlYyMjNDY2LgQ2xzH5YoR5bNuxcpVlfOl49JFb7pfdhTXBduxcS242N5ONpdDKhVawuEwqVSqcp2MFuJseDkbRjvQXJtb0xd4vXrTrPcry3JlbwCSJOPYNtlcllw+x+nTJ0lnUuzdex+ZTJru7k6qa2rRNX3as7794nlSKa/419S0pNIqNB/tvYs1gSFiCIFAIFi8zMnQ9vz58yxbNvkL+bJlyzh//vxVb+pGQtd1DMPAbxdZnusHIC/rdAUX56jGrBrglZot3Fsaz7wn3ka/v3beVDayLFNbW48kSVRX1xCPj5DLZSkUChSLRXw+XyW5MbHqZhoGzz3zc3Rdx1dqKXJxaWlZwdDQQGmqgU6hUODggf2EQuHL9plDOYhzF5WPijDNFQgEgsXL+fPn2b1796T7dV2nsbGRCxcuLIrkCkxWclzurCufueFQmPjIMLZlYzomekTDdRwcx/GKI6nUpHaeo7F1rB3tQsVhU+YiJyOryav+We3VdUGWJSKRKIZhUF1TS7GQq4xllmSZfD7PieNHOHHiKK4LhlGkZdkKIpHIlGe9qqo0NjRRKBZZvXpdpUDT2roVwzDQtbfULDM5Z8sJFV3TaTt5bFEmMEQMIRAIBIuXOSVXNmzYwFe/+lX+8i//ElX1lrAsi69+9ats2LBhXje42CnLaNeOdqPgBSPnwsvmddTxfHMxtIRl+QHWZrvRXYu7h4/ydOOeq24P8vl8aLrO6KhnCnjixDFGRoaxLYuBwX4cx0FVNXbuvKMSwIwNgF7a9yvi8WFURaW5eQnd3Z10d3fiOA6WZSGVql6mYaDpnlfMxMAinU6Ry+WwLAtVVUvKleW0tCxfND4qwjRXIBAIFi8bNmzgr/7qr3jwwQeprq6u3P/DH/6QU6dOsWbN7CbmXC+u5BlWfry7q5Niscjw8BCappHJZCqqU5jaJyWnBjgdWUlrph3VddiaPsfBmltntK+Jk4hyuSx+f4B8bpR8Po8LGPkciqKgKirnzp2hUCjiOA6SBNnRUUKh0KQkQk1NLZZlUSgWUVWFfD7Lvpd+VTn7N7duoa1t5gmSsYqQbHYUXdPRdH3RJTBEDCEQCASLlzklV/7n//yfvOc976m0Brmuy9GjRzEMg5/97GfzvcfFj+tyy5iWoMVkZDsdB2taaSoME7YLLCmOsClzkTejq69qTdM08QcCWKaJbTsYhkEuO4ppWRhFA0VRsEyTAwf2Y9s2kiQRCATYu/c+urs6SaUSGEUDQzLI5TzvmnJ1RlVV6usasWyTNWtu4eLF81NODCgHRgDLl6+sTCCAmVWtrgfCNFcgEAgWL1/+8pd57rnnWLZsGXfccUfFc+Xs2bP81V/91aJRrUzFWCXLVG0tmUyazq5LWLaNPxDAtm0wjUkJkKk4HlvL+lJr0PpMB23RNYzOQPX6VtLGwba9ZIthFFGUILquI8sKhmnQ0NDE+g0bOXH8KPF4vPL6UDhMPpejs+MSuq7TvGSptx4upmEymslQNIoUCgWy2VEaGprQdZ3urs4ZKTzKn1Mul608X9M8VbKm64sugSFiCIFAIFi8zCm5smfPHtrb2/mHf/gH3nzzTQAeeughPvnJTxJ9G/6RbyzGqbKyAPT5aklrCz+i8UoYssa+2m08NHgQgJ2JU/T660nqkTmv6TgOju1gmqZ323FIpdMUCwVMy8SyTGzbpqvzEpZlEQgEkWWZc+dOe6+3HXw+H7ZjU1NTR1VVNe3t5z3JsKLS19+DqqqkUsmK4mVsYDFWKquqKsFgaNEGHWJko0AgECxOamtref311/nhD3/IoUOHSKVS7Ny5k49+9KOLVrUykal8OTKZNE///CksyyKfz6HrPmzbRtN0NE0nn/d8VyRJwjTNScmWguLjzcgqtqbPo+CyLXmW/XXbZr0313WxLJtisYCmaRSNIgCSDJrqqV99Ph+WZbJt2y7C4RBvHH6N4ZFhTp95k9tu20Vz01LOnz/D0NAAlm1hGAbhkm9ONjuKaeisWXMLqVRy3PTBjksXpzXWtywL8OIHv9/Pzp13TIozxn6+C+nHImIIgUAgWJzMKbkCEIvF+IM/+IP53MsNy/rRzsrtxWhkOx19gXpORlaxOXMRFYe9I0f4adNdV9XSlMtlK6oU13UxikWKxSKSBI7rlgzzJBzHoVDIo6gqp0+drEhvHccp+arkOHz4NUzTa7syjAKqqgBeEscwjEkjmaeSyi50ACQQCASCGw9FUfjwhz/Mhz/84YXeypyYypdjYKAPx3WRFQWfz4+iyPj8PrKjo/h8nn+KqmqVqUlTcSK6hg2jHfgck7XZLk7E1pDSZl+UcV0Hy7YJBsMEgyGisSoCgSDxxDBV1TX09/WgKCr9/d00N7cgSRKObZMv5Dl+7AhHj7yBoiilRIy3d0VVqQ3XYRSLaLrOxYvnWbVqDfH4CNU1tZxsO35ZY31VVVm+fBXBYPCyMYMwlBUIBALBdMw4uXL6tKcu2LBhQ+X2dLydfFd022BlrheAoqzREWpe4B3NjterNrKkMES1OUqdkWJb6iyHq+b++7NtG3hLBmwYxYqpLLxltidJEqqq4fP5yBfyJJNJVFXFMAxCoRCarpPJeN4tkUgEwzCuKNGdKJWdyQhmkXwRCAQCQVdXF9lsluXLlzMyMkI2m532ucuXLycYnB8T+GvFVMUGXddpO3GsVOiAUCjC0PAgju1QLHrTgfL53GXXNRSdE9E17EyeRgZuS57ml/W75rRH27JwXIdAMFhRjixbtoJTp94kn88DEiMjI/j8fkyjiG07OLaNJEuYhkWhUPCSLo7DkiVLaW3dBrh0dl4CoFAocPzYEULhMN1dnWi6jj7BQ2Xi59TSsoxINEo6nZqkcikjDGUFAoFAMB0zTq5s3LgR8L40l29Px5X6dm8mqsxRTElFdQ3Oh1qwJWWhtzQrbFnhpdrtvLd/PzIuW1Ln6Ao0MuSrvvKLZ7K+bVNOrIAXiGiaRF1dM7bjYBgFioUihmEgyzKyLCOVlDOBQKDyOlmWWblqDYFAYJyPykTGSmXLYyfL150YAInqk0AgEAgAfvu3f5vnn3+eZ599lscee4znn39+2uc+++yz3H///ddxd7NnKl+OSDTKQw+/j66uDmpq6jh4YH/peHaRZQXLml6xMpY3I6vYlLlI0C6yMtdPXTHB8BxjhnQ6hU/XUTWNfC7Ly/tfID4yVCnUZDJpLrYX0TQV27Hx+wMYRQO7ZFqvaRqRaIzW1m1s3LSZTDpdMcI3TQO9ZH6v6zpG6eexBZqpPqcrxQbCUFYgEAgE0zHj5EpXV9eUt9/uDPpr+MeWB1ie6yeu35hfzEd8VRyJ3cJtqTPIwN7hI/ykeS+WPOeusQpTmeSZpomiKGxuvZX29gvIsszQYD+maeHz+fDpOoFAkHXr1oML58+fYSQ+zNDQQGX6z1imU59cqU1obPWpUChw6lQbGze2igSLQCAQvM34wQ9+QKFQoL6+nm3btlEoFKZ9bn19/XXc2dyZypejecnSiiEswPPP/RzXpeK3Mva8VhSlkuQYiyWrHI3dwp3xE4Dn2TbXiYOu4zA8PITrutMW5kzTwHFsfH4/1TW1qKrKkiVL6e/rRZLAMD0PmUw6TSQapXXzVrq6O8aZ3/v8fm4b46Hi4o5Tpkwc8Xy5wowwlBUIBALBdMz423NLS8uUt8tcunSJhoaGWUtlLcti3759DAwMcOutt7J58+bLPv///J//M2U/8C233MKdd94JwIEDBzhz5sy4x6urq3n/+98/q73NFEeSuRRack3Wvl4cj61lWX6ABiNJzMqyK3GKA7UzG7N4OcoBykQKhTzRaBWxWIxMJo0sy0SjMSKRCPHECEgSmUwagHw+TyqVqEwAiMdHcHFJxOPomk7byWMVSfHq1esqst4rtQm1tm5FlmUKhQJDgwNIQCqVFAoWgUAgeJtRV1dXue3z+SY9Pjg4iCRJN0xiZSasXXcLoVCIrq4Ostksp95so1AoYFkmsiyjquqUyRXw/OVa0xeIWjmWFEdYUhimNzC3z2a6OKGM67rePlyXcCiEz+/n1lu3sWrlGvbt+xXpVJIjR16jr6+H7Tt2cvKk560yNDRIc/PSiuLVxcWIxxnNZKaNG2BmypQrTWUSCAQCwduTOUkT3njjDb73ve/xrW99C4CPf/zj/J//83+IRCI8/fTTlSTHlYjH4zzwwAPE43FaW1t58cUX+dSnPsU3vvGNaV+zb9++cRWlTCbDP//zP/Nf/+t/rVz37//+73n66ae55557Ks9raWm5ZsmVmwFXknmpbjsf6HsR1XXYOHqJzmAjPYGGeb+WJElYlsXxY4dZu2497RfO4bqQTMZRFK+tyufzlXquwe/zkbAdkokENbW1aLpWSZJks6Pomo4LDA72k8/n6e7uqCRILtcmZBgGu3ffxalTbUhQMdUV/dMCgUDw9mV0dJRPfvKTfO973yMSifC3f/u3/O7v/i6O4/CXf/mXfOlLX1roLc6a6RIAZSVLJp0mlUowMjxCNuv5nRmGMe16riRzuGoD9wwfBmBn8hT/4q+bk3plJkiSzNp1t7BhQ2vlPXR3d1I0iiXVi1eI6e7q9EYyj46SyaTJ5/PEYjFiVVUVQ9uZxA0zVaaI9mKBQCAQjGVOyZX/+B//I1/72tcAaGtr46mnnuLgwYM888wzfOUrX+HFF1+c0Tr/6T/9J/L5PCdOnCAcDnPo0CH27NnDQw89xK/92q9N+Zq//uu/Hvfzd77zHX7yk5/wyU9+ctz9O3fu5Hvf+97s39wNQEW6K0kwj/42aS3Ma9Wb2BNvA+DukaP8c/M9GIo+b9dAktB1H4qqIElw/PgRikWvD9rvDxCNxaiSq1FVFVmWMU2DVCqJYRgESqqoVDJVSZJomo5hGDilz8Hv802bIJmqGhWJRtm4sbUyrtGyLHK5t+TF1wtR+RIIBILFwRNPPMGtt95KJBLBdV3++I//mO985zssX76c3/iN3+B3fud3iMViC73NGTNVAqCs/iyfOS4umuYZvtpOAFVRGRkZvuy67cEl3Kqdp9ZMU2ekWJXr5WJo6WVfMxdkWUbVVJLJFLrmqVczo2na289TyOcpFPIEAkECgQDVNbW0nThGLpfDMIqEwhEcx6G7q3NWccPEVqHpzmhhbisQCASCscwpufL6669z2223AfDMM8/wwQ9+kDvuuIPNmzfzF3/xFzNaw3VdfvCDH/Anf/InhMNhAO644w7uuOMOnnzyyWmTKxP57ne/y0MPPTSpVWlkZIT/+3//L7FYjB07dtywUl5JknHd8ZLZcl+yIsvTSnbnyqnwSpblBmgpDBG0i9wZP8EL9bfN2/p1tfWoqoppmfT29mIYRUzLwjCKBAJBNm5spbGxiXh8BE3XePXQKyQSCSzbIp/LEYtV4ZnveUkSv9/Pxg2t9PZ1e+Z2s5gmNDaI2r37Lrq7Omm/eJ7OzovjqljXGlH5EggEgsXD66+/zqc+9SkATpw4gaqqfPrTnwY8c/+zZ8+ya9fcJuQsBBMTAN3dnRXT1/KZ09PVRT6fJxQOk82NksgkrjycQJJ4o3oDDw6+CsCuxJt0BRrnxa/NW15C0zR0XUfTdDRNY9++X2GYBvlcjlAoTCQaJRAMsnz5SrZv30k8PkI4HCaZSmLbDoMDfQSDQbZsWVEposwmboDLn9HC3FYgEAgEY5nTCRgOh7l06RIbN27kpz/9Kf/23/5bAFKpVCVRciW6urpIpVKTPFZaW1s5fPjwjNY4ceIEr732Gj/5yU8mPXbmzBl+8IMf0NPTw8mTJ/nLv/xLPvvZz067VrFYpFgsVn5Op9Mz2sO1ZmJiZSzznVgBQJLYX7uVD/a9iM8xWZ3rpTPbRPs8VKM0TaO2robBwSGKhTzFooEsS6iKiuPY+P1+Ll48T2NjEytWrqLj0kUsy/YqaQUby7YwTYOWluW0tCwnHh8Z57miaRrLl68a1zs9sdo0lcEfeAmWYCiEqnr/l7ieFajLVb6EokUgEAiuL+UYB+CnP/0p9957b+WxmcY5iymmmJgAAMadOefOnub06TdJJhOomuqNN55hfNHtb6DL38CywiBhu8DW1DneqL78RMnZEIlGiYQjBIIhcrkc8ZFhstlRHMclmUwQiUTRdZ1169ZXzkjDMFFkBVmX0VSNmppampcsJRyO0N3VST6f58zZNyvThibGDRO53BktzG0FAoFAMBZ5Li/69V//dR555BHe9773cfToUd773vcC8Itf/IKHHnpoRmukUikAqqqqxt1fU1NTeexKfPe732XJkiU88sgj4+7/xCc+waVLl/jnf/5nDh06xP/4H/+D3/u93+Po0aPTrvXnf/7nXl9u6b9ly5bNaA/XAuka9SzPlJwa4JWat8xs98RPELTyc1hp/PuQJInBgUGMYhFV1ZBlCdu2kSRQNY1wJEoqlaK7uxPwAsJAIICiKgQDQWpr6tiz5+5KgqS6poau7o6KB4/jOGQyb/3bKVebTp8+ycGD+8lcIbgtB6DAda1ATXfd2e5fIBAIBFfPr//6r/PHf/zHfPjDH+a//bf/xic+8QkALl68iG3brF+//oprLKaYopwA2LBhM7t330VLy/LKmZPP5Th69A0GBwcwDAPLtAj4Q1dWrZSRJA7VbMYunfet6XYiZnbe9l7I56mvb6IqVkUkEvEmB7kupRnSyLJMQ0NjxR8mEo2ye89d+P0+gqVWoXXrvN+Xi0t3j6dQ7e/v9VqDJsQNU3Gl2CASjbJi5aoFTayk0yk6Ll2cFCdMd79AIBAIrg1zUq48/vjjrF27lo6ODv7Lf/kvVFdXA3D69Gn+9E//dEZrBAIBALLZ8YdwJpOpPHY5DMPg+9//Pp/73OcqJqhl3vGOd4z7+fOf/zz/+T//Z55++mm2bds25Xpf+cpXxpnUpdPpBQuGgqEw2dHMgly7zMXQUlbk+lmd68XnmNw9cpRfNOyelVmdJEEgEELTVPL5Aqqqks/nsCyrkkCqqanDBYLBAKOj3uHf3n6elpblRKJRtu/YyflzZwmHIzQ1N2MYBpl0ujL5p1ia9FNVXU0ykRg38We2vdALVYGa7rqil1sgEAiuP+9///v5h3/4B1544QW+973v8cADDwCwf/9+vvGNb1S+aF+OxRRTwGQPkd2776K7u5MTx4+Qz+exbAulpG7RdHXSWObLkdbCnIyuYUv6PAoOdyRO8lzD7XPap8/vxzRMHMfGdV0KhQIn2o6hyBJOaVyzhFSp3aiqijQh4TF2CtKyZSsqo6fLZ6rf5yMFZLOj5LLZSZMCp1K8Xik2WEiV6XRtS6LlWCAQCK4/c0quaJrGH/7hH066/+tf//qM11i+fDmaplWkt2UuXbrEmjVrrvj6H//4x8TjcX7nd35nRtcLBoOMjIxM+7jP55ty/OJCUMjnFnoLALxScyuNxTghu8DSwjAbRy9xKrJqxq93XZdcLksgEMSyTEzT8AIjSUJWFFRFpbq6mmAohCKrdHd3oGoabimRkMmkOXhwP5qmk8mk6evrqRjdtrSsKAWBOg0NjWi6jq7p4yb+1NTUYlkW+XyeQCAwIyXKdG1D15qprit6uQUCgWBh+MAHPsAHPvCBcfeVFSwzYTHFFFMRiUYJBkMEgiE03TONd10HRVGIj4x43mimOeP1jsbWsSbbTcgusDw/QEt+gO5A46z3VRwzDRK8wkKxkMd1Pa813eejqqoaWZYwTINgaHyLVjqdoqe7C4CNG1txcem4dBFd08nlsliWhabrNDUtIRqJkkolx8UNLi77XvpVJW7Yu/e+y7YUl6+5kEmM6QoxokAjEAgE1585u45ls1mee+452tvb+eIXvwjA2bNnWbdu3YzaWnRd54EHHuAf//EfK0ZxAwMD/PKXv+Tb3/525XmvvPIKQ0NDk8Yof/e73+X+++9n1arxX/Ydx6Gvr4+lS9/yCDl06BBdXV3s3r17rm/3ulI+DBcaQ9HZV7uVdw8eAjyzul5/HSktMqt18vkcqqpiWRbgJV1sy8KxHbq6OgmHIyiKTDKZACTyuRwbNrTyxuuHiCfiSBKEQmFUVSMSiZQ+n7dMbX1+P62tW2lrOzYuEeEyf5OUFgLRyy0QCAQLg+u6vPjii5w8eZL3vve9LF++nJ6eHmKx2Iy95RY7NTW1+P1+mpuXEh8ZRlU1FFUlnUpi2/askiuWrPJa9UbuGT4CwB3xk/QuqcORlCu88vKMVc84joNj22xu3YJtmfT0dqPremmUchdLW1rY99Kv6O/vBaC2tg5N8xInQ4MDNDQ0IslyxWMF4ODB/ePihu7uTvr7e3FdSKUSdHd3sXHT5in3VmahkxjTFWJEgUYgEAiuP3NKrpw9e5YHH3yQQqHAwMBAJbnyta99jUceeYSPfOQjM1rnv//3/8473vEOPvShD7F7927+7u/+jm3bto0bq/y3f/u3HDx4cFxypaOjg+eee44f/OAHk9a0bZsHHniAe+65h82bN9PZ2clf//Vf82/+zb/hgx/84Fze7nVnxr3O14HeQAOnwivZOHoJ1XW4d+gNnmq6C3uW0wDKiZWxuK5DoZDHdmxsywIkZFlCVmT6+rygSZLAsmwKhSJVVf4xa0m0tm7FMIxK4iEcjoxLRHRcuoiqqvh8vkrwdaUgabGxUEoagUAgeLtiGAYPP/wwhw4dwnVd1q9fz/Lly3nuuefYt28ff/M3f7PQW5wXxibwdV2nre0YxUKBTCaN48zeML89uJQNvg6ainFiVpZb0xc4FrtlnnctcenieWzHIZmIY9s2oVCY9vZzAOTzeVzXiwWHh4YJR7zCjOO6FIpFIpEIwWCwcq5euYAxPh6bqv1noZMYV5qEKAo0AoFAcP2Yk6Htv//3/54PfehD9PX1jbv/D//wD2c8ihm8yUDHjh1jw4YNnDlzhs9+9rO88MILaJpWec473vGOSdLcc+fO8du//duT1CzgtSwdPnyYnTt3cvr0aXw+Hz/84Q/5p3/6pxn1SV9LFEUhFApP8ogBJu1N0/Rp15FlGUmS0TRtkkpIURR8Ph+KqiLLV1cxKvNq9UYSmlepqzEz7Im3zcu6ZSzT9CpSjoNl2eRzeUbiw14fdXUNuA6xaBRcUGQF0zTo7LxIW9uxSYHEWFO5clvQ4GA/qVSC9vZzFVO3xWTytpj2IhAIBG93vv3tb2OaJr29vezZs6dy/yc+8Qn+5V/+heHh4QXc3fxSPjeblyxl9+67uHXLdtauXTe3Io8kcbCmlbL2dmvyHDFzfv3jZFlicHCQgf4+isViyZTWrihaA4EAjmN7hRvbIpPJIMsysiTh9/kmJT8mxg0tLctpalpCVVU1TU1LaGlZXnnudCbzLi4tLStYvnzlgviapNOpaRMoi8FsVyAQCN5OzEm5cuDAAZ588slJX+w3bNjAiRMnZrXWypUr+epXvzrt47/927896b7777+f+++/f9rX+P1+PvWpT81qH9cDx3EoFguTRihLkuT5kMgybsmwbbrARpIkHMdBkiQsyx73PEmSUBQVy7Kx7clKkbliyyq/qtvJe/v3obk2t2S7GPDXcC68/MovngHl96Bpmtfm4/NRKBRYvnwV2dEMRcMAXEbiI2RGMxhGkYaGJnRdv6z8NhKNsnr1WvL5PD6fD1VVKz3Vi8XkbaF7tQUCgUAwngMHDvAHf/AHRCLjW2BlWWb16tWcOnWKu+++e4F2N3euZLoaiUbJZNJcbG+veJzMtk05rsc4GV3DrekLqDjcNXKMf218B+48TUEsFouT4qNMJkNXVycbN7ayd+99HD3yBj29XYRLfiwNjU3s2XPXOKXrdESiUfbuva8ytXAsU7X/TIwnxiZjrgcihhAIBILFxZySK47jVMbejU2wXLp0iVgsNj87uwlxXbeSGBkbHJRVK+X7vCSJUmp/eet54XCEfD6HbZeTKuMDDC8p48xrYqVMUo/wcs0W7hnx+qn3xE8wrFeR0K/mEJdQFBnvbbvouoZhGJ6Dfz6H67g4rksuO0q81PsdicQwjCLFYhG/3z9JfjsxeGxpWU53d+c4uW48PjIuQOru7iQYDKFrOoZ55eBrPlnoXm2BQCAQjGe6GMdxHDo7O2/IOGcmX8LT6RT79r1AOp3yYhVZJhQMkh0dndW1DsfWszzXT8zK0lhMsCnTzsnolQcVzATPFF/GdZ1x9zm2zfHjh3nggYfZtv02CsV85b1u3Ng6o3O1HD/oml6JG7q7Oyuf1cT2H03XOH3qJMVCYZwp7mIwsxUIBALBwjCn5MoDDzzAX/zFX/D1r3+9EngMDw/zhS98gXe/+93zusGbjYoqpaRUkSUJXfdRKOQrSRdV1YjFqhgeHsRx3kqgZLOjFXXHdMqW2RjQzZb2cAuNxTgbRztQXYf7hl7nX5rvxpS1K794AuX3KkkSkizh2Db5QhFFlryWJ1VjZGQYRVUqah0kiI8MU1dXz+rVawgEQuPWHBs8WpbF6tXraGlZNmXPcTlAsiyL9vbz4wzvfH7/dav+LHSvtkAgEAjG88ADD/A//+f/5AMf+EAlxrEsiz/+4z9GURQ2b1783l0TCw0z+RKeiMdxXa8ApJZai6ORKJZpUiwWZ3xtW1bYX7uVRwZeAeC2xGl6/fVXWYzxUBSlpPZVKu/HBSTJ88o5d+40tbX1FU+2cqIEvJYfF3dK9c7Y+CGbHZ00fXDiSGZN1zjZdpxCoTAudrjeZ7iIIQQCgWBxIblzaKzt6Ojgnnvuwe/3c+bMGd75znfy+uuvU19fz/79+1myZMm12Ot1JZ1OE4vFSKVSRC/zJfvggZd56cXnZ7Smpmn4fH5UzTNZNYpFkCQUWSaZSuHYDo5jI8sKPp/O6tXrOXv2JJZllYIJz2fFdZ3LBjpzkfLOFMW1eaT/ZeqMFAAXg838qu42L7KZJV5iRcYtJYvKt8uBnd8f8KYM2Rau46IoCo7rEIvGiFVVV8Yy7959Fy4up0+dZGCgH4D+vl78pfHL5VGKY4NNgHh8hFwuS2fnJTKZDMlkgqqqaiKRCBs2bGbFypmPnb4aMum0MJxbpMz074BAILh5ME2TD3zgA7z++uulRP1qenp6SCaT/PjHP+bBBx+c9ZrX82/JVCoVGD8ZZ2wBoaLY0HUOH36Nnp4uHNsmGo0hKyoD/b2zSq6UuT1+ktZMOwBxLcJTzXdjX8X0oPJoa68t2sLn8+O6XpHEi5t8yIpCbW0duC5btm7nzJlT9PZ0Y9s2saoqZFkhGAzin1BE6bh0kdOnTwJeksY0DELh8LgYY2xSZuLzGxubZqyQmW9EDHHjIGIKgeDmZ07KlRUrVnD8+HG+//3v8/rrr+M4Do8++iif/OQn33Z/LM6dPT3j50qShKIqVFfXEB8ZLnmB+FF8Pny6TrFYxHG8KTqGYTAw0Et9fWNlrKDj2EiSXmqjkZjYFjTxWrquYxjGvE4fsiWFX9Xdxvv6XsLnWqzK9RFPneNY1ewnAriuC2NUOG4pISTLMj6/n0AwRCwaJZ/Pk81mMYwiiqpgGAaZTJpQKEyxWOTc2TOMxIfIZDIMDfbj9wfJ53O4rku/UaS7u4tYLMb+fS9gmiaapnH33ntZsXIVmXSa7u5OLyibxvDuWiMmAgkEAsHiQdM0nnrqKX7yk5/w3HPPkclkePjhh/nkJz/J6tWrF3p7V2QqlcqKlaumVHFOTMTs2LGL1avXAS5VVdW8vP/FSovUbHmjegNLCkPUmBlqzAy3JU7xak3rnN9XsVgc41GnYNuW1xLkujiWiaLIKK7L4EAfkqzw4ovPo6kauXwOx3YYHR3F7/cTCAZoaGiqeKaUE0vlwpTf72fnzjtIJhMAjGYytJ08Ni4xNVYx4vf755xYuZIPzkwQMYRAIBAsHuaUXPn4xz/O97//fT7/+c/P935uOEZn0YtsmiY+20HXdAoFz5StaBTx+XQikRiQxrZzuK5TkaYGQ400NDQxONiPJMmYplEKLmC6nImiqCiKF3iUJc3zmWDJaCFerNvBA0OvIgG3pc6Q1CN0BJtnvdZUpnmO45DLZgn4g+Tz+VIrlI1hFJFMr0Uok8kwIg95sl3bQtV0hocHvWlDhRw+nx+5NJUpn89y/PgR+np7sCwTWVb41S+f4b3v+zeTRlHOxPBuIvMRHAkEAoFgcfDYY4/x3ve+lw9+8IN88IMfXOjtzJrpWkWm+hI+MRFjGAYbN20mnU7R09XF6GhmzvGDLSm8WLeD9/btQ8WhNXORAX/tnGKFMuXWaq892sG2PbWvp2CxcfFioGIhj0/3kct6iZWyh12hkMd1XfK5LKZh8NwzP6ccUG3ZugNN06ipqcXFpa3NS6icyrZNahOaLlk1G4QZrUAgENx8zCm58qMf/YhCoYDf75/v/dxwZLMzT664rksul2NwaBDXdT1jWsumUCjS0FBF85KljIwM0t3VjSRJFItFsqMZ8vl8xazWcd7yK5kKr6IjYVlmJfmi6z6KxcJ8vN0K3cFGXq/ayK7kKQD2Dh/hp02hOfVUeya/Mj6fD9M0kGUZ27YZzWYoFr1/Z4qqomkapmlimRaWbUHJn0bVdDLpFLmsp1bxy36isSi6z08gECAQCHqfneuUPGxskskk3d2dbNzUelVVHxEcCQQCwc3FK6+8Qmtr6w3hrTIVY4sGV/riPzYRY1kWuVyO3t5uTrYdZ2RkmEQiflV7SehRXqvZxJ54GwB3Dx8l0RwhrYWval0om9tKOI43gdE0DbZvfwedXRcZzVBSlQQoGgVkWap40pmmgeO4HD78KvF4nEIhj98f4Pjxw+zZfXelZbicbMrlciSLCYKhEJFI9LLJqtkgzGgFAoHg5kOey4v27t3Lz372s/neyw3J0qXLZvV813VQFQVd19E0HZ/PR119Pal0klQqiSwpBAIBHMfGdR0ymfS46T+SJKFpGnqp93js/bJc8mQBVFWtKGDmO7FS5kR0DedDSwHQXJv7B1/Fb8++Lxu8z6W83zKaqqEoCrKsYBSLWJYnATZNAwmvfcg0DUzTZPnyVZVKVrFYZOWqtezatZu9e++jpWU5kUgUXdORZamk7JEZHhoik07Peq/pdIqOSxfJpNNTBkcCgUAguHF55zvfecPHOJFolBUrV037Zb18jgHs3n0Xy5etBKCz8yIHX9lPoeDFDZI0pzBxHKfCK7kQ9GIF3bW4b+h1VOfqpxqWpy8ClVahdDrBllt3YNsW+XyeVCqBhBcf+Xx+FEUlGAxhmiaGaZLP5z3Faz6HZZocOLCP06dP0t5+nnwuR39fL8NDQ6TTKeIjI+RyObq7u+YUO0yknNgChBmtQCAQ3CTMSbnS2trKxz/+cX7+85+zadMmdF0f9/jv//7vz8vmbgQ++pu/xf/47/913FjA6VA1DZ/uo1AooKoqkiRRV19fCV58Ph8SnqS1jGXbKLJSUXPIsoysqMiShBpUMYwijuOiaRpIpYSEqpIdzVwzU9sKksTLtVuJmVnqjSQRO899Q6/zdOMenDkEZMWiAbgVXxRZlgmHowSCfkzLwLJMVFWr+MiUgymfz0tSybJUUqa4+P2+cYa0e/feR3PzEk6fehPHdSpB18GD+6c09itX+6b6eaxSpbV1603v1C/angQCwduJlStX8v/9f/8fnZ2d3H333YTD41UWH/jAB2hpaVmg3V09Uykug6EQqurFHrquY5gGoVCYUCiELEuVZMuckCRert1CjZmi2hylxszwzuEjPF+/c05m+OOXfiu54jg2qVSKU6dOYDtvFWxs2yJWVQWuhGEUkRWZSDSCUSwSCATI53MEAkEMw0TTdDKZDH6fj9raejKjmVIRxyvujAwPcfLkcbq7O65aqTobhZFAIBAIbgzmlFx56qmnWLFiBfv372f//v2THn87JVe+87++NaPEiqZp1NbW4vMH0TUN23Hw+3ysWbsegPb2cxUJ6tKWpZw5XaqKuC6yLOG6MpJUMn91HSzbIRAIVqoeoXCEwcF+jGKxkniYClmWkSQJ27bn5f3bksJz9bt4X/8+QnaBpmKcd4wcY1/ttjkETW+1OpmmSSaTxjCKNCiN2LZd+s8hVAoCFUWhtq4eXdfJ5XIVozvHdem4dIlopApN1ypBy47bbmfdug2cOtXG4ED/pDGLEwPOza1bONl2fFwAOlV/+s0cHIm2J4FA8HbjZz/7GUuXLuXChQtcuHBh0uO33XbbDZ1cmUpxObY9yOf3c9vOO0gmEtTW1nH8+BGKpdhirliyyi/rd/Levv3orsWKfD87k6d5vXrjVb2XsmpXlmVcFzKZNJIsYRpmZb+maWIYJvfe+0CpNcilpWU5o6MZXnrpV4TNCLqmsWFjK6+/dhDHdZEliQ0bW0lnUhTyeUzLQpK8UdB+n29SG09vTzfd3Z0sW7aC5iVLp9zrVIUKYUYrEAgENxdzSq6cPj3zCTk3O6lUYkbPM02TeCLBju3rKBr5ypfVlpZluLjk81nOnTtLMBgkk06VRgy6yIpCMBCgUMiTz3vmbYZhEAgEWbPmFoKhIJcuXmB0dBRZknB5y/BtKjyj2/lJrJTJq36er9/FwwMvo7oO67Ld5BQ/b1xl0GTbNoVCgaGhQRzXRdd9gIvP5ycUDuE6bqU9qKa2Br/f+5xM06Snp4uurkssW7aCcCRSSQpEolE2bmwllUpOUptMDDi7uzovG4CWXztVcHSzqD1ET7hAIHi78bd/+7cLvYVrynTn2NhCQdnQdWRkeFyi4mpIaRF+VX8bDwweQga2pM+T1MKcD8+uvXoslmUhSXLJsNY7e8GLdaA0pVFRCQaCmKbJxk1v+ei4uITD4VKLj8ToaIZgKARAKBRG0zT27r2P7u4u8vksINHX14OqquNih96ebp7++VM4rkvbiWM89PD7JiVYRKHi5omLBAKB4HLMKbkieAtFUcd5olwOyzQ5ceIwv/bu945zpD908GVSqRSjo2k0TSWTyQCeb0pDQyOqptLf14c3ftlLnhSLBQzDYDSbJpvNUigUZtQGVDZ0m2+GfVW8WLeD+4ZeRwK2ps+TVQOcjqy8qnUdx6FQKJRap7wEi+PYDA8NEQwFyeXz3HXXOwmGPBXP2PDPdb1pTsFQaFxSYDop7sSAc9myFZOSMDOR8d5MQdR0UycEAoFAcGMy3Tk2tlDQcekihUKBVDI5r75tPYEGDlW3sifhGdzeNXKMvOKjJ9Aw5zUnq4clJElGlikND7AYGRniyOHXqKqqqiQ+EvE4xWKBeHwEyzLp7+/D5/OhamrFuDYSjY5LyGTS68d9bul0ihMnjmJZFrKi4LguXV0dhMLhcYmE2RQqbsYkxM0UFwkEAsHlEMmVq+SBBx/m6Z//y4yfrygq8fgwt99xJwCnTraRSqVQSu096VSKYrGAqmo4jsOSpS3ceus2Tpw4yrGjh8lmRytjCHt6OikU8oCEoioE5EDJwPbq5LtzpSPYzMGa1spUgD3xE+QV31WNXQRPwaIoXpCUz+cwLRPb8szqZFnm5f0vsu6W9USiUXw+nXgiUfJfgXA4PGVSwGX851MOZlatXEs8MVyR9obDEbq7Ose1OF1JqXIzqT1ET7hAIBDcfFypHaWmphbTMGZcPJoNp6KriFmjbMpcQsblvqHX+XnjnQz7qubpCi7RWIxUMgm4lbbigYE+fv6vT7Fhw2aqa6rRNI2B/v7KZCBZllEUhVhVNatXr5vy8xkbO5QTBl6By5s4pKoq1TW1HDr4MoVCAdM02LPn7kqholAoYBrGJK/CiWvebEmImykuEggEgsshkitXyYkTxy77uCzL6LqO67pomo4kQU1NHeAdou0Xz1dai2pr6wiFIhQvnKVQLIIL3V0drFy1mmx2lGAoSDabrZjOFQoFikVvOo+qqgSCQaqraujr68Gy7BkERRIwv0mYU5FVBK0CW9PnkYB3Dh3mF427GfBfneLBtu3KCGrTMCr3lycqHT16GFVVUBSFpUtbqK6uJRgMUl1d400LGnOITzKl3byVtpPHvBakwQEaGhpJpZKEwxFcXLp7vPagsoGdi1tJpLi49HR10X7xfEUqPFeT28VarRI94QKBQPD2IhKNsufOu/n5vz5FPp+vnL/zxaHqVgJ2kVW5PjTX5oHBQ/ys6R3zMqI5FqvGcWx0XavESOApdxOJEQ4deplwOEwwFK4MFyj71Lmui2WZVFVVTVp3YuzQ0rICx/F84FqWrSAUCrFly3YMw6BQKDA42I/rwoFX9vHAgw+zuXULBw/sR9N12tqO4eJiGua4M/9mTUIIFaxAIHi7MOPkSn9/P01NTddyLzckPd0dl33cdV1UVSMSiWKaBj6fjzNn3qSxsYme7i7y+Tw11bXYjsP69ZtpaVlGIj7MSHwERVEIBkN0d3VWEinlQABcHNdBUVQ0TSUcjrJl63Zqa+sY6O/j5Zdf5MrWKu64gGK+eKNqA0G7wLpsNyoO9w+9xs8b9xDXY1e1rqIolf5q13VKJnZKxaRX13T8gQBr1qxjZGSYTCZNNjtKrKpqnPJiYvDS1d1RUfw4rkuhWETT9cpY5XE+LN2ddHd7yZZyj3d58lBjQxOars/J5PZmrVYJBALBjUAikSAUCk2rKHg7EgqHqamtYXQ0g2WZlTbo8tl3NbiSxEt12/EPGDQXRwg4Bu8eOMDPG+8ko4XmvK6u6xSLeWzbmxY00Vjfdb3YqVgslqYtlmMJrxAmyQqhYIi2tmOEw5Fx5/DE2AHcSsIgMsbbLZNOY5oGrutdXh8TT4RCXvKoUChw8MB+QqEwlmWxevU6WlqW3bRJCKGCFQgEbxdmPC+3ufmt1o577rnnWuzlpsR1XXK5bMkjpUi+UKC/v5dz507T3u6pVuKJEQKBAC0ty4hEo9y99z4aG5pY0rwUn9/PsmUryOWy2LaN7tNRVQVZLhnTSl6rkSRJRKMxVqxcRbFYqJi5lZEkiWAw7LXJjHnscua3c0aS2F+7lW5/PQA+x+TdAweoMtJXsaREKOwZzCmKgqZphMJhYlUxwuEQxUKeXC5LKpmkv6+/ZMJnVAKY48eP8Oyz/0pfb08leAEq3iqyLHvjnCUJv89XCWrKzzUMg2x2lHw+VwmuMpk08ZGRylqFYnGcN8uKlatmHEBMVa0SCAQCwfXhN37jN3jppZcA+A//4T/wxhtvLPCOFp5EPE4gEKSpqdlTjZrGvCRWytiSwnMNu4hr3jkZtgs8PPAKETM75zXLqpHyXh3bRtN1fD4/sqLguuDYtheTmd7oZd3nY/36zWzZsoPly5YTDIUqpvYdly6WDG+ZFDu0tCxn9+672LBh87iCSCQa9VqBqmtobGjC5/ePiycATMNA07xiTH9/LydPHufgQW/65lRrXol0OjVur4uR2cZFAoFAcCMyY+VKOBwmHo9TU1PDiy++eC33dNPhui6jo6MEAoHKfdnR0ZJhbRPFYpHVq9dWDpzmJUt54MGHx7n2+3x+JLwRyo7joOs6Pp8PgGKxSLFY4KUXn8fFpX+gb5xxrSzL1NbW47oO4UiUzo6L1/49SzK/rN/Jrw0epLGYwO+YPDRwgH9tupOUFpnVWoriqVN8ug9cF8cBWZYAiVw2h6Ionmmd42AYOdovnse2LdKBAFWxalRNnSTPnVhBCYcjxOMj6CXlydjKSuvmrRw4sA9d1+nr6wW8BEgmkwHXxTCL1NbWVZRHcwkcFrJatVjbkQQCgeB6EYlEiMfjABw7doyHHnpogXe0MIw9D8rnUj6fm/cpg2VMWePpxt28e+AANWaGUCnB8vPGPfPSIgSglBSugUCQolHAMi0URQZJwsVF0zSampsIBIKkM960IcuyaDt5nEIhTyQS5V3v+rXLGgFPZKo4LhGP09q6FaPkudLWdoxUyrve2PHOs01ACOWrQCAQLB5mnFy5//77ueOOO9i0aRMAH/jAB6Z97o9//OOr3dcNw+7dd3Pw4L4pHyv38cqyTDQWxe8LICsysiTTvKSFixfPo+s6fr+flpbl41470bU/EAjQ2NhIX18fkiRRNIoEAgEv4VCiaBQ5cfwoiUQcVdVwXYhVxYjFqpBlBUWWUTWNqqpqEon4NTe9tWSVZxru4N0DB6k3kgQcg4cGDvCzxnfMWPbrfYYypmkyODhQuT8YDOG4DkbRQFVVbMdBcRxcF2QJdH+AgD/I2nW3cO7cWQzDQFXUijx3YvByOV8RwzQIhd8K8pYvX0Umk6IsNi4Ui6xfv3ncRIHZslCSWRGUCQQCgRfjfP7zn+cf/uEfOH78OH/6p3/Kt7/97Smf+9WvfpUtW7Zc5x3OPxMT67093ezf9wKO6+D3BVi/YSOtrVsZGRmed8+VsRQUH0837hmXYHlo4MC8JVhs28LnC+H3+8nmRrFsC9eVS2OaFWRJ5sKFc0iSjKoqrF69jkR8hAvnz+I4DsNDQ5xoOMad77h7Vh5k5edOdc66uLS0rKC2NktfX++k8c6z4Wb1aREIBIIbkRknV77//e/zd3/3d5w/fx6AlpaWa7apG4m999wLwKuvvYIzprITDodZs/YWerq7MEyjZGir4bgugWCQixfPVyoYV/oyXa4e2Y6Lz+8jEo6Ry2VpWbaMlSvX8KtfPUsu58loU8kkuWy2VGVyURWV0UyG6uoahkeGcWzbSzSoKpZlXfMEiylr/KLhDt49eIA6I03QLvLQwCv8a+M7GNWCV3x92VxuIoZRLE1NsjFNB0mWkSQZ3aeiKKrXAx2N0Ny0lAsXzmFbNrIkI00TvPT2dNPd3VmZEjSWiaqSlpZlwLLKmGaf31+67+pYCONYEZQJBAIB/Lt/9+9oaGjg1Vdf5dixY9TX108b55RVozcyUxm779v3Av39vbiO51VSLOapqa1j06Yt9PX2YFoWXMcEy8MDr/CvjXfOKcHiFbaUUgLFG628ctVqUq8nvfcHSJKMpmr4/H5GhodRNa1k0eJi2RaO42JZXlx37twpbr1166Tz8XKxQ5mJ52x3V2fFKF+WZXbs2DWjWHA6blafFoFAILgRmXFyJRQK8fu///sAHDx4cNqKztuRbTt20NHRTl9fD+Ad6tFYFZZlsW37Ttrbz+P3+SgUiyh45maO42AYBitWrrri+mVVQ3d3J2dOn2IkPgR47UCNjU3cdtvtnGw7TjgcJpvLYjtOxUulWDSIRqOMZkdRFYXUaAZjzLSd64Gh6PyiYTcPlYImr6/6ZZ6+iqqUoqgYhjcFwHVdXNtGkjz5byAQ9HxSigYXL10gWRrNbNs2zc1LpgyOnv75UziuS9uJYzz08PvGBUljVSWarlXUJTeDOZsIygQCgcA7t3/jN36D3/iN36BYLPKJT3yCXbt2LfS2rhlTGbu7rgNuyeDe9YYOO46Dpqps234bx48dqcQP16IwU1B8/LxxDw8NHKTG9Ioxj/S/zDMNdzAyyzHNkiSDBJqmef/pGslkomJea1kWtm2Ty+F5r6gqTqntOpGIEw5HUBQZ2wZZUYhGYpOKD1eKHcromk42O4qmeUplJGncZz/TWHA6FoNZrGgvFggEAo85jWI+ePDgfO/jhqbtxFEGBvsrX1J13UehZFzb3LyUWCyG43jqijJTfZG93OEUiUbZuKkVgJMnLXw+H6qqEo+PsG7dekZGhnAcB9M08Pt8GIaBJMn4fDoDA/1IEti2526/EBRLVamHBl6h2hwlbBd4pN9LsCT0mR3EkiSjaipqSZkyNriTZRlFVXEpqVksg2wuSzw+QqGQR5LkUkVKmrRud3enF2g5Noqs0NXVMSlAikSjuLiTpL1XExAtBhZDUCYQCASLiW9+85sLvYVrzsTE+rJlKxgaGiSdTmGaJqqqEi5Nsmm/eN6LbXw+TNOsJAauBcVSguXdAweoNdMEHIOHB17h+fpd9AbqZ7yO49hIroQW1KipqSWZSNDf10uxaCDLUqkNR0FVFUKhCLZtUyjkURSZk23Hqa2rR1YUFEXF5/MhSRK5XI5MOl05J7u7O3FKcYjjulPGDul0iraTx9BL5rU7d95BOByhuzSlcL6KGguhfC0j2osFAoHgLeaUXAFIJpP8zd/8DadOncJ1XTZt2sSnP/1pqqqq5nF7NwbxEW+yS/nLvmkaOLaNonoqirFfXoFxX2TLCRVN1zhy+HXy+TyBQIC9e++b8nBqaVlOd7c3mjk7Ooqu6+O+IOu6zqFDL9Pb01PakydhLhYLSGOqJWUkSULTtOuiZvGqUnfy7lJVqhw0PdNwB0O+6iu+3ufTWbFiNd3dHeTzhXGPOY6LbXsHu+u6FPIFTMtElmRs28bn0zwpt+vSceniuERCdU1tZRqToijU1NRNef2btYVmIYMygUAgWIzYts2TTz7JoUOHSCaTrFq1it/8zd9kw4YNC721eWGqxPrecITu7i7ApaqqGsMwyOVynD9/hmQygSIrhMNh0td4Ik1R0fnXpju5f/BVmotxNNfmgcFDvFi3g0uhJTNex3Vd8vk8w8NDOI5NPp8HwHGoTFQ0DBvHzRAMBnAcm1A4hGlapNNJLNNC17XS1MccnZ0X6e7uqCQPli1bwbFjR7AsE1XVWLZsxaQ9lOMGTdfRSob5N1tR42aNjQQCgWAuzHgU81jeeOMN1qxZw+OPP87AwABDQ0M8/vjjrF27lsOHD8/3Hhc9Gza2Vr7UQ1nm6U2QKU+PKRuojr1dzvafPn2S/S+9QE9PF8lkgv7+3lKAM5lINMrm1i2YpgGSxIED++jr7ams27xkKXfc/g7q6uqpqa0jGo0iSV4SxXE9VY2iKKiqiqqq+AMBFGXOObZZU1B8/GvjHgZ1L5lSHtPcnB++8msLBdrbz1MoFKd41PVc/cMRDNPEtm1cx8V2bGRZoRws9vX3cvr0SQ4e3F8ZWZhJpTw9jyThAul0csrrTxzDKFpoBAKB4OYjnU5z++2387nPfY7Tp0+Tz+f50Y9+xK233spf//VfL/T25o2Jo3E9hexmNm5qpXnJUlasXEWsKsbQ4AD5XI5CIY/PF7jCqvODKWs807ibjkATAAou9w6/wYbMpdmtYxoUi4VJhSUvXpMwTYtioUAqmcSyLDKZDKZRrKhdVVXzlLGKd/aXkwcAoXCYcDgMruezFw5PnoQ4XdxwM40lFrGRQCAQvMWcvlV/6Utf4kMf+hDf/OY30TQNANM0+cIXvsAXv/jFt92o5rXrbqG6uoah0jSbcovK+vWbJx2cY1t/xmX7XQfHLicC4HLtO6Zhomn6pPHC5WslUwlkRSHo86HpOkuWLuPUqRMUC0UsyyQQCGJaJhISiqxcc1PbiRiKztONu7l/6DWWFIYrValf1d9GV7Dpsq81TQNJmtzaA17DTzY76r3HYIhcdhRZltF1DZ/PT3V1LflCjkwmg9/nq1RXstkssiwjIeG6DvGR+JQtWleqNk31GtGHLBAIBDcWTzzxBJIk0dHRQV3dW0rGJ598ks985jN87GMfI/o2+XtuGib1DY0Ui0UUWcZ2HFLpJEZxqiLH/GJLCr+sv4074ydYP9qJBNwZP4HfNjgaWwfTxAITMUsFl7GUi2DgtUzbNvj9fmRJJhKNoWsaoSUtIHktRGWFr2l6Y5QBzp87w+DgAK7j0t/Xy4kTR7nzHXvHXedqVSo3QgxxsylxBAKB4GqYU3Ll0KFD/L//9/8qiRXwTMO+9rWvsWzZ1U9NudE4d/Y0yUS88rPrQn1dw6QJMpPc+Vu3VnqeI5Eofr8fy7IJBAKTRjOPpaamFtM0cF0vtiiPFy6rYdrbz5NKJUgBTU1LuPXWraxatZrnn/8FuWy2omJxbBvXdShehyBpIpas8mzD7dw79AbL8wOoOLxr6HVeqbmVs5HJ0tqxTJcMclyXbHa0IgX2Jjp41SnbsUkk4yQTcRzXxXUcNmz0PGzWrruFN988QS6XRZJlEsk4+176VWWi0urVa2lpWV5RHk0VOEw3anHfS7+6YquXQCAQCBYPhw4d4j/+x/84LrEC8LGPfYyvf/3rHD9+nLvuumuBdnd9KH+p13XPhFXXdWRZprGxmYH+PkzDuC6FGVeSeblmCwVZZ2vam1a5I3UGv1PkYHXrjBMsM/GJUVXN83VTVQLBEEuXtGDZltfu48KBA/vQdZ22tmOEwxGyo6OliYYWSHDu7BlWrVyDYRqTCjNzOft7e7o5eHB/xQh3MXuZiPZigUAg8JhTciUUCjE4ODgp8Ojv7ycYvPJ43ZuN9vbzSJKEJMu4joPP5+Mdd71z0kHT09VFKpXC5/Ohl3pvL+fHMh2RaJQ9e+7mwCveQe/z+yuvT8TjqKpKQ0MTxWKR5uYllTXf9a5f46WXfkk+l6NoFLFtm2LR8CYELAC2pPB8/U72Dh9lTa4HGZe74scJ2QWOxG6ZcdBUxnUcyrUpT93ijWBUVY1QKIxtWwSCQUYzGWRZ5vixwzQ2NtG8ZCm7bt/DyZPHCYfC2I5TSc4MDvaTz+fp7u6cFNhMq0IqyYZHhofo6uwoKZkUuru72Lhp8zx9egKBQCC4FpRjnIlYlsXw8DChUGgBdnX9mFgsWLVqDX29PSiqSvuFc8SqqlBVlWKxSKGQv/YbkiTeqN5IQdG5I/EmAJsyl/DbBi/VbceR5tThPg5ZlvH5fViWxejoKJlMxosZAkFSqSQtLSsIhb3phuUzfu269ZxoO45bGlgQCAQ4cGAfoXB4UmHmSkxUqKTTKQ4e2E88EUeSoKGhSXiZCAQCwQ3AnJIrjz76KB/96Ed54oknuP322wGv0vOFL3yBRx99dF43eCOwZs0tnDh+DNdxQJJoamqeZBCbTqdov+gpSsBTlJQP0bGH5UwPzuYlS3ngwYcnJWPKva/lKlNfXy9DQ4NYlkVz0xJ8Pj+WaZWqTixYYqWMK8m8WLedfMJHa6YdgO2ps4SsPC/XbsGdY9Dkui6S5LX5ZHNZDLOILMuEw1FUTZuk+IlEopV2o0DA6ykvm9/5fL5JJm2XUyHJsoyma5w/f8ZTBUkQDASZzaSmG0EKLBAIBDcjjz76KJ/5zGeorq7mkUceIRKJcO7cOf70T/8Uv9/Pli1bFnqL15SxxYJCocDhN14jM5qmWChimAbBQBBVU1mzdh1nTr9JNpu9Lvs6GV1DUda5a+QYMi6rc734Bg1+Vb8TQ9amfE1ZgXolZFkmny+gKiqGVQCkkg+Ljc/nI5/PVoYIlAtakWiUBx98mIMH9xMKhnBxK1OBLleYmchUyteyakiSPDW0WVLDCAQCgWBxM6fkyuOPP85nP/tZ7rvvvoosVJIkPvKRj/D444/P6wZvBMqtKAC4nonq2EMwnU5x+tRJXMehsaGJQrHI6tXrrvpL81QyzLG9r7lcls7OS5WDPj4ygmEWCYUiBAJBCoXCNCtfZySJV2s2k1X93J54Ewm4JdtF0C7wy/qdWPLcDHeLxQI+nx/HtrAlcGWFJUuWVIKWcoDU29PNC796lkKhQCI+wjvveYBVq1bT3d1Fe/u50sjG8SZtE5UqE1VI8fgIgWCIQDCAbdvEYrHLtnqNTaZMNfJZJFgEAoHg+vDhD3+Y9vZ2Pv/5z49LHOzatYuf/OQnlUkzNytjxzSbpuG10rpe0cKxbQqFAooiYxgmoVCYXC5XiYFUVQUkLMu8Jns7H15GQda5b/h1VNdhaWGY9/Tt59mG28lokxVFM0msgHeO53PZca1O2ewokXweRVWxbcub9mMabNi4uWJqu3bdLTQ2NlWmNba1HSOVSgFTF2ZgcvFkKuVrTU0tPr+fxoYmDMNgz567RRwgEAgENwBz+tYaiUR48skneeyxxzh16hSSJLFx48a3pd8KwLlzZ7y2oJLKwjNEG69wKBQKDA0O0NDQWPqife0+q3LSJZNO093dWfFUCYXDFIbzFErBQjQWZXhoaNxry1OPJMlzx6+trSeXy1IoFLAsc0Z9y3PlZHQNWSXA3uEjqDi0FIZ4eOBlnq2/g7zqn9Oauk8nO2piGAaKqjI4OMhtt+0iHh+hupQEOXv2NNlsFsu2wIUjR15l1arVbNy0mapYFefPn6nIgcuMDT7LiZeJyS6/309z81JM8/KB0cSqVW1tHalUCn/JkFhIgQUCgeD68pWvfIXPfe5ztLW1kUwmWb16NZs2bZrWUP1mYmyRRtd1Dh9+jWw2g6IqSIZUUua6dHVeIhAI4vP5SvdJaJpGLFbF4ODANYsXuoONPN2wh/uHXsXvmFRZo7y3fx/P1+9iwD83dUc5eTQeCVmWiUQiJT88r+39+LEjhMJhZFlm5co1JBIjLFu2guYlSwmXxllPV5iZSqWiazrZ7GjFW6VcZPEKMlJl6qRAIBAIFj+Se71HxdwgpNNpYrEYqVTqilMBjh87yrPP/KxiMPvAg4+wZes2ADouXeT06ZMAGIZBY2MTGze2XreD0kuweAe94zj09nTh8/kJhcNUV9dy7uxpcrkstm2jqCrBQLDiiO+11biEwxFcwLFtstnRa77nxsII9w+9hs/xKl9Zxc9z9bsY8VXNei1d13EcF9d18ft91NU3oqkqSBJDg/1UV9cymh31jG4dF3CprqnhzjvfydKWFva99Cv6+3sBr5VrrCltJp2uVJhc3EltPGMfv9zve+K/kVwux+hoetw1p1pfcO2Zzd8BgUAgmI4b8W/JWFPbZDJJT3cnp0+/6Y02dl1CwSA1tfVk0mmyuVE0VbuuXiwRM8v9Q69SbXpxiY3Eq9WbORVZOSvPtvIY4amSQaFQmOrqGoKhIIFAkGQy6cVFoRCGaTI40F8qSjm86/6HWLvuFmD683/seQ+wfPlKrwhWKHgKlTvvJhQOC/XqTcqN+HdAIBDMjqt3AROwZes27r77PsDFtm1ee/VA5bGywgE8JcOylhXE4yNk0unrsjcXl2AwyI4du4jFqpBlhaJhMDQ4iFEs0rxkCUtbltHUtITmpiUsW7a84j/iOE5lXKGmaVRX11yXqt2Av5afNr2DjOJ5n4TsAo8MvMyqbM+s1zJNE1VVkGQJJImR4SFGRzP09/WSz+fp6enCKBbRdB1d10ryX5v29nP0dHeTz+dLFS3Pg6W7q5OOSxfJpNNEolFWrFxVaeM5ffokBw/ur/xuy49fKSga+2/ENAyCwSANDU3EYtWsXr122vUFAoFAILgWlBUWp0+fpK3tGC0ty1jasgyfz4csK0h456KiyBhmEduyMYwihULh+pjcAhktxE+b7qLbXw+AgsueRBvvHD6C6sysHajc4jUxsaIoCsFgCNd1cFyHYtEgEokiSzLJRJy+vt7KWZwv5CkUiuPOZxeXXC5Ld3fnuDN77Hk/Nqmj6TqhcBjDMKZsE7oS6XSqEptM9fN09wkEAoFgfpmbmcU8U3Znr6qquuJz0+k0uVxu3H2aplFbO1kKOpt1r4Z0OsUrr7xYOQxHRob47v/vf/E7v/v58fJaTaft5LHrVo2Y3G5Sj4tLPpfDti0uXWpnydKlbN26o+IHEo+PcPp0GyMjQxWJrOtCIZ8jk05dl9GLACktwlPNd/OuoddoLCZQXYd7hw9TZWY4Els/46qU67oYhoGu+/D7AxjFIul0GsuyKu1PAEuXLkPTNLLZUUKhcKlv3CUQCDAyPIRpmpjBEO0Xz1ekvuXf31SB0HTjmqdSn0yUYLe1ef9G/H4/LS3LicdHZrS+QCAQCATzwVTnWkvLcuobGjBMA9dRqa6uJhQMYZkWiuK1yb5lJn99YgVT1ni24XZ2JU5VTPHX5HqoMdM8X7+TtBa+7Ott25sxWG7zBc9DUNO8oQC2Y5MdHUVRVc6dPUOhkMd2bGzborqmhmQygW1byKVkTDw+gos7SfW6Y/uuyojmiVMiu7s7x7UYj93PxLaiqZgY621u3cLJtuPjYk3h5SYQCATXhzklV0ZHRwmHpz6wLvfYRFzX5ctf/jLf/va3cRyH+vp6vv3tb/O+971v2tf80R/9Ed/73vfGJUw2bNjACy+8cFXrXg2JeHzSdKCRkbe8TMpeHB2XLl63L8llE91ioYCm6xQKBeIjw6iKVqqWqCUXfZtgMFTZRyQapbPjIqqq4Tg2kiSh+/QFqXQUFB8/b9zDnSMnuCXbBcD21DmqzQwv1W6fsdFt2XCW0VEsyyIcDuM4DoFAmGKx4CU7IhFaW7dWEhuyLNPSshxV1ejouIQkSySSCfx+P6qq4jgO3d2dBIOhymSmywVCU/VZT0ywlH8OhyOT5MSzCbQEAoFAMHcKhQKapk1pXHu5x24mpvMVW79+U2WCjq7r2JZdmTooyzI+nx/DKF7XvbqSzKs1mxn0VXP3yFE016bazPC+vn3sq9tGR7D5imtMVK5omo4kubiuRKFYwI8f13HI5bKAhGVb9HR34zg2rguaqmGZBrquk4jHK6pXgEwmXRnRXD7/V6xcVbnW2GRL+cyfeN/lJghOTIRdOHd2km/b2PcoijQCgUBw7Zizoe10VYnLPTaRv/qrv+J//+//zYsvvsj27dt54okn+PVf/3VOnDjB+vXrp33de97zHn74wx/O+7pzpaamFp/PVzGOBaitrZ/yedfjS/JEE92q6hpGRoY9eavjoCgKPp8PRVUIBALU1NSOO7jXrlvP6TOnsCwT13HIpDPXZJ8zwZEU9tduJalH2FWaJLQy10+V8RK/rN9FUo/MaB3XdSgWC7iuSyqVrMhxI5EI+XyeHavWVszoxgY0R4+8jiSBqmiVgETVvARVe/tbKpbW1q0YhjGtJ8pM1S0weQrUWGWL8FwRCASCa8t73vMevvzlL3P//ffP6rGbienOnZaW5RWlhWVZmKZRin8MFEWuJFoWgkuhJcT1KO8aeo1qcxTdtXjX0OuciK7h9aoNuNLMOuFd1yWT8Sb+aJqGJMlYlllRujqODa6LZZkoiorPp3qTlFyXtrZjtLZuRVUUjFJM6AQC6CG99NrJ5/9Ukx9d3oqjr1ScGRtbWpbFSHyYVCpBCk81Mxc1jEAgEAjmxrx6rhQKBfz+mU91+da3vsWnP/1pdu7ciaIofOlLX6KlpYXvfOc7V3xtKpWadsTe1aw7FyLRKJ/6nc8TjVYBXmLld37381M+b/fuu9iwYfM1lWSWv8jruk59QyOhUIhIJIIsK6iqRm1dHcuWr6ChoYn16zeN8/R46aVfkkwmueOOO1nWshxV88FCD0eQJNqia3i24XaKkpcPrLKyvLd/34x9WFzXHdPm5HnjFIsFEokEiUScl158nsNvvAZQ8Unp7emms8ubtpTL5ygWC0SiMUzDoLq6hnw+j2EYFWXM5fxVJvZZzzawmal/i0AgEAiuHYVCgUAgsNDbuC5EolGqa2rG+cSNjWOqq6tJJhKAhCR5n42n7Fg40lqYp5rupj24pHLfrekLvHvgAAG7MOv1TNPEskwsy0LTNMAbN61pGrKi4LgOjuuiaRqhkKeKTSYSmJZZ+U+SZaQJ5//l/E/G+t0cPLi/pJCZ3oNl7O9k9eq1BALjfdvKyZvrEX8KBALB251ZKVf+4i/+Ysrb4P3Bf+2119i8efOM1hoaGuLSpUvcdddd4+6/++67efXVVy/72h//+Mc8/fTTmKbJHXfcwTe/+U22bdt21eteDZFolM/9uy8A3sF46mQbSJNH6E1VoZhvxlYx/H4/ra1bS6MUPUd9RVHo6elGkiSGBgfYtn1nJUEwONhPJpMml80SDIVwHAtNVTFN85rueSZ0Bxr5l+a9vGvodWrMNJprc+/wYRqKCV6r3oQzw6pUGS/Z4lWfkskErx56hb6+nsp0noMH9pPP5wj4A0iSRCgUJhaLYRgGXV2d4yb6TNcKNFbGO1v1yeVkwAKBQCCYX/7pn/6Jjo4OOjs7+ad/+ieOHj067vH+/n6OHDnCunXrFmaD14nKlKAxPnGWZbF69bpKTJPJpDl5so3RTBrbcVAVFUmSJpveSxKKLFe8Ta4HlqzyQt0OBjI13JE4iYxLczHO+3tf4qW6bfQGGma9ZrFYpFgsliYDQV19PZZpea3TulbxApRlmXw+z9DgIKZhguQVvNav30htbX1luuDllCgTla7gXlF1Uo4tvQmRnei6XvFtm/gcgUAgEFw7ZpVc+f73vz/lbfCkkytXruS73/3ujNYaGvI8Serq6sbdX19fz4EDB6Z6CQA7duzgwIED7Ny5k0Qiwe/93u/xwAMP0NbWRmNj45zXLR+cZdKz8Bj5+mNfrdzesnU7ly6247ouqqoSi1Vx9957aV6ytLTutf/CPNUX+b3hCN3dnYBET3cnw8NDKLICikJ8ZJhsdrTiG2NbFkWjiM/nQ9M0wg2NZEdHyeWypbHGzpQjC68HGS3EU03v4M74CdZluwHYnLlIYzHOC3U7rmheV0aW5dJEJE/NIslyJSiKx0cYGR4inU5jWxaKqhKNRNB9PjKZDI5tEwwGCQWDFIpFVq9eN+l3OZ2Md6a/8yvJgAUCgUAwvzz//PMcPHiQvr4+nn/+eQ4dOlR5TJZl6uvr+bu/+zsaGq785fxqYoqFZOzZk82Ooms6LjA42O9NzOvuYPfuu+ju7kSSJAKBIPl8jlAoRC6XRdM0HMetJFkKhTy2vQDxgiRxKrqKET3GvcNvELILBJ0i7x48xPHoGg5XbbhsQcbn82PbFrZtj4t33JJKxTQNQqEw2ewosVg9sVgVDY1NtCxbzpttJ7AsE3DB9SYvxkfiBAIhampqr9gmPLGFvKVlecXc/kqxo2gjFggEgoVlVsmVchXn/vvv57nnnruqC5cP3omtPZZlXdYo7jOf+Uzldk1NDd/97nepr6/nhz/8Ib/3e78353X//M//nP/yX/7LrN/H2MQKwPFjRyq3NU3Dsi0OHNjHAw88fF3d2qfy7di4qZV0OsWZMycxDKOUANJIloxaLdMiGAx5Br2mQVbJUl1dQ3VVDTRJdHV1kIiPLEygNAZbVtlXu41BXzW74ydRcKgzUry/7yVeqbmVC+Fl077Wq6zJ6LpW+gw8PxYsC8u2CAQCGIbBG2+8Si6Xw8Wlob6R7bfdztkzp7CsPLpvjIGtJE05jWo2HitTcbWvFwgEAsHs+Ou//mvAM87/6Ec/yvbt2+e81lxjioVm7NmjabrX+lpqpbUt0zPHj4+wbNkK2k4cQ9U0wkqE23beQTQaIx4fxrIsTrYdJ5fPIUkSsiyVztqyj4gEJU+Raz1ZaNBfw0+a97J3+AgtBa/4tiV9gebCCC/U7SCjhaZ8XdlPZWIs6bUYO1RX16JpGqlkgv6Bfurq6mlZtpwjh1+np6cLuxTnaZqOoipcvHiejs52b3LQjl2XVaJMlyCZaQwgFCoCgUCwcMzJc+VqEysAS5Z4/bADAwPj7h8YGKg8NhOCwSBLlizh4sWLV7XuV77yFVKpVOW/rq6uGe9hOmzbk8pqmufWPtUX5vnmcn284AVOgUCQ5qYlqIpKMBAglU4CEAgGMYoGkiwR8AcIBkOYhklH50XOnH6TocGBKX1uZjI1YZJU+GqRJM5EVvJU812kVC840lybd44cZe/wEVRnaj8e13VxHJtisVgaG/nW76NYKLBs2UoSiREkWSYQCODz+WhZthxd01FVFZ/Ph2XZVFfXYJoGWml08sTP+2o9Vmb6+iv9vgUCgUAwO77+9a9fVWIFrk1McT0Ye/b4/X723Hk3q1evQZJkMqOjDA0OoOs6zUuW8tDD72PLlm28570fZMdtu1i77hZuv+NOqqtrMU0Tx7Ypm7aNTaCU19c0bdrEiizLKMqcZi5MoqD4eKbhDg5Vb8Iu7afeSPL+vpdYXVLATsS27SmnHmmaxspVa8mkUwwNDpLP5ymWhgf09/VWpgTpuk4sVsXKVauprq5BKrUTlb3aNrduobq6htbWrVMmQq6Xz5qIIQQCgWB+mfPJlUwm+Zu/+RtOnTqF67ps2rSJT3/601NW8aciFouxdetWnn32WT70oQ8Bnrrk+eef5/d+7/cqz0un05imSW2t9+XSdd1xX9QHBgbo6Ohg1apVs1p3Ij6fD5/PN6vPYDrKLSc1tbXU1TXg9/uvi1v7TFpJyoGTrCgEgoHKdJzRbBZd0wgEAuTz2cpn7LqeF4thGJMqTF6vsY9IJEomk0JVVUzLqjjkj0XTNGRZwbatefVviesxftK8l93xtsq45rXZbhqKcV6q3c6gv2bK100V0FmWxeHDr3HXXe9EliRQFFRVZd269YTDESzLYnCwHwDHtgkEg+i6Pq37/9VIc2fyetE6JBAIBNcG27Z58sknOXToEMlkklWrVvGbv/mbbNiwYUavn8+Y4noy1dljGAbNTc0UikX8Ph+GYZBOpzAMg40bW8edO7093fR0dwLgut5kHcdxxsUPrusiy0qlLXcqvMemLpLMCUniZHQN/b5a7hk+TMzKorsW9wwfoSU/xMHqzRiKftkldF1HURTaL5zFcRxs267EQZIsEx+JYxQL5EuKHUd32bixlTNn3qx43gUCATRd42TbcRzHIZVKEg5HrsnZfaU2dBFDCAQCwfwzp+TKG2+8wYMPPojP52PHjh1IksTjjz/OY489xjPPPMOOHTtmtM6f/Mmf8LGPfYzdu3ezZ88e/uIv/gLHcfj859+atPOlL32JgwcP0tbWRrFY5F3vehd/9Ed/xObNm+ns7OTLX/4yS5Ys4eMf//is1p0v/ujL/3lca9Cu2/cwOpph48ZWGhubJn05vpa9sDNpJSkHTt3dnZw5fYqR+BCy4iWD1q5bz+uvHUSWFVzX4ZZ1Gzhy9HUK+fyYpJaE65bkrqXKTC6bRdN0LMtC13TMUstRGa/6JGGYBu6EIGs+sGSV/XXb6A3UcefICXTXImrleHjgZdqiazlcdQuONDN1jSS5xOPD7H3nu+jt7SYcjlQCn9Wr15HP5/GXAmbDNNB1fcpE2VRBzWz9dq4k7RWtQwKBQDD/pNNp7r33Xk6fPs2ePXuIxWL86Ec/4rHHHuNb3/oWn/vc5xZ6i9eUiWdPTU0tPr8frXTe6Zo+5Zfy3p5unv75U56ao1hAVTVsW8J1JxdUHMeujDaemmvTKjTiq+InzXu5M36CtSXVytpsN0sKQxyouZWOYPOUr5NluTR62hwXv7iuSy7nFaRGsxlkRUXXdKKxKqpiMTRNY+/e+yqed7GqGN1dnRQKhWmLM/PBTBIniyGGEMb9AoHgZmNOyZUvfelLfOhDH+Kb3/xmZTSdaZp84Qtf4Itf/CIvvvjijNb59V//dYrFIk888QRf/epXufXWW3nhhRfGmcXFYrGKOa3P5+Mb3/gGX//61zly5AjV1dXcfffd/Kf/9J+IxWKzWnc++aMv/+dpH5squXGtDpCJJmiXm2BTdpA/edLC5/Oh6zqFQp6GhsZKdSqdTmFbNpqmI0lQW1dPMpHEKvVda6rGaCZTGW3sOJ6MdmzgoWkakixjmeY1N8FtD7UwpFfzzuEjNBgJZGBL+jwt+QFeqttOXI9d9vWqqmEYJoMD/QwNDWKaBoODA5UJQi0ty+ju7qhMTli5cg2BQICWluXjfqcTg5rWzVtJphK0t59HVdV5qxDN5Pd9rRABkUAguFl54oknkCSJjo6Oceb4Tz75JJ/5zGf42Mc+RvRt9HdvopolHh+Z8kt5d3enl4CwzNI5aRIIBCkUvJjAtm18fn/Jr0zGskxM8/p7uFmyykt12+nx17En3obuWgTtIu8aep2LwWYO1NxKQRmvOrpc/CLLCk1NzQQCAVRFIZvN4Pf78ZVUy5FolKUty+jp7uLI4dcxigUGBgaoqalF1VR0fXrFTPms1XQN0zBnfObOJHGykDEECOWMQCC4OZHcOUgI/H4/3d3dkybyDA8Ps2zZMvL5/LxtcKFIp9PEYjFSqdQNFURl0ulplTGTvvS3bqWt7diUP1uWRSqZYGhoqKRagVisGsMsYhQNCoUCiqKg6zqGUZzgqP+WWV354L6eSK5La/oCO5JnUCgFF0gcjd3C8djaSRMCJElGksDvD9DQ2EQsFiORiJNMxFFLiaU773wnGzdtrow5PHPmTSzLJhAIsHfvfeM+645LFzl9+iQA2ewomXQa27bI5fJUVVcTi1WxZct2VqxcddXv9XK/72vF2ykgulH/DggEgrnznve8h49//ON85CMfmfTYtm3b+Pa3v81dd901qzVvpr8lmXSagwf3TzoD+np7+Jef/JBCoYjjOuiaRixWTTY3ik/34fP7UWQFTdMYHhkmn8tRKLwVLyqKglRKulwvglaeO+MnWJ5/y6evKGscqt7M+VALzMAvTpIktmzdjmVZqKpaGlu9tlJ4KZ+ZqVSKRHwEFxfH9uKspUtbCEciU56j5dcVSp4u9Q2N+P3+GZ250/2OpnreQk0WGhsrAWzYsHle4qLFzM30d0AgEEzNnJQroVCIwcHBScmV/v5+gsHgvGxMMDcup4yZWMkwDGNSm1LZgyWXy3L+/FlGs6MUi0UUWSEWizEw0IcsS2iaiqKoSJJELFY9wZz3rXzdQoxsdiWJE7G1dAca2Dt8hFozjYzLjtQZVuZ6eaV2G4O+KkAqxU0urutV1UaGBwkGAji2N27asW0UVam8p/JnOzIyjOvCyPAgL77wPLftvL0ybrtcDSoUCvT39VEsFrFtq/SZF8nncuzceUdlv2NVIC7uvLYOXQsWg5RYIBAIrhXlGGcilmUxPDxMKDT1hJm3C9N5gjUvWcq77n+Igwf3EwyGkGUJVVEJhUKomkY2O0o4EkHXdArFArmSD0kZ27aRZa+V2LYn+61ci2JNTg3wXP0uVud6uSPeRsAx8Dkme0eOsn60gwM1t15R9SrLCoODnhKlvr6BQCA4TtFaPjP9Ph+2bePiIiGh6zq240x7jpZfVywWcVyXYrGIruszOnNn6vu2kJOFFlo5IxAIBNeCOSVXHn30UT760Y/yxBNPcPvttwNw6NAhvvCFL/Doo4/O6wZvdBZT+8RUB9lUI5sj0WhFodHcvJRcLofPpxMIBGlqXoJRNNA0jaAlgp4AAHhZSURBVGwuSzAYAlwSicmTjxZCtTKWhB7lqea72Zo6y9bUeWRcaswMj/Tv483IKt6o2oAlv/V/gWKxgCSBrCgEQ0Gy2VFs26ahtrHSRjUWyzQZzY5y6VI7PT2dvOv+h1i77hYi0Sitm7dy/MQRQqEwxZLBryzLqKpKtGQQCONVIOVJTPPZOnQtEAGRQCC4mXn00Uf5zGc+Q3V1NY888giRSIRz587xp3/6p/j9frZs2bLQW1xwpvtSvnbdLTQ2NtHd3Ul7+3kcx2F4ZBjHtioFB1VTMQ0TdwpfFc+LZWq1yDWLJySJ9tBSev113BE/yZpcDwCNxQTv73uJM+EVvFG1nqIytUGx6zq4joNRLHLpUjuhUJju7s7KGV4+MzVdL8VQBTRNJ5GI4/P5pj1Hy6/z+3y4rotlmViWNeMzd7GPZL5a43+BQCBYjMwpufL444/z2c9+lvvuu6/iryFJEh/5yEd4/PHH53WDNzKLrX1iNgfZxOcCk27rus7hw68RHxkpVZrsyutlWUGSJXBcrpUx3UxwJJkjVRvoCDZz18gx6owUErA5c5EVuT5eqdlCT6ip8u/YNE2GBgeJRKNEo1FcYPnylRVlTiQapaVlOU1NS+jr7UVRFCzLwrZtDh7YT2NjEy4ubSePYRoGhlHE7/eTz+cA8Pn8hCPRyuc4VgVSbqeLRCLjKlmLKUEHIiASCAQ3Nx/+8Idpb2/n85//PNlstnL/rl27+MlPfoKiXNkg/e1MJBolGAyhqiqGYaCpKkYpDjIMA8sa78FWnrDoui6O48yr4f1sKCg+Xqzfwfl8C7vjbcSsLBKwYbSDVblejsRu4XRkxTiD/PLes7ks+XyOhoYmYLyq08UtFWgkWlqWAW/FUIZhTDpHx5755QEElm1hWTZXYrHFC1disSeABAKBYLbMKbkSiUR48skneeyxxzh16hSSJLFx40aWLVs23/u7oVmM7ROzOcimUrWMvZ1OpwDQdM0zqXMdrNKYZUWR0XUfBbcwTt4rSTKue/3VLHE9xlNNd7E5c5EdydOorkPYLvDg0KtcGm3iUM1msmoQSZLQdI2+3m5c10VRVTo7LzE0NDguQbZ9x050/QRnz5zCNE0cx67IdcH7fbulzykajTE8NIhpmgQCAXbs2FX5LMeqQAKBQGW/5UpWb083Bw/sR9d1fJfptb7eAZUIiAQCwc3MV77yFT73uc/R1tZGMplk9erVbNq0aVpVxduV6c6emppaLMticLC/4i9SKBQmJE4kZFliyZIWAOKJOMUxz3HdhUm09AQa+NGSe9iUvsj21Bk018bnmOxOnGRzup0jVeu5EGoBWfYUKZpGwB8gGAxhGAa246CqCiMjQ4yMDNHX14vjOJiGQVVVFc1Llo6bIji2eJNOp9j30q/I5/MVTzdcsCwbn8+HqqrTxpLTFfRutISLQCAQ3MjMKblSZvny5SxfPrldQuBxo7ZPpNMperq7ACZNwhlLT1cX+XyeUChMKBRGkVWGhgYoFHLYjotRLABuJRiVZRkXcK9cfLkmuJJMW3QNHYEm7owfZ2lhGICV+X6W9g5xrGo97Y2bSSWTFAoF70XFIqlkikAgWEmQubicbDuO4zhEYzHiI8Poup9UOsXIyDDNzUsqQSWAbdkUi0UkWSZfyJNMJmhesrQS8LS2bq1Ur+AthZCLy8GD+4kn4kgSNDY0TRlULTaFlEAgENwMlCcSCqbmcmdPJBpl9ep15PN5/D4fw8PDJaNaiWKxiIvrJSZUlQ0bN7Nu3XrOnTvD+XOnyWZzjIwMIcue+fxYVez1wpFk2mJruBBays7kKdaVxjZH7Dx7R47Smr7A0drNDFWvRCopcnK5XCmpZDIyMsTg4ACO7Y2clmUZSZY5cGAfu/fcRSqRJJGMc/FiO4oiE4lE2bv3Pnq6uujv78V1IZVKcO7cafr6ekmlEji2QywWm3a60FQFPRdXxAcCgUBwHZlzciWZTPI3f/M3nDp1Ctd12bRpE5/+9Kepqqqax+3d2NyI7RPlqkl/fy8ATU1LJk3DKT/vzJlTDA8NoigK9Q0NyLJMbW0t3d05cB0kWUaTFUzTQJJkwCUYCDI6mlkw2S9ARgvxi4bdrM72cHviTYJOEc212Zl4k3XZLg7WbSOjVVWePzwyRCAQoLqmZtwYymx2lFQyiaJ4/zdybJuzZ09x6dIFmpqWkM/n8fl85EreLapcnlIkXTEoBc9JvzwG23UZl4AZy2JUSAkEAsGNjG3bPPnkkxw6dIhkMsmqVav4zd/8TTZs2LDQW1s0lM8ewzAoFot0d3excdPmyuMtLcvo7u7AcRyqqqu9WECW8fn96KWzraq6mnXr1pf8V1x0n5++Pi/+mKnHiqwoaKqGJPFWYWSeyKt+9tVt52R0NTsTp2gpDAFQY2a4r/8gQ8lzHK7dTDK2FEmCZDJOJBLFNAzKkxMty0YvKXxN0+KZX/ycQiFHLpvFcRxUVav43E2cTpQd9Z6jqRqpbJJgMEhb2zFc3Mpo5rIRvq7rkwp6043NnoqZKlyEEkYgEAimZ07JlTfeeIMHH3wQn8/Hjh07kCSJxx9/nMcee4xnnnmGHTt2zPc+b1hutPaJRDxOPp+nnPvI5/OTDuN0OsWrB1+ht9er5FiWha77Kn3ojY1NJBIJKOQxLbOUSPHkvX6/H9u2Ste4dgkWRVFxHHv6a0gS7eEWuoKN7EieYWPmIjIQMzL8Wu8+zoeW8mr1ZgqKD9uy6e/vZcPGVlxcRkaGGRkeIplMYNkWEiDLGrZtk0mnkWQZy7QIhcMlc9ooPn/AG9OoqIBLT3fXlAHP2KClpqYWv99PQ0MTpmmwZ8/dU/5bGjudyDSNaataIIIigUAguBLpdJp7772X06dPs2fPHmKxGD/60Y947LHH+Na3vsXnPve5hd7iomBi68+J44crbS8wucA0Opqhq6uDZctWgAtd3d5tF5dfPvcLOjovYRoGjuMgSfK4FqypznJVVSv/6/P5yWTS1+y9xvUYzzTupqkwzM7EaRqMBAD1hRF+reclBuJ1nG7cQn+gnkQigWmamKaJJEkoqorrukTCURKJEWzbU7OW35Pj2OQLeXp6utm8+dZKcSYQCBCLVXHixFEKhQKOY5NIJNA0nYMH9hMKhScZ4Y9VwpbPeMuyKutNp6Ceqh1pNq1HAoFAIPCYU3LlS1/6Eh/60If45je/iaZpgGcE+oUvfIEvfvGLvPjii/O6ScG1p/ylW9d1AoEAqZQXOEw8jMsHcMeli2SzWSQJVFUjmUgQq6pCVVV0n4+a2hpGR0eJjwwjy3IlABgdzaAoaskI1uZamd1eNrEyBlPWOFTTyvlQC3fGT1BvJAFYm+1hWW6Aw9UbOB1eiWlavP7aQdrbzzI0OOhVxyQI+ANIkoTP56uY2ikoBINBVq9e50lOJImqqiqSyQTt7efp7Lw0KSCqqamdMmiZ6SjF1s1bOXBgH7qu09Z2jHA4ItqHBAKBYA488cQTSJJER0cHdXV1lfuffPJJPvOZz/Cxj32MqPjbWWr9WUsmkyadTpHOZDhwYB8PPPDwOCVm+baLS2Njs9dae/I4hUKB7q5OmpqXMDw8jGPb4/xWZEVF13VMw6icmWU0TcMF7NL9xWLquihiRyLN/DzYQMtoLzuSp6g2vXHSjflhGi/9kmF/DW/Wb6Y70ISjeAWUYCBIVXU1saoqNE1jeHgIw/BUPDJe4sixbdrbz1EsFtixYxfJZIJ8Psep0ycrqh7XdTFNg6GhAZpLPjUTjfCTyURpiqPHVBOZpqKne3w70kQVUhmhlBUIBILLM6fkyqFDh/h//+//VRIr4B10X/va14Sp7Q3IxC/d3sGehJLD/diDs6xsUVWV/3979x0fR3Uu/v8z23elXTWrF3db7gWDuyk2hBJMIAmGQCDBAZLcQBISEggEQvgFuBfIvQnfEAgQSkJJKMF0MGCDwb13IyPZ6l3aXW0v8/tjtYNWxZZk2XJ53q+Xk9fOzM48Wi0zR8855zl6vS5W9FWvw2q1MmLEaGw2G01NjZSW7sdgMGCxWPH5vNq5IZaMMZki6PWxom/RKASDfm1etaIo6PV6IpHeJUi609f3NZlTeTNnHmPbypnRugdzNIRZDTO7eSej2ypYO2QKHp+FpqYoHq+nfR61QlpaOjabjVGjxrJzxzbUqIqiV1Dal13esX2LVoy2oKAooaetqGg4NptNS5wcPFDWpdEydNjwXjVcgqEgScnJCe/t/D5pFAkhxOGtW7eOX/7ylwmJFYDvfOc7/M///A/bt29n3rx5gxTd8aWgoIg9u3fGVghUwGg0HbY2mKetDRQlNoojHKG2rhaF9toqioJBr8disZJfUECSzU5ZWQlut5twONI+TVYl1F48H2hvhxxZmyE+neZwQqEQer2eg7Ycyq3ZjPRUMsVZQko4tqrUEH8zCypW0WpOYVvKaMqsufj8PmwBG3a7A5/Xh92RQlJSMsOGj8Dr8VJZWY7f7yMSidDmdmkdMc3NTXg9Hgx6A0FFQa+PjdAZMiSTeMdUx0L44XBYa3vFO1BampsxGAzY7XaAPjz3u/8cT9RagkIIcaz0K7mSlJREfX19l4ZHbW0tNpttQAITx07nP7qDwWC3PRYQe7BarVb0Bj1Wqw2/34fRaKKlpZnU1FSSkpPZuXMbTmcLkUgERacjNS2dluYmLO2jPAJBP4FAAIgl5UwmPUajAbfbjV6vx2g0tvdSRdunLB+j+iyKwj77UA7acpjRupcxbeUADAk6uaj6U770jWJ37jTCoTC0F+NLTxvCtGmnsWbtKrw+L0ajEbsjhbTUdNat+xyvx4PeoCc7KwdQEobnFhQUdlldob+Nlvjw7EMN/ZVGkRBCHF68jdNZOBymsbGRpKSkbt51arI7HMyeM581a1ZhNJqwWCyHrQ1mMplobW1FVWNtDoNejyMlhaSkJNraPKhqBL1eT31dHSmpAbxeb/sUIZVYo6CrIx210tv6LrFj20fXKAr7kwv5MqmAYd4apjhLSA/FpialBpycWb+RaQYbexwjKA0PZ7PLhd6gJz0tnZTUVCZNmgpA20cuyg/GPg+Xy0VLSzO1tdXtxfD9ZGQMIdnuQEHF7kjBYrF0Wwjf6/VQXn5A+3nio15789wvKCgiJycPt9uFTlFITU3r9rgTsZagEEIcS/1Krlx22WVceeWV/OlPf+KMM84AYj09N998M5dddtmABiiOvr780W13xCraV1ZW0NBQR2NjA9FoFLPZTDAYJNjeS5KdlYM/ECAvL59wOEySLQkUhWgkQjAUxOVsBcBisaDT6TEYY3OSw+Ew0WgEg8FAKBQ8Rp9AIr/ezOrMadTmTmBG7SZs7noUYFTLfgpdFWwaMpEvrAUoOh3uNhetzlat8Cw6HTpFobLyIF6PB5/fh9ViJRgMkpKacsjrHkmjxe124WlzE1VVwNrtMdIoEkKIw7vsssu44YYbSEtL46KLLsJut1NSUsLdd9+NxWJh8uTJgx3icSU3L59zz73wkM+Wzh0As2bPY/v2zYBCa0szyUnJhM0WwuEIPr831jmjxFYWslpt6PV6rW3gdrsTCtfqdDpUFdRjtBShqiYmYlRFoSwpjzJbLoW+eqY4vyCrfYqxI+xlZvNOprXsZb+9iH2pI/GYzKigTb0ZO3a89vMkJSVrU510+lgnVmHRMKZNmwHQ42dsdzi0orgd23K9fe7bHQ6mTZ/B2jWfYTT2PL04fqy0H4QQonv9Sq788Y9/5MYbb+Scc87RegsUReGKK67gj3/844AGKI6+vv7RbXc4GDd+AgWuQtau/axLUkan02E0mVB0OlpaYskWa3sNktTUVNat+5w2txtFUQiFQyhKGL/fi8FgwOFwaMXgejtM92hQVZVybLhGf53sg+uZ2rwHoxrBHAkwp24TI81lbMyehtE4HJ/XQygYJD0tVrV/2LARVFdV4m5zY7VYsSUlMXvOfILB4GGH59odDlRUmpubtNeH43I5WbvmM1xuN4oSa5z1NPT3VG8USUFfIcThLFmyhNLSUn70ox/h8Xi07aeffjrLli3TireLrxzu2dK59kd2do6WkAkFQ1TXVFJZUU44HCIcDmM2mYlGoyQnJeP3+4lEY6NZ0tIz0OuNNDc3xuqWKArhcESbdtxfOp1OW9Ww30s/KwoVtmwqrFnk+huZ7NpPvr8RAJMaZryrlHGuUiobc9iXPoad7TGnpqbFpgz5fOh0OkaNHovL7dISUdOmzeiymmB34m25yorEVYcO9bvR6u0ZTVRWlmM0mjCZTDJ1WAgh+qlfyRW73c4LL7zAAw88wJ49e1AUhXHjxkm9lRNYf/7oVlEpKBgKqKSmpGnJmXiixuv1Ul5eBsSr+qu0trQACqlpaQT8AewOB0ajEY+njWgkiqpGCQQCRCLhQ106wUAmYRRFaa9BG6v7EoyE2ZM2hi8tuZzRsosR3tgSkdmBZi4o/5jqcAO1yiKMJjNer5fRo8eSm5tHU1Mj2Vk5BINBZs+ZT25ePm6XS1vVx+v10tTU2OWP/Pi8dL/fT6jDezvqnCCIFyKOL9kcCnW/ZPOpTgr6CiF66/bbb+eHP/whO3fupLW1lREjRjB+/PiEFWxE78Vrf5jNZnw+H5WV5YwbH1uBb93az3E6nXg8bSiKEuuUsCUxa/Y8jEajVsfNYo6N+DAYDBgMxvbnvtI+cjaAqn7VFlAURVtxqKf2hE6nR6+PJVUMBgPBYBBVVY+8TaEo1FgzqU/OITXkZpzzS0a4KzCoERSg0FtLobeW1oZtVFdtZ2f2ODCaYjVX2mKJnQULzumSJOn47I8vv9y5DaGiUlkVG71SWXnwkM+5ju2Nhvo60tLSaWlpJjMru8fpXUIIIQ6t38kVt9tNUVERRUVFAx2TOAF0/EM1HA4TCoYIR8LaEn5Dhw1vH6J6UDumtHR/+9LOjaQ4UnC0j9IwmUzodA68Xg9OpxOdTqFvHUexxlUoFFv2uS9zr3U6PTqd0r70YzyxEpvXHQ6HsTvM6H0+vAYrKzNP4wtfEbOad5Aa9qBDpaB6O1kNJRwYNY96az6lpftpampg4sQptLbGVlxKTrZTXVVJZWU5DkcqFeXb8fm8uJyt1NRUJSx52NLcjN/vp76+FlWFNWtWMXvWfILtCZN4Q7RjgiA9PQOzxfJVMqeHJZtPdVLQVwjRG4sXL+aWW27hrLPOYv78+YMdzkmh47LNAKWl+ykoKNLuy2azGZ1eR1JSMiajKaFjIT09g5qaKny+WNFXh8OB1WqlqrqKaCSCwaDH4cjE4UilpaUJj6eNYPsKQ/H6KN1R1Sh2RxqeNjde71cjlHqbQIsX0Y2/p2PbQ6fTYbFYiTgcbHVkszPoY1jzF4xtLSUpElvhJzXgJLVkBSNLP6csdSTlWcV4ramsWb2KWXPmUVlVjt/vZ8+eHUyaPI0DZV9q7SkgoXBtxzZEb59z8WMDgQBRVSUSjZKVlU1Wdg7jxk2U56MQQvRDv5IrFouFpqYmMjIkq32q6vgAd7tdtLa0YDAaE5bw6zjdKF5oTadTtAaS2WRmxumz8Pt9hMNhamurCYdCfRqSG2vQxBober2BaDTa62WYY9SvhhTHh36gYDKZsDscuJyt7eeKna/amsnreWcxwV3KNGcJhmgYU8jHmD3LGWLNoGrq1wna7bS2tmhzn3fu2EZDYwOKouD3eWPLLravdtDmdiU0ftLTMwgFg/EVnAGFNWtWkZScjE6no6CgSPvcY42unYwbN1FqqfSCFPQVQvRGUlISdXV1gx3GSUVFxWFPwe12YTbFR69UUFBQiE6nw2QykZOTx4gRo7sUe+84pchsjk05NhiNmM1mTEYjHq+X5GQ7tiQbw4ePZM+enThdsZEwoWDPtdsURSESDncZpdLb9kNPiRW93kB2dg46nQ6dXoder8fr8VJqSWJXyigK2qqY4Cojyx+b/muOBClu2sPYpj3UO/JpGT2HL/ftpa62FpfLicFgYN3az0lJSQWgtaUFo8lEWlpalwRKX55zJqMJj6ctFqeiYDGbMVssx0ViRabwCiFOVP1Krnzve9/j3nvv5aGHHtKWlhWnlo7F6aKRSKc56F81MuLTjb4qtKZis9qwO1Iwm4zsL9lHUnIyztZWwqEwoXCs1orBYGxfKQhsSTa8Hi+hULBLoyf+OhKJoNPpSUlJ1VYq6qhz4yfWM6Uk9PAQVdHpde2V8lNwOl0Eu2mYRRUdOxyjqEgbwczWveQ3fxn7THxNpK15lobCqSiZ12krL9XV1WrFebVGnBrrNVMUhfT0jISGRMeVF0KhICaTqcN7FW1qUUN9rPHvdLYya9Y80tLT+1SrpaNToSEjBX2FEL1x7bXXcu+993LeeeeRltb9qimi9+IjXQN+P263G5fqRK/XU1paQkFB4WHvy52XEy4qGobbHVuVJxAIEAqHCQQDeOs8lJR8gUGvx+fzdllXyGAwoKpo04Si0Shtbe4j/vmMRmN7x04UnU6PyWQkJzeXQCCA2+0iGlWZNv10Nm/egN/vozy5gKqUYRQZgxRVbafQVY5ejaIA2a4qsje9jGfHu3iSimixDyVotmGxWHC7XLjdTvz+ADqdDrPJRLLdnpBA6e1zzuVysnPXNkxGE8FgkAVnLsRoNB4Xz0aZwiuEOJH1KzOybt06Vq1axUsvvcSYMWO0P/7iPvzwwwEJThy/OvYk2ZKSMRpN+P1+7A47BQVdp4pphdYqyykt3Y/BYMDjadO+O0ajsT1BokOn02G1WjEYDWRkDGHs2PHU1lazZfNGIu11WQwGI6oa1aYB6XQ6bDYrw4YPp7rKQH19A9HoVwkWVVXbE4EKihJrVHUdIaOiRlUUgw5VVTAaTQQCsQr+8WJ38UaZTqfHhZ5PMqeTaSvgjIatpAScKEBWxVbUf/4G39gz+TJ9dGxp6UgY2uM0mcyEw2FsNhvTT5vZ7VSfeKE/kylWtf+rocAqEydOoaLioBa10+mkpGQfTU0N3TZGDpc4OZkaMof7WU/1gr5CiMP7+OOP2bZtG0VFRUyYMIHk5OSE/Q8++CDTpk0bpOhOPPGRrkaTCbvdTigYIjUtDYPBQHNzE0OHDT/kfbnzaIx4G8PZvupgJBymuamJUChEJBLGZDKjKAqOlFSamxq1jpUhmVm0trQktB1UteflnXtDUXQYjSaCwQAAUTWKouhobmqizePG6/WCquJpayMjYwje9pEiAJaicWw2pbLV52ZoUwnF7oNYA7FkT1KwjRnB3Uxt2cuB5HwORifgScvH4/FonTQtLS3Mmt31ed3Tc67j87Hj78RoMmE0Ghk6bHiPP+ex7IA50abwngqdU0KI3utXcmXOnDnMmTNnoGMRJ5COPUkejwev14vZYsFoNPX4ntgqQxMpKCjqkjhQVZXc3Dwi0Sh6nY4hQzIZkplFQUFR+8NKwW7/An/AjxqNkpWdQ319PcH25IderycpyU5jYyM+vx+dXpeQXImLFblTiERCXQNUYomXSCSC09kSe7grSqwIn8mMotPh83qIRCKxUSfECubV27JYlncW49xlsVWFoiEUfxuF294mMy2PnUPn4sorIBgMMGZ0MXv37aa1JXb+fft2EwqFujQkOjY2k5PtWlKqvPwAlZXlTJw4hYaGemprYwV2S0r2kWSzYexU5b9z4mTCxMmEgqGERsCJ1pDpycmUJBJCDJ6xY8fyk5/8pMf98REUonc6Jkfs9tg9OV4vpDfTM1VUMjKG4GnzMGr0GO2+Hl8Zx+1y0dLSTDQaIRqN4vV6UHQ69J42cvMKCAYC+Hxe3C4ngYA/YRRrNBrFZDIRCkX7VK8tzpHiwGwyxzqEDAYCwQB+v5/q6sqEka9erxenqxWT0YjFYiM1LY3UtFQOHNhPGAO70sbSNO5Msp2VZJVtINsde7YbiDKqrYJRbRW02oawK6mIUls+Eb0enU7X7eha6PoHf+fn48SJU7qdPtRdouBYP1tPpCm80u4QQnTWr+TKAw88MNBxiBNM/OEXm55Si6LoCEdCJCcl0dzc1GMle0jsVUlOtnc7QmNIZnbCvOuCgkIyM7Oora1BURSam5sx6PWEOhSea2xqwGK2EI1GcThSaG5qTLhuvAhcZzqdTmtUxZMMwWBQm4esEEu4+DxtWv+W2WxGVdXYikLBIIpOxy77cGqHjGZGyy5y6/YCYGmpZkbLy9TmTiDjiltpDat4PR5UVcUf8LcPbVa7NCQ6N3BstiRtCl58utGIEaPw+XztxXyDtLa2kpKaisViwWQ0cfBAGV6vN6FGy9o1n5GUlJzQCDgeGjID0fNzsiSJhBCDa+nSpYMdwkml81QVoNfTM10uJ6s+XaF1JNTWVZOTncuo0WPJzcvHlpSEw+HA5WpFp9MTG50aiXX0KAqhYJDcvDycra20trZgNIa7TDHuKUERXzUw1qHSfeIlGAgSDIZQFNApOixWKzqdjlA3qw2FgkEikQhJybHkXFVlBcH2bTqdDrPZirdwIrszhrO2bC+jWvYz2n0QUzTWGZTqbWSut5EZuh3sdwzDlTWv26RId6NhOz8fg8Fgl+lD1VWVrF37GUajCYvFwsQJUwiGggntiEM9WwdqBMeJNIVX2h1CiM6kYIrol/jDb8+enYRCIVpamlDVWCPFZDQdMpPf+QGcMEKjopzSsv2Ul5dpywjGEzVFQ4cTjkQIh8O4nK1aAgQUbRnF+FKOfVnKOR6nTqcjHA6jKIo2mkan0xMKhWIrEUWjqIDJZCI52U5qWjotLbEaJ6FwCF00StTmwD3jevZv+IiJB9eQ5o+tGJRTswv1Lz/COvMbGHQGAu31ZHSKQkFBkTaaJz09A7fbxdq1n2nxzZ49v9sESHp6BpWVsdUEWltaSEtLJxQMMm7cBHbu6jiVKNZLGAoGMXao3xJvBAx2Q2agen6OhySREEKIrjpPVentPb6luRmfz4eqQjgUorKigsbGBkpK9nHBhYu/Wi0vO5f6+lrsjlQa6mtjf/CGVWxJSWRmZmG3O/AHfHh9XgwGI+FwKFa/no612HSAGmsDtE8Z6tgpE58ebDTG2hvRaBSfz6vt0+n0WK1W9Dp9j0s5RyMRFEUhHI7g8bQRr6NmNJoYMiSLqdNOA6CkZAyeNjfKsGEYStbj+/RljA3lAJijISa0lqCuLSHUupvWWRezoTVEVKVL4fv4s76752PH34nL5WTtms9obmlGUSAtLV0rpt95daLunq0DPYLjRJnCK+0OIURnklwR/WZ3OBg3biJOZytGo5FQKLYMcLzRAV0z+Yd6ANsdDmxJiSM0KivLtVV3fD4v0UgEnS62QpDDkUJrawt6vR4VlWhU1eZSQ6yhpKrdN3Di+yHWgIoXo4OviuQajab2xlXi9KJIJIrFYmXcuAkYjSZWrFhOrEGm48yzFhEKBdllzeS9ooUMa9zH9Na9mKMhlKCP5FUvcl7yEPYNm0tLxlDmd1iGOT50d+2az6ivr8Pn82G1WlmzehXnnndhtwmQWbPmsXXLRjweD0ajEaPJRHNzk/azGAwGioqGYbMlJYwOOtww4P7o73kGqudnsJNEQgghDq2vz4n09AwMBj3hUCg2SlRR0Ov0hMNhtm/fwpw5C7T7vskUK85aVVXJl19+QXJSMgajkZ07ttHa2oqiKNiTYwVgk5NT2LVrK6HQV1OEFZ3SXmye9v/5iqLEVhFMTU1DVaGlpVmrswJfjXo1mkxkZ+eyf/8XgEokEkm4BoCnrY2UlFRMJlNsqrJOj9lsZkhmpvaZTD/t9K/eMHQENbkTqFjzAbkVW8hqKNEK4Eb3riO6dx3jbak0Fk2jqWgqMBSf14vb7cbusGufdfxzMpqMVFbGEjXxqdctzc3t8cR+dK/XS5LNhtvtxmw2M2rUGGy2pEMWHT4VR3BIu0MI0ZkkV8QR6e7B4na5eszk9/QAjje4TCZTwnvjxwWDQZqaGjHoDbS1ubE7UvB5PQwZkoXT2Yy5fTpQbBnjWM9TRsYQ/H4fXq8noRdJURTMZjNmswW/30cgEEj4mWLDc81YLFZCoWCsfkv7iBkUBZ0+VnDXZksiLT2dzMxMWltaYsV5VfB5vYQjYYLhMHvswyh3FHK6cx8jWmKrCtnaGpm2cxnR0TPw14zAnWxPqH+iKAre9kSS1+dtnwb1VR0Wl8vJwQNl2vBfl9uFx+PG7XKSkpLKyJFjcDpbE4r/dZ6G1dM87P72Nh3JeQay5+dE6e0SQohTicvlpKqygtLS/bFndXtnTG5e/iETLioqRqOJ1LS0WO0Uvw8g9mz3eFi79jNmzZqXUIw1PT0Dj8dNNBqlvq6W+vo6rQ0QCgUxWyyoqsqcOWeyZ89OgsEAwWAAo8mEz+slEokSDnftmElOdjBn7gJcLidbNm+kqSmx7aDX6zEZjeTk5lFTWxUbzRuIrewTb2eYzRYcKSmkp2cwceIUNm9aR1RVsdsd3S4GAFBdVcn2HdtwRkwcyJuJOWsq4/3VZJdvxhb0xM7rbSV/7wry9q7Es6sYnTEbty0bd5uburpa7dmoorLq0xVUVVUQjUTIyc1j4cLzvxoBlJVDMBhk1OixbNywlqiqolMUZsyYSW5efo+/31N5BIe0O4QQHUlyRRyx7ob79pTJ7+4B3F2htWAwqD2cKyvLCQQCRCNRPH4P4XAEl9PZ3kvlB0XBZLZgiUTQKTpCoSA2WxLZOTlMn346W7ZsZM/uXVqB26SkZNLS0wkGA9pyjh2pqorBaKRo6DBKSr6IrShArM6KoujQ63UEQ7GisPFRIn6/H7/fz0cfvUtKalqsCr/RiKqqBHQGPs+YQuPQ6Uw4uIaklkoAdCUbse7fTMWImRR89zawJuH1evD5fCjt1V10ikKo/Vrw1fxzt9uFTlEYNXosBoOBtLQM6utqiKqxIrm5uflYrdaExEp3v6uB6m06kvNIz48QQpy84s94p9NJc3NjrBi8Tsea1auYPXu+No21u8R8vHh+Wlo6AJmZWTQ01OP1eLAlJWkjXDuOqui4OmFVZUVCvRRVVXE6W/F6PHh9XqZNn8HePbvaR6LERt0q3SwepCg68gvy2b5tCyaTCaPJiMFg0KbM6HQ6bElJFI+biNFowmFPweV2otfriEYNGAwRIpHYuT2eNpzOVgIBP/MXnKO1d3qqY7J2zWc4W1sIh8M4UlIYP34m4XCYjRWn46jdR0H1DjJaKlBQUVBJrtrDHPbg1VsoTRnO5o8iuFzzsVptgILb7cLnjSWpamtqqKwsZ9z4iQnP4ebmJrKysvEHAljM5h7r0sTJc1wIIWKOOLnS0tJCWlraQMQiTiD9XfK24wPYZIxNYek4siQajdLa2oLNlpRwfGVlOTu2b6W1tYVQOITBYCASiRAIBAgGg3i9HrKysikqivVedUwsJCfbCQaDNDc1Eo1GSU5Opr6+HkWnoDcYUCIRIu3zoGPLQNtIsiVTX18HqBiNxoQ51LGRLbHaJSajidqaGm0Fgvgyy/HESnyOtsViIZJbxN6icUyItmBa+Ty6tmYUNUrWl2vwPXAVVcVn0VA4jXA4hF6vx2g0AlBQ+FWCpKqiguqqSrw+L6gQDkdISU2NNUz1saHS1VWVuF0ubQhzX5a47G9v05GeR3p+hBDHo7a2Nsxms3Y/Fn0XT75bzGaikUisdpnehMlkoqLy4CET852fLaNHFzN6dDFr136m1RUrLd2v1QOJJ2fiheBT09JxupyEQyGttkkkHCEYCBCNRtm+bQtJSUmxkbKqisFgJD6dJx6XoouNVq2qrCQQDIAKwWAgYcpwNBrF2drKRx++R2pqGh6PB3/7KJvYlCIzOl04VjsmHCuqGwgEaG1tIb+gkObmWP22jiN5jSYjX5Z8QVubG4/XA6pKa2ts6ej09Ay2bd1MRcjG7qyZDC8+l6LGfaSVbcYWjtWBsUX8TGzeA817qPtyJQcyiwmOnEY0EtVWn9brY0WA49fu+NmbLRaM7aOJe/NMP16e47I0shBiMPUruRIIBLjjjjt46qmnaG1t1XoFli5dyi9/+UvGjRs3oEGK48uRTiWJD02Nn6NjsbSeGkrjxk8kNTWNNWtWEWsIqOTk5FFdXUU0EiEQDFBUNDxxnnKH650xczarPl1Jc1MjlZUVXxWx1esxmc0E/AFAxWKxYjSacLud6PUGLVFiNMWWTzTodRhNZsLhCJWVFdrSzJFIrJEVCgXxtLmxWm0YDaZYpO1F5sKhIKFQEP+kWTRkDMf93jOMqd+JQY2i97dRtPUtMkrW4kyfQNicgRqKkpScTH1dLZs3bsBqs9LS2kwgEECNRmNLTep1jBgxGp/PS0tLM87WVgKBQCxuk4k1a1Zx7rkX9vj70ZJXFeV0213Xh9+p9FoJIU4Wzz33HHfddRcHDx5k+fLlLFq0iMcffxyr1co111wz2OGdUOIJEqPJRE5uHsFAEJvNhtliobBwaMI01s5/xPf0bIlv83o97N//hVYbpGNyJj09A7vdztChw3G7nRQVDaeyspy62hqiURWdzh+bQuT1aAXso+2F6/V6PTqdHlWNYjSasFptBEMB/D4/4XC8hkrXFYRCoRANDfWdtiqxDhydDovZgopKfV0dOr2OjRvWsmXzBuyOFG2Fnp27tuF2u6iprmqfohTSPp9gwM+e3TswGI3o9ToMRgN6nZ4Kl48D+jyCBenk++oY4y6nwFuLrj3G7LZasttqCVWswT/qdHabs2kwpZKank5BQSHQPnWrogIUhYKCQq1jq7eOh6SGLI0shBhs/Uqu3HPPPXz88cc8//zzXHTRRdr2Cy+8kN///ve8+OKLAxagOP4MxFSSjueIFV0djs1mw+v1UF5+oNtz5+blc+65F2qJgNTUVFpamrUlGmtqqnC7xnYbSygYal9SMZbIiY9SsVltWK022hQXkUiEYChIJBImGAph0Bswm83k5OSSnZOLxWKl/OABmpobiEaibFi/pr1mi1+rfWezJcfqtOgCBAIBDAYDBqMRi8VCS0sroLL8w3ewWmx4MiZQ6hjGpPptDHUeBCDJ08g5nk84aM1hQ/p4TOnpNDTUU1tbg14fa/jp9XrC4RAWs4Vku4OC9l6vFIeD2tpaQMXv92MwGDC2jw461O9HRaWyqrx9ePXBfjdGjpdeKyGEOBIff/wxt9xyCw8++CB//etfte2XXXYZp59+OldeeaWMZOmDwy3F3LkWWHfv77w9vq2mqoqG+jqtNoipfUW87q5bWVHOvr270esNQBidTo/BYKB43ARWf/4pBoMBFRWrxYrX5yUQCGAxJ5GWlk5BYRG7dm4/5LLM3VPQ63UMHzESv9/f3s7xtnfEtNHY2AiotHnayM3Np6LyIH6/n9qaGnw+n3YORVFiU5RVlcbGRkymeMH9MIoh1jFiNJoIhcJUJefRNGQEQ9NTGOE8gL1kDVafM3ZMOIBx72fMBLzWVJoKp6A2T8XVXosl3p7Kyclj2vQZ2oIClZXlWtuguyTK8ZLUGOjCusdDwkgIcWLpV3LlhRde4J133mH8+PEJ2+fPn8/SpUsHJDBx/BqIqSSdz1FQUKgVw40/zLs7d8dEQGlpmHA4RCQcITU1DYPB0OODND09A6s1NirFHwhg0BuwWCxMm34GW7esJxQKaSNowtA+J1whHA7R3NJEbV0NaWkZRCIRzGYLnrY2mpoatIe4Xh8rvhsMBohEItoyj8FgEIvFgl6nw+V2Em0f5RIKhlDVKC69lRUZ08hJHsaMxm0MCbQCMNRXS0FVHfsDxexMHwdmG+H2xFBaemzueV5eAdOmzcDucNDmdtPY1EQkEltK2mg0Ync4sFgsh/39nKpV/oUQojsvvPACd911F9///vd54YUXtO2ZmZk4HA62bdvGjBkzBjHCE8+hlmI+ksR8MBQ8ZG2QhHMrSmxEil6HohhxOBzMnhNb4TC/oJBAIKCtjOPzeWluaiY9I4PRo8cCsL/kC1S1JeH8iqJDp1O00atxOp2uPdGjkJuXzznnnAegrWq0Zs0q3G4XSvuI0diqQkEKC4dSVvZlexsiNgVIp1MwGg0oio5AwE84HGv7pKdnkGJKITsnj7Y2F01NjSQpSUSiUXJycjHb7RR+/du0uZzs/+QN0g9uIa12L0ooVlzX5mvF9sUnBP/7EyJFE0ix5dNgziSAnuamJvaXfNGlbdBx1HHHJMrx0o4YyMK6x0vCSAhxYulXcqWmpoZhw4YBaA8GiBUKO1zRK3HiG4gpID2d41Dndrmc7N2zi4Dfj0qsgr6nvV6L1+dF0Sl4vV7cLleX97U0NzN9+umMGDGa2toqPG0eisdNIBQKYrXa8Pn8KDodkfYEiwpEIzoiKrS2tMSm/oTDmMxmzCYLUTWKoujaly2MoNPpSUlNwWQ043S2EgqFMBr1qCqxonuRqDaCONb7FI3NZVZ0oEapVzJ4K3cBI9sqOK1lN7ZIAD0qYxv3MLSllG1pxVRkj0dvNJGclIzZYtESKwCtzhb0Oh3xHq709AymTJnepaBtd07lKv9CCNFZTU0NixcvBhLbOCDtnONNfJWb3tQGKSgoJC+/ALfbjU5RmL/gbHLz8nG7XFgsFm21wtSUNK2Tp6amCqvVRkFBIUMyM2lsrEdVYzVZTCYzBqMRh8OOQW+ksbGeSCSCwWjEZDQxctQY8vMLEp7D8f+fPXs+qz5dQVNTI+FwiCRbMrNnzycpORk1qrYnKmIjbC0WM5MmTWffvp3aSksAra2tJNvtTJgwieRkOyVf7MXj8ZCbl4/RaCQ9PQO328WHH71Ha4sXc9pkMofOJa12Lzm1u8lsq9U+G335LorZxWhFR6U1h+qMEbQmWdFbbNo07Y5F/CExiZKenkE4HMbn82G1WgetHTGQU5SPl4SREOLE0q/kyrhx4/jkk0+44IILEhoeTz/9NFOnTh2o2MRxbCCmgHR3jp6GYMZ7EPx+Pw31ddiSkgiFQugUHTp9LKHg9XgpLy9LmNrSZSWiCVOorDyI0WRk377deL0eWlpbABU1XrxOUVCUWKIiEglpMUQisSk5o8eMpaKinJaWJnw+Hzpi856Tk+3YbEnYbDbq62tJSrYTCPgZkjGEUCiE1+shGIyiKArRqErA78dsthAMBtHp9aAolKUMpyZtGFPbShlVtwtdNIwlEmBm4zYmuMsInnU1rVnZFBYN6/LZxQvtRlWVrKzsXiVW4r8HqZcihBAx8TbO4sWLE9o469atY//+/UyYMGEQoxMdHe751blNsWDBOV2OVVEpKBgKqBQUFGkJhGAwSH19LW6Xix3btxCJRrSOCLPFQmpKWqwgrAJOZwvJdjvO1laMBiMGo4H8/ALGjZ/YbSy5efkUF49nxcoPQVXx+b142jzs2rmd2roabdUih8NOxpAsamoriUZVIpFwrFC+TofJaMJqtVJRcZCCwiKammNF+/ft282IEaMwGU2sXPEh9XV1sTZHwE8g4KfOmkvJqAKyTArTdG04SjcQqY/VVtGrUYZ6qxnqrSZSvY7QyNNg0gIc08/WPq/uOmPUburPDJaBmqIsHU9CiP7oV3Llrrvu4uqrr+bWW28F4Nlnn+W9997j3//+N2+++eaABihOHT0NwayuqmTHjq3a0ouZWdntjRoDNdWVqKqC0RAb4guJPQydex46rkzg8/nw+/xYLVaCwSCqCqr6VaE6vV5HJKJoD9fk5GRycvKYNGkqkyZNZeuWTXz5ZQnBYGyIrd/nZ+TI0WRkZGIymWhtbdGK85otFiZMmExJyV5C4RDhUDjWw2UwYLMlodMp7XOxfWRn5+BOmsyXkfMxrXpJq8eSHHDB+49izCiidOLXSL7wCq0BkZoSW7FLVSEcClFXV8Onn37MggXn9DrBIkkVIYSAm266idNOO41gMEhNTQ0rVqzg/fff569//Ss//vGPSUlJGewQRQc9Pb96alN013Hz1RTlIu2P6kAgQDQSxe12EY6EUaMqZrOFQDBAJBzG5XISDAYwmy2Ew+HYUss6HeFwmJzcXAoKirq9TjgcJi0tjR3btxIKBkFRiHq8fP75ytiUn1AInS62io/RZIb2Wit6gwGLxUowGNAK7ft8PurrajlQVkpUjWIymb/q+NEpeDxt7TXhYlOMVFVFjaqgg6hjCOnnXkNUjbLtzecx7f6cQmc51misTaOPhNB/sRa+WEvonUdxTz0b84zzmHn6bFqcrQkJqviS2Xa7HeCkGOUhHU9CiP7oV3Llsssuw2Aw8Ic//AGdTsd1113H1KlT+c9//sOFF1440DGKU0R3QzDdbhfvvfsm4XAYv99HYeFQku12pk47jTa3m127d6CqKsOHj6SsbH+XHobOPQ8dVyawWq2EgkH8/tgcZp1OiRW0a2/E5OTm09TYAEBqWhpTp86goKAQFZWW5mZGjR6Dy+38amlkBWpqqhk9uhiV2NDx6dNPp7WlBZ/fS3n5Aa1hZTAYiEQjhMIhrBYrC85cSCgUpLQ09jN42trIHT2Wzwvnsd1WxOnNu8gJNANgbypn7CdP4KzeTsvC75I2fBzBUJDc3DwaGxtobQ3hcrvwB/xUVlYwbrz0sgohRG8NHTqUVatWcdttt1FaWsp9991HUVERd9xxB7/+9a8HOzxxGPERIl6v97DTOrprdwwdNlxbKWfH9q243C4MGAhFQ6CAQa8n3D69V1Vpf7+Koigk2ZKwO1IoKhpGc3MTbW43wVBQiyWWsKuirPTLWPIm2j6atX055HA4jAqoapSkpCQmT55Gbm4emzdvwO1yEQwFMRqNJCUlk5KSRnzMiNPZ2l6wPzaSNxwOEQwE8Xja2hcC1GE0GbVCzJFIhMmTp2N3ODh4oIxGczqNBTNZk1JMtq+Jkd4qhvlqMYZjiRbV10ZgzZsE1ryJkpxGxvRzME1fhJo8DUWnP2lHeUjHkxCir/qVXPnwww9ZvHgxixcv1qqX63S6fgXw4Ycf8sgjj1BXV8ekSZO46667KCws7PH42tpa/vKXv7B69WoMBgPz5s3jZz/7mZYtB/jDH/7Ayy+/nPC+UaNG8corr/QrRnFsdPdw3rNnZ2wVAL0ei8WKLSmJWbPmoaKyc9c27djs7Byys3N6VcMlvjJBMBhk5YrlxHp0VPR6I9FoFIPRgMloIhqNzZ222+3Y21fl6VzMbfr003HYU6iqriA5KRmDwUBlZbk2XzteJNfn8+F0tpCenkFjYz0Qa4RZLFbmzjuTUaPHAJCSmsraNZ9hNJnYX7IPu8NBcyiHD6wZDA82MrV+G/agGwBLyTqi+zdSNvx0Mi/7CWaLBYvViuJyotfpCYdC7N+/j9TUVHLz8gfhNyqEECeeLVu2MHToUJYtWwbE/hDV6/WDHJXojc4jRICEmiGd9ZQUsDscjBs/kdTUNNasWRUrhu/34/W0YTSaaGysx2Qya6NavxqBmoSi01FTU82BA6XU19WRnZ2DyWwGwONpIxgIotPp2q8bm4ZstVoxGE3ow2Ecdgdms4UxY4vJyBhCcrKdBQvOYd3az/nii70AtLQ0o9MphMMRbEnJ6PQ6hgzJxeVy4XS20tjQgM/nRafTo9PpsNsd5BcUUllZrn2fXS4nBw+UYTLFphcZTUbM1iSazVZMxafjdtgZbw6TUrGd4NaVqAEvAGpbC/5PX8X/6aso9nTMU8/GPP2cbke0CCHEqaZfyZXzzz+fUCjUXptC6VLwrbeWL1/OhRdeyN13383s2bP505/+xNy5c9mxY0e3w24jkQhz5sxh6dKl3HHHHXi9Xu68807efvttVq1apWXkKyoqyMzM5MEHH9Tea7Va+xWjOHa6S4QUFg5l545tRFUVg8HA5MnTtJ6W7nqberOMo93hQEVlzepVqKqKxWLF5/ORlJREKBQkMysHs9mMub0xFE+aNDc3adeL/39rSwtDMjNxuZ1aA67jMfGlFC1mM04gqkaxWGLfxbS0dGxJSQlLeoaCIZKSkgFQILbkstWKD2h0jGTzyOmMaTtI5s4PMQQ86NQIeaVrif6/HcxYdC21E6ezz2Khra2NpsYGaqqrePedN7jgwsWSYBFCiF64/fbb+cUvfsG5554LIImVE0h8JEowGCQQCDBixEgyMjIPuczzoaZ+5Oblc+65F1JZUU5p2X6sllidtFmz5lFXX4unrQ2D0YjVamX69NMJBoN4vR727/+C+ro6AoEAdXW15BcUkp9fQFtbGwajgYDfj16vw2CwkJaeQUpKKvn5hRwo+xKTyYSi09HS0ozb7dKmNOUXFFJath9PWxuRSJS2Ng85uXlkDsnE5XYRjUbx+70YDAa8Pq9WPF+vN2C12cjJyaWmpgqdTk80GmF/yT4aGuq0jqLW1hZ8Ph81NVVEo1HafD70U+djX/hN1KCf4K7VBDYuJ7hjFbSvOKS6m/GvehX/qldRklOxj59D67DpqFPn40hLPya/cyGEOJ70K7kyfPhw9u3bR3Fx8RFd/K677mLJkiXceeedAMydO5fc3Fwef/xxfvWrX3U5Xq/Xs3v3biwWS0IsEydOZP369cydO1fbnpKSIsV1T0CdEyG5eflccOFiKioOUlg4VEsQHMkQ1HjPlsfjwefzYjAYsVgsTJ02g9zcPILBIEaTkS2bN+LxtOHxtJGTk6ddI37dcDhMaVmspgpAUdFwCgpio67iI1fiST2DwUBG+hC8Xi+hUAh/wE8kEiHPbE6IvePPZbZYOG3GTK3BAyo1NdVUp05lnyWX3JLPGNWwB70aQef3EHnrUbIzC8g97zrWWax4PR50ej1RVaWi4qAkV4QQohfibZx4ckWcOOKr1tTXx1bCiU/VPdRIisNN/bA7HNiSkrRnvQpUVpUTjap4vG1kZ+VgMBgIBoMMHTYct8vFnj07Y4VnlVibIb4yYWpqKkajkdqaKswWC9FIlNSUVJT2jplhw0dq7Yby8gPAVx1IBQVFpKSkEQ6FCAZD7fGoTJ0WWxZ8z56d7TXXatHr9KCq6HR6FEXH5MnTGT58BDU11fh8PiKRCDabTUtCtba2asV3a6ryWLNmFSaTiZ07t5GcbMfucGCedg7maefgbKjBveEjbGWbie5b/1Wipa0Vdf07WNe/g/d1G+EpZ5I883yMxWeg6Pv154YQQpxw+nW3+81vfsO1117Lww8/zPjx4zGZTAn7k5OTD3uOtrY21q1bx0033aRts1gsLFy4kI8++qjb5Er8mI7iowviwz/j1q5dy5w5c0hJSWH+/Pn8/Oc/l9ErJ6jcvPwuiYEjKTQW79kyGo1YLFb0BgNDhmQyevRY7TwHD5RhMBjIyspp7/0ape2LX9frja1OBLQXprV1OSY9PYM2t5uKyoNkZmZTWrofvc+AVbFisVgTztv55zKajASDQW3Vn4MHymhoqAfA7EijatxCmkfNYtTBdWRW7QAg2lBJ9PnfM61gLN6kUTQlZaFTFAoLh/bz0xdCiFPLzTffzEUXXUR2djbz58/v0qaxWq0ymuU4ZXc4GDFiND6fD4vZrI067e3KhD3p2PERCgYxdmj3+gMBzBZLwso5w4aNIBwKYzRmoaoqs2fPJznZrnW8mC0WsrJyAHCkpNLc1MiWLRsAyMnJY/r007Vj4x1IsdWOzubTTz4mHA5hNBqZPHma1tYYN24iTmcrAPX1tVitSbjcTrKycqirq2b48BHaakkmk4nNmzdQV1sNQGlpCQUFhdgdjlhdF5MJfyCWNOn4+blcTtZv2UJUl4pu9CJmXv5rzOXbCWz+iMD2VSjh2DLRhqCX6IZ3cW14F8XmwDRlAebpi2KJFsNXo3WFEOJk06/kynXXXQfA/Pnzu92vqodfkq2qqgpVVcnNzU3YnpeXx4cfftjrWO655x4KCgqYOXOmts1ut3PjjTdy5plnUlVVxT333MPrr7+u1WnpTiAQIND+IAFwuVy9jkEMjv4WGuu4EoDBaCA7KwejyZTQgIgfYzKZsFgsCVX/49d1u1xUtq8+1Hn0TPwYl8up1YaJF7JVFNAb9KRnZCSct+N7O9d2mTVrXkLjzmKxMGPGTILBIOmXXIm1tRrPq38i9MVGAHSV+5jPPjxDJ2O68MbDjlrpa0NTCCFOVjfddBNlZWVcfvnl3e5fvnw5ixYtOuQ5pE0xeAoKCnt8NkPPqwgdSseOj/iIjmg0Sk5OHiNGjNYSEx3PnZScnLAPaC+UW0FpaQkGg4FwOIwCBAJ+4k1nn8+nTT0q+WIvHo+HtjY3doeDpORkku12fD4fBr2effv2aFOSZ82alxBjRcVB6utqMZpM3U6fHtE+KtbcKQkVDAWoqqzQlnzOyy/U2gadCwC3eLwMPe1czKedi6uxjn1vPkdK1S5SakvQR2KJFtXrIrDmLQJr3kKxJmOafCbm0xZiLJ6JYjR1+ayFEOJE1q/kypo1a474wqFQbMnb+MiTOLPZrO07nAcffJCXX36ZDz74IGFEy3333ZdQx2LWrFmMHj2af/3rX1x11VXdnuv+++/nnnvu6euPIU5A8UZSZWW5tlRyd8mRw42M6c0xVZUVOJ1OLGYzKrGkTVHRMKxWK6kpaVRWlIOiJDS+oOcVDCZMnExlRXnCFCkAHA4cP3sU5/oPcL/6J6zu2CpHSQe3w+M30zb3EmwXXY8uZUiXGPvT0BRCiJPVI488gtPp7HH/+PHjD3sOaVMMnsM9m7t7vvbmmdexQydeGL/z+Tueu/OI1vg5xo2f0J4AirVBWp2tWvJNp48Vt01Pz8DtdrF16yaiqkpJyV4uuHAxwWBQW/LY7XYT9vmw2+3dJk+Sk+3a6ogd2zjxzpTU1DRSUlIS9rtcTnZs24qufUlpnV5Hael+mpoaunTydG43OYZkU/zNG2lubsKanIS5chfBTR8R3LHqq2K4vjYC694msO5tFEsSpskLME1fiGn8LBRj4t8DQghxIupXcmXWrFlHfOGMjNgNuampKWF7U1OTtu9QHnnkEX7729/y2muvsWDBgoR9HRMrEJs/PWzYMHbs2NHj+W6//XZuueUW7bXL5TrkqkXixBZfCaCgoKjHBlhvRsYc6hiXy0lp6X6czhZaIlHa10MkEPAzbPgIPv30Y1wuJzq9jpycPBYsOKfLyJnOjZ5dO7cTjUZxOlu1edBxiqLgzB7D9jnXkX5gE8PL1mAKeiAawb/qNfzr3sG68DtYz/0uOutXw9z729AUQoiT0bhx4474HNKmGFyHejYPxLLBPZ2/t+e2OxzYbF/VccnJzSMlJZXMzGytsyW+WiKg1U4bN26idv6OU927u1bnJJOKyp7dOxM6lSZOnBIbAdveBoqvHqQ36AmHQ4RDIfTt1+u4THWv2k1DsjBPPRs1FCC4ey3BzR8R3P4pqt8DgOr3EFj/LoH176KYbZgmzcd02kJM42ejmBJLAAghxIli0CpM5ebmkpeXx/r167n44ou17WvXruXss88+5Hv/8pe/cOutt/Lqq69y4YUXHvZaoVCI+vr6hOWaO+u4Oow4dfR3alFvtDQ3a3VbWltaMJqMmEyx5RxXf/YpLreLSDiMzZaEz+dLSGp01/PW3QpJnWM3mow0NDZQl1TI/vG5nJ8awbB2WawxE/Tje/fveFe+jGHRd0k99yoUo2lAGppCCCG+Im2K49eR1Gw7lPiIkM4Ji550nuo7bdqMhOM7rpYYr53WceQtQGpq2iGv1XGK8rq1n+N0OnE6W8jKysFkMmlFeDvGZLZYSE/LoLa2BqPRQHNLE6YOxff72m5SjGbMU87EPOVM1FCQ0N51BDZ9RHD7J6i+NgDUgJfAxvcJbHwfzFZME+dhnnYOpglzUCy2Xl9LCCEGW7+SK6qq8s9//pOXX36Z8vLyLsVkd+7c2avzXH/99Tz++OMsXbqUYcOG8cILL7B3717++c9/asf8/ve/Z/v27bzyyisA/PWvf+UXv/gFr776KhdddFGXcwaDQe6//35uvfVWrRL6LbfcQiAQ4Nvf/nZ/flwhDqmneiUd67akdxiN5fV48PtjqwWFwxHC4bA2DLijzg2Y3iRBQsEQmVnZBAIBzGYz/snTKLzwe3jffQr/p69CJIzicxN581GaPv8PyZf8mOQZ5x2VhqYQQpyo1q5dy5///Gf279+P1+tN2Pfkk08OyAheMXgGumPlSOu49LQMdHerJaqoWrHbysryQ14r3j7xej2xJI7ZjJNYTSBLhyK8nWPas2cnBqMRhVjB3hEjRg/I56UYTbERKpPmo4ZDhPauJ7D5I4LbPkH1ttclCvgIblpOcNNyMJgwjZ+FaerZmCbPR5eUcsQxCCHE0dSv5MpDDz3EH//4R2688UbefPNN7r//ftavX8/rr7/Oj3/8416f54477qC0tJSxY8eSnZ1Na2srTzzxBNOnT9eOKS8vZ+/evQC0tLTwX//1XzgcDu644w7uuOMO7bi7776bSy+9FKPRiMFgYOjQoaSmplJXV0dhYSHvvvsuY8aM6c+PK0SPDtWg6txwgljV/ab2VQFsio2wMcyYseOYOXPOETfEIJaAsVgsmEwmLQGjszuInn895eljsK5+lcya3bGDm2toe/q3+Jb/g6RLb2LoePljQQghNm7cyNlnn80PfvADNm3axFlnnYWiKPzjH/9g7ty55OfLsvYi0UDUcelOd6sl9vZaHdsn8U5Qo8nUXoR3lLYSYXcxxVceiq9sVFBQOOCF7xWDEdPEuZgmzo0lWr7YGBvRsm0lqqe95lE4SHD7pwS3fwo6PcbR0zFNOxvTlLPQp2YecQxCCDHQFLU3S/t0Mnr0aJ5++mnmzZuHoija6kB//vOfef/993n77bf7dL7GxkYaGhoYNmxYl+WSKyoq8Hq9jB07lkgk0mPdlKKiItLT07XX0WiUsrIy0tLSErb3lsvlIiUlBafTiUN68kUPDh4oY+/eXdrr4uIJCUNsu+N2ufj004/x+XxYrdaEWiuH4nI5qaqsAOixURQ/f8cETLyBFfD7qa+vY5hZZdj+T3HUf5nwPmPxGdi+8V8Yhx6+WOOpQu4DQpx6fvSjH5Gdnc3vfvc7Fi1axG233caiRYvYunUr5513HgcPHuzSVjkcuZec3NwuF2vXfnZUC8PHkxsdVys61LU6t0+KioZjs9l6nRzp2JbobgXDozXKVY2ECX2xieDWFQS2rkR1NXV7nGH4JExTz8Y89Sz0WSdGPSO5Dwhx8uvXyJWysjJt6WOLxYLb7cZut3PttdcmjCbprSFDhjBkSNdVTICEAnB6vZ6pU6f26pw6nY6RI0f2ORYh+qI/9UrsDgcLFpzTp2k4LpeTVZ+uoLa2GqBLAdzO51dRaW6ONUjivVxGk4msrGySs3PIvORqzFV78PznESIV+wAI7V2P84H1mKYvxHbxDzHkDOvDJyGEECeHsrIyFi9eDIDVasXtdgMwdepUhg4dyvbt27U2kBDQvzoufRkJ0nmUbG/qusTbJ36/n1AwSGpqapdRMIf7meLn7k3Nt4Gi6A2Yxs3ENG4mSUt+RfjAToJbVhDYuoJoY5V2XLhsB+GyHXj/82f0+aMxTT0L89Sz0eePQlGUAR9pI4QQvdGv5EokEtFW5CkqKmLDhg2cc845lJeXd1mpR4iTWX8L4/V1vndLczM+n4/4OLPOBXA76q4RFk8AmS0Wxo2bGHufYybGsacT3PQhnjce1Rotwc0fEdyyAvPsi7Fd9AP06Tm9jvNISWNICDHYwuFwlzbOpZdeSigUora2Vto5olt9ea73tUZL56lAnQvR9hTPhImTWbvmM4zto106rzLYW4NV+F7R6TCOmIxxxGRsl91MpKqEwJYVBLetJFK1XzsuUlWCr6oE39tPoMssgPFz2KM6aEvNQ6fXH9WRNkII0dERrxZ03XXXsWTJEhYuXMinn37KZZddNhBxCXHCOJorDsWlp2dgtVpxOlsAui2AG9ddI6ynBJCi02E+/TxM087G/9l/8L77FKqrGdQogdXLCKx/F8uZ38J2/vfRJace1Z+xPwUBhRDiaLr22mtZsGABe/fupaysDKvVysSJEwc7LHGC62uNlv4mN0LBEElJyb2+TlzHjg4VtU+rIB0tiqJgKBiDoWAMSRffSKS+nMDWlQS3rCB84KuFNKINlfDJvxkLBM3JOHPH4tT7SF7wdRSjrOAlhDi6+lVzpbGxMWEaz7PPPsuaNWsoLi7mxz/+MSaTaUCDHAwyL1Icb9wuF5WVFYB62Jor/Z37rQZ8+D5+Cd/y57QlEgEUSxLWRVdhWfgddJakgfhxuuhP/ZqjTe4DQpx6XC4XVqtVG6GyatUqXnnlFZKSkrjpppvIzc3t1znlXiLi+vOc7lxP7Whdp7tCuAaD4bju9Ii01hPcupLg1hWESrZANNL1IJMF07hZmCbPxzRxLjrHsRl905HcB4Q4+fUruXIqkBugOB70d5pMfxphHUU9TnwfPIdvxb8gFNC2K8lp2C74Ppb530QxDmwS9VgUBOwruQ8IIQaC3EtEZ/19Tve1XdDX63Ts6IjXG7Lb7cDx0elxONG2VoLbP8W7cTmRLzahREJdD1IUDMMnxpaFnrwAfe4IFEU56rHJfUCIk1+/kisHDhw45P5hw4b1M5zjh9wAxWA7HqbJRFrr8b3zFP7PlyX0BOnSc7BddD3mmRei6I94dqHmSJNCA03uA0Kceurq6vD5fD3uz8nJwWKx9Omcci8RA+FYtAs6dnScKCNXeqIGfAT3ro8t57zjM1R3c7fH6Ybka4kW4+hpA9qu6UjuA0Kc/PqVXDlcdvdkGAwjN0Ax2OK9R8FgkEAgwIQJkxk3fkKfzjFQBWIj9eV43nyc4MYPErbrc4ZjW/xDTFPPPia9Psea3AeEOPUsWrSIjz76qMf9y5cvZ9GiRX06p9xLxEA4VtNnO3Z0AMdVp0d/qdEo4QO72hMtq4hUf9ntcYo1GeOEOZgnL8A4fja6pIH7meU+IMTJr1+p2ZKSkoTX0WiUkpISfvWrX/HTn/50QAIT4lSXnp5BOBymvr4WgNLSEgoKCo/aagSHos8qwrH0D4TPuwbPskcJ7VoNQKS2DPfffo1h2ARsl/wXpuLT+3V+IYQ4Xjz33HN4vd6EbfX19Tz00EPY7Xbmzp07SJGJU92xWrWnc6H+EzmpEhdbeWgSxhGTSPrGfxFpqCS4YxXB7asIlWzWRueqvjaCGz+IdSbp9BhHTYvVaZm8AH1mwSD/FEKI492A1lzZsmULN954I+vXrx+oUw4ayS6L48Ge3TvZtWsHZrMZk8nUp16qo9nDFSrZjOf1vxAu3Z6w3Vh8BrZLfoxxWN9G2Byv5D4ghIgLBoOMGDGCHTt2kJaW1qf3yr1EDJTjbfrsySDqdRPatYbgjk8J7lyN6nN3e5w+d7g2fcgwfCKKTt+n68h9QIiT34BOKhw9ejS7d+8eyFMKcUorKCiisrK8X71UR7OHyzh6Oim/fJLQzs/wLHuUSNV+AEJ71+Pcux7T5AXYLv4hhoLRA3ZNIYQYTCaTiYKCAvbt28esWbMGOxxxiuo8qkQcOZ3Njvn08zCffh5qJEzoy22x6UPbP40t7dwuUlOGr6YM3wfPoSSnYZo0F9PkBZiKZ6JYbIP4EwghjhcDNnLF6/Vy//338+qrr54UCRbJLovjxZH0Uh2LHi41GiWw8X28bz5OtLEqYZ/ptHOxff0GDDnDjsq1jza5DwghACKRCO+99x7f/OY3+fLLL8nPz+/T++VeIsSJR1VVIrUHtDot4dLt0N2fTQYTqbc+haGo+JDnk/uAECe/fo1c6a5KfiAQIDU1lRdffPGIgxJCfOVIeqmORQ+XotNhOeMCzNMX4V/9Br53niLqbAAguGk5wc0fYZ51EbaLfoA+I++oxiKEEEfqwgsv5OOPP07YFgqFUBSFO++8s8+JFSHEiUlRFAy5wzHkDsf2tWuJulsI7vyM4PZVBPeshUBsVTHFYESfN3KQoxVCHA/6NXLlrbfe6rItLS2NSZMmnTSZWMkuC9E/atCPf9VreN97BrWt5asdegOWud/AesF16FMzBy/APpD7gBCnnnXr1tHQ0JCwzWq1Ulxc3O/EitxLhDi5qKEAoS82Edz+KegNJF/+y8O+R+4DQpz8BrSg7clEboBCHBnV78W34l/4lv8jsTic0Yz1zG9hPe9adPa+FYU81uQ+IIQYCHIvEULIfUCIk1+/pgUdOHCg18cOGzasP5cQQpzgFIsN2wXfx3Lmt/B9+E/8H7+EGvBCKIDvw+fxr/oPlnOuwLroanQ2+2CHK4QQANTV1eHz+Xp1bE5OTrdTpYUQQghx6unXyBVFUXp97Ik6MEayy0IMrKi7Bd8Hz+L75BUIBbTtitWO9dzvYj17yXFXbV/uA0KcehYtWsRHH33Uq2OXL1/OokWLDnuc3EuEEHIfEOLkp+vPmx599FHy8/N54okn2Lp1K1u3buWJJ54gPz+fRx99lLKyMu2fEEIA6OxpJH3zZ6T9/jUsC74F+tjAOdXnxvvGozT/9hv4PnoBtUPiRQghjrUHH3yQtLQ07rrrLtatW8fu3btZtmwZc+bM4aqrrkpo48ybN2+wwxVCCCHEcaJfI1emTZvGY489xsyZMxO2r127lh/96Eds2bJlwAIcLJJdFuLoijRV4337SQJr3wY1qm3XpWZhPf97WOZcgmI0DWKEch8Q4lR06623kpqayh133JGw3ev1MmLECHbu3MmQIUP6dE65lwgh5D4gxMmvXyNX9u3bx5gxY7psHzt2LF988cURByWEOPnpM/KwX3MXqXf9C9Np52rbo631eF76H1ruvgz/qtdQw6FBjFIIcarpqY1js9nIz8+npKRkEKISQgghxPGuX8mV4cOH8/DDDyfUU1FVlYcffpjhw4cPWHBCiJOfIWcYjh/cR+odL2CavEDbHm2po+2F+2m5+5v4P1+GGgkPYpRCiFPF8OHDefTRR/F6vQnbly9fzs6dOxk6dOggRSaEEEKI41m/pgV99NFHLF68mIKCAmbMmIGqqmzatImqqirefPNNzj777KMR6zElQ/eEGByhg7vxvvUEoZ2fJWzXDcnHduFSzGdcgKLv10JnfSb3ASFOPbW1tcyfP5+WlhbOPPNM7HY7JSUlrF27lnvvvZff/OY3fT6n3EuEEHIfEOLk16/kCsSWKvzb3/7G7t27ARg/fjw33ngjWVlZAxrgYJEboBCDK3RgF943Hye0e03Cdl1mIbaLfoB5xnlHPcki9wEhTk2BQIBnnnmGdevW4XQ6GT58OFdffTVTp07t1/nkXiKEkPuAECe/fidXTnZyAxTi+BAq3Y73rb8R2rMuYbs+qwjrRddjnnEuik5/VK4t9wEhxECQe4kQQu4DQpz8+lxzJRKJJLxubm7m3nvv5ZZbbmHlypUDFZcQQgBgHDGZlJv/Hym/eALj2Bna9kh9OW1P/5bWe68ksPED1Gj0EGcRQojDi0ajCfXkIpEIf/vb37jpppt45plnkP4oIYQQQvSkT8mVFStW8LWvfU17HQwGmTdvHvfddx+vvfYaCxcu5O233x7wIIUQwjhqKik/+yuOnz+GYfQ0bXuktgz3U3fQ+v9dSWDzR5JkEUL0i8vlYtSoUTidTm3bj3/8Y374wx/yzjvvcP3113PrrbcOYoRCCCGEOJ71Kbny8MMPJzQsli1bRllZGdu3b+fAgQP87ne/48EHHxzwIIUQIs405jRSfv44jp8+imHkFG17pKYU9xO30Xrf1QS2rpAeZiFEn/z973/nm9/8JqmpqQA0NTXx5JNP8ve//50vv/ySTz75hL/+9a+43e7BDVQIIYQQx6U+JVfWrVvHrFmztNcff/wx5513HqNHjwbghhtu0ArcCiHE0aIoCqbi00n5xRM4bv5/GIZP0vZFqkpwP/6rWJJl2yeSZBFC9ErnNs7KlStJTk7m6quvBmDOnDmMGDGCsrKywQpRCCGEEMexPiVXQqEQoVBIe7127Vpmz56tvU5OTsbr9Q5cdEIIcQiKomAaN5OUW5/C8ZM/YRg6XtsXqfwC92O/xPnAtQR3fCZJFiHEIXXXxjn99NMxGL5alUzaOUIIIYToSZ+SK5MmTeJvf/sbAFu3bmXbtm0sWrRI2//FF19QXFw8sBEKIcRhKIqCacIcUn79DI4f/y/6wq/uQ+HyPbge/TnO//k+wV2rJckihOjWpEmTePrppwmHw3g8Hl555ZWENg5ASUkJY8eOHaQIhRBCCHE869NSzO+//z4XX3wxOTk51NfXM3v2bFasWKHt//Wvf01WVha/+MUvjkqwx5IslybEiUtVVYLbP8X71t+IVH6RsM8wfBK2i2/EWHwGiqIc8jxyHxDi1FFXV8fUqVMJhUJEo1EURWHPnj1kZWUBsHz5cv74xz/y7rvv9vncci8RQsh9QIiTn+Hwh3zla1/7GmvWrOGtt94iPT2dpUuXJuzPzMzk+uuvH9AAhRCirxRFwTzlTEyT5hPc/kksyVK1H4Bw2Q48/36Y1N++CIp+kCMVQhwvsrOz2bRpEy+++CI+n4+rrrpKS6wAtLW18Yc//GEQIxRCCCHE8axPI1eOhqamJv79739TV1fHpEmTuPTSS9HpDj1bqTfv6c95O5LsshAnDzUaJbh1RSzJUlOK/Qf3YT7t3MO+T+4DQoiBIPcSIYTcB4Q4+fWp5spAKysrY9KkSfzrX//C4/Hwi1/8gosvvphoNHpE7+nPeYUQJy9Fp8M8fSGpd76I/YcPYZq2cLBDEkIIIYQQQpxEBnXkyuWXX05lZSWrVq1Cr9dTWlrK2LFjee6557jyyiv7/Z7+nLczyS4LIeQ+IIQYCHIvEULIfUCIk9+gjVwJh8O8+eabXH311ej1sboHI0aM4Mwzz+S1117r93v6c14hhBBCCCGEEEKI/upTQduBVF5ejt/vZ9SoUQnbR40axZo1a/r9nv6cFyAQCBAIBLTXLperTz+PEEIIIQRIm0IIIYQ4FQ3ayBWPxwPQZVhcSkqKtq8/7+nPeQHuv/9+UlJStH+FhYV9+GmEEEIIIWKkTSGEEEKcegYtuZKcnAyA0+lM2N7a2qrt6897+nNegNtvvx2n06n9q6io6MNPI4QQQggRI20KIYQQ4tQzaMmVoqIikpKS2LdvX8L2ffv2MW7cuH6/pz/nBTCbzTgcjoR/QgghhBB9JW0KIYQQ4tQzaMkVvV7PpZdeynPPPUcwGARg9+7dfPbZZ3z729/Wjnvttdf4v//7v16/p7fnFUIIIYQQQgghhBgIg7oUc1VVFfPnzyctLY3TTjuNN954g7POOosXX3wRRVEA+MEPfsDatWvZuXNnr9/Tm2MOR5ZLE0LIfUAIMRDkXiKEkPuAECe/QU2uALS1tfHGG29QV1fHpEmTWLRoUcL+d999l+rqapYuXdrr9/T2mEORG6AQQu4DQoiBIPcSIYTcB4Q4+Q16cuV4JTdAIYTcB4QQA0HuJUIIuQ8IcfIbtJorQgghhBBCCCGEECcDw2AHcLyKD+hxuVyDHIkQYrDE//uXAX5CiCMhbQohhLQphDj5SXKlB263G4DCwsJBjkQIMdjcbjcpKSmDHYYQ4gQlbQohRJy0KYQ4eUnNlR5Eo1Gqq6ux2+29XmGoN1wuF4WFhVRUVMh8y3bymXQln0miwfo8VFXF7XaTl5eHTiezKIUQ/dOXNoXc/w9NPp/Dk8/o0KRNIYQ4WmTkSg90Oh0FBQVH7fwOh0MeeJ3IZ9KVfCaJBuPzkN4lIcSR6k+bQu7/hyafz+HJZ3Ro0qYQQgw0SZsKIYQQQgghhBBCHAFJrgghhBBCCCGEEEIcAUmuHGNms5m7774bs9k82KEcN+Qz6Uo+k0TyeQghThVyvzs0+XwOTz6jQ5PPRwhxtEhBWyGEEEIIIYQQQogjICNXhBBCCCGEEEIIIY6AJFeEEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgGGwAzjVlJeXU19fz5gxY3A4HIMdzqBat24doVAoYVtRURFFRUWDFNHgKC0tpbq6mjPOOAOTydTtMfv378fpdDJ+/HisVusxjvDYUlWVzZs3YzAYmDJlSsK+aDTK6tWru7xnzJgxZGVlHasQhRDiqNm7dy8+n48JEyb0+Ew4FZWVlVFVVZWwzWq1ctpppw1SRMeHL774gvr6eubOnYuiKN0ecyp/p+rq6igpKWHixImkpqYm7JPvlBBioElB22PE5/Nx5ZVXsnz5coqKijh48CAPPfQQP/7xjwc7tEEzZMgQ7V/cddddx3XXXTeIUR07H3zwAQ8++CCbN2+mubmZiooKCgoKEo5pbGzkkksuYdeuXWRmZtLQ0MDTTz/NpZdeOkhRHz2qqvLHP/6Rxx9/nIaGBkaOHMnGjRsTjmlra8NutzN58mTsdru2/Y477uCCCy441iELIcSAqaio4OKLL6ayshKHw0FbWxsvvvgiCxcuHOzQjgs/+9nPeO655xg/fry2raCggJdeemkQoxo8r7/+Og8//DC7du2ipaUFn8+HxWJJOOZU/k5t3bqV+++/n5UrV1JfX8+7777L+eefn3CMfKeEEANNRq4cI3fddRdbtmyhtLSU7OxsXnnlFS6//HJmzpx5SmfIf/e733HFFVcMdhiDYufOndx6660YjUbOOeecbo/50Y9+hN/vp6qqiqSkJB566CGuuuoqSkpKyM/PP8YRH12hUIjq6mreeustHn30UT777LMej3388ceZNWvWMYxOCCGOrmuuuYa0tDTWr1+PyWTitttu49vf/jalpaVdetxPVXPmzOGtt94a7DCOC7t27eIPf/gD9fX1fPvb3+72mFP5O7Vr1y4uvfRS/vd///eQ7SX5TgkhBpLUXDkGVFXl6aef5oYbbiA7OxuAb33rWxQXF/P0008PcnSDq76+no0bN9LQ0DDYoRxzt9xyC+edd16Pw3hbWlr4z3/+wy233EJSUhIAN998MyaTiRdffPFYhnpMmEwmHn74YcaMGXPYYysrK9m0aROtra1HPzAhhDjKysrKWLlyJbfddps2beO2226jra2N119/fXCDO44Eg0E2b97M/v37iUQigx3OoLrjjjtYsGBBj/tP9e/UVVddxRVXXHHYaVDynRJCDCRJrhwDFRUVNDU1dRmhcvrpp7Nly5ZBiur4cNddd/GDH/yAoUOHcu6551JRUTHYIR03duzYQSQSSfjemEwmpkyZcsp/b370ox/xve99j+zsbJYsWSJJFiHECS1+T+94v09NTWX06NGn/P2+o48//phrr72WefPmUVhYyLJlywY7pOOWfKd6R75TQoiBJMmVY6C5uRmAjIyMhO0ZGRnavlPRf//3f9PU1MTWrVs5cOAATqeTK6+8crDDOm7I96Yrg8HAc889R0NDAzt27GDPnj1s2LCB//qv/xrs0IQQot/i9/T09PSE7afy/b6zc845h8rKSnbs2EF1dTVLly5lyZIl7NmzZ7BDOy7Jd+rw5DslhBhoklw5BoxGIwB+vz9hu8/nO+Wqtne0dOlS9Ho9AFlZWfz+97/n888/l9Er7eR705XFYuG73/2u9nrEiBH86le/4pVXXiEcDg9iZEII0X/x+30gEEjYfirf7ztbvHgxOTk5AOh0Ou655x4cDscpMcWlP+Q7dXjynRJCDDRJrhwDRUVFKIrSZbm3qqqqU27Z4UOJ16Pp/DmdqoYOHQp0/Tzke5MoOzubYDBIY2PjYIcihBD90tP9vrq6Wu73PdDpdGRmZkqboQfyneo7+U4JIY6UJFeOAbvdzsyZM3njjTe0bW63m48//phzzz13ECMbPB6Pp8u2Dz74AKPRyNixYwchouPP+PHjycvLS/jelJaWsmPHDvnedPDBBx+QmZlJVlbWIEQkhBBHbubMmdjt9oT7/YYNG6iurj5l7/eddb7/HzhwgJKSEiZOnDhIER3f5Dt1ePKdEkIMNFmK+Rj5wx/+wNe+9jWGDx/OGWecwZ///Gfy8vJYunTpYIc2KD788EMeffRRrrzySnJzc1m1ahUPPfQQd955J2lpaYMd3jFRXl5OeXk5O3bsAGKNngMHDjB27FgyMzPR6XTcf//9/OAHPyAjI4Phw4dz7733Mm/ePL7+9a8PcvRHx5YtW/B4PFRXV9PW1qYtxzxnzhx0Oh1PPfUUq1evZvHixaSmpvLOO+/w5JNP8sQTT6DTSa5YCHFislqt/O53v+O3v/0tFouFIUOGcOedd7J48WLmzJkz2OEdF2bMmMHSpUuZOHEi1dXV3H///UyYMIFrrrlmsEMbFF9++SU1NTXs3bsXgNWrV2MymZg4cSKpqamn/HeqsbGRvXv34nQ6gdjSzMnJyRQWFmqjeuQ7JYQYaIqqqupgB3GqWLVqFY8++ij19fVMmTKF22677ZTubf/ss8945plnqKioYOjQoVx11VWceeaZgx3WMfPEE0/w7LPPdtl+1113cd5552mv33jjDZ599llcLhezZ8/m1ltvxW63H8tQj5lrrrmG0tLSLtuXL1+O1WoF4M033+Tll1+moaGBESNGcMMNNzBlypRjHaoQQgy4F198kZdeegmfz8fZZ5/Nz3/+cywWy2CHdVyor6/nkUceYdOmTaSkpDB37lxuuOGGU7Z+yEMPPdRtbZCHH36YmTNnaq9P1e/URx99xN13391l+9VXX80Pf/hDQL5TQoiBJ8kVIYQQQgghhBBCiCMg4+iFEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgCRXhBBCCCGEEEIIIY6AJFeEEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgCRXhBBCCCGEEEIIIY6AJFeEEEIIIYQQQgghjoAkV4Ro9/7777Nv377BDkMIIYQQJ7gvv/ySt99+e7DDEEIIcQxJckV0q6ysjJdeeomKiorBDuWY+fWvf82bb755VM7d1NTEBx98wIoVK2hpaTkq1zha3nvvPb744ovBDkMIIcQJ7OWXX2blypWDHcYxs3z5cn76058elXOHw2E2bdrEW2+9dcJ1CpWUlPDOO+8MdhhCCHFUSHJFdOu3v/0tV155Jffdd99gh3JCi0aj3HjjjUyePJmHHnqIO++8k6FDh/Lss88Odmi99stf/lIaQkIIIfrts88+4/LLL+fiiy+mra1tsMM5oS1btozx48dzww038NhjjzFr1iwuueQS/H7/YIfWK++//z633HLLYIchhBBHhWGwAxDHn9bWVl599VVuvfVW/va3v/Hwww9js9kAWLt2LeFwmHnz5iW8Z82aNUQiEW17OBxm3bp1NDU1MXbsWMaOHZtw/Ntvv01xcTE2m40NGzaQnZ3NzJkz+eSTT6ipqUFRFLKzs5k6dSqpqaldYmxsbGT16tVkZWUxdepUPv/8c3Jzcxk/frx2zOFi6A2Px8Pq1avxer3MmDGD/Pz8PsUSiUQ47bTT+H//7/9hNBoBeOSRR7j++utZtGhRt+eLi0QibNiwgfr6ek477bQuxx4uttdee40zzjiDgoICbduHH35IXl6e9jnFfw8pKSls2bIFi8XCrFmztFg//vhjnE4nW7Zs4aWXXgLg8ssvR6eTvKwQQojeefLJJ7niiiv4/PPP+de//sXSpUuB2PPzww8/5Bvf+AYWi0U7vr6+no8//jhhe1lZGdu3b2fIkCFMnz4dq9WqHb9v3z4OHDjA2WefzZo1a6irq+Nb3/oWNTU1rFq1CgCbzUZxcTFjxozpEl8kEmH16tV4PB6mTJlCMBhk27ZtLF68OOG4Q8XQW1u3bqW0tJT8/HzOOOMMFEXpUyyqqrJ8+XKGDh0KQHV1NVOmTOF//ud/uOuuuw557YMHD7Jt2zZyc3M57bTTujzLDxXb9u3baW5u5qyzzkr4PHbs2KHFFv89LFy4kG3btlFbW8u0adPIy8sDoLy8nM2bN+N2u7U2xfTp07v9nQghxAlJFaKTRx55RC0uLlbD4bBaUFCgPvPMM9q+xx57TM3OzlbD4bC2LRqNqgUFBerDDz+sqqqq7t27Vx0zZow6ceJE9eKLL1azs7PV73znO2okEtHeM3LkSHXhwoXq0KFD1UsuuUR99NFHVVVV1fvvv19dsmSJevnll6uzZs1S09LS1HfffTchvuXLl6vJycnqaaedpp511lnq+PHj1REjRqj33nuvdkxvYuhsypQp6oMPPqi9XrNmjZqZmalOnjxZPeecc1Sr1ar+93//d59j6ayqqkoF1Pfff7/HY/bs2aOOHTtWLSoqUi+88EJ1+PDh2mfU29hSUlLUl19+OWHbzJkzE2KL/x5GjBihfv3rX1cLCwvV6dOnqz6fT1VVVb3nnnvUlJQUddq0aeqSJUvUJUuWqMFgsMe4hRBCiI6cTqdqs9nUlStXqr/73e/UWbNmafs8Ho+alJTU5Vn1+9//Xh0zZoyqqqoaiUTUH/7wh2pGRoZ60UUXqTNmzFCHDRumbtmyRTv+wQcfVAsKCtRp06apZ555pvas2rBhg/bsuuiii9TU1FT1+9//fsK12tra1Dlz5qhZWVnqBRdcoObn56uLFi1S8/PztWN6E0Nnf/3rX9WRI0dqrwOBgHrRRRep6enp6gUXXKDm5uaqM2fOVJubm/sUS3cuvvhi9dJLL+1xfyQSUW+88UbVZrOp55xzjnrGGWeoZ511lurxeHod269//Wt14cKFCed9+umnE2KL/x5mzJihnn322er8+fNVq9Wqvvfee6qqqurq1avV6dOnq3a7Xfu9vPPOO4f82YQQ4kQiyRXRxdSpU7VEyV133aXOnz9f29fU1KSaTCbtQamqqrpixQpVr9er1dXVajQaVSdOnKjefffd2v7W1lZ15MiR6l//+ldt28iRI9Xhw4cnPLi785e//EUtLCxUo9GoqqqqGgqF1JEjR6o//elPtWOefvppFdCSBr2NobOOyZVQKKQWFxer119/vbb/9ddfV3U6nbp9+/Zex9KdZ599VtXpdGpFRUW3+yORiFpcXKxedtllaiAQUFVVVYPBoPr222/3OjZV7X1yZfz48arT6VRVNdYIzsjIUP/+979rx0yYMEH93//93x5/HiGEEKInjz32mJYoqaioUPV6vbpr1y5t/1VXXaV+4xvfSHhPcXGxes8996iqqqp//vOf1eLiYrWlpUXbf+edd6pTpkzRXj/44IMqoL744ouHjKWmpkbNzMxU33rrLW3bfffdpxYUFKj19fWqqqpqfX29WlBQkJA06E0MnXVOrjz00ENqdna2WlVVpapqrF1SXFys3nTTTX2KpTO3261mZWWpv/3tb3s85uGHH1YdDkfC5/7JJ59obbDexNbb5AqQ8Pn+5Cc/Uc844wzt9SOPPKKOHTu2x1iFEOJEJmP7RYJNmzaxe/durr32WgB+8IMfsHr1aq2gaXp6OhdccAHPP/+89p7nn3+ec845h9zcXDZs2MDOnTspLCzklVde4eWXX+b9999n1KhRrFixIuFaV199NWlpaV1iqK6uZvny5fzrX/8CoKKigtraWgC2bNnCl19+ya233qodf80115CVlaW97ksMPdm2bRt79+7l9ttv17ZdcskljB8/npdffrnXsXRWWlrKLbfcwk9+8pOE6TodrVu3jr1793LfffdhMpkAMBqNXHjhhb2OrS+uuuoqHA4HAA6Hg2nTpp1wBfKEEEIcn5588kmuv/56AAoKCrjgggt48skntf1XX30177zzjlbsfdOmTezdu5errroKgKeffpopU6bw4Ycf8vLLL/Pvf/+blJQUtm3bllAgPjMzkyuuuKLL9YPBIKtXr+bVV19l5cqVFBQUsH79em3/K6+8wve+9z0yMzO183zve99LOEdvYziUl156iWuvvVabIpOSksJPfvITbXpMb2PpSFVVbrjhBgwGAzfffHOPxz377LNcd911CVOnFyxYoLXBehNbbxUWFnLRRRdpr8866yxpUwghThlSc0UkeOqppyguLmb58uXatpEjR/LUU0/x3//930Dsj/HrrrsOr9eLXq/nlVde4U9/+hMABw4cQFGUhPcDpKamMmHChIRtubm5Xa5/xx138H//93/MmDGDzMxMotEoEJt/nZubS0VFBUajMaG+iE6no6ioSHvdlxh6cvDgQXQ6nTanueNncfDgQYBexdJRZWUlixYtYt68eTz88MM9Xru8vBxFURg1alS/Y+uL9PT0hNdms/mEKYwnhBDi+LV9+3Y2btzINddco/2hXlRUxD/+8Q8eeOABTCYT5557Lmlpabzyyitcf/31PP/888yePZuRI0cCsWe6wWDglVdeSTj3kiVL8Pl8WoKguzbFpk2bWLx4MXa7ndGjR5OUlERDQwP19fXaMRUVFQwbNizhfZ1f9zaGQzl48CAjRoxI2DZy5EgaGhrwer3YbLZexdLRT3/6U95//30+/vhjhgwZ0uNx5eXlh6xr0pvYekvaFEKIU5kkV4TG5/PxwgsvMH/+fF5//XVt+8iRI3n22Wf5wx/+gMFg4OKLL0av1/PGG29gNpsJBoNcdtllQGzkg6qq/PGPf9R6QHrSuYhbaWkp9913H5s3b2batGkA7N27l//85z+oqgrEHtqhUIi2tjaSk5O193bsOepLDD0ZMmQI0WgUp9OZ0Ghqbm7WGny9iSWuqqqKs846i4kTJ/Lvf/8bg6Hn//RSU1NRVZWWlpZuG0u9iQ1iiZ54cipOGjhCCCGOlSeffJLi4mI+//zzhO2KorBs2TK+/e1vo9frWbJkCc8//zxLly7lpZde4s4779SOdTgcnH/++fz+978/5LU6tykAbr/9dr7+9a/z+OOPa9vOOussrU0BsWd5a2trwvs6P8d7G8OhDBkyhObm5oRtzc3NJCUlacmL3sQS9/Of/5x//vOffPjhh0yZMuWQ105NTaWpqemIYpM2hRBCHJ5MCxKal19+GbPZzLJly3jppZe0f8uWLSMQCPDmm28CYLFYuOyyy3j++ed5/vnnueSSS7Tkwpw5c7Db7Tz22GMJ51ZVlZqamkNev7a2FkVREnpXOvcSTZkyhaSkJN544w1t265duygtLdVeH0kMcZMnT8bhcPDaa69p2yoqKli3bp22IlJvYoGvEivjx4/nlVde0ab69GT27NkkJyfz3HPPJWxvaGjodWwA+fn57N+/X3tdU1PTr6G5ycnJ0oASQgjRJ4FAgOeff5577703oU3x0ksv8d3vfjdhatBVV13Fp59+yjPPPENjYyNLlizR9p1//vk899xzeL3ehPNXVVUdNoba2tqElQIrKioSpgQBzJ07l2XLliVs6/hcP9IY4ubNm5fQWQSxdtfcuXP7FAvALbfcwrPPPsvy5cuZPn36Ya993nnn8eKLLxIOh7Vtbrdbe7b3Jrb8/HxKS0sTjuntVOuOpE0hhDiZycgVoXnqqae4+OKLuyzNF6/38dRTT3HppZcCsTnS559/PjqdLuGPfIfDwWOPPcb3vvc9Dh48yPz586mtreU///kPv/jFL/jOd77T4/WnTp1KUVER3/rWt/j2t7/N1q1beeGFFxKOSUtL47bbbuOHP/whZWVl2O12/vznP+NwOLReqyOJIS41NZV7772Xm266ifLycjIzM3nkkUeYP3++9hn0Jhafz8fChQtpa2vjW9/6VsJnNXPmTIYPH97l2g6Hg0ceeYQbbriB/fv3M336dDZu3Iiqqjz++OO9ig1i9V/idVvMZjNPPvnkYRM73ZkxYwbPP/88ubm5mM1mWYpZCCHEYb322mt4PB7OP//8Lvu+8Y1v8H//93+Ul5dTVFTEGWecwahRo/jpT3/K+eefT0ZGhnbsvffey8qVKznjjDO47rrrsFgsrFmzhtra2i7Tf7u7zgMPPKA9s/785z9jNpsTjvnNb37D9OnT+da3vsXXvvY13n//ffbs2ZOwNPSRxBB39913M23aNC6++GIuueQSPvnkE5YvX85nn33Wp1juu+8+/vd//5dbb72VkpISSkpKgNjok0WLFnV77XvuuYe5c+cyd+5cvvvd79LW1saLL77Ixx9/jMVi6VVsl112Gbfddhvf/e53Oeecc/jkk09YuXIlRqOxVz9/3GmnnUZFRQUPPPAAw4YNk6WYhRAnFfkLSQCxHoy8vDy+//3vd7v/+uuvJzU1lUAgAMSG1V511VVcfvnlnHfeeQnHfuc732Hr1q0UFBSwatUqQqEQzzzzTEJS4+tf/3qXmiI2m43PP/+cadOmsXLlStLT0/n8889ZsmRJwvSXO++8k7/97W/s37+fqqoqXnzxRXJzc7Hb7X2KobPzzz+f4uJi7fXNN9/MsmXLaGhoYNOmTfz85z/n7bffTnjP4WIJBoNMnTqVM888k3feeYfXX39d+1deXt5jLN/73vdYs2YNNpuNNWvWMGPGDB599NE+xXbrrbfyyCOPsG/fPmpqavjHP/7BzTffnFB3prvfw4IFCxJ6wu677z6uvvpqVqxYweuvv04kEukxbiGEEAKgrq6O22+/PWHabNzcuXO5+uqr2b17t7btt7/9LRdddBE/+9nPEo7NzMxk8+bN3HTTTezatYs9e/Zw4YUX8t5772nHFBcXd5vE+d3vfscDDzzAjh07KCkp4bHHHuPuu+/m9NNP144ZOXIk69evp6ioiI0bN/K1r32N22+/PaFN0ZsYOhs1ahRf//rXtdf5+fls3bqVGTNmsGrVKgoKCtiyZQtTp07tUyxms5klS5ZQXl6e0Kb45JNPeowlJyeHLVu2cMUVV7Bx40ba2tpYtmyZlsTqTWy5ubmsX7+enJwcNmzYwMKFC/nXv/7FJZdccsjfQ35+Ppdffrn2etKkSSxbtozy8nKWLVvGl19+2WPcQghxolHUjuP7hDgBNDc3JxRM279/P+PGjWPlypUJQ1hPtViEEEII0TeqquJ0OklNTdW2nX/++WRmZvKPf/zjlI1FCCFE38m0IHHCef/993nppZe44IILcLlcPPLII5x33nmDksw4nmIRQgghRN+oqsrZZ5/NN7/5TbKysnj77bdZu3Ytn3766SkdixBCiL6TkSvihPTOO+/w3nvvoaoqZ5xxBlddddWg1QE5nmIRQgghRN9UVFTw9NNPa0sSf//73+/3aoMnUyxCCCH6RpIrQgghhBBCCCGEEEdAuteFEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgCRXhBBCCCGEEEIIIY6AJFeEEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgCRXhBBCCCGEEEIIIY6AJFeEEEIIIYQQQgghjoAkV4QQQgghhBBCCCGOgCRXhBBCCCGEEEIIIY7A/w9clS/v4InLxAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -267,7 +267,13 @@ "output_type": "stream", "text": [ "The 20 genes that gain most take 4% of the control libraries and 22% of the stimulated ones.\n", - "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "median factor control stimulated\n", "TMM 1.19 0.83\n", "RLE 1.19 0.84\n", @@ -344,7 +350,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,17 +482,18 @@ "text": [ "Design check: 16 samples, 10 columns, rank 10, 6 residual degrees of freedom.\n", "3 warnings:\n", - " 1. [similar_levels] condition has levels that differ only in case or surrounding\n", - " spaces ('Stim' and 'stim'), and each is a group of its own; if they mean the same\n", - " group, clean the labels before building the design\n", - " 2. [single_sample_level] condition has a single sample at level 'Stim' (1016_stim);\n", - " effects of such a level rest on one sample with no replicate. Add replicates, merge\n", - " the level with a similar one, or remove the sample\n", - " 3. [unreplicated_sample] the model fits sample 1016_ctrl (donor = 1016, condition =\n", - " ctrl) exactly (leverage 1), so it tells nothing about the residual variance and the\n", - " effects it determines rest on it alone. This happens when a level, or a combination\n", - " of levels in an interaction, has too few samples for the terms that involve it; add\n", - " replicates or simplify the formula\n" + " 1. [similar_levels] condition has levels that differ only in case or\n", + " surrounding spaces ('Stim' and 'stim'), and each is a group of its own; if\n", + " they mean the same group, clean the labels before building the design\n", + " 2. [single_sample_level] condition has a single sample at level 'Stim'\n", + " (1016_stim); effects of such a level rest on one sample with no replicate.\n", + " Add replicates, merge the level with a similar one, or remove the sample\n", + " 3. [unreplicated_sample] the model fits sample 1016_ctrl (donor = 1016,\n", + " condition = ctrl) exactly (leverage 1), so it tells nothing about the\n", + " residual variance and the effects it determines rest on it alone. This\n", + " happens when a level, or a combination of levels in an interaction, has too\n", + " few samples for the terms that involve it; add replicates or simplify the\n", + " formula\n" ] } ], @@ -532,7 +539,7 @@ "kang2018", "simulated_bulk" ], - "executed_at": "2026-10-26T21:56:54+00:00", + "executed_at": "2026-10-27T09:55:18+00:00", "executed_code_sha256": "eed2efcee4a18d468aece68892293efe57484a6875e7979e1773b3919dc49e87", "executed_datasets": { "kang2018": { @@ -543,8 +550,8 @@ "simulated_bulk_truth.npz": "sha256:a8a0275532e3cafb02401846176a7ddfa037579aceb804c5f9c007700f022977" } }, - "executed_with": "0.1.dev57+gb65bc7e32", - "execution_seconds": 8.8, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 9.4, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/pathway_activity.ipynb b/docs/source/guides/pathway_activity.ipynb index a39d8cc..45a90d3 100644 --- a/docs/source/guides/pathway_activity.ipynb +++ b/docs/source/guides/pathway_activity.ipynb @@ -35,10 +35,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n", + "CytePool 0.1.dev61+gcd5dbe953\n", "Network: 1,171 sources, 39,896 edges, 6,505 target genes\n", - " name: CollecTRI; version: 2.0 (Zenodo record 8192729); licence: CC BY 4.0 (Zenodo record 8192729); level 'commercial': the interactions of resources that OmniPath lists for commercial use, without those that GEREDB (listed for academic use) alone supports; each resource keeps its own terms\n", - " read from CollecTRI_regulons.csv, SHA-256 4473c9189dd53dacc80297709ad1452dda1086a1cc2185f9a56146c261668701\n", + " name: CollecTRI; version: 2.0 (Zenodo record 8192729); licence: CC BY 4.0\n", + " (Zenodo record 8192729); level 'commercial': the interactions of\n", + " resources that OmniPath lists for commercial use, without those that\n", + " GEREDB (listed for academic use) alone supports; each resource keeps its\n", + " own terms\n", + " read from CollecTRI_regulons.csv, SHA-256\n", + " 4473c9189dd53dacc80297709ad1452dda1086a1cc2185f9a56146c261668701\n", " sources: MYC (853), SPI1 (332), SMAD3 (159) and 1,168 more\n" ] } @@ -310,15 +315,15 @@ "datasets": [ "kang2018" ], - "executed_at": "2026-10-26T20:33:18+00:00", + "executed_at": "2026-10-27T08:56:25+00:00", "executed_code_sha256": "1928564a0c0ddc49fe7c9dc2dc94a61a075ccffbc0ee7d921400755b9e7a65a6", "executed_datasets": { "kang2018": { "kang2018.cube.zarr": "sha256:a30af3dabe17f21a6c75f41b64a279a1423640b9aa919022cf67897f9cc77a51" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 3.6, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 3.5, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/pool_cells.ipynb b/docs/source/guides/pool_cells.ipynb index c4f9d33..87b7428 100644 --- a/docs/source/guides/pool_cells.ipynb +++ b/docs/source/guides/pool_cells.ipynb @@ -38,9 +38,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev61+g194f49f8f\n", + "CytePool 0.1.dev61+gcd5dbe953\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", + " layers: counts (uint32), detected (uint32), log_sum (float64),\n", + " 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", @@ -238,7 +239,7 @@ "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", + "image/png": "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", "text/plain": [ "
" ] @@ -366,7 +367,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T22:21:37+00:00", + "executed_at": "2026-10-27T09:55:28+00:00", "executed_code_sha256": "cda3726c97acc5f96fb34da2f1a14df7ca8fd0725e2e817bb1c83427700dfef3", "executed_datasets": { "simulated_pbmc": { @@ -374,8 +375,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev61+g194f49f8f", - "execution_seconds": 6.4, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 7.6, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/repeated_measures.ipynb b/docs/source/guides/repeated_measures.ipynb index f1c50b0..0364732 100644 --- a/docs/source/guides/repeated_measures.ipynb +++ b/docs/source/guides/repeated_measures.ipynb @@ -35,7 +35,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev54+g3f0cbb52e\n" + "CytePool 0.1.dev61+gcd5dbe953\n" ] }, { @@ -130,18 +130,20 @@ "text": [ "Design check: 18 samples, 9 columns, rank 8, 10 residual degrees of freedom.\n", "2 errors:\n", - " 1. [rank_deficient] the design matrix has 9 columns but rank 8, so 1 coefficient is\n", - " not estimable. Aliased columns: diseasepatient = donorP1 + donorP2 + donorP3. The\n", - " columns in each relation cannot be estimated separately; remove or recode the\n", - " variables behind them (see the other findings), or drop terms from the formula\n", + " 1. [rank_deficient] the design matrix has 9 columns but rank 8, so 1\n", + " coefficient is not estimable. Aliased columns: diseasepatient = donorP1 +\n", + " donorP2 + donorP3. The columns in each relation cannot be estimated\n", + " separately; remove or recode the variables behind them (see the other\n", + " findings), or drop terms from the formula\n", " 2. [confounded] every level of donor holds a single level of disease (disease\n", - " 'healthy': donor 'H1', 'H2' and 'H3'; disease 'patient': donor 'P1', 'P2' and\n", - " 'P3'), so the effect of disease cannot be separated from the donor effects. Remove\n", - " donor from the formula; if donor groups repeated samples (donors, batches), the\n", - " right model has it as a random effect, random='(1 | donor)'; fit_mixed_model\n", - " estimates this random intercept by REML; fit_linear_model fits it with a known\n", - " correlation, given block= (the donor of each sample) and correlation=; or pool the\n", - " samples of each donor with Cube.collapse_samples('donor')\n" + " 'healthy': donor 'H1', 'H2' and 'H3'; disease 'patient': donor 'P1', 'P2'\n", + " and 'P3'), so the effect of disease cannot be separated from the donor\n", + " effects. Remove donor from the formula; if donor groups repeated samples\n", + " (donors, batches), the right model has it as a random effect, random='(1 |\n", + " donor)'; fit_mixed_model estimates this random intercept by REML;\n", + " fit_linear_model fits it with a known correlation, given block= (the donor\n", + " of each sample) and correlation=; or pool the samples of each donor with\n", + " Cube.collapse_samples('donor')\n" ] } ], @@ -351,14 +353,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "median share of a gene's variance:" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " donor 8%, condition 43%, residuals 34%\n" + "median share of a gene's variance: donor 8%, condition 43%, residuals 34%\n" ] }, { @@ -428,15 +423,15 @@ "datasets": [ "kang2018" ], - "executed_at": "2026-10-26T20:33:06+00:00", + "executed_at": "2026-10-27T08:56:32+00:00", "executed_code_sha256": "2e5054ab4f70248a8fc0402fc8e5a3b063e1195d610523ac208e67f8a3a1b56b", "executed_datasets": { "kang2018": { "kang2018.cube.zarr": "sha256:a30af3dabe17f21a6c75f41b64a279a1423640b9aa919022cf67897f9cc77a51" } }, - "executed_with": "0.1.dev54+g3f0cbb52e", - "execution_seconds": 2.3, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 2.8, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/replication_across_studies.ipynb b/docs/source/guides/replication_across_studies.ipynb index c1bacb7..a91416e 100644 --- a/docs/source/guides/replication_across_studies.ipynb +++ b/docs/source/guides/replication_across_studies.ipynb @@ -33,7 +33,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev55+g941b81fb5, numpy 2.5.4\n", + "CytePool 0.1.dev61+gcd5dbe953, numpy 2.5.4\n", "monocyte genes, adjusted p < 0.05 every cohort one cohort unchanged\n", "cohort_1 (60 donors) 62 10 1\n", "cohort_2 (32 donors) 38 10 4\n", @@ -204,8 +204,9 @@ "[@storey2003], estimates the share that change in the second cohort, whether it finds\n", "them or not. {api}`plot_study_agreement` draws it for every pair of cohorts. Each\n", "entry is computed from the few dozen genes that one cohort finds; on so few p-values\n", - "qvalue's default estimate of π₀, a smoother read at λ = 0.95, is unsteady, and a\n", - "single λ of 0.5 is steadier (`null_proportion={\"lambdas\": 0.5}`)." + "qvalue's default estimate of π₀, a smoother read at λ = 0.95, is unsteady, so the\n", + "analysis estimates it at a single λ of 0.5, which is steadier; `null_proportion={}`\n", + "asks for qvalue's smoother." ] }, { @@ -240,16 +241,16 @@ } ], "source": [ - "steady = differential_expression_replication(\n", + "smoother = differential_expression_replication(\n", " collection,\n", " results,\n", " group=monocytes,\n", " contrast=contrast,\n", - " null_proportion={\"lambdas\": 0.5},\n", + " null_proportion={},\n", ")\n", - "pairs = steady.study_pairs\n", + "pairs = replication.study_pairs\n", "for name, pi1 in (\n", - " (\"qvalue's smoother\", replication.study_pairs[\"pi1\"]),\n", + " (\"qvalue's smoother\", smoother.study_pairs[\"pi1\"]),\n", " (\"lambda 0.5\", pairs[\"pi1\"]),\n", "):\n", " low, high, mean = pi1.min(), pi1.max(), pi1.mean()\n", @@ -259,7 +260,7 @@ "print(f\"share of the genes found by both cohorts: mean {both.mean():.2f}\")\n", "print(f\"share with the same sign: {signs.min():.2f} to {signs.max():.2f}\")\n", "figure, ax = plt.subplots(figsize=(7.5, 5.8), layout=\"constrained\")\n", - "plot_study_agreement(steady, ax=ax)\n", + "plot_study_agreement(replication, ax=ax)\n", "plt.show()" ] }, @@ -377,7 +378,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -589,8 +590,9 @@ " neither says that a change replicates, which {api}`partial_conjunction` tests\n", " (`at_least`, and `conjunction_method` for Simes's, Fisher's or Stouffer's\n", " combination).\n", - "- **π₁ on few genes.** Estimate π₀ at one λ, such as 0.5, or with qvalue's bootstrap\n", - " (`null_proportion={\"method\": \"bootstrap\"}`), when the cohorts find few genes.\n", + "- **π₁ on few genes.** π₀ is estimated at λ = 0.5, which few genes allow;\n", + " `null_proportion` chooses qvalue's smoother (`{}`) or its bootstrap\n", + " (`{\"method\": \"bootstrap\"}`) instead, for cohorts that find many genes.\n", "- **SumRank's proportion and p-values.** Summing every cohort, the Irwin-Hall p-values\n", " serve; summing fewer needs permutations (`n_permutations` and `permute`), each of\n", " which runs every cohort's analysis again, and designs with random effects cannot be\n", @@ -606,8 +608,8 @@ "datasets": [ "simulated_cohorts" ], - "executed_at": "2026-10-26T21:31:43+00:00", - "executed_code_sha256": "150d11925767e14113ab6fb25d5b773c4c35c7a7807b2920ed3c0807d9da6454", + "executed_at": "2026-10-27T09:55:55+00:00", + "executed_code_sha256": "9bfed2842a4da7563afba831de632ce6218b6e2ad12310ed995b3f12cbeaaac3", "executed_datasets": { "simulated_cohorts": { "simulated_cohort_1.cube.zarr": "sha256:e97a0a97353376a5ac3a5c1e34f7e5f6fad6b0ac07c09b738b808fba6ccedb9e", @@ -619,8 +621,8 @@ "simulated_cohorts_truth.npz": "sha256:6599ea11dddb183f630183846f7ece9991003a4cc77875e4e7822317f66346ec" } }, - "executed_with": "0.1.dev55+g941b81fb5", - "execution_seconds": 19.3, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 26.7, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/guides/save_and_trace_cubes.ipynb b/docs/source/guides/save_and_trace_cubes.ipynb index 0be7efb..e57942f 100644 --- a/docs/source/guides/save_and_trace_cubes.ipynb +++ b/docs/source/guides/save_and_trace_cubes.ipynb @@ -39,9 +39,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev57+gb65bc7e32\n", + "CytePool 0.1.dev61+gcd5dbe953\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", + " layers: counts (uint32, lazy), detected (uint32, lazy), log_sum (float64,\n", + " 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", @@ -124,7 +125,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Source, as the caller recorded it (unresolved: CytePool does not follow its references):\n", + "Source, as the caller recorded it (unresolved: CytePool does not follow its\n", + " references):\n", " dataset: \"simulated_pbmc\"\n", " generator: \"docs/datasets.py, numpy.random.default_rng(20261026)\"\n", " cells: \"every simulated cell\"\n", @@ -135,15 +137,22 @@ " 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", + " normalized values: each cell scaled to a total of 10,000, with library sizes\n", + " the total count of each cell\n", + "1. select, applied to the cube\n", + " 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", + "2. regroup, applied to the cube\n", + " 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" + "References: CytePool resolves none on its own. The source record's references\n", + " need the tool that wrote them. A fingerprint names a cube without\n", + " saying where it is: Cube.fingerprint() of a cube at hand says\n", + " whether it is that cube.\n", + "Fingerprint:\n", + " sha256:dc89e3961d73b0f35d90cb69fccfeb7f8c004c3f0a1bc23ecaadd840d1dfaaec\n" ] } ], @@ -372,7 +381,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T22:03:19+00:00", + "executed_at": "2026-10-27T08:56:44+00:00", "executed_code_sha256": "bc541ca76208660d90591cf1253aa41a17b7b9a4cf7fbad83ff44a07b86181d5", "executed_datasets": { "simulated_pbmc": { @@ -380,8 +389,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev57+gb65bc7e32", - "execution_seconds": 2.9, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 2.0, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/quickstart.ipynb b/docs/source/quickstart.ipynb index ab6f73f..861eebc 100644 --- a/docs/source/quickstart.ipynb +++ b/docs/source/quickstart.ipynb @@ -49,9 +49,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "CytePool 0.1.dev57+gb65bc7e32\n", + "CytePool 0.1.dev61+gcd5dbe953\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", + " layers: counts (uint32), detected (uint32), log_sum (float64),\n", + " 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", @@ -137,18 +138,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "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" + "DifferentialExpressionResult (limma_voom): 6 groups, 6 fitted; 1 contrast:\n", + " stim_vs_ctrl\n", + " B cells: 24 samples, 1,951 features\n", + " CD4 T cells: 24 samples, 1,998 features\n", + " CD8 T cells: 24 samples, 1,974 features\n", + " Dendritic cells: 18 samples, 1,498 features\n", + " Monocytes: 24 samples, 1,997 features\n", + " NK cells: 24 samples, 1,918 features\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -199,7 +201,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -384,7 +386,7 @@ "datasets": [ "simulated_pbmc" ], - "executed_at": "2026-10-26T22:13:56+00:00", + "executed_at": "2026-10-27T09:54:43+00:00", "executed_code_sha256": "c45a47a9acccc6128493bc7f749914d4619686b9fe4c7d9948ad08dba4a141a5", "executed_datasets": { "simulated_pbmc": { @@ -392,8 +394,8 @@ "simulated_pbmc_cells.npz": "sha256:0d4c9154b87dbf8e9796232c2afec4a8340368fd0f5d386df4dd780c4e478129" } }, - "executed_with": "0.1.dev57+gb65bc7e32", - "execution_seconds": 5.0, + "executed_with": "0.1.dev61+gcd5dbe953", + "execution_seconds": 10.7, "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/docs/source/reference/api/differential_expression.md b/docs/source/reference/api/differential_expression.md index 30587b1..45cd9ff 100644 --- a/docs/source/reference/api/differential_expression.md +++ b/docs/source/reference/api/differential_expression.md @@ -19,7 +19,9 @@ off by default, add sample quality weights, prior weights from the number of cel minimum total count per sample, and p-values adjusted across groups. The result holds a table per group and contrast, a summary of every group, the samples used and left out with the weights of each fit, and a record that traces every number to the -profiles of the cube that produced it. +profiles of the cube that produced it. It keeps the cube and design it analysed, and +{meth}`~cytepool.differential_expression.DifferentialExpressionResult.fit` computes a +group's fit again, with the values, weights and moderated tests behind its tables. ```{eval-rst} .. automodule:: cytepool.differential_expression diff --git a/docs/source/reference/api/index.md b/docs/source/reference/api/index.md index 2e58e4b..6b65424 100644 --- a/docs/source/reference/api/index.md +++ b/docs/source/reference/api/index.md @@ -1,7 +1,7 @@ --- myst: html_meta: - description: The CytePool Python API for pseudobulk cubes, their conversion to and from AnnData and MuData, designs, normalization, linear models, mixed models, voom, dream, sample quality weights, negative binomial models, quasi-likelihood F-tests, DESeq2's dispersions and tests, empirical Bayes moderation, gene-set tests (including rotation tests), pathway scores, networks of regulators and pathways and their activities, multiple testing, differential expression, principal components of samples, cell-type composition, meta-analysis, combined p-values and replication across studies, SumRank and held-out prediction, and distributions. + description: The CytePool Python API for pseudobulk cubes, their conversion to and from AnnData and MuData, designs, normalization, linear models, mixed models, voom, dream, sample quality weights, negative binomial models, quasi-likelihood F-tests, DESeq2's dispersions and tests, empirical Bayes moderation, gene-set tests (including rotation tests), pathway scores, networks of regulators and pathways and their activities, tests of scores and activities with a design, multiple testing, differential expression, principal components of samples, cell-type composition, the results of several studies, meta-analysis, combined p-values and replication across studies, SumRank and held-out prediction, and distributions. --- # CytePool API reference @@ -42,6 +42,7 @@ gsea pathway_scores networks activity +score_tests multiple_testing combined_p_values differential_expression @@ -49,6 +50,7 @@ variance_partitioning principal_components composition meta_analysis +study_results replication sumrank held_out_prediction diff --git a/docs/source/reference/api/score_tests.md b/docs/source/reference/api/score_tests.md new file mode 100644 index 0000000..46ceff4 --- /dev/null +++ b/docs/source/reference/api/score_tests.md @@ -0,0 +1,22 @@ +--- +myst: + html_meta: + description: Test the pathway scores and regulator activities of each sample with a design in CytePool, by limma's linear models and moderated t-tests, in one call with the design built for the cube. +--- + +# Tests of pathway scores and activities + +Pathway scores and the activities of regulators give every sample of a cell type one +value per gene set or source, and differ between conditions as expression values do. +{func}`~cytepool.score_tests.limma` tests a contrast of a +{class}`~cytepool.design.Design` on them as GSVA's and decoupler's guides do with +limma: a linear model of every set's scores, moderated t-tests of the contrast and +Benjamini-Hochberg adjusted p-values, with the design built for the cube matched to +the scored samples by `sample_id`. It takes +{class}`~cytepool.pathway_scores.PathwayScores`, +{class}`~cytepool.activity.Activities` of samples, or an array of values from another +platform. + +```{eval-rst} +.. automodule:: cytepool.score_tests +``` diff --git a/docs/source/reference/api/study_results.md b/docs/source/reference/api/study_results.md new file mode 100644 index 0000000..7495a14 --- /dev/null +++ b/docs/source/reference/api/study_results.md @@ -0,0 +1,23 @@ +--- +myst: + html_meta: + description: Analyse every study of a CubeCollection alike in CytePool, each on its aligned cube with a design built from its own samples, and keep the results together, lined up gene by gene or as a studies x genes matrix for combined p-values and SumRank. +--- + +# Results of several studies + +Studies of one question are compared or combined once each is analysed on the +collection's axes: its aligned cube, with a design built from its own samples. +{func}`~cytepool.study_results.analyse_each_study` runs +{func}`~cytepool.differential_expression.limma_voom`, +{func}`~cytepool.differential_expression.limma_trend` or +{func}`~cytepool.differential_expression.dream_voom` on every study of a +{class}`~cytepool.cube.CubeCollection` that way, with one formula, its levels and +contrasts. {class}`~cytepool.study_results.StudyResults` keeps the results with their +collection: it lines them up gene by gene, with the reason a study has no value for a +gene, and gives one column of every study, such as the p-values, as a studies x genes +matrix, the form that combined p-values and SumRank take. + +```{eval-rst} +.. automodule:: cytepool.study_results +``` diff --git a/docs/source/statistics/meta_analysis.md b/docs/source/statistics/meta_analysis.md index ef35c8c..cd649e3 100644 --- a/docs/source/statistics/meta_analysis.md +++ b/docs/source/statistics/meta_analysis.md @@ -161,7 +161,10 @@ a {api}`ReplicationResult` with four tables: studies whose effect has the combined direction; and Cochran's $Q$, $I^2$ and $\tau^2$ of its log2 fold changes, from {api}`meta_analysis`; - `study_pairs`: for every ordered pair of studies, $\pi_1$ and the sign agreement of - the genes the first finds in the second, and how many the second finds too; + the genes the first finds in the second, and how many the second finds too. $\pi_0$ + is estimated at $\lambda = 0.5$ by default: on the few dozen p-values of the genes + one study finds, qvalue's smoother, which reads the largest $\lambda$, often gives + $\pi_1$ of 0 or 1 (`null_proportion={}` asks for it); - `found_in`: the genes that at least $k$ studies find, and in one direction; - `studies`: each study's samples, weight, and the genes it tested and finds. diff --git a/docs/source/validation.md b/docs/source/validation.md index f5209c2..346a25f 100644 --- a/docs/source/validation.md +++ b/docs/source/validation.md @@ -2108,11 +2108,12 @@ lambda, with its defaults, `smooth.df = 5`, `smooth.log.pi0`, `pi0.method = before and after a stimulation that changes 15% of 700 genes in two cell types, alike in every cohort up to 50% more or less, each measuring part of the genes, are aligned in a `CubeCollection` and tested by `limma_voom`; `differential_expression_replication` runs -on both cell types with three settings, and R computes every column from the cohorts' -tables with metap, qvalue, `p.adjust` and metafor's `rma.uni` (REML with `control = -list(threshold = 1e-13, maxiter = 10000)`, or DerSimonian-Laird). The figures are -compared with what R computes for them. Reference: scipy 1.18.1, mpmath 1.3.0; R 4.4.3, -metap 1.1, qvalue 2.38.0, jsonlite 2.0.0; metafor 5.0.1. +on both cell types with four settings, among them qvalue's defaults for pi1 +(`null_proportion={}`) and pi1 by default (lambda = 0.5), and R computes every column +from the cohorts' tables with metap, qvalue, `p.adjust` and metafor's `rma.uni` (REML +with `control = list(threshold = 1e-13, maxiter = 10000)`, or DerSimonian-Laird). The +figures are compared with what R computes for them. Reference: scipy 1.18.1, mpmath +1.3.0; R 4.4.3, metap 1.1, qvalue 2.38.0, jsonlite 2.0.0; metafor 5.0.1. | Check family | Reference | Largest difference | Tolerance | Outcome | | --- | --- | --- | --- | --- | @@ -2125,8 +2126,9 @@ metap 1.1, qvalue 2.38.0, jsonlite 2.0.0; metafor 5.0.1. | Replications, genes: counts, directions, sign agreement, combined and partial conjunction p-values, adjusted | metap, `p.adjust` | 3.1e-15 | 1e-10 | 1 pass | | Replications, heterogeneity: Q, its p-value, I² and tau², by REML and DerSimonian-Laird | `rma.uni` | 2.0e-12 | 1e-6 (REML), 1e-10 | 2 pass | | Replications, pairs of studies: genes found, sign agreement, pi1 where qvalue gives it; genes found in at least k studies | `pi0est`, R | 0 | 1e-10, 0 mismatches | 2 pass | +| pi1 by default (`null_proportion` left out): pi0 at lambda = 0.5, 9 values where qvalue gives one | `pi0est(lambda = 0.5)` | 0 | 1e-10 | 1 pass | | `plot_study_agreement` and `plot_replicated_genes`: the values and bars drawn | `pi0est`, R | 0 | 1e-10, 0 mismatches | 2 pass | -| metap at a p-value of 0 and for one study; pi0est where no p-value reaches the largest lambda (smoother, bootstrap), where its estimate is at most 0, for pi1 of 20 pairs of studies, and for 96 values of lambda | metap, `pi0est` | listed below | n/a | 7 deliberate differences | +| metap at a p-value of 0 and for one study; pi0est where no p-value reaches the largest lambda (smoother, bootstrap), where its estimate is at most 0, for pi1 of 23 pairs of studies, and for 96 values of lambda | metap, `pi0est` | listed below | n/a | 7 deliberate differences | Differences are scaled by max(\|reference\|, 1), and p-values by max(p, 1e-300) max(1, \|log p\|); counts and directions must be equal. qvalue's @@ -2139,9 +2141,9 @@ the smoothing parameter: the estimates agree to about 1e-12. Deliberate differen - qvalue stops with an error where no p-value reaches the largest lambda, with the smoother ("missing or infinite values in inputs are not allowed") and the bootstrap alike; CytePool smooths the zero, and gives the count no variance in the bootstrap. - This is common for pi1 between studies, whose genes have small p-values: of the 36 + This is common for pi1 between studies, whose genes have small p-values: of the 48 pairs of the replications, qvalue stopped for all 12 with its defaults, 7 of 12 with - the bootstrap and 1 of 12 with lambda = 0.5, where its estimate was 0. + the bootstrap and 4 of 24 with lambda = 0.5, where its estimate was 0. - qvalue stops where its estimate is at most 0; CytePool gives 0. - With more than 49 values of lambda, R's `smooth.spline` keeps a knot at some of them only; CytePool keeps one at every lambda. For 96 values (0, 0.01, ..., 0.95) the diff --git a/tests/test_activity.py b/tests/test_activity.py index 8f0a115..14b2522 100644 --- a/tests/test_activity.py +++ b/tests/test_activity.py @@ -8,11 +8,14 @@ plot is compared with decoupler's and the heatmap read back from what it draws. """ +import dataclasses import doctest import itertools import json import math +import pickle from pathlib import Path +from typing import Any import numpy as np import pytest @@ -423,6 +426,54 @@ def test_a_cubes_group_is_scored_as_its_log_cpm() -> None: assert fit.coefficients.shape == (len(result.sources), 2) +def assert_pickles(record: Any) -> None: + """A record comes back from pickle with equal fields, read-only arrays and + settings, and the same provenance, or none.""" + copy = pickle.loads(pickle.dumps(record)) + for field in dataclasses.fields(record): + mine, theirs = getattr(record, field.name), getattr(copy, field.name) + if isinstance(mine, np.ndarray): + assert_array_equal(theirs, mine) + assert theirs.dtype == mine.dtype and not theirs.flags.writeable + elif isinstance(mine, Table): + assert theirs.equals(mine) + elif field.name == "settings": + assert dict(theirs) == dict(mine) + with pytest.raises(TypeError): + theirs["x"] = 1 # type: ignore[index] + elif hasattr(mine, "edges"): # a Network + assert theirs.edges.equals(mine.edges) + elif hasattr(mine, "items"): # GeneSets + assert dict(theirs.items()) == dict(mine.items()) + else: + assert theirs == mine, field.name + assert copy.provenance == record.provenance + if record.provenance is None: + assert "_provenance" not in vars(copy) + + +def test_activities_of_a_cube_record_the_cube_they_read() -> None: + cube = _cube() + result = ulm(cube, NETWORK, group="B") + record = result.provenance + assert record is not None + assert record["method"] == "ulm" and record["layer"] == "counts" + assert record["cube"]["fingerprint"] == cube.fingerprint() + assert record["settings"] == result.settings + assert json.loads(json.dumps(record)) == record + assert mlm(cube, NETWORK, group="B").provenance["method"] == "mlm" + # Activities of values or of statistics name no cube. + of_values = ulm(VALUES, NETWORK, gene_ids=GENES) + assert of_values.provenance is None + tested = limma_voom(cube, Design(cube.samples, "~ condition"), + contrasts={"stim": "conditionstim"}, min_cells=0) # fmt: skip + assert ulm(tested, NETWORK, min_targets=3).provenance is None + # They pickle, the provenance with them. + assert_pickles(result) + assert_pickles(of_values) + assert_pickles(weighted_aggregate(cube, NETWORK, group="B", rng=1)) + + def test_each_group_and_contrast_of_a_result_is_a_profile() -> None: cube = _cube() result = limma_voom(cube, Design(cube.samples, "~ condition"), diff --git a/tests/test_anndata_conversion.py b/tests/test_anndata_conversion.py index 748d472..349bb01 100644 --- a/tests/test_anndata_conversion.py +++ b/tests/test_anndata_conversion.py @@ -8,6 +8,7 @@ skipped without them. """ +import json import sys from pathlib import Path from typing import Any @@ -277,6 +278,32 @@ def test_to_anndata_of_a_bulk_cube_writes_every_entry(ad: Any) -> None: assert_array_equal(adata.layers["counts"], cube.layer("counts", "bulk")) +def test_x_layer_copies_a_layer_into_x_and_reads_back_as_the_cube(ad: Any) -> None: + cube = varied_cube() + plain = to_anndata(cube) + adata = to_anndata(cube, x_layer="counts") + assert plain.X is None + # X is a copy of the layer; the rest is the export without it. + assert_array_equal(adata.X, adata.layers["counts"]) + assert adata.X.dtype == adata.layers["counts"].dtype + assert not np.shares_memory(adata.X, adata.layers["counts"]) + assert adata.obs.equals(plain.obs) and adata.var.equals(plain.var) + # anndata 0.13 also lists X among the layers, under the key None. + assert [name for name in adata.layers if name is not None] == list(plain.layers) + for name in cube.layer_names: + assert_array_equal(adata.layers[name], plain.layers[name]) + assert json.dumps(adata.uns["cytepool"], sort_keys=True) == json.dumps( + plain.uns["cytepool"], sort_keys=True + ) + assert from_anndata(adata).fingerprint() == cube.fingerprint() + detected = to_anndata(cube, x_layer="detected") + assert_array_equal(detected.X, plain.layers["detected"]) + with pytest.raises(KeyError, match="the cube has no layer 'raw' to copy into X"): + to_anndata(cube, x_layer="raw") + with pytest.raises(TypeError, match="x_layer must be a layer name"): + to_anndata(cube, x_layer=1) # type: ignore[arg-type] + + def test_to_mudata_writes_a_modality_for_each_group(md: Any, pd: Any) -> None: cube = varied_cube() mdata = to_mudata(cube) @@ -1283,12 +1310,14 @@ def test_the_history_describes_imports_in_plain_terms() -> None: text = describe_provenance({"construction": construction, "operations": [imported]}) + # Lines of at most 80 characters; a longer item continues below its value. assert text.splitlines() == [ - "Built by from_anndata (CytePool 1.0) from 12 profiles of an AnnData, in the " - "layout of decoupler.pp.pseudobulk:", + "Built by from_anndata (CytePool 1.0) from 12 profiles of an AnnData, in the", + " layout of decoupler.pp.pseudobulk:", " samples: the sorted distinct labels", " groups: the rows of group_table; the labels were integers, written as " - "decimal text", + "decimal", + " text", " layers: counts from 'X', detected from 'psbulk_props'", ' sample_column: "sample"', ' group_column: "group"', @@ -1296,8 +1325,8 @@ def test_the_history_describes_imports_in_plain_terms() -> None: " obs_columns: null", "1. from_mudata, reading a MuData that CytePool exported from the cube " "sha256:ab", - "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.", + "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.", ] diff --git a/tests/test_combined_p_values_and_replication.py b/tests/test_combined_p_values_and_replication.py index 24c9232..a097a3a 100644 --- a/tests/test_combined_p_values_and_replication.py +++ b/tests/test_combined_p_values_and_replication.py @@ -694,6 +694,43 @@ def column(name: str) -> np.ndarray: assert count == np.count_nonzero(result.genes["n_found"] >= k_studies) +def test_pi1_is_at_lambda_one_half_by_default_and_qvalues_with_no_options() -> None: + collection, results = cohorts() + + def run(**options: Any) -> ReplicationResult: + return differential_expression_replication( + collection, results, "T", "stim_vs_ctrl", **options + ) + + default, half, smoother = ( + run(), + run(null_proportion={"lambdas": 0.5}), + run(null_proportion={}), + ) + assert default.study_pairs.equals(half.study_pairs) + assert default.settings == half.settings + assert default.settings["null_proportion"] == {"lambdas": 0.5} + assert smoother.settings["null_proportion"] == {} + # Only pi1 changes: every other number is the same. + assert default.genes.equals(smoother.genes) + assert default.study_pairs.select(["discovery", "replication", "n_found"]).equals( + smoother.study_pairs.select(["discovery", "replication", "n_found"]) + ) + # pi1 of the first pair from its definition: 1 - pi0, pi0 the share of the + # p-values above 0.5 over 0.5, at most 1 (Storey and Tibshirani 2003); and from + # qvalue's smoother with {}. + aligned = align_study_results(collection, results, "T", "stim_vs_ctrl") + k, n = collection.n_studies, collection.n_features + tested = np.array(aligned["status"].tolist()).reshape(k, n) == "tested" + p = np.where(tested, np.asarray(aligned["p_value"]).reshape(k, n), np.nan) + adjusted = np.asarray(aligned["adjusted_p_value"]).reshape(k, n) + found = tested[0] & (adjusted[0] < 0.05) & tested[1] + replicated = p[1, found] + by_hand = 1.0 - min(1.0, np.mean(replicated > 0.5) / 0.5) + assert default.study_pairs["pi1"][0] == pytest.approx(by_hand, rel=1e-15) + assert smoother.study_pairs["pi1"][0] == proportion_of_true_nulls(replicated).pi1 + + def test_replication_records_its_settings_studies_and_provenance() -> None: result = replication("T1") settings = result.settings @@ -709,6 +746,7 @@ def test_replication_records_its_settings_studies_and_provenance() -> None: with pytest.raises(AttributeError, match="immutable"): result._genes = None # type: ignore[misc] assert "ReplicationResult of group 'T'" in repr(result) + assert max(map(len, repr(result).splitlines())) <= 80 def test_replication_refuses_invalid_settings() -> None: diff --git a/tests/test_composition.py b/tests/test_composition.py index bfa1028..28914cb 100644 --- a/tests/test_composition.py +++ b/tests/test_composition.py @@ -290,6 +290,15 @@ def test_baseline_and_mean_proportions_and_ratio_by_hand() -> None: ) +def test_the_table_of_the_only_contrast_needs_no_name() -> None: + result = propeller(CELLS, two_group_design()) + assert result.table().equals(result.table("stim_vs_ctrl")) + several = propeller(fixture_cube("covariate"), covariate_design()) + message = "the result has 4 contrasts; name one with contrast, one of 'B_vs_A'" + with pytest.raises(ValueError, match=message): + several.table() + + def test_a_weighted_contrast_has_the_weighted_geometric_ratio() -> None: contrasts = {"S_vs_C": "(conditionstim + conditionctrl)/2 - conditionctrl"} table = propeller(CELLS, two_group_design(contrasts=contrasts)).table("S_vs_C") @@ -551,6 +560,7 @@ def test_the_result_records_the_cube_and_settings_and_pickles() -> None: ): result.table("C_vs_A") assert "F-test across the 3 levels of group" in repr(result) + assert max(map(len, repr(result).splitlines())) <= 80 assert isinstance(result, CompositionResult) diff --git a/tests/test_cube.py b/tests/test_cube.py index 6f565e2..b0f999f 100644 --- a/tests/test_cube.py +++ b/tests/test_cube.py @@ -431,6 +431,209 @@ def test_collapse_samples_by_integer_column_and_invalid_columns( make_cube(layers, samples=missing).collapse_samples("donor") +def test_collapse_samples_by_several_columns_joins_their_values( + cells: dict[str, np.ndarray], cube: Cube +) -> None: + # Donor and batch: S1 and S4 are D1 in batch 1, S2 is D2 in batch 2, S3 is D1 in + # batch 2. + pooled = cube.collapse_samples(["donor", "batch"]) + key_of = {"S1": "D1_1", "S2": "D2_2", "S3": "D1_2", "S4": "D1_1"} + keys = np.array([key_of[sample] for sample in cells["sample"]]) + new_ids = ["D1_1", "D2_2", "D1_2"] + expected, n_cells = aggregate(cells, keys, cells["group"], new_ids, GROUPS) + assert pooled.samples["sample_id"].tolist() == new_ids + assert_array_equal(pooled.n_cells, n_cells) + assert_layers_equal(pooled, expected) + # The tissue varies within D1_1 and is dropped; the other columns are constant. + assert pooled.samples.columns == ( + "sample_id", + "donor", + "condition", + "age", + "batch", + "n_pooled_samples", + ) + assert pooled.samples["n_pooled_samples"].tolist() == [2, 1, 1] + assert pooled.provenance["operations"][-1] == { + "operation": "collapse_samples", + "input": cube.fingerprint(), + "by": ["donor", "batch"], + "membership": {"D1_1": ["S1", "S4"], "D2_2": ["S2"], "D1_2": ["S3"]}, + } + as_tuple = cube.collapse_samples(("donor", "batch")) + assert as_tuple.fingerprint() == pooled.fingerprint() + assert as_tuple.provenance == pooled.provenance + one = cube.collapse_samples(["donor"]) + assert one.fingerprint() == cube.collapse_samples("donor").fingerprint() + assert one.provenance["operations"][-1]["by"] == ["donor"] + + +def test_collapse_samples_without_columns_pools_every_sample( + cells: dict[str, np.ndarray], cube: Cube +) -> None: + pooled = cube.collapse_samples() + everyone = np.full(cells["sample"].size, "all") + expected, n_cells = aggregate(cells, everyone, cells["group"], ["all"], GROUPS) + assert pooled.samples["sample_id"].tolist() == ["all"] + # Every sample column varies across the samples, so only the count is left. + assert pooled.samples.columns == ("sample_id", "n_pooled_samples") + assert pooled.samples["n_pooled_samples"].tolist() == [4] + assert_array_equal(pooled.n_cells, n_cells) + assert_layers_equal(pooled, expected) + for g, group in enumerate(GROUPS): + rows = cells["group"] == group + assert_allclose( + pooled.mean()[g, 0], cells["log"][rows].mean(axis=0), rtol=1e-12 + ) + assert pooled.provenance["operations"][-1] == { + "operation": "collapse_samples", + "input": cube.fingerprint(), + "by": None, + "membership": {"all": SAMPLES}, + } + assert cube.collapse_samples(None).fingerprint() == pooled.fingerprint() + + +@pytest.mark.parametrize( + ("by", "error", "message"), + [ + ([], ValueError, "by names no sample column; give one or more, or None"), + (["donor", 3], TypeError, "by must name sample columns (str), got int 3"), + (["donor", "donor"], ValueError, "by names the sample column 'donor' twice"), + (["donor", "site"], KeyError, "no sample column named 'site'"), + (["donor", "age"], TypeError, "'age' has dtype float64"), + (3, TypeError, "by must be a sample column name, a list of them, or None"), + (b"donor", TypeError, "got bytes"), + ], +) +def test_collapse_samples_rejects_invalid_columns( + cube: Cube, by: Any, error: type, message: str +) -> None: + with pytest.raises(error, match=re.escape(message)): + cube.collapse_samples(by) + + +def test_collapse_samples_refuses_values_that_join_to_the_same_id( + layers: dict[str, np.ndarray], +) -> None: + # "x_y" with "z" and "x" with "y_z" both join to "x_y_z". + samples = dict(SAMPLE_TABLE, a=["x_y", "x", "x_y", "x"], b=["z", "y_z", "z", "y_z"]) + message = ( + "the values ('x_y', 'z') and ('x', 'y_z') of the sample columns 'a' and 'b' " + "both join to the id 'x_y_z'" + ) + with pytest.raises(ValueError, match=re.escape(message)): + make_cube(layers, samples=samples).collapse_samples(["a", "b"]) + + +@pytest.mark.parametrize("dtype", [np.uint16, np.int32]) +def test_collapse_samples_that_pools_nothing_keeps_the_integer_dtype( + layers: dict[str, np.ndarray], dtype: type +) -> None: + small = {name: layers[name].astype(dtype) for name in INTEGER_LAYERS} + cube = make_cube(dict(layers, **small)) + # Each donor and condition is one sample after selecting S1 and S2: nothing is + # summed, so the values and their dtype are kept. + two = cube.select(samples=["S1", "S2"]) + alone = two.collapse_samples("donor") + pooled = cube.collapse_samples("donor") + for name in INTEGER_LAYERS: + assert alone.layer(name).dtype == dtype + assert_array_equal(alone.layer(name), two.layer(name)) + assert pooled.layer(name).dtype == np.int64 + assert alone.samples["sample_id"].tolist() == ["D1", "D2"] + + +def test_with_columns_adds_and_replaces_columns_and_keeps_the_layers( + cube: Cube, +) -> None: + pools = ["P1", "P2", "P1", "P2"] + changed = cube.with_columns( + samples={"pool": pools, "condition": ["a", "b", "c", "d"]}, + groups={"marker": ["MS4A1", "CD4", "CD8A", "NCAM1"]}, + ) + # A replaced column keeps its place and new columns come last. + assert changed.samples.columns == (*SAMPLE_TABLE, "pool") + assert changed.samples["condition"].tolist() == ["a", "b", "c", "d"] + assert changed.samples["pool"].tolist() == pools + assert changed.groups.columns == (*GROUP_TABLE, "marker") + assert changed.features.equals(cube.features) + for name in cube.layer_names: + assert np.shares_memory(changed.layer(name), cube.layer(name)) + assert_array_equal(changed.n_cells, cube.n_cells) + assert changed.normalization == cube.normalization + assert changed.fingerprint() != cube.fingerprint() + assert changed.provenance == { + "source": "simulated cells", + "operations": [ + { + "operation": "with_columns", + "input": cube.fingerprint(), + "samples": {"added": ["pool"], "replaced": ["condition"]}, + "groups": {"added": ["marker"], "replaced": []}, + "features": None, + } + ], + } + # A Table gives the same cube as a mapping; nothing to add returns the cube. + from_table = cube.with_columns( + samples=changed.samples.select(["pool", "condition"]), + groups={"marker": ["MS4A1", "CD4", "CD8A", "NCAM1"]}, + ) + assert from_table.fingerprint() == changed.fingerprint() + assert cube.with_columns() is cube + assert cube.with_columns(samples={}) is cube + + +def test_with_columns_lets_any_set_of_samples_be_pooled( + cells: dict[str, np.ndarray], cube: Cube +) -> None: + pooled = cube.with_columns(samples={"pool": ["P1", "P2", "P1", "P2"]}) + pooled = pooled.collapse_samples("pool") + pool_of = {"S1": "P1", "S2": "P2", "S3": "P1", "S4": "P2"} + keys = np.array([pool_of[sample] for sample in cells["sample"]]) + expected, n_cells = aggregate(cells, keys, cells["group"], ["P1", "P2"], GROUPS) + assert pooled.samples["sample_id"].tolist() == ["P1", "P2"] + assert_array_equal(pooled.n_cells, n_cells) + assert_layers_equal(pooled, expected) + operations = pooled.provenance["operations"] + assert [record["operation"] for record in operations] == [ + "with_columns", + "collapse_samples", + ] + + +def test_with_columns_on_a_lazy_cube_reads_nothing( + cube: Cube, layers: dict[str, np.ndarray] +) -> None: + lazy = {name: LazyArray(array) for name, array in layers.items()} + lazy_cube = make_cube(lazy) + changed = lazy_cube.with_columns(features={"length": np.arange(N_FEATURES)}) + assert all(not array.reads for array in lazy.values()) + assert "lazy" in repr(changed) + expected = cube.with_columns(features={"length": np.arange(N_FEATURES)}) + assert changed.fingerprint() == expected.fingerprint() + assert_array_equal(changed.layer("counts", "B"), layers["counts"][0]) + + +@pytest.mark.parametrize( + ("arguments", "error", "message"), + [ + ({"samples": [1, 2, 3, 4]}, TypeError, "samples must be a mapping"), + ({"samples": {"sample_id": SAMPLES}}, ValueError, "names 'sample_id'"), + ({"groups": {"group_id": GROUPS}}, ValueError, "names 'group_id'"), + ({"features": {"feature_id": ["a"] * 20}}, ValueError, "names 'feature_id'"), + ({"samples": {"pool": ["P1", "P2"]}}, ValueError, "the samples table"), + ({"groups": {"size": [object()] * 4}}, TypeError, "the groups table"), + ], +) +def test_with_columns_rejects_invalid_columns( + cube: Cube, arguments: dict[str, Any], error: type, message: str +) -> None: + with pytest.raises(error, match=re.escape(message)): + cube.with_columns(**arguments) + + def test_statistics_regrouping_and_pooling_match_scanpy() -> None: # scanpy.get.aggregate on cells that scanpy normalized itself, written by # validation/cube.py --write-fixtures. @@ -1083,10 +1286,15 @@ def tiny_cube( def test_integer_layers_hold_values_up_to_the_largest_int64(lazy: bool) -> None: cube = tiny_cube(np.array([[[LARGEST, 0]]], dtype=np.uint64), lazy=lazy) assert cube.layer("counts", 0).tolist() == [[LARGEST, 0]] - # A rename converts to int64, where 2**63 - 1 is the largest value. + # A rename sums nothing and keeps the dtype; a merge sums in int64, where + # 2**63 - 1 is the largest value. renamed = cube.regroup({"h": ["g0"]}) - assert renamed.layer("counts", "h").dtype == np.int64 + assert renamed.layer("counts", "h").dtype == np.uint64 assert renamed.layer("counts", "h").tolist() == [[LARGEST, 0]] + two = tiny_cube(np.array([[[LARGEST, 0]], [[0, 1]]], dtype=np.uint64), lazy=lazy) + merged = two.regroup({"h": ["g0", "g1"]}) + assert merged.layer("counts", "h").dtype == np.int64 + assert merged.layer("counts", "h").tolist() == [[LARGEST, 1]] too_large = np.array([[[0, LARGEST + 1]]], dtype=np.uint64) message = re.escape( "layer 'counts' has a value above 2**63 - 1 (9223372036854775808) at group " @@ -1763,12 +1971,14 @@ def test_numpy_values_in_provenance_become_plain_json( def test_repr_reports_sizes_layers_and_filled_entries(cube: Cube) -> None: lines = repr(cube).splitlines() assert lines[0] == "Cube with 4 samples x 4 groups x 20 features" - assert lines[1] == ( - " layers: counts (int64), detected (int64), log_sum (float64), " - "log_sum_sq (float64), linear_sum (float64)" - ) - assert lines[2] == " filled: 15 of 16 sample x group entries have cells (93.8%)" - assert lines[3] == " samples: sample_id, donor, condition, age, tissue, batch" + # The layers continue on a second line, each with its dtype, under the first. + assert lines[1:3] == [ + " layers: counts (int64), detected (int64), log_sum (float64),", + " log_sum_sq (float64), linear_sum (float64)", + ] + assert lines[3] == " filled: 15 of 16 sample x group entries have cells (93.8%)" + assert lines[4] == " samples: sample_id, donor, condition, age, tissue, batch" + assert max(map(len, lines)) <= 80 def test_pickle_round_trip(cube: Cube) -> None: diff --git a/tests/test_cube_collection.py b/tests/test_cube_collection.py index b66b918..7a6055d 100644 --- a/tests/test_cube_collection.py +++ b/tests/test_cube_collection.py @@ -10,6 +10,7 @@ import copy import json import pickle +import re from functools import cache from pathlib import Path from typing import Any @@ -422,6 +423,80 @@ def test_groups_without_an_ontology_id_take_one_from_the_mapping() -> None: assert CubeCollection({"A": a, "P": plain}, group_mapping={"P": {"B": "B cell"}}) +def test_group_names_name_the_aligned_groups_and_change_no_value() -> None: + cubes = {"A": study_a(), "B": study_b()} + names = {"CL:2": "T cells", "CL:1": "B cells"} + named = CubeCollection(cubes, group_names=names) + plain = CubeCollection(cubes) + assert named.groups["group_id"].tolist() == ["B cells", "T cells", "CL:3"] + # The aligned column keeps each group's ontology id. + assert named.groups["cell_ontology_id"].tolist() == ["CL:1", "CL:2", "CL:3"] + assert named.group_members["group_id"].tolist() == [ + "B cells", "T cells", "B cells", "T cells", "T cells", "CL:3" + ] # fmt: skip + for study in ("A", "B"): + aligned, expected = named.aligned_cube(study), plain.aligned_cube(study) + assert aligned.groups["group_id"].tolist() == [ + names.get(group, group) for group in expected.groups["group_id"].tolist() + ] + assert aligned.groups.select(["cell_ontology_id"]).equals( + expected.groups.select(["cell_ontology_id"]) + ) + assert_array_equal(aligned.layer("counts"), expected.layer("counts")) + assert_array_equal(aligned.n_cells, expected.n_cells) + assert named.aligned_cube("B").provenance["operations"][-1]["membership"] == { + "B cells": ["B"], "T cells": ["CD4", "CD8"], "CL:3": ["NK"] + } # fmt: skip + stacked = named.stack() + assert stacked.groups["group_id"].tolist() == ["B cells", "T cells"] + assert_array_equal(stacked.layer("counts"), plain.stack().layer("counts")) + # The records hold the names as given, and nothing when none are given. + assert named.provenance["alignment"]["group_names"] == names + assert list(named.provenance["alignment"]["group_names"]) == ["CL:2", "CL:1"] + assert stacked.provenance["construction"]["group_names"] == names + assert "group_names" not in plain.provenance["alignment"] + assert "group_names" not in plain.stack().provenance["construction"] + selected = named.select(groups=["T cells"]) + assert selected.groups["group_id"].tolist() == ["T cells"] + assert selected.groups["cell_ontology_id"].tolist() == ["CL:2"] + # Groups aligned by group_id are renamed in that column. + mapping = {"B": {"B": "B cell", "CD4": "T cell", "CD8": "T cell", "NK": None}} + by_id = CubeCollection( + cubes, + align_groups_by="group_id", + group_mapping=mapping, + group_names={"T cell": "T lymphocytes"}, + ) + assert by_id.groups["group_id"].tolist() == ["B cell", "T lymphocytes"] + + +@pytest.mark.parametrize( + ("group_names", "error", "message"), + [ + (["CL:1"], TypeError, "group_names must map aligned group ids to names"), + ({1: "B cells"}, TypeError, "keyed by aligned group ids (str), got int 1"), + ({"CL:1": 3}, TypeError, "group_names['CL:1'] must be a name (str), got int"), + ({"CL:1": ""}, ValueError, "group_names['CL:1'] is empty"), + ({"CL:9": "x"}, KeyError, "names the aligned group 'CL:9', which no study has"), + ( + {"CL:1": "T", "CL:2": "T"}, + ValueError, + "the aligned groups 'CL:1' and 'CL:2' would both be named 'T'", + ), + ( + {"CL:1": "CL:3"}, + ValueError, + "the aligned groups 'CL:1' and 'CL:3' would both be named 'CL:3'", + ), + ], +) +def test_invalid_group_names_are_refused( + group_names: Any, error: type, message: str +) -> None: + with pytest.raises(error, match=re.escape(message)): + CubeCollection({"A": study_a(), "B": study_b()}, group_names=group_names) + + # Invariants. @@ -549,6 +624,38 @@ def cube(counts: np.ndarray) -> Cube: ).stack() +def _as_uint32(cube: Cube) -> Cube: + return Cube( + {"counts": cube.layer("counts").astype(np.uint32)}, + samples=cube.samples, + groups=cube.groups, + features=cube.features, + n_cells=cube.n_cells, + provenance=cube.provenance, + ) + + +def test_groups_only_renamed_keep_their_integer_dtype() -> None: + wide = {"A": study_a(), "B": study_b()} + small = {study: _as_uint32(cube) for study, cube in wide.items()} + # Aligned by ontology ids, A's groups are renamed (CL:1, CL:2) and B's CD4 and + # CD8 merge into CL:2; without CD8, B's groups are only renamed too. + for mapping, dtype_b in ((None, np.int64), ({"B": {"CD8": None}}, np.uint32)): + collection = CubeCollection(small, group_mapping=mapping) + reference = CubeCollection(wide, group_mapping=mapping) + for study, dtype in (("A", np.uint32), ("B", dtype_b)): + aligned = collection.aligned_cube(study) + assert aligned.groups["group_id"].tolist()[:2] == ["CL:1", "CL:2"] + assert aligned.layer("counts").dtype == dtype + assert_array_equal( + aligned.layer("counts"), reference.aligned_cube(study).layer("counts") + ) + # The stack takes the type that holds every study's part. + stacked = collection.stack().layer("counts") + assert stacked.dtype == (np.int64 if dtype_b == np.int64 else np.uint32) + assert_array_equal(stacked, reference.stack().layer("counts")) + + def test_normalized_layers_stack_only_from_studies_normalized_alike() -> None: def cube(target: float) -> Cube: return Cube( @@ -629,7 +736,9 @@ def test_a_stacked_cube_records_the_studies_it_stacks() -> None: assert construction["layers"] == ["counts"] history = stacked.history() assert "from 2 studies" in history - assert f"study 'B': the cube {b.fingerprint()}" in history + # Lines of at most 80 characters: a fingerprint goes on a line of its own. + assert f"study 'B': the cube {b.fingerprint()}" in " ".join(history.split()) + assert max(map(len, history.splitlines())) <= 80 assert " CL:2: CD4 + CD8" in history assert "sample columns written study::value: donor" in history diff --git a/tests/test_cube_fingerprints.py b/tests/test_cube_fingerprints.py index 1cfde68..ff4e4a3 100644 --- a/tests/test_cube_fingerprints.py +++ b/tests/test_cube_fingerprints.py @@ -246,13 +246,17 @@ def test_cubes_with_equal_values_have_the_same_fingerprint(tiny: Cube) -> None: rebuilt(tiny, samples={**samples, "score": score, "age": age}), rebuilt(tiny, layers=wide), # integers are hashed as int64, whatever the width rebuilt(tiny, provenance={"source": "anything else"}), - tiny.regroup({"type 0": ["type 0"]}), # renamed to itself: int64 layers + tiny.regroup({"type 0": ["type 0"]}), # renamed to itself: same dtypes pickle.loads(pickle.dumps(tiny)), ] # Computed anew from the values, not from digests a cube was given. assert {cube.verify_fingerprint() for cube in equal} == {tiny.fingerprint()} - assert equal[3].layer("counts").dtype == np.int64 + assert equal[3].layer("counts").dtype == tiny.layer("counts").dtype + # A merge sums in int64, which hashes alike. + merged = tiny.regroup({"both": ["type 0", "type 1"]}) + assert merged.layer("counts").dtype == np.int64 + assert merged.verify_fingerprint() == merged.fingerprint() assert equal[3].provenance != tiny.provenance @@ -608,7 +612,10 @@ def test_a_lone_surrogate_is_hashed_in_its_three_byte_form() -> None: def test_the_record_and_the_history_name_the_fingerprint(tiny: Cube) -> None: - assert tiny.history().splitlines()[-1] == f"Fingerprint: {tiny.fingerprint()}" + assert tiny.history().splitlines()[-2:] == [ + "Fingerprint:", + f" {tiny.fingerprint()}", + ] assert tiny.fingerprint() == tiny.digests()["fingerprint"] assert all( re.fullmatch(DIGEST, digest) diff --git a/tests/test_deseq2.py b/tests/test_deseq2.py index eed8448..1b7061d 100644 --- a/tests/test_deseq2.py +++ b/tests/test_deseq2.py @@ -349,6 +349,44 @@ def test_tests_match_deseq2(case: str, index: int) -> None: ) +def test_the_table_holds_the_columns_of_deseq2s_results() -> None: + case = CASES[0] + kind, value = json.loads(str(fixture(case)["tests"]))[0] + assert kind == "wald" + result = deseq2_wald_test(fitted(case), np.array(value)) + n_genes = result.p_value.size + ids = [f"gene{j}" for j in range(n_genes)] + table = result.table(feature_ids=ids) + assert table.columns == ( + "feature_id", + "base_mean", + "log2_fold_change", + "standard_error", + "statistic", + "p_value", + "adjusted_p_value", + ) + assert table["feature_id"].tolist() == ids + # Each column is DESeq2's, in the order of the genes, within its stopping error. + tight = { + k: reference(case, f"tight1_{k}") + for k in ("baseMean", "log2FoldChange", "lfcSE", "stat", "pvalue", "padj") + } + assert_allclose(table["base_mean"], tight["baseMean"], rtol=1e-13) + assert relative(table["log2_fold_change"], tight["log2FoldChange"], 1.0) < 1e-5 + assert relative(table["standard_error"], tight["lfcSE"]) < 1e-5 + assert relative(table["statistic"], tight["stat"], 1.0) < 1e-5 + assert log_relative(table["p_value"], tight["pvalue"]) < 1e-5 + assert log_relative(table["adjusted_p_value"], tight["padj"]) < 1e-5 + assert_array_equal(np.isnan(table["adjusted_p_value"]), np.isnan(tight["padj"])) + default = result.table() + assert default["feature_id"].tolist() == [f"feature_{j}" for j in range(n_genes)] + with pytest.raises(ValueError, match=rf"one id per feature \({n_genes}\), got"): + result.table(feature_ids=["a", "b"]) + with pytest.raises(TypeError, match="feature_ids must hold text ids, got int 0"): + result.table(feature_ids=list(range(n_genes))) + + @pytest.mark.parametrize("case", CASES) def test_results_options_match_deseq2(case: str) -> None: fit, contrast = fitted(case), wald_contrast(case) diff --git a/tests/test_design.py b/tests/test_design.py index 0d8f60a..ab4eed6 100644 --- a/tests/test_design.py +++ b/tests/test_design.py @@ -51,6 +51,35 @@ def test_design_holds_matrix_columns_terms_and_levels(samples: dict[str, Any]) - ] +def test_long_formulas_and_names_print_in_lines_of_80_characters() -> None: + samples = { + "sample_id": [f"S{i}" for i in range(8)], + "condition": ["a", "b"] * 4, + "age": [31.0, 35, 38, 42, 47, 51, 56, 60], + "library_preparation_batch": ["x", "y", "z", "w"] * 2, + } + formula = "~ condition + age + library_preparation_batch + condition:age" + design = Design( + samples, + formula, + contrasts={"b_versus_a_at_the_mean_age_of_the_donors": "conditionb"}, + ) + for text in (repr(design), repr(design.model_matrix), repr(design.contrasts)): + assert max(map(len, text.splitlines())) <= 80 + # Every column name is printed whole, on one line. + for text in (repr(design), repr(design.model_matrix)): + words = set(" ".join(text.splitlines()).replace(",", " ").split()) + assert set(design.columns) <= words + lines = repr(design).splitlines() + assert " ".join(" ".join(lines).split()).startswith( + f"Design: 8 samples x 7 columns, formula '{formula}'" + ) + # A continuation lines up under the text after its key. + columns = [line for line in lines if line.startswith(" columns: ")][0] + following = lines[lines.index(columns) + 1] + assert following.startswith(" " * len(" columns: ")) and following.strip() + + def test_random_effects_are_parsed_and_their_columns_validated( samples: dict[str, Any], ) -> None: diff --git a/tests/test_design_checks.py b/tests/test_design_checks.py index 2eb14c8..432ea3a 100644 --- a/tests/test_design_checks.py +++ b/tests/test_design_checks.py @@ -248,6 +248,43 @@ def test_numeric_columns_that_look_like_group_labels() -> None: assert Design(samples, "~ age + hours + dose").check().warnings == () +def test_numeric_ids_that_are_not_consecutive() -> None: + # Kang's donors 101, 107 and 1015, each in both conditions. + samples = { + "donor": [101, 101, 107, 107, 1015, 1015], + "condition": ["ctrl", "stim"] * 3, + } + report = Design(samples, "~ donor + condition").check() + assert report.kinds() == ("numeric_ids",) + assert report.warnings[0].message.startswith( + "donor holds whole numbers (3 distinct values, from 101 to 1015), each " + "shared by several samples, and its name says they are ids" + ) + assert "convert the column to text" in report.warnings[0].message + # The names that say ids: by their last word, or a number after an id word. + for name in ("patient_id", "subjectID", "Batches", "plate2", "run_number", "id"): + renamed = {name: samples["donor"], "condition": samples["condition"]} + found = Design(renamed, f"~ {name} + condition").check() + assert found.kinds() == ("numeric_ids",), name + # Not ids: names of measurements and counts, the same numbers in a column whose + # name says nothing of ids, a sample of its own per value, too few values, + # values that are not whole, and consecutive codes (numeric_codes warns). + others = { + "hours": [0, 0, 6, 6, 24, 24], + "donor_age": [31, 31, 47, 47, 52, 52], + "n_donors": [3, 3, 5, 5, 9, 9], + "dose": [101, 101, 107, 107, 1015, 1015], + "batch": [3, 7, 12, 3, 7, 13], + "plate": [10, 10, 30, 30, 10, 30], + "lane": [1.5, 1.5, 2.5, 2.5, 4.5, 4.5], + "run": [4, 4, 5, 5, 6, 6], + } + for name, values in others.items(): + table = {name: values, "condition": samples["condition"]} + kinds = Design(table, f"~ {name} + condition").check().kinds() + assert "numeric_ids" not in kinds, name + + def test_duplicate_column_names_are_reported_not_raised() -> None: # a = "bX" and ab = "X" both give a column named abX. samples = {"a": ["bX", "c", "d", "c"], "ab": ["X", "Y", "Y", "X"]} @@ -278,9 +315,11 @@ def test_random_effect_checks() -> None: assert "random_confounded" in report.kinds() report = Design(samples, "~ condition", random="(1 | sample_id)").check() assert report.kinds() == ("random_unreplicated",) - assert "every group of the random effect (1 | sample_id) has a single" in str( - report + text = str(report) + assert "every group of the random effect (1 | sample_id) has a single" in " ".join( + text.split() ) + assert max(map(len, text.splitlines())) <= 80 report = Design(samples, "~ condition", random="(1 | site)").check() assert report.kinds() == ("random_single_group",) # A slope per donor is absorbed when the fixed effects have one per donor. @@ -298,10 +337,11 @@ def test_a_clean_design_reports_nothing() -> None: } report = Design(samples, "~ donor + condition", contrasts=["conditionstim"]).check() assert report.ok and report.errors == () and report.warnings == () - assert str(report) == ( - "Design check: 8 samples, 5 columns, rank 5, 3 residual degrees of freedom; " - "no problems found." - ) + # In lines of at most 80 characters. + assert str(report).splitlines() == [ + "Design check: 8 samples, 5 columns, rank 5, 3 residual degrees of freedom; no", + " problems found.", + ] def test_report_text_lists_errors_then_warnings(nested_batches: dict[str, Any]) -> None: diff --git a/tests/test_differential_expression.py b/tests/test_differential_expression.py index a3439a7..e4cb6d7 100644 --- a/tests/test_differential_expression.py +++ b/tests/test_differential_expression.py @@ -15,6 +15,7 @@ import json import pickle +import re from functools import cache from pathlib import Path from typing import Any @@ -24,14 +25,16 @@ import pytest from cytepool.cube import Cube, from_bulk, from_cells -from cytepool.design import Design +from cytepool.design import Contrasts, Design from cytepool.differential_expression import ( DifferentialExpressionResult, + dream_voom, limma_trend, limma_voom, ) from cytepool.io import read_cube, write_cube from cytepool.io.zarr import ZarrArray +from cytepool.normalization import filter_by_expression from cytepool.table import Table DATA = Path(__file__).parent / "data" / "differential_expression" @@ -536,6 +539,81 @@ def test_a_filter_that_keeps_everything_equals_no_filter() -> None: assert unfiltered.settings["expression_filter"] is None +def genes_tested(result: DifferentialExpressionResult) -> dict[str, list[str]]: + """The features each fitted group tested.""" + fitted = result.summary.filter(status="fitted")["group_id"].tolist() + name = result.contrasts.names[0] + return {group: result.table(group, name)["feature_id"].tolist() for group in fitted} + + +def test_a_filter_by_sample_groups_is_filter_by_expression_with_their_labels() -> None: + cube = cells_cube() + design = paired_design(cube.samples) + by_condition = {"sample_groups": "condition", "min_count": 5} + result = limma_voom(cube, design, expression_filter=by_condition) + assert result.settings["expression_filter"] == { + "min_count": 5.0, + "min_total_count": 15.0, + "large_n": 10.0, + "min_prop": 0.7, + "sample_groups": "condition", + } + features = cube.features["feature_id"] + sample_ids = cube.samples["sample_id"].tolist() + found = genes_tested(result) + assert found + for group, genes in found.items(): + used = result.samples.filter(group_id=group, used=True)["sample_id"].tolist() + rows = [sample_ids.index(sample) for sample in used] + keep = filter_by_expression( + cube.layer("counts", group)[rows], + group=cube.samples["condition"][rows], + min_count=5, + ) + assert genes == features[keep].tolist(), group + # dream with the donors as a random effect tests the same genes, which the + # filter by its design (the conditions alone) would not. + random = Design( + cube.samples, + "~ condition", + random="(1 | donor)", + levels={"condition": ["ctrl", "stim"]}, + contrasts={"stim_vs_ctrl": "conditionstim"}, + ) + dream = dream_voom(cube, random, expression_filter=by_condition) + assert genes_tested(dream) == found + trend = limma_trend(cube, design, expression_filter=by_condition) + assert genes_tested(trend) == found + + +@pytest.mark.parametrize( + ("setting", "error", "message"), + [ + ({"sample_groups": "site"}, KeyError, "names 'site', which is not a column"), + ({"sample_groups": 3}, TypeError, "must name a column of the samples (str)"), + ({"groups": "condition"}, ValueError, "the settings are min_count"), + ], +) +def test_invalid_sample_groups_are_refused( + setting: dict[str, Any], error: type, message: str +) -> None: + cube = cells_cube() + with pytest.raises(error, match=re.escape(message)): + limma_voom(cube, paired_design(cube.samples), expression_filter=setting) + + +def test_sample_groups_must_name_a_group_for_every_sample() -> None: + cube = cells_cube() + labels = cube.samples["condition"].tolist() + labels[1] = None + samples = cube.samples.with_columns({"batch": labels}) + design = paired_design(samples) + with pytest.raises( + ValueError, match="which is missing for sample 'D1_stim'; every" + ): + limma_voom(cube, design, expression_filter={"sample_groups": "batch"}) + + def test_without_normalization_factors_they_are_one() -> None: cube = cells_cube() result = limma_trend(cube, paired_design(cube.samples), normalization=None) @@ -679,6 +757,40 @@ def test_the_result_is_immutable_and_survives_pickling() -> None: assert "not estimable: D2_vs_D1" in repr(result) +def test_the_repr_fits_80_characters_and_separates_thousands() -> None: + result = voom_result() + groups = len(result.summary) + # A summary of large groups, and contrasts whose names run past one line. + summary = result.summary.with_columns( + { + "n_samples_used": np.full(groups, 1_204), + "n_features_tested": np.full(groups, 15_031), + } + ) + names = [f"stimulated_{k}_versus_the_controls_of_donor_{k}" for k in range(4)] + contrasts = Contrasts( + np.tile(result.contrasts.matrix[:, :1], (1, 4)), + tuple(names), + result.contrasts.columns, + ) + large = DifferentialExpressionResult( + result.method, + contrasts, + summary, + result.samples, + {}, + result.provenance, + ) + lines = repr(large).splitlines() + assert max(map(len, lines)) <= 80 + text = " ".join(" ".join(lines).split()) + assert f"{groups} groups" in text and ", ".join(names) in text + assert "1,204 samples, 15,031 features" in text + # The first line continues four spaces in, deeper than the lines of the groups. + assert lines[1] == " stimulated_0_versus_the_controls_of_donor_0," + assert lines[-1] == " T: 1,204 samples, 15,031 features" + + def test_a_result_holds_checked_objects_and_a_json_record() -> None: result = voom_result() parts = { diff --git a/tests/test_documentation.py b/tests/test_documentation.py index 3dd81ba..2900443 100644 --- a/tests/test_documentation.py +++ b/tests/test_documentation.py @@ -652,6 +652,10 @@ def test_link_check_finds_broken_links() -> None: "cytepool.io._files": "names local files and notices their changes with the " "standard library", "cytepool.stats": "the package's namespace; its modules cite their sources", + "cytepool.stats._result_tables": "lays out the tests of fits in the columns of " + "CytePool's own result tables", + "cytepool.study_results": "runs CytePool's analyses of a cube on every study of " + "a collection and keeps their results together", "cytepool.table": "CytePool's own table of named, equal-length columns", } # An entry: "Authors (year). Title. Journal Volume, pages. doi:10....". diff --git a/tests/test_gene_sets.py b/tests/test_gene_sets.py index 34aa6b3..afe3610 100644 --- a/tests/test_gene_sets.py +++ b/tests/test_gene_sets.py @@ -395,6 +395,7 @@ def test_the_repr_says_what_the_collection_holds_and_where_it_comes_from() -> No f"{len({g for genes in sets.values() for g in genes}):,} genes in all" ) assert "source: simulated MSigDB; version: not stated; licence: not stated" in text - assert f"read from msigdb.gmt, SHA-256 {sets.sha256}" in text + assert f"read from msigdb.gmt, SHA-256 {sets.sha256}" in " ".join(text.split()) + assert max(map(len, text.splitlines())) <= 80 assert "and 3 more" in text assert repr(GeneSets({"A": ["G1"]})).startswith("GeneSets: 1 set of 1 gene,") diff --git a/tests/test_gsea.py b/tests/test_gsea.py index 7d56328..7e2698d 100644 --- a/tests/test_gsea.py +++ b/tests/test_gsea.py @@ -495,6 +495,43 @@ def test_warnings_about_ties_positive_statistics_and_p_values() -> None: assert floored.any() and np.all(np.isnan(table["log2_error"][floored])) +def test_more_permutations_are_suggested_only_where_they_can_help() -> None: + # Statistics of one sign but for the last three genes, the largest far above + # the others: random sets of 40 genes almost never score below zero, while + # some of those of 12 genes do. + rng = np.random.default_rng(5) + values = np.sort(np.exp(2.5 * rng.normal(size=500)))[::-1] + 0.01 + values[-3:] = [-0.01, -0.02, -0.03] + genes = [f"g{j}" for j in range(500)] + statistics = dict(zip(genes, values, strict=True)) + sets = {"twelve": genes[-12:], "forty": genes[-40:], "top": genes[:15]} + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + table = gsea(statistics, sets, rng=1) + messages = [" ".join(str(w.message).split()) for w in caught] + assert messages == [ + "1 gene set(s) have fewer than 10 random scores of the sign of their " + "enrichment score among 1000 permutations, but some; their normalized " + "scores and p-values are NaN. More permutations (n_permutations=10000) may " + "give them enough", + "1 gene set(s) have no random score of the sign of their enrichment score " + "among 1000 permutations: random sets of their size almost always score " + "with the other sign, because most statistics share one sign, so more " + "permutations are unlikely to give them any; their normalized scores and " + "p-values are NaN", + ] + assert all(len(line) <= 80 for w in caught for line in str(w.message).split("\n")) + assert np.isnan(table["p_value"][:2]).all() and table["p_value"][2] < 1e-20 + # Ten times the permutations give the set of 12 genes enough, and not the other. + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + bottom = {name: sets[name] for name in ("twelve", "forty")} + more = gsea(statistics, bottom, rng=1, n_permutations=10_000) + assert np.isfinite(more["p_value"][0]) and np.isnan(more["p_value"][1]) + assert any("have no random score" in str(w.message) for w in caught) + assert not any("fewer than 10 random" in str(w.message) for w in caught) + + # Messages. diff --git a/tests/test_held_out_prediction.py b/tests/test_held_out_prediction.py index 995108c..49bc6fa 100644 --- a/tests/test_held_out_prediction.py +++ b/tests/test_held_out_prediction.py @@ -273,6 +273,7 @@ def test_the_result_is_a_record_that_cannot_change() -> None: copy = pickle.loads(pickle.dumps(found)) assert copy.auc.equals(found.auc) and copy.genes.equals(found.genes) assert "sumrank: mean AUC" in repr(found) + assert max(map(len, repr(found).splitlines())) <= 80 with pytest.raises(TypeError, match="genes must be a Table"): HeldOutPrediction(found.auc, found.scores, {}, {}) # type: ignore[arg-type] diff --git a/tests/test_masked_inputs.py b/tests/test_masked_inputs.py index f710d68..8d58aca 100644 --- a/tests/test_masked_inputs.py +++ b/tests/test_masked_inputs.py @@ -49,7 +49,7 @@ from cytepool.composition import propeller from cytepool.cube import Cube, CubeCollection, from_bulk, from_cells from cytepool.design import Design, make_contrasts -from cytepool.differential_expression import limma_voom +from cytepool.differential_expression import dream_voom, limma_voom from cytepool.gene_sets import GeneSets from cytepool.gsea import gsea from cytepool.held_out_prediction import held_out_prediction @@ -62,7 +62,7 @@ from cytepool.pathway_scores import gsva from cytepool.replication import differential_expression_replication from cytepool.stats import distributions, special -from cytepool.stats.deseq2 import deseq2_dispersions, fit_deseq2 +from cytepool.stats.deseq2 import deseq2_dispersions, deseq2_wald_test, fit_deseq2 from cytepool.stats.distributions import norm_cdf, t_sf_scalar from cytepool.stats.empirical_bayes import moderated_statistics, squeeze_variances from cytepool.stats.gene_set_tests import camera @@ -71,6 +71,7 @@ from cytepool.stats.multiple_testing import adjust_p_values from cytepool.stats.quasi_likelihood import fit_quasi_likelihood from cytepool.stats.smoothing import lowess +from cytepool.stats.quasi_likelihood import quasi_likelihood_f_test from cytepool.stats.voom import voom, voom_with_quality_weights from cytepool.sumrank import differential_expression_sumrank from cytepool.table import Table @@ -242,6 +243,7 @@ def _collection_arguments(context: Context) -> dict[str, Any]: "cubes": {"A": cube, "B": cube}, "align_groups_by": "group_id", "group_mapping": {"B": {"T": "T"}}, + "group_names": {"T": "T cells"}, "within_study": ["donor"], } @@ -626,8 +628,11 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "cytepool.table.Table.take": Entry( lambda c: {"indices": [1, 0]}, {"indices": None}, instance=lambda c: TABLE ), + # A column named by its keyword takes one value, which a masked array is not. "cytepool.table.Table.filter": Entry( - lambda c: {"mask": [True, False]}, {"mask": None}, instance=lambda c: TABLE + lambda c: {"mask": [True, False], "x": 1.0}, + {"mask": None, "x": None}, + instance=lambda c: TABLE, ), "cytepool.table.Table.select": Entry( lambda c: {"names": ["s", "x"]}, {"names": None}, instance=lambda c: TABLE @@ -687,6 +692,20 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: {"samples": None, "groups": None, "features": None}, instance=lambda c: c.cube, ), + # The mapping of each axis is read column by column, as a table reads it. + "cytepool.cube.cube.Cube.with_columns": Entry( + lambda c: { + "samples": {"pool": ["a", "a"]}, + "groups": {"kind": ["x", None]}, + "features": {"length": [1.0, 2.0, np.nan]}, + }, + {"samples": "None or NaN", "groups": "None or NaN", "features": "None or NaN"}, + instance=lambda c: c.cube, + keys={"samples": "pool", "groups": "kind", "features": "length"}, + ), + "cytepool.cube.cube.Cube.collapse_samples": Entry( + lambda c: {"by": ["sample_id"]}, {"by": None}, instance=lambda c: c.cube + ), "cytepool.cube.cube.Cube.regroup": Entry( lambda c: {"mapping": {"all": ["B", "T"]}}, {"mapping": None}, @@ -697,10 +716,10 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: # groups and the column names are read value by value. "cytepool.cube.collection.CubeCollection": Entry( _collection_arguments, - {"group_mapping": None, "within_study": None}, + {"group_mapping": None, "group_names": None, "within_study": None}, options=("align_groups_by",), objects=("cubes",), - keys={"group_mapping": "B"}, + keys={"group_mapping": "B", "group_names": "T"}, ), "cytepool.cube.collection.CubeCollection.select": Entry( lambda c: {"studies": ["B"], "groups": [True, False], "features": [2, 0]}, @@ -1328,6 +1347,25 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: lambda c: {"means": COUNTS + 1.0, "dispersion": 0.1}, {"means": None, "dispersion": None}, ), + # Tables of the tests of fits on arrays: one id per gene. + "cytepool.stats.empirical_bayes.ModeratedFit.table": Entry( + lambda c: {"coefficient": "second", "feature_ids": [f"g{j}" for j in range(8)]}, + {"feature_ids": None}, + options=("coefficient",), + instance=lambda c: moderated_statistics(c.contrast_fit), + ), + "cytepool.stats.quasi_likelihood.QuasiLikelihoodTest.table": Entry( + lambda c: {"feature_ids": [f"g{j}" for j in range(8)]}, + {"feature_ids": None}, + instance=lambda c: quasi_likelihood_f_test( + fit_quasi_likelihood(COUNTS, DESIGN, dispersion=0.1), coefficients=[1] + ), + ), + "cytepool.stats.deseq2.DESeq2Results.table": Entry( + lambda c: {"feature_ids": [f"g{j}" for j in range(8)]}, + {"feature_ids": None}, + instance=lambda c: deseq2_wald_test(_deseq2_fit(), [0.0, 1.0]), + ), "cytepool.stats.quasi_likelihood.quasi_likelihood_f_test": Entry( lambda c: { "fit": fit_quasi_likelihood(COUNTS, DESIGN, dispersion=0.1), @@ -2147,10 +2185,12 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "samples": ["S1", "S2"], "standard_scale": "gene", "mean_only_expressed": True, + "vmin": 0.0, + "vmax": 2.0, "ax": _axes(), }, {"genes": None, "groups": None, "samples": None}, - options=("standard_scale", "mean_only_expressed"), + options=("standard_scale", "mean_only_expressed", "vmin", "vmax"), objects=("cube", "ax"), ), "cytepool.plotting.plot_cell_numbers": Entry( @@ -2190,11 +2230,22 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: {}, objects=("result", "ax"), ), + # A group of a differential-expression result, by id. + "cytepool.plotting.plot_mean_variance[result]": Entry( + lambda c: {"result": _tested(c), "group": "bulk", "ax": _axes()}, + {}, + options=("group",), + ), "cytepool.plotting.plot_residual_variances": Entry( lambda c: {"fit": moderated_statistics(c.fit), "ax": _axes()}, {}, objects=("fit", "ax"), ), + "cytepool.plotting.plot_residual_variances[result]": Entry( + lambda c: {"fit": _tested(c), "group": "bulk", "ax": _axes()}, + {}, + options=("group",), + ), "cytepool.plotting.plot_sample_weights": Entry( lambda c: { "weights": [1.0, 0.5, 2.0, 1.0], @@ -2511,6 +2562,51 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: options=("group", "sort"), objects=("data", "ax"), ), + # Scores of samples tested with a design: an array of values, with one id per + # column and per row, weights per sample and a covariate of the trend. + "cytepool.score_tests.limma": Entry( + lambda c: { + "data": log_cpm(COUNTS), + "design": Design( + SAMPLE_TABLE, + "~ condition", + levels=LEVELS, + contrasts={"stim": [0.0, 1.0]}, + ), + "contrast": "stim", + "feature_ids": [f"g{j}" for j in range(COUNTS.shape[1])], + "sample_ids": SAMPLE_TABLE["sample_id"], + "weights": [1.0, 2.0, 1.0, 2.0], + "trend": np.arange(COUNTS.shape[1], dtype=float), + "robust": False, + }, + { + "data": "NaN", + "feature_ids": None, + "sample_ids": None, + "weights": None, + "trend": "NaN", + }, + options=("contrast", "robust"), + objects=("design",), + ), + # Every study of a collection analysed alike: the design's parts, as Design reads + # them, and the analysis's options, as dream_voom reads them. + "cytepool.study_results.analyse_each_study": Entry( + lambda c: { + "collection": _studies()[0], + "formula": "~ condition", + "analysis": dream_voom, + "random": ["(1 | donor)"], + "levels": LEVELS, + "contrasts": {"stim": [0.0, 1.0]}, + "groups": ["bulk"], + }, + {"random": None, "levels": None, "contrasts": None, "groups": None}, + options=("formula",), + objects=("collection", "analysis"), + keys={"levels": "condition", "contrasts": "stim"}, + ), # Variance partitioning: a mixed model, a linear model, and every group of a cube. "cytepool.variance_partitioning.variance_fractions": Entry( lambda c: { @@ -2564,7 +2660,6 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "cytepool.table.Table.__contains__": (("name",), "a column name, looked up"), "cytepool.table.Table.equals": (("other",), "a table, compared as it is"), "cytepool.table.Table.rename": (("mapping",), "column names, which are str"), - "cytepool.cube.cube.Cube.collapse_samples": (("by",), "a column name, a str"), "cytepool.cube.collection.CubeCollection.aligned_cube": ( ("study",), "a study name, looked up", @@ -2584,8 +2679,8 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "a Cube, whose arrays were checked when it was built, a path and options", ), "cytepool.io.anndata.to_anndata": ( - ("cube",), - "a Cube, whose arrays were checked when it was built", + ("cube", "x_layer"), + "a Cube, whose arrays were checked when it was built, and a layer name", ), "cytepool.io.anndata.to_mudata": ( ("cube",), @@ -2607,9 +2702,42 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "a path, and attributes written as JSON, which cannot hold an array", ), "cytepool.differential_expression.DifferentialExpressionResult": ( - ("method", "contrasts", "summary", "samples", "tables", "provenance"), - "a method name, Contrasts and Tables, which were checked when they were " - "built, and a record kept as JSON, which cannot hold an array", + ( + "method", + "contrasts", + "summary", + "samples", + "tables", + "provenance", + "cube", + "design", + ), + "a method name, Contrasts, Tables, a Cube and a Design, which were checked " + "when they were built, and a record kept as JSON, which cannot hold an array", + ), + "cytepool.differential_expression.DifferentialExpressionResult.fit": ( + ("group",), + "a group id, looked up", + ), + "cytepool.table.Table.sort": ( + ("by", "descending"), + "a column name, looked up, and a flag", + ), + "cytepool.study_results.StudyResults": ( + ("collection", "results"), + "a CubeCollection and results, which were checked when they were built", + ), + "cytepool.study_results.StudyResults.__getitem__": ( + ("study",), + "a study name, looked up", + ), + "cytepool.study_results.StudyResults.table": ( + ("group", "contrast"), + "a group id and a contrast name, looked up", + ), + "cytepool.study_results.StudyResults.matrix": ( + ("column", "group", "contrast"), + "a column name, a group id and a contrast name, looked up", ), "cytepool.differential_expression.DifferentialExpressionResult.table": ( ("group", "contrast"), @@ -2718,6 +2846,7 @@ def _held_out_arguments(context: Context) -> dict[str, Any]: "cytepool.stats.quasi_likelihood.QuasiLikelihoodTest", "cytepool.stats.quasi_likelihood.UnitDevianceMoments", "cytepool.variance_partitioning.VarianceFractions", + "cytepool.differential_expression.GroupFit", "cytepool.pathway_scores.PathwayScores", "cytepool.activity.Activities", } diff --git a/tests/test_meta_analysis.py b/tests/test_meta_analysis.py index 2d3970a..e702005 100644 --- a/tests/test_meta_analysis.py +++ b/tests/test_meta_analysis.py @@ -603,6 +603,12 @@ def test_studies_left_out_and_features_tested_by_too_few() -> None: assert nk["reason"][0] == "1 of the 3 studies tested it, fewer than min_studies (2)" with pytest.raises(KeyError, match="were not meta-analysed: 1 of the 3 studies"): meta.table("NK", "stim_vs_ctrl") + # One contrast: only the group is needed; several groups must be named. + assert meta.table("T").equals(meta.table("T", "stim_vs_ctrl")) + with pytest.raises( + ValueError, match="the result has 3 groups; name one with group" + ): + meta.table() studies = meta.studies.filter(meta.studies["group_id"] == "NK") assert studies["study"].tolist() == ["A", "B", "C"] assert studies["tested"].tolist() == [True, False, False] @@ -687,10 +693,11 @@ def test_the_result_records_its_studies_and_settings() -> None: copy = pickle.loads(pickle.dumps(meta)) assert copy.provenance == record assert all(copy.tables[key].equals(table) for key, table in meta.tables.items()) - assert repr(meta).splitlines()[0] == ( - "MetaAnalysisResult (pm, test knapp_hartung): 3 studies; 3 group and contrast " - "pairs, 2 analysed" - ) + # In lines of at most 80 characters. + assert repr(meta).splitlines()[:2] == [ + "MetaAnalysisResult (pm, test knapp_hartung): 3 studies; 3 group and contrast", + " pairs, 2 analysed", + ] def renamed(result: DifferentialExpressionResult, prefix: str, **changes: Any) -> Any: diff --git a/tests/test_networks.py b/tests/test_networks.py index c5966e8..9530d99 100644 --- a/tests/test_networks.py +++ b/tests/test_networks.py @@ -310,6 +310,52 @@ def test_a_network_selects_records_and_pickles() -> None: network.select(["X"]) +def _as_written_in_the_guides(network: Network) -> GeneSets: + return GeneSets( + {source: list(targets) for source, targets in network.items()}, + source=network.name, + version=network.version, + licence=network.licence, + file=network.file, + sha256=network.sha256, + ) + + +def _same_sets(ours: GeneSets, expected: GeneSets) -> None: + assert list(ours) == list(expected) + for name in expected: + assert ours[name] == expected[name] + for attribute in ("source", "version", "licence", "file", "sha256"): + assert getattr(ours, attribute) == getattr(expected, attribute), attribute + + +def test_a_network_as_gene_sets_drops_the_weights_and_keeps_the_record( + cache: Path, +) -> None: + network = Network(EDGES, name="mine", version="1", licence="CC0") + sets = network.to_gene_sets() + # Each source's targets in the order of its edges, repressed ones included. + assert dict(sets.items()) == { + "STAT1": ("IRF1", "SOCS1", "MYC"), + "IRF1": ("CXCL10", "MYC"), + } + _same_sets(sets, _as_written_in_the_guides(network)) + assert (sets.source, sets.version, sets.licence) == ("mine", "1", "CC0") + # Back to a network, every target weighs 1. + again = Network(sets) + assert again.edges.select(["source", "target"]).equals( + network.edges.select(["source", "target"]) + ) + assert again.edges["weight"].tolist() == [1.0] * 5 + # A loaded network keeps its file and digest. + _place(cache, "collectri", ROWS) + academic = collectri(licence="academic", cache_dir=cache) + regulons = academic.to_gene_sets() + _same_sets(regulons, _as_written_in_the_guides(academic)) + assert regulons.sha256 == academic.sha256 is not None + assert len(regulons) == len(academic.sources) + + def test_network_messages() -> None: with pytest.raises(ValueError, match="from 'A' to 'B' is given twice"): Network({"source": ["A", "A"], "target": ["B", "B"], "weight": [1.0, 2.0]}) diff --git a/tests/test_pathway_scores.py b/tests/test_pathway_scores.py index a070492..8de94e6 100644 --- a/tests/test_pathway_scores.py +++ b/tests/test_pathway_scores.py @@ -7,15 +7,19 @@ artists it draws. """ +import dataclasses import doctest import json import math +import pickle from pathlib import Path +from typing import Any import numpy as np import pytest from numpy.testing import assert_allclose, assert_array_equal +import cytepool from cytepool import pathway_scores from cytepool.cube import Cube from cytepool.design import Design @@ -31,6 +35,7 @@ from cytepool.plotting import plot_pathway_scores from cytepool.stats.empirical_bayes import moderated_statistics from cytepool.stats.linear_models import fit_linear_model +from cytepool.table import Table DATA = Path(__file__).parent / "data" / "pathway_scores" FIXTURE = json.loads((DATA / "gsva.json").read_text()) @@ -477,6 +482,25 @@ def test_a_cube_group_is_scored_as_its_log_cpm() -> None: assert as_counts.settings["kernel"] == "poisson" +def test_a_cube_group_filtered_by_sample_groups_keeps_the_genes_of_each_group() -> None: + cube, counts = _cube() + sets = { + "treated": [f"G{j}" for j in range(30)], + "other": [f"G{j}" for j in range(50, 90)], + } + by_condition = {"sample_groups": "condition"} + result = gsva(cube, sets, gene_ids="symbol", expression_filter=by_condition) + used = np.flatnonzero(np.arange(12) != 3) + kept = counts[used] + keep = filter_by_expression(kept, group=cube.samples["condition"][used]) + values = log_cpm(kept[:, keep], norm_factors=tmm_factors(kept[:, keep])) + symbols = [f"G{j}" for j in np.flatnonzero(keep)] + assert_array_equal(result.scores, gsva(values, sets, gene_ids=symbols).scores) + assert result.settings["expression_filter"]["sample_groups"] == "condition" + with pytest.raises(KeyError, match="names 'site', which is not a column"): + gsva(cube, sets, gene_ids="symbol", expression_filter={"sample_groups": "site"}) + + def test_scores_of_a_cube_go_into_a_linear_model() -> None: cube, _ = _cube() sets = { @@ -491,6 +515,61 @@ def test_scores_of_a_cube_go_into_a_linear_model() -> None: assert abs(moderated.t[1, 1]) < 3.0 +def assert_pickles(record: Any) -> None: + """A record comes back from pickle with equal fields, read-only arrays and + settings, and the same provenance, or none.""" + copy = pickle.loads(pickle.dumps(record)) + for field in dataclasses.fields(record): + mine, theirs = getattr(record, field.name), getattr(copy, field.name) + if isinstance(mine, np.ndarray): + assert_array_equal(theirs, mine) + assert theirs.dtype == mine.dtype and not theirs.flags.writeable + elif isinstance(mine, Table): + assert theirs.equals(mine) + elif field.name == "settings": + assert dict(theirs) == dict(mine) + with pytest.raises(TypeError): + theirs["x"] = 1 # type: ignore[index] + elif hasattr(mine, "edges"): # a Network + assert theirs.edges.equals(mine.edges) + elif hasattr(mine, "items"): # GeneSets + assert dict(theirs.items()) == dict(mine.items()) + else: + assert theirs == mine, field.name + assert copy.provenance == record.provenance + if record.provenance is None: + assert "_provenance" not in vars(copy) + + +def test_scores_of_a_cube_record_the_cube_they_read() -> None: + cube, counts = _cube() + sets = { + "treated": [f"G{j}" for j in range(30)], + "other": [f"G{j}" for j in range(50, 90)], + } + result = gsva(cube, sets, gene_ids="symbol") + record = result.provenance + assert record is not None + assert list(record) == ["method", "versions", "cube", "layer", "settings"] + assert record["method"] == "gsva" and record["layer"] == "counts" + assert record["cube"]["fingerprint"] == cube.fingerprint() + assert record["cube"]["provenance"] == cube.provenance + assert record["settings"] == result.settings + assert record["versions"]["cytepool"] == cytepool.__version__ + assert json.loads(json.dumps(record)) == record + record["method"] = "changed" # a new dict each time + assert result.provenance["method"] == "gsva" + assert repr(result) == "PathwayScores(method='gsva', n_samples=11, n_sets=2)" + # Scores of values given as an array name no cube. + values = log_cpm(counts[:4], norm_factors=tmm_factors(counts[:4])) + symbols = [f"G{j}" for j in range(counts.shape[1])] + of_values = gsva(values, sets, gene_ids=symbols) + assert of_values.provenance is None + # Both pickle, the provenance with them. + assert_pickles(result) + assert_pickles(of_values) + + # Messages. diff --git a/tests/test_pca_and_dot_plots.py b/tests/test_pca_and_dot_plots.py index 6efebc1..c7e8cd2 100644 --- a/tests/test_pca_and_dot_plots.py +++ b/tests/test_pca_and_dot_plots.py @@ -18,6 +18,7 @@ import importlib import json +import pickle from functools import cache from pathlib import Path from typing import Any @@ -157,6 +158,29 @@ def test_a_cube_group_is_prepared_as_edgeR_prepares_it_for_plotPCA() -> None: assert result.settings == {"group": "T", "min_cells": 10, "top": 500} +def test_components_of_a_cube_record_the_cube_they_read() -> None: + cube = pca_cube() + result = principal_components(cube) + record = result.provenance + assert record is not None + assert record["method"] == "principal_components" + assert record["cube"]["fingerprint"] == cube.fingerprint() + assert record["settings"] == result.settings + assert json.loads(json.dumps(record)) == record + of_values = principal_components(fixture("pca")["values"]) + assert of_values.provenance is None + # Both pickle, the provenance with them; the copy keeps none it did not have. + for found in (result, of_values): + copy = pickle.loads(pickle.dumps(found)) + for name in ("coordinates", "variance_explained", "loadings", "genes"): + assert_array_equal(getattr(copy, name), getattr(found, name)) + assert not getattr(copy, name).flags.writeable + assert copy.samples.equals(found.samples) + assert dict(copy.settings) == dict(found.settings) + assert copy.provenance == found.provenance + assert "_provenance" not in vars(pickle.loads(pickle.dumps(of_values))) + + def test_the_figure_draws_the_points_and_labels_of_plotPCA() -> None: data = fixture("pca") ax = plotting.plot_pca(data["values"], top=100, labels=True, ax=axes()) @@ -487,6 +511,36 @@ def test_scaled_means_run_from_zero_to_one() -> None: assert_array_equal(artists(ax, "dots")[0].get_array(), [0.0, 0.0]) +def test_colour_limits_put_dot_plots_on_one_scale() -> None: + cube = from_cells(**cells()) + genes = ["x0", "x3", "x7", "x11"] + plain = artists(plotting.plot_dotplot(cube, genes, ax=axes()), "dots")[0] + values = np.asarray(plain.get_array()) + # By default the colours run from the smallest value shown to the largest. + assert (plain.norm.vmin, plain.norm.vmax) == (values.min(), values.max()) + ax = plotting.plot_dotplot(cube, genes, vmin=0.0, vmax=3.0, ax=axes()) + dots = artists(ax, "dots")[0] + assert (dots.norm.vmin, dots.norm.vmax) == (0.0, 3.0) + assert_array_equal(dots.get_array(), values) # the values are those drawn before + assert ax.figure.axes[-1].get_ylim() == (0.0, 3.0) # the colour bar + # One limit given, the other is the value shown at that end. + upper = artists(plotting.plot_dotplot(cube, genes, vmax=3.0, ax=axes()), "dots")[0] + assert (upper.norm.vmin, upper.norm.vmax) == (values.min(), 3.0) + # Two plots of other groups: on one scale, a group's dots have the same colours. + shared, alone = [], [] + for chosen in (["B", "T"], ["T", "NK"]): + position = chosen.index("T") + for limits, found in (({"vmin": 0.0, "vmax": 3.0}, shared), ({}, alone)): + drawn = artists( + plotting.plot_dotplot(cube, genes, groups=chosen, ax=axes(), **limits), + "dots", + )[0] + rows = np.asarray(drawn.get_array()).reshape(2, len(genes)) + found.append(drawn.to_rgba(rows[position])) + assert_array_equal(shared[0], shared[1]) + assert not np.array_equal(alone[0], alone[1]) + + def test_dot_plots_refuse_what_they_cannot_draw() -> None: bulk = Cube( {"counts": np.ones((1, 2, 2), dtype=np.uint32)}, @@ -534,3 +588,11 @@ def test_dot_plots_refuse_what_they_cannot_draw() -> None: ) with pytest.raises(ValueError, match="the symbol 'G' names 2 genes"): plotting.plot_dotplot(twice, ["G"], ax=axes()) + with pytest.raises(ValueError, match=r"vmin \(3\) must be below vmax \(1\)"): + plotting.plot_dotplot(hand_cube(), ["a"], vmin=3, vmax=1, ax=axes()) + with pytest.raises(ValueError, match=r"the values shown run from 0\.6 to 1"): + plotting.plot_dotplot(hand_cube(), ["a", "b"], vmax=0.5, ax=axes()) + with pytest.raises(ValueError, match="vmin must be finite"): + plotting.plot_dotplot(hand_cube(), ["a"], vmin=np.nan, ax=axes()) + with pytest.raises(TypeError, match="vmax must be a real number"): + plotting.plot_dotplot(hand_cube(), ["a"], vmax="high", ax=axes()) diff --git a/tests/test_plotting.py b/tests/test_plotting.py index d08372e..c2916af 100644 --- a/tests/test_plotting.py +++ b/tests/test_plotting.py @@ -20,6 +20,7 @@ """ import ast +import io from dataclasses import replace from functools import cache from pathlib import Path @@ -33,7 +34,7 @@ from cytepool.composition import propeller from cytepool.cube import Cube, from_bulk from cytepool.design import Design -from cytepool.differential_expression import limma_voom +from cytepool.differential_expression import DifferentialExpressionResult, limma_voom from cytepool.meta_analysis import differential_expression_meta_analysis from cytepool.normalization import log_cpm from cytepool.stats.deseq2 import deseq2_wald_test, fit_deseq2 @@ -112,6 +113,10 @@ def counts() -> np.ndarray: return fixture("limma")["counts"] +def counts_fixture() -> np.ndarray: + return counts() + + @cache def table() -> Table: cube = from_bulk(counts(), samples=SAMPLES, features=GENES) @@ -464,6 +469,143 @@ def test_mds_colours_and_markers_follow_the_sample_variables() -> None: assert np.min(np.hypot(*(drawn - position).T)) == 0.0 +def legend_place(ax: Any) -> str: + """Where the legend is drawn: "inside" the plot, "right" of it, or "across".""" + backend = pytest.importorskip("matplotlib.backends.backend_agg") + backend.FigureCanvasAgg(ax.figure).draw() + frame = ax.get_window_extent() + box = ax.get_legend().get_window_extent() + if frame.x0 <= box.x0 and box.x1 <= frame.x1 and frame.y0 <= box.y0: + return "inside" if box.y1 <= frame.y1 else "across" + return "right" if box.x0 >= frame.x1 else "across" + + +def covered(ax: Any) -> list[str]: + """What a legend inside a plot covers: the points, line vertices and labels of + the plot that lie within it, once the figure is drawn.""" + backend = pytest.importorskip("matplotlib.backends.backend_agg") + canvas = backend.FigureCanvasAgg(ax.figure) + canvas.draw() + box = ax.get_legend().get_window_extent() + found = [] + for collection in ax.collections: + xy = collection.get_offset_transform().transform(collection.get_offsets()) + if any(box.contains(x, y) for x, y in xy): + found.append(f"a point of {collection.get_gid()}") + for line in ax.lines: + xy = line.get_transform().transform(line.get_xydata()) + if any(box.contains(x, y) for x, y in xy): + found.append(f"the line {line.get_gid()}") + renderer = canvas.get_renderer() + for text in ax.texts: + if text.get_text() and text.get_window_extent(renderer).overlaps(box): + found.append(f"the label {text.get_text()}") + return found + + +def test_a_legend_inside_a_plot_covers_nothing_and_a_long_one_goes_beside() -> None: + cube = Cube( + {"counts": counts()[np.newaxis].astype(np.uint32)}, + samples={**SAMPLES, "donor": ["D1", "D2", "D3", "D4"] * 2}, + groups={"group_id": ["bulk"]}, + features={"feature_id": GENES}, + ) + values = log_cpm(counts()) + scatter = { + "md": plotting.plot_md(table(), ax=axes()), + "volcano": plotting.plot_volcano(table(), ax=axes()), + "mean-variance": plotting.plot_mean_variance( + voom(counts(), design()), ax=axes() + ), + "residual variances": plotting.plot_residual_variances( + moderated_statistics(fit_linear_model(values, design())), ax=axes() + ), + "dispersions": plotting.plot_dispersions( + fit_deseq2(counts(), design()).dispersion_estimates, ax=axes() + ), + "quasi-dispersions": plotting.plot_quasi_dispersions( + fit_quasi_likelihood(counts(), design()), ax=axes() + ), + "mds": plotting.plot_mds(cube, color_by="condition", ax=axes()), + "pca": plotting.plot_pca(cube, color_by="condition", labels=True, ax=axes()), + } + for name, ax in scatter.items(): + place = legend_place(ax) + # A legend of a few entries goes inside where it covers nothing, else beside. + assert place in ("inside", "right"), name + if place == "inside": + assert covered(ax) == [], name + assert legend_place(scatter["md"]) == "inside" + # Condition and donor make a legend of 7 entries, too long to sit inside. + styled = plotting.plot_mds(cube, color_by="condition", marker_by="donor", ax=axes()) + assert legend_place(styled) == "right" + result = limma_voom(bulk_cube(np.full((8, 1), 50)), design()) + bars = plotting.plot_significant_genes(result, ax=axes()) + assert legend_place(bars) == "right" + + +def test_a_legend_goes_inside_only_where_a_place_covers_nothing() -> None: + handles = [plotting._key("one", color="C0"), plotting._key("two", color="C1")] + # Points over the whole plot: every place inside would cover some. + ax = axes() + a, b = np.meshgrid(np.linspace(0.0, 1.0, 30), np.linspace(0.0, 1.0, 30)) + ax.scatter(a.ravel(), b.ravel(), s=8) + plotting._legend(ax, handles, inside=True) + assert legend_place(ax) == "right" + # The same points but for the upper left corner, where the legend goes. + ax = axes() + keep = (a.ravel() > 0.45) | (b.ravel() < 0.55) + ax.scatter(a.ravel()[keep], b.ravel()[keep], s=8) + plotting._legend(ax, handles, inside=True) + assert legend_place(ax) == "inside" and covered(ax) == [] + # A label in that corner, or a line across it, takes it away again. + ax = axes() + ax.scatter(a.ravel()[keep], b.ravel()[keep], s=8) + ax.text(0.02, 0.95, "a label in the corner") + plotting._legend(ax, handles, inside=True) + assert legend_place(ax) == "right" + ax = axes() + ax.scatter(a.ravel()[keep], b.ravel()[keep], s=8) + ax.plot([0.0, 0.4], [0.97, 0.97]) + plotting._legend(ax, handles, inside=True) + assert legend_place(ax) == "right" + # More than four entries go beside, wherever there is room. + ax = axes() + ax.scatter([0.0, 1.0], [0.0, 1.0]) + many = [plotting._key(f"entry {i}", color="C0") for i in range(5)] + plotting._legend(ax, many, inside=True) + assert legend_place(ax) == "right" + + +def test_mds_and_pca_draw_their_samples_alike() -> None: + cube = Cube( + {"counts": counts()[np.newaxis].astype(np.uint32)}, + samples={**SAMPLES, "donor": ["D1", "D2", "D3", "D4"] * 2}, + groups={"group_id": ["bulk"]}, + features={"feature_id": GENES}, + ) + options = {"color_by": "condition", "marker_by": "donor", "labels": True} + mds = plotting.plot_mds(cube, ax=axes(), **options) + pca = plotting.plot_pca(cube, ax=axes(), **options) + for ax in (mds, pca): + assert len(artists(ax, "samples")) == 4 # a collection per donor's marker + # The same colours, markers, sizes, legend and labels; only positions differ. + for first, second in zip( + artists(mds, "samples"), artists(pca, "samples"), strict=True + ): + assert_array_equal(first.get_facecolors(), second.get_facecolors()) + assert_array_equal(first.get_sizes(), second.get_sizes()) + assert_array_equal( # the marker + first.get_paths()[0].vertices, second.get_paths()[0].vertices + ) + texts = [[t.get_text() for t in ax.get_legend().get_texts()] for ax in (mds, pca)] + assert texts[0] == texts[1] == [ + "condition", "ctrl", "stim", "donor", "D1", "D2", "D3", "D4" + ] # fmt: skip + labels = [[t.get_text() for t in artists(ax, "sample labels")] for ax in (mds, pca)] + assert labels[0] == labels[1] == SAMPLES["sample_id"] + + @pytest.mark.parametrize( ("arguments", "error", "message"), [ @@ -733,6 +875,91 @@ def test_significant_genes_are_counted_in_each_group() -> None: plotting.plot_significant_genes(table) # type: ignore[arg-type] +def counted_result(counts: dict[str, tuple[int, int]]) -> DifferentialExpressionResult: + """A result of the groups named, whose tables hold the genes up and down given, + each at an adjusted p-value of 1e-4.""" + groups = list(counts) + cube = Cube( + {"counts": np.stack([counts_fixture()] * len(groups)).astype(np.uint32)}, + samples=SAMPLES, + groups={"group_id": groups}, + features={"feature_id": GENES}, + n_cells=np.full((8, len(groups)), 50), + ) + result = limma_voom(cube, design()) + tables = {} + for group, (up, down) in counts.items(): + n = up + down + tables[(group, "stim")] = Table( + { + "feature_id": [f"x{j}" for j in range(n)], + "log2_fold_change": np.where(np.arange(n) < down, -1.0, 1.0), + "adjusted_p_value": np.full(n, 1e-4), + } + ) + return DifferentialExpressionResult( + result.method, + result.contrasts, + result.summary, + result.samples, + tables, + result.provenance, + ) + + +def counts_inside(ax: Any) -> list[str]: + """The counts of a plot of significant genes that cross its frame.""" + frame = ax.get_window_extent() + return [ + text.get_text() + for text in artists(ax, "numbers") + if not (frame.x0 <= text.get_window_extent().x0) + or not (text.get_window_extent().x1 <= frame.x1) + ] + + +def test_the_numbers_of_the_longest_bars_stay_inside_the_frame() -> None: + # 12,000 genes down and 345 up: the number of the longest bar is wide. + built = counted_result({"T": (345, 12_000), "B": (49, 1_715)}) + ax = plotting.plot_significant_genes(built, ax=axes()) + canvas = pytest.importorskip("matplotlib.backends.backend_agg") + canvas.FigureCanvasAgg(ax.figure).draw() + numbers = artists(ax, "numbers") + assert [text.get_text() for text in numbers] == ["345", "12,000", "49", "1,715"] + assert counts_inside(ax) == [] + low, high = ax.get_xlim() + assert low == -high and high > 1.2 * 12_000 # widened from 1.2 times the bar + + +# Genes up and down in the eight cell types of Kang et al. (2018), by limma-voom and +# limma-trend, as "Changed genes per cell type" draws them side by side. +KANG_COUNTS = { + "B cells": ((498, 399), (408, 264)), + "CD14+ Monocytes": ((1619, 1549), (1550, 1553)), + "CD4 T cells": ((991, 826), (757, 497)), + "CD8 T cells": ((233, 147), (166, 76)), + "Dendritic cells": ((454, 285), (410, 273)), + "FCGR3A+ Monocytes": ((814, 663), (750, 549)), + "Megakaryocytes": ((63, 16), (56, 5)), + "NK cells": ((374, 300), (313, 170)), +} + + +def test_the_numbers_stay_inside_panels_side_by_side_after_the_final_draw() -> None: + # Constrained layout, shared groups and a legend beside each panel, which + # narrows the panels as it is added; checked once the figure is drawn in full. + left = counted_result({group: pair[0] for group, pair in KANG_COUNTS.items()}) + right = counted_result({group: pair[1] for group, pair in KANG_COUNTS.items()}) + figure = FIGURE.Figure(figsize=(11, 4.5), layout="constrained") + panels = figure.subplots(1, 2, sharey=True) + for ax, result in zip(panels, (left, right), strict=True): + plotting.plot_significant_genes(result, ax=ax) + figure.savefig(io.BytesIO(), format="png") + for ax in panels: + assert counts_inside(ax) == [] + assert ax.get_legend() is not None + + def test_volcano_labels_the_genes_with_the_smallest_p_values() -> None: ax = plotting.plot_volcano(table(), top=4, ax=axes()) labels = artists(ax, "gene labels") diff --git a/tests/test_provenance.py b/tests/test_provenance.py index 6807aa4..4b5604f 100644 --- a/tests/test_provenance.py +++ b/tests/test_provenance.py @@ -27,15 +27,17 @@ "artifacts": {"membership": "membership.parquet#sha256:5e1f"}, "exporter": {"name": "a cell store", "version": "2.1", "min_genes": 200}, } -UNRESOLVED = ( - "Source, as the caller recorded it (unresolved: CytePool does not follow its " - "references):" -) -REFERENCES = ( - "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." -) +# The texts of a history, in lines of at most 80 characters. +UNRESOLVED = [ + "Source, as the caller recorded it (unresolved: CytePool does not follow its", + " references):", +] +REFERENCES = [ + "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.", +] @pytest.fixture(scope="module") @@ -397,8 +399,9 @@ def test_history_reads_the_chain_in_plain_terms(cube: Cube) -> None: collapsed = regrouped.collapse_samples("donor") selected = collapsed.select(groups=["T", "B"], features=FEATURES[::-1]) - assert selected.history().splitlines() == [ - UNRESOLVED, + history = selected.history().splitlines() + assert history == [ + *UNRESOLVED, ' dataset: "simulated PBMC"', ' artifacts: {"membership": "membership.parquet#sha256:5e1f"}', ' exporter: {"name": "a cell store", "version": "2.1", "min_genes": 200}', @@ -408,20 +411,26 @@ def test_history_reads_the_chain_in_plain_terms(cube: Cube) -> None: " features: ids given as a sequence", " layers: counts, detected, log_sum, log_sum_sq, linear_sum", " normalized values: each cell scaled to a total of 10,000, with library " - "sizes the total count of each cell", - f"1. regroup, applied to the cube {cube.fingerprint()}", + "sizes", + " the total count of each cell", + "1. regroup, applied to the cube", + f" {cube.fingerprint()}", " T: T4 + T8", - f"2. collapse_samples by 'donor', applied to the cube {regrouped.fingerprint()}", + "2. collapse_samples by 'donor', applied to the cube", + f" {regrouped.fingerprint()}", " D1: S1 + S3", " D2: S2 + S5", " D3: S4", - f"3. select, applied to the cube {collapsed.fingerprint()}", + "3. select, applied to the cube", + f" {collapsed.fingerprint()}", " samples: every sample, as they were", " groups: T, B", " features: G11, G10, G09, G08, G07, G06, G05, G04, G03, G02, ... (12 in all)", - REFERENCES, - f"Fingerprint: {selected.fingerprint()}", + *REFERENCES, + "Fingerprint:", + f" {selected.fingerprint()}", ] + assert max(map(len, history)) <= 80 def test_a_lazy_history_says_what_was_not_computed(cube: Cube, tmp_path: Path) -> None: @@ -429,10 +438,10 @@ def test_a_lazy_history_says_what_was_not_computed(cube: Cube, tmp_path: Path) - lazy = read_cube(tmp_path / "c").select(features=["G01"]).regroup({"T": "T4"}) lines = lazy.history().splitlines() assert "2. regroup, applied to a cube whose fingerprint was not recorded" in lines - assert lines[-1] == ( - "Fingerprint: not known without reading the lazy layers; fingerprint() " - "reads them." - ) + assert lines[-2:] == [ + "Fingerprint: not known without reading the lazy layers; fingerprint() reads", + " them.", + ] def test_long_memberships_are_shortened() -> None: @@ -440,10 +449,46 @@ def test_long_memberships_are_shortened() -> None: record = {"operation": "collapse_samples", "by": "pool", "membership": membership} lines = describe_provenance({"operations": [record]}).splitlines() assert lines[0] == "1. collapse_samples by 'pool'" - assert lines[1] == " P0: " + " + ".join(f"S0-{j}" for j in range(10)) + ( - " + ... (12 in all)" + # The first 10 of each pooled sample's 12 members, the line broken at 80. + assert lines[1:3] == [ + " P0: " + " + ".join(f"S0-{j}" for j in range(10)) + " + ...", + " (12 in all)", + ] + assert len(lines) == 1 + 2 * 20 + 1 and lines[-1] == " ... (25 in all)" + + +def test_history_names_the_columns_added_and_each_way_of_pooling(cube: Cube) -> None: + changed = cube.with_columns( + samples={ + "pool": ["P1", "P1", "P2", "P2", "P1"], + "sex": ["F", "M", "F", "F", "F"], + }, + features={"length": np.arange(len(FEATURES))}, ) - assert len(lines) == 1 + 20 + 1 and lines[-1] == " ... (25 in all)" + by_two = changed.collapse_samples(["pool", "sex"]) + everything = by_two.collapse_samples() + lines = everything.history().splitlines() + start = lines.index("1. with_columns, applied to the cube") + assert lines[start : start + 12] == [ + "1. with_columns, applied to the cube", + f" {cube.fingerprint()}", + " samples: added pool; replaced sex", + " features: added length", + "2. collapse_samples by 'pool' and 'sex', applied to the cube", + f" {changed.fingerprint()}", + " P1_F: S1 + S5", + " P1_M: S2", + " P2_F: S3 + S4", + "3. collapse_samples of every sample into one, applied to the cube", + f" {by_two.fingerprint()}", + " all: P1_F + P1_M + P2_F", + ] + assert lines[start + 12 :] == [ + *REFERENCES, + "Fingerprint:", + f" {everything.fingerprint()}", + ] + assert max(map(len, lines)) <= 80 def test_records_of_earlier_versions_and_other_entries_are_shown_as_json() -> None: diff --git a/tests/test_quasi_likelihood.py b/tests/test_quasi_likelihood.py index c3c67ca..fcaf39a 100644 --- a/tests/test_quasi_likelihood.py +++ b/tests/test_quasi_likelihood.py @@ -240,6 +240,51 @@ def test_the_test_columns_are_edgers(fitted, name): assert_allclose(test.df_total, e["df.total"], rtol=PRIOR_DF) +@pytest.mark.parametrize("name", CASES) +def test_the_table_holds_the_columns_of_edgers_toptags(fitted, name): + case, fit, tests = fitted[name] + n_genes = case["counts"].shape[1] + genes = compared_genes(case) + estimated = "edger_top.proportion" in case + exact = one_way(case["design"]) and same_working_dispersion(case, fit) + for i, test in enumerate(tests, start=1): + e = { + key[len(f"edger_test{i}_") :]: value + for key, value in case.items() + if key.startswith(f"edger_test{i}_") + } + table = test.table() + lfc = e["logFC"].reshape(-1, n_genes).T + changes = ( + ["log2_fold_change"] + if lfc.shape[1] == 1 + else [f"log2_fold_change_{tested}" for tested in test.names] + ) + assert table.columns == ( + "feature_id", + *changes, + "average_log2_cpm", + "f_statistic", + "p_value", + "adjusted_p_value", + ) + assert table["feature_id"].tolist() == [f"feature_{j}" for j in range(n_genes)] + for j, column in enumerate(changes): + assert_allclose(table[column], lfc[:, j], atol=1e-6 if exact else FITS) + assert_allclose( + table["average_log2_cpm"][genes], + e["logCPM"][genes], + atol=1e-6 if estimated else 1e-8, + ) + assert scaled(table["f_statistic"][genes], e["F"][genes]) < MOMENTS + assert log10_ratio(table["p_value"][genes], e["PValue"][genes]) < PROBABILITY + assert log10_ratio(table["adjusted_p_value"][genes], e["FDR"][genes]) < ( + PROBABILITY + ) + ids = [f"g{j}" for j in range(n_genes)] + assert test.table(feature_ids=ids)["feature_id"].tolist() == ids + + # The fixtures where edgeR's average quasi-dispersion is 1. AVERAGE_ONE = [ name for name in CASES if load(name)["edger_average.ql.dispersion"][0] == 1.0 diff --git a/tests/test_result_fits.py b/tests/test_result_fits.py new file mode 100644 index 0000000..6b277f4 --- /dev/null +++ b/tests/test_result_fits.py @@ -0,0 +1,393 @@ +"""Tests of what a differential-expression result keeps and computes again. + +A result keeps the cube and design it analysed, and ``fit`` computes one group's fit +again. Each fit is compared, bit for bit, with the tables the analysis wrote, and with +the steps of limma-voom run by hand on the group's counts (``filter_by_expression``, +``tmm_factors``, ``voom``, ``fit_linear_model``, ``contrasts_fit`` and +``moderated_statistics``), the building blocks that the validation scripts check +against edgeR and limma. The cube is the fixture of the differential-expression tests, +whose NK cells leave out both samples of donor D1, the reference level, so that the +group's design is rank deficient. Also here: the tables of a result by default keys, +``ModeratedFit.table`` against the tables of ``limma_voom``, and the trend figures of a +result's group against those of the building blocks. +""" + +import pickle +from functools import cache +from typing import Any + +import numpy as np +import pytest +from numpy.testing import assert_array_equal +from test_differential_expression import cells_cube, paired_design, voom_result + +from cytepool.cube import from_bulk +from cytepool.design import Contrasts, Design +from cytepool.design.checks import _aliasing +from cytepool.differential_expression import ( + DifferentialExpressionResult, + GroupFit, + dream_voom, + limma_trend, + limma_voom, +) +from cytepool.normalization import filter_by_expression, log_cpm, tmm_factors +from cytepool.stats.empirical_bayes import ModeratedFit, moderated_statistics +from cytepool.stats.linear_models import contrasts_fit, fit_linear_model +from cytepool.stats.voom import voom + +matplotlib = pytest.importorskip("matplotlib") +matplotlib.use("Agg") +from matplotlib.figure import Figure # noqa: E402 + +from cytepool.plotting import ( # noqa: E402 + plot_mean_variance, + plot_residual_variances, +) + +LEVELS = {"condition": ["ctrl", "stim"]} + + +@cache +def trend_result() -> DifferentialExpressionResult: + """limma-trend with prior weights from the cells, robust.""" + cube = cells_cube() + return limma_trend( + cube, paired_design(cube.samples), prior_weights="n_cells", robust=True + ) + + +@cache +def quality_result() -> DifferentialExpressionResult: + cube = cells_cube() + return limma_voom(cube, paired_design(cube.samples), quality_weights=True) + + +@cache +def dream_result() -> DifferentialExpressionResult: + cube = cells_cube() + design = Design( + cube.samples, + "~ condition", + random="(1 | donor)", + levels=LEVELS, + contrasts={"stim_vs_ctrl": "conditionstim"}, + ) + return dream_voom(cube, design, span=0.5) + + +RESULTS = { + "voom": voom_result, + "voom, quality weights": quality_result, + "trend": trend_result, + "dream": dream_result, +} + + +def axes() -> Any: + return Figure().subplots() + + +def used_rows(result: DifferentialExpressionResult, group: str) -> np.ndarray: + """The cube's positions of the samples a group's fit used.""" + used = result.samples.filter(group_id=group, used=True)["sample_id"].tolist() + ids = result.cube.samples["sample_id"].tolist() # type: ignore[union-attr] + return np.array([ids.index(sample) for sample in used], dtype=np.intp) + + +# What a result keeps. + + +def test_a_result_keeps_the_cube_and_design_it_analysed() -> None: + cube = cells_cube() + design = paired_design(cube.samples) + result = limma_voom(cube, design, groups="T") + + assert result.cube is cube and result.design is design + restored = pickle.loads(pickle.dumps(result)) + assert restored.cube.fingerprint() == cube.fingerprint() + assert restored.design.formula == design.formula + assert_array_equal(restored.fit().moderated.t, result.fit().moderated.t) + built = DifferentialExpressionResult( + result.method, + result.contrasts, + result.summary, + result.samples, + result.tables, + result.provenance, + ) + assert built.cube is None and built.design is None + with pytest.raises(ValueError, match="keeps no cube and design"): + built.fit("T") + with pytest.raises(ValueError, match="both the cube and the design"): + DifferentialExpressionResult( + result.method, + result.contrasts, + result.summary, + result.samples, + result.tables, + result.provenance, + cube=cube, + ) + with pytest.raises(TypeError, match="design must be a Design"): + DifferentialExpressionResult( + result.method, + result.contrasts, + result.summary, + result.samples, + result.tables, + result.provenance, + cube=cube, + design=design.matrix, # type: ignore[arg-type] + ) + + +@pytest.mark.parametrize("name", list(RESULTS)) +def test_a_group_fitted_again_gives_the_tables_of_the_analysis(name: str) -> None: + result = RESULTS[name]() + for group in result.groups: + fit = result.fit(group) + moderated = fit.moderated + names = ( + moderated.tests.contrast_names + if result.method == "dream_voom" + else moderated.fit.coefficient_names + ) + for j, contrast in enumerate(names): + table = result.table(group, contrast) + assert_array_equal(table["feature_id"], fit.features["feature_id"]) + estimate = ( + moderated.tests.estimate + if result.method == "dream_voom" + else moderated.fit.coefficients + ) + assert_array_equal(table["log2_fold_change"], estimate[:, j]) + assert_array_equal(table["t"], moderated.t[:, j]) + assert_array_equal(table["p_value"], moderated.p_value[:, j]) + assert_array_equal(table["b_statistic"], moderated.lods[:, j]) + # The samples fitted are those the result says it used, with their numbers. + used = result.samples.filter(group_id=group, used=True) + assert fit.samples["sample_id"].tolist() == used["sample_id"].tolist() + for column in ("n_cells", "library_size", "norm_factor"): + assert_array_equal(fit.samples[column], used[column]) + for column in ("prior_weight", "quality_weight"): + assert (column in fit.samples) == (column in used) + if column in used: + assert_array_equal(fit.samples[column], used[column]) + assert fit.log2_cpm.shape == (len(used), len(fit.features)) + assert not fit.log2_cpm.flags.writeable + assert repr(fit).startswith(f"GroupFit(group={fit.group!r}, n_samples=") + + +def test_a_fit_is_limma_voom_by_hand_in_a_rank_deficient_group() -> None: + result = voom_result() + cube, design = cells_cube(), result.design + for group in ("T", "NK"): + rows = used_rows(result, group) + y = np.asarray(cube.layer("counts", group), dtype=np.float64)[rows] + x = design.matrix[rows] + kept = list(_aliasing(x).kept) + x = np.ascontiguousarray(x[:, kept]) + keep = filter_by_expression(y, design=x) + y = np.ascontiguousarray(y[:, keep]) + weighted = voom(y, x, norm_factors=tmm_factors(y)) + columns = tuple(design.columns[j] for j in kept) + model = fit_linear_model( + weighted.log_cpm, x, weights=weighted.weights, coefficient_names=columns + ) + estimable = [ + p for p, name in enumerate(design.contrasts.names) + if name not in result.provenance["groups"][ + result.groups.index(group) + ]["not_estimable"] + ] # fmt: skip + chosen = Contrasts( + design.contrasts.matrix[np.ix_(kept, estimable)], + tuple(design.contrasts.names[p] for p in estimable), + columns, + ) + moderated = moderated_statistics(contrasts_fit(model, chosen, method="limma")) + + fit = result.fit(group) + assert isinstance(fit, GroupFit) and fit.group == group + assert_array_equal(fit.log2_cpm, weighted.log_cpm) + assert_array_equal(fit.weights, weighted.weights) + assert fit.voom.span == weighted.span + assert_array_equal(fit.voom.sqrt_sd_trend, weighted.sqrt_sd_trend) + assert isinstance(fit.moderated, ModeratedFit) + assert fit.moderated.fit.coefficient_names == chosen.names + assert_array_equal(fit.moderated.t, moderated.t) + assert_array_equal( + fit.moderated.posterior_variance, moderated.posterior_variance + ) + assert_array_equal( + fit.features["feature_id"], cube.features["feature_id"][keep] + ) + # In NK, the reference donor's samples were left out: D2_vs_D1 is not tested. + assert result.fit("NK").moderated.fit.coefficient_names == ( + "stim_vs_ctrl", + "D2_vs_D4", + ) + + +def test_limma_trend_fits_log_cpm_with_the_sample_weights() -> None: + result = trend_result() + fit = result.fit("T") + rows = used_rows(result, "T") + cube = cells_cube() + y = np.asarray(cube.layer("counts", "T"), dtype=np.float64)[rows] + x = result.design.matrix[rows] + y = y[:, filter_by_expression(y, design=x)] + assert_array_equal( + fit.log2_cpm, log_cpm(y, norm_factors=tmm_factors(y), prior_count=3.0) + ) + assert fit.voom is None + assert_array_equal(fit.weights, np.asarray(cube.n_cells)[rows, 1].astype(float)) + assert_array_equal(fit.weights, fit.samples["prior_weight"]) + + +def test_the_group_fitted_last_is_kept() -> None: + result = limma_voom(cells_cube(), paired_design(cells_cube().samples)) + first = result.fit("T") + assert result.fit("T") is first + other = result.fit("NK") + assert other is not first and result.fit("NK") is other + again = result.fit("T") + assert again is not first + assert_array_equal(again.moderated.t, first.moderated.t) + + +def test_fit_says_which_group_it_cannot_fit() -> None: + cube = cells_cube() + result = limma_voom(cube, paired_design(cube.samples), min_cells=20) + with pytest.raises( + ValueError, match="the result has 2 groups; name one with group" + ): + result.fit() + with pytest.raises( + KeyError, match="no group 'B' was analysed; groups are: NK and T" + ): + result.fit("B") + with pytest.raises(TypeError, match="group must be a group id"): + result.fit(1) # type: ignore[arg-type] + with pytest.raises(KeyError, match="group 'NK' was not fitted"): + result.fit("NK") + one = limma_voom(cube, paired_design(cube.samples), groups="T") + assert one.fit().group == "T" + + +# Tables by default keys. + + +def test_the_table_of_the_only_group_and_contrast_needs_no_keys() -> None: + cube = cells_cube() + design = paired_design(cube.samples, contrasts={"stim": "conditionstim"}) + one = limma_voom(cube, design, groups="NK") + assert one.table().equals(one.table("NK", "stim")) + assert one.table(contrast="stim").equals(one.table("NK")) + several = voom_result() + with pytest.raises( + ValueError, match="the result has 2 groups; name one with group" + ): + several.table(contrast="stim_vs_ctrl") + with pytest.raises( + ValueError, + match="the result has 3 contrasts and F-tests; name one with contrast", + ): + several.table("T") + # A dream F-test counts among the keys. + design = Design( + cube.samples, "~ condition", random="(1 | donor)", levels=LEVELS, + contrasts={"stim": "conditionstim"}, + ) # fmt: skip + tested = dream_voom(cube, design, groups="T", f_tests={"both": ["stim"]}) + with pytest.raises(ValueError, match="2 contrasts and F-tests"): + tested.table() + + +# The tests of a fit as a table, as limma_voom's. + + +def test_a_moderated_fit_as_a_table_is_the_table_of_limma_voom() -> None: + result = voom_result() + for group in result.groups: + fit = result.fit(group) + ids = fit.features["feature_id"] + for contrast in fit.moderated.fit.coefficient_names: + mine = fit.moderated.table(contrast, feature_ids=ids) + theirs = result.table(group, contrast) + assert mine.columns == ( + "feature_id", "log2_fold_change", "standard_error", + "average_log2_cpm", "t", "p_value", "adjusted_p_value", "log_odds", + ) # fmt: skip + for column in theirs.columns: + found = "log_odds" if column == "b_statistic" else column + assert_array_equal(mine[found], theirs[column]) + moderated = result.fit("T").moderated + by_position = moderated.table(1) + assert by_position.equals( + moderated.table("D2_vs_D1").with_columns(feature_id=by_position["feature_id"]) + ) + assert by_position["feature_id"][:2].tolist() == ["feature_0", "feature_1"] + with pytest.raises(ValueError, match="the fit has 3 coefficients or contrasts"): + moderated.table() + with pytest.raises(KeyError, match="no coefficient or contrast 'x'"): + moderated.table("x") + with pytest.raises(IndexError, match="out of range for 3 coefficients"): + moderated.table(3) + with pytest.raises(ValueError, match="one id per feature"): + moderated.table(0, feature_ids=["a"]) + with pytest.raises(TypeError, match="feature_ids must hold text ids"): + moderated.table(0, feature_ids=list(range(len(by_position)))) + + +# The trend figures of a result's group. + + +def drawn(ax: Any, gid: str) -> np.ndarray: + """The points or the line of an artist, by its gid.""" + for artist in [*ax.collections, *ax.lines]: + if artist.get_gid() == gid: + if hasattr(artist, "get_offsets") and not hasattr(artist, "get_xdata"): + return np.asarray(artist.get_offsets()) + return np.column_stack([artist.get_xdata(), artist.get_ydata()]) + raise AssertionError(f"no artist {gid!r}") + + +def test_the_trend_figures_of_a_group_are_those_of_its_fit() -> None: + result = voom_result() + fit = result.fit("NK") + by_result = plot_mean_variance(result, group="NK", ax=axes()) + by_hand = plot_mean_variance(fit.voom, ax=axes()) + for gid in ("points", "trend"): + assert_array_equal(drawn(by_result, gid), drawn(by_hand, gid)) + by_result = plot_residual_variances(result, group="NK", ax=axes()) + by_hand = plot_residual_variances(fit.moderated, ax=axes()) + assert_array_equal(drawn(by_result, "points"), drawn(by_hand, "points")) + one = trend_result() + residuals = plot_residual_variances(one, group="T", ax=axes()) + # limma-trend's prior follows the trend: a curve, drawn as a line. + assert drawn(residuals, "prior").shape[0] == one.fit("T").log2_cpm.shape[1] + single = from_bulk(cells_cube().layer("counts", "T"), samples=cells_cube().samples) + bulk = limma_voom(single, paired_design(single.samples)) + assert_array_equal( + drawn(plot_mean_variance(bulk, ax=axes()), "points"), + drawn(plot_mean_variance(bulk.fit().voom, ax=axes()), "points"), + ) + + +def test_the_trend_figures_refuse_what_they_cannot_draw() -> None: + with pytest.raises(ValueError, match="limma-trend weights no observation"): + plot_mean_variance(trend_result(), group="T") + with pytest.raises(ValueError, match="dream moderates those of mixed models"): + plot_residual_variances(dream_result(), group="T") + with pytest.raises(ValueError, match="group applies to a differential-expression"): + plot_mean_variance(voom_result().fit("T").voom, group="T") + with pytest.raises(ValueError, match="group applies to a differential-expression"): + plot_residual_variances(voom_result().fit("T").moderated, group="T") + with pytest.raises(ValueError, match="the result has 2 groups"): + plot_mean_variance(voom_result()) + with pytest.raises(TypeError, match="result must be a VoomResult, or the"): + plot_mean_variance(np.ones(3)) + with pytest.raises(TypeError, match="fit must be a ModeratedFit or a TreatFit, or"): + plot_residual_variances(np.ones(3)) diff --git a/tests/test_score_tests.py b/tests/test_score_tests.py new file mode 100644 index 0000000..6eadc08 --- /dev/null +++ b/tests/test_score_tests.py @@ -0,0 +1,255 @@ +"""limma on scores of samples, checked against the steps a user would take by hand. + +By hand, the design is built from the samples the scores kept, and the scores go +through the validated ``fit_linear_model``, ``contrasts_fit`` and +``moderated_statistics``; ``limma`` instead matches the rows of the design built for +the whole cube by ``sample_id``. The two must agree bit for bit. +""" + +import re +from functools import cache +from typing import Any + +import numpy as np +import pytest +from numpy.testing import assert_allclose, assert_array_equal + +from cytepool.activity import Activities, ulm +from cytepool.cube import Cube +from cytepool.design import Design +from cytepool.differential_expression import limma_voom +from cytepool.networks import Network +from cytepool.pathway_scores import PathwayScores, gsva +from cytepool.score_tests import limma +from cytepool.stats.empirical_bayes import moderated_statistics +from cytepool.stats.linear_models import contrasts_fit, fit_linear_model +from cytepool.stats.multiple_testing import adjust_p_values +from cytepool.table import Table + +LEVELS = {"condition": ["control", "treated"]} +CONTRASTS = {"treated": "conditiontreated"} +COLUMNS = ( + "estimate", + "standard_error", + "average", + "t", + "p_value", + "adjusted_p_value", + "log_odds", +) + + +@cache +def cube() -> Cube: + """Six donors sampled in both conditions; S3 has too few cells to be scored.""" + rng = np.random.default_rng(8) + n_samples, n_genes = 12, 400 + means = np.exp(rng.uniform(2.0, 7.0, n_genes)) + counts = rng.negative_binomial(10, 10 / (10 + means), (n_samples, n_genes)) + condition = np.array(["control", "treated"] * (n_samples // 2)) + counts[condition == "treated", :30] *= 3 + cells = np.full((n_samples, 1), 40) + cells[3] = 5 + return Cube( + {"counts": counts[np.newaxis]}, + samples={ + "sample_id": [f"S{i}" for i in range(n_samples)], + "donor": np.repeat([f"D{i}" for i in range(6)], 2), + "condition": condition, + }, + groups={"group_id": ["B cells"]}, + features={ + "feature_id": [f"ENSG{j}" for j in range(n_genes)], + "symbol": [f"G{j}" for j in range(n_genes)], + }, + n_cells=cells, + ) + + +@cache +def scores() -> PathwayScores: + sets = { + "treated": [f"G{j}" for j in range(30)], + "other": [f"G{j}" for j in range(50, 90)], + "third": [f"G{j}" for j in range(100, 160)], + } + return gsva(cube(), sets, gene_ids="symbol") + + +@cache +def activities() -> Activities: + network = Network( + { + "A": {f"G{j}": 1.0 for j in range(30)}, + "B": {f"G{j}": (-1.0) ** j for j in range(40, 80)}, + } + ) + return ulm(cube(), network, group="B cells", gene_ids="symbol") + + +def design(samples: Any = None, formula: str = "~ donor + condition") -> Design: + table = cube().samples if samples is None else samples + return Design(table, formula, levels=LEVELS, contrasts=CONTRASTS) + + +def by_hand( + values: np.ndarray, built: Design, *, weights: Any = None, **moderation: Any +) -> dict[str, np.ndarray]: + """The steps of GSVA's guide: lmFit, contrasts.fit, eBayes and topTable.""" + fit = fit_linear_model(values, built, weights=weights) + tested = contrasts_fit(fit, built.contrasts, method="exact") + moderated = moderated_statistics(tested, **moderation) + p_value = moderated.p_value[:, 0] + return { + "estimate": tested.coefficients[:, 0], + "standard_error": tested.stdev_unscaled[:, 0] + * np.sqrt(moderated.posterior_variance), + "average": fit.mean_expression, + "t": moderated.t[:, 0], + "p_value": p_value, + "adjusted_p_value": adjust_p_values(p_value, "bh"), + "log_odds": moderated.lods[:, 0], + } + + +def assert_table(table: Table, id_column: str, ids: list[str], expected: dict) -> None: + assert table.columns == (id_column, *COLUMNS) + assert table[id_column].tolist() == ids + for name in COLUMNS: + assert_array_equal(table[name], expected[name], err_msg=name) + + +def test_scores_are_fitted_on_the_cubes_design_rows_of_their_samples() -> None: + result = scores() + # The scores left S3 out; the guide builds the design from the samples kept. + assert "S3" not in result.samples["sample_id"].tolist() + expected = by_hand(result.scores, design(result.samples)) + table = limma(result, design()) + assert_table(table, "gene_set", list(result.gene_sets), expected) + # The set of the tripled genes is higher in treated samples. + assert table["t"][0] > 10 and table["p_value"][0] < 1e-6 + # The contrast may be named; a sort reads the table from the smallest p-value. + assert limma(result, design(), contrast="treated").equals(table) + assert table.sort("p_value")["gene_set"].tolist()[0] == "treated" + + +def test_activities_of_samples_are_fitted_alike() -> None: + result = activities() + expected = by_hand(result.scores, design(result.profiles)) + assert_table(limma(result, design()), "source", list(result.sources), expected) + + +def test_an_array_takes_the_design_rows_or_the_samples_named() -> None: + result = scores() + values = result.scores + rows = result.samples["sample_id"].tolist() + expected = by_hand(values, design(result.samples)) + ids = [f"set{j}" for j in range(values.shape[1])] + named = limma(values, design(), sample_ids=rows, feature_ids=ids) + assert_table(named, "feature_id", ids, expected) + # Without sample_ids, the rows are the design's samples in order. + in_order = limma(values, design(result.samples)) + assert_table( + in_order, "feature_id", ["feature_0", "feature_1", "feature_2"], expected + ) + # Samples that the design lacks are left out; the rows' order does not matter. + shuffled = [10, 0, 3, 7, 1, 9, 2, 8, 4, 6, 5] + extra = np.vstack([values[shuffled], values[:1] + 1.0]) + found = limma(extra, design(), sample_ids=[rows[i] for i in shuffled] + ["X"]) + for name in COLUMNS: + assert_allclose(found[name], expected[name], rtol=1e-12) + + +def test_a_donor_without_samples_leaves_the_fit_as_its_columns_do() -> None: + # Without D1's samples, the cube's design has a column of zeros (donorD1), which + # the fit leaves out, as a design built from the other samples has no D1. + result = scores() + keep = [ + i for i, donor in enumerate(result.samples["donor"].tolist()) if donor != "D1" + ] + samples = result.samples.take(np.array(keep)) + values = result.scores[keep] + expected = by_hand(values, design(samples)) + table = limma(values, design(), sample_ids=samples["sample_id"].tolist()) + assert_table(table, "feature_id", ["feature_0", "feature_1", "feature_2"], expected) + + +def test_weights_trend_and_robust_reach_the_fit_and_the_moderation() -> None: + result = scores() + weights = np.linspace(0.5, 2.0, len(result.samples)) + expected = by_hand( + result.scores, design(result.samples), weights=weights, trend=True, robust=True + ) + table = limma(result, design(), weights=weights, trend=True, robust=True) + assert_table(table, "gene_set", list(result.gene_sets), expected) + sizes = np.asarray(result.n_genes, dtype=np.float64) + expected = by_hand(result.scores, design(result.samples), trend=sizes) + table = limma(result, design(), trend=sizes) + assert_table(table, "gene_set", list(result.gene_sets), expected) + # Weights per value fit each set alone, so they agree to rounding. + per_value = np.tile(weights[:, None], (1, result.scores.shape[1])) + alike = limma(result, design(), weights=per_value) + expected = by_hand(result.scores, design(result.samples), weights=per_value) + assert_table(alike, "gene_set", list(result.gene_sets), expected) + once = limma(result, design(), weights=weights) + for name in COLUMNS: + assert_allclose(alike[name], once[name], rtol=1e-12, atol=1e-15) + + +def test_what_limma_cannot_test_is_refused() -> None: + result = scores() + values = result.scores + full = cube() + of_contrasts = ulm( + limma_voom(full, design(), min_cells=0), + Network({"A": {f"G{j}": 1.0 for j in range(30)}}), + id_column="symbol", + min_targets=3, + ) + with pytest.raises(ValueError, match="these activities are of the statistics"): + limma(of_contrasts, design()) + with pytest.raises(ValueError, match="limma fits fixed effects only"): + limma( + result, + Design(full.samples, "~ condition", random="(1 | donor)", levels=LEVELS), + ) + with pytest.raises(ValueError, match="feature_ids applies to an array"): + limma(result, design(), feature_ids=["a", "b", "c"]) + with pytest.raises(ValueError, match="the design has 0 contrasts; name one"): + limma(result, Design(full.samples, "~ donor + condition", levels=LEVELS)) + two = Design( + full.samples, + "~ donor + condition", + levels=LEVELS, + contrasts={"treated": "conditiontreated", "d1": "donorD1"}, + ) + with pytest.raises(ValueError, match="the design has 2 contrasts; name one with"): + limma(result, two) + with pytest.raises(KeyError, match="the design has no contrast 'stim'"): + limma(result, design(), contrast="stim") + # Without D1's samples, a contrast of D1 is not estimable. + others = [i for i, d in enumerate(result.samples["donor"].tolist()) if d != "D1"] + rows = result.samples["sample_id"][others].tolist() + with pytest.raises(ValueError, match="the contrast 'd1' is not estimable"): + limma(values[others], two, contrast="d1", sample_ids=rows) + # One sample of each donor: the donors' columns span the samples. + single = ["S0", "S2", "S5", "S6", "S9", "S10"] + where = [result.samples["sample_id"].tolist().index(i) for i in single] + with pytest.raises(ValueError, match="no residual degrees of freedom: the design"): + limma(values[where], design(), sample_ids=single) + with pytest.raises(ValueError, match="none of the samples of the data is in"): + limma(values, design(), sample_ids=[f"X{i}" for i in range(len(values))]) + with pytest.raises( + ValueError, match=re.escape("data has 11 rows and the design 12") + ): + limma(values, design()) + with pytest.raises(TypeError, match="data must be PathwayScores, Activities"): + limma({"a": 1.0}, design()) + with pytest.raises(TypeError, match="design must be a Design"): + limma(result, full.samples) # type: ignore[arg-type] + with pytest.raises(ValueError, match="weights must hold one weight per sample"): + limma(result, design(), weights=np.ones(3)) + with pytest.raises(ValueError, match="data holds infinite values"): + limma(np.where(values > 0.5, np.inf, values), design(result.samples)) + with pytest.raises(ValueError, match="sample_ids must be unique"): + limma(values, design(), sample_ids=["S0"] * len(values)) diff --git a/tests/test_study_results.py b/tests/test_study_results.py new file mode 100644 index 0000000..16a0927 --- /dev/null +++ b/tests/test_study_results.py @@ -0,0 +1,239 @@ +"""Every study of a collection analysed alike, and the results lined up gene by gene. + +``analyse_each_study`` is checked against the loop it replaces, written out with the +validated functions, and ``StudyResults`` against ``align_study_results`` and each +study's own table. +""" + +import pickle +import re +from functools import cache +from typing import Any + +import numpy as np +import pytest +from numpy.testing import assert_array_equal +from test_cube_collection import LEVELS, fixture_collection + +from cytepool.cube import CubeCollection +from cytepool.design import Design +from cytepool.differential_expression import ( + DifferentialExpressionResult, + dream_voom, + limma_trend, + limma_voom, +) +from cytepool.meta_analysis import ( + align_study_results, + differential_expression_meta_analysis, +) +from cytepool.study_results import StudyResults, analyse_each_study + +FORMULA = "~ donor + condition" +CONTRASTS = {"stim": "conditionstim"} + + +@cache +def pair() -> CubeCollection: + """The two studies whose donors were sampled in both conditions.""" + return fixture_collection().select(studies=["lupus", "covid"]) + + +@cache +def voom_results() -> StudyResults: + return analyse_each_study(pair(), FORMULA, levels=LEVELS, contrasts=CONTRASTS) + + +def loop( + collection: CubeCollection, + formula: str, + analysis: Any = limma_voom, + random: str | None = None, + **options: Any, +) -> dict[str, DifferentialExpressionResult]: + """The loop over studies, written out.""" + results = {} + for study in collection.studies: + cube = collection.aligned_cube(study) + design = Design( + cube.samples, formula, random=random, levels=LEVELS, contrasts=CONTRASTS + ) + results[study] = analysis(cube, design, **options) + return results + + +def assert_same_result( + ours: DifferentialExpressionResult, expected: DifferentialExpressionResult +) -> None: + assert ours.method == expected.method + assert ours.summary.equals(expected.summary) + assert ours.samples.equals(expected.samples) + assert list(ours.tables) == list(expected.tables) + for key, table in expected.tables.items(): + assert ours.tables[key].equals(table), key + assert ours.provenance == expected.provenance + assert ours.cube is not None and expected.cube is not None + assert ours.cube.fingerprint() == expected.cube.fingerprint() + assert ours.design is not None and expected.design is not None + assert ours.design.formula == expected.design.formula + + +def test_each_study_is_analysed_as_the_loop_analyses_it() -> None: + results = voom_results() + expected = loop(pair(), FORMULA) + assert results.studies == ("lupus", "covid") + for study in pair().studies: + assert_same_result(results[study], expected[study]) + # Options reach the analysis, and random effects the design. + first = pair().groups["group_id"][0] + trend = analyse_each_study( + pair(), + FORMULA, + analysis=limma_trend, + levels=LEVELS, + contrasts=CONTRASTS, + groups=first, + ) + for study, result in loop(pair(), FORMULA, limma_trend, groups=first).items(): + assert_same_result(trend[study], result) + dream = analyse_each_study( + pair(), + "~ condition", + analysis=dream_voom, + random="(1 | donor)", + levels=LEVELS, + contrasts=CONTRASTS, + groups=[first], + ) + expected_dream = loop( + pair(), "~ condition", dream_voom, random="(1 | donor)", groups=[first] + ) + for study, result in expected_dream.items(): + assert_same_result(dream[study], result) + + +def test_the_table_lines_up_each_study_and_the_matrix_takes_one_column() -> None: + results = voom_results() + collection = pair() + features = collection.features["feature_id"].tolist() + for group in collection.groups["group_id"].tolist(): + table = results.table(group, "stim") + assert table.equals( + align_study_results(collection, dict(results), group, "stim") + ) + for column in ("p_value", "t", "log2_fold_change"): + matrix = results.matrix(column, group, "stim") + assert matrix.shape == (collection.n_studies, collection.n_features) + assert matrix.dtype == np.float64 and not matrix.flags.writeable + # Each study's own table, placed at its features; NaN elsewhere. + for row, study in enumerate(collection.studies): + expected = np.full(len(features), np.nan) + if group in results[study].groups: + own = results[study].table(group, "stim") + positions = [features.index(f) for f in own["feature_id"].tolist()] + expected[positions] = own[column] + assert_array_equal(matrix[row], expected) + + +def test_the_keys_may_be_left_out_when_the_studies_analysed_one() -> None: + results = voom_results() + groups = pair().groups["group_id"].tolist() + # One contrast: only the group is needed. + assert results.table(groups[1]).equals(results.table(groups[1], "stim")) + assert_array_equal( + results.matrix("t", groups[1]), results.matrix("t", groups[1], "stim") + ) + message = ( + f"the studies analysed 5 groups; name one with group, one of '{groups[0]}', " + ) + with pytest.raises(ValueError, match=re.escape(message)): + results.table() + one = analyse_each_study( + pair(), FORMULA, levels=LEVELS, contrasts=CONTRASTS, groups=groups[0] + ) + assert one.table().equals(results.table(groups[0], "stim")) + assert_array_equal(one.matrix("p_value"), results.matrix("p_value", groups[0])) + + +def test_the_summary_designs_and_repr_cover_every_study() -> None: + results = voom_results() + first = pair().groups["group_id"][0] + covid = pair().aligned_cube("covid") + dream = dream_voom( + covid, + Design(covid.samples, "~ condition", random="(1 | donor)", levels=LEVELS), + contrasts=CONTRASTS, + groups=[first], + ) + mixed = StudyResults(pair(), {"covid": dream, "lupus": results["lupus"]}) + assert mixed.studies == ("lupus", "covid") # the collection's order + summary = mixed.summary + lupus, other = results["lupus"].summary, dream.summary + assert summary.columns[0] == "study" + assert summary["study"].tolist() == ["lupus"] * len(lupus) + ["covid"] + for name in lupus.columns: + assert summary[name].tolist()[: len(lupus)] == lupus[name].tolist(), name + for name in other.columns: + assert summary[name].tolist()[len(lupus) :] == other[name].tolist(), name + # dream's df_method is missing in limma's rows. + assert summary["df_method"].tolist() == [None] * len(lupus) + ["kenward_roger"] + assert mixed.designs["covid"] is dream.design + with pytest.raises(TypeError): + mixed.designs["covid"] = None # type: ignore[index] + lines = repr(results).splitlines() + assert lines == [ + "StudyResults of 2 studies: 5 groups, 1 contrast: stim", + " lupus: limma_voom, 4 groups, 4 fitted", + " covid: limma_voom, 4 groups, 4 fitted", + ] + + +def test_the_results_are_a_read_only_mapping_that_pickles() -> None: + results = voom_results() + assert list(results) == ["lupus", "covid"] and len(results) == 2 + assert results.collection is pair() + with pytest.raises(KeyError, match="no study named 'atlas'; studies are: 'lupus'"): + results["atlas"] + with pytest.raises(AttributeError, match="immutable"): + results.extra = 1 # type: ignore[attr-defined] + restored = pickle.loads(pickle.dumps(results)) + for study in results: + assert_same_result(restored[study], results[study]) + group = pair().groups["group_id"][0] + assert restored.table(group).equals(results.table(group)) + # The combining functions take the results as they take a dict of them. + meta = differential_expression_meta_analysis(results) + expected = differential_expression_meta_analysis(dict(results)) + assert meta.table(group, "stim").equals(expected.table(group, "stim")) + + +def test_invalid_results_and_analyses_are_refused() -> None: + results = voom_results() + lupus = results["lupus"] + with pytest.raises(TypeError, match="collection must be a CubeCollection"): + StudyResults({"lupus": lupus}, {"lupus": lupus}) # type: ignore[arg-type] + with pytest.raises(TypeError, match="results must be a mapping"): + StudyResults(pair(), [lupus]) # type: ignore[arg-type] + with pytest.raises(ValueError, match="no other: missing 'covid'"): + StudyResults(pair(), {"lupus": lupus}) + extra = {"lupus": lupus, "covid": lupus, "atlas": lupus} + with pytest.raises(ValueError, match="not in the collection: 'atlas'"): + StudyResults(pair(), extra) + with pytest.raises(TypeError, match=r"results\['covid'\] must be a Differential"): + StudyResults(pair(), {"lupus": lupus, "covid": lupus.table("CL:0000236")}) + with pytest.raises(KeyError, match="no study's table has a column 'pvalue'"): + results.matrix("pvalue", "CL:0000236") + with pytest.raises(ValueError, match="'status' holds text"): + results.matrix("status", "CL:0000236") + with pytest.raises(TypeError, match="column must be a column name"): + results.matrix(3, "CL:0000236") # type: ignore[arg-type] + with pytest.raises(TypeError, match="collection must be a CubeCollection"): + analyse_each_study(dict(results), FORMULA) # type: ignore[arg-type] + with pytest.raises(TypeError, match="formula must be a formula"): + analyse_each_study(pair(), 3) # type: ignore[arg-type] + with pytest.raises(TypeError, match="analysis must be limma_voom, limma_trend"): + analyse_each_study(pair(), FORMULA, analysis=len) + # A study's error says which study it came from. + with pytest.raises(ValueError, match="uses site, which is not a column") as raised: + analyse_each_study(pair(), "~ site + condition", levels=LEVELS) + assert "(in study 'lupus' of the collection)" in raised.value.__notes__ diff --git a/tests/test_sumrank.py b/tests/test_sumrank.py index 948126a..d46b461 100644 --- a/tests/test_sumrank.py +++ b/tests/test_sumrank.py @@ -7,6 +7,7 @@ invariants that a wrong ranking, sum or count would break. """ +import io import math import pickle from functools import cache @@ -33,6 +34,7 @@ differential_expression_sumrank, sumrank, ) +from cytepool.table import Table DATA = Path(__file__).parent / "data" / "sumrank" CONTRAST = "case_vs_ctrl" @@ -387,7 +389,10 @@ def studies() -> tuple[CubeCollection, dict[str, DifferentialExpressionResult]]: def test_studies_of_a_collection_are_ranked_as_sumrank_ranks_their_results() -> None: collection, results = studies() - with pytest.warns(RuntimeWarning, match="best 2 of 3 studies' ranks are too small"): + # The warning's lines are at most 80 characters. + with pytest.warns( + RuntimeWarning, match=r"best 2 of 3 studies' ranks are too\ssmall" + ): result = differential_expression_sumrank( collection, results, "T", CONTRAST, proportion_of_studies=0.7 ) @@ -524,8 +529,9 @@ def test_the_result_records_its_studies_and_is_immutable() -> None: copy = pickle.loads(pickle.dumps(result)) assert copy.table.equals(result.table) and copy.provenance == record text = repr(result) - assert "3 studies, the best 3 summed" in text + assert "3 studies, the best 3 summed" in " ".join(text.split()) assert "2 permutations of 'condition'" in text + assert max(map(len, text.splitlines())) <= 80 def test_permutations_need_a_variable_of_each_design() -> None: @@ -669,6 +675,136 @@ def test_the_figure_shows_the_p_values_in_alphabetical_order() -> None: plot_sumrank(table) # type: ignore[arg-type] +def tied_result() -> SumRankResult: + """200 genes, of which 30 next to each other in alphabetical order share the + smallest p-value of 100 permutations, with statistics in a shuffled order.""" + n = 200 + rng = np.random.default_rng(3) + p = rng.uniform(0.05, 1.0, n) + tied = np.arange(50, 80) + p[tied] = 1.0 / 101.0 + statistic = rng.permutation(n).astype(np.float64) + adjusted = np.where(np.isin(np.arange(n), tied), 0.01, 0.9) + table = Table( + { + "feature_id": [f"g{j:03d}" for j in range(n)], + "symbol": [f"GENE{j:03d}" for j in range(n)], + "up_statistic": statistic, + "up_p_value": p, + "up_adjusted_p_value": adjusted, + "down_statistic": statistic, + "down_p_value": p, + "down_adjusted_p_value": adjusted, + } + ) + settings = { + "group": "T", + "contrast": CONTRAST, + "n_studies": 3, + "n_studies_summed": 3, + "p_values": "permutation", + "n_permutations": 100, + "permute": "condition", + } + return SumRankResult( + table, Table({"study": ["a", "b", "c"]}), {"settings": settings} + ) + + +def test_tied_p_values_are_labelled_by_statistic_and_the_labels_kept_apart() -> None: + pytest.importorskip("matplotlib") + from matplotlib.backends.backend_agg import FigureCanvasAgg + from matplotlib.figure import Figure + from matplotlib.text import Text + + from cytepool.plotting import plot_sumrank + + result = tied_result() + figure = Figure() + FigureCanvasAgg(figure) + ax = plot_sumrank(result, n_labels=10, ax=figure.subplots()) + labels = [text for text in ax.texts if text.get_gid() == "labels"] + # Of the 30 genes tied at the smallest p-value, the 10 with the smallest + # statistics, the best ranks. + statistic = result.table["up_statistic"] + tied = np.arange(50, 80) + best = tied[np.argsort(statistic[tied], kind="stable")[:10]] + assert sorted(text.get_text() for text in labels) == sorted( + f"GENE{j:03d}" for j in best + ) + figure.canvas.draw() + renderer = figure.canvas.get_renderer() + # The extent of each name, without the line that joins a moved name to its gene. + boxes = [Text.get_window_extent(text, renderer) for text in labels] + for i, first in enumerate(boxes): + for second in boxes[i + 1 :]: + assert not first.overlaps(second) + # Labels moved above others point at their genes; all are inside the frame. + frame = ax.get_window_extent() + assert all(box.y1 <= frame.y1 for box in boxes) + moved = [text for text in labels if text.xyann[1] > labels[0].xyann[1]] + assert moved and all(text.arrow_patch is not None for text in moved) + assert labels[0].arrow_patch is None + + +def test_labels_and_legends_stay_inside_two_panels_after_the_final_draw() -> None: + pytest.importorskip("matplotlib") + from matplotlib.backends.backend_agg import FigureCanvasAgg + from matplotlib.figure import Figure + from matplotlib.text import Text + + from cytepool.plotting import plot_sumrank + + # The genes with the smallest p-values are the first and last in alphabetical + # order, where a label centred on its gene would cross the frame. + n = 400 + rng = np.random.default_rng(4) + p = rng.uniform(0.2, 1.0, n) + ends = np.array([0, 1, n - 2, n - 1]) + p[ends] = [1e-9, 2e-9, 3e-9, 4e-9] + adjusted = np.where(np.isin(np.arange(n), ends), 1e-6, 0.9) + table = Table( + { + "feature_id": [f"gene_with_a_long_name_{j:04d}" for j in range(n)], + "up_statistic": np.arange(n, dtype=np.float64), + "up_p_value": p, + "up_adjusted_p_value": adjusted, + "down_statistic": np.arange(n, dtype=np.float64), + "down_p_value": p, + "down_adjusted_p_value": adjusted, + } + ) + settings = { + "group": "T", + "contrast": CONTRAST, + "n_studies": 3, + "n_studies_summed": 3, + "p_values": "irwin_hall", + } + result = SumRankResult( + table, Table({"study": ["a", "b", "c"]}), {"settings": settings} + ) + # As the replication guide draws genes up and down: two panels, constrained. + figure = Figure(figsize=(8, 6.5), layout="constrained") + FigureCanvasAgg(figure) + upper, lower = figure.subplots(2, 1) + plot_sumrank(result, n_labels=4, ax=upper) + plot_sumrank(result, direction="down", n_labels=4, ax=lower) + figure.savefig(io.BytesIO(), format="png") + renderer = figure.canvas.get_renderer() + for ax in (upper, lower): + frame = ax.get_window_extent() + labels = [text for text in ax.texts if text.get_gid() == "labels"] + assert len(labels) == 4 + for text in labels: + box = Text.get_window_extent(text, renderer) # the name, without its line + assert frame.x0 <= box.x0 and box.x1 <= frame.x1, text.get_text() + assert box.y1 <= frame.y1, text.get_text() + # The legend lies beside the plot, clear of the labels along its top. + legend = ax.get_legend().get_window_extent(renderer) + assert legend.x0 >= frame.x1 + + def test_a_result_is_built_from_tables_and_a_record() -> None: collection, results = studies() result = differential_expression_sumrank(collection, results, "T", CONTRAST) diff --git a/tests/test_table.py b/tests/test_table.py index eaf8d27..b085a40 100644 --- a/tests/test_table.py +++ b/tests/test_table.py @@ -161,6 +161,82 @@ def test_filter_keeps_rows_where_the_mask_is_true(table: Table) -> None: table.filter([True, False]) +def test_filter_by_values_keeps_the_rows_a_mask_of_equalities_keeps( + table: Table, +) -> None: + # Each value against the mask built by hand; missing values match missing ones. + cases = [ + ({"sample_id": "S2"}, table["sample_id"] == "S2"), + ({"donor": None}, np.array([v is None for v in table["donor"]])), + ({"donor": ""}, np.array([v == "" for v in table["donor"]])), + ({"cells": 85}, table["cells"] == 85), + ({"age": 61.0}, table["age"] == 61.0), + ({"age": np.nan}, np.isnan(table["age"])), + ({"cells": np.nan}, np.zeros(3, dtype=bool)), # integers are never missing + ({"treated": True}, table["treated"]), + ({"collected": np.datetime64("2024-03-04")}, np.array([False, False, True])), + ({"collected": np.datetime64("NaT", "s")}, np.array([False, True, False])), + ({"treated": True, "cells": 3}, table["treated"] & (table["cells"] == 3)), + ] + for values, mask in cases: + assert table.filter(**values).equals(table.filter(mask)), values + # A mask and values together; the mask's keyword, as before values existed. + both = table.filter(np.array([True, True, False]), treated=True) + assert both["sample_id"].tolist() == ["S1"] + assert table.filter(mask=np.array([False, True, True])).equals( + table.filter(np.array([False, True, True])) + ) + assert table.filter().equals(table) + # A column named mask is filtered by its value. + named = Table({"mask": [1.0, 2.0]}) + assert named.filter(mask=2.0)["mask"].tolist() == [2.0] + + +def test_filter_refuses_values_of_another_kind(table: Table) -> None: + with pytest.raises(TypeError, match="the column holds numbers, a number, got str"): + table.filter(cells="85") + with pytest.raises(TypeError, match="holds numbers, a number, got NoneType None"): + table.filter(age=None) # NaN marks a missing number + with pytest.raises(TypeError, match="the column holds text, a string, got int 1"): + table.filter(donor=1) + with pytest.raises(TypeError, match=r"numpy.isin\(table\['donor'\], values\)"): + table.filter(donor=["D1", None]) + with pytest.raises(TypeError, match="booleans, True or False, got int"): + table.filter(treated=1) + with pytest.raises(TypeError, match="datetimes, a numpy.datetime64"): + table.filter(collected="2024-03-04") + with pytest.raises(KeyError, match="no column named 'tissue'"): + table.filter(tissue="lung") + + +def test_sort_is_stable_and_puts_missing_values_last() -> None: + rng = np.random.default_rng(3) + values = rng.integers(0, 4, 40).astype(float) + values[[3, 17, 30]] = np.nan + text = np.array([f"t{v}" for v in rng.integers(0, 3, 40)], dtype=object) + text[[5, 9]] = None + table = Table({"row": np.arange(40), "value": values, "text": text}) + present = np.flatnonzero(~np.isnan(values)) + order = present[np.argsort(values[present], kind="stable")] + expected = np.concatenate([order, np.flatnonzero(np.isnan(values))]) + assert_array_equal(table.sort("value")["row"], expected) + # Descending: the largest first, equal values in their order, missing last. + order = present[np.argsort(-values[present], kind="stable")] + expected = np.concatenate([order, np.flatnonzero(np.isnan(values))]) + assert_array_equal(table.sort("value", descending=True)["row"], expected) + named = [i for i in range(40) if text[i] is not None] + by_text = sorted(named, key=lambda i: text[i]) + [5, 9] + assert table.sort("text")["row"].tolist() == by_text + by_text = sorted(named, key=lambda i: text[i], reverse=True) + [5, 9] + assert table.sort("text", descending=True)["row"].tolist() == by_text + assert table.sort("row", descending=True)["row"].tolist() == list(range(39, -1, -1)) + with pytest.raises(KeyError, match="no column named 'x'"): + table.sort("x") + with pytest.raises(TypeError, match="descending must be True or False"): + table.sort("row", descending="yes") # type: ignore[arg-type] + assert Table({"a": []}).sort("a").equals(Table({"a": []})) + + def test_select_chooses_and_orders_columns(table: Table) -> None: assert table.select(["age", "sample_id"]).columns == ("age", "sample_id") assert table.select("donor").columns == ("donor",) diff --git a/tests/test_variance_partitioning.py b/tests/test_variance_partitioning.py index 22bf948..6916c60 100644 --- a/tests/test_variance_partitioning.py +++ b/tests/test_variance_partitioning.py @@ -27,7 +27,7 @@ from cytepool.cube import Cube, from_bulk from cytepool.design import Design -from cytepool.normalization import tmm_factors +from cytepool.normalization import filter_by_expression, tmm_factors from cytepool.stats.dream import voom_with_dream_weights from cytepool.stats.voom import voom from cytepool.table import Table @@ -444,6 +444,10 @@ def test_groups_that_cannot_be_partitioned_say_why_and_the_rest_are_fitted() -> result.table("empty") with pytest.raises(KeyError, match="no group 'other'"): result.table("other") + with pytest.raises( + ValueError, match="the result has 4 groups; name one with group" + ): + result.table() table = result.table("fine") assert table.columns == ("feature_id", "donor", "condition", "age", "residuals") fractions = np.column_stack([table[name] for name in result.variables]) @@ -473,6 +477,7 @@ def test_a_design_without_random_effects_is_fitted_after_voom() -> None: direct = variance_fractions(weighted.log_cpm, design, weights=weighted.weights) table = result.table("fine") + assert result.table().equals(table) # the only group needs no name assert result.variables == ("age", "condition", "residuals") assert_allclose( np.column_stack([table[name] for name in result.variables]), @@ -482,6 +487,30 @@ def test_a_design_without_random_effects_is_fitted_after_voom() -> None: ) +def test_a_filter_by_sample_groups_keeps_the_genes_of_any_one_group() -> None: + fine = small_cube(np.random.default_rng(14)).select(groups=["fine"]) + counts = fine.layer("counts", "fine").copy() + counts[2:, 0] = 0 # g0: counted in the two samples of donor D0 only + counts[1:, 1] = 0 # g1: counted in one sample only + cube = Cube( + {"counts": counts[np.newaxis]}, + samples=fine.samples, + groups=fine.groups, + features=fine.features, + n_cells=fine.n_cells, + ) + design = Design(cube.samples, "~ age + condition") + by_donor = variance_partitioning( + cube, design, expression_filter={"sample_groups": "donor"}, normalization=None + ) + keep = filter_by_expression(counts, group=cube.samples["donor"]) + tested = by_donor.table()["feature_id"].tolist() + assert tested == cube.features["feature_id"][keep].tolist() + assert "g0" in tested and "g1" not in tested + by_design = variance_partitioning(cube, design, normalization=None) + assert "g0" not in by_design.table()["feature_id"].tolist() + + def test_the_result_records_its_samples_settings_and_provenance() -> None: result = cube_result() record = result.provenance @@ -506,6 +535,7 @@ def test_the_result_records_its_samples_settings_and_provenance() -> None: result.summary = result.samples # type: ignore[misc] assert "3 groups, 2 fitted" in repr(result) assert "rare: not fitted (random_effects_not_estimable)" in repr(result) + assert max(map(len, repr(result).splitlines())) <= 80 def test_cube_options_and_names_are_checked() -> None: diff --git a/validation/combined_p_values_and_replication.py b/validation/combined_p_values_and_replication.py index 26f2904..3b87680 100644 --- a/validation/combined_p_values_and_replication.py +++ b/validation/combined_p_values_and_replication.py @@ -29,8 +29,10 @@ stimulation that changes 15% of 700 genes in two cell types alike in every cohort, up to 50% more or less, each measuring part of the genes, are aligned in a ``CubeCollection``, tested by ``limma_voom`` and passed to -``differential_expression_replication`` with three settings; R computes every column -from the cohorts' tables, and the figures are compared with what R computes for them. +``differential_expression_replication`` with four settings, among them pi1 with +qvalue's defaults (``null_proportion={}``) and pi1 by default (``null_proportion`` left +out), which is ``pi0est(lambda = 0.5)``; R computes every column from the cohorts' +tables, and the figures are compared with what R computes for them. Tolerances: exact (1e-10) for every closed form, the smoother of pi0 included (R's search for its smoothing parameter is followed step by step); close (1e-6) for REML. @@ -90,12 +92,15 @@ NAMES = {"smooth.df": "smooth_df", "smooth.log.pi0": "smooth_log"} NAMES |= {"pi0.method": "method", "lambda": "lambdas"} # The replications: method, conjunction method, at_least, alpha, meta_method, and -# pi0est's options. +# pi0est's options; None leaves null_proportion out, for pi1 by default, which is +# pi0est at DEFAULT_PI0. SETTINGS = ( ("stouffer", "simes", 2, 0.05, "reml", {}), ("fisher", "fisher", 3, 0.25, "dl", {"pi0.method": "bootstrap"}), ("tippett", "stouffer", 2, 0.1, "reml", {"lambda": 0.5}), + ("stouffer", "simes", 2, 0.05, "dl", None), ) +DEFAULT_PI0 = {"lambda": 0.5} def reference_main(directory): @@ -443,10 +448,13 @@ def replications(collection, results, settings=SETTINGS): out = [] for group in collection.groups["group_id"].tolist(): for s, (method, conjunction, u, alpha, meta, pi0) in enumerate(settings): + options = {} if pi0 is None else { + "null_proportion": {NAMES[key]: value for key, value in pi0.items()} + } # fmt: skip result = differential_expression_replication( collection, results, group, "stim_vs_ctrl", alpha=alpha, method=method, at_least=u, conjunction_method=conjunction, meta_method=meta, - null_proportion={NAMES[key]: value for key, value in pi0.items()}, + **options, ) # fmt: skip out.append((f"{group}{s}", s, result)) return out @@ -509,6 +517,7 @@ def run_references(directory, cases, extreme, pi0, analyses, collection, results write_binary(folder / f"{file}.bin", values[:, keep].T) write_binary(folder / "n_samples.bin", result.studies["n_samples"]) method, conjunction, u, alpha, meta, options = SETTINGS[s] + options = DEFAULT_PI0 if options is None else options spec = {"name": name, "method": method, "conjunction": conjunction} spec |= {"at_least": u, "alpha": alpha, "meta": meta, "pi0": options} lines.append(json.dumps(spec)) @@ -743,13 +752,14 @@ def check_pi0(pi0, reference): def check_replication(analyses, reference): worst = dict.fromkeys(("genes", "reml", "dl", "pairs", "found_in"), 0.0) - compared = stops = 0 + worst["default"] = 0.0 + compared = stops = by_default = 0 counts = ("n_studies", "n_up", "n_down", "n_found", "n_found_up", "n_found_down") counts += ("direction",) values = ("sign_agreement", "p_value", "replication_p_value", "adjusted_p_value") values += ("replication_adjusted_p_value",) heterogeneity = ("q_statistic", "q_p_value", "i_squared", "tau_squared") - for name, _, result in analyses: + for name, s, result in analyses: theirs = reference["replication"][name] genes, g = result.genes, theirs["genes"] if any(not np.array_equal(genes[c], g[i]) for i, c in enumerate(counts)): @@ -769,6 +779,11 @@ def check_replication(analyses, reference): worst["pairs"] = max( worst["pairs"], difference(pairs["pi1"][known], r[5][known]) ) + if SETTINGS[s][-1] is None: # pi1 by default, against pi0est(lambda = 0.5) + worst["default"] = max( + worst["default"], difference(pairs["pi1"][known], r[5][known]) + ) + by_default += int(known.sum()) compared += int(known.sum()) stops += int(np.count_nonzero(~known & ~np.isnan(pairs["pi1"]))) f, found_in = theirs["found_in"], result.found_in @@ -782,6 +797,7 @@ def check_replication(analyses, reference): report(f"{reml} replications with REML: Q, its p-value, I^2 and tau^2", "rma.uni", worst["reml"], CLOSE), report(f"{n - reml} replications with DerSimonian-Laird: the same", "rma.uni", worst["dl"], EXACT), report(f"{n} replications, pairs of studies: genes found, sign agreement, {compared} values of pi1", "pi0est", worst["pairs"], EXACT), + report(f"pi1 by default (null_proportion left out), {by_default} values: pi0 at lambda = 0.5", "pi0est(lambda = 0.5)", worst["default"], EXACT), report(f"{n} replications: genes found in at least k studies, and in one direction", "R", worst["found_in"], 0.0, "mismatches"), behaviour(f"pi1 of {stops} pairs where qvalue stops: no p-value at its largest lambda, or an estimate of 0", "pi0est", "qvalue: an error; CytePool: an estimate"), ] # fmt: skip