diff --git a/.gitignore b/.gitignore index 977d7ee..c1df5e4 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,10 @@ __pycache__ .hypothesis .env ._* +.snakemake + +# Workflow output directories +**/simple_workflow/*/output/ data exports diff --git a/.gitmodules b/.gitmodules index 5bca6a6..e69de29 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,4 +0,0 @@ -[submodule "my_datalad_repo"] - path = my_datalad_repo - url = ./my_datalad_repo - datalad-id = 74807713-a6cf-4418-9dfc-e490a881645b diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..5e0589a --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,93 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +This is an open-source book on building better code for science using AI, authored by Russell Poldrack. The rendered book is published at https://poldrack.github.io/BetterCodeBetterScience/. + +## Build Commands + +```bash +# Install dependencies (uses uv package manager) +uv pip install -r pyproject.toml +uv pip install -e . + +# Build book as HTML and serve locally +myst build --html +npx serve _build/html + +# Build PDF (requires LaTeX) +jupyter-book build book/ --builder pdflatex + +# Clean build artifacts +rm -rf book/_build +``` + +## Testing + +```bash +# Run all tests +pytest + +# Run tests with coverage +pytest --cov=src/BetterCodeBetterScience --cov-report term-missing + +# Run specific test modules +pytest tests/textmining/ +pytest tests/property_based_testing/ +pytest tests/narps/ + +# Run tests with specific markers +pytest -m unit +pytest -m integration +``` + +Test markers defined in pyproject.toml: `unit` and `integration`. + +## Linting and Code Quality + +```bash +# Spell checking (configured in pyproject.toml) +codespell + +# Python linting and formatting +ruff check . +ruff format . + +# Pre-commit hooks (runs codespell) +pre-commit run --all-files +``` + +## Project Structure + +- `book/` - MyST markdown chapters (configured in myst.yml) +- `src/BetterCodeBetterScience/` - Example Python code referenced in book chapters +- `tests/` - Test examples demonstrating testing concepts from the book +- `data/` - Data files for examples +- `scripts/` - Utility scripts +- `_build/` - Build output (gitignored) + +## Key Configuration Files + +- `myst.yml` - MyST book configuration (table of contents, exports, site settings) +- `pyproject.toml` - Python dependencies, pytest config, codespell settings +- `.pre-commit-config.yaml` - Pre-commit hooks (codespell) + +## Contribution Guidelines + +- New text should be authored by a human (AI may be used to check/improve text) +- Code examples should follow PEP8 +- Avoid introducing new dependencies when possible +- Custom words for codespell are in `project-words.txt` + +## Coding guidelines + +## Notes for Development + +- Think about the problem before generating code. +- Write code that is clean and modular. Prefer shorter functions/methods over longer ones. +- Prefer reliance on widely used packages (such as numpy, pandas, and scikit-learn); avoid unknown packages from Github. +- Do not include *any* code in `__init__.py` files. +- Use pytest for testing. +- Use functions rather than classes for tests. Use pytest fixtures to share resources between tests. diff --git a/Makefile b/Makefile index 7cd3860..cadd7fe 100644 --- a/Makefile +++ b/Makefile @@ -1,12 +1,16 @@ clean: - rm -rf book/_build -build: clean - uv run jupyter-book build book/ +build-html: clean + myst build --html + npx serve _build/html -pdf: +build-pdf: jupyter-book build book/ --builder pdflatex +check-links: + check-links + pipinstall: uv pip install -r pyproject.toml uv pip install -e . diff --git a/book/extras.md b/book/extras.md index bc62202..615fb0a 100644 --- a/book/extras.md +++ b/book/extras.md @@ -329,3 +329,12 @@ Found 422 publications containing Memory in the title One very nice feature of the document store is that not all records have to have the same keys; this provides a great deal of flexibility at data ingestion. However, too much heterogeneity between documents can make the database hard to work with. One benefit of homogeneity in the document structure is that it allows indexing, which can greatly increase the speed of queries in large document stores. For example, if we know that we will often want to search by the `year` field, then we can add an index for this field: *MORE HERE* + + +### NARPS + +The example comes from a paper that we published in 2020 {cite:p}`Botvinik-Nezer:2020aa`, which involved analysis of data from a large study called the Neuroimaging Analysis Replication and Prediction Study (hereafter *NARPS* for short). The goal of this study was to identify how the results of data analysis varied between different research groups when given the same data. A relatively large neuroimaging dataset was collected and distributed to groups of researchers, who were asked to test a set of nine hypotheses about brain activity in relation to a monetary gambling task that the participants performed during MRI scanning. Seventy teams submitted results, which included their answers to the 9 yes/no hypotheses along with a detailed description of their analysis workflow and a number of outputs from intermediate stages of the analysis. The main finding was that there was a striking amount of variability in the results between teams, even though the raw data were identical. + +The workflow that I will use here starts with the results that the teams submitted, and ends with preprocessed data that are ready for further statistical analysis. I wrote much of the original analysis code for the project, which can be found [here](https://github.com/poldrack/narps). This code was written at the point when I was just becoming interested in software engineering practices for science, and while it represents a first step in that direction, it has *a lot* of problems. In particular, it uses the problematic *God object* anti-pattern that I mentioned in an earlier chapter. For the purposes of this chapter I have first rewritten the analysis into a monolithic mega-script, which I will then incrementally refactor into a well-structured workflow. I chose this example because it is relatively complex yet runs quickly on any modern laptop. + + diff --git a/book/images/simple-DAG.png b/book/images/simple-DAG.png new file mode 100644 index 0000000..aa0abe0 Binary files /dev/null and b/book/images/simple-DAG.png differ diff --git a/book/images/snakemake-DAG.png b/book/images/snakemake-DAG.png new file mode 100644 index 0000000..231ddf5 Binary files /dev/null and b/book/images/snakemake-DAG.png differ diff --git a/book/software_engineering.md b/book/software_engineering.md index 90a9bd8..b6b1575 100644 --- a/book/software_engineering.md +++ b/book/software_engineering.md @@ -69,7 +69,7 @@ User stories are also useful for thinking through the potential impact of new fe Perhaps the most common example of violations of YAGNI comes about in the development of visualization tools. In this example, the developer might decide to create an visualizer to show how the original dataset is being converted into the new format, with interactive features that would allow the user to view features of individual files. The question that you should always ask yourself is: What user stories would this feature address? If it's difficult to come up with stories that make clear how the feature would help solve particular problems for users, then the feature is probably not needed. "If you build it, they will come" might work in baseball, but it rarely works in scientific software. -This is the reason that one of us (RP) regularly tells his trainees to post a note in their workspace with one simple mantra: "MVP". +This is the reason that I regularly tells my trainees to post a note in their workspace with one simple mantra: "MVP". ## Refactoring code @@ -954,7 +954,7 @@ def get_subject_label(file): return None ``` -When one of us asked the question "Should there ever be a file path that doesn't include a subject label?", the answer was "No", meaning that this code allows what amounts to an error to occur without announcing its presence. +When I asked the question "Should there ever be a file path that doesn't include a subject label?", the answer was "No", meaning that this code allows what amounts to an error to occur without announcing its presence. When we looked at the place where this function was used in the code, there was no check for whether the output was `None`, meaning that such an error would go unnoticed until it caused an error later when `subject_label` was assumed to be a string. Also note that the docstring for this function is misleading, as it states that a message will be printed if the return value is `None`, but no message is actually printed. In general, printing a message is a poor way to signal the potential presence of a problem, particularly if the code has a large amount of text output in which the message might be lost. diff --git a/book/workflows.md b/book/workflows.md index 5e43fdd..4fea77a 100644 --- a/book/workflows.md +++ b/book/workflows.md @@ -1,30 +1,767 @@ # Workflow Management -- discuss fit-transform model somewhere +In most parts of science today, data processing and analysis comprise many different steps. We will refer to such a set of steps as a computational *workflow*. If you have been doing science for very long, you have very likely encountered a *mega-script* that implements such a workflow. Usually written in a scripting language like *Bash*, this is a script that may be hundreds or even thousands of lines long that runs a single workflow from start to end. Often these scripts are handed down to new trainees over generations, such that users become afraid to make any changes lest the entire house of cards comes crashing down. I think that most of us can agree that this is not an optimal workflow, and in this chapter I will discuss in detail how to move from a mega-script to a workflow that will meet all of the requirements to provide robust and reliable answers to our scientific questions. -https://workflowhub.eu/ +## What do we want from a scientific workflow? +First let's ask: What do we want from a computational scientific workflow? Here are some of the factors that I think are important. First, we care about the *correctness* of the workflow, which includes the following factors: -### Russ's First Law of Scientific Data Management +- *Validity*: The workflow includes validation procedures to ensure against known problems or edge cases. +- *Reproducibility*: The workflow can be rerun from scratch on the same data and get the same answer, at least within the limits of uncontrollable factors such as floating point imprecision. +- *Robustness*: When there is a problem, the workflow fails quickly with explicit error messages, or degrades gracefully when possible. -> "Don't use spreadsheets to manage scientific data." +Second, we care about the *usability* of the workflow. Factors related to usability include: -In this chapter I will talk in detail about best practices for data management, but I start by discussing a data management "anti-pattern", which is the use of spreadsheets for data management. Spreadsheet software such as Microsoft Excel is commonly used by researchers for all sorts of data management and processing operations. Why are spreadsheets problematic? +- *Configurability*: The workflow uses smart defaults, but allows the user to easily change the configuration in a way that is traceable. +- *Parameterizability*: Multiple runs of the workflow can be executed with different parameters, and the separate outputs can be tracked. +- *Standards compliance*: The workflow leverages common standards to easily read in data and generates output using community standards for file formats and organization when available. -- They encourage manual manipulation of the data, which makes the operations non-reproducible by definition. -- Spreadsheet tools will often automatically format data, sometimes changing things in important but unwanted ways. For example, gene names such as "SEPT2" and "MARCH1" are converted to dates by Microsoft Excel, and some accession numbers (e.g., "2310009E13") are converted to floating point numbers. An analysis of published genomics papers {cite:p}`Ziemann:2016aa` found that roughly twenty percent of supplementary gene lists created using Excel contained errors in gene names due to these conversions. -- It is very easy to make errors when performing operations on a spreadsheet, and these errors can often go unnoticed. A well known example occurred in the paper ["Growth in the time of debt"](https://www.nber.org/papers/w15639) by the prominent economists Carmen Reinhart and Kenneth Rogoff. This paper claimed to have found that high levels of national debt led to decreased economic growth, and was used as a basis for promoting austerity programs after the 2008 financial crisis. However, [researchers subsequently discovered](https://academic.oup.com/cje/article/38/2/257/1714018) that the authors had made an error in their Excel spreadsheet, excluding data from several countries; when the full data were used, the relationship between growth and debt became much weaker. -- Spreadsheet software can sometimes have limitations that can cause problems. For example, the use of an outdated Microsoft Excel file format (.xls) [caused underreporting of COVID-19 cases](https://www.bbc.com/news/technology-54423988) due to limitations on the number of rows in that file format, and the lack of any warnings when additional rows in the imported data files were ignored. -- Spreadsheets do not easily lend themselves to version control and change tracking, although some spreadsheet tools (such as Google Sheets) do provide the ability to clearly label versions of the data. +Third, we care about the *engineering quality* of the code, which includes: -I will occasionally use Microsoft Excel to examine a data file, but I think that spreadsheet tools should *never* be used as part of a scientific data workflow. +- *Maintainability*: The workflow is structured and documented so that others (including your future self) can easily maintain, update, and extend it in the future. +- *Modularity*: The workflow is composed of a set of independently testable modules, which can be swapped in or out relatively easily. +- *Idempotency*: This term from computer science means that the result of the workflow does not change after its first successful run, which allows safely rerunning the workflow. +- *Traceability*: All operations are logged, and provenance information is stored for outputs. +Finally, we care about the *efficiency* of the workflow implementation. This includes: +- *Incremental execution*: The workflow only reruns a module if necessary, such as when an input changes. +- *Cached computation*: The workflow pre-computes and reuses results from expensive operations when possible. -## Simple workflow management with Makefiles +It's worth noting that these different desiderata will sometimes conflict with one another (such as configurability versus maintainability), and that no workflow will be perfect. For example, a highly configurable workflow will often be more difficult to maintain. +## Pipelines versus workflows + +The terms *workflow* and *pipeline* are sometimes used interchangeably, but in this chapter I will use them to refer to different kinds of applications. I will use *workflow* as the more general term to refer to any set of analysis procedures that are implemented as separate modules. I will use the term *pipeline* to refer more specifically to a data analysis workflow where several operations are combined into a single command through the use of *pipes*, which are a syntactic construct that feed the results of one process directly into the next process. Some readers may be familiar with pipes from the UNIX command line, where they are represented by the vertical bar "|". For example, let's say that we had a log file that contains the following entries: + +```bash +2024-01-15 10:23:45 ERROR: Database connection failed +2024-01-15 10:24:12 ERROR: Invalid user input +2024-01-15 10:25:33 ERROR: Database connection failed +2024-01-15 10:26:01 INFO: Request processed +2024-01-15 10:27:15 ERROR: Database connection failed +``` + +and that we wanted to generate a summary of errors. We could use the following pipeline: + +```bash +grep "ERROR" app.log | sed 's/.*ERROR: //' | sort | uniq -c | sort -rn > error_summary.txt + +``` + +where: + +- `grep "ERROR" app.log` extracts lines containing the word "ERROR" +- `sed 's/.*ERROR: //'` replaces everything up to the actual message with an empty string +- `sort` sorts the rows alphabetically +- `uniq -c` counts the number of appearances of each unique error message +- `sort -rn` sorts the rows in reverse numerical order (largest to smallest) +- `> error_summary.txt` redirects the output into a file called `error_summary.txt` + +Pipes are also commonly used in the R ecosystem, where they are a fundamental component of the *tidyverse* group of packages. + +#### Method chaining + +One way that simple pipelines can be built in Python is using *method chaining*, where each method returns an object on which the next method is called; this is slightly different from the operation of UNIX pipes, where it is the result of each command that is being passed through the pipe. This is commonly used to perform data transformations in `pandas`, as it allows composing multiple transformations into a single command. As an example, we will work with the Eisenberg et al. dataset that we used in a previous chapter, to compute the probability of having ever been arrested separately for males and females in the sample. To do this we need to perform a number of operations: + +- drop any observations that have missing values for the `Sex` or `ArrestedChargedLifeCount` variables +- replace the numeric values in the `Sex` variable with text labels +- create a new variable called `EverArrested` that binarizes the counts in the ArrestedChargedLifeCount variable +- group the data by the `Sex` variable +- select the column that we want to compute the mean of (`EverArrested`) +- compute the mean + +We can do this in a single command using method chaining in `pandas`. It's useful to format the code in a way that makes the pipeline steps explicit, by putting parentheses around the operation; in Python, any commands within parentheses are implicitly treated as a single line, which can be useful for making complex code more readable: + +```python +arrest_stats_by_sex = (df + .dropna(subset=['Sex', 'ArrestedChargedLifeCount']) + .replace({'Sex': {0: 'Male', 1: 'Female'}}) + .assign(EverArrested=lambda x: (x['ArrestedChargedLifeCount'] > 0).astype(int)) + .groupby('Sex') + ['EverArrested'] + .mean() +) +print(arrest_stats_by_sex) +``` +```bash +Sex +Female 0.156489 +Male 0.274131 +Name: EverArrested, dtype: float64 +``` + +Note that `pandas` data frames also include an explicit `.pipe` method that allows using arbitrary functions within a pipeline. While these kinds of pipelines can be useful for simple data processing operations, they can become very difficult to debug, so I would generally avoid using complex functions within a method chain. + + +## FAIR-inspired practices for workflows + - FAIR workflows + - https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699/ + - https://www.nature.com/articles/s41597-025-04451-9 + - this seems really heavyweight. + - 80/20 approach to reproducible workflows + - version control + documentation + - requirements file or container + - clear workflow structure + - standard file formats + - The full FAIR approach may be necessary in some contexts + +In the earlier chapter on Data Management I discussed the FAIR (Findable, Accessible, Interoperable, and Reusable) principles for data. Since those principles were proposed in 2016 they have been extended to many other types of research objects, including workflows (REFS - https://www.nature.com/articles/s41597-025-04451-9). The reader who is not an informatician is likely to quickly glaze over when reading these articles, as they ... + +Realizing that most scientists are unlikely to go to the lengths of a fully FAIR workflow, and preferring that the perfect never be the enemy of the good, I think that we can take an "80/20" approach, meaning that we can get 80% of the benefits for about 20% of the effort. We can adhere to the spirit of the FAIR Workflows principle by adopting the following principles, based in part on the "Ten Quick Tips for FAIR Workflows" presented by de Visser et al., (2023; https://pmc.ncbi.nlm.nih.gov/articles/PMC10538699): + +- *Metadata*: Provide sufficient metadata in a standard machine-readable format to make the workflow findable once it is shared. +- *Version control*: All workflow code should be kept under version control and hosted on a public repository such as Github. +- *Documentation*: Workflows should be well documented. Documentation should focus primarily on the scientific motivation and technical design of the workflow, along with instructions on how to run it and description of the outputs. +- *Standard organization schemes*: Both the workflow files (code and configuration) and data files should follow established standards for organization. +- *Standard file formats*: The inputs and outputs to the workflow should use established standard file formats rather than inventing new formats. +- *Configurability*: The workflow should be easily configurable, and example configuration files should be included in the repository. +- *Requirements*: The requirements for the workflow should be clearly specified, either in a file (such as `pyproject.toml` or `requiremets.txt`) or in a container configuration file (such as a Dockerfile). +- *Clear workflow structure*: The workflow structure should be easily understandable. + +There are certainly some contexts where a more formal structure adhering in detail to the FAIR Workflows standard may be required, as in large collaborative projects with specific compliance objectives, but these rough guidelines should get a researcher most of the way there. + + +## A simple workflow example + +Most real scientific workflows are complex and can often run for hours, and we will encounter such a complex workflow later in the chapter. However, we will start our discussion of workflows with a relatively simple and fast-running example that will help demonstrate the basic concepts of workflow execution. We will use the same data as above (from Eisenberg et al.) to perform a simple workflow: + +- Load the demographic and meaningful variables files +- Filter out any non-numeric variables from each data frame +- Join the data frames using their shared index +- Compute the correlation matrix across all variables +- Generate a clustered heatmap for the correlation matrix + +I have implemented each of these components as a module [here](). The simplest possible workflow would be a script that simply imnports and calls each of the methods in turn. For such a simple workflow this would be fine, but we will use the example to show how we might take advantage of more sophisticated workflow management tools. + +### Running a simple workflow using GNU make + +One of the simplest ways to organize a workflow is using the GNU `make` command, which executes commands defined in a file named `Makefile`. `make` is a very handy general-purpose tool that every user of UNIX systems should become familiar with. The Makefile defines a set of labeled commands, like this: + +```Makefile + +all: step1 step2 + +step1: + python step1.py + +step2: + python step2.py +``` + +In this case, the command `make step1` will run `python step1.py`, `make step2` will run `python step2.py`, and `make all` will run both of those commands. This should already show you why `make` is such a handy tool: Any time there is a command that you run regularly in a particular directory, you can put it into a `Makefile` and then execute it with just a single `make` call. Here is how we could build a very simple Makefile to run our simple workflow: + +```Makefile +# Simple Correlation Workflow using Make +# +# Usage: +# make all - Run full workflow +# make clean - Remove output directory + +# if OUTPUT_DIR isn't already defined, set it to the default +OUTPUT_DIR ?= ./output + +# run commands even if files exist with these names +.PHONY: all clean + +all: + mkdir -p $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures + python scripts/download_data.py $(OUTPUT_DIR)/data + python scripts/filter_data.py $(OUTPUT_DIR)/data + python scripts/join_data.py $(OUTPUT_DIR)/data + python scripts/compute_correlation.py $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results + python scripts/generate_heatmap.py $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures + +clean: + rm -rf $(OUTPUT_DIR) +``` + +We can run the entire workflow by simply running `make all`. We could also take advantage of another feature of `make`: it only triggers the action if a file with the name of the action doesn't exist. Thus, if the command was `make results/output.txt`, then the action would only be triggered if the file does not exist. This is why we had to put the `.PHONY` command in the makefile above: it's telling `make` that those are not meant to be interpreted as file names, but rather as commands, so that they will be run even if files named "all" or "clean" exist. + +For a very simple workflow `make` can be useful, but we will see below why this wouldn't be sufficient for a complex workflow. For those workflows we could either build our own more complex workflow management system, or we could use an existing software tool that is built to manage workflow execution, known as a *workflow engine*. Later in the chapter I will show an example of a purpose-built workflow management system, but for this first example we will now turn to a general-purpose workflow engine. + +### Using a workflow engine + +There is a wide variety of workflow engines available for data analysis workflows, most of which are centered around the concept of an "execution graph". This is a graph in the sense described by graph theory, which refers to a set of nodes that are connected by lines (known as "edges"). Workflow execution graphs are a particular kind of graph known as a *directed acyclic graph*, or *DAG* for short. Each node in the graph represents a single step in the workflow, and each edge represents the dependency relationships that exist between nodes. DAGs have two important features. First, the edges are directed, which means that they move in one direction that is represented graphically as an arrow. These represent the dependencies within the workflow. For example, in our workflow step 1 (obtaining the data) must occur before step 2 (filtering the data), so the graph would have an edge from step 1 with an arrow pointing at step 2. Second, the graph is *acyclic*, which means that it doesn't have any cycles, that is, it never circles back on itself. Cycles would be problematic, since they could result in workflows that executed in an infinite loop as the cycle repeated itself. + +Most workflow engines provide tools to visualize a workflow as a DAG. #simpleDAG-fig shows our example workflow visualized using the Snakemake tool that we will introduce below: + +```{figure} images/simple-DAG.png +:label: simpleDAG-fig +:align: center +:width: 300px + +The execution graph for the simple example analysis workflow visualized as a DAG. +``` + +The use of DAGs to represent workflows provides a number of important benefits: + +- The engine can identify independent pathways through the graph, which can then be executed in parallel +- If one node of the graph changes, the engine can identify which downstream nodes need to be rerun +- If a node fails, the engine can continue with executing the nodes that don't depend on the failed node either directly or indirectly + +There are a couple of additional benefits to using a workflow engine, which we will discuss in more detail in the context of a more complex workflow. The first is that they generally deal automatically with the storage of intermediate results (known as *checkpointing*), which can help speed up execution when nothing has changed. The second is that the workflow engine uses the execution graph to optimize the computation, only performing those operations that are actually needed. This is similar in spirit to the concept of *lazy execution* used by packages like Polars, in which the system optimizes computational efficiency by first analyzing the full computational graph. + +### General-purpose versus domain-specific workflow engines + +With the growth of data science within industry and research, there has been an explosion of new workflow management systems that aim to solve particular problems; a list of these can be found at [awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines). It's also worth noting that there are a number of domain-specific workflow engines that are specialized for particular kinds of data and workflows. Examples include [Galaxy](https://galaxyproject.org/) which is specialized for bioinformatics and genomics, and [Nipype](https://nipype.readthedocs.io/en/latest/index.html) which is specialized for neuroimaging analysis workflows. If your research community uses one of these then it's worth exploring that engine as your first option, since it will probably be well supported within the community. However, a benefit of using a general-purpose engine is that they will often be better maintained and supported, and AI tools will likely have more examples to work from in generating workflows. + +### Workflow management using Snakemake + +We will use the Snakemake workflow system for our example, which I chose for several reasons: + +- It is a very well-established project that is actively maintained. +- It is Python-based, which makes it easy for Python users to grasp. +- Because of its long history and wide use, AI coding assistants are quite familiar with it and can easily generate the necessary files for complex workflows. + +Snakemake is a sort of "make on steroids", designed specifically to manage complex computational workflows. It uses a Python-like syntax to define the workflow, from which it infers the computational graph and optimizes the computation. The Snakemake workflow is defined using a `Snakefile`, the most important aspect of which is a set of rules that define the different workflow steps in terms of their outputs. Here is an initial portion of the `Snakefile` for our simple workflow: + +```Python +# Load configuration +configfile: "config/config.yaml" + +# Global report +report: "report/workflow.rst" + +OUTPUT_DIR = Path(config["output_dir"]) +DATA_DIR = OUTPUT_DIR / "data" +RESULTS_DIR = OUTPUT_DIR / "results" +FIGURES_DIR = OUTPUT_DIR / "figures" + +# Default target +rule all: + input: + FIGURES_DIR / "correlation_heatmap.png", +``` + +What this does is first specify the configuration file, which is a YAML file that defines various parameters for the workflow. Here are the contents of the config file for our simple example: + +```bash +# Data URLs +meaningful_variables_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv" +demographics_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv" + +# Correlation settings +correlation_method: "spearman" + +# Heatmap settings +heatmap: + figsize: [12, 10] + cmap: "coolwarm" + vmin: -1.0 + vmax: 1.0 +``` + +The only rule shown here is the `all` rule, which takes as its input the correlation figure that is the final output of the workflow. If snakemake is called and that file already exists, then it won't be rerun (since it's the only requirement for the rule) unless 1) the `--force` flag is included, which forces rerunning the entire workflow, or 2) a rerun is triggered by one of the changes that Snakemake looks for (discussed more below). If the file doesn't exist, then Snakemake examines the additional rules to determine which steps need to be run in order to generate that output. In this case, it would start with the rule that generates the correlation figure: + +```python +# Step 5: Generate clustered heatmap +rule generate_heatmap: + input: + RESULTS_DIR / "correlation_matrix.csv", + output: + report( + FIGURES_DIR / "correlation_heatmap.png", + caption="report/heatmap.rst", + category="Results", + ), + params: + figsize=config["heatmap"]["figsize"], + cmap=config["heatmap"]["cmap"], + vmin=config["heatmap"]["vmin"], + vmax=config["heatmap"]["vmax"], + log: + OUTPUT_DIR / "logs" / "generate_heatmap.log", + script: + "scripts/generate_heatmap.py" +``` + +This step uses the `generate_heatmap.py` script to generate the correlation figure, and it requires the `correlation_matrix.csv` file as input. Snakemake would then work backward to identify which step is required to generate that file, which is the following: + +```python +# Step 4: Compute correlation matrix +rule compute_correlation: + input: + DATA_DIR / "joined_data.csv", + output: + RESULTS_DIR / "correlation_matrix.csv", + params: + method=config["correlation_method"], + log: + OUTPUT_DIR / "logs" / "compute_correlation.log", + script: + "scripts/compute_correlation.py" +``` + +By working backwards this way from the intended output, Snakemake can reconstruct the computational graph that we saw in #simpleDAG-fig. It then uses this graph to plan the computations that will be performed. + + +#### Snakemake scripts + +In order for Snakemake to execute each of our modules, we need to wrap those modules in a script that can use the configuration information from the config file. Here is an example of what the [generate_heatmap.py]() script would looks like: + +```python +from pathlib import Path +import pandas as pd +from BetterCodeBetterScience.simple_workflow.visualization import ( + generate_clustered_heatmap, +) + +def main(): + """Generate and save clustered heatmap.""" + # ruff: noqa: F821 + input_path = Path(snakemake.input[0]) + output_path = Path(snakemake.output[0]) + figsize = tuple(snakemake.params.figsize) + cmap = snakemake.params.cmap + vmin = snakemake.params.vmin + vmax = snakemake.params.vmax + + # Load correlation matrix + corr_matrix = pd.read_csv(input_path, index_col=0) + print(f"Loaded correlation matrix: {corr_matrix.shape}") + + # Generate heatmap + output_path.parent.mkdir(parents=True, exist_ok=True) + generate_clustered_heatmap( + corr_matrix, + output_path=output_path, + figsize=figsize, + cmap=cmap, + vmin=vmin, + vmax=vmax, + ) + print(f"Saved heatmap to {output_path}") + +if __name__ == "__main__": + main() +``` + +You can see that the code refers to `snakemake` even though we haven't explicitly imported it; this is possible because the script is executed within the Snakemake environment which makes that object available, which contains all of the configuration details. + +- Dry run + +```bash +Config file config/config.yaml is extended by additional config specified via the command line. +host: Russells-MacBook-Pro.local +Building DAG of jobs... +Job stats: +job count +----------------------------- ------- +all 1 +compute_correlation 1 +download_demographics 1 +download_meaningful_variables 1 +filter_demographics 1 +filter_meaningful_variables 1 +generate_heatmap 1 +join_datasets 1 +total 8 + +... (omitting intermediate output) + +Job stats: +job count +----------------------------- ------- +all 1 +compute_correlation 1 +download_demographics 1 +download_meaningful_variables 1 +filter_demographics 1 +filter_meaningful_variables 1 +generate_heatmap 1 +join_datasets 1 +total 8 + +Reasons: + (check individual jobs above for details) + input files updated by another job: + all, compute_correlation, filter_demographics, filter_meaningful_variables, generate_heatmap, join_datasets + output files have to be generated: + compute_correlation, download_demographics, download_meaningful_variables, filter_demographics, filter_meaningful_variables, generate_heatmap, join_datasets +This was a dry-run (flag -n). The order of jobs does not reflect the order of execution. +``` + +Once we have confirmed that everything is set up properly, we can then use `snakemake` to run the workflow: + +```bash +➤ snakemake --cores 1 --config output_dir=./output +Config file config/config.yaml is extended by additional config specified via the command line. +Assuming unrestricted shared filesystem usage. +host: Russells-MacBook-Pro.local +Building DAG of jobs... +Using shell: /bin/bash +Provided cores: 1 (use --cores to define parallelism) +Rules claiming more threads will be scaled down. +Job stats: +job count +----------------------------- ------- +all 1 +compute_correlation 1 +download_demographics 1 +download_meaningful_variables 1 +filter_demographics 1 +filter_meaningful_variables 1 +generate_heatmap 1 +join_datasets 1 +total 8 + +Select jobs to execute... +Execute 1 jobs... + +[Wed Dec 24 08:17:57 2025] +localrule download_demographics: + output: output/data/demographics.csv + log: output/logs/download_demographics.log + jobid: 7 + reason: Missing output files: output/data/demographics.csv + resources: tmpdir=/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T +Downloaded 522 rows from https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv +Saved to output/data/demographics.csv +[Wed Dec 24 08:17:58 2025] +Finished jobid: 7 (Rule: download_demographics) +1 of 8 steps (12%) done + +... (omitting intermediate output) + +8 of 8 steps (100%) done +Complete log(s): .snakemake/log/2025-12-24T081757.266320.snakemake.log +``` + +One handy feature of snakemake is that, just like `make`, we can give it a specific target file and it will perform only the portions of the workflow that are required to regenerate that specific file. + +#### Best practices for Snakemake workflows + +The Snakemake team has published a set of [best practices](https://snakemake.readthedocs.io/en/stable/snakefiles/best_practices.html) for the creation of Snakemake workflows, some of which I will outline here, along with one of my own (the first). + +#### Using a working directory- TBD +By default Snakemake looks for a Snakefile in the current directory, so it's tempting to run the workflow from the code repository. However, Snakemake creates a directory called `.snakemake` to store metadata in the directory where the workflow is run, which one generally doesn't want to mix with the code. Thus, it's best to create a working directory with its own copy of the config file (to allow local modifications), and then run the command from that directory using the + +##### Workflow organization +There is a [standard format](https://snakemake.readthedocs.io/en/stable/snakefiles/deployment.html#distribution-and-reproducibility) for the organization of Snakemake workflow directories, which one should follow when developing new workflows. + +##### Snakefile formatting +Snakemake comes with a set of commands that help ensure that Snakemake files are properly formatted and follow best practices. First, there is a static analysis tool (i.e a "linter", akin to ruff or flake8 for Python code), which can automatically identify problems with Snakemake rule files. Unfortunately, this tool assumes that one is using the Conda environment manager (which is increasingly being abandoned in favor of uv) or a container (which comes with substantial overhead), and it raises an issue for any rule that doesn't specify a Conda or container environment. Nonetheless, if those are ignored the linter can be useful in identifying problems. There is also a formatting tool called `snakefmt` (separately installed) that optimally formats Snakemake files in the way that `black` or `blue` format Python code. These can both be useful tools when developing a new workflow. + +##### Configurability +Workflow configuration details should be stored in configuration files, such as the `config.yaml` files that we have used in our workflow examples. However, these files should not be used for runtime parameters, such as the number of cores or the output directory; those should instead be handled using Snakemake's standard arguments. The initial workflow generated by Claude did not follow this guidance, and instead custom variables to define runtime details such as the output directory and the number of cores. (TBD - CHECK THIS) + +#### Updating the workflow when inputs change + +Once the workflow has completed successfully, re-running it will not result in the re-execution of any of the analyses: + +```bash +snakemake --cores 1 --config output_dir=/Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake +Config file config/config.yaml is extended by additional config specified via the command line. +Assuming unrestricted shared filesystem usage. +host: Russells-MacBook-Pro.local +Building DAG of jobs... +Nothing to be done (all requested files are present and up to date). +``` + +However, Snakemake checks several features of the workflow (by default) when generating its DAG to see if anything relevant has changed. By default it checks to see if any of the following have changed (configurable using the `-rerun-triggers` flag): + +- modification times of input files +- the code specified within the rule +- the input files or parameters for the rule + +Snakemake also checks for changes in the details of the software environment, but as of the date of writing this only works for Conda environments. + +As an example, I will first update the modification time of the demographics file from a previous successful run using the `touch` command: + +```bash +➤ ls -l data/meaningful_variables.csv +Permissions Size User Date Modified Name +.rw-r--r--@ 1.2M poldrack 24 Dec 10:11 data/meaningful_variables.csv + +➤ touch data/meaningful_variables.csv + +➤ ls -l data/meaningful_variables.csv +Permissions Size User Date Modified Name +.rw-r--r--@ 1.2M poldrack 24 Dec 10:14 data/meaningful_variables.csv +``` + +You can see that the touch command updated the modification time of the file. Now let's rerun the `snakemake` command: + +```bash +snakemake --cores 1 --config output_dir=/Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake +Config file config/config.yaml is extended by additional config specified via the command line. +Assuming unrestricted shared filesystem usage. +host: Russells-MacBook-Pro.local +Building DAG of jobs... +Using shell: /bin/bash +Provided cores: 1 (use --cores to define parallelism) +Rules claiming more threads will be scaled down. +Job stats: +job count +--------------------------- ------- +all 1 +compute_correlation 1 +filter_meaningful_variables 1 +generate_heatmap 1 +join_datasets 1 +total 5 +``` + +Similarly, Snakemake will rerun the workflow if any of the scripts used to run the workflow are modified. However, it's important to note that it will not identify changes in the modules that are imported. In that case you would need to rerun the workflow in order to re-execute the relevant steps. + +## Scaling to a complex workflow + +We now turn to a more realistic and complex scientific data analysis workflow. For this example I will use an analysis of single-cell RNA-sequencing data to determine how gene expression in immune system cells changes with age. This analysis will utilize a [large openly available dataset](https://cellxgene.cziscience.com/collections/dde06e0f-ab3b-46be-96a2-a8082383c4a1) that includes data from 982 people comprising about 1.3 million peripheral blood mononuclear cells (i.e. white blood cells) for about 35K transcripts. I chose this particular example for several reasons: + +- It is a realistic example of a workflow that a researcher might actually perform. +- It has a large enough sample size to provide a robust answer to our scientific question. +- The data are large enough to call for a real workflow management scheme, but small enough to be processed on a single laptop (assuming it has decent memory). +- The workflow has many different steps, some of which can take a significant amount of time (over 30 minutes) +- There is an established Python library ([scanpy](https://scanpy.readthedocs.io/en/stable/)) that implements the necessary workflow components. +- It's an example outside of my own research domain, to help demonstrate the applicability of the book's ideas across a broader set of data types. + +I will use this example to show how to move from a monolithic analysis script to a well-structured and usable workflow that meets most of the desired features described above. + +### Starting point: One huge notebook + +I developed the initial version of this workflow as many researchers would: by creating a Jupyter notebook that implements the entire workflow, which can be found [here](). Although I don't usually prefer to do code generation using a chatbot, I did most of the coding for this example using the Google Gemini 3 chatbot, for a couple of reasons. First, this model seemed particularly knowledgeable about this kind of analysis and the relevant packages. Second, I found it useful to read the commentary about why particular analysis steps were being selected. For debugging I used a mixture of the Gemini 3 chatbot and the VSCode Copilot agent, depending on the nature of the problem; for problems specific to the RNA-seq analysis tools I used Gemini, while for standard Python/Pandas issues I used Copilot. The total execution time for this notebook is about two hours on an M3 Max Macbook Pro. + +#### The problem of in-place operations + +What I found as I developed the workflow is that I increasingly ran into problems that arose because the state of particular objects had changed. This occurred for two reasons at different points. In some cases it occurred because I saved a new version of the object to the same name, resulting in an object with different structure than before. Second, and more insidiously, it occurred when an object passed into a function is modified by the function internally. This is known as an *in-place* operation, in which a function modifies an object directly rather than returning a new object that can be assigned to a variable. + +In-place operations can make code particularly difficult to debug in the context of a Jupyter notebook, because it's a case where out-of-order execution can result in very confusing results or errors, since the changes that were made in-place may not be obvious. For this reason, I generally avoid any kind of in-place operations if possible. Rather, any functions should immediately create a copy of the object that was passed in, and then do its work on that copy, which is returned at the end of the function for assignment to a new variable. One can then re-assign it to the same variable name if desired, which is more transparent than an in-place operation but still makes the workflow dependent on the exact state of execution and can lead to confusion when debugging. Some packages allow a feature called "copy-on-write" which defers actually copying the data in memory until it is actually modified, which can make copying more efficient. + +If one must modify objects in-place, then it is good practice to announce this loudly. The loudest way to do this would be to put "inplace" in the function name. Another cleaner but less loud way is through conventions regarding function naming; for example, in PyTorch it is a convention that any function that ends with an underscore (e.g. `tensor.mul_(x)`) performs an in-place operation whereas the same function without the underscore (`tensor.mul(x)`) returns a new object. Another way that some packages enable explicit in-place operations is through a function argument (e.g. `inplace=True` in pandas), though this is being phased out from many functions in Pandas because "It is generally seen (at least by several pandas maintainers and educators) as bad practice and often unnecessary" ([PDEP-8](https://pandas.pydata.org/pdeps/0008-inplace-methods-in-pandas.html)). + +One way to prevent in-place operations altogether is to use data types that are *immutable*, meaning that they can't be changed once created. This is one of the central principles in *functional programming* languages (such as Haskell), where all data types are immutable, such that one is required to create a new object any time data are modified. Some native data types in Python are immutable (such as tuples and frozensets), and some data science packages also provide immutable data types; in particular, the Polars package (which is meant to be a high-performance alternative to pandas) implements its version of a data frame as an immutable object, and the JAX package (for high-performance numerical computation and machine learning) implements immutable numerical arrays. + +#### Converting from Jupyter notebook to a runnable python script + +As we discussed in an earlier chapter, converting a Jupyter notebook to a pure Python script is easy using `jupytext`. This results in a script that can be run from the command line. However, there can be some commands that will block execution of the script; in particular, plotting commands can open windows that will block execution until they are closed. To prevent this, and to ensure that the results of the plots are saved for later examination, I replaced all of the `plt.show()` commands that display a figure to the screen with `plt.savefig()` commands that save the figures to a file in the results directory. (This was an easy job for the Copilot agent to complete.) + +## Decomposing a complex workflow + +The first thing we need to do with a large monolithic workflow is to determine how to decompose it into coherent modules. There are various reasons that one might choose a particular breakpoint between modules. First and foremost, there are usually different stages that do conceptually different things. In our example, we can break the workflow into several high-level processes: + +- Data (down)loading +- Data filtering (removing subjects or cell types with insufficient observations) +- Quality control + - identifying bad cells on the basis of mitochondrial, ribosomal, or hemoglobin genes or hemoglobin contamination + - identifying "doublets" (multiple cells identified as one) +- Preprocessing + - Count normalization + - Log transformation + - Identification of high-variance features + - Filtering of nuisance genes +- Dimensionality reduction +- UMAP generation +- Clustering +- Pseudobulking +- Differential expression analysis +- Pathway enrichment analysis (GSEA) +- Overrepresentation analysis (Enrichr) +- Predictive modeling + +In addition to a conceptual breakdown, there are also other reasons that one might want to further decompose the workflow: + +- There may be points where one might need to restart the computation (e.g. due to computational cost). +- There may be sections where one might wish to swap in a new method or different parameterization. +- There may be points where the output could be reusable elsewhere. + +## Stateless workflows + +I asked Claude Code to help modularize the monolithic workflow, using a prompt that provided the conceptual breakdown described above. The resulting code (found at XXX - link to commit 678983e1c337b6a23b0f35cfb974a87587cfd13e) ran correctly, but crashed about two hours into the process due to a resource issue that appeared to be due to asking for too many CPU cores in the differential expression analysis. This left me in the situation of having to rerun the entire two hours of preliminary workflow simply to get to a point where I could test my fix for the differential expression component, which is not a particularly efficient way of coding. The problem here is that the workflow execution is *stateful*, in the sense that the previous steps need to be rerun prior to performing the current step in order to establish the required objects in memory. The solution to this problem is to implement the workflow in a *stateless* way, which doesn't require that earlier steps be rerun if they have already been completed. One way to do this is by implementing a process called *checkpointing*, in which intermediate results are stored for each step. These can then be used to start the workflow at any point without having to rerun all of the previous steps. + +Another important feature of a workflow related to statelessness is *idempotency*, which means that a workflow will result in the same answer when run multiple times. This is related to, but not the same as, the idea of statelessness. For example, a stateless workflow that saves its outputs to checkpoint files could fail to be idempotent if the results were appended to the output file with each execution, rather than overwriting them. This would result in different outputs depending on how many times the workflow has been executed. Thus, when we use checkpointing we should be sure to either reuse the existing file or rewrite it completely with a new version. + + +I asked Claude Code to help with this: + +> I would like to modify the workflow described in src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py to make it execute in a stateless way through the use of checkpointing. Please analyze the code and suggest the best way to accomplish this. + +After analyzing the codebase Claude came up with three proposed solutions to the problem: + +- 1. Use a "registry pattern" in which we define each step in terms of its inputs, outputs, and checkpoint file, and then assemble these into a workflow that can be executed in a stateless way, automatically skipping completed steps. This was its recommended approach. +- 2. Use simple "wrapper" approach in which each module in the workflow is executed via a wrapper function that checks for cached checkpoint values. +- 3. Use a well-established existing workflow engine such as [Prefect](https://www.prefect.io/) or [Luigi](https://github.com/spotify/luigi). While these are powerful, they incur additional dependencies and complexity and may be too heavyweight for our problem. + +Here we will examine the first (recommended) option and the third solution; while the second option is easy to implement, it's not as clean as the registry approach. + +### A workflow registry with checkpointing + +We start with a custom approach in order to get a better view of the details of workflow orchestration. It's important to note that I generally would not recommend building one's one custom workflow manager, at least not before trying a general-purpose workflow engine, but I will show an example of a custom workflow engine in order to provide a better understanding of the detailed process of workflow management. We start with a prompt: + +> let's implement the recommended Stateless Workflow with Checkpointing. Please generate new code within src/BetterCodeBetterScience/rnaseq/stateless_workflow. + +The resulting code worked straight out of the box, but it didn't maintain any sort of log of its processing, which can be very useful. In particular, I wanted to log the time required to execute each step in the workflow, for use in optimization that I will discuss further below. I asked Claude to add this: + +> I would like to log information about execution, including the time required to execute each step along with the details about execution such as parameters passed for each step. please record these during execution and save to a date-stamped json file within the workflows directory. + +After Claude's implementation of this feature, a fresh run of the workflow gives the following summary: + +```bash +============================================================ +EXECUTION SUMMARY +============================================================ +Workflow: immune_aging_scrnaseq +Run ID: 20251221_114458 +Status: completed +Total Duration: 7094.5 seconds + +Step Details: +------------------------------------------------------------ + ✓ Step 1: data_download 0.0s [cached] + ✓ Step 2: filtering 74.7s + ✓ Step 3: quality_control 263.3s + ✓ Step 4: preprocessing 35.9s + ✓ Step 5: dimensionality_reduction 6565.4s + ✓ Step 6: clustering 69.6s + ✓ Step 7: pseudobulking 11.6s + ✓ Step 8: differential_expression 19.0s + ✓ Step 9: gsea 1.7s + ✓ Step 10: overrepresentation 13.3s + ✓ Step 11: predictive_modeling 39.8s +------------------------------------------------------------ +``` + +The associated JSON file contains much more detail regarding each workflow step. If we run the workflow again, we see that it now uses cached results at each step: + +```bash +============================================================ +EXECUTION SUMMARY +============================================================ +Workflow: immune_aging_scrnaseq +Run ID: 20251221_142225 +Status: completed +Total Duration: 17.4 seconds + +Step Details: +------------------------------------------------------------ + ✓ Step 1: data_download 0.0s [cached] + ✓ Step 2: filtering 1.9s [cached] + ✓ Step 3: quality_control 3.0s [cached] + ✓ Step 4: preprocessing 3.1s [cached] + ✓ Step 5: dimensionality_reduction 3.4s [cached] + ✓ Step 6: clustering 4.3s [cached] + ✓ Step 7: pseudobulking 0.1s [cached] + ✓ Step 8: differential_expression 1.4s [cached] + ✓ Step 9: gsea 0.0s [cached] + ✓ Step 10: overrepresentation 0.0s [cached] + ✓ Step 11: predictive_modeling 0.0s [cached] +------------------------------------------------------------ +``` + +Checkpointing thus solved our problem, by allowing each step to be skipped over once it's been completed. + +#### Checkpointing and disk usage + +One potential drawback of checkpointing is that it can result in substantial disk usage when working with large datasets. In the example above, the checkpoint directory after workflow completion weighs in at a whopping 64 Gigabytes, with numerous very large files: + +```bash +➤ du -sh * + +7.3G step02_filtered.h5ad + 13G step03_qc.h5ad + 13G step04_preprocessed.h5ad + 14G step05_dimreduced.h5ad + 14G step06_clustered.h5ad +380M step07_pseudobulk.h5ad + 28M step08_counts.parquet +1.6M step08_de_results.parquet +1.8G step08_stat_res.pkl + 13M step09_gsea.pkl + 44K step10_enr_down.pkl + 28K step10_enr_up.pkl + 36K step11_prediction.pkl + ``` + +In particular, in step 3 a copy of the original data was added for reuse in a later step (in a separate variable within the dataset) alongside the results of processing at that step, leading to files that were roughly doubled in size. However, those raw data were not needed again until step 7. By changing the workflow to avoid saving those data in the checkpoints and instead loading them directly at step 7, we were able to halve the size of those intermediate checkpoints. + +In this implementation a checkpoint file was stored for each step in the workflow. However, if the goal of checkpointing is primarily to avoid having to rerun expensive computations, then we don't need to checkpoint every step given that some of them take relatively little time. In this case, we can checkpoint only after a subset of steps. In this case I chose to checkpoint after steps 2, 3, and 5 since those each take well over a minute to run (with step 5 taking well over an hour). Another goal of checkpointing is to store files that might be useful for later analyses or QA by the researcher. In this example workflow, steps 1-7 can be classified as "preprocessing" in the sense that they are preparing the data for analysis, whereas steps 8-11 reflect actual analyses of the data, such that the results could be reported in a publication. It is thus important to save those outputs for later analyses and for sharing with the final results. + +#### Compressing checkpoint files + +Another potentially helpful solution is to compress the checkpoint data if they are not already being compressed by default. In this example, the default in the AnnData package for saving `h5ad` files is to use no compression, so there are substantial savings in disk space to be had by compressing the data: whereas the raw data file was 7.3 GB, a version of the same data saved using compression took up only 2.9 GB. The tradeoff is that working with compressed files takes longer. This is particularly the case for saving of files; whereas it took about 3 seconds to save an uncompressed version of the data, it took about 105 seconds to store the compressed version. Given that the saving of the compressed file will happen in the context of an already long workflow, that doesn't seem like such a concern. We are more concerned about how the use of compression increases loading times, and here the difference is not quite so dramatic, at 1.3 seconds versus 19.8 seconds. The decision about whether or not to compress will ultimately come down to the relative cost of time versus disk space, but in this case I decided to go ahead and compress the checkpoint files. + +Combining these strategies of reducing data duplication, eliminating some intermediate checkpoints, and compressing the stored data, our final pipeline generates about 13 GB worth of checkpoint data, substantially smaller than the initial 64 GB. With all checkpoints generated, the entire workflow completes in less than four minutes, with only three time-consuming steps being rerun each time. The initial execution of the workflow is a few minutes longer due to the extra time needed to read and write compressed checkpoint files, but these few minutes are hardly noticeable for a workflow that takes more than two hours to complete. + +The use of a modular architecture for our stateless workflow helps to separate the actual workflow components from the execution logic of the workflow. One important benefit of this is that it allows us to plug those modules into any other workflow system, and as long as the inputs are correct it should work. We will see that next when we create new versions of this workflow using two common workflow engines. + +### Managing a complex workflow with Snakemake + +In general I recommend trying a general-purpose workflow engine instead of writing a custom one. In this example I will focus on the Snakemake workflow engine; in the project repository there is also a parallel workflow developed using the [Prefect] workflow engine (which is integrated directly into the Python code), but I will not discuss it here. + #rnaseq-DAG-fig shows the DAG generated by Snakemake for the RNA-seq analysis workflow. + +```{figure} images/snakemake-DAG.png +:label: rnaseq-DAG-fig +:align: center +:width: 300px + +The execution graph for the RNA-seq analysis workflow visualized as a DAG. +``` + +The `Snakemake` file is substantially larger for this complex workflow; to keep it from being even longer, we can also move some of the rules into separate rules files using the following syntax within the `Snakemake` file: + +```bash +# Include modular rule files +include: "rules/common.smk" +include: "rules/preprocessing.smk" +include: "rules/pseudobulk.smk" +include: "rules/per_cell_type.smk" +``` + + +#### Pipeline optimization + +The first time that I ran this workflow using snakemake, I noticed that it was substantially slower than when I ran it using the custom workflow engine. When I asked Claude about this, it gave me a reasonable answer: + +> The Snakemake rules don't specify a threads directive. By default, Snakemake runs each job with 1 thread, which limits parallelization of computationally intensive operations like neighbor computation and UMAP (which use numba internally). + +I asked Claude to fix this, and it returned the following change: + +> Fixes applied: +> 1. Added threads: 8 to dimensionality_reduction rule +> 2. Added threads: 8 to quality_control rule (Scrublet) +> 3. Added threads: 4 to preprocess rule +> 4. Set NUMBA_NUM_THREADS and OMP_NUM_THREADS environment variables in dimred.py +> In contrast, tasks run in the main process have access to all CPUs by default, which is why it was faster. + +This solves the problem but it's a brittle soluution: in particular, it will probably fail if there are fewer than 8 threads available on the system and it won't take advantage of more than 8 if they are available. Snakemake actually take a command line argument (`--cores`) to specify the number of cores to use, so I instead asked Claude to have Snakemake use the number of cores specified at the command line rather than an arbitrary number that might not be optimal. We will discuss optimization in much greater detail in a later chapter, but whenever a pipeline takes much longer to run using a workflow manager than one would expect, it's likely that there is optimization to be done. + +#### Running snakemake + + + +It's important to know that when snakemake is run, it stores metadata regarding the workflow in a hidden directory called `.snakemake`. It's generally a good idea to add this to the `.gitignore` file since one probably doesn't want to include detailed workflow metadata in one's git repository. It's also a best practice to execute the + +#### Report generation + +One of the very handy features of Snakemake is its ability to generate reports for workflow execution. Report generation is as simple as: + +```bash +snakemake --report $DATADIR/immune_aging/wf_snakemake/report.html --config datadir=$DATADIR/immune_aging/ +``` + +This command uses the metadata stored in the .snakemake + +#### Tracking provenance + +As I discussed in the earlier chapter on data management, it is essential to be able to track the provenance of files in a workflow. That is, how did the file come to be, and what other files did it depend on? + +#### Parametric sweeps + +A common pattern in some computational research domains is the *parametric sweep*, where a workflow is run using a range of values for specific parameters in the workflow. A key to successful execution of parametric sweeps is proper organization of the outputs so that they can be easily processed by downstream tools. Snakemake provides the ability to easily implement parametric sweeps simply by specifying a list of parameter values in the configuration file. For example... TBD + + +## Testing workflows + +- write tests for common edge cases + - use a small toy dataset for testing +- unit vs integration tests + + +## Scaling workflows + +- maybe leave this to the HPC chapter? + +## Choosing a workflow engine -## Workflow management systems for complex workflows -## Building a workflow management system from scratch diff --git a/my_datalad_repo b/my_datalad_repo deleted file mode 160000 index e8ce63a..0000000 --- a/my_datalad_repo +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e8ce63a3121002619888b8a6c87a693d177d78ea diff --git a/myst.yml b/myst.yml index e13acf1..edc3d9b 100644 --- a/myst.yml +++ b/myst.yml @@ -8,7 +8,7 @@ project: - book/references.bib exports: - format: pdf - template: https://github.com/myst-templates/plain_typst_book.git + template: plain_latex_book output: exports/book.pdf - format: md - format: docx @@ -23,7 +23,7 @@ project: - file: book/project_organization.md - file: book/data_management.md # - file: workflows -# - file: validation_robustness.md +# - file: validation.md # - file: performance # - file: HPC # - file: sharing diff --git a/problems_to_solve.md b/problems_to_solve.md new file mode 100644 index 0000000..f45c496 --- /dev/null +++ b/problems_to_solve.md @@ -0,0 +1,87 @@ +## Problems to be fixed + +Open problems marked with [ ] +Fixed problems marked with [x] + +[x] I would like to generate a new example of a very simple pandas-based data analysis workflow for demonstrating the features of Prefect and snakemake. Put the new code into src/BetterCodeBetterScience/simple_workflow. The example should include separate modules that implement each of the following functions: +- load these two files (using the first column as the index for each): + - https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv + - https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv +- Filter out any non-numerical variables from each +- join the two data frames based on the index +- compute the correlation matrix across all measures using Spearman correlation +- generate a clustered heatmap from the correlation matrix using Seaborn + - Created `simple_workflow/` directory with modular functions: + - `load_data.py`: Functions to load CSV data from URLs with optional caching + - `filter_data.py`: Functions to filter dataframes to numerical columns only + - `join_data.py`: Functions to join dataframes based on index + - `correlation.py`: Functions to compute Spearman correlation matrices + - `visualization.py`: Functions to generate clustered heatmaps with Seaborn + - Created `prefect_workflow/` subdirectory: + - `tasks.py`: Prefect task definitions wrapping each workflow function + - `flows.py`: Main workflow flow orchestrating all steps + - `run_workflow.py`: CLI entry point + - Usage: `python run_workflow.py --output-dir ./output` + - Created `snakemake_workflow/` subdirectory: + - `Snakefile`: Workflow rules with dependencies + - `config/config.yaml`: Configuration for URLs and heatmap settings + - `scripts/*.py`: Scripts for each workflow step + - `report/`: RST files for Snakemake report generation + - Usage: `snakemake --cores 1 --config output_dir=/path/to/output` + - Created `make_workflow/` subdirectory: + - `Makefile`: GNU Make-based workflow with proper dependencies + - `scripts/*.py`: Standalone CLI scripts for each step + - Usage: `make OUTPUT_DIR=/path/to/output all` + + +[x] For the Snakemake workflow I would like to use the Snakemake report generating functions to create a report showing the results from each of the analyses. + - Added `report: "report/workflow.rst"` global declaration to Snakefile + - Created `report/` directory with RST caption files for each figure type + - Updated preprocessing.smk rules (filtering, qc, dimred, clustering) to declare figures as outputs with `report()` wrapper + - Updated pseudobulk.smk checkpoint to include pseudobulk figure with `report()` wrapper + - Updated per_cell_type.smk rules (GSEA, Enrichr, prediction) to include figures with `report()` wrapper and cell_type subcategory + - Updated common.smk `aggregate_per_cell_type_outputs()` to include figure files + - Added `report` and `report-zip` targets to Makefile + - Updated WORKFLOW_OVERVIEW.md with report generation documentation + - Usage: `snakemake --report report.html --config datadir=/path/to/data` or `make report` + +[x] For the Prefect workflow, the default parameters for each workflow module are embedded in the python code for the workflow. I would rather that they be defined using a configuration file. Please extract all of the parameters into a configuration file (using whatever format you think is most appropriate) and read those in during workflow execution rather than hard-coding. + - Created `prefect_workflow/config/config.yaml` with all workflow parameters + - Parameters organized by step: filtering, qc, preprocessing, dimred, clustering, pseudobulk, differential_expression, pathway_analysis, overrepresentation, predictive_modeling + - Added `load_config()` function to flows.py that loads from YAML file + - Updated `run_workflow()` and `analyze_single_cell_type()` to accept `config_path` parameter + - Added `--config` CLI argument to run_workflow.py + - Default config bundled with package; custom configs can be specified via CLI +[x] For the Prefect workflow, please save the output to a folder called "wf_prefect" (rather than "workflow") + - Updated all output directories in flows.py and run_workflow.py to use `wf_prefect/` instead of `workflow/` +[x] For the Snakemake workflow, please save the output to a folder called "wf_snakemake" (rather than "workflow") + - Updated Snakefile to use `wf_snakemake/` for CHECKPOINT_DIR, RESULTS_DIR, FIGURE_DIR, LOG_DIR + - Updated WORKFLOW_OVERVIEW.md to reflect new output structure + +[x] I would now like to add another workflow, with code saved to src/BetterCodeBetterScience/rnaseq/snakemake_workflow. This workflow will use the Snakemake workflow manager (https://snakemake.readthedocs.io/en/stable/index.html); otherwise it should be functionally equivalent to the other workflows already developed. + - Created `snakemake_workflow/` directory with: + - `Snakefile`: Main workflow entry point + - `config/config.yaml`: All workflow parameters with defaults + - `rules/common.smk`: Helper functions (sanitize_cell_type, aggregate functions) + - `rules/preprocessing.smk`: Steps 1-6 rules + - `rules/pseudobulk.smk`: Step 7 as Snakemake checkpoint (enables dynamic rules) + - `rules/per_cell_type.smk`: Steps 8-11 with {cell_type} wildcard + - `scripts/*.py`: 12 Python scripts wrapping modular workflow functions + - Uses Snakemake checkpoint for step 7 to discover cell types dynamically + - Per-cell-type steps (8-11) triggered automatically for all valid cell types + - Reuses existing modular workflow functions and checkpoint utilities + - Added `snakemake>=8.0` dependency to pyproject.toml + - Usage: `snakemake --cores 8 --config datadir=/path/to/data` + +[x] I would like to add a new workflow, with code saved to src/BetterCodeBetterScience/rnaseq/prefect_workflow. This workflow will use the Prefect workflow manager (https://github.com/PrefectHQ/prefect) to manage the workflow that was previously developed in src/BetterCodeBetterScience/rnaseq/stateless_workflow. The one new feature that I would like to add here is to perform steps 8-11 separately on each different cell type that survives the initial filtering. + - Created `prefect_workflow/` directory with: + - `tasks.py`: Prefect task definitions wrapping modular workflow functions + - `flows.py`: Main workflow flow with parallel per-cell-type analysis + - `run_workflow.py`: CLI entry point with argument parsing + - Steps 1-7 run sequentially with checkpoint caching (reuses existing system) + - Steps 8-11 run in parallel for each cell type: + - DE tasks submitted in parallel across all cell types + - GSEA, Enrichr, and predictive modeling run in parallel within each cell type + - Added `prefect>=3.0` dependency to pyproject.toml + - Results organized by cell type in `workflow/results/per_cell_type/` + - CLI supports: `--force-from`, `--cell-type`, `--list-cell-types`, `--min-samples` diff --git a/project-words.txt b/project-words.txt index bcf5a52..48b2505 100644 --- a/project-words.txt +++ b/project-words.txt @@ -1,4 +1,5 @@ # New Words +ttests pheno tsim keepdims diff --git a/prompts/refactor_monolithic_to_modular.md b/prompts/refactor_monolithic_to_modular.md new file mode 100644 index 0000000..a6ea614 --- /dev/null +++ b/prompts/refactor_monolithic_to_modular.md @@ -0,0 +1,27 @@ +Prompt: please read CLAUDE.md for guidelines, and then read refactor_monolithic_to_modular.md for a description of your task. + +# Goal + +src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py is currently a single monolithic script for a data analysis workflow. I would like to refactor it into a modular script based on the following decomposition of the workflow: + +- Data (down)loading +- Data filtering (removing subjects or cell types with insufficient observations) +- Quality control + - identifying bad cells on the basis of mitochondrial, ribosomal, or hemoglobin genes or hemoglobin contamination + - identifying "doublets" (multiple cells identified as one) +- Preprocessing + - Count normalization + - Log transformation + - Identification of high-variance features + - Filtering of nuisance genes +- Dimensionality reduction +- UMAP generation +- Clustering +- Pseudobulking +- Differential expression analysis +- Pathway enrichment analysis (GSEA) +- Overrepresentation analysis (Enrichr) +- Predictive modeling + +Please generate a new set of scripts within a new directory called `src/BetterCodeBetterScience/rnaseq/modular_workflow` that implements the same workflow in a modular way. + diff --git a/pyproject.toml b/pyproject.toml index 18de041..f467571 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,13 +29,12 @@ dependencies = [ "icecream>=2.1.4", "python-dotenv>=1.0.1", "pyyaml>=6.0.2", - "numba>=0.61.0", + "numba>=0.61,<0.63", "codespell>=2.4.1", "tomli>=2.2.1", "pre-commit>=4.2.0", "mdnewline>=0.1.3", "anthropic>=0.61.0", - "rpy2>=3.6.4", "nibabel>=5.3.2", "fastparquet>=2024.11.0", "templateflow>=25.1.1", @@ -47,7 +46,6 @@ dependencies = [ "datalad-osf>=0.3.0", "pymongo[srv]>=4.15.4", "mysql-connector-python>=9.5.0", - "mariadb>=1.1.14", "biopython>=1.86", "neo4j>=6.0.3", "tqdm>=4.66.5", @@ -59,13 +57,40 @@ dependencies = [ "ols-client>=0.2.1", "statsmodels>=0.14.5", "blue>=0.9.1", + "nilearn>=0.12.1", + "fmriprep-docker>=25.2.3", "mystmd>=1.7.0", + "mne>=1.11.0", + "mongomock>=4.3.0", + "linkcheckmd>=1.4.0", + "anndata>=0.12.7", + "xarray>=2025.12.0", + "dask>=2025.12.0", + "pyarrow>=22.0.0", + "scanpy>=1.11.5", + "scrublet>=0.2.3", + "igraph>=1.0.0", + "leidenalg>=0.11.0", + "fastcluster>=1.3.0", + "scikit-misc>=0.5.2", + "harmony-pytorch>=0.1.8", + "pydeseq2>=0.5.3", + "gseapy>=1.1.11", + "ipython>=9.8.0", + "harmonypy>=0.0.10", + "rpy2>=3.6.4", + "prefect>=3.0", + "snakemake>=8.0", ] [build-system] requires = ["hatchling"] build-backend = "hatchling.build" +# add script entry points here +[project.scripts] +check-links = "BetterCodeBetterScience.check_links:main" + [tool.codespell] # Ref: https://github.com/codespell-project/codespell#using-a-config-file skip = './book/transcripts,./book/_build/html,.js*,.git*,*.lock,*.bib,.venv*,*.ipynb,*.json' diff --git a/src/BetterCodeBetterScience/LifeSnaps_example.ipynb b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb new file mode 100644 index 0000000..9d75202 --- /dev/null +++ b/src/BetterCodeBetterScience/LifeSnaps_example.ipynb @@ -0,0 +1,639 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5397a69c", + "metadata": {}, + "outputs": [], + "source": [ + "import pymongo\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "\n", + "db_import_dir = Path('/Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized')\n" + ] + }, + { + "cell_type": "markdown", + "id": "9318b6f9", + "metadata": {}, + "source": [ + "## Step 1: load mongobd data from bson\n", + "\n", + "There are three data files:\n", + "\n", + "- fitbit.bson\n", + "- sema.bson\n", + "- surveys.bson\n", + "\n", + "we load these into the local mongodb using mongorestore.\n", + "\n", + "the id/user_id entry in the mongo records refers to the subject id\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "342e7980", + "metadata": {}, + "outputs": [], + "source": [ + "def get_collection_type_counts(db, collection_name, sample_size=3):\n", + " # Get distinct types in a collection and sample documents for each type\n", + " collection = db[collection_name]\n", + " distinct_types = collection.distinct(\"type\")\n", + " type_counts = {}\n", + " for dtype in distinct_types:\n", + " count = collection.count_documents({\"type\": dtype})\n", + " sample_docs = list(collection.find({\"type\": dtype}).limit(sample_size))\n", + " type_counts[dtype] = count\n", + " \n", + " return type_counts\n", + "\n", + "def get_collection_size(db, collection_name):\n", + " # Get the numner of documents in a collection\n", + "\n", + " return db[collection_name].count_documents({})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1c55e4bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collection 'fitbit' has 0 documents, expected 71284346. Importing data...\n", + "Importing data into collection 'fitbit' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson...\n", + "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection fitbit --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-12-16T20:53:00.855-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n", + "2025-12-16T20:53:00.856-0800\treading metadata for lifesnaps.fitbit from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.metadata.json\n", + "2025-12-16T20:53:00.889-0800\trestoring lifesnaps.fitbit from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/fitbit.bson\n", + "2025-12-16T20:53:03.854-0800\t[........................] lifesnaps.fitbit 246MB/9.02GB (2.7%)\n", + "2025-12-16T20:53:06.854-0800\t[#.......................] lifesnaps.fitbit 511MB/9.02GB (5.5%)\n", + "2025-12-16T20:53:09.854-0800\t[#.......................] lifesnaps.fitbit 758MB/9.02GB (8.2%)\n", + "2025-12-16T20:53:12.854-0800\t[##......................] lifesnaps.fitbit 968MB/9.02GB (10.5%)\n", + "2025-12-16T20:53:15.854-0800\t[###.....................] lifesnaps.fitbit 1.19GB/9.02GB (13.2%)\n", + "2025-12-16T20:53:18.854-0800\t[###.....................] lifesnaps.fitbit 1.45GB/9.02GB (16.0%)\n", + "2025-12-16T20:53:21.854-0800\t[####....................] lifesnaps.fitbit 1.66GB/9.02GB (18.4%)\n", + "2025-12-16T20:53:24.854-0800\t[#####...................] lifesnaps.fitbit 1.90GB/9.02GB (21.0%)\n", + "2025-12-16T20:53:27.854-0800\t[#####...................] lifesnaps.fitbit 2.15GB/9.02GB (23.8%)\n", + "2025-12-16T20:53:30.854-0800\t[######..................] lifesnaps.fitbit 2.40GB/9.02GB (26.7%)\n", + "2025-12-16T20:53:33.854-0800\t[#######.................] lifesnaps.fitbit 2.66GB/9.02GB (29.5%)\n", + "2025-12-16T20:53:36.854-0800\t[#######.................] lifesnaps.fitbit 2.91GB/9.02GB (32.3%)\n", + "2025-12-16T20:53:39.854-0800\t[########................] lifesnaps.fitbit 3.13GB/9.02GB (34.7%)\n", + "2025-12-16T20:53:42.854-0800\t[#########...............] lifesnaps.fitbit 3.39GB/9.02GB (37.6%)\n", + "2025-12-16T20:53:45.854-0800\t[#########...............] lifesnaps.fitbit 3.64GB/9.02GB (40.4%)\n", + "2025-12-16T20:53:48.854-0800\t[##########..............] lifesnaps.fitbit 3.89GB/9.02GB (43.1%)\n", + "2025-12-16T20:53:51.854-0800\t[##########..............] lifesnaps.fitbit 4.13GB/9.02GB (45.8%)\n", + "2025-12-16T20:53:54.854-0800\t[###########.............] lifesnaps.fitbit 4.34GB/9.02GB (48.1%)\n", + "2025-12-16T20:53:57.854-0800\t[############............] lifesnaps.fitbit 4.59GB/9.02GB (50.9%)\n", + "2025-12-16T20:54:00.854-0800\t[############............] lifesnaps.fitbit 4.84GB/9.02GB (53.7%)\n", + "2025-12-16T20:54:03.854-0800\t[#############...........] lifesnaps.fitbit 5.10GB/9.02GB (56.6%)\n", + "2025-12-16T20:54:06.854-0800\t[##############..........] lifesnaps.fitbit 5.36GB/9.02GB (59.4%)\n", + "2025-12-16T20:54:09.854-0800\t[##############..........] lifesnaps.fitbit 5.62GB/9.02GB (62.3%)\n", + "2025-12-16T20:54:12.854-0800\t[###############.........] lifesnaps.fitbit 5.83GB/9.02GB (64.6%)\n", + "2025-12-16T20:54:15.854-0800\t[################........] lifesnaps.fitbit 6.06GB/9.02GB (67.2%)\n", + "2025-12-16T20:54:18.854-0800\t[################........] lifesnaps.fitbit 6.31GB/9.02GB (69.9%)\n", + "2025-12-16T20:54:21.854-0800\t[#################.......] lifesnaps.fitbit 6.57GB/9.02GB (72.8%)\n", + "2025-12-16T20:54:24.854-0800\t[##################......] lifesnaps.fitbit 6.81GB/9.02GB (75.5%)\n", + "2025-12-16T20:54:27.854-0800\t[##################......] lifesnaps.fitbit 7.05GB/9.02GB (78.2%)\n", + "2025-12-16T20:54:30.854-0800\t[###################.....] lifesnaps.fitbit 7.29GB/9.02GB (80.8%)\n", + "2025-12-16T20:54:33.854-0800\t[####################....] lifesnaps.fitbit 7.55GB/9.02GB (83.7%)\n", + "2025-12-16T20:54:36.854-0800\t[####################....] lifesnaps.fitbit 7.81GB/9.02GB (86.6%)\n", + "2025-12-16T20:54:39.854-0800\t[#####################...] lifesnaps.fitbit 8.06GB/9.02GB (89.4%)\n", + "2025-12-16T20:54:42.854-0800\t[######################..] lifesnaps.fitbit 8.31GB/9.02GB (92.2%)\n", + "2025-12-16T20:54:45.855-0800\t[######################..] lifesnaps.fitbit 8.54GB/9.02GB (94.7%)\n", + "2025-12-16T20:54:48.855-0800\t[#######################.] lifesnaps.fitbit 8.78GB/9.02GB (97.4%)\n", + "2025-12-16T20:54:51.722-0800\t[########################] lifesnaps.fitbit 9.02GB/9.02GB (100.0%)\n", + "2025-12-16T20:54:51.722-0800\tfinished restoring lifesnaps.fitbit (71284346 documents, 0 failures)\n", + "2025-12-16T20:54:51.722-0800\trestoring indexes for collection lifesnaps.fitbit from metadata\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"type_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"type\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1_type_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}, primitive.E{Key:\"type\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1_type_1_data.dateTime_1_data.value.bpm_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}, primitive.E{Key:\"type\", Value:1}, primitive.E{Key:\"data.dateTime\", Value:1}, primitive.E{Key:\"data.value.bpm\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.dateTime_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.dateTime\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.reading_time_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.reading_time\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.sleep_start_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.sleep_start\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.startTime_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.startTime\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"id_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"id\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:54:51.722-0800\tindex: &idx.IndexDocument{Options:primitive.M{\"background\":true, \"name\":\"data.timestamp_1\", \"ns\":\"raisV3_anonymized.fitbit\", \"v\":2}, Key:primitive.D{primitive.E{Key:\"data.timestamp\", Value:1}}, PartialFilterExpression:primitive.D(nil)}\n", + "2025-12-16T20:59:25.881-0800\t71284346 document(s) restored successfully. 0 document(s) failed to restore.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Successfully imported collection 'fitbit' with 71284346 documents.\n", + "Collection 'sema' has 0 documents, expected 15380. Importing data...\n", + "Importing data into collection 'sema' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson...\n", + "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection sema --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n", + "Successfully imported collection 'sema' with 15380 documents.\n", + "Collection 'surveys' has 0 documents, expected 935. Importing data...\n", + "Importing data into collection 'surveys' from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson...\n", + "Running command: mongorestore --host localhost --port 27017 --db lifesnaps --collection surveys --drop /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n", + "Successfully imported collection 'surveys' with 935 documents.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-12-16T20:59:31.410-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n", + "2025-12-16T20:59:31.411-0800\treading metadata for lifesnaps.sema from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.metadata.json\n", + "2025-12-16T20:59:31.442-0800\trestoring lifesnaps.sema from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/sema.bson\n", + "2025-12-16T20:59:31.492-0800\tfinished restoring lifesnaps.sema (15380 documents, 0 failures)\n", + "2025-12-16T20:59:31.492-0800\tno indexes to restore for collection lifesnaps.sema\n", + "2025-12-16T20:59:31.492-0800\t15380 document(s) restored successfully. 0 document(s) failed to restore.\n", + "2025-12-16T20:59:31.538-0800\tchecking for collection data in /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n", + "2025-12-16T20:59:31.538-0800\treading metadata for lifesnaps.surveys from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.metadata.json\n", + "2025-12-16T20:59:31.560-0800\trestoring lifesnaps.surveys from /Users/poldrack/data_unsynced/LifeSnaps/rais_anonymized/mongo_rais_anonymized/surveys.bson\n", + "2025-12-16T20:59:31.604-0800\tfinished restoring lifesnaps.surveys (935 documents, 0 failures)\n", + "2025-12-16T20:59:31.604-0800\tno indexes to restore for collection lifesnaps.surveys\n", + "2025-12-16T20:59:31.604-0800\t935 document(s) restored successfully. 0 document(s) failed to restore.\n" + ] + } + ], + "source": [ + "# Connect to MongoDB\n", + "def get_mongo_client(host='localhost', port=27017):\n", + " try:\n", + " client = pymongo.MongoClient(f\"mongodb://{host}:{port}/\")\n", + " except pymongo.errors.ConnectionError as e:\n", + " raise Exception(f\"Error connecting to MongoDB - have you set it up yet?: {e}\")\n", + " return client\n", + "\n", + "client = get_mongo_client()\n", + "\n", + "# load the database and import data if necessary\n", + "db = client['lifesnaps']\n", + "collection_lengths = {\n", + " 'fitbit': 71284346,\n", + " 'sema': 15380,\n", + " 'surveys': 935\n", + "}\n", + "\n", + "# in general we will need to overwrite to get the full dataset to begin with\n", + "overwrite = True\n", + "\n", + "for collection_name, expected_length in collection_lengths.items():\n", + " actual_length = get_collection_size(db, collection_name)\n", + " # use ge since we will removing some objects below\n", + " if actual_length >= expected_length and not overwrite:\n", + " print(f\"Collection '{collection_name}' already loaded with {actual_length} documents.\")\n", + " else:\n", + " # import the data from the BSON file\n", + " print(f\"Collection '{collection_name}' has {actual_length} documents, expected {expected_length}. Importing data...\")\n", + " import_file = db_import_dir / f\"{collection_name}.bson\"\n", + " if not import_file.exists():\n", + " raise FileNotFoundError(f\"Import file {import_file} does not exist.\")\n", + " print(f\"Importing data into collection '{collection_name}' from {import_file}...\")\n", + " command = f\"mongorestore --host {client.address[0]} --port {client.address[1]} --db lifesnaps --collection {collection_name} --drop {import_file}\"\n", + " print(f\"Running command: {command}\")\n", + " os.system(command)\n", + " \n", + " actual_length = get_collection_size(db, collection_name)\n", + " assert actual_length >= expected_length, f\"After import, collection '{collection_name}' has {actual_length} documents, expected {expected_length}.\"\n", + " print(f\"Successfully imported collection '{collection_name}' with {actual_length} documents.\")\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "0729c2ec", + "metadata": {}, + "source": [ + "### Step 2: remove unnecessary entries from fitbit database\n", + "\n", + "The fitbit store is huge and we don't need many of the entries, so let's remove them.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "56ad6fcb", + "metadata": {}, + "source": [ + "First pull Profile records into a separate object store since they are a different kind of data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e6bfae7a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created 'fitbit_profile' collection with 69 documents.\n" + ] + } + ], + "source": [ + "# create a new table containing all documents from fitbit with type 'Profile'\n", + "profile_collection = db['fitbit_profile']\n", + "profile_collection.drop() # drop existing collection if it exists\n", + "fitbit_collection = db['fitbit']\n", + "profiles = list(fitbit_collection.find({\"type\": \"Profile\"}))\n", + "if len(profiles) > 0:\n", + " profile_collection.insert_many(profiles)\n", + " print(f\"Created 'fitbit_profile' collection with {get_collection_size(db, 'fitbit_profile')} documents.\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "a653da8c", + "metadata": {}, + "source": [ + "Remove unwanted fitbit data types" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a2dd2b2e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed 9845042 unwanted documents from 'fitbit' collection.\n", + "Remaining documents in 'fitbit' collection: 61439304\n", + "Final document counts in 'fitbit' collection after cleanup:\n", + "Type: calories, Count: 9675782\n", + "Type: heart_rate, Count: 48720040\n", + "Type: lightly_active_minutes, Count: 7203\n", + "Type: moderately_active_minutes, Count: 7203\n", + "Type: sedentary_minutes, Count: 7203\n", + "Type: sleep, Count: 4141\n", + "Type: steps, Count: 3010529\n", + "Type: very_active_minutes, Count: 7203\n" + ] + } + ], + "source": [ + "fitbit_types_to_keep = [\n", + " \"heart_rate\",\n", + " \"sleep\",\n", + " \"steps\",\n", + " \"lightly_active_minutes\",\n", + " \"moderately_active_minutes\",\n", + " \"very_active_minutes\",\n", + " \"sedentary_minutes\",\n", + " \"calories\",\n", + "]\n", + "\n", + "# remove unwanted fitbit data\n", + "fitbit_collection = db['fitbit']\n", + "deletion_result = fitbit_collection.delete_many({\"type\": {\"$nin\": fitbit_types_to_keep}})\n", + "print(f\"Removed {deletion_result.deleted_count} unwanted documents from 'fitbit' collection.\")\n", + "print(f\"Remaining documents in 'fitbit' collection: {get_collection_size(db, 'fitbit')}\")\n", + "print(\"Final document counts in 'fitbit' collection after cleanup:\")\n", + "final_type_counts = get_collection_type_counts(db, 'fitbit')\n", + "for dtype, count in final_type_counts.items():\n", + " print(f\"Type: {dtype}, Count: {count}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f6d90f7", + "metadata": {}, + "source": [ + "## Harmonize the documents and combine into a single database\n", + "\n", + "We want to be able to treat each of the different data types similarly, but currently some of them have their value in a different location than the `value` field." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3752b2db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed 2 documents with null 'data.SURVEY_NAME' from 'sema' collection.\n", + "Remaining documents in 'sema' collection: 15378\n", + "Updated 15378 documents in 'sema' collection to add 'type' field.\n", + "Document counts in 'sema' collection after adding 'type' field:\n", + "Type: Context and Mood Survey, Count: 11526\n", + "Type: Step Goal Survey, Count: 3852\n" + ] + } + ], + "source": [ + "# for sema collection, create a 'type' field based on data['SURVEY_NAME']\n", + "\n", + "sema_collection = db['sema']\n", + "# first remove documents that None for data.SURVEY_NAME\n", + "deletion_result = sema_collection.delete_many({\"data.SURVEY_NAME\": None})\n", + "print(f\"Removed {deletion_result.deleted_count} documents with null 'data.SURVEY_NAME' from 'sema' collection.\")\n", + "print(f\"Remaining documents in 'sema' collection: {get_collection_size(db,'sema')}\")\n", + "# now update documents to add 'type'\n", + "update_result = sema_collection.update_many(\n", + " {\"type\": {\"$exists\": False}},\n", + " [{\"$set\": {\"type\": \"$data.SURVEY_NAME\"}}]\n", + ")\n", + "print(f\"Updated {update_result.modified_count} documents in 'sema' collection to add 'type' field.\")\n", + "print(f\"Document counts in 'sema' collection after adding 'type' field:\")\n", + "sema_type_counts = get_collection_type_counts(db, 'sema')\n", + "for dtype, count in sema_type_counts.items():\n", + " print(f\"Type: {dtype}, Count: {count}\") " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eb0057c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Combined 'sema' collection into 'fitbit'. New 'fitbit' collection size: 61450830 documents.\n" + ] + } + ], + "source": [ + "# combine the sema collection into fitbit\n", + "\n", + "sema_collection = db['sema']\n", + "# drop the \"Step Goal Survey\" from sema\n", + "sema_collection.delete_many({\"type\": \"Step Goal Survey\"})\n", + "\n", + "fitbit_collection = db['fitbit']\n", + "fitbit_collection.insert_many(sema_collection.find())\n", + "print(f\"Combined 'sema' collection into 'fitbit'. New 'fitbit' collection size: {get_collection_size(db, 'fitbit')} documents.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "853eb7e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Updated 48720040 documents of type 'heart_rate' to add 'value' field from 'data.value.bpm'.\n", + "Updated 4141 documents of type 'sleep' to add 'date' field from 'data.endTime'.\n", + "Updated 4141 documents of type 'sleep' to add 'value' field from 'data.minutesAsleep'.\n", + "Updated 7203 documents of type 'lightly_active_minutes' to add 'value' field from 'data.value'.\n", + "Updated 7203 documents of type 'moderately_active_minutes' to add 'value' field from 'data.value'.\n", + "Updated 7203 documents of type 'very_active_minutes' to add 'value' field from 'data.value'.\n", + "Updated 7203 documents of type 'sedentary_minutes' to add 'value' field from 'data.value'.\n", + "Updated 9675782 documents of type 'calories' to add 'date' field from 'data.dateTime'.\n", + "Updated 9675782 documents of type 'calories' to add 'value' field from 'data.value'.\n", + "Updated 3010529 documents of type 'steps' to add 'date' field from 'data.dateTime'.\n", + "Updated 3010529 documents of type 'steps' to add 'value' field from 'data.value'.\n", + "Updated 11526 documents of type 'Context and Mood Survey' to add 'date' field from 'data.COMPLETED_TS'.\n", + "Updated 11526 documents of type 'Context and Mood Survey' to add 'value' field from 'data.MOOD'.\n", + "\n", + "Verifying updates:\n", + "Type 'heart_rate': 48720040/48720040 documents now have 'value' field.\n", + "Type 'sleep': 4141/4141 documents now have 'value' field.\n", + "Type 'lightly_active_minutes': 7203/7203 documents now have 'value' field.\n", + "Type 'moderately_active_minutes': 7203/7203 documents now have 'value' field.\n", + "Type 'very_active_minutes': 7203/7203 documents now have 'value' field.\n", + "Type 'sedentary_minutes': 7203/7203 documents now have 'value' field.\n", + "Type 'calories': 9675782/9675782 documents now have 'value' field.\n", + "Type 'steps': 3010529/3010529 documents now have 'value' field.\n", + "Type 'Context and Mood Survey': 11526/11526 documents now have 'value' field.\n" + ] + } + ], + "source": [ + "# some already are called \"value\": calories, active/sedentary minutes\n", + "value_variable = {\n", + " 'heart_rate': 'value.bpm',\n", + " 'sleep': 'minutesAsleep',\n", + " 'lightly_active_minutes': 'value',\n", + " 'moderately_active_minutes': 'value',\n", + " 'very_active_minutes': 'value',\n", + " 'sedentary_minutes': 'value',\n", + " 'calories': 'value',\n", + " 'steps': 'value',\n", + " \"Context and Mood Survey\": 'MOOD'\n", + "}\n", + "date_variable = {\n", + " 'sleep': 'endTime',\n", + " 'calories': 'dateTime',\n", + " 'steps': 'dateTime',\n", + " \"Context and Mood Survey\": 'COMPLETED_TS'\n", + "}\n", + "# for each object that has type matching one of the keys in value_variable,\n", + "# move data[value_variable] into 'value' field at root level of object\n", + "\n", + "fitbit_collection = db['fitbit']\n", + "\n", + "for doc_type, value_field in value_variable.items():\n", + " # Update documents of this type to move the value from data[value_field] to root level 'value'\n", + " update_result = fitbit_collection.update_many(\n", + " {\n", + " \"type\": doc_type,\n", + " f\"data.{value_field}\": {\"$exists\": True}\n", + " },\n", + " [\n", + " {\"$set\": {\n", + " \"value\": f\"$data.{value_field}\",\n", + " \"value_origin\": value_field\n", + " }}\n", + " ]\n", + " )\n", + " # fix date field if applicable\n", + " if doc_type in date_variable:\n", + " date_field = date_variable[doc_type]\n", + " date_update_result = fitbit_collection.update_many(\n", + " {\n", + " \"type\": doc_type,\n", + " f\"data.{date_field}\": {\"$exists\": True}\n", + " },\n", + " [\n", + " {\"$set\": {\n", + " \"date\": f\"$data.{date_field}\",\n", + " \"date_origin\": date_field\n", + " }}\n", + " ]\n", + " )\n", + " print(f\"Updated {date_update_result.modified_count} documents of type '{doc_type}' to add 'date' field from 'data.{date_field}'.\")\n", + " print(f\"Updated {update_result.modified_count} documents of type '{doc_type}' to add 'value' field from 'data.{value_field}'.\")\n", + "\n", + "print(\"\\nVerifying updates:\")\n", + "for doc_type in value_variable.keys():\n", + " count_with_value = fitbit_collection.count_documents({\n", + " \"type\": doc_type,\n", + " \"value\": {\"$exists\": True}\n", + " })\n", + " total_count = fitbit_collection.count_documents({\"type\": doc_type})\n", + " print(f\"Type '{doc_type}': {count_with_value}/{total_count} documents now have 'value' field.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "b137d0f7", + "metadata": {}, + "source": [ + "Harmonize by adding type field to sema database" + ] + }, + { + "cell_type": "markdown", + "id": "335a1d89", + "metadata": {}, + "source": [ + "rename id to user_id for fitbit collection to harmonize with others" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "89b2a549", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Renamed 'id' field to 'user_id' in 61439304 documents in 'fitbit' collection.\n" + ] + } + ], + "source": [ + "# rename \"id\" field to \"user_id\" in fitbit collection\n", + "\n", + "# skip if all entities already have \"user_id\"\n", + "if fitbit_collection.count_documents({\"user_id\": {\"$exists\": False}}) > 0:\n", + "\n", + " rename_result = fitbit_collection.update_many(\n", + " {},\n", + " {\"$rename\": {\"id\": \"user_id\"}}\n", + " )\n", + " print(f\"Renamed 'id' field to 'user_id' in {rename_result.modified_count} documents in 'fitbit' collection.\")\n", + "else:\n", + " print(\"Field 'id' already renamed to 'user_id' in 'fitbit' collection; skipping rename.\") " + ] + }, + { + "cell_type": "markdown", + "id": "df746117", + "metadata": {}, + "source": [ + "Doublecheck that every document has a fields for type, value, user_id, and date." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "523fa955", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Missing field counts in 'fitbit' collection:\n", + "Field 'user_id': 0 documents missing this field.\n", + "Field 'type': 0 documents missing this field.\n", + "Field 'value': 0 documents missing this field.\n", + "Field 'date': 48748852 documents missing this field.\n" + ] + } + ], + "source": [ + "field_to_check_for = ['user_id', 'type', 'value', 'date']\n", + "# check that all documents in fitbit collection have these fields\n", + "missing_field_counts = {}\n", + "for field in field_to_check_for:\n", + " count_missing = fitbit_collection.count_documents({field: {\"$exists\": False}})\n", + " missing_field_counts[field] = count_missing\n", + "print(\"Missing field counts in 'fitbit' collection:\")\n", + "for field, count in missing_field_counts.items():\n", + " print(f\"Field '{field}': {count} documents missing this field.\") " + ] + }, + { + "cell_type": "markdown", + "id": "ce192d95", + "metadata": {}, + "source": [ + "### Combine all three stores into a single store\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ce02ac7b", + "metadata": {}, + "outputs": [], + "source": [ + "# delete intermediate collections if desired\n", + "#fitbit_collection.drop()\n", + "#sema_collection.drop()\n", + "#print(\"Deleted intermediate collections 'fitbit' and 'sema'.\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5e7e8199", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total size of 'lifesnaps_data' collection: 0.00 GB\n" + ] + } + ], + "source": [ + "# get total size of lifesnaps_data collection in gigabytes\n", + "\n", + "total_size_gb = get_collection_size(db, 'lifesnaps_data') / 1e7\n", + "print(f\"Total size of 'lifesnaps_data' collection: {total_size_gb:.02f} GB\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "BetterCodeBetterScience", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/BetterCodeBetterScience/narps/bids_utils.py b/src/BetterCodeBetterScience/narps/bids_utils.py new file mode 100644 index 0000000..66c1d8c --- /dev/null +++ b/src/BetterCodeBetterScience/narps/bids_utils.py @@ -0,0 +1,234 @@ +from typing import Dict, List, Union +from pathlib import Path + + +def parse_bids_filename(filename) -> Dict[str, str]: + """ + Parse a BIDS-like filename into its components. + + Parameters + ---------- + filename : str or Path + BIDS-like filename (string or Path object) + + Returns + ------- + dict + Dictionary with components of the filename, including 'path' key + """ + if isinstance(filename, str): + filepath = Path(filename) + else: + filepath = filename + + base = filepath.name + parts = base.split('_') + # take the last element which is the suffix + suffix = parts[-1].split('.')[0] + parts = parts[:-1] # remove suffix part + components = {'path': str(filepath), 'suffix': suffix} + for part in parts: + if '-' in part: + key, value = part.split('-', 1) + components[key] = value + return components + + +# take in a set of bids tags (defined as kwargs) and find all files matching them +def find_bids_files(basedir: Union[str, Path], **bids_tags) -> List[Path]: + """ + Find all files in a BIDS-like directory that match specified tags. + + Parameters + ---------- + basedir : str or Path + Base directory to search + **bids_tags : dict + Key-value pairs of BIDS tags to match + + Returns + ------- + list of Path + List of Path objects for files matching the specified tags + """ + if isinstance(basedir, str): + basedir = Path(basedir) + + matched_files = [] + for filepath in basedir.rglob('*'): + if filepath.is_file(): + components = parse_bids_filename(filepath) + if all(components.get(k) == v for k, v in bids_tags.items()): + matched_files.append(filepath) + return matched_files + + +def modify_bids_filename(filename: Union[str, Path], **bids_tags) -> Union[str, Path]: + """ + Modify a BIDS-like filename by replacing specified tag values. + + Parameters + ---------- + filename : str or Path + Original BIDS-like filename (string or Path object) + **bids_tags : dict + Key-value pairs of BIDS tags to modify + + Returns + ------- + str or Path + Modified filename with updated tag values, returned in the same type + as the input (str or Path). Full directory path is preserved. + + Examples + -------- + >>> modify_bids_filename("sub-123_desc-test_type-1_stat.nii.gz", desc="real") + 'sub-123_desc-real_type-1_stat.nii.gz' + + >>> modify_bids_filename("sub-01_task-rest_bold.nii", task="memory", run="02") + 'sub-01_task-memory_run-02_bold.nii' + """ + # Track input type + input_is_string = isinstance(filename, str) + + if input_is_string: + filepath = Path(filename) + else: + filepath = filename + + # Get directory and original filename + parent_dir = filepath.parent + original_name = filepath.name + + # Get the file extension(s) + if '.' in original_name: + # Handle both .nii.gz and .nii cases + ext_parts = original_name.split('.') + extension = '.' + '.'.join(ext_parts[1:]) + else: + extension = '' + + # Parse original filename to extract key-value pairs in order + base = original_name + if '.' in base: + base = base.split('.')[0] # Remove extension + + parts = base.split('_') + suffix = parts[-1] # Last part is the suffix + kv_parts = parts[:-1] # Everything before suffix + + # Build ordered list of (key, value) tuples, preserving original order + ordered_pairs = [] + existing_keys = set() + + for part in kv_parts: + if '-' in part: + key, value = part.split('-', 1) + # Update value if modification requested + if key in bids_tags: + value = bids_tags[key] + ordered_pairs.append((key, value)) + existing_keys.add(key) + + # Check if suffix should be modified + if 'suffix' in bids_tags: + suffix = bids_tags['suffix'] + existing_keys.add('suffix') + + # Add any new keys from bids_tags that weren't in original (except suffix) + for key, value in bids_tags.items(): + if key not in existing_keys and key != 'suffix': + ordered_pairs.append((key, value)) + + # Reconstruct filename maintaining order + new_parts = [f"{key}-{value}" for key, value in ordered_pairs] + new_filename = '_'.join(new_parts) + f"_{suffix}{extension}" + + # Reconstruct full path + new_filepath = parent_dir / new_filename + + # Return in same type as input + if input_is_string: + return str(new_filepath) + else: + return new_filepath + + +def bids_summary( + basedir: Union[str, Path], + extension: str = ".nii.gz", + verbose: bool = True +) -> Dict[str, Dict[str, int]]: + """ + Summarize BIDS files in a directory by counting images for each type within each desc. + + Parameters + ---------- + basedir : str or Path + Base directory containing BIDS files + extension : str, optional + File extension to filter (default: ".nii.gz") + verbose : bool, optional + Whether to print summary to screen (default: True) + + Returns + ------- + dict + Nested dictionary with structure: + {desc_value: {type_value: count, ...}, ...} + If desc is not present, uses 'no_desc' as key. + If type is not present, uses 'no_type' as key. + + Examples + -------- + >>> summary = bids_summary("/data/narps", extension=".nii.gz", verbose=True) + Summary of BIDS files in /data/narps (*.nii.gz): + desc-orig: + type-thresh: 10 files + type-unthresh: 10 files + desc-rect: + type-thresh: 5 files + """ + if isinstance(basedir, str): + basedir = Path(basedir) + + # Find all files with the specified extension + if extension.startswith('.'): + pattern = f"*{extension}" + else: + pattern = f"*.{extension}" + + all_files = list(basedir.rglob(pattern)) + + # Count by desc and type + summary_dict = {} + + for filepath in all_files: + components = parse_bids_filename(filepath) + + # Get desc and type, with defaults if missing + desc_value = components.get('desc', 'no_desc') + type_value = components.get('type', 'no_type') + + # Initialize nested dict if needed + if desc_value not in summary_dict: + summary_dict[desc_value] = {} + + if type_value not in summary_dict[desc_value]: + summary_dict[desc_value][type_value] = 0 + + summary_dict[desc_value][type_value] += 1 + + # Print summary if verbose + if verbose: + print(f"Summary of BIDS files in {basedir} (*{extension}):") + if not summary_dict: + print(" No files found") + else: + for desc, type_counts in sorted(summary_dict.items()): + print(f" desc-{desc}:") + for type_val, count in sorted(type_counts.items()): + print(f" type-{type_val}: {count} files") + + return summary_dict + diff --git a/src/BetterCodeBetterScience/narps/image_utils.py b/src/BetterCodeBetterScience/narps/image_utils.py new file mode 100644 index 0000000..7a9e950 --- /dev/null +++ b/src/BetterCodeBetterScience/narps/image_utils.py @@ -0,0 +1,134 @@ + +import os +from typing import Dict, Optional, Union +from pathlib import Path + +import numpy as np +import nibabel as nib + + +def compare_thresh_unthresh_values( + thresh_image_path: Union[str, Path], + unthresh_image_path: Union[str, Path], + hyp_num: int, + team_id: Optional[str] = None, + collection_id: Optional[str] = None, + error_thresh: float = 0.05, + verbose: bool = True, + logger=None, +) -> Dict: + """ + Examine unthresholded values within thresholded map voxels + to check direction of maps and determine if rectification is needed. + + If more than error_thresh percent of voxels are in opposite direction, + then flag a problem. We allow a few to bleed over due to interpolation. + + Parameters + ---------- + thresh_image_path : str or Path + Path to thresholded image + unthresh_image_path : str or Path + Path to unthresholded image + hyp_num : int + Hypothesis number + team_id : str, optional + Team identifier + collection_id : str, optional + Collection identifier + error_thresh : float + Threshold for flagging problems (proportion of voxels in wrong direction) + verbose : bool + Whether to print diagnostic messages + + Returns + ------- + dict + Dictionary containing diagnostic information: + - autorectify: bool, whether image should be rectified + - problem: bool, whether there's a problem with the image + - n_thresh_vox: int, number of thresholded voxels + - min_unthresh: float, minimum unthresholded value within mask + - max_unthresh: float, maximum unthresholded value within mask + - p_pos_unthresh: float, proportion of positive unthresholded values + - p_neg_unthresh: float, proportion of negative unthresholded values + """ + result = { + "hyp": hyp_num, + "team_id": team_id, + "collection_id": collection_id, + "autorectify": False, + "problem": False, + "n_thresh_vox": 0, + "min_unthresh": np.nan, + "max_unthresh": np.nan, + "p_pos_unthresh": np.nan, + "p_neg_unthresh": np.nan, + } + + # Check if files exist + if not os.path.exists(thresh_image_path): + if verbose and logger: + logger.warning("Threshold image not found: %s", thresh_image_path) + return result + + if not os.path.exists(unthresh_image_path): + if verbose and logger: + logger.warning("Unthreshold image not found: %s", unthresh_image_path) + return result + + # Load images + thresh_img = nib.load(thresh_image_path) + thresh_data = thresh_img.get_fdata().flatten() + thresh_data = np.nan_to_num(thresh_data) + + unthresh_img = nib.load(unthresh_image_path) + unthresh_data = unthresh_img.get_fdata().flatten() + unthresh_data = np.nan_to_num(unthresh_data) + + # Check shape compatibility + if thresh_data.shape != unthresh_data.shape: + if verbose and logger: + logger.error("thresh/unthresh size mismatch for hyp %d", hyp_num) + result["problem"] = True + return result + + # Count thresholded voxels + n_thresh_vox = np.sum(thresh_data > 0) + result["n_thresh_vox"] = int(n_thresh_vox) + + if n_thresh_vox == 0: + if verbose and logger: + logger.warning("hyp %d - empty mask", hyp_num) + return result + + # Analyze values within the mask + inmask_unthresh_data = unthresh_data[thresh_data > 0] + + min_val = float(np.min(inmask_unthresh_data)) + max_val = float(np.max(inmask_unthresh_data)) + p_pos_unthresh = float(np.mean(inmask_unthresh_data > 0)) + p_neg_unthresh = float(np.mean(inmask_unthresh_data < 0)) + + result["min_unthresh"] = min_val + result["max_unthresh"] = max_val + result["p_pos_unthresh"] = p_pos_unthresh + result["p_neg_unthresh"] = p_neg_unthresh + + # Check if rectification is needed + if max_val < 0: # All values are negative + result["autorectify"] = True + if verbose and logger: + logger.info("Autorectify needed: hyp %d", hyp_num) + + # Check for problems + min_p_direction = min(p_pos_unthresh, p_neg_unthresh) + if min_p_direction > error_thresh: + if verbose and logger: + logger.warning( + "hyp %d invalid in-mask values (neg: %.3f, pos: %.3f)", + hyp_num, p_neg_unthresh, p_pos_unthresh + ) + result["problem"] = True + + return result diff --git a/src/BetterCodeBetterScience/narps/narps_megascript.py b/src/BetterCodeBetterScience/narps/narps_megascript.py new file mode 100644 index 0000000..b7e6ddf --- /dev/null +++ b/src/BetterCodeBetterScience/narps/narps_megascript.py @@ -0,0 +1,533 @@ +## This is a megascript to run the NARPS preprocessing workflow +## This will serve as the basis for refactoring into a more modular workflow later. + +import os +import dotenv +from pathlib import Path +import tarfile +import urllib.request +import shutil +from BetterCodeBetterScience.narps.bids_utils import ( + parse_bids_filename, + find_bids_files, + modify_bids_filename, +) +from nilearn.maskers import NiftiMasker +import nilearn.image +import nibabel as nib +import numpy as np +import json +import templateflow.api as tflow +from nilearn.image import resample_to_img +import pandas as pd +from scipy.stats import norm, t + +dotenv.load_dotenv() + +## 1. Download data +# - the organized data are available from https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz + +assert ( + 'NARPS_DATADIR' in os.environ +), 'Please set NARPS_DATADIR in your environment variables or .env file' +basedir = Path(os.environ['NARPS_DATADIR']) +if not basedir.exists(): + basedir.mkdir(parents=True, exist_ok=True) + +narps_data_url = ( + 'https://zenodo.org/record/3528329/files/narps_origdata_1.0.tgz' +) +narps_data_archive = basedir / 'narps_origdata_1.0.tgz' + +overwrite_data = False + +if not narps_data_archive.exists() or overwrite_data: + + print(f'Downloading NARPS data from {narps_data_url}...') + urllib.request.urlretrieve(narps_data_url, narps_data_archive) + print('Download complete.') + +origdir = basedir / 'orig' +if not origdir.exists() or overwrite_data: + print('Extracting data...') + with tarfile.open(narps_data_archive, 'r:gz') as tar: + tar.extractall(path=basedir) + print('Extraction complete.') + +logdir = basedir / 'logs' +if not logdir.exists(): + logdir.mkdir(parents=True, exist_ok=True) + + +## 2. convert orig data to a BIDS-like organization + +overwrite = False +datadir = basedir / 'data-teams' +if datadir.exists() and overwrite: + shutil.rmtree(datadir) + +if not datadir.exists(): + datadir.mkdir(parents=True, exist_ok=True) + +# Get info about teams - we will only process data for hypothesis 1 here +# team dirs are in orig, starting with numeric team IDs + +teamdirs = sorted( + [d for d in origdir.iterdir() if d.is_dir() and d.name[0].isdigit()] +) +print(f'Found {len(teamdirs)} team directories.') +team_dict = {d.name: {'orig': d} for d in teamdirs} + +# we will only process hypothesis 1 for this analysis for the sake of speed +target_hypothesis = 1 + +team_id_to_number = {} + +for team_id, paths in team_dict.items(): + # only use the team number + team_id_short = team_id.split('_')[0] + team_id_to_number[team_id.split('_')[1]] = team_id_short + team_orig_dir = paths['orig'] + # include "thresh" to prevent some additional files from being detected + for type in ['thresh', 'unthresh']: + for img_file in team_orig_dir.glob(f'*_{type}.nii.gz'): + hyp, imgtype = ( + img_file.name.split('.')[0].replace('hypo', '').split('_') + ) + try: + int(hyp) + except ValueError: + print( + f'Unexpected hypothesis number format in file {img_file}, skipping.' + ) + continue + if int(hyp) != target_hypothesis: + continue + dest_file = ( + datadir + / f'team-{team_id_short}_hyp-{hyp}_type-{imgtype}_space-native_desc-orig_stat.nii.gz' + ) + if not dest_file.exists(): + print(f'Copying {img_file} to {dest_file}') + shutil.copy(img_file.resolve(), dest_file) + assert parse_bids_filename(dest_file)['team'] == team_id_short + assert parse_bids_filename(dest_file)['hyp'] == hyp + assert parse_bids_filename(dest_file)['type'] == imgtype + +## 3. QC to identify bad data and move them to excluded data dir +# look for: +# - different image dimensions or affine between thresh and unthresh images for a given team/hyp +# - missing thresholded images +# - need for rectification (i.e. mostly negative values in unthresh image within the mask defined by the thresh image) +# - invalid in-mask values (i.e. both positive and negative values in unthresh image within the mask defined by the thresh image) - don't exclude, just note in log + +datadir_excluded = basedir / 'data-teams-excluded' +if not datadir_excluded.exists(): + datadir_excluded.mkdir(parents=True, exist_ok=True) + +qc_results = {} +error_thresh = 0.1 # proportion of invalid in-mask values to flag problem + +print('Running QC on original images...') +unthresh_images = find_bids_files(datadir, type='unthresh', desc='orig') +print(f'Found {len(unthresh_images)} unthresh original images to QC.') + +for unthresh_img_path in unthresh_images: + components = parse_bids_filename(unthresh_img_path) + hyp_num = int(components['hyp']) + team_id = components['team'] + result = { + 'hyp': hyp_num, + 'team_id': team_id, + 'infile': str(unthresh_img_path), + } + thresh_img_path = modify_bids_filename(unthresh_img_path, type='thresh') + if not Path(thresh_img_path).exists(): + print( + f'Thresholded image not found for hyp {hyp_num}, team {team_id}, moving to excluded data.' + ) + shutil.move( + unthresh_img_path, datadir_excluded / unthresh_img_path.name + ) + result['exclusion'] = 'thresholded image not found' + qc_results[str(unthresh_img_path)] = result + continue + + # Load images + unthresh_img = nib.load(str(unthresh_img_path)) + thresh_img = nib.load(str(thresh_img_path)) + + # check image dimensions and affine + if unthresh_img.shape != thresh_img.shape or not np.allclose( + unthresh_img.affine, thresh_img.affine + ): + print( + f"Image shape or affine mismatch for hyp {components['hyp']}, team {components['team']}, moving to excluded data." + ) + shutil.move( + unthresh_img_path, datadir_excluded / unthresh_img_path.name + ) + shutil.move( + thresh_img_path, datadir_excluded / Path(thresh_img_path).name + ) + result['exclusion'] = 'image shape or affine mismatch' + qc_results[str(unthresh_img_path)] = result + continue + + thresh_data = thresh_img.get_fdata().flatten() + thresh_data = np.nan_to_num(thresh_data) + n_thresh_vox = np.sum(thresh_data > 0) + # check for min_p_direction > error_thresh + result['n_thresh_vox'] = int(n_thresh_vox) + + # decide whether to rectify based on in-mask values + # and info from researcher survey + + if n_thresh_vox > 0: + masker = NiftiMasker(mask_img=thresh_img) + masker.fit() + unthresh_data_masked = masker.transform(str(unthresh_img_path)) + + min_val = float(np.min(unthresh_data_masked.flatten())) + max_val = float(np.max(unthresh_data_masked.flatten())) + p_pos_unthresh = float(np.mean(unthresh_data_masked.flatten() > 0)) + p_neg_unthresh = float(np.mean(unthresh_data_masked.flatten() < 0)) + result['min_unthresh'] = min_val + result['max_unthresh'] = max_val + result['p_pos_unthresh'] = p_pos_unthresh + result['p_neg_unthresh'] = p_neg_unthresh + + if p_neg_unthresh > (1 - error_thresh): + # mostly negative values, rectify + result['autorectify'] = True + else: + result['autorectify'] = False + + # Check for problems - note these in QC but don't exclude + min_p_direction = min(p_pos_unthresh, p_neg_unthresh) + if min_p_direction > error_thresh: + result['problem'] = 'invalid in-mask values' + print( + f'hyp {hyp_num}, team {team_id} - invalid in-mask values (neg: {p_neg_unthresh:.3f}, pos: {p_pos_unthresh:.3f})' + ) + + qc_results[str(unthresh_img_path)] = result + +with open(logdir / 'qc_log.json', 'w') as f: + json.dump(qc_results, f, indent=4) + + +## 4 - Get binarized thresholded maps +# some thresholded masks have continuous values, so we will binarize +# them at a small threshold (1e-4) + +print('Creating binarized images...') +thresh_images_to_binarize = find_bids_files( + datadir, type='thresh', desc='orig' +) +print( + f'Found {len(thresh_images_to_binarize)} thresh binarized images to process.' +) + +results = {} +overwrite = False +thresh = 1e-4 +for thresh_img_path in thresh_images_to_binarize: + outfile = Path( + modify_bids_filename(thresh_img_path, desc='binarized', suffix='mask') + ) + if outfile.exists() and not overwrite: + continue + + thresh_img = nib.load(str(thresh_img_path)) + thresh_data = thresh_img.get_fdata() + thresh_data = np.nan_to_num(thresh_data) + binarized_data = (np.abs(thresh_data) > thresh).astype(np.float32) + binarized_img = nib.Nifti1Image( + binarized_data, thresh_img.affine, thresh_img.header + ) + binarized_img.to_filename(str(outfile)) + results[str(outfile)] = { + 'infile': str(thresh_img_path), + 'n_nonzero_voxels': int(np.sum(binarized_data)), + } + +with open(logdir / 'binarization_log.json', 'w') as f: + json.dump(results, f, indent=4) + + +# 5 - Create rectified images +# some unthresh images need to be rectified (i.e. multiplied by -1) +# so that they match the hypothesis +# we infer this based on the match between thresh and unthresh images + +print('Creating rectified images...') +results = {} +overwrite = False + +for unthresh_img_path, values in qc_results.items(): + if not Path(unthresh_img_path).exists(): + continue + + output_path = Path( + modify_bids_filename(unthresh_img_path, desc='rectified') + ) + + if output_path.exists() and not overwrite: + print(f'Rectified image already exists: {output_path}, skipping.') + continue + + unthresh_img = nib.load(str(unthresh_img_path)) + unthresh_data = unthresh_img.get_fdata() + + if values.get('autorectify', False): + # mostly negative values, rectify + print(f'Rectifying unthresh image for hyp {hyp_num}, team {team_id}') + rectified_data = -1 * unthresh_data + qc_results[unthresh_img_path]['rectified'] = True + else: + rectified_data = unthresh_data + qc_results[unthresh_img_path]['rectified'] = False + + rectified_img = nib.Nifti1Image( + rectified_data, unthresh_img.affine, unthresh_img.header + ) + rectified_img.to_filename(str(output_path)) + + results[str(output_path)] = result + +with open(logdir / 'rectification_log.json', 'w') as f: + json.dump(qc_results, f, indent=4) + + +## 6: Get resampled images + +## first get MNI152NLin2009cAsym template from templateflow +mni_template = tflow.get( + 'MNI152NLin2009cAsym', resolution=2, suffix='T1w', desc=None +) + +print('Resampling images to MNI space...') +results = {} +overwrite = False +all_images_to_resample = find_bids_files( + datadir, type='thresh', space='native', desc='binarized' +) + find_bids_files(datadir, type='unthresh', space='native', desc='rectified') + +print(f'Found {len(all_images_to_resample)} images to resample.') + +for img_path in all_images_to_resample: + components = parse_bids_filename(img_path) + output_path = Path( + modify_bids_filename(img_path, space='MNI152NLin2009cAsym') + ) + results[str(output_path)] = { + 'infile': str(img_path), + } + if output_path.exists() and not overwrite: + continue + + img = nib.load(str(img_path)) + # use linear interpolation for binarized maps, then threshold at 0.5 + # this avoids empty voxels that can occur with NN interpolation + # resample to MNI space + if components['desc'] == 'binarized': + interpolation = 'linear' + else: + interpolation = 'continuous' + + resampled_img = resample_to_img( + img, + mni_template, + interpolation=interpolation, + force_resample=True, + copy_header=True, + ) + + if components['desc'] == 'binarized': + interpolation = 'linear' + # re-binarize + resampled_data = resampled_img.get_fdata() + binarized_data = (resampled_data > 0.5).astype(np.float32) + resampled_img = nib.Nifti1Image( + binarized_data, resampled_img.affine, resampled_img.header + ) + + resampled_img.to_filename(str(output_path)) + +with open(logdir / 'resampling_log.json', 'w') as f: + json.dump(results, f, indent=4) + +## 7: convert concatenated unthresh image to z scores +# some teams provided t instead of z scores + + +def TtoZ(data, df=54): + """ + takes a nibabel file object and converts from z to t + using Hughett's transform + adapted from: + https://github.com/vsoch/TtoZ/blob/master/TtoZ/scripts.py + - default to 54 which is full sample per condition for narps + """ + + # Select just the nonzero voxels + nonzero_vox = data != 0 + nonzero = data[nonzero_vox] + + # We will store our results here + Z = np.zeros(len(nonzero)) + + # Select values less than or == 0, and greater than zero + c = np.zeros(len(nonzero)) + k1 = nonzero <= c + k2 = nonzero > c + + # Subset the data into two sets + t1 = nonzero[k1] + t2 = nonzero[k2] + + # Calculate p values for <=0 + p_values_t1 = t.cdf(t1, df=df) + z_values_t1 = norm.ppf(p_values_t1) + + # Calculate p values for > 0 + p_values_t2 = t.cdf(-t2, df=df) + z_values_t2 = -norm.ppf(p_values_t2) + Z[k1] = z_values_t1 + Z[k2] = z_values_t2 + + # Write new image to file + new_nii = np.zeros(data.shape) + new_nii[nonzero_vox] = Z + + return new_nii + + +print('Converting unthresh images to z-scores...') + +# first load the spreadsheet to get the stats types +stats_types_df = pd.read_csv( + origdir / 'narps_neurovault_images_details_responses_corrected.csv' +) # .set_index('team_id') +stats_types_df.columns = [ + 'Timestamp', + 'team_id', + 'software', + 'unthresh_type', + 'thresh_type', + 'template', + 'h5', + 'h6', + 'h9', + 'comments', +] +stats_types_df['team_number'] = [ + team_id_to_number.get(tid, None) for tid in stats_types_df['team_id'] +] + +stat_type_by_team = {} +for _, row in stats_types_df.iterrows(): + team_number = row['team_number'] + if 't value' in row['unthresh_type'].strip().lower(): + stat_type_by_team[team_number] = 't' + else: + # default to z if unsure - i.e. no conversion + stat_type_by_team[team_number] = 'z' + +for team, stattype in stat_type_by_team.items(): + team_unthresh_images = find_bids_files( + datadir, + team=team, + type='unthresh', + space='MNI152NLin2009cAsym', + desc='rectified', + ) + if len(team_unthresh_images) == 0: + continue + if len(team_unthresh_images) > 1: + print( + f'Warning: multiple unthresh images found for team {team}, using first one.' + ) + unthresh_img_path = team_unthresh_images[0] + output_path = Path(modify_bids_filename(unthresh_img_path, suffix='zstat')) + if output_path.exists() and not overwrite: + continue + unthresh_img = nib.load(str(unthresh_img_path)) + unthresh_data = unthresh_img.get_fdata() + converted = False + if stattype == 't': + unthresh_data = TtoZ(unthresh_data, df=54) + converted = True + zstat_img = nib.Nifti1Image( + unthresh_data, unthresh_img.affine, unthresh_img.header + ) + zstat_img.to_filename(str(output_path)) + results[str(output_path)] = { + 'infile': str(unthresh_img_path), + 'original_stat_type': stattype, + } + +with open(logdir / 't_to_z_log.json', 'w') as f: + json.dump(results, f, indent=4) + +## 8: Create concatenated versions of all images + +concat_dir = basedir / 'data-concat' +if not concat_dir.exists(): + concat_dir.mkdir(parents=True, exist_ok=True) + +results = {} +for hyp in [target_hypothesis]: + print(f'Creating concatenated images for hypothesis {hyp}...') + + resampled_images = { + 'unthresh': find_bids_files( + datadir, + type='unthresh', + space='MNI152NLin2009cAsym', + hyp=str(hyp), + suffix='zstat', + ), + 'thresh': [], + } + team_ids = [] + for img_path in resampled_images['unthresh']: + components = parse_bids_filename(img_path) + team_ids.append(components['team']) + thresh_img_path = modify_bids_filename( + img_path, type='thresh', desc='binarized', suffix='mask' + ) + assert Path( + thresh_img_path + ).exists(), f'Binarized thresholded image not found for {img_path}' + resampled_images['thresh'].append(thresh_img_path) + assert len(resampled_images['thresh']) == len( + resampled_images['unthresh'] + ), 'Mismatch in number of unthresh and thresh images' + print( + f'Found {len(team_ids)} unthresh resampled images to concatenate for hypothesis {hyp}.' + ) + + suffix_dict = {'unthresh': 'zstat', 'thresh': 'mask'} + for imgtype in ['unthresh', 'thresh']: + img_list = [] + for img_path in resampled_images[imgtype]: + img = nib.load(str(img_path)) + img_list.append(img) + img_paths = [p.as_posix() for p in resampled_images[imgtype]] + # concatenate along 4th dimension + concat_img = nilearn.image.concat_imgs(img_list) + + output_path = ( + concat_dir + / f'hyp-{hyp}_type-{imgtype}_space-MNI152NLin2009cAsym_desc-concat_{suffix_dict[imgtype]}.nii.gz' + ) + concat_img.to_filename(str(output_path)) + print( + f'Saved concatenated {imgtype} image for hypothesis {hyp} to {output_path}' + ) + results[str(output_path)] = {'infiles': img_paths} + +with open(logdir / 'concatenation_log.json', 'w') as f: + json.dump(results, f, indent=4) diff --git a/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md b/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md new file mode 100644 index 0000000..64b9c96 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/RUNNING_WORKFLOWS.md @@ -0,0 +1,441 @@ +# Running the scRNA-seq Immune Aging Workflows + +This document provides examples of how to run each of the four workflow implementations for the immune aging scRNA-seq analysis. + +All workflows perform the same 11-step analysis pipeline: +1. Data Download +2. Data Filtering +3. Quality Control +4. Preprocessing +5. Dimensionality Reduction +6. Clustering +7. Pseudobulking +8. Differential Expression (per cell type) +9. Pathway Analysis / GSEA (per cell type) +10. Overrepresentation Analysis / Enrichr (per cell type) +11. Predictive Modeling (per cell type) + +--- + +## Prerequisites + +### Environment Setup + +All workflows require the `DATADIR` environment variable to be set, pointing to the base data directory. The workflows will create an `immune_aging/` subdirectory within this path. + +```bash +# Option 1: Set environment variable directly +export DATADIR=/path/to/your/data + +# Option 2: Create a .env file in your working directory +echo "DATADIR=/path/to/your/data" > .env +``` + +### Install Dependencies + +```bash +# From the repository root +uv pip install -e . +``` + +--- + +## 1. Monolithic Workflow + +The monolithic workflow is a single Python script that runs all analysis steps sequentially. It's the simplest implementation but lacks checkpointing and resumability. + +**Location:** `immune_scrnaseq_monolithic.py` + +### Running as a Script + +```bash +# Edit the datadir path in the script first, then run: +python src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py +``` + +### Running as a Jupyter Notebook + +The script uses jupytext format and can be opened directly in Jupyter: + +```bash +jupyter notebook src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py +``` + +### Output Location + +``` +{datadir}/workflow/figures/ +``` + +### Notes + +- No checkpointing - must run from start each time +- Analyzes only one cell type (hardcoded in script) +- Best for understanding the analysis pipeline + +--- + +## 2. Modular Workflow + +The modular workflow uses reusable pipeline functions organized by analysis step. It provides better code organization than the monolithic version but still lacks robust checkpointing. + +**Location:** `modular_workflow/run_workflow.py` + +### Running the Workflow + +```bash +# Using environment variable +export DATADIR=/path/to/your/data +python -m BetterCodeBetterScience.rnaseq.modular_workflow.run_workflow + +# Or import and run programmatically +python -c " +from pathlib import Path +from BetterCodeBetterScience.rnaseq.modular_workflow.run_workflow import run_full_workflow + +datadir = Path('/path/to/your/data/immune_aging') +results = run_full_workflow(datadir) +" +``` + +### Available Options + +The `run_full_workflow()` function accepts these parameters: + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `datadir` | Required | Base directory for data files | +| `dataset_name` | "OneK1K" | Name of the dataset | +| `url` | CELLxGENE URL | Source URL for the h5ad file | +| `cell_type_for_de` | "central memory CD4-positive, alpha-beta T cell" | Cell type for differential expression | +| `skip_download` | False | Skip data download if file exists | +| `skip_filtering` | False | Load pre-filtered data | +| `skip_qc` | False | Load post-QC data | + +### Output Location + +``` +{datadir}/workflow/figures/ +``` + +### Notes + +- Basic skip functionality for early steps +- Analyzes only one cell type +- Outputs figures only (no result files saved) + +--- + +## 3. Stateless Workflow (with Checkpointing) + +The stateless workflow adds robust checkpointing using BIDS-compliant naming. It can resume from any step and tracks execution history. + +**Location:** `stateless_workflow/run_workflow.py` + +### Running the Workflow + +```bash +# Basic run (resumes from last checkpoint automatically) +export DATADIR=/path/to/your/data +python -m BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow +``` + +### Force Re-run from a Specific Step + +```python +from pathlib import Path +from BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow import ( + run_stateless_workflow, + print_checkpoint_status, +) + +datadir = Path('/path/to/your/data/immune_aging') + +# Check current checkpoint status +print_checkpoint_status(datadir) + +# Force re-run from step 5 onwards +results = run_stateless_workflow(datadir, force_from_step=5) +``` + +### Available Options + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `datadir` | Required | Base directory for data files | +| `dataset_name` | "OneK1K" | Name of the dataset | +| `url` | CELLxGENE URL | Source URL for the h5ad file | +| `cell_type_for_de` | "central memory CD4-positive, alpha-beta T cell" | Cell type for differential expression | +| `force_from_step` | None | Clear checkpoints from this step onwards | +| `checkpoint_steps` | {2,3,5,8,9,10,11} | Which steps to save checkpoints for | + +### Utility Functions + +```python +from BetterCodeBetterScience.rnaseq.stateless_workflow.run_workflow import ( + list_checkpoints, + print_checkpoint_status, + list_execution_logs, + load_execution_log, +) + +# List all checkpoints +checkpoints = list_checkpoints(datadir) + +# Print checkpoint status with file sizes +print_checkpoint_status(datadir) + +# View execution history +logs = list_execution_logs(datadir) +if logs: + log = load_execution_log(logs[0]) # Load most recent + log.print_summary() +``` + +### Output Location + +``` +{datadir}/workflow/ +├── checkpoints/ # BIDS-named checkpoint files +├── figures/ # Visualization outputs +└── logs/ # Execution logs (JSON) +``` + +### Notes + +- Automatic checkpointing and resumption +- Execution logging with timing information +- Analyzes only one cell type +- Step 3 checkpoint required for pseudobulking + +--- + +## 4. Prefect Workflow + +The Prefect workflow uses the Prefect orchestration framework and analyzes all cell types in parallel. + +**Location:** `prefect_workflow/run_workflow.py` + +### Running the Workflow + +```bash +# Basic run with default config +python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --datadir /path/to/data/immune_aging + +# With custom config file +python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \ + --datadir /path/to/data/immune_aging \ + --config /path/to/custom_config.yaml + +# Force re-run from step 8 +python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \ + --datadir /path/to/data/immune_aging \ + --force-from 8 +``` + +### List Available Cell Types + +```bash +python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \ + --datadir /path/to/data/immune_aging \ + --list-cell-types +``` + +### Analyze a Single Cell Type + +```bash +python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow \ + --datadir /path/to/data/immune_aging \ + --cell-type "central memory CD4-positive, alpha-beta T cell" +``` + +### CLI Options + +| Option | Description | +|--------|-------------| +| `--datadir` | Base directory for data files | +| `--config` | Path to custom config YAML file | +| `--force-from` | Force re-run from this step onwards (1-11) | +| `--cell-type` | Analyze a single cell type only | +| `--list-cell-types` | List available cell types and exit | + +### Configuration File + +The default configuration is in `prefect_workflow/config/config.yaml`. You can create a custom config to override any parameters: + +```yaml +# Custom config example +dataset_name: "MyDataset" + +filtering: + cutoff_percentile: 2.0 + min_cells_per_celltype: 20 + +qc: + min_genes: 300 + max_genes: 5000 + +differential_expression: + n_cpus: 16 + +min_samples_per_cell_type: 20 +``` + +### Output Location + +``` +{datadir}/wf_prefect/ +├── checkpoints/ # BIDS-named checkpoint files +├── figures/ # Visualization outputs +├── results/per_cell_type/ # Per-cell-type analysis results +│ └── {cell_type}/ +│ ├── stat_res.pkl +│ ├── de_results.parquet +│ ├── counts.parquet +│ ├── gsea_results.pkl +│ ├── enrichr_up.pkl +│ ├── enrichr_down.pkl +│ └── prediction_results.pkl +└── logs/ # Execution logs +``` + +### Notes + +- Analyzes ALL cell types (not just one) +- Configuration via YAML file +- Results saved per cell type +- Uses Prefect for orchestration and logging + +--- + +## 5. Snakemake Workflow + +The Snakemake workflow uses the Snakemake workflow management system with dynamic rule generation for per-cell-type analysis. + +**Location:** `snakemake_workflow/Snakefile` + +### Running the Workflow + +```bash +cd src/BetterCodeBetterScience/rnaseq/snakemake_workflow + +# Run full workflow +snakemake --cores 16 --config datadir=/path/to/data/immune_aging + +# Dry run (see what would be executed) +snakemake -n --config datadir=/path/to/data/immune_aging + +# Run only preprocessing (steps 1-6) +snakemake --cores 16 preprocessing_only --config datadir=/path/to/data/immune_aging + +# Run only through pseudobulking (steps 1-7) +snakemake --cores 16 pseudobulk_only --config datadir=/path/to/data/immune_aging +``` + +### Force Re-run from a Specific Rule + +```bash +# Force re-run from dimensionality reduction +snakemake --cores 16 --forcerun dimensionality_reduction \ + --config datadir=/path/to/data/immune_aging + +# Force re-run from a specific cell type's DE +snakemake --cores 16 --forcerun differential_expression \ + --config datadir=/path/to/data/immune_aging +``` + +### Configuration + +Configuration is in `snakemake_workflow/config/config.yaml`. Override any parameter via command line: + +```bash +snakemake --cores 16 --config \ + datadir=/path/to/data/immune_aging \ + dataset_name=MyDataset \ + min_samples_per_cell_type=20 +``` + +### Generate Workflow Visualization + +```bash +# Generate rule graph +snakemake --rulegraph --config datadir=/path/to/data/immune_aging | dot -Tpng > rulegraph.png + +# Generate DAG for specific run +snakemake --dag --config datadir=/path/to/data/immune_aging | dot -Tpng > dag.png +``` + +### Output Location + +``` +{datadir}/wf_snakemake/ +├── checkpoints/ # BIDS-named checkpoint files +├── figures/ # Visualization outputs +├── results/ +│ ├── per_cell_type/ # Per-cell-type analysis results +│ │ └── {cell_type}/ +│ │ ├── stat_res.pkl +│ │ ├── de_results.parquet +│ │ ├── counts.parquet +│ │ ├── gsea_results.pkl +│ │ ├── enrichr_up.pkl +│ │ ├── enrichr_down.pkl +│ │ └── prediction_results.pkl +│ └── workflow_complete.txt +└── logs/ # Step logs +``` + +### Notes + +- Uses Snakemake checkpoint mechanism for dynamic cell type discovery +- Analyzes ALL cell types +- Automatic dependency tracking and parallel execution +- See `WORKFLOW_OVERVIEW.md` for detailed step documentation + +--- + +## Workflow Comparison + +| Feature | Monolithic | Modular | Stateless | Prefect | Snakemake | +|---------|------------|---------|-----------|---------|-----------| +| Checkpointing | No | Limited | Yes | Yes | Yes | +| Resume from step | No | Limited | Yes | Yes | Yes | +| All cell types | No | No | No | Yes | Yes | +| Config file | No | No | No | Yes | Yes | +| Execution logs | No | No | Yes | Yes | Yes | +| Parallel execution | No | No | No | Sequential | Yes | +| Output folder | workflow | workflow | workflow | wf_prefect | wf_snakemake | + +--- + +## Troubleshooting + +### Memory Issues + +The dataset is large (~1.2M cells). If you encounter memory issues: + +1. Use a machine with at least 64GB RAM +2. For Prefect/Snakemake workflows, reduce `--cores` to limit parallel jobs +3. For the stateless workflow, ensure checkpoints are saved to reduce memory pressure + +### Missing Dependencies + +```bash +# Install all dependencies +uv pip install -e ".[dev]" + +# For Snakemake specifically +uv pip install snakemake>=8.0 +``` + +### Environment Variable Not Set + +If you see "DATADIR environment variable not set": + +```bash +# Set it for your session +export DATADIR=/path/to/your/data + +# Or create .env file +echo "DATADIR=/path/to/your/data" > .env +``` diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb new file mode 100644 index 0000000..3fbe4cb --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_1_dataprep.ipynb @@ -0,0 +1,406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b317a9e1", + "metadata": {}, + "source": [ + "### Immune system gene expression and aging\n", + "\n", + "We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total. These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants. \n", + "\n", + "The flagship paper for this study is:\n", + "\n", + "Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022)\n", + "\n", + "We will use the data to ask a simple question: how does gene expression in PBMCs change with age?" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0d3385e0", + "metadata": {}, + "outputs": [], + "source": [ + "import anndata as ad\n", + "from anndata.experimental import read_lazy\n", + "import dask.array as da\n", + "import h5py\n", + "import numpy as np\n", + "import scanpy as sc\n", + "from pathlib import Path\n", + "import os\n", + "\n", + "datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7b67c0b6", + "metadata": {}, + "outputs": [], + "source": [ + "datafile = datadir / 'a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'\n", + "url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad'\n", + "dataset_name = 'OneK1K'\n", + "\n", + "if not datafile.exists():\n", + " cmd = f'wget -O {datafile.as_posix()} {url}'\n", + " print(f'Downloading data from {url} to {datafile.as_posix()}')\n", + " os.system(cmd)\n", + "\n", + "load_annotation_index = True\n", + "adata = read_lazy(h5py.File(datafile, 'r'),\n", + " load_annotation_index=load_annotation_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "40d53939", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 1248980 × 35528\n", + " obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n", + " var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type'\n", + " uns: 'cell_type_ontology_term_id_colors', 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n", + " obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n", + " varm: 'PCs'\n" + ] + } + ], + "source": [ + "print(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "7eeca179", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['CD14-low, CD16-positive monocyte' 'CD14-positive monocyte'\n", + " 'CD16-negative, CD56-bright natural killer cell, human'\n", + " 'CD4-positive, alpha-beta T cell'\n", + " 'CD4-positive, alpha-beta cytotoxic T cell'\n", + " 'CD8-positive, alpha-beta T cell'\n", + " 'central memory CD4-positive, alpha-beta T cell'\n", + " 'central memory CD8-positive, alpha-beta T cell'\n", + " 'conventional dendritic cell' 'dendritic cell'\n", + " 'double negative thymocyte'\n", + " 'effector memory CD4-positive, alpha-beta T cell'\n", + " 'effector memory CD8-positive, alpha-beta T cell' 'erythrocyte'\n", + " 'gamma-delta T cell' 'hematopoietic precursor cell'\n", + " 'innate lymphoid cell' 'memory B cell' 'mucosal invariant T cell'\n", + " 'naive B cell' 'naive thymus-derived CD4-positive, alpha-beta T cell'\n", + " 'naive thymus-derived CD8-positive, alpha-beta T cell'\n", + " 'natural killer cell' 'peripheral blood mononuclear cell' 'plasmablast'\n", + " 'plasmacytoid dendritic cell' 'platelet' 'regulatory T cell'\n", + " 'transitional stage B cell']\n" + ] + } + ], + "source": [ + "unique_cell_types = np.unique(adata.obs['cell_type'])\n", + "print(unique_cell_types)" + ] + }, + { + "cell_type": "markdown", + "id": "c763a5e1", + "metadata": {}, + "source": [ + "### Filtering out bad donors" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a0e4918c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Donor Cell Count Statistics:\n", + "count 981.000000\n", + "mean 1273.170234\n", + "std 322.280557\n", + "min 333.000000\n", + "25% 1070.000000\n", + "50% 1246.000000\n", + "75% 1446.000000\n", + "max 3511.000000\n", + "Name: count, dtype: float64\n", + "cutoff of 894 would exclude 98 donors\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from scipy.stats import scoreatpercentile\n", + "\n", + "# 1. Calculate how many cells each donor has\n", + "donor_cell_counts = pd.Series(adata.obs['donor_id']).value_counts()\n", + "\n", + "# Print some basic statistics to read the exact numbers\n", + "print(\"Donor Cell Count Statistics:\")\n", + "print(donor_cell_counts.describe())\n", + "\n", + "# 2. Plot the histogram\n", + "plt.figure(figsize=(10, 6))\n", + "# Bins set to 'auto' or a fixed number depending on your N of donors\n", + "plt.hist(donor_cell_counts.values, bins=50, color='skyblue', edgecolor='black')\n", + "\n", + "plt.title('Distribution of Total Cells per Donor')\n", + "plt.xlabel('Number of Cells Captured')\n", + "plt.ylabel('Number of Donors')\n", + "plt.grid(axis='y', alpha=0.5)\n", + "\n", + "# Optional: Draw a vertical line at the propsoed cutoff\n", + "# This helps you visualize how many donors you would lose.\n", + "cutoff_percentile = 10 # e.g., 10th percentile\n", + "min_cells_per_donor = int(scoreatpercentile(donor_cell_counts.values, cutoff_percentile))\n", + "print(f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors')\n", + "plt.axvline(min_cells_per_donor, color='red', linestyle='dashed', linewidth=1, label=f'Cutoff ({min_cells_per_donor} cells)')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "8ad05821", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filtering to keep only donors with at least 894 cells.\n", + "Number of donors excluded: 98\n" + ] + } + ], + "source": [ + "print(f\"Filtering to keep only donors with at least {min_cells_per_donor} cells.\")\n", + "print(f\"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}\")\n", + "valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index\n", + "adata = adata[adata.obs['donor_id'].isin(valid_donors)]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "5a5e8f9b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of donors after filtering: 883\n" + ] + } + ], + "source": [ + "print(f'Number of donors after filtering: {len(valid_donors)}')" + ] + }, + { + "cell_type": "markdown", + "id": "81b16da4", + "metadata": {}, + "source": [ + "### Filtering cell types by frequency\n", + "\n", + "Drop cell types that don't have at least 10 cells for at least 95% of people" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "00dff55b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keeping 8 cell types out of 29\n", + "Cell types to keep: ['central memory CD4-positive, alpha-beta T cell', 'effector memory CD4-positive, alpha-beta T cell', 'effector memory CD8-positive, alpha-beta T cell', 'memory B cell', 'naive B cell', 'naive thymus-derived CD4-positive, alpha-beta T cell', 'natural killer cell', 'regulatory T cell']\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# 1. Calculate the count of cells for each 'cell_type' within each 'donor_id'\n", + "# We use pandas crosstab on adata.obs, which is loaded in memory.\n", + "counts_per_donor = pd.crosstab(adata.obs['donor_id'], adata.obs['cell_type'])\n", + "\n", + "# 2. Identify cell types to keep\n", + "# Keep if >= 10 cells in at least 90% of donors\n", + "\n", + "min_cells = 10\n", + "percent_donors = 0.9\n", + "donor_count = counts_per_donor.shape[0]\n", + "cell_types_to_keep = counts_per_donor.columns[\n", + " (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors)]\n", + "\n", + "print(f\"Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}\")\n", + "print(f\"Cell types to keep: {cell_types_to_keep.tolist()}\")\n", + "\n", + "# 3. Filter the AnnData object\n", + "# We subset the AnnData to include only observations belonging to the valid cell types.\n", + "adata_filtered = adata[adata.obs['cell_type'].isin(cell_types_to_keep)]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ba931464", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final number of donors after filtering: 698\n" + ] + } + ], + "source": [ + "# now drop subjects who have any zeros in these cell types\n", + "donor_celltype_counts = pd.crosstab(adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type'])\n", + "valid_donors_final = donor_celltype_counts.index[\n", + " (donor_celltype_counts >= min_cells).all(axis=1)]\n", + "adata_filtered = adata_filtered[adata_filtered.obs['donor_id'].isin(valid_donors_final)]\n", + "print(f\"Final number of donors after filtering: {len(valid_donors_final)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "f741845e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading data into memory (this can take a few minutes)...\n", + "Filtering genes with zero counts...\n" + ] + } + ], + "source": [ + "\n", + "print(\"Loading data into memory (this can take a few minutes)...\")\n", + "adata_loaded = adata_filtered.to_memory()\n", + "\n", + "# filter out genes with zero counts across all selected cells\n", + "print(\"Filtering genes with zero counts...\")\n", + "sc.pp.filter_genes(adata_loaded, min_counts=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "310f8343", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 785021 × 29331\n", + " obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n", + " var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type', 'n_counts'\n", + " uns: 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n", + " obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n", + " varm: 'PCs'\n" + ] + } + ], + "source": [ + "print(adata_loaded)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "ecb61446", + "metadata": {}, + "outputs": [], + "source": [ + "adata_loaded.write(datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "10b6c9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 22022184\n", + "-rw-r--r--@ 1 poldrack staff 4.1G Dec 19 09:03 a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad\n", + "-rw-r--r--@ 1 poldrack staff 6.4G Dec 20 09:36 dataset-OneK1K_subset-immune_filtered.h5ad\n", + "-rw-r--r-- 1 poldrack staff 185B Dec 19 09:02 get_data.sh\n" + ] + } + ], + "source": [ + "!ls -lh /Users/poldrack/data_unsynced/BCBS/immune_aging" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "BetterCodeBetterScience", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb new file mode 100644 index 0000000..02a3b5e --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_2_preprocess.ipynb @@ -0,0 +1,1984 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c3333c8c", + "metadata": {}, + "source": [ + "Preprocessing based on suggestions from Google Gemini\n", + "\n", + "based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html\n", + "\n", + "and https://www.10xgenomics.com/analysis-guides/common-considerations-for-quality-control-filters-for-single-cell-rna-seq-data\n", + "\n", + "Code in this notebook primarily generated using Gemini 3.0" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5e94c5f6", + "metadata": {}, + "outputs": [], + "source": [ + "import anndata as ad\n", + "import dask.array as da\n", + "import h5py\n", + "import numpy as np\n", + "import scanpy as sc\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3c5b35d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AnnData object with n_obs × n_vars = 785021 × 29331\n", + " obs: 'orig.ident', 'nCount_RNA', 'nFeature_RNA', 'percent.mt', 'donor_id', 'pool_number', 'predicted.celltype.l2', 'predicted.celltype.l2.score', 'age', 'tissue_ontology_term_id', 'assay_ontology_term_id', 'disease_ontology_term_id', 'cell_type_ontology_term_id', 'self_reported_ethnicity_ontology_term_id', 'development_stage_ontology_term_id', 'sex_ontology_term_id', 'is_primary_data', 'suspension_type', 'tissue_type', 'cell_type', 'assay', 'disease', 'sex', 'tissue', 'self_reported_ethnicity', 'development_stage', 'observation_joinid'\n", + " var: 'vst.mean', 'vst.variance', 'vst.variance.expected', 'vst.variance.standardized', 'vst.variable', 'feature_is_filtered', 'feature_name', 'feature_reference', 'feature_biotype', 'feature_length', 'feature_type', 'n_counts'\n", + " uns: 'citation', 'default_embedding', 'organism', 'organism_ontology_term_id', 'schema_reference', 'schema_version', 'title'\n", + " obsm: 'X_azimuth_spca', 'X_azimuth_umap', 'X_harmony', 'X_pca', 'X_umap'\n", + " varm: 'PCs'\n" + ] + } + ], + "source": [ + "adata = ad.read_h5ad(datadir / 'dataset-OneK1K_subset-immune_filtered.h5ad')\n", + "print(adata)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "003237c7", + "metadata": {}, + "outputs": [], + "source": [ + "var_to_feature = dict(zip(adata.var_names, adata.var['feature_name']))\n" + ] + }, + { + "cell_type": "markdown", + "id": "ca1edf40", + "metadata": {}, + "source": [ + "### Quality control\n", + "\n", + "based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a95e8baa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of mitochondrial genes: 13\n", + "Number of ribosomal genes: 107\n", + "Number of hemoglobin genes: 12\n" + ] + } + ], + "source": [ + "# mitochondrial genes\n", + "adata.var[\"mt\"] = adata.var['feature_name'].str.startswith(\"MT-\")\n", + "print(f\"Number of mitochondrial genes: {adata.var['mt'].sum()}\")\n", + "\n", + "# ribosomal genes\n", + "adata.var[\"ribo\"] = adata.var['feature_name'].str.startswith((\"RPS\", \"RPL\"))\n", + "print(f\"Number of ribosomal genes: {adata.var['ribo'].sum()}\")\n", + "\n", + "# hemoglobin genes.\n", + "adata.var[\"hb\"] = adata.var['feature_name'].str.contains(\"^HB[^(P)]\")\n", + "print(f\"Number of hemoglobin genes: {adata.var['hb'].sum()}\")\n", + "\n", + "sc.pp.calculate_qc_metrics(\n", + " adata, qc_vars=[\"mt\", \"ribo\", \"hb\"], inplace=True, percent_top=[20], log1p=True\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "c79181f1", + "metadata": {}, + "source": [ + "#### Visualization of distributions " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a4819733", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABeQAAAHqCAYAAABlfU4LAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvQnYHFWV/19JSEJCCEtYJIQ1gAYChDUGWUSWsI2o7K6DCrIpyCoqII6Aw6ijAjLgAv7cEBgZR0EYQEBUQBBBdlkVlEVRZA0kUP/nlP/Tnve859y6VV3dXdX1/TzPfbq7+tbdq2/19546d0yapmkCAAAAAAAAAAAAAAAAAICeMra3yQMAAAAAAAAAAAAAAAAAgIAgDwAAAAAAAAAAAAAAAAD0AQjyAAAAAAAAAAAAAAAAAEAfgCAPAAAAAAAAAAAAAAAAAPQBCPIAAAAAAAAAAAAAAAAAQB+AIA8AAAAAAAAAAAAAAAAA9AEI8gAAAAAAAAAAAAAAAABAH4AgDwAAAAAAAAAAAAAAAAD0AQjyAAAAAAAAAAAAAAAAAEAfgCAPAOg5//qv/5q87W1vG3QxAAAAAFCAa6+9NhkzZkzyzDPPDLooAAAAAAAADA0Q5AFoKW9+85uTI444oufnNJFHHnkkEyBuu+22QRcFAAAAAD3mU5/6VDJnzpxBFwMAAEDNaepCdV3+31IZ/ud//megZQCgLkCQBwAAAAAAAAAAAAAAAAD6AAR5AFrqQua6665LvvSlL2Wr1BRo1ZyObb755snEiROTlVZaKfnYxz6WLFq0KHjOq6++mnzgAx9I1lhjjWTSpEnJ61//+ixOWV577bXk9NNPT9Zaa62sHKuuumpyyimndL6/4447kre85S1ZXtOmTUsOPPDA5Pnnnw9a8ZO7HCo/s/rqqyennnpq8v73vz9ZcsklszzOPffczvdUF2KjjTbK6klpskUEtc8SSyyRLL300smb3vSm5Pe//33pugIAAKg/NAd85CMfSY499thk2WWXTV73utdlFtUx3HvvvcmWW26ZLL744sm6666bXHXVVaOswx599NFk7733zuYVSn/33XfP5lft9u1zn/tcNjfT3HfooYcmCxcu7MR5+eWXk6OPPjpZeeWVszlq7ty52ZzF0Fz1L//yL8kyyyyTfb/eeusll112WXQb/OIXv0g22GCDrB5vfOMbkzvvvDM7/sILLyRTp05NLr744hHxqX6Uz3PPPZeb9mOPPZbst99+Wd3pnE033TS56aabOt+fffbZycyZM5MJEyZk9xjf+ta3ghZ/ZLVIx7j+bM149dVXZ2lPnjw52WKLLZL77rsv+/78889PTj755OT222/v3N/QsTRNs36mewS6H5k+fXo2DgAAADR/Xj/ssMOysNRSSyXLLbdccsIJJ2S/+zynHnfccckqq6yS/f7T/9Kvf/3r2Zyz7bbbZnFoPqX5Qv7HbNP/W36y7Bvf+EaW15QpU5JDDjkk0waornSvtMIKK4yoJ5WRePvb356VgT8D0FYgyAPQQkgwnzdvXnLAAQckjz/+eBbGjx+f7LLLLslmm22W/SmlP8B04/GZz3zGPYduUugGY8aMGclFF12U3H333cmJJ56YfPzjH08uvPDCUmU7/vjjk89+9rPZTRGl993vfjdZccUVO3/858+fn90A3XzzzVmeJG7QzVRRPv/5z2d/zH/zm99kNw8HH3xw58/5r371q+yV0qZ6/uAHP8gWJujGZ5tttkl++9vfJjfccEN2s0Q3EwAAAIabb37zm9mfVRKK6Y/mpz/96eTKK68MnkN/SmneIAGYzqM/xp/4xCdGxCFRneY1+vN8/fXXZ8I3/andaaedkldeeaUT75prrkkefPDB7JXKQoIxBYbmQZqXLrjggmyO2muvvbI07r///ux7EvBJYPjZz36W/fH/93//9yyfWI455phs3qS5d/nll8/EfSo7tcm+++6bnHfeeSPi0+c999wzq1cIEhxoXv3jH/+Y/O///m92/0ELH3RvQVxyySXJ4Ycfnhx11FHZIsCHPvShZP/998/aoSjU9lSHW265JVlsscUy0YLYZ599svRpkYLvb+jYf//3fyf/+Z//mZxzzjlZO9Iiw/rrr184XwAAAPWD5lKaC+h/H/3P/cIXvpB87Wtfy75773vfm3zve99LvvzlLyf33HNPNg/QnEn/fWluIOh/I80XMYZow/r/lu5LfvKTnySXX3551l6kHey6667ZQjsZ8tG9xic/+cnOIjvVj+8RqAz8GYDWkgIAWsk222yTHn744Z3PH//4x9PXv/716WuvvdY5dtZZZ6VTpkxJX331VfMcj0MPPTTdY489Op/f9773pbvvvnvuec8++2w6ceLE9Ktf/ar5/bnnnpsus8wy6fPPP985dumll6Zjx45Nn3jiCbeMlDeVgVlttdXSd7/73Z3PVOcVVlghPfvss7PPDz/8MJlHpL/5zW86cZ5++uns2LXXXptbDwAAAMMDzStbbrnliGObbbZZetxxxwXP+8lPfpIutthi6eOPP945duWVV2ZzySWXXJJ9/ta3vjVq7n355ZfTSZMmpVdccUX2meYvmrcWLVrUibPXXnul++yzT/b+97//fTpu3Lj0j3/844j8t9tuu/T444/P3q+//vrppz71qcJ1v+aaa7LyXnDBBSPmQyrf97///ezzTTfdlOX/pz/9Kfv85JNPZvWOmS/POeecdMkll8zStNhiiy3SAw44YMQxqvsuu+ziztd/+9vfsmNUdlmHq666asS9Ax176aWXss8nnXRSuuGGG47I5/Of/3y6zjrrpK+88kpESwEAAGjSvD5r1qwRcy/N6XTsvvvuy+YHmq8teE6huSaGYf1/S/Pm5MmTs/ox8+fPT1dfffWOdkDQPc5pp53W+SzvgQBoO7CQBwBk0Oo/WcDLFXF6ZI2s12iVO8RZZ52VbLLJJpnVHFkPkBXgH/7wh1JlIAu+7bbbzv1+ww03zCzyZBnJko5X/2OhR+8ZqjM9VvfUU0+58elRenoskCwYyDKQrCFoZR8AAMDwI+cMglzHhOYMguYlsqaj+YWhx8IlZBH+wAMPZJbkNH9SoPlmwYIFmeUZQ9bb48aNM/Mni3eyxl9nnXU6aVAg6zROg1yt0BNvNGeedNJJmSVcEej+gKHykesYmpO5TlQ+sjYkvv3tbyerrbZasvXWW+emS65m6PF5StOC8qAyS+gz5122D6n9iFAf0lMGL730UrLmmmtmTweStT678QMAANBsyP2a/N9L8xw9DUXW5TTfktV4FQzz/1tyOSOfhCOrf3LPN3bs2BHH8u6XAGgrEOQBAF1Bj8eT31ryI/9///d/2Z9repxcPmofC/nN6xa6AWD/f4z0s8uQix4J3bTwI/Ie9HgdPcpHvme///3vZ+LHjTfe2HWZAQAA1Jsyc0YMtOhNC9o0d8rwu9/9LnnnO98ZlT+lQeLBr3/96xFp0J98fpT+gx/8YPLQQw8l73nPezIBnx5pP+OMM5KqoPTZhQ7NlXQfEPPIe7fzPv/pl/O+NefrNuSyhfqQFlNIDPnKV76SlZMe/6dFBi99AAAAzYf2SqmSYf5/a+XXq/slAIYRCPIAtBTaHI0s6phZs2Zlk7Gc7MmXLa16k4946xyOQxM4/VElKzfarEZa9RVh7bXXzm5aaOM1CyojWROSrz2ZP92kkLUeQVb6cmWfysubz8VC9eRzNVRH8gP4y1/+Mpk9e3bmAxAAAADQ0LxEG7Y++eSTnWPaX+rGG2+cWeTRxmc0f8pAG83FQPMSzVdkgabTkNb5JDAfdNBBmd9Y8pn+1a9+Nbou8s/53/72t2zBgOZk5t3vfne2CRz52yX/uO973/uirflo8eCvf/2r+T3lQfO8hD6TBR7P+YSc9+UGr7FY9zcE3ZOQ1SDViza+o/skWtAAAADQbOTm4TzP0X9RslYnAZmeMiv6P9EC/29HQoJ9bNsBMOxAkAegpdAjZnQjQrvF/+Uvf8kEdRIOPvzhDyf33ntv8sMf/jB7rP3II4/sWKDpc+hmhW4yaIO0K664IvuDTpvVlN2ghSwSaEd72tDt//2//5cJ+3RzRBvEEO9617uyOPRHn25CaFM3Ki9Z/PHGOLRD/aWXXpoFqgdtZvPMM88UKgcJI3TjRBvUkJDy97//PXn44YezGxX6M06iAz0NQCKKFCQAAAAAZocddkhmzpyZzVnkIob+YNPmZtJCm+a15ZZbLtl9992zTV1priHhl1zM5LmLY8iajdKhTehIbKc0aPO20047LZsLiSOOOCKbp+m7W2+9NZs/i8xftIktiQk099Lj7VRm2giOoc3o3vGOd2Sbv+64446dhfw89ttvv2zRgNKi9iErftowj+ZagtIjy3vaaJ7mXNp0j+pIT+YRNFeT2wHaLI+eCCABhdu4CHR/Q21DYj7d35B7AcqX7j+ozlQucsVD+ZE7HgAAAM2G3KvS/1x6Eoo2JKWnxmgTcZoPaN6mjb9pM2+ely+88MLsPJoDaA7/8Y9/nPz5z3/OnlILgf+3I6H2pfuJJ554IlvgB6DNQJAHoKXQn1l6xJ2szGjVnR57u+yyy7I/8WQZQFZ05IZG/rHV59CNzIc+9KHsT/g+++yTzJ07N3n66aczcb8sJOiT5d6JJ56Y3QxQuux3bvLkyZmgQJZ0m222WbLnnntm/vjOPPPMzvl080Q3NCRMkO8/8v267bbbFirDYostllnDnXPOOcn06dMzoYTyphugPfbYIxM/aAf6Qw89NKs/AAAAoKH5kv7M0591mrPIrcsnPvGJEY/E09zys5/9LFl11VWzuZTmPZp7yYf81KlTo/OiR85p3qP5kyzqSOCmxXFKlyBrNJqzKP2ddtopm8fIFUssJHiTUEHudehP9I9+9KOOtR1D5SZ3dTQPx0JpkABAQsEuu+ySrL/++lle7C+f6kFudz73uc9lfuppXqa6vvnNb+6k8Y1vfCPz7U5lo4UH8pVfFJrbqV3ofoHub0icWXrppbOnCMiXL1nyX3XVVVm9p02bVjh9AAAA9YLmTNonhPZBofmR5jj6f0fQIjD9z6T/tG94wxuyfUTYgn3llVdOTj755ORjH/tYJpgfdthhuXnh/+0/+fznP59ceeWV2VN7ZJkPQJsZQzu7DroQAAAAAAAADDtkBb7llltmG7mS9fww8a1vfSv56Ec/mvzpT38aJdYDAAAAdYEWdefMmZN88YtfHHRRAAAtZrFBFwAAAAAAAIBh5JJLLkmmTJmSuXcjEZ4s8MjiepjE+BdffDHzbUuW7WRVBzEeAAAAAACAMHBZAwDoG+TihoQJL9D3AAAAQBP4zne+485n5F6FeO6557LHv+mRd/K9To+j0x4tdYHc03l1oO9iOP3007P6kS948kUrOfXUU930d9555x7VCgAAAOgPw/r/lu5jvDrR/Q8AoHvgsgYA0DfIxyttCBva5IX82wEAAAB1h8R22hjNYvz48Y3Y/JN82D777LPmd+TDnny7dwP5xKVgQZvLkS9eAAAAoKkM6/9b2uSV9pizIN/5Sy65ZN/LBMCwAUEeAAAAAAAAAAAAAAAAAOgDcFkDAAAAAAAAAAAAAAAAAPQBCPIAAAAAAAAAAAAAAAAAQB+AIF8R5PmHfHDCAxAAAAAwWDAnAwAAAPUB8zIAAAAwEgjyFW7stdRSS2WvAAAAABgcmJMBAACA+oB5GQAAABgJBHkAAAAAAAAAAAAAAAAAoA9AkAcAAAAAAAAAAAAAAAAA+gAEeQAAAAAAAAAAAAAAAACgD0CQBwAAAAAAAAAAAAAAAAD6AAR5AAAAAAAAAAAAAAAAAKAPQJAHAAAAAAAAAAAAAAAAAIZdkD/77LOTDTbYIJk6dWoW5s2bl/zkJz/pfP/mN785GTNmzIhw0EEHjUjjD3/4Q7LrrrsmkydPTlZYYYXkmGOOSRYtWjQizrXXXptsvPHGycSJE5O11lorOf/880eV5ayzzkpWX331ZPHFF0/mzp2b/OpXv+phzQEAAAAAAAAAAAAAAAC0jYEK8jNmzEg++9nPJr/+9a+TW265JXnLW96S7L777sldd93ViXPAAQckjz/+eCecfvrpne9effXVTIx/5ZVXkl/+8pfJN7/5zUxsP/HEEztxHn744SzOtttum9x2223JEUcckXzwgx9Mrrjiik6c73//+8mRRx6ZnHTSScmtt96abLjhhsn8+fOTp556qo+tAQAAAAAAAAAA1Af6z33CCScka6yxRjJp0qRk5syZyb/9278laZoOumgAAABAYxmT1mwmXXbZZZP/+I//SD7wgQ9kFvJz5sxJvvjFL5pxyZp+t912S/70pz8lK664Ynbsv/7rv5Ljjjsu+fOf/5xMmDAhe3/ppZcmd955Z+e8fffdN3nmmWeSyy+/PPtMFvGbbbZZcuaZZ2afX3vttWSVVVZJPvzhDycf+9jHosr97LPPJksttVTy97//PbP2BwAAAMBgwJwMAAAAVMOpp56afOELX8iM39Zbb73MkG7//fdPTjnllOQjH/lIVBqYlwEAAICa+pCnlfcLLrggeeGFFzLXNcx3vvOdZLnllktmz56dHH/88cmLL77Y+e6GG25I1l9//Y4YT5BlO034bGVPcbbffvsReVEcOk6QdT1Z6Ms4Y8eOzT5zHIuXX345y0cGAAAAAAAAAABgWKAn0ekpdnrqnFy87rnnnsmOO+4IF68AAABAFyyWDJg77rgjE+AXLFiQTJkyJbnkkkuSddddN/vune98Z7Laaqsl06dPT377299m1u733Xdf8oMf/CD7/oknnhghxhP8mb4LxSEB/aWXXkr+9re/ZYsBVpx7773XLfdpp52WnHzyyRW1AgAAAAAAAAAAUC+22GKL5Nxzz01+97vfJeuss05y++23Jz//+c8zq/mQ8RoFBsZrAAAAQM0E+de//vWZb3d6fO3iiy9O3ve+9yXXXXddJsofeOCBnXhkCb/SSisl2223XfLggw9mvusGCVnrk995eZNBbm4AAAAAAAAAAIBhgFy40n/dN7zhDcm4ceMyYzZyV/Oud73LPQfGawAAAEDNXdaQn/e11lor2WSTTbKJmzZU/dKXvmTGJV/vxAMPPJC9vu51r0uefPLJEXH4M30XikO+62hTGnKHQzcWVhxOw2LixIlZGjIAAAAAAAAAAADDwoUXXpi5kf3ud7+b3HrrrZkv+c997nPZa8h4jQzuODz66KN9LTMAAABQdwYuyGtoQ1X5eJuELOkJspQnyNUNubx56qmnOnGuvPLKTBxntzcU5+qrrx6RDsVhP/W0IECLATIOlYE+S1/2AAAAAAAAAABAmzjmmGMyK/l99903e2r9Pe95T/LRj340M6bzgPEaAAAAUGOXNbRyvvPOOyerrrpq8txzz2Wr7tdee21yxRVXZG5p6PMuu+ySTJs2LfMhTxP/1ltvnWywwQbZ+bSZDAnvdFNw+umnZ/7iP/nJTyaHHnpodhNAHHTQQcmZZ56ZHHvsscn73//+5Kc//Wm2yn/ppZd2ykGuZ8hVzqabbppsvvnmyRe/+MVsc1naPR4AAAAAAAAAAGgjL774YjJ27Eg7PnrCnIzYAAAAANBAQZ4s29/73vcmjz/+eLLUUktlQjuJ8TvssEP2WNtVV13VEcfJP/see+yRCe7yRuDHP/5xcvDBB2fW7EsssUQmrH/605/uxFljjTUy8Z3EfHKFM2PGjORrX/taMn/+/E6cffbZJ/nzn/+cnHjiiZmoP2fOnOTyyy8ftdErAAAAAAAAAADQFv7lX/4l8xlPRnTrrbde8pvf/Cbb0JWM3QAAAABQjjFpmqYlzwUC2uiGFhXIRx4eyQMAAAAGB+ZkAAAAoBroSfYTTjghueSSSzKDuunTpyf77bdfZsxG7l9jwLwMAAAAjASCfEXgJgMAAACoB5iTAQAAgPqAeRkAAACo+aauAAAAAAAAAAAAAAAAAMAwAkEegCHnkUceSZrIAw88kHzqU5/KHpMFAADQDpo6Zw07CxcuTP7t3/4t+e1vfzvoogAAAOgCzLPDwTe/+c3kW9/6ViPHDsYgAP8AgjwAQwxNdrSxcRMnvf/4j/9Irr322uRHP/rRoIsCAACgDzR5zhp2brzxxuTqq6/OfEYDAABoJm2YZ4e5bpLzzjsv+frXv964sdP0MRgqd1PrBAYHBHkAhpjVV189efjhh7PXpvGHP/whe33hhRcGXRQAAAB9oMlz1rDzyiuvZK/PPPPMoIsCAAA9p0phrU4i3bDPs0XE3jr1SxOoauxY6TSlL0Ljq+kLDWAwQJAHYMgZ1hsuAAAAwwfmLAAAAIOkSmGtjiLdMM+zsaJxHfulCVQ1drQY35S+kONLl3fYF7tAb4AgDwAAAAAAAAAAgNZTRljzxESIdGF6IcLGtDX6pT6U7YtBCfgsxluLCBhPoCgQ5AEAAAAAAAAAAAAKCmt5Fr4Q6WwGbRndbb80waK7KeUvI8YPeuxgQQdUAQR5AEAtGTNmzKCLAAAAAAAAAAAuEOfa126DFoTbXv46jJ0mjltQPyDIAwAAAAAAAAAAAAxQnGuqQDrsombd/IW/+uqrnfdpmhY+v6ryD3K8NmXsABACgjwAAAAAAAAAAADAgATIOlstW2Xyyhkqf9G6yfiDapc6+gtftGiRKc4XIVT+mP6u83gFoClAkAcAAAAAAAAAAABw6LUAOWir6yL19toi1EZF20/Gzzu3l6JwHftFCvLyfYgy7R46Vsd2qXJxaBBjDbQPCPIAAAAAAAAAAAAAAWIFyLKinZX2oAVAS3i1jlE5QyJtUQFXxg+d2w9L7TKic9nyxJy3cOFC873Hz3/+8+g2iulvTqfuYnzZxaEyC05FyjUoqs570L9NwwAEeQAAAAAAAAAAAICAe47Yc6sSiOviFsQT2LlcspwhkbaogKtFYS9O3Sy1y/Zb7HlFBHlKa6uttkquv/76Qosh3rG6jMk8ii4Ohaz/5QIEHS9CzJMlOl4v6KbfqnjiBdhAkAcAAAAAAAAAAEDr6dY9R5UCcZ0339Qi/CDLWScxnijbHp4QLKFjRQR5TnPLLbcsVJbYMtaZ2MUh75r3vosVovW5Xtv16ymPMv0W2kOhKeOgzkCQBwAAAAAAAAAAQOvxhKYiwpMluHVTnm7ohdhnifB1Kmc/rXa9vMq6NgoJwXzsoYce6hyT7z2qFk2HTYTNs6aXTxd0uzhXhTunspRJP69tQHdAkAcAAAAAAAAAAACoWGjqp2sHT+At6mYjL48Y9zSxafFrrCgZsxlnvzaAjenbon7KGa896NiKK66YvV+wYEGyxRZb9HRs1dklSTebtmq8cccufyzr+Zh8pWunUPxeiduW+62iQHjvHRDkAQAAAAAAAAAAACqgrLubbvMMCbzdLAr0oj5cXrnhaIwYz3GLCtk6z7x8YtrqscceG/EaKq8+HtOOllsV4pVXXsleF1988eSqq67qydjiNqirn/BQ21ZZ7iLjPfRUg1WWvM12y+xBECpPqM3AYIAgDwAAAAAAAAAAANAFnhgYK5gWEcaK+HSOERWLWHJ3a8WufZuzBX/eedLaP8+63EqP3Y9Ii2dPxIzZfJPKTul5/tm1uxOZvrcAEbPQwII8sfzyy1cuqErxP/aphX6Lut7GrEXKXaX7Ia9MIb/xoc12iywqhH53tFspr81i+w/ifbVAkAcAAAAAAAAAAAAoSRViYIwwFrIAjrW2LpJ3UYt4bfUbqo9MU4vgIXE0doHBqhMvALArEU/EjN18M7RZqufuRIqwMdbU2q2J3Mi1F1bssn1jn1qwnjzotdsga5+H2HJbZeq2Hb1FltAiWWgxJ/Skhy43EbP3RajNYupX1ycmmgoEeQAAAAAAAAAAAICSdCMG6vN7JfqXzbuIhT8J0BdeeKEreIfyDwnlRcsUsxmlF8frw6KLE55FMov0up4yPh/jBQ4pdmsL+V64RCpaR+vJA29xoZcW2WXboVtXTGXE6pgxnJdPt787eeWIcVcFgb48EOQBAAAAAAAAAAAAClDEQt1DCq15G0B2awFcVuCOFdzY+nvvvfeO9pMuz80TysuUp4o4VcbXfWi5OJG+7nmBQ4r4L7/8cic+vfdc9Ghi3Z8U/Z7ynzFjRq57lNBxnUc3vuDLCsTduLjpxi1UbBzrmuJjVfR9GXdVcqyC4kCQBwAAAAAAAAAAAIikCktfFlxZzOqVS4g8v+gx58aex37VWSSsymo3z/K632i3IUXQArxOg0VXErmJzTbbbITv/EcffXSUtXxeu8S0W5k06D1b8YfqGXNc5lHUh71Xxl6NkxixOi9+kTjyOzlm9MbI1nllr5mYRQZehNOumUAcEOQBAAAAAAAAAAAAIq3KWayKTccSMlm8ZuHVsn6N8TGeR8gveuy5Rd3WWK5WyqLFyF64aClbHq9vY9Kw0mO0Bb38vMwyy4wS5GPaJUZczXNdpMcnlTu0OWlZOL1YH/ae25+i14vlYseiCvdFReJ4T1Pwwk1ozwOi7DUTc47clwEUA4I8AAAAAAAAYCiBxRYAoJdW5UV8pGshk15JTNOCopd/N2J0WR/T2iI3Jh/erLIby9mQO5Cqhb88q2XrsyyP17ehNEP9muda6KWXXup8lu+9dvEs2K16eX7LdR5ycURa81fh9klvdlr2CYQyi0lyESmvL0OuYjzXPrFlL/Kd17dlXFyFFiFDQIwvBwR5AAAAAAAAwNBRF9cGAIDmEWNVrq1xQxbQlmUrC2Uh62LeIFWeWxdLcA8uo3ZfE5OfzrfXxLoJkZ9ZAJUWyGUtob2FmFCbe4K8Vz9aFKmqDfQxLnc37pDkUxT6WokRxctuSGwtBshFpFDaof6JHb9VjO8y9c9zbYP7pv4BQR4AAAAAAAAwdNTBtQEAoLnEWJZarjFiRFUpwFpW5HqD1FiqFNL0wkGMFbcWbmPd14Tc0uQJnN20j7eoEhJkpTsVb+PSPDyXKqE2t0R46U++ioUlrrv3nXWs7FxL8fWGtVZ75LnDKfvkhzWmpPuV0HgLuYLh9iiTfxmK1D+0wEIUdW3Vj0WHYQaCPACglqRpOugiAAAAAKDhQIwHAFSJ54pCinhSkIuxYPW+L+qbObS5Y1lirLjzXLGE3NfkueOJsVSO3cQztDjiLaJYQrR0pxLTN6EylRH0WZBfsGBB8slPfjJ3oSJ2YanIZqVVzK2UBy045cWRgn1VhMaUHA/WQlJokUCWM7QINSiDAe/pDL1XQewTLd4TAqHvwT+BIA8AAAAAAAAAAABQUoCyLJ4tUZfjS6qw/mXhMmZzTc9lhRfXs+Im8nzcS/c1+jtLwCekRb3XhlZZ8gTCWNHfiqfL6BHrvoSPP/bYY2463rnPP/989rr44osnH/jAB7peqOhWKA7VMZS/tt63LMutsZYnzhepa+g7ytdaSNJPfmgBmq3NYxahqqKI6G39VuW5CbL60btOqtrMuQ1AkAcAAAAAAAAAAAAoaF2qRWP+XgqtISty/b2FJ+hZZSPhu6iVeBlLVs+NTchndaw1OS8s0EahseIwi9t6QcISHq26Uz96+XhPBGjkWMhbBGAra0+w1S5RZJxnn322YyH/9a9/PeqpjZiNZvnVWyTwCAmzemHFOlfXz1oA0sJ8EZ/3Vj1j62VtVstl0eNTivj0Xu6hEFu+GGIXffLqFrq2LJdRVj+GxjWnA3wgyAMAAACR4JE7AAAAAID23vOR4CQtuLVVOouLfDzPijxGQPT801tly7OMtoQ4FmAtITbG5U6oXHlPFXjuM0js1BumekgRUAvcee1tCeM6DrWLFIMt61/uc44fI5DyUwNWfaTVuC7Pc889lyTjJiSLT56SvPOd73RdjGihWLaBLrsUXNn6W8ex6qzz0nXgRaLQGJL1y3Mlo63qdTqh860Fkxi89Lzxye3HYyLPqrwIRcX3mMU+a4HKW+yLKbuOB7c1PhDkAQC1Br7kQV2owqIBAAAAAADUm5BFrxTb2QJW+hSXIq8+Lr+X70P+0fX3lohd1DJaC7NePazyyrJ5+crvLTckuly6vT33JR50HouAeT7ZrfbWAqLMmxddSGQPWbXzd2X+P4T6yIIs5F8bNyF5bbGJ0XnkLZzItj7zzDNHjAXrCQFr4cfytS7bNJaQcK/T5eN5TzqEFsk8LHFaljHvyQfCixP7tIJF3uJG7O8YP2mg41hPO3j9mNeG3S5ADD0pqIS///3vpBpmrwCA7tlpp53SbbbZJj333HMHXRQAOjz88MODLgKIAHMyANVy1VVXZXMyBQAAGOZ5me71qKzXX3999plfdRwZV98f8vELL7xwRPwy5fDO1eUMpVOk7FWWjV6pfFZ8es/HZT10nLwydlOP2DrqNg7lxfXV9Qidl1d2SpPL8tprr6U77LBDuuUue6Zb7vyOdOutt45Kw8tPt583nmR/6fpY/ViUvPLnXWvcRhzHSk8et/qnTLnKnBcas7o+MdcD10uP2VB/yHNCvwkxZfXGA/435wMLeQAAACASrO4DAAAAAAwv0j0DW0ez+wkZR8a1LGAvvPDCZO+99x5hsRtjkVvEVYzlasWKp62ai2y4mGeF75WNvr/55ps71uXeZq9ssUwuajx3MiFr4KIWuLFPusp0rScgvLSpvpbLD8vKPLa80i0Sbej6yiuvJK+Nn5y8tPC15Gc/+1lyzz33lLZA1+3HdY2x2Ld8p+s9DPJc3YTSt9BulaSLIyLPAl5vEhzj4qkM7NqqSqtx6zzLip/aSO7DoJHnSLdI1vWW50KI4+snFGAVHwcEeQAAAACAIQJulQAAAIDysJAkxSxPyPZEp7322muEG5hYX/Es/mvRUMfVPsg9wVfnm7fhonVukXrL/GlBghYmqJyWqwtKW26Mqd3tWD64Gb2Zbp4IrM/x6hyqY14eIf/m0g2OtyeAJ9bzAhHx9NNPZ6/phMnJhKVXSObOnZtMmTIl6Qavb3SZ8sRZFuPluXr8lHEBqseuJZrLhbTQQlmsL/tYvP0E5GKeVx/rmKyHFLtlHaz42s2T3Ichxr0Uxbvooovc9rWQ16deIIQYHwcEeQAAAACAIaHMnwkAAAAAjEaLY5447CGthT0xUIrvnIf062yJo1Lk5A1ECUvw5Xw5HgvgbGlsicOcdp4Vvj4m/VJzeWhhIuQL22pzacFr+aXXVuOWCKzLqc+R3xXxJ84LJqGNdUNPDuhFBy3Uy/aX7cB5/eUvf8le0/GTknT85GTxxRfvHJPieUx9vAUGfqKBx4weTyG0QKzHT6z1NMfnRRQeu9YTE1bZYgVhbRVOC0gxT7RQuSzRXS406QU5OT5DGzXz2KC0SSS3xrN1jJBPpeixpustobLSAloRrKcrYBlfDAjyAIBaMmbMmEEXAQAAGgceEwUAAACqR4tNIUt3+V4L3DquFOfkxqRarGZxlF5Z5GRBkOH0rfsAikdiI6dluZKxBFRZb8/6WVqqy7Lrc3S9STy0NpX02lVbW2t3HFqElOdxu2iXLKH7Jm2ZnPd0QV75ZVrcbuziQ7p9kVbGepHlySefzD6/NmFK8tqEJbL3v/3tb0eMpdBmnrJNOI6Mz2Pq0ksvHTVmYuom6+eJtHltLfuaF1G4HfSiWMyCiid8E1JUp+9IlCYRXMe1ziH0ZshS4Gc3TLK9uR3ZtU7IxQuL5NpSXgvtst9ZVOdrw7sGvQUEgq7LmLbk9LkePGa9hR5gEOFnHgzZRjUANIGdd94Zm7oCAEqBORmAasGmrgCANs7LeRtJxhy3NmeUeN9bm4rKuHIDxbxNGeW53kalOm/veMxmpXrDWSs9Lg9tfBvaqFLWV8a1Np702lmWI7Q5qa5TzAaash1DG2jq/PLqbqVBfO1rX8vm4s0+9O/pZgd+Np07d+6INrHq55VfbrgrN6Plcsnvvc1SdR9xO8Ru8Co3INX9YJXVG/fWq9f2Vj/w+zPPPNO8xvTGt179rE1muT1luvJ7rhtjXee6jXR9rDFujR/9WddT932obvy9rJ8uOzZ3DQNBvuU3GQDUFQjyAICyYE4GoFogyAMA2jgvW8KW/M7CErKkcJcnGFv5FxG4QmKkVbZQXXScIuKaJ7Ja9bXiyM9SFA6J3la6lkDqia2WOC3T0fFlHbVIW0QQDcXTx4888shsLt7kI19JN/nwmdn7Aw880I2vj3nCaUh494R+LegXFWJlntZYkQK5jKMFbm+Rw+oLT1z36qjbgKF8dFt7YrlsK11vuRigx6AuM+ep21xfa7GLgFaf0THZr6G6ybS4HrreEOPDQJBv+U0GAHUFgjwAoCyYkwGoFgjyAIC2zcuWIJVneapFTZ2OFtbk9yEB20orVCZ5fp5IZwmAoTYpEscSFVlgDVngeu3sCfmW8K7Fct0eoTLrJwn0YoAlVsv65gmiVhqy/rptdN3mzn1juvFR52VBWshbaVvty+JpqI298urxpIVmq11CeNbmWrTmfDj+ySef7F57Upj3rNj157z28xYcvOuXX6WIbuXptZ3XFnkCub6e8653a5GA3ssx4v1GeGl5bQFGA0G+xTcZANQZCPIAgLJgTgagWiDIAwDaOC9bYpUltmvhOSSWWUKhJ8p5AnqoTNb5lqAnCYmXIbcznkgr62mJ3SywhiyRPYtpWVbLylemIQVcTyC1XM7weTJPKx+rnyzROySaamE7ZMlP7LTTTulmW70l3fjob6Zr7/vxdKsddk233XbbYHlCCw7emJHHvLrrJwn0uAktFFh9pfEWCOSijkT2E7etlbdXVj0WdH9RvjI9PVb1ggyXU7rB0fXT1vkeVhxLINevod8Q/ZnrzNeYbGe50KHbjY7xOZZ7nrzFqTYDQb7lNxkA1BUI8gCAsmBOBqBaIMgDANo6L2vh0LL6jhE3LYvtonnr7/LER2uhwLNyzRPQPYFcC+NSZJYCpkwvJArLuNa5Uuz2xEyrbMQRRxwxQmiU4r4WxvVxS4D1BEdZVmldb40HHUKLCS+//HLHIn713Q7JXtfZaF72es0114zqa298hiz49ZiT5ZdjRbaztQCg41kW5lrEzXsCQfevN1YtC21vwUmXRfa5LK9VRnk9e2NOtoG1QJN3PVi/N/rat9rEG5teW4aeAOB6yLHAyOPyugrlCf4JBPmKaPJNBgB1BII8AKAsmJMBqBYI8gC0l9VWW80UDg855JChn5ctkcsSuDyLU30eu9nIE6ikyGeJdVows8Rwz+rXsyzm73W9tCit20ZaSWtBzyqzFmllO1lpy3J7luqhfuHjWlCUacv20W1lLWRIATYkGMu8dBoyjvSTHhKR//u//zubhzfaad90vQM+l32/3ta7pnPmzHHPtfo7JMh7fSvHihaC9SKDHLOybpaQK/vFE4atOlhl9zYkpffaSl2PH6v81uKMju+NR41egJFpeOWx6iPHUchC3iqTdZ3o+ljxrEULq27WQgEIA0G+Ipp6kwFAXYEgDwAoC+ZkAKoFgjwA7eWpp55KH3/88U648sorR1nkDvO8bImRIVHdElI9i2l5jhYFddyQ5Sx/lsK1TEtbEst8LSt4LYR6gqglIst0Q08TaPFTt6n+XrvPsOqh+4vTkQKnZ43siai6rNpK2YPrI+tt5akFaa9MXIZZs2alb3znRzsua+gYWc1//etfH5W/7G9tSW2NKSs/WQ+G+iK0iKLrLMekjCvb0bq2tBCc11+63Dovq3zemLPOl/2ln9jwkGNAL3B4C0kyfcsNjzX+rb7Qvykxv1tWPPnZW5CxfsO8vMA/gSBfEU2+yQCgjkCQBwCUBXMyANUCQR4AwBx++OHpzJkz09dee60187IU4rS7FCuuFsYJOsZCpt7Y1BK/LetkTt+yYOVj2hLYE42l8Kf9qmuRzRPzuF30ud5iguWixMrHKp9sz9jFg5D47onPun0s8V0L87L++r1MXwu3Mg9vo1XJscce+w9Rfqf3ZYI8hQ33OCwT6T3LZ6u9LZHbawNvIcWKG1rssdpO9q216KPT8YRs71XWQYvZ3iKBbhfdR1q0DgnkeUK4vraselgLZtZClz7XWoDxkHH1wpYuo762rWsv9PsIRgJBviKafpMBQN2AIA8AKAvmZACqBYI8AIB9WE+bNi095ZRTgvEWLFiQzcEcHn300cbNy5YgJy2DPfHPEqrkd9aGidoiN1Qmz4pYipshMc4Soj2xU4pwnrW9Fnw5DSmAWgsEWpi16u49LaDP4U0lQ6K/156hMmih1Opjy62JztezbLa+84R14qtf/WrHPQ25rKGw5nbvzD4fdNBBbh1lu+vx7I0Tq50YfR1o0d5rO73gJMdPqI+sBQBdH2vjVD2WZft614plqa+flLCuD71gIZ/s8PDS4HSs43l9rMdR3sKeZ31vLRTwed73+mmWmN+0tgNBviLw5x+AaoEgDwAoC+ZkAKoFgjwAgPj+97+fjhs3Lv3jH/8YjHfSSSeNElKbNC9rgVILw/q4tmjV72W6fJ4UBUMirHzvbZYo/XRLy18tuFnWtFrctwTnkCDIdbSs1i1BT7dbyB2JLrsVdL0tMd4SFWU9rcUNPRZ0mSzxVZeD9w3gY6GNQbVwbrXVv/3bv2Xz8Ox//beOD3kKZCF/6qmnun1jpccb3FpPIITwxpMeR964lufJRSkLPS5138nrQo97ftXCtuwv7hvO33pyRY9/r+7WApPlc90ba9wPsqzeuJfpyHS9az9k9W+1Ud4CUahvdF+E0gAQ5CsDf/4BqBYI8gCAsmBOBqBaIMgDAIgdd9wx3W233XLjNd1CXotTfExb1koB1rJm9QRpS0gmLKGf40phV8bRPshZVJTCmCWqW+K8JdDphYWQaw7tmsRq1zxrcmtBQLebPo/qrC2BLcFeis9SsNT18BYILKFZi8LS6lz3jewfS1j1+oTb9dBDD023efO26cZHndfxIb/eB/8j3ebNb04/8pGPjBL2Zf97ZdVtlCec6nHhCfl5Ym5ozOi+scaGvq54POkxose0HhfW9cLoa8dagNN1tRZUrHiWAK6vC32te2Mo1OayXXSZrd8lucCgyx5aeLHaQC86gNFAkK8I/PkHoFogyANQb0477bRs3iNfssxLL72UHnLIIemyyy6bLrHEEuk73vGO9Iknnhhx3u9///t0l112SSdNmpQuv/zy6dFHH50uXLhwRBzaKG6jjTZKJ0yYkPmpPe+88wqVDXMyANUCQR4A8Mgjj6Rjx45N/+d//qfwuU2cl6Wg6gmCUihji2MtsHkCrxS+pCBoWQ1rwc6y1JU+yDk/LhML1rp+ulyWeG8JsFo01Fa4njBopRuy3LdETktw1vnz93rRRAqaOj0pVmthW76GFlj0oglBeWlhPrRYERJ7aQ7easddR2zouvpuh6Rb7bBLdt9sjRFdfy0GewtHnjCv+09a2lvtYp2vhXarP62xIcvt+cCXQrIU4q3FHdmn+qkK75qzrmVLlLZ+M+TY0Olpa3q9UGAtIHhjVyLz5Tz1kwB6bOtxE/o9s34nrHEMaijIf+UrX0nXX3/9dMkll8zCG9/4xvSyyy4byB97GpSrrbZaOnHixHTzzTdPb7rppqG/yQCgzkCQB6C+/OpXv0pXX331dIMNNhghyJP/ylVWWSW9+uqr01tuuSWb17fYYovO94sWLUpnz56dbr/99ulvfvObbM5fbrnl0uOPP74T56GHHkonT56cHnnkkendd9+dnnHGGdnj8Zdffnl0+TAnA1AtEOQBAOSG5nWve92o/9rDOC97Apx25aDFMukCQwuCISHccj0TEma1wKityaXAt//++48SX3W+Mg2drnwlPGHPahOr3ThfLch74q3lC17mpwVFLqMWU7XQKMVIXfbQIonOy2o/vTCh09bnWwK5TINeSdOiY7PnvaXjrmbFeW/LXleZOcsV3vmpAJmnFpGtcaHTsMaubJ88i/i8z1o8122ox5IlsMu+0gJ5qHyWaM19bS2M6TT0opC0YJf1shb4ZNtrn/6y32Q8vRAnf3ssn/Vy7OkyWuNTx5XfeZbyulzW7w2omSD/v//7v+mll16a/u53v0vvu+++9OMf/3g6fvz49M477+zrH/sLLrggE+u/8Y1vpHfddVd6wAEHpEsvvXT65JNPDu1NBgB1B4I8APXkueeeS9dee+30yiuvzK5RFuSfeeaZbA6/6KKLOnHvueeebG684YYbss80T5N1nVxcP/vss9OpU6dmG8URxx57bLreeuuNyHOfffZJ58+fH11GzMkAVAsEeQDazauvvpquuuqq6XHHHVfq/CbNy5albUjE1HHl+VrADFmNaoFalsU6T+cTshi2xDaZr0xTioha4LWs4HWenKbVbpbYbIl3+lwp+Eoh0bN05+/kMd1OOugnE7T1sBTute9xXU/5nW4z3dfyfG31LPvrqaeeyjZ03XjHPUdZyG+8wx6ZH3nS1mT7W4tKjGX5rM/TCxuWFbxnga7HqTf29XWl+8taxJBtqeukr1Fr3Mm8rTayxr5MP9QOUsT2XBZZ+Vu+1/MEbd1/1oKgVUf5FIgel/o69BYr9KKHjKd/HyHKN8hlzTLLLJN+7Wtf6+sfe7KIJ39c8oZj+vTp2eP4w3iTAUATgCAPQD1573vfmz2eSkhBnhbPaR7829/+NiI+/YH/whe+kL0/4YQT0g033HDE97RwTufdeuut2eetttpqhNU9QQvmNLfHgjm5veCmvzdAkAeg3VxxxRXZvEpGdGVo2rwsxScpTnkWrvxeCpfaQleLg4wnMoZETk+Qk2KezlsL7fq9TlPHk4J4qHx5iwf6OykQWm2m62iJj9YiiCX6a3Gdv9dW1dbiC5eV40oraC1oWm0Su4DiLaqQ4ejcuXOzz2Qhz1byLMyTWO+NNT1OLYtp68kHOa50+TWhBRXdrtrSWovfeuzJtCyRWPart1Bjvdfishbe9UKFbicvPTkmLXFet4U1TnX+ul1lsJ5UkUEL9Pp6YLw+0EK/Hps6XX394t7cZ2xSE1599dXkggsuSF544YVk3rx5ya9//etk4cKFyfbbb9+J84Y3vCFZddVVkxtuuCH7TK/rr79+suKKK3bizJ8/P3n22WeTu+66qxNHpsFxOI1XXnkly0vGGTt2bPaZ41i8/PLLWT4yAAAAAMMMzdO33nprctppp4367oknnkgmTJiQLL300iOO0xxN33EcOWfz9/xdKA7Nsy+99JJZLszJgHjkkUeSNdZYI3sFAABQHTvuuCMZ8iXrrLNOMuzQHLL33nsnN998c/Lwww+PmF/ouIxHxx577LHOvHP99dcnW221VfL4449n52655ZbZ6+qrr54F+p7SpfN+/vOfd9K46KKLslc6l47RdxSPmDFjhltO/u7CCy/MXql8lBalQ4HyIyhtzpehcnMcKhtB+dIxhusvjx122GFZ3nQOfS/LR+dz3az5mOvH5edyULnplfMjLr300iwNSp/rwXWlzyeddFJy5plnZt9TunScXjkdPofrSIH6g8pm1UmWkfuS+1PWadddd82Ob7jhhlk8aleKQ+3O7Uj5aDhdTk+PJTqH+5HHFLctvT799NPJ4osvnsza4Z3ZsYlLLZ+sve/Hk4XPP/OPzxMnJhdffHGnDBpZB8qb2o7HDL9Svtwe3M7ESiutNCot617L6nvZ9nwN8Pjk8Uj9tddee2WvPC5l28rr4f/9v/+XHaPyU5n5uqE41E5Ubio/9YeG20aPXyoTX6f03WabbdYpO49Jjk/l5HrotLlu8po4+eSTs/RkmzMcX9ZZp8vXp762ONC5PH5lvlx2zkOWUx6n+vJvDpWR2o/bnX+v6FqjenBZOS+ZtkxX/u5wP+Pe3Gbggvwdd9yRTJkyJfsBOeigg5JLLrkkWXfddfv2x/4vf/lLthhgxeE0LEiMWGqppTphlVVW6bIlAAAAgPry6KOPJocffnjyne98J/tDUCcwJwP5Z8D7MwoAAADkQXMIiVIkTrEozGIgIQVsKdhKsVuKm1IEpLgsgEpxi46xkMVimBZs5Xu5GEDznhRM5XsW6ChdFtvoGAuRvGhAYhyL8RRXitsEx2ORj48TLLZx/SgOp80Cpxabub206EzxOS6JjCzscd4EiZv8meJwG5BQyuXmNpTiIddTL1bIfpUiNAurXG5eZOH+ZFGY8iWxktrXW4jgNuS0pWjJ7SGFYB5T9B2PN9KvFixYkNxz5XeTu756dPLcY/cl919wavLIj7+SrLr5/OzefIkllhiRJ6et+5DbjhcydDtwOzPcZrIu+l6LBWnuex4bWqC+/fbbs1dqM3muzIvSYcGdj1F56BwSh6nMhx56aGc8ch0oPx7/vDgl+0NeO3yMy0hjRl5XEo6vF650X8t68jim8hI8pnmMysUmeW1xfXksynFrjSVub30unUf14O/lOOPxTPBvHPPUU0+N+O3h6+rEE0/siPI8ziWcLi+QyYUx3JsHSAcMuZa5//77Mx/xH/vYxzIf8PQ4zne+853Mr7tms802y9zQEOTrfccddxzx/QsvvJA9IsGbw5Kf21NPPXVEHPKtRXFefPHF9I9//GP2/pe//OWIOMccc0zmysZjwYIF2SN3HB599NFGPYYHQN2ByxoA6sUll1ySzXO0DwsH+jxmzJjsPbm0GJTLGszJAPQWuKwBAHRD01zWEHKTRM9dg3ZtYfmBZrR7FO1qRbu44Hh6k07t0kKnwXlpNynahYXn0sWqm+VaJM8FScjFj+XqJ+ROxHPDojeblK5stMsT2QeWiw3dDpbbFes82U8cX6Lrx25iZFwrL93+3/3udztuaaTbGvIhT5/Jnc33v//9Efla7pEsFyZWv3ttrMurXcpIVyjaXYnVxvJ7vYkou8qRbmKsPGSbWden5SJGtpG3cbDlNke79ZHtIuPIOstrRx6zyqndzVi/F5ZrJD02tYsc3Q6hOksXRbqNeG8G2Tb6GrHGErAZuCCv2W677dIDDzywb75oaUGAhAQSGrSP3Le+9a1DfZMBQJ2BIA9AvXj22WfTO+64Y0TYdNNN03e/+93Ze9775eKLL+6cc++995p7v8hN088555xsTiZRnaBFd9qwXbLffvthU1cABggEeQBANzRtXrbEXfZLrUVFOq59kMt4Ib/OnkgmBTIpjBHSz7UWuC1RUqcvxXOG62mJ8JZAKX10W+2h284S62VdtIipv5NxdFtaG2dS3jo/3Y6cphYkZbvlCc38mdvcGkf8vRYu5TnWYooWXT/zmc90zs02cj36m53NXdd/58ey+fmrX/3qiLrJftT9FRJSPeFWpivbXQrmWlT3BHkdR4q4HNfy7W8tHujrxBOErcUt2ffe2NDXK58nfcPr9tFjSdfZW/iS52gRXI4PfZ3qtOWCohyLWnTX15k1FmV9dft4ddDXEWiIIL/tttum73vf+/r6x54s4Q877LARm7quvPLK2NQVgAECQR6A+iM3dSUOOuigbOH8pz/9afbk27x587LALFq0KJuT6em22267Lb388svT5ZdfPj3++ONHLKxPnjw5e1KNNnM/66yzsoVzihsL5mQAqgWCPACgG5o4L0thUW/kaQmSLEpKLMtcLXLnCdBS6OJzPNFTW9XL9C0xlPPRoqoWzaVVsBZOrfNJDOR40qLWEk216GdZ01rCnxYVWTC0LNYtUV2Xwdro1BLqtWWxJfTLvtALE1Jk1f3iid70+fTTT09nzpzZiUvW8byh6zpvPzyzkP/85z8/Yjzp8afrrTd01f0g+1C3h9VWsh1lHa06WUK2FHzlNWct6GgLcN1P8nxdZjkudPms8WK1ib7+rd8OmZ+3qau2RpfXuN4MVl6TegFBjiOu+xFHHGHWQdfNstC3FhZlm8lxLM+RaXrXM6iJIE8uaq677rqsk377299mn+nR9//7v//r6x/7Cy64IJ04cWJ6/vnnp3fffXdmob/00kunTzzxxFDfZABQZyDIA9A8Qf6ll15KDznkkHSZZZbJ5t63v/3t6eOPPz7inEceeSS7vidNmpS5qTvqqKPShQsXjohzzTXXZI/lkuu6NddcMz3vvPMKlQtzMgDVAkEeANANTZyXtdhKwiqhrUpZcNWWzRJ9jmWha4mDUuyiY/KzFmzlOdLNhcQT+Czh3rK81e8tEVeWTwq5Oug0pEgp29AqgxYypTBsicQhq3opIkrxXC84eGKsFjBlG7IgymWV38m8pVWyToOPn3jiidkcvPI2+3YEebaQn73/P6zn99prr1F5aKtrfUwGa2zqBRg9pvVCk+57b9GJz7XKa40Pq3xWH8r+0U9+WFbssmy6fCwqW32jr2U9XvXYl6I2E3KHJdvRSt9aXNCCuWUBz+/l9aYFd92nOq4lxlv94C1WgZoI8u9///vT1VZbLfvDTUI6uathMb7ff+zPOOOMTPynOGQxf+ONNw79TQYAdQaCPACgLJiTAagWCPIAgDbNy1JAs6yjWWCS1thaJLQENsu1g8xPW8BKUVFaXGsLYV0eLSrLcnB99DlafJPl0G4utIhoiZlamNOipCfOa+theZ4W/rz4shxapNdlYjyLX5mWLjP3DS/W6L7TZZLW0rot5fk6T4J0LpqD1977+OwcEuJZlN/4yK93rOe11btMV6Znidg6Lr/XTwV4Cy+WGOvVzYqXJzrrsWxde/rJBbaw90RvS/DX16q+XkNpeePMq6P1FAGPKb3YJ9tCL7Jo4dtrV/17o8e0da3o3wOrjWjxyVqkgSDfMJc1TaVpNxkA1B0I8gCAsmBOBqBaIMgDANo2L1sCMB+X32tBzfKLbQUtnGpB0HJBYYmYujyUnnRVoUV1KZByGfbff39XQJfH8jaKlEKcTN8SKq3FB0vYtazsLZcguu10HbXFr+wz3efeUwBWv0rRNNRn2lWLFnmtvpdl/9CHPpTOmbNx9pk3cmVhnl3XkOcIWQ8tyOu+kC5+QuK0LrfsZ3m+59JJjj+rH6yFA6sP9Hi3Fi9kG1rXn+WmR6Yhr3FeNJGLJ1YdLb/wcjzI863rSy/M6UUG/eSG7ifZLnos61fZlrLO+jePf0OsBQM+l+vNcXUZYSGfDwT5Ft9kAFBnIMgDAMqCORmAarnyyishyAMAWjMvF7GktcRAbdkthTtL3JPfc75alLWslC2RTaatRXVt4W9ZOmuxWpdDCuQyf8syWIuPUnCXbSTPZWtz6V5Hl0mWVQt+uk10/2kh0xKuuR21WK5FXu1yRAu2fFxvrCldqXBdZTsS2uXL9ttvn31e+S3vzizjtdC84Sabp+9+97tHWU9bQrUWeS0RVQvfun66feWTG/pa8MaF7ltLQPcWh/R48K5Zy72QLovVProsfN3KYF3rWhiXY9hamLCuSWtRQo8tb+FC5ql/N6x6Wb9hPF71PgyyfeXvjHxvtTcEeR8I8i29yQCg7kCQBwCUBXMyANUCQR4A0JZ5WQt82prU+k6LdpaQrje71CKZFuel8GgJ49riVouS1nkEi20yrid+yzbhuDELEVrg1GWyrJRlG2hXQLosWnDW32tx03oKQZZZxtWCpSVkWtbiXEcthEt/5jKO9m8u621tTEuf15y1YcdCnjd1Zdc1W+789vTNb35zrvisF22sOlliriXWa6Fci/PWOJF9aD0loq8Z3Td6kcHqc11eq231YotcDJHCNgvU+lwtpuuFAJm2FK2thSrZBtb4k/W2+tHao0Be0974t35LrLaX9dK/Q9ZYsX7DgA0E+RbeZADQBCDIAwDKgjkZgGqBIA8AaNO8rP1pW+IrYQmb2oKd41mCp7a41hbyUmiU5dLio7a6leW2BFi9IBCy1NVoy2dPjOTyWgsGui5SuJPWufqcGOt2S6yUx2TdQosbWgC1+lTXTYue/J7FdynCyvO1RTOnz9x9993Zd+tsumUnHlnK83sS5N/01ndlc/S3v/1tdyzKPpL1lwsAut7WgoHXx3Sc3ZfQq75W+FW6ONEit2eJrY9bIrHVF94imXV9W8K4t1CmBeeQkK3T1uNOP63A+eqx5o1t60kNbwHP+n3QlvfazZP1nRwnXp9ZC2ZgJBDkW3qTAUDdgSAPACgL5mQAqgWCPACgLfOytijXgqYWn1hAtlx5aEHLE/eksGUJeTp/S6izBMk8cZkFNl0XLcJZQqklTlrtIy11tcivy2lZ2WoLW91OenFCt520MLbKq62zZX21EGr1qyXEMtLCX4qTuo288cX8/ve/T+fMmZN9v+K8t40S5clKft4eH0znzp07os6ynbVAKi339ZjUbSCtxGWd9GKV1bby2rD2QpDjWY8Lr72sMS2vCcta3BqX+prXZbMszLXobV0vemxbbWOV0SpH6MkFyzWN1W5aOLeuOX6qQV9b+vdJjxFdZ91W8nswGgjyLbzJAKAJQJAHAJQFczIYZgbxxwaCPACgTfOy5VLGsh7WYpgWvbTAri2WLQttSwwNifpS8CNkupbwpn18h8RHLfpZ4qEsrxZqteWvZcHMn2WaWki12tJbJNDtovtR9o1l7Wul51lrW/7RGVl3T3C3BH5tAU3cfPPN2fw7a7s9Oy5r2FUN5zFzi3/8d/7xj388qr5cZ52vFtN1O1tul7QIa7WBbFtpxc358P4GlmAbul7kNSDjWu5etAgu+14v9kjXNLq/rWtbtmfIOt5qN/2UgXWNWmNZu3fyvte/PXI86763PuvrQZdZp2stzugFGAjyPhDkW3qTAUDdgSAPACgL5mQwrOg/wv0CgjzIA3+4wbDMy5YwagUW7qSopcU7LS6HBEwpdOly8GeZBqEFNSkCS3HQswDmcxjLR7Y8rkVUS/C1hFotFspzWAi1yq2FYymmaiFQL0rIPLTQKAVSvSiiRUgpRFoLEvRe+yXnz3vuuafpE17noRcCWLSWdab5d/P3n5xZxW989Dc7gUR5Eugp7qxZs9LPfOYzI+ol21vmK8ecHrdcV11f3W+yffUx2Q9WWnp8y3S9Mav7JBRHi9W6ffX1KK8dKcTL7ywhWl5Hslz6OL3qhRJrPLE7H+sat+qsF9Os7+VvhnU9Wxb3Oi89BqxryrpOZb5gNBDkW3iTAUATgCAPACgL5mQwzAxC+IQgD7pZKIJYD5o2L2tRkF7333//juBnuVOxrFa1mGaJfJ7A7Vn7eq96sUCmoYVvLRxrwdSycJZllGK5FVfWW28iK9vYE0S1uKtFTulfW8bxhGgtPHr1tBYBOF8dX+Zl+dxm0dvrC+tcS0yl48cee2w2/87Y+p8W8lKUp7Dmju8bJZ5agrdOW/d7nggu09HjSX6n28RqV2uxQJ9jLRLIcljW8Tof7zrh9HhRit0rWQsjVh9ZVvjWNaXbUl8f+lztRkiPGf37Yf0m6L7V16r8HbPGskxL15H7Sy8A6IU3OeaBDQT5lt5kAFB3IMgDAMqCORmAaoEgD/L+UIfEePwhB02bl7UAJcVEbYHriceeICgtqqXrDs9aWgctcHrCqv4+5FbDes+fdXllmjJfLSbKPC0LYy2SyvP174bV/vye09NPHuh2stxoSKFTErLUtlz4WGPFGx+WSKoXf6TQzGnPmrVex4e8tpCnsPFR53X8zEvx2BK9ZRvr9rIWlrSATq/cp5ZbEn2Obisp3Mr+lQsf8hzdPvr64HGqhWY5LuSCmha39bjyrgvZh1Yecowx1ri22lsuUFljWR+TddHjT7att0im62n9Tlm/a7JOOsiFDT32gQ0E+ZbeZABQdyDIAwDKgjm5PuBGfDiAIN9uuhXV8TsAmjQvS4GLBSY6JkUoKcJJS1UtgsvA6VhWyFpgZqRFcCgdT6TUArK8jj03KpyftqC1RGmZrxbyCXm+FM/lubJtpcjrWU9rv/T6sz5uieba6tf6jbLEZ5muHBtSSNbtoMeELrMnxlt9x5u4sggvfciTT/nXz9k8e/+9731v1KKMbkdtga4t+HWZ9EID18NbeJDnyldt0S37OLTY5Vlsy34l0V1vPivj0Pe6fFpc120kx6lepNDXgx5POh6nIdOU14s+z8pPLz55rnZ0/aWbIm/xzsrLGxe8wMGBXe3o8oAwEORbeJMBQBOAIA8AKAvm5OEQ8bw0Qdr39oQgD3DtgbbMyyw4scDkWc7mid9S6NLivBb4pV9taYnsWW574q1nSauFcs+yWwuiWij3xEcW7qSgLtPQm+RqgVCKd/pJARnHEu6terJYroVoHV9bkFvirxQcPXFfH9NW9FZ63pMMOi16XXXVVYPCPInx/N306dMzQd7KT441rq+OZ4nC/NlbGAk9ZREai3L8WGNK9iFfD3JRw1oYs9pP+vOXblakyGwJ79a4ta4BHddqL+uzJYRbLm+0MK7LKdtDtoUei17ZLRFfW9/rPQ0I/o3kvOTTB9aiCxgNBPkW3mQA0AQgyAMAyoI5uT5ULcbLPyOgf+0JQR4A0JZ5WQpJIX/Q8rgWmrUwZwmteSKfZ8FuWepqodn7rK3OPUHbEjrlooG2srXKbIl+hOejWi4+WP6suT212KcXErTY7Fkdy6cRZB/ptOVCA4u6uo56HGixVC606Pecvywzpy/7Z+bW78iEd97AlQJ9Ztc1UpT3xpS2zJd9LPvZKovuK21Vr/tWC+16c1POQ+ejrby1eK0Xs+R53jUWWlzzrhstNuu4so7W4oU11iyLfFkW2Qd6UcAbN1b5tQ96ztP6zeH0ZJ/qcSzr7j0loIM1PsBoIMi38CYDgCYAQR4AUBbMycMLbuqrBRbyAIB+0KR52bIaloKgFLG0qOxZPEt3DpaALQVlbZWrLWW1RbkU5yzRUIqbEi1WhgQ1bfUsLf0JvXAhy2MtIFgLGdw+IetqLdRq0VcLgLqNqK6EZUEs+9CzXpafCcvK3bI+10K4dn8ky2xZjFNY5x2HZ69akGcLeem+5p3vfKe7WMPCrOd6RIvNWljW8ayyy7aU9dZW9dxHfJ4nkOt+pFcut+eyxVpskteXfkLFis+bB8txrhe39KKCFLithTp9Pep6U71CVuwyH+t8+fQIl08L8/J7a6x5CyJSnNfXHT8VI38X+BoBPhDkW3iTAUATgCAPACgL5mQAqgWCPACgTfNyyI2GFN20OExY1qSWsGsJdJZw6h2TQiFhuVfxrHr1cemOxVpc0OKjPC7rLdtPC4SW6xNLCOW89SKGtbGstjDmvGUZtPAshVzZh1Zby3RlGaSoLhcgrLJwPTwrbb3Bryw7t92sdddP1/vgf4xwV6PDP6znD87e77TTTiP6QOZtjUFvwUgK7JaLGmvBRj85oBeYZB6hJyr0QpG1UKLHjWcxHhK4rTRZeJbf6c2E9WKXti7nMsu0dDr6WpZPYMh204sH8trTiyZ67Mp8rXpadZPXkf4t0Ney3muC3UXJa4KvETAaCPItvckAoO5AkAcAlAVzMgDV0mRBHk9VADB4mjYvSyFJCmNSiJYCoyV2SgGTxUVLXJMiv7TAlWnweVokk8Icx9MWz5ZFsExblk2Lkyw0Wr+lOl8uC39nlUG7wvAEYy1uewKsbmfLQl0LhjJvy9qXhXrZbp4rFssK2ROI+bN2BWTVgfO44447smOzt9h+hAW8Feh7cl0ze95b0jlz5mTztiyXfvpA1onwLMqtMSO/0+NIuk3R4rwWirWYbKXP494StKVFtl7E0MK092q5fwktqunA15teQLCeENALBN7vhVVW/t6yvtdp6fFo7Q2hxXJp/W61C6ep937gstFxbgPZvxDjw0CQb+lNBgB1B4I8AKAsmJNBr2iruNtUQV5bdwIABkOT5mXLBYr+LDcvpPdSOJeCuBYHLUFMi2aWCxEtEGoxU4uV0oLXqpPlGkQKb95ChLR+le2l3ehoy1vLul0/heBZymu3P9bCgQ78veeGROftiaH6mERawet0pFCfV0aen6xNSb/61a923ktXNfSeBHhpLc/HZr1ljxF5SOt2LbhaT3VowdhzI2OJxdY1I8/R7lNkWeQY5Pdy3BDWGOExKMe5XiQLLcDIvpXjgvO38vWCFOXl4pR8gkDW01vw4PJw/rL8uixSBJeLE9ZvgkxLCvzWGNbtZC04eYsVOg3gA0G+hTcZADQBCPIAgLJgTga9oM3iblMFeaKN/QVA3WjKvKytbKWIzmK0JZxqoZJdwFgWyVoslcKs5VokVvSSoqQW0qQ7EYbjWZa98rNlza6tkqU454n/0kpXnieDLrMW+GX69L3sJ+12Q75afRb6jsvD/cC+53mMyDLo9pFCpyVOyzHlPVHA4YQTTkhXXXXVUcdJePcs5me+ebTbE36v3apYwq0et5bwqsetdCej+0u2kxa8rXQ98VuPH319yKdLLOtwWTfrCRi5ya/sU3l9yKcl9JMXFE8vZMh0rHrJsSfTY4tzfp+3gKTb2btO9EKVXGCzfmdkP1tPKMi6yrT1kwHAB4J8y24yAGgKEOQBAGXBnAx6RVv/WDRZkAcADJ4mzcuW8GT5/5YCnBTiLGFTitAhC3gp5EnR0BPx9LmE5/M65DNblkmL65aoHBJQpeDMcVj4kwsH8ryQcMmLCFxv9rPt+UXXgqwspy6btETWbavzo1fZbpZPbpmuFrWtdpQidsjimMKK897WsYQn1zQUyG+8F3/mzJlm/8hxJQVcKZjL60D2j7a018IvnyfrTmNLpmctNEnBWB9j1zd6oYfHutUHXF5L4JbXp/VkgLyGpDse7XZJjgP9OeT+R9dFXnvyaRv9HfeNXmDT40j2p1yokuNVjgtOVz5V4JVdL55ZC2nWGAM+EORbeJMBQBOAIA8AKAvmZACqBYJ8PcEfXdAUmjYveyKp58rEsgLX4p20VOWgrdOtPPRneY4WxCxL1jwXOCw4e0Ict4EWs3WQoqeVj2XBruNptyW6XlxWmossoVOXidvHc7sihV1rAUb3j7Z61r6yOW09dnQ/Wf7VdbmtscFuaTiQKM+ubMh9DYv2OshxqetrLWxoC29rEYO/47rqNtBjQ7eX/o772XO3YvUtl0Nfh/yqx77lX14Hac1PWGNA52eNFb2IF3oqQca3rjW9sOK5IJKCvv6t0YsX1gIYPwkin3iQfSXrohccZVm1pTzuVXwgyLf0JgOAugNBHgBQFszJAFQLBPn6gT+6oEk0cV72rJ89S2YpyFmWoixUscsXab3ricpSpPN8rFtiIf82aAHZEzfzxE+dR2iRQAqvhBTxrA0/tTW5JWbKMkkLec89jnQJY4mf2uVKqL66PDw2LLcsnJe2NvZEUi2WsoAsy7rOJlt2fMVri3jpV16GGWvPzizkvby09T/ny/2mxXrdt4Rl6a7HDv2fl+3Nxy1rbDlmrPblcacXOrSArsentkDX/aWfRrGEc1m+0PUgreO5nFwm3V76yQ9uFz0e5UKXtNTPu1Y5T9m3Vp30GJf3FLJtrQUPvYCi0+Q8gQ8E+RbfZABQZyDIAwDKgjkZgPYK8m3689emuoJm07R5mYU5Fsvof4l0t0JYVqmWKGb5EpdivCX4WQK8tHJmIdGzCvfcV3jiHZVDCpFShIv1v26JyZZ1LYu00qe5JXZalv26bfgc/dSAFFulOCrLLN2kWHXUbnz00w9SpLSEZM/KnhcjPJc97Brnxz/+cTpnzpx0zm7/2hHi9cauljsbr3+5zUPjQAuqsh10G/M1wNeLtrjWG9zK+umxI/P1nkIJuU7yLOItV1PcZ1LEt8YL14s/S7Fe96l+wkJah4fa27P81+XX7+k86TKL681jy/p90deHLDP3iayndrkU47Nenid98gMfCPItvckAoO5AkAcAtGlOhrBWHrRd72mKIN8kq/EmlBGANs7LIeFPi1CeaCwFNClus0Cnz8vzOR1j4c4iLyGFRk+Mt3yvs4inBTlrs0wZX5+r66Atrqn+2g0Hl8dyZ6OFUBaA8wRNLaRaZdZ58VMMlkWzPNdzu2O1qWVpLtOyrKXPOOOMdNasWZ3PbCXPQYvv9D1v9Dpr5/2zc88++2zXqltac2uxN6+PLYtv3e4s+PI49Npbu7Pha9CytJYLCpbLFX1N6jSsMlgunyy3RDI+YYnllkscKXznPZ0i32trea++Vl1keeVTENr6Xy+YWQto8jqS31m/a9x3cuFSLhCC0UCQb+FNBgBNAII8AKAtc3KeiIgb2eEQYJtMUwR5ogljAeMWtI2mzcuer3cWm0h80iKr5RpDumPRltPSD7o8z7MG1qKeFic9Ny8hC10Wnz0xU7u8YRHOEphDCwV58ayFDe2vOk9Mj/2e6+FZalu+t2W/cxxrUcByvxMSU7XvbRnvQx/6UG49dGDRfpWt9she3/Wud41wUSPLzfnL8WK9D7WpLr9nXa2F5bzri9/HPnnC9dK++bku0rWKFs29JzpkveVCkX7ixboWpKupGEtz66mC0HF+r10kWU/kSLc1fI73NIJcZJGW7nxMxpftaC046KcxcL9jA0G+pTcZANQdCPIAgDbNySExPvZGtq03u22tdz9pkiDfFDBuQZto0ryshag8n9r0vT7Owhenx9e7FqlYSNQuUSz3H3ojRymgyQ1ctVUwYQlwUnRllzxaVNOCnOV+R4uDcmFAWuprVy9We3r+sb0nEdhth3YxJP1mW+fphQdtfa3d1ci4Vnryu5CPb8vqW9efrfPf+ta3mvmQZTy7sPE2cc0L2qrdE75lm1r+yz2BWW/UymNft4k11q20PBcscrHByt+zTPfc8HjjW7dJkTawLO3z3AaFXEyF/LeH+tK61kJPeYTcBMkFHu5fb2FPLmSA0UCQb+FNBgBNAII8AKAswzYnx4rxuOEFvaLtgjyuKwDaNS/zNa/9LfMxKbZpcVlvoshzsxZ2LQt2LZBp39T6XCkiWlbHvChg+Vz3fHrLNKULEe0OI7RIIcvq+aOWiwV5ImhIRNSB6yPdpVg+7zmetvzNEx+1P3bpc9+qvxagZdvlCbMyLLfRDtkruaVh1zRalCehngX7NWetnx37/ve/b/qOt1yvaPHWWgjx3B/p95wn9wG3Ife59DEuhW3LB7pcFOC0tVsbPi77mOJwP1v9qa9X+ardHclryOs3SwyXC0ahNtRW9bpf9IJBnhspa4HN6muKq/s7bxNi/WSFbGN5fcjrAvdRNhDkW3qTAUDdgSAPAChLW+dk3OyCXtFmQR5/JpsB+qfeNG1etixPLWEtL2hxT4pr2p+zjK/9alvCp5WuFaQI5wmGLJRqEU8uTHB8FrilVb8UKS3Rz7Lql+Kj5X+cBXDLV7zcMFVaE1sW1FoE10Imi8Yha+eQ8CqtiT3xn9/L763FDg7nnHPOCP/xMpDgzv7jWYxnIX7jo7/ZEes33nGPbFPYm2++2UxH9pn0M57nmoSvD8tdjexfOR5kXP10grVgYQm7IVdELP57QjkvTmmBXQvPul91mawnTeR7bxPWvDRkneXCDveH9MluLdJZorv+7bA20ZXn8WbLXr/zeJG/aXqBy3o6h8sMbCDIt/QmA4C6A0EeAFAWzMkAVEubBXkCfybr3TZYNKk/TZqXrc1MY/yjS3EqTwSXwbKet6xwpcW9Jwh6Il2MX3UWlLWQqMViz22PzFML5Hoz1lAZpFAoFwry/JjLssY8fSDLJ92AWPG47S1XKJZw6S1QaPFZjjleGKFzyap97ty56aqbviWLS2I7+4dnS3kOdJxd2NArifJ07I3vPDJL4xe/+IUpzMYuLrGAzqK9d54et1Y7amt1OaasdK1FDW3RLheP9FMK1tMqulx544r7xrr+uA9jF3LkEwOhsWa1lbVIKJ8YsH6rrHP00zJeX4U2g/b60Bpj3G7ABoJ8C28yAGgCEOQBAGXBnAxAtbRdkAf1F8LrUAYwPPOytJbWQiGLX1rsos/WpqiWsKt9V1sCl7aSlxbpeT6/pcsZvRGr5Yu+iPDGQqcUJS3LfT7GwiJbs3MZpFV5yLre8yVvbXSp+8tbUNGLFVpo1QsJVtk8q28ug7bu96ywY8Vctoq3AlnF0/f8SsdWmbdb9vrxj3882L7cHtri3Rtj1nEtAvP14Z3j9R23K7Vn3iKSbreQ33VrjOt9AqxxLEX4UHnleNNucqw09caycg8Db0zkCeHyiRv+7SGsfQpknWX/6ydVQmWQddTj3+oHzNE2EORbepMBQN2BIA8AKAvmZACqBYI88MCfbDBs87IWZS1xVYpT3maVnsW5Fj4ty11tdR2ypLWswLXgZwmZ8lXW26qfJT5b1vOeGCe/022ohVQt7ln+tHU7We5BLFco0re2lU5MkFbJOh/9nbcZrc5TLmDIsPaex2QCO1vFS1GerOD5szxOojx9N3v/z2Qua7gNvfFq7YfgLdZooVmOITnmrfEVejpCuiCSx0Ptp68lz1WSvj54vOX5dJd9Y32f55rJi6NdxFj+/WMWMOhYaH8Czp/rmffkC9dVuuqRbSXfhxYHZBryNxTYQJBv4U0GAE0AgjwAoO1zMoQuUBcgyAMA2jIv51ksS1HZ8wMdOl8G7bYiJAzKoMVQnZ4WxOQ5bDGvrXpjXLRo4VSmz+KpFHqlgJfnPsZra2uzVFlfy/Kcrd65TDKeFiO172wdLFHYcvuiXYzoz9K3txZAdXustNL07JXd1HDwhHl5TJ7zhvXnjHg6wbLW1uPKW8Dx+scam7qNpDsZS6TWZaO20y5Q9BMo1ljiDUrlmNZjN88Xfay7Js9dlVVH6Xc9tMlq3l4MoSdj9MIWj2vrHKteoQU+XZ6QH3vL0h74QJBv4U0GAE0AgjwAoM1zcp1cQQAAQR4A0KZ5OWSJKoU+z4WMFutYzNKCovYvHmu9LQV3LfDq87zztcBpbWhpCYPaKj0kcEpR2toIVX9nWeBafrD5HM8/tteG2r1HyILZs6aX4qrnEsQrh95Y1LLw3meffbLX1dffvPPd1LU2HZGOFuq9Yxvv8I50+vR/iPu6jHniL/cdC70s2obc7OgFHOmexVr0kb7ZuTxyTHvXTsyil34SwLJ0t0Rk72kNyy0LL2DIpwKkX3nvqQHOW48d/bSK99QMt5F+IkMvQug85TXrXQPS3ZUsS+g60wtnlkseYANBvqU3GQDUHQjyAIC2z8m4gQV14aqrrooW5DFuAQBNnpc9kdfyGy+Ps+9rfUxvRhkSgS2xyxK5PBc21nFpGR/jesMSXLXwJ4O0MJeLCt4GntJnu66XJXKzwOnVOfRUAVtL63paG1t6YqIWf6WozmX1LM91G3hWy7oPZs6cmc6a/66O0E5uaLwNXfm9dF9Dm7vSOXPf+7FsY1eOw2PQcoHC4zdm01NLKLaeQLDGbMgNTZEgFwcsAdsaLyG3OVzmvPLpvqJ8dHtaY0Z+z65dpLsq/s3Qx7z8LTc/cnGDP+s0eExa6XMZeFyH3EVpi/q8/Rpwb2gDQb6FNxkANAEI8gCAsmBOBmAwgjye7AAANHlelkKw9JUeEty0ACVFT89NhxYSPTFR+/LW7j9YALcszrUA7Qn2UjyVYl7IZUZoUUFaxFJ+lnBoCaPSep0I+cGXbSQt6i3/9IQnwmprbC8vdvniWVhbbWAtBEhBVLepDjO23nOU2M5C+4rz3jbivSXS0/ez33NSOmvWLLMcIStz6zstVPNn7RZIi/whQV/G19dYyK0RXwfa4twqZ2gMyc1rrcUdXsyQIrbXl7o99PXAbWQtDMl8vT0VrHakY3ydyTrx+LOOx1xT3vXCbSQX7fQCntUPcFvjA0G+ZTcZADQFCPIAgLJgTgagWmAhDwBoy7wsRTpLpLSEQik+SVcSLNixkCXTYJFOnqvTtizbpbBm+X0Olc0SK2X6eZbbui28Y1zXopu+Wu0grfO1H2spdkpXIZ7oKgPNZ1a5pPsUy6pdP/HglV2Wl8sZ2vRVvl9lzbVGiewksG989DdN1zQ6aEt6q4xyLPL41OIvi6+hBYbQmJDHLSHaCpynTo/LRtdUyLe7Nc6kexyrr/T+B3lul3RdrMWOPHc4oadMvHJai0YhX/a6jbxrQz7lYZWx6FMDsty4JwwDQb6FNxkANAEI8gCAsmBOBh74Y9B7QR4AMHw89thj6bve9a502WWXTRdffPF09uzZ6c033zzUFvJaZIrxmZ7njkYKfHpDUs8vd8hnd155Qn7kZfrWxqmeOCldVHhCvhTy5KKBtQmq5XdcWxKHNlaVPt211XSMuCjFaa8unoW0VU9rk1Z5ruU73Atk/c4W8CzIU1hm3S2zz9I6no5pMd4S760NRy0XM1wXIrSIIsVkaxPh0HXhWceXDdJli9cHWvDXT3BwXS2f9ZZ7Iqt/vbHHixsxi1JyYc96wsbLg+LGPv1gWfV7vzUhUd572oXbDPfePhDkK6IpNxkANAUI8gCAsmBOBhZwp1IeCPIAtJe//vWv6WqrrZb+67/+a3rTTTelDz30UHrFFVekDzzwwFDOy2x5TYQ2vYwJofOkwC+F5DzBP8alR8yigRTYQlb4WnTlskrLdEuY5HP099odhxTW8yzvrbYjrEUFa8Eg5Atf52m5+JBlyXPbY7VJnmX2xhtvnL0uufJIC3lyWUPuaSiw+xoZJq/8+uyVBXr9agXOWy/4yLaVYr0sp+4TuU9BnrU1H5eCs9dOeZboHJ+fdtCbHFP8oteuFV/Xx9tsVYvtnk9762kB7WLGErn1kzbepsmekG/1n7y2rT6whHjtt9/bE4Lj0ivuvW0gyFdEk24yAGgCEOQBAGXBnAw88IegHBDkAWgvxx13XLrlllu2Zl6Wrktk8AQ8b/PSGKHPE/5CYlhMGfLcqkjLWEvMDvmwlm4otDCvN6+ULmUsMS8UPOt+XTe5QMBipSWYyk15ZZradY3VDiyGyr7UIqS3Gaosm/VEgRa9tcU7BSnCW1bv/L38jt7T8WVmvSn7zL7kQ/7h88ayPteKH3pCIbRQ5F0Luu29cZp3vWm3UjHlslw4yTEvv+e2oO+ta133ccy1HfObITeL1vtE6AULWfe8ayA0FrwFJu3WiBc2ce/tA0G+Ipp0kwFAE4AgDwAoC+ZkAKoFgjwA7YWEPBJYSKBZfvnl0zlz5hS+P2/KvGyJidrqNeS+RFp7a4tXS9QKuXrIczNT5HvOS7reCOUl3a+w+w/P6jtk1Ss3d5X5hFzwcDtYVthFRMui8TnQ+OZ4VE7t419alnt9EOMv3XLTssIKK3Teh6zbOZDgToGF+Bj/8tYTEqHy6XHBCxvW+NaCsGwHfR1py2xrDIf2a2Cr/NCGvXkCf94ChNdG+tqyBG39VAbnReMrtKGqVWf9NEGRuDpIV1mynFQ+LqO2vLeeLIldXOGnWIANBPmKaMpNBgBNAYI8AKAsmJMBqJYrr7wSgjwALWXixIlZOP7449Nbb701PeecczI/8ueff757zoIFC7I5mMOjjz7amHlZischC1zPEtYTQLUwqdMmEcxzcaHL4pVLio1STLdEMp2GJZDm+Va36qXbSLuwCZXfCyy+6rpoQVVbenub1FpCLMUNCbQxCwR5/sVlO0ixV46RaTM3GHFuSJgnP/Lys3ZnQwI9i/RS7Jc+7732yBv7clFFjx1OXz5F4KVntQ0HvXDE6egnDHSanpuV0PjyNtiVbRNyqWPVyXNxpH23S9/3oXStEHstcR6Wj3wv6P6QeXn+9K3fEYoHbCDIVwT+/ANQLRDkAQBlwZwMQDwxjxJDkAegvYwfPz6dN2/eiGMf/vCH0ze+8Y3uOSeddJIp8DRhXg65IvGEXEus47jWJqLW+Z6gqC1ttVAZ8nnNAp90a2HF12UsIsTrPNly2nPFEhNi3ADlCYp5vrHlcc/aW9bdqosnqlttGdOOq6666qhjLKjLDV49QV5byE9da9Ps9XWb75LbttqfvfZzr0MRt0NF+9zy+a/3OeBFmpArGJmmjGstEuX1Y0yYO3euOb68MWu5eAm1tS4b7z/BcfQTCtK3vpWfVSb+bNXFW2Dw9hbgeMAHgnxF4M8/ANUCQR4AUBbMyaAIbfZtGbvRLQR5ANoLiYQf+MAHRhz7yle+kk6fPn0oLeRDwisLt9KNS2jjVy1+yjjWpqexLiHkBrBevFhf7WWE1FC9ioib3J46nvf0QRmx1LOut9pT1l8vZmjL4rw2CrlkofbjdGS89TffMrNyX26jHQpZyOe5t6HNYFeZ+XqzbWLaio+H+kJ/1mKwtWmv14ZaWNabxep+42sxtIjAvt+LXheUJovT8ikWr3/1YlrIpQ6RN6bZD7t2DSXbVb5a+eSVM+Y7uTjpLep411mb77PzgCBfEfjzD0C1QJAHALR5TsbNa70E6bJpNwFYyAMAQuy3336jNnUlEUlbzQ/DvGxt3mqJgHmuU3QIfa8FNb15qCWqxQiZeRbOnvhGn7WfaV13tla2rHGtELLmjxEI8+KwWCjFc0tE1vH5e8vS2ip/3jFrvMSEAw88MHtdca0NR31HVu+0wasU6eV3VnpsGc9CPcVbd9vRor2ssx6jngCs626NkyKuf2L6P/T0gfZT7+VjlcnLM+Z6De0/4Pl419dI3sKAftKFnzrh3ylZztB4jHlSIW+/C6/98zYohruaMBDkK6IpNxkANAUI8gCAts7JvRSJwWiqbGdOqw59WGXe2NQVgPbyq1/9Kl1sscXSU045Jb3//vvT73znO+nkyZPTb3/720M5L+sNK70NOrUAFvI1LYNnWcvCVsiy2tpclY+z8CX9UMdYAhdxK1PElU1ICNRCqhYp5Xd6Y9W8ctC5UgQM1U8KiLH+wWNFXe3Oxno6IhRIgLcs39lPPIns/D0J9lYa+jj5kX/rW9/aaTdv0YLGcqjvZJvpzW3le66ntBTnRZ1QH8rPUsTO65OYRR3LNVERi3kdV5fdevIhb3+CkNW+9MXPFv4x12zM+I112WP1aUy788bIwAeCfEU06SYDgCYAQR4A0OY5GWJ889Ai/KDFeFmWbhlmQV63Ea49AEbzox/9KJ09e3a2uesb3vCGwvfnTZqXtZW8Z+1qBRbdSIjSglzofBa0pPgYIy56YiOn4/mxDwmUfE6er3FPsJNtoL/L85+vre6pDYtsQqkXRaTgTnlRGpb4G/KBHZOXfAIgTyzlxQK5uELXVugcKcyTUK83b9UCvBbyp6y2fjp15iZmH8p6aL/hevPRMi6DZs6cGTVuY4Xm2M2UZX/K+soxQelIH+yh/qd20hb48rO8dr0FF25fa1Egb4NmnR+PZ6881m+K1bd5/SLfhxbGQvWGKO8DQb4imnSTAUATgCAPACgL5mQwKOok5lZZlmF1WWMtosjPAID2zct688hQsIRBKYCF3LjINAjtIsRyGyMFr5iNT61zuUxSBI0RomUcLdRq8S3WjUnMIkdIOLQESJ1f7MKGtBbXZZVp5FnE67FDx+WmnXp8ffzj/9yYVQvp7JLGc03jnSet6KWV/LIrTB/Rn9KCXY9lKrflfiS2TSxx1nJpwvFk+4fGhXVtWlbp1rjNq4c+x/qO8y/jmoiDt/Ag3VbFLODF1FVa33vn6X0cQvsk6N8077dDPhXCfvDBaCDIt/AmA4AmAEEeAFAWzMnFgQA5/HTTx8MqyFdtIY/rCIBmz8vaOt6yDLZE9jwf43kWvVKk1e4rWKiUIlmMhTDF9xYWPHc2eRtE6jRke7Ewx3WRrk3ygnbpIS3jQ+dYcfIWKkJCcjciq5WeDnnp0yatWly3fMeHgrSel2nR8Tfu+5F02rRphcuoBVv5JEBoLGqBnF2u6L7SFuyh8lkujEKB8gyVUYvvvEdCrN96rx6yrbw8ZeDFGukuq9vx5vUpnZeXj7yO9JMlMl+5p0bo2sP9kQ0E+ZbdZADQFHbaaScI8gCAUmBOLgasgoefbvt4mAX5qsB1NDjQ5vWnKfMyX8d5FuNlXHewOJnng5k3hvTyi3Wr4m24Kt2SaCGU02ZR0nKtYbmgkeKet/mnPifGB70n8FEb8vkcJ5SebPNYsVOeE3rSoYibG9mOvCiiRVUW4D2/8DJYPubXO+BzprBPgvxSq88OjikthmshXrttkcdj621tnCzL5C3i6OuGx3GeP36uG6Vt9ZU+Zo2Psm5fuv0diR1bsk+8pwTy0pKLCkXdZcn8vbGAedoGgnzLbjIAaAoQ5AEAZcGcXBzcKA8/3fTxMPuQrxJcR/1vByyENIOmzMshsZDFKi1sSQGqjDgb49YmJkghrag7G6s+lljo+RKXoqfXht45efG4zVmojRELtSjpCbGWSKv9qFtt6flgj6lfKO3JK7/ejJcnzrOIT68kyIfiePnrJxq0RbzlxqTI/gostltxtW90TjNvY2Ip4EsL9zJ9EtqEWI8pPUZk2tp63Bs3Vpnkwoi3t4M1Vr1y63NkHbldvXMtt1RFfldkXPiQ94Eg37KbDACaAgR5AEBZMCeDqoDI9w8gyIM6C+S4TutPk+Zlz0K3qMgdEik9lxV5rm9ijnvCms7TEgetBYfYOsiNTS0RM68984R27eM6z5e79dnbXNcrp46v0wr1fZHNRylMXWvTaCt4tngnS3gS4KWbGu1v3jp/1VVXTffdd99RbSs3mvXGjyUge20Xa2lNeXp+0/PaWdeB40v/+DquVwYv7dC49dJnf/nsgsqrR94TI9yGeb9L3vXoBT2WZfp5vwExi4hyDwzM0T4Q5Ft4kwFAE4Ag/w8wgQFQHMzJvaNNv0mwvP0nEOTrSV3HZl3LBQZHk+ZlKUx5G4Xyd9LXtNzE0BMwpQCn0+ZzLXHYc1ljWa/mbVhpiY+hwFbksRbuXujGaj8kJBY9v4y7IasdpTsX7jNPVGZL7pBAzaK6tGQncV1btpO1vPYNL0V4fi+t5kN102KsLmNozwLP4t1b4MgbA3kbsMaeY30nBXKr3HQtS7ctRNHyhPqX29ASszlNKqP3hErMWO/m2tCLBrKvuCx0LPaJHu0OC9RQkD/11FPTTTfdNJ0yZUq6/PLLp7vvvnt67733johjdfiHPvShEXF+//vfp7vssks6adKkLJ2jjz46Xbhw4Yg411xzTbrRRhulEyZMSGfOnJmed955o8pDF8Jqq62WTpw4Md18883Tm266aShvMgBokiB/zjnnpG0FYhAA5cCc7NPthpVt+00K1bVN7VAHQb5N7R1DG69H0FyaMi9b7lYs1w1aqMoTHj2/6p74FrIs96y8tbAX2kzS+j7k712eX5WgHSvQs9sSq03YsjovjVi/8dbmlF6/F9kANiSOkrU6vUqR3bOKj3FjQ4I8n89xpqy2fm66ui3pfVnf6aE+LrsRaV7QZZVtLr+ja5xDqI/yNoLVmy9bgRdidLw8v/fc/kXqH2pH2ZZ6M+Si/uLzAtXZ6nfcq9RQkJ8/f34mjN95553pbbfdlonq9IP0/PPPd+LQxXPAAQekjz/+eCfIiXzRokXp7Nmz0+233z79zW9+k1522WXpcsstlx5//PGdOA899FA6efLk9Mgjj0zvvvvu9IwzzkjHjRuXXn755Z04F1xwQSbWf+Mb30jvuuuuLM+ll146ffLJJ4fqJgOApgBB/h9g8gKgOJiTeyfg4TepnWLooAX5trV3LGgP0BSaNC97riG0qCiFLBbvLPE+xoWLPl+Lf571fMjPO4eYTU8tAY1EvKJiXV58Wf5QeTxLXzKsLON3P+R6pojQ6JU7rzxaFJVhlZmzcv3I51m5x/qaZ+v55aevYn4vhVqrTjRO6PrQT39owTevf8u2s9e2WrzWG/5a6ct6eHWxxpF8H1vGIgtS7Bfean/r9yNkcS/rK4P1hAC3YZFrg8oa0wbwId8QlzVPPfVU1mHXXXdd5xgNsMMPP9w9hwT4sWPHpk888UTn2Nlnn51OnTo1ffnll7PPxx57bLreeuuNOG+fffbJFgQYsog/9NBDO59fffXVdPr06elpp502dDcZYDgZtj9lEOQBAGXBnNy8uaLbcg2iXnVty2EU5NvW3nVvI/QFGPZ52XM9EiM8kWhG14gWCS0XFCGhNka41IsHnsg3Z86c6HTzBLZZs0YKyJZYKOsq61fEvUlM4PqyKKnFySJucmSZyUhU943sz27KLAMvMIQCW7d7gQV8jjd+mZVGHF98xTWzV201n9fvMeMyJHx7gdINtV+MZXjRpzS4fKENi8uMN8/FD1vFhxYEQueXcZ8k31u/P6G+pTIR7M7HWiDkelltJ/uT2kZu8kyvEOQbIsjff//9WYfdcccdnWPUoWTxPm3atExU/9jHPpa+8MILne9POOGEdMMNNxyRDlnEUzq33npr9nmrrbYaJeqTJTyJ9gQJ92Qxf8kll4yI8973vjd961vfOpQ3GWC4GEbLMQjyAICyYE5u1xw2jHNg3aiDIB9LW8dBv64DXG9g2OdlFrlJ0GJBigWnPAv1kA9nz4e4laYlHPK58pi1kWqeOCpFYI5rHdPCYxER2luMyNvAMk+8jPk+5Pe/yMJEXj9x+9Bvoc6TrZy9wPXXgrwW31lM90R5Ft1ZhNfnSRc1luU9j8sii0LSz7rsZz3uqL2kYK+/954qkGMkbyzLdqfzij45ERo3eZbiWuSX4zG0j4B0lcN5eItcscF6miVvYYPOkVb+ZRcpYgLlAWouyJNF+q677pq+6U1vGnGcxDhyLfPb3/42/fa3v52uvPLK6dvf/vbO9+RaZscddxxxDgn21PFkPU+svfbamb96yaWXXprFefHFF9M//vGP2ftf/vKXI+Icc8wxmeW8xYIFC7IbCg6PPvpoY24ywHAybH+MIMgDANrwxx8010K+TfRSkK+y79ouFsNCHtSVYXJZU9TdiRY8Q24ntLAuxV5PxJYuQsq6CdHBE5SpfLr+lvgY69ddn+u57LF8yHtibVXCoifu6jYu+0RBXvAEdBLZ81zTSBc1a+/7cVPQX2XNfywGfPnLX+5qfFj154UP/V3o2tHXQJGxTHG9BSO9satVBx1oXMrxVWZDYs5Xj6PYxY/Y+uftdxDj5z62bFwmKx/eC8ELuG+ouSB/0EEHZRuqkrAd4uqrr8469IEHHhioIH/SSSeZA60JNxkANAGaVGkCO/fccwddFABAw2jSH/8i4GY2DNqneYJ8LwT0uoyDupSjCaCthp9hEuSLWuHG+JAv4itbC86e4FZ04YDSLWJpzwKdZ/mv2yv09EBe4LJY7WeV07LWDvWL5w87pg1ZxNRuO2LrNnWtTTPhnP27c2DR3RPmOXjf57m6yWufvBDztEFIDPb2E9CisBTqvf6IffKh6GKNFO1D10NeuqH2tQR1Wc8i17Hlikb7hvee9okZB7FPuOhrnsoAaizIk+/2GTNmZK5m8qANX6lTeUPWQbmsgYU8AL0FgjwAoA1//GNpu+VvHmif3tIUC/m6MOzjEU81gGGel6X/5TzhqehGqV7QPust0czalNRyWVNGyCsi9IWs52PT69aSX2/SWlRYLNJGZdzmdBNoA1fexFWK6tIqnuNIEZ/Pid0AtmgIuf6xNiK13NnEWLFXNWZk32q3MrEbt3LfFllg8eqoRerYMRqzyXSei6S8oMewLFvod4zqovuFz+U0IcbXWJB/7bXXMjGeNk/93e9+F3XOz3/+86xjb7/99hGbuj755JOdOOTigsR2Es15U9fZs2ePSGe//fYbtanrYYcdNsKFDrnHwaauAAwGCPIAgLIM65wMwSoM2qd3NMmHfF0Y1vE4zE81gN7RlHmZx7e1uSG/j7EsjRF6Q3Es8TFmkUALc/yZX0N50ndF6iFdsbClfEydrTRjj1kCoo4X2ii1zCIFtx0Jk7LtPZE2tGDB5d56663T6SuvOsrPOwc+VlRcl2mxH/lQHD3mLD/kss6xFtR8rtXm+kmMULDilnEfo8dMSJC3NjT1ylPV5r66zWUeeuNcPQ5DLpRCbVV2M2krz7y4oKaC/MEHH5wutdRS6bXXXps+/vjjnUBuZAhyS/PpT386veWWW7LJ8Yc//GG65pprZj9gzKJFizKxndzW3HbbbZnl/PLLL58ef/zxIyzmJ0+enLmgueeee9Kzzjors4hnK3viggsuSCdOnJief/756d13350eeOCB6dJLL50+8cQTQ3WTAUBTgCAPACgL5uT6U5UAVzQdCH/luPLKKyHIgw64jsCwzstyw0UtklkClifwhlyfSKHfCp6Ipt1/lLWAt9KX4nKZjU9lWSyhOtaqntstT+iU6XFcSyQMpSPL3AthlfPQ7f3hD3/Y9LdNrmu8dMg6nv3BU5Df0edYn/KxbRoTZJtZY8YbZ3SN5S3exLghKvJkgic+yzp76dG4Cm3eXGSBISboxaa8xQN9vcWI5XpfC73wIvvX6gvLFRHF91wUwUq+poK8N0DOO++87Ps//OEPmfi+7LLLZmL5WmutlYnqeiJ/5JFHsgEwadKkdLnllkuPOuqodOHChSPiXHPNNdkPxYQJEzJRn/OQnHHGGdmPI8Uhi/kbb7xx6G4yAGgKEOQBAGVp8pzcBqGrKgvbounANUZ5IMi3B1wfoO3zMlvHlxHQYlx5hCztQ8GzVPYseqt2pcIh1n1H7IKBt1Ek56Pz89ot1u92noUzC5CW6K/7mERN7aLDyl+ez++XWm3dzjGyhF99t0M6n0MCu/YtH+trPi/dIn0fGrtFFnRiNv/Vm+LqzYC9vtaLaKFFMmuDYfldKJ4Wt7sNXtuGnvyICVx/3osi1H55164n3nuB8gQ19iE/DDTpJgOAJgBBHgDQtjm5TYIxLOSbBQT5dtCm3yDQX5oyL/M1UKXAFhM88Vy7p7CEMU+QL+L3msVnKX5qkY2F6iI+1S1hj8vF6cVY9MqNPb2yxwiSXl5lnzaIGSeyfLSv4Q477pjOXHukyCyD56ZGWtBPWG6V6DJaG8bGhlC7xGx46vn65/5kgds63xJ5dVqeWxkSnLUlvtdXlIb3ZExMv8f6vy+7QCYXOIpuKN3NQkjRcRIS5akfgA0E+ZbdZADQFCDIAwDaOCdDCBs+hqFPIci3ByxygbbPy2XEKs/q2hIatQWxdGsiN5z0LI1l/G43bs0TCcu6crHaQwuXITFbtltMGSz/51a7ed95fc7l4L7Q4n+obEUFWLKQ1+5oQm5sYizhWdxn63vPf7wOscJvjD/3bjfwtfqQ0owZF7rPvfJyPHnNyb0DYsZQXp/nueFhN0Z5bRrqG29xSh/XfaIX4rw+K7sgAJc1PhDkW3iTAUAT2GmnnSDIAwBKgTkZ1IVhsTjuRpBvet0HSd3bTo9vXd66lx/0jybNy1Io1gIbfWZRTn5n+Zjm8R/rPiUk3pGglmeNzfnwK6dRxjVO6BzLsr3MEwWxm2zqttCbXHYT8nx0y/aUomZRf+sxCycklku3NVWGshbyRcT02DaxxhaPhaLtqsvqXU9FxieVL68cZRaqylwjXj5lhfHY/iyymBTTZxDkfSDIt/AmA4AmAEEeAFAWzMmgTpQRJesmZF511VWuIB8q67AsSPSCvDZpSttJMV6WtynlB/2hSfMyW0uHLNRDn6UIFRLh6DxpmU3vq3IlUdZyvsjGqHRtx1jqx2x8mydWyjJIAVALk1QeL7+iPva1a53YdgmdU4WPd8+lDYXFV1zTtKxny/jQuXn18ETgImOtTLuEnn6oej+DIoHHYS/SDi0U0biTLnZi2sBbnCvz9EJMfta1Bbc1NhDkW3iTUSdwkw48IMgDAMqCORk0mToKmZ4gH1PWOtWjaX3ctLaDhTwYhnnZEsWLusfoxnqbhLgq3HzkueewhMW8zR6l4BbrdztGsOT2pbi9EDhj8vZE/yIiPX0fck2ywgorjDgeEsjHL7NSV8J93iav0g/9kiutFjV+ilhmW3H1RqpFLM1pzEmhV/dRXtlCeemNY4uMHW8syON0XYUWgIpshGv1TVW+5a32oHKHnkqRcfWGsfI4sIEg38KbjLpQxz+coD5AkAcAlAVzMmg6dbOqL2shD3zQbmHQPsNFk+ZluRGkJYCROBXrV1oKZUXcQEhB3hILiwj+Mq2Qu5C8YzqE6l1EYJw5c2alYmLVIVSXsosnZLHu+XOfstr6wXOLWrkXEfF13bptK2+cWuMrNJ5ixnvM0yVFXdeUHTMhgb8KV0sxoVcLWzEb1FrXBOZ0GwjyLbzJqBO4MEGeIH/OOecMuigAgIaBObl/YB6vR5v02sgBm7q2j36PY5kfjHaGjybNyyza8SaLMWJimSD90XcjbJe17rWEMxYLQ370q2yDooGtoouK+DR3FRXOy9axKiGUBXR2Q6OD9jefZxGvBX9O39o4Vj6x0G1f9eLJDsv9kHUe9yHXJ2/PBss9Ttm9GMq0qWwzzreMgG/lYVnRe5b1Resa09eYz20gyLfwJgOAJgBBHgBQlmGbk+t6EwvRrF5t0ss82yLIYywPZhxb+aEvhosmzcuWFW1RcZFFcikcs0sYLbD120VLt1bQUrDjBYMYP/Fl25JDSJiswmVHNxuKVhFYePes51k4Z0E9z5I+tKlrEWv5QbdL0evEi0fXZNFFljIivJV/Wd/5vWpLb7Gx7PWV1zfwH+8DQb6FNxmgHPhj0F8gyAMAyjJMc3KVwlgv5rEq0xyWeXZY6lFEkB+GOmOBqT4W8mD4aMq8bLmr6VasirF4l8JfbHpFhNJurXspeGJmSOQsshlnFWXs5dMEsYJpL54esKzYi4RY8X7ZFV4XFa+owKzj00JQmUUUa8zTsVCbV9EfXP6yCz80v3WzaKTrTb8joevfq3O3C1dWv8tyhDa4BjYQ5Ft2kwHKgT9p/QeCPACgLMM2J1clxtd5Hqt7+dpOSJAfpr4bhjoAUEeaNC+zmBVyF9Mr8XhQrmBi6hgjyE+fPr1Ue1nfFxXPy/QJieq9tETmoDdzDQXpekZuvFpVIOt7cnfD+WgXNksvvXRUu5V1BRSbdkwoc42ygKzFaR5vVppSiC4qatO5/CSK3ixVl9dKu18+57vJS7YZifJWG8JK3gaCfAtvMkA58Cetv0CQBwCUBXNyM+exupevjXCftMFCvqkMc9sPc93axjBbyPcjkKBHgSxNtbuY2GCJff1YAMgTWGM2h61iAaRMGmXzZWGzqDuibi3hZWDBfcziS+amzxvFTp6+ltsHRcdNWXGX28yyAPcEbdlP8j3F8dwyVTH29dgelPupPB/5VfUNB9033jUuN8DGfG4DQb5lNxkANAUI8gCAts/Jbb95bYI7nLLpNqFvpeV7033IN6G9yzBMTye0qW5tpCnzMgneMcJbjOBXVPiqwg96WWtlzrtKa1wWJ1kkrKJ+oXy6DZ5FPoud3S4KsAW65T7G27jVCtpqvogv+SLBc4nSq36MDf1wbRQStvOedgiNR2q7KsqvNzXuNk3u67zr31qcidlgmdoT2ECQb9lNBgBNE+TPPffcQRcFANAwhmFObrsYVbXv/KrbktIqm2435RmUX+8mC/JV9H+dr8M6l61bhrlubaNJ87IlxnniZDdiMItoVW6aGSuoc95ViKsk0vVKJKUFBsu1RzftYrnVsTbarcoVi+fGxwpaXGfxnQV76c7G+lyHUHRRJ28M5l0fejx46RXdyLQfoco9DUK/TaGxXLYMut35s5UefMj7QJBv4U0GAE0AgjwAoO1z8rCKUVyvvPrV1UJeCrz9tJAf5CINC/L0x7iXVFE3y09pt2J8t+0+rNcyAMM2L/P1XlSM6kfoxno9RniPSb9qf9a6HWN9rccshMRY7pbtyzxr+hgRmNzHsKuYbizmqwpa3F955ZVHfC7qIikmFFkQqnLs6bqELMSrEPLpKZqyCzy6TN7Y00/ryPfdLC6VXbSTC2nwH+8DQb5lNxlNAX9chpfYvoUgDwAoC+bk+osd7Ke3qfP9oMo9qHxJkOc/rL10/9Nt+jyuyvz5C+U7aEE/L/06U/fygf7QpHnZ8yPvCZK9cOHBwm6sqNzLck2bNi26LWJDqF5Wfvq8kIiet5lnmSBFUM/ivSp//N26oGHXOHmBFgNiLOx7vfjE7VbUUtsSz4v2QT+eTgkJ+nn7OpS5znixSpZHt0s3vw1lNmDGfYAPBPkW3mTUnbY/pj/MFOlb+JAHAJQFc/JwWMiD3lKk/ZtuIZ+XR1NF87rfM1dVvrrWDwznvOz5kc8LUpQKicpVhrKCYsjKVn4usiAgRb6QiBsSKLndytSrHxvUxrjU6caVUUiM1+K5ZUW/4ry3pavvdsiIY+OXWWlE+jodstTnc7R/+n4Eb6zINvTEbn28zBgg0ZvOs4TsUF4x6VbRDr0KeVb7uvzemM6rJ+UBfCDIt/Amowngxnt4KWohD0EeAFCUts/J/ZhDMU83u/2KCqVN9iEfW++q+mRQfv7rShVifGis1r3+oNkuazxLUhKZWKCLFV8tQa+M8FzW/QSfR8JfEeEyRlgM1YPy6qdY3o31flFRNLShrwx5QveYxZeMEuhXfsu7R3wmcb0KP/Ik5MvPi01dvm/95Y2NsotN1IfduLepau+AskH+nvDvT4zbnJj2sn7PqnZDZQX4kPeBIN+ymwxQDbj57z0Q5AEAZWnznNwPi9lBWuUOw/xbF6vmMhbyTRfkiWG9NupIrxc50N7Nock+5PNE2l64rPHy7WYT2apF+FgRsCrr/W7yim23QVjZSwv2btzR9FJEr2qMk9hddgzz4kdZwbzM5qXWeLAE7JCoTd/FXstWfkU2Ba7j3hccME/bQJBv2U0G6B7c/PcHCPIAgLK0fU4eVgv5YZp/m1YHKcg3rez9pq6bEQ/6em2aOyDQ3nm5rMsaT3ArYoGq48ZschojcLIQV0aUrIMY2K1Q7rmW6TYUSTPPSj7W93sdQ5m2LfM0gnVtFlmoKeKCaRCLM/16MkQusFD7eRb4ocWP0CKN1SeYq23GJgAMkEceeSRpGquvvnry8MMPZ68AlBnzTRz3AIDm0I/5qUwe3f72DdP824Q6WP21YMGCZI011ijUl72e8zh9/VqHvu2mLHRubFsPus4efL0WqUseMg16X1V7A8A89dRTpc6bO3fuiM/nnXde9nrxxRePOL7zzju7aVDcbbbZplBZOJ85c+Yks2bNMuP85Cc/yV7vuece83s6N8See+6ZWw6qVygel6EMX/ziF5NVV12183n69OmF+uWkk07K0qiaImm+8pdHg9//7e6fJ1NWWz9pImXalsdDzNgiLr300mTvvfcedfymm26KzvPBBx/MjXPmmWdmgeoUW7ZuOeKII0Yd8/KW14Hktttui87vuuuuG9F+f/jDH8w8brzxRjeNjTbayP1O9gnVbVju3XuCI9SDIV71rwvDZOkGemchf+6556bDgnwMFuMegN4xrHNyk383mjzn16nM/SqL7i/PQj6vPP3YLJXSp41c5Wsd+qyKusecW8dryypTFe0g07Us8OvWDqB58zL/hsRag4YsSItY41YZYqzq++E3ulsL4xjL51iL/xgf3FWUuWwYxGaqoUAbvZZtQxr3VbajlRaPcc+dyyCfBGlSqNIdTijQ7yqwgSDfspuMuoGbZtAmQZ7gP5EAgN4xjHPyoMSmfrrfqONvY53avd9lkflYPuRjxe+y5Y09T7tEqdM4GkRfDaP/eDnOQiJ/HdsBNG9e7tbPclGXN9345445t1c+7ouGsu1axnc8i7ihc61FCW4rS9At2o6xvuEXX3HNnrX5chvt4IrtsS5yxi222MCE4ZgxU0Z853Gh+7QfC1VlApdrkD7gQyGvXLRwCWwgyLfwJgOAJjCsgjwAoPcM65w8CFGY2rFfPumryqvq8tap3QclOGpBXlqm94K6WTuXKUddyl6WOpW/TmUBwz0vazFdWgXHimGxol6e0Bxj6d7PUFSQLrv5ZjfCX6x4X6WwaT0JMWb8xM77cVOWLZ32lNXWHyGex4jobG3PYrwW5Vd+y7v7Pnb68QRCNxseD9q/uzVu62bln3f9h/qWvgM28CEPAKg1tHAIBgf8sQLJ2WefnWywwQbJ1KlTszBv3rwRPkHJv/Shhx6aTJs2LZkyZUqyxx57JE8++eSINMhP4a677ppMnjw5WWGFFZJjjjkmWbRo0Yg41157bbLxxhsnEydOTNZaa63k/PPP71sd60y//S/22md71f6k+XNVvqrr2O518cHJZdxyyy07x6pu87r4HC0zpnoxDmXavaaX5S9DHcYBaAebbbbZiM/St7L2ge75ctY+4z3yfF+X9WWvoXstj5A/e/Yrz77xpd9pz1e95LLLLstNO4+ZM2eOaOs8P/TUpqH6MpzO/vvvH90eRfySpwtf7rx/9fm/JmV5/vd3dPzLy9cYX/V/+c2V/8j/5ZdGfP/Hn347Nw3yZT9+mZWSqunGjz/trRDqH95LwdvTIQbyHd8NMk85xtm/u1d+67fA2+9hUMjrP9S3fK3ytcvf1eV+om5AkAcA1JoxY8YMugitpW5/yMHgmTFjRvLZz342+fWvf53ccsstyVve8pZk9913T+66667s+49+9KPJj370o+Siiy7Kbtz+9Kc/Je94xzs657/66quZGP/KK68kv/zlL5NvfvObmdh+4oknduKQCEdxtt122+wGljYD+uAHP5hcccUVybBTx2utV0LYz3/+8xG/L2UEWOs3qk5CbjfElr9XYyYmXb2ZZtMXQjzqNKb6NS/Xqc4A9BMa81qUk5usSvRGiHnEiL15m0iWERlDwn5I4GYRsaxYaJ3H5Y/dgJLF7iJtXWQhQ4u4sj2koKqFewnHkwJk1az8lncni6+4Zm68xaYun72Om7Js5xiJ+BOWW2VU3OU22iG4ELDwb4+734faI++6CeEtchH0v6LIxsA8/rhfYhaBHnjggdw4lJ61CavM0xvjsvwxbUgGTmUo0/ZVQAt122233aiFKvpNxf2Eg2M5D4b0MTwAmgJc1tQDPCYO8lhmmWXSr33ta+kzzzyTjh8/Pr3ooos6391zzz3Z3HjDDTdkny+77LJ07Nix6RNPPNGJc/bZZ6dTp05NX3755ezzsccem6633noj8thnn33S+fPnD/WcXDcXHb2kSncnbWgvTa83sbTStXzIe+XqJdp/eF37v2zZYjdxrTI9APpBk+blXrhayQt5rlbK+FGXYdq0aX2tD7kPkS4uLDc+eS5GYl325LkD6aa9qN3JjVG3vsXJ1Yx2HbPY1OXd+JNXfn1f+8vKN9YH/rAFa1z2a/PTQYR+/TbgfsQGFvIAAABcsJoNPMja/YILLkheeOGFzHUNWc0vXLgw2X777Ttx3vCGN2TWLjfccEP2mV7XX3/9ZMUVV+zEmT9/fvLss892rOwpjkyD43Aaw0qbLFItdyfdpNWmJxikhXSvxkzZdHvdF7Lu/IRFHZ/i4nKWPS+vPkWenqhL+3RThjqUv+186lOfyp5YlYHm92GExttJJ53Uk7SlVa12+ZLnvsb6PtbtC/H0009Hxy2atmd5Ll1csBsfabmrrdNjLN2XXnrpUcdire2LPGnA7UXtvvfee0e7ISLGTl5q1DGyUn/xqZFW/oue/bObxot/vC/phhXnva1wGXW+IQv5YeaJJ54YdYye+K0CfgIgxuVTDGWemOn2t6HMbwcs5H0gyAMAAAAgmjvuuCPzD0/+3Q866KDkkksuSdZdd93sBnbChAmj/iyR+M43t/QqxXj+nr8LxSHR/qWXRvrBZF5++eXsexmaSB1vVnslhtWxrk0QN7VYrt3GVJnPoPDqwXUnttpqq+T666+v1SJWN+6XujmvyvRix1C//OkXOXfQ1+aws9566yWPP/54J9CiWBsoK3hZLi2WWWaZSv1DFxWi2XVHjOucMiJ3FX6o83jmmWe6WkA4+eSToxZAuuG1F/9emcg+da1NS5XhyRv+p1QZ6wC5colx59ILaMGoiFscfS3ljUN2vVSVf/hejuPp06cXis99Rr8dg3KZ00QgyAMAAAAgmte//vXZzRbdBB588MHJ+973vuTuu+8eaJlOO+20ZKmlluqEVVYZ7SsTNFeE7jWx/tItcXMQbWMJrP3qK9q4uSqssobqwU8FyCcs6iTG6z0R+HgRitanjDW9d07sGCo61rpZaIg9ty2/VYNkscUWS173utd1wnLLLZcMIzTWpMgWErxCghVtYqjFul5Z3sfCPp214Oj5w+43lv/8WEvi2AUE7oMYf+8krg5KGGaefeAWc8PVulCVpbeEnpyQT0+ErrNYv/2x4jIvGMUKyvpa8sZhzEbDVV0zeftQxBLzVIBcgJB9phfeelX/YQCCPAAAAACiISv4tdZaK9lkk00yIXzDDTdMvvSlL2V/0GmzVm299OSTT2bfEfRKn/X3/F0oztSpU5NJkyaZZTr++OOTv//9753w6KOPVlpn0F/6KaoVEfIsMd46d1AifbfW1XnlJjGexKkq6ue1XWjhwxK860wZkbjXluehc+QTCFWPtW76K2ZRoU0uvwbF/fffn4laa665ZvKud70rd5PNpj65Rpb/loWsJczmCVZFLG2r3PyyKHTfFEOMZX3sUweW4CndwrDQW5Ulsbc4QeKltyBB4mqeW51+whuz0oardaFX/RN7ncmNQ8umUeWTHN51GbvRsFxgiFnssFwpWceq/L0osxC20kor9ST/YQCCPAAAtABYjYFe8dprr2V/vEmgHz9+fHL11Vd3vrvvvvuyP+3kY56gV3J5I29Mr7zyykxsJ7c3HEemwXE4DQtyn0NpyACaSb8tXau23h2kpW63YnxeuRdffPFMSKlC9Ay1u3esH4Jr2X6zyle0zOwXv5eW5zHnVOnHvheEFnNAb6Dr/vzzz08uv/zy5Oyzz87GELmNeu6554buybUZM2aYVp2xwmwvLIYt8hZEipQztm5VLTDQwm5I8KSFn6qE3jwhksRLepphkH0Zyyt/ebS0tLf4imsmTaVXYrJeZKriaYhur0u5wFDlYke35fKw9nSwoPkCWoQNBHkAQK1JU9qYG3QDHuUGVUGW6D/72c+ysUTCOn2+9tprM2s5+sP9gQ98IDnyyCOTa665JtvklW5uSUh/4xvfmJ2/4447ZsL7e97znuT2229PrrjiiuSTn/xkcuihh2aiOkF+6R966KHk2GOPTe69997kK1/5SnLhhRcmH/3oR5M24LnqaAuDsHSt0np32Cx19dgjUb6b8yV13jS2DLGLC17e7Be/15bnoXOaMH6bUMZhg0SrvfbaK9lggw2yTdYvu+yy7Gk4mps9huHJtVir1n5bDBdl2rRpUeXsdiPXqqhqA00WIov6wu51X05e+fVdxR03ZVkn9mtuOguefCgZFHkuVPLcmXhichWuWeQik7XAWBd3TlURe41bvxnWEzLeng4amiswZ9tAkAcA1JoxY8YMugiNB39eQZV/Tt/73vdmfuS322675Oabb85E9R122CH7/j//8z+T3XbbLdljjz2SrbfeOnM/84Mf/KBz/rhx45If//jH2SsJ9e9+97uz9D796U934pAgdumll2ZW8eQO5/Of/3zyta99LRMBhh1LEOz3gprMZ1C/HU36rfJcfzSNXlj7N20xeJBzpfSLzwyq3fpR/27r1sRrbJggq8h11lkneeCBB9w4bXxyrazwW5SiGyY+/fTTUT63q9zIlZ6q8DbE7aXFc68F/ioWLYps7mrFffX5v5bKd+zkpZKqiNlslgVcdqHitV2ZhS+Zbt71QN9LMdkbl9rVCwn+3tMTTf2dib3G5W9GFU/IlO3jNjAmhflpJZBfPLIOJAuANtxwANBraOJ86aWXMsvbAw44YNDFAQA0iCbPybxxZd6xXuVNAmpdFvD6Ve+ytKG9OM2rrroq+cxnPpMdo6diBlmmfjDocueNrUGXr5syxF43dagjsHn++eczUfVTn/pU8pGPfGSo5mUen1VA4nesj2vtKmXQlva0oELuCGP+r5UV6khYLCuWx7YRicBVLjSAkUyaNDl56aUXKx3/vaSJ46HqdqTf7l65sAldo3W5V64bsJAHAAAAAKgJ3bi9qCLvuvjprtq6uhfWxnV6+qhX1uhct7JPq1ltQ77S64S1Ka/1pEq/CYnxob6m470ubzfjLea6adrTFcPO0Ucfnfn8pv745S9/mbz97W/PnnTbb7/9Bl20WlNGRCPr3UGL8USMGE/EiPHeZrDdWK7HtlFIfO3VEw2LTV1+9MGx4+NOnrDEiI/jl1mp8k1hq8QT463x368nSEJ0I8Z7/tKLPrFSlKoXNXotxvMTMHX4HWsCEOQBAAAAABpIr0TmIvkULcMghDa9WWaZMlfVXr2iTosDeX1BvtLrIspb41G3ZdEx223/51nohvqaz+3lNcaW692Mt7zzmjKe28Jjjz2Wie/krm7vvffO/AvfeOONyfLLG8Jjw6ExV8Xmjt1seOoRcjdTJWXz8VyBVLUZbJ1d2UgWPfvn0QdfWxjnMuaVF0Z8XPi3x3u2KeyYxZcslY5cJBi3xDIDaW9e5PHGXC/w/KWHNii2CC1M9NqdU7e/ITHnW4L/ySefjPncAYI8AKDWwIc8AACMJiQSduPzu2g+ZYS/GKGtKkFOb5ZZRlztZfxu0Hk04c8O+UinvpC+0ntFTB9446xsW1bR/3ljP+TKhc/VCwpWGt3Wr9fjraw7HFA9F1xwQSamkdU0ifP0uV/i8CDYZJNNkjoSspS1rHfL9lFZi9zQYoLFMI8hi9de/HvfN4UNkS54rpQFvVwkePWFv/XVYpwFa17k0WOunwJ9WUILE722XpfXNvv0z9tU1zu/CHfccUep89oABHkAAAAAgBrRjZBYVhD0zguJg0VF86K+easQ/PRmmUXLXFX8qoXCKoTfIudWueVUv8T42PapcnEoNm5euUJifF696NyQdX+3Y6eulutwcwOqgJ7eOeyww5I6ITfD1IIjC5SW9W4v/Hd7FrxlRFhdvl5a73ruRppIkU1hu7GgL4u2GK/S6jtPsC66KNQL+r1pcbfue/qx4eqMGTN6nkdTgSAPwBCCPyMAANBMuhUSy1qW5wnveWXoZhGh13Rr/dxt/F4IhdyWbRQvY8tc5Vgrkk6MGF/WBU6euxoLHb/sddjNZpf9GGdwcwOqFI5oQ8IqqMIKXPq91oJjPzZnlPXw8ivqtkND7d3tAkLofM/dSFMZN2XZzvvFV1wzqStkfd2vMVo1ZX3eN7W+3bDEEiP3PtBsscUWfStL04AgD8CQ0eQ/2b22ygPDy7CMdwCqEJV65de5H9bIw0KsiNotvdxYsxd0ux8Bj7WQD/puhOPYcnRDkbb3fNzHxAu1Q5l+l+Uu0kb9vC9ty+8L6O0YOvPMMyvbkLAXVuqaPffcs+d59LoeTd8Akvyqa5cvvRTKX33+r533C558KKkFY0ZLi1VYXw/KDY10LTNMT1j0YgHxhRdG7n2gob1H6rJ3UN2AIA/AkDEsFkLwHQ/auggFwKB+v8teQ8My71RFrIjaLb3eWLNqqtiPgMpMPuhpXwAvbjft0q/5pGqXSVa8XlyXZfZhiCkH5m8wTJCLGRbJy1rZFuHiiy8edawf+VZJvzfSLetWRFqma7/q2uWLFspNgX78pKRbpqy2fuFzFpsa2JB5sYn28QlhK+gkfS3pBXVwQ1P0CYt+CvixY5njhazZe7nwBrc1NhDkARhCIIqANgExEIDu6VaIlNdfP8W1vLyqKkuRdMr41i9LyNd43Z5WK7IfgVd+Ok4+6HU6VW1wG7Ohar8pIt6XPbfXc25oTwUsqoNh8yFPLmZYJA9t4NhLqs532rRplaTjbSB53nnnJf2krFsRaZleFNOSfeFLSbc8//viG2a++soCX3xf9LJ90isvhAX7AaPHVlm3U1X4gO+ni6TYsczx8qzZewE9dYT/6TYQ5AEAADQeTPJgWBiUKGWJbGXKkieuVVm/mLzK+uruJh2i6Ea39Frl4kFeefu1kFFEmA1tRKqP63HabX1DZSySTzf5VkG/8svbtDh0Lel2xKI6qBOPP/54aVF5mHn66ae7age22A+5MKnKbz/IJ13wXFh8D1HmnD64qtFjq6wbJBauq9j/oelU1QYPPPBAJekMIxDkAQC1Bj7kQdXACg/UlUFbihYVOb00QptOVlm/GCGvG1/dRfKpYnPWqtomxsq76EJGt27kirip8cpf9HhePkXKy4sARZ986Of17PmRzzun6nzJwji0oEJY7nWqLBMAZdlrr71y3adU4Re7V+y8886Zy5xewu44irRDjMV+P/3It0ZsHTchqQtFx+WgXdVU4b6l1+MsbzPVbqnKhc0Xv/hFzO0OEOQBALUGvuTBMAmeADSFbkRo75xe+bSuYmPPvLJVUeaQz3P2jV5V2+Slk1fXbnywdyu8h8pfpn+6FdI9y/w8+m35bbn9qfIJkph8KS3y72+NZRmvysUTAKqExl6/3adU6Xf6Jz/5SeYyp5dl6Kc7jl7Rj812a8Grrwxc5Gd3R0XGZdP2QBjUOCvjfmbJJZfsSVlAOSDIAwAAaA14NB7UmX6Pz5gNNOuQZi/bstcbr8p88sRRb6PSKl2kxC5UdLMhKllIx1I0nyLW314+MWNUjp1eLE71Cm9T114/+aHbivz855XP+75MmSDgg2GgDkJ3HcowTJTZcHVgxG4wW1Dkt9wd5dHPvRfINU5R9zhl6Pcig+cL/7nn/n93RX2EnjrCf28bCPIAAABaBW4IQJ3ppxhf1L1FkTT76aajbFt6rjV6QZ4rH+/7IhbDlmV3kXLEsGDB/78RnAFb+dPCghTl84ThsuOrTN/FnmdZd8ekXTe4zb3rsuw46Oa6q2rxxHqCAYBu4d8xAKqgzIarQSb00EVJ7AazY8cnwwS5xum1exwS/Pu9wXNos9deu7XS0FNHRYw12gQEeQByaOMNfp3qDB/yAADQG4q4t4iBhdfHHnus67TKCNBF0/dca/SKPL/6nuuWWAFdC98hn/hlxXj60xpqb7KMZlFeP33Q7RjTLk/KLCz06imUOovCMfsUFFlE61ddQ09c6OsGT76BKvnv//7vQRcBRLpB6SuLTUwGzivFXZRUzmsLe5p8nd3VlN3QeZD+8C3xndwH1bmd2wQEeQAa+gerV7SxzgAA0DSqsDSWVClqdSt092MeynOt0S9iNiQt6rc8Jt0yLL744pmVV16aM2bMGJV3VcKptxFo2TSqou6icGifAr7eYq+5ftVVPnGRt/9AXdsdNA8aa7QBYZVA+Ip3p9FLNyhds+jl/ufZQvptSV6EOm/o7OH57q9zO7cJCPIANPgPVh3rXObxcQAAAPHEuCYp8ztf5Hc/lCcL3aHy5bm8iJmHup2v6jK392qDS/n0Q9mnCCxRPnaxh/Mtuylq0bINmrqMJw9vnwK+jopcS/2qK/2OFN34F4C60TbhK8Z6PeROYyis6fvo3mXs5KWC349fZqWel6EtTJoU6We/C4ZtAW/mzJnZ4vqgDWDqCgR5AHJo4w1/v6waYY0PAADF8VyTlN3ksijeb7cWY9ndhOWrPu+3vxthsKo5JdZtTp6f6ypctJTFsn4u4w4o1n2cdo/C46GKenhlaxNlF+HyxhNb0Hv59ZOyfu7bOB5A9dB422abbZK6sfTSSydNoR/W63kiu3TTMRBr+oLuXaJF83ETRmfx4t+Dpyz82+NJG+j2qYsYXnop0s9+yxfw5KLCgw8+mNx+++0DLU+dGaggf9pppyWbbbZZsuSSS2b+mN72trcl99133yh/lYceemj2oztlypRkjz32SJ588slRK6y77rprMnny5CydY445Jlm0aNGIONdee22y8cYbJxMnTkzWWmut5Pzzzx9VnrPOOiubhPmR3F/96lc9qjkAw0lR8SAUH77jAQAg3jUJkSdSViVYhSzstY9vy8I1xk1LWfLE2tjjMaJvnquPoq5AemUUIK2fi2xqKvvotddey+7JQ5u6ynO11XWVC0BVbBJbxbXQSwE4NJ5iNyMuun+AXvTox8JHmeuum/MAyIOur+uuuy6pG88880zQpzXpKW0iT2T33HSUxhDCqyRaNH/1laTNhCzU+/nURa8YP344NszViwplfe+3gnSAzJ8/Pz3vvPPSO++8M73tttvSXXbZJV111VXT559/vhPnoIMOSldZZZX06quvTm+55Zb0jW98Y7rFFlt0vl+0aFE6e/bsdPvtt09/85vfpJdddlm63HLLpccff3wnzkMPPZROnjw5PfLII9O77747PeOMM9Jx48all19+eSfOBRdckE6YMCH9xje+kd51113pAQcckC699NLpk08+GVWXv//976QeZq8AgO7Zaaed0m222SY999xzB10UAEDDaOuc/PDDD7vHKVCbeHF6mX/RNLotZ6gdrLRDx2Py4nhWfPl9t+UvSrf1ktD9OqXl9U0vx5WXftmxEjovNq1eXk+hfguNtW7KJ+Pr972i7PjsZlyDwdGkeXn//ffv/N4hlA+LLbbYwMuAUP8wffr0WqU3adKkwudMnDhx4O3YrzBz5szC55x88smD/lmvLQMV5DVPPfVU1mHXXXdd9vmZZ55Jx48fn1500UWdOPfcc08W54Ybbsg+kwA/duzY9IknnujEOfvss9OpU6emL7/8cvb52GOPTddbb70Ree2zzz7ZggCz+eabp4ceemjn86uvvppdzKeddtrQ3WSA9tHEPyl0fUKQB8MynkF/GYY5WY5z733oHHmsSnHNEwSrEih1OcuIx2XiVlHuovX3BNcq2tHLI/YcXYb//d//TefOnZuFmPhl884rV8yxGK6//nozrSJt38/FrbLjq+x4LCOSx8QL5dmP88DgaNK8fOaZZw5c9EJAQEAYpoB526ZWPuT//vd/+L9adtlls9df//rXycKFC5Ptt9++E+cNb3hD5h/qhhtuyD7T6/rrr5+suOKKnTjz589Pnn322eSuu+7qxJFpcBxO45VXXsnyknHGjh2bfeY4mpdffjnLQwYA6gge4+0/aOtmjWf0F6gb2i+89T50TsiNTBXl8lxmVOXvvIzbmFgXF175ut3IPOSGx/IjL9tSfibYBVEVlKmXVZdXX301c+lobepqxa/6tzo0vqve3FRuhhuiXxvU8ma4edeXlU4R903arZSMF9qnItaVTp4LnTJ7YGD+BlVDY+qwww4bdDEaRT98d1vU0U3PYlOXH3QRAKgdZ555Ziv3ZYyhNoI8+aY84ogjkje96U3J7Nmzs2NPPPFEMmHChFGbmJD4Tt9xHCnG8/f8XSgOiei0McNf/vKX7I+GFYfTsPzfL7XUUp2wyiqrdN0GAPSCKjaFA/FgAcSnijapejyjv0AdsXyx6/dFBOGqrhfOY8aMGSPy10J6t+lb/vEl8nqNFSql+N0NRTYXlW2j41F5r7/++o4wrOtR9HdJlys2roduT7pPjokfMx7LEPIbX+b3O+9aKTM3lCmHlY+3CBcSoa10vD4o6h8+b5+K0H4RofIV+b6qcwCoI6R3NJlufHfnbc4a4rnnnuvK53gvWPTsn/uaHwAeddqcmhY5MVfXXJCnjVvvvPPO5IILLkiawPHHH59Z9HN49NFHB10kAFyaLMY3bXNXLID0/o9zlW2L/gJ1RQqPMZar+juP2GvQiycXBghp1Z0nGMZg1UHW0RMe89KU4rdFTPm0sK9FYquchNzcVOIJmEV/l0JPUVS1+WWeIG+lXfXvaqidi4zr0OJR2QWFsu3KY9Pb9Niy2s97EkYft8r52GOPFaqftyCo8wk9gRJ68qNMexd9ogGAukJP67eVvM1Zu4WML0HVjOl7jnPmzOl7nk2nTptTn3zyyfivXWdBnlZMfvzjHyfXXHPNCKur173uddkEpXcVf/LJJ7PvOA591t/zd6E4U6dOzVZNl1tuuWTcuHFmHE5DM3HixOx8GQAA1TFmzJgRr00CE06zhO86lgmAPPcPRSgqXsZYlFvW+14e3SzIeVbzlqW0rqsk1no3ZGluCftWufTnkLsgr92K/C55Am6M1XRsn9CTrEXKkUdZy/NQO4fSjRHaq+qDIoTc53jv9fgvUl45hkNlCp0fg5UGLQJoN01l07aeGqjqKRgAQH0YP378oIsARtF/Y7nbbrut73mC6sCCeU0FebJ8JTH+kksuSX7605+OsljZZJNNsh/hq6++unPsvvvuyx6LmjdvXvaZXu+4447kqaee6sS58sorM4F83XXX7cSRaXAcToMeE6O8ZBz640GfOc6wg4sEANBrIHwDUEyk05azmhgxUotXITG7iEW5jOuVyRNBy1gR68+WACePFfE3brnk8BYRpOFITDkleW3ezaKlJeB6VsneIoAnlGpBvoxgW3aBJuaJCK8+3kJU3jioog9i4Gsy7zq38skb6zIPTczilL6uiuAtytHvyYUXXpi9drPgaPVTkd8sAELQwhGoj8se2k8QgLL022URsDnvvPOwYO6RDpCDDz44XWqppdJrr702ffzxxzvhxRdf7MQ56KCD0lVXXTX96U9/mt5yyy3pvHnzssAsWrQonT17drrjjjumt912W3r55Zenyy+/fHr88cd34jz00EPp5MmT02OOOSa955570rPOOisdN25cFpe54IIL0okTJ6bnn39+evfdd6cHHnhguvTSS6dPPPHE0O0cr6Edj3u18zF2UwZl2WmnndJtttkmPffccwddFABAw2jynKznz7x5VMaz5nL6bB2Lmfetc4uU3yuPl/f1119fKA+Kr9MKtZsVL/Z9TPnz8itzXpk4Xr6hNuG2vPDCC7NX3Rff+ta3sjl57ty5wfTyylCkjjpuTH7e9VBVuxcpb14cbueY9rTgPvLOK3t/z2OAy1QkjZjrr0ifFKGb3yvQe5oyL/OYR/hnmDBhwsDL0NowZrHBlwEhNyy55JIDL0OZQPpnv/LC/GwzUEHe66zzzjuvE+ell15KDznkkHSZZZbJRPW3v/3tmWgveeSRR9Kdd945nTRpUrrccsulRx11VLpw4cIRca655pp0zpw52YSy5pprjsiDOeOMMzLxn+Jsvvnm6Y033jh0Nxn9vIHtpdAPhp+tt94agjwAoBRNnpMleUJmnugYmoetuDH5Fy1/7HEWJrUQHLsgkRdXC9PW+5j8OE5MuUJ9V+S8InG8fGPS5ba3Fjq++c1vZnMyhbx2i6l70TFVtM5F86jqntVqu1Ce/Fp0HMaOr6JtIhcKylwTg7rvx3+O+tOUeRmC/GAEvPHjxw+8bgjDG6ZNmzbwMrQ9YH6uoSA/TDTlJqPfN7C48EA345Is8SDIx4FrDYDmz8kWRYTOGEGu6L1AEcG7KPocS4z3ylUkrpWf9T5WFI0VgKteyMjLyxPHi1okWwsOUpC3LLRD41IfK3vvWfX4i02jSLtRveTYLPLUB7d7mfFVxUKOLkdsH3Vj5V+EmMUEUF+aMi8PSpBfYYUVBi6YISAgIPQqnHnmmYP+ea8lEORbdpNhgRtYUEf4jz8E+XxgGQbA8MzJeXQrEnvplbHIjfnOK0uZc7QAqG/uqxJUYwRJq51D7VO2TEXKrfP3jntpyHNCgnyeRXfMGGmKuFp0fpWitPfUR0xeZcZXSBAPtXveb0eMyB/zZEs3C1ZFxltdxg5o5rw8KEG+TmHMmDHB72FtjICAUDRgbrYZ6KauoB5go0VQRyZPnjzoIjSGbjei6yfYbA2A7vA2ZLU2h8zbPFNv+Fr2dybmN8jaWNPacNRK29qU8swzz0wOO+ywEZtE6bpb+cbWMa9OOi8rvrc5bJEyhdBtqdtTHo/tm7x+WbBgQRaXkOl6G6t647PIWOkHobxixqmEy07jlOpMrzHo8ed9J8ur28pqt7zr3BvrcvNYr334XFnHmDFftI/1ZtHe5ssXXXRR38cOAMPGPzwL+zz99NN9KwsATWKFFVYYdBFqy8033zzoItQTR6gHQ7rqD0DTNnU955xzBl0UUBGw5Af9Ypjn5JA1q3c8L71elDHmeLe/CZ7lcVFr7G6w6sD+t/l41fUO5Vs2XW1lrdPRFvLWubIcXnmLWIsXrUc348jqK2nhXmQ8dduveWnEWotb77sZG0XOr8JCPjRWrDJxP+E+o540aV7ef//9G79hYz83a0Socwg/7dC7MLYGda9/WGKJJQZehn4E+k0FNrCQB0MFLGKGjzFjxvQkXYyV/tMkS34A6oJlaexZs1oWtJbVuD5Pfi8tWIuW07MIt/IK1UWn6+FZHsf+1kjr+jJYlvGU5lZbbZU89thj0dbOZdAW51QWylc/JVEkPe47WXYvbsjymcrhWchb33lYVtZVW9XLdpN5yuM0zizrbI+i7a+vHRpDMVbp1tMG3pMKsWX38su7tmVddJl02WLg68i7Rq068xMJuM8A3UBj+Lzzzhtx7LnnnkuaxssvvzzoIoBaQHroIHhtQPk2hyWXXDJ54YUXBl0MMGAgyIOhYRCPOMu8QXMY5FhpO2X+JKOfQJuIcW0SclvjnRfrviZGEAydS7C4qetj4dUlpsx56YbSYMGPXFyUwXMDEuumpFvBUAvfluuQ2HQs0TwWSxz2BFEpbFv5a/QCkxTLrXKUWYyQ7Wa5LOL2jKlfGfS1w3nm5RHrYso6Flt27V6Gy2edHyvYy/ih/izq7keeBzEedAPcKgAwHCy22GJJXVliiSUaudBXljbVtSgQ5AHoEoi7YerYLrDUbk6/4foCbUKLVN5vVVELWu+YdU6sIKiFXD6XrKtJ0JXCfsgSPc+ivsxvtVU2nQbV8cILL0z23nvvUlbVecJzN79dMedUMY9ZZYzpe1lGvSARswATyl8e9wRm75wi1vc6bcuyO+YJAZl/GbT//xgf+5xfTJ66rYqI8XpfAV6o0NdzjGCvyetPoqgYDwAAADCLFi3qSboTJkzoOo22WcZffPHFXT+VOrQ4rmzAEPvFG2YG5TMSviptuvGTCx/yzei3WJ+wVfjUBaANc7Llw1v6ti7qi7tfvxGy3OxDPdavedlr3PNTXWTeKdqOMemX8det+7eM//Sy58Wco33Icz/rccr+Qi1/7DF+xfOOlz0nlFa3Pv17tSdAXlzrGrTidlMmjfSrr49XmU+ROLhHaAZNmZcvvPDCgftbbnJYddVVRx0bP378wMuFgIAwuLDnnnsO+qe9tpQW5O+///708ssvT1988cXs82uvvZa2mabcZLQR3Kg3s/1ZkD/33HMrLxPIp4gokCckYTPXetCmeXsY5mRP5JTf5Z2rj1V5DWohkMtXpSgYqm9I6I89VnSzTi8ta8GkiGgc2qTTyiNUjqLElvfrX/96R5CXx/V51kaooc02yyxayM8x4zpUt9C4LVKmMgshRdPQ50gRvMxCetk6a/G9igWNvPxC1zruL5ox/zdlXpa/V20JY8ZUv/HnuHHjBl4vBASE+gTM0xUJ8n/5y1/S7bbbLvvhHjt2bPrggw9mx2nn3COPPDJtK025yWgbdbxRr1NZ6gwE+WYQK65g3A+ONs7bwzYnFxEMrXnPs6iNTS+mHFVf454Vtv4upiyhNuE0urEwl20bEolDeeRZAOv+q/L+Jkaw/q//+q8RgnwoDUvwtSzkiyxeeAvAVruUzSPmeJG0Y86LTcOrv27j2Lxjnlyxzi36XdF66fNifrtwf9GM+b8p8zIs5PsXINojILQnDPLJ3jpT2If8Rz/60WyDhD/84Q/J5MmTO8f32Wef5PLLL6/aow4AQ+UrHP6wwbChr60iPndBf8C83XyKXD8h//FF50Oes8jvo9x8MrShrJeOfK8/W+/lpppc7ry5U5ZT5hPa4FJu2qnjlPEBTnmTH31vM15v49GQH3adRzflLdJ3ciw99dRTbjr63sbyg25tthm6R7PSlONAtok87vV9aCNkz4d9zL2a7INYv+7W5rFFzrE+x/rQt66rGPLaJKYPY+pl7ZEhN4mOzRv8A8z/xdlrr72SnXfeedDFaAWvvvrqoIsAAOgD+++/P/aF8Siq4K+44orpbbfdlr2fMmVKZ6WdXpdYYom0rTRl1R/0nyoeKW8j8CEPQDW0cd4etjm5jDuKsvlopCVtnqV+yCqcLaTZUkZbB8dYMsvvtYWvdJVipRfThmWshr028CzGZX1j6imPl6lTbNox582dO3eUD3nZ/lUT85SB9Rp6IiLWgj62TXjMSKvaotdJmX60Pvf6/jKmTqF2jGlj+Ruhf3tAs+f/pszLsJBHQEAYRjdSgw6wkLcpLMjTZP673/1u1MR+8803p8suu2zaVppyk1FHhvkmu8pHytssyDex/ZpYZjCctHHeHrY5OVbg62bOCQmd1vEieYdE/ZBg59XT+2z5tvbK6tW/2z8MVpl03WMWH6yyWeOgqFgZ4//baoMTTjhhhMsaKVrx+17+2QotcHhujfT5ofGZl7c3Zvh8Lkde/5ZZAAgtLJS55ouMu7yyyDIU8fWe10b9WmQYduo0/zdpXrY2JkVAQEBAKBeOOOKIQf+sD48gv/POO6ef/OQnOxP7Qw89lL766qvpXnvtle6xxx5pW2nSTUadaINgPcx164cgf8oppzRujLRhXIPm0MZ5e5jm5DwBL08wt9Lz8Pyph/KKybsKC9eionNoAcFrz1if9KEyyrS1UFukn7wy5NUnT9gNjSVdZsnnPve5jiAvBVhtId5NP4eEb11H2cZ59Y5JO9T3/IeyTPm8NGPKbKVtnVdUjNf1lYsIoT0V9MKQ9xuRV++YcpcZR7jnqvf835R5GRbyCAgICNUHWMhXJMjfcccd6QorrJCJZRMmTEj33HPPdNasWdkjcQ888EDaVppyk1FH6nQDXaeytLkOBCzkAaiGNs7bTZ+TQ+I7v5YRd4tY7nZjRRubZyxaCAzBAjHf/Ft563S06Fqm/F4f8R8QT+jOSy+mLFyfmD6MEUFJkNKcfvrp2ZxMbmu4Pl7di9RH1y00PnW8WBdDeaJ2Xjpe+5aJEypTqL6x16Msi4d+aoPf63aIqUOoHGUp85tRxe/MMFKn+b8p87KcQxAQEIY/0G/joMvQhmDdW4ISgjzxzDPPpJ/5zGey1XVaef/EJz6R/ulPf0rbTFNuMoaZbm/Ch+FmfhjqwMCHPADV0bZ5u8lzckh0lceLilXW+1C8Kimbri53rDgZspDn73U6bO0dU/5Y0V6XoYgYz+mF8rZE21ghV6fJ8T1L99NOOy0T4+m76667rtC9hieIW8eKlFe3R945jCU8510XeXHz/J17fWQRI4zrNPWxvP7xxlGZazVmEaJoumUWk4bl/ndY5/+mzMvyGkJAQEBAqCZgfq5QkAfNvckYVqq6ER+GH4phqIMU5M8999xBFwUA0DCaNifnCb55x/POyZsfY0XQMueVJWTd7pWP4ue5MNHx5LGY+4hYcTkvfh55CxD6O0vsj+lzmU7Iiv/Tn/50x0J+wYIF0f1ildUqQ5H0QvXJO1/3dcwij4zv+av32s2Kk9cWeWnl1bOMsK7boej5srza7Y23yFPk8fWYpxhkn4L60ZR5GRbyCAgICNUGejoLVCTIk1VMKLSVptxkDDO4AR8uIMiDXtKm34s2zttNmpOLWjJbx2JExW7yD4nQVfqELCNKWpbPea5qQt/F5JNnCRwSh4saEHhpeW5HQufGLF5458hNXZ999tnCdfKEXil4W/7LQwKxtaiQVz/+HLtAwnFlO+dtjJt3HZY9vwhl0gj5j887z1vUsRZ5Qos/ocUn73F3fe0VKfuw06v5n56YoXY+/PDDh25ehg95BAQEhOoDfMhXJMiPGTNmVBg7dmwntJWm3GQA0BQgyINe0bY/7G2ct5s2J8cIcSFRPE+4DOUZe44lNMe61vDyCYm6sWXSbcLuajzhV4qreeXT5+aJh1JcDpXfSyem/bgcujy6LUO/c145WSi1zjnuuOMy63ial2+99Vaz3fPqElo4sBYYQgssof6k9yyq5bVVCO+aC42dspbcReej0DUfO8fFXH9FxmTM+NZ9G7uw47Wr9RvUpvl9EPP/r371q3T11VdPN9hgg6EU5Anysz9o8QoBAQFhmMKZZ5456J/24RDkyQ+dDH/+85/T//u//8tu0q+66qq0rTTpJgOAJgAf8qCXtOnPehvn7SbOyTFCUp6IXESI0/HKnCPPy8tbC3exZQjlRxRxPaPLap3rlV8Lxt5igGXJmyd8clny2sMTc2U7hHyZW2XVQrJuP359//vfnx2n3w3yP23VSdY/rw8srLrnCfy6PfWmvlab6L4Plc+zZveeLgilHSq3/C6vbHKc67bOE9JD12sVwn5Mu2mBPi+tvPLpRaQ2ze/9nv+fe+65dO21106vvPLK7B59WAV58rU/aPEKAQEBYZgC5uYe+5C/9tpr04033jhtK026yQCgCcBCHoDeMszzdlPn5Fir1DLnhoSvosJbbB6aMptpcnzLutYTsWMei7VE45jFgZAoznXU1sKhfOTnmD6x0tFCuOdPXre9rAefpwVTPn7ooYd2LOR///vfm+nLsnTjAz1W0NafPYFW5mMt2ngitSew542/2Pp6orWVp1U23dZ517GVRl65i/wW5Y0Bso6zruduf/dif79A9/P/e9/73vSII47I3ucJ8rTXBM3BHB599NHGzMu8gTUCAgICQveBFjlBjwX5e+65J11iiSXSttLUP/8A1JX58+dDkAeghwzzvN3kOTnGclWTJwxawraVRp44nieixYiR+lxdbi9fWX4ur5VnnssQmW/IEtlLI69/pBgZk0+I2MUKzlefYwnX8tVy42ItblA+++67b0eQv+aaa9zzioisMSKzd46MExLirTrx+dbY0n3ruWWy2tDL06qvt7DDbVAkzbw4Ekvor0LQDrWj7FdaNLIWgLwyxNYPvml7P/9/73vfS2fPnp2+9NJLUYL8SSedZAozdZ+XsakrAgICQvXh5JNPHvTP+3AI8rfffvuIcNttt6U/+clPskn5TW96U9pWmvznH4A60jRBvm6WWXUrDxgcbZy3mz4nSyErJFTJ72OssrUYKb+zjnvfW+Irv2fBLa9uulyxbaLztcoZKoMnrOaV0/vOEpBj/JXnCdcx5QoJtHl9HeOXXb7fY489ss9z5swZFcfbYDZPKLfKy+JtXvtbeYbGRMxChdWmeUJzbJ7W8aJieNl53SuvtyhQNE2rfF6/8jHLRVJee4U2aw5dS22mqvn/D3/4Q7rCCitkaTDDaiFPotGghSsEBASEYQuYmyvc1JU2gdEbxMybNy9bbW8rTf/zD0BdBfkm+JCvwrpsmMtThCaWue60cd4ehjlZW5Fa3/H38nqXorSXbkjct/B8o/O5ukxFfn9C4mWRz7qsuk2svIqI4qGFCs+Pt4zniZUx5ZJphNrWE3y9snhlsqzt99tvv46F/De+8Q23Lvq91R9Wua0nC2JEfKteoXheWlxW67i8PmLGYaj8eYK/l2bekx+em568MR7jHsirX+zTKLot5bn8PpRX7O+ajId7iWrn/0suuSRr13HjxnUCfaa06P2iRYuGal6eNm3awMUrBAQEhGEKmJcrEuQfeeSREYFWzPnRtTbTpJsMUC34cekNW2+9NSzkuyBWgKgT+CPdG9o4bw/LnOyJmXmuHkJuP4pal8aKzoTnw9wSoGNEOymC5v028He6DHl+67085OeQ8KiFWi+dUFohAV7WIdZyPPS9l48unxRJKey+++7ZnMy+lfN+p3X9Y9wDVfFkQaiuXhy+nmQbh/rQQ/vf9/LU0JjN80sfakPrdyK0uW9sG3ltbS0iWHX00reuxZj+ilkAkOmD6ub/Z599Nr3jjjtGhE033TR997vfnb0fpnkZLmsQEBAQqg/egnrbqcyHfNtpyk0GqBYIiL1tV/rj3xRBvinUfcwOslx1bRPQ7jlZi14hC3CJJaDHCGT8vRYEZRqesCvLxUFvOOptpqrz1cJojLAq85DHtdCry+jlIcug/0iE2swSGkM+5a0FFBnXazerDfJ+37XQzvG1yx35PYUtt9wqc1dDovy3v/1tM39dHzkGdDza4NNqS52WV1dZZ08UzlucIGS7epuj8merzEWuS8+9EZ/njfnQIoRVDz3mYtrSKm9sGfQ5Mp7ue+88ayEolDbm68GT57KmqfMyX0sICAgICNUE0nSAzWJJBF/+8peTWD7ykY9ExwWg6ay++urJww8/nL16PPLII8Hvh50y9af4W2+9dTJmzJielautxIzZQTKoctE4XWONNWrdNkXAvD086PE4Y8aM7PX666/vfKfj0Hjee++9O3Hk+LbGuEyHvifk9SDjy3Q4L45D+W211VbJzTffnOXPnHnmmdnnCy+8cES5ZP4yX07HK6/HSiutlJ275ZZbjkiX20Cm89hjjwXzoPj8vSyPbk+rzWTa8nvv95fKK8ut4+p0ZLvL+hC6ba06cX3oldOU5aUxJvt50aJFyV577ZXcdtttyZw5c5KpU6eOyP/nP/95Jz06l95TX3M7EPR5s802y9I9+eSTk5NOOik7fuihh2bpyDS4LNwOus6yP63+5f4hZHvTcYbHmRyP8jrQ7chjd8MNN+y0j+wz7kO+PvUY4bandGRba7xr0Bp7Mg71jyyzlYY1HnSbyTHGdeS2kelY/cLty/G4T2VZdJ8w1G7cnt587LUNQ/lROsMwh3cD5v/uoGtp5syZyYMPPjjoogAAwFBw0003tV4Tc0kjWH311aPCGmuskbaVpqz6N5kmWsPkWSPGnN9Wa+yddtqpZz7km96u/aYt7TVM9Wz7vN30ObmoS4aQ24i8z5ZVd6gM2opY/8azpStZE8vXkOWrV66Y8uh82SrY2+Q2xpWHlWdMe3L+sr7yu6K/MXl5WFb4sWmGLJLl0wMUyF3FrFmzsvhkJf/lL395RBvSe21pzmOD3ks3QpaFvC6L9TSBtuYP1d/6rMcrp2P1sbdJrWxf7wkUz8Jdl0NbsltuiUJW6Pq9NcbyniCw4usxFjpft7VuX92n1hjVbWLV0cpb953lk76t1HX+b8q8LH8rEBAQEBCqCcP0P7tK4LKmZTcZbRR2B433hzpGCKiizoNus7L5syBftcuaJo+lQYD2Ak2kyXOyd81pgdmKnyd6eyJazMabVtnoNbTRq3R9Ys2FnvBoCaGhsmkhlYMWdqV4HKpjngBpxckT+suI8bqtQ3nkfbbSD7kPkm4b/ud//id7fcMGG2WPHdOmrp4oLI9pwdQqmyfcyvwtQdu6BuRxT1zXxy0Rn/MPjU9rjMnzrWtN1yMkKnvjLK9PY8aBJ4LrNEJjWZ4r29D6nbLaQNY3Zo8Gnbf1e8WLf7hnqSdNmZfhQx4BAQGh+iANMcA/gSDfspuMJjNMN9exdalCjKdx2cS265UgT7TdeqooTRw/oN00fU7WopgUrrQlrRT36Lj2JS3T5PP4s3zN81Fuif15fp8twU2WVX+ny6lfvbaSaVsCvk5bfqeFUv29VSYdRwuOnpDrld+Kq+sl28tLwzo31GZWepbY/NBDD2VC/Cbb7podP+KII3LrElMv6zw5hr2NhLUQzO+t+FZ/5pUjxjqcyyfz9647ubggr2Gv/bXInzeOdH1D/S7LntcmeWK+rEvMcf2kBB/Tez/o8ugyhZ5CseoF6kGT5uXp06cPXLxCQEBAGKaAublCQf7RRx9NzzrrrPS4445LP/rRj44IbaVJNxmgPvTjh6mpP36wkAcxlO3HtvV/2+btps3JnjCmXa0wnmBnueiQAmFINAzdMIfcTcj05Pk6TUuI9zaxlJuyynp57ea5OPFeQ8KrJSZbVtbW4oOsc2hhJNTP8nvdnyFxWJc/VFZdTys92ZZ33nlnNh9vvOMemcsaPRa0GBvbBpbw6/WfXmTRC1MyT6tMVj1DY8VqHz7Hux6sz/LPqLTgluNf563HmodVx5AYr/vHahfLRZBOQ1/L1sKE7Bt5XIryMi63jc6PjnttI9tA5gGji3rO/02Zl08++eSBC1cICAgIwxZCT6e2mcKC/FVXXZVOnjw5nT17drrYYotlN+ZLL710utRSS6Xbbrtt2laacpMB6gOE4TDwId+ccjbtGmrbtdfGebtJc7I3HkOipTyviHU6x/PETe+64HO872Qc6zxdXi3gs1Ur37DrenG8PDE7z9reatOYJwpkefL6UJbDWnDgOsq4nIYVN88VDsF/ciwxPK9fQ8Izf3fzzTdnFvKUDr3uv//+o8qpFwBCbeD1jRZ8dbuEBHDZl3ltphcdrFfvetNB1tkae7ofrCcyrDGvx6JGljPv6Rarvz0x3utXXRbvaRE5fqx6WflY7WcJ/t41Kts1ti3aQp3m/6bMy961joCAgIBQPmBerkiQ32yzzdITTzwxez9lypT0wQcfTJ977rn0rW99a/qVr3wlbStNuckA9QI/TIMR5JtA20TjGEJiYBVpDSttnLebNCdbQp4nBlpiVIzAzoKYFL75Oy2U63w9Udsqn/4+JIRri1npasIS9i3BTgvKniAfIwR7bSxf8/rRykOfrwVaHc/LP2SVLdtRvuc2svo2JKjqPv3e976Xzcdz3nZg9nrMMceYdbXGsteH0kJct52uk9Uu3tMaMZbiVn9ZZdT5yLa0BHyrjfk87UolJGzrMnjXvrbWD41TLy2dpha/vXOs3w09JvSmzqFry/o9Y1Fffy+DtrS3rpE2U6f5vynzsh5PCAgICAjdBbp3BBUJ8jSZP/DAA9l7WmGnx1iJ2267LV1ttdXSttKUmwwwONokAA6zIN/PfmzrmAmJBW1tk25o47zdtDlZW4NTsARH/ZnjyfhSWJPfszBGx1nEstL2xGxLcNTlscRx3sRJC2uyzJa7ilAesi6yjLrdtOBrCa8hFx1Wu1vlsc4PWVrLcuVZZus2s+LIBRdOyxJHtcgqLfUteJz86Ec/yubjzfc/Md1m27ek73rXu0a0TYwVf57VuNV2epzq+sh2tPrDyz8mjl7g0OnLz1Z61pMb3liTY8LLR/azPEe2gx4begyErMdDiwwxbek9iSPTta5P6/q1fv9ku+g/+vJawj1Cfef/pszL1hhDQEBAQOguYFPXigT5FVdcMb377ruz97NmzUp/+MMfdib2JZZYIm0rTbnJCIGb2N7RCzFx2PurjoJ8r0ThYe/Lqtq4bDu1vX3bOG83aU72xLmY3xpLCNQCtEzfs5APlcU7bglgWlTjQJuAesKmJaRbQqC2hKU0LVFdxuc8ZVlkXC3+WWWQ9bbERD7fEi7z2tfrRy6b/F7W32ofTtvzxa2tqfPGmBwnX/7yl7P5eIN9jko3f9M2I/pYisGeIGqJxLyZp25bSxD32sd6EkSWzRPQrb6wxo52u2KVR7eBFpd1+1jjwmp3/cfVE/W99vEEc0/olm0ur+/QfKzrq+PqfrAEeLkoZPWZ7hvr6Q+rL0D95v+mzMuwkEdAQECoPsCHfEWC/O67797ZZPGoo45K11prrfQzn/lMuvHGG6fbbbdd2laacpPBWDe7VH7cxPaOqsX4Ye+vOgryRC/E+Lr3Zb/LhmulWto4bzdxTpZCkva9HHO+JULrzVG1oClFsbzrRYuQMniCq4zDmzNaaWvxWactBRJtuRwSDaXluIyrX2W6njiohUBZL6sddH9Yor5uM11/nZcU4q08ZX46fa+eliAtz6E06feDN3PddOsd0i233HJEfrINrPHgHdN1pFfdzrrOeqzLdOQ1ExLJZZ/qMlqLHTJNWQZd3pAFu+Xf3hoD+gkQLUbrcnkLGjofuVBjPR3jCf7eYpMeM5ZLHn2+7lt5LYcWUfTY0L8L1pho85xf1/m/KfOyNcchICAgIHQXMC9XJMiT77nbb789e//888+nH/rQh9L1118/fcc73pE+8sgjaVtpyk1G6A83LpJmMez9xYI8/5EYZurcl8MgaDe57FXQxnm7SXOyZW2tRdXQGNYCHItW0nezjKeFLEsA9fLUwhqL7F48WSf9WZdfi6Pa0lt+1uXW7SWRYrEUTTkdKZbK/CxRUG6eqhc1dLqWqGMJutZvrLSs5ni6fywB1TtuBV0vXQZZrk984hPZ+9e//SPpJtvukr1/6KGHXJ/4Oh1L0LXGoF5I0vWR/S/HlW4DS5TW/SHHsOxTaxxY48IT7ax66jFqtY+uP19bVvn1uMnrc9lH8ndBP+VgieFWvtaChb6udd1lu1u/DTo/72mVk08+2SyX7ndQv/m/KfMyBHkEBASE6gPm5ooE+Q984APpNddcU/S0oacpNxlM2wUqUH/aJMjXHfxeNJs2zttNnJNDmx/ScU8o18Kc/sxxpAAtb4xDgqdVDg6e33cthsZYsHrW51Io1DfzUhTUTxTo/EjE8+qYZzluWdtbZbHqpxdadJ/IMoUsnHVZ9TEt9HtuVqx+leNOC8Zc5sMPPzyLs8bOH0w32eFt2ftvfetboxaBrHbxxoqupxagvYUQPWa1aC3HFKehF044LpdLL/ZYY1qPA93O2kJc1zNv0cN62kBes5y35/Yp1O58nn5iw/qzrNtBt5v359oT0GX++nfHu7ewFq50e+s2kOfinqWe839T5mX9xA8CAgICQvcBc3NFgjztyj5x4sR0xowZ6dFHH535oAPNucmoI7g4QVsE+TqOda9MvSxrHdthmGnjvN2kOdkS0Pm4fu9ZgGrhTN74SmHMsoaX6VnWsYQW8LRFuRX4PFkWy5LWEop1+Syx1UpXltNKS6ajxWQtQHrlplcSbCxL+5DVr5Wu107Wq05Xp231txauuS66Hak++skK2cck6pH/aXq/3ta7dd7LvvQWaKTVtyd0e+5K5PlWH8jrxhO3PRc4XKaQeyhL7JVp8WKPl4bVj17/6WtBLz7I/uAFJu8aoVfdn5a4z99b168cq96TJV6ddb9YCwRem3tjQ5bbw1vwazN1mv+bNC9Pnz594OIVAgICwjAF2vsJVCDIE3/9618zv84klo0dOzZdd91101NOOaXVNz9Nusmomm76Xf9xBmBYBfk6jnWvTL0sa7/boU7tPUjaNm83bU72BGoWtCwXHqHrVgvs2q2IJUJ76UkrYkvQ0y4pZLn5vUwv1h2JFlYZy62JFqG16Onl4VnrWgK3tNLmvCxLSi0OcxqWJbxVltjfTV0+LerqPtBtoPtNjjP93b777pvOnbdluva+H0/n7X1IOnfu3PS73/2uKRpbvykhX/+6z616a+Fc1scS8+V44H7ScbWbHP4+1K5cV24n2f+e337Lcl2PB11+PRZkv7AYL8eaHkf61RLZdT66vtZ50r0Pl8uqO7vckfWyhHX9e8Vtal17efcN+jcT1G/+b8q8bM1pCAgICAjlw7Rp0wb90z5cgrzk0UcfTU8//fT0DW94Qzpu3Li0rTTlJqOO4lqvRL9+gJv+9m3qOizjRYsM3ve9zLuNiyB1oA3zdpPmZCkkhQTTGJ/yljCn3WroNC2hTov0LAJaltxaNPM2r9TWq/I8mZ8W7jhv6dJEfi/r7gl3+vdO/jbo+lvuMCyLfCmMaj/1ug1lm8t+lnlqQdnqW6uPLattWV4+rhcf5DnWUwSyzNtuu232ut4Bn0vnvPX92ftTTz11VL7eooM1hvXY12NOfi+DN+Y00jreSoPbQvavzsMaL9r3PC8WWOPMWoSwRG7retV5a/FfL/zofvT2RQj9dujFM44r89ZPUMjfBllnfc3K+smyyN8La4Nkq03zfv9APef/pszLEOQREBAQqg/SuAZUJMi/8sor6SWXXJLuscce6eKLL5493tVWmnKT0QvqdvPbLxGul/lUlWbd+qbNFvJ1og1Cdd6CQ1tpy7zdtDlZuzshpJAlXaRI5PjWrkhkupZYm+fGhr/T5+lyWEKidi+hhU8WkrXvcfkqxXkp+mkRT7ZFkRt+LUDLdL1y6b7iuHzc8oUvhVJrg1mdnraYtoR4vXAh41tpeW0sy+mdR+/nz5+frj9363Tjo7+Zzn3v8emcOXNGxdcitHarYllE6wUWfm8tDFjW4J4orzcd1vWVY0COX7k4ZOXJaHc5nJd3PXnXuxagrScNtHjvCdRW/7Fwr69Djd70VV+7fFw/6WD1NZ8jFyx0Xb0NmWW7W8gxohdC9IImqN/835R5ec8996xMgEJAQEBASIJze9spJcj/9Kc/TT/4wQ+myyyzTLrUUkul+++/f3rVVVelr732WtpWmnKT0RahS5etV2XtlRhPY6nbtJsuug5KkO9He2lBYBAMs4VZ0bHf9PrG0LZ5u2lzshRrtUsXLUrK7/iY586D0BapnJcWsbSgrtPkNHS5PbHNspjXorQ8ruvrifehJwdkG1pWwfq3l9OQIqzVXjqOtr7W58t6eQshljhvie+yzpbgbz2JIOusxWgvbfbvKePS64IFCzIXNWwhv/n7P9UR5K3xpi2kdXvLcWEtfFhjR4rEcozye2llrseCfkLA6n8ZSFzW9dDziU5Pj2nLOl33q35iwVpQkX2or09rXMjNi3V61u+LrCcd5/7XVvuWayZZDlkfmS+nx+Xiz6FrUi+y6ffakt5qe1DP+b8p87L3ZA0CAgICQvkAQb4iQZ5W02lV/W1ve1t60UUXZTfqoDk3GVWIdXxB0WsThCz9Z7rqtHtxTlXl7FX5hlWQ78cihiXu1KXNtUDVZIqI8cNQ3xBtnLebNCfLedWyjOXfCs8aPOTGwhJydXz9fczmmVwGT7jUlq/aNY5092IJ37IM+r1uL84ntDhg3bdY1rjenwXZ/jpPy5WQFog5LpdfWmJblr2yTaQFvjxXC+26rSxBXrepbH8usxR16fWWW27J5uKN5++VWchvsN+x2fGDDz54VH1lvT33NNaijByLeqzpvpRW4lYcmZ/lisY6T48bXgDQY163nR7XevGIxX3rerYWh+R3UuD2xr+uixwH8nw9dvV8p+tlLXzohQNZDusYtydv4uYtCMgy6jFpvZdt6+15MMzzeZPn/6bMy95iHQICAgJC+YAF84oEeRLH/va3vxU9behpyk1GHnkioWfV0m2evaYX4meZ9Oou/tWpfLGCfL8XWarIz7L6qgvWwlXdylg1w16/Ns7bTZqTLctgFh2t3wotXnHQFsGWyM3na3/slqCqBU1P3NZl0ZbS+pXP08JyqL4yfxnPEvGkoCnP02UOCZ2WYMlpWe2mRX35nW43LVzqdrNEaM9iM+97q82tsjDW0wH3339/NhfP2/vgzEL+9W/7sDnuZND9aNVZjjlGW2bLxQav7t4Cg9ceIRcqnv92XQZ9Xeg6hizk9bWh76mta8J6GsMSrfU1YS0w6YU9ma/ldkfHk5/1ta4FfN0G1uKV7ivtvka2gfUkgIxrXbttp07zf1PmZQjyCAgICNWGSZMmDfqnfXg3dQXNuskIYd3Ye9/3Is9+0G/xth9lqJrQgkvZspc5jwX5r371qz0fP7Hnd5tf3ft+UNdoE9qlCWUEzZ2TpUWptB63BCdPkLTEQ8vK3RK6ZBxprSzLJS3wPRHbEjT1q+WXXt97yOvNElxlm3C5OG5e/rJu3oKDblcp0IREUl1mT0y2BFQtcMrvCdlPss66fFp0132l3frI8nCecrycdtpp2VzMm7laQbvf0Ysisr25Lnpukf0p20WPM6vPZH7yvecWRwr/+tqRT6nI9pf9ottSx5fllljnyriyvXjfiFC7WkK5Xjyyyp03Zqx6y/aRfa/d5OjrzRrn1m+Vvr5138iy6vJZYwnUj6bMy3BZg4CAgFB9kE8Ngn8CQb5lNxl55N3E9uImFzfOzRBhywqzZc6juCFBXpcrlE7e8aLl60aML9N+daDXYnzd26UJZQTNnpOlUEhYmyfy+LMsxaWQqoVNaf0r89NilxbHpOCvBUwZR4q5HEciv5dipWfBLuunfaZr639LnLWsgnVZpCAsN4z1rL61NXfI+l73J796iwr8atVfY7lgsQRP7b5I92+Mr3F65fczZ87MNnMlC/m19/7npq7ki1r2h07LGjOegCvHmbcIIvtRL17ofOW48PYz0AK15QJKl1W3tWVxLs+X3+l+0K56OC9rUUWmIce51e6hRS9dJmvRTl8r+hqznoqwfmd0e3nXvlyM1PHlb4f83bKua903oF40ZV62FlEREBAQELoLofvzNgNBvmU3GQALAN20UzdidJG4dC1tvfXWpsuaWHHUi+ctNvQDjD2bXi+GlMEaN6A5NHFOtqxtLVHa8nMtN0zUYr4U4bRwJ8Vo/t6z7tabSloiJ3+W6eibcS0IEjq/vMWCvJt9LTzKdpJxtYjolZnQrjS0ZbVeLLDKxnF0H8l0ZRoSz8pdniOPSR/3uo66XXWbSUF3n332yV433OuIdPXdDsnez9lo0xHjUI9bLQLrhQTtGsf6Tn6v20OOk1A+llsaT3iWwrQlOOt29tpfl0MuHFjXlR4Xeqzq/pRtYS2k6OvUG69WX+nfFD1+9RjVvwH690SmFdM3sj10eazr17pudP6gPjRlXoYgj4CAgFB9gCBvA0G+ZTcZbSdWzAWDhX6w2UL+nHPOqVzARf83j9iFlCr6Fr8Tzadpc7IWzfiYFpi0+C6FPGsTSW3JK99r0dESIbRFqr6ZliKddLXjpSNvyOWrJSpqf/b8XguUWgjXrkBkWT3Ld8uSmYMl7mlx2BIL+VzOR1siy7rpPte/QZbYall7W8KljKvFZ8sPuxZ7jz322Mwifs3t35l9JlF+062374xDLYjyuZ5/e/2Uge5/7dbGeiJDj4XQ+NUCtUxH1lML2LJtrQUuPT5kuWSfeYtJevHHGvt5/vk5Xz2m5Ks3vriNQ2OSyy6D7gfdn/opB+/3RtZbCvzWgoVMT6Yj09d1wvxdP5o0L8+aNcudzxAQEBAQioUll1xy0D/rtQWCfAtvMtrOIG7S6/bHoM5CNf/58izky1KHug1jWfuJZRmoBXp9rJu8QHNp4pxsuXJgsUmiBWkZ3xKWZTwZ17IYlmKeJ4TKa5BfLcGRhTbtKscqA4v5HD/kB92yiNVCtExPtpkun36V7aaFPwuZvyWQyzrL+sj2sdrYEsqlOw+vnzzhVYqdVt/rNLyykxi/8dHfTDfZfveOYKX7RYv/esFI5qeFXS7Pnnvu6f6p0/npdvUWhjzrdK6nxBoTMk+9EKYXl6z29BaTZD/IstN7fb3oa1xfU7Lf9BjQZZNl1PtWyLHkWQvL+siFDP3EjAy6b3hh0YrvLYbIOCF/9qB+NGleXmGFFdzfIAQEBASE4gFPr9VQkL/uuuvS3XbbLV1ppZWyTrrkkktGfP++971vVEfOnz9/RJynn346fec735mtuiy11FLp+9///vS5554bEef2229Pt9xyy3TixInpjBkz0n//938fVRYaIK9//euzOLNnz04vvfTSob3J6BYIVcWoUiTsZXn6Wc48cUNayFchyJet26AWb3rRD3UZf93gCYI6DgBNm5M9wVwLzjpengWtFtu18GZZrutFLimwaWtgyz2GtbAg/WlrP/ey7FJ4t76Xx7T1vrTEtYR63V58PiHd/WjRleutxW7ZDpZFr/W0gtWHuv5yEUHWSecjP1uLANaY8ayULYGf06D7dI639r4fzwK9J6v5L33pS506xgjOcpxZwrAO8jxqT2txR7a1TFOPPd3m+qkDy82KLJ8W1a3FM9nX1njVdbI2UtaitfxOb8ir+4rHjZe3dk1Fx3jsy/a1rP51ufV1LttfpmP1O6Wr926QCxfeWNS/L1wu2d58/YP60ZR52fudREBAQEAoH7BYXkNB/rLLLks/8YlPpD/4wQ9cQZ5Euccff7wT/vrXv46IQ99vuOGG6Y033ph18lprrZXut99+ne9p0l9xxRXTd73rXemdd96Zfu9730snTZo0wg3GL37xi3TcuHHp6aefnt59993pJz/5yXT8+PHpHXfcMXQ3GZoyAiUuqOIMUuQuErdf5aQxlFeGKgV5mW4V5ex1O/VCjA+1eZOwFpKKngOGnybOyZa4pK1E+XNIMNCCpxYktcsbeVyL8ZblMwtelgitBUBt6SxFOG0lr31Z8yu3iRacdZvIfLTIp58SkOWWwmSMuxXZVp5QKuNzmlbfcF4c5KJIXlm5PbUlsyfyW65gOE9rAYXPp3tsel1x3tvc8WYJ0LrN5KKHbGdZJktMluNG1ofbSD4Noec62Z6yv0L9K+NaIrAec5ZobF2j+tq2nlKQorzXrlqwl/EsVzf8vbXQp/tGl0c/AZD3u6OvS+/asH479DiWfa+vB/37Y/mjx7xfP5oyL1sLwQgICAgI3QXohzV3WeMJ8rvvvrt7DonndN7NN9/cOfaTn/wkHTNmTPrHP/4x+/yVr3wlXWaZZdKXX365E+e4447LrOGZvffeO911111HpD137tz0Qx/60NDdZFQh0umb527L0BTqXNamCa4x5Qz5kO8XnhjfpLZmmlbeGGL6InYBCAwXTZuTLctnT9iSoiKLfJZVrRQVrRtjKRBabkZkWfg6sVxb6PfWZxZ+Lct3LUjyDbvMSwqlhBRvtZDnlVEK37odvHJz2H///TvvpQhuCYFyAUSW2XJvYgk/chFGBpkOIRdVtFWx55JGP+0g85Xtxt/9x3/8xyiXNWwhL4MsrzferPJQ4HrIhR4rHWuMy7RkO2hRXddZL+7QccvVjSynLBuPQX7vCXh6MUxey5yGHEfeooRcVJFt5S00cdn0IoA15q0FHF1WLYDrBQOZjxbmrXxlel5fyd81WV/52buGMa/Xk6bMy6HfMAQEBASEcgFzc0MFeXJDs/zyy6frrLNOetBBB6V/+ctfOt9//etfT5deeukR5yxcuDCzdiere+I973nPKFH/pz/9aZYfW9uvssoq6X/+53+OiHPiiSemG2ywwdDdZGjKXhjdXlCWJVOv8qoi7SIibJny5gmK3abRTdyydJtHyEJ+0D/oTbOQ7yfawraf+RWNU2Zxpcl90yaaNCdbIrUU8rTgSnhCnBactZDHwXJdI8vAYp5MV5ZTi+uWsK8FOS30h27Y9SKErqN8L9EiPrevdn0i48hjLM56bk4sEZzFSd1e8lio/fl8LaLL/tHl0Hlb40QLqFb7STFctonsJ/IVv9qcLTtW8usd8LlR5ZPjWFv9y/x5HOlxYPkSD7WJdjOjF3g8sVaOC8JaOOLy60UBb0HJs+TX9dHXrGV1zvXRY9TKTy5u6P7V/amfSJFPF8ixpK3YLVFd+2mXwnqeEC/ryP0r+88aH/ppHj2W+LhcNIMVXj1pyrwMlzUICAgI1Qd9zw4aIMiTe5kf/vCH6W9/+9vsO/pTsNlmm6WLFi3Kvj/llFMyoV5DAj5ZxhM77LBDeuCBB474/q677sryIwt7gtzTfPe73x0R56yzzso2dPFYsGBBdkPB4dFHH23ETUYdkH/apJVSXtxelyMmfpE0y5SjivR6UcZB5OEJ8r1aHKlikakKmmqBb11TvajHINPTdWpiH7WFpvzxZ+Q1Y1mvsqhGSFHWctsgBUV9M6ytjy0x3bJet763rIJlGbToqkV9aW3OZdJCvrVYYN3ch4Q5mWfegoW2tNUWvdqS1wpazNGitxSfrX6WZeVyWNbhlnCvf4NDCytaBNfueDyr72XW/Yc4P23aNHO8WePHEmRle0gRWIvWsv3lmLF8wHsW5bo81rXDbWa5e4mxYA8Jw3qhitvLGgtaePb6WNeZ0tKLMJZ7G0KOKSuOXqDy8pfXA1+H1jXgPd1gjRHvmteLhXohSMfD/Fw/mjIvW3MnAgICAkJ3AfNyAwV5zYMPPpjFu+qqqwYuyJ900knmQKv7TUYMvbpYLMvZGNEuVjAvWgaZdpU/EoOykK8iv6qF/14I8px2TP6x/drtGKjDGOoX/Ac89L31PhSvSN5F+rQsoXMta1BQP5ryx9+aE6UAqMVYKUIyWsDWoqx282BZsUqXE/IcKUITlk9pT8iUIqusD1soa2Ffi/hSFLTqogVZWQbPItwKlo9zS4jUls5cHm4feb7OQ9dV5yXbUraFtCJmoVdbgMv6Wv0rx5S1UKMtt+XYOuqoozIXjrN2+afITC5rVn7LuzuftbBvCeF0zPIDr8uox7R+MkQLu5bQK/tH5mu5bwlZuofaSS5sWeWWZdbn6LFB/ar7Swv93G/aKt1awPAWYaw25Pdy0ch7GkFulirHplVXfW3p3y4+39pTQvdl6AkE+dsgLekxL9eTpszL1mIYAgICAkJ3AU+vDYEgTyy33HLpf/3Xfw3cZc2wWsiXFZny4ofSzROHi5YplJ6VTpWCf2xZisTr1x+LXojK3aRXxaauRfLudpGinwsng0pb//EfxNjo9QKLda73W4Q//fWlKX/89bjyHpX3LF35fClCWWJdkUfwpQWyFB05XS2oexbj2hpf1kNa+3OZZZocPJcvHCzraMqDsFyVeG2qy2XVR6dhlc2yOiah0LPAtxYa+DsrPbkAIhdC5GdrnGjLaV1+6zw+Z86cOen67xzpN14K8lxHHifyfDkGuE/k+NGW0Lq88prwntzwrhHdb3rRQbaX1T+yPtqHubZs1wtkckFFXqOynDINeQ3reVaPfY7nbeDK6ekFJavcUryXCxayjHoRwbqm9W+Pbhv5O6L7sKh7ENkXevzI6wfUj6bMy97vPwICAgJC+UD3FKDhgjyJ3rRhK7mxkZu63nLLLZ04V1xxhbmp6yuvvNKJc/zxx4/a1HW33XYbkde8efOGflNXiSU+FTmX6h4jysci/1QUOTevLJYYH1P2MhRpFy9eL8vnlaUu6bEg/9WvfnVg5Qkt4vSafo7NogsXVfiA63UbdpO+/j3UbdVmIf7UU09NN91003TKlCnZ02i04H3vvfeOiPPSSy+lhxxySLrsssumSyyxRPqOd7wjfeKJJ0bE+f3vf5/usssu6aRJk7J0jj766GxBXXLNNdekG220UTphwoR05syZ6XnnnTe0c7Il2FmCmnbL4VnWymPyuHZjweJWrChmiWjax7VlXa7T0da1Mk26YZcuQvg9W4izSMjXoSXWWwI2IS2O9fdaxJPW3lIU1u1O31lisOe6RqZj9a9OnxcYPGFWf5ZtpsVbLoMW5eWTBTJvEuPpdeU3v3OUZTyFVVddNdt43etnq09kOfL2CLDKqdvOE+Kl2KwXHbRFt3xiQbpD4XEg05UuaWTZ5Ljynq6wyiy/14tf1jVmLUx4/cr11mPHajPvaQF5TI+rvHPkUy5cP/lbJ8V6a3zIp0KsxTAOXBZZhjbP03WlKfNy3m8ZAgICAkKxMH369EH/tNeWgQryzz33XPqb3/wmC9RRX/jCF7L39EedvqM/6DfccEN2U0VuajbeeON07bXXzqzTpWhHf9hvuumm9Oc//3n2/X777df5/plnnklXXHHFzFL+zjvvTC+44IJ08uTJ2R8I5he/+EW62GKLpZ/73OfSe+65J3NHQ25s7rjjjqG7yeiV8Ff23JAIXdbCpYzo2iuqsK4e1j8VefXSgny37VB2nOtx2O34jKXXizGe1Xe35arDeO3lwlK/F8nqxvz58zNhnObT2267LRPVSZR7/vnnO3FoA3Z68uzqq6/OFszf+MY3pltssUXne9oHZvbs2en222+fzfmXXXZZ9vQbLZYzDz30UDZXH3nkkdni+xlnnJE9/Xb55ZcP5ZwshSpLrAq52tAWxFK8ZKGKXrV1rBbLtLsXKXBZQrEU+WW6nrsMz3qW8CzgtfDGAh0LxzJNrh+LyBwscdVrPx1Pt40lHsqFFG3trttd9qnVF1b7yDp4dbbKo99rIZn7Ju9JguWnzwj+yfLEdSt93jiU47NoTq+6fF6ddP/p/tGLLtqVkO5LTmPnnXc2x6Y3dnVZPItvOea0Zbc3FjlPy6+/FvC9BTW9+WrIjZPldkimafm6t36zrPyl5b0W8r19FaxFhFD7y37UCyqgPjRlXo4dewgICAgI8aGt/51rLciT9ZvVWe973/vSF198Md1xxx0zyzkSx1dbbbX0gAMOGGVl9/TTT2cCPFnrTZ06NbuhJzFfcvvtt6dbbrllOnHixHTllVdOP/vZz5qTL/mjJ0u89dZbL7300kuH8ibDI8YCuBciF7WZdeOMC3a4KPNkghTk854iiMkzFDdUbitf/QRHGWLO1UJw0fOrLEtM/G7E6irqwwJBqAx5+cT2C36j/sFTTz2Vtfd1113XWQSnOfuiiy7qxKGFbopDC+wECfBjx44dMZ+fffbZ2Rz+8ssvZ5+PPfbYbC6W7LPPPtmCwLDNyVJM8lybxFi4Wv7TraB9sxOW4El41vryWguFPAt+yxqcXrWILS3mvfp5Vv66vNqKWOanRVq5GCI3H/XKr59ysCx5Gb2goYVt3e+WhbSuvyy/5Wte7iMQEp34O1ps2+Lt/9qxjF9x3ts6cVbaaLvsyRU9brV/fN2H3kIOn8/fc59Z1s96fPB1pOu05557jshLt2HeYhUvEnA6/KrP9/ychyy7Q77aQ08J6PpY6XiLLNyO1rWrx4+Xli6v7KfQuIr5DdP9KY/pNpELKFbemKPrR1PmZQjyCAgICNUHzMs1d1nTdJpykxGDJWiVEdpiBLEYYTMkSlZBE38cmlLmkECaJ5hrH/KhpynKCP5eeWOOhY7H5lOkfDp+FVbavba8L3pOTH3yfic4jbILBkXKgRuLf3D//fdnbcFPlJFVPH3+29/+NiIeCXv0FBxxwgknpBtuuOGI78kins679dZbs89bbbVVevjhh4+I841vfCMT7YdxXxfL+jzPDYoU+0KiGVtuW1aungW+TlPG4XGvXcl4/tGt9HSwrMi1pbO0WNbtI9+zaCrLwq/WgodXbo5PSF/uIV/mLBx64jm3nfc0gzzHWmDR1tUcTy+YSBGXv+N+0pbXPI70Exnk8pG+n7P7BzJ3Nesd8Lks0PvlNtqhc/4OO+wwagx5CypWm8h209br2lJbl122qyfG032ELlfIbRO3gycY8/Ukx5aul7X5rO5Xz8q/Gz/5etxrIVtfE3oMyjbyxou2fNdPk+jyyqdaQkKnvG6ta9Xre9mWckEM1I+m/FeGyxoEBASE6gOeXrOBIN+ym4xYLFGrqBgfK5QWEdmsNIsQKk9Ri+Uq4xZJp6x1dr8F2DJtK+sV60PeS7voj363onCv+6PI9VgXQTm27zmu9b5ImYsu+sSk0W28YebVV19Nd9111/RNb3pT59h3vvOd7EkzzWabbZZZvRP0tBs9ASd54YUXsv4l63mC3M+Rv3oJPblGcegJOg25mrNu/powJ0uLZl1+KahaFs9SiNKipCcMhwRBKXqRqMV5ynJ6Ar7OT55jCYl6gYAtXkP+xT13Ixzy8tHuUuQcpUVtnadMQ7pa8f54WIsEdK61MJKXp+VuRi+Y6Lp7gqosn+ejnd4feuih6axZs9JV5u02wjp+9d0OMcsvy2AtKFkLC56Iay068Ljj1zyR33JfFOoja+FCWmHLOmnxnuOHxGkeY5ZbKimGW9beuu91+UPiPV+X8rN0xWT9blAbEHlPtOjvQq5wrDLxeXlPvcgnWPTYlXEJvUEzqA9N+a+c95QZAgICAkLxgHnZBoJ8y24y+m2xWvQcL74UBLopj1WnWLG/iMBcleCp85RWWXnn9aI8ofLFlCMmPSZGkO/W0lmnU7Zf62QxbY0ZL16VeXptUrRdQm1ZJJ2iC1d16LumQb7iyZ0cWaMPWpBvsoW8JchLAVYKndrNinaXQmjLWBbgtHjPIpcnEMv8pRAqRTkWcD33L541tD4W8m8trdNlmbSQKL/XArZsI20RbJVT1o/jSQteea7OQ7sp0Rb7oT8qUujXIqslVOvysKCrLe9lfbz888YBB2kd75XB+k73l+5rXWft19xyDSTT8J4qobFgCej6qQQ5Z1He0m2NfgrBG7vWEyd8nXpPMegx6y30cBnlIhdhPfXhhdAGuDoN6wkU+dSK5V5K92mMRXtocY++kxb2egzpcSXbAtSPpvxXjrmWEBAQEBCKBczNNhDkW3aTYVFWsCtisdqN2KXzKSPCslDRjVUxx6lisaIIOs9uROMy5etlPUPnapc1RetZdX/mlblOgq6sl65bFeXU6Vn5yHJ0k37Z8kkBIzZ+nfqw7pD17IwZMzJXM5JBuaxp8pwsF1pD7k9k0BtQSgE25PqC05IimmdVbgnhMs08P7uWWxi+Ji2BUgvXlpAtz9dtZgl7JOZJgVq2gX5SQAvAug5W0G2j3a7Qe+4ry8UQC4pWG1vubmQZtcsQ2XdW2WOeUpD133zzzUccW2bdLc247Ec+lLb2yS7HtzWm+FW6OZGLFVJY137DZXvIRQxroUOmw+fmLUxwHXRdOF1dhtC48frQ6x/t2kePYes3Q7rpsdpfPm3CZclzhcX1tJ7a0b9BcuFPC+qWmyPpEoiD9hcv20Wmye2KubyeNGVe1uMPAQEBAaH7gLnZBoJ8y24yqrZwzhO4Ke2yLlasfMqUV/6Zq4p+/qCUWdSoYjGlSLyixAjhLMifc845wXT0K6dZpG7DMkHoevAfbfm9bvOidbcWyKq+voqWx3ov/+jHjgedBhjNa6+9lonx06dPT3/3u9+N+p43db344os7x+69915zU9cnn3yyE4eucxLbydKdIGv62bNnj0ibNnAf5k1dpRCmRToppkpxyvIzbvl1l8Kf5wqGXdTo49Z7Clr4s/yby+/kqw5cJ70Jp5WO56tc+6jW/sKlmOnVi8+JtWq3ymC9D7Wljsd5axc2edbxoe/04oolOstyfPe7381e15g1Z8RGrmQdTy5rpNuaadOmjWpnOe74+Ny5c0eNBx2HvyNCPtm9NpH3Fp5LFL0g47lwkuNJ58/jlV+1yEyE3MhYT2mEfKRbC236urAWh6y49Nug4+p29Mqjnwawzg2VwfqcNxZ1ueSY1k8N6DEE6kVT5uW8xWYEBAQEhOIBPuRtIMi37CbDoozFecz58rsqrXJjLV75lX8E+mXR3i15AmrRNLqJkxevrPUz16kbC3krPf5cxdjtFb3KU9fZWwgrMr6843pCHdS1o8eSrgsfH/QC1DBx8MEHp0sttVR67bXXpo8//ngnSDcy5MqGLOJ/+tOfprfccks6b968LDCLFi3KxHZyW3Pbbbell19+ebr88sunxx9//AiL+cmTJ6fHHHNMes8996RnnXVWOm7cuCzuMM7JlssUPm6JY5ZLlpAAnBdYFOP8pLhaRPSTlu+eFbMus3QJo4VaXW+ZvyyzZ9UccoVjxZVxWGyVm4Lq+JZfbv30Qkyw+irkUkh/JxdcQvX0BGDdxr/85S+jrOPz2lMfk770rfja+t2rv+xTz22TdV3pcWOlk7cYo/tXu46y2lPXUz+1kRdi3OXoMem5/5GLMlb/Sx/6Mr7eCNc7rtu4rPsPWWb91IdVb50P5vH60ZR5GT7kERAQEKoPmJdtIMi37CajSsE1VuiqSoyPvZA9gTYUvy5CXIwFc551c7/qUiafIosqLMhrP9KhdPOOlUmnSnrZN5Y4HbMSXXRBri7XCpN3nRddFKzjIk6d8G6yzjvvvE6cl156KT3kkEPSZZZZJhPV3/72t2eiveSRRx7JhK1Jkyalyy23XHrUUUelCxcuHBHnmmuuyTZlJJ/0a6655og8hmlO1tadnn9yy7UKx5PW6iwsh4RcL1hCvxbiPZFNnmsJZ9rdiv7slcmyUrZEQBZSLbGQ8iLyXPVwfrodWHQNCTXUj9Iq37Mu1mXXfsdDfrdjLDcprdAihRw3sgzyu1NOOaXjikb6jNfC/Os2/8eGr7FBLxh4+w9441ZeG96ChV4EonOoP2VeerFIX4Oyf0Kuo3icyGvTckuUN+Z0nnljTZdHj7f/r70vAbukqq6tpptupm666aYbGmjARrFFoJlpRQmTgOAUQHBAAokGQR9E44CJoIkRE41TwKC+iL7Pp0ZJHN5DCA4RRAwiTxAQEQRjKwgGZVJm7vtOmf27/9V7n3Oqbt2/qu5d6/vWf/9bwzn7TFV119m1jxbl8U0RK78Ab7Itlo+O7y71KJ+xSSY837NL2439xqsXHe+e6Bb6cl9mDHmSJMnmOem/oT1QkJ+whwzEMB7Ycl5K7G5qAFYR1HLzzC3HTCK3PmPlrOrxXNe2qmJ8lboOgry84j5MvpYdKftGiabST4nPqYmbunlgPl3AqCcPdHn5QNEP9O2ebC2EaHndoggZExN1DHUU1bRgh+JDSrTGsBUorsc8o61jMASFt5ikt1gobkOxTjyatSBuiaboESz1p7fFhG4MWyLtgmX3xB4U5HUcf8wjFvtd26HzxnNyF3HVIWu2OvDlU/9L2JqlS5etUz4thntezTltif3ECyGjyxQQq2MJZyKisQi3elzE6keL8Li4rLXYrFU2mRzIeZvBKyuGH8Jx6NVPqu4xtFAqHn4udV+03jqJhcsKlEkrLfxb7av/J7qFvtyXm+rzJEmS5O8pi9ET00FBfsIeMizkCtd1zwv1kut1Okqx0tvXhnf1MF64KLTmCtzDiolNiJFV3kbwPOSr2qHrJzWJEduXyqMu6va13HKMSkTWXvhdEKirTELlXm+wv3Zp4o4Yr3uyJTRKWBErlrN40GrPahGa9cKXYXvKq1oLf9YikiJAahEt5XUbKOfpNNEj2vIkxzwsj3yMC6/zS6VnlR3LklpsE4+1Fre0hH0rrn0sbIgWf60+gh7G3j4UVlOTBEceeWQZdsoT5Z983FsGO73yPeVn2LbTTju5b1GI3Zbnvp4Ykv05YlgsvnxMSLcmXbCuvAkm7KupvhHz4se6l76GYZOk3sI+6w2U1DiUc6wwO96xHr04/ugNj33LCnWFx8mPdF0u/QaDNxZjYbooyDeLD33oQ4Odd955MH/+/JL77rtvuR7MON6X6SFPkiTZPPkb2gYF+YbQl4eMHDTtZZp6KNYLb9XJp66XtpWGJRhXFe3q2pC73zq2yvFNi8dVJ3RybAj7RZD/6Ec/WitPr36qTNZUba86fbfu2IqNq6beKEidhwun9gF6IqFKu9I7vl/o0z3ZE/bQ21Pvywl9gWEtrMUcY2FbvHRRrBAhz4q9jcJfzOtXxxe3FgX1bLAWcs2N5W6FkZH6tmKMp8KIeDHcrUmFlEd4SiCN1bXUZUwIFtEzFkZkyeoDTVFeGAT5p+yxXxlaystHJpRyJ4hi3u+x87TdOBmB9RKrE7TP68MiEldZAFjKZ5XRm5QLwDcjsJ9ZceGx/6MAbvUFy15PnMRY81X7qZ6MiU1+eX0Kj9dvCnBR1+bxpS99aXDhhReWi7nfdNNNg7e85S3lAu7XX3/92N2Xc98eIkmSJPMpIfKI6aAg3xD68pAxrGA9THpWGvoVbTm+CYE9Zrs34aAFulzv4rpewihQp2xOpZUrNmt7m0Bu/et6TdWnHPPsZz+7fHXaEuRTNllpDoOcCYQmJ5Ry8qvajqOYLGi6P80Uqky26f8pxvcHfbsnWwKdFte0wKjFAi1MSRoSLzv3AdkSFHVa8l0Lql6Ym5TnbcrzED2kdb2gwFhl4T2xGd8oQPuwrHXqziO+KRAriyfa4rG6TNabAlUW+tX9bbfddlsnTE3wiA9hauTTqw9pQy8vK0wStoH2UreOj9WdhDTRgnGg9B9vokNPCHmTK1U9Z1Mhoazvehv2RRGbdUiklPe5iO3yBoJO0wuJ5IU6ssaG9eYFTv7FPPnxTQovX32svB0Uax/er0ePsE7M//yf/3Ms78sLFy6sNNZJkiRJn2HNMMIGBfmG0KeHjBTqPMTmCsHWcfp15jqiZq4YrI+NechXST+grhBbxb4ce2J1rPcNY6+FqguH5tgf0gyCfPh+9tlnZ6eNZWtCHM89L+QrdRErYyqd3EmLKu1Y17s7N+0mjhkVmsib3vH9Q5/uyTKWg4glAp6IhzpUhSVmadFQC1g63Atu0+fliNqWF7kI3DGBEkN/aO/eqt7fKBSmBG1dZ+hNL0Je7lsHXtgPqwypGOQijgbg+alwLdrLXETmmFc+LnbrpYXHXHbZZdPCEwXP+CDCS4gaCVMjXL7LM9328urBKx/WrddPrPBCOX1ZL/zrrQcg91e51+ZMaljH6ONi+em46LJuQI63OC4oa/VRqz1iZcHwMFa8fCt8llUHVei9CaPb36qX2MQgMTo89thjg09/+tPlgus33HDD2N2XGUOeJEmyefbNgW+mQEG+IfTlIQOhwzEMk0YoexVvU88Ob7AOYyN6uzctSOs88P/YcfK9in2egG+lV9fGqsegPcNcbC0P+Y985CNZIr4lildp52FFV2xHq2287VXbX5dZp5Fj3zCoM2FUpx28tKqiqTa1bKE432307Z6cEqhlcVYR7XIffkWg80Q0TS0YamEv5BkTSLXHfBA8U2KGV1b0YMaQMbocqTqwBEgvXy8tLRCiqG2d44W/scKgWG8NyL0L20ovsqlFeK/+MFSRVzZMQ2z62Mc+NhWCZtHT9is/LY/4INTjdhHyMX9df/K/Lpf2zrf6q6a1T2+zFj7OSQe9sLENPZti6yDk9DfrLZhYvwzbY29m6PUKpO9ZE3A4KROLj4+LR+vJNRTv9TmxesN6RztSoapS5A//5vH9739/sPHGGw9mz5492HTTTcsQNjE89NBD5T1YuHbt2l7cl6u8YUaSJEnmkfdlGxTkJ/THf4B+uG5CUG/KppidTQh0mE/Twrxnp+W9jcdWETxRjI7lX8czOre+Me+cC26VGPLBQz5mS059xr7j8XX6Q259p8Tq3PbX+0cxweTlKW3r5Ven/2H96z7d5JjPtceyJbWP4nz30Kd7svQnEbPFu9YS+jwv1JhQFQsxExOd0fNYxFY51/Pct4RNEYktUdwTynHyIRX6Q6cTztUTDJaA6XmWWxMCVv1LmnryQkJpoJ16W2ohSqtsUvepEDlBSA/QZfPOEW/sYJue6PjgBz847bglux2yjle8hLHx0g1pVhWqvbS0/bEwOFa/98LOWF7ddUS41DoFnkc89lcvjE3OorAeq3qsy1sBGJ/dE8glTrvuP7qt9ISL1Q+tRZ/1mwWe9778r0NoWbH8eV9uHg8//PDg5ptvHnz3u98dvPnNbx4sWbIk6iF/1llnmX2t6/dlLupKkiTZPCnI26AgP4E//jVE+PJEJ8t7NzfdUdg5ijRDuZr0MI4JeFh/w4q/8uNJl8HKI7eMeF6dc3LE+JQ9WpAPHvJN9DtLRJUbRGpCI6c8dW8yw/Tr3LybyENfK2J1lArbo/d56zZUmaCI5eFNwFj2e5NoqTI0NXFATPY9OSaeBeFKi00oAqL3uD4Pt1tCgw5PIqy6UKWmxDWXclnxxC0B0vOqxokAKVtssU4r/jRShwnR9YXH6AUzsW6turM8mFMLY8aOiwnq1vacxWxT6axcudI8NojzWpAPn7LY69KlS2vlZfUfLLcOVYT1ods3No50H8uNb5/rte71BatNUhMVOg+Z2MC6wTa27EqJit4khndcsMOLJ58KUTTMYsWYRmyiTNogfCdGj4MOOmjwqle9yt1PD3mSJElSyHuzDQryE/rjPwUUKy3hN+YFnHPcTMPyxNUeQSnPal2mKvl4aVa12bIDBVkUT/V5VUXmUXleW3VptU0IWRN+XL3zne+sbUeqDqxt4vVVBU3WVZ1JkNT+YW3z6s3rnzle9NoDD4X5piZJvHRSk1apiYcmJgyI0aJP92Tpa5bHqCcAarE9AD2B0esUReWUKKbDfYS09QKbOSFRrGNCGpivFY7F2y8UQdYKDWPZUcfbsWp8/Fidor3eWwIxMdT6UWOVOybGDzPJUpcYNz2UB8MfYT3ior5V1jmwyqrbygr1U1UgTk14xCZr0K5UfPrYBICsR6DfSEkt8GrVs7ew67D9Rk+AeGGstM3emMMJl9zxTE+80eOAAw4YnHDCCWN3X67zRgpJkiQZJ+/LNijIN4S+PGR48EQnEapD2dBzVbbF0kuJr03ZmtpnlUG/+ioXipgQnSN8Yj6xOrLStITplB05XsBVJxT0xbNufcfEylQ5tYf8hz/84dpifG5bYJ+oc8NoQqQdhXges6XKuLTazGo3q/yYtp5A0nXv1V1seyxPy2a9iLSXB14r8DjpI8O2FTE69O2e7ImOKY/f8KkFqpzjUWBD792Yhz2mZVHE5TA2ME51irliW8xLOicUiJWWJzzqSYGQT0qgtOLtVw0fkhKEvMIvkaAAAJBzSURBVHpKhdmxKO2v+8GT9/zdoupC8YQPMePFO1484+UzcPvtt3fbKUf4Fq/rVD+w3lbQ5fRCruDzjTeZ4S3Y63mi57ytkPJIF2eAWN+W2P5eepY3vdcPrDdXsO6wHuQ+7ZVZLwobCweEduo1Daoszuu1pUxUEs0hhKi59NJLy/YPseTD91mzZg0uueSSsbsvD7NAMUmSJGmT92YbFOQbQl8eMizEhF/Z7i20mpt+Kq/cNFJeq7G0PaE6QH5kaLGtqn1ynj4/FfICbYl9r4pcUdM6z5uYyJ0wkAtv7uSGZZMW5OsiR3DGcgwze6vbP9V2sXrNOcfbL/mmRGwtTKf6Wiq0DOatz8vp157Ar+330kn1NSuP1FsQuZMTFOO7iz7dk7UAJvG3PRE7Jh5r8SwlfmI6IpynFmTFvGNe3/oBXAt03rE53uAec0XnKj8aqv7QQK91/WaBDu3hhRbS1ydrkdJwHIrPsmimtF2O3ZaYjVyx58Hmdmtx1xDGZsnqg7NCt1Rt11zvbMvTXC+y6y242yRTkyjeWgveNmxLLcZXYU54G+x/+vqj21PEeH18bALM25bTT6uOWUyfaBYnnXTSYNtttx3MnTt3sPnmm5fhaqqI8X26LzNkDUmSZPOkh7wNCvINoS8PGRoxb1LcHsrWhPhUJa2YEJc6JyfdWH6551ri5DCiLB7flBgfyyO2v459enLCEm1THsgoyJ933nnJ8g5zgc/tk15ZMR2xJSb6Yh3k9O8qduIEkSdi60XZUvla4rqVr/yvx4En5MeuQam6sQT5nLqJhd6q+2YEhfnuoW/3ZGvhytyQKB4t0avKopjaBrRFC/neObFtlriYEyYgJfYGe6wwN3V+NEjZJD0MRRLqYJjQBrH48TkTI8OKRrnitMSNTy3m6ompsZjiqTctsH+gSBt7i8NrV6vPSHtWrUPdH70Jp9zwUN42PbFj1VFOiKu6/RTHm9VnQj/Ux4V6tPqmTB7l1ovXTphmqB/r7Qb+8O8e+nJfpiBPkiTZPOuEBZ4EUJCfsIcMz+M1x0O2DjzvXOu4mPir7ayTZ845sfJ7NoXvVpgTLc5XtaPOPstOr83qCM/WPmwTr16siRWvz+n/gyAfRJt//Md/XCdPDR16qEo50ebUcZatujxVQ99Y5c6ZMMmFVzax11p3INdWK01dF/I/5hGLFR9LL2aXJbJXqRuxy+pHuf2iSt7EzKBP92Tdj1KioI7B7Xk668UWhxGMUx6qTXkb5yzAGlhHaJd6wbJoATHHE9d6KyCnXLle69iGeI7VL3Ji6OeUIzXJoQV5S5gPIWvC961W7ZFsY68ec0IBNTkJket9rftc7hsosfAssVA4uWK6TGbl9IlUe+j0cHx57aFD9+Ax1gLMqfrKsVVPvMTCUOk3SIjuoU/35Y033nioaw1JkiQ5nRTkbVCQn8CHDM/jNSbGy/F18kmJjZaohcdqr6Yc0byK2KjP1Z+xY/C7F97FqudUWrFyeeJlk22We5y+wHpex6kyxiZh9t577/L7n/3Zn00rk1WPGBfcEoW9MsTE71h76WOsdHQfTCEm5NcR4aucmxK9MR2vL6f6Nl5nqtZ/yjYv/1Qauu96YXxyJgWIbqFP92Rr8VMtyFYN3VBV/KqyEOQwXL58eTL8hh6HWCexbZ4QKelpL2jP6z8VD7xOvYS28LzdUxMMVeLI54QzScXKzxHiLW6y7c7JY7w6kHZDm/C7J2TnvElQNx5/3cmsYSaqcOzrNPX2VatWVcoL67POWwGpY3X/StWpd01r8rrD+3L30Jf7Mj3kSZIkmyfvyzYoyE/YQ0bKO9faFlsIEdOsIsDmnoterCnEQlKkUEXAt871bPG8xat6KceETi/vXBG/atlRPK57kfXE00MPPbQUGT7wgQ9M64eeOGzVTWxiIiak6gmHnNncVDpVJltQjM9tE6wLq8/hmEjF+PcmHPT/ueMtdc3BY1P5WvVjCel1bcP0+Pp7v9Cne7K+3nihYXLFwipxpkWolhjkdeKmpyj250wqSJx5K9a22JYqnxUGRq5RVSYqRFSUZx+0v4roank/W+0avIvlOUcmEqqKwnW8pr08YuFpwr6dXvmewUZb7Tht+/z589c5turCvl7d6bKF/2NvH2BbYx3E3grw6iunD1vn6vrVE0LamzzXOx6/i00o2Hu0PM2rXmMwrdwJw1HF78f6FPKHf/fQl/tyzkQfSZIkWY38LW2DgvyEPWRoeN6qnoiVIyrq84axy7KzqjjppZdzfMrbtqrIb51jhQ2KpeuJy6l2sbZ5F8WqbZd7vHdcbOFYiSH/nve8p/zuTQqlbPDKGetLsl9+4KbiwccmPar2v9i+nAkvPRZxwkf/KI69caD3i7hvwYoTn6rX3Lq3xmGs/8fOw/2xOrSAnvNE99Gne7L0zZxFVVMeph7DuNcTdTEBT4t8VUS0lMd3SkyPiaRa0G1C2KsTQqPOIpO6zDrPmECdmhyRkEQ6DUs8TXkbB3v0YrNHHnnktP2pePELdtizcn1g/40tuOrZnxu6yIutnhpDUvc4kZC7JkMdz3qdj/QTebsid5LOytvqZ6kQOrl1atGbuBpmzFYNKSXkD//uoS/35VFMTpMkSU46+RvaBgX5CXvIEOgf/fLQqj3QqwraclwdgTbmjZvycE3lmSPix/K0/q8SrxrLZu3XYgymi5MR8pCYmiTIEamrXBiHuYDGhFApt3zXx4og/853vrPWJELK5tz9Vp3HxlHVySO0xesnsZj81vFWfcuP4lAmna53vtXfrbjw2Ie964geS3XqIzUpU/VaELu+xOLM84Gi++jzPbkOcwSE0G9zFlz1WEdUE5E9de4wMaYtG3NF3pBvTOD0hPNU3HUvvr9V1xJ+pGq76rJV8XKOLSaLgvyip+1Xqx3OOuusRtqz6toBoWzeZJPUhdemEi7GiwGvvcpFJI71W2nXnDA0uJCzJULnjlNrgWidhvUGiv4fF0m1+g0u4hrOs+oC+2UsXVlzwctT3qBJ9QuZaCK6h77cl+khT5Ik2TzDfZ5YFxTkJ+whwxOYmhIW5byc/D3RL9eD1fLwxfNzF2q0RHBvn6SbOh5Fylg9erHD9XmxY2KLZaYmA2L1ovMYVpS3PrH/ibgbIIK8LM7llcGyLTWRU8Vur+2s9rXKEROgvUkfSzS22j42gebZK2I81lNsXEioICtMkdWmmDamF6tvy2ZdN2hvbv/0ymql440hbAOiu+jTPTlAC2dalAv9TYtSIn7VeRBGMUyHr0CBq+nwEpaYmCv6iUhYdRFTCcczjL3DxLSWslSN3V6FVdIM7euF92iCOnxNnbKG+4w+r4lJmtwQTlZeVcI4SV/GNxdS9YF9BPfpBU1HRT2OcGJgmDpteuKuaugjTpx3D325L9NDniRJslnOnTu37Ut7Z0FBfsIeMgSeIKW9lUN5LMEtll6uOKZFrdwY5JZIicKnDHpdDu1Vm/JwzbE/JRLq8/WEANZnrHy6bvR5lmBpCaEYQkTqSueTEoIxj5iwmvPDx5o80OfidhHk//Iv/zKaT0pMHmZCwRLksR6EUr/WwqC6/jHtHHEZj8F0Mb9UbHgrbbQR20X2exN2w4RASonguo6tRZJzx1RMWE+lGRu7RPfQp3tyzBvPE6hiIl3dxShzxNQmxTgRHOV7jgiSKpsXczvXy9qq77qCaFOitxeyA2OP6zLWCa8zCmIbV2UqFA+2a25bpeonlY63X/cfyxu9bpmr1HfViatRUF8nrEnEqmPD876XdHR6cizv191DX+7L9JAnSZJsnnRqs0FBfsIeMnJEbkuQignZVRdRzRWCdVrWcZ6Xro6JqvOxxFUvz5gop49BsdoS7bSAWCfkhVdPOk1MX1/49EQEhvyw6hPzRrux/aoI3jh54O0P2HvvvcsfWW9605um2WK1SSx/PWmTeyPw2jS2OK+uX8uT3eq/uo2sOrDs0nVvTbJgn8TzPXjCvhbCsb9Z+1J1ibZYk1VeH9Pjt8p1RiP2xopln9V+eBx/+HcPfbonS19FkQo92PW2qgJ5rgAW89TV23KFxiqe5lJOfawOF+LlqevHWxi2SplHIWBa9e+1SaqtZH+sTvFZACc7ckKJbLLtztM+qxLzyO2DeJzuA9YbFN6bENaiozlt64n1Tb01UmVSS4616m7FihW1bag7nr1zrPNXrlyZ7BOebaH/ojd86lzdbvpNQKI76Mt9mR7yJEmSzZP3ZhsU5CfsIUPDE3lRVEuJbda+mNClv8fELEzbE6NlkKPYaaWds80Tz62JBG+/rkvZ5tkUQ0qojYVIQYE1px2tuJso/uptumwx2628YoKx2Bp+jL7uda8zhdCcetJljpXfss8aG952K+STV1calrd3CrH+hv3WE7m99PBYLK8VYsgaK1694PiRH9yy4KRlF9ZjTj1pe/Wn5BseCHAiBM/H64sVisfrE0T76NM9GcdbE6IwxiW3PEwlDx0WI5ZvFU/xVNx0K5a7XAuqljV2jg4l4nnP47F6IiQnTEbMYzuXkkZKtPaEIsw3d4FUjzp2fIglv2S3Q8zQNIHL1rywVpljbHpSpO7bCsO+EVL17QppNyx/FYGwqpiYGhd1yzLKOov1D9nHe3L30Jf7cpXQSCRJkmSaS5cubfvS3llQkJ+whwyEJRBa4pMXg90T9fU2FLBix6FtMog9z1UtnFmx1XO9aPWxnshoCfQxcVPS1aKrV15PnPbKrhHzureEec9m/WaBBsZIx7y9xWhjtnt26HP22GOP8kf0H/3RH5n9B8/F/oBp5tZnzD5ruxZ9sW0x/9jEgf5M2abPQyHdEpNj5bf6eqy8Xp+yxrzu/5adAVo8sPL3JlCsN2Ry3lpAz9FYPeuJnFjb8Yd/99C3e3KOYKpFdhEKMUyJJWZZInFK8KwqYHoLk2p7RGyMxc2OhWep+vAvacVE9VyhGutVzhs2NEzVek5NWNSpp6OOOmodcT2I8NaxKMbPNOsI69JGVdsqtPEohDndl3JFbi80UZU2D+XJmRzLYZ03UKTtPHu9tvXsTpELu3YPfbkvM2QNSZJks5w3b17bl/bOgoL8hD1kpCAP2Rjjvaqo6Ql7Om0U6HQeepssKInH6fQt7+dcr20MaYI26nxjIqCVFwp3Vj1aYqYn2mPZveOtOsRyWHmjeKlFeu+NAZ2+V9feRI9lb+Ctt95a/jgLPPnkk92+h3ZYfSE2KWClFzsWBXMvRA3WMean/7eEY2s8eGnosmObo1gcGxM5bw5gfccWS9Zieqq/63KLLbps3ls7GH7GGwfW2x3WZIOVR44nPQX57qFP92Qcy1W9ckVoHMWioVU8aGO0bKtib44A6KU3jJjfBoeNPW+JvFZ5cvrZKAX4uv11FIuK1mXVNzp02+pzZdKo6TcDQl/IieNf9c2OYG9X1inwyPty99CX+zJD1pAkSTZPTpTboCA/YQ8ZMejwESlhOBeegOiFWvG80vU2S4yXY718cVvMPkv80/miAOyJcqkJAfwf6ygmcOo80A7PI9ir01iIIklPi8Q46ZESclE8RTHUKoP8QAw/Xk866SSzzrBuvDRz20B/t9rUs9O6uegf2pbnvLYZ2wrLg+3k9Ru0E/tRzNM7Z3ICxyBOIHjneOPHmkCwrg1e/9KTTLHx64133GfZn/J+T4n6RHvosyAfi8GsOdOCWBD1UKiwBMlglxeLfibtTYmOdQXhXBG2SnktER7fOsD2zrUD09bpPP/5zx9sscUW2XYu2GHPdULYBOL3puplVMwdO7qPeG+BaNYJWTSs+Iftm2Nnk/lVYd2QTlUmZcQ+/vDvHvpyX25jIWSSJMlxJ+/LNijIT9hDhgUU7MKPA08YrirGi3AXgAuv6QFqCWoxT1ZL4Lf2xbyldZlz98sxWDfeeVKXOXUl+VjhQKxJAM/rXC542j5LpIxNJnjCa+xtCaucKK7qNvGE7bDtkksumfKQP/7445P1p8sfs8cKr2Odj//rOtP/W6GSJA+JU271Uauu5X/rTQSvH8b6PU4EeP3YEp69/ox1i978WC5s61T62O+9+vImXFJvYui8Y/3F66toh9eXiPYxDoK8iGuWeJgS6zFuo6SFYlZVUR9F4CCuatEyR6yL5an3YVqWmOctbBkEFUtwR6El2F9VJJR064iLlhjdtsf38uXLy88gtItH/PqLtiw/5yzYfJ3jZZHXcPwGy560Tsz5uoyJYFjXMzlZ1URasXGh09f9I2cdiGGuCzm2aY7qDZxRkYvHdQ99uS/TQ54kSbJ58jezDQryE/aQEROltCgWC1GS8hjVxwrl4UYL1FbMcut8T3T0xEv5jhMN2m4t2HkhdASefbF68CYcrPpCO9FTWJcV2wlFV6sMMW9xLKtlm9jkCZdY73qf1X5WGla4FvGQP/bYY5O26nr3jtX164nD6P1vCbP4BgHaLeWxBHWvj+n60mMC08B2wbxj3ure9pxwQno/lsXKE8dhTPzW9sWEdJ039issiz439gYH2odhc7C+0X6vPET7GBdBHhkTgXMEbHLm2ISA2WZYkLlLtmklX8vDO/RtEewtATkmVscmXZoeI564je0ok2SBo/TG9fqgtifkX2cx5VR+uf1fjmu6HuiJ1z305b6Mv+FIkiTJ4cn7sg0K8hP2kBFgiUtakMLQIvq8mNiHIpwMPNnmeZlrWzBdzyPbE9f1d0wL08Ryii1aoLSEWEtM1LbotGQCwpo4sOJf4wXLEgy17SgOe8IoitCW7dZ5Wii16l6XW+zA7bnQ7fid73xnykP+BS94wbQ8cOJB11OqrVA4z/1f8rAmSVDEx/qzbIzZh21q9VMrnAu+jYDbLRFZ0sAbZGwyQfdRPWastC0bPMHfC2mkbdLj0tqH5U9NRuk3WfT1yKozL81UHkQ76NM92frxLyLV4sWLh34A9kRdESNjoqQWyeouruilb3m3Dxs/faZZpz7qrhEwTF1XEbDDwq4SgiaEqMlJTzzltQd94Pz582ekHSzPcCyjtShybh3h4smjLk/Iw8pHrgsz+VaFNyatPpQ7HmL91Hvrpeq1gffk7qEv9+WmJqhIkiTJ35P3ZRsU5CfsIUPgiarefs9jVQthlggngp4nsFnioc4fBdGYSIefVhgOsRM9kCVv2e95P8fS1HmjWGml5S1YKw+CWG5dx5awG6tjnb/XplVE2NTkiiW85kDSv/TSS6cE+Wc961nriLGYl1c3Vr+xRHa9z6sbbzIkdg7CSsNqD6x3fKMDz8X0sW6sRX3xJhkTufEtERGw5U0afTyWDW3AusEypa41lgBujU/cZk1+hP1YFryWeWPcKxvRDfTpnqzvF3XjQMt9Q3uleqJXTGxAMUzsQDFMi3GegJbDVDmDKGkJf1XFuZSA6dVJlUmIJmOjS9uNQvxNtVcQ5APbWuw1VpcYIqmpdHNYd7JoJsXz3AmZUfSrJifT9ERkaLM6cfGrOIQQM4O+3JcpyJMkSTZP/l62QUF+wh4yLKREMP0/CoiaWvjyXvezhGMZnHKOPAh5YUIQ2lNVxHbMU9trCak6HAfWC5ZX24GTCigYe0IqxjL3wvigGIj1ruvPEoR1nXtCpj7WE+9FtLTEerTJ2x/rVyjyXn/99eWPO/lxecstt6xT/57Ijn0C+x7+j+1k1Z0+Tr5re2M2YNllEgbtso71PMu1sI+wxGRr7Ek6VngqnT/2VR1+Cs/xJhy8iSOvPb3JQX2N8QR5a8xb1wLLTqvdMG28BsXWJSDaQ5/uyTnxasP1MCXsNSkItxkqJYcomNSJnT1qm5DSfgsXLsyu56rtEOsDoZ8NM3nicu7GlUX7lHiL5ZY497lMlXPevHmuTV47WhNnM8GqZW9ycVd5BrNs6IJoGetHFOS7h77clxlDniRJsnlSkLdBQX7CHjIQVlgM2Y4ClBaLUeSyfqhowVK2oeCLC2DqhyAtdut0LfESJwDQQ94S1VCsw/A6uuxeaBC0Swt9KQ9my2sZ87LaAutHn2uJnZZI7PUFq36w3SWdlKcybkuJ3boffOELX5iKIR9EjCDQazuxPFYeum/r7fpmoPumN0liCbG6biyh3xKIrckKPZa8tvHazxKTrfNwHGG/030Jy6frRvcFWSwNz9F1ZU0mxMI0WV7nsYkRvF6lyoELLHuTINifcCLEKy/RLfTpnjys0DeseD6TizWOWjivMylR5xyps5gg2MZirTFvfq+fWAu3zt5ks+xjNXW4mrpMifXYXrH+nxKlR9Efg311vcVjHu5eWdpaFLjKdWOmJvh0XfCHf/fQl/tyFyabSJIkx410XrNBQX7CHjI0UABG0dAKz6G9YoX6wUUEVRSOMT60FtC0CK9FehTZLIHPEuy9Aa9tRsENPW91Wp4grWl5wot9Vr2jnZZ4jMdivWM7Sv5WHWmbY+dpG7AOUJjU9W/VM27zbJS2xX6DP0B1W+NbHdbbFLrtdB/E88N2z1PammDQZcAJLRwf1kSKpCXH6rKn6hHr06p/3W88MVy3J9al/t8SCmWyKSZaa/vQJuvtBqx/HHNIXQdVy4FvQ8T6KY53TJsPGN1Fn+7J1j2sSY/Xpr2wR8k6saVzzx+WufVUpZ2CqNkFb8yU0J4bP976PrV9gw1aE4WDQI7t14QHeZfCvjQRxgnrs+nxNJN1zony7qEv9+W23oYhSZIcZ4pDHzEdFOQn7CFD4Hn9yjb0pBWxS3uZajEdPZa0wG15Xcv5aI8lfHkeqlYYDDxGQ6cj51tpoTiPkwYoAEu6KLDq47G8aKcl8KHYq9OSc7y6tNpZt43lWe/lH/OctsKWYD1b9uqJF6GIr2HfGWecMe0HHE7SWP0DBXv5rssb0pGbQWzyBPug15+sutDp63JZb2DIeEIbrP7j2RYbx1Y/0HXpjRtsf32efvMF2x3z1/Z7+XrithblY2MJ88bJMYH1pk6s33rfMX2K8d1En+7JOBE5LGX9DWv7sGnPlHg/SmE9xra8jWfaxg033LD1cnhM9VP9FkAb/aTrfSQnxE2sDE3Ggh91WmFb+P1hXZcoyHcPfbkv506SkyRJkvkMz2/EuqAgP2EPGRooqAWgQKaFOfkRFDzitVglHvLa01j2WWKp7JP8LHELhVAU5nG7FnolPwuW2IYirj4fRTzLS9t6cEORMyX2yTYRaFHoRQETRVwsC4r1KO57Aqy1yCz2EUlDx/rPmShBey2xWs57xzveUf7/1F12Lz+/+tWvrtM3YsIpClxiI4ZRQqFc14fVT7EPYXlxgsKadLD6qa5D7F+yH/PEslo2anh9Gu3z3kSIefvjGPNEd+vti3CsXFvwFXMU5WPl9fqYrkfr7RtJ03tLwWtrb3wQ3cAkC/J9oOXtPpPes1ZolyZi8Dcl1nbOe3v23KHTmDt3biMiutSNXvhzFEy1gZf/0qVLs/MIfa5v4TH0GgixumpSjK9DeuJ1D325L3fhrSWSJMlxI+/LNijIT9hDhsASx2U7esgHiFBlLbiKaaFYqtPHkB46LZ2GJ6xbEwh6kGM6VrktMQ09k7EetIewJTJK/lroxjcDdLpWWawFXbXXvTVRgpMIYhfaqsuBbRvrC942SQPbyprc8PoFtq3lBf/0NQeWP97/3//7f9P6Ik48aKHb6xPWZFGq7F5oFxSFsT/rNLSnPn636tnzLNd9wfqMCcMobFuhdTB0VGxCwBujOAFhTQRpwd6aONHt7LUXCv6YtmWLtdAsTg5Y9WitLeDVC9Ed9OmebPXDOpxJAWxY4bkJz+ZhbLBEU52eJ86nxFbrPAkDUkdk1zZVeTth2PaRWPBzl2zTeN953vOe5+6z6igVqqiJyYsqkzFVBHfkTC4+POq1IXS75E4qzOQ1ivfl7qEv9+WZXFeFJElyUsg312xQkJ+whwwBCqSyTQZMbMFILWjpcy3xHMVjz+Nb8kKRVM7H9K2FOuV4FLH1OTpNSzjXZUbB27qYWMKcTguFT0t0x7rHMst3y1ZsK/3DCEOnyDGWwCjpWBMeVvtjXWD5UQzVbe1djPHc8CN790OOKoWbyy+/fFreVjgT7f1uiften8bJpVSdWRM61jasF+yD1qK+nqiPYrkWta2xrCF5ikcolgfrCL3YU9cCTMcL72RNKmE+2BfwjQNsfxzLXrtbk1Y6HctmnZ6e0cdy5kyIEDOPcfeQb0LYG0ZY1Jw/f36t88K1vevhP8aJOTH422RsQdpReMR3se/lhJvJGbcySZGT3qg40+GEUETlq/HdQ1/uy028LUWSJElOJxdbt0FBfsIeMgIs0Q89X1Oew55QZomdllCn00bh3BIu5X8tJur8Rey2hI2wDz2lUTjXoTp0/lrgs4RZC5Yduk4tIQ8FQhSaLSHY8kK3hHBdP5bteJ5XLpwkwJjg+CaBFj+xPlB8DcD+ob3e3ve+903LA9PDWOyShyVGexNR3oQMTljoyRV9PqaLkydW/7e8571xZYnoVggWXadimw4rpesOJ6+wT3r9ybuWWJMFKOhbk2t6jOljMG0cG7qNLZEe08O2xuN1nWBoJpxAkGN1fRPdQR/vyX1ZeLVNEb9LlHvUKL0pc72/UfysI4Z6i7HGOHuTzRora5UJoqbC3pD1Oapr0rAThTLxFO7dRLfQl/syQ9aQJEk2T4assUFBfsIeMgQxT9PwPwq9Ai1uYzxsPF6L9pYHKwqLOEEgA9caxFboG/09JgZbgqYnnGvhVXvLel6xlhDvxa3GyQi013ogtMKX6PPQMxiFWbTZm8DQsIRIb/JD79fni63Yr6x2xjbBH87owa3rQvZZdZdaQDV8el7PaBOWEyeisJ+jhzvGasf+j33Kaj8cL9jWOJ61jVhWfZ4V1x8nzaw+hP3EEv5xUknXF45Jq0xhn341Xk804LjHOtBpY/tY10VrMkFsxbohuoc+3ZO960uXY0Y3xfXXX39kaadEW/EenklP6Y033rj19myTcxZsPrFvAEwqMUxNk9eT2BinJ1730Jf7ctfvySRJkn0k31yzQUF+wh4yNFAA0/Hh0fM1QItt2ltYDzTxSLHidet09P+WN7wnpMXSQfFUC5Xhu55IEFFU6sHLV5fLurBg2bDslhe5VW8oIurzPK9mnPCQ471Y+ugxjO2p6wfrDicRdPqW6Ky3x7y+rTcXAuV10VWHvaL8MadfZUcPdrnAY/1YfdvrVzjxI22AHti6HixxV5dPtmGdaFtibaX7NnqLa1hjFcV+3R7eOTEvXes4ayxiunoyDoV//K7rHO3FekWPVOv6gBMZXnthGXDiCOtVb4+1C9Eu+nRPjo29LrOLcXbp+TxzrONRP2xIGn1MKsTNOLCJyaLgyT6Tseu7QnridQ99uS/TQ54kSbJ5cqLcBgX5CXvIQIhoJSKhCOpaSNNimxaWw/F6mxYaA1B8tjyvZbsWqy3RGgVhbZcuB3q4hv+1IGx5xOv/0ZvbOh4FWiyblWbMS9/zcrdCbOB+8dbXdYD2ok0oTOp2s0KUYLtJ3eu2EHghZfA4a9JD1+dLX/rS0vNpr1f+jfmDVE8eoMe0ZwcK0rG3GZB6sgrLq+3RbYjtpwX4MOEg+Usb4oQHvglghfnx+pvXZ3SbYr9FD/NYuBpdPt1HvMk3zA+96q26tzz49XXGC4GF+eHEoyWi621Yl1gmDNeF1z2iG+jTPdm6HjbJpmNvt7FA4zjEByf7Fxapq/2oq3Z1iQxZ0z305b78yU9+svX+S5IkOW781Kc+1fblvZOgID9hDxk5IoDlje15aOd6nep42ygSe17plmiNNuC5IiTq/NHTVot66B2vj9flQg9cFPBQkJRz8FidnhxvicBYXyh+W2EztG0okkqanve25V2NIW+8/mNNOqCYafUL3ZYYdib8v8++awY7v/yt69RL6mKPb2dgH/a8z7EM8taAJUxbkx+6fjHuuCbaibHo0UtcC+qevfocrHfcpvupbm9dPuv64E0uYXliojiOfW9iBic6UJzXIj2usSD79bFeX7XGq3WNwmNlv9jJV/C6hz7dk/l6fHVOosfvTLPJ+PCj4nrrrddKvqMMPdTmQqzjRHridQ99uS/feuutrfdfkiTJcSPfXLNBQX7CHjIEKFBpAQw9T7WnrhxnrUAvYioKciiq6XS0WCavv8snCpiWF60WvS3hDePd67JrAdUSJTH0DArLKDajAGlNFqAoj4IkxhrHOkYBUc6xvKK1nWiD5TUdgBMQOk19Lrat1T5Wmho6Pcwz8KlPXz14+h/99VRcWH2s7lNhm/6u6wcFVJxAiXmU43fdB8J27Zlv1RtOyOg8MJ49Cv96nQJ9HoZzsW52uu9aIr3up/iWhOSL9Rwb6zodPTGE6xzE/vfKgNcmr2/rcnnXGbRT92ldLu+6hUK+5O+9PUG0iz7dk0ftIU92k12LeR5C0Gy01Y7u/vUXbdm6jePCYRcuJdMMvyWIbqFP9+XNNuv+hCRJkmSfyLfJbVCQn8CHDBQsUSgWBqFJi80okGOoDUuMtYQ9mR3T4pcI/DomrRY0URzTYigKe1gOSRvLqEVOLKPleYzCGwrdKJTrfFB41kIpCr2p43WdY96WuKjT8by6dVvpuvIEcxSPUQCWOrXC4mA/1GlKWXbaaafBns8+ZGrfwQcfnBRydfugzZbXNk4KybaYOGbVoTdRgHXqtY8nemMYKQyVZI0vLeR7C+Wid7oXhxcnu7CNsC2sfiD1gP0Qx5ElumM96PLofmSNR22/eK/resHrj643fZ3QdYN2Yz3yIaNb6NM9eSYF+TaEQHr8doezNhg+jMu4c+7cua3bQA5PeuJ1D325L3vOIiRJkmR9MpScDQryE/aQERMAtGgnIpgWKLVgrUVBAW5HodsSdLXIJhMAWgizxELL417nrR+krMVYLdHP8thHb1rZJmXSwp0lfss5lkCKnuY48SFlQnssr2PdLlLvlqCpbbQmDSwPYk0Rj71JGKxrb2IC+yBOrvz4xz8u/3/6mgPLzxUrthucfPLJ60yYiD1a1NbezNYEUUDIT0+eeGNB17slpGNYGt1m0pZWP0VPa6x3mYCx+qfVh6wxq9vQmniw3l7ARY+x3tDbXh+D/cCaIMAxgpMkVt1j//EmWHCc6MkMtEPXje47Og2cBNTjA6+f+q0Aojvo2z05rJmBfb6rHrZNxOYmyT6xa28zkGnyh3/30Kf78pw5c1rvwyRJkuNE/l62QUF+Ah8yBJbArgcMipIoOsr/6B0e/hch3RMWdT4ixFsCpnzXIiUK0Vqow0mAAFz00wovYn3XQpsWgWMiaLBVL4zr2aDLb9UlirpWvQWgSGkJt/LdEj6tC6X2ILYmKNALHNPRC83q9teCL9aj3n/JJZeUC5Y94wXHD5583FvKbXvttdc6Nks9Sl/zwv3ofiNvS2iRVaerJ4B0GpgHTi7hpIgAxWh8IwHr1uqTVggpq+1wn46tjmlre6zJB5wosibTsLxaxLbssmzQdWQJ8bo99FjUwLdmrFBCKKDjBJQei7rN9GSWNW5wgoDoDvp0T55JD3mSJLsfR54cnlzbpXvoy33Ze5YlSZIk61N0OqJDgvyll146OPLIIwdbbvm7uJSf//znp+1/4oknBm9961sHW2yxxWCDDTYYHHTQQYMf/ehH0465++67By996UtLj61NN910cNJJJw3uv//+acdce+21g/32228wb968wdZbbz3427/923VsCR1kxx13LI95+tOfPrjwwgvH8iFDoMU0S2hH71vZ5h2D4pY8DFsityVsokeqdYz873nDo/e4Lpv22hVKWTAkhvamRW9gXQ5MTwuBWgzF8C66LLpOUTDXIi9OeOiyoc0oKkva1nY8HkVuXZ+6LLrOxBYUj3UdWt7w2J5Yx7sf+uLB7n/+icGOu+4xbbvuF2InvtFhTShgvmijFt29yRcUt7HNsc/osaWPxVAoWgC3xh96eGN7oZc2xltP/biwxgDWle6X1hsyUudyjm4nS8TW5bU89a1rD8I6Vte1fisD29S7zliTiN550veJ7qFP92QK8iQ53sQ3Wuh9O3oyZE330Jf7suf0QpIkSdYnJ8o7KMh/+ctfHvzFX/zF4F//9V9NQf5d73pXKbJ/4QtfKEX15z//+YPtt99+8OCDD04dc9hhhw123XXXwX/8x3+UP2p32GGHwUte8pKp/eGmv2zZssHLXvaywfXXXz/49Kc/Pdhwww0HH/7wh6eO+da3vjWYPXv24O/+7u8GP/jBDwZ/+Zd/OVh//fUH11133dg9ZKCQqz2xcV9KTENP1ABLWNd5ofAgHtmWh7IVSgKZ8r4PwO061IgWVnXZPU9zLU6jR78WnbEedbqeJ7En3uu80INee8hrSp3KMfpCqNPDiQD05Pc8uFGwtexG73BcRwDTlv8/85nPlOEb1hzz6lKQ3++5Rw122WUX016rjXTeug+IDVYIldjipXi8dXPBNsb+ImnoxZB1/eKEhzchJuXFeO04wabLZE2i6Pwsz3KdrvRZ/R3Lp8eZnmCwPP7x+oMTHzntqfu11Iccp/djH8P2lLJhfev+qo+3xqy+fhLdQZ/uyfzxT5Ik2Sz5w7976Mt9mfdkkiTJ5slQch0PWYOCfPCOD57x7373u6e23XPPPaUHexDVA4J4Hs676qqrpo656KKLBrNmzRr8/Oc/L79/6EMfGixatGjw8MMPTx3zpje9qfSGF7z4xS8eHHHEEdPsCYLgn/7pn47dQ0YAimU6/Inst0RK7wFFBheeo72EtejmiY5WvHiM042hJ1Do1R7hcjwKvlJGFFfRA1Z7XWNZ9PFyrBbKpT4soRrj5uP+mOhnvRFgvZ2AbabFWbFNyiBpW/lrb2HL0zg2gWDZpQVpFOV1fYbxt/rIPyoF+T0Oev5UfGUUxbUN1oKm1sSJ55GPbaRt033WemNCC7u4PcCrB+tNFczfCpsi2zFPPMaa+LDy9N4KwD6r04r1XczDe0vEslnXM6Yj9lliO7aPNynmjTVrshHD+eB413VIUb5b6NM9uYnX49uMKU92gwt22LN1G0iyada9tvHV+O6hL/dlCvIkSZLNU+tkRA8EeVnY8Xvf+96045797GcP/sf/+B/l///0T/80WLhw4bT9jz76aOntHrzuA44//vjBC17wgmnHfP3rXy/T/tWvflV+32abbQbve9/7ph1z5plnll65Hh566KHygUK4du3aXjxkeIK89m5FAVsfhyFNdExuHHSeiK0FrJRgKzboSQNP/MRz9Hb0DtZ1YXnAosiX8gq2yo3brXjzWnSV8mmPZf2DQouDOPERYIVEQcHaqhtLnNX2SjvJMbotAzBUkDXZoe09+uijze1Stg984ANTArzEkA8x5WPnaLFdi8iWLdZCvzntbuWh207q0VrEVc5HEVugx4Vef8FKy3pjBcV2b5JKjxsc9zg+tQc/fuo+YgnVlhiPZdfjAe3V4zM21rx1DKx+Ltus8SB56okG3T56XQWdFr6xQnQHffnhHxCbPKrCxYsXN5IO2Ty5EC5Jzix5X+4e+nJfbuqeTJIkSf6enCjvmSAfwsiEbbfffvu044455pjSoz3gb/7mbwZPecpT1klr8803Lz3jAw455JDBq171qmn7b7jhhjLt4GEfEMLTfOpTn5p2zLnnnlt6ZXg466yzzI7W9YcMgSU+Wx6veh967Fqe7TGxVQQsDJHhpYdCnSewWV7wmD+K/VboC/TWRrFS24PhRXTaeB7S8uoO8ERsa0IAvbatCQBMKwDjYYudGErEqjcdY92Lv+2J/lZ7WG0ZPk877bTBqlWryv+3O/KUweojT5gS6K1602JqrjCL7YF16k1Q6XKE+rDeptDfrbc49HoGOvRM7I0U/YqXbJfwQ+gtLn3JGhN6jOFkg/7xiuMOhX4sE/ZP/YljXB+LE0dafPe86sV23f+1zRg/PtbXtJ0YrknqEes29SYL0Q305Yd/QGySkCRJkqzO/fffv+1LO9HT+zI95EmSJJsnBXkbFORrCvJ99pAPQLFKi1ueOCsiGApYWmS3xKqYEIsimmzDhyH0Dvc827FcKHTIhIEWGWP5akHaCmNhhRbRtmixVe/X4X3wLQIrHZ2HJYRKXrG61mXTgipOjIiXsD5e6uDwww93FybVYrQOaWOJTVLXVuibwBUrVkx5yK/+w1dPC1mD+WLZMFZ96uZgLfirbcLQRQFWmbB9sVwx0Q0nOKzwTdLvrLFpha3x3tSI2YBj3BoH+s0DS/zWfdIS4qUetde5hiXY635p9f0c4R1t157tsRA21psEWEd8wOge+vLDX7B8+fLssUqSJEnGGZ5XiW6hL/dlCvIkSZLNk85rPRPkux6ypq8PGQHoCY7icCz0hfyvPaG9RRhRsNLewpaYHvOO1+nIeSjqaU9z9A7WZdX2S37asz9GLTZjXYhNKBp6MeMtkQ/rQadthX2xxGyr7tATW4u6Od6ZVrgiPB/T8SZZULjW9mvBf+v9j536X4eskTSw3rWnPwrUUmaczPDKLn1Jyqonn1AU12WzBHivHvTEh/fwb/UJXPjYmoTyYvhb9WfVA37Xb4DgmJUx6K1DoNPU41vqU8YvXp8wZBWOBR06CevWq0McU1ZYIew/+i0ESSvUh86X6B76dE/W44skSbJrDGtztW1DVYbrKtEt9OW+3MS6LiRJkuR0UpDv6aKu73nPe6a2hRu4tajrd7/73alj/u3f/s1c1PWRRx6ZOuaMM85YZ1HXI488cpo9a9asGftFXZEi5IX/tUioPWO18K2FdRQJA1AIw/jjko9OW471PIuthyQUeL1zYsKn52UbE5LRezclSKIYjF7RWB4Ul8V+K9wGer9jLHUsN4ZoQepwLJI+CvIY4kOO057RIrB7b05oGyXdMPbC51YHvmzqWAlhE9LVYqiXtn7rQAvg2C+tyQxMV7ez9yaIF15I75NxZIn3Xl+XMlge8zFa4W8wzIt3rJ4M0scF+7049nhNserMsg/fdNH/a1t1P8H1ILSNum9q0V9P2GBb69BHenLBqx9r8o4PGN1Dn+7JFORJkiSbpQ71R3QDfbkv00OeJEmyeYbf6UTHBPn777+/9IAPDI303ve+t/z/P//zP8v973rXu0oP+C9+8YuD73//+6Wn+/bbbz948MEHp9I47LDDBrvtttvgyiuvHFx++eWDJz/5yYOXvOQlU/vvueeewbJly0pP+euvv37wmc98ZrDRRhsNPvzhD08LjzNnzpxS/L/xxhvL+PAhjM111103dg8ZKDaJMKxDT1gPIihCpWK7WyKz9rIWAULy0wKq9jS3QnRo714t/KXC1WhiiJXwqcNwYEgKTzzXZcP0LRu8MC56YkIfa9UvCsyWR3gqbZyk0OWLhTmJCUc4gaDbRoemwfLExOatDnz5YMcXnFrGAg2TZti2OCmCoq62B9+msOoHxXI9LlIeM9JfU2FixCZd59jusUkD/ZYGxlbXb43E1jXA8E+e0BybsNBtKZ/Ylt6PGh2zHic5qoSg0W1tjXf9Jg32+wDrDYNQBj2xp73npW4xpBOG3SHaR5/uyYwhT5Ik2Sz59lr30Jf7Mu/JJEmSzZMhXjsoyP/7v/+72VgnnHDClJf8W9/61lJQD57xBx100OCmm26alsbdd99dCvCbbLLJYMGCBaUIFYR+jWuvvXaw3377lWlstdVWpdCPCB0kxKOfO3fuYKeddhpceOGFY/mQIcgRvUTQQ6HOEpktsdITWnV6lsCG3qmW1yzaq0NfWOfGFqzVFwj9hoB8t8RbS3j0xEor9jyei17JemIC89TexSI26skOy0Yrby9MiZ4Y0WJ97gMqTiTghAWG9dFlCuc+85nPHOyz7zNKMT5s2/GFr52KIa896b2+hm2hPcwtT3bLFgwtpPsFTl5giCBLUMeQKzgW0DM/QM7Tojf2XfmUdDA9HQIIBWQRkfX2MPGBfdaz3Wpr3RbinRbzNLIm9nDCygpdo8PIeKF5LM99b/zn2KX36euNDn1DdAd9uifz9XiSJMlmGZ4biebwzne+c7DnnnuWv7fDWm3BSe6HP/zhWN6XU441JEmSZHVyorzjIWv6jr48ZARoj0+M1+xRRNXYcVoUtcKaeAI9eq9qL3Lt0YsLaqIImwpn43l/y+szmL6exYuFdxH7qsRX92zU5cd28YRKrEsRKC0xUocf8tKw3koQO7EerNAoci4KuVpE9epEjl/55KeWn9sdecq0GPKxvD3iBBCGKIn1TYwdH3tI15Mp0p+s8DReX7K84mMe5t5EiXjqe97kVognPdGBb0FYMf+1fbE6sbz70TY9wRQL3+SlqwV29JSPTbpIP7UWCbbyxjcZpJ3R657oBvp0T+aPf5IkyWbJGPLN4tBDDx2cf/755dvm11xzzeC5z33uYMWKFYMHHnhgLO/Lixcvbr0PkyRJjhMpyNugIN8Q+vSQ4cVHtkQ8K064FW4lx9tUBFARNq3wJzGRWdKI5Z0SVr0Y4Cjyi22xhTE9Ic+zxVrcU3tYe6KvlDFWx5a47S3MaXkuxyYS9GKcaJc1uSPpimApx2GoJPnE0DY777xz+f+Tj3vL73j0G0vP7UMOOaRMz5qUELFUxwrX5dN9LTaxpD3KvTc5MH0d6kZ7S3tvZwRYEzgoJGNIF0nfm8jAcuFxVl9OCepen8IY7/iWjNSJbhOdZwB6qntvbFh9H7dhyBgddgZD4ViTUfptB6uf6/4sfVm3Ix8wuoe+3pNJkiTJ4RmeG4nR4a677irr+dJLLx27+zJD1pAkSTZPOq/ZoCDfEPrykCHQYpknjOlQIyhYi3Apx1gipxXDWoix5EO6VogX9H7VC2TqsC5VYp1jLHEUm0WIFW/e1MUl9eCG6XgTEVZ4HM+TXfZZAqIWkmURVP1dym7Zr4V1K6a4PscT2YXYNrhGgFX+sI6EbJOQNdpj3gslYk20iGgr9RTzOscwNboPSFm8MDu4HoIeJxhuRU+6WGsPeHnoMWDZLvnLfhx7WuDHSTi9TY8zjJ+vJyDkGpIKg4R9yusrQlwcWo8dr8+LPXoCCPPQx3j1i2XQeUv/1P1Xh9Iiuoc+3ZOrLtpMkiRJxhl+pxCjw80331zWc2y9tYceeqi8BwvXrl3bi/syJ8lJkiSbJxdbt0FBfgJ//Fuinidgi+jmPZygl6rneS7paw9k6xxL0EOxQtLQ4VesEC+WKGrZLd8xJIxVR7F41XpSAe32BJeYEKM92r36kZjf4Vj0No/Face8JGSJ9my2bNKe6FJua1FZFC3lXPRattowvAK7wz4HT8t3m5Wrys+w4LLON6cPWyFXsDxe3/PeqMDY9NI3rHaPeV9jTHxPcNbtJkKxZ7vUg3zGwvygWK4XTMb60Z7ierxZcfS1Tda6EFY76Qkg3ZZigxbAsR3wDRrdR/WkVupNHpwUjE3sYf5Et9Cne7Jcx0mSJMlmyB/+o8Pjjz8+OOKII8o1n2KQZ3Zk1+/LXNeFJEmyedJD3gYF+Qn88W8JhynxSUQ4LVB63uMiyIpoGvOGRdFW0va87XUoCssD3wpvoQU5Lw44ipASqsW6kOR4xVtiuldn6MGOkwro0Rx7UMRjdRtL2XW4oJSIjZMaVj7oKW2J5TE7JY+YWCpCvdUWaIukp/sKhizCvm+teYBtiJMI2Hd1H42VA+sY21m3Sfg/FnPfo17c1VsnAtseJ3Owv+rJl4DY+MC2tvqsbievj3h56DGNsfp1eXEywBs/sWsfjkGpHz3hIP2B6A76dE+mhzxJkmSzXLVqVduX9rHFySefPNh2221Lj/cY+uohz3VdSJIkm6es20hMBwX5CfzxH6A9a/HBwxIrrRjQsg1jbaO3ak58c8xX0kaPeo+x0BPesRjKRC8i66WjBXMrz3A+it2SjzU54b05kHNBS5UzRd1uIpp6wmQqNj/WgQ7dor0/rQkC7IfhR5Qcs2S3Q6b+l+2xUDpW2ByvrdDWGHEixhOLpR332WefZJpezHQhes1KmBuctMG+pCcX9Fi0JjB0O4RjcSIKPd+9vu8tvqrp1ZlX39ojXsR13X9w4kLy0G8uYL1aE3KxdrAWXLbqj2J899CnezLj1ZIkSTbL5cuXt31pH0uceuqpg6233npw6623ju19mR7yJEmSzZNhXm1QkG8IfXnIsDzkY4tcWtSLG1oex16sbvFYRmHaWzQ0RUs81h7SljiYEr4xfI4IxTnewJ4nbY7d2raYN7FHEfxR8NZ14bUxniMTCBg7PKcMOh19TBCX8RwdVkQziNmb7bj31PdFT9tvSpA/44wzsvoGxm5He7BcVngfy4s/VndYPi3KW+FY9PjB0DMYxsZr89ibKnKMFuOtdkuJgXI+ruOQGg9YXstOKzSMFVbIs82bnPDy0elaIaikv8QWztXlkHbiA0b30Kd7cmySkSRJkqzOcF0lmsMTTzxRivFhouNHP/rRWN+XOUlOkiTZPOkhb4OCfEPoy0NGAC7EGYCilrfQaaAOA2GF+Egx51VAb+HTOud5tB64vFjfOelYcdHxGMuDu0r8YEtYF2ExZzKgan3G8tXliS1Giv1KT3BYMdDnzZs37ZwnH/eW8nP16tVTeca80/Gtj5x6QME+1ackL/1GRCqUEIaoSYVOEtu1aKzrTsaojE1tU6ptpQ4xpJLenxueSZdJH6/fOJE6xvbGfqsnGMTGAFwfQU9+eWtQSB3j5EvYjuGIvAVjw/6UWKrLQnQHfbony7WNJEmSbIZc1LVZvPrVrx5suummg2984xuDO+64Y4q//e1vx+6+zJA1JEmSzZMObDYoyDeEvjxkBOgwIQGp0C6WQJgS/LToZXlGY5pWGiIwaiE2lWf4FAHNE9JkAVT5jmKITDjU8dq3FgHVAikugCnH54p+8hkLjYJ2S16Yhz5Op2OFArHSS3lMi70issbeMhBbNttss3WO2emV7xk8/YS3rxNDvm77pEKWeOsMWPnFFozNoVW/sTqVyZuYSJ6yIfQDa50FHNfoCV6lvq01FCw7LW90GR+x0FAp5rwN4rWjF8bIm7Dhoq7dRJ/uyfTGI0mSbJZc1LVZePV8/vnnj919ueqzPEmSJJn3+5xYFxTkG0JfHjICtNCmvbot0RTjqsfEsVg8bksI08djupZAjTHZLTE5FcIjpxxSbrFbBNIcYRDD9WgB2IpRL17AuBAl2qnzxroRkRbDnIhgHqsPFFo9wRLDveTUrSW0pupvq622Kj+XrXnhYKsDX17+v92RpwyefGw6VE0qjjkuwon9TepLhGkrlFKOcKaP0W8/xERiK0RNlbc9rPRTMdtzwiB55ZO68iZ/rPS9/FL9wutPsh0982PXAG8NB01roWlJH2PTixhPQb576NM9ueoaIiRJkmSc4fmL6Bb6cl9mDHmSJMnmSQ95GxTkJ+whQ6BDYIjIFBPM6ngLxMTAmNhoxWIX4nYR41GkFgHdE/yt2NVISdNapFV/WmEyMC61TtcTXyxbY17t1vmWt7dlg1Xncjzm36T3puRjeVD/yZ/8ybRjgygfxPjgIa8Xd/2Hf/gHsz7xzQhcjBjrZBgG+5uol9TCrrJNl0OXD9s/tthrrD28vujRe4NAh8NCcR73YR4x738dh94KsyOht3Li4aM3vK4fveaA3uYt9Kr/pyjfLfTpnswf/yRJks2Sgnz30Jf7srW+FUmSJFmfS5cubfvS3llQkJ+whwyBFYfcE4tji19qonjsCfmW8GaJbF7IGzk+x4NYvIS1SK6FdC8eueeFnkurznRemL5428bSxHA1ORRhMSZC40QDxhZvgloc99r1Qx/60DrniZd84JJtVmbnp0X62CKhMoGCC9Ci7VIvsXBLKG7rdtJpWm80SP+wvOMxrI/XzzRDOnqiTf4X7/GU4G7t1xNRsXyxL+l8q/RZi56XPI5jufbotyKw3FXeQLBi+GMfIbqFPt2TrdBjJEmSZH1yUdfuoS/3ZU6SkyRJNk96yNugID9hDxkBWpSyxN2YUCXithYHUcD04qHneHuHbXUWikXP66pMnYfx6T37rbA1Fr0FUnX6qbjyng1aeIyJubl5aOqFQ3U4HE+o9GLpW+U47bTTzH0iyq9cc1j5+eY3v9k8zps08cqu1w6w7Iq1rxaCdRpWfWqxDb35Na0JqtRCsVXeXJHyxN7eqENPoPZsjqXlTZCl8sP6RTssMV5PgOVeB623d6R9xUuf6Ab6dE+usx4GSZIk6ZOLunYPfbkvM4Y8SZJks6SHvA8K8hP2kBEgQhQuZhoTxmIx3b39Fi3PcBS4JIyEiL6pNHNEePGUlu+puOnaazzmkY4iui6jtwgoPujhgq2W2JfjFS/tKesBhP+x/mLCj5Q55a2p6xs9j60FdWOLlOrFf2PUnvJVJmkwVEoOcU0CvZ6AbMtJJ9VvYn1E54/1aVHbGepH1xFOcll9VcZH1cVbR0WvvF58fl3XaH+oi1Q9Y9/yFjmO9TWiW+jTPZke8iRJks2SP/67h77cl5sIbUmSJElOJ8O72qAgP2EPGQFVBMocAbcuc0T8KgtcxsKHxMqSEt0tWkJ5rDyekKhtS725YIn5OKmCwk4V7+Wc9qrS5rjIqrbfs+GpO6+eFj8+fOr98+fPd8vliVopD3kUsKvWSd0JIs82CV9UtZ28uO51yhWjV8+y3QsxhbZ4b8xUmXyKjd3cslsTIKm2s/ofHzK6hT7dk1etWtX4OCVJkpxkMoZ899CX+zJD1pAkSTZPhqyxQUF+wh4ytCBfVVy1vJ/lobeKcI7UMbpzz9E2VI3v3tYFKPWAhwKiJWLm1AduS7WJ7Jd46rE3JzxbhUEcrWI3xpPfbtd9h6rnIArH8q4iUKcWO47R6pOyDfdZ/V5EZgxLo8/Fek55gVv9S+p+mDUDrDdpvD7nhYGRUFhem9a1TeyJLRibagvLbomJr8cdBfluoU/35D7cw0iSJPtEesh3D325LzNkDUmSZPPkb2UbFOQn7CFDEAQlb2HXHFre2t5xuC0nHAR6vdbxIJTyWSEsvONzvPZzw/PocurY057gXaX+dRgOtCe3HKmypTyVcX+OkG8xlOP1r399+f+KvQ+dFp4Gue3qZw5WrFiRTFPbNuybHFYfGpa5bxvoMRoT7VLrPlQtUyyMU27/sMJTyWfuoswxu6zzpY7keoFvaaTKqW3GegvHyn6rXTjr3y306Z5c93pNkiRJ+s/gRLfQl/ty1VCXJEmSZJpcb80GBfkJe8ioMvMfRCcRvbQYWGWxUU8MXL58+TrbmhBOLRsk7VxhPqdecgTLtpmKzx7axhPRrfJpAbZqiB+LXj9asMOe074vetp+U/8vXrnaTcfqUx5xgifUk/cGA06sNFHGFK21FcROK4/Y2xfWGMxdiLkum+gfVYltE/o2xv3Xi/E26QEV0iW6hT7dk+tOZpIkSZI2GbKme+jLfZkx5EmSJJsnfy/boCA/YQ8Z1sy/XsBUD5gqMfRiAhyKfSKcel7vXmiPugM/5zgULXPCZKTE2ZgY7i1IOUyeuQuk5qavJ2Sq9AEJW1Mn/4222jH6PYfD1IEl6g5Tn+GhXoeWwcVvm2TIR/pVE30hJdrrUEc56TW1cKUVYqfq2wbW9xyGvh2un4wh33306Z5MQZ4kSbJZrly5su1LO9HT+zJD1pAkSTZPCvI2KMhP2EOGwIo9bYWD8MS2OmJ51YVZq1IL22JfrigZhFMR2ryy5XpK6zw9T+e2GHvTYRiv5r7FQPYEcd12ufWRWrDXSz93HQQJDyXn5oTsqdPntA3S1+tMHOA5KMRjWdFWqXfrrZZRif5Vyql/qOn2pCDfLfTpnjyKxZdJkiQnmcH5h+gW+nJfpoc8SZJk82TIGhsU5CfsIaPqzL8ITkHoqirYNinaW3lX9QBO2V91MmDYsBxefphuFbEmx6bYMTFPzdz6sYTdOlx/0ZZT/2+y7c7J4628rD5YJfa51H1s3YHY+U32l9RaCqlxbdVFXc9ca2JHPquOI69uq1w/vLr1xo7XL73JDmtNArSbgny30Kd7chshnkiSJMeZjCHfPfTlvswY8iRJks2T663ZoCA/YQ8ZTT1ohFdBmx6kWtwUobBuaI8mwmMEMW8Yj31JY9Se5XUWvA1sQgRKhSoaVVz90P+22mor0w7PJqvPWguVNvlGAy4uWrfNc8ZB3X5QZc2EmO3aRhx/o7Ktah15fST2Zkwu+ZDRLfTpnty19UdIkiT7zvnz57d9aSd6el9myBqSJMnmSec1GxTkJ+whQwvyWpSqsiBmk2K8tqGrr+2PIt73KNKMUXtCVxXiUSyqKlx6Ymxq0kR7yM8kLXtDmYcRzarWWax/pOotJozn2tFUvHfv2hIE8FGNgWHStd4YsNLDbYyJ1z306Z480/cDkiTJcee8efPavrQTPb0vU5AnSZJsnnRes0FBfsIeMkYVG6+uB6ycN+pX9j2B0ds+UzHRhxFixMaqEyS5eVapg1EJSk0s8lqHOXVadwJp4cKFM1IGizPhqd5HDrOopvQDzvp3C326J1OQJ0mSbJb0kO8e+nJf7tLaXyRJkuNCxpC3sV5BTByuvfbaWuedeOKJxeGHHz5t2+rVq8vPG2+8sVaact5FF11UjBJXXnllpe2XXnppMROYP3/+tO/Lly/PPlds/PGPf1wpzwsuuKBS+sOmKX3Ew7InPbX8nLNg83X2/fbnN0W/18WqVaui+3Pq9P3vf3+tvO+5556pOtl///3NY/T2ffbZx03LO9+DNU7DuG66H1e17+ijj67Vd7y8QpnOOeec7HOvueaa8hOvb4KVK1c23g8IQvDVr361bRMIgiDGCo888kjbJhA9xS233NK2CQRBEGOHLbfcsm0TuglHqCfGdNa/Tgz5YbxHm+RMxtmdCY/FUcTh7wpjZasSHmlYttl3Y28YDPsGRpMhZYZp15gdTY6hOm/QDLv+g1dmbx9n/buFPt2Tx/leQJIk2QZnzZrV9qWd6Ol9mR7yJEmSzWsyhA16yE8gtttuu+L000+f+r506dIs79G6iHmXomer51EbPF7PP//8Yqaw9dZbVz5nxYoVlY4PXthVPZybgOcFXAeeB3PMw/z2229Ppjt3yTbTN8yZN/Xvoqftl21frO9W8b4W6HGjYbWj94ZBeAvC2xfzhs95s2PUwHaN2eG9NVGn3uu8QXPWWWdN8/736lbGg3edivVlvY+z/kRdLFmypG0TCIIgxgqbbbZZ2yYQPUXqdzFBEARRDUGTufzyy9s2o5Mo3QfaNmIccN999xWbbrppce+99xYLFiwouozPfe5zxYtf/OKizw9Kd9111zQxdKZCzHQVCxcuLEOhhFAsEpYkTBD89Kc/rZROECdHHT6obwhCbdWwQG0iCM9tCfZtYPHixcXdd989VBphkmCYiccwbr785S8PZQMxuffk3XbbbeiJb4IgCGL6b4U777yzbTOIHt6Xg2j0rGc9q20zCIIgxgq33XZb6RhMTAc95CcQe+21VyUP9pmGF0dd7NRifEBVMX4mylslFnwTCGJ8EGJ1jPAqYrx4g3RNjJ+9SXUPJ/RWr/rmAqJPYnxAE2K8F9O9i6gqxmtPefHWH1YMDeOGs/5EXfzBH/xB2yYQBEGMFX71q1+1bQJBEARBEP+Nq666qm0TOgkK8kS24LjxxhsXMwEvpElTwmhOOnXCalQNy9IlIRYnOXLDp2A9DRWCZ/0N19n0+AO/Mhd7jQEnaKq+JTDK11yHnRyYKaxdu7YVT/eZHicxIV4W/s0N8XTHHXc0YB0xifjZz37WtgkEQRBjhVmzZrVtAtFT1AlbShAEQcSdVY855pi2zegkKMhPIC688MJa5/3mN78puorc2Nu5mDfv9zHLJzUeYY7Aj3Gzhwod9OiD5ubH7vtl0RdYExvDTA40+TZHFcG7jZA3w4adaRJhokneNtFvjYTQUJOOyy67rHje855XPlgFweMLX/jCtP0hCt6ZZ55ZXhs23HDD4uCDDy5uvvnmdTwXX/ayl5WvrIc6/eM//uPigQcemHbM97///fKV8Q022KDYZpttir/7u78rxhU33HBD2yYQBEGMFebMmdO2CURPwUlygiCIZhGcVfk2uQ0K8hOIXXfddSTp1vUqbyK8S0pAFG/Xquk1JaSnhNq+YqZD3Ezzlp89txh3NBkup0uCd9fhec6H0FC5ocDGFWFiNtxDzj33XHN/EM4/+MEPFuedd155HQ1vVh166KHFQw89NHVMEOODCP2Vr3yl+L//9/+WIv+rXvWqaXFmn/Oc5xTbbrttcfXVVxfvfve7i7e97W3FRz7ykWIc0fQEMEEQxKRj0aJFbZtAEARBEAQRR1jUlRge9957b1gct/zsOs4555zS1lFyn332qX3u0qVLR24f+TuuWrWqdRuEszfZrHUb6nDu3Lmt29A2OWaLwW233TaYNIRyf/7zn5/6/sQTTwy22GKLwbvf/e6pbffcc89g3rx5g09/+tPl9x/84AfleVddddXUMRdddNFg1qxZg5///Ofl9w996EODRYsWDR5++OGpY970pjcNdtxxx7G8Jy9evLj1/kuSJDlODPcUolvo03356KOPbr0PkyRJjhM/+9nPtn1p7yToIU/0Ip45MRroRWDbRogX30c88sgjxaSDY5avOAfcdtttxS9+8YsyTI1g0003LUOKffvb3y6/h88QpmbPPfecOiYcv956603dN8Ixz372s4u5c3//Fkzwsr/pppuKX//612beDz/8cOlZr9kXhJA8BEEQRHPQ9w+CqIKf/OQnxQUXXNC2GQRBEGMFDHVM/A4U5CcQt9xyS9smEDOMviwmShB9HQ9c1LUoxfiAZcuWTdsevsu+8ImhwEKs380222zaMVYaOg/E2WefXYr/wj6J3CGmPkEQBNEcfvcSF0EQBNFfcHFuYvxBQX4C8b3vfa9tE4gZRtXFRAlinDGK8cC3BNrFGWecUdx7771TXLt2bdEXrL/++m2bQBAEMVbg2hxEXfCNR4LoCjixOi448cQTi/32269tMzoJCvITiFNPPXXG8po/f/6M5UUQBDFui2X3CVtssUX5eeedd07bHr7LvvCJkxePPfZY6SWuj7HS0HlY4suCBQumsS+ILRZMEARBVMdvf/vbtk0geoqtt9666CpCeD+CIIi+YbvttmvbhM6CV3VipLj//vvbNqHX4IQGQfQDX//614tJx/bbb18K5l/72temtoVY7iE2/Jo1a8rv4TMI0FdfffW0unviiSfKWPNyzGWXXVY8+uijU8d85StfKXbcccdi0aJFxbjhoYceatsEgiCIsUJYq4Qg6uCqq65qLK1Zs5oNuRGelQiCIPq4Ngdhg4L8BIKhFfoDTmgQRD+wePHiYhLwwAMPFNdcc01JWcg1/B/CAIUfnqeffnrxjne8o/jSl75UXHfddcUrXvGKYvny5cULX/jC8vhVq1YVhx12WPHKV76y+M53vlN861vfKl7zmtcUxx13XHlcwEtf+tJyQb4//uM/Lm644Ybin//5n4sPfOADxete97piHME1PgiCIJqFtwA4QczkwoNcy4AgCIKIgYL8BAIX1CMIgiCGw6Qslv3d73632G233UoGBJE8/H/mmWeW39/4xjcWr33ta4tXvepVxV577VUK+BdffHGxwQYbTKXxv//3/y6e+tSnFgcddFDx3Oc+t4wp+JGPfGRqf1iU9ZJLLinF/j322KN4/etfX6Yf0hxHcEFggiCIZtGnsGXE+ISsCc4EBDFRWI/rIBFpnH/++fSSdzDH20GML6644oq2TSAIghgrTMpi2X/wB38Q9fgKXvJ/9Vd/VdLDZpttVnzqU5+K5rPLLrsU3/zmN4tJwMMPP9y2CQRBEARBDIlHHnmk6CrCZEGX7SN6iid+H16SIDy8/e1vZxx5B/SQn0DssMMObZtAEAQxVth8883bNoHoKUJsfIIgCKI5cLFsokuYPXt22yZQjJ9wzN5ks7ZNIMb4+kLUBwV5giAIgiCIlnD77be3bQJBEMRYYf31GUaBqIef/exnjaf5+OOPN54mQVTB4w/8qm0TiBGhD9eXs846q7j88svbNqOToCA/gfjGN77RtgkEQRBjhWFijhKTjUlZEJggCGKm8Nhjj7VtAtFTTNLzHGPe1wc9zkeH2XM4oTqOmKRraxVQkJ9ATMrigwRBEDOF0047rW0TiJ5i3333bdsEgiCIscJ66/EnLlEPIc7xpKxhwzA29UGP89Hh8ccYlz5g/vz5xbjgnHPOYQx5B3xamUDMmzevbRMIgiDGChdeeGHbJhA9xaQsCEwQBDFTmDNnTtsmED3Gtdde27YJY4fly5e3bQJB9Ar3339/2yYQMwAK8hOI448/vm0TCIIgxgqf+9zn2jaB6CkYQ54gCKJZPPzww22bQPQUIc7xa17zmvJ/OrE1Bz7rEMTk4u67727bhM6CgvwEgsIRQRBEs9htt93aNoHoKR588MG2TSAIghgrUEgl6uKOO+6Y+p8TOwRBjDOWLl06I/n85Cc/mZF8+ggK8gRBEAQxJBh2hKiLRYsWtW0CQRDEWIEx5Im62HLLLds2oTNYuXJl0RWsWLGivcznbpx96JwFm4/UFILIwcYb5/XZu+66a0Zi1TN+vA8+rUwgnvSkJ7VtAkEQBEEQRVH85je/adsEgiCIsQLfPCLqYr/99iuOPvroGcvPE8NQDJ8pT1aNH//4x50RD3/6058WreGR/Oe0x+775UhNIfojdvflt0UqVn0T6z+cddZZ9JLvoyD/tre9rZg1a9Y0PvWpT53a/9BDDxWnnnpqsXjx4mKTTTYpjjrqqOLOO+9c5+J9xBFHFBtttFF5I3vDG95QPPbYY9OO+cY3vlHsvvvu5euNO+ywQ/Hxj3+8GGdcdtllbZtAEAQxVmDIGqIuHnnkkbZNIAiCGCuE34YEURc777zzjOXliWEohgdP1j5gww03rCUeNjXhMCOe9LPnRnfTS74oNlxUrz1Xr16dddw+++xTK/3111+/GBahv47LIsU5b8E0sf7DOeecQy/5PgryATvttFMZy00YFloR/Nmf/Vnxf/7P/yljol966aVlZ/nDP/zDqf2PP/54KcaHH7tXXHFF8YlPfKIU288888ypY2677bbymAMOOKC45ppritNPP734kz/5k+Lf/u3finHFo48+2rYJBEEQY4UwmUsQfX8lnCAIYhzw29/+tm0TxtKh63nPe14pRAUnuS984QvFuOLAAw8sP4On/OGHH962ORPxdsowEw5aHJ0RT/rHHxl7L/m5S7YZ6vwHf12vPYMel+OFfuWVV9YS9pvSwcZlkeKZegsmLJRND3kbc4qOY86cOcUWW2yxzvZ77723+Kd/+qfiU5/61NRN8/zzzy9WrVpV/Md//Eex7777Fpdccknxgx/8oPjqV79aLFu2rByYf/3Xf1286U1vKr3v586dW5x33nnF9ttvX/z93/99mUY4P4j+73vf+4pDDz20GEc0MTNIEARBtPsqMTEe4KJxBEEQzYIha5pH8Ardddddi5NOOmmaA9y4IYhGz3rWs8r/L7jgAtcLu9UQKsRYiqNdwiP/tbbX4RxTYVjqhJZqOs0chAge4/A74bOf/Sw95PvqIX/zzTeXs54h7vnLXvayqZvf1VdfXc5wHXzwwVPHhnA24Qb57W9/u/wePsMrZ0GMFwSR/b777ituuOGGqWN0GnKMpOEhDIyQjmZfMBMLNxAEQUwSwoMGQdR9E5AgCIJoDsGDm2gWwVP8He94R/GiF72oGGcE0ejtb397+f/+++9vHkMxvll49dxbzJlXjD1mzWks/Mwo3iRFz+/gdBv7nkIbYnxAk2L8TIbZwby4WHZPBfkQGyqEmLn44ouLf/zHfyzDy4QZ6zAgfvGLX5Qe7gsXLpx2ThDfw76A8KnFeNkv+2LHBIE95l1x9tlnF5tuuukUt9lmuNd6ZhLjMMtGEATRJXBhTqIuuK4LQRBEsxgMBm2bMPHos/OavH0fQuISw4l7OQvkDlvPo1yEt5ao/NgEaC2D6WsyeuFndP2hCJ5bt6mwKjlrhtx4443R76MKJ+lNNp144olFX94kQb21Tl7/8i//UivvScB6XZ+JP+aYY4pddtml9Fr/8pe/XNxzzz2d8EQ844wzyrA5wrVr232tpwrojUcQBNEswlokBFEHfGuNIAiCGDf01XlNh6wh1l1EU4T4HHEviI5e2J8m0VQelte0xDRvArM32ayYBOgFV3X9oQgewrE0gbvvvrvoSmx1FPK9yaYQarsLyFkEOeivVWBNkBx11FGV0pgkdFqQt2ZnnvKUpxS33HJLGVc+LNaKHeTOO++cijkfPsN33C/7YscsWLAgukp4uICEYzT7gnFesJYgCKINnHvuuW2bQPQUW2+9ddsmEARBjBWaEnqIyXNeCyFrYs5/WmxsSvDqQ1gXWURznOK144K9TXlNb7DsSeb2xx/4VTETWLDDnkWbSC24WvW4uo4rTY29KmMxCPlePxmVPcMgN/yWvIWSc/2zJkjCJCcXdR0DQf6BBx4oO3mIQbTHHnuUi5N+7Wtfm9p/0003lZ1qzZo15ffwed11101btfsrX/lKKZ4/7WlPmzpGpyHHSBrjCP74JwiCaBZc1JWoiyuuuKJtEwiCIMYKDM/ZPvrsvLbXXnsNLSI2HW8ePW1HGaalKTTtBVw17rcHCRdy0UUXVRJdc72mH7rz1lY95O+75btF3xCb7Kgbvz2MPS0g54TICZM0p59+urs/pJcKsST9BAV4fS2whO2YYN/278zgEI3XP6sMnmDPRV0jGHQYr3/96wff+MY3BrfddtvgW9/61uDggw8eLFmyZHDXXXeV+08++eTBihUrBl//+tcH3/3udwdr1qwpKXjssccGT3/60wfPec5zBtdcc83g4osvHmy++eaDM844Y+qYW2+9dbDRRhsN3vCGNwxuvPHGwbnnnjuYPXt2eWwV3HvvvSFYYfnZdSxcuLC0lSRJkmyG++yzT9uXdqKn9+TwHNN2/yVJkhwnzpkzp+1L+1gj1PHnP//5sb0vn3POOY30w/nz50/7fvjhh7cyHlavXt36mESuXLky67jUM5Ku0/333z+ZHh7TVt2sv2jL0eYxa04j6Sxb88LW+kgOTz/99EZ/y7VdnlweffTRU/+vWrWq0TGXYs44Q372s59t+7LeWXRakD/22GMHW2655WDu3LmDrbbaqvx+yy23TO1/8MEHB6eccspg0aJFpaj+ohe9aHDHHXdMS+MnP/lJeaHecMMNSzE/iPyPPvrotGP+/d//vbwYh3ye9KQnDc4///zKtvbpISN30JIkSZJ5DPcQojvo0z15k002ab3/kiRJjhuJZnH//fcPvve975UM9fve9763/P8///M/x+q+HBwBpQ8FYf7tb3/7UOLU0qVLh+rHJ554YqOiZRPpdUHwrCMKeoJmF8rTFW6y7c6DDZY9aZ3twWE1dl6b/SrF2KRLVbtlLI1iIqduf5K+7NnU1kSgzjdcVwkbfFppCH15yAighzxJkmSzDF4HRHfQp3tyEz8KSZIkyd9z1qxZbV/axw7Bgc2q6xNOOGFsBXkU7UQEXr58eeMeu/pZIJb+MNSCnZWHJ3IH20K5xMZRCnxVHAdjomiYSNFtETvWKndKHM0RZINDqLfPEr1TnLtkG9eL3fNk32irHWu3xWZL63nxS30OO2kyLIfJX3uT54rvTYwLtFn3w1EL6zK+w7iJ5YVvreTUc5jcJGxQkG8IfXnICBjVTZ4kSXJSSUG+W+jTPbmpV0hJkiTJ33tzEt1CXwX5qpPmWkBDIS/siwldOWJ+VY/eqmHxUm8ExKjLmxK0c8pR9e0CnX8QACX0EOYVwmeEdq5a1nBeIJatKeF5wQ57DnZ65XsGS3Y7pBEhP3i7N2HXYYcd5u6r+gxbZTzleoxbIja2eV3vc2+8hr6F47XuZFwdob3LbyRYZMgaHxTkJ+whIwDj2ZEkSZLDMfxoILqDPt2TGUOeJEmyWVKQ7x76dF/WomEdsbWK+KdFYRTZPPFShOeYuJkSmz1BLwhnw4y9OvUVExctj/kcMVK3gVVPufWjRf5Uvp6wWiU6waKn7Vep7rR4HwT93Nj1MWEfnTd1ua31FepEX2jq7VCs85wJAnzjRdvinY/56H6u/0+J655ob9VHrlBfty6rTlJYYxvzxu+67zBsjQ0K8hP4kMEY8iRJks2SHvLdQp/uyXxrjSRJslkyZE330OeQNSiM1YkfHdKQ0C+WYBUTe5uIV41CmSe8jzJG9qgo7ZMzGeDVc+zNBqsPeOemjm1SjB8Vd9hhh6Ena0YVrqaJsC04BmOTM6k3WkYRdjLnzZBYvlWF9phnf05aMVt02hTkbVCQn7CHjICweO0oLpAkSZKTyjDRSXQHfbonr7/++q33X5IkyXHinDlz2r60Ez2+LwfhSIS4nNArMTFdBCnLs3hUsaFzxHQrzyCsoZ05tg0TPsPyqE2lF84ZJk8RYOuGGFm8eHGtOtHnrbfhgnX2hzjww4jyMQ958YgPYWxiIXGq9BlLiI0tLFpFCE8J+1bbxeKv47lYFmyv2Hcp9ze/+U3X7py+ZY0teWs2NxRQ7LriraHgjelhJhdyrhMU5G1QkJ/Ah4xhV3snSZIkpzM86BDdQZ/uyRtvvHHr/ZckSXLcSHQLfbovB+FIhC69OKgWrOvGEZe0gsCXE0rFEzhzPOtj6caYI4hXGYt1hD4t8Hlin2WnV1+5NqTqSdrZijiQK/DPmzev/Fx/4TJ3MVYR13F/ncVgPVoLvh566KFD1VNOPQ8zmSLjTveJ3LbNmaiq0lflWjCKt0nC2wgxsb1uTPyqbVAnHyttxpD3waeVCXzI4I9/kiTJZskY8t1Cn+7JnCQnSZJsluG3DtEt9DlkTRNiYsqD1BIYUQyLiWNaDI4tRKmPSQnIIrpimT2h0ArJY1EEzJSXcsq2mGCJdsWODfuDYBg8ngN0GYYRnqvEFs/xWvfE+Kpe9U0t9lqlLnLryWJoG90OOA5i/RGPz/HkDumFvhA+JV/MM/SR3Eku77iYkB/Sr7qeQ5V2COXLsV9ssMZmaryG9PXEFT3kbVCQn7CHjAAu6kqSJNksGUO+W+jTPXlYLxeSJElyOkMoMKJb6NN9OQhHMTFMC4CeCJZzb0dBLEfQDvsxVEZIB9PSYpn8X1UYlDqQT6ussi0mquaKl15davstQTVWZ3Ju7Bi9L2dCwWrbmNCr37JAbrJwsSmsi0CfEuotMX67I08pz3vycW+Zdj5622+xYmUZIuWQQ353TLDREllzhefQT6QNU+KwVV8hb+nbeL5Vf9pWtNHqj9huIQ85r+oEi5WuN/Fj1Z+2JZRD0q4ae1+XAdOPtVuwU8b1sBMLVjtZ7UVB3gYF+Ql8yJg9e3algU6SJEnGSQ/5bqFP9+TcOJEkSZJkPoluoU/3ZfGS16K8J6haAmbufb1uDHMtyHteqlW9a2MUsVLyanohy5ggHvIM7RHKnCpTbBIkCJC6rqyQIFU89mNi8EwTY8dvdeDLs86TeOUpYr1rz/HYmwe6XnTYJ6/t5ZxYbHadbuoNiVj7aeE7Z9ImJ51UnxuWo1oo13tjJNYPdDumJkvkXMIGn1Ym8CFjvfXWm5HBTJIkOSkMbx4R3UGf7snLly9vvf+SJEmOG4luoU/3ZUvwkxApsfAYljCLIpqERvHSyOnbIQ0J4+F5FKN3O1KLz1VDesQY84bHMBwi2kl4EMtWbAOsqxwRNXWMrjucTEEPaktgDfbnirmSnlVHy/Z9QfkZvNqDN3sQ1q3wMlqAFw959JQP5wYP+UAU7Bcs2XLq/9NOOy3LZq8fYTlQUK8zWZEryMunnlyxJo1ibYP2Sv8P56S83fW4kQmjWF9IjW/rTZe6DOWw6gfrQ64lqTrXdZOiVc6QP2GDTysT+JDRxCAnSZIkf8+5c+e2fWknenpPpoc8SZJks5w1a1bbl3aip/dlLUx5whoKdZ6Y7FGLbpantQj/kqbnQR6OScW8t8SxKl672nvYCu9heZ7niopSj5bwmSv+ibd2LIY+htGQuvXqta4nctVwOsLdd989ul+L8iiuW2FtLA95CVez0cIl0bbQ7ai/y0LHOcIthkLx6tlrYyuPkFZOv82xT9uW2pY6RgR9KfMwXvsx+/VkoJeG1CeGw8E2Dm2pF6620sR1FGLj0Xv7ActF2KAgP2EPGQE5FymSJEkyn4sXL2770k709J48rDcaSZIkOZ0LFy5s+9JO9Pi+nLPgoSVY6nOqerpqccyK7Yyiphwv2/WxmJZli7VwqT7OOk+nq8OWpIgCPsakR0HP81LGyYuY+GnFxU/ZG/aLDbG3IbxzdRm1+O8Jqfr5b7fddnOF9iCw7/TK90x5vGO8+LAvFaYG48ejzfKWgtf+3gK/sk97pmM/SdWXtHWwQYTi1EKt1piQcljiuF7E2AqLY01upZ7PU5NwaF+s/2lv9lQ/xrRzfkeEegtlFmHcE/5xMqpKSKywTWzBNSwYP94HBfkJfMhIDViSJEmyGjfccMO2L+1ET+/JTcaXJEmSJH9Holvo0305QMI4oPAkQhhuF4HLE9YsogDuxbIOxwVBC73j9TFhvz5f2y6fWnS1xMGYzSLoVRmDOQtzeufgsxHaK+JiLC0tVHrx46Wuqk6gYLx6nJCJtTV+120pYQyDwB7EdhTew/9BlLcEds+DXtIJMeNXrVo1bZ/n9Y4hTjDUkJxjtakeA14bacFfp5HT7l7/tZizUC1Oalme3iJU632pMW5dP3SZc8McVVmzIWeiTNZkwPJbb4bgZJ2+/lUdNxTlbfBpZQIfMnIHDUmSJJlHxpDvFvp0T44tQkaSJElWJ99a6x76dF+2PNTRi1Z788p3y6vXEsBjnt9IT/DSHsvBDrFZi9A6RIUljso2DF+h8/AWptSCqmWj5+Ws45GHdLVd2nNZ2+p5S1tezmibJ3pqodQTjYN9uV7yueGNJO+YmLtqp+lx48X7XYR18ZKXOPOyX8eRF2E+7Nv5+DOj9loTQJb9OsZ5KsSNjJVUSKWQXgCODz2ZhBNXmIYWkmPlyiF6m2P8da/PW2+qiACdWmNA+j3WqYwP3I42eIK9TJx4k4ci3gegfTqclG6DnPUS9OSizpOwQUF+Ah8yQlzFqhcnkiRJ0ue8efPavrQTPb0n1/nBQJIkSfrkui7dQ5/uywGeEK7FMRG2PHEVw2BUCYGC6WCIGs2Up64VQkSEePSW9QTXkK/nBa4nBFBsFlE/ZqMVYkQ81/V2FFsDtHAo4mOArvdUjGtLTM6pT0vI1gvUWt7csrilFaJIGNYW2nHXvQbbHXFy+R294VPhaTCm/C57T1/wVdui1ymwJmxyw7JoQVqfkxPmCOszJ18R4S0xXsadNWGDeVnjSSYEZHzgpIIeI2in/o42WGNKtuUs+KpFexmPuv9bk1CW0I92p95KSFFPhHnpyrgk1gUF+Ql8yKgywEiSJMk0GbKmW+jTPdmLD0mSJEnW4+zZs9u+tBM9vi97YTFQiEMhWcc11x6lKO6JeGwJetpDV4tp4ikr4qAONaKFPxHBUjHQdb5SFpxg0HHBA7QwqfPR51ke0Za4GtL0xH9r8gDrA+tdn6c9ky1BUiYjMKwP1nWVutP9QYcIsiYb0LPZK9+qg46eClWjRXYdykZ7wmsb9TEhVI1lv7SXVY/WGxUpoRaFXU9U98IlYf3hRAFOGoSxEmC1b2qyzOp3KCjrdoy1v5W2FVJJ17WuKxnzVvx1jPNv5YP1pdOyJlyk/6fqJDYG9FoLGLoGJwSknxE2KMhP4EPGeuutF72YkiRJktVIQb5b6NM92YrZSJIkSdYnF3XtHvpyX0ahSnug6k9NFM5lmyXceR61etFHvUBlTqgVLxyNfGrBXtK2PIjRa17Hrdde8Fpwsxa3RUFfEz2StbCPoTikDj3RU/IK0JMKVnm1LbFQKtjOWliVNLRNkpYlvOt6DbDaU4dnEdvf+973TnnKWzaK2K4XfdXfA4OI/6RDXlH+v+ppT5tWPlyPQNst6xUIMMa8J9hi2+k68t4E9YR5bQuOSZws0X3fmhDQ54qXOY4JpO6Tnp1YRj3BZuVrjZUYRfDOEf/R619724e8rXUvvAWbrTdnvDBAVl+3QtXoiUNiXVCQn7CHjIDcCwFJkiSZxzlz5rR9aSd6ek/2fnCRJEmS9chJ8u6hT/dla8FDLRBawpaIsp7Q68WexpjTGPIiJuJhWij6o9CrxWYRxywhVafpeRqL+Khj6ovwnBsCxoq7rUU9SzQU4VN7+eYKnXqiQwRHLRhansMouOs49yJe6/rXaYmtAVLfsXj9nt3L1rxg6n8dJ97yhhdudcDLsq+X6Ckv9aDLjOXDOpdQNQE4ORULzyP7UVSWNsY2Qpuwn2Of88aQ5cGO4zp2HcDzvPUZvEk1a1JBrwuB+6T/hO96zHr56gk+r+7Fi17C31hlj41dqw/IPnz7hSFrfFCQn8CHjNyLM0mSJJlHvh7fLfTpnsxFXUmSJJslY8h3D326LwekFmnVgp/2JkWRSseJ9oRqEcBQDI6FVNFpWOIXniO2YogZnT+WNSYo6mMsb1pcoNVaXFKO0+K4FvUwvA+e68W0t2Jy6+/eWwpYXhRaPTHZmwDRfUDs1elhSB0RxiWd5z//+eXnque81IwNj4u94nYMVYOCr34TwWtf7A/Yl2J1awnkWlDGOsaFRNEmnBxBwd8T3q0xp8eADqmi33wIwLcAUEjXExFYNp2fR11Wa7zobV7/021hTRzIWNRlxrazQulg38G3VeTaY12/vPFKrAsK8hP4kBG7KJAkSZL1SHQHfbonpxZyIkmSJKsxrM1BdAt9ui9b4SaEKA5bXvGe56gWw1FIs87T1MeLjSh6iVhpLTaK6VsiMpYPvYu9mO/eIqf6OEsYtWJ/W+lrag9qDPGDbYXhakSUtLymLWFfC5g6Lr0cb7WdvCVgvSmBoXJ038F2kO/hWvbsgw8d7HTSuwZPPu4tJUWAD2FpAnf/809MbS+//9lHB7vuvnd5zLvf/W4zBJEOY4I2YLtpD220D8MXyaQKet1b9Y1vJ0i9iT3Yn/Sx2D+9UDpayPcmFCRN3TbYVrp/xBamtfZb+6wwPvi2jDfJZ/VT780Lq+6wf+oxheMTJwK8MD5yXcI2wnFBrAsqCBP4kBEb0CRJkmQ9Et1Bn+7J6MFEkiRJDseNN9647Us70eP7coAlUKOg7YWEiQlYqQVM9bFeDG4rdjUKjrKII+aH4pvOC0VIa9FL/V2EV0wP3yIQb3dcSFXnr9NHETUnTjvWJbaVXlTXqkcsJ8Z9R49pESB1PHL0ANYe/+iFjX1He6tj3kGUX7HHAess3hr+14J82BY+933J6eU5sTcdrBj5uiy6HrSduj5Q+I4Jx7ouLOo20vVshcmRPiSQ/i/HSB3rvHFcW2I/hnUK0DZhX8VY9xheB9MWm6xY9zjWY+GDvDcD5DjrrQ7sn3i9iF2fpF5wTOm6xH6vbaRnfBxUECbwISN2AyNJkiTrkegO+nRP9ha7IkmSJOsxhAIjuoU+3ZcDrPAlsj1814Kx3u553VqhUKzwG/pcS1hEwQ3Dj1jhV1JiqY6Dj+KsFTpEC26eCCnpaRFTi4I6L2vBXPSo1aK8bh9PpEcR3xOWY978WsTXwAkQLaLq/qPrDP/X2/RzIE4AfOUrX5nat2yf5/3+/zUvnPo/eMaLKL/76R8e7LPmd3HmP/nJT5rtjQu16vLr/hUTaS3RWY61jrf6sVX3Oi0tukt9Y8gl/B/rXy8Mi/1RvPS1oI+x9OVc3UctIduauNFCOb4xod/a0OMcz9HXDzxGTwp452pbse/jWwz6OLx+WO2m08LroO7X9I6PgwrCBD5keDdjkiRJsh7nzZvX9qWd6Ok9ef/992+9/5IkSY4TeU/uHvp0X7aEL0uA8oQzOUegRWgU+3RIkLAd44nHvNgx/Iik64XXEGEehVarDDnCvM5TtmH5La9dLXBbwrWub0nDyjtmk84fw5F4wiSWAcVGSc+aZMG0dbt4oW08IVSno+1esfv+0zzhLVF+3+NeO7U2UUyYjdWlZRsu7CptZ40NyVOHEopNSqCdOAnieXPLubhOArYL9hMRw7HMOl8Uo612siZxPA95SRMn4bCNtQ2eLVhmvV6DnrBCz3qvPXU9YV+3xqO+fljXROzz1qQW8XtQkJ/Ahwy8qJAkSZLDk+gO+nRPZgx5kiTJZhkmOoluoS/3ZS2Ce6K7FS7C8rxGUd4LNaFFdEvkRFEbBXIU34RahMPFLHW5xD75xMkBnDzQeaCnuiXUy3YU9iRNnZ54IFuipCWuWyFNrPwtz230oE+9EYEe/ThRoj2qsZ7RRh1aRQv31sTOD3/4w8HTdtqp/P7kF795miivQ9js9Md/O3j2QYcO9ttvv8HXvva1dfo1trfVjyxx1SIK/LrcWjDWk0VWv9dCOE6a6LaWPoZCdGxMocAvIrrUu3xiP0Ih3FszwcrX6vd6G3rE4/UFx4Vs894o0F7olr0Y+gb7ojVRYk3kWHbj9ce6BuHbB8S6oIIwYQ8ZAbGLK0mSJFmPRHfQp3syQ9aQJEk2Swry3UOf7stW/GkU6WIx1q0wLfoYLVBhGAj0psW09XYR1MQ+bZMXYkOLlAKceLA8cgW43xMftfBrTR5YYquuS0sc9sRk9GxG4VmLptYbCBgCRIu80h/Qi9nzAEZBXYexkeP0mwkCK2a5tvW8884r48LvetRr14kZL597/9FfDlatWmX2Xaw/3e46ZJE+FusZw7BYkxWxhT6tdsI2x3GForHUn/UWCIrPVntgGQPQexzHlBbzrfuNFsVxUkXKqq8rOAmgJ3N0vjgphBNfVh/zJlKsCTevvq1JO2uiDse8dR3UZSJsUEGYwIeM2AMsSZIkWY9Ed9CnezIu7kSSJEkOx6VLl7Z9aSd6fF8OsEQ99ByV41CYCrDisst+S2C2Fjf10kYh0xLZ0LsVRTX8jkK/TsM6N2ZbrD6xLtAzWnvIY/l02dFzV8OyQUR13WZiT8wbXMf6tsRJbE/cr220PPAtoVTXk/SL73znO4N99tm3/F8Wcg2fwt1f//HBnvsfWu7/6Ec/arY99uUAK166V39eebyY8bo9dJ7YVjgRZNHqP3oBYTwOxxd+WuPX8lrH/ofhWjxveRyrlmd5rM5yPeutvmd501sTWLrsWLfWor84brA+dVrYHoQPKggT+JAx7EMuSZIkuS6J7qBP92R6yJMkSTbL4ElKdAt9ui9reIKphohlItKhIGWFjLHEdcuTXLaj8Czb9HYtMlohV/RxltiItqDwjx7zVlli9ahFbC0+apt1+mibt01vt8qry2a1J4a1kX0Yq1yngyKlJwTjpIMup5WG/sTwNscff3z5feeX/cWUIB++h88dn//q8s2g0047zfQ+tyaTtE1YR1Yf18fK8Rh2yToXJyqs7d6kFU4oWKK95WWOEwLYD6Scloc3ivX46fUHb7JIt6POzwrzhIK69UaC1WZWvWhvd3xrR9eT7mM6b/37BGPTow3WGwjY/wgbVBAm8CGjjQdjkiTJcSfRHfTpnkxBniRJslmGtTmIbqFP92UBeoTKNr1fxCd9L9ees1bccs/T2hNI9bnaLkxTzvXC4+g00cNVp2153VpioK4Pb7LC8jTGY720PRHcE9t1GlUEefSStzzavbrSduI2S6jUYrs+DutF0tFrC4gtux35ijJETVjINXyXOPJhIvLDH/7wtDJZnuU6j5xJDXwLQteN5T3t9W+rv3rtZgm8KNLrCSmsOxxT2EbSBjJGrbbFsWhNKmD7W3Wm87ImXcRGXA9B90M5xgp3hH0T29YKX2WJ8jo/6Xco5OuyYLta7WVNvhHTQQVhAh8y2nxAJkmSHEfOnj277Us70dN7MgV5kiTJZhnCTBDdQp/uywFauEIhSnuxWrHPBVro0yFTUvHHU0J1gOdNbwmqMQ9h/d2KyS52eDHRdZ54jucxjBMdkq5Vdktg1bDEXU+4t2KDW0KtTsOK3W/VsT7fCqOi92M9Y1thOuK1HxZq3WeffQa77LVmKu0gyodwNbvsue/giCOOHDz66KPreMhb3uaW4Iz9Gfs+2ocTElZbxPLT/cabKNHt7OVl9XPrXOw3ehxZIY08D3AP1gQSjgEvBr8VJio2DmJlw0k57MdWWaw49F48fJ2ObLMmd2LXL+L3oCA/gQ8ZbT8kkyRJjiOJ7qBP92RvkSiSJEmyHrmoa/fQp/uy9kYVaOEQ96O3rhxvCWnaK9cTzLUNcp5noyWiW168eF5KiMVyYPksAdkS7VBYRAFUj1tdn5YdsXayFifV8ERkqzzaZhROUWT1bMG6tOo9NmEi9WPVU/CE3/GFrym95EO4mj1f/fflNe+d73zntDLJudYEhJTFqyMUiLVt2LZWu1gTTdoG7LtYR2ifVUdeHVr2xI6xFinFyZucMmub0N6cSRBvO4afik0saXstz3drfKBXvtW3rfLIcdi2lh2EDyoIE/iQ0fZDMkmS5DiS6A76dE/Wr4OSJEmSw3PVqlVtX9qJHt+XAzyRDD0/UYDyPHytdKzvAi3KWUBxGEU/T+z1xGr5tM5HEds6RtuAZUJBUHvDyzYdmkWfo223vluCszXBgWnmCLzSxnoyxsoHP0XY9GzGPBFe/wr84Ac/+Ltr3EFHTx2z+sgTSkH+W9/61jppeG8qpPoc9l99jNfHPVjtYgm/erv3ZoJVl15aukzeuLAmUqyJgpQdnuiu8/DGni6nQE/c6TytdRxi1x6vjyK8CTm0H7dj++L4iE2UEL8DFYQJfMho+yGZJElyHEl0B326JzNkDUmSZLNkyJruoU/35YCUCCjexzGRN5a2912naQmD2jbZp8WwKpMIKbHWE/ownZggh4KjJVii529M8Lf263qzbEbx3Esfy+4d652jbcMyxvqB1Vc8MfPGG28s097jgCNK7/jA/Z57zODAgw4aPPTQQ9POwzcUvPJrGzyPZwuxyR9dBsxL159Xdm0z/m+lo4VrtNvry9ivse4wD+stEWvseIJ+zH7rjRpPJLfGQezakxLUdR2n+mKqT8TanLBBBWECHzLafkgmSZIcRxLdQZ/uyQxZQ5Ik2SwPP/zwti/tRI/vy7let+jF66VTNU9MW++zhDEUkLWdWiCz4ldr2z0xE//HvNEu3I6e9zERVguUVfZ7nsbeZII+DtvRmsjw6lW3MQq3ul6sssTqz0PYf9xxxw32P+DAwe6v+1jJ/f/ggMHJJ588lZauZ13u1IQICvkp2zyRG9NMtblXTq+OcL/lTW/VPfZbq/xYbzp/TFePN6v/47leeXFcpca9Tjf3+mKJ716fT7Vxqr9SkK8GKggT+JDR9kMySZLkOJLoDvp0Tw7CUdt9lyRJcpxYRQQlZgZ9ui9bgrt1TIAXykL2STqxvHSe+vgc8U2f53m3y3GWuOaF1qhaX7HtsckN2e/ViZWHJRrqdDyRUJcZxWq9qCemYdVRrJ5T5cA69iY3rDKE/W9961vLxV33PPk9gz1PfncZriaE/NGCu9XesTZPlQfTknqxRG5s75xyWeWMtb/st/LSQnkqXQGOY28CrIrQrvOtck/Csnr9Ayc6vHGBaVke+FY7ev0X0/HGm2cHMR1UECbwIaPth2SSJMlx43rrrdf2pZ3o6T05ICzQ1XYfJmeOixcvbteGWXNar4NJ5NKlS1u3YVIYQoER3ULf7sueh6oHT/ySPpnjSRoT2GL5o5c72uDZGQtd4p2XI9pZZYyJ8db+mDiK+erzY6KrJzbHJlW8MnmCfSpPPB/zi03+yP+f/OQnyzRXv/BPB/u8/M+nPUNafSjVj3KFXd2n9YKjOl/dHrFy6vJa9R47T+dhtX2OUGyVCYXz1FjUx8f6f9W+VeX6oOsaj7XaRYgTGKm6teo/dm3zykCsCwryE/iQ0fZDMkmS5Lhxzpw5bV/aiZ7ek/HBdpRcuXLltO99jl/fuqhNjiVxjJDNc8WKFSPPI4QCI7qFPt6XU6JgzvkpcTBnnxaO8ZgqArS1P1e4tmJl42fVfASeqIkCr2dfLJyPZYtX1iqioSV85hyrz7FijWNa1ra1a9eWHvJrjvqTwe6Hvrjc/6//+q+1+kBOOS2bPMHXEoBjbYFtm2u7NzZztlvCfWwsYdnw/9ikQqxvoa05E096nxeCSZ9rXYtyJn08ezBtb9LCS5tYFxTkJ/Aho+0HcZIkyXEk0R306Z4sD7zhx1XbfXhYrlq1qvxcvnx5LSGu6Trw7JgkLly4sJF0Zm+ymbl97pJt3HPW22jTSnnUaf/wqn7bdVyH8+fPb2RyQMacx4033ngiJ8BiIUKIdtCn+7IlIsUE4ZRgnyPWevtQvK3iDRxLPyYWWuWzxEidfkpwj9no5Yn1ECuXJVTmCoGeAOoda4nPOXlom2Kx6WP2BTz66KODAw44YPDMI15cLuj6jGc8Y/DYY48ly1d10sHL39vuxfWPtVXKnty6je3zBHi9P7fd9TEYm7+KbWhTKqyTl1ZqvQJ9Xqx/eedXGUPe9YSIgwrCBD5ktP2QTJIkOW6cO3du25d2oqf35IAQ+1P3p5wQNp542VeBUnjiiScmj6kTd38Yz2evrnNs9Y7LPXdYjqI/LNhhz+Qxi1Y1P8GUEp9HVd4cjjLslExk6Txmwsvcq0ssqxzX9HoYOe1tkeFquom+3Zc1rFjyMc/VKsgVHK18csTwKmKldZ7nHZwLL/2YrZY4n5tvTn65ImlsoiJVHznbsC2r1O1LX/rSwbMPPmzw7IMOHRx//PHJ4yX9KvVYBZ79qcmeKulXyRf3eWMlt168PonrEeTYnGtbFaTGV6reh8kbBf9hroeTCAryE/iQMeoHeJIkyUkk0R306Z6MPwhmSqiN8eijj84+NkeES4mkKHjrhaY8xupJh+KJHVc1pneTYm+dcEF18x+2T22w7Enl50Zb7Zg8dvHKp8+IYBzzph+FKK/LExPfZR/WeY64bR0j6dQtk6QfxjSO1aavNTnjNkZtT10xXshFXbuHvt2X8f6cWpg1FQYilnauoF5V5Mr1UJZxkyPWVfGYrWu3nFNXkK8irHp25wqXVT2Oh7VL8MY3vrG8LwSeccYZWbblei/X8Ziu4hld9focm4yK2ZTap4+pM0mhv1thk6qM7WGQ29+GHZNeOnjPpRhfDVQQJvAhI8Q6bvIBnCRJctLJRV27hT7dkwNCvGMRaXVMyJRgHs4LD77hU9LIoSWWojinBeOQtt6vBXv07hdq8a+KbZh3VYo92q5Y/tpz3itLrJ6GtR2PD/Xmia+xyQ+rTXNsedGLXjTYddddy/+XLl1Wfm60/CmDJbsdkmU/Hid2PPOZz3TPqdofsF2k/8XaS47BOgt5o3CM4r6MQ6utY5NVYV8VUdqyPzYOc6jLG+urVj2EvKxzwnZta50+LunG+nCqX4Q0gs2BsWMZrqab6Nt9WSMlMHnhR8K2HJE0lq+VRo6Nlle/lyYKksMKarllr5JGjtBeR5hs4rimzvUEcKtc73vf+6YE+Q9+8IOuB3ddj2irvmPtWqWf5h7r2duEF3ZT7RPbP5PC9LDXlSpjAs/NDUlF2KAgP4EPGfPmzav0IE2SJEnGueGGG7Z9aSd6ek/W3mmaImBZAqAW0qqKmyj2WuKa3pYjGlriHtqFAr+Oe6nzkXATYZ8nbkra+hhJP9SnbNPHWXVgibVoL9ZXsFOXJfwv+Wl7PbFY54Fta7W1nqyx9oU8Y8K0ZVOq/yxcND1e+HZHnlLSSv9Jh5wwbXLjrW9967Q6F/vCpxatrLZHe0R81Wnp46yxk/t2hKQrx4uNsj1nYiycK22gj5d21O1p9WWrv1l2SjpyTGzM6jLE+ppVN7FriW4jKUus30la8mmNG6/P6zSknXU76f5lkT/8u4k+3ZfrwFqYdBjh0kvDO0anq6+ZVdKsImpXtVunW9fL3rPLig1u2VDV/mHqoQlxNlZnH//4x6cE+fe+972V8sz13raOSQn8dSaPcvfVOc47t8447PL9JWeseGOjatm8iaO+1l3boCA/gQ8ZXOSMJEmyWQavUKI76NM9OSAl/gURSgvNIrrlCNWaEutS77PyDvvF8x4FPEtIkzRQhEO7RFyTh3Mt7GmxFn+Eokgr2+XhXtcLpu2J9Gibrmv5XwuIljexV29Yx9gG+L/OE//3JmwwTe0Nqb278Y0BEY08cVzzSat2nvp/p1e+pyQK88G7PPDggw+eZouVpt6m21DqS9pTbMW2wTYMx+s0vUkLPamh05RztZhtjSWvX+t0cAxowVvKpkUybbcul/b+xjdmrIkfzMvqR9rusF1PzIT0UVhPvQWCi9DpyUNdFmsc6H6a6tdyLLazN3b0pBzRPfTtvlxXlEr1wRzBuAnv3WHCgsh9eFibrDzqCPMxGyS9nDcB6qRdxz7MexhB0jvni1/8YinGyxteTdRlnWM0LE/pqkJ91b5Rpx/l2tPEOU2cm0rX6l/W9SBWt1WuFzNdd+MOCvIT+JBBD3mSJMlmufHGG7d9aSd6ek8WoJArojs+xGqBy/NKlx/UKLZqMUynbXlhW+IjCndagLYEdfkfRegAtA1FAPwhi6Ip5oehAtAGOVf246SEzl+XFT1yRWjEtgjbrTbCOkMhGtsGRefUxAvWg04z1JkWu/GHGIrI+L+Ob77Tie8c7P7nnyi56jkvHax62k7l9mOOOWbwpS99aeo4EWctYd6bWMG+ITbrthS70QtVT9roOsQQErqurLwt6v6gz7PKofPS+etjrUkIb5zofqPHhS6/JVJrgR0nwPD6gH3AmsiTsuhxjvUfoNtde8VLGjpvJF6r8K0IfR3Q1y1sH+xHRPMI7bjtttuWvyX33nvvwZVXXjnW92UPMYG1ipBopTGMeOshd0zgdSUlKOdMLnj5NFnOYSc2cmxJpWWJ8HVsyUFI67LLLpvykL/gggsaS3sYm/D6q7fltnWVvqGv/10WfHMEc+ucKumm+i4+01jPgjnXsyptQ+SBgnxD6NNDxuLF019FJkmSJIdjWICO6A76dE/O+UFiebqg0OwJ9SikWeJ4gAjKWgy1vMq1mKnTwwd6/CGP4jHaiqK+rgt9rE7bEg50HWG6uj4kH+tHA4qpXigCKw1L/EThVaeF3tP6OG2/bke0CevA8z62PKTkUwRZ3f9uueWWwUknnVR64K158SmlGL/zy38XkuaQQw4ZfOxjHxs89thjU+foSQy0X9tg9U+caIn9wMS+hSIy1gP+8MS2xjq2xGcM/YB1aPUtHEd6v64bbDPrTQAPXn/QE0RYZ/iDGoVtnCBIiXJW3VoTEdb/Xp1a7Yfto+vQmpgjmsVnPvOZwdy5c8txf8MNNwxe+cpXDhYuXDi48847J+K+3ITglCvSVhHuUrDuqzH7vHtjTJjLFems/IbZ3yRyBM2ZtDfWN4ItX/7yl6cE+euvv752ek0iJujic12dtLzjRlW2UbVnqj9VGU9V6ilmi3V98H6H5IyDOteDSQUF+YbQp4cMvYAZSZIkOTyDdyDRHfTpnuwBhSdPgEUBC0U2L20UhyU9T1iPec15gjX+jw/3lkioxUsrD6+ecJucg0KjZZ+VplW/sTJax+CxOCGBi+5Z4r71wwbTt34sSfrYplaasR9Pjz766ODYY48b7H/AgYM9TvvHwTNeeEIp0F911VVm2bVwbZVFH6dtwj7tlduyXdddLE+rnbxyVxGxtB26vnVbW29wWHnheMsV0WLfc86x7LKOqyJ4ez/iY2M2Nd68N0pGKcoQv0PwiD/11FOnvj/++ONlGNSzzz57Yu7Lw6COSNWUsFV13NY5tunx1zVRr0lxdNiyh+0333zzlCB/66231k5vJuoXn6m61K4eRm1njqg9U0g9J9W9dhF5oCDfEPr0kOEtHEWSJEnWo7dwFtEO+nRPtoAPv56naE46uXnoh27vx3uO15yVdo5NuSJ4LqoIs6nzLRvr2KPrVrftKGxJ1WGVOr7wwgvLH/3PfN5x5ecpp5wyeOKJJwZ1YfWzVLvH+kcsj2F+9Fb1tkYbcdIgdo7nnTZuAsWwwpCuV3yjY1jbCB8PP/zwYPbs2YPPf/7z07a/4hWvGDz/+c+fiPtyExj2XjZpGKXg3zSavgal0vn5z38+JcjnvKXS1DNN3fL1qS2r2tmX8gyDSShjW6Ag3xD69JAhF19ZBGQmFz3UnzGGm0sbolp49dLb14XFcFP1osMRVWlfHSd2FJwzZ85g6dKlrddfTnvutttuWf1hptnUeA2hVbCvhB9Zw9RZk7SuD2JzU+mNghTku4U+3ZM9DCtK5/zQqiuY5+Y/jg/8w4qRXbGlCqa85P/7x7/nHV8FM9E/RlE/o/Bq60O/b9LWtjwOifoI4l+4/l9xxRXTtr/hDW8oPectPPTQQ+U9WLh27dre35fb7Hdt5dOFcdWXCbeZ9KL/9a9/PbWo6/333187napifB/aYSZRpU66VG9dsmXSMSv8KYihcd999xWbbrppce+99xYLFiwouo6f/OQnxXbbbVd+/uxnPyuuvfbaYtdddy223nrr4qqrriq23HLL4l/+5V+K97///cVnP/vZ8pywTY4LCMcGXHjhhcXdd99drFq1qjzmjjvuKPbaa6/iAx/4QLHDDjuUx4dtxxxzTPG5z32u/Pyrv/qr4sADDyy3yzl33XXXlA3BtnDsFVdcMZXG17/+9eIVr3hFaV84dunSpcWNN95YbgtlkDRe85rXFN/85jdLW4844ojy+HDc4sWL1yljOOfFL35xcfrppxfPeMYzStukTqQc4X8p7/bbb1+8/e1vL6677rpi5513nkozQMoS8g31Econ2zH/UGfyf6inRYsWFb/+9a+L0047rfwePiXfkN4tt9xSHHXUUcV+++1X1kvIRxDSFwT7L7/88qk6DGWRNgqQ+gjlCp+h7KE8Z555ZnlsOE6OkToO0PUc0pZPSeuJJ54ofvSjHxX/8A//UJbrt7/9bXHbbbeV5dpss82KJUuWlGMjpPOb3/ymrJ9f/vKXxe23316sXLmymDt3bjluwjgKnw8//PC0/irf582bV3Lt2rXluaHPhfRCfYTPDTbYoNhqq62m2uElL3lJWT+PPPLIlF0bbbRRWY+hLaWuAqS+pY5D+U899dSyr4Z8pD50vUh/O+ecc6b2BYT2Cv021KWGjBXpG2GMhX4n4yvY8r/+1/+a1le0XdJGus/JuNH9ICC0S0hL8nrWs55VHH300cUFF1xQjo+Q3rnnnlvaGsZ56AchXylHsFPGm+5f4RzJT18TwvgMecn38BnSuuiii8r+JXUcynTKKacU++67b3HWWWdNjT0pP16Xrr766uL8888vbZb6kvGk6zz8L2M65Hn44YeX30M5QxuG4/VxH/vYx4qTTjqpTDOMLT0uQ1lCm4fxEdpWoMdPODakJWMp1A3RHfTtnjzqe31X0yP6g4svvrh417veVeyyyy7lc8qsWbOKSUPo/+HZITzfcBwQk4TwzB2er8PvsjVr1kxtf+Mb31hceumlxZVXXrnOOW9729vKZ0vEON2XZ+qa0FY+XbrmjcPzR5P1+dhjj5W/ccLYC7/lwu/pmcA4tEMbddK1sdQVW4iioCDfEMb1x38fL7pVbQ6ibLihjSLtrqPN8gSRPUxshPHy4IMPVjo3CAH33HNPsdNOO5Xjbs6cOUVb6Euf0JNwaG9bZcjNt+v2Ed3DuN6TCaIthJ8LYeI9iHKbbLJJMangfYGYRATHluDQEpw6XvjCF05tP+GEE8rn8S9+8Yvmc752sAn35W222Wbs7sszdU1oKx9e85pFk/UZnJJ++tOfFnvuuWcj6RGjRZfGUpdsmXRQkG8I/PFPEARBEN0A78kEQRAE0Rz22WefYu+99y7fhg0Ib8euWLGifFP0zW9+c/J83pcJgiAIYjrWg+8TjxCOIcwWhdAX4cHjO9/5TtsmEQRBEARBEARBEEQreN3rXld89KMfLT7xiU+UoQNf/epXl+EiTzzxxLZNIwiCIIheor04Dx3EP//zP5cPG+edd14pxoe4yoceemhx0003TcWMJgiCIAiCIAiCIIhJwbHHHluu/xTWBfrFL35RrF69ulxbYtmyZW2bRhAEQRC9BEPWKAQRPizQJ4v4hVfxQqy71772tclX8fgaHkEQBEF0A7wnEwRBEER3wPsyQRAEQUwHQ9aoxWquvvrq4uCDD57att5665Xfv/3tb7dqG0EQBEEQBEEQBEEQBEEQBNF/MGTNf+O//uu/iscff3yd1+7C9x/+8IdZK8cTBEEQBEEQBEEQBEEQBEEQhAd6yNfE2WefXb52JwyhbQiCIAiCIAiCIAiCIAiCIAjCAwX5/8aSJUuK2bNnF3feeee07eH7Fltssc7xZ5xxRhkDT7h27doZtJYgCIIgCIIgCIIgCIIgCILoGyjI/zfmzp1b7LHHHsXXvva1qW1hUdfwfc2aNescP2/evHJBGk2CIAiCIAiCIAiCIAiCIAiC8MAY8gqve93rihNOOKHYc889i7333rt4//vfX/zmN78pTjzxxLZNIwiCIAiCIAiCIAiCIAiCIHoOCvIKxx57bPHLX/6yOPPMM4tf/OIXxerVq4uLL754nYVeCYIgCIIgCIIgCIIgCIIgCKIqZg0Gg0Hls4h1cN9995WLu4Z48gxfQxAEQRDtgfdkgiAIgugOeF8mCIIgiOlgDHmCIAiCIAiCIAiCIAiCIAiCmAFQkCcIgiAIgiAIgiAIgiAIgiCIGQAFeYIgCIIgCIIgCIIgCIIgCIKYAVCQJwiCIAiCIAiCIAiCIAiCIIgZAAV5giAIgiAIgiAIgiAIgiAIgpgBzJmJTCYBg8FgagV5giAIgugq5s+fX8yaNasYZ/CeTBAEQfQBk3BPDuB9mSAIgug65s/wPZmCfEO4//77y89tttmmbVMIgiAIwsW9995bLFiwoBhn8J5MEARB9AGTcE8O4H2ZIAiC6DruneF78qyBTFcTQ+GJJ54obr/99onxciCIUSN40ISH9rVr107EDxWCmClMwn2K92SCaBa8JxPEaDAp9ynelwmiOfCeTBCjAT3ke4r11luv2Hrrrds2gyDGDuEhgw8aBEFUAe/JBDEa8J5MEEQd8L5MEM2D92SC6De4qCtBEARBEARBEARBEARBEARBzAAoyBMEQRAEQRAEQRAEQRAEQRDEDICCPEEQncS8efOKs846q/wkCIIgCKI98J5MEARBEN0A78kEMR7goq4EQRAEQRAEQRAEQRAEQRAEMQOghzxBEARBEARBEARBEARBEARBzAAoyBMEQRAEQRAEQRAEQRAEQRDEDICCPEEQBEEQBEEQBEEQBEEQBEHMACjIEwRBEARBEARBEARBEARBEMQMgII8QRAEQRAEQRAEQRAEQRAEQcwAKMgTBEEQBEEQBEEQBEEQBEEQxAyAgjxBEARBEARBEARBEARBEARBzAAoyBMEQRAEQRAEQRAEQRAEQRBEMXr8f+ZMEy/VlctyAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqQAAAG0CAYAAADkeDWvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA81VJREFUeJzsnQeUJHd17r/qqs45TZ5N2l1Jq4hENiYKARY20TwbTDBweGAyJhibBwYMAvywjR8mmGxjjG0M2GSLHARCAWWtNu9OnumcKle9c/89NdvTOzM7Mztx9/44dWa6uvpfVd3s6Osbviu5ruuCYRiGYRiGYTYJ32admGEYhmEYhmEIFqQMwzAMwzDMpsKClGEYhmEYhtlUWJAyDMMwDMMwmwoLUoZhGIZhGGZTYUHKMAzDMAzDbCosSBmGYRiGYZhNhQUpwzAMwzAMs6mwIGUYhmEYhmE2FRakDMMwDMMwzKbCgpRhmPOKj33sY/j85z+P84Wtdj+tVgt/+Zd/iR//+MebfSkMw5xHSDzLnmGY84nLL78cuVzuvBFMW+1+CoUC8vk83vWudwlhyjAMsxZwhJRhGIZhGIbZVFiQMgyzqVCUTZIkHDx4EM973vOQSCSQzWbx+te/HpqmnXH8F7/4RTz84Q9HJBJBOp3GYx/7WPzP//yPeG7Xrl2477778JOf/ESsSdvjH//4Jc/vOA4+8pGP4IorrkAoFBLRv6c+9am47bbb5o6xLAvvfe97cdFFFyEYDIrz/Pmf/zl0XZ+3Fp1voaghHf+Sl7xk7jGl4OnYX/ziF3jTm94kzhmNRvGsZz0LMzMz81632P2Ypol3v/vd2Ldvn7hues8e85jH4Kabblryfr1z//znP8frXvc6ce5UKoX//b//NwzDQKVSwYte9CLx3tL21re+FV4i7cSJE+J4gs7tXRNHShmGOVeUc16BYRhmDSAxSgLsxhtvxK9+9Sv8/d//PcrlMv7pn/5p7hgSQSR+Hv3oR+M973kPAoEAbrnlFvzwhz/E9ddfj7/7u7/Da1/7WsRiMfzFX/yFeE1vb++S533Zy14mRNrTnvY0vPzlLxfi82c/+5m4hoc+9KHiGNr/hS98Ac997nPxp3/6p+KcdJ0PPPAAvva1r636nulaSfRR+pvEHl3/a17zGvzbv/2beH6p+6H3ga6Bro0Eeq1WEyL6jjvuwJOf/ORlnbuvr0+8p3Sv//iP/yiE6c0334wdO3bg/e9/P7797W/jr//6r0XZAIlUEqMf//jH8apXvUqI52c/+9lirSuvvHLV7wHDMIyAakgZhmE2i3e9610UfnN/7/d+b97+P/mTPxH777rrLvH48OHDrs/nc5/1rGe5tm3PO9ZxnLnfL7vsMvdxj3vcss79wx/+UJzjda973RnPeWveeeed4piXv/zl855/85vfLPbTGh70mO6nm507d7ovfvGL5x5/7nOfE8ded9118679jW98oyvLslupVM56P1dddZV7ww03uCvFO/dTnvKUeed+1KMe5UqS5L7yla+c22dZljs0NDTv/DMzM4veJ8MwzGrhlD3DMFuCV7/61WdE8AiK0hFf//rXRXr9ne98J3y++X+6KG28Gv7zP/9TvJYilN14a3rnp9R6JxQpJb71rW9htbziFa+Yd+2//du/Ddu2cfLkybO+lqKZlM4/fPjwqs5NkeHOcz/iEY8QqXna7yHLsogSHzt2bFXnYBiGWS4sSBmG2RJQLWQnVK9JwpNS2cTRo0fF4wMHDqzZOWnNgYEBZDKZRY8hcUjn3bt377z9lO4mUbgc8bgYlBrvhNL3BJUqnA0qWaB6z/3794v617e85S24++67V33uZDIpfg4PD5+xfznXwzAMcy6wIGUYZkuy2qjnVrweinouBEUgF2I5bnzUzEWC+rOf/ayo8fz0pz+Na665RvxcDoude6H97A7IMMx6w4KUYZgtQXfq+ciRIyJFT41OXsSUHt9///1rJhxpzfHxcZRKpUWP2blzpzhv9/VNTU2JCCU93xnhpH2dUOf6xMQEVstS90OR3T/+4z/Gv/7rv2JkZEQ0F613x/tW+6LAMMz5AQtShmG2BP/wD/8w7/H/+3//T/yk7nfimc98pkidU6qaBOJiETyyT+oWhYvxnOc8R7yWOs278db8nd/5nbmO907+5m/+Rvy84YYb5gncn/70p/OOo+71xSKky2Gx+ykWi/MeUyc+lRV0W1GtNWS3RSz3PWYYhlkObPvEMMyW4Pjx4/i93/s94QH6y1/+UviNPv/5z8dVV10lniexRdZH5AdKzT9kOUSeoLfeequoAyULJOLaa68V1kR/9Vd/JV7T09ODJz7xiQue8wlPeAJe+MIXCospioDSuUnsku0TPUcWTHT+F7/4xUJYkgh73OMeh1//+tfCBopEMh3nQRZMr3zlK4XQJeulu+66C9/73vfEpKXVstj9UC0teZLS8xQpJcunr3zlK+Ka15NwOCzOTdZUVL9K56aSAdoYhmFWzar78xmGYdbQ9un+++93n/vc57rxeNxNp9Pua17zGldV1TOO/+xnP+s+5CEPcYPBoDiOLIluuummuecnJyeFHRKtQ+uezQKKrI3++q//2r3kkkvcQCDg5vN592lPe5p7++23zx1jmqb77ne/2929e7fr9/vd4eFh9+1vf7uradq8tciO6m1ve5uby+XcSCQirJWOHDmyqO3TrbfeOu/1P/rRj8R++nm2+/mrv/or9+EPf7ibSqXccDgsrv9973ufaxjGkve72Lm9z4FsnTqh645Go/P23Xzzze61114r3i+2gGIYZi3gWfYMw2wqVPNIKXOaUHQukUSGYRhm+8I1pAzDMAzDMMymwoKUYRiGYRiG2VRYkDIMwzAMwzCbCteQMgzDMAzDMJsKR0gZhmEYhmGYTYUFKcMwDMMwDLOpsDH+MiGzbBoxGI/HeXQewzAMwzDriuu6qNfrYvAHTanz0DRNjCRebwKBAEKhEDYKFqTLhMTo8PDwZl8GwzAMwzAXECMjIxgaGpoTo7t3xjA5vfpxxMulr69PTNDbKFHKgnSZUGTU+z9GIpHY7MthGIZhGOY8plariUCYpz8IioySGD15+y4k4utXdVmrO9h57QlxPhakWwwvTU9ilAUpwzAMwzAbgbRAmWAsLoltvXCw8aWJLEgZhmEYhmG2EbbrwHbXd/2NhgUpwzAMwzDMNsKBK7b1XH+jYdsnhmEYhmEYZlPhCCnDMAzDMMw2whH/W9/1NxoWpAzDMAzDMNsI23XFtp7rbzQsSBmGYRiGYbYRDteQMgzDMAzDMMzawhFShmEYhmGYbYQDF/Z5FiFlQcowDMMwDLONcDhlzzAMwzAMwzBrC0dIGYZhGIZhthE2d9kzDMMwDMMwm4kzu63n+hsNC1KGYRiGYZhthL3OTU3rufZicA0pwzAMwzDbAs20YNmbEb9j1huOkDIMwzAMsy0I+Vm2ELbb3taL9Vx7MfiTZRiGYRiG2UY4XEPKMAzDMAzDbCYOJNiQ1nX9jYZrSBmGYRiGYZhNhSOkDMMwDMMw2wjHbW/ruf5Gw4KUYRiGYRhmG2Gvc8p+PddeDBakDMMwDMMw2wj7PBSkXEPKMAzDMAzDbCocIWUYhmEYhtlGOK4ktvVcf6NhQcowDMMwDLONsDllzzAMwzAMwzBrC0dIGYZhGIZhthE2fGJbv/U3HhakDMMwDMMw2wh3nWtIaf2NhgUpwzAMwzDMNsLmGlKGYRiGYRiGWVs4QsowDMMwDLONsF2f2NZvfWw4HCFlGIZhtjQNTd/sS2CYLYUDCQ5867itLGW/a9cuSJJ0xvbqV7962WtwhJRhGIbZ0sRCwc2+BIbZUthbrIb01ltvhW2f7s2/99578eQnPxm///u/v+w1WJAyDMMwDMMwqyafz897/IEPfAAXXXQRHve4xy17DRakDMMwDMMw2wh73WtIV19EahgGvvjFL+JNb3qTSNsvFxakDMMwDMMw266GVFrX9YlarTZvfzAYFNtSfP3rX0elUsFLXvKSFZ2Tm5oYhmEYhmGYMxgeHkYymZzbbrzxRpyNz3zmM3ja056GgYEBrASOkDIMwzAMw2wjnHUeHeqgnbIfGRlBIpGY23+26OjJkyfx/e9/H1/96ldXfE4WpAzDMAzDMNsIe4NqSEmMdgrSs/G5z30OPT09uOGGG1Z8ThakDMMwDMMwK6BlaQjLwRU17awlzqxf6Pqtv/KmJsdxhCB98YtfDEVZubxkQcowDMMwDLMCIkposy9hy0Gp+lOnTuGlL33pql7PgpRhGIZhGGYbYbuS2NZz/ZVy/fXXwz0HuygWpAzDMAzDMNsIe52bmuxVpOzPFRakDMMwDMMw2wjH9Ylt/dbfeEHKPqQMwzAMwzDMpsIRUoZhGIZhmG2EzSl7hmEYhmEYZjNxVtl4tJL1NxoWpAzDMAzDMNsIZ919SDe+opNrSBmGYRiGYZhNZUsJ0g984ANi6sEb3vCGuX2apuHVr341stksYrEYnvOc52Bqamre68iIlcZURSIRMbLqLW95CyzLmnfMj3/8Y1xzzTViDuvevXvx+c9/fsPui2EYhmEYZq1Hh9rruF2wgvTWW2/FJz/5SVx55ZXz9r/xjW/EN77xDfzHf/wHfvKTn2B8fBzPfvaz5563bVuIUcMwcPPNN+MLX/iCEJvvfOc75445fvy4OOYJT3gC7rzzTiF4X/7yl+N73/veht4jwzAMwzDMueJAWvftghSkjUYDL3jBC/CpT30K6XR6bn+1WsVnPvMZ/M3f/A2e+MQn4tprrxVzUkl4/upXvxLH/M///A/uv/9+fPGLX8TVV1+Npz3taXjve9+Lf/iHfxAilfjEJz6B3bt348Mf/jAuvfRSvOY1r8Fzn/tc/O3f/u2m3TPDMAzDMAyzhQQppeQpgnndddfN23/77bfDNM15+y+55BLs2LEDv/zlL8Vj+nnFFVegt7d37pinPOUpqNVquO++++aO6V6bjvHWWAhd18UanRvDMAyzPTmXkYYMs9Wwz8OU/aZ32X/5y1/GHXfcIVL23UxOTiIQCCCVSs3bT+KTnvOO6RSj3vPec0sdQyJTVVWEw+Ezzn3jjTfi3e9+9xrcIcMwDLPZtAwT0WBgsy+DYbaJD6kPF1SEdGRkBK9//evxL//yLwiFQthKvP3tbxclA95G18owDMNsT1iMMucTjiut+3ZBCVJKyU9PT4vud0VRxEaNS3//938vfqcoJtWBViqVea+jLvu+vj7xO/3s7rr3Hp/tmEQisWB0lKBufHq+c2MYhmEYhmHOM0H6pCc9Cffcc4/ofPe2hz70oaLByfvd7/fjBz/4wdxrHnzwQWHz9KhHPUo8pp+0Bglbj5tuukkIyAMHDswd07mGd4y3BsMwDMMwzHbBmU3Zr9e2Gcb4m1pDGo/Hcfnll8/bF41Gheeot/9lL3sZ3vSmNyGTyQiR+drXvlYIyUc+8pHi+euvv14Izxe+8IX40Ic+JOpF3/GOd4hGKYpyEq985Svx0Y9+FG9961vx0pe+FD/84Q/x7//+7/jWt761CXfNMAzDMAyzehzXJ7b1XP+Ca2o6G2TN5PP5hCE+db5Td/zHPvaxuedlWcY3v/lNvOpVrxJClQTti1/8YrznPe+ZO4Ysn0h8kqfpRz7yEQwNDeHTn/60WIthGIZhGGY7YUMS23quv9FILnthLAvqyE8mk6LBietJGYZhGIbZaN1Rm9333l8/EaHY+sUUtYaF//PwH26o5tnyEVKGYRiGYRjmNJyyZxiGYRiGYTYVe53T6rT+BTmpiWEYhmEYhrlw4QgpwzAMc040NB2xUNvVhGGY9cfhlD3DMAyzFM2WjmgkeEEJvO10rQxzPmCv87z5C3KWPcMwzPnEuYpRggXe9hXnDLMRuJDgrGMNKa2/0XANKcMwDLMhqIa54tesVoxqtoH1wnYctFZxLwzDLA5HSBmGYZgNwS/LG3cu3/qdS/b5EAlwPIfZPGxO2TMMwzDM6lDkjfuPnCxtnPhlmI3GcSWxref6Gw0LUoZhGIZhmG2EDZ/Y1nP9jYZzDgzDMMy2pGFqm30JDMOsERwhZRiGuUBpqDpi4e3bwR7zhzb7EhhmU3A4Zc8wDMOcL2xnMcowFzIOfGJbz/U3GhakDMMwzII0TB0xP4tWhtlq2K4ktvVcf6PhGlKGYZjzAPLGXI3P51KwGGUYZqPgCCnDMMx5AHljhme9MeumjvgGiUnHdeGTNj6aQjR0HbEgi2bmwsM5D2tIOULKMAxznrFRYpTQLAubxUaK0bqhb9i5GOZsuK4PzjputP5KGRsbwx/90R8hm80iHA7jiiuuwG233bbs13OElGEYhpknvOKB5Qu9iN+PC4GVvCcMc6FRLpfxW7/1W3jCE56A73znO8jn8zh8+DDS6fSy12BByjAMsw1oaPqq57qvxN6JhRfDbH1sSGJbz/VXwgc/+EEMDw/jc5/73Ny+3bt3r2gNTtkzDMNsA1YrRtfS3qnZ4rQ1w2wFHPd0Hen6bO3z1Gq1eZuuL/w34L//+7/x0Ic+FL//+7+Pnp4ePOQhD8GnPvWpFd0TC1KGYRhmWUQjHD1lmK2As841pLQRFPVMJpNz24033rjg9Rw7dgwf//jHsW/fPnzve9/Dq171Krzuda/DF77whWXfE6fsGYZhmG3Bdp8sxTDbjZGRESQSibnHwUUaCR3HERHS97///eIxRUjvvfdefOITn8CLX/ziZZ2LBSnDMAyzLWAxyjBtHEhiWy+8tUmMdgrSxejv78eBAwfm7bv00kvxn//5n8s+JwtShmGYLWp0r1s2IoELo4udYZjtO6mJOuwffPDBefsOHTqEnTt3LnsNFqQMwzBb1Og+Mmt0zzAM00lnned6sNK13/jGN+LRj360SNk/73nPw69//Wv84z/+o9iWC/+1YxjmgsTx2kgZhmGYc+JhD3sYvva1r+Ff//Vfcfnll+O9730v/u7v/g4veMELlr0GR0gZhrkg0Q0LoaACaZPGXjIMw5xTDam7/jWkK+HpT3+62FYLC1KGYS5IwiGuzWQYZnvirnNTE62/0XDKnmEYhmEYhtlUOELKMAzDzJvGxAb4DLO1cWYnKq3n+hsNC1KGYZgVUtd1xBcxiN7usBhlmK2Ps8W67NcCFqQMwzArZKuI0ZZhrtqn1LCb0G0F8cDWuBeGYS7sCCnXkDIMw2xTQsriMYWGpi/52oAcZTHKMMyWgSOkDMMw24y6oQsx6fNJc793Ewux2GSY8xVng0aHbiQsSBmGueBp6gaiwcC6rE2RyrUWh+GOyOjZopxNS0NUCa3p+RmG2Vyc8zBlz4KUYZjzjoauI7aCOs/1EqPrFak0HRuKT17WsSxGGeb8wzkPBSnXkDIMc96xEjG6HQkr6yegtxqu66JhGJt9GQzDrDMcIWUYZlOikluR89nOabtCo11jgQtHgDPMhRohZUHKMMyasBZidLEGnfUwbl+otpPFKMMw2wGHBSnDMMz6cVYxSs1Ha2TcvlBt53o0IK0ndVNH3L99rpdhmLXBXedOeFp/o+EaUoZhtg0h//p+hz5XMdpQl/b+bOhrWwvJYpRhmPMFjpAyDLMp6IYFnyTB719etzgh+7b2d+hYeGmBGF3lVCWGYZjzPWW/tf+6MwyzJTnbFKDlEAwoyxajVFu6FtTX4LrPtUFnszlbFJdhmO0jSJ113DYaFqQMw6xpans9BM9ajbiMb6P60M2K4jIMw2wGnLJnGOasWI4DZZnp8o0UPCu5rqV8LpumgRjPdWcYZpvgnIcpexakDMOcFcs+d+G3HrQnFvnWwOcyuGwPUooAc5SRYZjNxGFByjDMhch6d7evlrCydk1CnWJ0KZN/FqMMw2w2riuJbT3X32i2XsiDYZgLAvLQ3AhWU9O6nSZOUcnBSrEsG5phrsv1MAzDrAYWpAxzgUAp6a1Et4fmYp379XNskloqonmua28FmtbKvU0VRUaILagYZtviQFr3bVsKUtu2ceedd6JcLq/FcgzDrANbfSzmYp378TVIkRu2vW5rbzYxNsdnmAsOh22f2rzhDW/AZz7zmTkx+rjHPQ7XXHMNhoeH8eMf/3itr5FhmA3ifPWoXE1a+3yNTDMMc/7UkLrruG0LQfqVr3wFV111lfj9G9/4Bo4fP46DBw/ijW98I/7iL/5ira+RYZgVdMM7zsLiq9nSV5XebmrGpgq6tTDnDyrKeRuZPl+/RDAMc2GxKkFaKBTQ19cnfv/2t7+N3//938f+/fvx0pe+FPfcc89aXyPDMMvExeLCMRpZnTCKhgJbYsLQWs+dX2/ORSg2TG3Za3DXP8NceDicsm/T29uL+++/X6Trv/vd7+LJT36y2N9qtSDLy59LzTDM2uKXZfh8W088bidaq2gSWo5QXElEN+YPLbgGwzAMwSn7Wf74j/8Yz3ve83D55ZeLyMl1110n9t9yyy245JJL1voaGYbZQDTTEhOQNgPdbm7YuWzHgblAs1NQXl56v6EbK47o0jk3krrB6XyGYbYHqyqs+su//EshRkdGRkS6PjhbI0XR0T/7sz9b62tkGGYDCSryuqXoqdvdcV2EFqnpDMrRJV/vCTp5DaZGSZCgW6a4185pT7btiK/qZztHdBW2SbplIxLYOLe9OI9DZZjzEned0+qbESFdlSD9p3/6J/yv//W/5oSoxx/+4R/iy1/+8lpdG8Mws13aG2nZtFZilFLU3XWegXMs6Vmqt4rqLV3f4k1E3ddjOPaCBviKjwT5+rxPkWWIWB5NyjDM2aA/hevZa7oZbayrTtlXq9Uz9tfrdfEcwzAXjn/oYnSKv7WyPlJkn9gWPF84uOR71S2OfYsISqrBXanYpFGjiz63wolULEYZhjkbbIw/C1nALPQHe3R0FMlkci2ui2GYNWIlzTRLrjPb8b2U+FprUb2aa1/ua5YTrV2ukF5q1Cgb1zMMw6xxyv4hD3mIEKK0PelJT4LSUQdGHffkR/rUpz51JUsyDLOF7JGWShd7+zdyzvtqrJ3oNYt9aV5piUEsEFjx+RmGYdYbd5074bd8Dekzn/lM8ZPGhD7lKU9BLBabey4QCGDXrl14znOes/ZXyTDMqllJTeLZjltNfaNqqwjL4bnHumEhGFjen57VNDHRcAB6XdA//xy6aZ2x72zit6WbwoeVYRhmK+G4EqR1FI3OVhek73rXu8RPEp7U1BQKtb3yGIbZPCardfQl44s+7wlI6m5XTRPRZUT9yC5ooQ7t5YhRmhSl6SYi4fZ5OsUosRyf1GZTRzQaFBZUFOn0OtMpihkNLm3Uv1id6aqatRaZesUwDLOZuO46NzW5K3dfeve73z1v38UXXyymeK5rl/2LX/xi8dMwDExPT8Pp8tbbsWPHapZlGGYV5ONLWyV1NvEsR4yeq10QCU5PjC6EXzl77aY7ewh9Se+0Vwr5/cI6KbRApHOqXkdvfHFhHjjLeReKoC403aqu6Yh3RFPpdXTPNJRgIyEPVdtxF3wvGIZhNprLLrsM3//+9+ced5Z1rltT0+HDh/Hbv/3bCIfD2LlzJ3bv3i02ipzSz+Xy8Y9/HFdeeSUSiYTYHvWoR+E73/nO3POapuHVr341stmsKA+gcoCpqal5a5w6dQo33HADIpEIenp68Ja3vAWWZc075sc//jGuueYaYVO1d+9efP7zn1/NbTPMlsQwzzR3Xw/Ws8FosfR5dw0nRT4XE2AR2X9O17BY1303nWKUIBG70WKUoHOupxhdTfMawzAX7qQmRVHEWHlvy+VyK3v9is8I4CUveYk48Te/+U309/ev2rdwaGgIH/jAB7Bv3z7RhPCFL3wBz3jGM/Cb3/xGKO03vvGN+Na3voX/+I//EN37r3nNa/DsZz8bv/jFL+YaqUiM0o3ffPPNmJiYwIte9CL4/X68//3vF8dQoxUd88pXvhL/8i//gh/84Ad4+ctfLq6b6mAZZquyUJPNQoSD84UY/VtyVyCwqN6yu0ZzIe/TzmuZrNbQl0ycdV1F2kAT+EjonBqjlhO5vZDYyOY1hmG2ZlNTrVabt58Ce90e9J3ByoGBAVHOSQHGG2+8cUUZc8ml/3qtkGg0ittvv31dxoRmMhn89V//NZ773Ocin8/jS1/6kvidoFqESy+9FL/85S/xyEc+UkRTn/70p2N8fBy9vb3imE984hN429vehpmZGdFoRb+TqL333nvnzvEHf/AHqFQq+O53v7vs66IPhUQx+a9SNJdhNhMSezRpaKF6THrOcp0lR2A2W/pcOrplmMsybN9s4b1Wr+tmJR35bFrPMMxGUVtAd3j7Lv7Sn0FeoKRorbBbOh58/gcW7CWietFuSI81Gg1RN0rBQaonHRsbE9orvkQpVSerCl8cOHAAhUIBawlFO2nKU7PZFMqaBK9pmrjuuuvmjiEBTGqbBClBP6+44oo5MUpQ1JM+sPvuu2/umM41vGO8NRhmu9A5B10UtC8yS4OinWebx95ZG7lWYrSprmy2u8dqRWXn6zyP1NUwXW0u/5wbLEa7yw14Nj3DMBsJjYgnQextb3/72xc87mlPe5oYJU9lmKSxvv3tb4vA37//+78v+1yrEqQf/OAH8da3vlXUZhaLRSEAO7eVcM8994j6UAoBU1r9a1/7mhC8k5OTIsKZSqXmHU/ik54j6GenGPWe955b6hi6TlVVF70uXdfP6b4YZq2wrHaNqN5RK0q1lOcyz3096gMjocWF7VS5vibi8WxCkbr7O6md5T7rpo6e5PKawpZLUzdE1HUt6BbrPJueYZjOLvv13Aivx8fbFkvXd0Pabf/+/Thy5AjWtYbUiziSOf5CqS+Kdi4XCu+Srykp76985Suig/8nP/kJNhuqfei2MGCYzcCiWkzIiHTVinanrVeSwl6P+kBK/Yf9/gXLCHrT8WVFGRezm+ouN3CUhcWZ0lEHSmIzcZb7jPuDaGrGnNeo9x5qloXQCjtEPciWilkd5CFL7gHhTSwhYZjtgCtE43rWkJ7b6yl9f/ToUbzwhS9c9mtW9Rf3Rz/6EdYKioJS5ztx7bXX4tZbb8VHPvIR4XNKtlIU8u2MklKXPTUxEfTz17/+9bz1vC78zmO6O/PpMSl9cglYDApLv+lNb5p7TBHS4eHhNblnhlmMhZqJQkv8x7lTgC4lRlc6uWg19ZmLCbHF6i67r4mEZnyJmijvmhayYhKvNwwhiDvF5rKuu8P43rvn5TaEMWvLYh6yDMNsbd785jfjd3/3d4XzEvX1UK2pLMv4wz/8w/UVpI973OOwXpCnKaXLSZxStzx1xXvTnx588EFh80Q1pgT9fN/73ie8UMnyibjpppuE2KS0v3cM1TJ0Qsd4ayzGUp1kDLNerGTmO6XdlxvppOjlSiJ3q63rXCjCuVhEtHMKEtXHLiY0l3tN5LHaMPU1mR2/nDn3DMMwm4W7xUaHjo6OCvFJZZzUkP6YxzwGv/rVr8Tv6ypIf/rTny75/GMf+9hlrUNRSCqEpUaler0uOuqpLvV73/ue6CJ72cteJqKU1HlPIvO1r32tEJLUYU9cf/31QnhSSPhDH/qQqBd9xzveIbxLPTFJdakf/ehHRc3rS1/6Uvzwhz8URbbUec8w2xVRo7iCKN5SYnQtO8c9MapaBsJKYNmRSYPStD7fvO7/1XAuYrQ7Or3SqPJq0WwTsuSD38cimGGY5UEZ9fWcI7fStakp/VxZlSB9/OMff8a+zj/cy60hpcgm+YaSRQAJUOrOIjH65Cc/WTz/t3/7t/D5fCJCSlFT6tz62Mc+Nvd6CgeTF+qrXvUqIVTJjopqUN/znvfMHUNG/SQ+ydOUSgHI+/TTn/40e5Ay2xr699ZtGn82VMMUZurdKdFzFaMUlYwqp8d5tnQDAf98cWVYFgIdNZnd3qdeqn0xMVpXNSg++QzP1bUsOeiOTrc0E9GOiVO6bkKmlPIa+5WGFjH0ZxiG2S4R0rVgVT6k1IDUCdkzkZn9//k//0ek0Lubnc4H2IeU2epQCjzol5fdfX+2BqLpYh2RWACSDYTDAaimOW/0aPcIzaUiixQB7UyDUwmBLTlQHJ8Qr67jzhN6C5UjrGXEktZSVQORWQFcM3QkuIOdYZht4kO655/+HPIiw0DWArul4diL3r+hmmdVEVJ6M7qhqCY1KFGKnTxEGYZZHtSME/H7lyW2lor8LdSFP++1qg7JJ82l7z0xulgtak92vpmxJ0YtpwHFF1tQjBIL3Ud3TWa396luW/P+GJEIXmzd1aT1u983WssTo8RCYnQlNboMwzAXdM5+DVjTdkby96TGI4a50FmJ1yYJvaXEaKc5+krS0CTculPzC5ngk+jSTFPYSy11bg8So2sNzYMnHMdFi2yYlhCcq6kxXeh9O1tyiMUowzBbFned59hvQsp+VRHSu++++4w/7FQHSnPpr7766rW6NobZtqymLrM78udF9ZYrQikNHlROp+xpre4o32LCN+T3i3/H9ZY2byb8WozmXAnqWcTocmpDyQz/bP6jIloMaV6NKMMwzHbB7TCvX6/1t4UgJdFJ/2HrjjBQ9/tnP/vZtbo2hrmg6BZi3aMxzyZyF4t+LhfTshFepan7ajr1FxKX52r9RHSKUbonx3XnIrBz6/A8eoZhmC3FqgTp8ePH5z2mTnjymgqF1q/AlmG2GpTiFlNlOszYu7vH14rFBNRCRvrG7KjRwALd4EsJx0CXaFsJ7gpv2buOzvdrutpAPhE9wyx/MZFK3fyRswho/xp3xC+XtbTSYhiGuRC67Ff1XyBy4meYCx3F5xNbJ7plIxI4uzpbzohMmmHvdZ4v1mBDYrRblJIQ7cxekGi2HRchEpzS8kTTSm2T6Px0HrKVOhveeem6FfgQDrbfr57kmbWpnhhd6P2iMoP2cxrigaW/DFOklN6TTtG9mEvAuVJpVZGKnNn4yTAMs2a461znuQmCdNWhHJo3T2OiaOwnbb/3e7+Hn/3sZ2t7dQyzzVgobU5Q2pi66T3OJkaJziajpVLvC0136owyGobdFqPdo0aXiOAtR4x2N27ZriP2UWPSUnjnpev2fEVrqrbkaxZ6v3y+9j2eTYx6kdLuCPB6iFEiEY6uy7oMwzDnM6sSpF/84hdx3XXXIRKJ4HWve53YaC48+Y/StCWGYeZDs9E7PTw7oUjhQiw0w76pG2ftDu9ee6HGHfIUPRuqtfgx1XrrDEEbUvxin25aKzoPiViq8Vyoy/9s79FWxCetvvSBYRhmJU1N67ltC0FK5vc0qvPf/u3f5gQp/U5d9u9973vX/ioZ5jy0e1qsBnSptchDtLtTfqpWX9SiaaG1SdAapn1W8eeNsvQe00SmyUr7XKElPE8p6uld+3JS+CRig4oyV/5AryVx2ilmF3uP1upzoPekqZ2OYDMMw2wLH1J3HbftIEiPHTsm0vXdUNq+u+GJYS4kvKih8NPUzy5wlhJay22K6U20DeyXW/NJ5QOJrrU7BZx3TZ5A9B7TnPi+VPtcwa7obd080/O0c43FRGC1pULriKh6r6XXUbPYQpFRqqf1pj+Rof5CrLShiER+NMQWUAzDbA/cdfYh3YymplUJ0uHhYfzgBz84Y//3v/998RzDXOhQfePZOsA7WajukpqESDyeDTK1LzWaoglqOdiue8aX39V0hFOjkWFY0HQTYV+XQFX1BSO2nTQMA8lIeK6+tappyxLsXj0tTX8KypweZxiGOR9Y1V/zP/3TPxVp+jvvvBOPfvSjxb5f/OIX+PznP4+PfOQja32NDLPtWOnYSRKV3QKWonYUeUyepWmHxG8mNr+RZrGOdxKt1IW/UId993x3r5yAIpiyT5q3Hl0XNRqRIO1M34v9/iDiCwjc7vIEStPrliV+knj1L+IdtVCH/XJdANh+iWGY8xYX5xWrEqSvetWr0NfXhw9/+MP493//d7Hv0ksvFXWkz3jGM9b6Ghlm27GYGC01WsjEImfs7xajnuBaSIx2i7GArMwTjVQqQN7A/gXKN2cqDeTSMSHSOsWa93vnfHcSj5QSpwgmiUJa24t6Uof6QqIwAFlYLFFXO0V9NcNEZDYV7olRT5h2zrdfSlx2ilHPe3S55QmbLUZZEDMMsx647EN6mmc961liYxhm+SxbSHUdZzr2XJPRQmt4ae/27/45S6Ru+nPJhaO5s6JpsSYrqaMawDt/53WQgb3P3677FI81A47PQXyBYRkLrb9UcxehWSZkyTfnPbqVhONSr2UxyjDMuuCuc4R0uzQ13XrrrbjlllvO2E/7brvttrW4LobZlsxruLHObLihdDml55dTG9oJTTTy1vbo9DXtPHenGO1sCpqstjvkO8USCcnOaK7PPr02RUC9Gk1PWHkilJ4jIeZFTMnAvjOlTw1Cnj9o5zVQ9LTTFsqDxOhSNaeW6Yj1O++NSgxEd3zX+yD2qe19Z/NE7XwvVguLToZhmE0SpK9+9asxMjJyxv6xsTHxHMNciIgUdmfDjXI6aknCzyOgKMKXtPu1RIsii10iioQfeXx2rkfYlnPWMgHJPb1+XzJ+Rke9EpBFvWn3ZCSKdHZHYr17oPQ9PUdCrPOY7o76ufR+x3VRKr97rvx0pS7umdbqvDZqlpq7t3AQlt2+32Kj1Z5RDxu22x7d2nkPomN+1nu10zrKXORLAsMwzPZD2oBtGwjS+++/H9dcc80Z+x/ykIeI5xjmfKZt6WTOi+gZprVkOp6EXrM5G8GcFaOd4st7LdVbUhSw1tLmRzLrmhj/6dE0jQUjc01rfqd6Z3rdsKx56XlhSK8oIvLYKZjp/roFM9VuemKVajpFdFTVxZpira7oJu3vfD9m6g3hLdoZGab3jOhJxaHOeoB23pM3NpWoqxqcWeP8bCwihK0skXepArVlzHtvun1bPeg+u0X9ubJSv1OGYZg1wWUfUkEwGMTU1NQZ+ycmJqCs8R98htmalk7+FX+BjEbbYqultqctUUTRno36dSJmvMu+ef6e0XhI1Inqs1HDqD9whmgkXLMr8krC0WyL1IZmzI+izh5KYtQTmyRGqdygG6rd7BStIjraEbVcSozTMRIkcb8zzebC701HM5WH9x4Q8XDojNGfc6+NBufV0J4Lnfe4HDhdzzDMpuCyIBVcf/31ePvb345qtTq3r1Kp4M///M/x5Cc/eS2vj2G2LJ3irlsskcdm54hPL4JIKeNIOICGbgi7JLlDdHlQitvruicLpc6xoS3TFCKV1qt1+XZ6YtKLWs4JR3+7lrOzq71TRHaKQYq8krgjETtVa4h9NJ2JRLh3XGc0lLr5ScR1lxlQWQJRqDaEcA7NPu6NxYRIpghw93tG5QqbHbFcSBhv1LkZhmEuZFYVVvi///f/4rGPfSx27twp0vQEeZL29vbin//5n9f6Ghlm06F081JTh7qJdcytJxGq2RZi6LBUWma3vddh7pdkkX6eS0H7gZbZFnAnC2UMpBMiEulZSi3Y+b1ERFcjP9GA0jGVKYTYbEN7JhrG2HQFvdkEKk0VucRpz1MRmfQrmCnWkc+2a1Q7ycSjQsx61yJEugLIC3wXDnVMf6q3dMQ7xKF3fWfrht/MiCVHSxmG2TBcqb2t5/rbIUI6ODiIu+++W8yzP3DgAK699lphiH/PPffwpCbmvGKyVhM/LWfhKUjLiepR3WJotlt9JTWMXhe74pPnpjB1RiIj/rY4HUwnhWAOB/yYrjbmiSPVMOfS6tTh311jSpTU5lx6nNYhT9POjnyKZA72pMQxTcuY10AkrlPXzxCj1PhE199tP0UNRzSClEoOuuk8tlOMdpYwrJfo4+gmwzDbCddd/22jWXXhVTQaxSte8Yolj7nhhhvw6U9/Gv39/as9DcNsGNS40+3h2ZdIiJ/U5d4NicVIRyS00dQRm60T9aCIYEszhRj0LI+6RVWnBycJSGq+IQE2r8En2BZkZDQfDNCEIxuRgH/utWSKT8096VgYLTKjn402kkidKdURjPqFKI4qC019csX5vLUoEhzrmutOIpWioTsz6dP3q+qiiz+2QJrbM7PvrE9d7nSlbhTJd7pUwF0fUbrYmsv1J6WGNa9GmGEYhtmgCOly+elPfwpVVdfzFAyzZlDd5mKG8gt1klOnNxnWe3SLUS8i6MiuiDLS8QuJm05bJBKQnc084ryzTUniGkMBtCwTju2I6/FeO16owqfQdCZZiFG1wzIpn4kjEQzBJ/mEoJ0q1+f5lmbCsTOuAx29VuTpSYL3jHtzlq65pDpR3+y9CL/TRcRod3Syux7Ve088q6mNxJtodTbWU4zS+99Zj8wwDANuamKYC5duQUXpdy8FT5HP7lS214gUVc5MTy9FqdJEq6VDt2etkPyhed3fFH0UwsxtWyfRNphPicjp3LUt0HVOoo5S8q58uimLajO7EZHMcFCIIBp1GvDLc6b3XvqfoqnRBaPBp0sYEpEQwrNz7qmJazG6RSYNDlgO3ULRe3zG/q4vEjPV5rIN8xe6vo2GPFXpiw3DMMwZNaTruW0wLEgZZgVQI9FCU5ZIAHZOKpoTPNL82shuGl02QyTcErEQbBmQpY7JR5GgKCnoRnSqdyw/U28KYeyds9MI3kuZx/zU5d8+ryxLYgoUTTvyRK8nvEkEUZMURXYJs6ODv3vMJ61Nx3tz67vpTcdRbajzjOoXoq7qcw4DKxWKc9Okuvd3fZHIJ9uNVgzDMNsVyV3/baNhQcpc8NBEIC/ydzYc60zT+O6RnMJ+abYJyZvt3j1CszHrL+rVX3pRvFgwIAzh27WcbSE4XWqvX9HUedG+hSJ3+Xh0njCet7Znkk9WULOCko6VfT5EA4El0++q3S4boPeJamE7jfs7114Kqk11jKXf5/gi0chuf9Du93wxvGEEDMMwzNaGBSlzXrKSrmnyA+2u21xsLbImoiihJy5JKHkjOT0s2xYWRURnCrszqkid5nPr0/SkWUFHae/pcrtTXjUMHJqeQU+mvf5AMnnmOM9ZwdXpPdoJlRTYCxQDeZOWvEipZy9FNbFNzRCTkTqvLyyHhMcpiVmKLpJwpGs1zdNlCpTe76amasLblCDB63RVEnSK9KXoFsudY1C7xWqnaD8fG43oC483IIFhmAsU9/yrIeWxSsx5ybnW/VEkkEQqibTO2kza57qSMH6vU1NRZH43OdWSkkWTZ/q+nOvoNNintHdPut1kROzJZueuZSFIcHmpePpJgpkikYZjwgefiLJ6XeoisqlryEajC16X5yTgD8kLXh9FUcU6tgPbdeZS+WTULwz8F6jLTITnd/WTKKfSA1nyidIHX0edkif8u69tqe78he5jOdFaEtPkaLDc8oDVoAtHhDPdGc4V+kLgX6PJVAzDbFNc9iEVNBcZ/9cNTW7KZDKrOQXDbCpegxKJtO4UOEUQPXN7r1bUi+BVGiqi1Jnd1UhDqNrpqNZCz3cLM5rPTkKUhKTXGT/vOE1vNxKps81PoaC4boo6Bnx+MdWJnvfM9EmAkRjtprMhi85N91SutcR5F7ouw7CE4Ka6U8215qZJZToM8zujylOVuhDs3j2QCCSRTw1P87rHpbbApGO9qCe913T9nU1IVPNK20JR8OWO/hT1rusoRgkqhVgvuAaWYS5w3PMvQrqqv5g0kemlL30pfv7zny95HI0XTaVSq702htk0yGpoSSsgrS2ayEapE9fvLhqlIxE22aid/cvn7L9Kbw0SbtQU5InK8VJtznapHVGNt43oqS7VIcP89rUrrk+I2jko1WuY7dS8bQtBR2NBqSFLN9plCF5KPp043cxECPE3e82ud33B4Jzf6GLQdfWm4kKwU7f4Qu/lQqNMRXrfdSH5JHGPZ7zPixTdL1UHu9Hm91QLzDAMw6yjIP3iF7+IUqmEJz7xidi/fz8+8IEPYHx8fDVLMcymstyIGtWCdkbzSDyR+CGx6E1HIvpibSP9TmpGux6ThF4y5J/nH9rdHCSM2Ls62ImZRkNEBUkoD2QS84QhIdlARA6I66HIHNlNUfq+04oqEQtDlmU0G4YQc4ZuCWsmWheyhIbedS16u8608547fxLlprpg/SoJTTLo9wQrRWs773EhuqPG9J57Bv+d3ft0f6J0YoWf4dnKJ5a7DsMwzKbjcoRU8MxnPhNf//rXMTY2hle+8pX40pe+JObaP/3pT8dXv/pVWIs0WDDMVmOpiFon/oAM3bbmon4eFL3LJ6JLjhBNBE7XUYaV8DxBJ3fVhpKRfHGB5qB8LCaEWKdoaznmXOqaxBZZKnlij9LcJIDrXYKXhBzVf9K//EBIEYKP1o0FAvA5PhTrTdG8RJAw9qLB9JMiliQyCa+pJhkOwTTsBUVdqGNMKv3e2eW/kKsBPd+y1EUFpDfpau752c9ubhLUOUZAl/v/BYZhmE3H3dqClAKV9N/HN7zhDct+zTkVOeXzebzpTW8Sc+3/5m/+Bt///vfx3Oc+FwMDA3jnO9+JVuvM/7AyzFbGEzWdwooigK7jzjX9dKepPf9NEodkzSTW0XSRAu9cp9Neip4jayifLAnvzUMTM2I/CUQSk140lqKU05VGu1bUMkTdo7duTyQmJjJ5wo1e1zlZiH6SjyiJR2rA8qAUv+Xa7UaoDhFHqXWqDa2qqtjv1ZDScVTD6Y0P9YQ0XQeJ3k4hRz6q5VlBTc95U6a6rbIWGiIg7l8Jz3tM105NYgSVECxk+D/3uUmL+7suB8+qi2EYhlk9t956Kz75yU/iyiuvXNHrzkmQTk1N4UMf+hAOHDiAP/uzPxNi9Ac/+AE+/OEPi0gpRVIZZjtADToUAZwTdx3+oNRRT9vZUsxuh1glEUdpeW+dmq6jZZtzwoyeoyafsOKHzwX29+eFif1UsSZEH4lcL33fk4qJWlCyWFJtU9SOLtllPhst9ftlUccYDPpFAxbhTWYKyYG5tD+JZBKb4rpCQWQiEfFekABszIrfYrWJoCLPGdt7Xqke07WGeD+o1nVes5AtzY2/7IRKDxZq7OqOctK1d9Zidr9mzmOVvFVn75G+QAQCi9dvTs36up7JJuSoGIZhzqNJTY1GAy94wQvwqU99Cul0ev0FKYnN3/3d38Xw8LBI1//Jn/yJSN9TbekTnvAEvPCFL8R//dd/4cc//vFqlmeYDYWEIUVAu6N4BImcQrOJ0WJlbl/3RCNPGJHdEqW/qS7UE0qewEoEg8IztNpU0TDa4kyXbHEcidaZSkO8tjebOENsUmSVrkGGT9R+1q32azrPPXe+2Z+iztLnQ7HWRLl+OlPRPZNeGPDLPiGCvVIEeq038tNHllEBF+FQO7VP1k/lVhOO68wTh8lI6PREJ8s+bfw/+x5FQmc2iS3U+HW2Os/O15DH6UIjNRf7AuHRO+vr6qGqhogAL/WaTpZySGAYhrmQJzW9+tWvxg033IDrrrtuxa9dlZndH//xH+MP/uAP8Itf/AIPe9jDFjyG0vZ/8Rd/sZrlGWZDoaieZxBPc+EbLQOZZERYDkWCfuTIKil6WoxKAVeISqq77BRKFH0kQ3yqc8wnY2cIrHQ8goBPRiCgoNZsoT8WFY1HRCYROcMmqG5oiAdCwrg/CkdES6ksoD+eECI6Eg20jflTbRFLv3u1rPTllsQmpbi9iKow4A8GMVmrtY35bRexWEg0QFG6v7MUwbO6arQ0hPx+WI6Futq2XKJ0PZ3LMG3xnGq1o7bdozu92lbCE44UiSVR7K1P61F1guKVAFiAJEvifTmbtVG3x2knnd6sZ/MlDS/Q/b8Uy/E5ZRiGWVfcdU7qzK5dq7VdXTyC9N+VBRpviS9/+cu44447RMp+NaxKkE5MTCASiSx5TDgcxrve9a5VXRTDrAVUExjoSPeSITsJqE6h45m6e53tVEMZCLZrCaMLzGWnyKSo75xdVkwrchzhzekZ6Odm/Ti981NNZSQQEEJGRCEtCbFISAjDaKgtqihCZ1ptQes9dnUXCECIQS89Xiw1kUiE4Ei2EJAk4KhOM+YPta+Nbs1tm9iTOCVBSBFLirIG/bJIZ1NKngThTLWJ2GzdKjU/kcUS3U+8Q+hRDSoJ0EZTE9OZVN1AraULMRyS2t3ucXlp03oSr5FwQIhSm0TsbHRX1NRaDmR/ex36Ru5NVuoUs511p7btzr1HS7GQI8Ba4w1DYBiGOV8ZHh6e95h03V/+5V+ecdzIyAhe//rX46abbkJo9r9rGyJISYzato2vfe1reOCBB8S+Sy+9VNSMKstMezHMejPPdH3WkL0bz9S9E0/EUMSORJKItM1GRMkP04QzF00kX1DqPI92GOhTZLUtptrnT8faX95oDXodRVB9kox4ODwXtdRpLOfs9dE+Gw4cxRZrS7ChGhYsn4Z8NimuIZ9IoNBoii530Xnu7zCXn71+W3KFWKXuebp3w6bztsUfQbWpREtvRzhFx/+sb6moNZUw18Qk+duvCQcDsOC27z8wm74mETwbISWRRtFNukaqT/XssSgtTtdDx9L7SgKbIr/oePs7xeNCqXt6f/2zXwTonhdqcFpIyK4XLEYZhjnfGRkZQSJxupRssejo7bffjunpaVxzzTVz+0gn/vSnP8VHP/pR6LoubAeXYlXq8b777hM1pNTUdPHFF4t9H/zgB0XX/Te+8Q1cfvnlq1mWYdaUxTqyKUrZ3SkvuthJWHaIVi8qKSJhs2nd9ljO011F1PyTi0fP8B0lUUQR0lKrhb7Zf8xRv188pgglIfxI/UFUmqqI3lIdK0UhSaDSLPlkOCaOCQcCMF0NPoRErSnVdyqyKxqi2iJNxrHxAgbzKTRUDaZrIx2OCJ3oWhKUgA+W4yAgK5ipN5Gfvd6xUhU98Zj4o0EepfQeeKl11TTmC8RgOzJMUU3SlVQLSzWXQqxThDbY/kYcCvlRbWqwDBs92TgaTR2xaHAuLS7KIFY59pI+H2qsotIGeYHaUXGdGyBGN1L0LpdmQ0c0trWuiWGY9UOarSNdz/UJEqOdgnQxnvSkJ+Gee+45o7zzkksuwdve9razilFiVf9lePnLXy5EJylir4uqXC7jJS95CV7xilfg5ptvXs2yDLMg1AzkpXLPVTyQIKJOcs/CyItQNi1j0XIc1bIRpa732WPlliWigwR1v1M00KsFpWaekOzHXRMT2JNMCzE6b8qR484J4ojsb3tyWjZaZgu2c9p2iNLm08U6HPoX6lK9ZFvElgwH0VAQR6YL2N+Xb1+fbiKRpjGcQF86ObeGV4ZQb2pznp25WESIX4qYUic6CepQiKKnthCovfGYELzxUGgukjr3PlCK3XUguVTjqWBOl1sSGlb7fSaxmImfLuchMdoJlUFQVNm0DVEDKmp3Z6PQJPyp5IDWsW1HlBqQkJYgiS8EVFpAjgD0etGl3/HZqi0DpuS011yibpRKIUjLLtQMtVy2mhglWIwyzAWGu7Vm2cfj8TOCkdFoFNlsdtlBylUJ0jvvvBO33XbbvJZ++v1973vfok1ODLNaVitGu8VDpdZCKhGZ121Ooo0imVGlXeNYarZE/aUXXaU57JZtw7SDUHyyEEgN04CrttdOhIPzxA01C1mSjati/ahpmmgYItsiL/Udm81RU7QxKLc728UIUFkREUDDqQsTfE23UHcMoNkWWe1rqUH2yWgZBvb15tr7ynUhLHPR5Jy3p+M48JGJvqm3r8e2xX0FZyOaJEIJqqc1XFtMbupLxuF321354bBfpMRdGRhKtkf/doq/ekMTf6wcz0tUoiiyV6awdFc6nZ/EZNirMZhN9YvorCzNRaipfMAbGkDPeecn+6me9JkNY+FIAJ6D6VJ1o/asoFZkngXPMAyzlViVIKVxoZSuv+yyy+btp/qBvXv3rtW1McyqoagjiUcvctndTU3CxA9ZNDUFIM+JSrIuoteRpKFaRzKLJ0FFafFqqynS8yRC7dlwaqcY9TrfRZ2obYnHA5mkiEhaDtWIzgo6VRfiiwSkIvmEYPTDj1QyJEoCCEq7X5TPnr4f20FvKoFThcpc0xThzbinayYfU5pJT4KV0vOyIuFkuQxbsrErmxX7Z0p18T6QwKPygM7ShKGetvgUo0Rn7Z/EfVXqwm3AizDTGNBOQ3wSgAuJQDoHNXsloqF5XqJk0k9RahFxprpTzRCR04VqfL332BOfJEYpUutFO73Ib3eD0UJR0nrHPTMMw2xr3I3psj8XVmr9uWxB2tn6f+ONN+J1r3ud6LR65CMfKfb96le/wnve8x5RS8owmw0JIMVrhZ+Fop7UwOPAmYuAdjc1kTjzmqHIa1NYEUFCVVORmo1UUk0n1XhOtmroiyTm20fRhCPTFuvv7cvh6FQBfdk4pksNaBETjkQz5/2YrjdQrjWwJ59DLBKA36cI+yRPkHpG9p0Cm6KXfmpxsh2cmC6JmfYk1gpqUwjEgXhb/JKo1jUTtuFiZ09aRExpf3tkqCSinyReqXGKvE27o42m7dBhbeHna09ccmcVOK3l3SeVUoTCfpSrLeRmo5aVektEQMnQniKsNJ6UPovOdLx3b55A98QuRXRdw4Uc8CHib1taOZILv08W90yC05uKdbYGo4UEMotRhmHOG9ytL0hXyrIFaSqVmhcNov9oP+95z5vb5/1HnJqdqEmCYdabhWx3KJLo1T4u1HxC1keq3p5MZEmOEGepaDvZq1mmSEV76fWxYhV7enKiblJ2ZRF9JHFFTUiaZYk6S4pyenWVFNX0+30oaU30+ttiMZ+Kty2ZeoIYq1SRDIXa4z0NA3t27xBz670UOollFzaaqo1MNIyZegN9ibb4m6jXEA2GMJCmLnsLQ9kk/IqCpmkgGQoLIU2lB5ptiXGbpD0H8knMVBtC5JJITUbCsEMUSbWRDUTFulQvSsb5dE2dtbBUPkDn6aPrJ+/Sah2y0UQ8EhXvO0Vkqy0NWTnSFvqaISyzUrP1o8V6E4lQCP7ZiUlUC0sWVZ3QKNSgT5mLxApv1A7//LkpVw1VNF11f55iwpRxenTqYrRaBiKRlXmNMgzDbGWkczCvX+76W1aQ/uhHP1rfK2GYFdItRsnv07McEqMkSfjNNiJ5kPiZV3tIx+umEJokwkjYeeneEEXptPY8eKoFrRk6Wo4pZtrHpQAcnytS+ZUyCaaQSNVTFzsJRIouUkSSJjRRlJXqLFPhsLBCorpRqtkkSHiScD02WUQqGkJYDiISl3C0WEBPLD43llO2JKRS7YYdEoC3nxrHrnQaLctEtaViOJsSdbDlcgtD+RQUxScEHHmdDsQTiMUjmKo04FMgalRnag1Rmyr8Tme/Z5JwpddQZDMVCQMdVsOSTX+gZqc3KT7EFT+S0ZAQe5AlIaqr9fb7T1HgbJfzAL03DWf+hKOI0haJng3UQrW+mmaKJi4SwV563oO+DCwmRjvXpJpYhmEYZmuzbEH6uMc9bsWL00hRSuPncu0GDIZZC7pFpgfVIIrGHgkiJU3WQ90iRqSFyYBdCUAzTZGKJmFLEUCqY/RslIgeqtV0gal6Qwi0/lQCNU0XlkMUDU3625FVMqonn00SimSpNNe5rxlCbIZkRXSx0/ok+EioFvQGcvEYTk6UsGsgiz197XpRei01VZGQ1SxDNDzt6T1dS+pxeV+vEGP3npzAlcP9KNRbsCUH+VxU1IA2m4bodu+JJ5BNxYSg603F2s+1dBG5tEwbdcNAPhEVHf1KQEY8Epy7/8laHSEfmem3U/2aaor3mEQ8RXMpktzZcLaYOPRcEmieveimp7n2bvt9p8gq3e+8z3G21rezDjSqnLk2Xcfc56rqIjJOopq+XHQKXC+LsxXtmhiGYVaFe/6l7Fc1y3650Gz77rFTDHOuLCRGCRKEXoMNNfCQ4PHmsxMUDQz5/NQxhAJ1k1O3dygg6iupWYnEjGUbGK9VhWgUgpCslBJxTDdqKFYaotNdmMxLtmhaojWrdRWBkDTXTU7XR8KSalCn601R/+il5cmjk6KICnxCjOYyMREBPT5ZFDZH1B1PHp+WTdFBCy3TwsRUpT0fvqlD1UwR/RM+p4aFy3f248RUSdSDkkhOBMPiXIVGo30tfr+I/FJdJtWoUnqeXj9VrIlSg1goILrmyTM0TWlxw5gz+6f7dm0Sfgp6klH4ZjvTSdQqPkmI8NGpsthHEWG6RhKf3ntNqXYSgSRGS/UW/EHf3Fx7b1oW2WB5v9PrCUr9L1QHutQMeWGfReUaHc1TCx3DMAxzXglSdx2380mQdk/KYZiNIj1rPu9zTwtFoqFp8Mk+MaWIImckhhRFQk1rwtBNUftIdZ4koHKx+FxZwFAiLVLjF/Xm2jWUbru5h0QetUkF0B4NSlFFYrRQFWJW1wwxkSjg92GkMol8Kir+nTdtE7lUDJZkiTrOnmQME8UKZb9RaFURp1Gj/gAc6s5PhUXkl1Leols/0I60TlcbmGjUMJRNiWu21LagK9da0BumGBPqD8qi0ahW0xDwycglY0KY9aUTwvapUGqIyUsEjQQ1DBrP6aBWbgqhnoiHcHK6IkQuifepal1YquqmLYQmpftJCE6Wqqi1tHYktKXjvuPjiHQIQIrWZqj+tKljptSYE530/tLn06AGptkpUYtB0WLvsxTerrN4ItgTnGK9jucZhmGYrc+6ClKGWesvOFTLuRgkQkg0erZABJmpezWSFV1FKhoRqfPJSls40rGVVh1BOQCfX0YgEERtNmJK1HRN1JiK2s2oXwhDElF60xKd7xThoxnwZKx/olQSozzpOvoycZTVtvilyB9FHYdTfSICeXx8RkxtcuEipoRnfwcyiRgM20EiFIdtOahoGoKSLAQolQoUSlXRkFRrtq8pFQkhoYQQ8MviPkPxAMYKFfRm4rhoOCdKE6jZaiCbRA9dz2x0dKZcEw1O5MWazbRtrKhuk7rQFX+7CaivNyWE6X0nR9Gfj+PkTFEYypNv6Mh0FeFgW1AO96TFcUO5NLKzdlSabePA7v52c5nwKNVRb2miLIAEK0Vj6fq9L6wiqh0JIjg7o56O7/5cCXrfPQN9b0zpQj61Yj2OhjIMcwE0NUnruG00PHie2TZQRLNztGc3nSLEm45E9YoUyRQd+f7Trw0GZCEUKToZDmZm58wHRNd9OqKI+k+yHGrSqMyQJHxDZVOG7tgIQhHiiTrkqXt7IJEQ0UGf4ooOd2t2xGY6Hkal1hTPkVijaGZAkmH5ANltz5efrtSRiIRETWUsEhIlBslQEIVGCztyadGENVWqicYeMxaDbTrIZdt1oqOlqoh6CmFGkV5JQi4RE9HH0UpVmNUPJBNiWhK9D2QbtS/eA386hcmZKvrySSiuI9wDSDC7GhDyBWD6LZwcL6LYbGFXT1Z4mu7pzbfrUGd9T6eKdfH+kpAkgd/p9WlTt79mIhBUoJk2cvEIWqqBfCZ2upYzEsTETAXBUGDeZKeFmtW6/zB6z/MseYZhLljcrTWpaS1gQcpsGVbTdNJp/aQLqyIbsnzaSJ1CjxPNGvqjp/1CKZVNEc2gn+zoZVHvSbWevnh8zhPT+ym+KUJCo6GhL5sQUT2KMiaDIVhw0DB0+G1JiEpJa0cXVddCIhhqj9FMxhH2K5iq10VtKVkfUYMUrVHTddFYFQwpsC0XJNco/U1i13Yt3HViDPuHexANBzFVayATCQtrJ5G2dtt2SJft6BOC0rJdWK4tXltutcT5d2XToubUJ0nC7ioaD6JlGmKtpD+IkUJJ2C4l4xGkFVl0xxfKddGlTzW0gz0plKotBELt99mRIdYmM//ebFuYelHO+05MYGd/RtSxpuMRIewNzUJYlkWtrVciIRqVZj8bsoiiMgDvM/QioeQzSut6dlDLFZ50Hk8wL2QJxjAMc97gclMTw6wbq0qzKm3LIa9hiEzmO9eh30mMTlRqmKm0G30CioJ0MIIjhRkh5igXHVIUIdpOliooN1toGgaaptn2HoUPLVkVYopsnSj6qdqmsE3qjyVQ1FuoapoYLSr5bWTiIZwqlnFqsiRS6STEeuNxIT4NyUE6HBYClsQh1XKapiMsnwqNJizDEvZVmXgclwz2Cm9O2+cKUXu8WhJ2TSenymKWfDRIFlcWRgsVNJuaiJ7Se0FCmxqVTpTaDUckDqkmlkS0Y7noTcTQ1HWko1HMFBsiOjulVlEuNYTNFTVZhYMB0WBF6XWKtJK4o6ix8Naf/bNBNaYjk+1zXLarXwhuikKT5ykJeYoeU4kF/U61qp2NShSxJXFNzE18mrXqIjHqkCMr+Yxqp8svloLErCdGO9dkGIZhtgfrKkj/6I/+CInE6cgUw6wGGjXZDUU1CbIMogggdYXTPHMvqiaOUXU0TE38TpZNVGs5XavjaHlGpOIvyuQwTXZPfj8ykQiaVguG00ClXkehVYfrOJis1nB0uoB0KNb2Jg0qmKzXRDZjvFLDfZOTSIbDcKixp1CFIsnQdBvxYADZWYF0tDQjJis1NAMJql9tVNG0dOzry4t7C4UUIUplSCKqmI6EUSFxajkYmSkjKPuE+KXrJbGZS0XF64bzGVEOIFL6saCItN5/ahKu6QjrpB2plGi6IpFHUc9aU8VMpS7cBEiw0nCAnTuyKFSaqBfa3fAX9eeRjkZwcqokyglodjwJPUq598RjYsoSddufmighIMtQQrKYTDUyXUGl2hKWWAQNH6X1e9JxEfHMZ9sG/x7UaZ+MhUUks7sBiT5Dms5En2koNN9DtN5VX7rYlxmDIrRmlxM/wzDMeYJ0HtaQrkqQfve738XPf/7zucf/8A//gKuvvhrPf/7zUS63IybExz/+cfYgZc6Z7jGa3dZPVE/p9/kgU855NiJIkAm9K3rC2ylcX8Anxn4m/RHULU3Uo5KB+0S9LkRWIhBDXzwPR5IxnMxgokH1nWFhJG9b7XXuOzWBgBi4KYlIXiYUQZEsjWQZA/kUyoaGaCCIeCSE6XpdRFV3pbNiGlQ+GkWhQun0CCqlljDwH62UxVo0kpOapCyZJhjpwp+TGoFIUJfqGsYKZTRVHdlMCKPTJTw4Pi0ikSTGr943jGKlKbrN84kYTkyWhIiUZZ8QpvT+jJer8KHdZX9ssoRdwznIDkSDVM3SkY5FRYOWO2ufRe8L+bhmk1EcmyjA75eFI0G5qSKoKMK/lSyWgrIsxDHVy9K4UrKiIoHpSI6IcIr61lknJmGXZVhCwHreoKJRqUtMegJ1oVGf5JO6HKiO1uvkZxiGOe9w2fZJ8Ja3vGXOX/See+7Bn/7pn+J3fud3cPz4cbzpTW9a62tkmCXRbUuIM5qcRALQK8WWJd/crPqyrkLXLcSClFL24aJMVhxLqeGmqYtoH0GG6vGADd3R0RuNYyiTFI1P2VgEx8eL2NeTF0bzlG4Oh/zwB3xCzFL0lMZ09gYTIr1OpQR781nRDHWiUBbd+TSalIQinePinX2is/2ynj5RBiDM4CUJtm6jVNXEbHuaB78jlUHT1oUEjpOfZ1UXtZe9qQQOn5iGY7XHn1JXP43XpBpSKeBDSW0J0TdRrOFHdx2GAhn9uYSIeGZSESHoqemoXtdw6UAvfH4JM9WmGChAHq0kMKmelcTh7r4sWrMiMRuPYLpchym1G7joPfWakqLJECKzApNm0Yv0OzU+BYOi3lXVDQQCihC3HgvZMy2ndGO9bJ3ontmujmGYLY+7ztHR7SJISXgeOHBA/P6f//mfePrTn473v//9IlL6ne98Z62vkbmAKTaaZxUmlN6lFDQJH4rA0QQiIqjIQnSSYCVPT6pnrLRUxAMhVBqttoWQZQiTd8u2RaMR1WDGIxmEfCHRsER1pPSP0zBtJBNhuAGgVlXhUL2m6aLWbPtnlrUWItEAwuEAKqoGl9LthYqoqfSJBqSWqAcdHSsJgXt0ugjNsdEwDeSiEczU2yb76WQEyXgQPcm29RNFNqG5kCNyO10fC6M3FkdEkmEG2jWjyWgY5ZaGyVpViOMDQ73Ck5TuPR+L4opdA8IKiiyxkqkgeuMx1FUNpwplEUWtNEksWhjIJUTHPNWn3nNiAk3TEJHfqXIDsiLj+FhRpNOpuSufjELxy1BkWdSDUjMXRaQ96F46m9RILJN49RBWULPP00+CIrmdkE2VZ5Y/93l7wwfWydaJxCjrUYZhmG0iSAOBAFqtlvj9+9//Pq6//nrxeyaT4clMzJoh5pHP+nouhNexTV3wZG0kHkdDqNnt42nOO4nOoKygXFOxM5sWYzyp7rKgtdrTgyQaN6ngRLEsoqSFalNE8B4cnYZFaXTHxmSjgYaltWe/Ww5CEQUDuSRqhoZSq4WIooiGqgDZPjmWiNCqZnsGOwlfqm11JQm1hgYEgclmDdGwH8lICKZuQaL58vE41KYhIr227sJ0bBERpc75vkwCfckE7js4Lrrpm7aBsqYhpPjRsiycLJZFKUHCH0ap2hSRSN21xAQnanqamK5gqlIX3qMRJYSJmfaUJvIQpfsoV1qioYsEMAlzuoF0LIJdvRkUy00Uaw3hmRqJ+UUn+6mpkqj/pLpR8jelelB6/13rtJKj8oNu0ZhJtX1K6XOiVL2Xkvd+ksdqJ9StT+9HJ9L8Q9YcUQYxOzmKYRhmy+Jyyl7wmMc8RqTm3/ve9+LXv/41brjhBrH/0KFDGBoaWutrZC5QKLVNIrFT2Hhm6DQb3qsRpO5103GEjZJKI0ODQSFmyaOzUGt3d8uKD4dHp1E3DSEaU8GQ6Ja/89SYEFukcybKNYTDflRVDXsHc6IJylBtBIMy7js6JYzkdVMX0VJKv0f8CoK2BM0wYDoqqjUTruGi1NKghCT4XFdMTQpJCmTHJ7rOFVdGpaqiRd3jFDltaoDjE+IxFAtANWc9QWkqEaXLe3O4f3RSdNDv25MXNaOm4aJmqMgkIqLxiKKVlw71IpeOiRpRy3BwYqSI/kQcju2iryeFcr2Jk8Ui7njgFLLpqKiDPT5TwomJEpLJsHh/Kk0dD55qlwFQd31DN1BUG7h4qAeSIok0PKXnB/Mp0eRExvzkCEBQ6YPc4Vvn/epFNGmClffFonskqAc5EpyNbhN8hmGYCxKXBangox/9KBRFwVe+8hXRuDQ4OCj2U7r+qU996lpfI3OBQuMkO6HoH/lWijS8ZQnfUYLsk6iOMqr4EQsEEVH8QsxS3aZByo48L6NhMWmIusBpPGg8FBKp6SsHBpDwh7A/n0W11sLBySkUGu0ofzIQFsU01Pl+6c4e1JsaMsE4dmQzaKkmMtGoaAYyLBe7Mn3oTydEB35PNIKR8QpKmgoloog58jT2s2mYsP0uBtIp7MlnRVSShF9A9omoK82Vn6pXRZRypFwWqf0jYwXsy+dEWv3IVAFNVcMUCWfFj3pFxVW7B2AaNhKzIq9YaaGiqdg/1APT54ooazIWEjWotu6gJx1t+5JSXWwojGQyhGbDEKKfricWDgkz+6lCDb2pOOKxcDvS7A+KpqSTE0URRdYsS5QLUCS1RKKbpk11BBa9LxGe+KSSCW8ffakg0d0NpfnJSophGIa58JBcruBfFlSKkEwmUa1W2cpqA3BcB6pmifGTJKAojU41hpQKp1pREqWU1qYUNnXY+xQbIUXCA5NV0bR0aU+vaOopqi1Uyy1hiURWT2T4PpxIombq8Pl9OFoo4KJsGuPTTUQjbaN8ao6ikRFUqym6yBuaaBSq1lQRKYyFA6IOleopjxemoBoO4kpINBQFJB8Q8GFspoKhnhRs1RG1laOlMkzNRl8uDkg+5ONRjJUqIhV/pFbC/nRORB1jSQX1poWWrsEN+kSU1204SCYjoowglPAjJgdgGTp25nswMVURJQiqY2H/7l4cP1UQApgEeYJEd8iPn915FHt35ERDETkAmLYD3W5HaHf2ZMQY1dGJMh5y8ZAQm+MzNTxk/+BcDShFSkn8U/c9dc5TzW4o6IdhmphqNrEzkxYd/hS9pNGl2URMiP3Fhh3Q5ygGAMxGuOlPEAlUErwMwzDM4rrD23fRn78fciiE9cLWNBx9/59vqOZZtQ/p0aNH8Y53vAN/+Id/iOnp6bkI6X333beW18dcYHj+omOlEqjxPdjRlU0CkMTo0ZmiiLxVWpoQdhT9tA0JATmK/T15DCaTc7ZCNAs+mgjAL/uwO5/BrlwGcoDqJV34DGBvNgefo8CQDezpzQrBGQr4Uaw3MF6q4FcHT6Kmajg5OQXVNESZAE1BouaokXoJNiQkQxHRnET1nA+MTaHa0pBLRjFOkcxYQNRrhqMK5LAsmoMsWNCkdoNP07RwcTYnRmmSJ+p0RcVUqY6yqiKnRJENRDCtN0H2qmT6bzZtaLoFfzCElmHAF5bhhgDbdTEyXoatuLBovGiybcRPvp0X7c6LkadUykBp/t50DBElgHJLFbWl0zM1BH1kPiUJT9ZdvSmRiqe3kKKZtGViESEgydCf0vOj0xVhqUVilCAxSqJ0MJdCtanOfZ6eGCULK6JYJvN9Q3zRoJIJEqb0WZEYpdczDMMwFyarEqQ/+clPcMUVV+CWW27BV7/6VTQa7Tq9u+66C+9617vW+hqZC0iMev6iw9kcNMsQ5ujdDGdSODg+JSYPkRk7YfvaTVAt3RRp9oOnpmbXNBCS/Khq1DGvi9GXJwslBEgYug6OTRdRUFu4KJfHeKGKuqqKsaFXDw1BkRXsGEhBoqin7EelYQirpuMTJUzWq3BsCWH4kYgEsTOdgmw7eMjeYSHclKCMXDiChqbiYHUSx8ZK0JqmqKU80ZiB3rREU5Tkc/HLgyfx66MnoYQUHDwxhWQ4iHw4gV8dPoHxUhUhn4If3nMU5VJLNPpQM1PQlUWKe7RQFh31rtIW75lEDJlkBKMzJdx7YlKY0pM0D/sDsOFiptTA4ZFpYeQvro8mKfkl0XBEtbQaSOwqqNRUyD5ZNB+ReCTRSLZQlYYqakwH8m07LK8ulD67YJCau9S5iUnU1T/nATs7sCCZiAhRS18uKMpKa3twfSjDMMwy4RrSNn/2Z3+Gv/qrv8JNN90kOu49nvjEJ+JXv/rVWl4fcwHRaXZPpCKxtqdnF5SiH8qkRINNKtn2wDw+UxTpeMOxhQH8UG8K9YYqfEI1m+odgVQ4glpNFaNDSXSS1+benhyCFlA3WqKJiayVyNaJooeST8KuTBY7etLoTcRx2c4epBJhkXbvicQQcHxwfQ5OzJRgSy5y6ThUR4Xr2KKrn4TgPYfHsT+ax0P37kR/PoFgWEGfL4VqXUXI5xfWS/lcBDuzGUR9Cvb35mBRLaVp4OG7d2CkWEVYCeARu4eRTocRkmX0p2OYrjTw8/uPI+IGoET8uGSwR9gw2aqFWktHLhfHVXsHRZmCo7nIxUikllF3Dezqz4oSBhK3aZo+pfhh2A5OjpdgaY4wuqcSBWo29+yxCBKxNKkqEQ+LTv5T02URAaUoJ41XJfsnckWglDzV+FarbUFKopbspIhOAbrenqIMwzDM9mFVgpTM8J/1rGedsb+npweFQmHZ69x444142MMehng8Ll77zGc+Ew8++OC8YzRNw6tf/Wpks1nEYjE85znPwdRUO/rlcerUKdHpH4lExDpk3G9Z88cG/vjHP8Y111yDYDCIvXv34vOf//yK75vZGKzZWlFiejb6LkzsXbudQjbadk6FclPMi59uNTCQTgpRRL6bPpvEk4uqZcBSHXHs7lxadLwP92ZQUJuQHBeaQWNCNeQyCeRp3j0ZvjsuYgkfClpNlAPUDR01XUOjaYBa8Q3LweGZAlqmJZ6zfA4CroLJWg0T5SpCchhHporY3ZNCRa/gmgM7UdSamKlVofkM5MnKSDKQSCioqwYedtEORJyAiO5Sh30uHxeRQjLwrzRb2JlOYqxcxr2nJhGn0gTJxWi5BkWRcOXefiEQ/a4kJjWRpVU+FRPR0+mpOjTNwEylhkgsIFL2VJNbnWiIsoNjY0Uxo75lWIgEFNEkle+JC8sjyZKQDAbEcVQvShZO9L7HAgFYpotGQxOlB33pxJzI9KKdVCagqm3/0h39GfG8l/Zvku1VB16Kfr08RRmGYc5XJB4d2iaVSmFiYuKM/b/5zW/mOu6Xm/onsUlRVYq2mqYpPE2bzdNm6G984xvxjW98A//xH/8hjh8fH8ezn/3suedt2xZi1DAM3HzzzfjCF74gxOY73/nOeUb+dMwTnvAE3HnnnXjDG96Al7/85fje9763mttn1gFPnJAwo9pCap4heuNxIfzIf7KutWBKDgzbEkb0NUsV6V9Xd5EMhITwLDdUlJqq6LonA/hisyWmEY1OVVBQ6yhrTWT8AXHMiVIFOizRgERenm7IhUajOlUNiqrAcKmZx8KpmTJU2YQS8iERCGAommyn/H02xqfrKDTqSAXDwmLK1E0MJZMo1TSE5Dia5I0aIoEZBppAy9BhKyHYPgV9sRiOjBdwfLqEdCiEYr0u5s2XGi1oro37R6dwslRFKhzGzt60mLJEJQO2YyOXisPWHBi+9sjRiqGh2mxhotQQzV52gCKTIZF2OXJyStSKXrVnAMFoQNR/pmMhqLDQk4ohHAwIIak12o1iyVgQzuz3OYpuCrN4idLtNAlKFhFRsmii5jHvc6Of1LnfaupCnJqzI0QJV5bEJKpo7HQBvvAi5RQ9wzDM6nHPn3T9qrvs3/zmN4v6URKJ+/fvxx133CGili960YvEtto60pmZGRHhJOH52Mc+VnR35fN5fOlLX8Jzn/tccczBgwdx6aWX4pe//CUe+chHikYqmhRFQrW3t1cc84lPfAJve9vbxHpUUkC/f+tb38K99947d64/+IM/QKVSwXe/+91lXRt32a89Xmd2NyRW1JYhGozGm2XRiR6VwoiGA0Lk1HUD6SiNtrSF2KMmJxpjSTPvA4ofql1DuW7jonwOxyeLsHwuhnIp1GsaepIx3Dc5DUlxsTuVw8liSRjC98XikCI+DCWSKDZaiAb9mClXEAiGRIc52S41rAaiIQWKEkUkoMO2YhjMxnF8pIRjzSL65BiS8YgQeRTtnJyuIJYM4eYHj2JXMo98NAzDsTCtNrGjN4u+ZBy3HD+Fq4YGRJ3oiXIZ1VILmZwfxybrQrCGg0FouiHqMS8d7BW1qA+9dEdb6EaCQlxS9HH3cBaqbUJXHRw8OYE9vTk4po0aTAxnk6hXdfTm4qKbnYRjtdqET/IJ71L6JkzC88RkCa7kIuoPwpFdcX3TxTqiyQCiShDVekuUE9D7RXZV1JxEqXgxrtVy5wQnHRcMBsRQAfp8Fuq0F0MMFvEjZRiGYbBkl/3et70fcnAdu+x1DUc+uA267GlM6CWXXILh4WHR0ERjRElAPvrRjxad96uFbtyb+ETcfvvtImp63XXXzR1D592xY4cQpAT9pAYrT4wST3nKU8SH5nX80zGda3jHeGswm4MnRlWKiDpOe5ykqcGVgXwmjmDAj+F4FjIktBxDjP6k/8fKkg6T8ucU/ZsoiM7tcMAv7I5aroahdC8iwSAqZlPUkpIYnZmu4+bR4yhXG0hHgghZCppGixyYxKz2pmQiF4miorVw7+gkGi0DU4YOzdQRClBTD9DUHQTkGE6VZzAxpdLgc9x1YlxEDq/tH0QiFUE2E8GJQgl+uJiu1TFebeB/PepalPWm8CXVJEd0yVPd5sxMFfszOfzotkM4NlGEZLjYN5RHPBjHNTuH8KhLdyNDpvW2BMsBdNjisSQDh2YKqDQ0RBNB7BnKIehT2vWftRb6UwnAD+R7EhiIxNETj8GCI8aqBn0yipWGaHYiUTtZrsOSVBGV3tWXwVA2hUhQgTQ7xZO+BJAYpSisbtjIJqPC4J9GepYr7UyG5EqQ/Kf/lAgngdkvCySAPTFKUW9Va/uMLkeMeqb63UMRzsZyj2MYhmHOg9Ghn/rUp4T10ze/+U188YtfFJHLf/7nf4ZMXj2rwHEckUr/rd/6LVx++eVi3+TkpDgXlQh0QuKTnvOO6RSj3vPec0sdQ6JVVU9b1HSi67p4vnNj1h5qhKFubeq6FuMk/SHE/cG5tDCJGde0hB9nqdUUNY2JcBLTpQaKRgN7+3O4evcgHEmD7PoQcP0oNFQkokHIjl94bh4dL6DYaKInGcHR2hQCARktR0PLtJGNRNGo0xz4GibqVdxy8BAG0lEUjSbS/iAkWYZmuYhFwtidzoljL+8bQMVx8MDMFHZkUrjz4CkcHC8gJiswdQe5aBQnahU84tLdGErEYVg20uGIsK8q6xqSmRAaTQ13T0xiqljHVfsHYZFQ1SwxntS0TRwZncLh0QIKxQYy6ShqrZaoE+3PpzA2U8XFvXkcOjWOkfESGkZb5NFEJ2rKqusaas0qaoaOHYMZjBaqov6TOuSDYT/6UnH4FBkX7+xDMhSCz/Xj2HgRM+UGTMuCatoi8knCrjErIGnsqRehFp+J66I31/7WTFFVahQjDNNqj3OdzbtQLamHLPvEnPjOJibv94VEZLdopf9/LIflHscwDLNdkc7DGtIzW5hXAEUqaVsLqJaUUuo///nPsRWghqt3v/vdm30Z5z0kchaCbITIF5PEDs2CL9d0BIJ+jFar2JFOIRUJotBsYlKqC+9M01Zw8+ETuHQoCUUKIyIFMD5TRW8+jlDYhma7SElRDPQkIUsyepIpNA0VdR04WZjBI/bsRkVtoS+Vg+T6UCjVEI0GIJs+TFXryERiSIWDogN9j5zD1YODwnbJsVxcsqdPTDM6WJzCzmROeJQOJJI4NDYDS7JgWQ4kWcJ4uYpdfTnYTROhmA+xaEiMIK2Na4glwhjIxDBSKosO/KDS9k7dN5zHaKGC33vUFZguNzA2WUaCpiepBq7Zu1NEmY+NzmBmuoFd2TTqhgqFBLfuIGPamKzWkYiFcHyshIFsXJj0U/BTkSRo9GUg7BeCNhkJoVCqw0xEUGu0MNSfEWVEiWhIeIiSlVUgqIi59yEyyHddtJoasqmY+FLhmdzTEAPxuUbaUVWlaxZ9OOSf84gVafvZ6CmLSIZhmBWw3rWe26WpiRqJPvOZz+D5z3++SIWT3VPntlJe85rXiEjrj370IwwNDc3t7+vrE81KVOvZCdWr0nPeMd1d997jsx1DdRHhcHjBa3r7298uSgi8bWRkZMX3xZwdStWT16gXKRstTInUfCoShqFb4h/FREUTkbeQJMMvyZioN6DQtCAlIJ53ZRs+1xENTn5fFH00zrLcFKMwAz4FthnAjp4URuoVuBZwdHpaNN5EfEEcPTWJWCwgLJ7uHB0TXp4tqo0MhyC7CmZqKnKhKOJxBSVTRTQWREVVcffYpJi0RLWdM40GTNVGQFJw5/gYMvEwjk8XRJQ9JAdE6QGlza+4aFDUVzpBB4qkoDfYNs9/5GW7EIj7YFs2Rhs1nCxWcNnOPhiyhe/edlB0vY+OlzFaKGCoPw0/jSOFhAdOTuGeo+OidjOVCGG8WMdD9+0U7wvZPJFPKolbVTPRm4oKYVuqkJdoC4fHC5iutk3qqVa0L5/Avl29wl9012AOlmFjptqAX5HRMk1RRmHbrkjXk1sBRT6pXnZkqiwcAWzy1SKhOytA6fP0GtM68cQowTWkDMMwq0M6DyOkqxKkr3/968VGwpTS61ddddW8bblQ2o/E6Ne+9jX88Ic/xO7du+c9f+2118Lv9+MHP/jB3D6yhSKbp0c96lHiMf0kGypvWhRBHfskNqm21Tumcw3vGG+NhSB7KFqjc2PODeqWp5pCmoHeNA0hWiqtpvDrFCMqNR2paEr4hp4oFYVPaLmpwtJt9KTiKJsthCUZAUdCyWzBNRwEFB9GZgqYrKq4YrAXqRhF9GxUTQ1S0MVUpQZZAu4bm4Rf9rc78HUHRwrjkP0SHnnlLhzo6RdWUJf1pBALh9E0Tdx89BhM20I06kMiHRYm/NWGLtLmd58cw2AwhjtOjcIXdFFWdShhGb2xpBgrSuWtNM1ocDiLi/IZ6LohJkHdf3QcNKApF01gtFjGQH8KjziwC3cfHYVa1BFPRZGAH1fu6sedI+M4dqqIuOJH0VSRy0QRloOim/7IyWncOz4horVUitBSdZyYLCISDeDeoxNQXBfRcHuGPTUbUe1oodESY0IppU+Ce/dAGkrAh+npmqjhnS7X0dT1dhOYaYvyATqerJyajXYDEo0DDSoy/GT8L/vE1pdJiOgmRU29RjUv8mk6zoL1oGfzHV3oea4LZRiGOb9ZVZd9LpfDP/3TP+F3fud3zunkf/InfyI66P/rv/4LF1988dx+6iDzIpevetWr8O1vf1tYOZEofO1rXyv2k8UTQaL46quvxsDAAD70oQ+JetEXvvCFwtaJmq882ycSzlQW8NKXvlSI39e97nWi856am5YDd9mvDcJEvcMc3XZt1DQDiWBQROJoBjtZNo2Wq8J0nupLNcMSnqAHR2eEmfz+wRyahoGRYgF+hVL3ZeSiGdGIU2s1EVZkZNMJ4TG6uz+Lm4+cwJWDWUyVNMSjQYw3a0gEfeiJZDFaKImIYkuykAiFMTIzDVODMMKnGknTMWBawIMnpoUx/WAuCaNl4yRFR2staI6N/lQcA4kEjhsziMlRoOVCNXW4roQ92TQmaw1Re+qPKnAtCf3pKCpOCz3xtHATqGoaoopfTEtSGzoeODWJgaEMBsIxzDRasCQbatMU9arRWAAufKg3NTEIIBMJCxN+sqoaSMfRsnT4LAlVXcfewZyIXJKQPDVWxEi1hot6siI97zWU0aAAGw4mZ2qQQj7s7c0jGgnA0Gwxdck0LeRzCSE4SdiSd2pPJiYEJv3p8MEnxLdvtlOfvnBQ9HQhA/yFWKgDn2EYhsGSXfb7/3T9u+wPfXhju+xXVUNKjUZkLn+ufPzjHxc/H//4x8/b/7nPfQ4veclLxO9/+7d/K8YOkiE+pUBJQH7sYx+bO5aaqCjdT8KVIp7RaBQvfvGL8Z73vGfuGIq8kvgkT9OPfOQjoizg05/+9LLFKLN+Nk9Uz5kOh1FqNkV6nWoeTdeGQsaXriwM2/26jJlaU8yspy7tnx0+joTiR382Ap8dhBtLolCtY3cmi754FP/1m/txCVxcks/jtuMnhbi0LBkT1PVeqiGRCmGkoEJNlTHVKOHKvp0itT1OHqZVHQOZAPwxF8dOTYPsOCnauiOTxq7etDDFj0dD6EtFYNo1XJwawJFqAYlGEDtzeaSVEG4unMTUTBlPvuYALLuBWFKB5UoYmakhn4qiL5PEHbccx2SuhSsG+zFRMdBwdWRjUdx5bAL7+7NQfH76vgjTcBBUfJiqq7hLU+HKLq7a0YPhnpwwtyd7qYPFaQz0pURjFHXE666Fyy/qF76lVDBKwnVgMINwNCBEd03TxRYOKMI6KhwIIJOMic55milPDUpKREYs1rZsopGi1JAUDgdEdHuhdDuJU88Gau7zbulnrQ1lMcowDLMKzsMa0lVFSD/84Q/j2LFj+OhHPzqvJux8hiOkayNCpyrk5elv+1OS36hhIp+IodHSUaw3sbM3I0Qpdd3HwjRasyqOdWnyUqOFsVoNF+/oRa2uotBoIh+KomXqcGSgYhTxxP1X4P6xGezKxaHZErSGiVPVMo6UZnBpf5+weypbmhCGxVYLPt2FZTqo2wYO9PegYego1JvIhWKY1poi2ogAEPJLSASjmK6U8Ig9F+GXD55EWJYRTAcxMVPBEw/sw60PHENvMiNqMy3Zwn0jk7h8Vy/25HraZvcNEzVHx1XDAzg4OiWioqpk4/b7R/DMx1whIqnkD+oaNg7sHcKdx06h0TKxeyCDwZ6MSPn3JGKQ4cNgXxozxRr68kkcmpwSwtaWIKLJA5mESMNPTlQQTYRx8PgkEqkwLt/dj5GJEnwkLv1+EYkmqyxdtbB7MIvJQg2pREREVIn7j4xj50BWiMrOSKYnND0vUS/F3v08wzAMs04R0jdtQIT0b7ZBhJQ64akBiUzpL7vsMlHn2clXv/rVtbo+ZhtDnqIUTSQ8QdObis09Hwr4RYc2dWP7AzLiMbI8spGOkY+lgpPTZVwy0IvJSh0t20AgpOBApAeZcBRxnx+qWkcmFoavBgQTAQS1AMYqDZiajTtPTotUeDjih9/2IRuMYLJaw85kBmkphEZVE5OcRvUaspEwpit1nKxXRce+gxZqdgC9oRiaoJGhLi7qzePkVAnX7tiB7xy6C/vjQ5ihiWJNA2GfjUJVxbjaQDgYQa43Jrr0H79vr0i5/+bIGDKxCEYaJQzFMzg+WhB1rb6QgsFIHJc8rkfMtDdaGsJQ4Eb9CMgSdvRlodZ1RIMBjJ6aEdFiGqtKzVqmbojmqfHpKvZks7hzdBxxOYBkLILjE0X4Qwokvwx/2IeLduUxPl3BxDSVQUBEQelLQUIOY6JQQTQUFNHUvlxC2FFNNVX0puM4sHdAfG7NuoZYvOMPnwu0dFNYcRFklE+fsydEzyZGabRoIKCIqOvcPsMUXrIMwzDM2VnvxqNtY/tEvqALzbJnmE7IU9TjjEk9qt72unRMJB1HTCnan8/hSHESftuPSDQMRZKFiCRhe//IFLLhKHbnM6IJ6lu/uRdX7B/AZLOBRCSIpm2IBp57jo+hh4zhpZaYxGQqjhgBmo5lxCz3e4ojOJAcwGAyhYapIxGwkUr50d9Mwmk6UF0Dg/kU4koKk8068uEoxtUqfnNyFM2qiv5kAvVpHXbEQdFsIIsYapaMJnmfuiEYpo0jRyZRtzWkd0Swf2ceB09NoqcvCGsiCcV0cHSmLGplfbKCSU3H/bUWHnNgDzTbxi8PncRQLIafHTyB4XgC/qgfumZjpFjDQy4ZQj4ex4MjU3AaEnwOpcodlGot7MnmAIeaxUzILvn6uqJ5ySw5iAX8uHRHH2TFh/FSVURAKUrqk4DdAzkRkabmsGK5iWw6KuyovM9ooZS6F/EmFwSy54rOpvLPJkS99Sj1302nXynBUVaGYZgLK2W/KkFKNZ4Ms5qGJhrBmUtE54TOnmwGhVpTCD2qE03643AUG5loWDTUyJAxUqhiqCcBxwZUyRTjPn/nmstw7/Q4rBb9w3HgD9JsdRn7BnJ4YGYa+3I9yIWjuK8wjpg/AEWWccVwHolSAHeMj0G1DFwxNAhrso6fHDyFa/cM4cjRSVy5fxg/PHIIaVSRTEdQm6nCHwqjZRmoNU388N5DGBjMY9IoIioFcceRETz2kl2oOzrUsIWWVsaJUgWP27cHk5Wq8DIdpNn2Y6qYjBSMRzDYn4FMvqSNMq4aGhTenTRrXpMsXNqXQ90w8NxHXYXbHzwlOtx1x8TDL9khZs6PFMoiukjNWVPFGvyShJKmIagoQpiruotkIiIM6NsOBRr60jGUSg3h40rG+yOlCnbk06IMQndsYftE1FwVumGhRaNZ4xEhEqmulN5XSs+TACYx6ZXpGDQadBk1oF5qf6lju5ugWIwyDMNsH0FKPUG0nThxQjym7Pk73/lOPO1pT1tf2yfCsix8//vfxyc/+UnU63Wxj+bJ0yhRhlkImrVODUuehU9N1cTvQiQVyqJ2k8SZZVu4b3wC6UQIRbWJR+zaAdf2wQ8ZlVoLBb2Me8gzVJKQiUdoVJCIElJTUKtu4ZE7dyHoyrh/fAoDqRRKBRW/OTGGXx86hV8cPYm4HIKmOfjOfQehkgG97sNMtYmd/T2YrjSRD8ThVyRU1Cb8Gb+oLx2KJLFjRwr7duQRMHyQEYTrc7Enn8OJyQoqFQ05fwzFlobLh/twfKaCsUYN41MV3Dc1hhNGBdFAAAPZFJKhAO44chyKreDBo1M4PFLAdL2BB49NQaXxngq5jAKHZ4rwBSSkAmH4FB8m1Bri0TBcOJgo1XHlnkEkY2EYTV34hJIHKHX+l8tNIXh35pJI+IO4/+QkBgfSYq2WaiIVi7Trch0XPhL5mikiu1PVhrCQIjFKIpI8WUmQEnS8Q6b6jivGjDaay++OZ79RhmGY85uhoSF84AMfECPfb7vtNuFJ/4xnPGNuhPu6CdKTJ0+K+fF0MrJSmpmZEfs/+MEP4s1vfvNqlmTOQ6gusJN4IChS1RT9unt8ApppQTMNlI0mIuTc0B9DPBzEyRKlkP1i1OVQKil+RgKOqKE8OlOEYoUxUmxgStdgSDZSoQhy6RCOVyfgSA5s00Gh1cSM3sChiQKMgCXskvriEp58xS6kEj4MZ9rTnk6Up3HxYB4B+HCiOiVmvrdaVeTDCcTcIMZm6jg5PoOQ7Mf37z2Cu46Pwx+XodUMmD4XD0xMYCCbhAVbTE8aCMfhmsBvX34R9vX1AiEZTc3FZdkeYe5///gIDMtFJhEVrgElQ0M8HcJgLClGiFIqPRQM4OhoAY+5dDeCih+m6aDW0lGv6GjVVDH5KeRK4t7yiTiVuKKiarj/+DjKpkb6XBj9N1ULFw3ncfFwj2gS0zULil/CyZkyKs0WZpotUVNK05OoYGggk0RkNjLpNZ2JOt/ZLxC0j+o+aahArKNRra6zRyjDMMyFbIz/u7/7u8IKdN++fdi/fz/e9773IRaL4Ve/+tX6G+M/9KEPRblcnjfpiOpKuw3omQuDhUSJVxdIHebCDN8w0NLaIvWiTAbTlRqOlacxUa3AcRyMVQycrBbgDytIBoOi4enByWkcK0/gVEVD3SkhGw9hptVEOhHAYDAhRm8eKs5grFADVD8sycVYrY50MIzBSBQ94QjGqxUhbOuWhLGZFhwoONKcREaJYn+mF8dmphEPhtCfTiIth+BXwjg+U0RJbSGKAHTDxi1HjmNXOoWH7B1GNhRBb5ZqSZu4atcgMqkwVLWJQqGJ/kRCCE+KgN4/NYWeaBSXD/WKOlaqSU2G40hEAnjipZdA1S3kk1EMReNQScVaDhLhAKamqzg+PY0JSuM3DUiKhH19OeTiEZyolBDy+5HLxtGsq+LYh1yyA33xGE4WqyJKnE5G4JiOcAwQTUktAw8cmxC1oU3NxEP3DMG2XBEBPTZWEJZNZPXk2I6YWe9BAtTnkxZMn3ea19OXDIZhGGYTUvbuOm6rhPzhv/zlL6PZbC45gGhNBOnPfvYzvOMd7xB+pJ3s2rULY2Njq1mS2eYsJEo66wIpXU9WQz5ZQqHWQLleR80y8bBdF6E/moJtU/e3H7YJRCDh9vGTOEUjWysVHB4vQbeaOFU00ZNP4NRMGVft7EMgGBANOdlICI7lwy3HTwqT9tFqEVWthYlCFZrZRK1p4NjUJCYaKqK+IP1rQXmChKkrZtxXoeIXp44Aloxv3nUf9IYlRJpW1zFhlNGTjsMXdhCVAhidKWFiuoF7x8eRDkVEVHSyUEU6mBIz7WtWA42qSvlzDEfj+PX9J6H4ZdxzZAqyX8b4ZAVjxSpuHRtDw20hG43ijhMTaLQMTJQaGJ+uY7pUhz8aRAg+RGUFAz1JUTd7slLGRX15aI4lIpxipGfYh0jAj+HeNG542KWQXZ8YxTpWqKI/HRfvO82dD0QCSMfCwkuVDO6T0RD6k3FcedGg+JIgTO59EvLp0y4Ii0GuCDSEYC2g1D/DMAyzNSOkZDPVuZEf/GLQ1EyKitKky1e+8pViCqc3MXPdBClFs0gBdzM6Oop4vN0gwVy4UPd6J2R5RFN/yO4nE42I6Jzk82NPOo1DxWncRWnvdByFUgMJJQTTMbE3nYOumogHwhhMZtATy+DhA4O448FxPOWy/Zio1jE6fQKSI+FUdQo7k0lcu3MHxkplBKHgWKuAsUoT5UYTu2NZRIMx6HYFY0YZlbqFnp4oUmT3VKsjhySaTRsnx4q4etcgLtnfj75sAr6wgt/ed4mo18yF02IsaKnawlSlLASwQy5FDnDvzDQOl2cwWS9hpmhADzlicpFpuMhlY7jvxARCYQU+x0EoEBB1mnLLhV6wUKzUkYgFqV1eNC21TBWXDPcgIrcjljOqCpWspQIB1KsaGi0Ng4mkGBZxxc4BJCIhMVt+ZLKMhmYiHg8hn4yJBieFakBVWxjcK1Z7KhOJ1alaQ8yZp/Q7RXOpO18zTBRr1CE2n6ZunLGPrKeoZnUt6Ez9MwzDMFuL4eFh4XvqbTfeeOOix9LEzTvvvBO33HKLGFZEQ4ruv//+9RWk119/Pf7u7/5u7jF13VIz07ve9a5zHifKbH9i/iBU05yXxve7Mhq6gfumpuALS9BcC36fD6bmIhr0i8abY5UCptUWVMOFn1Llpi1GgVIz0Oh0FXcVJoSfKHXlh5UQ+uNDwhQ/EUzDcC3opoFcOgZLd9FoOtiZTaM3mseMXhZG+pNFE806CTAHVdXCsUYRaX8QR2tTCCd8OFE7Ccmy0bQ1jDVraNZ13HzoBHb1t2snp5pN1GsGpmsq6paOgt5CzdDRG4khGvEjH0wg6ijYEU/j3tIYKloLM4WmiBQPxdMwGi4yKYr/AvFMAEMDadx+fBRBScapQgkKbFw0kMcvHjiOwVQKtx4cQSDqx0yljlNjJVgNC0bTwlS5hr29OWG7RM4FmmnCcG2E/Qps2xXjR/tzSciShIF8EulIWPiShshuyQGGsknRmNRp40QTnzLJiHhMQwo86vXTKXwPqitdSaPS2WbXMwzDMFszZT8yMiLM8b3t7W9/+1mneF577bVCuF511VViOua6ClKa1PSLX/xChGI1TcPzn//8uXQ9NTYxFzaGZYn6US+NP1KrIBT2i+lI+VgExXoDitxu7BktVnB5Xz8u3pXHQ4aGUa42UbdN6H5LCFq1oaJsNWBKNiKREOI9Afz88BFYmouxSg09sSjKegvjrQYaqoFqq4lQSMJQMo58T0x4hbpGAIFoS0yEqpgaNNfARfkeRBw/DlWmEQ8o6I2EkVR64AaBZtXGQ3cPwS/54Hd9sH0WjpQm0ZeICCuqvlQM4aAfwYAPFw/lMVWuY3S8IqybVMnCyWIFj+3fh6sGB3Fsugiz5SCTjSIUU1BoloXlkmUAJ6aKuKy/T6TJr947hIJmoF7TkUlGcc+xCTzzsVeK+0tFIhgrV3DZxUNQIn5MlxuiIz5EzUg2kBVjPx0cPDWN/cN5ERltGqYY5el9YSTRP1muC7soErHW7IA2Y7aLnqLYJGApckpRUa+RSZjln6Og5PGgDMMw21OQJhKJeRul41eSTV8qxb8mPqTU3n/XXXeJotW7775bREdf9rKX4QUveMG8JifmwoM6swOKjOPlIgbjKVHfmFCCIoqnmTr64gmMF2rI98aEUHr43mFRR/jDg0eQS8poWi4OpAZQKLdw1dAAptQ6bMdCUpIxQQI0HsHlQwP4zdgpRINB9Pn9mKg0cXJ8HLt7B9EbjQOmi3g4grtGx8QUsct39MG1gAmniKRBqXDgu/ffg+FURkwZahkudksxxPKAYbu46e678fjaxRgp1HDpvl409BBmpmdww5VXYLrZRCodxYCUFJ3v5DNKnelZfxiFRgvBiB8X7+jB0bEZTFWq2J1JIZuP4t7j4xjMpUUjl2bYmKk3cM2+nWKSlGnaKNd1HBjohWXYCNQDGM6nRGq9P53A8ckSnvGYq/Cbe08hmgwhkwiLoQI01YrKIMiYvicZxaU7eoXPKxngq01dpNZPThaRjUeFD6tlUm0s1fZSvt08QyyGZ+fQ05Sm7ojoYixlYE/Ct9tflGEYhjn/ePvb3y48R3fs2CGsQL/0pS/hxz/+Mb73ve+tryAVL1QU/NEf/dFqX86ch3gG6ER/JIFirQElncDBmRnsz+eRjsRQajUxlA8iqgQxOlVGzVdDS/fhYRcP47bDI3jkRbtQ1TU8cGoClw/nMVqtYSgSw5FKCXvyCTTLFRiSDycnS9gxkMXtp8pIIITH7L8Uo5MVVGUV000Vlw3ZSEUj2J3OoFhv4Z7WCShqELlEALLpQ28yjBPVIoZjWeo/gmabmG61kAlGsTOdRjgagBTyYXyyjFQmjP5MCj+95yim1Tpicgi3jxeQiAaRTkRhSi4qWgOXDvXh1EwRkz4fjs+U8JgrLsKe/ix+cd8JJGjylAXszmWFKA0rikilT5Rr6ElFcc/0OKJhP06MFHD1nkE4iouwJAvze1gufnbXUQz2JqG3TCTjEWFqT/Wj6WgYp6Yr2EsTlwo1jM5UsG9PTtSNBmRZNDBRvamqGcilYrj/0BiuvHQY2WRURHbJIqovFT/j8+uc0rSUsFxIjOq2haCswLJtFqQMwzDrgDS7ref6K2F6ehovetGLMDExIWpNr7zySiFGn/zkJ6+vIP3v//7vBfdTxCsUCokagt27d69maWabQqlfStMXqEM85EcyEkIgIKOuahiKJeCXffjl0RNIBsIIRiTcfvw4UgGgqLUwkMrgzmMjGOwL49ZTh7Ejmgf8uuhop/GaISgIRmT4fEGx7mSL0tVBXDHYi6MjJWQyUYw2alDSEqZL5E9ax8FfT0NxXBwbnkaPksKV4R24R5uAqZs4fqqEJ1y6DxG3ilarKSZDmbqLI6eK8PsKuGLvMCqVFoYG4riqZwA/feAIgmE/yg0Dv33pXvzy3mPYM5DB2HQF949NIekoiERi0B0LrZaB3p0JlNWWmKI0NllBudyA41IkVsPTfvsAjhaKSMTCmKnVocPETK2BvTvzeODoJNLJEH56+DB2RTNwFAm7+zKYnKzgir2DSCXDwgrrgVNT4r2uq7rwMu3PJVCzdNEgtENKI6qEoLmmaGCiNDxNWnIjAUSDAQz1pdFsaIjGQiIS6qXmu9PynhilsonV2jotFVllGIZhzp9JTZ/5zGfO+ZSrEqTPfOYzhfgkq5hOvH308zGPeQy+/vWvI51On/NFMlubuqFDstsiRkpEMF2to6yq2JVNY7wyg2wqgqauo26pqGsarkz3YEeO7IUkHCnPIBmLoTedwsRoDf2xDEZrZVw61I/psoE9qQiq9QJaugo5ZePIeAUtVUNMDuLWwydxxc5+4aXZP5AVc9UDUR+GkIQvVBOG8L3JJFqNFo4UJ5EMRICAD76UhP85dhA7EmkcL9WwN5vDfaOT2J/PIRhRUK40RbTwqr4BjFXrsC1Atxz0pEN48PgU9u/ogem62DmQxa7eOG799RgqsokbHnZAvA+RmIKKpeG+ySlIlovHX3YRJisN1AMafn7fcTFKtFhp4ATZUAWCyPZGkQiFseNhadx7dBRPPHAxCs2mGOlJTgMD+RQcn4sjIwXs6ssgH45gd38Wt50aEZFoMsFPz0Y2Z0oNWBUH0XAQlmkjHA6iqqrtf6sUVU1EoHc2NM1GOCmaSv9uu1PwqxGjFB1lGIZh1g9pFeb1K11/o1lVPu2mm27Cwx72MPHT67yi3x/xiEfgm9/8Jn7605+iWCzy1KYLBJrARDZA0wWasCTD72/XMBJBScGp6WkcnyqiPxGHEpZw+EgRUV8IB8dmsLunB2bVQaFcwEP39uNYswTXZ+PkRB22YeHY1ASOV0wUWiqKlTL2Dvfgkv5+JBJBhON+nCyXAb8ftx4bQWmmBKfuQlNVRIIuTpRL+Pmh4/jJ8RFM1FTYpgm1aSEihTEcTSMdDKK/N4ShWByxqE80AbmOhPtHxtCsazh8fAy1SkuIyl2pLCZmWqImNuAownD/x3cdwnd/eQRVS0OxWsMP7jyEYrkGvWbh6t4h7EgnMZBM46d3HcG9hSn4TKBab0HyO2IOfCgsIxiS4YOLe06Ni9rXvYO9qDUrCPhkUQtaMnVctn8QkXBAeIrS/R64eECY2j/6ol0oVZrii6wX6aRoKdk+GZopDPXLDRXJcEiM/CShSSl0T3CS6PYIBBT4/fIZKXhv3e7fGYZhGGYtUVY7qekf//Ef8ehHP3pu35Oe9CSRrn/FK14hZpeSLdRLX/rStbxWZovRWWeoWjois56SvYmE2Oj5oOSDrPhxvFFEwozAlSQxf71iqyjrTUxPFJGLxHAgvwM/Pz4CJeQTafqAZGCmSXPVHTimjWTYxaRdx6mTDTFHvmKXkFXSGErGMNHQkPL7kQjFoTVNBCitXzFQKZSFv+mA4qImm8IOKhKWoELFPcebeNRVu+BvRsREpVw6iRmjgh/edxLXDg0jHAtAresoGxqS0SCOTM+gbFfgqgZ+M24gGgxjZ28OQb9PpOr7Q3GcnCmiPxvHvWNTiIdCiCkywtEQVL8rosXBSAjTowXUiwb6U3EcPDGFy3bHYDjAYDSGH/76EK44kIHihkDFnalwGHfOjOBksN3EFPcHhHdqpdZCwzBEZ3x/PomAv/3P+ORECblkVIz2JAHam5itDVV1SFQsOisqKaIaCQVEvSj5kNLrOyOjnb/TT+9zXqx5iWEYhrmwU/abFiE9evSoaP/vhvYdO3ZM/E7zTAuFwrlfIbNlIZFCdYokfnLhmEgrj5TLItJIDTPkOWr7AccA6mUVPluC4ZiouSomRqtiYtNANA1LdXF38RT6c1G4po5CswVVsqG1TIzXTEQcCQ8fPoCHD+7BoeoU/H4H+6IDUCQFD5ROYDifhOEzMG7MwCErTR0YCAbQm0uhptlo6jR7PgQDNm4dGcXxgooDu3Ni2lGtUUXTZ2G0VsKDE1XRpd+CBVmVUDANMQN+crKOq4b6kHGT6ImkUHMM6HpR1LWmkzHsSGbENKaeRBythimajWgKFM26z8bDiAf8KFdV9CphmLaDSquFWDyM3oEk/GTRZBuomybssIs775/BQE9aRDfpfX3k5XtEFz1FVC/bOwDdtdu1mS6E9RQxXazj4CiJYBpzamFiooJUIgLbceY+J4qwEqRLO2s76RjVMIXYbFptz9Fu4cm2TQzDMFsQd+uNDd1wQUqmp295y1swMzMzt49+f+tb3ypS+cThw4eFwz9z/kA1mt1QCrtQaQilU1GrqKk6plpVkTamlHVvIoZGQ8dle/vgC/lQK+q46+g4JmpTqLZM1DUdU24LAV8ENbUFW/djUisKf82+TAxZfwRHa0V8/Td34zv3H8Gg3Atds3C4Oo1as4WRVgu3jh5B3IoBqg+wNRybLqNoVLAvmYHsV9GXk9DSi4iFgGhIRkwOYKbWgqlSCryEQMDGkckyNKsFI2QiGvDjltFjmCwXUam3MKbX8P0Hj6BiNXFkqoAn7rwIPfE+6JKOBycmcOexcezt7xWTlabVJgzDxkMGB7GzJ4cdPVlRV5qIhfCTw0fR0i3EgkERpbQsFelkFGbVxM5cCk+56mI86rLdKDaaqNZaYriA2jJFBLPR0KC2DOztzQtxWWq04NiuMK7vycaRi0VEk1O9pSKTi7UtoXQTU6V6+4OS2g1KJC5pRKgHTYcKzwpUaoZiGIZhtj7SBo0O3fIpe+qmesYzniH8SD3RSW7+e/bswX/913+Jx+RNSvPumfMHElLd9kBETyaOQqOGgBRBSNKFddJkpYZasYFisgXb52J8YhIVM4B8PIad2SR+efIULsv2IOYPYKahIhyWMVpVYQct/FZ2Pw4VC+iL+jANFbujfdi1N4GxWgEpKYMjU5OwJAmxWAihZhBBJ4rx4iTy0R7UWirKqIqoaPnYSUwaTZQLJiKhMA4dK6Nit5CPRVGoN6G4MtL+OKZLJWQQQrw3htFaBVNSC27Ej12JBColHYOZOPLpFGbIJsl0YJkm4nIQrboPiVQYo80K7js1iWQwAEgylLAPd4+MiclJBbWJHX0ZGKaNXekMWraFPTtywpd1T3YAsVAAvdk4dMuG1dLRtEyEXQW5RFxMpIoHA+1BAxE/yvWWaE7SHZrolIVh23B8ECn8XCqOcMhAJOiHZloiCkr1ol50k2bPxygKuoBvKM2mJ3EbCHIzEsMwDLM5rOq/QDSvlOaT/s///A8OHTo0t4/8psjz0OvEZ85POsVosd7ESLGIQCiI6ZmaSDcXKiVIQQWHqkX0OElhhH/SbGFfH5nIS/j11EnMqBUMJhM4VB1HLh4VnqUVYxwxuR8TZgVq2cTdpSkc6OnBUb2AATMNzVFQc5swAz5YdRM1qAg4PpSbTWh1EwiXUVF17MjkcWCgD7ccO4WddgJjvjIqLQ09SkQY1Z8qN1Ecr6M5YMBu+XD1xf04dKQIu64Ly6mxShWmZOHe6hRykTiOTBTwmEhcdLcnchEUm01M1ZuiSWtiqo6+XBqmYSHXG8dMo4WRYwUk02FEezKQ6jYkv4RsIgIXEurNBk5MlsSozuF4AkFFwVBfCpMzNUCRENR8SEbDoqGJIqETxSpiSgj16SZSu7JQLQvVhoa9QzmR0ievTzqeCPoVYXxPafg6WTuFAiJF79V/LiRGKeotvmiwFmUYhtk+uOdfDemq/zNEwvOpT32q2BbjiiuuwLe//W1O3Z+nTFbqiEZkxCMRRPwBpPtDGKnWYJo6AjW/sDSq2yoGd0agnrIQdQN48PgYgqaMbDyJ8WYJlWYJfZEYXD+QiQ5C0gI4PjWG4WQKQTuKYpPEroI7Ro+LSUOJWAB9sTSy0ShUrQFfLQwEHDSCdUh1CamYH+OFKg6PFhBL+VG1bexPDaImVzHdaAHNICQdeOJv7cH0pIZW1sbRySo0y4Dlk1HWNOxOplGp6LBTLixNR1gKYKQ6jf35QRyvTSGKKAb6EtBrpoj+7hnM4YGjo7jj4Ahi4QCecu0BPHhiGuMjVVz3Wxfjm7+4C1ftGcZVewYxUvHDrwTgwkE+GoUtuzh6om2yL1Lnfhcnpgt41OUXCQGZTERQL6no70uhVG7C5wJ7d/aI6VY+WZpLtwtIjdL4T9dBPBYSz3X6iy4kSL2oN8MwDLN9kNj2aWWcOHECpnna85DZ/n6jnb/ThJ9W00IsJIlUMRmzD+WSCCaAabcBQ7bxwPQEHMuHKaOMe8YncLhaR1FqQjKollKGixCqdRvj5SamTjVw+9gJDITyiGTDaNkqGqqLcq0IVdfFtKNMMIlCswZLq4smqXTcQrOqQVctxAIKlFYIsbiMcNiB1jDRH6AO/2kcnqxiRySJ+6bHYUWa+OW9k7hnagqtUQ3lRgkIGAiEfZio1sQkqN5dSfQFo4j7Y8jlowgGI1ACMmxNgumqOHG8CEe2MBxJY3y8LJq3Qn4Zj7v4IhSrLfQkE7json7cfM9x7MrnYTnAvQ+O4+DRGWSDITG1iaKblekm+tJxmA5NlgpTeBO7+/KYLNfg+iA6/WnqkiRLGMgm0ZdPivef3mtqpBL1pbOik74kUsQ6GQ7PCdXOhqSe3JmNiAzDMAyzFeC5fsyK/EYJqn+k3+8+Po6mZaFZdzGtNlBpNnHv+ARqDRNHRmeErZHjWDg2UcKeaA/gAEOxJFyfDz74USqqyMckaK4FX8hAM6rDdDSMlEooTOtwNR9Uw8D+gV6Rhr93/BRM20Wp2MJktYWZqoq66uDyPX0Ihn0oanW4rgO95GK8pGOq2kI8FEWwGIQWslA1DVya7EGp4qClGAgFXQSyfuwO96JhO/CpEgbTSUA1MDJehiYDdVNFyhfBqFYXjUVhfxAhJYTHXb0Pp6bqKDTqcFsOLNfFJX15jKkNRELUOa9Bt0woLpBNxpDJBmD5XDxs/5BItQdCfqiahXQ6glg8BNknizpT8gP1QRLZEoqCUsQzHFCEVRZ13nsRzlK5MTeYolZTxU9qVqJmsoUg0UoTmjofd8IeowzDMNsIdwO2DYYrx5hl0dnIVGjQWEwf4tEAQgEZM80GGnodzRLQcDXI5GvpqhivV3AgMgBXNtFUAcNHgzLr6Ff60fCVUKrZaMgKDLOE/kgO5UoVaX8ax9RxNKQmLhkYxl3HZ2COuqg7lvAUvbtwApdk+vCdBx/AQ3b3YEbVcJxGa+aHUW01cUibFAbzJHibDRX3jY4LayoTDo7VC1BdB67fwoCcQ0vXcN+RMSRTEfREowhBgmQBbhyYma7AH5TapQGWiV1KGMenS/AbPpTdOnbmc3jqlZdgslTDcCaFoOrHVLMFuQQEByXRDX/LwZPYMZDGpXv6MD5ZFpOexis1PGzfDnzjZ/eifyABq2UgkAzChSs64rOxCLKpKMYmywiGFaQSYfgkCbpmwJEAEwZCvhAS8bCweKIa1EwqOu+zIsHb2Um/kHVT92P2GGUYhtk+SJyyZxigLxGHbLdTzv6gD34liPEJEzv681AdF2PFClLJoLARqrSqCPv90F0NLUuGU4/g7vEJuCEZ/hiQiwTEvPVT+ima6omg40NPOI5HDOyH6QDZcASS0kS/EkGrRv6iGRwrVpAJJdCoyvCZQVyU7kEwqMDRXOzN98CyHNSaOvb0JVEPzKDmL8Nn2cjHo8gpcWSUKE7MzKDls4S11MW5fvjlIJqKBTPu4t6RAioNA1rLgW5a2NWbRGFSFT6mmUwIkWAMI4UivnfPIdiOjUDQD9cBAjbaYz5VF785MY6Lh3pw8c4+zBRrkCGLyUw7cxlM1xp48sMvwUAyiZ6+JNLhMCzDwXBPSlg4tQxDrFkuq2LcJ6XlAwE/UvEIksGYaF4i71BXbotOMsLvRNfaZTLkBcswDMOch7gcIWUuMKrVFiKR9lQfYrxRQzoQRi4bx/EjJYyUqhgtVnD5riz++647YMkyNKOJuBlHxB/EiXoRD5YqUHwKWroD01Zx3f69+PnhE4gHQuiPpTEQ9uNYswx/PIhhJYkHyyp+NXUMsmMhHpExfsxGeKCCY5UC4uEIjswUMdAfEQIRqoaWqmDkVAWKX0LpRB07UnmMuzWM1GsIBTNwqY5ZkVGqGJhxdSRpTKarIKAruL9QgKn6UPfreOTATnzn4IPIRwLYnc6hoqrYl8/gtvtHsXtPD4qlOkLxEK6MxtAKOTjQn4YdcdHSdIQUPy7e14vDkzPYm89CkWSUak3REd+XjePkaBmKIWHGaODhl+4UEec+fwKHpwpwLVeM7aSoJXXHa7op6kapLle3HQQdFxVDRV/otPCMRxb3DA1H2ib4ven2pCaGYRiG2epwhJRZkkQijBPTZVFjWFJbgO6iomuiBtHQKUKqwKcAhyhtPjiAsZkqGj4VE6UyZFlGTvEjlpBQ05roSYYwmA/iVKWCjD+MimWJNHrTX8ae+B70BjOYkiqQfSYOTRYwXp9BBlkY1DnesOHICiqahUTQj4kZFWPT5CtawVRQg5RyUJUbaOo2fnNqHLpuIKkEYLccNGhaU0tFzTaRMhUEgnUkMxGEfRIyiTBcSn3Dj+89eBiZYAChYBRqieotNdwxOYkDOwfgs33YPZzCAyNTKFoG6uMqwqEIGjUTd42NU3ksfnLXEST8ATQMHdVqE5fs6YXrODg6UoDtd1HUNGSTURw8RbW1DuCTMJxOIhuPYCCVEBOXqDs+n43Dtl2EwwHkU1Fh49S3wGS0hVioFrRF6X5nk0ZvMAzDMGuPyxHSOX7wgx+IbXp6uv0f1w4++9nPip+f/OQn0dvbe+5XyWwakiRhMJ9EJBCAYpvCb7NaVlFEA1NqDSkpKqJ4E41p/GyijmgMKE6ZSMVlqLoKM+THwUNTyMT8KNUbCEVs9CdDeODkJK4a3gNDNVBz6jhiH4dc9iOaCiJmhnBFoh9TjWncdPJ+kdJWjRD29MZQK1bQsC3IPgum6aJW9eGqHQE8UCgI03kaORqQdKhNBS23AskNwfYZCCs+hKIK7Hod5TE/0lmIRqWhvgjMio6wHkNeCUNXNSgxCapjYU88h/GZMqakMqYNHXsbaVyxqx8DiSRaGR3DPQlMHayjLxrDJT1Z7MgkkU1F4JgulJwPmmOjXG4iGg6iJxETTUumZcNP40jpvXAU7OhPozlaQMs0MZRPCUFJ3qEUHfUrshCS1G1vmraIohLebPmFWKgWlObWMwzDMOcPEteQtnn3u9+N66+/XghSmldfLpfnbR7Pf/7zEY3Ob7hgtheaYQl7y3KjhZpqYHya0uAKVNVELBoWE4AitoyTMwWEkxZako5INICxySpG6xWcqkxjX08SsANoNixUmgZ+NPobxHoCONE4hXgiBGom9/lc9EfCqKsGiqhg2mnBH4gh7Pow0tAwWa3BrkhIxpLQnRaavjqu3jsEicRdeQLxQAS7kzHETB/ScggWTPgNaq5qQdYllHQHcgNoGhJiCT/KpSZy4TDqJQsN28W4XkENDTRsG2FNQTSi4LaRSSjkJqBPw23amGjUMD5ZwXS9joCj4Fe/Pon+ZBKZYAQzzRYmpsq4/9Qk+nMpVOsqpkbL2NGbRdCnQFZk7OjPYHdvRjQqJZQgwrOTkfp7U9jRmxajQUlQkvistXQxVpWmNVG5hDPbUU/wbHmGYZgLHJcjpIJPfOIT+PznP48XvvCFa39FzJbhxHRJeGS2TAOy7IOqGtg9nMWpQgW3jRwTkb5D9RLygTiaTRkTRgtZiWyHTBQdFajXEAs7mNZ90GUdF+X6UHFr6NOG8UD9JIbCw7i7chCSoqA5JaHkmxJNUv1yHqdqk9gdS0GSHARUB0O5LI5NFmGEC/BpfsT0CH5zbAxBQ8YxHzAYMzBWNWC4LjTHByNkIGxFgLoEO6QjEJRwsDGD3YEUxmoN7LUzMAOGiGZGjBAq0HFFph8PGAVMmmVE3AAuH+jBFf39OFooYspsoGg3sCfTA9OwUWw1kBiII5EMY4cYMapicCgNU7dx36kJ9Eaj6M2moJqGqCGljvijJ6dFY9JMsY69u3pQb2loaoaYqCSQXOiGiXQiIh5StLQn1bZxCgbO/Ke6kNE9wzAMw2xHVhUhNQwDj370o9f+apgtBdkPWZKNiORHrUG+ng3cdvQkfnDoPgSifkz8//b+A8qyqzrw/783h5dfxc5BOQtJSJbJBpM8DAx4GY/52TgMOMD8h4UjDtie5Rk82MM4DIPtNWOzvMaMwbNs7OWAyWAYEEhGSEJZaqm71d3VFV+6+d7zX+e2qt0tJNQSKnV19/6wHlWv3q1X952+r7TrnLP3HkY4E4coT3FcB9+2eThbZakcsq3j45sNwqLFxIlpOA5La0OWllO+ni1wzfw2VsuYXa0e6UrOdNfDt9o4zQjTnbC7MUU/9Oi5DS7f0uRwMqC5BcLKpRN6lE6KqiIIMypd+umRFYp4TBzlVEWKXViUfoLt24yyCts2mdZtRscjps0W3nRAsQamcnW+E7pg6EI0xsJktt8ltAwGk5j9h5c5tDBkxvPZMzPHNRdsZfdUt25FetHUFDu6nbqO6CNra8RRgaMstvbadbZ8VZXs2tav94oGTZe5uW7dkWrPjmkmcYauxopOWIqO1RF1bJullTGrUVTf10v3j7c3VPe21/3rJRgVQohzk6HUht/OiID03/27f8eHPvShZ/5sxGml9zfqguvachThWhYN69hysedadGyHwiwJzLBexj+0sMb9gyVuP7KfwhwxjgtmrAZLY0WlLCbGmP32Mt0ypOcF6PX9pJrgqZSV1ZJoOGRhJWZBzyquHCUqxkxX5/H1QxNWswXuPjwkKQsOxRWLwwUGizAeRNybPcIkjVkexiR5VWfbp5FFXDkYVkZsxxiUjAYJuTXEzg1Wo5jScpgkBoeyAfvWFoknBSrOOLq8xEwj4P7RKnPtBkFkMd1sk8WKry49QpUUzO3q0vNcRsOCexeWaTVdts32WFwdMxinnLd1pi5ofyAaUtqwEsd14fpkktfJV9PtJsujMemkqGebdcAaNl0qVF2wXi/xu57NtvkevTCs/y1O3MOjg09dAF8Hpq6t65Mem0V9rBMDVyl2L4QQZyklS/a1JEn4oz/6Iz75yU9y5ZVX4jgn10F83/ve90ydn3iWrC//9nvHloinwrCeuXt4tMpDhxa4fMcOvr58BFcZ7Jhu8aU7HmLHlh7GeIV90YR24eOUExJl0PZjVrMMz6yYMnrsS1bYqq8028HPfaaNWWJjEd/tMolzPFfhJRZOT3H7wj4qU/HQSsp832JfvEY0snBtjyzW5ZscXjJ1HrfuX8LwIx4pJrQiHTRDoQvbK12bFEYTRcPTZaEcxqain1jknkXVzOqaprpwfGwW7G12+EaaYaSKF+/exsHFCb5jcu/ykO39gLbV5XXXXM3N+x7Ciy0wS2b7bfqtsJ7C1J2V7rr/MBftmGH3tml2qj633fsIL732Au49uFTXE9021+Nzt9/P5Xu24JpWPUtaUxB4Lnla0Gr8SxmnySSt25Q+lk5q0pn3x49LMxreyQlLJ86aygyqEEKcnYyzMKnpaQWkt912G1dffXX9+R133PFNWdnizLMevOis7pVJhK0MVvKEXVM6aEy569ARung8sjLk/+27l0NFzIWqB2bGKE3wK8WBbIRr2JhVRqU8tjS7HFmdsKUPTafBSpyjTIOH1BHCcUC8FrN7e4/7FlbYaXdZGgzwdeBZxvhWg6PLQwbKYMb1KFRcB7uTsuCfDg2Y8kyGhoGz6mH5JVNeyjD1WEsVM3ZF14WjsUerndIYN0maFckkwjBsHnLHTA31bK+BriG/reUSZxVff2ABow2B43LZtnmSQYxZWNz/yBLRMKVULpOkwE4KVicjbpsk7JmZYqoXslzEjI5m+LnNNRfu4ODhNc7fNYNn6LqsJTv7vXoGVc8264SmKM7q2dU9W6fotENK3brUtI4HmrONVl0A/0QnBqNa+Gi/eiGEEOJM97QC0s985jPP/JmITUHPHA4nCbtme5gT+NqhRzBig1bgcOu+IywPJ7TbIUeWhnzt8CPYvmLCkIZvo+dW3aBgLXPq/ZN+I8NKDJYHCQuuRQuTnDEBHqkRYXZ89i1O6t7vWIeIJz2qTGG4TTwzYxLkhCWkTDAnHrGe+sxMQl+RpwGGKhnW86KKsWkRthNwLQ5OXGZLRWRXeJRkKLyqYKppMl41CO0Ar2kRTkzuOXIUmgZN06CoCs43pqiSkmE+oeMF9Keb5FHOtqk+2WrGSEWcv22a1eWEi8/fwjceOEQ/DLAch91zPe685xEOHl3l6ot21Nnwq2uTei+qnlW1LbNuA6r/aAsDl2max2emrUcnRPVSve5b/0R04KqPsW2rfj4hhBDnILXBy+pnygypOPuM0rSeoncsqw6whknCOEo4uLBIWWbct3/EQ5NlisQkLo6ymhl10HZRZ4aVZIXViU3s5PRSjyKJaNohj6xMSM0Mhx6+ysiLnDizWYoiZhoNxlVC4U7q2cmh1ya2xigzxbAaJKmiLBRlbBMHioZr0DNihpbPYGxTWRm+n9IuPSY5+LnF4cTCCCqCyiDrx+TLIaly6PmK4chhrZFRZAZmbqDCHEd3vJ/ymVM+wzRlR6tN6Dh0HJ/ILlnKE5zEpd/x6r2eU7s67Jru8fDB5XqPqLUPeo6L5VlcsGOG++47wuUXbK9nP3XSUjzWyV4WTdchLQocyyVXFSpXZEVJ69HyTSfWFdW1R0+U5UX9UZeCOlYSqsD3dQktXS/1ibs1CSGEOHsZZ+GSvUyxiFrL8+p6l3qZODcUDxxa4vDaEMszufnQUbwW7GpO4fVM+vNzmL4ibDrsi1bwdV/7KsUuDbJqjULZdf3OhCFKmRTGMmkFY44FpTPbC8behEYzJ0ttsoHBKEoxC4/RWoe1ZZum0yapjvVwn/dybHON1UEDIwfDT7BaEXmuK8aDYYGKXSwcPCtHlSXjsU+3k2GPXdZUSeyW5HGGahY0WyWW7eAELtVSzjBPsUKThcmEw2sj7o+XCRKTbmGi1/SPHB4zazdIJjFJUdT1RG1lcvHOOa6/7ny2T3UxCoWFUddr3bV9isB1aHYCFiZjelMtGp5T7zf1bKtektcBqJ5tXleUJzeXWFf3sXd0XdRjAasORrWGBKNCCCHOIhKQipPo2brSKjEtg2bPZVdvnq7l1e0xF0cj7j18hC8cvI9kUhBPcvxgkSq3CFxFy0ixqzaOnZPFBylzk3FRMCwtVld1K06HhhfgsoBKDUYDk4SURjvDaY2hUKhWTKbgyGRCqEoWB/BQZnNo0kS5sDbR/d0DslFAUcLYLlFWzrgbUbVzHNegaOY0dRmAzNGdTqlioy6wH6Q+rkk9Q2lXFQ3foed5GEXJNr9D23U5b8s0r7zkUiobrrh4B81Wgy39JgdGQ2Y6bfbdv4AXOuya72E4FncfWKhnK+986Ah7zp/FsAyOLA9oN32qomJrt0Oa5OxfONYwwjJNes1jGfLths/C6qj+vNAvRq+SnFBqYzKWLHkhhBDnRpa9BKTiJAeXBrQNH9u1WTwUccv9+7l/fJQiK7l/tERVKrzcoSRB6RqasU9RhuhCS6uJR24PMauKpGjQ8HQfdgM/bhBOlzgq54gx5EjUpWhEGFNreI0h48ojHfuYlaKTKzphhu9FTGwD0y/wlO7rHpOaik4jpRUUZBkkhY1ZGBSpg5laVIlBPvIpK5uBUqSRgW2YFDr3x1NkpYll2VS2iWX4eGMbw3fA0ztNFS0VMD/d5dDRNWamAx5eWSGqYmzDIkozrtyzBRVYLBweEBgW47WEuXYL33e4aNdsHYD22yG9XuOEvaHH3mIX7Jj9plJMenvEXK9Vz6b63rEEpUhnWT2q0fyXLHkd9OrbU6X3nAohhDg7l+yNDbw92yQgFcfp5Jut020Wx2M+e8+9fPLee1idTFhbLlgs1xgHKwwYMbFjYj/GDmLMxGalSIkmJo6ToawKyygoGyWRqmi3JgyCiCIuGJQFQWHRNzxUbkNlMMlcDDNmdeIxsPRsqo1R5eSFQTQyaDQSJksuaaaXrjOGhcPqRAdvCtsryAunfuOYVknopJSNjFag1/ENVFCCnZEaBZOkZFRV2FQ4hs180KyX6WcaIZf15xivpdh+wT/f+zCRVfLQI2sM1hLuPXCEuV6TPbNdbr7zIE3f5/pLd1EE0OmERFFKGPr1zOdDDy/SDry6OP/6Enua5nUCk5551tZbg+pkp3U6SWld4zGZ9OtBrE5i8h4NWp8KvedUCCHEWUadfTOkktQkjvNdh0/ecx/LCyO2tzp8fd9+VKYYGzH50GHJjfEMAz+rO3KSK5MGFdMzy5SGRTr0sQuDceXirjkoXYqpDNAhUelU9Syka0QsmyWWWTKOfEgdnELhdxOaRESxT46LCjN6fsxg0sDoFlimIs+suqOSoePMyqQySpSfYedQeAaqqDCrkuFiqy4FZSTUM7dOoHRyPk5ZkcYOKi3ZlyyyrdPWMTELiwO2NpuUoWKr28SIKrb2uzT7AXNFlzQtoDS45OL5ul3p1+9/hPmtPbIi5+DhVZoNn/N3zvK86y7g0Nqgrg16PFFJQZTmdXb9ifVEe93Gv4z7kwSa30490fU9p0IIIcRmJjOkgnGS1ok2y9GIwDJphA5ffnAfoc4eb8ziUJE5Ywwb/O6YcZDiGSaBTizyStZGAWlik9gVg9yqZxgnzYihm9Nsj3CqEmUoLAM64Yg09Zh2Exp+QZ5bDD1FEduklkfDS5lkJsbIJFEWhl3ilAapXop3zXp/qudmmI2SKvFQpYXh5BSRQ2HZJJMQMyxQlYmyTUzbIBy6TBsGDdOi4zhMd32mrSapVbG8MqGyKtZUTmA7bJ9uczidcMH2WcqVlB3NNo2ezwuuOZ/79i9yyY5ZLtwzT8NyCJs+O7dNsWfbNAce3SMamg5rK1Fd3F7rdRp1r/rg0aBTz3auL9tLJyUhhBBPl3EWLddrEpCeg+I0p6yO7S2cjOI6u/6hpSXuOnSUUZpxOD5C6BpERcWXF+4jdwtWLQVlzjgy6rT2aGJgOznRwMGoAlRq41qKUnm0/RzbMeiQMxnoeqEGjlNi5ybLwzbtYMTh1RZxbGP6Kb5b0HIj0rHNMPd1MVRSwyWOdEmlgiJ2cFsJdqn3jtr1zKhe0tetSKkgUw5OpSgSF9OvsDID1yrIdBZ+YREHFVVksjNsEakhcVyhjJJ24bK336ETNkhXUi7fspWHV4fs7U7Vez93bJmqM9yNyuCr9z3MltnOsRaqvk9RleghsUK77mV/3rbpejx1S8+pqSbTj3a8eryGEeszntJJSQghxNOi1MbfnmUSkJ6D9Gyd3vM4ylKUYzIaxRimgWtY7Htkia/uX+Wh4ZjUSoiqEQeGa1hOhhemjHOPIK+YmRkyWOpg2jaBNyZzTJJJA99QDJZbVKnJcqXrbprovp5ZZFHGpo4PKUsHw6lAlSi9acRUrCVNysLAtCpMFL6TYRSQD1yCzliHdJSpj6lMSuXQ7MYYZYWlZ0qVS46F5ZWYay6tsICRR6hj7gp02Of3U1bzhJbqUvgGlWNip/BwNGC62cBuGNx94Aiua9D1PPbunOY1L7mKMPRIypLZdpPd23q4rsvDS6uYnlHPqM43W2RpUXdRWlge1uObJgVLq/qcIYqykzLnJQgVQgjx7TLOwqQm2UN6DosmGapULEcTDk9Wuf/QGqZtElsxdgmHFlLKPCC3U2w925k5tANdXN4ir5y6q1NhFbhuRpTb2HaK5WW0VI4TZnVRe+XqRCJFPGzQnhkSrQaUOvj1cgqdkGTYpBOPdmOMLvuZJza+l5BbFn4/I08tklFIZRv1Mr7TyzEyg1EeonT90azEiKv6Si4SC9svqbwCr5MS+SX+2rE+927URG8+je2CWaOJZ9lMzbV56dYt3PzIfmY7DbZP9ek1AsKux9987jYm16aQVWxrt+uOTTr3aLrT5M4HD9dL9mtGQl9n0RvUxfB979jbqchy5ua69ed6K0QQnFoykl7m12P62BahQgghxNlOZkjPUTr4CUOXSZWRGDmD1ZiHBkdZjFYoopQDq8vkxoBFa4jn6lqfCttPsdwMw8koBzaGWxG0YwZxAFZGq5EyHDcwOhmrE59eP6FrpiS5w/SWFWyV4+okJFfRNHWnpQg3HGE1MyLDodDF7dslk9ipl9/zFQdHVRSlhRNkWFMJmVWR5Q6OnklVBmQ2Xl9n1euVfkWpS1GNfVReEgw8HMOqZygn4xzXMHB8k4buvORXLEcpX73vfsxBVQejW3b1WBiM6AU+F+6aRT+9LlyalAVVVTHbbdalrr7jij3s2TnN7h1T9fYH3epTJy09uguC5qOtP3U2/XS3cdJy/bfSaHh1CSkhhBDiXMuyl4D0HHRkNKyDnzpQqiAoHR4YLPGNhYe4Lz7E0XHOcpkw0T3kWzGVm6J0kJg5JJGL5xdY/QSlC9nHLq6tZy0tsEqavZgyc/G9gmiol7stmo2EUeRhmOCFOnhUrFZNdG8jx1RYhd4uUFIkDvmyi9fLcKwCS3dU0nVMVU41cCn0vtGJjWVV5Jl9LGCsDCyzgNimyiyM3Ky3AyjDoMxMfFvh62QsvaWgqPBjm+FCjO+ZzIUBKvO45IIddMOAalzR7zUYlTmX796K6zjMzbTZNdMjryruuOeRuoSTTkY6unysoP3cdLv+qHcmuOajb6dH408dvJ5qMLruqR4vhBDi3GNUG397tklAeg5qeB4Hj6xyx5FDLKdjjo6GdIyA2UbA/oWYwpzUrT4zq6i7LVmGoh2MIVQUpkGc+FSVhe1UmH6O6ep6ozF65dxXcb2M3g4iVKqX0A0mSYBtFIwynyq1aFsxDTPGbxQMCv9Yn/ZuhN+PMHs5VWpgezF57DLJPYp2haf71rciTD+utwG4To7SES4mkZ6hdfSmFwgcA2PoQmXRCHMsxySN7Hp/6sx0ky26/qhr1m1GC2JuuGKW1SIlLUtWVgZs6bSZajdZXBqzrdvGMg2wDS7ePsflF23jvv0L9T7Qxy7D61JPun+9nnle3yfqPrqE/3TpovZxkn1bzyGEEEJstPe85z0897nPpdVqMTs7y+te9zruueeep/QcEpCeY7K8oOm4mK5JrltaPrLC5w88xBcPP0hBg9SfsKIS2q1BvVTvhCWGYWL4BWps0/MiDLPAtTMUFZZOTEIxjPx6ljN1bPrNiDQ3iHBxg5xWc0JqOhgN3d3JZGXUxTQrxrFVt/c0PJvlpRZpaeG5Vb2snitdMN8gnInqn1EUMIjaFGaA6Sjy3MbMKsxQ96438RoFVl6RTyx8TErDZqW0GKUVTdNkttfCUwGxUXLljjn2Oh0Mw+PQ0ZTVtSFXXLGNyy7eQWe2STHMmdnWYt/hJYZRwjjKGOmWqpVi1/xUPY7m+mxo3Ye+ZHltUveX1zPP2v6Dy8crGTxdOtM/kDqiQgghNvmS/ec+9zne9ra38eUvf5lPfOIT5HnOy1/+ciaTf2kC82QkqelcY8Ch1SFRljFZzfni/Q+TGRkLKxOOJGPSRkoQVIwKB8ctsEtFqxlhqpLcHjCZ+Jh2wSQPcHSNUCcnT30csyROQ3LddKgq6QUZtNd0tEZReTg692ctoDIM3GZM6ZgYpVnXONXVmVRs1wXskzWTMnZpNCcQKMwYitw69qeTXgLXAeCqW/ear9PwC1WXhkqHLiYVVVhCbmBODMLKJGwZNFyLS3fOcdviAdyxS9Kr8BoOF0/NM1iOeOXVl1ONoNnQJQCgN9fhyNEh26c6dWOA7dv7ddKSHZiMq5J9B5fZs32qLn6vs+hnp1p1macT64ru3H4scP1W6tnURwNYIYQQ4lRtdCb8U33uj33sYyfd/+AHP1jPlN5yyy288IUvPKXnkBnSc8goTVkbJRgYDKKUQ/EaUZKyb3iUtXBM7mYoV0eUOX4jI8k93KJgsBqyOOhjlA7KVUzWWnWnpa41YRyHJJGFZZcEzRinqJgYLmuZj+2apKWNUgZmXhC7Njp9X8+uTtsTikphugW+XWDZYOQGzc4EvzuhwKIsFJOVNhaq7gRlW7lu1ETpVQRhXHdP0lsCqoGDpUuSGrp0WolfGnWCU7NX0fEdUiIWVsZUixVBQwfaitByWRtEtNshrmESeg6z/TaXnb+NtXFE0/bY99BSXWN0ZRDVZbK0wHWZ6oQMxnHdiUkHo5oOTp9qSScJRoUQQmzmOqTD4fCkW5qeWkOXwWBQf+z3+6f8kiQgPQes18FseR4Pj1bJi4Iojbn78GHKluJInDDOJ1jhGE+XXjIcArOk48cYnYL+zIBdUwvkuV/3grebBZglR8uAbhDTnB5R6ppNRoHpjZlvjlDKZhxZ+GGFYR4rYG8R0wgiEsvi8KRLFfs0/QwrP1Z3tCwN1NAhK2zSwkKZFoE/wu1kddtPnaGvuypZYUZWOHjdgmBInRhlOiWBXxzrad8yCW2Ljh0QxBZTYZ+O6zHTa3HVtjl6zZDZVoDbtum2vLpFqK8znzD4xv2P0Ap9moHLc6/aw/RUqw4614NHvYxeFGV9jBZnef2xbhN6ita7OAkhhBCb2Y4dO+h0Osdveq/ok9FVad7xjnfwvOc9j8svv/yUf5Ys2Z8DJkXGvqMrXLFtCztbHb5wzz4C1+DhySqPRCMSa4BrJySGUy9368AyNy2i3GC+kdStPgulKNKcxmyOGVWEVoHpw2oW4OYGoZ5ddUwCqyLOfeba+rnbrA4C+u0JgzSg30oYjkMyPXtq61JSsJK7GMrG1g3qjYLY1ntADVKzohz6pI6FWjUwY4tcV9XXa/a5QqUuZVowrux65d5o6U2mHoFV1i1Bd/Y6LKfLOO0uYWaR+QXbGj0s1+HAQ8v0LvEIlMV522c5cnCFSy/chu1YzHVbdS3QXq/JkdUVGo0ZxmlKNM4IXYdHVgbs3jJFHGd1kOra1lP+95CZUSGEEGfCkv2BAwdot49Vk9E878n/+6X3kt5xxx184QtfeEo/UwLSc0DT8bhkfo77jizyjUcWGMcJtx3cj1EqKm8Ju8pIS6cuHD/dH7Ky3CVPjHo2cCVq0DTLembSaSlUZjDJfGK98G9mWE6FFWT1DKleLh9mDZwqZTlzCZwS08oYjTx03JbnLrZVUOh+9GZGrpoEpASzQxYX+jh2QV7YVJWiKi1cP8Fy9ecmcWoTNPK6vFNuWHUNVNPLKMY6mAVr7NHyKnRlqFgpRnGCnXlcuXWOlSpi21SflYUhXtvmwgvneSSKee1Vl9Vvur0XzrEURfQr3YGqQ54XFGVFL2iRpHldekrvEdWB6kWtYzOjeVbUH3Ud0vXZUb1srz+XvaFCCCE2lNrgWqGPPrcORk8MSJ/M29/+dv72b/+Wz3/+82zfvv0p/UhZsj+L6QBp3UPLyzxyeI3dMz1Wopg7l1Y5nK2xENmkyqIyFK4DceRT2Cbn9ZewDYOOn5E6DmnhkQ5CImXR6cZ12aVONyI0sros1FrWrfechm5CVfpklU+U+wzzBpnhkFkmUeZg2gbtZkwR24TNhMqyqVIHz4sJ7IqOldK0dUknKFK3LjEVj30MZZCteWQ68MWqe9RXYx+rsHAK0J1I08pgSxM8o6K0RvSaTaK4ZG6qSzrO+J4XXMl0v8nu6Smed+l5TPdbVJ5Vt/o8f/sMhmlS5CWGnun1HJpNH8e2WBlH3zS2+rH1AHR9nNcD01K3dBJCCCHOkdahSqk6GP2rv/orPv3pT7Nnz56n/JokID2bOaqe6VueDHErq661+eWvPcDYmFAWIw6k42OF5XMT06kozRy3FeG4KUejJmEzZlB6WE5ClRkE/RXcKiNKTAInJx6E9FsjkrGHX41puwlZbtQBbmAltP0RncaIhjfGzEw6foQqDaLMhY6JSUGeuCSRj6McMtMkLh3GeKjUpmqouruToUNQ59gSf8POsCYWuAVVoYvgpzhTKYH+ko5M05C5oEPPmmJuqs1lF8xRpbBzusfDB1dwHZuVNK4Dz7sePAKlwnOduuvTtvlunbyk6+wvDI71pdezxO3Qr0s4RWn+uKWcHrt/1Pk2648KIYQQZxK9TP+///f/5kMf+lBdi/TIkSP1LY7jU34OCUjPYk3bZxgnuKZLmeXkdsFKkvC5ex/gAXOx7lfvkGF1Yqb8hKJyUKZNpxORlT6mXtIvTfLco9eZEOpGSVWAq/96MgoazRH7lmZIbQuvqZfrQ+IixHYzUhwGkxaZLm4/aRF0ImyzrGuLErsUiUG3mdUBalbZxLrTEgbJ0D+2T7SyUIs2pjLrpXLdwEjp1vKRV7fpNHMLqzQIDQt3JSCsoF34JGaB41roCFVn3R+OIhzHorAqGoFLsx1w49V78fT+0d3TbJ1qM91p1PVGoyQn0UlKBjQttw5AFxYHtBrHZkp1Jv56tv23SmSS2qFCCCHOhiz7U/WBD3ygzqx/8YtfzJYtW47fPvzhD5/yc8hUzlmu3wy5a/9RHjh0lFtXHmEliVhRKxSFQ9nRM4r6IlCsVbqoe1yXaEp04ribMYlsfKvAUAWD1CMrbaaaE+IkYJCHeM6Elj+hMB1aRkbgRYzcgKKyMKuKVqCDXBPLhMGwwUiXcjKq+jE9I3l42K1jT8NS9VK+QUm3OWGQeShHYTtlXdPULGwcvV8UDzO1yc0KI6/wXV2U30Aph4FTMVuZtP2QwLe4sj3HwMoZHlnjJd9xGcNhzGy/xbapDvfvP8wFW+cpiopD4yHb57t0mj5lXhH4zkkBZTjTOa3/fkIIIcRmr0O6Xs3n2yEzpGcxnQmuE4RmOw3uWlpkbTzhpsFdeFaEr+slFbq9ZU5SuDT9CR45UWrhuoo4cymUi+UrWjq5yMnodSKizKqDxsDICHUx/NzFtXIS06YoXUK3okVBYGX1FoA0sWg2J/WFpn+uVxiEVkXoHEuIwqvwzRylY+PFRt1e1DIVnp9RRlY9O1tENtk4xHb0Hk+FoeuX6tqhpku3dGgFiqncYroREpguc80e7lxAp9tg68wUdmXh2rrVp4Hf9zhvyzxxXuB7Dttnu/TbDaKswAuOBaO6ZeczQco7CSGEOBc6NT0TJCA9S+muQUGge8FnfOrOe1gdxzx4eIUkNjm80mElauKFGY3OBEvvB9WlkeyKhleiU9Vnp9bwGimmlVPkDpauSF8owiDHrApMJyWgot8d14Grbu05wcYkA1sXHbXxg5wgSJnkPsrO6iX+0q2oXEhyi6osKBObdOLWhewbjaRe0rdj3X/exbQrKl3kvjApTYMit7G6BYZt1t2Z1nJVz7Q2zIDLts7XdVb1DOgF8zNsbXQoMGg2PRoNhysu2kYYOsRrKS1dk7TdqLs95eWxBKSpVohjWXWCUvZoBv1klJw0pkk9dUzds/5USKa9EEIIcWpkyf4s5ftOHVwdnQxpNQLuXT7CXclhVGOC7xmEnQmFDeNcz2rmTDKHtt4faWW4ecGS3v+JQafKybFwdDJS5WGqoq4h6nsliWGxPGjS1r3rSxNinRylC9u7JLFD6YSQ6oAxZVz55GmI7yTkYx+9ju/owJYKvxcTrwZEsY/TKCmVhZ0oSsfAUgqlp3JNHSi7VIVHG0WeOvgmzPTaGKZF7lVYhcHOuT65WTK7tc3CcEJvusPS6gTHdjh/1wxYBklRMN851mHp6OKx5KV1RgVBw62XH1xfz6r+C70XVdN7UYUQQojTxdhkS/bPBJkhPUslecGh1QF33XeIL379PiYqwTQLwjDFDgoKwyYwSjxHJ/FUdNspeWpQ5gaZZRGPQnpextG4QaJMBlGDvc1Fslxn63u0/AK9g3OqNUaVOZQVU/6EpDCxHV2HM8GsStLEBlf3qzeJCodk4uEGMUni1HtNY6cgzXTRe4NGO8Y1S4pUP13dMgpDmRi60OjQIwwL2iXoDqSuYdA0FfE4YzbweM7uHShMzKzESCvSYcZVe7ZwyXldLtw5S7/bQIe2SZQx127WY5RmBb1eow7cF5eG3zSrqROpTqQz7oUQQojTrlIbf3uWyQzpWSqrckpTcSAacl+5xIHVEU4nJVW2rnTE1uYaURESGDGhXZLlNmZD0bUjlrMWYXNMPDHptYcEJkxcgwN5E79Z0jInrI0DAjdiXIYEQYWdKiZVWHd8GqchZWqhSovQTxnmPo6Vk2cenTAlUQ5GZZJPfDyrIBp5hM2U8cADHcCaeo9pTjLycBoZmenWuwBcy9JlAepI8Tv62zmsxviGxZTbohG6vOJ5l1OWBZ12iFeYbJ3t0gp8Gh233g6jA8y1QUykuyyFHp6ObPXMp219U8a8YRjYT6ML00bQWwcajxbkF0IIIc5Gp3XKR1fyf81rXsPWrVvrAOCjH/3oSY/rZdN3v/vddemAIAh42ctexn333XfSMSsrK7zpTW+qOwl0u11+7Md+jPF4fNIxt912Gy94wQvwfb/uy/re976Xs9naYMLhw0PKJOMf7/0G964cxuuvkbs5tpnTaqeUpa4CatV7Ri2rQtkVo8SjMF0sMqb9Md0wZsZJWEtdMt2OXhnkE8hKr64Zqmcpde/4tdin442x7ZhK6cL1irSsS3wyihvH2oKaFo4qqPQM60jv10zxK53MZEBlkozdej+oznMyUot42a3rocajoC4/4dhgZxZGaXJBb4pmy+HSmVnm+i0Wk5hklBE2XHbOTmEVsPf8OUq9J9Z1WVob43l2nbC0Y0uvDkaPLg3rfbYnNg/YrCQYFUIIcRJJanpmTSYTrrrqKt7//vc/7uM6cPy93/s9/uAP/oCbbrqJRqPBK17xCpLkX5JNdDD6jW98g0984hPH21W99a1vPf74cDjk5S9/Obt27eKWW27ht37rt/i1X/s1/uiP/oiz1UIckVLwuQfvp7IshnlJpJe4uxW2bRCXx2p5hlYMpsK2SnTOUmZYHI0DSlMXgrJYy5ssVj6zYUTTzbB0YpGeoiwLpoMRpqWYJAYdu6DIXFTu1DVDfS9nppUQOilWkFOVNmWuSBOPVd11yS3ohRGpYxAECYGfUle9T1zMRoXnl5jKJq98dOWnbm7RKEvahcHV2+exUhNaFktpzHP2bOf/970v5tqrziMwbVYHI87bMUtplgSGyyBK2LVtinGuKw5UDB9NVJqdbteB6ePVEp0UJyczCSGEEJuJsdHdmk7DazqtS/avetWr6tvj0bOjv/M7v8Mv//Iv89rXvrb+2p/+6Z8yNzdXz6R+//d/P3fddRcf+9jH+OpXv8p1111XH/P7v//7vPrVr+a3f/u365nXP/uzPyPLMv74j/8Y13W57LLLuPXWW3nf+953UuB6NnFMk5se3M9n7nyQB/JDNPtrREmAV6UMVUCvEaHzxW1TMZkEJI7CtRLmvAlR5NYzlsrUOergKkVumOhQNM1deuG4LopfKpPluInjge+OWJt4da96PZvpUlDq+vdYdaelLPFwzArTrFCVS7FsMWibVJXDZMWrp1LdRqpL9JOtupilVb8hrNzCNSuqymC+3STVRf4Lg4kLQWmTKD3TW7GyFtEKXRZWR3z3jZdy30NHuKAzx5HVEedvn67HxFVmva+232scz5jX3/t4mfANW2YkhRBCbGLqqRevf8rP/yzbtFka+/btq9tO6WX6dZ1OhxtuuIEvfelL9X39US/Trwejmj7e1AHZTTcdP+aFL3xhHYyu07Os99xzD6urq5xt9h1ervdKLiarPDJeorAz0tKhcBSWFzHfXMIxIhxLJyVB5WT4Rsoo9knGDrlysDzd117X5czr4DOwc4aFj28buDojP/VZSnSSUIFVKrLSrOuC6iBXz7pO4gAzBw8DU//J4+pappN6eT9QaT0LGsUGoR2jfIXVS0mjsO5fb4YKw6mwGznN3GC75zPf9bhw+xwvuujCusj+jZfvYcf2Lj/8qhvrvbL90Ge0FnHB9hmOLA2Y67ZxXYuZXqOesdXWZ0P1Mv36vlEpyySEEEJsDps2INXBqKZnRE+k768/pj/Ozs6e9Lht2/T7/ZOOebznOPFnPJ40Tevl/hNvm5kuZbQ6jiishE9//V5ueWg/g2CM7+dYrmKqO8G1dR46ZNjkhkvTSWhbJePCxbCtes+lY6cUpWItb2BkOZZtMM5cfKfCc1KixKflFvTdiMq0abTH9fJ+ZVjMtIaMU48t/WUSw2YUe/h6f2riMCgaOHZJqtuAmgWBY9SZ/J5Vki8GmGWJoXt9Dg38oKJRWYTNhLQssSqHwjq2L3XP7hkajstomOHaNt/zvKuxmw7fef2FOK5NvxXS7zdIsqIueK/3Jp9IB6aaZW/aS18IIYT4ljZ0uX6DS0o9Efmv8hN4z3veU8/Irt90MtRm5ts27YbPA6vL3LfwEPtWByROTqFKWnVL0IJYL4VbCpuSWXdElDk0vIKGp0snDVGVgWNVOGZOaBb4Ts4gDRlnTj19r/eBdv2IiQ4QlYHOQTf0vtCoSVXYrE1aNO2C0C/JJh6OAeNRC89LyZd94kGTMvIpljxKPVGZW+QTE8NXVLmL4+s0KwNzbNB3HPrOFOfNTPHdl11Avwo4b1eXthOQZSXXX7KTNC85eGCZ0LRZWB4yO93Cb7p10Nlrh6f7n0QIIYTYGEqSmp418/Pz9ceFhYWTvq7vrz+mPx49evSkx4uiqDPvTzzm8Z7jxJ/xeN71rncxGAyO3w4cOMBmp9uEHlqKuO3QMlV3SNPPCTpjTFIcr6DMLQZFSNMrWE08uk7EWubU5caKyqDtRfh2RlSYRAo6foRnxexsLuHbBaZVHeuwVBl1Zr2vOylh0A4jbKNCTfS+To/7DvcpXYtS95nPS7JhA50+r3SDo1KhXN0C1MZwS6rcplqz0PsHyrHLLt/haj3rbZp4rsU4TRiZBS+75iKmWl0u2buF6y7bxcU7txA4NmEzwHZs0ryg1wxx1LFLuiiOdWBaX6IXQgghzhaGUht+e7Zt2oB0z549dcD4qU996vjX9LK53ht644031vf1x7W1tTp7ft2nP/3pOpta7zVdP0Zn3uf5sbaPms7Iv+iii+j1ek/48z3Pq0tJnXjbzO49eJSv7n+Q2+4/yMPZKqlhEGc2pm3UbTen/BhlKFqODtBMQj8mw6uX8evAUen2nAF5UTITZuwIxpi2SVLaHE669fR91804lu9j0nArxrnNMAsYjjyGacig9BkOAqzUIZvYGEWJ0n3pWzFz3gg9peoGKZaV1zVK3VRh2Tm+UdHwFXOmQb8REscFs67LtTu2sWPrNLoYQG+qwd6tfYqy4nydRQ9sm+uxd8cUjmWwY75XF67P87Iu5VRU1UlL9EIIIYTYvE5rQKrrheqMd31bT2TSn+/fv7/e+/eOd7yD3/iN3+Bv/uZvuP322/mhH/qhOnP+da97XX38JZdcwitf+Ure8pa38JWvfIUvfvGLvP3tb68z8PVx2g/8wA/UCU26PqkuD/XhD3+Y3/3d3+Wd73wnZwsdgOl2lnc/vMKhyRqRURIGEZ7e92mWGLbOkK9oNyd07AlJrPvCW3XWe1DmmMrCdwoqlWP4ej9oRYRFlNrsbQ/pmLqIFETKZHUc4NvpsSYOiUGlbDpBQWgkTLWHesEd5RnoMNd0FA3drWnosBg1sYyCdKkBEwsjN4hzhzz2CVyDZmzScgJG5RpT7YDpdpPSUsy1G8z1mtz74AJ37Vvgmku3EyUZ/XZIXlW6hj5T/dbxPvO2Y9bJS2VxLCAVQgghzjrVs3A7l8o+3XzzzbzkJS85fn89SHzzm9/MBz/4QX7u536urlWqyzPpmdDnP//5dZknXeB+nS7rpIPQl770pXV2/Rve8Ia6duk6vf/z4x//OG9729u49tprmZ6erovtny0ln9IyJypSDiyuctuRh9hn3o0dBFh+Qb8xpLQs/Kog8EqyTJG5Hr1WVLf4zOrFfJftrUUOxW1Qelndrgvm685Ka5ld1zFtuTFp4TDJHZLcwTULJnmDhp8wSlyWoxZ6pdxLi7rlZ1VUeHZFMvDroLPbGjFJwjoItVoFbp6Rpzat1MRrwKzZodf0SeIcC5+ZXostM10cw+CiLbMMopjdW2eY6TVZWYnYs32Kew4ssHOmh+vYROPkeJ9PXfz+xL7zQgghxNlmo5fVT8eSvaF0wU/xpPR2AR3c6v2km2X5vlQVWVmwPJzwP//xy3z+8AOshQ/idzNKo6TrjrGcot7rqfvGF/W/tMFEd0SioG3kVI7DWmrT08lIdsr+cZ9t4RpJ5TEsnXoGMs1cXLdkOPHQFUkDL2Wc+uS6DWlm07BSVpb7WE6GaVhkmVEnNGWJiWFYVGOvDlK7JAySEFfPqJYO07lPq92AqGRrt8P2bVN1mamLt29lfraD5zncdtd+rrpkJzumu3VgumfrNA8fWmZuqs1wnDA71Tppr+j6En2WF3WwKoQQQpwtccfw0a+98AXvxt7AmtlFkfD5f/qPz2rMI//FPkPpBCbLNI9lwpklI3PAoXgRr6swzBLTPFbP07Er4sJh3h/VxeoX0gBPt/c0rXqfqVlZtM2S3CgxjIqOO2A581CGwTh2adglpluyFIX0g1QvyDOMQ9Lcpu2Nic2Q1WELwynxwpxxZFEWFrku+RRGGCbktt4z6rCWhRiFTTEw8QwL1TBoGDbTe9tEcYnTKOl5zXqpQO9Z7Qce33X9RXU/+jgtaDZ8jiwO2LV1qh4DvV9UGycpzcfsFX2iYFSPW5LnhN6/1KUVQgghzihqgzPhT8NUpQSkZ6g0ybE9i31HlvnoLbdz8yP78PpJPSNq6jqfQVYHmiuVj2sUPDIJsL2KvHAJnYy2rjeqTNLKIHAKDk76FF6BWaVM+RGHJ11CPyM0ctIsYCqckGUOeWER5U7deWkYhZTKxXYg1ZtKYxdj4uC3UrIK8tilWvGwXYWVWnVZJ99KmSEE5TDXCAk8nwCXG56zg1vveojzr5glsH16rZDlOOE552+vA8/KhE4YEMU6VR9GWYqtq+Q/5o0TTVKC0P2m+qPrdKF8CUaFEEKc0dTZ16lJAtIzlA66ojxlYW2Nux45yMAZoewSpUrWopALO2vEhUXTyckrA8OwMY2cuHQJzBLPq+p9pI5Z1KltjhXT1kXsrbwu69R2E5azBoNMl4nSfeFLRjg0wxRDZRgVqNJkqK/ZvMSzdKBqUyYORVFPi2LoxPq6ZWjJdGCQrjjM9Xwats1cp0dEwRtfdg1pVuAW8AMvuZ6G6zI33+WhA4t1Gae1UcQwStg516/byUZZTrPh0XI94jir23+e2I8+lO5LQgghznLGBhevPx2F8SUgPUPpZWpllty5vMCdyUEGhkt3KqLjRbi65mdu0XVTRrmeIVW4dl6XcNrSHuConBgbwzR0V0+SzGE6LOoOTfqSGKYNKnI6Xlz3rx9mLlHlUZQmqyMTw4OqNAkaJYxsisqknLh4vs7ST8hSGyMyoLDwdSa/MtlidZnMFbQdnx27PLp+s+7A9I9f/Aavfe5lxEbFVK9FlhVEUcb5O2fxfZfBOGam3axfs571nO0d+1wLApnpFEIIIc4GEpCewW694xC3HDnMoCxoza4xFY5JKgvPLlktHcqixLdibFPV3ZVcPZtIgmGqOsjMbbPOZE+UT4sY185Yzrsot6RjFYxLmx3egCNJk0h5TPsTDuVd8oFJ0ywYli5FZEFlYeuZ0BSq3IG62L6B7UJfuUzrnvJlwla7x7Zmhyv2bmXabtVF8q96+fZ6hnQSZUwmKVtnO/Ve0TQ9VsZJz37maXF8mV7PjD6RyTil0ZQZUiGEEGc5JUv2YpOwDJND0Sr3rhzACjJMW7f6TBmlbbreGh45BQZxQR0c6jrxYV2U3mCUucw3xtw/7GI4Bq6TYhsJR3StUEu3bbIYmR5JZpObGaGbY6UwKhz6/oSx7dB0C1aXuuTKxEFhGCWThRaVp7BXPLygwvUL5sIWxUrOjh0t4sLjqvO2QWZiuSZBYNd7YENsOv0GjmuR6f2ilaJ89M2QpPnxzHm9u4BvMSkqwagQQohzgaGTfzewVuhGPvcTkYD0DHTvoaO6ehOf3n8XSXWUsFMxHaQcnjTY2lpjJWvSNid1ZyU9s2kZGS07q0s/uVZK06sYJD5bghGZXpLXM51FwLSTsFLYVGVBVnq4OqDNm0SFh1Xk6NKea3mIWSiOrjVwLEWblMGggWl5qMqkaaXYPQNrYrHNbhHgsGPPLDNTIQ+vDGi1A1zTot11uWB+jrJUrMQR6ShjbudUvU+0Tjx6tJ7oiZ2WpOuSEEIIwVk5Q7ppW4eKJ3bh1lk+t/9OHlx+hHZ3QNdfIzNgW3NA6OVk+jo1FYlyaHiJjl1x7RJsgyN5A7cqce0UWyc7uRA6FYWp+9C7uFaBbduo3KCoFEXpUWYmgZuT5w5FZGNVUEYe5dAhLj1UZmGMTOwcjNxCFSbt0MRIK3RC+7Z+lwyLNzz3OfR6Ib1uk5lWm6Qs632su+b69KcbdTH7TEmHJSGEEOJcIzOkZxjdo/3ew4t8bf8+jrJKqFwcEuaaI/JKMckgtEqmnEmdZa8L3PeCiKKydcd6OnZaF60flQ6ZaVMVRh1AZpVHWpjMhmOWcrMOUnXhfbMsaLiKxYUZDKfA0clRa2Fda1QlHnZa4BomdjPFsQO2pE3mtvSZm7KI1iyu2bOV6X6DfqPJnm1TtBs+lmHUs51xktX1QidphmdaddJSyz/1WVBdDF9mTYUQQpxzlNQhFafZwmjIF/fdzS2HlyiDY/U59d7QxdhnR51Bn5KojKwOQEswrTpAnRQGgamIK5+jlYtVZoR2xmLVpu9OsLKC0rF5YNCj70espG3cClpBxOG1Fo12TD50MGIbx4spYz25rlC2hVq1MJMm5zebXPqc7SzsH9Lxelx3WZ8XXH0hSysjmq2Qg4dXaHcD+o2QQlV0GkH9mnzbxg2e+qV4KsHoOE5PKgslhBBCnOmMs7B1qASkZ5jBKOGrd9+D8o/QDBK8cELopjQcne+TkOAQOjFlHmBYBm0ihnrfp1kQV7r1Z6YLPrFaBbRJ6FgJq1lQZ+erwkGHbmXpkKY2lipZyTsYkUPuWUSjQDdRou1lWIWFkSiKicecB+22R8v3ObQw5vyZKa67bAc9t8F9h5fYtaVPaDvsvWovDx5ZoijL473ntY1s8SnBqBBCiLOOOvv2kEpAegY5ujTkvpWD3DtaZtUO2TqzRj8YoXCYswfkhcm07sBkKlYUbHfHDHTSUm7R0Vn4ChwjBddCmSZZ6bAaefhWSVL4UHn1NTiIAuabIw4c7WKZFk0vYWXUQvkKc9Ul03+ZjXVb0ZwLt7bwLBdbL7WnijnL5Htf9hxGi2P6nSaTcYJVwuxsq66d2msEOI5N8zFL8zKTKYQQQpy7JCA9Q+iAbWaqxeHbI7LWUXY0hzTDCao0mGuv6c2ldT3RXNlUOfWy+9EsYNpLULbCNUusqmCYuHTcksNZyE5/hdy1iLKg7jXvqxTPUqxmPotrHShcEtMim3gUma43alBNFFnkMu9WNDt9dnRm2NpusziK2HFen73TfZqBw93DMZ2pFrv2TGMeKyl6LAh9gj2iEowKIYQQp0hPYG5kDrDsIRVPpCpLvnLPfv7vHV+mCAsiw2RK566HeuazpHIrrCTDKC0Cq8KoKtpOhqIkzi0qy69rkbadgqXYw65K7p9M0zJzCp3gFLsEQVr3uk9Ln1HUpKtSlpfauOTHMulVvSWVFgZTQRtd1Gm+H1C2DJ67eze75vucv72NgcfVF+6ok5eMQso1CSGEEM8k4yzcQypln84Qgyzlb+67hXGRMSh8eo2UxHAoM4vQjIkyg76b0LJTGmaOaTus5Lo8vsOMbaCUwZQV1bOfvm2iLF3QPmeUuBQqqzPx09QjwqSMLIIyZ3nUwnMiysIk0M85cWgqix29HhdOzXLZ7Ay7Z6bpJj6mkbFjrks8OjYTOtUO2TbXPWnmU2fFCyGEEEI8lsyQniFGScxn7rmHvH+Unb0xgZfSNmNKy2SoQmJ82maEYysW84AeCVv8lFw5DA2bqLAZqw6uVZHoMk+ZSWk4ejspWWmyGDdJUp9Zc0xShNiqwMhNLByyiYVr2/Rtg17YplkZPO+83Uxv65FGY3bv3ML0VAMbkzV1rAWoepw/dWSmVAghhHimyj6pjX3+Z5kEpGeApeGET3/jDjJ/BSsosJ2CJHfZO73EIHLIKguzMsgNhZHbWFlJ6pl1Vn2pYK3w2OlOOJoGNMyCqHLpOBmT1OLAeJq49PFKAxKIXReflNGwjRlZJCbomvp+5eBZNs+/cCc3XrSTlVHJaGXMC597EeNxgu/reqgWu2f79TmXZXVSopJOaHpsIpMQQgghngbJshenQ2Uq/vmBQ0wsRc/OyMnZHkasxE08J8apMrr+sez60Bvj2wZRZdfZ9/NeTFXYHEybBHppvzA5mjbwDYNh5dV7TaeMmNj0sDOTyLApRyGO7tQ0sGg3Tabdgl3BDNu29dg9N8XN9xzhuot2cd6umXqf6Na57vFz1YFn6LoMJjH9duP41yUYFUIIIZ4hld7oucHP/yyTPaRngNvuPsDN2T34YUazETETxFjoPp0JlYLCcMAqcFFYloFeaLcqA9uEpTzEdwvKyuBwMlXf1pI2K1HAIG7gVDaTtQbjxZA88vEGFsXYpli1cTKDLX6I024Rtlyu2rmVlh3y5n99HddfsZv7Hz7KahTX56hnQ9cDT92L/sRgVAghhBBnr89//vO85jWvYevWrXXXxY9+9KNP+TlkhnSTU0rx2QM3QzNh6/QSXW+IZ2VYli5cr2i7MVZpMFEm8+aEO0fz9LwRXS/lQNwkq9uCKkIrx6gMxoVP244ZxgFGabCypnPmK8rIwPUqkszDiXVgq7hkukHbD5nptPnOK/dw4fY5fNMgsEIC1+E5F+zAckxGaUpLyjYJIYQQ52SW/WQy4aqrruJHf/RHef3rX/+0fqYEpJvch276Z246cA+qbTIpXLbbOY4DZa5wrAq3UphGRYMUZZX0nEm9RL+Ei2EUdeCqKo9Hxk1Co2CSheSl3u1ZoWJwKCkSCzcAM4J40adrW0x5Ljt3ddnVnWOm0+T6y3eRpBXTfY/Adupz67SPtf4UQgghxLm7h/RVr3pVfft2SEC6ieVFyVq2ygIFW7pLhH5M4JaYKqdwXVRuYBpwKAvY7o+IM4uOH1OUNitRk7U0JLAzktShF05gbJInFpbubT8MqTBJ13yMvKI86uM3Kna3ShpGk2nX4cL+Fl547YWsRhFxXEJcYTZtJnlC69E+9EIIIYQ4OwPS4XB40pc9z6tvG0H2kG5iwzTiI3ffitWa0HAnOCphMWpSVroYU04/jFnKHWbdCNesSEyXxSjk4KBJbDq0wpiD2TQFdr1E/0jSxzFhba2LSmzsoYGTK5j49Hop07HHdDHD3FSPGy69mCsvnif0XJ5/5fk0Gy47d05xNJmcUjCqW4YKIYQQ4sy1Y8cOOp3O8dt73vOeDftZMkO6Sd31wCFuWX2IlWiRuV1jPDujMAx6/ohxbtHWJZ50rVBlEmUuXbsgKQJ6Xs5a6pFmNj2jpFllVKXJeNxgbdAmMEqq2KTILcq4JE9cWiOLRj/ggq1T9PttWv2AGy7by+4tfRz/2PL8XKdNlhXsnZ466TzLoqpncv1Hj1vXaPrP6ngJIYQQ5wz17MyQHjhwgHa7ffzLGzU7qklAuklNz7S455ZDOGHClsYKjlkwVDYdM2E2rFgpbXyzZCoo645MR9OQgop9406d5T5nJhyIu6ymLdKRQzT2MC3FaOShxg6hVRBPWgSRxc5egNNwuGLvVrZtnWbrli4X7ZrDc2xW1qJ6Hn0yirBth2m3edJ5WrZZ34QQQghxdpV9arfbJwWkG0kC0k2oKCsC3+HOwf2knsJ0wDEKtvspy0WDWXuIaSiWsxYte8KcE5GVipW4g4eBZRociDtUhUke68V9A8/ISSduvQe1MB3KRZ8ePlO2wRV7t9P3Q17/vGtwAoe8KuuyDXr2s98NScqC+eneNxW7F0IIIYR4JkhAugktro34yoEHeCBdo92PyfOcIARVlLimouUUUBk4VkTTTlkqPJLKoKxgKfOoKqsumm+rCjIDN4Y0D8mGLtWCg1M69EqHG3fP0ZlpceV52whDn6gsmXZ8Qtcj8ByiKMPzHZq2VZ+XZZkSjAohhBCnmbHJyj6Nx2Puv//+4/f37dvHrbfeSr/fZ+fOnaf0HBKQbkKtps/Hb78bx05oeRmOZeDYOUkWEFgRi3GLGX+VI0kDU7kspQ0ssyQvXQKrYpJ5uIViMOlh5RWDYQsjszAL0A0+LwoaeDMu0/MB11x6HtdevoujC2tcsHu2Djr1TKjeL9poSPAphBBCbDpqc5V9uvnmm3nJS15y/P473/nO+uOb3/xmPvjBD57Sc0hAugmtLo25c/AQxlTKlDfEdCpUCaEZ0bETKgyW8xYts+CBeJqstGiaMMxDlGExjEKicYNyYDGaNKiWHMzcopXZXNZr8bznnc99Dy9z/SUXsWN7B1WW7N45Q1XpgvjHZkL1TQghhBCbUKX0NObGPv9T8OIXv7hu5PPtkIB0k0mynI8dvpu4sUgYxMwEY+LKpihsAi9lOW1TGhaGkWOYBqGVsJa0yG2f8cRjJW5A5lImFtFCiKmX7ZXBTOxwwV6bS5rTbPE7XP/ivczOdel3G1RFVbf81LOi6ybDiEY7PK1jIYQQQohzgwSkm0ypFJ+/9V4yu6Rrpkxym04Y0zIyUmVg2xm6z5JZVizkDeLEJSkajCIL16iYDyY8tNhCLTk4WYmdOHi+zXTHZtvsFr7v5d9JWhYsHh5x0QVbju8JfWyykgSjQgghxCalNteS/TNBAtJN5s6Dh3lQPYAyKxxLMTYc/KwE20Dp/ymLEoWpFGtJSFBldVZ9nHmovOLQ0jRWYRJPPJqVyaxlc2F/npe8+DIu6vcZpQVXnL+VbbMZVQVxltd96SVZSQghhDhTqA0OGiUgPafFac7y0ioreUq/N2LGGzAobQrHwFLQslMWkhZ7/DUWixY2BgtxnyS1WTwyg2lXVEc9slFAozCYTz22zTd4zsVbaeU2JhYX757HdWz6HfmnF0IIIc5ISmZIxQbKs4IHBmtYjqJhKw6Nmly1bZEDUYNuMGZShgROxb58mqMjj9W0A6lJOnDJIwt75GCNHaYwmHWaXHhen++64mKufc55lGWJ7dg47r/8k0+ilEYoM6NCCCGEOL0kIN1EHMfmEw9+g1wv13sZc+GYsjTYEy7gmRZxalBRcWDQojRtsshhMrLIV9sYB0N0tdDzvJC20eC7rju/buc5N9ejzEuaLZ/OY/aFSjAqhBBCnIEqPYO5ebLsnwkSkG4iB4ZLjMNleo0hrl2RViaumTFM2lSYDIoGZWFgmy6rq03y2CY70kKNAjqZyfyUy2VbdnDljnluvPJ85rZ0qSxo+RJ4CiGEEGcNpSvoVBv7/M8yCUg3ka88cICj0ZDpdgYFGLbB0azNrDfh3vEMjoJcmZSxiZEYJPsbKOXSqCx2TbncsPc8dk33uWzvNrZs6xEEbl1GqihK7Ee7LQkhhBDiDKdkD6nYQFN+g6qEvDQoDR1EQpEbrJQ+aWFTpgaL45A0D4gWA4zMZXoQ8MPXXkM43eCi86bZMjfL9tlO3Yt+MklP6rYktUWFEEIIsRlJQLqJLIxW6tJOjleyVoRkiUPPGDMqeiSxx3DNJ4lDxoMm6t6AyyyPC87biu0ZXHjJVq6/eDejUUIS5wSh+02tPyUYFUIIIc4ClewhFRvIr3ysICMwctLKxjcUjnIoqXTlUbKxT7Vq4K0Z7PQcXvX8q9gWtLnk2p1cuHtL/Rytln+6X4YQQgghNpKSJXuxgZbSNZLIpnKcugOTFdk8EnfIhx62UzFeCVH7Ay5wQv6/l34Hl1+wndmZDl7oUlUVpin954UQQghx5pGAdBOZabRxW4ojSyGeq1hMA2bcEY9Ebcw1RXWgxfmhx3effx5b5vp10lJRVrR8hyTJCaWMkxBCCHH2Uxs8i/nsT5BKQLqZ3L70YN2rvttIiCcBHTvl3ru3Y0cV0eGQ5/ZaXL5lB69+1Q3Mz3QoLZhqNervVadhel0IIYQQp4GSJXuxgb77iqv5u8/cROb7jNcCMgXufoNOEnDV1nledMkFXHPdeVx8wVbGSUr3hPqiOqteCCGEEOeAStcJrTb4+Z9dEpBuIulQkSQh8bKNWVZED+iC9wHPaU1xzYW7+O7vvoq5bX3GcUozkOV5IYQQQpwdJCDdRC7fvpVi4KGGChyT+YnPea0+3/uaG7nymj1M91v1cRKMCiGEEOcwJUv2YgN9+Z8fgAWLwvDYOTDZrdq88//7btpTbZKswLIki14IIYQ45ykJSMUG2jbbZeaoi9uy+b7rruSSvTuY3jXFti39031qQgghhNgsKimMLzbQbL/N1dv7NC2D73nVcwk9l27/WBa9EEIIIcTZSgLSTaTpubz+1ddxwY55du2cOd2nI4QQQohNSKmqvm3k8z/bJCDdRGbmO7xo6gocx6rvT8YJjaa0AhVCCCHEY/Z4VmfXHlLJktlk1oNRTYJRIYQQQpwLZIZUCCGEEOJMojY4qUmy7IUQQgghxJN2UjI2cJ+n7CEVQgghhBDn2gyp7CEVQgghhBCnlcyQCiGEEEKcQVRVoTZwyV7KPgkhhBBCiHNuyV4CUiGEEEKIM0mlwDi7AlLZQyqEEEIIIU4rmSEVQgghhDiTKD2DuZFln2TJXgghhBBCfAuqUqgNXLJXsmQvhBBCCCG+JZ0Fv9G3p+H9738/u3fvxvd9brjhBr7yla+c8vdKQCqEEEIIIb4tH/7wh3nnO9/Jr/7qr/LP//zPXHXVVbziFa/g6NGjp/T9EpAKIYQQQpxpS/bVxt6eqve973285S1v4Ud+5Ee49NJL+YM/+APCMOSP//iPT+n7JSAVQgghhDiTqM21ZJ9lGbfccgsve9nLjn/NNM36/pe+9KVTeg5JanqKG3yHw+HpPhUhhBBCnOWGj8Ybj5dgVJBvaF38+vkfJ+bxPK++PdbS0hJlWTI3N3fS1/X9u++++5R+pgSkp2g0GtUfd+zYcbpPRQghhBDnUPzR6XTqz13XZX5+ni8c+fsN/7nNZvObYh69P/TXfu3XNuTnSUB6irZu3cqBAwdotVoYhvGUvlf/haH/UfX3t9vtDTvHM5mM0ZOTMTo1Mk5PTsbo1Mg4PTkZo40bJ6VUHYzq+GOdzl7ft29fvUS+0fTPf2y883izo9r09DSWZbGwsHDS1/V9HUCfCglIT5HeC7F9+/Zv6zn0RShv2G9NxujJyRidGhmnJydjdGpknJ6cjNHGjFPn0ZnRE+mgVN82Ez1ze+211/KpT32K173udfXXqqqq77/97W8/peeQgFQIIYQQQnxbdMmnN7/5zVx33XVcf/31/M7v/A6TyaTOuj8VEpAKIYQQQohvyxvf+EYWFxd597vfzZEjR7j66qv52Mc+9k2JTk9EAtJngd5zoTcCP9HeCyFjdCpkjE6NjNOTkzE6NTJOT07G6NScK+P09re//ZSX6B/LUKejYakQQgghhBCPksL4QgghhBDitJKAVAghhBBCnFYSkAohhBBCiNNKAtIN9v73v5/du3fXNcNuuOEGvvKVr3A20p0bdAHdE28XX3zx8ceTJOFtb3sbU1NTdfeHN7zhDd9UQHf//v18z/d8D2EYMjs7y8/+7M9SFMVJx3z2s5/lmmuuqTeGn3/++Xzwgx9kM/v85z/Pa17zmrqwsR6Tj370oyc9rrdw64zELVu2EARB3ff3vvvuO+mYlZUV3vSmN9W167rdLj/2Yz/GeDw+6ZjbbruNF7zgBfV1posvv/e97/2mc/mLv/iL+t9EH3PFFVfw93+/8Z0+nokx+uEf/uFvurZe+cpXnlNj9J73vIfnPve5dWMO/d7Qdf7uueeek455Nt9jm/X32qmM04tf/OJvup5+4id+4pwZpw984ANceeWVx+th3njjjfzDP/zD8cflOjq1cTrXr6MNoZOaxMb48z//c+W6rvrjP/5j9Y1vfEO95S1vUd1uVy0sLKizza/+6q+qyy67TB0+fPj4bXFx8fjjP/ETP6F27NihPvWpT6mbb75Zfcd3fIf6zu/8zuOPF0WhLr/8cvWyl71Mfe1rX1N///d/r6anp9W73vWu48c8+OCDKgxD9c53vlPdeeed6vd///eVZVnqYx/7mNqs9Ov4pV/6JfWXf/mXOnlQ/dVf/dVJj//mb/6m6nQ66qMf/aj6+te/rv71v/7Xas+ePSqO4+PHvPKVr1RXXXWV+vKXv6z+6Z/+SZ1//vnq3/7bf3v88cFgoObm5tSb3vQmdccdd6j/83/+jwqCQP3hH/7h8WO++MUv1mP13ve+tx67X/7lX1aO46jbb79dbfYxevOb31yPwYnX1srKyknHnO1j9IpXvEL9yZ/8SX3ut956q3r1q1+tdu7cqcbj8bP+HtvMv9dOZZxe9KIX1ed84vWkr49zZZz+5m/+Rv3d3/2duvfee9U999yjfvEXf7G+zvWYaXIdndo4nevX0UaQgHQDXX/99eptb3vb8ftlWaqtW7eq97znPepsDEh1QPB41tbW6jfyX/zFXxz/2l133VUHH1/60pfq+/rNapqmOnLkyPFjPvCBD6h2u63SNK3v/9zP/Vwd9J7ojW98Y/0foTPBY4OtqqrU/Py8+q3f+q2TxsrzvDpg0vQvKf19X/3qV48f8w//8A/KMAz1yCOP1Pf/x//4H6rX6x0fJ+3nf/7n1UUXXXT8/vd93/ep7/me7znpfG644Qb14z/+42ozeaKA9LWvfe0Tfs+5Nkba0aNH69f8uc997ll/j51Jv9ceO07rgcR/+A//4Qm/51wcJ/3e+J//83/KdXSK46TJdfTMkyX7DaL7zN5yyy31EuyJ7Uf1/S996UucjfRSs1523bt3b718qpcrND0OeZ6fNBZ6WXTnzp3Hx0J/1EukJxbQfcUrXlH3//3GN75x/JgTn2P9mDN1PHU/Yl08+MTXpNvE6SWZE8dFL0Hrzhfr9PH6WrrpppuOH/PCF76wbt124rjopcrV1dWzYuz0spZe8rrooov4yZ/8SZaXl48/di6O0WAwqD/2+/1n9T12pv1ee+w4rfuzP/uzuvf25Zdfzrve9S6iKDr+2Lk0TmVZ8ud//ud1Nx29JC3X0amN0zq5jp5ZUhh/gywtLdUX8WM7FOj7d999N2cbHUTpvS86YDh8+DC//uu/Xu/Xu+OOO+qgSwcCOmh47FjoxzT98fHGav2xb3WMfoPHcVzvwTyTrL+ux3tNJ75mHYidyLbt+j+wJx6zZ8+eb3qO9cd6vd4Tjt36c2xmer/o61//+vo1PvDAA/ziL/4ir3rVq+pfyJZlnXNjpPtDv+Md7+B5z3te/R9C7dl6j+ng/Uz5vfZ446T9wA/8ALt27ar/eNb7in/+53++/sPkL//yL8+Zcbr99tvrwErvF9X7RP/qr/6KSy+9lFtvvVWuo1MYJ02uo2eeBKTiGaEDhHV6I7gOUPWb9SMf+cgZFyiKzeX7v//7j3+uZxz09XXeeefVs6YvfelLOdfohBP9h94XvvCF030qZ+Q4vfWtbz3petIJhfo60n/s6OvqXKAnDnTwqWeQ/+///b91//HPfe5zp/u0zphx0kGpXEfPPFmy3yB6Gl/P3jw2O1Hfn5+f52yn/8K+8MILuf/+++vXq5ce1tbWnnAs9MfHG6v1x77VMToD8kwMetdf17e6RvTHo0ePnvS4ztLUWeXPxNididei3hKi31/62jrXxki35Pvbv/1bPvOZz7B9+/bjX3+23mNnyu+1Jxqnx6P/eNZOvJ7O9nHSs6A6o/vaa6+tKxNcddVV/O7v/q5cR6c4To/nXLyOnmkSkG7ghawv4k996lMnLSHp+yfuQTlb6ZI7+i9F/VejHgfHcU4aC720ofeYro+F/qiXR04MLD7xiU/Ub8z1JRJ9zInPsX7MmTqeeglZ/1I58TXppRq97/HEcdH/cdD7iNZ9+tOfrq+l9V+A+hhdOknv/TpxXPRf93op+mwbu4MHD9Z7SPW1da6Mkc730kGWXjLUr+2x2w+erffYZv+99mTj9Hj0DJh24vV0to/TY+lzS9NUrqNTHKfHI9fRM2ADEqXECeUadMb0Bz/4wToT+K1vfWtdruHErLuzxU//9E+rz372s2rfvn11+Rxd6kKXuNBZruulRHT5lU9/+tN1KZEbb7yxvj22RMbLX/7yulyLLnsxMzPzuCUyfvZnf7bO/Hz/+9+/6cs+jUajuuSHvum32/ve977684cffvh42Sd9Tfz1X/+1uu222+ps8scr+/Sc5zxH3XTTTeoLX/iCuuCCC04qaaQzY3VJox/8wR+sS5Lo606P02NLGtm2rX77t3+7HjtdFWGzlDT6VmOkH/uZn/mZOsNXX1uf/OQn1TXXXFOPQZIk58wY/eRP/mRdHky/x04sMxNF0fFjnq332Gb+vfZk43T//fer//gf/2M9Pvp60u+7vXv3qhe+8IXnzDj9wi/8Ql11QL9+/TtH39cVKT7+8Y/Xj8t19OTjJNfRxpCAdIPpumL6za3riOnyDbpO4tlIl6rYsmVL/Tq3bdtW39dv2nU6wPqpn/qpumyGfgP+m3/zb+r/UJzooYceUq961avq+pA6mNVBbp7nJx3zmc98Rl199dX1z9G/AHTNwc1Mn68Osh5706WM1ks//cqv/EodLOlfOi996UvrmncnWl5eroOrZrNZlwz5kR/5kTpQO5GuYfr85z+/fg49/jrQfayPfOQj6sILL6zHTpca0TX2NvsY6UBC/0LXv8h1cLhr1666Dt9jfxmf7WP0eOOjbyde/8/me2yz/l57snHav39/HTT0+/36OtD1anUwcGL9yLN9nH70R3+0fh/pc9LvK/07Zz0Y1eQ6evJxkutoYxj6/56JmVYhhBBCCCGeDtlDKoQQQgghTisJSIUQQgghxGklAakQQgghhDitJCAVQgghhBCnlQSkQgghhBDitJKAVAghhBBCnFYSkAohhBBCiNNKAlIhhBBCCHFaSUAqhBCn4Id/+Id53eted7pPQwghzkoSkAohzlgvfvGLecc73rHh33MmeuihhzAMg1tvvfV0n4oQQjwpCUiFEEIIIcRpJQGpEOKMXUL/3Oc+x+/+7u/WM4H6pmcF9deuv/56PM9jy5Yt/MIv/AJFUXzL7ynLkh/7sR9jz549BEHARRddVB/zdFVVxXvf+17OP//8+jx27tzJf/pP/+n447fffjvf9V3fVf+sqakp3vrWtzIej7/lLK7eLqDPf93u3bv5z//5P/OjP/qjtFqt+mf80R/90fHH9WvRnvOc59SvUz+n9tnPfrYen0ajQbfb5XnPex4PP/zw036tQgjxTJCAVAhxRtIB44033shb3vIWDh8+XN8cx+HVr341z33uc/n617/OBz7wAf7X//pf/MZv/MYTfs+OHTvqAHL79u38xV/8BXfeeSfvfve7+cVf/EU+8pGPPK1ze9e73sVv/uZv8iu/8iv1833oQx9ibm6ufmwymfCKV7yCXq/HV7/61fpnfvKTn+Ttb3/7U/45//W//leuu+46vva1r/FTP/VT/ORP/iT33HNP/dhXvvKV+qN+bv06//Iv/7IOzHVg+6IXvYjbbruNL33pS3UwrANWIYQ4nezT+tOFEOJp6nQ6uK5LGIbMz8/XX/ulX/qlOsD87//9v9dB1sUXX8yhQ4f4+Z//+TrIfLzv0SzL4td//ddPml3UwZoOSL/v+77vKZ3XaDSqA199Dm9+85vrr5133nk8//nPrz/XwWmSJPzpn/5pPUup6WNf85rX8F/+y385HrieCh1860BU06/xv/23/8ZnPvOZeoZ3Zmam/rqegV1/rSsrKwwGA/7Vv/pX9Tlpl1xyyVN6fUIIsRFkhlQIcda466676hnQE2f89JK0Xg4/ePDgt/ze97///Vx77bV1INdsNuvl7/379z+tc0jTlJe+9KVP+PhVV111PBhdP0c9S7s+u3mqrrzyyuOf69esA8+jR48+4fH9fr9e9tcztDoA1oGznj0VQojTTQJSIcQ578///M/5mZ/5mXof6cc//vE6M/1HfuRHyLLsKT+X3hf67TJNE6XUSV/L8/ybjtNbFE6kg1Id2H4rf/Inf1LP/n7nd34nH/7wh7nwwgv58pe//G2fsxBCfDskIBVCnLH08rtOSFqnl591sHViMPfFL36xTvrRe0Qf73vWj9EBml7+1klAOhnpgQceeFrndMEFF9RB6ac+9anHfVyfo97fqveSnvjzdRCql9o1PUt74sylPt877rjjKZ2Hfp3r3/tY+jXqfa7/7//9Py6//PJ6G4EQQpxOEpAKIc5YOtP8pptuqjPll5aW6oDywIED/Pt//++5++67+eu//mt+9Vd/lXe+8511wPd436NnFHUQefPNN/OP//iP3HvvvXUykk44ejp836/3c/7cz/1cvU9UB7Z6BlInV2lvetOb6mP0/lIdZOo9n/p8f/AHf/D4/lGdgf93f/d39U2/Dp2stLa29pTOY3Z2tg6MP/axj7GwsFDvHd23b18diOqgXWfW69ng++67T/aRCiFOOwlIhRBnLL3MrhOSLr300npWUS9r//3f/32dYa73af7ET/xEvQz/y7/8y0/4PXqf6I//+I/z+te/nje+8Y3ccMMNLC8vH08Wejp0QPvTP/3TdSKVDvb0867v7dQJVTrw1QlGuhrA937v99b7TXVi0zpdykkHrD/0Qz9UZ8Tv3buXl7zkJU/pHGzb5vd+7/f4wz/8Q7Zu3cprX/va+mfrAPcNb3hDvVSvM+zf9ra31a9fCCFOJ0M9dqOSEEIIIYQQzyKZIRVCCCGEEKeVBKRCCPEU6CV+XRbqiW5Pp1SUEEKc62TJXgghngLd7UgnRD0RnTSl928KIYQ4dRKQCiGEEEKI00qW7IUQQgghxGklAakQQgghhDitJCAVQgghhBCnlQSkQgghhBDitJKAVAghhBBCnFYSkAohhBBCiNNKAlIhhBBCCHFaSUAqhBBCCCE4nf7/2Uf79f79ewMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# 1. Violin plots to see the distribution of QC metrics\n", + "# Note: I am using the exact column names from your adata output\n", + "p1 = sc.pl.violin(adata, ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'],\n", + " jitter=0.4, multi_panel=True)\n", + "\n", + "# 2. Scatter plot to spot doublets and dying cells\n", + "# High mito + low genes = dying cell\n", + "# High counts + high genes = potential doublet\n", + "sc.pl.scatter(adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt')" + ] + }, + { + "cell_type": "markdown", + "id": "f44acde9", + "metadata": {}, + "source": [ + "#### Check Hemoglobin (RBC contamination)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "73d83421", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhsAAAGJCAYAAAAjYfFoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQwlJREFUeJzt3Qd8VFX6//EnBAhVAZFOCCgdAaWJDVE0ArKCjV1bxBVWBUWxLPx2JeofRUUiKiqWBewiKqwVlCJYQJoURQRWQBapikpoUbj/1/dkZ5hUQshkJnc+79fryr13JnfOnRnnPvec55wT53meZwAAAGFSKlwHBgAAEIINAAAQVgQbAAAgrAg2AABAWBFsAACAsCLYAAAAYUWwAQAAwopgAwAAhBXBBgAACCuCDaCYnX322W45UuvXr7e4uDh75JFHDvvce+65xz0X0SnwWU6cODHsr6XX0GvpNQOSkpLswgsvtOLwySefuNfXv4hdBBuIuMCP4aJFi3J9XBfmVq1aFXu5kNNvv/1m9957r7Vp08YqVapk5cuXd5/N3//+d/vxxx/D9rp79uxxAVRxXbCeeuqpIwoE9P0NLKVLl7Zq1apZu3btbPDgwbZy5cqIlas4RXPZEHmlI10AAEXvn//8pw0dOrRIj/n9999bt27d7IcffrDLLrvMBgwYYGXLlrXly5fbv/71L5syZYqtXr3awhVsKMiRwtQKFebCWb16dbv22msL/DfnnXeeXXPNNabppn799VdbtmyZvfDCC+5YDz30kA0ZMiT43AYNGtjevXutTJkyYS/X1VdfbX/+858tISHBwimvsp111lnuXPVdQewi2AB8SHfXWorKH3/8YRdffLFt3brV1S6cccYZWR6///773QU1ljVp0sSuuuqqLPsefPBB69Wrl91+++3WrFkz69Gjh9uvGpBy5cqFtTy7d++2ihUrWnx8vFsipVSpUmE/V0Q/mlFQYr388suuqlpV+aq21t3bxo0bc22C0d13ly5drEKFCnbiiSfam2++6R6fM2eOderUyR2jadOmNmPGjByv89VXX1n37t3tmGOOcU0H5557rs2fPz/H8wKvoWPVq1fPRowYYRMmTMjRXp6bbdu22V//+lerWbOm+2FWM4XuivPy6KOPurtjvZZe8+uvvz5szoa2Bw0aZFOnTnXvie50W7ZsadOmTbPDeeutt9yd+j/+8Y8cgYbovVHAEWry5MnBz0d3vLoQb9q0KctzdBes91T7e/fu7daPP/54u+OOO+zAgQPuOXrvtE9UuxFortA5BqxatcouvfRS9z3Q+9e+fXt75513cm2u+/zzz10tg46pi3GfPn1s+/btWfIZvvnmG/fdCLxWYWtTjjvuOHv99ddd4Bf6/uSWs7Flyxbr16+f++7os6ldu7ZddNFFwe9OfuUKnJseu+mmm6xGjRruOKGP5fYd/Oijj6xt27buPWvRooW9/fbbBcr9yX7M/MqWV85GUX0/UDJQs4GooarnHTt25Nj/+++/59inH+67777bLr/8crv++uvdxeKJJ55wVbYKDqpUqRJ87s6dO10ynIIRVf8//fTTbv2VV16xW2+91W644Qa74oorbNSoUe6CpYClcuXK7m/1A3rmmWe6i+ldd93lqr2feeYZ90MaCFREP4Zdu3Z1P6rDhg1zF7Hnn3++QFXXqmLW8dauXeuCgYYNG7ofYv3Q/vLLL67dP9SLL75ou3btsoEDB9q+ffvsscces3POOcdWrFjhgpX8fPbZZ+6CoguSzvHxxx+3Sy65xDWN6MKYl8CFW1XyBaGLkS6cHTp0sJEjR7oaEZVTF/rsn48uGsnJye69VPKrAr7Ro0fbCSecYDfeeKO7uOgz07oCA9WwSOvWrYOf0emnn25169Z1TUd679944w13cVKQpL8JdfPNN1vVqlUtNTXVXSzHjBnj3vdJkya5x7Wt5+jCpuBKDve+5icxMdEFhLNnz3Y5L/ou5Uafg85Fr62LtwLQjz/+2H022i5IufS56v0aPny4q9nIz5o1a6xv377u+5+SkuICY/3/oeBTTUJH4kjfs6L8fqCE8IAImzBhgqevYn5Ly5Ytg89fv369Fx8f791///1ZjrNixQqvdOnSWfZ36dLF/f2rr74a3Ldq1Sq3r1SpUt78+fOD+6dPn+72qzwBvXv39sqWLev95z//Ce778ccfvcqVK3tnnXVWcN/NN9/sxcXFeV999VVw308//eRVq1bNHXPdunVZyqQlYMyYMe45L7/8cnBfRkaG17lzZ69SpUreb7/95vbpGHpe+fLlvf/+97/B53755Zdu/2233Rbcl5qa6vaF0rbOZe3atcF9y5Ytc/ufeOIJLz8nn3yyd+yxx+b7nNCy16hRw2vVqpW3d+/e4P733nvPvdbw4cOD+1JSUty+++67L8frtWvXLri9fft29zydV3bnnnuud9JJJ3n79u0L7jt48KB32mmneY0bN87xPevWrZt7PEDvm75Pv/zyS3Cfvm+hn9Hh6LgDBw7M8/HBgwe75+j9Dv0sA9+1nTt3uu1Ro0bl+zp5lStwbmeccYb3xx9/5PpY6HewQYMGbt9bb70V3Pfrr796tWvXdu99ft+jvI6ZV9lmz57tnqt/w/X9QPSjGQVR48knn3R3ctmXwB1sgO7MDx486Go1VBMSWGrVqmWNGzd2d5ChdLelmowANZfozql58+bBmgkJrCsRMnBHpWpm3SE3atQo+DxVb6smRLUEulMV3Q127tzZVUkHqEr/yiuvPOx5f/DBB67sf/nLX4L7VINyyy23WHp6uqtBCaXy6C4+oGPHjq7sOs7hKMFTd4QBem91px0457zoPAO1PYejXkW6K9dddmhbfc+ePV3ewvvvv5/jb3R3HUq1SYcrk/z88882a9Ys911QbU/gu/DTTz+5u2HdvWevmldia2jTgF5Ln/WGDRssXPQdFJUxN2pKUAKlmhpUE1dY/fv3L3B+Rp06dbLU+uh7oARX1SyoSSdcivP7gehBMwqihi6aamvPTlXeoc0ruoDoZlKBRW6yZ/ir7Tp7u/Oxxx5r9evXz7FPAj/2appRLwgFJ9kpUFHAoyYX5T3oQqVgIzvlhxyO/lbnokS67K8ReDxUbuet5EQ1HRSkSj+39/dwF7iCBCQBgfLm9r7pYqIgLZQuOIGcjCMpk6jpSd8FNalpyY0ubKHBWfb3QK8lR3ORPxwFjZJXwKbmNiXYKpFUzQ+nnnqqa/rTxV+BaEGpCa6g9N3M/v+Fvkei5qUjed0jUZzfD0QPgg2UOLrI60fyww8/zPUuLnAXGZDXnV5e+zNrxf2psOesi4DueBVcZQ/SwlWmgn4XRAmDqsnITfaALxKfuxJ49br5BQPKH1LPFSXwTp8+3QVPymdQzc3JJ59coNdRDUlRymtguOJMzoxkTxoUHYINlDhqBtCFQT/cgTuxcNDdlHqvfPfddzkeU+8H1UQELrzqGaK77Oxy25ed/lY9WXThDK3d0GsEHg+lmp3sNL6FkgjDRRfB1157zfUAUgJsfgLl1fumxNVQ2pf9fI7mohdo3lJtlpqIikpRjr6qBE81hanm63BNUfpuq3ZDiz5nNcspGVLve1GXK1ArFHrMwDgpge9SoNZHicqhSZu5NTkVtGzh+H4g+pGzgRJHvRF0t6NukNnvRrWt9vqioNc4//zz7d///neWboPKnH/11VddF9BAzwLdVc+bN8+WLl2aJZ9APV4OR2MvqI080BsiMK6FeteolkY9GULpzjc0D2HBggX25Zdfuu654aJeOieddJLrBaTzzE65CIFeCGoKU9fLcePG2f79+4PPUU3Ut99+69rmj5SCvsBFL5ReRz151ENo8+bNOf4utEvrkVCPluyvVRj6DigXRzUBgfcnN2quU8+i7IGHgpPQ97CoyiUa8VUDsYXm5ainkwKcQBNKIL9n7ty5weepl0tu3bILWrZwfD8Q/ajZQImjH0CNYaE7bAUBSpjUj/K6devcj6cSAFWtXhT0OkpSVWChhDaNl6ALm34kH3744eDz1C1Wd5/qMqgugIGur8oP0AUnv7s+lVfHVFfXxYsXu7tKjQOiboDqUpj9bljNAiqPuv2pHHqOuq2qDOGimgMl5qr2QN2LlZCp7qbar+6aCr50F6xgRPuUf6CujQqUdLENdG3Uud12221H/PpqHtA4EArIVJul5FuNFaJFicV6PxQMKUFStR16PQVF//3vf934IEdK4z+ou60+f73fujhmvwvPTrUC+g4o4NWFW6+rLszK10hLS7MLLrgg37/V+C16X3We+p7pu6zzCE1uLky58qL3UWO7LFy40OWJjB8/3r2eusAGKNjWd1jPu/POO10Aruep1k81NoV5z8Lx/UAJEOnuMECgG93ChQtzfVzd6UK7vgao2566+lWsWNEtzZo1c90Pv/vuu8P+rbr+9ezZs0BdGJcsWeIlJye7bqgVKlTwunbt6n3xxRc5/lbdXs8880wvISHBq1evnjdy5Ejv8ccfd8fcsmVLljJl7yK4detWr1+/fl716tVd91R15QztghvaXVLdI0ePHu3Vr1/fvZZeM9Cl8nBdX3Prnqn3Ql0MC0JdNNU1UeXTe1GuXDnXhXHYsGHe5s2bszx30qRJrouiyqguwFdeeWWWLrui19Vnl11u5dd7ru6Oen+yd4NV1+RrrrnGq1WrllemTBmvbt263oUXXui9+eabh/2eZe+aKfq89P1QF2c9drhusKHdtNWlukqVKu7c1eX1m2++yfH87F1fd+zY4T4bfYf1fqibcadOnbw33ngjy9/lVa78/h/Kq+urjqPu3q1bt3afkV578uTJOf5+8eLFrix63xMTE720tLRcj5lX2XJ7f8Px/UB0i9N/Ih3wAH6lpD/VWujulkQ3ALGKnA2giGgk0FDKHXnppZdcFT+BBoBYRs4GUETU20DJihofQ23QmglVbfd5jf8AALGCYAMoIupVosTOZ5991iWEnnLKKS7gUEIlAMQycjYAAEBYkbMBAADCimADAACEVcznbGiIaI2kp4GTinIoYAAA/M7zPDeCsGYRzj6ZZKiYDzYUaBT1xFIAAMSSjRs3uhm28xLzwUZgKGi9UYF5LgAAwOGpe79u2A83yWDMBxuBphMFGiU62Nizx6xDh8z1hQs1c1WkSwQAiBFxh0lD8EWCqCbg6tq1q5vASJMxaVbCmKMezCtXZi70ZgYARBFf1GxotkzNNHjmmWe6GTYTEhIiXSQAAOCXYEPTW2vKYgUaoqmnAQBA9Ih4sDF37lwbNWqULV682DZv3mxTpkyx3r17Z3nOk08+6Z6zZcsWa9OmjT3xxBPWsWNH99iaNWusUqVK1qtXL9u0aZNdeuml9n//938ROhsAiG3qCvnHH3/YgQMHIl0UFAFNIlm6dOmjHhoi4sGG8isUQFx33XV28cUX53h80qRJNmTIEBs3bpx16tTJxowZY8nJyfbdd99ZjRo13Jf6008/taVLl7rtCy64wDp06GDnnXdeRM4HAGJVRkaGu2nco4R1+EaFChWsdu3aVrZs2ZIbbHTv3t0teUlLS7P+/ftbv3793LaCjvfff9/Gjx9vQ4cOtbp161r79u2DY2VoMiwFHnkFG/v373dLaLcdAMDRD5CoZH3dCWuAJ12YGCix5NdSZWRk2Pbt291n27hx43wH7orqYCM/Okk1rwwbNiy4TyfarVs3mzdvnttWLca2bdts586dduyxx7pmmb/97W95HnPkyJF27733mu/of+oGDQ6tA0Ax/14r4NCNn+6E4Q/ly5d3eZEbNmxwn3G5cuUKdZyo7vq6Y8cO1+5Xs2bNLPu1rfwNUVvSAw884Kbxbt26tYu8LrzwwjyPqcDl119/DS4azMsX9D/3+vWZC/+jA4iQwt75wt+faVTXbBRVU0wodYvVoqRTLSQxAQAQXlEdglavXt21/23dujXLfm3XqlXrqI49cOBAW7lypS3UaJsAACA2gw0lGLVr185mzpwZ3Kc2QW137tz5qI6tWg2NOKqcD1/YuzdzuHItWgcAIITSD9R5omLFilalSpU89/ky2EhPT3e9R7SIMl61/sMPP7htdXt97rnn7IUXXrBvv/3WbrzxRtddNtA7JVprNsaOHWvNmjXLc9HjRergQbNFizIXrQMADuuee+5xvWZCF/1Gh9J1SANGKvn1lVdeyfLY5MmT3ThPBZGRkWEPP/ywG+5BSbSqvT/99NNtwoQJ9vvvvxe4zCrj1KlT7Ug9+uijrmuyrrGrV6/Oc184RDxnY9GiRW5ek9APVVJSUmzixInWt29f1+1m+PDhLgJr27atTZs2LUfSaLQZNGiQWwAA0a1ly5Y2Y8aM4LY6HgS8++679uqrr9pHH33kBpHUmFAa60mBgjoZ/OMf/8jyt/kFGsnJybZs2TL7f//v/7kgQ5N/zp8/3x555BE7+eST3fUtnP7zn/+41gJ1pMhvX1h4MWrs2LFe8+bNvSZNmmjWMu/XX3/1SrT0dE2/lrloHQCK0d69e72VK1e6f7PQ71Fey5E8d8+egj33CKWmpnpt2rTJ8/GHHnrI69u3b3C7Ro0a3oIFC9z6gAEDvLS0tAK9zkMPPeSVKlXKW7JkSY7HMjIyvPT/lb1Bgwbeo48+muVxlU/lDDyua1Zg0XbAU0895TVq1MgrU6aMu7a9+OKLwcey/11KSkqu+47os/U8d+0syDU04jUbkaJmFC0a1EvjcwAAwqBSpbwf69HD7P33D23XqGGW1+ijXbqYffLJoe2kJI2PkPN5hZj1WjUWGohMY0goH1DjMSUmJrrH1OTx7LPPurGcvv/+e9u7d6+deOKJ9tlnn9mSJUvsqaeeKtBrvPLKK26MKNVgZKdxLLQUhJr+NVq2ml40YrY6UYim+hg8eLAbZVuv895777l0g3r16rnWA/3dNddc42pTHnvsMTd+hmpbsu/zbc4GAACRomkw1GSv5vmnn37a5Q1qYs9du3a5x9X0cdVVV7nOBJphXPmDSqZU/qBGtNbfNG3a1DWLaGLQ/AKaZtlyQQrj+OOPd/8qmVO9MgPbaopR+W666SZr0qSJS0nQFCDaH/g7DfuggEJ/p5vs3PaFS8zWbDDOBgAUg/T0vB/731150LZteT83+8BSGsCwCISO0aSBIRV8NGjQwN544w3761//Gkwi1RKgUahVe6DaiBEjRtiKFStcTYJqCTTqdV5Df4eTOlAMGDAgyz4FQKqxiAYxG2z4shmlevVIlwAAsqpYMfLPPQKqMVDNwNq1a3N9fNWqVfbyyy/bV1995ebo0ujVqiG4/PLLXfKoakQqV66c4++aNGni/rYgo3VmD0yOpKdKtKIZxS/0P9727ZlLmP4nBAC/03AM6qGhWU6zUxCgubc0QWilSpVczXggEAj8m1dt+RVXXOF6rShIyU5/qyEdRIGLuqIG6IZYTTuhVKOS/XWaN29un3/+eZZ92tZ4UtGAYAMAELPuuOMOmzNnjq1fv96++OIL69Onj0u6/Mtf/pLjuc8//7wLBgLjaqiZYtasWa77qsar0IU9r4Gxbr31Vvf8c8891zXhqwusEk7VXHPqqae6nA4555xz7KWXXrJPP/3UNc9oGIhAEmhAUlKSG9xSw0EocVXuvPNOl3uiHBIdSwHR22+/7c4vGsRsMwo5GwCA//73vy6w+Omnn1wgccYZZ7jgIZB4GTpNxv333+8CkoCOHTva7bffbj179nQ9RJQ8mpeEhAT7+OOPXVDyzDPPuCBAA3upRuKWW26xVq1aBScLVU2GJhRVE7/G5MheszF69OjggJd169Z1gVLv3r1dfoYSQtUrpWHDhq7Hytlnn23RIE79Xy2GBXI2NDiLuv+UWBqiPJDo9OGHmhc40iUCEEP27dvnLoq6yBV2GnKUvM+2oNfQmK3Z8B0NUT5nzqF1AACiBDkbAAAgrAg2AABAWMVssOG7KeYBAIhSMRtshHuKeQCIRTHe58CXvCL4TGM22AAAFJ3ARGJ78ppIDSVW4DMt6GRxuaE3ip9UqBDpEgCIURp4SgNabfvf/CYaQyIuLi7SxcJR1mgo0NBnqs82++BiR4Jgwy80RPn/hrsFgEjQzKESCDjgD1X+N8Ps0SDYAAAUCdVkaE4Rjabph8nDYK7p5GhqNCzWgw2GKweA8NDFqSguUPAPhiv3y3Dl+/aZXXJJ5vpbb5kxXDAAIMwYrjzWqIbmgw8OrQMAECXo+goAAMKKYAMAAIQVwQYAAAgrgg0AABBWBBsAACCsYjbYYNZXAACKB+Ns+GWcDQAAovQaGrM1GwAAoHgQbAAAgLAi2PALDVd+2WWZi9YBAIgSBBt+oSHK33wzc2G4cgBAFCHYAAAAYUWwAQAAwopgAwAAhJUvpphPSkpy/XtLlSplVatWtdmzZ0e6SAAAwE/BhnzxxRdWqVKlSBcDAABkQzMKAADwd7Axd+5c69Wrl9WpU8fi4uJs6tSpuc5joqaScuXKWadOnWzBggVZHtffdenSxc1z8sorr1hMqlDBLD09c9E6AABRIuLBxu7du61NmzYuoMjNpEmTbMiQIZaammpLlixxz01OTrZt27YFn/PZZ5/Z4sWL7Z133rEHHnjAli9fnufr7d+/343lHrr4QlycWcWKmYvWAQCIEhEPNrp3724jRoywPn365Pp4Wlqa9e/f3/r16+dmaR03bpxVqFDBxo8fH3xO3bp13b+1a9e2Hj16uKAkLyNHjnSTxgSW+vXrh+GsAABA1AQb+cnIyHA1Ft26dQvuU48Tbc+bNy9YM7Jr1y63np6ebrNmzbKWLVvmecxhw4a52ekCy8aNG80X9u83u/bazEXrAABEiajujbJjxw47cOCA1axZM8t+ba9atcqtb926NVgroueqFkS5G3lJSEhwi5pttOhvfOGPP8xeeCFzXU1SCQmRLhEAANEfbBREo0aNbNmyZUf8dwMHDnSLcjbUnAIAAGKwGaV69eoWHx/vai9CabtWrVoRKxcAAPBJsFG2bFlr166dzZw5M7jv4MGDbrtz585HdWw1oSjhNL8mFwAA4INmFCV1rl27Nri9bt06W7p0qVWrVs0SExNdt9eUlBRr3769dezY0caMGeOSQtU75WjQjAIAQIwEG4sWLbKuXbsGtxVciAKMiRMnWt++fW379u02fPhw27Jli7Vt29amTZuWI2kUAABEpzjP8zyLQaG9UVavXu26wWoytxJr926zwNwwGkVUg3sBABBGgdaBw11DYzbYONI3KurpY9yxI3O9enVGEQUARM01NOLNKCgiCi6OPz7SpQAAoGT1RgkneqMAAFA8aEbxSzOKhij/X3KtpaUxgigAIGquoTFbs+E7Gq78qacyF60DABAlCDYAAEBYxWywQc4GAADFg5wNv+RsMM4GAKCYkbMBAACiAsEGAAAIq5gNNsjZAACgeJCz4ZecjYMHzX74IXM9MdGsVMzGkQCAYsJw5bFGwUVSUqRLAQBADtz+AgCAsCLY8IuMDLM778xctA4AQJQgZ8MvORuMswEAKGaMs3EY9EYBAKB4ULNBzQYAAIVCzQYAAIgKBBsAACCsCDYAAEBYEWwAAICwYgRRvyhf3uzrrw+tAwAQJQg2/DRcecuWkS4FAAA5xGwzCuNsAABQPBhnwy/jbGiI8gceyFz/v/8zK1s20iUCAPjcbwW8hhJs+CXYYFAvAEAxY1AvAAAQFQg2AABAWBFsAACAsCLYAAAAYUWwAQAAwopgAwAAhJVvgo09e/ZYgwYN7I477rCYVK6c2YIFmYvWAQCIEr4Zrvz++++3U0891WJWfLwZo6ECAKKQL2o21qxZY6tWrbLu3btHuigAACDago25c+dar169rE6dOhYXF2dTp07NdR6TpKQkK1eunHXq1MkWqKkghJpORo4caTFNw5WPGpW5aB0AgCgR8WBj9+7d1qZNGxdQ5GbSpEk2ZMgQS01NtSVLlrjnJicn27Zt29zj//73v61JkyZuiWm//252112Zi9YBAIgSEc/ZUNNHfs0faWlp1r9/f+vXr5/bHjdunL3//vs2fvx4Gzp0qM2fP99ef/11mzx5sqWnp9vvv//uxmcfPnx4rsfbv3+/W0LHdQcAAD6u2chPRkaGLV682Lp16xbcV6pUKbc9b948t63mk40bN9r69evtkUcecYFJXoFG4PmaNCaw1K9fv1jOBQCAWBXVwcaOHTvswIEDVrNmzSz7tb1ly5ZCHXPYsGFudrrAokAFAAD4uBmlKF177bWHfU5CQoJblCOiRcEMAACI0ZqN6tWrW3x8vG3dujXLfm3XqlXrqI49cOBAW7lypS1cuPAoSwkAAEpssFG2bFlr166dzZw5M7jv4MGDbrtz585HdWzVarRo0cI6MBAWAAD+bkZRD5K1a9cGt9etW2dLly61atWqWWJiouv2mpKSYu3bt7eOHTvamDFjXHfZQO+Uo6nZ0KLeKEoULfE0RPns2YfWAQCIEhEPNhYtWmRdu3YNbiu4EAUYEydOtL59+9r27dtdDxMlhbZt29amTZuWI2k05mm48rPPjnQpAADIIc7zPM9iUGiC6OrVq13PFI3PAQAACibQOnC4a2jMBhtH+kZFPY0a+uyzmesDBpiVKRPpEgEAfO63Al5DI96MgiKi+VAGDcpcVxdggg0AQJSI6t4o4URvFAAAigfNKH5pRtm926xSpcz19HSzihUjXSIAgM/9VsBraMzWbAAAgOJBsAEAAMIqZoMNcjYAACge5GyQswEAQKHQ9TXWJCSYvffeoXUAAKIEwYZflC5t1rNnpEsBAEAOMZuzAQAAikfMBhu+SxDVcOUTJ2YuWgcAIEqQIEqCKAAAhcKgXgAAICoQbAAAgLAi2AAAAGFFsAEAAMIqZoMN3/VGAQAgStEbhd4oAAAUCsOVxxoNUf7GG4fWAQCIEgQbfhqu/LLLIl0KAAByiNmcDQAAUDyo2fCLP/4wmzIlc71Pn8yaDgAAogBXJL/Yv9/s8ssPJYgSbAAASnIzSqNGjeynn37Ksf+XX35xjwEAABxVsLF+/Xo7cOBAjv379++3TZs2WUnAOBsAABSPI6prf+edd4Lr06dPd31rAxR8zJw505KSkqwkGDhwoFsCfYQBAEAUBBu9e/d2/8bFxVlKSkqWx8qUKeMCjdGjRxdtCQEAQOwEGwcPHnT/NmzY0BYuXGjVq1cPV7kAAIBPFKrLwrp164q+JAAAwJcK3T9S+Rlatm3bFqzxCBg/fnxRlA1HomxZswkTDq0DAFCSg417773X7rvvPmvfvr3Vrl3b5XAgwsqUMbv22kiXAgCAogk2xo0bZxMnTrSrr766MH8OAABiSKGCjYyMDDvttNOKvjQ4uuHKp0/PXE9OZgRRAEDJHtTr+uuvt1dffdWigUYtVXNO27ZtrVWrVvbcc89ZzA5XfuGFmYvWAQCIEoW6/d23b589++yzNmPGDGvdurUbYyNUWlqaFZfKlSvb3LlzrUKFCrZ7924XcFx88cV23HHHFVsZAABAEQcby5cvdzUJ8vXXX2d5rLiTRePj412gERgu3fM8twAAgBIcbMyePbvICqBaiVGjRtnixYtt8+bNNmXKlOBIpaHzmOg5W7ZssTZt2tgTTzxhHTt2zNKU0qVLF1uzZo17HoONAQBQwnM2ipKaPhRAKKDIzaRJk2zIkCGWmppqS5Yscc9NTk5243sEVKlSxZYtW+YGG1MuydatW/N8PdV+aD6U0AUAAIRPnFeINoeuXbvm21wya9aswhUmLi5HzUanTp3czKxjx4512xpArH79+nbzzTfb0KFDcxzjpptusnPOOccuvfTSXF/jnnvuceOEZPfrr7/aMcccYyXW7t1mlSplrqenm1WsGOkSAQB87rf/TWZ6uGtooWo2lK+hGobAoqna1R1WNQ8nnXSSFRUdU80r3bp1O1TgUqXc9rx589y2ajF27drl1nWyapZp2rRpnsccNmyYe15g2bhxY5GVFwAAFFHOxqOPPppnrUG67qqLyI4dO9zU9TVr1syyX9urVq1y6xs2bLABAwYEE0NV45FfwJOQkOAWNdto0fF9QUOU/6/2h+HKAQDRpEhHfrrqqqtc4uYjjzxixUWvt3Tp0iP+u4EDB7olUAVU4qn78cCBkS4FAADhTRBV00a5cuWK7HjqVaKurdkTPrVdq1atInsdAAAQZTUbGjQrlJov1G110aJFdvfddxdV2axs2bLWrl07N7tsIGlUCaLaHjRo0FEd23fNKDqPTz/NXD/zTA1AEukSAQBQ+GAje7ODkjaVlKmZYM8///wjOpZyPNauXRvcVvdVNYtUq1bNEhMTXbfXlJQUNyS5mkzGjBnjusv269fPjobvmlH27VM3ocx1eqMAAEp6sDFhwoQiK4BqQ9SVNkDBhSjA0Myyffv2te3bt9vw4cPdoF7qCTNt2rQcSaMAAMBH42wEqFvqt99+69ZbtmxpJ598spUUoc0oq1evZpwNAADCNM5GoYINjd755z//2T755BM3emdgyHDVULz++ut2/PHHm9/eqKhHsAEA8NOgXhrLQgNpffPNN/bzzz+7RROy6UVvueWWoyk3AADwmULlbChnQtPLN2/ePLhPo4iqWeJIE0QjxXe9UQAAiFKFqtlQ99MyGkQqG+3TYyWBeqKsXLnSFi5cGOmiAADga4UKNjTR2eDBg+3HH38M7tu0aZPddtttdu655xZl+VBQCv4efjhzySUQBAAgUgqVIKrJy/70pz+5nA3NwBrY16pVK3vnnXesXr16VlL4JkEUAIAovYYWKmdDAYZmeFXeRmBCNOVvhM7OGu3I2QAAIAprNmbNmuWGCZ8/f36OCEZRzWmnnWbjxo2zMzVcdgnhm5oNBU1LlmSun3IKw5UDAEpm11cNFd6/f/9cD6gX+9vf/mZpaWmFKzGOfrjyjh0zF60DABAljijYWLZsmV1wwQV5Pq5urxpVFAAAoFDBhqZ2z63La0Dp0qXdPCYlgfI1NDZIhw4dIl0UAAB87YiCjbp167qRQvOyfPlyq127tpUEjLMBAEAUBhs9evSwu+++2/blkhOwd+9eS01NtQsvvLAoywcAAGKpN4qaUU455RSLj493vVKaNm3q9qv7a6AbqbrElqTp333TG4WJ2AAAfhhnQ0HEF198YTfeeKMNGzbMAnFKXFycJScnu4CjJAUaAAAg/I54UK8GDRrYBx98YDt37rS1a9e6gKNx48ZWtWrV8JQQBaPE3dTUQ+sAAJTk4cr9IHQE0dWrV5f8ZhQAAKK0GSVmgw3f5WwAAOCnuVEQhQ4eNPv228z15s3NShVqQl8AAIocwYZf7N1r1qpV5jq9UQAAUYTbXwAAEFYEGwAAIKwINgAAQFgRbAAAgLCK2WCDWV8BACgejLPhl3E2mBsFAFDMGGcj1miI8jvuOLQOAECUINjwi7JlzUaNinQpAADIgWAjQsaOHeuW/AwaNMgtAACUZORs+CVnQ8OV//BD5npiIsOVAwDCjpyNWByuvGHDzHUSRAEAUYTbXwAAEFYEGwAAIKxKfLCxceNGO/vss90AXa1bt7bJkydHukgAAMBPORulS5e2MWPGWNu2bW3Lli3Wrl0769Gjh1UkZwEAgKhQ4oON2rVru0Vq1apl1atXt59//plgAwCAKBHxZpS5c+dar169rE6dOhYXF2dTp07NdR6TpKQkK1eunHXq1MkWLFiQ67EWL15sBw4csPr16xdDyQEAQIkINnbv3m1t2rRxAUVuJk2aZEOGDLHU1FRbsmSJe25ycrJt27Yty/NUm3HNNdfYs88+azGpdGmzm27KXLQOAECUiKpBvVSzMWXKFOvdu3dwn2oyNDNrYLTNgwcPupqLm2++2YYOHer27d+/38477zzr37+/XX311fm+hp6rJXRAEh2vxA/qBQBAlA7qFfGajfxkZGS4ppFu3boF95UqVcptz5s3z20rVrr22mvtnHPOOWygISNHjnRvTGChyQUAgPCK6mBjx44dLgejZs2aWfZrWz1P5PPPP3dNLcr1UI8ULStWrMjzmMOGDXMRWGBR11lfUAXV9u2ZS/RUVgEAUPJ7o5xxxhmuaaWgEhIS3KIcES0KZnxhzx6zGjUy1xmuHAAQRaK6ZkPdWOPj423r1q1Z9mtb3VyPxsCBA23lypW2cOHCoywlAAAoscFG2bJl3SBdM2fODO5TLYa2O3fufFTHVq2GRh1V8ikAAPBxM0p6erqtXbs2uL1u3TpbunSpVatWzRITE12315SUFGvfvr117NjRjRaq7rL9+vU76poNLYFMWgAA4NNgY9GiRda1a9fgtoILUYAxceJE69u3r23fvt2GDx/ukkKVADpt2rQcSaMAACA6RdU4G8UpNEF09erVJX+cjd27zSpVylwnQRQAEEXjbMRssHGkb1TUI9gAAETpNTTizSgoIhqiPCXl0DoAAFEiZq9KvhtnIyHBbOLESJcCAIAcaEbxSzMKAADFjGaUWKOYUaOISoUKmtUu0iUCACD6B/XCEVCgoQRRLYGgAwCAKBCzwQYjiAIAUDzI2fBLzgZdXwEAUXoNjdmaDQAAUDwINgAAQFgRbAAAgLCK2WCDBFEAAIoHCaJ+SRDdt8/s6qsz1196yaxcuUiXCADgc78xqFeMUXAxeXKkSwEAQA4x24wCAACKB8EGAAAIK4INv9CgXpoPRYvWAQCIEjEbbNAbBQCA4kFvFL/0RmG4cgBAMaM3ig+MHTvWLXkZNGiQWwAAiGbUbFCzAQBAoTARGwAAiAoEGwAAIKzI2fCL+HizHj0OrQMAECUINvw0XPn770e6FAAA5BCzzSiMswEAQPGgN4pfeqMAAFDM6I0Sa9T1Vd1dtTBcOQAgipCz4Sd79kS6BAAA5EDNBgAACCuCDQAAEFYEGwAAIKwINgAAQFgRbAAAgLDyRbDRp08fq1q1ql166aUWs0qVMuvSJXPROgAAUcIXV6XBgwfbiy++aDGtfHmzTz7JXLQOAECU8EWwcfbZZ1vlypUjXQwAABCNwcbcuXOtV69eVqdOHYuLi7OpU6fmOo9JUlKSlStXzjp16mQLFiyISFmjzdixY61Zs2b5LnoOAAAxPYLo7t27rU2bNnbdddfZxRdfnOPxSZMm2ZAhQ2zcuHEu0BgzZowlJyfbd999ZzVq1Dji19u/f79bQsd1L6kGDRrkFkdDlCclZa6vX585bDkAAFEg4jUb3bt3txEjRrgkz9ykpaVZ//79rV+/fm6WVgUdFSpUsPHjxxfq9UaOHOkmjQks9evXN9/YsSNzAQAgikQ82MhPRkaGLV682Lp16xbcV6pUKbc9b968Qh1z2LBhbna6wLJx48YiLDEAAIi6ZpT87Nixww4cOGA1a9bMsl/bq1atCm4r+Fi2bJlrkqlXr55NnjzZOnfunOsxExIS3KI8EC06PgAAiNFgo6BmzJhxxH8zcOBAtyhnQ80pAAAgBptRqlevbvHx8bZ169Ys+7Vdq1atiJULAAD4JNgoW7astWvXzmbOnBncd/DgQbedVzNJQakJRQmnHTp0KIKSAgCAqG1GSU9Pt7Vr1wa3161bZ0uXLrVq1apZYmKi6/aakpJi7du3t44dO7qur8rNUO+Uo+G7ZhQNUd6+/aF1AACiRMSDjUWLFlnXrl2D2wouRAHGxIkTrW/fvrZ9+3YbPny4bdmyxdq2bWvTpk3LkTQa8zRE+cKFkS4FAAA5xHme51kMCu2Nsnr1atcN9phjjol0sQAAKDECrQOHu4bGbLBxpG8UAAAo3DWUxn2/2LMnc7hyLVoHACBKRDxnI1J8N6iXKqg2bDi0DgBAlKAZxS/NKJqIrVKlzPX0dCZiAwCEHc0oAAAgKhBsAACAsCJnwy85Gz43duxYt+Rn0KBBbgHvVyx/tnyuiEbkbJCzAQBAWK+hMVuz4TtxcWYtWhxaBwAgShBs+EWFCmbffBPpUgAAkEPMBhvkbMQe8hgQC/ieIxqRs+GXnA0AAIoZ42zEGg1R3rJl5sJw5QCAKBKzzSi+owqqlSsPrQMAECWo2QAAAGFFsAEAAMIqZptRYqU3yuEy00866SRbsWJFoR8vSGZ7QbLjD/c6sZQ9Hy29Cfz0uRXHqJvR8rkVhaI4F0Y6RSh6o/ilNwojiAIAihm9UQAAQFSI2WYU39EQ5Q0aHFoHACBKEGz4abjy9esjXQoAAHKgGQUAAIQVwQYAAAgrgg2/2LvXrEOHzEXrAABEiZjN2fDdOBsHD5otWnRovRhFS3/6oihHtJxLcYilc42lMUVKiuIYy6O4joHDY5wNxtkAAKBQGGcDAABEBYINAAAQVgQbAAAgrAg2AABAWMVsbxRfql490iUAACAHgg2/UO+T7dsjXQoAAHKgGQUAAISVL4KN9957z5o2bWqNGze2559/PtLFAQAAfmpG+eOPP2zIkCE2e/ZsN7BIu3btrE+fPnbcccdZTNEQ5d27Z65/+KFZ+fKRLhEAAP6o2ViwYIG1bNnS6tata5UqVbLu3bvbRx99ZDFHQ5TPmZO5FPNw5QAARHWwMXfuXOvVq5fVqVPH4uLibOrUqTmeozlMkpKSrFy5ctapUycXYAT8+OOPLtAI0PqmTZuKrfwAACDKg43du3dbmzZtXECRm0mTJrlmktTUVFuyZIl7bnJysm3btq3YywoAAEpgsKFmjxEjRrg8i9ykpaVZ//79rV+/ftaiRQsbN26cVahQwcaPH+8eV41IaE2G1rUvL/v373cTx4QuAAAgRhNEMzIybPHixTZs2LDgvlKlSlm3bt1s3rx5brtjx4729ddfuyBDCaIffvih3X333Xkec+TIkXbvvfcWS/nhP8UxpXVBprMuKdPDF8XU7Yd7vCDPiZb343CY7rxkipbPbWwU/y5E1RTzytmYMmWK9e7dO0s+xhdffGGdO3cOPu+uu+6yOXPm2Jdffum233nnHbvjjjvs4MGD7rEBAwbkW7OhJUA1G/Xr12eKeQAAwjTFfFTXbBTUn/70J7cUREJCgluUI6LlwIED5hsVKkS6BAAARF/ORn6qV69u8fHxtnXr1iz7tV2rVq2jOvbAgQNt5cqVtnDhQvMF1WSodkMLtRoAgCgS1cFG2bJl3SBdM2fODO5TU4m2Q5tVCkO1Gko47dChQxGUFAAARG0zSnp6uq1duza4vW7dOlu6dKlVq1bNEhMTXbfXlJQUa9++vUsGHTNmjOsuq94pR1uzoSXQ3gQAAHwabCxatMi6du0a3FZwIQowJk6caH379rXt27fb8OHDbcuWLda2bVubNm2a1axZM4KljkL79pldcknm+ltvmZUrF+kSAQAQfb1RilNogujq1avpjQIAQJh6o8RssHGkb1TUI9gAAETpNTSqE0QBAEDJF7PBBr1RAAAoHjSj0IwCAECh0IwCAACiQsS7vkZaoGKnxM/+qpqNAJ2Ln4ZhBwBEpcC183CNJDEfbOzatcv9q8nYfKNOnUiXAAAQY9fSY/MZIDPmczY0/Llml61cubKbdbYoBGaS3bhxY8nOAymgWDvfWDznWDvfWDznWDvfWDzn38JwvgohFGjUqVPHSpXKOzMj5ms29ObUq1cvLMfWhxkLX+BYPd9YPOdYO99YPOdYO99YPOdjivh8CzLlBwmiAAAgrAg2AABAWBFshEFCQoKlpqa6f2NBrJ1vLJ5zrJ1vLJ5zrJ1vLJ5zQgTPN+YTRAEAQHhRswEAAMKKYAMAAIQVwQYAAAgrgg0AABBWBBthmLo+KSnJypUrZ506dbIFCxaYX8ydO9d69erlRorTaKtTp07N8rhyjYcPH261a9e28uXLW7du3WzNmjVWUo0cOdI6dOjgRpetUaOG9e7d27777rssz9m3b58NHDjQjjvuOKtUqZJdcskltnXrViupnn76aWvdunVw0J/OnTvbhx9+6Nvzze7BBx903+1bb73Vl+d8zz33uPMLXZo1a+bLcw21adMmu+qqq9x56bfppJNOskWLFvnytyspKSnHZ6xFn2skP2OCjSI0adIkGzJkiOtatGTJEmvTpo0lJyfbtm3bzA92797tzkkBVW4efvhhe/zxx23cuHH25ZdfWsWKFd3568tdEs2ZM8f9Tzl//nz7+OOP7ffff7fzzz/fvQ8Bt912m7377rs2efJk93wNfX/xxRdbSaXRdHXBXbx4sfsxPuecc+yiiy6yb775xpfnG2rhwoX2zDPPuGArlN/OuWXLlrZ58+bg8tlnn/n2XGXnzp12+umnW5kyZVzgvHLlShs9erRVrVrVl79dCxcuzPL56rdLLrvsssh+xur6iqLRsWNHb+DAgcHtAwcOeHXq1PFGjhzp+Y2+OlOmTAluHzx40KtVq5Y3atSo4L5ffvnFS0hI8F577TXPD7Zt2+bOe86cOcHzK1OmjDd58uTgc7799lv3nHnz5nl+UbVqVe/555/39fnu2rXLa9y4sffxxx97Xbp08QYPHuz2++2cU1NTvTZt2uT6mN/ONeDvf/+7d8YZZ+T5uN9/uwYPHuydcMIJ7jwj+RlTs1FEMjIy3N2gqt9C513R9rx588zv1q1bZ1u2bMly/hovX01Jfjn/X3/91f1brVo1968+b9V2hJ6zqqQTExN9cc4HDhyw119/3dXkqDnFz+erGqyePXtmOTfx4zmreUBNoY0aNbIrr7zSfvjhB9+eq7zzzjvWvn17d2ev5tCTTz7ZnnvuuZj47crIyLCXX37ZrrvuOteUEsnPmGCjiOzYscP9ONesWTPLfm3ri+x3gXP06/lrdmC146s6tlWrVm6fzqts2bJWpUoVX53zihUrXFuuRhm84YYbbMqUKdaiRQvfnq8CKjV7KkcnO7+dsy6gEydOtGnTprn8HF1ozzzzTDdrp9/ONeD7779359q4cWObPn263XjjjXbLLbfYCy+84PvfrqlTp9ovv/xi1157rduO5Gcc87O+AgW98/3666+ztG/7VdOmTW3p0qWuJufNN9+0lJQU17brR5pqe/Dgwa5dW0ndfte9e/fgunJTFHw0aNDA3njjDZcY6Ue6UVDNxgMPPOC2VbOh/5eVn6Hvtp/961//cp+5arIijZqNIlK9enWLj4/PkdWr7Vq1apnfBc7Rj+c/aNAge++992z27NkugTJA56VqSt05+Omcdedz4oknWrt27dzdvpKCH3vsMV+er6qVlcB9yimnWOnSpd2iwErJglrXHZ/fzjmU7nCbNGlia9eu9eXnK+phopq5UM2bNw82H/n1t2vDhg02Y8YMu/7664P7IvkZE2wU4Q+0fpxnzpyZJaLWttq7/a5hw4buyxp6/r/99pvL7C6p5688WAUaakaYNWuWO8dQ+ryV4R56zuoaqx+xknrOudH3eP/+/b4833PPPdc1G6kmJ7DoLli5DIF1v51zqPT0dPvPf/7jLsh+/HxFTZ/Zu6yvXr3a1ej49bdLJkyY4HJUlIsUENHPOKzppzHm9ddfdxnMEydO9FauXOkNGDDAq1KlirdlyxbPD5Sx/9VXX7lFX520tDS3vmHDBvf4gw8+6M733//+t7d8+XLvoosu8ho2bOjt3bvXK4luvPFG79hjj/U++eQTb/PmzcFlz549wefccMMNXmJiojdr1ixv0aJFXufOnd1SUg0dOtT1tlm3bp37DLUdFxfnffTRR74839yE9kbx2znffvvt7vusz/fzzz/3unXr5lWvXt31tPLbuQYsWLDAK126tHf//fd7a9as8V555RWvQoUK3ssvvxx8jt9+uw4cOOA+R/XEyS5SnzHBRhF74okn3AdZtmxZ1xV2/vz5nl/Mnj3bBRnZl5SUFPe4ulbdfffdXs2aNV3Qde6553rfffedV1Lldq5aJkyYEHyOfoxuuukm1z1UP2B9+vRxAUlJdd1113kNGjRw39/jjz/efYaBQMOP51uQYMNP59y3b1+vdu3a7vOtW7eu2167dq0vzzXUu+++67Vq1cr9LjVr1sx79tlnszzut9+u6dOnu9+q3M4hUp8xU8wDAICwImcDAACEFcEGAAAIK4INAAAQVgQbAAAgrAg2AABAWBFsAACAsCLYAAAAYUWwAQAAwopgA0DE3HPPPda2bdsCP3/9+vUWFxfn5i3JyyeffOKek32yKQCRQ7ABFLNXXnnF6tevb1WrVrUhQ4bkuJhqFk5NBFXYi+7ZZ59tt956q8Wq0047zTZv3mzHHnvsUR/rrbfecu+njlWpUiU3Lft9991nP//8s0VzUAZEG4INoBjt2LHDTfn8yCOP2EcffWQvv/yym74+4KabbrIHH3zQjjnmmIiWs6TPwKxZPBWMHY1//OMf1rdvX+vQoYN9+OGH9vXXX9vo0aNt2bJl9tJLLxVZeYFYQLABFKPvv//e3SUHLmJdu3a1b7/91j322muvuemfL7744iJ9TU0Pf8cdd1jdunWtYsWK1qlTJ9fUEDBx4kSrUqWKC3qaNm1qFSpUsEsvvdT27NljL7zwgiUlJblamFtuucUOHDgQ/LudO3faNddc4x7T33Tv3t3WrFmT5bWfe+45V4ujx/v06WNpaWnutfKbzl41B/Xq1bOEhAR3Nz9t2rQcz1u1apWrwShXrpy1atXK5syZk2czSuD8pk+fbs2bN3c1FBdccIGr/cjLggUL7IEHHnDBxahRo9xr6X0477zzXG1HSkpK8LlPP/20nXDCCS7I0fsXGojkVgOlcmlf4DMIlFfTfmtKe71Xer3AtOgq/7333uuCHD1Pi/ZpWivVeCQmJrr3qk6dOu4zAqJS2Kd6AxD0888/e5UrV/aWLFni/fTTT24a62nTprn9J5xwgvfDDz8U6DiaIlz/+3711VeHnbX0+uuv90477TRv7ty5bobPUaNGuZktV69e7R7XLLZlypTxzjvvPFcuTTF/3HHHeeeff753+eWXe998842bNVMzhb7++uvB4/7pT3/ymjdv7o67dOlSLzk52TvxxBO9jIwM9/hnn33mlSpVyr2eZp988sknvWrVqnnHHnts8BipqalemzZtgttpaWneMccc47322mveqlWrvLvuusuVLVDWwHnXq1fPe/PNN72VK1e689N7umPHjiyzE+/cuTPL+Wk69YULF3qLFy925b7iiivyfH9vueUWr1KlSsFzycvbb7/tjq1z0zmOHj3ai4+Pd9N35/U5qVzap3KGlrdTp05u+ne932eeeab7zGTPnj1uaviWLVu62Tm1aN/kyZPde/XBBx94GzZs8L788sscs5kC0YJgAyhmukBpumsFF7rYBqZ2f/TRR92Fvm3btu7CootJXgIXsfLly3sVK1bMsugCHwg2dBHSxW/Tpk1Z/l5TaA8bNix4MdaxQqca/9vf/uamn961a1dwn4IJ7Rdd/PU3n3/+efBxXexVnjfeeMNta/rynj17ZnndK6+8Mt9go06dOt7999+f5W86dOjgpsQOPe8HH3ww+Pjvv//ugo+HHnooz2Aj+/kpONB04nnp3r2717p1a+9wFBD0798/y77LLrvM69GjxxEHGzNmzAg+5/3333f7NB14bu+TKLBp0qTJYQMiIBqUjnTNChBr1JygJUBNAMuXL7cnnnjCTjzxRNecopyDjh072llnnWU1atTI81iTJk1yTQOhrrzyyuD6ihUrXNOHkk6zN60cd9xxwW1V3aspIKBmzZqu2UBNDqH7tm3b5tbV9FO6dGnXJBOg46kZIdAspGaA0PMUnVNojkooJcX++OOPdvrpp2fZr201IYTq3LlzcF3lUPND4HVzk/38ateuHTyX3OhGrCD0mgMGDMhR3scee8yOlJJPQ8snKqOaSXJz2WWX2ZgxY6xRo0auWahHjx7Wq1cv934A0YZvJRBBuugrKVTt/GvXrrU//vjDunTp4h5TgPDll1+6C0helA+hACVU+fLlg+vp6ekWHx9vixcvdv+GCg0klCsSSnkBue1TTkVJlNu55BdQ6L3/7LPP7Pfff8/xt0eiVKnMtLjQ19IxD1fGQHJrfu+3PnsFdDNmzLCPP/7YfY+UX6Lg9WjKDIQDCaJABI0YMcLdlZ5yyimuBkLBRuhFKTQhszBOPvlkdwzdISsoCV1Ue1JYqk1RWRUMBfz000/u4teiRQu3rVqOhQsXZvm77Nuh1ANHSY6ff/55lv3aDhwzYP78+cF1lUPBVPYanqNxxRVXuEDtqaeeyvXxQPKpXjO/8h5//PHu39Bk1PzGCMmLkk9z+y4osFQw+vjjj7tE03nz5rnaLCDaULMBRMjKlStdM8hXX33ltps1a+buhP/1r3+5QEA9LtRj5WjoDl3NKuo1op4VCj62b9/uej6o2r5nz56FOm7jxo3toosusv79+9szzzxjlStXtqFDh7oeL9ovN998s2sGUg8UXRBnzZrlupDm1yX1zjvvtNTUVNfkoZ4oEyZMcBdnjU0S6sknn3Rl0MX+0UcfdT1jrrvuOisqah6666677Pbbb7dNmza55iAFQqp9GjdunJ1xxhk2ePBgV97LL7/cva/dunWzd999195++21X2xAIBk499VTXnblhw4Yu6PvnP/95xOVRk9a6devce6GeOnq/1dymAERlVTORulHr9Ro0aFBk7wNQZCKdNALEooMHD3qnn3666+URStuJiYkuefG5554rkt4oSiAcPny4l5SU5HpO1K5d2+vTp4+3fPnyYAJlaNJmXgmJKSkp3kUXXRTcVg+aq6++2v2tEkOVQBroNRKg3hF169Z1j/fu3dsbMWKEV6tWrTxf58CBA94999zj/kZl1WMffvhhjvN+9dVXvY4dO7oeMi1atAj2/sgrQTT7+U2ZMsU953AmTZrknXXWWa63i5JvlTR63333BY8tTz31lNeoUSNXXiVsvvjii1mOoR4znTt3du+Bkn8/+uijXBNEQ4+pz1X7dL6yb98+75JLLvGqVKni9uucdA7qwaIeKSrbqaeemiXJFIgmcfpP0YUuAJA31YSoxubTTz+NdFEAFCOaUQCEjUZK1UBYGkxMTSgaJCyvPAgA/kXNBoCwUT6DEhd37drlumgqj+OGG26IdLEAFDOCDQAAEFZ0fQUAAGFFsAEAAMKKYAMAAIQVwQYAAAgrgg0AABBWBBsAACCsCDYAAEBYEWwAAAALp/8PeIpPJUg+i0YAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.figure(figsize=(6, 4))\n", + "sns.histplot(adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True)) # Log scale y to see small RBC populations\n", + "plt.title(\"Hemoglobin Content Distribution\")\n", + "plt.xlabel(\"% Hemoglobin Counts\")\n", + "plt.axvline(5, color='red', linestyle='--', label='5% Cutoff')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dabf25b2", + "metadata": {}, + "source": [ + "#### Create a copy of the data and apply QC cutoffs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "be603387", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Before filtering: 785021 cells\n", + "After filtering: 784929 cells\n" + ] + } + ], + "source": [ + "# Create a copy or view to avoid modifying the original if needed\n", + "adata_qc = adata.copy()\n", + "\n", + "# --- Define Thresholds ---\n", + "# Low quality (Empty droplets / debris)\n", + "min_genes = 200 # Standard for immune cells (T-cells can be small)\n", + "min_counts = 500 # Minimum UMIs\n", + "\n", + "# Doublets (Two cells stuck together)\n", + "# Adjust this based on the scatter plot above. \n", + "# 4000-6000 is common for 10x Genomics data.\n", + "max_genes = 6000 \n", + "max_counts = 30000 # Very high counts often indicate doublets\n", + "\n", + "# Contaminants\n", + "max_hb_pct = 5.0 # Remove Red Blood Cells (> 5% hemoglobin)\n", + "\n", + "# --- Apply Filtering ---\n", + "print(f\"Before filtering: {adata_qc.n_obs} cells\")\n", + "\n", + "# 1. Filter Low Quality & Doublets\n", + "adata_qc = adata_qc[\n", + " (adata_qc.obs['n_genes_by_counts'] > min_genes) &\n", + " (adata_qc.obs['n_genes_by_counts'] < max_genes) &\n", + " (adata_qc.obs['total_counts'] > min_counts) &\n", + " (adata_qc.obs['total_counts'] < max_counts)\n", + "]\n", + "\n", + "# 2. Filter Red Blood Cells (Hemoglobin)\n", + "# Only run this if you want to remove RBCs\n", + "adata_qc = adata_qc[adata_qc.obs['pct_counts_hb'] < max_hb_pct]\n", + "\n", + "print(f\"After filtering: {adata_qc.n_obs} cells\")" + ] + }, + { + "cell_type": "markdown", + "id": "faa4a504", + "metadata": {}, + "source": [ + "### Perform doublet detection\n", + "\n", + "According to Gemini:\n", + "\n", + "You must do this before normalization or clustering because doublets create \"hybrid\" expression profiles that can form fake clusters (e.g., a \"cluster\" that looks like a mix of T-cells and B-cells) or distort your normalization factors.\n", + "\n", + "**Important: Run Per Donor**\n", + "\n", + "Since you have multiple people, you must run doublet detection separately for each donor. The doublet rate is a technical artifact of the physical loading of the machine (10x Genomics chip), which varies per run. If you run it on the whole dataset at once, the algorithm will get confused by biological differences between people.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7c89ced5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data shape before doublet detection: (784929, 29331)\n", + "Running Scrublet on 698 donors...\n", + "Detected 7335 doublets across all donors.\n", + "predicted_doublet\n", + "False 777594\n", + "True 7335\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "\n", + "# 1. Check preliminary requirements\n", + "# Scrublet needs RAW counts. Ensure adata.X contains integers, not log-normalized data.\n", + "# If your main layer is already normalized, use adata.raw or a specific layer.\n", + "print(f\"Data shape before doublet detection: {adata_qc.shape}\")\n", + "\n", + "# 2. Run Scrublet per donor\n", + "# We split the data, run detection, and then recombine.\n", + "# This prevents the algorithm from comparing a cell from Person A to a cell from Person B.\n", + "\n", + "adatas_list = []\n", + "# Get list of unique donors\n", + "donors = adata_qc.obs['donor_id'].unique()\n", + "\n", + "print(f\"Running Scrublet on {len(donors)} donors...\")\n", + "\n", + "for donor in donors:\n", + " # Subset to current donor\n", + " curr_adata = adata_qc[adata_qc.obs['donor_id'] == donor].copy()\n", + " \n", + " # Skip donors with too few cells (Scrublet needs statistical power)\n", + " if curr_adata.n_obs < 100:\n", + " print(f\"Skipping donor {donor}: too few cells ({curr_adata.n_obs})\")\n", + " # We still add it back to keep the data, but mark as singlet (or filter later)\n", + " curr_adata.obs['doublet_score'] = 0\n", + " curr_adata.obs['predicted_doublet'] = False\n", + " adatas_list.append(curr_adata)\n", + " continue\n", + "\n", + " # Run Scrublet\n", + " # expected_doublet_rate=0.06 is standard for 10x (approx ~0.8% per 1000 cells recovered)\n", + " # If you loaded very heavily (20k cells/well), increase this to 0.10\n", + " sc.pp.scrublet(curr_adata, expected_doublet_rate=0.06)\n", + " \n", + " adatas_list.append(curr_adata)\n", + "\n", + "# 3. Merge back into one object\n", + "adata_qc = sc.concat(adatas_list)\n", + "\n", + "# 4. Check results\n", + "print(f\"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors.\")\n", + "print(adata_qc.obs['predicted_doublet'].value_counts())" + ] + }, + { + "cell_type": "markdown", + "id": "04d2984a", + "metadata": {}, + "source": [ + "#### Visualize doublets\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5882e417", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20)" + ] + }, + { + "cell_type": "markdown", + "id": "25f6e3fb", + "metadata": {}, + "source": [ + "#### Filter doublets\n", + "- Question: how consistent are these results with other methods for doublet detection? https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html#doublet-detection" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "dd9b6443", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "found 7335 predicted doublets\n", + "Remaining cells: 777594\n" + ] + } + ], + "source": [ + "# Check how many doublets were found\n", + "print(f'found {adata_qc.obs[\"predicted_doublet\"].sum()} predicted doublets')\n", + "\n", + "# Filter the data to keep only singlets (False)\n", + "# write back to adata for simplicity\n", + "adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :]\n", + "print(f\"Remaining cells: {adata.n_obs}\")" + ] + }, + { + "cell_type": "markdown", + "id": "71f3bbaa", + "metadata": {}, + "source": [ + "#### Save raw counts for later use" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "00da60cb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T/ipykernel_48619/871672687.py:2: ImplicitModificationWarning: Setting element `.layers['counts']` of view, initializing view as actual.\n", + " adata.layers['counts'] = adata.X.copy()\n" + ] + } + ], + "source": [ + "# set the .raw attribute (standard Scanpy convention)\n", + "adata.layers['counts'] = adata.X.copy()" + ] + }, + { + "cell_type": "markdown", + "id": "d97842a3", + "metadata": {}, + "source": [ + "### Total Count Normalization\n", + "This scales each cell so that they all have the same total number of counts (default is often 10,000, known as \"CP10k\")." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2d2d9b0c", + "metadata": {}, + "outputs": [], + "source": [ + "# Normalize to 10,000 reads per cell\n", + "# target_sum=1e4 is the standard for 10x data\n", + "sc.pp.normalize_total(adata, target_sum=1e4)" + ] + }, + { + "cell_type": "markdown", + "id": "0efc2045", + "metadata": {}, + "source": [ + "### Log Transformation (Log1p)\n", + "This applies a natural logarithm to the data: log(X+1). This reduces the skewness of the data (since gene expression follows a power law) and stabilizes the variance." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d412ddd8", + "metadata": {}, + "outputs": [], + "source": [ + "# Logarithmically transform the data\n", + "sc.pp.log1p(adata)" + ] + }, + { + "cell_type": "markdown", + "id": "bd5a1cde", + "metadata": {}, + "source": [ + "### select high-variance features\n", + "\n", + "according to Gemini:\n", + "For a large immune dataset (PBMCs, ~1.2M cells), the standard defaults often fail to capture the subtle biological variation needed to distinguish similar cell types (like CD4+ T-cell subsets).\n", + "\n", + "Here are the reasonable parameters and, more importantly, the **immune-specific strategy** you should use.\n", + "\n", + "#### The Recommended Parameters\n", + "\n", + "For a dataset of your size, the **`seurat_v3`** flavor is generally superior because it selects genes based on standardized variance (handling the mean-variance relationship better than the dispersion-based method).\n", + "\n", + "* **`flavor`**: `'seurat_v3'` (Requires **RAW integer counts** in `adata.X` or a layer)\n", + "* **`n_top_genes`**: **2000 - 3000** (3000 is safer for immune data to capture rare cytokines/markers)\n", + "* **`batch_key`**: **`'donor_id'`** (CRITICAL)\n", + " * *Why?* With 1.2M cells across many people, you have massive batch effects. If you don't set this, \"highly variable genes\" will just be the genes that differ between Person A and Person B (e.g., HLA genes, gender-specific genes like XIST/RPS4Y1), rather than genes distinguishing cell types.\n", + "\n", + "#### The \"Expert\" Trick: Blocklisting Nuisance Genes\n", + "In immune datasets, \"highly variable\" does not always mean \"biologically interesting.\" You often need to **exclude** specific gene families from the HVG list *after* calculation but *before* PCA, or they will hijack your clustering:\n", + "1. **TCR/BCR Variable Regions (IG*, TR*):** These are hyper-variable by definition (V(D)J recombination). If you keep them, T-cells will cluster by **clone** (clonotype) rather than by **phenotype** (state).\n", + "2. **Mitochondrial/Ribosomal:** Usually technical noise.\n", + "3. **Cell Cycle:** (Optional) If you don't want proliferating cells to cluster separately.\n", + "\n", + "\n", + "\n", + "#### Why 3000 genes instead of 2000?\n", + "Immune cells are dense with specific markers. The difference between a *Naive CD8 T-cell* and a *Central Memory CD8 T-cell* might rest on a handful of genes (e.g., *CCR7, SELL, IL7R* vs *GZMK*). If you limit to 2000 genes in a massive, diverse dataset, you might accidentally drop a subtle marker required to resolve these fine-grained states." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5a64c2c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Blocked 0 immune receptor genes from HVG list.\n", + "Final HVG count: 3000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/poldrack/Dropbox/code/BetterCodeBetterScience/.venv/lib/python3.12/site-packages/scanpy/preprocessing/_pca/__init__.py:226: FutureWarning: Argument `use_highly_variable` is deprecated, consider using the mask argument. Use_highly_variable=True can be called through mask_var=\"highly_variable\". Use_highly_variable=False can be called through mask_var=None\n", + " mask_var_param, mask_var = _handle_mask_var(\n" + ] + } + ], + "source": [ + "\n", + "import scanpy as sc\n", + "import pandas as pd\n", + "\n", + "\n", + "# 2. Run Highly Variable Gene Selection\n", + "# batch_key is critical here to find genes variable WITHIN donors, not BETWEEN them.\n", + "sc.pp.highly_variable_genes(\n", + " adata,\n", + " n_top_genes=3000,\n", + " flavor='seurat_v3',\n", + " batch_key='donor_id',\n", + " span=0.8, # helps avoid numerical issues with LOESS\n", + " layer='counts', # Change this to None if adata.X is raw counts\n", + " subset=False # Keep False so we can manually filter the list below\n", + ")\n", + "\n", + "# 3. Filter out \"Nuisance\" Genes from the HVG list\n", + "# We don't remove the genes from the object, we just set their 'highly_variable' status to False\n", + "# so they aren't used in PCA.\n", + "\n", + "# A. Identify TCR/BCR genes (starts with IG or TR)\n", + "# Regex: IG or TR followed by a V, D, J, or C gene part\n", + "import re\n", + "immune_receptor_genes = [\n", + " name for name in adata.var_names \n", + " if re.match(r'^(IG[HKL]|TR[ABDG])[VDJC]', name)\n", + "]\n", + "\n", + "# B. Identify Ribosomal/Mitochondrial (if not already handled)\n", + "mt_genes = adata.var_names[adata.var_names.str.startswith('MT-')]\n", + "rb_genes = adata.var_names[adata.var_names.str.startswith(('RPS', 'RPL'))]\n", + "\n", + "# C. Manually set them to False\n", + "genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes)\n", + "\n", + "# Using set operations for speed\n", + "adata.var.loc[adata.var_names.isin(genes_to_block), 'highly_variable'] = False\n", + "\n", + "print(f\"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.\")\n", + "print(f\"Final HVG count: {adata.var['highly_variable'].sum()}\")\n", + "\n", + "# 4. Proceed to PCA\n", + "sc.tl.pca(adata, svd_solver='arpack', use_highly_variable=True)\n" + ] + }, + { + "cell_type": "markdown", + "id": "2055120b", + "metadata": {}, + "source": [ + "### Dimensionality reduction" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "93802dfb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-12-20 10:37:58,784 - harmonypy - INFO - Computing initial centroids with sklearn.KMeans...\n", + "2025-12-20 10:38:23,074 - harmonypy - INFO - sklearn.KMeans initialization complete.\n", + "2025-12-20 10:38:25,994 - harmonypy - INFO - Iteration 1 of 10\n", + "2025-12-20 10:49:03,832 - harmonypy - INFO - Iteration 2 of 10\n", + "2025-12-20 10:59:50,478 - harmonypy - INFO - Iteration 3 of 10\n", + "2025-12-20 11:10:24,641 - harmonypy - INFO - Iteration 4 of 10\n", + "2025-12-20 11:20:50,945 - harmonypy - INFO - Iteration 5 of 10\n", + "2025-12-20 11:30:24,097 - harmonypy - INFO - Converged after 5 iterations\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Harmony integration successful. Using corrected PCA.\n" + ] + } + ], + "source": [ + "import scanpy.external as sce\n", + "\n", + "# 1. Run Harmony\n", + "# This adjusts the PCA coordinates to mix donors together while preserving biology.\n", + "# It creates a new entry in obsm: 'X_pca_harmony'\n", + "try:\n", + " sce.pp.harmony_integrate(adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony')\n", + " use_rep = 'X_pca_harmony'\n", + " print(\"Harmony integration successful. Using corrected PCA.\")\n", + "except ImportError:\n", + " print(\"Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).\")\n", + " print(\"To install: pip install harmony-pytorch\")\n", + " use_rep = 'X_pca'" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "55f80ce1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Reality check: Check if PC1 is just \"Cell Size\":\n", + "\n", + "sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'])" + ] + }, + { + "cell_type": "markdown", + "id": "406256c8", + "metadata": {}, + "source": [ + "PC1 separates cell types and isn't driven only by the number of cells." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "5cde35ac", + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Compute Neighbors\n", + "# n_neighbors: 15-30 is standard. Higher (30-50) is better for large datasets to preserve global structure.\n", + "# n_pcs: 30-50 is standard.\n", + "sc.pp.neighbors(adata, n_neighbors=30, n_pcs=40, use_rep=use_rep)\n", + "\n", + "# 3. Compute UMAP\n", + "# This projects the graph into 2D for you to look at.\n", + "sc.tl.umap(adata, init_pos='X_pca_harmony')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ce2bc327", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sc.pl.umap(adata, color=\"total_counts\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "2209ee21", + "metadata": {}, + "source": [ + "### Clustering\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "35247ba6", + "metadata": {}, + "outputs": [], + "source": [ + "# 4. Run Clustering (Leiden algorithm)\n", + "# We run multiple resolutions so you can choose the best one later.\n", + "#sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5')\n", + "sc.tl.leiden(adata, resolution=1.0, key_added='leiden_1.0',\n", + " flavor=\"igraph\", n_iterations=2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "1e9ab973", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABWAAAAGvCAYAAADVBnyvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QV8XGW6BvDnnDM+mXgaqRvQlhaKU6y4LL6Lu+tiiy/uLssuuotedGEXWFhkcXcvlLo3buMzR+7v/dIJSZq0TRvP87+/3GTszJlJ7+XNM+/3fprjOA6IiIiIiIiIiIiIqMvpXX9IIiIiIiIiIiIiIhIMYImIiIiIiIiIiIi6CQNYIiIiIiIiIiIiom7CAJaIiIiIiIiIiIiomzCAJSIiIiIiIiIiIuomDGCJiIiIiIiIiIiIugkDWCIiIiIiIiIiIqJuwgCWiIiIiIiIiIiIqJswgCUiIiIiIiIiIiLqJgxgiahLaJqGq666qvnyo48+qq5bsGBBr54XEREREVFft7a1s9Tf8ri1qdeJiKjnMIAloj7jk08+UUVhfX19b58KERERERF1g+uvvx777rsviouL1yoUTiaTuOiii1BWVga/348tt9wS//vf/7rtfImIugIDWCLqUwHs1VdfzQCWiIiIiGgNXHbZZYjH4+hv5/zll19i6tSpa/X4Y489FnfccQeOOOII3H333TAMA3vttRc++uijLj9XIqKu4uqyIxERERERERFRj3G5XOqrP5k/fz5GjRqF6upqFBUVdeqxX3zxBZ555hnceuutOP/889V1Rx99NDbccENceOGFqqGDiKgvYgcs0SC3dOlSnHDCCWoJj9frxejRo3HaaachlUqp26Ub9ZxzzsHw4cPV7ePGjcPNN98M27a79Dxk6dEFF1ygfpZzkOVImTlYO+ywAzbaaKN2H7f++utj9913Vz/LfeUxt912G+68806MHDlSLUuSx//0008rPXbmzJn4wx/+gPz8fPh8Pmy22WZ4+eWXu/R1ERERERGtjddeew3bbbcdgsEgQqEQfve732HGjBmrnQErS/TPPfdcFW7K42S5/5IlSzr8W+D4449X4wCk1p80aRIefvjhVvd577331HM899xzanzAsGHDVO288847Y86cOZ1+XRK+rq3nn39edbyefPLJzdfJucjfM59++ikWL1681scmIupO/eujMiLqUsuWLcMWW2yhQlYpYjbYYANVhElhE4vFYJqmCi/lulNOOQUjRoxQnypfcsklWL58Oe66664uO5cDDzwQs2bNwtNPP63C08LCQnW9FI5HHXUUTjrpJBWiyqfbGbJ0SR4jy5haevzxxxEOh3HGGWcgkUiopUk77bQTfvzxR1VcCilet9lmGwwdOhQXX3yxKmylqNx///3xwgsv4IADDuiy10ZERERE1BlPPPEEjjnmGNVoIM0PUpvfd9992HbbbfHtt9+uMsQ88cQT8X//9384/PDDMW3aNLzzzjsqvG2roqICW221lQpXzzzzTFV3S+grYWZjY6Nqwmjppptugq7rqvO0oaEBt9xyixoD8Pnnn6OnyGtfb731kJ2d3ep6+ZtGfPfdd6pxhIioz3GIaNA6+uijHV3XnS+//HKl22zbdq699lonGAw6s2bNanXbxRdf7BiG4SxatKj5Ovl/J1deeWXz5UceeURdN3/+/DU+n1tvvbXdx9TX1zs+n8+56KKLWl1/1llnqfOLRCLqsjxOHu/3+50lS5Y03+/zzz9X15977rnN1+28887O5MmTnUQi0eo1T5s2zRk/fvwanzMRERER0bpqWTuHw2EnNzfXOemkk1rdp7y83MnJyWl1vdTfLf+s/+6779Tl008/vdVjDz/88JXq9RNOOMEpLS11qqurW9330EMPVc8Ti8XU5XfffVc9dsKECU4ymWy+3913362u//HHH9fqNVdVVa10TqszadIkZ6eddlrp+hkzZqhj3X///Wt1LkRE3Y0jCIgGKRkh8OKLL2KfffZRS+/bkk/C//nPf6plT3l5eWpGU+Zrl112gWVZ+OCDD3rkXHNycrDffvup7timrBfq+Z999lnVsSrdqy3JddLZ2vITcdkd9b///a+6XFtbqzoBDj74YNUpm3ldNTU1qstg9uzZquuXiIiIiKin/e9//1Mr1A477LBWNbgsvZea9t133+3wsZl696yzzmp1fdtuVqmpZdWX/C0gP7d8HqmHpcP1m2++afWY4447Dh6Pp/my/J0g5s2bh54iG47JqIS2ZAxB5nYior6IIwiIBqmqqiq1tKjlkv62JIj84YcfOhyOX1lZiZ4iw/UlcP3www+x/fbb46233lLLpmQ8QVvjx49f6TpZqiQjBoTMqpJC8/LLL1dfHb22liEuEREREVFPkBpcyAit9rRdft/SwoUL1ZiAsWPHrrRvQtu/BSTkffDBB9XXmtT6Mo6sJWnSEHV1degpsr+DzLhtS8aOZW4nIuqLGMAS0Sq7ZHfddVe1o2h7JNTsKfJJvMxvlXlWEsDK95KSEtWN21mZDcRkflVmA6+2ZLMxIiIiIqKelqlVZQ6s1LttuVyuLnuOI488Us2abc+UKVNaXZYO3PZkVqj1hNLS0nZXqsn+FEI2FiYi6osYwBINUtLVKp+ey8ZWHZFPziORyFqFnGuj7Q6ubQs+2Ujg0UcfVRsRyPgE2ZirvUIw0zXQkmzWldmsYMyYMeq72+3usddGRERERLQmMt2rQ4YM6XStOnLkSBWuzp07t1XX66+//rrS3wKhUEiN9epP9fDGG2+sRjDISr6WncCZjcDkdiKivogzYIkGKVmaJLNS//Of/+Crr75q95NsmZH66aef4o033ljpdlmyZJpml55TZparHLs9Mm5AljidcsopKhiWT+zbI+Fsy0/Gv/jiC1WU7bnnns3F7PTp0/HAAw80f1redkkWEREREVFvkBVaEi7ecMMNSKfTnapVM/XuX/7yl1bX33XXXa0uSxPD73//ezUHtr2GjL5QD8s82pkzZyIWizVf94c//EGFxi3HJshIgkceeUTNxx0+fHgvnS0R0aqxA5ZoEJOi7s0338QOO+yAk08+GRMmTFCBpGy+9dFHH+GCCy7Ayy+/jL333hvHHnssNt10U0SjUfz44494/vnnsWDBAhQWFnbZ+cjxxZ///GcceuihqkNVNgbIBLNTp05VM2vl/ORcN9lkkw7HB2y77bY47bTTVEEmBWdBQUGrUQp/+9vf1H0mT56sOmmlK1ZmykrgvGTJEnz//fdd9rqIiIiIiNaUhK/33Xefaj6QelfqYulYXbRoEV599VVss802+Otf/9ruY6UDVDbvuvfee9VGWtOmTcPbb7+t9kBo66abblLdpBJcSj08ceJEtVmtbL4l+y3Iz91BRivIrNpMsCob+1533XXqZ3nN0sUr5DVeffXV6hyleULIuR500EG45JJL1Ixaqfsfe+wx9XfJP/7xj245XyKirsAAlmgQk02mpDNUNqJ68skn1VIeuU4+OQ8EAmqX0/fff18FtRJ6Pv7446oglNmvUgzl5OR06flsvvnmuPbaa3H//ffj9ddfV8un5s+f3xzAZjbjkiC1vc23Wt5HOnwleJXCbIsttlAFnMyMypACUzp/5XXIWIOamhrVGSsh7xVXXNGlr4uIiIiIqDNk9JbMM5WQ9NZbb1VNBVKnb7fddjjuuONW+diHH35YBbZS38vKMNnMS4Lbtt2hsr+CrBS75ppr8K9//UuFttK0MGnSJDXyq7tIUCp/Y2RIwCpfQhokMgFsR+RvEvn7RYJcWR0ns2pfeeUVtU8EEVFfpTk9OTGbiGgd3X333Tj33HPVp9xtd2KV60aPHq2KVNlgi4iIiIiIiIiot3EGLBH1G/J5kXxiLiMT2oavRERERERERER9EUcQEFG3kw2z5GtVZJmUbAbQHpk7K7NoZWmSzJ996aWXuulMiYiIiIios+LxuJo5uyr5+flqxBkR0WDEAJaIut1tt92mZq2uisx6HTVqVLu3yS6sMgcrNzcXl156Kfbdd99uOlMiIiIiIuqsZ599drWzaVtupkVENNhwBiwRdbt58+apr1WRgfs+n6/HzomIiIiIiLrG8uXLMWPGjFXeZ9NNN0VeXl6PnRMRUV/CAJaIiIiIiIiIiIiom3ATLiIiIiIiIiIiIqKBNAPWtm0sW7YMoVAImqb1xikQERFRHyYLdMLhMMrKyqDr/LyYqCexViciIqLVYb3eDwJYKeiGDx/eG09NRERE/cjixYsxbNiw3j4NokGFtToRERGtKdbrfTiAlU/TM7+k7Ozs3jgFIiIi6sMaGxtVAJSpGYio57BWJyIiotVhvd4PAtjMUiYp6FjUERERUUe4/Jmo57FWJyIiojXFen3NcEgDERERERERERERUTdhAEtERERERERERETUTRjAEhEREREREREREXUTBrBERERERERERERE3YQBLBEREREREREREVE3YQBLRERERERERERE1E0YwBIRERERERERERF1EwawRERERERERERERN2EASwRERERERERERFRN2EAS0RERERERERERNRNGMASERERERERERERdRMGsERERERERERERETdhAEsERERERERERERUTdhADuIRFKRVpeXNC5BOBnutfMhIiIiIqLf2Amz+WfHtGHWJ2HF0716TkRERLTuXF1wDOpDbMeGrunNP8fSMdQl6hB0BxFJR1Abr1XXp+00loWXYUT2CIS8od4+bSIiIiKiQcGxHWi61hy4ah4D6aoYNJ8BOA6scBJw6UjVxmG4dOh+Dwy/u7dPm4iIiNYBA9gBwLRNuPSmX+W8+nlIWknAaQpgy6PlKmz1G34VuKacFPI8eSgOFWNm7UxUxapUSCvXDwkMQY43B1merN5+SUREREREA4ZjOdCMptA1sbgRmlcHLMAKp+CYacDR4EBDalkEus+Au9APK2kjmUjDZWgwoym4Qx7A0GAEPdA9Rm+/JCIiIuoEBrD9lOM4iJkxGJqBmngNSoIlSNkplGWV4aMlH6HMX4ZPl32KqmgV3C43quPVCBgBlMfLodkaxhWMU49bXL8Yny/9HIdMPER1yspxZVRBSVZJb79EIiIiIqJ+SWpqTdNgRVPQXAbslAXNrcHwuaG7dFjhNKyEhfjCOjVqAG7Aqk9LDwWchiiQG0BgaDZiM6th5PuhL44ge/NSGEE30nVxuHN80H38U46IiKi/4H+1+ykJX+PRKhTmjlLjBX6o+gFF/iJ8V/Ed5tTPwRPLnkCOyw/N8KIqXgW/y4/6eD3MdBQNZkJ1wzYkG5Dnz4PX7cUHSz5Aob9QHWtc3jhke7NV0SiPIyIiIiKiNeekbdgSrNoOHNuG5tGRWBqGK8eL5PIIkssakfy5CigLAXFTlrQBKQuw04Bs27C8AeHqBuhxCWbjsLL9iHy7HN4R2UDSgr5+oXoehrBERET9A/+L3U9JUFqtV8OKVSCejquRAw98+wA8mgdxO666WGUcgQceOEgjARMOHMQQU49vTDTCgoWaWA0KtHwsCy5THbI5nhw0Jhsxv2E+RuaM7O2XSURERETU76gRAR4DqcoYNI8NO2nBbIij7vOlcGUZMGsSgOkAsxsBmSYgra/J1sfQlsmVQAoaPFLNF/qh1yTgLg0iVR+HK2HCKwEuERER9XkMYPuhimgFUlYKny/+HEVZRbAsC3Pq5mBy0WQ8+sOjiCVjiCKKhJ0Amvbj+o0tFaGMnLJUoefVgLATwXvL3sPMupnYvHRzFPgKsPPonZHl5ixYIiIiIqLOzntN18ZV92tibi00mdka8iAxvxHeoAfJGRVAfVNNLrW5k1bjYGEiDR/cSCIFGw588ECDBgM27DoN+L4W8SBgTi2BrzAI11BPb79UIiIiWkMMYPsR6WqVDbKk+3Vhw0IUBgtRHi5Xm2ktiSxBNBlFRbICKaSaHtAyfJUP0LU212lA0rYBven+Mqpgds1s5A7NxesLXke+Px/FweKefZFERERERP2QnTDVSADZbEs20krXJGBpDtKLG+HAQrq8EWhMNoWv6gHS3WqqLxfcMGEiASCOOPKQgwpUwwNDlfFSxLtNL0IxH9IL6yFbdum6BsPvgivX16uvm4iIiFaPAWw/IuGrhLAy/zVtpjGzeiZqkjVY1LAItbFaLEss+y18zZClTZrWFL42bbzaRAWvetPXCjKeQEYP1MarsGHhFHyx7AtMLJqoOmEZxBIRERERdSwzj1WCWBk5EJldA8PQYEdSMGtiQF2yab7rClGkYavw1VDdrzI0LA23uq4WtchFDuoRVRMKNFgwYSGVNuFZnECqIQFnQ0APeGBG0vCUBNXmXkRERNQ3MYDtR2Q2a8pO4aMlH2FZ4zK12ZadttHYWIlysxoJ9Zl5G4YGWCagrdmvuhGNcFIOljTOQ9LaUgW7gexA178YIiIiIqIBxJENt1KW2mzLrI2pn2OVUSBpAtUJaW1VGpCEjbQaOiDRaloNIJBOCQdxJBCAgTgsRFCNLEh3q6Oq/CQakIIfHtOPvJQP6UX1SA4NwOtu2WVBREREfRE/Ju0nTNvE8shyVEYrEUlE4E3EUBYqwy+1vyCcqkbMadpcC1bTIqWmny0glVQdsDI7qvk6+cp0vjpO02X7t8dFEEFtKoL/zvkvahI1mF83Hz9U/YBYesVzEBERERFRK3Y0hXRDElYsCasxBbfXDbh1mfOFVNxEBAnUqa7XmNokNyazXVUUK9dYiKseV7nFgR8G3PAgDBM1iCCKGBJqOqwJNxxUxSJwqpOIza2HY9qIz6lBYmFDb78FRERE1AEGsP2ES3ehJFiCpeGlqInXIOgbAi1SB90xUalFfxsvoDlN814lb5XRAx4PEEnAksA1E77K9aZ84r5CJoyVsQTqM3YH1akaJM0kFjQsQI4vB1OKpiDgZicsEREREVF7jJAXukeXTRaQjiaRlro7kZZZA3CrrlYbFsKqVE8irUaHSawaUZtuyYgBU226FUcKi1CHatSr/9HhUsGrtFQ0IIzlqIVtJ7EoUQFNdyFVHYO7LAu+kTm9/RYQERFRBziCoB+paVgEj+FBZXgJPEY1Pqj+FpblIGRpqHe1mOuaMoF0CtCNpsA15AcSCcC0AK+36WCG0dT9Kpo7YrUVAa0Or66rjb6G1g5FjicHhmFgfO54GHJMIiIiIiJaSXJxWHW9pqoT0NwpoLxpBVkCDgwkVMCaUN2u6RXjBzSkkEQSgA8GokjBp+JaDVkIqGEFsimXC7qaBSsdsgF4Va9F0PSiYeYS2IkieEuz4ERMeMtCvf0WEBERUTvYAdtPVDQsRrp+Ib5c/iVKXFlYlo6gzFeAHN392z5a8oNpNwWxPn9TyOr3NnXDSiesR5ZBuVTIqknQmkyuGD9gN3XFOnbTYzQNjXYcebofo3JHoSHVgHA8DHtFh6xsBEZERERERGjeeCtRHkaqPo7okgboIQ8c2Ych20C9J4plqIYOLxqRVGGsjB6QWbDS5SqXJXSVVWgSscqoAQlca9GoRoOFVTwrnTNyH9mzQa6TgQU2fD4vArlZSC7/bUWcY9lw0jJXloiIiPoKBrD9hEszUO3yotgIoipWg0Q8jLn1c7DQLkfStGFIkJo24U+l1P01Kc9UU6sGdzIOxBNAOg00ptT4AW+y6X4qgJXQNdMFq8LYpn8ZVXYYby14C42xRiyPLoe+IunN8mT15ltBRERERNSnaF4DTtKCNz8ALWbBTltIhqOIL0uhLhWBjRQqUaU22Wqa/5pS33VoiKlANYUw0liGBsxGFRoRUxNhJajNR0CFtTHE4YMXHrjU5rvqCGGg/pdlcOqT0GTerJyLoUNzc9UaERFRX8IAtp+oj1WhyOXHUF8eHM1GvRmGyzZhOEDAsWDF08i2ZIlSUyesu7EBfhk70NCgljZJOItUGtCbgteEhKwe729jCOQ+mR8tB17bVnOoKiOVqE5VI5qOIm6u2LqViIiIiIia2XETMB1Y2QbSbhsIpxCPJdCIRgThQVzNeNXggY75KIcNB3WIwK3+HDPUGALpi5Umilz4EFV9sBYakUD1ikvSCStdrzIz1gsvsqDDTqbgjQJxO4Z0XQJ2ssU+D0RERNRnMIDtJ3xGCCF/Eapi1XDiYQzVPSjyl8LQgJjmQpYB+KJhZEknq5lGynAhLh2vALypZNMoAhkzIB2utgOX3BRONIWy6joZRbBiHIFjq4VOsjXApKJJ8MCD0lApKmIV6ngcQUBERERE9Bsps42QB1rcggsuxOw4NJcLZm7TXFc/dBWyViIKN1yIIg4NOqpU92tM/SxjBSRY9alpsNIZK/NjTRXaSjAbggflaFC77crU2AhkzICNaAEQzM2BFTObTmTFSAQiIiLqOxjA9gMJMwGfZmNZ3WxoXj/GBoag2kygMJmGLwHoasyAhRrDjZSZApIJQGZOaU0bbqWlyzUWA1wGQhLQOg4cRzbpkp27nKZZsBK8Gi7AJV+G6qKV/zFTJjYt3RSL6hehPFyOmngNRxAQEREREbVgmzYc20G6KgatwA3NAzS6YyoIlYECS1GPBahSQwVk/MCKR6mfZf6rjByoVQMKUqhDvVqdJh2zCbUmzYIBl+qY9cBQ4wrccMMj82CNBAKBIDSXDrMhATOSVM+p+7jXMhERUV/CALYf0NIueLNLsMhJwgrXYaw3hLJYBNWJZQjGk0jHk/DapkwOgCG/Us2NkAO47ASk9HLLJ+Eut5oBG5YdU9MpWBK0mpGmDbnkNtNEIBoBkmkEkk1D+6fmbATNBVTWzIGmaSgOFsPn8sFpHltARERERES621AhqMvtQnxZI9yeALwxA07CVuMDQvChADmoh8yDtVVXbCPSKEGO2nyrqcNVYlUdbngRRgJpWPBLNy0SqFJbciUhQ8Ky4FGzYOV+BcXZMGUcWUMaRsjdvBEXERER9S0MYPsBrxaDFqvDLsWbY7yRh0BWMWJuH4I2UKLZGGnqSEBDELLkyUa2k4ZP5kc5DmTxUVI22TJlyH/TLzwqna8ynsBx1CfnXgloPR7EdLfqfI15DbX06eeGXxH0ZCHp8WL6qOnI9+cj6A6qMJaIiIiIiH6jauR8NwKluXC8Fmq8UcSQhA8eRFdsoiUJqQVL1eQuaGhAI7LgQ6O6h6W6YCtQBxd0NRO2UW3OZSIAP7LgVaMK5BgyqkDmyMbDNtwuLwy/Bv+IXLiCXna/EhER9UEMYPuBmOGCz5+PaKQBfieIurqF2BQu5OePQ5ajw9RsFEJHtgMVuhY4Duo1DQ26Dtn/NM9smgFly5d0r9pyWQZVudU/Ab+MJ0hbcHkMlCXkXnKrhgPGHoCklcS4vHEIuUNI22nOfyUiIiIiaofMgJVRAVYshfJkGAXZ+dBzPaqulo24pGdVBgrUIgYTDvwwVFdrJcKq7xWwVCesjCRIIq26XW2k1WNlCy8JaCNq9qts7hWD5dZRuFGZem7vqHwVvsomXPaK1WxERETUdzCA7QcC7gCMRD2CwQByvW5MXH8/jPTkY+vqpVjfchBAGsXpNEotB4WmlG6A5gCFjgPNcZC14hcdcBzkNx/VUXcyNQ11mg44BkxTQ4PfheHIw8TgSEStKLYbvh1yfDloSDYg25vN+a9ERERERG1I16kdk81tHXhGZGPY6KEI2xHZ1RYBuJGChRRMBOHFEGSrUDYFG14EVGesBK8ODPW/5Z4y9VVud+BSYWs9YpDWCpn8WooiePL9yCnNgWUDgVG56hyscAKukBe6V1owiIiIqC9hANtfhEoRiCVROm4L5FYuRXVDDRJFY6EZPhTaGibFo9A0By5NR5WmYajjqEVORY6DRgA++WVrGkrV+ABDBbOj0xbcjg24vCiwHWRrOspc2ShHI3Kzh2JY9jCMyB6BSQWTkOPNgd/l7+13gYiIiIioT9L9LhhZbmQVhmDbNvKi2QhmBVCrJ9XM1ywE1LRXPzxqNEEaptqvwQ8fYqrjFWoTLhk2IPFsAYJqYIHIRY7qiPXAjZgehx2zoee4kRXwwjciB56SIPSgDBcjIiKivogBbD/hxBtg+/PVZ9+pqhnI9+gIRBsxwgI2tNzIMXyYHrUxOpnAREeWNAFDHdXninxV6AHDHAdLAWQ7plSIaNCl4HNgaB64fC6EvCH5kB67hyajNl6FHE8Ocv25iFtx5PpyOX6AiIiIiKgDVtyEO8+PdCwJozyFtCuFRlcCxU4QBUY20pB9GlxqBqwbBrJUhW6jARHokD0dpH3CVtGs1PAS2jYgre6rVrjBQHEoDz6XH4GROQhHwkiXeYCkrVa/GQE37ETT6DEiIiLqWxjA9hPhdBppuxFZmg6zcDMMsYCCSBIl0UaMTKeRazZNiaoyPChKAVMSaeQ5GoZKAGvZyJERBLaDPAfIk7mwdhwF8MAJ5mCI4cAxDHjdeRiaux5m2o3YOH8DFb7menNRGChELB3j+AEiIiIiolVIVcfhzc1COgTkaAFEI2GE9Tgsy0KO6myVGNVAHkLqD7EIYvDChVz4UYhsdZ8c+GBDhwkLhQjCDRfcEtF6ZLtdDfljCpEIh1EwuhielAbf8JDa3sGxbG7ARURE1Efxv9D9RJY/C1aiEUjFUJyYg8qsUhQ7fkS1GEY1LMMC3cBIOwUjGUW9x49qB/DaDkpMG0s9GraIpFHh12E5NpKagRzZnisQUBt2GZ4QcjUPvK4ANtN8CA/dEVPLpmJs3li18ZZlW/Aa3t5+C4iIiIiI+iwnZcOd64UZSSGEACoDEYzRRmIuFiK/IYCU+h8LDtKII6maJ3KQgzCialMuBzaiaoMuX9NGuggh5XYQdAJIu0xoIRdSPsDt82BC6SQEJhYh7bGQTCbh9Xtl3lhvvwVERETUAXbA9hO6NwB3XiksmREwZANkBQIwrBjykwl40hbWt+MwkIbhuFGUNLFDOolRsShsK43ihI18x4QvkcbQtI0C+DBSDyDXnY3NHC+m6VnwaTa29+TByRuNYXnDUCozZ90B5Pvz4XP5YOgc5k9ERERE1BF3kV9twuXK8kALueH2GPC6NAxJZsNU/awWdGhwwUAQPhXBNiCqxg/I2IEaRKDBg0YkoRtu1LqTKPTlocCXg6AniBK9EKOySuBkeZAa7obH54ZHc8OfE1TdsZra64GIiIj6InbA9is2DPmNjdwSDb98gKxANtzLw7ARQ518gq5pcDkyuB9YrGnw6jq2sEz8YBiIOhpGmIDPSqPCcBB0GZiS0pFTugMak9XIc+nQ0zEMNxNw0mkU+wpQm2qAV/fCY3hg2iZCnpCaA8tRBERERERErUkAKiMArEgK/qE5cBYuRyJoI5FIqoA1IcGq2p/Bj0ak4JYRYfAjBRtpWAjCDwsmgvBAd2kY6iqCpulwD89CmVEALWaiQcaCBaTad5B2OfAaHsSqGuHJC8BxHLjdTXNgOYqAiIiob2EHbH/iDQG5Q1H36wfIGb4+oikdjVYYsuWWS9OQ7Thq1quM3k9JAAvA5wDTzCTSbkPNj0oGh6BYd8Nvmgj4izCvbjZcmoFiVzaKR+0Ib9EGyM8fi5rwUiTNpJonVR4rR0OiQZ0Cw1ciIiIiovZJ8Kl5DKTrEnAXhhCrjsIPrwpXA/CozbTCSEB2b3DBBT/8anMuLwy4oMOreZHtDqHQyUHYiiEnPxtaowXHsWGGdJSOK0V2SQ5CrgCctIVEOAaXy41IRT309G/nQERERH0LA9j+xkohr7AUiEWRX/8LCqEjC2FEHAd6ChgGQGqvKbaNTSwLAU1DCMDWqSR2QAKbhOsw3jSRlpjW5cWGMPBFbDka88pQGshHfjqN0ZqBZKIehmYgnArDMR01joCIiIiIiFbNSdswQi5olgN/1AMbQBwxeFTIqqERCdXxKvW49MZKk4Tc5oEOv+NCYToE3dKQl5UNXRYspm0V6JaNHAqXx4dQxAs95EGiOoKEmVZjDwyvW5piiYiIqI9iANvvOMCwzREYtwOC+SOgpZMwHCDH0hDQgaqUhmG2DCuQiQUagg7QqGkodhzEnCCGI45s08a2Whby/EE18P+w4qnIbahEypeNhNuNxmQDhuWMxMickRibOxZBbxCV0UqEk+HefvFERERERH2aEXQja3wRAoEAsnK8kPVjQQTV5luy0VYushCCV32XEQRZ8EPL/FmmGWh0x+DRXch1ZcEIuOF4gZIxZahfUotQcS6iqQQMU0N2cR7yigvgCnrgzvIiVRnt7ZdOREREHWAA29/4coBUHFj0KdKBPBjuYoQTQLbhwHYBRW5HjR3IcoChcDDccbCR46Bac6HUimCJr1DNim3U3VhW/i2qfAFEdGD8yO3QmA7D8echqXthGW7MqpmFhY0LkeXOQq4vt/kUZA4sERERERGtTEYAmJEU7KQt87tUY6pMbZUtuAxoah6spYYQWKhHI/IRhA0HDgwYjgGf4UfSa8OuT8FZFgd8biTNNNabvD6saBIB3Q2X3424mUC4sqFp9qtjwJ3nU/NfReY7ERER9Q0cENTf2BZQOQPIGw5r+TdIGgkEvUA0DQRk5VEC8DtANKjBZTtIaoBpAYWGiWojFzG3jnAkgXy/B3m+QniNIjiOG3asBpuN2B4ROwUYksz7sEHhBqhN1CKajiLkDSFhJhi+EhERERGtgoSfZnUcWtCAS9NRiyQ0pNSGui64YaMRyxCTXlm1um0ZatUYgjBiKEMuyu0GpE0guyQXBYlcLM2Kwp8dRGV1FUo2HAlXwkEiEkOwJBe624AVbtq3wfJrsCJJuD3ssSEiIupr+F/n/kY3gMLxgOGGT/PA682DXwcCGgCpveQ36gMKbQe2DXgcIF8Dih0gF/WYGK5BkSuAEsQQdfmwJL8MSw0Di3QdP9fORsAfgunPQ8qwkbJSGBIYgqAnCMuW4f+y06ps7QXUJ+tVIEtERERERK07YI0cD7xBL0wPEPR64YYPluqFdRBDGsNQgkI1fMCDHARQiwgC8GIWlsFlGShEDsykBafYh1I7G5F4FAGXH9VVVYBHhz8vhFQ0Cc3QYGR71agCy7KQdFvQNPnDADAbkr39VhAREdEKDGD7Idkn1QkNBXy5cA8Zp2bAYkUACzfUCAL5UF0zAM0GZPWT3C7ffDDQ6ERhWSbSNXOx/vIfUWoD60Xq4PX4Ea+rQnjpzypgDVhNS5dUB6wnBEM34NKbmqZzPDnNYSwREREREbUOYVMewOcPIpEjf3RpqEQjTNjQYCCCRrjUQAIHFoB8BNQYgiKEkDDS0E0TemMK1eVVqIk2YEh+IRL1ERXWxpY1Il4XgR1rqtU1XUM8moDf74ff8CKdTsNxSzDrUQ0URERE1PsYwPZDbqSg+YKAPwRbkxIOyNKBhB8IOIBlADmBpvDVMJq6Yy1bQ8iWz9xTyDNNxMwYcvy58GWVqU22sks2RGOyDpZuIFg4THXO1sNWna8BVwCVsUokraT6nvlUXY5BREREREStSQgaGip7KFjI1rMQRwJFyFXNEPIHmBd+pGCqnxsRQXjFBl0ueICUg6Djg2YYCMKHkSNGwIynkDO0AIalwwi5YXk1eLK8iIeb6nG3ZiAajarA1Yyn1fOr7gtTbc1LREREvYwBbH/kywa8IWD93ZDOHQNTy4NlAaVuwNCbGmFl7n6e3jQyNqwDPt2BowM5ahMAE6M1H/J0H+J1i5AfrkXacTDKdDC/6gukHRtDVvzTkLC1Lt6Iykgj8n35anuAJeEl+Kr8KwTdQXUffrJORERERPQbX3YAXp8XyeFuhPL8cMOj+l2lA7YIeUgioQJXmf0qS9XkVhlB4IEGuXe1FkFICyCZZyK5sA6OacPULETqGhFbUA/drcM0LHjdHiQSCVhuB6naGHSPC+lIAlY8jciyemhuadVgvU5ERNTbGMD2R7E6IB0HYvXwjtoE7oJhcLk8iFtAMg1400DSBOrMpjEEWRoQWvHQejXCwKXmt+aloihw+dFgRhF0+xDPH4GyoZurTbwaPEH4XD4sqPgJAXcWJucUozJaiUJfIdy6G+vlr4dwKtx0OuyEJSIiIiJqZtYn4NgOvJoH8RFuaEGXmgCbUrGrBQ0upGGhElH44Iah1qlZqEVCzYrNMX2ImXHYSQtmjhvelAG334esnCwE1s+H7dhw0rYadVC5tAJux0B2fq7qfA3mhmDrDjw5Ppimqc6DnbBERES9iwFsfxTIA0LFMMumwgoWwhqzF1w5I2W+ANw2EHABmg8IpgCfBVnIpOhp6X4FZBFU2vCixjZhhnKQnzcG0WQjvKYGd0MFsgvHozirGD4zhTElU1CgAxE4KHT5UV69ALnefMTNODyGB7XxWtUJG0lFevlNISIiIiLqG1y5PrUxVvH4MpQVlyGwXiF8WVlqFmxMDR9Iw4SDAgQQgA8lyFOXhyCELOmHNdxoRByGqcGbE4Dl0VTgCl2DHnGQW5SPQEEIdsLE8DEjoLl0pMw0PLoL9TV18Lm8gFdHKpJUM2JlmZydkmmzRERE1BsYwPZjLlgwxu4AM2cIMHpb+IduhlqfdKRqyNEAT6DpfjKSwEwBhltTQ/5loZMr3oAhaRvpaDUWJiOINCxEmZNCcfEEeCPV6nFpjx+J2rmImjE4mo4Z5TMQS1WiLlKvljHNrp2NukQdKqIVyPJk9e6bQURERETUxxguF7LGFCBckIa2gR8+XxABeJAFnxo4IJtuSRQr3a858KEBDZCttWTvhZx0AF7ThZrlVUjZJoyIBcPvhjvHp0YMiFQiBStpwoqkEAmHUVNTA03X4URMpMpjcKWAZHUUqWgCuqdpHAERERH1PAaw/VUyrGbB2rYNffQ0YNI+QP4YlARGIi2ffKcB01EfksNrAZobCDoOJCbVoCMBHZ5YNfzROEI5xRhTNAHlZhT13hDi8Tq1XCkaroQvq1RdDplJbDpme3hCZRhbNApBVxC5rlzV/TokMAThZBixNEcREBEREREJmc0qIwLExA0moGzcKGhlHlT6ZEsumf9qqOA1igQqUK9GFPgRRL6KaF2IuhIor69CQSgX/hy/Glkg3aymYyKRSqruV0dzANtBYzqGwqJCFJUMgS/oh6c4qB5jehwYLgNunwdWNNXbbwkREdGgxQC2v5JNuOQXaBhqBiwMN5BdBpROQrB4MtyahkyJJR2wMvpJJj/FLPmlyw6rDTAMvxrYX1oxS+3WpdkWcjx50LNGweVyIejxq+PqvhxEbBO10Wrkp+JAohENqQbMqp2FeKoRS+vmojJeCa/hZQhLRERERCQbcfl86ruEqcXDSpFOJuHK82DcpPEwgm7UIII6xJCPLLihw4EGGzYiSCKKOLwxl9rIqyZWD6sqAW92APF0EnZAhz8rAMetwev1wtRteD0eFchGq8PwB3zq54aGRqA6jcaaeqRr4mpcmeAoAiIiop7HAHYgSIaRLNkMGLMtUqN3Q8pxwzVsWtNMWB3wG03dsG4NCKxYeRSCC+FkI8yEjepUAsnsUrhjjaiom9N0h3g9bDmAlUIgFkfA9sM0YzByh6E6XIPhnhxMHToVfk82orBQ5spCeeNCFcISEREREVET6YKtqqrCuKkTMHrCerAkMM3xIzc3F1kIQIOBIciXaBRhNSE2DRsaHIlkow6MOgfw6/AW+BEurwNSNuykiVh9RB3bsiykUin1s8vSAceBnUgjWJwNJ9+FnLICpB0L0XAE6VhKzYslIiKintW0Job6t5yh8KaiwPid4BlWCz1SDu3X/yI5Zj8kF3wAB3Xw6apWk3oMXhXCehEM5gGpGuixbJgz/wfPsE0Q0A0YhgloOry+XETidXAbBuysILJsN3RLh9/nQ1jT4E+bsGMxmOkGLLQdGI6FxbWzMDx/PRg6Z0wREREREYmioiI1kmDkhmORNFMwA3mom1uJWn8U/gogYkfhhVuFrqUoUtt0FQTzoCUdBPJCwII4ooUNyBmSC7/Hh1TaRKggp+ngUQvekF89xje0aWOupGPCrXthORqSlVGkNBOa5iBW3YhgdpbaJIyIiIh6DgPYgcITbPqeSiBdPBX+oROBisXQckrgXfA2kA6rma+AWyZSSaUG2xiKhOOCO1mDZMkEZNsm0LhUjTdIx8PQLRNZwXwgFQPSMbjgwHJswJ2HoNcHODbcWXmobmzA0OxhWNCwAC7Dg7kNc+EzfPAYHpQES3r7nSEiIiIi6jMjCTSPjuwNSjBk9FAsmrcIVYEK5FS6YNom/NEU/FoWkk6tlOvwF3mgLYoBxSG4/G6kXTaidWEYIQ+qq6uRlZUFf24QjmkjbVtqvIDsESGbdXk8HriCOuJ2DL6kC1aOAbM+qTpwGxdVIic/T4XBgdwVf0cQERFRt2EAO9DkDYffcCNlB+AN/QItuQHCyShCQ0YBs99GePlseLRsILsQ3uwh8BsBmGYU6cVfIzl6F3g9XsA24fIGoJkJoOIXYMgGau4rHAtJOw3bbSCRAHS3X818Xb9kqnrqiYUTsTS8FCGXXxWQ8XQc4UQaIZ+EvkRERERENH7i+kjXxRFPJlA0thi5oSykSlJwWxoSC2vgKtcR8A5BsMgPmSlm+xzYQTfqF9TAPyYbjleHxzGQ7cmCbhlIN8ThLgxAi5nQvBrMhAm3y606bj26G/5QAHpR0599lu6DCQs+vweOZcGKxQEGsERERN2OAewAk4qb8GSXQA+HYYzYDHUz3kXWNmfBcaLQ0lGE8oYj5S2CUb8Y0G2kHRd82x4D7/q7I1m1CMjOg520oHt1JCKN8PlygGgNoGlAeDkCOcMATQLYMFzeAuRAR8JMwEybCHj9cKW05k/3U6YO3UghadrwujgbloiIiIhIRgRIh2oo1wdPwIuIqwHeEV7IFLB5yRSMYTpCCCFdEYWW7VEb5RbvvQF02UrXsWF4XDAbk9C9Bux4GlZAgxFNw+V2Ibm4EZ7h2XASptqBV7ptHemKlcsS5zoOzEQa/lCWmhmrpWJIxBJqsy9N13r7rSEiIhqwGMAOMB6/C8lYDOmaGmSFQsiZtDOklEovmQF9+A6o8yxAbskY6OH5wIitgHQa8HoQrp2DkFRpugEtKwBEq+DLLQZiNUBWIdBYDmSXwa6ZBz1UAl9OWdMT+rJhhpchK1SmumENlwepdAr5wXy4DTdMS+bJApFUBFmerN5+e4iIiIiIepUEn/FwDK6YDl9+AN5AU/NCYmkYhaOHqI20nEI3gssC8G9eBKs6CSduwYIJ07BhuA0YEsw6gOZzw2VogK7BNi1oWR4V3LryfPD5V4w8kOdriMKXHYCua3BHf9uEKxDKbv5ZQlo5NyIiIup63AJzAPIGAnAPGaJ+TtXWwElG4CkeCbNoHLI33gtutwWnZDPYmg5f6QZIpWyECsYD2aVqlmyqsRrIKkbCtJuuE1lFahasVTQRyGo6NsIVTTe5s9TPAXcAQ3KHwOP2NH/C7nF5YMOGz8VB/0REREREwuv1wpXjhWM5SFdFobl0eEuCCA7LQ/5U2WBXhzPaDyMJ+PL8sj8uXCEvAvkhFZLa0XRTB6uhNX136XAFpO624Clp6m51bAdWONX8fPKz7jHgKW4aOeCkbWheQz1WumQZvhIREXUf/ld2gJHuVwlg5UvoviB0vx/JaAqerEJoPh+SmgdGIAgzEYFH14GsgqYH+7JVoWYYeYCuN48SaDqQASdYCpcsTYosRzKVgtulQ49WAzIr1t30fKlUCgFX08+yREpzNPhdMr+qCTthiYiIiGgwk9msmTo7mUzCXRRQNbjtOAgWhlSLTHBkvrpd86wISO1Uc0AqnaoydkB2Wchclxkf4M2SsFZDqjzSFMI6DuzaGHTDaPV4dZvlwJHRYysC3PbOj4iIiLoGO2AHmEzwKrNgha6nkU4moekm0ol6pBNxaJ4sOLYNX3Y+rHQa7mAuovPmobahUhVsrux25rUmGqC5DWiGLhUevEWjoftzAcMDBIcAgaYiUXZb1SXUlSVN7gDSVrrVYSSMlVEFRERERESDUSbclKBTOlOduKkCWE3T1ExXO26psQESvkrHqmPa0Nw6UhVRxOqjKjBtG5DaKUsdIxOy6n43XLk+1SHryvFBD7rVzFi0DG1XdM9m5sNmaLbdQ+8EERHR4MEO2AE+C1Z+xZpjw+MPAPK1gm03haRurw9mOg2tsBD52b/NgFqJbMa1QsqbD08y3HSdI8OnOh7Y7zf8qitWgllh6AZgelAfSyE30HQdEREREdFgIyGqhJ/S5ADLgeF1AfK1ggSqQkJY23bgyvXC0+L2luQ+LTloeqwR8qpgt7MNHclYVKLY5uYOIiIiWjfsgB2gknGzeRSBx/fbCAAJTJN1ldAlCF0hhTS8WcHmEQGrY7ikOAyteHAEMFNAOtHqPvKJvrqvYTSHrxkBj6tV+BpNS4FHRERERDR4ZEYBqK8V3aki3hBTowMyYwUy9BXha9uO1fa4sppWtMls144ek7muvdmv3kCwOXy1LQtmqmmWLBEREa0dBrADlNffVEhZZusRAKmEBfiykIw2Ba3SJaslLNhmUwG2JvNZJVT97YlCgMsDOWxLbZdFZQLZ9mRmxhIRERERDRaZ4NNcUYcLO2nCl+1XIWzzdQkTdvK3YntNNsuS8QItQ1v1mERju8/f8nnaPU/DgOGWibNERES0thjADnCydEk+QW85msArowhkK9UVS4x0Q4fhWreianWD+ld1e2eXRRERERERDRQta3UJTKU2DuQGmwNRtRGXz2h1v7XiW8W4sdUEu6zXiYiI1g0D2AHO5fGojbea5sE2ScVjiNQ1tlpihHT3D9tfVRcsEREREdFgZK/Y9CoTuMrlZDyBeDiuLssoApkPmxkn0K3nsgbjDYiIiKjzGMAO0PmvLckGXGqY/orrDbhRMLSk+fZ0MtG8PKkrWJa1Vl2yRERERESDQcug0+v1Nnegqrmwug4XDASLQr/dP2V1ab3uWO03X6zJeAMiIiLqPAawA3j+a1uOtiKAdZny0Xrz9ZnxA027nXbdp/hERERERNT5oFMz9HYvd1mHqr2O4wyIiIioUxjADiLNHaiGR31L1i5rHqyfGUXQFWMC3BzST0RERES01sGs5tJVl2qsPtp6U60VXbLrSnO32FSXiIiIuh0D2MFIN2TdEbw5Q1a6qdWYgGSkVadsd+J8WCIiIiIiNM99lS5V2YxrVd2zPTmzlfNhiYiI1h4D2MHKcMNG0yfpjm0j3V4A6s0C9J75J8L5sERERERErbtUHctZZfjZkzNbOR+WiIho7TGAHcQsM62+a7oO94oAlJ9sExERERH1DZnNsnqr65WIiIi6BgPYQSIZX7lQc3tX7jrlJ9tERERERD2vvWBV96w8q5X1OhERUf/DAHaQ8PpZqBERERER9VUMVomIiAYuBrCDVDLWtKMqERERERH1PRw1QERENHAwgB2kvIGVd1QlIiIiIqK+gR2xREREAwcDWCIiIiIiIiIiIqJuwgCWiIiIiIiIiIiIqJswgCUiIiIiIiIiIiLqJgxgiYiIiIiIiIiIiLoJA9hBIBnnDqpERERERH2RYzuwk1ZvnwYRERF1I26tOQh4/fw1ExERERH1RZquQfMavX0aRERE1I3YAUtERERERERERETUTRjAEhEREREREREREXUTBrCDgGWm4ThOb58GERERERG1wzHt3j4FIiIi6kYMYAcJTdN6+xSIiIiIiIiIiIgGHQawg4Dhcvf2KRARERERUQc0F/8sIyIiGsj4X3oiIiIiIiIiIiKibsIAloiIiIiIiIiIiKibMIAlIiIiIiIiIiIi6iYMYImIiIiIiIiIiIi6CQNYIiIiIiIiIiIiom7CAJaIiIiIiIiIiIiomzCAJSIiIiIiIiIiIuomDGCJiIiIiIiIiIiIugkDWCIiIiIiIiIiIqJuwgCWiIiIiIiIiIiIqJswgCUiIiIiIiIiIiLqJgxgiYiIiIiIiIiIiLoJA1giIiIi6tD06dNxzjnndHj7VVddhY033rjD2x999FHk5uZ2eP9jjz0W+++/P/oiTdPw4osvqp8XLFigLn/33Xe9fVpERERE1M8wgCUiIiLqJ9qGmf3BIYccglmzZvX2aRARERERrZG//e1vGDVqFHw+H7bcckt88cUXWFcMYImIiGhQsmwHn86twUvfLVXf5fJgkk6ne+R5/H4/hgwZ0m3HdxwHpml22/GJiIiIaPDU688++yzOO+88XHnllfjmm2+w0UYbYffdd0dlZeU6HZcBLBEREQ06r/+0HNve/A4Oe+gznP3Md+q7XJbru3Mp/1lnnYULL7wQ+fn5KCkpUcvxW7rjjjswefJkBINBDB8+HKeffjoikYi67b333sNxxx2HhoYGtRRevjKPb7lUPkM6ZaVjtuXyeSkod9hhB/Vp/pNPPomamhocdthhGDp0KAKBgHrup59+ep1e59y5czFmzBiceeaZKhztbNeubdu48cYbMXr0aBXeStH7/PPPN98u74O8ltdeew2bbropvF4vPvroo3aPtWTJEvX65P2W93SzzTbD559/3nz7Sy+9hE022US9H3LOV199NcNcIiIiokFar2fq8ZNOOknV3RMnTsT999+v6uSHH34Y64IBLBEREQ0qUrSd9n/fYHlDotX15Q0JdX13FnWPPfaYCgIlBLzllltwzTXX4H//+1/z7bqu4y9/+QtmzJih7vvOO++owFZMmzYNd911F7Kzs7F8+XL1df7553fq+S+++GKcffbZ+OWXX9Qn+YlEQoWYr776Kn766SecfPLJOOqoo9Z6mdUPP/yAbbfdFocffjj++te/qqC0syR8ffzxx1WxK+/DueeeiyOPPBLvv//+Sq/lpptuUq9lypQpKx1HgmsJm5cuXYqXX34Z33//vXovJeAVH374IY4++mj1fvz888944IEHVFh8/fXXr9VrJyIiIqL+Xa+nUil8/fXX2GWXXVrV53L5008/Xadju7rg/IiIiIj6BVm2dPV/fkZ7i5fkOokL5fZdJ5bA0DsfHq6OBIWynEmMHz9ehZRvv/02dt11V3Vdy82uZO7Uddddh1NPPRX33nsvPB4PcnJyVKgp3bNrQ45/4IEHtrquZYj7xz/+EW+88Qaee+45bLHFFp069ieffIK9994bf/7zn/GnP/1prc4vmUzihhtuwFtvvYWtt95aXSedqdLhKgGpBKoZEl5n3rf2PPXUU6iqqsKXX36pOmDFuHHjmm+XblcJcY855pjm57n22mtVSJv5HRERERHR4KnXq6urYVkWiouLW10vl2fOnLlOx2YAS0RERIPGF/NrV/okvW1RJ7fL/bYeW9Dlz9+2U7O0tLTVPCkJHqUDVAq8xsZGtRxeulRjsZha+rSuZAl+S1JgSuApgat0isqn/hKCdva5Fi1apMJQ6R5tGSJ31pw5c9RrbRusynlNnTp1la+lre+++049JhO+tiUdsR9//HGrjld5P7ry/SYiIiKizunter27MIAlIiKiQaMynOjS+3WW2+1udVm6WTNL4mVOq3SQnnbaaSoUlOBQOj9POOEEFUCuKhCU48i81dVtsiXjD1q69dZbcffdd6vRBpnZsxKgyvN1RlFREcrKytT82OOPP16NSVgbmXm3MhJB5tK2JLNeV/Va2pL5sat7LumCbdsRLGQmLBERERENrnq9sLAQhmGgoqKi1fVyeW1XoGVwBiwRERENGkNCvi69X1eSeVMSxt5+++3YaqutsN5662HZsmWt7iNjCKRLs70AVGbCZsyePVt1ca6OdIDut99+asaqbHYly/BnzZrV6XOXsPOVV15RwaXMlg2Hw1gbstGBBK3SUSvjAlp+yaZkne02li7Y2tradm+Xzbd+/fXXlZ5HvmTWFxERERENrnrd4/Go/RFkRFiG1OdyOTMea22xuiQiIqJBY4vR+SjN8anZUe2R6+V2uV9Pk+BPulbvuecezJs3D0888YTaiKolmQsrnZtSBMqMqkzIutNOO6l5st9++y2++uorNTe2bbdte2QOrWwCJvNbZTOrU045ZaVP/NeUdKRK56rL5cKee+7Z3M3aGaFQSM2klY23ZBOyuXPn4ptvvlHviVzujMMOO0x1Kuy///4qaJb39IUXXmjeQOGKK65Qm31JF6xs9iWv/5lnnsFll13W6fMmIiIiooFRr5933nl46KGHVO0p9aGsTotGozjuuOPW6bgMYImIiGjQkEH9V+4zUf3ctqjLXJbbu2MDrtWRDtQ77rgDN998MzbccEM8+eSTah5sS9OmTVPh6iGHHKK6Xm+55RZ1vXTNSofodttth8MPP1yFmGsyw1TCRukEla7V6dOnNweWaysrKwuvvfaaGofwu9/9ThWrnSUbYV1++eXqtU+YMAF77LGHCnZHjx7d6Q6GN998E0OGDMFee+2lRizcdNNNalmZkNcsXbtyn80331x1Hd95550YOXJkp8+ZiIiIiAZGvX7IIYfgtttuUx/Wb7zxxmpF1euvv77SxlydpTltB4b1ANlUQnbxbWhoWOsZYURERDRwdXet8PpPy9XuqS0H/Msn6VLM7bFhaZc/H1F/wlqdiIiIVof1eudwEy4iIiIadKRo23Viido9VQb4ywwpWcbUG52vREREREQ0sOt1BrBEREQ0KEnxtvXYgt4+DSIiIiIiGuD1OmfAEhEREREREREREXUTBrBERERERERERERE3YQBLBEREREREREREVE3YQBLRERERERERERE1E0YwBIRERERERERERF1EwawRERERERERERERN2EASwRERERERERERFRN2EAS0REREQDznvvvQdN01BfX68uP/roo8jNze3t0yIiIiKiQYgBLBERERF1exCa+fL7/Zg0aRIefPDB3j41IiIiIqJWPvjgA+yzzz4oKytTteuLL76IruDqkqMQERER9Te2BSz8BIhUAFnFwMhpgG709ln1WalUCh6PZ60f/+uvvyI7OxvxeBz/+c9/cNppp2Hs2LHYeeedu/Q8iYiIiGiAsHu+Xo9Go9hoo41w/PHH48ADD+yy47IDloiIiAafn18G7toQeGxv4IUTmr7LZbm+m0yfPh1//OMfcc455yAvLw/FxcV46KGHVJF33HHHIRQKYdy4cXjttddaPe6nn37CnnvuiaysLPWYo446CtXV1et83Pfffx9bbLEFvF4vSktLcfHFF8M0zVbHPfPMM9VxCwsLsfvuu6tCdO+99251nHQ6jSFDhuAf//jHKl+/3KekpASjR4/GWWedpb5/8803q3zMxx9/rM4jEAio1ybnUFdXp26zbRs33nijOo501Uqh/Pzzz6/Bb4KIiIiI+ryfe75eF1J3X3fddTjggAO69LgMYImIiGhwkaLtuaOBxmWtr29c3nR9NxZ1jz32mAozv/jiCxWaShfoQQcdhGnTpqkwcrfddlMBaywWU/eX+aU77bQTpk6diq+++gqvv/46KioqcPDBB6/TcZcuXYq99toLm2++Ob7//nvcd999KkCVYrPtcaXrVYLQ+++/HyeeeKI6h+XLlzff55VXXlHHPeSQQ9boPXAcRx1j0aJF2HLLLTu833fffae6YydOnIhPP/0UH330kVoOZlmWul3C18cff1yd14wZM3DuuefiyCOPVMEyEREREfVjP/devd5dNEeq4B7W2NiInJwcNDQ0qKVoRERERD1SK8gyJvnkvG0x10wDssuAc37s8uVN0skp4eGHH36oLsvP8hplaZMEiaK8vFx1o0rguNVWW6lAVO7/xhtvNB9nyZIlGD58uFrSv956663Vcf/85z/jhRdewC+//KJmW4l7770XF110kXrPdV1Xx5XfQ9suVZnfeswxx+DCCy9Ul/fdd18UFBTgkUce6XAG7I477ohgMKguJ5NJ1b16zTXXqPPoyOGHH65CWgle25Jj5Ofn46233sLWW2/dfL0ExBIGP/XUU83PKx2zsvmWbMIl3byZTbmoY6zViYiIaDDW621Jnfzvf/8b+++/P9YVZ8ASERHR4CEzpDos5oQDNC5tut/o7br86adMmdL8s2EYKricPHly83UyPkBUVlaq79Kd+u6776rxA23NnTtXBbBrc1wJXiW4zISvYptttkEkElEB74gRI9R1m2666UrPKyGnbKAlAax048pog3feeWe1r10CYhmHIOGpdOrKeAMJUaVbt6MOWOnibc+cOXNU0LrrrruuNKdWuoWJiIiIqJ9a2Lv1endhAEtERESDhwzw78r7dZLb7W51WQLQltdlAlHpEFWnEYmoZfc333zzSseSjta1Pe6aynSttnT00UerebHSTfvJJ5+oGazbbbf64lfuJ52omS7azz//HNdff32HAazMde2IvC/i1VdfxdChQ1vdJjNtiYiIiKifivRuvd5dGMASERHR4CG7p3bl/brZJptsokYFjBo1Ci5X15VtEyZMUMeVSVSZcFbmvEqH6rBhw1b5WOmulWVYMnJAQljZ6GttSKduPB7v8Hbp6n377bdx9dVXr3SbzIWVoFVGFOywww5r9fxERERE1Adl9a96fU1xEy4iIiIaPEZOa5oZJbOjOpwpNbTpfn3AGWecgdraWhx22GH48ssv1dgBmQcroWdmM6q1cfrpp2Px4sVqw66ZM2fipZdewpVXXonzzjtPzX9dHRlDIBt0ySgDmQe7JmT8gcyiXbhwIf75z3/iiSeewH777dfh/S+55BL1muVcf/jhB3WesllYdXW1CorPP/98tfGWnIe8LzKr9p577lGXiYiIiKifGtm79bqstJJRWPIl5s+fr36WD/7XBTtgiYiIaPCQQf173Ny0e6oq6lruRbqiyNvjpm4f6L+mysrKVGeqbI612267qfmpI0eOxB577LFGQWlHZNn+f//7X1xwwQXYaKON1CzWE044AZdddtkaPX6XXXZRIxBklICc45pYf/311Xfp5JVNxE455RRcddVVHd5f5tu++eabuPTSS7HFFluokQRbbrmlCqPFtddei6KiItx4442YN2+eGm8gHcNyfyIiIiLqp/Terde/+uortZFrhjQoCGk6kE1d15bmyNqzHsadVYmIiKhXa4WfXwZev6j1gH/5JF2KuYn7dv3zDTDSGSAhrowhOPDAA3v7dKiLsVYnIiKi1WG93jnsgCUiIqLBR4q2DX7XtHuqDPCXGVKyjKmPdL72VbKJl4wAuP3221XH6b779r/il4iIiIj6gYkDq15nAEtERESDkxRvo7fr7bPoV2T21ejRo9VGXbIEqys3BiMiIiIiGqj1OqtmIiIiIlojo0aNQi9MryIiIiIi6tfWfvcGIiIiIiIiIiIiIlolBrBERERERERERERE3YQBLBEREREREREREVE3YQBLRERERERERERE1E0YwBIRERERERERERF1EwawRERERERERERERN2EASwRERFRP/Hoo48iNzcXA9F7770HTdNQX18/4F8rEREREQ0uDGCJiIiI+olDDjkEs2bN6pEgNPPl9/sxadIkPPjgg936vEREREREvenGG2/E5ptvjlAohCFDhmD//ffHr7/+2iXHdnXJUYiIiIj6Gcu28E3lN6iKVaEoUIRNhmwCQzfQl0kYKl89QYrN7OxsxONx/Oc//8Fpp52GsWPHYuedd+6R5yciIiKiwc3q4Xr9/fffxxlnnKFCWNM0cemll2K33XbDzz//jGAwuE7HZgcsERERDTpvLXwLu7+wO45/43hc9OFF6rtcluu7y/Tp03HWWWfhwgsvRH5+PkpKSnDVVVe1us8dd9yByZMnqwJv+PDhOP300xGJRJpvb7ksXzphpUN15syZrY5x5513qqA046effsKee+6JrKwsFBcX46ijjkJ1dfVqz1c+9ZdzHD16tDpv+f7NN9+s8jEff/yxep2BQAB5eXnYfffdUVdXp26zbVt1FchxJETeaKON8Pzzz6/hu0dEREREg8lbvVCvv/766zj22GPV6i+pVaX2XrRoEb7++ut1PjYDWCIiIhpUpGg7773zUBGraHV9ZaxSXd+dRd1jjz2mwtXPP/8ct9xyC6655hr873//a75d13X85S9/wYwZM9R933nnHRXYtme99dbDZptthieffLLV9XL58MMPVz/LPNWddtoJU6dOxVdffaWKyoqKChx88MFrfM6O46jHSfG55ZZbdni/7777TnXHTpw4EZ9++ik++ugj7LPPPrAsS90u4evjjz+O+++/X72+c889F0ceeaTqNCAiIiIi6gv1eksNDQ3quzRPrCvNkaq6hzU2NiInJ0e9EFnaRkRERNQTtYIsY5JPztsWcxkaNBQHivH671/v8uVN0hkqYeSHH37YfN0WW2yhAtKbbrqp3cdIh+ipp57a3LEqn8Kfc845zRtV3XXXXfjrX/+KOXPmNHfFrr/++vjll1+wwQYb4LrrrlPP98YbbzQfc8mSJaq7VkYMSIjb3gzYHXfcsXmZVTKZVN2rEhb/+c9/7vD1SegrIa0Er23JMaRwfeutt7D11ls3X3/iiSciFovhqaeean5e6ZiVLt+2r5V6Dmt1IiIiGoz1ektS/+67776qFm2vvu0szoAlIiKiQUNmSHVUzAkHDspj5ep+m5ds3uXPP2XKlFaXS0tLUVlZ2XxZAkrpFJWxAlLUyuypRCKhQkpZ1t/WoYceivPPPx+fffYZttpqK9X9uskmm6jwVXz//fd499131fiBtubOndtuAJshwa1sQCDh6RdffIEzzzxThagyC7ajDtiDDjqo3dskIJbXsOuuu7a6PpVKqe5cIiIiIqK+UK9nyCxYGeXVFeGrYABLREREg4YM8O/K+3WW2+1udVlmuMqn62LBggXYe++9VcB5/fXXq7BTCr4TTjhBBZXtBbAyo1U6aKWDVAJY+d4yIJX5sTIG4Oabb17psRL+rorMas3Mm5U5WDI2Qc6rowB2VZuDZebYvvrqqxg6dGir27xe7yrPg4iIiIgGj6perteFNB688sor+OCDDzBs2LAuOSYDWCIiIho0ZPfUrrxfV5Lh/hLG3n777WoWrHjuuedW+7gjjjhCzYk97LDDMG/ePNUVmyHdsC+88AJGjRoFl2vdyj7DMBCPx1fZ3fv222/j6quvXuk2mQsrQauMKNhhhx3W6TyIiIiIaOAq6sV6Xaa0/vGPf8S///1vNR5LGhK6CjfhIiIiokFjkyGbqJlRMjuqPXJ9SaBE3a+njRs3Dul0Gvfcc48KUp944gm1YdXqHHjggQiHw6ozVWaolpWVtVo6VVtbq8LZL7/8Uo0dkHmwxx13XPPmWB2R0Qjl5eVYuHAh/vnPf6rz2W+//Tq8/yWXXKKe4/TTT8cPP/ygxijcd999an6tjDKQUQmy8ZZsLibn8c0336jXKpeJiIiIiHq7Xpfa+f/+7//UqjKpX6UWlq9VNSGsKQawRERENGjIoP6Lt7hY/dy2qMtcvmiLi7p1oH9HNtpoI9xxxx1qXMCGG26o5rnKPNjVkeJQxgzIvFfphm1JwtiPP/5Yha277bYbJk+erDa2ktECmS7bjshmXjKmQILhiy66CKeccooKTDsi82TffPNNdR6yuZhstvXSSy81d95ee+21uPzyy9VrmjBhAvbYYw81kqArOwuIiIiIqH8zerFel+YB2VRMNs+VOjjz9eyzz67zsTVH+mt7GHdWJSIiot6sFd5a+BZu+uKmVgP+5ZN0KeZ2GblLlz8fUX/CWp2IiIhWh/V653AGLBEREQ06UrTtOHxHtXuqDPCXGVKyjKk3Ol+JiIiIiGhg1+sMYImIiGhQkuJt85LNe/s0iIiIiIhogNfrnAFLRERERERERERE1E0YwBIRERERERERERF1EwawRERERERERERERN2EASwRERERERERERFRXwlg4/E4PvroI/z8888r3ZZIJPD444931bkREREREVEnsV4nIiIi6scB7KxZszBhwgRsv/32mDx5MnbYYQcsX768+faGhgYcd9xx3XGeRERERES0GqzXiYiIiPp5AHvRRRdhww03RGVlJX799VeEQiFss802WLRoUfedIRERERERrRHW60RERET9PID95JNPcOONN6KwsBDjxo3Df/7zH+y+++7YbrvtMG/evO47SyIiIiJaawsWLICmafjuu+96+1T6tPfee0+9T/X19eryo48+itzcXPQnrNeJiIiI+nkAK/OkXC5X82UpUO+77z7ss88+anmTLHkiIiIiov7v2GOPxf77798rz33VVVepOnNVX9Q+1utEREREa0dqpilTpiA7O1t9bb311njttdfQFX6rztbABhtsgK+++krNlWrpr3/9q/q+7777dslJEREREXU3x7IQ++prmFVVcBUVIbDZptAMo8eeP5VKwePxYKBbm9d5/vnn49RTT22+vPnmm+Pkk0/GSSed1A1nOLCwXiciIqKBwunhen3YsGG46aabMH78eDiOg8ceewz77bcfvv32W0yaNKnnOmAPOOAAPP300+3eJkXdYYcdpk6QiIiIqC9rfPNNzNl5Fyw65hgsO/989V0uy/XdZfr06TjzzDNxzjnnqOXhsixc/PTTT9hzzz2RlZWF4uJiHHXUUaiurm5+XDgcxhFHHIFgMIjS0lLceeed6lhynJZdji+++GKr55Ol87KEvj2WZeGEE07A6NGj4ff7sf766+Puu+9u1YEqBedLL73U3HEqy/PFjz/+iJ122kk9rqCgQAWjkUhkpc7Z66+/HmVlZerY11xzjZpL2tbGG2+Myy+/fKXr5b0oKSlp/jIMQ80ybXldRz7++GP1/gQCAeTl5an3ua6uTt1m27Zanp953RtttBGef/55DCSs14mIiGggaOyFel1WDO21114qgF1vvfVUPSt16WeffbbOx+5UAHvJJZfgv//9b4e333vvvaqwJSIiIuqrpGhbevY5MMvLW11vVlSo67uzqJNQU7pBJSS8//771axRCTOnTp2quhZff/11VFRU4OCDD25+zHnnnafu//LLL+N///sfPvzwQ3zzzTfrdB5Sr8kn/P/85z/x888/44orrsCll16K5557rrkDVc5hjz32wPLly9XXtGnTEI1GVaApweaXX36pHv/WW2+pYLmlt99+W20AJef7yiuv4Pjjj8cvv/yiHpMhnQQ//PADjjvuOHQVmXG78847Y+LEifj000/x0UcfqUJaAmch4evjjz+u3vsZM2bg3HPPxZFHHon3338fAwXrdSIiIurvGnuxXs+Q+vGZZ55R9a+MIujREQSZTRykmJblZDJHqr1uBiIiIqK+uoyp4oYbgfY6AOU6TVO3h3beuVuWN8mn6bfcckvz5euuu06FrzfccEPzdQ8//DCGDx+uZnVKx6uEtk899ZQKFsUjjzyiOkvXhdvtxtVXX918WTpCJbCUAFaCV/mkXzpEk8lkq25TOZdEIqFCTOnIzXRVSsh58803qw5eIbf9/e9/bzV6QIJbOXcZJ5B5HVJLjhkzBl1F3tvNNttMhYwZmeVi8lrkfZbAOFNEy3NLSPvAAw+ocxkoWK8TERFRf+X0cr0uq72kVpSaV2rif//73+rD/R4NYN99913svffeari/erDLpf5IkM4BIiIior5OzZBq80l6K46jbpf7Bbfcosuff9NNN211+fvvv1f1lRR3bc2dO1fVXOl0Glts8du55OTkqGX96+pvf/ubquMWLVqknkfCOhkJsCrSxSrL9jPhq9hmm21UR6V0vGYC2MmTJ68091Xmt0on7B133AFd11WoLOMUupJ0wB500EHt3jZnzhzEYjHsuuuura6X1y0h+EDBep2IiIj6s1gv1+tSZ0tN2dDQoEZVHXPMMWq11LqGsJ0KYGVGlxStsiuYz+fDZZddhgsvvJAFHREREfULMsC/K+/XWS2DSyGzUzPdo21J96uEhmtCZrS2nespwW1HZDmVjBm4/fbb1Sf8Ml/11ltvxeeff47ueJ1CXqfX61VdBBLOyvn94Q9/QFeSrt2OZObUvvrqqxg6dGir2+S8BgrW60RERNSfmb1cr0udOm7cuObmCRmhJXslyIqpHgtgZZOITz75RP1BIKRQlxOoqalRmzAQERER9WWye2pX3m9dbbLJJnjhhRcwatQo1anYliyRl3EBUviNGDFCXSefxst4gu233775fkVFRWpOa8bs2bNVt2dHZKaszHQ9/fTTW3Xcti0+M7NTMyZMmKA29pJZWJmQVY4lHa2r68qV1ycdBDJ6QI596KGHrjIwXRtTpkxR82dbjlfIkK4FCVql43cgjRtoi/U6ERER9WeuPlavy0ovGWXVo5twNTY2ql17M2R3WSmc5Q8BIiIior4usNmmcMlMU01r/w6apm6X+/WEM844A7W1tWpneglZJQR944031MZUEn5KZ6qElhdccIFaWi4bR51wwgkq8JSu1wzZyEtmscrGVrKZ16mnnqqC21XNopX7yXNJmCtdky03yBISCssmWTJaoLq6WnWsHnHEEaqrUs5Jgj45pz/+8Y846qijmscPrMqJJ56Id955R202JuMIumMDKnkdEizLuc+cOVN1gsr5y3spXb+y8ZbMspX3WjYzu+eee9TlgYL1OhEREfVngV6s16WW/OCDD9Q8fZkFK5ffe+89VQP3+CZcUqjL7LGWSbB0GkgRnrHvvvuu84kRERERdTUZ1F986SVq91RV1LVctr+iyJPbu2Ogf3tkMy3pIL3ooouw2267qU/XR44ciT322EOFrEJmpkqgKnM9s7Oz1XLyxYsXqyA0Q0YJSGi73XbbqWPKMqmvv/66w+c95ZRTVFh7yCGHqCBXAmAJLV977bVWM1ul4JRNrWT5voSt06dPV7Xg2WefrTbTknDv97//vTrHNSHBr3TeSui85ZZboqutt956ePPNN3HppZequbkSPMrzyOsT1157reoWvvHGGzFv3jzk5uaqLmS5/0DCep2IiIj6K60X6/XKykocffTRamWZ1FKyukrqqrZ7CKwNzWk7MGwVMn8IrPKAmrbScrX2PpmXFyKfxMsfEkREREQ9WSs0vvmm2j215YB/+SRdirns3XZDXybL/2WGqYSu0g3bn0jZKSGshL3nnXdeb5/OgNQV9TprdSIiIlod1uvd2AErn54TERER9XdStIV23rlpl9WqKjVDSpYx9VTna2dIp6ospZeOTilwr7nmGnX9fvvth/6kqqpKbf5VXl6uunWpe7BeJyIiooEgux/V690ygmB1Bd9///tftUSOiIiIqC+T4i245RboD2677TY1i1U2r5LdWD/88MNWcz77gyFDhqhzfvDBB5GXl9fbpzNosV4nIiKi/kLrR/V6jwSwc+bMwcMPP6x2xZXuBtmkgYiIiIjW3dSpU1c5z7W/6MTUK+oGrNeJiIiIes/qh0R1IB6P4/HHH8f222+P9ddfH5988gmuuOIKLFmypGvPkIiIiIiIOo31OhEREVE/7YD98ssv8fe//13N8Bo7diyOOOIIVczde++9mDhxYvecJRERERERrRHW60RERET9OICdMmWK2uXs8MMPV0XcpEmT1PUXX3xxd50fERERERGtIdbrRERERP18BIFs/iBLmHbccUd+ek5ERERE1MewXiciIiLq5wHsvHnz1Pyo0047DcOGDcP555+Pb7/9Fpqmdd8ZEhERERHRGmG9TkRERNTPA9ihQ4fiz3/+s9pF9YknnkB5eTm22WYbmKapdlSdNWtW950pERERERGtEut1IiIion4ewLa000474f/+7/+wfPly/PWvf8U777yDDTbYQM2dIiIiIqKuJwFabm5urzz3qFGjcNddd2GgOvbYY7H//vuv83GuuuoqbLzxxugLvw/W60RERET9PIDNyMnJwemnn46vvvoK33zzDaZPn941Z0ZERETUjWzbwdJf6zDry3L1XS73dYcccki3dzD2Zsg7EMiS/7fffht9gWzGJd2wW265Jc477zwsWbIEm2++OYYPHw7Hafr3LrW7jCeQL6/XqzpoDz744N4+dSIiIiL0dr1+0003qRrpnHPOWedjudCF5NP+v/zlL115SCIiIqIuN/fbSnz47GxE65PN1wVzvdjukPEYO3UI+iq/36++qO+RQNOyLGRlZamv3lZfX49tt90WDQ0NuO6661Tw6nK58P777+Pmm29W12eC9pNOOgnXXHONGlMgIe0zzzyDN954o7dfAhEREQ1ic3u5Xv/yyy/xwAMPdNnKoU51wMoyptV97bzzzl1yYkRERETdVcy9/sBPrYo5IZflerm9O0in4VlnnYULL7wQ+fn5KCkpUcvVW7rjjjswefJkBINB1aUoq4wikUi73anSCSufyM+cObPVMe68806MHTu2+fJPP/2EPffcU4WCxcXFOOqoo1BdXd3uOb733ns47rjjVDiX6YpseY6xWAzHH388QqEQRowYgQcffLD5NqkDzzzzzFbHq6qqgsfjae4IlWXzEgYeffTR6nxGjhyJl19+Wd1vv/32U9dJkSsrq1a1pF+W3suxWp73Fltsod43eX9k5unChQs7/F1IUCodoXLfgoIC9TvJdIRm2LaNG2+8EaNHj1ah90YbbYTnn3++1XPK+/Paa69h0003Vd2jH330UavzffPNN+Hz+VQY2tLZZ5+t3q8Medx2222nnkd+7/LvJBqNNt9eWVmJffbZR90u5/Pkk092+NoyNfmkSZPwyy+/qN/TY489pn43p556Kp5++mm1OVfLkDgQCKh/j3L9VlttpcJYIiIiosFWr2dI/X3EEUfgoYceQl5eHno8gJVCc/78+Zg4caIqQtv74kwpIiIi6qtk2ZJ8kr4qHz03u9uWN0kQJiHh559/jltuuUUFXf/73/+ab9d1Xa0mmjFjhrqvzOyUcLA96623HjbbbLOVwji5fPjhh6ufJfiTMG7q1Kkq1Hz99ddRUVHR4RLzadOmqXAzOztbzQ2VL1lSn3H77ber5/z2229VOHzaaafh119/VbedeOKJeOqpp5BM/lYoy/xRWdLeMmyUgFgCUjnG7373OxUISyB75JFHqnFWEh7L5baBaEeka1Nmt+6www744Ycf8Omnn+Lkk09W4WhH5HVImP3www+r8LO2thb//ve/W91HwtfHH38c999/v/p9nHvuueocpYO0pYsvvlgtT5Ows20dLI0JEvK+8MILrcLfZ599VhX1Yu7cudhjjz3w+9//Xp2/3Cbn1DLMlvm0ixcvxrvvvqtC4HvvvVeFsquq12tqalTNLsF023pd/j1INywRERFRX2P3cr0uzjjjDFWn7rLLLl12zE5VXrJc6ZFHHsE///lPVTRKB8SGG27YZSdDRERE1J2Wz65f6ZP0tiJ1SXW/oet3zafdLUlAd+WVV6qfx48frzZGku7QXXfdVV3Xcr5UpltUuhYlcGuP1GNyjGuvvba5K/brr79WwaeQ2yRsu+GGG5ofI6GjdFnKfSXEbUm6VWW+v4SX0hHZ1l577aWCV3HRRRepMFVCwfXXXx8HHnigCg1feuml5oBXQk4JD1uGoXKMU045Rf18xRVX4L777lPL4w866KDm42699dYqKG7vHNqbcyodu3vvvXdz5++ECRNW+RgJmS+55BJ1zkJC1pZL7iVElvfsrbfeUucixowZo4JRWYomYW+GhOiZ319bhmHg0EMPVcH0CSecoK6T37cE4xK4ZoJe+T1mfvfy70JCeHkOeW8WLVqkumy/+OIL9T6Jf/zjHx2+RqnX//73v6vXIN298rys14mIiKi/WN7L9bqMYpKmABlB0JU61QF7wQUX4Oeff8aLL76IcDisuhfkU3UpWqX4JSIiIurLoo3JLr1fZ7XtkCwtLW3VySiBn3RNSteoLPOX7lDpZJSl/+2RcG/BggX47LPPmrtfN9lkE7XTvfj+++9VQJqZSypfmduk83Jdzj8T0mbOX5bay/lKwCukcJXxBxLAdnQMGYkgZOxC2+s66vBsS8Y5yHPsvvvuapn+3XffrTp3hYSXLV+7hKoS1srtsjFVhnSDSmdvxpw5c9R7LsFqy8dLR2zb963l49oj4ap0pS5btqz5dyQdFZlREvI7kqC65fPIa5ERCNLJKp21cn4y5iBDfocdbZQm9foHH3ygfk4kEqzXiYiIqF+J9mK9LiuOZFSU1GtS2/ZaAJshnQAyB0GKV2nLlUK7rKyMRR0RERH1acFsb5fer7PcbneryxJiStAmJEiVLk4JKGXJunSy/u1vf1O3pVKpdo8nAags75cOSyHfM0vbM/OrJJT87rvvWn3Nnj0b22+/fZeef2YMgYxUkI2cZNWUnJvMee3oGJnO2PauyxxXxjK0HUeQTqdbXZbnktEDMkJBlvBLZ6+E0lKftnzd0k28JjJzd1999dVWj5dGhJZzYIWMlFgV6VqVzlzppojH42rUQdvfkXQEt3weCWXld9Rylm9nFBUVqYBWxg2wXiciIqL+JNiL9brU39IEIA0N8gF4ZgNTWZ0kP8soqbW1TsOfpLNBTkQ+mZelTW2LciIiIqK+pHR8rto9dVXLmrLyvOp+PU0KPgkdZT6phI7iueeeW+3jJMyTObGHHXYY5s2bp7piM6R4lDBXxhms6cxPGUOwtsWldLJKR6h8UC9hsIxAWFcSJpaXl6sQNhPOSkjZloxakC8ZLSDNAvL8sqHUuHHjVrqvdB7LHN5MCC1zZOX9l/dLyOxU2VRLOmhbjhtYW/I7kk4K2eRKfrfSAZshzynBbnvnmel2zZxfZgSBzN1tu7FXS/Ic8u/giSeeUBuwta3XJfSVrg7OgSUiIqK+prQX63VZifbjjz+2uk42qJV6TMZkyXipHuuAleVTsnxLOgv+8Ic/qGVfUsBKl4HszEpERETUV+m6hu0OGb/K+2x78Hh1v54mAZx0dt5zzz0qSJXwTJaNr47MMZXRULIh1o477qi6HDOk81E2mJJwVuZYyfJ5mXUqhWRHIauEtRLQyazS6urqDscfdES6YGVTKglMDzjgAKyr6dOno6qqSm1aJucvXcEyEzVDlulL6CodsAsXLsSbb76pukdXNQdWlpbJOcpYrZkzZ6q5ti0DTRn/IJuPycZbshmaPK80HsjvRi6vTQArj7/++utV/SzhboYU85988oman5vpTpY5uplNuGS+rmzSJV2yUnNLECvv8arqbqnXZf6rdE7LrFnpgpUAWP5NPf300yqoznT5CvkdS8gtnctS08tsXiIiIqLBVq+HQiH1gXXLL1ntJHXVus7U71QAK5smyFIoKf5uvfVWVaTddtttqkuAiIiIqD8YO3UI9jhlQ/XJettP0uV6ub03yHLxO+64Q22iJAWeBGayQdOaFIoyZkCWrbdc2i4kjP34449V2LrbbrupDlXZ7EmWp2e6bNuSZfyyVP+QQw5R3acSfHaGhL3SWSnfu2J2lgSpsgmZBK/yHslmVBKOZgQCARWiStAoDQInn3yyCp4zG321509/+pOaV3vMMceobll5D9uGxbKx2eWXX65+B3IOEoLKSILRo0evVbguc1h/+OGHlX5HMnJCOlRlU7TttttOhaMSgLYM0mXEglyWblwJ3OU1DhkyZJX1unRvyGxZea8kQJZNzuT4EsBKHS+brWVIx7J0Bcvj5PjyfhIRERH1lrF9tF5fF5rTdqjWKkihLsWZFHwtd7NtSz7hXxWZPSVFn2yCkJ2d3bkzJiIiogGvJ2oF23aadlltTKoZUrKMqTc6XwcamWUrQZ503GaW9FPP6Yp6nbU6ERERrQ7r9c7p1OAn+TR+VYUcERERUX8hxdvQ9fN6+zQGDBmfUFNTg8suu0zNXmX42jtYrxMREdFAoQ+ger1TAexVV13VfWdCRERERP2WjDqQGbQyBuD555/v7dMZtFivExEREfXzADYvL6/dT9Sl5ViKbZkxteuuu3bl+RERERFRPyCbZXVishV1E9brRERERP08gL3rrrvavV52jZUdWffee2/V8SAbQRARERERUc9ivU5ERETUzwNY2Sl2VTbeeGO1UywLOiIiIiKinsd6nYiIiKjv0bvyYPKJ+syZM7vykERERERE1EVYrxMRERH18wA2mUzC4/F05SGJiIiIiKiLsF4nIiIi6ucB7D/+8Q+1rImIiIiIiPoe1utEREREfXwG7Hnnndfu9Q0NDfjmm28wa9YsfPDBB111bkRERERE1Ams14mIiIj6eQD77bfftnt9dnY2dt11V/zrX//C6NGju+rciIiIiKgXaZqGf//739h///17+1RoDbFeJyIiIurnAey7777bfWdCRERE1INs28LSX2YgUl+HrNw8DJ0wCbpuoD8bNWoUzjnnHPVF3ctxHDz00ENqSf+MGTPgcrkwbtw4HHnkkTj55JMRCARw1VVX4eqrr1b3NwwDubm5mDhxIg488ECcdtpp8Hq97R771FNPxQMPPIA777yz079L1utEREQ0UNg9XK+3rN0y1l9//S7ZwLRTASwRERHRQDD780/wzqMPIlJb3XxdVn4hdjr2ZIzfchoGMsuyVGerrnfpVgD9UiqVWusNqY466ijVTXrZZZfhr3/9K4qKivD999/jrrvuUkF4pmt40qRJeOutt2DbNmpqavDee+/huuuuwxNPPKF+DoVCrY4rHcefffYZysrKuuQ1EhEREfVHs3upXs/UbhnyIXtXYOVNREREg66Ye/mOG1oVc0Iuy/Vye3eQAO6WW25RXZLS+ThixAhcf/31zbcvXrwYBx98sOqSzM/Px3777YcFCxY0337ssceqUO+2225DaWkpCgoKcMYZZyCdTqvbp0+fjoULF+Lcc89VAat8iUcffVQd8+WXX1bdl/LcixYtwpdffqmWpBcWFiInJwc77LCDmhHaGfKcf/zjH1WXZl5eHoqLi1VXaDQaxXHHHafCRXm9r732WqvH/fTTT9hzzz2RlZWlHiNhZnV19Tof9/3338cWW2yhXqO8RxdffDFM02x13DPPPFMdV1737rvvjuOPPx577713q+PIezpkyBDV3dqe5557Dk8++SSefvppXHrppdh8881V6Cq/s3feeQc77rhjq6K9pKREBaqTJ09Wr0vOU96Dm2++udVxly5dqm6XY7vd7tW+/xLgyu/51VdfxZQpU+Dz+bDVVlupY7f0wgsvqD8m5H2R87z99ttb3X7vvfdi/Pjx6vGZ3wcRERHRYKvXW9ZumS+pGbsCA1giIiIaVMuY5JP0VXn3sQfV/braJZdcgptuugmXX345fv75Zzz11FMq7MoEfhIGSrD44Ycf4uOPP1bh5B577KG6NJvP7d13MXfuXPX9scceU+GqfAnpxhw2bBiuueYaLF++XH1lxGIxFfb9/e9/V8vlJVwMh8M45phj8NFHH6mOSwng9tprL3V9Z8h5SGH6xRdfqPBQltYfdNBBmDZtmgp0d9ttNxXoyTmI+vp67LTTTpg6dSq++uorvP7666ioqFDh87ocV8JLOX8JQ6UT9b777lMBqnSbtj2udL3Ke3z//ffjxBNPVOfQ8v165ZVX1HEPOeSQdl+zBKSyHE0C17YkEJVAe1U22GADFUDL76xlQC+v54ILLlBhaWfIYyRUlVBdOnH32Wef5mD+66+/Vu/toYceih9//FEtrZN/g5l/N/I7OOuss9S/m19//VW9F9tss02nnp+IiIhoINTrYvbs2eqD8zFjxuCII45QjQtdgQEsERERDRpqhlSbT9LbCtdUq/t1JQk17777btUBK6Hn2LFjse2226rwTzz77LMqgJOAVLokJ0yYgEceeUQVfNLlmCHdoLLcXQI86dr83e9+h7ffflvdJl2zMmdUQtzMJ/YZEsZJl6OElxIcynxSCUFlXqkcS57vwQcfVKGjdGd2xkYbbaSW4UuAKyGzdFFKcHrSSSep66644gq19P6HH35Q95fzl/D1hhtuUM8tPz/88MMqVJ41a9ZaH1de3/Dhw5vfH+kWlhleEkzKe5shj5Xfg7wP8pV5T2QkQIa89xL2SgjeUWEuj1kXco4tO5wlIJeOCwlDO+vKK69U3czyb0cCZgm0ZZSBuOOOO7Dzzjur0HW99dZTndTSBXzrrbeq2+XfWDAYVP+eRo4cqX4fMoOWiIiIaDDV62LLLbdUH1LLB9LyYf78+fOx3XbbdbpBoT0MYImIiGjQkAH+XXm/NfXLL78gmUyqIKw90rE5Z84cFZ5K6CdfEqgmEgnV8ZohnZESsmbIMvvKysrVPr90fMoS9ZYkpMuEmdKxmZ2djUgk0ulP+VseV85NRiNIEJiR6fLNnKe8VglbM69TviSMFC1fa2ePK+/x1ltv3Tx6QUgnp7ymJUuWNF+36aabrvQaJAiX0DXzvshoAxlNsKoNuNaVHCNzrtKlKgG9FPwtz7+lzMgG+WrbISuvO0P+3Ug4LO+HkO9tO1rlsoTIMg9YglsJXqXLQzpwpbs301VMRERENFjq9Uy9JR/CSx0qq9P++9//qtVbMn5qXXETLiIiIho0ZPfUrrzfmvL7/au8XUJCCQYl/GpLlpRntJ0LKmFdy+7OVT1/22BPOnGlg1SCPwngZD6oBHktRx6sifbOqeV1mefNnKe8Vlki33b+aSZQXtvjrinp9mzr6KOPVvNiP/30U3zyyScYPXq06nboiHSSrutuuBKMyvMIGTshQbLMBc6QcPRPf/qT2tRLOmWlOzoej6vb1mQ+7JqS0F9GOkin9Ztvvqk6i+WLiIiIqDf0Vr3eHtlHQeo+aZRYV+yAJSIiokFj6IRJavfUVQkVFKr7dSXpMpUQNDMuoK1NNtlEdSTKbFbZXKrl1+rmibbtdJXgbk3IDFRZ7i5zUzMbNLXcCKu7yGuVObSyGVTb19peOLqmZIyCBKgtu1PlNUrAKLNxV0W6a2VkgXTBSheqbPS1Kocffrgal/DSSy+tdJs8f0NDwyofL+GtLG37/e9/ry5L56mMUvjuu++av2T2mMx2feONN9R9hg4d2vw+SWDekszwzairq1PnJu9H5n2R96EluSx/TGS6qWX0wS677KJGM8h5yGZuRERERIOpXm+PNA7ICq2WTQJriwEsERERDRq6bmCnY09e5X12POZkdb+uJPNLL7roIlx44YV4/PHHVSEnoZlsEiVkwL/MN5VNnaQbUuZNSUeiBKQtl8+vjoSaH3zwgdqQanVhqoTCMvdUOjE///xzdQ6r69TtCmeccQZqa2tx2GGHqU2j5L2QkFFCzzUNj9tz+umnY/HixWrDLgk4JRyV2ajnnXcedH31Ja+MIZD5qfJ+SHfwqsimVrJBl7wGmWUrG1lJaCmbd0mQKSMWMkzTRHl5OZYtW6Y2wbrnnnuwww47YOONN1YBayYA3nDDDVt9SZerzPFdk1mzsoGWhPs//fSTmvEq/5YkUBbSRSu3XXvttSqYldcoc3LPP/98dbuc81/+8hcV+sprkH+fne0qJiIiIurv9bqQ+kj2Q5DVR7Iq6oADDlAfWEvNt64YwBIREdGgMn7Ladj3vEtX+mRdPkmX6+X27iCbIEkYJsu7pStRArzM/FLZFEuCU1mCfuCBB6rbTzjhBDUDVmazrikJ4qRglE2+Wo4uaI+Ev9ItKR2p0oEpYa904HY36eyUDkwJW3fbbTc11/Wcc85RS7zWJCjtiHSIypyuL774Qm3gJRtJyXsoG3mtCQlOpbtB5n3JOa6KjD946qmn1AZXL774ogpUZVbYVVddpUJ0OUaGdPvKceV3O336dDVDTDYVk6C9o02+Ouumm27C2WefrcZYSNj7n//8R3VDC/n9ynM+88wzKtiVf3/y70SCWiHv+7/+9S+1KZv8u7v//vvVpmhEREREg61eX7JkiQpb5QNw+cBdPiSXponV1dVrQnO6YheBTmpsbFTL6WR5Vmf+qCAiIqLBoSdqBdu2mnZZra9TM6RkGVN3fJJO/YMsMZMQV8YQSAjeH0iX9I477qiCdAlSuwprdSIiIlod1uudw024iIiIaFCS4m34pCm9fRrUy2S5vYxruP3221WIue+++/b2KRERERERBla9zgCWiIj6FFmY0Xa3diKi7rJo0SKMHj1abdQlG3DJhlRERETUMdbrRJ3HCpOIiPqUmBlD0L32O6ETEXWGbFzWCxO5uoTMlO2v505ERP2Xk7KgeRknEXUGN+EiIqI+ZVXhayQV6dFzISIiIiKi1vRVhK/JWKxHz4Wov2AAS0RE/UaWp2t2DCciIiIioq7nDQR6+xSI+iQGsERE1O80xlMIJ9K9fRpERERERNSGjMeRTlh2wxL9hgEsERH1O4YrjZDPvdL1kaTZK+dDRERERERNzHQKbq93pW7YVJyBLA1enJpMRET9ek5sy11Ygx6jF8+KiIiIiIjcHm+ry5l63e3z99o5EfU2dsASEVG/E0v91ukaTVnqu4wkyASxRP3Vxx9/jMmTJ8PtdmP//ffv8DoiIiKiviydSLT4Oa6+p+JN34kGIwawRETU57Wd9+p1/dbpmtViF9akacGynR49N6KudN5552HjjTfG/Pnz8eijj3Z43bpYsGCB+rDiu+++64IzprYaGxvx5z//GRtssAF8Ph9KSkqwyy674F//+pfqABLTp09XvwP58nq9GDp0KPbZZx91n44kk0n174C/OyIi6ovsROtRYIbnt3FhHv9vowjSyd+CWaK+aOnSpTjyyCNRUFAAv9+vGiG++uqrdT4uA1giIurz2s57NXSt3ftUh5NoeRM36qJVcWwHibn1iH1Xqb7L5d42d+5c7LTTThg2bBhyc3M7vK6vSKcH5v+Nre3rqq+vx7Rp0/D444/jkksuwTfffIMPPvgAhxxyCC688EI0NDQ03/ekk07C8uXL1e/3hRdewMSJE3HooYfi5JNPbvfY8viysrK1fk1ERETdSfe1nnCp6yuPBpOZsLEW/y0U3KiL+lK9XldXh2222UatPHvttdfw888/4/bbb0deXt46H5sBLBERDRhD8wKtxhBkgtto0oTdB8I16jviP1Wj/OYvUP3Qj6h95lf1XS7L9d3Ftm3ceOONGD16tPo0faONNsLzzz/fqiu1pqYGxx9/vPpZul3bu0789NNP2HPPPZGVlYXi4mIcddRRqK6ubvVct9xyC8aNG6c6LEeMGIHrr79e3SbPL6ZOnaqOKd2Ymcdcc801KuiVx0i35euvv958zMw5Pvvss9hhhx1Ud+eTTz7Z7muV+z3wwAPYe++9EQgEMGHCBHz66aeYM2eOer5gMKiCSgkfW3rppZewySabqGOPGTMGV199NUzTXOfj3nfffRg7diw8Hg/WX399PPHEEyudr9xn3333Vce47rrr1Ht32223tbqfdJ7KfeX52nPppZeq9+nzzz/HMccco0LV9dZbT4Wt8lj5fWXI+Ut3rLzfW221FW6++Wb12h566CG89dZbrY4rfwC8+eabK51PR6666ir1+5PjDR8+XD3XwQcf3CoAXt3vm4iIqDvkDCludTmzUVcyFu2lM6K+Kt4L9brUY1I7PfLII9hiiy1U3bzbbrupOnJdMYAlIqIBobFFt2tFpF4t9c10wFqOA13X1OWGWEqFsS3vT4OLFG01//cLrIZUq+vlslzfXUWdhK/SGXn//fdjxowZOPfcc9Xypvfff18VetINmZ2djbvuukv9fNBBB610nXRSSpeldMRKgCrLoSQ0q6ioUAFbhnRf3nTTTbj88svVJ/dPPfWUCmrFF198ob5LyCfHzCx7v/vuu9Un/BLy/fDDD9h9991VIDl79uxWr+Piiy/G2WefjV9++UXdpyPXXnstjj76aBU8ynL8ww8/HKeccoo6Nzlv+b/RM888s/n+H374obq/HFvOWcJDCZwzwfHaHvff//63Ouaf/vQnFVzLfY877ji8++67K4WWBxxwAH788UeccMIJKvSW4rslubz99turcLYtCTSfeeYZHHHEEe12qkr46nKtev9bCW2lw6LlKAL53UqAK6GxBKlrSkLi5557Dv/5z3/Uv5Fvv/0Wp59+evPta/r7JiIi6gqObSO1YhasCNdUt9sBG66tgZlqqtEYyg5e8V6q119++WVsttlmqg4fMmSIqrflw/Eu4fSChoYGaUNS34mIiDrLtGwnmkw3Xw4nw05jPNX0cyLt2Latfs5c11LKtJy0aa10vWXZ6qs97R2H+metYFu2s+yGz5zFF33Q4deyGz5X9+tKiUTCCQQCzieffNLq+hNOOME57LDDmi/n5OQ4jzzySKv7tL3u2muvdXbbbbdW91m8eLF6v3799VensbHR8Xq9zkMPPdTuucyfP1/d99tvv211fVlZmXP99de3um7zzTd3Tj/99FaPu+uuu1b7euV+l112WfPlTz/9VF33j3/8o/m6p59+2vH5fM2Xd955Z+eGG25odZwnnnjCKS0tXafjTps2zTnppJNaHfeggw5y9tprr1bHPeecc1rdZ+nSpY5hGM7nn3+uLqdSKaewsNB59NFH233NFRUV6jh33HHHat+fHXbYwTn77LPbvW3LLbd09txzT/Wz/P+yPfbYQ/3OV/W7a+vKK69U575kyZLm61577TVH13Vn+fLlq/19s1YnIqJ1lYhGV7qcuS4RjXR4P5FKJto9ppn+rf5vdf943LEscx3PmAZ7vS6khpavSy65xPnmm2+cBx54QNWVHdV/ncEOWCIi6ndkBmzA09RJprITx9c8bkA25cqMIZDrltfHW82CdRtN/+mrakw2b9ylNu9yHNgrNshpOzu27QzagUZe74Lqpg6D2mgSKdNWP8t7J9KmjWTaWukx/VFyfsNKn6S3ZTUk1f26knQjxmIx7LrrrqoTMvMlHbFtl8uvzvfff6+6N1seRzpBhRxLOlNlw6add965UxtHLVu2TM28akkuy/Fakq6ANTFlypTmnzPdt7KJQcvrEomEeu7M65Il8S1fV2ZOqrx3a3tcOf+1eV3Sxfq73/0ODz/8sLosnaTyvkpHRHsyG2ytKzlO5v+H3XPPPQiHw6q7tyMt369TTz21+XoZOyGbe2VsvfXWqkv3119/7dTvm4iIaG1kRgtkOlnlcuY6byDY6n41Sxa3eqzb40W4pqb5v62ZLlnbttrtmnX7fO3OnB1I5DXXly9T70EiEoFlplVXcbi2Vn230ml1XdvH9EfJXqrXhdRKMg7rhhtuUN2vMptf6lFZwbauVr0OioiIqI+ToEJC17ZkxEC2z43SXP9Kt7kMHUXZXhUitheuDoTA1bRs9Tozr1HGLsypDKMk1w/TcuDSgUTSgnwU69Z1eFwaPptXjbpoUg23H1+SjSEhn3ofY0kTy+tjmDqyQIWzmaC6P7LDqS6935qKRCLq+6uvvtoqFBMyf7Ozx9pnn33UjKq2SktLMW/ePHQnmZG6JmTzgoxMoNjedVLoZl6XzHw98MADVzqWzIRd2+Ouy+s68cQT1XzdO++8U40fkBEQHY0BKCoqUpukzZw5E2vLsiw1AmDzzTdXl9955x0147btvxEJi2XUwWOPPaZGMWTIuAoiIqK+pmXgmmFblgoNJTwtGDZ8pdtDBQXNIWImuJVgtul4az6Spy+T90A3jObXKN8TkTA8K16f1DTpRBzpVBqB7Gy4vF7M/upTBHMKUVu+GGOmbAq3x4OG6kq4vX7E6mpRNGq0Oo7hcsHl6Z9/09i9VK9nammZ4d+S7DkgG6auKwawREQ04EjoqLVzXdtgtaMAtq9re94Stpq2g28W1qAoJEGVhhy/G0tqo5AMKifowveL6lERjmOzEXn4bnE9huYF8cHMcjhwEEnbcCwLHrcLU8pyMTQ/gK/n16q5udJtHE2lMboopDYziyTS8HtdsGynX75/esjTpfdbU1LISYi2aNEitYHVupBP5aUIHDVqVLszRcePH682+Xr77bdVgNiWbESVCftaBnfS8fnxxx+3Oj+5LBsQ9AR5XdKd2d581XUhRbO8DpmvmiGX2xbX7dlrr71UMCsbdMkc1Q8++KDD++q6jkMPPVTNar3yyitXmgMrAbMEyauaAyuBquy++/vf/15d/stf/qI2BMuQrlWZ1SoboW255Zbquo7eL/m3JvfPnMdnn32mzlE2IesLv28iIhq8UvEY3D7/Sh+WtgxbM/dznM59oNoXSOduOpmAx+dfKWhdNutnFAwdoW63TVM1NliWCTOZQqS+Fg0VFSgePQYV8+YhmJ+H+T98C38giEhdDSzTQoFsrhnKgSfgx+JZM5CONq1Yc7ncCBUVIdZYD48/qIJbmaUbKihEf6P3Ur2eWQ0k9WhLs2bNwsiRI9f52AxgiYhowFnTrtay3NV/et5RyNid4WOme7WlBdURjMgPqlBUnveX5fXI9nnh1jU8//l8jByShe8X16M4x4fZFWEVwMYSJhpTJiLxFFwaMKc6ird+LkeB34WfvPVYUBtFcdCL/Cw/GpMOPIaOuJlGNGWhPpps+tTdsbDjBmVwYKMyHEdBlk8VlXKOeYHfuhL7C+/oHBg5nlUuazJyvOp+XSkUCuH8889XG2/JHxvbbrut2pFeAi8Jw1qGg6tzxhlnqM0ADjvsMFx44YXIz89XIw5kA6i///3vKuS76KKL1G0StkohWVVVpTb+ks2lZEMBCWglUBw2bJi6f05ODi644AIVHMourxtvvLHq+JTuyieffBI94YorrsDee++tls7/4Q9/UGGhjCWQjbNahpCdJa9LNiiTZWS77LKLGiUgm1zJJmSrYxgGjj32WDUCQIJtWca/KrJh2HvvvafCUflZOlWlO1c2GJNN2L788kvVJStkrEJ5eTlM08SSJUvUZmHSaXvaaadhxx13VPeR96IlGTMg5Hckv7tVkd+r/LuSTbZk5MBZZ52l3oeSkpLm96U3f99ERDR4efyZUQSta/G2lzP3W522wW1H13WlTKiaIRuMJWNxhPLzVQ0t4euSmb+gcNgwVC9ZjNnffIbxm22F+T/8gFlffgZ/VjbMeArhxjo4lglL02DFYyhfMB9Dx41XK9KgOQjX1qFo+HA4moa8kqGI1tUjkJsPjy+Iyvnz4fX4VRg7YvIU1C1bDrfXByudgmWaa/z+9TXeXqrXhdTq06ZNUyMIpG6SzWsffPBB9bWuGMASEdGAlBlB0FIibcHnNjqct9iejkLW7gpf62MpuHQdWYauQs76WBquFaf8ydwqxFMmKuqTWFgbhgYNlZEEKhuieOarefB5PPC5dCyuTUBGQCWkbpOl0SEgHAdkcEBNYxoLDMA2AVmVZCZseA0gkrLhNzR8Nb8O08a78FN5PQ6YOgJel46ldVGMLMhCZUMSI/KzVFdsf6XpGnL3Gat2T+1I7j5j1P262rXXXquWqUsQJ2MCJIiTrs9LL720U8fJdC5KyLrbbrupuaTyqfwee+yhQktx+eWXq05LCTWlC1KWU2Xmg8r10lkp81bl9u22206FhhLQSSj8pz/9CZWVlapDVHaCleCxJ0hn5yuvvKLOS8YrSHAps23b6+LtjP333x933323CiLPPvtsjB49WoWN06dPX6PHS2gtRfhxxx232vtKGC6dpjfddJMKjRcuXIi8vDw1o/bWW29VQXeGhOjyJSF5QUEBNt10U9XZesABB6ArSGesjHOQLt7a2loVbt97773Nt6/q952Zn0tERNSdmmbDth5PkE4lm0cNrGm93l7Q2p3ha6yhAW6ft7mrNZ1KQNcMxOprsGz2z/AGQiifOxvpVArfv/OGOvdls2di7tdfw0mbMg8N4fpaOFGZ0WoDhgtZ+UWIRBqgazoWzZwBt8uFZGMj/PmFqFiyCAXFQ1FbuQxWKgV7vg6zOI54XSNGbrMh0mkTtYsXI6ekFBXz52HYBhPbHfvQX2i9WK/LGCj5UFw+fJeaVOrGu+66S41+Wlea7MSFHiZFnRSgUvRxVhUREfWUtGWrELZleBpJmu3OkO0pmYLyp6X1TV2rKRMp01JB7K/LI5g0NBsf/FqlZrMmzTTqImnMqWxANCnFCWCZQEPr/bHaJa9QSlnZakt66GQxV2EQWB4Fhua6VDfwhmU5mFXRiE1HFaIo5MGIwhDcLh25Pg+G5fnV6IGBUivEf6pG/X/mtvpkXT5Jl2LOv2H/W6pF3Ue6V2VDs8WLFzdv+tXXXXXVVXjxxRdbzYftDNbqRETUW+KRMHyBILQVHypnRhH0VjenbHAl5yLfZRzA0PUmoHbpEpjpFNLJJOqWL8PwSZPwzWsvIxFLwIGGeLgBdcuXIJlOSRMr7GjTXgCrpUnXhWwwbEMPZsNOJgCvB0jEUTB6HHweH7KLipBKJlA2dgOkzSQmbrMD4vV1COTnIysnF6424XV3Yr3eOeyAJSKifqczy/9bdsK6DV19tSThqxxPZI7ZXvdsV5Hn0jUN0WQa86oiiCZTqI2ZKAy6YZsePPHZQlQ1JODzaJhVUY/qekc+FIfbA2grRmBVNI166hRzxZeQT17lFddHARmdJCucgl4XokkLG48sgNtlwIaGyUNzm65PmT0avvYEKdp8EwvU7qkywF9mSMkypu74JJ36J+ksltENEmYedNBB/SZ8JSIi6gsSiUSrTTQ7Ikvlbdtq7nr1Z4VWuo+Er9JpKlVsprOzve7ZriLHTsXjaiOrmqVL0VBdAZfHA92lo3b5Unzw7OMwDDcMjweLfv4Bzr/1piX/bo/q4NV0N+xogzpWpzoend+6KmwrpUYQIJFAztDhSDU0IDg8hJziMiQj9fCFsuBJ+5BXXILs/AL1HvZk+NoT/AOsXh9Yf00REVG/IF2oEkJ6XK3D0DUlQWkmJF1dGLsmQWrbx6/qMWsa/iZNS81UlXUm8nob4mmU5vrV42sjSXy9oAbL6qLwuFxYVNMAGzo+mV2jHit7IyVMIJE5mKSlTRlxl5BDlYYA04aaGZvl1jCqIIBheVnQDA3Zfg8mlWar7tdwMo0cf9cPuO8LpHjzjW2ax0nU1tNPP63GD8h81Mcff7y3T4eIiKhHresMVQlfMyHpqo4lIaexBtHUyvNi2w9fzXRT0exyr75el02qJFiVsNXt8yFcU4NQQQESkTCqlixG9ZJFSEQiaKwqV5tZlc+ahcolC+Dx+tUYArXbbYvQNKXWmnUydO2INEhk50N3G2qkWOGIUcgqKFTvQ/Go0YjUVWPCtjuo91Zq2syGXwONNoDqdY4gICKiAachlkJO4LfQUEJPN6x2P4XPBLkSmApvZuBqBzrqjpXHy2MrGuPQoSGSMKFpjgqZf17WqOaoLq2LYVZFGGnTRMBjYMbyBoS8OpY32EimgSR6hpSvoSAQNKA2Y5o8NAeThucix+dRowhGFQbRmDAxpqhpw5/ewFqBqPfw//6IiKg7yXL+VCLRKlRt6nBtf3ZrJsBd01C4ve5YeU7ZCFXm5Ucb65GMROELZSNaXw9oFuqWLUO0vhGLf/kRdjqJeCKFRETuF4OVTsJxNKTC9egpnlC22nzXn50Pw+3BmE02RSAnG4GsEHKHFCO/bJja9Cu7sAi9hfVC57ADloiIBhTbltCzdYja1LHqbreTNROmtgxe2+tybXl/y3bURlRynXyOmeV1Y3l9XIW+M5bUozKSRGVjAkuqIwh43fhoTgVsy8bSegseDfB5gKpM2hpeMVegB//DL521hS4N65fkY1RREBuPyseE0hzMqQxj/ZJshPxu5AZ69ryIiIiIaHCQZford7R2HLxmbst8TyXiamRByzmxre8fVEvydb1pkyy1PN/lRjIeh+PYWDxzBuKNdQjX1COdSCDSUIvl8+bA0HVEKpbDyMqGFendDSlTiRRySktQOmYcPMEgRk/eGG6vT7320nEbqPu4vQOz63WgYgBLREQDinxSvIpNUputaoxAe7dVhhNw6zrqEykVwlZHEiq0XVobRyRloiGawqdzqjCzvGkzLdlIqzKcRDJpoTxiIzM6PukA4aR0266q01Zul4JSWzG5teV/rlf32I5JyZoXAvKCfpRmeTC+LIQNSnIwsiCEvKAXm470qPBVuNrMyiUiIiIi6gqyXD6z/H9VOup2bW+5vWyIlYxHVKerNEjICIKG+grohhuVC2chkFeIxTN+xrKZPyOZjMLnz0I8FkbVwoUwskJIVlU0H6tXw9dgFrIkRA6GUDhiJAqGjcSQEaNVp6uMSTBkc4gVdGPt/iag3sEAloiIBhyZL9uelGm3O3dWrjdtWwWq0tma6aSdXx1BQZYXpmWjIODF818thNdrIBo31XULaiIwLQs/LalDbSSlxgjEU00zVuU/sHE1AarluWTCVCmWMh2m+opQ1Wnxn2WjRdDqWnFfp/lxOhzYnfhPuEvdW8cmI7PhchsYXhDEpLIQfG4XhmT7sUEplwwRERERUc9pbyMl2chKQkWtnVreMtMwU+lWoWyktgaaywWXy4V4OKzq5V+//xSpZEL+IEA6EkGkrg7LFy+A7gANFUvVsn2kUoCEuImmsQdmL3e7NvMHUDJ8JAqGjkAgFII3mIX80lL4s0O9OmqAugYDWCIiGnA62tzL7mDsuVwf8LjUaAEhn5r/uKQeQ7K9+HBWJRxoasMsmVLwyexy1WFbHUnj5yURSKNoveSqbTSN/9dW8Z/dludorHhEy27Xtp9oZ47lbo5uWz9bxx29pdkGRuX6EbEsbDUiFxOH5SKRsjCqIISNR+Z1+DgiIiIiou5guNqrXTveosixHRW+ZkYLSL1eX1kBGBoSDWGEa6uRiETh8fmw8IevYbgMNFRVoGbpMtVpa0YjrQ+4InztK3KHj4A/lAtfMAiP34sRkyajoaIC+UOHIb90aG+fHnUBBrBERDSgtDe/NcPnNhBPWXAbMqZAQ0VDvHnJ/eLaKGrDKRTmePHw+/MwdVQu/vr2ctiWibRtYWZ5RNWEqaSJqO1q7nI1W6WhHY0HcFZ8Zbpd2+uIbdv52vJY6RY/Z46RuSwn0P7yozwvMCTkxYTiAMoKs5Hn92G79QrREE8h2+/FhLKczry1RERERETrrKPNtDKhbOZ227IQra+D2+dXY8aWzJwNTTfUz9+/9QZKx6+PXz/7BB6PC/W1tQhXVajGCjMSlhZbSW3V8cx0ZhhY3xMsKobH60PZ2PHQ3R6Mm7oZArl5gOYgp2gK8krLevsUqYswgCUiogElE762F8TKJ+UyYuDXijCqGuPwunTEEjaqojFE4iaqIkmUR5JoCMfx4awlMC3AkrEC8uU0xZwptaC/yW+Nr1LU6dChrbgtU+TJXCu5puUjXCtCVLmP0SKcda+4LjMLKxOqWm1C2vZC3tYdvzkGUBgyMG29EkwZlo2i7CCCHh2hgBfheApbjOESJiIiIiLqHc2bacVj8PgDK9XrUhtXL16EJbN+xrD1JmLhjO8Rb2yAyxvAou+/g8vvQ0NNJeZ/9w1sWDBNB2Ys2lS4Z+riFeFrX+UOZaOgZBgKRgzHuE23hNfrgyOb9QaC0F0uFAwdvtImY9S/MYAlIqI+JZFIIAVDbXS1NpKmpeazNsZ/C2BllqvH0PH+rxUq6vR73Ph2YZWa25rtN1AfNVERjiGeNFEfS6su17TtQtQ2Yaml/1L8OCvGCrQshDKzWSU0jcFW95VNAQz102+LqDIBa9NjXEjAVJclSE22CFTd7XTAtg1b2w9f5T/o3hUR7/RJQ+B36Zg0LBdDcppmvMp7ku33IFTCea992ccff4xTTz0VM2fOxO9+9zu8+OKL7V5HRERE1FuSEnaqIDW4lo+PwXC71XcJYOORRiQjUcTCDQjX1qJmyWKECgqx9OcZqJg3V4Wy5fPmweNxIxJuQCLcCNO04NgmkJRauqW+HbzC61NL6DaYth08Hi9yS0rV2IHCEaOQikXhDWR1uPkY9W8MYImIqM8Erz6fr+mrE4+ToFW6WuW7pJ6/Lm/A5OF58HsMvP7jEnwxtw4luToiiab7f7ewBlWRNLZerwjzKxuxtDoFjxeIrbhdSjizeeOrzH8mrRVBZ2xFAOpts/TfbBHMyn0tOCv6ZZvCWXPFl8SyBkx138SK42stjtXymJkuWXebTljRenOvkA6kbGDYEA8O2mQkKsMJTByaj3AyiU1HFiDL50K5jFtYy1Cbes55552HjTfeGK+99hqysrI6vG5dLFiwAKNHj8a3336rjktdq7GxETfffDNeeOEF9V7n5uZiww03xOmnn44DDjhAjT+ZPn063n//fXV/j8eDwsJCbLLJJjjuuONw4IEHtjrerFmzcMEFF6ggPpVKYcqUKbj22mux44479tIrJCKiwSozGqCzwWukthpuX1OoWFe+DI5lIbe4BOlUCj++9yaWz52LvOJSRBvrkYxG1NxWK5lEwdBhWDjjB0QaGuDIxlqy+YJsoNXvaIBmAC4dIydujMKRwyCNviMnTEa0sQ5FI0dD13R4fPLeMnztTaNGjcLChQtXul7quL/97W/rdGwGsERE1CdI8Lo2Qj4X5lVGUBNJoDqaxPeLavHhrAqMKcpGVSSOGeUN+Lncxv+z9x9AkuVrehf8O/6kd+VN+57pcXeuX2+02tXKg1YWIpD4hAn48IFAGAFCIZBCAkkQfBBCAi3I7iIkVhJi/WoN1+i6uePbTpvyLn0ef84X7z8re2r6julxPT09/9+NvFl18uRxVdP15nOe93m3DoZ4DrzWBd+E/a/foRulKjSgH87a/k9iHgui2fHzSfEyP5ZqRQR1TwzBmoUSJMfL5XUpEm1MRuRKWi6Ot+mecMZmx4LszE07G8o1E37N42VyvCLu2mpLNhauC6faZb5wocNCrYRnW/zg40s8e6qlhB7/eCBZ2dN/8u8lz3NVYI1GIyVsnj59GvMjbvW6fv26cruura297bKHhSRJcJxHT9h/r+fV6/X4/u//fvr9Pn/6T/9pvvCFL6jJzCK2/of/4X/Ij/zIjyhBVvhX/pV/hT/1p/4UaZqysbHB3//7f58/9If+EP/iv/gv8j//z//z3W3+zt/5O7l48SK//Mu/TKlU4i/9pb+klsnvxdLS0gd63hqNRqPRvB3vVRws1Zvs375JOB4SjkfcfvklHM+ns7LKreefIxgO2b5+ldHhAYZhEXT3oVRmb3sDgqnbVnFylMLHBdel1GxSa3RYf+op6nNLRIMel77vh/CrNWzXwbJsTMsiP3YWaz66ev1rX/saWfb6L9qLL77Ij/3Yj/H7f//vf9/b1oESGo1Go/lYMAgTwiRT2a7Cc3eO+AffusNf/9INfvI3rvIXfv5F/sZvXOfm7oAvv7zB/+8XXuZXX9xhrzfg1Y2hylDa6eZKxhzlcBBJDWccRwHMclpHGEowje/5UzlzqZrKvyriq/WGCnAm4GbHwuzM9ZocP1JyFU1gHAut/vHzyX2Jq5YTDljZRulEZuyUAo+mZ1ErWZxf8vjei3N84VyHZ9fbnO3U+NGnlvn+xxbUulXPxhanALznSIdHlZdfflkJWf/b//a/KaeiPMv3svzDLCD/zJ/5M8p9KkLas88+y9/9u39XvSZOSRHMDw8P+aN/9I+qr3/yJ3/yTZfNisHf9tt+mypEFxcX+Rf+hX+Bg4ODN+zrz/25P8eFCxfwPI9Tp07xX/1X/5V6TfYvfOYzn7nrxpy9RwRBEXrlPeKO/dmf/dm725wd40/91E/xQz/0Q+qmyd/8m3/zTc9V1vvLf/kvK6GwXC7zxBNP8OUvf5lr166p/VUqFb73e79XiYgn+Zmf+RnlBJVtnzt3jv/yv/wvlUD5frf7P/1P/xPnz59XbtPHH3+cv/7X//p3HK+s87t/9+9W2xDxVK7df/Pf/DdvWO+5555T68r+3oz/5D/5T9R1+upXv8of+SN/hCeffJLHHntMia3y3pMOZjl+EVDlen/3d3+3cs3Kuf2Vv/JX+MVf/EW1jvxMr169yn/0H/1HyvkqQuyf/bN/lslkon4H3gr5PRGhV+Iq5D1yPX/8x3+cO3fuvKvrotFoNBrNu0EGZs2csmkccfvlF3nxV3+ZL/+ff4fnf/GX+PLf/z/4yj/4e+xcu8zVr32Fr/5fP83WjWscbN2hu7ONYVsq61URTN4ovn7MMMs1ynNztFfWufDpL3D6mU8xv3qWztIqz/zIb6Fcr1OqVnFcT4mv7yfS4VHl5Y+gXp+fn1f12ezxj/7RP1K1ktS+7xejmCYcP/DWrEajodwB9brOotNoNJqHLQbgo+Te4VnjKMU1Df7fGwd8Zr3FX/4nr1LzXX71yj6eZbDTDan6hsp+HYYpcVwovbI3yQiwaNpgZDAsCkwSlS87FT0NDEwK9fXMmZofC58j8daeEFTt48fJ2IDieD33WDyNjpfJ9g2MPKAwneNtj4+fT7pq4+N9zDJmZ27Ze924CSaOWuqYcH7B48JinXrF55nVFqc7ZXYGIb/16RV6k5isKJivfbQ/w4e9VpCi7ad/+qff8vU/8Af+gBLOPmhEAP0bf+NvqMJRRLFf+7VfU87Wn/u5n1Ouyf39fSWCiQj6B//gH6RWqzEcDt+wTK5JFEVK1PuX/+V/mT/8h/8wQRDwx//4H1dCpbgkBflehLy/+Bf/otr29va2ypCV98id/S9+8YtK5HvqqaeU+NZut9W6f/JP/kklAoo4+7/+r/+rWvbSSy+p451FF0hr1n/73/63ah3592J5efk7zlVEytXVVf7CX/gLSsiV4xEBUkRVcYKKICyisoiEEq0g/Pqv/7oSVv/7//6/5wd+4AeUiPqv/qv/qnKE/hf/xX/xnrcrzlK5dnLdf/RHf1QV0rLuL/zCL9xt45ftLiwsKHFTCmxxrcrPSgRmOf8Z/86/8++o/c3iA04iArZECYhDQq7h2yFisRy/HNObbUOcsP/j//g/qsw7EZnlesi6IozL85//839e/TxbrdZbCrBy7UTkl+spP2NpnZPzkiiDd7oun/vc53StrtFoNA8hSRhiuQ6mee9MgAefAXtSLFSCaxqzf/s25UqNl37jl8mznP07NzEomAz6WJbDZDwkzwrl+hweHkB8nN/q+sdfz0wPH0/Mao08zWgvrbB87hyNhSVay6vYjk210Wbx3HlG3SPcUumREFsfxXr9JBL9tLKyouLA5Cb7+0ULsBqNRqN5aB2vUoJd2R7wj1/YUuLi9d0hc1UXx4KdUcwrG2MWqnAwgoU6ZCnsTgpyUlJpz1fyqqXcqpkq5qYZrK/HAMizyJsBiXKbZsc5rzNBVpgJtukJIVa2E4iH7YSjdbot+d7Ap1Cia+l4PRfrWJyd+mZLmByR03pDlqtDSnJPOlDThOWOnLPJZ0938BxLuVqfXm3xg48vkBeFEq1Xmo9WXtSHVSuIwCWCk2z/rZD9/bv/7r/7gbY3iWgqIqeInt/zPd9zd7kIouJm/Ft/62+p70U4lOMT0XHGvcvEnSlipQi3M6SFfX19ncuXLytBVO7e/w//w/+gtn+/GbAibP4b/8a/8YYCU4RaaaOXzKvZ++RYRIh8O0TQ/BN/4k+orFLhK1/5ijrv/+V/+V+UQCr8nb/zd1TmqQjIgoiAv/k3/2b+4//4P767HRFBRRTc2tp6z9v9vu/7PiU0n2zrl6J9PB7zf//f//fd7crPXATnGbJPEXS/9KUvqesgsQRShIsrVtyt97K3t6fcyCIO/3v/3r/3ngRYQdyw8rvyj//xP777s/1n/9l/lm9+85vqd1KEYjluEcDfChFg5RrI9fmu7/outUwEWxFzxZ0r5/N21+Vv/+2/rWt1jUaj0bwjwXAApslr3/4GN776Nbxqia1r17B9H8s2VfbroNtXNxRFiPUqFZIwIBtPPtZC6xswbZVNu3bpSYb7+zz2vT/MZNBl8cw55tbWaS2t4FerSrSuNKYxRI8Kj1q9fi8iAP/z//w/z+3bt1UN+H7RgXAajUajeSgQB6vkl17bG3AwjHh5s8dcrcRXr+8zX3X5+Rf31J30q9tjJVk2alPJcxhC2YXNwcxDaijhVV4VKVaQqAGPmEj92Ztluk6HWkmmaqZE1iFQOSG4iqgqxaF9T6SAPM8cuiLwyL4kyCAnUeuJq1Zw1DtTJcIWZOo9U+esxYRMuV/jY/fsVJaVrS+VYCeAlgO1ksk/89k1JbJ+9vQ8RWFQL9ksNnz2+iEVz34kxdcPE8mQertiTpDXZb1Zq/4HgbSsi9AqGVL33ll/OyHtzfj2t7/Nr/zKr7zpQC5xjUoOqQi+ImbeL3LOIjiKKHcS+V72d5LPf/7z97VNaZmfIcKk8Mwzz7xhmbjuZd9SRMt+xJ05i0oQJINL1pFrJy3772W7r7zyinKD3nte/91/99+97XlJof07fsfvUE5gESz/4T/8h+q6vlUG2AflaVAfUg3j7tciiovoKqK7RFf81b/6V/ldv+t3KSeziO0ios6GRYhTdub8FberiOczLl26pMR8uR5yPvd7XTQajUajEbI0wbKnNfCtF76tXKx7N6+TJCnBoEthwo3nn1MOT9t1Sccj/HZbDc8yS2XyKCI83OeRwPHFjoxRqTK3tMr5z30eyzJZPPe4ejYsC79UEcsj1VZLOYQfNfH1UazX70Vu8Evk1wchvgpagNVoNBrNh4oIFtI2m+cFYZpRdr/zT88oSPjFl3eUFPpT//Q2q3WfUZRxZaeHJcJmYXAwlAiBjIZrEiQ5ljX1lHbTqQBaVU7WBAuDAJcaEybHg7EcJb5OBQ2L5K4LVSIEZKvyeN3VahwPuhLxVZDXZl/P3KrFPc/iXPVOrCfH4ZOeyIM1CchpKPF36sblhJAra8t3GWvtMktZwefPzhEl4gI2ORpF1DybL56fV4LrXj/ic2c66p0n4xo074wE+H+Q673b/YpzUZymJ5H/Pt7ttkSAk8zQexFB7saNG3yYSEbq/XByiNVMUHyzZeJymJ2XZL7+xE/8xHds62Q0yrvd7vs5L3EQS76uOGP/2l/7a6plfyYE34u4jkXgFKfpe0UEZ8l8nQmnEikh0QDdbveus0SiCSQmQHLQJBtWnLLizhVEoNVoNBqN5t0ShwGuX1JC4ZsN2hLxNYlCnvulnyUaTrj2tS8xf/Eih7fuMOwdKME1GAxIJL/VLeG6JXLDPE74SsnHJ8Q0+Tv94BuxPxhEgC4KLnz+i/R2t1k+ex7LL0NhEI4CmgsLVJotlet6tLVBZ+3U+xpe9kll9BHV6ycRcVc61/7e3/t7H9g2tQCr0Wg0mg+VmTBimsZ3iK+9ccSvvLrHTn/ML7+6C0VOb5QwihKsJGJ3UNApwSgR12jGWIRKA8LCJOpN/4jFZNjEFDj0MKioXFaPofKTTsXZhDIOE5Jj8dVSUu6sEBSRxlbip6StqmNVjtVpNqtDyDQMQYTUqcjhEJEoyTRVYQOh2oaIt/7dDNhMuVvLx45ZT3lwp8jr1bui8UrHJokjcmw+f26Jz59qszdJcYyCM3MNLq226E0SOlXvruCqRdf3zpu5Rt/PeveLZFSJ0CotTO83xF+GVMkgAsliFZfjvUheqwhxv/RLv/SmEQSSByqcnPAq4p7c3RcH6snjk+/FLfkgkPOSCAUZfvVBIm33ch4nYwPk+/vJDfvtv/23K2FWhlXJQDLJ7X0rpAVOsltlkJVk1t7rlpAPCSIkv9nPbIaIqiK2/t7f+3vV9+L8nW373n3NBGaZBvxmSCbw17/+9bs/P7m24o6W6/F+r4tGo9FoHi1EMHwroTAYDvn6//MzytV59Sv/L4a03BcZ25cvE/R7hOMAt+yTRMd5rllKEI4pgjHhm+WcfszEV7fWwKtWyOIU0zZ57Lu/n0qtxuLZc2RJwvqlpzAsg3KthV+uKCFbmImvmo9PvX4SufEuHUjSDfVBoQVYjUaj0XyonBQOxAUbZzmbRxN+5uu36E4ibuz12R8GzNdLZHlG3S04GIXcGeVUDZPdIOdTyyUlgV7bjbCSDI9ESasigi5YBqPMJ8TEYESkhFILj5CClFiJoiK9SvaUcRxMkN17lMciq2zVIFdrylYkS1a+ksdM0JWvHAwiFSYQnhii5RIQK6FVRFb3ONZAXK+m2qZzvBVJfq3WbM4vNXl8qQpZzrmlFj/x2XWu7A5ZapRI0pSl5sc/nP9hQ8QqERvfKVPqrUSt94oM1Ppjf+yPqWxQEc5kMJbkZYngJft7s0zRt0Ja0mXA1j/3z/1zKh9V8kIl4kCyT6U9XUQ+GU4lr4nYKm3lMuBLhkn9S//Sv6SKSRFoRVBcW1tT60t+13/wH/wHSjiUSa+STyqFpwyckkFUD4L//D//z9UQLsld/X2/7/epfzskluDFF19UubfvFTkvyTaVqAfJmZUoAXEziKvhnRCnvWTvSi6tCNsn83vfDIlP+Cf/5J+o3FX5WmIN5CaUxAf8mT/zZ1RsgLhkZ+Lqzs6OEkol51WGYonT9l//1//1u8PBZH8yaEt+P+T6yM9NfvavvfbaO34gkP3+W//Wv6WGcIno+2/+m/+mypedCbLv57poNBqN5tHCOFGvixvWsm1ee+E5rnzlS9Tn5vn2L/+iym+t1hrkRcbwaKyyXONBDyxb1fDz66eZ9HuMu0cU8dS0wGQMIkgWhkzq4uODgV2rYTsuFz//XViWTZHnXPjCFzn15KfYfe065XqTUq2mBmppHo16fYbU6lIHS/31djfO3y1agNVoNBrNh06S5Wx1J7y63ePa7gjPhis7h1imyfXDgCyG7UGAGDv7Ecx5EhBQkBWR8q4OhgH9SUjL8QiTFNcwmRQipg7ZyzzlaDUZHTtYIyWnRipiQEZwRcrNKn/wJKdVwgBkvemArlmkgHyVKp9qqIZ2iXRr3BVf7eP3TZlOZxU5dxpjMB28NR2h5dx1yk7XbuCS4ZsWTgkatslCs8xCzeVUu0pcGKx1ynzx7ByjMFGCk+S7+o5FU4JtNR84co1/62/9rW87VVVe/zAC/WVwlLSpixAnMQEixInr891OVZ05VUVk/S2/5beomA8pQE8e93/2n/1nqmAU0U6yXSWa4F/71/419ZosF1HuT/2pP6Vel9xQEQ3/7X/731ai8L//7//7aqCUOCH/wT/4B0p4fBD8+I//uGq3l+OSeAURECW39M1cvO8GGWAluaYyPEuGh0lWmBTVMgjrfhDR+r/+r/9rNdTqnRAxXAZf/dk/+2eVaCztayKgSkbtn//zf14J3TNESJWHiOSdTofPfe5z/NRP/RS/5/f8nrvrzM3NKaH8P/1P/1N+5Ed+REUNSObrz/zMz/Dss8++7bFIVIL8jsjwiM3NTfVzliyz+7ku75S7ptFoNJpHjziYsHP9Ot3dLRVFEI6HTHpHTPoD4iggCicM9vemDtY4nAqr0umWJFimxf7tm5AX4HsQp5AdmxvC6VDMhxrTEhUat1qhXG/RWFhUsQqdlVWiIGD9qadozi3ilMqYlkWpVqexsECe32vq0Hzc63VBbkZL19pswOsHhVF8UBMDHoJJaRqNRqN5eBiECeMoZTCJGYYxv35ln9Ek5JWtAa5rMQgz8izFiBMOJxINYBGGOfNeRGK4TMIEwzWVHNqLZbxVqtaRoADv2FEqya4JJeU8DcS1moNjyjAsQ6WwToVTCQZI1fq5kkXlq5lEOhVgPTVAS5JZRUAtlIQqkuz0/eKglZaq4niolrhjPQpKKtZAogYkd3bOrnKQGtRtA7OAcsViHMNyo8RTa3V81+J0u8EwjPjBi20mqcFSs0QUZ9imybmFGqaYA9JcCbCfdD7sWuHll19WwtZJoUn2I8WcbsHWnETcqzLQ7M6dO3eHfj3s/ORP/qSaDCyRA+8FXatrNBrNo4+Ih9ForG7udXe2lLB49etfpb+7RTAaUVgW6WRClkjXl8Hw4AApVvNUZiWA5/hESTQVZKWkDieScyQTRl/PS02PnbAPCUa5SjEZgeXhVX0VqxCOQ574vh8iGg6YWz+FZRs4pSpnnn6WUfdQ5bpK11uexLRX19R1kviwWWzDJxldr787tANWo9FoNB84/UnMVm/CK5sD9oYj+kHG9n6XkdwNt22OhmMGQUbZgkrJoJlZ+FWP65sDLL9EFomoWdBwc+LcpZkMSQobny5VXLoqmzWnj0+uPKsmFcl6NafSqMil8rpNRqpelVFemRJWRVSVKlFE2qkLVuRVqRptqhQqQfa4bMTBxTr+TnJhbUzGamuSOSvLKiyVXMLc5UzH5SnfwzYzohx+6NI6Nw+GXFyo0mmUWW9XcC2D8ws1dgch20cjzs3VCJPsruAqX1uiwmo+dKRoE3elOBQlm1MypMRF+mHdSdd8/BBnsUQ3/Mk/+Sf5/b//939sxFeNRqPRaO6HwcEB4WjInkycP9xh0uvT3d6gkMGOlkt4dEgwCSiXKyRppCIILNdhuLdPY2Ge/sE+hu1gmCJOihPUhESsD8c8LOKruFtLvopBuPjpzxIMB0RhTGd5Gbdcxi1XWTpzBq9cxfY96u0OXrnC8OiI+vwCreW1Nwiu0WSsXtd8+Dz5iNXrWoDVaDQazQfCMEzUcKh+ECsh8We+doODUYxnW2wNY5xoTG657HeHTCYZy22X/SCjGqf4vk33oMdSyWJvnFC1RRiNyYOU2Mwp+yXGgYQAmEyUAOoQE9JkSIbDSLldp65YKfvKKiKgwM5zAtNUHlURV2VIVwNLuWXrajiXhAiIEIuKKRhjUFP3+MXTKoO4UN/b2IywWal5jDMLI0+peTanFqosNsqcaXvcHOZKUK24Fk+ttkjznO+5OK/crY6RUViOihWQgmG5WVYP4aTbVTtfHyzys5C2a43mzfjbf/tvq/gBycP93//3//2jPhyNRqPRaN43Ei1g2haGYdLb3ebyV77MuHeoWuuTYESWpCrP9XDzNWzXptGZU0KtabtSOBH2hzh+if6+uGEtivEIu9FWPWN2tUr6IU6lf2dMsC11fKVGg8HBPpVGi/Nf+G7yOKYxN8foqMfaU5/CdVw6p9YxTRvDMLDErUuhBonVOvNqa53V1weSnXS7avH1wWI+QvW6jiDQaDQazfsWXeM0Z38Ysrt/QD932DoKuL3fYzIa89xejFOElCd9mF+WHnt2DiPmajmD3KZGRJhJOEDBsB+y3PYY5h7j0RjSsRJU5X5hT0msqXKeStkzwcOmICBU2aslWbMwGRoWlXxM16xTJ1Z3Gj0iAjwcRIwVV6xHhTFjfBVqIMKuQQWTUK1Td1LGRQkrL2iWc5r1mhritVb3uHBqlVu7XZY6DUpOwfpck+89P8flrQHDJOFUq8woLvjUWpM4E3ervtf5XtC1gkbz0aH/+9NoNJpHg5Nuzd7+LnmWEfS6ZFnOa899nSRO6e5sMzzaJQ0jLM9VQ3Mbi8tsXXmVUrlCvd1mf+MObrlCmkRE4zH1hQXi0Ziw351GEDxoSmWIYnAsSpUaWRxTmetQb7SxXJeFM2fpHezjqBzXddYvPUm5Xmf7+hXldJ1bP0N/b4e5U6fVoC0RYTXvHl0vvDv0p0KNRqPRvGvCMFST0/Nowmv7Yw5Tn0EYUnVLkGWMJwELzRq3R0OW7IBSxadr1TnqT3h23qBhFXTcnCtHMeMooeIY3BnatCWzPwjoB2MwS8RKNB0rZ6uDQZuQHjJ0K8YnIVAhA45ys06wKBsJdZFUTZsVEiYU1AgYUqVuOhzmMbXjcVk5Lk3LxSEjyzIca0JqlWj7MNduY+YJjWqZUZhhOS7ffWGROJdk2Yzf+elTfOrMAqZpsNGd0B0GPLXeouRajKKUCzJNTBytpv4zq9FoNBqNRqP5aNyuErslOabjbpdxv6v6vPxSlaPt21iOh2Hb2I5Nc3GV4dEB8WSMZbsqhmBueYXJcEAwGuD6NmkcEE1iDMdheHhAEQTgl6fZr+8C6TKbDrO9B8tFTea9u6IFRXYstkYgA69cHwyD9rwMxCphug62YRKMB6xeeIql8+c42LhNrbPAhS98D9V6E69WZffGVTUc9+ynP68EV7k2yxce+wCuskZz/+hPhhqNRvMJEUs/CKdrkuX0JjFpHGPHsN9P2ewmXN3vc2a+ws9/86o0IPH87S5/+AcvcXl/zGdOtbm9e8RaOWOt4fLy7TFzXsZ+tUKrnNOuuGwcTDjtSM4r9FM51hAzD5g3c4LcZawiAWBMQRlLDdgyVdKrOFkTqmR0GJMYVZJimug6JEci8yumS6nIiPMJbbNC08zppxl1r0IRDXnqzCLDzCSKExoVl+VOjWatzpm5MoXtsVS1SZOEcWLSqZc5P+erNqw4zah6DqutMiXHUmKsINdJo9FoNBqNRqO5b8IB+O/PQSiiolcuK9erEl6PDlVbvRgJZMjW3q2blKo1Nq9cIQpHDLuHnHnqWYLxCNf1qHfmmbgetuewceUK9WqJamcJS4ZxHaREoz6likc4HoApAV6S4SWBXYK4YF8XVR2rQMXC3l0mPW02WCZWnpAWJ2K3xH0qEQDJsfjq+ZDlkMbgV5TDdvWpZwiGY4oiVbECi2fO4pbKtJZXZJPkSUFtcZE8Tpg7dZ5au6XONQ4DbNthbk0yXl+PFDj5tUbzoNACrEaj0TzivJn4OhNU74eT6+Zpwm5voFr9XTPh16/uUTcT7mx1MYoGjlPGTSZ8asHmqNujlAVsbkaqcJPBXJ26zdkFj3wyIA6G7ByN8EslepGB53sqqqCeT+gRKyE3V1muDktWQmw71IuM7SRn2QhU4muQ94/9sCaOX+colErPwjcLWg7EqQmmzZId4pYqXB1a1Eo2jzc9DoOcs8unSQqX9YrBhbOn2N454gvnF0ksh3bVo+Y5LNR9bh6M6FQ9qp7NOM6U01UeQsXTf0o1Go1Go9FoNO+De8XXeAy2Px0g9S7EVyHPczZefoHVS0+ydeUyh5u3GBwcEokYWRIjgYntOMytniIadBnsbbOwvEC4u0FkVmi1KzTrZcqOSX93k/FwQsk1lBCaxDG+ZZCnE9VPliXRcddXSlJq4SYjIon2ymXoLbhMiCljOja+CZMkJ7ctZBCDIQOwrIxoLPV7oZyqfr3J+HCX1vIcRqlOEsU05xfx6zWWz16gsbhKEozprK9SrjVVfd9aWmLYO6JUrqpzd0slkjDAtCz8SlUdhxZcNQ8D+lOjRqPRfAK5X/F1vzdU7fwySMq2DI6CnOFwhGX77AYxc/QoVzustEuq/ai/v82leR/Hs3ht4xanWx6D0ZhkklGtlhiPYrJ4QC+U5qMU1wxJopySFJg5DKMAKTPPWCGx6dFNMlxDQgJyomjIIRYlJjimTWL7BFFEatrMVUxGucuCPSKkIE7BNwycagXfs0hDm1bF51NehldrcGGtw3qzxPmWw9raGrtHfdK84Lc+/SlsyySIM3Z7Q+ru9DqdmZsWb4KIsBqNRqPRaDQazYeGe3+DnuLJhLwoSOMQ0zLJs5x4EtDv9pmPYo52t5VxYuXxJ7jz8kt0t7YZbF1X3w9394ksm0arQTIZkbktyQKjv71NnoSMkwK/GEEyIHSXaFhj0rRgHMmA2oBms4IVT9ifeGR+hVa6w1HsqvG14mVdbLnsTZq4SZc4rVA7tUiwN6Tsir48gWSEb3t4Cy0l6hZ5TmqYNBfmWbr0aWzT4dznv4hjOzTXVjna2KTSaCjXaxpHOJ7P4cYd4jCk3p574+WT2AKN5iFDf4rUaDQazV0molxmKeWSz1ZvgmdMU5q+fuU2WRxiuz7b/Yj97gEUCeQWHStUU1Mj02OJkG/vuMz5CaZhcGP7iE7VouOkXN8O8CseZhRhZQmu5TBJMwwrp27ISC2DHibn3ZhuUaZchGRWAzcPaVkmVSOjbAYc5A26qc16OVftSacrEbtZmXoxoe94lK2CugltJyG3DdbmyjQbDc4vNFQo/0FU8MNPrbF/NKTTaSLJAdVKhflmlSwv1DVwLZMzC82P+seh0Wg0Go1Go9F8R3eamyfK1Tnu91QWajgaqmiBNAnxyxWS7g7f+Ed/XwmpzeVTdG++iimRWdE+9axLEckwrR52EZEebGO31vGKAd7oFnF1iSV3wHiSkuY5sVGhlncpewbjSU5Z6vKyryIDoiBhpVOi248o/BIt18KIR6RehSgc0yl5GI6JMz9PcrTFWs0iSS2yuQaEfSrzLbLIpH7mAounL5EZBqValTSKWbr4OK7vU643VJRBY36B+tyccvs6nqeuRWdt/aP+cWg0940WYDUajeYTwttlwcprrusqUXJOWu73elRdmyBOeXGrz3LZ4ueuDHDMI1omtBhzkLh89fouT62WmQxHjNOcPE4xwwPCSYJlO/hpQNKN2cLHLjJGI4jMEvVkwFgyVI0MM+sxycoMcOkQchibWHZKZFdoZqG6g34UZyy7OWOzgVPIHXUbL5oWghUpzEKTPB3xhfUycwtLjMcpuZFRcy3Or6/Tnmtxfqml8mt/qF0hCEJWl+bvOoFnl8UyDcqu/tOo0Wg0Go1Go3m4smCnQ7UgGw4oqjV2rl+htbzG9svfonBKRMGY7muvYFkGdtLFNetkk022vnVDggmoVW2Koy0sI6S68yWGeQMjOES0zFJwXYJUaZRTtnp3yMwcv5hg2GWa1QPizKJkOrRKIVFmkOPh2iHmcoejYULZntCWqK7Uxq56lJ0JtYpPFE6QhrLc2CfoNGjlmwxbn6fa6RDbLUrhFllljvUv/Bh+tUatM68yZv1KXYmv4m6dxQfc+6zRfNzQnzI1Go3mE4KIr28mwh70huqucksEU8/iha0Rjy3V2Tk4Yjjokw8DXuq7LJkTllZX+cpzlzmaTGgUI5Ydi8H+QMUA3DkIuThX4nYQUsoj6nZMZPh4nkceBSQYGEZGPT7ElCj+rKDiu4zjgjknZDcrYRUlWtZQTTMN0zGJN0caBKx4BoZpU0uHzFfK2PkIs1JmbNeozDW4ZJvER9u0ltZ5+uwq4eCAdrNNu1GhWS3jOA6+77yeZSvb0lECGo1Go9FoNJqHCRFfwz744vqcEgcTiqJQAqy01ju+x9FrL1FbPsvOjSuEkwAj2MbLE6rpAUbnKXqXbzHe/SqLa+eYTPapmiMalkFiBvh+mbi3yby5Q1IUWJU5qkwIRkPKMnCr6tBMN3BIGNHAqHoEkwn1yoRB1qGT95irDNgYVXDyPU4t2uTDAWl9gSSJ8JyMIKuSp2Pqi2cIC59qvUkWGizPLbBQWqR2+kk8xyb0v5dKZx6nXAXbw/VLdwVWGaClxVbNo4T+9KnRaDQfY6QYi+NYiZz3N0zL50iC9G2DUqmklnm+z43NPYr+mEk6IpiY7B/GXLuzx97WBtVakzQN2R1F7Lz4EpZjYOYx/eEQvBb5ZA+jXGfRDHCDCZ0iwLQtjCKFZEiRZhylVSpEVFyLfu6w6sYEccF8uUKemxxFBnN2H4yAYdpisWQwKjwadqymqDaqvhrKNUk8FUngVqtUmnN8rpYzKgxKnkVz+TE+//QlxjJU68kz6rqIq3d27idlZz04S6PRaDQajUbzUbta33yYVoPR0SGO7yvBNTZdnCxmsHUT06sSjvqYJGy8/Dx1a8jo6reoVEpYaYAZHlHd+iUCy+FstUt/7+uslRokwwNMt4Y92aHdnGeU72H6HbJoRDO9TWCW8QhxC4c0jbHIqJVznLhP4S0Shjkto0/TDyUmlmHgstryVY0dJCaV2lRAXZmrsrW3h2clLK0uEZaqZJlJWF/k/No8vcCh9eT3UW7NKXG1FIUqy3V27icRMVajeZTQn0A1Go3mY4xhGO8ovspAKclvEvdnmuUcTlLy0YRKM0XGW5mmxXgUcSUdUisbbG7usbPjcOvqFdqtCsngkFe3jqgZIxKzTpJmuJM+RZEzGe8RUKboDig5E8KooYTSWhGRFLDkwEbis+RE7CUeRTyhbccEhscZNyVOItxChnE5qh3KzKFh9TGTlIrVoe2kOJ5BnGYsVQusuk+7UqVZr7IVOJy/dIFSrU7Vsan6troWddsmSZK74uu7GTqm0Wg0Go1Go9F8oNyH+JpEoRqgJe7WNI4JRj16d45YW5+navsMRhPc0S3swGRp+Sw3f+0f0Wy0ObjyFZrVFt5Rn+hwF89tYzkJi2FAnS4RFk40wPOHlLKb9K0atWQXp1rQj/qsV2IMK8BNC0qdnCgMaJRGDPIyFceg7hWM8xHLcyFhnJJj0K7GxNgUaZdqY528cHDiQ9JSmaZnU16fp3bm0+xu71KfW6H0+A+TYFNptmm11yFLiPJCnfdMfBW021XzqKMFWI1Go/mYEUWREhdFfL0fHMmBMmA0GnFl+4h6pczu0RHFSHJaU2qOSU7Br726xXK2xwv7GV9Yd0mKlM2DCCPq0ah4XN9Kqdl7lDGIsxTPiEjyEo7ZJSRnkDgcJSENMyRWd9EnBLlF0xxBCutOpHJiVZmVx1iWQy7uXVPyYftULYvI9MkNcEwP0yuUYze1LBZbNZYX5uiPA86vLRAUFt/fbrC60MY0TSW8iqNXo9FoNBqNRqP5OLleBcMwsc2UcPs6LiFWlJPuXaEfb9BYu4gx6JH298h2nsd84Q7lkYkXVll0UorwNm5wQLNaIul/FS90iIsQJ7dZsBKsvCBOCxw7puUdSvIYTQP8UpmikGkLhRp0GyY2ZT8jTTPmjQF1y+EwK1Gnh0p9dQOcDGKrhJODUepQsQNyy+So/BSdU4/hhdsUc58lXTxPo3aAv3wRRHQ1bfBq4JTU45179zSaRw8twGo0Gs3HbGDWWzlee+MIu0hUMZUmMZsHA6oVn0a1wiuvXlM5rZnhMuwe4Tk5L7/4DZbmazw/yFivuGRHN+k8fpbK7stsdWsc7R9iFRlBYRD3+5SKCKuAQQ6FIZEAYItrtSjwLQvfilVAf5wb+GZMNzTomBm9wqdjh5TMHNc1Gec5SWpiGQnjzGDJGTO2DOXG7Rc5DUL6SZ31hsuFixexipRqrY5lmlxYnePMmTNUq1UmYawmsA6HQy2+ajQajUaj0WgeHNEQ3Koop2/++puJr9GQQe5RZ6IyXqPRgG5/zJI3wupcYPiVn8ZtLRJ4c1T6V8gaZXj+pwn2nqDmGCSHGzjGBGrz1A9ewi9Mkv4dadbHI4JwQpTBxJKBuTAyHKI0wTehYkPJksMt040nSBqXJ/FhTJ2okQlelmJgUbMzJcpGeYxppDSkRU0ivXBwLOmgy5XAW4sLaF6E8z/ASqlFVJgw90P4ovCufhq7uQ7jI/AqEI3elSCt0TyKaAFWo9FoHkJm4uvbCbGz14UEi3rJIUkgznI15MozMl68epu6W2DkFuPwiGGUMdg/JDFNDsYTXtvaYqVd58uX96nkId/80gZZkXM42FflmG8a5HlBKnWYCeMUJcJaIqgaMM4KItPAyjJSQ4Zb5aqQC+KUugnS+d/IYiYJJCYYZo5nmNTsnMSQYyzUfpLC4iiH1XJBbe4Mn55vUa/WKAyT+YU1OrUyfq1J1bPV9ZCIgVplKrrW67qY02g0Go1Go9E8QMTNeZ9u1zzokhkl8tyiboZgl5Ug6eVjFqw+vPzzhHOX1NyDZPNlCtMh3n+ZtpGQhnuYr95i6DhUupvkdok4PqBsTChCD4MIFwuQQV0wyaFlqeYzMBIWHTAN+awAg0yiviZUbek2kxWKEwcJvmyG7PVTFFGWXIm6WA1qjOULaKzgzZ2FchuWnyQKI7ylJ8CuQ2sF3BLYPuQ5VNrTjdna86rRaAFWo9FoHtCwrDRNcZx3l0V6UnyVkHspk+rHeaaDMFHCZ5xDt9clrfoYjsfW5i1sv8xrNzfZ3d/D6DS5cv01wtihtTLH9Zu3cT2HIE2xx3vsjPeQtNSe3D0vCroppIXPvBtKKYdjQSk1ifIcRwo4aTnKp4Kq1GjyHtuBJBNnbEGam1TNnLCAUSrFW45jo0Rc15BSLyezoFxALAIvBp1qBcu2mG/WMCybM2ur1KpVFS9QbXZYWeioc86yTF3LtxOlNRqNRqPRaDSad00STFvk3y0z8TWNIBanZwtMpXDC5AjTdDHHmzDpEbUfx9h5gXzcxShVGW9ext+7QmmyS3LnBXxX/KMZ9LeJMDEGB5D2qBoZ/SzBKyoYIr4CMSmx1NfWQO0qNqB1/FFDfLnV2RcSSYaIr8dfHx/aSURsfSs89b4Y2k9AFkKtA63TsHhJOXm9c0+C4+J1zqp8V6UE26/PYtBoNFO0AKvRaDQPAMlrFTHxvZJkOWGSMV/zlQhpSct/mvH113Z4bG2O/a3bbOKwsXuAY1vs3bnN3nDC/HyHL732GulkyKSw2Nu9SpyC6ZiMshTHsMiKjKxADccaFuAUcrwh41jcriKWmkjkvhRrFQsmUlMh7tdpASd31VOpAg2Dhl0wiAvlbhWHbCB3048Lv4GJEoszw6AtLlmgYhbY1Tq+WfC5zzxDuVym3W7fdbW2Wq03DNOS89ZoNBqNRqPRaD5wJKf0/SACrGxDav5M2sZsRoMBztFVvGoTdl/Ge+3XIOhD2GNw65u0bYNhVsbIeyTdLSxyUgKiLKWu6t6USW5iWjlNC6JsrMwR6nDzjOqJjxcnPaYfXMUsO3Dh9HdDdwO+//8LtuQZLEBjGeprUG6CebxHSw++1WjeCi3AajQazYdAHMdvEA7fq3gorfaScSpCZMXKubnbY+fgiOW6h2UUOEXC1VeuctA9ZHtnT+6TMwxjeqMQI404eu0KoyJXAmmcJkoszTAx85SaKcJpRpiCDCLdz+UO+vSmtWMaZLm4X00SEWyNacSVirnKp3fCaxbKLZuJEGuJsFocC7ESeSC1mUHDKuhlBk0RWiXs3xIXbKGcwGW3xFy7gVuq8sPf990qx9W2bSXCCtrlqtFoNBqNRqP5UIjH4FbeuOy9iodHN6G2OBUhRXjdeh4ObxA1zlE1YvJwn8HuFbIooHztHxE3L1Db+wb1OFTt/bU0ICq6zI7Guus6TdXrZWuawcrd5VOktr7PmbzvAROcuWl+6+KT4NXhN/0xaJ6BsA9LT73rQWMazScdLcBqNBrNh4AIibkMm0qStxya9U4C7mAwYKs7Yr7qcXBwwJ3tPTYP+uSmyfbNAUZhsLt1h8y22dk6pFHKlViLUaEoxmqC6ci0iGMouagYgH4sYqkIsgZRZqi8V8l0lVQDCegf5dDxICgKDFOep6+JsCpnIc8S5yTFXv84NsqyTVyJFTAglBgCaW2yRLSdrtC2C7Wwbk9F6EqlwurqKk8++aS6RjOhdWFh4YP9IWg0Go1Go9FoNG+GZJQK70dEjCdKfI2Ge8RhQs0IGG68AqM9asUEb/8KbH4d0y5R37tGb3iA11zCu/aPp44Ggtddqypn9fVND6R2lnkJb+Pf+NDE19rFad7Ys38QWqegvjgVlktz0FwD1t560JhGo3lLtACr0Wg0HzAnB2e9G/E1iiK1fhAEKhf1cG8P1zT59teukZY9qk7B7q2bbGzsYvkeRjohjRJSMiYxmKkM4JImoT5Dw1ZtS2EONU9ynwp6cY5jWSr/KaTAtYppPIAxDewfipPVMNhP5LmYxgvI+eTTZ/mLIe5YccPGMiPVKFSmq4ioYu41xWVrgGVC1YKe2t50+65hcO7cWeUKPnPmDKdOnWJ5eZnRaKQyXUWUfaeBYxqNRqPRaDQazQfmgBUB8d2KiNEIvCrR0Q5eY45o7xpeFsGL/5DIr1GbO0300v8Jgzsk1VVG3U1aoq4WXUoish7svOlmRWgVt+tMcBXx9cEi07qqsP55mH8M1p6Fcz84HTaWy4eMMVTmIQnB0fW6RvNe0AKsRqP5RCFi4fvJYr0f7kdEFIdrlBvUfIeNrR1azQa7B12icZ9JlDAaDjGKDNfzeP7GdRxCdezDgYTsF4wGY2xxrEYZBZZyuEqOq4ioJctWRVtfxFcTjCxjbEiilKVy+PsZNO3pffdeDmVzmtdatmGUFcw78jxdJtsoHTthJWpA7rTLfh1zKr4OVabrNNg/KqbbnSE5VTNX6+nTp6nVasr5uri4SLVaVYKrLJuh8101Go1Go9FoPuHk2et5oh8m9yO8Bj2wPeV0HaYWtXBHuVsxHbyNb0Cpgjc8hGhCvPVt3P4mmWXgBVKvBzhHB7SUm9V6Rzer8E6vf/Achx4016F9DuYuQHUenv5noNyaXiOJGyg1pw+NRvO+0AKsRqP5xCACpgyw+rAFWOHN3JwHvRGNisd4PFYPyXW9cuU16o0mt2/dJCsMvvalL9FcXObOrdtUyy637uxBESrhNDgWQ0kKCstQ7tKKZ5GIWGrCODep2LmKEpgJoAeJQcu2lDu1Yk+drhIFIC5WGaJVETFVogMk51XyWWVQVjF9lnUEyW0VtVa+F9F1hqxXMaZzBsQZm6g+qEKd99LSknLziuAqma7ieG00GuraS/6r2q52u2o0Go1Go9FoTpKG35nN+mEh4qLfeOOy/oaKJxgO+9TKJRjsQNClJi7XLIfudbj8C1Bfge0XIepBb5saY1UHT4DyiQgBoW6I9fVhojQdntWQxxKc/r5p5MDp75kuc6fzGBT3Xh+NRvOe0QKsRqN55HirVnYR/x6E+CpRAif3L8cjwq9nFdy4cYOdnR0lUF69eoWDgwHDUY9chm0d9uiFI25t3FHv2xEhNC+YpDm2iKhZTmybZIYMyJpm44s2WpjTmIAKCePCUsJokWZ4jkXFLESvVe5YiWRt2BLnPxVMJc9VXpsF/YeS82pMX1fHnU/FWdmeZbz+9UyEPSnGVqsVlms15XhtNpt86lOfUtfaMAyVg1uv15Xw+iCuv0aj0Wg0Go3mIefNxE/hQYmv0fCN+5csWHlkMWx+m5rkty5/iujVXyQuCoruBslgh3x8hB9tUSNWwa3idRUv7VANooVZb9eDjxB4KyQOTVrYSlN3a+sMzD0GK8/AwiWoLcFgE+rLUJ4D+41DhDUazQeHFmA1Gs0jx0flrIyjCNOyVKapcOXly5w6d5qbG1tMBj3293Zpd+a4fPk6N2/e5OjoiH6//50bKqbt/CJ6xkaO7U77kQzDVE5YiQaQiIBEhmGJaHrsUBULa1mEVsl0tSwlrhbGsWtW6srj/FYpq5Rge+x+nQX4y3YFmZml3K/H34vo6twjunY6HRUlIMLyhQsXWFlZUfmuIrLOMl3le41Go9FoNBqN5jv4iJyV+aQ3NQRItmmWMn75F6mcenrqZr3zLah2VMzAcOPb1C7/Et7eS8RpRJ3guOCG6MT2ZkEGtYdGcJUDkW4zH87/wFTQlnNd+yyc/i5wazA5gPaZ6YcAeb2+9FEftEbziUALsBqNRvMeEWen5LiK6Dmi4GBzk0azoRyvIrDu7uzy7eeeI3cdeof7YNp8+Stf/Y7thJmJJ20/IoYWkEstVEjgqkVuWDgiqh4XfNLvH8Vg2JLDOhVHFcfuVMl7dWxL5bqKDizriNNVNFgZuCUxBhyXZSLw3js9VbYh65dPuls9F9t28EolKiWfxx57jLNnzyoRdjKZqMf8/LwSXkV0FderOi89VEuj0Wg0Go1G81EyPiQrtYlGXcqlEsGtb1BZvAA7L8DL/w9WNKF/+WcpHV3GLc/Dt59jODqiYHh3EzNXa3xcQ9//iN0HgQt2e6q7lmpQqkOpAed/BJ78HWA5YEhW2T7MX5y6fBtPv+4C1mg0DwwtwGo0Gs27QERGiRjoTyLGvUPlAn3t9haTJGD/qE+nP+Drzz/PoHtEliSEcUSaHjf158eDBWzrDYKnbeZqkFWeg5slKtjfKAoVBeAkCYbjEGPedZ+atsQNZMSFpYpAcbpOU1VR4uuMmbhqnxBTZ27Ye5GIAMlqHQ6HSliVc5ybm2NlbZ08L9RAsMcef5zcdHCNnNFopIZmyTpvhRZfNRqNRqPRaDQPHHEhRAM4vK4KZ2v7ecp+g+6L36ZVKTN67nmqN/8J+XAPP+yTZClRvItLFbFVvD4i9o18uCZXVdW/zevVaT6rHESeQPs8pJPpssd+Mwz3p3ECC49DuQkyCEwE1sWnwLKhsfqdw8fEGavRaB4YWoDVaDSat0HE02GYMN7dJ3Ft8jigVCqpVvvdjW2uXr3K3t6ecsPevnVbuVan01unUQJ33akirooCa08zWpWYKsJplpKaFnFqUJG6S8TXMCJwPUo5xLaDm6W4UjgdZ0tN4wBeF2RnvFnDv7hRK14Zp+QqUVUGY4mILGKrxAeI2CrDwA4ODjh37pyKDhDhdDAYqNdEmJ0NMJNzlu/lfTJQS85Zo9FoNBqNRqP5SOlvKoFx8OqvUffsaY6pDPMScfL5n4LDOypWgO4Ww94GVRIGRUxmxGoWwkySHBaj74gSGB93hzUkuusDOVjZY3ZcuUtxn4C9AH51+vnBKUEaTV2sMujBcWH+ianwKu6K1c9AuQ3lFnQ3oLYInfMQi5vVgrnz0/VKEzVMjGQClgjLGo3mo0YLsBqNRnOMCIvi6tza2lICZZEUjJKINArojsdsvfAae70uS3Mtdu/ssnewRyaDse6OrZI66lh85Z6BVTNBNgFX/uVNJWJAogRsVcxJfTUj9bxpHqu09Bci2r7+T7XKrMqnQa+WbVOtVhkNhlTLNYzjoFYRWCdJQb3kKIeuiKoSByACrHwtea0ioEr+7ExY/cIXvqDEWbkGtm2rbcj3IrLOYgVmTl65RiefNRqNRqPRaDSaB4J0i0lb/da3GZbXYLhFLZ+oqIHyzjeJjq7jpSGHgYET7lE6eIlR0qdFNBU/juclyJAs6SJTy4y3znGtnJiLcN9YTdTEXL80bf+3JbTAAVMGNEg2mDMViN06WCZc+m0w2IBoBNWF6aTdS78V4jEc3YRSGzqnoH12Ks6WO1Mn63wP3CokATRWptdm1gLnlqfPnhZfNZqHBS3AajQfU0QoE7QI9vZi6tsh4qMImpPeiNyeul2ltV4yTcfjsdrGc889RxAESoC8fXuDPE+5/ZrktUrI6nFBpgZgvV6cjXKomseia36iaFMF2PH3J6IC7rpX5WdqmjiGgYONX/UYjse0W20mwUQJojPnqRyPOHFFgJXlcq5y/OJQlddERJUhX5/5zGeUu1VEV1lHvhaH69ramtqOPGbCq7x+7zWT12bINjUajUaj0Wg090eR5BgSyK/5TlTH2H18jhHBUkTFwxtTMXGwM22x379MbS6HF/6Pqaxx+8tYSYzZ32KQHtEhpTube3C8KWm4H5wQUwMRYt/POdhzYJch7MHcuWMn7tJ00JUIoyK8Bkew9jlorMPmN6BzemqAXXpyur5EBVz6MRgdQnURFh6D678K9RVonQLLnW7fb05drrJ8Rqk5fbaOowREmNZoNA8t+tO0RvMxZTboSPPuBFhxgjqFRZxHJFnO/t4e1167Q7tZZW97izub20RxpNyhIjjGcawmpKrspLscu1DThNR2MY3pDe2Z0Cri613366zmFserWvE7i/CZYFrYNmsry5imRWEYuJaF6ThkUYq5uKDE11qtpqIBRCgWIVUyWDc2NlhaWlKvyTn3ej11/uJ+FZH2mWeeUectgvPp06eV41WQ59nXWsjXaDQajUaj+YDR5fpbo9ya5ndOhJXcUrfKeNil4nuEh7fwD69MIwTE2HD9N6ZirKiYo12GYirNArJiQku6y44jBY4KaBsSK+BRNyIVJVCS107s7qT4Kg38ryeiyhyDUPyv4PoQT44XL4GRwNJTx8dtQHUeNr8JS4/D079LOXFZfhqcCnRvwfrnoTIHt74E3/VHYelpGGxN3a6l1jRKoL4Eq5+D4Q5k8dT9ehKJHFD7b3zwPweNRvPA0AKsRvMxRbWia94SaZsXpJVe8kyl9X7r1gZ9cX0OBlx77ZrqO9rrHxFMxsrxOn3DtJYq0ow4zrHlMs/EV3ltJrSKmGpZxwOujtuJpIic7X9W3Imr1XYp+y6GbamhXKVymVatSW/UpzW/wKeefIJrly+zduFxgkFXCbIXL15UzlsRTUVkFXeruFhFGJbHqVOnlGgrwqlkuJ4ceqXiE4ri7u+IiLF6IJZGo9FoNBrNg8VQhaTmTXFO1Kbh4PgLA679kmrRLw334LVfxxKhUoZp5SmMNsTVcPdtg2NzrBghRFidiajDY/FVqBnR61EC34EYEETVhZqIq+I2FQFYlpUWoboCkwN47Mfgwm+Cyz8Hp744da42T8HZH4K9F+GxH4VzPwz927D8DBzdgElv6nytL08/I4jIKrMi3ArMXZw6gJUL2J4O1VIHsfQhXWyNRvMwoAVYjUbzyCBipYiNIlCKaHnz5k3u3LnD4eGhcoK+9NJLjMc5pCPV+TOND8inrlRxtKoCbOoEFbHUTqTAs9UqUvOpDvxZlqsMyDKt42FaBqZlYlqWatkX4TNLcixZZoq71aFRb3BqeYn20jxBGFJgKPfp0vw8ju8rgfTs2bNKKJaYAIkGaDabSkxVMQmT6Z33WeTASUH13miAk25WuSYajUaj0Wg0Gs1DgYiO4vSU1n3Hgxf/IYw2p9ECRxtMdl9lOB6xSJe4iKczbU+IpyKuigHiDW7W2fOxUeLNslyHlKlVliHsQqms6ndiyU5dhag3PZ7zv+lYKBVn6wIEIyhX4PyPQH9jKpZ+6vdB0IP+Fsishku/fermlUzWbHG6M4kbKM9Nl824170q8QuzCAZdrms0nwi0AKvRPAREkzGe/HHX3DcyUEriAUScFKeotN2LcCm5p9vb22rZ0cEh+bRsmzJzr85yW6XuSo+zWg2DODNxRZqd5bOKsCl31dMMQ4rFQpZbGGJ4NaEmEQVpSqPZIE4SLl26RBHndI/2WF1f59S5c+oYRUg9PDigUq0q4bRjmpgpVNvTvFYRVSVWQMUdgBKPRTgV5+4sIkDiBYQ3y2l9O7RTWqPRaDQajeb9kUeZynI1pANKc/+E/WlLvgiS4grdfmnqHh3vws0vw/iAbDIiyQ8I8NSgLPGCzsZGSX+afVzKeypO4HizhUnJeKNqKa+J8DoqoGpI/eyrmn6IS83MqIm7NBrAZ/4AdG9PM1pXPgO1DrTPT4dbSdTB0jPg1WC8D6tzYLrToVfyWHx6OhhLslflIUYHiRNork0Porbwehbru8ljVUO6NBrNo44WYDWah4BPqvgquaT32xovgqQIlNJaf/v2bXZ2dpSz9dat2+omtbw2c4nG+YkIAEG+FsuriKjOsXipnKvgyp1rUWMzG9eRhSfEzdk6lkVuObgVnzjJWWp1SJIQz/doH2ezBqMxjz1xieFwyLnHz5NnGevr60oMljiE8xcuKHfrbOjVvYioKi7dk8KpCLcajUaj0Wg0mo8W0/uEZuUnwdT1eT9iosRxySMeQTKBF/6vqdg63GF4559SsxsQ7EG4ffct0uwvV7YsA7GyiEyMD8Y0LkAEVcl0lXq8m08F2NedrfldwXXanmZSGFJfR1T8BbBkutaSmtdQ65wDrwKVRZi/OHWtnvvBqeAqy898P2x9G6pz00Fa4nwVR+vC4995jiqW7EQdL0aHmfiq0Wg074AWYDUazUfGW4mvSRQrl2l/PFRO1q2tLXrdHoPhQImvInKKEKs4jgNQhgQDnNwCI5tmr1ompMbxv3TibDWnQizHYqw4Xb03/jNYN8sM8gnlkq9iAmqVGuWSS2dhUQmo4rwteSWeePwS416fQThi/cwZPNfFdpy75zTodlV8wJkzZ97gWH0z8VWj0Wg0Go1Go3nocF43B9zLcNCnVvKgfwfGR0SvfRlvcHsquu5dheEtgiJFpFt5SJ+X6iVT4mqJmhGoOr4sRorjOQtStqttH4urs+fWGxq6JH9glVqwwaDzOerhPjTWqItrdf4JDL88dd2ufBqqi+CV4Oj2NLu1tiiDHqZxACIuy0NE2FNfeKPIPIsG0Gg0mg8QLcBqNJoHjgyUOplbKu5WeVy+fJlut3s3SuBgb59JGBy/SVRWqbkkrzWdZgBYJqlk14sCKxmupkWixFd5gzUVZy15TSasijB7fJNcMC0cwyTJEhbabYZxzHyrw/LyCoPBEbVmi7Lp45Y8Kq2aEl5XV1eVg7Ver1N2fBqdJst5roZqzRy9M+rHg7HeTVyARqPRaDQajUbzkZPGaojsXWYzEyRS4IWfgfEetf4u3PrKNFpAFd0TukVB04BJYRAXBVXxQoigmsOcIUOzDBrisiBQUQEzR6tEDTSlVDfe4C+lZjgMJUpAtr/4DLXBBtRX4MKPMAxH1CWwII/g/A9P81y9KrglqK9OB2pVOhBP4PT3TDd+cuCXiMszgfndxAVoNBrNe0QLsBqN5k3JoxTDtVRG6QcZJSDOVXnIezY2Nrh+5Rrt+Q4vvPCCihQYj8cnVj4Rqi/jTTNz+q+WiK0ixMo/YpIgIAWhiK4ivsoda2M6PMvCIJu9doxjWpSqFYoip11v4eY2ixdWiIMAI4qpZSal5jzVxQ7VUklFB9iuq4Thdrv9hnOJgwnusfgq3O810Gg0Go1Go9Fo3i95mGL69v0JqtJ67/j3GSWQv/6eK78A1351mpV67Zdh9xpkR2+IEZBJBd6xy1VKd7colKs1E1er1N8G9KRmLwq6TB2t27lP1QjZKHzWjFBlv4aFQc2oMizPU5O63q9SK89PN/rYb4Htb4PXgckutbXPTgXhCz8CzVPT2AD5fFA6MexKdbx5r4uvwsnBWBqNRvMA0QKsRqN5U8x7WvPfjrcTHme5rftbu1i+o0RXiRV49eVXlLu13+upOm+WtzoVUo/fPBuWJZWbdVy9yTq2M31OUshlUJYMRrAolPgqB28rp6uBie+YFK7FE+vn8eaqzJVbdKMB7WqLzZ1NmrUGZ8+fZjAcKVH28UtPYJgmRZ7heq+f173iq+DKBFWNRqPRaDQajeYj4L7EV+Gkm/VeknDqFpUogaCr4gQ4vAEHV+HKr0zNE8MryqU6HQn7OjMXq2S0CrOoAMlyFW9pUFhYRo5NQaI62V4XIJZN6RyrsWT7DIsWju/Bpd8t02+pzT8GO9+Gte+GG78CF34YKkvTYV7yuWPti1P3qqr536bbTF4z3zpGQaPRaB4kWoDVaDTvizdzvw4GA6rVqooa2Nzc5Fvf+hZbm1tK7Nzb28PEoDcZTMXV5PhfoiydBtsfi69qkFZ2/Jp0BUm260yInTla7dn6FoXkv2JSbTZoWBXwLaqeR63TwIhSKrUWpZqD5Ze42FhUA64+812fZXjYp7nQVkKxDMuaMRlM3iDAajQajUaj0Wg0HzuiIbjVN7pAhf72NBN1uAPXfgW2X4YbvwSN07B/FYJDhkyU6CrvlOfNwmJVnKnHOa3V4+eZ8JoWU0esDM86knSw46JdhmrJNoZUqDnVqRN37jwUGXZ1Tg3Q8ucew5d81loLqvOw+v+B2jw88ePToV6N1WmcgFt+XThOQ3A/mcOMNRrNxw8twGo0n1DeTWzA2yHbkHxU0zSVuJoEEftHh2xubXLn2k2KrCALEvrFhIPDg6mIKkWaiK/HdaAp8U0ipqrM1mn/km9Mo1sVx/O2LCnjJIPKOF5P2ooMi5XaIoZnsLy+gpkYLJ9aJghDLjx+gTCKcWyHarlEnGVUymWMIlduWclnFfFVOCm+CuX6ifYljUaj0Wg0Go3mYY0YeDtkONVMiA3608FT289PzQ//9K+pPNdhkVAbHjJiTLV//e5bZ47X2TCsOSNTkurMcyqabnqipo+OowgEx5T3NxhZPsNsQH3tczIIAh7/MejehMVLU2F49dPUZXiuDMySfNgshuZpSMRzaxxHBkxnK9wVX9UOtFFCo9F8vNACrEbzARIFKV7pwf9nFU0meCeySO+H9yq+nhygJcLr1sYmhmVy+duvMM4Ctl+7w3g4ISCSm9rHQumxWCouVjPHKiwyUVWPBVeZqXV3OJZ87U7fMnXISl6VSd0ukxYpVsXBcR0ajo/bqOLGMZ210yyuLKjjckslnNAkrI0p8oLFxUXVOjU73zgMcEv6TrlGo9FoNBrNJ5EPRNR8L4gAOhND75P3fJwnh2hNjqaO1sObcPn/AbcON/4JjCWNFQYMlH4q30mzflccrfeOgBBjhJTuapDW9PvZOuJ+lYa2ITaOM09JOtryEbXWGYZuk6rnY3h1OP1FapV5hqVlaouPK8F1GKXULA9WnpgOx5rls0Yj8LUZQqPRPFpoAfYTgBKcfJ198yD4KMRXtd93Kb6+H/I8Z3tjm3QU8tzlF8i6EYfDHv1ggBkW9NLR9C643Mk2prEBTmqRFBmmKt7ExSo9ScWxwmqBc1zRJRJBZZDJ3W9ZxYKK6+LUa/iOTctv4rsVGitNKrUyzXZHOW9HvRFGLsO1putVFhqUSqfeIBbP0P8taDQajUajeZjIskzdLL63ZtF8OHwk4qvwLsXX94waopXB1/8GLD0OX/4r0NuENIL+5tRZmvXvri4yrV3A5Fh8bU5LcpXvOikcVs1EeSb6xz7UFIeSWgP2C4/UWKLRqkKWU20tYYigWplTDtda6zxDr0UtH8HRLbA8aiUP6o/D/GPUZHCW5LjeOxzLk3ADjUajebTQf+U/ATjurBFE86jzXu/oz+II7o0lCCYBpXKJW7duEU4C8iSj3x1w+/YtwmHI4d4+Q8RpCkZukB8Lp4r0uDnJgsScul9z+VWc5bhKA1NhY5qQS/9SkVHxS8R5RqVUotWoc+bcOQwjI49CSq15VhbXmAQ9qlaZ9ullxuMxFc/l9PK6Ou9oMsYrv+5ulQ8yWZooJ6x9T8SARqPRaDQazcOARCKJAKv5ZPCe6nXJOzXMqav1pFN05nCVWnr3Mgx2YLQNlg9Xfha++lfp7r9KTgmbI8RTOjzOapVc1nEO9rHgKoOzJAJMrAriclUO1yJRA7YSw6BCoURYw2xiFSOGtbP4p7+XvNJmIqaH+gLj1ily06JOynDh09SsCCe3ieuLuKe+OB32JYKr5Rz/8h8/33tOGo1G8wiiBdhPADLRXfNgEcHPELvnA+a9iK9SBM5EV1dmlBYF3W5XPff3uhz1jlQMwNb2FnsHB6T7AX65zNZkE2J7mtOaZsquKsO1zMIiNdPpvy7yWULEVxFjbXk+nkaqPmPYariWZ5Uo1XyWyh0q7QZJPmF9+RRm1WdhYYHhzhFzC01SxyEOAuZbC8ytLanjrVQqSmBN4hgP+w3i6wzLPi7sNBqNRqPRaB5SjHsHJGkeyVr9PdXr4lyV349ZpICK8SqmsQLidL39NTJcrKNXGRxtUr/zFSZJQtlxYbJJkjssmEds5i65GYtRlcKw6BUZcyaMjwXZKPMxjZSumRIWEBQurpliUqfilalUOhzVztOfe5Ik3Kdx+gns9e/i4HCfZtnGrq9A0GOQSfhrg1pnTR2tL8cqUWRJDM5bdKJp8VWj0XwC0AKsRvMhUCQ5hjeLp3+4EGF1VuRPRmNKns+gPyAYDCnXm1x/7hU8v0S312UyGHN74zZxPyLOYoo4p7ANDgbbpCK8Zin13GJcGBiZQe7mGHmBIxmvZoZlWngJjOwUNzOpVBp4FZPJOKFc9ajXG9SrVZZOnaZSONgNByf3sHwbt1qi0+nQbjQwbPstM2tFYNUiq0aj0Wg0Go3mvslyCrEOfEQi7DsiouVxvT4a71JtnILeHRjuEjVP4fzyn8C88KPkG18j3HgOe7xPv79DOxowLCwSMgbRAZaR0kxShp588E8IZbQCDpESYV32SIhxiFmiZXYxjIS8chEzt3Bsg8Aq4Z/7fvI8pHL604SBzdzyWfz+TezOaSg3mVt4Aobb0JwKrt8hpcp5SC6spUVWjUbzyUYLsBrNh4D5kIivMiTL86YRFEmSkEwiTM8mCxIcy+Fgfx+75HLtylXMPtw4ukXVq7B5+zYrtQV2dvZIrJgkTRinKTXTZJjklAsLD4swCxiXfMkQIM1ylSwgAq/pgpMU6vtmtU3bdYnNlJVTy5g4KvvJapRYbs9jug55kSmBteyXaM7NMx4PqdamRZpd1RlQGo1Go9FoNJoPDsN5OGp1FS2gWvKPP5ZLhIBbhngsNl3Vol/dvQr7N+DWrzEcjKF3hajwyV764xRpihHtE5hlleu6WeSUiZXAapkFk9ynaxnME+Aa0+8jw2BUNKh7Pnky4g5r1Ms+rtNWJozKhR+gNNggLi/gti7RXfgM7mSXSblBfaWGVaqRzZ/DKddRWWLCsfiq0Wg0mrdGC7AazSPILMvVsR3yOCOOAyzJX8oTov0h3e4RSZRw68p14jBlkiaM+l06Rh3iIckoojc8xMgK0iSikvvK8RqmGXXTYpwGFK6La7vkcYzp2rSsOnG1oO02GKRjluotmvMt1k+dZTDpMr+0wsGdHRrLbTWZdf38Re7cuM7p9bPqWKPJBNt1lBNhJr5qNBqNRqPRaDSPJJJ7KoO5ouE0hFUQIfbgOnh12PomJBOG3/g/qTkGw8mYIjriwD7Nle6EzxeXmdAgzTLCQnK+XObMPpPcYlJ4uCaUzQmVHJrAnrFG1zRZLplEjUuUkl1u1X+cx5aXaLfa7McupUqN3Mwozv0goVVn3jeJMofV1U+pmIBhmOA5psot1mg0Gs27QwuwGs0jIrZKlqsQJTF2YjAc9Qm2Rnh1n2++8DVqRo2FpXle+uZLZEnKaDjGCgtKls2AEUUS0o0iHNMlLxIm4ZCBk1FhmulaNkyGZo7EOmUVl7pRxsLAdS0V3l+qtKjULebPnsbaTqicruOWHIowZmlxhVKthnPRZXV1lXA8wjRNHn/6mbvn4ZXLH+FV1Gg0Go1Go9FoPiTCPviNqeh6PHBqe2Ky2H+F3cMB7XgL9+AVeqmJ4/jkV3+RflFlMDxkb+IzNB0+XezjFD32woBzTsghdcR/apFTGCktK+ZOsUKFIQvOkKExp5yySWWJseWS+21keENx7hmK2lluDCIudmzG7hwHS09hhEOMWk3ltdZai9TEiZsErJ7IZ635OvZLo9Fo3itagH2EKeIYQ09+f2SHBgT9MVmWYRgmk3DE/rVtqnM19nf2qNXrJHnK4fV9DnY2CYcTuv4ed758ld3iEMu2GeRjvNRVw6uGBKSkqgMqTEbUzQpDbyxx/mDY2J7LKOqx5DexSh51CxbsMqX5JiurS5SX5wi2emTZhErZpfVDF1XOfmGm1BsNbNdTIvHw8GAai1Cu6DvnGo1Go9FoPvGkMj3e1h/JHjlk6FQWQzyZOlxlCO34EK78Iqx9lv0Xfp7lc5+F7efIbl7jxZ1NWtkBVtjl9kRmIgxIzBpeukHLkC62OV7MYc22cM2cSVKAXScrMhZMSA0Hv9KCkUV98Ty3YwsbE6+9hF9tED3xe1iv2lzb3OFrWYtT800+92yVPAkxJiG1ugfr59Whb/cCatkIrIaKQNBoNBrNB4P+a/8Io4YtfdQHoXnfg7JOOl3D/gRfZTS5ap3bV28zjkeszq2QWTk3X7zKaBzw4sbzmJlBlKakoWQ+lYi6I5zCw8GkGjt4VGWGKoGR4hayFFpZmdvGkcr97xhVnMwkqBtU22VaQYPmXBuj4tCwHWorS1glk2ZR5aC7T7npU186jZEnzC2tMDw6otZuv+Ecap25B3wlNRqNRqPRaB5epJ7TfAw5MSTrJNGoqxyunl+eiq57l0mO7uCkI0aUKWQQ1a3niJ7/B3zzxS8zDmLuDGLmOGQzdwiyFm0OuZqtsIfPPCUOafIFrpJSkBg+ThHQsPtcL+bouB59Wkw6T2MXh7S8BOPU57GNBisVg37lDO78eRrj27zSX6S0/iwXkoAzp05TOA7hsEdtofWGc1hulgB5aDQajeaDRAuwjzCm55FEGc5DMhBKc//EcayGZ4noaucm4yQgOwopdarsvHCLoZMyvzBHOAiY86q8+s0XsDcCts0BlZFLK7I5ZICPQZjnYIbs50ecMhfIyDkqAjBMiiKhavoMipCl+SXCIMBLTS6urFKe72COUrr9LpXVBbwioV6ts3TmHMOwT6laZX5xkfFkwqXKCo7rEnQHlFrz6hzuFV81Go1Go9FoNG9EC7AfU1IZnuWojFaJEyj6W0RpwV4w4VTF4863fo5KZ4UtY5nLm/t8VzPhG7e7ZHe+QtVxuDlsY6UjBpnJEW3WCWgwokuNJXpU8fk0r3KFVZ61Ntgr2ixbKeHC9zPcu8JypUW19QMczT3L/PCbVFrn2A1DnNYpzM55LrRsbrPAeX9C0jpLJVnk6UqHIMnU4Tvu1Nlarr9RfNVoNBrNh4cWYB9xLOd4MqXmvshGI6xq9YHuM89zwiCkVC4p12uv16PuT4/BjgzC3QHD/j5G7nHn5RsYQUExznjlN64Q9cfcnAQYtq2iCWqFxX6xT2HapFmEhwuWRURADY+BGWAUBZ7hkHgFSRBRml+gQZ1KuYZVqfO5xz9LYOQE+3tc/MHPcHR0QKMzRzKOWT67jmvatIMOuW9QZBmNRkNluooAW2rp4VkajUaj0Wg094uOH3h3yMwD03/w16xIYwwRXd0qmCbDyRE1GaCVRiRJyss3dxkkBf0xbB78ApPcwLz1NYLty9wY1flKZNPhgIAqOzTocEibgD1q2CR8mUv8dr6MS8Id4wyhWefQtlkU40S+SHPt01wNXC42DKLOJeLHLpFsblKbW2Xw5I+w4ieUMMnSmItnzyqB+HSYUmquk4YJoVWmZBg6w1Wj0Wg+QvRf/Ecc03zwIQRFnmOYU+E3zzKyNMHxfD4OfJjiq8o+PXa1Sh5qIMKpZLnuT8hcg9H1ffxGFSvJuX77ZVzXwUlt9m9sMWJMthdiFR5RfzLNbc27VM0KmQzGSgtiM2VsZDTyMqN8QseaZ1QMMXyHIJxQ8mtEZkCl0sI3HaJgxPwXP0Ol2qBRKROPI+w8olzzWV1ZJltcwqtWaS0uUhQ5pVNlxgdd0nqF3APf8+6eW7mmhVeNRqPRaDSad4sMJX3QyM3/k/v9qETN98KHeZxplpPmBX4+UUJrVuRY8YihYbJ3bROvM8/B3kvUWh2ivU16wz57IRxSYftgyHJ8k4ONm7waLxBYHlkkFojHqZAQUeIFOuS4VJkQYLFPU6wSzBsRTzsjriWXaNRKrMWXob3AjckqS/UK5xZKxOvfzfzmZfzVsxwyT9ezWP3045SNDLO9wFxF9jfC8mtc3RlycUlq80Sd11R01cKrRqPRfNR8PP7Sat41aZxhux9N9EASR7j+NDfItCz1+DDIkvyhd/kWaU4eZRRJRmakpJmBhK2Od3rkhzHjoxHZokOw2aezuMjW169QhCn5MKO3M2TkxdBPCLMxriWCZ8iEBDO1wDYJSXBT6FoJfmpw6I7pWA2qmU3sJiyvnmY07tOem8Na9alVmlhHEdXzHbKowDQzojjFq1mc/+ynMbEY9ns05jv0HQOvUpEqHb9cVudTmdNtShqNRqPRaDQfBEmS4DjORzL4S/Y7mzfwYYqaHwdxN0ozrNEQI5sQFCX8ikF2uMWekbD18jVKzSZOkWPvH9KL6/zKV1/GHG5xeVzloBfRT4/YDWMlcUY8SUqCkWY4zFMl5IiScr0WmPwEX+eWcZ79wmCNPS7UYoL647RLEX4ywV56itXF38LL2yNOrz3F+fG3uFL7InOTa6x+10+wMtdmaXRIYNVZaZa4tnXImucQZwWuX1Pnc3Fp+qzdrhqNRvNw8XD/NdS8e8I++A1Ma1pQRZOxmjj/IJmJrx82H5XwOnOwvlkxKzle4igQZ8GsoC6yHLvpk++PiaMJTAomvQmj/QPSUUq2GXDn1TuEq132bmxQ88p0J31K2PihQxKnNIwG8iNNyKmT0bdTnCQnskMiueaZxVFpyGKpTdWuclQccfqxiww3tlg8PQ/zZVwMLj75FNgW+zc2aD69SBInDPcPmD+1ThSFRIMJ86fX1HG35xdIk0RFGGg0Go1Go9Fo3j9Zlt2tE2cu1LeqLT8sXFd8lw+Gj0x8DQcqm/Wtlt8bOzbGotxconc0YdAdc+dwgu97fPXAotu1ubWxybg/JPcq3NiLqRsWR8UBR2abat5jhPz8xLDgI5Wzi0mdsfq4Le7XJqaKF9iyz+O3TiOjkptU8C+cZXdriy+sN+j7KzyxWOP0qTW81T3yOKD6+O/l2TRVHXOLnRbBoIudhax0FtVxX1jp3P38p9FoNJqHGy3APuTEQYpbehc/puM/vqY1Lejei/j6rvf5ERIFKd4DPtaTBbLkrkqMwMkMr2h3pJaNsjHJboDRdBl9/TJxP2TSC6kXPrsb+xi1nGzXxHUtXMl6vX6EmRYqo9WQu9iZx8ScYNkuRmGyGe9Q8RuESU+yEui483TtEVbNJclGPLn4NCMvoFqpsb54gdBMmH/yixi9CVazipXnJFFM2a+y+PgalmUTmSb15WWSPMPzfOqn3zg4y/4IXBkajUaj0Wg0HxckYkoEzZmb9J2wLEs9Zl8L71Z8nd30/yjcsx8bF+wJ8fVkPJosH4YJo9Qgur3DKMsYDBMKxyR84WVeubXDK1GLowg2ukPmfbjenRCnEhvgykQFIly6hUnCKuRjJb5Kn1qE/A5ESnqNsIiNCm6Rs96wMIqUed+gs/AkrmnSnl/hqdoKUXmJ+sJZVpdsVvOCXphxMIpZX+iQmD5BnLLom9zIzpNlOfPz829yrlp81Wg0mo8DHw+V7RPMRyGEvu99PsC7sA9CfD1ZNMrXhWOQScxCqazEaktybicp6Tgmq5tk+2N6r+6QDlNSPyY9HGGFPvFgjBHnbJNiZJAPLWwzgdDCyQzlji05JkE6xjYMUsdUImk/6tF2OzT9Jqmd4VWaVNpV8smEi49dYnRwwHh+jopX4+ypS/QHh1j1KityRzyHoX1AZ3WZ8eEeQRbgmxUKw8JyHaq+T5HkuA9xjINGo9FoNBrNw4rk+3/cBnc9aMftAxFfj52tSZaT5QW2aRCmORXXoujvsUkd0zDYfO0Oa6eXeOX6bX7xxginiBmFCbcmNsNJzOhgSGhbdFNDymjuDMEgVPEBMCFC4rhiCQE73rGYXSqqI01omykNL8GxU2r1thJN/8jnmvz85SFPrbeolGosN1wOg4zVMyvUfJtwMiDFZW2uztXdESUzIzbKVPMRpUpDzfRYszJ8R3elaTQazccZo5Dbpw+YwWCgJqf3+33qdT2858Pm4+RofRgQkfVksSgu13QQYh3nKPV3D3AKh3wQYbRK5Pshw90uxf6I3m6PtJkzH7fYu71Hw6kySofspQdU7BrlwqFbxHhZQZLHWIVFTQRRG0bZiMgocAwTOzcYGBE1WzKcYopOCadZwo9NBpUhnuHRmF8iXy/TlNamMKKzvMD+zgG+5zKKh3QqHRK/oNGZp1SbZriG4xF+5cMbNKbRaDQfFLpW0Gg+OvR/fw+ej0NW6sOCOFgl33T2LGR5xt4gplZy6AZ9ukOTeDDCaViMQ4ev3zrECWO+vjNir9tlvtVk62jMfj8hU+7WspJYA+Sj8czNPDmOFRApNjxeNq2pZ8je68ZECabfe9ZlkvuEScpjS03iNOGfOW/SLerUG2JOKVhqlLhyaxu3XGe5lDHIPRolk4tLrbsCaz+IaZQeXEyERqPRvFd0vfDu0H/lPwF8FOLr+7mzHk0meMdDnx4kaW9aWEleazZJOHx1g9pCmySJ8KplJrtdgu6AvJeTlTxuX7nOgtOhd7NLUozwCg8mKcaBwa7xGuQeo2TCIBlSjhxsq6DnDfByhwpluumEzCrop30K26NqVSjMMdWiRLccUcur1JstJrWYUsfDtB1MC86fvYCZGxRJTFF2MYOMtYsX2Lv6CstPPI5hm3QkUqBcIUvTNwxB0+KrRqPRaDQazcPHgxZf8/EYo1R6vTX/YyIWb/cC9SzC6zhM+cr1fT59qs04CbAMl/1hwNWdmIPdTV7u2qxUM77+2iHbo4Q8s0jzjMNBymuHPfIiZfIdH4ffLEpCrpHMU+gSU8YioG3ZJDhYNjyztqze95lTJcLcpGRbfN+5Ol/bimgtzhONQxbclKWFea5v7vC9T53FtU1qIvD6DeI0w7Vfr9e1+KrRaDSPJlqA/YTzZmLnB+GYvV/x9c32/2GLr7N9ikjsJCaJmWJGBZbjkAUxQW9AvDHAs0r0rh8wPhjgGj7haER6NMAo2cRHEc4o5mp8mXbkqGmncTykbJUZpdP1IwLs0RicAtvzSbOMdtxg5ERK1HVdDwMP25X76hmpkVGqVqktdag6BWkJCrvg8bWLxHOQZBl+ZkPJIjjqMvfkOYo44eD2HaIsoPXEBWzPmZaNs2yx99miptFoNBqNRqP5aLlX8JTc2ZNDvN4LZqXynvf/IMRXcbeKSKm+DlKKOKbkWozCjIpvsdmd8NXXDllqePz0V1/DsSzS8ZhX9iYMspx2xeXaTpd/OumzF5QoGROGeZmRmFnF0SpGV2lBU4XzW332eH15lQkj6ipw4PxSm7pvc2GxhinDtTybp9eblEyLkifHXKgIgqcX4Im1JuWjMeGwT5CkfGqljlv11PnNIttOiq8ajUajeXTR6swjSp7lREFEqVp6W0fpmy3/IByzo26Xaqv1joOy7kdsTZNEDRUzxf75Fpw8R4kMkGLq3mEI4nDNopTMTun3h1RKDeI8ZPNbN2hfWCSOU8zdBNOzsDslBncOmLywh1WaxunHRU62MWAchZCllMwSrdQkSkb4dplxGBLlE6V9mlaG4dlkdoTv1jDTCaMiwihEaC0wPJ/QjKi7FQIvopz5VFdaVBaa2BWHqJRjByH+Spva+iLD/iH1RlvlyNZXFuD0sjpnv15j/eknH3iWl0aj0Wg0Go3m/RFOQjzfU7n+ZqX8loO87hU8P6jc2WAwplSvkGUZeZ6/5VCv+xFc8zjDdN9eSDxp8kizHPt4aPBJNo/G07q+WqEYjam06vSCmF//1i0+f7aDbxf83MuHPN6p41s2P//8Ntf3R7TdhAiHpIBvvjZAZuT2M9liSW239waR9dhhapyMGZjx+vfy/3JKjgtL9Rb9MOZ7zi2yXMlptdqYRsHpuolhOpxdbhGnOZYB9ZJLq+ISxBl5UXB2rgpz1amo7E+3PYtO0Gg0Gs0nBy3APqKIYOkeF0sfRTt/+UT+x73iazQZq/b4+xFT8zxT52IY73SHv6BIc/IoozAK8jRVA6ySNMI2XNU5NMrGlMsljMQi3B0xGfeplKvMV+c4urzP+PZtvDMtxl8Z0lmo0rt6xIgxjuORBDl+Knfj+3iGj+26DLMh1iQjIiaOMmIzpexX6Yc9anYTexySmxaTdEDVcPFsG8N1KYqIyvkqftqARs5abQXTkTamGGvBYzw4olRqYSw1qZeaBP0Bw6MB2AZ2vcp4NKJSrWJ73t1rpcVXjUaj0Wg0mo8XMyHVqt6/G/WDxK9M623LstTjJIMwof42IuEsf7XICgzLwHgTMfVec4hhGup9Yj5N0pwkKyi7prgmGAYJ9ZKDYYX41aoSaH/jzpjmYUQlT6Fc4jdeuMlrYU6tUuWXr19mMLE4GIS4Vs4d0+NoPGaSwHSaw1RffedhJ69/ThKpNqFMVRrOXPjexxbYPJyw1imzWPVpVz31OcN1HNZbZXUOq4s17HDA/iBU8Qc/+sQywahPHgSUSg01FGx2rbToqtFoNJ9stAD7CDETNmeinGV/dH/kT+aO3su94qs4XIWiyHFc7w2CcZYkOJ5PHMe47ut5SGkcKxF0huuUlABrVRySbsBwZxvLr1E/Pcdks0vv9j55mJMu14niMfH1PsO9A3qduhp6NTkaEo4igq9vq/U2D7tE6URFCRhByiQ+IkilRahCGI1wkzJhPsK1fSp+hXEQ4vgmk7SPbVsE2QSn5OHYNuOsT7HYwZ8M8ZfrtBfK5IOU6pOLMM4wqh5W3cUZTXBbPp3TnyKxEny/jOnabN+6wfzF01imoYTlWVaXOBU+CnFdo9FoNBqNRvM+hr2ahsrsF+Hyo+Tt9n+v+DrraCuSDMOx7oqJhQirlqW2JbmyJ6MNwiS7O1gqzgss28DJTXqThLmqy8++tMWzq03m6z4vvraH59psHHSp1Bp4jsmvv7pDzc9Zn2/x8o1d8Fz2RinJ7j77+yNS1yPOcjzG7KXfKQC/mfgqR6OMsffQsKBVsfBtg+++OE+GScWIeebZNazJAc35Fu2aw14/4uJSXYnFVdfGsU3yikc+CDk/P4+Mt869KoFhqLiCLC+08KrRaDQahRZgP2Tkbm+WFTjv0JIzI40z7Ptc962EzQ9alMszcaFad9uLVMEofT3vkTiY4Pilu21W9nG7UxwGdwtTw7MochXSRNSPMGyDLEtI0hBzbGC2pu7PPJBMKpfJdp9Kq0a83yMdxATdEWY1Zfh/bZDkMVajTHhlj3hyBHGBH9UJDntq0Faj2SExJySDROWw2rnkQZmUDJ8sjEgqBqW8QRDvkOOTFQm5Y1I4UAQZh+NDJRKX8ypd6wDbs/FNmyxPsBoei+3TVCsV3PoqUT1mdLDL4toFKqstrr78Mo+f+bTKofXOdMjjlKJUKDHYsWysksPKufPqOiRJguV62Me5rm/VJqbRaDQajUajuX/ebZTTTIR8L3xY+aknW/qz0Qir+v4Gr947E2LW0SZRX8axQ7bm2RRxAG6Vw16I49oYYcJuL6RaLuhUpm33gyBR77l1OGahXiLLc752Yx9JDfvW7S4v3u5hZzGDPCVNoHlUUHITkjzjy692+flvH+B4Fg1/zO3+9ANsgkcRidtVzlmyWFWy63fwhuUFFMY0gKBThlEEoo1WHJtLq3UWGj6tii9NZ+qzgO9UaVcdxu4CF5dq1Hyb1WaVZnnqZr12u8fFU01M06BRdu9et1rp9Rp9JkBrNBqNRqMF2A8ZlV36Lv7u3s+d8LfKdE3iSDlIP2iyVDJYpych2U7vZ0iXiKpydzwMU0qt+hvORTJelStAzuUgUC33IjpKPr6VQz4qoGnRzQfUuiWC233MBZfstYRuukNvz8UemdOMpX6f8PJrarBWc3WN3eevUV6oc3h1i3ySMDk6ZG5hmdxLORru4OQ+ru9gjnNMx2UUj0F+djKYKx7TD7s0/DmKNMUpl4jsAVWnwyTeV2Wda7v4tSaNSUK9tUy8mFNPynSzI4p6AmdL+NUWu1/+Bus//GkM31HF/lPf912E4yGlRl05eq2arZzMnYUFJoPBLKFKoQVXjUaj0Wg0mg+edx3ldB9GhLcSdfMwxPwQoqOknX82y0nE1/dTr4vbVc5wcnCA3WyrHNOZkCidWIejiKpvc+3mLvVOA2e/qzq1ktjndn+ohlOFO9u8chSzezQidx1sy2ISply+fUC77rE1TGmWbL5684gaBtWay85OxJoz5sVuyJX9kRJH/ZLNiIwgQgmungFjEVJPOFzlyGZVcnj8LMdfNcGz4SCGmgEx0K5C3bMYRTm/89kFldO6P0p4bKnBM6cabBwGXN8e8Ye+7zS+bXE0Snhitc52P2De9zAkMkFd71yJr0mY4pWdD3SWhkaj0WgeTfRfiIcMyzK/Y9Lovdwrvs4KLGOaJP+mr71bTgqj4u48ycntiVgoYfLiiJ2F70sWVBwF6v2zAm72HnG5utUWafH6PrLhEKNSUQJkMBwqVym+QdINlfiaXBsRtyw8yybdHWAmLvvFIbldkO4kBHcOqS4ucvDNW9QW64R3btO9s4/lOVhl2HrlFTrNU2xefhU/MJkYMUkScrC1gUOZlIz9YJNF8xShM4J0jGEWjOhTzts0WwvkLkRphCXuX8fBycqkWUDfn3Dq0kX6gz1wbDr1ddxOk/hwE/90m7miQm4aVBpNbNNi7guXqC3NkxkFw/0dcA0azaU3dTKfzNHVaDQajUaj0TwcREmMb729iHpSfC3imKIoMCXz9Z5BW+KmxXz3cQQy98BwXu9KK93TQTervWW/Uo/7xyKhCI6ubSrBdJZNOu5H+FVHfQ6R9RNT1ktpNNtEaabWSQcDrFpN7TPupQyO81slZuDaVp/M8TGZUHdMvnJjn92+fAYYcmrO58ZeQHccqpzZL1094InlBjvdIVcOAjqeQ7Vs8trNXVYaZX7tVkzqJQQhRDH004yyMR2NZR8Lr/IJRfrmxHYijWHimj0759ANEvohiBm1TMhO6OPn8HTb5fRSnSQvOBpHXFis45gmyw2PJC34wScqbHYndMol6iAItn0AAEHSSURBVJ7LWtVgrVXByWEiPx/gscU31uUzY+tJ8VWj0Wg0mrdDC7AfEW/lYn0vrUmzAksGVglZkmM55htem+U2vRX3ir7i3D0ZPfBW64tYqApAT7KfpvsM+iP8Sonh4QG1zhzhaESWeoy2AuprNVUo9q9dx7HrJHZANBqzc3SZxz7/DMP9I0w1fNSg0mrS39ojKMY4sUN/NOTo5ZusXHqGqDsgHPU5urqpttf0K2R2xN7GLQ6ONukULfIgI58UmKHFnWuvUCmVCWyHJBipcP5JHmNWM/JhTMnyyK0Uf1Jm6PUp202sNGNc9LFdj6gXUZufV07c3aMbtGtLWG6Fx8uPE7gW59pPyu10qucWCZIRbqNJZW2e1IzJMehtbbNy8QLzSY1JMKI5N0fl7IW7ea7iMpbMqFkcg0aj0Wg0Go3mo+WtWvnfrWNWhrDelVfTVKZvkccxpiw/VvJE+MzHk7cdyHXyeExv2jlmvM3nBjE5iGianRB3HcvgcBzhWya+zBroBSw3SxwMI+ZqHldu7vL42SWqns3/+/xt1lZb3Ng4YG+Q0GolPLXa5Op+j7AweXqhRtm1uNJP+exyRpbm/NKNHv3BhEsrNa4ehrxw64DL+0Nsy2a97eOZJhuHA67KQNxhRm3B4FvXQmwffuPWmPUy7A0L3EKlhiFn2xBDRgoTYzpgS854uQz7E5ivmEwGOeMoVd1r51oOqZkyDkucrU3r6lbVo+SYLJddnl1u8NhqnaNxSsk1+KxEgKU5c75NnGWsljzOdpZJRgl+y+dTa6271+79uIo1Go1GozEK+Wv/gBkMBjQaDfr9PnXt8vtAicaJahMqVV3yKFKDmuySzPT8Tt6piJi9LrEBEm/g+iV6e0c0F9pMeiNVfEpcqpmi7oZLHqs8B5MhpmNTqtbo7mxRJDb5IMYpObjtCgdXb+LPVYj2hpgVh+0rN2l7JeqnzrK3eRunVqHIQghyBr19DNumsE2Sm30m4QgTm9zNsDyf4cYepWaZOzdvUDZK+FaJ3IjVe8pZicDKKDnS2JQzDga0aytMenuM4zFOqYSVGviSWzW+xULrEkHUxfI8zCLFWW/S39ymvbBC4kk4f1O5FjJHclz36TTO4s2VaJ9aJ/dySvNN0s0xI+uIemuV3IyZJCPa7WX8apnChF73iPbc/If4G6DRaDSPBrpW0Gg+OvR/fx8uaS/EKptKmB0MA+q1N6/V3ynL9eTrM3PEKEqVW9Wv+sRpRqVSxUgTJsXU3SozGOJJqATJ1J5mmb640WMhGfH8CM7XbTLDohtApery1RsHfPFch199fkvFBNRKHuPxSAnAg2Gh8k6v7A45W7d46TBUYubNozEly+BUp85ef8z24QC3WuHW5ph6DY4G8OS8w7VeQpzCharJIMnV54rYgDCCkThwHZtAZvUa08FZYjaV2b0iJ9fq4tcwWZlrcDQcq+PyXEvl0uZpRr3q8cpGnydX2yx1SlQ9lwuLVZY9h6t9OT5bxSo0aw5uZlKqOrQrLtEoUbM7tNCq0Wg074yuF94d+i/LQ8793mnNskw9vIp7NyBf2pyyOKJIc9WvI+LoSVTAvPxHs9XFrjmYRoFp20pozdIU08oJdnfx5ufUMokYcF2X0V6PIowwm1XG+13yOFSipRR01tjlcHNTuUq9WhW3WVYFJmWb29+4hl1LGO73aA/nyE2HIhjieFU279zm9ms3MPMKYdjFNctMRj1cr8zoaIfISujUlznY28SzS0wmPTrWKoHZJzroUcMjdBN8u0wWuYwmm0RGDc+r0g8PSAnw4iZb6StUym1q1iITe09t1zQcvGqL3A5xCgO3VMUp+8SjCY7rIrfg0/6QfjNXsQanLz2Fd6tC85k1zJ7JKD5keNBlwTxLmAxYPHuB3Cjo3jyifXFZOZ3TNMFxfC2+ajQajUaj0TxCvJuBVzNHqt2cOmiLLKPqToXRYZRSl9DTE8h2ZfuJ6zHY2KGyukw/SFhpzgTbaTEv+aQLtelnAFtirjwY3t5hsVGmKFfY6k4o4oiGLx1lIaVOh5e+/Sq7YcHcYo1T7QZdw2a9FPN3f+5bdBarmHNz+EclVkoFv/DCbS4YAS/eiNjKHIowVjms/bhgte6yddTja4lFveQwDgJyx+Gwm7B1OGE0LlSEwPXemKYpnXrTQVhb4wQ3gsyC2+OcuhiBEzjM4YKItNj4KZytWdxMMpriFM4zDsT9WnOol1yGaUp/GFCxHMTk2wtylhuuEpVPtSusV8tUGz5rVZdBlnNrs0++VKUk7t21JuNuRHAYs3y2Ob12lond+ODnaWg0Go1GI2gB9iGIHHjDelGEJ/lQs/D+0ju3OKlppJInlZt3B3GJ6FpInZJmJIZFmub4mckoGOB5PlZqUThSNKZ4VZckyel192Fg4s0baqKoa1mMDgbUx4Vyb96+fpuzn71If2ODYBzgzlWZ9Puq9Du4fIVwEuCZFQoRfg8OCO+Mycc5lpFjdlz2ru2R5GOMscHB9dcIDvYx2w2S4YQ0H+H5VYxhQVDOSQd90omFWzaJBj2segVrFNKfHFErLZDGGUOny2B8hGuXiJMRS9Z5BsURo/EhnlNlFHXJnIJqaU4NPEjoUyt3sCQtdz7BH9eIwkP64S6duVVyx2TuzEUm9CnylPLqIsWOSbU2R/3UIsXApPX4Gn5qM14ukWYxXsPDzF1On34Gr15leOgQ5yFH+3usf+pxLAmmUpEOegKqRqPRaDQazcPKOBlTtsvTmvptmCQTys60ph/GQ2rV2n1tXwa5zvJfZ4O4iihSswWyXo9quUxyeCRTVwnSHEPmJPT7NGRo7WBEZ75JcrTPwZ1d9uod1ltl8u4R9twc4xde4dbpJUb9FGdwSPnxSyry6mrk8dl6yvbhEb7lcuXFV7lidOiML/PMZ57gV3/9BtW9CfPBi2R+k369ybV+TiMesftcj6RdYTgIVNxX2wi5HXhyeHgx1CseN7sRz++MVRZrToo/DvEMGytJZMwBu+MCaeA/OD71SgaWhLeWYDiGwFRfsppDxbDoFRmPl2EwgqWKxblTDV7Z71MxDfwwp9OpcME2KSyTM2ea9PcD5hbKbOwO+fz5ebqTEDeFJ0+3uXM05snTLTWcbM33OOxN+J4nlimXHUbdcPqjmKSce6yFNZteptFoNBrNh4iOIHiAiKDqOY4K4jfviQWQYVaSpxpHEaZp3s0CDYJAtfoXUaYGV1lOwWi7S2N9gf7mJo3VVQb7PUq1Kjuv3MFtQmNhBb/isfnqyxS5RXVhjuHmmLnzLXq39giiAFccnmHAaPOAtc88Sz7ss7Fxg0qljJ9W6IYHFBNpj1rESHsqd8nyXCWI3vzWy6w/cZGDl69jz7XovXabw6MDqvU2JbdJd3SdIjax8gr9wQ5GGjFMj6haLZXbZEwmBCpK36VQ80glJdWhwKBZW6A33oU8wKZGjSaDYpuSUVEDAdLcomzIrfMyhg2DdMhcfX06FlWEaMfEzA3KdoO+26cUOUqMnWQ9vFqDUrVKvTrH7WvPs/rYp4iigYo8iHZHrD/1FDdufQsvsFl99lOkVkLZrVCEGXbVxzRtFp48z2tf/QblpRatpRVGgwHJaMipp55hODigtbx632K7RqPRaN6aT2qtoNE8DHxS//uTj0WTdIKd23cNETMk2kvE2cKxKVRW6+uuV2n5t+t15VZVhAOy1MRuz5MeHeAuLdLduklJBs0aMVli4i0tqcis3i//CvXv+iIkAd1b29TmOoRJShAlpNUqvVdeoV6r03z2GV584VWq7XmMXo+NwwPczgrjtKCdbZMVTaLxhP284KmzK/zMlductV1eGAes+Q7fuNanZRsMfY8zjsHz/Ry7CChFOS8EZRqGSd/okdKklOwRFgvE0vIvuas52HmKbRrYhoVnwLCAJAfp7Yqz6XCs1BAXKUipLuvI91KvlwqoG9CXS5ND04I2sAUs1S0GRxnrNZtDAxUhcKHsMRhnXA8jHlurMkgyyp5FFma056oqtmESFywvVfi+xxa5fP2Q1bqPXfeJJzHff6rDC1cPKbVKnFqq0N8LqHs2peWK2r6gIwY0Go3m/fNJrRfeK1qAvYcHEa4ejsf4Fck5ze8Orupt7eHVS2KBpXvUp72yTri3xeHmNka9il9exMoj+sMBftkm7VsMxgfkBwHzj61w++WX6aytcbR5xLnPnmO4v8/e7gi7SKmvX+Bw+yb52KG56nDzuWtU7ZCSVyMtEgxabNx5iaW1C4xGt/GMJsPeNtG4j+e1iOMYy3ew8gRyl97hDmEe45kWQdqFxCFKo2ND9UBGE6jZpCYOubg/s4hcnacpvVbqFriJhUuTMD9Ui9+AhDxZImBOpPmIlBCTBrkq2zwaxhxBMSQlIlf7DGhV1ikccQHnuIZDKIKsaVA3OuReTNWuY3gumZNTSsskjQTLcjGNnNbKWepeg266jyXu1njI4pnTLJ2+QJYlbL30Ko2lBYrYwGv6hFlAfX6BNApZOH2WNI5x3uUwBo1Go9F8fGsFjeZR52H/7+/e4bEfNNOBWGPM4xvqMjQ1TxL6r12htnyKgRHivXQD9/x5+nsb7N2+zdnHniYbj5kMeyT7PSpf/DSDb30dd+MAw/dJzy5x+NWXaF+8gLl5C/93/QRHv/SLVPKU51pNnt7cplhsYu8ccj122HHLLEd9rMMeu5/9LOMXLpNbIZvuEutNjzv7MRkxG70hjdYio+AAx3CpLDT59pFFfzgmcSu0soSRZTIqcspRyJbfwCgcnNGY0LJksgKpVYKswLUd8smYtFSfRpVZkE5n/GLGqtkOW2LNZCiWLJT/M8HJIfFV6Y2TQsVWoxyopyDzZicJLHiQmVBXBgo4X7W5OkmZL2DddNko55RdE3tUcGG+zPUk4VTFx6k59IYR3/vYIjtHE3LDoNV0sYOcufNNNTTrcGvIWPaNQcmxOLVYpzcIac+XsQpoLVVIogzH005XjUaj+STVCw8bWoB9G9FVHKKSffp2hV93a4c8T2itrHK01cNPBzgLC0wGAV7ZZTJKcRwP28248hvfwnCX2Xr5Kzz++TMkgwpZPCb1TPbuDHGIsTKbwWgfy6lglRbZvf1NPLtFNtgk9n11B9wyPZI4IA0c9o9ucard4mA4odyqEU0qJP1NjIqPFzpM2MawHNJoj/n2ebqDXcJxgWWEVBoVBpMMNxtjUCFxHSwmROND8qxCUQTkmJjZkNyKsXDIpuqo+l9GCLENriyTXyMJdjruMcqKqbAqwqu8JEVc8fpqb7yYuXKvyi1zednGI0ME3Rm2EmxFfM0ZYKlmJcluLZMUE3wqOP//9u4sVrL8qvP9d8875uHMOWdWuSo9ULQxtLtFW/iqaa4RcNV+QYwSQrzwghC8IoQQbzzwAuKJ6YFBIHGRuKB7hdp0c41paDcu29UeqrKGnM8cc8Se/63135HldFUZ290+VVmZ6yMdZeY5EXHiRGXaK357/dciwrg5VRjgRtCiT3dnh3kyoUwyOttDyllB3OwwWt6n3+/hNVps7V6ks3WO9GDEwpvT7W7QOb9NWRVUpsB1IqoyJzke43VCNi5eJFnM2Lp4lfgbnPellFLq3V8rKPUkeRT//c2zOe3wzbWXDUpbrbe8j3SkyjH/MklJGy5VHBOezDCNBlEYUp6OoNmwR/09OfK/XDL71Kc4XZ3SPl0xv36ROIgpMbi39qlefgn/4lUOzRjv1X2GxOxvuITHc6Lbd1hsbJAuJ7Tfcx1/NKV87ZC02yU/eIXeBz5E9pnnSfd2GXkj5kmHrizMTcfMhhfYnJfMmzFhOcXH49WFIR32OFdU3Ci6vLyzzeXVPo3Y47NVl9h0mJUOKz9lYQa4Xk57kfNSawPHDQmqnGUprasOK2JbkvfyEaedXWnnlflY2HlljoefGgq3gWNSTBmBn8rRt7p+T9YvZgBxDokc0qukOSKWkay27Jd3ky0XsrCe8SrTaGWNgoSxoTQSy9sDA/Jfb+7BZSn4A2h5Lu9rh9yToJYK04xYJJntlo36Ee2lw/Bal0vtJrNZils6uH2f88MmYRwSZCW9Qcz+nSkbW03uvjzm4rMbdhFYb6tJqx/hy+xYpZRST0y98Ch7cgPYZApxl7Ks8NZdqA+rlksWSUq732N6MsVbzJnJpdzZGH+wQTI65fDmPlFfBrg7BPGcipjT1/aJhw3y0iXfnzA7WeD1uixv32Tlx4ROwWwuXZ8RZVrRaJ+jmr9MGe3apU8Oc3vUP5MxAXlI5htcs8JzIgoyG1BS7oMvGzu3yf0uppiCuQtOgeddpCxXeG4F0nkaDKDKMbbykTsX9op2Uckxfwi9c2SMwcS45ZzKTfCcBqUzW3eyyqXtrG5cXQ/HtxWUPIiEpq5cMV/awgu/7mut8iUEdUha560SrJY4pcxskp7YNbmTPKjx7XGsdbb7eterlG8yvsDYS/ASkBc2BJaZtzK8P3BDG44WrsvlC+/l7u3PsbFzhayqaHQ6hHHMeHpII+4R02Z4ZY8yLexrubk7oHftCqM7d3F7vv17sLl3idnoGM/zWI4nBHHDbniVH3fryjWGe+fseAH5J+O6sqxLxwwopdRjXSso9YR6FP79FUVha65AxnfluZ2V+kblfEExmxLu7JDcuGHTwMlyBOOpndO6qFKSF75AdmWb41e+yPWr38nB0ausPvNZBs99F+nxAav//hnbVJE5Do0v3WS51ebES+jdn9KuAl5oL7iyapGVS8owwjlOpGymdDzCvLThYurDnaHHhdOSaeyxbFQMJi5pXDKYwWlTqmqP41aLHQlmpY7NYdqNWHgBvUlChYfvBdxp+yR+xHF8iaRhGCQ+G7MDRkGbG5sXCFOfSVMW8DYxLYdl6kEcEVYBx1HArKxYhj166YqZ71O5McZxwStxKw/XZFSuQ2QatvTO3QpTSS0eg1nZDVlDx3Bqmx/keYfrqtz+qLYil/4L+YO8U0jk25d1MNvOsS0UhQvtCqIYOjmsQtiTejr2mFUlW47PqgXd7RbhpCQrMvLM4alzHRqNAGeeU243ebrZoLsRcedwTmu7wRU/pjdo8PLtE66c63PnpVO2LnSZHS/Zudan1Y3oDBvMRglR7OuYAaWUegLqhXeTJzKATVcFUcMnWeasJjMqU9Hu9UiTKcm9Kf6wyf2Xj+i1fe6/cANv0OHO5/ZphAWjhSGbVrjZfWZ5BwIH//SIpRlSpS/hRzvSOkvlX8TNXrILsHz/AmX+GkUwIKwcMi8nkI7T4i6OhJM2ZB3g4GMY4xZQeRtU7gg7IakcyTl+cOZgJNiscGTJlr8B3MEtQ4xZYgK5+p/SyLssgyVOGeG5GaXTBnMPt3QJ8Um9EmOvfMur0bRXsXGlklvYEQJuWVJF7rrKkmJXVpRKYOqtn8e6ozUDzw8oqxzflBRy7sht2fmteB3I5+uwdv3CS3grD7fIoSUbwORLlQ1iC1lSVT5IedchryuvTkBpcnwnpJAnZCpc2QhmCjvWwLHX0lcYeeDApe8PiTabFFlKf/sSaTnHL0K2z58nXy0ItmWBQcLWM5cZ3bpPMIjxcygWGc3NHoNnr5HLttkspbu9S3dz246L8OUyvlJKqSemVlDqSfYo/PuT7lWZs5q8+qoNX6uioHHlCsvPfc6ea3d7Gyz+8VMctyrK2RxzcMDBF/+ZxuYO4/ER5mTE7qjgJMjJs4JqNWKVQn8Or1yBp1+C0x60J7C/AdszOGjAKoDhwpb4lLJwalWRRy5eAoHsY1gHrpMGxAYy223g0JsZ0qAOHGUI1zJwOW5Df1H3GSTSERpAYwGHDR8/KFg5Ls3Swy8qbssprDRi5Jc03JCTVoSTlbiZi+s3mXk+w6Ti5e4WR+0+T83GzAOfm92hfU5H7R54Ma2y4MCXoawtVo5HbBxKryKqGsjQAuP4BGVC7vVps2CFRybdrOvWCwlb1/mqjWC9dfku2xvkR5WK2F3frn5XUn9etjpckg5Xe2atHkoWyMgCH7ayehRBI4SpD9dKON9vknQ9zuFzf56xMfTZcGPCrSaNeQLNkNDx6Dd8jmX57v6cD/27i8zvLRjstXB8l3Ses3mhQ6MZ0hp89cxepZRST0a98G7yxF0WlGAtn8y58/yUdHkizZssVxlOu8XpP32G1pVNJl9+jdNpSpFuUTnHFJl0pC4pTYpH1y58KrI7OMEFKqc+ch86FYVUHr5L4Uuod5vCD3CcgJwZrtfEdwoyVzpLO+SswB/iVnKsaUzlnICRMHEL31nim4mdfOqXRxRy1RqHOItJvDF4W5hgCWUC3pDKO7VXq+0HbVJzB8fsgTPFcXfrBVXSDetfIDEneElKGW1jn7A/lfQRNwqpvJa8GBCHYHKQP5dL/GKTIpzWowKcPh4LPHlNggWlTNmvDEWwPl8k5Zc83Ux+Tg83cKkKuRyeQ25ksj6u79rmWbl5IStSbehajyB4nRwxcjwbvkrYK92/D1Ru3Vfr01zPh5XXrcArXYpOSZUtGWzsMjq+zWB7j3l6SupsEbdjtncuMGvN8Johg6vnMVnJ0fFtujubBP0um+cv4bmunc0rHbBfbxOuUkoppZT61oev2f4BJ//0fxNvbjOZHrJ67WXKpy+T/H9/S/bBZyg/+d+ZFVNu5Sd0mz1e5JDhBHZf+Dw3OyCNoVsF7NyBSQvaSziRg2EJ7NyEwy5MQ8hb4OUwbkAewYUR3B9CO4F4JeWry8qDTgj+ov7aMPXxnIKFD1EGzczwmafgmbvrDlDHZSqBYw5HXewc0t4UDhyXeMOQuQUrr0EjhShdcRy0uDqaMYkLhmWbtEroL+YM05x73U2mQUy0yiljB+lbHaYn9v6e67OzWHGr3+f6eMys0+ae32KjKoiMoecXHBppevBJHWn18PGMIXVjGd5lu267xDY0lSq++VC/hN3jsP5YPPS5eP2r3DZb/1m+3gGO1qGshLPbEtpKn4UHpyFckg7Z9aKuLHao2j7NwnC8TNhtx7Yrtx0FbBiX3pUNPByytkdDntjhEr8ZwbJk91qf9jCmKycO01K7XJVSSr1rPFH/j2WqCi8vuPvCXRIS/sef/RfK1h7e7CaNzhYHd4+pvvgaReVQOSmlc0qQTsHtEpgIJxhSmZTS7WLCy7jVHM+VMQZH5G4MrT6UE3uEHkcudw+ppLxx9vFMi9L0iCvfHjsqi6mdV1rK5WB7LTkAR0qXOaUf4pgIzyRU0hkqpZCBIpBSJsCRSsY0Ma5ciw5t0ViFQ4x0hjo9TLAJxSvgNClcKYVkz6h0uC7BNZRxB8pb4O/Z8DR0QzLjEOcJSVSB17bhrJvMqKIupQxwylw8b0U5cym9tF532pa5UY26+lpIhbWEKKy7YyvPHnWqZHK/tAPIxP7YsRVoJeeSHlR3EhpLt6v9D7TurJUXyDP22NnDZHWX67gUVLQlaHZS+XFsmee6hrA9wDUlTbdBmWa0B9tsPvM03dGM+eyY/jPv5fhkn41LF1mcnBL3+xBXfOT/+DFO7txmcO4ccUv+GyillFJKqXdCOZtxMt7n89mLvOK9yBc+/ftcWEa44wX7y4DhZJ/u//PfWBhYSodlCaP5IQMJOwd1IijB5tEuNAu4ea5OF0/bsHcKh0MYt+DcCXSS+j7SqXrtfh3UurkcqTcYma/aglEEckJ/sYKO9+CYfWFPrB1vQH8J/gqePQIpxSXUTXzoSBPqOng93JbQERJT2T/LmbWOt2LuDwjSgvmgSZslyyhh0YyZl3361ZKbrffi5ROq2JDEHXqpwW3uYlxpVKiIUp88DHmvdPgGWywKw7MEbGYeX45dpqXLOdmh4MLcgYGRkNRh6fgUOETr8PVB9SsB6ca6e7V6KGCN1mV7b93hKuX3an3bbB26dtZlvNy+bjdZfy2FrnQO2x27Lu284ny/wTTLOVdAsNXm2l6H1Sil0fKJNkLGpwkXrvRIjxb4m03OPT3g+jAilKXAoUfcrMdRaPiqlFLq3eSJ+H8tO4A/anDn8ze5+cJNpvuG1Yuf5mSWkY9vEK3mzE4CMqdpL/MaJ8IxshgqJDAZSy8GL6xnnsrRneoWxuvg0LVXi6UL1dAkMgmpt7UuSST0dPDk2A89cr+PZyoSt41DgpGJ9KaDbyoqJ6d0DI59tBmuuUjqyFzXCj+Z40QDylI6auWbtfCXRxRxH6T7FIcq2MEzOYWMKCCtg1i/wq2OqOTslDexoaqMX61khmoygsYQjFyf9sjcNl45JpFr9n6Iyf06QJUO3myEI9mqzKz1e1BNoNGwn7Nl1vS0PlskH450zjo0/YAkT+x8fztnQKo218FPKyqpAKUbN4zX82SlUpNZsNLBu/6zfR1cTCYLAOSqvZzl8jFFZY9QSUPwwszwysqOIZDbx80usRvS6LcpY5/58YhL199PsUpp9jt4nYD+3h6Hr91ienJIGDfp7Wyzce4iWZKwffUpXBt2K6WUUkqpt1NSJHYk2HQx4r+98v9z9/Q1vnz7c4xeexEzX5DMbBMn55+Hz23BpbQOV6WLVfoERj3YmkAzhVETWikMTuu5pN05TNrQXNUjB5YRjGPYvwybK9g9qUcO3N3Cdlt+8Ro8c8dBDncdyoiCEvoTmHXAHUNV1J2yUrq2M9ujYI/Vy7sqCYPtjoUCpgGY0OF4YOjJwbfEp+kVpH6LwinYHKe8fNUnrNr00jZFKM0KLfbmBWFV8upgg8g1jJvnaZZ3CY1HFp6nkUzxow597zyLRsFm4ZCagNzkPG1CJq7Dot3mfQ7cBq6WhmMcBsR2rIIEpA+2X8jTHq8/zkujaV25s7MOWiXm7NfDyOzn6/NtdQkvtz+1Z/fqzld/3RU7Wz++PKZoVXU37LGBAR7Tjst23CAZpwwbPlutkGhe0DvXpuF7do7r6bRgdLRisN1m40KbdiciWRa0+vGbGjSUUkqpd4vHOoAt84pqNefk5iEvff6Ewy98kaPjDtn4HpUJqKq83uAZD5jb0kKOs8uL4lO4nXpWUhQSOSmpBI5ORuy2KMwUx4QU5sR2ucpcVh8ZFSChqwSpAa6Z4zl9KjmUIwuuzAzXiWxzp+tsUhkf44wpJPTFx5EuWDOSQQPkzvH6urF0lF6kkhLI3VmXQCV588K6tJEnJXtZKwonxjEdjCzPksVY8lnZnOXv4hcnFJxSmuY68LwCZlJ3xPqRPaNVyvH/UjpfS4zv4yUhpSSorUt4ZkK1LGAu3cARzKYUgYe78qi8JkQyXb8idnySoLQjHWi4dQ4tzzNJII8p7IgEubwugbZMP5Bu25hC5jzZRNdAQ7qHJcPO8YOYYjmXy9sgW1ylasyreohUWdnmWT8rKUKPJM8oqjGL+yOa29s02z1mizEmmbB34SmKNGd8eJ+ty+ftTNdWf4Nmr0fcbMHX2JyrlFJKKaXOVlZmnCQnvHLnBf765n8ivX+Hf1h+jjKDnimRnoWNDE5jmFyQI/tw47w9xMTeMQxncNSDmQ/3tyBcwGAO8249PetqWXe/7vfh/IksnYKBjBZYB6h3diGQ7lbpQ3Dh+m24s4ldnjVrweY+3NmqZ8WO2vDKLrz/Fow70JxA6IPsvpWyuzuDZaM+/CUn/4PScHEMt7elii/IWg0a4yWTpuw/gDJsg3PIpDshSGPyxjkaxRHTSE57hbSXCWXcsAGtU0VUvSHzMKJFhLR4hN6Q2CyYuT6tZovccxi6KW6esgwinjIw9lxi1xDJeoWHOlpvAbsPjRrw12GqxJvyrmiwvp0EqQ8OrjUeur/t4l23TUQPzYF90BXbW3fUPpgReyWXE4CGC0uPk+WM882QTjNkepTi9mOc05Rg2CSZ55x7Tx838Nnca+HasWC+/RA6HkwppdS71WMdwCajCYvJivHxCUE+ZZlJ+llQmhinOsF1dyjJMLLkSjpcpeuykiVPPpXnkMrZIjYx5n49R9UZklQyWkDC0CUOcux/hOtIJ+wmQTHB8zq2yMgd1z42HOM7OxSUdpaRY2SR1HE9rtUWTxXGhq+yaErCXUktfTBj3MpQOkd4Evoywi9PKbzLNJY3WTUkuJXn3LHjDowtnWQW7GRdBsmPI2VRk6K4aztUTbCLI4/vnOAyxK+W5KsUrzimkIVeUYGzzDFBTiWdp7JMK59QLCR4DXBbAdWywo82KMwCU0oZtgJ5XWVEQrEEI1Woi7soqWRUgoTIUihV0tHbsI/DTF7XlEKuYNtO2nqzrRvKHjCZ+SqzbUOKbAGlqTtg7bpVmUtr8KRDWb5eZVRS9QoZ7ZCucGU7beUzX41wWh5bl64yn494/7/5KKdHd7n03m8jakk5qJRSSiml3kllVTJajbg3vccr+b4dETZZTfD9mMbBwtbLEpi+tAWbU9jvwb9+CV4+B7Ke4NY2fGkHro3rTtRlALELQQVHDdiWuau9ehFWFsKkCbMGvP9efe3/pR3YnEN3VYeuMuv1srQ8LOCkBxcP4ahVd89uJ3C7C9/xCjSlR6KQEV4Zi6heNjVtRTSqlEUI3SziMEiZBy6LjQ6NlSyPXVIELU76Pr15g2mrxd6ize3dlMrtE/uJ7eo97e1g/KdoJYajjTm9qkPSbLAMNigaOWE5wE99TocNNsYGL3aJw0gOmxHJ3gQjTyi2Z/EkZN5dL7CV9yfLdTAqAev2OkwdrGe4Cn/d6Vo+tIxLHkdaQ9rr7lZ5C+M9dNvV+vEkzD34SguJDXMn618beESuRzk3hKFjD79VXZfp8ZytrS7tfojneXS6IXEn4PL75dkppZRSj5fHOoB14iaruyMODiImMw9/mZAvE3vUv3Q31mXCgEpmnkr5YCIiGmQyv9UGrS05KAPOJnCCX92ncOUlk6KgxLgNOwfWcXoE0rnqN3DMCOOE+OWKwnUIqz1k5KlfypVuY8cblPZasQyGkqVWEb50sJJTyeM6cpgnwCHHeF2MdOMaufYsj7PCq1JWjQH2HL6ZrwNXR8bU2/mvvP7YXZC5tPL1uI1HQFEd2nm28rWqOiXzDX4RUjRC26HrzWbk3R0oEoycr2qsd5hKN2sqoWxsu1CLqp67ZPPVoAm5lGiVXTpmh12VMqVVDi7Jc6hnz0rw7DgzKrvETF5TmRUb2jm3pVNgkgVl5uGYGOOs8LMlpQ2zV5BmEMn3lrEFKWUhM2h9CKv1DFmpzuf1lfeiopgf0t27QKs/ZPvyFfaefg+bFy5znve+038llVJKKaXUmsz2l47GF45f4Hh2zGJ0zIE7Z1otiWSUwBIGY5hswrgts1nhP38AntmH14bQyWHWhZvrKVI7p7KstZ7luujCpILOFLyoHj8gfQISqt7ago1TOyGL3VM46kCQw3AOr23bfg16Kdwf1IFtV/owSmgV8OULEKbSgZuRezCYYn9NgpQbW/VM2C/tOPRP5fMOSTilv+rSKzdx5GRep+Le5iXa0qWaw6Tf5up+n/3ugLIokfN5y/ZnqZz/QBkPODE+ebOgP/VIfReTN3G6hqHMcA0MiyC2pTCOb+vtwInJkPc7sW3VsO8Z7LuFhBaxDUujr7Rr2HYR+ZDd1c6627Wz/pCA1V1/Tl7ii+tQdT1xwdbeG+uv76/D1gezYqXH4qr9DnLSz8GvHDqyz0E+lbsEy5yNvR69rRab55s8853n8QMdB6aUUurx5T/WA/zvzFnNMlbHI1jMmS8rnColrGReqgSeFS4BlYSBtCmdef25qk+Ah5FQz1nZcajSnlm5EtQ6xMkBSSzlRknlSjhrKO0BnQbGaeOaBYUnk5GkMJNZr3OM38DYEQKn6+BVSpzEFi710XzphZXrxR2caoJxm7ZAMeYYnHPra84SVkaQn4AUKE7LFlv2unIxxXgjKke+x/26JDKvrksgj9JkOHaYq5RDMxw7GmFA0SihSHGKFnlDHk9CW1n6lcA0B79RL8mqSlhJ8Glw3Mw+bzuOYDWuby+drfJj2PmzIRQzfAxFKaWbhMltjF0eJoFpcx14Z5ROC79KbEiNK7eRcLZJIQu97G3k9hIAS/eydMLm0G7UZ8TkFZKzZeujSG6zTbPT40P/138kDkKe/tf/ltB2CiullFJKqUfJqlgRuAGfvv9p2kGbT00+hdvpcD8ds3fscRIVct2dL12ug0/Z63oS1ouzXtuAZ+/Vs11lxutBq971KsHosgnbY+hM6i5WCVjv7tTLsGQhlIS602Y9rkC6Zl+8AJMGhCUcDKC9hN4MJl3oLqG/gsM+7HfrgFbKzlJK4FxCXp/esmDUDZiFuaxgYG535yaETsjtXos4W7DfyvHSgJP+VRa+PKaci9siie/hO9/GSbvPazs3aOfb7CV99iYbJFEB3iaOkzDIm6z6hqocE4a+3QshqyCSlmOD0fqcvyFzG4R2GJr0tjoYOxrtgXr664M3fzLCjHVg+iBsDdajBSRQffA1Ie+ApPL21h2z2fprD+bByq9PrW8r388lpIsszq3P+z2QYmg3HNq7ER/+P58iaPjsXusTrscLKKWUUo8z/3ENX5epS75MWd69RehVjOYuKyI8v03hyVKuNtVyRSlzkoxj5776VQPjevZqdUELxxtg6rLGBqehFDZOTBL3cMmo7LVjCRVlbqldx1UHqY6Es1JYSZnh4ZoMz2lSmhFemVL6UuZIh60c1pHAUUqe3fVYA8eGr9LJWlHiODs41TG+icg8KYkyCDbAzMCGrRL8xpSedMBOwMj3lseXs1XSbSrdoSUE0qXah3wf392hcEu7DEvaWH23QR7HOFmAky8wsiCrOpVVpfbn8hIJcBMc49mfx1Slfb1yM8aR51pJWCrFn7QHxFBIcCpjExY4VYjjNKgq6Yh16zDXCvBsAJtSyPeR0QjSdSs1WiXPVSYsyCra9eQoWZAlC7eCRv37B1oygsGwc+kq7/mO7+LcM+9l8+JlijTV8FUppZRS6hFVVAUvj15mmk45WB5wtXeVT9z4BFVaMW+4pAmUsZwmkziz7n6VkFSu50uX6UEf5g1soLmzgDSEPKwPScnMVulobSTw0rk6tJ23ZN4sHFyuF2rJ3Fdf6s5xPbd1JrtlZezAPry4Uc+Lvb+JXWIroa10zRZBHdY2DGxOpC+h4r++B3xZQpv7uHnBohlw0ulSOKd0c4cvn2viFSHzzS6JV9Gfx9wdNonznPbqCrlTMRpOeGrxESqzYuXl+Bvdeinwao4XRCy9JS5NHL9jl5HZnodAwtU63HTcEI8Yad9YUki/qdzatnr08FhS2XcmUkHLO5gmHiMyW8/LMLQhHtKGktt3QEHdIIIhs7GsVO11lJvI4tt1lFuPP/PWt5Z1xIG0psg7n9dD1wcVu327UMGzzw547785T9wO6G23iJq+dr0qpZR6YjyWAazX6TC9vY9nFsSDHfJZTrc9ZSlnmYojkoZHtVriui1cU1JKR6bxSG2wlxKWEwqvK1GjXbQV0LSdmokjweap/XNuj/nLClTpwJTDOOH6WvB6BAATXNvVmoDbsx2oOO16aZW9btwAc2pHENjZqLY7VfLS+jh/fT1ZHmuLypmR2ZEJo/X1Z/mQWbKy6EvGpEqXbIhftCn8g/XX23X4Kh23ocy8le7cCQQyj3aKX0YUsrBLumA9H6+YUHmFLWqd8QQv7lNkCTRzysCAL8GrPLR0zJYUzgonauAtxpSRDG+V2a8S3JbgyOswtX+9jBeut5XKyIF1gCw/nx9RljKyIIdA7ivzYT1YunXAKo+ZyzKveqGYHW0g58SkcvZCnGbM3rWnuPK+f0WaLPi2j/4Hmt0ejY78N5IfX+e8KqWUUko9yk5Xp1wdXLVBrJSvzWaDy+Ueo2iJMRNymWa1KAkXxh68ko7VzIORzHUdy4gvaJWwL4NKC1jE4OfQWtULseKiDmNvduBf3YDbOzCO4JL0LDhw0KwD1fPzeu2Ak8LLu/X1/2lQP+4zd+Botw5xT3sxbpFQVHBnENNbJCRRQBH4zLOMIvQx/jn81Zh7O0NSLyTMZIZrxd2WR28x5PbWjKhqMkiaLFo9e9IrMG2SYEVZGRp5E68sKfyYvCXzbGW/wdK+Pg/6VyVulXECU0ridaerxLJyRq25vo2EoA/GDNTn6mr+OhYd1AMKbLuI7Uy1twltICvvQFq49uMBWftbyCxXXHv7hztb5WsS8H4lcq3fZcoe3a0LHc6/d4PQc3nqO3ZpDyS+VUoppZ48j2UAu5ymdHebLCYuk/2bBGZE6+kNmt4pk/Qid+4muDI/1Nkkzw8IiogyKwmLAxx3iOPEtvDKnRKv6lB4UmZ0CBiR0yO3R/zl8nOKY0PYFoYRURnbQqsOSkPZTWoLEWPmuDZU9TG221VCRQfHiTC2E9bHMzmlDS6b6/vLttMDjO0AldH4MjLgDjjX61H4Tj0yX1Z7uVVll2YVUnFKUGlnPWV4ZUYpow8qWWwlRZEP5V3wfAovw5i+nVnrlh6VDLuqZPnXHNOvKMppPebAHvEv6kxXSEU2aOPNXEonodwM7aQAT66Rh0bOk60PHzmYsImTTqDRhmQdGstcWbmJrK5NpLM1htir7yeVcEtC2jUZNZAX6+5XD+Im57/tac4/e53NS1fZuniZzfOXKIsCz38s/yorpZRSSj2Wy7fSMuXp4dOMkhGbzU1ujG7w7698LzcPX+ZedsiSxHZoLtoL8pYhCRwahyXdqWEkh8AkPAzrbtam7HqV7K8+VW9HBow7EJX1Yi4vhU8+B42sXiFwT0piUy/l6hT1n49jWZ5Vd7kOx3B3D+IU5v2QUWRIo4pRnFAFLm4R4BaFnTUrna/jZoLX7DOYLqnKe0xbe5j5Ma7bwHEHuMWUVjlg3shpZHISzeN+L6CbePhGelsjjrxDdswWbtAnC6TCL3BloK28Xq70l8pZNqn/v0Lmtsq8V9lhIR4Erm/0xsD0YW/8vDSQ1NHsV6s7aJ23vM+Dz4ugB5vn23z7v7toR5NtXe7S2YgxlcGV02xKKaXUE8oxdXvi22o6ndLr9ZhMJnS7Ujp8a6XLnKoyLMZzSgnwCDj+8pcZXLvGp//fz+EkKbN5wnLZJvZvMRkFVFVsj9b4EmpOZcaSj+clFHGMtxpROh6lLWukg1PGCkAlXavrrlfpdTW2+JHR9jIX9qi+xlzOKL0Y38QUjiMvuA1cjV0AJp23MpvV2KJE5sz6+QFFIOMIDuspTNIhKleTZRQqE4yRAFeO92xS2s5bWcTVXC/lkhEAsvRKtgrI507WYa+UUS6UJ+BJi4DMhu1D4WCHVQmZvSpjEIrbuIVLFa4LKTtjdj1/VZ6K/FFCWZn16vlyfgyyqj4TVsjzrMCTv1Je3T4gA7vsQzl1d6x8Xu7ny7Iu6YRdh7z2LvIc5f4PFWdxk86gz95Tz/D0d36Y7StXabS6NM/g741SSqlHx1nXCkqpd/bf3yydscgXnKxOaAZNvnD8BTzH4978Hq+OX+X2/DYnixOSPKHvdflS+iKNKiJxMzqT0p61IpKGBoOXGaKFsXsbGgWcRhDJ6gB3Hcyaej6sdM/aJk0PQukRcGV5Vn3wLJXDUyXIeoRUylPp4FxCIfNJy4JQZq4GHjtzj2lc4WcFRbxBkI/w3A2i1YrMD+kmO6zcI4b5M+TOksRL2Mqu2Vq7zDu0Smnq8OmUm8jKLXkyXXaoSO1uCululYpZjvM3iIhlLNo64EztQLU6bH2UyD7jOIJrHzzH1ec2Gey0CXyPqPVgiqxSSqnHkdbr35zHMoB9oyIrWewfUvgRWWo4vX9AmVTc/h932Lh2hYNXRjSqA+4dRmQnUzuLCX+EwzbV7JSsygndLhkz2y2bByF+tiLHw4vbeJ5HtkjwE1nYVa6DWR/HjzCFlIdd4mpMIoGkdHyWEuI2cc0Ur3LIvYLISFElYaWEqhGEcmQ/hPQYvB18r6LIZBFXCtEepKd4Hd9uS3WdBqRzTKOP62VU6QwvSPH9DCep6O1d5+T4LpW7ouM7ON0u6WT6+uh93y9JV9DsRrhhwejuAVs7V/EbFaODA1qNDmXkUY5H5JXD5rVLnN67STOIOL57i0COSBXrObD1VKr616gB0zGEsqBrHejaAPqrr5p3Bps47QZBEBPEMc9+14eZHB/zng/9W2ajE576jg9RFTmeHxA1H+qQVUop9djSgk6pJ+vf3zybc7g6JM1TpvmU26Pb3J7eZpSOuNC5wOcPP2/3N9wqDpgtjqlMRd8fclAe45UFs6CwKw9yaW2VjPK0hEgu6jv1FimpP0dS469PdEk3RewSFpBJU0IhNWoJfc9+3V9AYEcehLSmCYvIpZSO2dOSWdMnzlyiuImXDGknM+53pmxWF2jM2rSqju1hMGlseyLOF5dZJnOa2ZB20YOmQ5WU7PqXWJgRvdYQN4PlYv10e3L4y2ExlXFo0O36rOYFnnTzui6Oa1jODIOdmLLImY1KWn0P3/c4PcwIIxhsNZhNVhQSRNe7gu2ptf9VcR/ag5D5OOPSsxsMd9rkhexh6NpZrsNzLYrM6IgBpZR6gmi9/s15IgLYBzJ7PB6CSAoXl+n9OfgFi5OE5WRM/9we91854vZLx/T9FdPJ0i6rWkqIubHF/ssvkaURzfaAfl82kDrkSc7k7ph2T9avuixHx6R5TNxuY8oVReqRLUe0dy7TaoxIpyt7/MaNQhrtNuP79/CbAcUip/K7XP7AZe6/fIO9p7YIQ4d7N8bsvKfD6d3bpPOKS+97D37gkMym9Hc2Od6fyEhUZvtz4kaD/kaTyqvYuLBDnleYMqdIc7zExR82cLIli3RBkbm0hi3KJCfPMpLphEvPfZjV9C5VVTEfnXLx+vtYzVKy0wMyY9h75gPcfOF5PN+h1R/S7PeZHN5nOR7juj6zySmu69HqdHClOAx8OhtbHLxyw/6s0uWb5SmtTp/2cIO42SSVStPAxoVL9vdBFBG1WpRZjh9FOI6DqSr730sppdSTQws6pZ7Mf3+TZELgBcR+bMcUHC2PbK14d36XrMhoRS3+4fY/cDS7zzPNq/yX438ijmK7cMtpN3np5CVW2YpznXMkZcL53nlOZ6e8NH2J53aeY3+6z2w1oxN3GC1H9Ft9G/4usyVXu1cZtAbcmt5iO94iI6cTdrg5vkXbb7EV73AyGfFc90OM09fY3LpMvGpzK3+FLXeXeNWxq7CuX3iaO7M7BFmDS+EVRv4Rk9GMMjF0iw2uvW+P5SSjt9Uiz3Ki0ON4f2lr5Yvv3+Tk1oQsKfFCaeGF/mbM6DClKks2zrfJkorZ6ZLNCx0CXxaWlSznGa12RLMbcOfFU9oDaW5waQ1i7t8Y2cNrctv5JCFPDXtXuowOVrSHIV7oMztZEndCqtzY9wZRI6Ldj2kPY9JZZp/P+WeHTE5WxM0AP3SpyoogrMeAyVtKqduVUko9ObRe/+Y8UQHsw0Fs2PBJl0s8P8LJVnZMwNHN1+jtnmN8KEFiE79KyCcTyuYQ1ytoDdu0ezGje8ekSWpDV+mAndw7wnccjo5Ldi4NufvSq+w+fbkODUuZtZqzeX6b47uHtAcdDl++zeDiZVaH+zQ3e6zmOVE3pMoS4pYEt+D6LlGzyeToiK1Le4zun+J4GfORFFvnbFHkuA4n9+7i+bLQq6TIEzYvXLQ/l5D7LydT3CAgbn7luNJiPKbV77MYjyjLks5wwxZ38ngPF1APgk8p9oosrX8eGaPguPhBfaTI/vWR20ugfXxEs9enzHP7vd9KniYE0de+Mi7P/WvdVyml1JPjna4VlHqSPQr//mbZzIafMqJgGA+ZplPm+ZxxMqYdtFkUC1b5ikbQsLedZlM2402u9K7Yzz1/8Lw9un994zqrcmXHGozTMQ2vged6HM4Pub553TYNSD1bmpKtxharQpZhlRytjmgFLfIqtyMSJKA93znP0eSEyxsXYeqTRymBGzDL5mx3trg3v0+jalKsKlqbIb1G/dod7Y+pCkO73STPC/pbLebjxAacMjZtfprQ3fxKrb6cpDR7EWUuTREJrX6EJ+24tpH3jfW61OGOfX8jb+qihm9/H0Te67W9BKXSACL3WYxTGu2Qsqjs+6G3kmclQfjQQq2v8V5KKaXUk+1RqBfeTZ7IAPYB6bh8qyPtyWKOkbH/HvZI/IPFXjLHqEhXuL5vOz2X04LO8CthoryUcnVYCp9vRpHnZKslzW6v/l6TGc1e53/751NKKaXerR6VWkGpJ9Gj9O/vQRD7sFxOeJWFHVWw09qxn1vmSxuiSjgrQa2QmbISoPai3td9zK/nwePL/aRjtuE0Xw9FlVJKqSfRo1QvvBs80Zcuv9Y8UelCfSOZjyq8h+7TGX71yydXob/Z8FVIN6kvK0MffC8NX5VSSimllHrLoFRGFMhHI/xK16h0qf5L9/l6j/n1PPz47fDN7xWUUkoppf4letlWKaWUUkoppZRSSimlzogGsEoppZRSSimllFJKKXVGNIBVSimllFJKKaWUUkqpM6IBrFJKKaWUUkoppZRSSp0RDWCVUkoppZRSSimllFLqjGgAq5RSSimllFJKKaWUUmdEA1illFJKKaWUUkoppZQ6IxrAKqWUUkoppZRSSiml1BnRAFYppZRSSimllFJKKaXOiAawSimllFJKKaWUUkopdUY0gFVKKaWUUkoppZRSSqkzogGsUkoppZRSSimllFJKnRENYJVSSimllFJKKaWUUuqMaACrlFJKKaWUUkoppZRSZ8TnHWCMsb9Op9N34tsrpZRS6hH3oEZ4UDMopd4+WqsrpZRS6uvRev1dEMDOZjP768WLF9+Jb6+UUkqpdwmpGXq93jv9NJR6omitrpRSSqlvlNbr3xjHvANRdVVV3Lt3j06ng+M4b/e3V0oppdQjTsoTKebOnTuH6+rEJKXeTlqrK6WUUurr0Xr9XRDAKqWUUkoppZRSSiml1JNAI2qllFJKKaWUUkoppZQ6IxrAKqWUUkoppZRSSiml1BnRAFYppZRSSimllFJKKaXOiAawSimllFJKKaWUUkopdUY0gFVKfcM++tGP8vM///Nv+vzv//7v0+/37e9/5Vd+xW5M/tjHPvam2/36r/+6/Zo8zhvduXOHMAz5wAc+8JbfW+734KPX6/Hd3/3dfOITn3j963/3d3/HD/3QD9kNjHKbv/iLv/jf/GmVUkoppZR6d9F6XSmlHk0awCqlvuX29vb427/9W1ukPex3f/d3uXTp0lveR4rCH/7hH2Y6nfKP//iPb3mb3/u93+P+/fv8/d//PZubm/zgD/4gr7zyiv3aYrHg27/92/mt3/qtM/iJlFJKKaWUenxova6UUm8vDWCVUt9y29vbfN/3fR9/8Ad/8PrnPvWpT3F8fMwP/MAPvOn2xhhbrP3kT/4kP/ZjP8bv/M7vvOXjylX73d1de9X9t3/7t1mtVvzN3/yN/dr3f//382u/9mt8/OMfP8OfTCmllFJKqXc/rdeVUurtpQGsUupM/PRP/7S9Sv7w1fQf//Eft8eW3kiuvi+XS773e7+Xn/iJn+BP/uRP7BXyf0mj0bC/Zll2Bs9eKaWUUkqpx5vW60op9fbRAFYpdSbkuJEcT5JZT1Kc/emf/qkt8t6KXEH/kR/5ETzPs1fLr127xp/92Z99zceW4u+XfumX7O2/53u+5wx/CqWUUkoppR5PWq8rpdTbx38bv5dS6gkSBIG9Oi5HlWTu0zPPPMNzzz33ptuNx2P+/M//nE9+8pOvf07uJ0XeT/3UT33VbX/0R3/UFnFylGlra8ve5q0eUymllFJKKfUv03pdKaXePhrAKqW+Yd1ul8lk8pZFmWw6fSO5gv7hD3+YF1544WteTf+jP/ojkiSxt3t4xlRVVbz44ou2EHzgN37jN+yxJ/leUtAppZRSSimlvkLrdaWUejTpCAKl1Dfs2Wef5Z//+Z/f9Hn53MOF1wPvf//77YcUdDKs/63IVfFf/MVf5Pnnn3/947Of/Swf+chH7Byqh8lA/6efflqLOaWUUkoppd6C1utKKfVo0g5YpdQ37Gd/9mf5zd/8TX7u536On/mZnyGKIv7qr/6KP/7jP+Yv//Iv3/I+n/jEJ8jz3G5EfSMp3qQY/MM//EOuX7/+puNLv/qrv2o3pfr+1/+fqvl8zo0bN17/86uvvmoffzgccunSpf+ln1cppZRSSql3E63XlVLq0aQdsEqpb5gM25ch/V/60pfs0SI5hiTD+mUA/8c+9rG3vE+r1XrLYu7B1fT3ve99byrmxMc//nEODw/567/+62/ouX3605/mgx/8oP0Qv/ALv2B//8u//Mvf1M+olFJKKaXUu5XW60op9WhyjAxvUUoppZRSSimllFJKKfUtpx2wSimllFJKKaWUUkopdUY0gFVKKaWUUkoppZRSSqkzogGsUkoppZRSSimllFJKnRENYJVSSimllFJKKaWUUuqMaACrlFJKKaWUUkoppZRSZ0QDWKWUUkoppZRSSimllDojGsAqpZRSSimllFJKKaXUGdEAVimllFJKKaWUUkoppc6IBrBKKaWUUkoppZRSSil1RjSAVUoppZRSSimllFJKqTOiAaxSSimllFJKKaWUUkqdEQ1glVJKKaWUUkoppZRSirPxPwEzC3b9tjhwEAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot UMAP colored by Donor (to check integration) and Clusters\n", + "sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "44a42466", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cell_type natural killer cell memory B cell naive B cell \\\n", + "leiden_1.0 \n", + "0 16 0 0 \n", + "1 3307 0 0 \n", + "2 4 2 0 \n", + "3 0 0 0 \n", + "4 1 4 0 \n", + "5 115151 0 7 \n", + "6 4 13789 31184 \n", + "7 3 9320 19541 \n", + "\n", + "cell_type regulatory T cell \\\n", + "leiden_1.0 \n", + "0 562 \n", + "1 24 \n", + "2 6528 \n", + "3 5765 \n", + "4 8161 \n", + "5 1 \n", + "6 67 \n", + "7 29 \n", + "\n", + "cell_type naive thymus-derived CD4-positive, alpha-beta T cell \\\n", + "leiden_1.0 \n", + "0 2518 \n", + "1 73 \n", + "2 100187 \n", + "3 69940 \n", + "4 23760 \n", + "5 3 \n", + "6 79 \n", + "7 33 \n", + "\n", + "cell_type central memory CD4-positive, alpha-beta T cell \\\n", + "leiden_1.0 \n", + "0 51618 \n", + "1 427 \n", + "2 34061 \n", + "3 37446 \n", + "4 104032 \n", + "5 51 \n", + "6 145 \n", + "7 93 \n", + "\n", + "cell_type effector memory CD4-positive, alpha-beta T cell \\\n", + "leiden_1.0 \n", + "0 17521 \n", + "1 2570 \n", + "2 1341 \n", + "3 1125 \n", + "4 2417 \n", + "5 62 \n", + "6 23 \n", + "7 7 \n", + "\n", + "cell_type effector memory CD8-positive, alpha-beta T cell \n", + "leiden_1.0 \n", + "0 2877 \n", + "1 102572 \n", + "2 211 \n", + "3 150 \n", + "4 142 \n", + "5 8594 \n", + "6 35 \n", + "7 11 \n" + ] + } + ], + "source": [ + "# compute overlap between clusters and cell types\n", + "contingency_table = pd.crosstab(adata.obs['leiden_1.0'], adata.obs['cell_type'])\n", + "print(contingency_table)" + ] + }, + { + "cell_type": "markdown", + "id": "eb9e87c0", + "metadata": {}, + "source": [ + "### Pseudobulking" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "28538794", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Aggregating counts...\n", + "Pseudobulk complete.\n", + "Original shape: (777594, 29331)\n", + "Pseudobulk shape: (5584, 29331) (Samples x Genes)\n", + " cell_type \\\n", + "central memory CD4-positive, alpha-beta T cell:... central memory CD4-positive, alpha-beta T cell \n", + "central memory CD4-positive, alpha-beta T cell:... central memory CD4-positive, alpha-beta T cell \n", + "central memory CD4-positive, alpha-beta T cell:... central memory CD4-positive, alpha-beta T cell \n", + "central memory CD4-positive, alpha-beta T cell:... central memory CD4-positive, alpha-beta T cell \n", + "central memory CD4-positive, alpha-beta T cell:... central memory CD4-positive, alpha-beta T cell \n", + "\n", + " donor_id n_cells \\\n", + "central memory CD4-positive, alpha-beta T cell:... 1000_1001 562 \n", + "central memory CD4-positive, alpha-beta T cell:... 1001_1002 392 \n", + "central memory CD4-positive, alpha-beta T cell:... 1003_1004 414 \n", + "central memory CD4-positive, alpha-beta T cell:... 1004_1005 248 \n", + "central memory CD4-positive, alpha-beta T cell:... 1008_1009 656 \n", + "\n", + " development_stage sex \n", + "central memory CD4-positive, alpha-beta T cell:... 73-year-old stage female \n", + "central memory CD4-positive, alpha-beta T cell:... 57-year-old stage female \n", + "central memory CD4-positive, alpha-beta T cell:... 58-year-old stage female \n", + "central memory CD4-positive, alpha-beta T cell:... 74-year-old stage female \n", + "central memory CD4-positive, alpha-beta T cell:... 71-year-old stage male \n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import anndata as ad\n", + "from scipy import sparse\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "\n", + "def create_pseudobulk(adata, group_col, donor_col, layer='counts', metadata_cols=None):\n", + " \"\"\"\n", + " Sum raw counts for each (Donor, CellType) pair.\n", + " \n", + " Parameters:\n", + " -----------\n", + " adata : AnnData\n", + " Input single-cell data\n", + " group_col : str\n", + " Column name for grouping (e.g., 'cell_type')\n", + " donor_col : str\n", + " Column name for donor ID\n", + " layer : str\n", + " Layer to use for aggregation (default: 'counts')\n", + " metadata_cols : list of str, optional\n", + " Additional metadata columns to preserve from obs (e.g., ['development_stage', 'sex'])\n", + " These should have consistent values within each donor\n", + " \"\"\"\n", + " # 1. Create a combined key (e.g., \"Bcell::Donor1\")\n", + " groups = adata.obs[group_col].astype(str)\n", + " donors = adata.obs[donor_col].astype(str)\n", + " \n", + " # Create a DataFrame to manage the unique combinations\n", + " group_df = pd.DataFrame({'group': groups, 'donor': donors})\n", + " group_df['combined'] = group_df['group'] + \"::\" + group_df['donor']\n", + " \n", + " # 2. Build the Aggregation Matrix (One-Hot Encoding)\n", + " enc = OneHotEncoder(sparse_output=True, dtype=np.float32)\n", + " membership_matrix = enc.fit_transform(group_df[['combined']])\n", + " \n", + " # 3. Aggregation (Summing)\n", + " if layer is not None and layer in adata.layers:\n", + " X_source = adata.layers[layer]\n", + " else:\n", + " X_source = adata.X\n", + " \n", + " pseudobulk_X = membership_matrix.T @ X_source\n", + " \n", + " # 4. Create the Obs Metadata for the new object\n", + " unique_ids = enc.categories_[0]\n", + " \n", + " # Split back into Donor and Cell Type\n", + " obs_data = []\n", + " for uid in unique_ids:\n", + " ctype, donor = uid.split(\"::\")\n", + " obs_data.append({'cell_type': ctype, 'donor_id': donor})\n", + " \n", + " pb_obs = pd.DataFrame(obs_data, index=unique_ids)\n", + " \n", + " # 5. Count how many cells went into each sum\n", + " cell_counts = np.array(membership_matrix.sum(axis=0)).flatten()\n", + " pb_obs['n_cells'] = cell_counts.astype(int)\n", + " \n", + " # 6. Add additional metadata columns\n", + " if metadata_cols is not None:\n", + " for col in metadata_cols:\n", + " if col in adata.obs.columns:\n", + " # For each pseudobulk sample, get the first (should be consistent) value\n", + " # from the original data for that donor\n", + " col_values = []\n", + " for uid in unique_ids:\n", + " ctype, donor = uid.split(\"::\")\n", + " # Get value from any cell with this donor (should all be the same)\n", + " donor_mask = adata.obs[donor_col] == donor\n", + " if donor_mask.any():\n", + " col_values.append(adata.obs.loc[donor_mask, col].iloc[0])\n", + " else:\n", + " col_values.append(None)\n", + " pb_obs[col] = col_values\n", + " \n", + " # 7. Assemble the AnnData\n", + " pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy())\n", + " \n", + " return pb_adata\n", + "\n", + "# --- Execute ---\n", + "\n", + "target_cluster_col = 'cell_type'\n", + "\n", + "print(\"Aggregating counts...\")\n", + "pb_adata = create_pseudobulk(\n", + " adata, \n", + " group_col=target_cluster_col, \n", + " donor_col='donor_id', \n", + " layer='counts',\n", + " metadata_cols=['development_stage', 'sex'] # Add any other donor-level metadata here\n", + ")\n", + "\n", + "print(f\"Pseudobulk complete.\")\n", + "print(f\"Original shape: {adata.shape}\")\n", + "print(f\"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)\")\n", + "print(pb_adata.obs.head())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8fb76888", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dropping samples with < 10 cells...\n", + "Remaining samples: 5561\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "min_cells = 10\n", + "print(f\"Dropping samples with < {min_cells} cells...\")\n", + "\n", + "pb_adata = pb_adata[pb_adata.obs['n_cells'] >= min_cells].copy()\n", + "\n", + "print(f\"Remaining samples: {pb_adata.n_obs}\")\n", + "\n", + "# Optional: Visualize the 'depth' of your new pseudobulk samples\n", + "import scanpy as sc\n", + "pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten()\n", + "sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True)" + ] + }, + { + "cell_type": "markdown", + "id": "2907db1a", + "metadata": {}, + "source": [ + "### Differential expression with age\n", + "\n", + "First need to z-score the age variable to put it on same scale as expression, to help with convergence" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "b6298767", + "metadata": {}, + "outputs": [], + "source": [ + "# first need to create 'age_scaled' variable from 'development_stage'\n", + "# eg. from '19-year-old stage' to 19\n", + "ages = pb_adata.obs['development_stage'].str.extract(r'(\\d+)-year-old').astype(float)\n", + "pb_adata.obs['age'] = ages\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "f5fade97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " age age_scaled\n", + "central memory CD4-positive, alpha-beta T cell:... 73.0 0.632347\n", + "central memory CD4-positive, alpha-beta T cell:... 57.0 -0.313739\n", + "central memory CD4-positive, alpha-beta T cell:... 58.0 -0.254608\n", + "central memory CD4-positive, alpha-beta T cell:... 74.0 0.691478\n", + "central memory CD4-positive, alpha-beta T cell:... 71.0 0.514087\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from pydeseq2.dds import DeseqDataSet\n", + "from pydeseq2.ds import DeseqStats\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# Assume pb_adata is your pseudobulk object from the previous step\n", + "# 1. Extract counts and metadata\n", + "counts_df = pd.DataFrame(\n", + " pb_adata.X.toarray(), \n", + " index=pb_adata.obs_names, \n", + " columns=[var_to_feature.get(var, var) for var in pb_adata.var_names]\n", + ")\n", + "# remove duplicate columns if any\n", + "counts_df = counts_df.loc[:,~counts_df.columns.duplicated()]\n", + "\n", + "metadata = pb_adata.obs.copy()\n", + "\n", + "# 2. IMPORTANT: Scale the continuous variable\n", + "# This prevents convergence errors.\n", + "scaler = StandardScaler()\n", + "metadata['age_scaled'] = scaler.fit_transform(metadata[['age']]).flatten()\n", + "metadata['age_scaled'] = metadata['age_scaled'].astype(float)\n", + "\n", + "\n", + "# Check the scaling (Mean should be ~0, Std ~1)\n", + "print(metadata[['age', 'age_scaled']].head())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "0e30e949", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/r2/f85nyfr1785fj4257wkdj7480000gn/T/ipykernel_48619/2983949029.py:14: DeprecationWarning: design_factors is deprecated and will soon be removed.Please consider providing a formulaic formula using the design argumentinstead.\n", + " dds = DeseqDataSet(\n", + "Fitting size factors...\n", + "... done in 0.18 seconds.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using None as control genes, passed at DeseqDataSet initialization\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting dispersions...\n", + "... done in 1.58 seconds.\n", + "\n", + "Fitting dispersion trend curve...\n", + "... done in 0.19 seconds.\n", + "\n", + "Fitting MAP dispersions...\n", + "... done in 2.87 seconds.\n", + "\n", + "Fitting LFCs...\n", + "... done in 1.74 seconds.\n", + "\n", + "Calculating cook's distance...\n", + "... done in 0.29 seconds.\n", + "\n", + "Replacing 1 outlier genes.\n", + "\n", + "Fitting dispersions...\n", + "... done in 0.01 seconds.\n", + "\n", + "Fitting MAP dispersions...\n", + "... done in 0.01 seconds.\n", + "\n", + "Fitting LFCs...\n", + "... done in 0.01 seconds.\n", + "\n" + ] + } + ], + "source": [ + "# Perform DE analysis separately for each cell type\n", + "# For this example we just choose one of them\n", + "\n", + "cell_type = 'central memory CD4-positive, alpha-beta T cell'\n", + "pb_adata_ct = pb_adata[pb_adata.obs['cell_type'] == cell_type].copy()\n", + "counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy()\n", + "\n", + "metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy()\n", + "\n", + "assert 'age_scaled' in metadata_ct.columns, \"age_scaled column missing in metadata\"\n", + "assert 'sex' in metadata_ct.columns, \"sex column missing in metadata\"\n", + "\n", + "# 3. Initialize DeseqDataSet\n", + "dds = DeseqDataSet(\n", + " counts=counts_df_ct,\n", + " metadata=metadata_ct,\n", + " design_factors=[\"age_scaled\", \"sex\"], # Use the scaled column\n", + " refit_cooks=True,\n", + " n_cpus=8\n", + ")\n", + "\n", + "# 4. Run the fitting (Dispersions & LFCs)\n", + "dds.deseq2()\n" + ] + }, + { + "cell_type": "markdown", + "id": "6c867e35", + "metadata": {}, + "source": [ + "#### Compute statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0ab33f40", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "contrast: [0 1 0], model_vars: Index(['Intercept', 'age_scaled', 'sex[T.male]'], dtype='object')\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running Wald tests...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Log2 fold change & Wald test p-value, contrast vector: [0 1 0]\n", + " baseMean log2FoldChange lfcSE stat \\\n", + "OR4F5 0.000000 NaN NaN NaN \n", + "ENSG00000239945 0.005952 -0.100132 0.949557 -0.105451 \n", + "ENSG00000241860 0.365122 0.025313 0.091008 0.278135 \n", + "ENSG00000241599 0.001283 -0.103422 1.448770 -0.071386 \n", + "ENSG00000229905 0.000000 NaN NaN NaN \n", + "... ... ... ... ... \n", + "MT-ND4L 102.560848 0.079307 0.014440 5.492099 \n", + "MT-ND4 2574.820764 0.015613 0.009306 1.677810 \n", + "MT-ND5 759.807343 0.007827 0.010848 0.721464 \n", + "MT-ND6 37.003224 0.029722 0.013672 2.173891 \n", + "MT-CYB 2443.119315 0.030728 0.011338 2.710161 \n", + "\n", + " pvalue padj \n", + "OR4F5 NaN NaN \n", + "ENSG00000239945 9.160176e-01 NaN \n", + "ENSG00000241860 7.809089e-01 NaN \n", + "ENSG00000241599 9.430907e-01 NaN \n", + "ENSG00000229905 NaN NaN \n", + "... ... ... \n", + "MT-ND4L 3.971854e-08 0.000002 \n", + "MT-ND4 9.338413e-02 0.226846 \n", + "MT-ND5 4.706241e-01 0.658790 \n", + "MT-ND6 2.971332e-02 0.099708 \n", + "MT-CYB 6.725063e-03 0.032845 \n", + "\n", + "[29324 rows x 6 columns]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "... done in 2.22 seconds.\n", + "\n" + ] + } + ], + "source": [ + "model_vars = dds.varm[\"LFC\"].columns\n", + "contrast = np.array([0, 1, 0])\n", + "print(f\"contrast: {contrast}, model_vars: {model_vars}\")\n", + "\n", + "# 5. Statistical Test (Wald Test)\n", + "# Syntax for continuous: [\"variable\", \"\", \"\"]\n", + "stat_res = DeseqStats(\n", + " dds, \n", + " contrast=contrast\n", + ")\n", + "\n", + "stat_res.summary()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "6598e6ce", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running Wald tests...\n", + "... done in 0.62 seconds.\n", + "\n" + ] + } + ], + "source": [ + "stat_res.run_wald_test()" + ] + }, + { + "cell_type": "markdown", + "id": "01e512d6", + "metadata": {}, + "source": [ + "#### Find significant genes" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "cd4ccda1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 3124 significant genes.\n", + " log2FoldChange padj\n", + "ENSG00000260613 0.662743 6.155660e-05\n", + "GTSCR1 0.529188 2.553945e-35\n", + "PHLDA3 0.518890 7.488643e-12\n", + "GABRE 0.494251 4.340036e-04\n", + "DONSON 0.488810 5.428557e-09\n" + ] + } + ], + "source": [ + "# 1. Get the results dataframe\n", + "res = stat_res.results_df\n", + "\n", + "# 2. Filter for significant genes (e.g., FDR < 0.05)\n", + "# This automatically excludes NaNs (since NaN < 0.05 is False)\n", + "sigs = res[res['padj'] < 0.05]\n", + "\n", + "# 3. Sort by effect size (Log2 Fold Change) to see top hits\n", + "sigs = sigs.sort_values('log2FoldChange', ascending=False)\n", + "\n", + "print(f\"Found {len(sigs)} significant genes.\")\n", + "print(sigs[['log2FoldChange', 'padj']].head())" + ] + }, + { + "cell_type": "markdown", + "id": "c68688e2", + "metadata": {}, + "source": [ + "### Pathway enrichment: GSEA\n", + "\n", + "- what pathways are enriched in the differentially expressed genes?" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7f64589e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-12-20 11:59:18,597 [WARNING] Duplicated values found in preranked stats: 5.93% of genes\n", + "The order of those genes will be arbitrary, which may produce unexpected results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Top Upregulated Pathways:\n", + " Term NES FDR q-val\n", + "0 MSigDB_Hallmark_2020__TNF-alpha Signaling via ... 2.097542 0.0\n", + "1 MSigDB_Hallmark_2020__Hypoxia 1.782058 0.003216\n", + "2 MSigDB_Hallmark_2020__Interferon Gamma Response 1.750043 0.003216\n", + "3 MSigDB_Hallmark_2020__Apoptosis 1.660934 0.004824\n", + "4 MSigDB_Hallmark_2020__p53 Pathway 1.652138 0.005788\n", + "5 MSigDB_Hallmark_2020__Reactive Oxygen Species ... 1.601382 0.008039\n", + "6 MSigDB_Hallmark_2020__Interferon Alpha Response 1.550408 0.014701\n", + "7 MSigDB_Hallmark_2020__IL-2/STAT5 Signaling 1.4815 0.023314\n", + "8 MSigDB_Hallmark_2020__Oxidative Phosphorylation 1.473942 0.023582\n", + "10 MSigDB_Hallmark_2020__Cholesterol Homeostasis 1.429341 0.031836\n", + "\n", + "Top Downregulated Pathways:\n", + " Term NES FDR q-val\n", + "40 MSigDB_Hallmark_2020__Spermatogenesis -1.003029 0.778001\n", + "39 MSigDB_Hallmark_2020__Androgen Response -1.023541 0.776461\n", + "36 MSigDB_Hallmark_2020__Xenobiotic Metabolism -1.042344 0.787156\n", + "31 MSigDB_Hallmark_2020__Myc Targets V2 -1.143465 0.462271\n", + "25 MSigDB_Hallmark_2020__Apical Junction -1.2273 0.266236\n", + "23 MSigDB_Hallmark_2020__PI3K/AKT/mTOR Signaling -1.24776 0.26635\n", + "21 MSigDB_Hallmark_2020__Protein Secretion -1.251274 0.320531\n", + "14 MSigDB_Hallmark_2020__TGF-beta Signaling -1.369893 0.120925\n", + "12 MSigDB_Hallmark_2020__Notch Signaling -1.394944 0.128555\n", + "9 MSigDB_Hallmark_2020__Wnt-beta Catenin Signaling -1.468539 0.102245\n" + ] + } + ], + "source": [ + "import gseapy as gp\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "# 1. Prepare the Ranked List\n", + "# We use the 'stat' column if available (best metric). \n", + "# If 'stat' isn't there, approximate it with -log10(pvalue) * sign(log2FoldChange)\n", + "rank_df = res[['stat']].dropna().sort_values('stat', ascending=False)\n", + "\n", + "# 2. Run GSEA Preranked\n", + "# We look at GO Biological Process and the \"Hallmark\" set (good for general states)\n", + "# For immune specific, you can also add 'Reactome_2022' or 'KEGG_2021_Human'\n", + "prerank_res = gp.prerank(\n", + " rnk=rank_df, \n", + " gene_sets=['MSigDB_Hallmark_2020'],\n", + " threads=4,\n", + " min_size=10, # Min genes in pathway\n", + " max_size=1000, \n", + " permutation_num=1000, # Reduce to 100 for speed if testing\n", + " seed=42\n", + ")\n", + "\n", + "# 3. View Results\n", + "# 'NES' = Normalized Enrichment Score (Positive = Upregulated in Age, Negative = Downregulated)\n", + "# 'FDR q-val' = Significance\n", + "terms = prerank_res.res2d.sort_values('NES', ascending=False)\n", + "\n", + "print(\"Top Upregulated Pathways:\")\n", + "print(terms[['Term', 'NES', 'FDR q-val']].head(10))\n", + "\n", + "print(\"\\nTop Downregulated Pathways:\")\n", + "print(terms[['Term', 'NES', 'FDR q-val']].tail(10))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "573c2d0a", + "metadata": {}, + "source": [ + "#### Create a plot for the results" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "217bc4f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting 20 pathways.\n", + " Term NES FDR q-val Count\n", + "0 TNF-alpha Signaling via NF-kB 2.097542 0.000000 86\n", + "1 Hypoxia 1.782058 0.003216 51\n", + "2 Interferon Gamma Response 1.750043 0.003216 80\n", + "3 Apoptosis 1.660934 0.004824 51\n", + "4 p53 Pathway 1.652138 0.005788 59\n" + ] + } + ], + "source": [ + "\n", + "# 1. Get the results table\n", + "# (Assumes 'prerank_res' is your output from gp.prerank)\n", + "gsea_df = prerank_res.res2d.copy()\n", + "\n", + "# 2. Sort by NES to separate Up vs Down\n", + "gsea_df = gsea_df.sort_values('NES', ascending=False)\n", + "\n", + "# 3. Select Top 10 Up and Top 10 Down\n", + "top_up = gsea_df.head(10).copy()\n", + "top_down = gsea_df.tail(10).copy()\n", + "\n", + "# 4. Combine them\n", + "combined_gsea = pd.concat([top_up, top_down])\n", + "\n", + "# 5. Create metrics for plotting\n", + "# Direction based on NES sign\n", + "combined_gsea['Direction'] = combined_gsea['NES'].apply(lambda x: 'Upregulated' if x > 0 else 'Downregulated')\n", + "\n", + "# Significance for X-axis (-log10 FDR)\n", + "# We add a tiny epsilon (1e-10) to avoid log(0) errors if FDR is exactly 0\n", + "combined_gsea['FDR q-val'] = pd.to_numeric(combined_gsea['FDR q-val'], errors='coerce')\n", + "combined_gsea['log_FDR'] = -np.log10(combined_gsea['FDR q-val'] + 1e-10)\n", + "\n", + "# Gene Count for Dot Size\n", + "# GSEApy stores the leading edge genes as a semi-colon separated string in 'Lead_genes'\n", + "combined_gsea['Count'] = combined_gsea['Lead_genes'].apply(lambda x: len(str(x).split(';')))\n", + "\n", + "## remove MSigDB label from Term\n", + "combined_gsea['Term'] = combined_gsea['Term'].str.replace('MSigDB_Hallmark_2020__', '', regex=False)\n", + "\n", + "print(f\"Plotting {len(combined_gsea)} pathways.\")\n", + "print(combined_gsea[['Term', 'NES', 'FDR q-val', 'Count']].head())" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3da89ee8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 8))\n", + "\n", + "# Create the scatter plot\n", + "sns.scatterplot(\n", + " data=combined_gsea,\n", + " x='log_FDR',\n", + " y='Term',\n", + " hue='Direction', # Color by NES Direction\n", + " size='Count', # Size by number of Leading Edge genes\n", + " palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue\n", + " sizes=(50, 400), # Range of dot sizes\n", + " alpha=0.8\n", + ")\n", + "\n", + "# Customization\n", + "plt.title('Top GSEA Pathways (Up vs Down)', fontsize=14)\n", + "plt.xlabel('-log10(FDR q-value)', fontsize=12)\n", + "plt.ylabel('')\n", + "\n", + "# Add a vertical line for significance (FDR < 0.05 => -log10(0.05) ~= 1.3)\n", + "plt.axvline(-np.log10(0.25), color='gray', linestyle=':', label='FDR=0.25 (GSEA standard)')\n", + "plt.axvline(-np.log10(0.05), color='gray', linestyle='--', label='FDR=0.05')\n", + "\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n", + "plt.grid(axis='x', alpha=0.3)\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ceaad09c", + "metadata": {}, + "source": [ + "### Enrichr analysis for overrepresentation" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "7f5e6224", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing 1205 upregulated and 1919 downregulated genes.\n", + "Upregulated Pathways:\n", + " Term Adjusted P-value Overlap\n", + "0 TNF-alpha Signaling via NF-kB 3.695219e-15 48/200\n", + "1 Myc Targets V1 2.231576e-13 45/200\n", + "2 p53 Pathway 5.909649e-11 41/200\n", + "3 Apoptosis 6.464364e-11 36/161\n", + "4 Interferon Gamma Response 2.287547e-09 38/200\n", + "5 Hypoxia 2.679064e-07 34/200\n", + "6 Oxidative Phosphorylation 2.679064e-07 34/200\n", + "7 Reactive Oxygen Species Pathway 4.441324e-06 14/49\n", + "8 Unfolded Protein Response 1.912995e-05 21/113\n", + "9 mTORC1 Signaling 4.982898e-05 29/200\n", + "Downregulated Pathways:\n", + " Term Adjusted P-value Overlap\n", + "0 Myc Targets V1 0.001618 38/200\n", + "1 Protein Secretion 0.005788 21/96\n", + "2 PI3K/AKT/mTOR Signaling 0.005788 22/105\n", + "3 Androgen Response 0.014601 20/100\n", + "4 Wnt-beta Catenin Signaling 0.054265 10/42\n", + "5 TGF-beta Signaling 0.102715 11/54\n", + "6 Oxidative Phosphorylation 0.115051 29/200\n", + "7 Fatty Acid Metabolism 0.301496 22/158\n", + "8 G2-M Checkpoint 0.342076 26/200\n", + "9 mTORC1 Signaling 0.342076 26/200\n" + ] + } + ], + "source": [ + "# 1. Define your significant gene lists\n", + "# Up in Age\n", + "up_genes = res[\n", + " (res['padj'] < 0.05) & (res['log2FoldChange'] > 0)\n", + "].index.tolist()\n", + "\n", + "# Down in Age\n", + "down_genes = res[\n", + " (res['padj'] < 0.05) & (res['log2FoldChange'] < 0)\n", + "].index.tolist()\n", + "\n", + "print(f\"Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.\")\n", + "\n", + "# 2. Run Enrichr (Over-Representation Analysis)\n", + "if len(up_genes) > 0:\n", + " enr_up = gp.enrichr(\n", + " gene_list=up_genes,\n", + " gene_sets=['MSigDB_Hallmark_2020'],\n", + " organism='human', \n", + " outdir=None\n", + " )\n", + " print(\"Upregulated Pathways:\")\n", + " print(enr_up.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))\n", + " \n", + "\n", + "if len(down_genes) > 0:\n", + " enr_down = gp.enrichr(\n", + " gene_list=down_genes,\n", + " gene_sets=['MSigDB_Hallmark_2020'],\n", + " organism='human', \n", + " outdir=None\n", + " )\n", + " print(\"Downregulated Pathways:\")\n", + " print(enr_down.results[['Term', 'Adjusted P-value', 'Overlap']].head(10))\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "390796aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting 20 pathways.\n" + ] + } + ], + "source": [ + "\n", + "# 1. Add a \"Direction\" column to distinguish them\n", + "up_res = enr_up.results.copy()\n", + "up_res['Direction'] = 'Upregulated'\n", + "up_res['Color'] = 'Red' # For custom palette\n", + "\n", + "down_res = enr_down.results.copy()\n", + "down_res['Direction'] = 'Downregulated'\n", + "down_res['Color'] = 'Blue'\n", + "\n", + "# 2. Filter for top 10 pathways by Adjusted P-value\n", + "# (You can also filter by 'Combined Score' if you prefer)\n", + "top_up = up_res.sort_values('Adjusted P-value').head(10)\n", + "top_down = down_res.sort_values('Adjusted P-value').head(10)\n", + "\n", + "# 3. Concatenate\n", + "combined = pd.concat([top_up, top_down])\n", + "\n", + "# 4. Create a \"-log10(P-value)\" column for plotting\n", + "combined['log_p'] = -np.log10(combined['Adjusted P-value'])\n", + "\n", + "# 5. Extract \"Count\" from the \"Overlap\" column (e.g., \"5/200\" -> 5)\n", + "# This is used to size the dots\n", + "combined['Gene_Count'] = combined['Overlap'].apply(lambda x: int(x.split('/')[0]))\n", + "\n", + "print(f\"Plotting {len(combined)} pathways.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "290615f7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(10, 8))\n", + "\n", + "# Create the scatter plot\n", + "sns.scatterplot(\n", + " data=combined,\n", + " x='log_p',\n", + " y='Term',\n", + " hue='Direction', # Color by Up/Down\n", + " size='Gene_Count', # Size by number of genes in pathway\n", + " palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue\n", + " sizes=(50, 400), # Range of dot sizes\n", + " alpha=0.8\n", + ")\n", + "\n", + "# Customization\n", + "plt.title('Top Enriched Pathways (Up vs Down)', fontsize=14)\n", + "plt.xlabel('-log10(Adjusted P-value)', fontsize=12)\n", + "plt.ylabel('')\n", + "plt.axvline(-np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05') # Significance threshold line\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.)\n", + "plt.grid(axis='x', alpha=0.3)\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bc7868dc", + "metadata": {}, + "source": [ + "### Age prediction from gene expression\n", + "\n", + "Here we will build a predictive model and assess our ability to predict age from held-out individuals. We also test against a baseline model with only sex as a covariate." + ] + }, + { + "cell_type": "markdown", + "id": "b826767b", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "086597f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature matrix shape: (698, 29325)\n", + "Number of samples: 698\n", + "Age range: 19.0 - 97.0 years\n", + "\n", + "Fold 1/5\n", + " R² Score: 0.310\n", + " MAE: 11.38 years\n", + "\n", + "Fold 2/5\n", + " R² Score: 0.305\n", + " MAE: 11.63 years\n", + "\n", + "Fold 3/5\n", + " R² Score: 0.247\n", + " MAE: 11.94 years\n", + "\n", + "Fold 4/5\n", + " R² Score: 0.314\n", + " MAE: 10.67 years\n", + "\n", + "Fold 5/5\n", + " R² Score: 0.240\n", + " MAE: 10.87 years\n", + "\n", + "==================================================\n", + "CROSS-VALIDATION RESULTS\n", + "==================================================\n", + "R² Score: 0.283 ± 0.033\n", + "MAE: 11.30 ± 0.47 years\n", + "==================================================\n" + ] + } + ], + "source": [ + "from sklearn.svm import LinearSVR\n", + "from sklearn.model_selection import ShuffleSplit\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.metrics import r2_score, mean_absolute_error\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# 1. Prepare features and target\n", + "# Features: all genes from counts_df_ct + sex variable\n", + "X_genes = counts_df_ct.copy()\n", + "\n", + "# Add sex as a binary feature (encode as 0/1)\n", + "sex_encoded = pd.get_dummies(metadata_ct['sex'], drop_first=True)\n", + "X = pd.concat([X_genes, sex_encoded], axis=1)\n", + "\n", + "# Target: age\n", + "y = metadata_ct['age'].values\n", + "\n", + "print(f\"Feature matrix shape: {X.shape}\")\n", + "print(f\"Number of samples: {len(y)}\")\n", + "print(f\"Age range: {y.min():.1f} - {y.max():.1f} years\")\n", + "\n", + "# 2. Set up ShuffleSplit cross-validation\n", + "# Using 5 splits with 20% test size\n", + "cv = ShuffleSplit(n_splits=5, test_size=0.2, random_state=42)\n", + "\n", + "# 3. Store results\n", + "r2_scores = []\n", + "mae_scores = []\n", + "predictions_list = []\n", + "actual_list = []\n", + "\n", + "# 4. Train and evaluate model for each split\n", + "for fold, (train_idx, test_idx) in enumerate(cv.split(X)):\n", + " print(f\"\\nFold {fold + 1}/5\")\n", + " \n", + " # Split data\n", + " X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]\n", + " y_train, y_test = y[train_idx], y[test_idx]\n", + " \n", + " # Scale features (important for SVR)\n", + " scaler = StandardScaler()\n", + " X_train_scaled = scaler.fit_transform(X_train)\n", + " X_test_scaled = scaler.transform(X_test)\n", + " \n", + " # Train Linear SVR\n", + " # C parameter controls regularization (smaller = more regularization)\n", + " model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')\n", + " model.fit(X_train_scaled, y_train)\n", + " \n", + " # Predict on test set\n", + " y_pred = model.predict(X_test_scaled)\n", + " \n", + " # Calculate metrics\n", + " r2 = r2_score(y_test, y_pred)\n", + " mae = mean_absolute_error(y_test, y_pred)\n", + " \n", + " r2_scores.append(r2)\n", + " mae_scores.append(mae)\n", + " predictions_list.extend(y_pred)\n", + " actual_list.extend(y_test)\n", + " \n", + " print(f\" R² Score: {r2:.3f}\")\n", + " print(f\" MAE: {mae:.2f} years\")\n", + "\n", + "# 5. Summary statistics\n", + "print(\"\\n\" + \"=\"*50)\n", + "print(\"CROSS-VALIDATION RESULTS\")\n", + "print(\"=\"*50)\n", + "print(f\"R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}\")\n", + "print(f\"MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years\")\n", + "print(\"=\"*50)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "9a1f7eda", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize predictions vs actual ages\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Scatter plot of predictions vs actual\n", + "plt.scatter(actual_list, predictions_list, alpha=0.6, s=80)\n", + "\n", + "# Add diagonal line (perfect predictions)\n", + "min_age = min(min(actual_list), min(predictions_list))\n", + "max_age = max(max(actual_list), max(predictions_list))\n", + "plt.plot([min_age, max_age], [min_age, max_age], 'r--', linewidth=2, label='Perfect Prediction')\n", + "\n", + "plt.xlabel('Actual Age (years)', fontsize=12)\n", + "plt.ylabel('Predicted Age (years)', fontsize=12)\n", + "plt.title(f'Age Prediction Performance\\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years', \n", + " fontsize=14)\n", + "plt.legend()\n", + "plt.grid(alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "902799f5", + "metadata": {}, + "source": [ + "#### Baseline model: Sex only\n", + "\n", + "Compare against a baseline model that only uses sex as a predictor to assess the contribution of gene expression." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "781a934c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "MODEL COMPARISON\n", + "============================================================\n", + "Full Model (Genes + Sex):\n", + " R² Score: 0.283 ± 0.033\n", + " MAE: 11.30 ± 0.47 years\n", + "\n", + "Baseline Model (Sex Only):\n", + " R² Score: -0.027 ± 0.018\n", + " MAE: 13.55 ± 0.54 years\n", + "\n", + "Improvement:\n", + " ΔR²: 0.310\n", + " ΔMAE: 2.25 years\n", + "============================================================\n" + ] + } + ], + "source": [ + "# Baseline model: Sex only\n", + "X_baseline = sex_encoded.copy()\n", + "\n", + "# Store baseline results\n", + "baseline_r2_scores = []\n", + "baseline_mae_scores = []\n", + "\n", + "# Train and evaluate baseline model for each split\n", + "for fold, (train_idx, test_idx) in enumerate(cv.split(X_baseline)):\n", + " # Split data\n", + " X_train, X_test = X_baseline.iloc[train_idx], X_baseline.iloc[test_idx]\n", + " y_train, y_test = y[train_idx], y[test_idx]\n", + " \n", + " # Scale features\n", + " scaler = StandardScaler()\n", + " X_train_scaled = scaler.fit_transform(X_train)\n", + " X_test_scaled = scaler.transform(X_test)\n", + " \n", + " # Train Linear SVR\n", + " model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto')\n", + " model.fit(X_train_scaled, y_train)\n", + " \n", + " # Predict on test set\n", + " y_pred = model.predict(X_test_scaled)\n", + " \n", + " # Calculate metrics\n", + " r2 = r2_score(y_test, y_pred)\n", + " mae = mean_absolute_error(y_test, y_pred)\n", + " \n", + " baseline_r2_scores.append(r2)\n", + " baseline_mae_scores.append(mae)\n", + "\n", + "# Summary comparison\n", + "print(\"=\"*60)\n", + "print(\"MODEL COMPARISON\")\n", + "print(\"=\"*60)\n", + "print(f\"Full Model (Genes + Sex):\")\n", + "print(f\" R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}\")\n", + "print(f\" MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years\")\n", + "print(f\"\\nBaseline Model (Sex Only):\")\n", + "print(f\" R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}\")\n", + "print(f\" MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years\")\n", + "print(f\"\\nImprovement:\")\n", + "print(f\" ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}\")\n", + "print(f\" ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years\")\n", + "print(\"=\"*60)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "052f9c31", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "BetterCodeBetterScience", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py new file mode 100644 index 0000000..cac638e --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/immune_scrnaseq_monolithic.py @@ -0,0 +1,1219 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.18.1 +# kernelspec: +# display_name: BetterCodeBetterScience +# language: python +# name: python3 +# --- + +# %% [markdown] +# ### Immune system gene expression and aging +# +# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total. These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants. +# +# The flagship paper for this study is: +# +# Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022) +# +# We will use the data to ask a simple question: how does gene expression in PBMCs change with age? + + +# %% +import anndata as ad +import h5py +import numpy as np +import scanpy as sc +from pathlib import Path +import matplotlib.pyplot as plt +import seaborn as sns +from anndata.experimental import read_lazy +import os +import pandas as pd +from scipy.stats import scoreatpercentile +import re +import scanpy.external as sce +from sklearn.preprocessing import OneHotEncoder +from pydeseq2.dds import DeseqDataSet +from pydeseq2.ds import DeseqStats +from sklearn.preprocessing import StandardScaler +import gseapy as gp +from sklearn.svm import LinearSVR +from sklearn.model_selection import ShuffleSplit +from sklearn.metrics import r2_score, mean_absolute_error + + +datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/') + + +# %% [markdown] +# ### Immune system gene expression and aging +# +# We will use a dataset distributed by the [OneK1K](https://onek1k.org/) project, which includes single-cell RNA-seq data from peripheral blood mononuclear cells (PBMCs) obtained from 982 donors, comprising more than 1.2 million cells in total. These data are released under a Creative Commons Zero Public Domain Dedication and are thus free to reuse, with the restriction that users agree not to attempt to reidentify the participants. +# +# The flagship paper for this study is: +# +# Yazar S., Alquicira-Hernández J., Wing K., Senabouth A., Gordon G., Andersen S., Lu Q., Rowson A., Taylor T., Clarke L., Maccora L., Chen C., Cook A., Ye J., Fairfax K., Hewitt A., Powell J. Single cell eQTL mapping identified cell type specific control of autoimmune disease. Science, 376, 6589 (2022) +# +# We will use the data to ask a simple question: how does gene expression in PBMCs change with age? +# +# # Code in this notebook primarily generated using Gemini 3.0 + + +# %% + +datadir = Path('/Users/poldrack/data_unsynced/BCBS/immune_aging/') +figure_dir = datadir / 'workflow/figures' +figure_dir.mkdir(parents=True, exist_ok=True) + +# %% +dataset_name = 'OneK1K' +datafile = datadir / f'dataset-{dataset_name}_subset-immune_raw.h5ad' +url = 'https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad' + +if not datafile.exists(): + cmd = f'wget -O {datafile.as_posix()} {url}' + print(f'Downloading data from {url} to {datafile.as_posix()}') + os.system(cmd) + +load_annotation_index = True +adata = read_lazy( + h5py.File(datafile, 'r'), load_annotation_index=load_annotation_index +) + +# %% +print(adata) + +# %% +unique_cell_types = np.unique(adata.obs['cell_type']) +print(unique_cell_types) + +# %% [markdown] +# ### Filtering out bad donors + +# %% + + +# 1. Calculate how many cells each donor has +donor_cell_counts = pd.Series(adata.obs['donor_id']).value_counts() + +# Print some basic statistics to read the exact numbers +print('Donor Cell Count Statistics:') +print(donor_cell_counts.describe()) + +# 2. Plot the histogram +plt.figure(figsize=(10, 6)) +# Bins set to 'auto' or a fixed number depending on your N of donors +plt.hist(donor_cell_counts.values, bins=50, color='skyblue', edgecolor='black') + +plt.title('Distribution of Total Cells per Donor') +plt.xlabel('Number of Cells Captured') +plt.ylabel('Number of Donors') +plt.grid(axis='y', alpha=0.5) + +# Optional: Draw a vertical line at the propsoed cutoff +# This helps you visualize how many donors you would lose. +cutoff_percentile = 1 # e.g., 1st percentile +min_cells_per_donor = int( + scoreatpercentile(donor_cell_counts.values, cutoff_percentile) +) +print( + f'cutoff of {min_cells_per_donor} would exclude {(donor_cell_counts < min_cells_per_donor).sum()} donors' +) +plt.axvline( + min_cells_per_donor, + color='red', + linestyle='dashed', + linewidth=1, + label=f'Cutoff ({min_cells_per_donor} cells)', +) +plt.legend() + +plt.savefig(figure_dir / 'donor_cell_counts_distribution.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% +print( + f'Filtering to keep only donors with at least {min_cells_per_donor} cells.' +) +print( + f'Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}' +) +valid_donors = donor_cell_counts[ + donor_cell_counts >= min_cells_per_donor +].index +adata = adata[adata.obs['donor_id'].isin(valid_donors)] + +# %% +print(f'Number of donors after filtering: {len(valid_donors)}') + +# %% [markdown] +# ### Filtering cell types by frequency +# +# Drop cell types that don't have at least 10 cells for at least 95% of people + +# %% + +# 1. Calculate the count of cells for each 'cell_type' within each 'donor_id' +# We use pandas crosstab on adata.obs, which is loaded in memory. +counts_per_donor = pd.crosstab(adata.obs['donor_id'], adata.obs['cell_type']) + +# 2. Identify cell types to keep +# Keep if >= 10 cells in at least 90% of donors + +min_cells = 10 +percent_donors = 0.95 +donor_count = counts_per_donor.shape[0] +cell_types_to_keep = counts_per_donor.columns[ + (counts_per_donor >= min_cells).sum(axis=0) + >= (donor_count * percent_donors) +] + +print( + f'Keeping {len(cell_types_to_keep)} cell types out of {len(counts_per_donor.columns)}' +) +print(f'Cell types to keep: {cell_types_to_keep.tolist()}') + +# 3. Filter the AnnData object +# We subset the AnnData to include only observations belonging to the valid cell types. +adata_filtered = adata[adata.obs['cell_type'].isin(cell_types_to_keep)] + +# %% +# now drop subjects who have any zeros in these cell types +donor_celltype_counts = pd.crosstab( + adata_filtered.obs['donor_id'], adata_filtered.obs['cell_type'] +) +valid_donors_final = donor_celltype_counts.index[ + (donor_celltype_counts >= min_cells).all(axis=1) +] +adata_filtered = adata_filtered[ + adata_filtered.obs['donor_id'].isin(valid_donors_final) +] +print(f'Final number of donors after filtering: {len(valid_donors_final)}') + +# %% + +print('Loading data into memory (this can take a few minutes)...') +adata_loaded = adata_filtered.to_memory() + +# filter out genes with zero counts across all selected cells +print('Filtering genes with zero counts...') +sc.pp.filter_genes(adata_loaded, min_counts=1) + + +# %% +print(adata_loaded) + + +# %% +adata_loaded.write( + datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad' +) +del adata_loaded + +# %% +adata = ad.read_h5ad( + datadir / f'dataset-{dataset_name}_subset-immune_filtered.h5ad' +) +print(adata) + +# %% +var_to_feature = dict(zip(adata.var_names, adata.var['feature_name'])) + +# %% [markdown] +# Preprocessing based on suggestions from Google Gemini +# +# based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html +# +# and https://www.10xgenomics.com/analysis-guides/common-considerations-for-quality-control-filters-for-single-cell-rna-seq-data +# + +# %% [markdown] +# ### Quality control +# +# based on https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html +# + +# %% +# mitochondrial genes +adata.var['mt'] = adata.var['feature_name'].str.startswith('MT-') +print(f"Number of mitochondrial genes: {adata.var['mt'].sum()}") + +# ribosomal genes +adata.var['ribo'] = adata.var['feature_name'].str.startswith(('RPS', 'RPL')) +print(f"Number of ribosomal genes: {adata.var['ribo'].sum()}") + +# hemoglobin genes. +adata.var['hb'] = adata.var['feature_name'].str.contains('^HB[^(P)]') +print(f"Number of hemoglobin genes: {adata.var['hb'].sum()}") + +sc.pp.calculate_qc_metrics( + adata, + qc_vars=['mt', 'ribo', 'hb'], + inplace=True, + percent_top=[20], + log1p=True, +) + + +# %% [markdown] +# #### Visualization of distributions + +# %% + +# 1. Violin plots to see the distribution of QC metrics +# Note: I am using the exact column names from your adata output +p1 = sc.pl.violin( + adata, + ['total_counts', 'n_genes_by_counts', 'pct_counts_mt'], + jitter=0.4, + multi_panel=True, + show=False, +) +plt.savefig(figure_dir / 'qc_violin_plots.png', dpi=300, bbox_inches='tight') +plt.close() + +# 2. Scatter plot to spot doublets and dying cells +# High mito + low genes = dying cell +# High counts + high genes = potential doublet +sc.pl.scatter( + adata, x='total_counts', y='n_genes_by_counts', color='pct_counts_mt', show=False +) +plt.savefig(figure_dir / 'qc_scatter_doublets.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# #### Check Hemoglobin (RBC contamination) +# + +# %% + +plt.figure(figsize=(6, 4)) +sns.histplot( + adata.obs['pct_counts_hb'], bins=50, log_scale=(False, True) +) # Log scale y to see small RBC populations +plt.title('Hemoglobin Content Distribution') +plt.xlabel('% Hemoglobin Counts') +plt.axvline(5, color='red', linestyle='--', label='5% Cutoff') +plt.legend() +plt.savefig(figure_dir / 'hemoglobin_distribution.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# #### Create a copy of the data and apply QC cutoffs +# + +# %% +# Create a copy or view to avoid modifying the original if needed +adata_qc = adata.copy() + +# --- Define Thresholds --- +# Low quality (Empty droplets / debris) +min_genes = 200 # Standard for immune cells (T-cells can be small) +min_counts = 500 # Minimum UMIs + +# Doublets (Two cells stuck together) +# Adjust this based on the scatter plot above. +# 4000-6000 is common for 10x Genomics data. +max_genes = 6000 +max_counts = 30000 # Very high counts often indicate doublets + +# Contaminants +max_hb_pct = 5.0 # Remove Red Blood Cells (> 5% hemoglobin) + +# --- Apply Filtering --- +print(f'Before filtering: {adata_qc.n_obs} cells') + +# 1. Filter Low Quality & Doublets +adata_qc = adata_qc[ + (adata_qc.obs['n_genes_by_counts'] > min_genes) + & (adata_qc.obs['n_genes_by_counts'] < max_genes) + & (adata_qc.obs['total_counts'] > min_counts) + & (adata_qc.obs['total_counts'] < max_counts) +] + +# 2. Filter Red Blood Cells (Hemoglobin) +# Only run this if you want to remove RBCs +adata_qc = adata_qc[adata_qc.obs['pct_counts_hb'] < max_hb_pct] + +print(f'After filtering: {adata_qc.n_obs} cells') + +# %% [markdown] +# ### Perform doublet detection +# +# According to Gemini: +# +# You must do this before normalization or clustering because doublets create "hybrid" expression profiles that can form fake clusters (e.g., a "cluster" that looks like a mix of T-cells and B-cells) or distort your normalization factors. +# +# **Important: Run Per Donor** +# +# Since you have multiple people, you must run doublet detection separately for each donor. The doublet rate is a technical artifact of the physical loading of the machine (10x Genomics chip), which varies per run. If you run it on the whole dataset at once, the algorithm will get confused by biological differences between people. +# + +# %% + +# 1. Check preliminary requirements +# Scrublet needs RAW counts. Ensure adata.X contains integers, not log-normalized data. +# If your main layer is already normalized, use adata.raw or a specific layer. +print(f'Data shape before doublet detection: {adata_qc.shape}') + +# 2. Run Scrublet per donor +# We split the data, run detection, and then recombine. +# This prevents the algorithm from comparing a cell from Person A to a cell from Person B. + +adatas_list = [] +# Get list of unique donors +donors = adata_qc.obs['donor_id'].unique() + +print(f'Running Scrublet on {len(donors)} donors...') + +for donor in donors: + # Subset to current donor + curr_adata = adata_qc[adata_qc.obs['donor_id'] == donor].copy() + + # Skip donors with too few cells (Scrublet needs statistical power) + if curr_adata.n_obs < 100: + print(f'Skipping donor {donor}: too few cells ({curr_adata.n_obs})') + # We still add it back to keep the data, but mark as singlet (or filter later) + curr_adata.obs['doublet_score'] = 0 + curr_adata.obs['predicted_doublet'] = False + adatas_list.append(curr_adata) + continue + + # Run Scrublet + # expected_doublet_rate=0.06 is standard for 10x (approx ~0.8% per 1000 cells recovered) + # If you loaded very heavily (20k cells/well), increase this to 0.10 + sc.pp.scrublet(curr_adata, expected_doublet_rate=0.06) + + adatas_list.append(curr_adata) + +# 3. Merge back into one object +adata_qc = sc.concat(adatas_list) + +# 4. Check results +print( + f"Detected {adata_qc.obs['predicted_doublet'].sum()} doublets across all donors." +) +print(adata_qc.obs['predicted_doublet'].value_counts()) + +# %% [markdown] +# #### Visualize doublets +# +# + +# %% +sc.pl.umap(adata_qc, color=['doublet_score', 'predicted_doublet'], size=20, show=False) +plt.savefig(figure_dir / 'doublet_detection_umap.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# #### Filter doublets +# - Question: how consistent are these results with other methods for doublet detection? https://www.sc-best-practices.org/preprocessing_visualization/quality_control.html#doublet-detection + +# %% +# Check how many doublets were found +print(f'found {adata_qc.obs["predicted_doublet"].sum()} predicted doublets') + +# Filter the data to keep only singlets (False) +# write back to adata for simplicity +adata = adata_qc[adata_qc.obs['predicted_doublet'] == False, :] #noqa: E712 +print(f'Remaining cells: {adata.n_obs}') + +# %% [markdown] +# #### Save raw counts for later use + +# %% +# set the .raw attribute (standard Scanpy convention) +adata.layers['counts'] = adata.X.copy() + +# %% [markdown] +# ### Total Count Normalization +# This scales each cell so that they all have the same total number of counts (default is often 10,000, known as "CP10k"). + +# %% +# Normalize to 10,000 reads per cell +# target_sum=1e4 is the standard for 10x data +sc.pp.normalize_total(adata, target_sum=1e4) + +# %% [markdown] +# ### Log Transformation (Log1p) +# This applies a natural logarithm to the data: log(X+1). This reduces the skewness of the data (since gene expression follows a power law) and stabilizes the variance. + +# %% +# Logarithmically transform the data +sc.pp.log1p(adata) + +# %% [markdown] +# ### select high-variance features +# +# according to Gemini: +# For a large immune dataset (PBMCs, ~1.2M cells), the standard defaults often fail to capture the subtle biological variation needed to distinguish similar cell types (like CD4+ T-cell subsets). +# +# Here are the reasonable parameters and, more importantly, the **immune-specific strategy** you should use. +# +# #### The Recommended Parameters +# +# For a dataset of your size, the **`seurat_v3`** flavor is generally superior because it selects genes based on standardized variance (handling the mean-variance relationship better than the dispersion-based method). +# +# * **`flavor`**: `'seurat_v3'` (Requires **RAW integer counts** in `adata.X` or a layer) +# * **`n_top_genes`**: **2000 - 3000** (3000 is safer for immune data to capture rare cytokines/markers) +# * **`batch_key`**: **`'donor_id'`** (CRITICAL) +# * *Why?* With 1.2M cells across many people, you have massive batch effects. If you don't set this, "highly variable genes" will just be the genes that differ between Person A and Person B (e.g., HLA genes, gender-specific genes like XIST/RPS4Y1), rather than genes distinguishing cell types. +# +# #### The "Expert" Trick: Blocklisting Nuisance Genes +# In immune datasets, "highly variable" does not always mean "biologically interesting." You often need to **exclude** specific gene families from the HVG list *after* calculation but *before* PCA, or they will hijack your clustering: +# 1. **TCR/BCR Variable Regions (IG*, TR*):** These are hyper-variable by definition (V(D)J recombination). If you keep them, T-cells will cluster by **clone** (clonotype) rather than by **phenotype** (state). +# 2. **Mitochondrial/Ribosomal:** Usually technical noise. +# 3. **Cell Cycle:** (Optional) If you don't want proliferating cells to cluster separately. +# +# +# +# #### Why 3000 genes instead of 2000? +# Immune cells are dense with specific markers. The difference between a *Naive CD8 T-cell* and a *Central Memory CD8 T-cell* might rest on a handful of genes (e.g., *CCR7, SELL, IL7R* vs *GZMK*). If you limit to 2000 genes in a massive, diverse dataset, you might accidentally drop a subtle marker required to resolve these fine-grained states. + +# %% + + +# 2. Run Highly Variable Gene Selection +# batch_key is critical here to find genes variable WITHIN donors, not BETWEEN them. +sc.pp.highly_variable_genes( + adata, + n_top_genes=3000, + flavor='seurat_v3', + batch_key='donor_id', + span=0.8, # helps avoid numerical issues with LOESS + layer='counts', # Change this to None if adata.X is raw counts + subset=False, # Keep False so we can manually filter the list below +) + +# 3. Filter out "Nuisance" Genes from the HVG list +# We don't remove the genes from the object, we just set their 'highly_variable' status to False +# so they aren't used in PCA. + +# A. Identify TCR/BCR genes (starts with IG or TR) +# Regex: IG or TR followed by a V, D, J, or C gene part + +immune_receptor_genes = [ + name + for name in adata.var_names + if re.match(r'^(IG[HKL]|TR[ABDG])[VDJC]', name) +] + +# B. Identify Ribosomal/Mitochondrial (if not already handled) +mt_genes = adata.var_names[adata.var_names.str.startswith('MT-')] +rb_genes = adata.var_names[adata.var_names.str.startswith(('RPS', 'RPL'))] + +# C. Manually set them to False +genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes) + +# Using set operations for speed +adata.var.loc[adata.var_names.isin(genes_to_block), 'highly_variable'] = False + +print( + f'Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.' +) +print(f"Final HVG count: {adata.var['highly_variable'].sum()}") + +# 4. Proceed to PCA +sc.tl.pca(adata, svd_solver='arpack', use_highly_variable=True) + + +# %% [markdown] +# ### Dimensionality reduction + +# %% + +# 1. Run Harmony +# This adjusts the PCA coordinates to mix donors together while preserving biology. +# It creates a new entry in obsm: 'X_pca_harmony' +try: + sce.pp.harmony_integrate( + adata, key='donor_id', basis='X_pca', adjusted_basis='X_pca_harmony' + ) + use_rep = 'X_pca_harmony' + print('Harmony integration successful. Using corrected PCA.') +except ImportError: + print( + 'Harmony not installed. Proceeding with standard PCA (Warning: Batch effects may persist).' + ) + print('To install: pip install harmony-pytorch') + use_rep = 'X_pca' + +# %% +# Reality check: Check if PC1 is just "Cell Size": + +sc.pl.pca(adata, color=['total_counts', 'cell_type'], components=['1,2'], show=False) +plt.savefig(figure_dir / 'pca_cell_type.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# PC1 separates cell types and isn't driven only by the number of cells. + +# %% +# 2. Compute Neighbors +# n_neighbors: 15-30 is standard. Higher (30-50) is better for large datasets to preserve global structure. +# n_pcs: 30-50 is standard. +sc.pp.neighbors(adata, n_neighbors=30, n_pcs=40, use_rep=use_rep) + +# 3. Compute UMAP +# This projects the graph into 2D for you to look at. +sc.tl.umap(adata, init_pos='X_pca_harmony') + +# %% +sc.pl.umap(adata, color='total_counts', show=False) +plt.savefig(figure_dir / 'umap_total_counts.png', dpi=300, bbox_inches='tight') +plt.close() + + +# %% [markdown] +# ### Clustering +# + +# %% +# 4. Run Clustering (Leiden algorithm) +# We run multiple resolutions so you can choose the best one later. +# sc.tl.leiden(adata, resolution=0.5, key_added='leiden_0.5') +sc.tl.leiden( + adata, + resolution=1.0, + key_added='leiden_1.0', + flavor='igraph', + n_iterations=2, +) + + +# %% +# Plot UMAP colored by Donor (to check integration) and Clusters +sc.pl.umap(adata, color=['cell_type', 'leiden_1.0'], wspace=0.3, show=False) +plt.savefig(figure_dir / 'umap_cell_type_leiden.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% +# compute overlap between clusters and cell types +contingency_table = pd.crosstab( + adata.obs['leiden_1.0'], adata.obs['cell_type'] +) +print(contingency_table) + +# %% [markdown] +# ### Pseudobulking + +# %% + + +def create_pseudobulk( + adata, group_col, donor_col, layer='counts', metadata_cols=None +): + """ + Sum raw counts for each (Donor, CellType) pair. + + Parameters: + ----------- + adata : AnnData + Input single-cell data + group_col : str + Column name for grouping (e.g., 'cell_type') + donor_col : str + Column name for donor ID + layer : str + Layer to use for aggregation (default: 'counts') + metadata_cols : list of str, optional + Additional metadata columns to preserve from obs (e.g., ['development_stage', 'sex']) + These should have consistent values within each donor + """ + # 1. Create a combined key (e.g., "Bcell::Donor1") + groups = adata.obs[group_col].astype(str) + donors = adata.obs[donor_col].astype(str) + + # Create a DataFrame to manage the unique combinations + group_df = pd.DataFrame({'group': groups, 'donor': donors}) + group_df['combined'] = group_df['group'] + '::' + group_df['donor'] + + # 2. Build the Aggregation Matrix (One-Hot Encoding) + enc = OneHotEncoder(sparse_output=True, dtype=np.float32) + membership_matrix = enc.fit_transform(group_df[['combined']]) + + # 3. Aggregation (Summing) + if layer is not None and layer in adata.layers: + X_source = adata.layers[layer] + else: + X_source = adata.X + + pseudobulk_X = membership_matrix.T @ X_source + + # 4. Create the Obs Metadata for the new object + unique_ids = enc.categories_[0] + + # Split back into Donor and Cell Type + obs_data = [] + for uid in unique_ids: + ctype, donor = uid.split('::') + obs_data.append({'cell_type': ctype, 'donor_id': donor}) + + pb_obs = pd.DataFrame(obs_data, index=unique_ids) + + # 5. Count how many cells went into each sum + cell_counts = np.array(membership_matrix.sum(axis=0)).flatten() + pb_obs['n_cells'] = cell_counts.astype(int) + + # 6. Add additional metadata columns + if metadata_cols is not None: + for col in metadata_cols: + if col in adata.obs.columns: + # For each pseudobulk sample, get the first (should be consistent) value + # from the original data for that donor + col_values = [] + for uid in unique_ids: + ctype, donor = uid.split('::') + # Get value from any cell with this donor (should all be the same) + donor_mask = adata.obs[donor_col] == donor + if donor_mask.any(): + col_values.append( + adata.obs.loc[donor_mask, col].iloc[0] + ) + else: + col_values.append(None) + pb_obs[col] = col_values + + # 7. Assemble the AnnData + pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy()) + + return pb_adata + + +# --- Execute --- + +target_cluster_col = 'cell_type' + +print('Aggregating counts...') +pb_adata = create_pseudobulk( + adata, + group_col=target_cluster_col, + donor_col='donor_id', + layer='counts', + metadata_cols=[ + 'development_stage', + 'sex', + ], # Add any other donor-level metadata here +) + +print('Pseudobulk complete.') +print(f'Original shape: {adata.shape}') +print(f'Pseudobulk shape: {pb_adata.shape} (Samples x Genes)') +print(pb_adata.obs.head()) + +# %% +min_cells = 10 +print(f'Dropping samples with < {min_cells} cells...') + +pb_adata = pb_adata[pb_adata.obs['n_cells'] >= min_cells].copy() + +print(f'Remaining samples: {pb_adata.n_obs}') + +# Optional: Visualize the 'depth' of your new pseudobulk samples + +pb_adata.obs['total_counts'] = np.array(pb_adata.X.sum(axis=1)).flatten() +sc.pl.violin(pb_adata, ['n_cells', 'total_counts'], multi_panel=True, show=False) +plt.savefig(figure_dir / 'pseudobulk_violin.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# ### Differential expression with age +# +# First need to z-score the age variable to put it on same scale as expression, to help with convergence + +# %% +# first need to create 'age_scaled' variable from 'development_stage' +# eg. from '19-year-old stage' to 19 +ages = ( + pb_adata.obs['development_stage'] + .str.extract(r'(\d+)-year-old') + .astype(float) +) +pb_adata.obs['age'] = ages + + +# %% + +# Assume pb_adata is your pseudobulk object from the previous step +# 1. Extract counts and metadata +counts_df = pd.DataFrame( + pb_adata.X.toarray(), + index=pb_adata.obs_names, + columns=[var_to_feature.get(var, var) for var in pb_adata.var_names], +) +# remove duplicate columns if any +counts_df = counts_df.loc[:, ~counts_df.columns.duplicated()] + +metadata = pb_adata.obs.copy() + +# 2. IMPORTANT: Scale the continuous variable +# This prevents convergence errors. +scaler = StandardScaler() +metadata['age_scaled'] = scaler.fit_transform(metadata[['age']]).flatten() +metadata['age_scaled'] = metadata['age_scaled'].astype(float) + + +# Check the scaling (Mean should be ~0, Std ~1) +print(metadata[['age', 'age_scaled']].head()) + +# %% +# Perform DE analysis separately for each cell type +# For this example we just choose one of them + +cell_type = 'central memory CD4-positive, alpha-beta T cell' +pb_adata_ct = pb_adata[pb_adata.obs['cell_type'] == cell_type].copy() +counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy() + +metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy() + +assert ( + 'age_scaled' in metadata_ct.columns +), 'age_scaled column missing in metadata' +assert 'sex' in metadata_ct.columns, 'sex column missing in metadata' + +# 3. Initialize DeseqDataSet +dds = DeseqDataSet( + counts=counts_df_ct, + metadata=metadata_ct, + design_factors=['age_scaled', 'sex'], # Use the scaled column + refit_cooks=True, + n_cpus=8, +) + +# 4. Run the fitting (Dispersions & LFCs) +dds.deseq2() + + +# %% [markdown] +# #### Compute statistics + +# %% +model_vars = dds.varm['LFC'].columns +contrast = np.array([0, 1, 0]) +print(f'contrast: {contrast}, model_vars: {model_vars}') + +# 5. Statistical Test (Wald Test) +# Syntax for continuous: ["variable", "", ""] +stat_res = DeseqStats(dds, contrast=contrast) + +stat_res.summary() + + +# %% +stat_res.run_wald_test() + +# %% [markdown] +# #### Find significant genes + +# %% +# 1. Get the results dataframe +res = stat_res.results_df + +# 2. Filter for significant genes (e.g., FDR < 0.05) +# This automatically excludes NaNs (since NaN < 0.05 is False) +sigs = res[res['padj'] < 0.05] + +# 3. Sort by effect size (Log2 Fold Change) to see top hits +sigs = sigs.sort_values('log2FoldChange', ascending=False) + +print(f'Found {len(sigs)} significant genes.') +print(sigs[['log2FoldChange', 'padj']].head()) + +# %% [markdown] +# ### Pathway enrichment: GSEA +# +# - what pathways are enriched in the differentially expressed genes? + +# %% + + +# 1. Prepare the Ranked List +# We use the 'stat' column if available (best metric). +# If 'stat' isn't there, approximate it with -log10(pvalue) * sign(log2FoldChange) +rank_df = res[['stat']].dropna().sort_values('stat', ascending=False) + +# 2. Run GSEA Preranked +# We look at GO Biological Process and the "Hallmark" set (good for general states) +# For immune specific, you can also add 'Reactome_2022' or 'KEGG_2021_Human' +prerank_res = gp.prerank( + rnk=rank_df, + gene_sets=['MSigDB_Hallmark_2020'], + threads=4, + min_size=10, # Min genes in pathway + max_size=1000, + permutation_num=1000, # Reduce to 100 for speed if testing + seed=42, +) + +# 3. View Results +# 'NES' = Normalized Enrichment Score (Positive = Upregulated in Age, Negative = Downregulated) +# 'FDR q-val' = Significance +terms = prerank_res.res2d.sort_values('NES', ascending=False) + +print('Top Upregulated Pathways:') +print(terms[['Term', 'NES', 'FDR q-val']].head(10)) + +print('\nTop Downregulated Pathways:') +print(terms[['Term', 'NES', 'FDR q-val']].tail(10)) + + +# %% [markdown] +# #### Create a plot for the results + +# %% + +# 1. Get the results table +# (Assumes 'prerank_res' is your output from gp.prerank) +gsea_df = prerank_res.res2d.copy() + +# 2. Sort by NES to separate Up vs Down +gsea_df = gsea_df.sort_values('NES', ascending=False) + +# 3. Select Top 10 Up and Top 10 Down +top_up = gsea_df.head(10).copy() +top_down = gsea_df.tail(10).copy() + +# 4. Combine them +combined_gsea = pd.concat([top_up, top_down]) + +# 5. Create metrics for plotting +# Direction based on NES sign +combined_gsea['Direction'] = combined_gsea['NES'].apply( + lambda x: 'Upregulated' if x > 0 else 'Downregulated' +) + +# Significance for X-axis (-log10 FDR) +# We add a tiny epsilon (1e-10) to avoid log(0) errors if FDR is exactly 0 +combined_gsea['FDR q-val'] = pd.to_numeric( + combined_gsea['FDR q-val'], errors='coerce' +) +combined_gsea['log_FDR'] = -np.log10(combined_gsea['FDR q-val'] + 1e-10) + +# Gene Count for Dot Size +# GSEApy stores the leading edge genes as a semi-colon separated string in 'Lead_genes' +combined_gsea['Count'] = combined_gsea['Lead_genes'].apply( + lambda x: len(str(x).split(';')) +) + +## remove MSigDB label from Term +combined_gsea['Term'] = combined_gsea['Term'].str.replace( + 'MSigDB_Hallmark_2020__', '', regex=False +) + +print(f'Plotting {len(combined_gsea)} pathways.') +print(combined_gsea[['Term', 'NES', 'FDR q-val', 'Count']].head()) + +# %% +plt.figure(figsize=(10, 8)) + +# Create the scatter plot +sns.scatterplot( + data=combined_gsea, + x='log_FDR', + y='Term', + hue='Direction', # Color by NES Direction + size='Count', # Size by number of Leading Edge genes + palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue + sizes=(50, 400), # Range of dot sizes + alpha=0.8, +) + +# Customization +plt.title('Top GSEA Pathways (Up vs Down)', fontsize=14) +plt.xlabel('-log10(FDR q-value)', fontsize=12) +plt.ylabel('') + +# Add a vertical line for significance (FDR < 0.05 => -log10(0.05) ~= 1.3) +plt.axvline( + -np.log10(0.25), + color='gray', + linestyle=':', + label='FDR=0.25 (GSEA standard)', +) +plt.axvline(-np.log10(0.05), color='gray', linestyle='--', label='FDR=0.05') + +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.0) +plt.grid(axis='x', alpha=0.3) +plt.tight_layout() + +plt.savefig(figure_dir / 'gsea_pathways.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# ### Enrichr analysis for overrepresentation + +# %% +# 1. Define your significant gene lists +# Up in Age +up_genes = res[ + (res['padj'] < 0.05) & (res['log2FoldChange'] > 0) +].index.tolist() + +# Down in Age +down_genes = res[ + (res['padj'] < 0.05) & (res['log2FoldChange'] < 0) +].index.tolist() + +print( + f'Analyzing {len(up_genes)} upregulated and {len(down_genes)} downregulated genes.' +) + +# 2. Run Enrichr (Over-Representation Analysis) +if len(up_genes) > 0: + enr_up = gp.enrichr( + gene_list=up_genes, + gene_sets=['MSigDB_Hallmark_2020'], + organism='human', + outdir=None, + ) + print('Upregulated Pathways:') + print(enr_up.results[['Term', 'Adjusted P-value', 'Overlap']].head(10)) + + +if len(down_genes) > 0: + enr_down = gp.enrichr( + gene_list=down_genes, + gene_sets=['MSigDB_Hallmark_2020'], + organism='human', + outdir=None, + ) + print('Downregulated Pathways:') + print(enr_down.results[['Term', 'Adjusted P-value', 'Overlap']].head(10)) + + +# %% + +# 1. Add a "Direction" column to distinguish them +up_res = enr_up.results.copy() +up_res['Direction'] = 'Upregulated' +up_res['Color'] = 'Red' # For custom palette + +down_res = enr_down.results.copy() +down_res['Direction'] = 'Downregulated' +down_res['Color'] = 'Blue' + +# 2. Filter for top 10 pathways by Adjusted P-value +# (You can also filter by 'Combined Score' if you prefer) +top_up = up_res.sort_values('Adjusted P-value').head(10) +top_down = down_res.sort_values('Adjusted P-value').head(10) + +# 3. Concatenate +combined = pd.concat([top_up, top_down]) + +# 4. Create a "-log10(P-value)" column for plotting +combined['log_p'] = -np.log10(combined['Adjusted P-value']) + +# 5. Extract "Count" from the "Overlap" column (e.g., "5/200" -> 5) +# This is used to size the dots +combined['Gene_Count'] = combined['Overlap'].apply( + lambda x: int(x.split('/')[0]) +) + +print(f'Plotting {len(combined)} pathways.') + + +# %% + + +plt.figure(figsize=(10, 8)) + +# Create the scatter plot +sns.scatterplot( + data=combined, + x='log_p', + y='Term', + hue='Direction', # Color by Up/Down + size='Gene_Count', # Size by number of genes in pathway + palette={'Upregulated': '#E41A1C', 'Downregulated': '#377EB8'}, # Red/Blue + sizes=(50, 400), # Range of dot sizes + alpha=0.8, +) + +# Customization +plt.title('Top Enriched Pathways (Up vs Down)', fontsize=14) +plt.xlabel('-log10(Adjusted P-value)', fontsize=12) +plt.ylabel('') +plt.axvline( + -np.log10(0.05), color='gray', linestyle='--', alpha=0.5, label='p=0.05' +) # Significance threshold line +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0.0) +plt.grid(axis='x', alpha=0.3) +plt.tight_layout() + +plt.savefig(figure_dir / 'enrichr_pathways.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# ### Age prediction from gene expression +# +# Here we will build a predictive model and assess our ability to predict age from held-out individuals. We also test against a baseline model with only sex as a covariate. + +# %% [markdown] +# + +# %% + + +# 1. Prepare features and target +# Features: all genes from counts_df_ct + sex variable +X_genes = counts_df_ct.copy() + +# Add sex as a binary feature (encode as 0/1) +sex_encoded = pd.get_dummies(metadata_ct['sex'], drop_first=True) +X = pd.concat([X_genes, sex_encoded], axis=1) + +# Target: age +y = metadata_ct['age'].values + +print(f'Feature matrix shape: {X.shape}') +print(f'Number of samples: {len(y)}') +print(f'Age range: {y.min():.1f} - {y.max():.1f} years') + +# 2. Set up ShuffleSplit cross-validation +# Using 5 splits with 20% test size +cv = ShuffleSplit(n_splits=5, test_size=0.2, random_state=42) + +# 3. Store results +r2_scores = [] +mae_scores = [] +predictions_list = [] +actual_list = [] + +# 4. Train and evaluate model for each split +for fold, (train_idx, test_idx) in enumerate(cv.split(X)): + print(f'\nFold {fold + 1}/5') + + # Split data + X_train, X_test = X.iloc[train_idx], X.iloc[test_idx] + y_train, y_test = y[train_idx], y[test_idx] + + # Scale features (important for SVR) + scaler = StandardScaler() + X_train_scaled = scaler.fit_transform(X_train) + X_test_scaled = scaler.transform(X_test) + + # Train Linear SVR + # C parameter controls regularization (smaller = more regularization) + model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto') + model.fit(X_train_scaled, y_train) + + # Predict on test set + y_pred = model.predict(X_test_scaled) + + # Calculate metrics + r2 = r2_score(y_test, y_pred) + mae = mean_absolute_error(y_test, y_pred) + + r2_scores.append(r2) + mae_scores.append(mae) + predictions_list.extend(y_pred) + actual_list.extend(y_test) + + print(f' R² Score: {r2:.3f}') + print(f' MAE: {mae:.2f} years') + +# 5. Summary statistics +print('\n' + '=' * 50) +print('CROSS-VALIDATION RESULTS') +print('=' * 50) +print(f'R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}') +print(f'MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years') +print('=' * 50) + +# %% +# Visualize predictions vs actual ages + +plt.figure(figsize=(8, 6)) + +# Scatter plot of predictions vs actual +plt.scatter(actual_list, predictions_list, alpha=0.6, s=80) + +# Add diagonal line (perfect predictions) +min_age = min(min(actual_list), min(predictions_list)) +max_age = max(max(actual_list), max(predictions_list)) +plt.plot( + [min_age, max_age], + [min_age, max_age], + 'r--', + linewidth=2, + label='Perfect Prediction', +) + +plt.xlabel('Actual Age (years)', fontsize=12) +plt.ylabel('Predicted Age (years)', fontsize=12) +plt.title( + f'Age Prediction Performance\nR² = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years', + fontsize=14, +) +plt.legend() +plt.grid(alpha=0.3) +plt.tight_layout() +plt.savefig(figure_dir / 'age_prediction_performance.png', dpi=300, bbox_inches='tight') +plt.close() + +# %% [markdown] +# #### Baseline model: Sex only +# +# Compare against a baseline model that only uses sex as a predictor to assess the contribution of gene expression. + +# %% +# Baseline model: Sex only +X_baseline = sex_encoded.copy() + +# Store baseline results +baseline_r2_scores = [] +baseline_mae_scores = [] + +# Train and evaluate baseline model for each split +for fold, (train_idx, test_idx) in enumerate(cv.split(X_baseline)): + # Split data + X_train, X_test = X_baseline.iloc[train_idx], X_baseline.iloc[test_idx] + y_train, y_test = y[train_idx], y[test_idx] + + # Scale features + scaler = StandardScaler() + X_train_scaled = scaler.fit_transform(X_train) + X_test_scaled = scaler.transform(X_test) + + # Train Linear SVR + model = LinearSVR(C=1.0, max_iter=10000, random_state=42, dual='auto') + model.fit(X_train_scaled, y_train) + + # Predict on test set + y_pred = model.predict(X_test_scaled) + + # Calculate metrics + r2 = r2_score(y_test, y_pred) + mae = mean_absolute_error(y_test, y_pred) + + baseline_r2_scores.append(r2) + baseline_mae_scores.append(mae) + +# Summary comparison +print('=' * 60) +print('MODEL COMPARISON') +print('=' * 60) +print('Full Model (Genes + Sex):') +print(f' R² Score: {np.mean(r2_scores):.3f} ± {np.std(r2_scores):.3f}') +print(f' MAE: {np.mean(mae_scores):.2f} ± {np.std(mae_scores):.2f} years') +print('\nBaseline Model (Sex Only):') +print( + f' R² Score: {np.mean(baseline_r2_scores):.3f} ± {np.std(baseline_r2_scores):.3f}' +) +print( + f' MAE: {np.mean(baseline_mae_scores):.2f} ± {np.std(baseline_mae_scores):.2f} years' +) +print('\nImprovement:') +print(f' ΔR²: {np.mean(r2_scores) - np.mean(baseline_r2_scores):.3f}') +print( + f' ΔMAE: {np.mean(baseline_mae_scores) - np.mean(mae_scores):.2f} years' +) +print('=' * 60) + +# %% diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py new file mode 100644 index 0000000..d707a7e --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/clustering.py @@ -0,0 +1,137 @@ +"""Clustering module for scRNA-seq analysis workflow. + +Functions for cell clustering using Leiden algorithm. +""" + +from pathlib import Path + +import anndata as ad +import matplotlib.pyplot as plt +import pandas as pd +import scanpy as sc + + +def run_leiden_clustering( + adata: ad.AnnData, + resolution: float = 1.0, + key_added: str = "leiden_1.0", + flavor: str = "igraph", + n_iterations: int = 2, +) -> ad.AnnData: + """Run Leiden clustering algorithm. + + Parameters + ---------- + adata : AnnData + AnnData object with neighbor graph + resolution : float + Resolution parameter for clustering + key_added : str + Key to store cluster assignments + flavor : str + Implementation flavor + n_iterations : int + Number of iterations + + Returns + ------- + AnnData + AnnData with cluster assignments + """ + sc.tl.leiden( + adata, + resolution=resolution, + key_added=key_added, + flavor=flavor, + n_iterations=n_iterations, + ) + return adata + + +def plot_clusters( + adata: ad.AnnData, + cluster_key: str = "leiden_1.0", + cell_type_key: str = "cell_type", + figure_dir: Path | None = None, +) -> None: + """Plot UMAP colored by clusters and cell types. + + Parameters + ---------- + adata : AnnData + AnnData object with UMAP and clusters + cluster_key : str + Key for cluster assignments + cell_type_key : str + Key for cell type annotations + figure_dir : Path, optional + Directory to save figures + """ + sc.pl.umap(adata, color=[cell_type_key, cluster_key], wspace=0.3, show=False) + if figure_dir is not None: + plt.savefig( + figure_dir / "umap_cell_type_leiden.png", dpi=300, bbox_inches="tight" + ) + plt.close() + + +def compute_cluster_celltype_overlap( + adata: ad.AnnData, + cluster_key: str = "leiden_1.0", + cell_type_key: str = "cell_type", +) -> pd.DataFrame: + """Compute contingency table between clusters and cell types. + + Parameters + ---------- + adata : AnnData + AnnData object with clusters and cell types + cluster_key : str + Key for cluster assignments + cell_type_key : str + Key for cell type annotations + + Returns + ------- + pd.DataFrame + Contingency table + """ + contingency_table = pd.crosstab(adata.obs[cluster_key], adata.obs[cell_type_key]) + return contingency_table + + +def run_clustering_pipeline( + adata: ad.AnnData, + resolution: float = 1.0, + figure_dir: Path | None = None, +) -> ad.AnnData: + """Run complete clustering pipeline. + + Parameters + ---------- + adata : AnnData + Input AnnData object with UMAP computed + resolution : float + Leiden resolution parameter + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + AnnData + AnnData with cluster assignments + """ + cluster_key = f"leiden_{resolution}" + + # Run Leiden clustering + adata = run_leiden_clustering(adata, resolution, cluster_key) + + # Plot clusters + plot_clusters(adata, cluster_key, figure_dir=figure_dir) + + # Compute and print overlap + contingency = compute_cluster_celltype_overlap(adata, cluster_key) + print("Cluster-Cell Type Contingency Table:") + print(contingency) + + return adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py new file mode 100644 index 0000000..2bc75d6 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_filtering.py @@ -0,0 +1,246 @@ +"""Data filtering module for scRNA-seq analysis workflow. + +Functions for filtering donors and cell types with insufficient observations. +""" + +from pathlib import Path + +import anndata as ad +import matplotlib.pyplot as plt +import pandas as pd +import scanpy as sc +from scipy.stats import scoreatpercentile + + +def compute_donor_cell_counts(adata: ad.AnnData) -> pd.Series: + """Calculate how many cells each donor has. + + Parameters + ---------- + adata : AnnData + AnnData object with 'donor_id' in obs + + Returns + ------- + pd.Series + Cell counts per donor + """ + return pd.Series(adata.obs["donor_id"]).value_counts() + + +def plot_donor_cell_distribution( + donor_cell_counts: pd.Series, + cutoff_percentile: float = 1.0, + figure_dir: Path | None = None, +) -> int: + """Plot distribution of cells per donor and determine cutoff. + + Parameters + ---------- + donor_cell_counts : pd.Series + Cell counts per donor + cutoff_percentile : float + Percentile to use as cutoff (default: 1.0) + figure_dir : Path, optional + Directory to save figure + + Returns + ------- + int + Minimum cells per donor cutoff + """ + min_cells_per_donor = int( + scoreatpercentile(donor_cell_counts.values, cutoff_percentile) + ) + + plt.figure(figsize=(10, 6)) + plt.hist(donor_cell_counts.values, bins=50, color="skyblue", edgecolor="black") + plt.title("Distribution of Total Cells per Donor") + plt.xlabel("Number of Cells Captured") + plt.ylabel("Number of Donors") + plt.grid(axis="y", alpha=0.5) + + print( + f"cutoff of {min_cells_per_donor} would exclude " + f"{(donor_cell_counts < min_cells_per_donor).sum()} donors" + ) + plt.axvline( + min_cells_per_donor, + color="red", + linestyle="dashed", + linewidth=1, + label=f"Cutoff ({min_cells_per_donor} cells)", + ) + plt.legend() + + if figure_dir is not None: + plt.savefig( + figure_dir / "donor_cell_counts_distribution.png", + dpi=300, + bbox_inches="tight", + ) + plt.close() + + return min_cells_per_donor + + +def filter_donors_by_cell_count( + adata: ad.AnnData, min_cells_per_donor: int +) -> ad.AnnData: + """Filter to keep only donors with sufficient cells. + + Parameters + ---------- + adata : AnnData + AnnData object + min_cells_per_donor : int + Minimum cells required per donor + + Returns + ------- + AnnData + Filtered AnnData object + """ + donor_cell_counts = compute_donor_cell_counts(adata) + print(f"Filtering to keep only donors with at least {min_cells_per_donor} cells.") + print( + f"Number of donors excluded: {(donor_cell_counts < min_cells_per_donor).sum()}" + ) + valid_donors = donor_cell_counts[donor_cell_counts >= min_cells_per_donor].index + filtered = adata[adata.obs["donor_id"].isin(valid_donors)] + print(f"Number of donors after filtering: {len(valid_donors)}") + return filtered + + +def filter_cell_types_by_frequency( + adata: ad.AnnData, min_cells: int = 10, percent_donors: float = 0.95 +) -> ad.AnnData: + """Filter cell types that don't have sufficient observations. + + Keep cell types with at least min_cells in at least percent_donors of donors. + + Parameters + ---------- + adata : AnnData + AnnData object + min_cells : int + Minimum cells per cell type per donor + percent_donors : float + Fraction of donors that must meet the min_cells threshold + + Returns + ------- + AnnData + Filtered AnnData object + """ + counts_per_donor = pd.crosstab(adata.obs["donor_id"], adata.obs["cell_type"]) + donor_count = counts_per_donor.shape[0] + + cell_types_to_keep = counts_per_donor.columns[ + (counts_per_donor >= min_cells).sum(axis=0) >= (donor_count * percent_donors) + ] + + print( + f"Keeping {len(cell_types_to_keep)} cell types out of " + f"{len(counts_per_donor.columns)}" + ) + print(f"Cell types to keep: {cell_types_to_keep.tolist()}") + + return adata[adata.obs["cell_type"].isin(cell_types_to_keep)] + + +def filter_donors_with_missing_cell_types( + adata: ad.AnnData, min_cells: int = 10 +) -> ad.AnnData: + """Filter donors who have zeros in any remaining cell types. + + Parameters + ---------- + adata : AnnData + AnnData object + min_cells : int + Minimum cells per cell type per donor + + Returns + ------- + AnnData + Filtered AnnData object + """ + donor_celltype_counts = pd.crosstab(adata.obs["donor_id"], adata.obs["cell_type"]) + valid_donors = donor_celltype_counts.index[ + (donor_celltype_counts >= min_cells).all(axis=1) + ] + filtered = adata[adata.obs["donor_id"].isin(valid_donors)] + print(f"Final number of donors after filtering: {len(valid_donors)}") + return filtered + + +def load_to_memory_and_filter_genes(adata: ad.AnnData) -> ad.AnnData: + """Load lazy AnnData to memory and filter zero-count genes. + + Parameters + ---------- + adata : AnnData + Lazy AnnData object + + Returns + ------- + AnnData + In-memory AnnData with filtered genes + """ + print("Loading data into memory (this can take a few minutes)...") + adata_loaded = adata.to_memory() + + print("Filtering genes with zero counts...") + sc.pp.filter_genes(adata_loaded, min_counts=1) + + return adata_loaded + + +def run_filtering_pipeline( + adata: ad.AnnData, + cutoff_percentile: float = 1.0, + min_cells_per_celltype: int = 10, + percent_donors: float = 0.95, + figure_dir: Path | None = None, +) -> ad.AnnData: + """Run complete filtering pipeline. + + Parameters + ---------- + adata : AnnData + Input AnnData object (can be lazy) + cutoff_percentile : float + Percentile for donor cell count cutoff + min_cells_per_celltype : int + Minimum cells per cell type per donor + percent_donors : float + Fraction of donors that must meet cell count threshold + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + AnnData + Filtered and loaded AnnData object + """ + # Step 1: Filter donors by total cell count + donor_counts = compute_donor_cell_counts(adata) + min_cells = plot_donor_cell_distribution( + donor_counts, cutoff_percentile, figure_dir + ) + adata = filter_donors_by_cell_count(adata, min_cells) + + # Step 2: Filter cell types by frequency + adata = filter_cell_types_by_frequency( + adata, min_cells_per_celltype, percent_donors + ) + + # Step 3: Filter donors with missing cell types + adata = filter_donors_with_missing_cell_types(adata, min_cells_per_celltype) + + # Step 4: Load to memory and filter genes + adata = load_to_memory_and_filter_genes(adata) + + print(f"Final dataset shape: {adata.shape}") + return adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py new file mode 100644 index 0000000..491784c --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/data_loading.py @@ -0,0 +1,77 @@ +"""Data loading module for scRNA-seq analysis workflow. + +Functions for downloading and loading single-cell RNA-seq data. +""" + +import os +from pathlib import Path + +import anndata as ad +import h5py +from anndata.experimental import read_lazy + + +def download_data(datafile: Path, url: str) -> None: + """Download data file if it doesn't exist. + + Parameters + ---------- + datafile : Path + Path to save the downloaded file + url : str + URL to download from + """ + if not datafile.exists(): + cmd = f"wget -O {datafile.as_posix()} {url}" + print(f"Downloading data from {url} to {datafile.as_posix()}") + os.system(cmd) + + +def load_lazy_anndata(datafile: Path, load_annotation_index: bool = True) -> ad.AnnData: + """Load AnnData object lazily from h5ad file. + + Parameters + ---------- + datafile : Path + Path to h5ad file + load_annotation_index : bool + Whether to load annotation index + + Returns + ------- + AnnData + Lazily loaded AnnData object + """ + adata = read_lazy( + h5py.File(datafile, "r"), load_annotation_index=load_annotation_index + ) + return adata + + +def load_anndata(datafile: Path) -> ad.AnnData: + """Load AnnData object from h5ad file. + + Parameters + ---------- + datafile : Path + Path to h5ad file + + Returns + ------- + AnnData + AnnData object + """ + return ad.read_h5ad(datafile) + + +def save_anndata(adata: ad.AnnData, filepath: Path) -> None: + """Save AnnData object to h5ad file. + + Parameters + ---------- + adata : AnnData + AnnData object to save + filepath : Path + Path to save the file + """ + adata.write(filepath) diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py new file mode 100644 index 0000000..ec257a7 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/differential_expression.py @@ -0,0 +1,268 @@ +"""Differential expression module for scRNA-seq analysis workflow. + +Functions for running DESeq2-based differential expression analysis. +""" + +import anndata as ad +import numpy as np +import pandas as pd +from pydeseq2.dds import DeseqDataSet +from pydeseq2.ds import DeseqStats +from sklearn.preprocessing import StandardScaler + + +def extract_age_from_development_stage(pb_adata: ad.AnnData) -> ad.AnnData: + """Extract numeric age from development_stage column. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData with 'development_stage' in obs + + Returns + ------- + AnnData + AnnData with 'age' column added to obs + """ + ages = ( + pb_adata.obs["development_stage"].str.extract(r"(\d+)-year-old").astype(float) + ) + pb_adata.obs["age"] = ages + return pb_adata + + +def prepare_deseq_inputs( + pb_adata: ad.AnnData, + var_to_feature: dict | None = None, +) -> tuple[pd.DataFrame, pd.DataFrame]: + """Prepare counts and metadata for DESeq2. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + var_to_feature : dict, optional + Mapping from var_names to feature names + + Returns + ------- + tuple[pd.DataFrame, pd.DataFrame] + Counts dataframe and metadata dataframe + """ + # Extract counts + if var_to_feature is not None: + columns = [var_to_feature.get(var, var) for var in pb_adata.var_names] + else: + columns = pb_adata.var_names.tolist() + + counts_df = pd.DataFrame( + pb_adata.X.toarray(), + index=pb_adata.obs_names, + columns=columns, + ) + # Remove duplicate columns + counts_df = counts_df.loc[:, ~counts_df.columns.duplicated()] + + # Extract metadata + metadata = pb_adata.obs.copy() + + # Scale continuous variables + if "age" in metadata.columns: + scaler = StandardScaler() + metadata["age_scaled"] = scaler.fit_transform(metadata[["age"]]).flatten() + metadata["age_scaled"] = metadata["age_scaled"].astype(float) + print("Age scaling applied:") + print(metadata[["age", "age_scaled"]].head()) + + return counts_df, metadata + + +def subset_by_cell_type( + pb_adata: ad.AnnData, + counts_df: pd.DataFrame, + metadata: pd.DataFrame, + cell_type: str, +) -> tuple[ad.AnnData, pd.DataFrame, pd.DataFrame]: + """Subset data to a specific cell type. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + counts_df : pd.DataFrame + Counts dataframe + metadata : pd.DataFrame + Metadata dataframe + cell_type : str + Cell type to subset to + + Returns + ------- + tuple[AnnData, pd.DataFrame, pd.DataFrame] + Subsetted AnnData, counts, and metadata + """ + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy() + counts_df_ct = counts_df.loc[pb_adata_ct.obs_names].copy() + metadata_ct = metadata.loc[pb_adata_ct.obs_names].copy() + + return pb_adata_ct, counts_df_ct, metadata_ct + + +def run_deseq2( + counts_df: pd.DataFrame, + metadata: pd.DataFrame, + design_factors: list[str], + n_cpus: int = 2, +) -> DeseqDataSet: + """Initialize and fit DESeq2 model. + + Parameters + ---------- + counts_df : pd.DataFrame + Counts dataframe + metadata : pd.DataFrame + Metadata dataframe + design_factors : list[str] + Design factors for the model + n_cpus : int + Number of CPUs for parallel processing + + Returns + ------- + DeseqDataSet + Fitted DESeq2 dataset + """ + # Validate required columns + for factor in design_factors: + assert factor in metadata.columns, f"{factor} column missing in metadata" + + # Initialize and fit + dds = DeseqDataSet( + counts=counts_df, + metadata=metadata, + design_factors=design_factors, + refit_cooks=True, + n_cpus=n_cpus, + ) + dds.deseq2() + + return dds + + +def run_wald_test( + dds: DeseqDataSet, + contrast: np.ndarray | None = None, +) -> DeseqStats: + """Run Wald test for differential expression. + + Parameters + ---------- + dds : DeseqDataSet + Fitted DESeq2 dataset + contrast : np.ndarray, optional + Contrast vector for the test + + Returns + ------- + DeseqStats + Statistics results object + """ + model_vars = dds.varm["LFC"].columns + print(f"Model variables: {model_vars.tolist()}") + + if contrast is None: + # Default: test second variable (typically age_scaled) + contrast = np.zeros(len(model_vars)) + contrast[1] = 1 + + print(f"Contrast: {contrast}") + + stat_res = DeseqStats(dds, contrast=contrast) + stat_res.summary() + stat_res.run_wald_test() + + return stat_res + + +def get_significant_genes( + stat_res: DeseqStats, + padj_threshold: float = 0.05, +) -> pd.DataFrame: + """Extract significant genes from DESeq2 results. + + Parameters + ---------- + stat_res : DeseqStats + DESeq2 statistics results + padj_threshold : float + Adjusted p-value threshold + + Returns + ------- + pd.DataFrame + Significant genes sorted by log2 fold change + """ + res = stat_res.results_df + sigs = res[res["padj"] < padj_threshold] + sigs = sigs.sort_values("log2FoldChange", ascending=False) + + print(f"Found {len(sigs)} significant genes.") + print(sigs[["log2FoldChange", "padj"]].head()) + + return sigs + + +def run_differential_expression_pipeline( + pb_adata: ad.AnnData, + cell_type: str, + design_factors: list[str] | None = None, + var_to_feature: dict | None = None, + n_cpus: int = 8, +) -> tuple[DeseqStats, pd.DataFrame, pd.DataFrame]: + """Run complete differential expression pipeline for a cell type. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + cell_type : str + Cell type to analyze + design_factors : list[str], optional + Design factors (default: ['age_scaled', 'sex']) + var_to_feature : dict, optional + Mapping from var_names to feature names + n_cpus : int + Number of CPUs + + Returns + ------- + tuple[DeseqStats, pd.DataFrame, pd.DataFrame] + Statistics results, full results dataframe, and counts dataframe + """ + if design_factors is None: + design_factors = ["age_scaled", "sex"] + + # Extract age + pb_adata = extract_age_from_development_stage(pb_adata) + + # Prepare inputs + counts_df, metadata = prepare_deseq_inputs(pb_adata, var_to_feature) + + # Subset to cell type + _, counts_df_ct, metadata_ct = subset_by_cell_type( + pb_adata, counts_df, metadata, cell_type + ) + + print(f"Running DE analysis for cell type: {cell_type}") + print(f"Number of samples: {len(counts_df_ct)}") + + # Run DESeq2 + dds = run_deseq2(counts_df_ct, metadata_ct, design_factors, n_cpus) + + # Run Wald test + stat_res = run_wald_test(dds) + + # Get significant genes + _ = get_significant_genes(stat_res) + + return stat_res, stat_res.results_df, counts_df_ct diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py new file mode 100644 index 0000000..ddd7146 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/dimensionality_reduction.py @@ -0,0 +1,182 @@ +"""Dimensionality reduction module for scRNA-seq analysis workflow. + +Functions for batch correction, neighbor computation, and UMAP generation. +""" + +from pathlib import Path + +import anndata as ad +import matplotlib.pyplot as plt +import scanpy as sc +import scanpy.external as sce + + +def run_harmony_integration( + adata: ad.AnnData, + batch_key: str = "donor_id", + basis: str = "X_pca", + adjusted_basis: str = "X_pca_harmony", +) -> tuple[ad.AnnData, str]: + """Run Harmony batch correction on PCA coordinates. + + Parameters + ---------- + adata : AnnData + AnnData object with PCA computed + batch_key : str + Column name for batch variable + basis : str + Name of PCA coordinates + adjusted_basis : str + Name for corrected coordinates + + Returns + ------- + tuple[AnnData, str] + AnnData with Harmony results and the representation to use + """ + try: + sce.pp.harmony_integrate( + adata, key=batch_key, basis=basis, adjusted_basis=adjusted_basis + ) + use_rep = adjusted_basis + print("Harmony integration successful. Using corrected PCA.") + except ImportError: + print( + "Harmony not installed. Proceeding with standard PCA " + "(Warning: Batch effects may persist)." + ) + print("To install: pip install harmony-pytorch") + use_rep = basis + + return adata, use_rep + + +def plot_pca_qc(adata: ad.AnnData, figure_dir: Path | None = None) -> None: + """Plot PCA colored by total counts and cell type. + + Parameters + ---------- + adata : AnnData + AnnData object with PCA computed + figure_dir : Path, optional + Directory to save figures + """ + sc.pl.pca( + adata, color=["total_counts", "cell_type"], components=["1,2"], show=False + ) + if figure_dir is not None: + plt.savefig(figure_dir / "pca_cell_type.png", dpi=300, bbox_inches="tight") + plt.close() + + +def compute_neighbors( + adata: ad.AnnData, + n_neighbors: int = 30, + n_pcs: int = 40, + use_rep: str = "X_pca_harmony", +) -> ad.AnnData: + """Compute neighborhood graph. + + Parameters + ---------- + adata : AnnData + AnnData object + n_neighbors : int + Number of neighbors + n_pcs : int + Number of PCs to use + use_rep : str + Representation to use + + Returns + ------- + AnnData + AnnData with neighbor graph + """ + sc.pp.neighbors(adata, n_neighbors=n_neighbors, n_pcs=n_pcs, use_rep=use_rep) + return adata + + +def compute_umap( + adata: ad.AnnData, + init_pos: str = "X_pca_harmony", +) -> ad.AnnData: + """Compute UMAP embedding. + + Parameters + ---------- + adata : AnnData + AnnData object with neighbor graph + init_pos : str + Initial position for UMAP + + Returns + ------- + AnnData + AnnData with UMAP coordinates + """ + sc.tl.umap(adata, init_pos=init_pos) + return adata + + +def plot_umap_qc(adata: ad.AnnData, figure_dir: Path | None = None) -> None: + """Plot UMAP colored by total counts. + + Parameters + ---------- + adata : AnnData + AnnData object with UMAP + figure_dir : Path, optional + Directory to save figures + """ + sc.pl.umap(adata, color="total_counts", show=False) + if figure_dir is not None: + plt.savefig(figure_dir / "umap_total_counts.png", dpi=300, bbox_inches="tight") + plt.close() + + +def run_dimensionality_reduction_pipeline( + adata: ad.AnnData, + batch_key: str = "donor_id", + n_neighbors: int = 30, + n_pcs: int = 40, + figure_dir: Path | None = None, +) -> ad.AnnData: + """Run complete dimensionality reduction pipeline. + + Parameters + ---------- + adata : AnnData + Input AnnData object with PCA computed + batch_key : str + Column for batch correction + n_neighbors : int + Number of neighbors for graph + n_pcs : int + Number of PCs to use + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + AnnData + AnnData with UMAP coordinates + """ + # Run Harmony integration + adata, use_rep = run_harmony_integration(adata, batch_key) + + # Plot PCA QC + plot_pca_qc(adata, figure_dir) + + # Compute neighbors + adata = compute_neighbors(adata, n_neighbors, n_pcs, use_rep) + + # Compute UMAP + init_pos = use_rep if use_rep == "X_pca_harmony" else "spectral" + adata = compute_umap(adata, init_pos) + + # Plot UMAP QC + plot_umap_qc(adata, figure_dir) + + return adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py new file mode 100644 index 0000000..9aa6dd2 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/overrepresentation_analysis.py @@ -0,0 +1,262 @@ +"""Overrepresentation analysis module for scRNA-seq analysis workflow. + +Functions for Enrichr-based overrepresentation analysis. +""" + +from pathlib import Path + +import gseapy as gp +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns + + +def get_significant_gene_lists( + results_df: pd.DataFrame, + padj_threshold: float = 0.05, +) -> tuple[list[str], list[str]]: + """Extract lists of up and down regulated genes. + + Parameters + ---------- + results_df : pd.DataFrame + DESeq2 results dataframe + padj_threshold : float + Adjusted p-value threshold + + Returns + ------- + tuple[list[str], list[str]] + Lists of upregulated and downregulated genes + """ + up_genes = results_df[ + (results_df["padj"] < padj_threshold) & (results_df["log2FoldChange"] > 0) + ].index.tolist() + + down_genes = results_df[ + (results_df["padj"] < padj_threshold) & (results_df["log2FoldChange"] < 0) + ].index.tolist() + + print( + f"Analyzing {len(up_genes)} upregulated and " + f"{len(down_genes)} downregulated genes." + ) + + return up_genes, down_genes + + +def run_enrichr( + gene_list: list[str], + gene_sets: list[str] | None = None, + organism: str = "human", +) -> gp.Enrichr | None: + """Run Enrichr overrepresentation analysis. + + Parameters + ---------- + gene_list : list[str] + List of gene names + gene_sets : list[str], optional + Gene set databases to use + organism : str + Organism name + + Returns + ------- + gp.Enrichr or None + Enrichr results object or None if no genes + """ + if len(gene_list) == 0: + print("No genes to analyze.") + return None + + if gene_sets is None: + gene_sets = ["MSigDB_Hallmark_2020"] + + enr = gp.enrichr( + gene_list=gene_list, + gene_sets=gene_sets, + organism=organism, + outdir=None, + ) + + return enr + + +def run_enrichr_both_directions( + results_df: pd.DataFrame, + gene_sets: list[str] | None = None, + padj_threshold: float = 0.05, +) -> tuple[gp.Enrichr | None, gp.Enrichr | None]: + """Run Enrichr for both up and down regulated genes. + + Parameters + ---------- + results_df : pd.DataFrame + DESeq2 results dataframe + gene_sets : list[str], optional + Gene set databases + padj_threshold : float + Adjusted p-value threshold + + Returns + ------- + tuple[gp.Enrichr, gp.Enrichr] + Enrichr results for up and down genes + """ + up_genes, down_genes = get_significant_gene_lists(results_df, padj_threshold) + + enr_up = None + enr_down = None + + if len(up_genes) > 0: + enr_up = run_enrichr(up_genes, gene_sets) + if enr_up is not None: + print("Upregulated Pathways:") + print(enr_up.results[["Term", "Adjusted P-value", "Overlap"]].head(10)) + + if len(down_genes) > 0: + enr_down = run_enrichr(down_genes, gene_sets) + if enr_down is not None: + print("Downregulated Pathways:") + print(enr_down.results[["Term", "Adjusted P-value", "Overlap"]].head(10)) + + return enr_up, enr_down + + +def prepare_enrichr_plot_data( + enr_up: gp.Enrichr | None, + enr_down: gp.Enrichr | None, + n_top: int = 10, +) -> pd.DataFrame | None: + """Prepare Enrichr results for plotting. + + Parameters + ---------- + enr_up : gp.Enrichr + Enrichr results for upregulated genes + enr_down : gp.Enrichr + Enrichr results for downregulated genes + n_top : int + Number of top pathways per direction + + Returns + ------- + pd.DataFrame or None + Combined dataframe for plotting + """ + dfs = [] + + if enr_up is not None: + up_res = enr_up.results.copy() + up_res["Direction"] = "Upregulated" + up_res["Color"] = "Red" + top_up = up_res.sort_values("Adjusted P-value").head(n_top) + dfs.append(top_up) + + if enr_down is not None: + down_res = enr_down.results.copy() + down_res["Direction"] = "Downregulated" + down_res["Color"] = "Blue" + top_down = down_res.sort_values("Adjusted P-value").head(n_top) + dfs.append(top_down) + + if not dfs: + return None + + combined = pd.concat(dfs) + + # Compute -log10(P-value) + combined["log_p"] = -np.log10(combined["Adjusted P-value"]) + + # Extract gene count from Overlap (e.g., "5/200" -> 5) + combined["Gene_Count"] = combined["Overlap"].apply(lambda x: int(x.split("/")[0])) + + return combined + + +def plot_enrichr_results( + combined: pd.DataFrame, + figure_dir: Path | None = None, + title: str = "Top Enriched Pathways (Up vs Down)", +) -> None: + """Plot Enrichr results as dot plot. + + Parameters + ---------- + combined : pd.DataFrame + Prepared Enrichr dataframe + figure_dir : Path, optional + Directory to save figures + title : str + Plot title + """ + print(f"Plotting {len(combined)} pathways.") + + plt.figure(figsize=(10, 8)) + + sns.scatterplot( + data=combined, + x="log_p", + y="Term", + hue="Direction", + size="Gene_Count", + palette={"Upregulated": "#E41A1C", "Downregulated": "#377EB8"}, + sizes=(50, 400), + alpha=0.8, + ) + + plt.title(title, fontsize=14) + plt.xlabel("-log10(Adjusted P-value)", fontsize=12) + plt.ylabel("") + plt.axvline( + -np.log10(0.05), color="gray", linestyle="--", alpha=0.5, label="p=0.05" + ) + plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0) + plt.grid(axis="x", alpha=0.3) + plt.tight_layout() + + if figure_dir is not None: + plt.savefig(figure_dir / "enrichr_pathways.png", dpi=300, bbox_inches="tight") + plt.close() + + +def run_overrepresentation_pipeline( + results_df: pd.DataFrame, + gene_sets: list[str] | None = None, + padj_threshold: float = 0.05, + n_top: int = 10, + figure_dir: Path | None = None, +) -> tuple[gp.Enrichr | None, gp.Enrichr | None]: + """Run complete overrepresentation analysis pipeline. + + Parameters + ---------- + results_df : pd.DataFrame + DESeq2 results dataframe + gene_sets : list[str], optional + Gene set databases + padj_threshold : float + Adjusted p-value threshold + n_top : int + Number of top pathways to show + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + tuple[gp.Enrichr, gp.Enrichr] + Enrichr results for up and down genes + """ + # Run Enrichr + enr_up, enr_down = run_enrichr_both_directions( + results_df, gene_sets, padj_threshold + ) + + # Prepare and plot + combined = prepare_enrichr_plot_data(enr_up, enr_down, n_top) + if combined is not None: + plot_enrichr_results(combined, figure_dir) + + return enr_up, enr_down diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py new file mode 100644 index 0000000..bdba7a5 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pathway_analysis.py @@ -0,0 +1,249 @@ +"""Pathway analysis module for scRNA-seq analysis workflow. + +Functions for Gene Set Enrichment Analysis (GSEA). +""" + +from pathlib import Path + +import gseapy as gp +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns + + +def prepare_ranked_list(results_df: pd.DataFrame) -> pd.DataFrame: + """Prepare ranked gene list for GSEA from DE results. + + Parameters + ---------- + results_df : pd.DataFrame + DESeq2 results dataframe with 'stat' column + + Returns + ------- + pd.DataFrame + Ranked gene list sorted by statistic + """ + rank_df = results_df[["stat"]].dropna().sort_values("stat", ascending=False) + return rank_df + + +def run_gsea_prerank( + rank_df: pd.DataFrame, + gene_sets: list[str] | None = None, + min_size: int = 10, + max_size: int = 1000, + permutation_num: int = 1000, + threads: int = 4, + seed: int = 42, +) -> gp.GSEA: + """Run GSEA preranked analysis. + + Parameters + ---------- + rank_df : pd.DataFrame + Ranked gene list + gene_sets : list[str], optional + Gene set databases to use + min_size : int + Minimum genes in pathway + max_size : int + Maximum genes in pathway + permutation_num : int + Number of permutations + threads : int + Number of threads + seed : int + Random seed + + Returns + ------- + gp.GSEA + GSEA results object + """ + if gene_sets is None: + gene_sets = ["MSigDB_Hallmark_2020"] + + prerank_res = gp.prerank( + rnk=rank_df, + gene_sets=gene_sets, + threads=threads, + min_size=min_size, + max_size=max_size, + permutation_num=permutation_num, + seed=seed, + ) + + return prerank_res + + +def get_gsea_top_terms( + prerank_res: gp.GSEA, + n_top: int = 10, +) -> tuple[pd.DataFrame, pd.DataFrame]: + """Get top upregulated and downregulated pathways. + + Parameters + ---------- + prerank_res : gp.GSEA + GSEA results object + n_top : int + Number of top terms to return + + Returns + ------- + tuple[pd.DataFrame, pd.DataFrame] + Top upregulated and downregulated pathways + """ + terms = prerank_res.res2d.sort_values("NES", ascending=False) + + print("Top Upregulated Pathways:") + print(terms[["Term", "NES", "FDR q-val"]].head(n_top)) + + print("\nTop Downregulated Pathways:") + print(terms[["Term", "NES", "FDR q-val"]].tail(n_top)) + + top_up = terms.head(n_top) + top_down = terms.tail(n_top) + + return top_up, top_down + + +def prepare_gsea_plot_data( + prerank_res: gp.GSEA, + n_top: int = 10, + label_prefix: str = "MSigDB_Hallmark_2020__", +) -> pd.DataFrame: + """Prepare GSEA results for plotting. + + Parameters + ---------- + prerank_res : gp.GSEA + GSEA results object + n_top : int + Number of top terms per direction + label_prefix : str + Prefix to remove from term names + + Returns + ------- + pd.DataFrame + Prepared dataframe for plotting + """ + gsea_df = prerank_res.res2d.copy() + gsea_df = gsea_df.sort_values("NES", ascending=False) + + top_up = gsea_df.head(n_top).copy() + top_down = gsea_df.tail(n_top).copy() + combined = pd.concat([top_up, top_down]) + + # Add direction + combined["Direction"] = combined["NES"].apply( + lambda x: "Upregulated" if x > 0 else "Downregulated" + ) + + # Compute -log10(FDR) + combined["FDR q-val"] = pd.to_numeric(combined["FDR q-val"], errors="coerce") + combined["log_FDR"] = -np.log10(combined["FDR q-val"] + 1e-10) + + # Get gene count from leading edge + combined["Count"] = combined["Lead_genes"].apply(lambda x: len(str(x).split(";"))) + + # Clean term names + combined["Term"] = combined["Term"].str.replace(label_prefix, "", regex=False) + + return combined + + +def plot_gsea_results( + combined_gsea: pd.DataFrame, + figure_dir: Path | None = None, + title: str = "Top GSEA Pathways (Up vs Down)", +) -> None: + """Plot GSEA results as dot plot. + + Parameters + ---------- + combined_gsea : pd.DataFrame + Prepared GSEA dataframe + figure_dir : Path, optional + Directory to save figures + title : str + Plot title + """ + plt.figure(figsize=(10, 8)) + + sns.scatterplot( + data=combined_gsea, + x="log_FDR", + y="Term", + hue="Direction", + size="Count", + palette={"Upregulated": "#E41A1C", "Downregulated": "#377EB8"}, + sizes=(50, 400), + alpha=0.8, + ) + + plt.title(title, fontsize=14) + plt.xlabel("-log10(FDR q-value)", fontsize=12) + plt.ylabel("") + + plt.axvline( + -np.log10(0.25), + color="gray", + linestyle=":", + label="FDR=0.25 (GSEA standard)", + ) + plt.axvline(-np.log10(0.05), color="gray", linestyle="--", label="FDR=0.05") + + plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0) + plt.grid(axis="x", alpha=0.3) + plt.tight_layout() + + if figure_dir is not None: + plt.savefig(figure_dir / "gsea_pathways.png", dpi=300, bbox_inches="tight") + plt.close() + + +def run_gsea_pipeline( + results_df: pd.DataFrame, + gene_sets: list[str] | None = None, + n_top: int = 10, + figure_dir: Path | None = None, +) -> gp.GSEA: + """Run complete GSEA pipeline. + + Parameters + ---------- + results_df : pd.DataFrame + DESeq2 results dataframe + gene_sets : list[str], optional + Gene set databases + n_top : int + Number of top pathways to show + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + gp.GSEA + GSEA results object + """ + # Prepare ranked list + rank_df = prepare_ranked_list(results_df) + + # Run GSEA + prerank_res = run_gsea_prerank(rank_df, gene_sets) + + # Get top terms + get_gsea_top_terms(prerank_res, n_top) + + # Prepare and plot + combined = prepare_gsea_plot_data(prerank_res, n_top) + print(f"Plotting {len(combined)} pathways.") + print(combined[["Term", "NES", "FDR q-val", "Count"]].head()) + + plot_gsea_results(combined, figure_dir) + + return prerank_res diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py new file mode 100644 index 0000000..474ecb4 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/predictive_modeling.py @@ -0,0 +1,337 @@ +"""Predictive modeling module for scRNA-seq analysis workflow. + +Functions for building and evaluating age prediction models. +""" + +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from sklearn.metrics import mean_absolute_error, r2_score +from sklearn.model_selection import ShuffleSplit +from sklearn.preprocessing import StandardScaler +from sklearn.svm import LinearSVR + + +def prepare_features( + counts_df: pd.DataFrame, + metadata: pd.DataFrame, +) -> tuple[pd.DataFrame, np.ndarray]: + """Prepare feature matrix and target variable. + + Parameters + ---------- + counts_df : pd.DataFrame + Gene expression counts + metadata : pd.DataFrame + Metadata with 'age' and 'sex' columns + + Returns + ------- + tuple[pd.DataFrame, np.ndarray] + Feature matrix (genes + sex) and age target + """ + X_genes = counts_df.copy() + + # Add sex as binary feature + sex_encoded = pd.get_dummies(metadata["sex"], drop_first=True) + X = pd.concat([X_genes, sex_encoded], axis=1) + + # Target: age + y = metadata["age"].values + + print(f"Feature matrix shape: {X.shape}") + print(f"Number of samples: {len(y)}") + print(f"Age range: {y.min():.1f} - {y.max():.1f} years") + + return X, y + + +def prepare_baseline_features(metadata: pd.DataFrame) -> pd.DataFrame: + """Prepare baseline feature matrix (sex only). + + Parameters + ---------- + metadata : pd.DataFrame + Metadata with 'sex' column + + Returns + ------- + pd.DataFrame + Sex-only feature matrix + """ + return pd.get_dummies(metadata["sex"], drop_first=True) + + +def train_evaluate_fold( + X_train: np.ndarray, + X_test: np.ndarray, + y_train: np.ndarray, + y_test: np.ndarray, + C: float = 1.0, + max_iter: int = 10000, + random_state: int = 42, +) -> tuple[float, float, np.ndarray]: + """Train and evaluate model for one fold. + + Parameters + ---------- + X_train : np.ndarray + Training features + X_test : np.ndarray + Test features + y_train : np.ndarray + Training target + y_test : np.ndarray + Test target + C : float + Regularization parameter + max_iter : int + Maximum iterations + random_state : int + Random seed + + Returns + ------- + tuple[float, float, np.ndarray] + R2 score, MAE, and predictions + """ + # Scale features + scaler = StandardScaler() + X_train_scaled = scaler.fit_transform(X_train) + X_test_scaled = scaler.transform(X_test) + + # Train model + model = LinearSVR(C=C, max_iter=max_iter, random_state=random_state, dual="auto") + model.fit(X_train_scaled, y_train) + + # Predict + y_pred = model.predict(X_test_scaled) + + # Metrics + r2 = r2_score(y_test, y_pred) + mae = mean_absolute_error(y_test, y_pred) + + return r2, mae, y_pred + + +def run_cross_validation( + X: pd.DataFrame, + y: np.ndarray, + n_splits: int = 5, + test_size: float = 0.2, + random_state: int = 42, +) -> tuple[list[float], list[float], list[float], list[float]]: + """Run cross-validation for age prediction. + + Parameters + ---------- + X : pd.DataFrame + Feature matrix + y : np.ndarray + Target variable + n_splits : int + Number of CV splits + test_size : float + Fraction for test set + random_state : int + Random seed + + Returns + ------- + tuple[list, list, list, list] + R2 scores, MAE scores, predictions, actuals + """ + cv = ShuffleSplit(n_splits=n_splits, test_size=test_size, random_state=random_state) + + r2_scores = [] + mae_scores = [] + predictions_list = [] + actual_list = [] + + for fold, (train_idx, test_idx) in enumerate(cv.split(X)): + print(f"\nFold {fold + 1}/{n_splits}") + + X_train, X_test = X.iloc[train_idx], X.iloc[test_idx] + y_train, y_test = y[train_idx], y[test_idx] + + r2, mae, y_pred = train_evaluate_fold( + X_train.values, X_test.values, y_train, y_test + ) + + r2_scores.append(r2) + mae_scores.append(mae) + predictions_list.extend(y_pred) + actual_list.extend(y_test) + + print(f" R2 Score: {r2:.3f}") + print(f" MAE: {mae:.2f} years") + + return r2_scores, mae_scores, predictions_list, actual_list + + +def print_cv_results( + r2_scores: list[float], + mae_scores: list[float], + model_name: str = "Model", +) -> None: + """Print cross-validation summary. + + Parameters + ---------- + r2_scores : list[float] + R2 scores per fold + mae_scores : list[float] + MAE scores per fold + model_name : str + Name of the model + """ + print("\n" + "=" * 50) + print(f"{model_name} CROSS-VALIDATION RESULTS") + print("=" * 50) + print(f"R2 Score: {np.mean(r2_scores):.3f} +/- {np.std(r2_scores):.3f}") + print(f"MAE: {np.mean(mae_scores):.2f} +/- {np.std(mae_scores):.2f} years") + print("=" * 50) + + +def plot_predictions( + actual: list[float], + predicted: list[float], + r2_scores: list[float], + mae_scores: list[float], + figure_dir: Path | None = None, +) -> None: + """Plot predicted vs actual ages. + + Parameters + ---------- + actual : list[float] + Actual ages + predicted : list[float] + Predicted ages + r2_scores : list[float] + R2 scores + mae_scores : list[float] + MAE scores + figure_dir : Path, optional + Directory to save figures + """ + plt.figure(figsize=(8, 6)) + + plt.scatter(actual, predicted, alpha=0.6, s=80) + + min_age = min(min(actual), min(predicted)) + max_age = max(max(actual), max(predicted)) + plt.plot( + [min_age, max_age], + [min_age, max_age], + "r--", + linewidth=2, + label="Perfect Prediction", + ) + + plt.xlabel("Actual Age (years)", fontsize=12) + plt.ylabel("Predicted Age (years)", fontsize=12) + plt.title( + f"Age Prediction Performance\n" + f"R2 = {np.mean(r2_scores):.3f}, MAE = {np.mean(mae_scores):.2f} years", + fontsize=14, + ) + plt.legend() + plt.grid(alpha=0.3) + plt.tight_layout() + + if figure_dir is not None: + plt.savefig( + figure_dir / "age_prediction_performance.png", dpi=300, bbox_inches="tight" + ) + plt.close() + + +def compare_models( + full_r2: list[float], + full_mae: list[float], + baseline_r2: list[float], + baseline_mae: list[float], +) -> None: + """Print comparison between full and baseline models. + + Parameters + ---------- + full_r2 : list[float] + R2 scores for full model + full_mae : list[float] + MAE scores for full model + baseline_r2 : list[float] + R2 scores for baseline + baseline_mae : list[float] + MAE scores for baseline + """ + print("=" * 60) + print("MODEL COMPARISON") + print("=" * 60) + print("Full Model (Genes + Sex):") + print(f" R2 Score: {np.mean(full_r2):.3f} +/- {np.std(full_r2):.3f}") + print(f" MAE: {np.mean(full_mae):.2f} +/- {np.std(full_mae):.2f} years") + print("\nBaseline Model (Sex Only):") + print(f" R2 Score: {np.mean(baseline_r2):.3f} +/- {np.std(baseline_r2):.3f}") + print(f" MAE: {np.mean(baseline_mae):.2f} +/- {np.std(baseline_mae):.2f} years") + print("\nImprovement:") + print(f" Delta R2: {np.mean(full_r2) - np.mean(baseline_r2):.3f}") + print(f" Delta MAE: {np.mean(baseline_mae) - np.mean(full_mae):.2f} years") + print("=" * 60) + + +def run_predictive_modeling_pipeline( + counts_df: pd.DataFrame, + metadata: pd.DataFrame, + n_splits: int = 5, + figure_dir: Path | None = None, +) -> dict: + """Run complete predictive modeling pipeline. + + Parameters + ---------- + counts_df : pd.DataFrame + Gene expression counts + metadata : pd.DataFrame + Metadata with age and sex + n_splits : int + Number of CV splits + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + dict + Results dictionary with scores + """ + # Prepare features + X, y = prepare_features(counts_df, metadata) + X_baseline = prepare_baseline_features(metadata) + + # Run full model + print("\n--- Full Model (Genes + Sex) ---") + r2_scores, mae_scores, predictions, actuals = run_cross_validation(X, y, n_splits) + print_cv_results(r2_scores, mae_scores, "Full Model") + + # Plot predictions + plot_predictions(actuals, predictions, r2_scores, mae_scores, figure_dir) + + # Run baseline model + print("\n--- Baseline Model (Sex Only) ---") + baseline_r2, baseline_mae, _, _ = run_cross_validation(X_baseline, y, n_splits) + print_cv_results(baseline_r2, baseline_mae, "Baseline") + + # Compare models + compare_models(r2_scores, mae_scores, baseline_r2, baseline_mae) + + return { + "full_r2": r2_scores, + "full_mae": mae_scores, + "baseline_r2": baseline_r2, + "baseline_mae": baseline_mae, + "predictions": predictions, + "actuals": actuals, + } diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py new file mode 100644 index 0000000..4ab383e --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/preprocessing.py @@ -0,0 +1,210 @@ +"""Preprocessing module for scRNA-seq analysis workflow. + +Functions for normalization, log transformation, and feature selection. +""" + +import re + +import anndata as ad +import scanpy as sc + + +def normalize_counts(adata: ad.AnnData, target_sum: float = 1e4) -> ad.AnnData: + """Normalize counts to target sum per cell. + + Parameters + ---------- + adata : AnnData + AnnData object with raw counts + target_sum : float + Target sum for normalization (default: 10,000) + + Returns + ------- + AnnData + Normalized AnnData object + """ + sc.pp.normalize_total(adata, target_sum=target_sum) + return adata + + +def log_transform(adata: ad.AnnData) -> ad.AnnData: + """Apply log1p transformation. + + Parameters + ---------- + adata : AnnData + AnnData object + + Returns + ------- + AnnData + Log-transformed AnnData object + """ + sc.pp.log1p(adata) + return adata + + +def select_highly_variable_genes( + adata: ad.AnnData, + n_top_genes: int = 3000, + batch_key: str = "donor_id", + layer: str = "counts", + span: float = 0.8, +) -> ad.AnnData: + """Select highly variable genes using seurat_v3 method. + + Parameters + ---------- + adata : AnnData + AnnData object + n_top_genes : int + Number of top variable genes to select + batch_key : str + Column name for batch correction + layer : str + Layer containing raw counts + span : float + LOESS span parameter + + Returns + ------- + AnnData + AnnData with highly_variable annotation + """ + sc.pp.highly_variable_genes( + adata, + n_top_genes=n_top_genes, + flavor="seurat_v3", + batch_key=batch_key, + span=span, + layer=layer, + subset=False, + ) + return adata + + +def identify_nuisance_genes(adata: ad.AnnData) -> list[str]: + """Identify nuisance genes to exclude from HVG list. + + Identifies TCR/BCR variable regions, mitochondrial, and ribosomal genes. + + Parameters + ---------- + adata : AnnData + AnnData object + + Returns + ------- + list[str] + List of gene names to block + """ + # TCR/BCR genes (V(D)J recombination genes) + immune_receptor_genes = [ + name for name in adata.var_names if re.match(r"^(IG[HKL]|TR[ABDG])[VDJC]", name) + ] + + # Mitochondrial genes + mt_genes = adata.var_names[adata.var_names.str.startswith("MT-")] + + # Ribosomal genes + rb_genes = adata.var_names[adata.var_names.str.startswith(("RPS", "RPL"))] + + genes_to_block = list(immune_receptor_genes) + list(mt_genes) + list(rb_genes) + return genes_to_block + + +def filter_nuisance_genes_from_hvg(adata: ad.AnnData) -> ad.AnnData: + """Remove nuisance genes from HVG list. + + Parameters + ---------- + adata : AnnData + AnnData object with highly_variable annotation + + Returns + ------- + AnnData + AnnData with filtered HVG list + """ + genes_to_block = identify_nuisance_genes(adata) + + # Count immune receptor genes separately for reporting + immune_receptor_genes = [ + name for name in adata.var_names if re.match(r"^(IG[HKL]|TR[ABDG])[VDJC]", name) + ] + + # Set blocked genes to not highly variable + adata.var.loc[adata.var_names.isin(genes_to_block), "highly_variable"] = False + + print(f"Blocked {len(immune_receptor_genes)} immune receptor genes from HVG list.") + print(f"Final HVG count: {adata.var['highly_variable'].sum()}") + + return adata + + +def run_pca( + adata: ad.AnnData, + svd_solver: str = "arpack", + use_highly_variable: bool = True, +) -> ad.AnnData: + """Run PCA on the data. + + Parameters + ---------- + adata : AnnData + AnnData object + svd_solver : str + SVD solver to use + use_highly_variable : bool + Whether to use only HVGs + + Returns + ------- + AnnData + AnnData with PCA results + """ + sc.tl.pca(adata, svd_solver=svd_solver, use_highly_variable=use_highly_variable) + return adata + + +def run_preprocessing_pipeline( + adata: ad.AnnData, + target_sum: float = 1e4, + n_top_genes: int = 3000, + batch_key: str = "donor_id", +) -> ad.AnnData: + """Run complete preprocessing pipeline. + + Parameters + ---------- + adata : AnnData + Input AnnData object with raw counts in 'counts' layer + target_sum : float + Target sum for normalization + n_top_genes : int + Number of HVGs to select + batch_key : str + Column for batch correction + + Returns + ------- + AnnData + Preprocessed AnnData object + """ + # Normalize + adata = normalize_counts(adata, target_sum) + + # Log transform + adata = log_transform(adata) + + # Select HVGs + adata = select_highly_variable_genes(adata, n_top_genes, batch_key) + + # Filter nuisance genes + adata = filter_nuisance_genes_from_hvg(adata) + + # Run PCA + adata = run_pca(adata) + + return adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py new file mode 100644 index 0000000..14f64e7 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/pseudobulk.py @@ -0,0 +1,210 @@ +"""Pseudobulking module for scRNA-seq analysis workflow. + +Functions for aggregating single-cell counts to pseudobulk samples. +""" + +from pathlib import Path + +import anndata as ad +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import scanpy as sc +from sklearn.preprocessing import OneHotEncoder + + +def create_pseudobulk( + adata: ad.AnnData, + group_col: str, + donor_col: str, + layer: str = "counts", + metadata_cols: list[str] | None = None, +) -> ad.AnnData: + """Sum raw counts for each (Donor, CellType) pair. + + Parameters + ---------- + adata : AnnData + Input single-cell data + group_col : str + Column name for grouping (e.g., 'cell_type') + donor_col : str + Column name for donor ID + layer : str + Layer to use for aggregation (default: 'counts') + metadata_cols : list of str, optional + Additional metadata columns to preserve from obs + + Returns + ------- + AnnData + Pseudobulk AnnData object + """ + # Create a combined key (e.g., "Bcell::Donor1") + groups = adata.obs[group_col].astype(str) + donors = adata.obs[donor_col].astype(str) + + group_df = pd.DataFrame({"group": groups, "donor": donors}) + group_df["combined"] = group_df["group"] + "::" + group_df["donor"] + + # Build the aggregation matrix (One-Hot Encoding) + enc = OneHotEncoder(sparse_output=True, dtype=np.float32) + membership_matrix = enc.fit_transform(group_df[["combined"]]) + + # Get source matrix + if layer is not None and layer in adata.layers: + X_source = adata.layers[layer] + else: + X_source = adata.X + + # Aggregate by summing + pseudobulk_X = membership_matrix.T @ X_source + + # Create obs metadata for the new object + unique_ids = enc.categories_[0] + + obs_data = [] + for uid in unique_ids: + ctype, donor = uid.split("::") + obs_data.append({"cell_type": ctype, "donor_id": donor}) + + pb_obs = pd.DataFrame(obs_data, index=unique_ids) + + # Count cells per pseudobulk sample + cell_counts = np.array(membership_matrix.sum(axis=0)).flatten() + pb_obs["n_cells"] = cell_counts.astype(int) + + # Add additional metadata columns + if metadata_cols is not None: + for col in metadata_cols: + if col in adata.obs.columns: + col_values = [] + for uid in unique_ids: + ctype, donor = uid.split("::") + donor_mask = adata.obs[donor_col] == donor + if donor_mask.any(): + col_values.append(adata.obs.loc[donor_mask, col].iloc[0]) + else: + col_values.append(None) + pb_obs[col] = col_values + + # Assemble the AnnData + pb_adata = ad.AnnData(X=pseudobulk_X, obs=pb_obs, var=adata.var.copy()) + + return pb_adata + + +def filter_pseudobulk_by_cell_count( + pb_adata: ad.AnnData, min_cells: int = 10 +) -> ad.AnnData: + """Filter pseudobulk samples with too few cells. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + min_cells : int + Minimum cells required per sample + + Returns + ------- + AnnData + Filtered pseudobulk AnnData + """ + print(f"Dropping samples with < {min_cells} cells...") + pb_adata = pb_adata[pb_adata.obs["n_cells"] >= min_cells].copy() + print(f"Remaining samples: {pb_adata.n_obs}") + return pb_adata + + +def compute_pseudobulk_qc(pb_adata: ad.AnnData) -> ad.AnnData: + """Compute QC metrics for pseudobulk samples. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + + Returns + ------- + AnnData + Pseudobulk AnnData with QC metrics + """ + pb_adata.obs["total_counts"] = np.array(pb_adata.X.sum(axis=1)).flatten() + return pb_adata + + +def plot_pseudobulk_qc(pb_adata: ad.AnnData, figure_dir: Path | None = None) -> None: + """Plot QC metrics for pseudobulk samples. + + Parameters + ---------- + pb_adata : AnnData + Pseudobulk AnnData object + figure_dir : Path, optional + Directory to save figures + """ + sc.pl.violin(pb_adata, ["n_cells", "total_counts"], multi_panel=True, show=False) + if figure_dir is not None: + plt.savefig(figure_dir / "pseudobulk_violin.png", dpi=300, bbox_inches="tight") + plt.close() + + +def run_pseudobulk_pipeline( + adata: ad.AnnData, + group_col: str = "cell_type", + donor_col: str = "donor_id", + metadata_cols: list[str] | None = None, + min_cells: int = 10, + figure_dir: Path | None = None, + layer: str | None = None, +) -> ad.AnnData: + """Run complete pseudobulking pipeline. + + Parameters + ---------- + adata : AnnData + Input single-cell AnnData object + group_col : str + Column for cell type grouping + donor_col : str + Column for donor ID + metadata_cols : list of str, optional + Metadata columns to preserve + min_cells : int + Minimum cells per pseudobulk sample + figure_dir : Path, optional + Directory to save figures + layer : str, optional + Layer to use for counts. If None, uses .X directly. + + Returns + ------- + AnnData + Pseudobulk AnnData object + """ + if metadata_cols is None: + metadata_cols = ["development_stage", "sex"] + + print("Aggregating counts...") + pb_adata = create_pseudobulk( + adata, + group_col=group_col, + donor_col=donor_col, + layer=layer, + metadata_cols=metadata_cols, + ) + + print("Pseudobulk complete.") + print(f"Original shape: {adata.shape}") + print(f"Pseudobulk shape: {pb_adata.shape} (Samples x Genes)") + print(pb_adata.obs.head()) + + # Filter by cell count + pb_adata = filter_pseudobulk_by_cell_count(pb_adata, min_cells) + + # Compute and plot QC + pb_adata = compute_pseudobulk_qc(pb_adata) + plot_pseudobulk_qc(pb_adata, figure_dir) + + return pb_adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py new file mode 100644 index 0000000..3e83822 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/quality_control.py @@ -0,0 +1,371 @@ +"""Quality control module for scRNA-seq analysis workflow. + +Functions for identifying bad cells and doublets. +""" + +from pathlib import Path + +import anndata as ad +import matplotlib.pyplot as plt +import scanpy as sc +import seaborn as sns + + +def annotate_gene_types(adata: ad.AnnData) -> ad.AnnData: + """Annotate mitochondrial, ribosomal, and hemoglobin genes. + + Parameters + ---------- + adata : AnnData + AnnData object with 'feature_name' in var + + Returns + ------- + AnnData + AnnData with mt, ribo, hb annotations in var + """ + # Mitochondrial genes + adata.var["mt"] = adata.var["feature_name"].str.startswith("MT-") + print(f"Number of mitochondrial genes: {adata.var['mt'].sum()}") + + # Ribosomal genes + adata.var["ribo"] = adata.var["feature_name"].str.startswith(("RPS", "RPL")) + print(f"Number of ribosomal genes: {adata.var['ribo'].sum()}") + + # Hemoglobin genes + adata.var["hb"] = adata.var["feature_name"].str.contains("^HB[^(P)]") + print(f"Number of hemoglobin genes: {adata.var['hb'].sum()}") + + return adata + + +def calculate_qc_metrics(adata: ad.AnnData) -> ad.AnnData: + """Calculate QC metrics for cells. + + Parameters + ---------- + adata : AnnData + AnnData object with gene type annotations + + Returns + ------- + AnnData + AnnData with QC metrics in obs + """ + sc.pp.calculate_qc_metrics( + adata, + qc_vars=["mt", "ribo", "hb"], + inplace=True, + percent_top=[20], + log1p=True, + ) + return adata + + +def plot_qc_metrics(adata: ad.AnnData, figure_dir: Path | None = None) -> None: + """Plot QC metric distributions. + + Parameters + ---------- + adata : AnnData + AnnData object with QC metrics + figure_dir : Path, optional + Directory to save figures + """ + # Violin plots for QC metrics + sc.pl.violin( + adata, + ["total_counts", "n_genes_by_counts", "pct_counts_mt"], + jitter=0.4, + multi_panel=True, + show=False, + ) + if figure_dir is not None: + plt.savefig(figure_dir / "qc_violin_plots.png", dpi=300, bbox_inches="tight") + plt.close() + + # Scatter plot for doublets and dying cells + sc.pl.scatter( + adata, + x="total_counts", + y="n_genes_by_counts", + color="pct_counts_mt", + show=False, + ) + if figure_dir is not None: + plt.savefig( + figure_dir / "qc_scatter_doublets.png", dpi=300, bbox_inches="tight" + ) + plt.close() + + +def plot_hemoglobin_distribution( + adata: ad.AnnData, figure_dir: Path | None = None +) -> None: + """Plot hemoglobin content distribution to check RBC contamination. + + Parameters + ---------- + adata : AnnData + AnnData object with QC metrics + figure_dir : Path, optional + Directory to save figures + """ + plt.figure(figsize=(6, 4)) + sns.histplot(adata.obs["pct_counts_hb"], bins=50, log_scale=(False, True)) + plt.title("Hemoglobin Content Distribution") + plt.xlabel("% Hemoglobin Counts") + plt.axvline(5, color="red", linestyle="--", label="5% Cutoff") + plt.legend() + if figure_dir is not None: + plt.savefig( + figure_dir / "hemoglobin_distribution.png", dpi=300, bbox_inches="tight" + ) + plt.close() + + +def apply_qc_filters( + adata: ad.AnnData, + min_genes: int = 200, + max_genes: int = 6000, + min_counts: int = 500, + max_counts: int = 30000, + max_hb_pct: float = 5.0, +) -> ad.AnnData: + """Apply QC filters to remove low quality cells and doublets. + + Parameters + ---------- + adata : AnnData + AnnData object with QC metrics + min_genes : int + Minimum genes per cell + max_genes : int + Maximum genes per cell (doublet filter) + min_counts : int + Minimum UMIs per cell + max_counts : int + Maximum UMIs per cell (doublet filter) + max_hb_pct : float + Maximum hemoglobin percentage (RBC filter) + + Returns + ------- + AnnData + Filtered AnnData object + """ + adata_qc = adata.copy() + print(f"Before filtering: {adata_qc.n_obs} cells") + + # Filter low quality and doublets + adata_qc = adata_qc[ + (adata_qc.obs["n_genes_by_counts"] > min_genes) + & (adata_qc.obs["n_genes_by_counts"] < max_genes) + & (adata_qc.obs["total_counts"] > min_counts) + & (adata_qc.obs["total_counts"] < max_counts) + ] + + # Filter Red Blood Cells + adata_qc = adata_qc[adata_qc.obs["pct_counts_hb"] < max_hb_pct] + + print(f"After filtering: {adata_qc.n_obs} cells") + return adata_qc + + +def detect_doublets_per_donor( + adata: ad.AnnData, + expected_doublet_rate: float = 0.06, + min_cells_per_donor: int = 100, +) -> ad.AnnData: + """Run doublet detection separately for each donor. + + Parameters + ---------- + adata : AnnData + AnnData object with raw counts + expected_doublet_rate : float + Expected doublet rate for Scrublet + min_cells_per_donor : int + Minimum cells required to run Scrublet + + Returns + ------- + AnnData + AnnData with doublet annotations + """ + print(f"Data shape before doublet detection: {adata.shape}") + + adatas_list = [] + donors = adata.obs["donor_id"].unique() + + print(f"Running Scrublet on {len(donors)} donors...") + + for donor in donors: + curr_adata = adata[adata.obs["donor_id"] == donor].copy() + + if curr_adata.n_obs < min_cells_per_donor: + print(f"Skipping donor {donor}: too few cells ({curr_adata.n_obs})") + curr_adata.obs["doublet_score"] = 0 + curr_adata.obs["predicted_doublet"] = False + adatas_list.append(curr_adata) + continue + + sc.pp.scrublet(curr_adata, expected_doublet_rate=expected_doublet_rate) + adatas_list.append(curr_adata) + + adata_combined = sc.concat(adatas_list) + + print( + f"Detected {adata_combined.obs['predicted_doublet'].sum()} " + f"doublets across all donors." + ) + print(adata_combined.obs["predicted_doublet"].value_counts()) + + return adata_combined + + +def compute_umap_for_qc(adata: ad.AnnData, n_pcs: int = 30) -> ad.AnnData: + """Compute a simple UMAP embedding for QC visualization. + + This computes a quick UMAP on the raw counts for visualizing + doublet detection results. This is separate from the main + dimensionality reduction in step 5. + + Parameters + ---------- + adata : AnnData + AnnData object (raw counts in .X) + n_pcs : int + Number of principal components to use + + Returns + ------- + AnnData + AnnData with UMAP coordinates in .obsm['X_umap'] + """ + # Work on a copy to avoid modifying the original + adata_temp = adata.copy() + + # Basic preprocessing for UMAP computation + sc.pp.normalize_total(adata_temp, target_sum=1e4) + sc.pp.log1p(adata_temp) + sc.pp.highly_variable_genes(adata_temp, n_top_genes=2000, flavor="seurat_v3") + sc.pp.pca(adata_temp, n_comps=n_pcs, use_highly_variable=True) + sc.pp.neighbors(adata_temp, n_neighbors=15, n_pcs=n_pcs) + sc.tl.umap(adata_temp) + + # Copy UMAP coordinates back to original + adata.obsm["X_umap"] = adata_temp.obsm["X_umap"] + + return adata + + +def plot_doublets(adata: ad.AnnData, figure_dir: Path | None = None) -> None: + """Visualize doublet detection results on UMAP. + + Parameters + ---------- + adata : AnnData + AnnData object with doublet annotations and UMAP coordinates + figure_dir : Path, optional + Directory to save figures + """ + if "X_umap" not in adata.obsm: + print("Warning: No UMAP coordinates found, skipping doublet plot") + return + + sc.pl.umap(adata, color=["doublet_score", "predicted_doublet"], size=20, show=False) + if figure_dir is not None: + plt.savefig( + figure_dir / "doublet_detection_umap.png", dpi=300, bbox_inches="tight" + ) + plt.close() + + +def filter_doublets(adata: ad.AnnData) -> ad.AnnData: + """Remove predicted doublets from the dataset. + + Parameters + ---------- + adata : AnnData + AnnData object with doublet predictions + + Returns + ------- + AnnData + Filtered AnnData with only singlets + """ + print(f"Found {adata.obs['predicted_doublet'].sum()} predicted doublets") + adata_filtered = adata[adata.obs["predicted_doublet"] == False, :] # noqa: E712 + print(f"Remaining cells: {adata_filtered.n_obs}") + return adata_filtered + + +def run_qc_pipeline( + adata: ad.AnnData, + min_genes: int = 200, + max_genes: int = 6000, + min_counts: int = 500, + max_counts: int = 30000, + max_hb_pct: float = 5.0, + expected_doublet_rate: float = 0.06, + figure_dir: Path | None = None, +) -> ad.AnnData: + """Run complete quality control pipeline. + + Parameters + ---------- + adata : AnnData + Input AnnData object + min_genes : int + Minimum genes per cell + max_genes : int + Maximum genes per cell + min_counts : int + Minimum UMIs per cell + max_counts : int + Maximum UMIs per cell + max_hb_pct : float + Maximum hemoglobin percentage + expected_doublet_rate : float + Expected doublet rate + figure_dir : Path, optional + Directory to save figures + + Returns + ------- + AnnData + QC-filtered AnnData object + """ + # Annotate gene types + adata = annotate_gene_types(adata) + + # Calculate QC metrics + adata = calculate_qc_metrics(adata) + + # Plot QC metrics + plot_qc_metrics(adata, figure_dir) + plot_hemoglobin_distribution(adata, figure_dir) + + # Apply QC filters + adata = apply_qc_filters( + adata, min_genes, max_genes, min_counts, max_counts, max_hb_pct + ) + + # Detect doublets + adata = detect_doublets_per_donor(adata, expected_doublet_rate) + + # Compute UMAP for doublet visualization (before filtering) + print("Computing UMAP for doublet visualization...") + adata = compute_umap_for_qc(adata) + plot_doublets(adata, figure_dir) + + # Filter doublets + adata = filter_doublets(adata) + + # Save raw counts for HVG selection (step 4) and pseudobulking (step 7) + # Note: Raw counts are also in .X at this point, which will be used + # by pseudobulking when loading this checkpoint directly. + adata.layers["counts"] = adata.X.copy() + + return adata diff --git a/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py new file mode 100644 index 0000000..f88d965 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/modular_workflow/run_workflow.py @@ -0,0 +1,314 @@ +"""Main workflow runner for scRNA-seq immune aging analysis. + +This script orchestrates the complete analysis workflow using the modular components. +""" + +import os +from pathlib import Path + +from dotenv import load_dotenv + +from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import ( + run_clustering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import ( + run_filtering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import ( + download_data, + load_anndata, + load_lazy_anndata, + save_anndata, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import ( + run_differential_expression_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import ( + run_dimensionality_reduction_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import ( + run_overrepresentation_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import ( + run_gsea_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import ( + run_predictive_modeling_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import ( + run_preprocessing_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import ( + run_pseudobulk_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import ( + run_qc_pipeline, +) + + +def run_full_workflow( + datadir: Path, + dataset_name: str = "OneK1K", + url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad", + cell_type_for_de: str = "central memory CD4-positive, alpha-beta T cell", + skip_download: bool = False, + skip_filtering: bool = False, + skip_qc: bool = False, +) -> dict: + """Run the complete immune aging scRNA-seq analysis workflow. + + Parameters + ---------- + datadir : Path + Base directory for data files + dataset_name : str + Name of the dataset + url : str + URL to download data from + cell_type_for_de : str + Cell type to use for differential expression + skip_download : bool + Skip data download step + skip_filtering : bool + Skip filtering, load pre-filtered data + skip_qc : bool + Skip QC, load post-QC data + + Returns + ------- + dict + Dictionary containing all results + """ + # Setup directories + figure_dir = datadir / "workflow/figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + results = {} + + # ===================================================================== + # STEP 1: Data Loading + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 1: DATA LOADING") + print("=" * 60) + + datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad" + filtered_file = datadir / f"dataset-{dataset_name}_subset-immune_filtered.h5ad" + + if not skip_download: + download_data(datafile, url) + + # ===================================================================== + # STEP 2: Data Filtering + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 2: DATA FILTERING") + print("=" * 60) + + if skip_filtering and filtered_file.exists(): + print("Loading pre-filtered data...") + adata = load_anndata(filtered_file) + else: + adata = load_lazy_anndata(datafile) + print(f"Loaded dataset: {adata}") + + adata = run_filtering_pipeline( + adata, + cutoff_percentile=1.0, + min_cells_per_celltype=10, + percent_donors=0.95, + figure_dir=figure_dir, + ) + + # Save filtered data + save_anndata(adata, filtered_file) + print(f"Saved filtered data to {filtered_file}") + + print(f"Dataset after filtering: {adata}") + + # Build var_to_feature mapping + var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"])) + + # ===================================================================== + # STEP 3: Quality Control + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 3: QUALITY CONTROL") + print("=" * 60) + + qc_file = datadir / f"dataset-{dataset_name}_subset-immune_qc.h5ad" + + if skip_qc and qc_file.exists(): + print("Loading post-QC data...") + adata = load_anndata(qc_file) + else: + adata = run_qc_pipeline( + adata, + min_genes=200, + max_genes=6000, + min_counts=500, + max_counts=30000, + max_hb_pct=5.0, + expected_doublet_rate=0.06, + figure_dir=figure_dir, + ) + save_anndata(adata, qc_file) + + print(f"Dataset after QC: {adata}") + + # ===================================================================== + # STEP 4: Preprocessing + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 4: PREPROCESSING") + print("=" * 60) + + adata = run_preprocessing_pipeline( + adata, + target_sum=1e4, + n_top_genes=3000, + batch_key="donor_id", + ) + + # ===================================================================== + # STEP 5: Dimensionality Reduction + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 5: DIMENSIONALITY REDUCTION") + print("=" * 60) + + adata = run_dimensionality_reduction_pipeline( + adata, + batch_key="donor_id", + n_neighbors=30, + n_pcs=40, + figure_dir=figure_dir, + ) + + # ===================================================================== + # STEP 6: Clustering + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 6: CLUSTERING") + print("=" * 60) + + adata = run_clustering_pipeline( + adata, + resolution=1.0, + figure_dir=figure_dir, + ) + + results["adata"] = adata + + # ===================================================================== + # STEP 7: Pseudobulking + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 7: PSEUDOBULKING") + print("=" * 60) + + pb_adata = run_pseudobulk_pipeline( + adata, + group_col="cell_type", + donor_col="donor_id", + metadata_cols=["development_stage", "sex"], + min_cells=10, + figure_dir=figure_dir, + ) + + results["pb_adata"] = pb_adata + + # ===================================================================== + # STEP 8: Differential Expression + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 8: DIFFERENTIAL EXPRESSION") + print("=" * 60) + + stat_res, de_results, counts_df_ct = run_differential_expression_pipeline( + pb_adata, + cell_type=cell_type_for_de, + design_factors=["age_scaled", "sex"], + var_to_feature=var_to_feature, + n_cpus=8, + ) + + results["de_results"] = de_results + results["counts_df"] = counts_df_ct + + # ===================================================================== + # STEP 9: Pathway Analysis (GSEA) + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 9: PATHWAY ANALYSIS (GSEA)") + print("=" * 60) + + gsea_results = run_gsea_pipeline( + de_results, + gene_sets=["MSigDB_Hallmark_2020"], + n_top=10, + figure_dir=figure_dir, + ) + + results["gsea"] = gsea_results + + # ===================================================================== + # STEP 10: Overrepresentation Analysis (Enrichr) + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 10: OVERREPRESENTATION ANALYSIS (Enrichr)") + print("=" * 60) + + enr_up, enr_down = run_overrepresentation_pipeline( + de_results, + gene_sets=["MSigDB_Hallmark_2020"], + padj_threshold=0.05, + n_top=10, + figure_dir=figure_dir, + ) + + results["enrichr_up"] = enr_up + results["enrichr_down"] = enr_down + + # ===================================================================== + # STEP 11: Predictive Modeling + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 11: PREDICTIVE MODELING") + print("=" * 60) + + # Get metadata for the cell type + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type_for_de].copy() + pb_adata_ct.obs["age"] = ( + pb_adata_ct.obs["development_stage"] + .str.extract(r"(\d+)-year-old")[0] + .astype(float) + ) + metadata_ct = pb_adata_ct.obs.copy() + + prediction_results = run_predictive_modeling_pipeline( + counts_df_ct, + metadata_ct, + n_splits=5, + figure_dir=figure_dir, + ) + + results["prediction"] = prediction_results + + print("\n" + "=" * 60) + print("WORKFLOW COMPLETE") + print("=" * 60) + print(f"Figures saved to: {figure_dir}") + + return results + + +if __name__ == "__main__": + load_dotenv() + + datadir_env = os.getenv("DATADIR") + if datadir_env is None: + raise ValueError("DATADIR environment variable not set") + + datadir = Path(datadir_env) / "immune_aging" + results = run_full_workflow(datadir) diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml new file mode 100644 index 0000000..e4043e2 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/config/config.yaml @@ -0,0 +1,75 @@ +# Configuration for Prefect scRNA-seq immune aging workflow +# +# Usage: +# python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --config /path/to/config.yaml +# +# Override any parameter via CLI: +# python ... --dataset-name MyDataset --force-from 5 + +# Dataset configuration +dataset_name: "OneK1K" +url: "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad" + +# Step 2: Filtering parameters +filtering: + cutoff_percentile: 1.0 + min_cells_per_celltype: 10 + percent_donors: 0.95 + +# Step 3: QC parameters +qc: + min_genes: 200 + max_genes: 6000 + min_counts: 500 + max_counts: 30000 + max_hb_pct: 5.0 + expected_doublet_rate: 0.06 + +# Step 4: Preprocessing parameters +preprocessing: + target_sum: 10000 + n_top_genes: 3000 + batch_key: "donor_id" + +# Step 5: Dimensionality reduction parameters +dimred: + batch_key: "donor_id" + n_neighbors: 30 + n_pcs: 40 + +# Step 6: Clustering parameters +clustering: + resolution: 1.0 + +# Step 7: Pseudobulking parameters +pseudobulk: + group_col: "cell_type" + donor_col: "donor_id" + metadata_cols: + - "development_stage" + - "sex" + min_cells: 10 + +# Steps 8-11: Per-cell-type analysis parameters +differential_expression: + design_factors: + - "age_scaled" + - "sex" + n_cpus: 8 + +pathway_analysis: + gene_sets: + - "MSigDB_Hallmark_2020" + n_top: 10 + +overrepresentation: + gene_sets: + - "MSigDB_Hallmark_2020" + padj_threshold: 0.05 + n_top: 10 + +predictive_modeling: + n_splits: 5 + +# Minimum samples per cell type for per-cell-type analysis +min_samples_per_cell_type: 10 diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py new file mode 100644 index 0000000..ef40fdc --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/flows.py @@ -0,0 +1,631 @@ +"""Prefect flow definitions for scRNA-seq workflow. + +Main workflow flow that orchestrates all tasks. +""" + +import logging +from datetime import datetime +from pathlib import Path +from typing import Any + +import yaml +from prefect import flow, get_run_logger + +from BetterCodeBetterScience.rnaseq.prefect_workflow.tasks import ( + clustering_task, + differential_expression_task, + dimensionality_reduction_task, + download_data_task, + load_and_filter_task, + overrepresentation_task, + pathway_analysis_task, + predictive_modeling_task, + preprocessing_task, + pseudobulk_task, + quality_control_task, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + bids_checkpoint_name, + load_checkpoint, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import ( + create_execution_log, + serialize_parameters, +) + + +def get_default_config_path() -> Path: + """Get the path to the default config file bundled with the package.""" + return Path(__file__).parent / "config" / "config.yaml" + + +def load_config(config_path: Path | None = None) -> dict[str, Any]: + """Load workflow configuration from YAML file. + + Parameters + ---------- + config_path : Path, optional + Path to config file. If None, uses the default config bundled with the package. + + Returns + ------- + dict + Configuration dictionary + """ + if config_path is None: + config_path = get_default_config_path() + + with open(config_path) as f: + return yaml.safe_load(f) + + +def setup_file_logging(log_dir: Path) -> tuple[Path, logging.FileHandler]: + """Set up file-based logging for the workflow. + + Parameters + ---------- + log_dir : Path + Directory to save log files + + Returns + ------- + tuple[Path, logging.FileHandler] + Path to log file and the file handler (for cleanup) + """ + log_dir.mkdir(parents=True, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + log_file = log_dir / f"prefect_workflow_{timestamp}.log" + + # Create file handler + file_handler = logging.FileHandler(log_file) + file_handler.setLevel(logging.INFO) + formatter = logging.Formatter( + "%(asctime)s | %(levelname)-8s | %(name)s - %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + ) + file_handler.setFormatter(formatter) + + # Add handler to root logger to capture all logs + root_logger = logging.getLogger() + root_logger.addHandler(file_handler) + + # Also add to prefect logger + prefect_logger = logging.getLogger("prefect") + prefect_logger.addHandler(file_handler) + + return log_file, file_handler + + +@flow(name="immune_aging_scrna_workflow", log_prints=False) +def run_workflow( + datadir: Path, + config_path: Path | None = None, + force_from_step: int | None = None, +) -> dict[str, Any]: + """Run the complete immune aging scRNA-seq workflow with Prefect. + + All steps run sequentially to minimize memory usage. + + Parameters + ---------- + datadir : Path + Base directory for data files + config_path : Path, optional + Path to config file. If None, uses the default config bundled with the package. + force_from_step : int, optional + If provided, forces re-run from this step onwards + + Returns + ------- + dict + Dictionary containing all results organized by cell type + """ + logger = get_run_logger() + + # Load configuration + config = load_config(config_path) + dataset_name = config["dataset_name"] + url = config["url"] + min_samples_per_cell_type = config["min_samples_per_cell_type"] + + # Setup directories (using wf_prefect folder) + figure_dir = datadir / "wf_prefect/figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + checkpoint_dir = datadir / "wf_prefect/checkpoints" + checkpoint_dir.mkdir(parents=True, exist_ok=True) + + results_dir = datadir / "wf_prefect/results/per_cell_type" + results_dir.mkdir(parents=True, exist_ok=True) + + log_dir = datadir / "wf_prefect/logs" + log_dir.mkdir(parents=True, exist_ok=True) + + # Set up file logging + log_file, file_handler = setup_file_logging(log_dir) + logger.info(f"Logging to file: {log_file}") + + # Initialize execution log for structured tracking + execution_log = create_execution_log( + workflow_name="immune_aging_scrnaseq_prefect", + workflow_parameters=serialize_parameters( + datadir=datadir, + dataset_name=dataset_name, + url=url, + force_from_step=force_from_step, + min_samples_per_cell_type=min_samples_per_cell_type, + ), + ) + + # Determine which steps to force re-run + force = {i: False for i in range(1, 12)} + if force_from_step is not None: + for i in range(force_from_step, 12): + force[i] = True + + error_occurred = None + + try: + # ===================================================================== + # STEP 1: Data Download + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 1: DATA DOWNLOAD") + logger.info("=" * 60) + + step_record = execution_log.add_step( + step_number=1, + step_name="data_download", + parameters=serialize_parameters(url=url), + ) + datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad" + download_data_task(datafile, url) + execution_log.complete_step(step_record, from_cache=datafile.exists()) + + # ===================================================================== + # STEP 2: Data Filtering + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 2: DATA FILTERING") + logger.info("=" * 60) + + step2_params = config["filtering"] + step_record = execution_log.add_step( + step_number=2, + step_name="data_filtering", + parameters=step2_params, + ) + checkpoint_file = checkpoint_dir / bids_checkpoint_name( + dataset_name, 2, "filtered" + ) + from_cache = checkpoint_file.exists() and not force[2] + adata = load_and_filter_task( + datafile=datafile, + checkpoint_file=checkpoint_file, + cutoff_percentile=step2_params["cutoff_percentile"], + min_cells_per_celltype=step2_params["min_cells_per_celltype"], + percent_donors=step2_params["percent_donors"], + figure_dir=figure_dir, + force=force[2], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # Build var_to_feature mapping + var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"])) + + # ===================================================================== + # STEP 3: Quality Control + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 3: QUALITY CONTROL") + logger.info("=" * 60) + + step3_params = config["qc"] + step_record = execution_log.add_step( + step_number=3, + step_name="quality_control", + parameters=step3_params, + ) + checkpoint_file = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc") + from_cache = checkpoint_file.exists() and not force[3] + adata = quality_control_task( + adata=adata, + checkpoint_file=checkpoint_file, + min_genes=step3_params["min_genes"], + max_genes=step3_params["max_genes"], + min_counts=step3_params["min_counts"], + max_counts=step3_params["max_counts"], + max_hb_pct=step3_params["max_hb_pct"], + expected_doublet_rate=step3_params["expected_doublet_rate"], + figure_dir=figure_dir, + force=force[3], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # ===================================================================== + # STEP 4: Preprocessing + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 4: PREPROCESSING") + logger.info("=" * 60) + + step4_params = config["preprocessing"] + step_record = execution_log.add_step( + step_number=4, + step_name="preprocessing", + parameters=step4_params, + ) + checkpoint_file = checkpoint_dir / bids_checkpoint_name( + dataset_name, 4, "preprocessed" + ) + from_cache = checkpoint_file.exists() and not force[4] + adata = preprocessing_task( + adata=adata, + checkpoint_file=checkpoint_file, + target_sum=step4_params["target_sum"], + n_top_genes=step4_params["n_top_genes"], + batch_key=step4_params["batch_key"], + force=force[4], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # ===================================================================== + # STEP 5: Dimensionality Reduction + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 5: DIMENSIONALITY REDUCTION") + logger.info("=" * 60) + + step5_params = config["dimred"] + step_record = execution_log.add_step( + step_number=5, + step_name="dimensionality_reduction", + parameters=step5_params, + ) + checkpoint_file = checkpoint_dir / bids_checkpoint_name( + dataset_name, 5, "dimreduced" + ) + from_cache = checkpoint_file.exists() and not force[5] + adata = dimensionality_reduction_task( + adata=adata, + checkpoint_file=checkpoint_file, + batch_key=step5_params["batch_key"], + n_neighbors=step5_params["n_neighbors"], + n_pcs=step5_params["n_pcs"], + figure_dir=figure_dir, + force=force[5], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # ===================================================================== + # STEP 6: Clustering + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 6: CLUSTERING") + logger.info("=" * 60) + + step6_params = config["clustering"] + step_record = execution_log.add_step( + step_number=6, + step_name="clustering", + parameters=step6_params, + ) + checkpoint_file = checkpoint_dir / bids_checkpoint_name( + dataset_name, 6, "clustered" + ) + from_cache = checkpoint_file.exists() and not force[6] + adata = clustering_task( + adata=adata, + checkpoint_file=checkpoint_file, + resolution=step6_params["resolution"], + figure_dir=figure_dir, + force=force[6], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # ===================================================================== + # STEP 7: Pseudobulking + # ===================================================================== + logger.info("=" * 60) + logger.info("STEP 7: PSEUDOBULKING") + logger.info("=" * 60) + + step7_params = config["pseudobulk"] + step_record = execution_log.add_step( + step_number=7, + step_name="pseudobulking", + parameters=step7_params, + ) + # Load step 3 checkpoint for raw counts + step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc") + adata_raw_counts = load_checkpoint(step3_checkpoint) + logger.info(f"Loaded raw counts from step 3: {adata_raw_counts.shape}") + + checkpoint_file = checkpoint_dir / bids_checkpoint_name( + dataset_name, 7, "pseudobulk" + ) + from_cache = checkpoint_file.exists() and not force[7] + pb_adata = pseudobulk_task( + adata=adata_raw_counts, + checkpoint_file=checkpoint_file, + group_col=step7_params["group_col"], + donor_col=step7_params["donor_col"], + metadata_cols=step7_params["metadata_cols"], + min_cells=step7_params["min_cells"], + figure_dir=figure_dir, + layer=None, # Use .X directly (raw counts) + force=force[7], + ) + execution_log.complete_step(step_record, from_cache=from_cache) + + # ===================================================================== + # STEPS 8-11: Per-Cell-Type Analysis (Sequential) + # ===================================================================== + logger.info("=" * 60) + logger.info("STEPS 8-11: PER-CELL-TYPE ANALYSIS (SEQUENTIAL)") + logger.info("=" * 60) + + # Get all cell types from pseudobulk + cell_types = pb_adata.obs["cell_type"].unique().tolist() + logger.info(f"Found {len(cell_types)} cell types to analyze") + + # Filter cell types with insufficient samples + cell_type_counts = pb_adata.obs["cell_type"].value_counts() + valid_cell_types = [ + ct for ct in cell_types if cell_type_counts[ct] >= min_samples_per_cell_type + ] + skipped_cell_types = [ct for ct in cell_types if ct not in valid_cell_types] + + if skipped_cell_types: + logger.warning( + f"Skipping {len(skipped_cell_types)} cell types with " + f"< {min_samples_per_cell_type} samples: {skipped_cell_types}" + ) + + logger.info(f"Analyzing {len(valid_cell_types)} cell types sequentially") + + # Initialize results + all_results = { + "adata": adata, + "pb_adata": pb_adata, + "per_cell_type": {}, + } + + # Process each cell type sequentially + for i, cell_type in enumerate(valid_cell_types): + logger.info(f"\n[{i + 1}/{len(valid_cell_types)}] Processing: {cell_type}") + + # Get config for per-cell-type steps + de_config = config["differential_expression"] + gsea_config = config["pathway_analysis"] + enrichr_config = config["overrepresentation"] + pred_config = config["predictive_modeling"] + + # Log combined steps 8-11 for this cell type + step_record = execution_log.add_step( + step_number=8, + step_name=f"per_cell_type_analysis ({cell_type})", + parameters=serialize_parameters( + cell_type=cell_type, + design_factors=de_config["design_factors"], + gene_sets=gsea_config["gene_sets"], + n_splits=pred_config["n_splits"], + ), + ) + + try: + # Step 8: Differential Expression + de_result = differential_expression_task( + pb_adata=pb_adata, + cell_type=cell_type, + var_to_feature=var_to_feature, + output_dir=results_dir, + design_factors=de_config["design_factors"], + n_cpus=de_config["n_cpus"], + ) + + # Get metadata for this cell type (for predictive modeling) + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy() + pb_adata_ct.obs["age"] = ( + pb_adata_ct.obs["development_stage"] + .str.extract(r"(\d+)-year-old")[0] + .astype(float) + ) + metadata_ct = pb_adata_ct.obs.copy() + + # Step 9: Pathway Analysis (GSEA) + gsea_result = pathway_analysis_task( + de_results=de_result["de_results"], + cell_type=cell_type, + output_dir=results_dir, + gene_sets=gsea_config["gene_sets"], + n_top=gsea_config["n_top"], + ) + + # Step 10: Overrepresentation Analysis (Enrichr) + enrichr_result = overrepresentation_task( + de_results=de_result["de_results"], + cell_type=cell_type, + output_dir=results_dir, + gene_sets=enrichr_config["gene_sets"], + padj_threshold=enrichr_config["padj_threshold"], + n_top=enrichr_config["n_top"], + ) + + # Step 11: Predictive Modeling + prediction_result = predictive_modeling_task( + counts_df=de_result["counts_df"], + metadata=metadata_ct, + cell_type=cell_type, + output_dir=results_dir, + n_splits=pred_config["n_splits"], + ) + + all_results["per_cell_type"][cell_type] = { + "de": de_result, + "gsea": gsea_result, + "enrichment": enrichr_result, + "prediction": prediction_result, + } + logger.info(f"Completed analysis for: {cell_type}") + execution_log.complete_step(step_record) + + except Exception as e: + logger.error(f"Failed analysis for {cell_type}: {e}") + all_results["per_cell_type"][cell_type] = {"error": str(e)} + execution_log.complete_step(step_record, error_message=str(e)) + + # ===================================================================== + # Summary + # ===================================================================== + logger.info("=" * 60) + logger.info("WORKFLOW COMPLETE") + logger.info("=" * 60) + + successful = sum( + 1 + for ct_results in all_results["per_cell_type"].values() + if "error" not in ct_results + ) + failed = len(valid_cell_types) - successful + + logger.info( + f"Successfully analyzed: {successful}/{len(valid_cell_types)} cell types" + ) + if failed > 0: + logger.warning(f"Failed: {failed} cell types") + + logger.info(f"Figures saved to: {figure_dir}") + logger.info(f"Checkpoints saved to: {checkpoint_dir}") + logger.info(f"Per-cell-type results saved to: {results_dir}") + + except Exception as e: + error_occurred = str(e) + raise + + finally: + # Complete and save execution log + execution_log.complete(error_message=error_occurred) + execution_log_file = execution_log.save(log_dir) + execution_log.print_summary() + logger.info(f"Execution log saved to: {execution_log_file}") + logger.info(f"Workflow log saved to: {log_file}") + + # Clean up file handler + logging.getLogger().removeHandler(file_handler) + logging.getLogger("prefect").removeHandler(file_handler) + file_handler.close() + + return all_results + + +@flow(name="analyze_single_cell_type", log_prints=False) +def analyze_single_cell_type( + datadir: Path, + cell_type: str, + config_path: Path | None = None, +) -> dict[str, Any]: + """Run analysis for a single cell type (useful for debugging/testing). + + Requires that steps 1-7 have already been run. + + Parameters + ---------- + datadir : Path + Base directory for data files + cell_type : str + Cell type to analyze + config_path : Path, optional + Path to config file. If None, uses the default config bundled with the package. + + Returns + ------- + dict + Results for the specified cell type + """ + logger = get_run_logger() + + # Load configuration + config = load_config(config_path) + dataset_name = config["dataset_name"] + de_config = config["differential_expression"] + gsea_config = config["pathway_analysis"] + enrichr_config = config["overrepresentation"] + pred_config = config["predictive_modeling"] + + checkpoint_dir = datadir / "wf_prefect/checkpoints" + results_dir = datadir / "wf_prefect/results/per_cell_type" + results_dir.mkdir(parents=True, exist_ok=True) + + # Load required checkpoints + pb_adata = load_checkpoint( + checkpoint_dir / bids_checkpoint_name(dataset_name, 7, "pseudobulk") + ) + adata_filtered = load_checkpoint( + checkpoint_dir / bids_checkpoint_name(dataset_name, 2, "filtered") + ) + var_to_feature = dict( + zip(adata_filtered.var_names, adata_filtered.var["feature_name"]) + ) + + # Verify cell type exists + available_cell_types = pb_adata.obs["cell_type"].unique().tolist() + if cell_type not in available_cell_types: + raise ValueError( + f"Cell type '{cell_type}' not found. Available: {available_cell_types}" + ) + + logger.info(f"Analyzing cell type: {cell_type}") + + # Run DE + de_result = differential_expression_task( + pb_adata=pb_adata, + cell_type=cell_type, + var_to_feature=var_to_feature, + output_dir=results_dir, + design_factors=de_config["design_factors"], + n_cpus=de_config["n_cpus"], + ) + + # Get metadata + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy() + pb_adata_ct.obs["age"] = ( + pb_adata_ct.obs["development_stage"] + .str.extract(r"(\d+)-year-old")[0] + .astype(float) + ) + metadata_ct = pb_adata_ct.obs.copy() + + # Run tasks sequentially + gsea_result = pathway_analysis_task( + de_results=de_result["de_results"], + cell_type=cell_type, + output_dir=results_dir, + gene_sets=gsea_config["gene_sets"], + n_top=gsea_config["n_top"], + ) + + enrichr_result = overrepresentation_task( + de_results=de_result["de_results"], + cell_type=cell_type, + output_dir=results_dir, + gene_sets=enrichr_config["gene_sets"], + padj_threshold=enrichr_config["padj_threshold"], + n_top=enrichr_config["n_top"], + ) + + prediction_result = predictive_modeling_task( + counts_df=de_result["counts_df"], + metadata=metadata_ct, + cell_type=cell_type, + output_dir=results_dir, + n_splits=pred_config["n_splits"], + ) + + return { + "cell_type": cell_type, + "de": de_result, + "gsea": gsea_result, + "enrichment": enrichr_result, + "prediction": prediction_result, + } diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py new file mode 100644 index 0000000..6247b55 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/run_workflow.py @@ -0,0 +1,182 @@ +"""Entry point for running the Prefect-based scRNA-seq workflow. + +Usage: + python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow + +Or with arguments: + python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --force-from 8 + +With custom config: + python -m BetterCodeBetterScience.rnaseq.prefect_workflow.run_workflow --config /path/to/config.yaml +""" + +import argparse +import os +from pathlib import Path + +from dotenv import load_dotenv + +from BetterCodeBetterScience.rnaseq.prefect_workflow.flows import ( + analyze_single_cell_type, + load_config, + run_workflow, +) + + +def main(): + """Run the Prefect workflow.""" + parser = argparse.ArgumentParser( + description="Run the immune aging scRNA-seq workflow with Prefect" + ) + parser.add_argument( + "--datadir", + type=Path, + default=None, + help="Base directory for data files (default: from DATADIR env var)", + ) + parser.add_argument( + "--config", + type=Path, + default=None, + dest="config_path", + help="Path to config file (default: uses bundled config/config.yaml)", + ) + parser.add_argument( + "--force-from", + type=int, + default=None, + dest="force_from_step", + help="Force re-run from this step onwards (1-11)", + ) + parser.add_argument( + "--cell-type", + type=str, + default=None, + dest="cell_type", + help="Run analysis for a single cell type only (requires prior completion of steps 1-7)", + ) + parser.add_argument( + "--list-cell-types", + action="store_true", + dest="list_cell_types", + help="List available cell types and exit", + ) + + args = parser.parse_args() + + # Load environment variables + load_dotenv() + + # Load configuration + config = load_config(args.config_path) + dataset_name = config["dataset_name"] + min_samples = config["min_samples_per_cell_type"] + + if args.config_path: + print(f"Using config file: {args.config_path}") + else: + print("Using default bundled config") + + # Get data directory + if args.datadir is not None: + datadir = args.datadir + else: + datadir_env = os.getenv("DATADIR") + if datadir_env is None: + raise ValueError( + "DATADIR environment variable not set. " + "Set it or use --datadir argument." + ) + datadir = Path(datadir_env) / "immune_aging" + + print(f"Data directory: {datadir}") + + # List cell types if requested + if args.list_cell_types: + from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + bids_checkpoint_name, + load_checkpoint, + ) + + checkpoint_dir = datadir / "wf_prefect/checkpoints" + pb_checkpoint = checkpoint_dir / bids_checkpoint_name( + dataset_name, 7, "pseudobulk" + ) + + if not pb_checkpoint.exists(): + print(f"Pseudobulk checkpoint not found: {pb_checkpoint}") + print("Run steps 1-7 first to generate pseudobulk data.") + return + + pb_adata = load_checkpoint(pb_checkpoint) + cell_types = pb_adata.obs["cell_type"].unique().tolist() + cell_type_counts = pb_adata.obs["cell_type"].value_counts() + + print(f"\nAvailable cell types ({len(cell_types)} total):") + print("-" * 60) + for ct in sorted(cell_types): + count = cell_type_counts[ct] + status = "OK" if count >= min_samples else f"< {min_samples} samples" + print(f" {ct}: {count} samples ({status})") + return + + # Run single cell type analysis + if args.cell_type is not None: + print(f"\nRunning analysis for single cell type: {args.cell_type}") + results = analyze_single_cell_type( + datadir=datadir, + cell_type=args.cell_type, + config_path=args.config_path, + ) + print("\nResults:") + print(f" DE genes: {len(results['de']['de_results'])}") + if results["gsea"]["gsea_results"] is not None: + print(f" GSEA pathways: {len(results['gsea']['gsea_results'].res2d)}") + if results["prediction"]["prediction_results"]: + pred = results["prediction"]["prediction_results"] + import numpy as np + + print(f" Prediction R2: {np.mean(pred['full_r2']):.3f}") + print(f" Prediction MAE: {np.mean(pred['full_mae']):.2f} years") + return + + # Run full workflow + print("\nRunning full workflow...") + if args.force_from_step: + print(f"Forcing re-run from step {args.force_from_step}") + + results = run_workflow( + datadir=datadir, + config_path=args.config_path, + force_from_step=args.force_from_step, + ) + + # Print summary + print("\n" + "=" * 60) + print("RESULTS SUMMARY") + print("=" * 60) + + successful_cell_types = [ + ct for ct, res in results["per_cell_type"].items() if "error" not in res + ] + + print(f"Analyzed {len(successful_cell_types)} cell types:") + for ct in sorted(successful_cell_types): + ct_res = results["per_cell_type"][ct] + de_count = len(ct_res["de"]["de_results"]) + sig_genes = (ct_res["de"]["de_results"]["padj"] < 0.05).sum() + print(f" {ct}:") + print(f" - DE genes tested: {de_count}") + print(f" - Significant (padj<0.05): {sig_genes}") + + failed_cell_types = [ + ct for ct, res in results["per_cell_type"].items() if "error" in res + ] + if failed_cell_types: + print(f"\nFailed cell types ({len(failed_cell_types)}):") + for ct in failed_cell_types: + print(f" {ct}: {results['per_cell_type'][ct]['error']}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py new file mode 100644 index 0000000..b0c7c83 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/prefect_workflow/tasks.py @@ -0,0 +1,376 @@ +"""Prefect task definitions for scRNA-seq workflow. + +Wraps modular workflow functions as Prefect tasks for orchestration. +""" + +from pathlib import Path +from typing import Any + +import anndata as ad +import pandas as pd +from prefect import task + +from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import ( + run_clustering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import ( + run_filtering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import ( + download_data, + load_lazy_anndata, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import ( + run_differential_expression_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import ( + run_dimensionality_reduction_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import ( + run_overrepresentation_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import ( + run_gsea_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import ( + run_predictive_modeling_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import ( + run_preprocessing_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import ( + run_pseudobulk_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import ( + run_qc_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +@task(name="download_data", retries=2, retry_delay_seconds=30) +def download_data_task(datafile: Path, url: str) -> Path: + """Download data file if it doesn't exist. + + Returns the datafile path for chaining. + """ + download_data(datafile, url) + return datafile + + +@task(name="load_and_filter") +def load_and_filter_task( + datafile: Path, + checkpoint_file: Path, + cutoff_percentile: float = 1.0, + min_cells_per_celltype: int = 10, + percent_donors: float = 0.95, + figure_dir: Path | None = None, + force: bool = False, +) -> ad.AnnData: + """Load data and run filtering pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + adata = load_lazy_anndata(datafile) + print(f"Loaded dataset: {adata}") + adata = run_filtering_pipeline( + adata, + cutoff_percentile=cutoff_percentile, + min_cells_per_celltype=min_cells_per_celltype, + percent_donors=percent_donors, + figure_dir=figure_dir, + ) + save_checkpoint(adata, checkpoint_file) + return adata + + +@task(name="quality_control") +def quality_control_task( + adata: ad.AnnData, + checkpoint_file: Path, + min_genes: int = 200, + max_genes: int = 6000, + min_counts: int = 500, + max_counts: int = 30000, + max_hb_pct: float = 5.0, + expected_doublet_rate: float = 0.06, + figure_dir: Path | None = None, + force: bool = False, +) -> ad.AnnData: + """Run quality control pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + adata = run_qc_pipeline( + adata, + min_genes=min_genes, + max_genes=max_genes, + min_counts=min_counts, + max_counts=max_counts, + max_hb_pct=max_hb_pct, + expected_doublet_rate=expected_doublet_rate, + figure_dir=figure_dir, + ) + save_checkpoint(adata, checkpoint_file) + return adata + + +@task(name="preprocessing") +def preprocessing_task( + adata: ad.AnnData, + checkpoint_file: Path, + target_sum: float = 1e4, + n_top_genes: int = 3000, + batch_key: str = "donor_id", + force: bool = False, +) -> ad.AnnData: + """Run preprocessing pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + adata = run_preprocessing_pipeline( + adata, + target_sum=target_sum, + n_top_genes=n_top_genes, + batch_key=batch_key, + ) + # Remove counts layer after preprocessing to save space + if "counts" in adata.layers: + del adata.layers["counts"] + print("Removed counts layer to save checkpoint space") + + save_checkpoint(adata, checkpoint_file) + return adata + + +@task(name="dimensionality_reduction") +def dimensionality_reduction_task( + adata: ad.AnnData, + checkpoint_file: Path, + batch_key: str = "donor_id", + n_neighbors: int = 30, + n_pcs: int = 40, + figure_dir: Path | None = None, + force: bool = False, +) -> ad.AnnData: + """Run dimensionality reduction pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + adata = run_dimensionality_reduction_pipeline( + adata, + batch_key=batch_key, + n_neighbors=n_neighbors, + n_pcs=n_pcs, + figure_dir=figure_dir, + ) + save_checkpoint(adata, checkpoint_file) + return adata + + +@task(name="clustering") +def clustering_task( + adata: ad.AnnData, + checkpoint_file: Path, + resolution: float = 1.0, + figure_dir: Path | None = None, + force: bool = False, +) -> ad.AnnData: + """Run clustering pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + adata = run_clustering_pipeline( + adata, + resolution=resolution, + figure_dir=figure_dir, + ) + save_checkpoint(adata, checkpoint_file) + return adata + + +@task(name="pseudobulk") +def pseudobulk_task( + adata: ad.AnnData, + checkpoint_file: Path, + group_col: str = "cell_type", + donor_col: str = "donor_id", + metadata_cols: list[str] | None = None, + min_cells: int = 10, + figure_dir: Path | None = None, + layer: str | None = None, + force: bool = False, +) -> ad.AnnData: + """Run pseudobulking pipeline with checkpointing.""" + if checkpoint_file.exists() and not force: + print(f"Loading from checkpoint: {checkpoint_file.name}") + return load_checkpoint(checkpoint_file) + + pb_adata = run_pseudobulk_pipeline( + adata, + group_col=group_col, + donor_col=donor_col, + metadata_cols=metadata_cols, + min_cells=min_cells, + figure_dir=figure_dir, + layer=layer, + ) + save_checkpoint(pb_adata, checkpoint_file) + return pb_adata + + +@task(name="differential_expression", retries=1) +def differential_expression_task( + pb_adata: ad.AnnData, + cell_type: str, + var_to_feature: dict[str, str], + output_dir: Path, + design_factors: list[str] | None = None, + n_cpus: int = 8, +) -> dict[str, Any]: + """Run differential expression for a specific cell type. + + Returns dict with stat_res, de_results, and counts_df. + """ + print(f"\n{'=' * 60}") + print(f"Running DE for cell type: {cell_type}") + print(f"{'=' * 60}") + + stat_res, de_results, counts_df = run_differential_expression_pipeline( + pb_adata, + cell_type=cell_type, + design_factors=design_factors, + var_to_feature=var_to_feature, + n_cpus=n_cpus, + ) + + # Save results to cell-type specific directory + ct_dir = output_dir / _sanitize_cell_type(cell_type) + ct_dir.mkdir(parents=True, exist_ok=True) + + save_checkpoint(stat_res, ct_dir / "stat_res.pkl") + de_results.to_parquet(ct_dir / "de_results.parquet") + counts_df.to_parquet(ct_dir / "counts.parquet") + + return { + "cell_type": cell_type, + "stat_res": stat_res, + "de_results": de_results, + "counts_df": counts_df, + } + + +@task(name="pathway_analysis") +def pathway_analysis_task( + de_results: pd.DataFrame, + cell_type: str, + output_dir: Path, + gene_sets: list[str] | None = None, + n_top: int = 10, +) -> dict[str, Any]: + """Run GSEA pathway analysis for a cell type.""" + print(f"\n{'=' * 60}") + print(f"Running GSEA for cell type: {cell_type}") + print(f"{'=' * 60}") + + ct_dir = output_dir / _sanitize_cell_type(cell_type) + ct_dir.mkdir(parents=True, exist_ok=True) + figure_dir = ct_dir / "figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + gsea_results = run_gsea_pipeline( + de_results, + gene_sets=gene_sets, + n_top=n_top, + figure_dir=figure_dir, + ) + + save_checkpoint(gsea_results, ct_dir / "gsea_results.pkl") + + return { + "cell_type": cell_type, + "gsea_results": gsea_results, + } + + +@task(name="overrepresentation") +def overrepresentation_task( + de_results: pd.DataFrame, + cell_type: str, + output_dir: Path, + gene_sets: list[str] | None = None, + padj_threshold: float = 0.05, + n_top: int = 10, +) -> dict[str, Any]: + """Run Enrichr overrepresentation analysis for a cell type.""" + print(f"\n{'=' * 60}") + print(f"Running Enrichr for cell type: {cell_type}") + print(f"{'=' * 60}") + + ct_dir = output_dir / _sanitize_cell_type(cell_type) + ct_dir.mkdir(parents=True, exist_ok=True) + figure_dir = ct_dir / "figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + enr_up, enr_down = run_overrepresentation_pipeline( + de_results, + gene_sets=gene_sets, + padj_threshold=padj_threshold, + n_top=n_top, + figure_dir=figure_dir, + ) + + save_checkpoint(enr_up, ct_dir / "enrichr_up.pkl") + save_checkpoint(enr_down, ct_dir / "enrichr_down.pkl") + + return { + "cell_type": cell_type, + "enr_up": enr_up, + "enr_down": enr_down, + } + + +@task(name="predictive_modeling") +def predictive_modeling_task( + counts_df: pd.DataFrame, + metadata: pd.DataFrame, + cell_type: str, + output_dir: Path, + n_splits: int = 5, +) -> dict[str, Any]: + """Run predictive modeling for a cell type.""" + print(f"\n{'=' * 60}") + print(f"Running predictive modeling for cell type: {cell_type}") + print(f"{'=' * 60}") + + ct_dir = output_dir / _sanitize_cell_type(cell_type) + ct_dir.mkdir(parents=True, exist_ok=True) + figure_dir = ct_dir / "figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + prediction_results = run_predictive_modeling_pipeline( + counts_df, + metadata, + n_splits=n_splits, + figure_dir=figure_dir, + ) + + save_checkpoint(prediction_results, ct_dir / "prediction_results.pkl") + + return { + "cell_type": cell_type, + "prediction_results": prediction_results, + } + + +def _sanitize_cell_type(cell_type: str) -> str: + """Sanitize cell type name for use as directory name.""" + return cell_type.replace(" ", "_").replace(",", "").replace("-", "_") diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile new file mode 100644 index 0000000..147bd26 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Makefile @@ -0,0 +1,27 @@ +include ../../../../.env +export + +# Generate rule dependency graph +rulegraph: + snakemake --rulegraph --config datadir=$(DATADIR)/immune_aging/wf_snakemake/ --cores 2 | dot -Tpng > rulegraph.png + +# Run the full workflow +run: + snakemake --cores 8 --config datadir=$(DATADIR)/immune_aging/wf_snakemake/ +# Generate HTML report (run after workflow completes) +report: + snakemake --report $(DATADIR)/immune_aging/wf_snakemake/report.html --config datadir=$(DATADIR)/immune_aging/ + +# Generate ZIP report (for larger reports with many figures) +report-zip: + snakemake --report $(DATADIR)/immune_aging/workflow/wf_snakemake/report.zip --config datadir=$(DATADIR)/immune_aging/ + +# Dry run - show what would be executed +dry-run: + snakemake -n --config datadir=$(DATADIR)/immune_aging/wf_snakemake/ + +# Clean all outputs +clean: + rm -rf $(DATADIR)/immune_aging/wf_snakemake + +.PHONY: rulegraph run report report-zip dry-run clean diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile new file mode 100644 index 0000000..796a140 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/Snakefile @@ -0,0 +1,104 @@ +"""Main Snakemake workflow for scRNA-seq immune aging analysis. + +This workflow is functionally equivalent to the Prefect and stateless workflows. +It processes scRNA-seq data through 11 steps: + +Global Steps (1-7): +1. Data Download +2. Data Filtering +3. Quality Control +4. Preprocessing +5. Dimensionality Reduction +6. Clustering +7. Pseudobulking (discovers cell types) + +Per-Cell-Type Steps (8-11): +8. Differential Expression +9. Pathway Analysis (GSEA) +10. Overrepresentation Analysis (Enrichr) +11. Predictive Modeling + +Usage: + # Run full workflow + snakemake --cores 8 --config datadir=/path/to/data + + # Dry run (see what would be executed) + snakemake -n --config datadir=/path/to/data + + # Force re-run from a specific rule + snakemake --cores 8 --forcerun dimensionality_reduction --config datadir=/path/to/data + + # Run only preprocessing (steps 1-6) + snakemake --cores 8 clustering --config datadir=/path/to/data +""" + +from pathlib import Path + +from snakemake.utils import min_version + +# Require Snakemake 8.0 or higher +min_version("8.0") + + +# Load configuration +configfile: "config/config.yaml" + + +# Global report description +report: "report/workflow.rst" + + +# Validate required config +if config.get("datadir") is None: + raise ValueError( + "datadir must be provided via --config datadir=/path/to/data" + ) + +DATADIR = Path(config["datadir"]) +DATASET = config["dataset_name"] + +# Derived paths (using wf_snakemake folder) +CHECKPOINT_DIR = DATADIR / "wf_snakemake" / "checkpoints" +RESULTS_DIR = DATADIR / "wf_snakemake" / "results" +FIGURE_DIR = DATADIR / "wf_snakemake" / "figures" +LOG_DIR = DATADIR / "wf_snakemake" / "logs" + + +# Include modular rule files +include: "rules/common.smk" +include: "rules/preprocessing.smk" +include: "rules/pseudobulk.smk" +include: "rules/per_cell_type.smk" + + +# Default target: all analyses complete +rule all: + input: + # Global preprocessing outputs + CHECKPOINT_DIR / f"dataset-{DATASET}_step-06_desc-clustered.h5ad", + # Aggregated per-cell-type results (triggers dynamic rules) + RESULTS_DIR / "workflow_complete.txt", + + +# Rule to aggregate all per-cell-type results +rule aggregate_results: + input: + aggregate_per_cell_type_outputs, + output: + RESULTS_DIR / "workflow_complete.txt", + log: + LOG_DIR / "aggregate_results.log", + script: + "scripts/aggregate_results.py" + + +# Preprocessing-only target (stops at step 6) +rule preprocessing_only: + input: + CHECKPOINT_DIR / f"dataset-{DATASET}_step-06_desc-clustered.h5ad", + + +# Pseudobulk-only target (stops at step 7) +rule pseudobulk_only: + input: + CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_desc-pseudobulk.h5ad", diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md new file mode 100644 index 0000000..b39b832 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/WORKFLOW_OVERVIEW.md @@ -0,0 +1,424 @@ +# Snakemake scRNA-seq Immune Aging Workflow + +## Overview + +This workflow analyzes single-cell RNA sequencing (scRNA-seq) data to investigate gene expression changes associated with aging in immune cells. It processes data from the OneK1K dataset (peripheral blood mononuclear cells from 982 donors) through quality control, normalization, dimensionality reduction, and per-cell-type differential expression analysis. + +The workflow is divided into two phases: +- **Global Steps (1-7)**: Process the entire dataset +- **Per-Cell-Type Steps (8-11)**: Run independently for each cell type discovered in Step 7 + +--- + +## Workflow Diagram + +``` +┌─────────────────────────────────────────────────────────────────────────┐ +│ GLOBAL STEPS (1-7) │ +├─────────────────────────────────────────────────────────────────────────┤ +│ │ +│ Step 1: Download ──► Step 2: Filter ──► Step 3: QC ──► Step 4: Preprocess +│ │ │ +│ ▼ │ +│ Step 7: Pseudobulk ◄── Step 6: Cluster ◄── Step 5: DimRed. | +│ │ │ +└──────────────────────────────┼──────────────────────────────────────────┘ + │ + ▼ (discovers N cell types) +┌──────────────────────────────────────────────────────────────────────────┐ +│ PER-CELL-TYPE STEPS (8-11) │ +│ Runs in parallel for each cell type │ +├──────────────────────────────────────────────────────────────────────────┤ +│ │ +│ For each cell type: │ +│ │ +│ Step 8: Differential Expression │ +│ │ │ +│ ├──► Step 9: GSEA (Pathway Analysis) │ +│ │ │ +│ ├──► Step 10: Enrichr (Overrepresentation) │ +│ │ │ +│ └──► Step 11: Predictive Modeling (Age Prediction) │ +│ │ +└──────────────────────────────────────────────────────────────────────────┘ +``` + +--- + +## Step Details + +### Step 1: Data Download + +**Purpose**: Download the raw scRNA-seq dataset from CELLxGENE. + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `url` | CELLxGENE URL | Source URL for the h5ad file | +| `dataset_name` | "OneK1K" | Dataset identifier | + +**Input**: None (downloads from URL) +**Output**: Raw h5ad file (~1.2M cells × 35K genes) + +--- + +### Step 2: Data Filtering + +**Purpose**: Remove low-quality donors and rare cell types to ensure robust downstream analysis. + +**Operations**: +1. **Donor filtering**: Remove donors with abnormally low cell counts + - Uses percentile-based cutoff to identify outliers +2. **Cell type filtering**: Keep only cell types present in sufficient donors + - Requires minimum cells per cell type in a threshold percentage of donors +3. **Zero-count gene removal**: Remove genes with no expression across retained cells +4. **Memory loading**: Convert lazy-loaded data to in-memory representation + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `cutoff_percentile` | 1.0 | Percentile for donor cell count cutoff | +| `min_cells_per_celltype` | 10 | Minimum cells per cell type per donor | +| `percent_donors` | 0.95 | Fraction of donors that must have the cell type | + +**Input**: Raw h5ad file +**Output**: Filtered h5ad checkpoint + +--- + +### Step 3: Quality Control (QC) + +**Purpose**: Identify and remove low-quality cells, dying cells, and doublets. + +**Operations**: +1. **Gene annotation**: Identify mitochondrial (MT-), ribosomal (RPS/RPL), and hemoglobin (HB) genes +2. **QC metric calculation**: Compute per-cell metrics using scanpy + - Total counts, genes detected, % mitochondrial, % ribosomal, % hemoglobin +3. **Cell filtering**: Remove cells outside quality thresholds +4. **Doublet detection**: Run Scrublet per-donor to identify and remove doublets +5. **Raw count preservation**: Store raw counts in a layer for pseudobulking + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `min_genes` | 200 | Minimum genes per cell | +| `max_genes` | 6000 | Maximum genes per cell (doublet filter) | +| `min_counts` | 500 | Minimum UMIs per cell | +| `max_counts` | 30000 | Maximum UMIs per cell (doublet filter) | +| `max_hb_pct` | 5.0 | Maximum hemoglobin % (RBC contamination) | +| `expected_doublet_rate` | 0.06 | Expected doublet rate for Scrublet | + +**Algorithm**: Scrublet (doublet detection) +**Input**: Filtered h5ad +**Output**: QC-filtered h5ad checkpoint + +--- + +### Step 4: Preprocessing + +**Purpose**: Normalize expression values and select informative genes for downstream analysis. + +**Operations**: +1. **Normalization**: Scale counts to target sum per cell (CPM-like) +2. **Log transformation**: Apply log1p transformation for variance stabilization +3. **HVG selection**: Identify highly variable genes using Seurat v3 method + - Accounts for batch effects using donor as batch key +4. **Nuisance gene removal**: Exclude from HVG list: + - TCR/BCR variable region genes (IG[HKL]V, TR[ABDG]V patterns) + - Mitochondrial genes (MT-*) + - Ribosomal genes (RPS*, RPL*) +5. **PCA**: Compute principal components on HVG subset + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `target_sum` | 10000 | Target sum for normalization | +| `n_top_genes` | 3000 | Number of highly variable genes | +| `batch_key` | "donor_id" | Column for batch correction in HVG selection | + +**Algorithms**: +- Normalization: scanpy `normalize_total` +- HVG: Seurat v3 method (`flavor="seurat_v3"`) +- PCA: ARPACK solver + +**Input**: QC-filtered h5ad +**Output**: Preprocessed h5ad checkpoint + +--- + +### Step 5: Dimensionality Reduction + +**Purpose**: Reduce dimensionality and correct for batch effects for visualization and clustering. + +**Operations**: +1. **Batch correction**: Run Harmony integration on PCA coordinates + - Corrects for donor-specific technical effects +2. **Neighbor graph**: Compute k-nearest neighbor graph in corrected PCA space +3. **UMAP**: Generate 2D embedding for visualization + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `batch_key` | "donor_id" | Column for batch correction | +| `n_neighbors` | 30 | Number of neighbors for graph | +| `n_pcs` | 40 | Number of PCs to use | + +**Algorithms**: +- Batch correction: Harmony (harmony-pytorch) +- Neighbor graph: scanpy `pp.neighbors` (uses pynndescent/numba) +- UMAP: scanpy `tl.umap` + +**Input**: Preprocessed h5ad +**Output**: Dimensionality-reduced h5ad checkpoint + +--- + +### Step 6: Clustering + +**Purpose**: Cluster cells for visualization and validation (uses pre-existing cell type annotations). + +**Operations**: +1. **Leiden clustering**: Community detection on neighbor graph +2. **UMAP visualization**: Plot clusters colored by cell type + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `resolution` | 1.0 | Leiden clustering resolution | + +**Algorithm**: Leiden clustering (scanpy `tl.leiden`) + +**Input**: Dimensionality-reduced h5ad +**Output**: Clustered h5ad checkpoint + +--- + +### Step 7: Pseudobulking (Checkpoint) + +**Purpose**: Aggregate single-cell counts to donor-level pseudobulk samples for differential expression analysis. + +**Operations**: +1. **Count aggregation**: Sum raw counts per (cell_type, donor) combination + - Uses one-hot encoding for efficient sparse matrix multiplication +2. **Metadata preservation**: Retain donor-level metadata (age, sex, etc.) +3. **Sample filtering**: Remove pseudobulk samples with too few contributing cells +4. **Cell type discovery**: Identify cell types with sufficient samples for analysis + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `group_col` | "cell_type" | Column for grouping cells | +| `donor_col` | "donor_id" | Column for donor identity | +| `metadata_cols` | ["development_stage", "sex"] | Metadata to preserve | +| `min_cells` | 10 | Minimum cells per pseudobulk sample | +| `min_samples_per_cell_type` | 10 | Minimum samples to include cell type | + +**Note**: This step uses Snakemake's `checkpoint` mechanism to dynamically determine which cell types to analyze in subsequent steps. + +**Input**: QC checkpoint (raw counts), filtered checkpoint (gene names) +**Output**: Pseudobulk h5ad, cell_types.json, var_to_feature.json + +--- + +### Step 8: Differential Expression (Per-Cell-Type) + +**Purpose**: Identify genes associated with aging within each cell type. + +**Operations**: +1. **Age extraction**: Parse numeric age from development_stage field +2. **Age scaling**: Z-score normalize age for stable model fitting +3. **DESeq2 analysis**: Fit negative binomial GLM with design `~ age_scaled + sex` +4. **Wald test**: Test for age effect (contrast on age_scaled coefficient) +5. **Multiple testing**: Apply Benjamini-Hochberg FDR correction + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `design_factors` | ["age_scaled", "sex"] | Model covariates | +| `n_cpus` | 8 | CPUs for DESeq2 | + +**Algorithm**: DESeq2 (via PyDESeq2) +- Dispersion estimation with shrinkage +- Wald test for coefficient significance +- Cook's distance for outlier detection + +**Input**: Pseudobulk h5ad, var_to_feature mapping +**Output**: DESeq2 statistics (pkl), results table (parquet), counts (parquet) + +--- + +### Step 9: Pathway Analysis - GSEA (Per-Cell-Type) + +**Purpose**: Identify biological pathways enriched in aging-associated genes using ranked gene set enrichment. + +**Operations**: +1. **Gene ranking**: Rank genes by DESeq2 test statistic +2. **Preranked GSEA**: Run against MSigDB Hallmark gene sets +3. **NES calculation**: Compute normalized enrichment scores +4. **Visualization**: Generate pathway enrichment plots + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `gene_sets` | ["MSigDB_Hallmark_2020"] | Gene set databases | +| `n_top` | 10 | Number of top pathways to display | + +**Algorithm**: GSEA prerank (via gseapy) +- 1000 permutations for p-value estimation +- Min pathway size: 10 genes, Max: 1000 genes + +**Input**: DE results (parquet) +**Output**: GSEA results (pkl) + +--- + +### Step 10: Overrepresentation Analysis - Enrichr (Per-Cell-Type) + +**Purpose**: Test for pathway enrichment in significantly up/down-regulated gene sets. + +**Operations**: +1. **Gene set extraction**: Separate significant genes (padj < 0.05) by direction +2. **Enrichr analysis**: Query Enrichr web service for pathway enrichment +3. **Visualization**: Generate dot plots for enriched pathways + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `gene_sets` | ["MSigDB_Hallmark_2020"] | Gene set databases | +| `padj_threshold` | 0.05 | Significance threshold for gene selection | +| `n_top` | 10 | Number of top pathways to display | + +**Algorithm**: Enrichr (via gseapy) +- Fisher's exact test with FDR correction + +**Input**: DE results (parquet) +**Output**: Enrichr results for up/down genes (pkl) + +--- + +### Step 11: Predictive Modeling (Per-Cell-Type) + +**Purpose**: Assess whether gene expression in each cell type can predict donor age. + +**Operations**: +1. **Feature preparation**: Combine gene expression with sex as features +2. **Cross-validation**: 5-fold shuffle split +3. **Model training**: Linear Support Vector Regression with scaling +4. **Baseline comparison**: Compare full model (genes + sex) vs. baseline (sex only) +5. **Metrics**: R² score and Mean Absolute Error (MAE) + +| Parameter | Default Value | Description | +|-----------|--------------|-------------| +| `n_splits` | 5 | Number of CV folds | + +**Algorithm**: Linear SVR (scikit-learn) +- StandardScaler for feature normalization +- C=1.0 regularization +- Max 10,000 iterations + +**Input**: Counts (parquet), pseudobulk metadata +**Output**: Prediction results with CV metrics (pkl) + +--- + +## Output Structure + +``` +{datadir}/wf_snakemake/ +├── checkpoints/ +│ ├── dataset-{name}_step-02_desc-filtered.h5ad +│ ├── dataset-{name}_step-03_desc-qc.h5ad +│ ├── dataset-{name}_step-04_desc-preprocessed.h5ad +│ ├── dataset-{name}_step-05_desc-dimreduced.h5ad +│ ├── dataset-{name}_step-06_desc-clustered.h5ad +│ ├── dataset-{name}_step-07_desc-pseudobulk.h5ad +│ ├── dataset-{name}_step-07_cell_types.json +│ └── dataset-{name}_step-07_var_to_feature.json +├── results/ +│ └── per_cell_type/ +│ └── {cell_type}/ +│ ├── stat_res.pkl +│ ├── de_results.parquet +│ ├── counts.parquet +│ ├── gsea_results.pkl +│ ├── enrichr_up.pkl +│ ├── enrichr_down.pkl +│ └── prediction_results.pkl +├── figures/ +│ ├── donor_cell_counts_distribution.png +│ ├── qc_violin_plots.png +│ ├── hemoglobin_distribution.png +│ ├── pca_cell_type.png +│ ├── umap_total_counts.png +│ └── per_cell_type/{cell_type}/ +│ ├── gsea_pathways.png +│ └── enrichr_*.png +└── logs/ + └── step*.log +``` + +--- + +## Usage + +```bash +# Run full workflow +snakemake --cores 16 --config datadir=/path/to/data + +# Dry run (see what would be executed) +snakemake -n --config datadir=/path/to/data + +# Run only preprocessing (steps 1-6) +snakemake --cores 16 preprocessing_only --config datadir=/path/to/data + +# Force re-run from a specific step +snakemake --cores 16 --forcerun dimensionality_reduction --config datadir=/path/to/data + +# Generate HTML report (after workflow completes) +snakemake --report /path/to/data/wf_snakemake/report.html --config datadir=/path/to/data + +# Generate ZIP report (for larger reports) +snakemake --report /path/to/data/wf_snakemake/report.zip --config datadir=/path/to/data +``` + +--- + +## Report Generation + +The workflow includes Snakemake's built-in report generation functionality. After the workflow completes, you can generate a self-contained HTML report that includes: + +- **Runtime statistics**: Execution times for each rule +- **Provenance information**: Input/output file tracking +- **Workflow topology**: Visual representation of rule dependencies +- **Analysis results**: Figures from each analysis step + +### Report Contents + +The report organizes results by analysis step: + +| Category | Contents | +|----------|----------| +| Step 2: Filtering | Donor cell count distribution | +| Step 3: Quality Control | QC violin plots, scatter plots, hemoglobin distribution, doublet UMAP | +| Step 5: Dimensionality Reduction | PCA and UMAP visualizations | +| Step 6: Clustering | UMAP with cell type and cluster annotations | +| Step 7: Pseudobulking | Pseudobulk sample characteristics | +| Step 9: Pathway Analysis (GSEA) | GSEA pathway plots per cell type | +| Step 10: Overrepresentation Analysis | Enrichr pathway plots per cell type | +| Step 11: Predictive Modeling | Age prediction performance per cell type | + +### Using the Makefile + +If using the provided Makefile: + +```bash +# Generate HTML report +make report + +# Generate ZIP report (recommended for many cell types) +make report-zip +``` + +--- + +## Key Dependencies + +| Package | Purpose | +|---------|---------| +| scanpy | scRNA-seq analysis framework | +| anndata | Data structure for scRNA-seq | +| harmony-pytorch | Batch correction | +| pydeseq2 | Differential expression | +| gseapy | GSEA and Enrichr analysis | +| scikit-learn | Predictive modeling | +| snakemake | Workflow management | diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml new file mode 100644 index 0000000..121be0f --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/config/config.yaml @@ -0,0 +1,75 @@ +# Configuration for Snakemake scRNA-seq immune aging workflow +# +# Usage: +# snakemake --cores 8 --config datadir=/path/to/data +# +# Override any parameter: +# snakemake --cores 8 --config datadir=/path/to/data dataset_name=MyDataset + +# Dataset configuration +dataset_name: "OneK1K" +url: "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad" + +# Step 2: Filtering parameters +filtering: + cutoff_percentile: 1.0 + min_cells_per_celltype: 10 + percent_donors: 0.95 + +# Step 3: QC parameters +qc: + min_genes: 200 + max_genes: 6000 + min_counts: 500 + max_counts: 30000 + max_hb_pct: 5.0 + expected_doublet_rate: 0.06 + +# Step 4: Preprocessing parameters +preprocessing: + target_sum: 10000 + n_top_genes: 3000 + batch_key: "donor_id" + +# Step 5: Dimensionality reduction parameters +dimred: + batch_key: "donor_id" + n_neighbors: 30 + n_pcs: 40 + +# Step 6: Clustering parameters +clustering: + resolution: 1.0 + +# Step 7: Pseudobulking parameters +pseudobulk: + group_col: "cell_type" + donor_col: "donor_id" + metadata_cols: + - "development_stage" + - "sex" + min_cells: 10 + +# Steps 8-11: Per-cell-type analysis parameters +differential_expression: + design_factors: + - "age_scaled" + - "sex" + n_cpus: 8 + +pathway_analysis: + gene_sets: + - "MSigDB_Hallmark_2020" + n_top: 10 + +overrepresentation: + gene_sets: + - "MSigDB_Hallmark_2020" + padj_threshold: 0.05 + n_top: 10 + +predictive_modeling: + n_splits: 5 + +# Minimum samples per cell type for per-cell-type analysis +min_samples_per_cell_type: 10 diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst new file mode 100644 index 0000000..79cc652 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/clustering.rst @@ -0,0 +1,4 @@ +UMAP visualization with cell type and Leiden clustering. + +Cell types are annotated from the original dataset. Leiden clustering +identifies communities of cells with similar expression profiles. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst new file mode 100644 index 0000000..3210df8 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/de_results.rst @@ -0,0 +1,4 @@ +Differential expression results for {{ snakemake.wildcards.cell_type }}. + +Contains log2 fold changes, p-values, and adjusted p-values from +DESeq2 analysis comparing conditions within this cell type. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst new file mode 100644 index 0000000..efc9341 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/doublet_umap.rst @@ -0,0 +1,4 @@ +UMAP visualization of predicted doublets. + +Doublets (cells containing RNA from multiple cells) are computationally +detected and shown here in the context of the full UMAP embedding. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst new file mode 100644 index 0000000..fb9dc2b --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/enrichr.rst @@ -0,0 +1,4 @@ +Enrichr pathway analysis for {{ snakemake.wildcards.cell_type }}. + +Overrepresentation analysis of differentially expressed genes using +the Enrichr database to identify enriched biological processes. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst new file mode 100644 index 0000000..2afe459 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/filtering.rst @@ -0,0 +1,4 @@ +Distribution of cell counts per donor after filtering. + +This plot shows the number of cells from each donor that passed quality filters, +helping to identify potential batch effects or sample quality issues. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst new file mode 100644 index 0000000..bc4c4e0 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/gsea.rst @@ -0,0 +1,4 @@ +Gene Set Enrichment Analysis (GSEA) results for {{ snakemake.wildcards.cell_type }}. + +Shows significantly enriched pathways based on the ranking of genes +by their differential expression statistics. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst new file mode 100644 index 0000000..ea70d4f --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/hemoglobin.rst @@ -0,0 +1,4 @@ +Distribution of hemoglobin gene expression. + +High hemoglobin gene expression can indicate red blood cell contamination. +Cells exceeding the threshold are filtered out to improve data quality. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst new file mode 100644 index 0000000..805e6ec --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pca.rst @@ -0,0 +1,4 @@ +PCA visualization of cells colored by cell type. + +Principal component analysis reduces dimensionality while preserving +the major sources of variation in gene expression. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst new file mode 100644 index 0000000..da779b7 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/prediction.rst @@ -0,0 +1,4 @@ +Age prediction performance for {{ snakemake.wildcards.cell_type }}. + +Cross-validated prediction of donor age from gene expression using +machine learning models. Shows correlation between predicted and actual age. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst new file mode 100644 index 0000000..3fcbdd4 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/pseudobulk.rst @@ -0,0 +1,4 @@ +Distribution of pseudobulk sample characteristics. + +Shows the distribution of cells per sample and total counts after +aggregating single-cell data to pseudobulk samples per donor and cell type. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst new file mode 100644 index 0000000..5e2b9f4 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_scatter.rst @@ -0,0 +1,5 @@ +Scatter plot of QC metrics with doublet predictions. + +Shows the relationship between gene counts and UMI counts per cell, +colored by predicted doublet status. Doublets typically have elevated +counts in both dimensions. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst new file mode 100644 index 0000000..e4d4415 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/qc_violin.rst @@ -0,0 +1,8 @@ +Violin plots of quality control metrics. + +Shows the distribution of key QC metrics across cells: +- Number of genes detected per cell +- Total UMI counts per cell +- Mitochondrial gene percentage + +These metrics help identify low-quality cells for filtering. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst new file mode 100644 index 0000000..64c8b38 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/umap.rst @@ -0,0 +1,4 @@ +UMAP visualization colored by total counts. + +UMAP provides a non-linear dimensionality reduction that preserves +local structure. Coloring by total counts helps assess technical variation. diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst new file mode 100644 index 0000000..f011d94 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/report/workflow.rst @@ -0,0 +1,29 @@ +This workflow performs single-cell RNA-seq analysis of immune aging data. + +The analysis consists of 11 steps: + +**Global Preprocessing (Steps 1-7)** + +1. Data Download - Retrieve raw data from repository +2. Data Filtering - Remove low-quality cells and cell types +3. Quality Control - Filter cells based on QC metrics and detect doublets +4. Preprocessing - Normalize and select highly variable genes +5. Dimensionality Reduction - PCA and UMAP computation +6. Clustering - Leiden clustering for cell type identification +7. Pseudobulking - Aggregate single-cell data to pseudobulk per donor/cell-type + +**Per-Cell-Type Analysis (Steps 8-11)** + +For each cell type discovered in step 7: + +8. Differential Expression - Compare gene expression between conditions +9. Pathway Analysis (GSEA) - Identify enriched biological pathways +10. Overrepresentation Analysis - Enrichr analysis of DE genes +11. Predictive Modeling - Age prediction from gene expression + +Configuration +============= + +Dataset: ``{{ snakemake.config["dataset_name"] }}`` + +Data directory: ``{{ snakemake.config["datadir"] }}`` diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk new file mode 100644 index 0000000..1bff4bb --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/common.smk @@ -0,0 +1,96 @@ +"""Common helper functions and wildcards for Snakemake workflow.""" + +import json +from pathlib import Path + + +def sanitize_cell_type(cell_type: str) -> str: + """Sanitize cell type name for filesystem use. + + Matches the function used in Prefect workflow. + """ + return cell_type.replace(" ", "_").replace(",", "").replace("-", "_") + + +def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str: + """Convert sanitized cell type back to original name. + + Parameters + ---------- + sanitized : str + Sanitized cell type name + cell_types_file : Path + Path to cell_types.json file from pseudobulk step + + Returns + ------- + str + Original cell type name + """ + with open(cell_types_file) as f: + data = json.load(f) + # Reverse lookup + for original, sanitized_name in data["sanitized_names"].items(): + if sanitized_name == sanitized: + return original + raise ValueError(f"Unknown sanitized cell type: {sanitized}") + + +def bids_checkpoint_name( + dataset_name: str, step_number: int, description: str, extension: str = "h5ad" +) -> str: + """Generate BIDS-compliant checkpoint filename. + + Matches the naming convention used in stateless_workflow. + """ + return f"dataset-{dataset_name}_step-{step_number:02d}_desc-{description}.{extension}" + + +def get_valid_cell_types(wildcards): + """Get list of valid cell types from pseudobulk checkpoint. + + This function is used as an input function after the checkpoint + to determine which cell types to process. + """ + checkpoint_output = checkpoints.pseudobulk.get(**wildcards) + cell_types_file = checkpoint_output.output.cell_types + + with open(cell_types_file) as f: + data = json.load(f) + + return data["valid_cell_types"] + + +def aggregate_per_cell_type_outputs(wildcards): + """Aggregate function to collect all per-cell-type outputs. + + This is called after the pseudobulk checkpoint is resolved to + generate the list of expected outputs for all valid cell types. + """ + checkpoint_output = checkpoints.pseudobulk.get(**wildcards) + cell_types_file = checkpoint_output.output.cell_types + + with open(cell_types_file) as f: + data = json.load(f) + + valid_cell_types = data["valid_cell_types"] + + outputs = [] + for ct in valid_cell_types: + ct_sanitized = sanitize_cell_type(ct) + ct_dir = RESULTS_DIR / "per_cell_type" / ct_sanitized + outputs.extend( + [ + ct_dir / "de_results.parquet", + ct_dir / "gsea_results.pkl", + ct_dir / "enrichr_up.pkl", + ct_dir / "enrichr_down.pkl", + ct_dir / "prediction_results.pkl", + # Figures for report + ct_dir / "figures" / "gsea_pathways.png", + ct_dir / "figures" / "enrichr_pathways.png", + ct_dir / "figures" / "age_prediction_performance.png", + ] + ) + + return outputs diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk new file mode 100644 index 0000000..ea5bbe1 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/per_cell_type.smk @@ -0,0 +1,114 @@ +"""Per-cell-type analysis rules (Steps 8-11). + +These rules are triggered dynamically based on the cell types discovered +in the pseudobulk checkpoint (step 7). Each rule uses the {cell_type} +wildcard to process all valid cell types. + +The workflow is: +- Step 8: Differential Expression (required first - provides DE results and counts) +- Step 9: Pathway Analysis (GSEA) - depends on DE results +- Step 10: Overrepresentation Analysis (Enrichr) - depends on DE results +- Step 11: Predictive Modeling - depends on counts from DE step +""" + + +# Step 8: Differential Expression (per cell type) +rule differential_expression: + input: + pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"), + var_to_feature=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_var_to_feature.json", + cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json", + output: + stat_res=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "stat_res.pkl", + de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet", + counts_df=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "counts.parquet", + params: + cell_type=lambda wildcards: wildcards.cell_type, + design_factors=config["differential_expression"]["design_factors"], + n_cpus=config["differential_expression"]["n_cpus"], + threads: config["differential_expression"]["n_cpus"] + log: + LOG_DIR / "step08_de_{cell_type}.log", + script: + "../scripts/differential_expression.py" + + +# Step 9: Pathway Analysis (GSEA) (per cell type) +rule pathway_analysis: + input: + de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet", + output: + gsea_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "gsea_results.pkl", + fig_gsea=report( + RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "gsea_pathways.png", + caption="../report/gsea.rst", + category="Step 9: Pathway Analysis (GSEA)", + subcategory="{cell_type}", + ), + params: + cell_type=lambda wildcards: wildcards.cell_type, + gene_sets=config["pathway_analysis"]["gene_sets"], + n_top=config["pathway_analysis"]["n_top"], + figure_dir=lambda wildcards: str( + RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures" + ), + log: + LOG_DIR / "step09_gsea_{cell_type}.log", + script: + "../scripts/gsea.py" + + +# Step 10: Overrepresentation Analysis (Enrichr) (per cell type) +rule overrepresentation: + input: + de_results=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "de_results.parquet", + output: + enr_up=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_up.pkl", + enr_down=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "enrichr_down.pkl", + fig_enrichr=report( + RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "enrichr_pathways.png", + caption="../report/enrichr.rst", + category="Step 10: Overrepresentation Analysis", + subcategory="{cell_type}", + ), + params: + cell_type=lambda wildcards: wildcards.cell_type, + gene_sets=config["overrepresentation"]["gene_sets"], + padj_threshold=config["overrepresentation"]["padj_threshold"], + n_top=config["overrepresentation"]["n_top"], + figure_dir=lambda wildcards: str( + RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures" + ), + log: + LOG_DIR / "step10_enrichr_{cell_type}.log", + script: + "../scripts/enrichr.py" + + +# Step 11: Predictive Modeling (per cell type) +rule predictive_modeling: + input: + counts_df=RESULTS_DIR / "per_cell_type" / "{cell_type}" / "counts.parquet", + pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"), + cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json", + output: + prediction_results=RESULTS_DIR + / "per_cell_type" + / "{cell_type}" + / "prediction_results.pkl", + fig_prediction=report( + RESULTS_DIR / "per_cell_type" / "{cell_type}" / "figures" / "age_prediction_performance.png", + caption="../report/prediction.rst", + category="Step 11: Predictive Modeling", + subcategory="{cell_type}", + ), + params: + cell_type=lambda wildcards: wildcards.cell_type, + n_splits=config["predictive_modeling"]["n_splits"], + figure_dir=lambda wildcards: str( + RESULTS_DIR / "per_cell_type" / wildcards.cell_type / "figures" + ), + log: + LOG_DIR / "step11_prediction_{cell_type}.log", + script: + "../scripts/prediction.py" diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk new file mode 100644 index 0000000..5700454 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/preprocessing.smk @@ -0,0 +1,150 @@ +"""Preprocessing rules (Steps 1-6). + +These rules handle the initial data processing pipeline: +1. Data Download +2. Data Filtering +3. Quality Control +4. Preprocessing (normalization, HVG selection) +5. Dimensionality Reduction (PCA, UMAP) +6. Clustering +""" + + +# Step 1: Data Download +rule download_data: + output: + DATADIR / f"dataset-{DATASET}_subset-immune_raw.h5ad", + params: + url=config["url"], + log: + LOG_DIR / "step01_download.log", + script: + "../scripts/download.py" + + +# Step 2: Data Filtering +rule filter_data: + input: + DATADIR / f"dataset-{DATASET}_subset-immune_raw.h5ad", + output: + checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"), + fig_donor_counts=report( + FIGURE_DIR / "donor_cell_counts_distribution.png", + caption="../report/filtering.rst", + category="Step 2: Filtering", + ), + params: + cutoff_percentile=config["filtering"]["cutoff_percentile"], + min_cells_per_celltype=config["filtering"]["min_cells_per_celltype"], + percent_donors=config["filtering"]["percent_donors"], + figure_dir=str(FIGURE_DIR), + log: + LOG_DIR / "step02_filtering.log", + script: + "../scripts/filter.py" + + +# Step 3: Quality Control +rule quality_control: + input: + CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"), + output: + checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"), + fig_violin=report( + FIGURE_DIR / "qc_violin_plots.png", + caption="../report/qc_violin.rst", + category="Step 3: Quality Control", + ), + fig_scatter=report( + FIGURE_DIR / "qc_scatter_doublets.png", + caption="../report/qc_scatter.rst", + category="Step 3: Quality Control", + ), + fig_hemoglobin=report( + FIGURE_DIR / "hemoglobin_distribution.png", + caption="../report/hemoglobin.rst", + category="Step 3: Quality Control", + ), + fig_doublet_umap=report( + FIGURE_DIR / "doublet_detection_umap.png", + caption="../report/doublet_umap.rst", + category="Step 3: Quality Control", + ), + threads: workflow.cores + params: + min_genes=config["qc"]["min_genes"], + max_genes=config["qc"]["max_genes"], + min_counts=config["qc"]["min_counts"], + max_counts=config["qc"]["max_counts"], + max_hb_pct=config["qc"]["max_hb_pct"], + expected_doublet_rate=config["qc"]["expected_doublet_rate"], + figure_dir=str(FIGURE_DIR), + log: + LOG_DIR / "step03_qc.log", + script: + "../scripts/qc.py" + + +# Step 4: Preprocessing +rule preprocess: + input: + CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"), + output: + CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"), + threads: workflow.cores + params: + target_sum=config["preprocessing"]["target_sum"], + n_top_genes=config["preprocessing"]["n_top_genes"], + batch_key=config["preprocessing"]["batch_key"], + log: + LOG_DIR / "step04_preprocessing.log", + script: + "../scripts/preprocess.py" + + +# Step 5: Dimensionality Reduction +rule dimensionality_reduction: + input: + CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 4, "preprocessed"), + output: + checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"), + fig_pca=report( + FIGURE_DIR / "pca_cell_type.png", + caption="../report/pca.rst", + category="Step 5: Dimensionality Reduction", + ), + fig_umap=report( + FIGURE_DIR / "umap_total_counts.png", + caption="../report/umap.rst", + category="Step 5: Dimensionality Reduction", + ), + threads: workflow.cores + params: + batch_key=config["dimred"]["batch_key"], + n_neighbors=config["dimred"]["n_neighbors"], + n_pcs=config["dimred"]["n_pcs"], + figure_dir=str(FIGURE_DIR), + log: + LOG_DIR / "step05_dimred.log", + script: + "../scripts/dimred.py" + + +# Step 6: Clustering +rule clustering: + input: + CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 5, "dimreduced"), + output: + checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"), + fig_clustering=report( + FIGURE_DIR / "umap_cell_type_leiden.png", + caption="../report/clustering.rst", + category="Step 6: Clustering", + ), + params: + resolution=config["clustering"]["resolution"], + figure_dir=str(FIGURE_DIR), + log: + LOG_DIR / "step06_clustering.log", + script: + "../scripts/cluster.py" diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk new file mode 100644 index 0000000..606ab86 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/rules/pseudobulk.smk @@ -0,0 +1,45 @@ +"""Pseudobulking rule (Step 7) - Uses Snakemake checkpoint for dynamic cell types. + +This step aggregates single-cell data to pseudobulk samples per cell-type and donor. +It outputs a JSON file listing valid cell types, which enables dynamic downstream rules. + +IMPORTANT: This uses 'checkpoint' instead of 'rule' because: +- The number of cell types is not known until this step completes +- Downstream rules (steps 8-11) need to run for each discovered cell type +- Snakemake's checkpoint mechanism re-evaluates the DAG after this step +""" + + +# Step 7: Pseudobulking (CHECKPOINT - enables dynamic per-cell-type rules) +checkpoint pseudobulk: + input: + # Step 2 provides feature_name column for var_to_feature mapping + filtered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 2, "filtered"), + # Step 3 provides raw counts in .X (after QC filtering) + qc_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 3, "qc"), + # Step 6 listed for workflow ordering (ensures clustering completes first) + clustered_checkpoint=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 6, "clustered"), + output: + # Main pseudobulk AnnData + pseudobulk=CHECKPOINT_DIR / bids_checkpoint_name(DATASET, 7, "pseudobulk"), + # JSON file listing valid cell types (enables dynamic downstream rules) + cell_types=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_cell_types.json", + # Gene name mapping (needed for DE analysis) + var_to_feature=CHECKPOINT_DIR / f"dataset-{DATASET}_step-07_var_to_feature.json", + # Pseudobulk figure + fig_pseudobulk=report( + FIGURE_DIR / "pseudobulk_violin.png", + caption="../report/pseudobulk.rst", + category="Step 7: Pseudobulking", + ), + params: + group_col=config["pseudobulk"]["group_col"], + donor_col=config["pseudobulk"]["donor_col"], + metadata_cols=config["pseudobulk"]["metadata_cols"], + min_cells=config["pseudobulk"]["min_cells"], + min_samples_per_cell_type=config["min_samples_per_cell_type"], + figure_dir=str(FIGURE_DIR), + log: + LOG_DIR / "step07_pseudobulk.log", + script: + "../scripts/pseudobulk.py" diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py new file mode 100644 index 0000000..4686bea --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/aggregate_results.py @@ -0,0 +1,56 @@ +"""Snakemake script for aggregating all per-cell-type results. + +This script runs after all per-cell-type analyses are complete. +It creates a summary file indicating successful completion. +""" +# ruff: noqa: F821 + +from datetime import datetime +from pathlib import Path + + +def main(): + """Aggregate results and create completion marker.""" + output_file = Path(snakemake.output[0]) + input_files = [Path(f) for f in snakemake.input] + + print(f"Aggregating {len(input_files)} result files...") + + # Group files by cell type + cell_types = set() + for f in input_files: + # Extract cell type from path: results/per_cell_type/{cell_type}/... + parts = f.parts + if "per_cell_type" in parts: + idx = parts.index("per_cell_type") + if idx + 1 < len(parts): + cell_types.add(parts[idx + 1]) + + # Create summary + summary = { + "workflow": "snakemake_scrna_immune_aging", + "completed_at": datetime.now().isoformat(), + "cell_types_analyzed": sorted(cell_types), + "total_cell_types": len(cell_types), + "output_files": len(input_files), + } + + # Write summary to output file + output_file.parent.mkdir(parents=True, exist_ok=True) + with open(output_file, "w") as f: + f.write("Workflow completed successfully!\n") + f.write(f"Completed at: {summary['completed_at']}\n") + f.write(f"Cell types analyzed: {summary['total_cell_types']}\n") + f.write("\n") + f.write("Cell types:\n") + for ct in summary["cell_types_analyzed"]: + f.write(f" - {ct}\n") + f.write("\n") + f.write(f"Total output files: {summary['output_files']}\n") + + print(f"Summary written to: {output_file}") + print(f"Analyzed {len(cell_types)} cell types") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py new file mode 100644 index 0000000..ff8ed68 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/cluster.py @@ -0,0 +1,48 @@ +"""Snakemake script for Step 6: Clustering.""" + +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import ( + run_clustering_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def main(): + """Run clustering pipeline.""" + # ruff: noqa: F821 + input_file = Path(snakemake.input[0]) + output_file = Path(snakemake.output.checkpoint) + + # Get parameters + resolution = snakemake.params.resolution + figure_dir = ( + Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None + ) + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + if figure_dir: + figure_dir.mkdir(parents=True, exist_ok=True) + + print(f"Loading data from: {input_file}") + adata = load_checkpoint(input_file) + print(f"Loaded dataset: {adata}") + + print("Running clustering pipeline...") + adata = run_clustering_pipeline( + adata, + resolution=resolution, + figure_dir=figure_dir, + ) + + # Save checkpoint + save_checkpoint(adata, output_file) + print(f"Saved checkpoint: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py new file mode 100644 index 0000000..193b423 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/differential_expression.py @@ -0,0 +1,79 @@ +"""Snakemake script for Step 8: Differential Expression.""" + +import json +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import ( + run_differential_expression_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str: + """Convert sanitized cell type back to original name.""" + # ruff: noqa: F821 + with open(cell_types_file) as f: + data = json.load(f) + # Reverse lookup + for original, sanitized_name in data["sanitized_names"].items(): + if sanitized_name == sanitized: + return original + raise ValueError(f"Unknown sanitized cell type: {sanitized}") + + +def main(): + """Run differential expression for a cell type.""" + pseudobulk_file = Path(snakemake.input.pseudobulk) + var_to_feature_file = Path(snakemake.input.var_to_feature) + cell_types_file = Path(snakemake.input.cell_types) + + output_stat_res = Path(snakemake.output.stat_res) + output_de_results = Path(snakemake.output.de_results) + output_counts_df = Path(snakemake.output.counts_df) + + # Get parameters + sanitized_cell_type = snakemake.params.cell_type + design_factors = snakemake.params.design_factors + n_cpus = snakemake.params.n_cpus + + # Get original cell type name + cell_type = unsanitize_cell_type(sanitized_cell_type, cell_types_file) + + print(f"Running DE for cell type: {cell_type}") + print(f"(sanitized: {sanitized_cell_type})") + + # Create output directory + output_stat_res.parent.mkdir(parents=True, exist_ok=True) + + # Load pseudobulk data + pb_adata = load_checkpoint(pseudobulk_file) + + # Load var_to_feature mapping + with open(var_to_feature_file) as f: + var_to_feature = json.load(f) + + # Run differential expression + stat_res, de_results, counts_df = run_differential_expression_pipeline( + pb_adata, + cell_type=cell_type, + design_factors=design_factors, + var_to_feature=var_to_feature, + n_cpus=n_cpus, + ) + + # Save outputs + save_checkpoint(stat_res, output_stat_res) + de_results.to_parquet(output_de_results) + counts_df.to_parquet(output_counts_df) + + print(f"DE results saved for: {cell_type}") + print(f" - stat_res: {output_stat_res}") + print(f" - de_results: {output_de_results}") + print(f" - counts_df: {output_counts_df}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py new file mode 100644 index 0000000..4e72cb6 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/dimred.py @@ -0,0 +1,59 @@ +"""Snakemake script for Step 5: Dimensionality Reduction.""" +# ruff: noqa: F821 + +import os +from pathlib import Path + +# Set thread count for numba/pynndescent before importing scanpy +os.environ["NUMBA_NUM_THREADS"] = str(snakemake.threads) +os.environ["OMP_NUM_THREADS"] = str(snakemake.threads) + +from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import ( + run_dimensionality_reduction_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def main(): + """Run dimensionality reduction pipeline.""" + print(f"Running with {snakemake.threads} threads") + + input_file = Path(snakemake.input[0]) + output_file = Path(snakemake.output.checkpoint) + + # Get parameters + batch_key = snakemake.params.batch_key + n_neighbors = snakemake.params.n_neighbors + n_pcs = snakemake.params.n_pcs + figure_dir = ( + Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None + ) + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + if figure_dir: + figure_dir.mkdir(parents=True, exist_ok=True) + + print(f"Loading data from: {input_file}") + adata = load_checkpoint(input_file) + print(f"Loaded dataset: {adata}") + + print("Running dimensionality reduction pipeline...") + adata = run_dimensionality_reduction_pipeline( + adata, + batch_key=batch_key, + n_neighbors=n_neighbors, + n_pcs=n_pcs, + figure_dir=figure_dir, + ) + + # Save checkpoint + save_checkpoint(adata, output_file) + print(f"Saved checkpoint: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py new file mode 100644 index 0000000..659b04d --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/download.py @@ -0,0 +1,23 @@ +"""Snakemake script for Step 1: Data Download.""" + +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import download_data + + +def main(): + """Download data file if it doesn't exist.""" + # ruff: noqa: F821 + datafile = Path(snakemake.output[0]) + url = snakemake.params.url + + print(f"Downloading data from: {url}") + print(f"Output file: {datafile}") + + download_data(datafile, url) + + print(f"Download complete: {datafile}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py new file mode 100644 index 0000000..a076199 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/enrichr.py @@ -0,0 +1,54 @@ +"""Snakemake script for Step 10: Overrepresentation Analysis (Enrichr).""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import ( + run_overrepresentation_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint + + +def main(): + """Run Enrichr overrepresentation analysis for a cell type.""" + # ruff: noqa: F821 + de_results_file = Path(snakemake.input.de_results) + output_enr_up = Path(snakemake.output.enr_up) + output_enr_down = Path(snakemake.output.enr_down) + + # Get parameters + cell_type = snakemake.params.cell_type + gene_sets = snakemake.params.gene_sets + padj_threshold = snakemake.params.padj_threshold + n_top = snakemake.params.n_top + figure_dir = Path(snakemake.params.figure_dir) + + print(f"Running Enrichr for cell type: {cell_type}") + + # Create output directories + output_enr_up.parent.mkdir(parents=True, exist_ok=True) + figure_dir.mkdir(parents=True, exist_ok=True) + + # Load DE results + de_results = pd.read_parquet(de_results_file) + + # Run overrepresentation analysis + enr_up, enr_down = run_overrepresentation_pipeline( + de_results, + gene_sets=gene_sets, + padj_threshold=padj_threshold, + n_top=n_top, + figure_dir=figure_dir, + ) + + # Save results + save_checkpoint(enr_up, output_enr_up) + save_checkpoint(enr_down, output_enr_down) + print("Enrichr results saved:") + print(f" - enr_up: {output_enr_up}") + print(f" - enr_down: {output_enr_down}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py new file mode 100644 index 0000000..41a24bc --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/filter.py @@ -0,0 +1,53 @@ +"""Snakemake script for Step 2: Data Filtering.""" + +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import ( + run_filtering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import ( + load_lazy_anndata, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint + + +def main(): + """Load data and run filtering pipeline.""" + # ruff: noqa: F821 + input_file = Path(snakemake.input[0]) + output_file = Path(snakemake.output.checkpoint) + + # Get parameters + cutoff_percentile = snakemake.params.cutoff_percentile + min_cells_per_celltype = snakemake.params.min_cells_per_celltype + percent_donors = snakemake.params.percent_donors + figure_dir = ( + Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None + ) + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + if figure_dir: + figure_dir.mkdir(parents=True, exist_ok=True) + + print(f"Loading data from: {input_file}") + adata = load_lazy_anndata(input_file) + print(f"Loaded dataset: {adata}") + + print("Running filtering pipeline...") + adata = run_filtering_pipeline( + adata, + cutoff_percentile=cutoff_percentile, + min_cells_per_celltype=min_cells_per_celltype, + percent_donors=percent_donors, + figure_dir=figure_dir, + ) + print(f"Dataset after filtering: {adata}") + + # Save checkpoint + save_checkpoint(adata, output_file) + print(f"Saved checkpoint: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py new file mode 100644 index 0000000..2d956c0 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/gsea.py @@ -0,0 +1,48 @@ +"""Snakemake script for Step 9: Pathway Analysis (GSEA).""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import ( + run_gsea_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import save_checkpoint + + +def main(): + """Run GSEA pathway analysis for a cell type.""" + # ruff: noqa: F821 + de_results_file = Path(snakemake.input.de_results) + output_file = Path(snakemake.output.gsea_results) + + # Get parameters + cell_type = snakemake.params.cell_type + gene_sets = snakemake.params.gene_sets + n_top = snakemake.params.n_top + figure_dir = Path(snakemake.params.figure_dir) + + print(f"Running GSEA for cell type: {cell_type}") + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + figure_dir.mkdir(parents=True, exist_ok=True) + + # Load DE results + de_results = pd.read_parquet(de_results_file) + + # Run GSEA + gsea_results = run_gsea_pipeline( + de_results, + gene_sets=gene_sets, + n_top=n_top, + figure_dir=figure_dir, + ) + + # Save results + save_checkpoint(gsea_results, output_file) + print(f"GSEA results saved: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py new file mode 100644 index 0000000..5ff128b --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/prediction.py @@ -0,0 +1,79 @@ +"""Snakemake script for Step 11: Predictive Modeling.""" + +import json +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import ( + run_predictive_modeling_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def unsanitize_cell_type(sanitized: str, cell_types_file: Path) -> str: + """Convert sanitized cell type back to original name.""" + # ruff: noqa: F821 + with open(cell_types_file) as f: + data = json.load(f) + # Reverse lookup + for original, sanitized_name in data["sanitized_names"].items(): + if sanitized_name == sanitized: + return original + raise ValueError(f"Unknown sanitized cell type: {sanitized}") + + +def main(): + """Run predictive modeling for a cell type.""" + counts_df_file = Path(snakemake.input.counts_df) + pseudobulk_file = Path(snakemake.input.pseudobulk) + cell_types_file = Path(snakemake.input.cell_types) + output_file = Path(snakemake.output.prediction_results) + + # Get parameters + sanitized_cell_type = snakemake.params.cell_type + n_splits = snakemake.params.n_splits + figure_dir = Path(snakemake.params.figure_dir) + + # Get original cell type name + cell_type = unsanitize_cell_type(sanitized_cell_type, cell_types_file) + + print(f"Running predictive modeling for cell type: {cell_type}") + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + figure_dir.mkdir(parents=True, exist_ok=True) + + # Load counts + counts_df = pd.read_parquet(counts_df_file) + + # Load pseudobulk to get metadata + pb_adata = load_checkpoint(pseudobulk_file) + + # Get metadata for this cell type + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type].copy() + pb_adata_ct.obs["age"] = ( + pb_adata_ct.obs["development_stage"] + .str.extract(r"(\d+)-year-old")[0] + .astype(float) + ) + metadata = pb_adata_ct.obs.copy() + + # Run predictive modeling + prediction_results = run_predictive_modeling_pipeline( + counts_df, + metadata, + n_splits=n_splits, + figure_dir=figure_dir, + ) + + # Save results + save_checkpoint(prediction_results, output_file) + print(f"Prediction results saved: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py new file mode 100644 index 0000000..dfdee46 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/preprocess.py @@ -0,0 +1,48 @@ +"""Snakemake script for Step 4: Preprocessing.""" + +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import ( + run_preprocessing_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def main(): + """Run preprocessing pipeline.""" + # ruff: noqa: F821 + input_file = Path(snakemake.input[0]) + output_file = Path(snakemake.output[0]) + + # Get parameters + target_sum = snakemake.params.target_sum + n_top_genes = snakemake.params.n_top_genes + batch_key = snakemake.params.batch_key + + print(f"Loading data from: {input_file}") + adata = load_checkpoint(input_file) + print(f"Loaded dataset: {adata}") + + print("Running preprocessing pipeline...") + adata = run_preprocessing_pipeline( + adata, + target_sum=target_sum, + n_top_genes=n_top_genes, + batch_key=batch_key, + ) + + # Remove counts layer after preprocessing to save space + if "counts" in adata.layers: + del adata.layers["counts"] + print("Removed counts layer to save checkpoint space") + + # Save checkpoint + save_checkpoint(adata, output_file) + print(f"Saved checkpoint: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py new file mode 100644 index 0000000..d8a19bb --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/pseudobulk.py @@ -0,0 +1,117 @@ +"""Snakemake script for Step 7: Pseudobulking. + +This script creates the pseudobulk data AND outputs a JSON file listing +all valid cell types, which enables downstream dynamic rules. +""" +# ruff: noqa: F821 + +import json +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import ( + run_pseudobulk_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def sanitize_cell_type(cell_type: str) -> str: + """Sanitize cell type name for filesystem use.""" + return cell_type.replace(" ", "_").replace(",", "").replace("-", "_") + + +def main(): + """Run pseudobulking pipeline and output cell types JSON.""" + filtered_checkpoint = Path(snakemake.input.filtered_checkpoint) + qc_checkpoint = Path(snakemake.input.qc_checkpoint) + # Note: clustered_checkpoint is listed as input for dependency ordering + output_pseudobulk = Path(snakemake.output.pseudobulk) + output_cell_types = Path(snakemake.output.cell_types) + output_var_to_feature = Path(snakemake.output.var_to_feature) + + # Get parameters + group_col = snakemake.params.group_col + donor_col = snakemake.params.donor_col + metadata_cols = snakemake.params.metadata_cols + min_cells = snakemake.params.min_cells + min_samples_per_cell_type = snakemake.params.min_samples_per_cell_type + figure_dir = ( + Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None + ) + + # Create output directories + output_pseudobulk.parent.mkdir(parents=True, exist_ok=True) + if figure_dir: + figure_dir.mkdir(parents=True, exist_ok=True) + + # Load step 2 checkpoint to get var_to_feature mapping (has feature_name) + print(f"Loading filtered data for var_to_feature: {filtered_checkpoint}") + adata_filtered = load_checkpoint(filtered_checkpoint) + var_to_feature = dict( + zip(adata_filtered.var_names, adata_filtered.var["feature_name"]) + ) + print(f"Built var_to_feature mapping with {len(var_to_feature)} genes") + + # Load step 3 checkpoint for raw counts (after QC filtering) + print(f"Loading raw counts from: {qc_checkpoint}") + adata_raw = load_checkpoint(qc_checkpoint) + print(f"Loaded: {adata_raw}") + + # Run pseudobulking on raw counts + print("Running pseudobulking pipeline...") + pb_adata = run_pseudobulk_pipeline( + adata_raw, + group_col=group_col, + donor_col=donor_col, + metadata_cols=metadata_cols, + min_cells=min_cells, + figure_dir=figure_dir, + layer=None, # Use .X directly (raw counts) + ) + print(f"Pseudobulk data: {pb_adata}") + + # Save pseudobulk checkpoint + save_checkpoint(pb_adata, output_pseudobulk) + print(f"Saved pseudobulk checkpoint: {output_pseudobulk}") + + # Determine valid cell types (with sufficient samples) + all_cell_types = pb_adata.obs[group_col].unique().tolist() + cell_type_counts = pb_adata.obs[group_col].value_counts() + + valid_cell_types = [ + ct for ct in all_cell_types if cell_type_counts[ct] >= min_samples_per_cell_type + ] + skipped_cell_types = [ct for ct in all_cell_types if ct not in valid_cell_types] + + print(f"\nFound {len(all_cell_types)} cell types total") + print( + f"Valid cell types (>= {min_samples_per_cell_type} samples): {len(valid_cell_types)}" + ) + if skipped_cell_types: + print(f"Skipped cell types (insufficient samples): {skipped_cell_types}") + + # Write cell types JSON (enables dynamic rules) + cell_types_data = { + "all_cell_types": all_cell_types, + "valid_cell_types": valid_cell_types, + "skipped_cell_types": skipped_cell_types, + "cell_type_counts": {str(k): int(v) for k, v in cell_type_counts.items()}, + "min_samples_threshold": min_samples_per_cell_type, + # Include sanitized names for filesystem use + "sanitized_names": {ct: sanitize_cell_type(ct) for ct in valid_cell_types}, + } + + with open(output_cell_types, "w") as f: + json.dump(cell_types_data, f, indent=2) + print(f"Saved cell types JSON: {output_cell_types}") + + # Write var_to_feature mapping (needed for DE) + with open(output_var_to_feature, "w") as f: + json.dump(var_to_feature, f) + print(f"Saved var_to_feature mapping: {output_var_to_feature}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py new file mode 100644 index 0000000..abda90f --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/snakemake_workflow/scripts/qc.py @@ -0,0 +1,59 @@ +"""Snakemake script for Step 3: Quality Control.""" + +from pathlib import Path + +from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import ( + run_qc_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + load_checkpoint, + save_checkpoint, +) + + +def main(): + """Run quality control pipeline.""" + # ruff: noqa: F821 + input_file = Path(snakemake.input[0]) + output_file = Path(snakemake.output.checkpoint) + + # Get parameters + min_genes = snakemake.params.min_genes + max_genes = snakemake.params.max_genes + min_counts = snakemake.params.min_counts + max_counts = snakemake.params.max_counts + max_hb_pct = snakemake.params.max_hb_pct + expected_doublet_rate = snakemake.params.expected_doublet_rate + figure_dir = ( + Path(snakemake.params.figure_dir) if snakemake.params.figure_dir else None + ) + + # Create output directories + output_file.parent.mkdir(parents=True, exist_ok=True) + if figure_dir: + figure_dir.mkdir(parents=True, exist_ok=True) + + print(f"Loading data from: {input_file}") + adata = load_checkpoint(input_file) + print(f"Loaded dataset: {adata}") + + print("Running QC pipeline...") + adata = run_qc_pipeline( + adata, + min_genes=min_genes, + max_genes=max_genes, + min_counts=min_counts, + max_counts=max_counts, + max_hb_pct=max_hb_pct, + expected_doublet_rate=expected_doublet_rate, + figure_dir=figure_dir, + ) + print(f"Dataset after QC: {adata}") + + # Save checkpoint + save_checkpoint(adata, output_file) + print(f"Saved checkpoint: {output_file}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/__init__.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py new file mode 100644 index 0000000..08459ba --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/checkpoint.py @@ -0,0 +1,426 @@ +"""Checkpoint utilities for stateless workflow execution. + +Provides functions to save and load intermediate results, enabling +workflow resumption from any step. +""" + +from __future__ import annotations + +import hashlib +import json +import pickle +from collections.abc import Callable +from pathlib import Path +from typing import TYPE_CHECKING, Any + +import anndata as ad +import pandas as pd + +if TYPE_CHECKING: + from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import ( + ExecutionLog, + ) + + +def bids_checkpoint_name( + dataset_name: str, + step_number: int, + description: str, + extension: str = "h5ad", +) -> str: + """Generate a BIDS-compliant checkpoint filename. + + Parameters + ---------- + dataset_name : str + Name of the dataset (e.g., "OneK1K") + step_number : int + Step number in the workflow + description : str + Description of the checkpoint content (e.g., "filtered", "qc", "preprocessed") + extension : str + File extension without the dot (e.g., "h5ad", "pkl", "parquet") + + Returns + ------- + str + BIDS-formatted filename like "dataset-OneK1K_step-02_desc-filtered.h5ad" + """ + return f"dataset-{dataset_name}_step-{step_number:02d}_desc-{description}.{extension}" + + +def parse_bids_checkpoint_name(filename: str) -> dict[str, str | int]: + """Parse a BIDS-formatted checkpoint filename. + + Parameters + ---------- + filename : str + BIDS-formatted filename + + Returns + ------- + dict + Dictionary with keys: dataset, step_number, description, extension + """ + import re + + pattern = r"dataset-([^_]+)_step-(\d+)_desc-([^.]+)\.(.+)" + match = re.match(pattern, filename) + if match: + return { + "dataset": match.group(1), + "step_number": int(match.group(2)), + "description": match.group(3), + "extension": match.group(4), + } + return {} + + +def get_file_type(filepath: Path) -> str: + """Determine file type from extension. + + Parameters + ---------- + filepath : Path + Path to the file + + Returns + ------- + str + File type identifier: 'h5ad', 'parquet', or 'pickle' + """ + suffix = filepath.suffix.lower() + if suffix == ".h5ad": + return "h5ad" + elif suffix == ".parquet": + return "parquet" + else: + return "pickle" + + +def save_checkpoint(data: Any, filepath: Path) -> None: + """Save data to a checkpoint file. + + Automatically selects serialization format based on file extension: + - .h5ad: AnnData objects + - .parquet: pandas DataFrames + - .pkl: Any picklable object + + Parameters + ---------- + data : Any + Data to save + filepath : Path + Path to save the checkpoint + """ + filepath.parent.mkdir(parents=True, exist_ok=True) + file_type = get_file_type(filepath) + + if file_type == "h5ad": + if not isinstance(data, ad.AnnData): + raise TypeError(f"Expected AnnData for .h5ad file, got {type(data)}") + data.write(filepath, compression="gzip") + elif file_type == "parquet": + if not isinstance(data, pd.DataFrame): + raise TypeError(f"Expected DataFrame for .parquet file, got {type(data)}") + data.to_parquet(filepath) + else: + with open(filepath, "wb") as f: + pickle.dump(data, f) + + +def load_checkpoint(filepath: Path) -> Any: + """Load data from a checkpoint file. + + Automatically selects deserialization format based on file extension. + + Parameters + ---------- + filepath : Path + Path to the checkpoint file + + Returns + ------- + Any + Loaded data + """ + file_type = get_file_type(filepath) + + if file_type == "h5ad": + return ad.read_h5ad(filepath) + elif file_type == "parquet": + return pd.read_parquet(filepath) + else: + with open(filepath, "rb") as f: + return pickle.load(f) + + +def hash_parameters(**kwargs) -> str: + """Create a hash of parameters for cache invalidation. + + Parameters + ---------- + **kwargs + Parameters to hash + + Returns + ------- + str + 8-character hash string + """ + param_str = json.dumps(kwargs, sort_keys=True, default=str) + return hashlib.md5(param_str.encode()).hexdigest()[:8] + + +def run_with_checkpoint( + step_name: str, + checkpoint_file: Path, + func: Callable, + *args, + force: bool = False, + skip_save: bool = False, + execution_log: ExecutionLog | None = None, + step_number: int | None = None, + log_parameters: dict[str, Any] | None = None, + **kwargs, +) -> Any: + """Execute a function with checkpoint caching. + + If the checkpoint file exists and force=False, loads and returns + the cached result. Otherwise, executes the function, saves the + result (unless skip_save=True), and returns it. + + Parameters + ---------- + step_name : str + Human-readable name for logging + checkpoint_file : Path + Path to save/load the checkpoint + func : Callable + Function to execute + *args + Positional arguments for func + force : bool + If True, ignore existing checkpoint and re-run + skip_save : bool + If True, don't save checkpoint after running (still loads if exists) + execution_log : ExecutionLog, optional + Execution log to record step details + step_number : int, optional + Step number for logging + log_parameters : dict, optional + Parameters to record in the execution log + **kwargs + Keyword arguments for func + + Returns + ------- + Any + Result of func(*args, **kwargs) or cached result + """ + # Start logging if provided + step_record = None + if execution_log is not None and step_number is not None: + step_record = execution_log.add_step( + step_number=step_number, + step_name=step_name, + parameters=log_parameters, + checkpoint_file=str(checkpoint_file) if not skip_save else None, + ) + + from_cache = False + error_message = None + save_succeeded = False + + try: + if checkpoint_file.exists() and not force: + print(f"[{step_name}] Loading from checkpoint: {checkpoint_file.name}") + from_cache = True + result = load_checkpoint(checkpoint_file) + save_succeeded = True # Loading counts as success + else: + print(f"[{step_name}] Executing...") + result = func(*args, **kwargs) + + if not skip_save: + print(f"[{step_name}] Saving checkpoint: {checkpoint_file.name}") + save_checkpoint(result, checkpoint_file) + save_succeeded = True # Mark success after execution (and optional save) + + return result + + except BaseException as e: + # Catch all exceptions including KeyboardInterrupt, SystemExit + if not save_succeeded: + error_message = f"{type(e).__name__}: {e}" + raise + + finally: + if step_record is not None: + execution_log.complete_step( + step_record, from_cache=from_cache, error_message=error_message + ) + + +def run_with_checkpoint_multi( + step_name: str, + checkpoint_files: dict[str, Path], + func: Callable, + *args, + force: bool = False, + skip_save: bool = False, + execution_log: ExecutionLog | None = None, + step_number: int | None = None, + log_parameters: dict[str, Any] | None = None, + **kwargs, +) -> dict[str, Any]: + """Execute a function that returns multiple outputs with checkpoint caching. + + The function must return a dict with keys matching checkpoint_files. + + Parameters + ---------- + step_name : str + Human-readable name for logging + checkpoint_files : dict[str, Path] + Mapping of output names to checkpoint file paths + func : Callable + Function to execute (must return dict) + *args + Positional arguments for func + force : bool + If True, ignore existing checkpoints and re-run + skip_save : bool + If True, don't save checkpoints after running (still loads if exists) + execution_log : ExecutionLog, optional + Execution log to record step details + step_number : int, optional + Step number for logging + log_parameters : dict, optional + Parameters to record in the execution log + **kwargs + Keyword arguments for func + + Returns + ------- + dict[str, Any] + Dict of results keyed by output names + """ + # Start logging if provided + step_record = None + if execution_log is not None and step_number is not None: + checkpoint_files_str = {k: str(v) for k, v in checkpoint_files.items()} + step_record = execution_log.add_step( + step_number=step_number, + step_name=step_name, + parameters=log_parameters, + checkpoint_file=str(checkpoint_files_str) if not skip_save else None, + ) + + from_cache = False + error_message = None + save_succeeded = False + + try: + all_exist = all(fp.exists() for fp in checkpoint_files.values()) + + if all_exist and not force: + print(f"[{step_name}] Loading from checkpoints...") + from_cache = True + result = {key: load_checkpoint(fp) for key, fp in checkpoint_files.items()} + save_succeeded = True # Loading counts as success + return result + + print(f"[{step_name}] Executing...") + results = func(*args, **kwargs) + + if not isinstance(results, dict): + raise TypeError( + f"Function must return dict for multi-checkpoint, got {type(results)}" + ) + + if not skip_save: + print(f"[{step_name}] Saving checkpoints...") + for key, filepath in checkpoint_files.items(): + if key not in results: + raise KeyError(f"Function result missing key: {key}") + save_checkpoint(results[key], filepath) + + save_succeeded = True # Mark success after execution (and optional saves) + return results + + except BaseException as e: + # Catch all exceptions including KeyboardInterrupt, SystemExit + if not save_succeeded: + error_message = f"{type(e).__name__}: {e}" + raise + + finally: + if step_record is not None: + execution_log.complete_step( + step_record, from_cache=from_cache, error_message=error_message + ) + + +def clear_checkpoints(checkpoint_dir: Path, pattern: str = "step*.") -> list[Path]: + """Remove checkpoint files matching a pattern. + + Parameters + ---------- + checkpoint_dir : Path + Directory containing checkpoints + pattern : str + Glob pattern for files to remove + + Returns + ------- + list[Path] + List of removed files + """ + removed = [] + for filepath in checkpoint_dir.glob(pattern + "*"): + filepath.unlink() + removed.append(filepath) + print(f"Removed: {filepath.name}") + return removed + + +def clear_checkpoints_from_step(checkpoint_dir: Path, from_step: int) -> list[Path]: + """Remove checkpoints from a specific step onwards. + + Useful for invalidating downstream results when re-running an upstream step. + Supports both legacy naming (step02_*) and BIDS naming (dataset-*_step-02_*). + + Parameters + ---------- + checkpoint_dir : Path + Directory containing checkpoints + from_step : int + Step number to start clearing from (inclusive) + + Returns + ------- + list[Path] + List of removed files + """ + removed = [] + for filepath in checkpoint_dir.glob("*"): + step_num = None + # Try BIDS format first + parsed = parse_bids_checkpoint_name(filepath.name) + if parsed: + step_num = parsed["step_number"] + else: + # Try legacy format (step02_*) + try: + if filepath.name.startswith("step"): + step_num = int(filepath.name.split("_")[0].replace("step", "")) + except (ValueError, IndexError): + pass + + if step_num is not None and step_num >= from_step: + filepath.unlink() + removed.append(filepath) + print(f"Removed: {filepath.name}") + + return removed diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py new file mode 100644 index 0000000..b496d96 --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/execution_log.py @@ -0,0 +1,202 @@ +"""Execution logging for stateless workflow. + +Tracks execution details including timing, parameters, and status for each step. +""" + +import json +from dataclasses import asdict, dataclass, field +from datetime import datetime +from pathlib import Path +from typing import Any + + +@dataclass +class StepRecord: + """Record of a single workflow step execution.""" + + step_number: int + step_name: str + start_time: str + end_time: str | None = None + duration_seconds: float | None = None + parameters: dict[str, Any] = field(default_factory=dict) + from_cache: bool = False + status: str = "running" + checkpoint_file: str | None = None + error_message: str | None = None + + +@dataclass +class ExecutionLog: + """Complete execution log for a workflow run.""" + + workflow_name: str + run_id: str + start_time: str + end_time: str | None = None + total_duration_seconds: float | None = None + status: str = "running" + steps: list[StepRecord] = field(default_factory=list) + workflow_parameters: dict[str, Any] = field(default_factory=dict) + + def add_step( + self, + step_number: int, + step_name: str, + parameters: dict[str, Any] | None = None, + checkpoint_file: str | None = None, + ) -> StepRecord: + """Add a new step record and return it.""" + record = StepRecord( + step_number=step_number, + step_name=step_name, + start_time=datetime.now().isoformat(), + parameters=parameters or {}, + checkpoint_file=checkpoint_file, + ) + self.steps.append(record) + return record + + def complete_step( + self, + record: StepRecord, + from_cache: bool = False, + error_message: str | None = None, + ) -> None: + """Mark a step as completed.""" + record.end_time = datetime.now().isoformat() + start = datetime.fromisoformat(record.start_time) + end = datetime.fromisoformat(record.end_time) + record.duration_seconds = (end - start).total_seconds() + record.from_cache = from_cache + record.status = "completed" if error_message is None else "failed" + record.error_message = error_message + + def complete(self, error_message: str | None = None) -> None: + """Mark the entire workflow as completed.""" + self.end_time = datetime.now().isoformat() + start = datetime.fromisoformat(self.start_time) + end = datetime.fromisoformat(self.end_time) + self.total_duration_seconds = (end - start).total_seconds() + self.status = "completed" if error_message is None else "failed" + + def to_dict(self) -> dict: + """Convert to dictionary for JSON serialization.""" + return { + "workflow_name": self.workflow_name, + "run_id": self.run_id, + "start_time": self.start_time, + "end_time": self.end_time, + "total_duration_seconds": self.total_duration_seconds, + "status": self.status, + "workflow_parameters": self.workflow_parameters, + "steps": [asdict(step) for step in self.steps], + } + + def save(self, log_dir: Path) -> Path: + """Save execution log to a date-stamped JSON file. + + Parameters + ---------- + log_dir : Path + Directory to save the log file + + Returns + ------- + Path + Path to the saved log file + """ + log_dir.mkdir(parents=True, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + log_file = log_dir / f"execution_log_{timestamp}.json" + + with open(log_file, "w") as f: + json.dump(self.to_dict(), f, indent=2, default=str) + + return log_file + + def print_summary(self) -> None: + """Print a summary of the execution.""" + print("\n" + "=" * 60) + print("EXECUTION SUMMARY") + print("=" * 60) + print(f"Workflow: {self.workflow_name}") + print(f"Run ID: {self.run_id}") + print(f"Status: {self.status}") + if self.total_duration_seconds is not None: + print(f"Total Duration: {self.total_duration_seconds:.1f} seconds") + + print("\nStep Details:") + print("-" * 60) + for step in self.steps: + cache_indicator = " [cached]" if step.from_cache else "" + duration = ( + f"{step.duration_seconds:.1f}s" + if step.duration_seconds is not None + else "N/A" + ) + status_icon = "✓" if step.status == "completed" else "✗" + print( + f" {status_icon} Step {step.step_number}: {step.step_name:<25} " + f"{duration:>8}{cache_indicator}" + ) + print("-" * 60) + + +def create_execution_log( + workflow_name: str, + workflow_parameters: dict[str, Any] | None = None, +) -> ExecutionLog: + """Create a new execution log. + + Parameters + ---------- + workflow_name : str + Name of the workflow + workflow_parameters : dict, optional + Parameters passed to the workflow + + Returns + ------- + ExecutionLog + New execution log instance + """ + run_id = datetime.now().strftime("%Y%m%d_%H%M%S") + return ExecutionLog( + workflow_name=workflow_name, + run_id=run_id, + start_time=datetime.now().isoformat(), + workflow_parameters=workflow_parameters or {}, + ) + + +def serialize_parameters(**kwargs) -> dict[str, Any]: + """Convert parameters to JSON-serializable format. + + Handles common non-serializable types like Path objects. + + Parameters + ---------- + **kwargs + Parameters to serialize + + Returns + ------- + dict + Serialized parameters + """ + result = {} + for key, value in kwargs.items(): + if isinstance(value, Path): + result[key] = str(value) + elif hasattr(value, "tolist"): # numpy arrays + result[key] = value.tolist() + elif hasattr(value, "__dict__"): # objects + result[key] = str(type(value).__name__) + else: + try: + json.dumps(value) + result[key] = value + except (TypeError, ValueError): + result[key] = str(value) + return result diff --git a/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py new file mode 100644 index 0000000..f43384a --- /dev/null +++ b/src/BetterCodeBetterScience/rnaseq/stateless_workflow/run_workflow.py @@ -0,0 +1,722 @@ +"""Stateless workflow runner for scRNA-seq immune aging analysis. + +This script orchestrates the complete analysis workflow using checkpointing +to enable stateless execution and resumption from any step. +""" + +import os +from pathlib import Path + +from dotenv import load_dotenv + +from BetterCodeBetterScience.rnaseq.modular_workflow.clustering import ( + run_clustering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_filtering import ( + run_filtering_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.data_loading import ( + download_data, + load_lazy_anndata, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.differential_expression import ( + run_differential_expression_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.dimensionality_reduction import ( + run_dimensionality_reduction_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.overrepresentation_analysis import ( + run_overrepresentation_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pathway_analysis import ( + run_gsea_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.predictive_modeling import ( + run_predictive_modeling_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.preprocessing import ( + run_preprocessing_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.pseudobulk import ( + run_pseudobulk_pipeline, +) +from BetterCodeBetterScience.rnaseq.modular_workflow.quality_control import ( + run_qc_pipeline, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.checkpoint import ( + bids_checkpoint_name, + clear_checkpoints_from_step, + load_checkpoint, + parse_bids_checkpoint_name, + run_with_checkpoint, + run_with_checkpoint_multi, +) +from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import ( + ExecutionLog, + create_execution_log, + serialize_parameters, +) + + +def _run_differential_expression_as_dict( + pb_adata, + cell_type, + design_factors, + var_to_feature, + n_cpus, +): + """Wrapper to return DE results as dict for checkpointing.""" + stat_res, de_results, counts_df = run_differential_expression_pipeline( + pb_adata, + cell_type=cell_type, + design_factors=design_factors, + var_to_feature=var_to_feature, + n_cpus=n_cpus, + ) + return { + "stat_res": stat_res, + "de_results": de_results, + "counts_df": counts_df, + } + + +def _run_overrepresentation_as_dict( + de_results, + gene_sets, + padj_threshold, + n_top, + figure_dir, +): + """Wrapper to return enrichment results as dict for checkpointing.""" + enr_up, enr_down = run_overrepresentation_pipeline( + de_results, + gene_sets=gene_sets, + padj_threshold=padj_threshold, + n_top=n_top, + figure_dir=figure_dir, + ) + return { + "enr_up": enr_up, + "enr_down": enr_down, + } + + +DEFAULT_CHECKPOINT_STEPS = frozenset({2, 3, 5, 8, 9, 10, 11}) + + +def run_stateless_workflow( + datadir: Path, + dataset_name: str = "OneK1K", + url: str = "https://datasets.cellxgene.cziscience.com/a3f5651f-cd1a-4d26-8165-74964b79b4f2.h5ad", + cell_type_for_de: str = "central memory CD4-positive, alpha-beta T cell", + force_from_step: int | None = None, + checkpoint_steps: set[int] | None = None, +) -> dict: + """Run the complete immune aging scRNA-seq analysis workflow with checkpointing. + + Only specified steps save checkpoints. On subsequent runs, steps with + existing checkpoints are skipped by loading from checkpoints. + + Parameters + ---------- + datadir : Path + Base directory for data files + dataset_name : str + Name of the dataset + url : str + URL to download data from + cell_type_for_de : str + Cell type to use for differential expression + force_from_step : int, optional + If provided, clears checkpoints from this step onwards and re-runs + checkpoint_steps : set[int], optional + Set of step numbers that should save checkpoints. Defaults to {2, 3, 5, 8, 9, 10, 11}. + Step 3 is always required (provides raw counts for pseudobulking). + + Returns + ------- + dict + Dictionary containing all results + """ + # Setup checkpoint steps + if checkpoint_steps is None: + checkpoint_steps = set(DEFAULT_CHECKPOINT_STEPS) + else: + checkpoint_steps = set(checkpoint_steps) + + # Step 3 is required for pseudobulking (provides raw counts) + if 3 not in checkpoint_steps: + print("Warning: Step 3 is required for pseudobulking. Adding to checkpoint_steps.") + checkpoint_steps.add(3) + + print(f"Checkpointing enabled for steps: {sorted(checkpoint_steps)}") + + # Setup directories + figure_dir = datadir / "workflow/figures" + figure_dir.mkdir(parents=True, exist_ok=True) + + checkpoint_dir = datadir / "workflow/checkpoints" + checkpoint_dir.mkdir(parents=True, exist_ok=True) + + log_dir = datadir / "workflow/logs" + log_dir.mkdir(parents=True, exist_ok=True) + + # Clear downstream checkpoints if forcing re-run + if force_from_step is not None: + print(f"\nClearing checkpoints from step {force_from_step} onwards...") + clear_checkpoints_from_step(checkpoint_dir, force_from_step) + + # Initialize execution log + execution_log = create_execution_log( + workflow_name="immune_aging_scrnaseq", + workflow_parameters=serialize_parameters( + datadir=datadir, + dataset_name=dataset_name, + url=url, + cell_type_for_de=cell_type_for_de, + force_from_step=force_from_step, + checkpoint_steps=sorted(checkpoint_steps), + ), + ) + + results = {} + error_occurred = None + + try: + # ===================================================================== + # STEP 1: Data Download + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 1: DATA DOWNLOAD") + print("=" * 60) + + datafile = datadir / f"dataset-{dataset_name}_subset-immune_raw.h5ad" + + # Log step 1 manually (no checkpoint wrapper for download) + step1_record = execution_log.add_step( + step_number=1, + step_name="data_download", + parameters=serialize_parameters(datafile=datafile, url=url), + ) + download_data(datafile, url) + execution_log.complete_step( + step1_record, from_cache=datafile.exists(), error_message=None + ) + + # ===================================================================== + # STEP 2: Data Filtering + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 2: DATA FILTERING") + print("=" * 60) + + step2_params = { + "cutoff_percentile": 1.0, + "min_cells_per_celltype": 10, + "percent_donors": 0.95, + } + + def _load_and_filter(): + adata = load_lazy_anndata(datafile) + print(f"Loaded dataset: {adata}") + return run_filtering_pipeline( + adata, + cutoff_percentile=step2_params["cutoff_percentile"], + min_cells_per_celltype=step2_params["min_cells_per_celltype"], + percent_donors=step2_params["percent_donors"], + figure_dir=figure_dir, + ) + + adata = run_with_checkpoint( + "filtering", + checkpoint_dir / bids_checkpoint_name(dataset_name, 2, "filtered"), + _load_and_filter, + skip_save=2 not in checkpoint_steps, + execution_log=execution_log, + step_number=2, + log_parameters=step2_params, + ) + print(f"Dataset after filtering: {adata}") + + # Build var_to_feature mapping + var_to_feature = dict(zip(adata.var_names, adata.var["feature_name"])) + + # ===================================================================== + # STEP 3: Quality Control + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 3: QUALITY CONTROL") + print("=" * 60) + + step3_params = { + "min_genes": 200, + "max_genes": 6000, + "min_counts": 500, + "max_counts": 30000, + "max_hb_pct": 5.0, + "expected_doublet_rate": 0.06, + } + + adata = run_with_checkpoint( + "quality_control", + checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc"), + run_qc_pipeline, + adata, + min_genes=step3_params["min_genes"], + max_genes=step3_params["max_genes"], + min_counts=step3_params["min_counts"], + max_counts=step3_params["max_counts"], + max_hb_pct=step3_params["max_hb_pct"], + expected_doublet_rate=step3_params["expected_doublet_rate"], + figure_dir=figure_dir, + skip_save=3 not in checkpoint_steps, + execution_log=execution_log, + step_number=3, + log_parameters=step3_params, + ) + print(f"Dataset after QC: {adata}") + + # ===================================================================== + # STEP 4: Preprocessing + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 4: PREPROCESSING") + print("=" * 60) + + step4_params = { + "target_sum": 1e4, + "n_top_genes": 3000, + "batch_key": "donor_id", + } + + adata = run_with_checkpoint( + "preprocessing", + checkpoint_dir / bids_checkpoint_name(dataset_name, 4, "preprocessed"), + run_preprocessing_pipeline, + adata, + target_sum=step4_params["target_sum"], + n_top_genes=step4_params["n_top_genes"], + batch_key=step4_params["batch_key"], + skip_save=4 not in checkpoint_steps, + execution_log=execution_log, + step_number=4, + log_parameters=step4_params, + ) + + # Remove counts layer after preprocessing to save space in subsequent checkpoints + # (counts layer was needed for HVG selection but is no longer needed) + if "counts" in adata.layers: + del adata.layers["counts"] + print("Removed counts layer to save checkpoint space") + + # ===================================================================== + # STEP 5: Dimensionality Reduction + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 5: DIMENSIONALITY REDUCTION") + print("=" * 60) + + step5_params = { + "batch_key": "donor_id", + "n_neighbors": 30, + "n_pcs": 40, + } + + adata = run_with_checkpoint( + "dimensionality_reduction", + checkpoint_dir / bids_checkpoint_name(dataset_name, 5, "dimreduced"), + run_dimensionality_reduction_pipeline, + adata, + batch_key=step5_params["batch_key"], + n_neighbors=step5_params["n_neighbors"], + n_pcs=step5_params["n_pcs"], + figure_dir=figure_dir, + skip_save=5 not in checkpoint_steps, + execution_log=execution_log, + step_number=5, + log_parameters=step5_params, + ) + + # ===================================================================== + # STEP 6: Clustering + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 6: CLUSTERING") + print("=" * 60) + + step6_params = {"resolution": 1.0} + + adata = run_with_checkpoint( + "clustering", + checkpoint_dir / bids_checkpoint_name(dataset_name, 6, "clustered"), + run_clustering_pipeline, + adata, + resolution=step6_params["resolution"], + figure_dir=figure_dir, + skip_save=6 not in checkpoint_steps, + execution_log=execution_log, + step_number=6, + log_parameters=step6_params, + ) + + results["adata"] = adata + + # ===================================================================== + # STEP 7: Pseudobulking + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 7: PSEUDOBULKING") + print("=" * 60) + + # Load step 3 checkpoint to get raw counts (stored in .X) + # This avoids redundant storage of counts in layers["counts"] for steps 4-6 + step3_checkpoint = checkpoint_dir / bids_checkpoint_name(dataset_name, 3, "qc") + adata_raw_counts = load_checkpoint(step3_checkpoint) + print(f"Loaded raw counts from step 3 checkpoint: {adata_raw_counts.shape}") + + step7_params = { + "group_col": "cell_type", + "donor_col": "donor_id", + "metadata_cols": ["development_stage", "sex"], + "min_cells": 10, + } + + pb_adata = run_with_checkpoint( + "pseudobulking", + checkpoint_dir / bids_checkpoint_name(dataset_name, 7, "pseudobulk"), + run_pseudobulk_pipeline, + adata_raw_counts, # Use step 3 data with raw counts in .X + group_col=step7_params["group_col"], + donor_col=step7_params["donor_col"], + metadata_cols=step7_params["metadata_cols"], + min_cells=step7_params["min_cells"], + figure_dir=figure_dir, + layer=None, # Use .X directly (raw counts) + skip_save=7 not in checkpoint_steps, + execution_log=execution_log, + step_number=7, + log_parameters=step7_params, + ) + + results["pb_adata"] = pb_adata + + # ===================================================================== + # STEP 8: Differential Expression + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 8: DIFFERENTIAL EXPRESSION") + print("=" * 60) + + step8_params = { + "cell_type": cell_type_for_de, + "design_factors": ["age_scaled", "sex"], + "n_cpus": 8, + } + + de_outputs = run_with_checkpoint_multi( + "differential_expression", + { + "stat_res": checkpoint_dir + / bids_checkpoint_name(dataset_name, 8, "statres", "pkl"), + "de_results": checkpoint_dir + / bids_checkpoint_name(dataset_name, 8, "deresults", "parquet"), + "counts_df": checkpoint_dir + / bids_checkpoint_name(dataset_name, 8, "counts", "parquet"), + }, + _run_differential_expression_as_dict, + pb_adata, + cell_type=step8_params["cell_type"], + design_factors=step8_params["design_factors"], + var_to_feature=var_to_feature, + n_cpus=step8_params["n_cpus"], + skip_save=8 not in checkpoint_steps, + execution_log=execution_log, + step_number=8, + log_parameters=step8_params, + ) + + de_results = de_outputs["de_results"] + counts_df_ct = de_outputs["counts_df"] + + results["stat_res"] = de_outputs["stat_res"] + results["de_results"] = de_results + results["counts_df"] = counts_df_ct + + # ===================================================================== + # STEP 9: Pathway Analysis (GSEA) + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 9: PATHWAY ANALYSIS (GSEA)") + print("=" * 60) + + step9_params = { + "gene_sets": ["MSigDB_Hallmark_2020"], + "n_top": 10, + } + + gsea_results = run_with_checkpoint( + "gsea", + checkpoint_dir / bids_checkpoint_name(dataset_name, 9, "gsea", "pkl"), + run_gsea_pipeline, + de_results, + gene_sets=step9_params["gene_sets"], + n_top=step9_params["n_top"], + figure_dir=figure_dir, + skip_save=9 not in checkpoint_steps, + execution_log=execution_log, + step_number=9, + log_parameters=step9_params, + ) + + results["gsea"] = gsea_results + + # ===================================================================== + # STEP 10: Overrepresentation Analysis (Enrichr) + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 10: OVERREPRESENTATION ANALYSIS (Enrichr)") + print("=" * 60) + + step10_params = { + "gene_sets": ["MSigDB_Hallmark_2020"], + "padj_threshold": 0.05, + "n_top": 10, + } + + enr_outputs = run_with_checkpoint_multi( + "overrepresentation", + { + "enr_up": checkpoint_dir + / bids_checkpoint_name(dataset_name, 10, "enrup", "pkl"), + "enr_down": checkpoint_dir + / bids_checkpoint_name(dataset_name, 10, "enrdown", "pkl"), + }, + _run_overrepresentation_as_dict, + de_results, + gene_sets=step10_params["gene_sets"], + padj_threshold=step10_params["padj_threshold"], + n_top=step10_params["n_top"], + figure_dir=figure_dir, + skip_save=10 not in checkpoint_steps, + execution_log=execution_log, + step_number=10, + log_parameters=step10_params, + ) + + results["enrichr_up"] = enr_outputs["enr_up"] + results["enrichr_down"] = enr_outputs["enr_down"] + + # ===================================================================== + # STEP 11: Predictive Modeling + # ===================================================================== + print("\n" + "=" * 60) + print("STEP 11: PREDICTIVE MODELING") + print("=" * 60) + + # Get metadata for the cell type + pb_adata_ct = pb_adata[pb_adata.obs["cell_type"] == cell_type_for_de].copy() + pb_adata_ct.obs["age"] = ( + pb_adata_ct.obs["development_stage"] + .str.extract(r"(\d+)-year-old")[0] + .astype(float) + ) + metadata_ct = pb_adata_ct.obs.copy() + + step11_params = {"n_splits": 5} + + prediction_results = run_with_checkpoint( + "predictive_modeling", + checkpoint_dir + / bids_checkpoint_name(dataset_name, 11, "prediction", "pkl"), + run_predictive_modeling_pipeline, + counts_df_ct, + metadata_ct, + n_splits=step11_params["n_splits"], + figure_dir=figure_dir, + skip_save=11 not in checkpoint_steps, + execution_log=execution_log, + step_number=11, + log_parameters=step11_params, + ) + + results["prediction"] = prediction_results + + except Exception as e: + error_occurred = str(e) + raise + + finally: + # Complete and save execution log + execution_log.complete(error_message=error_occurred) + log_file = execution_log.save(log_dir) + execution_log.print_summary() + print(f"\nExecution log saved to: {log_file}") + + print("\n" + "=" * 60) + print("WORKFLOW COMPLETE") + print("=" * 60) + print(f"Figures saved to: {figure_dir}") + print(f"Checkpoints saved to: {checkpoint_dir}") + + return results + + +def list_checkpoints(datadir: Path) -> list[tuple[str, Path]]: + """List all checkpoint files in the workflow directory. + + Supports both BIDS naming (dataset-*_step-*_desc-*) and legacy naming (step*_*). + + Parameters + ---------- + datadir : Path + Base directory for data files + + Returns + ------- + list[tuple[str, Path]] + List of (step_name, file_path) tuples, sorted by step number + """ + checkpoint_dir = datadir / "workflow/checkpoints" + if not checkpoint_dir.exists(): + return [] + + checkpoints = [] + for filepath in checkpoint_dir.glob("*"): + if filepath.is_dir(): + continue + + # Try BIDS format first + parsed = parse_bids_checkpoint_name(filepath.name) + if parsed: + step_num = parsed["step_number"] + step_name = parsed["description"] + checkpoints.append((step_num, step_name, filepath)) + else: + # Try legacy format (step02_*) + if filepath.name.startswith("step"): + try: + parts = filepath.stem.split("_", 1) + step_num = int(parts[0].replace("step", "")) + step_name = parts[1] if len(parts) > 1 else filepath.stem + checkpoints.append((step_num, step_name, filepath)) + except (ValueError, IndexError): + continue + + # Sort by step number and return as (step_name, filepath) tuples + checkpoints.sort(key=lambda x: x[0]) + return [(step_name, filepath) for _, step_name, filepath in checkpoints] + + +def print_checkpoint_status(datadir: Path) -> None: + """Print the status of all workflow checkpoints. + + Parameters + ---------- + datadir : Path + Base directory for data files + """ + checkpoints = list_checkpoints(datadir) + + if not checkpoints: + print("No checkpoints found.") + return + + print("\nCheckpoint Status:") + print("-" * 50) + for step_name, filepath in checkpoints: + size_mb = filepath.stat().st_size / (1024 * 1024) + print(f" {step_name:<30} ({size_mb:.1f} MB)") + print("-" * 50) + + +def list_execution_logs(datadir: Path) -> list[Path]: + """List all execution log files. + + Parameters + ---------- + datadir : Path + Base directory for data files + + Returns + ------- + list[Path] + List of log file paths, sorted by date (newest first) + """ + log_dir = datadir / "workflow/logs" + if not log_dir.exists(): + return [] + + return sorted(log_dir.glob("execution_log_*.json"), reverse=True) + + +def load_execution_log(log_file: Path) -> ExecutionLog: + """Load an execution log from a JSON file. + + Parameters + ---------- + log_file : Path + Path to the log file + + Returns + ------- + ExecutionLog + Loaded execution log + """ + import json + + from BetterCodeBetterScience.rnaseq.stateless_workflow.execution_log import ( + StepRecord, + ) + + with open(log_file) as f: + data = json.load(f) + + log = ExecutionLog( + workflow_name=data["workflow_name"], + run_id=data["run_id"], + start_time=data["start_time"], + end_time=data.get("end_time"), + total_duration_seconds=data.get("total_duration_seconds"), + status=data.get("status", "unknown"), + workflow_parameters=data.get("workflow_parameters", {}), + ) + + for step_data in data.get("steps", []): + step = StepRecord( + step_number=step_data["step_number"], + step_name=step_data["step_name"], + start_time=step_data["start_time"], + end_time=step_data.get("end_time"), + duration_seconds=step_data.get("duration_seconds"), + parameters=step_data.get("parameters", {}), + from_cache=step_data.get("from_cache", False), + status=step_data.get("status", "unknown"), + checkpoint_file=step_data.get("checkpoint_file"), + error_message=step_data.get("error_message"), + ) + log.steps.append(step) + + return log + + +if __name__ == "__main__": + load_dotenv() + + datadir_env = os.getenv("DATADIR") + if datadir_env is None: + raise ValueError("DATADIR environment variable not set") + + datadir = Path(datadir_env) / "immune_aging" + + # Print current checkpoint status + print_checkpoint_status(datadir) + + # Show recent execution logs + logs = list_execution_logs(datadir) + if logs: + print(f"\nRecent execution logs: {len(logs)} found") + for log_path in logs[:3]: + print(f" {log_path.name}") + + # Run the workflow (will resume from last checkpoint) + results = run_stateless_workflow(datadir) diff --git a/src/BetterCodeBetterScience/simple_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/simple_workflow/correlation.py b/src/BetterCodeBetterScience/simple_workflow/correlation.py new file mode 100644 index 0000000..935b194 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/correlation.py @@ -0,0 +1,43 @@ +"""Correlation computation module for the simple workflow example. + +This module provides functions to compute correlation matrices. +""" + +import pandas as pd + + +def compute_spearman_correlation(df: pd.DataFrame) -> pd.DataFrame: + """Compute Spearman correlation matrix for a dataframe. + + Parameters + ---------- + df : pd.DataFrame + Input dataframe with numerical columns + + Returns + ------- + pd.DataFrame + Spearman correlation matrix + """ + return df.corr(method="spearman") + + +def compute_correlation_matrix( + df: pd.DataFrame, + method: str = "spearman", +) -> pd.DataFrame: + """Compute correlation matrix using the specified method. + + Parameters + ---------- + df : pd.DataFrame + Input dataframe with numerical columns + method : str + Correlation method: 'pearson', 'spearman', or 'kendall' (default: 'spearman') + + Returns + ------- + pd.DataFrame + Correlation matrix + """ + return df.corr(method=method) diff --git a/src/BetterCodeBetterScience/simple_workflow/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/filter_data.py new file mode 100644 index 0000000..c4b3bbe --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/filter_data.py @@ -0,0 +1,56 @@ +"""Data filtering module for the simple workflow example. + +This module provides functions to filter dataframes to keep only numerical columns. +""" + +import pandas as pd + + +def filter_numerical_columns(df: pd.DataFrame) -> pd.DataFrame: + """Filter a dataframe to keep only numerical columns. + + Parameters + ---------- + df : pd.DataFrame + Input dataframe + + Returns + ------- + pd.DataFrame + Dataframe with only numerical columns + """ + numerical_df = df.select_dtypes(include=["number"]) + return numerical_df + + +def filter_meaningful_variables(df: pd.DataFrame) -> pd.DataFrame: + """Filter meaningful variables dataframe to numerical columns only. + + Parameters + ---------- + df : pd.DataFrame + Meaningful variables dataframe + + Returns + ------- + pd.DataFrame + Filtered dataframe with only numerical columns + """ + return filter_numerical_columns(df) + + +def filter_demographics(df: pd.DataFrame) -> pd.DataFrame: + """Filter demographics dataframe to numerical columns only. + + Parameters + ---------- + df : pd.DataFrame + Demographics dataframe + + Returns + ------- + pd.DataFrame + Filtered dataframe with only numerical columns + """ + return filter_numerical_columns(df) + diff --git a/src/BetterCodeBetterScience/simple_workflow/join_data.py b/src/BetterCodeBetterScience/simple_workflow/join_data.py new file mode 100644 index 0000000..f5c8090 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/join_data.py @@ -0,0 +1,54 @@ +"""Data joining module for the simple workflow example. + +This module provides functions to join dataframes based on their index. +""" + +import pandas as pd + + +def join_dataframes( + df1: pd.DataFrame, + df2: pd.DataFrame, + how: str = "inner", +) -> pd.DataFrame: + """Join two dataframes based on their index. + + Parameters + ---------- + df1 : pd.DataFrame + First dataframe + df2 : pd.DataFrame + Second dataframe + how : str + Type of join: 'inner', 'outer', 'left', 'right' (default: 'inner') + + Returns + ------- + pd.DataFrame + Joined dataframe + """ + return df1.join(df2, how=how, lsuffix="_mv", rsuffix="_demo") + + +def join_meaningful_and_demographics( + meaningful_vars: pd.DataFrame, + demographics: pd.DataFrame, + how: str = "inner", +) -> pd.DataFrame: + """Join meaningful variables and demographics dataframes. + + Parameters + ---------- + meaningful_vars : pd.DataFrame + Meaningful variables dataframe (filtered to numerical) + demographics : pd.DataFrame + Demographics dataframe (filtered to numerical) + how : str + Type of join (default: 'inner') + + Returns + ------- + pd.DataFrame + Joined dataframe + """ + return join_dataframes(meaningful_vars, demographics, how=how) diff --git a/src/BetterCodeBetterScience/simple_workflow/load_data.py b/src/BetterCodeBetterScience/simple_workflow/load_data.py new file mode 100644 index 0000000..5f67460 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/load_data.py @@ -0,0 +1,87 @@ +"""Data loading module for the simple workflow example. + +This module provides functions to load CSV data from URLs or local files. +""" + +from pathlib import Path + +import pandas as pd + + +def load_csv_from_url(url: str, index_col: int = 0) -> pd.DataFrame: + """Load a CSV file from a URL. + + Parameters + ---------- + url : str + URL to the CSV file + index_col : int + Column to use as index (default: 0, first column) + + Returns + ------- + pd.DataFrame + Loaded dataframe with the first column as index + """ + return pd.read_csv(url, index_col=index_col) + + +def load_meaningful_variables( + url: str = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv", + cache_path: Path | None = None, +) -> pd.DataFrame: + """Load the meaningful variables dataset. + + Parameters + ---------- + url : str + URL to the meaningful variables CSV file + cache_path : Path, optional + If provided, save/load from this local path + + Returns + ------- + pd.DataFrame + Meaningful variables dataframe + """ + if cache_path is not None and cache_path.exists(): + return pd.read_csv(cache_path, index_col=0) + + df = load_csv_from_url(url) + + if cache_path is not None: + cache_path.parent.mkdir(parents=True, exist_ok=True) + df.to_csv(cache_path) + + return df + + +def load_demographics( + url: str = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv", + cache_path: Path | None = None, +) -> pd.DataFrame: + """Load the demographics dataset. + + Parameters + ---------- + url : str + URL to the demographics CSV file + cache_path : Path, optional + If provided, save/load from this local path + + Returns + ------- + pd.DataFrame + Demographics dataframe + """ + if cache_path is not None and cache_path.exists(): + return pd.read_csv(cache_path, index_col=0) + + df = load_csv_from_url(url) + + if cache_path is not None: + cache_path.parent.mkdir(parents=True, exist_ok=True) + df.to_csv(cache_path) + + return df + diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile new file mode 100644 index 0000000..b3367b6 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/Makefile @@ -0,0 +1,20 @@ +# Simple Correlation Workflow using Make +# +# Usage: +# make all - Run full workflow +# make clean - Remove output directory + +OUTPUT_DIR ?= ./output + +.PHONY: all clean + +all: + mkdir -p $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures + python scripts/download_data.py $(OUTPUT_DIR)/data + python scripts/filter_data.py $(OUTPUT_DIR)/data + python scripts/join_data.py $(OUTPUT_DIR)/data + python scripts/compute_correlation.py $(OUTPUT_DIR)/data $(OUTPUT_DIR)/results + python scripts/generate_heatmap.py $(OUTPUT_DIR)/results $(OUTPUT_DIR)/figures + +clean: + rm -rf $(OUTPUT_DIR) diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py new file mode 100644 index 0000000..e09a55b --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/compute_correlation.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Compute Spearman correlation matrix. + +Usage: + python compute_correlation.py +""" + +import sys +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.correlation import ( + compute_spearman_correlation, +) + + +def main(): + """Compute Spearman correlation matrix.""" + if len(sys.argv) != 3: + print("Usage: python compute_correlation.py ") + sys.exit(1) + + data_dir = Path(sys.argv[1]) + results_dir = Path(sys.argv[2]) + + # Load joined data + df = pd.read_csv(data_dir / "joined_data.csv", index_col=0) + print(f"Loaded joined data: {df.shape}") + + # Compute correlation + corr_matrix = compute_spearman_correlation(df) + corr_matrix.to_csv(results_dir / "correlation_matrix.csv") + print(f"Saved correlation matrix: {corr_matrix.shape}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py new file mode 100644 index 0000000..a3abe23 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/download_data.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +"""Download data files. + +Usage: + python download_data.py +""" + +import sys +from pathlib import Path + +import pandas as pd + +MV_URL = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv" +DEMO_URL = "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv" + + +def main(): + """Download both data files.""" + if len(sys.argv) != 2: + print("Usage: python download_data.py ") + sys.exit(1) + + data_dir = Path(sys.argv[1]) + + # Download meaningful variables + mv_df = pd.read_csv(MV_URL, index_col=0) + mv_df.to_csv(data_dir / "meaningful_variables.csv") + print(f"Downloaded meaningful_variables.csv ({len(mv_df)} rows)") + + # Download demographics + demo_df = pd.read_csv(DEMO_URL, index_col=0) + demo_df.to_csv(data_dir / "demographics.csv") + print(f"Downloaded demographics.csv ({len(demo_df)} rows)") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py new file mode 100644 index 0000000..73c13bc --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/filter_data.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +"""Filter dataframes to numerical columns only. + +Usage: + python filter_data.py +""" + +import sys +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.filter_data import ( + filter_numerical_columns, +) + + +def main(): + """Filter both datasets to numerical columns.""" + if len(sys.argv) != 2: + print("Usage: python filter_data.py ") + sys.exit(1) + + data_dir = Path(sys.argv[1]) + + # Filter meaningful variables + mv_df = pd.read_csv(data_dir / "meaningful_variables.csv", index_col=0) + mv_num = filter_numerical_columns(mv_df) + mv_num.to_csv(data_dir / "meaningful_variables_numerical.csv") + print(f"Filtered meaningful_variables: {mv_df.shape} -> {mv_num.shape}") + + # Filter demographics + demo_df = pd.read_csv(data_dir / "demographics.csv", index_col=0) + demo_num = filter_numerical_columns(demo_df) + demo_num.to_csv(data_dir / "demographics_numerical.csv") + print(f"Filtered demographics: {demo_df.shape} -> {demo_num.shape}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py new file mode 100644 index 0000000..11b0415 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/generate_heatmap.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Generate clustered heatmap from correlation matrix. + +Usage: + python generate_heatmap.py +""" + +import sys +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.visualization import ( + generate_clustered_heatmap, +) + + +def main(): + """Generate and save clustered heatmap.""" + if len(sys.argv) != 3: + print("Usage: python generate_heatmap.py ") + sys.exit(1) + + results_dir = Path(sys.argv[1]) + figures_dir = Path(sys.argv[2]) + + # Load correlation matrix + corr_matrix = pd.read_csv(results_dir / "correlation_matrix.csv", index_col=0) + print(f"Loaded correlation matrix: {corr_matrix.shape}") + + # Generate heatmap + output_path = figures_dir / "correlation_heatmap.png" + generate_clustered_heatmap(corr_matrix, output_path=output_path) + print(f"Saved heatmap to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py new file mode 100644 index 0000000..b8f09f4 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/make_workflow/scripts/join_data.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Join two dataframes based on their index. + +Usage: + python join_data.py +""" + +import sys +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes + + +def main(): + """Join the two datasets.""" + if len(sys.argv) != 2: + print("Usage: python join_data.py ") + sys.exit(1) + + data_dir = Path(sys.argv[1]) + + # Load filtered data + mv_df = pd.read_csv(data_dir / "meaningful_variables_numerical.csv", index_col=0) + demo_df = pd.read_csv(data_dir / "demographics_numerical.csv", index_col=0) + + print(f"Meaningful variables: {mv_df.shape}") + print(f"Demographics: {demo_df.shape}") + + # Join + joined = join_dataframes(mv_df, demo_df) + joined.to_csv(data_dir / "joined_data.csv") + print(f"Joined: {joined.shape}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py new file mode 100644 index 0000000..498e670 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/flows.py @@ -0,0 +1,115 @@ +"""Prefect flow definitions for the simple correlation workflow. + +This workflow demonstrates Prefect features with a simple pandas-based analysis: +1. Load two datasets from URLs +2. Filter to numerical columns +3. Join the datasets +4. Compute Spearman correlation +5. Generate a clustered heatmap +""" + +from pathlib import Path + +from prefect import flow, get_run_logger + +from BetterCodeBetterScience.simple_workflow.prefect_workflow.tasks import ( + compute_correlation_task, + filter_numerical_task, + generate_heatmap_task, + join_dataframes_task, + load_demographics_task, + load_meaningful_variables_task, + save_correlation_task, +) + + +@flow(name="simple_correlation_workflow", log_prints=True) +def run_workflow( + output_dir: Path, + cache_data: bool = True, +) -> Path: + """Run the simple correlation workflow. + + Steps: + 1. Load meaningful variables and demographics datasets + 2. Filter both to numerical columns only + 3. Join the datasets on their index + 4. Compute Spearman correlation matrix + 5. Generate clustered heatmap + + Parameters + ---------- + output_dir : Path + Directory to save outputs (correlation matrix CSV and heatmap) + cache_data : bool + Whether to cache downloaded data locally (default: True) + + Returns + ------- + Path + Path to the generated heatmap + """ + logger = get_run_logger() + + # Setup directories + output_dir = Path(output_dir) + data_dir = output_dir / "data" + results_dir = output_dir / "results" + figures_dir = output_dir / "figures" + + for d in [data_dir, results_dir, figures_dir]: + d.mkdir(parents=True, exist_ok=True) + + # Step 1: Load data (can run in parallel) + logger.info("Step 1: Loading datasets...") + mv_cache = data_dir / "meaningful_variables.csv" if cache_data else None + demo_cache = data_dir / "demographics.csv" if cache_data else None + + meaningful_vars = load_meaningful_variables_task(cache_path=mv_cache) + demographics = load_demographics_task(cache_path=demo_cache) + + logger.info(f" Meaningful variables: {meaningful_vars.shape}") + logger.info(f" Demographics: {demographics.shape}") + + # Step 2: Filter to numerical columns + logger.info("Step 2: Filtering to numerical columns...") + meaningful_vars_num = filter_numerical_task(meaningful_vars) + demographics_num = filter_numerical_task(demographics) + + logger.info(f" Meaningful variables (numerical): {meaningful_vars_num.shape}") + logger.info(f" Demographics (numerical): {demographics_num.shape}") + + # Step 3: Join datasets + logger.info("Step 3: Joining datasets...") + joined_df = join_dataframes_task(meaningful_vars_num, demographics_num) + logger.info(f" Joined dataset: {joined_df.shape}") + + # Step 4: Compute correlation matrix + logger.info("Step 4: Computing Spearman correlation matrix...") + corr_matrix = compute_correlation_task(joined_df) + logger.info(f" Correlation matrix: {corr_matrix.shape}") + + # Save correlation matrix + corr_path = results_dir / "correlation_matrix.csv" + save_correlation_task(corr_matrix, corr_path) + logger.info(f" Saved correlation matrix to: {corr_path}") + + # Step 5: Generate heatmap + logger.info("Step 5: Generating clustered heatmap...") + heatmap_path = figures_dir / "correlation_heatmap.png" + generate_heatmap_task(corr_matrix, heatmap_path) + logger.info(f" Saved heatmap to: {heatmap_path}") + + logger.info("Workflow complete!") + return heatmap_path + + +if __name__ == "__main__": + import sys + + if len(sys.argv) < 2: + print("Usage: python flows.py ") + sys.exit(1) + + output_dir = Path(sys.argv[1]) + run_workflow(output_dir) diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py new file mode 100644 index 0000000..e85c670 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/run_workflow.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""CLI entry point for the simple correlation Prefect workflow. + +Usage: + python run_workflow.py --output-dir ./output + python run_workflow.py --output-dir ./output --no-cache +""" + +import argparse +from pathlib import Path + +from BetterCodeBetterScience.simple_workflow.prefect_workflow.flows import run_workflow + + +def main(): + """Run the simple correlation workflow from the command line.""" + parser = argparse.ArgumentParser( + description="Run the simple correlation workflow with Prefect" + ) + parser.add_argument( + "--output-dir", + type=Path, + required=True, + help="Directory to save outputs", + ) + parser.add_argument( + "--no-cache", + action="store_true", + help="Do not cache downloaded data locally", + ) + + args = parser.parse_args() + + result = run_workflow( + output_dir=args.output_dir, + cache_data=not args.no_cache, + ) + + print(f"\nWorkflow complete! Heatmap saved to: {result}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py new file mode 100644 index 0000000..4d5193e --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/prefect_workflow/tasks.py @@ -0,0 +1,153 @@ +"""Prefect task definitions for the simple correlation workflow. + +Each task wraps a function from the modular workflow modules. +""" + +from pathlib import Path + +import pandas as pd +from prefect import task + +from BetterCodeBetterScience.simple_workflow.correlation import ( + compute_spearman_correlation, +) +from BetterCodeBetterScience.simple_workflow.filter_data import ( + filter_numerical_columns, +) +from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes +from BetterCodeBetterScience.simple_workflow.load_data import ( + load_demographics, + load_meaningful_variables, +) +from BetterCodeBetterScience.simple_workflow.visualization import ( + generate_clustered_heatmap, + save_correlation_matrix, +) + + +@task(name="load_meaningful_variables") +def load_meaningful_variables_task( + cache_path: Path | None = None, +) -> pd.DataFrame: + """Load meaningful variables dataset. + + Parameters + ---------- + cache_path : Path, optional + Path to cache the downloaded data + + Returns + ------- + pd.DataFrame + Meaningful variables dataframe + """ + return load_meaningful_variables(cache_path=cache_path) + + +@task(name="load_demographics") +def load_demographics_task( + cache_path: Path | None = None, +) -> pd.DataFrame: + """Load demographics dataset. + + Parameters + ---------- + cache_path : Path, optional + Path to cache the downloaded data + + Returns + ------- + pd.DataFrame + Demographics dataframe + """ + return load_demographics(cache_path=cache_path) + + +@task(name="filter_numerical_columns") +def filter_numerical_task(df: pd.DataFrame) -> pd.DataFrame: + """Filter dataframe to keep only numerical columns. + + Parameters + ---------- + df : pd.DataFrame + Input dataframe + + Returns + ------- + pd.DataFrame + Filtered dataframe + """ + return filter_numerical_columns(df) + + +@task(name="join_dataframes") +def join_dataframes_task( + df1: pd.DataFrame, + df2: pd.DataFrame, +) -> pd.DataFrame: + """Join two dataframes based on their index. + + Parameters + ---------- + df1 : pd.DataFrame + First dataframe + df2 : pd.DataFrame + Second dataframe + + Returns + ------- + pd.DataFrame + Joined dataframe + """ + return join_dataframes(df1, df2) + + +@task(name="compute_correlation") +def compute_correlation_task(df: pd.DataFrame) -> pd.DataFrame: + """Compute Spearman correlation matrix. + + Parameters + ---------- + df : pd.DataFrame + Input dataframe + + Returns + ------- + pd.DataFrame + Correlation matrix + """ + return compute_spearman_correlation(df) + + +@task(name="save_correlation_matrix") +def save_correlation_task( + corr_matrix: pd.DataFrame, + output_path: Path, +) -> None: + """Save correlation matrix to CSV. + + Parameters + ---------- + corr_matrix : pd.DataFrame + Correlation matrix + output_path : Path + Output path + """ + save_correlation_matrix(corr_matrix, output_path) + + +@task(name="generate_heatmap") +def generate_heatmap_task( + corr_matrix: pd.DataFrame, + output_path: Path, +) -> None: + """Generate and save clustered heatmap. + + Parameters + ---------- + corr_matrix : pd.DataFrame + Correlation matrix + output_path : Path + Output path for the figure + """ + generate_clustered_heatmap(corr_matrix, output_path) diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile new file mode 100644 index 0000000..95954e9 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Makefile @@ -0,0 +1,19 @@ +OUTPUT_DIR := /Users/poldrack/data_unsynced/BCBS/simple_workflow/wf_snakemake + +.PHONY: run report graph + +clean: + -rm .snakemake + -rm -rf $(OUTPUT_DIR)/* + +run: + snakemake --cores 1 --config output_dir=$(OUTPUT_DIR) + +dryrun: + snakemake --dry-run --cores 1 --config output_dir=$(OUTPUT_DIR) + +report: + snakemake --report $(OUTPUT_DIR)/report.html --config output_dir=$(OUTPUT_DIR) + +graph: + snakemake --rulegraph --config output_dir=$(OUTPUT_DIR) --cores 2 | dot -Tpng -Gdpi=300 > output/rulegraph.png diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile new file mode 100644 index 0000000..789fd98 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/Snakefile @@ -0,0 +1,151 @@ +"""Simple correlation Snakemake workflow. + +This workflow demonstrates Snakemake features with a simple pandas-based analysis: +1. Load two datasets from URLs +2. Filter to numerical columns +3. Join the datasets +4. Compute Spearman correlation +5. Generate a clustered heatmap + +Usage: + # Run full workflow + snakemake --cores 1 --config output_dir=/path/to/output + + # Dry run + snakemake -n --config output_dir=/path/to/output + + # Generate report + snakemake --report report.html --config output_dir=/path/to/output +""" + +from pathlib import Path + +from snakemake.utils import min_version + +min_version("8.0") + + +# Load configuration +configfile: "config/config.yaml" + + +# Global report +report: "report/workflow.rst" + + +# Validate required config +if config.get("output_dir") is None: + raise ValueError("output_dir must be provided via --config output_dir=/path/to/output") + +OUTPUT_DIR = Path(config["output_dir"]) +DATA_DIR = OUTPUT_DIR / "data" +RESULTS_DIR = OUTPUT_DIR / "results" +FIGURES_DIR = OUTPUT_DIR / "figures" +LOGS_DIR = OUTPUT_DIR / "logs" + + +# Create output directories at workflow start +onstart: + shell(f"mkdir -p {DATA_DIR} {RESULTS_DIR} {FIGURES_DIR} {LOGS_DIR}") + + +# Default target +rule all: + input: + FIGURES_DIR / "correlation_heatmap.png", + + +# Step 1a: Download meaningful variables data +rule download_meaningful_variables: + output: + DATA_DIR / "meaningful_variables.csv", + params: + url=config["meaningful_variables_url"], + log: + OUTPUT_DIR / "logs" / "download_meaningful_variables.log", + script: + "scripts/download_data.py" + + +# Step 1b: Download demographics data +rule download_demographics: + output: + DATA_DIR / "demographics.csv", + params: + url=config["demographics_url"], + log: + OUTPUT_DIR / "logs" / "download_demographics.log", + script: + "scripts/download_data.py" + + +# Step 2a: Filter meaningful variables to numerical columns +rule filter_meaningful_variables: + input: + DATA_DIR / "meaningful_variables.csv", + output: + DATA_DIR / "meaningful_variables_numerical.csv", + log: + OUTPUT_DIR / "logs" / "filter_meaningful_variables.log", + script: + "scripts/filter_data.py" + + +# Step 2b: Filter demographics to numerical columns +rule filter_demographics: + input: + DATA_DIR / "demographics.csv", + output: + DATA_DIR / "demographics_numerical.csv", + log: + OUTPUT_DIR / "logs" / "filter_demographics.log", + script: + "scripts/filter_data.py" + + +# Step 3: Join the two datasets +rule join_datasets: + input: + meaningful_vars=DATA_DIR / "meaningful_variables_numerical.csv", + demographics=DATA_DIR / "demographics_numerical.csv", + output: + DATA_DIR / "joined_data.csv", + log: + OUTPUT_DIR / "logs" / "join_datasets.log", + script: + "scripts/join_data.py" + + +# Step 4: Compute correlation matrix +rule compute_correlation: + input: + DATA_DIR / "joined_data.csv", + output: + RESULTS_DIR / "correlation_matrix.csv", + params: + method=config["correlation_method"], + log: + OUTPUT_DIR / "logs" / "compute_correlation.log", + script: + "scripts/compute_correlation.py" + + +# Step 5: Generate clustered heatmap +rule generate_heatmap: + input: + RESULTS_DIR / "correlation_matrix.csv", + output: + report( + FIGURES_DIR / "correlation_heatmap.png", + caption="report/heatmap.rst", + category="Results", + ), + params: + figsize=config["heatmap"]["figsize"], + cmap=config["heatmap"]["cmap"], + vmin=config["heatmap"]["vmin"], + vmax=config["heatmap"]["vmax"], + log: + OUTPUT_DIR / "logs" / "generate_heatmap.log", + script: + "scripts/generate_heatmap.py" diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/__init__.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml new file mode 100644 index 0000000..332399f --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/config/config.yaml @@ -0,0 +1,15 @@ +# Configuration for the simple correlation Snakemake workflow + +# Data URLs +meaningful_variables_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/meaningful_variables_clean.csv" +demographics_url: "https://raw.githubusercontent.com/IanEisenberg/Self_Regulation_Ontology/refs/heads/master/Data/Complete_02-16-2019/demographics.csv" + +# Correlation settings +correlation_method: "spearman" + +# Heatmap settings +heatmap: + figsize: [12, 10] + cmap: "coolwarm" + vmin: -1.0 + vmax: 1.0 diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst new file mode 100644 index 0000000..8700d3b --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/heatmap.rst @@ -0,0 +1 @@ +Clustered correlation heatmap showing Spearman correlations between all numerical variables from the meaningful variables and demographics datasets. Variables are hierarchically clustered to reveal patterns of related measures. diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst new file mode 100644 index 0000000..0dadb46 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/report/workflow.rst @@ -0,0 +1,10 @@ +Simple Correlation Workflow +=========================== + +This workflow demonstrates a simple pandas-based data analysis pipeline: + +1. **Data Loading**: Downloads two datasets from the Self-Regulation Ontology project +2. **Filtering**: Removes non-numerical columns from both datasets +3. **Joining**: Combines the datasets based on their common index (subject IDs) +4. **Correlation**: Computes Spearman correlation matrix across all measures +5. **Visualization**: Generates a clustered heatmap showing correlation patterns diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py new file mode 100644 index 0000000..33a29a1 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/compute_correlation.py @@ -0,0 +1,34 @@ +"""Snakemake script for computing correlation matrix.""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.correlation import ( + compute_correlation_matrix, +) + + +def main(): + """Compute Spearman correlation matrix.""" + # ruff: noqa: F821 + input_path = Path(snakemake.input[0]).expanduser() + output_path = Path(snakemake.output[0]).expanduser() + method = snakemake.params.method + + # Load data + df = pd.read_csv(input_path, index_col=0) + print(f"Loaded {df.shape} from {input_path}") + + # Compute correlation + corr_matrix = compute_correlation_matrix(df, method=method) + print(f"Computed {method} correlation matrix: {corr_matrix.shape}") + + # Save + output_path.parent.mkdir(parents=True, exist_ok=True) + corr_matrix.to_csv(output_path) + print(f"Saved to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py new file mode 100644 index 0000000..abad205 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/download_data.py @@ -0,0 +1,26 @@ +"""Snakemake script for downloading data from URL.""" + +from pathlib import Path + +import pandas as pd + + +def main(): + """Download data from URL.""" + # ruff: noqa: F821 + url = snakemake.params.url + output_path = Path(snakemake.output[0]).expanduser() + + # Create output directory + output_path.parent.mkdir(parents=True, exist_ok=True) + + # Download and save + df = pd.read_csv(url, index_col=0) + df.to_csv(output_path) + + print(f"Downloaded {len(df)} rows from {url}") + print(f"Saved to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py new file mode 100644 index 0000000..6e5af11 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/filter_data.py @@ -0,0 +1,33 @@ +"""Snakemake script for filtering data to numerical columns.""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.filter_data import ( + filter_numerical_columns, +) + + +def main(): + """Filter data to numerical columns.""" + # ruff: noqa: F821 + input_path = Path(snakemake.input[0]).expanduser() + output_path = Path(snakemake.output[0]).expanduser() + + # Load data + df = pd.read_csv(input_path, index_col=0) + print(f"Loaded {df.shape} from {input_path}") + + # Filter to numerical columns + df_num = filter_numerical_columns(df) + print(f"Filtered to {df_num.shape} (numerical columns only)") + + # Save + output_path.parent.mkdir(parents=True, exist_ok=True) + df_num.to_csv(output_path) + print(f"Saved to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py new file mode 100644 index 0000000..cb59946 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/generate_heatmap.py @@ -0,0 +1,40 @@ +"""Snakemake script for generating clustered heatmap.""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.visualization import ( + generate_clustered_heatmap, +) + + +def main(): + """Generate and save clustered heatmap.""" + # ruff: noqa: F821 + input_path = Path(snakemake.input[0]) + output_path = Path(snakemake.output[0]) + figsize = tuple(snakemake.params.figsize) + cmap = snakemake.params.cmap + vmin = snakemake.params.vmin + vmax = snakemake.params.vmax + + # Load correlation matrix + corr_matrix = pd.read_csv(input_path, index_col=0) + print(f"Loaded correlation matrix: {corr_matrix.shape}") + + # Generate heatmap + output_path.parent.mkdir(parents=True, exist_ok=True) + generate_clustered_heatmap( + corr_matrix, + output_path=output_path, + figsize=figsize, + cmap=cmap, + vmin=vmin, + vmax=vmax, + ) + print(f"Saved heatmap to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py new file mode 100644 index 0000000..b484d92 --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/snakemake_workflow/scripts/join_data.py @@ -0,0 +1,35 @@ +"""Snakemake script for joining two dataframes.""" + +from pathlib import Path + +import pandas as pd + +from BetterCodeBetterScience.simple_workflow.join_data import join_dataframes + + +def main(): + """Join the two datasets.""" + # ruff: noqa: F821 + mv_path = Path(snakemake.input.meaningful_vars).expanduser() + demo_path = Path(snakemake.input.demographics).expanduser() + output_path = Path(snakemake.output[0]).expanduser() + + # Load data + meaningful_vars = pd.read_csv(mv_path, index_col=0) + demographics = pd.read_csv(demo_path, index_col=0) + + print(f"Meaningful variables: {meaningful_vars.shape}") + print(f"Demographics: {demographics.shape}") + + # Join + joined = join_dataframes(meaningful_vars, demographics) + print(f"Joined: {joined.shape}") + + # Save + output_path.parent.mkdir(parents=True, exist_ok=True) + joined.to_csv(output_path) + print(f"Saved to {output_path}") + + +if __name__ == "__main__": + main() diff --git a/src/BetterCodeBetterScience/simple_workflow/visualization.py b/src/BetterCodeBetterScience/simple_workflow/visualization.py new file mode 100644 index 0000000..f6dddca --- /dev/null +++ b/src/BetterCodeBetterScience/simple_workflow/visualization.py @@ -0,0 +1,84 @@ +"""Visualization module for the simple workflow example. + +This module provides functions to generate heatmaps from correlation matrices. +""" + +from pathlib import Path + +import matplotlib.pyplot as plt +import pandas as pd +import seaborn as sns + + +def generate_clustered_heatmap( + corr_matrix: pd.DataFrame, + output_path: Path | None = None, + figsize: tuple[int, int] = (8, 10), + cmap: str = "coolwarm", + vmin: float = -1.0, + vmax: float = 1.0, +) -> sns.matrix.ClusterGrid: + """Generate a clustered heatmap from a correlation matrix. + + Parameters + ---------- + corr_matrix : pd.DataFrame + Correlation matrix + output_path : Path, optional + If provided, save the figure to this path + figsize : tuple + Figure size (width, height) in inches + cmap : str + Colormap name (default: 'coolwarm') + vmin : float + Minimum value for color scale + vmax : float + Maximum value for color scale + + Returns + ------- + sns.matrix.ClusterGrid + The ClusterGrid object containing the heatmap + """ + # Create clustered heatmap + g = sns.clustermap( + corr_matrix, + cmap=cmap, + vmin=vmin, + vmax=vmax, + figsize=figsize, + dendrogram_ratio=(0.1, 0.1), + cbar_pos=(0.02, 0.8, 0.03, 0.15), + xticklabels=False, + yticklabels=True, + ) + + # Set y-axis label font size + plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0, fontsize=3) + + # Set title + g.fig.suptitle("Clustered Correlation Heatmap (Spearman)", y=1.02, fontsize=14) + + # Save if output path provided + if output_path is not None: + output_path.parent.mkdir(parents=True, exist_ok=True) + g.savefig(output_path, dpi=300, bbox_inches="tight") + + return g + + +def save_correlation_matrix( + corr_matrix: pd.DataFrame, + output_path: Path, +) -> None: + """Save a correlation matrix to a CSV file. + + Parameters + ---------- + corr_matrix : pd.DataFrame + Correlation matrix + output_path : Path + Path to save the CSV file + """ + output_path.parent.mkdir(parents=True, exist_ok=True) + corr_matrix.to_csv(output_path) diff --git a/tests/narps/test_bids.py b/tests/narps/test_bids.py new file mode 100644 index 0000000..1f10019 --- /dev/null +++ b/tests/narps/test_bids.py @@ -0,0 +1,627 @@ +"""Tests for BIDS utility functions.""" + +import pytest +from pathlib import Path +import tempfile +import shutil + +from BetterCodeBetterScience.narps.bids_utils import ( + parse_bids_filename, + find_bids_files, + modify_bids_filename, + bids_summary, +) + + +# Tests for parse_bids_filename + + +def test_parse_bids_filename_basic_string(): + """Test parsing a basic BIDS filename from a string.""" + filename = "sub-01_task-rest_bold.nii.gz" + result = parse_bids_filename(filename) + + assert result['sub'] == '01' + assert result['task'] == 'rest' + assert result['suffix'] == 'bold' + assert 'path' in result + assert result['path'] == filename + + +def test_parse_bids_filename_path_object(): + """Test parsing a BIDS filename from a Path object.""" + filepath = Path("/data/sub-02_ses-01_T1w.nii.gz") + result = parse_bids_filename(filepath) + + assert result['sub'] == '02' + assert result['ses'] == '01' + assert result['suffix'] == 'T1w' + assert result['path'] == str(filepath) + + +def test_parse_bids_filename_complex(): + """Test parsing a complex BIDS filename with multiple entities.""" + filename = "sub-01_ses-02_task-rest_acq-mb_run-01_bold.nii.gz" + result = parse_bids_filename(filename) + + assert result['sub'] == '01' + assert result['ses'] == '02' + assert result['task'] == 'rest' + assert result['acq'] == 'mb' + assert result['run'] == '01' + assert result['suffix'] == 'bold' + + +def test_parse_bids_filename_with_hyphen_in_value(): + """Test parsing when a value contains a hyphen.""" + filename = "sub-control-01_task-go-nogo_bold.nii" + result = parse_bids_filename(filename) + + # Should split only on first hyphen + assert result['sub'] == 'control-01' + assert result['task'] == 'go-nogo' + assert result['suffix'] == 'bold' + + +def test_parse_bids_filename_narps_format(): + """Test parsing NARPS-specific filename format.""" + filename = "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz" + result = parse_bids_filename(filename) + + assert result['sub'] == 'team01' + assert result['hyp'] == '1' + assert result['type'] == 'thresh' + assert result['desc'] == 'orig' + assert result['suffix'] == 'stat' + + +def test_parse_bids_filename_with_full_path(): + """Test parsing with a full absolute path.""" + filepath = Path("/home/user/data/sub-03_T2w.nii.gz") + result = parse_bids_filename(filepath) + + assert result['sub'] == '03' + assert result['suffix'] == 'T2w' + assert result['path'] == str(filepath) + # Should only parse the filename, not the directory + assert 'home' not in result + assert 'user' not in result + + +def test_parse_bids_filename_minimal(): + """Test parsing a minimal BIDS filename.""" + filename = "sub-01_bold.nii" + result = parse_bids_filename(filename) + + assert result['sub'] == '01' + assert result['suffix'] == 'bold' + assert len(result) == 3 # sub, suffix, path + + +def test_parse_bids_filename_no_extension(): + """Test parsing a filename without extension.""" + filename = "sub-01_task-rest_bold" + result = parse_bids_filename(filename) + + assert result['sub'] == '01' + assert result['task'] == 'rest' + assert result['suffix'] == 'bold' + + +# Tests for find_bids_files + + +@pytest.fixture +def temp_bids_dir(): + """Create a temporary BIDS-like directory structure for testing.""" + tmpdir = tempfile.mkdtemp() + basedir = Path(tmpdir) + + # Create test files + files = [ + "sub-01_task-rest_bold.nii.gz", + "sub-01_task-rest_T1w.nii.gz", + "sub-01_task-memory_bold.nii.gz", + "sub-02_task-rest_bold.nii.gz", + "sub-02_task-memory_bold.nii.gz", + "sub-03_ses-01_task-rest_bold.nii.gz", + "sub-03_ses-02_task-rest_bold.nii.gz", + ] + + for filename in files: + filepath = basedir / filename + filepath.touch() + + yield basedir + + # Cleanup + shutil.rmtree(tmpdir) + + +def test_find_bids_files_single_tag(temp_bids_dir): + """Test finding files with a single BIDS tag.""" + results = find_bids_files(temp_bids_dir, sub='01') + + assert len(results) == 3 + assert all('sub-01' in r.name for r in results) + + +def test_find_bids_files_multiple_tags(temp_bids_dir): + """Test finding files with multiple BIDS tags.""" + results = find_bids_files(temp_bids_dir, sub='01', task='rest') + + assert len(results) == 2 + filenames = [r.name for r in results] + assert "sub-01_task-rest_bold.nii.gz" in filenames + assert "sub-01_task-rest_T1w.nii.gz" in filenames + + +def test_find_bids_files_with_suffix(temp_bids_dir): + """Test finding files filtered by suffix.""" + results = find_bids_files(temp_bids_dir, suffix='bold') + + assert len(results) == 6 + assert all('bold' in r.name for r in results) + + +def test_find_bids_files_no_matches(temp_bids_dir): + """Test finding files when no matches exist.""" + results = find_bids_files(temp_bids_dir, sub='99') + + assert len(results) == 0 + + +def test_find_bids_files_all_tags_must_match(temp_bids_dir): + """Test that all specified tags must match.""" + results = find_bids_files(temp_bids_dir, sub='01', task='rest', suffix='bold') + + assert len(results) == 1 + assert results[0].name == "sub-01_task-rest_bold.nii.gz" + + +def test_find_bids_files_with_session(temp_bids_dir): + """Test finding files with session tag.""" + results = find_bids_files(temp_bids_dir, sub='03', ses='01') + + assert len(results) == 1 + assert results[0].name == "sub-03_ses-01_task-rest_bold.nii.gz" + + +def test_find_bids_files_string_basedir(temp_bids_dir): + """Test that basedir can be a string.""" + results = find_bids_files(str(temp_bids_dir), sub='02') + + assert len(results) == 2 + assert all('sub-02' in r.name for r in results) + + +def test_find_bids_files_no_tags(temp_bids_dir): + """Test finding files with no tag filters returns all files.""" + results = find_bids_files(temp_bids_dir) + + assert len(results) == 7 + + +def test_find_bids_files_nonexistent_tag(temp_bids_dir): + """Test filtering by a tag that doesn't exist in any files.""" + results = find_bids_files(temp_bids_dir, run='01') + + assert len(results) == 0 + + +@pytest.fixture +def temp_narps_dir(): + """Create a temporary NARPS-like directory structure.""" + tmpdir = tempfile.mkdtemp() + basedir = Path(tmpdir) + + # Create NARPS-style test files + files = [ + "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz", + "sub-team01_hyp-1_type-unthresh_desc-orig_stat.nii.gz", + "sub-team01_hyp-2_type-thresh_desc-orig_stat.nii.gz", + "sub-team02_hyp-1_type-thresh_desc-orig_stat.nii.gz", + "sub-team02_hyp-1_type-thresh_desc-rect_stat.nii.gz", + ] + + for filename in files: + filepath = basedir / filename + filepath.touch() + + yield basedir + + shutil.rmtree(tmpdir) + + +def test_find_bids_files_narps_format(temp_narps_dir): + """Test finding NARPS-formatted files.""" + results = find_bids_files(temp_narps_dir, sub='team01', hyp='1') + + assert len(results) == 2 + + +def test_find_bids_files_narps_by_type(temp_narps_dir): + """Test finding NARPS files by type.""" + results = find_bids_files(temp_narps_dir, type='thresh') + + assert len(results) == 4 + + +def test_find_bids_files_narps_by_desc(temp_narps_dir): + """Test finding NARPS files by description.""" + results = find_bids_files(temp_narps_dir, desc='rect') + + assert len(results) == 1 + assert results[0].name == "sub-team02_hyp-1_type-thresh_desc-rect_stat.nii.gz" + + +def test_find_bids_files_narps_complex_filter(temp_narps_dir): + """Test complex filtering on NARPS files.""" + results = find_bids_files( + temp_narps_dir, + sub='team01', + hyp='1', + type='thresh', + desc='orig' + ) + + assert len(results) == 1 + assert results[0].name == "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz" + + +# Tests for modify_bids_filename + + +def test_modify_bids_filename_single_tag(): + """Test modifying a single BIDS tag.""" + original = "sub-123_desc-test_type-1_stat.nii.gz" + result = modify_bids_filename(original, desc="real") + + # Should preserve order and return same type + assert result == "sub-123_desc-real_type-1_stat.nii.gz" + assert isinstance(result, str) + + +def test_modify_bids_filename_multiple_tags(): + """Test modifying multiple BIDS tags at once.""" + original = "sub-01_task-rest_bold.nii" + result = modify_bids_filename(original, task="memory", run="02") + + # Should add run and modify task, preserving original order + assert result == "sub-01_task-memory_run-02_bold.nii" + assert isinstance(result, str) + + +def test_modify_bids_filename_path_object(): + """Test that function works with Path objects.""" + original = Path("sub-01_ses-01_T1w.nii.gz") + result = modify_bids_filename(original, ses="02") + + # Should return Path object when input is Path + assert isinstance(result, Path) + assert result.name == "sub-01_ses-02_T1w.nii.gz" + + +def test_modify_bids_filename_add_new_tag(): + """Test adding a tag that wasn't in the original filename.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, run="01", acq="mb") + + # New tags should be added at the end (after existing tags) + assert result == "sub-01_task-rest_run-01_acq-mb_bold.nii.gz" + assert isinstance(result, str) + + +def test_modify_bids_filename_preserve_extension(): + """Test that file extensions are preserved.""" + original = "sub-01_bold.nii.gz" + result = modify_bids_filename(original, sub="02") + + assert result.endswith(".nii.gz") + assert result == "sub-02_bold.nii.gz" + + +def test_modify_bids_filename_simple_extension(): + """Test with simple extension (not .nii.gz).""" + original = "sub-01_task-rest_bold.nii" + result = modify_bids_filename(original, task="memory") + + assert result.endswith(".nii") + assert "task-memory" in result + + +def test_modify_bids_filename_no_extension(): + """Test with no file extension.""" + original = "sub-01_task-rest_bold" + result = modify_bids_filename(original, task="memory") + + assert "task-memory" in result + assert not result.endswith(".") + + +def test_modify_bids_filename_narps_format(): + """Test modifying NARPS-specific fields.""" + original = "sub-team01_hyp-1_type-thresh_desc-orig_stat.nii.gz" + result = modify_bids_filename(original, desc="rect", type="unthresh") + + assert "desc-rect" in result + assert "type-unthresh" in result + assert "hyp-1" in result + assert "sub-team01" in result + + +def test_modify_bids_filename_change_subject(): + """Test changing the subject ID.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, sub="99") + + # Should preserve order with modified subject + assert result == "sub-99_task-rest_bold.nii.gz" + + +def test_modify_bids_filename_preserve_suffix(): + """Test that suffix is preserved when modifying other tags.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, task="memory") + + assert result.endswith("_bold.nii.gz") + + +def test_modify_bids_filename_change_suffix(): + """Test changing the suffix.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, suffix="T1w") + + # Suffix should be at the end, not as suffix-value + assert result == "sub-01_task-rest_T1w.nii.gz" + assert "suffix-" not in result + + +def test_modify_bids_filename_change_suffix_and_tags(): + """Test changing both suffix and other tags.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, task="memory", suffix="T1w") + + assert result == "sub-01_task-memory_T1w.nii.gz" + assert "suffix-" not in result + + +def test_modify_bids_filename_complex_modification(): + """Test complex modification with many changes.""" + original = "sub-01_ses-01_task-rest_acq-mb_bold.nii.gz" + result = modify_bids_filename( + original, + sub="02", + ses="03", + task="memory", + run="01" + ) + + # Should preserve original order and append new tag + assert result == "sub-02_ses-03_task-memory_acq-mb_run-01_bold.nii.gz" + + +def test_modify_bids_filename_hyphenated_value(): + """Test that hyphenated values are handled correctly.""" + original = "sub-control-01_task-go_bold.nii" + result = modify_bids_filename(original, task="go-nogo") + + # Should preserve order with hyphenated values + assert result == "sub-control-01_task-go-nogo_bold.nii" + + +def test_modify_bids_filename_empty_modification(): + """Test that calling with no modifications returns identical filename.""" + original = "sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original) + + # Should return exactly the same filename + assert result == original + + +def test_modify_bids_filename_with_full_path(): + """Test modification preserves full directory path.""" + original = Path("/data/bids/sub-01_task-rest_bold.nii.gz") + result = modify_bids_filename(original, task="memory") + + # Result should preserve the full directory path + assert isinstance(result, Path) + assert result == Path("/data/bids/sub-01_task-memory_bold.nii.gz") + assert result.parent == Path("/data/bids") + assert result.name == "sub-01_task-memory_bold.nii.gz" + + +def test_modify_bids_filename_string_with_path(): + """Test that string input with directory path preserves the path.""" + original = "/data/bids/sub-01_task-rest_bold.nii.gz" + result = modify_bids_filename(original, task="memory") + + # Should return string and preserve directory path + assert isinstance(result, str) + assert result == "/data/bids/sub-01_task-memory_bold.nii.gz" + + +def test_modify_bids_filename_order_preservation(): + """Test that original key order is strictly preserved.""" + original = "sub-01_desc-orig_type-thresh_hyp-1_stat.nii.gz" + result = modify_bids_filename(original, type="unthresh") + + # Order should be exactly: sub, desc, type, hyp + assert result == "sub-01_desc-orig_type-unthresh_hyp-1_stat.nii.gz" + + +def test_modify_bids_filename_relative_path(): + """Test with relative path.""" + original = Path("data/sub-01_task-rest_bold.nii.gz") + result = modify_bids_filename(original, task="memory") + + assert isinstance(result, Path) + assert result == Path("data/sub-01_task-memory_bold.nii.gz") + assert result.parent == Path("data") + + +# Tests for bids_summary + + +@pytest.fixture +def temp_summary_dir(): + """Create a temporary directory with various BIDS files for summary testing.""" + tmpdir = tempfile.mkdtemp() + basedir = Path(tmpdir) + + # Create test files with different desc and type combinations + files = [ + "sub-team01_desc-orig_type-thresh_hyp-1_stat.nii.gz", + "sub-team01_desc-orig_type-thresh_hyp-2_stat.nii.gz", + "sub-team01_desc-orig_type-unthresh_hyp-1_stat.nii.gz", + "sub-team01_desc-orig_type-unthresh_hyp-2_stat.nii.gz", + "sub-team02_desc-orig_type-thresh_hyp-1_stat.nii.gz", + "sub-team02_desc-rect_type-thresh_hyp-1_stat.nii.gz", + "sub-team02_desc-rect_type-unthresh_hyp-1_stat.nii.gz", + "sub-team03_desc-rect_type-thresh_hyp-1_stat.nii.gz", + # Files without desc or type + "sub-team04_hyp-1_stat.nii.gz", + "sub-team05_desc-orig_hyp-1_stat.nii.gz", + # Different extension (should be excluded by default) + "sub-team01_desc-orig_type-thresh_hyp-1_stat.nii", + ] + + for filename in files: + filepath = basedir / filename + filepath.touch() + + yield basedir + + shutil.rmtree(tmpdir) + + +def test_bids_summary_basic(temp_summary_dir, capsys): + """Test basic summary functionality.""" + result = bids_summary(temp_summary_dir, verbose=False) + + # Check the structure + assert 'orig' in result + assert 'rect' in result + + # Check counts for orig + assert result['orig']['thresh'] == 3 + assert result['orig']['unthresh'] == 2 + + # Check counts for rect + assert result['rect']['thresh'] == 2 + assert result['rect']['unthresh'] == 1 + + +def test_bids_summary_verbose_output(temp_summary_dir, capsys): + """Test that verbose mode prints summary.""" + result = bids_summary(temp_summary_dir, verbose=True) + + captured = capsys.readouterr() + assert "Summary of BIDS files" in captured.out + assert "desc-orig:" in captured.out + assert "desc-rect:" in captured.out + assert "type-thresh:" in captured.out + assert "type-unthresh:" in captured.out + + +def test_bids_summary_no_verbose(temp_summary_dir, capsys): + """Test that verbose=False suppresses output.""" + result = bids_summary(temp_summary_dir, verbose=False) + + captured = capsys.readouterr() + assert captured.out == "" + + +def test_bids_summary_different_extension(temp_summary_dir): + """Test filtering by different extension.""" + result = bids_summary(temp_summary_dir, extension=".nii", verbose=False) + + # Should find only the .nii file + assert 'orig' in result + assert result['orig']['thresh'] == 1 + # Should not find .nii.gz files + assert result['orig'].get('unthresh') is None + + +def test_bids_summary_no_desc(temp_summary_dir): + """Test handling of files without desc tag.""" + result = bids_summary(temp_summary_dir, verbose=False) + + # Files without desc should be grouped under 'no_desc' + assert 'no_desc' in result + + +def test_bids_summary_no_type(temp_summary_dir): + """Test handling of files without type tag.""" + result = bids_summary(temp_summary_dir, verbose=False) + + # Check for files with desc but no type + assert 'orig' in result + assert 'no_type' in result['orig'] + assert result['orig']['no_type'] == 1 + + +def test_bids_summary_empty_directory(): + """Test summary on empty directory.""" + tmpdir = tempfile.mkdtemp() + try: + result = bids_summary(tmpdir, verbose=False) + assert result == {} + finally: + shutil.rmtree(tmpdir) + + +def test_bids_summary_string_path(temp_summary_dir): + """Test that function accepts string paths.""" + result = bids_summary(str(temp_summary_dir), verbose=False) + + assert isinstance(result, dict) + assert 'orig' in result + + +def test_bids_summary_extension_with_dot(temp_summary_dir): + """Test that extension works with or without leading dot.""" + result1 = bids_summary(temp_summary_dir, extension=".nii.gz", verbose=False) + result2 = bids_summary(temp_summary_dir, extension="nii.gz", verbose=False) + + # Both should produce same results + assert result1 == result2 + + +def test_bids_summary_nested_directories(): + """Test summary works with nested directory structures.""" + tmpdir = tempfile.mkdtemp() + basedir = Path(tmpdir) + + try: + # Create nested structure + subdir1 = basedir / "sub-01" + subdir2 = basedir / "sub-02" / "nested" + subdir1.mkdir(parents=True) + subdir2.mkdir(parents=True) + + (subdir1 / "sub-01_desc-orig_type-thresh_stat.nii.gz").touch() + (subdir2 / "sub-02_desc-orig_type-thresh_stat.nii.gz").touch() + + result = bids_summary(basedir, verbose=False) + + # Should find files in nested directories + assert result['orig']['thresh'] == 2 + + finally: + shutil.rmtree(tmpdir) + + +def test_bids_summary_return_structure(temp_summary_dir): + """Test that return structure is correct type.""" + result = bids_summary(temp_summary_dir, verbose=False) + + assert isinstance(result, dict) + for desc_key, type_dict in result.items(): + assert isinstance(desc_key, str) + assert isinstance(type_dict, dict) + for type_key, count in type_dict.items(): + assert isinstance(type_key, str) + assert isinstance(count, int) + assert count > 0 + diff --git a/uv.lock b/uv.lock index 259e282..bc7755a 100644 --- a/uv.lock +++ b/uv.lock @@ -29,6 +29,71 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/39/e8/806475fe4cdfd8635535d3fa11bd61d19b7cc94b61b9147ebdd2ab4cbbee/acres-0.5.0-py3-none-any.whl", hash = "sha256:fcc32b974b510897de0f041609b4234f9ff03e2e960aea088f63973fb106c772", size = 12703, upload-time = "2025-06-04T12:40:28.745Z" }, ] +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload-time = "2025-10-28T20:56:30.797Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload-time = "2025-10-28T20:56:32.708Z" }, + { url = "https://files.pythonhosted.org/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload-time = "2025-10-28T20:56:34.57Z" }, + { url = "https://files.pythonhosted.org/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload-time = "2025-10-28T20:56:36.377Z" }, + { url = "https://files.pythonhosted.org/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload-time = "2025-10-28T20:56:38.034Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload-time = "2025-10-28T20:56:39.75Z" }, + { url = "https://files.pythonhosted.org/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload-time = "2025-10-28T20:56:41.471Z" }, + { url = "https://files.pythonhosted.org/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload-time = "2025-10-28T20:56:43.162Z" }, + { url = "https://files.pythonhosted.org/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload-time = "2025-10-28T20:56:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload-time = "2025-10-28T20:56:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload-time = "2025-10-28T20:56:48.528Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload-time = "2025-10-28T20:56:50.77Z" }, + { url = "https://files.pythonhosted.org/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload-time = "2025-10-28T20:56:52.568Z" }, + { url = "https://files.pythonhosted.org/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload-time = "2025-10-28T20:56:54.292Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload-time = "2025-10-28T20:56:56.428Z" }, + { url = "https://files.pythonhosted.org/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload-time = "2025-10-28T20:56:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload-time = "2025-10-28T20:57:00.795Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + +[[package]] +name = "aiosqlite" +version = "0.22.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/0d/449c024bdabd0678ae07d804e60ed3b9786facd3add66f51eee67a0fccea/aiosqlite-0.22.0.tar.gz", hash = "sha256:7e9e52d72b319fcdeac727668975056c49720c995176dc57370935e5ba162bb9", size = 14707, upload-time = "2025-12-13T18:32:45.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/39/b2181148075272edfbbd6d87e6cd78cc71dca243446fa3b381fd4116950b/aiosqlite-0.22.0-py3-none-any.whl", hash = "sha256:96007fac2ce70eda3ca1bba7a3008c435258a592b8fbf2ee3eeaa36d33971a09", size = 17263, upload-time = "2025-12-13T18:32:44.619Z" }, +] + [[package]] name = "airium" version = "0.2.7" @@ -47,6 +112,40 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511, upload-time = "2024-01-10T00:56:08.388Z" }, ] +[[package]] +name = "alembic" +version = "1.17.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mako" }, + { name = "sqlalchemy" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/a6/74c8cadc2882977d80ad756a13857857dbcf9bd405bc80b662eb10651282/alembic-1.17.2.tar.gz", hash = "sha256:bbe9751705c5e0f14877f02d46c53d10885e377e3d90eda810a016f9baa19e8e", size = 1988064, upload-time = "2025-11-14T20:35:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/88/6237e97e3385b57b5f1528647addea5cc03d4d65d5979ab24327d41fb00d/alembic-1.17.2-py3-none-any.whl", hash = "sha256:f483dd1fe93f6c5d49217055e4d15b905b425b6af906746abb35b69c1996c4e6", size = 248554, upload-time = "2025-11-14T20:35:05.699Z" }, +] + +[[package]] +name = "anndata" +version = "0.12.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "array-api-compat" }, + { name = "h5py" }, + { name = "legacy-api-wrap" }, + { name = "natsort" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "scipy" }, + { name = "zarr" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/64/ea6da6d88c0b5ad3231828a8ab895cec871ff965e626e4986bc4dfae053d/anndata-0.12.7.tar.gz", hash = "sha256:10612d476e78570be2fdd391b09cb64d3b33cda32b1b46a0a4b999ba98d64d47", size = 2248853, upload-time = "2025-12-16T13:47:14.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/bc/dee9a01c1b9cd16d7e257644a2fc8ee6df6c685faaf68d289bdc4c91adec/anndata-0.12.7-py3-none-any.whl", hash = "sha256:bd7c18bdc2ed24b9089fd1494b52b787566dea175dde4689d4144693d0949581", size = 174195, upload-time = "2025-12-16T13:47:12.637Z" }, +] + [[package]] name = "annexremote" version = "1.6.6" @@ -74,6 +173,12 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, ] +[[package]] +name = "annoy" +version = "1.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/07/38/e321b0e05d8cc068a594279fb7c097efb1df66231c295d482d7ad51b6473/annoy-1.17.3.tar.gz", hash = "sha256:9cbfebefe0a5f843eba29c6be4c84d601f4f41ad4ded0486f1b88c3b07739c15", size = 647460, upload-time = "2023-06-14T16:37:34.152Z" } + [[package]] name = "anthropic" version = "0.75.0" @@ -130,6 +235,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, ] +[[package]] +name = "apprise" +version = "1.9.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "click" }, + { name = "markdown" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "requests-oauthlib" }, + { name = "tzdata", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/a7/bb182d81f35c3fe405505f0976da4b74f942cfdd53c7193b0fe50412aa27/apprise-1.9.6.tar.gz", hash = "sha256:4206be9cb5694a3d08dd8e0393bbb9b36212ac3a7769c2633620055e75c6caef", size = 1921714, upload-time = "2025-12-07T19:24:30.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/df/343d125241f8cd3c9af58fd09688cf2bf59cc1edfd609adafef3556ce8ec/apprise-1.9.6-py3-none-any.whl", hash = "sha256:2fd18e8a5251b6a12f6f9d169f1d895d458d1de36a5faee4db149cedcce51674", size = 1452059, upload-time = "2025-12-07T19:24:28.568Z" }, +] + [[package]] name = "argon2-cffi" version = "25.1.0" @@ -163,6 +286,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, ] +[[package]] +name = "argparse-dataclass" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/ff/a2e4e328075ddef2ac3c9431eb12247e4ba707a70324894f1e6b4f43c286/argparse_dataclass-2.0.0.tar.gz", hash = "sha256:09ab641c914a2f12882337b9c3e5086196dbf2ee6bf0ef67895c74002cc9297f", size = 6395, upload-time = "2023-06-11T20:32:54.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/66/e6c0a808950ba5a4042e2fcedd577fc7401536c7db063de4d7c36be06f84/argparse_dataclass-2.0.0-py3-none-any.whl", hash = "sha256:3ffc8852a88d9d98d1364b4441a712491320afb91fb56049afd8a51d74bb52d2", size = 8762, upload-time = "2023-06-11T20:32:52.724Z" }, +] + +[[package]] +name = "array-api-compat" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/bd/9fa5c7c5621698d5632cc852a79fbbdc28024462c9396698e5fdcb395f37/array_api_compat-1.12.0.tar.gz", hash = "sha256:585bc615f650de53ac24b7c012baecfcdd810f50df3573be47e6dd9fa20df974", size = 99883, upload-time = "2025-05-16T08:49:59.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/b1/0542e0cab6f49f151a2d7a42400f84f706fc0b64e85dc1f56708b2e9fd37/array_api_compat-1.12.0-py3-none-any.whl", hash = "sha256:a0b4795b6944a9507fde54679f9350e2ad2b1e2acf4a2408a098cdc27f890a8b", size = 58156, upload-time = "2025-05-16T08:49:58.129Z" }, +] + [[package]] name = "arrow" version = "1.4.0" @@ -176,6 +317,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" }, ] +[[package]] +name = "asgi-lifespan" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sniffio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/da/e7908b54e0f8043725a990bf625f2041ecf6bfe8eb7b19407f1c00b630f7/asgi-lifespan-2.1.0.tar.gz", hash = "sha256:5e2effaf0bfe39829cf2d64e7ecc47c7d86d676a6599f7afba378c31f5e3a308", size = 15627, upload-time = "2023-03-28T17:35:49.126Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/f5/c36551e93acba41a59939ae6a0fb77ddb3f2e8e8caa716410c65f7341f72/asgi_lifespan-2.1.0-py3-none-any.whl", hash = "sha256:ed840706680e28428c01e14afb3875d7d76d3206f3d5b2f2294e059b5c23804f", size = 10895, upload-time = "2023-03-28T17:35:47.772Z" }, +] + [[package]] name = "asttokens" version = "3.0.1" @@ -194,6 +347,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" }, ] +[[package]] +name = "asyncpg" +version = "0.31.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cc/d18065ce2380d80b1bcce927c24a2642efd38918e33fd724bc4bca904877/asyncpg-0.31.0.tar.gz", hash = "sha256:c989386c83940bfbd787180f2b1519415e2d3d6277a70d9d0f0145ac73500735", size = 993667, upload-time = "2025-11-24T23:27:00.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/a6/59d0a146e61d20e18db7396583242e32e0f120693b67a8de43f1557033e2/asyncpg-0.31.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b44c31e1efc1c15188ef183f287c728e2046abb1d26af4d20858215d50d91fad", size = 662042, upload-time = "2025-11-24T23:25:49.578Z" }, + { url = "https://files.pythonhosted.org/packages/36/01/ffaa189dcb63a2471720615e60185c3f6327716fdc0fc04334436fbb7c65/asyncpg-0.31.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0c89ccf741c067614c9b5fc7f1fc6f3b61ab05ae4aaa966e6fd6b93097c7d20d", size = 638504, upload-time = "2025-11-24T23:25:51.501Z" }, + { url = "https://files.pythonhosted.org/packages/9f/62/3f699ba45d8bd24c5d65392190d19656d74ff0185f42e19d0bbd973bb371/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:12b3b2e39dc5470abd5e98c8d3373e4b1d1234d9fbdedf538798b2c13c64460a", size = 3426241, upload-time = "2025-11-24T23:25:53.278Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d1/a867c2150f9c6e7af6462637f613ba67f78a314b00db220cd26ff559d532/asyncpg-0.31.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:aad7a33913fb8bcb5454313377cc330fbb19a0cd5faa7272407d8a0c4257b671", size = 3520321, upload-time = "2025-11-24T23:25:54.982Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1a/cce4c3f246805ecd285a3591222a2611141f1669d002163abef999b60f98/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3df118d94f46d85b2e434fd62c84cb66d5834d5a890725fe625f498e72e4d5ec", size = 3316685, upload-time = "2025-11-24T23:25:57.43Z" }, + { url = "https://files.pythonhosted.org/packages/40/ae/0fc961179e78cc579e138fad6eb580448ecae64908f95b8cb8ee2f241f67/asyncpg-0.31.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bd5b6efff3c17c3202d4b37189969acf8927438a238c6257f66be3c426beba20", size = 3471858, upload-time = "2025-11-24T23:25:59.636Z" }, + { url = "https://files.pythonhosted.org/packages/52/b2/b20e09670be031afa4cbfabd645caece7f85ec62d69c312239de568e058e/asyncpg-0.31.0-cp312-cp312-win32.whl", hash = "sha256:027eaa61361ec735926566f995d959ade4796f6a49d3bde17e5134b9964f9ba8", size = 527852, upload-time = "2025-11-24T23:26:01.084Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f0/f2ed1de154e15b107dc692262395b3c17fc34eafe2a78fc2115931561730/asyncpg-0.31.0-cp312-cp312-win_amd64.whl", hash = "sha256:72d6bdcbc93d608a1158f17932de2321f68b1a967a13e014998db87a72ed3186", size = 597175, upload-time = "2025-11-24T23:26:02.564Z" }, +] + [[package]] name = "attrs" version = "25.4.0" @@ -287,33 +456,46 @@ version = "0.1.0" source = { editable = "." } dependencies = [ { name = "accelerate" }, + { name = "anndata" }, { name = "anthropic" }, { name = "biopython" }, { name = "biothings-client" }, { name = "blue" }, { name = "chromadb" }, { name = "codespell" }, + { name = "dask" }, { name = "datalad" }, { name = "datalad-osf" }, { name = "docutils" }, + { name = "fastcluster" }, { name = "fastembed" }, { name = "fastparquet" }, + { name = "fmriprep-docker" }, { name = "gprofiler-official" }, + { name = "gseapy" }, { name = "h5py" }, + { name = "harmony-pytorch" }, + { name = "harmonypy" }, { name = "hypothesis" }, { name = "icecream" }, + { name = "igraph" }, + { name = "ipython" }, { name = "jupyter" }, { name = "jupyter-book" }, { name = "jupytext" }, - { name = "mariadb" }, + { name = "leidenalg" }, + { name = "linkcheckmd" }, { name = "matplotlib" }, { name = "mdnewline" }, + { name = "mne" }, { name = "monarch-py" }, + { name = "mongomock" }, { name = "mysql-connector-python" }, { name = "mystmd" }, { name = "neo4j" }, { name = "networkx" }, { name = "nibabel" }, + { name = "nilearn" }, { name = "numba" }, { name = "numpy" }, { name = "ols-client" }, @@ -321,6 +503,9 @@ dependencies = [ { name = "pandas" }, { name = "pickleshare" }, { name = "pre-commit" }, + { name = "prefect" }, + { name = "pyarrow" }, + { name = "pydeseq2" }, { name = "pygithub" }, { name = "pymongo" }, { name = "pyppeteer" }, @@ -331,55 +516,76 @@ dependencies = [ { name = "pyyaml" }, { name = "rpy2" }, { name = "ruff" }, + { name = "scanpy" }, { name = "scikit-learn" }, + { name = "scikit-misc" }, { name = "scipy" }, + { name = "scrublet" }, { name = "seaborn" }, + { name = "snakemake" }, { name = "statsmodels" }, { name = "templateflow" }, { name = "tomli" }, { name = "torch" }, { name = "tqdm" }, { name = "transformers" }, + { name = "xarray" }, { name = "zarr" }, ] [package.metadata] requires-dist = [ { name = "accelerate", specifier = ">=1.4.0" }, + { name = "anndata", specifier = ">=0.12.7" }, { name = "anthropic", specifier = ">=0.61.0" }, { name = "biopython", specifier = ">=1.86" }, { name = "biothings-client", specifier = ">=0.4.1" }, { name = "blue", specifier = ">=0.9.1" }, { name = "chromadb", specifier = ">=1.3.5" }, { name = "codespell", specifier = ">=2.4.1" }, + { name = "dask", specifier = ">=2025.12.0" }, { name = "datalad", specifier = ">=1.2.3" }, { name = "datalad-osf", specifier = ">=0.3.0" }, { name = "docutils", specifier = "==0.17.1" }, + { name = "fastcluster", specifier = ">=1.3.0" }, { name = "fastembed", specifier = ">=0.7.3" }, { name = "fastparquet", specifier = ">=2024.11.0" }, + { name = "fmriprep-docker", specifier = ">=25.2.3" }, { name = "gprofiler-official", specifier = ">=1.0.0" }, + { name = "gseapy", specifier = ">=1.1.11" }, { name = "h5py", specifier = ">=3.15.1" }, + { name = "harmony-pytorch", specifier = ">=0.1.8" }, + { name = "harmonypy", specifier = ">=0.0.10" }, { name = "hypothesis", specifier = ">=6.115.3" }, { name = "icecream", specifier = ">=2.1.4" }, + { name = "igraph", specifier = ">=1.0.0" }, + { name = "ipython", specifier = ">=9.8.0" }, { name = "jupyter", specifier = ">=1.1.1" }, { name = "jupyter-book", specifier = ">=1.0.2" }, { name = "jupytext", specifier = ">=1.16.4" }, - { name = "mariadb", specifier = ">=1.1.14" }, + { name = "leidenalg", specifier = ">=0.11.0" }, + { name = "linkcheckmd", specifier = ">=1.4.0" }, { name = "matplotlib", specifier = ">=3.9.2" }, { name = "mdnewline", specifier = ">=0.1.3" }, + { name = "mne", specifier = ">=1.11.0" }, { name = "monarch-py", specifier = ">=1.22.0" }, + { name = "mongomock", specifier = ">=4.3.0" }, { name = "mysql-connector-python", specifier = ">=9.5.0" }, { name = "mystmd", specifier = ">=1.7.0" }, { name = "neo4j", specifier = ">=6.0.3" }, { name = "networkx", specifier = ">=3.4.2" }, { name = "nibabel", specifier = ">=5.3.2" }, - { name = "numba", specifier = ">=0.61.0" }, + { name = "nilearn", specifier = ">=0.12.1" }, + { name = "numba", specifier = ">=0.61,<0.63" }, { name = "numpy", specifier = ">=2.1.2" }, { name = "ols-client", specifier = ">=0.2.1" }, { name = "openai", specifier = ">=1.51.2" }, { name = "pandas", specifier = ">=2.2.3" }, { name = "pickleshare", specifier = ">=0.7.5" }, { name = "pre-commit", specifier = ">=4.2.0" }, + { name = "prefect", specifier = ">=3.0" }, + { name = "pyarrow", specifier = ">=22.0.0" }, + { name = "pydeseq2", specifier = ">=0.5.3" }, { name = "pygithub", specifier = ">=2.4.0" }, { name = "pymongo", extras = ["srv"], specifier = ">=4.15.4" }, { name = "pyppeteer", specifier = ">=2.0.0" }, @@ -390,15 +596,20 @@ requires-dist = [ { name = "pyyaml", specifier = ">=6.0.2" }, { name = "rpy2", specifier = ">=3.6.4" }, { name = "ruff", specifier = ">=0.6.9" }, + { name = "scanpy", specifier = ">=1.11.5" }, { name = "scikit-learn", specifier = ">=1.5.2" }, + { name = "scikit-misc", specifier = ">=0.5.2" }, { name = "scipy", specifier = ">=1.14.1" }, + { name = "scrublet", specifier = ">=0.2.3" }, { name = "seaborn", specifier = ">=0.13.2" }, + { name = "snakemake", specifier = ">=8.0" }, { name = "statsmodels", specifier = ">=0.14.5" }, { name = "templateflow", specifier = ">=25.1.1" }, { name = "tomli", specifier = ">=2.2.1" }, { name = "torch", specifier = ">=2.6.0" }, { name = "tqdm", specifier = ">=4.66.5" }, { name = "transformers", specifier = ">=4.49.0" }, + { name = "xarray", specifier = ">=2025.12.0" }, { name = "zarr", specifier = ">=3.1.3" }, ] @@ -416,16 +627,16 @@ wheels = [ [[package]] name = "bidsschematools" -version = "1.1.3" +version = "1.1.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "acres" }, { name = "click" }, { name = "pyyaml" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f6/e4/98ecf10fb56d0967619c7d03e78a895adce7546f24d6af6008297f07ba74/bidsschematools-1.1.3.tar.gz", hash = "sha256:a3df5a4dfa085cd3acd00be2f0770019eaa5c4e6827763dad522d3ebef735b3a", size = 1754718, upload-time = "2025-11-18T12:50:59.759Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/1c/c9464d519150e88c1a5fdd298384313fff067405f58f08dcd9372561b933/bidsschematools-1.1.4.tar.gz", hash = "sha256:843b611050a2d294dde64e7774e0fb998f57cf96fe44127ac7e44b2bdaa3f750", size = 1757344, upload-time = "2025-12-19T01:06:54.75Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/40/e91d484e66e24c684baac044ff703c9a4cec833be00cad4b21e8cb9d8f8d/bidsschematools-1.1.3-py3-none-any.whl", hash = "sha256:01334729cb84bb7c0f7a4ee026debfd562fbabc52e5dce3029a1e08fa9b8cce4", size = 180659, upload-time = "2025-11-18T12:50:57.27Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/9f28c6637450c03ff0a950b92853262d65cc95fe9b595310483ec172a512/bidsschematools-1.1.4-py3-none-any.whl", hash = "sha256:8aa97c035ebff3d25b85a3e7554211e094333ff0887defeda4845d5477bd0394", size = 182396, upload-time = "2025-12-19T01:06:51.355Z" }, ] [[package]] @@ -543,30 +754,30 @@ wheels = [ [[package]] name = "boto3" -version = "1.42.8" +version = "1.42.14" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "botocore" }, { name = "jmespath" }, { name = "s3transfer" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9d/34/64e34fb40903d358a4a3d697e2ee4784a7b52c11e7effbad01967b2d3fc3/boto3-1.42.8.tar.gz", hash = "sha256:e967706af5887339407481562c389c612d5eae641eb854ddd59026d049df740e", size = 112886, upload-time = "2025-12-11T21:54:15.614Z" } +sdist = { url = "https://files.pythonhosted.org/packages/09/72/e236ca627bc0461710685f5b7438f759ef3b4106e0e08dda08513a6539ab/boto3-1.42.14.tar.gz", hash = "sha256:a5d005667b480c844ed3f814a59f199ce249d0f5669532a17d06200c0a93119c", size = 112825, upload-time = "2025-12-19T20:27:15.325Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/37/9702c0b8e63aaeb1ad430ece22567b03e58ea41e446d68b92e2cb00e7817/boto3-1.42.8-py3-none-any.whl", hash = "sha256:747acc83488fc80b0e7d1c4ff0c533039ff3ede21bdbd4e89544e25b010b070c", size = 140559, upload-time = "2025-12-11T21:54:14.513Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ba/c657ea6f6d63563cc46748202fccd097b51755d17add00ebe4ea27580d06/boto3-1.42.14-py3-none-any.whl", hash = "sha256:bfcc665227bb4432a235cb4adb47719438d6472e5ccbf7f09512046c3f749670", size = 140571, upload-time = "2025-12-19T20:27:13.316Z" }, ] [[package]] name = "botocore" -version = "1.42.8" +version = "1.42.14" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jmespath" }, { name = "python-dateutil" }, { name = "urllib3" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3a/ea/4be7a4a640d599b5691c7cf27e125155d7d3643ecbe37e32941f412e3de5/botocore-1.42.8.tar.gz", hash = "sha256:4921aa454f82fed0880214eab21126c98a35fe31ede952693356f9c85ce3574b", size = 14861038, upload-time = "2025-12-11T21:54:04.031Z" } +sdist = { url = "https://files.pythonhosted.org/packages/35/3f/50c56f093c2c6ce6de1f579726598db1cf9a9cccd3bf8693f73b1cf5e319/botocore-1.42.14.tar.gz", hash = "sha256:cf5bebb580803c6cfd9886902ca24834b42ecaa808da14fb8cd35ad523c9f621", size = 14910547, upload-time = "2025-12-19T20:27:04.431Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1c/24/a4301564a979368d6f3644f47acc921450b5524b8846e827237d98b04746/botocore-1.42.8-py3-none-any.whl", hash = "sha256:4cb89c74dd9083d16e45868749b999265a91309b2499907c84adeffa0a8df89b", size = 14534173, upload-time = "2025-12-11T21:54:01.143Z" }, + { url = "https://files.pythonhosted.org/packages/ad/94/67a78a8d08359e779894d4b1672658a3c7fcce216b48f06dfbe1de45521d/botocore-1.42.14-py3-none-any.whl", hash = "sha256:efe89adfafa00101390ec2c371d453b3359d5f9690261bc3bd70131e0d453e8e", size = 14583247, upload-time = "2025-12-19T20:27:00.54Z" }, ] [[package]] @@ -585,11 +796,11 @@ wheels = [ [[package]] name = "cachetools" -version = "6.2.2" +version = "5.5.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload-time = "2025-11-13T17:42:51.465Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380, upload-time = "2025-02-20T21:01:19.524Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload-time = "2025-11-13T17:42:50.232Z" }, + { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080, upload-time = "2025-02-20T21:01:16.647Z" }, ] [[package]] @@ -700,7 +911,7 @@ wheels = [ [[package]] name = "chromadb" -version = "1.3.6" +version = "1.3.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "bcrypt" }, @@ -731,13 +942,13 @@ dependencies = [ { name = "typing-extensions" }, { name = "uvicorn", extra = ["standard"] }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c0/5c/c8d751b327f863c11cc51e4cd01750696bacdc65b291beda8b008917910e/chromadb-1.3.6.tar.gz", hash = "sha256:834d7d154471b36bed10ddb53fcc96dfa912d18f0d57418490d829f7aad59895", size = 1959127, upload-time = "2025-12-10T05:25:22.644Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/b9/23eb242c0bad56bcac57d9f45a6cc85e016a44ae9baf763c0d040e45e2d7/chromadb-1.3.7.tar.gz", hash = "sha256:393b866b6ac60c12fc0f2a43d07b2884f2d02a68a1b2cb43c5ef87d141543571", size = 1960950, upload-time = "2025-12-12T21:03:13.941Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/6d/2a09221575a4fd7b6356c1416160d491fccd38ab6b24eee7df030552a7ac/chromadb-1.3.6-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d80b9621af6dfdd23a4aced8e33f667ab41e8252c2a1c4f46eb27acbbb67fe48", size = 20782782, upload-time = "2025-12-10T05:25:20.205Z" }, - { url = "https://files.pythonhosted.org/packages/bf/8e/528f64a8ec1e32b9d079c77572e0e8301e1fb461474fefca6bce7ce90f8e/chromadb-1.3.6-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1dee1987755d1dc920d9608f76eedb0f70ae06ade020d462f3265b290ca05b65", size = 20078289, upload-time = "2025-12-10T05:25:17.621Z" }, - { url = "https://files.pythonhosted.org/packages/33/1c/07bb66f9d8f243ae232fa9f73bcb63ae1386dc327cfa085feca7365c34ad/chromadb-1.3.6-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1a59a2ef5121b0321ce1ffcdf84dfa1f11fba7c6734fe6b3b22a22c9c531314", size = 20703285, upload-time = "2025-12-10T05:25:11.594Z" }, - { url = "https://files.pythonhosted.org/packages/4b/5d/210639c32d3f6f49b265c84990be5da1bb6e1b2fd31f9845abec4580e3ba/chromadb-1.3.6-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f98ee1e180c11aaf33f0aed11a54f385def8361931fcab8c876e56e94f02699", size = 21633675, upload-time = "2025-12-10T05:25:14.759Z" }, - { url = "https://files.pythonhosted.org/packages/59/91/bf5dfa3bd5b457a9195439e077128c274202b1a231bd3a9d4d7f3c2259a3/chromadb-1.3.6-cp39-abi3-win_amd64.whl", hash = "sha256:cde42db6c3b31b7edf75bbf60447cd83e9693fe08d2005496ae418c05cae9b3f", size = 21870402, upload-time = "2025-12-10T05:25:24.475Z" }, + { url = "https://files.pythonhosted.org/packages/b6/9d/306e220cfb4382e9f29e645339826d1deec64c34cf905c344d0d7345dbdb/chromadb-1.3.7-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:74839c349a740b8e349fabc569f8f4becae9806fa8ff9ca186797bef1f54ee4c", size = 20816599, upload-time = "2025-12-12T21:03:11.173Z" }, + { url = "https://files.pythonhosted.org/packages/51/3e/0fbb4c6e7971019c976cf3dbef1c22c1a3089f74ef86c88e2e066edc47e4/chromadb-1.3.7-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:fe9c96f73450274d9f722572afc9d455b4f6f4cd960fa49e4bf489075ef30e6f", size = 20113076, upload-time = "2025-12-12T21:03:07.873Z" }, + { url = "https://files.pythonhosted.org/packages/69/78/2ae4064c9b194271b9c2bc66a26a7e11363d13ed2bd691a563fac1a7c5f2/chromadb-1.3.7-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:972cb168033db76a4bb1031bc38b6cc4e6d05ef716c1ffce8ae95a1a3b515dd2", size = 20738619, upload-time = "2025-12-12T21:03:01.409Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/3aa34cb02c3c0e4920a47da5d9092cab690fcbf6df13ec744eacf96891d6/chromadb-1.3.7-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e05190236e309b54165866dd11676c2702a35b73beaa29502741f22f333c51a", size = 21654395, upload-time = "2025-12-12T21:03:04.909Z" }, + { url = "https://files.pythonhosted.org/packages/00/36/7d2d7b6bb26e53214492d71ccb4e128fa2de4d98a215befb7787deaf2701/chromadb-1.3.7-cp39-abi3-win_amd64.whl", hash = "sha256:4618ba7bb5ef5dbf0d4fd9ce708b912d8cd1ab24d3c81e0e092841f325b2c94d", size = 21874973, upload-time = "2025-12-12T21:03:16.918Z" }, ] [[package]] @@ -754,14 +965,14 @@ wheels = [ [[package]] name = "click" -version = "8.3.1" +version = "8.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" }, ] [[package]] @@ -773,6 +984,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ae/8a/c4bb04426d608be4a3171efa2e233d2c59a5c8937850c10d098e126df18e/cloudpathlib-0.23.0-py3-none-any.whl", hash = "sha256:8520b3b01468fee77de37ab5d50b1b524ea6b4a8731c35d1b7407ac0cd716002", size = 62755, upload-time = "2025-10-07T22:47:54.905Z" }, ] +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, +] + [[package]] name = "codespell" version = "2.4.1" @@ -812,6 +1032,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, ] +[[package]] +name = "conda-inject" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/a8/8dc86113c65c949cc72d651461d6e4c544b3302a85ed14a5298829e6a419/conda_inject-1.3.2.tar.gz", hash = "sha256:0b8cde8c47998c118d8ff285a04977a3abcf734caf579c520fca469df1cd0aac", size = 3635, upload-time = "2024-05-27T12:20:58.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/4c/fc30b69fb4062aee57e3ab7ff493647c4220144908f0839c619f912045bf/conda_inject-1.3.2-py3-none-any.whl", hash = "sha256:6e641b408980c2814e3e527008c30749117909a21ff47392f07ef807da93a564", size = 4133, upload-time = "2024-05-27T12:20:57.332Z" }, +] + [[package]] name = "confection" version = "0.1.5" @@ -825,6 +1057,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0c/00/3106b1854b45bd0474ced037dfe6b73b90fe68a68968cef47c23de3d43d2/confection-0.1.5-py3-none-any.whl", hash = "sha256:e29d3c3f8eac06b3f77eb9dfb4bf2fc6bcc9622a98ca00a698e3d019c6430b14", size = 35451, upload-time = "2024-05-31T16:16:59.075Z" }, ] +[[package]] +name = "configargparse" +version = "1.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/4d/6c9ef746dfcc2a32e26f3860bb4a011c008c392b83eabdfb598d1a8bbe5d/configargparse-1.7.1.tar.gz", hash = "sha256:79c2ddae836a1e5914b71d58e4b9adbd9f7779d4e6351a637b7d2d9b6c46d3d9", size = 43958, upload-time = "2025-05-23T14:26:17.369Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/28/d28211d29bcc3620b1fece85a65ce5bb22f18670a03cd28ea4b75ede270c/configargparse-1.7.1-py3-none-any.whl", hash = "sha256:8b586a31f9d873abd1ca527ffbe58863c99f36d896e2829779803125e83be4b6", size = 25607, upload-time = "2025-05-23T14:26:15.923Z" }, +] + +[[package]] +name = "connection-pool" +version = "0.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/df/c9b4e25dce00f6349fd28aadba7b6c3f7431cc8bd4308a158fbe57b6a22e/connection_pool-0.0.3.tar.gz", hash = "sha256:bf429e7aef65921c69b4ed48f3d48d3eac1383b05d2df91884705842d974d0dc", size = 3795, upload-time = "2020-09-17T02:48:28.824Z" } + [[package]] name = "contourpy" version = "1.3.3" @@ -847,6 +1094,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, ] +[[package]] +name = "coolname" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/c6/1eaa4495ff4640e80d9af64f540e427ba1596a20f735d4c4750fe0386d07/coolname-2.2.0.tar.gz", hash = "sha256:6c5d5731759104479e7ca195a9b64f7900ac5bead40183c09323c7d0be9e75c7", size = 59006, upload-time = "2023-01-09T14:50:41.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/b1/5745d7523d8ce53b87779f46ef6cf5c5c342997939c2fe967e607b944e43/coolname-2.2.0-py2.py3-none-any.whl", hash = "sha256:4d1563186cfaf71b394d5df4c744f8c41303b6846413645e31d31915cdeb13e8", size = 37849, upload-time = "2023-01-09T14:50:39.897Z" }, +] + [[package]] name = "coverage" version = "7.13.0" @@ -935,15 +1191,15 @@ wheels = [ [[package]] name = "curies" -version = "0.12.5" +version = "0.12.6" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a9/4c/fc5d51c21b99f802948a8b3079565806239c76e7b2f1f6702a603fe282f7/curies-0.12.5.tar.gz", hash = "sha256:57e4853045f8029c2564fbf2290221ff7a529034405076d1e82b7a8727b33dfc", size = 282912, upload-time = "2025-11-25T12:47:24.825Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/48/f2d73a4b266c7407af39a8f6d397bce7260627802d1bdf88ab3745a89408/curies-0.12.6.tar.gz", hash = "sha256:fe16fd217dadc7f85e80137ae303ba6afc35abaeeadb2730b45de01433843248", size = 283201, upload-time = "2025-12-17T11:42:18.316Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/dd/29000adb47118edbf865a6e366fba294dcdacdf34322cedb23b8e7d30ae0/curies-0.12.5-py3-none-any.whl", hash = "sha256:e7fbb63cb49aeb389d46db64dae02f1563741084e033c2075cd1e163fdb1ead8", size = 69711, upload-time = "2025-11-25T12:47:23.058Z" }, + { url = "https://files.pythonhosted.org/packages/de/b5/2a7682e76e011ea56547f7adf0bddd4cc151caab2183355773d069368e55/curies-0.12.6-py3-none-any.whl", hash = "sha256:64568d18d547daeca82f96e24acf7b829ae62c7a7ee875f9d178f7f59871f321", size = 69950, upload-time = "2025-12-17T11:42:16.427Z" }, ] [[package]] @@ -971,6 +1227,46 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/94/fb/1b681635bfd5f2274d0caa8f934b58435db6c091b97f5593738065ddb786/cymem-2.0.13-cp312-cp312-win_arm64.whl", hash = "sha256:6bbd701338df7bf408648191dff52472a9b334f71bcd31a21a41d83821050f67", size = 35959, upload-time = "2025-11-14T14:57:41.682Z" }, ] +[[package]] +name = "cython" +version = "3.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/e1/c0d92b1258722e1bc62a12e630c33f1f842fdab53fd8cd5de2f75c6449a9/cython-3.2.3.tar.gz", hash = "sha256:f13832412d633376ffc08d751cc18ed0d7d00a398a4065e2871db505258748a6", size = 3276650, upload-time = "2025-12-14T07:50:34.691Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b4/14/d16282d17c9eb2f78ca9ccd5801fed22f6c3360f5a55dbcce3c93cc70352/cython-3.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cf210228c15b5c625824d8e31d43b6fea25f9e13c81dac632f2f7d838e0229a5", size = 2968471, upload-time = "2025-12-14T07:51:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3c/46304a942dac5a636701c55f5b05ec00ad151e6722cd068fe3d0993349bb/cython-3.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5bf0cebeb4147e172a114437d3fce5a507595d8fdd821be792b1bb25c691514", size = 3223581, upload-time = "2025-12-14T07:51:04.336Z" }, + { url = "https://files.pythonhosted.org/packages/29/ad/15da606d71f40bcf2c405f84ca3d4195cb252f4eaa2f551fe6b2e630ee7c/cython-3.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1f8700ba89c977438744f083890d87187f15709507a5489e0f6d682053b7fa0", size = 3391391, upload-time = "2025-12-14T07:51:05.998Z" }, + { url = "https://files.pythonhosted.org/packages/51/9e/045b35eb678682edc3e2d57112cf5ac3581a9ef274eb220b638279195678/cython-3.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:25732f3981a93407826297f4423206e5e22c3cfccfc74e37bf444453bbdc076f", size = 2756814, upload-time = "2025-12-14T07:51:07.759Z" }, + { url = "https://files.pythonhosted.org/packages/43/49/afe1e3df87a770861cf17ba39f4a91f6d22a2571010fc1890b3708360630/cython-3.2.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:74f482da8b605c61b4df6ff716d013f20131949cb2fa59b03e63abd36ef5bac0", size = 2874467, upload-time = "2025-12-14T07:51:31.568Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/044f725a083e28fb4de5bd33d13ec13f0753734b6ae52d4bc07434610cc8/cython-3.2.3-cp39-abi3-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0a75a04688875b275a6c875565e672325bae04327dd6ec2fc25aeb5c6cf82fce", size = 3211272, upload-time = "2025-12-14T07:51:33.673Z" }, + { url = "https://files.pythonhosted.org/packages/95/14/af02ba6e2e03279f2ca2956e3024a44faed4c8496bda8170b663dc3ba6e8/cython-3.2.3-cp39-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b01b36c9eb1b68c25bddbeef7379f7bfc37f7c9afc044e71840ffab761a2dd0", size = 2856058, upload-time = "2025-12-14T07:51:36.015Z" }, + { url = "https://files.pythonhosted.org/packages/69/16/d254359396c2f099ab154f89b2b35f5b8b0dd21a8102c2c96a7e00291434/cython-3.2.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3829f99d611412288f44ff543e9d2b5c0c83274998b2a6680bbe5cca3539c1fd", size = 2993276, upload-time = "2025-12-14T07:51:37.863Z" }, + { url = "https://files.pythonhosted.org/packages/51/0e/1a071381923e896f751f8fbff2a01c5dc8860a8b9a90066f6ec8df561dc4/cython-3.2.3-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c2365a0c79ab9c0fa86d30a4a6ba7e37fc1be9537c48b79b9d63ee7e08bf2fef", size = 2890843, upload-time = "2025-12-14T07:51:40.409Z" }, + { url = "https://files.pythonhosted.org/packages/f4/46/1e93e10766db988e6bb8e5c6f7e2e90b9e62f1ac8dee4c1a6cf1fc170773/cython-3.2.3-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3141734fb15f8b5e9402b9240f8da8336edecae91742b41c85678c31ab68f66d", size = 3225339, upload-time = "2025-12-14T07:51:42.09Z" }, + { url = "https://files.pythonhosted.org/packages/d4/ae/c284b06ae6a9c95d5883bf8744d10466cf0df64cef041a4c80ccf9fd07bd/cython-3.2.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9a24cc653fad3adbd9cbaa638d80df3aa08a1fe27f62eb35850971c70be680df", size = 3114751, upload-time = "2025-12-14T07:51:44.088Z" }, + { url = "https://files.pythonhosted.org/packages/c6/d6/7795a4775c70256217134195f06b07233cf17b00f8905d5b3d782208af64/cython-3.2.3-cp39-abi3-win32.whl", hash = "sha256:b39dff92db70cbd95528f3b81d70e06bd6d3fc9c1dd91321e4d3b999ece3bceb", size = 2435616, upload-time = "2025-12-14T07:51:46.063Z" }, + { url = "https://files.pythonhosted.org/packages/18/9e/2a3edcb858ad74e6274448dccf32150c532bc6e423f112a71f65ff3b5680/cython-3.2.3-cp39-abi3-win_arm64.whl", hash = "sha256:18edc858e6a52de47fe03ffa97ea14dadf450e20069de0a8aef531006c4bbd93", size = 2440952, upload-time = "2025-12-14T07:51:47.943Z" }, + { url = "https://files.pythonhosted.org/packages/e5/41/54fd429ff8147475fc24ca43246f85d78fb4e747c27f227e68f1594648f1/cython-3.2.3-py3-none-any.whl", hash = "sha256:06a1317097f540d3bb6c7b81ed58a0d8b9dbfa97abf39dfd4c22ee87a6c7241e", size = 1255561, upload-time = "2025-12-14T07:50:31.217Z" }, +] + +[[package]] +name = "dask" +version = "2025.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "cloudpickle" }, + { name = "fsspec" }, + { name = "packaging" }, + { name = "partd" }, + { name = "pyyaml" }, + { name = "toolz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/ae/92fca08ff8fe3e8413842564dd55ee30c9cd9e07629e1bf4d347b005a5bf/dask-2025.12.0.tar.gz", hash = "sha256:8d478f2aabd025e2453cf733ad64559de90cf328c20209e4574e9543707c3e1b", size = 10995316, upload-time = "2025-12-12T14:59:10.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/3a/2121294941227c548d4b5f897a8a1b5f4c44a58f5437f239e6b86511d78e/dask-2025.12.0-py3-none-any.whl", hash = "sha256:4213ce9c5d51d6d89337cff69de35d902aa0bf6abdb8a25c942a4d0281f3a598", size = 1481293, upload-time = "2025-12-12T14:58:59.32Z" }, +] + [[package]] name = "datalad" version = "1.2.3" @@ -1030,17 +1326,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/53/ee/e97f37023938022e38d3abb28058191025c7a2cb240210e7e016f21fee72/datalad_osf-0.3.0-py2.py3-none-any.whl", hash = "sha256:2cdc42ac3015d0734ac1f386a2f09fe2bfd2bad56e2035ebcce87a378b0ec209", size = 26384, upload-time = "2023-06-09T09:45:40.014Z" }, ] +[[package]] +name = "dateparser" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "regex" }, + { name = "tzlocal" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/30/064144f0df1749e7bb5faaa7f52b007d7c2d08ec08fed8411aba87207f68/dateparser-1.2.2.tar.gz", hash = "sha256:986316f17cb8cdc23ea8ce563027c5ef12fc725b6fb1d137c14ca08777c5ecf7", size = 329840, upload-time = "2025-06-26T09:29:23.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/22/f020c047ae1346613db9322638186468238bcfa8849b4668a22b97faad65/dateparser-1.2.2-py3-none-any.whl", hash = "sha256:5a5d7211a09013499867547023a2a0c91d5a27d15dd4dbcea676ea9fe66f2482", size = 315453, upload-time = "2025-06-26T09:29:21.412Z" }, +] + [[package]] name = "debugpy" -version = "1.8.18" +version = "1.8.19" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/62/1a/7cb5531840d7ba5d9329644109e62adee41f2f0083d9f8a4039f01de58cf/debugpy-1.8.18.tar.gz", hash = "sha256:02551b1b84a91faadd2db9bc4948873f2398190c95b3cc6f97dc706f43e8c433", size = 1644467, upload-time = "2025-12-10T19:48:07.236Z" } +sdist = { url = "https://files.pythonhosted.org/packages/73/75/9e12d4d42349b817cd545b89247696c67917aab907012ae5b64bbfea3199/debugpy-1.8.19.tar.gz", hash = "sha256:eea7e5987445ab0b5ed258093722d5ecb8bb72217c5c9b1e21f64efe23ddebdb", size = 1644590, upload-time = "2025-12-15T21:53:28.044Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/83/01/439626e3572a33ac543f25bc1dac1e80bc01c7ce83f3c24dc4441302ca13/debugpy-1.8.18-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:530c38114725505a7e4ea95328dbc24aabb9be708c6570623c8163412e6d1d6b", size = 2549961, upload-time = "2025-12-10T19:48:21.73Z" }, - { url = "https://files.pythonhosted.org/packages/cd/73/1eeaa15c20a2b627be57a65bc1ebf2edd8d896950eac323588b127d776f2/debugpy-1.8.18-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:a114865099283cbed4c9330cb0c9cb7a04cfa92e803577843657302d526141ec", size = 4309855, upload-time = "2025-12-10T19:48:23.41Z" }, - { url = "https://files.pythonhosted.org/packages/e4/6f/2da8ded21ae55df7067e57bd7f67ffed7e08b634f29bdba30c03d3f19918/debugpy-1.8.18-cp312-cp312-win32.whl", hash = "sha256:4d26736dfabf404e9f3032015ec7b0189e7396d0664e29e5bdbe7ac453043c95", size = 5280577, upload-time = "2025-12-10T19:48:25.386Z" }, - { url = "https://files.pythonhosted.org/packages/f5/8e/ebe887218c5b84f9421de7eb7bb7cdf196e84535c3f504a562219297d755/debugpy-1.8.18-cp312-cp312-win_amd64.whl", hash = "sha256:7e68ba950acbcf95ee862210133681f408cbb78d1c9badbb515230ec55ed6487", size = 5322458, upload-time = "2025-12-10T19:48:28.049Z" }, - { url = "https://files.pythonhosted.org/packages/dc/0d/bf7ac329c132436c57124202b5b5ccd6366e5d8e75eeb184cf078c826e8d/debugpy-1.8.18-py2.py3-none-any.whl", hash = "sha256:ab8cf0abe0fe2dfe1f7e65abc04b1db8740f9be80c1274acb625855c5c3ece6e", size = 5286576, upload-time = "2025-12-10T19:48:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/4a/15/d762e5263d9e25b763b78be72dc084c7a32113a0bac119e2f7acae7700ed/debugpy-1.8.19-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:bccb1540a49cde77edc7ce7d9d075c1dbeb2414751bc0048c7a11e1b597a4c2e", size = 2549995, upload-time = "2025-12-15T21:53:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/a7/88/f7d25c68b18873b7c53d7c156ca7a7ffd8e77073aa0eac170a9b679cf786/debugpy-1.8.19-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:e9c68d9a382ec754dc05ed1d1b4ed5bd824b9f7c1a8cd1083adb84b3c93501de", size = 4309891, upload-time = "2025-12-15T21:53:45.26Z" }, + { url = "https://files.pythonhosted.org/packages/c5/4f/a65e973aba3865794da65f71971dca01ae66666132c7b2647182d5be0c5f/debugpy-1.8.19-cp312-cp312-win32.whl", hash = "sha256:6599cab8a783d1496ae9984c52cb13b7c4a3bd06a8e6c33446832a5d97ce0bee", size = 5286355, upload-time = "2025-12-15T21:53:46.763Z" }, + { url = "https://files.pythonhosted.org/packages/d8/3a/d3d8b48fec96e3d824e404bf428276fb8419dfa766f78f10b08da1cb2986/debugpy-1.8.19-cp312-cp312-win_amd64.whl", hash = "sha256:66e3d2fd8f2035a8f111eb127fa508469dfa40928a89b460b41fd988684dc83d", size = 5328239, upload-time = "2025-12-15T21:53:48.868Z" }, + { url = "https://files.pythonhosted.org/packages/25/3e/e27078370414ef35fafad2c06d182110073daaeb5d3bf734b0b1eeefe452/debugpy-1.8.19-py2.py3-none-any.whl", hash = "sha256:360ffd231a780abbc414ba0f005dad409e71c78637efe8f2bd75837132a41d38", size = 5292321, upload-time = "2025-12-15T21:54:16.024Z" }, ] [[package]] @@ -1162,6 +1473,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0c/d5/c5db1ea3394c6e1732fb3286b3bd878b59507a8f77d32a2cebda7d7b7cd4/donfig-0.8.1.post1-py3-none-any.whl", hash = "sha256:2a3175ce74a06109ff9307d90a230f81215cbac9a751f4d1c6194644b8204f9d", size = 21592, upload-time = "2024-05-23T14:13:55.283Z" }, ] +[[package]] +name = "dpath" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/ce/e1fd64d36e4a5717bd5e6b2ad188f5eaa2e902fde871ea73a79875793fc9/dpath-2.2.0.tar.gz", hash = "sha256:34f7e630dc55ea3f219e555726f5da4b4b25f2200319c8e6902c394258dd6a3e", size = 28266, upload-time = "2024-06-12T22:08:03.686Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/d1/8952806fbf9583004ab479d8f58a9496c3d35f6b6009ddd458bdd9978eaf/dpath-2.2.0-py3-none-any.whl", hash = "sha256:b330a375ded0a0d2ed404440f6c6a715deae5313af40bbb01c8a41d891900576", size = 17618, upload-time = "2024-06-12T22:08:01.881Z" }, +] + [[package]] name = "durationpy" version = "0.10" @@ -1193,6 +1513,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/26/b5/d343da782460999bd3e7c3c367b91d7b77f2eaf424bff7b315ce72bb4e54/eutils-0.6.1-py3-none-any.whl", hash = "sha256:6916efd10f397f20ba0e6bd5b84d4e868e077161509e240d7c4ab1d98fb2d3b1", size = 40910, upload-time = "2025-12-07T23:33:43.053Z" }, ] +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + [[package]] name = "executing" version = "2.2.1" @@ -1204,7 +1536,7 @@ wheels = [ [[package]] name = "fastapi" -version = "0.124.4" +version = "0.127.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-doc" }, @@ -1212,9 +1544,26 @@ dependencies = [ { name = "starlette" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cd/21/ade3ff6745a82ea8ad88552b4139d27941549e4f19125879f848ac8f3c3d/fastapi-0.124.4.tar.gz", hash = "sha256:0e9422e8d6b797515f33f500309f6e1c98ee4e85563ba0f2debb282df6343763", size = 378460, upload-time = "2025-12-12T15:00:43.891Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0c/02/2cbbecf6551e0c1a06f9b9765eb8f7ae126362fbba43babbb11b0e3b7db3/fastapi-0.127.0.tar.gz", hash = "sha256:5a9246e03dcd1fdb19f1396db30894867c1d630f5107dc167dcbc5ed1ea7d259", size = 369269, upload-time = "2025-12-21T16:47:16.393Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/fa/6a27e2ef789eb03060abb43b952a7f0bd39e6feaa3805362b48785bcedc5/fastapi-0.127.0-py3-none-any.whl", hash = "sha256:725aa2bb904e2eff8031557cf4b9b77459bfedd63cae8427634744fd199f6a49", size = 112055, upload-time = "2025-12-21T16:47:14.757Z" }, +] + +[[package]] +name = "fastcluster" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/41/1e/417892546cb92e71f5bcaeffc8d89b47716fd811805a8ae559b91f754015/fastcluster-1.3.0.tar.gz", hash = "sha256:d5233aeba5c3faa949c7fa6a39345a09f716ccebbd748541e5735c866696df02", size = 173065, upload-time = "2025-05-06T17:45:30.101Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3e/57/aa70121b5008f44031be645a61a7c4abc24e0e888ad3fc8fda916f4d188e/fastapi-0.124.4-py3-none-any.whl", hash = "sha256:6d1e703698443ccb89e50abe4893f3c84d9d6689c0cf1ca4fad6d3c15cf69f15", size = 113281, upload-time = "2025-12-12T15:00:42.44Z" }, + { url = "https://files.pythonhosted.org/packages/41/dc/b43081c5f4c1441b46e847adee464cea22dbb106891437b4a2d41a81f59a/fastcluster-1.3.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b20785852abb0ba5af62316327b654cea0fd736f819cd48792de0875ffb485f0", size = 62799, upload-time = "2025-05-06T17:45:15.084Z" }, + { url = "https://files.pythonhosted.org/packages/fe/77/d1cf1f6e6c83c11ebcf4d378a5ea566d30b50e240477f695e33a9b88698b/fastcluster-1.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6be2e33529917df1398f5d85ea55856ebddd81041b0fbe2dfc6badcb0c3b2054", size = 38879, upload-time = "2025-05-06T17:45:16.649Z" }, + { url = "https://files.pythonhosted.org/packages/e5/69/0bf77416d2fba60d773039eb236c6fcf64384236c58e63b5a2120e803af3/fastcluster-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1ddd6df989ee9ced20c4ecd7cef8df421a10b5410913385bb29d9183d21cc5ee", size = 34778, upload-time = "2025-05-06T17:45:17.646Z" }, + { url = "https://files.pythonhosted.org/packages/db/36/bc720b34d27bcb40024d63692e1f30a4e9402670881121755c5a1fb5e5c8/fastcluster-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0d22a99d2fef1d7a314650e0f5fc78d4f91d4b233e5aa81b31da45506d25f21", size = 184385, upload-time = "2025-05-06T17:45:18.697Z" }, + { url = "https://files.pythonhosted.org/packages/27/eb/df607b9e505fc105539977c7da68af06a448d6dfb86355ff2b839c775fbe/fastcluster-1.3.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:428126288895fcb6316a239635bafaa19e4677240afee2723a952e488929091d", size = 194095, upload-time = "2025-05-06T17:45:20.378Z" }, + { url = "https://files.pythonhosted.org/packages/d0/63/e6ffa0b2cc9d708f9ab6eb4dd22fc843d64002e7cf9b2bc1ca6ec6df0dd7/fastcluster-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:317db2531895cdf178a3009d3a8b13dfa83a5ed4ab14943b33377174cf9420cf", size = 37350, upload-time = "2025-05-06T17:45:22.018Z" }, ] [[package]] @@ -1271,7 +1620,7 @@ wheels = [ [[package]] name = "fastparquet" -version = "2024.11.0" +version = "2025.12.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cramjam" }, @@ -1280,25 +1629,24 @@ dependencies = [ { name = "packaging" }, { name = "pandas" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b4/66/862da14f5fde4eff2cedc0f51a8dc34ba145088e5041b45b2d57ac54f922/fastparquet-2024.11.0.tar.gz", hash = "sha256:e3b1fc73fd3e1b70b0de254bae7feb890436cb67e99458b88cb9bd3cc44db419", size = 467192, upload-time = "2024-11-15T19:30:10.413Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/ad/87f7f5750685e8e0a359d732c85332481ba9b5723af579f8755f81154d0b/fastparquet-2025.12.0.tar.gz", hash = "sha256:85f807d3846c7691855a68ed7ff6ee40654b72b997f5b1199e6310a1e19d1cd5", size = 480045, upload-time = "2025-12-18T16:22:22.016Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/08/76/068ac7ec9b4fc783be21a75a6a90b8c0654da4d46934d969e524ce287787/fastparquet-2024.11.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dbad4b014782bd38b58b8e9f514fe958cfa7a6c4e187859232d29fd5c5ddd849", size = 915968, upload-time = "2024-11-12T20:37:52.861Z" }, - { url = "https://files.pythonhosted.org/packages/c7/9e/6d3b4188ad64ed51173263c07109a5f18f9c84a44fa39ab524fca7420cda/fastparquet-2024.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:403d31109d398b6be7ce84fa3483fc277c6a23f0b321348c0a505eb098a041cb", size = 685399, upload-time = "2024-11-12T20:37:54.899Z" }, - { url = "https://files.pythonhosted.org/packages/8f/6c/809220bc9fbe83d107df2d664c3fb62fb81867be8f5218ac66c2e6b6a358/fastparquet-2024.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cbbb9057a26acf0abad7adf58781ee357258b7708ee44a289e3bee97e2f55d42", size = 1758557, upload-time = "2024-11-12T20:37:56.553Z" }, - { url = "https://files.pythonhosted.org/packages/e0/2c/b3b3e6ca2e531484289024138cd4709c22512b3fe68066d7f9849da4a76c/fastparquet-2024.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63e0e416e25c15daa174aad8ba991c2e9e5b0dc347e5aed5562124261400f87b", size = 1781052, upload-time = "2024-11-12T20:37:58.339Z" }, - { url = "https://files.pythonhosted.org/packages/21/fe/97ed45092d0311c013996dae633122b7a51c5d9fe8dcbc2c840dc491201e/fastparquet-2024.11.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e2d7f02f57231e6c86d26e9ea71953737202f20e948790e5d4db6d6a1a150dc", size = 1715797, upload-time = "2024-11-12T20:38:00.694Z" }, - { url = "https://files.pythonhosted.org/packages/24/df/02fa6aee6c0d53d1563b5bc22097076c609c4c5baa47056b0b4bed456fcf/fastparquet-2024.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fbe4468146b633d8f09d7b196fea0547f213cb5ce5f76e9d1beb29eaa9593a93", size = 1795682, upload-time = "2024-11-12T20:38:02.38Z" }, - { url = "https://files.pythonhosted.org/packages/b0/25/f4f87557589e1923ee0e3bebbc84f08b7c56962bf90f51b116ddc54f2c9f/fastparquet-2024.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:29d5c718817bcd765fc519b17f759cad4945974421ecc1931d3bdc3e05e57fa9", size = 1857842, upload-time = "2024-11-12T20:38:04.196Z" }, - { url = "https://files.pythonhosted.org/packages/b1/f9/98cd0c39115879be1044d59c9b76e8292776e99bb93565bf990078fd11c4/fastparquet-2024.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:74a0b3c40ab373442c0fda96b75a36e88745d8b138fcc3a6143e04682cbbb8ca", size = 673269, upload-time = "2024-12-11T21:22:48.073Z" }, + { url = "https://files.pythonhosted.org/packages/6c/b2/229a4482d80a737d0fe6706c4f93adb631f42ec5b0a2b154247d63bb48fe/fastparquet-2025.12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:27b1cf0557ddddbf0e28db64d4d3bea1384be1d245b2cef280d001811e3600fe", size = 896986, upload-time = "2025-12-18T21:53:52.611Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c2/953117c43bf617379eff79ce8a2318ef49f7f41908faade051fa12281ac8/fastparquet-2025.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9356c59e48825d61719960ccb9ce799ad5cd1b04f2f13368f03fab1f3c645d1e", size = 687642, upload-time = "2025-12-18T21:54:13.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/35/41deaa9a4fc9ab6c00f3b49afe56cbafee13a111032aa41f23d077b69ad6/fastparquet-2025.12.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c4c92e299a314d4b542dc881eeb4d587dc075c0a5a86c07ccf171d8852e9736d", size = 1764260, upload-time = "2025-12-18T21:58:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/1a/0f/a229b3f699aaccc7b5ec3f5e21cff8aa99bc199499bff08cf38bc6ab52c6/fastparquet-2025.12.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4881dc91c7e6d1d08cda9968ed1816b0c66a74b1826014c26713cad923aaca71", size = 1810920, upload-time = "2025-12-18T21:57:31.514Z" }, + { url = "https://files.pythonhosted.org/packages/90/c2/ca76afca0c2debef368a42a701d501e696490e0a7138f0337709a724b189/fastparquet-2025.12.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d8d70d90614f19752919037c4a88aaaeda3cd7667aeb54857c48054e2a9e3588", size = 1819692, upload-time = "2025-12-18T21:58:43.095Z" }, + { url = "https://files.pythonhosted.org/packages/ab/41/f235c0d8171f6676b9d4fb8468c781fbe7bf90fed2c4383f2d8d82e574db/fastparquet-2025.12.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e2ccf387f629cb11b72fec6f15a55e0f40759b47713124764a9867097bcd377", size = 1784357, upload-time = "2025-12-18T21:58:13.258Z" }, + { url = "https://files.pythonhosted.org/packages/29/7e/c86bf33b363cf5a1ad71d3ebd4a352131ba99566c78aa58d9e56c98526ba/fastparquet-2025.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1978e7f3c32044f2f7a0b35784240dfc3eaeb8065a879fa3011c832fea4e7037", size = 1815777, upload-time = "2025-12-18T21:58:44.432Z" }, ] [[package]] name = "filelock" -version = "3.20.0" +version = "3.20.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/23/ce7a1126827cedeb958fc043d61745754464eb56c5937c35bbf2b8e26f34/filelock-3.20.1.tar.gz", hash = "sha256:b8360948b351b80f420878d8516519a2204b07aefcdcfd24912a5d33127f188c", size = 19476, upload-time = "2025-12-15T23:54:28.027Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7f/a1a97644e39e7316d850784c642093c99df1290a460df4ede27659056834/filelock-3.20.1-py3-none-any.whl", hash = "sha256:15d9e9a67306188a44baa72f569d2bfd803076269365fdea0934385da4dc361a", size = 16666, upload-time = "2025-12-15T23:54:26.874Z" }, ] [[package]] @@ -1317,28 +1665,36 @@ wheels = [ [[package]] name = "flatbuffers" -version = "25.9.23" +version = "25.12.19" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9d/1f/3ee70b0a55137442038f2a33469cc5fddd7e0ad2abf83d7497c18a2b6923/flatbuffers-25.9.23.tar.gz", hash = "sha256:676f9fa62750bb50cf531b42a0a2a118ad8f7f797a511eda12881c016f093b12", size = 22067, upload-time = "2025-09-24T05:25:30.106Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/1b/00a78aa2e8fbd63f9af08c9c19e6deb3d5d66b4dda677a0f61654680ee89/flatbuffers-25.9.23-py2.py3-none-any.whl", hash = "sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2", size = 30869, upload-time = "2025-09-24T05:25:28.912Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" }, +] + +[[package]] +name = "fmriprep-docker" +version = "25.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/1a/df92c6e30179895add181faf3a7ce0ee9c7888052177cb0ca29a35e99db6/fmriprep_docker-25.2.3.tar.gz", hash = "sha256:19c9fe7ac860a49142aa51e5351c44af2a68737a3a0c78603e2ef138f718ae93", size = 9278, upload-time = "2025-10-17T18:07:32.242Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/b3/b442ad416fd14bbc33ef7c595f5cbe119c2b612f2f1b77928be5e5d583dd/fmriprep_docker-25.2.3-py2.py3-none-any.whl", hash = "sha256:16b31baf18fa9bf761e022ec931bde3464a0673d5778c9ed5121ebb4208ae241", size = 10449, upload-time = "2025-10-17T18:07:28.637Z" }, ] [[package]] name = "fonttools" -version = "4.61.0" +version = "4.61.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/33/f9/0e84d593c0e12244150280a630999835a64f2852276161b62a0f98318de0/fonttools-4.61.0.tar.gz", hash = "sha256:ec520a1f0c7758d7a858a00f090c1745f6cde6a7c5e76fb70ea4044a15f712e7", size = 3561884, upload-time = "2025-11-28T17:05:49.491Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/00/5d/19e5939f773c7cb05480fe2e881d63870b63ee2b4bdb9a77d55b1d36c7b9/fonttools-4.61.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e24a1565c4e57111ec7f4915f8981ecbb61adf66a55f378fdc00e206059fcfef", size = 2846930, upload-time = "2025-11-28T17:04:46.639Z" }, - { url = "https://files.pythonhosted.org/packages/25/b2/0658faf66f705293bd7e739a4f038302d188d424926be9c59bdad945664b/fonttools-4.61.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2bfacb5351303cae9f072ccf3fc6ecb437a6f359c0606bae4b1ab6715201d87", size = 2383016, upload-time = "2025-11-28T17:04:48.525Z" }, - { url = "https://files.pythonhosted.org/packages/29/a3/1fa90b95b690f0d7541f48850adc40e9019374d896c1b8148d15012b2458/fonttools-4.61.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0bdcf2e29d65c26299cc3d502f4612365e8b90a939f46cd92d037b6cb7bb544a", size = 4949425, upload-time = "2025-11-28T17:04:50.482Z" }, - { url = "https://files.pythonhosted.org/packages/af/00/acf18c00f6c501bd6e05ee930f926186f8a8e268265407065688820f1c94/fonttools-4.61.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6cd0d9051b8ddaf7385f99dd82ec2a058e2b46cf1f1961e68e1ff20fcbb61af", size = 4999632, upload-time = "2025-11-28T17:04:52.508Z" }, - { url = "https://files.pythonhosted.org/packages/5f/e0/19a2b86e54109b1d2ee8743c96a1d297238ae03243897bc5345c0365f34d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e074bc07c31406f45c418e17c1722e83560f181d122c412fa9e815df0ff74810", size = 4939438, upload-time = "2025-11-28T17:04:54.437Z" }, - { url = "https://files.pythonhosted.org/packages/04/35/7b57a5f57d46286360355eff8d6b88c64ab6331107f37a273a71c803798d/fonttools-4.61.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5a9b78da5d5faa17e63b2404b77feeae105c1b7e75f26020ab7a27b76e02039f", size = 5088960, upload-time = "2025-11-28T17:04:56.348Z" }, - { url = "https://files.pythonhosted.org/packages/3e/0e/6c5023eb2e0fe5d1ababc7e221e44acd3ff668781489cc1937a6f83d620a/fonttools-4.61.0-cp312-cp312-win32.whl", hash = "sha256:9821ed77bb676736b88fa87a737c97b6af06e8109667e625a4f00158540ce044", size = 2264404, upload-time = "2025-11-28T17:04:58.149Z" }, - { url = "https://files.pythonhosted.org/packages/36/0b/63273128c7c5df19b1e4cd92e0a1e6ea5bb74a400c4905054c96ad60a675/fonttools-4.61.0-cp312-cp312-win_amd64.whl", hash = "sha256:0011d640afa61053bc6590f9a3394bd222de7cfde19346588beabac374e9d8ac", size = 2314427, upload-time = "2025-11-28T17:04:59.812Z" }, - { url = "https://files.pythonhosted.org/packages/0c/14/634f7daea5ffe6a5f7a0322ba8e1a0e23c9257b80aa91458107896d1dfc7/fonttools-4.61.0-py3-none-any.whl", hash = "sha256:276f14c560e6f98d24ef7f5f44438e55ff5a67f78fa85236b218462c9f5d0635", size = 1144485, upload-time = "2025-11-28T17:05:47.573Z" }, + { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" }, + { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" }, + { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" }, + { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" }, + { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" }, + { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" }, + { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" }, ] [[package]] @@ -1359,6 +1715,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1a/9d/c2c8b51b32f829a16fe042db30ad1dcef7947bf1dcf77c2cfd7b6f37b83a/formulaic-1.2.1-py3-none-any.whl", hash = "sha256:661d6d2467aa961b9afb3a1e2a187494239793c63eb729e422d1307afa98b43b", size = 117290, upload-time = "2025-09-21T05:27:30.025Z" }, ] +[[package]] +name = "formulaic-contrasts" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "formulaic" }, + { name = "pandas" }, + { name = "session-info" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e6/4850976c248746062cfaa08628b3ec5ba3dfcab3d6ecd0d3886c36c04681/formulaic_contrasts-1.0.0.tar.gz", hash = "sha256:0a575a810bf1fba28938259d86a3ae2ae90cb9826fca84b9409085170862f701", size = 123794, upload-time = "2024-12-15T13:44:06.844Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/7b/639411281256c84e8111bf6cb9676c44dbf5d8ad4cb042f4359b7e7b9e74/formulaic_contrasts-1.0.0-py3-none-any.whl", hash = "sha256:e1220d315cf446bdec9385375ca4da43896e4ba68114ebea1b2a37efa5d097f5", size = 10054, upload-time = "2024-12-15T13:44:05.454Z" }, +] + [[package]] name = "fqdn" version = "1.5.1" @@ -1377,6 +1747,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/38/74/f94141b38a51a553efef7f510fc213894161ae49b88bffd037f8d2a7cb2f/frozendict-2.4.7-py3-none-any.whl", hash = "sha256:972af65924ea25cf5b4d9326d549e69a9a4918d8a76a9d3a7cd174d98b237550", size = 16264, upload-time = "2025-11-11T22:40:12.836Z" }, ] +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + [[package]] name = "fsspec" version = "2025.12.0" @@ -1403,31 +1798,55 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/36/93/f7d93f394eaa5f96d8249fb582034dfb5a7d1eb4007ad4a1cc65c2e17463/funowl-0.2.3-py3-none-any.whl", hash = "sha256:4c4328d03c7815cd61d6691f0fafc78dc9a78ec3dcab4c83afb64d125ad3660e", size = 51376, upload-time = "2023-08-08T17:38:14.735Z" }, ] +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" }, +] + +[[package]] +name = "gitpython" +version = "3.1.45" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/c8/dd58967d119baab745caec2f9d853297cec1989ec1d63f677d3880632b88/gitpython-3.1.45.tar.gz", hash = "sha256:85b0ee964ceddf211c41b9f27a49086010a190fd8132a24e21f362a4b36a791c", size = 215076, upload-time = "2025-07-24T03:45:54.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/61/d4b89fec821f72385526e1b9d9a3a0385dda4a72b206d28049e2c7cd39b8/gitpython-3.1.45-py3-none-any.whl", hash = "sha256:8908cb2e02fb3b93b7eb0f2827125cb699869470432cc885f019b8fd0fccff77", size = 208168, upload-time = "2025-07-24T03:45:52.517Z" }, +] + [[package]] name = "google-auth" -version = "2.43.0" +version = "2.45.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cachetools" }, { name = "pyasn1-modules" }, { name = "rsa" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ff/ef/66d14cf0e01b08d2d51ffc3c20410c4e134a1548fc246a6081eae585a4fe/google_auth-2.43.0.tar.gz", hash = "sha256:88228eee5fc21b62a1b5fe773ca15e67778cb07dc8363adcb4a8827b52d81483", size = 296359, upload-time = "2025-11-06T00:13:36.587Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/00/3c794502a8b892c404b2dea5b3650eb21bfc7069612fbfd15c7f17c1cb0d/google_auth-2.45.0.tar.gz", hash = "sha256:90d3f41b6b72ea72dd9811e765699ee491ab24139f34ebf1ca2b9cc0c38708f3", size = 320708, upload-time = "2025-12-15T22:58:42.889Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6f/d1/385110a9ae86d91cc14c5282c61fe9f4dc41c0b9f7d423c6ad77038c4448/google_auth-2.43.0-py2.py3-none-any.whl", hash = "sha256:af628ba6fa493f75c7e9dbe9373d148ca9f4399b5ea29976519e0a3848eddd16", size = 223114, upload-time = "2025-11-06T00:13:35.209Z" }, + { url = "https://files.pythonhosted.org/packages/c6/97/451d55e05487a5cd6279a01a7e34921858b16f7dc8aa38a2c684743cd2b3/google_auth-2.45.0-py2.py3-none-any.whl", hash = "sha256:82344e86dc00410ef5382d99be677c6043d72e502b625aa4f4afa0bdacca0f36", size = 233312, upload-time = "2025-12-15T22:58:40.777Z" }, ] [[package]] name = "google-crc32c" -version = "1.7.1" +version = "1.8.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/19/ae/87802e6d9f9d69adfaedfcfd599266bf386a54d0be058b532d04c794f76d/google_crc32c-1.7.1.tar.gz", hash = "sha256:2bff2305f98846f3e825dbeec9ee406f89da7962accdb29356e4eadc251bd472", size = 14495, upload-time = "2025-03-26T14:29:13.32Z" } +sdist = { url = "https://files.pythonhosted.org/packages/03/41/4b9c02f99e4c5fb477122cd5437403b552873f014616ac1d19ac8221a58d/google_crc32c-1.8.0.tar.gz", hash = "sha256:a428e25fb7691024de47fecfbff7ff957214da51eddded0da0ae0e0f03a2cf79", size = 14192, upload-time = "2025-12-16T00:35:25.142Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/dd/b7/787e2453cf8639c94b3d06c9d61f512234a82e1d12d13d18584bd3049904/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2d73a68a653c57281401871dd4aeebbb6af3191dcac751a76ce430df4d403194", size = 30470, upload-time = "2025-03-26T14:34:31.655Z" }, - { url = "https://files.pythonhosted.org/packages/ed/b4/6042c2b0cbac3ec3a69bb4c49b28d2f517b7a0f4a0232603c42c58e22b44/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:22beacf83baaf59f9d3ab2bbb4db0fb018da8e5aebdce07ef9f09fce8220285e", size = 30315, upload-time = "2025-03-26T15:01:54.634Z" }, - { url = "https://files.pythonhosted.org/packages/29/ad/01e7a61a5d059bc57b702d9ff6a18b2585ad97f720bd0a0dbe215df1ab0e/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19eafa0e4af11b0a4eb3974483d55d2d77ad1911e6cf6f832e1574f6781fd337", size = 33180, upload-time = "2025-03-26T14:41:32.168Z" }, - { url = "https://files.pythonhosted.org/packages/3b/a5/7279055cf004561894ed3a7bfdf5bf90a53f28fadd01af7cd166e88ddf16/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6d86616faaea68101195c6bdc40c494e4d76f41e07a37ffdef270879c15fb65", size = 32794, upload-time = "2025-03-26T14:41:33.264Z" }, - { url = "https://files.pythonhosted.org/packages/0f/d6/77060dbd140c624e42ae3ece3df53b9d811000729a5c821b9fd671ceaac6/google_crc32c-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:b7491bdc0c7564fcf48c0179d2048ab2f7c7ba36b84ccd3a3e1c3f7a72d3bba6", size = 33477, upload-time = "2025-03-26T14:29:10.94Z" }, + { url = "https://files.pythonhosted.org/packages/e9/5f/7307325b1198b59324c0fa9807cafb551afb65e831699f2ce211ad5c8240/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:4b8286b659c1335172e39563ab0a768b8015e88e08329fa5321f774275fc3113", size = 31300, upload-time = "2025-12-16T00:21:56.723Z" }, + { url = "https://files.pythonhosted.org/packages/21/8e/58c0d5d86e2220e6a37befe7e6a94dd2f6006044b1a33edf1ff6d9f7e319/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:2a3dc3318507de089c5384cc74d54318401410f82aa65b2d9cdde9d297aca7cb", size = 30867, upload-time = "2025-12-16T00:38:31.302Z" }, + { url = "https://files.pythonhosted.org/packages/ce/a9/a780cc66f86335a6019f557a8aaca8fbb970728f0efd2430d15ff1beae0e/google_crc32c-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14f87e04d613dfa218d6135e81b78272c3b904e2a7053b841481b38a7d901411", size = 33364, upload-time = "2025-12-16T00:40:22.96Z" }, + { url = "https://files.pythonhosted.org/packages/21/3f/3457ea803db0198c9aaca2dd373750972ce28a26f00544b6b85088811939/google_crc32c-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb5c869c2923d56cb0c8e6bcdd73c009c36ae39b652dbe46a05eb4ef0ad01454", size = 33740, upload-time = "2025-12-16T00:40:23.96Z" }, + { url = "https://files.pythonhosted.org/packages/df/c0/87c2073e0c72515bb8733d4eef7b21548e8d189f094b5dad20b0ecaf64f6/google_crc32c-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc0c8912038065eafa603b238abf252e204accab2a704c63b9e14837a854962", size = 34437, upload-time = "2025-12-16T00:35:21.395Z" }, ] [[package]] @@ -1479,6 +1898,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6c/79/3912a94cf27ec503e51ba493692d6db1e3cd8ac7ac52b0b47c8e33d7f4f9/greenlet-3.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a7a34b13d43a6b78abf828a6d0e87d3385680eaf830cd60d20d52f249faabf39", size = 301964, upload-time = "2025-12-04T14:36:58.316Z" }, ] +[[package]] +name = "griffe" +version = "1.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/0c/3a471b6e31951dce2360477420d0a8d1e00dea6cf33b70f3e8c3ab6e28e1/griffe-1.15.0.tar.gz", hash = "sha256:7726e3afd6f298fbc3696e67958803e7ac843c1cfe59734b6251a40cdbfb5eea", size = 424112, upload-time = "2025-11-10T15:03:15.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/83/3b1d03d36f224edded98e9affd0467630fc09d766c0e56fb1498cbb04a9b/griffe-1.15.0-py3-none-any.whl", hash = "sha256:6f6762661949411031f5fcda9593f586e6ce8340f0ba88921a0f2ef7a81eb9a3", size = 150705, upload-time = "2025-11-10T15:03:13.549Z" }, +] + [[package]] name = "grpcio" version = "1.76.0" @@ -1500,6 +1931,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/00/7bd478cbb851c04a48baccaa49b75abaa8e4122f7d86da797500cccdd771/grpcio-1.76.0-cp312-cp312-win_amd64.whl", hash = "sha256:c088e7a90b6017307f423efbb9d1ba97a22aa2170876223f9709e9d1de0b5347", size = 4704003, upload-time = "2025-10-21T16:21:46.244Z" }, ] +[[package]] +name = "gseapy" +version = "1.1.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "requests" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/78/7c0fbec6019db95dadb560049cc503e950438488b3b0822a2270e1f62d2a/gseapy-1.1.11.tar.gz", hash = "sha256:d36a164ee466f7ea6deadfe82ea041f3328ee937ff4c9de862b3e6e2825df0dd", size = 116084, upload-time = "2025-11-16T22:55:26.486Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/71/8034311bc4a7a41414cd188da9b411b4cd0c357574b01d8609d6e9a1d336/gseapy-1.1.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4d22c2ec30dc863b86292a0e967f8c7216ef03028b41f1ece6c59d277a870bdc", size = 533921, upload-time = "2025-11-16T23:02:53.061Z" }, + { url = "https://files.pythonhosted.org/packages/0d/3e/c3c23ff829d6a88c403cda12ed856ff93c7f07c510e3bf5c114a4d2f575e/gseapy-1.1.11-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:48453a402feae0412f6330a3c39f95ab02e82693f33bc4a1c6c02c867e7e6d1c", size = 605338, upload-time = "2025-11-16T22:58:48.471Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9f/592125b3eabb64ecaf3275e4f0cff7dc59d438f8ffde360d686802787bc5/gseapy-1.1.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:6c64e60a8f61047c7d4053b791c7dea1c375bd28b955f0c50ae3cd607013c47f", size = 585366, upload-time = "2025-11-16T23:41:36.192Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a6/2b86532b665a3dd50d5bf5390e3b751487a6b6f64eddff1c21ea9d302fef/gseapy-1.1.11-cp312-cp312-win32.whl", hash = "sha256:18ba31a03b043b7a78397c0589f04d0f4d7a3ff76af09e219f0240085708c4c6", size = 391320, upload-time = "2025-11-16T23:05:48.509Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ab/6374ddf4cd4637b0cab1e9cd2dd8b1bf007bdf1e9fe1bf8bff2d83482a9b/gseapy-1.1.11-cp312-cp312-win_amd64.whl", hash = "sha256:5645f8f8c88a9218225a7c207d6d1de9eed9955f108ad2a06c46f42885ba4fa8", size = 423182, upload-time = "2025-11-16T23:03:12.868Z" }, +] + [[package]] name = "gunicorn" version = "23.0.0" @@ -1521,6 +1972,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] +[[package]] +name = "h2" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "hpack" }, + { name = "hyperframe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" }, +] + [[package]] name = "h5py" version = "3.15.1" @@ -1541,22 +2005,54 @@ wheels = [ ] [[package]] -name = "hbreader" -version = "0.9.1" +name = "harmony-pytorch" +version = "0.1.8" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/66/3a649ce125e03d1d43727a8b833cd211f0b9fe54a7e5be326f50d6f1d951/hbreader-0.9.1.tar.gz", hash = "sha256:d2c132f8ba6276d794c66224c3297cec25c8079d0a4cf019c061611e0a3b94fa", size = 19016, upload-time = "2021-02-25T19:22:32.799Z" } +dependencies = [ + { name = "numpy" }, + { name = "pandas" }, + { name = "psutil" }, + { name = "scikit-learn" }, + { name = "threadpoolctl" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8d/df/71fe694d70ff148db2364c4118a6bbd37e598be269be471ed3d2f6bfee1a/harmony-pytorch-0.1.8.tar.gz", hash = "sha256:1b097906d49c6ed9dde6cf234f7d987fb49a3b649b8a1323d99e6ea71b5b7df2", size = 8373, upload-time = "2024-01-07T21:36:56.059Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7b/24/61844afbf38acf419e01ca2639f7bd079584523d34471acbc4152ee991c5/hbreader-0.9.1-py3-none-any.whl", hash = "sha256:9a6e76c9d1afc1b977374a5dc430a1ebb0ea0488205546d4678d6e31cc5f6801", size = 7595, upload-time = "2021-02-25T19:22:31.944Z" }, + { url = "https://files.pythonhosted.org/packages/75/da/42486f1c79b6f2db9140ee23161791e5b25d9369f30c1d9f67b67f3eb4bf/harmony_pytorch-0.1.8-py3-none-any.whl", hash = "sha256:1f92f6145ea93225b0226fda9da5bdd442e411d14ff402052afae0fde7fd1452", size = 8474, upload-time = "2024-01-07T21:36:54.488Z" }, ] [[package]] -name = "hf-xet" -version = "1.2.0" +name = "harmonypy" +version = "0.0.10" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" } +dependencies = [ + { name = "numpy" }, + { name = "pandas" }, + { name = "scikit-learn" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1a/69/9af6183745618057797b940a76320c52a38ad2a69e688e6345e2a0219655/harmonypy-0.0.10.tar.gz", hash = "sha256:27bd39a6f9ada1708ffa577e46c9b7363d1e2fd62740e477ce11fd61819a54df", size = 20339, upload-time = "2024-07-04T20:55:06.385Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" }, - { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" }, + { url = "https://files.pythonhosted.org/packages/cc/cd/9479dd66e503af191edc016a302d2125c4f02ea777ebea1e48f6b944b073/harmonypy-0.0.10-py3-none-any.whl", hash = "sha256:dab528052f909204e521c9c2bd980221c64003538b0c0fe25be2e43c1199282b", size = 20885, upload-time = "2024-07-04T20:55:00.329Z" }, +] + +[[package]] +name = "hbreader" +version = "0.9.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/66/3a649ce125e03d1d43727a8b833cd211f0b9fe54a7e5be326f50d6f1d951/hbreader-0.9.1.tar.gz", hash = "sha256:d2c132f8ba6276d794c66224c3297cec25c8079d0a4cf019c061611e0a3b94fa", size = 19016, upload-time = "2021-02-25T19:22:32.799Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/24/61844afbf38acf419e01ca2639f7bd079584523d34471acbc4152ee991c5/hbreader-0.9.1-py3-none-any.whl", hash = "sha256:9a6e76c9d1afc1b977374a5dc430a1ebb0ea0488205546d4678d6e31cc5f6801", size = 7595, upload-time = "2021-02-25T19:22:31.944Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" }, + { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" }, { url = "https://files.pythonhosted.org/packages/9a/92/cf3ab0b652b082e66876d08da57fcc6fa2f0e6c70dfbbafbd470bb73eb47/hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd", size = 3320214, upload-time = "2025-10-24T19:04:03.596Z" }, { url = "https://files.pythonhosted.org/packages/46/92/3f7ec4a1b6a65bf45b059b6d4a5d38988f63e193056de2f420137e3c3244/hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c", size = 3229054, upload-time = "2025-10-24T19:04:01.949Z" }, { url = "https://files.pythonhosted.org/packages/0b/dd/7ac658d54b9fb7999a0ccb07ad863b413cbaf5cf172f48ebcd9497ec7263/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737", size = 3413812, upload-time = "2025-10-24T19:04:24.585Z" }, @@ -1564,6 +2060,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" }, ] +[[package]] +name = "hpack" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276, upload-time = "2025-01-22T21:44:58.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357, upload-time = "2025-01-22T21:44:56.92Z" }, +] + [[package]] name = "httpcore" version = "1.0.9" @@ -1607,6 +2112,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] +[package.optional-dependencies] +http2 = [ + { name = "h2" }, +] + [[package]] name = "huggingface-hub" version = "0.36.0" @@ -1640,11 +2150,20 @@ wheels = [ [[package]] name = "humanize" -version = "4.14.0" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/66/a3921783d54be8a6870ac4ccffcd15c4dc0dd7fcce51c6d63b8c63935276/humanize-4.15.0.tar.gz", hash = "sha256:1dd098483eb1c7ee8e32eb2e99ad1910baefa4b75c3aff3a82f4d78688993b10", size = 83599, upload-time = "2025-12-20T20:16:13.19Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/7b/bca5613a0c3b542420cf92bd5e5fb8ebd5435ce1011a091f66bb7693285e/humanize-4.15.0-py3-none-any.whl", hash = "sha256:b1186eb9f5a9749cd9cb8565aee77919dd7c8d076161cf44d70e59e3301e1769", size = 132203, upload-time = "2025-12-20T20:16:11.67Z" }, +] + +[[package]] +name = "hyperframe" +version = "6.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/43/50033d25ad96a7f3845f40999b4778f753c3901a11808a584fed7c00d9f5/humanize-4.14.0.tar.gz", hash = "sha256:2fa092705ea640d605c435b1ca82b2866a1b601cdf96f076d70b79a855eba90d", size = 82939, upload-time = "2025-10-15T13:04:51.214Z" } +sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c3/5b/9512c5fb6c8218332b530f13500c6ff5f3ce3342f35e0dd7be9ac3856fd3/humanize-4.14.0-py3-none-any.whl", hash = "sha256:d57701248d040ad456092820e6fde56c930f17749956ac47f4f655c0c547bfff", size = 132092, upload-time = "2025-10-15T13:04:49.404Z" }, + { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" }, ] [[package]] @@ -1692,6 +2211,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, ] +[[package]] +name = "igraph" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "texttable" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/be/56bef1919005b4caf1f71522b300d359f7faeb7ae93a3b0baa9b4f146a87/igraph-1.0.0.tar.gz", hash = "sha256:2414d0be2e4d77ee5357807d100974b40f6082bb1bb71988ec46cfb6728651ee", size = 5077105, upload-time = "2025-10-23T12:22:50.127Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/03/3278ad0ceb3ea0e84d8ae3a85bdded4d0e57853aeb802a200feb43847b93/igraph-1.0.0-cp39-abi3-macosx_10_15_x86_64.whl", hash = "sha256:c2cbc415e02523e5a241eecee82319080bf928a70b1ba299f3b3e25bf029b6d4", size = 2257415, upload-time = "2025-10-23T12:22:27.246Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bc/6281ec7f9baaf71ee57c3b1748da2d3148d15d253e1a03006f204aa68ca5/igraph-1.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a27753cd80680a8f676c2d5a467aaa4a95e510b30748398ec4e4aeb982130e8", size = 2048555, upload-time = "2025-10-23T12:22:29.49Z" }, + { url = "https://files.pythonhosted.org/packages/2a/38/3cd6428a4ed4c09a56df05998438e7774fd1d799ee4fb8fc481674f5f7fc/igraph-1.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a55dc3a2a4e3fc3eba42479910c1511bfc3ecb33cdf5f0406891fd85f14b5aee", size = 5314141, upload-time = "2025-10-23T12:22:31.023Z" }, + { url = "https://files.pythonhosted.org/packages/7d/da/dd2867c25adbb41563720f14b5fc895c98bf88be682a3faff4f7b3118d2a/igraph-1.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2d04c2c76f686fb1f554ee35dfd3085f5e73b7965ba6b4cf06d53e66b1955522", size = 5683134, upload-time = "2025-10-23T12:22:32.423Z" }, + { url = "https://files.pythonhosted.org/packages/e5/40/243c118d34ab80382d7009c4dcb99b887384c3d2ce84d29eeac19e2a007a/igraph-1.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2b52dc1757fff0fed29a9f7a276d971a11db4211569ed78b9eab36288dfcc9d", size = 6211583, upload-time = "2025-10-23T12:22:34.238Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b7/88f433819c54b496cb0315fce28e658970cb20ff5dbd52a5a605ce2888de/igraph-1.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:05c79a2a8fca695b2f217a6fa7f2549f896f757d4db41be32a055400cb19cc30", size = 6594509, upload-time = "2025-10-23T12:22:35.831Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5d/8f7f6f619d374e959aa3664ebc4b24c10abc90c2e8efbed97f2623fadaf5/igraph-1.0.0-cp39-abi3-win32.whl", hash = "sha256:c2bce3cd472fec3dd9c4d8a3ea5b6b9be65fb30edf760beb4850760dd4f2d479", size = 2725406, upload-time = "2025-10-23T12:22:37.588Z" }, + { url = "https://files.pythonhosted.org/packages/af/77/a85b3745cf40a0572bae2de8cd9c2a2a8af78e5cf3e880fc0a249114e609/igraph-1.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:faeff8ede0cf15eb4ded44b0fcea6e1886740146e60504c24ad2da14e0939563", size = 3221663, upload-time = "2025-10-23T12:22:39.404Z" }, + { url = "https://files.pythonhosted.org/packages/ef/7e/5df541c37bdf6493035e89c22bd53f30d99b291bcda6c78e9a8afeecec2b/igraph-1.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:b607cafc24b10a615e713ee96e58208ef27e0764af80140c7cc45d4724a3f2df", size = 2785701, upload-time = "2025-10-23T12:22:41.03Z" }, +] + [[package]] name = "ijson" version = "3.4.0.post0" @@ -1711,6 +2250,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a1/2b/6f7ade27a8ff5758fc41006dadd2de01730def84fe3e60553b329c59e0d4/ijson-3.4.0.post0-cp312-cp312-win_amd64.whl", hash = "sha256:e15833dcf6f6d188fdc624a31cd0520c3ba21b6855dc304bc7c1a8aeca02d4ac", size = 54789, upload-time = "2025-10-10T05:28:19.552Z" }, ] +[[package]] +name = "imageio" +version = "2.37.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/6f/606be632e37bf8d05b253e8626c2291d74c691ddc7bcdf7d6aaf33b32f6a/imageio-2.37.2.tar.gz", hash = "sha256:0212ef2727ac9caa5ca4b2c75ae89454312f440a756fcfc8ef1993e718f50f8a", size = 389600, upload-time = "2025-11-04T14:29:39.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/fe/301e0936b79bcab4cacc7548bf2853fc28dced0a578bab1f7ef53c9aa75b/imageio-2.37.2-py3-none-any.whl", hash = "sha256:ad9adfb20335d718c03de457358ed69f141021a333c40a53e57273d8a5bd0b9b", size = 317646, upload-time = "2025-11-04T14:29:37.948Z" }, +] + [[package]] name = "imagesize" version = "1.4.1" @@ -1720,16 +2272,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, ] +[[package]] +name = "immutables" +version = "0.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/41/0ccaa6ef9943c0609ec5aa663a3b3e681c1712c1007147b84590cec706a0/immutables-0.21.tar.gz", hash = "sha256:b55ffaf0449790242feb4c56ab799ea7af92801a0a43f9e2f4f8af2ab24dfc4a", size = 89008, upload-time = "2024-10-10T00:55:01.434Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/f9/0c46f600702b815182212453f5514c0070ee168b817cdf7c3767554c8489/immutables-0.21-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef1ed262094b755903122c3c3a83ad0e0d5c3ab7887cda12b2fe878769d1ee0d", size = 31885, upload-time = "2024-10-10T00:54:19.406Z" }, + { url = "https://files.pythonhosted.org/packages/29/34/7608d2eab6179aa47e8f59ab0fbd5b3eeb2333d78c9dc2da0de8de4ed322/immutables-0.21-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce604f81d9d8f26e60b52ebcb56bb5c0462c8ea50fb17868487d15f048a2f13e", size = 31537, upload-time = "2024-10-10T00:54:20.998Z" }, + { url = "https://files.pythonhosted.org/packages/f7/52/cb9e2bb7a69338155ffabbd2f993c968c750dd2d5c6c6eaa6ebb7bfcbdfa/immutables-0.21-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b48b116aaca4500398058b5a87814857a60c4cb09417fecc12d7da0f5639b73d", size = 104270, upload-time = "2024-10-10T00:54:21.912Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a4/25df835a9b9b372a4a869a8a1ac30a32199f2b3f581ad0e249f7e3d19eed/immutables-0.21-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dad7c0c74b285cc0e555ec0e97acbdc6f1862fcd16b99abd612df3243732e741", size = 104864, upload-time = "2024-10-10T00:54:22.956Z" }, + { url = "https://files.pythonhosted.org/packages/4a/51/b548fbc657134d658e179ee8d201ae82d9049aba5c3cb2d858ed2ecb7e3f/immutables-0.21-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e44346e2221a5a676c880ca8e0e6429fa24d1a4ae562573f5c04d7f2e759b030", size = 99733, upload-time = "2024-10-10T00:54:23.99Z" }, + { url = "https://files.pythonhosted.org/packages/47/db/d7b1e0e88faf07fe9a88579a86f58078a9a37fff871f4b3dbcf28cad9a12/immutables-0.21-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b10139b529a460e53fe8be699ebd848c54c8a33ebe67763bcfcc809a475a26f", size = 101698, upload-time = "2024-10-10T00:54:25.734Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/6fe42a1a053dd8cfb9f45e91d5246522637c7287dc6bd347f67aedf7aedb/immutables-0.21-cp312-cp312-win32.whl", hash = "sha256:fc512d808662614feb17d2d92e98f611d69669a98c7af15910acf1dc72737038", size = 30977, upload-time = "2024-10-10T00:54:27.436Z" }, + { url = "https://files.pythonhosted.org/packages/63/45/d062aca6971e99454ce3ae42a7430037227fee961644ed1f8b6c9b99e0a5/immutables-0.21-cp312-cp312-win_amd64.whl", hash = "sha256:461dcb0f58a131045155e52a2c43de6ec2fe5ba19bdced6858a3abb63cee5111", size = 35088, upload-time = "2024-10-10T00:54:28.388Z" }, +] + [[package]] name = "importlib-metadata" -version = "8.7.0" +version = "8.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, ] [[package]] @@ -1885,14 +2453,14 @@ wheels = [ [[package]] name = "jaraco-functools" -version = "4.3.0" +version = "4.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "more-itertools" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f7/ed/1aa2d585304ec07262e1a83a9889880701079dde796ac7b1d1826f40c63d/jaraco_functools-4.3.0.tar.gz", hash = "sha256:cfd13ad0dd2c47a3600b439ef72d8615d482cedcff1632930d6f28924d92f294", size = 19755, upload-time = "2025-08-18T20:05:09.91Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/27/056e0638a86749374d6f57d0b0db39f29509cce9313cf91bdc0ac4d91084/jaraco_functools-4.4.0.tar.gz", hash = "sha256:da21933b0417b89515562656547a77b4931f98176eb173644c0d35032a33d6bb", size = 19943, upload-time = "2025-12-21T09:29:43.6Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b4/09/726f168acad366b11e420df31bf1c702a54d373a83f968d94141a8c3fde0/jaraco_functools-4.3.0-py3-none-any.whl", hash = "sha256:227ff8ed6f7b8f62c56deff101545fa7543cf2c8e7b82a7c2116e672f29c26e8", size = 10408, upload-time = "2025-08-18T20:05:08.69Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c4/813bb09f0985cb21e959f21f2464169eca882656849adf727ac7bb7e1767/jaraco_functools-4.4.0-py3-none-any.whl", hash = "sha256:9eec1e36f45c818d9bf307c8948eb03b2b56cd44087b3cdc989abca1f20b9176", size = 10481, upload-time = "2025-12-21T09:29:42.27Z" }, ] [[package]] @@ -1928,6 +2496,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] +[[package]] +name = "jinja2-humanize-extension" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "humanize" }, + { name = "jinja2" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/77/0bba383819dd4e67566487c11c49479ced87e77c3285d8e7f7a3401cf882/jinja2_humanize_extension-0.4.0.tar.gz", hash = "sha256:e7d69b1c20f32815bbec722330ee8af14b1287bb1c2b0afa590dbf031cadeaa0", size = 4746, upload-time = "2023-09-01T12:52:42.781Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/b4/08c9d297edd5e1182506edecccbb88a92e1122a057953068cadac420ca5d/jinja2_humanize_extension-0.4.0-py3-none-any.whl", hash = "sha256:b6326e2da0f7d425338bebf58848e830421defbce785f12ae812e65128518156", size = 4769, upload-time = "2023-09-01T12:52:41.098Z" }, +] + [[package]] name = "jiter" version = "0.12.0" @@ -1964,11 +2545,11 @@ wheels = [ [[package]] name = "joblib" -version = "1.5.2" +version = "1.5.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e8/5d/447af5ea094b9e4c4054f82e223ada074c552335b9b4b2d14bd9b35a67c4/joblib-1.5.2.tar.gz", hash = "sha256:3faa5c39054b2f03ca547da9b2f52fde67c06240c31853f306aea97f13647b55", size = 331077, upload-time = "2025-08-27T12:15:46.575Z" } +sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396, upload-time = "2025-08-27T12:15:45.188Z" }, + { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" }, ] [[package]] @@ -2026,6 +2607,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f8/62/d9ba6323b9202dd2fe166beab8a86d29465c41a0288cbe229fac60c1ab8d/jsonlines-4.0.0-py3-none-any.whl", hash = "sha256:185b334ff2ca5a91362993f42e83588a360cf95ce4b71a73548502bda52a7c55", size = 8701, upload-time = "2023-09-01T12:34:42.563Z" }, ] +[[package]] +name = "jsonpatch" +version = "1.33" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonpointer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/78/18813351fe5d63acad16aec57f94ec2b70a09e53ca98145589e185423873/jsonpatch-1.33.tar.gz", hash = "sha256:9fcd4009c41e6d12348b4a0ff2563ba56a2923a7dfee731d004e212e1ee5030c", size = 21699, upload-time = "2023-06-26T12:07:29.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/07/02e16ed01e04a374e644b575638ec7987ae846d25ad97bcc9945a3ee4b0e/jsonpatch-1.33-py2.py3-none-any.whl", hash = "sha256:0ae28c0cd062bbd8b8ecc26d7d164fbbea9652a1a3693f3b956c1eae5145dade", size = 12898, upload-time = "2023-06-16T21:01:28.466Z" }, +] + [[package]] name = "jsonpointer" version = "3.0.0" @@ -2241,7 +2834,7 @@ wheels = [ [[package]] name = "jupyterlab" -version = "4.5.0" +version = "4.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "async-lru" }, @@ -2258,9 +2851,9 @@ dependencies = [ { name = "tornado" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/df/e5/4fa382a796a6d8e2cd867816b64f1ff27f906e43a7a83ad9eb389e448cd8/jupyterlab-4.5.0.tar.gz", hash = "sha256:aec33d6d8f1225b495ee2cf20f0514f45e6df8e360bdd7ac9bace0b7ac5177ea", size = 23989880, upload-time = "2025-11-18T13:19:00.365Z" } +sdist = { url = "https://files.pythonhosted.org/packages/09/21/413d142686a4e8f4268d985becbdb4daf060524726248e73be4773786987/jupyterlab-4.5.1.tar.gz", hash = "sha256:09da1ddfbd9eec18b5101dbb8515612aa1e47443321fb99503725a88e93d20d9", size = 23992251, upload-time = "2025-12-15T16:58:59.361Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/1e/5a4d5498eba382fee667ed797cf64ae5d1b13b04356df62f067f48bb0f61/jupyterlab-4.5.0-py3-none-any.whl", hash = "sha256:88e157c75c1afff64c7dc4b801ec471450b922a4eae4305211ddd40da8201c8a", size = 12380641, upload-time = "2025-11-18T13:18:56.252Z" }, + { url = "https://files.pythonhosted.org/packages/af/c3/acced767eecc11a70c65c45295db5396c4f0c1937874937d5a76d7b177b6/jupyterlab-4.5.1-py3-none-any.whl", hash = "sha256:31b059de96de0754ff1f2ce6279774b6aab8c34d7082e9752db58207c99bd514", size = 12384821, upload-time = "2025-12-15T16:58:55.563Z" }, ] [[package]] @@ -2424,6 +3017,56 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, ] +[[package]] +name = "lazy-loader" +version = "0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6b/c875b30a1ba490860c93da4cabf479e03f584eba06fe5963f6f6644653d8/lazy_loader-0.4.tar.gz", hash = "sha256:47c75182589b91a4e1a85a136c074285a5ad4d9f39c63e0d7fb76391c4574cd1", size = 15431, upload-time = "2024-04-05T13:03:12.261Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/60/d497a310bde3f01cb805196ac61b7ad6dc5dcf8dce66634dc34364b20b4f/lazy_loader-0.4-py3-none-any.whl", hash = "sha256:342aa8e14d543a154047afb4ba8ef17f5563baad3fc610d7b15b213b0f119efc", size = 12097, upload-time = "2024-04-05T13:03:10.514Z" }, +] + +[[package]] +name = "legacy-api-wrap" +version = "1.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/49/f06f94048c8974205730d40beca879e43b6eee08efb0101cfb8623e60f41/legacy_api_wrap-1.5.tar.gz", hash = "sha256:b41ba6532f3ebfe3a897a35a7f97dec3be04b92a450f6c2bcf89f1b91c9cadf2", size = 11610, upload-time = "2025-11-03T13:21:12.437Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/5b/058db09c45ba58a7321bdf2294cae651b37d6fec68117265af90cde043b0/legacy_api_wrap-1.5-py3-none-any.whl", hash = "sha256:5a8ea50e3e3bcbcdec3447b77034fd0d32cb2cf4089db799238708e4d7e0098d", size = 10182, upload-time = "2025-11-03T13:21:11.102Z" }, +] + +[[package]] +name = "leidenalg" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "igraph" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5d/a5/853e93441aed7f82b0389f86f37e19413e817ba0c54cc790895935256968/leidenalg-0.11.0.tar.gz", hash = "sha256:f454be96bbc8089ea2a90ca853d8d389ab646de964a03bd58417f8b29ff8ef5d", size = 452850, upload-time = "2025-10-31T17:14:48.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/a9/4ab4e244215db0c8b626e4bed0d3e0fbd191c52d2d5f5cb9d160139ecc7e/leidenalg-0.11.0-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:5607589050bfc1926e657b4d8a3b5341fe1eb81018c22cf4a3d3a39e368d1fcb", size = 2256514, upload-time = "2025-10-31T17:14:27.574Z" }, + { url = "https://files.pythonhosted.org/packages/98/f4/98db342d603671ae0a233f0a624939a47161044a2716cbd62a50440a1132/leidenalg-0.11.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:9b5781876b1f1faed72a4f9926ff52de286843556b9d6791fe25a2acb33b7a5c", size = 1926003, upload-time = "2025-10-31T17:14:29.521Z" }, + { url = "https://files.pythonhosted.org/packages/9b/38/fd6ac21af10b12828b472eada4fce0edf2a212581238ad0c8d1afebc6f98/leidenalg-0.11.0-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a80f49477f8e793f27d8e08949177f19e3834cd878af50a662b4f87335d06549", size = 2545535, upload-time = "2025-10-31T17:14:31.102Z" }, + { url = "https://files.pythonhosted.org/packages/77/87/b087584750a788535b4a8d56ddeb82a175d32b472aa5338a4e2cc593a42c/leidenalg-0.11.0-cp38-abi3-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:2143be3e80485584ccbdf927323fce65345da17facd0f8b438f11015f5dc6c27", size = 2845029, upload-time = "2025-10-31T17:14:32.815Z" }, + { url = "https://files.pythonhosted.org/packages/b0/a4/a89e2ce16a580f7bea066ed49364f0b3e04a6412f0c3692975bee8515141/leidenalg-0.11.0-cp38-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:571a0934f831a69442d82889d319bdba93de924bd9e09b720cd8cbe6fdc08c17", size = 2738084, upload-time = "2025-10-31T17:14:35.246Z" }, + { url = "https://files.pythonhosted.org/packages/e8/fe/8923cac6cd7c9e0ac5f38aaa69a4744c93d025575763d05f7a3baae8020d/leidenalg-0.11.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:aec03e7178b19102dd271b453a39b9865cf283b4113151ba60514e5681046294", size = 4070307, upload-time = "2025-10-31T17:14:36.796Z" }, + { url = "https://files.pythonhosted.org/packages/fe/94/beaab5ee9968f9389f705532c31ffb868bad8a5ce68fb699ddde5ddc5409/leidenalg-0.11.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:310b9269a11fd1e960590c1a2b6ff685a2cc42aa3234ce67bc2a623ab61f26a9", size = 3797863, upload-time = "2025-10-31T17:14:38.124Z" }, + { url = "https://files.pythonhosted.org/packages/6e/8e/8caf4ba38fd7d8e6197348b348a4ab666b1b3117225ea2f0934a98a93176/leidenalg-0.11.0-cp38-abi3-win32.whl", hash = "sha256:5ea4cd7ee054540112b28f7e2d64658dcccd59f61a5d6a08a41df808645f96e9", size = 1643351, upload-time = "2025-10-31T17:14:39.385Z" }, + { url = "https://files.pythonhosted.org/packages/47/15/7d459a8e2a43f17c1db129b997b7bb7aa7f000a0967bab87c28b8c5cf448/leidenalg-0.11.0-cp38-abi3-win_amd64.whl", hash = "sha256:5e789c0960008d185413344a402d0587580c441644d4d20bf57c96f25d4d1710", size = 1990321, upload-time = "2025-10-31T17:14:40.892Z" }, +] + +[[package]] +name = "linkcheckmd" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/59/ea/34da82a2c946699e18275b19a97464046f1193299c42401ae7b088108eed/linkcheckmd-1.4.0.tar.gz", hash = "sha256:3a539c9a4e11697fc7fcc269d379accf93c8cccbf971f3cea0bae40912d9f609", size = 10760, upload-time = "2021-02-28T02:50:22.504Z" } + [[package]] name = "linkml" version = "1.9.3" @@ -2500,14 +3143,24 @@ wheels = [ [[package]] name = "llvmlite" -version = "0.46.0" +version = "0.45.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/99/8d/5baf1cef7f9c084fb35a8afbde88074f0d6a727bc63ef764fe0e7543ba40/llvmlite-0.45.1.tar.gz", hash = "sha256:09430bb9d0bb58fc45a45a57c7eae912850bedc095cd0810a57de109c69e1c32", size = 185600, upload-time = "2025-10-01T17:59:52.046Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/7c/82cbd5c656e8991bcc110c69d05913be2229302a92acb96109e166ae31fb/llvmlite-0.45.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:28e763aba92fe9c72296911e040231d486447c01d4f90027c8e893d89d49b20e", size = 43043524, upload-time = "2025-10-01T18:03:30.666Z" }, + { url = "https://files.pythonhosted.org/packages/9d/bc/5314005bb2c7ee9f33102c6456c18cc81745d7055155d1218f1624463774/llvmlite-0.45.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a53f4b74ee9fd30cb3d27d904dadece67a7575198bd80e687ee76474620735f", size = 37253123, upload-time = "2025-10-01T18:04:18.177Z" }, + { url = "https://files.pythonhosted.org/packages/96/76/0f7154952f037cb320b83e1c952ec4a19d5d689cf7d27cb8a26887d7bbc1/llvmlite-0.45.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b3796b1b1e1c14dcae34285d2f4ea488402fbd2c400ccf7137603ca3800864f", size = 56288211, upload-time = "2025-10-01T18:01:24.079Z" }, + { url = "https://files.pythonhosted.org/packages/00/b1/0b581942be2683ceb6862d558979e87387e14ad65a1e4db0e7dd671fa315/llvmlite-0.45.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:779e2f2ceefef0f4368548685f0b4adde34e5f4b457e90391f570a10b348d433", size = 55140958, upload-time = "2025-10-01T18:02:30.482Z" }, + { url = "https://files.pythonhosted.org/packages/33/94/9ba4ebcf4d541a325fd8098ddc073b663af75cc8b065b6059848f7d4dce7/llvmlite-0.45.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e6c9949baf25d9aa9cd7cf0f6d011b9ca660dd17f5ba2b23bdbdb77cc86b116", size = 38132231, upload-time = "2025-10-01T18:05:03.664Z" }, +] + +[[package]] +name = "locket" +version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/74/cd/08ae687ba099c7e3d21fe2ea536500563ef1943c5105bf6ab4ee3829f68e/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb", size = 193456, upload-time = "2025-12-08T18:15:36.295Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/83/97b29fe05cb6ae28d2dbd30b81e2e402a3eed5f460c26e9eaa5895ceacf5/locket-1.0.0.tar.gz", hash = "sha256:5c0d4c052a8bbbf750e056a8e65ccd309086f4f0f18a2eac306a8dfa4112a632", size = 4350, upload-time = "2022-04-20T22:04:44.312Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2b/f8/4db016a5e547d4e054ff2f3b99203d63a497465f81ab78ec8eb2ff7b2304/llvmlite-0.46.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b9588ad4c63b4f0175a3984b85494f0c927c6b001e3a246a3a7fb3920d9a137", size = 37232767, upload-time = "2025-12-08T18:15:00.737Z" }, - { url = "https://files.pythonhosted.org/packages/aa/85/4890a7c14b4fa54400945cb52ac3cd88545bbdb973c440f98ca41591cdc5/llvmlite-0.46.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3535bd2bb6a2d7ae4012681ac228e5132cdb75fefb1bcb24e33f2f3e0c865ed4", size = 56275176, upload-time = "2025-12-08T18:15:03.936Z" }, - { url = "https://files.pythonhosted.org/packages/6a/07/3d31d39c1a1a08cd5337e78299fca77e6aebc07c059fbd0033e3edfab45c/llvmlite-0.46.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cbfd366e60ff87ea6cc62f50bc4cd800ebb13ed4c149466f50cf2163a473d1e", size = 55128630, upload-time = "2025-12-08T18:15:07.196Z" }, - { url = "https://files.pythonhosted.org/packages/2a/6b/d139535d7590a1bba1ceb68751bef22fadaa5b815bbdf0e858e3875726b2/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38", size = 38138940, upload-time = "2025-12-08T18:15:10.162Z" }, + { url = "https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3", size = 4398, upload-time = "2022-04-20T22:04:42.23Z" }, ] [[package]] @@ -2559,16 +3212,24 @@ wheels = [ ] [[package]] -name = "mariadb" -version = "1.1.14" +name = "mako" +version = "1.3.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging" }, + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c4/ba/cedef19833be88e07bfff11964441cda8a998f1628dd3b2fa3e7751d36e0/mariadb-1.1.14.tar.gz", hash = "sha256:e6d702a53eccf20922e47f2f45cfb5c7a0c2c6c0a46e4ee2d8a80d0ff4a52f34", size = 111715, upload-time = "2025-10-07T06:45:48.017Z" } + +[[package]] +name = "markdown" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/7dd27d9d863b3376fcf23a5a13cb5d024aed1db46f963f1b5735ae43b3be/markdown-3.10.tar.gz", hash = "sha256:37062d4f2aa4b2b6b32aefb80faa300f82cc790cb949a35b8caede34f2b68c0e", size = 364931, upload-time = "2025-11-03T19:51:15.007Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/00/04/659a8d30513700b5921ec96bddc07f550016c045fcbeb199d8cd18476ecc/mariadb-1.1.14-cp312-cp312-win32.whl", hash = "sha256:98d552a8bb599eceaa88f65002ad00bd88aeed160592c273a7e5c1d79ab733dd", size = 185266, upload-time = "2025-10-07T06:45:34.164Z" }, - { url = "https://files.pythonhosted.org/packages/e4/a9/8f210291bc5fc044e20497454f40d35b3bab326e2cab6fccdc38121cb2c1/mariadb-1.1.14-cp312-cp312-win_amd64.whl", hash = "sha256:685a1ad2a24fd0aae1c4416fe0ac794adc84ab9209c8d0c57078f770d39731db", size = 202112, upload-time = "2025-10-07T06:45:35.824Z" }, + { url = "https://files.pythonhosted.org/packages/70/81/54e3ce63502cd085a0c556652a4e1b919c45a446bd1e5300e10c44c8c521/markdown-3.10-py3-none-any.whl", hash = "sha256:b5b99d6951e2e4948d939255596523444c0e677c669700b1d17aa4a8a464cb7c", size = 107678, upload-time = "2025-11-03T19:51:13.887Z" }, ] [[package]] @@ -2715,6 +3376,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/fd/f7420e8cbce45c259c770cac5718badf907b302d3a99ec587ba5ce030237/mmh3-5.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:3d6bfd9662a20c054bc216f861fa330c2dac7c81e7fb8307b5e32ab5b9b4d2e0", size = 39350, upload-time = "2025-07-29T07:42:29.794Z" }, ] +[[package]] +name = "mne" +version = "1.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "decorator" }, + { name = "jinja2" }, + { name = "lazy-loader" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pooch" }, + { name = "scipy" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9b/4f/ed4c27b6179665235a7ce3a738b24a05cafe9fa67f728994361598b27c2f/mne-1.11.0.tar.gz", hash = "sha256:0a89b8fc44133b81218a35cdcba74ad0f8ae2e265136249b365b9ce04864c688", size = 7152794, upload-time = "2025-11-21T19:34:45.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/60/a9b51009f6df38b491a874b3ca5db1ce37395c6327faca1008e71e9814e6/mne-1.11.0-py3-none-any.whl", hash = "sha256:993f25b0c92e563c23cb272c42c6c0298be10f40ed50abe4dd2deeba8d184ac2", size = 7451119, upload-time = "2025-11-21T19:34:43.463Z" }, +] + [[package]] name = "monarch-py" version = "1.23.1" @@ -2742,6 +3423,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/be/3b/6b13ac39ed9e714c75214ae9d6bb70f272ea65c36e37b8a396ebff20e2da/monarch_py-1.23.1-py3-none-any.whl", hash = "sha256:9cba9cad1c88745fba19b699a5e81aee653802568997c700e7d1707b863aecd1", size = 71086, upload-time = "2025-12-10T04:04:01.81Z" }, ] +[[package]] +name = "mongomock" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "pytz" }, + { name = "sentinels" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4d/a4/4a560a9f2a0bec43d5f63104f55bc48666d619ca74825c8ae156b08547cf/mongomock-4.3.0.tar.gz", hash = "sha256:32667b79066fabc12d4f17f16a8fd7361b5f4435208b3ba32c226e52212a8c30", size = 135862, upload-time = "2024-11-16T11:23:25.957Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/4d/8bea712978e3aff017a2ab50f262c620e9239cc36f348aae45e48d6a4786/mongomock-4.3.0-py2.py3-none-any.whl", hash = "sha256:5ef86bd12fc8806c6e7af32f21266c61b6c4ba96096f85129852d1c4fec1327e", size = 64891, upload-time = "2024-11-16T11:23:24.748Z" }, +] + [[package]] name = "more-click" version = "0.1.3" @@ -2789,6 +3484,33 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, ] +[[package]] +name = "multidict" +version = "6.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload-time = "2025-10-06T14:49:20.884Z" }, + { url = "https://files.pythonhosted.org/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload-time = "2025-10-06T14:49:22.054Z" }, + { url = "https://files.pythonhosted.org/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload-time = "2025-10-06T14:49:23.566Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload-time = "2025-10-06T14:49:24.882Z" }, + { url = "https://files.pythonhosted.org/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload-time = "2025-10-06T14:49:26.778Z" }, + { url = "https://files.pythonhosted.org/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload-time = "2025-10-06T14:49:28.562Z" }, + { url = "https://files.pythonhosted.org/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload-time = "2025-10-06T14:49:29.96Z" }, + { url = "https://files.pythonhosted.org/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload-time = "2025-10-06T14:49:31.404Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload-time = "2025-10-06T14:49:32.974Z" }, + { url = "https://files.pythonhosted.org/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload-time = "2025-10-06T14:49:34.52Z" }, + { url = "https://files.pythonhosted.org/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload-time = "2025-10-06T14:49:35.956Z" }, + { url = "https://files.pythonhosted.org/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload-time = "2025-10-06T14:49:37.631Z" }, + { url = "https://files.pythonhosted.org/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload-time = "2025-10-06T14:49:39.502Z" }, + { url = "https://files.pythonhosted.org/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload-time = "2025-10-06T14:49:41.32Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload-time = "2025-10-06T14:49:46.021Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload-time = "2025-10-06T14:49:48.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload-time = "2025-10-06T14:49:50.28Z" }, + { url = "https://files.pythonhosted.org/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload-time = "2025-10-06T14:49:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" }, +] + [[package]] name = "murmurhash" version = "1.0.15" @@ -2843,16 +3565,25 @@ wheels = [ [[package]] name = "narwhals" -version = "2.13.0" +version = "2.14.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/89/ea/f82ef99ced4d03c33bb314c9b84a08a0a86c448aaa11ffd6256b99538aa5/narwhals-2.13.0.tar.gz", hash = "sha256:ee94c97f4cf7cfeebbeca8d274784df8b3d7fd3f955ce418af998d405576fdd9", size = 594555, upload-time = "2025-12-01T13:54:05.329Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/84/897fe7b6406d436ef312e57e5a1a13b4a5e7e36d1844e8d934ce8880e3d3/narwhals-2.14.0.tar.gz", hash = "sha256:98be155c3599db4d5c211e565c3190c398c87e7bf5b3cdb157dece67641946e0", size = 600648, upload-time = "2025-12-16T11:29:13.458Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/87/0d/1861d1599571974b15b025e12b142d8e6b42ad66c8a07a89cb0fc21f1e03/narwhals-2.13.0-py3-none-any.whl", hash = "sha256:9b795523c179ca78204e3be53726da374168f906e38de2ff174c2363baaaf481", size = 426407, upload-time = "2025-12-01T13:54:03.861Z" }, + { url = "https://files.pythonhosted.org/packages/79/3e/b8ecc67e178919671695f64374a7ba916cf0adbf86efedc6054f38b5b8ae/narwhals-2.14.0-py3-none-any.whl", hash = "sha256:b56796c9a00179bd757d15282c540024e1d5c910b19b8c9944d836566c030acf", size = 430788, upload-time = "2025-12-16T11:29:11.699Z" }, +] + +[[package]] +name = "natsort" +version = "8.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e2/a9/a0c57aee75f77794adaf35322f8b6404cbd0f89ad45c87197a937764b7d0/natsort-8.4.0.tar.gz", hash = "sha256:45312c4a0e5507593da193dedd04abb1469253b601ecaf63445ad80f0a1ea581", size = 76575, upload-time = "2023-06-20T04:17:19.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/82/7a9d0550484a62c6da82858ee9419f3dd1ccc9aa1c26a1e43da3ecd20b0d/natsort-8.4.0-py3-none-any.whl", hash = "sha256:4732914fb471f56b5cce04d7bae6f164a592c7712e1c85f9ef585e197299521c", size = 38268, upload-time = "2023-06-20T04:17:17.522Z" }, ] [[package]] name = "nbclient" -version = "0.10.2" +version = "0.10.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-client" }, @@ -2860,9 +3591,9 @@ dependencies = [ { name = "nbformat" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/f3/1f6cf2ede4b026bc5f0b424cb41adf22f9c804e90a4dbd4fdb42291a35d5/nbclient-0.10.3.tar.gz", hash = "sha256:0baf171ee246e3bb2391da0635e719f27dc77d99aef59e0b04dcb935ee04c575", size = 62564, upload-time = "2025-12-19T15:50:09.331Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, + { url = "https://files.pythonhosted.org/packages/b2/77/0c73678f5260501a271fd7342bee5d639440f2e9e07d590f1100a056d87c/nbclient-0.10.3-py3-none-any.whl", hash = "sha256:39e9bd403504dd2484dd0fd25235bb6a683ce8cd9873356e40d880696adc9e35", size = 25473, upload-time = "2025-12-19T15:50:07.671Z" }, ] [[package]] @@ -2968,6 +3699,26 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b8/f5/7f6aa3bbff013c0bf993129cbb2b1505790091f812accbe85cf001514737/nibabel-5.3.3-py3-none-any.whl", hash = "sha256:e8b17423ee8464da3b69e6a15799eb19f2350a7d38377026d527b6b84938adac", size = 3293989, upload-time = "2025-12-05T19:16:51.941Z" }, ] +[[package]] +name = "nilearn" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "lxml" }, + { name = "nibabel" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "requests" }, + { name = "scikit-learn" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4f/1c/5d6ef3f80145889bee1c7abbf107c88e7adea7d5b498633f8644910c673c/nilearn-0.12.1.tar.gz", hash = "sha256:a08bbfae94d0fac5ba0aebbbcd864b7f91d1ef5725d1c309ce643dd64b2391b9", size = 25134624, upload-time = "2025-09-03T06:00:40.631Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/90/f17ebc6914b9ed0b577475a17a0b8d31e929897f7002bae1b03438852dad/nilearn-0.12.1-py3-none-any.whl", hash = "sha256:2112e1cdf9f7b96e0af87d679997e834ee36534fc0a970811a703700820edc4c", size = 12743284, upload-time = "2025-09-03T06:00:18.625Z" }, +] + [[package]] name = "nodeenv" version = "1.9.1" @@ -2979,7 +3730,7 @@ wheels = [ [[package]] name = "notebook" -version = "7.5.0" +version = "7.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-server" }, @@ -2988,9 +3739,9 @@ dependencies = [ { name = "notebook-shim" }, { name = "tornado" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/89/ac/a97041621250a4fc5af379fb377942841eea2ca146aab166b8fcdfba96c2/notebook-7.5.0.tar.gz", hash = "sha256:3b27eaf9913033c28dde92d02139414c608992e1df4b969c843219acf2ff95e4", size = 14052074, upload-time = "2025-11-19T08:36:20.093Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/a9/882707b0aa639e6d7d3e7df4bfbe07479d832e9a8f02d8471002a4ea6d65/notebook-7.5.1.tar.gz", hash = "sha256:b2fb4cef4d47d08c33aecce1c6c6e84be05436fbd791f88fce8df9fbca088b75", size = 14058696, upload-time = "2025-12-16T07:38:59.223Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/73/96/00df2a4760f10f5af0f45c4955573cae6189931f9a30265a35865f8c1031/notebook-7.5.0-py3-none-any.whl", hash = "sha256:3300262d52905ca271bd50b22617681d95f08a8360d099e097726e6d2efb5811", size = 14460968, upload-time = "2025-11-19T08:36:15.869Z" }, + { url = "https://files.pythonhosted.org/packages/d1/86/ca516cb58ad2cb2064124d31cf0fd8b012fca64bebeb26da2d2ddf03fc79/notebook-7.5.1-py3-none-any.whl", hash = "sha256:f4e2451c19910c33b88709b84537e11f6368c1cdff1aa0c43db701aea535dd44", size = 14468080, upload-time = "2025-12-16T07:38:55.644Z" }, ] [[package]] @@ -3019,18 +3770,19 @@ wheels = [ [[package]] name = "numba" -version = "0.63.1" +version = "0.62.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "llvmlite" }, { name = "numpy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/dc/60/0145d479b2209bd8fdae5f44201eceb8ce5a23e0ed54c71f57db24618665/numba-0.63.1.tar.gz", hash = "sha256:b320aa675d0e3b17b40364935ea52a7b1c670c9037c39cf92c49502a75902f4b", size = 2761666, upload-time = "2025-12-10T02:57:39.002Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/20/33dbdbfe60e5fd8e3dbfde299d106279a33d9f8308346022316781368591/numba-0.62.1.tar.gz", hash = "sha256:7b774242aa890e34c21200a1fc62e5b5757d5286267e71103257f4e2af0d5161", size = 2749817, upload-time = "2025-09-29T10:46:31.551Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/9c/c0974cd3d00ff70d30e8ff90522ba5fbb2bcee168a867d2321d8d0457676/numba-0.63.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2819cd52afa5d8d04e057bdfd54367575105f8829350d8fb5e4066fb7591cc71", size = 2680981, upload-time = "2025-12-10T02:57:17.579Z" }, - { url = "https://files.pythonhosted.org/packages/cb/70/ea2bc45205f206b7a24ee68a159f5097c9ca7e6466806e7c213587e0c2b1/numba-0.63.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5cfd45dbd3d409e713b1ccfdc2ee72ca82006860254429f4ef01867fdba5845f", size = 3801656, upload-time = "2025-12-10T02:57:19.106Z" }, - { url = "https://files.pythonhosted.org/packages/0d/82/4f4ba4fd0f99825cbf3cdefd682ca3678be1702b63362011de6e5f71f831/numba-0.63.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69a599df6976c03b7ecf15d05302696f79f7e6d10d620367407517943355bcb0", size = 3501857, upload-time = "2025-12-10T02:57:20.721Z" }, - { url = "https://files.pythonhosted.org/packages/af/fd/6540456efa90b5f6604a86ff50dabefb187e43557e9081adcad3be44f048/numba-0.63.1-cp312-cp312-win_amd64.whl", hash = "sha256:bbad8c63e4fc7eb3cdb2c2da52178e180419f7969f9a685f283b313a70b92af3", size = 2750282, upload-time = "2025-12-10T02:57:22.474Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/30fa6873e9f821c0ae755915a3ca444e6ff8d6a7b6860b669a3d33377ac7/numba-0.62.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:1b743b32f8fa5fff22e19c2e906db2f0a340782caf024477b97801b918cf0494", size = 2685346, upload-time = "2025-09-29T10:43:43.677Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d5/504ce8dc46e0dba2790c77e6b878ee65b60fe3e7d6d0006483ef6fde5a97/numba-0.62.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fa21b0142bcf08ad8e32a97d25d0b84b1e921bc9423f8dda07d3652860eef6", size = 2688139, upload-time = "2025-09-29T10:44:04.894Z" }, + { url = "https://files.pythonhosted.org/packages/50/5f/6a802741176c93f2ebe97ad90751894c7b0c922b52ba99a4395e79492205/numba-0.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6ef84d0ac19f1bf80431347b6f4ce3c39b7ec13f48f233a48c01e2ec06ecbc59", size = 3796453, upload-time = "2025-09-29T10:42:52.771Z" }, + { url = "https://files.pythonhosted.org/packages/7e/df/efd21527d25150c4544eccc9d0b7260a5dec4b7e98b5a581990e05a133c0/numba-0.62.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9315cc5e441300e0ca07c828a627d92a6802bcbf27c5487f31ae73783c58da53", size = 3496451, upload-time = "2025-09-29T10:43:19.279Z" }, + { url = "https://files.pythonhosted.org/packages/80/44/79bfdab12a02796bf4f1841630355c82b5a69933b1d50eb15c7fa37dabe8/numba-0.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:44e3aa6228039992f058f5ebfcfd372c83798e9464297bdad8cc79febcf7891e", size = 2745552, upload-time = "2025-09-29T10:44:26.399Z" }, ] [[package]] @@ -3306,7 +4058,7 @@ wheels = [ [[package]] name = "openai" -version = "2.11.0" +version = "2.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -3318,9 +4070,9 @@ dependencies = [ { name = "tqdm" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f4/8c/aa6aea6072f985ace9d6515046b9088ff00c157f9654da0c7b1e129d9506/openai-2.11.0.tar.gz", hash = "sha256:b3da01d92eda31524930b6ec9d7167c535e843918d7ba8a76b1c38f1104f321e", size = 624540, upload-time = "2025-12-11T19:11:58.539Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/b1/12fe1c196bea326261718eb037307c1c1fe1dedc2d2d4de777df822e6238/openai-2.14.0.tar.gz", hash = "sha256:419357bedde9402d23bf8f2ee372fca1985a73348debba94bddff06f19459952", size = 626938, upload-time = "2025-12-19T03:28:45.742Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/f1/d9251b565fce9f8daeb45611e3e0d2f7f248429e40908dcee3b6fe1b5944/openai-2.11.0-py3-none-any.whl", hash = "sha256:21189da44d2e3d027b08c7a920ba4454b8b7d6d30ae7e64d9de11dbe946d4faa", size = 1064131, upload-time = "2025-12-11T19:11:56.816Z" }, + { url = "https://files.pythonhosted.org/packages/27/4b/7c1a00c2c3fbd004253937f7520f692a9650767aa73894d7a34f0d65d3f4/openai-2.14.0-py3-none-any.whl", hash = "sha256:7ea40aca4ffc4c4a776e77679021b47eec1160e341f42ae086ba949c9dcc9183", size = 1067558, upload-time = "2025-12-19T03:28:43.727Z" }, ] [[package]] @@ -3465,11 +4217,11 @@ wheels = [ [[package]] name = "packaging" -version = "25.0" +version = "24.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" }, ] [[package]] @@ -3520,6 +4272,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" }, ] +[[package]] +name = "partd" +version = "1.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "locket" }, + { name = "toolz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029, upload-time = "2024-05-06T19:51:41.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905, upload-time = "2024-05-06T19:51:39.271Z" }, +] + [[package]] name = "pathlib-abc" version = "0.5.2" @@ -3559,6 +4324,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl", hash = "sha256:37bfddbc58fcf0362febb5f54f10743f8b21dd2aa73dec7e7ef59d1b02ae668a", size = 233301, upload-time = "2025-10-20T16:17:36.563Z" }, ] +[[package]] +name = "pendulum" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/23/7c/009c12b86c7cc6c403aec80f8a4308598dfc5995e5c523a5491faaa3952e/pendulum-3.1.0.tar.gz", hash = "sha256:66f96303560f41d097bee7d2dc98ffca716fbb3a832c4b3062034c2d45865015", size = 85930, upload-time = "2025-04-19T14:30:01.675Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/d7/b1bfe15a742f2c2713acb1fdc7dc3594ff46ef9418ac6a96fcb12a6ba60b/pendulum-3.1.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:4dfd53e7583ccae138be86d6c0a0b324c7547df2afcec1876943c4d481cf9608", size = 336209, upload-time = "2025-04-19T14:01:27.815Z" }, + { url = "https://files.pythonhosted.org/packages/eb/87/0392da0c603c828b926d9f7097fbdddaafc01388cb8a00888635d04758c3/pendulum-3.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6a6e06a28f3a7d696546347805536f6f38be458cb79de4f80754430696bea9e6", size = 323130, upload-time = "2025-04-19T14:01:29.336Z" }, + { url = "https://files.pythonhosted.org/packages/c0/61/95f1eec25796be6dddf71440ee16ec1fd0c573fc61a73bd1ef6daacd529a/pendulum-3.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7e68d6a51880708084afd8958af42dc8c5e819a70a6c6ae903b1c4bfc61e0f25", size = 341509, upload-time = "2025-04-19T14:01:31.1Z" }, + { url = "https://files.pythonhosted.org/packages/b5/7b/eb0f5e6aa87d5e1b467a1611009dbdc92f0f72425ebf07669bfadd8885a6/pendulum-3.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e3f1e5da39a7ea7119efda1dd96b529748c1566f8a983412d0908455d606942", size = 378674, upload-time = "2025-04-19T14:01:32.974Z" }, + { url = "https://files.pythonhosted.org/packages/29/68/5a4c1b5de3e54e16cab21d2ec88f9cd3f18599e96cc90a441c0b0ab6b03f/pendulum-3.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9af1e5eeddb4ebbe1b1c9afb9fd8077d73416ade42dd61264b3f3b87742e0bb", size = 436133, upload-time = "2025-04-19T14:01:34.349Z" }, + { url = "https://files.pythonhosted.org/packages/87/5d/f7a1d693e5c0f789185117d5c1d5bee104f5b0d9fbf061d715fb61c840a8/pendulum-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20f74aa8029a42e327bfc150472e0e4d2358fa5d795f70460160ba81b94b6945", size = 351232, upload-time = "2025-04-19T14:01:35.669Z" }, + { url = "https://files.pythonhosted.org/packages/30/77/c97617eb31f1d0554edb073201a294019b9e0a9bd2f73c68e6d8d048cd6b/pendulum-3.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:cf6229e5ee70c2660148523f46c472e677654d0097bec010d6730f08312a4931", size = 521562, upload-time = "2025-04-19T14:01:37.05Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/0d0ef3393303877e757b848ecef8a9a8c7627e17e7590af82d14633b2cd1/pendulum-3.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:350cabb23bf1aec7c7694b915d3030bff53a2ad4aeabc8c8c0d807c8194113d6", size = 523221, upload-time = "2025-04-19T14:01:38.444Z" }, + { url = "https://files.pythonhosted.org/packages/99/f3/aefb579aa3cebd6f2866b205fc7a60d33e9a696e9e629024752107dc3cf5/pendulum-3.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:42959341e843077c41d47420f28c3631de054abd64da83f9b956519b5c7a06a7", size = 260502, upload-time = "2025-04-19T14:01:39.814Z" }, + { url = "https://files.pythonhosted.org/packages/02/74/4332b5d6e34c63d4df8e8eab2249e74c05513b1477757463f7fdca99e9be/pendulum-3.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:006758e2125da2e624493324dfd5d7d1b02b0c44bc39358e18bf0f66d0767f5f", size = 253089, upload-time = "2025-04-19T14:01:41.171Z" }, + { url = "https://files.pythonhosted.org/packages/6e/23/e98758924d1b3aac11a626268eabf7f3cf177e7837c28d47bf84c64532d0/pendulum-3.1.0-py3-none-any.whl", hash = "sha256:f9178c2a8e291758ade1e8dd6371b1d26d08371b4c7730a6e9a3ef8b16ebae0f", size = 111799, upload-time = "2025-04-19T14:02:34.739Z" }, +] + [[package]] name = "pexpect" version = "4.9.0" @@ -3617,6 +4405,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] +[[package]] +name = "pooch" +version = "1.8.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, + { name = "platformdirs" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c6/77/b3d3e00c696c16cf99af81ef7b1f5fe73bd2a307abca41bd7605429fe6e5/pooch-1.8.2.tar.gz", hash = "sha256:76561f0de68a01da4df6af38e9955c4c9d1a5c90da73f7e40276a5728ec83d10", size = 59353, upload-time = "2024-06-06T16:53:46.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/87/77cc11c7a9ea9fd05503def69e3d18605852cd0d4b0d3b8f15bbeb3ef1d1/pooch-1.8.2-py3-none-any.whl", hash = "sha256:3529a57096f7198778a5ceefd5ac3ef0e4d06a6ddaf9fc2d609b806f25302c47", size = 64574, upload-time = "2024-06-06T16:53:44.343Z" }, +] + [[package]] name = "posthog" version = "5.4.0" @@ -3635,7 +4437,7 @@ wheels = [ [[package]] name = "pre-commit" -version = "4.5.0" +version = "4.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cfgv" }, @@ -3644,9 +4446,72 @@ dependencies = [ { name = "pyyaml" }, { name = "virtualenv" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f4/9b/6a4ffb4ed980519da959e1cf3122fc6cb41211daa58dbae1c73c0e519a37/pre_commit-4.5.0.tar.gz", hash = "sha256:dc5a065e932b19fc1d4c653c6939068fe54325af8e741e74e88db4d28a4dd66b", size = 198428, upload-time = "2025-11-22T21:02:42.304Z" } +sdist = { url = "https://files.pythonhosted.org/packages/40/f1/6d86a29246dfd2e9b6237f0b5823717f60cad94d47ddc26afa916d21f525/pre_commit-4.5.1.tar.gz", hash = "sha256:eb545fcff725875197837263e977ea257a402056661f09dae08e4b149b030a61", size = 198232, upload-time = "2025-12-16T21:14:33.552Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/19/fd3ef348460c80af7bb4669ea7926651d1f95c23ff2df18b9d24bab4f3fa/pre_commit-4.5.1-py2.py3-none-any.whl", hash = "sha256:3b3afd891e97337708c1674210f8eba659b52a38ea5f822ff142d10786221f77", size = 226437, upload-time = "2025-12-16T21:14:32.409Z" }, +] + +[[package]] +name = "prefect" +version = "3.2.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiosqlite" }, + { name = "alembic" }, + { name = "anyio" }, + { name = "apprise" }, + { name = "asgi-lifespan" }, + { name = "asyncpg" }, + { name = "cachetools" }, + { name = "click" }, + { name = "cloudpickle" }, + { name = "coolname" }, + { name = "cryptography" }, + { name = "dateparser" }, + { name = "docker" }, + { name = "exceptiongroup" }, + { name = "fastapi" }, + { name = "fsspec" }, + { name = "graphviz" }, + { name = "griffe" }, + { name = "httpcore" }, + { name = "httpx", extra = ["http2"] }, + { name = "humanize" }, + { name = "jinja2" }, + { name = "jinja2-humanize-extension" }, + { name = "jsonpatch" }, + { name = "jsonschema" }, + { name = "opentelemetry-api" }, + { name = "orjson" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "pendulum" }, + { name = "prometheus-client" }, + { name = "pydantic" }, + { name = "pydantic-core" }, + { name = "pydantic-extra-types" }, + { name = "pydantic-settings" }, + { name = "python-dateutil" }, + { name = "python-slugify" }, + { name = "python-socks" }, + { name = "pytz" }, + { name = "pyyaml" }, + { name = "readchar" }, + { name = "rfc3339-validator" }, + { name = "rich" }, + { name = "ruamel-yaml" }, + { name = "sniffio" }, + { name = "sqlalchemy", extra = ["asyncio"] }, + { name = "toml" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "ujson" }, + { name = "uvicorn" }, + { name = "websockets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/9e/7009c09d4e6a09ff4ad35afa93d5dba901635dd2c8f8e09e1eca597b884d/prefect-3.2.7.tar.gz", hash = "sha256:e24c06acabc38a1062e8672f71fea8a61348e8619df8ce2a4749e7bbf0142b54", size = 5780087, upload-time = "2025-02-21T19:40:28.984Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/c4/b2d28e9d2edf4f1713eb3c29307f1a63f3d67cf09bdda29715a36a68921a/pre_commit-4.5.0-py2.py3-none-any.whl", hash = "sha256:25e2ce09595174d9c97860a95609f9f852c0614ba602de3561e267547f2335e1", size = 226429, upload-time = "2025-11-22T21:02:40.836Z" }, + { url = "https://files.pythonhosted.org/packages/f1/70/13eb4bb6a9224d07fb7893d2d970488a607445d9868aa2acaa034148cdd0/prefect-3.2.7-py3-none-any.whl", hash = "sha256:7c91097e1de68fd6bd6f22bdf883866b757a6b661437b3ba68727936187f1842", size = 6264722, upload-time = "2025-02-21T19:40:25.936Z" }, ] [[package]] @@ -3733,6 +4598,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/79/217ae7eb2462ef254aab95b3610d85105a86f4ec8b43863788e32c0d5369/pronto-2.7.2-py3-none-any.whl", hash = "sha256:9c4b037ae1f9598398f38a55306eb1af7c3cdf8be7d535925500b978b32d1450", size = 62212, upload-time = "2025-11-10T12:45:42.969Z" }, ] +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" }, + { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" }, + { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" }, + { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" }, + { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" }, + { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, +] + [[package]] name = "protobuf" version = "6.33.2" @@ -3771,6 +4660,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, ] +[[package]] +name = "pulp" +version = "3.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/1c/d880b739b841a8aa81143091c9bdda5e72e226a660aa13178cb312d4b27f/pulp-3.3.0.tar.gz", hash = "sha256:7eb99b9ce7beeb8bbb7ea9d1c919f02f003ab7867e0d1e322f2f2c26dd31c8ba", size = 16301847, upload-time = "2025-09-18T08:14:57.552Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/6c/64cafaceea3f99927e84b38a362ec6a8f24f33061c90bda77dfe1cd4c3c6/pulp-3.3.0-py3-none-any.whl", hash = "sha256:dd6ad2d63f196d1254eddf9dcff5cd224912c1f046120cb7c143c5b0eda63fae", size = 16387700, upload-time = "2025-09-18T08:14:53.368Z" }, +] + [[package]] name = "pure-eval" version = "0.2.3" @@ -3798,6 +4696,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2f/6a/15135b69e4fd28369433eb03264d201b1b0040ba534b05eddeb02a276684/py_rust_stemmers-0.1.5-cp312-none-win_amd64.whl", hash = "sha256:6ed61e1207f3b7428e99b5d00c055645c6415bb75033bff2d06394cbe035fd8e", size = 209395, upload-time = "2025-02-19T13:55:36.519Z" }, ] +[[package]] +name = "pyarrow" +version = "22.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" }, + { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" }, + { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" }, + { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" }, +] + [[package]] name = "pyasn1" version = "0.6.1" @@ -3936,23 +4849,69 @@ wheels = [ ] [[package]] -name = "pyee" -version = "11.1.1" +name = "pydantic-extra-types" +version = "2.10.6" source = { registry = "https://pypi.org/simple" } dependencies = [ + { name = "pydantic" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/54/20/3e646860d5a2f9c24b23b1964fb7c65312236883fa7b62d0f64456addc93/pyee-11.1.1.tar.gz", hash = "sha256:82e1eb1853f8497c4ff1a0c7fa26b9cd2f1253e2b6ffb93b4700fda907017302", size = 30002, upload-time = "2024-08-30T19:15:39.282Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/10/fb64987804cde41bcc39d9cd757cd5f2bb5d97b389d81aa70238b14b8a7e/pydantic_extra_types-2.10.6.tar.gz", hash = "sha256:c63d70bf684366e6bbe1f4ee3957952ebe6973d41e7802aea0b770d06b116aeb", size = 141858, upload-time = "2025-10-08T13:47:49.483Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/db/99/7e80837f60b13227f03334e3b0537d650dea2c0cea44c543b0a2e719a48f/pyee-11.1.1-py3-none-any.whl", hash = "sha256:9e4cdd7c2f9fcf247db94bad39a260aceffefdbe52286ce71be01959de34a5c2", size = 15300, upload-time = "2024-08-30T19:15:37.73Z" }, + { url = "https://files.pythonhosted.org/packages/93/04/5c918669096da8d1c9ec7bb716bd72e755526103a61bc5e76a3e4fb23b53/pydantic_extra_types-2.10.6-py3-none-any.whl", hash = "sha256:6106c448316d30abf721b5b9fecc65e983ef2614399a24142d689c7546cc246a", size = 40949, upload-time = "2025-10-08T13:47:48.268Z" }, ] [[package]] -name = "pyflakes" -version = "2.4.0" +name = "pydantic-settings" +version = "2.12.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/15/60/c577e54518086e98470e9088278247f4af1d39cb43bcbd731e2c307acd6a/pyflakes-2.4.0.tar.gz", hash = "sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c", size = 69101, upload-time = "2021-10-06T20:39:50.936Z" } -wheels = [ +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/ac7e0aae12027748076d72a8764ff1c9d82ca75a7a52622e67ed3f765c54/pydantic_settings-2.12.0.tar.gz", hash = "sha256:005538ef951e3c2a68e1c08b292b5f2e71490def8589d4221b95dab00dafcfd0", size = 194184, upload-time = "2025-11-10T14:25:47.013Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" }, +] + +[[package]] +name = "pydeseq2" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anndata" }, + { name = "formulaic" }, + { name = "formulaic-contrasts" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "scikit-learn" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/e2/92bab7a299821396baca1a8c600c273ee13c5a081bcd788adc8e4a000ccc/pydeseq2-0.5.3.tar.gz", hash = "sha256:7dcbb34f80ce8147f566e9080d259b88df193174138983c4a77c1fe18ff3fe76", size = 790037, upload-time = "2025-10-28T15:43:41.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/68/c969b97f7147090273f147a01cf48d87b26296775f02b3caacd4c061ce34/pydeseq2-0.5.3-py3-none-any.whl", hash = "sha256:113842dedaeffdeac0873ed498af2408c58b99fb646a89013f0c7710ae796608", size = 48420, upload-time = "2025-10-28T15:35:51.995Z" }, +] + +[[package]] +name = "pyee" +version = "11.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/20/3e646860d5a2f9c24b23b1964fb7c65312236883fa7b62d0f64456addc93/pyee-11.1.1.tar.gz", hash = "sha256:82e1eb1853f8497c4ff1a0c7fa26b9cd2f1253e2b6ffb93b4700fda907017302", size = 30002, upload-time = "2024-08-30T19:15:39.282Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/99/7e80837f60b13227f03334e3b0537d650dea2c0cea44c543b0a2e719a48f/pyee-11.1.1-py3-none-any.whl", hash = "sha256:9e4cdd7c2f9fcf247db94bad39a260aceffefdbe52286ce71be01959de34a5c2", size = 15300, upload-time = "2024-08-30T19:15:37.73Z" }, +] + +[[package]] +name = "pyflakes" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/60/c577e54518086e98470e9088278247f4af1d39cb43bcbd731e2c307acd6a/pyflakes-2.4.0.tar.gz", hash = "sha256:05a85c2872edf37a4ed30b0cce2f6093e1d0581f8c19d7393122da7e25b2b24c", size = 69101, upload-time = "2021-10-06T20:39:50.936Z" } +wheels = [ { url = "https://files.pythonhosted.org/packages/43/fb/38848eb494af7df9aeb2d7673ace8b213313eb7e391691a79dbaeb6a838f/pyflakes-2.4.0-py2.py3-none-any.whl", hash = "sha256:3bb3a3f256f4b7968c9c788781e4ff07dce46bdf12339dcda61053375426ee2e", size = 69704, upload-time = "2021-10-06T20:39:49.185Z" }, ] @@ -4054,6 +5013,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/35/76/c34426d532e4dce7ff36e4d92cb20f4cbbd94b619964b93d24e8f5b5510f/pynacl-1.6.1-cp38-abi3-win_arm64.whl", hash = "sha256:5953e8b8cfadb10889a6e7bd0f53041a745d1b3d30111386a1bb37af171e6daf", size = 183970, upload-time = "2025-11-10T16:02:05.786Z" }, ] +[[package]] +name = "pynndescent" +version = "0.5.13" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "llvmlite" }, + { name = "numba" }, + { name = "scikit-learn" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/58/560a4db5eb3794d922fe55804b10326534ded3d971e1933c1eef91193f5e/pynndescent-0.5.13.tar.gz", hash = "sha256:d74254c0ee0a1eeec84597d5fe89fedcf778593eeabe32c2f97412934a9800fb", size = 2975955, upload-time = "2024-06-17T15:48:32.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/53/d23a97e0a2c690d40b165d1062e2c4ccc796be458a1ce59f6ba030434663/pynndescent-0.5.13-py3-none-any.whl", hash = "sha256:69aabb8f394bc631b6ac475a1c7f3994c54adf3f51cd63b2730fefba5771b949", size = 56850, upload-time = "2024-06-17T15:48:31.184Z" }, +] + [[package]] name = "pyparsing" version = "3.2.5" @@ -4261,6 +5236,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/51/e5/fecf13f06e5e5f67e8837d777d1bc43fac0ed2b77a676804df5c34744727/python_json_logger-4.0.0-py3-none-any.whl", hash = "sha256:af09c9daf6a813aa4cc7180395f50f2a9e5fa056034c9953aec92e381c5ba1e2", size = 15548, upload-time = "2025-10-06T04:15:17.553Z" }, ] +[[package]] +name = "python-slugify" +version = "8.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "text-unidecode" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/c7/5e1547c44e31da50a460df93af11a535ace568ef89d7a811069ead340c4a/python-slugify-8.0.4.tar.gz", hash = "sha256:59202371d1d05b54a9e7720c5e038f928f45daaffe41dd10822f3907b937c856", size = 10921, upload-time = "2024-02-08T18:32:45.488Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/62/02da182e544a51a5c3ccf4b03ab79df279f9c60c5e82d5e8bec7ca26ac11/python_slugify-8.0.4-py2.py3-none-any.whl", hash = "sha256:276540b79961052b66b7d116620b36518847f52d5fd9e3a70164fc8c50faa6b8", size = 10051, upload-time = "2024-02-08T18:32:43.911Z" }, +] + +[[package]] +name = "python-socks" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/07/cfdd6a846ac859e513b4e68bb6c669a90a74d89d8d405516fba7fc9c6f0c/python_socks-2.8.0.tar.gz", hash = "sha256:340f82778b20a290bdd538ee47492978d603dff7826aaf2ce362d21ad9ee6f1b", size = 273130, upload-time = "2025-12-09T12:17:05.433Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/10/e2b575faa32d1d32e5e6041fc64794fa9f09526852a06b25353b66f52cae/python_socks-2.8.0-py3-none-any.whl", hash = "sha256:57c24b416569ccea493a101d38b0c82ed54be603aa50b6afbe64c46e4a4e4315", size = 55075, upload-time = "2025-12-09T12:17:03.269Z" }, +] + [[package]] name = "pytz" version = "2025.2" @@ -4380,6 +5376,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5f/97/d8a785d2c7131c731c90cb0e65af9400081af4380bea4ec04868dc21aa92/rdflib_shim-1.0.3-py3-none-any.whl", hash = "sha256:7a853e7750ef1e9bf4e35dea27d54e02d4ed087de5a9e0c329c4a6d82d647081", size = 5190, upload-time = "2021-12-21T16:31:05.719Z" }, ] +[[package]] +name = "readchar" +version = "4.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dd/f8/8657b8cbb4ebeabfbdf991ac40eca8a1d1bd012011bd44ad1ed10f5cb494/readchar-4.2.1.tar.gz", hash = "sha256:91ce3faf07688de14d800592951e5575e9c7a3213738ed01d394dcc949b79adb", size = 9685, upload-time = "2024-11-04T18:28:07.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/10/e4b1e0e5b6b6745c8098c275b69bc9d73e9542d5c7da4f137542b499ed44/readchar-4.2.1-py3-none-any.whl", hash = "sha256:a769305cd3994bb5fa2764aa4073452dc105a4ec39068ffe6efd3c20c60acc77", size = 9350, upload-time = "2024-11-04T18:28:02.859Z" }, +] + [[package]] name = "referencing" version = "0.37.0" @@ -4473,6 +5478,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, ] +[[package]] +name = "reretry" +version = "0.11.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/40/1d/25d562a62b7471616bccd7c15a7533062eb383927e68667bf331db990415/reretry-0.11.8.tar.gz", hash = "sha256:f2791fcebe512ea2f1d153a2874778523a8064860b591cd90afc21a8bed432e3", size = 4836, upload-time = "2022-12-18T11:08:50.641Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/11/e295e07d4ae500144177f875a8de11daa4d86b8246ab41c76a98ce9280ca/reretry-0.11.8-py2.py3-none-any.whl", hash = "sha256:5ec1084cd9644271ee386d34cd5dd24bdb3e91d55961b076d1a31d585ad68a79", size = 5609, upload-time = "2022-12-18T11:08:49.1Z" }, +] + [[package]] name = "rfc3339-validator" version = "0.1.4" @@ -4517,15 +5531,15 @@ wheels = [ [[package]] name = "rich" -version = "14.2.0" +version = "13.9.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markdown-it-py" }, { name = "pygments" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149, upload-time = "2024-11-01T16:43:57.873Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424, upload-time = "2024-11-01T16:43:55.817Z" }, ] [[package]] @@ -4606,30 +5620,60 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" }, ] +[[package]] +name = "ruamel-yaml" +version = "0.18.17" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ruamel-yaml-clib", marker = "platform_python_implementation == 'CPython'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/2b/7a1f1ebcd6b3f14febdc003e658778d81e76b40df2267904ee6b13f0c5c6/ruamel_yaml-0.18.17.tar.gz", hash = "sha256:9091cd6e2d93a3a4b157ddb8fabf348c3de7f1fb1381346d985b6b247dcd8d3c", size = 149602, upload-time = "2025-12-17T20:02:55.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/fe/b6045c782f1fd1ae317d2a6ca1884857ce5c20f59befe6ab25a8603c43a7/ruamel_yaml-0.18.17-py3-none-any.whl", hash = "sha256:9c8ba9eb3e793efdf924b60d521820869d5bf0cb9c6f1b82d82de8295e290b9d", size = 121594, upload-time = "2025-12-17T20:02:07.657Z" }, +] + +[[package]] +name = "ruamel-yaml-clib" +version = "0.2.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/97/60fda20e2fb54b83a61ae14648b0817c8f5d84a3821e40bfbdae1437026a/ruamel_yaml_clib-0.2.15.tar.gz", hash = "sha256:46e4cc8c43ef6a94885f72512094e482114a8a706d3c555a34ed4b0d20200600", size = 225794, upload-time = "2025-11-16T16:12:59.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/4b/5fde11a0722d676e469d3d6f78c6a17591b9c7e0072ca359801c4bd17eee/ruamel_yaml_clib-0.2.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb15a2e2a90c8475df45c0949793af1ff413acfb0a716b8b94e488ea95ce7cff", size = 149088, upload-time = "2025-11-16T16:13:22.836Z" }, + { url = "https://files.pythonhosted.org/packages/85/82/4d08ac65ecf0ef3b046421985e66301a242804eb9a62c93ca3437dc94ee0/ruamel_yaml_clib-0.2.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:64da03cbe93c1e91af133f5bec37fd24d0d4ba2418eaf970d7166b0a26a148a2", size = 134553, upload-time = "2025-11-16T16:13:24.151Z" }, + { url = "https://files.pythonhosted.org/packages/b9/cb/22366d68b280e281a932403b76da7a988108287adff2bfa5ce881200107a/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f6d3655e95a80325b84c4e14c080b2470fe4f33b6846f288379ce36154993fb1", size = 737468, upload-time = "2025-11-16T20:22:47.335Z" }, + { url = "https://files.pythonhosted.org/packages/71/73/81230babf8c9e33770d43ed9056f603f6f5f9665aea4177a2c30ae48e3f3/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71845d377c7a47afc6592aacfea738cc8a7e876d586dfba814501d8c53c1ba60", size = 753349, upload-time = "2025-11-16T16:13:26.269Z" }, + { url = "https://files.pythonhosted.org/packages/61/62/150c841f24cda9e30f588ef396ed83f64cfdc13b92d2f925bb96df337ba9/ruamel_yaml_clib-0.2.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e5499db1ccbc7f4b41f0565e4f799d863ea720e01d3e99fa0b7b5fcd7802c9", size = 788211, upload-time = "2025-11-16T16:13:27.441Z" }, + { url = "https://files.pythonhosted.org/packages/30/93/e79bd9cbecc3267499d9ead919bd61f7ddf55d793fb5ef2b1d7d92444f35/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4b293a37dc97e2b1e8a1aec62792d1e52027087c8eea4fc7b5abd2bdafdd6642", size = 743203, upload-time = "2025-11-16T16:13:28.671Z" }, + { url = "https://files.pythonhosted.org/packages/8d/06/1eb640065c3a27ce92d76157f8efddb184bd484ed2639b712396a20d6dce/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:512571ad41bba04eac7268fe33f7f4742210ca26a81fe0c75357fa682636c690", size = 747292, upload-time = "2025-11-16T20:22:48.584Z" }, + { url = "https://files.pythonhosted.org/packages/a5/21/ee353e882350beab65fcc47a91b6bdc512cace4358ee327af2962892ff16/ruamel_yaml_clib-0.2.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5e9f630c73a490b758bf14d859a39f375e6999aea5ddd2e2e9da89b9953486a", size = 771624, upload-time = "2025-11-16T16:13:29.853Z" }, + { url = "https://files.pythonhosted.org/packages/57/34/cc1b94057aa867c963ecf9ea92ac59198ec2ee3a8d22a126af0b4d4be712/ruamel_yaml_clib-0.2.15-cp312-cp312-win32.whl", hash = "sha256:f4421ab780c37210a07d138e56dd4b51f8642187cdfb433eb687fe8c11de0144", size = 100342, upload-time = "2025-11-16T16:13:31.067Z" }, + { url = "https://files.pythonhosted.org/packages/b3/e5/8925a4208f131b218f9a7e459c0d6fcac8324ae35da269cb437894576366/ruamel_yaml_clib-0.2.15-cp312-cp312-win_amd64.whl", hash = "sha256:2b216904750889133d9222b7b873c199d48ecbb12912aca78970f84a5aa1a4bc", size = 119013, upload-time = "2025-11-16T16:13:32.164Z" }, +] + [[package]] name = "ruff" -version = "0.14.9" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/1b/ab712a9d5044435be8e9a2beb17cbfa4c241aa9b5e4413febac2a8b79ef2/ruff-0.14.9.tar.gz", hash = "sha256:35f85b25dd586381c0cc053f48826109384c81c00ad7ef1bd977bfcc28119d5b", size = 5809165, upload-time = "2025-12-11T21:39:47.381Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/1c/d1b1bba22cffec02351c78ab9ed4f7d7391876e12720298448b29b7229c1/ruff-0.14.9-py3-none-linux_armv6l.whl", hash = "sha256:f1ec5de1ce150ca6e43691f4a9ef5c04574ad9ca35c8b3b0e18877314aba7e75", size = 13576541, upload-time = "2025-12-11T21:39:14.806Z" }, - { url = "https://files.pythonhosted.org/packages/94/ab/ffe580e6ea1fca67f6337b0af59fc7e683344a43642d2d55d251ff83ceae/ruff-0.14.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ed9d7417a299fc6030b4f26333bf1117ed82a61ea91238558c0268c14e00d0c2", size = 13779363, upload-time = "2025-12-11T21:39:20.29Z" }, - { url = "https://files.pythonhosted.org/packages/7d/f8/2be49047f929d6965401855461e697ab185e1a6a683d914c5c19c7962d9e/ruff-0.14.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d5dc3473c3f0e4a1008d0ef1d75cee24a48e254c8bed3a7afdd2b4392657ed2c", size = 12925292, upload-time = "2025-12-11T21:39:38.757Z" }, - { url = "https://files.pythonhosted.org/packages/9e/e9/08840ff5127916bb989c86f18924fd568938b06f58b60e206176f327c0fe/ruff-0.14.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84bf7c698fc8f3cb8278830fb6b5a47f9bcc1ed8cb4f689b9dd02698fa840697", size = 13362894, upload-time = "2025-12-11T21:39:02.524Z" }, - { url = "https://files.pythonhosted.org/packages/31/1c/5b4e8e7750613ef43390bb58658eaf1d862c0cc3352d139cd718a2cea164/ruff-0.14.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aa733093d1f9d88a5d98988d8834ef5d6f9828d03743bf5e338bf980a19fce27", size = 13311482, upload-time = "2025-12-11T21:39:17.51Z" }, - { url = "https://files.pythonhosted.org/packages/5b/3a/459dce7a8cb35ba1ea3e9c88f19077667a7977234f3b5ab197fad240b404/ruff-0.14.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a1cfb04eda979b20c8c19550c8b5f498df64ff8da151283311ce3199e8b3648", size = 14016100, upload-time = "2025-12-11T21:39:41.948Z" }, - { url = "https://files.pythonhosted.org/packages/a6/31/f064f4ec32524f9956a0890fc6a944e5cf06c63c554e39957d208c0ffc45/ruff-0.14.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1e5cb521e5ccf0008bd74d5595a4580313844a42b9103b7388eca5a12c970743", size = 15477729, upload-time = "2025-12-11T21:39:23.279Z" }, - { url = "https://files.pythonhosted.org/packages/7a/6d/f364252aad36ccd443494bc5f02e41bf677f964b58902a17c0b16c53d890/ruff-0.14.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd429a8926be6bba4befa8cdcf3f4dd2591c413ea5066b1e99155ed245ae42bb", size = 15122386, upload-time = "2025-12-11T21:39:33.125Z" }, - { url = "https://files.pythonhosted.org/packages/20/02/e848787912d16209aba2799a4d5a1775660b6a3d0ab3944a4ccc13e64a02/ruff-0.14.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab208c1b7a492e37caeaf290b1378148f75e13c2225af5d44628b95fd7834273", size = 14497124, upload-time = "2025-12-11T21:38:59.33Z" }, - { url = "https://files.pythonhosted.org/packages/f3/51/0489a6a5595b7760b5dbac0dd82852b510326e7d88d51dbffcd2e07e3ff3/ruff-0.14.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72034534e5b11e8a593f517b2f2f2b273eb68a30978c6a2d40473ad0aaa4cb4a", size = 14195343, upload-time = "2025-12-11T21:39:44.866Z" }, - { url = "https://files.pythonhosted.org/packages/f6/53/3bb8d2fa73e4c2f80acc65213ee0830fa0c49c6479313f7a68a00f39e208/ruff-0.14.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:712ff04f44663f1b90a1195f51525836e3413c8a773574a7b7775554269c30ed", size = 14346425, upload-time = "2025-12-11T21:39:05.927Z" }, - { url = "https://files.pythonhosted.org/packages/ad/04/bdb1d0ab876372da3e983896481760867fc84f969c5c09d428e8f01b557f/ruff-0.14.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a111fee1db6f1d5d5810245295527cda1d367c5aa8f42e0fca9a78ede9b4498b", size = 13258768, upload-time = "2025-12-11T21:39:08.691Z" }, - { url = "https://files.pythonhosted.org/packages/40/d9/8bf8e1e41a311afd2abc8ad12be1b6c6c8b925506d9069b67bb5e9a04af3/ruff-0.14.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8769efc71558fecc25eb295ddec7d1030d41a51e9dcf127cbd63ec517f22d567", size = 13326939, upload-time = "2025-12-11T21:39:53.842Z" }, - { url = "https://files.pythonhosted.org/packages/f4/56/a213fa9edb6dd849f1cfbc236206ead10913693c72a67fb7ddc1833bf95d/ruff-0.14.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:347e3bf16197e8a2de17940cd75fd6491e25c0aa7edf7d61aa03f146a1aa885a", size = 13578888, upload-time = "2025-12-11T21:39:35.988Z" }, - { url = "https://files.pythonhosted.org/packages/33/09/6a4a67ffa4abae6bf44c972a4521337ffce9cbc7808faadede754ef7a79c/ruff-0.14.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7715d14e5bccf5b660f54516558aa94781d3eb0838f8e706fb60e3ff6eff03a8", size = 14314473, upload-time = "2025-12-11T21:39:50.78Z" }, - { url = "https://files.pythonhosted.org/packages/12/0d/15cc82da5d83f27a3c6b04f3a232d61bc8c50d38a6cd8da79228e5f8b8d6/ruff-0.14.9-py3-none-win32.whl", hash = "sha256:df0937f30aaabe83da172adaf8937003ff28172f59ca9f17883b4213783df197", size = 13202651, upload-time = "2025-12-11T21:39:26.628Z" }, - { url = "https://files.pythonhosted.org/packages/32/f7/c78b060388eefe0304d9d42e68fab8cffd049128ec466456cef9b8d4f06f/ruff-0.14.9-py3-none-win_amd64.whl", hash = "sha256:c0b53a10e61df15a42ed711ec0bda0c582039cf6c754c49c020084c55b5b0bc2", size = 14702079, upload-time = "2025-12-11T21:39:11.954Z" }, - { url = "https://files.pythonhosted.org/packages/26/09/7a9520315decd2334afa65ed258fed438f070e31f05a2e43dd480a5e5911/ruff-0.14.9-py3-none-win_arm64.whl", hash = "sha256:8e821c366517a074046d92f0e9213ed1c13dbc5b37a7fc20b07f79b64d62cc84", size = 13744730, upload-time = "2025-12-11T21:39:29.659Z" }, +version = "0.14.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/08/52232a877978dd8f9cf2aeddce3e611b40a63287dfca29b6b8da791f5e8d/ruff-0.14.10.tar.gz", hash = "sha256:9a2e830f075d1a42cd28420d7809ace390832a490ed0966fe373ba288e77aaf4", size = 5859763, upload-time = "2025-12-18T19:28:57.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/01/933704d69f3f05ee16ef11406b78881733c186fe14b6a46b05cfcaf6d3b2/ruff-0.14.10-py3-none-linux_armv6l.whl", hash = "sha256:7a3ce585f2ade3e1f29ec1b92df13e3da262178df8c8bdf876f48fa0e8316c49", size = 13527080, upload-time = "2025-12-18T19:29:25.642Z" }, + { url = "https://files.pythonhosted.org/packages/df/58/a0349197a7dfa603ffb7f5b0470391efa79ddc327c1e29c4851e85b09cc5/ruff-0.14.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:674f9be9372907f7257c51f1d4fc902cb7cf014b9980152b802794317941f08f", size = 13797320, upload-time = "2025-12-18T19:29:02.571Z" }, + { url = "https://files.pythonhosted.org/packages/7b/82/36be59f00a6082e38c23536df4e71cdbc6af8d7c707eade97fcad5c98235/ruff-0.14.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d85713d522348837ef9df8efca33ccb8bd6fcfc86a2cde3ccb4bc9d28a18003d", size = 12918434, upload-time = "2025-12-18T19:28:51.202Z" }, + { url = "https://files.pythonhosted.org/packages/a6/00/45c62a7f7e34da92a25804f813ebe05c88aa9e0c25e5cb5a7d23dd7450e3/ruff-0.14.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6987ebe0501ae4f4308d7d24e2d0fe3d7a98430f5adfd0f1fead050a740a3a77", size = 13371961, upload-time = "2025-12-18T19:29:04.991Z" }, + { url = "https://files.pythonhosted.org/packages/40/31/a5906d60f0405f7e57045a70f2d57084a93ca7425f22e1d66904769d1628/ruff-0.14.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16a01dfb7b9e4eee556fbfd5392806b1b8550c9b4a9f6acd3dbe6812b193c70a", size = 13275629, upload-time = "2025-12-18T19:29:21.381Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/61c0087df21894cf9d928dc04bcd4fb10e8b2e8dca7b1a276ba2155b2002/ruff-0.14.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7165d31a925b7a294465fa81be8c12a0e9b60fb02bf177e79067c867e71f8b1f", size = 14029234, upload-time = "2025-12-18T19:29:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/44/84/77d911bee3b92348b6e5dab5a0c898d87084ea03ac5dc708f46d88407def/ruff-0.14.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:c561695675b972effb0c0a45db233f2c816ff3da8dcfbe7dfc7eed625f218935", size = 15449890, upload-time = "2025-12-18T19:28:53.573Z" }, + { url = "https://files.pythonhosted.org/packages/e9/36/480206eaefa24a7ec321582dda580443a8f0671fdbf6b1c80e9c3e93a16a/ruff-0.14.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bb98fcbbc61725968893682fd4df8966a34611239c9fd07a1f6a07e7103d08e", size = 15123172, upload-time = "2025-12-18T19:29:23.453Z" }, + { url = "https://files.pythonhosted.org/packages/5c/38/68e414156015ba80cef5473d57919d27dfb62ec804b96180bafdeaf0e090/ruff-0.14.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f24b47993a9d8cb858429e97bdf8544c78029f09b520af615c1d261bf827001d", size = 14460260, upload-time = "2025-12-18T19:29:27.808Z" }, + { url = "https://files.pythonhosted.org/packages/b3/19/9e050c0dca8aba824d67cc0db69fb459c28d8cd3f6855b1405b3f29cc91d/ruff-0.14.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:59aabd2e2c4fd614d2862e7939c34a532c04f1084476d6833dddef4afab87e9f", size = 14229978, upload-time = "2025-12-18T19:29:11.32Z" }, + { url = "https://files.pythonhosted.org/packages/51/eb/e8dd1dd6e05b9e695aa9dd420f4577debdd0f87a5ff2fedda33c09e9be8c/ruff-0.14.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:213db2b2e44be8625002dbea33bb9c60c66ea2c07c084a00d55732689d697a7f", size = 14338036, upload-time = "2025-12-18T19:29:09.184Z" }, + { url = "https://files.pythonhosted.org/packages/6a/12/f3e3a505db7c19303b70af370d137795fcfec136d670d5de5391e295c134/ruff-0.14.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:b914c40ab64865a17a9a5b67911d14df72346a634527240039eb3bd650e5979d", size = 13264051, upload-time = "2025-12-18T19:29:13.431Z" }, + { url = "https://files.pythonhosted.org/packages/08/64/8c3a47eaccfef8ac20e0484e68e0772013eb85802f8a9f7603ca751eb166/ruff-0.14.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1484983559f026788e3a5c07c81ef7d1e97c1c78ed03041a18f75df104c45405", size = 13283998, upload-time = "2025-12-18T19:29:06.994Z" }, + { url = "https://files.pythonhosted.org/packages/12/84/534a5506f4074e5cc0529e5cd96cfc01bb480e460c7edf5af70d2bcae55e/ruff-0.14.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c70427132db492d25f982fffc8d6c7535cc2fd2c83fc8888f05caaa248521e60", size = 13601891, upload-time = "2025-12-18T19:28:55.811Z" }, + { url = "https://files.pythonhosted.org/packages/0d/1e/14c916087d8598917dbad9b2921d340f7884824ad6e9c55de948a93b106d/ruff-0.14.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5bcf45b681e9f1ee6445d317ce1fa9d6cba9a6049542d1c3d5b5958986be8830", size = 14336660, upload-time = "2025-12-18T19:29:16.531Z" }, + { url = "https://files.pythonhosted.org/packages/f2/1c/d7b67ab43f30013b47c12b42d1acd354c195351a3f7a1d67f59e54227ede/ruff-0.14.10-py3-none-win32.whl", hash = "sha256:104c49fc7ab73f3f3a758039adea978869a918f31b73280db175b43a2d9b51d6", size = 13196187, upload-time = "2025-12-18T19:29:19.006Z" }, + { url = "https://files.pythonhosted.org/packages/fb/9c/896c862e13886fae2af961bef3e6312db9ebc6adc2b156fe95e615dee8c1/ruff-0.14.10-py3-none-win_amd64.whl", hash = "sha256:466297bd73638c6bdf06485683e812db1c00c7ac96d4ddd0294a338c62fdc154", size = 14661283, upload-time = "2025-12-18T19:29:30.16Z" }, + { url = "https://files.pythonhosted.org/packages/74/31/b0e29d572670dca3674eeee78e418f20bdf97fa8aa9ea71380885e175ca0/ruff-0.14.10-py3-none-win_arm64.whl", hash = "sha256:e51d046cf6dda98a4633b8a8a771451107413b0f07183b2bef03f075599e44e6", size = 13729839, upload-time = "2025-12-18T19:28:48.636Z" }, ] [[package]] @@ -4666,6 +5710,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" }, ] +[[package]] +name = "scanpy" +version = "1.11.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anndata" }, + { name = "h5py" }, + { name = "joblib" }, + { name = "legacy-api-wrap" }, + { name = "matplotlib" }, + { name = "natsort" }, + { name = "networkx" }, + { name = "numba" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "patsy" }, + { name = "pynndescent" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "seaborn" }, + { name = "session-info2" }, + { name = "statsmodels" }, + { name = "tqdm" }, + { name = "typing-extensions" }, + { name = "umap-learn" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/a8/285f1a9c995906b7e0ae3c399208fe67cfba8126dd31359dfef0908f6edc/scanpy-1.11.5.tar.gz", hash = "sha256:b2ef5476dfb1144b7dd0fae90b0198699c7988e6b27f083904150642c7ba6b89", size = 14088122, upload-time = "2025-10-21T08:24:43.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/e9/c1d43543da87cd27e8e2a74db85cf0b6c5cff2d5f04a86bd584d2fbc2bb0/scanpy-1.11.5-py3-none-any.whl", hash = "sha256:fcd383ddcf7acbf7c0ca232c25ad51b00aec9f8d2f7c8954b8c6ee0962257166", size = 2097836, upload-time = "2025-10-21T08:24:41.741Z" }, +] + +[[package]] +name = "scikit-image" +version = "0.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "imageio" }, + { name = "lazy-loader" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "scipy" }, + { name = "tifffile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/b4/2528bb43c67d48053a7a649a9666432dc307d66ba02e3a6d5c40f46655df/scikit_image-0.26.0.tar.gz", hash = "sha256:f5f970ab04efad85c24714321fcc91613fcb64ef2a892a13167df2f3e59199fa", size = 22729739, upload-time = "2025-12-20T17:12:21.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/e8/e13757982264b33a1621628f86b587e9a73a13f5256dad49b19ba7dc9083/scikit_image-0.26.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d454b93a6fa770ac5ae2d33570f8e7a321bb80d29511ce4b6b78058ebe176e8c", size = 12376452, upload-time = "2025-12-20T17:10:52.796Z" }, + { url = "https://files.pythonhosted.org/packages/e3/be/f8dd17d0510f9911f9f17ba301f7455328bf13dae416560126d428de9568/scikit_image-0.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3409e89d66eff5734cd2b672d1c48d2759360057e714e1d92a11df82c87cba37", size = 12061567, upload-time = "2025-12-20T17:10:55.207Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/c70120a6880579fb42b91567ad79feb4772f7be72e8d52fec403a3dde0c6/scikit_image-0.26.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c717490cec9e276afb0438dd165b7c3072d6c416709cc0f9f5a4c1070d23a44", size = 13084214, upload-time = "2025-12-20T17:10:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/f4/a2/70401a107d6d7466d64b466927e6b96fcefa99d57494b972608e2f8be50f/scikit_image-0.26.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7df650e79031634ac90b11e64a9eedaf5a5e06fcd09bcd03a34be01745744466", size = 13561683, upload-time = "2025-12-20T17:10:59.49Z" }, + { url = "https://files.pythonhosted.org/packages/13/a5/48bdfd92794c5002d664e0910a349d0a1504671ef5ad358150f21643c79a/scikit_image-0.26.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cefd85033e66d4ea35b525bb0937d7f42d4cdcfed2d1888e1570d5ce450d3932", size = 14112147, upload-time = "2025-12-20T17:11:02.083Z" }, + { url = "https://files.pythonhosted.org/packages/ee/b5/ac71694da92f5def5953ca99f18a10fe98eac2dd0a34079389b70b4d0394/scikit_image-0.26.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3f5bf622d7c0435884e1e141ebbe4b2804e16b2dd23ae4c6183e2ea99233be70", size = 14661625, upload-time = "2025-12-20T17:11:04.528Z" }, + { url = "https://files.pythonhosted.org/packages/23/4d/a3cc1e96f080e253dad2251bfae7587cf2b7912bcd76fd43fd366ff35a87/scikit_image-0.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:abed017474593cd3056ae0fe948d07d0747b27a085e92df5474f4955dd65aec0", size = 11911059, upload-time = "2025-12-20T17:11:06.61Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/d1b8055f584acc937478abf4550d122936f420352422a1a625eef2c605d8/scikit_image-0.26.0-cp312-cp312-win_arm64.whl", hash = "sha256:4d57e39ef67a95d26860c8caf9b14b8fb130f83b34c6656a77f191fa6d1d04d8", size = 11348740, upload-time = "2025-12-20T17:11:09.118Z" }, +] + [[package]] name = "scikit-learn" version = "1.8.0" @@ -4686,6 +5788,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/24/90/344a67811cfd561d7335c1b96ca21455e7e472d281c3c279c4d3f2300236/scikit_learn-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb", size = 7641898, upload-time = "2025-12-10T07:08:01.36Z" }, ] +[[package]] +name = "scikit-misc" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/71/d6d2d1710fb56473817b0520212d33874069952dcb417614f6dd24efb51e/scikit_misc-0.5.2.tar.gz", hash = "sha256:49fa30e4051b341edc7422db66a12c0f59d468729285bfe644d10924dc51be0a", size = 298626, upload-time = "2025-11-03T11:56:30.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/1daca03447aa3bb80e4ca604fac647fc9ce926d928102a2aab9a9426ef18/scikit_misc-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:36f33c33494bea53196e68ba165a03cc0af19d09f83585adb0dc469d62dff0b7", size = 162933, upload-time = "2025-11-03T11:56:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/59/48/5a486b3a9cff8cd8abc0bdc21a1a23f9c5b73962ef6e66a502b7636fad08/scikit_misc-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:efc64474adcec7fc373b13519db19682ae1e75fbed0da044efce1ae232a6bb01", size = 150855, upload-time = "2025-11-03T11:56:17.895Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7e/f003fd232ec3c3e29ae565e38536dbdef417c76f7c29a67203e05b800f44/scikit_misc-0.5.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd5a6e06864b07e9fe18c2bac756163e87f26615e5ddaa5f6129fd62535b7cfb", size = 182978, upload-time = "2025-11-03T11:56:19.104Z" }, + { url = "https://files.pythonhosted.org/packages/46/35/fe7a3074c1453b2b8cd259d1797fc5146d2383603f9ac838c92bc0bca148/scikit_misc-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:4e46fd2e8c46625d1e69ea7fa6f4544d73203387e2601f2bbce82ff0a086ada1", size = 150692, upload-time = "2025-11-03T11:56:20.286Z" }, +] + [[package]] name = "scipy" version = "1.16.3" @@ -4707,6 +5824,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" }, ] +[[package]] +name = "scrublet" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annoy" }, + { name = "cython" }, + { name = "matplotlib" }, + { name = "numba" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "scikit-image" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "umap-learn" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/f8/52cecc93d2ac7b7ffe53662b60c34b2ad7f97eed7360e3d264080f8b1608/scrublet-0.2.3.tar.gz", hash = "sha256:2185f63070290267f82a36e5b4cae8c321f10415d2d0c9f7e5e97b1126bf653a", size = 15331, upload-time = "2020-12-29T03:02:03.561Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/74/82308f7bdcbda730b772a6d1afb6f55b9706601032126c4359afb3fb8986/scrublet-0.2.3-py3-none-any.whl", hash = "sha256:92b8a0206fc710b397c8dd535ac75d26242dea0976d8aa632e3765438b60478a", size = 15491, upload-time = "2020-12-29T03:02:02.62Z" }, +] + [[package]] name = "seaborn" version = "0.13.2" @@ -4757,6 +5895,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" }, ] +[[package]] +name = "sentinels" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/9b/07195878aa25fe6ed209ec74bc55ae3e3d263b60a489c6e73fdca3c8fe05/sentinels-1.1.1.tar.gz", hash = "sha256:3c2f64f754187c19e0a1a029b148b74cf58dd12ec27b4e19c0e5d6e22b5a9a86", size = 4393, upload-time = "2025-08-12T07:57:50.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/65/dea992c6a97074f6d8ff9eab34741298cac2ce23e2b6c74fb7d08afdf85c/sentinels-1.1.1-py3-none-any.whl", hash = "sha256:835d3b28f3b47f5284afa4bf2db6e00f2dc5f80f9923d4b7e7aeeeccf6146a11", size = 3744, upload-time = "2025-08-12T07:57:48.858Z" }, +] + +[[package]] +name = "session-info" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "stdlib-list" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/dc/4a0c85aee2034be368d3ca293a563128122dde6db6e1bc9ca9ef3472c731/session_info-1.0.1.tar.gz", hash = "sha256:d71950d5a8ce7f7f7d5e86aa208c148c4e50b5440b77d5544d422b48e4f3ed41", size = 24663, upload-time = "2025-04-11T16:08:43.504Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/c4/f6b7c0ec5241a2bde90c7ba1eca6ba44f8488bcedafe9072c79593015ec0/session_info-1.0.1-py3-none-any.whl", hash = "sha256:451d191e51816070b9f21a6ff3f6eb5d6015ae2738e8db63ac4e6398260a5838", size = 9119, upload-time = "2025-04-11T16:08:42.612Z" }, +] + +[[package]] +name = "session-info2" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/4f/6333d79d97ccfea6d2199b7e666f8c53c5a31b64968c948a750a0b5c748a/session_info2-0.2.3.tar.gz", hash = "sha256:6d16e3c6bb72ea52e589da4d722d24798aa3511c34ab8446a131d655cba2e2c9", size = 23859, upload-time = "2025-10-09T12:51:28.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/b7/7d4c95c7b8525dabea23c548a1bb068d7a61635d544e8c92c51e784dad63/session_info2-0.2.3-py3-none-any.whl", hash = "sha256:f211d9930f73b485b727b6c4d8b964fa1b634351b3079393738f42be9b4c7f5e", size = 16347, upload-time = "2025-10-09T12:51:26.413Z" }, +] + [[package]] name = "setuptools" version = "80.9.0" @@ -4808,6 +5976,135 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ad/95/bc978be7ea0babf2fb48a414b6afaad414c6a9e8b1eafc5b8a53c030381a/smart_open-7.5.0-py3-none-any.whl", hash = "sha256:87e695c5148bbb988f15cec00971602765874163be85acb1c9fb8abc012e6599", size = 63940, upload-time = "2025-11-08T21:38:39.024Z" }, ] +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" }, +] + +[[package]] +name = "snakemake" +version = "9.14.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appdirs" }, + { name = "conda-inject" }, + { name = "configargparse" }, + { name = "connection-pool" }, + { name = "docutils" }, + { name = "dpath" }, + { name = "gitpython" }, + { name = "humanfriendly" }, + { name = "immutables" }, + { name = "jinja2" }, + { name = "jsonschema" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pulp" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "requests" }, + { name = "reretry" }, + { name = "smart-open" }, + { name = "snakemake-interface-common" }, + { name = "snakemake-interface-executor-plugins" }, + { name = "snakemake-interface-logger-plugins" }, + { name = "snakemake-interface-report-plugins" }, + { name = "snakemake-interface-scheduler-plugins" }, + { name = "snakemake-interface-storage-plugins" }, + { name = "tabulate" }, + { name = "throttler" }, + { name = "wrapt" }, + { name = "yte" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0c/28/b6ad097922b45a85f792bdf9b4f823ee6f37e72d80d471d0b13262309398/snakemake-9.14.5.tar.gz", hash = "sha256:f66b181806f02f9d7f43542bd85091a2e65ab126dfcb7bd869a622917d786bfb", size = 6745401, upload-time = "2025-12-15T13:55:25.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/a7/a13ec64b15cbd3dd0797847cb529e118e939d46968e80d0cdf7f5c638374/snakemake-9.14.5-py3-none-any.whl", hash = "sha256:a0f23d2250918553d283675051486f75c14f9fc33217a65810fefd52e292d390", size = 1132670, upload-time = "2025-12-15T13:55:23.721Z" }, +] + +[[package]] +name = "snakemake-interface-common" +version = "1.22.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argparse-dataclass" }, + { name = "configargparse" }, + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fd/be/cbd3f30c24eecb0e7d48f7025c770b7dc664124a01c8d9df6da73eb4fbd1/snakemake_interface_common-1.22.0.tar.gz", hash = "sha256:ef1fa710a15629be4cc352b938596ab5235ecf0b615c5845f086d6c5da10cb88", size = 13859, upload-time = "2025-09-30T17:11:00.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/c4/2da11760cebae7cfc66304ce5dccbabf9f1323e3e0ab8091960b84ad2bd6/snakemake_interface_common-1.22.0-py3-none-any.whl", hash = "sha256:a68c57cba8569536195fc9b7db07bc2a91b56ad811636585dae0313b2ca2e1ce", size = 16840, upload-time = "2025-09-30T17:10:59.594Z" }, +] + +[[package]] +name = "snakemake-interface-executor-plugins" +version = "9.3.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argparse-dataclass" }, + { name = "snakemake-interface-common" }, + { name = "throttler" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/51/e62e14090393d6688e7d4026a574f0a9de14ffb678bc4c6993306fc3e62a/snakemake_interface_executor_plugins-9.3.9.tar.gz", hash = "sha256:988ab388d48522fac84107867ae3f3398312b93b55df6ed7b99afc225468ca26", size = 16530, upload-time = "2025-07-29T15:34:21.993Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/8b/fec4419acedfa5924549f40664cb2134f2ea5fae3d8a39df5e24035df06a/snakemake_interface_executor_plugins-9.3.9-py3-none-any.whl", hash = "sha256:bae310d5e258d5504731cca69d73051cd5ae1702d46fa66c03ef947be27fe09a", size = 22511, upload-time = "2025-07-29T15:34:20.472Z" }, +] + +[[package]] +name = "snakemake-interface-logger-plugins" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "snakemake-interface-common" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/92/2fe4fa879a5d4408cad6db5330cd4ebd352e47529cb0fdfdf8ebf73f2920/snakemake_interface_logger_plugins-2.0.0.tar.gz", hash = "sha256:0e8ff2af4c55ca140d6ea1c1540e733a4b3944abae48fe0eaf6a707e5797cd17", size = 13767, upload-time = "2025-09-28T19:51:55.094Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/1f/f0848d750e7ca675e2cc0ea5e14135f432db498e8ad8cf746a19108e9d55/snakemake_interface_logger_plugins-2.0.0-py3-none-any.whl", hash = "sha256:c06a6779528a60f0362049c3adfb558e64d071769691718c810ef3057fdb9ff3", size = 12293, upload-time = "2025-09-28T19:51:53.556Z" }, +] + +[[package]] +name = "snakemake-interface-report-plugins" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "snakemake-interface-common" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/d6/6160ed98de665d6871dd356597dbf726688cc786e88668359ca37b7d9f54/snakemake_interface_report_plugins-1.3.0.tar.gz", hash = "sha256:fc9495298bec4e69721ab8afe6d6d88a86966fda2eeb003db56b9a88b86d5934", size = 4283, upload-time = "2025-10-31T10:52:36.55Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f0/f0/df73f6abc9b5910e43612ae28c7b6f666af80c4edd46a216ef47599ab6cb/snakemake_interface_report_plugins-1.3.0-py3-none-any.whl", hash = "sha256:78da3931f70e79eef51e5645a40b172929e555fe4d86ff45d6b856e521a379db", size = 7251, upload-time = "2025-10-31T10:52:35.474Z" }, +] + +[[package]] +name = "snakemake-interface-scheduler-plugins" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "snakemake-interface-common" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/88/d9/d480807d2cfc2d132bc760d877d45ec8fbe620a24200ec4d2697c4a26031/snakemake_interface_scheduler_plugins-2.0.2.tar.gz", hash = "sha256:2797e8fa9019d983132c2b403f14d6fcd3c5ad4c8d8a66b984b4740a71cacc46", size = 8642, upload-time = "2025-10-20T13:58:12.988Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/d0/f4e9894c8aaf37efe3bf1afe15ee3cf0546d82b2713a589e266ee47bf2ef/snakemake_interface_scheduler_plugins-2.0.2-py3-none-any.whl", hash = "sha256:b9ddfa508bd480711de1770dfb24f3b813cfa3cd0f862f0127ef721ae5346915", size = 10766, upload-time = "2025-10-20T13:58:11.898Z" }, +] + +[[package]] +name = "snakemake-interface-storage-plugins" +version = "4.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "reretry" }, + { name = "snakemake-interface-common" }, + { name = "throttler" }, + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d4/0c/906d09e4e99733b605a5b24b03fcdbe40c47787c770aea42421f225f9171/snakemake_interface_storage_plugins-4.3.2.tar.gz", hash = "sha256:2f45c6b784e2af5b6e7102d3cb700d597b7cf7515fcf02d7d1153065e90a7895", size = 14543, upload-time = "2025-12-01T13:30:30.754Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/7e/51e4d50494725c77116fc3978879babe1a15336d9b144bba061ec968e02a/snakemake_interface_storage_plugins-4.3.2-py3-none-any.whl", hash = "sha256:bd185233cb7882a58d79294ad2f8d1cead535744fe3c9d42d9ef51bc8f1744b1", size = 17800, upload-time = "2025-12-01T13:30:29.699Z" }, +] + [[package]] name = "sniffio" version = "1.3.1" @@ -4837,11 +6134,11 @@ wheels = [ [[package]] name = "soupsieve" -version = "2.8" +version = "2.8.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +sdist = { url = "https://files.pythonhosted.org/packages/89/23/adf3796d740536d63a6fbda113d07e60c734b6ed5d3058d1e47fc0495e47/soupsieve-2.8.1.tar.gz", hash = "sha256:4cf733bc50fa805f5df4b8ef4740fc0e0fa6218cf3006269afd3f9d6d80fd350", size = 117856, upload-time = "2025-12-18T13:50:34.655Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, + { url = "https://files.pythonhosted.org/packages/48/f3/b67d6ea49ca9154453b6d70b34ea22f3996b9fa55da105a79d8732227adc/soupsieve-2.8.1-py3-none-any.whl", hash = "sha256:a11fe2a6f3d76ab3cf2de04eb339c1be5b506a8a47f2ceb6d139803177f85434", size = 36710, upload-time = "2025-12-18T13:50:33.267Z" }, ] [[package]] @@ -5038,6 +6335,11 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/bf/e1/3ccb13c643399d22289c6a9786c1a91e3dcbb68bce4beb44926ac2c557bf/sqlalchemy-2.0.45-py3-none-any.whl", hash = "sha256:5225a288e4c8cc2308dbdd874edad6e7d0fd38eac1e9e5f23503425c8eee20d0", size = 1936672, upload-time = "2025-12-09T21:54:52.608Z" }, ] +[package.optional-dependencies] +asyncio = [ + { name = "greenlet" }, +] + [[package]] name = "sqlalchemy-utils" version = "0.38.3" @@ -5150,6 +6452,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/60/15/3daba2df40be8b8a9a027d7f54c8dedf24f0d81b96e54b52293f5f7e3418/statsmodels-0.14.6-cp312-cp312-win_amd64.whl", hash = "sha256:b5eb07acd115aa6208b4058211138393a7e6c2cf12b6f213ede10f658f6a714f", size = 9543991, upload-time = "2025-12-05T23:10:58.536Z" }, ] +[[package]] +name = "stdlib-list" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/25/f1540879c8815387980e56f973e54605bd924612399ace31487f7444171c/stdlib_list-0.12.0.tar.gz", hash = "sha256:517824f27ee89e591d8ae7c1dd9ff34f672eae50ee886ea31bb8816d77535675", size = 60923, upload-time = "2025-10-24T19:21:22.849Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/3d/2970b27a11ae17fb2d353e7a179763a2fe6f37d6d2a9f4d40104a2f132e9/stdlib_list-0.12.0-py3-none-any.whl", hash = "sha256:df2d11e97f53812a1756fb5510393a11e3b389ebd9239dc831c7f349957f62f2", size = 87615, upload-time = "2025-10-24T19:21:20.619Z" }, +] + [[package]] name = "sympy" version = "1.14.0" @@ -5162,6 +6473,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, ] +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" }, +] + [[package]] name = "templateflow" version = "25.1.1" @@ -5201,6 +6521,24 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, ] +[[package]] +name = "text-unidecode" +version = "1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ab/e2/e9a00f0ccb71718418230718b3d900e71a5d16e701a3dae079a21e9cd8f8/text-unidecode-1.3.tar.gz", hash = "sha256:bad6603bb14d279193107714b288be206cac565dfa49aa5b105294dd5c4aab93", size = 76885, upload-time = "2019-08-30T21:36:45.405Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a6/a5/c0b6468d3824fe3fde30dbb5e1f687b291608f9473681bbf7dabbf5a87d7/text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8", size = 78154, upload-time = "2019-08-30T21:37:03.543Z" }, +] + +[[package]] +name = "texttable" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/dc/0aff23d6036a4d3bf4f1d8c8204c5c79c4437e25e0ae94ffe4bbb55ee3c2/texttable-1.7.0.tar.gz", hash = "sha256:2d2068fb55115807d3ac77a4ca68fa48803e84ebb0ee2340f858107a36522638", size = 12831, upload-time = "2023-10-03T09:48:12.272Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/99/4772b8e00a136f3e01236de33b0efda31ee7077203ba5967fcc76da94d65/texttable-1.7.0-py2.py3-none-any.whl", hash = "sha256:72227d592c82b3d7f672731ae73e4d1f88cd8e2ef5b075a7a7f01a23a3743917", size = 10768, upload-time = "2023-10-03T09:48:10.434Z" }, +] + [[package]] name = "thinc" version = "8.3.10" @@ -5240,6 +6578,27 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, ] +[[package]] +name = "throttler" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/22/638451122136d5280bc477c8075ea448b9ebdfbd319f0f120edaecea2038/throttler-1.2.2.tar.gz", hash = "sha256:d54db406d98e1b54d18a9ba2b31ab9f093ac64a0a59d730c1cf7bb1cdfc94a58", size = 7970, upload-time = "2022-11-22T19:08:57.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/d4/36bf6010b184286000b2334622bfb3446a40c22c1d2a9776bff025cb0fe5/throttler-1.2.2-py3-none-any.whl", hash = "sha256:fc6ae612a2529e01110b32335af40375258b98e3b81232ec77cd07f51bf71392", size = 7609, upload-time = "2022-11-22T19:08:55.699Z" }, +] + +[[package]] +name = "tifffile" +version = "2025.12.20" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/a6/85e8ecfd7cb4167f8bd17136b2d42cba296fbc08a247bba70d5747e2046a/tifffile-2025.12.20.tar.gz", hash = "sha256:cb8a4fee327d15b3e3eeac80bbdd8a53b323c80473330bcfb99418ee4c1c827f", size = 373364, upload-time = "2025-12-21T06:23:54.241Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/fe/e59859aa1134fac065d36864752daf13215c98b379cb5d93f954dc0ec830/tifffile-2025.12.20-py3-none-any.whl", hash = "sha256:bc0345a20675149353cfcb3f1c48d0a3654231ee26bd46beebaab4d2168feeb6", size = 232031, upload-time = "2025-12-21T06:23:53.003Z" }, +] + [[package]] name = "tinycss2" version = "1.4.0" @@ -5277,6 +6636,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/46/e33a8c93907b631a99377ef4c5f817ab453d0b34f93529421f42ff559671/tokenizers-0.22.1-cp39-abi3-win_amd64.whl", hash = "sha256:65fd6e3fb11ca1e78a6a93602490f134d1fdeb13bcef99389d5102ea318ed138", size = 2674684, upload-time = "2025-09-19T09:49:24.953Z" }, ] +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + [[package]] name = "tomli" version = "2.3.0" @@ -5294,6 +6662,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" }, ] +[[package]] +name = "toolz" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/d6/114b492226588d6ff54579d95847662fc69196bdeec318eb45393b24c192/toolz-1.1.0.tar.gz", hash = "sha256:27a5c770d068c110d9ed9323f24f1543e83b2f300a687b7891c1a6d56b697b5b", size = 52613, upload-time = "2025-10-17T04:03:21.661Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl", hash = "sha256:15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8", size = 58093, upload-time = "2025-10-17T04:03:20.435Z" }, +] + [[package]] name = "torch" version = "2.9.1" @@ -5332,21 +6709,21 @@ wheels = [ [[package]] name = "tornado" -version = "6.5.3" +version = "6.5.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7f/2e/3d22d478f27cb4b41edd4db7f10cd7846d0a28ea443342de3dba97035166/tornado-6.5.3.tar.gz", hash = "sha256:16abdeb0211796ffc73765bc0a20119712d68afeeaf93d1a3f2edf6b3aee8d5a", size = 513348, upload-time = "2025-12-11T04:16:42.225Z" } +sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d3/e9/bf22f66e1d5d112c0617974b5ce86666683b32c09b355dfcd59f8d5c8ef6/tornado-6.5.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2dd7d7e8d3e4635447a8afd4987951e3d4e8d1fb9ad1908c54c4002aabab0520", size = 443860, upload-time = "2025-12-11T04:16:26.638Z" }, - { url = "https://files.pythonhosted.org/packages/ca/9c/594b631f0b8dc5977080c7093d1e96f1377c10552577d2c31bb0208c9362/tornado-6.5.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:5977a396f83496657779f59a48c38096ef01edfe4f42f1c0634b791dde8165d0", size = 442118, upload-time = "2025-12-11T04:16:28.32Z" }, - { url = "https://files.pythonhosted.org/packages/78/f6/685b869f5b5b9d9547571be838c6106172082751696355b60fc32a4988ed/tornado-6.5.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f72ac800be2ac73ddc1504f7aa21069a4137e8d70c387172c063d363d04f2208", size = 445700, upload-time = "2025-12-11T04:16:29.64Z" }, - { url = "https://files.pythonhosted.org/packages/91/4c/f0d19edf24912b7f21ae5e941f7798d132ad4d9b71441c1e70917a297265/tornado-6.5.3-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c43c4fc4f5419c6561cfb8b884a8f6db7b142787d47821e1a0e1296253458265", size = 445041, upload-time = "2025-12-11T04:16:30.799Z" }, - { url = "https://files.pythonhosted.org/packages/eb/2b/e02da94f4a4aef2bb3b923c838ef284a77548a5f06bac2a8682b36b4eead/tornado-6.5.3-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de8b3fed4b3afb65d542d7702ac8767b567e240f6a43020be8eaef59328f117b", size = 445270, upload-time = "2025-12-11T04:16:32.316Z" }, - { url = "https://files.pythonhosted.org/packages/58/e2/7a7535d23133443552719dba526dacbb7415f980157da9f14950ddb88ad6/tornado-6.5.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dbc4b4c32245b952566e17a20d5c1648fbed0e16aec3fc7e19f3974b36e0e47c", size = 445957, upload-time = "2025-12-11T04:16:33.913Z" }, - { url = "https://files.pythonhosted.org/packages/a0/1f/9ff92eca81ff17a86286ec440dcd5eab0400326eb81761aa9a4eecb1ffb9/tornado-6.5.3-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:db238e8a174b4bfd0d0238b8cfcff1c14aebb4e2fcdafbf0ea5da3b81caceb4c", size = 445371, upload-time = "2025-12-11T04:16:35.093Z" }, - { url = "https://files.pythonhosted.org/packages/70/b1/1d03ae4526a393b0b839472a844397337f03c7f3a1e6b5c82241f0e18281/tornado-6.5.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:892595c100cd9b53a768cbfc109dfc55dec884afe2de5290611a566078d9692d", size = 445348, upload-time = "2025-12-11T04:16:36.679Z" }, - { url = "https://files.pythonhosted.org/packages/4b/7d/7c181feadc8941f418d0d26c3790ee34ffa4bd0a294bc5201d44ebd19c1e/tornado-6.5.3-cp39-abi3-win32.whl", hash = "sha256:88141456525fe291e47bbe1ba3ffb7982549329f09b4299a56813923af2bd197", size = 446433, upload-time = "2025-12-11T04:16:38.332Z" }, - { url = "https://files.pythonhosted.org/packages/34/98/4f7f938606e21d0baea8c6c39a7c8e95bdf8e50b0595b1bb6f0de2af7a6e/tornado-6.5.3-cp39-abi3-win_amd64.whl", hash = "sha256:ba4b513d221cc7f795a532c1e296f36bcf6a60e54b15efd3f092889458c69af1", size = 446842, upload-time = "2025-12-11T04:16:39.867Z" }, - { url = "https://files.pythonhosted.org/packages/7a/27/0e3fca4c4edf33fb6ee079e784c63961cd816971a45e5e4cacebe794158d/tornado-6.5.3-cp39-abi3-win_arm64.whl", hash = "sha256:278c54d262911365075dd45e0b6314308c74badd6ff9a54490e7daccdd5ed0ea", size = 445863, upload-time = "2025-12-11T04:16:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" }, + { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" }, + { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" }, + { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" }, + { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" }, + { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" }, + { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" }, + { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" }, + { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" }, ] [[package]] @@ -5401,7 +6778,7 @@ wheels = [ [[package]] name = "typer" -version = "0.20.0" +version = "0.15.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -5409,22 +6786,22 @@ dependencies = [ { name = "shellingham" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8f/28/7c85c8032b91dbe79725b6f17d2fffc595dff06a35c7a30a37bef73a1ab4/typer-0.20.0.tar.gz", hash = "sha256:1aaf6494031793e4876fb0bacfa6a912b551cf43c1e63c800df8b1a866720c37", size = 106492, upload-time = "2025-10-20T17:03:49.445Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/89/c527e6c848739be8ceb5c44eb8208c52ea3515c6cf6406aa61932887bf58/typer-0.15.4.tar.gz", hash = "sha256:89507b104f9b6a0730354f27c39fae5b63ccd0c95b1ce1f1a6ba0cfd329997c3", size = 101559, upload-time = "2025-05-14T16:34:57.704Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/64/7713ffe4b5983314e9d436a90d5bd4f63b6054e2aca783a3cfc44cb95bbf/typer-0.20.0-py3-none-any.whl", hash = "sha256:5b463df6793ec1dca6213a3cf4c0f03bc6e322ac5e16e13ddd622a889489784a", size = 47028, upload-time = "2025-10-20T17:03:47.617Z" }, + { url = "https://files.pythonhosted.org/packages/c9/62/d4ba7afe2096d5659ec3db8b15d8665bdcb92a3c6ff0b95e99895b335a9c/typer-0.15.4-py3-none-any.whl", hash = "sha256:eb0651654dcdea706780c466cf06d8f174405a659ffff8f163cfbfee98c0e173", size = 45258, upload-time = "2025-05-14T16:34:55.583Z" }, ] [[package]] name = "typer-slim" -version = "0.20.0" +version = "0.20.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8e/45/81b94a52caed434b94da65729c03ad0fb7665fab0f7db9ee54c94e541403/typer_slim-0.20.0.tar.gz", hash = "sha256:9fc6607b3c6c20f5c33ea9590cbeb17848667c51feee27d9e314a579ab07d1a3", size = 106561, upload-time = "2025-10-20T17:03:46.642Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/3d/6a4ec47010e8de34dade20c8e7bce90502b173f62a6b41619523a3fcf562/typer_slim-0.20.1.tar.gz", hash = "sha256:bb9e4f7e6dc31551c8a201383df322b81b0ce37239a5ead302598a2ebb6f7c9c", size = 106113, upload-time = "2025-12-19T16:48:54.206Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5e/dd/5cbf31f402f1cc0ab087c94d4669cfa55bd1e818688b910631e131d74e75/typer_slim-0.20.0-py3-none-any.whl", hash = "sha256:f42a9b7571a12b97dddf364745d29f12221865acef7a2680065f9bb29c7dc89d", size = 47087, upload-time = "2025-10-20T17:03:44.546Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f9/a273c8b57c69ac1b90509ebda204972265fdc978fbbecc25980786f8c038/typer_slim-0.20.1-py3-none-any.whl", hash = "sha256:8e89c5dbaffe87a4f86f4c7a9e2f7059b5b68c66f558f298969d42ce34f10122", size = 47440, upload-time = "2025-12-19T16:48:52.678Z" }, ] [[package]] @@ -5450,11 +6827,11 @@ wheels = [ [[package]] name = "tzdata" -version = "2025.2" +version = "2025.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" }, ] [[package]] @@ -5469,6 +6846,42 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" }, ] +[[package]] +name = "ujson" +version = "5.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/d9/3f17e3c5773fb4941c68d9a37a47b1a79c9649d6c56aefbed87cc409d18a/ujson-5.11.0.tar.gz", hash = "sha256:e204ae6f909f099ba6b6b942131cee359ddda2b6e4ea39c12eb8b991fe2010e0", size = 7156583, upload-time = "2025-08-20T11:57:02.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/ef/a9cb1fce38f699123ff012161599fb9f2ff3f8d482b4b18c43a2dc35073f/ujson-5.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7895f0d2d53bd6aea11743bd56e3cb82d729980636cd0ed9b89418bf66591702", size = 55434, upload-time = "2025-08-20T11:55:34.987Z" }, + { url = "https://files.pythonhosted.org/packages/b1/05/dba51a00eb30bd947791b173766cbed3492269c150a7771d2750000c965f/ujson-5.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12b5e7e22a1fe01058000d1b317d3b65cc3daf61bd2ea7a2b76721fe160fa74d", size = 53190, upload-time = "2025-08-20T11:55:36.384Z" }, + { url = "https://files.pythonhosted.org/packages/03/3c/fd11a224f73fbffa299fb9644e425f38b38b30231f7923a088dd513aabb4/ujson-5.11.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0180a480a7d099082501cad1fe85252e4d4bf926b40960fb3d9e87a3a6fbbc80", size = 57600, upload-time = "2025-08-20T11:55:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/55/b9/405103cae24899df688a3431c776e00528bd4799e7d68820e7ebcf824f92/ujson-5.11.0-cp312-cp312-manylinux_2_24_i686.manylinux_2_28_i686.whl", hash = "sha256:fa79fdb47701942c2132a9dd2297a1a85941d966d8c87bfd9e29b0cf423f26cc", size = 59791, upload-time = "2025-08-20T11:55:38.877Z" }, + { url = "https://files.pythonhosted.org/packages/17/7b/2dcbc2bbfdbf68f2368fb21ab0f6735e872290bb604c75f6e06b81edcb3f/ujson-5.11.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8254e858437c00f17cb72e7a644fc42dad0ebb21ea981b71df6e84b1072aaa7c", size = 57356, upload-time = "2025-08-20T11:55:40.036Z" }, + { url = "https://files.pythonhosted.org/packages/d1/71/fea2ca18986a366c750767b694430d5ded6b20b6985fddca72f74af38a4c/ujson-5.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1aa8a2ab482f09f6c10fba37112af5f957689a79ea598399c85009f2f29898b5", size = 1036313, upload-time = "2025-08-20T11:55:41.408Z" }, + { url = "https://files.pythonhosted.org/packages/a3/bb/d4220bd7532eac6288d8115db51710fa2d7d271250797b0bfba9f1e755af/ujson-5.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a638425d3c6eed0318df663df44480f4a40dc87cc7c6da44d221418312f6413b", size = 1195782, upload-time = "2025-08-20T11:55:43.357Z" }, + { url = "https://files.pythonhosted.org/packages/80/47/226e540aa38878ce1194454385701d82df538ccb5ff8db2cf1641dde849a/ujson-5.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7e3cff632c1d78023b15f7e3a81c3745cd3f94c044d1e8fa8efbd6b161997bbc", size = 1088817, upload-time = "2025-08-20T11:55:45.262Z" }, + { url = "https://files.pythonhosted.org/packages/7e/81/546042f0b23c9040d61d46ea5ca76f0cc5e0d399180ddfb2ae976ebff5b5/ujson-5.11.0-cp312-cp312-win32.whl", hash = "sha256:be6b0eaf92cae8cdee4d4c9e074bde43ef1c590ed5ba037ea26c9632fb479c88", size = 39757, upload-time = "2025-08-20T11:55:46.522Z" }, + { url = "https://files.pythonhosted.org/packages/44/1b/27c05dc8c9728f44875d74b5bfa948ce91f6c33349232619279f35c6e817/ujson-5.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:b7b136cc6abc7619124fd897ef75f8e63105298b5ca9bdf43ebd0e1fa0ee105f", size = 43859, upload-time = "2025-08-20T11:55:47.987Z" }, + { url = "https://files.pythonhosted.org/packages/22/2d/37b6557c97c3409c202c838aa9c960ca3896843b4295c4b7bb2bbd260664/ujson-5.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:6cd2df62f24c506a0ba322d5e4fe4466d47a9467b57e881ee15a31f7ecf68ff6", size = 38361, upload-time = "2025-08-20T11:55:49.122Z" }, +] + +[[package]] +name = "umap-learn" +version = "0.5.9.post2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numba" }, + { name = "numpy" }, + { name = "pynndescent" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5f/ee/6bc65bd375c812026a7af63fe9d09d409382120aff25f2152f1ba12af5ec/umap_learn-0.5.9.post2.tar.gz", hash = "sha256:bdf60462d779bd074ce177a0714ced17e6d161285590fa487f3f9548dd3c31c9", size = 95441, upload-time = "2025-07-03T00:18:02.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/b1/c24deeda9baf1fd491aaad941ed89e0fed6c583a117fd7b79e0a33a1e6c0/umap_learn-0.5.9.post2-py3-none-any.whl", hash = "sha256:fbe51166561e0e7fab00ef3d516ac2621243b8d15cf4bef9f656d701736b16a0", size = 90146, upload-time = "2025-07-03T00:18:01.042Z" }, +] + [[package]] name = "universal-pathlib" version = "0.3.7" @@ -5514,15 +6927,15 @@ wheels = [ [[package]] name = "uvicorn" -version = "0.38.0" +version = "0.40.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" }, ] [package.optional-dependencies] @@ -5731,6 +7144,64 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" }, ] +[[package]] +name = "xarray" +version = "2025.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d3/af/7b945f331ba8911fdfff2fdfa092763156119f124be1ba4144615c540222/xarray-2025.12.0.tar.gz", hash = "sha256:73f6a6fadccc69c4d45bdd70821a47c72de078a8a0313ff8b1e97cd54ac59fed", size = 3082244, upload-time = "2025-12-05T21:51:22.432Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/e4/62a677feefde05b12a70a4fc9bdc8558010182a801fbcab68cb56c2b0986/xarray-2025.12.0-py3-none-any.whl", hash = "sha256:9e77e820474dbbe4c6c2954d0da6342aa484e33adaa96ab916b15a786181e970", size = 1381742, upload-time = "2025-12-05T21:51:20.841Z" }, +] + +[[package]] +name = "yarl" +version = "1.22.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" }, + { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" }, + { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" }, + { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" }, + { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" }, + { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" }, + { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" }, + { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" }, + { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" }, + { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" }, + { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" }, + { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" }, + { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" }, +] + +[[package]] +name = "yte" +version = "1.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argparse-dataclass" }, + { name = "dpath" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/44/f5/7e44620e6e077bfe624b9a17c329b8e0d0159e176e1f1a93c2790428ab2c/yte-1.9.4.tar.gz", hash = "sha256:86a47e6d722cec9419a7ac88be57d0d6c4ce28f02860393b71a66f2c674069f6", size = 8101, upload-time = "2025-11-27T12:55:00.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/63/6a44729fdc60eb255a7b156a84e7552290174a9bf151e3b6c18e83d6fbfa/yte-1.9.4-py3-none-any.whl", hash = "sha256:5dac63303d3e6bc2ebadc36ece3c3fb09343772fe6e25e9356d9baf8f9dfaf6d", size = 10618, upload-time = "2025-11-27T12:55:01.685Z" }, +] + [[package]] name = "zarr" version = "3.1.5"